diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
new file mode 100644
index 0000000000000..8e1bbfe88c1e3
--- /dev/null
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,50 @@
+// For format details, see https://aka.ms/devcontainer.json.
+{
+  "name": "Homebrew/brew",
+  "image": "ghcr.io/homebrew/brew:latest",
+
+  "workspaceFolder": "/home/linuxbrew/.linuxbrew/Homebrew",
+  "workspaceMount": "source=${localWorkspaceFolder},target=/home/linuxbrew/.linuxbrew/Homebrew,type=bind,consistency=cached",
+
+  "onCreateCommand": ".devcontainer/on-create-command.sh",
+
+  "customizations": {
+    "codespaces": {
+      "repositories": {
+        "Homebrew/homebrew-bundle": {
+          "permissions": {
+            "contents": "write"
+          }
+        },
+        "Homebrew/homebrew-services": {
+          "permissions": {
+            "contents": "write"
+          }
+        }
+      }
+    },
+    "vscode": {
+      // Installing all necessary extensions for vscode
+      // Taken from: .vscode/extensions.json
+      "extensions": [
+        "Shopify.ruby-lsp",
+        "sorbet.sorbet-vscode-extension",
+        "github.vscode-github-actions",
+        "anykeyh.simplecov-vscode",
+        "ms-azuretools.vscode-docker",
+        "github.vscode-pull-request-github",
+        "davidanson.vscode-markdownlint",
+        "foxundermoon.shell-format",
+        "timonwong.shellcheck",
+        "ban.spellright",
+        "redhat.vscode-yaml",
+        "koichisasada.vscode-rdbg",
+        "editorconfig.editorconfig"
+      ]
+    }
+  },
+
+  "remoteEnv": {
+    "HOMEBREW_GITHUB_API_TOKEN": "${localEnv:GITHUB_TOKEN}"
+  }
+}
diff --git a/.devcontainer/on-create-command.sh b/.devcontainer/on-create-command.sh
new file mode 100755
index 0000000000000..7762064c888a6
--- /dev/null
+++ b/.devcontainer/on-create-command.sh
@@ -0,0 +1,45 @@
+#!/bin/bash
+set -e
+
+# fix permissions so Homebrew and Bundler don't complain
+sudo chmod -R g-w,o-w /home/linuxbrew
+
+# everything below is too slow to do unless prebuilding so skip it
+CODESPACES_ACTION_NAME="$(jq --raw-output '.ACTION_NAME' /workspaces/.codespaces/shared/environment-variables.json)"
+if [[ "${CODESPACES_ACTION_NAME}" != "createPrebuildTemplate" ]]
+then
+  echo "Skipping slow items, not prebuilding."
+  exit 0
+fi
+
+# install Homebrew's development gems
+brew install-bundler-gems --groups=all
+
+# install Homebrew formulae we might need
+brew install shellcheck shfmt gh gnu-tar
+
+# cleanup any mess
+brew cleanup
+
+# actually tap homebrew/core, no longer done by default
+brew tap --force homebrew/core
+# tap some other repos so codespaces can be used for developing multiple taps
+brew tap homebrew/bundle
+brew tap homebrew/services
+
+# install some useful development things
+sudo apt-get update
+
+apt_get_install() {
+  sudo apt-get install -y \
+    -o Dpkg::Options::=--force-confdef \
+    -o Dpkg::Options::=--force-confnew \
+    "$@"
+}
+
+apt_get_install \
+  openssh-server \
+  zsh
+
+# Start the SSH server so that `gh cs ssh` works.
+sudo service ssh start
diff --git a/.editorconfig b/.editorconfig
index 3c1a0b9a9f3b7..a3f724a3659a0 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -16,11 +16,6 @@ trim_trailing_whitespace = true
 # trailing whitespace is crucial for patches
 trim_trailing_whitespace = false
 
-[**.drawio.svg]
-indent_size = unset
-indent_style = unset
-insert_final_newline = false
-
 [**.md]
 trim_trailing_whitespace = true
 x-soft-wrap-text = true
diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
index 09af8ebef84d7..ff2c5e3577385 100644
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -1 +1 @@
-# Please fill out one of the templates on: https://github.com/Homebrew/brew/issues/new/choose or we will close it without comment.
+Please fill out one of the templates on https://github.com/Homebrew/brew/issues/new/choose or we will close your issue without comment.
diff --git a/.github/ISSUE_TEMPLATE/bug.yml b/.github/ISSUE_TEMPLATE/bug.yml
index 0403b6327dbb8..20f8839f1c95d 100644
--- a/.github/ISSUE_TEMPLATE/bug.yml
+++ b/.github/ISSUE_TEMPLATE/bug.yml
@@ -4,13 +4,7 @@ labels: [bug]
 body:
   - type: markdown
     attributes:
-      value: Please note we will close your issue without comment if you do not fill out the issue checklist below and provide ALL the requested information. If you repeatedly fail to use the issue template, we will block you from ever submitting issues to Homebrew again.
-  - type: textarea
-    attributes:
-      render: shell
-      label: "`brew config` output"
-    validations:
-      required: true
+      value: Please note we will close your issue without comment if you do not correctly fill out the issue checklist below and provide ALL the requested information. If you repeatedly fail to use the issue template, we will block you from ever submitting issues to Homebrew again.
   - type: textarea
     attributes:
       render: shell
@@ -20,12 +14,20 @@ body:
   - type: checkboxes
     attributes:
       label: Verification
-      description: Please verify that you've followed these steps.
+      description: Please verify that you've followed these steps. If you cannot truthfully check these boxes, open a discussion at https://github.com/orgs/Homebrew/discussions instead.
       options:
-        - label: I ran `brew update` and am still able to reproduce my issue.
+        - label: My "`brew doctor` output" above says `Your system is ready to brew.` and am still able to reproduce my issue.
+          required: true
+        - label: I ran `brew update` twice and am still able to reproduce my issue.
           required: true
-        - label: I have resolved all warnings from `brew doctor` and that did not fix my problem.
+        - label: This issue's title and/or description do not reference a single formula e.g. `brew install wget`. If they do, open an issue at https://github.com/Homebrew/homebrew-core/issues/new/choose instead.
           required: true
+  - type: textarea
+    attributes:
+      render: shell
+      label: "`brew config` output"
+    validations:
+      required: true
   - type: textarea
     attributes:
       label: What were you trying to do (and why)?
diff --git a/.github/ISSUE_TEMPLATE/feature.yml b/.github/ISSUE_TEMPLATE/feature.yml
index a74a79d4e5465..b96a27f18b7f5 100644
--- a/.github/ISSUE_TEMPLATE/feature.yml
+++ b/.github/ISSUE_TEMPLATE/feature.yml
@@ -5,6 +5,13 @@ body:
   - type: markdown
     attributes:
       value: Please note we will close your issue without comment if you do not fill out the issue checklist below and provide ALL the requested information. If you repeatedly fail to use the issue template, we will block you from ever submitting issues to Homebrew again.
+  - type: checkboxes
+    attributes:
+      label: Verification
+      description: Please verify that you've followed these steps.
+      options:
+        - label: This issue's title and/or description do not reference a single formula e.g. `brew install wget`. If they do, open an issue at https://github.com/Homebrew/homebrew-core/issues/new/choose instead.
+          required: true
   - type: textarea
     attributes:
       label: Provide a detailed description of the proposed feature
diff --git a/.github/actionlint-matcher.json b/.github/actionlint-matcher.json
new file mode 100644
index 0000000000000..4613e1617bfe2
--- /dev/null
+++ b/.github/actionlint-matcher.json
@@ -0,0 +1,17 @@
+{
+  "problemMatcher": [
+    {
+      "owner": "actionlint",
+      "pattern": [
+        {
+          "regexp": "^(?:\\x1b\\[\\d+m)?(.+?)(?:\\x1b\\[\\d+m)*:(?:\\x1b\\[\\d+m)*(\\d+)(?:\\x1b\\[\\d+m)*:(?:\\x1b\\[\\d+m)*(\\d+)(?:\\x1b\\[\\d+m)*: (?:\\x1b\\[\\d+m)*(.+?)(?:\\x1b\\[\\d+m)* \\[(.+?)\\]$",
+          "file": 1,
+          "line": 2,
+          "column": 3,
+          "message": 4,
+          "code": 5
+        }
+      ]
+    }
+  ]
+}
diff --git a/.github/actionlint.yaml b/.github/actionlint.yaml
new file mode 100644
index 0000000000000..97ba215778c25
--- /dev/null
+++ b/.github/actionlint.yaml
@@ -0,0 +1,8 @@
+self-hosted-runner:
+  # Labels of self-hosted runner in array of strings.
+  labels: []
+# Configuration variables in array of strings defined in your repository or
+# organization. `null` means disabling configuration variables check.
+# Empty array means no configuration variable is allowed.
+config-variables:
+  - BREW_COMMIT_APP_ID
diff --git a/.github/codecov.yml b/.github/codecov.yml
index 65b70e6ea521b..fa828ea69cbd6 100644
--- a/.github/codecov.yml
+++ b/.github/codecov.yml
@@ -3,6 +3,7 @@ coverage:
   status:
     project:
       default:
+        informational: true
         threshold: 0.05%
     patch:
       default:
diff --git a/.github/codeql/codeql-config.yml b/.github/codeql/codeql-config.yml
deleted file mode 100644
index af5879d427096..0000000000000
--- a/.github/codeql/codeql-config.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-paths-ignore:
-  - Library/Homebrew/vendor/
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 4058b3e79f60c..46a3a696938e4 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -5,10 +5,16 @@ updates:
     directory: /
     schedule:
       interval: daily
+    allow:
+      - dependency-type: all
     # The actions in triage-issues.yml are updated in the Homebrew/.github repo
     ignore:
       - dependency-name: actions/stale
       - dependency-name: dessant/lock-threads
+    groups:
+      artifacts:
+        patterns:
+          - actions/*-artifact
 
   - package-ecosystem: bundler
     directory: /Library/Homebrew
@@ -16,4 +22,31 @@ updates:
       interval: daily
     allow:
       - dependency-type: all
-    versioning-strategy: lockfile-only
+
+  - package-ecosystem: npm
+    directory: /
+    schedule:
+      interval: daily
+    allow:
+      - dependency-type: all
+
+  - package-ecosystem: docker
+    directory: /
+    schedule:
+      interval: daily
+    allow:
+      - dependency-type: all
+
+  - package-ecosystem: devcontainers
+    directory: /
+    schedule:
+      interval: daily
+    allow:
+      - dependency-type: all
+
+  - package-ecosystem: pip
+    directory: /
+    schedule:
+      interval: daily
+    allow:
+      - dependency-type: all
diff --git a/.github/workflows/actionlint.yml b/.github/workflows/actionlint.yml
new file mode 100644
index 0000000000000..2cccd9d7da88a
--- /dev/null
+++ b/.github/workflows/actionlint.yml
@@ -0,0 +1,85 @@
+name: actionlint
+
+on:
+  push:
+    branches:
+      - master
+    paths:
+      - '.github/workflows/*.ya?ml'
+      - '.github/actionlint.yaml'
+  pull_request:
+    paths:
+      - '.github/workflows/*.ya?ml'
+      - '.github/actionlint.yaml'
+  merge_group:
+
+env:
+  HOMEBREW_DEVELOPER: 1
+  HOMEBREW_NO_AUTO_UPDATE: 1
+  HOMEBREW_NO_ENV_HINTS: 1
+
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
+
+concurrency:
+  group: "actionlint-${{ github.ref }}"
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+permissions: {}
+
+jobs:
+  workflow_syntax:
+    if: github.repository_owner == 'Homebrew'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up Homebrew
+        id: setup-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: false
+
+      - name: Install tools
+        run: brew install actionlint shellcheck zizmor
+
+      - name: Set up GITHUB_WORKSPACE
+        env:
+          HOMEBREW_REPOSITORY: ${{ steps.setup-homebrew.outputs.repository-path }}
+        run: |
+          # Annotations work only relative to GITHUB_WORKSPACE
+          (shopt -s dotglob; rm -rf "${GITHUB_WORKSPACE:?}"/*; mv "${HOMEBREW_REPOSITORY:?}"/* "$GITHUB_WORKSPACE")
+          rmdir "$HOMEBREW_REPOSITORY"
+          ln -vs "$GITHUB_WORKSPACE" "$HOMEBREW_REPOSITORY"
+
+          echo "::add-matcher::.github/actionlint-matcher.json"
+
+      - run: zizmor --format sarif . >results.sarif
+
+      - name: Upload SARIF file
+        uses: actions/upload-artifact@v4
+        with:
+          name: results.sarif
+          path: results.sarif
+
+      - run: actionlint
+
+  upload_sarif:
+    needs: workflow_syntax
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      security-events: write
+    steps:
+      - name: Download SARIF file
+        uses: actions/download-artifact@v4
+        with:
+          name: results.sarif
+          path: results.sarif
+
+      - name: Upload SARIF file
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: results.sarif
+          category: zizmor
diff --git a/.github/workflows/autogenerated-files.yml b/.github/workflows/autogenerated-files.yml
new file mode 100644
index 0000000000000..4e4ff5f02933c
--- /dev/null
+++ b/.github/workflows/autogenerated-files.yml
@@ -0,0 +1,54 @@
+name: Autogenerated files check
+
+on:
+  pull_request:
+    paths:
+      - .github/workflows/autogenerated-files.yml
+      - README.md
+      - completions/**
+      - docs/Manpage.md
+      - manpages/brew.1
+
+permissions:
+  contents: read
+
+env:
+  HOMEBREW_DEVELOPER: 1
+  HOMEBREW_NO_AUTO_UPDATE: 1
+
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
+
+jobs:
+  autogenerated:
+    runs-on: ubuntu-22.04
+    if: github.repository == 'Homebrew/brew'
+    steps:
+      - name: Set up Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: true
+
+      - name: Cache Bundler RubyGems
+        uses: actions/cache@6849a6489940f00c2f30c0fb92c6274307ccb58a # v4
+        with:
+          path: ${{ steps.set-up-homebrew.outputs.gems-path }}
+          key: ${{ runner.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }}
+          restore-keys: ${{ runner.os }}-rubygems-
+
+      - name: Check for changes to autogenerated files
+        id: check
+        run: |
+          if brew generate-man-completions
+          then
+            echo "This PR modifies autogenerated files!" >&2
+            echo "Please ensure their source files are updated and then run the following:
+              brew generate-man-completions" >&2
+            exit 1
+          else
+            exit 0
+          fi
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 371605a34f1cf..333ba2a0f0de9 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -1,31 +1,39 @@
 name: "CodeQL"
 
 on:
- push:
-   branches:
-     - master
- pull_request:
-   branches:
-     - master
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
 
 jobs:
- analyze:
-   name: Analyze
-   runs-on: ubuntu-latest
-   permissions:
-     actions: read
-     contents: read
-     security-events: write
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-22.04
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
 
-   steps:
-   - name: Checkout repository
-     uses: actions/checkout@v3
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        with:
+          persist-credentials: false
 
-   - name: Initialize CodeQL
-     uses: github/codeql-action/init@v2
-     with:
-       languages: ruby
-       config-file: ./.github/codeql/codeql-config.yml
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@662472033e021d55d94146f66f6058822b0b39fd # v3
+        with:
+          languages: ruby
+          config: |
+            paths-ignore:
+              - Library/Homebrew/vendor
 
-   - name: Perform CodeQL Analysis
-     uses: github/codeql-action/analyze@v2
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@662472033e021d55d94146f66f6058822b0b39fd # v3
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
index 8bdfb1f8db32b..fe897d9a828dc 100644
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -1,27 +1,34 @@
 name: Docker
+
 on:
+  pull_request:
   push:
-    paths:
-      - .github/workflows/docker.yml
-      - Dockerfile
-    branches-ignore:
+    branches:
       - master
+  merge_group:
   release:
     types:
       - published
+
 permissions:
   contents: read
+
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
+
 jobs:
   ubuntu:
-    if: startsWith(github.repository, 'Homebrew/')
-    runs-on: ubuntu-latest
+    if: github.repository_owner == 'Homebrew'
+    name: docker (Ubuntu ${{ matrix.version }})
+    runs-on: ubuntu-22.04
     strategy:
       fail-fast: false
       matrix:
-        version: ["16.04", "18.04", "20.04", "22.04"]
+        version: ["18.04", "20.04", "22.04", "24.04"]
     steps:
       - name: Checkout
-        uses: actions/checkout@main
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           fetch-depth: 0
           persist-credentials: false
@@ -29,53 +36,109 @@ jobs:
       - name: Fetch origin/master from Git
         run: git fetch origin master
 
-      - name: Build Docker image
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@c47758b77c9736f4b2ef4073d4d51994fabfe349 # v3
+
+      - name: Determine build attributes
+        id: attributes
         run: |
+          date="$(date --rfc-3339=seconds --utc)"
           brew_version="$(git describe --tags --dirty --abbrev=7)"
-          echo "Building for Homebrew ${brew_version}"
-          docker build -t brew \
-               --build-arg=version=${{matrix.version}} \
-               --label org.opencontainers.image.created="$(date --rfc-3339=seconds --utc)" \
-               --label org.opencontainers.image.url="https://brew.sh" \
-               --label org.opencontainers.image.documentation="https://docs.brew.sh" \
-               --label org.opencontainers.image.source="https://github.com/${GITHUB_REPOSITORY}" \
-               --label org.opencontainers.image.version="${brew_version}" \
-               --label org.opencontainers.image.revision="${GITHUB_SHA}" \
-               --label org.opencontainers.image.vendor="${GITHUB_REPOSITORY_OWNER}" \
-               --label org.opencontainers.image.licenses="BSD-2-Clause" \
-               .
+
+          DELIMITER="END_LABELS_$(uuidgen)"
+          cat <<EOS | tee -a "${GITHUB_OUTPUT}"
+          labels<<${DELIMITER}
+          org.opencontainers.image.created=${date}
+          org.opencontainers.image.url=https://brew.sh
+          org.opencontainers.image.documentation=https://docs.brew.sh
+          org.opencontainers.image.source=https://github.com/${GITHUB_REPOSITORY}
+          org.opencontainers.image.version=${brew_version}
+          org.opencontainers.image.revision=${GITHUB_SHA}
+          org.opencontainers.image.vendor=${GITHUB_REPOSITORY_OWNER}
+          org.opencontainers.image.licenses=BSD-2-Clause
+          ${DELIMITER}
+          EOS
+
+          tags=()
+          if [[ "${GITHUB_EVENT_NAME}" == "release" ]]; then
+            tags+=(
+              "ghcr.io/homebrew/ubuntu${{matrix.version}}:${brew_version}"
+              "ghcr.io/homebrew/ubuntu${{matrix.version}}:latest"
+              "homebrew/ubuntu${{matrix.version}}:${brew_version}"
+              "homebrew/ubuntu${{matrix.version}}:latest"
+            )
+            if [[ "${{ matrix.version }}" == "22.04" ]]; then
+              tags+=(
+                "ghcr.io/homebrew/brew:${brew_version}"
+                "ghcr.io/homebrew/brew:latest"
+                "homebrew/brew:${brew_version}"
+                "homebrew/brew:latest"
+              )
+            fi
+          elif [[ "${GITHUB_EVENT_NAME}" == "push" &&
+                  "${GITHUB_REF}" == "refs/heads/master" &&
+                  "${{ matrix.version }}" == "22.04" ]]; then
+            tags+=(
+              "ghcr.io/homebrew/brew:master"
+              "ghcr.io/homebrew/ubuntu${{ matrix.version }}:master"
+              "homebrew/brew:master"
+              "homebrew/ubuntu${{matrix.version}}:master"
+            )
+          fi
+          if [[ "${{ matrix.version }}" == "18.04" ]]; then
+            # odeprecated: remove this in Homebrew >=4.4
+            echo "The homebrew/ubuntu18.04 image is deprecated and will soon be retired. Use homebrew/ubuntu22.04 or homebrew/ubuntu24.04 or homebrew/ubuntu20.04 or homebrew/brew." > .docker-deprecate
+          fi
+
+          {
+            if [[ "${#tags[@]}" -ne 0 ]]; then
+              DELIMITER="END_TAGS_$(uuidgen)"
+              echo "tags<<${DELIMITER}"
+              printf "%s\n" "${tags[@]}"
+              echo "${DELIMITER}"
+              echo "push=true"
+            else
+              echo "push=false"
+            fi
+          } | tee -a "${GITHUB_OUTPUT}"
+
+      - name: Build Docker image
+        uses: docker/build-push-action@4f58ea79222b3b9dc2c8bbdd6debcef730109a75 # v6
+        with:
+          context: .
+          load: true
+          tags: brew
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+          build-args: version=${{ matrix.version }}
+          labels: ${{ steps.attributes.outputs.labels }}
 
       - name: Run brew test-bot --only-setup
         run: docker run --rm brew brew test-bot --only-setup
 
-      - name: Deploy the tagged Docker image to GitHub Packages
-        if: startsWith(github.ref, 'refs/tags/')
-        run: |
-          brew_version="${GITHUB_REF:10}"
-          echo "brew_version=${brew_version}" >> "${GITHUB_ENV}"
-          echo ${{secrets.HOMEBREW_BREW_GITHUB_PACKAGES_TOKEN}} | docker login ghcr.io -u BrewTestBot --password-stdin
-          docker tag brew "ghcr.io/homebrew/ubuntu${{matrix.version}}:${brew_version}"
-          docker push "ghcr.io/homebrew/ubuntu${{matrix.version}}:${brew_version}"
-          docker tag brew "ghcr.io/homebrew/ubuntu${{matrix.version}}:latest"
-          docker push "ghcr.io/homebrew/ubuntu${{matrix.version}}:latest"
+      - name: Log in to GitHub Packages
+        if: steps.attributes.outputs.push == 'true'
+        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567 # v3
+        with:
+          registry: ghcr.io
+          username: BrewTestBot
+          password: ${{ secrets.HOMEBREW_BREW_GITHUB_PACKAGES_TOKEN }}
 
-      - name: Deploy the tagged Docker image to Docker Hub
-        if: startsWith(github.ref, 'refs/tags/')
-        run: |
-          echo ${{secrets.HOMEBREW_BREW_DOCKER_TOKEN}} | docker login -u brewtestbot --password-stdin
-          docker tag brew "homebrew/ubuntu${{matrix.version}}:${brew_version}"
-          docker push "homebrew/ubuntu${{matrix.version}}:${brew_version}"
-          docker tag brew "homebrew/ubuntu${{matrix.version}}:latest"
-          docker push "homebrew/ubuntu${{matrix.version}}:latest"
+      - name: Log in to Docker Hub
+        if: steps.attributes.outputs.push == 'true'
+        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567 # v3
+        with:
+          username: brewtestbot
+          password: ${{ secrets.HOMEBREW_BREW_DOCKER_TOKEN }}
 
-      - name: Deploy the homebrew/brew Docker image to GitHub Packages and Docker Hub
-        if: startsWith(github.ref, 'refs/tags/') && matrix.version == '22.04'
-        run: |
-          docker tag brew "ghcr.io/homebrew/brew:${brew_version}"
-          docker push "ghcr.io/homebrew/brew:${brew_version}"
-          docker tag brew "ghcr.io/homebrew/brew:latest"
-          docker push "ghcr.io/homebrew/brew:latest"
-          docker tag brew "homebrew/brew:${brew_version}"
-          docker push "homebrew/brew:${brew_version}"
-          docker tag brew "homebrew/brew:latest"
-          docker push "homebrew/brew:latest"
+      - name: Deploy the tagged Docker image
+        if: steps.attributes.outputs.push == 'true'
+        uses: docker/build-push-action@4f58ea79222b3b9dc2c8bbdd6debcef730109a75 # v6
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.attributes.outputs.tags }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+          build-args: version=${{ matrix.version }}
+          labels: ${{ steps.attributes.outputs.labels }}
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 0000000000000..f46e17e60fa73
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,79 @@
+name: Documentation CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+permissions:
+  contents: read
+  pages: read
+
+env:
+  HOMEBREW_DEVELOPER: 1
+  HOMEBREW_NO_AUTO_UPDATE: 1
+  HOMEBREW_NO_ENV_HINTS: 1
+  HOMEBREW_BOOTSNAP: 1
+  HOMEBREW_NO_INSTALL_CLEANUP: 1
+
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
+
+jobs:
+  docs:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Set up Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: false
+
+      - name: Checkout repository
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        with:
+          persist-credentials: false
+
+      - name: Install vale
+        run: brew install vale
+
+      - name: Cleanup Homebrew/brew docs
+        if: github.repository == 'Homebrew/brew'
+        run: |
+          # Avoid failing on broken symlinks.
+          rm Library/Homebrew/os/mac/pkgconfig/fuse/fuse.pc
+          rm Library/Homebrew/os/mac/pkgconfig/fuse/osxfuse.pc
+
+          # No ignore support (https://github.com/errata-ai/vale/issues/131).
+          rm -r Library/Homebrew/vendor
+
+      - name: Run Vale
+        run: vale docs/
+
+      - name: Install Ruby
+        uses: ruby/setup-ruby@7d3497fd78c07c0d84ebafa58d8dac60cd1f0763 # v1.199.0
+        with:
+          bundler-cache: true
+          working-directory: docs
+
+      - name: Check Markdown syntax
+        working-directory: docs
+        run: bundle exec rake lint
+
+      - name: Check code blocks conform to our Ruby style guide
+        run: brew style docs
+
+      - name: Generate formulae.brew.sh API samples
+        if: github.repository == 'Homebrew/formulae.brew.sh'
+        working-directory: docs
+        run: ../script/generate-api-samples.rb
+
+      - name: Build the site and check for broken links
+        working-directory: docs
+        run: bundle exec rake test
+        env:
+          JEKYLL_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/doctor.yml b/.github/workflows/doctor.yml
index 50409557e6d85..169d58de15163 100644
--- a/.github/workflows/doctor.yml
+++ b/.github/workflows/doctor.yml
@@ -8,21 +8,47 @@ on:
       - Library/Homebrew/extend/os/diagnostic.rb
       - Library/Homebrew/extend/os/mac/diagnostic.rb
       - Library/Homebrew/os/mac/xcode.rb
+
 permissions:
   contents: read
+
 env:
   HOMEBREW_DEVELOPER: 1
   HOMEBREW_NO_AUTO_UPDATE: 1
-  HOMEBREW_CHANGE_ARCH_TO_ARM: 1
+
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
+
 jobs:
+  determine-runners:
+    runs-on: ubuntu-22.04
+    outputs:
+      runners: ${{ steps.determine-runners.outputs.runners }}
+    steps:
+      - name: Set up Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: false
+
+      - name: Determine runners to use for this job
+        id: determine-runners
+        env:
+          HOMEBREW_MACOS_TIMEOUT: 30
+        run: brew determine-test-runners --all-supported
+
   tests:
+    needs: determine-runners
     strategy:
       matrix:
-        version: ["12-arm64", "12", "11-arm64", "11", "10.15"]
+        include: ${{ fromJson(needs.determine-runners.outputs.runners) }}
       fail-fast: false
-    runs-on: ${{ matrix.version }}
-    env:
-      PATH: "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.runner }}
+    timeout-minutes: ${{ matrix.timeout }}
     defaults:
       run:
         working-directory: /tmp
@@ -30,10 +56,15 @@ jobs:
       - name: Set up Homebrew
         id: set-up-homebrew
         uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: true
 
       - run: brew test-bot --only-cleanup-before
+        if: matrix.cleanup
 
-      - run: brew test-bot --only-setup
+      - run: brew doctor
 
       - run: brew test-bot --only-cleanup-after
-        if: always()
+        if: always() && matrix.cleanup
diff --git a/.github/workflows/pkg-installer.yml b/.github/workflows/pkg-installer.yml
new file mode 100644
index 0000000000000..2b0e4d492ff7b
--- /dev/null
+++ b/.github/workflows/pkg-installer.yml
@@ -0,0 +1,267 @@
+name: Installer Package
+on:
+  push:
+    branches:
+      - '**'
+    tags-ignore:
+      - '**'
+    paths:
+      - .github/workflows/pkg-installer.yml
+      - package/**/*
+  release:
+    types:
+      - published
+env:
+  PKG_APPLE_DEVELOPER_TEAM_ID: ${{ secrets.PKG_APPLE_DEVELOPER_TEAM_ID }}
+  HOMEBREW_NO_ANALYTICS_THIS_RUN: 1
+  HOMEBREW_NO_ANALYTICS_MESSAGE_OUTPUT: 1
+
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
+
+jobs:
+  build:
+    if: github.repository_owner == 'Homebrew' && github.actor != 'dependabot[bot]'
+    runs-on: macos-15
+    outputs:
+      installer_path: "Homebrew-${{ steps.homebrew-version.outputs.version }}.pkg"
+    env:
+      TEMPORARY_CERTIFICATE_FILE: 'homebrew_developer_id_installer_certificate.p12'
+      TEMPORARY_KEYCHAIN_FILE: 'homebrew_installer_signing.keychain-db'
+      # Set to the oldest supported version of macOS
+      HOMEBREW_MACOS_OLDEST_SUPPORTED: '13.0'
+    permissions:
+      contents: read # for code access
+      attestations: write # for actions/attest-build-provenance
+      id-token: write # for actions/attest-build-provenance
+    steps:
+      - name: Remove existing API cache (to force update)
+        run: rm -rvf ~/Library/Caches/Homebrew/api
+
+      - name: Set up Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: false
+
+      - name: Install Pandoc
+        run: brew install pandoc
+
+      - name: Create and unlock temporary macOS keychain
+        run: |
+          TEMPORARY_KEYCHAIN_PASSWORD="$(openssl rand -base64 20)"
+          TEMPORARY_KEYCHAIN_PATH="${RUNNER_TEMP}/${TEMPORARY_KEYCHAIN_FILE}"
+          security create-keychain -p "${TEMPORARY_KEYCHAIN_PASSWORD}" "${TEMPORARY_KEYCHAIN_PATH}"
+          security set-keychain-settings -l -u -t 21600 "${TEMPORARY_KEYCHAIN_PATH}"
+          security unlock-keychain -p "${TEMPORARY_KEYCHAIN_PASSWORD}" "${TEMPORARY_KEYCHAIN_PATH}"
+
+      - name: Create temporary certificate file
+        env:
+          PKG_APPLE_SIGNING_CERTIFICATE_BASE64: ${{ secrets.PKG_APPLE_SIGNING_CERTIFICATE_BASE64 }}
+        run: echo -n "${PKG_APPLE_SIGNING_CERTIFICATE_BASE64}" |
+             base64 --decode --output="${RUNNER_TEMP}/${TEMPORARY_CERTIFICATE_FILE}"
+
+      - name: Import certificate file into macOS keychain
+        env:
+          PKG_APPLE_SIGNING_CERTIFICATE_PASSWORD: ${{ secrets.PKG_APPLE_SIGNING_CERTIFICATE_PASSWORD }}
+        run: security import "${RUNNER_TEMP}/${TEMPORARY_CERTIFICATE_FILE}"
+                             -k "${RUNNER_TEMP}/${TEMPORARY_KEYCHAIN_FILE}"
+                             -P "${PKG_APPLE_SIGNING_CERTIFICATE_PASSWORD}"
+                             -t cert
+                             -f pkcs12
+                             -A
+
+      - name: Clean up temporary certificate file
+        if: ${{ always() }}
+        run: rm -f "${RUNNER_TEMP}/${TEMPORARY_CERTIFICATE_FILE}"
+
+      - name: Checkout another Homebrew to brew subdirectory
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        with:
+          path: brew
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: Get Homebrew version from Git
+        id: homebrew-version
+        run: echo "version=$(git -C brew describe --tags --always)" >> "${GITHUB_OUTPUT}"
+
+      - name: Copy Homebrew API cache to brew subdirectory
+        run: cp -vR ~/Library/Caches/Homebrew/api brew/cache_api
+
+      - name: Open macOS keychain
+        run: security list-keychain -d user -s "${RUNNER_TEMP}/${TEMPORARY_KEYCHAIN_FILE}"
+
+      - name: Build Homebrew installer component package
+        env:
+          HOMEBREW_VERSION: ${{ steps.homebrew-version.outputs.version }}
+        # Note: `Library/Homebrew/test/support/fixtures/` contains unsigned
+        # binaries so it needs to be excluded from notarization.
+        run: pkgbuild --root brew
+                      --scripts brew/package/scripts
+                      --identifier sh.brew.homebrew
+                      --version "${HOMEBREW_VERSION}"
+                      --install-location /opt/homebrew
+                      --filter .DS_Store
+                      --filter "(.*)/Library/Homebrew/test/support/fixtures/"
+                      --min-os-version "${HOMEBREW_MACOS_OLDEST_SUPPORTED}"
+                      --sign "${PKG_APPLE_DEVELOPER_TEAM_ID}"
+                      Homebrew.pkg
+
+      - name: Convert Homebrew license file to RTF
+        run: (printf "### " && cat brew/LICENSE.txt) |
+              pandoc --from markdown --standalone --output brew/package/resources/LICENSE.rtf
+
+      - name: Build Homebrew installer product package
+        env:
+          HOMEBREW_VERSION: ${{ steps.homebrew-version.outputs.version }}
+        run: productbuild --resources brew/package/resources
+                          --distribution brew/package/Distribution.xml
+                          --package-path Homebrew.pkg
+                          --sign "${PKG_APPLE_DEVELOPER_TEAM_ID}"
+                          "Homebrew-${HOMEBREW_VERSION}.pkg"
+
+      - name: Clean up temporary macOS keychain
+        if: ${{ always() }}
+        run: |
+          if [[ -f "${RUNNER_TEMP}/${TEMPORARY_KEYCHAIN_FILE}" ]]
+          then
+            security delete-keychain "${RUNNER_TEMP}/${TEMPORARY_KEYCHAIN_FILE}"
+          fi
+
+      - name: Generate build provenance
+        uses: actions/attest-build-provenance@1c608d11d69870c2092266b3f9a6f3abbf17002c # v1.4.3
+        with:
+          subject-path: Homebrew-${{ steps.homebrew-version.outputs.version }}.pkg
+
+      - name: Upload installer to GitHub Actions
+        uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
+        with:
+          name: Homebrew-${{ steps.homebrew-version.outputs.version }}.pkg
+          path: Homebrew-${{ steps.homebrew-version.outputs.version }}.pkg
+  test:
+    needs: build
+    name: "test (${{matrix.name}})"
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Intel
+          - runner: macos-13
+            name: macos-13-x86_64
+          # Apple Silicon
+          - runner: macos-14
+            name: macos-14-arm64
+          - runner: macos-15
+            name: macos-15-arm64
+    steps:
+      - name: Download installer from GitHub Actions
+        uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4
+        with:
+          name: "${{ needs.build.outputs.installer_path }}"
+
+      - name: Unset global Git safe directory setting
+        run: git config --global --unset-all safe.directory
+
+      - name: Remove existing Homebrew installations
+        run: |
+          sudo rm -rf brew /{usr/local,opt/homebrew}/{Cellar,Caskroom,Homebrew/Library/Taps}
+          brew cleanup --prune-prefix
+          sudo rm -rf /usr/local/{bin/brew,Homebrew} /opt/homebrew /home/linuxbrew
+
+      - name: Zero existing installer logs
+        run: echo | sudo tee /var/log/install.log
+
+      - name: Install Homebrew from installer package
+        env:
+          INSTALLER_PATH: ${{ needs.build.outputs.installer_path }}
+        run: sudo installer -verbose -pkg "${INSTALLER_PATH}" -target /
+
+      - name: Output installer logs
+        if: ${{ always() }}
+        run: sudo cat /var/log/install.log
+
+      - run: brew config
+
+      - run: brew doctor
+
+      - name: Zero existing installer logs (again)
+        run: echo | sudo tee /var/log/install.log
+
+      - name: Reinstall Homebrew from installer package
+        env:
+          INSTALLER_PATH: ${{ needs.build.outputs.installer_path }}
+        run: sudo installer -verbose -pkg "${INSTALLER_PATH}" -target /
+
+      - name: Output installer logs (again)
+        if: ${{ always() }}
+        run: sudo cat /var/log/install.log
+
+      - run: brew config
+
+      - run: brew doctor
+
+  upload:
+    needs: [build, test]
+    runs-on: macos-15
+    permissions:
+      # To write assets to GitHub release
+      contents: write
+    steps:
+      - name: Download installer from GitHub Actions
+        uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4
+        with:
+          name: "${{ needs.build.outputs.installer_path }}"
+
+      - name: Notarize Homebrew installer package
+        env:
+          PKG_APPLE_ID_EMAIL: ${{ secrets.PKG_APPLE_ID_EMAIL }}
+          PKG_APPLE_ID_APP_SPECIFIC_PASSWORD: ${{ secrets.PKG_APPLE_ID_APP_SPECIFIC_PASSWORD }}
+          INSTALLER_PATH: ${{ needs.build.outputs.installer_path }}
+        run: xcrun notarytool submit "${INSTALLER_PATH}"
+                                    --team-id  "${PKG_APPLE_DEVELOPER_TEAM_ID}"
+                                    --apple-id "${PKG_APPLE_ID_EMAIL}"
+                                    --password "${PKG_APPLE_ID_APP_SPECIFIC_PASSWORD}"
+                                    --wait
+
+      - name: Install gh
+        run: brew install gh
+
+      - name: Upload installer to GitHub release
+        if: github.event_name == 'release'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          INSTALLER_PATH: ${{ needs.build.outputs.installer_path }}
+        run: gh release upload --repo Homebrew/brew
+                                "${GITHUB_REF//refs\/tags\//}"
+                                "${INSTALLER_PATH}"
+
+  issue:
+    needs: [build, test, upload]
+    if: always() && github.event_name == 'release'
+    runs-on: ubuntu-latest
+    env:
+      RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+    permissions:
+      # To create or update issues
+      issues: write
+    steps:
+      - name: Open, update, or close pkg installer issue
+        uses: Homebrew/actions/create-or-update-issue@master
+        with:
+          title: Failed to publish pkg installer
+          body: >
+            The pkg installer workflow [failed](${{ env.RUN_URL }}) for release
+            ${{ github.ref_name }}. No pkg installer was uploaded to the GitHub
+            release.
+          labels: bug,release blocker
+          update-existing: ${{ contains(needs.*.result, 'failure') }}
+          close-existing: ${{ needs.upload.result == 'success' }}
+          close-from-author: github-actions[bot]
+          close-comment: >
+            The pkg installer workflow [succeeded](${{ env.RUN_URL }}) for
+            release ${{ github.ref_name }}. Closing this issue.
diff --git a/.github/workflows/rubydoc.yml b/.github/workflows/rubydoc.yml
new file mode 100644
index 0000000000000..b239e6a782f3b
--- /dev/null
+++ b/.github/workflows/rubydoc.yml
@@ -0,0 +1,53 @@
+name: Ruby Documentation CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+
+permissions:
+  contents: read
+
+env:
+  HOMEBREW_DEVELOPER: 1
+  HOMEBREW_NO_AUTO_UPDATE: 1
+  HOMEBREW_NO_ENV_HINTS: 1
+  HOMEBREW_BOOTSNAP: 1
+  HOMEBREW_NO_INSTALL_CLEANUP: 1
+
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
+
+jobs:
+  rubydoc:
+    if: github.repository == 'Homebrew/brew'
+    runs-on: ubuntu-22.04
+    env:
+      BUNDLE_GEMFILE: ${{ github.workspace }}/rubydoc/Gemfile
+    steps:
+      - name: Set up Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: false
+
+      - name: Checkout Homebrew/rubydoc.brew.sh
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+        with:
+          repository: Homebrew/rubydoc.brew.sh
+          path: rubydoc
+          persist-credentials: false
+
+      - name: Install Ruby
+        uses: ruby/setup-ruby@7d3497fd78c07c0d84ebafa58d8dac60cd1f0763 # v1.199.0
+        with:
+          bundler-cache: true
+          working-directory: rubydoc
+
+      - name: Process rubydoc comments
+        working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}/Library/Homebrew
+        run: bundle exec yard doc --no-output --fail-on-warning
diff --git a/.github/workflows/schemas.yml b/.github/workflows/schemas.yml
new file mode 100644
index 0000000000000..3afa4c9d072e6
--- /dev/null
+++ b/.github/workflows/schemas.yml
@@ -0,0 +1,95 @@
+name: Update schema data
+on:
+  push:
+    paths:
+      - .github/workflows/schemas.yml
+    branches-ignore:
+      - master
+  schedule:
+    - cron: "0 0 * * *"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
+
+jobs:
+  spdx:
+    if: github.repository == 'Homebrew/brew'
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Set up Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: false
+
+      - name: Configure Git user
+        uses: Homebrew/actions/git-user-config@master
+        with:
+          username: BrewTestBot
+
+      - name: Set up commit signing
+        uses: Homebrew/actions/setup-commit-signing@master
+        with:
+          signing_key: ${{ secrets.BREWTESTBOT_GPG_SIGNING_SUBKEY }}
+
+      - name: Update schema data
+        id: update
+        env:
+          GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
+          HOMEBREW_GPG_PASSPHRASE: ${{ secrets.BREWTESTBOT_GPG_SIGNING_SUBKEY_PASSPHRASE }}
+        working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
+        run: |
+          git fetch origin
+
+          BRANCH="schema-update"
+          echo "branch=${BRANCH}" >> "$GITHUB_OUTPUT"
+
+          if git ls-remote --exit-code --heads origin "${BRANCH}"
+          then
+            git checkout "${BRANCH}"
+            git checkout "Library/Homebrew/data/schemas"
+          else
+            git checkout --no-track -B "${BRANCH}" origin/master
+          fi
+
+          # Intentionally tracking 2.3.x to match what we output in sbom.rb. 3.0 also doesn't have a JSON Schema.
+          # Note: this is a 2.3.1 development branch - not a 2.3.1 tag. It contains bugfixes compared to 2.3.0.
+          curl --location --output Library/Homebrew/data/schemas/sbom.json https://raw.githubusercontent.com/spdx/spdx-spec/development/v2.3.1/schemas/spdx-schema.json
+          # https://github.com/spdx/spdx-spec/pull/1029
+          sed -i -e 's|\(2019-09/schema\)#|\1|' Library/Homebrew/data/schemas/sbom.json
+
+          if ! git diff --exit-code Library/Homebrew/data/schemas
+          then
+            git add "Library/Homebrew/data/schemas"
+            git commit -m "data/schemas: update schema data." -m "Autogenerated by [a scheduled GitHub Action](https://github.com/Homebrew/brew/blob/master/.github/workflows/schemas.yml)."
+            echo "committed=true" >> "$GITHUB_OUTPUT"
+            PULL_REQUEST_STATE="$(gh pr view --json=state | jq -r ".state")"
+            if [[ "${PULL_REQUEST_STATE}" != "OPEN" ]]
+            then
+              echo "pull_request=true" >> "$GITHUB_OUTPUT"
+            fi
+          fi
+
+      - name: Push commits
+        if: steps.update.outputs.committed == 'true'
+        uses: Homebrew/actions/git-try-push@master
+        with:
+          token: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
+          directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
+          branch: ${{ steps.update.outputs.branch }}
+          force: true
+          origin_branch: "master"
+
+      - name: Open a pull request
+        if: steps.update.outputs.pull_request == 'true'
+        run: gh pr create --fill
+        env:
+          GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
+        working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
diff --git a/.github/workflows/sorbet.yml b/.github/workflows/sorbet.yml
index 4944cfdaaad28..0e419bbfce9e4 100644
--- a/.github/workflows/sorbet.yml
+++ b/.github/workflows/sorbet.yml
@@ -1,6 +1,11 @@
 name: Update Sorbet files
 
 on:
+  pull_request:
+    paths:
+      - Library/Homebrew/dev-cmd/typecheck.rb
+      - Library/Homebrew/sorbet/**
+      - "!Library/Homebrew/sorbet/rbi/**"
   push:
     paths:
       - .github/workflows/sorbet.yml
@@ -13,68 +18,99 @@ on:
 permissions:
   contents: read
 
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
+
 jobs:
   tapioca:
     if: github.repository == 'Homebrew/brew'
-    runs-on: macos-latest
+    runs-on: macos-15
     steps:
       - name: Set up Homebrew
         id: set-up-homebrew
         uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: false
 
       - name: Configure Git user
+        if: github.event_name != 'pull_request'
         uses: Homebrew/actions/git-user-config@master
         with:
           username: BrewTestBot
 
       - name: Set up commit signing
+        if: github.event_name != 'pull_request'
         uses: Homebrew/actions/setup-commit-signing@master
         with:
           signing_key: ${{ secrets.BREWTESTBOT_GPG_SIGNING_SUBKEY }}
 
       - name: Update RBI files
         id: update
-        env:
-          GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
-          HOMEBREW_GPG_PASSPHRASE: ${{ secrets.BREWTESTBOT_GPG_SIGNING_SUBKEY_PASSPHRASE }}
+        working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
         run: |
-          git fetch origin
+          if [[ "${GITHUB_EVENT_NAME}" != "pull_request" ]]
+          then
+            git fetch origin
 
-          BRANCH="sorbet-files-update"
-          echo "::set-output name=branch::${BRANCH}"
+            BRANCH="sorbet-files-update"
+            echo "branch=${BRANCH}" >> "$GITHUB_OUTPUT"
 
-          if git ls-remote --exit-code --heads origin "${BRANCH}"
-          then
-            git checkout "${BRANCH}"
-            git reset --hard origin/master
-          else
-            git checkout --no-track -B "${BRANCH}" origin/master
+            if git ls-remote --exit-code --heads origin "${BRANCH}"
+            then
+              git checkout "${BRANCH}"
+              git checkout "Library/Homebrew/sorbet"
+            else
+              git checkout --no-track -B "${BRANCH}" origin/master
+            fi
           fi
 
-          if brew typecheck --update --fail-if-not-changed
+          brew typecheck --update --suggest-typed
+
+      - name: Commit changes
+        id: commit
+        if: github.event_name != 'pull_request'
+        env:
+          GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
+          HOMEBREW_GPG_PASSPHRASE: ${{ secrets.BREWTESTBOT_GPG_SIGNING_SUBKEY_PASSPHRASE }}
+        working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
+        run: |
+          if ! git diff --stat --exit-code "Library/Homebrew/sorbet"
           then
-            git add "${GITHUB_WORKSPACE}/Library/Homebrew/sorbet"
+            git add "Library/Homebrew/sorbet"
             git commit -m "sorbet: Update RBI files." \
                        -m "Autogenerated by the [sorbet](https://github.com/Homebrew/brew/blob/master/.github/workflows/sorbet.yml) workflow."
-            echo "::set-output name=committed::true"
+
+            if ! git diff --stat --exit-code "Library/Homebrew"
+            then
+              git add "Library/Homebrew/"
+              git commit -m "sorbet: Autobump sigils via Spoom" \
+                         -m "Autogenerated by the [sorbet](https://github.com/Homebrew/brew/blob/master/.github/workflows/sorbet.yml) workflow."
+            fi
+
+            echo "committed=true" >> "$GITHUB_OUTPUT"
             PULL_REQUEST_STATE="$(gh pr view --json=state | jq -r ".state")"
             if [[ "${PULL_REQUEST_STATE}" != "OPEN" ]]
             then
-              echo "::set-output name=pull_request::true"
+              echo "pull_request=true" >> "$GITHUB_OUTPUT"
             fi
           fi
 
       - name: Push commits
-        if: steps.update.outputs.committed == 'true'
+        if: steps.commit.outputs.committed == 'true'
         uses: Homebrew/actions/git-try-push@master
         with:
           token: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
+          directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
           branch: ${{ steps.update.outputs.branch }}
           force: true
           origin_branch: "master"
 
       - name: Open a pull request
-        if: steps.update.outputs.pull_request == 'true'
-        run: hub pull-request --no-edit
+        if: steps.commit.outputs.pull_request == 'true'
+        run: gh pr create --fill
         env:
           GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
+        working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
diff --git a/.github/workflows/spdx.yml b/.github/workflows/spdx.yml
index 71ed6a6e6b314..2b61db8899c2c 100644
--- a/.github/workflows/spdx.yml
+++ b/.github/workflows/spdx.yml
@@ -7,16 +7,27 @@ on:
       - master
   schedule:
     - cron: "0 0 * * *"
+  workflow_dispatch:
+
 permissions:
   contents: read
+
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
+
 jobs:
   spdx:
     if: github.repository == 'Homebrew/brew'
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Set up Homebrew
         id: set-up-homebrew
         uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: false
 
       - name: Configure Git user
         uses: Homebrew/actions/git-user-config@master
@@ -33,29 +44,30 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
           HOMEBREW_GPG_PASSPHRASE: ${{ secrets.BREWTESTBOT_GPG_SIGNING_SUBKEY_PASSPHRASE }}
+        working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
         run: |
           git fetch origin
 
           BRANCH="spdx-update"
-          echo "::set-output name=branch::${BRANCH}"
+          echo "branch=${BRANCH}" >> "$GITHUB_OUTPUT"
 
           if git ls-remote --exit-code --heads origin "${BRANCH}"
           then
             git checkout "${BRANCH}"
-            git reset --hard origin/master
+            git checkout "Library/Homebrew/data/spdx"
           else
             git checkout --no-track -B "${BRANCH}" origin/master
           fi
 
-          if brew update-license-data --fail-if-not-changed
+          if brew update-license-data
           then
-            git add "${GITHUB_WORKSPACE}/Library/Homebrew/data/spdx"
+            git add "Library/Homebrew/data/spdx"
             git commit -m "spdx: update license data." -m "Autogenerated by [a scheduled GitHub Action](https://github.com/Homebrew/brew/blob/master/.github/workflows/spdx.yml)."
-            echo "::set-output name=committed::true"
+            echo "committed=true" >> "$GITHUB_OUTPUT"
             PULL_REQUEST_STATE="$(gh pr view --json=state | jq -r ".state")"
             if [[ "${PULL_REQUEST_STATE}" != "OPEN" ]]
             then
-              echo "::set-output name=pull_request::true"
+              echo "pull_request=true" >> "$GITHUB_OUTPUT"
             fi
           fi
 
@@ -64,12 +76,14 @@ jobs:
         uses: Homebrew/actions/git-try-push@master
         with:
           token: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
+          directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
           branch: ${{ steps.update.outputs.branch }}
           force: true
           origin_branch: "master"
 
       - name: Open a pull request
         if: steps.update.outputs.pull_request == 'true'
-        run: hub pull-request --no-edit
+        run: gh pr create --fill
         env:
           GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
+        working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
diff --git a/.github/workflows/sponsors-maintainers-man-completions.yml b/.github/workflows/sponsors-maintainers-man-completions.yml
new file mode 100644
index 0000000000000..24db26bd46a70
--- /dev/null
+++ b/.github/workflows/sponsors-maintainers-man-completions.yml
@@ -0,0 +1,140 @@
+name: Update sponsors, maintainers, manpage and completions
+
+on:
+  push:
+    branches:
+      - master
+    paths:
+      - .github/workflows/sponsors-maintainers-man-completions.yml
+      - README.md
+      - Library/Homebrew/cmd/**
+      - Library/Homebrew/dev-cmd/**
+      - Library/Homebrew/completions/**
+      - Library/Homebrew/manpages/**
+      - Library/Homebrew/cli/parser.rb
+      - Library/Homebrew/completions.rb
+      - Library/Homebrew/env_config.rb
+  schedule:
+    - cron: "0 0 * * *"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
+
+jobs:
+  updates:
+    runs-on: ubuntu-22.04
+    if: github.repository == 'Homebrew/brew'
+    steps:
+      - name: Setup Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: false
+
+      - name: Configure Git user
+        uses: Homebrew/actions/git-user-config@master
+        with:
+          username: BrewTestBot
+
+      - name: Set up commit signing
+        uses: Homebrew/actions/setup-commit-signing@master
+        with:
+          signing_key: ${{ secrets.BREWTESTBOT_GPG_SIGNING_SUBKEY }}
+
+      - name: Cache Bundler RubyGems
+        uses: actions/cache@6849a6489940f00c2f30c0fb92c6274307ccb58a # v4
+        with:
+          path: ${{ steps.set-up-homebrew.outputs.gems-path }}
+          key: ${{ runner.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }}
+          restore-keys: ${{ runner.os }}-rubygems-
+
+      - name: Update sponsors, maintainers, manpage and completions
+        id: update
+        run: |
+          git fetch origin
+
+          if [[ -n "$GITHUB_REF_NAME" && "$GITHUB_REF_NAME" != "master" ]]
+          then
+            BRANCH="$GITHUB_REF_NAME"
+          else
+            BRANCH=sponsors-maintainers-man-completions
+          fi
+          echo "branch=${BRANCH}" >> "$GITHUB_OUTPUT"
+
+          if git ls-remote --exit-code --heads origin "${BRANCH}"
+          then
+            git checkout "${BRANCH}"
+            git checkout "README.md" \
+                         "docs/Manpage.md" \
+                         "manpages/brew.1" \
+                         "completions"
+          else
+            git checkout --no-track -B "${BRANCH}" origin/master
+          fi
+
+          if brew update-sponsors
+          then
+            git add "README.md"
+            git commit -m "Update sponsors." \
+                       -m "Autogenerated by the [sponsors-maintainers-man-completions](https://github.com/Homebrew/brew/blob/HEAD/.github/workflows/sponsors-maintainers-man-completions.yml) workflow."
+            COMMITTED=true
+          fi
+
+          if brew update-maintainers
+          then
+            git add "README.md" \
+                    "docs/Manpage.md" \
+                    "manpages/brew.1"
+            git commit -m "Update maintainers." \
+                       -m "Autogenerated by the [sponsors-maintainers-man-completions](https://github.com/Homebrew/brew/blob/HEAD/.github/workflows/sponsors-maintainers-man-completions.yml) workflow."
+            COMMITTED=true
+          fi
+
+          if brew generate-man-completions
+          then
+            git add "README.md" \
+                    "docs/Manpage.md" \
+                    "manpages/brew.1" \
+                    "completions"
+            git commit -m "Update manpage and completions." \
+                       -m "Autogenerated by the [sponsors-maintainers-man-completions](https://github.com/Homebrew/brew/blob/HEAD/.github/workflows/sponsors-maintainers-man-completions.yml) workflow."
+            COMMITTED=true
+          fi
+
+          if [[ -n "${COMMITTED-}" ]]
+          then
+            echo "committed=true" >> "$GITHUB_OUTPUT"
+            PULL_REQUEST_STATE="$(gh pr view --json=state | jq -r ".state")"
+            if [[ "${PULL_REQUEST_STATE}" != "OPEN" ]]
+            then
+              echo "pull_request=true" >> "$GITHUB_OUTPUT"
+            fi
+          fi
+        env:
+          GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
+          HOMEBREW_GITHUB_API_TOKEN: ${{ secrets.HOMEBREW_BREW_UPDATE_SPONSORS_MAINTAINERS_TOKEN }}
+          HOMEBREW_GPG_PASSPHRASE: ${{ secrets.BREWTESTBOT_GPG_SIGNING_SUBKEY_PASSPHRASE }}
+        working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
+
+      - name: Push commits
+        if: steps.update.outputs.committed == 'true'
+        uses: Homebrew/actions/git-try-push@master
+        with:
+          token: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
+          directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
+          branch: ${{ steps.update.outputs.branch }}
+          force: true
+
+      - name: Open a pull request
+        if: steps.update.outputs.pull_request == 'true'
+        run: gh pr create --fill
+        env:
+          GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
+        working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
diff --git a/.github/workflows/stale-issues.yml b/.github/workflows/stale-issues.yml
new file mode 100644
index 0000000000000..ba2621be3b3e7
--- /dev/null
+++ b/.github/workflows/stale-issues.yml
@@ -0,0 +1,82 @@
+# This file is synced from the `.github` repository, do not modify it directly.
+name: Manage stale issues
+
+on:
+  push:
+    paths:
+      - .github/workflows/stale-issues.yml
+    branches-ignore:
+      - dependabot/**
+  schedule:
+    # Once every day at midnight UTC
+    - cron: "0 0 * * *"
+  issue_comment:
+
+permissions: {}
+
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
+
+concurrency:
+  group: stale-issues
+  cancel-in-progress: ${{ github.event_name != 'issue_comment' }}
+
+jobs:
+  stale:
+    if: >
+      github.repository_owner == 'Homebrew' && (
+        github.event_name != 'issue_comment' || (
+          contains(github.event.issue.labels.*.name, 'stale') ||
+          contains(github.event.pull_request.labels.*.name, 'stale')
+        )
+      )
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+    steps:
+      - name: Mark/Close Stale Issues and Pull Requests
+        uses: actions/stale@28ca1036281a5e5922ead5184a1bbf96e5fc984e # v9
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          days-before-stale: 21
+          days-before-close: 7
+          stale-issue-message: >
+            This issue has been automatically marked as stale because it has not had
+            recent activity. It will be closed if no further activity occurs.
+          stale-pr-message: >
+            This pull request has been automatically marked as stale because it has not had
+            recent activity. It will be closed if no further activity occurs.
+          exempt-issue-labels: "gsoc-outreachy,help wanted,in progress"
+          exempt-pr-labels: "gsoc-outreachy,help wanted,in progress"
+          delete-branch: true
+
+  bump-pr-stale:
+    if: >
+      github.repository_owner == 'Homebrew' && (
+        github.event_name != 'issue_comment' || (
+          contains(github.event.issue.labels.*.name, 'stale') ||
+          contains(github.event.pull_request.labels.*.name, 'stale')
+        )
+      )
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+    steps:
+      - name: Mark/Close Stale `bump-formula-pr` and `bump-cask-pr` Pull Requests
+        uses: actions/stale@28ca1036281a5e5922ead5184a1bbf96e5fc984e # v9
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          days-before-stale: 2
+          days-before-close: 1
+          stale-pr-message: >
+            This pull request has been automatically marked as stale because it has not had
+            recent activity. It will be closed if no further activity occurs. To keep this
+            pull request open, add a `help wanted` or `in progress` label.
+          exempt-pr-labels: "help wanted,in progress"
+          any-of-labels: "bump-formula-pr,bump-cask-pr"
+          delete-branch: true
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 0bc3616251e30..701579ae9d490 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -5,6 +5,7 @@ on:
     branches:
       - master
   pull_request:
+  merge_group:
 
 permissions:
   contents: read
@@ -12,6 +13,14 @@ permissions:
 env:
   HOMEBREW_DEVELOPER: 1
   HOMEBREW_NO_AUTO_UPDATE: 1
+  HOMEBREW_NO_ENV_HINTS: 1
+  HOMEBREW_BOOTSNAP: 1
+  HOMEBREW_NO_INSTALL_CLEANUP: 1
+  HOMEBREW_VERIFY_ATTESTATIONS: 1
+
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
 
 concurrency:
   group: "${{ github.ref }}"
@@ -19,138 +28,180 @@ concurrency:
 
 jobs:
   syntax:
-    if: github.repository == 'Homebrew/brew'
-    runs-on: ubuntu-latest
+    if: github.repository_owner == 'Homebrew'
+    runs-on: ubuntu-22.04
     steps:
       - name: Set up Homebrew
         id: set-up-homebrew
         uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: false
 
       - name: Cache Bundler RubyGems
-        uses: actions/cache@v1
+        uses: actions/cache@6849a6489940f00c2f30c0fb92c6274307ccb58a # v4
         with:
           path: ${{ steps.set-up-homebrew.outputs.gems-path }}
-          key: ${{ runner.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }}
-          restore-keys: ${{ runner.os }}-rubygems-
+          key: ${{ runner.os }}-rubygems-syntax-${{ steps.set-up-homebrew.outputs.gems-hash }}
+          restore-keys: ${{ runner.os }}-rubygems-syntax-
 
       - name: Install Bundler RubyGems
-        run: brew install-bundler-gems --groups=sorbet
+        run: brew install-bundler-gems --groups=style,typecheck
 
-      - name: Install shellcheck
-        run: brew install shellcheck
+      - name: Install shellcheck and shfmt
+        run: brew install shellcheck shfmt
+
+      - name: Cache style cache
+        uses: actions/cache@6849a6489940f00c2f30c0fb92c6274307ccb58a # v4
+        with:
+          path: ~/.cache/Homebrew/style
+          key: syntax-style-cache-${{ github.sha }}
+          restore-keys: syntax-style-cache-
 
-      - run: brew style --display-cop-names
+      - run: brew style
 
       - run: brew typecheck
 
-      - name: Run vale for docs linting
+      - name: Check RuboCop filepaths
+        working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}/Library/Homebrew
         run: |
-          brew install vale
-          vale docs/
+          public_apis="$(git grep -l "@api public" -- :^sorbet/ :^vendor/ | sort)"
+          rubocop_docs="$(yq '.Style/Documentation.Include[]' .rubocop.yml | sort)"
+
+          if [[ "${public_apis}" != "${rubocop_docs}" ]]; then
+            echo "All public Homebrew APIs should be included in the \`Style/Documentation\` RuboCop."
+            echo "Add/remove the following paths from \`Library/Homebrew/.rubocop.yml\` as appropriate:"
+            echo "${public_apis} ${rubocop_docs}" | tr ' ' '\n' | sort | uniq -u
+
+            exit 1
+          fi
 
   tap-syntax:
-    name: tap syntax (Linux)
+    name: tap syntax
     needs: syntax
-    if: startsWith(github.repository, 'Homebrew/')
-    runs-on: ubuntu-latest
+    if: github.repository_owner == 'Homebrew'
+    runs-on: macos-14
     steps:
       - name: Set up Homebrew
         id: set-up-homebrew
         uses: Homebrew/actions/setup-homebrew@master
-
-      - run: brew test-bot --only-cleanup-before
-
-      - run: brew config
+        with:
+          core: true
+          cask: true
+          test-bot: true
 
       - name: Cache Bundler RubyGems
-        uses: actions/cache@v1
+        uses: actions/cache@6849a6489940f00c2f30c0fb92c6274307ccb58a # v4
         with:
           path: ${{ steps.set-up-homebrew.outputs.gems-path }}
-          key: ${{ runner.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }}
-          restore-keys: ${{ runner.os }}-rubygems-
+          key: ${{ runner.os }}-rubygems-tap-syntax-${{ steps.set-up-homebrew.outputs.gems-hash }}
+          restore-keys: ${{ runner.os }}-rubygems-tap-syntax-
 
       - name: Install Bundler RubyGems
-        run: brew install-bundler-gems --groups=sorbet
-
-      - run: brew doctor
-
-      - name: Run brew update-tests
-        if: github.event_name == 'pull_request'
-        run: |
-          brew update-test
-          brew update-test --to-tag
-          brew update-test --commit=HEAD
-
-      - name: Run brew readall on all taps
-        run: brew readall --aliases
+        run: brew install-bundler-gems --groups=style
 
-      - name: Run brew style on homebrew-core for Linux
-        run: brew style --display-cop-names homebrew/core
+      - name: Cache style cache
+        uses: actions/cache@6849a6489940f00c2f30c0fb92c6274307ccb58a # v4
+        with:
+          path: ~/.cache/Homebrew/style
+          key: tap-syntax-style-cache-${{ github.sha }}
+          restore-keys: tap-syntax-style-cache-
 
-      - name: Run brew audit --skip-style on all taps
-        run: brew audit --skip-style --except=version --display-failures-only
+      - name: Run brew style on homebrew-core
+        run: brew style homebrew/core
 
       - name: Set up all Homebrew taps
         run: |
-          HOMEBREW_REPOSITORY="$(brew --repo)"
-          HOMEBREW_CORE_REPOSITORY="${HOMEBREW_REPOSITORY}/Library/Taps/homebrew/homebrew-core"
-          git -C "${HOMEBREW_CORE_REPOSITORY}" remote add homebrew_core https://github.com/Homebrew/homebrew-core
-          git -C "${HOMEBREW_CORE_REPOSITORY}" fetch homebrew_core || git -C "${HOMEBREW_CORE_REPOSITORY}" fetch homebrew_core
-          git -C "${HOMEBREW_CORE_REPOSITORY}" checkout --force -B master homebrew_core/master
-
           brew tap homebrew/aliases
-          brew tap homebrew/autoupdate
           brew tap homebrew/bundle
-          brew tap homebrew/cask
-          brew tap homebrew/cask-drivers
-          brew tap homebrew/cask-fonts
-          brew tap homebrew/cask-versions
           brew tap homebrew/command-not-found
           brew tap homebrew/formula-analytics
           brew tap homebrew/portable-ruby
           brew tap homebrew/services
 
-          brew update-reset Library/Taps/homebrew/homebrew-bundle
-
           # brew style doesn't like world writable directories
-          sudo chmod -R g-w,o-w "${HOMEBREW_REPOSITORY}/Library/Taps"
+          sudo chmod -R g-w,o-w "$(brew --repo)/Library/Taps"
 
-      - name: Run brew style on homebrew-core for macOS
-        run: brew style --display-cop-names homebrew/core
-        env:
-          HOMEBREW_SIMULATE_MACOS_ON_LINUX: 1
+      - name: Run brew style on official taps
+        run: |
+          brew style homebrew/bundle \
+                     homebrew/services \
+                     homebrew/test-bot
 
-      - name: Run brew audit --skip-style on homebrew-core for macOS
-        run: brew audit --skip-style --except=version --tap=homebrew/core
-        env:
-          HOMEBREW_SIMULATE_MACOS_ON_LINUX: 1
+          brew style homebrew/aliases \
+                     homebrew/command-not-found \
+                     homebrew/formula-analytics \
+                     homebrew/portable-ruby
 
-      - name: Run brew style on official taps
+      - name: Run brew style on homebrew/cask
         run: |
-          brew style --display-cop-names homebrew/bundle \
-                                         homebrew/services \
-                                         homebrew/test-bot
+          brew style homebrew/cask
 
-          brew style --display-cop-names homebrew/aliases\
-                                         homebrew/autoupdate\
-                                         homebrew/command-not-found \
-                                         homebrew/formula-analytics \
-                                         homebrew/portable-ruby
+  formula-audit:
+    name: formula audit
+    needs: syntax
+    if: github.repository_owner == 'Homebrew'
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/homebrew/brew:master
+    steps:
+      - name: Set up Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: true
+          cask: false
+          test-bot: false
 
-      - name: Run brew style on cask taps
+      - name: Run brew readall on homebrew/core
+        run: brew readall --os=all --arch=all --aliases homebrew/core
+
+      - name: Run brew audit --skip-style on homebrew/core
+        run: brew audit --skip-style --except=version --tap=homebrew/core
+
+      - name: Generate formula API
+        run: brew generate-formula-api --dry-run
+
+  cask-audit:
+    name: cask audit
+    needs: syntax
+    if: github.repository_owner == 'Homebrew'
+    runs-on: macos-15
+    steps:
+      - name: Set up Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: true
+          cask: true
+          test-bot: false
+
+      - name: Run brew readall on all casks
+        run: brew readall --os=all --arch=all homebrew/cask
+
+      - name: Run brew audit --skip-style on homebrew/cask
         run: |
-          brew style --display-cop-names homebrew/cask \
-                                         homebrew/cask-drivers \
-                                         homebrew/cask-fonts \
-                                         homebrew/cask-versions
+          brew audit --skip-style --except=version --tap=homebrew/cask
+
+      - name: Generate formula API
+        run: brew generate-formula-api --dry-run
+
+      - name: Generate cask API
+        run: brew generate-cask-api --dry-run
 
   vendored-gems:
-    name: vendored gems (Linux)
-    runs-on: ubuntu-latest
+    name: vendored gems
+    needs: syntax
+    runs-on: ubuntu-22.04
     steps:
       - name: Set up Homebrew
         id: set-up-homebrew
         uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: false
 
       - name: Configure Git user
         uses: Homebrew/actions/git-user-config@master
@@ -160,173 +211,138 @@ jobs:
       # Can't cache this because we need to check that it doesn't fail the
       # "uncommitted RubyGems" step with a cold cache.
       - name: Install Bundler RubyGems
-        run: brew install-bundler-gems --groups=sorbet
+        run: brew install-bundler-gems --groups=all
 
       - name: Check for uncommitted RubyGems
+        working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
         run: git diff --stat --exit-code Library/Homebrew/vendor/bundle/ruby
 
-  docker:
+  update-test:
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.runs-on }}
     needs: syntax
-    runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request' || github.event_name == 'merge_group'
+    strategy:
+      matrix:
+        include:
+          - name: update-test (Ubuntu 22.04)
+            runs-on: ubuntu-22.04
+          - name: update-test (macOS)
+            runs-on: macos-15
     steps:
       - name: Set up Homebrew
         id: set-up-homebrew
         uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: false
 
-      - name: Build Docker image
-        run: docker build -t brew --build-arg=version=16.04 .
-
-      - name: Deploy the Docker image to GitHub Packages and Docker Hub
-        if: github.ref == 'refs/heads/master'
+      - name: Run brew update-tests
         run: |
-          echo ${{secrets.HOMEBREW_BREW_GITHUB_PACKAGES_TOKEN}} |
-            docker login ghcr.io -u BrewTestBot --password-stdin
-          docker tag brew "ghcr.io/homebrew/ubuntu16.04:master"
-          docker push "ghcr.io/homebrew/ubuntu16.04:master"
-          echo ${{secrets.HOMEBREW_BREW_DOCKER_TOKEN}} |
-            docker login -u brewtestbot --password-stdin
-          docker tag brew "homebrew/ubuntu16.04:master"
-          docker push "homebrew/ubuntu16.04:master"
+          brew update-test
+          brew update-test --to-tag
+          brew update-test --commit=HEAD
 
   tests:
     name: ${{ matrix.name }}
     needs: syntax
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.runs-on }}
     strategy:
       matrix:
         include:
-          - name: tests (no-compatibility mode)
-            test-flags: --no-compat --online --coverage
-          - name: tests (generic OS)
-            test-flags: --generic --online --coverage
-          - name: tests (Linux)
+          - name: tests (online)
             test-flags: --online --coverage
+            runs-on: ubuntu-latest
+          - name: tests (generic OS)
+            test-flags: --generic --coverage
+            runs-on: ubuntu-latest
+          - name: tests (Ubuntu 22.04)
+            test-flags: --coverage
+            runs-on: ubuntu-22.04
+          - name: tests (Ubuntu 20.04)
+            test-flags: --coverage
+            runs-on: ubuntu-20.04
+          - name: tests (macOS 13 x86_64)
+            test-flags: --coverage
+            runs-on: macos-13
+          - name: tests (macOS 15 arm64)
+            test-flags: --coverage
+            runs-on: macos-15
     steps:
       - name: Set up Homebrew
         id: set-up-homebrew
         uses: Homebrew/actions/setup-homebrew@master
+        with:
+          # We only test needs_homebrew_core tests on macOS because
+          # homebrew/core is not available by default on GitHub-hosted Ubuntu
+          # runners, and it's expensive to tap it.
+          core: ${{ runner.os == 'macOS' }}
+          cask: false
+          test-bot: false
 
       - name: Cache Bundler RubyGems
-        uses: actions/cache@v1
+        uses: actions/cache@6849a6489940f00c2f30c0fb92c6274307ccb58a # v4
         with:
           path: ${{ steps.set-up-homebrew.outputs.gems-path }}
-          key: ${{ runner.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }}
-          restore-keys: ${{ runner.os }}-rubygems-
+          key: ${{ matrix.runs-on }}-tests-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }}
+          restore-keys: ${{ matrix.runs-on }}-tests-rubygems-
+
+      - run: brew config
 
       - name: Install Bundler RubyGems
-        run: brew install-bundler-gems --groups=sorbet
+        run: brew install-bundler-gems --groups=all
 
       - name: Create parallel test log directory
         run: mkdir tests
 
       - name: Cache parallel tests log
-        uses: actions/cache@v1
+        uses: actions/cache@6849a6489940f00c2f30c0fb92c6274307ccb58a # v4
         with:
           path: tests
           key: ${{ runner.os }}-${{ matrix.test-flags }}-parallel_runtime_rspec-${{ github.sha }}
           restore-keys: ${{ runner.os }}-${{ matrix.test-flags }}-parallel_runtime_rspec-
 
       - name: Install brew tests dependencies
-        run: brew install curl
-
-      - name: Run brew tests
-        run: |
-          # brew tests doesn't like world writable directories
-          sudo chmod -R g-w,o-w /home/linuxbrew/.linuxbrew/Homebrew
+        if: matrix.name != 'tests (generic OS)'
+        run: brew install buildpulse-test-reporter
 
-          brew tests ${{ matrix.test-flags }}
-        env:
-          HOMEBREW_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378
-        with:
-          files: Library/Homebrew/test/coverage/coverage.xml
-
-  test-default-formula-linux:
-    name: test default formula (Linux)
-    runs-on: ubuntu-latest
-    env:
-      HOMEBREW_BOOTSNAP: 1
-    steps:
-      - name: Set up Homebrew
-        id: set-up-homebrew
-        uses: Homebrew/actions/setup-homebrew@master
-
-      - run: brew test-bot --only-cleanup-before
-
-      - run: brew test-bot --only-formulae --only-json-tab --test-default-formula
-
-  test-everything:
-    name: test everything (macOS)
-    needs: syntax
-    if: startsWith(github.repository, 'Homebrew/')
-    runs-on: macos-latest
-    env:
-      HOMEBREW_BOOTSNAP: 1
-    steps:
-      - name: Set up Homebrew
-        id: set-up-homebrew
-        uses: Homebrew/actions/setup-homebrew@master
-
-      - run: brew test-bot --only-cleanup-before
-
-      - run: brew config
-
-      # Can't cache this because we need to check that it doesn't fail the
-      # "uncommitted RubyGems" step with a cold cache.
-      - name: Install Bundler RubyGems
-        run: brew install-bundler-gems --groups=sorbet
-
-      - name: Check for uncommitted RubyGems
-        run: git diff --stat --exit-code Library/Homebrew/vendor/bundle/ruby
-
-      - run: brew doctor
-
-      - name: Run brew update-tests
-        if: github.event_name == 'pull_request'
-        run: |
-          brew update-test
-          brew update-test --to-tag
-          brew update-test --commit=HEAD
-
-      - name: Set up all Homebrew taps
-        run: |
-          brew tap homebrew/cask
-          brew tap homebrew/cask-drivers
-          brew tap homebrew/cask-fonts
-          brew tap homebrew/cask-versions
-          brew update-reset Library/Taps/homebrew/homebrew-bundle \
-                            Library/Taps/homebrew/homebrew-cask \
-                            Library/Taps/homebrew/homebrew-cask-versions \
-                            Library/Taps/homebrew/homebrew-services
-
-      - name: Run brew readall on all taps
-        run: brew readall --aliases
-
-      - name: Install brew tests dependencies
+      - name: Install brew tests --online dependencies
+        if: matrix.name == 'tests (online)'
         run: brew install subversion curl
 
-      - name: Create parallel test log directory
-        run: mkdir tests
+      - name: Install brew tests macOS dependencies
+        if: runner.os != 'Linux'
+        run: |
+          # Workaround GitHub Actions Python issues
+          brew unlink python && brew link --overwrite python
+          brew install subversion
 
-      - name: Cache parallel tests log
-        uses: actions/cache@v1
-        with:
-          path: tests
-          key: ${{ runner.os }}-parallel_runtime_rspec-${{ github.sha }}
-          restore-keys: ${{ runner.os }}-parallel_runtime_rspec-
+        # brew tests doesn't like world writable directories
+      - name: Cleanup permissions
+        if: runner.os == 'Linux'
+        run: sudo chmod -R g-w,o-w /home/linuxbrew/.linuxbrew/Homebrew
 
       - name: Run brew tests
+        if: github.event_name == 'pull_request' || matrix.name != 'tests (online)'
         run: |
+          # brew tests
+
+          # Don't attempt to use BuildPulse for generic tests.
+          # Fails for no apparent reason.
+          if [[ "${{ matrix.name }}" =~ "generic" ]]
+          then
+            unset HOMEBREW_BUILDPULSE_ACCESS_KEY_ID
+          fi
+
           # Retry multiple times when using BuildPulse to detect and submit
           # flakiness (because rspec-retry is disabled).
-          if [[ -n "${HOMEBREW_BUILDPULSE_ACCESS_KEY_ID}" ]]
+          if [[ -n "${HOMEBREW_BUILDPULSE_ACCESS_KEY_ID-}" ]]
           then
-            brew tests --online --coverage ||
-            brew tests --online --coverage ||
-            brew tests --online --coverage
+            brew tests ${{ matrix.test-flags }} ||
+            brew tests ${{ matrix.test-flags }}
           else
-            brew tests --online --coverage
+            brew tests ${{ matrix.test-flags }}
           fi
         env:
           HOMEBREW_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -337,8 +353,48 @@ jobs:
           HOMEBREW_BUILDPULSE_ACCOUNT_ID: 1503512
           HOMEBREW_BUILDPULSE_REPOSITORY_ID: 53238813
 
-      - run: brew test-bot --only-formulae --test-default-formula
-
-      - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378
+      - uses: codecov/codecov-action@b9fd7d16f6d7d1b5d2bec1a2887e65ceed900238 # v4.6.0
         with:
+          working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
           files: Library/Homebrew/test/coverage/coverage.xml
+          disable_search: true
+          token: ${{ secrets.CODECOV_TOKEN }}
+
+  test-default-formula:
+    name: ${{ matrix.name }}
+    needs: syntax
+    if: github.repository_owner == 'Homebrew'
+    runs-on: ${{ matrix.runs-on }}
+    container: ${{ matrix.container }}
+    strategy:
+      matrix:
+        include:
+          - name: test default formula (Ubuntu 22.04)
+            runs-on: ubuntu-latest
+            container: ghcr.io/homebrew/ubuntu22.04:master
+          - name: test default formula (Ubuntu 20.04)
+            runs-on: ubuntu-latest
+            container: ghcr.io/homebrew/ubuntu20.04
+          - name: test default formula (macOS 13 x86_64)
+            runs-on: macos-13
+          - name: test default formula (macOS 15 arm64)
+            runs-on: macos-15
+    env:
+      HOMEBREW_TEST_BOT_ANALYTICS: 1
+      HOMEBREW_ENFORCE_SBOM: 1
+    steps:
+      - name: Set up Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: true
+          cask: false
+          test-bot: true
+
+      - run: brew test-bot --only-cleanup-before
+
+      - run: brew test-bot --only-setup
+
+      - run: brew install gnu-tar
+
+      - run: brew test-bot --only-formulae --only-json-tab --test-default-formula
diff --git a/.github/workflows/triage-issues.yml b/.github/workflows/triage-issues.yml
deleted file mode 100644
index 7963be268822d..0000000000000
--- a/.github/workflows/triage-issues.yml
+++ /dev/null
@@ -1,84 +0,0 @@
-# This file is synced from the `.github` repository, do not modify it directly.
-name: Triage issues
-
-on:
-  push:
-    paths:
-      - .github/workflows/triage-issues.yml
-    branches-ignore:
-      - dependabot/**
-  schedule:
-    # Once every day at midnight UTC
-    - cron: "0 0 * * *"
-  issue_comment:
-
-permissions:
-  issues: write
-  pull-requests: write
-
-concurrency:
-  group: triage-issues
-  cancel-in-progress: ${{ github.event_name != 'issue_comment' }}
-
-jobs:
-  stale:
-    if: >
-      startsWith(github.repository, 'Homebrew/') && (
-        github.event_name != 'issue_comment' || (
-          contains(github.event.issue.labels.*.name, 'stale') ||
-          contains(github.event.pull_request.labels.*.name, 'stale')
-        )
-      )
-    runs-on: ubuntu-latest
-    steps:
-      - name: Mark/Close Stale Issues and Pull Requests
-        uses: actions/stale@v5
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          days-before-stale: 21
-          days-before-close: 7
-          close-issue-reason: "not_planned"
-          stale-issue-message: >
-            This issue has been automatically marked as stale because it has not had
-            recent activity. It will be closed if no further activity occurs.
-          stale-pr-message: >
-            This pull request has been automatically marked as stale because it has not had
-            recent activity. It will be closed if no further activity occurs.
-          exempt-issue-labels: "gsoc-outreachy,help wanted,in progress"
-          exempt-pr-labels: "gsoc-outreachy,help wanted,in progress"
-
-  bump-pr-stale:
-    if: >
-      startsWith(github.repository, 'Homebrew/') && (
-        github.event_name != 'issue_comment' || (
-          contains(github.event.issue.labels.*.name, 'stale') ||
-          contains(github.event.pull_request.labels.*.name, 'stale')
-        )
-      )
-    runs-on: ubuntu-latest
-    steps:
-      - name: Mark/Close Stale `bump-formula-pr` and `bump-cask-pr` Pull Requests
-        uses: actions/stale@v5
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          days-before-stale: 2
-          days-before-close: 1
-          stale-pr-message: >
-            This pull request has been automatically marked as stale because it has not had
-            recent activity. It will be closed if no further activity occurs. To keep this
-            pull request open, add a `help wanted` or `in progress` label.
-          exempt-pr-labels: "help wanted,in progress"
-          any-of-labels: "bump-formula-pr,bump-cask-pr"
-
-  lock-threads:
-    if: startsWith(github.repository, 'Homebrew/') && github.event_name != 'issue_comment'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Lock Outdated Threads
-        uses: dessant/lock-threads@e460dfeb36e731f3aeb214be6b0c9a9d9a67eda6
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          issue-inactive-days: 30
-          add-issue-labels: outdated
-          pr-inactive-days: 30
-          add-pr-labels: outdated
diff --git a/.github/workflows/triage.yml b/.github/workflows/triage.yml
deleted file mode 100644
index 2ef2939e34309..0000000000000
--- a/.github/workflows/triage.yml
+++ /dev/null
@@ -1,212 +0,0 @@
-name: Triage
-
-on:
-  pull_request_target:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - closed
-      - labeled
-      - unlabeled
-  schedule:
-    - cron: "0 */3 * * *" # every 3 hours
-
-permissions: {}
-
-concurrency: triage-${{ github.head_ref }}
-
-jobs:
-  review:
-    runs-on: ubuntu-latest
-    if: startsWith(github.repository, 'Homebrew/')
-    steps:
-      - name: Re-run this workflow
-        if: github.event_name == 'schedule' || github.event.action == 'closed'
-        uses: reitermarkus/rerun-workflow@c8d5bc3526acb50c12004f31c0dcb1598c87e32d
-        with:
-          token: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
-          continuous-label: waiting for feedback
-          trigger-labels: critical
-          workflow: triage.yml
-      - name: Review pull request
-        if: >
-          (github.event_name == 'pull_request' || github.event_name == 'pull_request_target') &&
-            github.event.action != 'closed' && github.event.pull_request.state != 'closed'
-        uses: actions/github-script@v6
-        with:
-          github-token: ${{ secrets.HOMEBREW_BREW_TRIAGE_PULL_REQUESTS_TOKEN }}
-          script: |
-            async function approvePullRequest(pullRequestNumber) {
-              const reviews = await approvalsByAuthenticatedUser(pullRequestNumber)
-
-              if (reviews.length > 0) {
-                return
-              }
-
-              await github.rest.pulls.createReview({
-                ...context.repo,
-                pull_number: pullRequestNumber,
-                event: 'APPROVE',
-              })
-            }
-
-            async function findComment(pullRequestNumber, id) {
-              const { data: comments } = await github.rest.issues.listComments({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: pullRequestNumber,
-              })
-
-              const regex = new RegExp(`<!--\\s*#${id}\\s*-->`)
-              return comments.filter(comment => comment.body.match(regex))[0]
-            }
-
-            async function createOrUpdateComment(pullRequestNumber, id, message) {
-              const beginComment = await findComment(pullRequestNumber, id)
-
-              const body = `<!-- #${id} -->\n\n${message}`
-              if (beginComment) {
-                await github.rest.issues.updateComment({
-                  ...context.repo,
-                  comment_id: beginComment.id,
-                  body,
-                })
-              } else {
-                await github.rest.issues.createComment({
-                  ...context.repo,
-                  issue_number: pullRequestNumber,
-                  body,
-                })
-              }
-            }
-
-            async function approvalsByAuthenticatedUser(pullRequestNumber) {
-              const { data: user } = await github.rest.users.getAuthenticated()
-
-              const { data: reviews } = await github.rest.pulls.listReviews({
-                ...context.repo,
-                pull_number: pullRequestNumber,
-              })
-
-              const approvals = reviews.filter(review => review.state == 'APPROVED')
-              return approvals.filter(review => review.user.login == user.login)
-            }
-
-            async function dismissApprovals(pullRequestNumber, message) {
-              const reviews = await approvalsByAuthenticatedUser(pullRequestNumber)
-              for (const review of reviews) {
-                await github.rest.pulls.dismissReview({
-                  ...context.repo,
-                  pull_number: pullRequestNumber,
-                  review_id: review.id,
-                  message: message
-                });
-              }
-            }
-
-            function offsetDate(start, offsetHours, skippedDays) {
-              let end = new Date(start)
-
-              end.setUTCHours(end.getUTCHours() + (offsetHours % 24))
-
-              while (skippedDays.includes(end.getUTCDay()) || offsetHours >= 24) {
-                if (!skippedDays.includes(end.getUTCDay())) {
-                  offsetHours -= 24
-                }
-
-                end.setUTCDate(end.getUTCDate() + 1)
-              }
-
-              if (skippedDays.includes(start.getUTCDay())) {
-                end.setUTCHours(offsetHours, 0, 0)
-              }
-
-              return end
-            }
-
-            function formatDate(date) {
-              return date.toISOString().replace(/\.\d+Z$/, ' UTC').replace('T', ' at ')
-            }
-
-            async function reviewPullRequest(pullRequestNumber) {
-              const { data: pullRequest } = await github.rest.pulls.get({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                pull_number: pullRequestNumber,
-              })
-
-              const { data: user } = await github.rest.users.getAuthenticated()
-              if (pullRequest.user.login == user.login) {
-                core.warning('Pull request author is a bot.')
-                return
-              }
-
-              if (pullRequest.author_association != 'MEMBER') {
-                core.warning('Pull request author is not a member.')
-                return
-              }
-
-              const reviewLabel = 'waiting for feedback'
-              const criticalLabel = 'critical'
-
-              const labels = pullRequest.labels.map(label => label.name)
-              const hasReviewLabel = labels.includes(reviewLabel)
-              const hasCriticalLabel = labels.includes(criticalLabel)
-
-              const offsetHours = 24
-              const skippedDays = [
-                6, // Saturday
-                0, // Sunday
-              ]
-
-              const currentDate = new Date()
-              const reviewStartDate = new Date(pullRequest.created_at)
-              const reviewEndDate = offsetDate(reviewStartDate, offsetHours, skippedDays)
-              const reviewEnded = currentDate > reviewEndDate
-
-              if (reviewEnded || hasCriticalLabel) {
-                let message
-                if (hasCriticalLabel && !reviewEnded) {
-                  message = `Review period skipped due to \`${criticalLabel}\` label.`
-                } else {
-                  message = 'Review period ended.'
-                }
-
-                if (hasReviewLabel) {
-                  await github.rest.issues.removeLabel({
-                    ...context.repo,
-                    issue_number: pullRequestNumber,
-                    name: reviewLabel,
-                  })
-                }
-
-                core.info(message)
-                await createOrUpdateComment(pullRequestNumber, 'review-period-end', message)
-                await approvePullRequest(pullRequestNumber)
-              } else {
-                const message = `Review period will end on ${formatDate(reviewEndDate)}.`
-                core.info(message)
-
-                await dismissApprovals(pullRequestNumber, 'Review period has not ended yet.')
-                await createOrUpdateComment(pullRequestNumber, 'review-period-begin', message)
-
-                const endComment = await findComment(pullRequestNumber, 'review-period-end')
-                if (endComment) {
-                  await github.rest.issues.deleteComment({
-                    ...context.repo,
-                    comment_id: endComment.id,
-                  })
-                }
-
-                await github.rest.issues.addLabels({
-                  ...context.repo,
-                  issue_number: pullRequestNumber,
-                  labels: [reviewLabel],
-                })
-
-                core.setFailed('Review period has not ended yet.')
-              }
-            }
-
-            await reviewPullRequest(context.issue.number)
diff --git a/.github/workflows/update-man-completions.yml b/.github/workflows/update-man-completions.yml
deleted file mode 100644
index 548d63be6e881..0000000000000
--- a/.github/workflows/update-man-completions.yml
+++ /dev/null
@@ -1,96 +0,0 @@
-name: Update maintainers, manpage and completions
-
-on:
-  push:
-    paths:
-      - .github/workflows/update-man-completions.yml
-      - README.md
-      - Library/Homebrew/cmd/**
-      - Library/Homebrew/dev-cmd/**
-      - Library/Homebrew/completions/**
-      - Library/Homebrew/manpages/**
-      - Library/Homebrew/cli/parser.rb
-      - Library/Homebrew/completions.rb
-      - Library/Homebrew/env_config.rb
-    branches:
-      - master
-  schedule:
-    - cron: "0 0 * * *"
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  update-manpage:
-    runs-on: ubuntu-latest
-    if: github.repository == 'Homebrew/brew'
-    steps:
-      - name: Setup Homebrew
-        uses: Homebrew/actions/setup-homebrew@master
-
-      - name: Configure Git user
-        uses: Homebrew/actions/git-user-config@master
-        with:
-          username: BrewTestBot
-
-      - name: Set up commit signing
-        uses: Homebrew/actions/setup-commit-signing@master
-        with:
-          signing_key: ${{ secrets.BREWTESTBOT_GPG_SIGNING_SUBKEY }}
-
-      - name: Update maintainers, manpage and completions
-        id: update
-        run: |
-          git fetch origin
-
-          BRANCH=update-man-completions
-          echo "::set-output name=branch::${BRANCH}"
-
-          if git ls-remote --exit-code --heads origin "${BRANCH}"
-          then
-            git checkout "${BRANCH}"
-            git reset --hard origin/master
-          else
-            git checkout --no-track -B "${BRANCH}" origin/master
-          fi
-
-          if [[ "${{github.event_name}}" != "push" ]]
-          then
-            brew update-maintainers
-          fi
-
-          if brew generate-man-completions --fail-if-not-changed
-          then
-            git add "${GITHUB_WORKSPACE}/README.md" \
-                    "${GITHUB_WORKSPACE}/docs/Manpage.md" \
-                    "${GITHUB_WORKSPACE}/manpages/brew.1" \
-                    "${GITHUB_WORKSPACE}/completions"
-            git commit -m "Update maintainers, manpage and completions." \
-                       -m "Autogenerated by the [update-man-completions](https://github.com/Homebrew/brew/blob/HEAD/.github/workflows/update-man-completions.yml) workflow."
-            echo "::set-output name=committed::true"
-            PULL_REQUEST_STATE="$(gh pr view --json=state | jq -r ".state")"
-            if [[ "${PULL_REQUEST_STATE}" != "OPEN" ]]
-            then
-              echo "::set-output name=pull_request::true"
-            fi
-          fi
-        env:
-          GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
-          HOMEBREW_GITHUB_API_TOKEN: ${{ secrets.HOMEBREW_BREW_UPDATE_MAINTAINERS_TOKEN }}
-          HOMEBREW_GPG_PASSPHRASE: ${{ secrets.BREWTESTBOT_GPG_SIGNING_SUBKEY_PASSPHRASE }}
-
-      - name: Push commits
-        if: steps.update.outputs.committed == 'true'
-        uses: Homebrew/actions/git-try-push@master
-        with:
-          token: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
-          branch: ${{ steps.update.outputs.branch }}
-          force: true
-          origin_branch: "master"
-
-      - name: Open a pull request
-        if: steps.update.outputs.pull_request == 'true'
-        run: hub pull-request --no-edit
-        env:
-          GITHUB_TOKEN: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
diff --git a/.github/workflows/vendor-gems.yml b/.github/workflows/vendor-gems.yml
index bbe11aeab80cb..649d45bab6e44 100644
--- a/.github/workflows/vendor-gems.yml
+++ b/.github/workflows/vendor-gems.yml
@@ -1,7 +1,15 @@
 name: Vendor Gems
 
 on:
-  pull_request_target:
+  pull_request:
+    paths:
+      - Library/Homebrew/dev-cmd/vendor-gems.rb
+      - Library/Homebrew/Gemfile*
+  push:
+    paths:
+      - .github/workflows/vendor-gems.yml
+    branches-ignore:
+      - master
   workflow_dispatch:
     inputs:
       pull_request:
@@ -12,69 +20,92 @@ permissions:
   contents: read
   pull-requests: read
 
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
+
 jobs:
   vendor-gems:
-    if: >
-      startsWith(github.repository, 'Homebrew/') && (
-        github.event_name == 'workflow_dispatch' || (
-          github.event.pull_request.user.login == 'dependabot[bot]' &&
-          contains(github.event.pull_request.title, '/Library/Homebrew')
-        )
-      )
-    runs-on: macos-latest
+    if: github.repository_owner == 'Homebrew'
+    runs-on: macos-15
     steps:
       - name: Set up Homebrew
         id: set-up-homebrew
         uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: false
 
       - name: Configure Git user
+        if: github.event_name == 'workflow_dispatch'
         uses: Homebrew/actions/git-user-config@master
         with:
           username: BrewTestBot
 
       - name: Set up commit signing
+        if: github.event_name == 'workflow_dispatch'
         uses: Homebrew/actions/setup-commit-signing@master
         with:
           signing_key: ${{ secrets.BREWTESTBOT_GPG_SIGNING_SUBKEY }}
 
       - name: Check out pull request
         id: checkout
+        if: github.event_name == 'workflow_dispatch'
         run: |
-          gh pr checkout '${{ github.event.pull_request.number || github.event.inputs.pull_request }}'
+          gh pr checkout "${PR}"
 
           branch="$(git branch --show-current)"
-          echo "::set-output name=branch::${branch}"
+          echo "branch=${branch}" >> "$GITHUB_OUTPUT"
 
           gem_name="$(echo "${branch}" | sed -E 's|.*/||;s|(.*)-.*$|\1|')"
-          echo "::set-output name=gem_name::${gem_name}"
+          echo "gem_name=${gem_name}" >> "$GITHUB_OUTPUT"
         env:
+          PR: ${{ github.event.pull_request.number || github.event.inputs.pull_request }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
 
       - name: Vendor Gems
         env:
           HOMEBREW_GPG_PASSPHRASE: ${{ secrets.BREWTESTBOT_GPG_SIGNING_SUBKEY_PASSPHRASE }}
-        run: brew vendor-gems
+        run: |
+          if [[ "${GITHUB_EVENT_NAME}" == "workflow_dispatch" ]]
+          then
+            brew vendor-gems --non-bundler-gems
+          else
+            brew vendor-gems --non-bundler-gems --no-commit
+          fi
 
       - name: Update RBI files
+        run: brew typecheck --update
+
+      - name: Commit RBI changes
+        if: github.event_name == 'workflow_dispatch'
         env:
           GEM_NAME: ${{ steps.checkout.outputs.gem_name }}
           HOMEBREW_GPG_PASSPHRASE: ${{ secrets.BREWTESTBOT_GPG_SIGNING_SUBKEY_PASSPHRASE }}
+        working-directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
         run: |
-          set -u
-
-          if brew typecheck --update --fail-if-not-changed
+          if ! git diff --stat --exit-code "Library/Homebrew/sorbet"
           then
-            if git add Library/Homebrew/sorbet
-            then
-              git commit -m "Update RBI files for ${GEM_NAME}."
-            fi
-
-            git reset --hard
+            git add "Library/Homebrew/sorbet"
+            git commit -m "Update RBI files for ${GEM_NAME}." \
+                       -m "Autogenerated by the [vendor-gems](https://github.com/Homebrew/brew/blob/HEAD/.github/workflows/vendor-gems.yml) workflow."
           fi
 
+      - name: Generate push token
+        uses: actions/create-github-app-token@5d869da34e18e7287c1daad50e0b8ea0f506ce69 # v1
+        id: app-token
+        if: github.event_name == 'workflow_dispatch'
+        with:
+          app-id: ${{ vars.BREW_COMMIT_APP_ID }}
+          private-key: ${{ secrets.BREW_COMMIT_APP_KEY }}
+
       - name: Push to pull request
+        if: github.event_name == 'workflow_dispatch'
         uses: Homebrew/actions/git-try-push@master
         with:
-          token: ${{ secrets.HOMEBREW_GITHUB_PUBLIC_REPO_TOKEN }}
+          token: ${{ steps.app-token.outputs.token }}
+          directory: ${{ steps.set-up-homebrew.outputs.repository-path }}
           branch: ${{ steps.checkout.outputs.branch }}
           force: true
diff --git a/.github/workflows/vendor-version.yml b/.github/workflows/vendor-version.yml
new file mode 100644
index 0000000000000..9ad05652ee82a
--- /dev/null
+++ b/.github/workflows/vendor-version.yml
@@ -0,0 +1,70 @@
+name: Check Vendor Version
+
+on:
+  pull_request:
+    paths:
+      - .github/workflows/vendor-version.yml
+      - Library/Homebrew/vendor/bundle/ruby/**
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    shell: bash -xeuo pipefail {0}
+
+jobs:
+  check-vendor-version:
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Set up Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+        with:
+          core: false
+          cask: false
+          test-bot: false
+
+      - name: Install Bundler RubyGems
+        run: brew install-bundler-gems --groups=all
+
+      - name: Get Ruby ABI version
+        id: ruby-abi
+        run: echo "version=$(brew ruby -e "puts Gem.ruby_api_version")" >> "${GITHUB_OUTPUT}"
+
+      - name: Get gem info
+        id: gem-info
+        working-directory: ${{ steps.set-up-homebrew.outputs.gems-path }}/${{ steps.ruby-abi.outputs.version }}/gems
+        run: |
+          {
+            echo "vendor-version=$(<../.homebrew_vendor_version)"
+            echo "ignored<<EOS"
+            git check-ignore -- *
+            echo "EOS"
+          } >> "${GITHUB_OUTPUT}"
+
+      - name: Compare to base ref
+        working-directory: ${{ steps.set-up-homebrew.outputs.gems-path }}/${{ steps.ruby-abi.outputs.version }}
+        env:
+          VENDOR_VERSION: ${{ steps.gem-info.outputs.vendor-version }}
+          IGNORED_GEMS: ${{ steps.gem-info.outputs.ignored }}
+        run: |
+          git checkout "origin/${GITHUB_BASE_REF}"
+          rm .homebrew_vendor_version
+          brew install-bundler-gems --groups=all
+          if [[ "$(<.homebrew_vendor_version)" == "${VENDOR_VERSION}" ]]; then
+            while IFS= read -r gem; do
+              gem_dir="./gems/${gem}"
+              [[ -d "${gem_dir}" ]] || continue
+              exit_code=0
+              git check-ignore --quiet "${gem_dir}" || exit_code=$?
+              if (( exit_code != 0 )); then
+                if (( exit_code == 1 )); then
+                  echo "::error::VENDOR_VERSION needs bumping in utils/gems.rb" >&2
+                else
+                  echo "::error::git check-ignore failed" >&2
+                fi
+                exit "${exit_code}"
+              fi
+            done <<< "${IGNORED_GEMS}"
+          fi
diff --git a/.gitignore b/.gitignore
index 10401ee27f8bd..065d40a469a7c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,12 +5,13 @@
 .DS_Store
 
 # Unignore the contents of `Library` as that's where our code lives.
-!/Library/
+!/Library
 
 # Ignore files within `Library` (again).
 /Library/Homebrew/.npmignore
 /Library/Homebrew/bin
 /Library/Homebrew/doc
+/Library/Homebrew/prof
 /Library/Homebrew/test/.gem
 /Library/Homebrew/test/.subversion
 /Library/Homebrew/test/coverage
@@ -20,150 +21,131 @@
 /Library/Taps
 /Library/PinnedTaps
 /Library/Homebrew/.byebug_history
-/Library/Homebrew/sorbet/rbi/hidden-definitions/errors.txt
+/Library/Homebrew/test/.rdbg_history
 
 # Ignore Bundler files
 **/.bundle/bin
 **/.bundle/cache
+**/vendor/bundle/ruby/.homebrew_gem_groups
+**/vendor/bundle/ruby/*/.homebrew_vendor_version
 **/vendor/bundle/ruby/*/bundler.lock
 **/vendor/bundle/ruby/*/bin
 **/vendor/bundle/ruby/*/build_info/
 **/vendor/bundle/ruby/*/cache
 **/vendor/bundle/ruby/*/extensions
 **/vendor/bundle/ruby/*/gems/*/*
+**/vendor/bundle/ruby/*/plugins
 **/vendor/bundle/ruby/*/specifications
 
+# Ignore Ruby gems for versions other than we explicitly vendor.
+# Keep this in sync with the list in standalone/init.rb.
+**/vendor/bundle/ruby/*/
+!**/vendor/bundle/ruby/3.3.0/
+
+# Ignore Bundler binary files
+**/vendor/bundle/ruby/*/gems/**/*.bundle
+
 # Ignore YARD files
 **/.yardoc
 
 # Unignore vendored gems
+!**/vendor/bundle/ruby/*/gems/*/*LICENSE*
 !**/vendor/bundle/ruby/*/gems/*/lib
 !**/vendor/bundle/ruby/*/gems/addressable-*/data
 !**/vendor/bundle/ruby/*/gems/public_suffix-*/data
-!**/vendor/bundle/ruby/*/gems/rubocop-performance-*/config
-!**/vendor/bundle/ruby/*/gems/rubocop-rails-*/config
-!**/vendor/bundle/ruby/*/gems/rubocop-rspec-*/config
-!**/vendor/bundle/ruby/*/gems/rubocop-sorbet-*/config
 
 # Ignore partially included gems where we don't need all files
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support.rb
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/all.rb
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/cache.rb
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/cache/
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/concurrency/
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/dependencies.rb
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/dependencies/
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/duration/
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/json.rb
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/json/
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/log_subscriber.rb
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/log_subscriber/
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/messages/
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/multibyte/
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/number_helper.rb
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/number_helper/
-**/vendor/bundle/ruby/*/gems/activesupport-*/lib/active_support/testing/
-**/vendor/bundle/ruby/*/gems/concurrent-ruby-*/lib/atomic/
-**/vendor/bundle/ruby/*/gems/concurrent-ruby-*/lib/atomic_reference/
-**/vendor/bundle/ruby/*/gems/concurrent-ruby-*/lib/collection/
-**/vendor/bundle/ruby/*/gems/concurrent-ruby-*/lib/concern/
-**/vendor/bundle/ruby/*/gems/concurrent-ruby-*/lib/executor/
-**/vendor/bundle/ruby/*/gems/concurrent-ruby-*/lib/synchronization/
-**/vendor/bundle/ruby/*/gems/concurrent-ruby-*/lib/thread_safe/
-**/vendor/bundle/ruby/*/gems/concurrent-ruby-*/lib/utility/
-**/vendor/bundle/ruby/*/gems/concurrent-ruby-*/lib/*/*.jar
-**/vendor/bundle/ruby/*/gems/i18n-*/lib/i18n/tests*
-**/vendor/bundle/ruby/*/gems/mechanize-*/lib/*.rb
-**/vendor/bundle/ruby/*/gems/mechanize-*/lib/mechanize/http/agent.rb
-**/vendor/bundle/ruby/*/gems/mechanize-*/lib/mechanize/http/*auth*.rb
-**/vendor/bundle/ruby/*/gems/mechanize-*/lib/mechanize/c*
-**/vendor/bundle/ruby/*/gems/mechanize-*/lib/mechanize/d*
-**/vendor/bundle/ruby/*/gems/mechanize-*/lib/mechanize/e*
-**/vendor/bundle/ruby/*/gems/mechanize-*/lib/mechanize/f*
-**/vendor/bundle/ruby/*/gems/mechanize-*/lib/mechanize/h*.rb
-**/vendor/bundle/ruby/*/gems/mechanize-*/lib/mechanize/i*
-**/vendor/bundle/ruby/*/gems/mechanize-*/lib/mechanize/p*
-**/vendor/bundle/ruby/*/gems/mechanize-*/lib/mechanize/r*
-**/vendor/bundle/ruby/*/gems/mechanize-*/lib/mechanize/t*
-**/vendor/bundle/ruby/*/gems/mechanize-*/lib/mechanize/u*
-**/vendor/bundle/ruby/*/gems/mechanize-*/lib/mechanize/x*
-**/vendor/bundle/ruby/*/gems/thread_safe-*/lib/thread_safe/util
+**/vendor/gems/mechanize-*/.*
+**/vendor/gems/mechanize-*/*.md
+**/vendor/gems/mechanize-*/*.rdoc
+**/vendor/gems/mechanize-*/*.gemspec
+**/vendor/gems/mechanize-*/Gemfile
+**/vendor/gems/mechanize-*/Rakefile
+**/vendor/gems/mechanize-*/examples/
+**/vendor/gems/mechanize-*/lib/**/*
+!**/vendor/gems/mechanize-*/lib/mechanize/
+!**/vendor/gems/mechanize-*/lib/mechanize/http/
+!**/vendor/gems/mechanize-*/lib/mechanize/http/content_disposition_parser.rb
+!**/vendor/gems/mechanize-*/lib/mechanize/version.rb
+**/vendor/gems/mechanize-*/test/
 
 # Ignore dependencies we don't wish to vendor
 **/vendor/bundle/ruby/*/gems/ast-*/
+**/vendor/bundle/ruby/*/gems/bigdecimal-*/
 **/vendor/bundle/ruby/*/gems/bootsnap-*/
 **/vendor/bundle/ruby/*/gems/bundler-*/
 **/vendor/bundle/ruby/*/gems/byebug-*/
 **/vendor/bundle/ruby/*/gems/coderay-*/
 **/vendor/bundle/ruby/*/gems/colorize-*/
 **/vendor/bundle/ruby/*/gems/commander-*/
-**/vendor/bundle/ruby/*/gems/connection_pool-*/
 **/vendor/bundle/ruby/*/gems/diff-lcs-*/
 **/vendor/bundle/ruby/*/gems/docile-*/
-**/vendor/bundle/ruby/*/gems/domain_name-*/
 **/vendor/bundle/ruby/*/gems/ecma-re-validator-*/
+**/vendor/bundle/ruby/*/gems/erubi-*/
 **/vendor/bundle/ruby/*/gems/hana-*/
 **/vendor/bundle/ruby/*/gems/highline-*/
-**/vendor/bundle/ruby/*/gems/http-cookie-*/
-**/vendor/bundle/ruby/*/gems/hpricot-*/
 **/vendor/bundle/ruby/*/gems/jaro_winkler-*/
 **/vendor/bundle/ruby/*/gems/json-*/
 **/vendor/bundle/ruby/*/gems/json_schemer-*/
+**/vendor/bundle/ruby/*/gems/kramdown-*/
+**/vendor/bundle/ruby/*/gems/language_server-protocol-*/
+**/vendor/bundle/ruby/*/gems/logger-*/
 **/vendor/bundle/ruby/*/gems/method_source-*/
-**/vendor/bundle/ruby/*/gems/mime-types-data-*/
-**/vendor/bundle/ruby/*/gems/mime-types-*/
 **/vendor/bundle/ruby/*/gems/mini_portile2-*/
 **/vendor/bundle/ruby/*/gems/minitest-*/
 **/vendor/bundle/ruby/*/gems/msgpack-*/
-**/vendor/bundle/ruby/*/gems/mustache-*/
-**/vendor/bundle/ruby/*/gems/net-http-digest_auth-*/
-**/vendor/bundle/ruby/*/gems/net-http-persistent-*/
-**/vendor/bundle/ruby/*/gems/nokogiri-*/
+**/vendor/bundle/ruby/*/gems/netrc-*/
 **/vendor/bundle/ruby/*/gems/ntlm-http-*/
 **/vendor/bundle/ruby/*/gems/parallel-*/
 **/vendor/bundle/ruby/*/gems/parallel_tests-*/
 **/vendor/bundle/ruby/*/gems/parlour-*/
 **/vendor/bundle/ruby/*/gems/parser-*/
 **/vendor/bundle/ruby/*/gems/powerpack-*/
+**/vendor/bundle/ruby/*/gems/prettier_print-*/
+**/vendor/bundle/ruby/*/gems/prism-*/
 **/vendor/bundle/ruby/*/gems/psych-*/
 **/vendor/bundle/ruby/*/gems/pry-*/
 **/vendor/bundle/ruby/*/gems/racc-*/
 **/vendor/bundle/ruby/*/gems/rainbow-*/
 **/vendor/bundle/ruby/*/gems/rbi-*/
-**/vendor/bundle/ruby/*/gems/rdiscount-*/
+**/vendor/bundle/ruby/*/gems/rbs-*/
+**/vendor/bundle/ruby/*/gems/rdoc-*/
+**/vendor/bundle/ruby/*/gems/redcarpet-*/
 **/vendor/bundle/ruby/*/gems/regexp_parser-*/
 **/vendor/bundle/ruby/*/gems/rexml-*/
-**/vendor/bundle/ruby/*/gems/ronn-*/
 **/vendor/bundle/ruby/*/gems/rspec-*/
 **/vendor/bundle/ruby/*/gems/rspec-core-*/
 **/vendor/bundle/ruby/*/gems/rspec-expectations-*/
 **/vendor/bundle/ruby/*/gems/rspec_junit_formatter-*/
-**/vendor/bundle/ruby/*/gems/rspec-its-*/
 **/vendor/bundle/ruby/*/gems/rspec-mocks-*/
 **/vendor/bundle/ruby/*/gems/rspec-retry-*/
 **/vendor/bundle/ruby/*/gems/rspec-support-*/
 **/vendor/bundle/ruby/*/gems/rspec-sorbet-*/
-**/vendor/bundle/ruby/*/gems/rspec-wait-*/
-**/vendor/bundle/ruby/*/gems/rubocop-1*/
-**/vendor/bundle/ruby/*/gems/rubocop-ast-*/
+**/vendor/bundle/ruby/*/gems/rubocop-*/
+**/vendor/bundle/ruby/*/gems/ruby-lsp-*/
 **/vendor/bundle/ruby/*/gems/ruby-prof-*/
+**/vendor/bundle/ruby/*/gems/ruby-progressbar-*/
 **/vendor/bundle/ruby/*/gems/simplecov-*/
 **/vendor/bundle/ruby/*/gems/simplecov-html-*/
+**/vendor/bundle/ruby/*/gems/simplecov_json_formatter-*/
+**/vendor/bundle/ruby/*/gems/simpleidn-*/
 **/vendor/bundle/ruby/*/gems/sorbet-*/
 !**/vendor/bundle/ruby/*/gems/sorbet-runtime-*/
 **/vendor/bundle/ruby/*/gems/spoom-*/
 **/vendor/bundle/ruby/*/gems/stackprof-*/
 **/vendor/bundle/ruby/*/gems/strscan-*/
+**/vendor/bundle/ruby/*/gems/syntax_tree-*/
 **/vendor/bundle/ruby/*/gems/tapioca-*/
 **/vendor/bundle/ruby/*/gems/thor-*/
-**/vendor/bundle/ruby/*/gems/unf_ext-*/
-**/vendor/bundle/ruby/*/gems/unf-*/
 **/vendor/bundle/ruby/*/gems/unicode-display_width-*/
 **/vendor/bundle/ruby/*/gems/unparser-*/
 **/vendor/bundle/ruby/*/gems/uri_template-*/
+**/vendor/bundle/ruby/*/gems/vernier-*/
 **/vendor/bundle/ruby/*/gems/webrobots-*/
 **/vendor/bundle/ruby/*/gems/yard-*/
 **/vendor/bundle/ruby/*/gems/yard-sorbet-*/
+**/vendor/cache/
+**/vendor/specifications/
 
 # Ignore `bin` contents (again).
 /bin
@@ -171,12 +153,17 @@
 # Unignore our `brew` script.
 !/bin/brew
 
-# Unignore our documentation/completions.
+# Unignore our configuration/completions/documentation.
+!/.devcontainer
 !/.github
 !/completions
 !/docs
 !/manpages
 
+# Unignore our packaging files
+!/package
+/package/resources/LICENSE.rtf
+
 # Ignore generated documentation site
 /docs/_site
 /docs/bin
@@ -188,9 +175,11 @@
 !/.dockerignore
 !/.editorconfig
 !/.gitignore
-!/.yardopts
-!/.vale.ini
+!/.irb_config
+!/.ruby-version
 !/.shellcheckrc
+!/.vale.ini
+!/.yardopts
 !/CHANGELOG.md
 !/CONTRIBUTING.md
 !/Dockerfile
diff --git a/.vale.ini b/.vale.ini
index 8aeb07510139e..13f035651a317 100644
--- a/.vale.ini
+++ b/.vale.ini
@@ -1,4 +1,7 @@
 StylesPath = ./docs/vale-styles
 
-[*.md]
+[formats]
+rb = md
+
+[*.{md,rb}]
 BasedOnStyles = Homebrew
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
index 4ff3e09d4dd4e..33251fe7a3813 100644
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@@ -1,11 +1,17 @@
 {
   "recommendations": [
-    "kaiwood.endwise",
-    "misogi.ruby-rubocop",
-    "rebornix.ruby",
-    "wingrunr21.vscode-ruby",
-    "timonwong.shellcheck",
+    "Shopify.ruby-lsp",
+    "sorbet.sorbet-vscode-extension",
+    "github.vscode-github-actions",
+    "anykeyh.simplecov-vscode",
+    "ms-azuretools.vscode-docker",
+    "github.vscode-pull-request-github",
+    "davidanson.vscode-markdownlint",
     "foxundermoon.shell-format",
+    "timonwong.shellcheck",
+    "ban.spellright",
+    "redhat.vscode-yaml",
+    "koichisasada.vscode-rdbg",
     "editorconfig.editorconfig"
   ]
 }
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 0000000000000..867e7ff68c3d3
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,23 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "rdbg",
+      "name": "Debug Homebrew command",
+      "request": "launch",
+      "rdbgPath": "${workspaceFolder}/Library/Homebrew/shims/gems/rdbg",
+      "command": "brew debugger --",
+      "script": "${fileBasenameNoExtension}",
+      "askParameters": true
+    },
+    {
+      "type": "rdbg",
+      "name": "Attach to Homebrew debugger",
+      "request": "attach",
+      "rdbgPath": "${workspaceFolder}/Library/Homebrew/shims/gems/rdbg",
+      "env": {
+        "TMPDIR": "/private/tmp/",
+      }
+    }
+  ]
+}
diff --git a/.vscode/ruby-lsp-activate.sh b/.vscode/ruby-lsp-activate.sh
new file mode 100755
index 0000000000000..142acf76b407a
--- /dev/null
+++ b/.vscode/ruby-lsp-activate.sh
@@ -0,0 +1,7 @@
+#!/bin/bash
+HOMEBREW_PREFIX="$(cd "$(dirname "$0")"/../ && pwd)"
+
+"${HOMEBREW_PREFIX}/bin/brew" install-bundler-gems --add-groups=style,typecheck,vscode >/dev/null 2>&1
+
+export PATH="${HOMEBREW_PREFIX}/Library/Homebrew/vendor/portable-ruby/current/bin:${PATH}"
+export BUNDLE_WITH="style:typecheck:vscode"
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 865fc53af2f00..fae9f4229f93b 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,12 +1,54 @@
 {
+  "search.exclude": {
+    "Library/Homebrew/vendor/bundle/ruby/": true,
+    "Library/Homebrew/vendor/gems/": true,
+    "Library/Homebrew/vendor/portable-ruby/": true
+  },
   "editor.insertSpaces": true,
   "editor.tabSize": 2,
+  "editor.rulers": [
+    80,
+    118
+  ],
   "files.encoding": "utf8",
   "files.eol": "\n",
   "files.trimTrailingWhitespace": true,
   "files.insertFinalNewline": true,
   "files.trimFinalNewlines": true,
-  "ruby.rubocop.executePath": "Library/Homebrew/shims/gems/",
+  "rubyLsp.rubyVersionManager": {
+    "identifier": "custom"
+  },
+  "spellright.language": [
+    "en_GB",
+    "en_US"
+  ],
+  "spellright.documentTypes": [
+    "markdown",
+  ],
+  "rubyLsp.customRubyCommand": "source ../../.vscode/ruby-lsp-activate.sh",
+  "rubyLsp.bundleGemfile": "Library/Homebrew/Gemfile",
+  "rubyLsp.formatter": "rubocop",
+  "[ruby]": {
+    "editor.defaultFormatter": "Shopify.ruby-lsp",
+    "editor.formatOnSave": true,
+    "editor.formatOnType": true,
+    "editor.semanticHighlighting.enabled": true,
+  },
+  "sorbet.enabled": true,
+  "sorbet.lspConfigs": [
+    {
+      "id": "default",
+      "name": "Brew Typecheck",
+      "description": "Default configuration",
+      "cwd": "${workspaceFolder}",
+      "command": [
+        "./bin/brew",
+        "typecheck",
+        "--lsp",
+      ]
+    }
+  ],
+  "sorbet.selectedLspConfigId": "default",
   "shellcheck.customArgs": [
     "--shell=bash",
     "--enable=all",
@@ -21,7 +63,9 @@
   "[shellscript]": {
     "editor.formatOnSave": true,
     "editor.codeActionsOnSave": {
-      "source.fixAll.shellcheck": true,
+      "source.fixAll.shellcheck": "explicit"
     }
-  }
+  },
+  "simplecov-vscode.path": "Library/Homebrew/test/coverage/.resultset.json",
+  "simplecov-vscode.enabled": false
 }
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index dfd91c66cd380..1623d75e30512 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,6 +1,6 @@
 # Contributing to Homebrew
 
-First time contributing to Homebrew? Read our [Code of Conduct](https://github.com/Homebrew/.github/blob/HEAD/CODE_OF_CONDUCT.md#code-of-conduct) and review [How To Open a Homebrew Pull Request](https://docs.brew.sh/How-To-Open-a-Homebrew-Pull-Request).
+First time contributing to Homebrew? Read our [Code of Conduct](https://github.com/Homebrew/.github/blob/HEAD/CODE_OF_CONDUCT.md#code-of-conduct) and review [How to Open a Homebrew Pull Request](https://docs.brew.sh/How-To-Open-a-Homebrew-Pull-Request).
 
 ### Report a bug
 
diff --git a/Dockerfile b/Dockerfile
index a8c8ee7fc348b..64ce1a2019616 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,61 +1,98 @@
 ARG version=22.04
+# version is passed through by Docker.
 # shellcheck disable=SC2154
 FROM ubuntu:"${version}"
 ARG DEBIAN_FRONTEND=noninteractive
 
+# Deterministic UID (first user). Helps with docker build cache
+ENV USER_ID=1000
+# Delete the default ubuntu user & group UID=1000 GID=1000 in Ubuntu 23.04+
+# that conflicts with the linuxbrew user
+RUN touch /var/mail/ubuntu && chown ubuntu /var/mail/ubuntu && userdel -r ubuntu; true
+
+# We don't want to manually pin versions, happy to use whatever
+# Ubuntu thinks is best.
 # hadolint ignore=DL3008
+
+# `gh` installation taken from https://github.com/cli/cli/blob/trunk/docs/install_linux.md#debian-ubuntu-linux-raspberry-pi-os-apt
+# /etc/lsb-release is checked inside the container and sets DISTRIB_RELEASE.
+# We need `[` instead of `[[` because the shell is `/bin/sh`.
+# shellcheck disable=SC1091,SC2154,SC2292
 RUN apt-get update \
   && apt-get install -y --no-install-recommends software-properties-common gnupg-agent \
   && add-apt-repository -y ppa:git-core/ppa \
   && apt-get update \
   && apt-get install -y --no-install-recommends \
-    bzip2 \
-    ca-certificates \
-    curl \
-    file \
-    fonts-dejavu-core \
-    g++ \
-    gawk \
-    git \
-    less \
-    libz-dev \
-    locales \
-    make \
-    netbase \
-    openssh-client \
-    patch \
-    sudo \
-    uuid-runtime \
-    tzdata \
-  && apt remove --purge -y software-properties-common \
-  && apt autoremove --purge -y \
+  acl \
+  bzip2 \
+  ca-certificates \
+  curl \
+  file \
+  fonts-dejavu-core \
+  g++ \
+  gawk \
+  git \
+  gpg \
+  less \
+  locales \
+  make \
+  netbase \
+  openssh-client \
+  patch \
+  sudo \
+  unzip \
+  uuid-runtime \
+  tzdata \
+  jq \
+  && if [ "$(. /etc/lsb-release; echo "${DISTRIB_RELEASE}" | cut -d. -f1)" -ge 22 ]; then apt-get install -y --no-install-recommends skopeo; fi \
+  && mkdir -p /etc/apt/keyrings \
+  && chmod 0755 /etc /etc/apt /etc/apt/keyrings \
+  && curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | tee /etc/apt/keyrings/githubcli-archive-keyring.gpg >/dev/null \
+  && chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg \
+  && echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | tee /etc/apt/sources.list.d/github-cli.list >/dev/null \
+  && apt-get update \
+  && apt-get install -y --no-install-recommends gh \
+  && apt-get remove --purge -y software-properties-common \
+  && apt-get autoremove --purge -y \
   && rm -rf /var/lib/apt/lists/* \
+  && sed -i -E 's/^(USERGROUPS_ENAB\s+)yes$/\1no/' /etc/login.defs \
   && localedef -i en_US -f UTF-8 en_US.UTF-8 \
-  && useradd -m -s /bin/bash linuxbrew \
+  && useradd -u "${USER_ID}" --create-home --shell /bin/bash --user-group linuxbrew \
   && echo 'linuxbrew ALL=(ALL) NOPASSWD:ALL' >>/etc/sudoers \
   && su - linuxbrew -c 'mkdir ~/.linuxbrew'
 
 USER linuxbrew
 COPY --chown=linuxbrew:linuxbrew . /home/linuxbrew/.linuxbrew/Homebrew
-ENV PATH="/home/linuxbrew/.linuxbrew/bin:/home/linuxbrew/.linuxbrew/sbin:${PATH}"
+ENV PATH="/home/linuxbrew/.linuxbrew/bin:/home/linuxbrew/.linuxbrew/sbin:${PATH}" \
+  XDG_CACHE_HOME=/home/linuxbrew/.cache
 WORKDIR /home/linuxbrew
 
-RUN mkdir -p \
-     .linuxbrew/bin \
-     .linuxbrew/etc \
-     .linuxbrew/include \
-     .linuxbrew/lib \
-     .linuxbrew/opt \
-     .linuxbrew/sbin \
-     .linuxbrew/share \
-     .linuxbrew/var/homebrew/linked \
-     .linuxbrew/Cellar \
+
+RUN --mount=type=cache,target=/tmp/homebrew-core,uid="${USER_ID}",sharing=locked \
+    # Clone the homebre-core repo into /tmp/homebrew-core or pull latest changes if it exists
+    git clone https://github.com/homebrew/homebrew-core /tmp/homebrew-core || { cd /tmp/homebrew-core && git pull; } \
+    && mkdir -p /home/linuxbrew/.linuxbrew/Homebrew/Library/Taps/homebrew/homebrew-core \
+    && cp -r /tmp/homebrew-core /home/linuxbrew/.linuxbrew/Homebrew/Library/Taps/homebrew/
+
+
+RUN --mount=type=cache,target=/home/linuxbrew/.cache,uid="${USER_ID}" \
+   --mount=type=cache,target=/home/linuxbrew/.bundle,uid="${USER_ID}" \
+   mkdir -p \
+  .linuxbrew/bin \
+  .linuxbrew/etc \
+  .linuxbrew/include \
+  .linuxbrew/lib \
+  .linuxbrew/opt \
+  .linuxbrew/sbin \
+  .linuxbrew/share \
+  .linuxbrew/var/homebrew/linked \
+  .linuxbrew/Cellar \
   && ln -s ../Homebrew/bin/brew .linuxbrew/bin/brew \
   && git -C .linuxbrew/Homebrew remote set-url origin https://github.com/Homebrew/brew \
   && git -C .linuxbrew/Homebrew fetch origin \
-  && HOMEBREW_NO_ANALYTICS=1 HOMEBREW_NO_AUTO_UPDATE=1 brew tap homebrew/core \
-  && brew install-bundler-gems \
+  && HOMEBREW_NO_ANALYTICS=1 HOMEBREW_NO_AUTO_UPDATE=1 brew tap --force homebrew/core \
+  && brew install-bundler-gems --groups=all \
   && brew cleanup \
   && { git -C .linuxbrew/Homebrew config --unset gc.auto; true; } \
   && { git -C .linuxbrew/Homebrew config --unset homebrew.devcmdrun; true; } \
-  && rm -rf .cache
+  && touch .linuxbrew/.homebrewdocker
diff --git a/Library/.rubocop.yml b/Library/.rubocop.yml
index bad15147fa56f..50302d5e119ea 100644
--- a/Library/.rubocop.yml
+++ b/Library/.rubocop.yml
@@ -1,9 +1,10 @@
-# TODO: Try getting more rules in sync.
-
+---
 require:
   - ./Homebrew/rubocops.rb
+  - rubocop-md
   - rubocop-performance
-  - rubocop-rails
+  - rubocop-rspec
+  - rubocop-sorbet
 
 inherit_mode:
   merge:
@@ -11,32 +12,24 @@ inherit_mode:
     - Exclude
 
 AllCops:
-  TargetRubyVersion: 2.6
-  DisplayCopNames: false
-  ActiveSupportExtensionsEnabled: true
-  # enable all pending rubocops
+  TargetRubyVersion: 3.3
   NewCops: enable
   Include:
     - "**/*.rbi"
   Exclude:
-    - "Homebrew/sorbet/rbi/gems/**/*.rbi"
-    - "Homebrew/sorbet/rbi/hidden-definitions/**/*.rbi"
-    - "Homebrew/sorbet/rbi/todo.rbi"
-    - "Homebrew/sorbet/rbi/upstream.rbi"
+    - "Homebrew/sorbet/rbi/{dsl,gems}/**/*.rbi"
     - "Homebrew/bin/*"
     - "Homebrew/vendor/**/*"
     - "Taps/*/*/vendor/**/*"
+  SuggestExtensions:
+    rubocop-minitest: false
 
 Cask/Desc:
   Description: "Ensure that the desc stanza conforms to various content and style checks."
   Enabled: true
 
-Cask/HomepageUrlTrailingSlash:
-  Description: "Ensure that the homepage url has a slash after the domain name."
-  Enabled: true
-
-Cask/NoDslVersion:
-  Description: "Do not use the deprecated DSL version syntax in your cask header."
+Cask/HomepageUrlStyling:
+  Description: "Ensure that the homepage url has the correct format and styling."
   Enabled: true
 
 Cask/StanzaGrouping:
@@ -47,352 +40,71 @@ Cask/StanzaOrder:
   Description: "Ensure that cask stanzas are sorted correctly. More info at https://docs.brew.sh/Cask-Cookbook#stanza-order"
   Enabled: true
 
-# enable all formulae audits
 FormulaAudit:
   Enabled: true
 
-# enable all formulae strict audits
 FormulaAuditStrict:
   Enabled: true
 
-# enable all Homebrew custom cops
 Homebrew:
   Enabled: true
 
-# makes DSL usage ugly.
-Layout/SpaceBeforeBrackets:
-  Exclude:
-    - "**/*_spec.rb"
-    - "Taps/*/*/*.rb"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
-
-# Use `<<~` for heredocs.
-Layout/HeredocIndentation:
-  Enabled: true
-
-# Keyword arguments don't have the same readability
-# problems as normal parameters.
-Metrics/ParameterLists:
-  CountKeywordArgs: false
-
-# Allow dashes in filenames.
-Naming/FileName:
-  Regex: !ruby/regexp /^[\w\@\-\+\.]+(\.rb)?$/
-
-# Implicitly allow EOS as we use it everywhere.
-Naming/HeredocDelimiterNaming:
-  ForbiddenDelimiters:
-    - END, EOD, EOF
-
-Naming/InclusiveLanguage:
-  CheckStrings: true
-  FlaggedTerms:
-    # TODO: If possible, make this stricter.
-    slave:
-      AllowedRegex:
-        - "gitslave" # Used in formula `gitslave`
-        - "log_slave" # Used in formula `ssdb`
-        - "ssdb_slave" # Used in formula `ssdb`
-        - "var_slave" # Used in formula `ssdb`
-        - "patches/13_fix_scope_for_show_slave_status_data.patch" # Used in formula `mytop`
-
-Naming/MethodName:
-  AllowedPatterns:
-    - '\A(fetch_)?HEAD\?\Z'
-
-# Both styles are used depending on context,
-# e.g. `sha256` and `something_countable_1`.
-Naming/VariableNumber:
-  Enabled: false
-
-# Require &&/|| instead of and/or
-Style/AndOr:
-  Enabled: true
-  EnforcedStyle: always
-
-# Avoid leaking resources.
-Style/AutoResourceCleanup:
-  Enabled: true
-
-# This makes these a little more obvious.
-Style/BarePercentLiterals:
-  EnforcedStyle: percent_q
-
-# Use consistent style for better readability.
-Style/CollectionMethods:
-  Enabled: true
-
-# This is quite a large change, so don't enforce this yet for formulae.
-# We should consider doing so in the future, but be aware of the impact on third-party taps.
-Style/FetchEnvVar:
-  Exclude:
-    - "Taps/*/*/*.rb"
-    - "/**/Formula/*.rb"
-    - "**/Formula/*.rb"
-
-# Prefer tokens with type annotations for consistency
-# between formatting numbers and strings.
-Style/FormatStringToken:
-  EnforcedStyle: annotated
-
-# autocorrectable and more readable
-Style/HashEachMethods:
-  Enabled: true
-Style/HashTransformKeys:
-  Enabled: true
-Style/HashTransformValues:
-  Enabled: true
-
-# Allow for license expressions
-Style/HashAsLastArrayItem:
+Homebrew/Blank:
   Exclude:
-    - "Taps/*/*/*.rb"
-    - "/**/Formula/*.rb"
-    - "**/Formula/*.rb"
+    # Core extensions are not available here:
+    - "Homebrew/startup/bootsnap.rb"
 
-# Enabled now LineLength is lowish.
-Style/IfUnlessModifier:
-  Enabled: true
-
-# Only use this for numbers >= `1_000_000`.
-Style/NumericLiterals:
-  MinDigits: 7
-  Strict: true
+Homebrew/CompactBlank:
   Exclude:
-    - "**/Brewfile"
-
-# Zero-prefixed octal literals are widely used and understood.
-Style/NumericLiteralPrefix:
-  EnforcedOctalStyle: zero_only
-
-# Rescuing `StandardError` is an understood default.
-Style/RescueStandardError:
-  EnforcedStyle: implicit
-
-# Returning `nil` is unnecessary.
-Style/ReturnNil:
-  Enabled: true
+    # `blank?` is not necessarily available here:
+    - "Homebrew/extend/enumerable.rb"
 
-# We have no use for using `warn` because we
-# are calling Ruby with warnings disabled.
-Style/StderrPuts:
-  Enabled: false
-
-# Use consistent method names.
-Style/StringMethods:
-  Enabled: true
-
-# An array of symbols is more readable than a symbol array
-# and also allows for easier grepping.
-Style/SymbolArray:
-  EnforcedStyle: brackets
-
-# Trailing commas make diffs nicer.
-Style/TrailingCommaInArguments:
-  EnforcedStyleForMultiline: comma
-Style/TrailingCommaInArrayLiteral:
-  EnforcedStyleForMultiline: comma
-Style/TrailingCommaInHashLiteral:
-  EnforcedStyleForMultiline: comma
-
-# Does not hinder readability, so might as well enable it.
-Performance/CaseWhenSplat:
-  Enabled: true
-
-# Makes code less readable for minor performance increases.
-Performance/Caller:
-  Enabled: false
+Homebrew/NoFileutilsRmrf:
+  Include:
+    - "/**/{Formula,Casks}/**/*.rb"
+    - "**/{Formula,Casks}/**/*.rb"
 
-# Makes code less readable for minor performance increases.
-Performance/MethodObjectAsBlock:
+# only used internally
+Homebrew/MoveToExtendOS:
   Enabled: false
 
-Rails:
-  # Selectively enable what we want.
-  Enabled: false
-  # Cannot use ActiveSupport in RuboCops.
+Homebrew/NegateInclude:
   Exclude:
+    # `exclude?` is not available here:
+    - "Homebrew/standalone/init.rb"
     - "Homebrew/rubocops/**/*"
-
-# These relate to ActiveSupport and not other parts of Rails.
-Rails/ActiveSupportAliases:
-  Enabled: true
-Rails/Blank:
-  Enabled: true
-Rails/CompactBlank:
-  Enabled: true
-Rails/Delegate:
-  Enabled: false # TODO
-Rails/DelegateAllowBlank:
-  Enabled: true
-Rails/DurationArithmetic:
-  Enabled: true
-Rails/ExpandedDateRange:
-  Enabled: true
-Rails/Inquiry:
-  Enabled: true
-Rails/NegateInclude:
-  Enabled: true
-Rails/PluralizationGrammar:
-  Enabled: true
-Rails/Presence:
-  Enabled: true
-Rails/Present:
-  Enabled: true
-Rails/RelativeDateConstant:
-  Enabled: true
-Rails/SafeNavigation:
-  Enabled: true
-Rails/SafeNavigationWithBlank:
-  Enabled: true
-Rails/StripHeredoc:
-  Enabled: true
-Rails/ToFormattedS:
-  Enabled: true
-
-# Don't allow cops to be disabled in casks and formulae.
-Style/DisableCopsWithinSourceCodeDirective:
-  Enabled: true
-  Include:
-    - "Taps/*/*/*.rb"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
-
-# make our hashes consistent
-Layout/HashAlignment:
-  EnforcedHashRocketStyle: table
-  EnforcedColonStyle: table
+    - "Homebrew/sorbet/tapioca/**/*"
 
 # `system` is a special case and aligns on second argument, so allow this for formulae.
 Layout/ArgumentAlignment:
   Exclude:
     - "Taps/*/*/*.rb"
-    - "/**/Formula/*.rb"
-    - "**/Formula/*.rb"
+    - "/**/Formula/**/*.rb"
+    - "**/Formula/**/*.rb"
 
 # this is a bit less "floaty"
 Layout/CaseIndentation:
   EnforcedStyle: end
 
-# Need to allow #: for external commands.
-Layout/LeadingCommentSpace:
-  Exclude:
-    - "Taps/*/*/cmd/*.rb"
-
-# this is a bit less "floaty"
-Layout/EndAlignment:
-  EnforcedStyleAlignWith: start_of_line
-
-# conflicts with DSL-style path concatenation with `/`
-Layout/SpaceAroundOperators:
-  Enabled: false
-
-# layout is not configurable (https://github.com/rubocop-hq/rubocop/issues/6254).
-Layout/RescueEnsureAlignment:
-  Enabled: false
-
 # significantly less indentation involved; more consistent
 Layout/FirstArrayElementIndentation:
   EnforcedStyle: consistent
 Layout/FirstHashElementIndentation:
   EnforcedStyle: consistent
 
-# favour parens-less DSL-style arguments
-Lint/AmbiguousBlockAssociation:
-  Enabled: false
-
-Lint/RequireRelativeSelfPath:
-  # bugged on formula-analytics
-  # https://github.com/Homebrew/brew/pull/12152/checks?check_run_id=3755137378#step:15:60
-  Exclude:
-    - "Taps/homebrew/homebrew-formula-analytics/*/*.rb"
-
-Lint/DuplicateBranch:
-  Exclude:
-    - "Taps/*/*/*.rb"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
-
-# needed for lazy_object magic
-Naming/MemoizedInstanceVariableName:
-  Exclude:
-    - "Homebrew/lazy_object.rb"
-
-# useful for metaprogramming in RSpec
-Lint/ConstantDefinitionInBlock:
-  Exclude:
-    - "**/*_spec.rb"
+# this is a bit less "floaty"
+Layout/EndAlignment:
+  EnforcedStyleAlignWith: start_of_line
 
-# so many of these in formulae and can't be autocorrected
-Lint/ParenthesesAsGroupedExpression:
-  Exclude:
-    - "Taps/*/*/*.rb"
-    - "/**/Formula/*.rb"
-    - "**/Formula/*.rb"
+# make our hashes consistent
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
 
-# Most metrics don't make sense to apply for casks/formulae/taps.
-Metrics/AbcSize:
-  Exclude:
-    - "Taps/**/*"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
-Metrics/BlockLength:
-  Exclude:
-    - "Taps/**/*"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
-Metrics/ClassLength:
-  Exclude:
-    - "Taps/**/*"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
-Metrics/CyclomaticComplexity:
-  Exclude:
-    - "Taps/**/*"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
-Metrics/MethodLength:
-  Exclude:
-    - "Taps/**/*"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
-Metrics/ModuleLength:
-  Exclude:
-    - "Taps/**/*"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
-Metrics/PerceivedComplexity:
+# Need to allow #: for external commands.
+Layout/LeadingCommentSpace:
   Exclude:
-    - "Taps/**/*"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
-
-# allow those that are standard
-# TODO: try to remove some of these
-Naming/MethodParameterName:
-  AllowedNames:
-    - "_"
-    - "a"
-    - "b"
-    - "cc"
-    - "c1"
-    - "c2"
-    - "d"
-    - "e"
-    - "f"
-    - "ff"
-    - "fn"
-    - "id"
-    - "io"
-    - "o"
-    - "p"
-    - "pr"
-    - "r"
-    - "rb"
-    - "s"
-    - "to"
-    - "v"
+    - "Taps/*/*/cmd/*.rb"
 
 # GitHub diff UI wraps beyond 118 characters
 Layout/LineLength:
@@ -404,7 +116,6 @@ Layout/LineLength:
       ' url "',
       ' mirror "',
       " plist_options ",
-      ' appcast "',
       ' executable: "',
       ' font "',
       ' homepage "',
@@ -420,98 +131,314 @@ Layout/LineLength:
       '"/Library/PreferencePanes/',
       ' "~/Library/Application Support/',
       '"~/Library/Caches/',
+      '"~/Library/Containers',
       '"~/Application Support',
       " was verified as official when first introduced to the cask",
     ]
 
-Sorbet/FalseSigil:
+# conflicts with DSL-style path concatenation with `/`
+Layout/SpaceAroundOperators:
+  Enabled: false
+
+# makes DSL usage ugly.
+Layout/SpaceBeforeBrackets:
   Exclude:
-    - "Taps/**/*"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
-    - "Homebrew/test/**/Casks/**/*.rb"
+    - "**/*_spec.rb"
+    - "Taps/*/*/*.rb"
+    - "/**/{Formula,Casks}/**/*.rb"
+    - "**/{Formula,Casks}/**/*.rb"
 
-Sorbet/StrictSigil:
+# favour parens-less DSL-style arguments
+Lint/AmbiguousBlockAssociation:
+  Enabled: false
+
+Lint/DuplicateBranch:
+  Exclude:
+    - "Taps/*/*/*.rb"
+    - "/**/{Formula,Casks}/**/*.rb"
+    - "**/{Formula,Casks}/**/*.rb"
+
+# so many of these in formulae and can't be autocorrected
+Lint/ParenthesesAsGroupedExpression:
+  Exclude:
+    - "Taps/*/*/*.rb"
+    - "/**/Formula/**/*.rb"
+    - "**/Formula/**/*.rb"
+
+# unused keyword arguments improve APIs
+Lint/UnusedMethodArgument:
+  AllowUnusedKeywordArguments: true
+
+# These metrics didn't end up helping.
+Metrics:
+  Enabled: false
+
+# Disabled because it breaks Sorbet: "The declaration for `with` is missing parameter(s): & (RuntimeError)"
+Naming/BlockForwarding:
+  Enabled: false
+
+# Allow dashes in filenames.
+Naming/FileName:
+  Regex: !ruby/regexp /^[\w\@\-\+\.]+(\.rb)?$/
+
+# Implicitly allow EOS as we use it everywhere.
+Naming/HeredocDelimiterNaming:
+  ForbiddenDelimiters:
+    - END, EOD, EOF
+
+Naming/InclusiveLanguage:
+  CheckStrings: true
+  FlaggedTerms:
+    slave:
+      AllowedRegex:
+        - "gitslave" # Used in formula `gitslave`
+        - "log_slave" # Used in formula `ssdb`
+        - "ssdb_slave" # Used in formula `ssdb`
+        - "var_slave" # Used in formula `ssdb`
+        - "patches/13_fix_scope_for_show_slave_status_data.patch" # Used in formula `mytop`
+
+Naming/MethodName:
+  AllowedPatterns:
+    - '\A(fetch_)?HEAD\?\Z'
+
+Naming/MethodParameterName:
   inherit_mode:
-    override:
-      - Include
+    merge:
+      - AllowedNames
+
+# Both styles are used depending on context,
+# e.g. `sha256` and `something_countable_1`.
+Naming/VariableNumber:
+  Enabled: false
+
+# Makes code less readable for minor performance increases.
+Performance/Caller:
+  Enabled: false
+
+# Does not hinder readability, so might as well enable it.
+Performance/CaseWhenSplat:
   Enabled: true
+
+# Makes code less readable for minor performance increases.
+Performance/MethodObjectAsBlock:
+  Enabled: false
+
+RSpec:
   Include:
-    - "**/*.rbi"
+    - "Homebrew/test/**/*"
+
+# Intentionally disabled as it doesn't fit with our code style.
+RSpec/AnyInstance:
+  Enabled: false
+RSpec/SpecFilePathFormat:
+  Enabled: false
+RSpec/StubbedMock:
+  Enabled: false
+RSpec/SubjectStub:
+  Enabled: false
+# These were ever-growing numbers, not useful.
+RSpec/ExampleLength:
+  Enabled: false
+RSpec/MultipleExpectations:
+  Enabled: false
+RSpec/NestedGroups:
+  Enabled: false
+RSpec/MultipleMemoizedHelpers:
+  Enabled: false
+
+RSpec/DescribedClassModuleWrapping:
+  Enabled: true
+# Annoying to have these autoremoved.
+RSpec/Focus:
+  AutoCorrect: false
+# We use `allow(:foo).to receive(:bar)` everywhere.
+RSpec/MessageSpies:
+  EnforcedStyle: receive
 
 # Try getting rid of these.
 Sorbet/ConstantsFromStrings:
   Enabled: false
 
-# Avoid false positives on modifiers used on symbols of methods
-# See https://github.com/rubocop-hq/rubocop/issues/5953
-Style/AccessModifierDeclarations:
+# This is already the default
+Sorbet/FalseSigil:
   Enabled: false
 
-# Conflicts with type signatures on `attr_*`s.
-Style/AccessorGrouping:
+# We generally prefer to colo rbi files with the Ruby files they describe.
+Sorbet/ForbidRBIOutsideOfAllowedPaths:
   Enabled: false
 
-# make rspec formatting more flexible
-Style/BlockDelimiters:
+# T::Sig is monkey-patched into Module
+Sorbet/RedundantExtendTSig:
+  Enabled: true
+
+# We make limited and intentional use of refinements.
+# It's posssible this may change in the future, though we probably still do not want to ban it in taps
+# and Sorbet typecheck will tell us what is and isn't a problem anyway.
+# Right now, our use of refinements isn't problematic (or at least not yet).
+Sorbet/Refinement:
+  Enabled: false
+
+Sorbet/StrictSigil:
+  Enabled: true
+  Exclude:
+    - "Taps/**/*"
+    - "/**/{Formula,Casks}/**/*.rb"
+    - "**/{Formula,Casks}/**/*.rb"
+    - "Homebrew/{standalone,startup}/*.rb" # These are loaded before sorbet-runtime
+    - "Homebrew/test/**/*.rb"
+
+Sorbet/TrueSigil:
+  Enabled: true
   Exclude:
-    - "Homebrew/**/*_spec.rb"
-    - "Homebrew/**/shared_examples/**/*.rb"
+    - "Taps/**/*"
+    - "/**/{Formula,Casks}/**/*.rb"
+    - "**/{Formula,Casks}/**/*.rb"
+    - "Homebrew/test/**/*.rb"
 
-# TODO: remove this when possible.
-Style/ClassVars:
+# Require &&/|| instead of and/or
+Style/AndOr:
+  EnforcedStyle: always
+
+# Disabled because it breaks Sorbet: "The declaration for `with` is missing parameter(s): & (RuntimeError)"
+Style/ArgumentsForwarding:
+  Enabled: false
+
+# Avoid leaking resources.
+Style/AutoResourceCleanup:
+  Enabled: true
+
+# This makes these a little more obvious.
+Style/BarePercentLiterals:
+  EnforcedStyle: percent_q
+
+Style/BlockDelimiters:
+  BracesRequiredMethods:
+    - "sig"
+
+Style/ClassAndModuleChildren:
   Exclude:
-    - "**/developer/bin/*"
+    - "**/*.rbi"
+
+# Use consistent style for better readability.
+Style/CollectionMethods:
+  Enabled: true
+
+# Don't allow cops to be disabled in casks and formulae.
+Style/DisableCopsWithinSourceCodeDirective:
+  Enabled: true
+  Include:
+    - "Taps/*/*/*.rb"
+    - "/**/{Formula,Casks}/**/*.rb"
+    - "**/{Formula,Casks}/**/*.rb"
 
-# Don't enforce documentation in casks or formulae.
+# The files actually scanned in this cop are in `Library/Homebrew/.rubocop.yml`.
 Style/Documentation:
   Exclude:
     - "Taps/**/*"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
+    - "/**/{Formula,Casks}/**/*.rb"
+    - "**/{Formula,Casks}/**/*.rb"
     - "**/*.rbi"
 
-Style/DocumentationMethod:
-  Include:
-    - "Homebrew/formula.rb"
+# This is impossible to fix if the line exceeds the maximum length.
+Style/EmptyMethod:
+  Exclude:
+    - "**/*.rbi"
+
+# This is quite a large change, so don't enforce this yet for formulae.
+# We should consider doing so in the future, but be aware of the impact on third-party taps.
+Style/FetchEnvVar:
+  Exclude:
+    - "Taps/*/*/*.rb"
+    - "/**/Formula/**/*.rb"
+    - "**/Formula/**/*.rb"
 
 # Not used for casks and formulae.
 Style/FrozenStringLiteralComment:
   EnforcedStyle: always
   Exclude:
     - "Taps/*/*/*.rb"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
+    - "/**/{Formula,Casks}/**/*.rb"
+    - "**/{Formula,Casks}/**/*.rb"
     - "Homebrew/test/**/Casks/**/*.rb"
     - "**/*.rbi"
     - "**/Brewfile"
 
-# TODO: remove this when possible.
-Style/GlobalVars:
-  Exclude:
-    - "**/developer/bin/*"
-
 # potential for errors in formulae too high with this
 Style/GuardClause:
   Exclude:
     - "Taps/*/*/*.rb"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
+    - "/**/{Formula,Casks}/**/*.rb"
+    - "**/{Formula,Casks}/**/*.rb"
+
+# Allow for license expressions
+Style/HashAsLastArrayItem:
+  Exclude:
+    - "Taps/*/*/*.rb"
+    - "/**/Formula/**/*.rb"
+    - "**/Formula/**/*.rb"
+
+Style/InverseMethods:
+  InverseMethods:
+    :blank?: :present?
+
+Style/InvertibleUnlessCondition:
+  Enabled: true
+  InverseMethods:
+    # Favor `if a != b` over `unless a == b`
+    :==: :!=
+    # Unset this (prefer `unless a.zero?` over `if a.nonzero?`)
+    :zero?:
+    :blank?: :present?
 
-# avoid hash rockets where possible
-Style/HashSyntax:
-  EnforcedStyle: ruby19
+Style/MutableConstant:
+  # would rather freeze too much than too little
+  EnforcedStyle: strict
+
+# Zero-prefixed octal literals are widely used and understood.
+Style/NumericLiteralPrefix:
+  EnforcedOctalStyle: zero_only
+
+# Only use this for numbers >= `1_000_000`.
+Style/NumericLiterals:
+  MinDigits: 7
+  Strict: true
+  Exclude:
+    - "**/Brewfile"
 
-# OpenStruct is a nice helper.
 Style/OpenStructUse:
+  Exclude:
+    - "Taps/**/*"
+    # TODO: This is a pre-existing violation and should be corrected
+    #   to define methods so that call sites can be type-checked.
+    - "Homebrew/cli/args.rb"
+    - "Homebrew/cli/args.rbi"
+
+Style/OptionalBooleanParameter:
+  AllowedMethods:
+    # These are overrides of core library methods
+    # see https://ruby-doc.org/3.3.4/Object.html#method-i-respond_to-3F
+    - respond_to?
+    - respond_to_missing?
+
+# Rescuing `StandardError` is an understood default.
+Style/RescueStandardError:
+  EnforcedStyle: implicit
+
+# Returning `nil` is unnecessary.
+Style/ReturnNil:
+  Enabled: true
+
+# We have no use for using `warn` because we
+# are calling Ruby with warnings disabled.
+Style/StderrPuts:
   Enabled: false
 
 # so many of these in formulae and can't be autocorrected
 Style/StringConcatenation:
   Exclude:
     - "Taps/*/*/*.rb"
-    - "/**/{Formula,Casks}/*.rb"
-    - "**/{Formula,Casks}/*.rb"
+    - "/**/{Formula,Casks}/**/*.rb"
+    - "**/{Formula,Casks}/**/*.rb"
 
 # ruby style guide favorite
 Style/StringLiterals:
@@ -521,10 +448,36 @@ Style/StringLiterals:
 Style/StringLiteralsInInterpolation:
   EnforcedStyle: double_quotes
 
+# Use consistent method names.
+Style/StringMethods:
+  Enabled: true
+
+# Treating this the same as Style/MethodCallWithArgsParentheses
+Style/SuperWithArgsParentheses:
+  Enabled: false
+
+# An array of symbols is more readable than a symbol array
+# and also allows for easier grepping.
+Style/SymbolArray:
+  EnforcedStyle: brackets
+
 # make things a bit easier to read
 Style/TernaryParentheses:
   EnforcedStyle: require_parentheses_when_complex
 
+Style/TopLevelMethodDefinition:
+  Enabled: true
+  Exclude:
+    - "Taps/**/*"
+
+# Trailing commas make diffs nicer.
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma
+
 # `unless ... ||` and `unless ... &&` are hard to mentally parse
 Style/UnlessLogicalOperators:
   Enabled: true
@@ -533,11 +486,3 @@ Style/UnlessLogicalOperators:
 # a bit confusing to non-Rubyists but useful for longer arrays
 Style/WordArray:
   MinSize: 4
-
-# would rather freeze too much than too little
-Style/MutableConstant:
-  EnforcedStyle: strict
-
-# unused keyword arguments improve APIs
-Lint/UnusedMethodArgument:
-  AllowUnusedKeywordArguments: true
diff --git a/Library/.rubocop_rspec.yml b/Library/.rubocop_rspec.yml
deleted file mode 100644
index 1cc0a316d4d96..0000000000000
--- a/Library/.rubocop_rspec.yml
+++ /dev/null
@@ -1,37 +0,0 @@
-inherit_from: ./.rubocop.yml
-
-# Intentionally disabled as it doesn't fit with our code style.
-RSpec/AnyInstance:
-  Enabled: false
-RSpec/FilePath:
-  Enabled: false
-RSpec/ImplicitBlockExpectation:
-  Enabled: false
-RSpec/SubjectStub:
-  Enabled: false
-
-# TODO: try to enable these
-RSpec/DescribeClass:
-  Enabled: false
-RSpec/LeakyConstantDeclaration:
-  Enabled: false
-RSpec/MessageSpies:
-  Enabled: false
-RSpec/RepeatedDescription:
-  Enabled: false
-RSpec/StubbedMock:
-  Enabled: false
-
-# TODO: try to reduce these
-RSpec/ExampleLength:
-  Max: 75
-RSpec/MultipleExpectations:
-  Max: 26
-RSpec/NestedGroups:
-  Max: 5
-RSpec/MultipleMemoizedHelpers:
-  Max: 12
-
-# Annoying to have these autoremoved.
-RSpec/Focus:
-  AutoCorrect: false
diff --git a/Library/Homebrew/.bundle/config b/Library/Homebrew/.bundle/config
index e2c528e14d425..5d1f6bbaea0ed 100644
--- a/Library/Homebrew/.bundle/config
+++ b/Library/Homebrew/.bundle/config
@@ -2,6 +2,7 @@
 BUNDLE_BIN: "false"
 BUNDLE_CLEAN: "true"
 BUNDLE_DISABLE_SHARED_GEMS: "true"
+BUNDLE_FORCE_RUBY_PLATFORM: "false"
 BUNDLE_FORGET_CLI_OPTIONS: "true"
 BUNDLE_JOBS: "4"
 BUNDLE_PATH: "vendor/bundle"
diff --git a/Library/Homebrew/.parlour b/Library/Homebrew/.parlour
deleted file mode 100644
index 1fe16333dc4e2..0000000000000
--- a/Library/Homebrew/.parlour
+++ /dev/null
@@ -1,10 +0,0 @@
-parser: false
-
-output_file:
-  rbi: sorbet/rbi/parlour.rbi
-
-relative_requires:
-  - sorbet/parlour.rb
-
-plugins:
-  Attr: {}
diff --git a/Library/Homebrew/.rspec_parallel b/Library/Homebrew/.rspec_parallel
index 5200a0136d80d..7bc3e335f0ac2 100644
--- a/Library/Homebrew/.rspec_parallel
+++ b/Library/Homebrew/.rspec_parallel
@@ -1,4 +1,4 @@
---format NoSeedProgressFormatter
+--format QuietProgressFormatter
 --format ParallelTests::RSpec::RuntimeLogger
 --out <%= ENV["PARALLEL_RSPEC_LOG_PATH"] %>
 --format RspecJunitFormatter
diff --git a/Library/Homebrew/.rubocop.yml b/Library/Homebrew/.rubocop.yml
index 07b613ecb3b2b..8cdc7766cc071 100644
--- a/Library/Homebrew/.rubocop.yml
+++ b/Library/Homebrew/.rubocop.yml
@@ -1,63 +1,81 @@
 inherit_from:
-  - ../.rubocop_rspec.yml
-  - .rubocop_todo.yml
+  - ../.rubocop.yml
 
-# make rspec formatting more flexible
-Layout/MultilineMethodCallIndentation:
-  Exclude:
-    - "**/*_spec.rb"
-
-# `formula do` uses nested method definitions
-Lint/NestedMethodDefinition:
-  Exclude:
-    - "test/**/*"
+Bundler/GemFilename:
+  Enabled: false
 
-# TODO: Try to bring down all metrics maximums.
-Metrics/AbcSize:
-  Max: 280
-Metrics/BlockLength:
-  Max: 106
-  Exclude:
-    # TODO: extract more of the bottling logic
-    - "dev-cmd/bottle.rb"
-    - "test/**/*"
-Metrics/BlockNesting:
-  Max: 5
-Metrics/ClassLength:
-  Max: 800
-  Exclude:
-    - "formula.rb"
-    - "formula_installer.rb"
-Metrics/CyclomaticComplexity:
-  Max: 80
-Metrics/PerceivedComplexity:
-  Max: 90
-Metrics/MethodLength:
-  Max: 260
-Metrics/ModuleLength:
-  Max: 500
+Homebrew/MoveToExtendOS:
+  Enabled: true
   Exclude:
-    # TODO: extract more of the bottling logic
-    - "dev-cmd/bottle.rb"
-    # TODO: try break this down
-    - "utils/github.rb"
-    - "test/**/*"
+    - "{extend,test,requirements}/**/*"
+    - "os.rb"
 
 Naming/PredicateName:
-  # Can't rename these.
+  inherit_mode:
+    merge:
+      - AllowedMethods
   AllowedMethods:
-    - is_a?
     - is_32_bit?
     - is_64_bit?
 
-Style/HashAsLastArrayItem:
-  Exclude:
-    - "test/utils/spdx_spec.rb"
-
-Style/BlockDelimiters:
-  BracesRequiredMethods:
-    - "sig"
+# Only enforce documentation for public APIs.
+# Checked by the tests.yml syntax job
+Style/Documentation:
+  AllowedConstants:
+    - Homebrew
+  Include:
+    - abstract_command.rb
+    - cask/cask.rb
+    - cask/dsl.rb
+    - cask/dsl/version.rb
+    - cask/url.rb
+    - development_tools.rb
+    - download_strategy.rb
+    - extend/ENV/super.rb
+    - extend/kernel.rb
+    - extend/pathname.rb
+    - formula.rb
+    - formula_assertions.rb
+    - formula_free_port.rb
+    - language/go.rb
+    - language/java.rb
+    - language/node.rb
+    - language/perl.rb
+    - language/python.rb
+    - livecheck/strategy/apache.rb
+    - livecheck/strategy/bitbucket.rb
+    - livecheck/strategy/cpan.rb
+    - livecheck/strategy/crate.rb
+    - livecheck/strategy/extract_plist.rb
+    - livecheck/strategy/git.rb
+    - livecheck/strategy/github_latest.rb
+    - livecheck/strategy/github_releases.rb
+    - livecheck/strategy/gnome.rb
+    - livecheck/strategy/gnu.rb
+    - livecheck/strategy/hackage.rb
+    - livecheck/strategy/json.rb
+    - livecheck/strategy/launchpad.rb
+    - livecheck/strategy/npm.rb
+    - livecheck/strategy/page_match.rb
+    - livecheck/strategy/pypi.rb
+    - livecheck/strategy/sourceforge.rb
+    - livecheck/strategy/sparkle.rb
+    - livecheck/strategy/xml.rb
+    - livecheck/strategy/xorg.rb
+    - livecheck/strategy/yaml.rb
+    - os.rb
+    - resource.rb
+    - utils/inreplace.rb
+    - utils/shebang.rb
+    - utils/string_inreplace_extension.rb
+    - version.rb
+    - tap.rb
 
-Bundler/GemFilename:
+Homebrew/NegateInclude:
   Exclude:
-    - "utils/gems.rb"
+    # YARD runs stand-alone.
+    - yard/docstring_parser.rb
+
+Style/DocumentationMethod:
+  Include:
+    - "formula.rb"
diff --git a/Library/Homebrew/.rubocop_todo.yml b/Library/Homebrew/.rubocop_todo.yml
deleted file mode 100644
index 249ddfbd948f3..0000000000000
--- a/Library/Homebrew/.rubocop_todo.yml
+++ /dev/null
@@ -1,38 +0,0 @@
-Style/Documentation:
-  Exclude:
-    - "compat/**/*.rb"
-    - "extend/**/*.rb"
-    - "cmd/**/*.rb"
-    - "dev-cmd/**/*.rb"
-    - "test/**/*.rb"
-    - "cask/macos.rb"
-    - "cli/args.rb"
-    - "cli/parser.rb"
-    - "default_prefix.rb"
-    - "global.rb"
-    - "keg_relocate.rb"
-    - "os/linux/global.rb"
-    - "os/mac/global.rb"
-    - "os/mac/keg.rb"
-    - "reinstall.rb"
-    - "software_spec.rb"
-    - "upgrade.rb"
-    - "utils.rb"
-    - "utils/fork.rb"
-    - "utils/gems.rb"
-    - "utils/git_repository.rb"
-    - "utils/popen.rb"
-    - "utils/shell.rb"
-    - "version.rb"
-
-Lint/EmptyBlock:
-  Exclude:
-    - "dependency.rb"
-    - "dev-cmd/extract.rb"
-    - "test/cache_store_spec.rb"
-    - "test/checksum_verification_spec.rb"
-    - "test/compiler_failure_spec.rb"
-    - "test/formula_spec.rb"
-    - "test/formula_validation_spec.rb"
-    - "test/pathname_spec.rb"
-    - "test/support/fixtures/cask/Casks/*flight*.rb"
diff --git a/Library/Homebrew/.ruby-version b/Library/Homebrew/.ruby-version
new file mode 100644
index 0000000000000..fa7adc7ac72a2
--- /dev/null
+++ b/Library/Homebrew/.ruby-version
@@ -0,0 +1 @@
+3.3.5
diff --git a/Library/Homebrew/.simplecov b/Library/Homebrew/.simplecov
index 792b6951ee864..6b48c7ad2699b 100755
--- a/Library/Homebrew/.simplecov
+++ b/Library/Homebrew/.simplecov
@@ -8,19 +8,23 @@ SimpleCov.enable_for_subprocesses true
 SimpleCov.start do
   coverage_dir File.expand_path("../test/coverage", File.realpath(__FILE__))
   root File.expand_path("..", File.realpath(__FILE__))
+  command_name "brew"
 
   # enables branch coverage as well as, the default, line coverage
   enable_coverage :branch
 
+  # enables coverage for `eval`ed code
+  enable_coverage_for_eval
+
+  # ensure that we always default to line coverage
+  primary_coverage :line
+
   # We manage the result cache ourselves and the default of 10 minutes can be
-  # too low (particularly on Travis CI), causing results from some integration
-  # tests to be dropped. This causes random fluctuations in test coverage.
+  # too low causing results from some integration tests to be dropped. This
+  # causes random fluctuations in test coverage.
   merge_timeout 86400
 
-  at_fork do |pid|
-    # This needs a unique name so it won't be ovewritten
-    command_name "#{SimpleCov.command_name} (#{pid})"
-
+  at_fork do
     # be quiet, the parent process will be in charge of output and checking coverage totals
     SimpleCov.print_error_status = false
   end
@@ -30,9 +34,9 @@ SimpleCov.start do
                .map { |p| "#{p}/**/*.rb" }.join(",")
   files = "#{SimpleCov.root}/{#{subdirs},*.rb}"
 
-  if ENV["HOMEBREW_INTEGRATION_TEST"]
-    # This needs a unique name so it won't be ovewritten
-    command_name "#{ENV["HOMEBREW_INTEGRATION_TEST"]} (#{$PROCESS_ID})"
+  if (integration_test_number = ENV.fetch("HOMEBREW_INTEGRATION_TEST", nil))
+    # This needs a unique name so it won't be overwritten
+    command_name "brew_i:#{integration_test_number}"
 
     # be quiet, the parent process will be in charge of output and checking coverage totals
     SimpleCov.print_error_status = false
@@ -53,39 +57,43 @@ SimpleCov.start do
       raise if $ERROR_INFO.is_a?(SystemExit)
     end
   else
-    command_name "#{command_name} (#{$PROCESS_ID})"
+    command_name "brew:#{ENV.fetch("TEST_ENV_NUMBER", $PROCESS_ID)}"
 
     # Not using this during integration tests makes the tests 4x times faster
     # without changing the coverage.
     track_files files
   end
 
-  add_filter %r{^/build.rb$}
-  add_filter %r{^/config.rb$}
-  add_filter %r{^/constants.rb$}
-  add_filter %r{^/postinstall.rb$}
-  add_filter %r{^/test.rb$}
-  add_filter %r{^/compat/}
-  add_filter %r{^/dev-cmd/tests.rb$}
+  add_filter %r{^/build\.rb$}
+  add_filter %r{^/config\.rb$}
+  add_filter %r{^/constants\.rb$}
+  add_filter %r{^/postinstall\.rb$}
+  add_filter %r{^/test\.rb$}
+  add_filter %r{^/dev-cmd/tests\.rb$}
+  add_filter %r{^/sorbet/}
   add_filter %r{^/test/}
   add_filter %r{^/vendor/}
+  add_filter %r{^/yard/}
 
   require "rbconfig"
   host_os = RbConfig::CONFIG["host_os"]
-  add_filter %r{/os/mac} unless /darwin/.match?(host_os)
-  add_filter %r{/os/linux} unless /linux/.match?(host_os)
+  add_filter %r{/os/mac} unless host_os.include?("darwin")
+  add_filter %r{/os/linux} unless host_os.include?("linux")
 
   # Add groups and the proper project name to the output.
   project_name "Homebrew"
-  add_group "Cask", %r{^/cask/}
+  add_group "Cask", %r{^/cask(/|\.rb$)}
   add_group "Commands", [%r{/cmd/}, %r{^/dev-cmd/}]
   add_group "Extensions", %r{^/extend/}
+  add_group "Livecheck", %r{^/livecheck(/|\.rb$)}
   add_group "OS", [%r{^/extend/os/}, %r{^/os/}]
   add_group "Requirements", %r{^/requirements/}
+  add_group "RuboCops", %r{^/rubocops/}
+  add_group "Unpack Strategies", %r{^/unpack_strategy(/|\.rb$)}
   add_group "Scripts", [
-    %r{^/brew.rb$},
-    %r{^/build.rb$},
-    %r{^/postinstall.rb$},
-    %r{^/test.rb$},
+    %r{^/brew\.rb$},
+    %r{^/build\.rb$},
+    %r{^/postinstall\.rb$},
+    %r{^/test\.rb$},
   ]
 end
diff --git a/Library/Homebrew/.yardopts b/Library/Homebrew/.yardopts
index b86f778054d33..4bb4553c05ef6 100644
--- a/Library/Homebrew/.yardopts
+++ b/Library/Homebrew/.yardopts
@@ -2,12 +2,15 @@
 --main README.md
 --markup markdown
 --no-private
---load yard/ignore_directives.rb
+--plugin sorbet
+--load ./yard/docstring_parser.rb
 --template-path yard/templates
+--exclude sorbet/rbi/gems/
 --exclude test/
 --exclude vendor/
---exclude compat/
+--exclude yard/
 extend/os/**/*.rb
 **/*.rb
+**/*.rbi
 -
 *.md
diff --git a/Library/Homebrew/Gemfile b/Library/Homebrew/Gemfile
index fdb2de5c98727..3bcd332f44923 100644
--- a/Library/Homebrew/Gemfile
+++ b/Library/Homebrew/Gemfile
@@ -2,48 +2,84 @@
 
 source "https://rubygems.org"
 
-ruby ">= 2.6.0"
+# The default case (no envs), should always be a restrictive bound on the lowest supported minor version.
+# This is the branch that Dependabot will use.
+if ENV.fetch("HOMEBREW_USE_RUBY_FROM_PATH", "").empty?
+  ruby "~> 3.3.0"
+else
+  ruby ">= 3.3.0"
+end
 
 # disallowed gems (should not be used)
 # * nokogiri - use rexml instead for XML parsing
 
 # installed gems (should all be require: false)
-gem "bootsnap", require: false
-gem "byebug", require: false
-gem "json_schemer", require: false
-gem "minitest", require: false
-gem "parallel_tests", require: false
-gem "ronn", require: false
-gem "rspec", require: false
-gem "rspec-github", require: false
-gem "rspec-its", require: false
-gem "rspec_junit_formatter", require: false
-gem "rspec-retry", require: false
-gem "rspec-sorbet", require: false
-gem "rspec-wait", require: false
-gem "rubocop", require: false
-gem "rubocop-ast", require: false
-gem "simplecov", require: false
-gem "simplecov-cobertura", require: false
-gem "warning", require: false
-
-group :sorbet, optional: true do
-  gem "parlour", require: false
+# ALL gems that are not vendored should be in a group
+group :doc, optional: true do
+  gem "redcarpet", require: false
+  gem "yard", require: false
+  gem "yard-sorbet", require: false
+end
+group :ast, optional: true do
+  gem "rubocop-ast", require: false
+end
+group :formula_test, optional: true do
+  gem "minitest", require: false
+end
+group :livecheck, optional: true do
+  gem "ruby-progressbar", require: false
+end
+group :man, optional: true do
+  gem "kramdown", require: false
+end
+group :pr_upload, :bottle, optional: true do
+  gem "json_schemer", require: false
+end
+group :prof, optional: true do
+  gem "ruby-prof", require: false
+  gem "stackprof", require: false
+  gem "vernier", require: false
+end
+group :pry, optional: true do
+  gem "pry", require: false
+end
+group :style, optional: true do
+  gem "rubocop", require: false
+  gem "rubocop-md", require: false
+  gem "rubocop-performance", require: false
+  gem "rubocop-rspec", require: false
+  gem "rubocop-sorbet", require: false
+end
+group :tests, optional: true do
+  gem "parallel_tests", require: false
+  gem "rspec", require: false
+  gem "rspec-github", require: false
+  gem "rspec_junit_formatter", require: false
+  gem "rspec-retry", require: false
+  gem "rspec-sorbet", require: false
+  gem "simplecov", require: false
+  gem "simplecov-cobertura", require: false
+end
+group :typecheck, optional: true do
+  gem "method_source", require: false
   gem "sorbet-static-and-runtime", require: false
+  gem "spoom", require: false
   gem "tapioca", require: false
 end
+group :vscode, optional: true do
+  gem "ruby-lsp", require: false
+end
+
+# shared gems (used by multiple groups)
+group :audit, :bump_unversioned_casks, :livecheck, optional: true do
+  gem "rexml", require: false
+end
 
-# vendored gems
-gem "activesupport"
+# vendored gems (no group)
 gem "addressable"
 gem "concurrent-ruby"
-gem "did_you_mean" # remove when HOMEBREW_REQUIRED_RUBY_VERSION >= 2.7
-gem "mechanize"
 gem "patchelf"
 gem "plist"
-gem "rubocop-performance"
-gem "rubocop-rails"
-gem "rubocop-rspec"
-gem "rubocop-sorbet"
 gem "ruby-macho"
 gem "sorbet-runtime"
+gem "warning"
diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock
index 8e7b3d447a4b2..aec666a3ea53a 100644
--- a/Library/Homebrew/Gemfile.lock
+++ b/Library/Homebrew/Gemfile.lock
@@ -1,246 +1,198 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.1.6.1)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 1.6, < 2)
-      minitest (>= 5.1)
-      tzinfo (~> 2.0)
-      zeitwerk (~> 2.3)
-    addressable (2.8.0)
-      public_suffix (>= 2.0.2, < 5.0)
+    addressable (2.8.7)
+      public_suffix (>= 2.0.2, < 7.0)
     ast (2.4.2)
-    bindata (2.4.10)
-    bootsnap (1.12.0)
-      msgpack (~> 1.2)
-    byebug (11.1.3)
+    bigdecimal (3.1.8)
+    bindata (2.5.0)
     coderay (1.1.3)
-    commander (4.6.0)
-      highline (~> 2.0.0)
-    concurrent-ruby (1.1.10)
-    connection_pool (2.2.5)
-    did_you_mean (1.6.1)
-    diff-lcs (1.5.0)
-    docile (1.4.0)
-    domain_name (0.5.20190701)
-      unf (>= 0.0.5, < 1.0.0)
-    ecma-re-validator (0.4.0)
-      regexp_parser (~> 2.2)
-    elftools (1.1.3)
+    concurrent-ruby (1.3.4)
+    diff-lcs (1.5.1)
+    docile (1.4.1)
+    elftools (1.3.1)
       bindata (~> 2)
+    erubi (1.13.0)
     hana (1.3.7)
-    highline (2.0.3)
-    hpricot (0.8.6)
-    http-cookie (1.0.5)
-      domain_name (~> 0.5)
-    i18n (1.12.0)
-      concurrent-ruby (~> 1.0)
-    json (2.6.2)
-    json_schemer (0.2.21)
-      ecma-re-validator (~> 0.3)
+    json (2.7.5)
+    json_schemer (2.3.0)
+      bigdecimal
       hana (~> 1.3)
       regexp_parser (~> 2.0)
-      uri_template (~> 0.7)
-    mechanize (2.8.5)
-      addressable (~> 2.8)
-      domain_name (~> 0.5, >= 0.5.20190701)
-      http-cookie (~> 1.0, >= 1.0.3)
-      mime-types (~> 3.0)
-      net-http-digest_auth (~> 1.4, >= 1.4.1)
-      net-http-persistent (>= 2.5.2, < 5.0.dev)
-      nokogiri (~> 1.11, >= 1.11.2)
-      rubyntlm (~> 0.6, >= 0.6.3)
-      webrick (~> 1.7)
-      webrobots (~> 0.1.2)
-    method_source (1.0.0)
-    mime-types (3.4.1)
-      mime-types-data (~> 3.2015)
-    mime-types-data (3.2022.0105)
-    mini_portile2 (2.8.0)
-    minitest (5.16.2)
-    msgpack (1.5.3)
-    mustache (1.1.1)
-    net-http-digest_auth (1.4.1)
-    net-http-persistent (4.0.1)
-      connection_pool (~> 2.2)
-    nokogiri (1.13.7)
-      mini_portile2 (~> 2.8.0)
-      racc (~> 1.4)
-    parallel (1.22.1)
-    parallel_tests (3.11.1)
+      simpleidn (~> 0.2)
+    kramdown (2.4.0)
+      rexml
+    language_server-protocol (3.17.0.3)
+    logger (1.6.1)
+    method_source (1.1.0)
+    minitest (5.25.1)
+    netrc (0.11.0)
+    parallel (1.26.3)
+    parallel_tests (4.7.2)
       parallel
-    parlour (8.0.0)
-      commander (~> 4.5)
-      parser
-      rainbow (~> 3.0)
-      sorbet-runtime (>= 0.5)
-    parser (3.1.2.0)
+    parser (3.3.5.1)
       ast (~> 2.4.1)
-    patchelf (1.3.0)
-      elftools (>= 1.1.3)
-    plist (3.6.0)
-    pry (0.14.1)
+      racc
+    patchelf (1.5.1)
+      elftools (>= 1.3)
+    plist (3.7.1)
+    prism (1.2.0)
+    pry (0.14.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    public_suffix (4.0.7)
-    racc (1.6.0)
-    rack (2.2.4)
+    public_suffix (6.0.1)
+    racc (1.8.1)
     rainbow (3.1.1)
-    rbi (0.0.14)
-      ast
-      parser (>= 2.6.4.0)
+    rbi (0.2.1)
+      prism (~> 1.0)
       sorbet-runtime (>= 0.5.9204)
-      unparser
-    rdiscount (2.2.0.2)
-    regexp_parser (2.5.0)
-    rexml (3.2.5)
-    ronn (0.7.3)
-      hpricot (>= 0.8.2)
-      mustache (>= 0.7.0)
-      rdiscount (>= 1.5.8)
-    rspec (3.11.0)
-      rspec-core (~> 3.11.0)
-      rspec-expectations (~> 3.11.0)
-      rspec-mocks (~> 3.11.0)
-    rspec-core (3.11.0)
-      rspec-support (~> 3.11.0)
-    rspec-expectations (3.11.0)
+    rbs (3.6.1)
+      logger
+    redcarpet (3.6.0)
+    regexp_parser (2.9.2)
+    rexml (3.3.9)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.2)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.3)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-github (2.3.1)
+      rspec-support (~> 3.13.0)
+    rspec-github (2.4.0)
       rspec-core (~> 3.0)
-    rspec-its (1.3.0)
-      rspec-core (>= 3.0.0)
-      rspec-expectations (>= 3.0.0)
-    rspec-mocks (3.11.1)
+    rspec-mocks (3.13.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
+      rspec-support (~> 3.13.0)
     rspec-retry (0.6.2)
       rspec-core (> 3.3)
-    rspec-sorbet (1.8.3)
+    rspec-sorbet (1.9.2)
       sorbet-runtime
-    rspec-support (3.11.0)
-    rspec-wait (0.0.9)
-      rspec (>= 3, < 4)
-    rspec_junit_formatter (0.5.1)
+    rspec-support (3.13.1)
+    rspec_junit_formatter (0.6.0)
       rspec-core (>= 2, < 4, != 2.12.0)
-    rubocop (1.32.0)
+    rubocop (1.67.0)
       json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
-      parser (>= 3.1.0.0)
+      parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 1.8, < 3.0)
-      rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.19.1, < 2.0)
+      regexp_parser (>= 2.4, < 3.0)
+      rubocop-ast (>= 1.32.2, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.19.1)
-      parser (>= 3.1.1.0)
-    rubocop-performance (1.14.3)
-      rubocop (>= 1.7.0, < 2.0)
-      rubocop-ast (>= 0.4.0)
-    rubocop-rails (2.15.2)
-      activesupport (>= 4.2.0)
-      rack (>= 1.1)
-      rubocop (>= 1.7.0, < 2.0)
-    rubocop-rspec (2.12.1)
-      rubocop (~> 1.31)
-    rubocop-sorbet (0.6.11)
-      rubocop (>= 0.90.0)
-    ruby-macho (3.0.0)
-    ruby-progressbar (1.11.0)
-    rubyntlm (0.6.3)
-    simplecov (0.21.2)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.33.0)
+      parser (>= 3.3.1.0)
+    rubocop-md (1.2.4)
+      rubocop (>= 1.45)
+    rubocop-performance (1.22.1)
+      rubocop (>= 1.48.1, < 2.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+    rubocop-rspec (3.2.0)
+      rubocop (~> 1.61)
+    rubocop-sorbet (0.8.7)
+      rubocop (>= 1)
+    ruby-lsp (0.21.2)
+      language_server-protocol (~> 3.17.0)
+      prism (>= 1.2, < 2.0)
+      rbs (>= 3, < 4)
+      sorbet-runtime (>= 0.5.10782)
+    ruby-macho (4.1.0)
+    ruby-prof (1.7.1)
+    ruby-progressbar (1.13.0)
+    simplecov (0.22.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
     simplecov-cobertura (2.1.0)
       rexml
       simplecov (~> 0.19)
-    simplecov-html (0.12.3)
+    simplecov-html (0.13.1)
     simplecov_json_formatter (0.1.4)
-    sorbet (0.5.10175)
-      sorbet-static (= 0.5.10175)
-    sorbet-runtime (0.5.10175)
-    sorbet-static (0.5.10175-universal-darwin-14)
-    sorbet-static-and-runtime (0.5.10175)
-      sorbet (= 0.5.10175)
-      sorbet-runtime (= 0.5.10175)
-    spoom (1.1.11)
-      sorbet (>= 0.5.9204)
-      sorbet-runtime (>= 0.5.9204)
+    simpleidn (0.2.3)
+    sorbet (0.5.11633)
+      sorbet-static (= 0.5.11633)
+    sorbet-runtime (0.5.11633)
+    sorbet-static (0.5.11633-aarch64-linux)
+    sorbet-static (0.5.11633-universal-darwin)
+    sorbet-static (0.5.11633-x86_64-linux)
+    sorbet-static-and-runtime (0.5.11633)
+      sorbet (= 0.5.11633)
+      sorbet-runtime (= 0.5.11633)
+    spoom (1.5.0)
+      erubi (>= 1.10.0)
+      prism (>= 0.28.0)
+      sorbet-static-and-runtime (>= 0.5.10187)
       thor (>= 0.19.2)
-    tapioca (0.7.2)
-      bundler (>= 1.17.3)
-      pry (>= 0.12.2)
-      rbi (~> 0.0.0, >= 0.0.14)
-      sorbet-runtime (>= 0.5.9204)
-      sorbet-static (>= 0.5.9204)
-      spoom (~> 1.1.0, >= 1.1.11)
+    stackprof (0.2.26)
+    tapioca (0.16.3)
+      bundler (>= 2.2.25)
+      netrc (>= 0.11.0)
+      parallel (>= 1.21.0)
+      rbi (~> 0.2)
+      sorbet-static-and-runtime (>= 0.5.11087)
+      spoom (>= 1.2.0)
       thor (>= 1.2.0)
       yard-sorbet
-    thor (1.2.1)
-    tzinfo (2.0.5)
-      concurrent-ruby (~> 1.0)
-    unf (0.1.4)
-      unf_ext
-    unf_ext (0.0.8.2)
-    unicode-display_width (2.2.0)
-    unparser (0.6.4)
-      diff-lcs (~> 1.3)
-      parser (>= 3.1.0)
-    uri_template (0.7.0)
-    warning (1.3.0)
-    webrick (1.7.0)
-    webrobots (0.1.2)
-    yard (0.9.28)
-      webrick (~> 1.7.0)
-    yard-sorbet (0.6.1)
-      sorbet-runtime (>= 0.5)
-      yard (>= 0.9)
-    zeitwerk (2.6.0)
+    thor (1.3.2)
+    unicode-display_width (2.6.0)
+    vernier (1.2.1)
+    warning (1.4.0)
+    yard (0.9.37)
+    yard-sorbet (0.9.0)
+      sorbet-runtime
+      yard
 
 PLATFORMS
-  ruby
+  aarch64-linux
+  arm-linux
+  arm64-darwin
+  x86_64-darwin
+  x86_64-linux
 
 DEPENDENCIES
-  activesupport
   addressable
-  bootsnap
-  byebug
   concurrent-ruby
-  did_you_mean
   json_schemer
-  mechanize
+  kramdown
+  method_source
   minitest
   parallel_tests
-  parlour
   patchelf
   plist
-  ronn
+  pry
+  redcarpet
+  rexml
   rspec
   rspec-github
-  rspec-its
   rspec-retry
   rspec-sorbet
-  rspec-wait
   rspec_junit_formatter
   rubocop
   rubocop-ast
+  rubocop-md
   rubocop-performance
-  rubocop-rails
   rubocop-rspec
   rubocop-sorbet
+  ruby-lsp
   ruby-macho
+  ruby-prof
+  ruby-progressbar
   simplecov
   simplecov-cobertura
   sorbet-runtime
   sorbet-static-and-runtime
+  spoom
+  stackprof
   tapioca
+  vernier
   warning
+  yard
+  yard-sorbet
 
 RUBY VERSION
-   ruby 2.6.8p205
+   ruby 3.3.5p100
 
 BUNDLED WITH
-   1.17.3
+   2.5.20
diff --git a/Library/Homebrew/PATH.rb b/Library/Homebrew/PATH.rb
index 6e48ef8553ea9..46fd38bb3f32b 100644
--- a/Library/Homebrew/PATH.rb
+++ b/Library/Homebrew/PATH.rb
@@ -1,28 +1,24 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-# Represention of a `*PATH` environment variable.
-#
-# @api private
-class PATH
-  extend T::Sig
+require "forwardable"
 
+# Representation of a `*PATH` environment variable.
+class PATH
   include Enumerable
   extend Forwardable
+  extend T::Generic
 
   delegate each: :@paths
 
-  # FIXME: Enable cop again when https://github.com/sorbet/sorbet/issues/3532 is fixed.
-  # rubocop:disable Style/MutableConstant
+  Elem = type_member(:out) { { fixed: String } }
   Element = T.type_alias { T.nilable(T.any(Pathname, String, PATH)) }
   private_constant :Element
   Elements = T.type_alias { T.any(Element, T::Array[Element]) }
   private_constant :Elements
-  # rubocop:enable Style/MutableConstant
-
   sig { params(paths: Elements).void }
   def initialize(*paths)
-    @paths = parse(paths)
+    @paths = T.let(parse(paths), T::Array[String])
   end
 
   sig { params(paths: Elements).returns(T.self_type) }
@@ -63,7 +59,9 @@ def to_ary
   def to_str
     @paths.join(File::PATH_SEPARATOR)
   end
-  alias to_s to_str
+
+  sig { returns(String) }
+  def to_s = to_str
 
   sig { params(other: T.untyped).returns(T::Boolean) }
   def ==(other)
@@ -79,7 +77,7 @@ def empty?
 
   sig { returns(T.nilable(T.self_type)) }
   def existing
-    existing_path = select(&File.method(:directory?))
+    existing_path = select { File.directory?(_1) }
     # return nil instead of empty PATH, to unset environment variables
     existing_path unless existing_path.empty?
   end
diff --git a/Library/Homebrew/abstract_command.rb b/Library/Homebrew/abstract_command.rb
new file mode 100644
index 0000000000000..03b493c83431c
--- /dev/null
+++ b/Library/Homebrew/abstract_command.rb
@@ -0,0 +1,82 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "cli/parser"
+require "shell_command"
+
+module Homebrew
+  # Subclass this to implement a `brew` command. This is preferred to declaring a named function in the `Homebrew`
+  # module, because:
+  #
+  # - Each Command lives in an isolated namespace.
+  # - Each Command implements a defined interface.
+  # - `args` is available as an instance method and thus does not need to be passed as an argument to helper methods.
+  # - Subclasses no longer need to reference `CLI::Parser` or parse args explicitly.
+  #
+  # To subclass, implement a `run` method and provide a `cmd_args` block to document the command and its allowed args.
+  # To generate method signatures for command args, run `brew typecheck --update`.
+  #
+  # @api public
+  class AbstractCommand
+    extend T::Helpers
+
+    abstract!
+
+    class << self
+      sig { returns(T.nilable(T.class_of(CLI::Args))) }
+      attr_reader :args_class
+
+      sig { returns(String) }
+      def command_name
+        require "utils"
+
+        Utils.underscore(T.must(name).split("::").fetch(-1))
+             .tr("_", "-")
+             .delete_suffix("-cmd")
+      end
+
+      # @return the AbstractCommand subclass associated with the brew CLI command name.
+      sig { params(name: String).returns(T.nilable(T.class_of(AbstractCommand))) }
+      def command(name) = subclasses.find { _1.command_name == name }
+
+      sig { returns(T::Boolean) }
+      def dev_cmd? = T.must(name).start_with?("Homebrew::DevCmd")
+
+      sig { returns(T::Boolean) }
+      def ruby_cmd? = !include?(Homebrew::ShellCommand)
+
+      sig { returns(CLI::Parser) }
+      def parser = CLI::Parser.new(self, &@parser_block)
+
+      private
+
+      # The description and arguments of the command should be defined within this block.
+      #
+      # @api public
+      sig { params(block: T.proc.bind(CLI::Parser).void).void }
+      def cmd_args(&block)
+        @parser_block = T.let(block, T.nilable(T.proc.void))
+        @args_class = T.let(const_set(:Args, Class.new(CLI::Args)), T.nilable(T.class_of(CLI::Args)))
+      end
+    end
+
+    sig { returns(CLI::Args) }
+    attr_reader :args
+
+    sig { params(argv: T::Array[String]).void }
+    def initialize(argv = ARGV.freeze)
+      @args = T.let(self.class.parser.parse(argv), CLI::Args)
+    end
+
+    # This method will be invoked when the command is run.
+    #
+    # @api public
+    sig { abstract.void }
+    def run; end
+  end
+
+  module Cmd
+    # The command class for `brew` itself, allowing its args to be parsed.
+    class Brew < AbstractCommand; end
+  end
+end
diff --git a/Library/Homebrew/api.rb b/Library/Homebrew/api.rb
index e4028b26781eb..103ac6eec4cb9 100644
--- a/Library/Homebrew/api.rb
+++ b/Library/Homebrew/api.rb
@@ -1,42 +1,207 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "api/analytics"
 require "api/cask"
-require "api/cask-source"
 require "api/formula"
-require "api/versions"
-require "extend/cachable"
+require "base64" # TODO: vendor this for Ruby 3.4.
 
 module Homebrew
   # Helper functions for using Homebrew's formulae.brew.sh API.
-  #
-  # @api private
   module API
-    extend T::Sig
-
     extend Cachable
 
-    module_function
-
-    API_DOMAIN = "https://formulae.brew.sh/api"
     HOMEBREW_CACHE_API = (HOMEBREW_CACHE/"api").freeze
+    HOMEBREW_CACHE_API_SOURCE = (HOMEBREW_CACHE/"api-source").freeze
 
-    sig { params(endpoint: String, json: T::Boolean).returns(T.any(String, Hash)) }
-    def fetch(endpoint, json: true)
+    sig { params(endpoint: String).returns(Hash) }
+    def self.fetch(endpoint)
       return cache[endpoint] if cache.present? && cache.key?(endpoint)
 
-      api_url = "#{API_DOMAIN}/#{endpoint}"
-      output = Utils::Curl.curl_output("--fail", api_url, max_time: 5)
+      api_url = "#{Homebrew::EnvConfig.api_domain}/#{endpoint}"
+      output = Utils::Curl.curl_output("--fail", api_url)
+      if !output.success? && Homebrew::EnvConfig.api_domain != HOMEBREW_API_DEFAULT_DOMAIN
+        # Fall back to the default API domain and try again
+        api_url = "#{HOMEBREW_API_DEFAULT_DOMAIN}/#{endpoint}"
+        output = Utils::Curl.curl_output("--fail", api_url)
+      end
       raise ArgumentError, "No file found at #{Tty.underline}#{api_url}#{Tty.reset}" unless output.success?
 
-      cache[endpoint] = if json
-        JSON.parse(output.stdout)
-      else
-        output.stdout
-      end
+      cache[endpoint] = JSON.parse(output.stdout, freeze: true)
     rescue JSON::ParserError
       raise ArgumentError, "Invalid JSON file: #{Tty.underline}#{api_url}#{Tty.reset}"
     end
+
+    sig {
+      params(endpoint: String, target: Pathname, stale_seconds: Integer).returns([T.any(Array, Hash), T::Boolean])
+    }
+    def self.fetch_json_api_file(endpoint, target: HOMEBREW_CACHE_API/endpoint,
+                                 stale_seconds: Homebrew::EnvConfig.api_auto_update_secs.to_i)
+      # Lazy-load dependency.
+      require "development_tools"
+
+      retry_count = 0
+      url = "#{Homebrew::EnvConfig.api_domain}/#{endpoint}"
+      default_url = "#{HOMEBREW_API_DEFAULT_DOMAIN}/#{endpoint}"
+
+      if Homebrew.running_as_root_but_not_owned_by_root? &&
+         (!target.exist? || target.empty?)
+        odie "Need to download #{url} but cannot as root! Run `brew update` without `sudo` first then try again."
+      end
+
+      curl_args = Utils::Curl.curl_args(retries: 0) + %W[
+        --compressed
+        --speed-limit #{ENV.fetch("HOMEBREW_CURL_SPEED_LIMIT")}
+        --speed-time #{ENV.fetch("HOMEBREW_CURL_SPEED_TIME")}
+      ]
+
+      insecure_download = DevelopmentTools.ca_file_substitution_required? ||
+                          DevelopmentTools.curl_substitution_required?
+      skip_download = target.exist? &&
+                      !target.empty? &&
+                      (!Homebrew.auto_update_command? ||
+                        Homebrew::EnvConfig.no_auto_update? ||
+                      ((Time.now - stale_seconds) < target.mtime))
+      skip_download ||= Homebrew.running_as_root_but_not_owned_by_root?
+
+      json_data = begin
+        begin
+          args = curl_args.dup
+          args.prepend("--time-cond", target.to_s) if target.exist? && !target.empty?
+          if insecure_download
+            opoo DevelopmentTools.insecure_download_warning(endpoint)
+            args.append("--insecure")
+          end
+          unless skip_download
+            ohai "Downloading #{url}" if $stdout.tty? && !Context.current.quiet?
+            # Disable retries here, we handle them ourselves below.
+            Utils::Curl.curl_download(*args, url, to: target, retries: 0, show_error: false)
+          end
+        rescue ErrorDuringExecution
+          if url == default_url
+            raise unless target.exist?
+            raise if target.empty?
+          elsif retry_count.zero? || !target.exist? || target.empty?
+            # Fall back to the default API domain and try again
+            # This block will be executed only once, because we set `url` to `default_url`
+            url = default_url
+            target.unlink if target.exist? && target.empty?
+            skip_download = false
+
+            retry
+          end
+
+          opoo "#{target.basename}: update failed, falling back to cached version."
+        end
+
+        mtime = insecure_download ? Time.new(1970, 1, 1) : Time.now
+        FileUtils.touch(target, mtime:) unless skip_download
+        JSON.parse(target.read, freeze: true)
+      rescue JSON::ParserError
+        target.unlink
+        retry_count += 1
+        skip_download = false
+        odie "Cannot download non-corrupt #{url}!" if retry_count > Homebrew::EnvConfig.curl_retries.to_i
+
+        retry
+      end
+
+      if endpoint.end_with?(".jws.json")
+        success, data = verify_and_parse_jws(json_data)
+        unless success
+          target.unlink
+          odie <<~EOS
+            Failed to verify integrity (#{data}) of:
+              #{url}
+            Potential MITM attempt detected. Please run `brew update` and try again.
+          EOS
+        end
+        [data, !skip_download]
+      else
+        [json_data, !skip_download]
+      end
+    end
+
+    sig { params(json: Hash).returns(Hash) }
+    def self.merge_variations(json)
+      return json unless json.key?("variations")
+
+      bottle_tag = ::Utils::Bottles::Tag.new(system: Homebrew::SimulateSystem.current_os,
+                                             arch:   Homebrew::SimulateSystem.current_arch)
+
+      if (variation = json.dig("variations", bottle_tag.to_s).presence)
+        json = json.merge(variation)
+      end
+
+      json.except("variations")
+    end
+
+    sig { params(names: T::Array[String], type: String, regenerate: T::Boolean).returns(T::Boolean) }
+    def self.write_names_file(names, type, regenerate:)
+      names_path = HOMEBREW_CACHE_API/"#{type}_names.txt"
+      if !names_path.exist? || regenerate
+        names_path.write(names.join("\n"))
+        return true
+      end
+
+      false
+    end
+
+    sig { params(json_data: Hash).returns([T::Boolean, T.any(String, Array, Hash)]) }
+    private_class_method def self.verify_and_parse_jws(json_data)
+      signatures = json_data["signatures"]
+      homebrew_signature = signatures&.find { |sig| sig.dig("header", "kid") == "homebrew-1" }
+      return false, "key not found" if homebrew_signature.nil?
+
+      header = JSON.parse(Base64.urlsafe_decode64(homebrew_signature["protected"]))
+      if header["alg"] != "PS512" || header["b64"] != false # NOTE: nil has a meaning of true
+        return false, "invalid algorithm"
+      end
+
+      require "openssl"
+
+      pubkey = OpenSSL::PKey::RSA.new((HOMEBREW_LIBRARY_PATH/"api/homebrew-1.pem").read)
+      signing_input = "#{homebrew_signature["protected"]}.#{json_data["payload"]}"
+      unless pubkey.verify_pss("SHA512",
+                               Base64.urlsafe_decode64(homebrew_signature["signature"]),
+                               signing_input,
+                               salt_length: :digest,
+                               mgf1_hash:   "SHA512")
+        return false, "signature mismatch"
+      end
+
+      [true, JSON.parse(json_data["payload"], freeze: true)]
+    end
+
+    sig { params(path: Pathname).returns(T.nilable(Tap)) }
+    def self.tap_from_source_download(path)
+      path = path.expand_path
+      source_relative_path = path.relative_path_from(Homebrew::API::HOMEBREW_CACHE_API_SOURCE)
+      return if source_relative_path.to_s.start_with?("../")
+
+      org, repo = source_relative_path.each_filename.first(2)
+      return if org.blank? || repo.blank?
+
+      Tap.fetch(org, repo)
+    end
+
+    sig { returns(T::Boolean) }
+    def self.internal_json_v3?
+      ENV["HOMEBREW_INTERNAL_JSON_V3"].present?
+    end
+  end
+
+  sig { params(block: T.proc.returns(T.untyped)).returns(T.untyped) }
+  def self.with_no_api_env(&block)
+    return yield if Homebrew::EnvConfig.no_install_from_api?
+
+    with_env(HOMEBREW_NO_INSTALL_FROM_API: "1", HOMEBREW_AUTOMATICALLY_SET_NO_INSTALL_FROM_API: "1", &block)
+  end
+
+  sig { params(condition: T::Boolean, block: T.proc.returns(T.untyped)).returns(T.untyped) }
+  def self.with_no_api_env_if_needed(condition, &block)
+    return yield unless condition
+
+    with_no_api_env(&block)
   end
 end
diff --git a/Library/Homebrew/api/analytics.rb b/Library/Homebrew/api/analytics.rb
index 87e57b1b0efa4..2bf4a62e49a33 100644
--- a/Library/Homebrew/api/analytics.rb
+++ b/Library/Homebrew/api/analytics.rb
@@ -1,22 +1,18 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
   module API
     # Helper functions for using the analytics JSON API.
-    #
-    # @api private
     module Analytics
       class << self
-        extend T::Sig
-
         sig { returns(String) }
         def analytics_api_path
           "analytics"
         end
         alias generic_analytics_api_path analytics_api_path
 
-        sig { params(category: String, days: T.any(Integer, String)).returns(Hash) }
+        sig { params(category: String, days: T.any(Integer, String)).returns(T::Hash[String, T.untyped]) }
         def fetch(category, days)
           Homebrew::API.fetch "#{analytics_api_path}/#{category}/#{days}d.json"
         end
diff --git a/Library/Homebrew/api/cask-source.rb b/Library/Homebrew/api/cask-source.rb
deleted file mode 100644
index 0c1cd67a21849..0000000000000
--- a/Library/Homebrew/api/cask-source.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-module Homebrew
-  module API
-    # Helper functions for using the cask source API.
-    #
-    # @api private
-    module CaskSource
-      class << self
-        extend T::Sig
-
-        sig { params(token: String).returns(Hash) }
-        def fetch(token)
-          token = token.sub(%r{^homebrew/cask/}, "")
-          Homebrew::API.fetch "cask-source/#{token}.rb", json: false
-        end
-
-        sig { params(token: String).returns(T::Boolean) }
-        def available?(token)
-          fetch token
-          true
-        rescue ArgumentError
-          false
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/api/cask.rb b/Library/Homebrew/api/cask.rb
index b7ec658bf2382..03b94f848a3cb 100644
--- a/Library/Homebrew/api/cask.rb
+++ b/Library/Homebrew/api/cask.rb
@@ -1,19 +1,93 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "extend/cachable"
+require "api/download"
+
 module Homebrew
   module API
     # Helper functions for using the cask JSON API.
-    #
-    # @api private
     module Cask
-      class << self
-        extend T::Sig
+      extend Cachable
+
+      DEFAULT_API_FILENAME = "cask.jws.json"
+
+      private_class_method :cache
+
+      sig { params(token: String).returns(Hash) }
+      def self.fetch(token)
+        Homebrew::API.fetch "cask/#{token}.json"
+      end
+
+      sig { params(cask: ::Cask::Cask).returns(::Cask::Cask) }
+      def self.source_download(cask)
+        path = cask.ruby_source_path.to_s || "Casks/#{cask.token}.rb"
+        sha256 = cask.ruby_source_checksum[:sha256]
+        checksum = Checksum.new(sha256) if sha256
+        git_head = cask.tap_git_head || "HEAD"
+        tap = cask.tap&.full_name || "Homebrew/homebrew-cask"
+
+        download = Homebrew::API::Download.new(
+          "https://raw.githubusercontent.com/#{tap}/#{git_head}/#{path}",
+          checksum,
+          mirrors: [
+            "#{HOMEBREW_API_DEFAULT_DOMAIN}/cask-source/#{File.basename(path)}",
+          ],
+          cache:   HOMEBREW_CACHE_API_SOURCE/"#{tap}/#{git_head}/Cask",
+        )
+        download.fetch
+        ::Cask::CaskLoader::FromPathLoader.new(download.symlink_location)
+                                          .load(config: cask.config)
+      end
+
+      def self.cached_json_file_path
+        HOMEBREW_CACHE_API/DEFAULT_API_FILENAME
+      end
+
+      sig { returns(T::Boolean) }
+      def self.download_and_cache_data!
+        json_casks, updated = Homebrew::API.fetch_json_api_file DEFAULT_API_FILENAME
+
+        cache["renames"] = {}
+        cache["casks"] = json_casks.to_h do |json_cask|
+          token = json_cask["token"]
+
+          json_cask.fetch("old_tokens", []).each do |old_token|
+            cache["renames"][old_token] = token
+          end
 
-        sig { params(name: String).returns(Hash) }
-        def fetch(name)
-          Homebrew::API.fetch "cask/#{name}.json"
+          [token, json_cask.except("token")]
         end
+
+        updated
+      end
+      private_class_method :download_and_cache_data!
+
+      sig { returns(T::Hash[String, Hash]) }
+      def self.all_casks
+        unless cache.key?("casks")
+          json_updated = download_and_cache_data!
+          write_names(regenerate: json_updated)
+        end
+
+        cache.fetch("casks")
+      end
+
+      sig { returns(T::Hash[String, String]) }
+      def self.all_renames
+        unless cache.key?("renames")
+          json_updated = download_and_cache_data!
+          write_names(regenerate: json_updated)
+        end
+
+        cache.fetch("renames")
+      end
+
+      sig { params(regenerate: T::Boolean).void }
+      def self.write_names(regenerate: false)
+        download_and_cache_data! unless cache.key?("casks")
+
+        Homebrew::API.write_names_file(all_casks.keys, "cask", regenerate:)
       end
     end
   end
diff --git a/Library/Homebrew/api/download.rb b/Library/Homebrew/api/download.rb
new file mode 100644
index 0000000000000..e848daf328481
--- /dev/null
+++ b/Library/Homebrew/api/download.rb
@@ -0,0 +1,60 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "downloadable"
+
+module Homebrew
+  module API
+    class DownloadStrategy < CurlDownloadStrategy
+      sig { override.returns(Pathname) }
+      def symlink_location
+        cache/name
+      end
+    end
+
+    class Download
+      include Downloadable
+
+      sig {
+        params(
+          url:      String,
+          checksum: T.nilable(Checksum),
+          mirrors:  T::Array[String],
+          cache:    T.nilable(Pathname),
+        ).void
+      }
+      def initialize(url, checksum, mirrors: [], cache: nil)
+        super()
+        @url = T.let(URL.new(url, using: API::DownloadStrategy), URL)
+        @checksum = checksum
+        @mirrors = mirrors
+        @cache = cache
+      end
+
+      sig { override.returns(API::DownloadStrategy) }
+      def downloader
+        T.cast(super, API::DownloadStrategy)
+      end
+
+      sig { override.returns(String) }
+      def name
+        download_name
+      end
+
+      sig { override.returns(String) }
+      def download_type
+        "API source"
+      end
+
+      sig { override.returns(Pathname) }
+      def cache
+        @cache || super
+      end
+
+      sig { returns(Pathname) }
+      def symlink_location
+        downloader.symlink_location
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/api/formula.rb b/Library/Homebrew/api/formula.rb
index cd65bdbe321f2..0baaa94e9dd06 100644
--- a/Library/Homebrew/api/formula.rb
+++ b/Library/Homebrew/api/formula.rb
@@ -1,45 +1,141 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "extend/cachable"
+require "api/download"
+
 module Homebrew
   module API
     # Helper functions for using the formula JSON API.
-    #
-    # @api private
     module Formula
-      class << self
-        extend T::Sig
+      extend Cachable
 
-        sig { returns(String) }
-        def formula_api_path
-          "formula"
-        end
-        alias generic_formula_api_path formula_api_path
+      DEFAULT_API_FILENAME = "formula.jws.json"
+      INTERNAL_V3_API_FILENAME = "internal/v3/homebrew-core.jws.json"
+
+      private_class_method :cache
+
+      sig { params(name: String).returns(Hash) }
+      def self.fetch(name)
+        Homebrew::API.fetch "formula/#{name}.json"
+      end
 
-        sig { returns(String) }
-        def cached_formula_json_file
-          HOMEBREW_CACHE_API/"#{formula_api_path}.json"
+      sig { params(formula: ::Formula).returns(::Formula) }
+      def self.source_download(formula)
+        path = formula.ruby_source_path || "Formula/#{formula.name}.rb"
+        git_head = formula.tap_git_head || "HEAD"
+        tap = formula.tap&.full_name || "Homebrew/homebrew-core"
+
+        download = Homebrew::API::Download.new(
+          "https://raw.githubusercontent.com/#{tap}/#{git_head}/#{path}",
+          formula.ruby_source_checksum,
+          cache: HOMEBREW_CACHE_API_SOURCE/"#{tap}/#{git_head}/Formula",
+        )
+        download.fetch
+
+        with_env(HOMEBREW_FORBID_PACKAGES_FROM_PATHS: nil) do
+          Formulary.factory(download.symlink_location,
+                            formula.active_spec_sym,
+                            alias_path: formula.alias_path,
+                            flags:      formula.class.build_flags)
         end
+      end
 
-        sig { params(name: String).returns(Hash) }
-        def fetch(name)
-          Homebrew::API.fetch "#{formula_api_path}/#{name}.json"
+      def self.cached_json_file_path
+        if Homebrew::API.internal_json_v3?
+          HOMEBREW_CACHE_API/INTERNAL_V3_API_FILENAME
+        else
+          HOMEBREW_CACHE_API/DEFAULT_API_FILENAME
         end
+      end
+
+      sig { returns(T::Boolean) }
+      def self.download_and_cache_data!
+        if Homebrew::API.internal_json_v3?
+          json_formulae, updated = Homebrew::API.fetch_json_api_file INTERNAL_V3_API_FILENAME
+          overwrite_cache! T.cast(json_formulae, T::Hash[String, T.untyped])
+        else
+          json_formulae, updated = Homebrew::API.fetch_json_api_file DEFAULT_API_FILENAME
 
-        sig { returns(Array) }
-        def all_formulae
-          @all_formulae ||= begin
-            curl_args = %w[--compressed --silent https://formulae.brew.sh/api/formula.json]
-            if cached_formula_json_file.exist? && !cached_formula_json_file.empty?
-              curl_args.prepend("--time-cond", cached_formula_json_file)
+          cache["aliases"] = {}
+          cache["renames"] = {}
+          cache["formulae"] = json_formulae.to_h do |json_formula|
+            json_formula["aliases"].each do |alias_name|
+              cache["aliases"][alias_name] = json_formula["name"]
+            end
+            (json_formula["oldnames"] || [json_formula["oldname"]].compact).each do |oldname|
+              cache["renames"][oldname] = json_formula["name"]
             end
-            curl_download(*curl_args, to: HOMEBREW_CACHE_API/"#{formula_api_path}.json", max_time: 5)
 
-            json_formulae = JSON.parse(cached_formula_json_file.read)
+            [json_formula["name"], json_formula.except("name")]
+          end
+        end
 
-            json_formulae.to_h do |json_formula|
-              [json_formula["name"], json_formula.except("name")]
-            end
+        updated
+      end
+      private_class_method :download_and_cache_data!
+
+      sig { returns(T::Hash[String, Hash]) }
+      def self.all_formulae
+        unless cache.key?("formulae")
+          json_updated = download_and_cache_data!
+          write_names_and_aliases(regenerate: json_updated)
+        end
+
+        cache["formulae"]
+      end
+
+      sig { returns(T::Hash[String, String]) }
+      def self.all_aliases
+        unless cache.key?("aliases")
+          json_updated = download_and_cache_data!
+          write_names_and_aliases(regenerate: json_updated)
+        end
+
+        cache["aliases"]
+      end
+
+      sig { returns(T::Hash[String, String]) }
+      def self.all_renames
+        unless cache.key?("renames")
+          json_updated = download_and_cache_data!
+          write_names_and_aliases(regenerate: json_updated)
+        end
+
+        cache["renames"]
+      end
+
+      sig { returns(Hash) }
+      def self.tap_migrations
+        # Not sure that we need to reload here.
+        unless cache.key?("tap_migrations")
+          json_updated = download_and_cache_data!
+          write_names_and_aliases(regenerate: json_updated)
+        end
+
+        cache["tap_migrations"]
+      end
+
+      sig { returns(String) }
+      def self.tap_git_head
+        # Note sure we need to reload here.
+        unless cache.key?("tap_git_head")
+          json_updated = download_and_cache_data!
+          write_names_and_aliases(regenerate: json_updated)
+        end
+
+        cache["tap_git_head"]
+      end
+
+      sig { params(regenerate: T::Boolean).void }
+      def self.write_names_and_aliases(regenerate: false)
+        download_and_cache_data! unless cache.key?("formulae")
+
+        return unless Homebrew::API.write_names_file(all_formulae.keys, "formula", regenerate:)
+
+        (HOMEBREW_CACHE_API/"formula_aliases.txt").open("w") do |file|
+          all_aliases.each do |alias_name, real_name|
+            file.puts "#{alias_name}|#{real_name}"
           end
         end
       end
diff --git a/Library/Homebrew/api/homebrew-1.pem b/Library/Homebrew/api/homebrew-1.pem
new file mode 100644
index 0000000000000..ba15b24146a52
--- /dev/null
+++ b/Library/Homebrew/api/homebrew-1.pem
@@ -0,0 +1,14 @@
+-----BEGIN PUBLIC KEY-----
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAyKoOYzp1rhwXISRi61BY
+XBEr2PalSK8lEVOL2USy7mpy0OubOlFyujawyQcBcCn+uPOJ/WaK+POhNWcLLoiK
+L2m8GViaQm7SMwdLKUXFgKSPHcG/1m6Vu+TNBKTfQqT60PjEYIrn5NW9ZrM0cUhK
+REmsbeAMBevdSaW9UwY9iIhprrgovvT8SzKhF8ZOIZKXfJX4VNk0y/7VJYNuGGqH
+3npxV7OKd4yTGRGqFcC9kJ84me3thiu0yqlOjASmfWIwIwcfp4j6BEM2LuqKd7yX
+h51/O+MTthkuxV36moDKfdgdOFsvlCFkziaYLScCX9lOlmZHtOfJTAOXxTmM7qGr
+wTGK0vhvTi8k9dBmH/dccredQBtPOfM/FEdeyakGLoTcDguiBS/4El3I2KtF6B2h
+OGoBumR915/cI4drr5yPMduZ7gjs7ZEZnVkeVzic24TfUHpnOYzrhucNJtHMBDj9
+6d1Gk82AhtuF9KlusLmCb6qXCWQSp/A4RZpN37E/p9q8rLp/7B/zp8X2TVvecPNy
+BdMagdktdEqK7WPlYMcUp56JaOph8vqYoU+oGyCpWoLvcXFb75o4eefuu6Rs5SyM
+c9JCCJ0DDFPjCRFnGPkvsKxFCzMFqH1jpWH0RQIrgmNVM5PO84iRH9YJsSPQzpMj
+KvK/ZH4YgR9wNkBNagFo7lsCAwEAAQ==
+-----END PUBLIC KEY-----
diff --git a/Library/Homebrew/api/versions.rb b/Library/Homebrew/api/versions.rb
deleted file mode 100644
index e2758c4b9c13d..0000000000000
--- a/Library/Homebrew/api/versions.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module Homebrew
-  module API
-    # Helper functions for using the versions JSON API.
-    #
-    # @api private
-    module Versions
-      class << self
-        extend T::Sig
-
-        def formulae
-          # The result is cached by Homebrew::API.fetch
-          Homebrew::API.fetch "versions-formulae.json"
-        end
-
-        def casks
-          # The result is cached by Homebrew::API.fetch
-          Homebrew::API.fetch "versions-casks.json"
-        end
-
-        sig { params(name: String).returns(T.nilable(PkgVersion)) }
-        def latest_formula_version(name)
-          versions = formulae
-          return unless versions.key? name
-
-          version = Version.new(versions[name]["version"])
-          revision = versions[name]["revision"]
-          PkgVersion.new(version, revision)
-        end
-
-        sig { params(token: String).returns(T.nilable(Version)) }
-        def latest_cask_version(token)
-          return unless casks.key? token
-
-          version = if casks[token]["versions"].key? MacOS.version.to_sym.to_s
-            casks[token]["versions"][MacOS.version.to_sym.to_s]
-          else
-            casks[token]["version"]
-          end
-          Version.new(version)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/ast_constants.rb b/Library/Homebrew/ast_constants.rb
index 1de605374de43..38df04869e65d 100644
--- a/Library/Homebrew/ast_constants.rb
+++ b/Library/Homebrew/ast_constants.rb
@@ -1,9 +1,9 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "macos_versions"
+require "macos_version"
 
-FORMULA_COMPONENT_PRECEDENCE_LIST = [
+FORMULA_COMPONENT_PRECEDENCE_LIST = T.let([
   [{ name: :include,   type: :method_call }],
   [{ name: :desc,      type: :method_call }],
   [{ name: :homepage,  type: :method_call }],
@@ -29,6 +29,10 @@
   [{ name: :depends_on, type: :method_call }],
   [{ name: :uses_from_macos, type: :method_call }],
   [{ name: :on_macos, type: :block_call }],
+  *MacOSVersion::SYMBOLS.keys.map do |os_name|
+    [{ name: :"on_#{os_name}", type: :block_call }]
+  end,
+  [{ name: :on_system, type: :block_call }],
   [{ name: :on_linux, type: :block_call }],
   [{ name: :on_arm, type: :block_call }],
   [{ name: :on_intel, type: :block_call }],
@@ -40,9 +44,11 @@
   [{ name: :go_resource, type: :block_call }, { name: :resource, type: :block_call }],
   [{ name: :patch, type: :method_call }, { name: :patch, type: :block_call }],
   [{ name: :needs, type: :method_call }],
+  [{ name: :allow_network_access!, type: :method_call }],
+  [{ name: :deny_network_access!, type: :method_call }],
   [{ name: :install, type: :method_definition }],
   [{ name: :post_install, type: :method_definition }],
   [{ name: :caveats, type: :method_definition }],
   [{ name: :plist_options, type: :method_call }, { name: :plist, type: :method_definition }],
   [{ name: :test, type: :block_call }],
-].freeze
+].freeze, T::Array[[{ name: Symbol, type: Symbol }]])
diff --git a/Library/Homebrew/attestation.rb b/Library/Homebrew/attestation.rb
new file mode 100644
index 0000000000000..d7479057ebea5
--- /dev/null
+++ b/Library/Homebrew/attestation.rb
@@ -0,0 +1,272 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "date"
+require "json"
+require "utils/popen"
+require "utils/github/api"
+require "exceptions"
+require "system_command"
+
+module Homebrew
+  module Attestation
+    extend SystemCommand::Mixin
+
+    # @api private
+    HOMEBREW_CORE_REPO = "Homebrew/homebrew-core"
+
+    # @api private
+    BACKFILL_REPO = "trailofbits/homebrew-brew-verify"
+
+    # No backfill attestations after this date are considered valid.
+    #
+    # This date is shortly after the backfill operation for homebrew-core
+    # completed, as can be seen here: <https://github.com/trailofbits/homebrew-brew-verify/attestations>.
+    #
+    # In effect, this means that, even if an attacker is able to compromise the backfill
+    # signing workflow, they will be unable to convince a verifier to accept their newer,
+    # malicious backfilled signatures.
+    #
+    # @api private
+    BACKFILL_CUTOFF = T.let(DateTime.new(2024, 3, 14).freeze, DateTime)
+
+    # Raised when the attestation was not found.
+    #
+    # @api private
+    class MissingAttestationError < RuntimeError; end
+
+    # Raised when attestation verification fails.
+    #
+    # @api private
+    class InvalidAttestationError < RuntimeError; end
+
+    # Raised if attestation verification cannot continue due to missing
+    # credentials.
+    #
+    # @api private
+    class GhAuthNeeded < RuntimeError; end
+
+    # Raised if attestation verification cannot continue due to invalid
+    # credentials.
+    #
+    # @api private
+    class GhAuthInvalid < RuntimeError; end
+
+    # Raised if attestation verification cannot continue due to `gh`
+    # being incompatible with attestations, typically because it's too old.
+    #
+    # @api private
+    class GhIncompatible < RuntimeError; end
+
+    # Returns whether attestation verification is enabled.
+    #
+    # @api private
+    sig { returns(T::Boolean) }
+    def self.enabled?
+      return false if Homebrew::EnvConfig.no_verify_attestations?
+      return true if Homebrew::EnvConfig.verify_attestations?
+      return false if ENV.fetch("CI", false)
+      return false if OS.unsupported_configuration?
+
+      # Always check credentials last to avoid unnecessary credential extraction.
+      (Homebrew::EnvConfig.developer? || Homebrew::EnvConfig.devcmdrun?) && GitHub::API.credentials.present?
+    end
+
+    # Returns a path to a suitable `gh` executable for attestation verification.
+    #
+    # @api private
+    sig { returns(Pathname) }
+    def self.gh_executable
+      @gh_executable ||= T.let(nil, T.nilable(Pathname))
+      return @gh_executable if @gh_executable.present?
+
+      # NOTE: We set HOMEBREW_NO_VERIFY_ATTESTATIONS when installing `gh` itself,
+      #       to prevent a cycle during bootstrapping. This can eventually be resolved
+      #       by vendoring a pure-Ruby Sigstore verifier client.
+      with_env(HOMEBREW_NO_VERIFY_ATTESTATIONS: "1") do
+        @gh_executable = ensure_executable!("gh", reason: "verifying attestations", latest: true)
+      end
+
+      T.must(@gh_executable)
+    end
+
+    # Prioritize installing `gh` first if it's in the formula list
+    # or check for the existence of the `gh` executable elsewhere.
+    #
+    # This ensures that a valid version of `gh` is installed before
+    # we use it to check the attestations of any other formulae we
+    # want to install.
+    #
+    # @api private
+    sig { params(formulae: T::Array[Formula]).returns(T::Array[Formula]) }
+    def self.sort_formulae_for_install(formulae)
+      if formulae.include?(Formula["gh"])
+        [Formula["gh"]] | formulae
+      else
+        Homebrew::Attestation.gh_executable
+        formulae
+      end
+    end
+
+    # Verifies the given bottle against a cryptographic attestation of build provenance.
+    #
+    # The provenance is verified as originating from `signing_repository`, which is a `String`
+    # that should be formatted as a GitHub `owner/repository`.
+    #
+    # Callers may additionally pass in `signing_workflow`, which will scope the attestation
+    # down to an exact GitHub Actions workflow, in
+    # `https://github/OWNER/REPO/.github/workflows/WORKFLOW.yml@REF` format.
+    #
+    # @return [Hash] the JSON-decoded response.
+    # @raise [GhAuthNeeded] on any authentication failures
+    # @raise [InvalidAttestationError] on any verification failures
+    #
+    # @api private
+    sig {
+      params(bottle: Bottle, signing_repo: String,
+             signing_workflow: T.nilable(String), subject: T.nilable(String)).returns(T::Hash[T.untyped, T.untyped])
+    }
+    def self.check_attestation(bottle, signing_repo, signing_workflow = nil, subject = nil)
+      cmd = ["attestation", "verify", bottle.cached_download, "--repo", signing_repo, "--format",
+             "json"]
+
+      cmd += ["--cert-identity", signing_workflow] if signing_workflow.present?
+
+      # Fail early if we have no credentials. The command below invariably
+      # fails without them, so this saves us an unnecessary subshell.
+      credentials = GitHub::API.credentials
+      raise GhAuthNeeded, "missing credentials" if credentials.blank?
+
+      begin
+        result = system_command!(gh_executable, args: cmd,
+                                 env: { "GH_TOKEN" => credentials, "GH_HOST" => "github.com" },
+                                 secrets: [credentials], print_stderr: false, chdir: HOMEBREW_TEMP)
+      rescue ErrorDuringExecution => e
+        if e.status.exitstatus == 1 && e.stderr.include?("unknown command")
+          raise GhIncompatible, "gh CLI is incompatible with attestations"
+        end
+
+        # Even if we have credentials, they may be invalid or malformed.
+        if e.status.exitstatus == 4 || e.stderr.include?("HTTP 401: Bad credentials")
+          raise GhAuthInvalid, "invalid credentials"
+        end
+
+        raise MissingAttestationError, "attestation not found: #{e}" if e.stderr.include?("HTTP 404: Not Found")
+
+        raise InvalidAttestationError, "attestation verification failed: #{e}"
+      end
+
+      begin
+        attestations = JSON.parse(result.stdout)
+      rescue JSON::ParserError
+        raise InvalidAttestationError, "attestation verification returned malformed JSON"
+      end
+
+      # `gh attestation verify` returns a JSON array of one or more results,
+      # for all attestations that match the input's digest. We want to additionally
+      # filter these down to just the attestation whose subject matches the bottle's name.
+      subject = bottle.filename.to_s if subject.blank?
+
+      attestation = if bottle.tag.to_sym == :all
+        # :all-tagged bottles are created by `brew bottle --merge`, and are not directly
+        # bound to their own filename (since they're created by deduplicating other filenames).
+        # To verify these, we parse each attestation subject and look for one with a matching
+        # formula (name, version), but not an exact tag match.
+        # This is sound insofar as the signature has already been verified. However,
+        # longer term, we should also directly attest to `:all`-tagged bottles.
+        attestations.find do |a|
+          actual_subject = a.dig("verificationResult", "statement", "subject", 0, "name")
+          actual_subject.start_with? "#{bottle.filename.name}--#{bottle.filename.version}"
+        end
+      else
+        attestations.find do |a|
+          a.dig("verificationResult", "statement", "subject", 0, "name") == subject
+        end
+      end
+
+      raise InvalidAttestationError, "no attestation matches subject: #{subject}" if attestation.blank?
+
+      attestation
+    end
+
+    ATTESTATION_MAX_RETRIES = 5
+
+    # Verifies the given bottle against a cryptographic attestation of build provenance
+    # from homebrew-core's CI, falling back on a "backfill" attestation for older bottles.
+    #
+    # This is a specialization of `check_attestation` for homebrew-core.
+    #
+    # @return [Hash] the JSON-decoded response
+    # @raise [GhAuthNeeded] on any authentication failures
+    # @raise [InvalidAttestationError] on any verification failures
+    #
+    # @api private
+    sig { params(bottle: Bottle).returns(T::Hash[T.untyped, T.untyped]) }
+    def self.check_core_attestation(bottle)
+      begin
+        # Ideally, we would also constrain the signing workflow here, but homebrew-core
+        # currently uses multiple signing workflows to produce bottles
+        # (e.g. `dispatch-build-bottle.yml`, `dispatch-rebottle.yml`, etc.).
+        #
+        # We could check each of these (1) explicitly (slow), (2) by generating a pattern
+        # to pass into `--cert-identity-regex` (requires us to build up a Go-style regex),
+        # or (3) by checking the resulting JSON for the expected signing workflow.
+        #
+        # Long term, we should probably either do (3) *or* switch to a single reusable
+        # workflow, which would then be our sole identity. However, GitHub's
+        # attestations currently do not include reusable workflow state by default.
+        attestation = check_attestation bottle, HOMEBREW_CORE_REPO
+        return attestation
+      rescue MissingAttestationError
+        odebug "falling back on backfilled attestation for #{bottle}"
+
+        # Our backfilled attestation is a little unique: the subject is not just the bottle
+        # filename, but also has the bottle's hosted URL hash prepended to it.
+        # This was originally unintentional, but has a virtuous side effect of further
+        # limiting domain separation on the backfilled signatures (by committing them to
+        # their original bottle URLs).
+        url_sha256 = if EnvConfig.bottle_domain == HOMEBREW_BOTTLE_DEFAULT_DOMAIN
+          Digest::SHA256.hexdigest(bottle.url)
+        else
+          # If our bottle is coming from a mirror, we need to recompute the expected
+          # non-mirror URL to make the hash match.
+          path, = Utils::Bottles.path_resolved_basename HOMEBREW_BOTTLE_DEFAULT_DOMAIN, bottle.name,
+                                                        bottle.resource.checksum, bottle.filename
+          url = "#{HOMEBREW_BOTTLE_DEFAULT_DOMAIN}/#{path}"
+
+          Digest::SHA256.hexdigest(url)
+        end
+        subject = "#{url_sha256}--#{bottle.filename}"
+
+        # We don't pass in a signing workflow for backfill signatures because
+        # some backfilled bottle signatures were signed from the 'backfill'
+        # branch, and others from 'main' of trailofbits/homebrew-brew-verify
+        # so the signing workflow is slightly different which causes some bottles to incorrectly
+        # fail when checking their attestation. This shouldn't meaningfully affect security
+        # because if somehow someone could generate false backfill attestations
+        # from a different workflow we will still catch it because the
+        # attestation would have been generated after our cutoff date.
+        backfill_attestation = check_attestation bottle, BACKFILL_REPO, nil, subject
+        timestamp = backfill_attestation.dig("verificationResult", "verifiedTimestamps",
+                                             0, "timestamp")
+
+        raise InvalidAttestationError, "backfill attestation is missing verified timestamp" if timestamp.nil?
+
+        if DateTime.parse(timestamp) > BACKFILL_CUTOFF
+          raise InvalidAttestationError, "backfill attestation post-dates cutoff"
+        end
+      end
+
+      backfill_attestation
+    rescue InvalidAttestationError
+      @attestation_retry_count ||= T.let(Hash.new(0), T.nilable(T::Hash[Bottle, Integer]))
+      raise if @attestation_retry_count[bottle] >= ATTESTATION_MAX_RETRIES
+
+      sleep_time = 3 ** @attestation_retry_count[bottle]
+      opoo "Failed to verify attestation. Retrying in #{sleep_time}s..."
+      sleep sleep_time if ENV["HOMEBREW_TESTS"].blank?
+      @attestation_retry_count[bottle] += 1
+      retry
+    end
+  end
+end
diff --git a/Library/Homebrew/attrable.rb b/Library/Homebrew/attrable.rb
new file mode 100644
index 0000000000000..8dd176ef240a9
--- /dev/null
+++ b/Library/Homebrew/attrable.rb
@@ -0,0 +1,30 @@
+# typed: strict
+# frozen_string_literal: true
+
+# This module provides methods to define specialized attributes.
+# Method stubs are generated by the {Tapioca::Compilers::Attrables} compiler.
+# @note The compiler is fragile, and must be updated if the filename changes, if methods are added or removed,
+#   or if a method's arity changes.
+module Attrable
+  extend T::Helpers
+
+  requires_ancestor { Module }
+
+  sig { params(attrs: Symbol).void }
+  def attr_predicate(*attrs)
+    attrs.each do |attr|
+      define_method attr do
+        instance_variable_get("@#{attr.to_s.sub(/\?$/, "")}") == true
+      end
+    end
+  end
+
+  sig { params(attrs: Symbol).void }
+  def attr_rw(*attrs)
+    attrs.each do |attr|
+      define_method attr do |val = nil|
+        val.nil? ? instance_variable_get(:"@#{attr}") : instance_variable_set(:"@#{attr}", val)
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/brew.rb b/Library/Homebrew/brew.rb
index 7f52b5a483d32..dbe7acc2105c8 100644
--- a/Library/Homebrew/brew.rb
+++ b/Library/Homebrew/brew.rb
@@ -1,23 +1,20 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+# `HOMEBREW_STACKPROF` should be set via `brew prof --stackprof`, not manually.
 if ENV["HOMEBREW_STACKPROF"]
+  require "rubygems"
   require "stackprof"
   StackProf.start(mode: :wall, raw: true)
 end
 
 raise "HOMEBREW_BREW_FILE was not exported! Please call bin/brew directly!" unless ENV["HOMEBREW_BREW_FILE"]
+if $PROGRAM_NAME != __FILE__ && !$PROGRAM_NAME.end_with?("/bin/ruby-prof")
+  raise "#{__FILE__} must not be loaded via `require`."
+end
 
 std_trap = trap("INT") { exit! 130 } # no backtrace thanks
 
-# check ruby version before requiring any modules.
-REQUIRED_RUBY_X, REQUIRED_RUBY_Y, = ENV.fetch("HOMEBREW_REQUIRED_RUBY_VERSION").split(".").map(&:to_i)
-RUBY_X, RUBY_Y, = RUBY_VERSION.split(".").map(&:to_i)
-if RUBY_X < REQUIRED_RUBY_X || (RUBY_X == REQUIRED_RUBY_X && RUBY_Y < REQUIRED_RUBY_Y)
-  raise "Homebrew must be run under Ruby #{REQUIRED_RUBY_X}.#{REQUIRED_RUBY_Y}! " \
-        "You're running #{RUBY_VERSION}."
-end
-
 require_relative "global"
 
 begin
@@ -31,8 +28,8 @@
   empty_argv = ARGV.empty?
   help_flag_list = %w[-h --help --usage -?]
   help_flag = !ENV["HOMEBREW_HELP"].nil?
-  help_cmd_index = nil
-  cmd = nil
+  help_cmd_index = T.let(nil, T.nilable(Integer))
+  cmd = T.let(nil, T.nilable(String))
 
   ARGV.each_with_index do |arg, i|
     break if help_flag && cmd
@@ -42,6 +39,7 @@
       help_flag = true
       help_cmd_index = i
     elsif !cmd && help_flag_list.exclude?(arg)
+      require "commands"
       cmd = ARGV.delete_at(i)
       cmd = Commands::HOMEBREW_INTERNAL_COMMAND_ALIASES.fetch(cmd, cmd)
     end
@@ -50,7 +48,7 @@
   ARGV.delete_at(help_cmd_index) if help_cmd_index
 
   require "cli/parser"
-  args = Homebrew::CLI::Parser.new.parse(ARGV.dup.freeze, ignore_invalid_options: true)
+  args = Homebrew::CLI::Parser.new(Homebrew::Cmd::Brew).parse(ARGV.dup.freeze, ignore_invalid_options: true)
   Context.current = args.context
 
   path = PATH.new(ENV.fetch("PATH"))
@@ -60,19 +58,18 @@
   path.prepend(HOMEBREW_SHIMS_PATH/"shared")
   homebrew_path.prepend(HOMEBREW_SHIMS_PATH/"shared")
 
-  ENV["PATH"] = path
+  ENV["PATH"] = path.to_s
 
   require "commands"
-  require "settings"
 
   internal_cmd = Commands.valid_internal_cmd?(cmd) || Commands.valid_internal_dev_cmd?(cmd) if cmd
 
   unless internal_cmd
     # Add contributed commands to PATH before checking.
-    homebrew_path.append(Tap.cmd_directories)
+    homebrew_path.append(Commands.tap_cmd_directories)
 
     # External commands expect a normal PATH
-    ENV["PATH"] = homebrew_path
+    ENV["PATH"] = homebrew_path.to_s
   end
 
   # Usage instructions should be displayed if and only if one of:
@@ -81,25 +78,35 @@
   # - no arguments are passed
   if empty_argv || help_flag
     require "help"
-    Homebrew::Help.help cmd, remaining_args: args.remaining, empty_argv: empty_argv
+    Homebrew::Help.help cmd, remaining_args: args.remaining, empty_argv:
     # `Homebrew::Help.help` never returns, except for unknown commands.
   end
 
   if internal_cmd || Commands.external_ruby_v2_cmd_path(cmd)
-    if Commands::INSTALL_FROM_API_FORBIDDEN_COMMANDS.include?(cmd) && Homebrew::EnvConfig.install_from_api?
-      odie "This command cannot be run while HOMEBREW_INSTALL_FROM_API is set!"
+    cmd = T.must(cmd)
+    cmd_class = Homebrew::AbstractCommand.command(cmd)
+    Homebrew.running_command = cmd
+    if cmd_class
+      command_instance = cmd_class.new
+
+      require "utils/analytics"
+      Utils::Analytics.report_command_run(command_instance)
+      command_instance.run
+    else
+      Homebrew.public_send Commands.method_name(cmd)
     end
-
-    Homebrew.send Commands.method_name(cmd)
   elsif (path = Commands.external_ruby_cmd_path(cmd))
+    Homebrew.running_command = cmd
     require?(path)
     exit Homebrew.failed? ? 1 : 0
   elsif Commands.external_cmd_path(cmd)
     %w[CACHE LIBRARY_PATH].each do |env|
-      ENV["HOMEBREW_#{env}"] = Object.const_get("HOMEBREW_#{env}").to_s
+      ENV["HOMEBREW_#{env}"] = Object.const_get(:"HOMEBREW_#{env}").to_s
     end
     exec "brew-#{cmd}", *ARGV
   else
+    require "tap"
+
     possible_tap = OFFICIAL_CMD_TAPS.find { |_, cmds| cmds.include?(cmd) }
     possible_tap = Tap.fetch(possible_tap.first) if possible_tap
 
@@ -114,16 +121,18 @@
       end
       # Check for cask explicitly because it's very common in old guides
       odie "`brew cask` is no longer a `brew` command. Use `brew <command> --cask` instead." if cmd == "cask"
-      odie "Unknown command: #{cmd}"
+      odie "Unknown command: brew #{cmd}"
     end
 
     # Unset HOMEBREW_HELP to avoid confusing the tap
     with_env HOMEBREW_HELP: nil do
       tap_commands = []
-      cgroup = Utils.popen_read("cat", "/proc/1/cgroup")
-      if %w[azpl_job actions_job docker garden kubepods].none? { |container| cgroup.include?(container) }
-        brew_uid = HOMEBREW_BREW_FILE.stat.uid
-        tap_commands += %W[/usr/bin/sudo -u ##{brew_uid}] if Process.uid.zero? && !brew_uid.zero?
+      if (File.exist?("/.dockerenv") ||
+         Homebrew.running_as_root? ||
+         ((cgroup = Utils.popen_read("cat", "/proc/1/cgroup").presence) &&
+          %w[azpl_job actions_job docker garden kubepods].none? { |type| cgroup.include?(type) })) &&
+         Homebrew.running_as_root_but_not_owned_by_root?
+        tap_commands += %W[/usr/bin/sudo -u ##{Homebrew.owner_uid}]
       end
       quiet_arg = args.quiet? ? "--quiet" : nil
       tap_commands += [HOMEBREW_BREW_FILE, "tap", *quiet_arg, possible_tap.name]
@@ -135,23 +144,42 @@
   end
 rescue UsageError => e
   require "help"
-  Homebrew::Help.help cmd, remaining_args: args.remaining, usage_error: e.message
+  Homebrew::Help.help cmd, remaining_args: args&.remaining || [], usage_error: e.message
 rescue SystemExit => e
-  onoe "Kernel.exit" if args.debug? && !e.success?
-  $stderr.puts e.backtrace if args.debug?
+  onoe "Kernel.exit" if args&.debug? && !e.success?
+  if args&.debug? || ARGV.include?("--debug")
+    require "utils/backtrace"
+    $stderr.puts Utils::Backtrace.clean(e)
+  end
   raise
 rescue Interrupt
   $stderr.puts # seemingly a newline is typical
   exit 130
 rescue BuildError => e
   Utils::Analytics.report_build_error(e)
-  e.dump(verbose: args.verbose?)
-
-  if e.formula.head? || e.formula.deprecated? || e.formula.disabled?
+  e.dump(verbose: args&.verbose? || false)
+
+  if OS.unsupported_configuration?
+    $stderr.puts "#{Tty.bold}Do not report this issue: you are running in an unsupported configuration.#{Tty.reset}"
+  elsif e.formula.head? || e.formula.deprecated? || e.formula.disabled?
+    reason = if e.formula.head?
+      "was built from an unstable upstream --HEAD"
+    elsif e.formula.deprecated?
+      "is deprecated"
+    elsif e.formula.disabled?
+      "is disabled"
+    end
     $stderr.puts <<~EOS
-      Please create pull requests instead of asking for help on Homebrew's GitHub,
-      Twitter or any other official channels.
+      #{e.formula.name}'s formula #{reason}.
+      This build failure is expected behaviour.
+      Do not create issues about this on Homebrew's GitHub repositories.
+      Any opened issues will be immediately closed without response.
+      Do not ask for help from Homebrew or its maintainers on social media.
+      You may ask for help in Homebrew's discussions but are unlikely to receive a response.
+      Try to figure out the problem yourself and submit a fix as a pull request.
+      We will review it but may or may not accept it.
     EOS
+
   end
 
   exit 1
@@ -159,28 +187,34 @@
   raise if e.message.empty?
 
   onoe e
-  $stderr.puts e.backtrace if args.debug?
-
-  exit 1
-rescue MethodDeprecatedError => e
-  onoe e
-  if e.issues_url
-    $stderr.puts "If reporting this issue please do so at (not Homebrew/brew or Homebrew/core):"
-    $stderr.puts "  #{Formatter.url(e.issues_url)}"
+  if args&.debug? || ARGV.include?("--debug")
+    require "utils/backtrace"
+    $stderr.puts Utils::Backtrace.clean(e)
   end
-  $stderr.puts e.backtrace if args.debug?
+
   exit 1
 rescue Exception => e # rubocop:disable Lint/RescueException
   onoe e
-  if internal_cmd && defined?(OS::ISSUES_URL)
-    if Homebrew::EnvConfig.no_auto_update?
-      $stderr.puts "#{Tty.bold}Do not report this issue until you've run `brew update` and tried again.#{Tty.reset}"
-    else
-      $stderr.puts "#{Tty.bold}Please report this issue:#{Tty.reset}"
-      $stderr.puts "  #{Formatter.url(OS::ISSUES_URL)}"
-    end
+
+  method_deprecated_error = e.is_a?(MethodDeprecatedError)
+  require "utils/backtrace"
+  $stderr.puts Utils::Backtrace.clean(e) if args&.debug? || ARGV.include?("--debug") || !method_deprecated_error
+
+  if OS.unsupported_configuration?
+    $stderr.puts "#{Tty.bold}Do not report this issue: you are running in an unsupported configuration.#{Tty.reset}"
+  elsif Homebrew::EnvConfig.no_auto_update? &&
+        (fetch_head = HOMEBREW_REPOSITORY/".git/FETCH_HEAD") &&
+        (!fetch_head.exist? || (fetch_head.mtime.to_date < Date.today))
+    $stderr.puts "#{Tty.bold}You have disabled automatic updates and have not updated today.#{Tty.reset}"
+    $stderr.puts "#{Tty.bold}Do not report this issue until you've run `brew update` and tried again.#{Tty.reset}"
+  elsif (issues_url = (method_deprecated_error && e.issues_url) || Utils::Backtrace.tap_error_url(e))
+    $stderr.puts "If reporting this issue please do so at (not Homebrew/brew or Homebrew/homebrew-core):"
+    $stderr.puts "  #{Formatter.url(issues_url)}"
+  elsif internal_cmd
+    $stderr.puts "#{Tty.bold}Please report this issue:#{Tty.reset}"
+    $stderr.puts "  #{Formatter.url(OS::ISSUES_URL)}"
   end
-  $stderr.puts e.backtrace
+
   exit 1
 else
   exit 1 if Homebrew.failed?
diff --git a/Library/Homebrew/brew.sh b/Library/Homebrew/brew.sh
index cbe08846a29ad..7c59fd881e8aa 100644
--- a/Library/Homebrew/brew.sh
+++ b/Library/Homebrew/brew.sh
@@ -1,47 +1,52 @@
 #####
-##### First do the essential, fast things to be able to make e.g. brew --prefix and other commands we want to be
-##### able to `source` in shell configuration quick.
+##### First do the essential, fast things to ensure commands like `brew --prefix` and others that we want
+##### to be able to `source` in shell configurations run quickly.
 #####
 
-# Doesn't need a default case because we don't support other OSs
-# shellcheck disable=SC2249
-HOMEBREW_PROCESSOR="$(uname -m)"
-HOMEBREW_PHYSICAL_PROCESSOR="${HOMEBREW_PROCESSOR}"
-HOMEBREW_SYSTEM="$(uname -s)"
-case "${HOMEBREW_SYSTEM}" in
-  Darwin) HOMEBREW_MACOS="1" ;;
-  Linux) HOMEBREW_LINUX="1" ;;
+case "${MACHTYPE}" in
+  arm64-*)
+    HOMEBREW_PROCESSOR="arm64"
+    ;;
+  x86_64-*)
+    HOMEBREW_PROCESSOR="x86_64"
+    ;;
+  *)
+    HOMEBREW_PROCESSOR="$(uname -m)"
+    ;;
 esac
 
-if [[ "${HOMEBREW_MACOS}" == "1" ]] &&
-   [[ "$(sysctl -n hw.optional.arm64 2>/dev/null)" == "1" ]]
-then
-  # used in vendor-install.sh
-  # shellcheck disable=SC2034
-  HOMEBREW_PHYSICAL_PROCESSOR="arm64"
-  HOMEBREW_ROSETTA="$(sysctl -n sysctl.proc_translated)"
-
-  # If we're running under macOS Rosetta 2, and it was requested by setting
-  # HOMEBREW_CHANGE_ARCH_TO_ARM (for example in CI), then we re-exec this
-  # same file under the native architecture
-  # These variables are set from the user environment.
-  # shellcheck disable=SC2154
-  if [[ "${HOMEBREW_CHANGE_ARCH_TO_ARM}" == "1" ]] &&
-     [[ "${HOMEBREW_ROSETTA}" == "1" ]]
-  then
-    exec arch -arm64e "${HOMEBREW_BREW_FILE}" "$@"
-  fi
-fi
+case "${OSTYPE}" in
+  darwin*)
+    HOMEBREW_SYSTEM="Darwin"
+    HOMEBREW_MACOS="1"
+    ;;
+  linux*)
+    HOMEBREW_SYSTEM="Linux"
+    HOMEBREW_LINUX="1"
+    ;;
+  *)
+    HOMEBREW_SYSTEM="$(uname -s)"
+    ;;
+esac
+HOMEBREW_PHYSICAL_PROCESSOR="${HOMEBREW_PROCESSOR}"
 
-# Where we store built products; a Cellar in HOMEBREW_PREFIX (often /usr/local
-# for bottles) unless there's already a Cellar in HOMEBREW_REPOSITORY.
-# These variables are set by bin/brew
-# shellcheck disable=SC2154
-if [[ -d "${HOMEBREW_REPOSITORY}/Cellar" ]]
+HOMEBREW_MACOS_ARM_DEFAULT_PREFIX="/opt/homebrew"
+HOMEBREW_MACOS_ARM_DEFAULT_REPOSITORY="${HOMEBREW_MACOS_ARM_DEFAULT_PREFIX}"
+HOMEBREW_LINUX_DEFAULT_PREFIX="/home/linuxbrew/.linuxbrew"
+HOMEBREW_LINUX_DEFAULT_REPOSITORY="${HOMEBREW_LINUX_DEFAULT_PREFIX}/Homebrew"
+HOMEBREW_GENERIC_DEFAULT_PREFIX="/usr/local"
+HOMEBREW_GENERIC_DEFAULT_REPOSITORY="${HOMEBREW_GENERIC_DEFAULT_PREFIX}/Homebrew"
+if [[ -n "${HOMEBREW_MACOS}" && "${HOMEBREW_PROCESSOR}" == "arm64" ]]
 then
-  HOMEBREW_CELLAR="${HOMEBREW_REPOSITORY}/Cellar"
+  HOMEBREW_DEFAULT_PREFIX="${HOMEBREW_MACOS_ARM_DEFAULT_PREFIX}"
+  HOMEBREW_DEFAULT_REPOSITORY="${HOMEBREW_MACOS_ARM_DEFAULT_REPOSITORY}"
+elif [[ -n "${HOMEBREW_LINUX}" ]]
+then
+  HOMEBREW_DEFAULT_PREFIX="${HOMEBREW_LINUX_DEFAULT_PREFIX}"
+  HOMEBREW_DEFAULT_REPOSITORY="${HOMEBREW_LINUX_DEFAULT_REPOSITORY}"
 else
-  HOMEBREW_CELLAR="${HOMEBREW_PREFIX}/Cellar"
+  HOMEBREW_DEFAULT_PREFIX="${HOMEBREW_GENERIC_DEFAULT_PREFIX}"
+  HOMEBREW_DEFAULT_REPOSITORY="${HOMEBREW_GENERIC_DEFAULT_REPOSITORY}"
 fi
 
 if [[ -n "${HOMEBREW_MACOS}" ]]
@@ -49,21 +54,93 @@ then
   HOMEBREW_DEFAULT_CACHE="${HOME}/Library/Caches/Homebrew"
   HOMEBREW_DEFAULT_LOGS="${HOME}/Library/Logs/Homebrew"
   HOMEBREW_DEFAULT_TEMP="/private/tmp"
+
+  HOMEBREW_MACOS_VERSION="$(/usr/bin/sw_vers -productVersion)"
+
+  IFS=. read -r -a MACOS_VERSION_ARRAY <<<"${HOMEBREW_MACOS_VERSION}"
+  printf -v HOMEBREW_MACOS_VERSION_NUMERIC "%02d%02d%02d" "${MACOS_VERSION_ARRAY[@]}"
+
+  unset MACOS_VERSION_ARRAY
 else
-  CACHE_HOME="${XDG_CACHE_HOME:-${HOME}/.cache}"
+  CACHE_HOME="${HOMEBREW_XDG_CACHE_HOME:-${HOME}/.cache}"
   HOMEBREW_DEFAULT_CACHE="${CACHE_HOME}/Homebrew"
   HOMEBREW_DEFAULT_LOGS="${CACHE_HOME}/Homebrew/Logs"
   HOMEBREW_DEFAULT_TEMP="/tmp"
 fi
 
+realpath() {
+  (cd "$1" &>/dev/null && pwd -P)
+}
+
+# Support systems where HOMEBREW_PREFIX is the default,
+# but a parent directory is a symlink.
+# Example: Fedora Silverblue symlinks /home -> var/home
+if [[ "${HOMEBREW_PREFIX}" != "${HOMEBREW_DEFAULT_PREFIX}" && "$(realpath "${HOMEBREW_DEFAULT_PREFIX}")" == "${HOMEBREW_PREFIX}" ]]
+then
+  HOMEBREW_PREFIX="${HOMEBREW_DEFAULT_PREFIX}"
+fi
+
+# Support systems where HOMEBREW_REPOSITORY is the default,
+# but a parent directory is a symlink.
+# Example: Fedora Silverblue symlinks /home -> var/home
+if [[ "${HOMEBREW_REPOSITORY}" != "${HOMEBREW_DEFAULT_REPOSITORY}" && "$(realpath "${HOMEBREW_DEFAULT_REPOSITORY}")" == "${HOMEBREW_REPOSITORY}" ]]
+then
+  HOMEBREW_REPOSITORY="${HOMEBREW_DEFAULT_REPOSITORY}"
+fi
+
+# Where we store built products; a Cellar in HOMEBREW_PREFIX (often /usr/local
+# for bottles) unless there's already a Cellar in HOMEBREW_REPOSITORY.
+# These variables are set by bin/brew
+# shellcheck disable=SC2154
+if [[ -d "${HOMEBREW_REPOSITORY}/Cellar" ]]
+then
+  HOMEBREW_CELLAR="${HOMEBREW_REPOSITORY}/Cellar"
+else
+  HOMEBREW_CELLAR="${HOMEBREW_PREFIX}/Cellar"
+fi
+
+HOMEBREW_CASKROOM="${HOMEBREW_PREFIX}/Caskroom"
+
 HOMEBREW_CACHE="${HOMEBREW_CACHE:-${HOMEBREW_DEFAULT_CACHE}}"
 HOMEBREW_LOGS="${HOMEBREW_LOGS:-${HOMEBREW_DEFAULT_LOGS}}"
 HOMEBREW_TEMP="${HOMEBREW_TEMP:-${HOMEBREW_DEFAULT_TEMP}}"
 
-# Don't need to handle a default case.
+# commands that take a single or no arguments.
 # HOMEBREW_LIBRARY set by bin/brew
-# shellcheck disable=SC2249,SC2154
-case "$*" in
+# shellcheck disable=SC2154
+# doesn't need a default case as other arguments handled elsewhere.
+# shellcheck disable=SC2249
+case "$1" in
+  formulae)
+    source "${HOMEBREW_LIBRARY}/Homebrew/cmd/formulae.sh"
+    homebrew-formulae
+    exit 0
+    ;;
+  casks)
+    source "${HOMEBREW_LIBRARY}/Homebrew/cmd/casks.sh"
+    homebrew-casks
+    exit 0
+    ;;
+  shellenv)
+    source "${HOMEBREW_LIBRARY}/Homebrew/cmd/shellenv.sh"
+    shift
+    homebrew-shellenv "$1"
+    exit 0
+    ;;
+  setup-ruby)
+    source "${HOMEBREW_LIBRARY}/Homebrew/cmd/setup-ruby.sh"
+    shift
+    homebrew-setup-ruby "$1"
+    exit 0
+    ;;
+esac
+
+source "${HOMEBREW_LIBRARY}/Homebrew/help.sh"
+
+# functions that take multiple arguments or handle multiple commands.
+# doesn't need a default case as other arguments handled elsewhere.
+# shellcheck disable=SC2249
+case "$@" in
   --cellar)
     echo "${HOMEBREW_CELLAR}"
     exit 0
@@ -73,130 +150,51 @@ case "$*" in
     exit 0
     ;;
   --caskroom)
-    echo "${HOMEBREW_PREFIX}/Caskroom"
+    echo "${HOMEBREW_CASKROOM}"
     exit 0
     ;;
   --cache)
     echo "${HOMEBREW_CACHE}"
     exit 0
     ;;
-  shellenv)
-    source "${HOMEBREW_LIBRARY}/Homebrew/cmd/shellenv.sh"
-    homebrew-shellenv
-    exit 0
+  # falls back to cmd/--prefix.rb and cmd/--cellar.rb on a non-zero return
+  --prefix* | --cellar*)
+    source "${HOMEBREW_LIBRARY}/Homebrew/formula_path.sh"
+    homebrew-formula-path "$@" && exit 0
     ;;
-  formulae)
-    source "${HOMEBREW_LIBRARY}/Homebrew/cmd/formulae.sh"
-    homebrew-formulae
-    exit 0
+  # falls back to cmd/command.rb on a non-zero return
+  command*)
+    source "${HOMEBREW_LIBRARY}/Homebrew/command_path.sh"
+    homebrew-command-path "$@" && exit 0
     ;;
-  casks)
-    source "${HOMEBREW_LIBRARY}/Homebrew/cmd/casks.sh"
-    homebrew-casks
+  # falls back to cmd/list.rb on a non-zero return
+  list* | ls*)
+    source "${HOMEBREW_LIBRARY}/Homebrew/list.sh"
+    homebrew-list "$@" && exit 0
+    ;;
+  # homebrew-tap only handles invocations with no arguments
+  tap)
+    source "${HOMEBREW_LIBRARY}/Homebrew/tap.sh"
+    homebrew-tap "$@"
     exit 0
     ;;
-  # falls back to cmd/prefix.rb on a non-zero return
-  --prefix*)
-    source "${HOMEBREW_LIBRARY}/Homebrew/prefix.sh"
-    homebrew-prefix "$@" && exit 0
+  # falls back to cmd/help.rb on a non-zero return
+  help | --help | -h | --usage | "-?" | "")
+    homebrew-help "$@" && exit 0
     ;;
 esac
 
 #####
 ##### Next, define all helper functions.
 #####
-
-# These variables are set from the user environment.
-# shellcheck disable=SC2154
-ohai() {
-  # Check whether stdout is a tty.
-  if [[ -n "${HOMEBREW_COLOR}" || (-t 1 && -z "${HOMEBREW_NO_COLOR}") ]]
-  then
-    echo -e "\\033[34m==>\\033[0m \\033[1m$*\\033[0m" # blue arrow and bold text
-  else
-    echo "==> $*"
-  fi
-}
-
-opoo() {
-  # Check whether stderr is a tty.
-  if [[ -n "${HOMEBREW_COLOR}" || (-t 2 && -z "${HOMEBREW_NO_COLOR}") ]]
-  then
-    echo -ne "\\033[4;33mWarning\\033[0m: " >&2 # highlight Warning with underline and yellow color
-  else
-    echo -n "Warning: " >&2
-  fi
-  if [[ $# -eq 0 ]]
-  then
-    cat >&2
-  else
-    echo "$*" >&2
-  fi
-}
-
-bold() {
-  # Check whether stderr is a tty.
-  if [[ -n "${HOMEBREW_COLOR}" || (-t 2 && -z "${HOMEBREW_NO_COLOR}") ]]
-  then
-    echo -e "\\033[1m""$*""\\033[0m"
-  else
-    echo "$*"
-  fi
-}
-
-onoe() {
-  # Check whether stderr is a tty.
-  if [[ -n "${HOMEBREW_COLOR}" || (-t 2 && -z "${HOMEBREW_NO_COLOR}") ]]
-  then
-    echo -ne "\\033[4;31mError\\033[0m: " >&2 # highlight Error with underline and red color
-  else
-    echo -n "Error: " >&2
-  fi
-  if [[ $# -eq 0 ]]
-  then
-    cat >&2
-  else
-    echo "$*" >&2
-  fi
-}
-
-odie() {
-  onoe "$@"
-  exit 1
-}
-
-safe_cd() {
-  cd "$@" >/dev/null || odie "Failed to cd to $*!"
-}
-
-brew() {
-  "${HOMEBREW_BREW_FILE}" "$@"
-}
-
-curl() {
-  "${HOMEBREW_LIBRARY}/Homebrew/shims/shared/curl" "$@"
-}
-
-git() {
-  "${HOMEBREW_LIBRARY}/Homebrew/shims/shared/git" "$@"
-}
-
-# Search given executable in PATH (remove dependency for `which` command)
-which() {
-  # Alias to Bash built-in command `type -P`
-  type -P "$@"
-}
-
-numeric() {
-  # Condense the exploded argument into a single return value.
-  # shellcheck disable=SC2086,SC2183
-  printf "%01d%02d%02d%03d" ${1//[.rc]/ } 2>/dev/null
-}
+source "${HOMEBREW_LIBRARY}/Homebrew/utils/helpers.sh"
 
 check-run-command-as-root() {
-  [[ "$(id -u)" == 0 ]] || return
+  [[ "${EUID}" == 0 || "${UID}" == 0 ]] || return
 
-  # Allow Azure Pipelines/GitHub Actions/Docker/Concourse/Kubernetes to do everything as root (as it's normal there)
+  # Allow Azure Pipelines/GitHub Actions/Docker/Podman/Concourse/Kubernetes to do everything as root (as it's normal there)
+  [[ -f /.dockerenv ]] && return
+  [[ -f /run/.containerenv ]] && return
   [[ -f /proc/1/cgroup ]] && grep -E "azpl_job|actions_job|docker|garden|kubepods" -q /proc/1/cgroup && return
 
   # Homebrew Services may need `sudo` for system-wide daemons.
@@ -219,26 +217,23 @@ check-prefix-is-not-tmpdir() {
   then
     odie <<EOS
 Your HOMEBREW_PREFIX is in the Homebrew temporary directory, which Homebrew
-uses to store downloads and builds. You can resolve this by installing Homebrew to
-either the standard prefix (/usr/local) or to a non-standard prefix that is not
-in the Homebrew temporary directory.
+uses to store downloads and builds. You can resolve this by installing Homebrew
+to either the standard prefix for your platform or to a non-standard prefix that
+is not in the Homebrew temporary directory.
 EOS
   fi
 }
 
-# Let user know we're still updating Homebrew if brew update --auto-update
-# exceeds 3 seconds.
-auto-update-timer() {
-  sleep 3
-  # Outputting a command but don't want to run it, hence single quotes.
-  # shellcheck disable=SC2016
-  echo 'Running `brew update --auto-update`...' >&2
-  if [[ -z "${HOMEBREW_NO_ENV_HINTS}" && -z "${HOMEBREW_AUTO_UPDATE_SECS}" ]]
+# NOTE: The members of the array in the second arg must not have spaces!
+check-array-membership() {
+  local item=$1
+  shift
+
+  if [[ " ${*} " == *" ${item} "* ]]
   then
-    # shellcheck disable=SC2016
-    echo 'Adjust how often this is run with HOMEBREW_AUTO_UPDATE_SECS or disable with' >&2
-    # shellcheck disable=SC2016
-    echo 'HOMEBREW_NO_AUTO_UPDATE. Hide these hints with HOMEBREW_NO_ENV_HINTS (see `man brew`).' >&2
+    return 0
+  else
+    return 1
   fi
 }
 
@@ -254,49 +249,90 @@ auto-update() {
   # If we've checked for updates, we don't need to check again.
   export HOMEBREW_AUTO_UPDATE_CHECKED="1"
 
-  if [[ "${HOMEBREW_COMMAND}" == "install" ]] ||
-     [[ "${HOMEBREW_COMMAND}" == "upgrade" ]] ||
-     [[ "${HOMEBREW_COMMAND}" == "bump-formula-pr" ]] ||
-     [[ "${HOMEBREW_COMMAND}" == "bump-cask-pr" ]] ||
-     [[ "${HOMEBREW_COMMAND}" == "bundle" ]] ||
-     [[ "${HOMEBREW_COMMAND}" == "release" ]] ||
-     [[ "${HOMEBREW_COMMAND}" == "tap" && "${HOMEBREW_ARG_COUNT}" -gt 1 ]]
+  if [[ -n "${HOMEBREW_AUTO_UPDATE_COMMAND}" ]]
   then
     export HOMEBREW_AUTO_UPDATING="1"
 
-    if [[ -z "${HOMEBREW_AUTO_UPDATE_SECS}" ]]
+    # Look for commands that may be referring to a formula/cask in a specific
+    # 3rd-party tap so they can be auto-updated more often (as they do not get
+    # their data from the API).
+    AUTO_UPDATE_TAP_COMMANDS=(
+      install
+      outdated
+      upgrade
+    )
+    if check-array-membership "${HOMEBREW_COMMAND}" "${AUTO_UPDATE_TAP_COMMANDS[@]}"
     then
-      HOMEBREW_AUTO_UPDATE_SECS="300"
+      for arg in "$@"
+      do
+        if [[ "${arg}" == */*/* ]] && [[ "${arg}" != Homebrew/* ]] && [[ "${arg}" != homebrew/* ]]
+        then
+
+          HOMEBREW_AUTO_UPDATE_TAP="1"
+          break
+        fi
+      done
     fi
 
-    # Skip auto-update if the repository has been updated in the
-    # last $HOMEBREW_AUTO_UPDATE_SECS.
-    repo_fetch_head="${HOMEBREW_REPOSITORY}/.git/FETCH_HEAD"
-    if [[ -f "${repo_fetch_head}" ]] &&
-       [[ -n "$(find "${repo_fetch_head}" -type f -mtime -"${HOMEBREW_AUTO_UPDATE_SECS}"s 2>/dev/null)" ]]
+    if [[ -z "${HOMEBREW_AUTO_UPDATE_SECS}" ]]
     then
-      return
+      if [[ -n "${HOMEBREW_NO_INSTALL_FROM_API}" || -n "${HOMEBREW_AUTO_UPDATE_TAP}" ]]
+      then
+        # 5 minutes
+        HOMEBREW_AUTO_UPDATE_SECS="300"
+      elif [[ -n "${HOMEBREW_DEV_CMD_RUN}" ]]
+      then
+        # 1 hour
+        HOMEBREW_AUTO_UPDATE_SECS="3600"
+      else
+        # 24 hours
+        HOMEBREW_AUTO_UPDATE_SECS="86400"
+      fi
     fi
 
-    if [[ -z "${HOMEBREW_VERBOSE}" ]]
+    repo_fetch_heads=("${HOMEBREW_REPOSITORY}/.git/FETCH_HEAD")
+    # We might have done an auto-update recently, but not a core/cask clone auto-update.
+    # So we check the core/cask clone FETCH_HEAD too.
+    if [[ -n "${HOMEBREW_AUTO_UPDATE_CORE_TAP}" && -d "${HOMEBREW_CORE_REPOSITORY}/.git" ]]
     then
-      auto-update-timer &
-      timer_pid=$!
+      repo_fetch_heads+=("${HOMEBREW_CORE_REPOSITORY}/.git/FETCH_HEAD")
+    fi
+    if [[ -n "${HOMEBREW_AUTO_UPDATE_CASK_TAP}" && -d "${HOMEBREW_CASK_REPOSITORY}/.git" ]]
+    then
+      repo_fetch_heads+=("${HOMEBREW_CASK_REPOSITORY}/.git/FETCH_HEAD")
     fi
 
-    brew update --auto-update
-
-    if [[ -n "${timer_pid}" ]]
+    # Skip auto-update if all of the selected repositories have been checked in the
+    # last $HOMEBREW_AUTO_UPDATE_SECS.
+    needs_auto_update=
+    for repo_fetch_head in "${repo_fetch_heads[@]}"
+    do
+      if [[ ! -f "${repo_fetch_head}" ]] ||
+         [[ -z "$(find "${repo_fetch_head}" -type f -newermt "-${HOMEBREW_AUTO_UPDATE_SECS} seconds" 2>/dev/null)" ]]
+      then
+        needs_auto_update=1
+        break
+      fi
+    done
+    if [[ -z "${needs_auto_update}" ]]
     then
-      kill "${timer_pid}" 2>/dev/null
-      wait "${timer_pid}" 2>/dev/null
+      return
     fi
 
+    brew update --auto-update
+
     unset HOMEBREW_AUTO_UPDATING
+    unset HOMEBREW_AUTO_UPDATE_TAP
 
     # exec a new process to set any new environment variables.
     exec "${HOMEBREW_BREW_FILE}" "$@"
   fi
+
+  unset AUTO_UPDATE_COMMANDS
+  unset AUTO_UPDATE_CORE_TAP_COMMANDS
+  unset AUTO_UPDATE_CASK_TAP_COMMANDS
+  unset HOMEBREW_AUTO_UPDATE_CORE_TAP
+  unset HOMEBREW_AUTO_UPDATE_CASK_TAP
 }
 
 #####
@@ -347,17 +383,22 @@ then
   odie "Cowardly refusing to continue at this prefix: ${HOMEBREW_PREFIX}"
 fi
 
-# Many Pathname operations use getwd when they shouldn't, and then throw
-# odd exceptions. Reduce our support burden by showing a user-friendly error.
-if [[ ! -d "$(pwd)" ]]
-then
-  odie "The current working directory doesn't exist, cannot proceed."
-fi
-
 #####
 ##### Now, do everything else (that may be a bit slower).
 #####
 
+# Docker image deprecation
+if [[ -f "${HOMEBREW_REPOSITORY}/.docker-deprecate" ]]
+then
+  read -r DOCKER_DEPRECATION_MESSAGE <"${HOMEBREW_REPOSITORY}/.docker-deprecate"
+  if [[ -n "${GITHUB_ACTIONS}" ]]
+  then
+    echo "::warning::${DOCKER_DEPRECATION_MESSAGE}" >&2
+  else
+    opoo "${DOCKER_DEPRECATION_MESSAGE}"
+  fi
+fi
+
 # USER isn't always set so provide a fall back for `brew` and subprocesses.
 export USER="${USER:-$(id -un)}"
 
@@ -399,12 +440,59 @@ setup_git() {
 setup_curl
 setup_git
 
-HOMEBREW_VERSION="$("${HOMEBREW_GIT}" -C "${HOMEBREW_REPOSITORY}" describe --tags --dirty --abbrev=7 2>/dev/null)"
+GIT_DESCRIBE_CACHE="${HOMEBREW_REPOSITORY}/.git/describe-cache"
+GIT_REVISION=$("${HOMEBREW_GIT}" -C "${HOMEBREW_REPOSITORY}" rev-parse HEAD 2>/dev/null)
+
+# safe fallback in case git rev-parse fails e.g. if this is not considered a safe git directory
+if [[ -z "${GIT_REVISION}" ]]
+then
+  read -r GIT_HEAD 2>/dev/null <"${HOMEBREW_REPOSITORY}/.git/HEAD"
+  if [[ "${GIT_HEAD}" == "ref: refs/heads/master" ]]
+  then
+    read -r GIT_REVISION 2>/dev/null <"${HOMEBREW_REPOSITORY}/.git/refs/heads/master"
+  elif [[ "${GIT_HEAD}" == "ref: refs/heads/stable" ]]
+  then
+    read -r GIT_REVISION 2>/dev/null <"${HOMEBREW_REPOSITORY}/.git/refs/heads/stable"
+  fi
+  unset GIT_HEAD
+fi
+
+if [[ -n "${GIT_REVISION}" ]]
+then
+  GIT_DESCRIBE_CACHE_FILE="${GIT_DESCRIBE_CACHE}/${GIT_REVISION}"
+  if [[ -r "${GIT_DESCRIBE_CACHE_FILE}" ]] && "${HOMEBREW_GIT}" -C "${HOMEBREW_REPOSITORY}" diff --quiet --no-ext-diff 2>/dev/null
+  then
+    read -r GIT_DESCRIBE_CACHE_HOMEBREW_VERSION <"${GIT_DESCRIBE_CACHE_FILE}"
+    if [[ -n "${GIT_DESCRIBE_CACHE_HOMEBREW_VERSION}" && "${GIT_DESCRIBE_CACHE_HOMEBREW_VERSION}" != *"-dirty" ]]
+    then
+      HOMEBREW_VERSION="${GIT_DESCRIBE_CACHE_HOMEBREW_VERSION}"
+    fi
+    unset GIT_DESCRIBE_CACHE_HOMEBREW_VERSION
+  fi
+
+  if [[ -z "${HOMEBREW_VERSION}" ]]
+  then
+    HOMEBREW_VERSION="$("${HOMEBREW_GIT}" -C "${HOMEBREW_REPOSITORY}" describe --tags --dirty --abbrev=7 2>/dev/null)"
+    # Don't output any permissions errors here. The user may not have write
+    # permissions to the cache but we don't care because it's an optional
+    # performance improvement.
+    rm -rf "${GIT_DESCRIBE_CACHE}" 2>/dev/null
+    mkdir -p "${GIT_DESCRIBE_CACHE}" 2>/dev/null
+    echo "${HOMEBREW_VERSION}" | tee "${GIT_DESCRIBE_CACHE_FILE}" &>/dev/null
+  fi
+  unset GIT_DESCRIBE_CACHE_FILE
+else
+  # Don't care about permission errors here either.
+  rm -rf "${GIT_DESCRIBE_CACHE}" 2>/dev/null
+fi
+unset GIT_REVISION
+unset GIT_DESCRIBE_CACHE
+
 HOMEBREW_USER_AGENT_VERSION="${HOMEBREW_VERSION}"
 if [[ -z "${HOMEBREW_VERSION}" ]]
 then
-  HOMEBREW_VERSION=">=2.5.0 (shallow or no git repository)"
-  HOMEBREW_USER_AGENT_VERSION="2.X.Y"
+  HOMEBREW_VERSION=">=4.3.0 (shallow or no git repository)"
+  HOMEBREW_USER_AGENT_VERSION="4.X.Y"
 fi
 
 HOMEBREW_CORE_REPOSITORY="${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core"
@@ -412,7 +500,17 @@ HOMEBREW_CORE_REPOSITORY="${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core"
 # shellcheck disable=SC2034
 HOMEBREW_CASK_REPOSITORY="${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-cask"
 
-case "$*" in
+# Shift the -v to the end of the parameter list
+if [[ "$1" == "-v" ]]
+then
+  shift
+  set -- "$@" -v
+fi
+
+# commands that take a single or no arguments.
+# doesn't need a default case as other arguments handled elsewhere.
+# shellcheck disable=SC2249
+case "$1" in
   --version | -v)
     source "${HOMEBREW_LIBRARY}/Homebrew/cmd/--version.sh"
     homebrew-version
@@ -420,18 +518,40 @@ case "$*" in
     ;;
 esac
 
+# TODO: bump version when new macOS is released or announced and update references in:
+# - docs/Installation.md
+# - https://github.com/Homebrew/install/blob/HEAD/install.sh
+# - Library/Homebrew/os/mac.rb (latest_sdk_version)
+# and, if needed:
+# - MacOSVersion::SYMBOLS
+HOMEBREW_MACOS_NEWEST_UNSUPPORTED="16"
+# TODO: bump version when new macOS is released and update references in:
+# - docs/Installation.md
+# - HOMEBREW_MACOS_OLDEST_SUPPORTED in .github/workflows/pkg-installer.yml
+# - `os-version min` in package/Distribution.xml
+# - https://github.com/Homebrew/install/blob/HEAD/install.sh
+HOMEBREW_MACOS_OLDEST_SUPPORTED="13"
+HOMEBREW_MACOS_OLDEST_ALLOWED="10.11"
+
 if [[ -n "${HOMEBREW_MACOS}" ]]
 then
   HOMEBREW_PRODUCT="Homebrew"
   HOMEBREW_SYSTEM="Macintosh"
   [[ "${HOMEBREW_PROCESSOR}" == "x86_64" ]] && HOMEBREW_PROCESSOR="Intel"
-  HOMEBREW_MACOS_VERSION="$(/usr/bin/sw_vers -productVersion)"
   # Don't change this from Mac OS X to match what macOS itself does in Safari on 10.12
   HOMEBREW_OS_USER_AGENT_VERSION="Mac OS X ${HOMEBREW_MACOS_VERSION}"
 
-  # Intentionally set this variable by exploding another.
-  # shellcheck disable=SC2086,SC2183
-  printf -v HOMEBREW_MACOS_VERSION_NUMERIC "%02d%02d%02d" ${HOMEBREW_MACOS_VERSION//./ }
+  if [[ "$(sysctl -n hw.optional.arm64 2>/dev/null)" == "1" ]]
+  then
+    # used in vendor-install.sh
+    # shellcheck disable=SC2034
+    HOMEBREW_PHYSICAL_PROCESSOR="arm64"
+  fi
+
+  IFS=. read -r -a MACOS_VERSION_ARRAY <<<"${HOMEBREW_MACOS_OLDEST_ALLOWED}"
+  printf -v HOMEBREW_MACOS_OLDEST_ALLOWED_NUMERIC "%02d%02d%02d" "${MACOS_VERSION_ARRAY[@]}"
+
+  unset MACOS_VERSION_ARRAY
 
   # Don't include minor versions for Big Sur and later.
   if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -gt "110000" ]]
@@ -442,7 +562,7 @@ then
   fi
 
   # Refuse to run on pre-El Capitan
-  if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -lt "101100" ]]
+  if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -lt "${HOMEBREW_MACOS_OLDEST_ALLOWED_NUMERIC}" ]]
   then
     printf "ERROR: Your version of macOS (%s) is too old to run Homebrew!\\n" "${HOMEBREW_MACOS_VERSION}" >&2
     if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -lt "100700" ]]
@@ -466,7 +586,14 @@ then
     HOMEBREW_FORCE_BREWED_CA_CERTIFICATES="1"
   fi
 
+  # TEMP: backwards compatiblity with existing 10.11-cross image
+  # Can (probably) be removed in March 2024.
   if [[ -n "${HOMEBREW_FAKE_EL_CAPITAN}" ]]
+  then
+    export HOMEBREW_FAKE_MACOS="10.11.6"
+  fi
+
+  if [[ "${HOMEBREW_FAKE_MACOS}" =~ ^10\.11(\.|$) ]]
   then
     # We only need this to work enough to update brew and build the set portable formulae, so relax the requirement.
     HOMEBREW_MINIMUM_GIT_VERSION="2.7.4"
@@ -478,44 +605,25 @@ then
       HOMEBREW_FORCE_BREWED_GIT="1"
     fi
   fi
-
-  # Set a variable when the macOS system Ruby is new enough to avoid spawning
-  # a Ruby process unnecessarily.
-  if [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -lt "120000" ]]
-  then
-    unset HOMEBREW_MACOS_SYSTEM_RUBY_NEW_ENOUGH
-  else
-    # Used in ruby.sh.
-    # shellcheck disable=SC2034
-    HOMEBREW_MACOS_SYSTEM_RUBY_NEW_ENOUGH="1"
-  fi
 else
   HOMEBREW_PRODUCT="${HOMEBREW_SYSTEM}brew"
-  [[ -n "${HOMEBREW_LINUX}" ]] && HOMEBREW_OS_VERSION="$(lsb_release -s -d 2>/dev/null)"
+  # Don't try to follow /etc/os-release
+  # shellcheck disable=SC1091,SC2154
+  [[ -n "${HOMEBREW_LINUX}" ]] && HOMEBREW_OS_VERSION="$(source /etc/os-release && echo "${PRETTY_NAME}")"
   : "${HOMEBREW_OS_VERSION:=$(uname -r)}"
   HOMEBREW_OS_USER_AGENT_VERSION="${HOMEBREW_OS_VERSION}"
 
-  # This is set by the user environment.
-  # shellcheck disable=SC2154
-  if [[ -n "${HOMEBREW_ON_DEBIAN7}" ]]
-  then
-    # Special version for our debian 7 docker container used to build binutils
-    HOMEBREW_MINIMUM_CURL_VERSION="7.25.0"
-    HOMEBREW_SYSTEM_CA_CERTIFICATES_TOO_OLD="1"
-    HOMEBREW_FORCE_BREWED_CA_CERTIFICATES="1"
-  else
-    # Ensure the system Curl is a version that supports modern HTTPS certificates.
-    HOMEBREW_MINIMUM_CURL_VERSION="7.41.0"
-  fi
+  # Ensure the system Curl is a version that supports modern HTTPS certificates.
+  HOMEBREW_MINIMUM_CURL_VERSION="7.41.0"
+
   curl_version_output="$(${HOMEBREW_CURL} --version 2>/dev/null)"
   curl_name_and_version="${curl_version_output%% (*}"
-  # shellcheck disable=SC2248
   if [[ "$(numeric "${curl_name_and_version##* }")" -lt "$(numeric "${HOMEBREW_MINIMUM_CURL_VERSION}")" ]]
   then
     message="Please update your system curl or set HOMEBREW_CURL_PATH to a newer version.
 Minimum required version: ${HOMEBREW_MINIMUM_CURL_VERSION}
 Your curl version: ${curl_name_and_version##* }
-Your curl executable: $(type -p ${HOMEBREW_CURL})"
+Your curl executable: $(type -p "${HOMEBREW_CURL}")"
 
     if [[ -z ${HOMEBREW_CURL_PATH} ]]
     then
@@ -538,13 +646,12 @@ Your curl executable: $(type -p ${HOMEBREW_CURL})"
   # $extra is intentionally discarded.
   # shellcheck disable=SC2034
   IFS='.' read -r major minor micro build extra <<<"${git_version_output##* }"
-  # shellcheck disable=SC2248
   if [[ "$(numeric "${major}.${minor}.${micro}.${build}")" -lt "$(numeric "${HOMEBREW_MINIMUM_GIT_VERSION}")" ]]
   then
     message="Please update your system Git or set HOMEBREW_GIT_PATH to a newer version.
 Minimum required version: ${HOMEBREW_MINIMUM_GIT_VERSION}
 Your Git version: ${major}.${minor}.${micro}.${build}
-Your Git executable: $(unset git && type -p ${HOMEBREW_GIT})"
+Your Git executable: $(unset git && type -p "${HOMEBREW_GIT}")"
     if [[ -z ${HOMEBREW_GIT_PATH} ]]
     then
       HOMEBREW_FORCE_BREWED_GIT="1"
@@ -559,7 +666,6 @@ Your Git executable: $(unset git && type -p ${HOMEBREW_GIT})"
   fi
 
   HOMEBREW_LINUX_MINIMUM_GLIBC_VERSION="2.13"
-  unset HOMEBREW_MACOS_SYSTEM_RUBY_NEW_ENOUGH
 
   HOMEBREW_CORE_REPOSITORY_ORIGIN="$("${HOMEBREW_GIT}" -C "${HOMEBREW_CORE_REPOSITORY}" remote get-url origin 2>/dev/null)"
   if [[ "${HOMEBREW_CORE_REPOSITORY_ORIGIN}" =~ (/linuxbrew|Linuxbrew/homebrew)-core(\.git)?$ ]]
@@ -598,6 +704,7 @@ then
   unset HOMEBREW_BOTTLE_DOMAIN
 fi
 
+HOMEBREW_API_DEFAULT_DOMAIN="https://formulae.brew.sh/api"
 HOMEBREW_BOTTLE_DEFAULT_DOMAIN="https://ghcr.io/v2/homebrew/core"
 
 HOMEBREW_USER_AGENT="${HOMEBREW_PRODUCT}/${HOMEBREW_USER_AGENT_VERSION} (${HOMEBREW_SYSTEM}; ${HOMEBREW_PROCESSOR} ${HOMEBREW_OS_USER_AGENT_VERSION})"
@@ -605,7 +712,21 @@ curl_version_output="$(curl --version 2>/dev/null)"
 curl_name_and_version="${curl_version_output%% (*}"
 HOMEBREW_USER_AGENT_CURL="${HOMEBREW_USER_AGENT} ${curl_name_and_version// //}"
 
+# Timeout values to check for dead connections
+# We don't use --max-time to support slow connections
+HOMEBREW_CURL_SPEED_LIMIT=100
+HOMEBREW_CURL_SPEED_TIME=5
+
+export HOMEBREW_HELP_MESSAGE
 export HOMEBREW_VERSION
+export HOMEBREW_MACOS_ARM_DEFAULT_PREFIX
+export HOMEBREW_LINUX_DEFAULT_PREFIX
+export HOMEBREW_GENERIC_DEFAULT_PREFIX
+export HOMEBREW_DEFAULT_PREFIX
+export HOMEBREW_MACOS_ARM_DEFAULT_REPOSITORY
+export HOMEBREW_LINUX_DEFAULT_REPOSITORY
+export HOMEBREW_GENERIC_DEFAULT_REPOSITORY
+export HOMEBREW_DEFAULT_REPOSITORY
 export HOMEBREW_DEFAULT_CACHE
 export HOMEBREW_CACHE
 export HOMEBREW_DEFAULT_LOGS
@@ -613,6 +734,7 @@ export HOMEBREW_LOGS
 export HOMEBREW_DEFAULT_TEMP
 export HOMEBREW_TEMP
 export HOMEBREW_CELLAR
+export HOMEBREW_CASKROOM
 export HOMEBREW_SYSTEM
 export HOMEBREW_SYSTEM_CA_CERTIFICATES_TOO_OLD
 export HOMEBREW_CURL
@@ -623,15 +745,21 @@ export HOMEBREW_GIT
 export HOMEBREW_GIT_WARNING
 export HOMEBREW_MINIMUM_GIT_VERSION
 export HOMEBREW_LINUX_MINIMUM_GLIBC_VERSION
+export HOMEBREW_PHYSICAL_PROCESSOR
 export HOMEBREW_PROCESSOR
 export HOMEBREW_PRODUCT
 export HOMEBREW_OS_VERSION
 export HOMEBREW_MACOS_VERSION
 export HOMEBREW_MACOS_VERSION_NUMERIC
+export HOMEBREW_MACOS_NEWEST_UNSUPPORTED
+export HOMEBREW_MACOS_OLDEST_SUPPORTED
+export HOMEBREW_MACOS_OLDEST_ALLOWED
 export HOMEBREW_USER_AGENT
 export HOMEBREW_USER_AGENT_CURL
+export HOMEBREW_API_DEFAULT_DOMAIN
 export HOMEBREW_BOTTLE_DEFAULT_DOMAIN
-export HOMEBREW_MACOS_SYSTEM_RUBY_NEW_ENOUGH
+export HOMEBREW_CURL_SPEED_LIMIT
+export HOMEBREW_CURL_SPEED_TIME
 
 if [[ -n "${HOMEBREW_MACOS}" && -x "/usr/bin/xcode-select" ]]
 then
@@ -652,6 +780,7 @@ EOS
   # a popup window asking the user to install the CLT
   if [[ -n "${XCODE_SELECT_PATH}" ]]
   then
+    # TODO: this is fairly slow, figure out if there's a faster way.
     XCRUN_OUTPUT="$(/usr/bin/xcrun clang 2>&1)"
     XCRUN_STATUS="$?"
 
@@ -665,13 +794,6 @@ EOS
   fi
 fi
 
-if [[ "$1" == "-v" ]]
-then
-  # Shift the -v to the end of the parameter list
-  shift
-  set -- "$@" -v
-fi
-
 for arg in "$@"
 do
   [[ "${arg}" == "--" ]] && break
@@ -686,6 +808,10 @@ done
 HOMEBREW_ARG_COUNT="$#"
 HOMEBREW_COMMAND="$1"
 shift
+# If you are going to change anything in below case statement,
+# be sure to also update HOMEBREW_INTERNAL_COMMAND_ALIASES hash in commands.rb
+# doesn't need a default case as other arguments handled elsewhere.
+# shellcheck disable=SC2249
 case "${HOMEBREW_COMMAND}" in
   ls) HOMEBREW_COMMAND="list" ;;
   homepage) HOMEBREW_COMMAND="home" ;;
@@ -694,6 +820,7 @@ case "${HOMEBREW_COMMAND}" in
   ln) HOMEBREW_COMMAND="link" ;;
   instal) HOMEBREW_COMMAND="install" ;; # gem does the same
   uninstal) HOMEBREW_COMMAND="uninstall" ;;
+  post_install) HOMEBREW_COMMAND="postinstall" ;;
   rm) HOMEBREW_COMMAND="uninstall" ;;
   remove) HOMEBREW_COMMAND="uninstall" ;;
   abv) HOMEBREW_COMMAND="info" ;;
@@ -702,6 +829,8 @@ case "${HOMEBREW_COMMAND}" in
   environment) HOMEBREW_COMMAND="--env" ;;
   --config) HOMEBREW_COMMAND="config" ;;
   -v) HOMEBREW_COMMAND="--version" ;;
+  lc) HOMEBREW_COMMAND="livecheck" ;;
+  tc) HOMEBREW_COMMAND="typecheck" ;;
 esac
 
 # Set HOMEBREW_DEV_CMD_RUN for users who have run a development command.
@@ -719,8 +848,50 @@ then
   unset HOMEBREW_RUBY_WARNINGS
 fi
 
-# Disable Ruby options we don't need.
-RUBY_DISABLE_OPTIONS="--disable=rubyopt"
+unset HOMEBREW_AUTO_UPDATE_COMMAND
+
+# Check for commands that should call `brew update --auto-update` first.
+AUTO_UPDATE_COMMANDS=(
+  install
+  outdated
+  upgrade
+  bundle
+  release
+)
+if check-array-membership "${HOMEBREW_COMMAND}" "${AUTO_UPDATE_COMMANDS[@]}" ||
+   [[ "${HOMEBREW_COMMAND}" == "tap" && "${HOMEBREW_ARG_COUNT}" -gt 1 ]]
+then
+  export HOMEBREW_AUTO_UPDATE_COMMAND="1"
+fi
+
+# Check for commands that should auto-update the homebrew-core tap.
+AUTO_UPDATE_CORE_TAP_COMMANDS=(
+  bump
+  bump-formula-pr
+)
+if check-array-membership "${HOMEBREW_COMMAND}" "${AUTO_UPDATE_CORE_TAP_COMMANDS[@]}"
+then
+  export HOMEBREW_AUTO_UPDATE_COMMAND="1"
+  export HOMEBREW_AUTO_UPDATE_CORE_TAP="1"
+elif [[ -z "${HOMEBREW_AUTO_UPDATING}" ]]
+then
+  unset HOMEBREW_AUTO_UPDATE_CORE_TAP
+fi
+
+# Check for commands that should auto-update the homebrew-cask tap.
+AUTO_UPDATE_CASK_TAP_COMMANDS=(
+  bump
+  bump-cask-pr
+  bump-unversioned-casks
+)
+if check-array-membership "${HOMEBREW_COMMAND}" "${AUTO_UPDATE_CASK_TAP_COMMANDS[@]}"
+then
+  export HOMEBREW_AUTO_UPDATE_COMMAND="1"
+  export HOMEBREW_AUTO_UPDATE_CASK_TAP="1"
+elif [[ -z "${HOMEBREW_AUTO_UPDATING}" ]]
+then
+  unset HOMEBREW_AUTO_UPDATE_CASK_TAP
+fi
 
 if [[ -z "${HOMEBREW_RUBY_WARNINGS}" ]]
 then
@@ -742,27 +913,43 @@ fi
 export HOMEBREW_CORE_GIT_REMOTE
 
 # Set HOMEBREW_DEVELOPER_COMMAND if the command being run is a developer command
+unset HOMEBREW_DEVELOPER_COMMAND
 if [[ -f "${HOMEBREW_LIBRARY}/Homebrew/dev-cmd/${HOMEBREW_COMMAND}.sh" ]] ||
    [[ -f "${HOMEBREW_LIBRARY}/Homebrew/dev-cmd/${HOMEBREW_COMMAND}.rb" ]]
 then
   export HOMEBREW_DEVELOPER_COMMAND="1"
 fi
 
+# Provide a (temporary, undocumented) way to disable Sorbet globally if needed
+# to avoid reverting the above.
+if [[ -n "${HOMEBREW_NO_SORBET_RUNTIME}" ]]
+then
+  unset HOMEBREW_SORBET_RUNTIME
+fi
+
 if [[ -n "${HOMEBREW_DEVELOPER_COMMAND}" && -z "${HOMEBREW_DEVELOPER}" ]]
 then
   if [[ -z "${HOMEBREW_DEV_CMD_RUN}" ]]
   then
-    message="$(bold "${HOMEBREW_COMMAND}") is a developer command, so
-Homebrew's developer mode has been automatically turned on.
-To turn developer mode off, run $(bold "brew developer off")
-"
-    opoo "${message}"
+    opoo <<EOS
+$(bold "${HOMEBREW_COMMAND}") is a developer command, so Homebrew's
+developer mode has been automatically turned on.
+To turn developer mode off, run:
+  brew developer off
+
+EOS
   fi
 
   git config --file="${HOMEBREW_GIT_CONFIG_FILE}" --replace-all homebrew.devcmdrun true 2>/dev/null
   export HOMEBREW_DEV_CMD_RUN="1"
 fi
 
+if [[ -n "${HOMEBREW_DEVELOPER}" || -n "${HOMEBREW_DEV_CMD_RUN}" ]]
+then
+  # Always run with Sorbet for Homebrew developers or when a Homebrew developer command has been run.
+  export HOMEBREW_SORBET_RUNTIME="1"
+fi
+
 if [[ -f "${HOMEBREW_LIBRARY}/Homebrew/cmd/${HOMEBREW_COMMAND}.sh" ]]
 then
   HOMEBREW_BASH_COMMAND="${HOMEBREW_LIBRARY}/Homebrew/cmd/${HOMEBREW_COMMAND}.sh"
@@ -775,17 +962,16 @@ check-run-command-as-root
 
 check-prefix-is-not-tmpdir
 
-# shellcheck disable=SC2250
 if [[ "${HOMEBREW_PREFIX}" == "/usr/local" ]] &&
    [[ "${HOMEBREW_PREFIX}" != "${HOMEBREW_REPOSITORY}" ]] &&
    [[ "${HOMEBREW_CELLAR}" == "${HOMEBREW_REPOSITORY}/Cellar" ]]
 then
   cat >&2 <<EOS
 Warning: your HOMEBREW_PREFIX is set to /usr/local but HOMEBREW_CELLAR is set
-to $HOMEBREW_CELLAR. Your current HOMEBREW_CELLAR location will stop
+to ${HOMEBREW_CELLAR}. Your current HOMEBREW_CELLAR location will stop
 you being able to use all the binary packages (bottles) Homebrew provides. We
 recommend you move your HOMEBREW_CELLAR to /usr/local/Cellar which will get you
-access to all bottles."
+access to all bottles.
 EOS
 fi
 
@@ -835,7 +1021,7 @@ else
   # shellcheck disable=SC2154
   {
     auto-update "$@"
-    exec "${HOMEBREW_RUBY_PATH}" "${HOMEBREW_RUBY_WARNINGS}" "${RUBY_DISABLE_OPTIONS}" \
+    exec "${HOMEBREW_RUBY_PATH}" "${HOMEBREW_RUBY_WARNINGS}" "${HOMEBREW_RUBY_DISABLE_OPTIONS}" \
       "${HOMEBREW_LIBRARY}/Homebrew/brew.rb" "$@"
   }
 fi
diff --git a/Library/Homebrew/brew_irbrc b/Library/Homebrew/brew_irbrc
new file mode 100644
index 0000000000000..00217d3fdd764
--- /dev/null
+++ b/Library/Homebrew/brew_irbrc
@@ -0,0 +1,9 @@
+# NOTE: We use a non-standard config file name to reduce name clashes with
+#       other IRB config files like `.irbrc`.
+# NOTE: This doesn't work with system Ruby for some reason.
+
+require 'irb/completion'
+
+IRB.conf[:HISTORY_FILE] = "#{Dir.home}/.brew_irb_history"
+IRB.conf[:IRB_NAME] = "brew"
+H = Homebrew
diff --git a/Library/Homebrew/build.rb b/Library/Homebrew/build.rb
index b432fdca82e34..4d782c2ed5da1 100644
--- a/Library/Homebrew/build.rb
+++ b/Library/Homebrew/build.rb
@@ -1,23 +1,23 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 # This script is loaded by formula_installer as a separate instance.
 # Thrown exceptions are propagated back to the parent process over a pipe
 
+raise "#{__FILE__} must not be loaded via `require`." if $PROGRAM_NAME != __FILE__
+
 old_trap = trap("INT") { exit! 130 }
 
 require_relative "global"
 require "build_options"
 require "keg"
 require "extend/ENV"
-require "debrew"
 require "fcntl"
-require "socket"
+require "utils/socket"
 require "cmd/install"
+require "json/add/exception"
 
 # A formula build.
-#
-# @api private
 class Build
   attr_reader :formula, :deps, :reqs, :args
 
@@ -55,7 +55,7 @@ def expand_deps
       build = effective_build_options_for(dependent)
       if dep.prune_from_option?(build) ||
          dep.prune_if_build_and_not_dependent?(dependent, formula) ||
-         (dep.test? && !dep.build?)
+         (dep.test? && !dep.build?) || dep.implicit?
         Dependency.prune
       elsif dep.build?
         Dependency.keep_but_prune_recursive_deps
@@ -75,34 +75,35 @@ def install
     ENV.activate_extensions!(env: args.env)
 
     if superenv?(args.env)
-      ENV.keg_only_deps = keg_only_deps
-      ENV.deps = formula_deps
-      ENV.run_time_deps = run_time_deps
+      superenv = T.cast(ENV, Superenv)
+      superenv.keg_only_deps = keg_only_deps
+      superenv.deps = formula_deps
+      superenv.run_time_deps = run_time_deps
       ENV.setup_build_environment(
-        formula:      formula,
-        cc:           args.cc,
-        build_bottle: args.build_bottle?,
-        bottle_arch:  args.bottle_arch,
+        formula:,
+        cc:            args.cc,
+        build_bottle:  args.build_bottle?,
+        bottle_arch:   args.bottle_arch,
+        debug_symbols: args.debug_symbols?,
       )
       reqs.each do |req|
         req.modify_build_environment(
           env: args.env, cc: args.cc, build_bottle: args.build_bottle?, bottle_arch: args.bottle_arch,
         )
       end
-      deps.each(&:modify_build_environment)
     else
       ENV.setup_build_environment(
-        formula:      formula,
-        cc:           args.cc,
-        build_bottle: args.build_bottle?,
-        bottle_arch:  args.bottle_arch,
+        formula:,
+        cc:            args.cc,
+        build_bottle:  args.build_bottle?,
+        bottle_arch:   args.bottle_arch,
+        debug_symbols: args.debug_symbols?,
       )
       reqs.each do |req|
         req.modify_build_environment(
           env: args.env, cc: args.cc, build_bottle: args.build_bottle?, bottle_arch: args.bottle_arch,
         )
       end
-      deps.each(&:modify_build_environment)
 
       keg_only_deps.each do |dep|
         ENV.prepend_path "PATH", dep.opt_bin.to_s
@@ -122,24 +123,30 @@ def install
     }
 
     with_env(new_env) do
-      formula.extend(Debrew::Formula) if args.debug?
+      if args.debug? && !Homebrew::EnvConfig.disable_debrew?
+        require "debrew"
+        formula.extend(Debrew::Formula)
+      end
 
       formula.update_head_version
 
       formula.brew(
-        fetch:       false,
-        keep_tmp:    args.keep_tmp?,
-        interactive: args.interactive?,
+        fetch:         false,
+        keep_tmp:      args.keep_tmp?,
+        debug_symbols: args.debug_symbols?,
+        interactive:   args.interactive?,
       ) do
         with_env(
           # For head builds, HOMEBREW_FORMULA_PREFIX should include the commit,
           # which is not known until after the formula has been staged.
-          HOMEBREW_FORMULA_PREFIX: formula.prefix,
+          HOMEBREW_FORMULA_PREFIX:    formula.prefix,
+          # https://reproducible-builds.org/docs/build-path/
+          HOMEBREW_FORMULA_BUILDPATH: formula.buildpath,
           # https://reproducible-builds.org/docs/source-date-epoch/
-          SOURCE_DATE_EPOCH:       formula.source_modified_time.to_i.to_s,
+          SOURCE_DATE_EPOCH:          formula.source_modified_time.to_i.to_s,
           # Avoid make getting confused about timestamps.
           # https://github.com/Homebrew/homebrew-core/pull/87470
-          TZ:                      "UTC0",
+          TZ:                         "UTC0",
         ) do
           formula.patch
 
@@ -193,34 +200,35 @@ def detect_stdlibs
     keg.detect_cxx_stdlibs(skip_executables: true)
   end
 
-  def fixopt(f)
-    path = if f.linked_keg.directory? && f.linked_keg.symlink?
-      f.linked_keg.resolved_path
-    elsif f.prefix.directory?
-      f.prefix
-    elsif (kids = f.rack.children).size == 1 && kids.first.directory?
+  def fixopt(formula)
+    path = if formula.linked_keg.directory? && formula.linked_keg.symlink?
+      formula.linked_keg.resolved_path
+    elsif formula.prefix.directory?
+      formula.prefix
+    elsif (kids = formula.rack.children).size == 1 && kids.first.directory?
       kids.first
     else
       raise
     end
     Keg.new(path).optlink(verbose: args.verbose?)
   rescue
-    raise "#{f.opt_prefix} not present or broken\nPlease reinstall #{f.full_name}. Sorry :("
+    raise "#{formula.opt_prefix} not present or broken\nPlease reinstall #{formula.full_name}. Sorry :("
   end
 end
 
 begin
-  args = Homebrew.install_args.parse
+  ENV.delete("HOMEBREW_FORBID_PACKAGES_FROM_PATHS")
+  args = Homebrew::Cmd::InstallCmd.new.args
   Context.current = args.context
 
-  error_pipe = UNIXSocket.open(ENV.fetch("HOMEBREW_ERROR_PIPE"), &:recv_io)
+  error_pipe = Utils::UNIXSocketExt.open(ENV.fetch("HOMEBREW_ERROR_PIPE"), &:recv_io)
   error_pipe.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 
   trap("INT", old_trap)
 
   formula = args.named.to_formulae.first
   options = Options.create(args.flags_only)
-  build   = Build.new(formula, options, args: args)
+  build   = Build.new(formula, options, args:)
   build.install
 rescue Exception => e # rubocop:disable Lint/RescueException
   error_hash = JSON.parse e.to_json
@@ -230,12 +238,12 @@ def fixopt(f)
   # BuildErrors are specific to build processes and not other
   # children, which is why we create the necessary state here
   # and not in Utils.safe_fork.
-  case error_hash["json_class"]
-  when "BuildError"
+  case e
+  when BuildError
     error_hash["cmd"] = e.cmd
     error_hash["args"] = e.args
     error_hash["env"] = e.env
-  when "ErrorDuringExecution"
+  when ErrorDuringExecution
     error_hash["cmd"] = e.cmd
     error_hash["status"] = if e.status.is_a?(Process::Status)
       {
diff --git a/Library/Homebrew/build_environment.rb b/Library/Homebrew/build_environment.rb
index 2392b98d5cc52..10fecf1579ba9 100644
--- a/Library/Homebrew/build_environment.rb
+++ b/Library/Homebrew/build_environment.rb
@@ -1,12 +1,8 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 # Settings for the build environment.
-#
-# @api private
 class BuildEnvironment
-  extend T::Sig
-
   sig { params(settings: Symbol).void }
   def initialize(*settings)
     @settings = Set.new(settings)
@@ -18,9 +14,9 @@ def merge(*args)
     self
   end
 
-  sig { params(o: Symbol).returns(T.self_type) }
-  def <<(o)
-    @settings << o
+  sig { params(option: Symbol).returns(T.self_type) }
+  def <<(option)
+    @settings << option
     self
   end
 
@@ -31,11 +27,17 @@ def std?
 
   # DSL for specifying build environment settings.
   module DSL
-    extend T::Sig
+    # Initialise @env for each class which may use this DSL (e.g. each formula subclass).
+    # `env` may never be called and it needs to be initialised before the class is frozen.
+    def inherited(child)
+      super
+      child.instance_eval do
+        @env = BuildEnvironment.new
+      end
+    end
 
     sig { params(settings: Symbol).returns(BuildEnvironment) }
     def env(*settings)
-      @env ||= BuildEnvironment.new
       @env.merge(settings)
     end
   end
@@ -55,25 +57,26 @@ def env(*settings)
   ].freeze
   private_constant :KEYS
 
-  sig { params(env: T.untyped).returns(T::Array[String]) }
+  sig { params(env: T::Hash[String, T.nilable(T.any(String, Pathname))]).returns(T::Array[String]) }
   def self.keys(env)
     KEYS & env.keys
   end
 
-  sig { params(env: T.untyped, f: IO).void }
-  def self.dump(env, f = $stdout)
+  sig { params(env: T::Hash[String, T.nilable(T.any(String, Pathname))], out: IO).void }
+  def self.dump(env, out = $stdout)
     keys = self.keys(env)
     keys -= %w[CC CXX OBJC OBJCXX] if env["CC"] == env["HOMEBREW_CC"]
 
     keys.each do |key|
       value = env.fetch(key)
-      s = +"#{key}: #{value}"
+
+      string = "#{key}: #{value}"
       case key
       when "CC", "CXX", "LD"
-        s << " => #{Pathname.new(value).realpath}" if File.symlink?(value)
+        string << " => #{Pathname.new(value).realpath}" if value.present? && File.symlink?(value)
       end
-      s.freeze
-      f.puts s
+      string.freeze
+      out.puts string
     end
   end
 end
diff --git a/Library/Homebrew/build_options.rb b/Library/Homebrew/build_options.rb
index 5f173ad2d2fe8..1baf70938e723 100644
--- a/Library/Homebrew/build_options.rb
+++ b/Library/Homebrew/build_options.rb
@@ -1,27 +1,34 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 # Options for a formula build.
-#
-# @api private
 class BuildOptions
-  # @private
   def initialize(args, options)
     @args = args
     @options = options
   end
 
   # True if a {Formula} is being built with a specific option.
-  # <pre>args << "--i-want-spam" if build.with? "spam"
   #
+  # ### Examples
+  #
+  # ```ruby
+  # args << "--i-want-spam" if build.with? "spam"
+  # ```
+  #
+  # ```ruby
   # args << "--qt-gui" if build.with? "qt" # "--with-qt" ==> build.with? "qt"
+  # ```
+  #
+  # If a formula presents a user with a choice, but the choice must be fulfilled:
   #
-  # # If a formula presents a user with a choice, but the choice must be fulfilled:
+  # ```ruby
   # if build.with? "example2"
   #   args << "--with-example2"
   # else
   #   args << "--with-example1"
-  # end</pre>
+  # end
+  # ```
   def with?(val)
     option_names = val.respond_to?(:option_names) ? val.option_names : [val]
 
@@ -29,7 +36,7 @@ def with?(val)
       if option_defined? "with-#{name}"
         include? "with-#{name}"
       elsif option_defined? "without-#{name}"
-        !include? "without-#{name}" # rubocop:disable Rails/NegateInclude
+        !include? "without-#{name}"
       else
         false
       end
@@ -37,7 +44,12 @@ def with?(val)
   end
 
   # True if a {Formula} is being built without a specific option.
-  # <pre>args << "--no-spam-plz" if build.without? "spam"</pre>
+  #
+  # ### Example
+  #
+  # ```ruby
+  # args << "--no-spam-plz" if build.without? "spam"
+  # ```
   def without?(val)
     !with?(val)
   end
@@ -48,19 +60,33 @@ def bottle?
   end
 
   # True if a {Formula} is being built with {Formula.head} instead of {Formula.stable}.
-  # <pre>args << "--some-new-stuff" if build.head?</pre>
-  # <pre># If there are multiple conditional arguments use a block instead of lines.
+  #
+  # ### Examples
+  #
+  # ```ruby
+  # args << "--some-new-stuff" if build.head?
+  # ```
+  #
+  # If there are multiple conditional arguments use a block instead of lines.
+  #
+  # ```ruby
   # if build.head?
   #   args << "--i-want-pizza"
   #   args << "--and-a-cold-beer" if build.with? "cold-beer"
-  # end</pre>
+  # end
+  # ```
   def head?
     include? "HEAD"
   end
 
   # True if a {Formula} is being built with {Formula.stable} instead of {Formula.head}.
   # This is the default.
-  # <pre>args << "--some-beta" if build.head?</pre>
+  #
+  # ### Example
+  #
+  # ```ruby
+  # args << "--some-beta" if build.head?
+  # ```
   def stable?
     !head?
   end
@@ -70,12 +96,10 @@ def any_args_or_options?
     !@args.empty? || !@options.empty?
   end
 
-  # @private
   def used_options
     @options & @args
   end
 
-  # @private
   def unused_options
     @options - @args
   end
diff --git a/Library/Homebrew/bump_version_parser.rb b/Library/Homebrew/bump_version_parser.rb
new file mode 100644
index 0000000000000..cc47324e32f35
--- /dev/null
+++ b/Library/Homebrew/bump_version_parser.rb
@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  # Class handling architecture-specific version information.
+  class BumpVersionParser
+    sig { returns(T.nilable(T.any(Version, Cask::DSL::Version))) }
+    attr_reader :arm, :general, :intel
+
+    sig {
+      params(general: T.nilable(T.any(Version, String)),
+             arm:     T.nilable(T.any(Version, String)),
+             intel:   T.nilable(T.any(Version, String))).void
+    }
+    def initialize(general: nil, arm: nil, intel: nil)
+      @general = T.let(parse_version(general), T.nilable(T.any(Version, Cask::DSL::Version))) if general.present?
+      @arm = T.let(parse_version(arm), T.nilable(T.any(Version, Cask::DSL::Version))) if arm.present?
+      @intel = T.let(parse_version(intel), T.nilable(T.any(Version, Cask::DSL::Version))) if intel.present?
+
+      return if @general.present?
+      raise UsageError, "`--version` must not be empty." if arm.blank? && intel.blank?
+      raise UsageError, "`--version-arm` must not be empty." if arm.blank?
+      raise UsageError, "`--version-intel` must not be empty." if intel.blank?
+    end
+
+    sig {
+      params(version: T.any(Version, String))
+        .returns(T.nilable(T.any(Version, Cask::DSL::Version)))
+    }
+    def parse_version(version)
+      if version.is_a?(Version)
+        version
+      elsif version.is_a?(String)
+        parse_cask_version(version)
+      end
+    end
+
+    sig { params(version: String).returns(T.nilable(Cask::DSL::Version)) }
+    def parse_cask_version(version)
+      if version == "latest"
+        Cask::DSL::Version.new(:latest)
+      else
+        Cask::DSL::Version.new(version)
+      end
+    end
+
+    sig { returns(T::Boolean) }
+    def blank?
+      @general.blank? && @arm.blank? && @intel.blank?
+    end
+  end
+end
diff --git a/Library/Homebrew/bundle_version.rb b/Library/Homebrew/bundle_version.rb
index 92c522659a1f5..065e3098ba61c 100644
--- a/Library/Homebrew/bundle_version.rb
+++ b/Library/Homebrew/bundle_version.rb
@@ -1,15 +1,11 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "system_command"
 
 module Homebrew
   # Representation of a macOS bundle version, commonly found in `Info.plist` files.
-  #
-  # @api private
   class BundleVersion
-    extend T::Sig
-
     include Comparable
 
     extend SystemCommand::Mixin
@@ -52,6 +48,9 @@ def self.from_package_info(package_info_path)
 
     sig { params(short_version: T.nilable(String), version: T.nilable(String)).void }
     def initialize(short_version, version)
+      # Remove version from short version, if present.
+      short_version = short_version&.sub(/\s*\(#{Regexp.escape(version)}\)\Z/, "") if version
+
       @short_version = short_version.presence
       @version = version.presence
 
@@ -61,8 +60,26 @@ def initialize(short_version, version)
     end
 
     def <=>(other)
-      [version, short_version].map { |v| v&.yield_self(&Version.public_method(:new)) || Version::NULL } <=>
-        [other.version, other.short_version].map { |v| v&.yield_self(&Version.public_method(:new)) || Version::NULL }
+      return super unless instance_of?(other.class)
+
+      make_version = ->(v) { v ? Version.new(v) : Version::NULL }
+
+      version = self.version.then(&make_version)
+      other_version = other.version.then(&make_version)
+
+      difference = version <=> other_version
+
+      # If `version` is equal or cannot be compared, compare `short_version` instead.
+      if difference.nil? || difference.zero?
+        short_version = self.short_version.then(&make_version)
+        other_short_version = other.short_version.then(&make_version)
+
+        short_version_difference = short_version <=> other_short_version
+
+        return short_version_difference unless short_version_difference.nil?
+      end
+
+      difference
     end
 
     def ==(other)
@@ -81,8 +98,6 @@ def nice_parts
       short_version = self.short_version
       version = self.version
 
-      short_version = short_version&.delete_suffix("(#{version})") if version
-
       return [T.must(short_version)] if short_version == version
 
       if short_version && version
diff --git a/Library/Homebrew/cache_store.rb b/Library/Homebrew/cache_store.rb
index e28795d4bf557..11426ef5eac45 100644
--- a/Library/Homebrew/cache_store.rb
+++ b/Library/Homebrew/cache_store.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "json"
@@ -60,7 +60,7 @@ def get(key)
     db[key]
   end
 
-  # Gets a value from the underlying database (if it already exists).
+  # Deletes a value from the underlying database (if it already exists).
   def delete(key)
     return unless created?
 
@@ -68,6 +68,14 @@ def delete(key)
     db.delete(key)
   end
 
+  # Deletes all content from the underlying database (if it already exists).
+  def clear!
+    return unless created?
+
+    dirty!
+    db.clear
+  end
+
   # Closes the underlying database (if it is created and open).
   def write_if_dirty!
     return unless dirty?
diff --git a/Library/Homebrew/cask.rb b/Library/Homebrew/cask.rb
index 2f9df69d02336..9bb3b7444a1b8 100644
--- a/Library/Homebrew/cask.rb
+++ b/Library/Homebrew/cask.rb
@@ -8,7 +8,6 @@
 require "cask/cask_loader"
 require "cask/cask"
 require "cask/caskroom"
-require "cask/cmd"
 require "cask/config"
 require "cask/exceptions"
 require "cask/denylist"
@@ -17,8 +16,10 @@
 require "cask/installer"
 require "cask/macos"
 require "cask/metadata"
+require "cask/migrator"
 require "cask/pkg"
 require "cask/quarantine"
 require "cask/staged"
+require "cask/tab"
 require "cask/url"
 require "cask/utils"
diff --git a/Library/Homebrew/cask/artifact.rb b/Library/Homebrew/cask/artifact.rb
index bee610cfb5702..eab26b9f4334f 100644
--- a/Library/Homebrew/cask/artifact.rb
+++ b/Library/Homebrew/cask/artifact.rb
@@ -11,6 +11,7 @@
 require "cask/artifact/input_method"
 require "cask/artifact/installer"
 require "cask/artifact/internet_plugin"
+require "cask/artifact/keyboard_layout"
 require "cask/artifact/manpage"
 require "cask/artifact/vst_plugin"
 require "cask/artifact/vst3_plugin"
@@ -29,8 +30,6 @@
 
 module Cask
   # Module containing all cask artifact classes.
-  #
-  # @api private
   module Artifact
   end
 end
diff --git a/Library/Homebrew/cask/artifact/abstract_artifact.rb b/Library/Homebrew/cask/artifact/abstract_artifact.rb
index 5c1abb3ffd40a..fa8057335c955 100644
--- a/Library/Homebrew/cask/artifact/abstract_artifact.rb
+++ b/Library/Homebrew/cask/artifact/abstract_artifact.rb
@@ -1,33 +1,37 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "attrable"
+require "extend/object/deep_dup"
+
 module Cask
   module Artifact
     # Abstract superclass for all artifacts.
-    #
-    # @api private
     class AbstractArtifact
-      extend T::Sig
+      extend T::Helpers
+      abstract!
 
       include Comparable
-      extend Predicable
 
       def self.english_name
-        @english_name ||= name.sub(/^.*:/, "").gsub(/(.)([A-Z])/, '\1 \2')
+        @english_name ||= T.must(name).sub(/^.*:/, "").gsub(/(.)([A-Z])/, '\1 \2')
       end
 
       def self.english_article
-        @english_article ||= (english_name =~ /^[aeiou]/i) ? "an" : "a"
+        @english_article ||= /^[aeiou]/i.match?(english_name) ? "an" : "a"
       end
 
       def self.dsl_key
-        @dsl_key ||= name.sub(/^.*:/, "").gsub(/(.)([A-Z])/, '\1_\2').downcase.to_sym
+        @dsl_key ||= T.must(name).sub(/^.*:/, "").gsub(/(.)([A-Z])/, '\1_\2').downcase.to_sym
       end
 
       def self.dirmethod
-        @dirmethod ||= "#{dsl_key}dir".to_sym
+        @dirmethod ||= :"#{dsl_key}dir"
       end
 
+      sig { abstract.returns(String) }
+      def summarize; end
+
       def staged_path_join_executable(path)
         path = Pathname(path)
         path = path.expand_path if path.to_s.start_with?("~")
@@ -75,6 +79,7 @@ def <=>(other)
             Service,
             InputMethod,
             InternetPlugin,
+            KeyboardLayout,
             AudioUnitPlugin,
             VstPlugin,
             Vst3Plugin,
@@ -97,7 +102,12 @@ def self.read_script_arguments(arguments, stanza, default_arguments = {}, overri
         description = key ? "#{stanza} #{key.inspect}" : stanza.to_s
 
         # backward-compatible string value
-        arguments = { executable: arguments } if arguments.is_a?(String)
+        arguments = if arguments.is_a?(String)
+          { executable: arguments }
+        else
+          # Avoid mutating the original argument
+          arguments.dup
+        end
 
         # key sanity
         permitted_keys = [:args, :input, :executable, :must_succeed, :sudo, :print_stdout, :print_stderr]
@@ -127,8 +137,9 @@ def self.read_script_arguments(arguments, stanza, default_arguments = {}, overri
 
       attr_reader :cask
 
-      def initialize(cask)
+      def initialize(cask, *dsl_args)
         @cask = cask
+        @dsl_args = dsl_args.deep_dup
       end
 
       def config
@@ -139,6 +150,10 @@ def config
       def to_s
         "#{summarize} (#{self.class.english_name})"
       end
+
+      def to_args
+        @dsl_args.compact_blank
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cask/artifact/abstract_flight_block.rb b/Library/Homebrew/cask/artifact/abstract_flight_block.rb
index 1695a257a5e5c..497f1afdf1b70 100644
--- a/Library/Homebrew/cask/artifact/abstract_flight_block.rb
+++ b/Library/Homebrew/cask/artifact/abstract_flight_block.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/artifact/abstract_artifact"
@@ -6,8 +6,6 @@
 module Cask
   module Artifact
     # Abstract superclass for block artifacts.
-    #
-    # @api private
     class AbstractFlightBlock < AbstractArtifact
       def self.dsl_key
         super.to_s.sub(/_block$/, "").to_sym
@@ -32,6 +30,10 @@ def uninstall_phase(**)
         abstract_phase(self.class.uninstall_dsl_key)
       end
 
+      def summarize
+        directives.keys.map(&:to_s).join(", ")
+      end
+
       private
 
       def class_for_dsl_key(dsl_key)
@@ -44,10 +46,6 @@ def abstract_phase(dsl_key)
 
         class_for_dsl_key(dsl_key).new(cask).instance_eval(&block)
       end
-
-      def summarize
-        directives.keys.map(&:to_s).join(", ")
-      end
     end
   end
 end
diff --git a/Library/Homebrew/cask/artifact/abstract_uninstall.rb b/Library/Homebrew/cask/artifact/abstract_uninstall.rb
index 2c8489828ce84..36b7aea555726 100644
--- a/Library/Homebrew/cask/artifact/abstract_uninstall.rb
+++ b/Library/Homebrew/cask/artifact/abstract_uninstall.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "timeout"
@@ -6,16 +6,14 @@
 require "utils/user"
 require "cask/artifact/abstract_artifact"
 require "cask/pkg"
-require "extend/hash_validator"
-using HashValidator
+require "extend/hash/keys"
+require "system_command"
 
 module Cask
   module Artifact
     # Abstract superclass for uninstall artifacts.
-    #
-    # @api private
     class AbstractUninstall < AbstractArtifact
-      extend T::Sig
+      include SystemCommand::Mixin
 
       ORDERED_DIRECTIVES = [
         :early_script,
@@ -32,21 +30,24 @@ class AbstractUninstall < AbstractArtifact
       ].freeze
 
       def self.from_args(cask, **directives)
-        new(cask, directives)
+        new(cask, **directives)
       end
 
       attr_reader :directives
 
-      def initialize(cask, directives)
-        directives.assert_valid_keys!(*ORDERED_DIRECTIVES)
+      def initialize(cask, **directives)
+        directives.assert_valid_keys(*ORDERED_DIRECTIVES)
 
-        super(cask)
+        super
         directives[:signal] = Array(directives[:signal]).flatten.each_slice(2).to_a
         @directives = directives
 
+        # This is already included when loading from the API.
+        return if cask.loaded_from_api?
         return unless directives.key?(:kext)
 
         cask.caveats do
+          T.bind(self, ::Cask::DSL::Caveats)
           kext
         end
       end
@@ -55,7 +56,7 @@ def to_h
         directives.to_h
       end
 
-      sig { returns(String) }
+      sig { override.returns(String) }
       def summarize
         to_h.flat_map { |key, val| Array(val).map { |v| "#{key.inspect} => #{v.inspect}" } }.join(", ")
       end
@@ -73,7 +74,7 @@ def dispatch_uninstall_directive(directive_sym, **options)
 
         args = directives[directive_sym]
 
-        send("uninstall_#{directive_sym}", *(args.is_a?(Hash) ? [args] : args), **options)
+        send(:"uninstall_#{directive_sym}", *(args.is_a?(Hash) ? [args] : args), **options)
       end
 
       def stanza
@@ -90,32 +91,63 @@ def uninstall_early_script(directives, **options)
       # :launchctl must come before :quit/:signal for cases where app would instantly re-launch
       def uninstall_launchctl(*services, command: nil, **_)
         booleans = [false, true]
+
+        all_services = []
+
+        # if launchctl item contains a wildcard, find matching process(es)
         services.each do |service|
+          all_services << service unless service.include?("*")
+          next unless service.include?("*")
+
+          found_services = find_launchctl_with_wildcard(service)
+          next if found_services.blank?
+
+          found_services.each { |found_service| all_services << found_service }
+        end
+
+        all_services.each do |service|
           ohai "Removing launchctl service #{service}"
-          booleans.each do |with_sudo|
+          booleans.each do |sudo|
             plist_status = command.run(
               "/bin/launchctl",
-              args: ["list", service],
-              sudo: with_sudo, print_stderr: false
+              args:         ["list", service],
+              sudo:,
+              sudo_as_root: sudo,
+              print_stderr: false,
             ).stdout
             if plist_status.start_with?("{")
-              command.run!("/bin/launchctl", args: ["remove", service], sudo: with_sudo)
+              command.run!(
+                "/bin/launchctl",
+                args:         ["remove", service],
+                sudo:,
+                sudo_as_root: sudo,
+              )
               sleep 1
             end
             paths = [
-              +"/Library/LaunchAgents/#{service}.plist",
-              +"/Library/LaunchDaemons/#{service}.plist",
+              "/Library/LaunchAgents/#{service}.plist",
+              "/Library/LaunchDaemons/#{service}.plist",
             ]
-            paths.each { |elt| elt.prepend(Dir.home).freeze } unless with_sudo
+            paths.each { |elt| elt.prepend(Dir.home).freeze } unless sudo
             paths = paths.map { |elt| Pathname(elt) }.select(&:exist?)
             paths.each do |path|
-              command.run!("/bin/rm", args: ["-f", "--", path], sudo: with_sudo)
+              command.run!("/bin/rm", args: ["-f", "--", path], sudo:, sudo_as_root: sudo)
             end
             # undocumented and untested: pass a path to uninstall :launchctl
             next unless Pathname(service).exist?
 
-            command.run!("/bin/launchctl", args: ["unload", "-w", "--", service], sudo: with_sudo)
-            command.run!("/bin/rm", args: ["-f", "--", service], sudo: with_sudo)
+            command.run!(
+              "/bin/launchctl",
+              args:         ["unload", "-w", "--", service],
+              sudo:,
+              sudo_as_root: sudo,
+            )
+            command.run!(
+              "/bin/rm",
+              args:         ["-f", "--", service],
+              sudo:,
+              sudo_as_root: sudo,
+            )
             sleep 1
           end
         end
@@ -131,11 +163,27 @@ def running_processes(bundle_id)
           end
       end
 
+      def find_launchctl_with_wildcard(search)
+        regex = Regexp.escape(search).gsub("\\*", ".*")
+        system_command!("/bin/launchctl", args: ["list"])
+          .stdout.lines.drop(1) # skip stdout column headers
+          .filter_map do |line|
+            pid, _state, id = line.chomp.split(/\s+/)
+            id if pid.to_i.nonzero? && id.match?(regex)
+          end
+      end
+
       sig { returns(String) }
       def automation_access_instructions
+        navigation_path = if MacOS.version >= :ventura
+          "System Settings → Privacy & Security"
+        else
+          "System Preferences → Security & Privacy → Privacy"
+        end
+
         <<~EOS
           Enable Automation access for "Terminal → System Events" in:
-            System Preferences → Security & Privacy → Privacy → Automation
+            #{navigation_path} → Automation
           if you haven't already.
         EOS
       end
@@ -145,7 +193,7 @@ def uninstall_quit(*bundle_ids, command: nil, **_)
         bundle_ids.each do |bundle_id|
           next unless running?(bundle_id)
 
-          unless User.current.gui?
+          unless T.must(User.current).gui?
             opoo "Not logged into a GUI; skipping quitting application ID '#{bundle_id}'."
             next
           end
@@ -220,12 +268,12 @@ def quit(bundle_id)
       # :signal should come after :quit so it can be used as a backup when :quit fails
       def uninstall_signal(*signals, command: nil, **_)
         signals.each do |pair|
-          raise CaskInvalidError.new(cask, "Each #{stanza} :signal must consist of 2 elements.") unless pair.size == 2
+          raise CaskInvalidError.new(cask, "Each #{stanza} :signal must consist of 2 elements.") if pair.size != 2
 
           signal, bundle_id = pair
           ohai "Signalling '#{signal}' to application ID '#{bundle_id}'"
           pids = running_processes(bundle_id).map(&:first)
-          next unless pids.any?
+          next if pids.none?
 
           # Note that unlike :quit, signals are sent from the current user (not
           # upgraded to the superuser). This is a todo item for the future, but
@@ -233,14 +281,19 @@ def uninstall_signal(*signals, command: nil, **_)
           # misapplied "kill" by root could bring down the system. The fact that we
           # learned the pid from AppleScript is already some degree of protection,
           # though indirect.
+          # TODO: check the user that owns the PID and don't try to kill those from other users.
           odebug "Unix ids are #{pids.inspect} for processes with bundle identifier #{bundle_id}"
-          Process.kill(signal, *pids)
+          begin
+            Process.kill(signal, *pids)
+          rescue Errno::EPERM => e
+            opoo "Failed to kill #{bundle_id} PIDs #{pids.join(", ")} with signal #{signal}: #{e}"
+          end
           sleep 3
         end
       end
 
-      def uninstall_login_item(*login_items, command: nil, upgrade: false, **_)
-        return if upgrade
+      def uninstall_login_item(*login_items, command: nil, successor: nil, **_)
+        return if successor
 
         apps = cask.artifacts.select { |a| a.class.dsl_key == :app }
         derived_login_items = apps.map { |a| { path: a.target } }
@@ -272,14 +325,35 @@ def uninstall_login_item(*login_items, command: nil, upgrade: false, **_)
       def uninstall_kext(*kexts, command: nil, **_)
         kexts.each do |kext|
           ohai "Unloading kernel extension #{kext}"
-          is_loaded = system_command!("/usr/sbin/kextstat", args: ["-l", "-b", kext], sudo: true).stdout
+          is_loaded = system_command!(
+            "/usr/sbin/kextstat",
+            args:         ["-l", "-b", kext],
+            sudo:         true,
+            sudo_as_root: true,
+          ).stdout
           if is_loaded.length > 1
-            system_command!("/sbin/kextunload", args: ["-b", kext], sudo: true)
+            system_command!(
+              "/sbin/kextunload",
+              args:         ["-b", kext],
+              sudo:         true,
+              sudo_as_root: true,
+            )
             sleep 1
           end
-          system_command!("/usr/sbin/kextfind", args: ["-b", kext], sudo: true).stdout.chomp.lines.each do |kext_path|
+          found_kexts = system_command!(
+            "/usr/sbin/kextfind",
+            args:         ["-b", kext],
+            sudo:         true,
+            sudo_as_root: true,
+          ).stdout.chomp.lines
+          found_kexts.each do |kext_path|
             ohai "Removing kernel extension #{kext_path}"
-            system_command!("/bin/rm", args: ["-rf", kext_path], sudo: true)
+            system_command!(
+              "/bin/rm",
+              args:         ["-rf", kext_path],
+              sudo:         true,
+              sudo_as_root: true,
+            )
           end
         end
       end
@@ -307,12 +381,12 @@ def uninstall_script(directives, directive_name: :script, force: false, command:
           return
         end
 
-        command.run(executable_path, script_arguments)
+        command.run(executable_path, **script_arguments)
         sleep 1
       end
 
       def uninstall_pkgutil(*pkgs, command: nil, **_)
-        ohai "Uninstalling packages; your password may be necessary:"
+        ohai "Uninstalling packages with sudo; the password may be necessary:"
         pkgs.each do |regex|
           ::Cask::Pkg.all_matching(regex, command).each do |pkg|
             puts pkg.package_id
@@ -344,8 +418,14 @@ def each_resolved_path(action, paths)
           rescue Errno::EPERM
             raise if File.readable?(File.expand_path("~/Library/Application Support/com.apple.TCC"))
 
+            navigation_path = if MacOS.version >= :ventura
+              "System Settings → Privacy & Security"
+            else
+              "System Preferences → Security & Privacy → Privacy"
+            end
+
             odie "Unable to remove some files. Please enable Full Disk Access for your terminal under " \
-                 "System Preferences → Security & Privacy → Privacy → Full Disk Access."
+                 "#{navigation_path} → Full Disk Access."
           end
         end
       end
@@ -377,12 +457,13 @@ def uninstall_trash(*paths, **options)
       def trash_paths(*paths, command: nil, **_)
         return if paths.empty?
 
-        stdout, stderr, = system_command HOMEBREW_LIBRARY_PATH/"cask/utils/trash.swift",
-                                         args:         paths,
-                                         print_stderr: false
+        stdout, = system_command HOMEBREW_LIBRARY_PATH/"cask/utils/trash.swift",
+                                 args:         paths,
+                                 print_stderr: Homebrew::EnvConfig.developer?
 
-        trashed = stdout.split(":").sort
-        untrashable = stderr.split(":").sort
+        trashed, _, untrashable = stdout.partition("\n")
+        trashed = trashed.split(":")
+        untrashable = untrashable.split(":")
 
         return trashed, untrashable if untrashable.empty?
 
@@ -390,7 +471,7 @@ def trash_paths(*paths, command: nil, **_)
           Utils.gain_permissions(path, ["-R"], SystemCommand) do
             system_command! HOMEBREW_LIBRARY_PATH/"cask/utils/trash.swift",
                             args:         [path],
-                            print_stderr: false
+                            print_stderr: Homebrew::EnvConfig.developer?
           end
 
           true
@@ -409,32 +490,48 @@ def all_dirs?(*directories)
       end
 
       def recursive_rmdir(*directories, command: nil, **_)
-        success = true
-        each_resolved_path(:rmdir, directories) do |_path, resolved_paths|
-          resolved_paths.select(&method(:all_dirs?)).each do |resolved_path|
-            puts resolved_path.sub(Dir.home, "~")
+        directories.all? do |resolved_path|
+          puts resolved_path.sub(Dir.home, "~")
 
-            if (ds_store = resolved_path.join(".DS_Store")).exist?
-              command.run!("/bin/rm", args: ["-f", "--", ds_store], sudo: true, print_stderr: false)
-            end
+          if resolved_path.readable?
+            children = resolved_path.children
 
-            unless recursive_rmdir(*resolved_path.children, command: command)
-              success = false
-              next
-            end
+            next false unless children.all? { |child| child.directory? || child.basename.to_s == ".DS_Store" }
+          else
+            lines = command.run!("/bin/ls", args: ["-A", "-F", "--", resolved_path], sudo: true, print_stderr: false)
+                           .stdout.lines.map(&:chomp)
+                           .flat_map(&:chomp)
+
+            # Using `-F` above outputs directories ending with `/`.
+            next false unless lines.all? { |l| l.end_with?("/") || l == ".DS_Store" }
+
+            children = lines.map { |l| resolved_path/l.delete_suffix("/") }
+          end
 
-            status = command.run("/bin/rmdir", args: ["--", resolved_path], sudo: true, print_stderr: false).success?
-            success &= status
+          # Directory counts as empty if it only contains a `.DS_Store`.
+          if children.include?((ds_store = resolved_path/".DS_Store"))
+            Utils.gain_permissions_remove(ds_store, command:)
+            children.delete(ds_store)
           end
+
+          next false unless recursive_rmdir(*children, command:)
+
+          Utils.gain_permissions_rmdir(resolved_path, command:)
+
+          true
         end
-        success
       end
 
-      def uninstall_rmdir(*args)
-        return if args.empty?
+      def uninstall_rmdir(*directories, **kwargs)
+        return if directories.empty?
 
         ohai "Removing directories if empty:"
-        recursive_rmdir(*args)
+
+        each_resolved_path(:rmdir, directories) do |_path, resolved_paths|
+          next unless resolved_paths.all?(&:directory?)
+
+          recursive_rmdir(*resolved_paths, **kwargs)
+        end
       end
     end
   end
diff --git a/Library/Homebrew/cask/artifact/app.rb b/Library/Homebrew/cask/artifact/app.rb
index c2ec38df44544..c4775ab323033 100644
--- a/Library/Homebrew/cask/artifact/app.rb
+++ b/Library/Homebrew/cask/artifact/app.rb
@@ -6,8 +6,6 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `app` stanza.
-    #
-    # @api private
     class App < Moved
     end
   end
diff --git a/Library/Homebrew/cask/artifact/artifact.rb b/Library/Homebrew/cask/artifact/artifact.rb
index 705cc4d18ade1..f28fa816c05db 100644
--- a/Library/Homebrew/cask/artifact/artifact.rb
+++ b/Library/Homebrew/cask/artifact/artifact.rb
@@ -3,17 +3,10 @@
 
 require "cask/artifact/moved"
 
-require "extend/hash_validator"
-using HashValidator
-
 module Cask
   module Artifact
     # Generic artifact corresponding to the `artifact` stanza.
-    #
-    # @api private
     class Artifact < Moved
-      extend T::Sig
-
       sig { returns(String) }
       def self.english_name
         "Generic Artifact"
@@ -25,7 +18,7 @@ def self.from_args(cask, *args)
 
         raise CaskInvalidError.new(cask.token, "No source provided for #{english_name}.") if source.blank?
 
-        unless options.try(:key?, :target)
+        unless options&.key?(:target)
           raise CaskInvalidError.new(cask.token, "#{english_name} '#{source}' requires a target.")
         end
 
@@ -36,11 +29,6 @@ def self.from_args(cask, *args)
       def resolve_target(target)
         super(target, base_dir: nil)
       end
-
-      sig { params(cask: Cask, source: T.any(String, Pathname), target: T.any(String, Pathname)).void }
-      def initialize(cask, source, target:)
-        super(cask, source, target: target)
-      end
     end
   end
 end
diff --git a/Library/Homebrew/cask/artifact/audio_unit_plugin.rb b/Library/Homebrew/cask/artifact/audio_unit_plugin.rb
index 1fe7cf108fa52..0a8b71eaa8310 100644
--- a/Library/Homebrew/cask/artifact/audio_unit_plugin.rb
+++ b/Library/Homebrew/cask/artifact/audio_unit_plugin.rb
@@ -6,8 +6,6 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `audio_unit_plugin` stanza.
-    #
-    # @api private
     class AudioUnitPlugin < Moved
     end
   end
diff --git a/Library/Homebrew/cask/artifact/binary.rb b/Library/Homebrew/cask/artifact/binary.rb
index a8c7d55450a62..aab9616be4c90 100644
--- a/Library/Homebrew/cask/artifact/binary.rb
+++ b/Library/Homebrew/cask/artifact/binary.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/artifact/symlinked"
@@ -6,11 +6,9 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `binary` stanza.
-    #
-    # @api private
     class Binary < Symlinked
       def link(command: nil, **options)
-        super(command: command, **options)
+        super
         return if source.executable?
 
         if source.writable?
diff --git a/Library/Homebrew/cask/artifact/colorpicker.rb b/Library/Homebrew/cask/artifact/colorpicker.rb
index 3743b70b21a57..a0d1bc7b5fe35 100644
--- a/Library/Homebrew/cask/artifact/colorpicker.rb
+++ b/Library/Homebrew/cask/artifact/colorpicker.rb
@@ -6,8 +6,6 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `colorpicker` stanza.
-    #
-    # @api private
     class Colorpicker < Moved
     end
   end
diff --git a/Library/Homebrew/cask/artifact/dictionary.rb b/Library/Homebrew/cask/artifact/dictionary.rb
index 50749b2bdd81b..a247c0949e9a3 100644
--- a/Library/Homebrew/cask/artifact/dictionary.rb
+++ b/Library/Homebrew/cask/artifact/dictionary.rb
@@ -6,8 +6,6 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `dictionary` stanza.
-    #
-    # @api private
     class Dictionary < Moved
     end
   end
diff --git a/Library/Homebrew/cask/artifact/font.rb b/Library/Homebrew/cask/artifact/font.rb
index caa2fcc7ba3ce..2902156de6e1b 100644
--- a/Library/Homebrew/cask/artifact/font.rb
+++ b/Library/Homebrew/cask/artifact/font.rb
@@ -6,8 +6,6 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `font` stanza.
-    #
-    # @api private
     class Font < Moved
     end
   end
diff --git a/Library/Homebrew/cask/artifact/input_method.rb b/Library/Homebrew/cask/artifact/input_method.rb
index 79b3acaadf875..347efba7d5e22 100644
--- a/Library/Homebrew/cask/artifact/input_method.rb
+++ b/Library/Homebrew/cask/artifact/input_method.rb
@@ -6,8 +6,6 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `input_method` stanza.
-    #
-    # @api private
     class InputMethod < Moved
     end
   end
diff --git a/Library/Homebrew/cask/artifact/installer.rb b/Library/Homebrew/cask/artifact/installer.rb
index 95c57418f49f8..903316077096e 100644
--- a/Library/Homebrew/cask/artifact/installer.rb
+++ b/Library/Homebrew/cask/artifact/installer.rb
@@ -1,36 +1,25 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/artifact/abstract_artifact"
-
-require "extend/hash_validator"
-using HashValidator
+require "extend/hash/keys"
 
 module Cask
   module Artifact
     # Artifact corresponding to the `installer` stanza.
-    #
-    # @api private
     class Installer < AbstractArtifact
       VALID_KEYS = Set.new([
         :manual,
         :script,
       ]).freeze
 
-      # Extension module for manual installers.
-      module ManualInstaller
-        def install_phase(**)
+      def install_phase(command: nil, **_)
+        if manual_install
           puts <<~EOS
-            To complete the installation of Cask #{cask}, you must also
-            run the installer at:
-              #{cask.staged_path.join(path)}
+            Cask #{cask} only provides a manual installer. To run it and complete the installation:
+              open #{cask.staged_path.join(path).to_s.shellescape}
           EOS
-        end
-      end
-
-      # Extension module for script installers.
-      module ScriptInstaller
-        def install_phase(command: nil, **_)
+        else
           ohai "Running #{self.class.dsl_key} script '#{path}'"
 
           executable_path = staged_path_join_executable(path)
@@ -38,9 +27,10 @@ def install_phase(command: nil, **_)
           command.run!(
             executable_path,
             **args,
-            env: { "PATH" => PATH.new(
+            env:       { "PATH" => PATH.new(
               HOMEBREW_PREFIX/"bin", HOMEBREW_PREFIX/"sbin", ENV.fetch("PATH")
             ) },
+            reset_uid: true,
           )
         end
       end
@@ -58,45 +48,46 @@ def self.from_args(cask, **args)
           args = { script: args }
         end
 
-        unless args.keys.count == 1
+        if args.keys.count != 1
           raise CaskInvalidError.new(
             cask,
             "invalid 'installer' stanza: Only one of #{VALID_KEYS.inspect} is permitted.",
           )
         end
 
-        args.assert_valid_keys!(*VALID_KEYS)
+        args.assert_valid_keys(*VALID_KEYS)
         new(cask, **args)
       end
 
       attr_reader :path, :args
 
+      sig { returns(T::Boolean) }
+      attr_reader :manual_install
+
       def initialize(cask, **args)
-        super(cask)
+        super
 
         if args.key?(:manual)
           @path = Pathname(args[:manual])
           @args = []
-          extend(ManualInstaller)
-          return
-        end
-
-        path, @args = self.class.read_script_arguments(
-          args[:script], self.class.dsl_key.to_s, { must_succeed: true, sudo: false }, print_stdout: true
-        )
-        raise CaskInvalidError.new(cask, "#{self.class.dsl_key} missing executable") if path.nil?
+          @manual_install = true
+        else
+          path, @args = self.class.read_script_arguments(
+            args[:script], self.class.dsl_key.to_s, { must_succeed: true, sudo: false }, print_stdout: true
+          )
+          raise CaskInvalidError.new(cask, "#{self.class.dsl_key} missing executable") if path.nil?
 
-        @path = Pathname(path)
-        extend(ScriptInstaller)
+          @path = Pathname(path)
+          @manual_install = false
+        end
       end
 
-      def summarize
-        path.to_s
-      end
+      sig { override.returns(String) }
+      def summarize = path.to_s
 
       def to_h
-        { path: path }.tap do |h|
-          h[:args] = args unless is_a?(ManualInstaller)
+        { path: }.tap do |h|
+          h[:args] = args unless manual_install
         end
       end
     end
diff --git a/Library/Homebrew/cask/artifact/internet_plugin.rb b/Library/Homebrew/cask/artifact/internet_plugin.rb
index 73c655a52bc34..a603b14200037 100644
--- a/Library/Homebrew/cask/artifact/internet_plugin.rb
+++ b/Library/Homebrew/cask/artifact/internet_plugin.rb
@@ -6,8 +6,6 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `internet_plugin` stanza.
-    #
-    # @api private
     class InternetPlugin < Moved
     end
   end
diff --git a/Library/Homebrew/cask/artifact/keyboard_layout.rb b/Library/Homebrew/cask/artifact/keyboard_layout.rb
new file mode 100644
index 0000000000000..b1e72ccaaff5c
--- /dev/null
+++ b/Library/Homebrew/cask/artifact/keyboard_layout.rb
@@ -0,0 +1,32 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "cask/artifact/moved"
+
+module Cask
+  module Artifact
+    # Artifact corresponding to the `keyboard_layout` stanza.
+    class KeyboardLayout < Moved
+      def install_phase(**options)
+        super
+        delete_keyboard_layout_cache(**options)
+      end
+
+      def uninstall_phase(**options)
+        super
+        delete_keyboard_layout_cache(**options)
+      end
+
+      private
+
+      def delete_keyboard_layout_cache(command: nil, **_)
+        command.run!(
+          "/bin/rm",
+          args:         ["-f", "--", "/System/Library/Caches/com.apple.IntlDataCache.le*"],
+          sudo:         true,
+          sudo_as_root: true,
+        )
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cask/artifact/manpage.rb b/Library/Homebrew/cask/artifact/manpage.rb
index 2c085154dec1e..170a0904d3b5b 100644
--- a/Library/Homebrew/cask/artifact/manpage.rb
+++ b/Library/Homebrew/cask/artifact/manpage.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/artifact/symlinked"
@@ -6,8 +6,6 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `manpage` stanza.
-    #
-    # @api private
     class Manpage < Symlinked
       attr_reader :section
 
diff --git a/Library/Homebrew/cask/artifact/mdimporter.rb b/Library/Homebrew/cask/artifact/mdimporter.rb
index 5a4ce2d052290..f2774fc971c28 100644
--- a/Library/Homebrew/cask/artifact/mdimporter.rb
+++ b/Library/Homebrew/cask/artifact/mdimporter.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/artifact/moved"
@@ -6,18 +6,14 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `mdimporter` stanza.
-    #
-    # @api private
     class Mdimporter < Moved
-      extend T::Sig
-
       sig { returns(String) }
       def self.english_name
         "Spotlight metadata importer"
       end
 
       def install_phase(**options)
-        super(**options)
+        super
         reload_spotlight(**options)
       end
 
diff --git a/Library/Homebrew/cask/artifact/moved.rb b/Library/Homebrew/cask/artifact/moved.rb
index 6ad4cf61ccd41..ee4a040051249 100644
--- a/Library/Homebrew/cask/artifact/moved.rb
+++ b/Library/Homebrew/cask/artifact/moved.rb
@@ -1,16 +1,13 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/artifact/relocated"
+require "cask/quarantine"
 
 module Cask
   module Artifact
     # Superclass for all artifacts that are installed by moving them to the target location.
-    #
-    # @api private
     class Moved < Relocated
-      extend T::Sig
-
       sig { returns(String) }
       def self.english_description
         "#{english_name}s"
@@ -34,48 +31,127 @@ def summarize_installed
 
       private
 
-      def move(force: false, command: nil, **options)
-        if Utils.path_occupied?(target)
-          message = "It seems there is already #{self.class.english_article} " \
-                    "#{self.class.english_name} at '#{target}'"
-          raise CaskError, "#{message}." unless force
-
-          opoo "#{message}; overwriting."
-          delete(target, force: force, command: command, **options)
-        end
-
+      def move(adopt: false, auto_updates: false, force: false, verbose: false, predecessor: nil, reinstall: false,
+               command: nil, **options)
         unless source.exist?
           raise CaskError, "It seems the #{self.class.english_name} source '#{source}' is not there."
         end
 
-        ohai "Moving #{self.class.english_name} '#{source.basename}' to '#{target}'"
-        if target.dirname.ascend.find(&:directory?).writable?
-          target.dirname.mkpath
-        else
-          command.run!("/bin/mkdir", args: ["-p", target.dirname], sudo: true)
+        if Utils.path_occupied?(target)
+          if target.directory? && target.children.empty? && matching_artifact?(predecessor)
+            # An upgrade removed the directory contents but left the directory itself (see below).
+            unless source.directory?
+              if target.parent.writable? && !force
+                target.rmdir
+              else
+                Utils.gain_permissions_remove(target, command:)
+              end
+            end
+          else
+            if adopt
+              ohai "Adopting existing #{self.class.english_name} at '#{target}'"
+
+              unless auto_updates
+                source_plist = Pathname("#{source}/Contents/Info.plist")
+                target_plist = Pathname("#{target}/Contents/Info.plist")
+                same = if source_plist.size? &&
+                          (source_bundle_version = Homebrew::BundleVersion.from_info_plist(source_plist)) &&
+                          target_plist.size? &&
+                          (target_bundle_version = Homebrew::BundleVersion.from_info_plist(target_plist))
+                  if source_bundle_version.short_version == target_bundle_version.short_version
+                    if source_bundle_version.version == target_bundle_version.version
+                      true
+                    else
+                      onoe "The bundle version of #{source} is #{source_bundle_version.version} but " \
+                           "is #{target_bundle_version.version} for #{target}!"
+                      false
+                    end
+                  else
+                    onoe "The bundle short version of #{source} is #{source_bundle_version.short_version} but " \
+                         "is #{target_bundle_version.short_version} for #{target}!"
+                    false
+                  end
+                else
+                  command.run(
+                    "/usr/bin/diff",
+                    args:         ["--recursive", "--brief", source, target],
+                    verbose:,
+                    print_stdout: verbose,
+                  ).success?
+                end
+
+                unless same
+                  raise CaskError,
+                        "It seems the existing #{self.class.english_name} is different from " \
+                        "the one being installed."
+                end
+              end
+
+              # Remove the source as we don't need to move it to the target location
+              FileUtils.rm_r(source)
+
+              return post_move(command)
+            end
+
+            message = "It seems there is already #{self.class.english_article} " \
+                      "#{self.class.english_name} at '#{target}'"
+            raise CaskError, "#{message}." if !force && !adopt
+
+            opoo "#{message}; overwriting."
+            delete(target, force:, command:, **options)
+          end
         end
 
-        if target.dirname.writable?
+        ohai "Moving #{self.class.english_name} '#{source.basename}' to '#{target}'"
+
+        Utils.gain_permissions_mkpath(target.dirname, command:) unless target.dirname.exist?
+
+        if target.directory? && Quarantine.app_management_permissions_granted?(app: target, command:)
+          if target.writable?
+            source.children.each { |child| FileUtils.move(child, target/child.basename) }
+          else
+            command.run!("/bin/cp", args: ["-pR", *source.children, target],
+                                    sudo: true)
+          end
+          Quarantine.copy_xattrs(source, target, command:)
+          FileUtils.rm_r(source)
+        elsif target.dirname.writable?
           FileUtils.move(source, target)
         else
-          command.run!("/bin/mv", args: [source, target], sudo: true)
+          # default sudo user isn't necessarily able to write to Homebrew's locations
+          # e.g. with runas_default set in the sudoers (5) file.
+          command.run!("/bin/cp", args: ["-pR", source, target], sudo: true)
+          FileUtils.rm_r(source)
         end
 
+        post_move(command)
+      end
+
+      # Performs any actions necessary after the source has been moved to the target location.
+      def post_move(command)
         FileUtils.ln_sf target, source
 
-        add_altname_metadata(target, source.basename, command: command)
+        add_altname_metadata(target, source.basename, command:)
+      end
+
+      def matching_artifact?(cask)
+        return false unless cask
+
+        cask.artifacts.any? do |a|
+          a.instance_of?(self.class) && instance_of?(a.class) && a.target == target
+        end
       end
 
-      def move_back(skip: false, force: false, command: nil, **options)
+      def move_back(skip: false, force: false, adopt: false, command: nil, **options)
         FileUtils.rm source if source.symlink? && source.dirname.join(source.readlink) == target
 
         if Utils.path_occupied?(source)
           message = "It seems there is already #{self.class.english_article} " \
                     "#{self.class.english_name} at '#{source}'"
-          raise CaskError, "#{message}." unless force
+          raise CaskError, "#{message}." if !force && !adopt
 
           opoo "#{message}; overwriting."
-          delete(source, force: force, command: command, **options)
+          delete(source, force:, command:, **options)
         end
 
         unless target.exist?
@@ -88,21 +164,27 @@ def move_back(skip: false, force: false, command: nil, **options)
         source.dirname.mkpath
 
         # We need to preserve extended attributes between copies.
-        command.run!("/bin/cp", args: ["-pR", target, source], sudo: !target.parent.writable?)
+        command.run!("/bin/cp", args: ["-pR", target, source], sudo: !source.parent.writable?)
 
-        delete(target, force: force, command: command, **options)
+        delete(target, force:, command:, **options)
       end
 
-      def delete(target, force: false, command: nil, **_)
+      def delete(target, force: false, successor: nil, command: nil, **_)
         ohai "Removing #{self.class.english_name} '#{target}'"
         raise CaskError, "Cannot remove undeletable #{self.class.english_name}." if MacOS.undeletable?(target)
 
         return unless Utils.path_occupied?(target)
 
-        if target.parent.writable? && !force
-          target.rmtree
+        if target.directory? && matching_artifact?(successor) && Quarantine.app_management_permissions_granted?(
+          app: target, command:,
+        )
+          # If an app folder is deleted, macOS considers the app uninstalled and removes some data.
+          # Remove only the contents to handle this case.
+          target.children.each do |child|
+            Utils.gain_permissions_remove(child, command:)
+          end
         else
-          Utils.gain_permissions_remove(target, command: command)
+          Utils.gain_permissions_remove(target, command:)
         end
       end
     end
diff --git a/Library/Homebrew/cask/artifact/pkg.rb b/Library/Homebrew/cask/artifact/pkg.rb
index dd3a9447bfe70..7c4ce514a60f8 100644
--- a/Library/Homebrew/cask/artifact/pkg.rb
+++ b/Library/Homebrew/cask/artifact/pkg.rb
@@ -1,29 +1,25 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "plist"
 
 require "utils/user"
 require "cask/artifact/abstract_artifact"
-
-require "extend/hash_validator"
-using HashValidator
+require "extend/hash/keys"
 
 module Cask
   module Artifact
     # Artifact corresponding to the `pkg` stanza.
-    #
-    # @api private
     class Pkg < AbstractArtifact
       attr_reader :path, :stanza_options
 
       def self.from_args(cask, path, **stanza_options)
-        stanza_options.assert_valid_keys!(:allow_untrusted, :choices)
+        stanza_options.assert_valid_keys(:allow_untrusted, :choices)
         new(cask, path, **stanza_options)
       end
 
       def initialize(cask, path, **stanza_options)
-        super(cask)
+        super
         @path = cask.staged_path.join(path)
         @stanza_options = stanza_options
       end
@@ -39,8 +35,7 @@ def install_phase(**options)
       private
 
       def run_installer(command: nil, verbose: false, **_options)
-        ohai "Running installer for #{cask}; your password may be necessary.",
-             "Package installers may write to any location; options such as `--appdir` are ignored."
+        ohai "Running installer for #{cask} with sudo; the password may be necessary."
         unless path.exist?
           pkg = path.relative_path_from(cask.staged_path)
           pkgs = Pathname.glob(cask.staged_path/"**"/"*.pkg").map { |path| path.relative_path_from(cask.staged_path) }
@@ -65,7 +60,14 @@ def run_installer(command: nil, verbose: false, **_options)
             "USER"     => User.current,
             "USERNAME" => User.current,
           }
-          command.run!("/usr/sbin/installer", sudo: true, args: args, print_stdout: true, env: env)
+          command.run!(
+            "/usr/sbin/installer",
+            sudo:         true,
+            sudo_as_root: true,
+            args:,
+            print_stdout: true,
+            env:,
+          )
         end
       end
 
diff --git a/Library/Homebrew/cask/artifact/postflight_block.rb b/Library/Homebrew/cask/artifact/postflight_block.rb
index 00d170fda7ce0..fb0e7b5efc2e6 100644
--- a/Library/Homebrew/cask/artifact/postflight_block.rb
+++ b/Library/Homebrew/cask/artifact/postflight_block.rb
@@ -6,8 +6,6 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `postflight` stanza.
-    #
-    # @api private
     class PostflightBlock < AbstractFlightBlock
     end
   end
diff --git a/Library/Homebrew/cask/artifact/preflight_block.rb b/Library/Homebrew/cask/artifact/preflight_block.rb
index 0b7f21c8ecd98..d2845590356e2 100644
--- a/Library/Homebrew/cask/artifact/preflight_block.rb
+++ b/Library/Homebrew/cask/artifact/preflight_block.rb
@@ -6,8 +6,6 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `preflight` stanza.
-    #
-    # @api private
     class PreflightBlock < AbstractFlightBlock
     end
   end
diff --git a/Library/Homebrew/cask/artifact/prefpane.rb b/Library/Homebrew/cask/artifact/prefpane.rb
index a2a1057b34d94..a397234538424 100644
--- a/Library/Homebrew/cask/artifact/prefpane.rb
+++ b/Library/Homebrew/cask/artifact/prefpane.rb
@@ -6,11 +6,7 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `prefpane` stanza.
-    #
-    # @api private
     class Prefpane < Moved
-      extend T::Sig
-
       sig { returns(String) }
       def self.english_name
         "Preference Pane"
diff --git a/Library/Homebrew/cask/artifact/qlplugin.rb b/Library/Homebrew/cask/artifact/qlplugin.rb
index d50956d8ca753..605303c360054 100644
--- a/Library/Homebrew/cask/artifact/qlplugin.rb
+++ b/Library/Homebrew/cask/artifact/qlplugin.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/artifact/moved"
@@ -6,23 +6,19 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `qlplugin` stanza.
-    #
-    # @api private
     class Qlplugin < Moved
-      extend T::Sig
-
       sig { returns(String) }
       def self.english_name
-        "QuickLook Plugin"
+        "Quick Look Plugin"
       end
 
       def install_phase(**options)
-        super(**options)
+        super
         reload_quicklook(**options)
       end
 
       def uninstall_phase(**options)
-        super(**options)
+        super
         reload_quicklook(**options)
       end
 
diff --git a/Library/Homebrew/cask/artifact/relocated.rb b/Library/Homebrew/cask/artifact/relocated.rb
index 612a0c7420e5c..1ff075e8cde34 100644
--- a/Library/Homebrew/cask/artifact/relocated.rb
+++ b/Library/Homebrew/cask/artifact/relocated.rb
@@ -1,26 +1,20 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/artifact/abstract_artifact"
-
-require "extend/hash_validator"
-using HashValidator
+require "extend/hash/keys"
 
 module Cask
   module Artifact
     # Superclass for all artifacts which have a source and a target location.
-    #
-    # @api private
     class Relocated < AbstractArtifact
-      extend T::Sig
-
       def self.from_args(cask, *args)
         source_string, target_hash = args
 
         if target_hash
-          raise CaskInvalidError unless target_hash.respond_to?(:keys)
+          raise CaskInvalidError, cask unless target_hash.respond_to?(:keys)
 
-          target_hash.assert_valid_keys!(:target)
+          target_hash.assert_valid_keys(:target)
         end
 
         target_hash ||= {}
@@ -39,21 +33,28 @@ def resolve_target(target, base_dir: config.public_send(self.class.dirmethod))
         target
       end
 
-      attr_reader :source, :target
-
       sig {
-        params(cask: Cask, source: T.nilable(T.any(String, Pathname)), target: T.nilable(T.any(String, Pathname)))
+        params(cask: Cask, source: T.nilable(T.any(String, Pathname)), target_hash: T.any(String, Pathname))
           .void
       }
-      def initialize(cask, source, target: nil)
-        super(cask)
+      def initialize(cask, source, **target_hash)
+        super
 
+        target = target_hash[:target]
         @source_string = source.to_s
         @target_string = target.to_s
-        source = cask.staged_path.join(source)
-        @source = source
-        target ||= source.basename
-        @target = resolve_target(target)
+      end
+
+      def source
+        @source ||= begin
+          base_path = cask.staged_path
+          base_path = base_path.join(cask.url.only_path) if cask.url&.only_path.present?
+          base_path.join(@source_string)
+        end
+      end
+
+      def target
+        @target ||= resolve_target(@target_string.presence || source.basename)
       end
 
       def to_a
@@ -62,7 +63,7 @@ def to_a
         end
       end
 
-      sig { returns(String) }
+      sig { override.returns(String) }
       def summarize
         target_string = @target_string.empty? ? "" : " -> #{@target_string}"
         "#{@source_string}#{target_string}"
diff --git a/Library/Homebrew/cask/artifact/screen_saver.rb b/Library/Homebrew/cask/artifact/screen_saver.rb
index c52e0361da015..cc9cd6249fdcb 100644
--- a/Library/Homebrew/cask/artifact/screen_saver.rb
+++ b/Library/Homebrew/cask/artifact/screen_saver.rb
@@ -6,8 +6,6 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `screen_saver` stanza.
-    #
-    # @api private
     class ScreenSaver < Moved
     end
   end
diff --git a/Library/Homebrew/cask/artifact/service.rb b/Library/Homebrew/cask/artifact/service.rb
index 901cb5ac07900..032fd78788e54 100644
--- a/Library/Homebrew/cask/artifact/service.rb
+++ b/Library/Homebrew/cask/artifact/service.rb
@@ -6,8 +6,6 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `service` stanza.
-    #
-    # @api private
     class Service < Moved
     end
   end
diff --git a/Library/Homebrew/cask/artifact/stage_only.rb b/Library/Homebrew/cask/artifact/stage_only.rb
index b475b00a860e0..5a1cb6f9d0e70 100644
--- a/Library/Homebrew/cask/artifact/stage_only.rb
+++ b/Library/Homebrew/cask/artifact/stage_only.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/artifact/abstract_artifact"
@@ -6,15 +6,13 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `stage_only` stanza.
-    #
-    # @api private
     class StageOnly < AbstractArtifact
-      extend T::Sig
+      def self.from_args(cask, *args, **kwargs)
+        if (args != [true] && args != ["true"]) || kwargs.present?
+          raise CaskInvalidError.new(cask.token, "'stage_only' takes only a single argument: true")
+        end
 
-      def self.from_args(cask, *args)
-        raise CaskInvalidError.new(cask.token, "'stage_only' takes only a single argument: true") if args != [true]
-
-        new(cask)
+        new(cask, true)
       end
 
       sig { returns(T::Array[T::Boolean]) }
@@ -22,7 +20,7 @@ def to_a
         [true]
       end
 
-      sig { returns(String) }
+      sig { override.returns(String) }
       def summarize
         "true"
       end
diff --git a/Library/Homebrew/cask/artifact/suite.rb b/Library/Homebrew/cask/artifact/suite.rb
index 5eb84626404ec..cc49c85b16058 100644
--- a/Library/Homebrew/cask/artifact/suite.rb
+++ b/Library/Homebrew/cask/artifact/suite.rb
@@ -6,11 +6,7 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `suite` stanza.
-    #
-    # @api private
     class Suite < Moved
-      extend T::Sig
-
       sig { returns(String) }
       def self.english_name
         "App Suite"
diff --git a/Library/Homebrew/cask/artifact/symlinked.rb b/Library/Homebrew/cask/artifact/symlinked.rb
index 653caeed91494..170ecc5367465 100644
--- a/Library/Homebrew/cask/artifact/symlinked.rb
+++ b/Library/Homebrew/cask/artifact/symlinked.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/artifact/relocated"
@@ -6,11 +6,7 @@
 module Cask
   module Artifact
     # Superclass for all artifacts which are installed by symlinking them to the target location.
-    #
-    # @api private
     class Symlinked < Relocated
-      extend T::Sig
-
       sig { returns(String) }
       def self.link_type_english_name
         "Symlink"
@@ -45,7 +41,7 @@ def summarize_installed
 
       private
 
-      def link(force: false, **options)
+      def link(force: false, adopt: false, command: nil, **_options)
         unless source.exist?
           raise CaskError,
                 "It seems the #{self.class.link_type_english_name.downcase} " \
@@ -56,30 +52,33 @@ def link(force: false, **options)
           message = "It seems there is already #{self.class.english_article} " \
                     "#{self.class.english_name} at '#{target}'"
 
-          if force && target.symlink? && \
+          if (force || adopt) && target.symlink? &&
              (target.realpath == source.realpath || target.realpath.to_s.start_with?("#{cask.caskroom_path}/"))
             opoo "#{message}; overwriting."
-            target.delete
+            Utils.gain_permissions_remove(target, command:)
           else
             raise CaskError, "#{message}."
           end
         end
 
         ohai "Linking #{self.class.english_name} '#{source.basename}' to '#{target}'"
-        create_filesystem_link(**options)
+        create_filesystem_link(command:)
       end
 
-      def unlink(**)
+      def unlink(command: nil, **)
         return unless target.symlink?
 
         ohai "Unlinking #{self.class.english_name} '#{target}'"
-        target.delete
+        Utils.gain_permissions_remove(target, command:)
       end
 
-      def create_filesystem_link(command: nil, **_)
-        target.dirname.mkpath
-        command.run!("/bin/ln", args: ["-h", "-f", "-s", "--", source, target])
-        add_altname_metadata(source, target.basename, command: command)
+      def create_filesystem_link(command: nil)
+        Utils.gain_permissions_mkpath(target.dirname, command:)
+
+        command.run! "/bin/ln", args: ["-h", "-f", "-s", "--", source, target],
+                                sudo: !target.dirname.writable?
+
+        add_altname_metadata(source, target.basename, command:)
       end
     end
   end
diff --git a/Library/Homebrew/cask/artifact/uninstall.rb b/Library/Homebrew/cask/artifact/uninstall.rb
index a91efd2fa88b7..e136b05b8fbbc 100644
--- a/Library/Homebrew/cask/artifact/uninstall.rb
+++ b/Library/Homebrew/cask/artifact/uninstall.rb
@@ -1,19 +1,26 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/artifact/abstract_uninstall"
 
+UPGRADE_REINSTALL_SKIP_DIRECTIVES = [:quit, :signal].freeze
+
 module Cask
   module Artifact
     # Artifact corresponding to the `uninstall` stanza.
-    #
-    # @api private
     class Uninstall < AbstractUninstall
-      def uninstall_phase(**options)
-        ORDERED_DIRECTIVES.reject { |directive_sym| directive_sym == :rmdir }
-                          .each do |directive_sym|
-                            dispatch_uninstall_directive(directive_sym, **options)
-                          end
+      def uninstall_phase(upgrade: false, reinstall: false, **options)
+        filtered_directives = ORDERED_DIRECTIVES.filter do |directive_sym|
+          next false if directive_sym == :rmdir
+
+          next false if (upgrade || reinstall) && UPGRADE_REINSTALL_SKIP_DIRECTIVES.include?(directive_sym)
+
+          true
+        end
+
+        filtered_directives.each do |directive_sym|
+          dispatch_uninstall_directive(directive_sym, **options)
+        end
       end
 
       def post_uninstall_phase(**options)
diff --git a/Library/Homebrew/cask/artifact/vst3_plugin.rb b/Library/Homebrew/cask/artifact/vst3_plugin.rb
index bd69c57a41fa8..f59701de59e0d 100644
--- a/Library/Homebrew/cask/artifact/vst3_plugin.rb
+++ b/Library/Homebrew/cask/artifact/vst3_plugin.rb
@@ -6,9 +6,11 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `vst3_plugin` stanza.
-    #
-    # @api private
     class Vst3Plugin < Moved
+      sig { returns(String) }
+      def self.english_name
+        "VST3 Plugin"
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cask/artifact/vst_plugin.rb b/Library/Homebrew/cask/artifact/vst_plugin.rb
index 976ae18d68fa5..cd330cc840fd1 100644
--- a/Library/Homebrew/cask/artifact/vst_plugin.rb
+++ b/Library/Homebrew/cask/artifact/vst_plugin.rb
@@ -6,9 +6,11 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `vst_plugin` stanza.
-    #
-    # @api private
     class VstPlugin < Moved
+      sig { returns(String) }
+      def self.english_name
+        "VST Plugin"
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cask/artifact/zap.rb b/Library/Homebrew/cask/artifact/zap.rb
index eadc014618ea6..0da02e19854c6 100644
--- a/Library/Homebrew/cask/artifact/zap.rb
+++ b/Library/Homebrew/cask/artifact/zap.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/artifact/abstract_uninstall"
@@ -6,8 +6,6 @@
 module Cask
   module Artifact
     # Artifact corresponding to the `zap` stanza.
-    #
-    # @api private
     class Zap < AbstractUninstall
       def zap_phase(**options)
         dispatch_uninstall_directives(**options)
diff --git a/Library/Homebrew/cask/artifact_set.rb b/Library/Homebrew/cask/artifact_set.rb
new file mode 100644
index 0000000000000..517debcd25968
--- /dev/null
+++ b/Library/Homebrew/cask/artifact_set.rb
@@ -0,0 +1,18 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module Cask
+  # Sorted set containing all cask artifacts.
+  class ArtifactSet < ::Set
+    def each(&block)
+      return enum_for(T.must(__method__)) { size } unless block
+
+      to_a.each(&block)
+      self
+    end
+
+    def to_a
+      super.sort
+    end
+  end
+end
diff --git a/Library/Homebrew/cask/audit.rb b/Library/Homebrew/cask/audit.rb
index 91bcf2d3ec749..0bc9292a80d39 100644
--- a/Library/Homebrew/cask/audit.rb
+++ b/Library/Homebrew/cask/audit.rb
@@ -1,89 +1,75 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "attrable"
 require "cask/denylist"
 require "cask/download"
 require "digest"
 require "livecheck/livecheck"
+require "source_location"
+require "system_command"
+require "utils/backtrace"
+require "formula_name_cask_token_auditor"
 require "utils/curl"
 require "utils/git"
 require "utils/shared_audits"
 
 module Cask
   # Audit a cask for various problems.
-  #
-  # @api private
   class Audit
-    extend T::Sig
+    include SystemCommand::Mixin
+    include ::Utils::Curl
+    extend Attrable
 
-    extend Predicable
+    sig { returns(Cask) }
+    attr_reader :cask
 
-    attr_reader :cask, :download
+    sig { returns(T.nilable(Download)) }
+    attr_reader :download
 
-    attr_predicate :appcast?, :new_cask?, :strict?, :online?, :token_conflicts?
+    attr_predicate :new_cask?, :strict?, :signing?, :online?, :token_conflicts?
 
-    def initialize(cask, appcast: nil, download: nil, quarantine: nil,
-                   token_conflicts: nil, online: nil, strict: nil,
-                   new_cask: nil)
-
-      # `new_cask` implies `online` and `strict`
+    def initialize(
+      cask,
+      download: nil, quarantine: nil,
+      token_conflicts: nil, online: nil, strict: nil, signing: nil,
+      new_cask: nil, only: [], except: []
+    )
+      # `new_cask` implies `online`, `token_conflicts`, `strict` and `signing`
       online = new_cask if online.nil?
       strict = new_cask if strict.nil?
-
-      # `online` implies `appcast` and `download`
-      appcast = online if appcast.nil?
-      download = online if download.nil?
-
-      # `new_cask` implies `token_conflicts`
+      signing = new_cask if signing.nil?
       token_conflicts = new_cask if token_conflicts.nil?
 
+      # `online` and `signing` imply `download`
+      download = online || signing if download.nil?
+
       @cask = cask
-      @appcast = appcast
-      @download = Download.new(cask, quarantine: quarantine) if download
+      @download = Download.new(cask, quarantine:) if download
       @online = online
       @strict = strict
+      @signing = signing
       @new_cask = new_cask
       @token_conflicts = token_conflicts
+      @only = only || []
+      @except = except || []
     end
 
     def run!
-      check_denylist
-      check_reverse_migration
-      check_required_stanzas
-      check_version
-      check_sha256
-      check_desc
-      check_url
-      check_unnecessary_verified
-      check_missing_verified
-      check_no_match
-      check_generic_artifacts
-      check_token_valid
-      check_token_bad_words
-      check_token_conflicts
-      check_languages
-      check_download
-      check_https_availability
-      check_single_pre_postflight
-      check_single_uninstall_zap
-      check_untrusted_pkg
-      livecheck_result = check_livecheck_version
-      check_hosting_with_livecheck(livecheck_result: livecheck_result)
-      check_appcast_and_livecheck
-      check_latest_with_appcast_or_livecheck
-      check_latest_with_auto_updates
-      check_stanza_requires_uninstall
-      check_appcast_contains_version
-      check_gitlab_repository
-      check_gitlab_repository_archived
-      check_gitlab_prerelease_version
-      check_github_repository
-      check_github_repository_archived
-      check_github_prerelease_version
-      check_bitbucket_repository
+      only_audits = @only
+      except_audits = @except
+
+      private_methods.map(&:to_s).grep(/^audit_/).each do |audit_method_name|
+        name = audit_method_name.delete_prefix("audit_")
+        next if !only_audits.empty? && only_audits&.exclude?(name)
+        next if except_audits&.include?(name)
+
+        send(audit_method_name)
+      end
+
       self
     rescue => e
-      odebug e, e.backtrace
+      odebug e, ::Utils::Backtrace.clean(e)
       add_error "exception while auditing #{cask}: #{e.message}"
       self
     end
@@ -92,44 +78,37 @@ def errors
       @errors ||= []
     end
 
-    def warnings
-      @warnings ||= []
-    end
-
-    def add_error(message, location: nil)
-      errors << ({ message: message, location: location })
+    sig { returns(T::Boolean) }
+    def errors?
+      errors.any?
     end
 
-    def add_warning(message, location: nil)
-      if strict?
-        add_error message, location: location
-      else
-        warnings << ({ message: message, location: location })
-      end
+    sig { returns(T::Boolean) }
+    def success?
+      !errors?
     end
 
-    def errors?
-      errors.any?
-    end
+    sig {
+      params(
+        message:     T.nilable(String),
+        location:    T.nilable(Homebrew::SourceLocation),
+        strict_only: T::Boolean,
+      ).void
+    }
+    def add_error(message, location: nil, strict_only: false)
+      # Only raise non-critical audits if the user specified `--strict`.
+      return if strict_only && !@strict
 
-    def warnings?
-      warnings.any?
+      errors << ({ message:, location:, corrected: false })
     end
 
     def result
-      if errors?
-        Formatter.error("failed")
-      elsif warnings?
-        Formatter.warning("warning")
-      else
-        Formatter.success("passed")
-      end
+      Formatter.error("failed") if errors?
     end
 
-    sig { params(include_passed: T::Boolean, include_warnings: T::Boolean).returns(String) }
-    def summary(include_passed: false, include_warnings: true)
-      return if success? && !include_passed
-      return if warnings? && !errors? && !include_warnings
+    sig { returns(T.nilable(String)) }
+    def summary
+      return if success?
 
       summary = ["audit for #{cask}: #{result}"]
 
@@ -137,22 +116,13 @@ def summary(include_passed: false, include_warnings: true)
         summary << " #{Formatter.error("-")} #{error[:message]}"
       end
 
-      if include_warnings
-        warnings.each do |warning|
-          summary << " #{Formatter.warning("-")} #{warning[:message]}"
-        end
-      end
-
       summary.join("\n")
     end
 
-    def success?
-      !(errors? || warnings?)
-    end
-
     private
 
-    def check_untrusted_pkg
+    sig { void }
+    def audit_untrusted_pkg
       odebug "Auditing pkg stanza: allow_untrusted"
 
       return if @cask.sourcefile_path.nil?
@@ -166,7 +136,8 @@ def check_untrusted_pkg
       add_error "allow_untrusted is not permitted in official Homebrew Cask taps"
     end
 
-    def check_stanza_requires_uninstall
+    sig { void }
+    def audit_stanza_requires_uninstall
       odebug "Auditing stanzas which require an uninstall"
 
       return if cask.artifacts.none? { |k| k.is_a?(Artifact::Pkg) || k.is_a?(Artifact::Installer) }
@@ -175,7 +146,8 @@ def check_stanza_requires_uninstall
       add_error "installer and pkg stanzas require an uninstall stanza"
     end
 
-    def check_single_pre_postflight
+    sig { void }
+    def audit_single_pre_postflight
       odebug "Auditing preflight and postflight stanzas"
 
       if cask.artifacts.count { |k| k.is_a?(Artifact::PreflightBlock) && k.directives.key?(:preflight) } > 1
@@ -186,18 +158,15 @@ def check_single_pre_postflight
         k.is_a?(Artifact::PostflightBlock) &&
           k.directives.key?(:postflight)
       end
-      return unless count > 1
+      return if count <= 1
 
       add_error "only a single postflight stanza is allowed"
     end
 
-    def check_single_uninstall_zap
+    sig { void }
+    def audit_single_uninstall_zap
       odebug "Auditing single uninstall_* and zap stanzas"
 
-      if cask.artifacts.count { |k| k.is_a?(Artifact::Uninstall) } > 1
-        add_error "only a single uninstall stanza is allowed"
-      end
-
       count = cask.artifacts.count do |k|
         k.is_a?(Artifact::PreflightBlock) &&
           k.directives.key?(:uninstall_preflight)
@@ -212,12 +181,13 @@ def check_single_uninstall_zap
 
       add_error "only a single uninstall_postflight stanza is allowed" if count > 1
 
-      return unless cask.artifacts.count { |k| k.is_a?(Artifact::Zap) } > 1
+      return if cask.artifacts.count { |k| k.is_a?(Artifact::Zap) } <= 1
 
       add_error "only a single zap stanza is allowed"
     end
 
-    def check_required_stanzas
+    sig { void }
+    def audit_required_stanzas
       odebug "Auditing required stanzas"
       [:version, :sha256, :url, :homepage].each do |sym|
         add_error "a #{sym} stanza is required" unless cask.send(sym)
@@ -229,77 +199,93 @@ def check_required_stanzas
       add_error "at least one activatable artifact stanza is required" if installable_artifacts.empty?
     end
 
-    def check_version
+    sig { void }
+    def audit_description
+      # Fonts seldom benefit from descriptions and requiring them disproportionately
+      # increases the maintenance burden.
+      return if cask.tap == "homebrew/cask" && cask.token.include?("font-")
+
+      add_error("Cask should have a description. Please add a `desc` stanza.", strict_only: true) if cask.desc.blank?
+    end
+
+    sig { void }
+    def audit_version_special_characters
       return unless cask.version
 
-      check_no_string_version_latest
+      return if cask.version.latest?
+
+      raw_version = cask.version.raw_version
+      return if raw_version.exclude?(":") && raw_version.exclude?("/")
+
+      add_error "version should not contain colons or slashes"
     end
 
-    def check_no_string_version_latest
-      odebug "Verifying version :latest does not appear as a string ('latest')"
-      return unless cask.version.raw_version == "latest"
+    sig { void }
+    def audit_no_string_version_latest
+      return unless cask.version
+
+      odebug "Auditing version :latest does not appear as a string ('latest')"
+      return if cask.version.raw_version != "latest"
 
       add_error "you should use version :latest instead of version 'latest'"
     end
 
-    def check_sha256
+    sig { void }
+    def audit_sha256_no_check_if_latest
       return unless cask.sha256
+      return unless cask.version
 
-      check_sha256_no_check_if_latest
-      check_sha256_no_check_if_unversioned
-      check_sha256_actually_256
-      check_sha256_invalid
-    end
-
-    def check_sha256_no_check_if_latest
-      odebug "Verifying sha256 :no_check with version :latest"
+      odebug "Auditing sha256 :no_check with version :latest"
       return unless cask.version.latest?
       return if cask.sha256 == :no_check
 
       add_error "you should use sha256 :no_check when version is :latest"
     end
 
-    def check_sha256_no_check_if_unversioned
+    sig { void }
+    def audit_sha256_no_check_if_unversioned
+      return unless cask.sha256
       return if cask.sha256 == :no_check
 
-      add_error "Use `sha256 :no_check` when URL is unversioned." if cask.url&.unversioned?
+      return unless cask.url&.unversioned?
+
+      add_error "Use `sha256 :no_check` when URL is unversioned."
     end
 
-    def check_sha256_actually_256
-      odebug "Verifying sha256 string is a legal SHA-256 digest"
+    sig { void }
+    def audit_sha256_actually_256
+      return unless cask.sha256
+
+      odebug "Auditing sha256 string is a legal SHA-256 digest"
       return unless cask.sha256.is_a?(Checksum)
       return if cask.sha256.length == 64 && cask.sha256[/^[0-9a-f]+$/i]
 
       add_error "sha256 string must be of 64 hexadecimal characters"
     end
 
-    def check_sha256_invalid
-      odebug "Verifying sha256 is not a known invalid value"
+    sig { void }
+    def audit_sha256_invalid
+      return unless cask.sha256
+
+      odebug "Auditing sha256 is not a known invalid value"
       empty_sha256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
-      return unless cask.sha256 == empty_sha256
+      return if cask.sha256 != empty_sha256
 
       add_error "cannot use the sha256 for an empty string: #{empty_sha256}"
     end
 
-    def check_appcast_and_livecheck
-      return unless cask.appcast
-
-      if cask.livecheckable?
-        add_error "Cask has a `livecheck`, the `appcast` should be removed."
-      elsif new_cask?
-        add_error "New casks should use a `livecheck` instead of an `appcast`."
-      end
-    end
-
-    def check_latest_with_appcast_or_livecheck
-      return unless cask.version.latest?
+    sig { void }
+    def audit_latest_with_livecheck
+      return unless cask.version&.latest?
+      return unless cask.livecheckable?
+      return if cask.livecheck.skip?
 
-      add_error "Casks with an `appcast` should not use `version :latest`." if cask.appcast
-      add_error "Casks with a `livecheck` should not use `version :latest`." if cask.livecheckable?
+      add_error "Casks with a `livecheck` should not use `version :latest`."
     end
 
-    def check_latest_with_auto_updates
-      return unless cask.version.latest?
+    sig { void }
+    def audit_latest_with_auto_updates
+      return unless cask.version&.latest?
       return unless cask.auto_updates
 
       add_error "Casks with `version :latest` should not use `auto_updates`."
@@ -307,128 +293,56 @@ def check_latest_with_auto_updates
 
     LIVECHECK_REFERENCE_URL = "https://docs.brew.sh/Cask-Cookbook#stanza-livecheck"
 
-    def check_hosting_with_livecheck(livecheck_result:)
-      return if cask.discontinued? || cask.version.latest?
-      return if block_url_offline? || cask.appcast || cask.livecheckable?
+    sig { params(livecheck_result: T.any(NilClass, T::Boolean, Symbol)).void }
+    def audit_hosting_with_livecheck(livecheck_result: audit_livecheck_version)
+      return if cask.deprecated? || cask.disabled?
+      return if cask.version&.latest?
+      return if (url = cask.url).nil?
+      return if block_url_offline?
+      return if cask.livecheckable?
       return if livecheck_result == :auto_detected
 
       add_livecheck = "please add a livecheck. See #{Formatter.url(LIVECHECK_REFERENCE_URL)}"
 
-      case cask.url.to_s
+      case url.to_s
       when %r{sourceforge.net/(\S+)}
         return unless online?
 
-        add_error "Download is hosted on SourceForge, #{add_livecheck}"
+        add_error "Download is hosted on SourceForge, #{add_livecheck}", location: url.location
       when %r{dl.devmate.com/(\S+)}
-        add_error "Download is hosted on DevMate, #{add_livecheck}"
+        add_error "Download is hosted on DevMate, #{add_livecheck}", location: url.location
       when %r{rink.hockeyapp.net/(\S+)}
-        add_error "Download is hosted on HockeyApp, #{add_livecheck}"
+        add_error "Download is hosted on HockeyApp, #{add_livecheck}", location: url.location
       end
     end
 
-    def check_desc
-      return if cask.desc.present?
-
-      # Fonts seldom benefit from descriptions and requiring them disproportionately increases the maintenance burden
-      return if cask.tap == "homebrew/cask-fonts"
-
-      add_warning "Cask should have a description. Please add a `desc` stanza."
-    end
-
-    def check_url
-      return unless cask.url
-
-      check_download_url_format
-    end
-
     SOURCEFORGE_OSDN_REFERENCE_URL = "https://docs.brew.sh/Cask-Cookbook#sourceforgeosdn-urls"
 
-    def check_download_url_format
-      odebug "Auditing URL format"
-      if bad_sourceforge_url?
-        add_error "SourceForge URL format incorrect. See #{Formatter.url(SOURCEFORGE_OSDN_REFERENCE_URL)}"
-      elsif bad_osdn_url?
-        add_error "OSDN URL format incorrect. See #{Formatter.url(SOURCEFORGE_OSDN_REFERENCE_URL)}"
-      end
-    end
-
-    def bad_url_format?(regex, valid_formats_array)
-      return false unless cask.url.to_s.match?(regex)
-
-      valid_formats_array.none? { |format| cask.url.to_s =~ format }
-    end
-
-    def bad_sourceforge_url?
-      bad_url_format?(/sourceforge/,
-                      [
-                        %r{\Ahttps://sourceforge\.net/projects/[^/]+/files/latest/download\Z},
-                        %r{\Ahttps://downloads\.sourceforge\.net/(?!(project|sourceforge)/)},
-                      ])
-    end
-
-    def bad_osdn_url?
-      bad_url_format?(/osd/, [%r{\Ahttps?://([^/]+.)?dl\.osdn\.jp/}])
-    end
-
-    def homepage
-      URI(cask.homepage.to_s).host
-    end
-
-    def domain
-      URI(cask.url.to_s).host
-    end
-
-    def url_match_homepage?
-      host = cask.url.to_s
-      host_uri = URI(host)
-      host = if host.match?(/:\d/) && host_uri.port != 80
-        "#{host_uri.host}:#{host_uri.port}"
-      else
-        host_uri.host
-      end
-      home = homepage.downcase
-      if (split_host = host.split(".")).length >= 3
-        host = split_host[-2..].join(".")
-      end
-      if (split_home = homepage.split(".")).length >= 3
-        home = split_home[-2..].join(".")
-      end
-      host == home
-    end
-
-    def strip_url_scheme(url)
-      url.sub(%r{^[^:/]+://(www\.)?}, "")
-    end
-
-    def url_from_verified
-      strip_url_scheme(cask.url.verified)
-    end
-
-    def verified_matches_url?
-      url_domain, url_path = strip_url_scheme(cask.url.to_s).split("/", 2)
-      verified_domain, verified_path = url_from_verified.split("/", 2)
-
-      (url_domain == verified_domain || (verified_domain && url_domain&.end_with?(".#{verified_domain}"))) &&
-        (!verified_path || url_path&.start_with?(verified_path))
-    end
+    sig { void }
+    def audit_download_url_format
+      return if (url = cask.url).nil?
+      return if block_url_offline?
 
-    def verified_present?
-      cask.url.verified.present?
-    end
+      odebug "Auditing URL format"
+      return unless bad_sourceforge_url?
 
-    def file_url?
-      URI(cask.url.to_s).scheme == "file"
+      add_error "SourceForge URL format incorrect. See #{Formatter.url(SOURCEFORGE_OSDN_REFERENCE_URL)}",
+                location: url.location
     end
 
-    def block_url_offline?
-      return false if online?
+    def audit_download_url_is_osdn
+      return if (url = cask.url).nil?
+      return if block_url_offline?
+      return unless bad_osdn_url?
 
-      cask.url.from_block?
+      add_error "OSDN download urls are disabled.", location: url.location, strict_only: true
     end
 
     VERIFIED_URL_REFERENCE_URL = "https://docs.brew.sh/Cask-Cookbook#when-url-and-homepage-domains-differ-add-verified"
 
-    def check_unnecessary_verified
+    sig { void }
+    def audit_unnecessary_verified
+      return unless cask.url
       return if block_url_offline?
       return unless verified_present?
       return unless url_match_homepage?
@@ -439,7 +353,9 @@ def check_unnecessary_verified
                 "See #{Formatter.url(VERIFIED_URL_REFERENCE_URL)}"
     end
 
-    def check_missing_verified
+    sig { void }
+    def audit_missing_verified
+      return unless cask.url
       return if block_url_offline?
       return if file_url?
       return if url_match_homepage?
@@ -450,17 +366,21 @@ def check_missing_verified
                 "See #{Formatter.url(VERIFIED_URL_REFERENCE_URL)}"
     end
 
-    def check_no_match
+    sig { void }
+    def audit_no_match
+      return if (url = cask.url).nil?
       return if block_url_offline?
       return unless verified_present?
       return if verified_matches_url?
 
       add_error "Verified URL #{Formatter.url(url_from_verified)} does not match URL " \
-                "#{Formatter.url(strip_url_scheme(cask.url.to_s))}. " \
-                "See #{Formatter.url(VERIFIED_URL_REFERENCE_URL)}"
+                "#{Formatter.url(strip_url_scheme(url.to_s))}. " \
+                "See #{Formatter.url(VERIFIED_URL_REFERENCE_URL)}",
+                location: url.location
     end
 
-    def check_generic_artifacts
+    sig { void }
+    def audit_generic_artifacts
       cask.artifacts.select { |a| a.is_a?(Artifact::Artifact) }.each do |artifact|
         unless artifact.target.absolute?
           add_error "target must be absolute path for #{artifact.class.english_name} #{artifact.source}"
@@ -468,7 +388,8 @@ def check_generic_artifacts
       end
     end
 
-    def check_languages
+    sig { void }
+    def audit_languages
       @cask.languages.each do |language|
         Locale.parse(language)
       rescue Locale::ParserError
@@ -476,82 +397,230 @@ def check_languages
       end
     end
 
-    def check_token_conflicts
-      return unless token_conflicts?
-      return unless core_formula_names.include?(cask.token)
+    sig { void }
+    def audit_token
+      token_auditor = Homebrew::FormulaNameCaskTokenAuditor.new(cask.token)
+      return if (errors = token_auditor.errors).none?
 
-      add_warning "possible duplicate, cask token conflicts with Homebrew core formula: " \
-                  "#{Formatter.url(core_formula_url)}"
+      add_error "Cask token '#{cask.token}' must not contain #{errors.to_sentence(two_words_connector: " or ",
+                                                                                  last_word_connector: " or ")}."
     end
 
-    def check_token_valid
-      add_error "cask token contains non-ascii characters" unless cask.token.ascii_only?
-      add_error "cask token + should be replaced by -plus-" if cask.token.include? "+"
-      add_error "cask token whitespace should be replaced by hyphens" if cask.token.include? " "
-      add_error "cask token @ should be replaced by -at-" if cask.token.include? "@"
-      add_error "cask token underscores should be replaced by hyphens" if cask.token.include? "_"
-      add_error "cask token should not contain double hyphens" if cask.token.include? "--"
-
-      if cask.token.match?(/[^a-z0-9\-]/)
-        add_error "cask token should only contain lowercase alphanumeric characters and hyphens"
-      end
+    sig { void }
+    def audit_token_conflicts
+      return unless token_conflicts?
 
-      return if !cask.token.start_with?("-") && !cask.token.end_with?("-")
+      Homebrew.with_no_api_env do
+        return unless core_formula_names.include?(cask.token)
 
-      add_error "cask token should not have leading or trailing hyphens"
+        add_error(
+          "possible duplicate, cask token conflicts with Homebrew core formula: #{Formatter.url(core_formula_url)}",
+          strict_only: true,
+        )
+      end
     end
 
-    def check_token_bad_words
+    sig { void }
+    def audit_token_bad_words
       return unless new_cask?
 
       token = cask.token
 
       add_error "cask token contains .app" if token.end_with? ".app"
 
-      if /-(?<designation>alpha|beta|rc|release-candidate)$/ =~ cask.token &&
-         cask.tap&.official? &&
-         cask.tap != "homebrew/cask-versions"
-        add_error "cask token contains version designation '#{designation}'"
+      match_data = /-(?<designation>alpha|beta|rc|release-candidate)$/.match(cask.token)
+      if match_data && cask.tap&.official?
+        add_error "cask token contains version designation '#{match_data[:designation]}'"
       end
 
-      add_warning "cask token mentions launcher" if token.end_with? "launcher"
+      add_error("cask token mentions launcher", strict_only: true) if token.end_with? "launcher"
 
-      add_warning "cask token mentions desktop" if token.end_with? "desktop"
+      add_error("cask token mentions desktop", strict_only: true) if token.end_with? "desktop"
 
-      add_warning "cask token mentions platform" if token.end_with? "mac", "osx", "macos"
+      add_error("cask token mentions platform", strict_only: true) if token.end_with? "mac", "osx", "macos"
 
-      add_warning "cask token mentions architecture" if token.end_with? "x86", "32_bit", "x86_64", "64_bit"
+      add_error("cask token mentions architecture", strict_only: true) if token.end_with? "x86", "32_bit", "x86_64",
+                                                                                          "64_bit"
 
       frameworks = %w[cocoa qt gtk wx java]
       return if frameworks.include?(token) || !token.end_with?(*frameworks)
 
-      add_warning "cask token mentions framework"
+      add_error("cask token mentions framework", strict_only: true)
     end
 
-    def core_tap
-      @core_tap ||= CoreTap.instance
+    sig { void }
+    def audit_download
+      return if (download = self.download).blank? || (url = cask.url).nil?
+
+      begin
+        download.fetch
+      rescue => e
+        add_error "download not possible: #{e}", location: url.location
+      end
     end
 
-    def core_formula_names
-      core_tap.formula_names
+    sig { void }
+    def audit_livecheck_unneeded_long_version
+      return if cask.version.nil? || (url = cask.url).nil?
+      return if cask.livecheck.strategy != :sparkle
+      return unless cask.version.csv.second
+      return if cask.url.to_s.include? cask.version.csv.second
+      return if cask.version.csv.third.present? && cask.url.to_s.include?(cask.version.csv.third)
+
+      add_error "Download does not require additional version components. Use `&:short_version` in the livecheck",
+                location:    url.location,
+                strict_only: true
     end
 
-    sig { returns(String) }
-    def core_formula_url
-      "#{core_tap.default_remote}/blob/HEAD/Formula/#{cask.token}.rb"
+    sig { void }
+    def audit_signing
+      return if !signing? || download.blank? || (url = cask.url).nil?
+
+      odebug "Auditing signing"
+
+      extract_artifacts do |artifacts, tmpdir|
+        is_container = artifacts.any? { |a| a.is_a?(Artifact::App) || a.is_a?(Artifact::Pkg) }
+
+        artifacts.each do |artifact|
+          next if artifact.is_a?(Artifact::Binary) && is_container == true
+
+          artifact_path = artifact.is_a?(Artifact::Pkg) ? artifact.path : artifact.source
+
+          path = tmpdir/artifact_path.relative_path_from(cask.staged_path)
+
+          result = case artifact
+          when Artifact::Pkg
+            system_command("spctl", args: ["--assess", "--type", "install", path], print_stderr: false)
+          when Artifact::App
+            system_command("spctl", args: ["--assess", "--type", "execute", path], print_stderr: false)
+          when Artifact::Binary
+            system_command("codesign",  args: ["--verify", path], print_stderr: false)
+          else
+            add_error "Unknown artifact type: #{artifact.class}", location: url.location
+          end
+
+          next if result.success?
+
+          add_error <<~EOS, location: url.location, strict_only: true
+            Signature verification failed:
+            #{result.merged_output}
+            macOS on ARM requires software to be signed.
+            Please contact the upstream developer to let them know they should sign and notarize their software.
+          EOS
+        end
+      end
     end
 
-    def check_download
-      return if download.blank? || cask.url.blank?
+    sig { void }
+    def extract_artifacts
+      return unless online?
+      return if (download = self.download).nil?
 
-      odebug "Auditing download"
-      download.fetch
-    rescue => e
-      add_error "download not possible: #{e}"
+      artifacts = cask.artifacts.select do |artifact|
+        artifact.is_a?(Artifact::Pkg) || artifact.is_a?(Artifact::App) || artifact.is_a?(Artifact::Binary)
+      end
+
+      if @artifacts_extracted && @tmpdir
+        yield artifacts, @tmpdir if block_given?
+        return
+      end
+
+      return if artifacts.empty?
+
+      @tmpdir ||= Pathname(Dir.mktmpdir("cask-audit", HOMEBREW_TEMP))
+
+      # Clean up tmp dir when @tmpdir object is destroyed
+      ObjectSpace.define_finalizer(
+        @tmpdir,
+        proc { FileUtils.remove_entry(@tmpdir) },
+      )
+
+      ohai "Downloading and extracting artifacts"
+
+      downloaded_path = download.fetch
+
+      primary_container = UnpackStrategy.detect(downloaded_path, type: @cask.container&.type, merge_xattrs: true)
+      return if primary_container.nil?
+
+      # Extract the container to the temporary directory.
+      primary_container.extract_nestedly(to: @tmpdir, basename: downloaded_path.basename, verbose: false)
+
+      if (nested_container = @cask.container&.nested)
+        FileUtils.chmod_R "+rw", @tmpdir/nested_container, force: true, verbose: false
+        UnpackStrategy.detect(@tmpdir/nested_container, merge_xattrs: true)
+                      .extract_nestedly(to: @tmpdir, verbose: false)
+      end
+
+      @artifacts_extracted = true # Set the flag to indicate that extraction has occurred.
+
+      # Yield the artifacts and temp directory to the block if provided.
+      yield artifacts, @tmpdir if block_given?
     end
 
-    def check_livecheck_version
-      return unless appcast?
+    sig { void }
+    def audit_rosetta
+      return if (url = cask.url).nil?
+      return unless online?
+      return if Homebrew::SimulateSystem.current_arch != :arm
+
+      odebug "Auditing Rosetta 2 requirement"
+
+      extract_artifacts do |artifacts, tmpdir|
+        is_container = artifacts.any? { |a| a.is_a?(Artifact::App) || a.is_a?(Artifact::Pkg) }
+
+        artifacts.filter { |a| a.is_a?(Artifact::App) || a.is_a?(Artifact::Binary) }
+                 .each do |artifact|
+          next if artifact.is_a?(Artifact::Binary) && is_container
+
+          path = tmpdir/artifact.source.relative_path_from(cask.staged_path)
+
+          result = case artifact
+          when Artifact::App
+            files = Dir[path/"Contents/MacOS/*"].select do |f|
+              File.executable?(f) && !File.directory?(f) && !f.end_with?(".dylib")
+            end
+            add_error "No binaries in App: #{artifact.source}", location: url.location if files.empty?
+
+            main_binary = get_plist_main_binary(path)
+            main_binary ||= files.first
+
+            system_command("lipo", args: ["-archs", main_binary], print_stderr: false)
+          when Artifact::Binary
+            binary_path = path.to_s.gsub(cask.appdir, tmpdir)
+            system_command("lipo", args: ["-archs", binary_path], print_stderr: true)
+          else
+            add_error "Unknown artifact type: #{artifact.class}", location: url.location
+          end
+
+          # binary stanza can contain shell scripts, so we just continue if lipo fails.
+          next unless result.success?
+
+          odebug result.merged_output
+
+          unless /arm64|x86_64/.match?(result.merged_output)
+            add_error "Artifacts architecture is no longer supported by macOS!",
+                      location: url.location
+            next
+          end
+
+          supports_arm = result.merged_output.include?("arm64")
+          mentions_rosetta = cask.caveats.include?("requires Rosetta 2")
+
+          if supports_arm && mentions_rosetta
+            add_error "Artifacts does not require Rosetta 2 but the caveats say otherwise!",
+                      location: url.location
+          elsif !supports_arm && !mentions_rosetta
+            add_error "Artifacts require Rosetta 2 but this is not indicated by the caveats!",
+                      location: url.location
+          end
+        end
+      end
+    end
+
+    sig { returns(T.any(NilClass, T::Boolean, Symbol)) }
+    def audit_livecheck_version
+      return unless online?
+      return unless cask.version
 
       referenced_cask, = Homebrew::Livecheck.resolve_livecheck_reference(cask)
 
@@ -559,11 +628,11 @@ def check_livecheck_version
       if referenced_cask
         skip_info = Homebrew::Livecheck::SkipConditions.referenced_skip_information(
           referenced_cask,
-          Homebrew::Livecheck.cask_name(cask),
+          Homebrew::Livecheck.package_or_resource_name(cask),
         )
       end
 
-      # Respect cask skip conditions (e.g. discontinued, latest, unversioned)
+      # Respect cask skip conditions (e.g. deprecated, disabled, latest, unversioned)
       skip_info ||= Homebrew::Livecheck::SkipConditions.skip_information(cask)
       return :skip if skip_info.present?
 
@@ -571,157 +640,344 @@ def check_livecheck_version
         cask,
         referenced_formula_or_cask: referenced_cask,
       )&.fetch(:latest)
-      if cask.version.to_s == latest_version.to_s
-        if cask.appcast
-          add_error "Version '#{latest_version}' was automatically detected by livecheck; " \
-                    "the appcast should be removed."
-        end
-
-        return :auto_detected
-      end
 
-      return :appcast if cask.appcast && !cask.livecheckable?
+      return :auto_detected if cask.version.to_s == latest_version.to_s
 
       add_error "Version '#{cask.version}' differs from '#{latest_version}' retrieved by livecheck."
 
       false
     end
 
-    def check_appcast_contains_version
-      return unless appcast?
-      return if cask.appcast.to_s.empty?
-      return if cask.appcast.must_contain == :no_check
+    sig { void }
+    def audit_min_os
+      return unless online?
+      return unless strict?
+
+      odebug "Auditing minimum OS version"
+
+      plist_min_os = cask_plist_min_os
+      sparkle_min_os = livecheck_min_os
+
+      debug_messages = []
+      debug_messages << "Plist #{plist_min_os}" if plist_min_os
+      debug_messages << "Sparkle #{sparkle_min_os}" if sparkle_min_os
+      odebug "Detected minimum OS version: #{debug_messages.join(" | ")}" unless debug_messages.empty?
+      min_os = [plist_min_os, sparkle_min_os].compact.max
+
+      return if min_os.nil? || min_os <= HOMEBREW_MACOS_OLDEST_ALLOWED
+
+      on_system_block_min_os = cask.on_system_block_min_os
+      cask_min_os = [on_system_block_min_os, cask.depends_on.macos&.minimum_version].compact.max
+      odebug "Declared minimum OS version: #{cask_min_os&.to_sym}"
+      return if cask_min_os&.to_sym == min_os.to_sym
+      return if cask.on_system_blocks_exist? &&
+                OnSystem.arch_condition_met?(:arm) &&
+                cask_min_os.present? &&
+                cask_min_os < MacOSVersion.new("11")
+
+      min_os_definition = if cask_min_os.present?
+        if on_system_block_min_os.present? &&
+           on_system_block_min_os > cask.depends_on.macos&.minimum_version
+          "a block with a minimum OS version of #{cask_min_os.to_sym.inspect}"
+        else
+          cask_min_os.to_sym.inspect
+        end
+      else
+        "no minimum OS version"
+      end
+      add_error "Upstream defined #{min_os.to_sym.inspect} as the minimum OS version " \
+                "but the cask declared #{min_os_definition}",
+                strict_only: true
+    end
+
+    sig { returns(T.nilable(MacOSVersion)) }
+    def livecheck_min_os
+      return unless online?
+      return unless cask.livecheckable?
+      return if cask.livecheck.strategy != :sparkle
+
+      # `Sparkle` strategy blocks that use the `items` argument (instead of
+      # `item`) contain arbitrary logic that ignores/overrides the strategy's
+      # sorting, so we can't identify which item would be first/newest here.
+      return if cask.livecheck.strategy_block.present? &&
+                cask.livecheck.strategy_block.parameters[0] == [:opt, :items]
+
+      content = Homebrew::Livecheck::Strategy.page_content(cask.livecheck.url)[:content]
+      return if content.blank?
 
-      appcast_url = cask.appcast.to_s
       begin
-        details = curl_http_content_headers_and_checksum(appcast_url, user_agent: HOMEBREW_USER_AGENT_FAKE_SAFARI)
-        appcast_contents = details[:file]
+        items = Homebrew::Livecheck::Strategy::Sparkle.sort_items(
+          Homebrew::Livecheck::Strategy::Sparkle.filter_items(
+            Homebrew::Livecheck::Strategy::Sparkle.items_from_content(content),
+          ),
+        )
       rescue
-        add_error "appcast at URL '#{Formatter.url(appcast_url)}' offline or looping"
         return
       end
+      return if items.blank?
 
-      version_stanza = cask.version.to_s
-      adjusted_version_stanza = cask.appcast.must_contain.presence || version_stanza.match(/^[[:alnum:].]+/)[0]
-      return if appcast_contents.blank?
-      return if appcast_contents.include?(adjusted_version_stanza)
+      min_os = items[0]&.minimum_system_version&.strip_patch
+      # Big Sur is sometimes identified as 10.16, so we override it to the
+      # expected macOS version (11).
+      min_os = MacOSVersion.new("11") if min_os == "10.16"
+      min_os
+    end
+
+    sig { returns(T.nilable(MacOSVersion)) }
+    def cask_plist_min_os
+      return unless online?
 
-      add_error <<~EOS.chomp
-        appcast at URL '#{Formatter.url(appcast_url)}' does not contain \
-        the version number '#{adjusted_version_stanza}':
-        #{appcast_contents}
-      EOS
+      plist_min_os = T.let(nil, T.untyped)
+      @staged_path ||= cask.staged_path
+
+      extract_artifacts do |artifacts, tmpdir|
+        artifacts.each do |artifact|
+          artifact_path = artifact.is_a?(Artifact::Pkg) ? artifact.path : artifact.source
+          path = tmpdir/artifact_path.relative_path_from(cask.staged_path)
+          plist_path = "#{path}/Contents/Info.plist"
+          next unless File.exist?(plist_path)
+
+          plist = system_command!("plutil", args: ["-convert", "xml1", "-o", "-", plist_path]).plist
+          plist_min_os = plist["LSMinimumSystemVersion"].presence
+          break if plist_min_os
+        end
+      end
+
+      begin
+        MacOSVersion.new(plist_min_os).strip_patch
+      rescue MacOSVersion::Error
+        nil
+      end
     end
 
-    def check_github_prerelease_version
-      return if cask.tap == "homebrew/cask-versions"
+    sig { params(path: Pathname).returns(T.nilable(String)) }
+    def get_plist_main_binary(path)
+      return unless online?
+
+      plist_path = "#{path}/Contents/Info.plist"
+      return unless File.exist?(plist_path)
+
+      plist = system_command!("plutil", args: ["-convert", "xml1", "-o", "-", plist_path]).plist
+      binary = plist["CFBundleExecutable"].presence
+      return unless binary
+
+      binary_path = "#{path}/Contents/MacOS/#{binary}"
+
+      binary_path if File.exist?(binary_path) && File.executable?(binary_path)
+    end
+
+    sig { void }
+    def audit_github_prerelease_version
+      return if (url = cask.url).nil?
 
       odebug "Auditing GitHub prerelease"
       user, repo = get_repo_data(%r{https?://github\.com/([^/]+)/([^/]+)/?.*}) if online?
-      return if user.nil?
+      return if user.nil? || repo.nil?
 
-      tag = SharedAudits.github_tag_from_url(cask.url)
+      tag = SharedAudits.github_tag_from_url(url.to_s)
       tag ||= cask.version
-      error = SharedAudits.github_release(user, repo, tag, cask: cask)
-      add_error error if error
+      error = SharedAudits.github_release(user, repo, tag, cask:)
+      add_error error, location: url.location if error
     end
 
-    def check_gitlab_prerelease_version
-      return if cask.tap == "homebrew/cask-versions"
+    sig { void }
+    def audit_gitlab_prerelease_version
+      return if (url = cask.url).nil?
 
       user, repo = get_repo_data(%r{https?://gitlab\.com/([^/]+)/([^/]+)/?.*}) if online?
-      return if user.nil?
+      return if user.nil? || repo.nil?
 
       odebug "Auditing GitLab prerelease"
 
-      tag = SharedAudits.gitlab_tag_from_url(cask.url)
+      tag = SharedAudits.gitlab_tag_from_url(url.to_s)
       tag ||= cask.version
-      error = SharedAudits.gitlab_release(user, repo, tag, cask: cask)
-      add_error error if error
+      error = SharedAudits.gitlab_release(user, repo, tag, cask:)
+      add_error error, location: url.location if error
     end
 
-    def check_github_repository_archived
-      user, repo = get_repo_data(%r{https?://github\.com/([^/]+)/([^/]+)/?.*}) if online?
-      return if user.nil?
+    sig { void }
+    def audit_github_repository_archived
+      # Deprecated/disabled casks may have an archived repository.
+      return if cask.deprecated? || cask.disabled?
+      return if (url = cask.url).nil?
 
-      odebug "Auditing GitHub repo archived"
+      user, repo = get_repo_data(%r{https?://github\.com/([^/]+)/([^/]+)/?.*}) if online?
+      return if user.nil? || repo.nil?
 
       metadata = SharedAudits.github_repo_data(user, repo)
       return if metadata.nil?
 
-      return unless metadata["archived"]
-
-      message = "GitHub repo is archived"
-
-      if cask.discontinued?
-        add_warning message
-      else
-        add_error message
-      end
+      add_error "GitHub repo is archived", location: url.location if metadata["archived"]
     end
 
-    def check_gitlab_repository_archived
+    sig { void }
+    def audit_gitlab_repository_archived
+      # Deprecated/disabled casks may have an archived repository.
+      return if cask.deprecated? || cask.disabled?
+      return if (url = cask.url).nil?
+
       user, repo = get_repo_data(%r{https?://gitlab\.com/([^/]+)/([^/]+)/?.*}) if online?
-      return if user.nil?
+      return if user.nil? || repo.nil?
 
       odebug "Auditing GitLab repo archived"
 
       metadata = SharedAudits.gitlab_repo_data(user, repo)
       return if metadata.nil?
 
-      return unless metadata["archived"]
-
-      message = "GitLab repo is archived"
-
-      if cask.discontinued?
-        add_warning message
-      else
-        add_error message
-      end
+      add_error "GitLab repo is archived", location: url.location if metadata["archived"]
     end
 
-    def check_github_repository
+    sig { void }
+    def audit_github_repository
       return unless new_cask?
+      return if (url = cask.url).nil?
 
       user, repo = get_repo_data(%r{https?://github\.com/([^/]+)/([^/]+)/?.*})
-      return if user.nil?
+      return if user.nil? || repo.nil?
 
       odebug "Auditing GitHub repo"
 
       error = SharedAudits.github(user, repo)
-      add_error error if error
+      add_error error, location: url.location if error
     end
 
-    def check_gitlab_repository
+    sig { void }
+    def audit_gitlab_repository
       return unless new_cask?
+      return if (url = cask.url).nil?
 
       user, repo = get_repo_data(%r{https?://gitlab\.com/([^/]+)/([^/]+)/?.*})
-      return if user.nil?
+      return if user.nil? || repo.nil?
 
       odebug "Auditing GitLab repo"
 
       error = SharedAudits.gitlab(user, repo)
-      add_error error if error
+      add_error error, location: url.location if error
     end
 
-    def check_bitbucket_repository
+    sig { void }
+    def audit_bitbucket_repository
       return unless new_cask?
+      return if (url = cask.url).nil?
 
       user, repo = get_repo_data(%r{https?://bitbucket\.org/([^/]+)/([^/]+)/?.*})
-      return if user.nil?
+      return if user.nil? || repo.nil?
 
       odebug "Auditing Bitbucket repo"
 
       error = SharedAudits.bitbucket(user, repo)
+      add_error error, location: url.location if error
+    end
+
+    sig { void }
+    def audit_denylist
+      return unless cask.tap
+      return unless cask.tap.official?
+      return unless (reason = Denylist.reason(cask.token))
+
+      add_error "#{cask.token} is not allowed: #{reason}"
+    end
+
+    sig { void }
+    def audit_reverse_migration
+      return unless new_cask?
+      return unless cask.tap
+      return unless cask.tap.official?
+      return unless cask.tap.tap_migrations.key?(cask.token)
+
+      add_error "#{cask.token} is listed in tap_migrations.json"
+    end
+
+    sig { void }
+    def audit_homepage_https_availability
+      return unless online?
+      return unless (homepage = cask.homepage)
+
+      user_agents = if cask.tap&.audit_exception(:simple_user_agent_for_homepage, cask.token)
+        ["curl"]
+      else
+        [:browser, :default]
+      end
+
+      validate_url_for_https_availability(
+        homepage, SharedAudits::URL_TYPE_HOMEPAGE,
+        user_agents:,
+        check_content: true,
+        strict:        strict?
+      )
+    end
+
+    sig { void }
+    def audit_url_https_availability
+      return unless online?
+      return unless (url = cask.url)
+      return if url.using
+
+      validate_url_for_https_availability(
+        url, "binary URL",
+        location:    url.location,
+        user_agents: [url.user_agent],
+        referer:     url.referer
+      )
+    end
+
+    sig { void }
+    def audit_livecheck_https_availability
+      return unless online?
+      return unless cask.livecheckable?
+      return unless (url = cask.livecheck.url)
+      return if url.is_a?(Symbol)
+
+      validate_url_for_https_availability(
+        url, "livecheck URL",
+        check_content: true,
+        user_agents:   [:default, :browser]
+      )
+    end
+
+    sig { void }
+    def audit_cask_path
+      return unless cask.tap.core_cask_tap?
+
+      expected_path = cask.tap.new_cask_path(cask.token)
+
+      return if cask.sourcefile_path.to_s.end_with?(expected_path)
+
+      add_error "Cask should be located in '#{expected_path}'"
+    end
+
+    sig { void }
+    def audit_deprecate_disable
+      error = SharedAudits.check_deprecate_disable_reason(cask)
       add_error error if error
     end
 
+    sig {
+      params(
+        url_to_check: T.any(String, URL),
+        url_type:     String,
+        location:     T.nilable(Homebrew::SourceLocation),
+        options:      T.untyped,
+      ).void
+    }
+    def validate_url_for_https_availability(url_to_check, url_type, location: nil, **options)
+      problem = curl_check_http_content(url_to_check.to_s, url_type, **options)
+      exception = cask.tap&.audit_exception(:secure_connection_audit_skiplist, cask.token, url_to_check.to_s)
+
+      if problem
+        add_error problem, location: location unless exception
+      elsif exception
+        add_error "#{url_to_check} is in the secure connection audit skiplist but does not need to be skipped",
+                  location:
+      end
+    end
+
+    sig { params(regex: T.any(String, Regexp)).returns(T.nilable(T::Array[String])) }
     def get_repo_data(regex)
       return unless online?
 
       _, user, repo = *regex.match(cask.url.to_s)
       _, user, repo = *regex.match(cask.homepage) unless user
-      _, user, repo = *regex.match(cask.appcast.to_s) unless user
       return if !user || !repo
 
       repo.gsub!(/.git$/, "")
@@ -729,52 +985,113 @@ def get_repo_data(regex)
       [user, repo]
     end
 
-    def check_denylist
-      return unless cask.tap
-      return unless cask.tap.official?
-      return unless (reason = Denylist.reason(cask.token))
+    sig {
+      params(regex: T.any(String, Regexp), valid_formats_array: T::Array[T.any(String, Regexp)]).returns(T::Boolean)
+    }
+    def bad_url_format?(regex, valid_formats_array)
+      return false unless cask.url.to_s.match?(regex)
 
-      add_error "#{cask.token} is not allowed: #{reason}"
+      valid_formats_array.none? { |format| cask.url.to_s.match?(format) }
     end
 
-    def check_reverse_migration
-      return unless new_cask?
-      return unless cask.tap
-      return unless cask.tap.official?
-      return unless cask.tap.tap_migrations.key?(cask.token)
+    sig { returns(T::Boolean) }
+    def bad_sourceforge_url?
+      bad_url_format?(%r{((downloads|\.dl)\.|//)sourceforge},
+                      [
+                        %r{\Ahttps://sourceforge\.net/projects/[^/]+/files/latest/download\Z},
+                        %r{\Ahttps://downloads\.sourceforge\.net/(?!(project|sourceforge)/)},
+                      ])
+    end
 
-      add_error "#{cask.token} is listed in tap_migrations.json"
+    sig { returns(T::Boolean) }
+    def bad_osdn_url?
+      domain.match?(%r{^(?:\w+\.)*osdn\.jp(?=/|$)})
     end
 
-    def check_https_availability
-      return unless download
+    # sig { returns(String) }
+    def homepage
+      URI(cask.homepage.to_s).host
+    end
 
-      if cask.url && !cask.url.using
-        check_url_for_https_availability(cask.url, "binary URL", cask.token, cask.tap,
-                                         user_agents: [cask.url.user_agent])
+    # sig { returns(String) }
+    def domain
+      URI(cask.url.to_s).host
+    end
+
+    sig { returns(T::Boolean) }
+    def url_match_homepage?
+      host = cask.url.to_s
+      host_uri = URI(host)
+      host = if host.match?(/:\d/) && host_uri.port != 80
+        "#{host_uri.host}:#{host_uri.port}"
+      else
+        host_uri.host
       end
 
-      if cask.appcast && appcast?
-        check_url_for_https_availability(cask.appcast, "appcast URL", cask.token, cask.tap, check_content: true)
+      return false if homepage.blank?
+
+      home = homepage.downcase
+      if (split_host = T.must(host).split(".")).length >= 3
+        host = T.must(split_host[-2..]).join(".")
       end
+      if (split_home = homepage.split(".")).length >= 3
+        home = split_home[-2..].join(".")
+      end
+      host == home
+    end
 
-      return unless cask.homepage
+    # sig { params(url: String).returns(String) }
+    def strip_url_scheme(url)
+      url.sub(%r{^[^:/]+://(www\.)?}, "")
+    end
 
-      check_url_for_https_availability(cask.homepage, "homepage URL", cask.token, cask.tap,
-                                       user_agents:   [:browser, :default],
-                                       check_content: true,
-                                       strict:        strict?)
+    # sig { returns(String) }
+    def url_from_verified
+      strip_url_scheme(T.must(cask.url).verified)
     end
 
-    def check_url_for_https_availability(url_to_check, url_type, cask_token, tap, **options)
-      problem = curl_check_http_content(url_to_check.to_s, url_type, **options)
-      exception = tap&.audit_exception(:secure_connection_audit_skiplist, cask_token, url_to_check.to_s)
+    sig { returns(T::Boolean) }
+    def verified_matches_url?
+      url_domain, url_path = strip_url_scheme(cask.url.to_s).split("/", 2)
+      verified_domain, verified_path = url_from_verified.split("/", 2)
 
-      if problem
-        add_error problem unless exception
-      elsif exception
-        add_error "#{url_to_check} is in the secure connection audit skiplist but does not need to be skipped"
-      end
+      (url_domain == verified_domain || (verified_domain && url_domain&.end_with?(".#{verified_domain}"))) &&
+        (!verified_path || url_path&.start_with?(verified_path))
+    end
+
+    sig { returns(T::Boolean) }
+    def verified_present?
+      cask.url&.verified.present?
+    end
+
+    sig { returns(T::Boolean) }
+    def file_url?
+      URI(cask.url.to_s).scheme == "file"
+    end
+
+    sig { returns(T::Boolean) }
+    def block_url_offline?
+      return false if online?
+
+      !!cask.url&.from_block?
+    end
+
+    sig { returns(Tap) }
+    def core_tap
+      @core_tap ||= CoreTap.instance
+    end
+
+    # sig { returns(T::Array[String]) }
+    def core_formula_names
+      core_tap.formula_names
+    end
+
+    sig { returns(String) }
+    def core_formula_url
+      formula_path = Formulary.core_path(cask.token)
+                              .to_s
+                              .delete_prefix(core_tap.path.to_s)
+      "#{core_tap.default_remote}/blob/HEAD#{formula_path}"
     end
   end
 end
diff --git a/Library/Homebrew/cask/auditor.rb b/Library/Homebrew/cask/auditor.rb
index 508fb0a379736..f79de7218568e 100644
--- a/Library/Homebrew/cask/auditor.rb
+++ b/Library/Homebrew/cask/auditor.rb
@@ -1,41 +1,13 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/audit"
 
 module Cask
   # Helper class for auditing all available languages of a cask.
-  #
-  # @api private
   class Auditor
-    def self.audit(
-      cask,
-      audit_download: nil,
-      audit_appcast: nil,
-      audit_online: nil,
-      audit_new_cask: nil,
-      audit_strict: nil,
-      audit_token_conflicts: nil,
-      quarantine: nil,
-      any_named_args: nil,
-      language: nil,
-      display_passes: nil,
-      display_failures_only: nil
-    )
-      new(
-        cask,
-        audit_download:        audit_download,
-        audit_appcast:         audit_appcast,
-        audit_online:          audit_online,
-        audit_new_cask:        audit_new_cask,
-        audit_strict:          audit_strict,
-        audit_token_conflicts: audit_token_conflicts,
-        quarantine:            quarantine,
-        any_named_args:        any_named_args,
-        language:              language,
-        display_passes:        display_passes,
-        display_failures_only: display_failures_only,
-      ).audit
+    def self.audit(cask, **options)
+      new(cask, **options).audit
     end
 
     attr_reader :cask, :language
@@ -43,55 +15,61 @@ def self.audit(
     def initialize(
       cask,
       audit_download: nil,
-      audit_appcast: nil,
       audit_online: nil,
       audit_strict: nil,
+      audit_signing: nil,
       audit_token_conflicts: nil,
       audit_new_cask: nil,
       quarantine: nil,
       any_named_args: nil,
       language: nil,
-      display_passes: nil,
-      display_failures_only: nil
+      only: [],
+      except: []
     )
       @cask = cask
       @audit_download = audit_download
-      @audit_appcast = audit_appcast
       @audit_online = audit_online
       @audit_new_cask = audit_new_cask
       @audit_strict = audit_strict
+      @audit_signing = audit_signing
       @quarantine = quarantine
       @audit_token_conflicts = audit_token_conflicts
       @any_named_args = any_named_args
       @language = language
-      @display_passes = display_passes
-      @display_failures_only = display_failures_only
+      @only = only
+      @except = except
     end
 
+    LANGUAGE_BLOCK_LIMIT = 10
+
     def audit
-      warnings = Set.new
       errors = Set.new
 
       if !language && language_blocks
-        language_blocks.each_key do |l|
+        sample_languages = if language_blocks.length > LANGUAGE_BLOCK_LIMIT && !@audit_new_cask
+          sample_keys = language_blocks.keys.sample(LANGUAGE_BLOCK_LIMIT)
+          ohai "Auditing a sample of available languages for #{cask}: " \
+               "#{sample_keys.map { |lang| lang[0].to_s }.to_sentence}"
+          language_blocks.select { |k| sample_keys.include?(k) }
+        else
+          language_blocks
+        end
+
+        sample_languages.each_key do |l|
           audit = audit_languages(l)
-          summary = audit.summary(include_passed: output_passed?, include_warnings: output_warnings?)
-          if summary.present? && output_summary?(audit)
+          if audit.summary.present? && output_summary?(audit)
             ohai "Auditing language: #{l.map { |lang| "'#{lang}'" }.to_sentence}" if output_summary?
-            puts summary
+            puts audit.summary
           end
-          warnings += audit.warnings
           errors += audit.errors
         end
       else
         audit = audit_cask_instance(cask)
-        summary = audit.summary(include_passed: output_passed?, include_warnings: output_warnings?)
-        puts summary if summary.present? && output_summary?(audit)
-        warnings += audit.warnings
+        puts audit.summary if audit.summary.present? && output_summary?(audit)
         errors += audit.errors
       end
 
-      { warnings: warnings, errors: errors }
+      errors
     end
 
     private
@@ -104,22 +82,9 @@ def output_summary?(audit = nil)
       audit.errors?
     end
 
-    def output_passed?
-      return false if @display_failures_only.present?
-      return true if @display_passes.present?
-
-      false
-    end
-
-    def output_warnings?
-      return false if @display_failures_only.present?
-
-      true
-    end
-
     def audit_languages(languages)
       original_config = cask.config
-      localized_config = original_config.merge(Config.new(explicit: { languages: languages }))
+      localized_config = original_config.merge(Config.new(explicit: { languages: }))
       cask.config = localized_config
 
       audit_cask_instance(cask)
@@ -130,16 +95,17 @@ def audit_languages(languages)
     def audit_cask_instance(cask)
       audit = Audit.new(
         cask,
-        appcast:         @audit_appcast,
         online:          @audit_online,
         strict:          @audit_strict,
+        signing:         @audit_signing,
         new_cask:        @audit_new_cask,
         token_conflicts: @audit_token_conflicts,
         download:        @audit_download,
         quarantine:      @quarantine,
+        only:            @only,
+        except:          @except,
       )
       audit.run!
-      audit
     end
 
     def language_blocks
diff --git a/Library/Homebrew/cask/cache.rb b/Library/Homebrew/cask/cache.rb
index 911a4eb833053..9735e4789d813 100644
--- a/Library/Homebrew/cask/cache.rb
+++ b/Library/Homebrew/cask/cache.rb
@@ -1,16 +1,12 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Cask
   # Helper functions for the cask cache.
-  #
-  # @api private
   module Cache
-    extend T::Sig
-
     sig { returns(Pathname) }
     def self.path
-      @path ||= HOMEBREW_CACHE/"Cask"
+      @path ||= T.let(HOMEBREW_CACHE/"Cask", T.nilable(Pathname))
     end
   end
 end
diff --git a/Library/Homebrew/cask/cask.rb b/Library/Homebrew/cask/cask.rb
index 955cad92df0c8..118358a9d93a2 100644
--- a/Library/Homebrew/cask/cask.rb
+++ b/Library/Homebrew/cask/cask.rb
@@ -1,36 +1,54 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "attrable"
+require "bundle_version"
 require "cask/cask_loader"
 require "cask/config"
 require "cask/dsl"
 require "cask/metadata"
-require "searchable"
+require "cask/tab"
 require "utils/bottles"
+require "extend/api_hashable"
 
 module Cask
   # An instance of a cask.
-  #
-  # @api private
   class Cask
-    extend T::Sig
-
     extend Forwardable
-    extend Searchable
+    extend Attrable
+    extend APIHashable
     include Metadata
 
-    attr_reader :token, :sourcefile_path, :source, :config, :default_config
+    # The token of this {Cask}.
+    #
+    # @api internal
+    attr_reader :token
+
+    # The configuration of this {Cask}.
+    #
+    # @api internal
+    attr_reader :config
 
+    attr_reader :sourcefile_path, :source, :default_config, :loader
     attr_accessor :download, :allow_reassignment
 
-    def self.all
-      Tap.flat_map(&:cask_files).map do |f|
-        CaskLoader::FromTapPathLoader.new(f).load(config: nil)
+    attr_predicate :loaded_from_api?
+
+    def self.all(eval_all: false)
+      if !eval_all && !Homebrew::EnvConfig.eval_all?
+        raise ArgumentError, "Cask::Cask#all cannot be used without `--eval-all` or HOMEBREW_EVAL_ALL"
+      end
+
+      # Load core casks from tokens so they load from the API when the core cask is not tapped.
+      tokens_and_files = CoreCaskTap.instance.cask_tokens
+      tokens_and_files += Tap.reject(&:core_cask_tap?).flat_map(&:cask_files)
+      tokens_and_files.filter_map do |token_or_file|
+        CaskLoader.load(token_or_file)
       rescue CaskUnreadableError => e
         opoo e.message
 
         nil
-      end.compact
+      end
     end
 
     def tap
@@ -39,13 +57,31 @@ def tap
       @tap
     end
 
-    def initialize(token, sourcefile_path: nil, source: nil, tap: nil, config: nil, allow_reassignment: false, &block)
+    sig {
+      params(
+        token:              String,
+        sourcefile_path:    T.nilable(Pathname),
+        source:             T.nilable(String),
+        tap:                T.nilable(Tap),
+        loaded_from_api:    T::Boolean,
+        config:             T.nilable(Config),
+        allow_reassignment: T::Boolean,
+        loader:             T.nilable(CaskLoader::ILoader),
+        block:              T.nilable(T.proc.bind(DSL).void),
+      ).void
+    }
+    def initialize(token, sourcefile_path: nil, source: nil, tap: nil, loaded_from_api: false,
+                   config: nil, allow_reassignment: false, loader: nil, &block)
       @token = token
       @sourcefile_path = sourcefile_path
       @source = source
       @tap = tap
       @allow_reassignment = allow_reassignment
-      @block = block
+      @loaded_from_api = loaded_from_api
+      @loader = loader
+      # Sorbet has trouble with bound procs assigned to instance variables:
+      # https://github.com/sorbet/sorbet/issues/6843
+      instance_variable_set(:@block, block)
 
       @default_config = config || Config.new
 
@@ -56,6 +92,17 @@ def initialize(token, sourcefile_path: nil, source: nil, tap: nil, config: nil,
       end
     end
 
+    # An old name for the cask.
+    sig { returns(T::Array[String]) }
+    def old_tokens
+      @old_tokens ||= if (tap = self.tap)
+        Tap.tap_migration_oldnames(tap, token) +
+          tap.cask_reverse_renames.fetch(token, [])
+      else
+        []
+      end
+    end
+
     def config=(config)
       @config = config
 
@@ -70,64 +117,112 @@ def refresh
       @dsl.language_eval
     end
 
-    DSL::DSL_METHODS.each do |method_name|
-      define_method(method_name) { |&block| @dsl.send(method_name, &block) }
+    ::Cask::DSL::DSL_METHODS.each do |method_name|
+      define_method(method_name) { |*args, &block| @dsl.send(method_name, *args, &block) }
+    end
+
+    sig { params(caskroom_path: Pathname).returns(T::Array[[String, String]]) }
+    def timestamped_versions(caskroom_path: self.caskroom_path)
+      relative_paths = Pathname.glob(metadata_timestamped_path(
+                                       version: "*", timestamp: "*",
+                                       caskroom_path:
+                                     ))
+                               .map { |p| p.relative_path_from(p.parent.parent) }
+      # Sorbet is unaware that Pathname is sortable: https://github.com/sorbet/sorbet/issues/6844
+      T.unsafe(relative_paths).sort_by(&:basename) # sort by timestamp
+       .map { |p| p.split.map(&:to_s) }
     end
 
-    sig { returns(T::Array[[String, String]]) }
-    def timestamped_versions
-      Pathname.glob(metadata_timestamped_path(version: "*", timestamp: "*"))
-              .map { |p| p.relative_path_from(p.parent.parent) }
-              .sort_by(&:basename) # sort by timestamp
-              .map { |p| p.split.map(&:to_s) }
+    # The fully-qualified token of this {Cask}.
+    #
+    # @api internal
+    def full_token
+      return token if tap.nil?
+      return token if tap.core_cask_tap?
+
+      "#{tap.name}/#{token}"
     end
 
-    def versions
-      timestamped_versions.map(&:first)
-                          .reverse
-                          .uniq
-                          .reverse
+    # Alias for {#full_token}.
+    #
+    # @api internal
+    def full_name = full_token
+
+    sig { returns(T::Boolean) }
+    def installed?
+      installed_caskfile&.exist? || false
     end
 
-    def os_versions
-      @os_versions ||= begin
-        version_os_hash = {}
-        actual_version = MacOS.full_version.to_s
+    # The caskfile is needed during installation when there are
+    # `*flight` blocks or the cask has multiple languages
+    def caskfile_only?
+      languages.any? || artifacts.any?(Artifact::AbstractFlightBlock)
+    end
 
-        MacOSVersions::SYMBOLS.each do |os_name, os_version|
-          MacOS.full_version = os_version
-          cask = CaskLoader.load(token)
-          version_os_hash[os_name] = cask.version if cask.version != version
+    def uninstall_flight_blocks?
+      artifacts.any? do |artifact|
+        case artifact
+        when Artifact::PreflightBlock
+          artifact.directives.key?(:uninstall_preflight)
+        when Artifact::PostflightBlock
+          artifact.directives.key?(:uninstall_postflight)
         end
-
-        version_os_hash
-      ensure
-        MacOS.full_version = actual_version
       end
     end
 
-    def full_name
-      return token if tap.nil?
-      return token if tap.user == "Homebrew"
+    sig { returns(T.nilable(Time)) }
+    def install_time
+      # <caskroom_path>/.metadata/<version>/<timestamp>/Casks/<token>.{rb,json} -> <timestamp>
+      time = installed_caskfile&.dirname&.dirname&.basename&.to_s
+      Time.strptime(time, Metadata::TIMESTAMP_FORMAT) if time
+    end
 
-      "#{tap.name}/#{token}"
+    sig { returns(T.nilable(Pathname)) }
+    def installed_caskfile
+      installed_caskroom_path = caskroom_path
+      installed_token = token
+
+      # Check if the cask is installed with an old name.
+      old_tokens.each do |old_token|
+        old_caskroom_path = Caskroom.path/old_token
+        next if !old_caskroom_path.directory? || old_caskroom_path.symlink?
+
+        installed_caskroom_path = old_caskroom_path
+        installed_token = old_token
+        break
+      end
+
+      installed_version = timestamped_versions(caskroom_path: installed_caskroom_path).last
+      return unless installed_version
+
+      caskfile_dir = metadata_main_container_path(caskroom_path: installed_caskroom_path)
+                     .join(*installed_version, "Casks")
+
+      ["json", "rb"]
+        .map { |ext| caskfile_dir.join("#{installed_token}.#{ext}") }
+        .find(&:exist?)
     end
 
-    def installed?
-      !versions.empty?
+    sig { returns(T.nilable(String)) }
+    def installed_version
+      return unless (installed_caskfile = self.installed_caskfile)
+
+      # <caskroom_path>/.metadata/<version>/<timestamp>/Casks/<token>.{rb,json} -> <version>
+      installed_caskfile.dirname.dirname.dirname.basename.to_s
     end
 
-    sig { returns(T.nilable(Time)) }
-    def install_time
-      _, time = timestamped_versions.last
-      return unless time
+    sig { returns(T.nilable(String)) }
+    def bundle_short_version
+      bundle_version&.short_version
+    end
 
-      Time.strptime(time, Metadata::TIMESTAMP_FORMAT)
+    sig { returns(T.nilable(String)) }
+    def bundle_long_version
+      bundle_version&.version
     end
 
-    def installed_caskfile
-      installed_version = timestamped_versions.last
-      metadata_main_container_path.join(*installed_version, "Casks", "#{token}.rb")
+    def tab
+      Tab.for_cask(self)
     end
 
     def config_path
@@ -135,6 +230,8 @@ def config_path
     end
 
     def checksumable?
+      return false if (url = self.url).nil?
+
       DownloadStrategyDetector.detect(url.to_s, url.using) <= AbstractFileDownloadStrategy
     end
 
@@ -158,56 +255,101 @@ def outdated_download_sha?
       current_download_sha.blank? || current_download_sha != new_download_sha
     end
 
+    sig { returns(Pathname) }
     def caskroom_path
       @caskroom_path ||= Caskroom.path.join(token)
     end
 
+    # Check if the installed cask is outdated.
+    #
+    # @api internal
     def outdated?(greedy: false, greedy_latest: false, greedy_auto_updates: false)
-      !outdated_versions(greedy: greedy, greedy_latest: greedy_latest,
-                         greedy_auto_updates: greedy_auto_updates).empty?
+      !outdated_version(greedy:, greedy_latest:,
+                        greedy_auto_updates:).nil?
     end
 
-    def outdated_versions(greedy: false, greedy_latest: false, greedy_auto_updates: false)
+    def outdated_version(greedy: false, greedy_latest: false, greedy_auto_updates: false)
       # special case: tap version is not available
-      return [] if version.nil?
+      return if version.nil?
 
       if version.latest?
-        return versions if (greedy || greedy_latest) && outdated_download_sha?
+        return installed_version if (greedy || greedy_latest) && outdated_download_sha?
 
-        return []
+        return
       elsif auto_updates && !greedy && !greedy_auto_updates
-        return []
+        return
       end
 
-      installed = versions
-      current   = installed.last
-
       # not outdated unless there is a different version on tap
-      return [] if current == version
+      return if installed_version == version
 
-      # collect all installed versions that are different than tap version and return them
-      installed.reject { |v| v == version }
+      installed_version
     end
 
     def outdated_info(greedy, verbose, json, greedy_latest, greedy_auto_updates)
       return token if !verbose && !json
 
-      installed_versions = outdated_versions(greedy: greedy, greedy_latest: greedy_latest,
-                                             greedy_auto_updates: greedy_auto_updates).join(", ")
+      installed_version = outdated_version(greedy:, greedy_latest:,
+                                           greedy_auto_updates:).to_s
 
       if json
         {
           name:               token,
-          installed_versions: installed_versions,
+          installed_versions: [installed_version],
           current_version:    version,
         }
       else
-        "#{token} (#{installed_versions}) != #{version}"
+        "#{token} (#{installed_version}) != #{version}"
       end
     end
 
-    def to_s
-      @token
+    def ruby_source_path
+      return @ruby_source_path if defined?(@ruby_source_path)
+
+      return unless sourcefile_path
+      return unless tap
+
+      @ruby_source_path = sourcefile_path.relative_path_from(tap.path)
+    end
+
+    sig { returns(T::Hash[Symbol, String]) }
+    def ruby_source_checksum
+      @ruby_source_checksum ||= {
+        sha256: Digest::SHA256.file(sourcefile_path).hexdigest,
+      }.freeze
+    end
+
+    def languages
+      @languages ||= @dsl.languages
+    end
+
+    def tap_git_head
+      @tap_git_head ||= tap&.git_head
+    rescue TapUnavailableError
+      nil
+    end
+
+    def populate_from_api!(json_cask)
+      raise ArgumentError, "Expected cask to be loaded from the API" unless loaded_from_api?
+
+      @languages = json_cask.fetch(:languages, [])
+      @tap_git_head = json_cask.fetch(:tap_git_head, "HEAD")
+
+      @ruby_source_path = json_cask[:ruby_source_path]
+
+      # TODO: Clean this up when we deprecate the current JSON API and move to the internal JSON v3.
+      ruby_source_sha256 = json_cask.dig(:ruby_source_checksum, :sha256)
+      ruby_source_sha256 ||= json_cask[:ruby_source_sha256]
+      @ruby_source_checksum = { sha256: ruby_source_sha256 }
+    end
+
+    # @api public
+    sig { returns(String) }
+    def to_s = token
+
+    sig { returns(String) }
+    def inspect
+      "#<Cask #{token}#{sourcefile_path&.to_s&.prepend(" ")}>"
     end
 
     def hash
@@ -221,92 +363,174 @@ def eql?(other)
 
     def to_h
       {
-        "token"          => token,
-        "full_token"     => full_name,
-        "tap"            => tap&.name,
-        "name"           => name,
-        "desc"           => desc,
-        "homepage"       => homepage,
-        "url"            => url,
-        "appcast"        => appcast,
-        "version"        => version,
-        "versions"       => os_versions,
-        "installed"      => versions.last,
-        "outdated"       => outdated?,
-        "sha256"         => sha256,
-        "artifacts"      => artifacts.map(&method(:to_h_gsubs)),
-        "caveats"        => (to_h_string_gsubs(caveats) unless caveats.empty?),
-        "depends_on"     => depends_on,
-        "conflicts_with" => conflicts_with,
-        "container"      => container,
-        "auto_updates"   => auto_updates,
+        "token"                => token,
+        "full_token"           => full_name,
+        "old_tokens"           => old_tokens,
+        "tap"                  => tap&.name,
+        "name"                 => name,
+        "desc"                 => desc,
+        "homepage"             => homepage,
+        "url"                  => url,
+        "url_specs"            => url_specs,
+        "version"              => version,
+        "installed"            => installed_version,
+        "installed_time"       => install_time&.to_i,
+        "bundle_version"       => bundle_long_version,
+        "bundle_short_version" => bundle_short_version,
+        "outdated"             => outdated?,
+        "sha256"               => sha256,
+        "artifacts"            => artifacts_list,
+        "caveats"              => (caveats unless caveats.empty?),
+        "depends_on"           => depends_on,
+        "conflicts_with"       => conflicts_with,
+        "container"            => container&.pairs,
+        "auto_updates"         => auto_updates,
+        "deprecated"           => deprecated?,
+        "deprecation_date"     => deprecation_date,
+        "deprecation_reason"   => deprecation_reason,
+        "disabled"             => disabled?,
+        "disable_date"         => disable_date,
+        "disable_reason"       => disable_reason,
+        "tap_git_head"         => tap_git_head,
+        "languages"            => languages,
+        "ruby_source_path"     => ruby_source_path,
+        "ruby_source_checksum" => ruby_source_checksum,
       }
     end
 
-    def to_hash_with_variations
-      hash = to_h
-      variations = {}
+    def to_internal_api_hash
+      api_hash = {
+        "token"              => token,
+        "name"               => name,
+        "desc"               => desc,
+        "homepage"           => homepage,
+        "url"                => url,
+        "version"            => version,
+        "sha256"             => sha256,
+        "artifacts"          => artifacts_list(compact: true),
+        "ruby_source_path"   => ruby_source_path,
+        "ruby_source_sha256" => ruby_source_checksum.fetch(:sha256),
+      }
+
+      if deprecation_date
+        api_hash["deprecation_date"] = deprecation_date
+        api_hash["deprecation_reason"] = deprecation_reason
+      end
+
+      if disable_date
+        api_hash["disable_date"] = disable_date
+        api_hash["disable_reason"] = disable_reason
+      end
+
+      if (url_specs_hash = url_specs).present?
+        api_hash["url_specs"] = url_specs_hash
+      end
+
+      api_hash["caskfile_only"] = true if caskfile_only?
+      api_hash["conflicts_with"] = conflicts_with if conflicts_with.present?
+      api_hash["depends_on"] = depends_on if depends_on.present?
+      api_hash["container"] = container.pairs if container
+      api_hash["caveats"] = caveats if caveats.present?
+      api_hash["auto_updates"] = auto_updates if auto_updates
+      api_hash["languages"] = languages if languages.present?
 
-      hash_keys_to_skip = %w[outdated installed versions]
+      api_hash
+    end
+
+    HASH_KEYS_TO_SKIP = %w[outdated installed versions].freeze
+    private_constant :HASH_KEYS_TO_SKIP
+
+    def to_hash_with_variations(hash_method: :to_h)
+      case hash_method
+      when :to_h
+        if loaded_from_api? && !Homebrew::EnvConfig.no_install_from_api?
+          return api_to_local_hash(Homebrew::API::Cask.all_casks[token].dup)
+        end
+      when :to_internal_api_hash
+        raise ArgumentError, "API Hash must be generated from Ruby source files" if loaded_from_api?
+      else
+        raise ArgumentError, "Unknown hash method #{hash_method.inspect}"
+      end
+
+      hash = public_send(hash_method)
+      variations = {}
 
       if @dsl.on_system_blocks_exist?
-        [:arm, :intel].each do |arch|
-          MacOSVersions::SYMBOLS.each_key do |os_name|
-            bottle_tag = ::Utils::Bottles::Tag.new(system: os_name, arch: arch)
+        begin
+          MacOSVersion::SYMBOLS.keys.product(OnSystem::ARCH_OPTIONS).each do |os, arch|
+            bottle_tag = ::Utils::Bottles::Tag.new(system: os, arch:)
             next unless bottle_tag.valid_combination?
+            next if depends_on.macos &&
+                    !@dsl.depends_on_set_in_block? &&
+                    !depends_on.macos.allows?(bottle_tag.to_macos_version)
 
-            Homebrew::SimulateSystem.os = os_name
-            Homebrew::SimulateSystem.arch = arch
-
-            refresh
+            Homebrew::SimulateSystem.with(os:, arch:) do
+              refresh
 
-            to_h.each do |key, value|
-              next if hash_keys_to_skip.include? key
-              next if value.to_s == hash[key].to_s
+              public_send(hash_method).each do |key, value|
+                next if HASH_KEYS_TO_SKIP.include? key
+                next if value.to_s == hash[key].to_s
 
-              variations[bottle_tag.to_sym] ||= {}
-              variations[bottle_tag.to_sym][key] = value
+                variations[bottle_tag.to_sym] ||= {}
+                variations[bottle_tag.to_sym][key] = value
+              end
             end
           end
+        ensure
+          refresh
         end
       end
 
-      Homebrew::SimulateSystem.clear
-      refresh
-
-      hash["variations"] = variations
+      hash["variations"] = variations if hash_method != :to_internal_api_hash || variations.present?
       hash
     end
 
-    private
-
-    def to_h_string_gsubs(string)
-      string.to_s
-            .gsub(Dir.home, "$HOME")
-            .gsub(HOMEBREW_PREFIX, "$(brew --prefix)")
+    def artifacts_list(compact: false, uninstall_only: false)
+      artifacts.filter_map do |artifact|
+        case artifact
+        when Artifact::AbstractFlightBlock
+          uninstall_flight_block = artifact.directives.key?(:uninstall_preflight) ||
+                                   artifact.directives.key?(:uninstall_postflight)
+          next if uninstall_only && !uninstall_flight_block
+
+          # Only indicate whether this block is used as we don't load it from the API
+          # We can skip this entirely once we move to internal JSON v3.
+          { artifact.summarize.to_sym => nil } unless compact
+        else
+          zap_artifact = artifact.is_a?(Artifact::Zap)
+          uninstall_artifact = artifact.respond_to?(:uninstall_phase) || artifact.respond_to?(:post_uninstall_phase)
+          next if uninstall_only && !zap_artifact && !uninstall_artifact
+
+          { artifact.class.dsl_key => artifact.to_args }
+        end
+      end
     end
 
-    def to_h_array_gsubs(array)
-      array.to_a.map do |value|
-        to_h_gsubs(value)
+    private
+
+    sig { returns(T.nilable(Homebrew::BundleVersion)) }
+    def bundle_version
+      @bundle_version ||= if (bundle = artifacts.find { |a| a.is_a?(Artifact::App) }&.target) &&
+                             (plist = Pathname("#{bundle}/Contents/Info.plist")) && plist.exist?
+        Homebrew::BundleVersion.from_info_plist(plist)
       end
     end
 
-    def to_h_hash_gsubs(hash)
-      hash.to_h.transform_values do |value|
-        to_h_gsubs(value)
-      end
-    rescue TypeError
-      to_h_array_gsubs(hash)
+    def api_to_local_hash(hash)
+      hash["token"] = token
+      hash["installed"] = installed_version
+      hash["outdated"] = outdated?
+      hash
     end
 
-    def to_h_gsubs(value)
-      if value.respond_to? :to_h
-        to_h_hash_gsubs(value)
-      elsif value.respond_to? :to_a
-        to_h_array_gsubs(value)
-      else
-        to_h_string_gsubs(value)
+    def url_specs
+      url&.specs.dup.tap do |url_specs|
+        case url_specs&.dig(:user_agent)
+        when :default
+          url_specs.delete(:user_agent)
+        when Symbol
+          url_specs[:user_agent] = ":#{url_specs[:user_agent]}"
+        end
       end
     end
   end
diff --git a/Library/Homebrew/cask/cask.rbi b/Library/Homebrew/cask/cask.rbi
index f2cb16087afbc..9ffa1b2428119 100644
--- a/Library/Homebrew/cask/cask.rbi
+++ b/Library/Homebrew/cask/cask.rbi
@@ -2,7 +2,7 @@
 
 module Cask
   class Cask
-    def appcast; end
+    def appdir; end
 
     def artifacts; end
 
@@ -14,9 +14,23 @@ module Cask
 
     def container; end
 
+    def depends_on; end
+
     def desc; end
 
-    def depends_on; end
+    def discontinued?; end
+
+    def deprecated?; end
+
+    def deprecation_date; end
+
+    def deprecation_reason; end
+
+    def disabled?; end
+
+    def disable_date; end
+
+    def disable_reason; end
 
     def homepage; end
 
@@ -24,22 +38,24 @@ module Cask
 
     def languages; end
 
+    def livecheck; end
+
+    def livecheckable?; end
+
     def name; end
 
+    def on_system_blocks_exist?; end
+
+    sig { returns(T.nilable(MacOSVersion)) }
+    def on_system_block_min_os; end
+
     def sha256; end
 
     def staged_path; end
 
+    sig { returns(T.nilable(::Cask::URL)) }
     def url; end
 
     def version; end
-
-    def appdir; end
-
-    def discontinued?; end
-
-    def livecheck; end
-
-    def livecheckable?; end
   end
 end
diff --git a/Library/Homebrew/cask/cask_loader.rb b/Library/Homebrew/cask/cask_loader.rb
index 8049077ee6280..a91882a6e5049 100644
--- a/Library/Homebrew/cask/cask_loader.rb
+++ b/Library/Homebrew/cask/cask_loader.rb
@@ -1,34 +1,84 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/cache"
 require "cask/cask"
 require "uri"
+require "utils/curl"
+require "extend/hash/keys"
 
 module Cask
   # Loads a cask from various sources.
-  #
-  # @api private
   module CaskLoader
+    extend Context
+
+    ALLOWED_URL_SCHEMES = %w[file].freeze
+    private_constant :ALLOWED_URL_SCHEMES
+
+    module ILoader
+      extend T::Helpers
+      interface!
+
+      sig { abstract.params(config: T.nilable(Config)).returns(Cask) }
+      def load(config:); end
+    end
+
     # Loads a cask from a string.
-    class FromContentLoader
+    class AbstractContentLoader
+      include ILoader
+      extend T::Helpers
+      abstract!
+
+      sig { returns(String) }
       attr_reader :content
 
-      def self.can_load?(ref)
-        return false unless ref.respond_to?(:to_str)
+      sig { returns(T.nilable(Tap)) }
+      attr_reader :tap
+
+      private
+
+      sig {
+        overridable.params(
+          header_token: String,
+          options:      T.untyped,
+          block:        T.nilable(T.proc.bind(DSL).void),
+        ).returns(Cask)
+      }
+      def cask(header_token, **options, &block)
+        Cask.new(header_token, source: content, tap:, **options, config: @config, &block)
+      end
+    end
+
+    # Loads a cask from a string.
+    class FromContentLoader < AbstractContentLoader
+      sig {
+        params(ref: T.any(Pathname, String, Cask, URI::Generic), warn: T::Boolean)
+          .returns(T.nilable(T.attached_class))
+      }
+      def self.try_new(ref, warn: false)
+        return if ref.is_a?(Cask)
 
         content = ref.to_str
 
-        token  = /(?:"[^"]*"|'[^']*')/
-        curly  = /\(\s*#{token.source}\s*\)\s*\{.*\}/
-        do_end = /\s+#{token.source}\s+do(?:\s*;\s*|\s+).*end/
-        regex  = /\A\s*cask(?:#{curly.source}|#{do_end.source})\s*\Z/m
+        # Cache compiled regex
+        @regex ||= begin
+          token  = /(?:"[^"]*"|'[^']*')/
+          curly  = /\(\s*#{token.source}\s*\)\s*\{.*\}/
+          do_end = /\s+#{token.source}\s+do(?:\s*;\s*|\s+).*end/
+          /\A\s*cask(?:#{curly.source}|#{do_end.source})\s*\Z/m
+        end
 
-        content.match?(regex)
+        return unless content.match?(@regex)
+
+        new(content)
       end
 
-      def initialize(content)
-        @content = content.force_encoding("UTF-8")
+      sig { params(content: String, tap: Tap).void }
+      def initialize(content, tap: T.unsafe(nil))
+        super()
+
+        @content = content.dup.force_encoding("UTF-8")
+        @tap = tap
       end
 
       def load(config:)
@@ -36,30 +86,47 @@ def load(config:)
 
         instance_eval(content, __FILE__, __LINE__)
       end
-
-      private
-
-      def cask(header_token, **options, &block)
-        Cask.new(header_token, source: content, **options, config: @config, &block)
-      end
     end
 
     # Loads a cask from a path.
-    class FromPathLoader < FromContentLoader
-      def self.can_load?(ref)
-        path = Pathname(ref)
-        path.extname == ".rb" && path.expand_path.exist?
+    class FromPathLoader < AbstractContentLoader
+      sig {
+        overridable.params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean)
+                   .returns(T.nilable(T.attached_class))
+      }
+      def self.try_new(ref, warn: false)
+        path = case ref
+        when String
+          Pathname(ref)
+        when Pathname
+          ref
+        else
+          return
+        end
+
+        return if %w[.rb .json].exclude?(path.extname)
+        return unless path.expand_path.exist?
+
+        return if Homebrew::EnvConfig.forbid_packages_from_paths? &&
+                  !path.realpath.to_s.start_with?("#{Caskroom.path}/", "#{HOMEBREW_LIBRARY}/Taps/")
+
+        new(path)
       end
 
       attr_reader :token, :path
 
-      def initialize(path) # rubocop:disable Lint/MissingSuper
+      sig { params(path: T.any(Pathname, String), token: String).void }
+      def initialize(path, token: T.unsafe(nil))
+        super()
+
         path = Pathname(path).expand_path
 
-        @token = path.basename(".rb").to_s
+        @token = path.basename(path.extname).to_s
         @path = path
+        @tap = Tap.from_path(path) || Homebrew::API.tap_from_source_download(path)
       end
 
+      sig { override.params(config: T.nilable(Config)).returns(Cask) }
       def load(config:)
         raise CaskUnavailableError.new(token, "'#{path}' does not exist.")  unless path.exist?
         raise CaskUnavailableError.new(token, "'#{path}' is not readable.") unless path.readable?
@@ -68,6 +135,10 @@ def load(config:)
         @content = path.read(encoding: "UTF-8")
         @config = config
 
+        if path.extname == ".json"
+          return FromAPILoader.new(token, from_json: JSON.parse(@content), path:).load(config:)
+        end
+
         begin
           instance_eval(content, path).tap do |cask|
             raise CaskUnreadableError.new(token, "'#{path}' does not contain a cask.") unless cask.is_a?(Cask)
@@ -90,33 +161,50 @@ def cask(header_token, **options, &block)
 
     # Loads a cask from a URI.
     class FromURILoader < FromPathLoader
-      extend T::Sig
+      sig {
+        override.params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean)
+                .returns(T.nilable(T.attached_class))
+      }
+      def self.try_new(ref, warn: false)
+        return if Homebrew::EnvConfig.forbid_packages_from_paths?
+
+        # Cache compiled regex
+        @uri_regex ||= begin
+          uri_regex = ::URI::DEFAULT_PARSER.make_regexp
+          Regexp.new("\\A#{uri_regex.source}\\Z", uri_regex.options)
+        end
 
-      def self.can_load?(ref)
-        uri_regex = ::URI::DEFAULT_PARSER.make_regexp
-        return false unless ref.to_s.match?(Regexp.new("\\A#{uri_regex.source}\\Z", uri_regex.options))
+        uri = ref.to_s
+        return unless uri.match?(@uri_regex)
 
-        uri = URI(ref)
-        return false unless uri
-        return false unless uri.path
+        uri = URI(uri)
+        return unless uri.path
 
-        true
+        new(uri)
       end
 
-      attr_reader :url
+      attr_reader :url, :name
 
       sig { params(url: T.any(URI::Generic, String)).void }
       def initialize(url)
         @url = URI(url)
-        super Cache.path/File.basename(@url.path)
+        @name = File.basename(T.must(@url.path))
+        super Cache.path/name
       end
 
       def load(config:)
         path.dirname.mkpath
 
+        if ALLOWED_URL_SCHEMES.exclude?(url.scheme)
+          raise UnsupportedInstallationMethod,
+                "Non-checksummed download of #{name} formula file from an arbitrary URL is unsupported! " \
+                "`brew extract` or `brew create` and `brew tap-new` to create a formula file in a tap " \
+                "on GitHub instead."
+        end
+
         begin
           ohai "Downloading #{url}"
-          curl_download url, to: path
+          ::Utils::Curl.curl_download url, to: path
         rescue ErrorDuringExecution
           raise CaskUnavailableError.new(token, "Failed to download #{Formatter.url(url)}.")
         end
@@ -125,39 +213,40 @@ def load(config:)
       end
     end
 
-    # Loads a cask from a tap path.
-    class FromTapPathLoader < FromPathLoader
-      def self.can_load?(ref)
-        super && !Tap.from_path(ref).nil?
-      end
-
+    # Loads a cask from a specific tap.
+    class FromTapLoader < FromPathLoader
+      sig { returns(Tap) }
       attr_reader :tap
 
-      def initialize(path)
-        @tap = Tap.from_path(path)
-        super(path)
-      end
+      sig {
+        override(allow_incompatible: true) # rubocop:todo Sorbet/AllowIncompatibleOverride
+          .params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean)
+          .returns(T.nilable(T.any(T.attached_class, FromAPILoader)))
+      }
+      def self.try_new(ref, warn: false)
+        ref = ref.to_s
 
-      private
+        return unless (token_tap_type = CaskLoader.tap_cask_token_type(ref, warn:))
 
-      def cask(*args, &block)
-        super(*args, tap: tap, &block)
-      end
-    end
+        token, tap, type = token_tap_type
 
-    # Loads a cask from a specific tap.
-    class FromTapLoader < FromTapPathLoader
-      def self.can_load?(ref)
-        ref.to_s.match?(HOMEBREW_TAP_CASK_REGEX)
+        if type == :migration && tap.core_cask_tap? && (loader = FromAPILoader.try_new(token))
+          loader
+        else
+          new("#{tap}/#{token}")
+        end
       end
 
-      def initialize(tapped_name)
-        user, repo, token = tapped_name.split("/", 3)
-        super Tap.fetch(user, repo).cask_dir/"#{token}.rb"
+      sig { params(tapped_token: String).void }
+      def initialize(tapped_token)
+        tap, token = Tap.with_cask_token(tapped_token)
+        cask = CaskLoader.find_cask_in_tap(token, tap)
+        super cask
       end
 
+      sig { override.params(config: T.nilable(Config)).returns(Cask) }
       def load(config:)
-        raise TapCaskUnavailableError.new(tap, token) unless tap.installed?
+        raise TapCaskUnavailableError.new(tap, token) unless T.must(tap).installed?
 
         super
       end
@@ -165,10 +254,17 @@ def load(config:)
 
     # Loads a cask from an existing {Cask} instance.
     class FromInstanceLoader
-      def self.can_load?(ref)
-        ref.is_a?(Cask)
+      include ILoader
+
+      sig {
+        params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean)
+          .returns(T.nilable(T.attached_class))
+      }
+      def self.try_new(ref, warn: false)
+        new(ref) if ref.is_a?(Cask)
       end
 
+      sig { params(cask: Cask).void }
       def initialize(cask)
         @cask = cask
       end
@@ -178,12 +274,268 @@ def load(config:)
       end
     end
 
+    # Loads a cask from the JSON API.
+    class FromAPILoader
+      include ILoader
+
+      sig { returns(String) }
+      attr_reader :token
+
+      sig { returns(Pathname) }
+      attr_reader :path
+
+      sig { returns(T.nilable(Hash)) }
+      attr_reader :from_json
+
+      sig {
+        params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean)
+          .returns(T.nilable(T.attached_class))
+      }
+      def self.try_new(ref, warn: false)
+        return if Homebrew::EnvConfig.no_install_from_api?
+        return unless ref.is_a?(String)
+        return unless (token = ref[HOMEBREW_DEFAULT_TAP_CASK_REGEX, :token])
+        if !Homebrew::API::Cask.all_casks.key?(token) &&
+           !Homebrew::API::Cask.all_renames.key?(token)
+          return
+        end
+
+        ref = "#{CoreCaskTap.instance}/#{token}"
+
+        token, tap, = CaskLoader.tap_cask_token_type(ref, warn:)
+        new("#{tap}/#{token}")
+      end
+
+      sig { params(token: String, from_json: Hash, path: T.nilable(Pathname)).void }
+      def initialize(token, from_json: T.unsafe(nil), path: nil)
+        @token = token.sub(%r{^homebrew/(?:homebrew-)?cask/}i, "")
+        @sourcefile_path = path || Homebrew::API::Cask.cached_json_file_path
+        @path = path || CaskLoader.default_path(@token)
+        @from_json = from_json
+      end
+
+      def load(config:)
+        json_cask = from_json || Homebrew::API::Cask.all_casks.fetch(token)
+
+        cask_options = {
+          loaded_from_api: true,
+          sourcefile_path: @sourcefile_path,
+          source:          JSON.pretty_generate(json_cask),
+          config:,
+          loader:          self,
+        }
+
+        json_cask = Homebrew::API.merge_variations(json_cask).deep_symbolize_keys.freeze
+
+        cask_options[:tap] = Tap.fetch(json_cask[:tap]) if json_cask[:tap].to_s.include?("/")
+
+        user_agent = json_cask.dig(:url_specs, :user_agent)
+        json_cask[:url_specs][:user_agent] = user_agent[1..].to_sym if user_agent && user_agent[0] == ":"
+        if (using = json_cask.dig(:url_specs, :using))
+          json_cask[:url_specs][:using] = using.to_sym
+        end
+
+        api_cask = Cask.new(token, **cask_options) do
+          version json_cask[:version]
+
+          if json_cask[:sha256] == "no_check"
+            sha256 :no_check
+          else
+            sha256 json_cask[:sha256]
+          end
+
+          url json_cask[:url], **json_cask.fetch(:url_specs, {}) if json_cask[:url].present?
+          json_cask[:name]&.each do |cask_name|
+            name cask_name
+          end
+          desc json_cask[:desc]
+          homepage json_cask[:homepage]
+
+          if (deprecation_date = json_cask[:deprecation_date].presence)
+            reason = DeprecateDisable.to_reason_string_or_symbol json_cask[:deprecation_reason], type: :cask
+            deprecate! date: deprecation_date, because: reason
+          end
+
+          if (disable_date = json_cask[:disable_date].presence)
+            reason = DeprecateDisable.to_reason_string_or_symbol json_cask[:disable_reason], type: :cask
+            disable! date: disable_date, because: reason
+          end
+
+          auto_updates json_cask[:auto_updates] unless json_cask[:auto_updates].nil?
+          conflicts_with(**json_cask[:conflicts_with]) if json_cask[:conflicts_with].present?
+
+          if json_cask[:depends_on].present?
+            dep_hash = json_cask[:depends_on].to_h do |dep_key, dep_value|
+              # Arch dependencies are encoded like `{ type: :intel, bits: 64 }`
+              # but `depends_on arch:` only accepts `:intel` or `:arm64`
+              if dep_key == :arch
+                next [:arch, :intel] if dep_value.first[:type] == "intel"
+
+                next [:arch, :arm64]
+              end
+
+              next [dep_key, dep_value] if dep_key != :macos
+
+              dep_type = dep_value.keys.first
+              if dep_type == :==
+                version_symbols = dep_value[dep_type].map do |version|
+                  MacOSVersion::SYMBOLS.key(version) || version
+                end
+                next [dep_key, version_symbols]
+              end
+
+              version_symbol = dep_value[dep_type].first
+              version_symbol = MacOSVersion::SYMBOLS.key(version_symbol) || version_symbol
+              [dep_key, "#{dep_type} :#{version_symbol}"]
+            end.compact
+            depends_on(**dep_hash)
+          end
+
+          if json_cask[:container].present?
+            container_hash = json_cask[:container].to_h do |container_key, container_value|
+              next [container_key, container_value] if container_key != :type
+
+              [container_key, container_value.to_sym]
+            end
+            container(**container_hash)
+          end
+
+          json_cask[:artifacts].each do |artifact|
+            # convert generic string replacements into actual ones
+            artifact = cask.loader.from_h_gsubs(artifact, appdir)
+            key = artifact.keys.first
+            if artifact[key].nil?
+              # for artifacts with blocks that can't be loaded from the API
+              send(key) {} # empty on purpose
+            else
+              args = artifact[key]
+              kwargs = if args.last.is_a?(Hash)
+                args.pop
+              else
+                {}
+              end
+              send(key, *args, **kwargs)
+            end
+          end
+
+          if json_cask[:caveats].present?
+            # convert generic string replacements into actual ones
+            caveats cask.loader.from_h_string_gsubs(json_cask[:caveats], appdir)
+          end
+        end
+        api_cask.populate_from_api!(json_cask)
+        api_cask
+      end
+
+      def from_h_string_gsubs(string, appdir)
+        string.to_s
+              .gsub(HOMEBREW_HOME_PLACEHOLDER, Dir.home)
+              .gsub(HOMEBREW_PREFIX_PLACEHOLDER, HOMEBREW_PREFIX)
+              .gsub(HOMEBREW_CELLAR_PLACEHOLDER, HOMEBREW_CELLAR)
+              .gsub(HOMEBREW_CASK_APPDIR_PLACEHOLDER, appdir)
+      end
+
+      def from_h_array_gsubs(array, appdir)
+        array.to_a.map do |value|
+          from_h_gsubs(value, appdir)
+        end
+      end
+
+      def from_h_hash_gsubs(hash, appdir)
+        hash.to_h.transform_values do |value|
+          from_h_gsubs(value, appdir)
+        end
+      end
+
+      def from_h_gsubs(value, appdir)
+        return value if value.blank?
+
+        case value
+        when Hash
+          from_h_hash_gsubs(value, appdir)
+        when Array
+          from_h_array_gsubs(value, appdir)
+        when String
+          from_h_string_gsubs(value, appdir)
+        else
+          value
+        end
+      end
+    end
+
+    # Loader which tries loading casks from tap paths, failing
+    # if the same token exists in multiple taps.
+    class FromNameLoader < FromTapLoader
+      sig {
+        override.params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean)
+                .returns(T.nilable(T.any(T.attached_class, FromAPILoader)))
+      }
+      def self.try_new(ref, warn: false)
+        return unless ref.is_a?(String)
+        return unless ref.match?(/\A#{HOMEBREW_TAP_CASK_TOKEN_REGEX}\Z/o)
+
+        token = ref
+
+        # If it exists in the default tap, never treat it as ambiguous with another tap.
+        if (core_cask_tap = CoreCaskTap.instance).installed? &&
+           (core_cask_loader = super("#{core_cask_tap}/#{token}", warn:))&.path&.exist?
+          return core_cask_loader
+        end
+
+        loaders = Tap.select { |tap| tap.installed? && !tap.core_cask_tap? }
+                     .filter_map { |tap| super("#{tap}/#{token}", warn:) }
+                     .uniq(&:path)
+                     .select { |loader| loader.is_a?(FromAPILoader) || loader.path.exist? }
+
+        case loaders.count
+        when 1
+          loaders.first
+        when 2..Float::INFINITY
+          raise TapCaskAmbiguityError.new(token, loaders)
+        end
+      end
+    end
+
+    # Loader which loads a cask from the installed cask file.
+    class FromInstalledPathLoader < FromPathLoader
+      sig {
+        override.params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean)
+                .returns(T.nilable(T.attached_class))
+      }
+      def self.try_new(ref, warn: false)
+        token = if ref.is_a?(String)
+          ref
+        elsif ref.is_a?(Pathname)
+          ref.basename(ref.extname).to_s
+        end
+        return unless token
+
+        possible_installed_cask = Cask.new(token)
+        return unless (installed_caskfile = possible_installed_cask.installed_caskfile)
+
+        new(installed_caskfile)
+      end
+
+      sig { params(path: T.any(Pathname, String), token: String).void }
+      def initialize(path, token: "")
+        super
+
+        installed_tap = Cask.new(@token).tab.tap
+        @tap = installed_tap if installed_tap
+      end
+    end
+
     # Pseudo-loader which raises an error when trying to load the corresponding cask.
     class NullLoader < FromPathLoader
-      extend T::Sig
-
-      def self.can_load?(*)
-        true
+      sig {
+        override.params(ref: T.any(String, Pathname, Cask, URI::Generic), warn: T::Boolean)
+                .returns(T.nilable(T.attached_class))
+      }
+      def self.try_new(ref, warn: false)
+        return if ref.is_a?(Cask)
+        return if ref.is_a?(URI::Generic)
+
+        new(ref)
       end
 
       sig { params(ref: T.any(String, Pathname)).void }
@@ -198,60 +550,101 @@ def load(config:)
     end
 
     def self.path(ref)
-      self.for(ref).path
+      self.for(ref, need_path: true).path
+    end
+
+    def self.load(ref, config: nil, warn: true)
+      self.for(ref, warn:).load(config:)
     end
 
-    def self.load(ref, config: nil)
-      self.for(ref).load(config: config)
+    sig { params(tapped_token: String, warn: T::Boolean).returns(T.nilable([String, Tap, T.nilable(Symbol)])) }
+    def self.tap_cask_token_type(tapped_token, warn:)
+      return unless (tap_with_token = Tap.with_cask_token(tapped_token))
+
+      tap, token = tap_with_token
+
+      type = nil
+
+      if (new_token = tap.cask_renames[token].presence)
+        old_token = tap.core_cask_tap? ? token : tapped_token
+        token = new_token
+        new_token = tap.core_cask_tap? ? token : "#{tap}/#{token}"
+        type = :rename
+      elsif (new_tap_name = tap.tap_migrations[token].presence)
+        new_tap, new_token = Tap.with_cask_token(new_tap_name) || [Tap.fetch(new_tap_name), token]
+        new_tap.ensure_installed!
+        new_tapped_token = "#{new_tap}/#{new_token}"
+
+        if tapped_token == new_tapped_token
+          opoo "Tap migration for #{tapped_token} points to itself, stopping recursion."
+        else
+          old_token = tap.core_cask_tap? ? token : tapped_token
+          return unless (token_tap_type = tap_cask_token_type(new_tapped_token, warn: false))
+
+          token, tap, = token_tap_type
+          new_token = new_tap.core_cask_tap? ? token : "#{tap}/#{token}"
+          type = :migration
+        end
+      end
+
+      opoo "Cask #{old_token} was renamed to #{new_token}." if warn && old_token && new_token
+
+      [token, tap, type]
     end
 
-    def self.for(ref)
+    def self.for(ref, need_path: false, warn: true)
       [
         FromInstanceLoader,
         FromContentLoader,
         FromURILoader,
+        FromAPILoader,
         FromTapLoader,
-        FromTapPathLoader,
+        FromNameLoader,
         FromPathLoader,
+        FromInstalledPathLoader,
+        NullLoader,
       ].each do |loader_class|
-        next unless loader_class.can_load?(ref)
-
-        if loader_class == FromTapLoader && Homebrew::EnvConfig.install_from_api? &&
-           ref.start_with?("homebrew/cask/") && Homebrew::API::CaskSource.available?(ref)
-          return FromContentLoader.new(Homebrew::API::CaskSource.fetch(ref))
+        if (loader = loader_class.try_new(ref, warn:))
+          $stderr.puts "#{$PROGRAM_NAME} (#{loader.class}): loading #{ref}" if debug?
+          return loader
         end
-
-        return loader_class.new(ref)
       end
+    end
 
-      if Homebrew::EnvConfig.install_from_api? && Homebrew::API::CaskSource.available?(ref)
-        return FromContentLoader.new(Homebrew::API::CaskSource.fetch(ref))
-      end
-
-      return FromTapPathLoader.new(default_path(ref)) if FromTapPathLoader.can_load?(default_path(ref))
-
-      case (possible_tap_casks = tap_paths(ref)).count
-      when 1
-        return FromTapPathLoader.new(possible_tap_casks.first)
-      when 2..Float::INFINITY
-        loaders = possible_tap_casks.map(&FromTapPathLoader.method(:new))
+    sig { params(ref: String, config: T.nilable(Config), warn: T::Boolean).returns(Cask) }
+    def self.load_prefer_installed(ref, config: nil, warn: true)
+      tap, token = Tap.with_cask_token(ref)
+      token ||= ref
+      tap ||= Cask.new(ref).tab.tap
 
-        raise TapCaskAmbiguityError.new(ref, loaders)
+      if tap.nil?
+        self.load(token, config:, warn:)
+      else
+        begin
+          self.load("#{tap}/#{token}", config:, warn:)
+        rescue CaskUnavailableError
+          # cask may be migrated to different tap. Try to search in all taps.
+          self.load(token, config:, warn:)
+        end
       end
+    end
 
-      possible_installed_cask = Cask.new(ref)
-      return FromPathLoader.new(possible_installed_cask.installed_caskfile) if possible_installed_cask.installed?
+    sig { params(path: Pathname, config: T.nilable(Config), warn: T::Boolean).returns(Cask) }
+    def self.load_from_installed_caskfile(path, config: nil, warn: true)
+      loader = FromInstalledPathLoader.try_new(path, warn:)
+      loader ||= NullLoader.new(path)
 
-      NullLoader.new(ref)
+      loader.load(config:)
     end
 
     def self.default_path(token)
-      Tap.default_cask_tap.cask_dir/"#{token.to_s.downcase}.rb"
+      find_cask_in_tap(token.to_s.downcase, CoreCaskTap.instance)
     end
 
-    def self.tap_paths(token)
-      Tap.map { |t| t.cask_dir/"#{token.to_s.downcase}.rb" }
-         .select(&:exist?)
+    def self.find_cask_in_tap(token, tap)
+      filename = "#{token}.rb"
+
+      tap.cask_files_by_name.fetch(token, tap.cask_dir/filename)
     end
   end
 end
diff --git a/Library/Homebrew/cask/caskroom.rb b/Library/Homebrew/cask/caskroom.rb
index 1d35d466d74ce..321b2997eb4e0 100644
--- a/Library/Homebrew/cask/caskroom.rb
+++ b/Library/Homebrew/cask/caskroom.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "utils/user"
@@ -6,20 +6,31 @@
 module Cask
   # Helper functions for interacting with the `Caskroom` directory.
   #
-  # @api private
+  # @api internal
   module Caskroom
-    extend T::Sig
-
     sig { returns(Pathname) }
     def self.path
       @path ||= HOMEBREW_PREFIX/"Caskroom"
     end
 
+    # Return all paths for installed casks.
+    sig { returns(T::Array[Pathname]) }
+    def self.paths
+      return [] unless path.exist?
+
+      path.children.select { |p| p.directory? && !p.symlink? }
+    end
+    private_class_method :paths
+
+    # Return all tokens for installed casks.
+    sig { returns(T::Array[String]) }
+    def self.tokens
+      paths.map { |path| path.basename.to_s }
+    end
+
     sig { returns(T::Boolean) }
     def self.any_casks_installed?
-      return false unless path.exist?
-
-      path.children.select(&:directory?).any?
+      paths.any?
     end
 
     sig { void }
@@ -33,29 +44,25 @@ def self.ensure_caskroom_exists
              "We'll set permissions properly so we won't need sudo in the future."
       end
 
-      SystemCommand.run("/bin/mkdir", args: ["-p", path], sudo: sudo)
-      SystemCommand.run("/bin/chmod", args: ["g+rwx", path], sudo: sudo)
-      SystemCommand.run("/usr/sbin/chown", args: [User.current, path], sudo: sudo)
-      SystemCommand.run("/usr/bin/chgrp", args: ["admin", path], sudo: sudo)
+      SystemCommand.run("/bin/mkdir", args: ["-p", path], sudo:)
+      SystemCommand.run("/bin/chmod", args: ["g+rwx", path], sudo:)
+      SystemCommand.run("/usr/sbin/chown", args: [User.current, path], sudo:)
+      SystemCommand.run("/usr/bin/chgrp", args: ["admin", path], sudo:)
     end
 
+    # Get all installed casks.
+    #
+    # @api internal
     sig { params(config: T.nilable(Config)).returns(T::Array[Cask]) }
     def self.casks(config: nil)
-      return [] unless path.exist?
-
-      path.children.select(&:directory?).sort.map do |path|
-        token = path.basename.to_s
-
-        begin
-          CaskLoader.load(token, config: config)
-        rescue TapCaskAmbiguityError
-          tap_path = CaskLoader.tap_paths(token).first
-          CaskLoader::FromTapPathLoader.new(tap_path).load(config: config)
-        rescue CaskUnavailableError
-          # Don't blow up because of a single unavailable cask.
-          nil
-        end
-      end.compact
+      tokens.sort.filter_map do |token|
+        CaskLoader.load_prefer_installed(token, config:, warn: false)
+      rescue TapCaskAmbiguityError => e
+        T.must(e.loaders.first).load(config:)
+      rescue
+        # Don't blow up because of a single unavailable cask.
+        nil
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cask/cmd.rb b/Library/Homebrew/cask/cmd.rb
deleted file mode 100644
index 1956cc445377e..0000000000000
--- a/Library/Homebrew/cask/cmd.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "optparse"
-require "shellwords"
-
-require "cli/parser"
-require "extend/optparse"
-
-require "cask/config"
-
-require "cask/cmd/abstract_command"
-require "cask/cmd/audit"
-require "cask/cmd/fetch"
-require "cask/cmd/info"
-require "cask/cmd/install"
-require "cask/cmd/list"
-require "cask/cmd/reinstall"
-require "cask/cmd/uninstall"
-require "cask/cmd/upgrade"
-require "cask/cmd/zap"
-
-module Cask
-  # Implementation of the `brew cask` command-line interface.
-  #
-  # @api private
-  class Cmd
-    extend T::Sig
-
-    include Context
-
-    def self.parser(&block)
-      Homebrew::CLI::Parser.new do
-        instance_eval(&block) if block
-
-        cask_options
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/cask/cmd/abstract_command.rb b/Library/Homebrew/cask/cmd/abstract_command.rb
deleted file mode 100644
index 6c93a9e49f674..0000000000000
--- a/Library/Homebrew/cask/cmd/abstract_command.rb
+++ /dev/null
@@ -1,99 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "search"
-
-module Cask
-  class Cmd
-    # Abstract superclass for all Cask implementations of commands.
-    #
-    # @api private
-    class AbstractCommand
-      extend T::Sig
-      extend T::Helpers
-
-      include Homebrew::Search
-
-      OPTIONS = [
-        [:switch, "--[no-]binaries", {
-          description: "Disable/enable linking of helper executables (default: enabled).",
-          env:         :cask_opts_binaries,
-        }],
-        [:switch, "--require-sha",  {
-          description: "Require all casks to have a checksum.",
-          env:         :cask_opts_require_sha,
-        }],
-        [:switch, "--[no-]quarantine", {
-          description: "Disable/enable quarantining of downloads (default: enabled).",
-          env:         :cask_opts_quarantine,
-        }],
-      ].freeze
-
-      def self.parser(&block)
-        Cmd.parser do
-          instance_eval(&block) if block
-
-          OPTIONS.each do |option|
-            send(*option)
-          end
-        end
-      end
-
-      sig { returns(String) }
-      def self.command_name
-        @command_name ||= name.sub(/^.*:/, "").gsub(/(.)([A-Z])/, '\1_\2').downcase
-      end
-
-      sig { returns(T::Boolean) }
-      def self.abstract?
-        name.split("::").last.match?(/^Abstract[^a-z]/)
-      end
-
-      sig { returns(T::Boolean) }
-      def self.visible?
-        true
-      end
-
-      sig { returns(String) }
-      def self.help
-        parser.generate_help_text
-      end
-
-      sig { returns(String) }
-      def self.short_description
-        description[/\A[^.]*\./]
-      end
-
-      def self.run(*args)
-        new(*args).run
-      end
-
-      attr_reader :args
-
-      def initialize(*args)
-        @args = self.class.parser.parse(args)
-      end
-
-      private
-
-      def casks(alternative: -> { [] })
-        return @casks if defined?(@casks)
-
-        @casks = args.named.empty? ? alternative.call : args.named.to_casks
-      rescue CaskUnavailableError => e
-        reason = [e.reason, *suggestion_message(e.token)].join(" ")
-        raise e.class.new(e.token, reason)
-      end
-
-      def suggestion_message(cask_token)
-        matches = search_casks(cask_token)
-
-        if matches.one?
-          "Did you mean '#{matches.first}'?"
-        elsif !matches.empty?
-          "Did you mean one of these?\n#{Formatter.columns(matches.take(20))}"
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/cask/cmd/audit.rb b/Library/Homebrew/cask/cmd/audit.rb
deleted file mode 100644
index 516f4199bd58e..0000000000000
--- a/Library/Homebrew/cask/cmd/audit.rb
+++ /dev/null
@@ -1,109 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "utils/github/actions"
-
-module Cask
-  class Cmd
-    # Cask implementation of the `brew audit` command.
-    #
-    # @api private
-    class Audit < AbstractCommand
-      extend T::Sig
-
-      def self.parser
-        super do
-          switch "--[no-]download",
-                 description: "Audit the downloaded file"
-          switch "--[no-]appcast",
-                 description: "Audit the appcast"
-          switch "--[no-]token-conflicts",
-                 description: "Audit for token conflicts"
-          switch "--[no-]strict",
-                 description: "Run additional, stricter style checks"
-          switch "--[no-]online",
-                 description: "Run additional, slower style checks that require a network connection"
-          switch "--new-cask",
-                 description: "Run various additional style checks to determine if a new cask is eligible " \
-                              "for Homebrew. This should be used when creating new casks and implies " \
-                              "`--strict` and `--online`"
-          switch "--display-failures-only",
-                 description: "Only display casks that fail the audit. This is the default for formulae."
-        end
-      end
-
-      sig { void }
-      def run
-        casks = args.named.flat_map do |name|
-          next name if File.exist?(name)
-          next Tap.fetch(name).cask_files if name.count("/") == 1
-
-          name
-        end
-        casks = casks.map { |c| CaskLoader.load(c, config: Config.from_args(args)) }
-        any_named_args = casks.any?
-        casks = Cask.to_a if casks.empty?
-
-        results = self.class.audit_casks(
-          *casks,
-          download:              args.download?,
-          appcast:               args.appcast?,
-          online:                args.online?,
-          strict:                args.strict?,
-          new_cask:              args.new_cask?,
-          token_conflicts:       args.token_conflicts?,
-          quarantine:            args.quarantine?,
-          any_named_args:        any_named_args,
-          language:              args.language,
-          display_passes:        args.verbose? || args.named.count == 1,
-          display_failures_only: args.display_failures_only?,
-        )
-
-        failed_casks = results.reject { |_, result| result[:errors].empty? }.map(&:first)
-        return if failed_casks.empty?
-
-        raise CaskError, "audit failed for casks: #{failed_casks.join(" ")}"
-      end
-
-      def self.audit_casks(
-        *casks,
-        download: nil,
-        appcast: nil,
-        online: nil,
-        strict: nil,
-        new_cask: nil,
-        token_conflicts: nil,
-        quarantine: nil,
-        any_named_args: nil,
-        language: nil,
-        display_passes: nil,
-        display_failures_only: nil
-      )
-        options = {
-          audit_download:        download,
-          audit_appcast:         appcast,
-          audit_online:          online,
-          audit_strict:          strict,
-          audit_new_cask:        new_cask,
-          audit_token_conflicts: token_conflicts,
-          quarantine:            quarantine,
-          language:              language,
-          any_named_args:        any_named_args,
-          display_passes:        display_passes,
-          display_failures_only: display_failures_only,
-        }.compact
-
-        options[:quarantine] = true if options[:quarantine].nil?
-
-        Homebrew.auditing = true
-
-        require "cask/auditor"
-
-        casks.to_h do |cask|
-          odebug "Auditing Cask #{cask}"
-          [cask.sourcefile_path, Auditor.audit(cask, **options)]
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/cask/cmd/fetch.rb b/Library/Homebrew/cask/cmd/fetch.rb
deleted file mode 100644
index da0eb66295629..0000000000000
--- a/Library/Homebrew/cask/cmd/fetch.rb
+++ /dev/null
@@ -1,41 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-module Cask
-  class Cmd
-    # Cask implementation of the `brew fetch` command.
-    #
-    # @api private
-    class Fetch < AbstractCommand
-      extend T::Sig
-
-      def self.parser
-        super do
-          switch "--force",
-                 description: "Force redownloading even if files already exist in local cache."
-        end
-      end
-
-      sig { void }
-      def run
-        require "cask/download"
-        require "cask/installer"
-
-        options = {
-          quarantine: args.quarantine?,
-        }.compact
-
-        options[:quarantine] = true if options[:quarantine].nil?
-
-        casks.each do |cask|
-          puts Installer.caveats(cask)
-          ohai "Downloading external files for Cask #{cask}"
-          download = Download.new(cask, **options)
-          download.clear_cache if args.force?
-          downloaded_path = download.fetch
-          ohai "Success! Downloaded to: #{downloaded_path}"
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/cask/cmd/info.rb b/Library/Homebrew/cask/cmd/info.rb
deleted file mode 100644
index c5d4d9a410153..0000000000000
--- a/Library/Homebrew/cask/cmd/info.rb
+++ /dev/null
@@ -1,154 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "json"
-
-module Cask
-  class Cmd
-    # Cask implementation of the `brew info` command.
-    #
-    # @api private
-    class Info < AbstractCommand
-      extend T::Sig
-
-      def self.parser
-        super do
-          flag   "--json=",
-                 description: "Output information in JSON format."
-          switch "--github",
-                 description: "Open the GitHub source page for <Cask> in a browser. "
-        end
-      end
-
-      def github_info(cask)
-        sourcefile_path = cask.sourcefile_path
-        dir = cask.tap.path
-        path = sourcefile_path.relative_path_from(dir)
-        remote = cask.tap.remote
-        github_remote_path(remote, path)
-      end
-
-      def github_remote_path(remote, path)
-        if remote =~ %r{^(?:https?://|git(?:@|://))github\.com[:/](.+)/(.+?)(?:\.git)?$}
-          "https://github.com/#{Regexp.last_match(1)}/#{Regexp.last_match(2)}/blob/HEAD/#{path}"
-        else
-          "#{remote}/#{path}"
-        end
-      end
-
-      sig { void }
-      def run
-        if args.json == "v1"
-          puts JSON.pretty_generate(args.named.to_casks.map(&:to_h))
-        elsif args.github?
-          raise CaskUnspecifiedError if args.no_named?
-
-          args.named.to_casks.map do |cask|
-            exec_browser(github_info(cask))
-          end
-        else
-          args.named.to_casks.each_with_index do |cask, i|
-            puts unless i.zero?
-            odebug "Getting info for Cask #{cask}"
-            self.class.info(cask)
-          end
-        end
-      end
-
-      def self.get_info(cask)
-        require "cask/installer"
-
-        output = +"#{title_info(cask)}\n"
-        output << "#{Formatter.url(cask.homepage)}\n" if cask.homepage
-        output << installation_info(cask)
-        repo = repo_info(cask)
-        output << "#{repo}\n" if repo
-        output << name_info(cask)
-        output << desc_info(cask)
-        language = language_info(cask)
-        output << language if language
-        output << "#{artifact_info(cask)}\n"
-        caveats = Installer.caveats(cask)
-        output << caveats if caveats
-        output
-      end
-
-      def self.info(cask)
-        puts get_info(cask)
-        ::Utils::Analytics.cask_output(cask, args: Homebrew::CLI::Args.new)
-      end
-
-      def self.title_info(cask)
-        title = "#{cask.token}: #{cask.version}"
-        title += " (auto_updates)" if cask.auto_updates
-        title
-      end
-
-      def self.formatted_url(url)
-        "#{Tty.underline}#{url}#{Tty.reset}"
-      end
-
-      def self.installation_info(cask)
-        return "Not installed\n" unless cask.installed?
-
-        install_info = +""
-        cask.versions.each do |version|
-          versioned_staged_path = cask.caskroom_path.join(version)
-          path_details = if versioned_staged_path.exist?
-            versioned_staged_path.abv
-          else
-            Formatter.error("does not exist")
-          end
-          install_info << "#{versioned_staged_path} (#{path_details})\n"
-        end
-        install_info.freeze
-      end
-
-      def self.name_info(cask)
-        <<~EOS
-          #{ohai_title((cask.name.size > 1) ? "Names" : "Name")}
-          #{cask.name.empty? ? Formatter.error("None") : cask.name.join("\n")}
-        EOS
-      end
-
-      def self.desc_info(cask)
-        <<~EOS
-          #{ohai_title("Description")}
-          #{cask.desc.nil? ? Formatter.error("None") : cask.desc}
-        EOS
-      end
-
-      def self.language_info(cask)
-        return if cask.languages.empty?
-
-        <<~EOS
-          #{ohai_title("Languages")}
-          #{cask.languages.join(", ")}
-        EOS
-      end
-
-      def self.repo_info(cask)
-        return if cask.tap.nil?
-
-        url = if cask.tap.custom_remote? && !cask.tap.remote.nil?
-          cask.tap.remote
-        else
-          "#{cask.tap.default_remote}/blob/HEAD/Casks/#{cask.token}.rb"
-        end
-
-        "From: #{Formatter.url(url)}"
-      end
-
-      def self.artifact_info(cask)
-        artifact_output = ohai_title("Artifacts").dup
-        cask.artifacts.each do |artifact|
-          next unless artifact.respond_to?(:install_phase)
-          next unless DSL::ORDINARY_ARTIFACT_CLASSES.include?(artifact.class)
-
-          artifact_output << "\n" << artifact.to_s
-        end
-        artifact_output.freeze
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/cask/cmd/install.rb b/Library/Homebrew/cask/cmd/install.rb
deleted file mode 100644
index 69bd9d80fab2d..0000000000000
--- a/Library/Homebrew/cask/cmd/install.rb
+++ /dev/null
@@ -1,86 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-module Cask
-  class Cmd
-    # Cask implementation of the `brew install` command.
-    #
-    # @api private
-    class Install < AbstractCommand
-      extend T::Sig
-
-      OPTIONS = [
-        [:switch, "--skip-cask-deps", {
-          description: "Skip installing cask dependencies.",
-        }],
-        [:switch, "--zap", {
-          description: "For use with `brew reinstall --cask`. Remove all files associated with a cask. " \
-                       "*May remove files which are shared between applications.*",
-        }],
-      ].freeze
-
-      def self.parser(&block)
-        super do
-          switch "--force",
-                 description: "Force overwriting existing files."
-
-          OPTIONS.each do |option|
-            send(*option)
-          end
-
-          instance_eval(&block) if block
-        end
-      end
-
-      sig { void }
-      def run
-        self.class.install_casks(
-          *casks,
-          binaries:       args.binaries?,
-          verbose:        args.verbose?,
-          force:          args.force?,
-          skip_cask_deps: args.skip_cask_deps?,
-          require_sha:    args.require_sha?,
-          quarantine:     args.quarantine?,
-          quiet:          args.quiet?,
-          zap:            args.zap?,
-        )
-      end
-
-      def self.install_casks(
-        *casks,
-        verbose: nil,
-        force: nil,
-        binaries: nil,
-        skip_cask_deps: nil,
-        require_sha: nil,
-        quarantine: nil,
-        quiet: nil,
-        zap: nil
-      )
-        odie "Installing casks is supported only on macOS" unless OS.mac?
-
-        options = {
-          verbose:        verbose,
-          force:          force,
-          binaries:       binaries,
-          skip_cask_deps: skip_cask_deps,
-          require_sha:    require_sha,
-          quarantine:     quarantine,
-          quiet:          quiet,
-          zap:            zap,
-        }.compact
-
-        options[:quarantine] = true if options[:quarantine].nil?
-
-        require "cask/installer"
-
-        casks.each do |cask|
-          Installer.new(cask, **options).install
-        rescue CaskAlreadyInstalledError => e
-          opoo e.message
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/cask/cmd/list.rb b/Library/Homebrew/cask/cmd/list.rb
deleted file mode 100644
index e38b994d0e731..0000000000000
--- a/Library/Homebrew/cask/cmd/list.rb
+++ /dev/null
@@ -1,81 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "cask/artifact/relocated"
-
-module Cask
-  class Cmd
-    # Cask implementation of the `brew list` command.
-    #
-    # @api private
-    class List < AbstractCommand
-      extend T::Sig
-
-      def self.parser
-        super do
-          switch "-1",
-                 description: "Force output to be one entry per line."
-          switch "--versions",
-                 description: "Show the version number the listed casks."
-          switch "--full-name",
-                 description: "Print casks with fully-qualified names."
-          switch "--json",
-                 description: "Print a JSON representation of the listed casks. "
-        end
-      end
-
-      sig { void }
-      def run
-        self.class.list_casks(
-          *casks,
-          json:      args.json?,
-          one:       args.public_send(:"1?"),
-          full_name: args.full_name?,
-          versions:  args.versions?,
-        )
-      end
-
-      def self.list_casks(*casks, json: false, one: false, full_name: false, versions: false)
-        output = if casks.any?
-          casks.each do |cask|
-            raise CaskNotInstalledError, cask unless cask.installed?
-          end
-        else
-          Caskroom.casks
-        end
-
-        if json
-          puts JSON.pretty_generate(output.map(&:to_h))
-        elsif one
-          puts output.map(&:to_s)
-        elsif full_name
-          puts output.map(&:full_name).sort(&tap_and_name_comparison)
-        elsif versions
-          puts output.map(&method(:format_versioned))
-        elsif !output.empty? && casks.any?
-          output.map(&method(:list_artifacts))
-        elsif !output.empty?
-          puts Formatter.columns(output.map(&:to_s))
-        end
-      end
-
-      def self.list_artifacts(cask)
-        cask.artifacts.group_by(&:class).sort_by { |klass, _| klass.english_name }.each do |klass, artifacts|
-          next if [Artifact::Uninstall, Artifact::Zap].include? klass
-
-          ohai klass.english_name
-          artifacts.each do |artifact|
-            puts artifact.summarize_installed if artifact.respond_to?(:summarize_installed)
-            next if artifact.respond_to?(:summarize_installed)
-
-            puts artifact
-          end
-        end
-      end
-
-      def self.format_versioned(cask)
-        cask.to_s.concat(cask.versions.map(&:to_s).join(" ").prepend(" "))
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/cask/cmd/reinstall.rb b/Library/Homebrew/cask/cmd/reinstall.rb
deleted file mode 100644
index 9637805450032..0000000000000
--- a/Library/Homebrew/cask/cmd/reinstall.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module Cask
-  class Cmd
-    # Cask implementation of the `brew reinstall` command.
-    #
-    # @api private
-    class Reinstall < Install
-      extend T::Sig
-
-      sig { void }
-      def run
-        self.class.reinstall_casks(
-          *casks,
-          binaries:       args.binaries?,
-          verbose:        args.verbose?,
-          force:          args.force?,
-          skip_cask_deps: args.skip_cask_deps?,
-          require_sha:    args.require_sha?,
-          quarantine:     args.quarantine?,
-          zap:            args.zap?,
-        )
-      end
-
-      def self.reinstall_casks(
-        *casks,
-        verbose: nil,
-        force: nil,
-        skip_cask_deps: nil,
-        binaries: nil,
-        require_sha: nil,
-        quarantine: nil,
-        zap: nil
-      )
-        require "cask/installer"
-
-        options = {
-          binaries:       binaries,
-          verbose:        verbose,
-          force:          force,
-          skip_cask_deps: skip_cask_deps,
-          require_sha:    require_sha,
-          quarantine:     quarantine,
-          zap:            zap,
-        }.compact
-
-        options[:quarantine] = true if options[:quarantine].nil?
-
-        casks.each do |cask|
-          Installer.new(cask, **options).reinstall
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/cask/cmd/uninstall.rb b/Library/Homebrew/cask/cmd/uninstall.rb
deleted file mode 100644
index 1ab2c8ce2d2aa..0000000000000
--- a/Library/Homebrew/cask/cmd/uninstall.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-module Cask
-  class Cmd
-    # Cask implementation of the `brew uninstall` command.
-    #
-    # @api private
-    class Uninstall < AbstractCommand
-      extend T::Sig
-
-      def self.parser
-        super do
-          switch "--force",
-                 description: "Uninstall even if the <cask> is not installed, overwrite " \
-                              "existing files and ignore errors when removing files."
-        end
-      end
-
-      sig { void }
-      def run
-        self.class.uninstall_casks(
-          *casks,
-          binaries: args.binaries?,
-          verbose:  args.verbose?,
-          force:    args.force?,
-        )
-      end
-
-      def self.uninstall_casks(*casks, binaries: nil, force: false, verbose: false)
-        require "cask/installer"
-
-        options = {
-          binaries: binaries,
-          force:    force,
-          verbose:  verbose,
-        }.compact
-
-        casks.each do |cask|
-          odebug "Uninstalling Cask #{cask}"
-
-          raise CaskNotInstalledError, cask if !cask.installed? && !force
-
-          Installer.new(cask, **options).uninstall
-
-          next if (versions = cask.versions).empty?
-
-          puts <<~EOS
-            #{cask} #{versions.to_sentence} #{"is".pluralize(versions.count)} still installed.
-            Remove #{(versions.count == 1) ? "it" : "them all"} with `brew uninstall --cask --force #{cask}`.
-          EOS
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/cask/cmd/upgrade.rb b/Library/Homebrew/cask/cmd/upgrade.rb
deleted file mode 100644
index ec97f1dccc56e..0000000000000
--- a/Library/Homebrew/cask/cmd/upgrade.rb
+++ /dev/null
@@ -1,246 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "env_config"
-require "cask/config"
-
-module Cask
-  class Cmd
-    # Cask implementation of the `brew upgrade` command.
-    #
-    # @api private
-    class Upgrade < AbstractCommand
-      extend T::Sig
-
-      OPTIONS = [
-        [:switch, "--skip-cask-deps", {
-          description: "Skip installing cask dependencies.",
-        }],
-        [:switch, "--greedy", {
-          description: "Also include casks with `auto_updates true` or `version :latest`.",
-        }],
-        [:switch, "--greedy-latest", {
-          description: "Also include casks with `version :latest`.",
-        }],
-        [:switch, "--greedy-auto-updates", {
-          description: "Also include casks with `auto_updates true`.",
-        }],
-      ].freeze
-
-      sig { returns(Homebrew::CLI::Parser) }
-      def self.parser
-        super do
-          switch "--force",
-                 description: "Force overwriting existing files."
-          switch "--dry-run",
-                 description: "Show what would be upgraded, but do not actually upgrade anything."
-
-          OPTIONS.each do |option|
-            send(*option)
-          end
-        end
-      end
-
-      sig { void }
-      def run
-        verbose = ($stdout.tty? || args.verbose?) && !args.quiet?
-        self.class.upgrade_casks(
-          *casks,
-          force:               args.force?,
-          greedy:              args.greedy?,
-          greedy_latest:       args.greedy_latest?,
-          greedy_auto_updates: args.greedy_auto_updates?,
-          dry_run:             args.dry_run?,
-          binaries:            args.binaries?,
-          quarantine:          args.quarantine?,
-          require_sha:         args.require_sha?,
-          skip_cask_deps:      args.skip_cask_deps?,
-          verbose:             verbose,
-          args:                args,
-        )
-      end
-
-      sig {
-        params(
-          casks:               Cask,
-          args:                Homebrew::CLI::Args,
-          force:               T.nilable(T::Boolean),
-          greedy:              T.nilable(T::Boolean),
-          greedy_latest:       T.nilable(T::Boolean),
-          greedy_auto_updates: T.nilable(T::Boolean),
-          dry_run:             T.nilable(T::Boolean),
-          skip_cask_deps:      T.nilable(T::Boolean),
-          verbose:             T.nilable(T::Boolean),
-          binaries:            T.nilable(T::Boolean),
-          quarantine:          T.nilable(T::Boolean),
-          require_sha:         T.nilable(T::Boolean),
-        ).returns(T::Boolean)
-      }
-      def self.upgrade_casks(
-        *casks,
-        args:,
-        force: false,
-        greedy: false,
-        greedy_latest: false,
-        greedy_auto_updates: false,
-        dry_run: false,
-        skip_cask_deps: false,
-        verbose: false,
-        binaries: nil,
-        quarantine: nil,
-        require_sha: nil
-      )
-
-        quarantine = true if quarantine.nil?
-
-        outdated_casks = if casks.empty?
-          Caskroom.casks(config: Config.from_args(args)).select do |cask|
-            cask.outdated?(greedy: greedy, greedy_latest: greedy_latest,
-                           greedy_auto_updates: greedy_auto_updates)
-          end
-        else
-          casks.select do |cask|
-            raise CaskNotInstalledError, cask if !cask.installed? && !force
-
-            if cask.outdated?(greedy: true)
-              true
-            elsif cask.version.latest?
-              opoo "Not upgrading #{cask.token}, the downloaded artifact has not changed"
-              false
-            else
-              opoo "Not upgrading #{cask.token}, the latest version is already installed"
-              false
-            end
-          end
-        end
-
-        manual_installer_casks = outdated_casks.select do |cask|
-          cask.artifacts.any?(Artifact::Installer::ManualInstaller)
-        end
-
-        if manual_installer_casks.present?
-          count = manual_installer_casks.count
-          ofail "Not upgrading #{count} `installer manual` #{"cask".pluralize(count)}."
-          puts manual_installer_casks.map(&:to_s)
-          outdated_casks -= manual_installer_casks
-        end
-
-        return false if outdated_casks.empty?
-
-        if casks.empty? && !greedy
-          if !greedy_auto_updates && !greedy_latest
-            ohai "Casks with 'auto_updates true' or 'version :latest' " \
-                 "will not be upgraded; pass `--greedy` to upgrade them."
-          end
-          if greedy_auto_updates && !greedy_latest
-            ohai "Casks with 'version :latest' will not be upgraded; pass `--greedy-latest` to upgrade them."
-          end
-          if !greedy_auto_updates && greedy_latest
-            ohai "Casks with 'auto_updates true' will not be upgraded; pass `--greedy-auto-updates` to upgrade them."
-          end
-        end
-
-        verb = dry_run ? "Would upgrade" : "Upgrading"
-        oh1 "#{verb} #{outdated_casks.count} outdated #{"package".pluralize(outdated_casks.count)}:"
-
-        caught_exceptions = []
-
-        upgradable_casks = outdated_casks.map { |c| [CaskLoader.load(c.installed_caskfile), c] }
-
-        puts upgradable_casks
-          .map { |(old_cask, new_cask)| "#{new_cask.full_name} #{old_cask.version} -> #{new_cask.version}" }
-          .join("\n")
-        return true if dry_run
-
-        upgradable_casks.each do |(old_cask, new_cask)|
-          upgrade_cask(
-            old_cask, new_cask,
-            binaries: binaries, force: force, skip_cask_deps: skip_cask_deps, verbose: verbose,
-            quarantine: quarantine, require_sha: require_sha
-          )
-        rescue => e
-          caught_exceptions << e.exception("#{new_cask.full_name}: #{e}")
-          next
-        end
-
-        return true if caught_exceptions.empty?
-        raise MultipleCaskErrors, caught_exceptions if caught_exceptions.count > 1
-        raise caught_exceptions.first if caught_exceptions.count == 1
-      end
-
-      def self.upgrade_cask(
-        old_cask, new_cask,
-        binaries:, force:, quarantine:, require_sha:, skip_cask_deps:, verbose:
-      )
-        require "cask/installer"
-
-        start_time = Time.now
-        odebug "Started upgrade process for Cask #{old_cask}"
-        old_config = old_cask.config
-
-        old_options = {
-          binaries: binaries,
-          verbose:  verbose,
-          force:    force,
-          upgrade:  true,
-        }.compact
-
-        old_cask_installer =
-          Installer.new(old_cask, **old_options)
-
-        new_cask.config = new_cask.default_config.merge(old_config)
-
-        new_options = {
-          binaries:       binaries,
-          verbose:        verbose,
-          force:          force,
-          skip_cask_deps: skip_cask_deps,
-          require_sha:    require_sha,
-          upgrade:        true,
-          quarantine:     quarantine,
-        }.compact
-
-        new_cask_installer =
-          Installer.new(new_cask, **new_options)
-
-        started_upgrade = false
-        new_artifacts_installed = false
-
-        begin
-          oh1 "Upgrading #{Formatter.identifier(old_cask)}"
-
-          # Start new cask's installation steps
-          new_cask_installer.check_conflicts
-
-          if (caveats = new_cask_installer.caveats)
-            puts caveats
-          end
-
-          new_cask_installer.fetch
-
-          # Move the old cask's artifacts back to staging
-          old_cask_installer.start_upgrade
-          # And flag it so in case of error
-          started_upgrade = true
-
-          # Install the new cask
-          new_cask_installer.stage
-
-          new_cask_installer.install_artifacts
-          new_artifacts_installed = true
-
-          # If successful, wipe the old cask from staging
-          old_cask_installer.finalize_upgrade
-        rescue => e
-          new_cask_installer.uninstall_artifacts if new_artifacts_installed
-          new_cask_installer.purge_versioned_files
-          old_cask_installer.revert_upgrade if started_upgrade
-          raise e
-        end
-
-        end_time = Time.now
-        Homebrew.messages.package_installed(new_cask.token, end_time - start_time)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/cask/cmd/zap.rb b/Library/Homebrew/cask/cmd/zap.rb
deleted file mode 100644
index b06bfa4223e52..0000000000000
--- a/Library/Homebrew/cask/cmd/zap.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-module Cask
-  class Cmd
-    # Cask implementation for the `brew uninstall` command.
-    #
-    # @api private
-    class Zap < AbstractCommand
-      extend T::Sig
-
-      def self.parser
-        super do
-          switch "--force",
-                 description: "Ignore errors when removing files."
-        end
-      end
-
-      sig { void }
-      def run
-        self.class.zap_casks(*casks, verbose: args.verbose?, force: args.force?)
-      end
-
-      sig { params(casks: Cask, force: T.nilable(T::Boolean), verbose: T.nilable(T::Boolean)).void }
-      def self.zap_casks(
-        *casks,
-        force: nil,
-        verbose: nil
-      )
-        require "cask/installer"
-
-        casks.each do |cask|
-          odebug "Zapping Cask #{cask}"
-
-          raise CaskNotInstalledError, cask if !cask.installed? && !force
-
-          Installer.new(cask, verbose: verbose, force: force).zap
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/cask/config.rb b/Library/Homebrew/cask/config.rb
index c99ac319da41b..a091d84a6de5b 100644
--- a/Library/Homebrew/cask/config.rb
+++ b/Library/Homebrew/cask/config.rb
@@ -1,23 +1,20 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "json"
 
 require "lazy_object"
 require "locale"
-
-require "extend/hash_validator"
-using HashValidator
+require "extend/hash/keys"
 
 module Cask
   # Configuration for installing casks.
   #
-  # @api private
+  # @api internal
   class Config
-    extend T::Sig
-
     DEFAULT_DIRS = {
       appdir:               "/Applications",
+      keyboard_layoutdir:   "/Library/Keyboard Layouts",
       colorpickerdir:       "~/Library/ColorPickers",
       prefpanedir:          "~/Library/PreferencePanes",
       qlplugindir:          "~/Library/QuickLook",
@@ -41,8 +38,10 @@ def self.defaults
 
     sig { params(args: Homebrew::CLI::Args).returns(T.attached_class) }
     def self.from_args(args)
+      args = T.unsafe(args)
       new(explicit: {
         appdir:               args.appdir,
+        keyboard_layoutdir:   args.keyboard_layoutdir,
         colorpickerdir:       args.colorpickerdir,
         prefpanedir:          args.prefpanedir,
         qlplugindir:          args.qlplugindir,
@@ -68,7 +67,7 @@ def self.from_json(json, ignore_invalid_keys: false)
         default:             config.fetch("default",  {}),
         env:                 config.fetch("env",      {}),
         explicit:            config.fetch("explicit", {}),
-        ignore_invalid_keys: ignore_invalid_keys,
+        ignore_invalid_keys:,
       )
     end
 
@@ -81,6 +80,8 @@ def self.canonicalize(config)
         key = k.to_sym
 
         if DEFAULT_DIRS.key?(key)
+          raise TypeError, "Invalid path for default dir #{k}: #{v.inspect}" if v.is_a?(Array)
+
           [key, Pathname(v).expand_path]
         else
           [key, v]
@@ -88,6 +89,9 @@ def self.canonicalize(config)
       end
     end
 
+    # Get the explicit configuration.
+    #
+    # @api internal
     sig { returns(T::Hash[Symbol, T.any(String, Pathname, T::Array[String])]) }
     attr_accessor :explicit
 
@@ -110,8 +114,8 @@ def initialize(default: nil, env: nil, explicit: {}, ignore_invalid_keys: false)
         return
       end
 
-      @env&.assert_valid_keys!(*self.class.defaults.keys)
-      @explicit.assert_valid_keys!(*self.class.defaults.keys)
+      @env&.assert_valid_keys(*self.class.defaults.keys)
+      @explicit.assert_valid_keys(*self.class.defaults.keys)
     end
 
     sig { returns(T::Hash[Symbol, T.any(String, Pathname, T::Array[String])]) }
@@ -151,9 +155,9 @@ def manpagedir
     sig { returns(T::Array[String]) }
     def languages
       [
-        *T.cast(explicit.fetch(:languages, []), T::Array[String]),
-        *T.cast(env.fetch(:languages, []), T::Array[String]),
-        *T.cast(default.fetch(:languages, []), T::Array[String]),
+        *explicit.fetch(:languages, []),
+        *env.fetch(:languages, []),
+        *default.fetch(:languages, []),
       ].uniq.select do |lang|
         # Ensure all languages are valid.
         Locale.parse(lang)
@@ -169,10 +173,12 @@ def languages=(languages)
 
     DEFAULT_DIRS.each_key do |dir|
       define_method(dir) do
+        T.bind(self, Config)
         explicit.fetch(dir, env.fetch(dir, default.fetch(dir)))
       end
 
       define_method(:"#{dir}=") do |path|
+        T.bind(self, Config)
         explicit[dir] = Pathname(path).expand_path
       end
     end
@@ -182,25 +188,13 @@ def merge(other)
       self.class.new(explicit: other.explicit.merge(explicit))
     end
 
-    sig { returns(String) }
-    def explicit_s
-      explicit.map do |key, value|
-        # inverse of #env - converts :languages config key back to --language flag
-        if key == :languages
-          key = "language"
-          value = T.cast(explicit.fetch(:languages, []), T::Array[String]).join(",")
-        end
-        "#{key}: \"#{value.to_s.sub(/^#{Dir.home}/, "~")}\""
-      end.join(", ")
-    end
-
     sig { params(options: T.untyped).returns(String) }
-    def to_json(**options)
+    def to_json(*options)
       {
-        default:  default,
-        env:      env,
-        explicit: explicit,
-      }.to_json(**options)
+        default:,
+        env:,
+        explicit:,
+      }.to_json(*options)
     end
   end
 end
diff --git a/Library/Homebrew/cask/denylist.rb b/Library/Homebrew/cask/denylist.rb
index 6b3a0ca5896a1..d65584862e8cf 100644
--- a/Library/Homebrew/cask/denylist.rb
+++ b/Library/Homebrew/cask/denylist.rb
@@ -3,11 +3,7 @@
 
 module Cask
   # List of casks which are not allowed in official taps.
-  #
-  # @api private
   module Denylist
-    extend T::Sig
-
     sig { params(name: String).returns(T.nilable(String)) }
     def self.reason(name)
       case name
diff --git a/Library/Homebrew/cask/download.rb b/Library/Homebrew/cask/download.rb
index 4c80eb262827e..eb1d9a7087139 100644
--- a/Library/Homebrew/cask/download.rb
+++ b/Library/Homebrew/cask/download.rb
@@ -1,79 +1,103 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "downloadable"
 require "fileutils"
 require "cask/cache"
 require "cask/quarantine"
 
 module Cask
   # A download corresponding to a {Cask}.
-  #
-  # @api private
   class Download
+    include Downloadable
+
     include Context
 
     attr_reader :cask
 
     def initialize(cask, quarantine: nil)
+      super()
+
       @cask = cask
       @quarantine = quarantine
     end
 
+    sig { override.returns(String) }
+    def name
+      cask.token
+    end
+
+    sig { override.returns(T.nilable(::URL)) }
+    def url
+      return if cask.url.nil?
+
+      @url ||= ::URL.new(cask.url.to_s, cask.url.specs)
+    end
+
+    sig { override.returns(T.nilable(::Checksum)) }
+    def checksum
+      @checksum ||= cask.sha256 if cask.sha256 != :no_check
+    end
+
+    sig { override.returns(T.nilable(Version)) }
+    def version
+      return if cask.version.nil?
+
+      @version ||= Version.new(cask.version)
+    end
+
+    sig {
+      override
+        .params(quiet:                     T.nilable(T::Boolean),
+                verify_download_integrity: T::Boolean,
+                timeout:                   T.nilable(T.any(Integer, Float)))
+        .returns(Pathname)
+    }
     def fetch(quiet: nil, verify_download_integrity: true, timeout: nil)
-      downloaded_path = begin
-        downloader.shutup! if quiet
-        downloader.fetch(timeout: timeout)
-        downloader.cached_location
-      rescue => e
-        error = CaskError.new("Download failed on Cask '#{cask}' with message: #{e}")
+      downloader.quiet! if quiet
+
+      begin
+        super(verify_download_integrity: false, timeout:)
+      rescue DownloadError => e
+        error = CaskError.new("Download failed on Cask '#{cask}' with message: #{e.cause}")
         error.set_backtrace e.backtrace
         raise error
       end
+
+      downloaded_path = cached_download
       quarantine(downloaded_path)
       self.verify_download_integrity(downloaded_path) if verify_download_integrity
       downloaded_path
     end
 
-    def downloader
-      @downloader ||= begin
-        strategy = DownloadStrategyDetector.detect(cask.url.to_s, cask.url.using)
-        strategy.new(cask.url.to_s, cask.token, cask.version, cache: Cache.path, **cask.url.specs)
-      end
-    end
-
     def time_file_size(timeout: nil)
-      downloader.resolved_time_file_size(timeout: timeout)
-    end
-
-    def clear_cache
-      downloader.clear_cache
-    end
+      raise ArgumentError, "not supported for this download strategy" unless downloader.is_a?(CurlDownloadStrategy)
 
-    def cached_download
-      downloader.cached_location
+      T.cast(downloader, CurlDownloadStrategy).resolved_time_file_size(timeout:)
     end
 
     def basename
       downloader.basename
     end
 
-    def verify_download_integrity(fn)
+    sig { override.params(filename: Pathname).void }
+    def verify_download_integrity(filename)
       if @cask.sha256 == :no_check
         opoo "No checksum defined for cask '#{@cask}', skipping verification."
         return
       end
 
-      begin
-        ohai "Verifying checksum for cask '#{@cask}'" if verbose?
-        fn.verify_checksum(@cask.sha256)
-      rescue ChecksumMissingError
-        opoo <<~EOS
-          Cannot verify integrity of '#{fn.basename}'.
-          No checksum was provided for this cask.
-          For your reference, the checksum is:
-            sha256 "#{fn.sha256}"
-        EOS
-      end
+      super
+    end
+
+    sig { override.returns(String) }
+    def download_name
+      cask.token
+    end
+
+    sig { override.returns(String) }
+    def download_type
+      "cask"
     end
 
     private
@@ -88,5 +112,15 @@ def quarantine(path)
         Quarantine.release!(download_path: path)
       end
     end
+
+    sig { override.returns(T.nilable(::URL)) }
+    def determine_url
+      url
+    end
+
+    sig { override.returns(Pathname) }
+    def cache
+      Cache.path
+    end
   end
 end
diff --git a/Library/Homebrew/cask/dsl.rb b/Library/Homebrew/cask/dsl.rb
index d4d06da622260..bb5d36cf7ec44 100644
--- a/Library/Homebrew/cask/dsl.rb
+++ b/Library/Homebrew/cask/dsl.rb
@@ -1,16 +1,17 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "attrable"
 require "locale"
 require "lazy_object"
 require "livecheck"
 
 require "cask/artifact"
+require "cask/artifact_set"
 
 require "cask/caskroom"
 require "cask/exceptions"
 
-require "cask/dsl/appcast"
 require "cask/dsl/base"
 require "cask/dsl/caveats"
 require "cask/dsl/conflicts_with"
@@ -29,8 +30,6 @@
 
 module Cask
   # Class representing the domain-specific language used for casks.
-  #
-  # @api private
   class DSL
     ORDINARY_ARTIFACT_CLASSES = [
       Artifact::Installer,
@@ -43,6 +42,7 @@ class DSL
       Artifact::Font,
       Artifact::InputMethod,
       Artifact::InternetPlugin,
+      Artifact::KeyboardLayout,
       Artifact::Manpage,
       Artifact::Pkg,
       Artifact::Prefpane,
@@ -67,6 +67,7 @@ class DSL
 
     DSL_METHODS = Set.new([
       :appcast,
+      :arch,
       :artifacts,
       :auto_updates,
       :caveats,
@@ -76,33 +77,54 @@ class DSL
       :depends_on,
       :homepage,
       :language,
-      :languages,
       :name,
       :sha256,
       :staged_path,
       :url,
       :version,
       :appdir,
-      :discontinued?,
+      :deprecate!,
+      :deprecated?,
+      :deprecation_date,
+      :deprecation_reason,
+      :disable!,
+      :disabled?,
+      :disable_date,
+      :disable_reason,
+      :discontinued?, # TODO: remove once discontinued? is removed (4.5.0)
       :livecheck,
       :livecheckable?,
+      :on_system_blocks_exist?,
+      :on_system_block_min_os,
+      :depends_on_set_in_block?,
       *ORDINARY_ARTIFACT_CLASSES.map(&:dsl_key),
       *ACTIVATABLE_ARTIFACT_CLASSES.map(&:dsl_key),
       *ARTIFACT_BLOCK_CLASSES.flat_map { |klass| [klass.dsl_key, klass.uninstall_dsl_key] },
     ]).freeze
 
-    extend Predicable
+    extend Attrable
     include OnSystem::MacOSOnly
 
-    attr_reader :cask, :token
+    attr_reader :cask, :token, :deprecation_date, :deprecation_reason, :disable_date, :disable_reason,
+                :on_system_block_min_os
 
-    attr_predicate :on_system_blocks_exist?
+    attr_predicate :deprecated?, :disabled?, :livecheckable?, :on_system_blocks_exist?, :depends_on_set_in_block?
 
     def initialize(cask)
       @cask = cask
       @token = cask.token
     end
 
+    # Specifies the cask's name.
+    #
+    # NOTE: Multiple names can be specified.
+    #
+    # ### Example
+    #
+    # ```ruby
+    # name "Visual Studio Code"
+    # ```
+    #
     # @api public
     def name(*args)
       @name ||= []
@@ -111,32 +133,48 @@ def name(*args)
       @name.concat(args.flatten)
     end
 
+    # Describes the cask.
+    #
+    # ### Example
+    #
+    # ```ruby
+    # desc "Open-source code editor"
+    # ```
+    #
     # @api public
     def desc(description = nil)
       set_unique_stanza(:desc, description.nil?) { description }
     end
 
     def set_unique_stanza(stanza, should_return)
-      return instance_variable_get("@#{stanza}") if should_return
+      return instance_variable_get(:"@#{stanza}") if should_return
 
       unless @cask.allow_reassignment
-        if instance_variable_defined?("@#{stanza}") && !@called_in_on_system_block
+        if instance_variable_defined?(:"@#{stanza}") && !@called_in_on_system_block
           raise CaskInvalidError.new(cask, "'#{stanza}' stanza may only appear once.")
         end
 
-        if instance_variable_defined?("@#{stanza}_set_in_block") && @called_in_on_system_block
+        if instance_variable_defined?(:"@#{stanza}_set_in_block") && @called_in_on_system_block
           raise CaskInvalidError.new(cask, "'#{stanza}' stanza may only be overridden once.")
         end
       end
 
-      instance_variable_set("@#{stanza}_set_in_block", true) if @called_in_on_system_block
-      instance_variable_set("@#{stanza}", yield)
+      instance_variable_set(:"@#{stanza}_set_in_block", true) if @called_in_on_system_block
+      instance_variable_set(:"@#{stanza}", yield)
     rescue CaskInvalidError
       raise
     rescue => e
       raise CaskInvalidError.new(cask, "'#{stanza}' stanza failed with: #{e}")
     end
 
+    # Sets the cask's homepage.
+    #
+    # ### Example
+    #
+    # ```ruby
+    # homepage "https://code.visualstudio.com/"
+    # ```
+    #
     # @api public
     def homepage(homepage = nil)
       set_unique_stanza(:homepage, homepage.nil?) { homepage }
@@ -169,12 +207,11 @@ def language_eval
       raise CaskInvalidError.new(cask, "No default language specified.") if @language_blocks.default.nil?
 
       locales = cask.config.languages
-                    .map do |language|
+                    .filter_map do |language|
                       Locale.parse(language)
                     rescue Locale::ParserError
                       nil
                     end
-                    .compact
 
       locales.each do |locale|
         key = locale.detect(@language_blocks.keys)
@@ -193,31 +230,59 @@ def languages
       @language_blocks.keys.flatten
     end
 
+    # Sets the cask's download URL.
+    #
+    # ### Example
+    #
+    # ```ruby
+    # url "https://update.code.visualstudio.com/#{version}/#{arch}/stable"
+    # ```
+    #
     # @api public
     def url(*args, **options, &block)
-      caller_location = caller_locations[0]
+      caller_location = T.must(caller_locations).fetch(0)
 
       set_unique_stanza(:url, args.empty? && options.empty? && !block) do
         if block
-          URL.new(*args, **options, caller_location: caller_location, dsl: self, &block)
+          URL.new(*args, **options, caller_location:, dsl: self, &block)
         else
-          URL.new(*args, **options, caller_location: caller_location)
+          URL.new(*args, **options, caller_location:)
         end
       end
     end
 
+    # Sets the cask's container type or nested container path.
+    #
+    # ### Examples
+    #
+    # The container is a nested disk image:
+    #
+    # ```ruby
+    # container nested: "orca-#{version}.dmg"
+    # ```
+    #
+    # The container should not be unarchived:
+    #
+    # ```ruby
+    # container type: :naked
+    # ```
+    #
     # @api public
-    def appcast(*args)
-      set_unique_stanza(:appcast, args.empty?) { DSL::Appcast.new(*args) }
-    end
-
-    # @api public
-    def container(*args)
-      set_unique_stanza(:container, args.empty?) do
-        DSL::Container.new(*args)
+    def container(**kwargs)
+      set_unique_stanza(:container, kwargs.empty?) do
+        DSL::Container.new(**kwargs)
       end
     end
 
+    # Sets the cask's version.
+    #
+    # ### Example
+    #
+    # ```ruby
+    # version "1.88.1"
+    # ```
+    #
+    # @see DSL::Version
     # @api public
     def version(arg = nil)
       set_unique_stanza(:version, arg.nil?) do
@@ -229,48 +294,97 @@ def version(arg = nil)
       end
     end
 
+    # Sets the cask's download checksum.
+    #
+    # ### Example
+    #
+    # For universal or single-architecture downloads:
+    #
+    # ```ruby
+    # sha256 "7bdb497080ffafdfd8cc94d8c62b004af1be9599e865e5555e456e2681e150ca"
+    # ```
+    #
+    # For architecture-dependent downloads:
+    #
+    # ```ruby
+    # sha256 arm:   "7bdb497080ffafdfd8cc94d8c62b004af1be9599e865e5555e456e2681e150ca",
+    #         intel: "b3c1c2442480a0219b9e05cf91d03385858c20f04b764ec08a3fa83d1b27e7b2"
+    # ```
+    #
     # @api public
-    def sha256(arg = nil)
-      set_unique_stanza(:sha256, arg.nil?) do
-        case arg
+    def sha256(arg = nil, arm: nil, intel: nil)
+      should_return = arg.nil? && arm.nil? && intel.nil?
+
+      set_unique_stanza(:sha256, should_return) do
+        @on_system_blocks_exist = true if arm.present? || intel.present?
+
+        val = arg || on_arch_conditional(arm:, intel:)
+        case val
         when :no_check
-          arg
+          val
         when String
-          Checksum.new(arg)
+          Checksum.new(val)
         else
-          raise CaskInvalidError.new(cask, "invalid 'sha256' value: #{arg.inspect}")
+          raise CaskInvalidError.new(cask, "invalid 'sha256' value: #{val.inspect}")
         end
       end
     end
 
-    # `depends_on` uses a load method so that multiple stanzas can be merged.
+    # Sets the cask's architecture strings.
+    #
+    # ### Example
+    #
+    # ```ruby
+    # arch arm: "darwin-arm64", intel: "darwin"
+    # ```
+    #
+    # @api public
+    def arch(arm: nil, intel: nil)
+      should_return = arm.nil? && intel.nil?
+
+      set_unique_stanza(:arch, should_return) do
+        @on_system_blocks_exist = true
+
+        on_arch_conditional(arm:, intel:)
+      end
+    end
+
+    # Declare dependencies and requirements for a cask.
+    #
+    # NOTE: Multiple dependencies can be specified.
+    #
     # @api public
-    def depends_on(*args)
+    def depends_on(**kwargs)
       @depends_on ||= DSL::DependsOn.new
-      return @depends_on if args.empty?
+      @depends_on_set_in_block = true if @called_in_on_system_block
+      return @depends_on if kwargs.empty?
 
       begin
-        @depends_on.load(*args)
+        @depends_on.load(**kwargs)
       rescue RuntimeError => e
         raise CaskInvalidError.new(cask, e)
       end
       @depends_on
     end
 
+    # Declare conflicts that keep a cask from installing or working correctly.
+    #
     # @api public
-    def conflicts_with(*args)
-      # TODO: remove this constraint, and instead merge multiple conflicts_with stanzas
-      set_unique_stanza(:conflicts_with, args.empty?) { DSL::ConflictsWith.new(*args) }
+    def conflicts_with(**kwargs)
+      # TODO: Remove this constraint and instead merge multiple `conflicts_with` stanzas
+      set_unique_stanza(:conflicts_with, kwargs.empty?) { DSL::ConflictsWith.new(**kwargs) }
     end
 
     def artifacts
-      @artifacts ||= SortedSet.new
+      @artifacts ||= ArtifactSet.new
     end
 
     def caskroom_path
       cask.caskroom_path
     end
 
+    # The staged location for this cask, including version number.
+    #
     # @api public
     def staged_path
       return @staged_path if @staged_path
@@ -279,6 +393,8 @@ def staged_path
       @staged_path = caskroom_path.join(cask_version.to_s)
     end
 
+    # Provide the user with cask-specific information at install time.
+    #
     # @api public
     def caveats(*strings, &block)
       @caveats ||= DSL::Caveats.new(cask)
@@ -295,17 +411,22 @@ def caveats(*strings, &block)
     end
 
     def discontinued?
+      odisabled "`discontinued?`", "`deprecated?` or `disabled?`"
       @caveats&.discontinued? == true
     end
 
+    # Asserts that the cask artifacts auto-update.
+    #
     # @api public
     def auto_updates(auto_updates = nil)
       set_unique_stanza(:auto_updates, auto_updates.nil?) { auto_updates }
     end
 
+    # Automatically fetch the latest version of a cask from changelogs.
+    #
     # @api public
     def livecheck(&block)
-      @livecheck ||= Livecheck.new(self)
+      @livecheck ||= Livecheck.new(cask)
       return @livecheck unless block
 
       if !@cask.allow_reassignment && @livecheckable
@@ -316,18 +437,46 @@ def livecheck(&block)
       @livecheck.instance_eval(&block)
     end
 
-    def livecheckable?
-      @livecheckable == true
+    # Declare that a cask is no longer functional or supported.
+    #
+    # NOTE: A warning will be shown when trying to install this cask.
+    #
+    # @api public
+    def deprecate!(date:, because:)
+      @deprecation_date = Date.parse(date)
+      return if @deprecation_date > Date.today
+
+      @deprecation_reason = because
+      @deprecated = true
+    end
+
+    # Declare that a cask is no longer functional or supported.
+    #
+    # NOTE: An error will be thrown when trying to install this cask.
+    #
+    # @api public
+    def disable!(date:, because:)
+      @disable_date = Date.parse(date)
+
+      if @disable_date > Date.today
+        @deprecation_reason = because
+        @deprecated = true
+        return
+      end
+
+      @disable_reason = because
+      @disabled = true
     end
 
     ORDINARY_ARTIFACT_CLASSES.each do |klass|
-      define_method(klass.dsl_key) do |*args|
+      define_method(klass.dsl_key) do |*args, **kwargs|
+        T.bind(self, DSL)
         if [*artifacts.map(&:class), klass].include?(Artifact::StageOnly) &&
-           (artifacts.map(&:class) & ACTIVATABLE_ARTIFACT_CLASSES).any?
+           artifacts.map(&:class).intersect?(ACTIVATABLE_ARTIFACT_CLASSES)
           raise CaskInvalidError.new(cask, "'stage_only' must be the only activatable artifact.")
         end
 
-        artifacts.add(klass.from_args(cask, *args))
+        artifacts.add(klass.from_args(cask, *args, **kwargs))
       rescue CaskInvalidError
         raise
       rescue => e
@@ -338,6 +487,7 @@ def livecheckable?
     ARTIFACT_BLOCK_CLASSES.each do |klass|
       [klass.dsl_key, klass.uninstall_dsl_key].each do |dsl_key|
         define_method(dsl_key) do |&block|
+          T.bind(self, DSL)
           artifacts.add(klass.new(cask, dsl_key => block))
         end
       end
@@ -356,8 +506,12 @@ def respond_to_missing?(*)
       true
     end
 
+    # The directory `app`s are installed into.
+    #
     # @api public
     def appdir
+      return HOMEBREW_CASK_APPDIR_PLACEHOLDER if Cask.generating_hash?
+
       cask.config.appdir
     end
   end
diff --git a/Library/Homebrew/cask/dsl/appcast.rb b/Library/Homebrew/cask/dsl/appcast.rb
deleted file mode 100644
index c29a798192e32..0000000000000
--- a/Library/Homebrew/cask/dsl/appcast.rb
+++ /dev/null
@@ -1,27 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module Cask
-  class DSL
-    # Class corresponding to the `appcast` stanza.
-    #
-    # @api private
-    class Appcast
-      attr_reader :uri, :parameters, :must_contain
-
-      def initialize(uri, **parameters)
-        @uri        = URI(uri)
-        @parameters = parameters
-        @must_contain = parameters[:must_contain] if parameters.key?(:must_contain)
-      end
-
-      def to_yaml
-        [uri, parameters].to_yaml
-      end
-
-      def to_s
-        uri.to_s
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/cask/dsl/base.rb b/Library/Homebrew/cask/dsl/base.rb
index 9a91b8381fabd..900889a59edbd 100644
--- a/Library/Homebrew/cask/dsl/base.rb
+++ b/Library/Homebrew/cask/dsl/base.rb
@@ -1,13 +1,12 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/utils"
+require "extend/on_system"
 
 module Cask
   class DSL
     # Superclass for all stanzas which take a block.
-    #
-    # @api private
     class Base
       extend Forwardable
 
@@ -16,7 +15,7 @@ def initialize(cask, command = SystemCommand)
         @command = command
       end
 
-      def_delegators :@cask, :token, :version, :caskroom_path, :staged_path, :appdir, :language
+      def_delegators :@cask, :token, :version, :caskroom_path, :staged_path, :appdir, :language, :arch
 
       def system_command(executable, **options)
         @command.run!(executable, **options)
@@ -26,7 +25,7 @@ def system_command(executable, **options)
       # rubocop:disable Style/MissingRespondToMissing
       def method_missing(method, *)
         if method
-          underscored_class = self.class.name.gsub(/([[:lower:]])([[:upper:]][[:lower:]])/, '\1_\2').downcase
+          underscored_class = T.must(self.class.name).gsub(/([[:lower:]])([[:upper:]][[:lower:]])/, '\1_\2').downcase
           section = underscored_class.split("::").last
           Utils.method_missing_message(method, @cask.to_s, section)
           nil
diff --git a/Library/Homebrew/cask/dsl/caveats.rb b/Library/Homebrew/cask/dsl/caveats.rb
index 0436481f092bd..cd27bf0776038 100644
--- a/Library/Homebrew/cask/dsl/caveats.rb
+++ b/Library/Homebrew/cask/dsl/caveats.rb
@@ -1,6 +1,8 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "attrable"
+
 module Cask
   class DSL
     # Class corresponding to the `caveats` stanza.
@@ -12,15 +14,13 @@ class DSL
     # The return value of the last method in the block is also sent
     # to the output by the caller, but that feature is only for the
     # convenience of cask authors.
-    #
-    # @api private
     class Caveats < Base
-      extend Predicable
+      extend Attrable
 
       attr_predicate :discontinued?
 
       def initialize(*args)
-        super(*args)
+        super
         @built_in_caveats = {}
         @custom_caveats = []
         @discontinued = false
@@ -37,6 +37,7 @@ def self.caveat(name, &block)
 
       private_class_method :caveat
 
+      sig { returns(String) }
       def to_s
         (@custom_caveats + @built_in_caveats.values).join("\n")
       end
@@ -58,10 +59,16 @@ def eval_caveats(&block)
       caveat :kext do
         next if MacOS.version < :high_sierra
 
+        navigation_path = if MacOS.version >= :ventura
+          "System Settings → Privacy & Security"
+        else
+          "System Preferences → Security & Privacy → General"
+        end
+
         <<~EOS
           #{@cask} requires a kernel extension to work.
           If the installation fails, retry after you enable it in:
-            System Preferences → Security & Privacy → General
+            #{navigation_path}
 
           For more information, refer to vendor documentation or this Apple Technical Note:
             #{Formatter.url("https://developer.apple.com/library/content/technotes/tn2459/_index.html")}
@@ -69,14 +76,20 @@ def eval_caveats(&block)
       end
 
       caveat :unsigned_accessibility do |access = "Accessibility"|
-        # access: the category in System Preferences > Security & Privacy > Privacy the app requires.
+        # access: the category in the privacy settings the app requires.
+
+        navigation_path = if MacOS.version >= :ventura
+          "System Settings → Privacy & Security"
+        else
+          "System Preferences → Security & Privacy → Privacy"
+        end
 
         <<~EOS
           #{@cask} is not signed and requires Accessibility access,
           so you will need to re-grant Accessibility access every time the app is updated.
 
           Enable or re-enable it in:
-            System Preferences → Security & Privacy → Privacy → #{access}
+            #{navigation_path} → #{access}
           To re-enable, untick and retick #{@cask}.app.
         EOS
       end
@@ -122,13 +135,13 @@ def eval_caveats(&block)
         else
           <<~EOS
             #{@cask} requires Java #{java_version}. You can install it with:
-              brew install --cask homebrew/cask-versions/temurin#{java_version}
+              brew install --cask temurin@#{java_version}
           EOS
         end
       end
 
       caveat :requires_rosetta do
-        next unless Hardware::CPU.arm?
+        next if Homebrew::SimulateSystem.current_arch != :arm
 
         <<~EOS
           #{@cask} is built for Intel macOS and so requires Rosetta 2 to be installed.
@@ -151,6 +164,7 @@ def eval_caveats(&block)
       end
 
       caveat :discontinued do
+        odisabled "`caveats :discontinued`", "`deprecate!`"
         @discontinued = true
         <<~EOS
           #{@cask} has been officially discontinued upstream.
diff --git a/Library/Homebrew/cask/dsl/caveats.rbi b/Library/Homebrew/cask/dsl/caveats.rbi
new file mode 100644
index 0000000000000..f9799bfcaa265
--- /dev/null
+++ b/Library/Homebrew/cask/dsl/caveats.rbi
@@ -0,0 +1,6 @@
+# typed: strict
+
+class Cask::DSL::Caveats
+  sig { returns(Symbol) }
+  def kext; end
+end
diff --git a/Library/Homebrew/cask/dsl/conflicts_with.rb b/Library/Homebrew/cask/dsl/conflicts_with.rb
index da47113ab521f..dcf8a84b51809 100644
--- a/Library/Homebrew/cask/dsl/conflicts_with.rb
+++ b/Library/Homebrew/cask/dsl/conflicts_with.rb
@@ -1,16 +1,12 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "delegate"
-
-require "extend/hash_validator"
-using HashValidator
+require "extend/hash/keys"
 
 module Cask
   class DSL
     # Class corresponding to the `conflicts_with` stanza.
-    #
-    # @api private
     class ConflictsWith < SimpleDelegator
       VALID_KEYS = [
         :formula,
@@ -22,16 +18,16 @@ class ConflictsWith < SimpleDelegator
       ].freeze
 
       def initialize(**options)
-        options.assert_valid_keys!(*VALID_KEYS)
+        options.assert_valid_keys(*VALID_KEYS)
 
-        conflicts = options.transform_values { |v| Set.new(Array(v)) }
+        conflicts = options.transform_values { |v| Set.new(Kernel.Array(v)) }
         conflicts.default = Set.new
 
         super(conflicts)
       end
 
       def to_json(generator)
-        transform_values(&:to_a).to_json(generator)
+        __getobj__.transform_values(&:to_a).to_json(generator)
       end
     end
   end
diff --git a/Library/Homebrew/cask/dsl/container.rb b/Library/Homebrew/cask/dsl/container.rb
index a386adab8d138..0ddcb8a6f1326 100644
--- a/Library/Homebrew/cask/dsl/container.rb
+++ b/Library/Homebrew/cask/dsl/container.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "unpack_strategy"
@@ -6,23 +6,12 @@
 module Cask
   class DSL
     # Class corresponding to the `container` stanza.
-    #
-    # @api private
     class Container
-      VALID_KEYS = Set.new([
-        :type,
-        :nested,
-      ]).freeze
+      attr_accessor :nested, :type
 
-      attr_accessor(*VALID_KEYS, :pairs)
-
-      def initialize(pairs = {})
-        @pairs = pairs
-        pairs.each do |key, value|
-          raise "invalid container key: #{key.inspect}" unless VALID_KEYS.include?(key)
-
-          send(:"#{key}=", value)
-        end
+      def initialize(nested: nil, type: nil)
+        @nested = nested
+        @type = type
 
         return if type.nil?
         return unless UnpackStrategy.from_type(type).nil?
@@ -30,13 +19,16 @@ def initialize(pairs = {})
         raise "invalid container type: #{type.inspect}"
       end
 
-      def to_yaml
-        @pairs.to_yaml
+      def pairs
+        instance_variables.to_h { |ivar| [ivar[1..].to_sym, instance_variable_get(ivar)] }.compact
       end
 
-      def to_s
-        @pairs.inspect
+      def to_yaml
+        pairs.to_yaml
       end
+
+      sig { returns(String) }
+      def to_s = pairs.inspect
     end
   end
 end
diff --git a/Library/Homebrew/cask/dsl/depends_on.rb b/Library/Homebrew/cask/dsl/depends_on.rb
index 1d4e3a2448ff9..2aaad1d6b52e0 100644
--- a/Library/Homebrew/cask/dsl/depends_on.rb
+++ b/Library/Homebrew/cask/dsl/depends_on.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "delegate"
@@ -8,8 +8,6 @@
 module Cask
   class DSL
     # Class corresponding to the `depends_on` stanza.
-    #
-    # @api private
     class DependsOn < SimpleDelegator
       VALID_KEYS = Set.new([
         :formula,
@@ -37,7 +35,7 @@ def load(**pairs)
         pairs.each do |key, value|
           raise "invalid depends_on key: '#{key.inspect}'" unless VALID_KEYS.include?(key)
 
-          self[key] = send(:"#{key}=", *value)
+          __getobj__[key] = send(:"#{key}=", *value)
         end
       end
 
@@ -49,22 +47,26 @@ def cask=(*args)
         @cask.concat(args)
       end
 
+      sig { params(args: T.any(String, Symbol)).returns(T.nilable(MacOSRequirement)) }
       def macos=(*args)
         raise "Only a single 'depends_on macos' is allowed." if defined?(@macos)
 
+        # workaround for https://github.com/sorbet/sorbet/issues/6860
+        first_arg = args.first&.to_s
+
         begin
           @macos = if args.count > 1
             MacOSRequirement.new([args], comparator: "==")
-          elsif MacOSVersions::SYMBOLS.key?(args.first)
+          elsif MacOSVersion::SYMBOLS.key?(args.first)
             MacOSRequirement.new([args.first], comparator: "==")
-          elsif /^\s*(?<comparator><|>|[=<>]=)\s*:(?<version>\S+)\s*$/ =~ args.first
-            MacOSRequirement.new([version.to_sym], comparator: comparator)
-          elsif /^\s*(?<comparator><|>|[=<>]=)\s*(?<version>\S+)\s*$/ =~ args.first
-            MacOSRequirement.new([version], comparator: comparator)
+          elsif (md = /^\s*(?<comparator><|>|[=<>]=)\s*:(?<version>\S+)\s*$/.match(first_arg))
+            MacOSRequirement.new([T.must(md[:version]).to_sym], comparator: md[:comparator])
+          elsif (md = /^\s*(?<comparator><|>|[=<>]=)\s*(?<version>\S+)\s*$/.match(first_arg))
+            MacOSRequirement.new([md[:version]], comparator: md[:comparator])
           else # rubocop:disable Lint/DuplicateBranch
             MacOSRequirement.new([args.first], comparator: "==")
           end
-        rescue MacOSVersionError => e
+        rescue MacOSVersion::Error, TypeError => e
           raise "invalid 'depends_on macos' value: #{e}"
         end
       end
diff --git a/Library/Homebrew/cask/dsl/depends_on.rbi b/Library/Homebrew/cask/dsl/depends_on.rbi
new file mode 100644
index 0000000000000..92d6827c64637
--- /dev/null
+++ b/Library/Homebrew/cask/dsl/depends_on.rbi
@@ -0,0 +1,5 @@
+# typed: strict
+
+class Cask::DSL::DependsOn
+  include Kernel
+end
diff --git a/Library/Homebrew/cask/dsl/postflight.rb b/Library/Homebrew/cask/dsl/postflight.rb
index 209533ba77487..254a6873d2863 100644
--- a/Library/Homebrew/cask/dsl/postflight.rb
+++ b/Library/Homebrew/cask/dsl/postflight.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "cask/staged"
@@ -6,14 +6,8 @@
 module Cask
   class DSL
     # Class corresponding to the `postflight` stanza.
-    #
-    # @api private
     class Postflight < Base
       include Staged
-
-      def suppress_move_to_applications(options = {})
-        # TODO: Remove from all casks because it is no longer needed
-      end
     end
   end
 end
diff --git a/Library/Homebrew/cask/dsl/preflight.rb b/Library/Homebrew/cask/dsl/preflight.rb
index d1f0e57098ce2..abaf1fb9751c3 100644
--- a/Library/Homebrew/cask/dsl/preflight.rb
+++ b/Library/Homebrew/cask/dsl/preflight.rb
@@ -1,11 +1,11 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "cask/staged"
+
 module Cask
   class DSL
     # Class corresponding to the `preflight` stanza.
-    #
-    # @api private
     class Preflight < Base
       include Staged
     end
diff --git a/Library/Homebrew/cask/dsl/uninstall_postflight.rb b/Library/Homebrew/cask/dsl/uninstall_postflight.rb
index 9dc523b05d0a0..1a3e38e86887a 100644
--- a/Library/Homebrew/cask/dsl/uninstall_postflight.rb
+++ b/Library/Homebrew/cask/dsl/uninstall_postflight.rb
@@ -4,8 +4,6 @@
 module Cask
   class DSL
     # Class corresponding to the `uninstall_postflight` stanza.
-    #
-    # @api private
     class UninstallPostflight < Base
     end
   end
diff --git a/Library/Homebrew/cask/dsl/uninstall_preflight.rb b/Library/Homebrew/cask/dsl/uninstall_preflight.rb
index d35da3f51fa70..5280e638bdb77 100644
--- a/Library/Homebrew/cask/dsl/uninstall_preflight.rb
+++ b/Library/Homebrew/cask/dsl/uninstall_preflight.rb
@@ -6,8 +6,6 @@
 module Cask
   class DSL
     # Class corresponding to the `uninstall_preflight` stanza.
-    #
-    # @api private
     class UninstallPreflight < Base
       include Staged
     end
diff --git a/Library/Homebrew/cask/dsl/version.rb b/Library/Homebrew/cask/dsl/version.rb
index bd7568c667a76..9613879652196 100644
--- a/Library/Homebrew/cask/dsl/version.rb
+++ b/Library/Homebrew/cask/dsl/version.rb
@@ -1,25 +1,21 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module Cask
   class DSL
     # Class corresponding to the `version` stanza.
-    #
-    # @api private
     class Version < ::String
-      extend T::Sig
-
       DIVIDERS = {
         "." => :dots,
         "-" => :hyphens,
         "_" => :underscores,
       }.freeze
 
-      DIVIDER_REGEX = /(#{DIVIDERS.keys.map { |v| Regexp.quote(v) }.join('|')})/.freeze
+      DIVIDER_REGEX = /(#{DIVIDERS.keys.map { |v| Regexp.quote(v) }.join("|")})/
 
-      MAJOR_MINOR_PATCH_REGEX = /^([^.,:]+)(?:.([^.,:]+)(?:.([^.,:]+))?)?/.freeze
+      MAJOR_MINOR_PATCH_REGEX = /^([^.,:]+)(?:.([^.,:]+)(?:.([^.,:]+))?)?/
 
-      INVALID_CHARACTERS = /[^0-9a-zA-Z.,:\-_+ ]/.freeze
+      INVALID_CHARACTERS = /[^0-9a-zA-Z.,:\-_+ ]/
 
       class << self
         private
@@ -32,6 +28,7 @@ def define_divider_methods(divider)
         def define_divider_deletion_method(divider)
           method_name = deletion_method_name(divider)
           define_method(method_name) do
+            T.bind(self, Version)
             version { delete(divider) }
           end
         end
@@ -49,6 +46,7 @@ def define_divider_conversion_methods(left_divider)
         def define_divider_conversion_method(left_divider, right_divider)
           method_name = conversion_method_name(left_divider, right_divider)
           define_method(method_name) do
+            T.bind(self, Version)
             version { gsub(left_divider, right_divider) }
           end
         end
@@ -96,78 +94,94 @@ def latest?
         to_s == "latest"
       end
 
+      # The major version.
+      #
       # @api public
       sig { returns(T.self_type) }
       def major
         version { slice(MAJOR_MINOR_PATCH_REGEX, 1) }
       end
 
+      # The minor version.
+      #
       # @api public
       sig { returns(T.self_type) }
       def minor
         version { slice(MAJOR_MINOR_PATCH_REGEX, 2) }
       end
 
+      # The patch version.
+      #
       # @api public
       sig { returns(T.self_type) }
       def patch
         version { slice(MAJOR_MINOR_PATCH_REGEX, 3) }
       end
 
+      # The major and minor version.
+      #
       # @api public
       sig { returns(T.self_type) }
       def major_minor
         version { [major, minor].reject(&:empty?).join(".") }
       end
 
+      # The major, minor and patch version.
+      #
       # @api public
       sig { returns(T.self_type) }
       def major_minor_patch
         version { [major, minor, patch].reject(&:empty?).join(".") }
       end
 
+      # The minor and patch version.
+      #
       # @api public
       sig { returns(T.self_type) }
       def minor_patch
         version { [minor, patch].reject(&:empty?).join(".") }
       end
 
+      # The comma separated values of the version as array.
+      #
       # @api public
       sig { returns(T::Array[Version]) } # Only top-level T.self_type is supported https://sorbet.org/docs/self-type
       def csv
-        split(",").map(&self.class.method(:new))
+        split(",").map { self.class.new(_1) }
       end
 
+      # The version part before the first comma.
+      #
       # @api public
       sig { returns(T.self_type) }
       def before_comma
         version { split(",", 2).first }
       end
 
+      # The version part after the first comma.
+      #
       # @api public
       sig { returns(T.self_type) }
       def after_comma
         version { split(",", 2).second }
       end
 
+      # The version without any dividers.
+      #
+      # @see DIVIDER_REGEX
       # @api public
       sig { returns(T.self_type) }
-      def before_colon
-        odisabled "Cask::DSL::Version#before_colon", "Cask::DSL::Version#csv"
-        version { split(":", 2).first }
-      end
-
-      # @api public
-      sig { returns(T.self_type) }
-      def after_colon
-        odisabled "Cask::DSL::Version#after_colon", "Cask::DSL::Version#csv"
-        version { split(":", 2).second }
+      def no_dividers
+        version { gsub(DIVIDER_REGEX, "") }
       end
 
+      # The version with the given record separator removed from the end.
+      #
+      # @see String#chomp
       # @api public
-      sig { returns(T.self_type) }
-      def no_dividers
-        version { gsub(DIVIDER_REGEX, "") }
+      sig { params(separator: String).returns(T.self_type) }
+      def chomp(separator = T.unsafe(nil))
+        version { to_s.chomp(separator) }
       end
 
       private
diff --git a/Library/Homebrew/cask/exceptions.rb b/Library/Homebrew/cask/exceptions.rb
index dcf76029fb407..7b681704fc7d4 100644
--- a/Library/Homebrew/cask/exceptions.rb
+++ b/Library/Homebrew/cask/exceptions.rb
@@ -1,18 +1,12 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module Cask
   # General cask error.
-  #
-  # @api private
   class CaskError < RuntimeError; end
 
   # Cask error containing multiple other errors.
-  #
-  # @api private
   class MultipleCaskErrors < CaskError
-    extend T::Sig
-
     def initialize(errors)
       super()
 
@@ -29,11 +23,7 @@ def to_s
   end
 
   # Abstract cask error containing a cask token.
-  #
-  # @api private
   class AbstractCaskErrorWithToken < CaskError
-    extend T::Sig
-
     sig { returns(String) }
     attr_reader :token
 
@@ -49,23 +39,30 @@ def initialize(token, reason = nil)
   end
 
   # Error when a cask is not installed.
-  #
-  # @api private
   class CaskNotInstalledError < AbstractCaskErrorWithToken
-    extend T::Sig
-
     sig { returns(String) }
     def to_s
       "Cask '#{token}' is not installed."
     end
   end
 
+  # Error when a cask cannot be installed.
+  class CaskCannotBeInstalledError < AbstractCaskErrorWithToken
+    attr_reader :message
+
+    def initialize(token, message)
+      super(token)
+      @message = message
+    end
+
+    sig { returns(String) }
+    def to_s
+      "Cask '#{token}' has been #{message}"
+    end
+  end
+
   # Error when a cask conflicts with another cask.
-  #
-  # @api private
   class CaskConflictError < AbstractCaskErrorWithToken
-    extend T::Sig
-
     attr_reader :conflicting_cask
 
     def initialize(token, conflicting_cask)
@@ -80,11 +77,7 @@ def to_s
   end
 
   # Error when a cask is not available.
-  #
-  # @api private
   class CaskUnavailableError < AbstractCaskErrorWithToken
-    extend T::Sig
-
     sig { returns(String) }
     def to_s
       "Cask '#{token}' is unavailable#{reason.empty? ? "." : ": #{reason}"}"
@@ -92,11 +85,7 @@ def to_s
   end
 
   # Error when a cask is unreadable.
-  #
-  # @api private
   class CaskUnreadableError < CaskUnavailableError
-    extend T::Sig
-
     sig { returns(String) }
     def to_s
       "Cask '#{token}' is unreadable#{reason.empty? ? "." : ": #{reason}"}"
@@ -104,11 +93,7 @@ def to_s
   end
 
   # Error when a cask in a specific tap is not available.
-  #
-  # @api private
   class TapCaskUnavailableError < CaskUnavailableError
-    extend T::Sig
-
     attr_reader :tap
 
     def initialize(tap, token)
@@ -125,54 +110,39 @@ def to_s
   end
 
   # Error when a cask with the same name is found in multiple taps.
-  #
-  # @api private
   class TapCaskAmbiguityError < CaskError
-    extend T::Sig
+    sig { returns(String) }
+    attr_reader :token
+
+    sig { returns(T::Array[CaskLoader::FromNameLoader]) }
+    attr_reader :loaders
+
+    sig { params(token: String, loaders: T::Array[CaskLoader::FromNameLoader]).void }
+    def initialize(token, loaders)
+      @loaders = loaders
+
+      taps = loaders.map(&:tap)
+      casks = taps.map { |tap| "#{tap}/#{token}" }
+      cask_list = casks.sort.map { |f| "\n       * #{f}" }.join
 
-    def initialize(ref, loaders)
       super <<~EOS
-        Cask #{ref} exists in multiple taps:
-        #{loaders.map { |loader| "  #{loader.tap}/#{loader.token}" }.join("\n")}
+        Cask #{token} exists in multiple taps:#{cask_list}
+
+        Please use the fully-qualified name (e.g. #{casks.first}) to refer to a specific Cask.
       EOS
     end
   end
 
   # Error when a cask already exists.
-  #
-  # @api private
   class CaskAlreadyCreatedError < AbstractCaskErrorWithToken
-    extend T::Sig
-
     sig { returns(String) }
     def to_s
       %Q(Cask '#{token}' already exists. Run #{Formatter.identifier("brew edit --cask #{token}")} to edit it.)
     end
   end
 
-  # Error when a cask is already installed.
-  #
-  # @api private
-  class CaskAlreadyInstalledError < AbstractCaskErrorWithToken
-    extend T::Sig
-
-    sig { returns(String) }
-    def to_s
-      <<~EOS
-        Cask '#{token}' is already installed.
-
-        To re-install #{token}, run:
-          #{Formatter.identifier("brew reinstall --cask #{token}")}
-      EOS
-    end
-  end
-
   # Error when there is a cyclic cask dependency.
-  #
-  # @api private
   class CaskCyclicDependencyError < AbstractCaskErrorWithToken
-    extend T::Sig
-
     sig { returns(String) }
     def to_s
       "Cask '#{token}' includes cyclic dependencies on other Casks#{reason.empty? ? "." : ": #{reason}"}"
@@ -180,11 +150,7 @@ def to_s
   end
 
   # Error when a cask depends on itself.
-  #
-  # @api private
   class CaskSelfReferencingDependencyError < CaskCyclicDependencyError
-    extend T::Sig
-
     sig { returns(String) }
     def to_s
       "Cask '#{token}' depends on itself."
@@ -192,11 +158,7 @@ def to_s
   end
 
   # Error when no cask is specified.
-  #
-  # @api private
   class CaskUnspecifiedError < CaskError
-    extend T::Sig
-
     sig { returns(String) }
     def to_s
       "This command requires a Cask token."
@@ -204,11 +166,7 @@ def to_s
   end
 
   # Error when a cask is invalid.
-  #
-  # @api private
   class CaskInvalidError < AbstractCaskErrorWithToken
-    extend T::Sig
-
     sig { returns(String) }
     def to_s
       "Cask '#{token}' definition is invalid#{reason.empty? ? "." : ": #{reason}"}"
@@ -216,8 +174,6 @@ def to_s
   end
 
   # Error when a cask token does not match the file name.
-  #
-  # @api private
   class CaskTokenMismatchError < CaskInvalidError
     def initialize(token, header_token)
       super(token, "Token '#{header_token}' in header line does not match the file name.")
@@ -225,11 +181,7 @@ def initialize(token, header_token)
   end
 
   # Error during quarantining of a file.
-  #
-  # @api private
   class CaskQuarantineError < CaskError
-    extend T::Sig
-
     attr_reader :path, :reason
 
     def initialize(path, reason)
@@ -241,7 +193,7 @@ def initialize(path, reason)
 
     sig { returns(String) }
     def to_s
-      s = +"Failed to quarantine #{path}."
+      s = "Failed to quarantine #{path}."
 
       unless reason.empty?
         s << " Here's the reason:\n"
@@ -254,14 +206,10 @@ def to_s
   end
 
   # Error while propagating quarantine information to subdirectories.
-  #
-  # @api private
   class CaskQuarantinePropagationError < CaskQuarantineError
-    extend T::Sig
-
     sig { returns(String) }
     def to_s
-      s = +"Failed to quarantine one or more files within #{path}."
+      s = "Failed to quarantine one or more files within #{path}."
 
       unless reason.empty?
         s << " Here's the reason:\n"
@@ -274,14 +222,10 @@ def to_s
   end
 
   # Error while removing quarantine information.
-  #
-  # @api private
   class CaskQuarantineReleaseError < CaskQuarantineError
-    extend T::Sig
-
     sig { returns(String) }
     def to_s
-      s = +"Failed to release #{path} from quarantine."
+      s = "Failed to release #{path} from quarantine."
 
       unless reason.empty?
         s << " Here's the reason:\n"
diff --git a/Library/Homebrew/cask/info.rb b/Library/Homebrew/cask/info.rb
new file mode 100644
index 0000000000000..e2e6b3f4de74d
--- /dev/null
+++ b/Library/Homebrew/cask/info.rb
@@ -0,0 +1,132 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "json"
+
+module Cask
+  class Info
+    sig { params(cask: Cask).returns(String) }
+    def self.get_info(cask)
+      require "cask/installer"
+
+      output = "#{title_info(cask)}\n"
+      output << "#{Formatter.url(cask.homepage)}\n" if cask.homepage
+      deprecate_disable = DeprecateDisable.message(cask)
+      output << "#{deprecate_disable.capitalize}\n" if deprecate_disable
+      output << "#{installation_info(cask)}\n"
+      repo = repo_info(cask)
+      output << "#{repo}\n" if repo
+      output << name_info(cask)
+      output << desc_info(cask)
+      deps = deps_info(cask)
+      output << deps if deps
+      language = language_info(cask)
+      output << language if language
+      output << "#{artifact_info(cask)}\n"
+      caveats = Installer.caveats(cask)
+      output << caveats if caveats
+      output
+    end
+
+    sig { params(cask: Cask).void }
+    def self.info(cask)
+      puts get_info(cask)
+
+      require "utils/analytics"
+      ::Utils::Analytics.cask_output(cask, args: Homebrew::CLI::Args.new)
+    end
+
+    sig { params(cask: Cask).returns(String) }
+    def self.title_info(cask)
+      title = "#{oh1_title(cask.token)}: #{cask.version}"
+      title += " (auto_updates)" if cask.auto_updates
+      title
+    end
+
+    sig { params(cask: Cask).returns(String) }
+    def self.installation_info(cask)
+      return "Not installed" unless cask.installed?
+      return "No installed version" unless (installed_version = cask.installed_version).present?
+
+      versioned_staged_path = cask.caskroom_path.join(installed_version)
+
+      return "Installed\n#{versioned_staged_path} (#{Formatter.error("does not exist")})\n" unless versioned_staged_path.exist?
+
+      path_details = versioned_staged_path.children.sum(&:disk_usage)
+
+      tab = Tab.for_cask(cask)
+
+      info = ["Installed"]
+      info << "#{versioned_staged_path} (#{disk_usage_readable(path_details)})"
+      info << "  #{tab}" if tab.tabfile&.exist?
+      info.join("\n")
+    end
+
+    sig { params(cask: Cask).returns(String) }
+    def self.name_info(cask)
+      <<~EOS
+        #{ohai_title((cask.name.size > 1) ? "Names" : "Name")}
+        #{cask.name.empty? ? Formatter.error("None") : cask.name.join("\n")}
+      EOS
+    end
+
+    sig { params(cask: Cask).returns(String) }
+    def self.desc_info(cask)
+      <<~EOS
+        #{ohai_title("Description")}
+        #{cask.desc.nil? ? Formatter.error("None") : cask.desc}
+      EOS
+    end
+
+    sig { params(cask: Cask).returns(T.nilable(String)) }
+    def self.deps_info(cask)
+      depends_on = cask.depends_on
+
+      formula_deps = Array(depends_on[:formula]).map(&:to_s)
+      cask_deps = Array(depends_on[:cask]).map { |dep| "#{dep} (cask)" }
+
+      all_deps = formula_deps + cask_deps
+      return if all_deps.empty?
+
+      <<~EOS
+        #{ohai_title("Dependencies")}
+        #{all_deps.join(", ")}
+      EOS
+    end
+
+    sig { params(cask: Cask).returns(T.nilable(String)) }
+    def self.language_info(cask)
+      return if cask.languages.empty?
+
+      <<~EOS
+        #{ohai_title("Languages")}
+        #{cask.languages.join(", ")}
+      EOS
+    end
+
+    sig { params(cask: Cask).returns(T.nilable(String)) }
+    def self.repo_info(cask)
+      return if cask.tap.nil?
+
+      url = if cask.tap.custom_remote? && !cask.tap.remote.nil?
+        cask.tap.remote
+      else
+        "#{cask.tap.default_remote}/blob/HEAD/#{cask.tap.relative_cask_path(cask.token)}"
+      end
+
+      "From: #{Formatter.url(url)}"
+    end
+
+    sig { params(cask: Cask).returns(String) }
+    def self.artifact_info(cask)
+      artifact_output = ohai_title("Artifacts").dup
+      cask.artifacts.each do |artifact|
+        next unless artifact.respond_to?(:install_phase)
+        next unless DSL::ORDINARY_ARTIFACT_CLASSES.include?(artifact.class)
+
+        artifact_output << "\n" << artifact.to_s
+      end
+      artifact_output.freeze
+    end
+  end
+end
diff --git a/Library/Homebrew/cask/installer.rb b/Library/Homebrew/cask/installer.rb
index ed69a5f5cecb5..0874fceb32a4a 100644
--- a/Library/Homebrew/cask/installer.rb
+++ b/Library/Homebrew/cask/installer.rb
@@ -1,55 +1,49 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "attrable"
 require "formula_installer"
 require "unpack_strategy"
 require "utils/topological_hash"
 
 require "cask/config"
 require "cask/download"
-require "cask/staged"
+require "cask/migrator"
 require "cask/quarantine"
+require "cask/tab"
 
 require "cgi"
 
 module Cask
   # Installer for a {Cask}.
-  #
-  # @api private
   class Installer
-    extend T::Sig
+    extend Attrable
 
-    extend Predicable
-    # TODO: it is unwise for Cask::Staged to be a module, when we are
-    #       dealing with both staged and unstaged casks here. This should
-    #       either be a class which is only sometimes instantiated, or there
-    #       should be explicit checks on whether staged state is valid in
-    #       every method.
-    include Staged
-
-    def initialize(cask, command: SystemCommand, force: false,
+    def initialize(cask, command: SystemCommand, force: false, adopt: false,
                    skip_cask_deps: false, binaries: true, verbose: false,
-                   zap: false, require_sha: false, upgrade: false,
-                   installed_as_dependency: false, quarantine: true,
-                   verify_download_integrity: true, quiet: false)
+                   zap: false, require_sha: false, upgrade: false, reinstall: false,
+                   installed_as_dependency: false, installed_on_request: true,
+                   quarantine: true, verify_download_integrity: true, quiet: false)
       @cask = cask
       @command = command
       @force = force
+      @adopt = adopt
       @skip_cask_deps = skip_cask_deps
       @binaries = binaries
       @verbose = verbose
       @zap = zap
       @require_sha = require_sha
-      @reinstall = false
+      @reinstall = reinstall
       @upgrade = upgrade
       @installed_as_dependency = installed_as_dependency
+      @installed_on_request = installed_on_request
       @quarantine = quarantine
       @verify_download_integrity = verify_download_integrity
       @quiet = quiet
     end
 
-    attr_predicate :binaries?, :force?, :skip_cask_deps?, :require_sha?,
-                   :reinstall?, :upgrade?, :verbose?, :zap?, :installed_as_dependency?,
+    attr_predicate :binaries?, :force?, :adopt?, :skip_cask_deps?, :require_sha?,
+                   :reinstall?, :upgrade?, :verbose?, :zap?, :installed_as_dependency?, :installed_on_request?,
                    :quarantine?, :quiet?
 
     def self.caveats(cask)
@@ -70,11 +64,16 @@ def self.caveats(cask)
     def fetch(quiet: nil, timeout: nil)
       odebug "Cask::Installer#fetch"
 
+      load_cask_from_source_api! if @cask.loaded_from_api? && @cask.caskfile_only?
       verify_has_sha if require_sha? && !force?
+      check_requirements
+
+      forbidden_tap_check
+      forbidden_cask_and_formula_check
 
-      download(quiet: quiet, timeout: timeout)
+      download(quiet:, timeout:)
 
-      satisfy_dependencies
+      satisfy_cask_and_formula_dependencies
     end
 
     def stage
@@ -93,13 +92,12 @@ def install
       start_time = Time.now
       odebug "Cask::Installer#install"
 
-      old_config = @cask.config
-      if @cask.installed? && !force? && !reinstall? && !upgrade?
-        return if quiet?
+      Migrator.migrate_if_needed(@cask)
 
-        raise CaskAlreadyInstalledError, @cask
-      end
+      old_config = @cask.config
+      predecessor = @cask if reinstall? && @cask.installed?
 
+      check_deprecate_disable
       check_conflicts
 
       print caveats
@@ -114,9 +112,17 @@ def install
 
       @cask.config = @cask.default_config.merge(old_config)
 
-      install_artifacts
+      install_artifacts(predecessor:)
 
-      ::Utils::Analytics.report_event("cask_install", @cask.token) unless @cask.tap&.private?
+      tab = Tab.create(@cask)
+      tab.installed_as_dependency = installed_as_dependency?
+      tab.installed_on_request = installed_on_request?
+      tab.write
+
+      if (tap = @cask.tap) && tap.should_report_analytics?
+        ::Utils::Analytics.report_package_event(:cask_install, package_name: @cask.token, tap_name: tap.name,
+on_request: true)
+      end
 
       purge_backed_up_versioned_files
 
@@ -128,12 +134,28 @@ def install
       raise
     end
 
+    def check_deprecate_disable
+      deprecate_disable_type = DeprecateDisable.type(@cask)
+      return if deprecate_disable_type.nil?
+
+      message = DeprecateDisable.message(@cask)
+      message_full = "#{@cask.token} has been #{message}"
+
+      case deprecate_disable_type
+      when :deprecated
+        opoo message_full
+      when :disabled
+        GitHub::Actions.puts_annotation_if_env_set(:error, message)
+        raise CaskCannotBeInstalledError.new(@cask, message)
+      end
+    end
+
     def check_conflicts
       return unless @cask.conflicts_with
 
       @cask.conflicts_with[:cask].each do |conflicting_cask|
-        if (match = conflicting_cask.match(HOMEBREW_TAP_CASK_REGEX))
-          conflicting_cask_tap = Tap.fetch(match[1], match[2])
+        if (conflicting_cask_tap_with_token = Tap.with_cask_token(conflicting_cask))
+          conflicting_cask_tap, = conflicting_cask_tap_with_token
           next unless conflicting_cask_tap.installed?
         end
 
@@ -144,26 +166,12 @@ def check_conflicts
       end
     end
 
-    def reinstall
-      odebug "Cask::Installer#reinstall"
-      @reinstall = true
-      install
-    end
-
     def uninstall_existing_cask
       return unless @cask.installed?
 
-      # use the same cask file that was used for installation, if possible
-      installed_caskfile = @cask.installed_caskfile
-      installed_cask = begin
-        installed_caskfile.exist? ? CaskLoader.load(installed_caskfile) : @cask
-      rescue CaskInvalidError # could be thrown by call to CaskLoader#load with outdated caskfile
-        @cask # default
-      end
-
       # Always force uninstallation, ignore method parameter
-      cask_installer = Installer.new(installed_cask, verbose: verbose?, force: true, upgrade: upgrade?)
-      zap? ? cask_installer.zap : cask_installer.uninstall
+      cask_installer = Installer.new(@cask, verbose: verbose?, force: true, upgrade: upgrade?, reinstall: true)
+      zap? ? cask_installer.zap : cask_installer.uninstall(successor: @cask)
     end
 
     sig { returns(String) }
@@ -182,13 +190,13 @@ def downloader
     sig { params(quiet: T.nilable(T::Boolean), timeout: T.nilable(T.any(Integer, Float))).returns(Pathname) }
     def download(quiet: nil, timeout: nil)
       # Store cask download path in cask to prevent multiple downloads in a row when checking if it's outdated
-      @cask.download ||= downloader.fetch(quiet: quiet, verify_download_integrity: @verify_download_integrity,
-                                          timeout: timeout)
+      @cask.download ||= downloader.fetch(quiet:, verify_download_integrity: @verify_download_integrity,
+                                          timeout:)
     end
 
     def verify_has_sha
       odebug "Checking cask has checksum"
-      return unless @cask.sha256 == :no_check
+      return if @cask.sha256 != :no_check
 
       raise CaskError, <<~EOS
         Cask '#{@cask}' does not have a sha256 checksum defined and was not installed.
@@ -211,31 +219,31 @@ def extract_primary_container(to: @cask.staged_path)
       basename = downloader.basename
 
       if (nested_container = @cask.container&.nested)
-        Dir.mktmpdir do |tmpdir|
+        Dir.mktmpdir("cask-installer", HOMEBREW_TEMP) do |tmpdir|
           tmpdir = Pathname(tmpdir)
-          primary_container.extract(to: tmpdir, basename: basename, verbose: verbose?)
+          primary_container.extract(to: tmpdir, basename:, verbose: verbose?)
 
           FileUtils.chmod_R "+rw", tmpdir/nested_container, force: true, verbose: verbose?
 
           UnpackStrategy.detect(tmpdir/nested_container, merge_xattrs: true)
-                        .extract_nestedly(to: to, verbose: verbose?)
+                        .extract_nestedly(to:, verbose: verbose?)
         end
       else
-        primary_container.extract_nestedly(to: to, basename: basename, verbose: verbose?)
+        primary_container.extract_nestedly(to:, basename:, verbose: verbose?)
       end
 
       return unless quarantine?
       return unless Quarantine.available?
 
-      Quarantine.propagate(from: primary_container.path, to: to)
+      Quarantine.propagate(from: primary_container.path, to:)
     end
 
-    def install_artifacts
+    sig { params(predecessor: T.nilable(Cask)).void }
+    def install_artifacts(predecessor: nil)
       artifacts = @cask.artifacts
       already_installed_artifacts = []
 
       odebug "Installing artifacts"
-      odebug "#{artifacts.length} #{"artifact".pluralize(artifacts.length)} defined", artifacts
 
       artifacts.each do |artifact|
         next unless artifact.respond_to?(:install_phase)
@@ -244,7 +252,10 @@ def install_artifacts
 
         next if artifact.is_a?(Artifact::Binary) && !binaries?
 
-        artifact.install_phase(command: @command, verbose: verbose?, force: force?)
+        artifact.install_phase(
+          command: @command, verbose: verbose?, adopt: adopt?, auto_updates: @cask.auto_updates,
+          force: force?, predecessor:
+        )
         already_installed_artifacts.unshift(artifact)
       end
 
@@ -252,7 +263,7 @@ def install_artifacts
       save_download_sha if @cask.version.latest?
     rescue => e
       begin
-        already_installed_artifacts.each do |artifact|
+        already_installed_artifacts&.each do |artifact|
           if artifact.respond_to?(:uninstall_phase)
             odebug "Reverting installation of artifact of class #{artifact.class}"
             artifact.uninstall_phase(command: @command, verbose: verbose?, force: force?)
@@ -269,25 +280,19 @@ def install_artifacts
       end
     end
 
-    # TODO: move dependencies to a separate class,
-    #       dependencies should also apply for `brew cask stage`,
-    #       override dependencies with `--force` or perhaps `--force-deps`
-    def satisfy_dependencies
-      return unless @cask.depends_on
-
-      macos_dependencies
-      arch_dependencies
-      cask_and_formula_dependencies
+    def check_requirements
+      check_macos_requirements
+      check_arch_requirements
     end
 
-    def macos_dependencies
+    def check_macos_requirements
       return unless @cask.depends_on.macos
       return if @cask.depends_on.macos.satisfied?
 
       raise CaskError, @cask.depends_on.macos.message(type: :cask)
     end
 
-    def arch_dependencies
+    def check_arch_requirements
       return if @cask.depends_on.arch.nil?
 
       @current_arch ||= { type: Hardware::CPU.type, bits: Hardware::CPU.bits }
@@ -302,12 +307,12 @@ def arch_dependencies
             "but you are running #{@current_arch}."
     end
 
-    def collect_cask_and_formula_dependencies
+    def cask_and_formula_dependencies
       return @cask_and_formula_dependencies if @cask_and_formula_dependencies
 
       graph = ::Utils::TopologicalHash.graph_package_dependencies(@cask)
 
-      raise CaskSelfReferencingDependencyError, cask.token if graph[@cask].include?(@cask)
+      raise CaskSelfReferencingDependencyError, @cask.token if graph[@cask].include?(@cask)
 
       ::Utils::TopologicalHash.graph_package_dependencies(primary_container.dependencies, graph)
 
@@ -321,27 +326,27 @@ def collect_cask_and_formula_dependencies
     end
 
     def missing_cask_and_formula_dependencies
-      collect_cask_and_formula_dependencies.reject do |cask_or_formula|
-        installed = if cask_or_formula.respond_to?(:any_version_installed?)
-          cask_or_formula.any_version_installed?
-        else
-          cask_or_formula.try(:installed?)
+      cask_and_formula_dependencies.reject do |cask_or_formula|
+        case cask_or_formula
+        when Formula
+          cask_or_formula.any_version_installed? && cask_or_formula.optlinked?
+        when Cask
+          cask_or_formula.installed?
         end
-        installed && (cask_or_formula.respond_to?(:optlinked?) ? cask_or_formula.optlinked? : true)
       end
     end
 
-    def cask_and_formula_dependencies
+    def satisfy_cask_and_formula_dependencies
       return if installed_as_dependency?
 
-      formulae_and_casks = collect_cask_and_formula_dependencies
+      formulae_and_casks = cask_and_formula_dependencies
 
       return if formulae_and_casks.empty?
 
       missing_formulae_and_casks = missing_cask_and_formula_dependencies
 
       if missing_formulae_and_casks.empty?
-        puts "All formula dependencies satisfied."
+        puts "All dependencies satisfied."
         return
       end
 
@@ -355,12 +360,15 @@ def cask_and_formula_dependencies
 
           Installer.new(
             cask_or_formula,
+            adopt:                   adopt?,
             binaries:                binaries?,
             verbose:                 verbose?,
             installed_as_dependency: true,
+            installed_on_request:    false,
             force:                   false,
           ).install
         else
+          Homebrew::Install.perform_preinstall_checks_once
           fi = FormulaInstaller.new(
             cask_or_formula,
             **{
@@ -382,14 +390,18 @@ def caveats
       self.class.caveats(@cask)
     end
 
+    def metadata_subdir
+      @metadata_subdir ||= @cask.metadata_subdir("Casks", timestamp: :now, create: true)
+    end
+
     def save_caskfile
       old_savedir = @cask.metadata_timestamped_path
 
       return if @cask.source.blank?
 
-      savedir = @cask.metadata_subdir("Casks", timestamp: :now, create: true)
-      (savedir/"#{@cask.token}.rb").write @cask.source
-      old_savedir&.rmtree
+      extension = @cask.loaded_from_api? ? "json" : "rb"
+      (metadata_subdir/"#{@cask.token}.#{extension}").write @cask.source
+      FileUtils.rm_r(old_savedir) if old_savedir
     end
 
     def save_config_file
@@ -400,10 +412,13 @@ def save_download_sha
       @cask.download_sha_path.atomic_write(@cask.new_download_sha) if @cask.checksumable?
     end
 
-    def uninstall
+    sig { params(successor: T.nilable(Cask)).void }
+    def uninstall(successor: nil)
+      load_installed_caskfile!
       oh1 "Uninstalling Cask #{Formatter.identifier(@cask)}"
-      uninstall_artifacts(clear: true)
+      uninstall_artifacts(clear: true, successor:)
       if !reinstall? && !upgrade?
+        remove_tabfile
         remove_download_sha
         remove_config_file
       end
@@ -411,17 +426,25 @@ def uninstall
       purge_caskroom_path if force?
     end
 
+    def remove_tabfile
+      tabfile = @cask.tab.tabfile
+      FileUtils.rm_f tabfile if tabfile
+      @cask.config_path.parent.rmdir_if_possible
+    end
+
     def remove_config_file
       FileUtils.rm_f @cask.config_path
       @cask.config_path.parent.rmdir_if_possible
     end
 
     def remove_download_sha
-      FileUtils.rm_f @cask.download_sha_path if @cask.download_sha_path.exist?
+      FileUtils.rm_f @cask.download_sha_path
+      @cask.download_sha_path.parent.rmdir_if_possible
     end
 
-    def start_upgrade
-      uninstall_artifacts
+    sig { params(successor: T.nilable(Cask)).void }
+    def start_upgrade(successor:)
+      uninstall_artifacts(successor:)
       backup
     end
 
@@ -433,17 +456,18 @@ def backup
     def restore_backup
       return if !backup_path.directory? || !backup_metadata_path.directory?
 
-      Pathname.new(@cask.staged_path).rmtree if @cask.staged_path.exist?
-      Pathname.new(@cask.metadata_versioned_path).rmtree if @cask.metadata_versioned_path.exist?
+      FileUtils.rm_r(@cask.staged_path) if @cask.staged_path.exist?
+      FileUtils.rm_r(@cask.metadata_versioned_path) if @cask.metadata_versioned_path.exist?
 
       backup_path.rename @cask.staged_path
       backup_metadata_path.rename @cask.metadata_versioned_path
     end
 
-    def revert_upgrade
+    sig { params(predecessor: Cask).void }
+    def revert_upgrade(predecessor:)
       opoo "Reverting upgrade for Cask #{@cask}"
       restore_backup
-      install_artifacts
+      install_artifacts(predecessor:)
     end
 
     def finalize_upgrade
@@ -454,17 +478,24 @@ def finalize_upgrade
       puts summary
     end
 
-    def uninstall_artifacts(clear: false)
+    sig { params(clear: T::Boolean, successor: T.nilable(Cask)).void }
+    def uninstall_artifacts(clear: false, successor: nil)
       artifacts = @cask.artifacts
 
       odebug "Uninstalling artifacts"
-      odebug "#{artifacts.length} #{"artifact".pluralize(artifacts.length)} defined", artifacts
+      odebug "#{::Utils.pluralize("artifact", artifacts.length, include_count: true)} defined", artifacts
 
       artifacts.each do |artifact|
         if artifact.respond_to?(:uninstall_phase)
           odebug "Uninstalling artifact of class #{artifact.class}"
           artifact.uninstall_phase(
-            command: @command, verbose: verbose?, skip: clear, force: force?, upgrade: upgrade?,
+            command:   @command,
+            verbose:   verbose?,
+            skip:      clear,
+            force:     force?,
+            successor:,
+            upgrade:   upgrade?,
+            reinstall: reinstall?,
           )
         end
 
@@ -472,12 +503,17 @@ def uninstall_artifacts(clear: false)
 
         odebug "Post-uninstalling artifact of class #{artifact.class}"
         artifact.post_uninstall_phase(
-          command: @command, verbose: verbose?, skip: clear, force: force?, upgrade: upgrade?,
+          command:   @command,
+          verbose:   verbose?,
+          skip:      clear,
+          force:     force?,
+          successor:,
         )
       end
     end
 
     def zap
+      load_installed_caskfile!
       ohai "Implied `brew uninstall --cask #{@cask}`"
       uninstall_artifacts
       if (zap_stanzas = @cask.artifacts.select { |a| a.is_a?(Artifact::Zap) }).empty?
@@ -539,11 +575,138 @@ def purge_versioned_files
 
       # toplevel staged distribution
       @cask.caskroom_path.rmdir_if_possible unless upgrade?
+
+      # Remove symlinks for renamed casks if they are now broken.
+      @cask.old_tokens.each do |old_token|
+        old_caskroom_path = Caskroom.path/old_token
+        FileUtils.rm old_caskroom_path if old_caskroom_path.symlink? && !old_caskroom_path.exist?
+      end
     end
 
     def purge_caskroom_path
       odebug "Purging all staged versions of Cask #{@cask}"
       gain_permissions_remove(@cask.caskroom_path)
     end
+
+    sig { void }
+    def forbidden_tap_check
+      return if Tap.allowed_taps.blank? && Tap.forbidden_taps.blank?
+
+      owner = Homebrew::EnvConfig.forbidden_owner
+      owner_contact = if (contact = Homebrew::EnvConfig.forbidden_owner_contact.presence)
+        "\n#{contact}"
+      end
+
+      unless skip_cask_deps?
+        cask_and_formula_dependencies.each do |cask_or_formula|
+          dep_tap = cask_or_formula.tap
+          next if dep_tap.blank? || (dep_tap.allowed_by_env? && !dep_tap.forbidden_by_env?)
+
+          dep_full_name = cask_or_formula.full_name
+          error_message = "The installation of #{@cask} has a dependency #{dep_full_name}\n" \
+                          "from the #{dep_tap} tap but #{owner} "
+          error_message << "has not allowed this tap in `HOMEBREW_ALLOWED_TAPS`" unless dep_tap.allowed_by_env?
+          error_message << " and\n" if !dep_tap.allowed_by_env? && dep_tap.forbidden_by_env?
+          error_message << "has forbidden this tap in `HOMEBREW_FORBIDDEN_TAPS`" if dep_tap.forbidden_by_env?
+          error_message << ".#{owner_contact}"
+
+          raise CaskCannotBeInstalledError.new(@cask, error_message)
+        end
+      end
+
+      cask_tap = @cask.tap
+      return if cask_tap.blank? || (cask_tap.allowed_by_env? && !cask_tap.forbidden_by_env?)
+
+      error_message = "The installation of #{@cask.full_name} has the tap #{cask_tap}\n" \
+                      "but #{owner} "
+      error_message << "has not allowed this tap in `HOMEBREW_ALLOWED_TAPS`" unless cask_tap.allowed_by_env?
+      error_message << " and\n" if !cask_tap.allowed_by_env? && cask_tap.forbidden_by_env?
+      error_message << "has forbidden this tap in `HOMEBREW_FORBIDDEN_TAPS`" if cask_tap.forbidden_by_env?
+      error_message << ".#{owner_contact}"
+
+      raise CaskCannotBeInstalledError.new(@cask, error_message)
+    end
+
+    sig { void }
+    def forbidden_cask_and_formula_check
+      forbidden_formulae = Set.new(Homebrew::EnvConfig.forbidden_formulae.to_s.split)
+      forbidden_casks = Set.new(Homebrew::EnvConfig.forbidden_casks.to_s.split)
+      return if forbidden_formulae.blank? && forbidden_casks.blank?
+
+      owner = Homebrew::EnvConfig.forbidden_owner
+      owner_contact = if (contact = Homebrew::EnvConfig.forbidden_owner_contact.presence)
+        "\n#{contact}"
+      end
+
+      unless skip_cask_deps?
+        cask_and_formula_dependencies.each do |dep_cask_or_formula|
+          dep_name, dep_type, variable = if dep_cask_or_formula.is_a?(Cask) && forbidden_casks.present?
+            dep_cask = dep_cask_or_formula
+            dep_cask_name = if forbidden_casks.include?(dep_cask.token)
+              dep_cask.token
+            elsif dep_cask.tap.present? &&
+                  forbidden_casks.include?(dep_cask.full_name)
+              dep_cask.full_name
+            end
+            [dep_cask_name, "cask", "HOMEBREW_FORBIDDEN_CASKS"]
+          elsif dep_cask_or_formula.is_a?(Formula) && forbidden_formulae.present?
+            dep_formula = dep_cask_or_formula
+            formula_name = if forbidden_formulae.include?(dep_formula.name)
+              dep_formula.name
+            elsif dep_formula.tap.present? &&
+                  forbidden_formulae.include?(dep_formula.full_name)
+              dep_formula.full_name
+            end
+            [formula_name, "formula", "HOMEBREW_FORBIDDEN_FORMULAE"]
+          end
+          next if dep_name.blank?
+
+          raise CaskCannotBeInstalledError.new(@cask, <<~EOS
+            has a dependency #{dep_name} but the
+            #{dep_name} #{dep_type} was forbidden for installation by #{owner} in `#{variable}`.#{owner_contact}
+          EOS
+          )
+        end
+      end
+      return if forbidden_casks.blank?
+
+      if forbidden_casks.include?(@cask.token)
+        @cask.token
+      elsif forbidden_casks.include?(@cask.full_name)
+        @cask.full_name
+      else
+        return
+      end
+
+      raise CaskCannotBeInstalledError.new(@cask, <<~EOS
+        forbidden for installation by #{owner} in `HOMEBREW_FORBIDDEN_CASKS`.#{owner_contact}
+      EOS
+      )
+    end
+
+    private
+
+    # load the same cask file that was used for installation, if possible
+    def load_installed_caskfile!
+      Migrator.migrate_if_needed(@cask)
+
+      installed_caskfile = @cask.installed_caskfile
+
+      if installed_caskfile&.exist?
+        begin
+          @cask = CaskLoader.load(installed_caskfile)
+          return
+        rescue CaskInvalidError
+          # could be caused by trying to load outdated caskfile
+        end
+      end
+
+      load_cask_from_source_api! if @cask.loaded_from_api? && @cask.caskfile_only?
+      # otherwise we default to the current cask
+    end
+
+    def load_cask_from_source_api!
+      @cask = Homebrew::API::Cask.source_download(@cask)
+    end
   end
 end
diff --git a/Library/Homebrew/cask/list.rb b/Library/Homebrew/cask/list.rb
new file mode 100644
index 0000000000000..519123f876d98
--- /dev/null
+++ b/Library/Homebrew/cask/list.rb
@@ -0,0 +1,48 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "cask/artifact/relocated"
+
+module Cask
+  class List
+    def self.list_casks(*casks, one: false, full_name: false, versions: false)
+      output = if casks.any?
+        casks.each do |cask|
+          raise CaskNotInstalledError, cask unless cask.installed?
+        end
+      else
+        Caskroom.casks
+      end
+
+      if one
+        puts output.map(&:to_s)
+      elsif full_name
+        puts output.map(&:full_name).sort(&tap_and_name_comparison)
+      elsif versions
+        puts output.map { format_versioned(_1) }
+      elsif !output.empty? && casks.any?
+        output.map { list_artifacts(_1) }
+      elsif !output.empty?
+        puts Formatter.columns(output.map(&:to_s))
+      end
+    end
+
+    def self.list_artifacts(cask)
+      cask.artifacts.group_by(&:class).sort_by { |klass, _| klass.english_name }.each do |klass, artifacts|
+        next if [Artifact::Uninstall, Artifact::Zap].include? klass
+
+        ohai klass.english_name
+        artifacts.each do |artifact|
+          puts artifact.summarize_installed if artifact.respond_to?(:summarize_installed)
+          next if artifact.respond_to?(:summarize_installed)
+
+          puts artifact
+        end
+      end
+    end
+
+    def self.format_versioned(cask)
+      "#{cask}#{cask.installed_version&.prepend(" ")}"
+    end
+  end
+end
diff --git a/Library/Homebrew/cask/macos.rb b/Library/Homebrew/cask/macos.rb
index be2693b239111..ac1a2349b9c1e 100644
--- a/Library/Homebrew/cask/macos.rb
+++ b/Library/Homebrew/cask/macos.rb
@@ -1,8 +1,6 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "os/mac/version"
-
 module OS
   module Mac
     module_function
@@ -378,8 +376,7 @@ module Mac
       "~/Library/Widgets",
       "~/Library/Workflows",
     ]
-                        .map { |path| Pathname(path.sub(%r{^~(?=(/|$))}, Dir.home)).expand_path }
-                        .to_set
+                        .to_set { |path| Pathname(path.sub(%r{^~(?=(/|$))}, Dir.home)).expand_path }
                         .union(SYSTEM_DIRS)
                         .freeze
     private_constant :UNDELETABLE_PATHS
diff --git a/Library/Homebrew/cask/metadata.rb b/Library/Homebrew/cask/metadata.rb
index c2db2e2cc0e30..39ab2d8c5bec7 100644
--- a/Library/Homebrew/cask/metadata.rb
+++ b/Library/Homebrew/cask/metadata.rb
@@ -1,34 +1,37 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module Cask
   # Helper module for reading and writing cask metadata.
-  #
-  # @api private
   module Metadata
+    extend T::Helpers
+
     METADATA_SUBDIR = ".metadata"
     TIMESTAMP_FORMAT = "%Y%m%d%H%M%S.%L"
 
-    def metadata_main_container_path
-      @metadata_main_container_path ||= caskroom_path.join(METADATA_SUBDIR)
+    requires_ancestor { Cask }
+
+    def metadata_main_container_path(caskroom_path: self.caskroom_path)
+      caskroom_path.join(METADATA_SUBDIR)
     end
 
-    def metadata_versioned_path(version: self.version)
+    def metadata_versioned_path(version: self.version, caskroom_path: self.caskroom_path)
       cask_version = (version || :unknown).to_s
 
       raise CaskError, "Cannot create metadata path with empty version." if cask_version.empty?
 
-      metadata_main_container_path.join(cask_version)
+      metadata_main_container_path(caskroom_path:).join(cask_version)
     end
 
-    def metadata_timestamped_path(version: self.version, timestamp: :latest, create: false)
+    def metadata_timestamped_path(version: self.version, timestamp: :latest, create: false,
+                                  caskroom_path: self.caskroom_path)
       raise CaskError, "Cannot create metadata path when timestamp is :latest." if create && timestamp == :latest
 
       path = if timestamp == :latest
-        Pathname.glob(metadata_versioned_path(version: version).join("*")).max
+        Pathname.glob(metadata_versioned_path(version:, caskroom_path:).join("*")).max
       else
         timestamp = new_timestamp if timestamp == :now
-        metadata_versioned_path(version: version).join(timestamp)
+        metadata_versioned_path(version:, caskroom_path:).join(timestamp)
       end
 
       if create && !path.directory?
@@ -39,11 +42,13 @@ def metadata_timestamped_path(version: self.version, timestamp: :latest, create:
       path
     end
 
-    def metadata_subdir(leaf, version: self.version, timestamp: :latest, create: false)
+    def metadata_subdir(leaf, version: self.version, timestamp: :latest, create: false,
+                        caskroom_path: self.caskroom_path)
       raise CaskError, "Cannot create metadata subdir when timestamp is :latest." if create && timestamp == :latest
       raise CaskError, "Cannot create metadata subdir for empty leaf." if !leaf.respond_to?(:empty?) || leaf.empty?
 
-      parent = metadata_timestamped_path(version: version, timestamp: timestamp, create: create)
+      parent = metadata_timestamped_path(version:, timestamp:, create:,
+                                         caskroom_path:)
 
       return if parent.nil?
 
diff --git a/Library/Homebrew/cask/migrator.rb b/Library/Homebrew/cask/migrator.rb
new file mode 100644
index 0000000000000..1b9648869500b
--- /dev/null
+++ b/Library/Homebrew/cask/migrator.rb
@@ -0,0 +1,87 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "cask/cask_loader"
+require "utils/inreplace"
+
+module Cask
+  class Migrator
+    sig { returns(Cask) }
+    attr_reader :old_cask, :new_cask
+
+    sig { params(old_cask: Cask, new_cask: Cask).void }
+    def initialize(old_cask, new_cask)
+      raise CaskNotInstalledError, new_cask unless new_cask.installed?
+
+      @old_cask = old_cask
+      @new_cask = new_cask
+    end
+
+    sig { params(new_cask: Cask, dry_run: T::Boolean).void }
+    def self.migrate_if_needed(new_cask, dry_run: false)
+      old_tokens = new_cask.old_tokens
+      return if old_tokens.empty?
+
+      return unless (installed_caskfile = new_cask.installed_caskfile)
+
+      old_cask = CaskLoader.load(installed_caskfile)
+      return if new_cask.token == old_cask.token
+
+      migrator = new(old_cask, new_cask)
+      migrator.migrate(dry_run:)
+    end
+
+    sig { params(dry_run: T::Boolean).void }
+    def migrate(dry_run: false)
+      old_token = old_cask.token
+      new_token = new_cask.token
+
+      old_caskroom_path = old_cask.caskroom_path
+      new_caskroom_path = new_cask.caskroom_path
+
+      old_caskfile = old_cask.installed_caskfile
+      return if old_caskfile.nil?
+
+      old_installed_caskfile = old_caskfile.relative_path_from(old_caskroom_path)
+      new_installed_caskfile = old_installed_caskfile.dirname/old_installed_caskfile.basename.sub(
+        old_token,
+        new_token,
+      )
+
+      if dry_run
+        oh1 "Would migrate cask #{Formatter.identifier(old_token)} to #{Formatter.identifier(new_token)}"
+
+        puts "cp -r #{old_caskroom_path} #{new_caskroom_path}"
+        puts "mv #{new_caskroom_path}/#{old_installed_caskfile} #{new_caskroom_path}/#{new_installed_caskfile}"
+        puts "rm -r #{old_caskroom_path}"
+        puts "ln -s #{new_caskroom_path.basename} #{old_caskroom_path}"
+      else
+        oh1 "Migrating cask #{Formatter.identifier(old_token)} to #{Formatter.identifier(new_token)}"
+
+        begin
+          FileUtils.cp_r old_caskroom_path, new_caskroom_path
+          FileUtils.mv new_caskroom_path/old_installed_caskfile, new_caskroom_path/new_installed_caskfile
+          self.class.replace_caskfile_token(new_caskroom_path/new_installed_caskfile, old_token, new_token)
+        rescue => e
+          FileUtils.rm_rf new_caskroom_path
+          raise e
+        end
+
+        FileUtils.rm_r old_caskroom_path
+        FileUtils.ln_s new_caskroom_path.basename, old_caskroom_path
+      end
+    end
+
+    sig { params(path: Pathname, old_token: String, new_token: String).void }
+    def self.replace_caskfile_token(path, old_token, new_token)
+      case path.extname
+      when ".rb"
+        ::Utils::Inreplace.inreplace path, /\A\s*cask\s+"#{Regexp.escape(old_token)}"/, "cask #{new_token.inspect}"
+      when ".json"
+        json = JSON.parse(path.read)
+        json["token"] = new_token
+        path.atomic_write json.to_json
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cask/pkg.rb b/Library/Homebrew/cask/pkg.rb
index 83447c4b6ebde..39f13c54f7711 100644
--- a/Library/Homebrew/cask/pkg.rb
+++ b/Library/Homebrew/cask/pkg.rb
@@ -1,15 +1,11 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask/macos"
 
 module Cask
   # Helper class for uninstalling `.pkg` installers.
-  #
-  # @api private
   class Pkg
-    extend T::Sig
-
     sig { params(regexp: String, command: T.class_of(SystemCommand)).returns(T::Array[Pkg]) }
     def self.all_matching(regexp, command)
       command.run("/usr/sbin/pkgutil", args: ["--pkgs=#{regexp}"]).stdout.split("\n").map do |package_id|
@@ -32,9 +28,10 @@ def uninstall
         odebug "Deleting pkg files"
         @command.run!(
           "/usr/bin/xargs",
-          args:  ["-0", "--", "/bin/rm", "--"],
-          input: pkgutil_bom_files.join("\0"),
-          sudo:  true,
+          args:         ["-0", "--", "/bin/rm", "--"],
+          input:        pkgutil_bom_files.join("\0"),
+          sudo:         true,
+          sudo_as_root: true,
         )
       end
 
@@ -42,9 +39,10 @@ def uninstall
         odebug "Deleting pkg symlinks and special files"
         @command.run!(
           "/usr/bin/xargs",
-          args:  ["-0", "--", "/bin/rm", "--"],
-          input: pkgutil_bom_specials.join("\0"),
-          sudo:  true,
+          args:         ["-0", "--", "/bin/rm", "--"],
+          input:        pkgutil_bom_specials.join("\0"),
+          sudo:         true,
+          sudo_as_root: true,
         )
       end
 
@@ -61,7 +59,12 @@ def uninstall
     sig { void }
     def forget
       odebug "Unregistering pkg receipt (aka forgetting)"
-      @command.run!("/usr/sbin/pkgutil", args: ["--forget", package_id], sudo: true)
+      @command.run!(
+        "/usr/sbin/pkgutil",
+        args:         ["--forget", package_id],
+        sudo:         true,
+        sudo_as_root: true,
+      )
     end
 
     sig { returns(T::Array[Pathname]) }
@@ -71,7 +74,7 @@ def pkgutil_bom_files
 
     sig { returns(T::Array[Pathname]) }
     def pkgutil_bom_specials
-      @pkgutil_bom_specials ||= pkgutil_bom_all.select(&method(:special?))
+      @pkgutil_bom_specials ||= pkgutil_bom_all.select { special?(_1) }
     end
 
     sig { returns(T::Array[Pathname]) }
@@ -85,7 +88,7 @@ def pkgutil_bom_all
                                    .stdout
                                    .split("\n")
                                    .map { |path| root.join(path) }
-                                   .reject(&MacOS.public_method(:undeletable?))
+                                   .reject { MacOS.undeletable?(_1) }
     end
 
     sig { returns(Pathname) }
@@ -114,9 +117,10 @@ def special?(path)
     def rmdir(path)
       @command.run!(
         "/usr/bin/xargs",
-        args:  ["-0", "--", RMDIR_SH.to_s],
-        input: Array(path).join("\0"),
-        sudo:  true,
+        args:         ["-0", "--", RMDIR_SH.to_s],
+        input:        Array(path).join("\0"),
+        sudo:         true,
+        sudo_as_root: true,
       )
     end
 
diff --git a/Library/Homebrew/cask/quarantine.rb b/Library/Homebrew/cask/quarantine.rb
index 2b9ec8705884a..6af81b6aeb716 100644
--- a/Library/Homebrew/cask/quarantine.rb
+++ b/Library/Homebrew/cask/quarantine.rb
@@ -1,42 +1,50 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "development_tools"
 require "cask/exceptions"
+require "system_command"
 
 module Cask
   # Helper module for quarantining files.
-  #
-  # @api private
   module Quarantine
-    extend T::Sig
-
-    module_function
+    extend SystemCommand::Mixin
 
     QUARANTINE_ATTRIBUTE = "com.apple.quarantine"
 
     QUARANTINE_SCRIPT = (HOMEBREW_LIBRARY_PATH/"cask/utils/quarantine.swift").freeze
-
-    def swift
-      @swift ||= DevelopmentTools.locate("swift")
+    COPY_XATTRS_SCRIPT = (HOMEBREW_LIBRARY_PATH/"cask/utils/copy-xattrs.swift").freeze
+
+    def self.swift
+      @swift ||= begin
+        # /usr/bin/swift (which runs via xcrun) adds `/usr/local/include` to the top of the include path,
+        # which allows really broken local setups to break our Swift usage here. Using the underlying
+        # Swift executable directly however (returned by `xcrun -find`) avoids this CPATH mess.
+        xcrun_swift = ::Utils.popen_read("/usr/bin/xcrun", "-find", "swift", err: :close).chomp
+        if $CHILD_STATUS.success? && File.executable?(xcrun_swift)
+          xcrun_swift
+        else
+          DevelopmentTools.locate("swift")
+        end
+      end
     end
-    private :swift
+    private_class_method :swift
 
-    def xattr
+    def self.xattr
       @xattr ||= DevelopmentTools.locate("xattr")
     end
-    private :xattr
+    private_class_method :xattr
 
-    def swift_target_args
+    def self.swift_target_args
       ["-target", "#{Hardware::CPU.arch}-apple-macosx#{MacOS.version}"]
     end
-    private :swift_target_args
+    private_class_method :swift_target_args
 
     sig { returns(Symbol) }
-    def check_quarantine_support
+    def self.check_quarantine_support
       odebug "Checking quarantine support"
 
-      if !system_command(xattr, args: ["-h"], print_stderr: false).success?
+      if xattr.nil? || !system_command(xattr, args: ["-h"], print_stderr: false).success?
         odebug "There's no working version of `xattr` on this system."
         :xattr_broken
       elsif swift.nil?
@@ -58,13 +66,13 @@ def check_quarantine_support
       end
     end
 
-    def available?
+    def self.available?
       @status ||= check_quarantine_support
 
       @status == :quarantine_available
     end
 
-    def detect(file)
+    def self.detect(file)
       return if file.nil?
 
       odebug "Verifying Gatekeeper status of #{file}"
@@ -76,13 +84,13 @@ def detect(file)
       quarantine_status
     end
 
-    def status(file)
+    def self.status(file)
       system_command(xattr,
                      args:         ["-p", QUARANTINE_ATTRIBUTE, file],
                      print_stderr: false).stdout.rstrip
     end
 
-    def toggle_no_translocation_bit(attribute)
+    def self.toggle_no_translocation_bit(attribute)
       fields = attribute.split(";")
 
       # Fields: status, epoch, download agent, event ID
@@ -94,7 +102,7 @@ def toggle_no_translocation_bit(attribute)
       fields.join(";")
     end
 
-    def release!(download_path: nil)
+    def self.release!(download_path: nil)
       return unless detect(download_path)
 
       odebug "Releasing #{download_path} from quarantine"
@@ -112,7 +120,7 @@ def release!(download_path: nil)
       raise CaskQuarantineReleaseError.new(download_path, quarantiner.stderr)
     end
 
-    def cask!(cask: nil, download_path: nil, action: true)
+    def self.cask!(cask: nil, download_path: nil, action: true)
       return if cask.nil? || download_path.nil?
 
       return if detect(download_path)
@@ -139,7 +147,7 @@ def cask!(cask: nil, download_path: nil, action: true)
       end
     end
 
-    def propagate(from: nil, to: nil)
+    def self.propagate(from: nil, to: nil)
       return if from.nil? || to.nil?
 
       raise CaskError, "#{from} was not quarantined properly." unless detect(from)
@@ -176,5 +184,85 @@ def propagate(from: nil, to: nil)
 
       raise CaskQuarantinePropagationError.new(to, quarantiner.stderr)
     end
+
+    sig { params(from: Pathname, to: Pathname, command: T.class_of(SystemCommand)).void }
+    def self.copy_xattrs(from, to, command:)
+      odebug "Copying xattrs from #{from} to #{to}"
+
+      command.run!(
+        swift,
+        args: [
+          *swift_target_args,
+          COPY_XATTRS_SCRIPT,
+          from,
+          to,
+        ],
+        sudo: !to.writable?,
+      )
+    end
+
+    # Ensures that Homebrew has permission to update apps on macOS Ventura.
+    # This may be granted either through the App Management toggle or the Full Disk Access toggle.
+    # The system will only show a prompt for App Management, so we ask the user to grant that.
+    sig { params(app: Pathname, command: T.class_of(SystemCommand)).returns(T::Boolean) }
+    def self.app_management_permissions_granted?(app:, command:)
+      return true unless app.directory?
+
+      # To get macOS to prompt the user for permissions, we need to actually attempt to
+      # modify a file in the app.
+      test_file = app/".homebrew-write-test"
+
+      # We can't use app.writable? here because that conflates several access checks,
+      # including both file ownership and whether system permissions are granted.
+      # Here we just want to check whether sudo would be needed.
+      looks_writable_without_sudo = if app.owned?
+        (app.lstat.mode & 0200) != 0
+      elsif app.grpowned?
+        (app.lstat.mode & 0020) != 0
+      else
+        (app.lstat.mode & 0002) != 0
+      end
+
+      if looks_writable_without_sudo
+        begin
+          File.write(test_file, "")
+          test_file.delete
+          return true
+        rescue Errno::EACCES, Errno::EPERM
+          # Using error handler below
+        end
+      else
+        begin
+          command.run!(
+            "touch",
+            args:         [
+              test_file,
+            ],
+            print_stderr: false,
+            sudo:         true,
+          )
+          command.run!(
+            "rm",
+            args:         [
+              test_file,
+            ],
+            print_stderr: false,
+            sudo:         true,
+          )
+          return true
+        rescue ErrorDuringExecution => e
+          # We only want to handle "touch" errors here; propagate "sudo" errors up
+          raise e unless e.stderr.include?("touch: #{test_file}: Operation not permitted")
+        end
+      end
+
+      opoo <<~EOF
+        Your terminal does not have App Management permissions, so Homebrew will delete and reinstall the app.
+        This may result in some configurations (like notification settings or location in the Dock/Launchpad) being lost.
+        To fix this, go to System Settings > Privacy & Security > App Management and add or enable your terminal.
+      EOF
+
+      false
+    end
   end
 end
diff --git a/Library/Homebrew/cask/reinstall.rb b/Library/Homebrew/cask/reinstall.rb
new file mode 100644
index 0000000000000..bad643b380fc7
--- /dev/null
+++ b/Library/Homebrew/cask/reinstall.rb
@@ -0,0 +1,33 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module Cask
+  class Reinstall
+    def self.reinstall_casks(
+      *casks,
+      verbose: nil,
+      force: nil,
+      skip_cask_deps: nil,
+      binaries: nil,
+      require_sha: nil,
+      quarantine: nil,
+      zap: nil
+    )
+      require "cask/installer"
+
+      quarantine = true if quarantine.nil?
+
+      casks.each do |cask|
+        Installer.new(cask,
+                      binaries:,
+                      verbose:,
+                      force:,
+                      skip_cask_deps:,
+                      require_sha:,
+                      reinstall:      true,
+                      quarantine:,
+                      zap:).install
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cask/staged.rb b/Library/Homebrew/cask/staged.rb
index bc05bb0b79fa1..43d0e8c37c2ac 100644
--- a/Library/Homebrew/cask/staged.rb
+++ b/Library/Homebrew/cask/staged.rb
@@ -1,20 +1,16 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "utils/user"
 
 module Cask
   # Helper functions for staged casks.
-  #
-  # @api private
   module Staged
-    extend T::Sig
+    extend T::Helpers
 
-    # FIXME: Enable cop again when https://github.com/sorbet/sorbet/issues/3532 is fixed.
-    # rubocop:disable Style/MutableConstant
-    Paths = T.type_alias { T.any(String, Pathname, T::Array[T.any(String, Pathname)]) }
-    # rubocop:enable Style/MutableConstant
+    requires_ancestor { Kernel }
 
+    Paths = T.type_alias { T.any(String, Pathname, T::Array[T.any(String, Pathname)]) }
     sig { params(paths: Paths, permissions_str: String).void }
     def set_permissions(paths, permissions_str)
       full_paths = remove_nonexistent(paths)
@@ -29,7 +25,7 @@ def set_ownership(paths, user: T.must(User.current), group: "staff")
       full_paths = remove_nonexistent(paths)
       return if full_paths.empty?
 
-      ohai "Changing ownership of paths required by #{@cask}; your password may be necessary."
+      ohai "Changing ownership of paths required by #{@cask} with sudo; the password may be necessary."
       @command.run!("/usr/sbin/chown", args: ["-R", "--", "#{user}:#{group}", *full_paths],
                                        sudo: true)
     end
diff --git a/Library/Homebrew/cask/staged.rbi b/Library/Homebrew/cask/staged.rbi
deleted file mode 100644
index ddf5f8cdbcc0f..0000000000000
--- a/Library/Homebrew/cask/staged.rbi
+++ /dev/null
@@ -1,7 +0,0 @@
-# typed: strict
-
-module Cask
-  module Staged
-    include Kernel
-  end
-end
diff --git a/Library/Homebrew/cask/tab.rb b/Library/Homebrew/cask/tab.rb
new file mode 100644
index 0000000000000..f7e12a3bcb853
--- /dev/null
+++ b/Library/Homebrew/cask/tab.rb
@@ -0,0 +1,108 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "tab"
+
+module Cask
+  class Tab < ::AbstractTab
+    attr_accessor :uninstall_flight_blocks, :uninstall_artifacts
+
+    # Instantiates a {Tab} for a new installation of a cask.
+    def self.create(cask)
+      tab = super
+
+      tab.tabfile = cask.metadata_main_container_path/FILENAME
+      tab.uninstall_flight_blocks = cask.uninstall_flight_blocks?
+      tab.runtime_dependencies = Tab.runtime_deps_hash(cask)
+      tab.source["version"] = cask.version.to_s
+      tab.source["path"] = cask.sourcefile_path.to_s
+      tab.uninstall_artifacts = cask.artifacts_list(uninstall_only: true)
+
+      tab
+    end
+
+    # Returns a {Tab} for an already installed cask,
+    # or a fake one if the cask is not installed.
+    def self.for_cask(cask)
+      path = cask.metadata_main_container_path/FILENAME
+
+      return from_file(path) if path.exist?
+
+      tab = empty
+      tab.source = {
+        "path"         => cask.sourcefile_path.to_s,
+        "tap"          => cask.tap&.name,
+        "tap_git_head" => cask.tap_git_head,
+        "version"      => cask.version.to_s,
+      }
+      tab.uninstall_artifacts = cask.artifacts_list(uninstall_only: true)
+
+      tab
+    end
+
+    def self.empty
+      tab = super
+      tab.uninstall_flight_blocks = false
+      tab.uninstall_artifacts = []
+      tab.source["version"] = nil
+
+      tab
+    end
+
+    def self.runtime_deps_hash(cask)
+      cask_and_formula_dep_graph = ::Utils::TopologicalHash.graph_package_dependencies(cask)
+      cask_deps, formula_deps = cask_and_formula_dep_graph.values.flatten.uniq.partition do |dep|
+        dep.is_a?(Cask)
+      end
+
+      runtime_deps = {}
+
+      if cask_deps.any?
+        runtime_deps[:cask] = cask_deps.map do |dep|
+          {
+            "full_name"         => dep.full_name,
+            "version"           => dep.version.to_s,
+            "declared_directly" => cask.depends_on.cask.include?(dep.full_name),
+          }
+        end
+      end
+
+      if formula_deps.any?
+        runtime_deps[:formula] = formula_deps.map do |dep|
+          formula_to_dep_hash(dep, cask.depends_on.formula)
+        end
+      end
+
+      runtime_deps
+    end
+
+    def version
+      source["version"]
+    end
+
+    def to_json(*_args)
+      attributes = {
+        "homebrew_version"        => homebrew_version,
+        "loaded_from_api"         => loaded_from_api,
+        "uninstall_flight_blocks" => uninstall_flight_blocks,
+        "installed_as_dependency" => installed_as_dependency,
+        "installed_on_request"    => installed_on_request,
+        "time"                    => time,
+        "runtime_dependencies"    => runtime_dependencies,
+        "source"                  => source,
+        "arch"                    => arch,
+        "uninstall_artifacts"     => uninstall_artifacts,
+        "built_on"                => built_on,
+      }
+
+      JSON.pretty_generate(attributes)
+    end
+
+    def to_s
+      s = ["Installed"]
+      s << "using the formulae.brew.sh API" if loaded_from_api
+      s << Time.at(time).strftime("on %Y-%m-%d at %H:%M:%S") if time
+      s.join(" ")
+    end
+  end
+end
diff --git a/Library/Homebrew/cask/uninstall.rb b/Library/Homebrew/cask/uninstall.rb
new file mode 100644
index 0000000000000..ebfc74ee27790
--- /dev/null
+++ b/Library/Homebrew/cask/uninstall.rb
@@ -0,0 +1,18 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module Cask
+  class Uninstall
+    def self.uninstall_casks(*casks, binaries: nil, force: false, verbose: false)
+      require "cask/installer"
+
+      casks.each do |cask|
+        odebug "Uninstalling Cask #{cask}"
+
+        raise CaskNotInstalledError, cask if !cask.installed? && !force
+
+        Installer.new(cask, binaries:, force:, verbose:).uninstall
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cask/upgrade.rb b/Library/Homebrew/cask/upgrade.rb
new file mode 100644
index 0000000000000..89dade90e9233
--- /dev/null
+++ b/Library/Homebrew/cask/upgrade.rb
@@ -0,0 +1,222 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "env_config"
+require "cask/config"
+
+module Cask
+  class Upgrade
+    sig {
+      params(
+        casks:               Cask,
+        args:                Homebrew::CLI::Args,
+        force:               T.nilable(T::Boolean),
+        greedy:              T.nilable(T::Boolean),
+        greedy_latest:       T.nilable(T::Boolean),
+        greedy_auto_updates: T.nilable(T::Boolean),
+        dry_run:             T.nilable(T::Boolean),
+        skip_cask_deps:      T.nilable(T::Boolean),
+        verbose:             T.nilable(T::Boolean),
+        quiet:               T.nilable(T::Boolean),
+        binaries:            T.nilable(T::Boolean),
+        quarantine:          T.nilable(T::Boolean),
+        require_sha:         T.nilable(T::Boolean),
+      ).returns(T::Boolean)
+    }
+    def self.upgrade_casks(
+      *casks,
+      args:,
+      force: false,
+      greedy: false,
+      greedy_latest: false,
+      greedy_auto_updates: false,
+      dry_run: false,
+      skip_cask_deps: false,
+      verbose: false,
+      quiet: false,
+      binaries: nil,
+      quarantine: nil,
+      require_sha: nil
+    )
+
+      quarantine = true if quarantine.nil?
+
+      greedy = true if Homebrew::EnvConfig.upgrade_greedy?
+
+      outdated_casks = if casks.empty?
+        Caskroom.casks(config: Config.from_args(args)).select do |cask|
+          cask.outdated?(greedy:, greedy_latest:,
+                         greedy_auto_updates:)
+        end
+      else
+        casks.select do |cask|
+          raise CaskNotInstalledError, cask if !cask.installed? && !force
+
+          if cask.outdated?(greedy: true)
+            true
+          elsif cask.version.latest?
+            opoo "Not upgrading #{cask.token}, the downloaded artifact has not changed" unless quiet
+            false
+          else
+            opoo "Not upgrading #{cask.token}, the latest version is already installed" unless quiet
+            false
+          end
+        end
+      end
+
+      manual_installer_casks = outdated_casks.select do |cask|
+        cask.artifacts.any? do |artifact|
+          artifact.is_a?(Artifact::Installer) && artifact.manual_install
+        end
+      end
+
+      if manual_installer_casks.present?
+        count = manual_installer_casks.count
+        ofail "Not upgrading #{count} `installer manual` #{::Utils.pluralize("cask", count)}."
+        puts manual_installer_casks.map(&:to_s)
+        outdated_casks -= manual_installer_casks
+      end
+
+      return false if outdated_casks.empty?
+
+      if casks.empty? && !greedy
+        if !greedy_auto_updates && !greedy_latest
+          ohai "Casks with 'auto_updates true' or 'version :latest' " \
+               "will not be upgraded; pass `--greedy` to upgrade them."
+        end
+        if greedy_auto_updates && !greedy_latest
+          ohai "Casks with 'version :latest' will not be upgraded; pass `--greedy-latest` to upgrade them."
+        end
+        if !greedy_auto_updates && greedy_latest
+          ohai "Casks with 'auto_updates true' will not be upgraded; pass `--greedy-auto-updates` to upgrade them."
+        end
+      end
+
+      verb = dry_run ? "Would upgrade" : "Upgrading"
+      oh1 "#{verb} #{outdated_casks.count} outdated #{::Utils.pluralize("package", outdated_casks.count)}:"
+
+      caught_exceptions = []
+
+      upgradable_casks = outdated_casks.map do |c|
+        unless c.installed?
+          odie <<~EOS
+            The cask '#{c.token}' was affected by a bug and cannot be upgraded as-is. To fix this, run:
+              brew reinstall --cask --force #{c.token}
+          EOS
+        end
+
+        [CaskLoader.load(c.installed_caskfile), c]
+      end
+
+      puts upgradable_casks
+        .map { |(old_cask, new_cask)| "#{new_cask.full_name} #{old_cask.version} -> #{new_cask.version}" }
+        .join("\n")
+      return true if dry_run
+
+      upgradable_casks.each do |(old_cask, new_cask)|
+        upgrade_cask(
+          old_cask, new_cask,
+          binaries:, force:, skip_cask_deps:, verbose:,
+          quarantine:, require_sha:
+        )
+      rescue => e
+        new_exception = e.exception("#{new_cask.full_name}: #{e}")
+        new_exception.set_backtrace(e.backtrace)
+        caught_exceptions << new_exception
+        next
+      end
+
+      return true if caught_exceptions.empty?
+      raise MultipleCaskErrors, caught_exceptions if caught_exceptions.count > 1
+      raise caught_exceptions.fetch(0) if caught_exceptions.count == 1
+
+      false
+    end
+
+    sig {
+      params(
+        old_cask:       Cask,
+        new_cask:       Cask,
+        binaries:       T.nilable(T::Boolean),
+        force:          T.nilable(T::Boolean),
+        quarantine:     T.nilable(T::Boolean),
+        require_sha:    T.nilable(T::Boolean),
+        skip_cask_deps: T.nilable(T::Boolean),
+        verbose:        T.nilable(T::Boolean),
+      ).void
+    }
+    def self.upgrade_cask(
+      old_cask, new_cask,
+      binaries:, force:, quarantine:, require_sha:, skip_cask_deps:, verbose:
+    )
+      require "cask/installer"
+
+      start_time = Time.now
+      odebug "Started upgrade process for Cask #{old_cask}"
+      old_config = old_cask.config
+
+      old_options = {
+        binaries:,
+        verbose:,
+        force:,
+        upgrade:  true,
+      }.compact
+
+      old_cask_installer =
+        Installer.new(old_cask, **old_options)
+
+      new_cask.config = new_cask.default_config.merge(old_config)
+
+      new_options = {
+        binaries:,
+        verbose:,
+        force:,
+        skip_cask_deps:,
+        require_sha:,
+        upgrade:        true,
+        quarantine:,
+      }.compact
+
+      new_cask_installer =
+        Installer.new(new_cask, **new_options)
+
+      started_upgrade = false
+      new_artifacts_installed = false
+
+      begin
+        oh1 "Upgrading #{Formatter.identifier(old_cask)}"
+
+        # Start new cask's installation steps
+        new_cask_installer.check_conflicts
+
+        if (caveats = new_cask_installer.caveats)
+          puts caveats
+        end
+
+        new_cask_installer.fetch
+
+        # Move the old cask's artifacts back to staging
+        old_cask_installer.start_upgrade(successor: new_cask)
+        # And flag it so in case of error
+        started_upgrade = true
+
+        # Install the new cask
+        new_cask_installer.stage
+
+        new_cask_installer.install_artifacts(predecessor: old_cask)
+        new_artifacts_installed = true
+
+        # If successful, wipe the old cask from staging.
+        old_cask_installer.finalize_upgrade
+      rescue => e
+        new_cask_installer.uninstall_artifacts(successor: old_cask) if new_artifacts_installed
+        new_cask_installer.purge_versioned_files
+        old_cask_installer.revert_upgrade(predecessor: new_cask) if started_upgrade
+        raise e
+      end
+
+      end_time = Time.now
+      Homebrew.messages.package_installed(new_cask.token, end_time - start_time)
+    end
+  end
+end
diff --git a/Library/Homebrew/cask/url.rb b/Library/Homebrew/cask/url.rb
index fa09e3a0a536a..0fc7ead73f1ff 100644
--- a/Library/Homebrew/cask/url.rb
+++ b/Library/Homebrew/cask/url.rb
@@ -1,45 +1,212 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-# Class corresponding to the `url` stanza.
-#
-# @api private
-class URL < Delegator
-  extend T::Sig
+require "source_location"
+require "utils/curl"
 
-  # @api private
-  class DSL
-    extend T::Sig
+module Cask
+  # Class corresponding to the `url` stanza.
+  class URL < SimpleDelegator
+    class DSL
+      attr_reader :uri, :tag, :branch, :revisions, :revision,
+                  :trust_cert, :cookies, :header, :data, :only_path
 
-    attr_reader :uri, :specs,
-                :verified, :using,
-                :tag, :branch, :revisions, :revision,
-                :trust_cert, :cookies, :referer, :header, :user_agent,
-                :data
+      sig { returns(T.nilable(T.any(URI::Generic, String))) }
+      attr_reader :referer
 
-    extend Forwardable
-    def_delegators :uri, :path, :scheme, :to_s
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      attr_reader :specs
+
+      sig { returns(T.nilable(T.any(Symbol, String))) }
+      attr_reader :user_agent
+
+      sig { returns(T.any(T::Class[T.anything], Symbol, NilClass)) }
+      attr_reader :using
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :verified
+
+      extend Forwardable
+      def_delegators :uri, :path, :scheme, :to_s
+
+      sig {
+        params(
+          uri:        T.any(URI::Generic, String),
+          # @api public
+          verified:   T.nilable(String),
+          # @api public
+          using:      T.any(Class, Symbol, NilClass),
+          # @api public
+          tag:        T.nilable(String),
+          # @api public
+          branch:     T.nilable(String),
+          # @api public
+          revisions:  T.nilable(T::Array[String]),
+          # @api public
+          revision:   T.nilable(String),
+          # @api public
+          trust_cert: T.nilable(T::Boolean),
+          # @api public
+          cookies:    T.nilable(T::Hash[String, String]),
+          referer:    T.nilable(T.any(URI::Generic, String)),
+          # @api public
+          header:     T.nilable(T.any(String, T::Array[String])),
+          user_agent: T.nilable(T.any(Symbol, String)),
+          # @api public
+          data:       T.nilable(T::Hash[String, String]),
+          # @api public
+          only_path:  T.nilable(String),
+        ).void
+      }
+      def initialize(
+        uri,
+        verified: nil,
+        using: nil,
+        tag: nil,
+        branch: nil,
+        revisions: nil,
+        revision: nil,
+        trust_cert: nil,
+        cookies: nil,
+        referer: nil,
+        header: nil,
+        user_agent: nil,
+        data: nil,
+        only_path: nil
+      )
+
+        @uri = URI(uri)
+
+        header = Array(header) unless header.nil?
+
+        specs = {}
+        specs[:verified]   = @verified   = verified
+        specs[:using]      = @using      = using
+        specs[:tag]        = @tag        = tag
+        specs[:branch]     = @branch     = branch
+        specs[:revisions]  = @revisions  = revisions
+        specs[:revision]   = @revision   = revision
+        specs[:trust_cert] = @trust_cert = trust_cert
+        specs[:cookies]    = @cookies    = cookies
+        specs[:referer]    = @referer    = referer
+        specs[:headers]    = @header     = header
+        specs[:user_agent] = @user_agent = user_agent || :default
+        specs[:data]       = @data       = data
+        specs[:only_path]  = @only_path  = only_path
+
+        @specs = specs.compact
+      end
+    end
+
+    class BlockDSL
+      # Allow accessing the URL associated with page contents.
+      module PageWithURL
+        # Get the URL of the fetched page.
+        #
+        # ### Example
+        #
+        # ```ruby
+        # url "https://example.org/download" do |page|
+        #   file = page[/href="([^"]+.dmg)"/, 1]
+        #   URL.join(page.url, file)
+        # end
+        # ```
+        #
+        # @api public
+        sig { returns(URI::Generic) }
+        attr_accessor :url
+      end
+
+      sig {
+        params(
+          uri:   T.nilable(T.any(URI::Generic, String)),
+          dsl:   ::Cask::DSL,
+          block: T.proc.params(arg0: T.all(String, PageWithURL))
+                       .returns(T.any(T.any(URI::Generic, String), [T.any(URI::Generic, String), Hash])),
+        ).void
+      }
+      def initialize(uri, dsl:, &block)
+        @uri = uri
+        @dsl = dsl
+        @block = block
+
+        odeprecated "cask `url do` blocks" if @block
+      end
+
+      sig { returns(T.any(T.any(URI::Generic, String), [T.any(URI::Generic, String), Hash])) }
+      def call
+        if @uri
+          result = ::Utils::Curl.curl_output("--fail", "--silent", "--location", @uri)
+          result.assert_success!
+
+          page = result.stdout
+          page.extend PageWithURL
+          page.url = URI(@uri)
+
+          instance_exec(page, &@block)
+        else
+          instance_exec(&@block)
+        end
+      end
+
+      private
+
+      # Allows calling a nested `url` stanza in a `url do` block.
+      #
+      # @api public
+      sig {
+        params(
+          uri:   T.any(URI::Generic, String),
+          block: T.proc.params(arg0: T.all(String, PageWithURL))
+                       .returns(T.any(T.any(URI::Generic, String), [T.any(URI::Generic, String), Hash])),
+        ).returns(T.any(T.any(URI::Generic, String), [T.any(URI::Generic, String), Hash]))
+      }
+      def url(uri, &block)
+        self.class.new(uri, dsl: @dsl, &block).call
+      end
+
+      # This allows calling DSL methods from inside a `url` block.
+      #
+      # @api public
+      def method_missing(method, *args, &block)
+        if @dsl.respond_to?(method)
+          @dsl.public_send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_all)
+        @dsl.respond_to?(method, include_all) || super
+      end
+    end
 
-    # @api public
     sig {
       params(
-        uri:        T.any(URI::Generic, String),
-        verified:   T.nilable(String),
-        using:      T.nilable(Symbol),
-        tag:        T.nilable(String),
-        branch:     T.nilable(String),
-        revisions:  T.nilable(T::Array[String]),
-        revision:   T.nilable(String),
-        trust_cert: T.nilable(T::Boolean),
-        cookies:    T.nilable(T::Hash[String, String]),
-        referer:    T.nilable(T.any(URI::Generic, String)),
-        header:     T.nilable(String),
-        user_agent: T.nilable(T.any(Symbol, String)),
-        data:       T.nilable(T::Hash[String, String]),
+        uri:             T.nilable(T.any(URI::Generic, String)),
+        verified:        T.nilable(String),
+        using:           T.any(Class, Symbol, NilClass),
+        tag:             T.nilable(String),
+        branch:          T.nilable(String),
+        revisions:       T.nilable(T::Array[String]),
+        revision:        T.nilable(String),
+        trust_cert:      T.nilable(T::Boolean),
+        cookies:         T.nilable(T::Hash[String, String]),
+        referer:         T.nilable(T.any(URI::Generic, String)),
+        header:          T.nilable(T.any(String, T::Array[String])),
+        user_agent:      T.nilable(T.any(Symbol, String)),
+        data:            T.nilable(T::Hash[String, String]),
+        only_path:       T.nilable(String),
+        caller_location: Thread::Backtrace::Location,
+        dsl:             T.nilable(::Cask::DSL),
+        block:           T.nilable(
+          T.proc.params(arg0: T.all(String, BlockDSL::PageWithURL))
+                .returns(T.any(T.any(URI::Generic, String), [T.any(URI::Generic, String), Hash])),
+        ),
       ).void
     }
     def initialize(
-      uri,
+      uri = nil,
       verified: nil,
       using: nil,
       tag: nil,
@@ -51,197 +218,74 @@ def initialize(
       referer: nil,
       header: nil,
       user_agent: nil,
-      data: nil
+      data: nil,
+      only_path: nil,
+      caller_location: T.must(caller_locations).fetch(0),
+      dsl: nil,
+      &block
     )
+      super(
+        if block
+          LazyObject.new do
+            uri2, options = *BlockDSL.new(uri, dsl: T.must(dsl), &block).call
+            options ||= {}
+            DSL.new(uri2, **options)
+          end
+        else
+          DSL.new(
+            T.must(uri),
+            verified:,
+            using:,
+            tag:,
+            branch:,
+            revisions:,
+            revision:,
+            trust_cert:,
+            cookies:,
+            referer:,
+            header:,
+            user_agent:,
+            data:,
+            only_path:,
+          )
+        end
+      )
 
-      @uri = URI(uri)
-
-      specs = {}
-      specs[:verified]   = @verified   = verified
-      specs[:using]      = @using      = using
-      specs[:tag]        = @tag        = tag
-      specs[:branch]     = @branch     = branch
-      specs[:revisions]  = @revisions  = revisions
-      specs[:revision]   = @revision   = revision
-      specs[:trust_cert] = @trust_cert = trust_cert
-      specs[:cookies]    = @cookies    = cookies
-      specs[:referer]    = @referer    = referer
-      specs[:header]     = @header     = header
-      specs[:user_agent] = @user_agent = user_agent || :default
-      specs[:data]       = @data       = data
-
-      @specs = specs.compact
-    end
-  end
-
-  # @api private
-  class BlockDSL
-    extend T::Sig
-
-    module PageWithURL
-      extend T::Sig
-
-      # @api public
-      sig { returns(URI::Generic) }
-      attr_accessor :url
+      @from_block = !block.nil?
+      @caller_location = caller_location
     end
 
-    sig {
-      params(
-        uri:   T.nilable(T.any(URI::Generic, String)),
-        dsl:   T.nilable(Cask::DSL),
-        block: T.proc.params(arg0: T.all(String, PageWithURL)).returns(T.untyped),
-      ).void
-    }
-    def initialize(uri, dsl: nil, &block)
-      @uri = uri
-      @dsl = dsl
-      @block = block
+    sig { returns(Homebrew::SourceLocation) }
+    def location
+      Homebrew::SourceLocation.new(@caller_location.lineno, raw_url_line&.index("url"))
     end
 
-    sig { returns(T.untyped) }
-    def call
-      if @uri
-        result = curl_output("--fail", "--silent", "--location", @uri)
-        result.assert_success!
+    sig { params(ignore_major_version: T::Boolean).returns(T::Boolean) }
+    def unversioned?(ignore_major_version: false)
+      interpolated_url = raw_url_line&.then { |line| line[/url\s+"([^"]+)"/, 1] }
 
-        page = result.stdout
-        page.extend PageWithURL
-        page.url = URI(@uri)
+      return false unless interpolated_url
 
-        instance_exec(page, &@block)
-      else
-        instance_exec(&@block)
-      end
-    end
-
-    # @api public
-    sig {
-      params(
-        uri:   T.any(URI::Generic, String),
-        block: T.proc.params(arg0: T.all(String, PageWithURL)).returns(T.untyped),
-      ).void
-    }
-    def url(uri, &block)
-      self.class.new(uri, &block).call
-    end
-    private :url
-
-    # @api public
-    def method_missing(method, *args, &block)
-      if @dsl.respond_to?(method)
-        T.unsafe(@dsl).public_send(method, *args, &block)
-      else
-        super
-      end
-    end
+      interpolated_url = interpolated_url.gsub(/\#{\s*version\s*\.major\s*}/, "") if ignore_major_version
 
-    def respond_to_missing?(method, include_all)
-      @dsl.respond_to?(method, include_all) || super
+      interpolated_url.exclude?('#{')
     end
-  end
 
-  sig {
-    params(
-      uri:             T.nilable(T.any(URI::Generic, String)),
-      verified:        T.nilable(String),
-      using:           T.nilable(Symbol),
-      tag:             T.nilable(String),
-      branch:          T.nilable(String),
-      revisions:       T.nilable(T::Array[String]),
-      revision:        T.nilable(String),
-      trust_cert:      T.nilable(T::Boolean),
-      cookies:         T.nilable(T::Hash[String, String]),
-      referer:         T.nilable(T.any(URI::Generic, String)),
-      header:          T.nilable(String),
-      user_agent:      T.nilable(T.any(Symbol, String)),
-      data:            T.nilable(T::Hash[String, String]),
-      caller_location: Thread::Backtrace::Location,
-      dsl:             T.nilable(Cask::DSL),
-      block:           T.nilable(T.proc.params(arg0: T.all(String, BlockDSL::PageWithURL)).returns(T.untyped)),
-    ).void
-  }
-  def initialize(
-    uri = nil,
-    verified: nil,
-    using: nil,
-    tag: nil,
-    branch: nil,
-    revisions: nil,
-    revision: nil,
-    trust_cert: nil,
-    cookies: nil,
-    referer: nil,
-    header: nil,
-    user_agent: nil,
-    data: nil,
-    caller_location: T.must(caller_locations).fetch(0),
-    dsl: nil,
-    &block
-  )
-    super(
-    if block
-      LazyObject.new do
-        *args = BlockDSL.new(uri, dsl: dsl, &block).call
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        uri = T.let(args.first, T.any(URI::Generic, String))
-        DSL.new(uri, **options)
-      end
-    else
-      DSL.new(
-        T.must(uri),
-        verified:   verified,
-        using:      using,
-        tag:        tag,
-        branch:     branch,
-        revisions:  revisions,
-        revision:   revision,
-        trust_cert: trust_cert,
-        cookies:    cookies,
-        referer:    referer,
-        header:     header,
-        user_agent: user_agent,
-        data:       data,
-      )
+    sig { returns(T::Boolean) }
+    def from_block?
+      @from_block
     end
-    )
 
-    @from_block = !block.nil?
-    @caller_location = caller_location
-  end
-
-  def __getobj__
-    @dsl
-  end
-
-  def __setobj__(dsl)
-    @dsl = dsl
-  end
+    private
 
-  sig { returns(T.nilable(String)) }
-  def raw_interpolated_url
-    return @raw_interpolated_url if defined?(@raw_interpolated_url)
+    sig { returns(T.nilable(String)) }
+    def raw_url_line
+      return @raw_url_line if defined?(@raw_url_line)
 
-    @raw_interpolated_url =
-      Pathname(@caller_location.absolute_path)
-      .each_line.drop(@caller_location.lineno - 1)
-      .first&.then { |line| line[/url\s+"([^"]+)"/, 1] }
-  end
-  private :raw_interpolated_url
-
-  sig { params(ignore_major_version: T::Boolean).returns(T::Boolean) }
-  def unversioned?(ignore_major_version: false)
-    interpolated_url = raw_interpolated_url
-
-    return false unless interpolated_url
-
-    interpolated_url = interpolated_url.gsub(/\#{\s*version\s*\.major\s*}/, "") if ignore_major_version
-
-    interpolated_url.exclude?('#{')
-  end
-
-  sig { returns(T::Boolean) }
-  def from_block?
-    @from_block
+      @raw_url_line = Pathname(T.must(@caller_location.path))
+                      .each_line
+                      .drop(@caller_location.lineno - 1)
+                      .first
+    end
   end
 end
diff --git a/Library/Homebrew/cask/url.rbi b/Library/Homebrew/cask/url.rbi
deleted file mode 100644
index 6f32e1b3b2711..0000000000000
--- a/Library/Homebrew/cask/url.rbi
+++ /dev/null
@@ -1,6 +0,0 @@
-# typed: strict
-# typed: false
-
-class URL
-  include Kernel
-end
diff --git a/Library/Homebrew/cask/utils.rb b/Library/Homebrew/cask/utils.rb
index 23e52b91c8a37..b90dbfdad6635 100644
--- a/Library/Homebrew/cask/utils.rb
+++ b/Library/Homebrew/cask/utils.rb
@@ -1,33 +1,60 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "utils/user"
-require "yaml"
 require "open3"
-require "stringio"
 
 BUG_REPORTS_URL = "https://github.com/Homebrew/homebrew-cask#reporting-bugs"
 
 module Cask
   # Helper functions for various cask operations.
-  #
-  # @api private
   module Utils
-    extend T::Sig
+    def self.gain_permissions_mkpath(path, command: SystemCommand)
+      dir = path.ascend.find(&:directory?)
+      return if path == dir
+
+      if dir.writable?
+        path.mkpath
+      else
+        command.run!("/bin/mkdir", args: ["-p", "--", path], sudo: true, print_stderr: false)
+      end
+    end
+
+    def self.gain_permissions_rmdir(path, command: SystemCommand)
+      gain_permissions(path, [], command) do |p|
+        if p.parent.writable?
+          FileUtils.rmdir p
+        else
+          command.run!("/bin/rmdir", args: ["--", p], sudo: true, print_stderr: false)
+        end
+      end
+    end
 
     def self.gain_permissions_remove(path, command: SystemCommand)
-      if path.respond_to?(:rmtree) && path.exist?
-        gain_permissions(path, ["-R"], command) do |p|
-          if p.parent.writable?
-            p.rmtree
+      directory = false
+      permission_flags = if path.symlink?
+        ["-h"]
+      elsif path.directory?
+        directory = true
+        ["-R"]
+      elsif path.exist?
+        []
+      else
+        # Nothing to remove.
+        return
+      end
+
+      gain_permissions(path, permission_flags, command) do |p|
+        if p.parent.writable?
+          if directory
+            FileUtils.rm_r p
           else
-            command.run("/bin/rm",
-                        args: ["-r", "-f", "--", p],
-                        sudo: true)
+            FileUtils.rm_f p
           end
+        else
+          recursive_flag = directory ? ["-R"] : []
+          command.run!("/bin/rm", args: recursive_flag + ["-f", "--", p], sudo: true, print_stderr: false)
         end
-      elsif File.symlink?(path)
-        gain_permissions(path, ["-h"], command, &FileUtils.method(:rm_f))
       end
     end
 
@@ -39,18 +66,19 @@ def self.gain_permissions(path, command_args, command)
       rescue
         # in case of permissions problems
         unless tried_permissions
+          print_stderr = Context.current.debug? || Context.current.verbose?
           # TODO: Better handling for the case where path is a symlink.
-          #       The -h and -R flags cannot be combined, and behavior is
+          #       The `-h` and `-R` flags cannot be combined and behavior is
           #       dependent on whether the file argument has a trailing
-          #       slash.  This should do the right thing, but is fragile.
+          #       slash. This should do the right thing, but is fragile.
           command.run("/usr/bin/chflags",
-                      must_succeed: false,
+                      print_stderr:,
                       args:         command_args + ["--", "000", path])
           command.run("/bin/chmod",
-                      must_succeed: false,
+                      print_stderr:,
                       args:         command_args + ["--", "u+rwx", path])
           command.run("/bin/chmod",
-                      must_succeed: false,
+                      print_stderr:,
                       args:         command_args + ["-N", path])
           tried_permissions = true
           retry # rmtree
@@ -59,7 +87,7 @@ def self.gain_permissions(path, command_args, command)
         unless tried_ownership
           # in case of ownership problems
           # TODO: Further examine files to see if ownership is the problem
-          #       before using sudo+chown
+          #       before using `sudo` and `chown`.
           ohai "Using sudo to gain ownership of path '#{path}'"
           command.run("/usr/sbin/chown",
                       args: command_args + ["--", User.current, path],
@@ -100,11 +128,11 @@ def self.error_message_with_suggestions
     end
 
     def self.method_missing_message(method, token, section = nil)
-      message = +"Unexpected method '#{method}' called "
+      message = "Unexpected method '#{method}' called "
       message << "during #{section} " if section
       message << "on Cask #{token}."
 
-      opoo "#{message}\n#{error_message_with_suggestions}"
+      ofail "#{message}\n#{error_message_with_suggestions}"
     end
   end
 end
diff --git a/Library/Homebrew/cask/utils/copy-xattrs.swift b/Library/Homebrew/cask/utils/copy-xattrs.swift
new file mode 100755
index 0000000000000..794242ed13974
--- /dev/null
+++ b/Library/Homebrew/cask/utils/copy-xattrs.swift
@@ -0,0 +1,80 @@
+#!/usr/bin/swift
+
+import Foundation
+
+struct SwiftErr: TextOutputStream {
+    public static var stream = SwiftErr()
+
+    mutating func write(_ string: String) {
+        fputs(string, stderr)
+    }
+}
+
+guard CommandLine.arguments.count >= 3 else {
+    print("Usage: swift copy-xattrs.swift <source> <dest>")
+    exit(2)
+}
+
+CommandLine.arguments[2].withCString { destinationPath in
+    let destinationNamesLength = listxattr(destinationPath, nil, 0, 0)
+    if destinationNamesLength == -1 {
+        print("listxattr for destination failed: \(errno)", to: &SwiftErr.stream)
+        exit(1)
+    }
+    let destinationNamesBuffer = UnsafeMutablePointer<Int8>.allocate(capacity: destinationNamesLength)
+    if listxattr(destinationPath, destinationNamesBuffer, destinationNamesLength, 0) != destinationNamesLength {
+        print("Attributes changed during system call", to: &SwiftErr.stream)
+        exit(1)
+    }
+
+    var destinationNamesIndex = 0
+    while destinationNamesIndex < destinationNamesLength {
+        let attribute = destinationNamesBuffer + destinationNamesIndex
+
+        if removexattr(destinationPath, attribute, 0) != 0 {
+            print("removexattr for \(String(cString: attribute)) failed: \(errno)", to: &SwiftErr.stream)
+            exit(1)
+        }
+
+        destinationNamesIndex += strlen(attribute) + 1
+    }
+    destinationNamesBuffer.deallocate()
+
+    CommandLine.arguments[1].withCString { sourcePath in
+        let sourceNamesLength = listxattr(sourcePath, nil, 0, 0)
+        if sourceNamesLength == -1 {
+            print("listxattr for source failed: \(errno)", to: &SwiftErr.stream)
+            exit(1)
+        }
+        let sourceNamesBuffer = UnsafeMutablePointer<Int8>.allocate(capacity: sourceNamesLength)
+        if listxattr(sourcePath, sourceNamesBuffer, sourceNamesLength, 0) != sourceNamesLength {
+            print("Attributes changed during system call", to: &SwiftErr.stream)
+            exit(1)
+        }
+
+        var sourceNamesIndex = 0
+        while sourceNamesIndex < sourceNamesLength {
+            let attribute = sourceNamesBuffer + sourceNamesIndex
+
+            let valueLength = getxattr(sourcePath, attribute, nil, 0, 0, 0)
+            if valueLength == -1 {
+                print("getxattr for \(String(cString: attribute)) failed: \(errno)", to: &SwiftErr.stream)
+                exit(1)
+            }
+            let valueBuffer = UnsafeMutablePointer<Int8>.allocate(capacity: valueLength)
+            if getxattr(sourcePath, attribute, valueBuffer, valueLength, 0, 0) != valueLength {
+                print("Attributes changed during system call", to: &SwiftErr.stream)
+                exit(1)
+            }
+
+            if setxattr(destinationPath, attribute, valueBuffer, valueLength, 0, 0) != 0 {
+                print("setxattr for \(String(cString: attribute)) failed: \(errno)", to: &SwiftErr.stream)
+                exit(1)
+            }
+
+            valueBuffer.deallocate()
+            sourceNamesIndex += strlen(attribute) + 1
+        }
+        sourceNamesBuffer.deallocate()
+    }
+}
diff --git a/Library/Homebrew/cask/utils/trash.swift b/Library/Homebrew/cask/utils/trash.swift
index cfdd3d896ac68..cd380aeb1f6fd 100755
--- a/Library/Homebrew/cask/utils/trash.swift
+++ b/Library/Homebrew/cask/utils/trash.swift
@@ -2,14 +2,6 @@
 
 import Foundation
 
-extension FileHandle : TextOutputStream {
-  public func write(_ string: String) {
-      if let data = string.data(using: .utf8) { self.write(data) }
-  }
-}
-
-var stderr = FileHandle.standardError
-
 let manager = FileManager.default
 
 var success = true
@@ -17,19 +9,24 @@ var success = true
 // The command line arguments given but without the script's name
 let CMDLineArgs = Array(CommandLine.arguments.dropFirst())
 
+var trashed: [String] = []
+var untrashable: [String] = []
 for item in CMDLineArgs {
     do {
         let url = URL(fileURLWithPath: item)
         var trashedPath: NSURL!
         try manager.trashItem(at: url, resultingItemURL: &trashedPath)
-        print((trashedPath as URL).path, terminator: ":")
+        trashed.append((trashedPath as URL).path)
         success = true
     } catch {
-        print(item, terminator: ":", to: &stderr)
+        untrashable.append(item)
         success = false
     }
 }
 
+print(trashed.joined(separator: ":"))
+print(untrashable.joined(separator: ":"), terminator: "")
+
 guard success else {
     exit(1)
 }
diff --git a/Library/Homebrew/cask_dependent.rb b/Library/Homebrew/cask_dependent.rb
index cb9841fb8b808..cdea653623951 100644
--- a/Library/Homebrew/cask_dependent.rb
+++ b/Library/Homebrew/cask_dependent.rb
@@ -1,8 +1,17 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "requirement"
+
 # An adapter for casks to provide dependency information in a formula-like interface.
 class CaskDependent
+  # Defines a dependency on another cask
+  class Requirement < ::Requirement
+    satisfy(build_env: false) do
+      Cask::CaskLoader.load(cask).installed?
+    end
+  end
+
   attr_reader :cask
 
   def initialize(cask)
@@ -33,11 +42,21 @@ def requirements
       dsl_reqs = @cask.depends_on
 
       dsl_reqs.arch&.each do |arch|
-        requirements << ArchRequirement.new([:x86_64]) if arch[:bits] == 64
-        requirements << ArchRequirement.new([arch[:type]])
+        arch = if arch[:bits] == 64
+          if arch[:type] == :intel
+            :x86_64
+          else
+            :"#{arch[:type]}64"
+          end
+        elsif arch[:type] == :intel && arch[:bits] == 32
+          :i386
+        else
+          arch[:type]
+        end
+        requirements << ArchRequirement.new([arch])
       end
       dsl_reqs.cask.each do |cask_ref|
-        requirements << Requirement.new([{ cask: cask_ref }])
+        requirements << CaskDependent::Requirement.new([{ cask: cask_ref }])
       end
       requirements << dsl_reqs.macos if dsl_reqs.macos
 
diff --git a/Library/Homebrew/caveats.rb b/Library/Homebrew/caveats.rb
index 66b4fcf1a7069..4a233a0acd6bd 100644
--- a/Library/Homebrew/caveats.rb
+++ b/Library/Homebrew/caveats.rb
@@ -1,29 +1,31 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 require "language/python"
+require "utils/service"
 
 # A formula's caveats.
-#
-# @api private
 class Caveats
   extend Forwardable
 
-  attr_reader :f
+  sig { returns(Formula) }
+  attr_reader :formula
 
-  def initialize(f)
-    @f = f
+  sig { params(formula: Formula).void }
+  def initialize(formula)
+    @formula = formula
   end
 
+  sig { returns(String) }
   def caveats
     caveats = []
     begin
-      build = f.build
-      f.build = Tab.for_formula(f)
-      s = f.caveats.to_s
-      caveats << "#{s.chomp}\n" unless s.empty?
+      build = formula.build
+      formula.build = Tab.for_formula(formula)
+      string = formula.caveats.to_s
+      caveats << "#{string.chomp}\n" unless string.empty?
     ensure
-      f.build = build
+      formula.build = build
     end
     caveats << keg_only_text
 
@@ -47,68 +49,72 @@ def caveats
 
   delegate [:empty?, :to_s] => :caveats
 
+  sig { params(skip_reason: T::Boolean).returns(T.nilable(String)) }
   def keg_only_text(skip_reason: false)
-    return unless f.keg_only?
+    return unless formula.keg_only?
 
     s = if skip_reason
       ""
     else
       <<~EOS
-        #{f.name} is keg-only, which means it was not symlinked into #{HOMEBREW_PREFIX},
-        because #{f.keg_only_reason.to_s.chomp}.
+        #{formula.name} is keg-only, which means it was not symlinked into #{HOMEBREW_PREFIX},
+        because #{formula.keg_only_reason.to_s.chomp}.
       EOS
     end.dup
 
-    if f.bin.directory? || f.sbin.directory?
+    if formula.bin.directory? || formula.sbin.directory?
       s << <<~EOS
 
-        If you need to have #{f.name} first in your PATH, run:
+        If you need to have #{formula.name} first in your PATH, run:
       EOS
-      s << "  #{Utils::Shell.prepend_path_in_profile(f.opt_bin.to_s)}\n" if f.bin.directory?
-      s << "  #{Utils::Shell.prepend_path_in_profile(f.opt_sbin.to_s)}\n" if f.sbin.directory?
+      s << "  #{Utils::Shell.prepend_path_in_profile(formula.opt_bin.to_s)}\n" if formula.bin.directory?
+      s << "  #{Utils::Shell.prepend_path_in_profile(formula.opt_sbin.to_s)}\n" if formula.sbin.directory?
     end
 
-    if f.lib.directory? || f.include.directory?
+    if formula.lib.directory? || formula.include.directory?
       s << <<~EOS
 
-        For compilers to find #{f.name} you may need to set:
+        For compilers to find #{formula.name} you may need to set:
       EOS
 
-      s << "  #{Utils::Shell.export_value("LDFLAGS", "-L#{f.opt_lib}")}\n" if f.lib.directory?
+      s << "  #{Utils::Shell.export_value("LDFLAGS", "-L#{formula.opt_lib}")}\n" if formula.lib.directory?
 
-      s << "  #{Utils::Shell.export_value("CPPFLAGS", "-I#{f.opt_include}")}\n" if f.include.directory?
+      s << "  #{Utils::Shell.export_value("CPPFLAGS", "-I#{formula.opt_include}")}\n" if formula.include.directory?
 
       if which("pkg-config", ORIGINAL_PATHS) &&
-         ((f.lib/"pkgconfig").directory? || (f.share/"pkgconfig").directory?)
+         ((formula.lib/"pkgconfig").directory? || (formula.share/"pkgconfig").directory?)
         s << <<~EOS
 
-          For pkg-config to find #{f.name} you may need to set:
+          For pkg-config to find #{formula.name} you may need to set:
         EOS
 
-        if (f.lib/"pkgconfig").directory?
-          s << "  #{Utils::Shell.export_value("PKG_CONFIG_PATH", "#{f.opt_lib}/pkgconfig")}\n"
+        if (formula.lib/"pkgconfig").directory?
+          s << "  #{Utils::Shell.export_value("PKG_CONFIG_PATH", "#{formula.opt_lib}/pkgconfig")}\n"
         end
 
-        if (f.share/"pkgconfig").directory?
-          s << "  #{Utils::Shell.export_value("PKG_CONFIG_PATH", "#{f.opt_share}/pkgconfig")}\n"
+        if (formula.share/"pkgconfig").directory?
+          s << "  #{Utils::Shell.export_value("PKG_CONFIG_PATH", "#{formula.opt_share}/pkgconfig")}\n"
         end
       end
     end
-    s << "\n"
+    s << "\n" unless s.end_with?("\n")
+    s
   end
 
   private
 
+  sig { returns(T.nilable(Keg)) }
   def keg
-    @keg ||= [f.prefix, f.opt_prefix, f.linked_keg].map do |d|
+    @keg ||= T.let([formula.prefix, formula.opt_prefix, formula.linked_keg].filter_map do |d|
       Keg.new(d.resolved_path)
     rescue
       nil
-    end.compact.first
+    end.first, T.nilable(Keg))
   end
 
+  sig { params(shell: Symbol).returns(T.nilable(String)) }
   def function_completion_caveats(shell)
-    return unless keg
+    return unless (keg = self.keg)
     return unless which(shell.to_s, ORIGINAL_PATHS)
 
     completion_installed = keg.completion_installed?(shell)
@@ -119,7 +125,7 @@ def function_completion_caveats(shell)
     installed << "completions" if completion_installed
     installed << "functions" if functions_installed
 
-    root_dir = f.keg_only? ? f.opt_prefix : HOMEBREW_PREFIX
+    root_dir = formula.keg_only? ? formula.opt_prefix : HOMEBREW_PREFIX
 
     case shell
     when :bash
@@ -127,69 +133,60 @@ def function_completion_caveats(shell)
         Bash completion has been installed to:
           #{root_dir}/etc/bash_completion.d
       EOS
+    when :fish
+      fish_caveats = "fish #{installed.join(" and ")} have been installed to:"
+      fish_caveats << "\n  #{root_dir}/share/fish/vendor_completions.d" if completion_installed
+      fish_caveats << "\n  #{root_dir}/share/fish/vendor_functions.d" if functions_installed
+      fish_caveats.freeze
     when :zsh
       <<~EOS
         zsh #{installed.join(" and ")} have been installed to:
           #{root_dir}/share/zsh/site-functions
       EOS
-    when :fish
-      fish_caveats = +"fish #{installed.join(" and ")} have been installed to:"
-      fish_caveats << "\n  #{root_dir}/share/fish/vendor_completions.d" if completion_installed
-      fish_caveats << "\n  #{root_dir}/share/fish/vendor_functions.d" if functions_installed
-      fish_caveats.freeze
     end
   end
 
+  sig { returns(T.nilable(String)) }
   def elisp_caveats
-    return if f.keg_only?
-    return unless keg
+    return if formula.keg_only?
+    return unless (keg = self.keg)
     return unless keg.elisp_installed?
 
     <<~EOS
       Emacs Lisp files have been installed to:
-        #{HOMEBREW_PREFIX}/share/emacs/site-lisp/#{f.name}
+        #{HOMEBREW_PREFIX}/share/emacs/site-lisp/#{formula.name}
     EOS
   end
 
+  sig { returns(T.nilable(String)) }
   def service_caveats
-    return if !f.plist && !f.service? && !keg&.plist_installed?
+    return if !formula.service? && !Utils::Service.installed?(formula) && !keg&.plist_installed?
+    return if formula.service? && !formula.service.command? && !Utils::Service.installed?(formula)
 
     s = []
 
-    command = if f.service?
-      f.service.manual_command
-    else
-      f.plist_manual
-    end
-
-    return <<~EOS if !which("launchctl") && f.plist
-      #{Formatter.warning("Warning:")} #{f.name} provides a launchd plist which can only be used on macOS!
-      You can manually execute the service instead with:
-        #{command}
-    EOS
-
     # Brew services only works with these two tools
-    return <<~EOS if !which("systemctl") && !which("launchctl") && f.service?
-      #{Formatter.warning("Warning:")} #{f.name} provides a service which can only be used on macOS or systemd!
+    return <<~EOS if !Utils::Service.systemctl? && !Utils::Service.launchctl? && formula.service.command?
+      #{Formatter.warning("Warning:")} #{formula.name} provides a service which can only be used on macOS or systemd!
       You can manually execute the service instead with:
-        #{command}
+        #{formula.service.manual_command}
     EOS
 
-    is_running_service = f.service? && quiet_system("ps aux | grep #{f.service.command&.first}")
-    if is_running_service || (f.plist && quiet_system("/bin/launchctl list #{f.plist_name} &>/dev/null"))
-      s << "To restart #{f.full_name} after an upgrade:"
-      s << "  #{f.plist_startup ? "sudo " : ""}brew services restart #{f.full_name}"
-    elsif f.plist_startup
-      s << "To start #{f.full_name} now and restart at startup:"
-      s << "  sudo brew services start #{f.full_name}"
+    startup = formula.service.requires_root?
+    if Utils::Service.running?(formula)
+      s << "To restart #{formula.full_name} after an upgrade:"
+      s << "  #{startup ? "sudo " : ""}brew services restart #{formula.full_name}"
+    elsif startup
+      s << "To start #{formula.full_name} now and restart at startup:"
+      s << "  sudo brew services start #{formula.full_name}"
     else
-      s << "To start #{f.full_name} now and restart at login:"
-      s << "  brew services start #{f.full_name}"
+      s << "To start #{formula.full_name} now and restart at login:"
+      s << "  brew services start #{formula.full_name}"
     end
 
-    if f.plist_manual || f.service?
+    if formula.service.command?
       s << "Or, if you don't want/need a background service you can just run:"
-      s << "  #{command}"
+      s << "  #{formula.service.manual_command}"
     end
 
     # pbpaste is the system clipboard tool on macOS and fails with `tmux` by default
diff --git a/Library/Homebrew/checksum.rb b/Library/Homebrew/checksum.rb
index 30d0d2f22e749..210a9fb2e4c5b 100644
--- a/Library/Homebrew/checksum.rb
+++ b/Library/Homebrew/checksum.rb
@@ -1,20 +1,21 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 # A formula's checksum.
-#
-# @api private
 class Checksum
   extend Forwardable
 
+  sig { returns(String) }
   attr_reader :hexdigest
 
+  sig { params(hexdigest: String).void }
   def initialize(hexdigest)
-    @hexdigest = hexdigest.downcase
+    @hexdigest = T.let(hexdigest.downcase, String)
   end
 
   delegate [:empty?, :to_s, :length, :[]] => :@hexdigest
 
+  sig { params(other: T.any(String, Checksum, Symbol)).returns(T::Boolean) }
   def ==(other)
     case other
     when String
diff --git a/Library/Homebrew/cleaner.rb b/Library/Homebrew/cleaner.rb
index 32954f6b0c8c4..5df0e39b15865 100644
--- a/Library/Homebrew/cleaner.rb
+++ b/Library/Homebrew/cleaner.rb
@@ -1,10 +1,11 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 # Cleans a newly installed keg.
 # By default:
 #
 # * removes `.la` files
+# * removes `.tbd` files
 # * removes `perllocal.pod` files
 # * removes `.packlist` files
 # * removes empty directories
@@ -14,55 +15,59 @@ class Cleaner
   include Context
 
   # Create a cleaner for the given formula.
-  def initialize(f)
-    @f = f
+  sig { params(formula: Formula).void }
+  def initialize(formula)
+    @formula = formula
   end
 
   # Clean the keg of the formula.
+  sig { void }
   def clean
     ObserverPathnameExtension.reset_counts!
 
-    # Many formulae include 'lib/charset.alias', but it is not strictly needed
-    # and will conflict if more than one formula provides it
-    observe_file_removal @f.lib/"charset.alias"
+    # Many formulae include `lib/charset.alias`, but it is not strictly needed
+    # and will conflict if more than one formula provides it.
+    observe_file_removal @formula.lib/"charset.alias"
 
-    [@f.bin, @f.sbin, @f.lib].each { |d| clean_dir(d) if d.exist? }
+    [@formula.bin, @formula.sbin, @formula.lib].each { |dir| clean_dir(dir) if dir.exist? }
 
-    # Get rid of any info 'dir' files, so they don't conflict at the link stage
+    # Get rid of any info `dir` files, so they don't conflict at the link stage.
     #
-    # The 'dir' files come in at least 3 locations:
+    # The `dir` files come in at least 3 locations:
     #
-    # 1. 'info/dir'
-    # 2. 'info/#{name}/dir'
-    # 3. 'info/#{arch}/dir'
+    # 1. `info/dir`
+    # 2. `info/#{name}/dir`
+    # 3. `info/#{arch}/dir`
     #
-    # Of these 3 only 'info/#{name}/dir' is safe to keep since the rest will
+    # Of these 3 only `info/#{name}/dir` is safe to keep since the rest will
     # conflict with other formulae because they use a shared location.
     #
-    # See [cleaner: recursively delete info `dir`s by gromgit · Pull Request
-    # #11597][1], [emacs 28.1 bottle does not contain `dir` file · Issue
-    # #100190][2], and [Keep `info/#{f.name}/dir` files in cleaner by
-    # timvisher][3] for more info.
+    # See
+    # [cleaner: recursively delete info `dir`s][1],
+    # [emacs 28.1 bottle does not contain `dir` file][2] and
+    # [Keep `info/#{f.name}/dir` files in cleaner][3]
+    # for more info.
     #
     # [1]: https://github.com/Homebrew/brew/pull/11597
     # [2]: https://github.com/Homebrew/homebrew-core/issues/100190
     # [3]: https://github.com/Homebrew/brew/pull/13215
-    Dir.glob(@f.info/"**/dir").each do |f|
-      info_dir_file = Pathname(f)
+    @formula.info.glob("**/dir").each do |info_dir_file|
       next unless info_dir_file.file?
-      next if info_dir_file == @f.info/@f.name/"dir"
-      next if @f.skip_clean?(info_dir_file)
+      next if info_dir_file == @formula.info/@formula.name/"dir"
+      next if @formula.skip_clean?(info_dir_file)
 
       observe_file_removal info_dir_file
     end
 
     rewrite_shebangs
+    clean_python_metadata
 
     prune
   end
 
   private
 
+  sig { params(path: Pathname).void }
   def observe_file_removal(path)
     path.extend(ObserverPathnameExtension).unlink if path.exist?
   end
@@ -70,11 +75,12 @@ def observe_file_removal(path)
   # Removes any empty directories in the formula's prefix subtree
   # Keeps any empty directories protected by skip_clean
   # Removes any unresolved symlinks
+  sig { void }
   def prune
     dirs = []
     symlinks = []
-    @f.prefix.find do |path|
-      if path == @f.libexec || @f.skip_clean?(path)
+    @formula.prefix.find do |path|
+      if path == @formula.libexec || @formula.skip_clean?(path)
         Find.prune
       elsif path.symlink?
         symlinks << path
@@ -98,6 +104,7 @@ def prune
     end
   end
 
+  sig { params(path: Pathname).returns(T::Boolean) }
   def executable_path?(path)
     path.text_executable? || path.executable?
   end
@@ -106,31 +113,32 @@ def executable_path?(path)
   # pointless conflicts with other formulae. They are removed by Debian,
   # Arch & MacPorts amongst other packagers as well. The files are
   # created as part of installing any Perl module.
-  PERL_BASENAMES = Set.new(%w[perllocal.pod .packlist]).freeze
+  PERL_BASENAMES = T.let(Set.new(%w[perllocal.pod .packlist]).freeze, T::Set[String])
 
-  # Clean a top-level (bin, sbin, lib) directory, recursively, by fixing file
+  # Clean a top-level (`bin`, `sbin`, `lib`) directory, recursively, by fixing file
   # permissions and removing .la files, unless the files (or parent
   # directories) are protected by skip_clean.
   #
-  # bin and sbin should not have any subdirectories; if either do that is
-  # caught as an audit warning
+  # `bin` and `sbin` should not have any subdirectories; if either do that is
+  # caught as an audit warning.
   #
-  # lib may have a large directory tree (see Erlang for instance), and
-  # clean_dir applies cleaning rules to the entire tree
-  def clean_dir(d)
-    d.find do |path|
+  # `lib` may have a large directory tree (see Erlang for instance) and
+  # clean_dir applies cleaning rules to the entire tree.
+  sig { params(directory: Pathname).void }
+  def clean_dir(directory)
+    directory.find do |path|
       path.extend(ObserverPathnameExtension)
 
-      Find.prune if @f.skip_clean? path
+      Find.prune if @formula.skip_clean? path
 
       next if path.directory?
 
-      if path.extname == ".la" || PERL_BASENAMES.include?(path.basename.to_s)
+      if path.extname == ".la" || path.extname == ".tbd" || PERL_BASENAMES.include?(path.basename.to_s)
         path.unlink
       elsif path.symlink?
         # Skip it.
       else
-        # Set permissions for executables and non-executables
+        # Set permissions for executables and non-executables.
         perms = if executable_path?(path)
           0555
         else
@@ -145,20 +153,50 @@ def clean_dir(d)
     end
   end
 
+  sig { void }
   def rewrite_shebangs
+    require "language/node"
     require "language/perl"
     require "utils/shebang"
 
-    basepath = @f.prefix.realpath
+    rewrites = [Language::Node::Shebang.method(:detected_node_shebang),
+                Language::Perl::Shebang.method(:detected_perl_shebang)].filter_map do |detector|
+      detector.call(@formula)
+    rescue ShebangDetectionError
+      nil
+    end
+    return if rewrites.empty?
+
+    basepath = @formula.prefix.realpath
     basepath.find do |path|
-      Find.prune if @f.skip_clean? path
+      Find.prune if @formula.skip_clean? path
 
       next if path.directory? || path.symlink?
 
-      begin
-        Utils::Shebang.rewrite_shebang Language::Perl::Shebang.detected_perl_shebang(@f), path
-      rescue ShebangDetectionError
-        break
+      rewrites.each { |rw| Utils::Shebang.rewrite_shebang rw, path }
+    end
+  end
+
+  # Remove non-reproducible pip direct_url.json which records the /tmp build directory.
+  # Remove RECORD files to prevent changes to the installed Python package.
+  # Modify INSTALLER to provide information that files are managed by brew.
+  #
+  # @see https://packaging.python.org/en/latest/specifications/recording-installed-packages/
+  sig { void }
+  def clean_python_metadata
+    basepath = @formula.prefix.realpath
+    basepath.find do |path|
+      Find.prune if @formula.skip_clean?(path)
+
+      next if path.directory? || path.symlink?
+      next if path.parent.extname != ".dist-info"
+
+      case path.basename.to_s
+      when "direct_url.json", "RECORD"
+        observe_file_removal path
+      when "INSTALLER"
+        odebug "Modifying #{path} contents from #{path.read.chomp} to brew"
+        path.atomic_write("brew\n")
       end
     end
   end
diff --git a/Library/Homebrew/cleanup.rb b/Library/Homebrew/cleanup.rb
index 4eb4689c9bacc..99d2fa3311f1f 100644
--- a/Library/Homebrew/cleanup.rb
+++ b/Library/Homebrew/cleanup.rb
@@ -1,142 +1,198 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "utils/bottles"
 
+require "attrable"
 require "formula"
 require "cask/cask_loader"
-require "set"
 
 module Homebrew
   # Helper class for cleaning up the Homebrew cache.
-  #
-  # @api private
   class Cleanup
     CLEANUP_DEFAULT_DAYS = Homebrew::EnvConfig.cleanup_periodic_full_days.to_i.freeze
     private_constant :CLEANUP_DEFAULT_DAYS
 
-    # {Pathname} refinement with helper functions for cleaning up files.
-    module CleanupRefinement
-      refine Pathname do
-        def incomplete?
-          extname.end_with?(".incomplete")
-        end
+    class << self
+      sig { params(pathname: Pathname).returns(T::Boolean) }
+      def incomplete?(pathname)
+        pathname.extname.end_with?(".incomplete")
+      end
 
-        def nested_cache?
-          directory? && %w[
-            cargo_cache
-            go_cache
-            go_mod_cache
-            glide_home
-            java_cache
-            npm_cache
-            gclient_cache
-          ].include?(basename.to_s)
-        end
+      sig { params(pathname: Pathname).returns(T::Boolean) }
+      def nested_cache?(pathname)
+        pathname.directory? && %w[
+          cargo_cache
+          go_cache
+          go_mod_cache
+          glide_home
+          java_cache
+          npm_cache
+          pip_cache
+          gclient_cache
+        ].include?(pathname.basename.to_s)
+      end
 
-        def go_cache_directory?
-          # Go makes its cache contents read-only to ensure cache integrity,
-          # which makes sense but is something we need to undo for cleanup.
-          directory? && %w[go_cache go_mod_cache].include?(basename.to_s)
-        end
+      sig { params(pathname: Pathname).returns(T::Boolean) }
+      def go_cache_directory?(pathname)
+        # Go makes its cache contents read-only to ensure cache integrity,
+        # which makes sense but is something we need to undo for cleanup.
+        pathname.directory? && %w[go_cache go_mod_cache].include?(pathname.basename.to_s)
+      end
 
-        def prune?(days)
-          return false unless days
-          return true if days.zero?
+      sig { params(pathname: Pathname, days: T.nilable(Integer)).returns(T::Boolean) }
+      def prune?(pathname, days)
+        return false unless days
+        return true if days.zero?
+        return true if pathname.symlink? && !pathname.exist?
 
-          return true if symlink? && !exist?
+        days_ago = (DateTime.now - days).to_time
+        pathname.mtime < days_ago && pathname.ctime < days_ago
+      end
 
-          mtime < days.days.ago && ctime < days.days.ago
+      sig { params(entry: { path: Pathname, type: T.nilable(Symbol) }, scrub: T::Boolean).returns(T::Boolean) }
+      def stale?(entry, scrub: false)
+        pathname = entry[:path]
+        return false unless pathname.resolved_path.file?
+
+        case entry[:type]
+        when :api_source
+          stale_api_source?(pathname, scrub)
+        when :cask
+          stale_cask?(pathname, scrub)
+        when :gh_actions_artifact
+          stale_gh_actions_artifact?(pathname, scrub)
+        else
+          stale_formula?(pathname, scrub)
         end
+      end
 
-        def stale?(scrub: false)
-          return false unless resolved_path.file?
+      private
 
-          if dirname.basename.to_s == "Cask"
-            stale_cask?(scrub)
-          else
-            stale_formula?(scrub)
+      GH_ACTIONS_ARTIFACT_CLEANUP_DAYS = 3
+
+      sig { params(pathname: Pathname, scrub: T::Boolean).returns(T::Boolean) }
+      def stale_gh_actions_artifact?(pathname, scrub)
+        scrub || prune?(pathname, GH_ACTIONS_ARTIFACT_CLEANUP_DAYS)
+      end
+
+      sig { params(pathname: Pathname, scrub: T::Boolean).returns(T::Boolean) }
+      def stale_api_source?(pathname, scrub)
+        return true if scrub
+
+        org, repo, git_head, type, basename = pathname.each_filename.to_a.last(5)
+
+        name = "#{org}/#{repo}/#{File.basename(T.must(basename), ".rb")}"
+        package = if type == "Cask"
+          begin
+            Cask::CaskLoader.load(name)
+          rescue Cask::CaskError
+            nil
+          end
+        else
+          begin
+            Formulary.factory(name)
+          rescue FormulaUnavailableError
+            nil
           end
         end
+        return true if package.nil?
 
-        private
+        package.tap_git_head != git_head
+      end
 
-        def stale_formula?(scrub)
-          return false unless HOMEBREW_CELLAR.directory?
+      sig { params(pathname: Pathname, scrub: T::Boolean).returns(T::Boolean) }
+      def stale_formula?(pathname, scrub)
+        return false unless HOMEBREW_CELLAR.directory?
 
-          version = if HOMEBREW_BOTTLES_EXTNAME_REGEX.match?(to_s)
-            begin
-              Utils::Bottles.resolve_version(self)
-            rescue
-              nil
-            end
+        version = if HOMEBREW_BOTTLES_EXTNAME_REGEX.match?(to_s)
+          begin
+            Utils::Bottles.resolve_version(pathname).to_s
+          rescue
+            nil
           end
+        end
+        basename_str = pathname.basename.to_s
 
-          version ||= basename.to_s[/\A.*(?:--.*?)*--(.*?)#{Regexp.escape(extname)}\Z/, 1]
-          version ||= basename.to_s[/\A.*--?(.*?)#{Regexp.escape(extname)}\Z/, 1]
+        version ||= basename_str[/\A.*(?:--.*?)*--(.*?)#{Regexp.escape(pathname.extname)}\Z/, 1]
+        version ||= basename_str[/\A.*--?(.*?)#{Regexp.escape(pathname.extname)}\Z/, 1]
 
-          return false unless version
+        return false if version.blank?
 
-          version = Version.new(version)
+        version = Version.new(version)
+
+        unless (formula_name = basename_str[/\A(.*?)(?:--.*?)*--?(?:#{Regexp.escape(version.to_s)})/, 1])
+          return false
+        end
 
-          return false unless (formula_name = basename.to_s[/\A(.*?)(?:--.*?)*--?(?:#{Regexp.escape(version)})/, 1])
+        formula = begin
+          Formulary.from_rack(HOMEBREW_CELLAR/formula_name)
+        rescue FormulaUnavailableError, TapFormulaAmbiguityError
+          nil
+        end
 
+        if formula.blank? && formula_name.delete_suffix!("_bottle_manifest")
           formula = begin
             Formulary.from_rack(HOMEBREW_CELLAR/formula_name)
-          rescue FormulaUnavailableError, TapFormulaAmbiguityError, TapFormulaWithOldnameAmbiguityError
+          rescue FormulaUnavailableError, TapFormulaAmbiguityError
             nil
           end
 
           return false if formula.blank?
 
-          resource_name = basename.to_s[/\A.*?--(.*?)--?(?:#{Regexp.escape(version)})/, 1]
-
-          if resource_name == "patch"
-            patch_hashes = formula.stable&.patches&.select(&:external?)&.map(&:resource)&.map(&:version)
-            return true unless patch_hashes&.include?(Checksum.new(version.to_s))
-          elsif resource_name && (resource_version = formula.stable&.resources&.dig(resource_name)&.version)
-            return true if resource_version != version
-          elsif version.is_a?(PkgVersion)
-            return true if formula.pkg_version > version
-          elsif formula.version > version
-            return true
-          end
-
-          return true if scrub && !formula.latest_version_installed?
+          # We can't determine an installed rebuild and parsing manifest version cannot be reliably done.
+          return false unless formula.latest_version_installed?
 
-          return true if Utils::Bottles.file_outdated?(formula, self)
+          return true if (bottle = formula.bottle).blank?
 
-          false
+          return version != GitHubPackages.version_rebuild(bottle.resource.version, bottle.rebuild)
         end
 
-        def stale_cask?(scrub)
-          return false unless (name = basename.to_s[/\A(.*?)--/, 1])
+        return false if formula.blank?
 
-          cask = begin
-            Cask::CaskLoader.load(name)
-          rescue Cask::CaskError
-            nil
-          end
+        resource_name = basename_str[/\A.*?--(.*?)--?(?:#{Regexp.escape(version.to_s)})/, 1]
 
-          return false if cask.blank?
+        if resource_name == "patch"
+          patch_hashes = formula.stable&.patches&.select(&:external?)&.map(&:resource)&.map(&:version)
+          return true unless patch_hashes&.include?(Checksum.new(version.to_s))
+        elsif resource_name && (resource_version = formula.stable&.resources&.dig(resource_name)&.version)
+          return true if resource_version != version
+        elsif (formula.latest_version_installed? && formula.pkg_version.to_s != version) ||
+              formula.pkg_version.to_s > version
+          return true
+        end
 
-          return true unless basename.to_s.match?(/\A#{Regexp.escape(name)}--#{Regexp.escape(cask.version)}\b/)
+        return true if scrub && !formula.latest_version_installed?
+        return true if Utils::Bottles.file_outdated?(formula, pathname)
 
-          return true if scrub && cask.versions.exclude?(cask.version)
+        false
+      end
 
-          if cask.version.latest?
-            return mtime < CLEANUP_DEFAULT_DAYS.days.ago &&
-                   ctime < CLEANUP_DEFAULT_DAYS.days.ago
-          end
+      sig { params(pathname: Pathname, scrub: T::Boolean).returns(T::Boolean) }
+      def stale_cask?(pathname, scrub)
+        basename = pathname.basename
+        return false unless (name = basename.to_s[/\A(.*?)--/, 1])
 
-          false
+        cask = begin
+          Cask::CaskLoader.load(name)
+        rescue Cask::CaskError
+          nil
         end
+
+        return false if cask.blank?
+        return true unless basename.to_s.match?(/\A#{Regexp.escape(name)}--#{Regexp.escape(cask.version)}\b/)
+        return true if scrub && cask.installed_version != cask.version
+
+        if cask.version.latest?
+          cleanup_threshold = (DateTime.now - CLEANUP_DEFAULT_DAYS).to_time
+          return pathname.mtime < cleanup_threshold && pathname.ctime < cleanup_threshold
+        end
+
+        false
       end
     end
 
-    using CleanupRefinement
-
-    extend Predicable
+    extend Attrable
 
     PERIODIC_CLEAN_FILE = (HOMEBREW_CACHE/".cleaned").freeze
 
@@ -154,37 +210,47 @@ def initialize(*args, dry_run: false, scrub: false, days: nil, cache: HOMEBREW_C
       @cleaned_up_paths = Set.new
     end
 
-    def self.install_formula_clean!(f, dry_run: false)
+    def self.install_formula_clean!(formula, dry_run: false)
       return if Homebrew::EnvConfig.no_install_cleanup?
+      return unless formula.latest_version_installed?
+      return if skip_clean_formula?(formula)
 
-      cleanup = Cleanup.new(dry_run: dry_run)
-      if cleanup.periodic_clean_due?
-        cleanup.periodic_clean!
-      elsif f.latest_version_installed? && !cleanup.skip_clean_formula?(f)
-        ohai "Running `brew cleanup #{f}`..."
-        puts_no_install_cleanup_disable_message_if_not_already!
-        cleanup.cleanup_formula(f)
+      if dry_run
+        ohai "Would run `brew cleanup #{formula}`"
+      else
+        ohai "Running `brew cleanup #{formula}`..."
       end
+
+      puts_no_install_cleanup_disable_message_if_not_already!
+      return if dry_run
+
+      Cleanup.new.cleanup_formula(formula)
     end
 
-    def self.puts_no_install_cleanup_disable_message_if_not_already!
+    def self.puts_no_install_cleanup_disable_message
       return if Homebrew::EnvConfig.no_env_hints?
       return if Homebrew::EnvConfig.no_install_cleanup?
-      return if @puts_no_install_cleanup_disable_message_if_not_already
 
       puts "Disable this behaviour by setting HOMEBREW_NO_INSTALL_CLEANUP."
       puts "Hide these hints with HOMEBREW_NO_ENV_HINTS (see `man brew`)."
+    end
+
+    def self.puts_no_install_cleanup_disable_message_if_not_already!
+      return if @puts_no_install_cleanup_disable_message_if_not_already
+
+      puts_no_install_cleanup_disable_message
       @puts_no_install_cleanup_disable_message_if_not_already = true
     end
 
-    def skip_clean_formula?(f)
-      return false if Homebrew::EnvConfig.no_cleanup_formulae.blank?
+    def self.skip_clean_formula?(formula)
+      no_cleanup_formula = Homebrew::EnvConfig.no_cleanup_formulae
+      return false if no_cleanup_formula.blank?
 
-      skip_clean_formulae = Homebrew::EnvConfig.no_cleanup_formulae.split(",")
-      skip_clean_formulae.include?(f.name) || (skip_clean_formulae & f.aliases).present?
+      @skip_clean_formulae ||= no_cleanup_formula.split(",")
+      @skip_clean_formulae.include?(formula.name) || @skip_clean_formulae.intersect?(formula.aliases)
     end
 
-    def periodic_clean_due?
+    def self.periodic_clean_due?
       return false if Homebrew::EnvConfig.no_install_cleanup?
 
       unless PERIODIC_CLEAN_FILE.exist?
@@ -193,35 +259,46 @@ def periodic_clean_due?
         return false
       end
 
-      PERIODIC_CLEAN_FILE.mtime < CLEANUP_DEFAULT_DAYS.days.ago
+      PERIODIC_CLEAN_FILE.mtime < (DateTime.now - CLEANUP_DEFAULT_DAYS).to_time
     end
 
-    def periodic_clean!
-      return false unless periodic_clean_due?
+    def self.periodic_clean!(dry_run: false)
+      return if Homebrew::EnvConfig.no_install_cleanup?
+      return unless periodic_clean_due?
 
-      if dry_run?
-        ohai "Would run `brew cleanup` which has not been run in the last #{CLEANUP_DEFAULT_DAYS} days"
+      if dry_run
+        oh1 "Would run `brew cleanup` which has not been run in the last #{CLEANUP_DEFAULT_DAYS} days"
       else
-        ohai "`brew cleanup` has not been run in the last #{CLEANUP_DEFAULT_DAYS} days, running now..."
+        oh1 "`brew cleanup` has not been run in the last #{CLEANUP_DEFAULT_DAYS} days, running now..."
       end
 
-      Cleanup.puts_no_install_cleanup_disable_message_if_not_already!
-      return if dry_run?
+      puts_no_install_cleanup_disable_message
+      return if dry_run
 
-      clean!(quiet: true, periodic: true)
+      Cleanup.new.clean!(quiet: true, periodic: true)
     end
 
     def clean!(quiet: false, periodic: false)
       if args.empty?
         Formula.installed
                .sort_by(&:name)
-               .reject { |f| skip_clean_formula?(f) }
+               .reject { |f| Cleanup.skip_clean_formula?(f) }
                .each do |formula|
-          cleanup_formula(formula, quiet: quiet, ds_store: false, cache_db: false)
+          cleanup_formula(formula, quiet:, ds_store: false, cache_db: false)
+        end
+
+        if ENV["HOMEBREW_AUTOREMOVE"].present?
+          opoo "HOMEBREW_AUTOREMOVE is now a no-op as it is the default behaviour. " \
+               "Set HOMEBREW_NO_AUTOREMOVE=1 to disable it."
         end
+        Cleanup.autoremove(dry_run: dry_run?) unless Homebrew::EnvConfig.no_autoremove?
+
         cleanup_cache
+        cleanup_empty_api_source_directories
+        cleanup_bootsnap
         cleanup_logs
         cleanup_lockfiles
+        cleanup_python_site_packages
         prune_prefix_symlinks_and_directories
 
         unless dry_run?
@@ -238,12 +315,11 @@ def clean!(quiet: false, periodic: false)
         return if periodic
 
         cleanup_portable_ruby
-        cleanup_bootsnap
       else
         args.each do |arg|
           formula = begin
             Formulary.resolve(arg)
-          rescue FormulaUnavailableError, TapFormulaAmbiguityError, TapFormulaWithOldnameAmbiguityError
+          rescue FormulaUnavailableError, TapFormulaAmbiguityError
             nil
           end
 
@@ -253,7 +329,7 @@ def clean!(quiet: false, periodic: false)
             nil
           end
 
-          if formula && skip_clean_formula?(formula)
+          if formula && Cleanup.skip_clean_formula?(formula)
             onoe "Refusing to clean #{formula} because it is listed in " \
                  "#{Tty.bold}HOMEBREW_NO_CLEANUP_FORMULAE#{Tty.reset}!"
           elsif formula
@@ -269,16 +345,16 @@ def unremovable_kegs
     end
 
     def cleanup_formula(formula, quiet: false, ds_store: true, cache_db: true)
-      formula.eligible_kegs_for_cleanup(quiet: quiet)
-             .each(&method(:cleanup_keg))
-      cleanup_cache(Pathname.glob(cache/"#{formula.name}--*"))
+      formula.eligible_kegs_for_cleanup(quiet:)
+             .each { cleanup_keg(_1) }
+      cleanup_cache(Pathname.glob(cache/"#{formula.name}{_bottle_manifest,}--*").map { |path| { path:, type: nil } })
       rm_ds_store([formula.rack]) if ds_store
       cleanup_cache_db(formula.rack) if cache_db
       cleanup_lockfiles(FormulaLock.new(formula.name).path)
     end
 
     def cleanup_cask(cask, ds_store: true)
-      cleanup_cache(Pathname.glob(cache/"Cask/#{cask.token}--*"))
+      cleanup_cache(Pathname.glob(cache/"Cask/#{cask.token}--*").map { |path| { path:, type: :cask } })
       rm_ds_store([cask.caskroom_path]) if ds_store
       cleanup_lockfiles(CaskLock.new(cask.token).path)
     end
@@ -293,14 +369,34 @@ def cleanup_keg(keg)
     def cleanup_logs
       return unless HOMEBREW_LOGS.directory?
 
-      logs_days = if days > CLEANUP_DEFAULT_DAYS
-        CLEANUP_DEFAULT_DAYS
-      else
-        days
-      end
+      logs_days = [days, CLEANUP_DEFAULT_DAYS].min
 
       HOMEBREW_LOGS.subdirs.each do |dir|
-        cleanup_path(dir) { dir.rmtree } if dir.prune?(logs_days)
+        cleanup_path(dir) { FileUtils.rm_r(dir) } if self.class.prune?(dir, logs_days)
+      end
+    end
+
+    def cache_files
+      files = cache.directory? ? cache.children : []
+      cask_files = (cache/"Cask").directory? ? (cache/"Cask").children : []
+      api_source_files = (cache/"api-source").glob("*/*/*/*/*") # `<org>/<repo>/<git_head>/<type>/<token>.rb`
+      gh_actions_artifacts = (cache/"gh-actions-artifact").directory? ? (cache/"gh-actions-artifact").children : []
+
+      files.map { |path| { path:, type: nil } } +
+        cask_files.map { |path| { path:, type: :cask } } +
+        api_source_files.map { |path| { path:, type: :api_source } } +
+        gh_actions_artifacts.map { |path| { path:, type: :gh_actions_artifact } }
+    end
+
+    def cleanup_empty_api_source_directories(directory = cache/"api-source")
+      return if dry_run?
+      return unless directory.directory?
+
+      directory.each_child do |child|
+        next unless child.directory?
+
+        cleanup_empty_api_source_directories(child)
+        child.rmdir if child.empty?
       end
     end
 
@@ -310,15 +406,12 @@ def cleanup_unreferenced_downloads
 
       downloads = (cache/"downloads").children
 
-      referenced_downloads = [cache, cache/"Cask"].select(&:directory?)
-                                                  .flat_map(&:children)
-                                                  .select(&:symlink?)
-                                                  .map(&:resolved_path)
+      referenced_downloads = cache_files.map { |file| file[:path] }.select(&:symlink?).map(&:resolved_path)
 
       (downloads - referenced_downloads).each do |download|
-        if download.incomplete?
+        if self.class.incomplete?(download)
           begin
-            LockFile.new(download.basename).with_lock do
+            DownloadLock.new(download).with_lock do
               download.unlink
             end
           rescue OperationInProgressError
@@ -334,16 +427,17 @@ def cleanup_unreferenced_downloads
     end
 
     def cleanup_cache(entries = nil)
-      entries ||= [cache, cache/"Cask"].select(&:directory?).flat_map(&:children)
+      entries ||= cache_files
 
-      entries.each do |path|
+      entries.each do |entry|
+        path = entry[:path]
         next if path == PERIODIC_CLEAN_FILE
 
-        FileUtils.chmod_R 0755, path if path.go_cache_directory? && !dry_run?
-        next cleanup_path(path) { path.unlink } if path.incomplete?
-        next cleanup_path(path) { FileUtils.rm_rf path } if path.nested_cache?
+        FileUtils.chmod_R 0755, path if self.class.go_cache_directory?(path) && !dry_run?
+        next cleanup_path(path) { path.unlink } if self.class.incomplete?(path)
+        next cleanup_path(path) { FileUtils.rm_rf path } if self.class.nested_cache?(path)
 
-        if path.prune?(days)
+        if self.class.prune?(path, days)
           if path.file? || path.symlink?
             cleanup_path(path) { path.unlink }
           elsif path.directory? && path.to_s.include?("--")
@@ -353,7 +447,7 @@ def cleanup_cache(entries = nil)
         end
 
         # If we've specified --prune don't do the (expensive) .stale? check.
-        cleanup_path(path) { path.unlink } if !prune? && path.stale?(scrub: scrub?)
+        cleanup_path(path) { path.unlink } if !prune? && self.class.stale?(entry, scrub: scrub?)
       end
 
       cleanup_unreferenced_downloads
@@ -391,55 +485,53 @@ def cleanup_lockfiles(*lockfiles)
     end
 
     def cleanup_portable_ruby
-      rubies = [which("ruby"), which("ruby", ORIGINAL_PATHS)].compact
-      system_ruby = Pathname.new("/usr/bin/ruby")
-      rubies << system_ruby if system_ruby.exist?
-
-      use_system_ruby = if Homebrew::EnvConfig.force_vendor_ruby?
-        false
-      elsif OS.mac?
-        ENV["HOMEBREW_MACOS_SYSTEM_RUBY_NEW_ENOUGH"].present?
-      else
-        check_ruby_version = HOMEBREW_LIBRARY_PATH/"utils/ruby_check_version_script.rb"
-        rubies.uniq.any? do |ruby|
-          quiet_system ruby, "--enable-frozen-string-literal", "--disable=gems,did_you_mean,rubyopt",
-                       check_ruby_version, HOMEBREW_REQUIRED_RUBY_VERSION
-        end
-      end
-
       vendor_dir = HOMEBREW_LIBRARY/"Homebrew/vendor"
       portable_ruby_latest_version = (vendor_dir/"portable-ruby-version").read.chomp
 
       portable_rubies_to_remove = []
       Pathname.glob(vendor_dir/"portable-ruby/*.*").select(&:directory?).each do |path|
-        next if !use_system_ruby && portable_ruby_latest_version == path.basename.to_s
+        next if !use_system_ruby? && portable_ruby_latest_version == path.basename.to_s
 
         portable_rubies_to_remove << path
-        puts "Would remove: #{path} (#{path.abv})" if dry_run?
       end
 
       return if portable_rubies_to_remove.empty?
 
-      bundler_path = vendor_dir/"bundle/ruby"
-      if dry_run?
-        puts Utils.popen_read("git", "-C", HOMEBREW_REPOSITORY, "clean", "-nx", bundler_path).chomp
-      else
-        puts Utils.popen_read("git", "-C", HOMEBREW_REPOSITORY, "clean", "-ffqx", bundler_path).chomp
+      bundler_paths = (vendor_dir/"bundle/ruby").children.select do |child|
+        basename = child.basename.to_s
+
+        next false if basename == ".homebrew_gem_groups"
+        next true unless child.directory?
+
+        [
+          "#{Version.new(portable_ruby_latest_version).major_minor}.0",
+          RbConfig::CONFIG["ruby_version"],
+        ].uniq.exclude?(basename)
       end
 
-      return if dry_run?
+      bundler_paths.each do |bundler_path|
+        if dry_run?
+          puts Utils.popen_read("git", "-C", HOMEBREW_REPOSITORY, "clean", "-nx", bundler_path).chomp
+        else
+          puts Utils.popen_read("git", "-C", HOMEBREW_REPOSITORY, "clean", "-ffqx", bundler_path).chomp
+        end
+      end
 
-      FileUtils.rm_rf portable_rubies_to_remove
+      portable_rubies_to_remove.each do |portable_ruby|
+        cleanup_path(portable_ruby) { FileUtils.rm_r(portable_ruby) }
+      end
+    end
+
+    def use_system_ruby?
+      false
     end
 
     def cleanup_bootsnap
       bootsnap = cache/"bootsnap"
-      return unless bootsnap.exist?
+      return unless bootsnap.directory?
 
-      if dry_run?
-        puts "Would remove: #{bootsnap} (#{bootsnap.abv})"
-      else
-        FileUtils.rm_rf bootsnap
+      bootsnap.each_child do |subdir|
+        cleanup_path(subdir) { FileUtils.rm_r(subdir) } if subdir.basename.to_s != Homebrew.bootsnap_key
       end
     end
 
@@ -463,7 +555,7 @@ def cleanup_cache_db(rack = nil)
     end
 
     def rm_ds_store(dirs = nil)
-      dirs ||= Keg::MUST_EXIST_DIRECTORIES + [
+      dirs ||= Keg.must_exist_directories + [
         HOMEBREW_PREFIX/"Caskroom",
       ]
       dirs.select(&:directory?)
@@ -476,12 +568,62 @@ def rm_ds_store(dirs = nil)
           end
     end
 
+    def cleanup_python_site_packages
+      pyc_files = Hash.new { |h, k| h[k] = [] }
+      seen_non_pyc_file = Hash.new { |h, k| h[k] = false }
+      unused_pyc_files = []
+
+      HOMEBREW_PREFIX.glob("lib/python*/site-packages").each do |site_packages|
+        site_packages.each_child do |child|
+          next unless child.directory?
+          # TODO: Work out a sensible way to clean up `pip`'s, `setuptools`' and `wheel`'s
+          #       `{dist,site}-info` directories. Alternatively, consider always removing
+          #       all `-info` directories, because we may not be making use of them.
+          next if child.basename.to_s.end_with?("-info")
+
+          # Clean up old *.pyc files in the top-level __pycache__.
+          if child.basename.to_s == "__pycache__"
+            child.find do |path|
+              next if path.extname != ".pyc"
+              next unless self.class.prune?(path, days)
+
+              unused_pyc_files << path
+            end
+
+            next
+          end
+
+          # Look for directories that contain only *.pyc files.
+          child.find do |path|
+            next if path.directory?
+
+            if path.extname == ".pyc"
+              pyc_files[child] << path
+            else
+              seen_non_pyc_file[child] = true
+              break
+            end
+          end
+        end
+      end
+
+      unused_pyc_files += pyc_files.reject { |k,| seen_non_pyc_file[k] }
+                                   .values
+                                   .flatten
+      return if unused_pyc_files.blank?
+
+      unused_pyc_files.each do |pyc|
+        cleanup_path(pyc) { pyc.unlink }
+      end
+    end
+
     def prune_prefix_symlinks_and_directories
       ObserverPathnameExtension.reset_counts!
 
       dirs = []
+      children_count = {}
 
-      Keg::MUST_EXIST_SUBDIRECTORIES.each do |dir|
+      Keg.must_exist_subdirectories.each do |dir|
         next unless dir.directory?
 
         dir.find do |path|
@@ -492,21 +634,38 @@ def prune_prefix_symlinks_and_directories
 
               if dry_run?
                 puts "Would remove (broken link): #{path}"
+                children_count[path.dirname] -= 1 if children_count.key?(path.dirname)
               else
                 path.unlink
               end
             end
-          elsif path.directory? && Keg::MUST_EXIST_SUBDIRECTORIES.exclude?(path)
+          elsif path.directory? && Keg.must_exist_subdirectories.exclude?(path)
             dirs << path
+            children_count[path] = path.children.length if dry_run?
           end
         end
       end
 
       dirs.reverse_each do |d|
-        if dry_run? && d.children.empty?
-          puts "Would remove (empty directory): #{d}"
-        else
+        if !dry_run?
           d.rmdir_if_possible
+        elsif children_count[d].zero?
+          puts "Would remove (empty directory): #{d}"
+          children_count[d.dirname] -= 1 if children_count.key?(d.dirname)
+        end
+      end
+
+      require "cask/caskroom"
+      if Cask::Caskroom.path.directory?
+        Cask::Caskroom.path.each_child do |path|
+          path.extend(ObserverPathnameExtension)
+          next if !path.symlink? || path.resolved_path_exists?
+
+          if dry_run?
+            puts "Would remove (broken link): #{path}"
+          else
+            path.unlink
+          end
         end
       end
 
@@ -519,5 +678,43 @@ def prune_prefix_symlinks_and_directories
       print "and #{d} directories " if d.positive?
       puts "from #{HOMEBREW_PREFIX}"
     end
+
+    def self.autoremove(dry_run: false)
+      require "utils/autoremove"
+      require "cask/caskroom"
+
+      # If this runs after install, uninstall, reinstall or upgrade,
+      # the cache of installed formulae may no longer be valid.
+      Formula.clear_cache unless dry_run
+
+      formulae = Formula.installed
+      # Remove formulae listed in HOMEBREW_NO_CLEANUP_FORMULAE and their dependencies.
+      if Homebrew::EnvConfig.no_cleanup_formulae.present?
+        formulae -= formulae.select { skip_clean_formula?(_1) }
+                            .flat_map { |f| [f, *f.runtime_formula_dependencies] }
+      end
+      casks = Cask::Caskroom.casks
+
+      removable_formulae = Utils::Autoremove.removable_formulae(formulae, casks)
+
+      return if removable_formulae.blank?
+
+      formulae_names = removable_formulae.map(&:full_name).sort
+
+      verb = dry_run ? "Would autoremove" : "Autoremoving"
+      oh1 "#{verb} #{formulae_names.count} unneeded #{Utils.pluralize("formula", formulae_names.count, plural: "e")}:"
+      puts formulae_names.join("\n")
+      return if dry_run
+
+      require "uninstall"
+
+      kegs_by_rack = removable_formulae.filter_map(&:any_installed_keg).group_by(&:rack)
+      Uninstall.uninstall_kegs(kegs_by_rack)
+
+      # The installed formula cache will be invalid after uninstalling.
+      Formula.clear_cache
+    end
   end
 end
+
+require "extend/os/cleanup"
diff --git a/Library/Homebrew/cli/args.rb b/Library/Homebrew/cli/args.rb
index 49a99405414f7..462d4eef1e5ef 100644
--- a/Library/Homebrew/cli/args.rb
+++ b/Library/Homebrew/cli/args.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "ostruct"
@@ -6,23 +6,27 @@
 module Homebrew
   module CLI
     class Args < OpenStruct
-      extend T::Sig
-
+      # Represents a processed option. The array elements are:
+      #   0: short option name (e.g. "-d")
+      #   1: long option name (e.g. "--debug")
+      #   2: option description (e.g. "Print debugging information")
+      #   3: whether the option is hidden
+      OptionsType = T.type_alias { T::Array[[String, T.nilable(String), String, T::Boolean]] }
+      sig { returns(T::Array[String]) }
       attr_reader :options_only, :flags_only
 
-      # undefine tap to allow --tap argument
-      undef tap
-
       sig { void }
       def initialize
         require "cli/named_args"
 
-        super()
+        super
 
-        @processed_options = []
-        @options_only = []
-        @flags_only = []
-        @cask_options = false
+        @cli_args = T.let(nil, T.nilable(T::Array[String]))
+        @processed_options = T.let([], OptionsType)
+        @options_only = T.let([], T::Array[String])
+        @flags_only = T.let([], T::Array[String])
+        @cask_options = T.let(false, T::Boolean)
+        @table = T.let({}, T::Hash[Symbol, T.untyped])
 
         # Can set these because they will be overwritten by freeze_named_args!
         # (whereas other values below will only be overwritten if passed).
@@ -30,21 +34,27 @@ def initialize
         self[:remaining] = []
       end
 
+      sig { params(remaining_args: T::Array[T.any(T::Array[String], String)]).void }
       def freeze_remaining_args!(remaining_args)
         self[:remaining] = remaining_args.freeze
       end
 
-      def freeze_named_args!(named_args, cask_options:)
+      sig { params(named_args: T::Array[String], cask_options: T::Boolean, without_api: T::Boolean).void }
+      def freeze_named_args!(named_args, cask_options:, without_api:)
+        options = {}
+        options[:force_bottle] = true if self[:force_bottle?]
+        options[:override_spec] = :head if self[:HEAD?]
+        options[:flags] = flags_only unless flags_only.empty?
         self[:named] = NamedArgs.new(
           *named_args.freeze,
-          override_spec: spec(nil),
-          force_bottle:  self[:force_bottle?],
-          flags:         flags_only,
-          cask_options:  cask_options,
-          parent:        self,
+          parent:       self,
+          cask_options:,
+          without_api:,
+          **options,
         )
       end
 
+      sig { params(processed_options: OptionsType).void }
       def freeze_processed_options!(processed_options)
         # Reset cache values reliant on processed_options
         @cli_args = nil
@@ -52,8 +62,8 @@ def freeze_processed_options!(processed_options)
         @processed_options += processed_options
         @processed_options.freeze
 
-        @options_only = cli_args.select { |a| a.start_with?("-") }.freeze
-        @flags_only = cli_args.select { |a| a.start_with?("--") }.freeze
+        @options_only = cli_args.select { _1.start_with?("-") }.freeze
+        @flags_only = cli_args.select { _1.start_with?("--") }.freeze
       end
 
       sig { returns(NamedArgs) }
@@ -62,10 +72,10 @@ def named
         self[:named]
       end
 
-      def no_named?
-        named.blank?
-      end
+      sig { returns(T::Boolean) }
+      def no_named? = named.blank?
 
+      sig { returns(T::Array[String]) }
       def build_from_source_formulae
         if build_from_source? || self[:HEAD?] || self[:build_bottle?]
           named.to_formulae.map(&:full_name)
@@ -74,6 +84,7 @@ def build_from_source_formulae
         end
       end
 
+      sig { returns(T::Array[String]) }
       def include_test_formulae
         if include_test?
           named.to_formulae.map(&:full_name)
@@ -82,6 +93,7 @@ def include_test_formulae
         end
       end
 
+      sig { params(name: String).returns(T.nilable(String)) }
       def value(name)
         arg_prefix = "--#{name}="
         flag_with_value = flags_only.find { |arg| arg.start_with?(arg_prefix) }
@@ -95,25 +107,66 @@ def context
         Context::ContextStruct.new(debug: debug?, quiet: quiet?, verbose: verbose?)
       end
 
+      sig { returns(T.nilable(Symbol)) }
       def only_formula_or_cask
-        return :formula if formula? && !cask?
-        return :cask if cask? && !formula?
+        if formula? && !cask?
+          :formula
+        elsif cask? && !formula?
+          :cask
+        end
+      end
+
+      sig { returns(T::Array[[Symbol, Symbol]]) }
+      def os_arch_combinations
+        skip_invalid_combinations = false
+
+        oses = case (os_sym = os&.to_sym)
+        when nil
+          [SimulateSystem.current_os]
+        when :all
+          skip_invalid_combinations = true
+
+          OnSystem::ALL_OS_OPTIONS
+        else
+          [os_sym]
+        end
+
+        arches = case (arch_sym = arch&.to_sym)
+        when nil
+          [SimulateSystem.current_arch]
+        when :all
+          skip_invalid_combinations = true
+          OnSystem::ARCH_OPTIONS
+        else
+          [arch_sym]
+        end
+
+        oses.product(arches).select do |os, arch|
+          if skip_invalid_combinations
+            bottle_tag = Utils::Bottles::Tag.new(system: os, arch:)
+            bottle_tag.valid_combination?
+          else
+            true
+          end
+        end
       end
 
       private
 
+      sig { params(option: String).returns(String) }
       def option_to_name(option)
         option.sub(/\A--?/, "")
               .tr("-", "_")
       end
 
+      sig { returns(T::Array[String]) }
       def cli_args
         return @cli_args if @cli_args
 
         @cli_args = []
         @processed_options.each do |short, long|
           option = long || short
-          switch = "#{option_to_name(option)}?".to_sym
+          switch = :"#{option_to_name(option)}?"
           flag = option_to_name(option).to_sym
           if @table[switch] == true || @table[flag] == true
             @cli_args << option
@@ -126,18 +179,12 @@ def cli_args
         @cli_args.freeze
       end
 
-      def spec(default = :stable)
-        if self[:HEAD?]
-          :head
-        else
-          default
-        end
-      end
-
-      def respond_to_missing?(*)
-        !frozen?
+      sig { params(method_name: Symbol, _include_private: T::Boolean).returns(T::Boolean) }
+      def respond_to_missing?(method_name, _include_private = false)
+        @table.key?(method_name)
       end
 
+      sig { params(method_name: Symbol, args: T.untyped).returns(T.untyped) }
       def method_missing(method_name, *args)
         return_value = super
 
diff --git a/Library/Homebrew/cli/args.rbi b/Library/Homebrew/cli/args.rbi
index 32b1cd8e6e041..11451fdb558e7 100644
--- a/Library/Homebrew/cli/args.rbi
+++ b/Library/Homebrew/cli/args.rbi
@@ -1,319 +1,43 @@
 # typed: strict
 
-module Homebrew
-  module CLI
-    class Args < OpenStruct
-      sig { returns(T::Boolean) }
-      def remove_bottle_block?; end
+# This file contains global args as defined in `Homebrew::CLI::Parser.global_options`
+# `Command`-specific args are defined in the commands themselves, with type signatures
+# generated by the `Tapioca::Compilers::Args` compiler.
 
-      sig { returns(T::Boolean) }
-      def strict?; end
+class Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def debug?; end
 
-      sig { returns(T::Boolean) }
-      def HEAD?; end
+  sig { returns(T::Boolean) }
+  def help?; end
 
-      sig { returns(T::Boolean) }
-      def include_test?; end
+  sig { returns(T::Boolean) }
+  def quiet?; end
 
-      sig { returns(T::Boolean) }
-      def build_bottle?; end
+  sig { returns(T::Array[String]) }
+  def remaining; end
 
-      sig { returns(T::Boolean) }
-      def build_universal?; end
+  sig { returns(T::Boolean) }
+  def verbose?; end
 
-      sig { returns(T::Boolean) }
-      def build_from_source?; end
+  # FIXME: The methods below are not defined by Args, but are valid because Args inherits from OpenStruct
+  # We should instead be using type guards to check if the method is defined on the object before calling it
 
-      sig { returns(T::Boolean) }
-      def force_bottle?; end
+  sig { returns(T.nilable(String)) }
+  def arch; end
 
-      sig { returns(T::Boolean) }
-      def newer_only?; end
+  sig { returns(T::Boolean) }
+  def build_from_source?; end
 
-      sig { returns(T::Boolean) }
-      def full_name?; end
+  sig { returns(T::Boolean) }
+  def cask?; end
 
-      sig { returns(T::Boolean) }
-      def json?; end
+  sig { returns(T::Boolean) }
+  def formula?; end
 
-      sig { returns(T::Boolean) }
-      def debug?; end
+  sig { returns(T::Boolean) }
+  def include_test?; end
 
-      sig { returns(T::Boolean) }
-      def quiet?; end
-
-      sig { returns(T::Boolean) }
-      def verbose?; end
-
-      sig { returns(T::Boolean) }
-      def fetch_HEAD?; end
-
-      sig { returns(T::Boolean) }
-      def cask?; end
-
-      sig { returns(T::Boolean) }
-      def dry_run?; end
-
-      sig { returns(T::Boolean) }
-      def skip_cask_deps?; end
-
-      sig { returns(T::Boolean) }
-      def greedy?; end
-
-      sig { returns(T::Boolean) }
-      def force?; end
-
-      sig { returns(T::Boolean) }
-      def ignore_pinned?; end
-
-      sig { returns(T::Boolean) }
-      def display_times?; end
-
-      sig { returns(T::Boolean) }
-      def formula?; end
-
-      sig { returns(T::Boolean) }
-      def zap?; end
-
-      sig { returns(T::Boolean) }
-      def ignore_dependencies?; end
-
-      sig { returns(T::Boolean) }
-      def aliases?; end
-
-      sig { returns(T::Boolean) }
-      def fix?; end
-
-      sig { returns(T::Boolean) }
-      def keep_tmp?; end
-
-      sig { returns(T::Boolean) }
-      def overwrite?; end
-
-      sig { returns(T::Boolean) }
-      def silent?; end
-
-      sig { returns(T::Boolean) }
-      def repair?; end
-
-      sig { returns(T::Boolean) }
-      def prune_prefix?; end
-
-      sig { returns(T::Boolean) }
-      def upload?; end
-
-      sig { returns(T::Boolean) }
-      def linux?; end
-
-      sig { returns(T::Boolean) }
-      def linux_self_hosted?; end
-
-      sig { returns(T::Boolean) }
-      def linux_wheezy?; end
-
-      sig { returns(T::Boolean) }
-      def total?; end
-
-      sig { returns(T::Boolean) }
-      def dependents?; end
-
-      sig { returns(T::Boolean) }
-      def installed?; end
-
-      sig { returns(T::Boolean) }
-      def installed_on_request?; end
-
-      sig { returns(T::Boolean) }
-      def installed_as_dependency?; end
-
-      sig { returns(T::Boolean) }
-      def all?; end
-
-      sig { returns(T::Boolean) }
-      def full?; end
-
-      sig { returns(T::Boolean) }
-      def list_pinned?; end
-
-      sig { returns(T::Boolean) }
-      def display_cop_names?; end
-
-      sig { returns(T::Boolean) }
-      def syntax?; end
-
-      sig { returns(T::Boolean) }
-      def ignore_non_pypi_packages?; end
-
-      sig { returns(T::Boolean) }
-      def test?; end
-
-      sig { returns(T::Boolean) }
-      def reverse?; end
-
-      sig { returns(T::Boolean) }
-      def print_only?; end
-
-      sig { returns(T::Boolean) }
-      def markdown?; end
-
-      sig { returns(T::Boolean) }
-      def reset_cache?; end
-
-      sig { returns(T::Boolean) }
-      def major?; end
-
-      sig { returns(T::Boolean) }
-      def minor?; end
-
-      sig { returns(T.nilable(String)) }
-      def bottle_tag; end
-
-      sig { returns(T.nilable(String)) }
-      def tag; end
-
-      sig { returns(T.nilable(String)) }
-      def tap; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def macos; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def hide; end
-
-      sig { returns(T.nilable(String)) }
-      def version; end
-
-      sig { returns(T.nilable(String)) }
-      def name; end
-
-      sig { returns(T::Boolean) }
-      def no_publish?; end
-
-      sig { returns(T::Boolean) }
-      def shallow?; end
-
-      sig { returns(T::Boolean) }
-      def fail_if_not_changed?; end
-
-      sig { returns(T.nilable(String)) }
-      def limit; end
-
-      sig { returns(T.nilable(String)) }
-      def start_with; end
-
-      sig { returns(T.nilable(String)) }
-      def message; end
-
-      sig { returns(T.nilable(String)) }
-      def timeout; end
-
-      sig { returns(T.nilable(String)) }
-      def issue; end
-
-      sig { returns(T.nilable(String)) }
-      def workflow; end
-
-      sig { returns(T.nilable(String)) }
-      def package_name; end
-
-      sig { returns(T.nilable(String)) }
-      def prune; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def only_cops; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def except_cops; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def only; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def except; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def mirror; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def without_labels; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def workflows; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def ignore_missing_artifacts; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def language; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def extra_packages; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def exclude_packages; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def update; end
-
-      sig { returns(T::Boolean) }
-      def s?; end
-
-      sig { returns(T.nilable(String)) }
-      def appdir; end
-
-      sig { returns(T.nilable(String)) }
-      def fontdir; end
-
-      sig { returns(T.nilable(String)) }
-      def colorpickerdir; end
-
-      sig { returns(T.nilable(String)) }
-      def prefpanedir; end
-
-      sig { returns(T.nilable(String)) }
-      def qlplugindir; end
-
-      sig { returns(T.nilable(String)) }
-      def dictionarydir; end
-
-      sig { returns(T.nilable(String)) }
-      def servicedir; end
-
-      sig { returns(T.nilable(String)) }
-      def input_methoddir; end
-
-      sig { returns(T.nilable(String)) }
-      def mdimporterdir; end
-
-      sig { returns(T.nilable(String)) }
-      def internet_plugindir; end
-
-      sig { returns(T.nilable(String)) }
-      def audio_unit_plugindir; end
-
-      sig { returns(T.nilable(String)) }
-      def vst_plugindir; end
-
-      sig { returns(T.nilable(String)) }
-      def vst3_plugindir; end
-
-      sig { returns(T.nilable(String)) }
-      def screen_saverdir; end
-
-      sig { returns(T.nilable(T::Array[String])) }
-      def groups; end
-
-      sig { returns(T::Boolean) }
-      def write_only?; end
-
-      sig { returns(T::Boolean) }
-      def custom_remote?; end
-
-      sig { returns(T::Boolean) }
-      def print_path?; end
-
-      sig { returns(T.nilable(T::Boolean)) }
-      def force_auto_update?; end
-    end
-  end
+  sig { returns(T.nilable(String)) }
+  def os; end
 end
diff --git a/Library/Homebrew/cli/named_args.rb b/Library/Homebrew/cli/named_args.rb
index e7337d2cf845c..7d46b75450182 100644
--- a/Library/Homebrew/cli/named_args.rb
+++ b/Library/Homebrew/cli/named_args.rb
@@ -1,30 +1,39 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "delegate"
-require "api"
 require "cli/args"
 
 module Homebrew
   module CLI
     # Helper class for loading formulae/casks from named arguments.
-    #
-    # @api private
     class NamedArgs < Array
-      extend T::Sig
-
-      def initialize(*args, parent: Args.new, override_spec: nil, force_bottle: false, flags: [], cask_options: false)
-        require "cask/cask"
-        require "cask/cask_loader"
-        require "formulary"
-        require "keg"
-        require "missing_formula"
-
+      sig {
+        params(
+          args:          String,
+          parent:        Args,
+          override_spec: Symbol,
+          force_bottle:  T::Boolean,
+          flags:         T::Array[String],
+          cask_options:  T::Boolean,
+          without_api:   T::Boolean,
+        ).void
+      }
+      def initialize(
+        *args,
+        parent: Args.new,
+        override_spec: T.unsafe(nil),
+        force_bottle: T.unsafe(nil),
+        flags: T.unsafe(nil),
+        cask_options: false,
+        without_api: false
+      )
         @args = args
         @override_spec = override_spec
         @force_bottle = force_bottle
         @flags = flags
         @cask_options = cask_options
+        @without_api = without_api
         @parent = parent
 
         super(@args)
@@ -49,12 +58,20 @@ def to_formulae
           ignore_unavailable: T.nilable(T::Boolean),
           method:             T.nilable(Symbol),
           uniq:               T::Boolean,
+          warn:               T::Boolean,
         ).returns(T::Array[T.any(Formula, Keg, Cask::Cask)])
       }
-      def to_formulae_and_casks(only: parent&.only_formula_or_cask, ignore_unavailable: nil, method: nil, uniq: true)
+      def to_formulae_and_casks(
+        only: parent&.only_formula_or_cask,
+        ignore_unavailable: nil,
+        method: T.unsafe(nil),
+        uniq: true,
+        warn: T.unsafe(nil)
+      )
         @to_formulae_and_casks ||= {}
         @to_formulae_and_casks[only] ||= downcased_unique_named.flat_map do |name|
-          load_formula_or_cask(name, only: only, method: method)
+          options = { warn: }.compact
+          load_formula_or_cask(name, only:, method:, **options)
         rescue FormulaUnreadableError, FormulaClassUnavailableError,
                TapFormulaUnreadableError, TapFormulaClassUnavailableError,
                Cask::CaskUnreadableError
@@ -74,160 +91,243 @@ def to_formulae_and_casks(only: parent&.only_formula_or_cask, ignore_unavailable
 
       def to_formulae_to_casks(only: parent&.only_formula_or_cask, method: nil)
         @to_formulae_to_casks ||= {}
-        @to_formulae_to_casks[[method, only]] = to_formulae_and_casks(only: only, method: method)
+        @to_formulae_to_casks[[method, only]] = to_formulae_and_casks(only:, method:)
                                                 .partition { |o| o.is_a?(Formula) || o.is_a?(Keg) }
                                                 .map(&:freeze).freeze
       end
 
+      # Returns formulae and casks after validating that a tap is present for each of them.
+      def to_formulae_and_casks_with_taps
+        formulae_and_casks_with_taps, formulae_and_casks_without_taps =
+          to_formulae_and_casks.partition do |formula_or_cask|
+            T.cast(formula_or_cask, T.any(Formula, Cask::Cask)).tap&.installed?
+          end
+
+        return formulae_and_casks_with_taps if formulae_and_casks_without_taps.blank?
+
+        types = []
+        types << "formulae" if formulae_and_casks_without_taps.any?(Formula)
+        types << "casks" if formulae_and_casks_without_taps.any?(Cask::Cask)
+
+        odie <<~ERROR
+          These #{types.join(" and ")} are not in any locally installed taps!
+
+            #{formulae_and_casks_without_taps.sort_by(&:to_s).join("\n  ")}
+
+          You may need to run `brew tap` to install additional taps.
+        ERROR
+      end
+
       def to_formulae_and_casks_and_unavailable(only: parent&.only_formula_or_cask, method: nil)
         @to_formulae_casks_unknowns ||= {}
         @to_formulae_casks_unknowns[method] = downcased_unique_named.map do |name|
-          load_formula_or_cask(name, only: only, method: method)
+          load_formula_or_cask(name, only:, method:)
         rescue FormulaOrCaskUnavailableError => e
           e
         end.uniq.freeze
       end
 
-      def load_formula_or_cask(name, only: nil, method: nil)
-        unreadable_error = nil
-
-        if only != :cask
-          begin
-            formula = case method
-            when nil, :factory
-              Formulary.factory(name, *spec, force_bottle: @force_bottle, flags: @flags)
-            when :resolve
-              resolve_formula(name)
-            when :latest_kegs
-              resolve_latest_keg(name)
-            when :default_kegs
-              resolve_default_keg(name)
-            when :kegs
-              _, kegs = resolve_kegs(name)
-              kegs
-            else
-              raise
+      def load_formula_or_cask(name, only: nil, method: nil, warn: nil)
+        Homebrew.with_no_api_env_if_needed(@without_api) do
+          unreadable_error = nil
+
+          formula_or_kegs = if only != :cask
+            begin
+              case method
+              when nil, :factory
+                options = { warn:, force_bottle: @force_bottle, flags: @flags }.compact
+                Formulary.factory(name, *@override_spec, **options)
+              when :resolve
+                resolve_formula(name)
+              when :latest_kegs
+                resolve_latest_keg(name)
+              when :default_kegs
+                resolve_default_keg(name)
+              when :kegs
+                _, kegs = resolve_kegs(name)
+                kegs
+              else
+                raise
+              end
+            rescue FormulaUnreadableError, FormulaClassUnavailableError,
+                   TapFormulaUnreadableError, TapFormulaClassUnavailableError,
+                   FormulaSpecificationError => e
+              # Need to rescue before `FormulaUnavailableError` (superclass of this)
+              # The formula was found, but there's a problem with its implementation
+              unreadable_error ||= e
+              nil
+            rescue NoSuchKegError, FormulaUnavailableError => e
+              raise e if only == :formula
+
+              nil
             end
-
-            warn_if_cask_conflicts(name, "formula") unless only == :formula
-            return formula
-          rescue FormulaUnreadableError, FormulaClassUnavailableError,
-                 TapFormulaUnreadableError, TapFormulaClassUnavailableError => e
-            # Need to rescue before `FormulaUnavailableError` (superclass of this)
-            # The formula was found, but there's a problem with its implementation
-            unreadable_error ||= e
-          rescue NoSuchKegError, FormulaUnavailableError => e
-            raise e if only == :formula
           end
-        end
-
-        if only != :formula
-          want_keg_like_cask = [:latest_kegs, :default_kegs, :kegs].include?(method)
 
-          begin
-            config = Cask::Config.from_args(@parent) if @cask_options
-            cask = Cask::CaskLoader.load(name, config: config)
+          if only == :formula
+            return formula_or_kegs if formula_or_kegs
+          elsif formula_or_kegs && (!formula_or_kegs.is_a?(Formula) || formula_or_kegs.tap&.core_tap?)
+            warn_if_cask_conflicts(name, "formula")
+            return formula_or_kegs
+          else
+            want_keg_like_cask = [:latest_kegs, :default_kegs, :kegs].include?(method)
+
+            cask = begin
+              config = Cask::Config.from_args(@parent) if @cask_options
+              options = { warn: }.compact
+              candidate_cask = Cask::CaskLoader.load(name, config:, **options)
+
+              if unreadable_error.present?
+                onoe <<~EOS
+                  Failed to load formula: #{name}
+                  #{unreadable_error}
+                EOS
+                opoo "Treating #{name} as a cask."
+              end
 
-            if unreadable_error.present?
-              onoe <<~EOS
-                Failed to load formula: #{name}
-                #{unreadable_error}
-              EOS
-              opoo "Treating #{name} as a cask."
-            end
+              # If we're trying to get a keg-like Cask, do our best to use the same cask
+              # file that was used for installation, if possible.
+              if want_keg_like_cask &&
+                 (installed_caskfile = candidate_cask.installed_caskfile) &&
+                 installed_caskfile.exist?
+                cask = Cask::CaskLoader.load_from_installed_caskfile(installed_caskfile)
+
+                requested_tap, requested_token = Tap.with_cask_token(name)
+                if requested_tap && requested_token
+                  installed_cask_tap = cask.tab.tap
+
+                  if installed_cask_tap && installed_cask_tap != requested_tap
+                    raise Cask::TapCaskUnavailableError.new(requested_tap, requested_token)
+                  end
+                end
+
+                cask
+              else
+                candidate_cask
+              end
+            rescue Cask::CaskUnreadableError, Cask::CaskInvalidError => e
+              # If we're trying to get a keg-like Cask, do our best to handle it
+              # not being readable and return something that can be used.
+              if want_keg_like_cask
+                cask_version = Cask::Cask.new(name, config:).installed_version
+                Cask::Cask.new(name, config:) do
+                  version cask_version if cask_version
+                end
+              else
+                # Need to rescue before `CaskUnavailableError` (superclass of this)
+                # The cask was found, but there's a problem with its implementation
+                unreadable_error ||= e
+                nil
+              end
+            rescue Cask::CaskUnavailableError => e
+              raise e if only == :cask
 
-            # If we're trying to get a keg-like Cask, do our best to use the same cask
-            # file that was used for installation, if possible.
-            if want_keg_like_cask && (installed_caskfile = cask.installed_caskfile) && installed_caskfile.exist?
-              cask = Cask::CaskLoader.load(installed_caskfile)
+              nil
             end
 
-            return cask
-          rescue Cask::CaskUnreadableError, Cask::CaskInvalidError => e
-            # If we're trying to get a keg-like Cask, do our best to handle it
-            # not being readable and return something that can be used.
-            if want_keg_like_cask
-              cask_version = Cask::Cask.new(name, config: config).versions.first
-              cask = Cask::Cask.new(name, config: config) do
-                version cask_version if cask_version
+            # Prioritise formulae unless it's a core tap cask (we already prioritised core tap formulae above)
+            if formula_or_kegs && !cask&.tap&.core_cask_tap?
+              if cask || unreadable_error
+                onoe <<~EOS if unreadable_error
+                  Failed to load cask: #{name}
+                  #{unreadable_error}
+                EOS
+                opoo package_conflicts_message(name, "formula", cask) unless Context.current.quiet?
+              end
+              return formula_or_kegs
+            elsif cask
+              if formula_or_kegs && !Context.current.quiet?
+                opoo package_conflicts_message(name, "cask", formula_or_kegs)
               end
               return cask
             end
-
-            # Need to rescue before `CaskUnavailableError` (superclass of this)
-            # The cask was found, but there's a problem with its implementation
-            unreadable_error ||= e
-          rescue Cask::CaskUnavailableError => e
-            raise e if only == :cask
           end
-        end
 
-        raise unreadable_error if unreadable_error.present?
+          raise unreadable_error if unreadable_error.present?
 
-        user, repo, short_name = name.downcase.split("/", 3)
-        if repo.present? && short_name.present?
-          tap = Tap.fetch(user, repo)
-          raise TapFormulaOrCaskUnavailableError.new(tap, short_name)
-        end
+          user, repo, short_name = name.downcase.split("/", 3)
+          if repo.present? && short_name.present?
+            tap = Tap.fetch(user, repo)
+            raise TapFormulaOrCaskUnavailableError.new(tap, short_name)
+          end
 
-        raise NoSuchKegError, name if resolve_formula(name)
+          raise NoSuchKegError, name if resolve_formula(name)
 
-        raise FormulaOrCaskUnavailableError, name
+          raise FormulaOrCaskUnavailableError, name
+        end
       end
       private :load_formula_or_cask
 
       def resolve_formula(name)
-        Formulary.resolve(name, spec: spec, force_bottle: @force_bottle, flags: @flags)
+        Formulary.resolve(name, **{ spec: @override_spec, force_bottle: @force_bottle, flags: @flags }.compact)
       end
       private :resolve_formula
 
       sig { params(uniq: T::Boolean).returns(T::Array[Formula]) }
       def to_resolved_formulae(uniq: true)
-        @to_resolved_formulae ||= to_formulae_and_casks(only: :formula, method: :resolve, uniq: uniq)
+        @to_resolved_formulae ||= to_formulae_and_casks(only: :formula, method: :resolve, uniq:)
                                   .freeze
       end
 
       def to_resolved_formulae_to_casks(only: parent&.only_formula_or_cask)
-        to_formulae_to_casks(only: only, method: :resolve)
+        to_formulae_to_casks(only:, method: :resolve)
       end
 
+      LOCAL_PATH_REGEX = %r{^/|[.]|/$}
+      TAP_NAME_REGEX = %r{^[^./]+/[^./]+$}
+      private_constant :LOCAL_PATH_REGEX, :TAP_NAME_REGEX
+
       # Keep existing paths and try to convert others to tap, formula or cask paths.
       # If a cask and formula with the same name exist, includes both their paths
       # unless `only` is specified.
       sig { params(only: T.nilable(Symbol), recurse_tap: T::Boolean).returns(T::Array[Pathname]) }
       def to_paths(only: parent&.only_formula_or_cask, recurse_tap: false)
         @to_paths ||= {}
-        @to_paths[only] ||= downcased_unique_named.flat_map do |name|
-          if File.exist?(name)
-            Pathname(name)
-          elsif name.count("/") == 1 && !name.start_with?("./", "/")
-            tap = Tap.fetch(name)
-
-            if recurse_tap
-              next tap.formula_files if only == :formula
-              next tap.cask_files if only == :cask
-            end
+        @to_paths[only] ||= Homebrew.with_no_api_env_if_needed(@without_api) do
+          downcased_unique_named.flat_map do |name|
+            path = Pathname(name).expand_path
+            if only.nil? && name.match?(LOCAL_PATH_REGEX) && path.exist?
+              path
+            elsif name.match?(TAP_NAME_REGEX)
+              tap = Tap.fetch(name)
+
+              if recurse_tap
+                next tap.formula_files if only == :formula
+                next tap.cask_files if only == :cask
+              end
 
-            tap.path
-          else
-            next Formulary.path(name) if only == :formula
-            next Cask::CaskLoader.path(name) if only == :cask
+              tap.path
+            else
+              next Formulary.path(name) if only == :formula
+              next Cask::CaskLoader.path(name) if only == :cask
 
-            formula_path = Formulary.path(name)
-            cask_path = Cask::CaskLoader.path(name)
+              formula_path = Formulary.path(name)
+              cask_path = Cask::CaskLoader.path(name)
 
-            paths = []
+              paths = []
 
-            paths << formula_path if formula_path.exist?
-            paths << cask_path if cask_path.exist?
+              if formula_path.exist? ||
+                 (!Homebrew::EnvConfig.no_install_from_api? &&
+                 !CoreTap.instance.installed? &&
+                 Homebrew::API::Formula.all_formulae.key?(path.basename.to_s))
+                paths << formula_path
+              end
+              if cask_path.exist? ||
+                 (!Homebrew::EnvConfig.no_install_from_api? &&
+                 !CoreCaskTap.instance.installed? &&
+                 Homebrew::API::Cask.all_casks.key?(path.basename.to_s))
+                paths << cask_path
+              end
 
-            paths.empty? ? Pathname(name) : paths
-          end
-        end.uniq.freeze
+              paths.empty? ? path : paths
+            end
+          end.uniq.freeze
+        end
       end
 
       sig { returns(T::Array[Keg]) }
       def to_default_kegs
+        require "missing_formula"
+
         @to_default_kegs ||= begin
           to_formulae_and_casks(only: :formula, method: :default_kegs).freeze
         rescue NoSuchKegError => e
@@ -240,6 +340,8 @@ def to_default_kegs
 
       sig { returns(T::Array[Keg]) }
       def to_latest_kegs
+        require "missing_formula"
+
         @to_latest_kegs ||= begin
           to_formulae_and_casks(only: :formula, method: :latest_kegs).freeze
         rescue NoSuchKegError => e
@@ -252,6 +354,8 @@ def to_latest_kegs
 
       sig { returns(T::Array[Keg]) }
       def to_kegs
+        require "missing_formula"
+
         @to_kegs ||= begin
           to_formulae_and_casks(only: :formula, method: :kegs).freeze
         rescue NoSuchKegError => e
@@ -270,7 +374,7 @@ def to_kegs_to_casks(only: parent&.only_formula_or_cask, ignore_unavailable: nil
         method = all_kegs ? :kegs : :default_kegs
         @to_kegs_to_casks ||= {}
         @to_kegs_to_casks[method] ||=
-          to_formulae_and_casks(only: only, ignore_unavailable: ignore_unavailable, method: method)
+          to_formulae_and_casks(only:, ignore_unavailable:, method:)
           .partition { |o| o.is_a?(Keg) }
           .map(&:freeze).freeze
       end
@@ -306,11 +410,6 @@ def downcased_unique_named
         end.uniq
       end
 
-      def spec
-        @override_spec
-      end
-      private :spec
-
       def resolve_kegs(name)
         raise UsageError if name.blank?
 
@@ -319,6 +418,16 @@ def resolve_kegs(name)
         rack = Formulary.to_rack(name.downcase)
 
         kegs = rack.directory? ? rack.subdirs.map { |d| Keg.new(d) } : []
+
+        requested_tap, requested_formula = Tap.with_formula_name(name)
+        if requested_tap && requested_formula
+          kegs = kegs.select do |keg|
+            keg.tab.tap == requested_tap
+          end
+
+          raise NoSuchKegError.new(requested_formula, tap: requested_tap) if kegs.none?
+        end
+
         raise NoSuchKegError, name if kegs.none?
 
         [rack, kegs]
@@ -330,15 +439,15 @@ def resolve_latest_keg(name)
         # Return keg if it is the only installed keg
         return kegs if kegs.length == 1
 
-        stable_kegs = kegs.reject { |k| k.version.head? }
+        stable_kegs = kegs.reject { |keg| keg.version.head? }
 
         if stable_kegs.blank?
           return kegs.max_by do |keg|
-            [Tab.for_keg(keg).source_modified_time, keg.version.revision]
+            [keg.tab.source_modified_time, keg.version.revision]
           end
         end
 
-        stable_kegs.max_by(&:version)
+        stable_kegs.max_by(&:scheme_and_version)
       end
 
       def resolve_default_keg(name)
@@ -370,16 +479,34 @@ def resolve_default_keg(name)
           raise MultipleVersionsInstalledError, <<~EOS
             Multiple kegs installed to #{rack}
             However we don't know which one you refer to.
-            Please delete (with rm -rf!) all but one and then try again.
+            Please delete (with `rm -rf`!) all but one and then try again.
           EOS
         end
       end
 
-      def warn_if_cask_conflicts(ref, loaded_type)
+      def package_conflicts_message(ref, loaded_type, package)
         message = "Treating #{ref} as a #{loaded_type}."
-        begin
-          cask = Cask::CaskLoader.load ref
-          message += " For the cask, use #{cask.tap.name}/#{cask.token}" if cask.tap.present?
+        case package
+        when Formula, Keg, Array
+          message += " For the formula, "
+          if package.is_a?(Formula) && (tap = package.tap)
+            message += "use #{tap.name}/#{package.name} or "
+          end
+          message += "specify the `--formula` flag. To silence this message, use the `--cask` flag."
+        when Cask::Cask
+          message += " For the cask, "
+          if (tap = package.tap)
+            message += "use #{tap.name}/#{package.token} or "
+          end
+          message += "specify the `--cask` flag. To silence this message, use the `--formula` flag."
+        end
+        message.freeze
+      end
+
+      def warn_if_cask_conflicts(ref, loaded_type)
+        available = true
+        cask = begin
+          Cask::CaskLoader.load(ref, warn: false)
         rescue Cask::CaskUnreadableError => e
           # Need to rescue before `CaskUnavailableError` (superclass of this)
           # The cask was found, but there's a problem with its implementation
@@ -387,11 +514,16 @@ def warn_if_cask_conflicts(ref, loaded_type)
             Failed to load cask: #{ref}
             #{e}
           EOS
+          nil
         rescue Cask::CaskUnavailableError
           # No ref conflict with a cask, do nothing
-          return
+          available = false
+          nil
         end
-        opoo message.freeze
+        return unless available
+        return if Context.current.quiet?
+
+        opoo package_conflicts_message(ref, loaded_type, cask)
       end
     end
   end
diff --git a/Library/Homebrew/cli/parser.rb b/Library/Homebrew/cli/parser.rb
index 4fc804ad65f6d..3d9e6553e1ff6 100644
--- a/Library/Homebrew/cli/parser.rb
+++ b/Library/Homebrew/cli/parser.rb
@@ -1,42 +1,71 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "env_config"
 require "cask/config"
 require "cli/args"
+require "commands"
 require "optparse"
-require "set"
 require "utils/tty"
-
-COMMAND_DESC_WIDTH = 80
-OPTION_DESC_WIDTH = 45
-HIDDEN_DESC_PLACEHOLDER = "@@HIDDEN@@"
+require "utils/formatter"
 
 module Homebrew
   module CLI
     class Parser
-      extend T::Sig
+      ArgType = T.type_alias { T.any(NilClass, Symbol, T::Array[String], T::Array[Symbol]) }
+      HIDDEN_DESC_PLACEHOLDER = "@@HIDDEN@@"
+      SYMBOL_TO_USAGE_MAPPING = T.let({
+        text_or_regex: "<text>|`/`<regex>`/`",
+        url:           "<URL>",
+      }.freeze, T::Hash[Symbol, String])
+      private_constant :ArgType, :HIDDEN_DESC_PLACEHOLDER, :SYMBOL_TO_USAGE_MAPPING
+
+      sig { returns(Args) }
+      attr_reader :args
 
-      attr_reader :processed_options, :hide_from_man_page, :named_args_type
+      sig { returns(Args::OptionsType) }
+      attr_reader :processed_options
 
+      sig { returns(T::Boolean) }
+      attr_reader :hide_from_man_page
+
+      sig { returns(ArgType) }
+      attr_reader :named_args_type
+
+      sig { params(cmd_path: Pathname).returns(T.nilable(CLI::Parser)) }
       def self.from_cmd_path(cmd_path)
         cmd_args_method_name = Commands.args_method_name(cmd_path)
+        cmd_name = cmd_args_method_name.to_s.delete_suffix("_args").tr("_", "-")
 
         begin
-          Homebrew.send(cmd_args_method_name) if require?(cmd_path)
+          if require?(cmd_path)
+            cmd = Homebrew::AbstractCommand.command(cmd_name)
+            if cmd
+              cmd.parser
+            else
+              # FIXME: remove once commands are all subclasses of `AbstractCommand`:
+              Homebrew.send(cmd_args_method_name)
+            end
+          end
         rescue NoMethodError => e
-          raise if e.name != cmd_args_method_name
+          raise if e.name.to_sym != cmd_args_method_name
 
           nil
         end
       end
 
+      sig { returns(T::Array[[Symbol, String, { description: String }]]) }
       def self.global_cask_options
         [
           [:flag, "--appdir=", {
             description: "Target location for Applications " \
                          "(default: `#{Cask::Config::DEFAULT_DIRS[:appdir]}`).",
           }],
+          [:flag, "--keyboard-layoutdir=", {
+            description: "Target location for Keyboard Layouts " \
+                         "(default: `#{Cask::Config::DEFAULT_DIRS[:keyboard_layoutdir]}`).",
+          }],
           [:flag, "--colorpickerdir=", {
             description: "Target location for Color Pickers " \
                          "(default: `#{Cask::Config::DEFAULT_DIRS[:colorpickerdir]}`).",
@@ -46,7 +75,7 @@ def self.global_cask_options
                          "(default: `#{Cask::Config::DEFAULT_DIRS[:prefpanedir]}`).",
           }],
           [:flag, "--qlplugindir=", {
-            description: "Target location for QuickLook Plugins " \
+            description: "Target location for Quick Look Plugins " \
                          "(default: `#{Cask::Config::DEFAULT_DIRS[:qlplugindir]}`).",
           }],
           [:flag, "--mdimporterdir=", {
@@ -107,37 +136,57 @@ def self.global_options
         ]
       end
 
-      sig { params(block: T.nilable(T.proc.bind(Parser).void)).void }
-      def initialize(&block)
-        @parser = OptionParser.new
-
-        @parser.summary_indent = " " * 2
+      sig { params(option: String).returns(String) }
+      def self.option_to_name(option)
+        option.sub(/\A--?(\[no-\])?/, "").tr("-", "_").delete("=")
+      end
 
+      sig {
+        params(cmd: T.nilable(T.class_of(Homebrew::AbstractCommand)), block: T.nilable(T.proc.bind(Parser).void)).void
+      }
+      def initialize(cmd = nil, &block)
+        @parser = T.let(OptionParser.new, OptionParser)
+        @parser.summary_indent = "  "
         # Disable default handling of `--version` switch.
         @parser.base.long.delete("version")
-
         # Disable default handling of `--help` switch.
         @parser.base.long.delete("help")
 
-        @args = Homebrew::CLI::Args.new
-
-        # Filter out Sorbet runtime type checking method calls.
-        @command_name = caller_locations.select { |location| location.path.exclude?("/gems/sorbet-runtime-") }
-                                        .second.label.chomp("_args").tr("_", "-")
-
-        @constraints = []
-        @conflicts = []
-        @switch_sources = {}
-        @processed_options = []
-        @non_global_processed_options = []
-        @named_args_type = nil
-        @max_named_args = nil
-        @min_named_args = nil
-        @description = nil
-        @usage_banner = nil
-        @hide_from_man_page = false
-        @formula_options = false
-        @cask_options = false
+        @args = T.let((cmd&.args_class || Args).new, Args)
+
+        if cmd
+          @command_name = T.let(cmd.command_name, String)
+          @is_dev_cmd = T.let(cmd.dev_cmd?, T::Boolean)
+        else
+          # FIXME: remove once commands are all subclasses of `AbstractCommand`:
+          # Filter out Sorbet runtime type checking method calls.
+          cmd_location = caller_locations.select do |location|
+            T.must(location.path).exclude?("/gems/sorbet-runtime-")
+          end.fetch(1)
+          @command_name = T.let(T.must(cmd_location.label).chomp("_args").tr("_", "-"), String)
+          @is_dev_cmd = T.let(T.must(cmd_location.absolute_path).start_with?(Commands::HOMEBREW_DEV_CMD_PATH),
+                              T::Boolean)
+          odeprecated(
+            "`brew #{@command_name}'. This command needs to be refactored, as it is written in a style that",
+            "inherits from `Homebrew::AbstractCommand' ( see https://docs.brew.sh/External-Commands )",
+            disable_for_developers: false,
+          )
+        end
+
+        @constraints = T.let([], T::Array[[String, String]])
+        @conflicts = T.let([], T::Array[T::Array[String]])
+        @switch_sources = T.let({}, T::Hash[String, Symbol])
+        @processed_options = T.let([], Args::OptionsType)
+        @non_global_processed_options = T.let([], T::Array[[String, ArgType]])
+        @named_args_type = T.let(nil, T.nilable(ArgType))
+        @max_named_args = T.let(nil, T.nilable(Integer))
+        @min_named_args = T.let(nil, T.nilable(Integer))
+        @named_args_without_api = T.let(false, T::Boolean)
+        @description = T.let(nil, T.nilable(String))
+        @usage_banner = T.let(nil, T.nilable(String))
+        @hide_from_man_page = T.let(false, T::Boolean)
+        @formula_options = T.let(false, T::Boolean)
+        @cask_options = T.let(false, T::Boolean)
 
         self.class.global_options.each do |short, long, desc|
           switch short, long, description: desc, env: option_to_name(long), method: :on_tail
@@ -148,62 +197,68 @@ def initialize(&block)
         generate_banner
       end
 
+      sig {
+        params(names: String, description: T.nilable(String), replacement: T.untyped, env: T.untyped,
+               depends_on: T.nilable(String), method: Symbol, hidden: T::Boolean, disable: T::Boolean).void
+      }
       def switch(*names, description: nil, replacement: nil, env: nil, depends_on: nil,
-                 method: :on, hidden: false)
+                 method: :on, hidden: false, disable: false)
         global_switch = names.first.is_a?(Symbol)
         return if global_switch
 
-        description = option_description(description, *names, hidden: hidden)
-        if replacement.nil?
-          process_option(*names, description, type: :switch, hidden: hidden)
-        else
-          description += " (disabled#{"; replaced by #{replacement}" if replacement.present?})"
+        description = option_description(description, *names, hidden:)
+        process_option(*names, description, type: :switch, hidden:) unless disable
+
+        if replacement || disable
+          description += " (#{disable ? "disabled" : "deprecated"}#{"; replaced by #{replacement}" if replacement})"
         end
+
         @parser.public_send(method, *names, *wrap_option_desc(description)) do |value|
-          odisabled "the `#{names.first}` switch", replacement unless replacement.nil?
+          # This odeprecated should stick around indefinitely.
+          odeprecated "the `#{names.first}` switch", replacement, disable: disable if !replacement.nil? || disable
           value = true if names.none? { |name| name.start_with?("--[no-]") }
 
-          set_switch(*names, value: value, from: :args)
+          set_switch(*names, value:, from: :args)
         end
 
         names.each do |name|
-          set_constraints(name, depends_on: depends_on)
+          set_constraints(name, depends_on:)
         end
 
-        env_value = env?(env)
+        env_value = value_for_env(env)
         set_switch(*names, value: env_value, from: :env) unless env_value.nil?
       end
       alias switch_option switch
 
-      def env?(env)
-        return if env.blank?
-
-        Homebrew::EnvConfig.try(:"#{env}?")
-      end
-
+      sig { params(text: T.nilable(String)).returns(T.nilable(String)) }
       def description(text = nil)
         return @description if text.blank?
 
         @description = text.chomp
       end
 
+      sig { params(text: String).void }
       def usage_banner(text)
         @usage_banner, @description = text.chomp.split("\n\n", 2)
       end
 
-      def usage_banner_text
-        @parser.banner
-      end
+      sig { returns(T.nilable(String)) }
+      def usage_banner_text = @parser.banner
 
+      sig { params(name: String, description: T.nilable(String), hidden: T::Boolean).void }
       def comma_array(name, description: nil, hidden: false)
         name = name.chomp "="
-        description = option_description(description, name, hidden: hidden)
-        process_option(name, description, type: :comma_array, hidden: hidden)
+        description = option_description(description, name, hidden:)
+        process_option(name, description, type: :comma_array, hidden:)
         @parser.on(name, OptionParser::REQUIRED_ARGUMENT, Array, *wrap_option_desc(description)) do |list|
           @args[option_to_name(name)] = list
         end
       end
 
+      sig {
+        params(names: String, description: T.nilable(String), replacement: T.any(Symbol, String, NilClass),
+               depends_on: T.nilable(String), hidden: T::Boolean).void
+      }
       def flag(*names, description: nil, replacement: nil, depends_on: nil, hidden: false)
         required, flag_type = if names.any? { |name| name.end_with? "=" }
           [OptionParser::REQUIRED_ARGUMENT, :required_flag]
@@ -211,13 +266,14 @@ def flag(*names, description: nil, replacement: nil, depends_on: nil, hidden: fa
           [OptionParser::OPTIONAL_ARGUMENT, :optional_flag]
         end
         names.map! { |name| name.chomp "=" }
-        description = option_description(description, *names, hidden: hidden)
+        description = option_description(description, *names, hidden:)
         if replacement.nil?
-          process_option(*names, description, type: flag_type, hidden: hidden)
+          process_option(*names, description, type: flag_type, hidden:)
         else
           description += " (disabled#{"; replaced by #{replacement}" if replacement.present?})"
         end
         @parser.on(*names, *wrap_option_desc(description), required) do |option_value|
+          # This odisabled should stick around indefinitely.
           odisabled "the `#{names.first}` flag", replacement unless replacement.nil?
           names.each do |name|
             @args[option_to_name(name)] = option_value
@@ -225,20 +281,19 @@ def flag(*names, description: nil, replacement: nil, depends_on: nil, hidden: fa
         end
 
         names.each do |name|
-          set_constraints(name, depends_on: depends_on)
+          set_constraints(name, depends_on:)
         end
       end
 
+      sig { params(options: String).returns(T::Array[T::Array[String]]) }
       def conflicts(*options)
         @conflicts << options.map { |option| option_to_name(option) }
       end
 
-      def option_to_name(option)
-        option.sub(/\A--?(\[no-\])?/, "")
-              .tr("-", "_")
-              .delete("=")
-      end
+      sig { params(option: String).returns(String) }
+      def option_to_name(option) = self.class.option_to_name(option)
 
+      sig { params(name: String).returns(String) }
       def name_to_option(name)
         if name.length == 1
           "-#{name}"
@@ -247,10 +302,12 @@ def name_to_option(name)
         end
       end
 
+      sig { params(names: String).returns(T.nilable(String)) }
       def option_to_description(*names)
         names.map { |name| name.to_s.sub(/\A--?/, "").tr("-", " ") }.max
       end
 
+      sig { params(description: T.nilable(String), names: String, hidden: T::Boolean).returns(String) }
       def option_description(description, *names, hidden: false)
         return HIDDEN_DESC_PLACEHOLDER if hidden
         return description if description.present?
@@ -258,6 +315,10 @@ def option_description(description, *names, hidden: false)
         option_to_description(*names)
       end
 
+      sig {
+        params(argv: T::Array[String], ignore_invalid_options: T::Boolean)
+          .returns([T::Array[String], T::Array[String]])
+      }
       def parse_remaining(argv, ignore_invalid_options: false)
         i = 0
         remaining = []
@@ -297,9 +358,10 @@ def parse_remaining(argv, ignore_invalid_options: false)
       def parse(argv = ARGV.freeze, ignore_invalid_options: false)
         raise "Arguments were already parsed!" if @args_parsed
 
-        # If we accept formula options, parse once allowing invalid options
-        # so we can get the remaining list containing formula names.
-        if @formula_options
+        # If we accept formula options, but the command isn't scoped only
+        # to casks, parse once allowing invalid options so we can get the
+        # remaining list containing formula names.
+        if @formula_options && !only_casks?(argv)
           remaining, non_options = parse_remaining(argv, ignore_invalid_options: true)
 
           argv = [*remaining, "--", *non_options]
@@ -311,9 +373,9 @@ def parse(argv = ARGV.freeze, ignore_invalid_options: false)
               name = o.flag
               description = "`#{f.name}`: #{o.description}"
               if name.end_with? "="
-                flag   name, description: description
+                flag(name, description:)
               else
-                switch name, description: description
+                switch name, description:
               end
 
               conflicts "--cask", name
@@ -321,7 +383,7 @@ def parse(argv = ARGV.freeze, ignore_invalid_options: false)
           end
         end
 
-        remaining, non_options = parse_remaining(argv, ignore_invalid_options: ignore_invalid_options)
+        remaining, non_options = parse_remaining(argv, ignore_invalid_options:)
 
         named_args = if ignore_invalid_options
           []
@@ -330,16 +392,20 @@ def parse(argv = ARGV.freeze, ignore_invalid_options: false)
         end
 
         unless ignore_invalid_options
+          unless @is_dev_cmd
+            set_default_options
+            validate_options
+          end
           check_constraint_violations
           check_named_args(named_args)
         end
 
-        @args.freeze_named_args!(named_args, cask_options: @cask_options)
+        @args.freeze_named_args!(named_args, cask_options: @cask_options, without_api: @named_args_without_api)
         @args.freeze_remaining_args!(non_options.empty? ? remaining : [*remaining, "--", non_options])
         @args.freeze_processed_options!(@processed_options)
         @args.freeze
 
-        @args_parsed = true
+        @args_parsed = T.let(true, T.nilable(TrueClass))
 
         if !ignore_invalid_options && @args.help?
           puts generate_help_text
@@ -349,8 +415,15 @@ def parse(argv = ARGV.freeze, ignore_invalid_options: false)
         @args
       end
 
+      sig { void }
+      def set_default_options; end
+
+      sig { void }
+      def validate_options; end
+
+      sig { returns(String) }
       def generate_help_text
-        Formatter.format_help_text(@parser.to_s, width: COMMAND_DESC_WIDTH)
+        Formatter.format_help_text(@parser.to_s, width: Formatter::COMMAND_DESC_WIDTH)
                  .gsub(/\n.*?@@HIDDEN@@.*?(?=\n)/, "")
                  .sub(/^/, "#{Tty.bold}Usage: brew#{Tty.reset} ")
                  .gsub(/`(.*?)`/m, "#{Tty.bold}\\1#{Tty.reset}")
@@ -360,10 +433,12 @@ def generate_help_text
                  end
       end
 
+      sig { void }
       def cask_options
-        self.class.global_cask_options.each do |method, *args, **options|
-          send(method, *args, **options)
-          conflicts "--formula", args.last
+        self.class.global_cask_options.each do |args|
+          options = T.cast(args.pop, T::Hash[Symbol, String])
+          send(*args, **options)
+          conflicts "--formula", args[1]
         end
         @cask_options = true
       end
@@ -375,13 +450,14 @@ def formula_options
 
       sig {
         params(
-          type:   T.any(Symbol, T::Array[String], T::Array[Symbol]),
-          number: T.nilable(Integer),
-          min:    T.nilable(Integer),
-          max:    T.nilable(Integer),
+          type:        ArgType,
+          number:      T.nilable(Integer),
+          min:         T.nilable(Integer),
+          max:         T.nilable(Integer),
+          without_api: T::Boolean,
         ).void
       }
-      def named_args(type = nil, number: nil, min: nil, max: nil)
+      def named_args(type = nil, number: nil, min: nil, max: nil, without_api: false)
         if number.present? && (min.present? || max.present?)
           raise ArgumentError, "Do not specify both `number` and `min` or `max`"
         end
@@ -394,12 +470,14 @@ def named_args(type = nil, number: nil, min: nil, max: nil)
 
         if type == :none
           @max_named_args = 0
-        elsif number.present?
+        elsif number
           @min_named_args = @max_named_args = number
-        elsif min.present? || max.present?
+        elsif min || max
           @min_named_args = min
           @max_named_args = max
         end
+
+        @named_args_without_api = without_api
       end
 
       sig { void }
@@ -409,19 +487,15 @@ def hide_from_man_page!
 
       private
 
-      SYMBOL_TO_USAGE_MAPPING = {
-        text_or_regex: "<text>|`/`<regex>`/`",
-        url:           "<URL>",
-      }.freeze
-
+      sig { returns(String) }
       def generate_usage_banner
         command_names = ["`#{@command_name}`"]
         aliases_to_skip = %w[instal uninstal]
-        command_names += Commands::HOMEBREW_INTERNAL_COMMAND_ALIASES.map do |command_alias, command|
+        command_names += Commands::HOMEBREW_INTERNAL_COMMAND_ALIASES.filter_map do |command_alias, command|
           next if aliases_to_skip.include? command_alias
 
           "`#{command_alias}`" if command == @command_name
-        end.compact.sort
+        end.sort
 
         options = if @non_global_processed_options.empty?
           ""
@@ -430,21 +504,21 @@ def generate_usage_banner
         else
           required_argument_types = [:required_flag, :comma_array]
           @non_global_processed_options.map do |option, type|
-            next " [<#{option}>`=`]" if required_argument_types.include? type
+            next " [`#{option}=`]" if required_argument_types.include? type
 
-            " [<#{option}>]"
+            " [`#{option}`]"
           end.join
         end
 
         named_args = ""
         if @named_args_type.present? && @named_args_type != :none
           arg_type = if @named_args_type.is_a? Array
-            types = @named_args_type.map do |type|
+            types = @named_args_type.filter_map do |type|
               next unless type.is_a? Symbol
               next SYMBOL_TO_USAGE_MAPPING[type] if SYMBOL_TO_USAGE_MAPPING.key?(type)
 
               "<#{type}>"
-            end.compact
+            end
             types << "<subcommand>" if @named_args_type.any?(String)
             types.join("|")
           elsif SYMBOL_TO_USAGE_MAPPING.key? @named_args_type
@@ -469,6 +543,7 @@ def generate_usage_banner
         "#{command_names.join(", ")}#{options}#{named_args}"
       end
 
+      sig { returns(String) }
       def generate_banner
         @usage_banner ||= generate_usage_banner
 
@@ -480,6 +555,7 @@ def generate_banner
         BANNER
       end
 
+      sig { params(names: String, value: T.untyped, from: Symbol).void }
       def set_switch(*names, value:, from:)
         names.each do |name|
           @switch_sources[option_to_name(name)] = from
@@ -487,8 +563,9 @@ def set_switch(*names, value:, from:)
         end
       end
 
-      def disable_switch(*names)
-        names.each do |name|
+      sig { params(args: String).void }
+      def disable_switch(*args)
+        args.each do |name|
           @args["#{option_to_name(name)}?"] = if name.start_with?("--[no-]")
             nil
           else
@@ -497,14 +574,17 @@ def disable_switch(*names)
         end
       end
 
+      sig { params(name: String).returns(T::Boolean) }
       def option_passed?(name)
-        @args[name.to_sym] || @args["#{name}?".to_sym]
+        !!(@args[name.to_sym] || @args[:"#{name}?"])
       end
 
+      sig { params(desc: String).returns(T::Array[String]) }
       def wrap_option_desc(desc)
-        Formatter.format_help_text(desc, width: OPTION_DESC_WIDTH).split("\n")
+        Formatter.format_help_text(desc, width: Formatter::OPTION_DESC_WIDTH).split("\n")
       end
 
+      sig { params(name: String, depends_on: T.nilable(String)).returns(T.nilable(T::Array[[String, String]])) }
       def set_constraints(name, depends_on:)
         return if depends_on.nil?
 
@@ -513,6 +593,7 @@ def set_constraints(name, depends_on:)
         @constraints << [primary, secondary]
       end
 
+      sig { void }
       def check_constraints
         @constraints.each do |primary, secondary|
           primary_passed = option_passed?(primary)
@@ -527,6 +608,7 @@ def check_constraints
         end
       end
 
+      sig { void }
       def check_conflicts
         @conflicts.each do |mutually_exclusive_options_group|
           violations = mutually_exclusive_options_group.select do |option|
@@ -540,12 +622,13 @@ def check_conflicts
           end
 
           select_cli_arg = violations.count - env_var_options.count == 1
-          raise OptionConflictError, violations.map(&method(:name_to_option)) unless select_cli_arg
+          raise OptionConflictError, violations.map { name_to_option(_1) } unless select_cli_arg
 
-          env_var_options.each(&method(:disable_switch))
+          env_var_options.each { disable_switch(_1) }
         end
       end
 
+      sig { void }
       def check_invalid_constraints
         @conflicts.each do |mutually_exclusive_options_group|
           @constraints.each do |p, s|
@@ -556,36 +639,40 @@ def check_invalid_constraints
         end
       end
 
+      sig { void }
       def check_constraint_violations
         check_invalid_constraints
         check_conflicts
         check_constraints
       end
 
+      sig { params(args: T::Array[String]).void }
       def check_named_args(args)
-        types = Array(@named_args_type).map do |type|
+        types = Array(@named_args_type).filter_map do |type|
           next type if type.is_a? Symbol
 
           :subcommand
-        end.compact.uniq
+        end.uniq
 
         exception = if @min_named_args && @max_named_args && @min_named_args == @max_named_args &&
                        args.size != @max_named_args
-          NumberOfNamedArgumentsError.new(@min_named_args, types: types)
+          NumberOfNamedArgumentsError.new(@min_named_args, types:)
         elsif @min_named_args && args.size < @min_named_args
-          MinNamedArgumentsError.new(@min_named_args, types: types)
+          MinNamedArgumentsError.new(@min_named_args, types:)
         elsif @max_named_args && args.size > @max_named_args
-          MaxNamedArgumentsError.new(@max_named_args, types: types)
+          MaxNamedArgumentsError.new(@max_named_args, types:)
         end
 
         raise exception if exception
       end
 
+      sig { params(args: String, type: Symbol, hidden: T::Boolean).void }
       def process_option(*args, type:, hidden: false)
         option, = @parser.make_switch(args)
         @processed_options.reject! { |existing| existing.second == option.long.first } if option.long.first.present?
-        @processed_options << [option.short.first, option.long.first, option.arg, option.desc.first, hidden]
+        @processed_options << [option.short.first, option.long.first, option.desc.first, hidden]
 
+        args.pop # last argument is the description
         if type == :switch
           disable_switch(*args)
         else
@@ -600,6 +687,7 @@ def process_option(*args, type:, hidden: false)
         @non_global_processed_options << [option.long.first || option.short.first, type]
       end
 
+      sig { params(argv: T::Array[String]).returns([T::Array[String], T::Array[String]]) }
       def split_non_options(argv)
         if (sep = argv.index("--"))
           [argv.take(sep), argv.drop(sep + 1)]
@@ -608,6 +696,7 @@ def split_non_options(argv)
         end
       end
 
+      sig { params(argv: T::Array[String]).returns(T::Array[Formula]) }
       def formulae(argv)
         argv, non_options = split_non_options(argv)
 
@@ -619,19 +708,37 @@ def formulae(argv)
         end
 
         # Only lowercase names, not paths, bottle filenames or URLs
-        named_args.map do |arg|
+        named_args.filter_map do |arg|
           next if arg.match?(HOMEBREW_CASK_TAP_CASK_REGEX)
 
           begin
             Formulary.factory(arg, spec, flags: argv.select { |a| a.start_with?("--") })
-          rescue FormulaUnavailableError
+          rescue FormulaUnavailableError, FormulaSpecificationError
             nil
           end
-        end.compact.uniq(&:name)
+        end.uniq(&:name)
+      end
+
+      sig { params(argv: T::Array[String]).returns(T::Boolean) }
+      def only_casks?(argv)
+        argv.include?("--casks") || argv.include?("--cask")
+      end
+
+      sig { params(env: T.any(NilClass, String, Symbol)).returns(T.untyped) }
+      def value_for_env(env)
+        return if env.blank?
+
+        method_name = :"#{env}?"
+        if Homebrew::EnvConfig.respond_to?(method_name)
+          Homebrew::EnvConfig.public_send(method_name)
+        else
+          ENV.fetch("HOMEBREW_#{env.upcase}", nil)
+        end
       end
     end
 
     class OptionConstraintError < UsageError
+      sig { params(arg1: String, arg2: String, missing: T::Boolean).void }
       def initialize(arg1, arg2, missing: false)
         message = if missing
           "`#{arg2}` cannot be passed without `#{arg1}`."
@@ -643,22 +750,21 @@ def initialize(arg1, arg2, missing: false)
     end
 
     class OptionConflictError < UsageError
+      sig { params(args: T::Array[String]).void }
       def initialize(args)
-        args_list = args.map(&Formatter.public_method(:option))
-                        .join(" and ")
+        args_list = args.map { Formatter.option(_1) }.join(" and ")
         super "Options #{args_list} are mutually exclusive."
       end
     end
 
     class InvalidConstraintError < UsageError
+      sig { params(arg1: String, arg2: String).void }
       def initialize(arg1, arg2)
         super "`#{arg1}` and `#{arg2}` cannot be mutually exclusive and mutually dependent simultaneously."
       end
     end
 
     class MaxNamedArgumentsError < UsageError
-      extend T::Sig
-
       sig { params(maximum: Integer, types: T::Array[Symbol]).void }
       def initialize(maximum, types: [])
         super case maximum
@@ -669,35 +775,33 @@ def initialize(maximum, types: [])
           arg_types = types.map { |type| type.to_s.tr("_", " ") }
                            .to_sentence two_words_connector: " or ", last_word_connector: " or "
 
-          "This command does not take more than #{maximum} #{arg_types} #{"argument".pluralize(maximum)}."
+          "This command does not take more than #{maximum} #{arg_types} #{Utils.pluralize("argument", maximum)}."
         end
       end
     end
 
     class MinNamedArgumentsError < UsageError
-      extend T::Sig
-
       sig { params(minimum: Integer, types: T::Array[Symbol]).void }
       def initialize(minimum, types: [])
         types << :named if types.empty?
         arg_types = types.map { |type| type.to_s.tr("_", " ") }
                          .to_sentence two_words_connector: " or ", last_word_connector: " or "
 
-        super "This command requires at least #{minimum} #{arg_types} #{"argument".pluralize(minimum)}."
+        super "This command requires at least #{minimum} #{arg_types} #{Utils.pluralize("argument", minimum)}."
       end
     end
 
     class NumberOfNamedArgumentsError < UsageError
-      extend T::Sig
-
       sig { params(minimum: Integer, types: T::Array[Symbol]).void }
       def initialize(minimum, types: [])
         types << :named if types.empty?
         arg_types = types.map { |type| type.to_s.tr("_", " ") }
                          .to_sentence two_words_connector: " or ", last_word_connector: " or "
 
-        super "This command requires exactly #{minimum} #{arg_types} #{"argument".pluralize(minimum)}."
+        super "This command requires exactly #{minimum} #{arg_types} #{Utils.pluralize("argument", minimum)}."
       end
     end
   end
 end
+
+require "extend/os/parser"
diff --git a/Library/Homebrew/cmake/trap_fetchcontent_provider.cmake b/Library/Homebrew/cmake/trap_fetchcontent_provider.cmake
new file mode 100644
index 0000000000000..9eba3eb8e65c1
--- /dev/null
+++ b/Library/Homebrew/cmake/trap_fetchcontent_provider.cmake
@@ -0,0 +1,18 @@
+# Dependency providers were introduced in CMake 3.24. We don't set cmake_minimum_required here because that would
+# propagate to downstream projects, which may break projects that rely on deprecated CMake behavior. Since the build
+# is using brewed CMake, we can assume that the CMake version in use is at least 3.24.
+
+option(HOMEBREW_ALLOW_FETCHCONTENT "Allow FetchContent to be used in Homebrew builds" OFF)
+
+if (HOMEBREW_ALLOW_FETCHCONTENT)
+    return()
+endif()
+
+macro(trap_fetchcontent_provider method depName)
+    message(FATAL_ERROR "Refusing to populate dependency '${depName}' with FetchContent while building in Homebrew, please use a formula dependency or add a resource to the formula.")
+endmacro()
+
+cmake_language(
+    SET_DEPENDENCY_PROVIDER trap_fetchcontent_provider
+    SUPPORTED_METHODS FETCHCONTENT_MAKEAVAILABLE_SERIAL
+)
diff --git a/Library/Homebrew/cmd/--cache.rb b/Library/Homebrew/cmd/--cache.rb
index 1e39aa66c9c91..79137eb298849 100644
--- a/Library/Homebrew/cmd/--cache.rb
+++ b/Library/Homebrew/cmd/--cache.rb
@@ -1,78 +1,132 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "fetch"
-require "cli/parser"
 require "cask/download"
 
 module Homebrew
-  extend T::Sig
-
-  extend Fetch
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def __cache_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Display Homebrew's download cache. See also `HOMEBREW_CACHE`.
-
-        If <formula> is provided, display the file or directory used to cache <formula>.
-      EOS
-      switch "-s", "--build-from-source",
-             description: "Show the cache file used when building from source."
-      switch "--force-bottle",
-             description: "Show the cache file used when pouring a bottle."
-      flag "--bottle-tag=",
-           description: "Show the cache file used when pouring a bottle for the given tag."
-      switch "--HEAD",
-             description: "Show the cache file used when building from HEAD."
-      switch "--formula", "--formulae",
-             description: "Only show cache files for formulae."
-      switch "--cask", "--casks",
-             description: "Only show cache files for casks."
-
-      conflicts "--build-from-source", "--force-bottle", "--bottle-tag", "--HEAD", "--cask"
-      conflicts "--formula", "--cask"
-
-      named_args [:formula, :cask]
-    end
-  end
+  module Cmd
+    class Cache < AbstractCommand
+      include Fetch
 
-  sig { void }
-  def __cache
-    args = __cache_args.parse
+      sig { override.returns(String) }
+      def self.command_name = "--cache"
 
-    if args.no_named?
-      puts HOMEBREW_CACHE
-      return
-    end
+      cmd_args do
+        description <<~EOS
+          Display Homebrew's download cache. See also `HOMEBREW_CACHE`.
 
-    formulae_or_casks = args.named.to_formulae_and_casks
+          If a <formula> or <cask> is provided, display the file or directory used to cache it.
+        EOS
+        flag   "--os=",
+               description: "Show cache file for the given operating system. " \
+                            "(Pass `all` to show cache files for all operating systems.)"
+        flag   "--arch=",
+               description: "Show cache file for the given CPU architecture. " \
+                            "(Pass `all` to show cache files for all architectures.)"
+        switch "-s", "--build-from-source",
+               description: "Show the cache file used when building from source."
+        switch "--force-bottle",
+               description: "Show the cache file used when pouring a bottle."
+        flag "--bottle-tag=",
+             description: "Show the cache file used when pouring a bottle for the given tag."
+        switch "--HEAD",
+               description: "Show the cache file used when building from HEAD."
+        switch "--formula", "--formulae",
+               description: "Only show cache files for formulae."
+        switch "--cask", "--casks",
+               description: "Only show cache files for casks."
 
-    formulae_or_casks.each do |formula_or_cask|
-      if formula_or_cask.is_a? Formula
-        print_formula_cache formula_or_cask, args: args
-      else
-        print_cask_cache formula_or_cask
+        conflicts "--build-from-source", "--force-bottle", "--bottle-tag", "--HEAD", "--cask"
+        conflicts "--formula", "--cask"
+        conflicts "--os", "--bottle-tag"
+        conflicts "--arch", "--bottle-tag"
+
+        named_args [:formula, :cask]
       end
-    end
-  end
 
-  sig { params(formula: Formula, args: CLI::Args).void }
-  def print_formula_cache(formula, args:)
-    if fetch_bottle?(formula, args: args)
-      puts formula.bottle_for_tag(args.bottle_tag&.to_sym).cached_download
-    elsif args.HEAD?
-      puts formula.head.cached_download
-    else
-      puts formula.cached_download
-    end
-  end
+      sig { override.void }
+      def run
+        if args.no_named?
+          puts HOMEBREW_CACHE
+          return
+        end
+
+        formulae_or_casks = args.named.to_formulae_and_casks
+        os_arch_combinations = args.os_arch_combinations
+
+        formulae_or_casks.each do |formula_or_cask|
+          case formula_or_cask
+          when Formula
+            formula = formula_or_cask
+            ref = formula.loaded_from_api? ? formula.full_name : formula.path
+
+            os_arch_combinations.each do |os, arch|
+              SimulateSystem.with(os:, arch:) do
+                formula = Formulary.factory(ref)
+                print_formula_cache(formula, os:, arch:)
+              end
+            end
+          when Cask::Cask
+            cask = formula_or_cask
+            ref = cask.loaded_from_api? ? cask.full_name : cask.sourcefile_path
 
-  sig { params(cask: Cask::Cask).void }
-  def print_cask_cache(cask)
-    puts Cask::Download.new(cask).downloader.cached_location
+            os_arch_combinations.each do |os, arch|
+              next if os == :linux
+
+              SimulateSystem.with(os:, arch:) do
+                loaded_cask = Cask::CaskLoader.load(ref)
+                print_cask_cache(loaded_cask)
+              end
+            end
+          else
+            raise "Invalid type: #{formula_or_cask.class}"
+          end
+        end
+      end
+
+      private
+
+      sig { params(formula: Formula, os: Symbol, arch: Symbol).void }
+      def print_formula_cache(formula, os:, arch:)
+        if fetch_bottle?(
+          formula,
+          force_bottle:               args.force_bottle?,
+          bottle_tag:                 args.bottle_tag&.to_sym,
+          build_from_source_formulae: args.build_from_source_formulae,
+          os:                         args.os&.to_sym,
+          arch:                       args.arch&.to_sym,
+        )
+          bottle_tag = if (bottle_tag = args.bottle_tag&.to_sym)
+            Utils::Bottles::Tag.from_symbol(bottle_tag)
+          else
+            Utils::Bottles::Tag.new(system: os, arch:)
+          end
+
+          bottle = formula.bottle_for_tag(bottle_tag)
+
+          if bottle.nil?
+            opoo "Bottle for tag #{bottle_tag.to_sym.inspect} is unavailable."
+            return
+          end
+
+          puts bottle.cached_download
+        elsif args.HEAD?
+          if (head = formula.head)
+            puts head.cached_download
+          else
+            opoo "No head is defined for #{formula.full_name}."
+          end
+        else
+          puts formula.cached_download
+        end
+      end
+
+      sig { params(cask: Cask::Cask).void }
+      def print_cask_cache(cask)
+        puts Cask::Download.new(cask).downloader.cached_location
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/cmd/--caskroom.rb b/Library/Homebrew/cmd/--caskroom.rb
index 681cdf03314c7..a9debf878aec2 100644
--- a/Library/Homebrew/cmd/--caskroom.rb
+++ b/Library/Homebrew/cmd/--caskroom.rb
@@ -1,34 +1,34 @@
 # typed: strict
 # frozen_string_literal: true
 
-module Homebrew
-  extend T::Sig
-
-  module_function
+require "abstract_command"
 
-  sig { returns(CLI::Parser) }
-  def __caskroom_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Display Homebrew's Caskroom path.
+module Homebrew
+  module Cmd
+    class Caskroom < AbstractCommand
+      sig { override.returns(String) }
+      def self.command_name = "--caskroom"
 
-        If <cask> is provided, display the location in the Caskroom where <cask>
-        would be installed, without any sort of versioned directory as the last path.
-      EOS
+      cmd_args do
+        description <<~EOS
+          Display Homebrew's Caskroom path.
 
-      named_args :cask
-    end
-  end
+          If <cask> is provided, display the location in the Caskroom where <cask>
+          would be installed, without any sort of versioned directory as the last path.
+        EOS
 
-  sig { void }
-  def __caskroom
-    args = __caskroom_args.parse
+        named_args :cask
+      end
 
-    if args.named.to_casks.blank?
-      puts Cask::Caskroom.path
-    else
-      args.named.to_casks.each do |cask|
-        puts "#{Cask::Caskroom.path}/#{cask.token}"
+      sig { override.void }
+      def run
+        if args.named.to_casks.blank?
+          puts Cask::Caskroom.path
+        else
+          args.named.to_casks.each do |cask|
+            puts "#{Cask::Caskroom.path}/#{cask.token}"
+          end
+        end
       end
     end
   end
diff --git a/Library/Homebrew/cmd/--cellar.rb b/Library/Homebrew/cmd/--cellar.rb
index fa1eff526e0cc..aa7abafc65f0f 100644
--- a/Library/Homebrew/cmd/--cellar.rb
+++ b/Library/Homebrew/cmd/--cellar.rb
@@ -1,32 +1,34 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 
 module Homebrew
-  module_function
+  module Cmd
+    class Cellar < AbstractCommand
+      sig { override.returns(String) }
+      def self.command_name = "--cellar"
 
-  def __cellar_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Display Homebrew's Cellar path. *Default:* `$(brew --prefix)/Cellar`, or if
-        that directory doesn't exist, `$(brew --repository)/Cellar`.
+      cmd_args do
+        description <<~EOS
+          Display Homebrew's Cellar path. *Default:* `$(brew --prefix)/Cellar`, or if
+          that directory doesn't exist, `$(brew --repository)/Cellar`.
 
-        If <formula> is provided, display the location in the Cellar where <formula>
-        would be installed, without any sort of versioned directory as the last path.
-      EOS
+          If <formula> is provided, display the location in the Cellar where <formula>
+          would be installed, without any sort of versioned directory as the last path.
+        EOS
 
-      named_args :formula
-    end
-  end
-
-  def __cellar
-    args = __cellar_args.parse
+        named_args :formula
+      end
 
-    if args.no_named?
-      puts HOMEBREW_CELLAR
-    else
-      puts args.named.to_resolved_formulae.map(&:rack)
+      sig { override.void }
+      def run
+        if args.no_named?
+          puts HOMEBREW_CELLAR
+        else
+          puts args.named.to_resolved_formulae.map(&:rack)
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cmd/--env.rb b/Library/Homebrew/cmd/--env.rb
index f9c12119d9d4c..e0a2a503073eb 100644
--- a/Library/Homebrew/cmd/--env.rb
+++ b/Library/Homebrew/cmd/--env.rb
@@ -1,58 +1,56 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "extend/ENV"
 require "build_environment"
 require "utils/shell"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def __env_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Summarise Homebrew's build environment as a plain list.
-
-        If the command's output is sent through a pipe and no shell is specified,
-        the list is formatted for export to `bash`(1) unless `--plain` is passed.
-      EOS
-      flag   "--shell=",
-             description: "Generate a list of environment variables for the specified shell, " \
-                          "or `--shell=auto` to detect the current shell."
-      switch "--plain",
-             description: "Generate plain output even when piped."
-
-      named_args :formula
-    end
-  end
-
-  sig { void }
-  def __env
-    args = __env_args.parse
-
-    ENV.activate_extensions!
-    ENV.deps = args.named.to_formulae if superenv?(nil)
-    ENV.setup_build_environment
-
-    shell = if args.plain?
-      nil
-    elsif args.shell.nil?
-      :bash unless $stdout.tty?
-    elsif args.shell == "auto"
-      Utils::Shell.parent || Utils::Shell.preferred
-    elsif args.shell
-      Utils::Shell.from_path(args.shell)
-    end
+  module Cmd
+    class Env < AbstractCommand
+      sig { override.returns(String) }
+      def self.command_name = "--env"
+
+      cmd_args do
+        description <<~EOS
+          Summarise Homebrew's build environment as a plain list.
+
+          If the command's output is sent through a pipe and no shell is specified,
+          the list is formatted for export to `bash`(1) unless `--plain` is passed.
+        EOS
+        flag   "--shell=",
+               description: "Generate a list of environment variables for the specified shell, " \
+                            "or `--shell=auto` to detect the current shell."
+        switch "--plain",
+               description: "Generate plain output even when piped."
+
+        named_args :formula
+      end
 
-    if shell.nil?
-      BuildEnvironment.dump ENV
-    else
-      BuildEnvironment.keys(ENV).each do |key|
-        puts Utils::Shell.export_value(key, ENV.fetch(key), shell)
+      sig { override.void }
+      def run
+        ENV.activate_extensions!
+        T.cast(ENV, Superenv).deps = args.named.to_formulae if superenv?(nil)
+        ENV.setup_build_environment
+
+        shell = if args.plain?
+          nil
+        elsif args.shell.nil?
+          :bash unless $stdout.tty?
+        elsif args.shell == "auto"
+          Utils::Shell.parent || Utils::Shell.preferred
+        elsif args.shell
+          Utils::Shell.from_path(T.must(args.shell))
+        end
+
+        if shell.nil?
+          BuildEnvironment.dump ENV.to_h
+        else
+          BuildEnvironment.keys(ENV.to_h).each do |key|
+            puts Utils::Shell.export_value(key, ENV.fetch(key), shell)
+          end
+        end
       end
     end
   end
diff --git a/Library/Homebrew/cmd/--prefix.rb b/Library/Homebrew/cmd/--prefix.rb
index 51bda5716de99..2f1a87fe80235 100644
--- a/Library/Homebrew/cmd/--prefix.rb
+++ b/Library/Homebrew/cmd/--prefix.rb
@@ -1,111 +1,115 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
+require "fileutils"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class Prefix < AbstractCommand
+      include FileUtils
+
+      UNBREWED_EXCLUDE_FILES = %w[.DS_Store].freeze
+      UNBREWED_EXCLUDE_PATHS = %w[
+        */.keepme
+        .github/*
+        bin/brew
+        completions/zsh/_brew
+        docs/*
+        lib/gdk-pixbuf-2.0/*
+        lib/gio/*
+        lib/node_modules/*
+        lib/python[23].[0-9]/*
+        lib/python3.[0-9][0-9]/*
+        lib/pypy/*
+        lib/pypy3/*
+        lib/ruby/gems/[12].*
+        lib/ruby/site_ruby/[12].*
+        lib/ruby/vendor_ruby/[12].*
+        manpages/brew.1
+        share/pypy/*
+        share/pypy3/*
+        share/info/dir
+        share/man/whatis
+        share/mime/*
+        texlive/*
+      ].freeze
+
+      sig { override.returns(String) }
+      def self.command_name = "--prefix"
+
+      cmd_args do
+        description <<~EOS
+          Display Homebrew's install path. *Default:*
+
+            - macOS ARM: `#{HOMEBREW_MACOS_ARM_DEFAULT_PREFIX}`
+            - macOS Intel: `#{HOMEBREW_DEFAULT_PREFIX}`
+            - Linux: `#{HOMEBREW_LINUX_DEFAULT_PREFIX}`
+
+          If <formula> is provided, display the location where <formula> is or would be installed.
+        EOS
+        switch "--unbrewed",
+               description: "List files in Homebrew's prefix not installed by Homebrew."
+        switch "--installed",
+               description: "Outputs nothing and returns a failing status code if <formula> is not installed."
+        conflicts "--unbrewed", "--installed"
 
-  module_function
+        named_args :formula
+      end
 
-  sig { returns(CLI::Parser) }
-  def __prefix_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Display Homebrew's install path. *Default:*
+      sig { override.void }
+      def run
+        raise UsageError, "`--installed` requires a formula argument." if args.installed? && args.no_named?
+
+        if args.unbrewed?
+          raise UsageError, "`--unbrewed` does not take a formula argument." unless args.no_named?
+
+          list_unbrewed
+        elsif args.no_named?
+          puts HOMEBREW_PREFIX
+        else
+          formulae = args.named.to_resolved_formulae
+          prefixes = formulae.filter_map do |f|
+            next nil if args.installed? && !f.opt_prefix.exist?
+
+            # this case will be short-circuited by brew.sh logic for a single formula
+            f.opt_prefix
+          end
+          puts prefixes
+          if args.installed?
+            missing_formulae = formulae.reject(&:optlinked?)
+                                       .map(&:name)
+            return if missing_formulae.blank?
+
+            raise NotAKegError, <<~EOS
+              The following formulae are not installed:
+              #{missing_formulae.join(" ")}
+            EOS
+          end
+        end
+      end
 
-          - macOS Intel: `#{HOMEBREW_DEFAULT_PREFIX}`
-          - macOS ARM: `#{HOMEBREW_MACOS_ARM_DEFAULT_PREFIX}`
-          - Linux: `#{HOMEBREW_LINUX_DEFAULT_PREFIX}`
+      private
 
-        If <formula> is provided, display the location where <formula> is or would be installed.
-      EOS
-      switch "--unbrewed",
-             description: "List files in Homebrew's prefix not installed by Homebrew."
-      switch "--installed",
-             description: "Outputs nothing and returns a failing status code if <formula> is not installed."
-      conflicts "--unbrewed", "--installed"
+      sig { void }
+      def list_unbrewed
+        dirs  = HOMEBREW_PREFIX.subdirs.map { |dir| dir.basename.to_s }
+        dirs -= %w[Library Cellar Caskroom .git]
 
-      named_args :formula
-    end
-  end
+        # Exclude cache, logs and repository, if they are located under the prefix.
+        [HOMEBREW_CACHE, HOMEBREW_LOGS, HOMEBREW_REPOSITORY].each do |dir|
+          dirs.delete dir.relative_path_from(HOMEBREW_PREFIX).to_s
+        end
+        dirs.delete "etc"
+        dirs.delete "var"
 
-  def __prefix
-    args = __prefix_args.parse
-
-    raise UsageError, "`--installed` requires a formula argument." if args.installed? && args.no_named?
-
-    if args.unbrewed?
-      raise UsageError, "`--unbrewed` does not take a formula argument." unless args.no_named?
-
-      list_unbrewed
-    elsif args.no_named?
-      puts HOMEBREW_PREFIX
-    else
-      formulae = args.named.to_resolved_formulae
-      prefixes = formulae.map do |f|
-        next nil if args.installed? && !f.opt_prefix.exist?
-
-        # this case will be short-circuited by brew.sh logic for a single formula
-        f.opt_prefix
-      end.compact
-      puts prefixes
-      if args.installed?
-        missing_formulae = formulae.reject(&:optlinked?)
-                                   .map(&:name)
-        return if missing_formulae.blank?
-
-        raise NotAKegError, <<~EOS
-          The following formulae are not installed:
-          #{missing_formulae.join(" ")}
-        EOS
-      end
-    end
-  end
+        arguments = dirs.sort + %w[-type f (]
+        arguments.concat UNBREWED_EXCLUDE_FILES.flat_map { |f| %W[! -name #{f}] }
+        arguments.concat UNBREWED_EXCLUDE_PATHS.flat_map { |d| %W[! -path #{d}] }
+        arguments.push ")"
 
-  UNBREWED_EXCLUDE_FILES = %w[.DS_Store].freeze
-  UNBREWED_EXCLUDE_PATHS = %w[
-    */.keepme
-    .github/*
-    bin/brew
-    completions/zsh/_brew
-    docs/*
-    lib/gdk-pixbuf-2.0/*
-    lib/gio/*
-    lib/node_modules/*
-    lib/python[23].[0-9]/*
-    lib/python3.[0-9][0-9]/*
-    lib/pypy/*
-    lib/pypy3/*
-    lib/ruby/gems/[12].*
-    lib/ruby/site_ruby/[12].*
-    lib/ruby/vendor_ruby/[12].*
-    manpages/brew.1
-    share/pypy/*
-    share/pypy3/*
-    share/info/dir
-    share/man/whatis
-    share/mime/*
-    texlive/*
-  ].freeze
-
-  def list_unbrewed
-    dirs  = HOMEBREW_PREFIX.subdirs.map { |dir| dir.basename.to_s }
-    dirs -= %w[Library Cellar Caskroom .git]
-
-    # Exclude cache, logs, and repository, if they are located under the prefix.
-    [HOMEBREW_CACHE, HOMEBREW_LOGS, HOMEBREW_REPOSITORY].each do |dir|
-      dirs.delete dir.relative_path_from(HOMEBREW_PREFIX).to_s
+        cd(HOMEBREW_PREFIX) { safe_system("find", *arguments) }
+      end
     end
-    dirs.delete "etc"
-    dirs.delete "var"
-
-    arguments = dirs.sort + %w[-type f (]
-    arguments.concat UNBREWED_EXCLUDE_FILES.flat_map { |f| %W[! -name #{f}] }
-    arguments.concat UNBREWED_EXCLUDE_PATHS.flat_map { |d| %W[! -path #{d}] }
-    arguments.concat %w[)]
-
-    cd HOMEBREW_PREFIX
-    safe_system "find", *arguments
   end
 end
diff --git a/Library/Homebrew/cmd/--repository.rb b/Library/Homebrew/cmd/--repository.rb
index c72c0510fe7cf..c5ac522a13f6d 100644
--- a/Library/Homebrew/cmd/--repository.rb
+++ b/Library/Homebrew/cmd/--repository.rb
@@ -1,33 +1,26 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
+require "shell_command"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class Repository < AbstractCommand
+      include ShellCommand
 
-  module_function
+      sig { override.returns(String) }
+      def self.command_name = "--repository"
 
-  sig { returns(CLI::Parser) }
-  def __repository_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Display where Homebrew's git repository is located.
+      cmd_args do
+        description <<~EOS
+          Display where Homebrew's Git repository is located.
 
-        If <user>`/`<repo> are provided, display where tap <user>`/`<repo>'s directory is located.
-      EOS
+          If <user>`/`<repo> are provided, display where tap <user>`/`<repo>'s directory is located.
+        EOS
 
-      named_args :tap
-    end
-  end
-
-  def __repository
-    args = __repository_args.parse
-
-    if args.no_named?
-      puts HOMEBREW_REPOSITORY
-    else
-      puts args.named.to_taps.map(&:path)
+        named_args :tap
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cmd/--repository.sh b/Library/Homebrew/cmd/--repository.sh
new file mode 100644
index 0000000000000..81a4ffef11a6c
--- /dev/null
+++ b/Library/Homebrew/cmd/--repository.sh
@@ -0,0 +1,48 @@
+# Documentation defined in Library/Homebrew/cmd/--repository.rb
+
+# HOMEBREW_REPOSITORY, HOMEBREW_LIBRARY are set by brew.sh
+# shellcheck disable=SC2154
+
+tap_path() {
+  local tap="$1"
+  local user
+  local repo
+  local part
+
+  if [[ "${tap}" != *"/"* ]]
+  then
+    odie "Invalid tap name: ${tap}"
+  fi
+
+  user="$(echo "${tap%%/*}" | tr '[:upper:]' '[:lower:]')"
+  repo="$(echo "${tap#*/}" | tr '[:upper:]' '[:lower:]')"
+
+  for part in "${user}" "${repo}"
+  do
+    if [[ -z "${part}" || "${part}" == *"/"* ]]
+    then
+      odie "Invalid tap name: ${tap}"
+    fi
+  done
+
+  repo="${repo#@(home|linux)brew-}"
+  echo "${HOMEBREW_LIBRARY}/Taps/${user}/homebrew-${repo}"
+}
+
+homebrew---repository() {
+  local tap
+
+  if [[ "$#" -eq 0 ]]
+  then
+    echo "${HOMEBREW_REPOSITORY}"
+    return
+  fi
+
+  (
+    shopt -s extglob
+    for tap in "$@"
+    do
+      tap_path "${tap}"
+    done
+  )
+}
diff --git a/Library/Homebrew/cmd/--version.rb b/Library/Homebrew/cmd/--version.rb
new file mode 100644
index 0000000000000..bcaca65d2c879
--- /dev/null
+++ b/Library/Homebrew/cmd/--version.rb
@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "shell_command"
+
+module Homebrew
+  module Cmd
+    class Version < AbstractCommand
+      include ShellCommand
+
+      sig { override.returns(String) }
+      def self.command_name = "--version"
+
+      cmd_args do
+        description <<~EOS
+          Print the version numbers of Homebrew, Homebrew/homebrew-core and
+          Homebrew/homebrew-cask (if tapped) to standard output.
+        EOS
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cmd/--version.sh b/Library/Homebrew/cmd/--version.sh
index caf3ea62571d9..1b30d0e552a71 100644
--- a/Library/Homebrew/cmd/--version.sh
+++ b/Library/Homebrew/cmd/--version.sh
@@ -1,6 +1,4 @@
-#:  * `--version`, `-v`
-#:
-#:  Print the version numbers of Homebrew, Homebrew/homebrew-core and Homebrew/homebrew-cask (if tapped) to standard output.
+# Documentation defined in Library/Homebrew/cmd/--version.rb
 
 # HOMEBREW_CORE_REPOSITORY, HOMEBREW_CASK_REPOSITORY, HOMEBREW_VERSION are set by brew.sh
 # shellcheck disable=SC2154
@@ -27,7 +25,11 @@ version_string() {
 
 homebrew-version() {
   echo "Homebrew ${HOMEBREW_VERSION}"
-  echo "Homebrew/homebrew-core $(version_string "${HOMEBREW_CORE_REPOSITORY}")"
+
+  if [[ -n "${HOMEBREW_NO_INSTALL_FROM_API}" || -d "${HOMEBREW_CORE_REPOSITORY}" ]]
+  then
+    echo "Homebrew/homebrew-core $(version_string "${HOMEBREW_CORE_REPOSITORY}")"
+  fi
 
   if [[ -d "${HOMEBREW_CASK_REPOSITORY}" ]]
   then
diff --git a/Library/Homebrew/cmd/analytics.rb b/Library/Homebrew/cmd/analytics.rb
index b9c3badfd0187..6531b823c8bae 100644
--- a/Library/Homebrew/cmd/analytics.rb
+++ b/Library/Homebrew/cmd/analytics.rb
@@ -1,53 +1,48 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class Analytics < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Control Homebrew's anonymous aggregate user behaviour analytics.
+          Read more at <https://docs.brew.sh/Analytics>.
 
-  module_function
+          `brew analytics` [`state`]:
+          Display the current state of Homebrew's analytics.
 
-  sig { returns(CLI::Parser) }
-  def analytics_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Control Homebrew's anonymous aggregate user behaviour analytics.
-        Read more at <https://docs.brew.sh/Analytics>.
+          `brew analytics` (`on`|`off`):
+          Turn Homebrew's analytics on or off respectively.
+        EOS
 
-        `brew analytics` [`state`]:
-        Display the current state of Homebrew's analytics.
-
-        `brew analytics` (`on`|`off`):
-        Turn Homebrew's analytics on or off respectively.
-
-        `brew analytics regenerate-uuid`:
-        Regenerate the UUID used for Homebrew's analytics.
-      EOS
-
-      named_args %w[state on off regenerate-uuid], max: 1
-    end
-  end
-
-  def analytics
-    args = analytics_args.parse
+        named_args %w[state on off regenerate-uuid], max: 1
+      end
 
-    case args.named.first
-    when nil, "state"
-      if Utils::Analytics.disabled?
-        puts "Analytics are disabled."
-      else
-        puts "Analytics are enabled."
-        puts "UUID: #{Utils::Analytics.uuid}" if Utils::Analytics.uuid.present?
+      sig { override.void }
+      def run
+        case args.named.first
+        when nil, "state"
+          if Utils::Analytics.disabled?
+            puts "InfluxDB analytics are disabled."
+          else
+            puts "InfluxDB analytics are enabled."
+          end
+          puts "Google Analytics were destroyed."
+        when "on"
+          Utils::Analytics.enable!
+        when "off"
+          Utils::Analytics.disable!
+        when "regenerate-uuid"
+          Utils::Analytics.delete_uuid!
+          opoo "Homebrew no longer uses an analytics UUID so this has been deleted!"
+          puts "brew analytics regenerate-uuid is no longer necessary."
+        else
+          raise UsageError, "unknown subcommand: #{args.named.first}"
+        end
       end
-    when "on"
-      Utils::Analytics.enable!
-    when "off"
-      Utils::Analytics.disable!
-    when "regenerate-uuid"
-      Utils::Analytics.regenerate_uuid!
-    else
-      raise UsageError, "unknown subcommand: #{args.named.first}"
     end
   end
 end
diff --git a/Library/Homebrew/cmd/autoremove.rb b/Library/Homebrew/cmd/autoremove.rb
index a80cb4ae49fb4..45f22bde1f816 100644
--- a/Library/Homebrew/cmd/autoremove.rb
+++ b/Library/Homebrew/cmd/autoremove.rb
@@ -1,56 +1,26 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "formula"
-require "cli/parser"
-require "uninstall"
+require "abstract_command"
+require "cleanup"
 
 module Homebrew
-  module_function
-
-  def autoremove_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Uninstall formulae that were only installed as a dependency of another formula and are now no longer needed.
-      EOS
-      switch "-n", "--dry-run",
-             description: "List what would be uninstalled, but do not actually uninstall anything."
-
-      named_args :none
-    end
-  end
-
-  def get_removable_formulae(formulae)
-    removable_formulae = Formula.installed_formulae_with_no_dependents(formulae).reject do |f|
-      Tab.for_keg(f.any_installed_keg).installed_on_request
+  module Cmd
+    class Autoremove < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Uninstall formulae that were only installed as a dependency of another formula and are now no longer needed.
+        EOS
+        switch "-n", "--dry-run",
+               description: "List what would be uninstalled, but do not actually uninstall anything."
+
+        named_args :none
+      end
+
+      sig { override.void }
+      def run
+        Cleanup.autoremove(dry_run: args.dry_run?)
+      end
     end
-
-    removable_formulae += get_removable_formulae(formulae - removable_formulae) if removable_formulae.present?
-
-    removable_formulae
-  end
-
-  def autoremove
-    args = autoremove_args.parse
-
-    removable_formulae = get_removable_formulae(Formula.installed)
-
-    if (casks = Cask::Caskroom.casks.presence)
-      removable_formulae -= casks.flat_map { |cask| cask.depends_on[:formula] }
-                                 .compact
-                                 .map { |f| Formula[f] }
-                                 .flat_map { |f| [f, *f.runtime_formula_dependencies].compact }
-    end
-    return if removable_formulae.blank?
-
-    formulae_names = removable_formulae.map(&:full_name).sort
-
-    verb = args.dry_run? ? "Would uninstall" : "Uninstalling"
-    oh1 "#{verb} #{formulae_names.count} unneeded #{"formula".pluralize(formulae_names.count)}:"
-    puts formulae_names.join("\n")
-    return if args.dry_run?
-
-    kegs_by_rack = removable_formulae.map(&:any_installed_keg).group_by(&:rack)
-    Uninstall.uninstall_kegs(kegs_by_rack)
   end
 end
diff --git a/Library/Homebrew/cmd/casks.rb b/Library/Homebrew/cmd/casks.rb
new file mode 100644
index 0000000000000..4bc6ace0e88eb
--- /dev/null
+++ b/Library/Homebrew/cmd/casks.rb
@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "shell_command"
+
+# This Ruby command exists to allow generation of completions for the Bash
+# version. It is not meant to be run.
+module Homebrew
+  module Cmd
+    class Casks < AbstractCommand
+      include ShellCommand
+
+      cmd_args do
+        description "List all locally installable casks including short names."
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cmd/casks.sh b/Library/Homebrew/cmd/casks.sh
index aa3a75cf2bb2e..b9fe0f5729639 100644
--- a/Library/Homebrew/cmd/casks.sh
+++ b/Library/Homebrew/cmd/casks.sh
@@ -1,12 +1,25 @@
-#:  * `casks`
-#:
-#:  List all locally installable casks including short names.
-#:
+# Documentation defined in Library/Homebrew/cmd/casks.rb
 
 # HOMEBREW_LIBRARY is set in bin/brew
 # shellcheck disable=SC2154
 source "${HOMEBREW_LIBRARY}/Homebrew/items.sh"
 
 homebrew-casks() {
-  homebrew-items 'Formula' 's|/Casks/|/|' '^homebrew/cask'
+  local find_include_filter='*/Casks/*\.rb'
+  local sed_filter='s|/Casks/(.+/)?|/|'
+  local grep_filter='^homebrew/cask'
+
+  # HOMEBREW_CACHE is set by brew.sh
+  # shellcheck disable=SC2154
+  if [[ -z "${HOMEBREW_NO_INSTALL_FROM_API}" &&
+        -f "${HOMEBREW_CACHE}/api/cask_names.txt" ]]
+  then
+    {
+      cat "${HOMEBREW_CACHE}/api/cask_names.txt"
+      echo
+      homebrew-items "${find_include_filter}" '.*/homebrew/homebrew-cask/.*' "${sed_filter}" "${grep_filter}"
+    } | sort -uf
+  else
+    homebrew-items "${find_include_filter}" '^\b$' "${sed_filter}" "${grep_filter}"
+  fi
 }
diff --git a/Library/Homebrew/cmd/cleanup.rb b/Library/Homebrew/cmd/cleanup.rb
index 79d41232f3f62..4d75cfaa5ee34 100644
--- a/Library/Homebrew/cmd/cleanup.rb
+++ b/Library/Homebrew/cmd/cleanup.rb
@@ -1,76 +1,72 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "cleanup"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class CleanupCmd < AbstractCommand
+      cmd_args do
+        days = Homebrew::EnvConfig::ENVS[:HOMEBREW_CLEANUP_MAX_AGE_DAYS]&.dig(:default)
+        description <<~EOS
+          Remove stale lock files and outdated downloads for all formulae and casks,
+          and remove old versions of installed formulae. If arguments are specified,
+          only do this for the given formulae and casks. Removes all downloads more than
+          #{days} days old. This can be adjusted with `HOMEBREW_CLEANUP_MAX_AGE_DAYS`.
+        EOS
+        flag   "--prune=",
+               description: "Remove all cache files older than specified <days>. " \
+                            "If you want to remove everything, use `--prune=all`."
+        switch "-n", "--dry-run",
+               description: "Show what would be removed, but do not actually remove anything."
+        switch "-s", "--scrub",
+               description: "Scrub the cache, including downloads for even the latest versions. " \
+                            "Note that downloads for any installed formulae or casks will still not be deleted. " \
+                            "If you want to delete those too: `rm -rf \"$(brew --cache)\"`"
+        switch "--prune-prefix",
+               description: "Only prune the symlinks and directories from the prefix and remove no other files."
 
-  module_function
+        named_args [:formula, :cask]
+      end
 
-  sig { returns(CLI::Parser) }
-  def cleanup_args
-    Homebrew::CLI::Parser.new do
-      days = Homebrew::EnvConfig::ENVS[:HOMEBREW_CLEANUP_MAX_AGE_DAYS][:default]
-      description <<~EOS
-        Remove stale lock files and outdated downloads for all formulae and casks,
-        and remove old versions of installed formulae. If arguments are specified,
-        only do this for the given formulae and casks. Removes all downloads more than
-        #{days} days old. This can be adjusted with `HOMEBREW_CLEANUP_MAX_AGE_DAYS`.
-      EOS
-      flag   "--prune=",
-             description: "Remove all cache files older than specified <days>. " \
-                          "If you want to remove everything, use `--prune=all`."
-      switch "-n", "--dry-run",
-             description: "Show what would be removed, but do not actually remove anything."
-      switch "-s",
-             description: "Scrub the cache, including downloads for even the latest versions. " \
-                          "Note that downloads for any installed formulae or casks will still not be deleted. " \
-                          "If you want to delete those too: `rm -rf \"$(brew --cache)\"`"
-      switch "--prune-prefix",
-             description: "Only prune the symlinks and directories from the prefix and remove no other files."
+      sig { override.void }
+      def run
+        days = args.prune.presence&.then do |prune|
+          case prune
+          when /\A\d+\Z/
+            prune.to_i
+          when "all"
+            0
+          else
+            raise UsageError, "`--prune` expects an integer or `all`."
+          end
+        end
 
-      named_args [:formula, :cask]
-    end
-  end
+        cleanup = Cleanup.new(*args.named, dry_run: args.dry_run?, scrub: args.s?, days:)
+        if args.prune_prefix?
+          cleanup.prune_prefix_symlinks_and_directories
+          return
+        end
 
-  def cleanup
-    args = cleanup_args.parse
+        cleanup.clean!(quiet: args.quiet?, periodic: false)
 
-    days = args.prune.presence&.then do |prune|
-      case prune
-      when /\A\d+\Z/
-        prune.to_i
-      when "all"
-        0
-      else
-        raise UsageError, "`--prune=` expects an integer or `all`."
-      end
-    end
+        unless cleanup.disk_cleanup_size.zero?
+          disk_space = disk_usage_readable(cleanup.disk_cleanup_size)
+          if args.dry_run?
+            ohai "This operation would free approximately #{disk_space} of disk space."
+          else
+            ohai "This operation has freed approximately #{disk_space} of disk space."
+          end
+        end
 
-    cleanup = Cleanup.new(*args.named, dry_run: args.dry_run?, scrub: args.s?, days: days)
-    if args.prune_prefix?
-      cleanup.prune_prefix_symlinks_and_directories
-      return
-    end
-
-    cleanup.clean!
+        return if cleanup.unremovable_kegs.empty?
 
-    unless cleanup.disk_cleanup_size.zero?
-      disk_space = disk_usage_readable(cleanup.disk_cleanup_size)
-      if args.dry_run?
-        ohai "This operation would free approximately #{disk_space} of disk space."
-      else
-        ohai "This operation has freed approximately #{disk_space} of disk space."
+        ofail <<~EOS
+          Could not cleanup old kegs! Fix your permissions on:
+            #{cleanup.unremovable_kegs.join "\n  "}
+        EOS
       end
     end
-
-    return if cleanup.unremovable_kegs.empty?
-
-    ofail <<~EOS
-      Could not cleanup old kegs! Fix your permissions on:
-        #{cleanup.unremovable_kegs.join "\n  "}
-    EOS
   end
 end
diff --git a/Library/Homebrew/cmd/command.rb b/Library/Homebrew/cmd/command.rb
new file mode 100644
index 0000000000000..8b4753e933c11
--- /dev/null
+++ b/Library/Homebrew/cmd/command.rb
@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "commands"
+
+module Homebrew
+  module Cmd
+    class Command < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Display the path to the file being used when invoking `brew` <cmd>.
+        EOS
+
+        named_args :command, min: 1
+      end
+
+      sig { override.void }
+      def run
+        args.named.each do |cmd|
+          path = Commands.path(cmd)
+          odie "Unknown command: brew #{cmd}" unless path
+          puts path
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cmd/commands.rb b/Library/Homebrew/cmd/commands.rb
index ea41c1efa3a3b..6ec4cf889e6f3 100644
--- a/Library/Homebrew/cmd/commands.rb
+++ b/Library/Homebrew/cmd/commands.rb
@@ -1,50 +1,46 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def commands_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Show lists of built-in and external commands.
-      EOS
-      switch "-q", "--quiet",
-             description: "List only the names of commands without category headers."
-      switch "--include-aliases",
-             depends_on:  "--quiet",
-             description: "Include aliases of internal commands."
-
-      named_args :none
-    end
-  end
-
-  def commands
-    args = commands_args.parse
-
-    if args.quiet?
-      puts Formatter.columns(Commands.commands(aliases: args.include_aliases?))
-      return
-    end
-
-    prepend_separator = false
-
-    {
-      "Built-in commands"           => Commands.internal_commands,
-      "Built-in developer commands" => Commands.internal_developer_commands,
-      "External commands"           => Commands.external_commands,
-    }.each do |title, commands|
-      next if commands.blank?
-
-      puts if prepend_separator
-      ohai title, Formatter.columns(commands)
-
-      prepend_separator ||= true
+  module Cmd
+    class CommandsCmd < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Show lists of built-in and external commands.
+        EOS
+        switch "-q", "--quiet",
+               description: "List only the names of commands without category headers."
+        switch "--include-aliases",
+               depends_on:  "--quiet",
+               description: "Include aliases of internal commands."
+
+        named_args :none
+      end
+
+      sig { override.void }
+      def run
+        if args.quiet?
+          puts Formatter.columns(Commands.commands(aliases: args.include_aliases?))
+          return
+        end
+
+        prepend_separator = T.let(false, T::Boolean)
+
+        {
+          "Built-in commands"           => Commands.internal_commands,
+          "Built-in developer commands" => Commands.internal_developer_commands,
+          "External commands"           => Commands.external_commands,
+        }.each do |title, commands|
+          next if commands.blank?
+
+          puts if prepend_separator
+          ohai title, Formatter.columns(commands)
+
+          prepend_separator ||= true
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cmd/completions.rb b/Library/Homebrew/cmd/completions.rb
index 4003dd0de09f2..2fd15596ceebf 100644
--- a/Library/Homebrew/cmd/completions.rb
+++ b/Library/Homebrew/cmd/completions.rb
@@ -1,50 +1,46 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 require "completions"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class CompletionsCmd < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Control whether Homebrew automatically links external tap shell completion files.
+          Read more at <https://docs.brew.sh/Shell-Completion>.
 
-  module_function
+          `brew completions` [`state`]:
+          Display the current state of Homebrew's completions.
 
-  sig { returns(CLI::Parser) }
-  def completions_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Control whether Homebrew automatically links external tap shell completion files.
-        Read more at <https://docs.brew.sh/Shell-Completion>.
+          `brew completions` (`link`|`unlink`):
+          Link or unlink Homebrew's completions.
+        EOS
 
-        `brew completions` [`state`]:
-        Display the current state of Homebrew's completions.
-
-        `brew completions` (`link`|`unlink`):
-        Link or unlink Homebrew's completions.
-      EOS
-
-      named_args %w[state link unlink], max: 1
-    end
-  end
-
-  def completions
-    args = completions_args.parse
+        named_args %w[state link unlink], max: 1
+      end
 
-    case args.named.first
-    when nil, "state"
-      if Completions.link_completions?
-        puts "Completions are linked."
-      else
-        puts "Completions are not linked."
+      sig { override.void }
+      def run
+        case args.named.first
+        when nil, "state"
+          if Completions.link_completions?
+            puts "Completions are linked."
+          else
+            puts "Completions are not linked."
+          end
+        when "link"
+          Completions.link!
+          puts "Completions are now linked."
+        when "unlink"
+          Completions.unlink!
+          puts "Completions are no longer linked."
+        else
+          raise UsageError, "unknown subcommand: #{args.named.first}"
+        end
       end
-    when "link"
-      Completions.link!
-      puts "Completions are now linked."
-    when "unlink"
-      Completions.unlink!
-      puts "Completions are no longer linked."
-    else
-      raise UsageError, "unknown subcommand: #{args.named.first}"
     end
   end
 end
diff --git a/Library/Homebrew/cmd/config.rb b/Library/Homebrew/cmd/config.rb
index 7271881e561b5..515139b7ee637 100644
--- a/Library/Homebrew/cmd/config.rb
+++ b/Library/Homebrew/cmd/config.rb
@@ -1,29 +1,25 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "system_config"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class Config < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Show Homebrew and system configuration info useful for debugging. If you file
+          a bug report, you will be required to provide this information.
+        EOS
 
-  module_function
+        named_args :none
+      end
 
-  sig { returns(CLI::Parser) }
-  def config_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Show Homebrew and system configuration info useful for debugging. If you file
-        a bug report, you will be required to provide this information.
-      EOS
-
-      named_args :none
+      sig { override.void }
+      def run
+        SystemConfig.dump_verbose_config
+      end
     end
   end
-
-  def config
-    config_args.parse
-
-    SystemConfig.dump_verbose_config
-  end
 end
diff --git a/Library/Homebrew/cmd/deps.rb b/Library/Homebrew/cmd/deps.rb
index e684091929962..fab09e12ac05e 100644
--- a/Library/Homebrew/cmd/deps.rb
+++ b/Library/Homebrew/cmd/deps.rb
@@ -1,312 +1,351 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
-require "ostruct"
-require "cli/parser"
 require "cask/caskroom"
 require "dependencies_helpers"
 
 module Homebrew
-  extend T::Sig
-
-  extend DependenciesHelpers
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def deps_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Show dependencies for <formula>. Additional options specific to <formula>
-        may be appended to the command. When given multiple formula arguments,
-        show the intersection of dependencies for each formula.
-      EOS
-      switch "-n",
-             description: "Sort dependencies in topological order."
-      switch "--1",
-             description: "Only show dependencies one level down, instead of recursing."
-      switch "--union",
-             description: "Show the union of dependencies for multiple <formula>, instead of the intersection."
-      switch "--full-name",
-             description: "List dependencies by their full name."
-      switch "--include-build",
-             description: "Include `:build` dependencies for <formula>."
-      switch "--include-optional",
-             description: "Include `:optional` dependencies for <formula>."
-      switch "--include-test",
-             description: "Include `:test` dependencies for <formula> (non-recursive)."
-      switch "--skip-recommended",
-             description: "Skip `:recommended` dependencies for <formula>."
-      switch "--include-requirements",
-             description: "Include requirements in addition to dependencies for <formula>."
-      switch "--tree",
-             description: "Show dependencies as a tree. When given multiple formula arguments, " \
-                          "show individual trees for each formula."
-      switch "--graph",
-             description: "Show dependencies as a directed graph."
-      switch "--dot",
-             depends_on:  "--graph",
-             description: "Show text-based graph description in DOT format."
-      switch "--annotate",
-             description: "Mark any build, test, optional, or recommended dependencies as " \
-                          "such in the output."
-      switch "--installed",
-             description: "List dependencies for formulae that are currently installed. If <formula> is " \
-                          "specified, list only its dependencies that are currently installed."
-      switch "--all",
-             description: "List dependencies for all available formulae."
-      switch "--for-each",
-             description: "Switch into the mode used by the `--all` option, but only list dependencies " \
-                          "for each provided <formula>, one formula per line. This is used for " \
-                          "debugging the `--installed`/`--all` display mode."
-      switch "--formula", "--formulae",
-             depends_on:  "--installed",
-             description: "Treat all named arguments as formulae."
-      switch "--cask", "--casks",
-             depends_on:  "--installed",
-             description: "Treat all named arguments as casks."
-
-      conflicts "--tree", "--graph"
-      conflicts "--installed", "--all"
-      conflicts "--formula", "--cask"
-      formula_options
-
-      named_args [:formula, :cask]
-    end
-  end
-
-  def deps
-    args = deps_args.parse
-
-    Formulary.enable_factory_cache!
-
-    recursive = !args.send(:"1?")
-    installed = args.installed? || dependents(args.named.to_formulae_and_casks).all?(&:any_version_installed?)
-
-    @use_runtime_dependencies = installed && recursive &&
-                                !args.tree? &&
-                                !args.graph? &&
-                                !args.include_build? &&
-                                !args.include_test? &&
-                                !args.include_optional? &&
-                                !args.skip_recommended?
-
-    if args.tree? || args.graph?
-      dependents = if args.named.present?
-        sorted_dependents(args.named.to_formulae_and_casks)
-      elsif args.installed?
-        case args.only_formula_or_cask
-        when :formula
-          sorted_dependents(Formula.installed)
-        when :cask
-          sorted_dependents(Cask::Caskroom.casks)
-        else
-          sorted_dependents(Formula.installed + Cask::Caskroom.casks)
-        end
-      else
-        raise FormulaUnspecifiedError
+  module Cmd
+    class Deps < AbstractCommand
+      include DependenciesHelpers
+      cmd_args do
+        description <<~EOS
+          Show dependencies for <formula>. When given multiple formula arguments,
+          show the intersection of dependencies for each formula. By default, `deps`
+          shows all required and recommended dependencies.
+
+          If any version of each formula argument is installed and no other options
+          are passed, this command displays their actual runtime dependencies (similar
+          to `brew linkage`), which may differ from the current versions' stated
+          dependencies if the installed versions are outdated.
+
+          *Note:* `--missing` and `--skip-recommended` have precedence over `--include-*`.
+        EOS
+        switch "-n", "--topological",
+               description: "Sort dependencies in topological order."
+        switch "-1", "--direct", "--declared", "--1",
+               description: "Show only the direct dependencies declared in the formula."
+        switch "--union",
+               description: "Show the union of dependencies for multiple <formula>, instead of the intersection."
+        switch "--full-name",
+               description: "List dependencies by their full name."
+        switch "--include-build",
+               description: "Include `:build` dependencies for <formula>."
+        switch "--include-optional",
+               description: "Include `:optional` dependencies for <formula>."
+        switch "--include-test",
+               description: "Include `:test` dependencies for <formula> (non-recursive)."
+        switch "--skip-recommended",
+               description: "Skip `:recommended` dependencies for <formula>."
+        switch "--include-requirements",
+               description: "Include requirements in addition to dependencies for <formula>."
+        switch "--tree",
+               description: "Show dependencies as a tree. When given multiple formula arguments, " \
+                            "show individual trees for each formula."
+        switch "--graph",
+               description: "Show dependencies as a directed graph."
+        switch "--dot",
+               depends_on:  "--graph",
+               description: "Show text-based graph description in DOT format."
+        switch "--annotate",
+               description: "Mark any build, test, implicit, optional, or recommended dependencies as " \
+                            "such in the output."
+        switch "--installed",
+               description: "List dependencies for formulae that are currently installed. If <formula> is " \
+                            "specified, list only its dependencies that are currently installed."
+        switch "--missing",
+               description: "Show only missing dependencies."
+        switch "--eval-all",
+               description: "Evaluate all available formulae and casks, whether installed or not, to list " \
+                            "their dependencies."
+        switch "--for-each",
+               description: "Switch into the mode used by the `--eval-all` option, but only list dependencies " \
+                            "for each provided <formula>, one formula per line. This is used for " \
+                            "debugging the `--installed`/`--eval-all` display mode."
+        switch "--HEAD",
+               description: "Show dependencies for HEAD version instead of stable version."
+        flag   "--os=",
+               description: "Show dependencies for the given operating system."
+        flag   "--arch=",
+               description: "Show dependencies for the given CPU architecture."
+        switch "--formula", "--formulae",
+               description: "Treat all named arguments as formulae."
+        switch "--cask", "--casks",
+               description: "Treat all named arguments as casks."
+
+        conflicts "--tree", "--graph"
+        conflicts "--installed", "--missing"
+        conflicts "--installed", "--eval-all"
+        conflicts "--formula", "--cask"
+        formula_options
+
+        named_args [:formula, :cask]
       end
 
-      if args.graph?
-        dot_code = dot_code(dependents, recursive: recursive, args: args)
-        if args.dot?
-          puts dot_code
-        else
-          exec_browser "https://dreampuf.github.io/GraphvizOnline/##{ERB::Util.url_encode(dot_code)}"
+      sig { override.void }
+      def run
+        raise UsageError, "`brew deps --os=all` is not supported" if args.os == "all"
+        raise UsageError, "`brew deps --arch=all` is not supported" if args.arch == "all"
+
+        os, arch = T.must(args.os_arch_combinations.first)
+        all = args.eval_all?
+
+        Formulary.enable_factory_cache!
+
+        SimulateSystem.with(os:, arch:) do
+          recursive = !args.direct?
+          installed = args.installed? || dependents(args.named.to_formulae_and_casks).all?(&:any_version_installed?)
+
+          @use_runtime_dependencies = installed && recursive &&
+                                      !args.tree? &&
+                                      !args.graph? &&
+                                      !args.HEAD? &&
+                                      !args.include_build? &&
+                                      !args.include_test? &&
+                                      !args.include_optional? &&
+                                      !args.skip_recommended? &&
+                                      !args.missing? &&
+                                      args.os.nil? &&
+                                      args.arch.nil?
+
+          if args.tree? || args.graph?
+            dependents = if args.named.present?
+              sorted_dependents(args.named.to_formulae_and_casks)
+            elsif args.installed?
+              case args.only_formula_or_cask
+              when :formula
+                sorted_dependents(Formula.installed)
+              when :cask
+                sorted_dependents(Cask::Caskroom.casks)
+              else
+                sorted_dependents(Formula.installed + Cask::Caskroom.casks)
+              end
+            else
+              raise FormulaUnspecifiedError
+            end
+
+            if args.graph?
+              dot_code = dot_code(dependents, recursive:)
+              if args.dot?
+                puts dot_code
+              else
+                exec_browser "https://dreampuf.github.io/GraphvizOnline/##{ERB::Util.url_encode(dot_code)}"
+              end
+              return
+            end
+
+            puts_deps_tree(dependents, recursive:)
+            return
+          elsif all
+            puts_deps(sorted_dependents(
+                        Formula.all(eval_all: args.eval_all?) + Cask::Cask.all(eval_all: args.eval_all?),
+                      ), recursive:)
+            return
+          elsif !args.no_named? && args.for_each?
+            puts_deps(sorted_dependents(args.named.to_formulae_and_casks), recursive:)
+            return
+          end
+
+          if args.no_named?
+            raise FormulaUnspecifiedError unless args.installed?
+
+            sorted_dependents_formulae_and_casks = case args.only_formula_or_cask
+            when :formula
+              sorted_dependents(Formula.installed)
+            when :cask
+              sorted_dependents(Cask::Caskroom.casks)
+            else
+              sorted_dependents(Formula.installed + Cask::Caskroom.casks)
+            end
+            puts_deps(sorted_dependents_formulae_and_casks, recursive:)
+            return
+          end
+
+          dependents = dependents(args.named.to_formulae_and_casks)
+          check_head_spec(dependents) if args.HEAD?
+
+          all_deps = deps_for_dependents(dependents, recursive:, &(args.union? ? :| : :&))
+          condense_requirements(all_deps)
+          all_deps.map! { |d| dep_display_name(d) }
+          all_deps.uniq!
+          all_deps.sort! unless args.topological?
+          puts all_deps
         end
-        return
       end
 
-      puts_deps_tree dependents, recursive: recursive, args: args
-      return
-    elsif args.all?
-      puts_deps sorted_dependents(Formula.all + Cask::Cask.all), recursive: recursive, args: args
-      return
-    elsif !args.no_named? && args.for_each?
-      puts_deps sorted_dependents(args.named.to_formulae_and_casks), recursive: recursive, args: args
-      return
-    end
+      private
 
-    if args.no_named?
-      raise FormulaUnspecifiedError unless args.installed?
-
-      sorted_dependents_formulae_and_casks = case args.only_formula_or_cask
-      when :formula
-        sorted_dependents(Formula.installed)
-      when :cask
-        sorted_dependents(Cask::Caskroom.casks)
-      else
-        sorted_dependents(Formula.installed + Cask::Caskroom.casks)
+      def sorted_dependents(formulae_or_casks)
+        dependents(formulae_or_casks).sort_by(&:name)
       end
-      puts_deps sorted_dependents_formulae_and_casks, recursive: recursive, args: args
-      return
-    end
-
-    dependents = dependents(args.named.to_formulae_and_casks)
 
-    all_deps = deps_for_dependents(dependents, recursive: recursive, args: args, &(args.union? ? :| : :&))
-    condense_requirements(all_deps, args: args)
-    all_deps.map! { |d| dep_display_name(d, args: args) }
-    all_deps.uniq!
-    all_deps.sort! unless args.n?
-    puts all_deps
-  end
-
-  def sorted_dependents(formulae_or_casks)
-    dependents(formulae_or_casks).sort_by(&:name)
-  end
-
-  def condense_requirements(deps, args:)
-    deps.select! { |dep| dep.is_a?(Dependency) } unless args.include_requirements?
-    deps.select! { |dep| dep.is_a?(Requirement) || dep.installed? } if args.installed?
-  end
-
-  def dep_display_name(dep, args:)
-    str = if dep.is_a? Requirement
-      if args.include_requirements?
-        ":#{dep.display_s}"
-      else
-        # This shouldn't happen, but we'll put something here to help debugging
-        "::#{dep.name}"
+      def condense_requirements(deps)
+        deps.select! { |dep| dep.is_a?(Dependency) } unless args.include_requirements?
+        deps.select! { |dep| dep.is_a?(Requirement) || dep.installed? } if args.installed?
       end
-    elsif args.full_name?
-      dep.to_formula.full_name
-    else
-      dep.name
-    end
 
-    if args.annotate?
-      str = "#{str} " if args.tree?
-      str = "#{str} [build]" if dep.build?
-      str = "#{str} [test]" if dep.test?
-      str = "#{str} [optional]" if dep.optional?
-      str = "#{str} [recommended]" if dep.recommended?
-    end
+      def dep_display_name(dep)
+        str = if dep.is_a? Requirement
+          if args.include_requirements?
+            ":#{dep.display_s}"
+          else
+            # This shouldn't happen, but we'll put something here to help debugging
+            "::#{dep.name}"
+          end
+        elsif args.full_name?
+          dep.to_formula.full_name
+        else
+          dep.name
+        end
 
-    str
-  end
+        if args.annotate?
+          str = "#{str} " if args.tree?
+          str = "#{str} [build]" if dep.build?
+          str = "#{str} [test]" if dep.test?
+          str = "#{str} [optional]" if dep.optional?
+          str = "#{str} [recommended]" if dep.recommended?
+          str = "#{str} [implicit]" if dep.implicit?
+        end
 
-  def deps_for_dependent(d, args:, recursive: false)
-    includes, ignores = args_includes_ignores(args)
+        str
+      end
 
-    deps = d.runtime_dependencies if @use_runtime_dependencies
+      def deps_for_dependent(dependency, recursive: false)
+        includes, ignores = args_includes_ignores(args)
 
-    if recursive
-      deps ||= recursive_includes(Dependency, d, includes, ignores)
-      reqs   = recursive_includes(Requirement, d, includes, ignores)
-    else
-      deps ||= reject_ignores(d.deps, ignores, includes)
-      reqs   = reject_ignores(d.requirements, ignores, includes)
-    end
+        deps = dependency.runtime_dependencies if @use_runtime_dependencies
 
-    deps + reqs.to_a
-  end
+        if recursive
+          deps ||= recursive_includes(Dependency, dependency, includes, ignores)
+          reqs   = recursive_includes(Requirement, dependency, includes, ignores)
+        else
+          deps ||= select_includes(dependency.deps, ignores, includes)
+          reqs   = select_includes(dependency.requirements, ignores, includes)
+        end
 
-  def deps_for_dependents(dependents, args:, recursive: false, &block)
-    dependents.map { |d| deps_for_dependent(d, recursive: recursive, args: args) }.reduce(&block)
-  end
+        deps + reqs.to_a
+      end
 
-  def puts_deps(dependents, args:, recursive: false)
-    dependents.each do |dependent|
-      deps = deps_for_dependent(dependent, recursive: recursive, args: args)
-      condense_requirements(deps, args: args)
-      deps.sort_by!(&:name)
-      deps.map! { |d| dep_display_name(d, args: args) }
-      puts "#{dependent.full_name}: #{deps.join(" ")}"
-    end
-  end
+      def deps_for_dependents(dependents, recursive: false, &block)
+        dependents.map { |d| deps_for_dependent(d, recursive:) }.reduce(&block)
+      end
 
-  def dot_code(dependents, recursive:, args:)
-    dep_graph = {}
-    dependents.each do |d|
-      graph_deps(d, dep_graph: dep_graph, recursive: recursive, args: args)
-    end
+      def check_head_spec(dependents)
+        headless = dependents.select { |d| d.is_a?(Formula) && d.active_spec_sym != :head }
+                             .to_sentence two_words_connector: " or ", last_word_connector: " or "
+        opoo "No head spec for #{headless}, using stable spec instead" unless headless.empty?
+      end
 
-    dot_code = dep_graph.map do |d, deps|
-      deps.map do |dep|
-        attributes = []
-        attributes << "style = dotted" if dep.build?
-        attributes << "arrowhead = empty" if dep.test?
-        if dep.optional?
-          attributes << "color = red"
-        elsif dep.recommended?
-          attributes << "color = green"
+      def puts_deps(dependents, recursive: false)
+        check_head_spec(dependents) if args.HEAD?
+        dependents.each do |dependent|
+          deps = deps_for_dependent(dependent, recursive:)
+          condense_requirements(deps)
+          deps.sort_by!(&:name)
+          deps.map! { |d| dep_display_name(d) }
+          puts "#{dependent.full_name}: #{deps.join(" ")}"
         end
-        comment = " # #{dep.tags.map(&:inspect).join(", ")}" if dep.tags.any?
-        "  \"#{d.name}\" -> \"#{dep}\"#{" [#{attributes.join(", ")}]" if attributes.any?}#{comment}"
       end
-    end.flatten.join("\n")
-    "digraph {\n#{dot_code}\n}"
-  end
 
-  def graph_deps(f, dep_graph:, recursive:, args:)
-    return if dep_graph.key?(f)
+      def dot_code(dependents, recursive:)
+        dep_graph = {}
+        dependents.each do |d|
+          graph_deps(d, dep_graph:, recursive:)
+        end
 
-    dependables = dependables(f, args: args)
-    dep_graph[f] = dependables
-    return unless recursive
+        dot_code = dep_graph.map do |d, deps|
+          deps.map do |dep|
+            attributes = []
+            attributes << "style = dotted" if dep.build?
+            attributes << "arrowhead = empty" if dep.test?
+            if dep.optional?
+              attributes << "color = red"
+            elsif dep.recommended?
+              attributes << "color = green"
+            end
+            comment = " # #{dep.tags.map(&:inspect).join(", ")}" if dep.tags.any?
+            "  \"#{d.name}\" -> \"#{dep}\"#{" [#{attributes.join(", ")}]" if attributes.any?}#{comment}"
+          end
+        end.flatten.join("\n")
+        "digraph {\n#{dot_code}\n}"
+      end
 
-    dependables.each do |dep|
-      next unless dep.is_a? Dependency
+      def graph_deps(formula, dep_graph:, recursive:)
+        return if dep_graph.key?(formula)
 
-      graph_deps(Formulary.factory(dep.name),
-                 dep_graph: dep_graph,
-                 recursive: true,
-                 args:      args)
-    end
-  end
-
-  def puts_deps_tree(dependents, args:, recursive: false)
-    dependents.each do |d|
-      puts d.full_name
-      recursive_deps_tree(d, dep_stack: [], prefix: "", recursive: recursive, args: args)
-      puts
-    end
-  end
+        dependables = dependables(formula)
+        dep_graph[formula] = dependables
+        return unless recursive
 
-  def dependables(f, args:)
-    includes, ignores = args_includes_ignores(args)
-    deps = @use_runtime_dependencies ? f.runtime_dependencies : f.deps
-    deps = reject_ignores(deps, ignores, includes)
-    reqs = reject_ignores(f.requirements, ignores, includes) if args.include_requirements?
-    reqs ||= []
-    reqs + deps
-  end
+        dependables.each do |dep|
+          next unless dep.is_a? Dependency
 
-  def recursive_deps_tree(f, dep_stack:, prefix:, recursive:, args:)
-    dependables = dependables(f, args: args)
-    max = dependables.length - 1
-    dep_stack.push f.name
-    dependables.each_with_index do |dep, i|
-      tree_lines = if i == max
-        "└──"
-      else
-        "├──"
+          graph_deps(Formulary.factory(dep.name),
+                     dep_graph:,
+                     recursive: true)
+        end
       end
 
-      display_s = "#{tree_lines} #{dep_display_name(dep, args: args)}"
-      is_circular = dep_stack.include?(dep.name)
-      display_s = "#{display_s} (CIRCULAR DEPENDENCY)" if is_circular
-      puts "#{prefix}#{display_s}"
-
-      next if !recursive || is_circular
+      def puts_deps_tree(dependents, recursive: false)
+        check_head_spec(dependents) if args.HEAD?
+        dependents.each do |d|
+          puts d.full_name
+          recursive_deps_tree(d, dep_stack: [], prefix: "", recursive:)
+          puts
+        end
+      end
 
-      prefix_addition = if i == max
-        "    "
-      else
-        "│   "
+      def dependables(formula)
+        includes, ignores = args_includes_ignores(args)
+        deps = @use_runtime_dependencies ? formula.runtime_dependencies : formula.deps
+        deps = select_includes(deps, ignores, includes)
+        reqs = select_includes(formula.requirements, ignores, includes) if args.include_requirements?
+        reqs ||= []
+        reqs + deps
       end
 
-      next unless dep.is_a? Dependency
+      def recursive_deps_tree(formula, dep_stack:, prefix:, recursive:)
+        dependables = dependables(formula)
+        max = dependables.length - 1
+        dep_stack.push formula.name
+        dependables.each_with_index do |dep, i|
+          tree_lines = if i == max
+            "└──"
+          else
+            "├──"
+          end
+
+          display_s = "#{tree_lines} #{dep_display_name(dep)}"
+
+          # Detect circular dependencies and consider them a failure if present.
+          is_circular = dep_stack.include?(dep.name)
+          if is_circular
+            display_s = "#{display_s} (CIRCULAR DEPENDENCY)"
+            Homebrew.failed = true
+          end
+
+          puts "#{prefix}#{display_s}"
+
+          next if !recursive || is_circular
+
+          prefix_addition = if i == max
+            "    "
+          else
+            "│   "
+          end
+
+          next unless dep.is_a? Dependency
+
+          recursive_deps_tree(Formulary.factory(dep.name),
+                              dep_stack:,
+                              prefix:    prefix + prefix_addition,
+                              recursive: true)
+        end
 
-      recursive_deps_tree(Formulary.factory(dep.name),
-                          dep_stack: dep_stack,
-                          prefix:    prefix + prefix_addition,
-                          recursive: true,
-                          args:      args)
+        dep_stack.pop
+      end
     end
-
-    dep_stack.pop
   end
 end
diff --git a/Library/Homebrew/cmd/desc.rb b/Library/Homebrew/cmd/desc.rb
index d9976195432aa..b43d9235f8f7b 100644
--- a/Library/Homebrew/cmd/desc.rb
+++ b/Library/Homebrew/cmd/desc.rb
@@ -1,85 +1,74 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "descriptions"
 require "search"
 require "description_cache_store"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class Desc < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Display <formula>'s name and one-line description.
+          The cache is created on the first search, making that search slower than subsequent ones.
+        EOS
+        switch "-s", "--search",
+               description: "Search both names and descriptions for <text>. If <text> is flanked by " \
+                            "slashes, it is interpreted as a regular expression."
+        switch "-n", "--name",
+               description: "Search just names for <text>. If <text> is flanked by slashes, it is " \
+                            "interpreted as a regular expression."
+        switch "-d", "--description",
+               description: "Search just descriptions for <text>. If <text> is flanked by slashes, " \
+                            "it is interpreted as a regular expression."
+        switch "--eval-all",
+               description: "Evaluate all available formulae and casks, whether installed or not, to search their " \
+                            "descriptions. Implied if `HOMEBREW_EVAL_ALL` is set."
+        switch "--formula", "--formulae",
+               description: "Treat all named arguments as formulae."
+        switch "--cask", "--casks",
+               description: "Treat all named arguments as casks."
 
-  module_function
+        conflicts "--search", "--name", "--description"
 
-  extend Search
-
-  sig { returns(CLI::Parser) }
-  def desc_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Display <formula>'s name and one-line description.
-        Formula descriptions are cached; the cache is created on the
-        first search, making that search slower than subsequent ones.
-      EOS
-      switch "-s", "--search",
-             description: "Search both names and descriptions for <text>. If <text> is flanked by " \
-                          "slashes, it is interpreted as a regular expression."
-      switch "-n", "--name",
-             description: "Search just names for <text>. If <text> is flanked by slashes, it is " \
-                          "interpreted as a regular expression."
-      switch "-d", "--description",
-             description: "Search just descriptions for <text>. If <text> is flanked by slashes, " \
-                          "it is interpreted as a regular expression."
-      switch "--formula", "--formulae",
-             description: "Treat all named arguments as formulae."
-      switch "--cask", "--casks",
-             description: "Treat all named arguments as casks."
-
-      conflicts "--search", "--name", "--description"
-
-      named_args [:formula, :cask, :text_or_regex], min: 1
-    end
-  end
+        named_args [:formula, :cask, :text_or_regex], min: 1
+      end
 
-  def desc
-    args = desc_args.parse
+      sig { override.void }
+      def run
+        search_type = if args.search?
+          :either
+        elsif args.name?
+          :name
+        elsif args.description?
+          :desc
+        end
 
-    search_type = if args.search?
-      :either
-    elsif args.name?
-      :name
-    elsif args.description?
-      :desc
-    end
+        if search_type.present?
+          if !args.eval_all? && !Homebrew::EnvConfig.eval_all? && Homebrew::EnvConfig.no_install_from_api?
+            raise UsageError, "`brew desc --search` needs `--eval-all` passed or `HOMEBREW_EVAL_ALL` set!"
+          end
 
-    if search_type.blank?
-      desc = {}
-      args.named.to_formulae_and_casks.each do |formula_or_cask|
-        if formula_or_cask.is_a? Formula
-          desc[formula_or_cask.full_name] = formula_or_cask.desc
-        else
-          description = formula_or_cask.desc.presence || Formatter.warning("[no description]")
-          desc[formula_or_cask.full_name] = "(#{formula_or_cask.name.join(", ")}) #{description}"
-        end
-      end
-      Descriptions.new(desc).print
-    else
-      query = args.named.join(" ")
-      string_or_regex = query_regexp(query)
-      unless args.cask?
-        ohai "Formulae"
-        CacheStoreDatabase.use(:descriptions) do |db|
-          cache_store = DescriptionCacheStore.new(db)
-          Descriptions.search(string_or_regex, search_type, cache_store).print
+          query = args.named.join(" ")
+          string_or_regex = Search.query_regexp(query)
+          return Search.search_descriptions(string_or_regex, args, search_type:)
         end
-      end
-      unless args.formula?
-        puts unless args.cask?
-        ohai "Casks"
-        CacheStoreDatabase.use(:cask_descriptions) do |db|
-          cache_store = CaskDescriptionCacheStore.new(db)
-          Descriptions.search(string_or_regex, search_type, cache_store).print
+
+        desc = {}
+        args.named.to_formulae_and_casks.each do |formula_or_cask|
+          case formula_or_cask
+          when Formula
+            desc[formula_or_cask.full_name] = formula_or_cask.desc
+          when Cask::Cask
+            description = formula_or_cask.desc.presence || Formatter.warning("[no description]")
+            desc[formula_or_cask.full_name] = "(#{formula_or_cask.name.join(", ")}) #{description}"
+          else
+            raise TypeError, "Unsupported formula_or_cask type: #{formula_or_cask.class}"
+          end
         end
+        Descriptions.new(desc).print
       end
     end
   end
diff --git a/Library/Homebrew/cmd/developer.rb b/Library/Homebrew/cmd/developer.rb
old mode 100755
new mode 100644
index e967844b7a201..7788536ea95d9
--- a/Library/Homebrew/cmd/developer.rb
+++ b/Library/Homebrew/cmd/developer.rb
@@ -1,58 +1,55 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def developer_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Control Homebrew's developer mode. When developer mode is enabled,
-        `brew update` will update Homebrew to the latest commit on the `master`
-        branch instead of the latest stable version along with some other behaviour changes.
-
-        `brew developer` [`state`]:
-        Display the current state of Homebrew's developer mode.
-
-        `brew developer` (`on`|`off`):
-        Turn Homebrew's developer mode on or off respectively.
-      EOS
-
-      named_args %w[state on off], max: 1
-    end
-  end
-
-  def developer
-    args = developer_args.parse
-
-    env_vars = []
-    env_vars << "HOMEBREW_DEVELOPER" if Homebrew::EnvConfig.developer?
-    env_vars << "HOMEBREW_UPDATE_TO_TAG" if Homebrew::EnvConfig.update_to_tag?
-    env_vars.map! do |var|
-      "#{Tty.bold}#{var}#{Tty.reset}"
-    end
+  module Cmd
+    class Developer < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Control Homebrew's developer mode. When developer mode is enabled,
+          `brew update` will update Homebrew to the latest commit on the `master`
+          branch instead of the latest stable version along with some other behaviour changes.
+
+          `brew developer` [`state`]:
+          Display the current state of Homebrew's developer mode.
+
+          `brew developer` (`on`|`off`):
+          Turn Homebrew's developer mode on or off respectively.
+        EOS
+
+        named_args %w[state on off], max: 1
+      end
 
-    case args.named.first
-    when nil, "state"
-      if env_vars.any?
-        puts "Developer mode is enabled because #{env_vars.to_sentence} #{"is".pluralize(env_vars.count)} set."
-      elsif Homebrew::Settings.read("devcmdrun") == "true"
-        puts "Developer mode is enabled."
-      else
-        puts "Developer mode is disabled."
+      sig { override.void }
+      def run
+        env_vars = []
+        env_vars << "HOMEBREW_DEVELOPER" if Homebrew::EnvConfig.developer?
+        env_vars << "HOMEBREW_UPDATE_TO_TAG" if Homebrew::EnvConfig.update_to_tag?
+        env_vars.map! do |var|
+          "#{Tty.bold}#{var}#{Tty.reset}"
+        end
+
+        case args.named.first
+        when nil, "state"
+          if env_vars.any?
+            verb = (env_vars.count == 1) ? "is" : "are"
+            puts "Developer mode is enabled because #{env_vars.to_sentence} #{verb} set."
+          elsif Homebrew::EnvConfig.devcmdrun?
+            puts "Developer mode is enabled."
+          else
+            puts "Developer mode is disabled."
+          end
+        when "on"
+          Homebrew::Settings.write "devcmdrun", true
+        when "off"
+          Homebrew::Settings.delete "devcmdrun"
+          puts "To fully disable developer mode, you must unset #{env_vars.to_sentence}." if env_vars.any?
+        else
+          raise UsageError, "unknown subcommand: #{args.named.first}"
+        end
       end
-    when "on"
-      Homebrew::Settings.write "devcmdrun", true
-    when "off"
-      Homebrew::Settings.delete "devcmdrun"
-      puts "To fully disable developer mode, you must unset #{env_vars.to_sentence}." if env_vars.any?
-    else
-      raise UsageError, "unknown subcommand: #{args.named.first}"
     end
   end
 end
diff --git a/Library/Homebrew/cmd/docs.rb b/Library/Homebrew/cmd/docs.rb
new file mode 100644
index 0000000000000..9d5cedac9272a
--- /dev/null
+++ b/Library/Homebrew/cmd/docs.rb
@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+
+module Homebrew
+  module Cmd
+    class Docs < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Open Homebrew's online documentation at <#{HOMEBREW_DOCS_WWW}> in a browser.
+        EOS
+      end
+
+      sig { override.void }
+      def run
+        exec_browser HOMEBREW_DOCS_WWW
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cmd/doctor.rb b/Library/Homebrew/cmd/doctor.rb
index cb35eb83ae375..a273921d8e34a 100644
--- a/Library/Homebrew/cmd/doctor.rb
+++ b/Library/Homebrew/cmd/doctor.rb
@@ -1,83 +1,80 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "diagnostic"
-require "cli/parser"
 require "cask/caskroom"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class Doctor < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Check your system for potential problems. Will exit with a non-zero status
+          if any potential problems are found.
 
-  module_function
+          Please note that these warnings are just used to help the Homebrew maintainers
+          with debugging if you file an issue. If everything you use Homebrew for
+          is working fine: please don't worry or file an issue; just ignore this.
+        EOS
+        switch "--list-checks",
+               description: "List all audit methods, which can be run individually " \
+                            "if provided as arguments."
+        switch "-D", "--audit-debug",
+               description: "Enable debugging and profiling of audit methods."
 
-  sig { returns(CLI::Parser) }
-  def doctor_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Check your system for potential problems. Will exit with a non-zero status
-        if any potential problems are found. Please note that these warnings are just
-        used to help the Homebrew maintainers with debugging if you file an issue. If
-        everything you use Homebrew for is working fine: please don't worry or file
-        an issue; just ignore this.
-      EOS
-      switch "--list-checks",
-             description: "List all audit methods, which can be run individually " \
-                          "if provided as arguments."
-      switch "-D", "--audit-debug",
-             description: "Enable debugging and profiling of audit methods."
+        named_args :diagnostic_check
+      end
 
-      named_args :diagnostic_check
-    end
-  end
+      sig { override.void }
+      def run
+        Homebrew.inject_dump_stats!(Diagnostic::Checks, /^check_*/) if args.audit_debug?
 
-  def doctor
-    args = doctor_args.parse
+        checks = Diagnostic::Checks.new(verbose: args.verbose?)
 
-    inject_dump_stats!(Diagnostic::Checks, /^check_*/) if args.audit_debug?
+        if args.list_checks?
+          puts checks.all
+          return
+        end
 
-    checks = Diagnostic::Checks.new(verbose: args.verbose?)
+        if args.no_named?
+          slow_checks = %w[
+            check_for_broken_symlinks
+            check_missing_deps
+          ]
+          methods = (checks.all - slow_checks) + slow_checks
+          methods -= checks.cask_checks unless Cask::Caskroom.any_casks_installed?
+        else
+          methods = args.named
+        end
 
-    if args.list_checks?
-      puts checks.all
-      return
-    end
+        first_warning = T.let(true, T::Boolean)
+        methods.each do |method|
+          $stderr.puts Formatter.headline("Checking #{method}", color: :magenta) if args.debug?
+          unless checks.respond_to?(method)
+            ofail "No check available by the name: #{method}"
+            next
+          end
 
-    if args.no_named?
-      slow_checks = %w[
-        check_for_broken_symlinks
-        check_missing_deps
-      ]
-      methods = (checks.all - slow_checks) + slow_checks
-      methods -= checks.cask_checks unless Cask::Caskroom.any_casks_installed?
-    else
-      methods = args.named
-    end
+          out = checks.send(method)
+          next if out.blank?
 
-    first_warning = true
-    methods.each do |method|
-      $stderr.puts Formatter.headline("Checking #{method}", color: :magenta) if args.debug?
-      unless checks.respond_to?(method)
-        ofail "No check available by the name: #{method}"
-        next
-      end
+          if first_warning
+            $stderr.puts <<~EOS
+              #{Tty.bold}Please note that these warnings are just used to help the Homebrew maintainers
+              with debugging if you file an issue. If everything you use Homebrew for is
+              working fine: please don't worry or file an issue; just ignore this. Thanks!#{Tty.reset}
+            EOS
+          end
 
-      out = checks.send(method)
-      next if out.blank?
+          $stderr.puts
+          opoo out
+          Homebrew.failed = true
+          first_warning = false
+        end
 
-      if first_warning
-        $stderr.puts <<~EOS
-          #{Tty.bold}Please note that these warnings are just used to help the Homebrew maintainers
-          with debugging if you file an issue. If everything you use Homebrew for is
-          working fine: please don't worry or file an issue; just ignore this. Thanks!#{Tty.reset}
-        EOS
+        puts "Your system is ready to brew." if !Homebrew.failed? && !args.quiet?
       end
-
-      $stderr.puts
-      opoo out
-      Homebrew.failed = true
-      first_warning = false
     end
-
-    puts "Your system is ready to brew." unless Homebrew.failed?
   end
 end
diff --git a/Library/Homebrew/cmd/fetch.rb b/Library/Homebrew/cmd/fetch.rb
index 8fe94debabbf9..6bd826c48d25e 100644
--- a/Library/Homebrew/cmd/fetch.rb
+++ b/Library/Homebrew/cmd/fetch.rb
@@ -1,192 +1,337 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
 require "fetch"
-require "cli/parser"
 require "cask/download"
+require "retryable_download"
 
 module Homebrew
-  extend T::Sig
-
-  extend Fetch
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def fetch_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Download a bottle (if available) or source packages for <formula>e
-        and binaries for <cask>s. For files, also print SHA-256 checksums.
-      EOS
-      flag "--bottle-tag=",
-           description: "Download a bottle for given tag."
-      switch "--HEAD",
-             description: "Fetch HEAD version instead of stable version."
-      switch "-f", "--force",
-             description: "Remove a previously cached version and re-fetch."
-      switch "-v", "--verbose",
-             description: "Do a verbose VCS checkout, if the URL represents a VCS. This is useful for " \
-                          "seeing if an existing VCS cache has been updated."
-      switch "--retry",
-             description: "Retry if downloading fails or re-download if the checksum of a previously cached " \
-                          "version no longer matches."
-      switch "--deps",
-             description: "Also download dependencies for any listed <formula>."
-      switch "-s", "--build-from-source",
-             description: "Download source packages rather than a bottle."
-      switch "--build-bottle",
-             description: "Download source packages (for eventual bottling) rather than a bottle."
-      switch "--force-bottle",
-             description: "Download a bottle if it exists for the current or newest version of macOS, " \
-                          "even if it would not be used during installation."
-      switch "--[no-]quarantine",
-             description: "Disable/enable quarantining of downloads (default: enabled).",
-             env:         :cask_opts_quarantine
-      switch "--formula", "--formulae",
-             description: "Treat all named arguments as formulae."
-      switch "--cask", "--casks",
-             description: "Treat all named arguments as casks."
-
-      conflicts "--build-from-source", "--build-bottle", "--force-bottle", "--bottle-tag"
-      conflicts "--cask", "--HEAD"
-      conflicts "--cask", "--deps"
-      conflicts "--cask", "-s"
-      conflicts "--cask", "--build-bottle"
-      conflicts "--cask", "--force-bottle"
-      conflicts "--cask", "--bottle-tag"
-      conflicts "--formula", "--cask"
-
-      named_args [:formula, :cask], min: 1
-    end
-  end
+  module Cmd
+    class FetchCmd < AbstractCommand
+      include Fetch
+      FETCH_MAX_TRIES = 5
 
-  def fetch
-    args = fetch_args.parse
+      cmd_args do
+        description <<~EOS
+          Download a bottle (if available) or source packages for <formula>e
+          and binaries for <cask>s. For files, also print SHA-256 checksums.
+        EOS
+        flag   "--os=",
+               description: "Download for the given operating system. " \
+                            "(Pass `all` to download for all operating systems.)"
+        flag   "--arch=",
+               description: "Download for the given CPU architecture. " \
+                            "(Pass `all` to download for all architectures.)"
+        flag   "--bottle-tag=",
+               description: "Download a bottle for given tag."
+        flag "--concurrency=", description: "Number of concurrent downloads.", hidden: true
+        switch "--HEAD",
+               description: "Fetch HEAD version instead of stable version."
+        switch "-f", "--force",
+               description: "Remove a previously cached version and re-fetch."
+        switch "-v", "--verbose",
+               description: "Do a verbose VCS checkout, if the URL represents a VCS. This is useful for " \
+                            "seeing if an existing VCS cache has been updated."
+        switch "--retry",
+               description: "Retry if downloading fails or re-download if the checksum of a previously cached " \
+                            "version no longer matches. Tries at most #{FETCH_MAX_TRIES} times with " \
+                            "exponential backoff."
+        switch "--deps",
+               description: "Also download dependencies for any listed <formula>."
+        switch "-s", "--build-from-source",
+               description: "Download source packages rather than a bottle."
+        switch "--build-bottle",
+               description: "Download source packages (for eventual bottling) rather than a bottle."
+        switch "--force-bottle",
+               description: "Download a bottle if it exists for the current or newest version of macOS, " \
+                            "even if it would not be used during installation."
+        switch "--[no-]quarantine",
+               description: "Disable/enable quarantining of downloads (default: enabled).",
+               env:         :cask_opts_quarantine
+        switch "--formula", "--formulae",
+               description: "Treat all named arguments as formulae."
+        switch "--cask", "--casks",
+               description: "Treat all named arguments as casks."
 
-    bucket = if args.deps?
-      args.named.to_formulae_and_casks.flat_map do |formula_or_cask|
-        case formula_or_cask
-        when Formula
-          f = formula_or_cask
+        conflicts "--build-from-source", "--build-bottle", "--force-bottle", "--bottle-tag"
+        conflicts "--cask", "--HEAD"
+        conflicts "--cask", "--deps"
+        conflicts "--cask", "-s"
+        conflicts "--cask", "--build-bottle"
+        conflicts "--cask", "--force-bottle"
+        conflicts "--cask", "--bottle-tag"
+        conflicts "--formula", "--cask"
+        conflicts "--os", "--bottle-tag"
+        conflicts "--arch", "--bottle-tag"
 
-          [f, *f.recursive_dependencies.map(&:to_formula)]
-        else
-          formula_or_cask
+        named_args [:formula, :cask], min: 1
+      end
+
+      def concurrency
+        @concurrency ||= args.concurrency&.to_i || 1
+      end
+
+      def download_queue
+        @download_queue ||= begin
+          require "download_queue"
+          DownloadQueue.new(concurrency)
         end
       end
-    else
-      args.named.to_formulae_and_casks
-    end.uniq
 
-    puts "Fetching: #{bucket * ", "}" if bucket.size > 1
-    bucket.each do |formula_or_cask|
-      case formula_or_cask
-      when Formula
-        f = formula_or_cask
+      class Spinner
+        FRAMES = [
+          "⠋",
+          "⠙",
+          "⠚",
+          "⠞",
+          "⠖",
+          "⠦",
+          "⠴",
+          "⠲",
+          "⠳",
+          "⠓",
+        ].freeze
 
-        f.print_tap_action verb: "Fetching"
+        sig { void }
+        def initialize
+          @start = Time.now
+          @i = 0
+        end
 
-        fetched_bottle = false
-        if fetch_bottle?(f, args: args)
-          begin
-            f.clear_cache if args.force?
-            f.fetch_bottle_tab
-            fetch_formula(f.bottle_for_tag(args.bottle_tag&.to_sym), args: args)
-          rescue Interrupt
-            raise
-          rescue => e
-            raise if Homebrew::EnvConfig.developer?
-
-            fetched_bottle = false
-            onoe e.message
-            opoo "Bottle fetch failed, fetching the source instead."
-          else
-            fetched_bottle = true
+        sig { returns(String) }
+        def to_s
+          now = Time.now
+          if @start + 0.1 < now
+            @start = now
+            @i = (@i + 1) % FRAMES.count
           end
+
+          FRAMES.fetch(@i)
         end
+      end
+
+      sig { override.void }
+      def run
+        Formulary.enable_factory_cache!
+
+        bucket = if args.deps?
+          args.named.to_formulae_and_casks.flat_map do |formula_or_cask|
+            case formula_or_cask
+            when Formula
+              formula = formula_or_cask
+              [formula, *formula.recursive_dependencies.map(&:to_formula)]
+            else
+              formula_or_cask
+            end
+          end
+        else
+          args.named.to_formulae_and_casks
+        end.uniq
+
+        os_arch_combinations = args.os_arch_combinations
+
+        puts "Fetching: #{bucket * ", "}" if bucket.size > 1
+        bucket.each do |formula_or_cask|
+          case formula_or_cask
+          when Formula
+            formula = T.cast(formula_or_cask, Formula)
+            ref = formula.loaded_from_api? ? formula.full_name : formula.path
+
+            os_arch_combinations.each do |os, arch|
+              SimulateSystem.with(os:, arch:) do
+                formula = Formulary.factory(ref, args.HEAD? ? :head : :stable)
+
+                formula.print_tap_action verb: "Fetching"
+
+                fetched_bottle = false
+                if fetch_bottle?(
+                  formula,
+                  force_bottle:               args.force_bottle?,
+                  bottle_tag:                 args.bottle_tag&.to_sym,
+                  build_from_source_formulae: args.build_from_source_formulae,
+                  os:                         args.os&.to_sym,
+                  arch:                       args.arch&.to_sym,
+                )
+                  begin
+                    formula.clear_cache if args.force?
+
+                    bottle_tag = if (bottle_tag = args.bottle_tag&.to_sym)
+                      Utils::Bottles::Tag.from_symbol(bottle_tag)
+                    else
+                      Utils::Bottles::Tag.new(system: os, arch:)
+                    end
+
+                    bottle = formula.bottle_for_tag(bottle_tag)
 
-        next if fetched_bottle
+                    if bottle.nil?
+                      opoo "Bottle for tag #{bottle_tag.to_sym.inspect} is unavailable."
+                      next
+                    end
+
+                    if (manifest_resource = bottle.github_packages_manifest_resource)
+                      fetch_downloadable(manifest_resource)
+                    end
+                    fetch_downloadable(bottle)
+                  rescue Interrupt
+                    raise
+                  rescue => e
+                    raise if Homebrew::EnvConfig.developer?
+
+                    fetched_bottle = false
+                    onoe e.message
+                    opoo "Bottle fetch failed, fetching the source instead."
+                  else
+                    fetched_bottle = true
+                  end
+                end
+
+                next if fetched_bottle
+
+                fetch_downloadable(formula.resource)
+
+                formula.resources.each do |r|
+                  fetch_downloadable(r)
+                  r.patches.each { |patch| fetch_downloadable(patch.resource) if patch.external? }
+                end
+
+                formula.patchlist.each { |patch| fetch_downloadable(patch.resource) if patch.external? }
+              end
+            end
+          else
+            cask = formula_or_cask
+            ref = cask.loaded_from_api? ? cask.full_name : cask.sourcefile_path
 
-        fetch_formula(f, args: args)
+            os_arch_combinations.each do |os, arch|
+              next if os == :linux
 
-        f.resources.each do |r|
-          fetch_resource(r, args: args)
-          r.patches.each { |p| fetch_patch(p, args: args) if p.external? }
+              SimulateSystem.with(os:, arch:) do
+                cask = Cask::CaskLoader.load(ref)
+
+                if cask.url.nil? || cask.sha256.nil?
+                  opoo "Cask #{cask} is not supported on os #{os} and arch #{arch}"
+                  next
+                end
+
+                quarantine = args.quarantine?
+                quarantine = true if quarantine.nil?
+
+                download = Cask::Download.new(cask, quarantine:)
+                fetch_downloadable(download)
+              end
+            end
+          end
         end
 
-        f.patchlist.each { |p| fetch_patch(p, args: args) if p.external? }
-      else
-        cask = formula_or_cask
+        if concurrency == 1
+          downloads.each do |downloadable, promise|
+            promise.wait!
+          rescue ChecksumMismatchError => e
+            opoo "#{downloadable.download_type.capitalize} reports different checksum: #{e.expected}"
+            Homebrew.failed = true if downloadable.is_a?(Resource::Patch)
+          end
+        else
+          spinner = Spinner.new
+          remaining_downloads = downloads.dup
+          previous_pending_line_count = 0
 
-        quarantine = args.quarantine?
-        quarantine = true if quarantine.nil?
+          begin
+            $stdout.print Tty.hide_cursor
+            $stdout.flush
 
-        download = Cask::Download.new(cask, quarantine: quarantine)
-        fetch_cask(download, args: args)
-      end
-    end
-  end
+            output_message = lambda do |downloadable, future|
+              status = case future.state
+              when :fulfilled
+                "#{Tty.green}✔︎#{Tty.reset}"
+              when :rejected
+                "#{Tty.red}✘#{Tty.reset}"
+              when :pending, :processing
+                "#{Tty.blue}#{spinner}#{Tty.reset}"
+              else
+                raise future.state.to_s
+              end
 
-  def fetch_resource(r, args:)
-    puts "Resource: #{r.name}"
-    fetch_fetchable r, args: args
-  rescue ChecksumMismatchError => e
-    retry if retry_fetch?(r, args: args)
-    opoo "Resource #{r.name} reports different sha256: #{e.expected}"
-  end
+              message = "#{downloadable.download_type.capitalize} #{downloadable.name}"
+              $stdout.puts "#{status} #{message}"
+              $stdout.flush
 
-  def fetch_formula(f, args:)
-    fetch_fetchable f, args: args
-  rescue ChecksumMismatchError => e
-    retry if retry_fetch?(f, args: args)
-    opoo "Formula reports different sha256: #{e.expected}"
-  end
+              if future.rejected? && (e = future.reason).is_a?(ChecksumMismatchError)
+                opoo "#{downloadable.download_type.capitalize} reports different checksum: #{e.expected}"
+                Homebrew.failed = true if downloadable.is_a?(Resource::Patch)
+                next 2
+              end
 
-  def fetch_cask(cask_download, args:)
-    fetch_fetchable cask_download, args: args
-  rescue ChecksumMismatchError => e
-    retry if retry_fetch?(cask_download, args: args)
-    opoo "Cask reports different sha256: #{e.expected}"
-  end
+              1
+            end
 
-  def fetch_patch(p, args:)
-    fetch_fetchable p, args: args
-  rescue ChecksumMismatchError => e
-    opoo "Patch reports different sha256: #{e.expected}"
-    Homebrew.failed = true
-  end
+            until remaining_downloads.empty?
+              begin
+                finished_states = [:fulfilled, :rejected]
 
-  def retry_fetch?(f, args:)
-    @fetch_failed ||= Set.new
-    if args.retry? && @fetch_failed.add?(f)
-      ohai "Retrying download"
-      f.clear_cache
-      true
-    else
-      Homebrew.failed = true
-      false
-    end
-  end
+                finished_downloads, remaining_downloads = remaining_downloads.partition do |_, future|
+                  finished_states.include?(future.state)
+                end
 
-  def fetch_fetchable(f, args:)
-    f.clear_cache if args.force?
+                finished_downloads.each do |downloadable, future|
+                  previous_pending_line_count -= 1
+                  $stdout.print Tty.clear_to_end
+                  $stdout.flush
+                  output_message.call(downloadable, future)
+                end
 
-    already_fetched = f.cached_download.exist?
+                previous_pending_line_count = 0
+                remaining_downloads.each do |downloadable, future|
+                  # FIXME: Allow printing full terminal height.
+                  break if previous_pending_line_count >= [concurrency, (Tty.height - 1)].min
 
-    begin
-      download = f.fetch(verify_download_integrity: false)
-    rescue DownloadError
-      retry if retry_fetch?(f, args: args)
-      raise
-    end
+                  $stdout.print Tty.clear_to_end
+                  $stdout.flush
+                  previous_pending_line_count += output_message.call(downloadable, future)
+                end
+
+                if previous_pending_line_count.positive?
+                  $stdout.print Tty.move_cursor_up_beginning(previous_pending_line_count)
+                  $stdout.flush
+                end
+
+                sleep 0.05
+              rescue Interrupt
+                remaining_downloads.each do |_, future|
+                  # FIXME: Implement cancellation of running downloads.
+                end
+
+                download_queue.cancel
+
+                if previous_pending_line_count.positive?
+                  $stdout.print Tty.move_cursor_down(previous_pending_line_count - 1)
+                  $stdout.flush
+                end
+
+                raise
+              end
+            end
+          ensure
+            $stdout.print Tty.show_cursor
+            $stdout.flush
+          end
+        end
+      ensure
+        download_queue.shutdown
+      end
 
-    return unless download.file?
+      private
 
-    puts "Downloaded to: #{download}" unless already_fetched
-    puts "SHA256: #{download.sha256}"
+      def downloads
+        @downloads ||= {}
+      end
 
-    f.verify_download_integrity(download)
+      def fetch_downloadable(downloadable)
+        downloads[downloadable] ||= begin
+          tries = args.retry? ? {} : { tries: 1 }
+          download_queue.enqueue(RetryableDownload.new(downloadable, **tries), force: args.force?)
+        end
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/cmd/formulae.rb b/Library/Homebrew/cmd/formulae.rb
new file mode 100644
index 0000000000000..58c41d034b982
--- /dev/null
+++ b/Library/Homebrew/cmd/formulae.rb
@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "shell_command"
+
+module Homebrew
+  module Cmd
+    class Formulae < AbstractCommand
+      include ShellCommand
+
+      cmd_args do
+        description "List all locally installable formulae including short names."
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cmd/formulae.sh b/Library/Homebrew/cmd/formulae.sh
index ccf04ea0766b8..c218b822fb498 100644
--- a/Library/Homebrew/cmd/formulae.sh
+++ b/Library/Homebrew/cmd/formulae.sh
@@ -1,12 +1,25 @@
-#:  * `formulae`
-#:
-#:  List all locally installable formulae including short names.
-#:
+# Documentation defined in Library/Homebrew/cmd/formulae.rb
 
 # HOMEBREW_LIBRARY is set by bin/brew
 # shellcheck disable=SC2154
 source "${HOMEBREW_LIBRARY}/Homebrew/items.sh"
 
 homebrew-formulae() {
-  homebrew-items 'Casks' 's|/Formula/|/|' '^homebrew/core'
+  local find_include_filter='*\.rb'
+  local sed_filter='s|/Formula/(.+/)?|/|'
+  local grep_filter='^homebrew/core'
+
+  # HOMEBREW_CACHE is set by brew.sh
+  # shellcheck disable=SC2154
+  if [[ -z "${HOMEBREW_NO_INSTALL_FROM_API}" &&
+        -f "${HOMEBREW_CACHE}/api/formula_names.txt" ]]
+  then
+    {
+      cat "${HOMEBREW_CACHE}/api/formula_names.txt"
+      echo
+      homebrew-items "${find_include_filter}" '.*Casks(/.*|$)|.*/homebrew/homebrew-core/.*' "${sed_filter}" "${grep_filter}"
+    } | sort -uf
+  else
+    homebrew-items "${find_include_filter}" '.*Casks(/.*|$)' "${sed_filter}" "${grep_filter}"
+  fi
 }
diff --git a/Library/Homebrew/cmd/gist-logs.rb b/Library/Homebrew/cmd/gist-logs.rb
index 81a76f7036322..54d7e3e3fc881 100644
--- a/Library/Homebrew/cmd/gist-logs.rb
+++ b/Library/Homebrew/cmd/gist-logs.rb
@@ -1,122 +1,138 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
 require "install"
 require "system_config"
 require "stringio"
 require "socket"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
-
-  extend Install
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def gist_logs_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Upload logs for a failed build of <formula> to a new Gist. Presents an
-        error message if no logs are found.
-      EOS
-      switch "--with-hostname",
-             description: "Include the hostname in the Gist."
-      switch "-n", "--new-issue",
-             description: "Automatically create a new issue in the appropriate GitHub repository " \
-                          "after creating the Gist."
-      switch "-p", "--private",
-             description: "The Gist will be marked private and will not appear in listings but will " \
-                          "be accessible with its link."
-
-      named_args :formula, number: 1
-    end
-  end
+  module Cmd
+    class GistLogs < AbstractCommand
+      include Install
+      cmd_args do
+        description <<~EOS
+          Upload logs for a failed build of <formula> to a new Gist. Presents an
+          error message if no logs are found.
+        EOS
+        switch "--with-hostname",
+               description: "Include the hostname in the Gist."
+        switch "-n", "--new-issue",
+               description: "Automatically create a new issue in the appropriate GitHub repository " \
+                            "after creating the Gist."
+        switch "-p", "--private",
+               description: "The Gist will be marked private and will not appear in listings but will " \
+                            "be accessible with its link."
+
+        named_args :formula, number: 1
+      end
 
-  def gistify_logs(f, args:)
-    files = load_logs(f.logs)
-    build_time = f.logs.ctime
-    timestamp = build_time.strftime("%Y-%m-%d_%H-%M-%S")
-
-    s = StringIO.new
-    SystemConfig.dump_verbose_config s
-    # Dummy summary file, asciibetically first, to control display title of gist
-    files["# #{f.name} - #{timestamp}.txt"] = { content: brief_build_info(f, with_hostname: args.with_hostname?) }
-    files["00.config.out"] = { content: s.string }
-    files["00.doctor.out"] = { content: Utils.popen_read("#{HOMEBREW_PREFIX}/bin/brew", "doctor", err: :out) }
-    unless f.core_formula?
-      tap = <<~EOS
-        Formula: #{f.name}
-            Tap: #{f.tap}
-           Path: #{f.path}
-      EOS
-      files["00.tap.out"] = { content: tap }
-    end
+      sig { override.void }
+      def run
+        Install.perform_preinstall_checks_once(all_fatal: true)
+        Install.perform_build_from_source_checks(all_fatal: true)
+        return unless (formula = args.named.to_resolved_formulae.first)
 
-    odie "`brew gist-logs` requires HOMEBREW_GITHUB_API_TOKEN to be set!" if GitHub::API.credentials_type == :none
+        gistify_logs(formula)
+      end
 
-    # Description formatted to work well as page title when viewing gist
-    descr = if f.core_formula?
-      "#{f.name} on #{OS_VERSION} - Homebrew build logs"
-    else
-      "#{f.name} (#{f.full_name}) on #{OS_VERSION} - Homebrew build logs"
-    end
-    url = GitHub.create_gist(files, descr, private: args.private?)
+      private
+
+      sig { params(formula: Formula).void }
+      def gistify_logs(formula)
+        files = load_logs(formula.logs)
+        build_time = formula.logs.ctime
+        timestamp = build_time.strftime("%Y-%m-%d_%H-%M-%S")
+
+        s = StringIO.new
+        SystemConfig.dump_verbose_config s
+        # Dummy summary file, asciibetically first, to control display title of gist
+        files["# #{formula.name} - #{timestamp}.txt"] = {
+          content: brief_build_info(formula, with_hostname: args.with_hostname?),
+        }
+        files["00.config.out"] = { content: s.string }
+        files["00.doctor.out"] = { content: Utils.popen_read("#{HOMEBREW_PREFIX}/bin/brew", "doctor", err: :out) }
+        unless formula.core_formula?
+          tap = <<~EOS
+            Formula: #{formula.name}
+                Tap: #{formula.tap}
+               Path: #{formula.path}
+          EOS
+          files["00.tap.out"] = { content: tap }
+        end
 
-    url = GitHub.create_issue(f.tap, "#{f.name} failed to build on #{MacOS.full_version}", url) if args.new_issue?
+        odie "`brew gist-logs` requires HOMEBREW_GITHUB_API_TOKEN to be set!" if GitHub::API.credentials_type == :none
 
-    puts url if url
-  end
+        # Description formatted to work well as page title when viewing gist
+        descr = if formula.core_formula?
+          "#{formula.name} on #{OS_VERSION} - Homebrew build logs"
+        else
+          "#{formula.name} (#{formula.full_name}) on #{OS_VERSION} - Homebrew build logs"
+        end
 
-  def brief_build_info(f, with_hostname:)
-    build_time_str = f.logs.ctime.strftime("%Y-%m-%d %H:%M:%S")
-    s = +<<~EOS
-      Homebrew build logs for #{f.full_name} on #{OS_VERSION}
-    EOS
-    if with_hostname
-      hostname = Socket.gethostname
-      s << "Host: #{hostname}\n"
-    end
-    s << "Build date: #{build_time_str}\n"
-    s.freeze
-  end
+        begin
+          url = GitHub.create_gist(files, descr, private: args.private?)
+        rescue GitHub::API::HTTPNotFoundError
+          odie <<~EOS
+            Your GitHub API token likely doesn't have the `gist` scope.
+            #{GitHub.pat_blurb(GitHub::CREATE_GIST_SCOPES)}
+          EOS
+        end
 
-  # Causes some terminals to display secure password entry indicators.
-  def noecho_gets
-    system "stty", "-echo"
-    result = $stdin.gets
-    system "stty", "echo"
-    puts
-    result
-  end
+        if args.new_issue?
+          url = GitHub.create_issue(formula.tap, "#{formula.name} failed to build on #{OS_VERSION}",
+                                    url)
+        end
 
-  def load_logs(dir, basedir = dir)
-    logs = {}
-    if dir.exist?
-      dir.children.sort.each do |file|
-        if file.directory?
-          logs.merge! load_logs(file, basedir)
-        else
-          contents = file.size? ? file.read : "empty log"
-          # small enough to avoid GitHub "unicorn" page-load-timeout errors
-          max_file_size = 1_000_000
-          contents = truncate_text_to_approximate_size(contents, max_file_size, front_weight: 0.2)
-          logs[file.relative_path_from(basedir).to_s.tr("/", ":")] = { content: contents }
+        puts url if url
+      end
+
+      sig { params(formula: Formula, with_hostname: T::Boolean).returns(String) }
+      def brief_build_info(formula, with_hostname:)
+        build_time_string = formula.logs.ctime.strftime("%Y-%m-%d %H:%M:%S")
+        string = <<~EOS
+          Homebrew build logs for #{formula.full_name} on #{OS_VERSION}
+        EOS
+        if with_hostname
+          hostname = Socket.gethostname
+          string << "Host: #{hostname}\n"
         end
+        string << "Build date: #{build_time_string}\n"
+        string.freeze
       end
-    end
-    odie "No logs." if logs.empty?
 
-    logs
-  end
+      # Causes some terminals to display secure password entry indicators.
+      sig { void }
+      def noecho_gets
+        system "stty", "-echo"
+        result = $stdin.gets
+        system "stty", "echo"
+        puts
+        result
+      end
 
-  def gist_logs
-    args = gist_logs_args.parse
+      sig { params(dir: Pathname, basedir: Pathname).returns(T::Hash[String, T::Hash[Symbol, String]]) }
+      def load_logs(dir, basedir = dir)
+        logs = {}
+        if dir.exist?
+          dir.children.sort.each do |file|
+            if file.directory?
+              logs.merge! load_logs(file, basedir)
+            else
+              contents = file.size? ? file.read : "empty log"
+              # small enough to avoid GitHub "unicorn" page-load-timeout errors
+              max_file_size = 1_000_000
+              contents = truncate_text_to_approximate_size(contents, max_file_size, front_weight: 0.2)
+              logs[file.relative_path_from(basedir).to_s.tr("/", ":")] = { content: contents }
+            end
+          end
+        end
+        odie "No logs." if logs.empty?
 
-    Install.perform_preinstall_checks(all_fatal: true)
-    Install.perform_build_from_source_checks(all_fatal: true)
-    gistify_logs(args.named.to_resolved_formulae.first, args: args)
+        logs
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/cmd/help.rb b/Library/Homebrew/cmd/help.rb
index bcad2600c1068..4ddb60473b7ee 100644
--- a/Library/Homebrew/cmd/help.rb
+++ b/Library/Homebrew/cmd/help.rb
@@ -1,10 +1,24 @@
-# typed: true
+# typed: strong
 # frozen_string_literal: true
 
+require "abstract_command"
 require "help"
 
 module Homebrew
-  def help
-    Help.help
+  module Cmd
+    class HelpCmd < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Outputs the usage instructions for `brew` <command>.
+          Equivalent to `brew --help` <command>.
+        EOS
+        named_args [:command]
+      end
+
+      sig { override.void }
+      def run
+        Help.help
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/cmd/home.rb b/Library/Homebrew/cmd/home.rb
index 649c3d09daf02..59ac2b6c5c573 100644
--- a/Library/Homebrew/cmd/home.rb
+++ b/Library/Homebrew/cmd/home.rb
@@ -1,56 +1,54 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 require "formula"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def home_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Open a <formula> or <cask>'s homepage in a browser, or open
-        Homebrew's own homepage if no argument is provided.
-      EOS
-      switch "--formula", "--formulae",
-             description: "Treat all named arguments as formulae."
-      switch "--cask", "--casks",
-             description: "Treat all named arguments as casks."
-
-      conflicts "--formula", "--cask"
-
-      named_args [:formula, :cask]
-    end
-  end
-
-  sig { void }
-  def home
-    args = home_args.parse
-
-    if args.no_named?
-      exec_browser HOMEBREW_WWW
-      return
-    end
-
-    # to_formulae_and_casks is typed to possibly return Kegs (but won't without explicitly asking)
-    formulae_or_casks = T.cast(args.named.to_formulae_and_casks, T::Array[T.any(Formula, Cask::Cask)])
-    homepages = formulae_or_casks.map do |formula_or_cask|
-      puts "Opening homepage for #{name_of(formula_or_cask)}"
-      formula_or_cask.homepage
-    end
-
-    exec_browser(*T.unsafe(homepages))
-  end
-
-  def name_of(formula_or_cask)
-    if formula_or_cask.is_a? Formula
-      "Formula #{formula_or_cask.name}"
-    else
-      "Cask #{formula_or_cask.token}"
+  module Cmd
+    class Home < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Open a <formula> or <cask>'s homepage in a browser, or open
+          Homebrew's own homepage if no argument is provided.
+        EOS
+        switch "--formula", "--formulae",
+               description: "Treat all named arguments as formulae."
+        switch "--cask", "--casks",
+               description: "Treat all named arguments as casks."
+
+        conflicts "--formula", "--cask"
+
+        named_args [:formula, :cask]
+      end
+
+      sig { override.void }
+      def run
+        if args.no_named?
+          exec_browser HOMEBREW_WWW
+          return
+        end
+
+        # to_formulae_and_casks is typed to possibly return Kegs (but won't without explicitly asking)
+        formulae_or_casks = T.cast(args.named.to_formulae_and_casks, T::Array[T.any(Formula, Cask::Cask)])
+        homepages = formulae_or_casks.map do |formula_or_cask|
+          puts "Opening homepage for #{name_of(formula_or_cask)}"
+          formula_or_cask.homepage
+        end
+
+        exec_browser(*homepages)
+      end
+
+      private
+
+      sig { params(formula_or_cask: T.any(Formula, Cask::Cask)).returns(String) }
+      def name_of(formula_or_cask)
+        if formula_or_cask.is_a? Formula
+          "Formula #{formula_or_cask.name}"
+        else
+          "Cask #{formula_or_cask.token}"
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cmd/info.rb b/Library/Homebrew/cmd/info.rb
index 4f6d706567bfc..9b0424e65e40f 100644
--- a/Library/Homebrew/cmd/info.rb
+++ b/Library/Homebrew/cmd/info.rb
@@ -1,9 +1,9 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "abstract_command"
 require "missing_formula"
 require "caveats"
-require "cli/parser"
 require "options"
 require "formula"
 require "keg"
@@ -14,368 +14,382 @@
 require "api"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  VALID_DAYS = %w[30 90 365].freeze
-  VALID_FORMULA_CATEGORIES = %w[install install-on-request build-error].freeze
-  VALID_CATEGORIES = (VALID_FORMULA_CATEGORIES + %w[cask-install os-version]).freeze
-
-  sig { returns(CLI::Parser) }
-  def info_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Display brief statistics for your Homebrew installation.
-
-        If a <formula> or <cask> is provided, show summary of information about it.
-      EOS
-      switch "--analytics",
-             description: "List global Homebrew analytics data or, if specified, installation and " \
-                          "build error data for <formula> (provided neither `HOMEBREW_NO_ANALYTICS` " \
-                          "nor `HOMEBREW_NO_GITHUB_API` are set)."
-      flag   "--days=",
-             depends_on:  "--analytics",
-             description: "How many days of analytics data to retrieve. " \
-                          "The value for <days> must be `30`, `90` or `365`. The default is `30`."
-      flag   "--category=",
-             depends_on:  "--analytics",
-             description: "Which type of analytics data to retrieve. " \
-                          "The value for <category> must be `install`, `install-on-request` or `build-error`; " \
-                          "`cask-install` or `os-version` may be specified if <formula> is not. " \
-                          "The default is `install`."
-      switch "--github",
-             description: "Open the GitHub source page for <formula> and <cask> in a browser. " \
-                          "To view the history locally: `brew log -p` <formula> or <cask>"
-      flag   "--json",
-             description: "Print a JSON representation. Currently the default value for <version> is `v1` for " \
-                          "<formula>. For <formula> and <cask> use `v2`. See the docs for examples of using the " \
-                          "JSON output: <https://docs.brew.sh/Querying-Brew>"
-      switch "--bottle",
-             depends_on:  "--json",
-             description: "Output information about the bottles for <formula> and its dependencies.",
-             hidden:      true
-      switch "--installed",
-             depends_on:  "--json",
-             description: "Print JSON of formulae that are currently installed."
-      switch "--all",
-             depends_on:  "--json",
-             description: "Print JSON of all available formulae."
-      switch "--variations",
-             depends_on:  "--json",
-             description: "Include the variations hash in each formula's JSON output."
-      switch "-v", "--verbose",
-             description: "Show more verbose analytics data for <formula>."
-      switch "--formula", "--formulae",
-             description: "Treat all named arguments as formulae."
-      switch "--cask", "--casks",
-             description: "Treat all named arguments as casks."
-
-      conflicts "--installed", "--all"
-      conflicts "--formula", "--cask"
-
-      %w[--cask --analytics --github].each do |conflict|
-        conflicts "--bottle", conflict
+  module Cmd
+    class Info < AbstractCommand
+      VALID_DAYS = %w[30 90 365].freeze
+      VALID_FORMULA_CATEGORIES = %w[install install-on-request build-error].freeze
+      VALID_CATEGORIES = (VALID_FORMULA_CATEGORIES + %w[cask-install os-version]).freeze
+
+      cmd_args do
+        description <<~EOS
+          Display brief statistics for your Homebrew installation.
+          If a <formula> or <cask> is provided, show summary of information about it.
+        EOS
+        switch "--analytics",
+               description: "List global Homebrew analytics data or, if specified, installation and " \
+                            "build error data for <formula> (provided neither `HOMEBREW_NO_ANALYTICS` " \
+                            "nor `HOMEBREW_NO_GITHUB_API` are set)."
+        flag   "--days=",
+               depends_on:  "--analytics",
+               description: "How many days of analytics data to retrieve. " \
+                            "The value for <days> must be `30`, `90` or `365`. The default is `30`."
+        flag   "--category=",
+               depends_on:  "--analytics",
+               description: "Which type of analytics data to retrieve. " \
+                            "The value for <category> must be `install`, `install-on-request` or `build-error`; " \
+                            "`cask-install` or `os-version` may be specified if <formula> is not. " \
+                            "The default is `install`."
+        switch "--github-packages-downloads",
+               description: "Scrape GitHub Packages download counts from HTML for a core formula.",
+               hidden:      true
+        switch "--github",
+               description: "Open the GitHub source page for <formula> and <cask> in a browser. " \
+                            "To view the history locally: `brew log -p` <formula> or <cask>"
+        switch "--fetch-manifest",
+               description: "Fetch GitHub Packages manifest for extra information when <formula> is not installed."
+        flag   "--json",
+               description: "Print a JSON representation. Currently the default value for <version> is `v1` for " \
+                            "<formula>. For <formula> and <cask> use `v2`. See the docs for examples of using the " \
+                            "JSON output: <https://docs.brew.sh/Querying-Brew>"
+        switch "--installed",
+               depends_on:  "--json",
+               description: "Print JSON of formulae that are currently installed."
+        switch "--eval-all",
+               depends_on:  "--json",
+               description: "Evaluate all available formulae and casks, whether installed or not, to print their " \
+                            "JSON. Implied if `HOMEBREW_EVAL_ALL` is set."
+        switch "--variations",
+               depends_on:  "--json",
+               description: "Include the variations hash in each formula's JSON output."
+        switch "-v", "--verbose",
+               description: "Show more verbose analytics data for <formula>."
+        switch "--formula", "--formulae",
+               description: "Treat all named arguments as formulae."
+        switch "--cask", "--casks",
+               description: "Treat all named arguments as casks."
+
+        conflicts "--installed", "--eval-all"
+        conflicts "--installed", "--all"
+        conflicts "--formula", "--cask"
+        conflicts "--fetch-manifest", "--cask"
+        conflicts "--fetch-manifest", "--json"
+
+        named_args [:formula, :cask]
       end
 
-      named_args [:formula, :cask]
-    end
-  end
-
-  sig { void }
-  def info
-    args = info_args.parse
-
-    if args.analytics?
-      if args.days.present? && VALID_DAYS.exclude?(args.days)
-        raise UsageError, "--days must be one of #{VALID_DAYS.join(", ")}"
-      end
-
-      if args.category.present?
-        if args.named.present? && VALID_FORMULA_CATEGORIES.exclude?(args.category)
-          raise UsageError, "--category must be one of #{VALID_FORMULA_CATEGORIES.join(", ")} when querying formulae"
+      sig { override.void }
+      def run
+        if args.analytics?
+          if args.days.present? && VALID_DAYS.exclude?(args.days)
+            raise UsageError, "`--days` must be one of #{VALID_DAYS.join(", ")}."
+          end
+
+          if args.category.present?
+            if args.named.present? && VALID_FORMULA_CATEGORIES.exclude?(args.category)
+              raise UsageError,
+                    "`--category` must be one of #{VALID_FORMULA_CATEGORIES.join(", ")} when querying formulae."
+            end
+
+            unless VALID_CATEGORIES.include?(args.category)
+              raise UsageError, "`--category` must be one of #{VALID_CATEGORIES.join(", ")}."
+            end
+          end
+
+          print_analytics
+        elsif args.json
+          all = args.eval_all?
+
+          print_json(all)
+        elsif args.github?
+          raise FormulaOrCaskUnspecifiedError if args.no_named?
+
+          exec_browser(*args.named.to_formulae_and_casks.map { |f| github_info(f) })
+        elsif args.no_named?
+          print_statistics
+        else
+          print_info
         end
+      end
 
-        unless VALID_CATEGORIES.include?(args.category)
-          raise UsageError, "--category must be one of #{VALID_CATEGORIES.join(", ")}"
+      def github_remote_path(remote, path)
+        if remote =~ %r{^(?:https?://|git(?:@|://))github\.com[:/](.+)/(.+?)(?:\.git)?$}
+          "https://github.com/#{Regexp.last_match(1)}/#{Regexp.last_match(2)}/blob/HEAD/#{path}"
+        else
+          "#{remote}/#{path}"
         end
       end
 
-      print_analytics(args: args)
-    elsif args.json
-      print_json(args: args)
-    elsif args.github?
-      raise FormulaOrCaskUnspecifiedError if args.no_named?
-
-      exec_browser(*args.named.to_formulae_and_casks.map { |f| github_info(f) })
-    elsif args.no_named?
-      print_statistics
-    else
-      print_info(args: args)
-    end
-  end
+      private
 
-  sig { void }
-  def print_statistics
-    return unless HOMEBREW_CELLAR.exist?
+      sig { void }
+      def print_statistics
+        return unless HOMEBREW_CELLAR.exist?
 
-    count = Formula.racks.length
-    puts "#{count} #{"keg".pluralize(count)}, #{HOMEBREW_CELLAR.dup.abv}"
-  end
+        count = Formula.racks.length
+        puts "#{Utils.pluralize("keg", count, include_count: true)}, #{HOMEBREW_CELLAR.dup.abv}"
+      end
 
-  sig { params(args: CLI::Args).void }
-  def print_analytics(args:)
-    if args.no_named?
-      Utils::Analytics.output(args: args)
-      return
-    end
+      sig { void }
+      def print_analytics
+        if args.no_named?
+          Utils::Analytics.output(args:)
+          return
+        end
 
-    args.named.to_formulae_and_casks_and_unavailable.each_with_index do |obj, i|
-      puts unless i.zero?
-
-      case obj
-      when Formula
-        Utils::Analytics.formula_output(obj, args: args)
-      when Cask::Cask
-        Utils::Analytics.cask_output(obj, args: args)
-      when FormulaOrCaskUnavailableError
-        Utils::Analytics.output(filter: obj.name, args: args)
-      else
-        raise
+        args.named.to_formulae_and_casks_and_unavailable.each_with_index do |obj, i|
+          puts unless i.zero?
+
+          case obj
+          when Formula
+            Utils::Analytics.formula_output(obj, args:)
+          when Cask::Cask
+            Utils::Analytics.cask_output(obj, args:)
+          when FormulaOrCaskUnavailableError
+            Utils::Analytics.output(filter: obj.name, args:)
+          else
+            raise
+          end
+        end
       end
-    end
-  end
 
-  sig { params(args: CLI::Args).void }
-  def print_info(args:)
-    args.named.to_formulae_and_casks_and_unavailable.each_with_index do |obj, i|
-      puts unless i.zero?
-
-      case obj
-      when Formula
-        info_formula(obj, args: args)
-      when Cask::Cask
-        info_cask(obj, args: args)
-      when FormulaUnreadableError, FormulaClassUnavailableError,
-         TapFormulaUnreadableError, TapFormulaClassUnavailableError,
-         Cask::CaskUnreadableError
-        # We found the formula/cask, but failed to read it
-        $stderr.puts obj.backtrace if Homebrew::EnvConfig.developer?
-        ofail obj.message
-      when FormulaOrCaskUnavailableError
-        # The formula/cask could not be found
-        ofail obj.message
-        # No formula with this name, try a missing formula lookup
-        if (reason = MissingFormula.reason(obj.name, show_info: true))
-          $stderr.puts reason
+      sig { void }
+      def print_info
+        args.named.to_formulae_and_casks_and_unavailable.each_with_index do |obj, i|
+          puts unless i.zero?
+
+          case obj
+          when Formula
+            info_formula(obj)
+          when Cask::Cask
+            info_cask(obj)
+          when FormulaUnreadableError, FormulaClassUnavailableError,
+             TapFormulaUnreadableError, TapFormulaClassUnavailableError,
+             Cask::CaskUnreadableError
+            # We found the formula/cask, but failed to read it
+            $stderr.puts obj.backtrace if Homebrew::EnvConfig.developer?
+            ofail obj.message
+          when FormulaOrCaskUnavailableError
+            # The formula/cask could not be found
+            ofail obj.message
+            # No formula with this name, try a missing formula lookup
+            if (reason = MissingFormula.reason(obj.name, show_info: true))
+              $stderr.puts reason
+            end
+          else
+            raise
+          end
         end
-      else
-        raise
       end
-    end
-  end
-
-  def json_version(version)
-    version_hash = {
-      true => :default,
-      "v1" => :v1,
-      "v2" => :v2,
-    }
-
-    raise UsageError, "invalid JSON version: #{version}" unless version_hash.include?(version)
-
-    version_hash[version]
-  end
 
-  sig { params(args: CLI::Args).void }
-  def print_json(args:)
-    raise FormulaOrCaskUnspecifiedError if !(args.all? || args.installed?) && args.no_named?
+      def json_version(version)
+        version_hash = {
+          true => :default,
+          "v1" => :v1,
+          "v2" => :v2,
+        }
 
-    json = case json_version(args.json)
-    when :v1, :default
-      raise UsageError, "cannot specify --cask with --json=v1!" if args.cask?
+        raise UsageError, "invalid JSON version: #{version}" unless version_hash.include?(version)
 
-      formulae = if args.all?
-        Formula.all.sort
-      elsif args.installed?
-        Formula.installed.sort
-      else
-        args.named.to_formulae
+        version_hash[version]
       end
 
-      if args.bottle?
-        formulae.map(&:to_recursive_bottle_hash)
-      elsif args.variations?
-        formulae.map(&:to_hash_with_variations)
-      else
-        formulae.map(&:to_hash)
-      end
-    when :v2
-      formulae, casks = if args.all?
-        [Formula.all.sort, Cask::Cask.all.sort_by(&:full_name)]
-      elsif args.installed?
-        [Formula.installed.sort, Cask::Caskroom.casks.sort_by(&:full_name)]
-      else
-        args.named.to_formulae_to_casks
-      end
+      sig { params(all: T::Boolean).void }
+      def print_json(all)
+        raise FormulaOrCaskUnspecifiedError if !(all || args.installed?) && args.no_named?
+
+        json = case json_version(args.json)
+        when :v1, :default
+          raise UsageError, "Cannot specify `--cask` when using `--json=v1`!" if args.cask?
+
+          formulae = if all
+            Formula.all(eval_all: args.eval_all?).sort
+          elsif args.installed?
+            Formula.installed.sort
+          else
+            args.named.to_formulae
+          end
+
+          if args.variations?
+            formulae.map(&:to_hash_with_variations)
+          else
+            formulae.map(&:to_hash)
+          end
+        when :v2
+          formulae, casks = if all
+            [
+              Formula.all(eval_all: args.eval_all?).sort,
+              Cask::Cask.all(eval_all: args.eval_all?).sort_by(&:full_name),
+            ]
+          elsif args.installed?
+            [Formula.installed.sort, Cask::Caskroom.casks.sort_by(&:full_name)]
+          else
+            args.named.to_formulae_to_casks
+          end
+
+          if args.variations?
+            {
+              "formulae" => formulae.map(&:to_hash_with_variations),
+              "casks"    => casks.map(&:to_hash_with_variations),
+            }
+          else
+            {
+              "formulae" => formulae.map(&:to_hash),
+              "casks"    => casks.map(&:to_h),
+            }
+          end
+        else
+          raise
+        end
 
-      if args.bottle?
-        { "formulae" => formulae.map(&:to_recursive_bottle_hash) }
-      elsif args.variations?
-        {
-          "formulae" => formulae.map(&:to_hash_with_variations),
-          "casks"    => casks.map(&:to_hash_with_variations),
-        }
-      else
-        {
-          "formulae" => formulae.map(&:to_hash),
-          "casks"    => casks.map(&:to_h),
-        }
+        puts JSON.pretty_generate(json)
       end
-    else
-      raise
-    end
 
-    puts JSON.pretty_generate(json)
-  end
+      def github_info(formula_or_cask)
+        return formula_or_cask.path if formula_or_cask.tap.blank? || formula_or_cask.tap.remote.blank?
 
-  def github_remote_path(remote, path)
-    if remote =~ %r{^(?:https?://|git(?:@|://))github\.com[:/](.+)/(.+?)(?:\.git)?$}
-      "https://github.com/#{Regexp.last_match(1)}/#{Regexp.last_match(2)}/blob/HEAD/#{path}"
-    else
-      "#{remote}/#{path}"
-    end
-  end
+        path = case formula_or_cask
+        when Formula
+          formula = formula_or_cask
+          formula.path.relative_path_from(T.must(formula.tap).path)
+        when Cask::Cask
+          cask = formula_or_cask
+          if cask.sourcefile_path.blank? || cask.sourcefile_path.extname != ".rb"
+            return "#{cask.tap.default_remote}/blob/HEAD/#{cask.tap.relative_cask_path(cask.token)}"
+          end
 
-  def github_info(f)
-    return f.path if f.tap.blank? || f.tap.remote.blank?
+          cask.sourcefile_path.relative_path_from(cask.tap.path)
+        end
 
-    path = case f
-    when Formula
-      f.path.relative_path_from(f.tap.path)
-    when Cask::Cask
-      f.sourcefile_path.relative_path_from(f.tap.path)
-    end
-    github_remote_path(f.tap.remote, path)
-  end
+        github_remote_path(formula_or_cask.tap.remote, path)
+      end
 
-  def info_formula(f, args:)
-    specs = []
+      def info_formula(formula)
+        specs = []
 
-    if (stable = f.stable)
-      s = "stable #{stable.version}"
-      s += " (bottled)" if stable.bottled? && f.pour_bottle?
-      specs << s
-    end
+        if (stable = formula.stable)
+          string = "stable #{stable.version}"
+          string += " (bottled)" if stable.bottled? && formula.pour_bottle?
+          specs << string
+        end
 
-    specs << "HEAD" if f.head
+        specs << "HEAD" if formula.head
 
-    attrs = []
-    attrs << "pinned at #{f.pinned_version}" if f.pinned?
-    attrs << "keg-only" if f.keg_only?
+        attrs = []
+        attrs << "pinned at #{formula.pinned_version}" if formula.pinned?
+        attrs << "keg-only" if formula.keg_only?
 
-    puts "#{f.full_name}: #{specs * ", "}#{" [#{attrs * ", "}]" unless attrs.empty?}"
-    puts f.desc if f.desc
-    puts Formatter.url(f.homepage) if f.homepage
+        puts "#{oh1_title(formula.full_name)}: #{specs * ", "}#{" [#{attrs * ", "}]" unless attrs.empty?}"
+        puts formula.desc if formula.desc
+        puts Formatter.url(formula.homepage) if formula.homepage
 
-    deprecate_disable_type, deprecate_disable_reason = DeprecateDisable.deprecate_disable_info f
-    if deprecate_disable_type.present?
-      if deprecate_disable_reason.present?
-        puts "#{deprecate_disable_type.capitalize} because it #{deprecate_disable_reason}!"
-      else
-        puts "#{deprecate_disable_type.capitalize}!"
-      end
-    end
+        deprecate_disable_info_string = DeprecateDisable.message(formula)
+        if deprecate_disable_info_string.present?
+          deprecate_disable_info_string.tap { |info_string| info_string[0] = info_string[0].upcase }
+          puts deprecate_disable_info_string
+        end
 
-    conflicts = f.conflicts.map do |c|
-      reason = " (because #{c.reason})" if c.reason
-      "#{c.name}#{reason}"
-    end.sort!
-    unless conflicts.empty?
-      puts <<~EOS
-        Conflicts with:
-          #{conflicts.join("\n  ")}
-      EOS
-    end
+        conflicts = formula.conflicts.map do |conflict|
+          reason = " (because #{conflict.reason})" if conflict.reason
+          "#{conflict.name}#{reason}"
+        end.sort!
+        unless conflicts.empty?
+          puts <<~EOS
+            Conflicts with:
+              #{conflicts.join("\n  ")}
+          EOS
+        end
 
-    kegs = f.installed_kegs
-    heads, versioned = kegs.partition { |k| k.version.head? }
-    kegs = [
-      *heads.sort_by { |k| -Tab.for_keg(k).time.to_i },
-      *versioned.sort_by(&:version),
-    ]
-    if kegs.empty?
-      puts "Not installed"
-    else
-      kegs.each do |keg|
-        puts "#{keg} (#{keg.abv})#{" *" if keg.linked?}"
-        tab = Tab.for_keg(keg).to_s
-        puts "  #{tab}" unless tab.empty?
-      end
-    end
+        kegs = formula.installed_kegs
+        heads, versioned = kegs.partition { |keg| keg.version.head? }
+        kegs = [
+          *heads.sort_by { |keg| -keg.tab.time.to_i },
+          *versioned.sort_by(&:scheme_and_version),
+        ]
+        if kegs.empty?
+          puts "Not installed"
+          if (bottle = formula.bottle)
+            begin
+              bottle.fetch_tab(quiet: !args.debug?) if args.fetch_manifest?
+              bottle_size = bottle.bottle_size
+              installed_size = bottle.installed_size
+              puts "Bottle Size: #{disk_usage_readable(bottle_size)}" if bottle_size
+              puts "Installed Size: #{disk_usage_readable(installed_size)}" if installed_size
+            rescue RuntimeError => e
+              odebug e
+            end
+          end
+        else
+          puts "Installed"
+          kegs.each do |keg|
+            puts "#{keg} (#{keg.abv})#{" *" if keg.linked?}"
+            tab = keg.tab.to_s
+            puts "  #{tab}" unless tab.empty?
+          end
+        end
 
-    puts "From: #{Formatter.url(github_info(f))}"
+        puts "From: #{Formatter.url(github_info(formula))}"
 
-    puts "License: #{SPDX.license_expression_to_string f.license}" if f.license.present?
+        puts "License: #{SPDX.license_expression_to_string formula.license}" if formula.license.present?
 
-    unless f.deps.empty?
-      ohai "Dependencies"
-      %w[build required recommended optional].map do |type|
-        deps = f.deps.send(type).uniq
-        puts "#{type.capitalize}: #{decorate_dependencies deps}" unless deps.empty?
-      end
-    end
+        unless formula.deps.empty?
+          ohai "Dependencies"
+          %w[build required recommended optional].map do |type|
+            deps = formula.deps.send(type).uniq
+            puts "#{type.capitalize}: #{decorate_dependencies deps}" unless deps.empty?
+          end
+        end
 
-    unless f.requirements.to_a.empty?
-      ohai "Requirements"
-      %w[build required recommended optional].map do |type|
-        reqs = f.requirements.select(&:"#{type}?")
-        next if reqs.to_a.empty?
+        unless formula.requirements.to_a.empty?
+          ohai "Requirements"
+          %w[build required recommended optional].map do |type|
+            reqs = formula.requirements.select(&:"#{type}?")
+            next if reqs.to_a.empty?
 
-        puts "#{type.capitalize}: #{decorate_requirements(reqs)}"
-      end
-    end
+            puts "#{type.capitalize}: #{decorate_requirements(reqs)}"
+          end
+        end
 
-    if !f.options.empty? || f.head
-      ohai "Options"
-      Options.dump_for_formula f
-    end
+        if !formula.options.empty? || formula.head
+          ohai "Options"
+          Options.dump_for_formula formula
+        end
 
-    caveats = Caveats.new(f)
-    ohai "Caveats", caveats.to_s unless caveats.empty?
+        caveats = Caveats.new(formula)
+        ohai "Caveats", caveats.to_s unless caveats.empty?
 
-    Utils::Analytics.formula_output(f, args: args)
-  end
+        Utils::Analytics.formula_output(formula, args:)
+      end
 
-  def decorate_dependencies(dependencies)
-    deps_status = dependencies.map do |dep|
-      if dep.satisfied?([])
-        pretty_installed(dep_display_s(dep))
-      else
-        pretty_uninstalled(dep_display_s(dep))
+      def decorate_dependencies(dependencies)
+        deps_status = dependencies.map do |dep|
+          if dep.satisfied?([])
+            pretty_installed(dep_display_s(dep))
+          else
+            pretty_uninstalled(dep_display_s(dep))
+          end
+        end
+        deps_status.join(", ")
       end
-    end
-    deps_status.join(", ")
-  end
 
-  def decorate_requirements(requirements)
-    req_status = requirements.map do |req|
-      req_s = req.display_s
-      req.satisfied? ? pretty_installed(req_s) : pretty_uninstalled(req_s)
-    end
-    req_status.join(", ")
-  end
+      def decorate_requirements(requirements)
+        req_status = requirements.map do |req|
+          req_s = req.display_s
+          req.satisfied? ? pretty_installed(req_s) : pretty_uninstalled(req_s)
+        end
+        req_status.join(", ")
+      end
 
-  def dep_display_s(dep)
-    return dep.name if dep.option_tags.empty?
+      def dep_display_s(dep)
+        return dep.name if dep.option_tags.empty?
 
-    "#{dep.name} #{dep.option_tags.map { |o| "--#{o}" }.join(" ")}"
-  end
+        "#{dep.name} #{dep.option_tags.map { |o| "--#{o}" }.join(" ")}"
+      end
 
-  def info_cask(cask, args:)
-    require "cask/cmd"
-    require "cask/cmd/info"
+      def info_cask(cask)
+        require "cask/info"
 
-    Cask::Cmd::Info.info(cask)
+        Cask::Info.info(cask)
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/cmd/install.rb b/Library/Homebrew/cmd/install.rb
index cff794979e32a..defbe8f820d5d 100644
--- a/Library/Homebrew/cmd/install.rb
+++ b/Library/Homebrew/cmd/install.rb
@@ -1,308 +1,416 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "cask/config"
-require "cask/cmd"
-require "cask/cmd/install"
+require "cask/installer"
+require "cask_dependent"
 require "missing_formula"
 require "formula_installer"
 require "development_tools"
 require "install"
-require "search"
 require "cleanup"
-require "cli/parser"
 require "upgrade"
 
 module Homebrew
-  extend T::Sig
-
-  extend Search
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def install_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Install a <formula> or <cask>. Additional options specific to a <formula> may be
-        appended to the command.
-
-        Unless `HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew reinstall` will be run for
-        outdated dependents and dependents with broken linkage, respectively.
-
-        Unless `HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for
-        the installed formulae or, every 30 days, for all formulae.
-
-        Unless `HOMEBREW_NO_INSTALL_UPGRADE` is set, `brew install <formula>` will upgrade <formula> if it
-        is already installed but outdated.
-      EOS
-      switch "-d", "--debug",
-             description: "If brewing fails, open an interactive debugging session with access to IRB " \
-                          "or a shell inside the temporary build directory."
-      switch "-f", "--force",
-             description: "Install formulae without checking for previously installed keg-only or " \
-                          "non-migrated versions. When installing casks, overwrite existing files " \
-                          "(binaries and symlinks are excluded, unless originally from the same cask)."
-      switch "-v", "--verbose",
-             description: "Print the verification and postinstall steps."
-      [
-        [:switch, "--formula", "--formulae", {
-          description: "Treat all named arguments as formulae.",
-        }],
-        [:flag, "--env=", {
-          description: "Disabled other than for internal Homebrew use.",
-          hidden:      true,
-        }],
-        [:switch, "--ignore-dependencies", {
-          description: "An unsupported Homebrew development flag to skip installing any dependencies of any kind. " \
-                       "If the dependencies are not already present, the formula will have issues. If you're not " \
-                       "developing Homebrew, consider adjusting your PATH rather than using this flag.",
-        }],
-        [:switch, "--only-dependencies", {
-          description: "Install the dependencies with specified options but do not install the " \
-                       "formula itself.",
-        }],
-        [:flag, "--cc=", {
-          description: "Attempt to compile using the specified <compiler>, which should be the name of the " \
-                       "compiler's executable, e.g. `gcc-7` for GCC 7. In order to use LLVM's clang, specify " \
-                       "`llvm_clang`. To use the Apple-provided clang, specify `clang`. This option will only " \
-                       "accept compilers that are provided by Homebrew or bundled with macOS. Please do not " \
-                       "file issues if you encounter errors while using this option.",
-        }],
-        [:switch, "-s", "--build-from-source", {
-          description: "Compile <formula> from source even if a bottle is provided. " \
-                       "Dependencies will still be installed from bottles if they are available.",
-        }],
-        [:switch, "--force-bottle", {
-          description: "Install from a bottle if it exists for the current or newest version of " \
-                       "macOS, even if it would not normally be used for installation.",
-        }],
-        [:switch, "--include-test", {
-          description: "Install testing dependencies required to run `brew test` <formula>.",
-        }],
-        [:switch, "--HEAD", {
-          description: "If <formula> defines it, install the HEAD version, aka. main, trunk, unstable, master.",
-        }],
-        [:switch, "--fetch-HEAD", {
-          description: "Fetch the upstream repository to detect if the HEAD installation of the " \
-                       "formula is outdated. Otherwise, the repository's HEAD will only be checked for " \
-                       "updates when a new stable or development version has been released.",
-        }],
-        [:switch, "--keep-tmp", {
-          description: "Retain the temporary files created during installation.",
-        }],
-        [:switch, "--build-bottle", {
-          description: "Prepare the formula for eventual bottling during installation, skipping any " \
-                       "post-install steps.",
-        }],
-        [:flag, "--bottle-arch=", {
-          depends_on:  "--build-bottle",
-          description: "Optimise bottles for the specified architecture rather than the oldest " \
-                       "architecture supported by the version of macOS the bottles are built on.",
-        }],
-        [:switch, "--display-times", {
-          env:         :display_install_times,
-          description: "Print install times for each package at the end of the run.",
-        }],
-        [:switch, "-i", "--interactive", {
-          description: "Download and patch <formula>, then open a shell. This allows the user to " \
-                       "run `./configure --help` and otherwise determine how to turn the software " \
-                       "package into a Homebrew package.",
-        }],
-        [:switch, "-g", "--git", {
-          description: "Create a Git repository, useful for creating patches to the software.",
-        }],
-        [:switch, "--overwrite", {
-          description: "Delete files that already exist in the prefix while linking.",
-        }],
-      ].each do |*args, **options|
-        send(*args, **options)
-        conflicts "--cask", args.last
+  module Cmd
+    class InstallCmd < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Install a <formula> or <cask>. Additional options specific to a <formula> may be
+          appended to the command.
+
+          Unless `HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew reinstall` will be run for
+          outdated dependents and dependents with broken linkage, respectively.
+
+          Unless `HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for
+          the installed formulae or, every 30 days, for all formulae.
+
+          Unless `HOMEBREW_NO_INSTALL_UPGRADE` is set, `brew install` <formula> will upgrade <formula> if it
+          is already installed but outdated.
+        EOS
+        switch "-d", "--debug",
+               description: "If brewing fails, open an interactive debugging session with access to IRB " \
+                            "or a shell inside the temporary build directory."
+        switch "--display-times",
+               env:         :display_install_times,
+               description: "Print install times for each package at the end of the run."
+        switch "-f", "--force",
+               description: "Install formulae without checking for previously installed keg-only or " \
+                            "non-migrated versions. When installing casks, overwrite existing files " \
+                            "(binaries and symlinks are excluded, unless originally from the same cask)."
+        switch "-v", "--verbose",
+               description: "Print the verification and post-install steps."
+        switch "-n", "--dry-run",
+               description: "Show what would be installed, but do not actually install anything."
+        [
+          [:switch, "--formula", "--formulae", {
+            description: "Treat all named arguments as formulae.",
+          }],
+          [:flag, "--env=", {
+            description: "Disabled other than for internal Homebrew use.",
+            hidden:      true,
+          }],
+          [:switch, "--ignore-dependencies", {
+            description: "An unsupported Homebrew development option to skip installing any dependencies of any " \
+                         "kind. If the dependencies are not already present, the formula will have issues. If " \
+                         "you're not developing Homebrew, consider adjusting your PATH rather than using this " \
+                         "option.",
+          }],
+          [:switch, "--only-dependencies", {
+            description: "Install the dependencies with specified options but do not install the " \
+                         "formula itself.",
+          }],
+          [:flag, "--cc=", {
+            description: "Attempt to compile using the specified <compiler>, which should be the name of the " \
+                         "compiler's executable, e.g. `gcc-9` for GCC 9. In order to use LLVM's clang, specify " \
+                         "`llvm_clang`. To use the Apple-provided clang, specify `clang`. This option will only " \
+                         "accept compilers that are provided by Homebrew or bundled with macOS. Please do not " \
+                         "file issues if you encounter errors while using this option.",
+          }],
+          [:switch, "-s", "--build-from-source", {
+            description: "Compile <formula> from source even if a bottle is provided. " \
+                         "Dependencies will still be installed from bottles if they are available.",
+          }],
+          [:switch, "--force-bottle", {
+            description: "Install from a bottle if it exists for the current or newest version of " \
+                         "macOS, even if it would not normally be used for installation.",
+          }],
+          [:switch, "--include-test", {
+            description: "Install testing dependencies required to run `brew test` <formula>.",
+          }],
+          [:switch, "--HEAD", {
+            description: "If <formula> defines it, install the HEAD version, aka. main, trunk, unstable, master.",
+          }],
+          [:switch, "--fetch-HEAD", {
+            description: "Fetch the upstream repository to detect if the HEAD installation of the " \
+                         "formula is outdated. Otherwise, the repository's HEAD will only be checked for " \
+                         "updates when a new stable or development version has been released.",
+          }],
+          [:switch, "--keep-tmp", {
+            description: "Retain the temporary files created during installation.",
+          }],
+          [:switch, "--debug-symbols", {
+            depends_on:  "--build-from-source",
+            description: "Generate debug symbols on build. Source will be retained in a cache directory.",
+          }],
+          [:switch, "--build-bottle", {
+            description: "Prepare the formula for eventual bottling during installation, skipping any " \
+                         "post-install steps.",
+          }],
+          [:switch, "--skip-post-install", {
+            description: "Install but skip any post-install steps.",
+          }],
+          [:flag, "--bottle-arch=", {
+            depends_on:  "--build-bottle",
+            description: "Optimise bottles for the specified architecture rather than the oldest " \
+                         "architecture supported by the version of macOS the bottles are built on.",
+          }],
+          [:switch, "-i", "--interactive", {
+            description: "Download and patch <formula>, then open a shell. This allows the user to " \
+                         "run `./configure --help` and otherwise determine how to turn the software " \
+                         "package into a Homebrew package.",
+          }],
+          [:switch, "-g", "--git", {
+            description: "Create a Git repository, useful for creating patches to the software.",
+          }],
+          [:switch, "--overwrite", {
+            description: "Delete files that already exist in the prefix while linking.",
+          }],
+        ].each do |args|
+          options = args.pop
+          send(*args, **options)
+          conflicts "--cask", args.last
+        end
+        formula_options
+        [
+          [:switch, "--cask", "--casks", { description: "Treat all named arguments as casks." }],
+          [:switch, "--[no-]binaries", {
+            description: "Disable/enable linking of helper executables (default: enabled).",
+            env:         :cask_opts_binaries,
+          }],
+          [:switch, "--require-sha",  {
+            description: "Require all casks to have a checksum.",
+            env:         :cask_opts_require_sha,
+          }],
+          [:switch, "--[no-]quarantine", {
+            description: "Disable/enable quarantining of downloads (default: enabled).",
+            env:         :cask_opts_quarantine,
+          }],
+          [:switch, "--adopt", {
+            description: "Adopt existing artifacts in the destination that are identical to those being installed. " \
+                         "Cannot be combined with `--force`.",
+          }],
+          [:switch, "--skip-cask-deps", {
+            description: "Skip installing cask dependencies.",
+          }],
+          [:switch, "--zap", {
+            description: "For use with `brew reinstall --cask`. Remove all files associated with a cask. " \
+                         "*May remove files which are shared between applications.*",
+          }],
+        ].each do |args|
+          options = args.pop
+          send(*args, **options)
+          conflicts "--formula", args.last
+        end
+        cask_options
+
+        conflicts "--ignore-dependencies", "--only-dependencies"
+        conflicts "--build-from-source", "--build-bottle", "--force-bottle"
+        conflicts "--adopt", "--force"
+
+        named_args [:formula, :cask], min: 1
       end
-      formula_options
-      [
-        [:switch, "--cask", "--casks", { description: "Treat all named arguments as casks." }],
-        *Cask::Cmd::AbstractCommand::OPTIONS,
-        *Cask::Cmd::Install::OPTIONS,
-      ].each do |*args, **options|
-        send(*args, **options)
-        conflicts "--formula", args.last
-      end
-      cask_options
-
-      conflicts "--ignore-dependencies", "--only-dependencies"
-      conflicts "--build-from-source", "--build-bottle", "--force-bottle"
-
-      named_args [:formula, :cask], min: 1
-    end
-  end
-
-  def install
-    args = install_args.parse
-
-    if args.build_from_source? && Homebrew::EnvConfig.install_from_api?
-      raise UsageError, "--build-from-source is not supported when using HOMEBREW_INSTALL_FROM_API."
-    end
-
-    if args.env.present?
-      # Can't use `replacement: false` because `install_args` are used by
-      # `build.rb`. Instead, `hide_from_man_page` and don't do anything with
-      # this argument here.
-      odisabled "brew install --env", "`env :std` in specific formula files"
-    end
-
-    args.named.each do |name|
-      next if File.exist?(name)
-      next unless name =~ HOMEBREW_TAP_FORMULA_REGEX
-
-      tap = Tap.fetch(Regexp.last_match(1), Regexp.last_match(2))
-      next if (tap.core_tap? || tap == "homebrew/cask") && EnvConfig.install_from_api?
-
-      tap.install unless tap.installed?
-    end
-
-    if args.ignore_dependencies?
-      opoo <<~EOS
-        #{Tty.bold}`--ignore-dependencies` is an unsupported Homebrew developer flag!#{Tty.reset}
-        Adjust your PATH to put any preferred versions of applications earlier in the
-        PATH rather than using this unsupported flag!
-
-      EOS
-    end
-
-    begin
-      formulae, casks = args.named.to_formulae_and_casks
-                            .partition { |formula_or_cask| formula_or_cask.is_a?(Formula) }
-    rescue FormulaOrCaskUnavailableError, Cask::CaskUnavailableError => e
-      retry if Tap.install_default_cask_tap_if_necessary(force: args.cask?)
 
-      raise e
-    end
-
-    if casks.any?
-      Cask::Cmd::Install.install_casks(
-        *casks,
-        binaries:       args.binaries?,
-        verbose:        args.verbose?,
-        force:          args.force?,
-        require_sha:    args.require_sha?,
-        skip_cask_deps: args.skip_cask_deps?,
-        quarantine:     args.quarantine?,
-        quiet:          args.quiet?,
-      )
-    end
-
-    # if the user's flags will prevent bottle only-installations when no
-    # developer tools are available, we need to stop them early on
-    unless DevelopmentTools.installed?
-      build_flags = []
-
-      build_flags << "--HEAD" if args.HEAD?
-      build_flags << "--build-bottle" if args.build_bottle?
-      build_flags << "--build-from-source" if args.build_from_source?
-
-      raise BuildFlagsError.new(build_flags, bottled: formulae.all?(&:bottled?)) if build_flags.present?
-    end
-
-    installed_formulae = formulae.select do |f|
-      Install.install_formula?(
-        f,
-        head:              args.HEAD?,
-        fetch_head:        args.fetch_HEAD?,
-        only_dependencies: args.only_dependencies?,
-        force:             args.force?,
-        quiet:             args.quiet?,
-      )
-    end
-
-    return if installed_formulae.empty?
-
-    Install.perform_preinstall_checks(cc: args.cc)
-
-    Install.install_formulae(
-      installed_formulae,
-      build_bottle:               args.build_bottle?,
-      force_bottle:               args.force_bottle?,
-      bottle_arch:                args.bottle_arch,
-      ignore_deps:                args.ignore_dependencies?,
-      only_deps:                  args.only_dependencies?,
-      include_test_formulae:      args.include_test_formulae,
-      build_from_source_formulae: args.build_from_source_formulae,
-      cc:                         args.cc,
-      git:                        args.git?,
-      interactive:                args.interactive?,
-      keep_tmp:                   args.keep_tmp?,
-      force:                      args.force?,
-      overwrite:                  args.overwrite?,
-      debug:                      args.debug?,
-      quiet:                      args.quiet?,
-      verbose:                    args.verbose?,
-    )
-
-    Upgrade.check_installed_dependents(
-      installed_formulae,
-      flags:                      args.flags_only,
-      installed_on_request:       args.named.present?,
-      force_bottle:               args.force_bottle?,
-      build_from_source_formulae: args.build_from_source_formulae,
-      interactive:                args.interactive?,
-      keep_tmp:                   args.keep_tmp?,
-      force:                      args.force?,
-      debug:                      args.debug?,
-      quiet:                      args.quiet?,
-      verbose:                    args.verbose?,
-    )
-
-    Homebrew.messages.display_messages(display_times: args.display_times?)
-  rescue FormulaUnreadableError, FormulaClassUnavailableError,
-         TapFormulaUnreadableError, TapFormulaClassUnavailableError => e
-    # Need to rescue before `FormulaUnavailableError` (superclass of this)
-    # is handled, as searching for a formula doesn't make sense here (the
-    # formula was found, but there's a problem with its implementation).
-    $stderr.puts e.backtrace if Homebrew::EnvConfig.developer?
-    ofail e.message
-  rescue FormulaOrCaskUnavailableError => e
-    if e.name == "updog"
-      ofail "What's updog?"
-      return
-    end
-
-    opoo e
-    ohai "Searching for similarly named formulae..."
-    formulae_search_results = search_formulae(e.name)
-    case formulae_search_results.length
-    when 0
-      ofail "No similarly named formulae found."
-    when 1
-      puts "This similarly named formula was found:"
-      puts formulae_search_results
-      puts "To install it, run:\n  brew install #{formulae_search_results.first}"
-    else
-      puts "These similarly named formulae were found:"
-      puts Formatter.columns(formulae_search_results)
-      puts "To install one of them, run (for example):\n  brew install #{formulae_search_results.first}"
-    end
-
-    if (reason = MissingFormula.reason(e.name))
-      $stderr.puts reason
-      return
-    end
-
-    # Do not search taps if the formula name is qualified
-    return if e.name.include?("/")
-
-    taps_search_results = search_taps(e.name)[:formulae]
-    case taps_search_results.length
-    when 0
-      ofail "No formulae found in taps."
-    when 1
-      puts "This formula was found in a tap:"
-      puts taps_search_results
-      puts "To install it, run:\n  brew install #{taps_search_results.first}"
-    else
-      puts "These formulae were found in taps:"
-      puts Formatter.columns(taps_search_results)
-      puts "To install one of them, run (for example):\n  brew install #{taps_search_results.first}"
+      sig { override.void }
+      def run
+        if args.env.present?
+          # Can't use `replacement: false` because `install_args` are used by
+          # `build.rb`. Instead, `hide_from_man_page` and don't do anything with
+          # this argument here.
+          # This odisabled should stick around indefinitely.
+          odisabled "brew install --env", "`env :std` in specific formula files"
+        end
+
+        args.named.each do |name|
+          if (tap_with_name = Tap.with_formula_name(name))
+            tap, = tap_with_name
+          elsif (tap_with_token = Tap.with_cask_token(name))
+            tap, = tap_with_token
+          end
+
+          tap&.ensure_installed!
+        end
+
+        if args.ignore_dependencies?
+          opoo <<~EOS
+            #{Tty.bold}`--ignore-dependencies` is an unsupported Homebrew developer option!#{Tty.reset}
+            Adjust your PATH to put any preferred versions of applications earlier in the
+            PATH rather than using this unsupported option!
+
+          EOS
+        end
+
+        begin
+          formulae, casks = T.cast(
+            args.named.to_formulae_and_casks(warn: false).partition { _1.is_a?(Formula) },
+            [T::Array[Formula], T::Array[Cask::Cask]],
+          )
+        rescue FormulaOrCaskUnavailableError, Cask::CaskUnavailableError
+          cask_tap = CoreCaskTap.instance
+          if !cask_tap.installed? && (args.cask? || Tap.untapped_official_taps.exclude?(cask_tap.name))
+            cask_tap.ensure_installed!
+            retry if cask_tap.installed?
+          end
+
+          raise
+        end
+
+        if casks.any?
+          if args.dry_run?
+            if (casks_to_install = casks.reject(&:installed?).presence)
+              ohai "Would install #{::Utils.pluralize("cask", casks_to_install.count, include_count: true)}:"
+              puts casks_to_install.map(&:full_name).join(" ")
+            end
+            casks.each do |cask|
+              dep_names = CaskDependent.new(cask)
+                                       .runtime_dependencies
+                                       .reject(&:installed?)
+                                       .map(&:to_formula)
+                                       .map(&:name)
+              next if dep_names.blank?
+
+              ohai "Would install #{::Utils.pluralize("dependenc", dep_names.count, plural: "ies", singular: "y",
+                                                  include_count: true)} for #{cask.full_name}:"
+              puts dep_names.join(" ")
+            end
+            return
+          end
+
+          require "cask/installer"
+
+          installed_casks, new_casks = casks.partition(&:installed?)
+
+          new_casks.each do |cask|
+            Cask::Installer.new(
+              cask,
+              binaries:       args.binaries?,
+              verbose:        args.verbose?,
+              force:          args.force?,
+              adopt:          args.adopt?,
+              require_sha:    args.require_sha?,
+              skip_cask_deps: args.skip_cask_deps?,
+              quarantine:     args.quarantine?,
+              quiet:          args.quiet?,
+            ).install
+          end
+
+          if !Homebrew::EnvConfig.no_install_upgrade? && installed_casks.any?
+            require "cask/upgrade"
+
+            Cask::Upgrade.upgrade_casks(
+              *installed_casks,
+              force:          args.force?,
+              dry_run:        args.dry_run?,
+              binaries:       args.binaries?,
+              quarantine:     args.quarantine?,
+              require_sha:    args.require_sha?,
+              skip_cask_deps: args.skip_cask_deps?,
+              verbose:        args.verbose?,
+              quiet:          args.quiet?,
+              args:,
+            )
+          end
+        end
+
+        formulae = Homebrew::Attestation.sort_formulae_for_install(formulae) if Homebrew::Attestation.enabled?
+
+        # if the user's flags will prevent bottle only-installations when no
+        # developer tools are available, we need to stop them early on
+        build_flags = []
+        unless DevelopmentTools.installed?
+          build_flags << "--HEAD" if args.HEAD?
+          build_flags << "--build-bottle" if args.build_bottle?
+          build_flags << "--build-from-source" if args.build_from_source?
+
+          raise BuildFlagsError.new(build_flags, bottled: formulae.all?(&:bottled?)) if build_flags.present?
+        end
+
+        if build_flags.present? && !Homebrew::EnvConfig.developer?
+          opoo "building from source is not supported!"
+          puts "You're on your own. Failures are expected so don't create any issues, please!"
+        end
+
+        installed_formulae = formulae.select do |f|
+          Install.install_formula?(
+            f,
+            head:              args.HEAD?,
+            fetch_head:        args.fetch_HEAD?,
+            only_dependencies: args.only_dependencies?,
+            force:             args.force?,
+            quiet:             args.quiet?,
+            overwrite:         args.overwrite?,
+          )
+        end
+
+        return if formulae.any? && installed_formulae.empty?
+
+        Install.perform_preinstall_checks_once
+        Install.check_cc_argv(args.cc)
+
+        Install.install_formulae(
+          installed_formulae,
+          build_bottle:               args.build_bottle?,
+          force_bottle:               args.force_bottle?,
+          bottle_arch:                args.bottle_arch,
+          ignore_deps:                args.ignore_dependencies?,
+          only_deps:                  args.only_dependencies?,
+          include_test_formulae:      args.include_test_formulae,
+          build_from_source_formulae: args.build_from_source_formulae,
+          cc:                         args.cc,
+          git:                        args.git?,
+          interactive:                args.interactive?,
+          keep_tmp:                   args.keep_tmp?,
+          debug_symbols:              args.debug_symbols?,
+          force:                      args.force?,
+          overwrite:                  args.overwrite?,
+          debug:                      args.debug?,
+          quiet:                      args.quiet?,
+          verbose:                    args.verbose?,
+          dry_run:                    args.dry_run?,
+          skip_post_install:          args.skip_post_install?,
+        )
+
+        Upgrade.check_installed_dependents(
+          installed_formulae,
+          flags:                      args.flags_only,
+          installed_on_request:       args.named.present?,
+          force_bottle:               args.force_bottle?,
+          build_from_source_formulae: args.build_from_source_formulae,
+          interactive:                args.interactive?,
+          keep_tmp:                   args.keep_tmp?,
+          debug_symbols:              args.debug_symbols?,
+          force:                      args.force?,
+          debug:                      args.debug?,
+          quiet:                      args.quiet?,
+          verbose:                    args.verbose?,
+          dry_run:                    args.dry_run?,
+        )
+
+        Cleanup.periodic_clean!(dry_run: args.dry_run?)
+
+        Homebrew.messages.display_messages(display_times: args.display_times?)
+      rescue FormulaUnreadableError, FormulaClassUnavailableError,
+             TapFormulaUnreadableError, TapFormulaClassUnavailableError => e
+        require "utils/backtrace"
+
+        # Need to rescue before `FormulaUnavailableError` (superclass of this)
+        # is handled, as searching for a formula doesn't make sense here (the
+        # formula was found, but there's a problem with its implementation).
+        $stderr.puts Utils::Backtrace.clean(e) if Homebrew::EnvConfig.developer?
+        ofail e.message
+      rescue FormulaOrCaskUnavailableError, Cask::CaskUnavailableError => e
+        Homebrew.failed = true
+
+        # formula name or cask token
+        name = case e
+        when FormulaOrCaskUnavailableError then e.name
+        when Cask::CaskUnavailableError then e.token
+        else T.absurd(e)
+        end
+
+        if name == "updog"
+          ofail "What's updog?"
+          return
+        end
+
+        opoo e
+
+        reason = MissingFormula.reason(name, silent: true)
+        if !args.cask? && reason
+          $stderr.puts reason
+          return
+        end
+
+        # We don't seem to get good search results when the tap is specified
+        # so we might as well return early.
+        return if name.include?("/")
+
+        require "search"
+
+        package_types = []
+        package_types << "formulae" unless args.cask?
+        package_types << "casks" unless args.formula?
+
+        ohai "Searching for similarly named #{package_types.join(" and ")}..."
+
+        # Don't treat formula/cask name as a regex
+        string_or_regex = name
+        all_formulae, all_casks = Search.search_names(string_or_regex, args)
+
+        if all_formulae.any?
+          ohai "Formulae", Formatter.columns(all_formulae)
+          first_formula = all_formulae.first.to_s
+          puts <<~EOS
+
+            To install #{first_formula}, run:
+              brew install #{first_formula}
+          EOS
+        end
+        puts if all_formulae.any? && all_casks.any?
+        if all_casks.any?
+          ohai "Casks", Formatter.columns(all_casks)
+          first_cask = all_casks.first.to_s
+          puts <<~EOS
+
+            To install #{first_cask}, run:
+              brew install --cask #{first_cask}
+          EOS
+        end
+        return if all_formulae.any? || all_casks.any?
+
+        odie "No #{package_types.join(" or ")} found for #{name}."
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cmd/leaves.rb b/Library/Homebrew/cmd/leaves.rb
index 1c003b4b96703..8bf66f3f46d5c 100644
--- a/Library/Homebrew/cmd/leaves.rb
+++ b/Library/Homebrew/cmd/leaves.rb
@@ -1,49 +1,53 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
-require "cli/parser"
+require "cask_dependent"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def leaves_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        List installed formulae that are not dependencies of another installed formula.
-      EOS
-      switch "-r", "--installed-on-request",
-             description: "Only list leaves that were manually installed."
-      switch "-p", "--installed-as-dependency",
-             description: "Only list leaves that were installed as dependencies."
-
-      conflicts "--installed-on-request", "--installed-as-dependency"
-
-      named_args :none
+  module Cmd
+    class Leaves < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          List installed formulae that are not dependencies of another installed formula or cask.
+        EOS
+        switch "-r", "--installed-on-request",
+               description: "Only list leaves that were manually installed."
+        switch "-p", "--installed-as-dependency",
+               description: "Only list leaves that were installed as dependencies."
+
+        conflicts "--installed-on-request", "--installed-as-dependency"
+
+        named_args :none
+      end
+
+      sig { override.void }
+      def run
+        leaves_list = Formula.installed - Formula.installed.flat_map(&:runtime_formula_dependencies)
+        casks_runtime_dependencies = Cask::Caskroom.casks.flat_map do |cask|
+          CaskDependent.new(cask).runtime_dependencies.map(&:to_formula)
+        end
+        leaves_list -= casks_runtime_dependencies
+        leaves_list.select! { installed_on_request?(_1) } if args.installed_on_request?
+        leaves_list.select! { installed_as_dependency?(_1) } if args.installed_as_dependency?
+
+        leaves_list.map(&:full_name)
+                   .sort
+                   .each { puts(_1) }
+      end
+
+      private
+
+      sig { params(formula: Formula).returns(T::Boolean) }
+      def installed_on_request?(formula)
+        formula.any_installed_keg&.tab&.installed_on_request
+      end
+
+      sig { params(formula: Formula).returns(T::Boolean) }
+      def installed_as_dependency?(formula)
+        formula.any_installed_keg&.tab&.installed_as_dependency
+      end
     end
   end
-
-  def installed_on_request?(formula)
-    Tab.for_keg(formula.any_installed_keg).installed_on_request
-  end
-
-  def installed_as_dependency?(formula)
-    Tab.for_keg(formula.any_installed_keg).installed_as_dependency
-  end
-
-  def leaves
-    args = leaves_args.parse
-
-    leaves_list = Formula.installed_formulae_with_no_dependents
-
-    leaves_list.select!(&method(:installed_on_request?)) if args.installed_on_request?
-    leaves_list.select!(&method(:installed_as_dependency?)) if args.installed_as_dependency?
-
-    leaves_list.map(&:full_name)
-               .sort
-               .each(&method(:puts))
-  end
 end
diff --git a/Library/Homebrew/cmd/link.rb b/Library/Homebrew/cmd/link.rb
index d52f4c5f3a911..6725453e6f029 100644
--- a/Library/Homebrew/cmd/link.rb
+++ b/Library/Homebrew/cmd/link.rb
@@ -1,138 +1,139 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "ostruct"
+require "abstract_command"
 require "caveats"
-require "cli/parser"
 require "unlink"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def link_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Symlink all of <formula>'s installed files into Homebrew's prefix. This
-        is done automatically when you install formulae but can be useful for DIY
-        installations.
-      EOS
-      switch "--overwrite",
-             description: "Delete files that already exist in the prefix while linking."
-      switch "-n", "--dry-run",
-             description: "List files which would be linked or deleted by " \
-                          "`brew link --overwrite` without actually linking or deleting any files."
-      switch "-f", "--force",
-             description: "Allow keg-only formulae to be linked."
-      switch "--HEAD",
-             description: "Link the HEAD version of the formula if it is installed."
-
-      named_args :installed_formula, min: 1
-    end
-  end
-
-  def link
-    args = link_args.parse
-
-    options = {
-      overwrite: args.overwrite?,
-      dry_run:   args.dry_run?,
-      verbose:   args.verbose?,
-    }
-
-    kegs = if args.HEAD?
-      args.named.to_kegs.group_by(&:name).map do |name, resolved_kegs|
-        head_keg = resolved_kegs.find { |keg| keg.version.head? }
-        next head_keg if head_keg.present?
-
-        opoo <<~EOS
-          No HEAD keg installed for #{name}
-          To install, run:
-            brew install --HEAD #{name}
+  module Cmd
+    class Link < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Symlink all of <formula>'s installed files into Homebrew's prefix.
+          This is done automatically when you install formulae but can be useful
+          for manual installations.
         EOS
-      end.compact
-    else
-      args.named.to_latest_kegs
-    end
-
-    kegs.freeze.each do |keg|
-      keg_only = Formulary.keg_only?(keg.rack)
-
-      if keg.linked?
-        opoo "Already linked: #{keg}"
-        name_and_flag = "#{"--HEAD " if args.HEAD?}#{"--force " if keg_only}#{keg.name}"
-        puts <<~EOS
-          To relink, run:
-            brew unlink #{keg.name} && brew link #{name_and_flag}
-        EOS
-        next
+        switch "--overwrite",
+               description: "Delete files that already exist in the prefix while linking."
+        switch "-n", "--dry-run",
+               description: "List files which would be linked or deleted by " \
+                            "`brew link --overwrite` without actually linking or deleting any files."
+        switch "-f", "--force",
+               description: "Allow keg-only formulae to be linked."
+        switch "--HEAD",
+               description: "Link the HEAD version of the formula if it is installed."
+
+        named_args :installed_formula, min: 1
       end
 
-      if args.dry_run?
-        if args.overwrite?
-          puts "Would remove:"
+      sig { override.void }
+      def run
+        options = {
+          overwrite: args.overwrite?,
+          dry_run:   args.dry_run?,
+          verbose:   args.verbose?,
+        }
+
+        kegs = if args.HEAD?
+          args.named.to_kegs.group_by(&:name).filter_map do |name, resolved_kegs|
+            head_keg = resolved_kegs.find { |keg| keg.version.head? }
+            next head_keg if head_keg.present?
+
+            opoo <<~EOS
+              No HEAD keg installed for #{name}
+              To install, run:
+                brew install --HEAD #{name}
+            EOS
+
+            nil
+          end
         else
-          puts "Would link:"
+          args.named.to_latest_kegs
         end
-        keg.link(**options)
-        puts_keg_only_path_message(keg) if keg_only
-        next
-      end
 
-      formula = begin
-        keg.to_formula
-      rescue FormulaUnavailableError
-        # Not all kegs may belong to formulae
-        nil
-      end
-
-      if keg_only
-        if HOMEBREW_PREFIX.to_s == HOMEBREW_DEFAULT_PREFIX && formula.present? && formula.keg_only_reason.by_macos?
-          caveats = Caveats.new(formula)
-          opoo <<~EOS
-            Refusing to link macOS provided/shadowed software: #{keg.name}
-            #{caveats.keg_only_text(skip_reason: true).strip}
-          EOS
-          next
-        end
-
-        if !args.force? && (formula.blank? || !formula.keg_only_reason.versioned_formula?)
-          opoo "#{keg.name} is keg-only and must be linked with `--force`."
-          puts_keg_only_path_message(keg)
-          next
+        kegs.freeze.each do |keg|
+          keg_only = Formulary.keg_only?(keg.rack)
+
+          if keg.linked?
+            opoo "Already linked: #{keg}"
+            name_and_flag = "#{"--HEAD " if args.HEAD?}#{"--force " if keg_only}#{keg.name}"
+            puts <<~EOS
+              To relink, run:
+                brew unlink #{keg.name} && brew link #{name_and_flag}
+            EOS
+            next
+          end
+
+          if args.dry_run?
+            if args.overwrite?
+              puts "Would remove:"
+            else
+              puts "Would link:"
+            end
+            keg.link(**options)
+            puts_keg_only_path_message(keg) if keg_only
+            next
+          end
+
+          formula = begin
+            keg.to_formula
+          rescue FormulaUnavailableError
+            # Not all kegs may belong to formulae
+            nil
+          end
+
+          if keg_only
+            if HOMEBREW_PREFIX.to_s == HOMEBREW_DEFAULT_PREFIX && formula.present? &&
+               formula.keg_only_reason.by_macos?
+              caveats = Caveats.new(formula)
+              opoo <<~EOS
+                Refusing to link macOS provided/shadowed software: #{keg.name}
+                #{T.must(caveats.keg_only_text(skip_reason: true)).strip}
+              EOS
+              next
+            end
+
+            if !args.force? && (formula.blank? || !formula.keg_only_reason.versioned_formula?)
+              opoo "#{keg.name} is keg-only and must be linked with `--force`."
+              puts_keg_only_path_message(keg)
+              next
+            end
+          end
+
+          Unlink.unlink_versioned_formulae(formula, verbose: args.verbose?) if formula
+
+          keg.lock do
+            print "Linking #{keg}... "
+            puts if args.verbose?
+
+            begin
+              n = keg.link(**options)
+            rescue Keg::LinkError
+              puts
+              raise
+            else
+              puts "#{n} symlinks created."
+            end
+
+            puts_keg_only_path_message(keg) if keg_only && !Homebrew::EnvConfig.developer?
+          end
         end
       end
 
-      Unlink.unlink_versioned_formulae(formula, verbose: args.verbose?) if formula
-
-      keg.lock do
-        print "Linking #{keg}... "
-        puts if args.verbose?
+      private
 
-        begin
-          n = keg.link(**options)
-        rescue Keg::LinkError
-          puts
-          raise
-        else
-          puts "#{n} symlinks created."
-        end
+      sig { params(keg: Keg).void }
+      def puts_keg_only_path_message(keg)
+        bin = keg/"bin"
+        sbin = keg/"sbin"
+        return if !bin.directory? && !sbin.directory?
 
-        puts_keg_only_path_message(keg) if keg_only && !Homebrew::EnvConfig.developer?
+        opt = HOMEBREW_PREFIX/"opt/#{keg.name}"
+        puts "\nIf you need to have this software first in your PATH instead consider running:"
+        puts "  #{Utils::Shell.prepend_path_in_profile(opt/"bin")}"  if bin.directory?
+        puts "  #{Utils::Shell.prepend_path_in_profile(opt/"sbin")}" if sbin.directory?
       end
     end
   end
-
-  def puts_keg_only_path_message(keg)
-    bin = keg/"bin"
-    sbin = keg/"sbin"
-    return if !bin.directory? && !sbin.directory?
-
-    opt = HOMEBREW_PREFIX/"opt/#{keg.name}"
-    puts "\nIf you need to have this software first in your PATH instead consider running:"
-    puts "  #{Utils::Shell.prepend_path_in_profile(opt/"bin")}"  if bin.directory?
-    puts "  #{Utils::Shell.prepend_path_in_profile(opt/"sbin")}" if sbin.directory?
-  end
 end
diff --git a/Library/Homebrew/cmd/list.rb b/Library/Homebrew/cmd/list.rb
index e8e152b4c3b39..084c74f526b66 100644
--- a/Library/Homebrew/cmd/list.rb
+++ b/Library/Homebrew/cmd/list.rb
@@ -1,245 +1,301 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "metafiles"
 require "formula"
 require "cli/parser"
-require "cask/cmd"
+require "cask/list"
+require "system_command"
+require "tab"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def list_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        List all installed formulae and casks.
-
-        If <formula> is provided, summarise the paths within its current keg.
-        If <cask> is provided, list its artifacts.
-      EOS
-      switch "--formula", "--formulae",
-             description: "List only formulae, or treat all named arguments as formulae."
-      switch "--cask", "--casks",
-             description: "List only casks, or treat all named arguments as casks."
-      switch "--full-name",
-             description: "Print formulae with fully-qualified names. Unless `--full-name`, `--versions` " \
-                          "or `--pinned` are passed, other options (i.e. `-1`, `-l`, `-r` and `-t`) are " \
-                          "passed to `ls`(1) which produces the actual output."
-      switch "--versions",
-             description: "Show the version number for installed formulae, or only the specified " \
-                          "formulae if <formula> are provided."
-      switch "--multiple",
-             depends_on:  "--versions",
-             description: "Only show formulae with multiple versions installed."
-      switch "--pinned",
-             description: "List only pinned formulae, or only the specified (pinned) " \
-                          "formulae if <formula> are provided. See also `pin`, `unpin`."
-      # passed through to ls
-      switch "-1",
-             description: "Force output to be one entry per line. " \
-                          "This is the default when output is not to a terminal."
-      switch "-l",
-             description: "List formulae and/or casks in long format. " \
-                          "Has no effect when a formula or cask name is passed as an argument."
-      switch "-r",
-             description: "Reverse the order of the formulae and/or casks sort to list the oldest entries first. " \
-                          "Has no effect when a formula or cask name is passed as an argument."
-      switch "-t",
-             description: "Sort formulae and/or casks by time modified, listing most recently modified first. " \
-                          "Has no effect when a formula or cask name is passed as an argument."
-
-      conflicts "--formula", "--cask"
-      conflicts "--pinned", "--cask"
-      conflicts "--multiple", "--cask"
-      conflicts "--pinned", "--multiple"
-      ["-1", "-l", "-r", "-t"].each do |flag|
-        conflicts "--versions", flag
-        conflicts "--pinned", flag
-      end
-      ["--versions", "--pinned", "-l", "-r", "-t"].each do |flag|
-        conflicts "--full-name", flag
+  module Cmd
+    class List < AbstractCommand
+      include SystemCommand::Mixin
+
+      cmd_args do
+        description <<~EOS
+          List all installed formulae and casks.
+          If <formula> is provided, summarise the paths within its current keg.
+          If <cask> is provided, list its artifacts.
+        EOS
+        switch "--formula", "--formulae",
+               description: "List only formulae, or treat all named arguments as formulae."
+        switch "--cask", "--casks",
+               description: "List only casks, or treat all named arguments as casks."
+        switch "--full-name",
+               description: "Print formulae with fully-qualified names. Unless `--full-name`, `--versions` " \
+                            "or `--pinned` are passed, other options (i.e. `-1`, `-l`, `-r` and `-t`) are " \
+                            "passed to `ls`(1) which produces the actual output."
+        switch "--versions",
+               description: "Show the version number for installed formulae, or only the specified " \
+                            "formulae if <formula> are provided."
+        switch "--multiple",
+               depends_on:  "--versions",
+               description: "Only show formulae with multiple versions installed."
+        switch "--pinned",
+               description: "List only pinned formulae, or only the specified (pinned) " \
+                            "formulae if <formula> are provided. See also `pin`, `unpin`."
+        switch "--installed-on-request",
+               description: "List the formulae installed on request."
+        switch "--installed-as-dependency",
+               description: "List the formulae installed as dependencies."
+        switch "--poured-from-bottle",
+               description: "List the formulae installed from a bottle."
+        switch "--built-from-source",
+               description: "List the formulae compiled from source."
+
+        # passed through to ls
+        switch "-1",
+               description: "Force output to be one entry per line. " \
+                            "This is the default when output is not to a terminal."
+        switch "-l",
+               description: "List formulae and/or casks in long format. " \
+                            "Has no effect when a formula or cask name is passed as an argument."
+        switch "-r",
+               description: "Reverse the order of the formulae and/or casks sort to list the oldest entries first. " \
+                            "Has no effect when a formula or cask name is passed as an argument."
+        switch "-t",
+               description: "Sort formulae and/or casks by time modified, listing most recently modified first. " \
+                            "Has no effect when a formula or cask name is passed as an argument."
+
+        conflicts "--formula", "--cask"
+        conflicts "--pinned", "--cask"
+        conflicts "--multiple", "--cask"
+        conflicts "--pinned", "--multiple"
+        ["--installed-on-request", "--installed-as-dependency",
+         "--poured-from-bottle", "--built-from-source"].each do |flag|
+          conflicts "--cask", flag
+          conflicts "--versions", flag
+          conflicts "--pinned", flag
+          conflicts "-l", flag
+        end
+        ["-1", "-l", "-r", "-t"].each do |flag|
+          conflicts "--versions", flag
+          conflicts "--pinned", flag
+        end
+        ["--versions", "--pinned",
+         "--installed-on-request", "--installed-as-dependency",
+         "--poured-from-bottle", "--built-from-source",
+         "-l", "-r", "-t"].each do |flag|
+          conflicts "--full-name", flag
+        end
+
+        named_args [:installed_formula, :installed_cask]
       end
 
-      named_args [:installed_formula, :installed_cask]
-    end
-  end
+      sig { override.void }
+      def run
+        if args.full_name?
+          unless args.cask?
+            formula_names = args.no_named? ? Formula.installed : args.named.to_resolved_formulae
+            full_formula_names = formula_names.map(&:full_name).sort(&tap_and_name_comparison)
+            full_formula_names = Formatter.columns(full_formula_names) unless args.public_send(:"1?")
+            puts full_formula_names if full_formula_names.present?
+          end
+          if args.cask? || (!args.formula? && args.no_named?)
+            cask_names = if args.no_named?
+              Cask::Caskroom.casks
+            else
+              args.named.to_formulae_and_casks(only: :cask, method: :resolve)
+            end
+            # The cast is because `Keg`` does not define `full_name`
+            full_cask_names = T.cast(cask_names, T::Array[T.any(Formula, Cask::Cask)])
+                               .map(&:full_name).sort(&tap_and_name_comparison)
+            full_cask_names = Formatter.columns(full_cask_names) unless args.public_send(:"1?")
+            puts full_cask_names if full_cask_names.present?
+          end
+        elsif args.pinned?
+          filtered_list
+        elsif args.versions?
+          filtered_list unless args.cask?
+          list_casks if args.cask? || (!args.formula? && !args.multiple? && args.no_named?)
+        elsif args.installed_on_request? ||
+              args.installed_as_dependency? ||
+              args.poured_from_bottle? ||
+              args.built_from_source?
+          flags = []
+          flags << "`--installed-on-request`" if args.installed_on_request?
+          flags << "`--installed-as-dependency`" if args.installed_as_dependency?
+          flags << "`--poured-from-bottle`" if args.poured_from_bottle?
+          flags << "`--built-from-source`" if args.built_from_source?
 
-  def list
-    args = list_args.parse
+          raise UsageError, "Cannot use #{flags.join(", ")} with formula arguments." unless args.no_named?
 
-    # Unbrewed uses the PREFIX, which will exist
-    # Things below use the CELLAR, which doesn't until the first formula is installed.
-    unless HOMEBREW_CELLAR.exist?
-      raise NoSuchKegError, args.named.first if args.named.present? && !args.cask?
+          formulae = if args.t?
+            Formula.installed.sort_by { |formula| test("M", formula.rack) }.reverse!
+          else
+            Formula.installed.sort
+          end
+          formulae.reverse! if args.r?
+          formulae.each do |formula|
+            tab = Tab.for_formula(formula)
 
-      return
-    end
+            statuses = []
+            statuses << "installed on request" if args.installed_on_request? && tab.installed_on_request
+            statuses << "installed as dependency" if args.installed_as_dependency? && tab.installed_as_dependency
+            statuses << "poured from bottle" if args.poured_from_bottle? && tab.poured_from_bottle
+            statuses << "built from source" if args.built_from_source? && !tab.poured_from_bottle
+            next if statuses.empty?
 
-    if args.full_name?
-      unless args.cask?
-        formula_names = args.no_named? ? Formula.installed : args.named.to_resolved_formulae
-        full_formula_names = formula_names.map(&:full_name).sort(&tap_and_name_comparison)
-        full_formula_names = Formatter.columns(full_formula_names) unless args.public_send(:"1?")
-        puts full_formula_names if full_formula_names.present?
-      end
-      if args.cask? || (!args.formula? && args.no_named?)
-        cask_names = if args.no_named?
-          Cask::Caskroom.casks
+            if flags.count > 1
+              puts "#{formula.name}: #{statuses.join(", ")}"
+            else
+              puts formula.name
+            end
+          end
+        elsif args.no_named?
+          ENV["CLICOLOR"] = nil
+
+          ls_args = []
+          ls_args << "-1" if args.public_send(:"1?")
+          ls_args << "-l" if args.l?
+          ls_args << "-r" if args.r?
+          ls_args << "-t" if args.t?
+
+          if !args.cask? && HOMEBREW_CELLAR.exist? && HOMEBREW_CELLAR.children.any?
+            ohai "Formulae" if $stdout.tty? && !args.formula?
+            safe_system "ls", *ls_args, HOMEBREW_CELLAR
+            puts if $stdout.tty? && !args.formula?
+          end
+          if !args.formula? && Cask::Caskroom.any_casks_installed?
+            ohai "Casks" if $stdout.tty? && !args.cask?
+            safe_system "ls", *ls_args, Cask::Caskroom.path
+          end
         else
-          args.named.to_formulae_and_casks(only: :cask, method: :resolve)
+          kegs, casks = args.named.to_kegs_to_casks
+
+          if args.verbose? || !$stdout.tty?
+            find_args = %w[-not -type d -not -name .DS_Store -print]
+            system_command! "find", args: kegs.map(&:to_s) + find_args, print_stdout: true if kegs.present?
+            system_command! "find", args: casks.map(&:caskroom_path) + find_args, print_stdout: true if casks.present?
+          else
+            kegs.each { |keg| PrettyListing.new keg } if kegs.present?
+            Cask::List.list_casks(*casks, one: args.public_send(:"1?")) if casks.present?
+          end
         end
-        full_cask_names = cask_names.map(&:full_name).sort(&tap_and_name_comparison)
-        full_cask_names = Formatter.columns(full_cask_names) unless args.public_send(:"1?")
-        puts full_cask_names if full_cask_names.present?
       end
-    elsif args.pinned?
-      filtered_list(args: args)
-    elsif args.versions?
-      filtered_list(args: args) unless args.cask?
-      list_casks(args: args) if args.cask? || (!args.formula? && !args.multiple? && args.no_named?)
-    elsif args.no_named?
-      ENV["CLICOLOR"] = nil
-
-      ls_args = []
-      ls_args << "-1" if args.public_send(:"1?")
-      ls_args << "-l" if args.l?
-      ls_args << "-r" if args.r?
-      ls_args << "-t" if args.t?
-
-      if !args.cask? && HOMEBREW_CELLAR.exist? && HOMEBREW_CELLAR.children.any?
-        ohai "Formulae" if $stdout.tty? && !args.formula?
-        safe_system "ls", *ls_args, HOMEBREW_CELLAR
-      end
-      if !args.formula? && Cask::Caskroom.any_casks_installed?
-        if $stdout.tty? && !args.cask?
-          puts
-          ohai "Casks"
+
+      private
+
+      sig { void }
+      def filtered_list
+        names = if args.no_named?
+          Formula.racks
+        else
+          racks = args.named.map { |n| Formulary.to_rack(n) }
+          racks.select do |rack|
+            Homebrew.failed = true unless rack.exist?
+            rack.exist?
+          end
         end
-        safe_system "ls", *ls_args, Cask::Caskroom.path
-      end
-    else
-      kegs, casks = args.named.to_kegs_to_casks
-
-      if args.verbose? || !$stdout.tty?
-        find_args = %w[-not -type d -not -name .DS_Store -print]
-        system_command! "find", args: kegs.map(&:to_s) + find_args, print_stdout: true if kegs.present?
-        system_command! "find", args: casks.map(&:caskroom_path) + find_args, print_stdout: true if casks.present?
-      else
-        kegs.each { |keg| PrettyListing.new keg } if kegs.present?
-        list_casks(args: args) if casks.present?
-      end
-    end
-  end
+        if args.pinned?
+          pinned_versions = {}
+          names.sort.each do |d|
+            keg_pin = (HOMEBREW_PINNED_KEGS/d.basename.to_s)
+            pinned_versions[d] = keg_pin.readlink.basename.to_s if keg_pin.exist? || keg_pin.symlink?
+          end
+          pinned_versions.each do |d, version|
+            puts d.basename.to_s.concat(args.versions? ? " #{version}" : "")
+          end
+        else # --versions without --pinned
+          names.sort.each do |d|
+            versions = d.subdirs.map { |pn| pn.basename.to_s }
+            next if args.multiple? && versions.length < 2
 
-  def filtered_list(args:)
-    names = if args.no_named?
-      Formula.racks
-    else
-      racks = args.named.map { |n| Formulary.to_rack(n) }
-      racks.select do |rack|
-        Homebrew.failed = true unless rack.exist?
-        rack.exist?
-      end
-    end
-    if args.pinned?
-      pinned_versions = {}
-      names.sort.each do |d|
-        keg_pin = (HOMEBREW_PINNED_KEGS/d.basename.to_s)
-        pinned_versions[d] = keg_pin.readlink.basename.to_s if keg_pin.exist? || keg_pin.symlink?
-      end
-      pinned_versions.each do |d, version|
-        puts d.basename.to_s.concat(args.versions? ? " #{version}" : "")
+            puts "#{d.basename} #{versions * " "}"
+          end
+        end
       end
-    else # --versions without --pinned
-      names.sort.each do |d|
-        versions = d.subdirs.map { |pn| pn.basename.to_s }
-        next if args.multiple? && versions.length < 2
 
-        puts "#{d.basename} #{versions * " "}"
+      sig { void }
+      def list_casks
+        casks = if args.no_named?
+          Cask::Caskroom.casks
+        else
+          filtered_args = args.named.dup.delete_if do |n|
+            Homebrew.failed = true unless Cask::Caskroom.path.join(n).exist?
+            !Cask::Caskroom.path.join(n).exist?
+          end
+          # NamedAargs subclasses array
+          T.cast(filtered_args, Homebrew::CLI::NamedArgs).to_formulae_and_casks(only: :cask)
+        end
+        return if casks.blank?
+
+        Cask::List.list_casks(
+          *casks,
+          one:       args.public_send(:"1?"),
+          full_name: args.full_name?,
+          versions:  args.versions?,
+        )
       end
     end
-  end
 
-  def list_casks(args:)
-    casks = if args.no_named?
-      Cask::Caskroom.casks
-    else
-      args.named.dup.delete_if do |n|
-        Homebrew.failed = true unless Cask::Caskroom.path.join(n).exist?
-        !Cask::Caskroom.path.join(n).exist?
-      end.to_formulae_and_casks(only: :cask)
-    end
-    return if casks.blank?
-
-    Cask::Cmd::List.list_casks(
-      *casks,
-      one:       args.public_send(:"1?"),
-      full_name: args.full_name?,
-      versions:  args.versions?,
-    )
-  end
-end
-
-class PrettyListing
-  def initialize(path)
-    Pathname.new(path).children.sort_by { |p| p.to_s.downcase }.each do |pn|
-      case pn.basename.to_s
-      when "bin", "sbin"
-        pn.find { |pnn| puts pnn unless pnn.directory? }
-      when "lib"
-        print_dir pn do |pnn|
-          # dylibs have multiple symlinks and we don't care about them
-          (pnn.extname == ".dylib" || pnn.extname == ".pc") && !pnn.symlink?
-        end
-      when ".brew"
-        next # Ignore .brew
-      else
-        if pn.directory?
-          if pn.symlink?
-            puts "#{pn} -> #{pn.readlink}"
+    class PrettyListing
+      sig { params(path: T.any(String, Pathname, Keg)).void }
+      def initialize(path)
+        Pathname.new(path).children.sort_by { |p| p.to_s.downcase }.each do |pn|
+          case pn.basename.to_s
+          when "bin", "sbin"
+            pn.find { |pnn| puts pnn unless pnn.directory? }
+          when "lib"
+            print_dir pn do |pnn|
+              # dylibs have multiple symlinks and we don't care about them
+              (pnn.extname == ".dylib" || pnn.extname == ".pc") && !pnn.symlink?
+            end
+          when ".brew"
+            next # Ignore .brew
           else
-            print_dir pn
+            if pn.directory?
+              if pn.symlink?
+                puts "#{pn} -> #{pn.readlink}"
+              else
+                print_dir pn
+              end
+            elsif Metafiles.list?(pn.basename.to_s)
+              puts pn
+            end
           end
-        elsif Metafiles.list?(pn.basename.to_s)
-          puts pn
         end
       end
-    end
-  end
 
-  def print_dir(root)
-    dirs = []
-    remaining_root_files = []
-    other = ""
-
-    root.children.sort.each do |pn|
-      if pn.directory?
-        dirs << pn
-      elsif block_given? && yield(pn)
-        puts pn
-        other = "other "
-      else
-        remaining_root_files << pn unless pn.basename.to_s == ".DS_Store"
-      end
-    end
+      private
 
-    dirs.each do |d|
-      files = []
-      d.find { |pn| files << pn unless pn.directory? }
-      print_remaining_files files, d
-    end
+      sig { params(root: Pathname, block: T.nilable(T.proc.params(arg0: Pathname).returns(T::Boolean))).void }
+      def print_dir(root, &block)
+        dirs = []
+        remaining_root_files = []
+        other = ""
 
-    print_remaining_files remaining_root_files, root, other
-  end
+        root.children.sort.each do |pn|
+          if pn.directory?
+            dirs << pn
+          elsif block && yield(pn)
+            puts pn
+            other = "other "
+          elsif pn.basename.to_s != ".DS_Store"
+            remaining_root_files << pn
+          end
+        end
+
+        dirs.each do |d|
+          files = []
+          d.find { |pn| files << pn unless pn.directory? }
+          print_remaining_files files, d
+        end
 
-  def print_remaining_files(files, root, other = "")
-    if files.length == 1
-      puts files
-    elsif files.length > 1
-      puts "#{root}/ (#{files.length} #{other}files)"
+        print_remaining_files remaining_root_files, root, other
+      end
+
+      sig { params(files: T::Array[Pathname], root: Pathname, other: String).void }
+      def print_remaining_files(files, root, other = "")
+        if files.length == 1
+          puts files
+        elsif files.length > 1
+          puts "#{root}/ (#{files.length} #{other}files)"
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cmd/log.rb b/Library/Homebrew/cmd/log.rb
index 9602e87d7c9fc..e76f131b87ab8 100644
--- a/Library/Homebrew/cmd/log.rb
+++ b/Library/Homebrew/cmd/log.rb
@@ -1,86 +1,89 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
+require "fileutils"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class Log < AbstractCommand
+      include FileUtils
 
-  module_function
+      cmd_args do
+        description <<~EOS
+          Show the `git log` for <formula> or <cask>, or show the log for the Homebrew repository
+          if no formula or cask is provided.
+        EOS
+        switch "-p", "-u", "--patch",
+               description: "Also print patch from commit."
+        switch "--stat",
+               description: "Also print diffstat from commit."
+        switch "--oneline",
+               description: "Print only one line per commit."
+        switch "-1",
+               description: "Print only one commit."
+        flag   "-n", "--max-count=",
+               description: "Print only a specified number of commits."
+        switch "--formula", "--formulae",
+               description: "Treat all named arguments as formulae."
+        switch "--cask", "--casks",
+               description: "Treat all named arguments as casks."
 
-  sig { returns(CLI::Parser) }
-  def log_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Show the `git log` for <formula> or <cask>, or show the log for the Homebrew repository
-        if no formula or cask is provided.
-      EOS
-      switch "-p", "-u", "--patch",
-             description: "Also print patch from commit."
-      switch "--stat",
-             description: "Also print diffstat from commit."
-      switch "--oneline",
-             description: "Print only one line per commit."
-      switch "-1",
-             description: "Print only one commit."
-      flag   "-n", "--max-count=",
-             description: "Print only a specified number of commits."
-      switch "--formula", "--formulae",
-             description: "Treat all named arguments as formulae."
-      switch "--cask", "--casks",
-             description: "Treat all named arguments as casks."
+        conflicts "-1", "--max-count"
+        conflicts "--formula", "--cask"
 
-      conflicts "-1", "--max-count"
-      conflicts "--formula", "--cask"
+        named_args [:formula, :cask], max: 1, without_api: true
+      end
 
-      named_args [:formula, :cask], max: 1
-    end
-  end
+      sig { override.void }
+      def run
+        # As this command is simplifying user-run commands then let's just use a
+        # user path, too.
+        ENV["PATH"] = PATH.new(ORIGINAL_PATHS).to_s
 
-  def log
-    args = log_args.parse
+        if args.no_named?
+          git_log(HOMEBREW_REPOSITORY)
+        else
+          path = T.must(args.named.to_paths.first)
+          tap = Tap.from_path(path)
+          git_log path.dirname, path, tap
+        end
+      end
 
-    # As this command is simplifying user-run commands then let's just use a
-    # user path, too.
-    ENV["PATH"] = PATH.new(ORIGINAL_PATHS).to_s
+      private
 
-    if args.no_named?
-      git_log HOMEBREW_REPOSITORY, args: args
-    else
-      path = args.named.to_paths.first
-      tap = Tap.from_path(path)
-      git_log path.dirname, path, tap, args: args
-    end
-  end
+      sig { params(cd_dir: Pathname, path: T.nilable(Pathname), tap: T.nilable(Tap)).void }
+      def git_log(cd_dir, path = nil, tap = nil)
+        cd cd_dir do
+          repo = Utils.popen_read("git", "rev-parse", "--show-toplevel").chomp
+          if tap
+            name = tap.to_s
+            git_cd = "$(brew --repo #{tap})"
+          elsif cd_dir == HOMEBREW_REPOSITORY
+            name = "Homebrew/brew"
+            git_cd = "$(brew --repo)"
+          else
+            name, git_cd = cd_dir
+          end
 
-  def git_log(cd_dir, path = nil, tap = nil, args:)
-    cd cd_dir
-    repo = Utils.popen_read("git", "rev-parse", "--show-toplevel").chomp
-    if tap
-      name = tap.to_s
-      git_cd = "$(brew --repo #{tap})"
-    elsif cd_dir == HOMEBREW_REPOSITORY
-      name = "Homebrew/brew"
-      git_cd = "$(brew --repo)"
-    else
-      name, git_cd = cd_dir
-    end
+          if File.exist? "#{repo}/.git/shallow"
+            opoo <<~EOS
+              #{name} is a shallow clone so only partial output will be shown.
+              To get a full clone, run:
+                git -C "#{git_cd}" fetch --unshallow
+            EOS
+          end
 
-    if File.exist? "#{repo}/.git/shallow"
-      opoo <<~EOS
-        #{name} is a shallow clone so only partial output will be shown.
-        To get a full clone, run:
-          git -C "#{git_cd}" fetch --unshallow
-      EOS
+          git_args = []
+          git_args << "--patch" if args.patch?
+          git_args << "--stat" if args.stat?
+          git_args << "--oneline" if args.oneline?
+          git_args << "-1" if args.public_send(:"1?")
+          git_args << "--max-count" << args.max_count if args.max_count
+          git_args += ["--follow", "--", path] if path&.file?
+          system "git", "log", *git_args
+        end
+      end
     end
-
-    git_args = []
-    git_args << "--patch" if args.patch?
-    git_args << "--stat" if args.stat?
-    git_args << "--oneline" if args.oneline?
-    git_args << "-1" if args.public_send(:"1?")
-    git_args << "--max-count" << args.max_count if args.max_count
-    git_args += ["--follow", "--", path] if path.present?
-    system "git", "log", *git_args
   end
 end
diff --git a/Library/Homebrew/cmd/migrate.rb b/Library/Homebrew/cmd/migrate.rb
index 68cae13b40dfb..7f24aa820e848 100644
--- a/Library/Homebrew/cmd/migrate.rb
+++ b/Library/Homebrew/cmd/migrate.rb
@@ -1,45 +1,44 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "migrator"
-require "cli/parser"
+require "cask/migrator"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def migrate_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Migrate renamed packages to new names, where <formula> are old names of
-        packages.
-      EOS
-      switch "-f", "--force",
-             description: "Treat installed <formula> and provided <formula> as if they are from " \
-                          "the same taps and migrate them anyway."
-      switch "-n", "--dry-run",
-             description: "Show what would be migrated, but do not actually migrate anything."
-
-      named_args :installed_formula, min: 1
-    end
-  end
-
-  def migrate
-    args = migrate_args.parse
-
-    args.named.to_kegs.each do |keg|
-      f = Formulary.from_keg(keg)
-
-      if f.oldname
-        rack = HOMEBREW_CELLAR/f.oldname
-        raise NoSuchKegError, f.oldname if !rack.exist? || rack.subdirs.empty?
-
-        odie "#{rack} is a symlink" if rack.symlink?
+  module Cmd
+    class Migrate < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Migrate renamed packages to new names, where <formula> are old names of
+          packages.
+        EOS
+        switch "-f", "--force",
+               description: "Treat installed <formula> and provided <formula> as if they are from " \
+                            "the same taps and migrate them anyway."
+        switch "-n", "--dry-run",
+               description: "Show what would be migrated, but do not actually migrate anything."
+        switch "--formula", "--formulae",
+               description: "Only migrate formulae."
+        switch "--cask", "--casks",
+               description: "Only migrate casks."
+
+        conflicts "--formula", "--cask"
+
+        named_args [:installed_formula, :installed_cask], min: 1
       end
 
-      Migrator.migrate_if_needed(f, force: args.force?, dry_run: args.dry_run?)
+      sig { override.void }
+      def run
+        args.named.to_formulae_and_casks(warn: false).each do |formula_or_cask|
+          case formula_or_cask
+          when Formula
+            Migrator.migrate_if_needed(formula_or_cask, force: args.force?, dry_run: args.dry_run?)
+          when Cask::Cask
+            Cask::Migrator.migrate_if_needed(formula_or_cask, dry_run: args.dry_run?)
+          end
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cmd/missing.rb b/Library/Homebrew/cmd/missing.rb
index d4784c683d40c..41cce0329db4c 100644
--- a/Library/Homebrew/cmd/missing.rb
+++ b/Library/Homebrew/cmd/missing.rb
@@ -1,50 +1,46 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
 require "tab"
 require "diagnostic"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def missing_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Check the given <formula> kegs for missing dependencies. If no <formula> are
-        provided, check all kegs. Will exit with a non-zero status if any kegs are found
-        to be missing dependencies.
-      EOS
-      comma_array "--hide",
-                  description: "Act as if none of the specified <hidden> are installed. <hidden> should be " \
-                               "a comma-separated list of formulae."
-
-      named_args :formula
-    end
-  end
-
-  def missing
-    args = missing_args.parse
-
-    return unless HOMEBREW_CELLAR.exist?
-
-    ff = if args.no_named?
-      Formula.installed.sort
-    else
-      args.named.to_resolved_formulae.sort
-    end
-
-    ff.each do |f|
-      missing = f.missing_dependencies(hide: args.hide)
-      next if missing.empty?
-
-      Homebrew.failed = true
-      print "#{f}: " if ff.size > 1
-      puts missing.join(" ")
+  module Cmd
+    class Missing < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Check the given <formula> kegs for missing dependencies. If no <formula> are
+          provided, check all kegs. Will exit with a non-zero status if any kegs are found
+          to be missing dependencies.
+        EOS
+        comma_array "--hide",
+                    description: "Act as if none of the specified <hidden> are installed. <hidden> should be " \
+                                 "a comma-separated list of formulae."
+
+        named_args :formula
+      end
+
+      sig { override.void }
+      def run
+        return unless HOMEBREW_CELLAR.exist?
+
+        ff = if args.no_named?
+          Formula.installed.sort
+        else
+          args.named.to_resolved_formulae.sort
+        end
+
+        ff.each do |f|
+          missing = f.missing_dependencies(hide: args.hide)
+          next if missing.empty?
+
+          Homebrew.failed = true
+          print "#{f}: " if ff.size > 1
+          puts missing.join(" ")
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cmd/nodenv-sync.rb b/Library/Homebrew/cmd/nodenv-sync.rb
new file mode 100644
index 0000000000000..5ae54f19ad903
--- /dev/null
+++ b/Library/Homebrew/cmd/nodenv-sync.rb
@@ -0,0 +1,71 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "formula"
+
+module Homebrew
+  module Cmd
+    class NodenvSync < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Create symlinks for Homebrew's installed NodeJS versions in `~/.nodenv/versions`.
+
+          Note that older version symlinks will also be created so e.g. NodeJS 19.1.0 will
+          also be symlinked to 19.0.0.
+        EOS
+
+        named_args :none
+      end
+
+      sig { override.void }
+      def run
+        nodenv_root = Pathname(ENV.fetch("HOMEBREW_NODENV_ROOT", Pathname(Dir.home)/".nodenv"))
+
+        # Don't run multiple times at once.
+        nodenv_sync_running = nodenv_root/".nodenv_sync_running"
+        return if nodenv_sync_running.exist?
+
+        begin
+          nodenv_versions = nodenv_root/"versions"
+          nodenv_versions.mkpath
+          FileUtils.touch nodenv_sync_running
+
+          HOMEBREW_CELLAR.glob("node{,@*}")
+                         .flat_map(&:children)
+                         .each { |path| link_nodenv_versions(path, nodenv_versions) }
+
+          nodenv_versions.children
+                         .select(&:symlink?)
+                         .reject(&:exist?)
+                         .each { |path| FileUtils.rm_f path }
+        ensure
+          nodenv_sync_running.unlink if nodenv_sync_running.exist?
+        end
+      end
+
+      private
+
+      sig { params(path: Pathname, nodenv_versions: Pathname).void }
+      def link_nodenv_versions(path, nodenv_versions)
+        nodenv_versions.mkpath
+
+        version = Keg.new(path).version
+        major_version = version.major.to_i
+        minor_version = version.minor.to_i || 0
+        patch_version = version.patch.to_i || 0
+
+        (0..minor_version).each do |minor|
+          (0..patch_version).each do |patch|
+            link_path = nodenv_versions/"#{major_version}.#{minor}.#{patch}"
+            # Don't clobber existing user installations.
+            next if link_path.exist? && !link_path.symlink?
+
+            FileUtils.rm_f link_path
+            FileUtils.ln_sf path, link_path
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cmd/options.rb b/Library/Homebrew/cmd/options.rb
index c97d57d52805b..ad62093461e05 100644
--- a/Library/Homebrew/cmd/options.rb
+++ b/Library/Homebrew/cmd/options.rb
@@ -1,69 +1,72 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
 require "options"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class OptionsCmd < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Show install options specific to <formula>.
+        EOS
+        switch "--compact",
+               description: "Show all options on a single line separated by spaces."
+        switch "--installed",
+               description: "Show options for formulae that are currently installed."
+        switch "--eval-all",
+               description: "Evaluate all available formulae and casks, whether installed or not, to show their " \
+                            "options."
+        flag   "--command=",
+               description: "Show options for the specified <command>."
 
-  module_function
+        conflicts "--installed", "--all", "--command"
 
-  sig { returns(CLI::Parser) }
-  def options_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Show install options specific to <formula>.
-      EOS
-      switch "--compact",
-             description: "Show all options on a single line separated by spaces."
-      switch "--installed",
-             description: "Show options for formulae that are currently installed."
-      switch "--all",
-             description: "Show options for all available formulae."
-      flag   "--command=",
-             description: "Show options for the specified <command>."
-
-      conflicts "--installed", "--all", "--command"
-
-      named_args :formula
-    end
-  end
+        named_args :formula
+      end
 
-  def options
-    args = options_args.parse
+      sig { override.void }
+      def run
+        all = args.eval_all?
 
-    if args.all?
-      puts_options Formula.all.sort, args: args
-    elsif args.installed?
-      puts_options Formula.installed.sort, args: args
-    elsif args.command.present?
-      cmd_options = Commands.command_options(args.command)
-      odie "Unknown command: #{args.command}" if cmd_options.nil?
+        if all
+          puts_options(Formula.all(eval_all: args.eval_all?).sort)
+        elsif args.installed?
+          puts_options(Formula.installed.sort)
+        elsif args.command.present?
+          cmd_options = Commands.command_options(T.must(args.command))
+          odie "Unknown command: brew #{args.command}" if cmd_options.nil?
 
-      if args.compact?
-        puts cmd_options.sort.map(&:first) * " "
-      else
-        cmd_options.sort.each { |option, desc| puts "#{option}\n\t#{desc}" }
-        puts
+          if args.compact?
+            puts cmd_options.sort.map(&:first) * " "
+          else
+            cmd_options.sort.each { |option, desc| puts "#{option}\n\t#{desc}" }
+            puts
+          end
+        elsif args.no_named?
+          raise FormulaUnspecifiedError
+        else
+          puts_options args.named.to_formulae
+        end
       end
-    elsif args.no_named?
-      raise FormulaUnspecifiedError
-    else
-      puts_options args.named.to_formulae, args: args
-    end
-  end
 
-  def puts_options(formulae, args:)
-    formulae.each do |f|
-      next if f.options.empty?
+      private
+
+      sig { params(formulae: T::Array[Formula]).void }
+      def puts_options(formulae)
+        formulae.each do |f|
+          next if f.options.empty?
 
-      if args.compact?
-        puts f.options.as_flags.sort * " "
-      else
-        puts f.full_name if formulae.length > 1
-        Options.dump_for_formula f
-        puts
+          if args.compact?
+            puts f.options.as_flags.sort * " "
+          else
+            puts f.full_name if formulae.length > 1
+            Options.dump_for_formula f
+            puts
+          end
+        end
       end
     end
   end
diff --git a/Library/Homebrew/cmd/outdated.rb b/Library/Homebrew/cmd/outdated.rb
index 256459c2d1583..17232e8dd4a24 100644
--- a/Library/Homebrew/cmd/outdated.rb
+++ b/Library/Homebrew/cmd/outdated.rb
@@ -1,205 +1,224 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
 require "keg"
-require "cli/parser"
-require "cask/cmd"
 require "cask/caskroom"
 require "api"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def outdated_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        List installed casks and formulae that have an updated version available. By default, version
-        information is displayed in interactive shells, and suppressed otherwise.
-      EOS
-      switch "-q", "--quiet",
-             description: "List only the names of outdated kegs (takes precedence over `--verbose`)."
-      switch "-v", "--verbose",
-             description: "Include detailed version information."
-      switch "--formula", "--formulae",
-             description: "List only outdated formulae."
-      switch "--cask", "--casks",
-             description: "List only outdated casks."
-      flag   "--json",
-             description: "Print output in JSON format. There are two versions: `v1` and `v2`. " \
-                          "`v1` is deprecated and is currently the default if no version is specified. " \
-                          "`v2` prints outdated formulae and casks."
-      switch "--fetch-HEAD",
-             description: "Fetch the upstream repository to detect if the HEAD installation of the " \
-                          "formula is outdated. Otherwise, the repository's HEAD will only be checked for " \
-                          "updates when a new stable or development version has been released."
-      switch "--greedy",
-             description: "Also include outdated casks with `auto_updates true` or `version :latest`."
-
-      switch "--greedy-latest",
-             description: "Also include outdated casks including those with `version :latest`."
-
-      switch "--greedy-auto-updates",
-             description: "Also include outdated casks including those with `auto_updates true`."
-
-      conflicts "--quiet", "--verbose", "--json"
-      conflicts "--formula", "--cask"
-
-      named_args [:formula, :cask]
-    end
-  end
-
-  def outdated
-    args = outdated_args.parse
-
-    case json_version(args.json)
-    when :v1
-      odie "`brew outdated --json=v1` is no longer supported. Use brew outdated --json=v2 instead."
-    when :v2, :default
-      formulae, casks = if args.formula?
-        [outdated_formulae(args: args), []]
-      elsif args.cask?
-        [[], outdated_casks(args: args)]
-      else
-        outdated_formulae_casks args: args
+  module Cmd
+    class Outdated < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          List installed casks and formulae that have an updated version available. By default, version
+          information is displayed in interactive shells and suppressed otherwise.
+        EOS
+        switch "-q", "--quiet",
+               description: "List only the names of outdated kegs (takes precedence over `--verbose`)."
+        switch "-v", "--verbose",
+               description: "Include detailed version information."
+        switch "--formula", "--formulae",
+               description: "List only outdated formulae."
+        switch "--cask", "--casks",
+               description: "List only outdated casks."
+        flag   "--json",
+               description: "Print output in JSON format. There are two versions: `v1` and `v2`. " \
+                            "`v1` is deprecated and is currently the default if no version is specified. " \
+                            "`v2` prints outdated formulae and casks."
+        switch "--fetch-HEAD",
+               description: "Fetch the upstream repository to detect if the HEAD installation of the " \
+                            "formula is outdated. Otherwise, the repository's HEAD will only be checked for " \
+                            "updates when a new stable or development version has been released."
+        switch "-g", "--greedy",
+               env:         :upgrade_greedy,
+               description: "Also include outdated casks with `auto_updates true` or `version :latest`."
+
+        switch "--greedy-latest",
+               description: "Also include outdated casks including those with `version :latest`."
+
+        switch "--greedy-auto-updates",
+               description: "Also include outdated casks including those with `auto_updates true`."
+
+        conflicts "--quiet", "--verbose", "--json"
+        conflicts "--formula", "--cask"
+
+        named_args [:formula, :cask]
       end
 
-      json = {
-        "formulae" => json_info(formulae, args: args),
-        "casks"    => json_info(casks, args: args),
-      }
-      puts JSON.pretty_generate(json)
-
-      outdated = formulae + casks
-
-    else
-      outdated = if args.formula?
-        outdated_formulae args: args
-      elsif args.cask?
-        outdated_casks args: args
-      else
-        outdated_formulae_casks(args: args).flatten
-      end
-
-      print_outdated(outdated, args: args)
-    end
-
-    Homebrew.failed = args.named.present? && outdated.present?
-  end
-
-  def print_outdated(formulae_or_casks, args:)
-    formulae_or_casks.each do |formula_or_cask|
-      if formula_or_cask.is_a?(Formula)
-        f = formula_or_cask
-
-        if verbose?
-          outdated_kegs = f.outdated_kegs(fetch_head: args.fetch_HEAD?)
-
-          current_version = if f.alias_changed? && !f.latest_formula.latest_version_installed?
-            latest = f.latest_formula
-            "#{latest.name} (#{latest.pkg_version})"
-          elsif f.head? && outdated_kegs.any? { |k| k.version.to_s == f.pkg_version.to_s }
-            # There is a newer HEAD but the version number has not changed.
-            "latest HEAD"
+      sig { override.void }
+      def run
+        case json_version(args.json)
+        when :v1
+          odie "`brew outdated --json=v1` is no longer supported. Use brew outdated --json=v2 instead."
+        when :v2, :default
+          formulae, casks = if args.formula?
+            [outdated_formulae, []]
+          elsif args.cask?
+            [[], outdated_casks]
           else
-            f.pkg_version.to_s
+            outdated_formulae_casks
           end
 
-          outdated_versions = outdated_kegs.group_by { |keg| Formulary.from_keg(keg).full_name }
-                                           .sort_by { |full_name, _kegs| full_name }
-                                           .map do |full_name, kegs|
-            "#{full_name} (#{kegs.map(&:version).join(", ")})"
-          end.join(", ")
+          json = {
+            "formulae" => json_info(formulae),
+            "casks"    => json_info(casks),
+          }
+          puts JSON.pretty_generate(json)
 
-          pinned_version = " [pinned at #{f.pinned_version}]" if f.pinned?
+          outdated = formulae + casks
 
-          puts "#{outdated_versions} < #{current_version}#{pinned_version}"
         else
-          puts f.full_installed_specified_name
+          outdated = if args.formula?
+            outdated_formulae
+          elsif args.cask?
+            outdated_casks
+          else
+            outdated_formulae_casks.flatten
+          end
+
+          print_outdated(outdated)
         end
-      else
-        c = formula_or_cask
 
-        puts c.outdated_info(args.greedy?, verbose?, false, args.greedy_latest?, args.greedy_auto_updates?)
+        Homebrew.failed = args.named.present? && outdated.present?
       end
-    end
-  end
 
-  def json_info(formulae_or_casks, args:)
-    formulae_or_casks.map do |formula_or_cask|
-      if formula_or_cask.is_a?(Formula)
-        f = formula_or_cask
+      private
+
+      sig { params(formulae_or_casks: T::Array[T.any(Formula, Cask::Cask)]).void }
+      def print_outdated(formulae_or_casks)
+        formulae_or_casks.each do |formula_or_cask|
+          if formula_or_cask.is_a?(Formula)
+            f = formula_or_cask
+
+            if verbose?
+              outdated_kegs = f.outdated_kegs(fetch_head: args.fetch_HEAD?)
+
+              current_version = if f.alias_changed? && !f.latest_formula.latest_version_installed?
+                latest = f.latest_formula
+                "#{latest.name} (#{latest.pkg_version})"
+              elsif f.head? && outdated_kegs.any? { |k| k.version.to_s == f.pkg_version.to_s }
+                # There is a newer HEAD but the version number has not changed.
+                "latest HEAD"
+              else
+                f.pkg_version.to_s
+              end
+
+              outdated_versions = outdated_kegs.group_by { |keg| Formulary.from_keg(keg).full_name }
+                                               .sort_by { |full_name, _kegs| full_name }
+                                               .map do |full_name, kegs|
+                "#{full_name} (#{kegs.map(&:version).join(", ")})"
+              end.join(", ")
+
+              pinned_version = " [pinned at #{f.pinned_version}]" if f.pinned?
+
+              puts "#{outdated_versions} < #{current_version}#{pinned_version}"
+            else
+              puts f.full_installed_specified_name
+            end
+          else
+            c = formula_or_cask
 
-        outdated_versions = f.outdated_kegs(fetch_head: args.fetch_HEAD?).map(&:version)
-        current_version = if f.head? && outdated_versions.any? { |v| v.to_s == f.pkg_version.to_s }
-          "HEAD"
-        else
-          f.pkg_version.to_s
+            puts c.outdated_info(args.greedy?, verbose?, false, args.greedy_latest?, args.greedy_auto_updates?)
+          end
         end
+      end
 
-        { name:               f.full_name,
-          installed_versions: outdated_versions.map(&:to_s),
-          current_version:    current_version,
-          pinned:             f.pinned?,
-          pinned_version:     f.pinned_version }
-      else
-        c = formula_or_cask
+      sig {
+        params(
+          formulae_or_casks: T::Array[T.any(Formula, Cask::Cask)],
+        ).returns(
+          T::Array[T.any(T::Hash[String, T.untyped], T::Hash[String, T.untyped])],
+        )
+      }
+      def json_info(formulae_or_casks)
+        formulae_or_casks.map do |formula_or_cask|
+          if formula_or_cask.is_a?(Formula)
+            f = formula_or_cask
+
+            outdated_versions = f.outdated_kegs(fetch_head: args.fetch_HEAD?).map(&:version)
+            current_version = if f.head? && outdated_versions.any? { |v| v.to_s == f.pkg_version.to_s }
+              "HEAD"
+            else
+              f.pkg_version.to_s
+            end
+
+            { name:               f.full_name,
+              installed_versions: outdated_versions.map(&:to_s),
+              current_version:,
+              pinned:             f.pinned?,
+              pinned_version:     f.pinned_version }
+          else
+            c = formula_or_cask
 
-        c.outdated_info(args.greedy?, verbose?, true, args.greedy_latest?, args.greedy_auto_updates?)
+            c.outdated_info(args.greedy?, verbose?, true, args.greedy_latest?, args.greedy_auto_updates?)
+          end
+        end
       end
-    end
-  end
 
-  def verbose?
-    ($stdout.tty? || super) && !quiet?
-  end
+      sig { returns(T::Boolean) }
+      def verbose?
+        ($stdout.tty? || Context.current.verbose?) && !Context.current.quiet?
+      end
 
-  def json_version(version)
-    version_hash = {
-      nil  => nil,
-      true => :default,
-      "v1" => :v1,
-      "v2" => :v2,
-    }
+      sig { params(version: T.nilable(T.any(TrueClass, String))).returns(T.nilable(Symbol)) }
+      def json_version(version)
+        version_hash = {
+          nil  => nil,
+          true => :default,
+          "v1" => :v1,
+          "v2" => :v2,
+        }
 
-    raise UsageError, "invalid JSON version: #{version}" unless version_hash.include?(version)
+        raise UsageError, "invalid JSON version: #{version}" unless version_hash.include?(version)
 
-    version_hash[version]
-  end
+        version_hash[version]
+      end
 
-  def outdated_formulae(args:)
-    select_outdated((args.named.to_resolved_formulae.presence || Formula.installed), args: args).sort
-  end
+      sig { returns(T::Array[Formula]) }
+      def outdated_formulae
+        T.cast(
+          select_outdated((args.named.to_resolved_formulae.presence || Formula.installed)).sort,
+          T::Array[Formula],
+        )
+      end
 
-  def outdated_casks(args:)
-    if args.named.present?
-      select_outdated(args.named.to_casks, args: args)
-    else
-      select_outdated(Cask::Caskroom.casks, args: args)
-    end
-  end
+      sig { returns(T::Array[Cask::Cask]) }
+      def outdated_casks
+        outdated = if args.named.present?
+          select_outdated(args.named.to_casks)
+        else
+          select_outdated(Cask::Caskroom.casks)
+        end
 
-  def outdated_formulae_casks(args:)
-    formulae, casks = args.named.to_resolved_formulae_to_casks
+        T.cast(outdated, T::Array[Cask::Cask])
+      end
 
-    if formulae.blank? && casks.blank?
-      formulae = Formula.installed
-      casks = Cask::Caskroom.casks
-    end
+      sig { returns([T::Array[T.any(Formula, Cask::Cask)], T::Array[T.any(Formula, Cask::Cask)]]) }
+      def outdated_formulae_casks
+        formulae, casks = args.named.to_resolved_formulae_to_casks
 
-    [select_outdated(formulae, args: args).sort, select_outdated(casks, args: args)]
-  end
+        if formulae.blank? && casks.blank?
+          formulae = Formula.installed
+          casks = Cask::Caskroom.casks
+        end
 
-  def select_outdated(formulae_or_casks, args:)
-    formulae_or_casks.select do |formula_or_cask|
-      if formula_or_cask.is_a?(Formula)
-        formula_or_cask.outdated?(fetch_head: args.fetch_HEAD?)
-      else
-        formula_or_cask.outdated?(greedy: args.greedy?, greedy_latest: args.greedy_latest?,
-                                  greedy_auto_updates: args.greedy_auto_updates?)
+        [select_outdated(formulae).sort, select_outdated(casks)]
+      end
+
+      sig {
+        params(formulae_or_casks: T::Array[T.any(Formula, Cask::Cask)]).returns(T::Array[T.any(Formula, Cask::Cask)])
+      }
+      def select_outdated(formulae_or_casks)
+        formulae_or_casks.select do |formula_or_cask|
+          if formula_or_cask.is_a?(Formula)
+            formula_or_cask.outdated?(fetch_head: args.fetch_HEAD?)
+          else
+            formula_or_cask.outdated?(greedy: args.greedy?, greedy_latest: args.greedy_latest?,
+                                      greedy_auto_updates: args.greedy_auto_updates?)
+          end
+        end
       end
     end
   end
diff --git a/Library/Homebrew/cmd/pin.rb b/Library/Homebrew/cmd/pin.rb
index 304105ffe908e..91a9608efed44 100644
--- a/Library/Homebrew/cmd/pin.rb
+++ b/Library/Homebrew/cmd/pin.rb
@@ -1,36 +1,35 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class Pin < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Pin the specified <formula>, preventing them from being upgraded when
+          issuing the `brew upgrade` <formula> command. See also `unpin`.
 
-  module_function
+          *Note:* Other packages which depend on newer versions of a pinned formula
+          might not install or run correctly.
+        EOS
 
-  sig { returns(CLI::Parser) }
-  def pin_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Pin the specified <formula>, preventing them from being upgraded when
-        issuing the `brew upgrade` <formula> command. See also `unpin`.
-      EOS
-
-      named_args :installed_formula, min: 1
-    end
-  end
-
-  def pin
-    args = pin_args.parse
+        named_args :installed_formula, min: 1
+      end
 
-    args.named.to_resolved_formulae.each do |f|
-      if f.pinned?
-        opoo "#{f.name} already pinned"
-      elsif !f.pinnable?
-        onoe "#{f.name} not installed"
-      else
-        f.pin
+      sig { override.void }
+      def run
+        args.named.to_resolved_formulae.each do |f|
+          if f.pinned?
+            opoo "#{f.name} already pinned"
+          elsif !f.pinnable?
+            onoe "#{f.name} not installed"
+          else
+            f.pin
+          end
+        end
       end
     end
   end
diff --git a/Library/Homebrew/cmd/postinstall.rb b/Library/Homebrew/cmd/postinstall.rb
index 821195f6dd862..f1f5d72eba91b 100644
--- a/Library/Homebrew/cmd/postinstall.rb
+++ b/Library/Homebrew/cmd/postinstall.rb
@@ -1,33 +1,34 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "sandbox"
 require "formula_installer"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class Postinstall < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Rerun the post-install steps for <formula>.
+        EOS
 
-  module_function
+        named_args :installed_formula, min: 1
+      end
 
-  sig { returns(CLI::Parser) }
-  def postinstall_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Rerun the post-install steps for <formula>.
-      EOS
-
-      named_args :installed_formula, min: 1
-    end
-  end
-
-  def postinstall
-    args = postinstall_args.parse
-
-    args.named.to_resolved_formulae.each do |f|
-      ohai "Postinstalling #{f}"
-      fi = FormulaInstaller.new(f, **{ debug: args.debug?, quiet: args.quiet?, verbose: args.verbose? }.compact)
-      fi.post_install
+      sig { override.void }
+      def run
+        args.named.to_resolved_formulae.each do |f|
+          ohai "Postinstalling #{f}"
+          f.install_etc_var
+          if f.post_install_defined?
+            fi = FormulaInstaller.new(f, **{ debug: args.debug?, quiet: args.quiet?, verbose: args.verbose? }.compact)
+            fi.post_install
+          else
+            opoo "#{f}: no `post_install` method was defined in the formula!"
+          end
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cmd/pyenv-sync.rb b/Library/Homebrew/cmd/pyenv-sync.rb
new file mode 100644
index 0000000000000..2ae2b8ca09ba3
--- /dev/null
+++ b/Library/Homebrew/cmd/pyenv-sync.rb
@@ -0,0 +1,68 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "formula"
+
+module Homebrew
+  module Cmd
+    class PyenvSync < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Create symlinks for Homebrew's installed Python versions in `~/.pyenv/versions`.
+
+          Note that older patch version symlinks will be created and linked to the minor
+          version so e.g. Python 3.11.0 will also be symlinked to 3.11.3.
+        EOS
+
+        named_args :none
+      end
+
+      sig { override.void }
+      def run
+        pyenv_root = Pathname(ENV.fetch("HOMEBREW_PYENV_ROOT", Pathname(Dir.home)/".pyenv"))
+
+        # Don't run multiple times at once.
+        pyenv_sync_running = pyenv_root/".pyenv_sync_running"
+        return if pyenv_sync_running.exist?
+
+        begin
+          pyenv_versions = pyenv_root/"versions"
+          pyenv_versions.mkpath
+          FileUtils.touch pyenv_sync_running
+          HOMEBREW_CELLAR.glob("python{,@*}")
+                         .flat_map(&:children)
+                         .each { |path| link_pyenv_versions(path, pyenv_versions) }
+
+          pyenv_versions.children
+                        .select(&:symlink?)
+                        .reject(&:exist?)
+                        .each { |path| FileUtils.rm_f path }
+        ensure
+          pyenv_sync_running.unlink if pyenv_sync_running.exist?
+        end
+      end
+
+      private
+
+      sig { params(path: Pathname, pyenv_versions: Pathname).void }
+      def link_pyenv_versions(path, pyenv_versions)
+        pyenv_versions.mkpath
+
+        version = Keg.new(path).version
+        major_version = version.major.to_i
+        minor_version = version.minor.to_i
+        patch_version = version.patch.to_i
+
+        (0..patch_version).each do |patch|
+          link_path = pyenv_versions/"#{major_version}.#{minor_version}.#{patch}"
+          # Don't clobber existing user installations.
+          next if link_path.exist? && !link_path.symlink?
+
+          FileUtils.rm_f link_path
+          FileUtils.ln_sf path, link_path
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cmd/rbenv-sync.rb b/Library/Homebrew/cmd/rbenv-sync.rb
new file mode 100644
index 0000000000000..4a9bf777d198a
--- /dev/null
+++ b/Library/Homebrew/cmd/rbenv-sync.rb
@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "formula"
+
+module Homebrew
+  module Cmd
+    class RbenvSync < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Create symlinks for Homebrew's installed Ruby versions in `~/.rbenv/versions`.
+
+          Note that older version symlinks will also be created so e.g. Ruby 3.2.1 will
+          also be symlinked to 3.2.0.
+        EOS
+
+        named_args :none
+      end
+
+      sig { override.void }
+      def run
+        rbenv_root = Pathname(ENV.fetch("HOMEBREW_RBENV_ROOT", Pathname(Dir.home)/".rbenv"))
+
+        # Don't run multiple times at once.
+        rbenv_sync_running = rbenv_root/".rbenv_sync_running"
+        return if rbenv_sync_running.exist?
+
+        begin
+          rbenv_versions = rbenv_root/"versions"
+          rbenv_versions.mkpath
+          FileUtils.touch rbenv_sync_running
+
+          HOMEBREW_CELLAR.glob("ruby{,@*}")
+                         .flat_map(&:children)
+                         .each { |path| link_rbenv_versions(path, rbenv_versions) }
+
+          rbenv_versions.children
+                        .select(&:symlink?)
+                        .reject(&:exist?)
+                        .each { |path| FileUtils.rm_f path }
+        ensure
+          rbenv_sync_running.unlink if rbenv_sync_running.exist?
+        end
+      end
+
+      private
+
+      sig { params(path: Pathname, rbenv_versions: Pathname).void }
+      def link_rbenv_versions(path, rbenv_versions)
+        rbenv_versions.mkpath
+
+        version = Keg.new(path).version
+        major_version = version.major.to_i
+        minor_version = version.minor.to_i
+        patch_version = version.patch.to_i || 0
+
+        (0..patch_version).each do |patch|
+          link_path = rbenv_versions/"#{major_version}.#{minor_version}.#{patch}"
+          # Don't clobber existing user installations.
+          next if link_path.exist? && !link_path.symlink?
+
+          FileUtils.rm_f link_path
+          FileUtils.ln_sf path, link_path
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cmd/readall.rb b/Library/Homebrew/cmd/readall.rb
index 7c64d8eb09a60..7d12ef53a4b0f 100644
--- a/Library/Homebrew/cmd/readall.rb
+++ b/Library/Homebrew/cmd/readall.rb
@@ -1,50 +1,68 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "readall"
-require "cli/parser"
+require "env_config"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def readall_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Import all items from the specified <tap>, or from all installed taps if none is provided.
-        This can be useful for debugging issues across all items when making
-        significant changes to `formula.rb`, testing the performance of loading
-        all items or checking if any current formulae/casks have Ruby issues.
-      EOS
-      switch "--aliases",
-             description: "Verify any alias symlinks in each tap."
-      switch "--syntax",
-             description: "Syntax-check all of Homebrew's Ruby files (if no `<tap>` is passed)."
-
-      named_args :tap
-    end
-  end
+  module Cmd
+    class ReadallCmd < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Import all items from the specified <tap>, or from all installed taps if none is provided.
+          This can be useful for debugging issues across all items when making
+          significant changes to `formula.rb`, testing the performance of loading
+          all items or checking if any current formulae/casks have Ruby issues.
+        EOS
+        flag   "--os=",
+               description: "Read using the given operating system. (Pass `all` to simulate all operating systems.)"
+        flag   "--arch=",
+               description: "Read using the given CPU architecture. (Pass `all` to simulate all architectures.)"
+        switch "--aliases",
+               description: "Verify any alias symlinks in each tap."
+        switch "--syntax",
+               description: "Syntax-check all of Homebrew's Ruby files (if no <tap> is passed)."
+        switch "--eval-all",
+               description: "Evaluate all available formulae and casks, whether installed or not. " \
+                            "Implied if `HOMEBREW_EVAL_ALL` is set."
+        switch "--no-simulate",
+               description: "Don't simulate other system configurations when checking formulae and casks."
 
-  def readall
-    args = readall_args.parse
+        named_args :tap
+      end
 
-    if args.syntax? && args.no_named?
-      scan_files = "#{HOMEBREW_LIBRARY_PATH}/**/*.rb"
-      ruby_files = Dir.glob(scan_files).grep_v(%r{/(vendor)/})
+      sig { override.void }
+      def run
+        Homebrew.with_no_api_env do
+          if args.syntax? && args.no_named?
+            scan_files = "#{HOMEBREW_LIBRARY_PATH}/**/*.rb"
+            ruby_files = Dir.glob(scan_files).grep_v(%r{/(vendor)/})
 
-      Homebrew.failed = true unless Readall.valid_ruby_syntax?(ruby_files)
-    end
+            Homebrew.failed = true unless Readall.valid_ruby_syntax?(ruby_files)
+          end
 
-    options = { aliases: args.aliases? }
-    taps = if args.no_named?
-      Tap
-    else
-      args.named.to_installed_taps
-    end
-    taps.each do |tap|
-      Homebrew.failed = true unless Readall.valid_tap?(tap, options)
+          options = {
+            aliases:     args.aliases?,
+            no_simulate: args.no_simulate?,
+          }
+          options[:os_arch_combinations] = args.os_arch_combinations if args.os || args.arch
+
+          taps = if args.no_named?
+            if !args.eval_all? && !Homebrew::EnvConfig.eval_all?
+              raise UsageError, "`brew readall` needs a tap or `--eval-all` passed or `HOMEBREW_EVAL_ALL` set!"
+            end
+
+            Tap.installed
+          else
+            args.named.to_installed_taps
+          end
+
+          taps.each do |tap|
+            Homebrew.failed = true unless Readall.valid_tap?(tap, **options)
+          end
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cmd/reinstall.rb b/Library/Homebrew/cmd/reinstall.rb
index bc6bca5053d65..bacf33beaac90 100644
--- a/Library/Homebrew/cmd/reinstall.rb
+++ b/Library/Homebrew/cmd/reinstall.rb
@@ -1,156 +1,191 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula_installer"
 require "development_tools"
 require "messages"
 require "install"
 require "reinstall"
-require "cli/parser"
 require "cleanup"
-require "cask/cmd"
 require "cask/utils"
 require "cask/macos"
+require "cask/reinstall"
 require "upgrade"
 require "api"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def reinstall_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Uninstall and then reinstall a <formula> or <cask> using the same options it was
-        originally installed with, plus any appended options specific to a <formula>.
-
-        Unless `HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew reinstall` will be run for
-        outdated dependents and dependents with broken linkage, respectively.
-
-        Unless `HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for the
-        reinstalled formulae or, every 30 days, for all formulae.
-      EOS
-      switch "-d", "--debug",
-             description: "If brewing fails, open an interactive debugging session with access to IRB " \
-                          "or a shell inside the temporary build directory."
-      switch "-f", "--force",
-             description: "Install without checking for previously installed keg-only or " \
-                          "non-migrated versions."
-      switch "-v", "--verbose",
-             description: "Print the verification and postinstall steps."
-      [
-        [:switch, "--formula", "--formulae", { description: "Treat all named arguments as formulae." }],
-        [:switch, "-s", "--build-from-source", {
-          description: "Compile <formula> from source even if a bottle is available.",
-        }],
-        [:switch, "-i", "--interactive", {
-          description: "Download and patch <formula>, then open a shell. This allows the user to " \
-                       "run `./configure --help` and otherwise determine how to turn the software " \
-                       "package into a Homebrew package.",
-        }],
-        [:switch, "--force-bottle", {
-          description: "Install from a bottle if it exists for the current or newest version of " \
-                       "macOS, even if it would not normally be used for installation.",
-        }],
-        [:switch, "--keep-tmp", {
-          description: "Retain the temporary files created during installation.",
-        }],
-        [:switch, "--display-times", {
-          env:         :display_install_times,
-          description: "Print install times for each formula at the end of the run.",
-        }],
-        [:switch, "-g", "--git", {
-          description: "Create a Git repository, useful for creating patches to the software.",
-        }],
-      ].each do |options|
-        send(*options)
-        conflicts "--cask", options[-2]
+  module Cmd
+    class Reinstall < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Uninstall and then reinstall a <formula> or <cask> using the same options it was
+          originally installed with, plus any appended options specific to a <formula>.
+
+          Unless `HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew reinstall` will be run for
+          outdated dependents and dependents with broken linkage, respectively.
+
+          Unless `HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for the
+          reinstalled formulae or, every 30 days, for all formulae.
+        EOS
+        switch "-d", "--debug",
+               description: "If brewing fails, open an interactive debugging session with access to IRB " \
+                            "or a shell inside the temporary build directory."
+        switch "--display-times",
+               env:         :display_install_times,
+               description: "Print install times for each package at the end of the run."
+        switch "-f", "--force",
+               description: "Install without checking for previously installed keg-only or " \
+                            "non-migrated versions."
+        switch "-v", "--verbose",
+               description: "Print the verification and post-install steps."
+        [
+          [:switch, "--formula", "--formulae", { description: "Treat all named arguments as formulae." }],
+          [:switch, "-s", "--build-from-source", {
+            description: "Compile <formula> from source even if a bottle is available.",
+          }],
+          [:switch, "-i", "--interactive", {
+            description: "Download and patch <formula>, then open a shell. This allows the user to " \
+                         "run `./configure --help` and otherwise determine how to turn the software " \
+                         "package into a Homebrew package.",
+          }],
+          [:switch, "--force-bottle", {
+            description: "Install from a bottle if it exists for the current or newest version of " \
+                         "macOS, even if it would not normally be used for installation.",
+          }],
+          [:switch, "--keep-tmp", {
+            description: "Retain the temporary files created during installation.",
+          }],
+          [:switch, "--debug-symbols", {
+            depends_on:  "--build-from-source",
+            description: "Generate debug symbols on build. Source will be retained in a cache directory.",
+          }],
+          [:switch, "-g", "--git", {
+            description: "Create a Git repository, useful for creating patches to the software.",
+          }],
+        ].each do |args|
+          options = args.pop
+          send(*args, **options)
+          conflicts "--cask", args.last
+        end
+        formula_options
+        [
+          [:switch, "--cask", "--casks", { description: "Treat all named arguments as casks." }],
+          [:switch, "--[no-]binaries", {
+            description: "Disable/enable linking of helper executables (default: enabled).",
+            env:         :cask_opts_binaries,
+          }],
+          [:switch, "--require-sha",  {
+            description: "Require all casks to have a checksum.",
+            env:         :cask_opts_require_sha,
+          }],
+          [:switch, "--[no-]quarantine", {
+            description: "Disable/enable quarantining of downloads (default: enabled).",
+            env:         :cask_opts_quarantine,
+          }],
+          [:switch, "--adopt", {
+            description: "Adopt existing artifacts in the destination that are identical to those being installed. " \
+                         "Cannot be combined with `--force`.",
+          }],
+          [:switch, "--skip-cask-deps", {
+            description: "Skip installing cask dependencies.",
+          }],
+          [:switch, "--zap", {
+            description: "For use with `brew reinstall --cask`. Remove all files associated with a cask. " \
+                         "*May remove files which are shared between applications.*",
+          }],
+        ].each do |args|
+          options = args.pop
+          send(*args, **options)
+          conflicts "--formula", args.last
+        end
+        cask_options
+
+        conflicts "--build-from-source", "--force-bottle"
+
+        named_args [:formula, :cask], min: 1
       end
-      formula_options
-      [
-        [:switch, "--cask", "--casks", { description: "Treat all named arguments as casks." }],
-        *Cask::Cmd::AbstractCommand::OPTIONS,
-        *Cask::Cmd::Install::OPTIONS,
-      ].each do |options|
-        send(*options)
-        conflicts "--formula", options[-2]
-      end
-      cask_options
-
-      conflicts "--build-from-source", "--force-bottle"
-
-      named_args [:formula, :cask], min: 1
-    end
-  end
-
-  def reinstall
-    args = reinstall_args.parse
-
-    if args.build_from_source? && Homebrew::EnvConfig.install_from_api?
-      raise UsageError, "--build-from-source is not supported when using HOMEBREW_INSTALL_FROM_API."
-    end
 
-    formulae, casks = args.named.to_formulae_and_casks(method: :resolve)
-                          .partition { |o| o.is_a?(Formula) }
-
-    if args.build_from_source? && !DevelopmentTools.installed?
-      raise BuildFlagsError.new(["--build-from-source"], bottled: formulae.all?(&:bottled?))
-    end
-
-    Install.perform_preinstall_checks
-
-    formulae.each do |formula|
-      if formula.pinned?
-        onoe "#{formula.full_name} is pinned. You must unpin it to reinstall."
-        next
+      sig { override.void }
+      def run
+        formulae, casks = T.cast(
+          args.named.to_resolved_formulae_to_casks,
+          [T::Array[Formula], T::Array[Cask::Cask]],
+        )
+
+        if args.build_from_source?
+          unless DevelopmentTools.installed?
+            raise BuildFlagsError.new(["--build-from-source"], bottled: formulae.all?(&:bottled?))
+          end
+
+          unless Homebrew::EnvConfig.developer?
+            opoo "building from source is not supported!"
+            puts "You're on your own. Failures are expected so don't create any issues, please!"
+          end
+        end
+
+        formulae = Homebrew::Attestation.sort_formulae_for_install(formulae) if Homebrew::Attestation.enabled?
+
+        unless formulae.empty?
+          Install.perform_preinstall_checks_once
+
+          formulae.each do |formula|
+            if formula.pinned?
+              onoe "#{formula.full_name} is pinned. You must unpin it to reinstall."
+              next
+            end
+            Migrator.migrate_if_needed(formula, force: args.force?)
+            Homebrew::Reinstall.reinstall_formula(
+              formula,
+              flags:                      args.flags_only,
+              installed_on_request:       args.named.present?,
+              force_bottle:               args.force_bottle?,
+              build_from_source_formulae: args.build_from_source_formulae,
+              interactive:                args.interactive?,
+              keep_tmp:                   args.keep_tmp?,
+              debug_symbols:              args.debug_symbols?,
+              force:                      args.force?,
+              debug:                      args.debug?,
+              quiet:                      args.quiet?,
+              verbose:                    args.verbose?,
+              git:                        args.git?,
+            )
+            Cleanup.install_formula_clean!(formula)
+          end
+
+          Upgrade.check_installed_dependents(
+            formulae,
+            flags:                      args.flags_only,
+            installed_on_request:       args.named.present?,
+            force_bottle:               args.force_bottle?,
+            build_from_source_formulae: args.build_from_source_formulae,
+            interactive:                args.interactive?,
+            keep_tmp:                   args.keep_tmp?,
+            debug_symbols:              args.debug_symbols?,
+            force:                      args.force?,
+            debug:                      args.debug?,
+            quiet:                      args.quiet?,
+            verbose:                    args.verbose?,
+          )
+        end
+
+        if casks.any?
+          Cask::Reinstall.reinstall_casks(
+            *casks,
+            binaries:       args.binaries?,
+            verbose:        args.verbose?,
+            force:          args.force?,
+            require_sha:    args.require_sha?,
+            skip_cask_deps: args.skip_cask_deps?,
+            quarantine:     args.quarantine?,
+            zap:            args.zap?,
+          )
+        end
+
+        Cleanup.periodic_clean!
+
+        Homebrew.messages.display_messages(display_times: args.display_times?)
       end
-      Migrator.migrate_if_needed(formula, force: args.force?)
-      reinstall_formula(
-        formula,
-        flags:                      args.flags_only,
-        installed_on_request:       args.named.present?,
-        force_bottle:               args.force_bottle?,
-        build_from_source_formulae: args.build_from_source_formulae,
-        interactive:                args.interactive?,
-        keep_tmp:                   args.keep_tmp?,
-        force:                      args.force?,
-        debug:                      args.debug?,
-        quiet:                      args.quiet?,
-        verbose:                    args.verbose?,
-        git:                        args.git?,
-      )
-      Cleanup.install_formula_clean!(formula)
     end
-
-    Upgrade.check_installed_dependents(
-      formulae,
-      flags:                      args.flags_only,
-      installed_on_request:       args.named.present?,
-      force_bottle:               args.force_bottle?,
-      build_from_source_formulae: args.build_from_source_formulae,
-      interactive:                args.interactive?,
-      keep_tmp:                   args.keep_tmp?,
-      force:                      args.force?,
-      debug:                      args.debug?,
-      quiet:                      args.quiet?,
-      verbose:                    args.verbose?,
-    )
-
-    if casks.any?
-      Cask::Cmd::Reinstall.reinstall_casks(
-        *casks,
-        binaries:       args.binaries?,
-        verbose:        args.verbose?,
-        force:          args.force?,
-        require_sha:    args.require_sha?,
-        skip_cask_deps: args.skip_cask_deps?,
-        quarantine:     args.quarantine?,
-        zap:            args.zap?,
-      )
-    end
-
-    Homebrew.messages.display_messages(display_times: args.display_times?)
   end
 end
diff --git a/Library/Homebrew/cmd/search.rb b/Library/Homebrew/cmd/search.rb
index 603735b340f59..9d0e6cf6bdc9b 100644
--- a/Library/Homebrew/cmd/search.rb
+++ b/Library/Homebrew/cmd/search.rb
@@ -1,163 +1,170 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
 require "missing_formula"
 require "descriptions"
-require "cli/parser"
 require "search"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  extend Search
-
-  PACKAGE_MANAGERS = {
-    repology:  ->(query) { "https://repology.org/projects/?search=#{query}" },
-    macports:  ->(query) { "https://ports.macports.org/search/?q=#{query}" },
-    fink:      ->(query) { "https://pdb.finkproject.org/pdb/browse.php?summary=#{query}" },
-    opensuse:  ->(query) { "https://software.opensuse.org/search?q=#{query}" },
-    fedora:    ->(query) { "https://apps.fedoraproject.org/packages/s/#{query}" },
-    archlinux: ->(query) { "https://archlinux.org/packages/?q=#{query}" },
-    debian:    lambda { |query|
-      "https://packages.debian.org/search?keywords=#{query}&searchon=names&suite=all&section=all"
-    },
-    ubuntu:    lambda { |query|
-      "https://packages.ubuntu.com/search?keywords=#{query}&searchon=names&suite=all&section=all"
-    },
-  }.freeze
-
-  sig { returns(CLI::Parser) }
-  def search_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Perform a substring search of cask tokens and formula names for <text>. If <text>
-        is flanked by slashes, it is interpreted as a regular expression.
-        The search for <text> is extended online to `homebrew/core` and `homebrew/cask`.
-      EOS
-      switch "--formula", "--formulae",
-             description: "Search online and locally for formulae."
-      switch "--cask", "--casks",
-             description: "Search online and locally for casks."
-      switch "--desc",
-             description: "Search for formulae with a description matching <text> and casks with " \
-                          "a name or description matching <text>."
-      switch "--pull-request",
-             description: "Search for GitHub pull requests containing <text>."
-      switch "--open",
-             depends_on:  "--pull-request",
-             description: "Search for only open GitHub pull requests."
-      switch "--closed",
-             depends_on:  "--pull-request",
-             description: "Search for only closed GitHub pull requests."
-      package_manager_switches = PACKAGE_MANAGERS.keys.map { |name| "--#{name}" }
-      package_manager_switches.each do |s|
-        switch s,
-               description: "Search for <text> in the given database."
+  module Cmd
+    class SearchCmd < AbstractCommand
+      PACKAGE_MANAGERS = T.let({
+        repology:  ->(query) { "https://repology.org/projects/?search=#{query}" },
+        macports:  ->(query) { "https://ports.macports.org/search/?q=#{query}" },
+        fink:      ->(query) { "https://pdb.finkproject.org/pdb/browse.php?summary=#{query}" },
+        opensuse:  ->(query) { "https://software.opensuse.org/search?q=#{query}" },
+        fedora:    ->(query) { "https://packages.fedoraproject.org/search?query=#{query}" },
+        archlinux: ->(query) { "https://archlinux.org/packages/?q=#{query}" },
+        debian:    lambda { |query|
+          "https://packages.debian.org/search?keywords=#{query}&searchon=names&suite=all&section=all"
+        },
+        ubuntu:    lambda { |query|
+          "https://packages.ubuntu.com/search?keywords=#{query}&searchon=names&suite=all&section=all"
+        },
+      }.freeze, T::Hash[Symbol, T.proc.params(query: String).returns(String)])
+
+      cmd_args do
+        description <<~EOS
+          Perform a substring search of cask tokens and formula names for <text>. If <text>
+          is flanked by slashes, it is interpreted as a regular expression.
+        EOS
+        switch "--formula", "--formulae",
+               description: "Search for formulae."
+        switch "--cask", "--casks",
+               description: "Search for casks."
+        switch "--desc",
+               description: "Search for formulae with a description matching <text> and casks with " \
+                            "a name or description matching <text>."
+        switch "--eval-all",
+               depends_on:  "--desc",
+               description: "Evaluate all available formulae and casks, whether installed or not, to search their " \
+                            "descriptions. Implied if `HOMEBREW_EVAL_ALL` is set."
+        switch "--pull-request",
+               description: "Search for GitHub pull requests containing <text>."
+        switch "--open",
+               depends_on:  "--pull-request",
+               description: "Search for only open GitHub pull requests."
+        switch "--closed",
+               depends_on:  "--pull-request",
+               description: "Search for only closed GitHub pull requests."
+        package_manager_switches = PACKAGE_MANAGERS.keys.map { |name| "--#{name}" }
+        package_manager_switches.each do |s|
+          switch s,
+                 description: "Search for <text> in the given database."
+        end
+
+        conflicts "--desc", "--pull-request"
+        conflicts "--open", "--closed"
+        conflicts(*package_manager_switches)
+
+        named_args :text_or_regex, min: 1
       end
 
-      conflicts "--desc", "--pull-request"
-      conflicts "--open", "--closed"
-      conflicts(*package_manager_switches)
+      sig { override.void }
+      def run
+        return if search_package_manager
 
-      named_args :text_or_regex, min: 1
-    end
-  end
-
-  def search
-    args = search_args.parse
+        query = args.named.join(" ")
+        string_or_regex = Search.query_regexp(query)
 
-    return if search_package_manager(args)
+        if args.desc?
+          if !args.eval_all? && !Homebrew::EnvConfig.eval_all? && Homebrew::EnvConfig.no_install_from_api?
+            raise UsageError, "`brew search --desc` needs `--eval-all` passed or `HOMEBREW_EVAL_ALL` set!"
+          end
 
-    query = args.named.join(" ")
-    string_or_regex = query_regexp(query)
+          Search.search_descriptions(string_or_regex, args)
+        elsif args.pull_request?
+          search_pull_requests(query)
+        else
+          formulae, casks = Search.search_names(string_or_regex, args)
+          print_results(formulae, casks, query)
+        end
 
-    if args.desc?
-      search_descriptions(string_or_regex, args)
-    elsif args.pull_request?
-      search_pull_requests(query, args)
-    else
-      search_names(query, string_or_regex, args)
-    end
-
-    print_regex_help(args)
-  end
+        puts "Use `brew desc` to list packages with a short description." if args.verbose?
 
-  def print_regex_help(args)
-    return unless $stdout.tty?
-
-    metacharacters = %w[\\ | ( ) [ ] { } ^ $ * + ?].freeze
-    return unless metacharacters.any? do |char|
-      args.named.any? do |arg|
-        arg.include?(char) && !arg.start_with?("/")
+        print_regex_help
       end
-    end
-
-    opoo <<~EOS
-      Did you mean to perform a regular expression search?
-      Surround your query with /slashes/ to search locally by regex.
-    EOS
-  end
-
-  def search_package_manager(args)
-    package_manager = PACKAGE_MANAGERS.find { |name,| args[:"#{name}?"] }
-    return false if package_manager.nil?
 
-    _, url = package_manager
-    exec_browser url.call(URI.encode_www_form_component(args.named.join(" ")))
-    true
-  end
-
-  def search_pull_requests(query, args)
-    only = if args.open? && !args.closed?
-      "open"
-    elsif args.closed? && !args.open?
-      "closed"
-    end
+      private
 
-    GitHub.print_pull_requests_matching(query, only)
-  end
-
-  def search_names(query, string_or_regex, args)
-    remote_results = search_taps(query, silent: true)
+      sig { void }
+      def print_regex_help
+        return unless $stdout.tty?
 
-    local_formulae = search_formulae(string_or_regex)
-    remote_formulae = remote_results[:formulae]
-    all_formulae = local_formulae + remote_formulae
+        metacharacters = %w[\\ | ( ) [ ] { } ^ $ * + ?].freeze
+        return unless metacharacters.any? do |char|
+          args.named.any? do |arg|
+            arg.include?(char) && !arg.start_with?("/")
+          end
+        end
 
-    local_casks = search_casks(string_or_regex)
-    remote_casks = remote_results[:casks]
-    all_casks = local_casks + remote_casks
+        opoo <<~EOS
+          Did you mean to perform a regular expression search?
+          Surround your query with /slashes/ to search locally by regex.
+        EOS
+      end
 
-    print_formulae = args.formula?
-    print_casks = args.cask?
-    print_formulae = print_casks = true if !print_formulae && !print_casks
-    print_formulae &&= all_formulae.any?
-    print_casks &&= all_casks.any?
+      sig { returns(T::Boolean) }
+      def search_package_manager
+        package_manager = PACKAGE_MANAGERS.find { |name,| args[:"#{name}?"] }
+        return false if package_manager.nil?
 
-    ohai "Formulae", Formatter.columns(all_formulae) if print_formulae
-    puts if print_formulae && print_casks
-    ohai "Casks", Formatter.columns(all_casks) if print_casks
+        _, url = package_manager
+        exec_browser url.call(URI.encode_www_form_component(args.named.join(" ")))
+        true
+      end
 
-    count = all_formulae.count + all_casks.count
+      sig { params(query: String).returns(String) }
+      def search_pull_requests(query)
+        only = if args.open? && !args.closed?
+          "open"
+        elsif args.closed? && !args.open?
+          "closed"
+        end
 
-    print_missing_formula_help(query, count.positive?) if local_casks.exclude?(query)
+        GitHub.print_pull_requests_matching(query, only)
+      end
 
-    odie "No formulae or casks found for #{query.inspect}." if count.zero?
-  end
+      sig { params(all_formulae: T::Array[String], all_casks: T::Array[String], query: String).void }
+      def print_results(all_formulae, all_casks, query)
+        count = all_formulae.size + all_casks.size
+
+        if all_formulae.any?
+          if $stdout.tty?
+            ohai "Formulae", Formatter.columns(all_formulae)
+          else
+            puts all_formulae
+          end
+        end
+        puts if all_formulae.any? && all_casks.any?
+        if all_casks.any?
+          if $stdout.tty?
+            ohai "Casks", Formatter.columns(all_casks)
+          else
+            puts all_casks
+          end
+        end
+
+        print_missing_formula_help(query, count.positive?) if all_casks.exclude?(query)
+
+        odie "No formulae or casks found for #{query.inspect}." if count.zero?
+      end
 
-  def print_missing_formula_help(query, found_matches)
-    return unless $stdout.tty?
+      sig { params(query: String, found_matches: T::Boolean).void }
+      def print_missing_formula_help(query, found_matches)
+        return unless $stdout.tty?
 
-    reason = MissingFormula.reason(query, silent: true)
-    return if reason.nil?
+        reason = MissingFormula.reason(query, silent: true)
+        return if reason.nil?
 
-    if found_matches
-      puts
-      puts "If you meant #{query.inspect} specifically:"
+        if found_matches
+          puts
+          puts "If you meant #{query.inspect} specifically:"
+        end
+        puts reason
+      end
     end
-    puts reason
   end
 end
diff --git a/Library/Homebrew/cmd/setup-ruby.rb b/Library/Homebrew/cmd/setup-ruby.rb
new file mode 100644
index 0000000000000..161d3e22ff0a4
--- /dev/null
+++ b/Library/Homebrew/cmd/setup-ruby.rb
@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "shell_command"
+
+module Homebrew
+  module Cmd
+    class SetupRuby < AbstractCommand
+      include ShellCommand
+
+      cmd_args do
+        description <<~EOS
+          Installs and configures Homebrew's Ruby. If `command` is passed, it will only run Bundler if necessary for that command.
+        EOS
+
+        named_args :command
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cmd/setup-ruby.sh b/Library/Homebrew/cmd/setup-ruby.sh
new file mode 100644
index 0000000000000..1a101cd481994
--- /dev/null
+++ b/Library/Homebrew/cmd/setup-ruby.sh
@@ -0,0 +1,41 @@
+# Documentation defined in Library/Homebrew/cmd/setup-ruby.rb
+
+# HOMEBREW_LIBRARY is set by brew.sh
+# HOMEBREW_BREW_FILE is set by extend/ENV/super.rb
+# shellcheck disable=SC2154
+homebrew-setup-ruby() {
+  source "${HOMEBREW_LIBRARY}/Homebrew/utils/helpers.sh"
+  source "${HOMEBREW_LIBRARY}/Homebrew/utils/ruby.sh"
+  setup-ruby-path
+
+  if [[ -z "${HOMEBREW_DEVELOPER}" ]]
+  then
+    return
+  fi
+
+  # Avoid running Bundler if the command doesn't need it.
+  local command="$1"
+  if [[ -n "${command}" ]]
+  then
+    source "${HOMEBREW_LIBRARY}/Homebrew/command_path.sh"
+
+    command_path="$(homebrew-command-path "${command}")"
+    if [[ -n "${command_path}" ]]
+    then
+      if [[ "${command_path}" != *"/dev-cmd/"* ]]
+      then
+        return
+      elif ! grep -q "Homebrew.install_bundler_gems\!" "${command_path}"
+      then
+        return
+      fi
+    fi
+  fi
+
+  setup-gem-home-bundle-gemfile
+
+  if ! bundle check &>/dev/null
+  then
+    "${HOMEBREW_BREW_FILE}" install-bundler-gems
+  fi
+}
diff --git a/Library/Homebrew/cmd/shellenv.rb b/Library/Homebrew/cmd/shellenv.rb
new file mode 100644
index 0000000000000..61c7e354cc3b2
--- /dev/null
+++ b/Library/Homebrew/cmd/shellenv.rb
@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "shell_command"
+
+module Homebrew
+  module Cmd
+    class Shellenv < AbstractCommand
+      include ShellCommand
+
+      cmd_args do
+        description <<~EOS
+          Valid shells: bash|csh|fish|pwsh|sh|tcsh|zsh
+
+          Print export statements. When run in a shell, this installation of Homebrew will be added to your `PATH`, `MANPATH`, and `INFOPATH`.
+
+          The variables `HOMEBREW_PREFIX`, `HOMEBREW_CELLAR` and `HOMEBREW_REPOSITORY` are also exported to avoid querying them multiple times.
+          To help guarantee idempotence, this command produces no output when Homebrew's `bin` and `sbin` directories are first and second
+          respectively in your `PATH`. Consider adding evaluation of this command's output to your dotfiles (e.g. `~/.bash_profile` or
+          `~/.zprofile` on macOS and `~/.bashrc` or `~/.zshrc` on Linux) with: `eval "$(brew shellenv)"`
+
+          The shell can be specified explicitly with a supported shell name parameter. Unknown shells will output POSIX exports.
+        EOS
+        named_args :shell
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cmd/shellenv.sh b/Library/Homebrew/cmd/shellenv.sh
index 97c630e47038a..9b48ffab1dcbd 100644
--- a/Library/Homebrew/cmd/shellenv.sh
+++ b/Library/Homebrew/cmd/shellenv.sh
@@ -1,14 +1,9 @@
-#:  * `shellenv`
-#:
-#:  Print export statements. When run in a shell, this installation of Homebrew will be added to your `PATH`, `MANPATH`, and `INFOPATH`.
-#:
-#:  The variables `HOMEBREW_PREFIX`, `HOMEBREW_CELLAR` and `HOMEBREW_REPOSITORY` are also exported to avoid querying them multiple times.
-#:  To help guarantee idempotence, this command produces no output when Homebrew's `bin` and `sbin` directories are first and second
-#:  respectively in your `PATH`. Consider adding evaluation of this command's output to your dotfiles (e.g. `~/.profile`,
-#:  `~/.bash_profile`, or `~/.zprofile`) with: `eval "$(brew shellenv)"`
+# Documentation defined in Library/Homebrew/cmd/shellenv.rb
 
 # HOMEBREW_CELLAR and HOMEBREW_PREFIX are set by extend/ENV/super.rb
 # HOMEBREW_REPOSITORY is set by bin/brew
+# Leading colon in MANPATH prepends default man dirs to search path in Linux and macOS.
+# Please do not submit PRs to remove it!
 # shellcheck disable=SC2154
 homebrew-shellenv() {
   if [[ "${HOMEBREW_PATH%%:"${HOMEBREW_PREFIX}"/sbin*}" == "${HOMEBREW_PREFIX}/bin" ]]
@@ -16,22 +11,51 @@ homebrew-shellenv() {
     return
   fi
 
-  case "$(/bin/ps -p "${PPID}" -c -o comm=)" in
+  if [[ -n "$1" ]]
+  then
+    HOMEBREW_SHELL_NAME="$1"
+  else
+    HOMEBREW_SHELL_NAME="$(/bin/ps -p "${PPID}" -c -o comm=)"
+  fi
+
+  if [[ -n "${HOMEBREW_MACOS}" ]] &&
+     [[ "${HOMEBREW_MACOS_VERSION_NUMERIC}" -ge "140000" ]] &&
+     [[ -x /usr/libexec/path_helper ]]
+  then
+    HOMEBREW_PATHS_FILE="${HOMEBREW_PREFIX}/etc/paths"
+
+    if [[ ! -f "${HOMEBREW_PATHS_FILE}" ]]
+    then
+      printf '%s/bin\n%s/sbin\n' "${HOMEBREW_PREFIX}" "${HOMEBREW_PREFIX}" 2>/dev/null >"${HOMEBREW_PATHS_FILE}"
+    fi
+
+    if [[ -r "${HOMEBREW_PATHS_FILE}" ]]
+    then
+      PATH_HELPER_ROOT="${HOMEBREW_PREFIX}"
+    fi
+  fi
+
+  case "${HOMEBREW_SHELL_NAME}" in
     fish | -fish)
-      echo "set -gx HOMEBREW_PREFIX \"${HOMEBREW_PREFIX}\";"
-      echo "set -gx HOMEBREW_CELLAR \"${HOMEBREW_CELLAR}\";"
-      echo "set -gx HOMEBREW_REPOSITORY \"${HOMEBREW_REPOSITORY}\";"
-      echo "set -q PATH; or set PATH ''; set -gx PATH \"${HOMEBREW_PREFIX}/bin\" \"${HOMEBREW_PREFIX}/sbin\" \$PATH;"
-      echo "set -q MANPATH; or set MANPATH ''; set -gx MANPATH \"${HOMEBREW_PREFIX}/share/man\" \$MANPATH;"
-      echo "set -q INFOPATH; or set INFOPATH ''; set -gx INFOPATH \"${HOMEBREW_PREFIX}/share/info\" \$INFOPATH;"
+      echo "set --global --export HOMEBREW_PREFIX \"${HOMEBREW_PREFIX}\";"
+      echo "set --global --export HOMEBREW_CELLAR \"${HOMEBREW_CELLAR}\";"
+      echo "set --global --export HOMEBREW_REPOSITORY \"${HOMEBREW_REPOSITORY}\";"
+      echo "fish_add_path --global --move --path \"${HOMEBREW_PREFIX}/bin\" \"${HOMEBREW_PREFIX}/sbin\";"
+      echo "if test -n \"\$MANPATH[1]\"; set --global --export MANPATH '' \$MANPATH; end;"
+      echo "if not contains \"${HOMEBREW_PREFIX}/share/info\" \$INFOPATH; set --global --export INFOPATH \"${HOMEBREW_PREFIX}/share/info\" \$INFOPATH; end;"
       ;;
     csh | -csh | tcsh | -tcsh)
       echo "setenv HOMEBREW_PREFIX ${HOMEBREW_PREFIX};"
       echo "setenv HOMEBREW_CELLAR ${HOMEBREW_CELLAR};"
       echo "setenv HOMEBREW_REPOSITORY ${HOMEBREW_REPOSITORY};"
-      echo "setenv PATH ${HOMEBREW_PREFIX}/bin:${HOMEBREW_PREFIX}/sbin:\$PATH;"
-      echo "setenv MANPATH ${HOMEBREW_PREFIX}/share/man\`[ \${?MANPATH} == 1 ] && echo \":\${MANPATH}\"\`:;"
-      echo "setenv INFOPATH ${HOMEBREW_PREFIX}/share/info\`[ \${?INFOPATH} == 1 ] && echo \":\${INFOPATH}\"\`;"
+      if [[ -n "${PATH_HELPER_ROOT}" ]]
+      then
+        PATH_HELPER_ROOT="${PATH_HELPER_ROOT}" PATH="${HOMEBREW_PATH}" /usr/libexec/path_helper -c
+      else
+        echo "setenv PATH ${HOMEBREW_PREFIX}/bin:${HOMEBREW_PREFIX}/sbin:\$PATH;"
+      fi
+      echo "test \${?MANPATH} -eq 1 && setenv MANPATH :\${MANPATH};"
+      echo "setenv INFOPATH ${HOMEBREW_PREFIX}/share/info\`test \${?INFOPATH} -eq 1 && echo :\${INFOPATH}\`;"
       ;;
     pwsh | -pwsh | pwsh-preview | -pwsh-preview)
       echo "[System.Environment]::SetEnvironmentVariable('HOMEBREW_PREFIX','${HOMEBREW_PREFIX}',[System.EnvironmentVariableTarget]::Process)"
@@ -45,8 +69,17 @@ homebrew-shellenv() {
       echo "export HOMEBREW_PREFIX=\"${HOMEBREW_PREFIX}\";"
       echo "export HOMEBREW_CELLAR=\"${HOMEBREW_CELLAR}\";"
       echo "export HOMEBREW_REPOSITORY=\"${HOMEBREW_REPOSITORY}\";"
-      echo "export PATH=\"${HOMEBREW_PREFIX}/bin:${HOMEBREW_PREFIX}/sbin\${PATH+:\$PATH}\";"
-      echo "export MANPATH=\"${HOMEBREW_PREFIX}/share/man\${MANPATH+:\$MANPATH}:\";"
+      if [[ "${HOMEBREW_SHELL_NAME}" == "zsh" ]] || [[ "${HOMEBREW_SHELL_NAME}" == "-zsh" ]]
+      then
+        echo "fpath[1,0]=\"${HOMEBREW_PREFIX}/share/zsh/site-functions\";"
+      fi
+      if [[ -n "${PATH_HELPER_ROOT}" ]]
+      then
+        PATH_HELPER_ROOT="${PATH_HELPER_ROOT}" PATH="${HOMEBREW_PATH}" /usr/libexec/path_helper -s
+      else
+        echo "export PATH=\"${HOMEBREW_PREFIX}/bin:${HOMEBREW_PREFIX}/sbin\${PATH+:\$PATH}\";"
+      fi
+      echo "[ -z \"\${MANPATH-}\" ] || export MANPATH=\":\${MANPATH#:}\";"
       echo "export INFOPATH=\"${HOMEBREW_PREFIX}/share/info:\${INFOPATH:-}\";"
       ;;
   esac
diff --git a/Library/Homebrew/cmd/tab.rb b/Library/Homebrew/cmd/tab.rb
new file mode 100644
index 0000000000000..48c891c74ac5e
--- /dev/null
+++ b/Library/Homebrew/cmd/tab.rb
@@ -0,0 +1,87 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "formula"
+require "tab"
+
+module Homebrew
+  module Cmd
+    class TabCmd < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Edit tab information for installed formulae or casks.
+
+          This can be useful when you want to control whether an installed
+          formula should be removed by `brew autoremove`.
+          To prevent removal, mark the formula as installed on request;
+          to allow removal, mark the formula as not installed on request.
+        EOS
+
+        switch "--installed-on-request",
+               description: "Mark <installed_formula> or <installed_cask> as installed on request."
+        switch "--no-installed-on-request",
+               description: "Mark <installed_formula> or <installed_cask> as not installed on request."
+        switch "--formula", "--formulae",
+               description: "Only mark formulae."
+        switch "--cask", "--casks",
+               description: "Only mark casks."
+
+        conflicts "--formula", "--cask"
+        conflicts "--installed-on-request", "--no-installed-on-request"
+
+        named_args [:installed_formula, :installed_cask], min: 1
+      end
+
+      sig { override.void }
+      def run
+        installed_on_request = if args.installed_on_request?
+          true
+        elsif args.no_installed_on_request?
+          false
+        end
+        raise UsageError, "No marking option specified." if installed_on_request.nil?
+
+        formulae, casks = args.named.to_formulae_to_casks
+        formulae_not_installed = formulae.reject(&:any_version_installed?)
+        casks_not_installed = casks.reject(&:installed?)
+        if formulae_not_installed.any? || casks_not_installed.any?
+          names = formulae_not_installed.map(&:name) + casks_not_installed.map(&:token)
+          is_or_are = (names.length == 1) ? "is" : "are"
+          odie "#{names.to_sentence} #{is_or_are} not installed."
+        end
+
+        [*formulae, *casks].each do |formula_or_cask|
+          update_tab formula_or_cask, installed_on_request:
+        end
+      end
+
+      private
+
+      sig { params(formula_or_cask: T.any(Formula, Cask::Cask), installed_on_request: T::Boolean).void }
+      def update_tab(formula_or_cask, installed_on_request:)
+        name, tab = if formula_or_cask.is_a?(Formula)
+          [formula_or_cask.name, Tab.for_formula(formula_or_cask)]
+        else
+          [formula_or_cask.token, formula_or_cask.tab]
+        end
+
+        if tab.tabfile.blank? || !tab.tabfile.exist?
+          raise ArgumentError,
+                "Tab file for #{name} does not exist."
+        end
+
+        installed_on_request_str = "#{"not " unless installed_on_request}installed on request"
+        if (tab.installed_on_request && installed_on_request) ||
+           (!tab.installed_on_request && !installed_on_request)
+          ohai "#{name} is already marked as #{installed_on_request_str}."
+          return
+        end
+
+        tab.installed_on_request = installed_on_request
+        tab.write
+        ohai "#{name} is now marked as #{installed_on_request_str}."
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cmd/tap-info.rb b/Library/Homebrew/cmd/tap-info.rb
index d97b6168d0805..bca54866041e5 100644
--- a/Library/Homebrew/cmd/tap-info.rb
+++ b/Library/Homebrew/cmd/tap-info.rb
@@ -1,93 +1,97 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class TapInfo < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Show detailed information about one or more <tap>s.
+          If no <tap> names are provided, display brief statistics for all installed taps.
+        EOS
+        switch "--installed",
+               description: "Show information on each installed tap."
+        flag   "--json",
+               description: "Print a JSON representation of <tap>. Currently the default and only accepted " \
+                            "value for <version> is `v1`. See the docs for examples of using the JSON " \
+                            "output: <https://docs.brew.sh/Querying-Brew>"
 
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def tap_info_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Show detailed information about one or more <tap>s.
-
-        If no <tap> names are provided, display brief statistics for all installed taps.
-      EOS
-      switch "--installed",
-             description: "Show information on each installed tap."
-      flag   "--json",
-             description: "Print a JSON representation of <tap>. Currently the default and only accepted " \
-                          "value for <version> is `v1`. See the docs for examples of using the JSON " \
-                          "output: <https://docs.brew.sh/Querying-Brew>"
+        named_args :tap
+      end
 
-      named_args :tap
-    end
-  end
+      sig { override.void }
+      def run
+        require "tap"
 
-  def tap_info
-    args = tap_info_args.parse
+        taps = if args.installed?
+          Tap
+        else
+          args.named.to_taps
+        end
 
-    taps = if args.installed?
-      Tap
-    else
-      args.named.to_taps
-    end
+        if args.json
+          raise UsageError, "invalid JSON version: #{args.json}" unless ["v1", true].include? args.json
 
-    if args.json
-      raise UsageError, "invalid JSON version: #{args.json}" unless ["v1", true].include? args.json
+          print_tap_json(taps.sort_by(&:to_s))
+        else
+          print_tap_info(taps.sort_by(&:to_s))
+        end
+      end
 
-      print_tap_json(taps.sort_by(&:to_s))
-    else
-      print_tap_info(taps.sort_by(&:to_s))
-    end
-  end
+      private
 
-  def print_tap_info(taps)
-    if taps.none?
-      tap_count = 0
-      formula_count = 0
-      command_count = 0
-      pinned_count = 0
-      private_count = 0
-      Tap.each do |tap|
-        tap_count += 1
-        formula_count += tap.formula_files.size
-        command_count += tap.command_files.size
-        pinned_count += 1 if tap.pinned?
-        private_count += 1 if tap.private?
-      end
-      info = "#{tap_count} #{"tap".pluralize(tap_count)}"
-      info += ", #{pinned_count} pinned"
-      info += ", #{private_count} private"
-      info += ", #{formula_count} #{"formula".pluralize(formula_count)}"
-      info += ", #{command_count} #{"command".pluralize(command_count)}"
-      info += ", #{Tap::TAP_DIRECTORY.dup.abv}" if Tap::TAP_DIRECTORY.directory?
-      puts info
-    else
-      taps.each_with_index do |tap, i|
-        puts unless i.zero?
-        info = "#{tap}: "
-        if tap.installed?
-          info += if (contents = tap.contents).blank?
-            "no commands/casks/formulae"
-          else
-            contents.join(", ")
+      sig { params(taps: T::Array[Tap]).void }
+      def print_tap_info(taps)
+        if taps.none?
+          tap_count = 0
+          formula_count = 0
+          command_count = 0
+          private_count = 0
+          Tap.installed.each do |tap|
+            tap_count += 1
+            formula_count += tap.formula_files.size
+            command_count += tap.command_files.size
+            private_count += 1 if tap.private?
           end
-          info += ", private" if tap.private?
-          info += "\n#{tap.path} (#{tap.path.abv})"
-          info += "\nFrom: #{tap.remote.presence || "N/A"}"
+          info = Utils.pluralize("tap", tap_count, include_count: true)
+          info += ", #{private_count} private"
+          info += ", #{Utils.pluralize("formula", formula_count, plural: "e", include_count: true)}"
+          info += ", #{Utils.pluralize("command", command_count, include_count: true)}"
+          info += ", #{HOMEBREW_TAP_DIRECTORY.dup.abv}" if HOMEBREW_TAP_DIRECTORY.directory?
+          puts info
         else
-          info += "Not installed"
+          info = ""
+          taps.each_with_index do |tap, i|
+            puts unless i.zero?
+            info = "#{tap}: "
+            if tap.installed?
+              info += "Installed"
+              info += if (contents = tap.contents).blank?
+                "\nNo commands/casks/formulae"
+              else
+                "\n#{contents.join(", ")}"
+              end
+              info += "\nPrivate" if tap.private?
+              info += "\n#{tap.path} (#{tap.path.abv})"
+              info += "\nFrom: #{tap.remote.presence || "N/A"}"
+              info += "\norigin: #{tap.remote}" if tap.remote != tap.default_remote
+              info += "\nHEAD: #{tap.git_head || "(none)"}"
+              info += "\nlast commit: #{tap.git_last_commit || "never"}"
+              info += "\nbranch: #{tap.git_branch || "(none)"}" if tap.git_branch != "master"
+            else
+              info += "Not installed"
+            end
+            puts info
+          end
         end
-        puts info
       end
-    end
-  end
 
-  def print_tap_json(taps)
-    puts JSON.pretty_generate(taps.map(&:to_hash))
+      sig { params(taps: T::Array[Tap]).void }
+      def print_tap_json(taps)
+        puts JSON.pretty_generate(taps.map(&:to_hash))
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/cmd/tap.rb b/Library/Homebrew/cmd/tap.rb
index 019d70c8d35ae..b902510452f0b 100644
--- a/Library/Homebrew/cmd/tap.rb
+++ b/Library/Homebrew/cmd/tap.rb
@@ -1,75 +1,76 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
+require "tap"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class TapCmd < AbstractCommand
+      cmd_args do
+        usage_banner "`tap` [<options>] [<user>`/`<repo>] [<URL>]"
+        description <<~EOS
+          Tap a formula repository.
+          If no arguments are provided, list all installed taps.
 
-  module_function
+          With <URL> unspecified, tap a formula repository from GitHub using HTTPS.
+          Since so many taps are hosted on GitHub, this command is a shortcut for
+          `brew tap` <user>`/`<repo> `https://github.com/`<user>`/homebrew-`<repo>.
 
-  sig { returns(CLI::Parser) }
-  def tap_args
-    Homebrew::CLI::Parser.new do
-      usage_banner "`tap` [<options>] [<user>`/`<repo>] [<URL>]"
-      description <<~EOS
-        Tap a formula repository.
+          With <URL> specified, tap a formula repository from anywhere, using
+          any transport protocol that `git`(1) handles. The one-argument form of `tap`
+          simplifies but also limits. This two-argument command makes no
+          assumptions, so taps can be cloned from places other than GitHub and
+          using protocols other than HTTPS, e.g. SSH, git, HTTP, FTP(S), rsync.
+        EOS
+        switch "--full",
+               description: "Convert a shallow clone to a full clone without untapping. Taps are only cloned as " \
+                            "shallow clones if `--shallow` was originally passed.",
+               replacement: false,
+               disable:     true
+        switch "--shallow",
+               description: "Fetch tap as a shallow clone rather than a full clone. Useful for continuous " \
+                            "integration.",
+               replacement: false,
+               disable:     true
+        switch "--[no-]force-auto-update",
+               hidden: true
+        switch "--custom-remote",
+               description: "Install or change a tap with a custom remote. Useful for mirrors."
+        switch "--repair",
+               description: "Migrate tapped formulae from symlink-based to directory-based structure."
+        switch "--eval-all",
+               description: "Evaluate all the formulae, casks and aliases in the new tap to check validity. " \
+                            "Implied if `HOMEBREW_EVAL_ALL` is set."
+        switch "--force",
+               description: "Force install core taps even under API mode."
 
-        If no arguments are provided, list all installed taps.
-
-        With <URL> unspecified, tap a formula repository from GitHub using HTTPS.
-        Since so many taps are hosted on GitHub, this command is a shortcut for
-        `brew tap` <user>`/`<repo> `https://github.com/`<user>`/homebrew-`<repo>.
-
-        With <URL> specified, tap a formula repository from anywhere, using
-        any transport protocol that `git`(1) handles. The one-argument form of `tap`
-        simplifies but also limits. This two-argument command makes no
-        assumptions, so taps can be cloned from places other than GitHub and
-        using protocols other than HTTPS, e.g. SSH, git, HTTP, FTP(S), rsync.
-      EOS
-      switch "--full",
-             description: "Convert a shallow clone to a full clone without untapping. Taps are only cloned as " \
-                          "shallow clones if `--shallow` was originally passed.",
-             replacement: false
-      switch "--shallow",
-             description: "Fetch tap as a shallow clone rather than a full clone. Useful for continuous integration.",
-             replacement: false
-      switch "--[no-]force-auto-update",
-             description: "Auto-update tap even if it is not hosted on GitHub. By default, only taps " \
-                          "hosted on GitHub are auto-updated (for performance reasons)."
-      switch "--custom-remote",
-             description: "Install or change a tap with a custom remote. Useful for mirrors."
-      switch "--repair",
-             description: "Migrate tapped formulae from symlink-based to directory-based structure."
-      switch "--list-pinned",
-             description: "List all pinned taps."
-
-      named_args :tap, max: 2
-    end
-  end
-
-  sig { void }
-  def tap
-    args = tap_args.parse
+        named_args :tap, max: 2
+      end
 
-    if args.repair?
-      Tap.each(&:link_completions_and_manpages)
-      Tap.each(&:fix_remote_configuration)
-    elsif args.list_pinned?
-      puts Tap.select(&:pinned?).map(&:name)
-    elsif args.no_named?
-      puts Tap.names
-    else
-      tap = Tap.fetch(args.named.first)
-      begin
-        tap.install clone_target:      args.named.second,
-                    force_auto_update: args.force_auto_update?,
-                    custom_remote:     args.custom_remote?,
-                    quiet:             args.quiet?
-      rescue TapRemoteMismatchError, TapNoCustomRemoteError => e
-        odie e
-      rescue TapAlreadyTappedError
-        nil
+      sig { override.void }
+      def run
+        if args.repair?
+          Tap.installed.each do |tap|
+            tap.link_completions_and_manpages
+            tap.fix_remote_configuration
+          end
+        elsif args.no_named?
+          puts Tap.installed.sort_by(&:name)
+        else
+          tap = Tap.fetch(args.named.first)
+          begin
+            tap.install clone_target:  args.named.second,
+                        custom_remote: args.custom_remote?,
+                        quiet:         args.quiet?,
+                        verify:        args.eval_all? || Homebrew::EnvConfig.eval_all?,
+                        force:         args.force?
+          rescue TapRemoteMismatchError, TapNoCustomRemoteError => e
+            odie e
+          rescue TapAlreadyTappedError
+            nil
+          end
+        end
       end
     end
   end
diff --git a/Library/Homebrew/cmd/uninstall.rb b/Library/Homebrew/cmd/uninstall.rb
index 8c40d4219de86..ff1aafadbc44c 100644
--- a/Library/Homebrew/cmd/uninstall.rb
+++ b/Library/Homebrew/cmd/uninstall.rb
@@ -1,77 +1,88 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "keg"
 require "formula"
 require "diagnostic"
 require "migrator"
-require "cli/parser"
-require "cask/cmd"
 require "cask/cask_loader"
+require "cask/exceptions"
+require "cask/installer"
+require "cask/uninstall"
 require "uninstall"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class UninstallCmd < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Uninstall a <formula> or <cask>.
+        EOS
+        switch "-f", "--force",
+               description: "Delete all installed versions of <formula>. Uninstall even if <cask> is not " \
+                            "installed, overwrite existing files and ignore errors when removing files."
+        switch "--zap",
+               description: "Remove all files associated with a <cask>. " \
+                            "*May remove files which are shared between applications.*"
+        switch "--ignore-dependencies",
+               description: "Don't fail uninstall, even if <formula> is a dependency of any installed " \
+                            "formulae."
+        switch "--formula", "--formulae",
+               description: "Treat all named arguments as formulae."
+        switch "--cask", "--casks",
+               description: "Treat all named arguments as casks."
 
-  module_function
+        conflicts "--formula", "--cask"
+        conflicts "--formula", "--zap"
 
-  sig { returns(CLI::Parser) }
-  def uninstall_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Uninstall a <formula> or <cask>.
-      EOS
-      switch "-f", "--force",
-             description: "Delete all installed versions of <formula>. Uninstall even if <cask> is not " \
-                          "installed, overwrite existing files and ignore errors when removing files."
-      switch "--zap",
-             description: "Remove all files associated with a <cask>. " \
-                          "*May remove files which are shared between applications.*"
-      switch "--ignore-dependencies",
-             description: "Don't fail uninstall, even if <formula> is a dependency of any installed " \
-                          "formulae."
-      switch "--formula", "--formulae",
-             description: "Treat all named arguments as formulae."
-      switch "--cask", "--casks",
-             description: "Treat all named arguments as casks."
+        named_args [:installed_formula, :installed_cask], min: 1
+      end
 
-      conflicts "--formula", "--cask"
-      conflicts "--formula", "--zap"
+      sig { override.void }
+      def run
+        all_kegs, casks = args.named.to_kegs_to_casks(
+          ignore_unavailable: args.force?,
+          all_kegs:           args.force?,
+        )
 
-      named_args [:installed_formula, :installed_cask], min: 1
-    end
-  end
+        # If ignore_unavailable is true and the named args
+        # are a series of invalid kegs and casks,
+        # #to_kegs_to_casks will return empty arrays.
+        return if all_kegs.blank? && casks.blank?
+
+        kegs_by_rack = all_kegs.group_by(&:rack)
 
-  def uninstall
-    args = uninstall_args.parse
+        Uninstall.uninstall_kegs(
+          kegs_by_rack,
+          casks:,
+          force:               args.force?,
+          ignore_dependencies: args.ignore_dependencies?,
+          named_args:          args.named,
+        )
 
-    all_kegs, casks = args.named.to_kegs_to_casks(
-      ignore_unavailable: args.force?,
-      all_kegs:           args.force?,
-    )
+        if args.zap?
+          casks.each do |cask|
+            odebug "Zapping Cask #{cask}"
 
-    kegs_by_rack = all_kegs.group_by(&:rack)
+            raise Cask::CaskNotInstalledError, cask if !cask.installed? && !args.force?
 
-    Uninstall.uninstall_kegs(
-      kegs_by_rack,
-      casks:               casks,
-      force:               args.force?,
-      ignore_dependencies: args.ignore_dependencies?,
-      named_args:          args.named,
-    )
+            Cask::Installer.new(cask, verbose: args.verbose?, force: args.force?).zap
+          end
+        else
+          Cask::Uninstall.uninstall_casks(
+            *casks,
+            verbose: args.verbose?,
+            force:   args.force?,
+          )
+        end
 
-    if args.zap?
-      T.unsafe(Cask::Cmd::Zap).zap_casks(
-        *casks,
-        verbose: args.verbose?,
-        force:   args.force?,
-      )
-    else
-      T.unsafe(Cask::Cmd::Uninstall).uninstall_casks(
-        *casks,
-        verbose: args.verbose?,
-        force:   args.force?,
-      )
+        if ENV["HOMEBREW_AUTOREMOVE"].present?
+          opoo "HOMEBREW_AUTOREMOVE is now a no-op as it is the default behaviour. " \
+               "Set HOMEBREW_NO_AUTOREMOVE=1 to disable it."
+        end
+        Cleanup.autoremove unless Homebrew::EnvConfig.no_autoremove?
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cmd/unlink.rb b/Library/Homebrew/cmd/unlink.rb
index 605adfbf22d95..cb6dcff4a1f45 100644
--- a/Library/Homebrew/cmd/unlink.rb
+++ b/Library/Homebrew/cmd/unlink.rb
@@ -1,44 +1,39 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "ostruct"
-require "cli/parser"
+require "abstract_command"
 require "unlink"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def unlink_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Remove symlinks for <formula> from Homebrew's prefix. This can be useful
-        for temporarily disabling a formula:
-        `brew unlink` <formula> `&&` <commands> `&& brew link` <formula>
-      EOS
-      switch "-n", "--dry-run",
-             description: "List files which would be unlinked without actually unlinking or " \
-                          "deleting any files."
-
-      named_args :installed_formula, min: 1
-    end
-  end
+  module Cmd
+    class UnlinkCmd < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Remove symlinks for <formula> from Homebrew's prefix. This can be useful
+          for temporarily disabling a formula:
+          `brew unlink` <formula> `&&` <commands> `&& brew link` <formula>
+        EOS
+        switch "-n", "--dry-run",
+               description: "List files which would be unlinked without actually unlinking or " \
+                            "deleting any files."
+
+        named_args :installed_formula, min: 1
+      end
 
-  def unlink
-    args = unlink_args.parse
+      sig { override.void }
+      def run
+        options = { dry_run: args.dry_run?, verbose: args.verbose? }
 
-    options = { dry_run: args.dry_run?, verbose: args.verbose? }
+        args.named.to_default_kegs.each do |keg|
+          if args.dry_run?
+            puts "Would remove:"
+            keg.unlink(**options)
+            next
+          end
 
-    args.named.to_default_kegs.each do |keg|
-      if args.dry_run?
-        puts "Would remove:"
-        keg.unlink(**options)
-        next
+          Unlink.unlink(keg, dry_run: args.dry_run?, verbose: args.verbose?)
+        end
       end
-
-      Unlink.unlink(keg, dry_run: args.dry_run?, verbose: args.verbose?)
     end
   end
 end
diff --git a/Library/Homebrew/cmd/unpin.rb b/Library/Homebrew/cmd/unpin.rb
index 7e287d5956ee1..e75d15eb439a7 100644
--- a/Library/Homebrew/cmd/unpin.rb
+++ b/Library/Homebrew/cmd/unpin.rb
@@ -1,36 +1,32 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class Unpin < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Unpin <formula>, allowing them to be upgraded by `brew upgrade` <formula>.
+          See also `pin`.
+        EOS
 
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def unpin_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Unpin <formula>, allowing them to be upgraded by `brew upgrade` <formula>.
-        See also `pin`.
-      EOS
-
-      named_args :installed_formula, min: 1
-    end
-  end
-
-  def unpin
-    args = unpin_args.parse
+        named_args :installed_formula, min: 1
+      end
 
-    args.named.to_resolved_formulae.each do |f|
-      if f.pinned?
-        f.unpin
-      elsif !f.pinnable?
-        onoe "#{f.name} not installed"
-      else
-        opoo "#{f.name} not pinned"
+      sig { override.void }
+      def run
+        args.named.to_resolved_formulae.each do |f|
+          if f.pinned?
+            f.unpin
+          elsif !f.pinnable?
+            onoe "#{f.name} not installed"
+          else
+            opoo "#{f.name} not pinned"
+          end
+        end
       end
     end
   end
diff --git a/Library/Homebrew/cmd/untap.rb b/Library/Homebrew/cmd/untap.rb
index 5245f4ad78647..17c5c11af62f9 100644
--- a/Library/Homebrew/cmd/untap.rb
+++ b/Library/Homebrew/cmd/untap.rb
@@ -1,53 +1,97 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class Untap < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Remove a tapped formula repository.
+        EOS
+        switch "-f", "--force",
+               description: "Untap even if formulae or casks from this tap are currently installed."
 
-  module_function
+        named_args :tap, min: 1
+      end
 
-  sig { returns(CLI::Parser) }
-  def untap_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Remove a tapped formula repository.
-      EOS
-      switch "-f", "--force",
-             description: "Untap even if formulae or casks from this tap are currently installed."
+      sig { override.void }
+      def run
+        args.named.to_installed_taps.each do |tap|
+          odie "Untapping #{tap} is not allowed" if tap.core_tap? && Homebrew::EnvConfig.no_install_from_api?
 
-      named_args :tap, min: 1
-    end
-  end
+          if Homebrew::EnvConfig.no_install_from_api? || (!tap.core_tap? && !tap.core_cask_tap?)
+            installed_tap_formulae = installed_formulae_for(tap:)
+            installed_tap_casks = installed_casks_for(tap:)
+
+            if installed_tap_formulae.present? || installed_tap_casks.present?
+              installed_names = (installed_tap_formulae + installed_tap_casks.map(&:token)).join("\n")
+              if args.force? || Homebrew::EnvConfig.developer?
+                opoo <<~EOS
+                  Untapping #{tap} even though it contains the following installed formulae or casks:
+                  #{installed_names}
+                EOS
+              else
+                odie <<~EOS
+                  Refusing to untap #{tap} because it contains the following installed formulae or casks:
+                  #{installed_names}
+                EOS
+              end
+            end
+          end
+
+          tap.uninstall manual: true
+        end
+      end
+
+      # All installed formulae currently available in a tap by formula full name.
+      sig { params(tap: Tap).returns(T::Array[Formula]) }
+      def installed_formulae_for(tap:)
+        tap.formula_names.filter_map do |formula_name|
+          next unless installed_formulae_names.include?(T.must(formula_name.split("/").last))
+
+          formula = begin
+            Formulary.factory(formula_name)
+          rescue FormulaUnavailableError
+            # Don't blow up because of a single unavailable formula.
+            next
+          end
+
+          # Can't use Formula#any_version_installed? because it doesn't consider
+          # taps correctly.
+          formula if formula.installed_kegs.any? { |keg| keg.tab.tap == tap }
+        end
+      end
+
+      # All installed casks currently available in a tap by cask full name.
+      sig { params(tap: Tap).returns(T::Array[Cask::Cask]) }
+      def installed_casks_for(tap:)
+        tap.cask_tokens.filter_map do |cask_token|
+          next unless installed_cask_tokens.include?(T.must(cask_token.split("/").last))
 
-  def untap
-    args = untap_args.parse
-
-    args.named.to_installed_taps.each do |tap|
-      odie "Untapping #{tap} is not allowed" if tap.core_tap? && !Homebrew::EnvConfig.install_from_api?
-
-      if !Homebrew::EnvConfig.install_from_api? || (!tap.core_tap? && tap != "homebrew/cask")
-        installed_tap_formulae = Formula.installed.select { |formula| formula.tap == tap }
-        installed_tap_casks = Cask::Caskroom.casks.select { |cask| cask.tap == tap }
-
-        if installed_tap_formulae.present? || installed_tap_casks.present?
-          installed_names = (installed_tap_formulae + installed_tap_casks.map(&:token)).join("\n")
-          if args.force? || Homebrew::EnvConfig.developer?
-            opoo <<~EOS
-              Untapping #{tap} even though it contains the following installed formulae or casks:
-              #{installed_names}
-            EOS
-          else
-            odie <<~EOS
-              Refusing to untap #{tap} because it contains the following installed formulae or casks:
-              #{installed_names}
-            EOS
+          cask = begin
+            Cask::CaskLoader.load(cask_token)
+          rescue Cask::CaskUnavailableError
+            # Don't blow up because of a single unavailable cask.
+            next
           end
+
+          cask if cask.installed?
         end
       end
 
-      tap.uninstall manual: true
+      private
+
+      sig { returns(T::Set[String]) }
+      def installed_formulae_names
+        @installed_formulae_names ||= T.let(Formula.installed_formula_names.to_set.freeze, T.nilable(T::Set[String]))
+      end
+
+      sig { returns(T::Set[String]) }
+      def installed_cask_tokens
+        @installed_cask_tokens ||= T.let(Cask::Caskroom.tokens.to_set.freeze, T.nilable(T::Set[String]))
+      end
     end
   end
 end
diff --git a/Library/Homebrew/cmd/update-report.rb b/Library/Homebrew/cmd/update-report.rb
index 89b8f50fca25e..dd22f475f6ab6 100644
--- a/Library/Homebrew/cmd/update-report.rb
+++ b/Library/Homebrew/cmd/update-report.rb
@@ -1,296 +1,421 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "abstract_command"
 require "migrator"
 require "formulary"
+require "cask/cask_loader"
+require "cask/migrator"
 require "descriptions"
 require "cleanup"
 require "description_cache_store"
-require "cli/parser"
 require "settings"
 require "linuxbrew-core-migration"
 
 module Homebrew
-  extend T::Sig
+  module Cmd
+    class UpdateReport < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          The Ruby implementation of `brew update`. Never called manually.
+        EOS
+        switch "--auto-update", "--preinstall",
+               description: "Run in 'auto-update' mode (faster, less output)."
+        switch "-f", "--force",
+               description: "Treat installed and updated formulae as if they are from " \
+                            "the same taps and migrate them anyway."
 
-  module_function
+        hide_from_man_page!
+      end
 
-  def auto_update_header(args:)
-    @auto_update_header ||= begin
-      ohai "Auto-updated Homebrew!" if args.auto_update?
-      true
-    end
-  end
+      sig { override.void }
+      def run
+        return output_update_report if $stdout.tty?
 
-  sig { returns(CLI::Parser) }
-  def update_report_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        The Ruby implementation of `brew update`. Never called manually.
-      EOS
-      switch "--auto-update", "--preinstall",
-             description: "Run in 'auto-update' mode (faster, less output)."
-      switch "-f", "--force",
-             description: "Treat installed and updated formulae as if they are from " \
-                          "the same taps and migrate them anyway."
-
-      hide_from_man_page!
-    end
-  end
+        redirect_stdout($stderr) do
+          output_update_report
+        end
+      end
 
-  def update_report
-    return output_update_report if $stdout.tty?
+      private
 
-    redirect_stdout($stderr) do
-      output_update_report
-    end
-  end
+      def auto_update_header
+        @auto_update_header ||= begin
+          ohai "Auto-updated Homebrew!" if args.auto_update?
+          true
+        end
+      end
 
-  def output_update_report
-    args = update_report_args.parse
+      def output_update_report
+        # Run `brew update` (again) if we've got a linuxbrew-core CoreTap
+        if CoreTap.instance.installed? && CoreTap.instance.linuxbrew_core? &&
+           ENV["HOMEBREW_LINUXBREW_CORE_MIGRATION"].blank?
+          ohai "Re-running `brew update` for linuxbrew-core migration"
 
-    # Run `brew update` (again) if we've got a linuxbrew-core CoreTap
-    if CoreTap.instance.installed? && CoreTap.instance.linuxbrew_core? &&
-       ENV["HOMEBREW_LINUXBREW_CORE_MIGRATION"].blank?
-      ohai "Re-running `brew update` for linuxbrew-core migration"
+          if Homebrew::EnvConfig.core_git_remote != HOMEBREW_CORE_DEFAULT_GIT_REMOTE
+            opoo <<~EOS
+              HOMEBREW_CORE_GIT_REMOTE was set: #{Homebrew::EnvConfig.core_git_remote}.
+              It has been unset for the migration.
+              You may need to change this from a linuxbrew-core mirror to a homebrew-core one.
 
-      if HOMEBREW_CORE_DEFAULT_GIT_REMOTE != Homebrew::EnvConfig.core_git_remote
-        opoo <<~EOS
-          HOMEBREW_CORE_GIT_REMOTE was set: #{Homebrew::EnvConfig.core_git_remote}.
-          It has been unset for the migration.
-          You may need to change this from a linuxbrew-core mirror to a homebrew-core one.
+            EOS
+          end
+          ENV.delete("HOMEBREW_CORE_GIT_REMOTE")
 
-        EOS
-      end
-      ENV.delete("HOMEBREW_CORE_GIT_REMOTE")
+          if Homebrew::EnvConfig.bottle_domain != HOMEBREW_BOTTLE_DEFAULT_DOMAIN
+            opoo <<~EOS
+              HOMEBREW_BOTTLE_DOMAIN was set: #{Homebrew::EnvConfig.bottle_domain}.
+              It has been unset for the migration.
+              You may need to change this from a Linuxbrew package mirror to a Homebrew one.
 
-      if HOMEBREW_BOTTLE_DEFAULT_DOMAIN != Homebrew::EnvConfig.bottle_domain
-        opoo <<~EOS
-          HOMEBREW_BOTTLE_DOMAIN was set: #{Homebrew::EnvConfig.bottle_domain}.
-          It has been unset for the migration.
-          You may need to change this from a Linuxbrew package mirror to a Homebrew one.
+            EOS
+          end
+          ENV.delete("HOMEBREW_BOTTLE_DOMAIN")
 
-        EOS
-      end
-      ENV.delete("HOMEBREW_BOTTLE_DOMAIN")
+          ENV["HOMEBREW_LINUXBREW_CORE_MIGRATION"] = "1"
+          FileUtils.rm_f HOMEBREW_LOCKS/"update"
 
-      ENV["HOMEBREW_LINUXBREW_CORE_MIGRATION"] = "1"
-      FileUtils.rm_f HOMEBREW_LOCKS/"update"
+          update_args = []
+          update_args << "--auto-update" if args.auto_update?
+          update_args << "--force" if args.force?
+          exec HOMEBREW_BREW_FILE, "update", *update_args
+        end
 
-      update_args = []
-      update_args << "--auto-update" if args.auto_update?
-      update_args << "--force" if args.force?
-      exec HOMEBREW_BREW_FILE, "update", *update_args
-    end
+        if ENV["HOMEBREW_ADDITIONAL_GOOGLE_ANALYTICS_ID"].present?
+          opoo "HOMEBREW_ADDITIONAL_GOOGLE_ANALYTICS_ID is now a no-op so can be unset."
+          puts "All Homebrew Google Analytics code and data was destroyed."
+        end
 
-    if !Utils::Analytics.messages_displayed? &&
-       !Utils::Analytics.disabled? &&
-       !Utils::Analytics.no_message_output?
+        if ENV["HOMEBREW_NO_GOOGLE_ANALYTICS"].present?
+          opoo "HOMEBREW_NO_GOOGLE_ANALYTICS is now a no-op so can be unset."
+          puts "All Homebrew Google Analytics code and data was destroyed."
+        end
 
-      ENV["HOMEBREW_NO_ANALYTICS_THIS_RUN"] = "1"
-      # Use the shell's audible bell.
-      print "\a"
+        unless args.quiet?
+          analytics_message
+          donation_message
+          install_from_api_message
+        end
 
-      # Use an extra newline and bold to avoid this being missed.
-      ohai "Homebrew has enabled anonymous aggregate formula and cask analytics."
-      puts <<~EOS
-        #{Tty.bold}Read the analytics documentation (and how to opt-out) here:
-          #{Formatter.url("https://docs.brew.sh/Analytics")}#{Tty.reset}
-        No analytics have been recorded yet (nor will be during this `brew` run).
+        tap_or_untap_core_taps_if_necessary
 
-      EOS
+        updated = false
+        new_tag = nil
 
-      # Consider the messages possibly missed if not a TTY.
-      Utils::Analytics.messages_displayed! if $stdout.tty?
-    end
+        initial_revision = ENV["HOMEBREW_UPDATE_BEFORE"].to_s
+        current_revision = ENV["HOMEBREW_UPDATE_AFTER"].to_s
+        odie "update-report should not be called directly!" if initial_revision.empty? || current_revision.empty?
 
-    if Settings.read("donationmessage") != "true" && !args.quiet?
-      ohai "Homebrew is run entirely by unpaid volunteers. Please consider donating:"
-      puts "  #{Formatter.url("https://github.com/Homebrew/brew#donations")}\n\n"
+        if initial_revision != current_revision
+          auto_update_header
 
-      # Consider the message possibly missed if not a TTY.
-      Settings.write "donationmessage", true if $stdout.tty?
-    end
+          updated = true
 
-    install_core_tap_if_necessary
+          old_tag = Settings.read "latesttag"
 
-    updated = false
-    new_tag = nil
+          new_tag = Utils.popen_read(
+            "git", "-C", HOMEBREW_REPOSITORY, "tag", "--list", "--sort=-version:refname", "*.*"
+          ).lines.first.chomp
 
-    initial_revision = ENV["HOMEBREW_UPDATE_BEFORE"].to_s
-    current_revision = ENV["HOMEBREW_UPDATE_AFTER"].to_s
-    odie "update-report should not be called directly!" if initial_revision.empty? || current_revision.empty?
+          Settings.write "latesttag", new_tag if new_tag != old_tag
 
-    if initial_revision != current_revision
-      auto_update_header args: args
+          if new_tag == old_tag
+            ohai "Updated Homebrew from #{shorten_revision(initial_revision)} " \
+                 "to #{shorten_revision(current_revision)}."
+          elsif old_tag.blank?
+            ohai "Updated Homebrew from #{shorten_revision(initial_revision)} " \
+                 "to #{new_tag} (#{shorten_revision(current_revision)})."
+          else
+            ohai "Updated Homebrew from #{old_tag} (#{shorten_revision(initial_revision)}) " \
+                 "to #{new_tag} (#{shorten_revision(current_revision)})."
+          end
+        end
 
-      updated = true
+        # Check if we can parse the JSON and do any Ruby-side follow-up.
+        unless Homebrew::EnvConfig.no_install_from_api?
+          Homebrew::API::Formula.write_names_and_aliases
+          Homebrew::API::Cask.write_names
+        end
 
-      old_tag = Settings.read "latesttag"
+        Homebrew.failed = true if ENV["HOMEBREW_UPDATE_FAILED"]
+        return if Homebrew::EnvConfig.disable_load_formula?
 
-      new_tag = Utils.popen_read(
-        "git", "-C", HOMEBREW_REPOSITORY, "tag", "--list", "--sort=-version:refname", "*.*"
-      ).lines.first.chomp
+        migrate_gcc_dependents_if_needed
 
-      Settings.write "latesttag", new_tag if new_tag != old_tag
+        hub = ReporterHub.new
 
-      if new_tag == old_tag
-        ohai "Updated Homebrew from #{shorten_revision(initial_revision)} to #{shorten_revision(current_revision)}."
-      elsif old_tag.blank?
-        ohai "Updated Homebrew from #{shorten_revision(initial_revision)} " \
-             "to #{new_tag} (#{shorten_revision(current_revision)})."
-      else
-        ohai "Updated Homebrew from #{old_tag} (#{shorten_revision(initial_revision)}) " \
-             "to #{new_tag} (#{shorten_revision(current_revision)})."
-      end
-    end
+        updated_taps = []
+        Tap.installed.each do |tap|
+          next if !tap.git? || tap.git_repository.origin_url.nil?
+          next if (tap.core_tap? || tap.core_cask_tap?) && !Homebrew::EnvConfig.no_install_from_api?
 
-    Homebrew.failed = true if ENV["HOMEBREW_UPDATE_FAILED"]
-    return if Homebrew::EnvConfig.disable_load_formula?
+          if ENV["HOMEBREW_MIGRATE_LINUXBREW_FORMULAE"].present? && tap.core_tap? &&
+             Settings.read("linuxbrewmigrated") != "true"
+            ohai "Migrating formulae from linuxbrew-core to homebrew-core"
 
-    hub = ReporterHub.new
+            LINUXBREW_CORE_MIGRATION_LIST.each do |name|
+              begin
+                formula = Formula[name]
+              rescue FormulaUnavailableError
+                next
+              end
+              next unless formula.any_version_installed?
 
-    updated_taps = []
-    Tap.each do |tap|
-      next unless tap.git?
-      next if (tap.core_tap? || tap == "homebrew/cask") && Homebrew::EnvConfig.install_from_api?
+              keg = formula.installed_kegs.last
+              tab = keg.tab
+              # force a `brew upgrade` from the linuxbrew-core version to the homebrew-core version (even if lower)
+              tab.source["versions"]["version_scheme"] = -1
+              tab.write
+            end
 
-      if ENV["HOMEBREW_MIGRATE_LINUXBREW_FORMULAE"].present? && tap.core_tap? &&
-         Settings.read("linuxbrewmigrated") != "true"
-        ohai "Migrating formulae from linuxbrew-core to homebrew-core"
+            Settings.write "linuxbrewmigrated", true
+          end
 
-        LINUXBREW_CORE_MIGRATION_LIST.each do |name|
           begin
-            formula = Formula[name]
-          rescue FormulaUnavailableError
+            reporter = Reporter.new(tap)
+          rescue Reporter::ReporterRevisionUnsetError => e
+            if Homebrew::EnvConfig.developer?
+              require "utils/backtrace"
+              onoe "#{e.message}\n#{Utils::Backtrace.clean(e)&.join("\n")}"
+            end
             next
           end
-          next unless formula.any_version_installed?
+          if reporter.updated?
+            updated_taps << tap.name
+            hub.add(reporter, auto_update: args.auto_update?)
+          end
+        end
+
+        # If we're installing from the API: we cannot use Git to check for #
+        # differences in packages so instead use {formula,cask}_names.txt to do so.
+        # The first time this runs: we won't yet have a base state
+        # ({formula,cask}_names.before.txt) to compare against so we don't output a
+        # anything and just copy the files for next time.
+        unless Homebrew::EnvConfig.no_install_from_api?
+          api_cache = Homebrew::API::HOMEBREW_CACHE_API
+          core_tap = CoreTap.instance
+          cask_tap = CoreCaskTap.instance
+          [
+            [:formula, core_tap, core_tap.formula_dir],
+            [:cask,    cask_tap, cask_tap.cask_dir],
+          ].each do |type, tap, dir|
+            names_txt = api_cache/"#{type}_names.txt"
+            next unless names_txt.exist?
+
+            names_before_txt = api_cache/"#{type}_names.before.txt"
+            if names_before_txt.exist?
+              reporter = Reporter.new(
+                tap,
+                api_names_txt:        names_txt,
+                api_names_before_txt: names_before_txt,
+                api_dir_prefix:       dir,
+              )
+              if reporter.updated?
+                updated_taps << tap.name
+                hub.add(reporter, auto_update: args.auto_update?)
+              end
+            else
+              FileUtils.cp names_txt, names_before_txt
+            end
+          end
+        end
+
+        unless updated_taps.empty?
+          auto_update_header
+          puts "Updated #{Utils.pluralize("tap", updated_taps.count,
+                                          include_count: true)} (#{updated_taps.to_sentence})."
+          updated = true
+        end
+
+        if updated
+          if hub.empty?
+            puts no_changes_message unless args.quiet?
+          else
+            if ENV.fetch("HOMEBREW_UPDATE_REPORT_ONLY_INSTALLED", false)
+              opoo "HOMEBREW_UPDATE_REPORT_ONLY_INSTALLED is now the default behaviour, " \
+                   "so you can unset it from your environment."
+            end
+
+            hub.dump(auto_update: args.auto_update?) unless args.quiet?
+            hub.reporters.each(&:migrate_tap_migration)
+            hub.reporters.each(&:migrate_cask_rename)
+            hub.reporters.each { |r| r.migrate_formula_rename(force: args.force?, verbose: args.verbose?) }
+
+            CacheStoreDatabase.use(:descriptions) do |db|
+              DescriptionCacheStore.new(db)
+                                   .update_from_report!(hub)
+            end
+            CacheStoreDatabase.use(:cask_descriptions) do |db|
+              CaskDescriptionCacheStore.new(db)
+                                       .update_from_report!(hub)
+            end
+          end
+          puts if args.auto_update?
+        elsif !args.auto_update? && !ENV["HOMEBREW_UPDATE_FAILED"] && !ENV["HOMEBREW_MIGRATE_LINUXBREW_FORMULAE"]
+          puts "Already up-to-date." unless args.quiet?
+        end
+
+        Commands.rebuild_commands_completion_list
+        link_completions_manpages_and_docs
+        Tap.installed.each(&:link_completions_and_manpages)
+
+        failed_fetch_dirs = ENV["HOMEBREW_MISSING_REMOTE_REF_DIRS"]&.split("\n")
+        if failed_fetch_dirs.present?
+          failed_fetch_taps = failed_fetch_dirs.map { |dir| Tap.from_path(dir) }
 
-          keg = formula.installed_kegs.last
-          tab = Tab.for_keg(keg)
-          # force a `brew upgrade` from the linuxbrew-core version to the homebrew-core version (even if lower)
-          tab.source["versions"]["version_scheme"] = -1
-          tab.write
+          ofail <<~EOS
+            Some taps failed to update!
+            The following taps can not read their remote branches:
+              #{failed_fetch_taps.join("\n  ")}
+            This is happening because the remote branch was renamed or deleted.
+            Reset taps to point to the correct remote branches by running `brew tap --repair`
+          EOS
         end
 
-        Settings.write "linuxbrewmigrated", true
+        return if new_tag.blank? || new_tag == old_tag || args.quiet?
+
+        puts
+
+        new_major_version, new_minor_version, new_patch_version = new_tag.split(".").map(&:to_i)
+        old_major_version, old_minor_version = (old_tag.split(".")[0, 2]).map(&:to_i) if old_tag.present?
+        if old_tag.blank? || new_major_version > old_major_version || new_minor_version > old_minor_version
+          puts <<~EOS
+            The #{new_major_version}.#{new_minor_version}.0 release notes are available on the Homebrew Blog:
+              #{Formatter.url("https://brew.sh/blog/#{new_major_version}.#{new_minor_version}.0")}
+          EOS
+        end
+
+        return if new_patch_version.zero?
+
+        puts <<~EOS
+          The #{new_tag} changelog can be found at:
+            #{Formatter.url("https://github.com/Homebrew/brew/releases/tag/#{new_tag}")}
+        EOS
       end
 
-      begin
-        reporter = Reporter.new(tap)
-      rescue Reporter::ReporterRevisionUnsetError => e
-        onoe "#{e.message}\n#{e.backtrace.join "\n"}" if Homebrew::EnvConfig.developer?
-        next
+      def no_changes_message
+        "No changes to formulae or casks."
       end
-      if reporter.updated?
-        updated_taps << tap.name
-        hub.add(reporter, auto_update: args.auto_update?)
+
+      def shorten_revision(revision)
+        Utils.popen_read("git", "-C", HOMEBREW_REPOSITORY, "rev-parse", "--short", revision).chomp
       end
-    end
 
-    unless updated_taps.empty?
-      auto_update_header args: args
-      puts "Updated #{updated_taps.count} #{"tap".pluralize(updated_taps.count)} (#{updated_taps.to_sentence})."
-      updated = true
-    end
+      def tap_or_untap_core_taps_if_necessary
+        return if ENV["HOMEBREW_UPDATE_TEST"]
 
-    if updated
-      if hub.empty?
-        puts "No changes to formulae." unless args.quiet?
-      else
-        if ENV.fetch("HOMEBREW_UPDATE_REPORT_ONLY_INSTALLED", false)
-          opoo "HOMEBREW_UPDATE_REPORT_ONLY_INSTALLED is now the default behaviour, " \
-               "so you can unset it from your environment."
-        end
+        if Homebrew::EnvConfig.no_install_from_api?
+          return if Homebrew::EnvConfig.automatically_set_no_install_from_api?
 
-        hub.dump(updated_formula_report: !args.auto_update?) unless args.quiet?
-        hub.reporters.each(&:migrate_tap_migration)
-        hub.reporters.each { |r| r.migrate_formula_rename(force: args.force?, verbose: args.verbose?) }
+          core_tap = CoreTap.instance
+          return if core_tap.installed?
 
-        CacheStoreDatabase.use(:descriptions) do |db|
-          DescriptionCacheStore.new(db)
-                               .update_from_report!(hub)
-        end
-        CacheStoreDatabase.use(:cask_descriptions) do |db|
-          CaskDescriptionCacheStore.new(db)
-                                   .update_from_report!(hub)
+          core_tap.ensure_installed!
+          revision = CoreTap.instance.git_head
+          ENV["HOMEBREW_UPDATE_BEFORE_HOMEBREW_HOMEBREW_CORE"] = revision
+          ENV["HOMEBREW_UPDATE_AFTER_HOMEBREW_HOMEBREW_CORE"] = revision
+        else
+          return if Homebrew::EnvConfig.developer? || ENV["HOMEBREW_DEV_CMD_RUN"]
+          return if ENV["HOMEBREW_GITHUB_HOSTED_RUNNER"] || ENV["GITHUB_ACTIONS_HOMEBREW_SELF_HOSTED"]
+          return if (HOMEBREW_PREFIX/".homebrewdocker").exist?
+
+          tap_output_header_printed = T.let(false, T::Boolean)
+          [CoreTap.instance, CoreCaskTap.instance].each do |tap|
+            next unless tap.installed?
+
+            if tap.git_branch == "master" &&
+               (Date.parse(T.must(tap.git_repository.last_commit_date)) <= Date.today.prev_month)
+              ohai "#{tap.name} is old and unneeded, untapping to save space..."
+              tap.uninstall
+            else
+              unless tap_output_header_printed
+                puts "Installing from the API is now the default behaviour!"
+                puts "You can save space and time by running:"
+                tap_output_header_printed = true
+              end
+              puts "  brew untap #{tap.name}"
+            end
+          end
         end
       end
-      puts if args.auto_update?
-    elsif !args.auto_update? && !ENV["HOMEBREW_UPDATE_FAILED"] && !ENV["HOMEBREW_MIGRATE_LINUXBREW_FORMULAE"]
-      puts "Already up-to-date." unless args.quiet?
-    end
 
-    Commands.rebuild_commands_completion_list
-    link_completions_manpages_and_docs
-    Tap.each(&:link_completions_and_manpages)
-
-    failed_fetch_dirs = ENV["HOMEBREW_MISSING_REMOTE_REF_DIRS"]&.split("\n")
-    if failed_fetch_dirs.present?
-      failed_fetch_taps = failed_fetch_dirs.map { |dir| Tap.from_path(dir) }
-
-      ofail <<~EOS
-        Some taps failed to update!
-        The following taps can not read their remote branches:
-          #{failed_fetch_taps.join("\n  ")}
-        This is happening because the remote branch was renamed or deleted.
-        Reset taps to point to the correct remote branches by running `brew tap --repair`
-      EOS
-    end
+      def link_completions_manpages_and_docs(repository = HOMEBREW_REPOSITORY)
+        command = "brew update"
+        Utils::Link.link_completions(repository, command)
+        Utils::Link.link_manpages(repository, command)
+        Utils::Link.link_docs(repository, command)
+      rescue => e
+        ofail <<~EOS
+          Failed to link all completions, docs and manpages:
+            #{e}
+        EOS
+      end
 
-    return if new_tag.blank? || new_tag == old_tag || args.quiet?
+      def migrate_gcc_dependents_if_needed
+        # do nothing
+      end
 
-    puts
+      def analytics_message
+        return if Utils::Analytics.messages_displayed?
+        return if Utils::Analytics.no_message_output?
+
+        if Utils::Analytics.disabled? && !Utils::Analytics.influx_message_displayed?
+          ohai "Homebrew's analytics have entirely moved to our InfluxDB instance in the EU."
+          puts "We gather less data than before and have destroyed all Google Analytics data:"
+          puts "  #{Formatter.url("https://docs.brew.sh/Analytics")}#{Tty.reset}"
+          puts "Please reconsider re-enabling analytics to help our volunteer maintainers with:"
+          puts "  brew analytics on"
+        elsif !Utils::Analytics.disabled?
+          ENV["HOMEBREW_NO_ANALYTICS_THIS_RUN"] = "1"
+          # Use the shell's audible bell.
+          print "\a"
+
+          # Use an extra newline and bold to avoid this being missed.
+          ohai "Homebrew collects anonymous analytics."
+          puts <<~EOS
+            #{Tty.bold}Read the analytics documentation (and how to opt-out) here:
+              #{Formatter.url("https://docs.brew.sh/Analytics")}#{Tty.reset}
+            No analytics have been recorded yet (nor will be during this `brew` run).
 
-    new_major_version, new_minor_version, new_patch_version = new_tag.split(".").map(&:to_i)
-    old_major_version, old_minor_version = (old_tag.split(".")[0, 2]).map(&:to_i) if old_tag.present?
-    if old_tag.blank? || new_major_version > old_major_version \
-        || new_minor_version > old_minor_version
-      puts <<~EOS
-        The #{new_major_version}.#{new_minor_version}.0 release notes are available on the Homebrew Blog:
-          #{Formatter.url("https://brew.sh/blog/#{new_major_version}.#{new_minor_version}.0")}
-      EOS
-    end
+          EOS
+        end
 
-    return if new_patch_version.zero?
+        # Consider the messages possibly missed if not a TTY.
+        Utils::Analytics.messages_displayed! if $stdout.tty?
+      end
 
-    puts <<~EOS
-      The #{new_tag} changelog can be found at:
-        #{Formatter.url("https://github.com/Homebrew/brew/releases/tag/#{new_tag}")}
-    EOS
-  end
+      def donation_message
+        return if Settings.read("donationmessage") == "true"
 
-  def shorten_revision(revision)
-    Utils.popen_read("git", "-C", HOMEBREW_REPOSITORY, "rev-parse", "--short", revision).chomp
-  end
+        ohai "Homebrew is run entirely by unpaid volunteers. Please consider donating:"
+        puts "  #{Formatter.url("https://github.com/Homebrew/brew#donations")}\n\n"
 
-  def install_core_tap_if_necessary
-    return if ENV["HOMEBREW_UPDATE_TEST"]
-    return if Homebrew::EnvConfig.install_from_api?
+        # Consider the message possibly missed if not a TTY.
+        Settings.write "donationmessage", true if $stdout.tty?
+      end
 
-    core_tap = CoreTap.instance
-    return if core_tap.installed?
+      def install_from_api_message
+        return if Settings.read("installfromapimessage") == "true"
 
-    CoreTap.ensure_installed!
-    revision = core_tap.git_head
-    ENV["HOMEBREW_UPDATE_BEFORE_HOMEBREW_HOMEBREW_CORE"] = revision
-    ENV["HOMEBREW_UPDATE_AFTER_HOMEBREW_HOMEBREW_CORE"] = revision
-  end
+        no_install_from_api_set = Homebrew::EnvConfig.no_install_from_api? &&
+                                  !Homebrew::EnvConfig.automatically_set_no_install_from_api?
+        return unless no_install_from_api_set
 
-  def link_completions_manpages_and_docs(repository = HOMEBREW_REPOSITORY)
-    command = "brew update"
-    Utils::Link.link_completions(repository, command)
-    Utils::Link.link_manpages(repository, command)
-    Utils::Link.link_docs(repository, command)
-  rescue => e
-    ofail <<~EOS
-      Failed to link all completions, docs and manpages:
-        #{e}
-    EOS
+        ohai "You have HOMEBREW_NO_INSTALL_FROM_API set"
+        puts "Homebrew >=4.1.0 is dramatically faster and less error-prone when installing"
+        puts "from the JSON API. Please consider unsetting HOMEBREW_NO_INSTALL_FROM_API."
+        puts "This message will only be printed once."
+        puts "\n\n"
+
+        # Consider the message possibly missed if not a TTY.
+        Settings.write "installfromapimessage", true if $stdout.tty?
+      end
+    end
   end
 end
 
+require "extend/os/cmd/update-report"
+
 class Reporter
   class ReporterRevisionUnsetError < RuntimeError
     def initialize(var_name)
@@ -298,18 +423,23 @@ def initialize(var_name)
     end
   end
 
-  attr_reader :tap, :initial_revision, :current_revision
-
-  def initialize(tap)
+  def initialize(tap, api_names_txt: nil, api_names_before_txt: nil, api_dir_prefix: nil)
     @tap = tap
 
-    initial_revision_var = "HOMEBREW_UPDATE_BEFORE#{tap.repo_var}"
-    @initial_revision = ENV[initial_revision_var].to_s
-    raise ReporterRevisionUnsetError, initial_revision_var if @initial_revision.empty?
+    # This is slightly involved/weird but all the #report logic is shared so it's worth it.
+    if installed_from_api?(api_names_txt, api_names_before_txt, api_dir_prefix)
+      @api_names_txt = api_names_txt
+      @api_names_before_txt = api_names_before_txt
+      @api_dir_prefix = api_dir_prefix
+    else
+      initial_revision_var = "HOMEBREW_UPDATE_BEFORE#{tap.repository_var_suffix}"
+      @initial_revision = ENV[initial_revision_var].to_s
+      raise ReporterRevisionUnsetError, initial_revision_var if @initial_revision.empty?
 
-    current_revision_var = "HOMEBREW_UPDATE_AFTER#{tap.repo_var}"
-    @current_revision = ENV[current_revision_var].to_s
-    raise ReporterRevisionUnsetError, current_revision_var if @current_revision.empty?
+      current_revision_var = "HOMEBREW_UPDATE_AFTER#{tap.repository_var_suffix}"
+      @current_revision = ENV[current_revision_var].to_s
+      raise ReporterRevisionUnsetError, current_revision_var if @current_revision.empty?
+    end
   end
 
   def report(auto_update: false)
@@ -323,7 +453,7 @@ def report(auto_update: false)
       src = Pathname.new paths.first
       dst = Pathname.new paths.last
 
-      next unless dst.extname == ".rb"
+      next if dst.extname != ".rb"
 
       if paths.any? { |p| tap.cask_file?(p) }
         case status
@@ -336,6 +466,14 @@ def report(auto_update: false)
         when "M"
           # Report updated casks
           @report[:MC] << tap.formula_file_to_name(src)
+        when /^R\d{0,3}/
+          src_full_name = tap.formula_file_to_name(src)
+          dst_full_name = tap.formula_file_to_name(dst)
+          # Don't report formulae that are moved within a tap but not renamed
+          next if src_full_name == dst_full_name
+
+          @report[:DC] << src_full_name
+          @report[:AC] << dst_full_name
         end
       end
 
@@ -362,6 +500,41 @@ def report(auto_update: false)
       end
     end
 
+    renamed_casks = Set.new
+    @report[:DC].each do |old_full_name|
+      old_name = old_full_name.split("/").last
+      new_name = tap.cask_renames[old_name]
+      next unless new_name
+
+      new_full_name = if tap.core_cask_tap?
+        new_name
+      else
+        "#{tap}/#{new_name}"
+      end
+
+      renamed_casks << [old_full_name, new_full_name] if @report[:AC].include?(new_full_name)
+    end
+
+    @report[:AC].each do |new_full_name|
+      new_name = new_full_name.split("/").last
+      old_name = tap.cask_renames.key(new_name)
+      next unless old_name
+
+      old_full_name = if tap.core_cask_tap?
+        old_name
+      else
+        "#{tap}/#{old_name}"
+      end
+
+      renamed_casks << [old_full_name, new_full_name]
+    end
+
+    if renamed_casks.any?
+      @report[:AC] -= renamed_casks.map(&:last)
+      @report[:DC] -= renamed_casks.map(&:first)
+      @report[:RC] = renamed_casks.to_a
+    end
+
     renamed_formulae = Set.new
     @report[:D].each do |old_full_name|
       old_name = old_full_name.split("/").last
@@ -391,17 +564,32 @@ def report(auto_update: false)
       renamed_formulae << [old_full_name, new_full_name]
     end
 
-    if renamed_formulae.present?
+    if renamed_formulae.any?
       @report[:A] -= renamed_formulae.map(&:last)
       @report[:D] -= renamed_formulae.map(&:first)
       @report[:R] = renamed_formulae.to_a
     end
 
+    # If any formulae/casks are marked as added and deleted, remove them from
+    # the report as we've not detected things correctly.
+    if (added_and_deleted_formulae = (@report[:A] & @report[:D]).presence)
+      @report[:A] -= added_and_deleted_formulae
+      @report[:D] -= added_and_deleted_formulae
+    end
+    if (added_and_deleted_casks = (@report[:AC] & @report[:DC]).presence)
+      @report[:AC] -= added_and_deleted_casks
+      @report[:DC] -= added_and_deleted_casks
+    end
+
     @report
   end
 
   def updated?
-    initial_revision != current_revision
+    if installed_from_api?
+      diff.present?
+    else
+      initial_revision != current_revision
+    end
   end
 
   def migrate_tap_migration
@@ -425,7 +613,7 @@ def migrate_tap_migration
         next unless (HOMEBREW_PREFIX/"Caskroom"/new_name).exist?
 
         new_tap = Tap.fetch(new_tap_name)
-        new_tap.install unless new_tap.installed?
+        new_tap.ensure_installed!
         ohai "#{name} has been moved to Homebrew.", <<~EOS
           To uninstall the cask, run:
             brew uninstall --cask --force #{name}
@@ -439,15 +627,18 @@ def migrate_tap_migration
             system HOMEBREW_BREW_FILE, "link", new_full_name, "--overwrite"
           end
         rescue Exception => e # rubocop:disable Lint/RescueException
-          onoe "#{e.message}\n#{e.backtrace.join "\n"}" if Homebrew::EnvConfig.developer?
+          if Homebrew::EnvConfig.developer?
+            require "utils/backtrace"
+            onoe "#{e.message}\n#{Utils::Backtrace.clean(e)&.join("\n")}"
+          end
         end
         next
       end
 
       next unless (dir = HOMEBREW_CELLAR/name).exist? # skip if formula is not installed.
 
-      tabs = dir.subdirs.map { |d| Tab.for_keg(Keg.new(d)) }
-      next unless tabs.first.tap == tap # skip if installed formula is not from this tap.
+      tabs = dir.subdirs.map { |d| Keg.new(d).tab }
+      next if tabs.first.tap != tap # skip if installed formula is not from this tap.
 
       new_tap = Tap.fetch(new_tap_name)
       # For formulae migrated to cask: Auto-install cask or provide install instructions.
@@ -475,7 +666,7 @@ def migrate_tap_migration
           EOS
         end
       else
-        new_tap.install unless new_tap.installed?
+        new_tap.ensure_installed!
         # update tap for each Tab
         tabs.each { |tab| tab.tap = new_tap }
         tabs.each(&:write)
@@ -483,49 +674,69 @@ def migrate_tap_migration
     end
   end
 
+  def migrate_cask_rename
+    Cask::Caskroom.casks.each do |cask|
+      Cask::Migrator.migrate_if_needed(cask)
+    end
+  end
+
   def migrate_formula_rename(force:, verbose:)
     Formula.installed.each do |formula|
       next unless Migrator.needs_migration?(formula)
 
-      oldname = formula.oldname
-      oldname_rack = HOMEBREW_CELLAR/oldname
-
-      if oldname_rack.subdirs.empty?
-        oldname_rack.rmdir_if_possible
-        next
-      end
-
-      new_name = tap.formula_renames[oldname]
-      next unless new_name
+      oldnames_to_migrate = formula.oldnames.select do |oldname|
+        oldname_rack = HOMEBREW_CELLAR/oldname
+        next false unless oldname_rack.exist?
 
-      new_full_name = "#{tap}/#{new_name}"
+        if oldname_rack.subdirs.empty?
+          oldname_rack.rmdir_if_possible
+          next false
+        end
 
-      begin
-        f = Formulary.factory(new_full_name)
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        onoe "#{e.message}\n#{e.backtrace.join "\n"}" if Homebrew::EnvConfig.developer?
-        next
+        true
       end
+      next if oldnames_to_migrate.empty?
 
-      Migrator.migrate_if_needed(f, force: force)
+      Migrator.migrate_if_needed(formula, force:)
     end
   end
 
   private
 
+  attr_reader :tap, :initial_revision, :current_revision, :api_names_txt, :api_names_before_txt, :api_dir_prefix
+
+  def installed_from_api?(api_names_txt = @api_names_txt, api_names_before_txt = @api_names_before_txt,
+                          api_dir_prefix = @api_dir_prefix)
+    !api_names_txt.nil? && !api_names_before_txt.nil? && !api_dir_prefix.nil?
+  end
+
   def diff
-    Utils.popen_read(
-      "git", "-C", tap.path, "diff-tree", "-r", "--name-status", "--diff-filter=AMDR",
-      "-M85%", initial_revision, current_revision
-    )
+    @diff ||= if installed_from_api?
+      # Hack `git diff` output with regexes to look like `git diff-tree` output.
+      # Yes, I know this is a bit filthy but it saves duplicating the #report logic.
+      diff_output = Utils.popen_read("git", "diff", "--no-ext-diff", api_names_before_txt, api_names_txt)
+      header_regex = /^(---|\+\+\+) /
+      add_delete_characters = ["+", "-"].freeze
+
+      diff_output.lines.filter_map do |line|
+        next if line.match?(header_regex)
+        next unless add_delete_characters.include?(line[0])
+
+        line.sub(/^\+/, "A #{api_dir_prefix.basename}/")
+            .sub(/^-/,  "D #{api_dir_prefix.basename}/")
+            .sub(/$/,   ".rb")
+            .chomp
+      end.join("\n")
+    else
+      Utils.popen_read(
+        "git", "-C", tap.path, "diff-tree", "-r", "--name-status", "--diff-filter=AMDR",
+        "-M85%", initial_revision, current_revision
+      )
+    end
   end
 end
 
 class ReporterHub
-  extend T::Sig
-
-  extend Forwardable
-
   attr_reader :reporters
 
   sig { void }
@@ -540,46 +751,29 @@ def select_formula_or_cask(key)
 
   def add(reporter, auto_update: false)
     @reporters << reporter
-    report = reporter.report(auto_update: auto_update).delete_if { |_k, v| v.empty? }
+    report = reporter.report(auto_update:).delete_if { |_k, v| v.empty? }
     @hash.update(report) { |_key, oldval, newval| oldval.concat(newval) }
   end
 
-  delegate empty?: :@hash
-
-  def dump(updated_formula_report: true)
-    report_all = Homebrew::EnvConfig.update_report_all_formulae?
+  def empty?
+    @hash.empty?
+  end
 
-    dump_new_formula_report
-    dump_new_cask_report
-    dump_renamed_formula_report if report_all
-    dump_deleted_formula_report(report_all)
-    dump_deleted_cask_report(report_all)
+  def dump(auto_update: false)
+    unless Homebrew::EnvConfig.no_update_report_new?
+      dump_new_formula_report
+      dump_new_cask_report
+    end
 
-    outdated_formulae = nil
-    outdated_casks = nil
+    dump_deleted_formula_report
+    dump_deleted_cask_report
 
-    if updated_formula_report && report_all
-      dump_modified_formula_report
-      dump_modified_cask_report
-    elsif updated_formula_report
-      outdated_formulae = Formula.installed.select(&:outdated?).map(&:name)
+    outdated_formulae = Formula.installed.select(&:outdated?).map(&:name)
+    outdated_casks = Cask::Caskroom.casks.select(&:outdated?).map(&:token)
+    unless auto_update
       output_dump_formula_or_cask_report "Outdated Formulae", outdated_formulae
-
-      outdated_casks = Cask::Caskroom.casks.select(&:outdated?).map(&:token)
       output_dump_formula_or_cask_report "Outdated Casks", outdated_casks
-    elsif report_all
-      if (changed_formulae = select_formula_or_cask(:M).count) && changed_formulae.positive?
-        ohai "Modified Formulae", "Modified #{changed_formulae} #{"formula".pluralize(changed_formulae)}."
-      end
-
-      if (changed_casks = select_formula_or_cask(:MC).count) && changed_casks.positive?
-        ohai "Modified Casks", "Modified #{changed_casks} #{"cask".pluralize(changed_casks)}."
-      end
-    else
-      outdated_formulae = Formula.installed.select(&:outdated?).map(&:name)
-      outdated_casks = Cask::Caskroom.casks.select(&:outdated?).map(&:token)
     end
-
     return if outdated_formulae.blank? && outdated_casks.blank?
 
     outdated_formulae = outdated_formulae.count
@@ -594,19 +788,24 @@ def dump(updated_formula_report: true)
     msg = ""
 
     if outdated_formulae.positive?
-      msg += "#{Tty.bold}#{outdated_formulae}#{Tty.reset} outdated #{"formula".pluralize(outdated_formulae)}"
+      noun = Utils.pluralize("formula", outdated_formulae, plural: "e")
+      msg += "#{Tty.bold}#{outdated_formulae}#{Tty.reset} outdated #{noun}"
     end
 
     if outdated_casks.positive?
       msg += " and " if msg.present?
-      msg += "#{Tty.bold}#{outdated_casks}#{Tty.reset} outdated #{"cask".pluralize(outdated_casks)}"
+      msg += "#{Tty.bold}#{outdated_casks}#{Tty.reset} outdated #{Utils.pluralize("cask", outdated_casks)}"
     end
 
     return if msg.blank?
 
     puts
+    puts "You have #{msg} installed."
+    # If we're auto-updating, don't need to suggest commands that we're perhaps
+    # already running.
+    return if auto_update
+
     puts <<~EOS
-      You have #{msg} installed.
       You can upgrade #{update_pronoun} with #{Tty.bold}brew upgrade#{Tty.reset}
       or list #{update_pronoun} with #{Tty.bold}brew outdated#{Tty.reset}.
     EOS
@@ -621,79 +820,32 @@ def dump_new_formula_report
   end
 
   def dump_new_cask_report
-    casks = select_formula_or_cask(:AC).sort.map do |name|
+    return if Homebrew::SimulateSystem.simulating_or_running_on_linux?
+
+    casks = select_formula_or_cask(:AC).sort.filter_map do |name|
       name.split("/").last unless cask_installed?(name)
-    end.compact
+    end
 
     output_dump_formula_or_cask_report "New Casks", casks
   end
 
-  def dump_renamed_formula_report
-    formulae = select_formula_or_cask(:R).sort.map do |name, new_name|
-      name = pretty_installed(name) if installed?(name)
-      new_name = pretty_installed(new_name) if installed?(new_name)
-      "#{name} -> #{new_name}"
+  def dump_deleted_formula_report
+    formulae = select_formula_or_cask(:D).sort.filter_map do |name|
+      pretty_uninstalled(name) if installed?(name)
     end
 
-    output_dump_formula_or_cask_report "Renamed Formulae", formulae
-  end
-
-  def dump_deleted_formula_report(report_all)
-    formulae = select_formula_or_cask(:D).sort.map do |name|
-      if installed?(name)
-        pretty_uninstalled(name)
-      elsif report_all
-        name
-      end
-    end.compact
-
-    output_dump_formula_or_cask_report "Deleted Formulae", formulae
+    output_dump_formula_or_cask_report "Deleted Installed Formulae", formulae
   end
 
-  def dump_deleted_cask_report(report_all)
-    casks = select_formula_or_cask(:DC).sort.map do |name|
-      name = name.split("/").last
-      if cask_installed?(name)
-        pretty_uninstalled(name)
-      elsif report_all
-        name
-      end
-    end.compact
+  def dump_deleted_cask_report
+    return if Homebrew::SimulateSystem.simulating_or_running_on_linux?
 
-    output_dump_formula_or_cask_report "Deleted Casks", casks
-  end
-
-  def dump_modified_formula_report
-    formulae = select_formula_or_cask(:M).sort.map do |name|
-      if installed?(name)
-        if outdated?(name)
-          pretty_outdated(name)
-        else
-          pretty_installed(name)
-        end
-      else
-        name
-      end
-    end
-
-    output_dump_formula_or_cask_report "Modified Formulae", formulae
-  end
-
-  def dump_modified_cask_report
-    casks = select_formula_or_cask(:MC).sort.map do |name|
+    casks = select_formula_or_cask(:DC).sort.filter_map do |name|
       name = name.split("/").last
-      if cask_installed?(name)
-        if cask_outdated?(name)
-          pretty_outdated(name)
-        else
-          pretty_installed(name)
-        end
-      else
-        name
-      end
+      pretty_uninstalled(name) if cask_installed?(name)
     end
 
-    output_dump_formula_or_cask_report "Modified Casks", casks
+    output_dump_formula_or_cask_report "Deleted Installed Casks", casks
   end
 
   def output_dump_formula_or_cask_report(title, formulae_or_casks)
diff --git a/Library/Homebrew/cmd/update-reset.rb b/Library/Homebrew/cmd/update-reset.rb
new file mode 100644
index 0000000000000..ca304d5625eb9
--- /dev/null
+++ b/Library/Homebrew/cmd/update-reset.rb
@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "shell_command"
+
+module Homebrew
+  module Cmd
+    class UpdateReset < AbstractCommand
+      include ShellCommand
+
+      cmd_args do
+        description <<~EOS
+          Fetch and reset Homebrew and all tap repositories (or any specified <repository>) using `git`(1) to their latest `origin/HEAD`.
+
+          *Note:* this will destroy all your uncommitted or committed changes.
+        EOS
+
+        named_args :repository
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cmd/update-reset.sh b/Library/Homebrew/cmd/update-reset.sh
index bfd1234e5e21a..2e7fa628a09ea 100644
--- a/Library/Homebrew/cmd/update-reset.sh
+++ b/Library/Homebrew/cmd/update-reset.sh
@@ -1,8 +1,4 @@
-#:  * `update-reset` [<repository> ...]
-#:
-#:  Fetch and reset Homebrew and all tap repositories (or any specified <repository>) using `git`(1) to their latest `origin/HEAD`.
-#:
-#:  *Note:* this will destroy all your uncommitted or committed changes.
+# Documentation defined in Library/Homebrew/cmd/update-reset.rb
 
 # Replaces the function in Library/Homebrew/brew.sh to cache the Git executable to provide
 # speedup when using Git repeatedly and prevent errors if the shim changes mid-update.
@@ -12,6 +8,10 @@ git() {
     # HOMEBREW_LIBRARY is set by bin/brew
     # shellcheck disable=SC2154
     GIT_EXECUTABLE="$("${HOMEBREW_LIBRARY}/Homebrew/shims/shared/git" --homebrew=print-path)"
+    if [[ -z "${GIT_EXECUTABLE}" ]]
+    then
+      odie "Can't find a working Git!"
+    fi
   fi
   "${GIT_EXECUTABLE}" "$@"
 }
@@ -33,7 +33,14 @@ homebrew-update-reset() {
         [[ "${option}" == *d* ]] && HOMEBREW_DEBUG=1
         ;;
       *)
-        REPOS+=("${option}")
+        if [[ -d "${option}/.git" ]]
+        then
+          REPOS+=("${option}")
+        else
+          onoe "${option} is not a Git repository!"
+          brew help update-reset
+          exit 1
+        fi
         ;;
     esac
   done
@@ -56,15 +63,29 @@ homebrew-update-reset() {
       opoo "No remote 'origin' in ${DIR}, skipping update and reset!"
       continue
     fi
+    git -C "${DIR}" config --bool core.autocrlf false
+    git -C "${DIR}" config --bool core.symlinks true
     ohai "Fetching ${DIR}..."
     git -C "${DIR}" fetch --force --tags origin
     git -C "${DIR}" remote set-head origin --auto >/dev/null
     echo
 
     ohai "Resetting ${DIR}..."
-    head="$(git -C "${DIR}" symbolic-ref refs/remotes/origin/HEAD)"
-    head="${head#refs/remotes/origin/}"
-    git -C "${DIR}" checkout --force -B "${head}" origin/HEAD
+    # HOMEBREW_* variables here may all set by bin/brew or the user
+    # shellcheck disable=SC2154
+    if [[ "${DIR}" == "${HOMEBREW_REPOSITORY}" &&
+       (-n "${HOMEBREW_UPDATE_TO_TAG}" ||
+       (-z "${HOMEBREW_DEVELOPER}" && -z "${HOMEBREW_DEV_CMD_RUN}")) ]]
+    then
+      local latest_git_tag
+      latest_git_tag="$(git -C "${DIR}" tag --list --sort="-version:refname" | head -n1)"
+
+      git -C "${DIR}" checkout --force -B stable "refs/tags/${latest_git_tag}"
+    else
+      head="$(git -C "${DIR}" symbolic-ref refs/remotes/origin/HEAD)"
+      head="${head#refs/remotes/origin/}"
+      git -C "${DIR}" checkout --force -B "${head}" origin/HEAD
+    fi
     echo
   done
 }
diff --git a/Library/Homebrew/cmd/update.rb b/Library/Homebrew/cmd/update.rb
new file mode 100644
index 0000000000000..b36f7776c973b
--- /dev/null
+++ b/Library/Homebrew/cmd/update.rb
@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "shell_command"
+
+module Homebrew
+  module Cmd
+    class Update < AbstractCommand
+      include ShellCommand
+
+      cmd_args do
+        description <<~EOS
+          Fetch the newest version of Homebrew and all formulae from GitHub using `git`(1) and perform any necessary migrations.
+        EOS
+        switch "--merge",
+               description: "Use `git merge` to apply updates (rather than `git rebase`)."
+        switch "--auto-update",
+               description: "Run on auto-updates (e.g. before `brew install`). Skips some slower steps."
+        switch "-f", "--force",
+               description: "Always do a slower, full update check (even if unnecessary)."
+        switch "-q", "--quiet",
+               description: "Make some output more quiet."
+        switch "-v", "--verbose",
+               description: "Print the directories checked and `git` operations performed."
+        switch "-d", "--debug",
+               description: "Display a trace of all shell commands as they are executed."
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cmd/update.sh b/Library/Homebrew/cmd/update.sh
index 0269d73edbd77..2bf3bb32722a2 100644
--- a/Library/Homebrew/cmd/update.sh
+++ b/Library/Homebrew/cmd/update.sh
@@ -1,14 +1,4 @@
-#:  * `update` [<options>]
-#:
-#:  Fetch the newest version of Homebrew and all formulae from GitHub using `git`(1) and perform any necessary migrations.
-#:
-#:        --merge                      Use `git merge` to apply updates (rather than `git rebase`).
-#:        --auto-update                Run on auto-updates (e.g. before `brew install`). Skips some slower steps.
-#:    -f, --force                      Always do a slower, full update check (even if unnecessary).
-#:    -q, --quiet                      Make some output more quiet
-#:    -v, --verbose                    Print the directories checked and `git` operations performed.
-#:    -d, --debug                      Display a trace of all shell commands as they are executed.
-#:    -h, --help                       Show this message.
+# Documentation defined in Library/Homebrew/cmd/update.rb
 
 # HOMEBREW_CURLRC, HOMEBREW_DEVELOPER, HOMEBREW_GIT_EMAIL, HOMEBREW_GIT_NAME
 # HOMEBREW_UPDATE_CLEANUP, HOMEBREW_UPDATE_TO_TAG are from the user environment
@@ -25,6 +15,10 @@ curl() {
   if [[ -z "${CURL_EXECUTABLE}" ]]
   then
     CURL_EXECUTABLE="$("${HOMEBREW_LIBRARY}/Homebrew/shims/shared/curl" --homebrew=print-path)"
+    if [[ -z "${CURL_EXECUTABLE}" ]]
+    then
+      odie "Can't find a working Curl!"
+    fi
   fi
   "${CURL_EXECUTABLE}" "$@"
 }
@@ -33,6 +27,10 @@ git() {
   if [[ -z "${GIT_EXECUTABLE}" ]]
   then
     GIT_EXECUTABLE="$("${HOMEBREW_LIBRARY}/Homebrew/shims/shared/git" --homebrew=print-path)"
+    if [[ -z "${GIT_EXECUTABLE}" ]]
+    then
+      odie "Can't find a working Git!"
+    fi
   fi
   "${GIT_EXECUTABLE}" "$@"
 }
@@ -45,9 +43,10 @@ git_init_if_necessary() {
     trap '{ rm -rf .git; exit 1; }' EXIT
     git init
     git config --bool core.autocrlf false
+    git config --bool core.symlinks true
     if [[ "${HOMEBREW_BREW_DEFAULT_GIT_REMOTE}" != "${HOMEBREW_BREW_GIT_REMOTE}" ]]
     then
-      echo "HOMEBREW_BREW_GIT_REMOTE set: using ${HOMEBREW_BREW_GIT_REMOTE} for Homebrew/brew Git remote URL."
+      echo "HOMEBREW_BREW_GIT_REMOTE set: using ${HOMEBREW_BREW_GIT_REMOTE} as the Homebrew/brew Git remote."
     fi
     git config remote.origin.url "${HOMEBREW_BREW_GIT_REMOTE}"
     git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
@@ -67,9 +66,10 @@ git_init_if_necessary() {
     trap '{ rm -rf .git; exit 1; }' EXIT
     git init
     git config --bool core.autocrlf false
+    git config --bool core.symlinks true
     if [[ "${HOMEBREW_CORE_DEFAULT_GIT_REMOTE}" != "${HOMEBREW_CORE_GIT_REMOTE}" ]]
     then
-      echo "HOMEBREW_CORE_GIT_REMOTE set: using ${HOMEBREW_CORE_GIT_REMOTE} for Homebrew/core Git remote URL."
+      echo "HOMEBREW_CORE_GIT_REMOTE set: using ${HOMEBREW_CORE_GIT_REMOTE} as the Homebrew/homebrew-core Git remote."
     fi
     git config remote.origin.url "${HOMEBREW_CORE_GIT_REMOTE}"
     git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
@@ -82,18 +82,18 @@ git_init_if_necessary() {
   fi
 }
 
-repo_var() {
-  local repo_var
+repository_var_suffix() {
+  local repository_directory="${1}"
+  local repository_var_suffix
 
-  repo_var="$1"
-  if [[ "${repo_var}" == "${HOMEBREW_REPOSITORY}" ]]
+  if [[ "${repository_directory}" == "${HOMEBREW_REPOSITORY}" ]]
   then
-    repo_var=""
+    repository_var_suffix=""
   else
-    repo_var="${repo_var#"${HOMEBREW_LIBRARY}/Taps"}"
-    repo_var="$(echo -n "${repo_var}" | tr -C "A-Za-z0-9" "_" | tr "[:lower:]" "[:upper:]")"
+    repository_var_suffix="${repository_directory#"${HOMEBREW_LIBRARY}/Taps"}"
+    repository_var_suffix="$(echo -n "${repository_var_suffix}" | tr -C "A-Za-z0-9" "_" | tr "[:lower:]" "[:upper:]")"
   fi
-  echo "${repo_var}"
+  echo "${repository_var_suffix}"
 }
 
 upstream_branch() {
@@ -256,9 +256,10 @@ EOS
     then
       git checkout --force "${UPSTREAM_BRANCH}" "${QUIET_ARGS[@]}"
     else
-      if [[ -n "${UPSTREAM_TAG}" && "${UPSTREAM_BRANCH}" != "master" ]]
+      if [[ -n "${UPSTREAM_TAG}" && "${UPSTREAM_BRANCH}" != "master" ]] &&
+         [[ "${INITIAL_BRANCH}" != "master" ]]
       then
-        git checkout --force -B "master" "origin/master" "${QUIET_ARGS[@]}"
+        git branch --force "master" "origin/master" "${QUIET_ARGS[@]}"
       fi
 
       git checkout --force -B "${UPSTREAM_BRANCH}" "${REMOTE_REF}" "${QUIET_ARGS[@]}"
@@ -269,7 +270,10 @@ EOS
   export HOMEBREW_UPDATE_BEFORE"${TAP_VAR}"="${INITIAL_REVISION}"
 
   # ensure we don't munge line endings on checkout
-  git config core.autocrlf false
+  git config --bool core.autocrlf false
+
+  # make sure symlinks are saved as-is
+  git config --bool core.symlinks true
 
   if [[ "${DIR}" == "${HOMEBREW_CORE_REPOSITORY}" && -n "${HOMEBREW_LINUXBREW_CORE_MIGRATION}" ]]
   then
@@ -334,9 +338,15 @@ homebrew-update() {
       --verbose) HOMEBREW_VERBOSE=1 ;;
       --debug) HOMEBREW_DEBUG=1 ;;
       --quiet) HOMEBREW_QUIET=1 ;;
-      --merge) HOMEBREW_MERGE=1 ;;
+      --merge)
+        shift
+        HOMEBREW_MERGE=1
+        ;;
       --force) HOMEBREW_UPDATE_FORCE=1 ;;
-      --simulate-from-current-branch) HOMEBREW_SIMULATE_FROM_CURRENT_BRANCH=1 ;;
+      --simulate-from-current-branch)
+        shift
+        HOMEBREW_SIMULATE_FROM_CURRENT_BRANCH=1
+        ;;
       --auto-update) export HOMEBREW_UPDATE_AUTO=1 ;;
       --*) ;;
       -*)
@@ -376,17 +386,23 @@ EOS
 ${HOMEBREW_CELLAR} is not writable. You should change the
 ownership and permissions of ${HOMEBREW_CELLAR} back to your
 user account:
-  sudo chown -R \$(whoami) ${HOMEBREW_CELLAR}
+  sudo chown -R ${USER-\$(whoami)} ${HOMEBREW_CELLAR}
 EOS
   fi
 
+  if [[ -d "${HOMEBREW_CORE_REPOSITORY}" ]] ||
+     [[ -z "${HOMEBREW_NO_INSTALL_FROM_API}" ]]
+  then
+    HOMEBREW_CORE_AVAILABLE="1"
+  fi
+
   if [[ ! -w "${HOMEBREW_REPOSITORY}" ]]
   then
     odie <<EOS
 ${HOMEBREW_REPOSITORY} is not writable. You should change the
 ownership and permissions of ${HOMEBREW_REPOSITORY} back to your
 user account:
-  sudo chown -R \$(whoami) ${HOMEBREW_REPOSITORY}
+  sudo chown -R ${USER-\$(whoami)} ${HOMEBREW_REPOSITORY}
 EOS
   fi
 
@@ -394,7 +410,7 @@ EOS
   if [[ -n "${HOMEBREW_FORCE_BREWED_CA_CERTIFICATES}" && ! -f "${HOMEBREW_PREFIX}/etc/ca-certificates/cert.pem" ]]
   then
     # we cannot install Homebrew CA certificates if homebrew/core is unavailable.
-    if [[ -d "${HOMEBREW_CORE_REPOSITORY}" || -n "${HOMEBREW_INSTALL_FROM_API}" ]]
+    if [[ -n "${HOMEBREW_CORE_AVAILABLE}" ]]
     then
       brew install ca-certificates
       setup_ca_certificates
@@ -405,7 +421,7 @@ EOS
   if [[ -n "${HOMEBREW_FORCE_BREWED_CURL}" && ! -x "${HOMEBREW_PREFIX}/opt/curl/bin/curl" ]]
   then
     # we cannot install a Homebrew cURL if homebrew/core is unavailable.
-    if [[ ! -d "${HOMEBREW_CORE_REPOSITORY}" && -z "${HOMEBREW_INSTALL_FROM_API}" ]] || ! brew install curl
+    if [[ -z "${HOMEBREW_CORE_AVAILABLE}" ]] || ! brew install curl
     then
       odie "'curl' must be installed and in your PATH!"
     fi
@@ -417,7 +433,7 @@ EOS
      [[ -n "${HOMEBREW_FORCE_BREWED_GIT}" && ! -x "${HOMEBREW_PREFIX}/opt/git/bin/git" ]]
   then
     # we cannot install a Homebrew Git if homebrew/core is unavailable.
-    if [[ ! -d "${HOMEBREW_CORE_REPOSITORY}" && -z "${HOMEBREW_INSTALL_FROM_API}" ]] || ! brew install git
+    if [[ -z "${HOMEBREW_CORE_AVAILABLE}" ]] || ! brew install git
     then
       odie "'git' must be installed and in your PATH!"
     fi
@@ -426,7 +442,7 @@ EOS
   fi
 
   [[ -f "${HOMEBREW_CORE_REPOSITORY}/.git/shallow" ]] && HOMEBREW_CORE_SHALLOW=1
-  [[ -f "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-cask/.git/shallow" ]] && HOMEBREW_CASK_SHALLOW=1
+  [[ -f "${HOMEBREW_CASK_REPOSITORY}/.git/shallow" ]] && HOMEBREW_CASK_SHALLOW=1
   if [[ -n "${HOMEBREW_CORE_SHALLOW}" && -n "${HOMEBREW_CASK_SHALLOW}" ]]
   then
     SHALLOW_COMMAND_PHRASE="These commands"
@@ -444,7 +460,7 @@ ${HOMEBREW_CORE_SHALLOW:+
   homebrew-cask is a shallow clone.}
 To \`brew update\`, first run:${HOMEBREW_CORE_SHALLOW:+
   git -C "${HOMEBREW_CORE_REPOSITORY}" fetch --unshallow}${HOMEBREW_CASK_SHALLOW:+
-  git -C "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-cask" fetch --unshallow}
+  git -C "${HOMEBREW_CASK_REPOSITORY}" fetch --unshallow}
 ${SHALLOW_COMMAND_PHRASE} may take a few minutes to run due to the large size of the ${SHALLOW_REPO_PHRASE}.
 This restriction has been made on GitHub's request because updating shallow
 clones is an extremely expensive operation due to the tree layout and traffic of
@@ -472,12 +488,13 @@ EOS
 
   if [[ -z "${HOMEBREW_VERBOSE}" ]]
   then
+    export GIT_ADVICE="false"
     QUIET_ARGS=(-q)
   else
     QUIET_ARGS=()
   fi
 
-  # HOMEBREW_CURLRC isn't misspelt here
+  # HOMEBREW_CURLRC is optionally defined in the user environment.
   # shellcheck disable=SC2153
   if [[ -z "${HOMEBREW_CURLRC}" ]]
   then
@@ -494,7 +511,7 @@ EOS
   if [[ "${HOMEBREW_BREW_DEFAULT_GIT_REMOTE}" != "${HOMEBREW_BREW_GIT_REMOTE}" ]]
   then
     safe_cd "${HOMEBREW_REPOSITORY}"
-    echo "HOMEBREW_BREW_GIT_REMOTE set: using ${HOMEBREW_BREW_GIT_REMOTE} for Homebrew/brew Git remote."
+    echo "HOMEBREW_BREW_GIT_REMOTE set: using ${HOMEBREW_BREW_GIT_REMOTE} as the Homebrew/brew Git remote."
     git remote set-url origin "${HOMEBREW_BREW_GIT_REMOTE}"
     git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
     git fetch --force --tags origin
@@ -513,7 +530,7 @@ EOS
     fi
 
     safe_cd "${HOMEBREW_CORE_REPOSITORY}"
-    echo "HOMEBREW_CORE_GIT_REMOTE set: using ${HOMEBREW_CORE_GIT_REMOTE} for Homebrew/core Git remote."
+    echo "HOMEBREW_CORE_GIT_REMOTE set: using ${HOMEBREW_CORE_GIT_REMOTE} as the Homebrew/homebrew-core Git remote."
     git remote set-url origin "${HOMEBREW_CORE_GIT_REMOTE}"
     git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
     git fetch --force origin refs/heads/master:refs/remotes/origin/master
@@ -546,9 +563,11 @@ EOS
 
   for DIR in "${HOMEBREW_REPOSITORY}" "${HOMEBREW_LIBRARY}"/Taps/*/*
   do
-    if [[ -n "${HOMEBREW_INSTALL_FROM_API}" ]] &&
-       [[ -n "${HOMEBREW_UPDATE_AUTO}" ]] &&
-       [[ "${DIR}" == "${HOMEBREW_CORE_REPOSITORY}" ]]
+    if [[ -z "${HOMEBREW_NO_INSTALL_FROM_API}" ]] &&
+       [[ -n "${HOMEBREW_UPDATE_AUTO}" || (-z "${HOMEBREW_DEVELOPER}" && -z "${HOMEBREW_DEV_CMD_RUN}") ]] &&
+       [[ -n "${HOMEBREW_UPDATE_AUTO}" &&
+          (("${DIR}" == "${HOMEBREW_CORE_REPOSITORY}" && -z "${HOMEBREW_AUTO_UPDATE_CORE_TAP}") ||
+          ("${DIR}" == "${HOMEBREW_CASK_REPOSITORY}" && -z "${HOMEBREW_AUTO_UPDATE_CASK_TAP}")) ]]
     then
       continue
     fi
@@ -556,6 +575,12 @@ EOS
     [[ -d "${DIR}/.git" ]] || continue
     cd "${DIR}" || continue
 
+    if [[ "${DIR}" = "${HOMEBREW_REPOSITORY}" && "${HOMEBREW_REPOSITORY}" = "${HOMEBREW_PREFIX}" ]]
+    then
+      # Git's fsmonitor prevents the release of our locks
+      git config --bool core.fsmonitor false
+    fi
+
     if ! git config --local --get remote.origin.url &>/dev/null
     then
       opoo "No remote 'origin' in ${DIR}, skipping update!"
@@ -567,11 +592,16 @@ EOS
       echo "Checking if we need to fetch ${DIR}..."
     fi
 
-    TAP_VAR="$(repo_var "${DIR}")"
+    TAP_VAR="$(repository_var_suffix "${DIR}")"
     UPSTREAM_BRANCH_DIR="$(upstream_branch)"
     declare UPSTREAM_BRANCH"${TAP_VAR}"="${UPSTREAM_BRANCH_DIR}"
     declare PREFETCH_REVISION"${TAP_VAR}"="$(git rev-parse -q --verify refs/remotes/origin/"${UPSTREAM_BRANCH_DIR}")"
 
+    if [[ -n "${GITHUB_ACTIONS}" && -n "${HOMEBREW_UPDATE_SKIP_BREW}" && "${DIR}" == "${HOMEBREW_REPOSITORY}" ]]
+    then
+      continue
+    fi
+
     # Force a full update if we don't have any tags.
     if [[ "${DIR}" == "${HOMEBREW_REPOSITORY}" && -z "$(git tag --list)" ]]
     then
@@ -584,12 +614,34 @@ EOS
       [[ -n "${SKIP_FETCH_CORE_REPOSITORY}" && "${DIR}" == "${HOMEBREW_CORE_REPOSITORY}" ]] && continue
     fi
 
+    if [[ -z "${UPDATING_MESSAGE_SHOWN}" ]]
+    then
+      if [[ -n "${HOMEBREW_UPDATE_AUTO}" ]]
+      then
+        # Outputting a command but don't want to run it, hence single quotes.
+        # shellcheck disable=SC2016
+        ohai 'Auto-updating Homebrew...' >&2
+        if [[ -z "${HOMEBREW_NO_ENV_HINTS}" && -z "${HOMEBREW_AUTO_UPDATE_SECS}" ]]
+        then
+          # shellcheck disable=SC2016
+          echo 'Adjust how often this is run with HOMEBREW_AUTO_UPDATE_SECS or disable with' >&2
+          # shellcheck disable=SC2016
+          echo 'HOMEBREW_NO_AUTO_UPDATE. Hide these hints with HOMEBREW_NO_ENV_HINTS (see `man brew`).' >&2
+        fi
+      else
+        ohai 'Updating Homebrew...' >&2
+      fi
+      UPDATING_MESSAGE_SHOWN=1
+    fi
+
     # The upstream repository's default branch may not be master;
     # check refs/remotes/origin/HEAD to see what the default
     # origin branch name is, and use that. If not set, fall back to "master".
     # the refspec ensures that the default upstream branch gets updated
     (
       UPSTREAM_REPOSITORY_URL="$(git config remote.origin.url)"
+      unset UPSTREAM_REPOSITORY
+      unset UPSTREAM_REPOSITORY_TOKEN
 
       # HOMEBREW_UPDATE_FORCE and HOMEBREW_UPDATE_AUTO aren't modified here so ignore subshell warning.
       # shellcheck disable=SC2030
@@ -597,31 +649,54 @@ EOS
       then
         UPSTREAM_REPOSITORY="${UPSTREAM_REPOSITORY_URL#https://github.com/}"
         UPSTREAM_REPOSITORY="${UPSTREAM_REPOSITORY%.git}"
+      elif [[ "${DIR}" != "${HOMEBREW_REPOSITORY}" ]] &&
+           [[ "${UPSTREAM_REPOSITORY_URL}" =~ https://([[:alnum:]_:]+)@github.com/(.*)$ ]]
+      then
+        UPSTREAM_REPOSITORY="${BASH_REMATCH[2]%.git}"
+        UPSTREAM_REPOSITORY_TOKEN="${BASH_REMATCH[1]#*:}"
+      fi
+
+      if [[ -n "${UPSTREAM_REPOSITORY}" ]]
+      then
+        # UPSTREAM_REPOSITORY_TOKEN is parsed (if exists) from UPSTREAM_REPOSITORY_URL
+        # HOMEBREW_GITHUB_API_TOKEN is optionally defined in the user environment.
+        # shellcheck disable=SC2153
+        if [[ -n "${UPSTREAM_REPOSITORY_TOKEN}" ]]
+        then
+          CURL_GITHUB_API_ARGS=("--header" "Authorization: token ${UPSTREAM_REPOSITORY_TOKEN}")
+        elif [[ -n "${HOMEBREW_GITHUB_API_TOKEN}" ]]
+        then
+          CURL_GITHUB_API_ARGS=("--header" "Authorization: token ${HOMEBREW_GITHUB_API_TOKEN}")
+        else
+          CURL_GITHUB_API_ARGS=()
+        fi
 
         if [[ "${DIR}" == "${HOMEBREW_REPOSITORY}" && -n "${HOMEBREW_UPDATE_TO_TAG}" ]]
         then
           # Only try to `git fetch` when the upstream tags have changed
           # (so the API does not return 304: unmodified).
           GITHUB_API_ETAG="$(sed -n 's/^ETag: "\([a-f0-9]\{32\}\)".*/\1/p' ".git/GITHUB_HEADERS" 2>/dev/null)"
-          GITHUB_API_ACCEPT="application/vnd.github.v3+json"
+          GITHUB_API_ACCEPT="application/vnd.github+json"
           GITHUB_API_ENDPOINT="tags"
         else
           # Only try to `git fetch` when the upstream branch is at a different SHA
           # (so the API does not return 304: unmodified).
           GITHUB_API_ETAG="$(git rev-parse "refs/remotes/origin/${UPSTREAM_BRANCH_DIR}")"
-          GITHUB_API_ACCEPT="application/vnd.github.v3.sha"
+          GITHUB_API_ACCEPT="application/vnd.github.sha"
           GITHUB_API_ENDPOINT="commits/${UPSTREAM_BRANCH_DIR}"
         fi
 
-        # HOMEBREW_CURL is set by brew.sh (and isn't mispelt here)
+        # HOMEBREW_CURL is set by brew.sh (and isn't misspelt here)
         # shellcheck disable=SC2153
         UPSTREAM_SHA_HTTP_CODE="$(
           curl \
             "${CURL_DISABLE_CURLRC_ARGS[@]}" \
+            "${CURL_GITHUB_API_ARGS[@]}" \
             --silent --max-time 3 \
             --location --no-remote-time --output /dev/null --write-out "%{http_code}" \
             --dump-header "${DIR}/.git/GITHUB_HEADERS" \
             --user-agent "${HOMEBREW_USER_AGENT_CURL}" \
+            --header "X-GitHub-Api-Version:2022-11-28" \
             --header "Accept: ${GITHUB_API_ACCEPT}" \
             --header "If-None-Match: \"${GITHUB_API_ETAG}\"" \
             "https://api.github.com/repos/${UPSTREAM_REPOSITORY}/${GITHUB_API_ENDPOINT}"
@@ -630,14 +705,6 @@ EOS
         # Touch FETCH_HEAD to confirm we've checked for an update.
         [[ -f "${DIR}/.git/FETCH_HEAD" ]] && touch "${DIR}/.git/FETCH_HEAD"
         [[ -z "${HOMEBREW_UPDATE_FORCE}" ]] && [[ "${UPSTREAM_SHA_HTTP_CODE}" == "304" ]] && exit
-      elif [[ -n "${HOMEBREW_UPDATE_AUTO}" ]]
-      then
-        FORCE_AUTO_UPDATE="$(git config homebrew.forceautoupdate 2>/dev/null || echo "false")"
-        if [[ "${FORCE_AUTO_UPDATE}" != "true" ]]
-        then
-          # Don't try to do a `git fetch` that may take longer than expected.
-          exit
-        fi
       fi
 
       # HOMEBREW_VERBOSE isn't modified here so ignore subshell warning.
@@ -685,13 +752,6 @@ EOS
   wait
   trap - SIGINT
 
-  if [[ -f "${update_failed_file}" ]]
-  then
-    onoe <"${update_failed_file}"
-    rm -f "${update_failed_file}"
-    export HOMEBREW_UPDATE_FAILED="1"
-  fi
-
   if [[ -f "${missing_remote_ref_dirs_file}" ]]
   then
     HOMEBREW_MISSING_REMOTE_REF_DIRS="$(cat "${missing_remote_ref_dirs_file}")"
@@ -701,9 +761,11 @@ EOS
 
   for DIR in "${HOMEBREW_REPOSITORY}" "${HOMEBREW_LIBRARY}"/Taps/*/*
   do
-    if [[ -n "${HOMEBREW_INSTALL_FROM_API}" ]] &&
-       [[ "${DIR}" == "${HOMEBREW_CORE_REPOSITORY}" ||
-          "${DIR}" == "${HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-cask" ]]
+    if [[ -z "${HOMEBREW_NO_INSTALL_FROM_API}" ]] &&
+       [[ -n "${HOMEBREW_UPDATE_AUTO}" || (-z "${HOMEBREW_DEVELOPER}" && -z "${HOMEBREW_DEV_CMD_RUN}") ]] &&
+       [[ -n "${HOMEBREW_UPDATE_AUTO}" &&
+          (("${DIR}" == "${HOMEBREW_CORE_REPOSITORY}" && -z "${HOMEBREW_AUTO_UPDATE_CORE_TAP}") ||
+          ("${DIR}" == "${HOMEBREW_CASK_REPOSITORY}" && -z "${HOMEBREW_AUTO_UPDATE_CASK_TAP}")) ]]
     then
       continue
     fi
@@ -716,7 +778,7 @@ EOS
       continue
     fi
 
-    TAP_VAR="$(repo_var "${DIR}")"
+    TAP_VAR="$(repository_var_suffix "${DIR}")"
     UPSTREAM_BRANCH_VAR="UPSTREAM_BRANCH${TAP_VAR}"
     UPSTREAM_BRANCH="${!UPSTREAM_BRANCH_VAR}"
     CURRENT_REVISION="$(read_current_revision)"
@@ -730,30 +792,110 @@ EOS
     if [[ -n "${HOMEBREW_SIMULATE_FROM_CURRENT_BRANCH}" ]]
     then
       simulate_from_current_branch "${DIR}" "${TAP_VAR}" "${UPSTREAM_BRANCH}" "${CURRENT_REVISION}"
-    elif [[ -z "${HOMEBREW_UPDATE_FORCE}" ]] &&
-         [[ "${PREFETCH_REVISION}" == "${POSTFETCH_REVISION}" ]] &&
-         [[ "${CURRENT_REVISION}" == "${POSTFETCH_REVISION}" ]]
+    elif [[ -z "${HOMEBREW_UPDATE_FORCE}" &&
+            "${PREFETCH_REVISION}" == "${POSTFETCH_REVISION}" &&
+            "${CURRENT_REVISION}" == "${POSTFETCH_REVISION}" ]] ||
+         [[ -n "${GITHUB_ACTIONS}" && -n "${HOMEBREW_UPDATE_SKIP_BREW}" && "${DIR}" == "${HOMEBREW_REPOSITORY}" ]]
     then
       export HOMEBREW_UPDATE_BEFORE"${TAP_VAR}"="${CURRENT_REVISION}"
       export HOMEBREW_UPDATE_AFTER"${TAP_VAR}"="${CURRENT_REVISION}"
     else
       merge_or_rebase "${DIR}" "${TAP_VAR}" "${UPSTREAM_BRANCH}"
-      [[ -n "${HOMEBREW_VERBOSE}" ]] && echo
     fi
   done
 
-  if [[ -n "${HOMEBREW_INSTALL_FROM_API}" ]]
-  then
-    mkdir -p "${HOMEBREW_CACHE}/api"
-    # TODO: use --header If-Modified-Since
-    curl \
-      "${CURL_DISABLE_CURLRC_ARGS[@]}" \
-      --fail --compressed --silent --max-time 5 \
-      --location --remote-time --output "${HOMEBREW_CACHE}/api/formula.json" \
-      --user-agent "${HOMEBREW_USER_AGENT_CURL}" \
-      "https://formulae.brew.sh/api/formula.json"
-    # TODO: we probably want to print an error if this fails.
-    # TODO: set HOMEBREW_UPDATED or HOMEBREW_UPDATE_FAILED
+  if [[ -z "${HOMEBREW_NO_INSTALL_FROM_API}" ]]
+  then
+    local api_cache="${HOMEBREW_CACHE}/api"
+    mkdir -p "${api_cache}"
+
+    for json in formula cask formula_tap_migrations cask_tap_migrations
+    do
+      local filename="${json}.jws.json"
+      local cache_path="${api_cache}/${filename}"
+      if [[ -f "${cache_path}" ]]
+      then
+        INITIAL_JSON_BYTESIZE="$(wc -c "${cache_path}")"
+      fi
+
+      if [[ -n "${HOMEBREW_VERBOSE}" ]]
+      then
+        echo "Checking if we need to fetch ${filename}..."
+      fi
+
+      JSON_URLS=()
+      if [[ -n "${HOMEBREW_API_DOMAIN}" && "${HOMEBREW_API_DOMAIN}" != "${HOMEBREW_API_DEFAULT_DOMAIN}" ]]
+      then
+        JSON_URLS=("${HOMEBREW_API_DOMAIN}/${filename}")
+      fi
+
+      JSON_URLS+=("${HOMEBREW_API_DEFAULT_DOMAIN}/${filename}")
+      for json_url in "${JSON_URLS[@]}"
+      do
+        time_cond=()
+        if [[ -s "${cache_path}" ]]
+        then
+          time_cond=("--time-cond" "${cache_path}")
+        fi
+        curl \
+          "${CURL_DISABLE_CURLRC_ARGS[@]}" \
+          --fail --compressed --silent \
+          --speed-limit "${HOMEBREW_CURL_SPEED_LIMIT}" --speed-time "${HOMEBREW_CURL_SPEED_TIME}" \
+          --location --remote-time --output "${cache_path}" \
+          "${time_cond[@]}" \
+          --user-agent "${HOMEBREW_USER_AGENT_CURL}" \
+          "${json_url}"
+        curl_exit_code=$?
+        [[ ${curl_exit_code} -eq 0 ]] && break
+      done
+
+      if [[ "${json}" == "formula" ]] && [[ -f "${api_cache}/formula_names.txt" ]]
+      then
+        mv -f "${api_cache}/formula_names.txt" "${api_cache}/formula_names.before.txt"
+      elif [[ "${json}" == "cask" ]] && [[ -f "${api_cache}/cask_names.txt" ]]
+      then
+        mv -f "${api_cache}/cask_names.txt" "${api_cache}/cask_names.before.txt"
+      fi
+
+      if [[ ${curl_exit_code} -eq 0 ]]
+      then
+        touch "${cache_path}"
+
+        CURRENT_JSON_BYTESIZE="$(wc -c "${cache_path}")"
+        if [[ "${INITIAL_JSON_BYTESIZE}" != "${CURRENT_JSON_BYTESIZE}" ]]
+        then
+
+          if [[ "${json}" == "formula" ]]
+          then
+            rm -f "${api_cache}/formula_aliases.txt"
+          fi
+          HOMEBREW_UPDATED="1"
+
+          if [[ -n "${HOMEBREW_VERBOSE}" ]]
+          then
+            echo "Updated ${filename}."
+          fi
+        fi
+      else
+        echo "Failed to download ${json_url}!" >>"${update_failed_file}"
+      fi
+
+    done
+
+    # Not a typo, these are the files we used to download that no longer need so should cleanup.
+    rm -f "${HOMEBREW_CACHE}/api/formula.json" "${HOMEBREW_CACHE}/api/cask.json"
+  else
+    if [[ -n "${HOMEBREW_VERBOSE}" ]]
+    then
+      echo "HOMEBREW_NO_INSTALL_FROM_API set: skipping API JSON downloads."
+    fi
+  fi
+
+  if [[ -f "${update_failed_file}" ]]
+  then
+    onoe <"${update_failed_file}"
+    rm -f "${update_failed_file}"
+    export HOMEBREW_UPDATE_FAILED="1"
   fi
 
   safe_cd "${HOMEBREW_REPOSITORY}"
diff --git a/Library/Homebrew/cmd/upgrade.rb b/Library/Homebrew/cmd/upgrade.rb
index ec7520a7c33d7..cf17914f10d53 100644
--- a/Library/Homebrew/cmd/upgrade.rb
+++ b/Library/Homebrew/cmd/upgrade.rb
@@ -1,231 +1,277 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 require "formula_installer"
 require "install"
 require "upgrade"
-require "cask/cmd"
 require "cask/utils"
+require "cask/upgrade"
 require "cask/macos"
 require "api"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def upgrade_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Upgrade outdated casks and outdated, unpinned formulae using the same options they were originally
-        installed with, plus any appended brew formula options. If <cask> or <formula> are specified,
-        upgrade only the given <cask> or <formula> kegs (unless they are pinned; see `pin`, `unpin`).
-
-        Unless `HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew reinstall` will be run for
-        outdated dependents and dependents with broken linkage, respectively.
-
-        Unless `HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for the
-        upgraded formulae or, every 30 days, for all formulae.
-      EOS
-      switch "-d", "--debug",
-             description: "If brewing fails, open an interactive debugging session with access to IRB " \
-                          "or a shell inside the temporary build directory."
-      switch "-f", "--force",
-             description: "Install formulae without checking for previously installed keg-only or " \
-                          "non-migrated versions. When installing casks, overwrite existing files " \
-                          "(binaries and symlinks are excluded, unless originally from the same cask)."
-      switch "-v", "--verbose",
-             description: "Print the verification and postinstall steps."
-      switch "-n", "--dry-run",
-             description: "Show what would be upgraded, but do not actually upgrade anything."
-      [
-        [:switch, "--formula", "--formulae", {
-          description: "Treat all named arguments as formulae. If no named arguments " \
-                       "are specified, upgrade only outdated formulae.",
-        }],
-        [:switch, "-s", "--build-from-source", {
-          description: "Compile <formula> from source even if a bottle is available.",
-        }],
-        [:switch, "-i", "--interactive", {
-          description: "Download and patch <formula>, then open a shell. This allows the user to " \
-                       "run `./configure --help` and otherwise determine how to turn the software " \
-                       "package into a Homebrew package.",
-        }],
-        [:switch, "--force-bottle", {
-          description: "Install from a bottle if it exists for the current or newest version of " \
-                       "macOS, even if it would not normally be used for installation.",
-        }],
-        [:switch, "--fetch-HEAD", {
-          description: "Fetch the upstream repository to detect if the HEAD installation of the " \
-                       "formula is outdated. Otherwise, the repository's HEAD will only be checked for " \
-                       "updates when a new stable or development version has been released.",
-        }],
-        [:switch, "--ignore-pinned", {
-          description: "Set a successful exit status even if pinned formulae are not upgraded.",
-        }],
-        [:switch, "--keep-tmp", {
-          description: "Retain the temporary files created during installation.",
-        }],
-        [:switch, "--display-times", {
-          env:         :display_install_times,
-          description: "Print install times for each package at the end of the run.",
-        }],
-      ].each do |options|
-        send(*options)
-        conflicts "--cask", options[-2]
-      end
-      formula_options
-      [
-        [:switch, "--cask", "--casks", {
-          description: "Treat all named arguments as casks. If no named arguments " \
-                       "are specified, upgrade only outdated casks.",
-        }],
-        *Cask::Cmd::AbstractCommand::OPTIONS,
-        *Cask::Cmd::Upgrade::OPTIONS,
-      ].each do |options|
-        send(*options)
-        conflicts "--formula", options[-2]
-      end
-      cask_options
+  module Cmd
+    class UpgradeCmd < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Upgrade outdated casks and outdated, unpinned formulae using the same options they were originally
+          installed with, plus any appended brew formula options. If <cask> or <formula> are specified,
+          upgrade only the given <cask> or <formula> kegs (unless they are pinned; see `pin`, `unpin`).
 
-      conflicts "--build-from-source", "--force-bottle"
+          Unless `HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew reinstall` will be run for
+          outdated dependents and dependents with broken linkage, respectively.
 
-      named_args [:outdated_formula, :outdated_cask]
-    end
-  end
+          Unless `HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for the
+          upgraded formulae or, every 30 days, for all formulae.
+        EOS
+        switch "-d", "--debug",
+               description: "If brewing fails, open an interactive debugging session with access to IRB " \
+                            "or a shell inside the temporary build directory."
+        switch "--display-times",
+               env:         :display_install_times,
+               description: "Print install times for each package at the end of the run."
+        switch "-f", "--force",
+               description: "Install formulae without checking for previously installed keg-only or " \
+                            "non-migrated versions. When installing casks, overwrite existing files " \
+                            "(binaries and symlinks are excluded, unless originally from the same cask)."
+        switch "-v", "--verbose",
+               description: "Print the verification and post-install steps."
+        switch "-n", "--dry-run",
+               description: "Show what would be upgraded, but do not actually upgrade anything."
+        [
+          [:switch, "--formula", "--formulae", {
+            description: "Treat all named arguments as formulae. If no named arguments " \
+                         "are specified, upgrade only outdated formulae.",
+          }],
+          [:switch, "-s", "--build-from-source", {
+            description: "Compile <formula> from source even if a bottle is available.",
+          }],
+          [:switch, "-i", "--interactive", {
+            description: "Download and patch <formula>, then open a shell. This allows the user to " \
+                         "run `./configure --help` and otherwise determine how to turn the software " \
+                         "package into a Homebrew package.",
+          }],
+          [:switch, "--force-bottle", {
+            description: "Install from a bottle if it exists for the current or newest version of " \
+                         "macOS, even if it would not normally be used for installation.",
+          }],
+          [:switch, "--fetch-HEAD", {
+            description: "Fetch the upstream repository to detect if the HEAD installation of the " \
+                         "formula is outdated. Otherwise, the repository's HEAD will only be checked for " \
+                         "updates when a new stable or development version has been released.",
+          }],
+          [:switch, "--keep-tmp", {
+            description: "Retain the temporary files created during installation.",
+          }],
+          [:switch, "--debug-symbols", {
+            depends_on:  "--build-from-source",
+            description: "Generate debug symbols on build. Source will be retained in a cache directory.",
+          }],
+          [:switch, "--overwrite", {
+            description: "Delete files that already exist in the prefix while linking.",
+          }],
+        ].each do |args|
+          options = args.pop
+          send(*args, **options)
+          conflicts "--cask", args.last
+        end
+        formula_options
+        [
+          [:switch, "--cask", "--casks", {
+            description: "Treat all named arguments as casks. If no named arguments " \
+                         "are specified, upgrade only outdated casks.",
+          }],
+          [:switch, "--skip-cask-deps", {
+            description: "Skip installing cask dependencies.",
+          }],
+          [:switch, "-g", "--greedy", {
+            description: "Also include casks with `auto_updates true` or `version :latest`.",
+          }],
+          [:switch, "--greedy-latest", {
+            description: "Also include casks with `version :latest`.",
+          }],
+          [:switch, "--greedy-auto-updates", {
+            description: "Also include casks with `auto_updates true`.",
+          }],
+          [:switch, "--[no-]binaries", {
+            description: "Disable/enable linking of helper executables (default: enabled).",
+            env:         :cask_opts_binaries,
+          }],
+          [:switch, "--require-sha",  {
+            description: "Require all casks to have a checksum.",
+            env:         :cask_opts_require_sha,
+          }],
+          [:switch, "--[no-]quarantine", {
+            description: "Disable/enable quarantining of downloads (default: enabled).",
+            env:         :cask_opts_quarantine,
+          }],
+        ].each do |args|
+          options = args.pop
+          send(*args, **options)
+          conflicts "--formula", args.last
+        end
+        cask_options
 
-  sig { void }
-  def upgrade
-    args = upgrade_args.parse
+        conflicts "--build-from-source", "--force-bottle"
 
-    formulae, casks = args.named.to_resolved_formulae_to_casks
-    # If one or more formulae are specified, but no casks were
-    # specified, we want to make note of that so we don't
-    # try to upgrade all outdated casks.
-    only_upgrade_formulae = formulae.present? && casks.blank?
-    only_upgrade_casks = casks.present? && formulae.blank?
+        named_args [:installed_formula, :installed_cask]
+      end
 
-    upgrade_outdated_formulae(formulae, args: args) unless only_upgrade_casks
-    upgrade_outdated_casks(casks, args: args) unless only_upgrade_formulae
+      sig { override.void }
+      def run
+        if args.build_from_source? && args.named.empty?
+          raise ArgumentError, "--build-from-source requires at least one formula"
+        end
 
-    Homebrew.messages.display_messages(display_times: args.display_times?)
-  end
+        formulae, casks = args.named.to_resolved_formulae_to_casks
+        # If one or more formulae are specified, but no casks were
+        # specified, we want to make note of that so we don't
+        # try to upgrade all outdated casks.
+        only_upgrade_formulae = formulae.present? && casks.blank?
+        only_upgrade_casks = casks.present? && formulae.blank?
 
-  sig { params(formulae: T::Array[Formula], args: CLI::Args).returns(T::Boolean) }
-  def upgrade_outdated_formulae(formulae, args:)
-    return false if args.cask?
+        formulae = Homebrew::Attestation.sort_formulae_for_install(formulae) if Homebrew::Attestation.enabled?
 
-    if args.build_from_source? && !DevelopmentTools.installed?
-      raise BuildFlagsError.new(["--build-from-source"], bottled: formulae.all?(&:bottled?))
-    end
+        upgrade_outdated_formulae(formulae) unless only_upgrade_casks
+        upgrade_outdated_casks(casks) unless only_upgrade_formulae
 
-    Install.perform_preinstall_checks
+        Cleanup.periodic_clean!(dry_run: args.dry_run?)
 
-    if formulae.blank?
-      outdated = Formula.installed.select do |f|
-        f.outdated?(fetch_head: args.fetch_HEAD?)
-      end
-    else
-      outdated, not_outdated = formulae.partition do |f|
-        f.outdated?(fetch_head: args.fetch_HEAD?)
+        Homebrew.messages.display_messages(display_times: args.display_times?)
       end
 
-      not_outdated.each do |f|
-        versions = f.installed_kegs.map(&:version)
-        if versions.empty?
-          ofail "#{f.full_specified_name} not installed"
+      private
+
+      sig { params(formulae: T::Array[Formula]).returns(T::Boolean) }
+      def upgrade_outdated_formulae(formulae)
+        return false if args.cask?
+
+        if args.build_from_source?
+          unless DevelopmentTools.installed?
+            raise BuildFlagsError.new(["--build-from-source"], bottled: formulae.all?(&:bottled?))
+          end
+
+          unless Homebrew::EnvConfig.developer?
+            opoo "building from source is not supported!"
+            puts "You're on your own. Failures are expected so don't create any issues, please!"
+          end
+        end
+
+        if formulae.blank?
+          outdated = Formula.installed.select do |f|
+            f.outdated?(fetch_head: args.fetch_HEAD?)
+          end
         else
-          version = versions.max
-          opoo "#{f.full_specified_name} #{version} already installed"
+          outdated, not_outdated = formulae.partition do |f|
+            f.outdated?(fetch_head: args.fetch_HEAD?)
+          end
+
+          not_outdated.each do |f|
+            latest_keg = f.installed_kegs.max_by(&:scheme_and_version)
+            if latest_keg.nil?
+              ofail "#{f.full_specified_name} not installed"
+            else
+              opoo "#{f.full_specified_name} #{latest_keg.version} already installed" unless args.quiet?
+            end
+          end
         end
-      end
-    end
 
-    return false if outdated.blank?
+        return false if outdated.blank?
 
-    pinned = outdated.select(&:pinned?)
-    outdated -= pinned
-    formulae_to_install = outdated.map do |f|
-      f_latest = f.latest_formula
-      if f_latest.latest_version_installed?
-        f
-      else
-        f_latest
-      end
-    end
+        pinned = outdated.select(&:pinned?)
+        outdated -= pinned
+        formulae_to_install = outdated.map do |f|
+          f_latest = f.latest_formula
+          if f_latest.latest_version_installed?
+            f
+          else
+            f_latest
+          end
+        end
 
-    if !pinned.empty? && !args.ignore_pinned?
-      ofail "Not upgrading #{pinned.count} pinned #{"package".pluralize(pinned.count)}:"
-      puts pinned.map { |f| "#{f.full_specified_name} #{f.pkg_version}" } * ", "
-    end
+        if pinned.any?
+          Kernel.public_send(
+            formulae.any? ? :ofail : :opoo, # only fail when pinned formulae are named explicitly
+            "Not upgrading #{pinned.count} pinned #{Utils.pluralize("package", pinned.count)}:",
+          )
+          puts pinned.map { |f| "#{f.full_specified_name} #{f.pkg_version}" } * ", "
+        end
 
-    if formulae_to_install.empty?
-      oh1 "No packages to upgrade"
-    else
-      verb = args.dry_run? ? "Would upgrade" : "Upgrading"
-      oh1 "#{verb} #{formulae_to_install.count} outdated #{"package".pluralize(formulae_to_install.count)}:"
-      formulae_upgrades = formulae_to_install.map do |f|
-        if f.optlinked?
-          "#{f.full_specified_name} #{Keg.new(f.opt_prefix).version} -> #{f.pkg_version}"
+        if formulae_to_install.empty?
+          oh1 "No packages to upgrade"
         else
-          "#{f.full_specified_name} #{f.pkg_version}"
+          verb = args.dry_run? ? "Would upgrade" : "Upgrading"
+          oh1 "#{verb} #{formulae_to_install.count} outdated #{Utils.pluralize("package",
+                                                                               formulae_to_install.count)}:"
+          formulae_upgrades = formulae_to_install.map do |f|
+            if f.optlinked?
+              "#{f.full_specified_name} #{Keg.new(f.opt_prefix).version} -> #{f.pkg_version}"
+            else
+              "#{f.full_specified_name} #{f.pkg_version}"
+            end
+          end
+          puts formulae_upgrades.join("\n")
         end
+
+        Install.perform_preinstall_checks_once
+
+        Upgrade.upgrade_formulae(
+          formulae_to_install,
+          flags:                      args.flags_only,
+          dry_run:                    args.dry_run?,
+          installed_on_request:       args.named.present?,
+          force_bottle:               args.force_bottle?,
+          build_from_source_formulae: args.build_from_source_formulae,
+          interactive:                args.interactive?,
+          keep_tmp:                   args.keep_tmp?,
+          debug_symbols:              args.debug_symbols?,
+          force:                      args.force?,
+          overwrite:                  args.overwrite?,
+          debug:                      args.debug?,
+          quiet:                      args.quiet?,
+          verbose:                    args.verbose?,
+        )
+
+        Upgrade.check_installed_dependents(
+          formulae_to_install,
+          flags:                      args.flags_only,
+          dry_run:                    args.dry_run?,
+          installed_on_request:       args.named.present?,
+          force_bottle:               args.force_bottle?,
+          build_from_source_formulae: args.build_from_source_formulae,
+          interactive:                args.interactive?,
+          keep_tmp:                   args.keep_tmp?,
+          debug_symbols:              args.debug_symbols?,
+          force:                      args.force?,
+          debug:                      args.debug?,
+          quiet:                      args.quiet?,
+          verbose:                    args.verbose?,
+        )
+
+        true
       end
-      puts formulae_upgrades.join("\n")
-    end
 
-    Upgrade.upgrade_formulae(
-      formulae_to_install,
-      flags:                      args.flags_only,
-      dry_run:                    args.dry_run?,
-      installed_on_request:       args.named.present?,
-      force_bottle:               args.force_bottle?,
-      build_from_source_formulae: args.build_from_source_formulae,
-      interactive:                args.interactive?,
-      keep_tmp:                   args.keep_tmp?,
-      force:                      args.force?,
-      debug:                      args.debug?,
-      quiet:                      args.quiet?,
-      verbose:                    args.verbose?,
-    )
-
-    Upgrade.check_installed_dependents(
-      formulae_to_install,
-      flags:                      args.flags_only,
-      dry_run:                    args.dry_run?,
-      installed_on_request:       args.named.present?,
-      force_bottle:               args.force_bottle?,
-      build_from_source_formulae: args.build_from_source_formulae,
-      interactive:                args.interactive?,
-      keep_tmp:                   args.keep_tmp?,
-      force:                      args.force?,
-      debug:                      args.debug?,
-      quiet:                      args.quiet?,
-      verbose:                    args.verbose?,
-    )
-
-    true
-  end
+      sig { params(casks: T::Array[Cask::Cask]).returns(T::Boolean) }
+      def upgrade_outdated_casks(casks)
+        return false if args.formula?
 
-  sig { params(casks: T::Array[Cask::Cask], args: CLI::Args).returns(T::Boolean) }
-  def upgrade_outdated_casks(casks, args:)
-    return false if args.formula?
-
-    Cask::Cmd::Upgrade.upgrade_casks(
-      *casks,
-      force:               args.force?,
-      greedy:              args.greedy?,
-      greedy_latest:       args.greedy_latest?,
-      greedy_auto_updates: args.greedy_auto_updates?,
-      dry_run:             args.dry_run?,
-      binaries:            args.binaries?,
-      quarantine:          args.quarantine?,
-      require_sha:         args.require_sha?,
-      skip_cask_deps:      args.skip_cask_deps?,
-      verbose:             args.verbose?,
-      args:                args,
-    )
+        Cask::Upgrade.upgrade_casks(
+          *casks,
+          force:               args.force?,
+          greedy:              args.greedy?,
+          greedy_latest:       args.greedy_latest?,
+          greedy_auto_updates: args.greedy_auto_updates?,
+          dry_run:             args.dry_run?,
+          binaries:            args.binaries?,
+          quarantine:          args.quarantine?,
+          require_sha:         args.require_sha?,
+          skip_cask_deps:      args.skip_cask_deps?,
+          verbose:             args.verbose?,
+          quiet:               args.quiet?,
+          args:,
+        )
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/cmd/uses.rb b/Library/Homebrew/cmd/uses.rb
index d5cf623617041..3bcb86a2e6de7 100644
--- a/Library/Homebrew/cmd/uses.rb
+++ b/Library/Homebrew/cmd/uses.rb
@@ -1,145 +1,176 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-# `brew uses foo bar` returns formulae that use both foo and bar
-# If you want the union, run the command twice and concatenate the results.
-# The intersection is harder to achieve with shell tools.
-
+require "abstract_command"
 require "formula"
-require "cli/parser"
 require "cask/caskroom"
 require "dependencies_helpers"
+require "ostruct"
 
 module Homebrew
-  extend T::Sig
-
-  extend DependenciesHelpers
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def uses_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Show formulae and casks that specify <formula> as a dependency; that is, show dependents
-        of <formula>. When given multiple formula arguments, show the intersection
-        of formulae that use <formula>. By default, `uses` shows all formulae and casks that
-        specify <formula> as a required or recommended dependency for their stable builds.
-      EOS
-      switch "--recursive",
-             description: "Resolve more than one level of dependencies."
-      switch "--installed",
-             description: "Only list formulae and casks that are currently installed."
-      switch "--all",
-             description: "List all formulae and casks whether installed or not.",
-             hidden:      true
-      switch "--include-build",
-             description: "Include all formulae that specify <formula> as `:build` type dependency."
-      switch "--include-test",
-             description: "Include all formulae that specify <formula> as `:test` type dependency."
-      switch "--include-optional",
-             description: "Include all formulae that specify <formula> as `:optional` type dependency."
-      switch "--skip-recommended",
-             description: "Skip all formulae that specify <formula> as `:recommended` type dependency."
-      switch "--formula", "--formulae",
-             description: "Include only formulae."
-      switch "--cask", "--casks",
-             description: "Include only casks."
-
-      conflicts "--formula", "--cask"
-      conflicts "--installed", "--all"
-
-      named_args :formula, min: 1
-    end
-  end
+  module Cmd
+    # `brew uses foo bar` returns formulae that use both foo and bar
+    # If you want the union, run the command twice and concatenate the results.
+    # The intersection is harder to achieve with shell tools.
+    class Uses < AbstractCommand
+      include DependenciesHelpers
+
+      cmd_args do
+        description <<~EOS
+          Show formulae and casks that specify <formula> as a dependency; that is, show dependents
+          of <formula>. When given multiple formula arguments, show the intersection
+          of formulae that use <formula>. By default, `uses` shows all formulae and casks that
+          specify <formula> as a required or recommended dependency for their stable builds.
+
+          *Note:* `--missing` and `--skip-recommended` have precedence over `--include-*`.
+        EOS
+        switch "--recursive",
+               description: "Resolve more than one level of dependencies."
+        switch "--installed",
+               description: "Only list formulae and casks that are currently installed."
+        switch "--missing",
+               description: "Only list formulae and casks that are not currently installed."
+        switch "--eval-all",
+               description: "Evaluate all available formulae and casks, whether installed or not, to show " \
+                            "their dependents."
+        switch "--include-build",
+               description: "Include formulae that specify <formula> as a `:build` dependency."
+        switch "--include-test",
+               description: "Include formulae that specify <formula> as a `:test` dependency."
+        switch "--include-optional",
+               description: "Include formulae that specify <formula> as an `:optional` dependency."
+        switch "--skip-recommended",
+               description: "Skip all formulae that specify <formula> as a `:recommended` dependency."
+        switch "--formula", "--formulae",
+               description: "Include only formulae."
+        switch "--cask", "--casks",
+               description: "Include only casks."
+
+        conflicts "--formula", "--cask"
+        conflicts "--installed", "--all"
+        conflicts "--missing", "--installed"
+
+        named_args :formula, min: 1
+      end
 
-  def uses
-    args = uses_args.parse
+      sig { override.void }
+      def run
+        Formulary.enable_factory_cache!
+
+        used_formulae_missing = false
+        used_formulae = begin
+          args.named.to_formulae
+        rescue FormulaUnavailableError => e
+          opoo e
+          used_formulae_missing = true
+          # If the formula doesn't exist: fake the needed formula object name.
+          # This is a legacy use of OpenStruct that should be refactored.
+          # rubocop:disable Style/OpenStructUse
+          args.named.map { |name| OpenStruct.new name:, full_name: name }
+          # rubocop:enable Style/OpenStructUse
+        end
 
-    Formulary.enable_factory_cache!
+        use_runtime_dependents = args.installed? &&
+                                 !used_formulae_missing &&
+                                 !args.include_build? &&
+                                 !args.include_test? &&
+                                 !args.include_optional? &&
+                                 !args.skip_recommended?
 
-    used_formulae_missing = false
-    used_formulae = begin
-      args.named.to_formulae
-    rescue FormulaUnavailableError => e
-      opoo e
-      used_formulae_missing = true
-      # If the formula doesn't exist: fake the needed formula object name.
-      args.named.map { |name| OpenStruct.new name: name, full_name: name }
-    end
+        uses = intersection_of_dependents(use_runtime_dependents, used_formulae)
 
-    use_runtime_dependents = args.installed? &&
-                             !used_formulae_missing &&
-                             !args.include_build? &&
-                             !args.include_test? &&
-                             !args.include_optional? &&
-                             !args.skip_recommended?
+        return if uses.empty?
 
-    uses = intersection_of_dependents(use_runtime_dependents, used_formulae, args: args)
+        puts Formatter.columns(uses.map(&:full_name).sort)
+        odie "Missing formulae should not have dependents!" if used_formulae_missing
+      end
 
-    return if uses.empty?
+      private
 
-    puts Formatter.columns(uses.map(&:full_name).sort)
-    odie "Missing formulae should not have dependents!" if used_formulae_missing
-  end
+      sig { params(use_runtime_dependents: T::Boolean, used_formulae: T::Array[Formula]).returns(T::Array[Formula]) }
+      def intersection_of_dependents(use_runtime_dependents, used_formulae)
+        recursive = args.recursive?
+        show_formulae_and_casks = !args.formula? && !args.cask?
+        includes, ignores = args_includes_ignores(args)
 
-  def intersection_of_dependents(use_runtime_dependents, used_formulae, args:)
-    recursive = args.recursive?
-    show_formulae_and_casks = !args.formula? && !args.cask?
-    includes, ignores = args_includes_ignores(args)
+        deps = []
+        if use_runtime_dependents
+          if show_formulae_and_casks || args.formula?
+            deps += used_formulae.map(&:runtime_installed_formula_dependents)
+                                 .reduce(&:&)
+                                 .select(&:any_version_installed?)
+          end
+          if show_formulae_and_casks || args.cask?
+            deps += select_used_dependents(
+              dependents(Cask::Caskroom.casks),
+              used_formulae, recursive, includes, ignores
+            )
+          end
 
-    # TODO: 3.6.0: odeprecate not specifying args.all?, require args.installed?
+          deps
+        else
+          all = args.eval_all?
 
-    deps = []
-    if use_runtime_dependents
-      if show_formulae_and_casks || args.formula?
-        deps += used_formulae.map(&:runtime_installed_formula_dependents)
-                             .reduce(&:&)
-                             .select(&:any_version_installed?)
-      end
-      if show_formulae_and_casks || args.cask?
-        deps += select_used_dependents(
-          dependents(Cask::Caskroom.casks),
-          used_formulae, recursive, includes, ignores
-        )
-      end
+          if !args.installed? && !(all || Homebrew::EnvConfig.eval_all?)
+            raise UsageError, "`brew uses` needs `--installed` or `--eval-all` passed or `HOMEBREW_EVAL_ALL` set!"
+          end
 
-      deps
-    else
-      if show_formulae_and_casks || args.formula?
-        deps += args.installed? ? Formula.installed : Formula.all
-      end
-      if show_formulae_and_casks || args.cask?
-        deps += args.installed? ? Cask::Caskroom.casks : Cask::Cask.all
-      end
+          if show_formulae_and_casks || args.formula?
+            deps += args.installed? ? Formula.installed : Formula.all(eval_all: args.eval_all?)
+          end
+          if show_formulae_and_casks || args.cask?
+            deps += args.installed? ? Cask::Caskroom.casks : Cask::Cask.all(eval_all: args.eval_all?)
+          end
 
-      select_used_dependents(dependents(deps), used_formulae, recursive, includes, ignores)
-    end
-  end
+          if args.missing?
+            deps.reject! do |dep|
+              case dep
+              when Formula
+                dep.any_version_installed?
+              when Cask::Cask
+                dep.installed?
+              end
+            end
+            ignores.delete(:satisfied?)
+          end
 
-  def select_used_dependents(dependents, used_formulae, recursive, includes, ignores)
-    dependents.select do |d|
-      deps = if recursive
-        recursive_includes(Dependency, d, includes, ignores)
-      else
-        reject_ignores(d.deps, ignores, includes)
+          select_used_dependents(dependents(deps), used_formulae, recursive, includes, ignores)
+        end
       end
 
-      used_formulae.all? do |ff|
-        deps.any? do |dep|
-          match = begin
-            dep.to_formula.full_name == ff.full_name if dep.name.include?("/")
-          rescue
-            nil
+      sig {
+        params(
+          dependents: T::Array[Formula], used_formulae: T::Array[Formula], recursive: T::Boolean,
+          includes: T::Array[Symbol], ignores: T::Array[Symbol]
+        ).returns(
+          T::Array[Formula],
+        )
+      }
+      def select_used_dependents(dependents, used_formulae, recursive, includes, ignores)
+        dependents.select do |d|
+          deps = if recursive
+            recursive_includes(Dependency, d, includes, ignores)
+          else
+            select_includes(d.deps, ignores, includes)
           end
-          next match unless match.nil?
 
-          dep.name == ff.name
+          used_formulae.all? do |ff|
+            deps.any? do |dep|
+              match = begin
+                dep.to_formula.full_name == ff.full_name if dep.name.include?("/")
+              rescue
+                nil
+              end
+              next match unless match.nil?
+
+              dep.name == ff.name
+            end
+          rescue FormulaUnavailableError
+            # Silently ignore this case as we don't care about things used in
+            # taps that aren't currently tapped.
+            next
+          end
         end
-      rescue FormulaUnavailableError
-        # Silently ignore this case as we don't care about things used in
-        # taps that aren't currently tapped.
-        next
       end
     end
   end
diff --git a/Library/Homebrew/cmd/vendor-install.rb b/Library/Homebrew/cmd/vendor-install.rb
new file mode 100644
index 0000000000000..5995dd7682e18
--- /dev/null
+++ b/Library/Homebrew/cmd/vendor-install.rb
@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "shell_command"
+
+module Homebrew
+  module Cmd
+    class VendorInstall < AbstractCommand
+      include ShellCommand
+
+      cmd_args do
+        description <<~EOS
+          Install Homebrew's portable Ruby.
+        EOS
+
+        named_args :target
+
+        hide_from_man_page!
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/cmd/vendor-install.sh b/Library/Homebrew/cmd/vendor-install.sh
index 90010adf0a8de..102a09b47ea10 100644
--- a/Library/Homebrew/cmd/vendor-install.sh
+++ b/Library/Homebrew/cmd/vendor-install.sh
@@ -1,62 +1,68 @@
-#:  @hide_from_man_page
-#:  * `vendor-install` [<target>]
-#:
-#:  Install Homebrew's portable Ruby.
+# Documentation defined in Library/Homebrew/cmd/vendor-install.rb
 
-# HOMEBREW_CURLRC, HOMEBREW_LIBRARY, HOMEBREW_STDERR is from the user environment
+# HOMEBREW_CURLRC, HOMEBREW_LIBRARY is from the user environment
 # HOMEBREW_CACHE, HOMEBREW_CURL, HOMEBREW_LINUX, HOMEBREW_LINUX_MINIMUM_GLIBC_VERSION, HOMEBREW_MACOS,
 # HOMEBREW_MACOS_VERSION_NUMERIC and HOMEBREW_PROCESSOR are set by brew.sh
 # shellcheck disable=SC2154
 source "${HOMEBREW_LIBRARY}/Homebrew/utils/lock.sh"
+source "${HOMEBREW_LIBRARY}/Homebrew/utils/ruby.sh"
 
 VENDOR_DIR="${HOMEBREW_LIBRARY}/Homebrew/vendor"
 
 # Built from https://github.com/Homebrew/homebrew-portable-ruby.
-if [[ -n "${HOMEBREW_MACOS}" ]]
-then
-  if [[ "${HOMEBREW_PHYSICAL_PROCESSOR}" == "x86_64" ]] ||
-     # Handle the case where /usr/local/bin/brew is run under arm64.
-     # It's a x86_64 installation there (we refuse to install arm64 binaries) so
-     # use a x86_64 Portable Ruby.
-     [[ "${HOMEBREW_PHYSICAL_PROCESSOR}" == "arm64" && "${HOMEBREW_PREFIX}" == "/usr/local" ]]
+set_ruby_variables() {
+  # Handle the case where /usr/local/bin/brew is run under arm64.
+  # It's a x86_64 installation there (we refuse to install arm64 binaries) so
+  # use a x86_64 Portable Ruby.
+  if [[ -n "${HOMEBREW_MACOS}" && "${VENDOR_PHYSICAL_PROCESSOR}" == "arm64" && "${HOMEBREW_PREFIX}" == "/usr/local" ]]
   then
-    ruby_FILENAME="portable-ruby-2.6.8_1.el_capitan.bottle.tar.gz"
-    ruby_SHA="1f50bf80583bd436c9542d4fa5ad47df0ef0f0bea22ae710c4f04c42d7560bca"
-  elif [[ "${HOMEBREW_PHYSICAL_PROCESSOR}" == "arm64" ]]
-  then
-    ruby_FILENAME="portable-ruby-2.6.8_1.arm64_big_sur.bottle.tar.gz"
-    ruby_SHA="cf9137b1da5568d4949f71161a69b101f60ddb765e94d2b423c9801b67a1cb43"
+    ruby_PROCESSOR="x86_64"
+    ruby_OS="darwin"
+  else
+    ruby_PROCESSOR="${VENDOR_PHYSICAL_PROCESSOR}"
+    if [[ -n "${HOMEBREW_MACOS}" ]]
+    then
+      ruby_OS="darwin"
+    elif [[ -n "${HOMEBREW_LINUX}" ]]
+    then
+      ruby_OS="linux"
+    fi
   fi
-elif [[ -n "${HOMEBREW_LINUX}" ]]
-then
-  case "${HOMEBREW_PROCESSOR}" in
-    x86_64)
-      ruby_FILENAME="portable-ruby-2.6.8_1.x86_64_linux.bottle.tar.gz"
-      ruby_SHA="fc45ee6eddf4c7a17f4373dde7b1bc8a58255ea61e6847d3bf895225b28d072a"
-      ;;
-    *) ;;
-  esac
-fi
-
-# Dynamic variables can't be detected by shellcheck
-# shellcheck disable=SC2034
-if [[ -n "${ruby_SHA}" && -n "${ruby_FILENAME}" ]]
-then
-  ruby_URLs=()
-  if [[ -n "${HOMEBREW_ARTIFACT_DOMAIN}" ]]
+
+  ruby_PLATFORMINFO="${HOMEBREW_LIBRARY}/Homebrew/vendor/portable-ruby-${ruby_PROCESSOR}-${ruby_OS}"
+  if [[ -f "${ruby_PLATFORMINFO}" && -r "${ruby_PLATFORMINFO}" ]]
   then
-    ruby_URLs+=("${HOMEBREW_ARTIFACT_DOMAIN}/v2/homebrew/portable-ruby/portable-ruby/blobs/sha256:${ruby_SHA}")
+    # ruby_TAG and ruby_SHA will be set via the sourced file if it exists
+    # shellcheck disable=SC1090
+    source "${ruby_PLATFORMINFO}"
   fi
-  if [[ -n "${HOMEBREW_BOTTLE_DOMAIN}" ]]
+
+  # Dynamic variables can't be detected by shellcheck
+  # shellcheck disable=SC2034
+  if [[ -n "${ruby_TAG}" && -n "${ruby_SHA}" ]]
   then
-    ruby_URLs+=("${HOMEBREW_BOTTLE_DOMAIN}/bottles-portable-ruby/${ruby_FILENAME}")
+    ruby_FILENAME="portable-ruby-${HOMEBREW_PORTABLE_RUBY_VERSION}.${ruby_TAG}.bottle.tar.gz"
+    ruby_URLs=()
+    if [[ -n "${HOMEBREW_ARTIFACT_DOMAIN}" ]]
+    then
+      ruby_URLs+=("${HOMEBREW_ARTIFACT_DOMAIN}/v2/homebrew/portable-ruby/portable-ruby/blobs/sha256:${ruby_SHA}")
+      if [[ -n "${HOMEBREW_ARTIFACT_DOMAIN_NO_FALLBACK}" ]]
+      then
+        ruby_URL="${ruby_URLs[0]}"
+        return
+      fi
+    fi
+    if [[ -n "${HOMEBREW_BOTTLE_DOMAIN}" ]]
+    then
+      ruby_URLs+=("${HOMEBREW_BOTTLE_DOMAIN}/bottles-portable-ruby/${ruby_FILENAME}")
+    fi
+    ruby_URLs+=(
+      "https://ghcr.io/v2/homebrew/portable-ruby/portable-ruby/blobs/sha256:${ruby_SHA}"
+      "https://github.com/Homebrew/homebrew-portable-ruby/releases/download/${HOMEBREW_PORTABLE_RUBY_VERSION}/${ruby_FILENAME}"
+    )
+    ruby_URL="${ruby_URLs[0]}"
   fi
-  ruby_URLs+=(
-    "https://ghcr.io/v2/homebrew/portable-ruby/portable-ruby/blobs/sha256:${ruby_SHA}"
-    "https://github.com/Homebrew/homebrew-portable-ruby/releases/download/2.6.8_1/${ruby_FILENAME}"
-  )
-  ruby_URL="${ruby_URLs[0]}"
-fi
+}
 
 check_linux_glibc_version() {
   if [[ -z "${HOMEBREW_LINUX}" || -z "${HOMEBREW_LINUX_MINIMUM_GLIBC_VERSION}" ]]
@@ -85,16 +91,6 @@ check_linux_glibc_version() {
   fi
 }
 
-# Execute the specified command, and suppress stderr unless HOMEBREW_STDERR is set.
-quiet_stderr() {
-  if [[ -z "${HOMEBREW_STDERR}" ]]
-  then
-    command "$@" 2>/dev/null
-  else
-    command "$@"
-  fi
-}
-
 fetch() {
   local -a curl_args
   local url
@@ -111,6 +107,9 @@ fetch() {
   if [[ -z "${HOMEBREW_CURLRC}" ]]
   then
     curl_args[${#curl_args[*]}]="-q"
+  elif [[ "${HOMEBREW_CURLRC}" == /* ]]
+  then
+    curl_args+=("-q" "--config" "${HOMEBREW_CURLRC}")
   fi
 
   # Authorization is needed for GitHub Packages but harmless on GitHub Releases
@@ -149,7 +148,7 @@ fetch() {
       first_try=''
       if [[ -f "${temporary_path}" ]]
       then
-        # HOMEBREW_CURL is set by brew.sh (and isn't mispelt here)
+        # HOMEBREW_CURL is set by brew.sh (and isn't misspelt here)
         # shellcheck disable=SC2153
         "${HOMEBREW_CURL}" "${curl_args[@]}" -C - "${url}" -o "${temporary_path}"
         if [[ $? -eq 33 ]]
@@ -186,21 +185,33 @@ EOS
   if [[ -x "/usr/bin/shasum" ]]
   then
     sha="$(/usr/bin/shasum -a 256 "${CACHED_LOCATION}" | cut -d' ' -f1)"
-  elif [[ -x "$(type -P sha256sum)" ]]
+  fi
+
+  if [[ -z "${sha}" && -x "$(type -P sha256sum)" ]]
   then
     sha="$(sha256sum "${CACHED_LOCATION}" | cut -d' ' -f1)"
-  elif [[ -x "$(type -P ruby)" ]]
+  fi
+
+  if [[ -z "${sha}" ]]
   then
-    sha="$(
-      ruby <<EOSCRIPT
+    if [[ -x "$(type -P ruby)" ]]
+    then
+      sha="$(
+        ruby <<EOSCRIPT
 require 'digest/sha2'
 digest = Digest::SHA256.new
 File.open('${CACHED_LOCATION}', 'rb') { |f| digest.update(f.read) }
 puts digest.hexdigest
 EOSCRIPT
-    )"
-  else
-    odie "Cannot verify checksum ('shasum' or 'sha256sum' not found)!"
+      )"
+    else
+      odie "Cannot verify checksum ('shasum', 'sha256sum' and 'ruby' not found)!"
+    fi
+  fi
+
+  if [[ -z "${sha}" ]]
+  then
+    odie "Could not get checksum ('shasum', 'sha256sum' and 'ruby' produced no output)!"
   fi
 
   if [[ "${sha}" != "${VENDOR_SHA}" ]]
@@ -238,9 +249,16 @@ install() {
   safe_cd "${VENDOR_DIR}"
   [[ -n "${HOMEBREW_QUIET}" ]] || ohai "Pouring ${VENDOR_FILENAME}" >&2
   tar "${tar_args}" "${CACHED_LOCATION}"
+
+  if [[ "${VENDOR_PROCESSOR}" != "${HOMEBREW_PROCESSOR}" ]] ||
+     [[ "${VENDOR_PHYSICAL_PROCESSOR}" != "${HOMEBREW_PHYSICAL_PROCESSOR}" ]]
+  then
+    return 0
+  fi
+
   safe_cd "${VENDOR_DIR}/portable-${VENDOR_NAME}"
 
-  if quiet_stderr "./${VENDOR_VERSION}/bin/${VENDOR_NAME}" --version >/dev/null
+  if "./${VENDOR_VERSION}/bin/${VENDOR_NAME}" --version >/dev/null
   then
     ln -sfn "${VENDOR_VERSION}" current
     if [[ -d "${VENDOR_VERSION}.reinstall" ]]
@@ -264,6 +282,9 @@ homebrew-vendor-install() {
   local url_var
   local sha_var
 
+  unset VENDOR_PHYSICAL_PROCESSOR
+  unset VENDOR_PROCESSOR
+
   for option in "$@"
   do
     case "${option}" in
@@ -281,14 +302,41 @@ homebrew-vendor-install() {
         [[ "${option}" == *d* ]] && HOMEBREW_DEBUG=1
         ;;
       *)
-        [[ -n "${VENDOR_NAME}" ]] && odie "This command does not take multiple vendor targets!"
-        VENDOR_NAME="${option}"
+        if [[ -n "${VENDOR_NAME}" ]]
+        then
+          if [[ -n "${HOMEBREW_DEVELOPER}" ]]
+          then
+            if [[ -n "${PROCESSOR_TARGET}" ]]
+            then
+              odie "This command does not take more than vendor and processor targets!"
+            else
+              VENDOR_PHYSICAL_PROCESSOR="${option}"
+              VENDOR_PROCESSOR="${option}"
+            fi
+          else
+            odie "This command does not take multiple vendor targets!"
+          fi
+        else
+          VENDOR_NAME="${option}"
+        fi
         ;;
     esac
   done
 
   [[ -z "${VENDOR_NAME}" ]] && odie "This command requires a vendor target!"
   [[ -n "${HOMEBREW_DEBUG}" ]] && set -x
+
+  if [[ -z "${VENDOR_PHYSICAL_PROCESSOR}" ]]
+  then
+    VENDOR_PHYSICAL_PROCESSOR="${HOMEBREW_PHYSICAL_PROCESSOR}"
+  fi
+
+  if [[ -z "${VENDOR_PROCESSOR}" ]]
+  then
+    VENDOR_PROCESSOR="${HOMEBREW_PROCESSOR}"
+  fi
+
+  set_ruby_variables
   check_linux_glibc_version
 
   filename_var="${VENDOR_NAME}_FILENAME"
@@ -311,7 +359,7 @@ homebrew-vendor-install() {
 
   CACHED_LOCATION="${HOMEBREW_CACHE}/${VENDOR_FILENAME}"
 
-  lock "vendor-install-${VENDOR_NAME}"
+  lock "vendor-install ${VENDOR_NAME}"
   fetch
   install
 }
diff --git a/Library/Homebrew/command_path.sh b/Library/Homebrew/command_path.sh
new file mode 100644
index 0000000000000..362b654abe255
--- /dev/null
+++ b/Library/Homebrew/command_path.sh
@@ -0,0 +1,47 @@
+# does the quickest output of brew command possible for the basic cases of an
+# official Bash or Ruby normal or dev-cmd command.
+# HOMEBREW_LIBRARY is set by brew.sh
+# shellcheck disable=SC2154
+homebrew-command-path() {
+  case "$1" in
+    # check we actually have command and not e.g. commandsomething
+    command) ;;
+    command*) return 1 ;;
+    *) ;;
+  esac
+
+  local first_command found_command
+  for arg in "$@"
+  do
+    if [[ -z "${first_command}" && "${arg}" == "command" ]]
+    then
+      first_command=1
+      continue
+    elif [[ -f "${HOMEBREW_LIBRARY}/Homebrew/cmd/${arg}.sh" ]]
+    then
+      echo "${HOMEBREW_LIBRARY}/Homebrew/cmd/${arg}.sh"
+      found_command=1
+    elif [[ -f "${HOMEBREW_LIBRARY}/Homebrew/dev-cmd/${arg}.sh" ]]
+    then
+      echo "${HOMEBREW_LIBRARY}/Homebrew/dev-cmd/${arg}.sh"
+      found_command=1
+    elif [[ -f "${HOMEBREW_LIBRARY}/Homebrew/cmd/${arg}.rb" ]]
+    then
+      echo "${HOMEBREW_LIBRARY}/Homebrew/cmd/${arg}.rb"
+      found_command=1
+    elif [[ -f "${HOMEBREW_LIBRARY}/Homebrew/dev-cmd/${arg}.rb" ]]
+    then
+      echo "${HOMEBREW_LIBRARY}/Homebrew/dev-cmd/${arg}.rb"
+      found_command=1
+    else
+      return 1
+    fi
+  done
+
+  if [[ -n "${found_command}" ]]
+  then
+    return 0
+  else
+    return 1
+  fi
+}
diff --git a/Library/Homebrew/commands.rb b/Library/Homebrew/commands.rb
index 383c5cb768481..bff04823efdfa 100644
--- a/Library/Homebrew/commands.rb
+++ b/Library/Homebrew/commands.rb
@@ -1,84 +1,72 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "completions"
-
 # Helper functions for commands.
-#
-# @api private
 module Commands
-  module_function
-
   HOMEBREW_CMD_PATH = (HOMEBREW_LIBRARY_PATH/"cmd").freeze
   HOMEBREW_DEV_CMD_PATH = (HOMEBREW_LIBRARY_PATH/"dev-cmd").freeze
+  # If you are going to change anything in below hash,
+  # be sure to also update appropriate case statement in brew.sh
   HOMEBREW_INTERNAL_COMMAND_ALIASES = {
-    "ls"          => "list",
-    "homepage"    => "home",
-    "-S"          => "search",
-    "up"          => "update",
-    "ln"          => "link",
-    "instal"      => "install", # gem does the same
-    "uninstal"    => "uninstall",
-    "rm"          => "uninstall",
-    "remove"      => "uninstall",
-    "abv"         => "info",
-    "dr"          => "doctor",
-    "--repo"      => "--repository",
-    "environment" => "--env",
-    "--config"    => "config",
-    "-v"          => "--version",
-    "lc"          => "livecheck",
-    "tc"          => "typecheck",
+    "ls"           => "list",
+    "homepage"     => "home",
+    "-S"           => "search",
+    "up"           => "update",
+    "ln"           => "link",
+    "instal"       => "install", # gem does the same
+    "uninstal"     => "uninstall",
+    "post_install" => "postinstall",
+    "rm"           => "uninstall",
+    "remove"       => "uninstall",
+    "abv"          => "info",
+    "dr"           => "doctor",
+    "--repo"       => "--repository",
+    "environment"  => "--env",
+    "--config"     => "config",
+    "-v"           => "--version",
+    "lc"           => "livecheck",
+    "tc"           => "typecheck",
   }.freeze
+  # This pattern is used to split descriptions at full stops. We only consider a
+  # dot as a full stop if it is either followed by a whitespace or at the end of
+  # the description. In this way we can prevent cutting off a sentence in the
+  # middle due to dots in URLs or paths.
+  DESCRIPTION_SPLITTING_PATTERN = /\.(?>\s|$)/
 
-  INSTALL_FROM_API_FORBIDDEN_COMMANDS = %w[
-    audit
-    bottle
-    bump-cask-pr
-    bump-formula-pr
-    bump-revision
-    bump-unversioned-casks
-    cat
-    create
-    edit
-    extract
-    formula
-    livecheck
-    pr-pull
-    pr-upload
-    test
-    update-python-resources
-  ].freeze
-
-  def valid_internal_cmd?(cmd)
+  def self.valid_internal_cmd?(cmd)
     require?(HOMEBREW_CMD_PATH/cmd)
   end
 
-  def valid_internal_dev_cmd?(cmd)
+  def self.valid_internal_dev_cmd?(cmd)
     require?(HOMEBREW_DEV_CMD_PATH/cmd)
   end
 
-  def method_name(cmd)
+  def self.valid_ruby_cmd?(cmd)
+    (valid_internal_cmd?(cmd) || valid_internal_dev_cmd?(cmd) || external_ruby_v2_cmd_path(cmd)) &&
+      Homebrew::AbstractCommand.command(cmd)&.ruby_cmd?
+  end
+
+  def self.method_name(cmd)
     cmd.to_s
        .tr("-", "_")
        .downcase
        .to_sym
   end
 
-  def args_method_name(cmd_path)
+  def self.args_method_name(cmd_path)
     cmd_path_basename = basename_without_extension(cmd_path)
     cmd_method_prefix = method_name(cmd_path_basename)
-    "#{cmd_method_prefix}_args".to_sym
+    :"#{cmd_method_prefix}_args"
   end
 
-  def internal_cmd_path(cmd)
+  def self.internal_cmd_path(cmd)
     [
       HOMEBREW_CMD_PATH/"#{cmd}.rb",
       HOMEBREW_CMD_PATH/"#{cmd}.sh",
     ].find(&:exist?)
   end
 
-  def internal_dev_cmd_path(cmd)
+  def self.internal_dev_cmd_path(cmd)
     [
       HOMEBREW_DEV_CMD_PATH/"#{cmd}.rb",
       HOMEBREW_DEV_CMD_PATH/"#{cmd}.sh",
@@ -86,21 +74,21 @@ def internal_dev_cmd_path(cmd)
   end
 
   # Ruby commands which can be `require`d without being run.
-  def external_ruby_v2_cmd_path(cmd)
-    path = which("#{cmd}.rb", Tap.cmd_directories)
+  def self.external_ruby_v2_cmd_path(cmd)
+    path = which("#{cmd}.rb", tap_cmd_directories)
     path if require?(path)
   end
 
   # Ruby commands which are run by being `require`d.
-  def external_ruby_cmd_path(cmd)
-    which("brew-#{cmd}.rb", PATH.new(ENV.fetch("PATH")).append(Tap.cmd_directories))
+  def self.external_ruby_cmd_path(cmd)
+    which("brew-#{cmd}.rb", PATH.new(ENV.fetch("PATH")).append(tap_cmd_directories))
   end
 
-  def external_cmd_path(cmd)
-    which("brew-#{cmd}", PATH.new(ENV.fetch("PATH")).append(Tap.cmd_directories))
+  def self.external_cmd_path(cmd)
+    which("brew-#{cmd}", PATH.new(ENV.fetch("PATH")).append(tap_cmd_directories))
   end
 
-  def path(cmd)
+  def self.path(cmd)
     internal_cmd = HOMEBREW_INTERNAL_COMMAND_ALIASES.fetch(cmd, cmd)
     path ||= internal_cmd_path(internal_cmd)
     path ||= internal_dev_cmd_path(internal_cmd)
@@ -110,7 +98,7 @@ def path(cmd)
     path
   end
 
-  def commands(external: true, aliases: false)
+  def self.commands(external: true, aliases: false)
     cmds = internal_commands
     cmds += internal_developer_commands
     cmds += external_commands if external
@@ -118,59 +106,70 @@ def commands(external: true, aliases: false)
     cmds.sort
   end
 
-  def internal_commands_paths
+  # An array of all tap cmd directory {Pathname}s.
+  sig { returns(T::Array[Pathname]) }
+  def self.tap_cmd_directories
+    Pathname.glob HOMEBREW_TAP_DIRECTORY/"*/*/cmd"
+  end
+
+  def self.internal_commands_paths
     find_commands HOMEBREW_CMD_PATH
   end
 
-  def internal_developer_commands_paths
+  def self.internal_developer_commands_paths
     find_commands HOMEBREW_DEV_CMD_PATH
   end
 
-  def official_external_commands_paths(quiet:)
+  def self.official_external_commands_paths(quiet:)
+    require "tap"
+
     OFFICIAL_CMD_TAPS.flat_map do |tap_name, cmds|
       tap = Tap.fetch(tap_name)
-      tap.install(quiet: quiet) unless tap.installed?
+      tap.install(quiet:) unless tap.installed?
       cmds.map(&method(:external_ruby_v2_cmd_path)).compact
     end
   end
 
-  def internal_commands
+  def self.internal_commands
     find_internal_commands(HOMEBREW_CMD_PATH).map(&:to_s)
   end
 
-  def internal_developer_commands
+  def self.internal_developer_commands
     find_internal_commands(HOMEBREW_DEV_CMD_PATH).map(&:to_s)
   end
 
-  def internal_commands_aliases
+  def self.internal_commands_aliases
     HOMEBREW_INTERNAL_COMMAND_ALIASES.keys
   end
 
-  def find_internal_commands(path)
+  def self.find_internal_commands(path)
     find_commands(path).map(&:basename)
-                       .map(&method(:basename_without_extension))
+                       .map { basename_without_extension(_1) }
+                       .uniq
   end
 
-  def external_commands
-    Tap.cmd_directories.flat_map do |path|
+  def self.external_commands
+    tap_cmd_directories.flat_map do |path|
       find_commands(path).select(&:executable?)
-                         .map(&method(:basename_without_extension))
+                         .map { basename_without_extension(_1) }
                          .map { |p| p.to_s.delete_prefix("brew-").strip }
     end.map(&:to_s)
        .sort
   end
 
-  def basename_without_extension(path)
+  def self.basename_without_extension(path)
     path.basename(path.extname)
   end
 
-  def find_commands(path)
+  def self.find_commands(path)
     Pathname.glob("#{path}/*")
             .select(&:file?)
             .sort
   end
 
-  def rebuild_internal_commands_completion_list
+  def self.rebuild_internal_commands_completion_list
+    require "completions"
+
     cmds = internal_commands + internal_developer_commands + internal_commands_aliases
     cmds.reject! { |cmd| Homebrew::Completions::COMPLETIONS_EXCLUSION_LIST.include? cmd }
 
@@ -178,7 +177,9 @@ def rebuild_internal_commands_completion_list
     file.atomic_write("#{cmds.sort.join("\n")}\n")
   end
 
-  def rebuild_commands_completion_list
+  def self.rebuild_commands_completion_list
+    require "completions"
+
     # Ensure that the cache exists so we can build the commands list
     HOMEBREW_CACHE.mkpath
 
@@ -190,16 +191,19 @@ def rebuild_commands_completion_list
     external_commands_file.atomic_write("#{external_commands.sort.join("\n")}\n")
   end
 
-  def command_options(command)
+  sig { params(command: String).returns(T.nilable(T::Array[[String, String]])) }
+  def self.command_options(command)
+    return if command == "help"
+
     path = self.path(command)
     return if path.blank?
 
     if (cmd_parser = Homebrew::CLI::Parser.from_cmd_path(path))
-      cmd_parser.processed_options.map do |short, long, _, desc, hidden|
+      cmd_parser.processed_options.filter_map do |short, long, desc, hidden|
         next if hidden
 
         [long || short, desc]
-      end.compact
+      end
     else
       options = []
       comment_lines = path.read.lines.grep(/^#:/)
@@ -207,21 +211,20 @@ def command_options(command)
 
       # skip the comment's initial usage summary lines
       comment_lines.slice(2..-1).each do |line|
-        if / (?<option>-[-\w]+) +(?<desc>.*)$/ =~ line
-          options << [option, desc]
-        end
+        match_data = / (?<option>-[-\w]+) +(?<desc>.*)$/.match(line)
+        options << [match_data[:option], match_data[:desc]] if match_data
       end
       options
     end
   end
 
-  def command_description(command, short: false)
+  def self.command_description(command, short: false)
     path = self.path(command)
     return if path.blank?
 
     if (cmd_parser = Homebrew::CLI::Parser.from_cmd_path(path))
       if short
-        cmd_parser.description.split(".").first
+        cmd_parser.description&.split(DESCRIPTION_SPLITTING_PATTERN)&.first
       else
         cmd_parser.description
       end
@@ -230,16 +233,18 @@ def command_description(command, short: false)
 
       # skip the comment's initial usage summary lines
       comment_lines.slice(2..-1)&.each do |line|
-        if /^#:  (?<desc>\w.*+)$/ =~ line
-          return desc.split(".").first if short
+        match_data = /^#:  (?<desc>\w.*+)$/.match(line)
+        next unless match_data
+
+        desc = match_data[:desc]
+        return T.must(desc).split(DESCRIPTION_SPLITTING_PATTERN).first if short
 
-          return desc
-        end
+        return desc
       end
     end
   end
 
-  def named_args_type(command)
+  def self.named_args_type(command)
     path = self.path(command)
     return if path.blank?
 
@@ -250,7 +255,7 @@ def named_args_type(command)
   end
 
   # Returns the conflicts of a given `option` for `command`.
-  def option_conflicts(command, option)
+  def self.option_conflicts(command, option)
     path = self.path(command)
     return if path.blank?
 
diff --git a/Library/Homebrew/compat/cask.rb b/Library/Homebrew/compat/cask.rb
deleted file mode 100644
index aa1521766e259..0000000000000
--- a/Library/Homebrew/compat/cask.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module Cask
-  class Cask
-    extend Enumerable
-
-    def self.each(&block)
-      odisabled "`Enumerable` methods on `Cask::Cask`",
-                "`Cask::Cask.all` (but avoid looping over all casks, it's slow and insecure)"
-
-      return to_enum unless block
-
-      Tap.flat_map(&:cask_files).each do |f|
-        yield CaskLoader::FromTapPathLoader.new(f).load(config: nil)
-      rescue CaskUnreadableError => e
-        opoo e.message
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/compat/early.rb b/Library/Homebrew/compat/early.rb
deleted file mode 100644
index b4806eee619c0..0000000000000
--- a/Library/Homebrew/compat/early.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
diff --git a/Library/Homebrew/compat/formula.rb b/Library/Homebrew/compat/formula.rb
deleted file mode 100644
index e9a7e7096ce16..0000000000000
--- a/Library/Homebrew/compat/formula.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-class Formula
-  extend Enumerable
-
-  def self.each(&_block)
-    odisabled "`Enumerable` methods on `Formula`",
-              "`Formula.all` (but avoid looping over all formulae, it's slow and insecure)"
-
-    files.each do |file|
-      yield Formulary.factory(file)
-    rescue FormulaUnavailableError, FormulaUnreadableError => e
-      # Don't let one broken formula break commands. But do complain.
-      onoe "Failed to import: #{file}"
-      $stderr.puts e
-      next
-    end
-  end
-end
diff --git a/Library/Homebrew/compat/late.rb b/Library/Homebrew/compat/late.rb
deleted file mode 100644
index 6e36cebe11415..0000000000000
--- a/Library/Homebrew/compat/late.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "compat/formula"
-require "compat/cask"
diff --git a/Library/Homebrew/compilers.rb b/Library/Homebrew/compilers.rb
index 0c61affc258ec..7097260fe47bc 100644
--- a/Library/Homebrew/compilers.rb
+++ b/Library/Homebrew/compilers.rb
@@ -1,10 +1,9 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-# @private
 module CompilerConstants
-  GNU_GCC_VERSIONS = %w[4.9 5 6 7 8 9 10 11 12].freeze
-  GNU_GCC_REGEXP = /^gcc-(4\.9|[5-9]|10|11|12)$/.freeze
+  GNU_GCC_VERSIONS = %w[7 8 9 10 11 12 13 14].freeze
+  GNU_GCC_REGEXP = /^gcc-(#{GNU_GCC_VERSIONS.join("|")})$/
   COMPILER_SYMBOL_MAP = {
     "gcc"        => :gcc,
     "clang"      => :clang,
@@ -16,8 +15,6 @@ module CompilerConstants
 end
 
 # Class for checking compiler compatibility for a formula.
-#
-# @api private
 class CompilerFailure
   attr_reader :type
 
@@ -54,7 +51,7 @@ def self.create(spec, &block)
       version = 9999
       exact_major_match = false
     end
-    new(type, version, exact_major_match: exact_major_match, &block)
+    new(type, version, exact_major_match:, &block)
   end
 
   def fails_with?(compiler)
@@ -68,6 +65,7 @@ def fails_with?(compiler)
     type == compiler.type && version_matched
   end
 
+  sig { returns(String) }
   def inspect
     "#<#{self.class.name}: #{type} #{version}>"
   end
@@ -97,10 +95,7 @@ def gcc_major(version)
 end
 
 # Class for selecting a compiler for a formula.
-#
-# @api private
 class CompilerSelector
-  extend T::Sig
   include CompilerConstants
 
   Compiler = Struct.new(:type, :name, :version)
@@ -172,9 +167,9 @@ def fails_with?(compiler)
   def compiler_version(name)
     case name.to_s
     when "gcc", GNU_GCC_REGEXP
-      versions.non_apple_gcc_version(name.to_s)
+      versions.gcc_version(name.to_s)
     else
-      versions.send("#{name}_build_version")
+      versions.send(:"#{name}_build_version")
     end
   end
 end
diff --git a/Library/Homebrew/completions.rb b/Library/Homebrew/completions.rb
index 232b1cd22b1eb..7b8a8d3f42aae 100644
--- a/Library/Homebrew/completions.rb
+++ b/Library/Homebrew/completions.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "utils/link"
@@ -7,15 +7,17 @@
 
 module Homebrew
   # Helper functions for generating shell completions.
-  #
-  # @api private
   module Completions
-    extend T::Sig
+    Variables = Struct.new(
+      :aliases,
+      :builtin_command_descriptions,
+      :completion_functions,
+      :function_mappings,
+      keyword_init: true,
+    )
 
-    module_function
-
-    COMPLETIONS_DIR = (HOMEBREW_REPOSITORY/"completions").freeze
-    TEMPLATE_DIR = (HOMEBREW_LIBRARY_PATH/"completions").freeze
+    COMPLETIONS_DIR = T.let((HOMEBREW_REPOSITORY/"completions").freeze, Pathname)
+    TEMPLATE_DIR = T.let((HOMEBREW_LIBRARY_PATH/"completions").freeze, Pathname)
 
     SHELLS = %w[bash fish zsh].freeze
     COMPLETIONS_EXCLUSION_LIST = %w[
@@ -24,7 +26,7 @@ module Completions
       update-report
     ].freeze
 
-    BASH_NAMED_ARGS_COMPLETION_FUNCTION_MAPPING = {
+    BASH_NAMED_ARGS_COMPLETION_FUNCTION_MAPPING = T.let({
       formula:           "__brew_complete_formulae",
       installed_formula: "__brew_complete_installed_formulae",
       outdated_formula:  "__brew_complete_outdated_formulae",
@@ -34,11 +36,11 @@ module Completions
       tap:               "__brew_complete_tapped",
       installed_tap:     "__brew_complete_tapped",
       command:           "__brew_complete_commands",
-      diagnostic_check:  '__brewcomp "$(brew doctor --list-checks)"',
+      diagnostic_check:  '__brewcomp "${__HOMEBREW_DOCTOR_CHECKS=$(brew doctor --list-checks)}"',
       file:              "__brew_complete_files",
-    }.freeze
+    }.freeze, T::Hash[Symbol, String])
 
-    ZSH_NAMED_ARGS_COMPLETION_FUNCTION_MAPPING = {
+    ZSH_NAMED_ARGS_COMPLETION_FUNCTION_MAPPING = T.let({
       formula:           "__brew_formulae",
       installed_formula: "__brew_installed_formulae",
       outdated_formula:  "__brew_outdated_formulae",
@@ -50,9 +52,9 @@ module Completions
       command:           "__brew_commands",
       diagnostic_check:  "__brew_diagnostic_checks",
       file:              "__brew_formulae_or_ruby_files",
-    }.freeze
+    }.freeze, T::Hash[Symbol, String])
 
-    FISH_NAMED_ARGS_COMPLETION_FUNCTION_MAPPING = {
+    FISH_NAMED_ARGS_COMPLETION_FUNCTION_MAPPING = T.let({
       formula:           "__fish_brew_suggest_formulae_all",
       installed_formula: "__fish_brew_suggest_formulae_installed",
       outdated_formula:  "__fish_brew_suggest_formulae_outdated",
@@ -63,20 +65,20 @@ module Completions
       installed_tap:     "__fish_brew_suggest_taps_installed",
       command:           "__fish_brew_suggest_commands",
       diagnostic_check:  "__fish_brew_suggest_diagnostic_checks",
-    }.freeze
+    }.freeze, T::Hash[Symbol, String])
 
     sig { void }
-    def link!
+    def self.link!
       Settings.write :linkcompletions, true
-      Tap.each do |tap|
+      Tap.installed.each do |tap|
         Utils::Link.link_completions tap.path, "brew completions link"
       end
     end
 
     sig { void }
-    def unlink!
+    def self.unlink!
       Settings.write :linkcompletions, false
-      Tap.each do |tap|
+      Tap.installed.each do |tap|
         next if tap.official?
 
         Utils::Link.unlink_completions tap.path
@@ -84,13 +86,13 @@ def unlink!
     end
 
     sig { returns(T::Boolean) }
-    def link_completions?
+    def self.link_completions?
       Settings.read(:linkcompletions) == "true"
     end
 
     sig { returns(T::Boolean) }
-    def completions_to_link?
-      Tap.each do |tap|
+    def self.completions_to_link?
+      Tap.installed.each do |tap|
         next if tap.official?
 
         SHELLS.each do |shell|
@@ -102,7 +104,7 @@ def completions_to_link?
     end
 
     sig { void }
-    def show_completions_message_if_needed
+    def self.show_completions_message_if_needed
       return if Settings.read(:completionsmessageshown) == "true"
       return unless completions_to_link?
 
@@ -117,7 +119,7 @@ def show_completions_message_if_needed
     end
 
     sig { void }
-    def update_shell_completions!
+    def self.update_shell_completions!
       commands = Commands.commands(external: false, aliases: true).sort
 
       puts "Writing completions to #{COMPLETIONS_DIR}"
@@ -128,12 +130,12 @@ def update_shell_completions!
     end
 
     sig { params(command: String).returns(T::Boolean) }
-    def command_gets_completions?(command)
+    def self.command_gets_completions?(command)
       command_options(command).any?
     end
 
     sig { params(description: String, fish: T::Boolean).returns(String) }
-    def format_description(description, fish: false)
+    def self.format_description(description, fish: false)
       description = if fish
         description.gsub("'", "\\\\'")
       else
@@ -143,7 +145,7 @@ def format_description(description, fish: false)
     end
 
     sig { params(command: String).returns(T::Hash[String, String]) }
-    def command_options(command)
+    def self.command_options(command)
       options = {}
       Commands.command_options(command)&.each do |option|
         next if option.blank?
@@ -151,7 +153,7 @@ def command_options(command)
         name = option.first
         desc = option.second
         if name.start_with? "--[no-]"
-          options[name.remove("[no-]")] = desc
+          options[name.gsub("[no-]", "")] = desc
           options[name.sub("[no-]", "no-")] = desc
         else
           options[name] = desc
@@ -161,7 +163,7 @@ def command_options(command)
     end
 
     sig { params(command: String).returns(T.nilable(String)) }
-    def generate_bash_subcommand_completion(command)
+    def self.generate_bash_subcommand_completion(command)
       return unless command_gets_completions? command
 
       named_completion_string = ""
@@ -187,31 +189,30 @@ def generate_bash_subcommand_completion(command)
               "
               return
               ;;
-            *)
+            *) ;;
           esac#{named_completion_string}
         }
       COMPLETION
     end
 
     sig { params(commands: T::Array[String]).returns(String) }
-    def generate_bash_completion_file(commands)
-      variables = OpenStruct.new
-
-      variables[:completion_functions] = commands.map do |command|
-        generate_bash_subcommand_completion command
-      end.compact
-
-      variables[:function_mappings] = commands.map do |command|
-        next unless command_gets_completions? command
-
-        "#{command}) _brew_#{Commands.method_name command} ;;"
-      end.compact
+    def self.generate_bash_completion_file(commands)
+      variables = Variables.new(
+        completion_functions: commands.filter_map do |command|
+          generate_bash_subcommand_completion command
+        end,
+        function_mappings:    commands.filter_map do |command|
+          next unless command_gets_completions? command
+
+          "#{command}) _brew_#{Commands.method_name command} ;;"
+        end,
+      )
 
       ERB.new((TEMPLATE_DIR/"bash.erb").read, trim_mode: ">").result(variables.instance_eval { binding })
     end
 
     sig { params(command: String).returns(T.nilable(String)) }
-    def generate_zsh_subcommand_completion(command)
+    def self.generate_zsh_subcommand_completion(command)
       return unless command_gets_completions? command
 
       options = command_options(command)
@@ -263,52 +264,53 @@ def generate_zsh_subcommand_completion(command)
       COMPLETION
     end
 
-    def generate_zsh_option_exclusions(command, option)
-      conflicts = Commands.option_conflicts(command, option.gsub(/^--/, ""))
+    sig { params(command: String, option: String).returns(String) }
+    def self.generate_zsh_option_exclusions(command, option)
+      conflicts = Commands.option_conflicts(command, option.gsub(/^--?/, ""))
       return "" unless conflicts.presence
 
-      "(#{conflicts.map { |conflict| "--#{conflict}" }.join(" ")})"
+      "(#{conflicts.map { |conflict| "-#{"-" if conflict.size > 1}#{conflict}" }.join(" ")})"
     end
 
     sig { params(commands: T::Array[String]).returns(String) }
-    def generate_zsh_completion_file(commands)
-      variables = OpenStruct.new
+    def self.generate_zsh_completion_file(commands)
+      variables = Variables.new(
+        aliases:                      Commands::HOMEBREW_INTERNAL_COMMAND_ALIASES.filter_map do |alias_cmd, command|
+          alias_cmd = "'#{alias_cmd}'" if alias_cmd.start_with? "-"
+          command = "'#{command}'" if command.start_with? "-"
+          "#{alias_cmd} #{command}"
+        end,
 
-      variables[:aliases] = Commands::HOMEBREW_INTERNAL_COMMAND_ALIASES.map do |alias_command, command|
-        alias_command = "'#{alias_command}'" if alias_command.start_with? "-"
-        command = "'#{command}'" if command.start_with? "-"
-        "#{alias_command} #{command}"
-      end.compact
+        builtin_command_descriptions: commands.filter_map do |command|
+          next if Commands::HOMEBREW_INTERNAL_COMMAND_ALIASES.key? command
 
-      variables[:builtin_command_descriptions] = commands.map do |command|
-        next if Commands::HOMEBREW_INTERNAL_COMMAND_ALIASES.key? command
+          description = Commands.command_description(command, short: true)
+          next if description.blank?
 
-        description = Commands.command_description(command, short: true)
-        next if description.blank?
+          description = format_description description
+          "'#{command}:#{description}'"
+        end,
 
-        description = format_description description
-        "'#{command}:#{description}'"
-      end.compact
-
-      variables[:completion_functions] = commands.map do |command|
-        generate_zsh_subcommand_completion command
-      end.compact
+        completion_functions:         commands.filter_map do |command|
+          generate_zsh_subcommand_completion command
+        end,
+      )
 
       ERB.new((TEMPLATE_DIR/"zsh.erb").read, trim_mode: ">").result(variables.instance_eval { binding })
     end
 
     sig { params(command: String).returns(T.nilable(String)) }
-    def generate_fish_subcommand_completion(command)
+    def self.generate_fish_subcommand_completion(command)
       return unless command_gets_completions? command
 
       command_description = format_description Commands.command_description(command, short: true), fish: true
       lines = ["__fish_brew_complete_cmd '#{command}' '#{command_description}'"]
 
-      options = command_options(command).sort.map do |opt, desc|
+      options = command_options(command).sort.filter_map do |opt, desc|
         arg_line = "__fish_brew_complete_arg '#{command}' -l #{opt.sub(/^-+/, "")}"
         arg_line += " -d '#{format_description desc, fish: true}'" if desc.present?
         arg_line
-      end.compact
+      end
 
       subcommands = []
       named_args = []
@@ -345,12 +347,12 @@ def generate_fish_subcommand_completion(command)
     end
 
     sig { params(commands: T::Array[String]).returns(String) }
-    def generate_fish_completion_file(commands)
-      variables = OpenStruct.new
-
-      variables[:completion_functions] = commands.map do |command|
-        generate_fish_subcommand_completion command
-      end.compact
+    def self.generate_fish_completion_file(commands)
+      variables = Variables.new(
+        completion_functions: commands.filter_map do |command|
+          generate_fish_subcommand_completion command
+        end,
+      )
 
       ERB.new((TEMPLATE_DIR/"fish.erb").read, trim_mode: ">").result(variables.instance_eval { binding })
     end
diff --git a/Library/Homebrew/completions.rbi b/Library/Homebrew/completions.rbi
deleted file mode 100644
index 8c4746bcafd67..0000000000000
--- a/Library/Homebrew/completions.rbi
+++ /dev/null
@@ -1,7 +0,0 @@
-# typed: strict
-
-module Homebrew
-  module Completions
-    include Kernel
-  end
-end
diff --git a/Library/Homebrew/completions/bash.erb b/Library/Homebrew/completions/bash.erb
index b9f52a2cd9836..a9395d3ef30bf 100644
--- a/Library/Homebrew/completions/bash.erb
+++ b/Library/Homebrew/completions/bash.erb
@@ -12,44 +12,38 @@
 # When done, regenerate the completions by running `brew generate-man-completions`.
 %>
 # Bash completion script for brew(1)
+# This file is automatically generated by running `brew generate-man-completions`.
+# See Library/Homebrew/completions/bash.erb for editing instructions.
+
+if [[ -n ${POSIXLY_CORRECT:-} ]] || shopt -oq posix
+then
+  echo "Homebrew Bash completions do not work in POSIX mode" 1>&2
+  return
+fi
 
 __brewcomp_words_include() {
-  local i=1
-  while [[ "${i}" -lt "${COMP_CWORD}" ]]
+  local element idx
+  for (( idx = 1; idx < COMP_CWORD; idx++ ))
   do
-    if [[ "${COMP_WORDS[i]}" = "$1" ]]
-    then
-      return 0
-    fi
-    (( i++ ))
+    element=${COMP_WORDS[idx]}
+    [[ -n ${element} && ${element} == "$1" ]] && return 0
   done
   return 1
 }
 
-# Find the previous non-switch word
-__brewcomp_prev() {
-  local idx="$((COMP_CWORD - 1))"
-  local prv="${COMP_WORDS[idx]}"
-  while [[ "${prv}" = -* ]]
-  do
-    (( idx-- ))
-    prv="${COMP_WORDS[idx]}"
-  done
-  echo "${prv}"
-}
-
 __brewcomp() {
   # break $1 on space, tab, and newline characters,
   # and turn it into a newline separated list of words
   local list s sep=$'\n' IFS=$' \t\n'
-  local cur="${COMP_WORDS[COMP_CWORD]}"
+  local cur=${COMP_WORDS[COMP_CWORD]}
 
   for s in $1
   do
-    __brewcomp_words_include "${s}" && continue
-    list="${list}${s}${sep}"
+    __brewcomp_words_include "${s}" || list+="${s}${sep}"
   done
 
+  list=${list%"${sep}"}
+
   IFS="${sep}"
   while read -r line; do COMPREPLY+=("${line}"); done < <(compgen -W "${list}" -- "${cur}")
 }
@@ -73,7 +67,7 @@ __brew_complete_casks() {
 __brew_complete_installed_formulae() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   local installed_formulae
-  installed_formulae="$(command ls "$(brew --cellar)" 2>/dev/null)"
+  installed_formulae="$(command ls "${HOMEBREW_CELLAR:-$(brew --cellar)}" 2>/dev/null)"
   while read -r line; do COMPREPLY+=("${line}"); done < <(compgen -W "${installed_formulae}" -- "${cur}")
 }
 
@@ -87,44 +81,50 @@ __brew_complete_installed_casks() {
 __brew_complete_outdated_formulae() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   local outdated_formulae
-  outdated_formulae="$(brew outdated --formula --quiet)"
+  outdated_formulae="$(HOMEBREW_NO_AUTO_UPDATE=1 brew outdated --formula --quiet)"
   while read -r line; do COMPREPLY+=("${line}"); done < <(compgen -W "${outdated_formulae}" -- "${cur}")
 }
 
 __brew_complete_outdated_casks() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   local outdated_casks
-  outdated_casks="$(brew outdated --cask --quiet)"
+  outdated_casks="$(HOMEBREW_NO_AUTO_UPDATE=1 brew outdated --cask --quiet 2>/dev/null)"
   while read -r line; do COMPREPLY+=("${line}"); done < <(compgen -W "${outdated_casks}" -- "${cur}")
 }
 
 __brew_complete_tapped() {
   local dir taps taplib
-  taplib="$(brew --repository)/Library/Taps"
+  taplib=${HOMEBREW_REPOSITORY:-$(brew --repository)}/Library/Taps
 
   for dir in "${taplib}"/*/*
   do
-    [[ -d "${dir}" ]] || continue
-    dir="${dir#"${taplib}"/}"
-    dir="${dir/homebrew-/}"
-    taps="${taps} ${dir}"
+    [[ -d ${dir} ]] || continue
+    dir=${dir#"${taplib}"/}
+    dir=${dir/homebrew-/}
+    taps+=" ${dir}"
   done
   __brewcomp "${taps}"
 }
 
 __brew_complete_commands() {
+  # Auto-complete Homebrew commands
+  # Do NOT auto-complete "*instal" aliases for "*install" commands
+
   local cur="${COMP_WORDS[COMP_CWORD]}"
   local cmds
-  HOMEBREW_CACHE=$(brew --cache)
-  HOMEBREW_REPOSITORY=$(brew --repo)
-  # Do not auto-complete "*instal" or "*uninstal" aliases for "*install" commands.
-  if [[ -f "${HOMEBREW_CACHE}/all_commands_list.txt" ]]
+
+  if [[ -n ${__HOMEBREW_COMMANDS} ]]
+  then
+    cmds=${__HOMEBREW_COMMANDS}
+  elif [[ -n ${HOMEBREW_CACHE:-} && -f ${HOMEBREW_CACHE}/all_commands_list.txt ]]
   then
     cmds="$(< "${HOMEBREW_CACHE}/all_commands_list.txt" \grep -v instal$)"
-  else
+  elif [[ -n ${HOMEBREW_REPOSITORY:-} && -f ${HOMEBREW_REPOSITORY}/completions/internal_commands_list.txt ]]
+  then
     cmds="$(< "${HOMEBREW_REPOSITORY}/completions/internal_commands_list.txt" \grep -v instal$)"
   fi
   while read -r line; do COMPREPLY+=("${line}"); done < <(compgen -W "${cmds}" -- "${cur}")
+  export __HOMEBREW_COMMANDS=${cmds}
 }
 
 # compopt is only available in newer versions of bash
diff --git a/Library/Homebrew/completions/fish.erb b/Library/Homebrew/completions/fish.erb
index f14ef8f2da437..383966bb8cc57 100644
--- a/Library/Homebrew/completions/fish.erb
+++ b/Library/Homebrew/completions/fish.erb
@@ -12,6 +12,8 @@
 # When done, regenerate the completions by running `brew generate-man-completions`.
 %>
 # Fish shell completions for Homebrew
+# This file is automatically generated by running `brew generate-man-completions`.
+# See Library/Homebrew/completions/fish.erb for editing instructions.
 
 # A note about aliases:
 #
@@ -96,30 +98,17 @@ end
 ######################
 # These functions return lists of suggestions for arguments completion
 
-function __fish_brew_ruby_parse_json -a file parser -d 'Parses given JSON file with Ruby'
-    # parser is any chain of methods to call on the parsed JSON
-    ruby -e "require('json'); JSON.parse(File.read('$file'))$parser"
-end
-
 function __fish_brew_suggest_formulae_all -d 'Lists all available formulae with their descriptions'
-    # store the brew cache path in a var (because calling (brew --cache) is slow)
-    set -q __brew_cache_path
-    or set -gx __brew_cache_path (brew --cache)
-
-    if test -f "$__brew_cache_path/descriptions.json"
-        __fish_brew_ruby_parse_json "$__brew_cache_path/descriptions.json" \
-            '.each{ |k, v| puts([k, v].reject(&:nil?).join("\t")) }'
-    else
-        brew formulae
-    end
+    brew formulae
 end
 
 function __fish_brew_suggest_formulae_installed
-    brew list --formula
+    command ls -1 (brew --cellar)
 end
 
+
 function __fish_brew_suggest_formulae_outdated -d "List of outdated formulae with the information about potential upgrade"
-    brew outdated --formula --verbose \
+    HOMEBREW_NO_AUTO_UPDATE=1 brew outdated --formula --verbose 2>/dev/null \
         # replace first space with tab to make the following a description in the completions list:
         | string replace -r '\s' '\t'
 end
@@ -141,17 +130,19 @@ function __fish_brew_suggest_casks_all -d "Lists locally available casks"
 end
 
 function __fish_brew_suggest_casks_installed -d "Lists installed casks"
-    brew list --cask -1
+    command ls -1 (brew --caskroom) 2>/dev/null
 end
 
 function __fish_brew_suggest_casks_outdated -d "Lists outdated casks with the information about potential upgrade"
-    brew outdated --cask --verbose \
+    HOMEBREW_NO_AUTO_UPDATE=1 brew outdated --cask --verbose 2>/dev/null \
         # replace first space with tab to make the following a description in the completions list:
         | string replace -r '\s' '\t'
 end
 
 function __fish_brew_suggest_taps_installed -d "List all available taps"
-    brew tap
+    command find (brew --repo)/Library/Taps -mindepth 2 -maxdepth 2 -type d \
+    | string replace homebrew- "" \
+    | string replace (brew --repo)/Library/Taps/ ""
 end
 
 function __fish_brew_suggest_commands -d "Lists all commands names, including aliases"
@@ -166,13 +157,10 @@ function __fish_brew_suggest_diagnostic_checks -d "List available diagnostic che
     brew doctor --list-checks
 end
 
-# TODO: any better way to list available services?
 function __fish_brew_suggest_services -d "Lists available services"
-    set -l list (brew services list)
-    set -e list[1] # Header
-    for line in $list
-        echo (string split ' ' $line)[1]
-    end
+    command find (brew --cellar) -mindepth 3 -maxdepth 3 -name '*.service' \
+      | awk -F'homebrew.|.service' '{print $3}' \
+      | sort -d
 end
 
 
@@ -237,10 +225,12 @@ __fish_brew_complete_arg 'bundle;
         and not __fish_brew_opt --file --global
     ' -l global  -d "Use \$HOME/.Brewfile"
 
+__fish_brew_complete_sub_cmd 'bundle' 'install' "Install and upgrade (by default) all dependencies from the Brewfile."
 __fish_brew_complete_sub_cmd 'bundle' 'dump'    "Write all installed casks/formulae/taps into a Brewfile"
 __fish_brew_complete_sub_cmd 'bundle' 'cleanup' "Uninstall all dependencies not listed in a Brewfile"
 __fish_brew_complete_sub_cmd 'bundle' 'check'   "Check if all dependencies are installed in a Brewfile"
 __fish_brew_complete_sub_cmd 'bundle' 'exec'    "Run an external command in an isolated build environment"
+__fish_brew_complete_sub_cmd 'bundle' 'list'    "List all dependencies present in the Brewfile."
 
 # --force is available only for the dump/cleanup subcommands
 __fish_brew_complete_sub_arg 'bundle' 'dump cleanup' -l force -d "Uninstall dependencies or overwrite an existing Brewfile"
diff --git a/Library/Homebrew/completions/zsh.erb b/Library/Homebrew/completions/zsh.erb
index 1049d9f01a155..025ab24ea6e1a 100644
--- a/Library/Homebrew/completions/zsh.erb
+++ b/Library/Homebrew/completions/zsh.erb
@@ -15,6 +15,8 @@
 #autoload
 
 # Brew ZSH completion function
+# This file is automatically generated by running `brew generate-man-completions`.
+# See Library/Homebrew/completions/zsh.erb for editing instructions.
 
 # functions starting with __brew are helper functions that complete or list
 #   various types of items.
@@ -72,7 +74,7 @@ __brew_outdated_formulae() {
   [[ -prefix '-' ]] && return 0
 
   local -a formulae
-  formulae=($(brew outdated --formula))
+  formulae=($(HOMEBREW_NO_AUTO_UPDATE=1 brew outdated --formula))
   _describe -t formulae 'outdated formulae' formulae
 }
 
@@ -96,7 +98,7 @@ __brew_installed_casks() {
 
   local -a list
   local expl
-  list=( $(brew list --cask) )
+  list=( $(brew list --cask 2>/dev/null) )
   _wanted list expl 'installed casks' compadd -a list
 }
 
@@ -104,7 +106,7 @@ __brew_outdated_casks() {
   [[ -prefix '-' ]] && return 0
 
   local -a casks
-  casks=($(brew outdated --cask))
+  casks=($(HOMEBREW_NO_AUTO_UPDATE=1 brew outdated --cask 2>/dev/null))
   _describe -t casks 'outdated casks' casks
 }
 
diff --git a/Library/Homebrew/config.rbi b/Library/Homebrew/config.rbi
deleted file mode 100644
index 2cab9bf6d521a..0000000000000
--- a/Library/Homebrew/config.rbi
+++ /dev/null
@@ -1,6 +0,0 @@
-# typed: strict
-
-module EnvVar
-  sig { params(env: String).returns(String) }
-  def self.[](env); end
-end
diff --git a/Library/Homebrew/context.rb b/Library/Homebrew/context.rb
index 5a9c410bcce2e..382f60906329c 100644
--- a/Library/Homebrew/context.rb
+++ b/Library/Homebrew/context.rb
@@ -1,11 +1,9 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "monitor"
 
 # Module for querying the current execution context.
-#
-# @api private
 module Context
   extend MonitorMixin
 
@@ -33,33 +31,39 @@ def initialize(debug: nil, quiet: nil, verbose: nil)
       @verbose = verbose
     end
 
+    sig { returns(T::Boolean) }
     def debug?
       @debug == true
     end
 
+    sig { returns(T::Boolean) }
     def quiet?
       @quiet == true
     end
 
+    sig { returns(T::Boolean) }
     def verbose?
       @verbose == true
     end
   end
 
+  sig { returns(T::Boolean) }
   def debug?
     Context.current.debug?
   end
 
+  sig { returns(T::Boolean) }
   def quiet?
     Context.current.quiet?
   end
 
+  sig { returns(T::Boolean) }
   def verbose?
     Context.current.verbose?
   end
 
   def with_context(**options)
-    old_context = Thread.current[:context]
+    old_context = Context.current
 
     new_context = ContextStruct.new(
       debug:   options.fetch(:debug, old_context&.debug?),
@@ -69,8 +73,10 @@ def with_context(**options)
 
     Thread.current[:context] = new_context
 
-    yield
-  ensure
-    Thread.current[:context] = old_context
+    begin
+      yield
+    ensure
+      Thread.current[:context] = old_context
+    end
   end
 end
diff --git a/Library/Homebrew/cxxstdlib.rb b/Library/Homebrew/cxxstdlib.rb
index ed43d0c3877fe..8b259144a875f 100644
--- a/Library/Homebrew/cxxstdlib.rb
+++ b/Library/Homebrew/cxxstdlib.rb
@@ -1,25 +1,30 @@
-# typed: true
+# typed: strong
 # frozen_string_literal: true
 
 require "compilers"
 
 # Combination of C++ standard library and compiler.
 class CxxStdlib
-  extend T::Sig
-
+  sig { params(type: T.nilable(Symbol), compiler: T.any(Symbol, String)).returns(CxxStdlib) }
   def self.create(type, compiler)
     raise ArgumentError, "Invalid C++ stdlib type: #{type}" if type && [:libstdcxx, :libcxx].exclude?(type)
 
     CxxStdlib.new(type, compiler)
   end
 
-  attr_reader :type, :compiler
+  sig { returns(T.nilable(Symbol)) }
+  attr_reader :type
+
+  sig { returns(Symbol) }
+  attr_reader :compiler
 
+  sig { params(type: T.nilable(Symbol), compiler: T.any(Symbol, String)).void }
   def initialize(type, compiler)
     @type = type
-    @compiler = compiler.to_sym
+    @compiler = T.let(compiler.to_sym, Symbol)
   end
 
+  sig { returns(String) }
   def type_string
     type.to_s.gsub(/cxx$/, "c++")
   end
diff --git a/Library/Homebrew/data/schemas/sbom.json b/Library/Homebrew/data/schemas/sbom.json
new file mode 100644
index 0000000000000..a04cb525d59bb
--- /dev/null
+++ b/Library/Homebrew/data/schemas/sbom.json
@@ -0,0 +1,750 @@
+{
+  "$schema" : "https://json-schema.org/draft/2019-09/schema",
+  "$id" : "http://spdx.org/rdf/terms/2.3",
+  "title" : "SPDX 2.3",
+  "type" : "object",
+  "properties" : {
+    "$schema": {
+      "type": "string",
+      "description": "Reference the SPDX 2.3 JSON schema."
+    },
+    "SPDXID" : {
+      "type" : "string",
+      "description" : "Uniquely identify any element in an SPDX document which may be referenced by other elements."
+    },
+    "annotations" : {
+      "description" : "Provide additional information about an SpdxElement.",
+      "type" : "array",
+      "items" : {
+        "type" : "object",
+        "properties" : {
+          "annotationDate" : {
+            "description" : "Identify when the comment was made. This is to be specified according to the combined date and time in the UTC format, as specified in the ISO 8601 standard.",
+            "type" : "string"
+          },
+          "annotationType" : {
+            "description" : "Type of the annotation.",
+            "type" : "string",
+            "enum" : [ "OTHER", "REVIEW" ]
+          },
+          "annotator" : {
+            "description" : "This field identifies the person, organization, or tool that has commented on a file, package, snippet, or the entire document.",
+            "type" : "string"
+          },
+          "comment" : {
+            "type" : "string"
+          }
+        },
+        "required" : [ "annotationDate", "annotationType", "annotator", "comment" ],
+        "additionalProperties" : false,
+        "description" : "An Annotation is a comment on an SpdxItem by an agent."
+      }
+    },
+    "comment" : {
+      "type" : "string"
+    },
+    "creationInfo" : {
+      "type" : "object",
+      "properties" : {
+        "comment" : {
+          "type" : "string"
+        },
+        "created" : {
+          "description" : "Identify when the SPDX document was originally created. The date is to be specified according to combined date and time in UTC format as specified in ISO 8601 standard.",
+          "type" : "string"
+        },
+        "creators" : {
+          "description" : "Identify who (or what, in the case of a tool) created the SPDX document. If the SPDX document was created by an individual, indicate the person's name. If the SPDX document was created on behalf of a company or organization, indicate the entity name. If the SPDX document was created using a software tool, indicate the name and version for that tool. If multiple participants or tools were involved, use multiple instances of this field. Person name or organization name may be designated as “anonymous” if appropriate.",
+          "minItems" : 1,
+          "type" : "array",
+          "items" : {
+            "description" : "Identify who (or what, in the case of a tool) created the SPDX document. If the SPDX document was created by an individual, indicate the person's name. If the SPDX document was created on behalf of a company or organization, indicate the entity name. If the SPDX document was created using a software tool, indicate the name and version for that tool. If multiple participants or tools were involved, use multiple instances of this field. Person name or organization name may be designated as “anonymous” if appropriate.",
+            "type" : "string"
+          }
+        },
+        "licenseListVersion" : {
+          "description" : "An optional field for creators of the SPDX file to provide the version of the SPDX License List used when the SPDX file was created.",
+          "type" : "string"
+        }
+      },
+      "required" : [ "created", "creators" ],
+      "additionalProperties" : false,
+      "description" : "One instance is required for each SPDX file produced. It provides the necessary information for forward and backward compatibility for processing tools."
+    },
+    "dataLicense" : {
+      "description" : "License expression for dataLicense. See SPDX Annex D for the license expression syntax.  Compliance with the SPDX specification includes populating the SPDX fields therein with data related to such fields (\"SPDX-Metadata\"). The SPDX specification contains numerous fields where an SPDX document creator may provide relevant explanatory text in SPDX-Metadata. Without opining on the lawfulness of \"database rights\" (in jurisdictions where applicable), such explanatory text is copyrightable subject matter in most Berne Convention countries. By using the SPDX specification, or any portion hereof, you hereby agree that any copyright rights (as determined by your jurisdiction) in any SPDX-Metadata, including without limitation explanatory text, shall be subject to the terms of the Creative Commons CC0 1.0 Universal license. For SPDX-Metadata not containing any copyright rights, you hereby agree and acknowledge that the SPDX-Metadata is provided to you \"as-is\" and without any representations or warranties of any kind concerning the SPDX-Metadata, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non-infringement, or the absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law.",
+      "type" : "string"
+    },
+    "externalDocumentRefs" : {
+      "description" : "Identify any external SPDX documents referenced within this SPDX document.",
+      "type" : "array",
+      "items" : {
+        "type" : "object",
+        "properties" : {
+          "checksum" : {
+            "type" : "object",
+            "properties" : {
+              "algorithm" : {
+                "description" : "Identifies the algorithm used to produce the subject Checksum. Currently, SHA-1 is the only supported algorithm. It is anticipated that other algorithms will be supported at a later time.",
+                "type" : "string",
+                "enum" : [ "SHA1", "BLAKE3", "SHA3-384", "SHA256", "SHA384", "BLAKE2b-512", "BLAKE2b-256", "SHA3-512", "MD2", "ADLER32", "MD4", "SHA3-256", "BLAKE2b-384", "SHA512", "MD6", "MD5", "SHA224" ]
+              },
+              "checksumValue" : {
+                "description" : "The checksumValue property provides a lower case hexidecimal encoded digest value produced using a specific algorithm.",
+                "type" : "string"
+              }
+            },
+            "required" : [ "algorithm", "checksumValue" ],
+            "additionalProperties" : false,
+            "description" : "A Checksum is value that allows the contents of a file to be authenticated. Even small changes to the content of the file will change its checksum. This class allows the results of a variety of checksum and cryptographic message digest algorithms to be represented."
+          },
+          "externalDocumentId" : {
+            "description" : "externalDocumentId is a string containing letters, numbers, ., - and/or + which uniquely identifies an external document within this document.",
+            "type" : "string"
+          },
+          "spdxDocument" : {
+            "description" : "SPDX ID for SpdxDocument.  A property containing an SPDX document.",
+            "type" : "string"
+          }
+        },
+        "required" : [ "checksum", "externalDocumentId", "spdxDocument" ],
+        "additionalProperties" : false,
+        "description" : "Information about an external SPDX document reference including the checksum. This allows for verification of the external references."
+      }
+    },
+    "hasExtractedLicensingInfos" : {
+      "description" : "Indicates that a particular ExtractedLicensingInfo was defined in the subject SpdxDocument.",
+      "type" : "array",
+      "items" : {
+        "type" : "object",
+        "properties" : {
+          "comment" : {
+            "type" : "string"
+          },
+          "crossRefs" : {
+            "description" : "Cross Reference Detail for a license SeeAlso URL",
+            "type" : "array",
+            "items" : {
+              "type" : "object",
+              "properties" : {
+                "isLive" : {
+                  "description" : "Indicate a URL is still a live accessible location on the public internet",
+                  "type" : "boolean"
+                },
+                "isValid" : {
+                  "description" : "True if the URL is a valid well formed URL",
+                  "type" : "boolean"
+                },
+                "isWayBackLink" : {
+                  "description" : "True if the License SeeAlso URL points to a Wayback archive",
+                  "type" : "boolean"
+                },
+                "match" : {
+                  "description" : "Status of a License List SeeAlso URL reference if it refers to a website that matches the license text.",
+                  "type" : "string"
+                },
+                "order" : {
+                  "description" : "The ordinal order of this element within a list",
+                  "type" : "integer"
+                },
+                "timestamp" : {
+                  "description" : "Timestamp",
+                  "type" : "string"
+                },
+                "url" : {
+                  "description" : "URL Reference",
+                  "type" : "string"
+                }
+              },
+              "required" : [ "url" ],
+              "additionalProperties" : false,
+              "description" : "Cross reference details for the a URL reference"
+            }
+          },
+          "extractedText" : {
+            "description" : "Provide a copy of the actual text of the license reference extracted from the package, file or snippet that is associated with the License Identifier to aid in future analysis.",
+            "type" : "string"
+          },
+          "licenseId" : {
+            "description" : "A human readable short form license identifier for a license. The license ID is either on the standard license list or the form \"LicenseRef-[idString]\" where [idString] is a unique string containing letters, numbers, \".\" or \"-\".  When used within a license expression, the license ID can optionally include a reference to an external document in the form \"DocumentRef-[docrefIdString]:LicenseRef-[idString]\" where docRefIdString is an ID for an external document reference.",
+            "type" : "string"
+          },
+          "name" : {
+            "description" : "Identify name of this SpdxElement.",
+            "type" : "string"
+          },
+          "seeAlsos" : {
+            "type" : "array",
+            "items" : {
+              "type" : "string"
+            }
+          }
+        },
+        "required" : [ "extractedText", "licenseId" ],
+        "additionalProperties" : false,
+        "description" : "An ExtractedLicensingInfo represents a license or licensing notice that was found in a package, file or snippet. Any license text that is recognized as a license may be represented as a License rather than an ExtractedLicensingInfo."
+      }
+    },
+    "name" : {
+      "description" : "Identify name of this SpdxElement.",
+      "type" : "string"
+    },
+    "revieweds" : {
+      "description" : "Reviewed",
+      "deprecated": true,
+      "type" : "array",
+      "items" : {
+        "type" : "object",
+        "properties" : {
+          "comment" : {
+            "type" : "string"
+          },
+          "reviewDate" : {
+            "description" : "The date and time at which the SpdxDocument was reviewed. This value must be in UTC and have 'Z' as its timezone indicator.",
+            "type" : "string"
+          },
+          "reviewer" : {
+            "description" : "The name and, optionally, contact information of the person who performed the review. Values of this property must conform to the agent and tool syntax.  The reviewer property is deprecated in favor of Annotation with an annotationType review.",
+            "type" : "string"
+          }
+        },
+        "required" : [ "reviewDate" ],
+        "additionalProperties" : false,
+        "description" : "This class has been deprecated in favor of an Annotation with an Annotation type of review."
+      }
+    },
+    "spdxVersion" : {
+      "description" : "Provide a reference number that can be used to understand how to parse and interpret the rest of the file. It will enable both future changes to the specification and to support backward compatibility. The version number consists of a major and minor version indicator. The major field will be incremented when incompatible changes between versions are made (one or more sections are created, modified or deleted). The minor field will be incremented when backwards compatible changes are made.",
+      "type" : "string"
+    },
+    "documentNamespace" : {
+      "type" : "string",
+      "description" : "The URI provides an unambiguous mechanism for other SPDX documents to reference SPDX elements within this SPDX document."
+    },
+    "documentDescribes" : {
+      "description" : "DEPRECATED: use relationships instead of this field. Packages, files and/or Snippets described by this SPDX document",
+      "deprecated": true,
+      "$comment": "This field has been deprecated as it is a duplicate of using the SPDXRef-DOCUMENT DESCRIBES relationship",
+      "type" : "array",
+      "items" : {
+        "type" : "string",
+        "description" : "SPDX ID for each Package, File, or Snippet."
+      }
+    },
+    "packages" : {
+      "description" : "Packages referenced in the SPDX document",
+      "type" : "array",
+      "items" : {
+        "type" : "object",
+        "properties" : {
+          "SPDXID" : {
+            "type" : "string",
+            "description" : "Uniquely identify any element in an SPDX document which may be referenced by other elements."
+          },
+          "annotations" : {
+            "description" : "Provide additional information about an SpdxElement.",
+            "type" : "array",
+            "items" : {
+              "type" : "object",
+              "properties" : {
+                "annotationDate" : {
+                  "description" : "Identify when the comment was made. This is to be specified according to the combined date and time in the UTC format, as specified in the ISO 8601 standard.",
+                  "type" : "string"
+                },
+                "annotationType" : {
+                  "description" : "Type of the annotation.",
+                  "type" : "string",
+                  "enum" : [ "OTHER", "REVIEW" ]
+                },
+                "annotator" : {
+                  "description" : "This field identifies the person, organization, or tool that has commented on a file, package, snippet, or the entire document.",
+                  "type" : "string"
+                },
+                "comment" : {
+                  "type" : "string"
+                }
+              },
+              "required" : [ "annotationDate", "annotationType", "annotator", "comment" ],
+              "additionalProperties" : false,
+              "description" : "An Annotation is a comment on an SpdxItem by an agent."
+            }
+          },
+          "attributionTexts" : {
+            "description" : "This field provides a place for the SPDX data creator to record acknowledgements that may be required to be communicated in some contexts. This is not meant to include the actual complete license text (see licenseConculded and licenseDeclared), and may or may not include copyright notices (see also copyrightText). The SPDX data creator may use this field to record other acknowledgements, such as particular clauses from license texts, which may be necessary or desirable to reproduce.",
+            "type" : "array",
+            "items" : {
+              "description" : "This field provides a place for the SPDX data creator to record acknowledgements that may be required to be communicated in some contexts. This is not meant to include the actual complete license text (see licenseConculded and licenseDeclared), and may or may not include copyright notices (see also copyrightText). The SPDX data creator may use this field to record other acknowledgements, such as particular clauses from license texts, which may be necessary or desirable to reproduce.",
+              "type" : "string"
+            }
+          },
+          "builtDate" : {
+            "description" : "This field provides a place for recording the actual date the package was built.",
+            "type" : "string"
+          },
+          "checksums" : {
+            "description" : "The checksum property provides a mechanism that can be used to verify that the contents of a File or Package have not changed.",
+            "type" : "array",
+            "items" : {
+              "type" : "object",
+              "properties" : {
+                "algorithm" : {
+                  "description" : "Identifies the algorithm used to produce the subject Checksum. Currently, SHA-1 is the only supported algorithm. It is anticipated that other algorithms will be supported at a later time.",
+                  "type" : "string",
+                  "enum" : [ "SHA1", "BLAKE3", "SHA3-384", "SHA256", "SHA384", "BLAKE2b-512", "BLAKE2b-256", "SHA3-512", "MD2", "ADLER32", "MD4", "SHA3-256", "BLAKE2b-384", "SHA512", "MD6", "MD5", "SHA224" ]
+                },
+                "checksumValue" : {
+                  "description" : "The checksumValue property provides a lower case hexidecimal encoded digest value produced using a specific algorithm.",
+                  "type" : "string"
+                }
+              },
+              "required" : [ "algorithm", "checksumValue" ],
+              "additionalProperties" : false,
+              "description" : "A Checksum is value that allows the contents of a file to be authenticated. Even small changes to the content of the file will change its checksum. This class allows the results of a variety of checksum and cryptographic message digest algorithms to be represented."
+            }
+          },
+          "comment" : {
+            "type" : "string"
+          },
+          "copyrightText" : {
+            "description" : "The text of copyright declarations recited in the package, file or snippet.\n\nIf the copyrightText field is not present, it implies an equivalent meaning to NOASSERTION.",
+            "type" : "string"
+          },
+          "description" : {
+            "description" : "Provides a detailed description of the package.",
+            "type" : "string"
+          },
+          "downloadLocation" : {
+            "description" : "The URI at which this package is available for download. Private (i.e., not publicly reachable) URIs are acceptable as values of this property. The values http://spdx.org/rdf/terms#none and http://spdx.org/rdf/terms#noassertion may be used to specify that the package is not downloadable or that no attempt was made to determine its download location, respectively.",
+            "type" : "string"
+          },
+          "externalRefs" : {
+            "description" : "An External Reference allows a Package to reference an external source of additional information, metadata, enumerations, asset identifiers, or downloadable content believed to be relevant to the Package.",
+            "type" : "array",
+            "items" : {
+              "type" : "object",
+              "properties" : {
+                "comment" : {
+                  "type" : "string"
+                },
+                "referenceCategory" : {
+                  "description" : "Category for the external reference",
+                  "type" : "string",
+                  "enum" : [ "OTHER", "PERSISTENT-ID", "PERSISTENT_ID", "SECURITY", "PACKAGE-MANAGER", "PACKAGE_MANAGER" ]
+                },
+                "referenceLocator" : {
+                  "description" : "The unique string with no spaces necessary to access the package-specific information, metadata, or content within the target location. The format of the locator is subject to constraints defined by the <type>.",
+                  "type" : "string"
+                },
+                "referenceType" : {
+                  "description" : "Type of the external reference. These are defined in an appendix in the SPDX specification.",
+                  "type" : "string"
+                }
+              },
+              "required" : [ "referenceCategory", "referenceLocator", "referenceType" ],
+              "additionalProperties" : false,
+              "description" : "An External Reference allows a Package to reference an external source of additional information, metadata, enumerations, asset identifiers, or downloadable content believed to be relevant to the Package."
+            }
+          },
+          "filesAnalyzed" : {
+            "description" : "Indicates whether the file content of this package has been available for or subjected to analysis when creating the SPDX document. If false indicates packages that represent metadata or URI references to a project, product, artifact, distribution or a component. If set to false, the package must not contain any files.",
+            "type" : "boolean"
+          },
+          "hasFiles" : {
+            "description" : "DEPRECATED: use relationships instead of this field. Indicates that a particular file belongs to a package.",
+            "deprecated": true,
+            "$comment": "This field has been deprecated as it is a duplicate of using CONTAINS relationships from a package to files",
+            "type" : "array",
+            "items" : {
+              "description" : "SPDX ID for File.  Indicates that a particular file belongs to a package.",
+              "type" : "string"
+            }
+          },
+          "homepage" : {
+            "type" : "string"
+          },
+          "licenseComments" : {
+            "description" : "The licenseComments property allows the preparer of the SPDX document to describe why the licensing in spdx:licenseConcluded was chosen.",
+            "type" : "string"
+          },
+          "licenseConcluded" : {
+            "description" : "License expression for licenseConcluded. See SPDX Annex D for the license expression syntax.  The licensing that the preparer of this SPDX document has concluded, based on the evidence, actually applies to the SPDX Item.\n\nIf the licenseConcluded field is not present for an SPDX Item, it implies an equivalent meaning to NOASSERTION.",
+            "type" : "string"
+          },
+          "licenseDeclared" : {
+            "description" : "License expression for licenseDeclared. See SPDX Annex D for the license expression syntax.  The licensing that the creators of the software in the package, or the packager, have declared. Declarations by the original software creator should be preferred, if they exist.",
+            "type" : "string"
+          },
+          "licenseInfoFromFiles" : {
+            "description" : "The licensing information that was discovered directly within the package. There will be an instance of this property for each distinct value of alllicenseInfoInFile properties of all files contained in the package.\n\nIf the licenseInfoFromFiles field is not present for a package and filesAnalyzed property for that same package is true or omitted, it implies an equivalent meaning to NOASSERTION.",
+            "type" : "array",
+            "items" : {
+              "description" : "License expression for licenseInfoFromFiles. See SPDX Annex D for the license expression syntax.  The licensing information that was discovered directly within the package. There will be an instance of this property for each distinct value of alllicenseInfoInFile properties of all files contained in the package.\n\nIf the licenseInfoFromFiles field is not present for a package and filesAnalyzed property for that same package is true or omitted, it implies an equivalent meaning to NOASSERTION.",
+              "type" : "string"
+            }
+          },
+          "name" : {
+            "description" : "Identify name of this SpdxElement.",
+            "type" : "string"
+          },
+          "originator" : {
+            "description" : "The name and, optionally, contact information of the person or organization that originally created the package. Values of this property must conform to the agent and tool syntax.",
+            "type" : "string"
+          },
+          "packageFileName" : {
+            "description" : "The base name of the package file name. For example, zlib-1.2.5.tar.gz.",
+            "type" : "string"
+          },
+          "packageVerificationCode" : {
+            "type" : "object",
+            "properties" : {
+              "packageVerificationCodeExcludedFiles" : {
+                "description" : "A file that was excluded when calculating the package verification code. This is usually a file containing SPDX data regarding the package. If a package contains more than one SPDX file all SPDX files must be excluded from the package verification code. If this is not done it would be impossible to correctly calculate the verification codes in both files.",
+                "type" : "array",
+                "items" : {
+                  "description" : "A file that was excluded when calculating the package verification code. This is usually a file containing SPDX data regarding the package. If a package contains more than one SPDX file all SPDX files must be excluded from the package verification code. If this is not done it would be impossible to correctly calculate the verification codes in both files.",
+                  "type" : "string"
+                }
+              },
+              "packageVerificationCodeValue" : {
+                "description" : "The actual package verification code as a hex encoded value.",
+                "type" : "string"
+              }
+            },
+            "required" : [ "packageVerificationCodeValue" ],
+            "additionalProperties" : false,
+            "description" : "A manifest based verification code (the algorithm is defined in section 4.7 of the full specification) of the SPDX Item. This allows consumers of this data and/or database to determine if an SPDX item they have in hand is identical to the SPDX item from which the data was produced. This algorithm works even if the SPDX document is included in the SPDX item."
+          },
+          "primaryPackagePurpose" : {
+            "description" : "This field provides information about the primary purpose of the identified package. Package Purpose is intrinsic to how the package is being used rather than the content of the package.",
+            "type" : "string",
+            "enum" : [ "OTHER", "INSTALL", "ARCHIVE", "FIRMWARE", "APPLICATION", "FRAMEWORK", "LIBRARY", "CONTAINER", "SOURCE", "DEVICE", "OPERATING_SYSTEM", "FILE" ]
+          },
+          "releaseDate" : {
+            "description" : "This field provides a place for recording the date the package was released.",
+            "type" : "string"
+          },
+          "sourceInfo" : {
+            "description" : "Allows the producer(s) of the SPDX document to describe how the package was acquired and/or changed from the original source.",
+            "type" : "string"
+          },
+          "summary" : {
+            "description" : "Provides a short description of the package.",
+            "type" : "string"
+          },
+          "supplier" : {
+            "description" : "The name and, optionally, contact information of the person or organization who was the immediate supplier of this package to the recipient. The supplier may be different than originator when the software has been repackaged. Values of this property must conform to the agent and tool syntax.",
+            "type" : "string"
+          },
+          "validUntilDate" : {
+            "description" : "This field provides a place for recording the end of the support period for a package from the supplier.",
+            "type" : "string"
+          },
+          "versionInfo" : {
+            "description" : "Provides an indication of the version of the package that is described by this SpdxDocument.",
+            "type" : "string"
+          }
+        },
+        "required" : [ "SPDXID", "downloadLocation", "name" ],
+        "additionalProperties" : false
+      }
+    },
+    "files" : {
+      "description" : "Files referenced in the SPDX document",
+      "type" : "array",
+      "items" : {
+        "type" : "object",
+        "properties" : {
+          "SPDXID" : {
+            "type" : "string",
+            "description" : "Uniquely identify any element in an SPDX document which may be referenced by other elements."
+          },
+          "annotations" : {
+            "description" : "Provide additional information about an SpdxElement.",
+            "type" : "array",
+            "items" : {
+              "type" : "object",
+              "properties" : {
+                "annotationDate" : {
+                  "description" : "Identify when the comment was made. This is to be specified according to the combined date and time in the UTC format, as specified in the ISO 8601 standard.",
+                  "type" : "string"
+                },
+                "annotationType" : {
+                  "description" : "Type of the annotation.",
+                  "type" : "string",
+                  "enum" : [ "OTHER", "REVIEW" ]
+                },
+                "annotator" : {
+                  "description" : "This field identifies the person, organization, or tool that has commented on a file, package, snippet, or the entire document.",
+                  "type" : "string"
+                },
+                "comment" : {
+                  "type" : "string"
+                }
+              },
+              "required" : [ "annotationDate", "annotationType", "annotator", "comment" ],
+              "additionalProperties" : false,
+              "description" : "An Annotation is a comment on an SpdxItem by an agent."
+            }
+          },
+          "artifactOfs" : {
+            "description" : "Indicates the project in which the SpdxElement originated. Tools must preserve doap:homepage and doap:name properties and the URI (if one is known) of doap:Project resources that are values of this property. All other properties of doap:Projects are not directly supported by SPDX and may be dropped when translating to or from some SPDX formats.",
+            "type" : "array",
+            "items" : {
+              "type" : "object"
+            }
+          },
+          "attributionTexts" : {
+            "description" : "This field provides a place for the SPDX data creator to record acknowledgements that may be required to be communicated in some contexts. This is not meant to include the actual complete license text (see licenseConculded and licenseDeclared), and may or may not include copyright notices (see also copyrightText). The SPDX data creator may use this field to record other acknowledgements, such as particular clauses from license texts, which may be necessary or desirable to reproduce.",
+            "type" : "array",
+            "items" : {
+              "description" : "This field provides a place for the SPDX data creator to record acknowledgements that may be required to be communicated in some contexts. This is not meant to include the actual complete license text (see licenseConculded and licenseDeclared), and may or may not include copyright notices (see also copyrightText). The SPDX data creator may use this field to record other acknowledgements, such as particular clauses from license texts, which may be necessary or desirable to reproduce.",
+              "type" : "string"
+            }
+          },
+          "checksums" : {
+            "description" : "The checksum property provides a mechanism that can be used to verify that the contents of a File or Package have not changed.",
+            "minItems" : 1,
+            "type" : "array",
+            "items" : {
+              "type" : "object",
+              "properties" : {
+                "algorithm" : {
+                  "description" : "Identifies the algorithm used to produce the subject Checksum. Currently, SHA-1 is the only supported algorithm. It is anticipated that other algorithms will be supported at a later time.",
+                  "type" : "string",
+                  "enum" : [ "SHA1", "BLAKE3", "SHA3-384", "SHA256", "SHA384", "BLAKE2b-512", "BLAKE2b-256", "SHA3-512", "MD2", "ADLER32", "MD4", "SHA3-256", "BLAKE2b-384", "SHA512", "MD6", "MD5", "SHA224" ]
+                },
+                "checksumValue" : {
+                  "description" : "The checksumValue property provides a lower case hexidecimal encoded digest value produced using a specific algorithm.",
+                  "type" : "string"
+                }
+              },
+              "required" : [ "algorithm", "checksumValue" ],
+              "additionalProperties" : false,
+              "description" : "A Checksum is value that allows the contents of a file to be authenticated. Even small changes to the content of the file will change its checksum. This class allows the results of a variety of checksum and cryptographic message digest algorithms to be represented."
+            }
+          },
+          "comment" : {
+            "type" : "string"
+          },
+          "copyrightText" : {
+            "description" : "The text of copyright declarations recited in the package, file or snippet.\n\nIf the copyrightText field is not present, it implies an equivalent meaning to NOASSERTION.",
+            "type" : "string"
+          },
+          "fileContributors" : {
+            "description" : "This field provides a place for the SPDX file creator to record file contributors. Contributors could include names of copyright holders and/or authors who may not be copyright holders yet contributed to the file content.",
+            "type" : "array",
+            "items" : {
+              "description" : "This field provides a place for the SPDX file creator to record file contributors. Contributors could include names of copyright holders and/or authors who may not be copyright holders yet contributed to the file content.",
+              "type" : "string"
+            }
+          },
+          "fileDependencies" : {
+            "description" : "This field is deprecated since SPDX 2.0 in favor of using Section 7 which provides more granularity about relationships.",
+            "deprecated": true,
+            "type" : "array",
+            "items" : {
+              "description" : "SPDX ID for File.  This field is deprecated since SPDX 2.0 in favor of using Section 7 which provides more granularity about relationships.",
+              "type" : "string"
+            }
+          },
+          "fileName" : {
+            "description" : "The name of the file relative to the root of the package.",
+            "type" : "string"
+          },
+          "fileTypes" : {
+            "description" : "The type of the file.",
+            "type" : "array",
+            "items" : {
+              "description" : "The type of the file.",
+              "type" : "string",
+              "enum" : [ "OTHER", "DOCUMENTATION", "IMAGE", "VIDEO", "ARCHIVE", "SPDX", "APPLICATION", "SOURCE", "BINARY", "TEXT", "AUDIO" ]
+            }
+          },
+          "licenseComments" : {
+            "description" : "The licenseComments property allows the preparer of the SPDX document to describe why the licensing in spdx:licenseConcluded was chosen.",
+            "type" : "string"
+          },
+          "licenseConcluded" : {
+            "description" : "License expression for licenseConcluded. See SPDX Annex D for the license expression syntax.  The licensing that the preparer of this SPDX document has concluded, based on the evidence, actually applies to the SPDX Item.\n\nIf the licenseConcluded field is not present for an SPDX Item, it implies an equivalent meaning to NOASSERTION.",
+            "type" : "string"
+          },
+          "licenseInfoInFiles" : {
+            "description" : "Licensing information that was discovered directly in the subject file. This is also considered a declared license for the file.\n\nIf the licenseInfoInFile field is not present for a file, it implies an equivalent meaning to NOASSERTION.",
+            "type" : "array",
+            "items" : {
+              "description" : "License expression for licenseInfoInFile. See SPDX Annex D for the license expression syntax.  Licensing information that was discovered directly in the subject file. This is also considered a declared license for the file.\n\nIf the licenseInfoInFile field is not present for a file, it implies an equivalent meaning to NOASSERTION.",
+              "type" : "string"
+            }
+          },
+          "noticeText" : {
+            "description" : "This field provides a place for the SPDX file creator to record potential legal notices found in the file. This may or may not include copyright statements.",
+            "type" : "string"
+          }
+        },
+        "required" : [ "SPDXID", "checksums", "fileName" ],
+        "additionalProperties" : false
+      }
+    },
+    "snippets" : {
+      "description" : "Snippets referenced in the SPDX document",
+      "type" : "array",
+      "items" : {
+        "type" : "object",
+        "properties" : {
+          "SPDXID" : {
+            "type" : "string",
+            "description" : "Uniquely identify any element in an SPDX document which may be referenced by other elements."
+          },
+          "annotations" : {
+            "description" : "Provide additional information about an SpdxElement.",
+            "type" : "array",
+            "items" : {
+              "type" : "object",
+              "properties" : {
+                "annotationDate" : {
+                  "description" : "Identify when the comment was made. This is to be specified according to the combined date and time in the UTC format, as specified in the ISO 8601 standard.",
+                  "type" : "string"
+                },
+                "annotationType" : {
+                  "description" : "Type of the annotation.",
+                  "type" : "string",
+                  "enum" : [ "OTHER", "REVIEW" ]
+                },
+                "annotator" : {
+                  "description" : "This field identifies the person, organization, or tool that has commented on a file, package, snippet, or the entire document.",
+                  "type" : "string"
+                },
+                "comment" : {
+                  "type" : "string"
+                }
+              },
+              "required" : [ "annotationDate", "annotationType", "annotator", "comment" ],
+              "additionalProperties" : false,
+              "description" : "An Annotation is a comment on an SpdxItem by an agent."
+            }
+          },
+          "attributionTexts" : {
+            "description" : "This field provides a place for the SPDX data creator to record acknowledgements that may be required to be communicated in some contexts. This is not meant to include the actual complete license text (see licenseConculded and licenseDeclared), and may or may not include copyright notices (see also copyrightText). The SPDX data creator may use this field to record other acknowledgements, such as particular clauses from license texts, which may be necessary or desirable to reproduce.",
+            "type" : "array",
+            "items" : {
+              "description" : "This field provides a place for the SPDX data creator to record acknowledgements that may be required to be communicated in some contexts. This is not meant to include the actual complete license text (see licenseConculded and licenseDeclared), and may or may not include copyright notices (see also copyrightText). The SPDX data creator may use this field to record other acknowledgements, such as particular clauses from license texts, which may be necessary or desirable to reproduce.",
+              "type" : "string"
+            }
+          },
+          "comment" : {
+            "type" : "string"
+          },
+          "copyrightText" : {
+            "description" : "The text of copyright declarations recited in the package, file or snippet.\n\nIf the copyrightText field is not present, it implies an equivalent meaning to NOASSERTION.",
+            "type" : "string"
+          },
+          "licenseComments" : {
+            "description" : "The licenseComments property allows the preparer of the SPDX document to describe why the licensing in spdx:licenseConcluded was chosen.",
+            "type" : "string"
+          },
+          "licenseConcluded" : {
+            "description" : "License expression for licenseConcluded. See SPDX Annex D for the license expression syntax.  The licensing that the preparer of this SPDX document has concluded, based on the evidence, actually applies to the SPDX Item.\n\nIf the licenseConcluded field is not present for an SPDX Item, it implies an equivalent meaning to NOASSERTION.",
+            "type" : "string"
+          },
+          "licenseInfoInSnippets" : {
+            "description" : "Licensing information that was discovered directly in the subject snippet. This is also considered a declared license for the snippet.\n\nIf the licenseInfoInSnippet field is not present for a snippet, it implies an equivalent meaning to NOASSERTION.",
+            "type" : "array",
+            "items" : {
+              "description" : "License expression for licenseInfoInSnippet. See SPDX Annex D for the license expression syntax.  Licensing information that was discovered directly in the subject snippet. This is also considered a declared license for the snippet.\n\nIf the licenseInfoInSnippet field is not present for a snippet, it implies an equivalent meaning to NOASSERTION.",
+              "type" : "string"
+            }
+          },
+          "name" : {
+            "description" : "Identify name of this SpdxElement.",
+            "type" : "string"
+          },
+          "ranges" : {
+            "description" : "This field defines the byte range in the original host file (in X.2) that the snippet information applies to",
+            "minItems" : 1,
+            "type" : "array",
+            "items" : {
+              "type" : "object",
+              "properties" : {
+                "endPointer" : {
+                  "type" : "object",
+                  "properties" : {
+                    "reference" : {
+                      "description" : "SPDX ID for File",
+                      "type" : "string"
+                    },
+                    "offset" : {
+                      "type" : "integer",
+                      "description" : "Byte offset in the file"
+                    },
+                    "lineNumber" : {
+                      "type" : "integer",
+                      "description" : "line number offset in the file"
+                    }
+                  },
+                  "required" : [ "reference" ],
+                  "additionalProperties" : false
+                },
+                "startPointer" : {
+                  "type" : "object",
+                  "properties" : {
+                    "reference" : {
+                      "description" : "SPDX ID for File",
+                      "type" : "string"
+                    },
+                    "offset" : {
+                      "type" : "integer",
+                      "description" : "Byte offset in the file"
+                    },
+                    "lineNumber" : {
+                      "type" : "integer",
+                      "description" : "line number offset in the file"
+                    }
+                  },
+                  "required" : [ "reference" ],
+                  "additionalProperties" : false
+                }
+              },
+              "required" : [ "endPointer", "startPointer" ],
+              "additionalProperties" : false
+            }
+          },
+          "snippetFromFile" : {
+            "description" : "SPDX ID for File.  File containing the SPDX element (e.g. the file contaning a snippet).",
+            "type" : "string"
+          }
+        },
+        "required" : [ "SPDXID", "name", "ranges", "snippetFromFile" ],
+        "additionalProperties" : false
+      }
+    },
+    "relationships" : {
+      "description" : "Relationships referenced in the SPDX document",
+      "type" : "array",
+      "items" : {
+        "type" : "object",
+        "properties" : {
+          "spdxElementId" : {
+            "type" : "string",
+            "description" : "Id to which the SPDX element is related"
+          },
+          "comment" : {
+            "type" : "string"
+          },
+          "relatedSpdxElement" : {
+            "description" : "SPDX ID for SpdxElement.  A related SpdxElement.",
+            "type" : "string"
+          },
+          "relationshipType" : {
+            "description" : "Describes the type of relationship between two SPDX elements.",
+            "type" : "string",
+            "enum" : [ "VARIANT_OF", "COPY_OF", "PATCH_FOR", "TEST_DEPENDENCY_OF", "CONTAINED_BY", "DATA_FILE_OF", "OPTIONAL_COMPONENT_OF", "ANCESTOR_OF", "GENERATES", "CONTAINS", "OPTIONAL_DEPENDENCY_OF", "FILE_ADDED", "REQUIREMENT_DESCRIPTION_FOR", "DEV_DEPENDENCY_OF", "DEPENDENCY_OF", "BUILD_DEPENDENCY_OF", "DESCRIBES", "PREREQUISITE_FOR", "HAS_PREREQUISITE", "PROVIDED_DEPENDENCY_OF", "DYNAMIC_LINK", "DESCRIBED_BY", "METAFILE_OF", "DEPENDENCY_MANIFEST_OF", "PATCH_APPLIED", "RUNTIME_DEPENDENCY_OF", "TEST_OF", "TEST_TOOL_OF", "DEPENDS_ON", "SPECIFICATION_FOR", "FILE_MODIFIED", "DISTRIBUTION_ARTIFACT", "AMENDS", "DOCUMENTATION_OF", "GENERATED_FROM", "STATIC_LINK", "OTHER", "BUILD_TOOL_OF", "TEST_CASE_OF", "PACKAGE_OF", "DESCENDANT_OF", "FILE_DELETED", "EXPANDED_FROM_ARCHIVE", "DEV_TOOL_OF", "EXAMPLE_OF" ]
+          }
+        },
+        "required" : [ "spdxElementId", "relatedSpdxElement", "relationshipType" ],
+        "additionalProperties" : false
+      }
+    }
+  },
+  "required" : [ "SPDXID", "creationInfo", "dataLicense", "name", "spdxVersion", "documentNamespace" ],
+  "additionalProperties" : false
+}
diff --git a/Library/Homebrew/data/spdx/spdx_exceptions.json b/Library/Homebrew/data/spdx/spdx_exceptions.json
index 62f5e044c82de..1b48b052bf384 100644
--- a/Library/Homebrew/data/spdx/spdx_exceptions.json
+++ b/Library/Homebrew/data/spdx/spdx_exceptions.json
@@ -1,22 +1,129 @@
 {
-  "licenseListVersion": "3.17",
+  "licenseListVersion": "3.25.0",
   "exceptions": [
     {
-      "reference": "./FLTK-exception.json",
+      "reference": "./389-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./FLTK-exception.html",
-      "referenceNumber": 1,
-      "name": "FLTK exception",
-      "licenseExceptionId": "FLTK-exception",
+      "detailsUrl": "./389-exception.html",
+      "referenceNumber": 53,
+      "name": "389 Directory Server Exception",
+      "licenseExceptionId": "389-exception",
       "seeAlso": [
-        "http://www.fltk.org/COPYING.php"
+        "http://directory.fedoraproject.org/wiki/GPL_Exception_License_Text",
+        "https://web.archive.org/web/20080828121337/http://directory.fedoraproject.org/wiki/GPL_Exception_License_Text"
+      ]
+    },
+    {
+      "reference": "./Asterisk-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./Asterisk-exception.html",
+      "referenceNumber": 60,
+      "name": "Asterisk exception",
+      "licenseExceptionId": "Asterisk-exception",
+      "seeAlso": [
+        "https://github.com/asterisk/libpri/blob/7f91151e6bd10957c746c031c1f4a030e8146e9a/pri.c#L22",
+        "https://github.com/asterisk/libss7/blob/03e81bcd0d28ff25d4c77c78351ddadc82ff5c3f/ss7.c#L24"
+      ]
+    },
+    {
+      "reference": "./Asterisk-linking-protocols-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./Asterisk-linking-protocols-exception.html",
+      "referenceNumber": 24,
+      "name": "Asterisk linking protocols exception",
+      "licenseExceptionId": "Asterisk-linking-protocols-exception",
+      "seeAlso": [
+        "https://github.com/asterisk/asterisk/blob/115d7c01e32ccf4566a99e9d74e2b88830985a0b/LICENSE#L27"
+      ]
+    },
+    {
+      "reference": "./Autoconf-exception-2.0.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./Autoconf-exception-2.0.html",
+      "referenceNumber": 72,
+      "name": "Autoconf exception 2.0",
+      "licenseExceptionId": "Autoconf-exception-2.0",
+      "seeAlso": [
+        "http://ac-archive.sourceforge.net/doc/copyright.html",
+        "http://ftp.gnu.org/gnu/autoconf/autoconf-2.59.tar.gz"
+      ]
+    },
+    {
+      "reference": "./Autoconf-exception-3.0.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./Autoconf-exception-3.0.html",
+      "referenceNumber": 17,
+      "name": "Autoconf exception 3.0",
+      "licenseExceptionId": "Autoconf-exception-3.0",
+      "seeAlso": [
+        "http://www.gnu.org/licenses/autoconf-exception-3.0.html"
+      ]
+    },
+    {
+      "reference": "./Autoconf-exception-generic.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./Autoconf-exception-generic.html",
+      "referenceNumber": 48,
+      "name": "Autoconf generic exception",
+      "licenseExceptionId": "Autoconf-exception-generic",
+      "seeAlso": [
+        "https://launchpad.net/ubuntu/precise/+source/xmltooling/+copyright",
+        "https://tracker.debian.org/media/packages/s/sipwitch/copyright-1.9.15-3",
+        "https://opensource.apple.com/source/launchd/launchd-258.1/launchd/compile.auto.html",
+        "https://git.savannah.gnu.org/gitweb/?p\u003dgnulib.git;a\u003dblob;f\u003dgnulib-tool;h\u003d029a8cf377ad8d8f2d9e54061bf2f20496ad2eef;hb\u003d73c74ba0197e6566da6882c87b1adee63e24d75c#l407"
+      ]
+    },
+    {
+      "reference": "./Autoconf-exception-generic-3.0.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./Autoconf-exception-generic-3.0.html",
+      "referenceNumber": 64,
+      "name": "Autoconf generic exception for GPL-3.0",
+      "licenseExceptionId": "Autoconf-exception-generic-3.0",
+      "seeAlso": [
+        "https://src.fedoraproject.org/rpms/redhat-rpm-config/blob/rawhide/f/config.guess"
+      ]
+    },
+    {
+      "reference": "./Autoconf-exception-macro.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./Autoconf-exception-macro.html",
+      "referenceNumber": 51,
+      "name": "Autoconf macro exception",
+      "licenseExceptionId": "Autoconf-exception-macro",
+      "seeAlso": [
+        "https://github.com/freedesktop/xorg-macros/blob/39f07f7db58ebbf3dcb64a2bf9098ed5cf3d1223/xorg-macros.m4.in",
+        "https://www.gnu.org/software/autoconf-archive/ax_pthread.html",
+        "https://launchpad.net/ubuntu/precise/+source/xmltooling/+copyright"
+      ]
+    },
+    {
+      "reference": "./Bison-exception-1.24.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./Bison-exception-1.24.html",
+      "referenceNumber": 59,
+      "name": "Bison exception 1.24",
+      "licenseExceptionId": "Bison-exception-1.24",
+      "seeAlso": [
+        "https://github.com/arineng/rwhoisd/blob/master/rwhoisd/mkdb/y.tab.c#L180"
+      ]
+    },
+    {
+      "reference": "./Bison-exception-2.2.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./Bison-exception-2.2.html",
+      "referenceNumber": 21,
+      "name": "Bison exception 2.2",
+      "licenseExceptionId": "Bison-exception-2.2",
+      "seeAlso": [
+        "http://git.savannah.gnu.org/cgit/bison.git/tree/data/yacc.c?id\u003d193d7c7054ba7197b0789e14965b739162319b5e#n141"
       ]
     },
     {
       "reference": "./Bootloader-exception.json",
       "isDeprecatedLicenseId": false,
       "detailsUrl": "./Bootloader-exception.html",
-      "referenceNumber": 2,
+      "referenceNumber": 40,
       "name": "Bootloader Distribution Exception",
       "licenseExceptionId": "Bootloader-exception",
       "seeAlso": [
@@ -24,65 +131,162 @@
       ]
     },
     {
-      "reference": "./WxWindows-exception-3.1.json",
+      "reference": "./Classpath-exception-2.0.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./WxWindows-exception-3.1.html",
-      "referenceNumber": 3,
-      "name": "WxWindows Library Exception 3.1",
-      "licenseExceptionId": "WxWindows-exception-3.1",
+      "detailsUrl": "./Classpath-exception-2.0.html",
+      "referenceNumber": 34,
+      "name": "Classpath exception 2.0",
+      "licenseExceptionId": "Classpath-exception-2.0",
       "seeAlso": [
-        "http://www.opensource.org/licenses/WXwindows"
+        "http://www.gnu.org/software/classpath/license.html",
+        "https://fedoraproject.org/wiki/Licensing/GPL_Classpath_Exception"
       ]
     },
     {
-      "reference": "./Linux-syscall-note.json",
+      "reference": "./CLISP-exception-2.0.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./Linux-syscall-note.html",
-      "referenceNumber": 4,
-      "name": "Linux Syscall Note",
-      "licenseExceptionId": "Linux-syscall-note",
+      "detailsUrl": "./CLISP-exception-2.0.html",
+      "referenceNumber": 71,
+      "name": "CLISP exception 2.0",
+      "licenseExceptionId": "CLISP-exception-2.0",
       "seeAlso": [
-        "https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/COPYING"
+        "http://sourceforge.net/p/clisp/clisp/ci/default/tree/COPYRIGHT"
       ]
     },
     {
-      "reference": "./Qt-LGPL-exception-1.1.json",
+      "reference": "./cryptsetup-OpenSSL-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./Qt-LGPL-exception-1.1.html",
+      "detailsUrl": "./cryptsetup-OpenSSL-exception.html",
       "referenceNumber": 5,
-      "name": "Qt LGPL exception 1.1",
-      "licenseExceptionId": "Qt-LGPL-exception-1.1",
+      "name": "cryptsetup OpenSSL exception",
+      "licenseExceptionId": "cryptsetup-OpenSSL-exception",
       "seeAlso": [
-        "http://code.qt.io/cgit/qt/qtbase.git/tree/LGPL_EXCEPTION.txt"
+        "https://gitlab.com/cryptsetup/cryptsetup/-/blob/main/COPYING",
+        "https://gitlab.nic.cz/datovka/datovka/-/blob/develop/COPYING",
+        "https://github.com/nbs-system/naxsi/blob/951123ad456bdf5ac94e8d8819342fe3d49bc002/naxsi_src/naxsi_raw.c",
+        "http://web.mit.edu/jgross/arch/amd64_deb60/bin/mosh",
+        "https://sourceforge.net/p/linux-ima/ima-evm-utils/ci/master/tree/src/evmctl.c#l30"
       ]
     },
     {
-      "reference": "./LLVM-exception.json",
+      "reference": "./DigiRule-FOSS-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./LLVM-exception.html",
-      "referenceNumber": 6,
-      "name": "LLVM Exception",
-      "licenseExceptionId": "LLVM-exception",
+      "detailsUrl": "./DigiRule-FOSS-exception.html",
+      "referenceNumber": 66,
+      "name": "DigiRule FOSS License Exception",
+      "licenseExceptionId": "DigiRule-FOSS-exception",
       "seeAlso": [
-        "http://llvm.org/foundation/relicensing/LICENSE.txt"
+        "http://www.digirulesolutions.com/drupal/foss"
       ]
     },
     {
-      "reference": "./PS-or-PDF-font-exception-20170817.json",
+      "reference": "./eCos-exception-2.0.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./PS-or-PDF-font-exception-20170817.html",
-      "referenceNumber": 7,
-      "name": "PS/PDF font exception (2017-08-17)",
-      "licenseExceptionId": "PS-or-PDF-font-exception-20170817",
+      "detailsUrl": "./eCos-exception-2.0.html",
+      "referenceNumber": 35,
+      "name": "eCos exception 2.0",
+      "licenseExceptionId": "eCos-exception-2.0",
       "seeAlso": [
-        "https://github.com/ArtifexSoftware/urw-base35-fonts/blob/65962e27febc3883a17e651cdb23e783668c996f/LICENSE"
+        "http://ecos.sourceware.org/license-overview.html"
+      ]
+    },
+    {
+      "reference": "./erlang-otp-linking-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./erlang-otp-linking-exception.html",
+      "referenceNumber": 46,
+      "name": "Erlang/OTP Linking Exception",
+      "licenseExceptionId": "erlang-otp-linking-exception",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/gpl-faq.en.html#GPLIncompatibleLibs",
+        "https://erlang.org/pipermail/erlang-questions/2012-May/066355.html",
+        "https://gitea.osmocom.org/erlang/osmo_ss7/src/commit/2286c1b8738d715950026650bf53f19a69d6ed0e/src/ss7_links.erl#L20"
+      ]
+    },
+    {
+      "reference": "./Fawkes-Runtime-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./Fawkes-Runtime-exception.html",
+      "referenceNumber": 23,
+      "name": "Fawkes Runtime Exception",
+      "licenseExceptionId": "Fawkes-Runtime-exception",
+      "seeAlso": [
+        "http://www.fawkesrobotics.org/about/license/"
+      ]
+    },
+    {
+      "reference": "./FLTK-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./FLTK-exception.html",
+      "referenceNumber": 9,
+      "name": "FLTK exception",
+      "licenseExceptionId": "FLTK-exception",
+      "seeAlso": [
+        "http://www.fltk.org/COPYING.php"
+      ]
+    },
+    {
+      "reference": "./fmt-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./fmt-exception.html",
+      "referenceNumber": 69,
+      "name": "fmt exception",
+      "licenseExceptionId": "fmt-exception",
+      "seeAlso": [
+        "https://github.com/fmtlib/fmt/blob/master/LICENSE",
+        "https://github.com/fmtlib/fmt/blob/2eb363297b24cd71a68ccfb20ff755430f17e60f/LICENSE#L22C1-L27C62"
+      ]
+    },
+    {
+      "reference": "./Font-exception-2.0.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./Font-exception-2.0.html",
+      "referenceNumber": 19,
+      "name": "Font exception 2.0",
+      "licenseExceptionId": "Font-exception-2.0",
+      "seeAlso": [
+        "http://www.gnu.org/licenses/gpl-faq.html#FontException"
+      ]
+    },
+    {
+      "reference": "./freertos-exception-2.0.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./freertos-exception-2.0.html",
+      "referenceNumber": 54,
+      "name": "FreeRTOS Exception 2.0",
+      "licenseExceptionId": "freertos-exception-2.0",
+      "seeAlso": [
+        "https://web.archive.org/web/20060809182744/http://www.freertos.org/a00114.html"
+      ]
+    },
+    {
+      "reference": "./GCC-exception-2.0.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./GCC-exception-2.0.html",
+      "referenceNumber": 14,
+      "name": "GCC Runtime Library exception 2.0",
+      "licenseExceptionId": "GCC-exception-2.0",
+      "seeAlso": [
+        "https://gcc.gnu.org/git/?p\u003dgcc.git;a\u003dblob;f\u003dgcc/libgcc1.c;h\u003d762f5143fc6eed57b6797c82710f3538aa52b40b;hb\u003dcb143a3ce4fb417c68f5fa2691a1b1b1053dfba9#l10",
+        "https://sourceware.org/git/?p\u003dglibc.git;a\u003dblob;f\u003dcsu/abi-note.c;h\u003dc2ec208e94fbe91f63d3c375bd254b884695d190;hb\u003dHEAD"
+      ]
+    },
+    {
+      "reference": "./GCC-exception-2.0-note.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./GCC-exception-2.0-note.html",
+      "referenceNumber": 55,
+      "name": "GCC    Runtime Library exception 2.0 - note variant",
+      "licenseExceptionId": "GCC-exception-2.0-note",
+      "seeAlso": [
+        "https://sourceware.org/git/?p\u003dglibc.git;a\u003dblob;f\u003dsysdeps/x86_64/start.S"
       ]
     },
     {
       "reference": "./GCC-exception-3.1.json",
       "isDeprecatedLicenseId": false,
       "detailsUrl": "./GCC-exception-3.1.html",
-      "referenceNumber": 8,
+      "referenceNumber": 6,
       "name": "GCC Runtime Library exception 3.1",
       "licenseExceptionId": "GCC-exception-3.1",
       "seeAlso": [
@@ -90,21 +294,156 @@
       ]
     },
     {
-      "reference": "./Autoconf-exception-3.0.json",
+      "reference": "./Gmsh-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./Autoconf-exception-3.0.html",
-      "referenceNumber": 9,
-      "name": "Autoconf exception 3.0",
-      "licenseExceptionId": "Autoconf-exception-3.0",
+      "detailsUrl": "./Gmsh-exception.html",
+      "referenceNumber": 58,
+      "name": "Gmsh exception\u003e",
+      "licenseExceptionId": "Gmsh-exception",
       "seeAlso": [
-        "http://www.gnu.org/licenses/autoconf-exception-3.0.html"
+        "https://gitlab.onelab.info/gmsh/gmsh/-/raw/master/LICENSE.txt"
+      ]
+    },
+    {
+      "reference": "./GNAT-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./GNAT-exception.html",
+      "referenceNumber": 26,
+      "name": "GNAT exception",
+      "licenseExceptionId": "GNAT-exception",
+      "seeAlso": [
+        "https://github.com/AdaCore/florist/blob/master/libsrc/posix-configurable_file_limits.adb"
+      ]
+    },
+    {
+      "reference": "./GNOME-examples-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./GNOME-examples-exception.html",
+      "referenceNumber": 12,
+      "name": "GNOME examples exception",
+      "licenseExceptionId": "GNOME-examples-exception",
+      "seeAlso": [
+        "https://gitlab.gnome.org/Archive/gnome-devel-docs/-/blob/master/platform-demos/C/legal.xml?ref_type\u003dheads",
+        "http://meldmerge.org/help/"
+      ]
+    },
+    {
+      "reference": "./GNU-compiler-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./GNU-compiler-exception.html",
+      "referenceNumber": 18,
+      "name": "GNU Compiler Exception",
+      "licenseExceptionId": "GNU-compiler-exception",
+      "seeAlso": [
+        "https://sourceware.org/git?p\u003dbinutils-gdb.git;a\u003dblob;f\u003dlibiberty/unlink-if-ordinary.c;h\u003de49f2f2f67bfdb10d6b2bd579b0e01cad0fd708e;hb\u003dHEAD#l19"
+      ]
+    },
+    {
+      "reference": "./gnu-javamail-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./gnu-javamail-exception.html",
+      "referenceNumber": 43,
+      "name": "GNU JavaMail exception",
+      "licenseExceptionId": "gnu-javamail-exception",
+      "seeAlso": [
+        "http://www.gnu.org/software/classpathx/javamail/javamail.html"
+      ]
+    },
+    {
+      "reference": "./GPL-3.0-interface-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./GPL-3.0-interface-exception.html",
+      "referenceNumber": 28,
+      "name": "GPL-3.0 Interface Exception",
+      "licenseExceptionId": "GPL-3.0-interface-exception",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/gpl-faq.en.html#LinkingOverControlledInterface"
+      ]
+    },
+    {
+      "reference": "./GPL-3.0-linking-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./GPL-3.0-linking-exception.html",
+      "referenceNumber": 45,
+      "name": "GPL-3.0 Linking Exception",
+      "licenseExceptionId": "GPL-3.0-linking-exception",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/gpl-faq.en.html#GPLIncompatibleLibs"
+      ]
+    },
+    {
+      "reference": "./GPL-3.0-linking-source-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./GPL-3.0-linking-source-exception.html",
+      "referenceNumber": 39,
+      "name": "GPL-3.0 Linking Exception (with Corresponding Source)",
+      "licenseExceptionId": "GPL-3.0-linking-source-exception",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/gpl-faq.en.html#GPLIncompatibleLibs",
+        "https://github.com/mirror/wget/blob/master/src/http.c#L20"
+      ]
+    },
+    {
+      "reference": "./GPL-CC-1.0.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./GPL-CC-1.0.html",
+      "referenceNumber": 27,
+      "name": "GPL Cooperation Commitment 1.0",
+      "licenseExceptionId": "GPL-CC-1.0",
+      "seeAlso": [
+        "https://github.com/gplcc/gplcc/blob/master/Project/COMMITMENT",
+        "https://gplcc.github.io/gplcc/Project/README-PROJECT.html"
+      ]
+    },
+    {
+      "reference": "./GStreamer-exception-2005.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./GStreamer-exception-2005.html",
+      "referenceNumber": 63,
+      "name": "GStreamer Exception (2005)",
+      "licenseExceptionId": "GStreamer-exception-2005",
+      "seeAlso": [
+        "https://gstreamer.freedesktop.org/documentation/frequently-asked-questions/licensing.html?gi-language\u003dc#licensing-of-applications-using-gstreamer"
+      ]
+    },
+    {
+      "reference": "./GStreamer-exception-2008.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./GStreamer-exception-2008.html",
+      "referenceNumber": 30,
+      "name": "GStreamer Exception (2008)",
+      "licenseExceptionId": "GStreamer-exception-2008",
+      "seeAlso": [
+        "https://gstreamer.freedesktop.org/documentation/frequently-asked-questions/licensing.html?gi-language\u003dc#licensing-of-applications-using-gstreamer"
+      ]
+    },
+    {
+      "reference": "./i2p-gpl-java-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./i2p-gpl-java-exception.html",
+      "referenceNumber": 36,
+      "name": "i2p GPL+Java Exception",
+      "licenseExceptionId": "i2p-gpl-java-exception",
+      "seeAlso": [
+        "http://geti2p.net/en/get-involved/develop/licenses#java_exception"
+      ]
+    },
+    {
+      "reference": "./KiCad-libraries-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./KiCad-libraries-exception.html",
+      "referenceNumber": 10,
+      "name": "KiCad Libraries Exception",
+      "licenseExceptionId": "KiCad-libraries-exception",
+      "seeAlso": [
+        "https://www.kicad.org/libraries/license/"
       ]
     },
     {
       "reference": "./LGPL-3.0-linking-exception.json",
       "isDeprecatedLicenseId": false,
       "detailsUrl": "./LGPL-3.0-linking-exception.html",
-      "referenceNumber": 10,
+      "referenceNumber": 31,
       "name": "LGPL-3.0 Linking Exception",
       "licenseExceptionId": "LGPL-3.0-linking-exception",
       "seeAlso": [
@@ -114,145 +453,202 @@
       ]
     },
     {
-      "reference": "./GCC-exception-2.0.json",
+      "reference": "./libpri-OpenH323-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./GCC-exception-2.0.html",
-      "referenceNumber": 11,
-      "name": "GCC Runtime Library exception 2.0",
-      "licenseExceptionId": "GCC-exception-2.0",
+      "detailsUrl": "./libpri-OpenH323-exception.html",
+      "referenceNumber": 15,
+      "name": "libpri OpenH323 exception",
+      "licenseExceptionId": "libpri-OpenH323-exception",
       "seeAlso": [
-        "https://gcc.gnu.org/git/?p\u003dgcc.git;a\u003dblob;f\u003dgcc/libgcc1.c;h\u003d762f5143fc6eed57b6797c82710f3538aa52b40b;hb\u003dcb143a3ce4fb417c68f5fa2691a1b1b1053dfba9#l10"
+        "https://github.com/asterisk/libpri/blob/1.6.0/README#L19-L22"
       ]
     },
     {
-      "reference": "./Bison-exception-2.2.json",
+      "reference": "./Libtool-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./Bison-exception-2.2.html",
-      "referenceNumber": 12,
-      "name": "Bison exception 2.2",
-      "licenseExceptionId": "Bison-exception-2.2",
+      "detailsUrl": "./Libtool-exception.html",
+      "referenceNumber": 20,
+      "name": "Libtool Exception",
+      "licenseExceptionId": "Libtool-exception",
+      "seeAlso": [
+        "http://git.savannah.gnu.org/cgit/libtool.git/tree/m4/libtool.m4",
+        "https://git.savannah.gnu.org/cgit/libtool.git/tree/libltdl/lt__alloc.c#n15"
+      ]
+    },
+    {
+      "reference": "./Linux-syscall-note.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./Linux-syscall-note.html",
+      "referenceNumber": 52,
+      "name": "Linux Syscall Note",
+      "licenseExceptionId": "Linux-syscall-note",
+      "seeAlso": [
+        "https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/COPYING"
+      ]
+    },
+    {
+      "reference": "./LLGPL.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./LLGPL.html",
+      "referenceNumber": 37,
+      "name": "LLGPL Preamble",
+      "licenseExceptionId": "LLGPL",
+      "seeAlso": [
+        "http://opensource.franz.com/preamble.html"
+      ]
+    },
+    {
+      "reference": "./LLVM-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./LLVM-exception.html",
+      "referenceNumber": 1,
+      "name": "LLVM Exception",
+      "licenseExceptionId": "LLVM-exception",
+      "seeAlso": [
+        "http://llvm.org/foundation/relicensing/LICENSE.txt"
+      ]
+    },
+    {
+      "reference": "./LZMA-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./LZMA-exception.html",
+      "referenceNumber": 61,
+      "name": "LZMA exception",
+      "licenseExceptionId": "LZMA-exception",
+      "seeAlso": [
+        "http://nsis.sourceforge.net/Docs/AppendixI.html#I.6"
+      ]
+    },
+    {
+      "reference": "./mif-exception.json",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "./mif-exception.html",
+      "referenceNumber": 7,
+      "name": "Macros and Inline Functions Exception",
+      "licenseExceptionId": "mif-exception",
       "seeAlso": [
-        "http://git.savannah.gnu.org/cgit/bison.git/tree/data/yacc.c?id\u003d193d7c7054ba7197b0789e14965b739162319b5e#n141"
+        "http://www.scs.stanford.edu/histar/src/lib/cppsup/exception",
+        "http://dev.bertos.org/doxygen/",
+        "https://www.threadingbuildingblocks.org/licensing"
       ]
     },
     {
-      "reference": "./openvpn-openssl-exception.json",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "./openvpn-openssl-exception.html",
+      "reference": "./Nokia-Qt-exception-1.1.json",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "./Nokia-Qt-exception-1.1.html",
       "referenceNumber": 13,
-      "name": "OpenVPN OpenSSL Exception",
-      "licenseExceptionId": "openvpn-openssl-exception",
+      "name": "Nokia Qt LGPL exception 1.1",
+      "licenseExceptionId": "Nokia-Qt-exception-1.1",
       "seeAlso": [
-        "http://openvpn.net/index.php/license.html"
+        "https://www.keepassx.org/dev/projects/keepassx/repository/revisions/b8dfb9cc4d5133e0f09cd7533d15a4f1c19a40f2/entry/LICENSE.NOKIA-LGPL-EXCEPTION"
       ]
     },
     {
-      "reference": "./Libtool-exception.json",
+      "reference": "./OCaml-LGPL-linking-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./Libtool-exception.html",
-      "referenceNumber": 14,
-      "name": "Libtool Exception",
-      "licenseExceptionId": "Libtool-exception",
+      "detailsUrl": "./OCaml-LGPL-linking-exception.html",
+      "referenceNumber": 2,
+      "name": "OCaml LGPL Linking Exception",
+      "licenseExceptionId": "OCaml-LGPL-linking-exception",
       "seeAlso": [
-        "http://git.savannah.gnu.org/cgit/libtool.git/tree/m4/libtool.m4"
+        "https://caml.inria.fr/ocaml/license.en.html"
       ]
     },
     {
-      "reference": "./Autoconf-exception-2.0.json",
+      "reference": "./OCCT-exception-1.0.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./Autoconf-exception-2.0.html",
-      "referenceNumber": 15,
-      "name": "Autoconf exception 2.0",
-      "licenseExceptionId": "Autoconf-exception-2.0",
+      "detailsUrl": "./OCCT-exception-1.0.html",
+      "referenceNumber": 49,
+      "name": "Open CASCADE Exception 1.0",
+      "licenseExceptionId": "OCCT-exception-1.0",
       "seeAlso": [
-        "http://ac-archive.sourceforge.net/doc/copyright.html",
-        "http://ftp.gnu.org/gnu/autoconf/autoconf-2.59.tar.gz"
+        "http://www.opencascade.com/content/licensing"
       ]
     },
     {
-      "reference": "./GPL-3.0-linking-source-exception.json",
+      "reference": "./OpenJDK-assembly-exception-1.0.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./GPL-3.0-linking-source-exception.html",
-      "referenceNumber": 16,
-      "name": "GPL-3.0 Linking Exception (with Corresponding Source)",
-      "licenseExceptionId": "GPL-3.0-linking-source-exception",
+      "detailsUrl": "./OpenJDK-assembly-exception-1.0.html",
+      "referenceNumber": 44,
+      "name": "OpenJDK Assembly exception 1.0",
+      "licenseExceptionId": "OpenJDK-assembly-exception-1.0",
       "seeAlso": [
-        "https://www.gnu.org/licenses/gpl-faq.en.html#GPLIncompatibleLibs",
-        "https://github.com/mirror/wget/blob/master/src/http.c#L20"
+        "http://openjdk.java.net/legal/assembly-exception.html"
       ]
     },
     {
-      "reference": "./GPL-CC-1.0.json",
+      "reference": "./openvpn-openssl-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./GPL-CC-1.0.html",
-      "referenceNumber": 17,
-      "name": "GPL Cooperation Commitment 1.0",
-      "licenseExceptionId": "GPL-CC-1.0",
+      "detailsUrl": "./openvpn-openssl-exception.html",
+      "referenceNumber": 29,
+      "name": "OpenVPN OpenSSL Exception",
+      "licenseExceptionId": "openvpn-openssl-exception",
       "seeAlso": [
-        "https://github.com/gplcc/gplcc/blob/master/Project/COMMITMENT",
-        "https://gplcc.github.io/gplcc/Project/README-PROJECT.html"
+        "http://openvpn.net/index.php/license.html",
+        "https://github.com/psycopg/psycopg2/blob/2_9_3/LICENSE#L14"
       ]
     },
     {
-      "reference": "./OCaml-LGPL-linking-exception.json",
+      "reference": "./PCRE2-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./OCaml-LGPL-linking-exception.html",
-      "referenceNumber": 18,
-      "name": "OCaml LGPL Linking Exception",
-      "licenseExceptionId": "OCaml-LGPL-linking-exception",
+      "detailsUrl": "./PCRE2-exception.html",
+      "referenceNumber": 8,
+      "name": "PCRE2 exception",
+      "licenseExceptionId": "PCRE2-exception",
       "seeAlso": [
-        "https://caml.inria.fr/ocaml/license.en.html"
+        "https://www.pcre.org/licence.txt"
       ]
     },
     {
-      "reference": "./Universal-FOSS-exception-1.0.json",
+      "reference": "./PS-or-PDF-font-exception-20170817.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./Universal-FOSS-exception-1.0.html",
-      "referenceNumber": 19,
-      "name": "Universal FOSS Exception, Version 1.0",
-      "licenseExceptionId": "Universal-FOSS-exception-1.0",
+      "detailsUrl": "./PS-or-PDF-font-exception-20170817.html",
+      "referenceNumber": 16,
+      "name": "PS/PDF font exception (2017-08-17)",
+      "licenseExceptionId": "PS-or-PDF-font-exception-20170817",
       "seeAlso": [
-        "https://oss.oracle.com/licenses/universal-foss-exception/"
+        "https://github.com/ArtifexSoftware/urw-base35-fonts/blob/65962e27febc3883a17e651cdb23e783668c996f/LICENSE"
       ]
     },
     {
-      "reference": "./i2p-gpl-java-exception.json",
+      "reference": "./QPL-1.0-INRIA-2004-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./i2p-gpl-java-exception.html",
-      "referenceNumber": 20,
-      "name": "i2p GPL+Java Exception",
-      "licenseExceptionId": "i2p-gpl-java-exception",
+      "detailsUrl": "./QPL-1.0-INRIA-2004-exception.html",
+      "referenceNumber": 68,
+      "name": "INRIA QPL 1.0 2004 variant exception",
+      "licenseExceptionId": "QPL-1.0-INRIA-2004-exception",
       "seeAlso": [
-        "http://geti2p.net/en/get-involved/develop/licenses#java_exception"
+        "https://git.frama-c.com/pub/frama-c/-/blob/master/licenses/Q_MODIFIED_LICENSE",
+        "https://github.com/maranget/hevea/blob/master/LICENSE"
       ]
     },
     {
-      "reference": "./CLISP-exception-2.0.json",
+      "reference": "./Qt-GPL-exception-1.0.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./CLISP-exception-2.0.html",
-      "referenceNumber": 21,
-      "name": "CLISP exception 2.0",
-      "licenseExceptionId": "CLISP-exception-2.0",
+      "detailsUrl": "./Qt-GPL-exception-1.0.html",
+      "referenceNumber": 50,
+      "name": "Qt GPL exception 1.0",
+      "licenseExceptionId": "Qt-GPL-exception-1.0",
       "seeAlso": [
-        "http://sourceforge.net/p/clisp/clisp/ci/default/tree/COPYRIGHT"
+        "http://code.qt.io/cgit/qt/qtbase.git/tree/LICENSE.GPL3-EXCEPT"
       ]
     },
     {
-      "reference": "./OCCT-exception-1.0.json",
+      "reference": "./Qt-LGPL-exception-1.1.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./OCCT-exception-1.0.html",
-      "referenceNumber": 22,
-      "name": "Open CASCADE Exception 1.0",
-      "licenseExceptionId": "OCCT-exception-1.0",
+      "detailsUrl": "./Qt-LGPL-exception-1.1.html",
+      "referenceNumber": 38,
+      "name": "Qt LGPL exception 1.1",
+      "licenseExceptionId": "Qt-LGPL-exception-1.1",
       "seeAlso": [
-        "http://www.opencascade.com/content/licensing"
+        "http://code.qt.io/cgit/qt/qtbase.git/tree/LGPL_EXCEPTION.txt"
       ]
     },
     {
       "reference": "./Qwt-exception-1.0.json",
       "isDeprecatedLicenseId": false,
       "detailsUrl": "./Qwt-exception-1.0.html",
-      "referenceNumber": 23,
+      "referenceNumber": 25,
       "name": "Qwt exception 1.0",
       "licenseExceptionId": "Qwt-exception-1.0",
       "seeAlso": [
@@ -260,65 +656,62 @@
       ]
     },
     {
-      "reference": "./gnu-javamail-exception.json",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "./gnu-javamail-exception.html",
-      "referenceNumber": 24,
-      "name": "GNU JavaMail exception",
-      "licenseExceptionId": "gnu-javamail-exception",
-      "seeAlso": [
-        "http://www.gnu.org/software/classpathx/javamail/javamail.html"
-      ]
-    },
-    {
-      "reference": "./u-boot-exception-2.0.json",
+      "reference": "./romic-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./u-boot-exception-2.0.html",
-      "referenceNumber": 25,
-      "name": "U-Boot exception 2.0",
-      "licenseExceptionId": "u-boot-exception-2.0",
+      "detailsUrl": "./romic-exception.html",
+      "referenceNumber": 22,
+      "name": "Romic Exception",
+      "licenseExceptionId": "romic-exception",
       "seeAlso": [
-        "http://git.denx.de/?p\u003du-boot.git;a\u003dblob;f\u003dLicenses/Exceptions"
+        "https://web.archive.org/web/20210124015834/http://mo.morsi.org/blog/2009/08/13/lesser_affero_gplv3/",
+        "https://sourceforge.net/p/romic/code/ci/3ab2856180cf0d8b007609af53154cf092efc58f/tree/COPYING",
+        "https://github.com/moll/node-mitm/blob/bbf24b8bd7596dc6e091e625363161ce91984fc7/LICENSE#L8-L11",
+        "https://github.com/zenbones/SmallMind/blob/3c62b5995fe7f27c453f140ff9b60560a0893f2a/COPYRIGHT#L25-L30",
+        "https://github.com/CubeArtisan/cubeartisan/blob/2c6ab53455237b88a3ea07be02a838a135c4ab79/LICENSE.LESSER#L10-L15",
+        "https://github.com/savearray2/py.js/blob/b781273c08c8afa89f4954de4ecf42ec01429bae/README.md#license"
       ]
     },
     {
-      "reference": "./freertos-exception-2.0.json",
+      "reference": "./RRDtool-FLOSS-exception-2.0.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./freertos-exception-2.0.html",
-      "referenceNumber": 26,
-      "name": "FreeRTOS Exception 2.0",
-      "licenseExceptionId": "freertos-exception-2.0",
+      "detailsUrl": "./RRDtool-FLOSS-exception-2.0.html",
+      "referenceNumber": 4,
+      "name": "RRDtool FLOSS exception 2.0",
+      "licenseExceptionId": "RRDtool-FLOSS-exception-2.0",
       "seeAlso": [
-        "https://web.archive.org/web/20060809182744/http://www.freertos.org/a00114.html"
+        "https://github.com/oetiker/rrdtool-1.x/blob/master/COPYRIGHT#L25-L90",
+        "https://oss.oetiker.ch/rrdtool/license.en.html"
       ]
     },
     {
-      "reference": "./Qt-GPL-exception-1.0.json",
+      "reference": "./SANE-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./Qt-GPL-exception-1.0.html",
-      "referenceNumber": 27,
-      "name": "Qt GPL exception 1.0",
-      "licenseExceptionId": "Qt-GPL-exception-1.0",
+      "detailsUrl": "./SANE-exception.html",
+      "referenceNumber": 11,
+      "name": "SANE Exception",
+      "licenseExceptionId": "SANE-exception",
       "seeAlso": [
-        "http://code.qt.io/cgit/qt/qtbase.git/tree/LICENSE.GPL3-EXCEPT"
+        "https://github.com/alexpevzner/sane-airscan/blob/master/LICENSE",
+        "https://gitlab.com/sane-project/backends/-/blob/master/sanei/sanei_pp.c?ref_type\u003dheads",
+        "https://gitlab.com/sane-project/frontends/-/blob/master/sanei/sanei_codec_ascii.c?ref_type\u003dheads"
       ]
     },
     {
-      "reference": "./OpenJDK-assembly-exception-1.0.json",
+      "reference": "./SHL-2.0.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./OpenJDK-assembly-exception-1.0.html",
-      "referenceNumber": 28,
-      "name": "OpenJDK Assembly exception 1.0",
-      "licenseExceptionId": "OpenJDK-assembly-exception-1.0",
+      "detailsUrl": "./SHL-2.0.html",
+      "referenceNumber": 56,
+      "name": "Solderpad Hardware License v2.0",
+      "licenseExceptionId": "SHL-2.0",
       "seeAlso": [
-        "http://openjdk.java.net/legal/assembly-exception.html"
+        "https://solderpad.org/licenses/SHL-2.0/"
       ]
     },
     {
       "reference": "./SHL-2.1.json",
       "isDeprecatedLicenseId": false,
       "detailsUrl": "./SHL-2.1.html",
-      "referenceNumber": 29,
+      "referenceNumber": 65,
       "name": "Solderpad Hardware License v2.1",
       "licenseExceptionId": "SHL-2.1",
       "seeAlso": [
@@ -326,34 +719,32 @@
       ]
     },
     {
-      "reference": "./mif-exception.json",
+      "reference": "./stunnel-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./mif-exception.html",
-      "referenceNumber": 30,
-      "name": "Macros and Inline Functions Exception",
-      "licenseExceptionId": "mif-exception",
+      "detailsUrl": "./stunnel-exception.html",
+      "referenceNumber": 70,
+      "name": "stunnel Exception",
+      "licenseExceptionId": "stunnel-exception",
       "seeAlso": [
-        "http://www.scs.stanford.edu/histar/src/lib/cppsup/exception",
-        "http://dev.bertos.org/doxygen/",
-        "https://www.threadingbuildingblocks.org/licensing"
+        "https://github.com/mtrojnar/stunnel/blob/master/COPYING.md"
       ]
     },
     {
-      "reference": "./Fawkes-Runtime-exception.json",
+      "reference": "./SWI-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./Fawkes-Runtime-exception.html",
-      "referenceNumber": 31,
-      "name": "Fawkes Runtime Exception",
-      "licenseExceptionId": "Fawkes-Runtime-exception",
+      "detailsUrl": "./SWI-exception.html",
+      "referenceNumber": 41,
+      "name": "SWI exception",
+      "licenseExceptionId": "SWI-exception",
       "seeAlso": [
-        "http://www.fawkesrobotics.org/about/license/"
+        "https://github.com/SWI-Prolog/packages-clpqr/blob/bfa80b9270274f0800120d5b8e6fef42ac2dc6a5/clpqr/class.pl"
       ]
     },
     {
       "reference": "./Swift-exception.json",
       "isDeprecatedLicenseId": false,
       "detailsUrl": "./Swift-exception.html",
-      "referenceNumber": 32,
+      "referenceNumber": 33,
       "name": "Swift Exception",
       "licenseExceptionId": "Swift-exception",
       "seeAlso": [
@@ -362,105 +753,84 @@
       ]
     },
     {
-      "reference": "./GPL-3.0-linking-exception.json",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "./GPL-3.0-linking-exception.html",
-      "referenceNumber": 33,
-      "name": "GPL-3.0 Linking Exception",
-      "licenseExceptionId": "GPL-3.0-linking-exception",
-      "seeAlso": [
-        "https://www.gnu.org/licenses/gpl-faq.en.html#GPLIncompatibleLibs"
-      ]
-    },
-    {
-      "reference": "./SHL-2.0.json",
+      "reference": "./Texinfo-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./SHL-2.0.html",
-      "referenceNumber": 34,
-      "name": "Solderpad Hardware License v2.0",
-      "licenseExceptionId": "SHL-2.0",
+      "detailsUrl": "./Texinfo-exception.html",
+      "referenceNumber": 67,
+      "name": "Texinfo exception",
+      "licenseExceptionId": "Texinfo-exception",
       "seeAlso": [
-        "https://solderpad.org/licenses/SHL-2.0/"
+        "https://git.savannah.gnu.org/cgit/automake.git/tree/lib/texinfo.tex?h\u003dv1.16.5#n23"
       ]
     },
     {
-      "reference": "./Classpath-exception-2.0.json",
+      "reference": "./u-boot-exception-2.0.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./Classpath-exception-2.0.html",
-      "referenceNumber": 35,
-      "name": "Classpath exception 2.0",
-      "licenseExceptionId": "Classpath-exception-2.0",
+      "detailsUrl": "./u-boot-exception-2.0.html",
+      "referenceNumber": 3,
+      "name": "U-Boot exception 2.0",
+      "licenseExceptionId": "u-boot-exception-2.0",
       "seeAlso": [
-        "http://www.gnu.org/software/classpath/license.html",
-        "https://fedoraproject.org/wiki/Licensing/GPL_Classpath_Exception"
+        "http://git.denx.de/?p\u003du-boot.git;a\u003dblob;f\u003dLicenses/Exceptions"
       ]
     },
     {
-      "reference": "./LZMA-exception.json",
+      "reference": "./UBDL-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./LZMA-exception.html",
-      "referenceNumber": 36,
-      "name": "LZMA exception",
-      "licenseExceptionId": "LZMA-exception",
+      "detailsUrl": "./UBDL-exception.html",
+      "referenceNumber": 62,
+      "name": "Unmodified Binary Distribution exception",
+      "licenseExceptionId": "UBDL-exception",
       "seeAlso": [
-        "http://nsis.sourceforge.net/Docs/AppendixI.html#I.6"
+        "https://github.com/ipxe/ipxe/blob/master/COPYING.UBDL"
       ]
     },
     {
-      "reference": "./Font-exception-2.0.json",
+      "reference": "./Universal-FOSS-exception-1.0.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./Font-exception-2.0.html",
-      "referenceNumber": 37,
-      "name": "Font exception 2.0",
-      "licenseExceptionId": "Font-exception-2.0",
-      "seeAlso": [
-        "http://www.gnu.org/licenses/gpl-faq.html#FontException"
-      ]
-    },
-    {
-      "reference": "./Nokia-Qt-exception-1.1.json",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "./Nokia-Qt-exception-1.1.html",
-      "referenceNumber": 38,
-      "name": "Nokia Qt LGPL exception 1.1",
-      "licenseExceptionId": "Nokia-Qt-exception-1.1",
+      "detailsUrl": "./Universal-FOSS-exception-1.0.html",
+      "referenceNumber": 42,
+      "name": "Universal FOSS Exception, Version 1.0",
+      "licenseExceptionId": "Universal-FOSS-exception-1.0",
       "seeAlso": [
-        "https://www.keepassx.org/dev/projects/keepassx/repository/revisions/b8dfb9cc4d5133e0f09cd7533d15a4f1c19a40f2/entry/LICENSE.NOKIA-LGPL-EXCEPTION"
+        "https://oss.oracle.com/licenses/universal-foss-exception/"
       ]
     },
     {
-      "reference": "./DigiRule-FOSS-exception.json",
+      "reference": "./vsftpd-openssl-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./DigiRule-FOSS-exception.html",
-      "referenceNumber": 39,
-      "name": "DigiRule FOSS License Exception",
-      "licenseExceptionId": "DigiRule-FOSS-exception",
+      "detailsUrl": "./vsftpd-openssl-exception.html",
+      "referenceNumber": 32,
+      "name": "vsftpd OpenSSL exception",
+      "licenseExceptionId": "vsftpd-openssl-exception",
       "seeAlso": [
-        "http://www.digirulesolutions.com/drupal/foss"
+        "https://git.stg.centos.org/source-git/vsftpd/blob/f727873674d9c9cd7afcae6677aa782eb54c8362/f/LICENSE",
+        "https://launchpad.net/debian/squeeze/+source/vsftpd/+copyright",
+        "https://github.com/richardcochran/vsftpd/blob/master/COPYING"
       ]
     },
     {
-      "reference": "./eCos-exception-2.0.json",
+      "reference": "./WxWindows-exception-3.1.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./eCos-exception-2.0.html",
-      "referenceNumber": 40,
-      "name": "eCos exception 2.0",
-      "licenseExceptionId": "eCos-exception-2.0",
+      "detailsUrl": "./WxWindows-exception-3.1.html",
+      "referenceNumber": 57,
+      "name": "WxWindows Library Exception 3.1",
+      "licenseExceptionId": "WxWindows-exception-3.1",
       "seeAlso": [
-        "http://ecos.sourceware.org/license-overview.html"
+        "http://www.opensource.org/licenses/WXwindows"
       ]
     },
     {
-      "reference": "./389-exception.json",
+      "reference": "./x11vnc-openssl-exception.json",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "./389-exception.html",
-      "referenceNumber": 41,
-      "name": "389 Directory Server Exception",
-      "licenseExceptionId": "389-exception",
+      "detailsUrl": "./x11vnc-openssl-exception.html",
+      "referenceNumber": 47,
+      "name": "x11vnc OpenSSL Exception",
+      "licenseExceptionId": "x11vnc-openssl-exception",
       "seeAlso": [
-        "http://directory.fedoraproject.org/wiki/GPL_Exception_License_Text"
+        "https://github.com/LibVNC/x11vnc/blob/master/src/8to24.c#L22"
       ]
     }
   ],
-  "releaseDate": "2022-05-08"
+  "releaseDate": "2024-08-19"
 }
\ No newline at end of file
diff --git a/Library/Homebrew/data/spdx/spdx_licenses.json b/Library/Homebrew/data/spdx/spdx_licenses.json
index a8fba9c425a79..6c1a1e1337c68 100644
--- a/Library/Homebrew/data/spdx/spdx_licenses.json
+++ b/Library/Homebrew/data/spdx/spdx_licenses.json
@@ -1,2111 +1,2030 @@
 {
-  "licenseListVersion": "3.17",
+  "licenseListVersion": "3.25.0",
   "licenses": [
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-ND-2.0.html",
+      "reference": "https://spdx.org/licenses/0BSD.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-ND-2.0.json",
-      "referenceNumber": 0,
-      "name": "Creative Commons Attribution Non Commercial No Derivatives 2.0 Generic",
-      "licenseId": "CC-BY-NC-ND-2.0",
+      "detailsUrl": "https://spdx.org/licenses/0BSD.json",
+      "referenceNumber": 582,
+      "name": "BSD Zero Clause License",
+      "licenseId": "0BSD",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-nd/2.0/legalcode"
+        "http://landley.net/toybox/license.html",
+        "https://opensource.org/licenses/0BSD"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/SGI-B-2.0.html",
+      "reference": "https://spdx.org/licenses/3D-Slicer-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SGI-B-2.0.json",
-      "referenceNumber": 1,
-      "name": "SGI Free Software License B v2.0",
-      "licenseId": "SGI-B-2.0",
+      "detailsUrl": "https://spdx.org/licenses/3D-Slicer-1.0.json",
+      "referenceNumber": 466,
+      "name": "3D Slicer License v1.0",
+      "licenseId": "3D-Slicer-1.0",
       "seeAlso": [
-        "http://oss.sgi.com/projects/FreeB/SGIFreeSWLicB.2.0.pdf"
+        "https://slicer.org/LICENSE",
+        "https://github.com/Slicer/Slicer/blob/main/License.txt"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LPPL-1.3c.html",
+      "reference": "https://spdx.org/licenses/AAL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LPPL-1.3c.json",
-      "referenceNumber": 2,
-      "name": "LaTeX Project Public License v1.3c",
-      "licenseId": "LPPL-1.3c",
+      "detailsUrl": "https://spdx.org/licenses/AAL.json",
+      "referenceNumber": 252,
+      "name": "Attribution Assurance License",
+      "licenseId": "AAL",
       "seeAlso": [
-        "http://www.latex-project.org/lppl/lppl-1-3c.txt",
-        "https://opensource.org/licenses/LPPL-1.3c"
+        "https://opensource.org/licenses/attribution"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/NIST-PD-fallback.html",
+      "reference": "https://spdx.org/licenses/Abstyles.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NIST-PD-fallback.json",
-      "referenceNumber": 3,
-      "name": "NIST Public Domain Notice with license fallback",
-      "licenseId": "NIST-PD-fallback",
+      "detailsUrl": "https://spdx.org/licenses/Abstyles.json",
+      "referenceNumber": 456,
+      "name": "Abstyles License",
+      "licenseId": "Abstyles",
       "seeAlso": [
-        "https://github.com/usnistgov/jsip/blob/59700e6926cbe96c5cdae897d9a7d2656b42abe3/LICENSE",
-        "https://github.com/usnistgov/fipy/blob/86aaa5c2ba2c6f1be19593c5986071cf6568cc34/LICENSE.rst"
+        "https://fedoraproject.org/wiki/Licensing/Abstyles"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/libtiff.html",
+      "reference": "https://spdx.org/licenses/AdaCore-doc.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/libtiff.json",
-      "referenceNumber": 4,
-      "name": "libtiff License",
-      "licenseId": "libtiff",
+      "detailsUrl": "https://spdx.org/licenses/AdaCore-doc.json",
+      "referenceNumber": 355,
+      "name": "AdaCore Doc License",
+      "licenseId": "AdaCore-doc",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/libtiff"
+        "https://github.com/AdaCore/xmlada/blob/master/docs/index.rst",
+        "https://github.com/AdaCore/gnatcoll-core/blob/master/docs/index.rst",
+        "https://github.com/AdaCore/gnatcoll-db/blob/master/docs/index.rst"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/XSkat.html",
+      "reference": "https://spdx.org/licenses/Adobe-2006.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/XSkat.json",
-      "referenceNumber": 5,
-      "name": "XSkat License",
-      "licenseId": "XSkat",
+      "detailsUrl": "https://spdx.org/licenses/Adobe-2006.json",
+      "referenceNumber": 128,
+      "name": "Adobe Systems Incorporated Source Code License Agreement",
+      "licenseId": "Adobe-2006",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/XSkat_License"
+        "https://fedoraproject.org/wiki/Licensing/AdobeLicense"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/PDDL-1.0.html",
+      "reference": "https://spdx.org/licenses/Adobe-Display-PostScript.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/PDDL-1.0.json",
-      "referenceNumber": 6,
-      "name": "Open Data Commons Public Domain Dedication \u0026 License 1.0",
-      "licenseId": "PDDL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/Adobe-Display-PostScript.json",
+      "referenceNumber": 433,
+      "name": "Adobe Display PostScript License",
+      "licenseId": "Adobe-Display-PostScript",
       "seeAlso": [
-        "http://opendatacommons.org/licenses/pddl/1.0/",
-        "https://opendatacommons.org/licenses/pddl/"
+        "https://gitlab.freedesktop.org/xorg/xserver/-/blob/master/COPYING?ref_type\u003dheads#L752"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/KiCad-libraries-exception.html",
+      "reference": "https://spdx.org/licenses/Adobe-Glyph.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/KiCad-libraries-exception.json",
-      "referenceNumber": 7,
-      "name": "KiCad Libraries Exception",
-      "licenseId": "KiCad-libraries-exception",
+      "detailsUrl": "https://spdx.org/licenses/Adobe-Glyph.json",
+      "referenceNumber": 125,
+      "name": "Adobe Glyph List License",
+      "licenseId": "Adobe-Glyph",
       "seeAlso": [
-        "https://www.kicad.org/libraries/license/"
+        "https://fedoraproject.org/wiki/Licensing/MIT#AdobeGlyph"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-1.0.html",
+      "reference": "https://spdx.org/licenses/Adobe-Utopia.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-1.0.json",
-      "referenceNumber": 8,
-      "name": "Creative Commons Attribution Non Commercial Share Alike 1.0 Generic",
-      "licenseId": "CC-BY-NC-SA-1.0",
+      "detailsUrl": "https://spdx.org/licenses/Adobe-Utopia.json",
+      "referenceNumber": 495,
+      "name": "Adobe Utopia Font License",
+      "licenseId": "Adobe-Utopia",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-sa/1.0/legalcode"
+        "https://gitlab.freedesktop.org/xorg/font/adobe-utopia-100dpi/-/blob/master/COPYING?ref_type\u003dheads"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.1-no-invariants-only.html",
+      "reference": "https://spdx.org/licenses/ADSL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.1-no-invariants-only.json",
-      "referenceNumber": 9,
-      "name": "GNU Free Documentation License v1.1 only - no invariants",
-      "licenseId": "GFDL-1.1-no-invariants-only",
+      "detailsUrl": "https://spdx.org/licenses/ADSL.json",
+      "referenceNumber": 560,
+      "name": "Amazon Digital Services License",
+      "licenseId": "ADSL",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/fdl-1.1.txt"
+        "https://fedoraproject.org/wiki/Licensing/AmazonDigitalServicesLicense"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Xerox.html",
+      "reference": "https://spdx.org/licenses/AFL-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Xerox.json",
-      "referenceNumber": 10,
-      "name": "Xerox License",
-      "licenseId": "Xerox",
+      "detailsUrl": "https://spdx.org/licenses/AFL-1.1.json",
+      "referenceNumber": 14,
+      "name": "Academic Free License v1.1",
+      "licenseId": "AFL-1.1",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Xerox"
+        "http://opensource.linux-mirror.org/licenses/afl-1.1.txt",
+        "http://wayback.archive.org/web/20021004124254/http://www.opensource.org/licenses/academic.php"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/LPPL-1.1.html",
+      "reference": "https://spdx.org/licenses/AFL-1.2.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LPPL-1.1.json",
-      "referenceNumber": 11,
-      "name": "LaTeX Project Public License v1.1",
-      "licenseId": "LPPL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/AFL-1.2.json",
+      "referenceNumber": 622,
+      "name": "Academic Free License v1.2",
+      "licenseId": "AFL-1.2",
       "seeAlso": [
-        "http://www.latex-project.org/lppl/lppl-1-1.txt"
+        "http://opensource.linux-mirror.org/licenses/afl-1.2.txt",
+        "http://wayback.archive.org/web/20021204204652/http://www.opensource.org/licenses/academic.php"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/VOSTROM.html",
+      "reference": "https://spdx.org/licenses/AFL-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/VOSTROM.json",
-      "referenceNumber": 12,
-      "name": "VOSTROM Public License for Open Source",
-      "licenseId": "VOSTROM",
+      "detailsUrl": "https://spdx.org/licenses/AFL-2.0.json",
+      "referenceNumber": 559,
+      "name": "Academic Free License v2.0",
+      "licenseId": "AFL-2.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/VOSTROM"
+        "http://wayback.archive.org/web/20060924134533/http://www.opensource.org/licenses/afl-2.0.txt"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/UCL-1.0.html",
+      "reference": "https://spdx.org/licenses/AFL-2.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/UCL-1.0.json",
-      "referenceNumber": 13,
-      "name": "Upstream Compatibility License v1.0",
-      "licenseId": "UCL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/AFL-2.1.json",
+      "referenceNumber": 570,
+      "name": "Academic Free License v2.1",
+      "licenseId": "AFL-2.1",
       "seeAlso": [
-        "https://opensource.org/licenses/UCL-1.0"
+        "http://opensource.linux-mirror.org/licenses/afl-2.1.txt"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/ADSL.html",
+      "reference": "https://spdx.org/licenses/AFL-3.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ADSL.json",
-      "referenceNumber": 14,
-      "name": "Amazon Digital Services License",
-      "licenseId": "ADSL",
+      "detailsUrl": "https://spdx.org/licenses/AFL-3.0.json",
+      "referenceNumber": 332,
+      "name": "Academic Free License v3.0",
+      "licenseId": "AFL-3.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/AmazonDigitalServicesLicense"
+        "http://www.rosenlaw.com/AFL3.0.htm",
+        "https://opensource.org/licenses/afl-3.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/OSL-2.0.html",
+      "reference": "https://spdx.org/licenses/Afmparse.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OSL-2.0.json",
-      "referenceNumber": 15,
-      "name": "Open Software License 2.0",
-      "licenseId": "OSL-2.0",
+      "detailsUrl": "https://spdx.org/licenses/Afmparse.json",
+      "referenceNumber": 163,
+      "name": "Afmparse License",
+      "licenseId": "Afmparse",
       "seeAlso": [
-        "http://web.archive.org/web/20041020171434/http://www.rosenlaw.com/osl2.0.html"
+        "https://fedoraproject.org/wiki/Licensing/Afmparse"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/AAL.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/AAL.json",
-      "referenceNumber": 16,
-      "name": "Attribution Assurance License",
-      "licenseId": "AAL",
+      "reference": "https://spdx.org/licenses/AGPL-1.0.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/AGPL-1.0.json",
+      "referenceNumber": 657,
+      "name": "Affero General Public License v1.0",
+      "licenseId": "AGPL-1.0",
       "seeAlso": [
-        "https://opensource.org/licenses/attribution"
+        "http://www.affero.org/oagpl.html"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/FDK-AAC.html",
+      "reference": "https://spdx.org/licenses/AGPL-1.0-only.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/FDK-AAC.json",
-      "referenceNumber": 17,
-      "name": "Fraunhofer FDK AAC Codec Library",
-      "licenseId": "FDK-AAC",
+      "detailsUrl": "https://spdx.org/licenses/AGPL-1.0-only.json",
+      "referenceNumber": 142,
+      "name": "Affero General Public License v1.0 only",
+      "licenseId": "AGPL-1.0-only",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/FDK-AAC",
-        "https://directory.fsf.org/wiki/License:Fdk"
+        "http://www.affero.org/oagpl.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/W3C-20150513.html",
+      "reference": "https://spdx.org/licenses/AGPL-1.0-or-later.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/W3C-20150513.json",
-      "referenceNumber": 18,
-      "name": "W3C Software Notice and Document License (2015-05-13)",
-      "licenseId": "W3C-20150513",
+      "detailsUrl": "https://spdx.org/licenses/AGPL-1.0-or-later.json",
+      "referenceNumber": 155,
+      "name": "Affero General Public License v1.0 or later",
+      "licenseId": "AGPL-1.0-or-later",
       "seeAlso": [
-        "https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document"
+        "http://www.affero.org/oagpl.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/AFL-1.1.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/AFL-1.1.json",
-      "referenceNumber": 19,
-      "name": "Academic Free License v1.1",
-      "licenseId": "AFL-1.1",
+      "reference": "https://spdx.org/licenses/AGPL-3.0.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/AGPL-3.0.json",
+      "referenceNumber": 70,
+      "name": "GNU Affero General Public License v3.0",
+      "licenseId": "AGPL-3.0",
       "seeAlso": [
-        "http://opensource.linux-mirror.org/licenses/afl-1.1.txt",
-        "http://wayback.archive.org/web/20021004124254/http://www.opensource.org/licenses/academic.php"
+        "https://www.gnu.org/licenses/agpl.txt",
+        "https://opensource.org/licenses/AGPL-3.0"
       ],
       "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/W3C.html",
+      "reference": "https://spdx.org/licenses/AGPL-3.0-only.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/W3C.json",
-      "referenceNumber": 20,
-      "name": "W3C Software Notice and License (2002-12-31)",
-      "licenseId": "W3C",
-      "seeAlso": [
-        "http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231.html",
-        "https://opensource.org/licenses/W3C"
+      "detailsUrl": "https://spdx.org/licenses/AGPL-3.0-only.json",
+      "referenceNumber": 330,
+      "name": "GNU Affero General Public License v3.0 only",
+      "licenseId": "AGPL-3.0-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/agpl.txt",
+        "https://opensource.org/licenses/AGPL-3.0"
       ],
       "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Sleepycat.html",
+      "reference": "https://spdx.org/licenses/AGPL-3.0-or-later.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Sleepycat.json",
-      "referenceNumber": 21,
-      "name": "Sleepycat License",
-      "licenseId": "Sleepycat",
+      "detailsUrl": "https://spdx.org/licenses/AGPL-3.0-or-later.json",
+      "referenceNumber": 366,
+      "name": "GNU Affero General Public License v3.0 or later",
+      "licenseId": "AGPL-3.0-or-later",
       "seeAlso": [
-        "https://opensource.org/licenses/Sleepycat"
+        "https://www.gnu.org/licenses/agpl.txt",
+        "https://opensource.org/licenses/AGPL-3.0"
       ],
       "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/CECILL-1.1.html",
+      "reference": "https://spdx.org/licenses/Aladdin.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CECILL-1.1.json",
-      "referenceNumber": 22,
-      "name": "CeCILL Free Software License Agreement v1.1",
-      "licenseId": "CECILL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/Aladdin.json",
+      "referenceNumber": 557,
+      "name": "Aladdin Free Public License",
+      "licenseId": "Aladdin",
       "seeAlso": [
-        "http://www.cecill.info/licences/Licence_CeCILL_V1.1-US.html"
+        "http://pages.cs.wisc.edu/~ghost/doc/AFPL/6.01/Public.htm"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/mpich2.html",
+      "reference": "https://spdx.org/licenses/AMD-newlib.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/mpich2.json",
-      "referenceNumber": 23,
-      "name": "mpich2 License",
-      "licenseId": "mpich2",
+      "detailsUrl": "https://spdx.org/licenses/AMD-newlib.json",
+      "referenceNumber": 340,
+      "name": "AMD newlib License",
+      "licenseId": "AMD-newlib",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/MIT"
+        "https://sourceware.org/git/?p\u003dnewlib-cygwin.git;a\u003dblob;f\u003dnewlib/libc/sys/a29khif/_close.S;h\u003d04f52ae00de1dafbd9055ad8d73c5c697a3aae7f;hb\u003dHEAD"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/SISSL.html",
+      "reference": "https://spdx.org/licenses/AMDPLPA.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SISSL.json",
-      "referenceNumber": 24,
-      "name": "Sun Industry Standards Source License v1.1",
-      "licenseId": "SISSL",
+      "detailsUrl": "https://spdx.org/licenses/AMDPLPA.json",
+      "referenceNumber": 467,
+      "name": "AMD\u0027s plpa_map.c License",
+      "licenseId": "AMDPLPA",
       "seeAlso": [
-        "http://www.openoffice.org/licenses/sissl_license.html",
-        "https://opensource.org/licenses/SISSL"
+        "https://fedoraproject.org/wiki/Licensing/AMD_plpa_map_License"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/NLOD-1.0.html",
+      "reference": "https://spdx.org/licenses/AML.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NLOD-1.0.json",
-      "referenceNumber": 25,
-      "name": "Norwegian Licence for Open Government Data (NLOD) 1.0",
-      "licenseId": "NLOD-1.0",
+      "detailsUrl": "https://spdx.org/licenses/AML.json",
+      "referenceNumber": 299,
+      "name": "Apple MIT License",
+      "licenseId": "AML",
       "seeAlso": [
-        "http://data.norge.no/nlod/en/1.0"
+        "https://fedoraproject.org/wiki/Licensing/Apple_MIT_License"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/ANTLR-PD.html",
+      "reference": "https://spdx.org/licenses/AML-glslang.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ANTLR-PD.json",
-      "referenceNumber": 26,
-      "name": "ANTLR Software Rights Notice",
-      "licenseId": "ANTLR-PD",
+      "detailsUrl": "https://spdx.org/licenses/AML-glslang.json",
+      "referenceNumber": 567,
+      "name": "AML glslang variant License",
+      "licenseId": "AML-glslang",
       "seeAlso": [
-        "http://www.antlr2.org/license.html"
+        "https://github.com/KhronosGroup/glslang/blob/main/LICENSE.txt#L949",
+        "https://docs.omniverse.nvidia.com/install-guide/latest/common/licenses.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-3.0-only.html",
+      "reference": "https://spdx.org/licenses/AMPAS.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GPL-3.0-only.json",
-      "referenceNumber": 27,
-      "name": "GNU General Public License v3.0 only",
-      "licenseId": "GPL-3.0-only",
+      "detailsUrl": "https://spdx.org/licenses/AMPAS.json",
+      "referenceNumber": 414,
+      "name": "Academy of Motion Picture Arts and Sciences BSD",
+      "licenseId": "AMPAS",
       "seeAlso": [
-        "https://www.gnu.org/licenses/gpl-3.0-standalone.html",
-        "https://opensource.org/licenses/GPL-3.0"
+        "https://fedoraproject.org/wiki/Licensing/BSD#AMPASBSD"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/gnuplot.html",
+      "reference": "https://spdx.org/licenses/ANTLR-PD.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/gnuplot.json",
-      "referenceNumber": 28,
-      "name": "gnuplot License",
-      "licenseId": "gnuplot",
+      "detailsUrl": "https://spdx.org/licenses/ANTLR-PD.json",
+      "referenceNumber": 460,
+      "name": "ANTLR Software Rights Notice",
+      "licenseId": "ANTLR-PD",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Gnuplot"
+        "http://www.antlr2.org/license.html"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/NLOD-2.0.html",
+      "reference": "https://spdx.org/licenses/ANTLR-PD-fallback.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NLOD-2.0.json",
-      "referenceNumber": 29,
-      "name": "Norwegian Licence for Open Government Data (NLOD) 2.0",
-      "licenseId": "NLOD-2.0",
+      "detailsUrl": "https://spdx.org/licenses/ANTLR-PD-fallback.json",
+      "referenceNumber": 65,
+      "name": "ANTLR Software Rights Notice with license fallback",
+      "licenseId": "ANTLR-PD-fallback",
       "seeAlso": [
-        "http://data.norge.no/nlod/en/2.0"
+        "http://www.antlr2.org/license.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-3-Clause-Open-MPI.html",
+      "reference": "https://spdx.org/licenses/any-OSI.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-Open-MPI.json",
-      "referenceNumber": 30,
-      "name": "BSD 3-Clause Open MPI variant",
-      "licenseId": "BSD-3-Clause-Open-MPI",
+      "detailsUrl": "https://spdx.org/licenses/any-OSI.json",
+      "referenceNumber": 310,
+      "name": "Any OSI License",
+      "licenseId": "any-OSI",
       "seeAlso": [
-        "https://www.open-mpi.org/community/license.php",
-        "http://www.netlib.org/lapack/LICENSE.txt"
+        "https://metacpan.org/pod/Exporter::Tidy#LICENSE"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LiLiQ-P-1.1.html",
+      "reference": "https://spdx.org/licenses/Apache-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LiLiQ-P-1.1.json",
-      "referenceNumber": 31,
-      "name": "Licence Libre du Québec – Permissive version 1.1",
-      "licenseId": "LiLiQ-P-1.1",
+      "detailsUrl": "https://spdx.org/licenses/Apache-1.0.json",
+      "referenceNumber": 250,
+      "name": "Apache License 1.0",
+      "licenseId": "Apache-1.0",
       "seeAlso": [
-        "https://forge.gouv.qc.ca/licence/fr/liliq-v1-1/",
-        "http://opensource.org/licenses/LiLiQ-P-1.1"
+        "http://www.apache.org/licenses/LICENSE-1.0"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-3-Clause-Clear.html",
+      "reference": "https://spdx.org/licenses/Apache-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-Clear.json",
-      "referenceNumber": 32,
-      "name": "BSD 3-Clause Clear License",
-      "licenseId": "BSD-3-Clause-Clear",
+      "detailsUrl": "https://spdx.org/licenses/Apache-1.1.json",
+      "referenceNumber": 288,
+      "name": "Apache License 1.1",
+      "licenseId": "Apache-1.1",
       "seeAlso": [
-        "http://labs.metacarta.com/license-explanation.html#license"
+        "http://apache.org/licenses/LICENSE-1.1",
+        "https://opensource.org/licenses/Apache-1.1"
       ],
-      "isOsiApproved": false,
+      "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/FSFUL.html",
+      "reference": "https://spdx.org/licenses/Apache-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/FSFUL.json",
-      "referenceNumber": 33,
-      "name": "FSF Unlimited License",
-      "licenseId": "FSFUL",
+      "detailsUrl": "https://spdx.org/licenses/Apache-2.0.json",
+      "referenceNumber": 143,
+      "name": "Apache License 2.0",
+      "licenseId": "Apache-2.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/FSF_Unlimited_License"
+        "https://www.apache.org/licenses/LICENSE-2.0",
+        "https://opensource.org/licenses/Apache-2.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-2.0-UK.html",
+      "reference": "https://spdx.org/licenses/APAFML.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-2.0-UK.json",
-      "referenceNumber": 34,
-      "name": "Creative Commons Attribution Non Commercial Share Alike 2.0 England and Wales",
-      "licenseId": "CC-BY-NC-SA-2.0-UK",
+      "detailsUrl": "https://spdx.org/licenses/APAFML.json",
+      "referenceNumber": 636,
+      "name": "Adobe Postscript AFM License",
+      "licenseId": "APAFML",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-sa/2.0/uk/legalcode"
+        "https://fedoraproject.org/wiki/Licensing/AdobePostscriptAFM"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CERN-OHL-S-2.0.html",
+      "reference": "https://spdx.org/licenses/APL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CERN-OHL-S-2.0.json",
-      "referenceNumber": 35,
-      "name": "CERN Open Hardware Licence Version 2 - Strongly Reciprocal",
-      "licenseId": "CERN-OHL-S-2.0",
+      "detailsUrl": "https://spdx.org/licenses/APL-1.0.json",
+      "referenceNumber": 85,
+      "name": "Adaptive Public License 1.0",
+      "licenseId": "APL-1.0",
       "seeAlso": [
-        "https://www.ohwr.org/project/cernohl/wikis/Documents/CERN-OHL-version-2"
+        "https://opensource.org/licenses/APL-1.0"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/Spencer-94.html",
+      "reference": "https://spdx.org/licenses/App-s2p.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Spencer-94.json",
-      "referenceNumber": 36,
-      "name": "Spencer License 94",
-      "licenseId": "Spencer-94",
+      "detailsUrl": "https://spdx.org/licenses/App-s2p.json",
+      "referenceNumber": 238,
+      "name": "App::s2p License",
+      "licenseId": "App-s2p",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Henry_Spencer_Reg-Ex_Library_License"
+        "https://fedoraproject.org/wiki/Licensing/App-s2p"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CERN-OHL-1.2.html",
+      "reference": "https://spdx.org/licenses/APSL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CERN-OHL-1.2.json",
-      "referenceNumber": 37,
-      "name": "CERN Open Hardware Licence v1.2",
-      "licenseId": "CERN-OHL-1.2",
+      "detailsUrl": "https://spdx.org/licenses/APSL-1.0.json",
+      "referenceNumber": 335,
+      "name": "Apple Public Source License 1.0",
+      "licenseId": "APSL-1.0",
       "seeAlso": [
-        "https://www.ohwr.org/project/licenses/wikis/cern-ohl-v1.2"
+        "https://fedoraproject.org/wiki/Licensing/Apple_Public_Source_License_1.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.1-or-later.html",
+      "reference": "https://spdx.org/licenses/APSL-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.1-or-later.json",
-      "referenceNumber": 38,
-      "name": "GNU Free Documentation License v1.1 or later",
-      "licenseId": "GFDL-1.1-or-later",
+      "detailsUrl": "https://spdx.org/licenses/APSL-1.1.json",
+      "referenceNumber": 308,
+      "name": "Apple Public Source License 1.1",
+      "licenseId": "APSL-1.1",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/fdl-1.1.txt"
+        "http://www.opensource.apple.com/source/IOSerialFamily/IOSerialFamily-7/APPLE_LICENSE"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/AGPL-1.0-or-later.html",
+      "reference": "https://spdx.org/licenses/APSL-1.2.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/AGPL-1.0-or-later.json",
-      "referenceNumber": 39,
-      "name": "Affero General Public License v1.0 or later",
-      "licenseId": "AGPL-1.0-or-later",
+      "detailsUrl": "https://spdx.org/licenses/APSL-1.2.json",
+      "referenceNumber": 280,
+      "name": "Apple Public Source License 1.2",
+      "licenseId": "APSL-1.2",
       "seeAlso": [
-        "http://www.affero.org/oagpl.html"
+        "http://www.samurajdata.se/opensource/mirror/licenses/apsl.php"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/Wsuipa.html",
+      "reference": "https://spdx.org/licenses/APSL-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Wsuipa.json",
-      "referenceNumber": 40,
-      "name": "Wsuipa License",
-      "licenseId": "Wsuipa",
+      "detailsUrl": "https://spdx.org/licenses/APSL-2.0.json",
+      "referenceNumber": 592,
+      "name": "Apple Public Source License 2.0",
+      "licenseId": "APSL-2.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Wsuipa"
+        "http://www.opensource.apple.com/license/apsl/"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/AML.html",
+      "reference": "https://spdx.org/licenses/Arphic-1999.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/AML.json",
-      "referenceNumber": 41,
-      "name": "Apple MIT License",
-      "licenseId": "AML",
+      "detailsUrl": "https://spdx.org/licenses/Arphic-1999.json",
+      "referenceNumber": 32,
+      "name": "Arphic Public License",
+      "licenseId": "Arphic-1999",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Apple_MIT_License"
+        "http://ftp.gnu.org/gnu/non-gnu/chinese-fonts-truetype/LICENSE"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-2-Clause.html",
+      "reference": "https://spdx.org/licenses/Artistic-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-2-Clause.json",
-      "referenceNumber": 42,
-      "name": "BSD 2-Clause \"Simplified\" License",
-      "licenseId": "BSD-2-Clause",
+      "detailsUrl": "https://spdx.org/licenses/Artistic-1.0.json",
+      "referenceNumber": 138,
+      "name": "Artistic License 1.0",
+      "licenseId": "Artistic-1.0",
       "seeAlso": [
-        "https://opensource.org/licenses/BSD-2-Clause"
+        "https://opensource.org/licenses/Artistic-1.0"
       ],
       "isOsiApproved": true,
-      "isFsfLibre": true
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/DSDP.html",
+      "reference": "https://spdx.org/licenses/Artistic-1.0-cl8.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/DSDP.json",
-      "referenceNumber": 43,
-      "name": "DSDP License",
-      "licenseId": "DSDP",
+      "detailsUrl": "https://spdx.org/licenses/Artistic-1.0-cl8.json",
+      "referenceNumber": 353,
+      "name": "Artistic License 1.0 w/clause 8",
+      "licenseId": "Artistic-1.0-cl8",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/DSDP"
+        "https://opensource.org/licenses/Artistic-1.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-2.5.html",
+      "reference": "https://spdx.org/licenses/Artistic-1.0-Perl.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-2.5.json",
-      "referenceNumber": 44,
-      "name": "Creative Commons Attribution 2.5 Generic",
-      "licenseId": "CC-BY-2.5",
+      "detailsUrl": "https://spdx.org/licenses/Artistic-1.0-Perl.json",
+      "referenceNumber": 660,
+      "name": "Artistic License 1.0 (Perl)",
+      "licenseId": "Artistic-1.0-Perl",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by/2.5/legalcode"
+        "http://dev.perl.org/licenses/artistic.html"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/MIT-CMU.html",
+      "reference": "https://spdx.org/licenses/Artistic-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MIT-CMU.json",
-      "referenceNumber": 45,
-      "name": "CMU License",
-      "licenseId": "MIT-CMU",
+      "detailsUrl": "https://spdx.org/licenses/Artistic-2.0.json",
+      "referenceNumber": 277,
+      "name": "Artistic License 2.0",
+      "licenseId": "Artistic-2.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing:MIT?rd\u003dLicensing/MIT#CMU_Style",
-        "https://github.com/python-pillow/Pillow/blob/fffb426092c8db24a5f4b6df243a8a3c01fb63cd/LICENSE"
+        "http://www.perlfoundation.org/artistic_license_2_0",
+        "https://www.perlfoundation.org/artistic-license-20.html",
+        "https://opensource.org/licenses/artistic-license-2.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Beerware.html",
+      "reference": "https://spdx.org/licenses/ASWF-Digital-Assets-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Beerware.json",
-      "referenceNumber": 46,
-      "name": "Beerware License",
-      "licenseId": "Beerware",
+      "detailsUrl": "https://spdx.org/licenses/ASWF-Digital-Assets-1.0.json",
+      "referenceNumber": 166,
+      "name": "ASWF Digital Assets License version 1.0",
+      "licenseId": "ASWF-Digital-Assets-1.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Beerware",
-        "https://people.freebsd.org/~phk/"
+        "https://github.com/AcademySoftwareFoundation/foundation/blob/main/digital_assets/aswf_digital_assets_license_v1.0.txt"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Sendmail.html",
+      "reference": "https://spdx.org/licenses/ASWF-Digital-Assets-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Sendmail.json",
-      "referenceNumber": 47,
-      "name": "Sendmail License",
-      "licenseId": "Sendmail",
+      "detailsUrl": "https://spdx.org/licenses/ASWF-Digital-Assets-1.1.json",
+      "referenceNumber": 29,
+      "name": "ASWF Digital Assets License 1.1",
+      "licenseId": "ASWF-Digital-Assets-1.1",
       "seeAlso": [
-        "http://www.sendmail.com/pdfs/open_source/sendmail_license.pdf",
-        "https://web.archive.org/web/20160322142305/https://www.sendmail.com/pdfs/open_source/sendmail_license.pdf"
+        "https://github.com/AcademySoftwareFoundation/foundation/blob/main/digital_assets/aswf_digital_assets_license_v1.1.txt"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/TU-Berlin-1.0.html",
+      "reference": "https://spdx.org/licenses/Baekmuk.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/TU-Berlin-1.0.json",
-      "referenceNumber": 48,
-      "name": "Technische Universitaet Berlin License 1.0",
-      "licenseId": "TU-Berlin-1.0",
+      "detailsUrl": "https://spdx.org/licenses/Baekmuk.json",
+      "referenceNumber": 380,
+      "name": "Baekmuk License",
+      "licenseId": "Baekmuk",
       "seeAlso": [
-        "https://github.com/swh/ladspa/blob/7bf6f3799fdba70fda297c2d8fd9f526803d9680/gsm/COPYRIGHT"
+        "https://fedoraproject.org/wiki/Licensing:Baekmuk?rd\u003dLicensing/Baekmuk"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CNRI-Jython.html",
+      "reference": "https://spdx.org/licenses/Bahyph.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CNRI-Jython.json",
-      "referenceNumber": 49,
-      "name": "CNRI Jython License",
-      "licenseId": "CNRI-Jython",
+      "detailsUrl": "https://spdx.org/licenses/Bahyph.json",
+      "referenceNumber": 368,
+      "name": "Bahyph License",
+      "licenseId": "Bahyph",
       "seeAlso": [
-        "http://www.jython.org/license.html"
+        "https://fedoraproject.org/wiki/Licensing/Bahyph"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/mplus.html",
+      "reference": "https://spdx.org/licenses/Barr.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/mplus.json",
-      "referenceNumber": 50,
-      "name": "mplus Font License",
-      "licenseId": "mplus",
+      "detailsUrl": "https://spdx.org/licenses/Barr.json",
+      "referenceNumber": 195,
+      "name": "Barr License",
+      "licenseId": "Barr",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing:Mplus?rd\u003dLicensing/mplus"
+        "https://fedoraproject.org/wiki/Licensing/Barr"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CPOL-1.02.html",
+      "reference": "https://spdx.org/licenses/bcrypt-Solar-Designer.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CPOL-1.02.json",
-      "referenceNumber": 51,
-      "name": "Code Project Open License 1.02",
-      "licenseId": "CPOL-1.02",
+      "detailsUrl": "https://spdx.org/licenses/bcrypt-Solar-Designer.json",
+      "referenceNumber": 478,
+      "name": "bcrypt Solar Designer License",
+      "licenseId": "bcrypt-Solar-Designer",
       "seeAlso": [
-        "http://www.codeproject.com/info/cpol10.aspx"
+        "https://github.com/bcrypt-ruby/bcrypt-ruby/blob/master/ext/mri/crypt_blowfish.c"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-3-Clause-No-Nuclear-License-2014.html",
+      "reference": "https://spdx.org/licenses/Beerware.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-No-Nuclear-License-2014.json",
-      "referenceNumber": 52,
-      "name": "BSD 3-Clause No Nuclear License 2014",
-      "licenseId": "BSD-3-Clause-No-Nuclear-License-2014",
+      "detailsUrl": "https://spdx.org/licenses/Beerware.json",
+      "referenceNumber": 616,
+      "name": "Beerware License",
+      "licenseId": "Beerware",
       "seeAlso": [
-        "https://java.net/projects/javaeetutorial/pages/BerkeleyLicense"
+        "https://fedoraproject.org/wiki/Licensing/Beerware",
+        "https://people.freebsd.org/~phk/"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/ISC.html",
+      "reference": "https://spdx.org/licenses/Bitstream-Charter.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ISC.json",
-      "referenceNumber": 53,
-      "name": "ISC License",
-      "licenseId": "ISC",
+      "detailsUrl": "https://spdx.org/licenses/Bitstream-Charter.json",
+      "referenceNumber": 455,
+      "name": "Bitstream Charter Font License",
+      "licenseId": "Bitstream-Charter",
       "seeAlso": [
-        "https://www.isc.org/licenses/",
-        "https://www.isc.org/downloads/software-support-policy/isc-license/",
-        "https://opensource.org/licenses/ISC"
+        "https://fedoraproject.org/wiki/Licensing/Charter#License_Text",
+        "https://raw.githubusercontent.com/blackhole89/notekit/master/data/fonts/Charter%20license.txt"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-SA-4.0.html",
+      "reference": "https://spdx.org/licenses/Bitstream-Vera.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-4.0.json",
-      "referenceNumber": 54,
-      "name": "Creative Commons Attribution Share Alike 4.0 International",
-      "licenseId": "CC-BY-SA-4.0",
+      "detailsUrl": "https://spdx.org/licenses/Bitstream-Vera.json",
+      "referenceNumber": 370,
+      "name": "Bitstream Vera Font License",
+      "licenseId": "Bitstream-Vera",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-sa/4.0/legalcode"
+        "https://web.archive.org/web/20080207013128/http://www.gnome.org/fonts/",
+        "https://docubrain.com/sites/default/files/licenses/bitstream-vera.html"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Eurosym.html",
+      "reference": "https://spdx.org/licenses/BitTorrent-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Eurosym.json",
-      "referenceNumber": 55,
-      "name": "Eurosym License",
-      "licenseId": "Eurosym",
+      "detailsUrl": "https://spdx.org/licenses/BitTorrent-1.0.json",
+      "referenceNumber": 106,
+      "name": "BitTorrent Open Source License v1.0",
+      "licenseId": "BitTorrent-1.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Eurosym"
+        "http://sources.gentoo.org/cgi-bin/viewvc.cgi/gentoo-x86/licenses/BitTorrent?r1\u003d1.1\u0026r2\u003d1.1.1.1\u0026diff_format\u003ds"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LGPL-3.0-only.html",
+      "reference": "https://spdx.org/licenses/BitTorrent-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LGPL-3.0-only.json",
-      "referenceNumber": 56,
-      "name": "GNU Lesser General Public License v3.0 only",
-      "licenseId": "LGPL-3.0-only",
+      "detailsUrl": "https://spdx.org/licenses/BitTorrent-1.1.json",
+      "referenceNumber": 541,
+      "name": "BitTorrent Open Source License v1.1",
+      "licenseId": "BitTorrent-1.1",
       "seeAlso": [
-        "https://www.gnu.org/licenses/lgpl-3.0-standalone.html",
-        "https://www.gnu.org/licenses/lgpl+gpl-3.0.txt",
-        "https://opensource.org/licenses/LGPL-3.0"
+        "http://directory.fsf.org/wiki/License:BitTorrentOSL1.1"
       ],
-      "isOsiApproved": true,
+      "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-1.3.html",
+      "reference": "https://spdx.org/licenses/blessing.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-1.3.json",
-      "referenceNumber": 57,
-      "name": "Open LDAP Public License v1.3",
-      "licenseId": "OLDAP-1.3",
+      "detailsUrl": "https://spdx.org/licenses/blessing.json",
+      "referenceNumber": 359,
+      "name": "SQLite Blessing",
+      "licenseId": "blessing",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003de5f8117f0ce088d0bd7a8e18ddf37eaa40eb09b1"
+        "https://www.sqlite.org/src/artifact/e33a4df7e32d742a?ln\u003d4-9",
+        "https://sqlite.org/src/artifact/df5091916dbb40e6"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.1-invariants-or-later.html",
+      "reference": "https://spdx.org/licenses/BlueOak-1.0.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.1-invariants-or-later.json",
-      "referenceNumber": 58,
-      "name": "GNU Free Documentation License v1.1 or later - invariants",
-      "licenseId": "GFDL-1.1-invariants-or-later",
+      "detailsUrl": "https://spdx.org/licenses/BlueOak-1.0.0.json",
+      "referenceNumber": 606,
+      "name": "Blue Oak Model License 1.0.0",
+      "licenseId": "BlueOak-1.0.0",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/fdl-1.1.txt"
+        "https://blueoakcouncil.org/license/1.0.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/Glulxe.html",
+      "reference": "https://spdx.org/licenses/Boehm-GC.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Glulxe.json",
-      "referenceNumber": 59,
-      "name": "Glulxe License",
-      "licenseId": "Glulxe",
+      "detailsUrl": "https://spdx.org/licenses/Boehm-GC.json",
+      "referenceNumber": 127,
+      "name": "Boehm-Demers-Weiser GC License",
+      "licenseId": "Boehm-GC",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Glulxe"
+        "https://fedoraproject.org/wiki/Licensing:MIT#Another_Minimal_variant_(found_in_libatomic_ops)",
+        "https://github.com/uim/libgcroots/blob/master/COPYING",
+        "https://github.com/ivmai/libatomic_ops/blob/master/LICENSE"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/SimPL-2.0.html",
+      "reference": "https://spdx.org/licenses/Borceux.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SimPL-2.0.json",
-      "referenceNumber": 60,
-      "name": "Simple Public License 2.0",
-      "licenseId": "SimPL-2.0",
+      "detailsUrl": "https://spdx.org/licenses/Borceux.json",
+      "referenceNumber": 571,
+      "name": "Borceux license",
+      "licenseId": "Borceux",
       "seeAlso": [
-        "https://opensource.org/licenses/SimPL-2.0"
+        "https://fedoraproject.org/wiki/Licensing/Borceux"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CDLA-Permissive-2.0.html",
+      "reference": "https://spdx.org/licenses/Brian-Gladman-2-Clause.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CDLA-Permissive-2.0.json",
-      "referenceNumber": 61,
-      "name": "Community Data License Agreement Permissive 2.0",
-      "licenseId": "CDLA-Permissive-2.0",
+      "detailsUrl": "https://spdx.org/licenses/Brian-Gladman-2-Clause.json",
+      "referenceNumber": 416,
+      "name": "Brian Gladman 2-Clause License",
+      "licenseId": "Brian-Gladman-2-Clause",
       "seeAlso": [
-        "https://cdla.dev/permissive-2-0"
+        "https://github.com/krb5/krb5/blob/krb5-1.21.2-final/NOTICE#L140-L156",
+        "https://web.mit.edu/kerberos/krb5-1.21/doc/mitK5license.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-2.0-with-font-exception.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GPL-2.0-with-font-exception.json",
-      "referenceNumber": 62,
-      "name": "GNU General Public License v2.0 w/Font exception",
-      "licenseId": "GPL-2.0-with-font-exception",
+      "reference": "https://spdx.org/licenses/Brian-Gladman-3-Clause.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Brian-Gladman-3-Clause.json",
+      "referenceNumber": 290,
+      "name": "Brian Gladman 3-Clause License",
+      "licenseId": "Brian-Gladman-3-Clause",
       "seeAlso": [
-        "https://www.gnu.org/licenses/gpl-faq.html#FontException"
+        "https://github.com/SWI-Prolog/packages-clib/blob/master/sha1/brg_endian.h"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OGL-UK-2.0.html",
+      "reference": "https://spdx.org/licenses/BSD-1-Clause.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OGL-UK-2.0.json",
-      "referenceNumber": 63,
-      "name": "Open Government Licence v2.0",
-      "licenseId": "OGL-UK-2.0",
+      "detailsUrl": "https://spdx.org/licenses/BSD-1-Clause.json",
+      "referenceNumber": 419,
+      "name": "BSD 1-Clause License",
+      "licenseId": "BSD-1-Clause",
       "seeAlso": [
-        "http://www.nationalarchives.gov.uk/doc/open-government-licence/version/2/"
+        "https://svnweb.freebsd.org/base/head/include/ifaddrs.h?revision\u003d326823"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-SA-3.0-DE.html",
+      "reference": "https://spdx.org/licenses/BSD-2-Clause.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-3.0-DE.json",
-      "referenceNumber": 64,
-      "name": "Creative Commons Attribution Share Alike 3.0 Germany",
-      "licenseId": "CC-BY-SA-3.0-DE",
+      "detailsUrl": "https://spdx.org/licenses/BSD-2-Clause.json",
+      "referenceNumber": 229,
+      "name": "BSD 2-Clause \"Simplified\" License",
+      "licenseId": "BSD-2-Clause",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-sa/3.0/de/legalcode"
+        "https://opensource.org/licenses/BSD-2-Clause"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-ND-1.0.html",
+      "reference": "https://spdx.org/licenses/BSD-2-Clause-Darwin.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-ND-1.0.json",
-      "referenceNumber": 65,
-      "name": "Creative Commons Attribution No Derivatives 1.0 Generic",
-      "licenseId": "CC-BY-ND-1.0",
+      "detailsUrl": "https://spdx.org/licenses/BSD-2-Clause-Darwin.json",
+      "referenceNumber": 296,
+      "name": "BSD 2-Clause - Ian Darwin variant",
+      "licenseId": "BSD-2-Clause-Darwin",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nd/1.0/legalcode"
+        "https://github.com/file/file/blob/master/COPYING"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.1.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.1.json",
-      "referenceNumber": 66,
-      "name": "GNU Free Documentation License v1.1",
-      "licenseId": "GFDL-1.1",
+      "reference": "https://spdx.org/licenses/BSD-2-Clause-first-lines.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/BSD-2-Clause-first-lines.json",
+      "referenceNumber": 217,
+      "name": "BSD 2-Clause - first lines requirement",
+      "licenseId": "BSD-2-Clause-first-lines",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/fdl-1.1.txt"
+        "https://github.com/krb5/krb5/blob/krb5-1.21.2-final/NOTICE#L664-L690",
+        "https://web.mit.edu/kerberos/krb5-1.21/doc/mitK5license.html"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-4.0.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-4.0.json",
-      "referenceNumber": 67,
-      "name": "Creative Commons Attribution 4.0 International",
-      "licenseId": "CC-BY-4.0",
+      "reference": "https://spdx.org/licenses/BSD-2-Clause-FreeBSD.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/BSD-2-Clause-FreeBSD.json",
+      "referenceNumber": 564,
+      "name": "BSD 2-Clause FreeBSD License",
+      "licenseId": "BSD-2-Clause-FreeBSD",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by/4.0/legalcode"
+        "http://www.freebsd.org/copyright/freebsd-license.html"
       ],
       "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/OpenSSL.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OpenSSL.json",
-      "referenceNumber": 68,
-      "name": "OpenSSL License",
-      "licenseId": "OpenSSL",
+      "reference": "https://spdx.org/licenses/BSD-2-Clause-NetBSD.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/BSD-2-Clause-NetBSD.json",
+      "referenceNumber": 376,
+      "name": "BSD 2-Clause NetBSD License",
+      "licenseId": "BSD-2-Clause-NetBSD",
       "seeAlso": [
-        "http://www.openssl.org/source/license.html"
+        "http://www.netbsd.org/about/redistribution.html#default"
       ],
       "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/TU-Berlin-2.0.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/TU-Berlin-2.0.json",
-      "referenceNumber": 69,
-      "name": "Technische Universitaet Berlin License 2.0",
-      "licenseId": "TU-Berlin-2.0",
-      "seeAlso": [
-        "https://github.com/CorsixTH/deps/blob/fd339a9f526d1d9c9f01ccf39e438a015da50035/licences/libgsm.txt"
-      ],
-      "isOsiApproved": false
-    },
-    {
-      "reference": "https://spdx.org/licenses/DOC.html",
+      "reference": "https://spdx.org/licenses/BSD-2-Clause-Patent.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/DOC.json",
-      "referenceNumber": 70,
-      "name": "DOC License",
-      "licenseId": "DOC",
+      "detailsUrl": "https://spdx.org/licenses/BSD-2-Clause-Patent.json",
+      "referenceNumber": 4,
+      "name": "BSD-2-Clause Plus Patent License",
+      "licenseId": "BSD-2-Clause-Patent",
       "seeAlso": [
-        "http://www.cs.wustl.edu/~schmidt/ACE-copying.html",
-        "https://www.dre.vanderbilt.edu/~schmidt/ACE-copying.html"
+        "https://opensource.org/licenses/BSDplusPatent"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.2-no-invariants-or-later.html",
+      "reference": "https://spdx.org/licenses/BSD-2-Clause-Views.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.2-no-invariants-or-later.json",
-      "referenceNumber": 71,
-      "name": "GNU Free Documentation License v1.2 or later - no invariants",
-      "licenseId": "GFDL-1.2-no-invariants-or-later",
+      "detailsUrl": "https://spdx.org/licenses/BSD-2-Clause-Views.json",
+      "referenceNumber": 514,
+      "name": "BSD 2-Clause with views sentence",
+      "licenseId": "BSD-2-Clause-Views",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/fdl-1.2.txt"
+        "http://www.freebsd.org/copyright/freebsd-license.html",
+        "https://people.freebsd.org/~ivoras/wine/patch-wine-nvidia.sh",
+        "https://github.com/protegeproject/protege/blob/master/license.txt"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/QPL-1.0.html",
+      "reference": "https://spdx.org/licenses/BSD-3-Clause.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/QPL-1.0.json",
-      "referenceNumber": 72,
-      "name": "Q Public License 1.0",
-      "licenseId": "QPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause.json",
+      "referenceNumber": 584,
+      "name": "BSD 3-Clause \"New\" or \"Revised\" License",
+      "licenseId": "BSD-3-Clause",
       "seeAlso": [
-        "http://doc.qt.nokia.com/3.3/license.html",
-        "https://opensource.org/licenses/QPL-1.0",
-        "https://doc.qt.io/archives/3.3/license.html"
+        "https://opensource.org/licenses/BSD-3-Clause",
+        "https://www.eclipse.org/org/documents/edl-v10.php"
       ],
       "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-2.8.html",
+      "reference": "https://spdx.org/licenses/BSD-3-Clause-acpica.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.8.json",
-      "referenceNumber": 73,
-      "name": "Open LDAP Public License v2.8",
-      "licenseId": "OLDAP-2.8",
+      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-acpica.json",
+      "referenceNumber": 341,
+      "name": "BSD 3-Clause acpica variant",
+      "licenseId": "BSD-3-Clause-acpica",
       "seeAlso": [
-        "http://www.openldap.org/software/release/license.html"
+        "https://github.com/acpica/acpica/blob/master/source/common/acfileio.c#L119"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OML.html",
+      "reference": "https://spdx.org/licenses/BSD-3-Clause-Attribution.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OML.json",
-      "referenceNumber": 74,
-      "name": "Open Market License",
-      "licenseId": "OML",
+      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-Attribution.json",
+      "referenceNumber": 71,
+      "name": "BSD with attribution",
+      "licenseId": "BSD-3-Clause-Attribution",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Open_Market_License"
+        "https://fedoraproject.org/wiki/Licensing/BSD_with_Attribution"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-2.7.html",
+      "reference": "https://spdx.org/licenses/BSD-3-Clause-Clear.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.7.json",
-      "referenceNumber": 75,
-      "name": "Open LDAP Public License v2.7",
-      "licenseId": "OLDAP-2.7",
+      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-Clear.json",
+      "referenceNumber": 253,
+      "name": "BSD 3-Clause Clear License",
+      "licenseId": "BSD-3-Clause-Clear",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d47c2415c1df81556eeb39be6cad458ef87c534a2"
+        "http://labs.metacarta.com/license-explanation.html#license"
       ],
       "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/NIST-PD.html",
+      "reference": "https://spdx.org/licenses/BSD-3-Clause-flex.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NIST-PD.json",
-      "referenceNumber": 76,
-      "name": "NIST Public Domain Notice",
-      "licenseId": "NIST-PD",
+      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-flex.json",
+      "referenceNumber": 52,
+      "name": "BSD 3-Clause Flex variant",
+      "licenseId": "BSD-3-Clause-flex",
       "seeAlso": [
-        "https://github.com/tcheneau/simpleRPL/blob/e645e69e38dd4e3ccfeceb2db8cba05b7c2e0cd3/LICENSE.txt",
-        "https://github.com/tcheneau/Routing/blob/f09f46fcfe636107f22f2c98348188a65a135d98/README.md"
+        "https://github.com/westes/flex/blob/master/COPYING"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Bitstream-Vera.html",
+      "reference": "https://spdx.org/licenses/BSD-3-Clause-HP.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Bitstream-Vera.json",
-      "referenceNumber": 77,
-      "name": "Bitstream Vera Font License",
-      "licenseId": "Bitstream-Vera",
+      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-HP.json",
+      "referenceNumber": 215,
+      "name": "Hewlett-Packard BSD variant license",
+      "licenseId": "BSD-3-Clause-HP",
       "seeAlso": [
-        "https://web.archive.org/web/20080207013128/http://www.gnome.org/fonts/",
-        "https://docubrain.com/sites/default/files/licenses/bitstream-vera.html"
+        "https://github.com/zdohnal/hplip/blob/master/COPYING#L939"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.2-or-later.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.2-or-later.json",
-      "referenceNumber": 78,
-      "name": "GNU Free Documentation License v1.2 or later",
-      "licenseId": "GFDL-1.2-or-later",
-      "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/fdl-1.2.txt"
-      ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
-    },
-    {
-      "reference": "https://spdx.org/licenses/OFL-1.1-RFN.html",
+      "reference": "https://spdx.org/licenses/BSD-3-Clause-LBNL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OFL-1.1-RFN.json",
-      "referenceNumber": 79,
-      "name": "SIL Open Font License 1.1 with Reserved Font Name",
-      "licenseId": "OFL-1.1-RFN",
+      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-LBNL.json",
+      "referenceNumber": 301,
+      "name": "Lawrence Berkeley National Labs BSD variant license",
+      "licenseId": "BSD-3-Clause-LBNL",
       "seeAlso": [
-        "http://scripts.sil.org/cms/scripts/page.php?item_id\u003dOFL_web",
-        "https://opensource.org/licenses/OFL-1.1"
+        "https://fedoraproject.org/wiki/Licensing/LBNLBSD"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/Bahyph.html",
+      "reference": "https://spdx.org/licenses/BSD-3-Clause-Modification.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Bahyph.json",
-      "referenceNumber": 80,
-      "name": "Bahyph License",
-      "licenseId": "Bahyph",
+      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-Modification.json",
+      "referenceNumber": 47,
+      "name": "BSD 3-Clause Modification",
+      "licenseId": "BSD-3-Clause-Modification",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Bahyph"
+        "https://fedoraproject.org/wiki/Licensing:BSD#Modification_Variant"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Barr.html",
+      "reference": "https://spdx.org/licenses/BSD-3-Clause-No-Military-License.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Barr.json",
-      "referenceNumber": 81,
-      "name": "Barr License",
-      "licenseId": "Barr",
+      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-No-Military-License.json",
+      "referenceNumber": 615,
+      "name": "BSD 3-Clause No Military License",
+      "licenseId": "BSD-3-Clause-No-Military-License",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Barr"
+        "https://gitlab.syncad.com/hive/dhive/-/blob/master/LICENSE",
+        "https://github.com/greymass/swift-eosio/blob/master/LICENSE"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/COIL-1.0.html",
+      "reference": "https://spdx.org/licenses/BSD-3-Clause-No-Nuclear-License.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/COIL-1.0.json",
-      "referenceNumber": 82,
-      "name": "Copyfree Open Innovation License",
-      "licenseId": "COIL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-No-Nuclear-License.json",
+      "referenceNumber": 647,
+      "name": "BSD 3-Clause No Nuclear License",
+      "licenseId": "BSD-3-Clause-No-Nuclear-License",
       "seeAlso": [
-        "https://coil.apotheon.org/plaintext/01.0.txt"
+        "http://download.oracle.com/otn-pub/java/licenses/bsd.txt"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.3.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.3.json",
-      "referenceNumber": 83,
-      "name": "GNU Free Documentation License v1.3",
-      "licenseId": "GFDL-1.3",
-      "seeAlso": [
-        "https://www.gnu.org/licenses/fdl-1.3.txt"
-      ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
-    },
-    {
-      "reference": "https://spdx.org/licenses/CECILL-B.html",
+      "reference": "https://spdx.org/licenses/BSD-3-Clause-No-Nuclear-License-2014.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CECILL-B.json",
-      "referenceNumber": 84,
-      "name": "CeCILL-B Free Software License Agreement",
-      "licenseId": "CECILL-B",
+      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-No-Nuclear-License-2014.json",
+      "referenceNumber": 377,
+      "name": "BSD 3-Clause No Nuclear License 2014",
+      "licenseId": "BSD-3-Clause-No-Nuclear-License-2014",
       "seeAlso": [
-        "http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html"
+        "https://java.net/projects/javaeetutorial/pages/BerkeleyLicense"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/JPNIC.html",
+      "reference": "https://spdx.org/licenses/BSD-3-Clause-No-Nuclear-Warranty.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/JPNIC.json",
-      "referenceNumber": 85,
-      "name": "Japan Network Information Center License",
-      "licenseId": "JPNIC",
+      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-No-Nuclear-Warranty.json",
+      "referenceNumber": 54,
+      "name": "BSD 3-Clause No Nuclear Warranty",
+      "licenseId": "BSD-3-Clause-No-Nuclear-Warranty",
       "seeAlso": [
-        "https://gitlab.isc.org/isc-projects/bind9/blob/master/COPYRIGHT#L366"
+        "https://jogamp.org/git/?p\u003dgluegen.git;a\u003dblob_plain;f\u003dLICENSE.txt"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Zed.html",
+      "reference": "https://spdx.org/licenses/BSD-3-Clause-Open-MPI.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Zed.json",
-      "referenceNumber": 86,
-      "name": "Zed License",
-      "licenseId": "Zed",
+      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-Open-MPI.json",
+      "referenceNumber": 633,
+      "name": "BSD 3-Clause Open MPI variant",
+      "licenseId": "BSD-3-Clause-Open-MPI",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Zed"
+        "https://www.open-mpi.org/community/license.php",
+        "http://www.netlib.org/lapack/LICENSE.txt"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/ICU.html",
+      "reference": "https://spdx.org/licenses/BSD-3-Clause-Sun.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ICU.json",
-      "referenceNumber": 87,
-      "name": "ICU License",
-      "licenseId": "ICU",
+      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-Sun.json",
+      "referenceNumber": 270,
+      "name": "BSD 3-Clause Sun Microsystems",
+      "licenseId": "BSD-3-Clause-Sun",
       "seeAlso": [
-        "http://source.icu-project.org/repos/icu/icu/trunk/license.html"
+        "https://github.com/xmlark/msv/blob/b9316e2f2270bc1606952ea4939ec87fbba157f3/xsdlib/src/main/java/com/sun/msv/datatype/regexp/InternalImpl.java"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-2.5.html",
+      "reference": "https://spdx.org/licenses/BSD-4-Clause.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-2.5.json",
-      "referenceNumber": 88,
-      "name": "Creative Commons Attribution Non Commercial Share Alike 2.5 Generic",
-      "licenseId": "CC-BY-NC-SA-2.5",
+      "detailsUrl": "https://spdx.org/licenses/BSD-4-Clause.json",
+      "referenceNumber": 470,
+      "name": "BSD 4-Clause \"Original\" or \"Old\" License",
+      "licenseId": "BSD-4-Clause",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-sa/2.5/legalcode"
+        "http://directory.fsf.org/wiki/License:BSD_4Clause"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-ND-3.0-DE.html",
+      "reference": "https://spdx.org/licenses/BSD-4-Clause-Shortened.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-ND-3.0-DE.json",
-      "referenceNumber": 89,
-      "name": "Creative Commons Attribution No Derivatives 3.0 Germany",
-      "licenseId": "CC-BY-ND-3.0-DE",
+      "detailsUrl": "https://spdx.org/licenses/BSD-4-Clause-Shortened.json",
+      "referenceNumber": 220,
+      "name": "BSD 4 Clause Shortened",
+      "licenseId": "BSD-4-Clause-Shortened",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nd/3.0/de/legalcode"
+        "https://metadata.ftp-master.debian.org/changelogs//main/a/arpwatch/arpwatch_2.1a15-7_copyright"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/bzip2-1.0.5.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/bzip2-1.0.5.json",
-      "referenceNumber": 90,
-      "name": "bzip2 and libbzip2 License v1.0.5",
-      "licenseId": "bzip2-1.0.5",
+      "reference": "https://spdx.org/licenses/BSD-4-Clause-UC.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/BSD-4-Clause-UC.json",
+      "referenceNumber": 175,
+      "name": "BSD-4-Clause (University of California-Specific)",
+      "licenseId": "BSD-4-Clause-UC",
       "seeAlso": [
-        "https://sourceware.org/bzip2/1.0.5/bzip2-manual-1.0.5.html",
-        "http://bzip.org/1.0.5/bzip2-manual-1.0.5.html"
+        "http://www.freebsd.org/copyright/license.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/SPL-1.0.html",
+      "reference": "https://spdx.org/licenses/BSD-4.3RENO.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SPL-1.0.json",
-      "referenceNumber": 91,
-      "name": "Sun Public License v1.0",
-      "licenseId": "SPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/BSD-4.3RENO.json",
+      "referenceNumber": 361,
+      "name": "BSD 4.3 RENO License",
+      "licenseId": "BSD-4.3RENO",
       "seeAlso": [
-        "https://opensource.org/licenses/SPL-1.0"
+        "https://sourceware.org/git/?p\u003dbinutils-gdb.git;a\u003dblob;f\u003dlibiberty/strcasecmp.c;h\u003d131d81c2ce7881fa48c363dc5bf5fb302c61ce0b;hb\u003dHEAD",
+        "https://git.openldap.org/openldap/openldap/-/blob/master/COPYRIGHT#L55-63"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/YPL-1.0.html",
+      "reference": "https://spdx.org/licenses/BSD-4.3TAHOE.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/YPL-1.0.json",
-      "referenceNumber": 92,
-      "name": "Yahoo! Public License v1.0",
-      "licenseId": "YPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/BSD-4.3TAHOE.json",
+      "referenceNumber": 46,
+      "name": "BSD 4.3 TAHOE License",
+      "licenseId": "BSD-4.3TAHOE",
       "seeAlso": [
-        "http://www.zimbra.com/license/yahoo_public_license_1.0.html"
+        "https://github.com/389ds/389-ds-base/blob/main/ldap/include/sysexits-compat.h#L15",
+        "https://git.savannah.gnu.org/cgit/indent.git/tree/doc/indent.texi?id\u003da74c6b4ee49397cf330b333da1042bffa60ed14f#n1788"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OSET-PL-2.1.html",
+      "reference": "https://spdx.org/licenses/BSD-Advertising-Acknowledgement.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OSET-PL-2.1.json",
-      "referenceNumber": 93,
-      "name": "OSET Public License version 2.1",
-      "licenseId": "OSET-PL-2.1",
+      "detailsUrl": "https://spdx.org/licenses/BSD-Advertising-Acknowledgement.json",
+      "referenceNumber": 297,
+      "name": "BSD Advertising Acknowledgement License",
+      "licenseId": "BSD-Advertising-Acknowledgement",
       "seeAlso": [
-        "http://www.osetfoundation.org/public-license",
-        "https://opensource.org/licenses/OPL-2.1"
+        "https://github.com/python-excel/xlrd/blob/master/LICENSE#L33"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Noweb.html",
+      "reference": "https://spdx.org/licenses/BSD-Attribution-HPND-disclaimer.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Noweb.json",
-      "referenceNumber": 94,
-      "name": "Noweb License",
-      "licenseId": "Noweb",
+      "detailsUrl": "https://spdx.org/licenses/BSD-Attribution-HPND-disclaimer.json",
+      "referenceNumber": 86,
+      "name": "BSD with Attribution and HPND disclaimer",
+      "licenseId": "BSD-Attribution-HPND-disclaimer",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Noweb"
+        "https://github.com/cyrusimap/cyrus-sasl/blob/master/COPYING"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/RPSL-1.0.html",
+      "reference": "https://spdx.org/licenses/BSD-Inferno-Nettverk.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/RPSL-1.0.json",
-      "referenceNumber": 95,
-      "name": "RealNetworks Public Source License v1.0",
-      "licenseId": "RPSL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/BSD-Inferno-Nettverk.json",
+      "referenceNumber": 89,
+      "name": "BSD-Inferno-Nettverk",
+      "licenseId": "BSD-Inferno-Nettverk",
       "seeAlso": [
-        "https://helixcommunity.org/content/rpsl",
-        "https://opensource.org/licenses/RPSL-1.0"
+        "https://www.inet.no/dante/LICENSE"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-3-Clause-LBNL.html",
+      "reference": "https://spdx.org/licenses/BSD-Protection.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-LBNL.json",
-      "referenceNumber": 96,
-      "name": "Lawrence Berkeley National Labs BSD variant license",
-      "licenseId": "BSD-3-Clause-LBNL",
+      "detailsUrl": "https://spdx.org/licenses/BSD-Protection.json",
+      "referenceNumber": 394,
+      "name": "BSD Protection License",
+      "licenseId": "BSD-Protection",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/LBNLBSD"
+        "https://fedoraproject.org/wiki/Licensing/BSD_Protection_License"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CDLA-Sharing-1.0.html",
+      "reference": "https://spdx.org/licenses/BSD-Source-beginning-file.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CDLA-Sharing-1.0.json",
-      "referenceNumber": 97,
-      "name": "Community Data License Agreement Sharing 1.0",
-      "licenseId": "CDLA-Sharing-1.0",
+      "detailsUrl": "https://spdx.org/licenses/BSD-Source-beginning-file.json",
+      "referenceNumber": 378,
+      "name": "BSD Source Code Attribution - beginning of file variant",
+      "licenseId": "BSD-Source-beginning-file",
       "seeAlso": [
-        "https://cdla.io/sharing-1-0"
+        "https://github.com/lattera/freebsd/blob/master/sys/cam/cam.c#L4"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CECILL-1.0.html",
+      "reference": "https://spdx.org/licenses/BSD-Source-Code.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CECILL-1.0.json",
-      "referenceNumber": 98,
-      "name": "CeCILL Free Software License Agreement v1.0",
-      "licenseId": "CECILL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/BSD-Source-Code.json",
+      "referenceNumber": 605,
+      "name": "BSD Source Code Attribution",
+      "licenseId": "BSD-Source-Code",
       "seeAlso": [
-        "http://www.cecill.info/licences/Licence_CeCILL_V1-fr.html"
+        "https://github.com/robbiehanson/CocoaHTTPServer/blob/master/LICENSE.txt"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/AMPAS.html",
+      "reference": "https://spdx.org/licenses/BSD-Systemics.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/AMPAS.json",
-      "referenceNumber": 99,
-      "name": "Academy of Motion Picture Arts and Sciences BSD",
-      "licenseId": "AMPAS",
+      "detailsUrl": "https://spdx.org/licenses/BSD-Systemics.json",
+      "referenceNumber": 327,
+      "name": "Systemics BSD variant license",
+      "licenseId": "BSD-Systemics",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/BSD#AMPASBSD"
+        "https://metacpan.org/release/DPARIS/Crypt-DES-2.07/source/COPYRIGHT"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/APAFML.html",
+      "reference": "https://spdx.org/licenses/BSD-Systemics-W3Works.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/APAFML.json",
-      "referenceNumber": 100,
-      "name": "Adobe Postscript AFM License",
-      "licenseId": "APAFML",
+      "detailsUrl": "https://spdx.org/licenses/BSD-Systemics-W3Works.json",
+      "referenceNumber": 427,
+      "name": "Systemics W3Works BSD variant license",
+      "licenseId": "BSD-Systemics-W3Works",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/AdobePostscriptAFM"
+        "https://metacpan.org/release/DPARIS/Crypt-Blowfish-2.14/source/COPYRIGHT#L7"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-ND-3.0.html",
+      "reference": "https://spdx.org/licenses/BSL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-ND-3.0.json",
-      "referenceNumber": 101,
-      "name": "Creative Commons Attribution No Derivatives 3.0 Unported",
-      "licenseId": "CC-BY-ND-3.0",
+      "detailsUrl": "https://spdx.org/licenses/BSL-1.0.json",
+      "referenceNumber": 334,
+      "name": "Boost Software License 1.0",
+      "licenseId": "BSL-1.0",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nd/3.0/legalcode"
+        "http://www.boost.org/LICENSE_1_0.txt",
+        "https://opensource.org/licenses/BSL-1.0"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/D-FSL-1.0.html",
+      "reference": "https://spdx.org/licenses/BUSL-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/D-FSL-1.0.json",
-      "referenceNumber": 102,
-      "name": "Deutsche Freie Software Lizenz",
-      "licenseId": "D-FSL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/BUSL-1.1.json",
+      "referenceNumber": 285,
+      "name": "Business Source License 1.1",
+      "licenseId": "BUSL-1.1",
       "seeAlso": [
-        "http://www.dipp.nrw.de/d-fsl/lizenzen/",
-        "http://www.dipp.nrw.de/d-fsl/index_html/lizenzen/de/D-FSL-1_0_de.txt",
-        "http://www.dipp.nrw.de/d-fsl/index_html/lizenzen/en/D-FSL-1_0_en.txt",
-        "https://www.hbz-nrw.de/produkte/open-access/lizenzen/dfsl",
-        "https://www.hbz-nrw.de/produkte/open-access/lizenzen/dfsl/deutsche-freie-software-lizenz",
-        "https://www.hbz-nrw.de/produkte/open-access/lizenzen/dfsl/german-free-software-license",
-        "https://www.hbz-nrw.de/produkte/open-access/lizenzen/dfsl/D-FSL-1_0_de.txt/at_download/file",
-        "https://www.hbz-nrw.de/produkte/open-access/lizenzen/dfsl/D-FSL-1_0_en.txt/at_download/file"
+        "https://mariadb.com/bsl11/"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-3.0.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-3.0.json",
-      "referenceNumber": 103,
-      "name": "Creative Commons Attribution Non Commercial 3.0 Unported",
-      "licenseId": "CC-BY-NC-3.0",
+      "reference": "https://spdx.org/licenses/bzip2-1.0.5.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/bzip2-1.0.5.json",
+      "referenceNumber": 574,
+      "name": "bzip2 and libbzip2 License v1.0.5",
+      "licenseId": "bzip2-1.0.5",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc/3.0/legalcode"
+        "https://sourceware.org/bzip2/1.0.5/bzip2-manual-1.0.5.html",
+        "http://bzip.org/1.0.5/bzip2-manual-1.0.5.html"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/libpng-2.0.html",
+      "reference": "https://spdx.org/licenses/bzip2-1.0.6.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/libpng-2.0.json",
-      "referenceNumber": 104,
-      "name": "PNG Reference Library version 2",
-      "licenseId": "libpng-2.0",
+      "detailsUrl": "https://spdx.org/licenses/bzip2-1.0.6.json",
+      "referenceNumber": 534,
+      "name": "bzip2 and libbzip2 License v1.0.6",
+      "licenseId": "bzip2-1.0.6",
       "seeAlso": [
-        "http://www.libpng.org/pub/png/src/libpng-LICENSE.txt"
+        "https://sourceware.org/git/?p\u003dbzip2.git;a\u003dblob;f\u003dLICENSE;hb\u003dbzip2-1.0.6",
+        "http://bzip.org/1.0.5/bzip2-manual-1.0.5.html",
+        "https://sourceware.org/cgit/valgrind/tree/mpi/libmpiwrap.c"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/PolyForm-Noncommercial-1.0.0.html",
+      "reference": "https://spdx.org/licenses/C-UDA-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/PolyForm-Noncommercial-1.0.0.json",
-      "referenceNumber": 105,
-      "name": "PolyForm Noncommercial License 1.0.0",
-      "licenseId": "PolyForm-Noncommercial-1.0.0",
+      "detailsUrl": "https://spdx.org/licenses/C-UDA-1.0.json",
+      "referenceNumber": 162,
+      "name": "Computational Use of Data Agreement v1.0",
+      "licenseId": "C-UDA-1.0",
       "seeAlso": [
-        "https://polyformproject.org/licenses/noncommercial/1.0.0"
+        "https://github.com/microsoft/Computational-Use-of-Data-Agreement/blob/master/C-UDA-1.0.md",
+        "https://cdla.dev/computational-use-of-data-agreement-v1-0/"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/dvipdfm.html",
+      "reference": "https://spdx.org/licenses/CAL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/dvipdfm.json",
-      "referenceNumber": 106,
-      "name": "dvipdfm License",
-      "licenseId": "dvipdfm",
+      "detailsUrl": "https://spdx.org/licenses/CAL-1.0.json",
+      "referenceNumber": 99,
+      "name": "Cryptographic Autonomy License 1.0",
+      "licenseId": "CAL-1.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/dvipdfm"
+        "http://cryptographicautonomylicense.com/license-text.html",
+        "https://opensource.org/licenses/CAL-1.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.3-or-later.html",
+      "reference": "https://spdx.org/licenses/CAL-1.0-Combined-Work-Exception.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.3-or-later.json",
-      "referenceNumber": 107,
-      "name": "GNU Free Documentation License v1.3 or later",
-      "licenseId": "GFDL-1.3-or-later",
+      "detailsUrl": "https://spdx.org/licenses/CAL-1.0-Combined-Work-Exception.json",
+      "referenceNumber": 333,
+      "name": "Cryptographic Autonomy License 1.0 (Combined Work Exception)",
+      "licenseId": "CAL-1.0-Combined-Work-Exception",
       "seeAlso": [
-        "https://www.gnu.org/licenses/fdl-1.3.txt"
+        "http://cryptographicautonomylicense.com/license-text.html",
+        "https://opensource.org/licenses/CAL-1.0"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/OGTSL.html",
+      "reference": "https://spdx.org/licenses/Caldera.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OGTSL.json",
-      "referenceNumber": 108,
-      "name": "Open Group Test Suite License",
-      "licenseId": "OGTSL",
+      "detailsUrl": "https://spdx.org/licenses/Caldera.json",
+      "referenceNumber": 528,
+      "name": "Caldera License",
+      "licenseId": "Caldera",
       "seeAlso": [
-        "http://www.opengroup.org/testing/downloads/The_Open_Group_TSL.txt",
-        "https://opensource.org/licenses/OGTSL"
+        "http://www.lemis.com/grog/UNIX/ancient-source-all.pdf"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/NPL-1.1.html",
+      "reference": "https://spdx.org/licenses/Caldera-no-preamble.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NPL-1.1.json",
-      "referenceNumber": 109,
-      "name": "Netscape Public License v1.1",
-      "licenseId": "NPL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/Caldera-no-preamble.json",
+      "referenceNumber": 233,
+      "name": "Caldera License (without preamble)",
+      "licenseId": "Caldera-no-preamble",
       "seeAlso": [
-        "http://www.mozilla.org/MPL/NPL/1.1/"
+        "https://github.com/apache/apr/blob/trunk/LICENSE#L298C6-L298C29"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-3.0.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GPL-3.0.json",
-      "referenceNumber": 110,
-      "name": "GNU General Public License v3.0 only",
-      "licenseId": "GPL-3.0",
+      "reference": "https://spdx.org/licenses/Catharon.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Catharon.json",
+      "referenceNumber": 337,
+      "name": "Catharon License",
+      "licenseId": "Catharon",
       "seeAlso": [
-        "https://www.gnu.org/licenses/gpl-3.0-standalone.html",
-        "https://opensource.org/licenses/GPL-3.0"
+        "https://github.com/scummvm/scummvm/blob/v2.8.0/LICENSES/CatharonLicense.txt"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CERN-OHL-P-2.0.html",
+      "reference": "https://spdx.org/licenses/CATOSL-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CERN-OHL-P-2.0.json",
-      "referenceNumber": 111,
-      "name": "CERN Open Hardware Licence Version 2 - Permissive",
-      "licenseId": "CERN-OHL-P-2.0",
+      "detailsUrl": "https://spdx.org/licenses/CATOSL-1.1.json",
+      "referenceNumber": 134,
+      "name": "Computer Associates Trusted Open Source License 1.1",
+      "licenseId": "CATOSL-1.1",
       "seeAlso": [
-        "https://www.ohwr.org/project/cernohl/wikis/Documents/CERN-OHL-version-2"
+        "https://opensource.org/licenses/CATOSL-1.1"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/BlueOak-1.0.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BlueOak-1.0.0.json",
-      "referenceNumber": 112,
-      "name": "Blue Oak Model License 1.0.0",
-      "licenseId": "BlueOak-1.0.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-1.0.json",
+      "referenceNumber": 415,
+      "name": "Creative Commons Attribution 1.0 Generic",
+      "licenseId": "CC-BY-1.0",
       "seeAlso": [
-        "https://blueoakcouncil.org/license/1.0.0"
+        "https://creativecommons.org/licenses/by/1.0/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/AGPL-3.0-or-later.html",
+      "reference": "https://spdx.org/licenses/CC-BY-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/AGPL-3.0-or-later.json",
-      "referenceNumber": 113,
-      "name": "GNU Affero General Public License v3.0 or later",
-      "licenseId": "AGPL-3.0-or-later",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-2.0.json",
+      "referenceNumber": 428,
+      "name": "Creative Commons Attribution 2.0 Generic",
+      "licenseId": "CC-BY-2.0",
       "seeAlso": [
-        "https://www.gnu.org/licenses/agpl.txt",
-        "https://opensource.org/licenses/AGPL-3.0"
+        "https://creativecommons.org/licenses/by/2.0/legalcode"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/blessing.html",
+      "reference": "https://spdx.org/licenses/CC-BY-2.5.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/blessing.json",
-      "referenceNumber": 114,
-      "name": "SQLite Blessing",
-      "licenseId": "blessing",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-2.5.json",
+      "referenceNumber": 573,
+      "name": "Creative Commons Attribution 2.5 Generic",
+      "licenseId": "CC-BY-2.5",
       "seeAlso": [
-        "https://www.sqlite.org/src/artifact/e33a4df7e32d742a?ln\u003d4-9",
-        "https://sqlite.org/src/artifact/df5091916dbb40e6"
+        "https://creativecommons.org/licenses/by/2.5/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/ImageMagick.html",
+      "reference": "https://spdx.org/licenses/CC-BY-2.5-AU.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ImageMagick.json",
-      "referenceNumber": 115,
-      "name": "ImageMagick License",
-      "licenseId": "ImageMagick",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-2.5-AU.json",
+      "referenceNumber": 388,
+      "name": "Creative Commons Attribution 2.5 Australia",
+      "licenseId": "CC-BY-2.5-AU",
       "seeAlso": [
-        "http://www.imagemagick.org/script/license.php"
+        "https://creativecommons.org/licenses/by/2.5/au/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/APSL-2.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-3.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/APSL-2.0.json",
-      "referenceNumber": 116,
-      "name": "Apple Public Source License 2.0",
-      "licenseId": "APSL-2.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-3.0.json",
+      "referenceNumber": 132,
+      "name": "Creative Commons Attribution 3.0 Unported",
+      "licenseId": "CC-BY-3.0",
       "seeAlso": [
-        "http://www.opensource.apple.com/license/apsl/"
+        "https://creativecommons.org/licenses/by/3.0/legalcode"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/MIT-advertising.html",
+      "reference": "https://spdx.org/licenses/CC-BY-3.0-AT.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MIT-advertising.json",
-      "referenceNumber": 117,
-      "name": "Enlightenment License (e16)",
-      "licenseId": "MIT-advertising",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-3.0-AT.json",
+      "referenceNumber": 25,
+      "name": "Creative Commons Attribution 3.0 Austria",
+      "licenseId": "CC-BY-3.0-AT",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/MIT_With_Advertising"
+        "https://creativecommons.org/licenses/by/3.0/at/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/curl.html",
+      "reference": "https://spdx.org/licenses/CC-BY-3.0-AU.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/curl.json",
-      "referenceNumber": 118,
-      "name": "curl License",
-      "licenseId": "curl",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-3.0-AU.json",
+      "referenceNumber": 392,
+      "name": "Creative Commons Attribution 3.0 Australia",
+      "licenseId": "CC-BY-3.0-AU",
       "seeAlso": [
-        "https://github.com/bagder/curl/blob/master/COPYING"
+        "https://creativecommons.org/licenses/by/3.0/au/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC0-1.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-3.0-DE.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC0-1.0.json",
-      "referenceNumber": 119,
-      "name": "Creative Commons Zero v1.0 Universal",
-      "licenseId": "CC0-1.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-3.0-DE.json",
+      "referenceNumber": 21,
+      "name": "Creative Commons Attribution 3.0 Germany",
+      "licenseId": "CC-BY-3.0-DE",
       "seeAlso": [
-        "https://creativecommons.org/publicdomain/zero/1.0/legalcode"
+        "https://creativecommons.org/licenses/by/3.0/de/legalcode"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Zimbra-1.4.html",
+      "reference": "https://spdx.org/licenses/CC-BY-3.0-IGO.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Zimbra-1.4.json",
-      "referenceNumber": 120,
-      "name": "Zimbra Public License v1.4",
-      "licenseId": "Zimbra-1.4",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-3.0-IGO.json",
+      "referenceNumber": 596,
+      "name": "Creative Commons Attribution 3.0 IGO",
+      "licenseId": "CC-BY-3.0-IGO",
       "seeAlso": [
-        "http://www.zimbra.com/legal/zimbra-public-license-1-4"
+        "https://creativecommons.org/licenses/by/3.0/igo/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/SSPL-1.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-3.0-NL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SSPL-1.0.json",
-      "referenceNumber": 121,
-      "name": "Server Side Public License, v 1",
-      "licenseId": "SSPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-3.0-NL.json",
+      "referenceNumber": 157,
+      "name": "Creative Commons Attribution 3.0 Netherlands",
+      "licenseId": "CC-BY-3.0-NL",
       "seeAlso": [
-        "https://www.mongodb.com/licensing/server-side-public-license"
+        "https://creativecommons.org/licenses/by/3.0/nl/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/psutils.html",
+      "reference": "https://spdx.org/licenses/CC-BY-3.0-US.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/psutils.json",
-      "referenceNumber": 122,
-      "name": "psutils License",
-      "licenseId": "psutils",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-3.0-US.json",
+      "referenceNumber": 395,
+      "name": "Creative Commons Attribution 3.0 United States",
+      "licenseId": "CC-BY-3.0-US",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/psutils"
+        "https://creativecommons.org/licenses/by/3.0/us/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-SA-2.0-UK.html",
+      "reference": "https://spdx.org/licenses/CC-BY-4.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-2.0-UK.json",
-      "referenceNumber": 123,
-      "name": "Creative Commons Attribution Share Alike 2.0 England and Wales",
-      "licenseId": "CC-BY-SA-2.0-UK",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-4.0.json",
+      "referenceNumber": 435,
+      "name": "Creative Commons Attribution 4.0 International",
+      "licenseId": "CC-BY-4.0",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-sa/2.0/uk/legalcode"
+        "https://creativecommons.org/licenses/by/4.0/legalcode"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/PSF-2.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/PSF-2.0.json",
-      "referenceNumber": 124,
-      "name": "Python Software Foundation License 2.0",
-      "licenseId": "PSF-2.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-1.0.json",
+      "referenceNumber": 641,
+      "name": "Creative Commons Attribution Non Commercial 1.0 Generic",
+      "licenseId": "CC-BY-NC-1.0",
       "seeAlso": [
-        "https://opensource.org/licenses/Python-2.0"
+        "https://creativecommons.org/licenses/by-nc/1.0/legalcode"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/Net-SNMP.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Net-SNMP.json",
-      "referenceNumber": 125,
-      "name": "Net-SNMP License",
-      "licenseId": "Net-SNMP",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-2.0.json",
+      "referenceNumber": 91,
+      "name": "Creative Commons Attribution Non Commercial 2.0 Generic",
+      "licenseId": "CC-BY-NC-2.0",
       "seeAlso": [
-        "http://net-snmp.sourceforge.net/about/license.html"
+        "https://creativecommons.org/licenses/by-nc/2.0/legalcode"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/NAIST-2003.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-2.5.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NAIST-2003.json",
-      "referenceNumber": 126,
-      "name": "Nara Institute of Science and Technology License (2003)",
-      "licenseId": "NAIST-2003",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-2.5.json",
+      "referenceNumber": 465,
+      "name": "Creative Commons Attribution Non Commercial 2.5 Generic",
+      "licenseId": "CC-BY-NC-2.5",
       "seeAlso": [
-        "https://enterprise.dejacode.com/licenses/public/naist-2003/#license-text",
-        "https://github.com/nodejs/node/blob/4a19cc8947b1bba2b2d27816ec3d0edf9b28e503/LICENSE#L343"
+        "https://creativecommons.org/licenses/by-nc/2.5/legalcode"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.2-invariants-or-later.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-3.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.2-invariants-or-later.json",
-      "referenceNumber": 127,
-      "name": "GNU Free Documentation License v1.2 or later - invariants",
-      "licenseId": "GFDL-1.2-invariants-or-later",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-3.0.json",
+      "referenceNumber": 234,
+      "name": "Creative Commons Attribution Non Commercial 3.0 Unported",
+      "licenseId": "CC-BY-NC-3.0",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/fdl-1.2.txt"
+        "https://creativecommons.org/licenses/by-nc/3.0/legalcode"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/SGI-B-1.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-3.0-DE.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SGI-B-1.0.json",
-      "referenceNumber": 128,
-      "name": "SGI Free Software License B v1.0",
-      "licenseId": "SGI-B-1.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-3.0-DE.json",
+      "referenceNumber": 354,
+      "name": "Creative Commons Attribution Non Commercial 3.0 Germany",
+      "licenseId": "CC-BY-NC-3.0-DE",
       "seeAlso": [
-        "http://oss.sgi.com/projects/FreeB/SGIFreeSWLicB.1.0.html"
+        "https://creativecommons.org/licenses/by-nc/3.0/de/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/NBPL-1.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-4.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NBPL-1.0.json",
-      "referenceNumber": 129,
-      "name": "Net Boolean Public License v1",
-      "licenseId": "NBPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-4.0.json",
+      "referenceNumber": 53,
+      "name": "Creative Commons Attribution Non Commercial 4.0 International",
+      "licenseId": "CC-BY-NC-4.0",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d37b4b3f6cc4bf34e1d3dec61e69914b9819d8894"
+        "https://creativecommons.org/licenses/by-nc/4.0/legalcode"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.2-invariants-only.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-ND-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.2-invariants-only.json",
-      "referenceNumber": 130,
-      "name": "GNU Free Documentation License v1.2 only - invariants",
-      "licenseId": "GFDL-1.2-invariants-only",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-ND-1.0.json",
+      "referenceNumber": 88,
+      "name": "Creative Commons Attribution Non Commercial No Derivatives 1.0 Generic",
+      "licenseId": "CC-BY-NC-ND-1.0",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/fdl-1.2.txt"
+        "https://creativecommons.org/licenses/by-nd-nc/1.0/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/W3C-19980720.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-ND-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/W3C-19980720.json",
-      "referenceNumber": 131,
-      "name": "W3C Software Notice and License (1998-07-20)",
-      "licenseId": "W3C-19980720",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-ND-2.0.json",
+      "referenceNumber": 426,
+      "name": "Creative Commons Attribution Non Commercial No Derivatives 2.0 Generic",
+      "licenseId": "CC-BY-NC-ND-2.0",
       "seeAlso": [
-        "http://www.w3.org/Consortium/Legal/copyright-software-19980720.html"
+        "https://creativecommons.org/licenses/by-nc-nd/2.0/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OFL-1.0-no-RFN.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-ND-2.5.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OFL-1.0-no-RFN.json",
-      "referenceNumber": 132,
-      "name": "SIL Open Font License 1.0 with no Reserved Font Name",
-      "licenseId": "OFL-1.0-no-RFN",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-ND-2.5.json",
+      "referenceNumber": 441,
+      "name": "Creative Commons Attribution Non Commercial No Derivatives 2.5 Generic",
+      "licenseId": "CC-BY-NC-ND-2.5",
       "seeAlso": [
-        "http://scripts.sil.org/cms/scripts/page.php?item_id\u003dOFL10_web"
+        "https://creativecommons.org/licenses/by-nc-nd/2.5/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/NetCDF.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-ND-3.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NetCDF.json",
-      "referenceNumber": 133,
-      "name": "NetCDF license",
-      "licenseId": "NetCDF",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-ND-3.0.json",
+      "referenceNumber": 304,
+      "name": "Creative Commons Attribution Non Commercial No Derivatives 3.0 Unported",
+      "licenseId": "CC-BY-NC-ND-3.0",
       "seeAlso": [
-        "http://www.unidata.ucar.edu/software/netcdf/copyright.html"
+        "https://creativecommons.org/licenses/by-nc-nd/3.0/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/TMate.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-ND-3.0-DE.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/TMate.json",
-      "referenceNumber": 134,
-      "name": "TMate Open Source License",
-      "licenseId": "TMate",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-ND-3.0-DE.json",
+      "referenceNumber": 121,
+      "name": "Creative Commons Attribution Non Commercial No Derivatives 3.0 Germany",
+      "licenseId": "CC-BY-NC-ND-3.0-DE",
       "seeAlso": [
-        "http://svnkit.com/license.html"
+        "https://creativecommons.org/licenses/by-nc-nd/3.0/de/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/NOSL.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-ND-3.0-IGO.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NOSL.json",
-      "referenceNumber": 135,
-      "name": "Netizen Open Source License",
-      "licenseId": "NOSL",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-ND-3.0-IGO.json",
+      "referenceNumber": 171,
+      "name": "Creative Commons Attribution Non Commercial No Derivatives 3.0 IGO",
+      "licenseId": "CC-BY-NC-ND-3.0-IGO",
       "seeAlso": [
-        "http://bits.netizen.com.au/licenses/NOSL/nosl.txt"
+        "https://creativecommons.org/licenses/by-nc-nd/3.0/igo/legalcode"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CNRI-Python-GPL-Compatible.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-ND-4.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CNRI-Python-GPL-Compatible.json",
-      "referenceNumber": 136,
-      "name": "CNRI Python Open Source GPL Compatible License Agreement",
-      "licenseId": "CNRI-Python-GPL-Compatible",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-ND-4.0.json",
+      "referenceNumber": 183,
+      "name": "Creative Commons Attribution Non Commercial No Derivatives 4.0 International",
+      "licenseId": "CC-BY-NC-ND-4.0",
       "seeAlso": [
-        "http://www.python.org/download/releases/1.6.1/download_win/"
+        "https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-1-Clause.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-1-Clause.json",
-      "referenceNumber": 137,
-      "name": "BSD 1-Clause License",
-      "licenseId": "BSD-1-Clause",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-1.0.json",
+      "referenceNumber": 501,
+      "name": "Creative Commons Attribution Non Commercial Share Alike 1.0 Generic",
+      "licenseId": "CC-BY-NC-SA-1.0",
       "seeAlso": [
-        "https://svnweb.freebsd.org/base/head/include/ifaddrs.h?revision\u003d326823"
+        "https://creativecommons.org/licenses/by-nc-sa/1.0/legalcode"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-3.0-DE.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-3.0-DE.json",
-      "referenceNumber": 138,
-      "name": "Creative Commons Attribution Non Commercial Share Alike 3.0 Germany",
-      "licenseId": "CC-BY-NC-SA-3.0-DE",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-2.0.json",
+      "referenceNumber": 358,
+      "name": "Creative Commons Attribution Non Commercial Share Alike 2.0 Generic",
+      "licenseId": "CC-BY-NC-SA-2.0",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-sa/3.0/de/legalcode"
+        "https://creativecommons.org/licenses/by-nc-sa/2.0/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-3-Clause-Modification.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-2.0-DE.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-Modification.json",
-      "referenceNumber": 139,
-      "name": "BSD 3-Clause Modification",
-      "licenseId": "BSD-3-Clause-Modification",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-2.0-DE.json",
+      "referenceNumber": 260,
+      "name": "Creative Commons Attribution Non Commercial Share Alike 2.0 Germany",
+      "licenseId": "CC-BY-NC-SA-2.0-DE",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing:BSD#Modification_Variant"
+        "https://creativecommons.org/licenses/by-nc-sa/2.0/de/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GLWTPL.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-2.0-FR.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GLWTPL.json",
-      "referenceNumber": 140,
-      "name": "Good Luck With That Public License",
-      "licenseId": "GLWTPL",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-2.0-FR.json",
+      "referenceNumber": 158,
+      "name": "Creative Commons Attribution-NonCommercial-ShareAlike 2.0 France",
+      "licenseId": "CC-BY-NC-SA-2.0-FR",
       "seeAlso": [
-        "https://github.com/me-shaon/GLWTPL/commit/da5f6bc734095efbacb442c0b31e33a65b9d6e85"
+        "https://creativecommons.org/licenses/by-nc-sa/2.0/fr/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.3-only.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-2.0-UK.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.3-only.json",
-      "referenceNumber": 141,
-      "name": "GNU Free Documentation License v1.3 only",
-      "licenseId": "GFDL-1.3-only",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-2.0-UK.json",
+      "referenceNumber": 33,
+      "name": "Creative Commons Attribution Non Commercial Share Alike 2.0 England and Wales",
+      "licenseId": "CC-BY-NC-SA-2.0-UK",
       "seeAlso": [
-        "https://www.gnu.org/licenses/fdl-1.3.txt"
+        "https://creativecommons.org/licenses/by-nc-sa/2.0/uk/legalcode"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-2.2.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-2.5.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.2.json",
-      "referenceNumber": 142,
-      "name": "Open LDAP Public License v2.2",
-      "licenseId": "OLDAP-2.2",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-2.5.json",
+      "referenceNumber": 222,
+      "name": "Creative Commons Attribution Non Commercial Share Alike 2.5 Generic",
+      "licenseId": "CC-BY-NC-SA-2.5",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d470b0c18ec67621c85881b2733057fecf4a1acc3"
+        "https://creativecommons.org/licenses/by-nc-sa/2.5/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-ND-4.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-3.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-ND-4.0.json",
-      "referenceNumber": 143,
-      "name": "Creative Commons Attribution No Derivatives 4.0 International",
-      "licenseId": "CC-BY-ND-4.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-3.0.json",
+      "referenceNumber": 255,
+      "name": "Creative Commons Attribution Non Commercial Share Alike 3.0 Unported",
+      "licenseId": "CC-BY-NC-SA-3.0",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nd/4.0/legalcode"
+        "https://creativecommons.org/licenses/by-nc-sa/3.0/legalcode"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-ND-3.0-DE.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-3.0-DE.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-ND-3.0-DE.json",
-      "referenceNumber": 144,
-      "name": "Creative Commons Attribution Non Commercial No Derivatives 3.0 Germany",
-      "licenseId": "CC-BY-NC-ND-3.0-DE",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-3.0-DE.json",
+      "referenceNumber": 525,
+      "name": "Creative Commons Attribution Non Commercial Share Alike 3.0 Germany",
+      "licenseId": "CC-BY-NC-SA-3.0-DE",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-nd/3.0/de/legalcode"
+        "https://creativecommons.org/licenses/by-nc-sa/3.0/de/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/EUPL-1.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-3.0-IGO.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/EUPL-1.0.json",
-      "referenceNumber": 145,
-      "name": "European Union Public License 1.0",
-      "licenseId": "EUPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-3.0-IGO.json",
+      "referenceNumber": 244,
+      "name": "Creative Commons Attribution Non Commercial Share Alike 3.0 IGO",
+      "licenseId": "CC-BY-NC-SA-3.0-IGO",
       "seeAlso": [
-        "http://ec.europa.eu/idabc/en/document/7330.html",
-        "http://ec.europa.eu/idabc/servlets/Doc027f.pdf?id\u003d31096"
+        "https://creativecommons.org/licenses/by-nc-sa/3.0/igo/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Linux-OpenIB.html",
+      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-4.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Linux-OpenIB.json",
-      "referenceNumber": 146,
-      "name": "Linux Kernel Variant of OpenIB.org license",
-      "licenseId": "Linux-OpenIB",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-4.0.json",
+      "referenceNumber": 513,
+      "name": "Creative Commons Attribution Non Commercial Share Alike 4.0 International",
+      "licenseId": "CC-BY-NC-SA-4.0",
       "seeAlso": [
-        "https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/infiniband/core/sa.h"
+        "https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LGPL-2.0-or-later.html",
+      "reference": "https://spdx.org/licenses/CC-BY-ND-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LGPL-2.0-or-later.json",
-      "referenceNumber": 147,
-      "name": "GNU Library General Public License v2 or later",
-      "licenseId": "LGPL-2.0-or-later",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-ND-1.0.json",
+      "referenceNumber": 474,
+      "name": "Creative Commons Attribution No Derivatives 1.0 Generic",
+      "licenseId": "CC-BY-ND-1.0",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/lgpl-2.0-standalone.html"
+        "https://creativecommons.org/licenses/by-nd/1.0/legalcode"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/OSL-1.1.html",
+      "reference": "https://spdx.org/licenses/CC-BY-ND-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OSL-1.1.json",
-      "referenceNumber": 148,
-      "name": "Open Software License 1.1",
-      "licenseId": "OSL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-ND-2.0.json",
+      "referenceNumber": 356,
+      "name": "Creative Commons Attribution No Derivatives 2.0 Generic",
+      "licenseId": "CC-BY-ND-2.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/OSL1.1"
+        "https://creativecommons.org/licenses/by-nd/2.0/legalcode"
       ],
       "isOsiApproved": false,
-      "isFsfLibre": true
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/Spencer-86.html",
+      "reference": "https://spdx.org/licenses/CC-BY-ND-2.5.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Spencer-86.json",
-      "referenceNumber": 149,
-      "name": "Spencer License 86",
-      "licenseId": "Spencer-86",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-ND-2.5.json",
+      "referenceNumber": 259,
+      "name": "Creative Commons Attribution No Derivatives 2.5 Generic",
+      "licenseId": "CC-BY-ND-2.5",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Henry_Spencer_Reg-Ex_Library_License"
+        "https://creativecommons.org/licenses/by-nd/2.5/legalcode"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/LGPL-2.0.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/LGPL-2.0.json",
-      "referenceNumber": 150,
-      "name": "GNU Library General Public License v2 only",
-      "licenseId": "LGPL-2.0",
+      "reference": "https://spdx.org/licenses/CC-BY-ND-3.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-ND-3.0.json",
+      "referenceNumber": 527,
+      "name": "Creative Commons Attribution No Derivatives 3.0 Unported",
+      "licenseId": "CC-BY-ND-3.0",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/lgpl-2.0-standalone.html"
+        "https://creativecommons.org/licenses/by-nd/3.0/legalcode"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-PDDC.html",
+      "reference": "https://spdx.org/licenses/CC-BY-ND-3.0-DE.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-PDDC.json",
-      "referenceNumber": 151,
-      "name": "Creative Commons Public Domain Dedication and Certification",
-      "licenseId": "CC-PDDC",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-ND-3.0-DE.json",
+      "referenceNumber": 214,
+      "name": "Creative Commons Attribution No Derivatives 3.0 Germany",
+      "licenseId": "CC-BY-ND-3.0-DE",
       "seeAlso": [
-        "https://creativecommons.org/licenses/publicdomain/"
+        "https://creativecommons.org/licenses/by-nd/3.0/de/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-ND-3.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-ND-4.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-ND-3.0.json",
-      "referenceNumber": 152,
-      "name": "Creative Commons Attribution Non Commercial No Derivatives 3.0 Unported",
-      "licenseId": "CC-BY-NC-ND-3.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-ND-4.0.json",
+      "referenceNumber": 481,
+      "name": "Creative Commons Attribution No Derivatives 4.0 International",
+      "licenseId": "CC-BY-ND-4.0",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-nd/3.0/legalcode"
+        "https://creativecommons.org/licenses/by-nd/4.0/legalcode"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/CDL-1.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-SA-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CDL-1.0.json",
-      "referenceNumber": 153,
-      "name": "Common Documentation License 1.0",
-      "licenseId": "CDL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-1.0.json",
+      "referenceNumber": 588,
+      "name": "Creative Commons Attribution Share Alike 1.0 Generic",
+      "licenseId": "CC-BY-SA-1.0",
       "seeAlso": [
-        "http://www.opensource.apple.com/cdl/",
-        "https://fedoraproject.org/wiki/Licensing/Common_Documentation_License",
-        "https://www.gnu.org/licenses/license-list.html#ACDL"
+        "https://creativecommons.org/licenses/by-sa/1.0/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Elastic-2.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-SA-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Elastic-2.0.json",
-      "referenceNumber": 154,
-      "name": "Elastic License 2.0",
-      "licenseId": "Elastic-2.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-2.0.json",
+      "referenceNumber": 180,
+      "name": "Creative Commons Attribution Share Alike 2.0 Generic",
+      "licenseId": "CC-BY-SA-2.0",
       "seeAlso": [
-        "https://www.elastic.co/licensing/elastic-license",
-        "https://github.com/elastic/elasticsearch/blob/master/licenses/ELASTIC-LICENSE-2.0.txt"
+        "https://creativecommons.org/licenses/by-sa/2.0/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-2.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-SA-2.0-UK.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-2.0.json",
-      "referenceNumber": 155,
-      "name": "Creative Commons Attribution 2.0 Generic",
-      "licenseId": "CC-BY-2.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-2.0-UK.json",
+      "referenceNumber": 385,
+      "name": "Creative Commons Attribution Share Alike 2.0 England and Wales",
+      "licenseId": "CC-BY-SA-2.0-UK",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by/2.0/legalcode"
+        "https://creativecommons.org/licenses/by-sa/2.0/uk/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-3-Clause-No-Military-License.html",
+      "reference": "https://spdx.org/licenses/CC-BY-SA-2.1-JP.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-No-Military-License.json",
-      "referenceNumber": 156,
-      "name": "BSD 3-Clause No Military License",
-      "licenseId": "BSD-3-Clause-No-Military-License",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-2.1-JP.json",
+      "referenceNumber": 17,
+      "name": "Creative Commons Attribution Share Alike 2.1 Japan",
+      "licenseId": "CC-BY-SA-2.1-JP",
       "seeAlso": [
-        "https://gitlab.syncad.com/hive/dhive/-/blob/master/LICENSE",
-        "https://github.com/greymass/swift-eosio/blob/master/LICENSE"
+        "https://creativecommons.org/licenses/by-sa/2.1/jp/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/IJG.html",
+      "reference": "https://spdx.org/licenses/CC-BY-SA-2.5.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/IJG.json",
-      "referenceNumber": 157,
-      "name": "Independent JPEG Group License",
-      "licenseId": "IJG",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-2.5.json",
+      "referenceNumber": 607,
+      "name": "Creative Commons Attribution Share Alike 2.5 Generic",
+      "licenseId": "CC-BY-SA-2.5",
       "seeAlso": [
-        "http://dev.w3.org/cvsweb/Amaya/libjpeg/Attic/README?rev\u003d1.2"
+        "https://creativecommons.org/licenses/by-sa/2.5/legalcode"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LPPL-1.3a.html",
+      "reference": "https://spdx.org/licenses/CC-BY-SA-3.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LPPL-1.3a.json",
-      "referenceNumber": 158,
-      "name": "LaTeX Project Public License v1.3a",
-      "licenseId": "LPPL-1.3a",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-3.0.json",
+      "referenceNumber": 26,
+      "name": "Creative Commons Attribution Share Alike 3.0 Unported",
+      "licenseId": "CC-BY-SA-3.0",
       "seeAlso": [
-        "http://www.latex-project.org/lppl/lppl-1-3a.txt"
+        "https://creativecommons.org/licenses/by-sa/3.0/legalcode"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/SAX-PD.html",
+      "reference": "https://spdx.org/licenses/CC-BY-SA-3.0-AT.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SAX-PD.json",
-      "referenceNumber": 159,
-      "name": "Sax Public Domain Notice",
-      "licenseId": "SAX-PD",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-3.0-AT.json",
+      "referenceNumber": 398,
+      "name": "Creative Commons Attribution Share Alike 3.0 Austria",
+      "licenseId": "CC-BY-SA-3.0-AT",
       "seeAlso": [
-        "http://www.saxproject.org/copying.html"
+        "https://creativecommons.org/licenses/by-sa/3.0/at/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BitTorrent-1.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-SA-3.0-DE.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BitTorrent-1.0.json",
-      "referenceNumber": 160,
-      "name": "BitTorrent Open Source License v1.0",
-      "licenseId": "BitTorrent-1.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-3.0-DE.json",
+      "referenceNumber": 120,
+      "name": "Creative Commons Attribution Share Alike 3.0 Germany",
+      "licenseId": "CC-BY-SA-3.0-DE",
       "seeAlso": [
-        "http://sources.gentoo.org/cgi-bin/viewvc.cgi/gentoo-x86/licenses/BitTorrent?r1\u003d1.1\u0026r2\u003d1.1.1.1\u0026diff_format\u003ds"
+        "https://creativecommons.org/licenses/by-sa/3.0/de/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-2.0.html",
+      "reference": "https://spdx.org/licenses/CC-BY-SA-3.0-IGO.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.0.json",
-      "referenceNumber": 161,
-      "name": "Open LDAP Public License v2.0 (or possibly 2.0A and 2.0B)",
-      "licenseId": "OLDAP-2.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-3.0-IGO.json",
+      "referenceNumber": 519,
+      "name": "Creative Commons Attribution-ShareAlike 3.0 IGO",
+      "licenseId": "CC-BY-SA-3.0-IGO",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003dcbf50f4e1185a21abd4c0a54d3f4341fe28f36ea"
+        "https://creativecommons.org/licenses/by-sa/3.0/igo/legalcode"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Giftware.html",
+      "reference": "https://spdx.org/licenses/CC-BY-SA-4.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Giftware.json",
-      "referenceNumber": 162,
-      "name": "Giftware License",
-      "licenseId": "Giftware",
+      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-4.0.json",
+      "referenceNumber": 13,
+      "name": "Creative Commons Attribution Share Alike 4.0 International",
+      "licenseId": "CC-BY-SA-4.0",
       "seeAlso": [
-        "http://liballeg.org/license.html#allegro-4-the-giftware-license"
+        "https://creativecommons.org/licenses/by-sa/4.0/legalcode"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/C-UDA-1.0.html",
+      "reference": "https://spdx.org/licenses/CC-PDDC.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/C-UDA-1.0.json",
-      "referenceNumber": 163,
-      "name": "Computational Use of Data Agreement v1.0",
-      "licenseId": "C-UDA-1.0",
+      "detailsUrl": "https://spdx.org/licenses/CC-PDDC.json",
+      "referenceNumber": 169,
+      "name": "Creative Commons Public Domain Dedication and Certification",
+      "licenseId": "CC-PDDC",
       "seeAlso": [
-        "https://github.com/microsoft/Computational-Use-of-Data-Agreement/blob/master/C-UDA-1.0.md",
-        "https://cdla.dev/computational-use-of-data-agreement-v1-0/"
+        "https://creativecommons.org/licenses/publicdomain/"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LGPL-2.0+.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/LGPL-2.0+.json",
-      "referenceNumber": 164,
-      "name": "GNU Library General Public License v2 or later",
-      "licenseId": "LGPL-2.0+",
-      "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/lgpl-2.0-standalone.html"
-      ],
-      "isOsiApproved": true
-    },
-    {
-      "reference": "https://spdx.org/licenses/Rdisc.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Rdisc.json",
-      "referenceNumber": 165,
-      "name": "Rdisc License",
-      "licenseId": "Rdisc",
-      "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Rdisc_License"
-      ],
-      "isOsiApproved": false
-    },
-    {
-      "reference": "https://spdx.org/licenses/GPL-2.0-with-classpath-exception.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GPL-2.0-with-classpath-exception.json",
-      "referenceNumber": 166,
-      "name": "GNU General Public License v2.0 w/Classpath exception",
-      "licenseId": "GPL-2.0-with-classpath-exception",
-      "seeAlso": [
-        "https://www.gnu.org/software/classpath/license.html"
-      ],
-      "isOsiApproved": false
-    },
-    {
-      "reference": "https://spdx.org/licenses/CC-BY-3.0-US.html",
+      "reference": "https://spdx.org/licenses/CC0-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-3.0-US.json",
-      "referenceNumber": 167,
-      "name": "Creative Commons Attribution 3.0 United States",
-      "licenseId": "CC-BY-3.0-US",
+      "detailsUrl": "https://spdx.org/licenses/CC0-1.0.json",
+      "referenceNumber": 491,
+      "name": "Creative Commons Zero v1.0 Universal",
+      "licenseId": "CC0-1.0",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by/3.0/us/legalcode"
+        "https://creativecommons.org/publicdomain/zero/1.0/legalcode"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
       "reference": "https://spdx.org/licenses/CDDL-1.0.html",
       "isDeprecatedLicenseId": false,
       "detailsUrl": "https://spdx.org/licenses/CDDL-1.0.json",
-      "referenceNumber": 168,
+      "referenceNumber": 185,
       "name": "Common Development and Distribution License 1.0",
       "licenseId": "CDDL-1.0",
       "seeAlso": [
@@ -2115,4041 +2034,6327 @@
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Xnet.html",
+      "reference": "https://spdx.org/licenses/CDDL-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Xnet.json",
-      "referenceNumber": 169,
-      "name": "X.Net License",
-      "licenseId": "Xnet",
+      "detailsUrl": "https://spdx.org/licenses/CDDL-1.1.json",
+      "referenceNumber": 476,
+      "name": "Common Development and Distribution License 1.1",
+      "licenseId": "CDDL-1.1",
       "seeAlso": [
-        "https://opensource.org/licenses/Xnet"
+        "http://glassfish.java.net/public/CDDL+GPL_1_1.html",
+        "https://javaee.github.io/glassfish/LICENSE"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CPL-1.0.html",
+      "reference": "https://spdx.org/licenses/CDL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CPL-1.0.json",
-      "referenceNumber": 170,
-      "name": "Common Public License 1.0",
-      "licenseId": "CPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/CDL-1.0.json",
+      "referenceNumber": 305,
+      "name": "Common Documentation License 1.0",
+      "licenseId": "CDL-1.0",
       "seeAlso": [
-        "https://opensource.org/licenses/CPL-1.0"
+        "http://www.opensource.apple.com/cdl/",
+        "https://fedoraproject.org/wiki/Licensing/Common_Documentation_License",
+        "https://www.gnu.org/licenses/license-list.html#ACDL"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LGPL-3.0-or-later.html",
+      "reference": "https://spdx.org/licenses/CDLA-Permissive-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LGPL-3.0-or-later.json",
-      "referenceNumber": 171,
-      "name": "GNU Lesser General Public License v3.0 or later",
-      "licenseId": "LGPL-3.0-or-later",
+      "detailsUrl": "https://spdx.org/licenses/CDLA-Permissive-1.0.json",
+      "referenceNumber": 386,
+      "name": "Community Data License Agreement Permissive 1.0",
+      "licenseId": "CDLA-Permissive-1.0",
       "seeAlso": [
-        "https://www.gnu.org/licenses/lgpl-3.0-standalone.html",
-        "https://www.gnu.org/licenses/lgpl+gpl-3.0.txt",
-        "https://opensource.org/licenses/LGPL-3.0"
+        "https://cdla.io/permissive-1-0"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/NASA-1.3.html",
+      "reference": "https://spdx.org/licenses/CDLA-Permissive-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NASA-1.3.json",
-      "referenceNumber": 172,
-      "name": "NASA Open Source Agreement 1.3",
-      "licenseId": "NASA-1.3",
+      "detailsUrl": "https://spdx.org/licenses/CDLA-Permissive-2.0.json",
+      "referenceNumber": 590,
+      "name": "Community Data License Agreement Permissive 2.0",
+      "licenseId": "CDLA-Permissive-2.0",
       "seeAlso": [
-        "http://ti.arc.nasa.gov/opensource/nosa/",
-        "https://opensource.org/licenses/NASA-1.3"
+        "https://cdla.dev/permissive-2-0"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BUSL-1.1.html",
+      "reference": "https://spdx.org/licenses/CDLA-Sharing-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BUSL-1.1.json",
-      "referenceNumber": 173,
-      "name": "Business Source License 1.1",
-      "licenseId": "BUSL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/CDLA-Sharing-1.0.json",
+      "referenceNumber": 190,
+      "name": "Community Data License Agreement Sharing 1.0",
+      "licenseId": "CDLA-Sharing-1.0",
       "seeAlso": [
-        "https://mariadb.com/bsl11/"
+        "https://cdla.io/sharing-1-0"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/etalab-2.0.html",
+      "reference": "https://spdx.org/licenses/CECILL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/etalab-2.0.json",
-      "referenceNumber": 174,
-      "name": "Etalab Open License 2.0",
-      "licenseId": "etalab-2.0",
+      "detailsUrl": "https://spdx.org/licenses/CECILL-1.0.json",
+      "referenceNumber": 625,
+      "name": "CeCILL Free Software License Agreement v1.0",
+      "licenseId": "CECILL-1.0",
       "seeAlso": [
-        "https://github.com/DISIC/politique-de-contribution-open-source/blob/master/LICENSE.pdf",
-        "https://raw.githubusercontent.com/DISIC/politique-de-contribution-open-source/master/LICENSE"
+        "http://www.cecill.info/licences/Licence_CeCILL_V1-fr.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/MIT-open-group.html",
+      "reference": "https://spdx.org/licenses/CECILL-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MIT-open-group.json",
-      "referenceNumber": 175,
-      "name": "MIT Open Group variant",
-      "licenseId": "MIT-open-group",
+      "detailsUrl": "https://spdx.org/licenses/CECILL-1.1.json",
+      "referenceNumber": 326,
+      "name": "CeCILL Free Software License Agreement v1.1",
+      "licenseId": "CECILL-1.1",
       "seeAlso": [
-        "https://gitlab.freedesktop.org/xorg/app/iceauth/-/blob/master/COPYING",
-        "https://gitlab.freedesktop.org/xorg/app/xvinfo/-/blob/master/COPYING",
-        "https://gitlab.freedesktop.org/xorg/app/xsetroot/-/blob/master/COPYING",
-        "https://gitlab.freedesktop.org/xorg/app/xauth/-/blob/master/COPYING"
+        "http://www.cecill.info/licences/Licence_CeCILL_V1.1-US.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-1.4.html",
+      "reference": "https://spdx.org/licenses/CECILL-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-1.4.json",
-      "referenceNumber": 176,
-      "name": "Open LDAP Public License v1.4",
-      "licenseId": "OLDAP-1.4",
+      "detailsUrl": "https://spdx.org/licenses/CECILL-2.0.json",
+      "referenceNumber": 463,
+      "name": "CeCILL Free Software License Agreement v2.0",
+      "licenseId": "CECILL-2.0",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003dc9f95c2f3f2ffb5e0ae55fe7388af75547660941"
+        "http://www.cecill.info/licences/Licence_CeCILL_V2-en.html"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.1-invariants-only.html",
+      "reference": "https://spdx.org/licenses/CECILL-2.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.1-invariants-only.json",
-      "referenceNumber": 177,
-      "name": "GNU Free Documentation License v1.1 only - invariants",
-      "licenseId": "GFDL-1.1-invariants-only",
+      "detailsUrl": "https://spdx.org/licenses/CECILL-2.1.json",
+      "referenceNumber": 170,
+      "name": "CeCILL Free Software License Agreement v2.1",
+      "licenseId": "CECILL-2.1",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/fdl-1.1.txt"
+        "http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.html"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/RPL-1.1.html",
+      "reference": "https://spdx.org/licenses/CECILL-B.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/RPL-1.1.json",
-      "referenceNumber": 178,
-      "name": "Reciprocal Public License 1.1",
-      "licenseId": "RPL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/CECILL-B.json",
+      "referenceNumber": 196,
+      "name": "CeCILL-B Free Software License Agreement",
+      "licenseId": "CECILL-B",
       "seeAlso": [
-        "https://opensource.org/licenses/RPL-1.1"
+        "http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-ND-2.5.html",
+      "reference": "https://spdx.org/licenses/CECILL-C.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-ND-2.5.json",
-      "referenceNumber": 179,
-      "name": "Creative Commons Attribution Non Commercial No Derivatives 2.5 Generic",
-      "licenseId": "CC-BY-NC-ND-2.5",
+      "detailsUrl": "https://spdx.org/licenses/CECILL-C.json",
+      "referenceNumber": 178,
+      "name": "CeCILL-C Free Software License Agreement",
+      "licenseId": "CECILL-C",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-nd/2.5/legalcode"
+        "http://www.cecill.info/licences/Licence_CeCILL-C_V1-en.html"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/FSFULLR.html",
+      "reference": "https://spdx.org/licenses/CERN-OHL-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/FSFULLR.json",
-      "referenceNumber": 180,
-      "name": "FSF Unlimited License (with License Retention)",
-      "licenseId": "FSFULLR",
+      "detailsUrl": "https://spdx.org/licenses/CERN-OHL-1.1.json",
+      "referenceNumber": 148,
+      "name": "CERN Open Hardware Licence v1.1",
+      "licenseId": "CERN-OHL-1.1",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/FSF_Unlimited_License#License_Retention_Variant"
+        "https://www.ohwr.org/project/licenses/wikis/cern-ohl-v1.1"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Saxpath.html",
+      "reference": "https://spdx.org/licenses/CERN-OHL-1.2.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Saxpath.json",
-      "referenceNumber": 181,
-      "name": "Saxpath License",
-      "licenseId": "Saxpath",
+      "detailsUrl": "https://spdx.org/licenses/CERN-OHL-1.2.json",
+      "referenceNumber": 651,
+      "name": "CERN Open Hardware Licence v1.2",
+      "licenseId": "CERN-OHL-1.2",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Saxpath_License"
+        "https://www.ohwr.org/project/licenses/wikis/cern-ohl-v1.2"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/NTP-0.html",
+      "reference": "https://spdx.org/licenses/CERN-OHL-P-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NTP-0.json",
-      "referenceNumber": 182,
-      "name": "NTP No Attribution",
-      "licenseId": "NTP-0",
+      "detailsUrl": "https://spdx.org/licenses/CERN-OHL-P-2.0.json",
+      "referenceNumber": 543,
+      "name": "CERN Open Hardware Licence Version 2 - Permissive",
+      "licenseId": "CERN-OHL-P-2.0",
       "seeAlso": [
-        "https://github.com/tytso/e2fsprogs/blob/master/lib/et/et_name.c"
+        "https://www.ohwr.org/project/cernohl/wikis/Documents/CERN-OHL-version-2"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/SISSL-1.2.html",
+      "reference": "https://spdx.org/licenses/CERN-OHL-S-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SISSL-1.2.json",
-      "referenceNumber": 183,
-      "name": "Sun Industry Standards Source License v1.2",
-      "licenseId": "SISSL-1.2",
+      "detailsUrl": "https://spdx.org/licenses/CERN-OHL-S-2.0.json",
+      "referenceNumber": 396,
+      "name": "CERN Open Hardware Licence Version 2 - Strongly Reciprocal",
+      "licenseId": "CERN-OHL-S-2.0",
       "seeAlso": [
-        "http://gridscheduler.sourceforge.net/Gridengine_SISSL_license.html"
+        "https://www.ohwr.org/project/cernohl/wikis/Documents/CERN-OHL-version-2"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-3.0-or-later.html",
+      "reference": "https://spdx.org/licenses/CERN-OHL-W-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GPL-3.0-or-later.json",
-      "referenceNumber": 184,
-      "name": "GNU General Public License v3.0 or later",
-      "licenseId": "GPL-3.0-or-later",
+      "detailsUrl": "https://spdx.org/licenses/CERN-OHL-W-2.0.json",
+      "referenceNumber": 614,
+      "name": "CERN Open Hardware Licence Version 2 - Weakly Reciprocal",
+      "licenseId": "CERN-OHL-W-2.0",
       "seeAlso": [
-        "https://www.gnu.org/licenses/gpl-3.0-standalone.html",
-        "https://opensource.org/licenses/GPL-3.0"
+        "https://www.ohwr.org/project/cernohl/wikis/Documents/CERN-OHL-version-2"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/Apache-1.1.html",
+      "reference": "https://spdx.org/licenses/CFITSIO.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Apache-1.1.json",
-      "referenceNumber": 185,
-      "name": "Apache License 1.1",
-      "licenseId": "Apache-1.1",
+      "detailsUrl": "https://spdx.org/licenses/CFITSIO.json",
+      "referenceNumber": 568,
+      "name": "CFITSIO License",
+      "licenseId": "CFITSIO",
       "seeAlso": [
-        "http://apache.org/licenses/LICENSE-1.1",
-        "https://opensource.org/licenses/Apache-1.1"
+        "https://heasarc.gsfc.nasa.gov/docs/software/fitsio/c/f_user/node9.html",
+        "https://heasarc.gsfc.nasa.gov/docs/software/ftools/fv/doc/license.html"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-SA-2.1-JP.html",
+      "reference": "https://spdx.org/licenses/check-cvs.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-2.1-JP.json",
-      "referenceNumber": 186,
-      "name": "Creative Commons Attribution Share Alike 2.1 Japan",
-      "licenseId": "CC-BY-SA-2.1-JP",
+      "detailsUrl": "https://spdx.org/licenses/check-cvs.json",
+      "referenceNumber": 324,
+      "name": "check-cvs License",
+      "licenseId": "check-cvs",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-sa/2.1/jp/legalcode"
+        "http://cvs.savannah.gnu.org/viewvc/cvs/ccvs/contrib/check_cvs.in?revision\u003d1.1.4.3\u0026view\u003dmarkup\u0026pathrev\u003dcvs1-11-23#l2"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/AGPL-3.0-only.html",
+      "reference": "https://spdx.org/licenses/checkmk.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/AGPL-3.0-only.json",
-      "referenceNumber": 187,
-      "name": "GNU Affero General Public License v3.0 only",
-      "licenseId": "AGPL-3.0-only",
+      "detailsUrl": "https://spdx.org/licenses/checkmk.json",
+      "referenceNumber": 464,
+      "name": "Checkmk License",
+      "licenseId": "checkmk",
       "seeAlso": [
-        "https://www.gnu.org/licenses/agpl.txt",
-        "https://opensource.org/licenses/AGPL-3.0"
+        "https://github.com/libcheck/check/blob/master/checkmk/checkmk.in"
       ],
-      "isOsiApproved": true,
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/ClArtistic.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/ClArtistic.json",
+      "referenceNumber": 230,
+      "name": "Clarified Artistic License",
+      "licenseId": "ClArtistic",
+      "seeAlso": [
+        "http://gianluca.dellavedova.org/2011/01/03/clarified-artistic-license/",
+        "http://www.ncftp.com/ncftp/doc/LICENSE.txt"
+      ],
+      "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-2.0-with-autoconf-exception.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GPL-2.0-with-autoconf-exception.json",
-      "referenceNumber": 188,
-      "name": "GNU General Public License v2.0 w/Autoconf exception",
-      "licenseId": "GPL-2.0-with-autoconf-exception",
+      "reference": "https://spdx.org/licenses/Clips.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Clips.json",
+      "referenceNumber": 424,
+      "name": "Clips License",
+      "licenseId": "Clips",
       "seeAlso": [
-        "http://ac-archive.sourceforge.net/doc/copyright.html"
+        "https://github.com/DrItanium/maya/blob/master/LICENSE.CLIPS"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Artistic-2.0.html",
+      "reference": "https://spdx.org/licenses/CMU-Mach.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Artistic-2.0.json",
-      "referenceNumber": 189,
-      "name": "Artistic License 2.0",
-      "licenseId": "Artistic-2.0",
+      "detailsUrl": "https://spdx.org/licenses/CMU-Mach.json",
+      "referenceNumber": 73,
+      "name": "CMU Mach License",
+      "licenseId": "CMU-Mach",
       "seeAlso": [
-        "http://www.perlfoundation.org/artistic_license_2_0",
-        "https://www.perlfoundation.org/artistic-license-20.html",
-        "https://opensource.org/licenses/artistic-license-2.0"
+        "https://www.cs.cmu.edu/~410/licenses.html"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/App-s2p.html",
+      "reference": "https://spdx.org/licenses/CMU-Mach-nodoc.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/App-s2p.json",
-      "referenceNumber": 190,
-      "name": "App::s2p License",
-      "licenseId": "App-s2p",
+      "detailsUrl": "https://spdx.org/licenses/CMU-Mach-nodoc.json",
+      "referenceNumber": 8,
+      "name": "CMU    Mach - no notices-in-documentation variant",
+      "licenseId": "CMU-Mach-nodoc",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/App-s2p"
+        "https://github.com/krb5/krb5/blob/krb5-1.21.2-final/NOTICE#L718-L728",
+        "https://web.mit.edu/kerberos/krb5-1.21/doc/mitK5license.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Unicode-DFS-2015.html",
+      "reference": "https://spdx.org/licenses/CNRI-Jython.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Unicode-DFS-2015.json",
-      "referenceNumber": 191,
-      "name": "Unicode License Agreement - Data Files and Software (2015)",
-      "licenseId": "Unicode-DFS-2015",
+      "detailsUrl": "https://spdx.org/licenses/CNRI-Jython.json",
+      "referenceNumber": 293,
+      "name": "CNRI Jython License",
+      "licenseId": "CNRI-Jython",
       "seeAlso": [
-        "https://web.archive.org/web/20151224134844/http://unicode.org/copyright.html"
+        "http://www.jython.org/license.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/diffmark.html",
+      "reference": "https://spdx.org/licenses/CNRI-Python.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/diffmark.json",
-      "referenceNumber": 192,
-      "name": "diffmark license",
-      "licenseId": "diffmark",
+      "detailsUrl": "https://spdx.org/licenses/CNRI-Python.json",
+      "referenceNumber": 402,
+      "name": "CNRI Python License",
+      "licenseId": "CNRI-Python",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/diffmark"
+        "https://opensource.org/licenses/CNRI-Python"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/CNRI-Python-GPL-Compatible.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/CNRI-Python-GPL-Compatible.json",
+      "referenceNumber": 224,
+      "name": "CNRI Python Open Source GPL Compatible License Agreement",
+      "licenseId": "CNRI-Python-GPL-Compatible",
+      "seeAlso": [
+        "http://www.python.org/download/releases/1.6.1/download_win/"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/SNIA.html",
+      "reference": "https://spdx.org/licenses/COIL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SNIA.json",
-      "referenceNumber": 193,
-      "name": "SNIA Public License 1.1",
-      "licenseId": "SNIA",
+      "detailsUrl": "https://spdx.org/licenses/COIL-1.0.json",
+      "referenceNumber": 345,
+      "name": "Copyfree Open Innovation License",
+      "licenseId": "COIL-1.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/SNIA_Public_License"
+        "https://coil.apotheon.org/plaintext/01.0.txt"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-SA-2.5.html",
+      "reference": "https://spdx.org/licenses/Community-Spec-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-2.5.json",
-      "referenceNumber": 194,
-      "name": "Creative Commons Attribution Share Alike 2.5 Generic",
-      "licenseId": "CC-BY-SA-2.5",
+      "detailsUrl": "https://spdx.org/licenses/Community-Spec-1.0.json",
+      "referenceNumber": 56,
+      "name": "Community Specification License 1.0",
+      "licenseId": "Community-Spec-1.0",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-sa/2.5/legalcode"
+        "https://github.com/CommunitySpecification/1.0/blob/master/1._Community_Specification_License-v1.md"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Linux-man-pages-copyleft.html",
+      "reference": "https://spdx.org/licenses/Condor-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Linux-man-pages-copyleft.json",
-      "referenceNumber": 195,
-      "name": "Linux man-pages Copyleft",
-      "licenseId": "Linux-man-pages-copyleft",
+      "detailsUrl": "https://spdx.org/licenses/Condor-1.1.json",
+      "referenceNumber": 77,
+      "name": "Condor Public License v1.1",
+      "licenseId": "Condor-1.1",
       "seeAlso": [
-        "https://www.kernel.org/doc/man-pages/licenses.html"
+        "http://research.cs.wisc.edu/condor/license.html#condor",
+        "http://web.archive.org/web/20111123062036/http://research.cs.wisc.edu/condor/license.html#condor"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/copyleft-next-0.3.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/copyleft-next-0.3.0.json",
+      "referenceNumber": 322,
+      "name": "copyleft-next 0.3.0",
+      "licenseId": "copyleft-next-0.3.0",
+      "seeAlso": [
+        "https://github.com/copyleft-next/copyleft-next/blob/master/Releases/copyleft-next-0.3.0"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/HPND-sell-variant.html",
+      "reference": "https://spdx.org/licenses/copyleft-next-0.3.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/HPND-sell-variant.json",
-      "referenceNumber": 196,
-      "name": "Historical Permission Notice and Disclaimer - sell variant",
-      "licenseId": "HPND-sell-variant",
+      "detailsUrl": "https://spdx.org/licenses/copyleft-next-0.3.1.json",
+      "referenceNumber": 403,
+      "name": "copyleft-next 0.3.1",
+      "licenseId": "copyleft-next-0.3.1",
       "seeAlso": [
-        "https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/sunrpc/auth_gss/gss_generic_token.c?h\u003dv4.19"
+        "https://github.com/copyleft-next/copyleft-next/blob/master/Releases/copyleft-next-0.3.1"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/ZPL-2.1.html",
+      "reference": "https://spdx.org/licenses/Cornell-Lossless-JPEG.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ZPL-2.1.json",
-      "referenceNumber": 197,
-      "name": "Zope Public License 2.1",
-      "licenseId": "ZPL-2.1",
+      "detailsUrl": "https://spdx.org/licenses/Cornell-Lossless-JPEG.json",
+      "referenceNumber": 98,
+      "name": "Cornell Lossless JPEG License",
+      "licenseId": "Cornell-Lossless-JPEG",
       "seeAlso": [
-        "http://old.zope.org/Resources/ZPL/"
+        "https://android.googlesource.com/platform/external/dng_sdk/+/refs/heads/master/source/dng_lossless_jpeg.cpp#16",
+        "https://www.mssl.ucl.ac.uk/~mcrw/src/20050920/proto.h",
+        "https://gitlab.freedesktop.org/libopenraw/libopenraw/blob/master/lib/ljpegdecompressor.cpp#L32"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/CPAL-1.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/CPAL-1.0.json",
+      "referenceNumber": 548,
+      "name": "Common Public Attribution License 1.0",
+      "licenseId": "CPAL-1.0",
+      "seeAlso": [
+        "https://opensource.org/licenses/CPAL-1.0"
       ],
       "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-4-Clause-UC.html",
+      "reference": "https://spdx.org/licenses/CPL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-4-Clause-UC.json",
-      "referenceNumber": 198,
-      "name": "BSD-4-Clause (University of California-Specific)",
-      "licenseId": "BSD-4-Clause-UC",
+      "detailsUrl": "https://spdx.org/licenses/CPL-1.0.json",
+      "referenceNumber": 114,
+      "name": "Common Public License 1.0",
+      "licenseId": "CPL-1.0",
       "seeAlso": [
-        "http://www.freebsd.org/copyright/license.html"
+        "https://opensource.org/licenses/CPL-1.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/CPOL-1.02.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/CPOL-1.02.json",
+      "referenceNumber": 6,
+      "name": "Code Project Open License 1.02",
+      "licenseId": "CPOL-1.02",
+      "seeAlso": [
+        "http://www.codeproject.com/info/cpol10.aspx"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Cronyx.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Cronyx.json",
+      "referenceNumber": 649,
+      "name": "Cronyx License",
+      "licenseId": "Cronyx",
+      "seeAlso": [
+        "https://gitlab.freedesktop.org/xorg/font/alias/-/blob/master/COPYING",
+        "https://gitlab.freedesktop.org/xorg/font/cronyx-cyrillic/-/blob/master/COPYING",
+        "https://gitlab.freedesktop.org/xorg/font/misc-cyrillic/-/blob/master/COPYING",
+        "https://gitlab.freedesktop.org/xorg/font/screen-cyrillic/-/blob/master/COPYING"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LAL-1.2.html",
+      "reference": "https://spdx.org/licenses/Crossword.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LAL-1.2.json",
-      "referenceNumber": 199,
-      "name": "Licence Art Libre 1.2",
-      "licenseId": "LAL-1.2",
+      "detailsUrl": "https://spdx.org/licenses/Crossword.json",
+      "referenceNumber": 593,
+      "name": "Crossword License",
+      "licenseId": "Crossword",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/Crossword"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/CrystalStacker.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/CrystalStacker.json",
+      "referenceNumber": 241,
+      "name": "CrystalStacker License",
+      "licenseId": "CrystalStacker",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing:CrystalStacker?rd\u003dLicensing/CrystalStacker"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/CUA-OPL-1.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/CUA-OPL-1.0.json",
+      "referenceNumber": 409,
+      "name": "CUA Office Public License v1.0",
+      "licenseId": "CUA-OPL-1.0",
+      "seeAlso": [
+        "https://opensource.org/licenses/CUA-OPL-1.0"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/Cube.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Cube.json",
+      "referenceNumber": 141,
+      "name": "Cube License",
+      "licenseId": "Cube",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/Cube"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/curl.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/curl.json",
+      "referenceNumber": 602,
+      "name": "curl License",
+      "licenseId": "curl",
+      "seeAlso": [
+        "https://github.com/bagder/curl/blob/master/COPYING"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/cve-tou.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/cve-tou.json",
+      "referenceNumber": 656,
+      "name": "Common Vulnerability Enumeration ToU License",
+      "licenseId": "cve-tou",
+      "seeAlso": [
+        "https://www.cve.org/Legal/TermsOfUse"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/D-FSL-1.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/D-FSL-1.0.json",
+      "referenceNumber": 116,
+      "name": "Deutsche Freie Software Lizenz",
+      "licenseId": "D-FSL-1.0",
+      "seeAlso": [
+        "http://www.dipp.nrw.de/d-fsl/lizenzen/",
+        "http://www.dipp.nrw.de/d-fsl/index_html/lizenzen/de/D-FSL-1_0_de.txt",
+        "http://www.dipp.nrw.de/d-fsl/index_html/lizenzen/en/D-FSL-1_0_en.txt",
+        "https://www.hbz-nrw.de/produkte/open-access/lizenzen/dfsl",
+        "https://www.hbz-nrw.de/produkte/open-access/lizenzen/dfsl/deutsche-freie-software-lizenz",
+        "https://www.hbz-nrw.de/produkte/open-access/lizenzen/dfsl/german-free-software-license",
+        "https://www.hbz-nrw.de/produkte/open-access/lizenzen/dfsl/D-FSL-1_0_de.txt/at_download/file",
+        "https://www.hbz-nrw.de/produkte/open-access/lizenzen/dfsl/D-FSL-1_0_en.txt/at_download/file"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/DEC-3-Clause.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/DEC-3-Clause.json",
+      "referenceNumber": 512,
+      "name": "DEC 3-Clause License",
+      "licenseId": "DEC-3-Clause",
+      "seeAlso": [
+        "https://gitlab.freedesktop.org/xorg/xserver/-/blob/master/COPYING?ref_type\u003dheads#L239"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/diffmark.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/diffmark.json",
+      "referenceNumber": 480,
+      "name": "diffmark license",
+      "licenseId": "diffmark",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/diffmark"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/DL-DE-BY-2.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/DL-DE-BY-2.0.json",
+      "referenceNumber": 84,
+      "name": "Data licence Germany – attribution – version 2.0",
+      "licenseId": "DL-DE-BY-2.0",
+      "seeAlso": [
+        "https://www.govdata.de/dl-de/by-2-0"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/DL-DE-ZERO-2.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/DL-DE-ZERO-2.0.json",
+      "referenceNumber": 522,
+      "name": "Data licence Germany – zero – version 2.0",
+      "licenseId": "DL-DE-ZERO-2.0",
+      "seeAlso": [
+        "https://www.govdata.de/dl-de/zero-2-0"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/DOC.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/DOC.json",
+      "referenceNumber": 646,
+      "name": "DOC License",
+      "licenseId": "DOC",
+      "seeAlso": [
+        "http://www.cs.wustl.edu/~schmidt/ACE-copying.html",
+        "https://www.dre.vanderbilt.edu/~schmidt/ACE-copying.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/DocBook-Schema.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/DocBook-Schema.json",
+      "referenceNumber": 153,
+      "name": "DocBook Schema License",
+      "licenseId": "DocBook-Schema",
+      "seeAlso": [
+        "https://github.com/docbook/xslt10-stylesheets/blob/efd62655c11cc8773708df7a843613fa1e932bf8/xsl/assembly/schema/docbook51b7.rnc"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/DocBook-XML.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/DocBook-XML.json",
+      "referenceNumber": 493,
+      "name": "DocBook XML License",
+      "licenseId": "DocBook-XML",
+      "seeAlso": [
+        "https://github.com/docbook/xslt10-stylesheets/blob/efd62655c11cc8773708df7a843613fa1e932bf8/xsl/COPYING#L27"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Dotseqn.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Dotseqn.json",
+      "referenceNumber": 533,
+      "name": "Dotseqn License",
+      "licenseId": "Dotseqn",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/Dotseqn"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/DRL-1.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/DRL-1.0.json",
+      "referenceNumber": 410,
+      "name": "Detection Rule License 1.0",
+      "licenseId": "DRL-1.0",
+      "seeAlso": [
+        "https://github.com/Neo23x0/sigma/blob/master/LICENSE.Detection.Rules.md"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/DRL-1.1.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/DRL-1.1.json",
+      "referenceNumber": 268,
+      "name": "Detection Rule License 1.1",
+      "licenseId": "DRL-1.1",
+      "seeAlso": [
+        "https://github.com/SigmaHQ/Detection-Rule-License/blob/6ec7fbde6101d101b5b5d1fcb8f9b69fbc76c04a/LICENSE.Detection.Rules.md"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/DSDP.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/DSDP.json",
+      "referenceNumber": 164,
+      "name": "DSDP License",
+      "licenseId": "DSDP",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/DSDP"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/dtoa.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/dtoa.json",
+      "referenceNumber": 263,
+      "name": "David M. Gay dtoa License",
+      "licenseId": "dtoa",
+      "seeAlso": [
+        "https://github.com/SWI-Prolog/swipl-devel/blob/master/src/os/dtoa.c",
+        "https://sourceware.org/git/?p\u003dnewlib-cygwin.git;a\u003dblob;f\u003dnewlib/libc/stdlib/mprec.h;hb\u003dHEAD"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/dvipdfm.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/dvipdfm.json",
+      "referenceNumber": 61,
+      "name": "dvipdfm License",
+      "licenseId": "dvipdfm",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/dvipdfm"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/ECL-1.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/ECL-1.0.json",
+      "referenceNumber": 264,
+      "name": "Educational Community License v1.0",
+      "licenseId": "ECL-1.0",
+      "seeAlso": [
+        "https://opensource.org/licenses/ECL-1.0"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/ECL-2.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/ECL-2.0.json",
+      "referenceNumber": 363,
+      "name": "Educational Community License v2.0",
+      "licenseId": "ECL-2.0",
+      "seeAlso": [
+        "https://opensource.org/licenses/ECL-2.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/eCos-2.0.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/eCos-2.0.json",
+      "referenceNumber": 298,
+      "name": "eCos license version 2.0",
+      "licenseId": "eCos-2.0",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/ecos-license.html"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/EFL-1.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/EFL-1.0.json",
+      "referenceNumber": 137,
+      "name": "Eiffel Forum License v1.0",
+      "licenseId": "EFL-1.0",
+      "seeAlso": [
+        "http://www.eiffel-nice.org/license/forum.txt",
+        "https://opensource.org/licenses/EFL-1.0"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/EFL-2.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/EFL-2.0.json",
+      "referenceNumber": 447,
+      "name": "Eiffel Forum License v2.0",
+      "licenseId": "EFL-2.0",
+      "seeAlso": [
+        "http://www.eiffel-nice.org/license/eiffel-forum-license-2.html",
+        "https://opensource.org/licenses/EFL-2.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/eGenix.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/eGenix.json",
+      "referenceNumber": 348,
+      "name": "eGenix.com Public License 1.1.0",
+      "licenseId": "eGenix",
+      "seeAlso": [
+        "http://www.egenix.com/products/eGenix.com-Public-License-1.1.0.pdf",
+        "https://fedoraproject.org/wiki/Licensing/eGenix.com_Public_License_1.1.0"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Elastic-2.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Elastic-2.0.json",
+      "referenceNumber": 404,
+      "name": "Elastic License 2.0",
+      "licenseId": "Elastic-2.0",
+      "seeAlso": [
+        "https://www.elastic.co/licensing/elastic-license",
+        "https://github.com/elastic/elasticsearch/blob/master/licenses/ELASTIC-LICENSE-2.0.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Entessa.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Entessa.json",
+      "referenceNumber": 198,
+      "name": "Entessa Public License v1.0",
+      "licenseId": "Entessa",
+      "seeAlso": [
+        "https://opensource.org/licenses/Entessa"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/EPICS.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/EPICS.json",
+      "referenceNumber": 532,
+      "name": "EPICS Open License",
+      "licenseId": "EPICS",
+      "seeAlso": [
+        "https://epics.anl.gov/license/open.php"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/EPL-1.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/EPL-1.0.json",
+      "referenceNumber": 115,
+      "name": "Eclipse Public License 1.0",
+      "licenseId": "EPL-1.0",
+      "seeAlso": [
+        "http://www.eclipse.org/legal/epl-v10.html",
+        "https://opensource.org/licenses/EPL-1.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/EPL-2.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/EPL-2.0.json",
+      "referenceNumber": 282,
+      "name": "Eclipse Public License 2.0",
+      "licenseId": "EPL-2.0",
+      "seeAlso": [
+        "https://www.eclipse.org/legal/epl-2.0",
+        "https://www.opensource.org/licenses/EPL-2.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/ErlPL-1.1.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/ErlPL-1.1.json",
+      "referenceNumber": 530,
+      "name": "Erlang Public License v1.1",
+      "licenseId": "ErlPL-1.1",
+      "seeAlso": [
+        "http://www.erlang.org/EPLICENSE"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/etalab-2.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/etalab-2.0.json",
+      "referenceNumber": 129,
+      "name": "Etalab Open License 2.0",
+      "licenseId": "etalab-2.0",
+      "seeAlso": [
+        "https://github.com/DISIC/politique-de-contribution-open-source/blob/master/LICENSE.pdf",
+        "https://raw.githubusercontent.com/DISIC/politique-de-contribution-open-source/master/LICENSE"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/EUDatagrid.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/EUDatagrid.json",
+      "referenceNumber": 393,
+      "name": "EU DataGrid Software License",
+      "licenseId": "EUDatagrid",
+      "seeAlso": [
+        "http://eu-datagrid.web.cern.ch/eu-datagrid/license.html",
+        "https://opensource.org/licenses/EUDatagrid"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/EUPL-1.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/EUPL-1.0.json",
+      "referenceNumber": 389,
+      "name": "European Union Public License 1.0",
+      "licenseId": "EUPL-1.0",
+      "seeAlso": [
+        "http://ec.europa.eu/idabc/en/document/7330.html",
+        "http://ec.europa.eu/idabc/servlets/Doc027f.pdf?id\u003d31096"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/EUPL-1.1.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/EUPL-1.1.json",
+      "referenceNumber": 503,
+      "name": "European Union Public License 1.1",
+      "licenseId": "EUPL-1.1",
+      "seeAlso": [
+        "https://joinup.ec.europa.eu/software/page/eupl/licence-eupl",
+        "https://joinup.ec.europa.eu/sites/default/files/custom-page/attachment/eupl1.1.-licence-en_0.pdf",
+        "https://opensource.org/licenses/EUPL-1.1"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/EUPL-1.2.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/EUPL-1.2.json",
+      "referenceNumber": 12,
+      "name": "European Union Public License 1.2",
+      "licenseId": "EUPL-1.2",
+      "seeAlso": [
+        "https://joinup.ec.europa.eu/page/eupl-text-11-12",
+        "https://joinup.ec.europa.eu/sites/default/files/custom-page/attachment/eupl_v1.2_en.pdf",
+        "https://joinup.ec.europa.eu/sites/default/files/custom-page/attachment/2020-03/EUPL-1.2%20EN.txt",
+        "https://joinup.ec.europa.eu/sites/default/files/inline-files/EUPL%20v1_2%20EN(1).txt",
+        "http://eur-lex.europa.eu/legal-content/EN/TXT/HTML/?uri\u003dCELEX:32017D0863",
+        "https://opensource.org/licenses/EUPL-1.2"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/Eurosym.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Eurosym.json",
+      "referenceNumber": 621,
+      "name": "Eurosym License",
+      "licenseId": "Eurosym",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/Eurosym"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Fair.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Fair.json",
+      "referenceNumber": 258,
+      "name": "Fair License",
+      "licenseId": "Fair",
+      "seeAlso": [
+        "https://web.archive.org/web/20150926120323/http://fairlicense.org/",
+        "https://opensource.org/licenses/Fair"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/FBM.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/FBM.json",
+      "referenceNumber": 626,
+      "name": "Fuzzy Bitmap License",
+      "licenseId": "FBM",
+      "seeAlso": [
+        "https://github.com/SWI-Prolog/packages-xpce/blob/161a40cd82004f731ba48024f9d30af388a7edf5/src/img/gifwrite.c#L21-L26"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/FDK-AAC.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/FDK-AAC.json",
+      "referenceNumber": 344,
+      "name": "Fraunhofer FDK AAC Codec Library",
+      "licenseId": "FDK-AAC",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/FDK-AAC",
+        "https://directory.fsf.org/wiki/License:Fdk"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Ferguson-Twofish.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Ferguson-Twofish.json",
+      "referenceNumber": 362,
+      "name": "Ferguson Twofish License",
+      "licenseId": "Ferguson-Twofish",
+      "seeAlso": [
+        "https://github.com/wernerd/ZRTPCPP/blob/6b3cd8e6783642292bad0c21e3e5e5ce45ff3e03/cryptcommon/twofish.c#L113C3-L127"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Frameworx-1.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Frameworx-1.0.json",
+      "referenceNumber": 188,
+      "name": "Frameworx Open License 1.0",
+      "licenseId": "Frameworx-1.0",
+      "seeAlso": [
+        "https://opensource.org/licenses/Frameworx-1.0"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/FreeBSD-DOC.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/FreeBSD-DOC.json",
+      "referenceNumber": 151,
+      "name": "FreeBSD Documentation License",
+      "licenseId": "FreeBSD-DOC",
+      "seeAlso": [
+        "https://www.freebsd.org/copyright/freebsd-doc-license/"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/FreeImage.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/FreeImage.json",
+      "referenceNumber": 232,
+      "name": "FreeImage Public License v1.0",
+      "licenseId": "FreeImage",
+      "seeAlso": [
+        "http://freeimage.sourceforge.net/freeimage-license.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/FSFAP.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/FSFAP.json",
+      "referenceNumber": 436,
+      "name": "FSF All Permissive License",
+      "licenseId": "FSFAP",
+      "seeAlso": [
+        "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/FSFAP-no-warranty-disclaimer.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/FSFAP-no-warranty-disclaimer.json",
+      "referenceNumber": 547,
+      "name": "FSF All Permissive License (without Warranty)",
+      "licenseId": "FSFAP-no-warranty-disclaimer",
+      "seeAlso": [
+        "https://git.savannah.gnu.org/cgit/wget.git/tree/util/trunc.c?h\u003dv1.21.3\u0026id\u003d40747a11e44ced5a8ac628a41f879ced3e2ebce9#n6"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/FSFUL.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/FSFUL.json",
+      "referenceNumber": 2,
+      "name": "FSF Unlimited License",
+      "licenseId": "FSFUL",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/FSF_Unlimited_License"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/FSFULLR.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/FSFULLR.json",
+      "referenceNumber": 508,
+      "name": "FSF Unlimited License (with License Retention)",
+      "licenseId": "FSFULLR",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/FSF_Unlimited_License#License_Retention_Variant"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/FSFULLRWD.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/FSFULLRWD.json",
+      "referenceNumber": 640,
+      "name": "FSF Unlimited License (With License Retention and Warranty Disclaimer)",
+      "licenseId": "FSFULLRWD",
+      "seeAlso": [
+        "https://lists.gnu.org/archive/html/autoconf/2012-04/msg00061.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/FTL.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/FTL.json",
+      "referenceNumber": 249,
+      "name": "Freetype Project License",
+      "licenseId": "FTL",
+      "seeAlso": [
+        "http://freetype.fis.uniroma2.it/FTL.TXT",
+        "http://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/docs/FTL.TXT",
+        "http://gitlab.freedesktop.org/freetype/freetype/-/raw/master/docs/FTL.TXT"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/Furuseth.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Furuseth.json",
+      "referenceNumber": 273,
+      "name": "Furuseth License",
+      "licenseId": "Furuseth",
+      "seeAlso": [
+        "https://git.openldap.org/openldap/openldap/-/blob/master/COPYRIGHT?ref_type\u003dheads#L39-51"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/fwlw.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/fwlw.json",
+      "referenceNumber": 50,
+      "name": "fwlw License",
+      "licenseId": "fwlw",
+      "seeAlso": [
+        "https://mirrors.nic.cz/tex-archive/macros/latex/contrib/fwlw/README"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GCR-docs.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GCR-docs.json",
+      "referenceNumber": 272,
+      "name": "Gnome GCR Documentation License",
+      "licenseId": "GCR-docs",
+      "seeAlso": [
+        "https://github.com/GNOME/gcr/blob/master/docs/COPYING"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GD.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GD.json",
+      "referenceNumber": 624,
+      "name": "GD License",
+      "licenseId": "GD",
+      "seeAlso": [
+        "https://libgd.github.io/manuals/2.3.0/files/license-txt.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.1.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.1.json",
+      "referenceNumber": 177,
+      "name": "GNU Free Documentation License v1.1",
+      "licenseId": "GFDL-1.1",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/fdl-1.1.txt"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.1-invariants-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.1-invariants-only.json",
+      "referenceNumber": 216,
+      "name": "GNU Free Documentation License v1.1 only - invariants",
+      "licenseId": "GFDL-1.1-invariants-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/fdl-1.1.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.1-invariants-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.1-invariants-or-later.json",
+      "referenceNumber": 57,
+      "name": "GNU Free Documentation License v1.1 or later - invariants",
+      "licenseId": "GFDL-1.1-invariants-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/fdl-1.1.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.1-no-invariants-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.1-no-invariants-only.json",
+      "referenceNumber": 38,
+      "name": "GNU Free Documentation License v1.1 only - no invariants",
+      "licenseId": "GFDL-1.1-no-invariants-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/fdl-1.1.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.1-no-invariants-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.1-no-invariants-or-later.json",
+      "referenceNumber": 289,
+      "name": "GNU Free Documentation License v1.1 or later - no invariants",
+      "licenseId": "GFDL-1.1-no-invariants-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/fdl-1.1.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.1-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.1-only.json",
+      "referenceNumber": 654,
+      "name": "GNU Free Documentation License v1.1 only",
+      "licenseId": "GFDL-1.1-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/fdl-1.1.txt"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.1-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.1-or-later.json",
+      "referenceNumber": 569,
+      "name": "GNU Free Documentation License v1.1 or later",
+      "licenseId": "GFDL-1.1-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/fdl-1.1.txt"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.2.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.2.json",
+      "referenceNumber": 235,
+      "name": "GNU Free Documentation License v1.2",
+      "licenseId": "GFDL-1.2",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/fdl-1.2.txt"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.2-invariants-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.2-invariants-only.json",
+      "referenceNumber": 461,
+      "name": "GNU Free Documentation License v1.2 only - invariants",
+      "licenseId": "GFDL-1.2-invariants-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/fdl-1.2.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.2-invariants-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.2-invariants-or-later.json",
+      "referenceNumber": 391,
+      "name": "GNU Free Documentation License v1.2 or later - invariants",
+      "licenseId": "GFDL-1.2-invariants-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/fdl-1.2.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.2-no-invariants-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.2-no-invariants-only.json",
+      "referenceNumber": 187,
+      "name": "GNU Free Documentation License v1.2 only - no invariants",
+      "licenseId": "GFDL-1.2-no-invariants-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/fdl-1.2.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.2-no-invariants-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.2-no-invariants-or-later.json",
+      "referenceNumber": 240,
+      "name": "GNU Free Documentation License v1.2 or later - no invariants",
+      "licenseId": "GFDL-1.2-no-invariants-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/fdl-1.2.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.2-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.2-only.json",
+      "referenceNumber": 302,
+      "name": "GNU Free Documentation License v1.2 only",
+      "licenseId": "GFDL-1.2-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/fdl-1.2.txt"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.2-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.2-or-later.json",
+      "referenceNumber": 562,
+      "name": "GNU Free Documentation License v1.2 or later",
+      "licenseId": "GFDL-1.2-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/fdl-1.2.txt"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.3.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.3.json",
+      "referenceNumber": 60,
+      "name": "GNU Free Documentation License v1.3",
+      "licenseId": "GFDL-1.3",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/fdl-1.3.txt"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.3-invariants-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.3-invariants-only.json",
+      "referenceNumber": 184,
+      "name": "GNU Free Documentation License v1.3 only - invariants",
+      "licenseId": "GFDL-1.3-invariants-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/fdl-1.3.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.3-invariants-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.3-invariants-or-later.json",
+      "referenceNumber": 346,
+      "name": "GNU Free Documentation License v1.3 or later - invariants",
+      "licenseId": "GFDL-1.3-invariants-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/fdl-1.3.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.3-no-invariants-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.3-no-invariants-only.json",
+      "referenceNumber": 59,
+      "name": "GNU Free Documentation License v1.3 only - no invariants",
+      "licenseId": "GFDL-1.3-no-invariants-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/fdl-1.3.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.3-no-invariants-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.3-no-invariants-or-later.json",
+      "referenceNumber": 281,
+      "name": "GNU Free Documentation License v1.3 or later - no invariants",
+      "licenseId": "GFDL-1.3-no-invariants-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/fdl-1.3.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.3-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.3-only.json",
+      "referenceNumber": 642,
+      "name": "GNU Free Documentation License v1.3 only",
+      "licenseId": "GFDL-1.3-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/fdl-1.3.txt"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GFDL-1.3-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GFDL-1.3-or-later.json",
+      "referenceNumber": 494,
+      "name": "GNU Free Documentation License v1.3 or later",
+      "licenseId": "GFDL-1.3-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/fdl-1.3.txt"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/Giftware.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Giftware.json",
+      "referenceNumber": 618,
+      "name": "Giftware License",
+      "licenseId": "Giftware",
+      "seeAlso": [
+        "http://liballeg.org/license.html#allegro-4-the-giftware-license"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GL2PS.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GL2PS.json",
+      "referenceNumber": 231,
+      "name": "GL2PS License",
+      "licenseId": "GL2PS",
+      "seeAlso": [
+        "http://www.geuz.org/gl2ps/COPYING.GL2PS"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Glide.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Glide.json",
+      "referenceNumber": 620,
+      "name": "3dfx Glide License",
+      "licenseId": "Glide",
+      "seeAlso": [
+        "http://www.users.on.net/~triforce/glidexp/COPYING.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Glulxe.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Glulxe.json",
+      "referenceNumber": 429,
+      "name": "Glulxe License",
+      "licenseId": "Glulxe",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/Glulxe"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GLWTPL.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GLWTPL.json",
+      "referenceNumber": 154,
+      "name": "Good Luck With That Public License",
+      "licenseId": "GLWTPL",
+      "seeAlso": [
+        "https://github.com/me-shaon/GLWTPL/commit/da5f6bc734095efbacb442c0b31e33a65b9d6e85"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/gnuplot.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/gnuplot.json",
+      "referenceNumber": 271,
+      "name": "gnuplot License",
+      "licenseId": "gnuplot",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/Gnuplot"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-1.0.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GPL-1.0.json",
+      "referenceNumber": 365,
+      "name": "GNU General Public License v1.0 only",
+      "licenseId": "GPL-1.0",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/gpl-1.0-standalone.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-1.0+.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GPL-1.0+.json",
+      "referenceNumber": 66,
+      "name": "GNU General Public License v1.0 or later",
+      "licenseId": "GPL-1.0+",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/gpl-1.0-standalone.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-1.0-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GPL-1.0-only.json",
+      "referenceNumber": 563,
+      "name": "GNU General Public License v1.0 only",
+      "licenseId": "GPL-1.0-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/gpl-1.0-standalone.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-1.0-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GPL-1.0-or-later.json",
+      "referenceNumber": 558,
+      "name": "GNU General Public License v1.0 or later",
+      "licenseId": "GPL-1.0-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/gpl-1.0-standalone.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-2.0.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GPL-2.0.json",
+      "referenceNumber": 613,
+      "name": "GNU General Public License v2.0 only",
+      "licenseId": "GPL-2.0",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html",
+        "https://opensource.org/licenses/GPL-2.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-2.0+.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GPL-2.0+.json",
+      "referenceNumber": 83,
+      "name": "GNU General Public License v2.0 or later",
+      "licenseId": "GPL-2.0+",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html",
+        "https://opensource.org/licenses/GPL-2.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-2.0-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GPL-2.0-only.json",
+      "referenceNumber": 483,
+      "name": "GNU General Public License v2.0 only",
+      "licenseId": "GPL-2.0-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html",
+        "https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt",
+        "https://opensource.org/licenses/GPL-2.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-2.0-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GPL-2.0-or-later.json",
+      "referenceNumber": 349,
+      "name": "GNU General Public License v2.0 or later",
+      "licenseId": "GPL-2.0-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html",
+        "https://opensource.org/licenses/GPL-2.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-2.0-with-autoconf-exception.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GPL-2.0-with-autoconf-exception.json",
+      "referenceNumber": 475,
+      "name": "GNU General Public License v2.0 w/Autoconf exception",
+      "licenseId": "GPL-2.0-with-autoconf-exception",
+      "seeAlso": [
+        "http://ac-archive.sourceforge.net/doc/copyright.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-2.0-with-bison-exception.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GPL-2.0-with-bison-exception.json",
+      "referenceNumber": 492,
+      "name": "GNU General Public License v2.0 w/Bison exception",
+      "licenseId": "GPL-2.0-with-bison-exception",
+      "seeAlso": [
+        "http://git.savannah.gnu.org/cgit/bison.git/tree/data/yacc.c?id\u003d193d7c7054ba7197b0789e14965b739162319b5e#n141"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-2.0-with-classpath-exception.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GPL-2.0-with-classpath-exception.json",
+      "referenceNumber": 144,
+      "name": "GNU General Public License v2.0 w/Classpath exception",
+      "licenseId": "GPL-2.0-with-classpath-exception",
+      "seeAlso": [
+        "https://www.gnu.org/software/classpath/license.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-2.0-with-font-exception.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GPL-2.0-with-font-exception.json",
+      "referenceNumber": 579,
+      "name": "GNU General Public License v2.0 w/Font exception",
+      "licenseId": "GPL-2.0-with-font-exception",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/gpl-faq.html#FontException"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-2.0-with-GCC-exception.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GPL-2.0-with-GCC-exception.json",
+      "referenceNumber": 449,
+      "name": "GNU General Public License v2.0 w/GCC Runtime Library exception",
+      "licenseId": "GPL-2.0-with-GCC-exception",
+      "seeAlso": [
+        "https://gcc.gnu.org/git/?p\u003dgcc.git;a\u003dblob;f\u003dgcc/libgcc1.c;h\u003d762f5143fc6eed57b6797c82710f3538aa52b40b;hb\u003dcb143a3ce4fb417c68f5fa2691a1b1b1053dfba9#l10"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-3.0.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GPL-3.0.json",
+      "referenceNumber": 434,
+      "name": "GNU General Public License v3.0 only",
+      "licenseId": "GPL-3.0",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/gpl-3.0-standalone.html",
+        "https://opensource.org/licenses/GPL-3.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-3.0+.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GPL-3.0+.json",
+      "referenceNumber": 586,
+      "name": "GNU General Public License v3.0 or later",
+      "licenseId": "GPL-3.0+",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/gpl-3.0-standalone.html",
+        "https://opensource.org/licenses/GPL-3.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-3.0-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GPL-3.0-only.json",
+      "referenceNumber": 42,
+      "name": "GNU General Public License v3.0 only",
+      "licenseId": "GPL-3.0-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/gpl-3.0-standalone.html",
+        "https://opensource.org/licenses/GPL-3.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-3.0-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/GPL-3.0-or-later.json",
+      "referenceNumber": 269,
+      "name": "GNU General Public License v3.0 or later",
+      "licenseId": "GPL-3.0-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/gpl-3.0-standalone.html",
+        "https://opensource.org/licenses/GPL-3.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-3.0-with-autoconf-exception.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GPL-3.0-with-autoconf-exception.json",
+      "referenceNumber": 200,
+      "name": "GNU General Public License v3.0 w/Autoconf exception",
+      "licenseId": "GPL-3.0-with-autoconf-exception",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/autoconf-exception-3.0.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/GPL-3.0-with-GCC-exception.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/GPL-3.0-with-GCC-exception.json",
+      "referenceNumber": 546,
+      "name": "GNU General Public License v3.0 w/GCC Runtime Library exception",
+      "licenseId": "GPL-3.0-with-GCC-exception",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/gcc-exception-3.1.html"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/Graphics-Gems.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Graphics-Gems.json",
+      "referenceNumber": 437,
+      "name": "Graphics Gems License",
+      "licenseId": "Graphics-Gems",
+      "seeAlso": [
+        "https://github.com/erich666/GraphicsGems/blob/master/LICENSE.md"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/gSOAP-1.3b.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/gSOAP-1.3b.json",
+      "referenceNumber": 658,
+      "name": "gSOAP Public License v1.3b",
+      "licenseId": "gSOAP-1.3b",
+      "seeAlso": [
+        "http://www.cs.fsu.edu/~engelen/license.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/gtkbook.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/gtkbook.json",
+      "referenceNumber": 397,
+      "name": "gtkbook License",
+      "licenseId": "gtkbook",
+      "seeAlso": [
+        "https://github.com/slogan621/gtkbook",
+        "https://github.com/oetiker/rrdtool-1.x/blob/master/src/plbasename.c#L8-L11"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Gutmann.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Gutmann.json",
+      "referenceNumber": 103,
+      "name": "Gutmann License",
+      "licenseId": "Gutmann",
+      "seeAlso": [
+        "https://www.cs.auckland.ac.nz/~pgut001/dumpasn1.c"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HaskellReport.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HaskellReport.json",
+      "referenceNumber": 357,
+      "name": "Haskell Language Report License",
+      "licenseId": "HaskellReport",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/Haskell_Language_Report_License"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/hdparm.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/hdparm.json",
+      "referenceNumber": 351,
+      "name": "hdparm License",
+      "licenseId": "hdparm",
+      "seeAlso": [
+        "https://github.com/Distrotech/hdparm/blob/4517550db29a91420fb2b020349523b1b4512df2/LICENSE.TXT"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HIDAPI.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HIDAPI.json",
+      "referenceNumber": 318,
+      "name": "HIDAPI License",
+      "licenseId": "HIDAPI",
+      "seeAlso": [
+        "https://github.com/signal11/hidapi/blob/master/LICENSE-orig.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Hippocratic-2.1.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Hippocratic-2.1.json",
+      "referenceNumber": 425,
+      "name": "Hippocratic License 2.1",
+      "licenseId": "Hippocratic-2.1",
+      "seeAlso": [
+        "https://firstdonoharm.dev/version/2/1/license.html",
+        "https://github.com/EthicalSource/hippocratic-license/blob/58c0e646d64ff6fbee275bfe2b9492f914e3ab2a/LICENSE.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HP-1986.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HP-1986.json",
+      "referenceNumber": 477,
+      "name": "Hewlett-Packard 1986 License",
+      "licenseId": "HP-1986",
+      "seeAlso": [
+        "https://sourceware.org/git/?p\u003dnewlib-cygwin.git;a\u003dblob;f\u003dnewlib/libc/machine/hppa/memchr.S;h\u003d1cca3e5e8867aa4bffef1f75a5c1bba25c0c441e;hb\u003dHEAD#l2"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HP-1989.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HP-1989.json",
+      "referenceNumber": 653,
+      "name": "Hewlett-Packard 1989 License",
+      "licenseId": "HP-1989",
+      "seeAlso": [
+        "https://github.com/bleargh45/Data-UUID/blob/master/LICENSE"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND.json",
+      "referenceNumber": 75,
+      "name": "Historical Permission Notice and Disclaimer",
+      "licenseId": "HPND",
+      "seeAlso": [
+        "https://opensource.org/licenses/HPND",
+        "http://lists.opensource.org/pipermail/license-discuss_lists.opensource.org/2002-November/006304.html"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-DEC.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-DEC.json",
+      "referenceNumber": 597,
+      "name": "Historical Permission Notice and Disclaimer - DEC variant",
+      "licenseId": "HPND-DEC",
+      "seeAlso": [
+        "https://gitlab.freedesktop.org/xorg/app/xkbcomp/-/blob/master/COPYING?ref_type\u003dheads#L69"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-doc.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-doc.json",
+      "referenceNumber": 384,
+      "name": "Historical Permission Notice and Disclaimer - documentation variant",
+      "licenseId": "HPND-doc",
+      "seeAlso": [
+        "https://gitlab.freedesktop.org/xorg/lib/libxext/-/blob/master/COPYING?ref_type\u003dheads#L185-197",
+        "https://gitlab.freedesktop.org/xorg/lib/libxtst/-/blob/master/COPYING?ref_type\u003dheads#L70-77"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-doc-sell.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-doc-sell.json",
+      "referenceNumber": 648,
+      "name": "Historical Permission Notice and Disclaimer - documentation sell variant",
+      "licenseId": "HPND-doc-sell",
+      "seeAlso": [
+        "https://gitlab.freedesktop.org/xorg/lib/libxtst/-/blob/master/COPYING?ref_type\u003dheads#L108-117",
+        "https://gitlab.freedesktop.org/xorg/lib/libxext/-/blob/master/COPYING?ref_type\u003dheads#L153-162"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-export-US.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-export-US.json",
+      "referenceNumber": 551,
+      "name": "HPND with US Government export control warning",
+      "licenseId": "HPND-export-US",
+      "seeAlso": [
+        "https://www.kermitproject.org/ck90.html#source"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-export-US-acknowledgement.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-export-US-acknowledgement.json",
+      "referenceNumber": 661,
+      "name": "HPND with US Government export control warning and acknowledgment",
+      "licenseId": "HPND-export-US-acknowledgement",
+      "seeAlso": [
+        "https://github.com/krb5/krb5/blob/krb5-1.21.2-final/NOTICE#L831-L852",
+        "https://web.mit.edu/kerberos/krb5-1.21/doc/mitK5license.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-export-US-modify.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-export-US-modify.json",
+      "referenceNumber": 119,
+      "name": "HPND with US Government export control warning and modification rqmt",
+      "licenseId": "HPND-export-US-modify",
+      "seeAlso": [
+        "https://github.com/krb5/krb5/blob/krb5-1.21.2-final/NOTICE#L1157-L1182",
+        "https://github.com/pythongssapi/k5test/blob/v0.10.3/K5TEST-LICENSE.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-export2-US.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-export2-US.json",
+      "referenceNumber": 450,
+      "name": "HPND with US Government export control and 2 disclaimers",
+      "licenseId": "HPND-export2-US",
+      "seeAlso": [
+        "https://github.com/krb5/krb5/blob/krb5-1.21.2-final/NOTICE#L111-L133",
+        "https://web.mit.edu/kerberos/krb5-1.21/doc/mitK5license.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-Fenneberg-Livingston.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-Fenneberg-Livingston.json",
+      "referenceNumber": 643,
+      "name": "Historical Permission Notice and Disclaimer - Fenneberg-Livingston variant",
+      "licenseId": "HPND-Fenneberg-Livingston",
+      "seeAlso": [
+        "https://github.com/FreeRADIUS/freeradius-client/blob/master/COPYRIGHT#L32",
+        "https://github.com/radcli/radcli/blob/master/COPYRIGHT#L34"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-INRIA-IMAG.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-INRIA-IMAG.json",
+      "referenceNumber": 583,
+      "name": "Historical Permission Notice and Disclaimer    - INRIA-IMAG variant",
+      "licenseId": "HPND-INRIA-IMAG",
+      "seeAlso": [
+        "https://github.com/ppp-project/ppp/blob/master/pppd/ipv6cp.c#L75-L83"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-Intel.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-Intel.json",
+      "referenceNumber": 20,
+      "name": "Historical Permission Notice and Disclaimer - Intel variant",
+      "licenseId": "HPND-Intel",
+      "seeAlso": [
+        "https://sourceware.org/git/?p\u003dnewlib-cygwin.git;a\u003dblob;f\u003dnewlib/libc/machine/i960/memcpy.S;hb\u003dHEAD"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-Kevlin-Henney.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-Kevlin-Henney.json",
+      "referenceNumber": 637,
+      "name": "Historical Permission Notice and Disclaimer - Kevlin Henney variant",
+      "licenseId": "HPND-Kevlin-Henney",
+      "seeAlso": [
+        "https://github.com/mruby/mruby/blob/83d12f8d52522cdb7c8cc46fad34821359f453e6/mrbgems/mruby-dir/src/Win/dirent.c#L127-L140"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-Markus-Kuhn.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-Markus-Kuhn.json",
+      "referenceNumber": 172,
+      "name": "Historical Permission Notice and Disclaimer - Markus Kuhn variant",
+      "licenseId": "HPND-Markus-Kuhn",
+      "seeAlso": [
+        "https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c",
+        "https://sourceware.org/git/?p\u003dbinutils-gdb.git;a\u003dblob;f\u003dreadline/readline/support/wcwidth.c;h\u003d0f5ec995796f4813abbcf4972aec0378ab74722a;hb\u003dHEAD#l55"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-merchantability-variant.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-merchantability-variant.json",
+      "referenceNumber": 572,
+      "name": "Historical Permission Notice and Disclaimer - merchantability variant",
+      "licenseId": "HPND-merchantability-variant",
+      "seeAlso": [
+        "https://sourceware.org/git/?p\u003dnewlib-cygwin.git;a\u003dblob;f\u003dnewlib/libc/misc/fini.c;hb\u003dHEAD"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-MIT-disclaimer.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-MIT-disclaimer.json",
+      "referenceNumber": 609,
+      "name": "Historical Permission Notice and Disclaimer with MIT disclaimer",
+      "licenseId": "HPND-MIT-disclaimer",
+      "seeAlso": [
+        "https://metacpan.org/release/NLNETLABS/Net-DNS-SEC-1.22/source/LICENSE"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-Netrek.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-Netrek.json",
+      "referenceNumber": 126,
+      "name": "Historical Permission Notice and Disclaimer - Netrek variant",
+      "licenseId": "HPND-Netrek",
+      "seeAlso": [],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-Pbmplus.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-Pbmplus.json",
+      "referenceNumber": 242,
+      "name": "Historical Permission Notice and Disclaimer - Pbmplus variant",
+      "licenseId": "HPND-Pbmplus",
+      "seeAlso": [
+        "https://sourceforge.net/p/netpbm/code/HEAD/tree/super_stable/netpbm.c#l8"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-sell-MIT-disclaimer-xserver.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-sell-MIT-disclaimer-xserver.json",
+      "referenceNumber": 160,
+      "name": "Historical Permission Notice and Disclaimer - sell xserver variant with MIT disclaimer",
+      "licenseId": "HPND-sell-MIT-disclaimer-xserver",
+      "seeAlso": [
+        "https://gitlab.freedesktop.org/xorg/xserver/-/blob/master/COPYING?ref_type\u003dheads#L1781"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-sell-regexpr.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-sell-regexpr.json",
+      "referenceNumber": 44,
+      "name": "Historical Permission Notice and Disclaimer - sell regexpr variant",
+      "licenseId": "HPND-sell-regexpr",
+      "seeAlso": [
+        "https://gitlab.com/bacula-org/bacula/-/blob/Branch-11.0/bacula/LICENSE-FOSS?ref_type\u003dheads#L245"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-sell-variant.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-sell-variant.json",
+      "referenceNumber": 485,
+      "name": "Historical Permission Notice and Disclaimer - sell variant",
+      "licenseId": "HPND-sell-variant",
+      "seeAlso": [
+        "https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/net/sunrpc/auth_gss/gss_generic_token.c?h\u003dv4.19"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-sell-variant-MIT-disclaimer.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-sell-variant-MIT-disclaimer.json",
+      "referenceNumber": 430,
+      "name": "HPND sell variant with MIT disclaimer",
+      "licenseId": "HPND-sell-variant-MIT-disclaimer",
+      "seeAlso": [
+        "https://github.com/sigmavirus24/x11-ssh-askpass/blob/master/README"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-sell-variant-MIT-disclaimer-rev.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-sell-variant-MIT-disclaimer-rev.json",
+      "referenceNumber": 10,
+      "name": "HPND sell variant with MIT disclaimer - reverse",
+      "licenseId": "HPND-sell-variant-MIT-disclaimer-rev",
+      "seeAlso": [
+        "https://github.com/sigmavirus24/x11-ssh-askpass/blob/master/dynlist.c"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-UC.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-UC.json",
+      "referenceNumber": 423,
+      "name": "Historical Permission Notice and Disclaimer - University of California variant",
+      "licenseId": "HPND-UC",
+      "seeAlso": [
+        "https://core.tcl-lang.org/tk/file?name\u003dcompat/unistd.h"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HPND-UC-export-US.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HPND-UC-export-US.json",
+      "referenceNumber": 82,
+      "name": "Historical Permission Notice and Disclaimer - University of California, US export warning",
+      "licenseId": "HPND-UC-export-US",
+      "seeAlso": [
+        "https://github.com/RTimothyEdwards/magic/blob/master/LICENSE"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/HTMLTIDY.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/HTMLTIDY.json",
+      "referenceNumber": 439,
+      "name": "HTML Tidy License",
+      "licenseId": "HTMLTIDY",
+      "seeAlso": [
+        "https://github.com/htacg/tidy-html5/blob/next/README/LICENSE.md"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/IBM-pibs.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/IBM-pibs.json",
+      "referenceNumber": 604,
+      "name": "IBM PowerPC Initialization and Boot Software",
+      "licenseId": "IBM-pibs",
+      "seeAlso": [
+        "http://git.denx.de/?p\u003du-boot.git;a\u003dblob;f\u003darch/powerpc/cpu/ppc4xx/miiphy.c;h\u003d297155fdafa064b955e53e9832de93bfb0cfb85b;hb\u003d9fab4bf4cc077c21e43941866f3f2c196f28670d"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/ICU.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/ICU.json",
+      "referenceNumber": 375,
+      "name": "ICU License",
+      "licenseId": "ICU",
+      "seeAlso": [
+        "http://source.icu-project.org/repos/icu/icu/trunk/license.html"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/IEC-Code-Components-EULA.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/IEC-Code-Components-EULA.json",
+      "referenceNumber": 18,
+      "name": "IEC    Code Components End-user licence agreement",
+      "licenseId": "IEC-Code-Components-EULA",
+      "seeAlso": [
+        "https://www.iec.ch/webstore/custserv/pdf/CC-EULA.pdf",
+        "https://www.iec.ch/CCv1",
+        "https://www.iec.ch/copyright"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/IJG.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/IJG.json",
+      "referenceNumber": 374,
+      "name": "Independent JPEG Group License",
+      "licenseId": "IJG",
+      "seeAlso": [
+        "http://dev.w3.org/cvsweb/Amaya/libjpeg/Attic/README?rev\u003d1.2"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/IJG-short.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/IJG-short.json",
+      "referenceNumber": 152,
+      "name": "Independent JPEG Group License - short",
+      "licenseId": "IJG-short",
+      "seeAlso": [
+        "https://sourceforge.net/p/xmedcon/code/ci/master/tree/libs/ljpg/"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/ImageMagick.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/ImageMagick.json",
+      "referenceNumber": 608,
+      "name": "ImageMagick License",
+      "licenseId": "ImageMagick",
+      "seeAlso": [
+        "http://www.imagemagick.org/script/license.php"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/iMatix.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/iMatix.json",
+      "referenceNumber": 645,
+      "name": "iMatix Standard Function Library Agreement",
+      "licenseId": "iMatix",
+      "seeAlso": [
+        "http://legacy.imatix.com/html/sfl/sfl4.htm#license"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/Imlib2.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Imlib2.json",
+      "referenceNumber": 96,
+      "name": "Imlib2 License",
+      "licenseId": "Imlib2",
+      "seeAlso": [
+        "http://trac.enlightenment.org/e/browser/trunk/imlib2/COPYING",
+        "https://git.enlightenment.org/legacy/imlib2.git/tree/COPYING"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/Info-ZIP.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Info-ZIP.json",
+      "referenceNumber": 451,
+      "name": "Info-ZIP License",
+      "licenseId": "Info-ZIP",
+      "seeAlso": [
+        "http://www.info-zip.org/license.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Inner-Net-2.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Inner-Net-2.0.json",
+      "referenceNumber": 58,
+      "name": "Inner Net License v2.0",
+      "licenseId": "Inner-Net-2.0",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/Inner_Net_License",
+        "https://sourceware.org/git/?p\u003dglibc.git;a\u003dblob;f\u003dLICENSES;h\u003d530893b1dc9ea00755603c68fb36bd4fc38a7be8;hb\u003dHEAD#l207"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Intel.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Intel.json",
+      "referenceNumber": 316,
+      "name": "Intel Open Source License",
+      "licenseId": "Intel",
+      "seeAlso": [
+        "https://opensource.org/licenses/Intel"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/Intel-ACPI.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Intel-ACPI.json",
+      "referenceNumber": 309,
+      "name": "Intel ACPI Software License Agreement",
+      "licenseId": "Intel-ACPI",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/Intel_ACPI_Software_License_Agreement"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Interbase-1.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Interbase-1.0.json",
+      "referenceNumber": 665,
+      "name": "Interbase Public License v1.0",
+      "licenseId": "Interbase-1.0",
+      "seeAlso": [
+        "https://web.archive.org/web/20060319014854/http://info.borland.com/devsupport/interbase/opensource/IPL.html"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/IPA.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/IPA.json",
+      "referenceNumber": 237,
+      "name": "IPA Font License",
+      "licenseId": "IPA",
+      "seeAlso": [
+        "https://opensource.org/licenses/IPA"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/IPL-1.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/IPL-1.0.json",
+      "referenceNumber": 443,
+      "name": "IBM Public License v1.0",
+      "licenseId": "IPL-1.0",
+      "seeAlso": [
+        "https://opensource.org/licenses/IPL-1.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/ISC.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/ISC.json",
+      "referenceNumber": 131,
+      "name": "ISC License",
+      "licenseId": "ISC",
+      "seeAlso": [
+        "https://www.isc.org/licenses/",
+        "https://www.isc.org/downloads/software-support-policy/isc-license/",
+        "https://opensource.org/licenses/ISC"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/ISC-Veillard.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/ISC-Veillard.json",
+      "referenceNumber": 554,
+      "name": "ISC Veillard variant",
+      "licenseId": "ISC-Veillard",
+      "seeAlso": [
+        "https://raw.githubusercontent.com/GNOME/libxml2/4c2e7c651f6c2f0d1a74f350cbda95f7df3e7017/hash.c",
+        "https://github.com/GNOME/libxml2/blob/master/dict.c",
+        "https://sourceforge.net/p/ctrio/git/ci/master/tree/README"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Jam.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Jam.json",
+      "referenceNumber": 338,
+      "name": "Jam License",
+      "licenseId": "Jam",
+      "seeAlso": [
+        "https://www.boost.org/doc/libs/1_35_0/doc/html/jam.html",
+        "https://web.archive.org/web/20160330173339/https://swarm.workshop.perforce.com/files/guest/perforce_software/jam/src/README"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/JasPer-2.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/JasPer-2.0.json",
+      "referenceNumber": 591,
+      "name": "JasPer License",
+      "licenseId": "JasPer-2.0",
+      "seeAlso": [
+        "http://www.ece.uvic.ca/~mdadams/jasper/LICENSE"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/JPL-image.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/JPL-image.json",
+      "referenceNumber": 343,
+      "name": "JPL Image Use Policy",
+      "licenseId": "JPL-image",
+      "seeAlso": [
+        "https://www.jpl.nasa.gov/jpl-image-use-policy"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/JPNIC.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/JPNIC.json",
+      "referenceNumber": 117,
+      "name": "Japan Network Information Center License",
+      "licenseId": "JPNIC",
+      "seeAlso": [
+        "https://gitlab.isc.org/isc-projects/bind9/blob/master/COPYRIGHT#L366"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/JSON.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/JSON.json",
+      "referenceNumber": 174,
+      "name": "JSON License",
+      "licenseId": "JSON",
+      "seeAlso": [
+        "http://www.json.org/license.html"
+      ],
+      "isOsiApproved": false,
+      "isFsfLibre": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Kastrup.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Kastrup.json",
+      "referenceNumber": 181,
+      "name": "Kastrup License",
+      "licenseId": "Kastrup",
+      "seeAlso": [
+        "https://ctan.math.utah.edu/ctan/tex-archive/macros/generic/kastrup/binhex.dtx"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Kazlib.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Kazlib.json",
+      "referenceNumber": 197,
+      "name": "Kazlib License",
+      "licenseId": "Kazlib",
+      "seeAlso": [
+        "http://git.savannah.gnu.org/cgit/kazlib.git/tree/except.c?id\u003d0062df360c2d17d57f6af19b0e444c51feb99036"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Knuth-CTAN.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Knuth-CTAN.json",
+      "referenceNumber": 22,
+      "name": "Knuth CTAN License",
+      "licenseId": "Knuth-CTAN",
+      "seeAlso": [
+        "https://ctan.org/license/knuth"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/LAL-1.2.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/LAL-1.2.json",
+      "referenceNumber": 261,
+      "name": "Licence Art Libre 1.2",
+      "licenseId": "LAL-1.2",
+      "seeAlso": [
+        "http://artlibre.org/licence/lal/licence-art-libre-12/"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/LAL-1.3.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/LAL-1.3.json",
+      "referenceNumber": 526,
+      "name": "Licence Art Libre 1.3",
+      "licenseId": "LAL-1.3",
+      "seeAlso": [
+        "https://artlibre.org/"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Latex2e.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Latex2e.json",
+      "referenceNumber": 3,
+      "name": "Latex2e License",
+      "licenseId": "Latex2e",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/Latex2e"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Latex2e-translated-notice.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Latex2e-translated-notice.json",
+      "referenceNumber": 104,
+      "name": "Latex2e with translated notice permission",
+      "licenseId": "Latex2e-translated-notice",
+      "seeAlso": [
+        "https://git.savannah.gnu.org/cgit/indent.git/tree/doc/indent.texi?id\u003da74c6b4ee49397cf330b333da1042bffa60ed14f#n74"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Leptonica.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Leptonica.json",
+      "referenceNumber": 221,
+      "name": "Leptonica License",
+      "licenseId": "Leptonica",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/Leptonica"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/LGPL-2.0.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/LGPL-2.0.json",
+      "referenceNumber": 81,
+      "name": "GNU Library General Public License v2 only",
+      "licenseId": "LGPL-2.0",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/lgpl-2.0-standalone.html"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/LGPL-2.0+.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/LGPL-2.0+.json",
+      "referenceNumber": 265,
+      "name": "GNU Library General Public License v2 or later",
+      "licenseId": "LGPL-2.0+",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/lgpl-2.0-standalone.html"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/LGPL-2.0-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/LGPL-2.0-only.json",
+      "referenceNumber": 517,
+      "name": "GNU Library General Public License v2 only",
+      "licenseId": "LGPL-2.0-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/lgpl-2.0-standalone.html"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/LGPL-2.0-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/LGPL-2.0-or-later.json",
+      "referenceNumber": 458,
+      "name": "GNU Library General Public License v2 or later",
+      "licenseId": "LGPL-2.0-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/lgpl-2.0-standalone.html"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/LGPL-2.1.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/LGPL-2.1.json",
+      "referenceNumber": 659,
+      "name": "GNU Lesser General Public License v2.1 only",
+      "licenseId": "LGPL-2.1",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/lgpl-2.1-standalone.html",
+        "https://opensource.org/licenses/LGPL-2.1"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/LGPL-2.1+.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/LGPL-2.1+.json",
+      "referenceNumber": 69,
+      "name": "GNU Lesser General Public License v2.1 or later",
+      "licenseId": "LGPL-2.1+",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/lgpl-2.1-standalone.html",
+        "https://opensource.org/licenses/LGPL-2.1"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/LGPL-2.1-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/LGPL-2.1-only.json",
+      "referenceNumber": 524,
+      "name": "GNU Lesser General Public License v2.1 only",
+      "licenseId": "LGPL-2.1-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/lgpl-2.1-standalone.html",
+        "https://opensource.org/licenses/LGPL-2.1"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/LGPL-2.1-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/LGPL-2.1-or-later.json",
+      "referenceNumber": 336,
+      "name": "GNU Lesser General Public License v2.1 or later",
+      "licenseId": "LGPL-2.1-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/old-licenses/lgpl-2.1-standalone.html",
+        "https://opensource.org/licenses/LGPL-2.1"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/LGPL-3.0.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/LGPL-3.0.json",
+      "referenceNumber": 381,
+      "name": "GNU Lesser General Public License v3.0 only",
+      "licenseId": "LGPL-3.0",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/lgpl-3.0-standalone.html",
+        "https://www.gnu.org/licenses/lgpl+gpl-3.0.txt",
+        "https://opensource.org/licenses/LGPL-3.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/LGPL-3.0+.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/LGPL-3.0+.json",
+      "referenceNumber": 303,
+      "name": "GNU Lesser General Public License v3.0 or later",
+      "licenseId": "LGPL-3.0+",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/lgpl-3.0-standalone.html",
+        "https://www.gnu.org/licenses/lgpl+gpl-3.0.txt",
+        "https://opensource.org/licenses/LGPL-3.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/LGPL-3.0-only.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/LGPL-3.0-only.json",
+      "referenceNumber": 225,
+      "name": "GNU Lesser General Public License v3.0 only",
+      "licenseId": "LGPL-3.0-only",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/lgpl-3.0-standalone.html",
+        "https://www.gnu.org/licenses/lgpl+gpl-3.0.txt",
+        "https://opensource.org/licenses/LGPL-3.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/LGPL-3.0-or-later.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/LGPL-3.0-or-later.json",
+      "referenceNumber": 411,
+      "name": "GNU Lesser General Public License v3.0 or later",
+      "licenseId": "LGPL-3.0-or-later",
+      "seeAlso": [
+        "https://www.gnu.org/licenses/lgpl-3.0-standalone.html",
+        "https://www.gnu.org/licenses/lgpl+gpl-3.0.txt",
+        "https://opensource.org/licenses/LGPL-3.0"
+      ],
+      "isOsiApproved": true,
+      "isFsfLibre": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/LGPLLR.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/LGPLLR.json",
+      "referenceNumber": 87,
+      "name": "Lesser General Public License For Linguistic Resources",
+      "licenseId": "LGPLLR",
       "seeAlso": [
-        "http://artlibre.org/licence/lal/licence-art-libre-12/"
+        "http://www-igm.univ-mlv.fr/~unitex/lgpllr.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/AGPL-1.0-only.html",
+      "reference": "https://spdx.org/licenses/Libpng.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/AGPL-1.0-only.json",
-      "referenceNumber": 200,
-      "name": "Affero General Public License v1.0 only",
-      "licenseId": "AGPL-1.0-only",
+      "detailsUrl": "https://spdx.org/licenses/Libpng.json",
+      "referenceNumber": 531,
+      "name": "libpng License",
+      "licenseId": "Libpng",
       "seeAlso": [
-        "http://www.affero.org/oagpl.html"
+        "http://www.libpng.org/pub/png/src/libpng-LICENSE.txt"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/MIT-enna.html",
+      "reference": "https://spdx.org/licenses/libpng-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MIT-enna.json",
-      "referenceNumber": 201,
-      "name": "enna License",
-      "licenseId": "MIT-enna",
+      "detailsUrl": "https://spdx.org/licenses/libpng-2.0.json",
+      "referenceNumber": 149,
+      "name": "PNG Reference Library version 2",
+      "licenseId": "libpng-2.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/MIT#enna"
+        "http://www.libpng.org/pub/png/src/libpng-LICENSE.txt"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Condor-1.1.html",
+      "reference": "https://spdx.org/licenses/libselinux-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Condor-1.1.json",
-      "referenceNumber": 202,
-      "name": "Condor Public License v1.1",
-      "licenseId": "Condor-1.1",
+      "detailsUrl": "https://spdx.org/licenses/libselinux-1.0.json",
+      "referenceNumber": 320,
+      "name": "libselinux public domain notice",
+      "licenseId": "libselinux-1.0",
       "seeAlso": [
-        "http://research.cs.wisc.edu/condor/license.html#condor",
-        "http://web.archive.org/web/20111123062036/http://research.cs.wisc.edu/condor/license.html#condor"
+        "https://github.com/SELinuxProject/selinux/blob/master/libselinux/LICENSE"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Naumen.html",
+      "reference": "https://spdx.org/licenses/libtiff.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Naumen.json",
-      "referenceNumber": 203,
-      "name": "Naumen Public License",
-      "licenseId": "Naumen",
+      "detailsUrl": "https://spdx.org/licenses/libtiff.json",
+      "referenceNumber": 24,
+      "name": "libtiff License",
+      "licenseId": "libtiff",
       "seeAlso": [
-        "https://opensource.org/licenses/Naumen"
+        "https://fedoraproject.org/wiki/Licensing/libtiff"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.3-no-invariants-or-later.html",
+      "reference": "https://spdx.org/licenses/libutil-David-Nugent.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.3-no-invariants-or-later.json",
-      "referenceNumber": 204,
-      "name": "GNU Free Documentation License v1.3 or later - no invariants",
-      "licenseId": "GFDL-1.3-no-invariants-or-later",
+      "detailsUrl": "https://spdx.org/licenses/libutil-David-Nugent.json",
+      "referenceNumber": 662,
+      "name": "libutil David Nugent License",
+      "licenseId": "libutil-David-Nugent",
       "seeAlso": [
-        "https://www.gnu.org/licenses/fdl-1.3.txt"
+        "http://web.mit.edu/freebsd/head/lib/libutil/login_ok.3",
+        "https://cgit.freedesktop.org/libbsd/tree/man/setproctitle.3bsd"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/RPL-1.5.html",
+      "reference": "https://spdx.org/licenses/LiLiQ-P-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/RPL-1.5.json",
-      "referenceNumber": 205,
-      "name": "Reciprocal Public License 1.5",
-      "licenseId": "RPL-1.5",
+      "detailsUrl": "https://spdx.org/licenses/LiLiQ-P-1.1.json",
+      "referenceNumber": 150,
+      "name": "Licence Libre du Québec – Permissive version 1.1",
+      "licenseId": "LiLiQ-P-1.1",
       "seeAlso": [
-        "https://opensource.org/licenses/RPL-1.5"
+        "https://forge.gouv.qc.ca/licence/fr/liliq-v1-1/",
+        "http://opensource.org/licenses/LiLiQ-P-1.1"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/PolyForm-Small-Business-1.0.0.html",
+      "reference": "https://spdx.org/licenses/LiLiQ-R-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/PolyForm-Small-Business-1.0.0.json",
-      "referenceNumber": 206,
-      "name": "PolyForm Small Business License 1.0.0",
-      "licenseId": "PolyForm-Small-Business-1.0.0",
+      "detailsUrl": "https://spdx.org/licenses/LiLiQ-R-1.1.json",
+      "referenceNumber": 203,
+      "name": "Licence Libre du Québec – Réciprocité version 1.1",
+      "licenseId": "LiLiQ-R-1.1",
       "seeAlso": [
-        "https://polyformproject.org/licenses/small-business/1.0.0"
+        "https://www.forge.gouv.qc.ca/participez/licence-logicielle/licence-libre-du-quebec-liliq-en-francais/licence-libre-du-quebec-reciprocite-liliq-r-v1-1/",
+        "http://opensource.org/licenses/LiLiQ-R-1.1"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/EFL-1.0.html",
+      "reference": "https://spdx.org/licenses/LiLiQ-Rplus-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/EFL-1.0.json",
-      "referenceNumber": 207,
-      "name": "Eiffel Forum License v1.0",
-      "licenseId": "EFL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/LiLiQ-Rplus-1.1.json",
+      "referenceNumber": 314,
+      "name": "Licence Libre du Québec – Réciprocité forte version 1.1",
+      "licenseId": "LiLiQ-Rplus-1.1",
       "seeAlso": [
-        "http://www.eiffel-nice.org/license/forum.txt",
-        "https://opensource.org/licenses/EFL-1.0"
+        "https://www.forge.gouv.qc.ca/participez/licence-logicielle/licence-libre-du-quebec-liliq-en-francais/licence-libre-du-quebec-reciprocite-forte-liliq-r-v1-1/",
+        "http://opensource.org/licenses/LiLiQ-Rplus-1.1"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/MirOS.html",
+      "reference": "https://spdx.org/licenses/Linux-man-pages-1-para.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MirOS.json",
-      "referenceNumber": 208,
-      "name": "The MirOS Licence",
-      "licenseId": "MirOS",
+      "detailsUrl": "https://spdx.org/licenses/Linux-man-pages-1-para.json",
+      "referenceNumber": 577,
+      "name": "Linux man-pages - 1 paragraph",
+      "licenseId": "Linux-man-pages-1-para",
       "seeAlso": [
-        "https://opensource.org/licenses/MirOS"
+        "https://git.kernel.org/pub/scm/docs/man-pages/man-pages.git/tree/man2/getcpu.2#n4"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-2.5-AU.html",
+      "reference": "https://spdx.org/licenses/Linux-man-pages-copyleft.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-2.5-AU.json",
-      "referenceNumber": 209,
-      "name": "Creative Commons Attribution 2.5 Australia",
-      "licenseId": "CC-BY-2.5-AU",
+      "detailsUrl": "https://spdx.org/licenses/Linux-man-pages-copyleft.json",
+      "referenceNumber": 213,
+      "name": "Linux man-pages Copyleft",
+      "licenseId": "Linux-man-pages-copyleft",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by/2.5/au/legalcode"
+        "https://www.kernel.org/doc/man-pages/licenses.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Afmparse.html",
+      "reference": "https://spdx.org/licenses/Linux-man-pages-copyleft-2-para.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Afmparse.json",
-      "referenceNumber": 210,
-      "name": "Afmparse License",
-      "licenseId": "Afmparse",
+      "detailsUrl": "https://spdx.org/licenses/Linux-man-pages-copyleft-2-para.json",
+      "referenceNumber": 352,
+      "name": "Linux man-pages Copyleft - 2 paragraphs",
+      "licenseId": "Linux-man-pages-copyleft-2-para",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Afmparse"
+        "https://git.kernel.org/pub/scm/docs/man-pages/man-pages.git/tree/man2/move_pages.2#n5",
+        "https://git.kernel.org/pub/scm/docs/man-pages/man-pages.git/tree/man2/migrate_pages.2#n8"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/MPL-2.0-no-copyleft-exception.html",
+      "reference": "https://spdx.org/licenses/Linux-man-pages-copyleft-var.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MPL-2.0-no-copyleft-exception.json",
-      "referenceNumber": 211,
-      "name": "Mozilla Public License 2.0 (no copyleft exception)",
-      "licenseId": "MPL-2.0-no-copyleft-exception",
+      "detailsUrl": "https://spdx.org/licenses/Linux-man-pages-copyleft-var.json",
+      "referenceNumber": 186,
+      "name": "Linux man-pages Copyleft Variant",
+      "licenseId": "Linux-man-pages-copyleft-var",
       "seeAlso": [
-        "https://www.mozilla.org/MPL/2.0/",
-        "https://opensource.org/licenses/MPL-2.0"
+        "https://git.kernel.org/pub/scm/docs/man-pages/man-pages.git/tree/man2/set_mempolicy.2#n5"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LiLiQ-Rplus-1.1.html",
+      "reference": "https://spdx.org/licenses/Linux-OpenIB.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LiLiQ-Rplus-1.1.json",
-      "referenceNumber": 212,
-      "name": "Licence Libre du Québec – Réciprocité forte version 1.1",
-      "licenseId": "LiLiQ-Rplus-1.1",
+      "detailsUrl": "https://spdx.org/licenses/Linux-OpenIB.json",
+      "referenceNumber": 278,
+      "name": "Linux Kernel Variant of OpenIB.org license",
+      "licenseId": "Linux-OpenIB",
       "seeAlso": [
-        "https://www.forge.gouv.qc.ca/participez/licence-logicielle/licence-libre-du-quebec-liliq-en-francais/licence-libre-du-quebec-reciprocite-forte-liliq-r-v1-1/",
-        "http://opensource.org/licenses/LiLiQ-Rplus-1.1"
+        "https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/infiniband/core/sa.h"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/AFL-1.2.html",
+      "reference": "https://spdx.org/licenses/LOOP.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/AFL-1.2.json",
-      "referenceNumber": 213,
-      "name": "Academic Free License v1.2",
-      "licenseId": "AFL-1.2",
+      "detailsUrl": "https://spdx.org/licenses/LOOP.json",
+      "referenceNumber": 521,
+      "name": "Common Lisp LOOP License",
+      "licenseId": "LOOP",
       "seeAlso": [
-        "http://opensource.linux-mirror.org/licenses/afl-1.2.txt",
-        "http://wayback.archive.org/web/20021204204652/http://www.opensource.org/licenses/academic.php"
+        "https://gitlab.com/embeddable-common-lisp/ecl/-/blob/develop/src/lsp/loop.lsp",
+        "http://git.savannah.gnu.org/cgit/gcl.git/tree/gcl/lsp/gcl_loop.lsp?h\u003dVersion_2_6_13pre",
+        "https://sourceforge.net/p/sbcl/sbcl/ci/master/tree/src/code/loop.lisp",
+        "https://github.com/cl-adams/adams/blob/master/LICENSE.md",
+        "https://github.com/blakemcbride/eclipse-lisp/blob/master/lisp/loop.lisp",
+        "https://gitlab.common-lisp.net/cmucl/cmucl/-/blob/master/src/code/loop.lisp"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OSL-1.0.html",
+      "reference": "https://spdx.org/licenses/LPD-document.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OSL-1.0.json",
-      "referenceNumber": 214,
-      "name": "Open Software License 1.0",
-      "licenseId": "OSL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/LPD-document.json",
+      "referenceNumber": 561,
+      "name": "LPD Documentation License",
+      "licenseId": "LPD-document",
       "seeAlso": [
-        "https://opensource.org/licenses/OSL-1.0"
+        "https://github.com/Cyan4973/xxHash/blob/dev/doc/xxhash_spec.md",
+        "https://www.ietf.org/rfc/rfc1952.txt"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-1.0-only.html",
+      "reference": "https://spdx.org/licenses/LPL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GPL-1.0-only.json",
-      "referenceNumber": 215,
-      "name": "GNU General Public License v1.0 only",
-      "licenseId": "GPL-1.0-only",
+      "detailsUrl": "https://spdx.org/licenses/LPL-1.0.json",
+      "referenceNumber": 267,
+      "name": "Lucent Public License Version 1.0",
+      "licenseId": "LPL-1.0",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/gpl-1.0-standalone.html"
+        "https://opensource.org/licenses/LPL-1.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/APSL-1.0.html",
+      "reference": "https://spdx.org/licenses/LPL-1.02.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/APSL-1.0.json",
-      "referenceNumber": 216,
-      "name": "Apple Public Source License 1.0",
-      "licenseId": "APSL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/LPL-1.02.json",
+      "referenceNumber": 122,
+      "name": "Lucent Public License v1.02",
+      "licenseId": "LPL-1.02",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Apple_Public_Source_License_1.0"
+        "http://plan9.bell-labs.com/plan9/license.html",
+        "https://opensource.org/licenses/LPL-1.02"
       ],
       "isOsiApproved": true,
-      "isFsfLibre": false
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/OGL-Canada-2.0.html",
+      "reference": "https://spdx.org/licenses/LPPL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OGL-Canada-2.0.json",
-      "referenceNumber": 217,
-      "name": "Open Government Licence - Canada",
-      "licenseId": "OGL-Canada-2.0",
+      "detailsUrl": "https://spdx.org/licenses/LPPL-1.0.json",
+      "referenceNumber": 133,
+      "name": "LaTeX Project Public License v1.0",
+      "licenseId": "LPPL-1.0",
       "seeAlso": [
-        "https://open.canada.ca/en/open-government-licence-canada"
+        "http://www.latex-project.org/lppl/lppl-1-0.txt"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CPAL-1.0.html",
+      "reference": "https://spdx.org/licenses/LPPL-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CPAL-1.0.json",
-      "referenceNumber": 218,
-      "name": "Common Public Attribution License 1.0",
-      "licenseId": "CPAL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/LPPL-1.1.json",
+      "referenceNumber": 284,
+      "name": "LaTeX Project Public License v1.1",
+      "licenseId": "LPPL-1.1",
       "seeAlso": [
-        "https://opensource.org/licenses/CPAL-1.0"
+        "http://www.latex-project.org/lppl/lppl-1-1.txt"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Latex2e.html",
+      "reference": "https://spdx.org/licenses/LPPL-1.2.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Latex2e.json",
-      "referenceNumber": 219,
-      "name": "Latex2e License",
-      "licenseId": "Latex2e",
+      "detailsUrl": "https://spdx.org/licenses/LPPL-1.2.json",
+      "referenceNumber": 407,
+      "name": "LaTeX Project Public License v1.2",
+      "licenseId": "LPPL-1.2",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Latex2e"
+        "http://www.latex-project.org/lppl/lppl-1-2.txt"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Zend-2.0.html",
+      "reference": "https://spdx.org/licenses/LPPL-1.3a.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Zend-2.0.json",
-      "referenceNumber": 220,
-      "name": "Zend License v2.0",
-      "licenseId": "Zend-2.0",
+      "detailsUrl": "https://spdx.org/licenses/LPPL-1.3a.json",
+      "referenceNumber": 510,
+      "name": "LaTeX Project Public License v1.3a",
+      "licenseId": "LPPL-1.3a",
       "seeAlso": [
-        "https://web.archive.org/web/20130517195954/http://www.zend.com/license/2_00.txt"
+        "http://www.latex-project.org/lppl/lppl-1-3a.txt"
       ],
       "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Unlicense.html",
+      "reference": "https://spdx.org/licenses/LPPL-1.3c.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Unlicense.json",
-      "referenceNumber": 221,
-      "name": "The Unlicense",
-      "licenseId": "Unlicense",
+      "detailsUrl": "https://spdx.org/licenses/LPPL-1.3c.json",
+      "referenceNumber": 300,
+      "name": "LaTeX Project Public License v1.3c",
+      "licenseId": "LPPL-1.3c",
       "seeAlso": [
-        "https://unlicense.org/"
+        "http://www.latex-project.org/lppl/lppl-1-3c.txt",
+        "https://opensource.org/licenses/LPPL-1.3c"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/xpp.html",
+      "reference": "https://spdx.org/licenses/lsof.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/xpp.json",
-      "referenceNumber": 222,
-      "name": "XPP License",
-      "licenseId": "xpp",
+      "detailsUrl": "https://spdx.org/licenses/lsof.json",
+      "referenceNumber": 76,
+      "name": "lsof License",
+      "licenseId": "lsof",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/xpp"
+        "https://github.com/lsof-org/lsof/blob/master/COPYING"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-1.0.html",
+      "reference": "https://spdx.org/licenses/Lucida-Bitmap-Fonts.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-1.0.json",
-      "referenceNumber": 223,
-      "name": "Creative Commons Attribution Non Commercial 1.0 Generic",
-      "licenseId": "CC-BY-NC-1.0",
+      "detailsUrl": "https://spdx.org/licenses/Lucida-Bitmap-Fonts.json",
+      "referenceNumber": 383,
+      "name": "Lucida Bitmap Fonts License",
+      "licenseId": "Lucida-Bitmap-Fonts",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc/1.0/legalcode"
+        "https://gitlab.freedesktop.org/xorg/font/bh-100dpi/-/blob/master/COPYING?ref_type\u003dheads"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-3.0-with-autoconf-exception.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GPL-3.0-with-autoconf-exception.json",
-      "referenceNumber": 224,
-      "name": "GNU General Public License v3.0 w/Autoconf exception",
-      "licenseId": "GPL-3.0-with-autoconf-exception",
+      "reference": "https://spdx.org/licenses/LZMA-SDK-9.11-to-9.20.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/LZMA-SDK-9.11-to-9.20.json",
+      "referenceNumber": 239,
+      "name": "LZMA SDK License (versions 9.11 to 9.20)",
+      "licenseId": "LZMA-SDK-9.11-to-9.20",
       "seeAlso": [
-        "https://www.gnu.org/licenses/autoconf-exception-3.0.html"
+        "https://www.7-zip.org/sdk.html",
+        "https://sourceforge.net/projects/sevenzip/files/LZMA%20SDK/"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-3.0.html",
+      "reference": "https://spdx.org/licenses/LZMA-SDK-9.22.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-3.0.json",
-      "referenceNumber": 225,
-      "name": "Creative Commons Attribution Non Commercial Share Alike 3.0 Unported",
-      "licenseId": "CC-BY-NC-SA-3.0",
+      "detailsUrl": "https://spdx.org/licenses/LZMA-SDK-9.22.json",
+      "referenceNumber": 600,
+      "name": "LZMA SDK License (versions 9.22 and beyond)",
+      "licenseId": "LZMA-SDK-9.22",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-sa/3.0/legalcode"
+        "https://www.7-zip.org/sdk.html",
+        "https://sourceforge.net/projects/sevenzip/files/LZMA%20SDK/"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/TCP-wrappers.html",
+      "reference": "https://spdx.org/licenses/Mackerras-3-Clause.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/TCP-wrappers.json",
-      "referenceNumber": 226,
-      "name": "TCP Wrappers License",
-      "licenseId": "TCP-wrappers",
+      "detailsUrl": "https://spdx.org/licenses/Mackerras-3-Clause.json",
+      "referenceNumber": 540,
+      "name": "Mackerras 3-Clause License",
+      "licenseId": "Mackerras-3-Clause",
       "seeAlso": [
-        "http://rc.quest.com/topics/openssh/license.php#tcpwrappers"
+        "https://github.com/ppp-project/ppp/blob/master/pppd/chap_ms.c#L6-L28"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/SCEA.html",
+      "reference": "https://spdx.org/licenses/Mackerras-3-Clause-acknowledgment.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SCEA.json",
-      "referenceNumber": 227,
-      "name": "SCEA Shared Source License",
-      "licenseId": "SCEA",
+      "detailsUrl": "https://spdx.org/licenses/Mackerras-3-Clause-acknowledgment.json",
+      "referenceNumber": 176,
+      "name": "Mackerras 3-Clause - acknowledgment variant",
+      "licenseId": "Mackerras-3-Clause-acknowledgment",
       "seeAlso": [
-        "http://research.scea.com/scea_shared_source_license.html"
+        "https://github.com/ppp-project/ppp/blob/master/pppd/auth.c#L6-L28"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/SSH-short.html",
+      "reference": "https://spdx.org/licenses/magaz.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SSH-short.json",
-      "referenceNumber": 228,
-      "name": "SSH short notice",
-      "licenseId": "SSH-short",
+      "detailsUrl": "https://spdx.org/licenses/magaz.json",
+      "referenceNumber": 93,
+      "name": "magaz License",
+      "licenseId": "magaz",
       "seeAlso": [
-        "https://github.com/openssh/openssh-portable/blob/1b11ea7c58cd5c59838b5fa574cd456d6047b2d4/pathnames.h",
-        "http://web.mit.edu/kolya/.f/root/athena.mit.edu/sipb.mit.edu/project/openssh/OldFiles/src/openssh-2.9.9p2/ssh-add.1",
-        "https://joinup.ec.europa.eu/svn/lesoll/trunk/italc/lib/src/dsa_key.cpp"
+        "https://mirrors.nic.cz/tex-archive/macros/latex/contrib/magaz/magaz.tex"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-3.0-NL.html",
+      "reference": "https://spdx.org/licenses/mailprio.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-3.0-NL.json",
-      "referenceNumber": 229,
-      "name": "Creative Commons Attribution 3.0 Netherlands",
-      "licenseId": "CC-BY-3.0-NL",
+      "detailsUrl": "https://spdx.org/licenses/mailprio.json",
+      "referenceNumber": 292,
+      "name": "mailprio License",
+      "licenseId": "mailprio",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by/3.0/nl/legalcode"
+        "https://fossies.org/linux/sendmail/contrib/mailprio"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/SchemeReport.html",
+      "reference": "https://spdx.org/licenses/MakeIndex.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SchemeReport.json",
-      "referenceNumber": 230,
-      "name": "Scheme Language Report License",
-      "licenseId": "SchemeReport",
-      "seeAlso": [],
+      "detailsUrl": "https://spdx.org/licenses/MakeIndex.json",
+      "referenceNumber": 552,
+      "name": "MakeIndex License",
+      "licenseId": "MakeIndex",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/MakeIndex"
+      ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-3.0.html",
+      "reference": "https://spdx.org/licenses/Martin-Birgmeier.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-3.0.json",
-      "referenceNumber": 231,
-      "name": "Creative Commons Attribution 3.0 Unported",
-      "licenseId": "CC-BY-3.0",
+      "detailsUrl": "https://spdx.org/licenses/Martin-Birgmeier.json",
+      "referenceNumber": 364,
+      "name": "Martin Birgmeier License",
+      "licenseId": "Martin-Birgmeier",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by/3.0/legalcode"
+        "https://github.com/Perl/perl5/blob/blead/util.c#L6136"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/MPL-2.0.html",
+      "reference": "https://spdx.org/licenses/McPhee-slideshow.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MPL-2.0.json",
-      "referenceNumber": 232,
-      "name": "Mozilla Public License 2.0",
-      "licenseId": "MPL-2.0",
+      "detailsUrl": "https://spdx.org/licenses/McPhee-slideshow.json",
+      "referenceNumber": 511,
+      "name": "McPhee Slideshow License",
+      "licenseId": "McPhee-slideshow",
       "seeAlso": [
-        "https://www.mozilla.org/MPL/2.0/",
-        "https://opensource.org/licenses/MPL-2.0"
+        "https://mirror.las.iastate.edu/tex-archive/graphics/metapost/contrib/macros/slideshow/slideshow.mp"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Unicode-TOU.html",
+      "reference": "https://spdx.org/licenses/metamail.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Unicode-TOU.json",
-      "referenceNumber": 233,
-      "name": "Unicode Terms of Use",
-      "licenseId": "Unicode-TOU",
+      "detailsUrl": "https://spdx.org/licenses/metamail.json",
+      "referenceNumber": 325,
+      "name": "metamail License",
+      "licenseId": "metamail",
       "seeAlso": [
-        "http://www.unicode.org/copyright.html"
+        "https://github.com/Dual-Life/mime-base64/blob/master/Base64.xs#L12"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-ND-1.0.html",
+      "reference": "https://spdx.org/licenses/Minpack.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-ND-1.0.json",
-      "referenceNumber": 234,
-      "name": "Creative Commons Attribution Non Commercial No Derivatives 1.0 Generic",
-      "licenseId": "CC-BY-NC-ND-1.0",
+      "detailsUrl": "https://spdx.org/licenses/Minpack.json",
+      "referenceNumber": 634,
+      "name": "Minpack License",
+      "licenseId": "Minpack",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nd-nc/1.0/legalcode"
+        "http://www.netlib.org/minpack/disclaimer",
+        "https://gitlab.com/libeigen/eigen/-/blob/master/COPYING.MINPACK"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Entessa.html",
+      "reference": "https://spdx.org/licenses/MirOS.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Entessa.json",
-      "referenceNumber": 235,
-      "name": "Entessa Public License v1.0",
-      "licenseId": "Entessa",
+      "detailsUrl": "https://spdx.org/licenses/MirOS.json",
+      "referenceNumber": 202,
+      "name": "The MirOS Licence",
+      "licenseId": "MirOS",
       "seeAlso": [
-        "https://opensource.org/licenses/Entessa"
+        "https://opensource.org/licenses/MirOS"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-3-Clause-No-Nuclear-License.html",
+      "reference": "https://spdx.org/licenses/MIT.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-No-Nuclear-License.json",
-      "referenceNumber": 236,
-      "name": "BSD 3-Clause No Nuclear License",
-      "licenseId": "BSD-3-Clause-No-Nuclear-License",
+      "detailsUrl": "https://spdx.org/licenses/MIT.json",
+      "referenceNumber": 601,
+      "name": "MIT License",
+      "licenseId": "MIT",
       "seeAlso": [
-        "http://download.oracle.com/otn-pub/java/licenses/bsd.txt?AuthParam\u003d1467140197_43d516ce1776bd08a58235a7785be1cc"
+        "https://opensource.org/license/mit/"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/SWL.html",
+      "reference": "https://spdx.org/licenses/MIT-0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SWL.json",
-      "referenceNumber": 237,
-      "name": "Scheme Widget Library (SWL) Software License Agreement",
-      "licenseId": "SWL",
+      "detailsUrl": "https://spdx.org/licenses/MIT-0.json",
+      "referenceNumber": 587,
+      "name": "MIT No Attribution",
+      "licenseId": "MIT-0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/SWL"
+        "https://github.com/aws/mit-0",
+        "https://romanrm.net/mit-zero",
+        "https://github.com/awsdocs/aws-cloud9-user-guide/blob/master/LICENSE-SAMPLECODE"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.2-no-invariants-only.html",
+      "reference": "https://spdx.org/licenses/MIT-advertising.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.2-no-invariants-only.json",
-      "referenceNumber": 238,
-      "name": "GNU Free Documentation License v1.2 only - no invariants",
-      "licenseId": "GFDL-1.2-no-invariants-only",
+      "detailsUrl": "https://spdx.org/licenses/MIT-advertising.json",
+      "referenceNumber": 39,
+      "name": "Enlightenment License (e16)",
+      "licenseId": "MIT-advertising",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/fdl-1.2.txt"
+        "https://fedoraproject.org/wiki/Licensing/MIT_With_Advertising"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Parity-7.0.0.html",
+      "reference": "https://spdx.org/licenses/MIT-CMU.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Parity-7.0.0.json",
-      "referenceNumber": 239,
-      "name": "The Parity Public License 7.0.0",
-      "licenseId": "Parity-7.0.0",
+      "detailsUrl": "https://spdx.org/licenses/MIT-CMU.json",
+      "referenceNumber": 36,
+      "name": "CMU License",
+      "licenseId": "MIT-CMU",
       "seeAlso": [
-        "https://paritylicense.com/versions/7.0.0.html"
+        "https://fedoraproject.org/wiki/Licensing:MIT?rd\u003dLicensing/MIT#CMU_Style",
+        "https://github.com/python-pillow/Pillow/blob/fffb426092c8db24a5f4b6df243a8a3c01fb63cd/LICENSE"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-2.2.1.html",
+      "reference": "https://spdx.org/licenses/MIT-enna.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.2.1.json",
-      "referenceNumber": 240,
-      "name": "Open LDAP Public License v2.2.1",
-      "licenseId": "OLDAP-2.2.1",
+      "detailsUrl": "https://spdx.org/licenses/MIT-enna.json",
+      "referenceNumber": 207,
+      "name": "enna License",
+      "licenseId": "MIT-enna",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d4bc786f34b50aa301be6f5600f58a980070f481e"
+        "https://fedoraproject.org/wiki/Licensing/MIT#enna"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/SGI-B-1.1.html",
+      "reference": "https://spdx.org/licenses/MIT-feh.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SGI-B-1.1.json",
-      "referenceNumber": 241,
-      "name": "SGI Free Software License B v1.1",
-      "licenseId": "SGI-B-1.1",
+      "detailsUrl": "https://spdx.org/licenses/MIT-feh.json",
+      "referenceNumber": 146,
+      "name": "feh License",
+      "licenseId": "MIT-feh",
       "seeAlso": [
-        "http://oss.sgi.com/projects/FreeB/"
+        "https://fedoraproject.org/wiki/Licensing/MIT#feh"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/FTL.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/FTL.json",
-      "referenceNumber": 242,
-      "name": "Freetype Project License",
-      "licenseId": "FTL",
-      "seeAlso": [
-        "http://freetype.fis.uniroma2.it/FTL.TXT",
-        "http://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/docs/FTL.TXT",
-        "http://gitlab.freedesktop.org/freetype/freetype/-/raw/master/docs/FTL.TXT"
-      ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
-    },
-    {
-      "reference": "https://spdx.org/licenses/OLDAP-2.4.html",
+      "reference": "https://spdx.org/licenses/MIT-Festival.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.4.json",
-      "referenceNumber": 243,
-      "name": "Open LDAP Public License v2.4",
-      "licenseId": "OLDAP-2.4",
+      "detailsUrl": "https://spdx.org/licenses/MIT-Festival.json",
+      "referenceNumber": 431,
+      "name": "MIT Festival Variant",
+      "licenseId": "MIT-Festival",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003dcd1284c4a91a8a380d904eee68d1583f989ed386"
+        "https://github.com/festvox/flite/blob/master/COPYING",
+        "https://github.com/festvox/speech_tools/blob/master/COPYING"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-4.0.html",
+      "reference": "https://spdx.org/licenses/MIT-Khronos-old.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-4.0.json",
-      "referenceNumber": 244,
-      "name": "Creative Commons Attribution Non Commercial 4.0 International",
-      "licenseId": "CC-BY-NC-4.0",
+      "detailsUrl": "https://spdx.org/licenses/MIT-Khronos-old.json",
+      "referenceNumber": 68,
+      "name": "MIT Khronos - old variant",
+      "licenseId": "MIT-Khronos-old",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc/4.0/legalcode"
+        "https://github.com/KhronosGroup/SPIRV-Cross/blob/main/LICENSES/LicenseRef-KhronosFreeUse.txt"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/bzip2-1.0.6.html",
+      "reference": "https://spdx.org/licenses/MIT-Modern-Variant.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/bzip2-1.0.6.json",
-      "referenceNumber": 245,
-      "name": "bzip2 and libbzip2 License v1.0.6",
-      "licenseId": "bzip2-1.0.6",
+      "detailsUrl": "https://spdx.org/licenses/MIT-Modern-Variant.json",
+      "referenceNumber": 92,
+      "name": "MIT License Modern Variant",
+      "licenseId": "MIT-Modern-Variant",
       "seeAlso": [
-        "https://sourceware.org/git/?p\u003dbzip2.git;a\u003dblob;f\u003dLICENSE;hb\u003dbzip2-1.0.6",
-        "http://bzip.org/1.0.5/bzip2-manual-1.0.5.html"
+        "https://fedoraproject.org/wiki/Licensing:MIT#Modern_Variants",
+        "https://ptolemy.berkeley.edu/copyright.htm",
+        "https://pirlwww.lpl.arizona.edu/resources/guide/software/PerlTk/Tixlic.html"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/copyleft-next-0.3.0.html",
+      "reference": "https://spdx.org/licenses/MIT-open-group.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/copyleft-next-0.3.0.json",
-      "referenceNumber": 246,
-      "name": "copyleft-next 0.3.0",
-      "licenseId": "copyleft-next-0.3.0",
+      "detailsUrl": "https://spdx.org/licenses/MIT-open-group.json",
+      "referenceNumber": 520,
+      "name": "MIT Open Group variant",
+      "licenseId": "MIT-open-group",
       "seeAlso": [
-        "https://github.com/copyleft-next/copyleft-next/blob/master/Releases/copyleft-next-0.3.0"
+        "https://gitlab.freedesktop.org/xorg/app/iceauth/-/blob/master/COPYING",
+        "https://gitlab.freedesktop.org/xorg/app/xvinfo/-/blob/master/COPYING",
+        "https://gitlab.freedesktop.org/xorg/app/xsetroot/-/blob/master/COPYING",
+        "https://gitlab.freedesktop.org/xorg/app/xauth/-/blob/master/COPYING"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/MakeIndex.html",
+      "reference": "https://spdx.org/licenses/MIT-testregex.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MakeIndex.json",
-      "referenceNumber": 247,
-      "name": "MakeIndex License",
-      "licenseId": "MakeIndex",
+      "detailsUrl": "https://spdx.org/licenses/MIT-testregex.json",
+      "referenceNumber": 578,
+      "name": "MIT testregex Variant",
+      "licenseId": "MIT-testregex",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/MakeIndex"
+        "https://github.com/dotnet/runtime/blob/55e1ac7c07df62c4108d4acedf78f77574470ce5/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/AttRegexTests.cs#L12-L28"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/NRL.html",
+      "reference": "https://spdx.org/licenses/MIT-Wu.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NRL.json",
-      "referenceNumber": 248,
-      "name": "NRL License",
-      "licenseId": "NRL",
+      "detailsUrl": "https://spdx.org/licenses/MIT-Wu.json",
+      "referenceNumber": 156,
+      "name": "MIT Tom Wu Variant",
+      "licenseId": "MIT-Wu",
       "seeAlso": [
-        "http://web.mit.edu/network/isakmp/nrllicense.html"
+        "https://github.com/chromium/octane/blob/master/crypto.js"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.3-invariants-or-later.html",
+      "reference": "https://spdx.org/licenses/MITNFA.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.3-invariants-or-later.json",
-      "referenceNumber": 249,
-      "name": "GNU Free Documentation License v1.3 or later - invariants",
-      "licenseId": "GFDL-1.3-invariants-or-later",
+      "detailsUrl": "https://spdx.org/licenses/MITNFA.json",
+      "referenceNumber": 650,
+      "name": "MIT +no-false-attribs license",
+      "licenseId": "MITNFA",
       "seeAlso": [
-        "https://www.gnu.org/licenses/fdl-1.3.txt"
+        "https://fedoraproject.org/wiki/Licensing/MITNFA"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-2.0.html",
+      "reference": "https://spdx.org/licenses/MMIXware.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-2.0.json",
-      "referenceNumber": 250,
-      "name": "Creative Commons Attribution Non Commercial 2.0 Generic",
-      "licenseId": "CC-BY-NC-2.0",
+      "detailsUrl": "https://spdx.org/licenses/MMIXware.json",
+      "referenceNumber": 444,
+      "name": "MMIXware License",
+      "licenseId": "MMIXware",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc/2.0/legalcode"
+        "https://gitlab.lrz.de/mmix/mmixware/-/blob/master/boilerplate.w"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/SugarCRM-1.1.3.html",
+      "reference": "https://spdx.org/licenses/Motosoto.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SugarCRM-1.1.3.json",
-      "referenceNumber": 251,
-      "name": "SugarCRM Public License v1.1.3",
-      "licenseId": "SugarCRM-1.1.3",
+      "detailsUrl": "https://spdx.org/licenses/Motosoto.json",
+      "referenceNumber": 31,
+      "name": "Motosoto License",
+      "licenseId": "Motosoto",
       "seeAlso": [
-        "http://www.sugarcrm.com/crm/SPL"
+        "https://opensource.org/licenses/Motosoto"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/AFL-2.1.html",
+      "reference": "https://spdx.org/licenses/MPEG-SSG.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/AFL-2.1.json",
-      "referenceNumber": 252,
-      "name": "Academic Free License v2.1",
-      "licenseId": "AFL-2.1",
+      "detailsUrl": "https://spdx.org/licenses/MPEG-SSG.json",
+      "referenceNumber": 323,
+      "name": "MPEG Software Simulation",
+      "licenseId": "MPEG-SSG",
       "seeAlso": [
-        "http://opensource.linux-mirror.org/licenses/afl-2.1.txt"
+        "https://sourceforge.net/p/netpbm/code/HEAD/tree/super_stable/converter/ppm/ppmtompeg/jrevdct.c#l1189"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-2.0-only.html",
+      "reference": "https://spdx.org/licenses/mpi-permissive.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GPL-2.0-only.json",
-      "referenceNumber": 253,
-      "name": "GNU General Public License v2.0 only",
-      "licenseId": "GPL-2.0-only",
+      "detailsUrl": "https://spdx.org/licenses/mpi-permissive.json",
+      "referenceNumber": 459,
+      "name": "mpi Permissive License",
+      "licenseId": "mpi-permissive",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html",
-        "https://opensource.org/licenses/GPL-2.0"
+        "https://sources.debian.org/src/openmpi/4.1.0-10/ompi/debuggers/msgq_interface.h/?hl\u003d19#L19"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.3-invariants-only.html",
+      "reference": "https://spdx.org/licenses/mpich2.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.3-invariants-only.json",
-      "referenceNumber": 254,
-      "name": "GNU Free Documentation License v1.3 only - invariants",
-      "licenseId": "GFDL-1.3-invariants-only",
+      "detailsUrl": "https://spdx.org/licenses/mpich2.json",
+      "referenceNumber": 448,
+      "name": "mpich2 License",
+      "licenseId": "mpich2",
       "seeAlso": [
-        "https://www.gnu.org/licenses/fdl-1.3.txt"
+        "https://fedoraproject.org/wiki/Licensing/MIT"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/TORQUE-1.1.html",
+      "reference": "https://spdx.org/licenses/MPL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/TORQUE-1.1.json",
-      "referenceNumber": 255,
-      "name": "TORQUE v2.5+ Software License v1.1",
-      "licenseId": "TORQUE-1.1",
+      "detailsUrl": "https://spdx.org/licenses/MPL-1.0.json",
+      "referenceNumber": 248,
+      "name": "Mozilla Public License 1.0",
+      "licenseId": "MPL-1.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/TORQUEv1.1"
+        "http://www.mozilla.org/MPL/MPL-1.0.html",
+        "https://opensource.org/licenses/MPL-1.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/Ruby.html",
+      "reference": "https://spdx.org/licenses/MPL-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Ruby.json",
-      "referenceNumber": 256,
-      "name": "Ruby License",
-      "licenseId": "Ruby",
+      "detailsUrl": "https://spdx.org/licenses/MPL-1.1.json",
+      "referenceNumber": 219,
+      "name": "Mozilla Public License 1.1",
+      "licenseId": "MPL-1.1",
       "seeAlso": [
-        "http://www.ruby-lang.org/en/LICENSE.txt"
+        "http://www.mozilla.org/MPL/MPL-1.1.html",
+        "https://opensource.org/licenses/MPL-1.1"
       ],
-      "isOsiApproved": false,
+      "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/X11.html",
+      "reference": "https://spdx.org/licenses/MPL-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/X11.json",
-      "referenceNumber": 257,
-      "name": "X11 License",
-      "licenseId": "X11",
+      "detailsUrl": "https://spdx.org/licenses/MPL-2.0.json",
+      "referenceNumber": 147,
+      "name": "Mozilla Public License 2.0",
+      "licenseId": "MPL-2.0",
       "seeAlso": [
-        "http://www.xfree86.org/3.3.6/COPYRIGHT2.html#3"
+        "https://www.mozilla.org/MPL/2.0/",
+        "https://opensource.org/licenses/MPL-2.0"
       ],
-      "isOsiApproved": false,
+      "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Borceux.html",
+      "reference": "https://spdx.org/licenses/MPL-2.0-no-copyleft-exception.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Borceux.json",
-      "referenceNumber": 258,
-      "name": "Borceux license",
-      "licenseId": "Borceux",
+      "detailsUrl": "https://spdx.org/licenses/MPL-2.0-no-copyleft-exception.json",
+      "referenceNumber": 529,
+      "name": "Mozilla Public License 2.0 (no copyleft exception)",
+      "licenseId": "MPL-2.0-no-copyleft-exception",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Borceux"
+        "https://www.mozilla.org/MPL/2.0/",
+        "https://opensource.org/licenses/MPL-2.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/Libpng.html",
+      "reference": "https://spdx.org/licenses/mplus.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Libpng.json",
-      "referenceNumber": 259,
-      "name": "libpng License",
-      "licenseId": "Libpng",
+      "detailsUrl": "https://spdx.org/licenses/mplus.json",
+      "referenceNumber": 553,
+      "name": "mplus Font License",
+      "licenseId": "mplus",
       "seeAlso": [
-        "http://www.libpng.org/pub/png/src/libpng-LICENSE.txt"
+        "https://fedoraproject.org/wiki/Licensing:Mplus?rd\u003dLicensing/mplus"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/X11-distribute-modifications-variant.html",
+      "reference": "https://spdx.org/licenses/MS-LPL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/X11-distribute-modifications-variant.json",
-      "referenceNumber": 260,
-      "name": "X11 License Distribution Modification Variant",
-      "licenseId": "X11-distribute-modifications-variant",
+      "detailsUrl": "https://spdx.org/licenses/MS-LPL.json",
+      "referenceNumber": 412,
+      "name": "Microsoft Limited Public License",
+      "licenseId": "MS-LPL",
       "seeAlso": [
-        "https://github.com/mirror/ncurses/blob/master/COPYING"
+        "https://www.openhub.net/licenses/mslpl",
+        "https://github.com/gabegundy/atlserver/blob/master/License.txt",
+        "https://en.wikipedia.org/wiki/Shared_Source_Initiative#Microsoft_Limited_Public_License_(Ms-LPL)"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Frameworx-1.0.html",
+      "reference": "https://spdx.org/licenses/MS-PL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Frameworx-1.0.json",
-      "referenceNumber": 261,
-      "name": "Frameworx Open License 1.0",
-      "licenseId": "Frameworx-1.0",
+      "detailsUrl": "https://spdx.org/licenses/MS-PL.json",
+      "referenceNumber": 360,
+      "name": "Microsoft Public License",
+      "licenseId": "MS-PL",
       "seeAlso": [
-        "https://opensource.org/licenses/Frameworx-1.0"
+        "http://www.microsoft.com/opensource/licenses.mspx",
+        "https://opensource.org/licenses/MS-PL"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/NCGL-UK-2.0.html",
+      "reference": "https://spdx.org/licenses/MS-RL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NCGL-UK-2.0.json",
-      "referenceNumber": 262,
-      "name": "Non-Commercial Government Licence",
-      "licenseId": "NCGL-UK-2.0",
+      "detailsUrl": "https://spdx.org/licenses/MS-RL.json",
+      "referenceNumber": 212,
+      "name": "Microsoft Reciprocal License",
+      "licenseId": "MS-RL",
       "seeAlso": [
-        "http://www.nationalarchives.gov.uk/doc/non-commercial-government-licence/version/2/"
+        "http://www.microsoft.com/opensource/licenses.mspx",
+        "https://opensource.org/licenses/MS-RL"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/CECILL-2.1.html",
+      "reference": "https://spdx.org/licenses/MTLL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CECILL-2.1.json",
-      "referenceNumber": 263,
-      "name": "CeCILL Free Software License Agreement v2.1",
-      "licenseId": "CECILL-2.1",
+      "detailsUrl": "https://spdx.org/licenses/MTLL.json",
+      "referenceNumber": 610,
+      "name": "Matrix Template Library License",
+      "licenseId": "MTLL",
       "seeAlso": [
-        "http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.html"
+        "https://fedoraproject.org/wiki/Licensing/Matrix_Template_Library_License"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-3.0-AT.html",
+      "reference": "https://spdx.org/licenses/MulanPSL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-3.0-AT.json",
-      "referenceNumber": 264,
-      "name": "Creative Commons Attribution 3.0 Austria",
-      "licenseId": "CC-BY-3.0-AT",
+      "detailsUrl": "https://spdx.org/licenses/MulanPSL-1.0.json",
+      "referenceNumber": 236,
+      "name": "Mulan Permissive Software License, Version 1",
+      "licenseId": "MulanPSL-1.0",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by/3.0/at/legalcode"
+        "https://license.coscl.org.cn/MulanPSL/",
+        "https://github.com/yuwenlong/longphp/blob/25dfb70cc2a466dc4bb55ba30901cbce08d164b5/LICENSE"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CNRI-Python.html",
+      "reference": "https://spdx.org/licenses/MulanPSL-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CNRI-Python.json",
-      "referenceNumber": 265,
-      "name": "CNRI Python License",
-      "licenseId": "CNRI-Python",
+      "detailsUrl": "https://spdx.org/licenses/MulanPSL-2.0.json",
+      "referenceNumber": 523,
+      "name": "Mulan Permissive Software License, Version 2",
+      "licenseId": "MulanPSL-2.0",
       "seeAlso": [
-        "https://opensource.org/licenses/CNRI-Python"
+        "https://license.coscl.org.cn/MulanPSL2"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/NCSA.html",
+      "reference": "https://spdx.org/licenses/Multics.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NCSA.json",
-      "referenceNumber": 266,
-      "name": "University of Illinois/NCSA Open Source License",
-      "licenseId": "NCSA",
+      "detailsUrl": "https://spdx.org/licenses/Multics.json",
+      "referenceNumber": 462,
+      "name": "Multics License",
+      "licenseId": "Multics",
+      "seeAlso": [
+        "https://opensource.org/licenses/Multics"
+      ],
+      "isOsiApproved": true
+    },
+    {
+      "reference": "https://spdx.org/licenses/Mup.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Mup.json",
+      "referenceNumber": 515,
+      "name": "Mup License",
+      "licenseId": "Mup",
       "seeAlso": [
-        "http://otm.illinois.edu/uiuc_openSource",
-        "https://opensource.org/licenses/NCSA"
+        "https://fedoraproject.org/wiki/Licensing/Mup"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/gSOAP-1.3b.html",
+      "reference": "https://spdx.org/licenses/NAIST-2003.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/gSOAP-1.3b.json",
-      "referenceNumber": 267,
-      "name": "gSOAP Public License v1.3b",
-      "licenseId": "gSOAP-1.3b",
+      "detailsUrl": "https://spdx.org/licenses/NAIST-2003.json",
+      "referenceNumber": 118,
+      "name": "Nara Institute of Science and Technology License (2003)",
+      "licenseId": "NAIST-2003",
       "seeAlso": [
-        "http://www.cs.fsu.edu/~engelen/license.html"
+        "https://enterprise.dejacode.com/licenses/public/naist-2003/#license-text",
+        "https://github.com/nodejs/node/blob/4a19cc8947b1bba2b2d27816ec3d0edf9b28e503/LICENSE#L343"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/EUPL-1.1.html",
+      "reference": "https://spdx.org/licenses/NASA-1.3.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/EUPL-1.1.json",
-      "referenceNumber": 268,
-      "name": "European Union Public License 1.1",
-      "licenseId": "EUPL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/NASA-1.3.json",
+      "referenceNumber": 488,
+      "name": "NASA Open Source Agreement 1.3",
+      "licenseId": "NASA-1.3",
       "seeAlso": [
-        "https://joinup.ec.europa.eu/software/page/eupl/licence-eupl",
-        "https://joinup.ec.europa.eu/sites/default/files/custom-page/attachment/eupl1.1.-licence-en_0.pdf",
-        "https://opensource.org/licenses/EUPL-1.1"
+        "http://ti.arc.nasa.gov/opensource/nosa/",
+        "https://opensource.org/licenses/NASA-1.3"
       ],
       "isOsiApproved": true,
-      "isFsfLibre": true
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/AMDPLPA.html",
+      "reference": "https://spdx.org/licenses/Naumen.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/AMDPLPA.json",
-      "referenceNumber": 269,
-      "name": "AMD\u0027s plpa_map.c License",
-      "licenseId": "AMDPLPA",
+      "detailsUrl": "https://spdx.org/licenses/Naumen.json",
+      "referenceNumber": 400,
+      "name": "Naumen Public License",
+      "licenseId": "Naumen",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/AMD_plpa_map_License"
+        "https://opensource.org/licenses/Naumen"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/Imlib2.html",
+      "reference": "https://spdx.org/licenses/NBPL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Imlib2.json",
-      "referenceNumber": 270,
-      "name": "Imlib2 License",
-      "licenseId": "Imlib2",
+      "detailsUrl": "https://spdx.org/licenses/NBPL-1.0.json",
+      "referenceNumber": 168,
+      "name": "Net Boolean Public License v1",
+      "licenseId": "NBPL-1.0",
       "seeAlso": [
-        "http://trac.enlightenment.org/e/browser/trunk/imlib2/COPYING",
-        "https://git.enlightenment.org/legacy/imlib2.git/tree/COPYING"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d37b4b3f6cc4bf34e1d3dec61e69914b9819d8894"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CDDL-1.1.html",
+      "reference": "https://spdx.org/licenses/NCBI-PD.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CDDL-1.1.json",
-      "referenceNumber": 271,
-      "name": "Common Development and Distribution License 1.1",
-      "licenseId": "CDDL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/NCBI-PD.json",
+      "referenceNumber": 599,
+      "name": "NCBI Public Domain Notice",
+      "licenseId": "NCBI-PD",
       "seeAlso": [
-        "http://glassfish.java.net/public/CDDL+GPL_1_1.html",
-        "https://javaee.github.io/glassfish/LICENSE"
+        "https://github.com/ncbi/sra-tools/blob/e8e5b6af4edc460156ad9ce5902d0779cffbf685/LICENSE",
+        "https://github.com/ncbi/datasets/blob/0ea4cd16b61e5b799d9cc55aecfa016d6c9bd2bf/LICENSE.md",
+        "https://github.com/ncbi/gprobe/blob/de64d30fee8b4c4013094d7d3139ea89b5dd1ace/LICENSE",
+        "https://github.com/ncbi/egapx/blob/08930b9dec0c69b2d1a05e5153c7b95ef0a3eb0f/LICENSE",
+        "https://github.com/ncbi/datasets/blob/master/LICENSE.md"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/WTFPL.html",
+      "reference": "https://spdx.org/licenses/NCGL-UK-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/WTFPL.json",
-      "referenceNumber": 272,
-      "name": "Do What The F*ck You Want To Public License",
-      "licenseId": "WTFPL",
+      "detailsUrl": "https://spdx.org/licenses/NCGL-UK-2.0.json",
+      "referenceNumber": 130,
+      "name": "Non-Commercial Government Licence",
+      "licenseId": "NCGL-UK-2.0",
       "seeAlso": [
-        "http://www.wtfpl.net/about/",
-        "http://sam.zoy.org/wtfpl/COPYING"
+        "http://www.nationalarchives.gov.uk/doc/non-commercial-government-licence/version/2/"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LPL-1.0.html",
+      "reference": "https://spdx.org/licenses/NCL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LPL-1.0.json",
-      "referenceNumber": 273,
-      "name": "Lucent Public License Version 1.0",
-      "licenseId": "LPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/NCL.json",
+      "referenceNumber": 516,
+      "name": "NCL Source Code License",
+      "licenseId": "NCL",
       "seeAlso": [
-        "https://opensource.org/licenses/LPL-1.0"
+        "https://gitlab.freedesktop.org/pipewire/pipewire/-/blob/master/src/modules/module-filter-chain/pffft.c?ref_type\u003dheads#L1-52"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/EPL-1.0.html",
+      "reference": "https://spdx.org/licenses/NCSA.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/EPL-1.0.json",
-      "referenceNumber": 274,
-      "name": "Eclipse Public License 1.0",
-      "licenseId": "EPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/NCSA.json",
+      "referenceNumber": 652,
+      "name": "University of Illinois/NCSA Open Source License",
+      "licenseId": "NCSA",
       "seeAlso": [
-        "http://www.eclipse.org/legal/epl-v10.html",
-        "https://opensource.org/licenses/EPL-1.0"
+        "http://otm.illinois.edu/uiuc_openSource",
+        "https://opensource.org/licenses/NCSA"
       ],
       "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-3-Clause-Attribution.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-Attribution.json",
-      "referenceNumber": 275,
-      "name": "BSD with attribution",
-      "licenseId": "BSD-3-Clause-Attribution",
+      "reference": "https://spdx.org/licenses/Net-SNMP.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/Net-SNMP.json",
+      "referenceNumber": 469,
+      "name": "Net-SNMP License",
+      "licenseId": "Net-SNMP",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/BSD_with_Attribution"
+        "http://net-snmp.sourceforge.net/about/license.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OSL-3.0.html",
+      "reference": "https://spdx.org/licenses/NetCDF.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OSL-3.0.json",
-      "referenceNumber": 276,
-      "name": "Open Software License 3.0",
-      "licenseId": "OSL-3.0",
+      "detailsUrl": "https://spdx.org/licenses/NetCDF.json",
+      "referenceNumber": 189,
+      "name": "NetCDF license",
+      "licenseId": "NetCDF",
       "seeAlso": [
-        "https://web.archive.org/web/20120101081418/http://rosenlaw.com:80/OSL3.0.htm",
-        "https://opensource.org/licenses/OSL-3.0"
+        "http://www.unidata.ucar.edu/software/netcdf/copyright.html"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/RHeCos-1.1.html",
+      "reference": "https://spdx.org/licenses/Newsletr.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/RHeCos-1.1.json",
-      "referenceNumber": 277,
-      "name": "Red Hat eCos Public License v1.1",
-      "licenseId": "RHeCos-1.1",
+      "detailsUrl": "https://spdx.org/licenses/Newsletr.json",
+      "referenceNumber": 499,
+      "name": "Newsletr License",
+      "licenseId": "Newsletr",
       "seeAlso": [
-        "http://ecos.sourceware.org/old-license.html"
+        "https://fedoraproject.org/wiki/Licensing/Newsletr"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/PHP-3.0.html",
+      "reference": "https://spdx.org/licenses/NGPL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/PHP-3.0.json",
-      "referenceNumber": 278,
-      "name": "PHP License v3.0",
-      "licenseId": "PHP-3.0",
+      "detailsUrl": "https://spdx.org/licenses/NGPL.json",
+      "referenceNumber": 167,
+      "name": "Nethack General Public License",
+      "licenseId": "NGPL",
       "seeAlso": [
-        "http://www.php.net/license/3_0.txt",
-        "https://opensource.org/licenses/PHP-3.0"
+        "https://opensource.org/licenses/NGPL"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-Protection.html",
+      "reference": "https://spdx.org/licenses/NICTA-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-Protection.json",
-      "referenceNumber": 279,
-      "name": "BSD Protection License",
-      "licenseId": "BSD-Protection",
+      "detailsUrl": "https://spdx.org/licenses/NICTA-1.0.json",
+      "referenceNumber": 486,
+      "name": "NICTA Public Software License, Version 1.0",
+      "licenseId": "NICTA-1.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/BSD_Protection_License"
+        "https://opensource.apple.com/source/mDNSResponder/mDNSResponder-320.10/mDNSPosix/nss_ReadMe.txt"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-3.0-DE.html",
+      "reference": "https://spdx.org/licenses/NIST-PD.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-3.0-DE.json",
-      "referenceNumber": 280,
-      "name": "Creative Commons Attribution Non Commercial 3.0 Germany",
-      "licenseId": "CC-BY-NC-3.0-DE",
+      "detailsUrl": "https://spdx.org/licenses/NIST-PD.json",
+      "referenceNumber": 194,
+      "name": "NIST Public Domain Notice",
+      "licenseId": "NIST-PD",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc/3.0/de/legalcode"
+        "https://github.com/tcheneau/simpleRPL/blob/e645e69e38dd4e3ccfeceb2db8cba05b7c2e0cd3/LICENSE.txt",
+        "https://github.com/tcheneau/Routing/blob/f09f46fcfe636107f22f2c98348188a65a135d98/README.md"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/APL-1.0.html",
+      "reference": "https://spdx.org/licenses/NIST-PD-fallback.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/APL-1.0.json",
-      "referenceNumber": 281,
-      "name": "Adaptive Public License 1.0",
-      "licenseId": "APL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/NIST-PD-fallback.json",
+      "referenceNumber": 223,
+      "name": "NIST Public Domain Notice with license fallback",
+      "licenseId": "NIST-PD-fallback",
       "seeAlso": [
-        "https://opensource.org/licenses/APL-1.0"
+        "https://github.com/usnistgov/jsip/blob/59700e6926cbe96c5cdae897d9a7d2656b42abe3/LICENSE",
+        "https://github.com/usnistgov/fipy/blob/86aaa5c2ba2c6f1be19593c5986071cf6568cc34/LICENSE.rst"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/EUDatagrid.html",
+      "reference": "https://spdx.org/licenses/NIST-Software.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/EUDatagrid.json",
-      "referenceNumber": 282,
-      "name": "EU DataGrid Software License",
-      "licenseId": "EUDatagrid",
+      "detailsUrl": "https://spdx.org/licenses/NIST-Software.json",
+      "referenceNumber": 251,
+      "name": "NIST Software License",
+      "licenseId": "NIST-Software",
       "seeAlso": [
-        "http://eu-datagrid.web.cern.ch/eu-datagrid/license.html",
-        "https://opensource.org/licenses/EUDatagrid"
+        "https://github.com/open-quantum-safe/liboqs/blob/40b01fdbb270f8614fde30e65d30e9da18c02393/src/common/rand/rand_nist.c#L1-L15"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-1.0.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GPL-1.0.json",
-      "referenceNumber": 283,
-      "name": "GNU General Public License v1.0 only",
-      "licenseId": "GPL-1.0",
+      "reference": "https://spdx.org/licenses/NLOD-1.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/NLOD-1.0.json",
+      "referenceNumber": 294,
+      "name": "Norwegian Licence for Open Government Data (NLOD) 1.0",
+      "licenseId": "NLOD-1.0",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/gpl-1.0-standalone.html"
+        "http://data.norge.no/nlod/en/1.0"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/SHL-0.5.html",
+      "reference": "https://spdx.org/licenses/NLOD-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SHL-0.5.json",
-      "referenceNumber": 284,
-      "name": "Solderpad Hardware License v0.5",
-      "licenseId": "SHL-0.5",
+      "detailsUrl": "https://spdx.org/licenses/NLOD-2.0.json",
+      "referenceNumber": 566,
+      "name": "Norwegian Licence for Open Government Data (NLOD) 2.0",
+      "licenseId": "NLOD-2.0",
       "seeAlso": [
-        "https://solderpad.org/licenses/SHL-0.5/"
+        "http://data.norge.no/nlod/en/2.0"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-SA-2.0.html",
+      "reference": "https://spdx.org/licenses/NLPL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-2.0.json",
-      "referenceNumber": 285,
-      "name": "Creative Commons Attribution Share Alike 2.0 Generic",
-      "licenseId": "CC-BY-SA-2.0",
+      "detailsUrl": "https://spdx.org/licenses/NLPL.json",
+      "referenceNumber": 367,
+      "name": "No Limit Public License",
+      "licenseId": "NLPL",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-sa/2.0/legalcode"
+        "https://fedoraproject.org/wiki/Licensing/NLPL"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-SA-3.0-AT.html",
+      "reference": "https://spdx.org/licenses/Nokia.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-3.0-AT.json",
-      "referenceNumber": 286,
-      "name": "Creative Commons Attribution Share Alike 3.0 Austria",
-      "licenseId": "CC-BY-SA-3.0-AT",
+      "detailsUrl": "https://spdx.org/licenses/Nokia.json",
+      "referenceNumber": 145,
+      "name": "Nokia Open Source License",
+      "licenseId": "Nokia",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-sa/3.0/at/legalcode"
+        "https://opensource.org/licenses/nokia"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-3.0-IGO.html",
+      "reference": "https://spdx.org/licenses/NOSL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-3.0-IGO.json",
-      "referenceNumber": 287,
-      "name": "Creative Commons Attribution Non Commercial Share Alike 3.0 IGO",
-      "licenseId": "CC-BY-NC-SA-3.0-IGO",
+      "detailsUrl": "https://spdx.org/licenses/NOSL.json",
+      "referenceNumber": 254,
+      "name": "Netizen Open Source License",
+      "licenseId": "NOSL",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-sa/3.0/igo/legalcode"
+        "http://bits.netizen.com.au/licenses/NOSL/nosl.txt"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Adobe-2006.html",
+      "reference": "https://spdx.org/licenses/Noweb.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Adobe-2006.json",
-      "referenceNumber": 288,
-      "name": "Adobe Systems Incorporated Source Code License Agreement",
-      "licenseId": "Adobe-2006",
+      "detailsUrl": "https://spdx.org/licenses/Noweb.json",
+      "referenceNumber": 30,
+      "name": "Noweb License",
+      "licenseId": "Noweb",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/AdobeLicense"
+        "https://fedoraproject.org/wiki/Licensing/Noweb"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Newsletr.html",
+      "reference": "https://spdx.org/licenses/NPL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Newsletr.json",
-      "referenceNumber": 289,
-      "name": "Newsletr License",
-      "licenseId": "Newsletr",
+      "detailsUrl": "https://spdx.org/licenses/NPL-1.0.json",
+      "referenceNumber": 211,
+      "name": "Netscape Public License v1.0",
+      "licenseId": "NPL-1.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Newsletr"
+        "http://www.mozilla.org/MPL/NPL/1.0/"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Nunit.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/Nunit.json",
-      "referenceNumber": 290,
-      "name": "Nunit License",
-      "licenseId": "Nunit",
+      "reference": "https://spdx.org/licenses/NPL-1.1.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/NPL-1.1.json",
+      "referenceNumber": 595,
+      "name": "Netscape Public License v1.1",
+      "licenseId": "NPL-1.1",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Nunit"
+        "http://www.mozilla.org/MPL/NPL/1.1/"
       ],
       "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Multics.html",
+      "reference": "https://spdx.org/licenses/NPOSL-3.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Multics.json",
-      "referenceNumber": 291,
-      "name": "Multics License",
-      "licenseId": "Multics",
+      "detailsUrl": "https://spdx.org/licenses/NPOSL-3.0.json",
+      "referenceNumber": 664,
+      "name": "Non-Profit Open Software License 3.0",
+      "licenseId": "NPOSL-3.0",
       "seeAlso": [
-        "https://opensource.org/licenses/Multics"
+        "https://opensource.org/licenses/NOSL3.0"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/OGL-UK-1.0.html",
+      "reference": "https://spdx.org/licenses/NRL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OGL-UK-1.0.json",
-      "referenceNumber": 292,
-      "name": "Open Government Licence v1.0",
-      "licenseId": "OGL-UK-1.0",
+      "detailsUrl": "https://spdx.org/licenses/NRL.json",
+      "referenceNumber": 113,
+      "name": "NRL License",
+      "licenseId": "NRL",
       "seeAlso": [
-        "http://www.nationalarchives.gov.uk/doc/open-government-licence/version/1/"
+        "http://web.mit.edu/network/isakmp/nrllicense.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Vim.html",
+      "reference": "https://spdx.org/licenses/NTP.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Vim.json",
-      "referenceNumber": 293,
-      "name": "Vim License",
-      "licenseId": "Vim",
+      "detailsUrl": "https://spdx.org/licenses/NTP.json",
+      "referenceNumber": 390,
+      "name": "NTP License",
+      "licenseId": "NTP",
       "seeAlso": [
-        "http://vimdoc.sourceforge.net/htmldoc/uganda.html"
+        "https://opensource.org/licenses/NTP"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/eCos-2.0.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/eCos-2.0.json",
-      "referenceNumber": 294,
-      "name": "eCos license version 2.0",
-      "licenseId": "eCos-2.0",
+      "reference": "https://spdx.org/licenses/NTP-0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/NTP-0.json",
+      "referenceNumber": 64,
+      "name": "NTP No Attribution",
+      "licenseId": "NTP-0",
       "seeAlso": [
-        "https://www.gnu.org/licenses/ecos-license.html"
+        "https://github.com/tytso/e2fsprogs/blob/master/lib/et/et_name.c"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Zimbra-1.3.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Zimbra-1.3.json",
-      "referenceNumber": 295,
-      "name": "Zimbra Public License v1.3",
-      "licenseId": "Zimbra-1.3",
+      "reference": "https://spdx.org/licenses/Nunit.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/Nunit.json",
+      "referenceNumber": 27,
+      "name": "Nunit License",
+      "licenseId": "Nunit",
       "seeAlso": [
-        "http://web.archive.org/web/20100302225219/http://www.zimbra.com/license/zimbra-public-license-1-3.html"
+        "https://fedoraproject.org/wiki/Licensing/Nunit"
       ],
       "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/eGenix.html",
+      "reference": "https://spdx.org/licenses/O-UDA-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/eGenix.json",
-      "referenceNumber": 296,
-      "name": "eGenix.com Public License 1.1.0",
-      "licenseId": "eGenix",
+      "detailsUrl": "https://spdx.org/licenses/O-UDA-1.0.json",
+      "referenceNumber": 161,
+      "name": "Open Use of Data Agreement v1.0",
+      "licenseId": "O-UDA-1.0",
       "seeAlso": [
-        "http://www.egenix.com/products/eGenix.com-Public-License-1.1.0.pdf",
-        "https://fedoraproject.org/wiki/Licensing/eGenix.com_Public_License_1.1.0"
+        "https://github.com/microsoft/Open-Use-of-Data-Agreement/blob/v1.0/O-UDA-1.0.md",
+        "https://cdla.dev/open-use-of-data-agreement-v1-0/"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/IBM-pibs.html",
+      "reference": "https://spdx.org/licenses/OAR.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/IBM-pibs.json",
-      "referenceNumber": 297,
-      "name": "IBM PowerPC Initialization and Boot Software",
-      "licenseId": "IBM-pibs",
+      "detailsUrl": "https://spdx.org/licenses/OAR.json",
+      "referenceNumber": 100,
+      "name": "OAR License",
+      "licenseId": "OAR",
       "seeAlso": [
-        "http://git.denx.de/?p\u003du-boot.git;a\u003dblob;f\u003darch/powerpc/cpu/ppc4xx/miiphy.c;h\u003d297155fdafa064b955e53e9832de93bfb0cfb85b;hb\u003d9fab4bf4cc077c21e43941866f3f2c196f28670d"
+        "https://sourceware.org/git/?p\u003dnewlib-cygwin.git;a\u003dblob;f\u003dnewlib/libc/string/strsignal.c;hb\u003dHEAD#l35"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BitTorrent-1.1.html",
+      "reference": "https://spdx.org/licenses/OCCT-PL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BitTorrent-1.1.json",
-      "referenceNumber": 298,
-      "name": "BitTorrent Open Source License v1.1",
-      "licenseId": "BitTorrent-1.1",
+      "detailsUrl": "https://spdx.org/licenses/OCCT-PL.json",
+      "referenceNumber": 408,
+      "name": "Open CASCADE Technology Public License",
+      "licenseId": "OCCT-PL",
       "seeAlso": [
-        "http://directory.fsf.org/wiki/License:BitTorrentOSL1.1"
+        "http://www.opencascade.com/content/occt-public-license"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OFL-1.1-no-RFN.html",
+      "reference": "https://spdx.org/licenses/OCLC-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OFL-1.1-no-RFN.json",
-      "referenceNumber": 299,
-      "name": "SIL Open Font License 1.1 with no Reserved Font Name",
-      "licenseId": "OFL-1.1-no-RFN",
+      "detailsUrl": "https://spdx.org/licenses/OCLC-2.0.json",
+      "referenceNumber": 468,
+      "name": "OCLC Research Public License 2.0",
+      "licenseId": "OCLC-2.0",
       "seeAlso": [
-        "http://scripts.sil.org/cms/scripts/page.php?item_id\u003dOFL_web",
-        "https://opensource.org/licenses/OFL-1.1"
+        "http://www.oclc.org/research/activities/software/license/v2final.htm",
+        "https://opensource.org/licenses/OCLC-2.0"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/psfrag.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/psfrag.json",
-      "referenceNumber": 300,
-      "name": "psfrag License",
-      "licenseId": "psfrag",
-      "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/psfrag"
-      ],
-      "isOsiApproved": false
-    },
-    {
-      "reference": "https://spdx.org/licenses/CC-BY-ND-2.0.html",
+      "reference": "https://spdx.org/licenses/ODbL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-ND-2.0.json",
-      "referenceNumber": 301,
-      "name": "Creative Commons Attribution No Derivatives 2.0 Generic",
-      "licenseId": "CC-BY-ND-2.0",
+      "detailsUrl": "https://spdx.org/licenses/ODbL-1.0.json",
+      "referenceNumber": 611,
+      "name": "Open Data Commons Open Database License v1.0",
+      "licenseId": "ODbL-1.0",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nd/2.0/legalcode"
+        "http://www.opendatacommons.org/licenses/odbl/1.0/",
+        "https://opendatacommons.org/licenses/odbl/1-0/"
       ],
       "isOsiApproved": false,
-      "isFsfLibre": false
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/SHL-0.51.html",
+      "reference": "https://spdx.org/licenses/ODC-By-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SHL-0.51.json",
-      "referenceNumber": 302,
-      "name": "Solderpad Hardware License, Version 0.51",
-      "licenseId": "SHL-0.51",
+      "detailsUrl": "https://spdx.org/licenses/ODC-By-1.0.json",
+      "referenceNumber": 15,
+      "name": "Open Data Commons Attribution License v1.0",
+      "licenseId": "ODC-By-1.0",
       "seeAlso": [
-        "https://solderpad.org/licenses/SHL-0.51/"
+        "https://opendatacommons.org/licenses/by/1.0/"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/FreeBSD-DOC.html",
+      "reference": "https://spdx.org/licenses/OFFIS.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/FreeBSD-DOC.json",
-      "referenceNumber": 303,
-      "name": "FreeBSD Documentation License",
-      "licenseId": "FreeBSD-DOC",
+      "detailsUrl": "https://spdx.org/licenses/OFFIS.json",
+      "referenceNumber": 418,
+      "name": "OFFIS License",
+      "licenseId": "OFFIS",
       "seeAlso": [
-        "https://www.freebsd.org/copyright/freebsd-doc-license/"
+        "https://sourceforge.net/p/xmedcon/code/ci/master/tree/libs/dicom/README"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Python-2.0.html",
+      "reference": "https://spdx.org/licenses/OFL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Python-2.0.json",
-      "referenceNumber": 304,
-      "name": "Python License 2.0",
-      "licenseId": "Python-2.0",
+      "detailsUrl": "https://spdx.org/licenses/OFL-1.0.json",
+      "referenceNumber": 603,
+      "name": "SIL Open Font License 1.0",
+      "licenseId": "OFL-1.0",
       "seeAlso": [
-        "https://opensource.org/licenses/Python-2.0"
+        "http://scripts.sil.org/cms/scripts/page.php?item_id\u003dOFL10_web"
       ],
-      "isOsiApproved": true,
+      "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Mup.html",
+      "reference": "https://spdx.org/licenses/OFL-1.0-no-RFN.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Mup.json",
-      "referenceNumber": 305,
-      "name": "Mup License",
-      "licenseId": "Mup",
+      "detailsUrl": "https://spdx.org/licenses/OFL-1.0-no-RFN.json",
+      "referenceNumber": 545,
+      "name": "SIL Open Font License 1.0 with no Reserved Font Name",
+      "licenseId": "OFL-1.0-no-RFN",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Mup"
+        "http://scripts.sil.org/cms/scripts/page.php?item_id\u003dOFL10_web"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-4-Clause-Shortened.html",
+      "reference": "https://spdx.org/licenses/OFL-1.0-RFN.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-4-Clause-Shortened.json",
-      "referenceNumber": 306,
-      "name": "BSD 4 Clause Shortened",
-      "licenseId": "BSD-4-Clause-Shortened",
+      "detailsUrl": "https://spdx.org/licenses/OFL-1.0-RFN.json",
+      "referenceNumber": 446,
+      "name": "SIL Open Font License 1.0 with Reserved Font Name",
+      "licenseId": "OFL-1.0-RFN",
       "seeAlso": [
-        "https://metadata.ftp-master.debian.org/changelogs//main/a/arpwatch/arpwatch_2.1a15-7_copyright"
+        "http://scripts.sil.org/cms/scripts/page.php?item_id\u003dOFL10_web"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-4.0.html",
+      "reference": "https://spdx.org/licenses/OFL-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-4.0.json",
-      "referenceNumber": 307,
-      "name": "Creative Commons Attribution Non Commercial Share Alike 4.0 International",
-      "licenseId": "CC-BY-NC-SA-4.0",
+      "detailsUrl": "https://spdx.org/licenses/OFL-1.1.json",
+      "referenceNumber": 0,
+      "name": "SIL Open Font License 1.1",
+      "licenseId": "OFL-1.1",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode"
+        "http://scripts.sil.org/cms/scripts/page.php?item_id\u003dOFL_web",
+        "https://opensource.org/licenses/OFL-1.1"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/HPND.html",
+      "reference": "https://spdx.org/licenses/OFL-1.1-no-RFN.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/HPND.json",
-      "referenceNumber": 308,
-      "name": "Historical Permission Notice and Disclaimer",
-      "licenseId": "HPND",
+      "detailsUrl": "https://spdx.org/licenses/OFL-1.1-no-RFN.json",
+      "referenceNumber": 110,
+      "name": "SIL Open Font License 1.1 with no Reserved Font Name",
+      "licenseId": "OFL-1.1-no-RFN",
       "seeAlso": [
-        "https://opensource.org/licenses/HPND"
+        "http://scripts.sil.org/cms/scripts/page.php?item_id\u003dOFL_web",
+        "https://opensource.org/licenses/OFL-1.1"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-2.6.html",
+      "reference": "https://spdx.org/licenses/OFL-1.1-RFN.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.6.json",
-      "referenceNumber": 309,
-      "name": "Open LDAP Public License v2.6",
-      "licenseId": "OLDAP-2.6",
+      "detailsUrl": "https://spdx.org/licenses/OFL-1.1-RFN.json",
+      "referenceNumber": 90,
+      "name": "SIL Open Font License 1.1 with Reserved Font Name",
+      "licenseId": "OFL-1.1-RFN",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d1cae062821881f41b73012ba816434897abf4205"
+        "http://scripts.sil.org/cms/scripts/page.php?item_id\u003dOFL_web",
+        "https://opensource.org/licenses/OFL-1.1"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/MPL-1.1.html",
+      "reference": "https://spdx.org/licenses/OGC-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MPL-1.1.json",
-      "referenceNumber": 310,
-      "name": "Mozilla Public License 1.1",
-      "licenseId": "MPL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/OGC-1.0.json",
+      "referenceNumber": 504,
+      "name": "OGC Software License, Version 1.0",
+      "licenseId": "OGC-1.0",
       "seeAlso": [
-        "http://www.mozilla.org/MPL/MPL-1.1.html",
-        "https://opensource.org/licenses/MPL-1.1"
+        "https://www.ogc.org/ogc/software/1.0"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-2.0-with-GCC-exception.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GPL-2.0-with-GCC-exception.json",
-      "referenceNumber": 311,
-      "name": "GNU General Public License v2.0 w/GCC Runtime Library exception",
-      "licenseId": "GPL-2.0-with-GCC-exception",
+      "reference": "https://spdx.org/licenses/OGDL-Taiwan-1.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/OGDL-Taiwan-1.0.json",
+      "referenceNumber": 23,
+      "name": "Taiwan Open Government Data License, version 1.0",
+      "licenseId": "OGDL-Taiwan-1.0",
       "seeAlso": [
-        "https://gcc.gnu.org/git/?p\u003dgcc.git;a\u003dblob;f\u003dgcc/libgcc1.c;h\u003d762f5143fc6eed57b6797c82710f3538aa52b40b;hb\u003dcb143a3ce4fb417c68f5fa2691a1b1b1053dfba9#l10"
+        "https://data.gov.tw/license"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/HaskellReport.html",
+      "reference": "https://spdx.org/licenses/OGL-Canada-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/HaskellReport.json",
-      "referenceNumber": 312,
-      "name": "Haskell Language Report License",
-      "licenseId": "HaskellReport",
+      "detailsUrl": "https://spdx.org/licenses/OGL-Canada-2.0.json",
+      "referenceNumber": 40,
+      "name": "Open Government Licence - Canada",
+      "licenseId": "OGL-Canada-2.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Haskell_Language_Report_License"
+        "https://open.canada.ca/en/open-government-licence-canada"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/ECL-1.0.html",
+      "reference": "https://spdx.org/licenses/OGL-UK-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ECL-1.0.json",
-      "referenceNumber": 313,
-      "name": "Educational Community License v1.0",
-      "licenseId": "ECL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/OGL-UK-1.0.json",
+      "referenceNumber": 497,
+      "name": "Open Government Licence v1.0",
+      "licenseId": "OGL-UK-1.0",
       "seeAlso": [
-        "https://opensource.org/licenses/ECL-1.0"
+        "http://www.nationalarchives.gov.uk/doc/open-government-licence/version/1/"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LGPL-2.1-or-later.html",
+      "reference": "https://spdx.org/licenses/OGL-UK-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LGPL-2.1-or-later.json",
-      "referenceNumber": 314,
-      "name": "GNU Lesser General Public License v2.1 or later",
-      "licenseId": "LGPL-2.1-or-later",
+      "detailsUrl": "https://spdx.org/licenses/OGL-UK-2.0.json",
+      "referenceNumber": 556,
+      "name": "Open Government Licence v2.0",
+      "licenseId": "OGL-UK-2.0",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/lgpl-2.1-standalone.html",
-        "https://opensource.org/licenses/LGPL-2.1"
+        "http://www.nationalarchives.gov.uk/doc/open-government-licence/version/2/"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OFL-1.0.html",
+      "reference": "https://spdx.org/licenses/OGL-UK-3.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OFL-1.0.json",
-      "referenceNumber": 315,
-      "name": "SIL Open Font License 1.0",
-      "licenseId": "OFL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/OGL-UK-3.0.json",
+      "referenceNumber": 585,
+      "name": "Open Government Licence v3.0",
+      "licenseId": "OGL-UK-3.0",
       "seeAlso": [
-        "http://scripts.sil.org/cms/scripts/page.php?item_id\u003dOFL10_web"
+        "http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/APSL-1.1.html",
+      "reference": "https://spdx.org/licenses/OGTSL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/APSL-1.1.json",
-      "referenceNumber": 316,
-      "name": "Apple Public Source License 1.1",
-      "licenseId": "APSL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/OGTSL.json",
+      "referenceNumber": 97,
+      "name": "Open Group Test Suite License",
+      "licenseId": "OGTSL",
       "seeAlso": [
-        "http://www.opensource.apple.com/source/IOSerialFamily/IOSerialFamily-7/APPLE_LICENSE"
+        "http://www.opengroup.org/testing/downloads/The_Open_Group_TSL.txt",
+        "https://opensource.org/licenses/OGTSL"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/MITNFA.html",
+      "reference": "https://spdx.org/licenses/OLDAP-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MITNFA.json",
-      "referenceNumber": 317,
-      "name": "MIT +no-false-attribs license",
-      "licenseId": "MITNFA",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-1.1.json",
+      "referenceNumber": 420,
+      "name": "Open LDAP Public License v1.1",
+      "licenseId": "OLDAP-1.1",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/MITNFA"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d806557a5ad59804ef3a44d5abfbe91d706b0791f"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CECILL-2.0.html",
+      "reference": "https://spdx.org/licenses/OLDAP-1.2.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CECILL-2.0.json",
-      "referenceNumber": 318,
-      "name": "CeCILL Free Software License Agreement v2.0",
-      "licenseId": "CECILL-2.0",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-1.2.json",
+      "referenceNumber": 487,
+      "name": "Open LDAP Public License v1.2",
+      "licenseId": "OLDAP-1.2",
       "seeAlso": [
-        "http://www.cecill.info/licences/Licence_CeCILL_V2-en.html"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d42b0383c50c299977b5893ee695cf4e486fb0dc7"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Crossword.html",
+      "reference": "https://spdx.org/licenses/OLDAP-1.3.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Crossword.json",
-      "referenceNumber": 319,
-      "name": "Crossword License",
-      "licenseId": "Crossword",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-1.3.json",
+      "referenceNumber": 627,
+      "name": "Open LDAP Public License v1.3",
+      "licenseId": "OLDAP-1.3",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Crossword"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003de5f8117f0ce088d0bd7a8e18ddf37eaa40eb09b1"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Aladdin.html",
+      "reference": "https://spdx.org/licenses/OLDAP-1.4.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Aladdin.json",
-      "referenceNumber": 320,
-      "name": "Aladdin Free Public License",
-      "licenseId": "Aladdin",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-1.4.json",
+      "referenceNumber": 45,
+      "name": "Open LDAP Public License v1.4",
+      "licenseId": "OLDAP-1.4",
       "seeAlso": [
-        "http://pages.cs.wisc.edu/~ghost/doc/AFPL/6.01/Public.htm"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003dc9f95c2f3f2ffb5e0ae55fe7388af75547660941"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Baekmuk.html",
+      "reference": "https://spdx.org/licenses/OLDAP-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Baekmuk.json",
-      "referenceNumber": 321,
-      "name": "Baekmuk License",
-      "licenseId": "Baekmuk",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.0.json",
+      "referenceNumber": 537,
+      "name": "Open LDAP Public License v2.0 (or possibly 2.0A and 2.0B)",
+      "licenseId": "OLDAP-2.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing:Baekmuk?rd\u003dLicensing/Baekmuk"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003dcbf50f4e1185a21abd4c0a54d3f4341fe28f36ea"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/XFree86-1.1.html",
+      "reference": "https://spdx.org/licenses/OLDAP-2.0.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/XFree86-1.1.json",
-      "referenceNumber": 322,
-      "name": "XFree86 License 1.1",
-      "licenseId": "XFree86-1.1",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.0.1.json",
+      "referenceNumber": 179,
+      "name": "Open LDAP Public License v2.0.1",
+      "licenseId": "OLDAP-2.0.1",
       "seeAlso": [
-        "http://www.xfree86.org/current/LICENSE4.html"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003db6d68acd14e51ca3aab4428bf26522aa74873f0e"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-1.0-or-later.html",
+      "reference": "https://spdx.org/licenses/OLDAP-2.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GPL-1.0-or-later.json",
-      "referenceNumber": 323,
-      "name": "GNU General Public License v1.0 or later",
-      "licenseId": "GPL-1.0-or-later",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.1.json",
+      "referenceNumber": 342,
+      "name": "Open LDAP Public License v2.1",
+      "licenseId": "OLDAP-2.1",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/gpl-1.0-standalone.html"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003db0d176738e96a0d3b9f85cb51e140a86f21be715"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CERN-OHL-W-2.0.html",
+      "reference": "https://spdx.org/licenses/OLDAP-2.2.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CERN-OHL-W-2.0.json",
-      "referenceNumber": 324,
-      "name": "CERN Open Hardware Licence Version 2 - Weakly Reciprocal",
-      "licenseId": "CERN-OHL-W-2.0",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.2.json",
+      "referenceNumber": 347,
+      "name": "Open LDAP Public License v2.2",
+      "licenseId": "OLDAP-2.2",
       "seeAlso": [
-        "https://www.ohwr.org/project/cernohl/wikis/Documents/CERN-OHL-version-2"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d470b0c18ec67621c85881b2733057fecf4a1acc3"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-SA-1.0.html",
+      "reference": "https://spdx.org/licenses/OLDAP-2.2.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-1.0.json",
-      "referenceNumber": 325,
-      "name": "Creative Commons Attribution Share Alike 1.0 Generic",
-      "licenseId": "CC-BY-SA-1.0",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.2.1.json",
+      "referenceNumber": 208,
+      "name": "Open LDAP Public License v2.2.1",
+      "licenseId": "OLDAP-2.2.1",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-sa/1.0/legalcode"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d4bc786f34b50aa301be6f5600f58a980070f481e"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/NTP.html",
+      "reference": "https://spdx.org/licenses/OLDAP-2.2.2.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NTP.json",
-      "referenceNumber": 326,
-      "name": "NTP License",
-      "licenseId": "NTP",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.2.2.json",
+      "referenceNumber": 312,
+      "name": "Open LDAP Public License 2.2.2",
+      "licenseId": "OLDAP-2.2.2",
       "seeAlso": [
-        "https://opensource.org/licenses/NTP"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003ddf2cc1e21eb7c160695f5b7cffd6296c151ba188"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/PHP-3.01.html",
+      "reference": "https://spdx.org/licenses/OLDAP-2.3.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/PHP-3.01.json",
-      "referenceNumber": 327,
-      "name": "PHP License v3.01",
-      "licenseId": "PHP-3.01",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.3.json",
+      "referenceNumber": 276,
+      "name": "Open LDAP Public License v2.3",
+      "licenseId": "OLDAP-2.3",
       "seeAlso": [
-        "http://www.php.net/license/3_01.txt"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003dd32cf54a32d581ab475d23c810b0a7fbaf8d63c3"
       ],
-      "isOsiApproved": true,
+      "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/OCLC-2.0.html",
+      "reference": "https://spdx.org/licenses/OLDAP-2.4.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OCLC-2.0.json",
-      "referenceNumber": 328,
-      "name": "OCLC Research Public License 2.0",
-      "licenseId": "OCLC-2.0",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.4.json",
+      "referenceNumber": 108,
+      "name": "Open LDAP Public License v2.4",
+      "licenseId": "OLDAP-2.4",
       "seeAlso": [
-        "http://www.oclc.org/research/activities/software/license/v2final.htm",
-        "https://opensource.org/licenses/OCLC-2.0"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003dcd1284c4a91a8a380d904eee68d1583f989ed386"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-3.0-DE.html",
+      "reference": "https://spdx.org/licenses/OLDAP-2.5.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-3.0-DE.json",
-      "referenceNumber": 329,
-      "name": "Creative Commons Attribution 3.0 Germany",
-      "licenseId": "CC-BY-3.0-DE",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.5.json",
+      "referenceNumber": 518,
+      "name": "Open LDAP Public License v2.5",
+      "licenseId": "OLDAP-2.5",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by/3.0/de/legalcode"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d6852b9d90022e8593c98205413380536b1b5a7cf"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-2.5.html",
+      "reference": "https://spdx.org/licenses/OLDAP-2.6.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-2.5.json",
-      "referenceNumber": 330,
-      "name": "Creative Commons Attribution Non Commercial 2.5 Generic",
-      "licenseId": "CC-BY-NC-2.5",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.6.json",
+      "referenceNumber": 275,
+      "name": "Open LDAP Public License v2.6",
+      "licenseId": "OLDAP-2.6",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc/2.5/legalcode"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d1cae062821881f41b73012ba816434897abf4205"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Zlib.html",
+      "reference": "https://spdx.org/licenses/OLDAP-2.7.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Zlib.json",
-      "referenceNumber": 331,
-      "name": "zlib License",
-      "licenseId": "Zlib",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.7.json",
+      "referenceNumber": 79,
+      "name": "Open LDAP Public License v2.7",
+      "licenseId": "OLDAP-2.7",
       "seeAlso": [
-        "http://www.zlib.net/zlib_license.html",
-        "https://opensource.org/licenses/Zlib"
+        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d47c2415c1df81556eeb39be6cad458ef87c534a2"
       ],
-      "isOsiApproved": true,
+      "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/CATOSL-1.1.html",
+      "reference": "https://spdx.org/licenses/OLDAP-2.8.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CATOSL-1.1.json",
-      "referenceNumber": 332,
-      "name": "Computer Associates Trusted Open Source License 1.1",
-      "licenseId": "CATOSL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.8.json",
+      "referenceNumber": 72,
+      "name": "Open LDAP Public License v2.8",
+      "licenseId": "OLDAP-2.8",
       "seeAlso": [
-        "https://opensource.org/licenses/CATOSL-1.1"
+        "http://www.openldap.org/software/release/license.html"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/LGPL-3.0+.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/LGPL-3.0+.json",
-      "referenceNumber": 333,
-      "name": "GNU Lesser General Public License v3.0 or later",
-      "licenseId": "LGPL-3.0+",
-      "seeAlso": [
-        "https://www.gnu.org/licenses/lgpl-3.0-standalone.html",
-        "https://www.gnu.org/licenses/lgpl+gpl-3.0.txt",
-        "https://opensource.org/licenses/LGPL-3.0"
-      ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
-    },
-    {
-      "reference": "https://spdx.org/licenses/CAL-1.0.html",
+      "reference": "https://spdx.org/licenses/OLFL-1.3.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CAL-1.0.json",
-      "referenceNumber": 334,
-      "name": "Cryptographic Autonomy License 1.0",
-      "licenseId": "CAL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/OLFL-1.3.json",
+      "referenceNumber": 204,
+      "name": "Open Logistics Foundation License Version 1.3",
+      "licenseId": "OLFL-1.3",
       "seeAlso": [
-        "http://cryptographicautonomylicense.com/license-text.html",
-        "https://opensource.org/licenses/CAL-1.0"
+        "https://openlogisticsfoundation.org/licenses/",
+        "https://opensource.org/license/olfl-1-3/"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/NPL-1.0.html",
+      "reference": "https://spdx.org/licenses/OML.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NPL-1.0.json",
-      "referenceNumber": 335,
-      "name": "Netscape Public License v1.0",
-      "licenseId": "NPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/OML.json",
+      "referenceNumber": 505,
+      "name": "Open Market License",
+      "licenseId": "OML",
       "seeAlso": [
-        "http://www.mozilla.org/MPL/NPL/1.0/"
+        "https://fedoraproject.org/wiki/Licensing/Open_Market_License"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/SMLNJ.html",
+      "reference": "https://spdx.org/licenses/OpenPBS-2.3.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SMLNJ.json",
-      "referenceNumber": 336,
-      "name": "Standard ML of New Jersey License",
-      "licenseId": "SMLNJ",
+      "detailsUrl": "https://spdx.org/licenses/OpenPBS-2.3.json",
+      "referenceNumber": 159,
+      "name": "OpenPBS v2.3 Software License",
+      "licenseId": "OpenPBS-2.3",
       "seeAlso": [
-        "https://www.smlnj.org/license.html"
+        "https://github.com/adaptivecomputing/torque/blob/master/PBS_License.txt",
+        "https://www.mcs.anl.gov/research/projects/openpbs/PBS_License.txt"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-2.0+.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GPL-2.0+.json",
-      "referenceNumber": 337,
-      "name": "GNU General Public License v2.0 or later",
-      "licenseId": "GPL-2.0+",
+      "reference": "https://spdx.org/licenses/OpenSSL.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/OpenSSL.json",
+      "referenceNumber": 445,
+      "name": "OpenSSL License",
+      "licenseId": "OpenSSL",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html",
-        "https://opensource.org/licenses/GPL-2.0"
+        "http://www.openssl.org/source/license.html"
       ],
-      "isOsiApproved": true,
+      "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-2.5.html",
+      "reference": "https://spdx.org/licenses/OpenSSL-standalone.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.5.json",
-      "referenceNumber": 338,
-      "name": "Open LDAP Public License v2.5",
-      "licenseId": "OLDAP-2.5",
+      "detailsUrl": "https://spdx.org/licenses/OpenSSL-standalone.json",
+      "referenceNumber": 635,
+      "name": "OpenSSL License - standalone",
+      "licenseId": "OpenSSL-standalone",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d6852b9d90022e8593c98205413380536b1b5a7cf"
+        "https://library.netapp.com/ecm/ecm_download_file/ECMP1196395",
+        "https://hstechdocs.helpsystems.com/manuals/globalscape/archive/cuteftp6/open_ssl_license_agreement.htm"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/JasPer-2.0.html",
+      "reference": "https://spdx.org/licenses/OpenVision.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/JasPer-2.0.json",
-      "referenceNumber": 339,
-      "name": "JasPer License",
-      "licenseId": "JasPer-2.0",
+      "detailsUrl": "https://spdx.org/licenses/OpenVision.json",
+      "referenceNumber": 589,
+      "name": "OpenVision License",
+      "licenseId": "OpenVision",
       "seeAlso": [
-        "http://www.ece.uvic.ca/~mdadams/jasper/LICENSE"
+        "https://github.com/krb5/krb5/blob/krb5-1.21.2-final/NOTICE#L66-L98",
+        "https://web.mit.edu/kerberos/krb5-1.21/doc/mitK5license.html",
+        "https://fedoraproject.org/wiki/Licensing:MIT#OpenVision_Variant"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-2.0-or-later.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GPL-2.0-or-later.json",
-      "referenceNumber": 340,
-      "name": "GNU General Public License v2.0 or later",
-      "licenseId": "GPL-2.0-or-later",
-      "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html",
-        "https://opensource.org/licenses/GPL-2.0"
-      ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
-    },
-    {
-      "reference": "https://spdx.org/licenses/BSD-2-Clause-Patent.html",
+      "reference": "https://spdx.org/licenses/OPL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-2-Clause-Patent.json",
-      "referenceNumber": 341,
-      "name": "BSD-2-Clause Plus Patent License",
-      "licenseId": "BSD-2-Clause-Patent",
+      "detailsUrl": "https://spdx.org/licenses/OPL-1.0.json",
+      "referenceNumber": 80,
+      "name": "Open Public License v1.0",
+      "licenseId": "OPL-1.0",
       "seeAlso": [
-        "https://opensource.org/licenses/BSDplusPatent"
+        "http://old.koalateam.com/jackaroo/OPL_1_0.TXT",
+        "https://fedoraproject.org/wiki/Licensing/Open_Public_License"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/MS-RL.html",
+      "reference": "https://spdx.org/licenses/OPL-UK-3.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MS-RL.json",
-      "referenceNumber": 342,
-      "name": "Microsoft Reciprocal License",
-      "licenseId": "MS-RL",
+      "detailsUrl": "https://spdx.org/licenses/OPL-UK-3.0.json",
+      "referenceNumber": 19,
+      "name": "United    Kingdom Open Parliament Licence v3.0",
+      "licenseId": "OPL-UK-3.0",
       "seeAlso": [
-        "http://www.microsoft.com/opensource/licenses.mspx",
-        "https://opensource.org/licenses/MS-RL"
+        "https://www.parliament.uk/site-information/copyright-parliament/open-parliament-licence/"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CUA-OPL-1.0.html",
+      "reference": "https://spdx.org/licenses/OPUBL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CUA-OPL-1.0.json",
-      "referenceNumber": 343,
-      "name": "CUA Office Public License v1.0",
-      "licenseId": "CUA-OPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/OPUBL-1.0.json",
+      "referenceNumber": 266,
+      "name": "Open Publication License v1.0",
+      "licenseId": "OPUBL-1.0",
       "seeAlso": [
-        "https://opensource.org/licenses/CUA-OPL-1.0"
+        "http://opencontent.org/openpub/",
+        "https://www.debian.org/opl",
+        "https://www.ctan.org/license/opl"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/IPA.html",
+      "reference": "https://spdx.org/licenses/OSET-PL-2.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/IPA.json",
-      "referenceNumber": 344,
-      "name": "IPA Font License",
-      "licenseId": "IPA",
+      "detailsUrl": "https://spdx.org/licenses/OSET-PL-2.1.json",
+      "referenceNumber": 307,
+      "name": "OSET Public License version 2.1",
+      "licenseId": "OSET-PL-2.1",
       "seeAlso": [
-        "https://opensource.org/licenses/IPA"
+        "http://www.osetfoundation.org/public-license",
+        "https://opensource.org/licenses/OPL-2.1"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/NLPL.html",
+      "reference": "https://spdx.org/licenses/OSL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NLPL.json",
-      "referenceNumber": 345,
-      "name": "No Limit Public License",
-      "licenseId": "NLPL",
+      "detailsUrl": "https://spdx.org/licenses/OSL-1.0.json",
+      "referenceNumber": 306,
+      "name": "Open Software License 1.0",
+      "licenseId": "OSL-1.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/NLPL"
+        "https://opensource.org/licenses/OSL-1.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/O-UDA-1.0.html",
+      "reference": "https://spdx.org/licenses/OSL-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/O-UDA-1.0.json",
-      "referenceNumber": 346,
-      "name": "Open Use of Data Agreement v1.0",
-      "licenseId": "O-UDA-1.0",
+      "detailsUrl": "https://spdx.org/licenses/OSL-1.1.json",
+      "referenceNumber": 111,
+      "name": "Open Software License 1.1",
+      "licenseId": "OSL-1.1",
       "seeAlso": [
-        "https://github.com/microsoft/Open-Use-of-Data-Agreement/blob/v1.0/O-UDA-1.0.md",
-        "https://cdla.dev/open-use-of-data-agreement-v1-0/"
+        "https://fedoraproject.org/wiki/Licensing/OSL1.1"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/MIT-Modern-Variant.html",
+      "reference": "https://spdx.org/licenses/OSL-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MIT-Modern-Variant.json",
-      "referenceNumber": 347,
-      "name": "MIT License Modern Variant",
-      "licenseId": "MIT-Modern-Variant",
+      "detailsUrl": "https://spdx.org/licenses/OSL-2.0.json",
+      "referenceNumber": 457,
+      "name": "Open Software License 2.0",
+      "licenseId": "OSL-2.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing:MIT#Modern_Variants",
-        "https://ptolemy.berkeley.edu/copyright.htm",
-        "https://pirlwww.lpl.arizona.edu/resources/guide/software/PerlTk/Tixlic.html"
+        "http://web.archive.org/web/20041020171434/http://www.rosenlaw.com/osl2.0.html"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-1.2.html",
+      "reference": "https://spdx.org/licenses/OSL-2.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-1.2.json",
-      "referenceNumber": 348,
-      "name": "Open LDAP Public License v1.2",
-      "licenseId": "OLDAP-1.2",
+      "detailsUrl": "https://spdx.org/licenses/OSL-2.1.json",
+      "referenceNumber": 247,
+      "name": "Open Software License 2.1",
+      "licenseId": "OSL-2.1",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d42b0383c50c299977b5893ee695cf4e486fb0dc7"
+        "http://web.archive.org/web/20050212003940/http://www.rosenlaw.com/osl21.htm",
+        "https://opensource.org/licenses/OSL-2.1"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-2-Clause-FreeBSD.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/BSD-2-Clause-FreeBSD.json",
-      "referenceNumber": 349,
-      "name": "BSD 2-Clause FreeBSD License",
-      "licenseId": "BSD-2-Clause-FreeBSD",
+      "reference": "https://spdx.org/licenses/OSL-3.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/OSL-3.0.json",
+      "referenceNumber": 432,
+      "name": "Open Software License 3.0",
+      "licenseId": "OSL-3.0",
       "seeAlso": [
-        "http://www.freebsd.org/copyright/freebsd-license.html"
+        "https://web.archive.org/web/20120101081418/http://rosenlaw.com:80/OSL3.0.htm",
+        "https://opensource.org/licenses/OSL-3.0"
       ],
-      "isOsiApproved": false,
+      "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Info-ZIP.html",
+      "reference": "https://spdx.org/licenses/PADL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Info-ZIP.json",
-      "referenceNumber": 350,
-      "name": "Info-ZIP License",
-      "licenseId": "Info-ZIP",
+      "detailsUrl": "https://spdx.org/licenses/PADL.json",
+      "referenceNumber": 43,
+      "name": "PADL License",
+      "licenseId": "PADL",
       "seeAlso": [
-        "http://www.info-zip.org/license.html"
+        "https://git.openldap.org/openldap/openldap/-/blob/master/libraries/libldap/os-local.c?ref_type\u003dheads#L19-23"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-2.0-FR.html",
+      "reference": "https://spdx.org/licenses/Parity-6.0.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-2.0-FR.json",
-      "referenceNumber": 351,
-      "name": "Creative Commons Attribution-NonCommercial-ShareAlike 2.0 France",
-      "licenseId": "CC-BY-NC-SA-2.0-FR",
+      "detailsUrl": "https://spdx.org/licenses/Parity-6.0.0.json",
+      "referenceNumber": 49,
+      "name": "The Parity Public License 6.0.0",
+      "licenseId": "Parity-6.0.0",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-sa/2.0/fr/legalcode"
+        "https://paritylicense.com/versions/6.0.0.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/0BSD.html",
+      "reference": "https://spdx.org/licenses/Parity-7.0.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/0BSD.json",
-      "referenceNumber": 352,
-      "name": "BSD Zero Clause License",
-      "licenseId": "0BSD",
+      "detailsUrl": "https://spdx.org/licenses/Parity-7.0.0.json",
+      "referenceNumber": 482,
+      "name": "The Parity Public License 7.0.0",
+      "licenseId": "Parity-7.0.0",
       "seeAlso": [
-        "http://landley.net/toybox/license.html",
-        "https://opensource.org/licenses/0BSD"
+        "https://paritylicense.com/versions/7.0.0.html"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Unicode-DFS-2016.html",
+      "reference": "https://spdx.org/licenses/PDDL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Unicode-DFS-2016.json",
-      "referenceNumber": 353,
-      "name": "Unicode License Agreement - Data Files and Software (2016)",
-      "licenseId": "Unicode-DFS-2016",
+      "detailsUrl": "https://spdx.org/licenses/PDDL-1.0.json",
+      "referenceNumber": 210,
+      "name": "Open Data Commons Public Domain Dedication \u0026 License 1.0",
+      "licenseId": "PDDL-1.0",
       "seeAlso": [
-        "http://www.unicode.org/copyright.html"
+        "http://opendatacommons.org/licenses/pddl/1.0/",
+        "https://opendatacommons.org/licenses/pddl/"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OFL-1.0-RFN.html",
+      "reference": "https://spdx.org/licenses/PHP-3.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OFL-1.0-RFN.json",
-      "referenceNumber": 354,
-      "name": "SIL Open Font License 1.0 with Reserved Font Name",
-      "licenseId": "OFL-1.0-RFN",
+      "detailsUrl": "https://spdx.org/licenses/PHP-3.0.json",
+      "referenceNumber": 580,
+      "name": "PHP License v3.0",
+      "licenseId": "PHP-3.0",
       "seeAlso": [
-        "http://scripts.sil.org/cms/scripts/page.php?item_id\u003dOFL10_web"
+        "http://www.php.net/license/3_0.txt",
+        "https://opensource.org/licenses/PHP-3.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/Intel.html",
+      "reference": "https://spdx.org/licenses/PHP-3.01.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Intel.json",
-      "referenceNumber": 355,
-      "name": "Intel Open Source License",
-      "licenseId": "Intel",
+      "detailsUrl": "https://spdx.org/licenses/PHP-3.01.json",
+      "referenceNumber": 594,
+      "name": "PHP License v3.01",
+      "licenseId": "PHP-3.01",
       "seeAlso": [
-        "https://opensource.org/licenses/Intel"
+        "http://www.php.net/license/3_01.txt"
       ],
       "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/AFL-2.0.html",
+      "reference": "https://spdx.org/licenses/Pixar.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/AFL-2.0.json",
-      "referenceNumber": 356,
-      "name": "Academic Free License v2.0",
-      "licenseId": "AFL-2.0",
+      "detailsUrl": "https://spdx.org/licenses/Pixar.json",
+      "referenceNumber": 619,
+      "name": "Pixar License",
+      "licenseId": "Pixar",
       "seeAlso": [
-        "http://wayback.archive.org/web/20060924134533/http://www.opensource.org/licenses/afl-2.0.txt"
+        "https://github.com/PixarAnimationStudios/OpenSubdiv/raw/v3_5_0/LICENSE.txt",
+        "https://graphics.pixar.com/opensubdiv/docs/license.html",
+        "https://github.com/PixarAnimationStudios/OpenSubdiv/blob/v3_5_0/opensubdiv/version.cpp#L2-L22"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GL2PS.html",
+      "reference": "https://spdx.org/licenses/pkgconf.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GL2PS.json",
-      "referenceNumber": 357,
-      "name": "GL2PS License",
-      "licenseId": "GL2PS",
+      "detailsUrl": "https://spdx.org/licenses/pkgconf.json",
+      "referenceNumber": 16,
+      "name": "pkgconf License",
+      "licenseId": "pkgconf",
       "seeAlso": [
-        "http://www.geuz.org/gl2ps/COPYING.GL2PS"
+        "https://github.com/pkgconf/pkgconf/blob/master/cli/main.c#L8"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/TAPR-OHL-1.0.html",
+      "reference": "https://spdx.org/licenses/Plexus.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/TAPR-OHL-1.0.json",
-      "referenceNumber": 358,
-      "name": "TAPR Open Hardware License v1.0",
-      "licenseId": "TAPR-OHL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/Plexus.json",
+      "referenceNumber": 442,
+      "name": "Plexus Classworlds License",
+      "licenseId": "Plexus",
       "seeAlso": [
-        "https://www.tapr.org/OHL"
+        "https://fedoraproject.org/wiki/Licensing/Plexus_Classworlds_License"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Apache-1.0.html",
+      "reference": "https://spdx.org/licenses/pnmstitch.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Apache-1.0.json",
-      "referenceNumber": 359,
-      "name": "Apache License 1.0",
-      "licenseId": "Apache-1.0",
+      "detailsUrl": "https://spdx.org/licenses/pnmstitch.json",
+      "referenceNumber": 502,
+      "name": "pnmstitch License",
+      "licenseId": "pnmstitch",
       "seeAlso": [
-        "http://www.apache.org/licenses/LICENSE-1.0"
+        "https://sourceforge.net/p/netpbm/code/HEAD/tree/super_stable/editor/pnmstitch.c#l2"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/MTLL.html",
+      "reference": "https://spdx.org/licenses/PolyForm-Noncommercial-1.0.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MTLL.json",
-      "referenceNumber": 360,
-      "name": "Matrix Template Library License",
-      "licenseId": "MTLL",
+      "detailsUrl": "https://spdx.org/licenses/PolyForm-Noncommercial-1.0.0.json",
+      "referenceNumber": 575,
+      "name": "PolyForm Noncommercial License 1.0.0",
+      "licenseId": "PolyForm-Noncommercial-1.0.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Matrix_Template_Library_License"
+        "https://polyformproject.org/licenses/noncommercial/1.0.0"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Motosoto.html",
+      "reference": "https://spdx.org/licenses/PolyForm-Small-Business-1.0.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Motosoto.json",
-      "referenceNumber": 361,
-      "name": "Motosoto License",
-      "licenseId": "Motosoto",
+      "detailsUrl": "https://spdx.org/licenses/PolyForm-Small-Business-1.0.0.json",
+      "referenceNumber": 9,
+      "name": "PolyForm Small Business License 1.0.0",
+      "licenseId": "PolyForm-Small-Business-1.0.0",
       "seeAlso": [
-        "https://opensource.org/licenses/Motosoto"
+        "https://polyformproject.org/licenses/small-business/1.0.0"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/RSA-MD.html",
+      "reference": "https://spdx.org/licenses/PostgreSQL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/RSA-MD.json",
-      "referenceNumber": 362,
-      "name": "RSA Message-Digest License",
-      "licenseId": "RSA-MD",
+      "detailsUrl": "https://spdx.org/licenses/PostgreSQL.json",
+      "referenceNumber": 94,
+      "name": "PostgreSQL License",
+      "licenseId": "PostgreSQL",
       "seeAlso": [
-        "http://www.faqs.org/rfcs/rfc1321.html"
+        "http://www.postgresql.org/about/licence",
+        "https://opensource.org/licenses/PostgreSQL"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/Community-Spec-1.0.html",
+      "reference": "https://spdx.org/licenses/PPL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Community-Spec-1.0.json",
-      "referenceNumber": 363,
-      "name": "Community Specification License 1.0",
-      "licenseId": "Community-Spec-1.0",
+      "detailsUrl": "https://spdx.org/licenses/PPL.json",
+      "referenceNumber": 454,
+      "name": "Peer Production License",
+      "licenseId": "PPL",
       "seeAlso": [
-        "https://github.com/CommunitySpecification/1.0/blob/master/1._Community_Specification_License-v1.md"
+        "https://wiki.p2pfoundation.net/Peer_Production_License",
+        "http://www.networkcultures.org/_uploads/%233notebook_telekommunist.pdf"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/ODC-By-1.0.html",
+      "reference": "https://spdx.org/licenses/PSF-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ODC-By-1.0.json",
-      "referenceNumber": 364,
-      "name": "Open Data Commons Attribution License v1.0",
-      "licenseId": "ODC-By-1.0",
+      "detailsUrl": "https://spdx.org/licenses/PSF-2.0.json",
+      "referenceNumber": 62,
+      "name": "Python Software Foundation License 2.0",
+      "licenseId": "PSF-2.0",
       "seeAlso": [
-        "https://opendatacommons.org/licenses/by/1.0/"
+        "https://opensource.org/licenses/Python-2.0"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/zlib-acknowledgement.html",
+      "reference": "https://spdx.org/licenses/psfrag.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/zlib-acknowledgement.json",
-      "referenceNumber": 365,
-      "name": "zlib/libpng License with Acknowledgement",
-      "licenseId": "zlib-acknowledgement",
+      "detailsUrl": "https://spdx.org/licenses/psfrag.json",
+      "referenceNumber": 279,
+      "name": "psfrag License",
+      "licenseId": "psfrag",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/ZlibWithAcknowledgement"
+        "https://fedoraproject.org/wiki/Licensing/psfrag"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/DL-DE-BY-2.0.html",
+      "reference": "https://spdx.org/licenses/psutils.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/DL-DE-BY-2.0.json",
-      "referenceNumber": 366,
-      "name": "Data licence Germany – attribution – version 2.0",
-      "licenseId": "DL-DE-BY-2.0",
+      "detailsUrl": "https://spdx.org/licenses/psutils.json",
+      "referenceNumber": 387,
+      "name": "psutils License",
+      "licenseId": "psutils",
       "seeAlso": [
-        "https://www.govdata.de/dl-de/by-2-0"
+        "https://fedoraproject.org/wiki/Licensing/psutils"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/VSL-1.0.html",
+      "reference": "https://spdx.org/licenses/Python-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/VSL-1.0.json",
-      "referenceNumber": 367,
-      "name": "Vovida Software License v1.0",
-      "licenseId": "VSL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/Python-2.0.json",
+      "referenceNumber": 498,
+      "name": "Python License 2.0",
+      "licenseId": "Python-2.0",
       "seeAlso": [
-        "https://opensource.org/licenses/VSL-1.0"
+        "https://opensource.org/licenses/Python-2.0"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/LiLiQ-R-1.1.html",
+      "reference": "https://spdx.org/licenses/Python-2.0.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LiLiQ-R-1.1.json",
-      "referenceNumber": 368,
-      "name": "Licence Libre du Québec – Réciprocité version 1.1",
-      "licenseId": "LiLiQ-R-1.1",
+      "detailsUrl": "https://spdx.org/licenses/Python-2.0.1.json",
+      "referenceNumber": 453,
+      "name": "Python License 2.0.1",
+      "licenseId": "Python-2.0.1",
       "seeAlso": [
-        "https://www.forge.gouv.qc.ca/participez/licence-logicielle/licence-libre-du-quebec-liliq-en-francais/licence-libre-du-quebec-reciprocite-liliq-r-v1-1/",
-        "http://opensource.org/licenses/LiLiQ-R-1.1"
+        "https://www.python.org/download/releases/2.0.1/license/",
+        "https://docs.python.org/3/license.html",
+        "https://github.com/python/cpython/blob/main/LICENSE"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OPL-1.0.html",
+      "reference": "https://spdx.org/licenses/python-ldap.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OPL-1.0.json",
-      "referenceNumber": 369,
-      "name": "Open Public License v1.0",
-      "licenseId": "OPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/python-ldap.json",
+      "referenceNumber": 422,
+      "name": "Python ldap License",
+      "licenseId": "python-ldap",
       "seeAlso": [
-        "http://old.koalateam.com/jackaroo/OPL_1_0.TXT",
-        "https://fedoraproject.org/wiki/Licensing/Open_Public_License"
+        "https://github.com/python-ldap/python-ldap/blob/main/LICENCE"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-3.0+.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GPL-3.0+.json",
-      "referenceNumber": 370,
-      "name": "GNU General Public License v3.0 or later",
-      "licenseId": "GPL-3.0+",
+      "reference": "https://spdx.org/licenses/Qhull.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Qhull.json",
+      "referenceNumber": 123,
+      "name": "Qhull License",
+      "licenseId": "Qhull",
       "seeAlso": [
-        "https://www.gnu.org/licenses/gpl-3.0-standalone.html",
-        "https://opensource.org/licenses/GPL-3.0"
+        "https://fedoraproject.org/wiki/Licensing/Qhull"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/MulanPSL-2.0.html",
+      "reference": "https://spdx.org/licenses/QPL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MulanPSL-2.0.json",
-      "referenceNumber": 371,
-      "name": "Mulan Permissive Software License, Version 2",
-      "licenseId": "MulanPSL-2.0",
+      "detailsUrl": "https://spdx.org/licenses/QPL-1.0.json",
+      "referenceNumber": 329,
+      "name": "Q Public License 1.0",
+      "licenseId": "QPL-1.0",
       "seeAlso": [
-        "https://license.coscl.org.cn/MulanPSL2/"
+        "http://doc.qt.nokia.com/3.3/license.html",
+        "https://opensource.org/licenses/QPL-1.0",
+        "https://doc.qt.io/archives/3.3/license.html"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/APSL-1.2.html",
+      "reference": "https://spdx.org/licenses/QPL-1.0-INRIA-2004.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/APSL-1.2.json",
-      "referenceNumber": 372,
-      "name": "Apple Public Source License 1.2",
-      "licenseId": "APSL-1.2",
+      "detailsUrl": "https://spdx.org/licenses/QPL-1.0-INRIA-2004.json",
+      "referenceNumber": 479,
+      "name": "Q Public License 1.0 - INRIA 2004 variant",
+      "licenseId": "QPL-1.0-INRIA-2004",
       "seeAlso": [
-        "http://www.samurajdata.se/opensource/mirror/licenses/apsl.php"
+        "https://github.com/maranget/hevea/blob/master/LICENSE"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OGDL-Taiwan-1.0.html",
+      "reference": "https://spdx.org/licenses/radvd.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OGDL-Taiwan-1.0.json",
-      "referenceNumber": 373,
-      "name": "Taiwan Open Government Data License, version 1.0",
-      "licenseId": "OGDL-Taiwan-1.0",
+      "detailsUrl": "https://spdx.org/licenses/radvd.json",
+      "referenceNumber": 182,
+      "name": "radvd License",
+      "licenseId": "radvd",
       "seeAlso": [
-        "https://data.gov.tw/license"
+        "https://github.com/radvd-project/radvd/blob/master/COPYRIGHT"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/RSCPL.html",
+      "reference": "https://spdx.org/licenses/Rdisc.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/RSCPL.json",
-      "referenceNumber": 374,
-      "name": "Ricoh Source Code Public License",
-      "licenseId": "RSCPL",
+      "detailsUrl": "https://spdx.org/licenses/Rdisc.json",
+      "referenceNumber": 101,
+      "name": "Rdisc License",
+      "licenseId": "Rdisc",
       "seeAlso": [
-        "http://wayback.archive.org/web/20060715140826/http://www.risource.org/RPL/RPL-1.0A.shtml",
-        "https://opensource.org/licenses/RSCPL"
+        "https://fedoraproject.org/wiki/Licensing/Rdisc_License"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OGC-1.0.html",
+      "reference": "https://spdx.org/licenses/RHeCos-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OGC-1.0.json",
-      "referenceNumber": 375,
-      "name": "OGC Software License, Version 1.0",
-      "licenseId": "OGC-1.0",
+      "detailsUrl": "https://spdx.org/licenses/RHeCos-1.1.json",
+      "referenceNumber": 373,
+      "name": "Red Hat eCos Public License v1.1",
+      "licenseId": "RHeCos-1.1",
       "seeAlso": [
-        "https://www.ogc.org/ogc/software/1.0"
+        "http://ecos.sourceware.org/old-license.html"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/EFL-2.0.html",
+      "reference": "https://spdx.org/licenses/RPL-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/EFL-2.0.json",
-      "referenceNumber": 376,
-      "name": "Eiffel Forum License v2.0",
-      "licenseId": "EFL-2.0",
+      "detailsUrl": "https://spdx.org/licenses/RPL-1.1.json",
+      "referenceNumber": 369,
+      "name": "Reciprocal Public License 1.1",
+      "licenseId": "RPL-1.1",
       "seeAlso": [
-        "http://www.eiffel-nice.org/license/eiffel-forum-license-2.html",
-        "https://opensource.org/licenses/EFL-2.0"
+        "https://opensource.org/licenses/RPL-1.1"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/CAL-1.0-Combined-Work-Exception.html",
+      "reference": "https://spdx.org/licenses/RPL-1.5.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CAL-1.0-Combined-Work-Exception.json",
-      "referenceNumber": 377,
-      "name": "Cryptographic Autonomy License 1.0 (Combined Work Exception)",
-      "licenseId": "CAL-1.0-Combined-Work-Exception",
+      "detailsUrl": "https://spdx.org/licenses/RPL-1.5.json",
+      "referenceNumber": 102,
+      "name": "Reciprocal Public License 1.5",
+      "licenseId": "RPL-1.5",
       "seeAlso": [
-        "http://cryptographicautonomylicense.com/license-text.html",
-        "https://opensource.org/licenses/CAL-1.0"
+        "https://opensource.org/licenses/RPL-1.5"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/MS-PL.html",
+      "reference": "https://spdx.org/licenses/RPSL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MS-PL.json",
-      "referenceNumber": 378,
-      "name": "Microsoft Public License",
-      "licenseId": "MS-PL",
+      "detailsUrl": "https://spdx.org/licenses/RPSL-1.0.json",
+      "referenceNumber": 663,
+      "name": "RealNetworks Public Source License v1.0",
+      "licenseId": "RPSL-1.0",
       "seeAlso": [
-        "http://www.microsoft.com/opensource/licenses.mspx",
-        "https://opensource.org/licenses/MS-PL"
+        "https://helixcommunity.org/content/rpsl",
+        "https://opensource.org/licenses/RPSL-1.0"
       ],
       "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Plexus.html",
+      "reference": "https://spdx.org/licenses/RSA-MD.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Plexus.json",
-      "referenceNumber": 379,
-      "name": "Plexus Classworlds License",
-      "licenseId": "Plexus",
+      "detailsUrl": "https://spdx.org/licenses/RSA-MD.json",
+      "referenceNumber": 139,
+      "name": "RSA Message-Digest License",
+      "licenseId": "RSA-MD",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Plexus_Classworlds_License"
+        "http://www.faqs.org/rfcs/rfc1321.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Sendmail-8.23.html",
+      "reference": "https://spdx.org/licenses/RSCPL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Sendmail-8.23.json",
-      "referenceNumber": 380,
-      "name": "Sendmail License 8.23",
-      "licenseId": "Sendmail-8.23",
+      "detailsUrl": "https://spdx.org/licenses/RSCPL.json",
+      "referenceNumber": 405,
+      "name": "Ricoh Source Code Public License",
+      "licenseId": "RSCPL",
       "seeAlso": [
-        "https://www.proofpoint.com/sites/default/files/sendmail-license.pdf",
-        "https://web.archive.org/web/20181003101040/https://www.proofpoint.com/sites/default/files/sendmail-license.pdf"
+        "http://wayback.archive.org/web/20060715140826/http://www.risource.org/RPL/RPL-1.0A.shtml",
+        "https://opensource.org/licenses/RSCPL"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/Cube.html",
+      "reference": "https://spdx.org/licenses/Ruby.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Cube.json",
-      "referenceNumber": 381,
-      "name": "Cube License",
-      "licenseId": "Cube",
+      "detailsUrl": "https://spdx.org/licenses/Ruby.json",
+      "referenceNumber": 192,
+      "name": "Ruby License",
+      "licenseId": "Ruby",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Cube"
+        "https://www.ruby-lang.org/en/about/license.txt"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/JSON.html",
+      "reference": "https://spdx.org/licenses/Ruby-pty.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/JSON.json",
-      "referenceNumber": 382,
-      "name": "JSON License",
-      "licenseId": "JSON",
+      "detailsUrl": "https://spdx.org/licenses/Ruby-pty.json",
+      "referenceNumber": 473,
+      "name": "Ruby pty extension license",
+      "licenseId": "Ruby-pty",
       "seeAlso": [
-        "http://www.json.org/license.html"
+        "https://github.com/ruby/ruby/blob/9f6deaa6888a423720b4b127b5314f0ad26cc2e6/ext/pty/pty.c#L775-L786",
+        "https://github.com/ruby/ruby/commit/0a64817fb80016030c03518fb9459f63c11605ea#diff-ef5fa30838d6d0cecad9e675cc50b24628cfe2cb277c346053fafcc36c91c204",
+        "https://github.com/ruby/ruby/commit/0a64817fb80016030c03518fb9459f63c11605ea#diff-fedf217c1ce44bda01f0a678d3ff8b198bed478754d699c527a698ad933979a0"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/EUPL-1.2.html",
+      "reference": "https://spdx.org/licenses/SAX-PD.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/EUPL-1.2.json",
-      "referenceNumber": 383,
-      "name": "European Union Public License 1.2",
-      "licenseId": "EUPL-1.2",
+      "detailsUrl": "https://spdx.org/licenses/SAX-PD.json",
+      "referenceNumber": 205,
+      "name": "Sax Public Domain Notice",
+      "licenseId": "SAX-PD",
       "seeAlso": [
-        "https://joinup.ec.europa.eu/page/eupl-text-11-12",
-        "https://joinup.ec.europa.eu/sites/default/files/custom-page/attachment/eupl_v1.2_en.pdf",
-        "https://joinup.ec.europa.eu/sites/default/files/custom-page/attachment/2020-03/EUPL-1.2%20EN.txt",
-        "https://joinup.ec.europa.eu/sites/default/files/inline-files/EUPL%20v1_2%20EN(1).txt",
-        "http://eur-lex.europa.eu/legal-content/EN/TXT/HTML/?uri\u003dCELEX:32017D0863",
-        "https://opensource.org/licenses/EUPL-1.2"
+        "http://www.saxproject.org/copying.html"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Adobe-Glyph.html",
+      "reference": "https://spdx.org/licenses/SAX-PD-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Adobe-Glyph.json",
-      "referenceNumber": 384,
-      "name": "Adobe Glyph List License",
-      "licenseId": "Adobe-Glyph",
+      "detailsUrl": "https://spdx.org/licenses/SAX-PD-2.0.json",
+      "referenceNumber": 209,
+      "name": "Sax Public Domain Notice 2.0",
+      "licenseId": "SAX-PD-2.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/MIT#AdobeGlyph"
+        "http://www.saxproject.org/copying.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/FreeImage.html",
+      "reference": "https://spdx.org/licenses/Saxpath.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/FreeImage.json",
-      "referenceNumber": 385,
-      "name": "FreeImage Public License v1.0",
-      "licenseId": "FreeImage",
+      "detailsUrl": "https://spdx.org/licenses/Saxpath.json",
+      "referenceNumber": 67,
+      "name": "Saxpath License",
+      "licenseId": "Saxpath",
       "seeAlso": [
-        "http://freeimage.sourceforge.net/freeimage-license.txt"
+        "https://fedoraproject.org/wiki/Licensing/Saxpath_License"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Watcom-1.0.html",
+      "reference": "https://spdx.org/licenses/SCEA.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Watcom-1.0.json",
-      "referenceNumber": 386,
-      "name": "Sybase Open Watcom Public License 1.0",
-      "licenseId": "Watcom-1.0",
+      "detailsUrl": "https://spdx.org/licenses/SCEA.json",
+      "referenceNumber": 617,
+      "name": "SCEA Shared Source License",
+      "licenseId": "SCEA",
       "seeAlso": [
-        "https://opensource.org/licenses/Watcom-1.0"
+        "http://research.scea.com/scea_shared_source_license.html"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Jam.html",
+      "reference": "https://spdx.org/licenses/SchemeReport.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Jam.json",
-      "referenceNumber": 387,
-      "name": "Jam License",
-      "licenseId": "Jam",
+      "detailsUrl": "https://spdx.org/licenses/SchemeReport.json",
+      "referenceNumber": 472,
+      "name": "Scheme Language Report License",
+      "licenseId": "SchemeReport",
+      "seeAlso": [],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/Sendmail.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Sendmail.json",
+      "referenceNumber": 135,
+      "name": "Sendmail License",
+      "licenseId": "Sendmail",
       "seeAlso": [
-        "https://www.boost.org/doc/libs/1_35_0/doc/html/jam.html",
-        "https://web.archive.org/web/20160330173339/https://swarm.workshop.perforce.com/files/guest/perforce_software/jam/src/README"
+        "http://www.sendmail.com/pdfs/open_source/sendmail_license.pdf",
+        "https://web.archive.org/web/20160322142305/https://www.sendmail.com/pdfs/open_source/sendmail_license.pdf"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Hippocratic-2.1.html",
+      "reference": "https://spdx.org/licenses/Sendmail-8.23.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Hippocratic-2.1.json",
-      "referenceNumber": 388,
-      "name": "Hippocratic License 2.1",
-      "licenseId": "Hippocratic-2.1",
+      "detailsUrl": "https://spdx.org/licenses/Sendmail-8.23.json",
+      "referenceNumber": 226,
+      "name": "Sendmail License 8.23",
+      "licenseId": "Sendmail-8.23",
       "seeAlso": [
-        "https://firstdonoharm.dev/version/2/1/license.html",
-        "https://github.com/EthicalSource/hippocratic-license/blob/58c0e646d64ff6fbee275bfe2b9492f914e3ab2a/LICENSE.txt"
+        "https://www.proofpoint.com/sites/default/files/sendmail-license.pdf",
+        "https://web.archive.org/web/20181003101040/https://www.proofpoint.com/sites/default/files/sendmail-license.pdf"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-2.0.1.html",
+      "reference": "https://spdx.org/licenses/SGI-B-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.0.1.json",
-      "referenceNumber": 389,
-      "name": "Open LDAP Public License v2.0.1",
-      "licenseId": "OLDAP-2.0.1",
+      "detailsUrl": "https://spdx.org/licenses/SGI-B-1.0.json",
+      "referenceNumber": 631,
+      "name": "SGI Free Software License B v1.0",
+      "licenseId": "SGI-B-1.0",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003db6d68acd14e51ca3aab4428bf26522aa74873f0e"
+        "http://oss.sgi.com/projects/FreeB/SGIFreeSWLicB.1.0.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-SA-2.0.html",
+      "reference": "https://spdx.org/licenses/SGI-B-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-SA-2.0.json",
-      "referenceNumber": 390,
-      "name": "Creative Commons Attribution Non Commercial Share Alike 2.0 Generic",
-      "licenseId": "CC-BY-NC-SA-2.0",
+      "detailsUrl": "https://spdx.org/licenses/SGI-B-1.1.json",
+      "referenceNumber": 48,
+      "name": "SGI Free Software License B v1.1",
+      "licenseId": "SGI-B-1.1",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-sa/2.0/legalcode"
+        "http://oss.sgi.com/projects/FreeB/"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Nokia.html",
+      "reference": "https://spdx.org/licenses/SGI-B-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Nokia.json",
-      "referenceNumber": 391,
-      "name": "Nokia Open Source License",
-      "licenseId": "Nokia",
+      "detailsUrl": "https://spdx.org/licenses/SGI-B-2.0.json",
+      "referenceNumber": 193,
+      "name": "SGI Free Software License B v2.0",
+      "licenseId": "SGI-B-2.0",
       "seeAlso": [
-        "https://opensource.org/licenses/nokia"
+        "http://oss.sgi.com/projects/FreeB/SGIFreeSWLicB.2.0.pdf"
       ],
-      "isOsiApproved": true,
+      "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/OCCT-PL.html",
+      "reference": "https://spdx.org/licenses/SGI-OpenGL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OCCT-PL.json",
-      "referenceNumber": 392,
-      "name": "Open CASCADE Technology Public License",
-      "licenseId": "OCCT-PL",
+      "detailsUrl": "https://spdx.org/licenses/SGI-OpenGL.json",
+      "referenceNumber": 565,
+      "name": "SGI OpenGL License",
+      "licenseId": "SGI-OpenGL",
       "seeAlso": [
-        "http://www.opencascade.com/content/occt-public-license"
+        "https://gitlab.freedesktop.org/mesa/glw/-/blob/master/README?ref_type\u003dheads"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/ErlPL-1.1.html",
+      "reference": "https://spdx.org/licenses/SGP4.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ErlPL-1.1.json",
-      "referenceNumber": 393,
-      "name": "Erlang Public License v1.1",
-      "licenseId": "ErlPL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/SGP4.json",
+      "referenceNumber": 291,
+      "name": "SGP4 Permission Notice",
+      "licenseId": "SGP4",
       "seeAlso": [
-        "http://www.erlang.org/EPLICENSE"
+        "https://celestrak.org/publications/AIAA/2006-6753/faq.php"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/TOSL.html",
+      "reference": "https://spdx.org/licenses/SHL-0.5.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/TOSL.json",
-      "referenceNumber": 394,
-      "name": "Trusster Open Source License",
-      "licenseId": "TOSL",
+      "detailsUrl": "https://spdx.org/licenses/SHL-0.5.json",
+      "referenceNumber": 623,
+      "name": "Solderpad Hardware License v0.5",
+      "licenseId": "SHL-0.5",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/TOSL"
+        "https://solderpad.org/licenses/SHL-0.5/"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OSL-2.1.html",
+      "reference": "https://spdx.org/licenses/SHL-0.51.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OSL-2.1.json",
-      "referenceNumber": 395,
-      "name": "Open Software License 2.1",
-      "licenseId": "OSL-2.1",
+      "detailsUrl": "https://spdx.org/licenses/SHL-0.51.json",
+      "referenceNumber": 34,
+      "name": "Solderpad Hardware License, Version 0.51",
+      "licenseId": "SHL-0.51",
       "seeAlso": [
-        "http://web.archive.org/web/20050212003940/http://www.rosenlaw.com/osl21.htm",
-        "https://opensource.org/licenses/OSL-2.1"
+        "https://solderpad.org/licenses/SHL-0.51/"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/ClArtistic.html",
+      "reference": "https://spdx.org/licenses/SimPL-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ClArtistic.json",
-      "referenceNumber": 396,
-      "name": "Clarified Artistic License",
-      "licenseId": "ClArtistic",
+      "detailsUrl": "https://spdx.org/licenses/SimPL-2.0.json",
+      "referenceNumber": 630,
+      "name": "Simple Public License 2.0",
+      "licenseId": "SimPL-2.0",
       "seeAlso": [
-        "http://gianluca.dellavedova.org/2011/01/03/clarified-artistic-license/",
-        "http://www.ncftp.com/ncftp/doc/LICENSE.txt"
+        "https://opensource.org/licenses/SimPL-2.0"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/xinetd.html",
+      "reference": "https://spdx.org/licenses/SISSL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/xinetd.json",
-      "referenceNumber": 397,
-      "name": "xinetd License",
-      "licenseId": "xinetd",
+      "detailsUrl": "https://spdx.org/licenses/SISSL.json",
+      "referenceNumber": 655,
+      "name": "Sun Industry Standards Source License v1.1",
+      "licenseId": "SISSL",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Xinetd_License"
+        "http://www.openoffice.org/licenses/sissl_license.html",
+        "https://opensource.org/licenses/SISSL"
       ],
-      "isOsiApproved": false,
+      "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-3.0-with-GCC-exception.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GPL-3.0-with-GCC-exception.json",
-      "referenceNumber": 398,
-      "name": "GNU General Public License v3.0 w/GCC Runtime Library exception",
-      "licenseId": "GPL-3.0-with-GCC-exception",
+      "reference": "https://spdx.org/licenses/SISSL-1.2.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/SISSL-1.2.json",
+      "referenceNumber": 401,
+      "name": "Sun Industry Standards Source License v1.2",
+      "licenseId": "SISSL-1.2",
       "seeAlso": [
-        "https://www.gnu.org/licenses/gcc-exception-3.1.html"
+        "http://gridscheduler.sourceforge.net/Gridengine_SISSL_license.html"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/ODbL-1.0.html",
+      "reference": "https://spdx.org/licenses/SL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ODbL-1.0.json",
-      "referenceNumber": 399,
-      "name": "Open Data Commons Open Database License v1.0",
-      "licenseId": "ODbL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/SL.json",
+      "referenceNumber": 632,
+      "name": "SL License",
+      "licenseId": "SL",
       "seeAlso": [
-        "http://www.opendatacommons.org/licenses/odbl/1.0/",
-        "https://opendatacommons.org/licenses/odbl/1-0/"
+        "https://github.com/mtoyoda/sl/blob/master/LICENSE"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/MIT.html",
+      "reference": "https://spdx.org/licenses/Sleepycat.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MIT.json",
-      "referenceNumber": 400,
-      "name": "MIT License",
-      "licenseId": "MIT",
+      "detailsUrl": "https://spdx.org/licenses/Sleepycat.json",
+      "referenceNumber": 283,
+      "name": "Sleepycat License",
+      "licenseId": "Sleepycat",
       "seeAlso": [
-        "https://opensource.org/licenses/MIT"
+        "https://opensource.org/licenses/Sleepycat"
       ],
       "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/LGPL-2.1+.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/LGPL-2.1+.json",
-      "referenceNumber": 401,
-      "name": "GNU Library General Public License v2.1 or later",
-      "licenseId": "LGPL-2.1+",
+      "reference": "https://spdx.org/licenses/SMLNJ.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/SMLNJ.json",
+      "referenceNumber": 413,
+      "name": "Standard ML of New Jersey License",
+      "licenseId": "SMLNJ",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/lgpl-2.1-standalone.html",
-        "https://opensource.org/licenses/LGPL-2.1"
+        "https://www.smlnj.org/license.html"
       ],
-      "isOsiApproved": true,
+      "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/LGPL-2.1-only.html",
+      "reference": "https://spdx.org/licenses/SMPPL.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/SMPPL.json",
+      "referenceNumber": 321,
+      "name": "Secure Messaging Protocol Public License",
+      "licenseId": "SMPPL",
+      "seeAlso": [
+        "https://github.com/dcblake/SMP/blob/master/Documentation/License.txt"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/SNIA.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/SNIA.json",
+      "referenceNumber": 41,
+      "name": "SNIA Public License 1.1",
+      "licenseId": "SNIA",
+      "seeAlso": [
+        "https://fedoraproject.org/wiki/Licensing/SNIA_Public_License"
+      ],
+      "isOsiApproved": false
+    },
+    {
+      "reference": "https://spdx.org/licenses/snprintf.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LGPL-2.1-only.json",
-      "referenceNumber": 402,
-      "name": "GNU Lesser General Public License v2.1 only",
-      "licenseId": "LGPL-2.1-only",
+      "detailsUrl": "https://spdx.org/licenses/snprintf.json",
+      "referenceNumber": 507,
+      "name": "snprintf License",
+      "licenseId": "snprintf",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/lgpl-2.1-standalone.html",
-        "https://opensource.org/licenses/LGPL-2.1"
+        "https://github.com/openssh/openssh-portable/blob/master/openbsd-compat/bsd-snprintf.c#L2"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CrystalStacker.html",
+      "reference": "https://spdx.org/licenses/softSurfer.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CrystalStacker.json",
-      "referenceNumber": 403,
-      "name": "CrystalStacker License",
-      "licenseId": "CrystalStacker",
+      "detailsUrl": "https://spdx.org/licenses/softSurfer.json",
+      "referenceNumber": 496,
+      "name": "softSurfer License",
+      "licenseId": "softSurfer",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing:CrystalStacker?rd\u003dLicensing/CrystalStacker"
+        "https://github.com/mm2/Little-CMS/blob/master/src/cmssm.c#L207",
+        "https://fedoraproject.org/wiki/Licensing/softSurfer"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/ECL-2.0.html",
+      "reference": "https://spdx.org/licenses/Soundex.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ECL-2.0.json",
-      "referenceNumber": 404,
-      "name": "Educational Community License v2.0",
-      "licenseId": "ECL-2.0",
+      "detailsUrl": "https://spdx.org/licenses/Soundex.json",
+      "referenceNumber": 1,
+      "name": "Soundex License",
+      "licenseId": "Soundex",
       "seeAlso": [
-        "https://opensource.org/licenses/ECL-2.0"
+        "https://metacpan.org/release/RJBS/Text-Soundex-3.05/source/Soundex.pm#L3-11"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LPPL-1.0.html",
+      "reference": "https://spdx.org/licenses/Spencer-86.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LPPL-1.0.json",
-      "referenceNumber": 405,
-      "name": "LaTeX Project Public License v1.0",
-      "licenseId": "LPPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/Spencer-86.json",
+      "referenceNumber": 257,
+      "name": "Spencer License 86",
+      "licenseId": "Spencer-86",
       "seeAlso": [
-        "http://www.latex-project.org/lppl/lppl-1-0.txt"
+        "https://fedoraproject.org/wiki/Licensing/Henry_Spencer_Reg-Ex_Library_License"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/iMatix.html",
+      "reference": "https://spdx.org/licenses/Spencer-94.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/iMatix.json",
-      "referenceNumber": 406,
-      "name": "iMatix Standard Function Library Agreement",
-      "licenseId": "iMatix",
+      "detailsUrl": "https://spdx.org/licenses/Spencer-94.json",
+      "referenceNumber": 228,
+      "name": "Spencer License 94",
+      "licenseId": "Spencer-94",
       "seeAlso": [
-        "http://legacy.imatix.com/html/sfl/sfl4.htm#license"
+        "https://fedoraproject.org/wiki/Licensing/Henry_Spencer_Reg-Ex_Library_License",
+        "https://metacpan.org/release/KNOK/File-MMagic-1.30/source/COPYING#L28"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-ND-3.0-IGO.html",
+      "reference": "https://spdx.org/licenses/Spencer-99.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-ND-3.0-IGO.json",
-      "referenceNumber": 407,
-      "name": "Creative Commons Attribution Non Commercial No Derivatives 3.0 IGO",
-      "licenseId": "CC-BY-NC-ND-3.0-IGO",
+      "detailsUrl": "https://spdx.org/licenses/Spencer-99.json",
+      "referenceNumber": 287,
+      "name": "Spencer License 99",
+      "licenseId": "Spencer-99",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-nd/3.0/igo/legalcode"
+        "http://www.opensource.apple.com/source/tcl/tcl-5/tcl/generic/regfronts.c"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-Source-Code.html",
+      "reference": "https://spdx.org/licenses/SPL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-Source-Code.json",
-      "referenceNumber": 408,
-      "name": "BSD Source Code Attribution",
-      "licenseId": "BSD-Source-Code",
+      "detailsUrl": "https://spdx.org/licenses/SPL-1.0.json",
+      "referenceNumber": 576,
+      "name": "Sun Public License v1.0",
+      "licenseId": "SPL-1.0",
       "seeAlso": [
-        "https://github.com/robbiehanson/CocoaHTTPServer/blob/master/LICENSE.txt"
+        "https://opensource.org/licenses/SPL-1.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Parity-6.0.0.html",
+      "reference": "https://spdx.org/licenses/ssh-keyscan.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Parity-6.0.0.json",
-      "referenceNumber": 409,
-      "name": "The Parity Public License 6.0.0",
-      "licenseId": "Parity-6.0.0",
+      "detailsUrl": "https://spdx.org/licenses/ssh-keyscan.json",
+      "referenceNumber": 78,
+      "name": "ssh-keyscan License",
+      "licenseId": "ssh-keyscan",
       "seeAlso": [
-        "https://paritylicense.com/versions/6.0.0.html"
+        "https://github.com/openssh/openssh-portable/blob/master/LICENCE#L82"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/TCL.html",
+      "reference": "https://spdx.org/licenses/SSH-OpenSSH.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/TCL.json",
-      "referenceNumber": 410,
-      "name": "TCL/TK License",
-      "licenseId": "TCL",
+      "detailsUrl": "https://spdx.org/licenses/SSH-OpenSSH.json",
+      "referenceNumber": 536,
+      "name": "SSH OpenSSH license",
+      "licenseId": "SSH-OpenSSH",
       "seeAlso": [
-        "http://www.tcl.tk/software/tcltk/license.html",
-        "https://fedoraproject.org/wiki/Licensing/TCL"
+        "https://github.com/openssh/openssh-portable/blob/1b11ea7c58cd5c59838b5fa574cd456d6047b2d4/LICENCE#L10"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Arphic-1999.html",
+      "reference": "https://spdx.org/licenses/SSH-short.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Arphic-1999.json",
-      "referenceNumber": 411,
-      "name": "Arphic Public License",
-      "licenseId": "Arphic-1999",
+      "detailsUrl": "https://spdx.org/licenses/SSH-short.json",
+      "referenceNumber": 438,
+      "name": "SSH short notice",
+      "licenseId": "SSH-short",
       "seeAlso": [
-        "http://ftp.gnu.org/gnu/non-gnu/chinese-fonts-truetype/LICENSE"
+        "https://github.com/openssh/openssh-portable/blob/1b11ea7c58cd5c59838b5fa574cd456d6047b2d4/pathnames.h",
+        "http://web.mit.edu/kolya/.f/root/athena.mit.edu/sipb.mit.edu/project/openssh/OldFiles/src/openssh-2.9.9p2/ssh-add.1",
+        "https://joinup.ec.europa.eu/svn/lesoll/trunk/italc/lib/src/dsa_key.cpp"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-SA-3.0.html",
+      "reference": "https://spdx.org/licenses/SSLeay-standalone.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-SA-3.0.json",
-      "referenceNumber": 412,
-      "name": "Creative Commons Attribution Share Alike 3.0 Unported",
-      "licenseId": "CC-BY-SA-3.0",
+      "detailsUrl": "https://spdx.org/licenses/SSLeay-standalone.json",
+      "referenceNumber": 421,
+      "name": "SSLeay License - standalone",
+      "licenseId": "SSLeay-standalone",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-sa/3.0/legalcode"
+        "https://www.tq-group.com/filedownloads/files/software-license-conditions/OriginalSSLeay/OriginalSSLeay.pdf"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Caldera.html",
+      "reference": "https://spdx.org/licenses/SSPL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Caldera.json",
-      "referenceNumber": 413,
-      "name": "Caldera License",
-      "licenseId": "Caldera",
+      "detailsUrl": "https://spdx.org/licenses/SSPL-1.0.json",
+      "referenceNumber": 295,
+      "name": "Server Side Public License, v 1",
+      "licenseId": "SSPL-1.0",
       "seeAlso": [
-        "http://www.lemis.com/grog/UNIX/ancient-source-all.pdf"
+        "https://www.mongodb.com/licensing/server-side-public-license"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/AGPL-1.0.html",
+      "reference": "https://spdx.org/licenses/StandardML-NJ.html",
       "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/AGPL-1.0.json",
-      "referenceNumber": 414,
-      "name": "Affero General Public License v1.0",
-      "licenseId": "AGPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/StandardML-NJ.json",
+      "referenceNumber": 201,
+      "name": "Standard ML of New Jersey License",
+      "licenseId": "StandardML-NJ",
       "seeAlso": [
-        "http://www.affero.org/oagpl.html"
+        "https://www.smlnj.org/license.html"
       ],
       "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/IPL-1.0.html",
+      "reference": "https://spdx.org/licenses/SugarCRM-1.1.3.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/IPL-1.0.json",
-      "referenceNumber": 415,
-      "name": "IBM Public License v1.0",
-      "licenseId": "IPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/SugarCRM-1.1.3.json",
+      "referenceNumber": 11,
+      "name": "SugarCRM Public License v1.1.3",
+      "licenseId": "SugarCRM-1.1.3",
       "seeAlso": [
-        "https://opensource.org/licenses/IPL-1.0"
+        "http://www.sugarcrm.com/crm/SPL"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LAL-1.3.html",
+      "reference": "https://spdx.org/licenses/Sun-PPP.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LAL-1.3.json",
-      "referenceNumber": 416,
-      "name": "Licence Art Libre 1.3",
-      "licenseId": "LAL-1.3",
+      "detailsUrl": "https://spdx.org/licenses/Sun-PPP.json",
+      "referenceNumber": 313,
+      "name": "Sun PPP License",
+      "licenseId": "Sun-PPP",
       "seeAlso": [
-        "https://artlibre.org/"
+        "https://github.com/ppp-project/ppp/blob/master/pppd/eap.c#L7-L16"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/EPICS.html",
+      "reference": "https://spdx.org/licenses/Sun-PPP-2000.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/EPICS.json",
-      "referenceNumber": 417,
-      "name": "EPICS Open License",
-      "licenseId": "EPICS",
+      "detailsUrl": "https://spdx.org/licenses/Sun-PPP-2000.json",
+      "referenceNumber": 489,
+      "name": "Sun PPP License (2000)",
+      "licenseId": "Sun-PPP-2000",
       "seeAlso": [
-        "https://epics.anl.gov/license/open.php"
+        "https://github.com/ppp-project/ppp/blob/master/modules/ppp_ahdlc.c#L7-L19"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/NGPL.html",
+      "reference": "https://spdx.org/licenses/SunPro.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NGPL.json",
-      "referenceNumber": 418,
-      "name": "Nethack General Public License",
-      "licenseId": "NGPL",
+      "detailsUrl": "https://spdx.org/licenses/SunPro.json",
+      "referenceNumber": 440,
+      "name": "SunPro License",
+      "licenseId": "SunPro",
       "seeAlso": [
-        "https://opensource.org/licenses/NGPL"
+        "https://github.com/freebsd/freebsd-src/blob/main/lib/msun/src/e_acosh.c",
+        "https://github.com/freebsd/freebsd-src/blob/main/lib/msun/src/e_lgammal.c"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/DRL-1.0.html",
+      "reference": "https://spdx.org/licenses/SWL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/DRL-1.0.json",
-      "referenceNumber": 419,
-      "name": "Detection Rule License 1.0",
-      "licenseId": "DRL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/SWL.json",
+      "referenceNumber": 331,
+      "name": "Scheme Widget Library (SWL) Software License Agreement",
+      "licenseId": "SWL",
       "seeAlso": [
-        "https://github.com/Neo23x0/sigma/blob/master/LICENSE.Detection.Rules.md"
+        "https://fedoraproject.org/wiki/Licensing/SWL"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-2-Clause-NetBSD.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/BSD-2-Clause-NetBSD.json",
-      "referenceNumber": 420,
-      "name": "BSD 2-Clause NetBSD License",
-      "licenseId": "BSD-2-Clause-NetBSD",
+      "reference": "https://spdx.org/licenses/swrule.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/swrule.json",
+      "referenceNumber": 206,
+      "name": "swrule License",
+      "licenseId": "swrule",
       "seeAlso": [
-        "http://www.netbsd.org/about/redistribution.html#default"
+        "https://ctan.math.utah.edu/ctan/tex-archive/macros/generic/misc/swrule.sty"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/ZPL-1.1.html",
+      "reference": "https://spdx.org/licenses/Symlinks.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ZPL-1.1.json",
-      "referenceNumber": 421,
-      "name": "Zope Public License 1.1",
-      "licenseId": "ZPL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/Symlinks.json",
+      "referenceNumber": 136,
+      "name": "Symlinks License",
+      "licenseId": "Symlinks",
       "seeAlso": [
-        "http://old.zope.org/Resources/License/ZPL-1.1"
+        "https://www.mail-archive.com/debian-bugs-rc@lists.debian.org/msg11494.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GD.html",
+      "reference": "https://spdx.org/licenses/TAPR-OHL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GD.json",
-      "referenceNumber": 422,
-      "name": "GD License",
-      "licenseId": "GD",
+      "detailsUrl": "https://spdx.org/licenses/TAPR-OHL-1.0.json",
+      "referenceNumber": 317,
+      "name": "TAPR Open Hardware License v1.0",
+      "licenseId": "TAPR-OHL-1.0",
       "seeAlso": [
-        "https://libgd.github.io/manuals/2.3.0/files/license-txt.html"
+        "https://www.tapr.org/OHL"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LPPL-1.2.html",
+      "reference": "https://spdx.org/licenses/TCL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LPPL-1.2.json",
-      "referenceNumber": 423,
-      "name": "LaTeX Project Public License v1.2",
-      "licenseId": "LPPL-1.2",
+      "detailsUrl": "https://spdx.org/licenses/TCL.json",
+      "referenceNumber": 644,
+      "name": "TCL/TK License",
+      "licenseId": "TCL",
       "seeAlso": [
-        "http://www.latex-project.org/lppl/lppl-1-2.txt"
+        "http://www.tcl.tk/software/tcltk/license.html",
+        "https://fedoraproject.org/wiki/Licensing/TCL"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Dotseqn.html",
+      "reference": "https://spdx.org/licenses/TCP-wrappers.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Dotseqn.json",
-      "referenceNumber": 424,
-      "name": "Dotseqn License",
-      "licenseId": "Dotseqn",
+      "detailsUrl": "https://spdx.org/licenses/TCP-wrappers.json",
+      "referenceNumber": 245,
+      "name": "TCP Wrappers License",
+      "licenseId": "TCP-wrappers",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Dotseqn"
+        "http://rc.quest.com/topics/openssh/license.php#tcpwrappers"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Spencer-99.html",
+      "reference": "https://spdx.org/licenses/TermReadKey.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Spencer-99.json",
-      "referenceNumber": 425,
-      "name": "Spencer License 99",
-      "licenseId": "Spencer-99",
+      "detailsUrl": "https://spdx.org/licenses/TermReadKey.json",
+      "referenceNumber": 37,
+      "name": "TermReadKey License",
+      "licenseId": "TermReadKey",
       "seeAlso": [
-        "http://www.opensource.apple.com/source/tcl/tcl-5/tcl/generic/regfronts.c"
+        "https://github.com/jonathanstowe/TermReadKey/blob/master/README#L9-L10"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-2.3.html",
+      "reference": "https://spdx.org/licenses/TGPPL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.3.json",
-      "referenceNumber": 426,
-      "name": "Open LDAP Public License v2.3",
-      "licenseId": "OLDAP-2.3",
+      "detailsUrl": "https://spdx.org/licenses/TGPPL-1.0.json",
+      "referenceNumber": 112,
+      "name": "Transitive Grace Period Public Licence 1.0",
+      "licenseId": "TGPPL-1.0",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003dd32cf54a32d581ab475d23c810b0a7fbaf8d63c3"
+        "https://fedoraproject.org/wiki/Licensing/TGPPL",
+        "https://tahoe-lafs.org/trac/tahoe-lafs/browser/trunk/COPYING.TGPPL.rst"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/YPL-1.1.html",
+      "reference": "https://spdx.org/licenses/threeparttable.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/YPL-1.1.json",
-      "referenceNumber": 427,
-      "name": "Yahoo! Public License v1.1",
-      "licenseId": "YPL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/threeparttable.json",
+      "referenceNumber": 319,
+      "name": "threeparttable License",
+      "licenseId": "threeparttable",
       "seeAlso": [
-        "http://www.zimbra.com/license/yahoo_public_license_1.1.html"
+        "https://fedoraproject.org/wiki/Licensing/Threeparttable"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Fair.html",
+      "reference": "https://spdx.org/licenses/TMate.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Fair.json",
-      "referenceNumber": 428,
-      "name": "Fair License",
-      "licenseId": "Fair",
+      "detailsUrl": "https://spdx.org/licenses/TMate.json",
+      "referenceNumber": 509,
+      "name": "TMate Open Source License",
+      "licenseId": "TMate",
       "seeAlso": [
-        "http://fairlicense.org/",
-        "https://opensource.org/licenses/Fair"
+        "http://svnkit.com/license.html"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Qhull.html",
+      "reference": "https://spdx.org/licenses/TORQUE-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Qhull.json",
-      "referenceNumber": 429,
-      "name": "Qhull License",
-      "licenseId": "Qhull",
+      "detailsUrl": "https://spdx.org/licenses/TORQUE-1.1.json",
+      "referenceNumber": 105,
+      "name": "TORQUE v2.5+ Software License v1.1",
+      "licenseId": "TORQUE-1.1",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Qhull"
+        "https://fedoraproject.org/wiki/Licensing/TORQUEv1.1"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.1-no-invariants-or-later.html",
+      "reference": "https://spdx.org/licenses/TOSL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.1-no-invariants-or-later.json",
-      "referenceNumber": 430,
-      "name": "GNU Free Documentation License v1.1 or later - no invariants",
-      "licenseId": "GFDL-1.1-no-invariants-or-later",
+      "detailsUrl": "https://spdx.org/licenses/TOSL.json",
+      "referenceNumber": 107,
+      "name": "Trusster Open Source License",
+      "licenseId": "TOSL",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/fdl-1.1.txt"
+        "https://fedoraproject.org/wiki/Licensing/TOSL"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CECILL-C.html",
+      "reference": "https://spdx.org/licenses/TPDL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CECILL-C.json",
-      "referenceNumber": 431,
-      "name": "CeCILL-C Free Software License Agreement",
-      "licenseId": "CECILL-C",
+      "detailsUrl": "https://spdx.org/licenses/TPDL.json",
+      "referenceNumber": 124,
+      "name": "Time::ParseDate License",
+      "licenseId": "TPDL",
       "seeAlso": [
-        "http://www.cecill.info/licences/Licence_CeCILL-C_V1-en.html"
+        "https://metacpan.org/pod/Time::ParseDate#LICENSE"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/MulanPSL-1.0.html",
+      "reference": "https://spdx.org/licenses/TPL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MulanPSL-1.0.json",
-      "referenceNumber": 432,
-      "name": "Mulan Permissive Software License, Version 1",
-      "licenseId": "MulanPSL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/TPL-1.0.json",
+      "referenceNumber": 490,
+      "name": "THOR Public License 1.0",
+      "licenseId": "TPL-1.0",
       "seeAlso": [
-        "https://license.coscl.org.cn/MulanPSL/",
-        "https://github.com/yuwenlong/longphp/blob/25dfb70cc2a466dc4bb55ba30901cbce08d164b5/LICENSE"
+        "https://fedoraproject.org/wiki/Licensing:ThorPublicLicense"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-1.1.html",
+      "reference": "https://spdx.org/licenses/TTWL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-1.1.json",
-      "referenceNumber": 433,
-      "name": "Open LDAP Public License v1.1",
-      "licenseId": "OLDAP-1.1",
+      "detailsUrl": "https://spdx.org/licenses/TTWL.json",
+      "referenceNumber": 35,
+      "name": "Text-Tabs+Wrap License",
+      "licenseId": "TTWL",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003d806557a5ad59804ef3a44d5abfbe91d706b0791f"
+        "https://fedoraproject.org/wiki/Licensing/TTWL",
+        "https://github.com/ap/Text-Tabs/blob/master/lib.modern/Text/Tabs.pm#L148"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-2.1.html",
+      "reference": "https://spdx.org/licenses/TTYP0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.1.json",
-      "referenceNumber": 434,
-      "name": "Open LDAP Public License v2.1",
-      "licenseId": "OLDAP-2.1",
+      "detailsUrl": "https://spdx.org/licenses/TTYP0.json",
+      "referenceNumber": 542,
+      "name": "TTYP0 License",
+      "licenseId": "TTYP0",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003db0d176738e96a0d3b9f85cb51e140a86f21be715"
+        "https://people.mpi-inf.mpg.de/~uwe/misc/uw-ttyp0/"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LPL-1.02.html",
+      "reference": "https://spdx.org/licenses/TU-Berlin-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LPL-1.02.json",
-      "referenceNumber": 435,
-      "name": "Lucent Public License v1.02",
-      "licenseId": "LPL-1.02",
+      "detailsUrl": "https://spdx.org/licenses/TU-Berlin-1.0.json",
+      "referenceNumber": 372,
+      "name": "Technische Universitaet Berlin License 1.0",
+      "licenseId": "TU-Berlin-1.0",
       "seeAlso": [
-        "http://plan9.bell-labs.com/plan9/license.html",
-        "https://opensource.org/licenses/LPL-1.02"
+        "https://github.com/swh/ladspa/blob/7bf6f3799fdba70fda297c2d8fd9f526803d9680/gsm/COPYRIGHT"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/UPL-1.0.html",
+      "reference": "https://spdx.org/licenses/TU-Berlin-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/UPL-1.0.json",
-      "referenceNumber": 436,
-      "name": "Universal Permissive License v1.0",
-      "licenseId": "UPL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/TU-Berlin-2.0.json",
+      "referenceNumber": 246,
+      "name": "Technische Universitaet Berlin License 2.0",
+      "licenseId": "TU-Berlin-2.0",
       "seeAlso": [
-        "https://opensource.org/licenses/UPL"
+        "https://github.com/CorsixTH/deps/blob/fd339a9f526d1d9c9f01ccf39e438a015da50035/licences/libgsm.txt"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Abstyles.html",
+      "reference": "https://spdx.org/licenses/Ubuntu-font-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Abstyles.json",
-      "referenceNumber": 437,
-      "name": "Abstyles License",
-      "licenseId": "Abstyles",
+      "detailsUrl": "https://spdx.org/licenses/Ubuntu-font-1.0.json",
+      "referenceNumber": 191,
+      "name": "Ubuntu Font Licence v1.0",
+      "licenseId": "Ubuntu-font-1.0",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Abstyles"
+        "https://ubuntu.com/legal/font-licence",
+        "https://assets.ubuntu.com/v1/81e5605d-ubuntu-font-licence-1.0.txt"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/ZPL-2.0.html",
+      "reference": "https://spdx.org/licenses/UCAR.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ZPL-2.0.json",
-      "referenceNumber": 438,
-      "name": "Zope Public License 2.0",
-      "licenseId": "ZPL-2.0",
+      "detailsUrl": "https://spdx.org/licenses/UCAR.json",
+      "referenceNumber": 452,
+      "name": "UCAR License",
+      "licenseId": "UCAR",
       "seeAlso": [
-        "http://old.zope.org/Resources/License/ZPL-2.0",
-        "https://opensource.org/licenses/ZPL-2.0"
+        "https://github.com/Unidata/UDUNITS-2/blob/master/COPYRIGHT"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/MIT-0.html",
+      "reference": "https://spdx.org/licenses/UCL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MIT-0.json",
-      "referenceNumber": 439,
-      "name": "MIT No Attribution",
-      "licenseId": "MIT-0",
+      "detailsUrl": "https://spdx.org/licenses/UCL-1.0.json",
+      "referenceNumber": 550,
+      "name": "Upstream Compatibility License v1.0",
+      "licenseId": "UCL-1.0",
       "seeAlso": [
-        "https://github.com/aws/mit-0",
-        "https://romanrm.net/mit-zero",
-        "https://github.com/awsdocs/aws-cloud9-user-guide/blob/master/LICENSE-SAMPLECODE"
+        "https://opensource.org/licenses/UCL-1.0"
       ],
       "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/LGPL-2.0-only.html",
+      "reference": "https://spdx.org/licenses/ulem.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LGPL-2.0-only.json",
-      "referenceNumber": 440,
-      "name": "GNU Library General Public License v2 only",
-      "licenseId": "LGPL-2.0-only",
+      "detailsUrl": "https://spdx.org/licenses/ulem.json",
+      "referenceNumber": 399,
+      "name": "ulem License",
+      "licenseId": "ulem",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/lgpl-2.0-standalone.html"
+        "https://mirrors.ctan.org/macros/latex/contrib/ulem/README"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.3-no-invariants-only.html",
+      "reference": "https://spdx.org/licenses/UMich-Merit.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.3-no-invariants-only.json",
-      "referenceNumber": 441,
-      "name": "GNU Free Documentation License v1.3 only - no invariants",
-      "licenseId": "GFDL-1.3-no-invariants-only",
+      "detailsUrl": "https://spdx.org/licenses/UMich-Merit.json",
+      "referenceNumber": 581,
+      "name": "Michigan/Merit Networks License",
+      "licenseId": "UMich-Merit",
       "seeAlso": [
-        "https://www.gnu.org/licenses/fdl-1.3.txt"
+        "https://github.com/radcli/radcli/blob/master/COPYRIGHT#L64"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/AGPL-3.0.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/AGPL-3.0.json",
-      "referenceNumber": 442,
-      "name": "GNU Affero General Public License v3.0",
-      "licenseId": "AGPL-3.0",
+      "reference": "https://spdx.org/licenses/Unicode-3.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Unicode-3.0.json",
+      "referenceNumber": 262,
+      "name": "Unicode License v3",
+      "licenseId": "Unicode-3.0",
       "seeAlso": [
-        "https://www.gnu.org/licenses/agpl.txt",
-        "https://opensource.org/licenses/AGPL-3.0"
+        "https://www.unicode.org/license.txt"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/EPL-2.0.html",
+      "reference": "https://spdx.org/licenses/Unicode-DFS-2015.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/EPL-2.0.json",
-      "referenceNumber": 443,
-      "name": "Eclipse Public License 2.0",
-      "licenseId": "EPL-2.0",
+      "detailsUrl": "https://spdx.org/licenses/Unicode-DFS-2015.json",
+      "referenceNumber": 328,
+      "name": "Unicode License Agreement - Data Files and Software (2015)",
+      "licenseId": "Unicode-DFS-2015",
       "seeAlso": [
-        "https://www.eclipse.org/legal/epl-2.0",
-        "https://www.opensource.org/licenses/EPL-2.0"
+        "https://web.archive.org/web/20151224134844/http://unicode.org/copyright.html"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/AFL-3.0.html",
+      "reference": "https://spdx.org/licenses/Unicode-DFS-2016.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/AFL-3.0.json",
-      "referenceNumber": 444,
-      "name": "Academic Free License v3.0",
-      "licenseId": "AFL-3.0",
+      "detailsUrl": "https://spdx.org/licenses/Unicode-DFS-2016.json",
+      "referenceNumber": 484,
+      "name": "Unicode License Agreement - Data Files and Software (2016)",
+      "licenseId": "Unicode-DFS-2016",
       "seeAlso": [
-        "http://www.rosenlaw.com/AFL3.0.htm",
-        "https://opensource.org/licenses/afl-3.0"
+        "https://www.unicode.org/license.txt",
+        "http://web.archive.org/web/20160823201924/http://www.unicode.org/copyright.html#License",
+        "http://www.unicode.org/copyright.html"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/CDLA-Permissive-1.0.html",
+      "reference": "https://spdx.org/licenses/Unicode-TOU.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CDLA-Permissive-1.0.json",
-      "referenceNumber": 445,
-      "name": "Community Data License Agreement Permissive 1.0",
-      "licenseId": "CDLA-Permissive-1.0",
+      "detailsUrl": "https://spdx.org/licenses/Unicode-TOU.json",
+      "referenceNumber": 628,
+      "name": "Unicode Terms of Use",
+      "licenseId": "Unicode-TOU",
       "seeAlso": [
-        "https://cdla.io/permissive-1-0"
+        "http://web.archive.org/web/20140704074106/http://www.unicode.org/copyright.html",
+        "http://www.unicode.org/copyright.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Artistic-1.0.html",
+      "reference": "https://spdx.org/licenses/UnixCrypt.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Artistic-1.0.json",
-      "referenceNumber": 446,
-      "name": "Artistic License 1.0",
-      "licenseId": "Artistic-1.0",
+      "detailsUrl": "https://spdx.org/licenses/UnixCrypt.json",
+      "referenceNumber": 95,
+      "name": "UnixCrypt License",
+      "licenseId": "UnixCrypt",
       "seeAlso": [
-        "https://opensource.org/licenses/Artistic-1.0"
+        "https://foss.heptapod.net/python-libs/passlib/-/blob/branch/stable/LICENSE#L70",
+        "https://opensource.apple.com/source/JBoss/JBoss-737/jboss-all/jetty/src/main/org/mortbay/util/UnixCrypt.java.auto.html",
+        "https://archive.eclipse.org/jetty/8.0.1.v20110908/xref/org/eclipse/jetty/http/security/UnixCrypt.html"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-NC-ND-4.0.html",
+      "reference": "https://spdx.org/licenses/Unlicense.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-NC-ND-4.0.json",
-      "referenceNumber": 447,
-      "name": "Creative Commons Attribution Non Commercial No Derivatives 4.0 International",
-      "licenseId": "CC-BY-NC-ND-4.0",
+      "detailsUrl": "https://spdx.org/licenses/Unlicense.json",
+      "referenceNumber": 218,
+      "name": "The Unlicense",
+      "licenseId": "Unlicense",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode"
+        "https://unlicense.org/"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/HTMLTIDY.html",
+      "reference": "https://spdx.org/licenses/UPL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/HTMLTIDY.json",
-      "referenceNumber": 448,
-      "name": "HTML Tidy License",
-      "licenseId": "HTMLTIDY",
+      "detailsUrl": "https://spdx.org/licenses/UPL-1.0.json",
+      "referenceNumber": 5,
+      "name": "Universal Permissive License v1.0",
+      "licenseId": "UPL-1.0",
       "seeAlso": [
-        "https://github.com/htacg/tidy-html5/blob/next/README/LICENSE.md"
+        "https://opensource.org/licenses/UPL"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Glide.html",
+      "reference": "https://spdx.org/licenses/URT-RLE.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Glide.json",
-      "referenceNumber": 449,
-      "name": "3dfx Glide License",
-      "licenseId": "Glide",
+      "detailsUrl": "https://spdx.org/licenses/URT-RLE.json",
+      "referenceNumber": 165,
+      "name": "Utah Raster Toolkit Run Length Encoded License",
+      "licenseId": "URT-RLE",
       "seeAlso": [
-        "http://www.users.on.net/~triforce/glidexp/COPYING.txt"
+        "https://sourceforge.net/p/netpbm/code/HEAD/tree/super_stable/converter/other/pnmtorle.c",
+        "https://sourceforge.net/p/netpbm/code/HEAD/tree/super_stable/converter/other/rletopnm.c"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/FSFAP.html",
+      "reference": "https://spdx.org/licenses/Vim.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/FSFAP.json",
-      "referenceNumber": 450,
-      "name": "FSF All Permissive License",
-      "licenseId": "FSFAP",
+      "detailsUrl": "https://spdx.org/licenses/Vim.json",
+      "referenceNumber": 549,
+      "name": "Vim License",
+      "licenseId": "Vim",
       "seeAlso": [
-        "https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html"
+        "http://vimdoc.sourceforge.net/htmldoc/uganda.html"
       ],
       "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/LGPLLR.html",
+      "reference": "https://spdx.org/licenses/VOSTROM.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/LGPLLR.json",
-      "referenceNumber": 451,
-      "name": "Lesser General Public License For Linguistic Resources",
-      "licenseId": "LGPLLR",
+      "detailsUrl": "https://spdx.org/licenses/VOSTROM.json",
+      "referenceNumber": 544,
+      "name": "VOSTROM Public License for Open Source",
+      "licenseId": "VOSTROM",
       "seeAlso": [
-        "http://www-igm.univ-mlv.fr/~unitex/lgpllr.html"
+        "https://fedoraproject.org/wiki/Licensing/VOSTROM"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OGL-UK-3.0.html",
+      "reference": "https://spdx.org/licenses/VSL-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OGL-UK-3.0.json",
-      "referenceNumber": 452,
-      "name": "Open Government Licence v3.0",
-      "licenseId": "OGL-UK-3.0",
+      "detailsUrl": "https://spdx.org/licenses/VSL-1.0.json",
+      "referenceNumber": 109,
+      "name": "Vovida Software License v1.0",
+      "licenseId": "VSL-1.0",
       "seeAlso": [
-        "http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/"
+        "https://opensource.org/licenses/VSL-1.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.2.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.2.json",
-      "referenceNumber": 453,
-      "name": "GNU Free Documentation License v1.2",
-      "licenseId": "GFDL-1.2",
+      "reference": "https://spdx.org/licenses/W3C.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/W3C.json",
+      "referenceNumber": 28,
+      "name": "W3C Software Notice and License (2002-12-31)",
+      "licenseId": "W3C",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/fdl-1.2.txt"
+        "http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231.html",
+        "https://opensource.org/licenses/W3C"
       ],
-      "isOsiApproved": false,
+      "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/SSH-OpenSSH.html",
+      "reference": "https://spdx.org/licenses/W3C-19980720.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SSH-OpenSSH.json",
-      "referenceNumber": 454,
-      "name": "SSH OpenSSH license",
-      "licenseId": "SSH-OpenSSH",
+      "detailsUrl": "https://spdx.org/licenses/W3C-19980720.json",
+      "referenceNumber": 629,
+      "name": "W3C Software Notice and License (1998-07-20)",
+      "licenseId": "W3C-19980720",
       "seeAlso": [
-        "https://github.com/openssh/openssh-portable/blob/1b11ea7c58cd5c59838b5fa574cd456d6047b2d4/LICENCE#L10"
+        "http://www.w3.org/Consortium/Legal/copyright-software-19980720.html"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.1-only.html",
+      "reference": "https://spdx.org/licenses/W3C-20150513.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.1-only.json",
-      "referenceNumber": 455,
-      "name": "GNU Free Documentation License v1.1 only",
-      "licenseId": "GFDL-1.1-only",
+      "detailsUrl": "https://spdx.org/licenses/W3C-20150513.json",
+      "referenceNumber": 315,
+      "name": "W3C Software Notice and Document License (2015-05-13)",
+      "licenseId": "W3C-20150513",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/fdl-1.1.txt"
+        "https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document",
+        "https://www.w3.org/copyright/software-license-2015/",
+        "https://www.w3.org/copyright/software-license-2023/"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/MIT-feh.html",
+      "reference": "https://spdx.org/licenses/w3m.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MIT-feh.json",
-      "referenceNumber": 456,
-      "name": "feh License",
-      "licenseId": "MIT-feh",
+      "detailsUrl": "https://spdx.org/licenses/w3m.json",
+      "referenceNumber": 379,
+      "name": "w3m License",
+      "licenseId": "w3m",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/MIT#feh"
+        "https://github.com/tats/w3m/blob/master/COPYING"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/MPL-1.0.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/MPL-1.0.json",
-      "referenceNumber": 457,
-      "name": "Mozilla Public License 1.0",
-      "licenseId": "MPL-1.0",
-      "seeAlso": [
-        "http://www.mozilla.org/MPL/MPL-1.0.html",
-        "https://opensource.org/licenses/MPL-1.0"
-      ],
-      "isOsiApproved": true
-    },
-    {
-      "reference": "https://spdx.org/licenses/PostgreSQL.html",
+      "reference": "https://spdx.org/licenses/Watcom-1.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/PostgreSQL.json",
-      "referenceNumber": 458,
-      "name": "PostgreSQL License",
-      "licenseId": "PostgreSQL",
+      "detailsUrl": "https://spdx.org/licenses/Watcom-1.0.json",
+      "referenceNumber": 612,
+      "name": "Sybase Open Watcom Public License 1.0",
+      "licenseId": "Watcom-1.0",
       "seeAlso": [
-        "http://www.postgresql.org/about/licence",
-        "https://opensource.org/licenses/PostgreSQL"
+        "https://opensource.org/licenses/Watcom-1.0"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": true,
+      "isFsfLibre": false
     },
     {
-      "reference": "https://spdx.org/licenses/OLDAP-2.2.2.html",
+      "reference": "https://spdx.org/licenses/Widget-Workshop.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OLDAP-2.2.2.json",
-      "referenceNumber": 459,
-      "name": "Open LDAP Public License 2.2.2",
-      "licenseId": "OLDAP-2.2.2",
+      "detailsUrl": "https://spdx.org/licenses/Widget-Workshop.json",
+      "referenceNumber": 256,
+      "name": "Widget Workshop License",
+      "licenseId": "Widget-Workshop",
       "seeAlso": [
-        "http://www.openldap.org/devel/gitweb.cgi?p\u003dopenldap.git;a\u003dblob;f\u003dLICENSE;hb\u003ddf2cc1e21eb7c160695f5b7cffd6296c151ba188"
+        "https://github.com/novnc/noVNC/blob/master/core/crypto/des.js#L24"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/SMPPL.html",
+      "reference": "https://spdx.org/licenses/Wsuipa.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/SMPPL.json",
-      "referenceNumber": 460,
-      "name": "Secure Messaging Protocol Public License",
-      "licenseId": "SMPPL",
+      "detailsUrl": "https://spdx.org/licenses/Wsuipa.json",
+      "referenceNumber": 199,
+      "name": "Wsuipa License",
+      "licenseId": "Wsuipa",
       "seeAlso": [
-        "https://github.com/dcblake/SMP/blob/master/Documentation/License.txt"
+        "https://fedoraproject.org/wiki/Licensing/Wsuipa"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OFL-1.1.html",
+      "reference": "https://spdx.org/licenses/WTFPL.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OFL-1.1.json",
-      "referenceNumber": 461,
-      "name": "SIL Open Font License 1.1",
-      "licenseId": "OFL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/WTFPL.json",
+      "referenceNumber": 173,
+      "name": "Do What The F*ck You Want To Public License",
+      "licenseId": "WTFPL",
       "seeAlso": [
-        "http://scripts.sil.org/cms/scripts/page.php?item_id\u003dOFL_web",
-        "https://opensource.org/licenses/OFL-1.1"
+        "http://www.wtfpl.net/about/",
+        "http://sam.zoy.org/wtfpl/COPYING"
       ],
-      "isOsiApproved": true,
+      "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Leptonica.html",
-      "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Leptonica.json",
-      "referenceNumber": 462,
-      "name": "Leptonica License",
-      "licenseId": "Leptonica",
+      "reference": "https://spdx.org/licenses/wxWindows.html",
+      "isDeprecatedLicenseId": true,
+      "detailsUrl": "https://spdx.org/licenses/wxWindows.json",
+      "referenceNumber": 350,
+      "name": "wxWindows Library License",
+      "licenseId": "wxWindows",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Leptonica"
+        "https://opensource.org/licenses/WXwindows"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/CERN-OHL-1.1.html",
+      "reference": "https://spdx.org/licenses/X11.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CERN-OHL-1.1.json",
-      "referenceNumber": 463,
-      "name": "CERN Open Hardware Licence v1.1",
-      "licenseId": "CERN-OHL-1.1",
+      "detailsUrl": "https://spdx.org/licenses/X11.json",
+      "referenceNumber": 274,
+      "name": "X11 License",
+      "licenseId": "X11",
       "seeAlso": [
-        "https://www.ohwr.org/project/licenses/wikis/cern-ohl-v1.1"
+        "http://www.xfree86.org/3.3.6/COPYRIGHT2.html#3"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-3-Clause-No-Nuclear-Warranty.html",
+      "reference": "https://spdx.org/licenses/X11-distribute-modifications-variant.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause-No-Nuclear-Warranty.json",
-      "referenceNumber": 464,
-      "name": "BSD 3-Clause No Nuclear Warranty",
-      "licenseId": "BSD-3-Clause-No-Nuclear-Warranty",
+      "detailsUrl": "https://spdx.org/licenses/X11-distribute-modifications-variant.json",
+      "referenceNumber": 286,
+      "name": "X11 License Distribution Modification Variant",
+      "licenseId": "X11-distribute-modifications-variant",
       "seeAlso": [
-        "https://jogamp.org/git/?p\u003dgluegen.git;a\u003dblob_plain;f\u003dLICENSE.txt"
+        "https://github.com/mirror/ncurses/blob/master/COPYING"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-ND-2.5.html",
+      "reference": "https://spdx.org/licenses/X11-swapped.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-ND-2.5.json",
-      "referenceNumber": 465,
-      "name": "Creative Commons Attribution No Derivatives 2.5 Generic",
-      "licenseId": "CC-BY-ND-2.5",
+      "detailsUrl": "https://spdx.org/licenses/X11-swapped.json",
+      "referenceNumber": 7,
+      "name": "X11 swapped final paragraphs",
+      "licenseId": "X11-swapped",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by-nd/2.5/legalcode"
+        "https://github.com/fedeinthemix/chez-srfi/blob/master/srfi/LICENSE"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": false
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/CC-BY-1.0.html",
+      "reference": "https://spdx.org/licenses/Xdebug-1.03.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/CC-BY-1.0.json",
-      "referenceNumber": 466,
-      "name": "Creative Commons Attribution 1.0 Generic",
-      "licenseId": "CC-BY-1.0",
+      "detailsUrl": "https://spdx.org/licenses/Xdebug-1.03.json",
+      "referenceNumber": 471,
+      "name": "Xdebug License v 1.03",
+      "licenseId": "Xdebug-1.03",
       "seeAlso": [
-        "https://creativecommons.org/licenses/by/1.0/legalcode"
+        "https://github.com/xdebug/xdebug/blob/master/LICENSE"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GFDL-1.2-only.html",
+      "reference": "https://spdx.org/licenses/Xerox.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/GFDL-1.2-only.json",
-      "referenceNumber": 467,
-      "name": "GNU Free Documentation License v1.2 only",
-      "licenseId": "GFDL-1.2-only",
+      "detailsUrl": "https://spdx.org/licenses/Xerox.json",
+      "referenceNumber": 417,
+      "name": "Xerox License",
+      "licenseId": "Xerox",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/fdl-1.2.txt"
+        "https://fedoraproject.org/wiki/Licensing/Xerox"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/OPUBL-1.0.html",
+      "reference": "https://spdx.org/licenses/Xfig.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/OPUBL-1.0.json",
-      "referenceNumber": 468,
-      "name": "Open Publication License v1.0",
-      "licenseId": "OPUBL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/Xfig.json",
+      "referenceNumber": 63,
+      "name": "Xfig License",
+      "licenseId": "Xfig",
       "seeAlso": [
-        "http://opencontent.org/openpub/",
-        "https://www.debian.org/opl",
-        "https://www.ctan.org/license/opl"
+        "https://github.com/Distrotech/transfig/blob/master/transfig/transfig.c",
+        "https://fedoraproject.org/wiki/Licensing:MIT#Xfig_Variant",
+        "https://sourceforge.net/p/mcj/xfig/ci/master/tree/src/Makefile.am"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/libselinux-1.0.html",
+      "reference": "https://spdx.org/licenses/XFree86-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/libselinux-1.0.json",
-      "referenceNumber": 469,
-      "name": "libselinux public domain notice",
-      "licenseId": "libselinux-1.0",
+      "detailsUrl": "https://spdx.org/licenses/XFree86-1.1.json",
+      "referenceNumber": 311,
+      "name": "XFree86 License 1.1",
+      "licenseId": "XFree86-1.1",
       "seeAlso": [
-        "https://github.com/SELinuxProject/selinux/blob/master/libselinux/LICENSE"
+        "http://www.xfree86.org/current/LICENSE4.html"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-3-Clause.html",
+      "reference": "https://spdx.org/licenses/xinetd.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-3-Clause.json",
-      "referenceNumber": 470,
-      "name": "BSD 3-Clause \"New\" or \"Revised\" License",
-      "licenseId": "BSD-3-Clause",
+      "detailsUrl": "https://spdx.org/licenses/xinetd.json",
+      "referenceNumber": 406,
+      "name": "xinetd License",
+      "licenseId": "xinetd",
       "seeAlso": [
-        "https://opensource.org/licenses/BSD-3-Clause"
+        "https://fedoraproject.org/wiki/Licensing/Xinetd_License"
       ],
-      "isOsiApproved": true,
+      "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/ANTLR-PD-fallback.html",
+      "reference": "https://spdx.org/licenses/xkeyboard-config-Zinoviev.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/ANTLR-PD-fallback.json",
-      "referenceNumber": 471,
-      "name": "ANTLR Software Rights Notice with license fallback",
-      "licenseId": "ANTLR-PD-fallback",
+      "detailsUrl": "https://spdx.org/licenses/xkeyboard-config-Zinoviev.json",
+      "referenceNumber": 55,
+      "name": "xkeyboard-config Zinoviev License",
+      "licenseId": "xkeyboard-config-Zinoviev",
       "seeAlso": [
-        "http://www.antlr2.org/license.html"
+        "https://gitlab.freedesktop.org/xkeyboard-config/xkeyboard-config/-/blob/master/COPYING?ref_type\u003dheads#L178"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/copyleft-next-0.3.1.html",
+      "reference": "https://spdx.org/licenses/xlock.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/copyleft-next-0.3.1.json",
-      "referenceNumber": 472,
-      "name": "copyleft-next 0.3.1",
-      "licenseId": "copyleft-next-0.3.1",
+      "detailsUrl": "https://spdx.org/licenses/xlock.json",
+      "referenceNumber": 140,
+      "name": "xlock License",
+      "licenseId": "xlock",
       "seeAlso": [
-        "https://github.com/copyleft-next/copyleft-next/blob/master/Releases/copyleft-next-0.3.1"
+        "https://fossies.org/linux/tiff/contrib/ras/ras2tif.c"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-1.0+.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GPL-1.0+.json",
-      "referenceNumber": 473,
-      "name": "GNU General Public License v1.0 or later",
-      "licenseId": "GPL-1.0+",
+      "reference": "https://spdx.org/licenses/Xnet.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Xnet.json",
+      "referenceNumber": 639,
+      "name": "X.Net License",
+      "licenseId": "Xnet",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/gpl-1.0-standalone.html"
+        "https://opensource.org/licenses/Xnet"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true
     },
     {
-      "reference": "https://spdx.org/licenses/wxWindows.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/wxWindows.json",
-      "referenceNumber": 474,
-      "name": "wxWindows Library License",
-      "licenseId": "wxWindows",
+      "reference": "https://spdx.org/licenses/xpp.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/xpp.json",
+      "referenceNumber": 243,
+      "name": "XPP License",
+      "licenseId": "xpp",
       "seeAlso": [
-        "https://opensource.org/licenses/WXwindows"
+        "https://fedoraproject.org/wiki/Licensing/xpp"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LGPL-3.0.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/LGPL-3.0.json",
-      "referenceNumber": 475,
-      "name": "GNU Lesser General Public License v3.0 only",
-      "licenseId": "LGPL-3.0",
+      "reference": "https://spdx.org/licenses/XSkat.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/XSkat.json",
+      "referenceNumber": 535,
+      "name": "XSkat License",
+      "licenseId": "XSkat",
       "seeAlso": [
-        "https://www.gnu.org/licenses/lgpl-3.0-standalone.html",
-        "https://www.gnu.org/licenses/lgpl+gpl-3.0.txt",
-        "https://opensource.org/licenses/LGPL-3.0"
+        "https://fedoraproject.org/wiki/Licensing/XSkat_License"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/LGPL-2.1.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/LGPL-2.1.json",
-      "referenceNumber": 476,
-      "name": "GNU Lesser General Public License v2.1 only",
-      "licenseId": "LGPL-2.1",
+      "reference": "https://spdx.org/licenses/xzoom.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/xzoom.json",
+      "referenceNumber": 339,
+      "name": "xzoom License",
+      "licenseId": "xzoom",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/lgpl-2.1-standalone.html",
-        "https://opensource.org/licenses/LGPL-2.1"
+        "https://metadata.ftp-master.debian.org/changelogs//main/x/xzoom/xzoom_0.3-27_copyright"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/StandardML-NJ.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/StandardML-NJ.json",
-      "referenceNumber": 477,
-      "name": "Standard ML of New Jersey License",
-      "licenseId": "StandardML-NJ",
+      "reference": "https://spdx.org/licenses/YPL-1.0.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/YPL-1.0.json",
+      "referenceNumber": 506,
+      "name": "Yahoo! Public License v1.0",
+      "licenseId": "YPL-1.0",
       "seeAlso": [
-        "http://www.smlnj.org//license.html"
+        "http://www.zimbra.com/license/yahoo_public_license_1.0.html"
       ],
-      "isOsiApproved": false,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-4-Clause.html",
+      "reference": "https://spdx.org/licenses/YPL-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-4-Clause.json",
-      "referenceNumber": 478,
-      "name": "BSD 4-Clause \"Original\" or \"Old\" License",
-      "licenseId": "BSD-4-Clause",
+      "detailsUrl": "https://spdx.org/licenses/YPL-1.1.json",
+      "referenceNumber": 538,
+      "name": "Yahoo! Public License v1.1",
+      "licenseId": "YPL-1.1",
       "seeAlso": [
-        "http://directory.fsf.org/wiki/License:BSD_4Clause"
+        "http://www.zimbra.com/license/yahoo_public_license_1.1.html"
       ],
       "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-2.0-with-bison-exception.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GPL-2.0-with-bison-exception.json",
-      "referenceNumber": 479,
-      "name": "GNU General Public License v2.0 w/Bison exception",
-      "licenseId": "GPL-2.0-with-bison-exception",
+      "reference": "https://spdx.org/licenses/Zed.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Zed.json",
+      "referenceNumber": 500,
+      "name": "Zed License",
+      "licenseId": "Zed",
       "seeAlso": [
-        "http://git.savannah.gnu.org/cgit/bison.git/tree/data/yacc.c?id\u003d193d7c7054ba7197b0789e14965b739162319b5e#n141"
+        "https://fedoraproject.org/wiki/Licensing/Zed"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Apache-2.0.html",
+      "reference": "https://spdx.org/licenses/Zeeff.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Apache-2.0.json",
-      "referenceNumber": 480,
-      "name": "Apache License 2.0",
-      "licenseId": "Apache-2.0",
+      "detailsUrl": "https://spdx.org/licenses/Zeeff.json",
+      "referenceNumber": 382,
+      "name": "Zeeff License",
+      "licenseId": "Zeeff",
       "seeAlso": [
-        "https://www.apache.org/licenses/LICENSE-2.0",
-        "https://opensource.org/licenses/Apache-2.0"
+        "ftp://ftp.tin.org/pub/news/utils/newsx/newsx-1.6.tar.gz"
       ],
-      "isOsiApproved": true,
-      "isFsfLibre": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Artistic-1.0-cl8.html",
+      "reference": "https://spdx.org/licenses/Zend-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Artistic-1.0-cl8.json",
-      "referenceNumber": 481,
-      "name": "Artistic License 1.0 w/clause 8",
-      "licenseId": "Artistic-1.0-cl8",
+      "detailsUrl": "https://spdx.org/licenses/Zend-2.0.json",
+      "referenceNumber": 51,
+      "name": "Zend License v2.0",
+      "licenseId": "Zend-2.0",
       "seeAlso": [
-        "https://opensource.org/licenses/Artistic-1.0"
+        "https://web.archive.org/web/20130517195954/http://www.zend.com/license/2_00.txt"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/GPL-2.0.html",
-      "isDeprecatedLicenseId": true,
-      "detailsUrl": "https://spdx.org/licenses/GPL-2.0.json",
-      "referenceNumber": 482,
-      "name": "GNU General Public License v2.0 only",
-      "licenseId": "GPL-2.0",
+      "reference": "https://spdx.org/licenses/Zimbra-1.3.html",
+      "isDeprecatedLicenseId": false,
+      "detailsUrl": "https://spdx.org/licenses/Zimbra-1.3.json",
+      "referenceNumber": 555,
+      "name": "Zimbra Public License v1.3",
+      "licenseId": "Zimbra-1.3",
       "seeAlso": [
-        "https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html",
-        "https://opensource.org/licenses/GPL-2.0"
+        "http://web.archive.org/web/20100302225219/http://www.zimbra.com/license/zimbra-public-license-1-3.html"
       ],
-      "isOsiApproved": true,
+      "isOsiApproved": false,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Intel-ACPI.html",
+      "reference": "https://spdx.org/licenses/Zimbra-1.4.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Intel-ACPI.json",
-      "referenceNumber": 483,
-      "name": "Intel ACPI Software License Agreement",
-      "licenseId": "Intel-ACPI",
+      "detailsUrl": "https://spdx.org/licenses/Zimbra-1.4.json",
+      "referenceNumber": 227,
+      "name": "Zimbra Public License v1.4",
+      "licenseId": "Zimbra-1.4",
       "seeAlso": [
-        "https://fedoraproject.org/wiki/Licensing/Intel_ACPI_Software_License_Agreement"
+        "http://www.zimbra.com/legal/zimbra-public-license-1-4"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BSL-1.0.html",
+      "reference": "https://spdx.org/licenses/Zlib.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSL-1.0.json",
-      "referenceNumber": 484,
-      "name": "Boost Software License 1.0",
-      "licenseId": "BSL-1.0",
+      "detailsUrl": "https://spdx.org/licenses/Zlib.json",
+      "referenceNumber": 74,
+      "name": "zlib License",
+      "licenseId": "Zlib",
       "seeAlso": [
-        "http://www.boost.org/LICENSE_1_0.txt",
-        "https://opensource.org/licenses/BSL-1.0"
+        "http://www.zlib.net/zlib_license.html",
+        "https://opensource.org/licenses/Zlib"
       ],
       "isOsiApproved": true,
       "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/Artistic-1.0-Perl.html",
+      "reference": "https://spdx.org/licenses/zlib-acknowledgement.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Artistic-1.0-Perl.json",
-      "referenceNumber": 485,
-      "name": "Artistic License 1.0 (Perl)",
-      "licenseId": "Artistic-1.0-Perl",
+      "detailsUrl": "https://spdx.org/licenses/zlib-acknowledgement.json",
+      "referenceNumber": 371,
+      "name": "zlib/libpng License with Acknowledgement",
+      "licenseId": "zlib-acknowledgement",
       "seeAlso": [
-        "http://dev.perl.org/licenses/artistic.html"
+        "https://fedoraproject.org/wiki/Licensing/ZlibWithAcknowledgement"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/BSD-2-Clause-Views.html",
+      "reference": "https://spdx.org/licenses/ZPL-1.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/BSD-2-Clause-Views.json",
-      "referenceNumber": 486,
-      "name": "BSD 2-Clause with views sentence",
-      "licenseId": "BSD-2-Clause-Views",
+      "detailsUrl": "https://spdx.org/licenses/ZPL-1.1.json",
+      "referenceNumber": 598,
+      "name": "Zope Public License 1.1",
+      "licenseId": "ZPL-1.1",
       "seeAlso": [
-        "http://www.freebsd.org/copyright/freebsd-license.html",
-        "https://people.freebsd.org/~ivoras/wine/patch-wine-nvidia.sh",
-        "https://github.com/protegeproject/protege/blob/master/license.txt"
+        "http://old.zope.org/Resources/License/ZPL-1.1"
       ],
       "isOsiApproved": false
     },
     {
-      "reference": "https://spdx.org/licenses/Interbase-1.0.html",
+      "reference": "https://spdx.org/licenses/ZPL-2.0.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/Interbase-1.0.json",
-      "referenceNumber": 487,
-      "name": "Interbase Public License v1.0",
-      "licenseId": "Interbase-1.0",
+      "detailsUrl": "https://spdx.org/licenses/ZPL-2.0.json",
+      "referenceNumber": 539,
+      "name": "Zope Public License 2.0",
+      "licenseId": "ZPL-2.0",
       "seeAlso": [
-        "https://web.archive.org/web/20060319014854/http://info.borland.com/devsupport/interbase/opensource/IPL.html"
+        "http://old.zope.org/Resources/License/ZPL-2.0",
+        "https://opensource.org/licenses/ZPL-2.0"
       ],
-      "isOsiApproved": false
+      "isOsiApproved": true,
+      "isFsfLibre": true
     },
     {
-      "reference": "https://spdx.org/licenses/NPOSL-3.0.html",
+      "reference": "https://spdx.org/licenses/ZPL-2.1.html",
       "isDeprecatedLicenseId": false,
-      "detailsUrl": "https://spdx.org/licenses/NPOSL-3.0.json",
-      "referenceNumber": 488,
-      "name": "Non-Profit Open Software License 3.0",
-      "licenseId": "NPOSL-3.0",
+      "detailsUrl": "https://spdx.org/licenses/ZPL-2.1.json",
+      "referenceNumber": 638,
+      "name": "Zope Public License 2.1",
+      "licenseId": "ZPL-2.1",
       "seeAlso": [
-        "https://opensource.org/licenses/NOSL3.0"
+        "http://old.zope.org/Resources/ZPL/"
       ],
-      "isOsiApproved": true
+      "isOsiApproved": true,
+      "isFsfLibre": true
     }
   ],
-  "releaseDate": "2022-05-08"
+  "releaseDate": "2024-08-19"
 }
\ No newline at end of file
diff --git a/Library/Homebrew/debrew.rb b/Library/Homebrew/debrew.rb
index 670446d3d2382..5679d2ccfbe49 100644
--- a/Library/Homebrew/debrew.rb
+++ b/Library/Homebrew/debrew.rb
@@ -1,13 +1,11 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "attrable"
 require "mutex_m"
-require "debrew/irb"
 require "ignorable"
 
 # Helper module for debugging formulae.
-#
-# @api private
 module Debrew
   extend Mutex_m
 
@@ -28,8 +26,6 @@ def test
 
   # Module for displaying a debugging menu.
   class Menu
-    extend T::Sig
-
     Entry = Struct.new(:name, :action)
 
     attr_accessor :prompt, :entries
@@ -47,7 +43,7 @@ def self.choose
       menu = new
       yield menu
 
-      choice = nil
+      choice = T.let(nil, T.nilable(Entry))
       while choice.nil?
         menu.entries.each_with_index { |e, i| puts "#{i + 1}. #{e.name}" }
         print menu.prompt unless menu.prompt.nil?
@@ -77,7 +73,7 @@ def self.choose
   @debugged_exceptions = Set.new
 
   class << self
-    extend Predicable
+    extend Attrable
     attr_predicate :active?
     attr_reader :debugged_exceptions
   end
@@ -90,7 +86,7 @@ def self.debrew
       yield
     rescue SystemExit
       raise
-    rescue Exception => e # rubocop:disable Lint/RescueException
+    rescue Ignorable::ExceptionMixin => e
       e.ignore if debug(e) == :ignore # execution jumps back to where the exception was thrown
     ensure
       Ignorable.unhook_raise
@@ -98,28 +94,31 @@ def self.debrew
     end
   end
 
-  def self.debug(e)
-    raise(e) if !active? || !debugged_exceptions.add?(e) || !try_lock
+  def self.debug(exception)
+    raise(exception) if !active? || !debugged_exceptions.add?(exception) || !mu_try_lock
 
     begin
-      puts e.backtrace.first.to_s
-      puts Formatter.error(e, label: e.class.name)
+      puts exception.backtrace.first
+      puts Formatter.error(exception, label: exception.class.name)
 
       loop do
         Menu.choose do |menu|
           menu.prompt = "Choose an action: "
 
-          menu.choice(:raise) { raise(e) }
-          menu.choice(:ignore) { return :ignore } if e.is_a?(Ignorable::ExceptionMixin)
-          menu.choice(:backtrace) { puts e.backtrace }
+          menu.choice(:raise) { raise(exception) }
+          menu.choice(:ignore) { return :ignore } if exception.is_a?(Ignorable::ExceptionMixin)
+          menu.choice(:backtrace) { puts exception.backtrace }
 
-          if e.is_a?(Ignorable::ExceptionMixin)
+          if exception.is_a?(Ignorable::ExceptionMixin)
             menu.choice(:irb) do
               puts "When you exit this IRB session, execution will continue."
               set_trace_func proc { |event, _, _, id, binding, klass|
                 if klass == Object && id == :raise && event == "return"
                   set_trace_func(nil)
-                  synchronize { IRB.start_within(binding) }
+                  mu_synchronize do
+                    require "debrew/irb"
+                    IRB.start_within(binding)
+                  end
                 end
               }
 
@@ -134,7 +133,7 @@ def self.debug(e)
         end
       end
     ensure
-      unlock
+      mu_unlock
     end
   end
 end
diff --git a/Library/Homebrew/debrew/irb.rb b/Library/Homebrew/debrew/irb.rb
index af3c358c9d3a4..a18f892225704 100644
--- a/Library/Homebrew/debrew/irb.rb
+++ b/Library/Homebrew/debrew/irb.rb
@@ -1,11 +1,13 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "irb"
 
-# @private
 module IRB
   def self.start_within(binding)
+    old_stdout_sync = $stdout.sync
+    $stdout.sync = true
+
     unless @setup_done
       setup(nil, argv: [])
       @setup_done = true
@@ -13,21 +15,8 @@ def self.start_within(binding)
 
     workspace = WorkSpace.new(binding)
     irb = Irb.new(workspace)
-
-    @CONF[:IRB_RC]&.call(irb.context)
-    @CONF[:MAIN_CONTEXT] = irb.context
-
-    prev_trap = trap("SIGINT") do
-      irb.signal_handle
-    end
-
-    begin
-      catch(:IRB_EXIT) do
-        irb.eval_input
-      end
-    ensure
-      trap("SIGINT", prev_trap)
-      irb_at_exit
-    end
+    irb.run(conf)
+  ensure
+    $stdout.sync = old_stdout_sync
   end
 end
diff --git a/Library/Homebrew/default_prefix.rb b/Library/Homebrew/default_prefix.rb
deleted file mode 100644
index b22f98268d75e..0000000000000
--- a/Library/Homebrew/default_prefix.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module Homebrew
-  DEFAULT_PREFIX, DEFAULT_REPOSITORY = if OS.mac? && Hardware::CPU.arm?
-    [HOMEBREW_MACOS_ARM_DEFAULT_PREFIX, HOMEBREW_MACOS_ARM_DEFAULT_REPOSITORY]
-  elsif OS.linux? && !EnvConfig.simulate_macos_on_linux?
-    [HOMEBREW_LINUX_DEFAULT_PREFIX, HOMEBREW_LINUX_DEFAULT_REPOSITORY]
-  else
-    [HOMEBREW_DEFAULT_PREFIX, HOMEBREW_DEFAULT_REPOSITORY]
-  end.freeze
-end
diff --git a/Library/Homebrew/dependable.rb b/Library/Homebrew/dependable.rb
index f9ebf7d74f102..f0d089491c3bc 100644
--- a/Library/Homebrew/dependable.rb
+++ b/Library/Homebrew/dependable.rb
@@ -1,15 +1,15 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "options"
 
 # Shared functions for classes which can be depended upon.
-#
-# @api private
 module Dependable
   # `:run` and `:linked` are no longer used but keep them here to avoid their
   # misuse in future.
-  RESERVED_TAGS = [:build, :optional, :recommended, :run, :test, :linked].freeze
+  RESERVED_TAGS = [:build, :optional, :recommended, :run, :test, :linked, :implicit].freeze
+
+  attr_reader :tags
 
   def build?
     tags.include? :build
@@ -27,6 +27,10 @@ def test?
     tags.include? :test
   end
 
+  def implicit?
+    tags.include? :implicit
+  end
+
   def required?
     !build? && !test? && !optional? && !recommended?
   end
@@ -40,7 +44,7 @@ def options
   end
 
   def prune_from_option?(build)
-    return if !optional? && !recommended?
+    return false if !optional? && !recommended?
 
     build.without?(self)
   end
diff --git a/Library/Homebrew/dependable.rbi b/Library/Homebrew/dependable.rbi
deleted file mode 100644
index c8eda0640b29f..0000000000000
--- a/Library/Homebrew/dependable.rbi
+++ /dev/null
@@ -1,5 +0,0 @@
-# typed: strict
-
-module Dependable
-  def tags; end
-end
diff --git a/Library/Homebrew/dependencies.rb b/Library/Homebrew/dependencies.rb
index b3a12d9bff71c..354b12745e2b8 100644
--- a/Library/Homebrew/dependencies.rb
+++ b/Library/Homebrew/dependencies.rb
@@ -1,15 +1,10 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "delegate"
-require "cask_dependent"
 
 # A collection of dependencies.
-#
-# @api private
 class Dependencies < SimpleDelegator
-  extend T::Sig
-
   def initialize(*args)
     super(args)
   end
@@ -17,55 +12,62 @@ def initialize(*args)
   alias eql? ==
 
   def optional
-    select(&:optional?)
+    __getobj__.select(&:optional?)
   end
 
   def recommended
-    select(&:recommended?)
+    __getobj__.select(&:recommended?)
   end
 
   def build
-    select(&:build?)
+    __getobj__.select(&:build?)
   end
 
   def required
-    select(&:required?)
+    __getobj__.select(&:required?)
   end
 
   def default
     build + required + recommended
   end
 
+  def dup_without_system_deps
+    self.class.new(*__getobj__.reject { |dep| dep.uses_from_macos? && dep.use_macos_install? })
+  end
+
   sig { returns(String) }
   def inspect
-    "#<#{self.class.name}: #{to_a}>"
+    "#<#{self.class.name}: #{__getobj__}>"
+  end
+
+  sig { returns(T::Array[Dependency]) }
+  def to_a
+    __getobj__.to_a
   end
 end
 
 # A collection of requirements.
-#
-# @api private
 class Requirements < SimpleDelegator
-  extend T::Sig
-
   def initialize(*args)
     super(Set.new(args))
   end
 
   def <<(other)
-    if other.is_a?(Comparable)
-      grep(other.class) do |req|
+    if other.is_a?(Object) && other.is_a?(Comparable)
+      __getobj__.grep(other.class) do |req|
         return self if req > other
 
-        delete(req)
+        __getobj__.delete(req)
       end
     end
+    # see https://sorbet.org/docs/faq#how-can-i-fix-type-errors-that-arise-from-super
+    T.bind(self, T.untyped)
     super
     self
   end
 
   sig { returns(String) }
   def inspect
-    "#<#{self.class.name}: {#{to_a.join(", ")}}>"
+    "#<#{self.class.name}: {#{__getobj__.to_a.join(", ")}}>"
   end
 end
diff --git a/Library/Homebrew/dependencies.rbi b/Library/Homebrew/dependencies.rbi
index 94819cec588db..ea20b01d7eff9 100644
--- a/Library/Homebrew/dependencies.rbi
+++ b/Library/Homebrew/dependencies.rbi
@@ -2,6 +2,10 @@
 
 class Dependencies < SimpleDelegator
   include Kernel
+  # This is a workaround to enable `alias eql? ==`
+  # @see https://github.com/sorbet/sorbet/issues/2378#issuecomment-569474238
+  sig { params(other: BasicObject).returns(T::Boolean) }
+  def ==(other); end
 end
 
 class Requirements < SimpleDelegator
diff --git a/Library/Homebrew/dependencies_helpers.rb b/Library/Homebrew/dependencies_helpers.rb
index 4d5f1a312a4d8..ab4241484159c 100644
--- a/Library/Homebrew/dependencies_helpers.rb
+++ b/Library/Homebrew/dependencies_helpers.rb
@@ -1,35 +1,23 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask_dependent"
 
 # Helper functions for dependencies.
-#
-# @api private
 module DependenciesHelpers
-  def args_includes_ignores(args)
-    includes = []
-    ignores = []
+  extend T::Helpers
 
-    if args.include_build?
-      includes << "build?"
-    else
-      ignores << "build?"
-    end
-
-    if args.include_test?
-      includes << "test?"
-    else
-      ignores << "test?"
-    end
+  requires_ancestor { Kernel }
 
-    if args.include_optional?
-      includes << "optional?"
-    else
-      ignores << "optional?"
-    end
+  def args_includes_ignores(args)
+    includes = [:required?, :recommended?] # included by default
+    includes << :build? if args.include_build?
+    includes << :test? if args.include_test?
+    includes << :optional? if args.include_optional?
 
-    ignores << "recommended?" if args.skip_recommended?
+    ignores = []
+    ignores << :recommended? if args.skip_recommended?
+    ignores << :satisfied? if args.missing?
 
     [includes, ignores]
   end
@@ -39,33 +27,26 @@ def recursive_includes(klass, root_dependent, includes, ignores)
 
     cache_key = "recursive_includes_#{includes}_#{ignores}"
 
-    klass.expand(root_dependent, cache_key: cache_key) do |dependent, dep|
-      if dep.recommended?
-        klass.prune if ignores.include?("recommended?") || dependent.build.without?(dep)
-      elsif dep.optional?
-        klass.prune if includes.exclude?("optional?") && !dependent.build.with?(dep)
-      elsif dep.build? || dep.test?
-        keep = false
-        keep ||= dep.test? && includes.include?("test?") && dependent == root_dependent
-        keep ||= dep.build? && includes.include?("build?")
-        klass.prune unless keep
+    klass.expand(root_dependent, cache_key:) do |dependent, dep|
+      klass.prune if ignores.any? { |ignore| dep.public_send(ignore) }
+      klass.prune if includes.none? do |include|
+        # Ignore indirect test dependencies
+        next if include == :test? && dependent != root_dependent
+
+        dep.public_send(include)
       end
 
       # If a tap isn't installed, we can't find the dependencies of one of
-      # its formulae, and an exception will be thrown if we try.
-      if klass == Dependency &&
-         dep.is_a?(TapDependency) &&
-         !dep.tap.installed?
-        Dependency.keep_but_prune_recursive_deps
-      end
+      # its formulae and an exception will be thrown if we try.
+      Dependency.keep_but_prune_recursive_deps if klass == Dependency && dep.tap && !dep.tap.installed?
     end
   end
 
-  def reject_ignores(dependables, ignores, includes)
-    dependables.reject do |dep|
-      next false unless ignores.any? { |ignore| dep.send(ignore) }
+  def select_includes(dependables, ignores, includes)
+    dependables.select do |dep|
+      next false if ignores.any? { |ignore| dep.public_send(ignore) }
 
-      includes.none? { |include| dep.send(include) }
+      includes.any? { |include| dep.public_send(include) }
     end
   end
 
diff --git a/Library/Homebrew/dependencies_helpers.rbi b/Library/Homebrew/dependencies_helpers.rbi
deleted file mode 100644
index f2226a40f4044..0000000000000
--- a/Library/Homebrew/dependencies_helpers.rbi
+++ /dev/null
@@ -1,5 +0,0 @@
-# typed: strict
-
-module DependenciesHelpers
-  include Kernel
-end
diff --git a/Library/Homebrew/dependency.rb b/Library/Homebrew/dependency.rb
index 41c88a8a892eb..7ab9abbafa20e 100644
--- a/Library/Homebrew/dependency.rb
+++ b/Library/Homebrew/dependency.rb
@@ -1,34 +1,30 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "dependable"
 
 # A dependency on another Homebrew formula.
 #
-# @api private
+# @api internal
 class Dependency
-  extend T::Sig
-
-  extend Forwardable
   include Dependable
   extend Cachable
 
-  attr_reader :name, :tags, :env_proc, :option_names
+  sig { returns(String) }
+  attr_reader :name
 
-  DEFAULT_ENV_PROC = proc {}.freeze
-  private_constant :DEFAULT_ENV_PROC
+  sig { returns(T.nilable(Tap)) }
+  attr_reader :tap
 
-  def initialize(name, tags = [], env_proc = DEFAULT_ENV_PROC, option_names = [name])
+  def initialize(name, tags = [])
     raise ArgumentError, "Dependency must have a name!" unless name
 
     @name = name
     @tags = tags
-    @env_proc = env_proc
-    @option_names = option_names
-  end
 
-  def to_s
-    name
+    return unless (tap_with_name = Tap.with_formula_name(name))
+
+    @tap, = tap_with_name
   end
 
   def ==(other)
@@ -41,17 +37,52 @@ def hash
   end
 
   def to_formula
-    formula = Formulary.factory(name)
+    formula = Formulary.factory(name, warn: false)
     formula.build = BuildOptions.new(options, formula.options)
     formula
   end
 
-  def installed?
-    to_formula.latest_version_installed?
+  sig { params(minimum_version: T.nilable(Version), minimum_revision: T.nilable(Integer)).returns(T::Boolean) }
+  def installed?(minimum_version: nil, minimum_revision: nil)
+    formula = begin
+      to_formula
+    rescue FormulaUnavailableError
+      nil
+    end
+    return false unless formula
+
+    return true if formula.latest_version_installed?
+
+    return false if minimum_version.blank?
+
+    # If the opt prefix doesn't exist: we likely have an incomplete installation.
+    return false unless formula.opt_prefix.exist?
+
+    installed_keg = formula.any_installed_keg
+    return false unless installed_keg
+
+    # If the keg name doesn't match, we may have moved from an alias to a full formula and need to upgrade.
+    return false unless formula.possible_names.include?(installed_keg.name)
+
+    installed_version = installed_keg.version
+
+    # Tabs prior to 4.1.18 did not have revision or pkg_version fields.
+    # As a result, we have to be more conversative when we do not have
+    # a minimum revision from the tab and assume that if the formula has a
+    # the same version and a non-zero revision that it needs upgraded.
+    if minimum_revision.present?
+      minimum_pkg_version = PkgVersion.new(minimum_version, minimum_revision)
+      installed_version >= minimum_pkg_version
+    elsif installed_version.version == minimum_version
+      formula.revision.zero?
+    else
+      installed_version.version > minimum_version
+    end
   end
 
-  def satisfied?(inherited_options)
-    installed? && missing_options(inherited_options).empty?
+  def satisfied?(inherited_options = [], minimum_version: nil, minimum_revision: nil)
+    installed?(minimum_version:, minimum_revision:) &&
+      missing_options(inherited_options).empty?
   end
 
   def missing_options(inherited_options)
@@ -63,32 +94,36 @@ def missing_options(inherited_options)
     required
   end
 
-  def modify_build_environment
-    env_proc&.call
+  def option_names
+    [name.split("/").last].freeze
+  end
+
+  sig { overridable.returns(T::Boolean) }
+  def uses_from_macos?
+    false
   end
 
+  sig { returns(String) }
+  def to_s = name
+
   sig { returns(String) }
   def inspect
     "#<#{self.class.name}: #{name.inspect} #{tags.inspect}>"
   end
 
-  # Define marshaling semantics because we cannot serialize @env_proc.
-  def _dump(*)
-    Marshal.dump([name, tags])
-  end
-
-  def self._load(marshaled)
-    new(*Marshal.load(marshaled)) # rubocop:disable Security/MarshalLoad
+  sig { params(formula: Formula).returns(T.self_type) }
+  def dup_with_formula_name(formula)
+    self.class.new(formula.full_name.to_s, tags)
   end
 
   class << self
-    extend T::Sig
-
     # Expand the dependencies of each dependent recursively, optionally yielding
     # `[dependent, dep]` pairs to allow callers to apply arbitrary filters to
     # the list.
     # The default filter, which is applied when a block is not given, omits
-    # optionals and recommendeds based on what the dependent has asked for
+    # optionals and recommends based on what the dependent has asked for
+    #
+    # @api internal
     def expand(dependent, deps = dependent.deps, cache_key: nil, &block)
       # Keep track dependencies to avoid infinite cyclic dependency recursion.
       @expand_stack ||= []
@@ -110,13 +145,17 @@ def expand(dependent, deps = dependent.deps, cache_key: nil, &block)
         when :skip
           next if @expand_stack.include? dep.name
 
-          expanded_deps.concat(expand(dep.to_formula, cache_key: cache_key, &block))
+          expanded_deps.concat(expand(dep.to_formula, cache_key:, &block))
         when :keep_but_prune_recursive_deps
           expanded_deps << dep
         else
           next if @expand_stack.include? dep.name
 
-          expanded_deps.concat(expand(dep.to_formula, cache_key: cache_key, &block))
+          dep_formula = dep.to_formula
+          expanded_deps.concat(expand(dep_formula, cache_key:, &block))
+
+          # Fixes names for renamed/aliased formulae.
+          dep = dep.dup_with_formula_name(dep_formula)
           expanded_deps << dep
         end
       end
@@ -151,6 +190,8 @@ def skip
     end
 
     # Keep a dependency, but prune its dependencies.
+    #
+    # @api internal
     sig { void }
     def keep_but_prune_recursive_deps
       throw(:action, :keep_but_prune_recursive_deps)
@@ -163,8 +204,9 @@ def merge_repeats(all)
         deps = grouped.fetch(name)
         dep  = deps.first
         tags = merge_tags(deps)
-        option_names = deps.flat_map(&:option_names).uniq
-        dep.class.new(name, tags, dep.env_proc, option_names)
+        kwargs = {}
+        kwargs[:bounds] = dep.bounds if dep.uses_from_macos?
+        dep.class.new(name, tags, **kwargs)
       end
     end
 
@@ -192,26 +234,67 @@ def merge_necessity(deps)
     end
 
     def merge_temporality(deps)
-      # Means both build and runtime dependency.
-      return [] unless deps.all?(&:build?)
-
-      [:build]
+      new_tags = []
+      new_tags << :build if deps.all?(&:build?)
+      new_tags << :implicit if deps.all?(&:implicit?)
+      new_tags
     end
   end
 end
 
-# A dependency on another Homebrew formula in a specific tap.
-class TapDependency < Dependency
-  attr_reader :tap
+# A dependency that's marked as "installed" on macOS
+class UsesFromMacOSDependency < Dependency
+  attr_reader :bounds
+
+  sig { params(name: String, tags: T::Array[Symbol], bounds: T::Hash[Symbol, Symbol]).void }
+  def initialize(name, tags = [], bounds:)
+    super(name, tags)
+
+    @bounds = bounds
+  end
+
+  def ==(other)
+    instance_of?(other.class) && name == other.name && tags == other.tags && bounds == other.bounds
+  end
+
+  def hash
+    [name, tags, bounds].hash
+  end
 
-  def initialize(name, tags = [], env_proc = DEFAULT_ENV_PROC, option_names = [name.split("/").last])
-    @tap = Tap.fetch(name.rpartition("/").first)
-    super(name, tags, env_proc, option_names)
+  sig { params(minimum_version: T.nilable(Version), minimum_revision: T.nilable(Integer)).returns(T::Boolean) }
+  def installed?(minimum_version: nil, minimum_revision: nil)
+    use_macos_install? || super
   end
 
-  def installed?
-    super
-  rescue FormulaUnavailableError
+  sig { returns(T::Boolean) }
+  def use_macos_install?
+    # Check whether macOS is new enough for dependency to not be required.
+    if Homebrew::SimulateSystem.simulating_or_running_on_macos?
+      # Assume the oldest macOS version when simulating a generic macOS version
+      return true if Homebrew::SimulateSystem.current_os == :macos && !bounds.key?(:since)
+
+      if Homebrew::SimulateSystem.current_os != :macos
+        current_os = MacOSVersion.from_symbol(Homebrew::SimulateSystem.current_os)
+        since_os = MacOSVersion.from_symbol(bounds[:since]) if bounds.key?(:since)
+        return true if current_os >= since_os
+      end
+    end
+
     false
   end
+
+  sig { override.returns(T::Boolean) }
+  def uses_from_macos?
+    true
+  end
+
+  sig { override.params(formula: Formula).returns(T.self_type) }
+  def dup_with_formula_name(formula)
+    self.class.new(formula.full_name.to_s, tags, bounds:)
+  end
+
+  sig { returns(String) }
+  def inspect
+    "#<#{self.class.name}: #{name.inspect} #{tags.inspect} #{bounds.inspect}>"
+  end
 end
diff --git a/Library/Homebrew/dependency_collector.rb b/Library/Homebrew/dependency_collector.rb
index aee6fb15ab231..50dc74434fa35 100644
--- a/Library/Homebrew/dependency_collector.rb
+++ b/Library/Homebrew/dependency_collector.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "dependency"
@@ -7,35 +7,55 @@
 require "requirements"
 require "extend/cachable"
 
-## A dependency is a formula that another formula needs to install.
-## A requirement is something other than a formula that another formula
-## needs to be present. This includes external language modules,
-## command-line tools in the path, or any arbitrary predicate.
-##
-## The `depends_on` method in the formula DSL is used to declare
-## dependencies and requirements.
+# A dependency is a formula that another formula needs to install.
+# A requirement is something other than a formula that another formula
+# needs to be present. This includes external language modules,
+# command-line tools in the path, or any arbitrary predicate.
+#
+# The `depends_on` method in the formula DSL is used to declare
+# dependencies and requirements.
 
 # This class is used by `depends_on` in the formula DSL to turn dependency
 # specifications into the proper kinds of dependencies and requirements.
 class DependencyCollector
-  extend T::Sig
-
   extend Cachable
 
   attr_reader :deps, :requirements
 
   sig { void }
   def initialize
+    # Ensure this is synced with `initialize_dup` and `freeze` (excluding simple objects like integers and booleans)
     @deps = Dependencies.new
     @requirements = Requirements.new
+
+    init_global_dep_tree_if_needed!
+  end
+
+  def initialize_dup(other)
+    super
+    @deps = @deps.dup
+    @requirements = @requirements.dup
+  end
+
+  def freeze
+    @deps.freeze
+    @requirements.freeze
+    super
   end
 
   def add(spec)
     case dep = fetch(spec)
+    when Array
+      dep.compact.each { |dep| @deps << dep }
     when Dependency
       @deps << dep
     when Requirement
       @requirements << dep
+    when nil
+      # no-op when we have a nil value
+      nil
+    else
+      raise ArgumentError, "DependencyCollector#add passed something that isn't a Dependency or Requirement!"
     end
     dep
   end
@@ -45,11 +65,14 @@ def fetch(spec)
   end
 
   def cache_key(spec)
-    if spec.is_a?(Resource) && spec.download_strategy <= CurlDownloadStrategy
-      File.extname(spec.url)
-    else
-      spec
+    if spec.is_a?(Resource)
+      if spec.download_strategy <= CurlDownloadStrategy
+        return "#{spec.download_strategy}#{File.extname(spec.url).split("?").first}"
+      end
+
+      return spec.download_strategy
     end
+    spec
   end
 
   def build(spec)
@@ -57,40 +80,48 @@ def build(spec)
     parse_spec(spec, Array(tags))
   end
 
+  sig { params(related_formula_names: T::Array[String]).returns(T.nilable(Dependency)) }
+  def gcc_dep_if_needed(related_formula_names); end
+
+  sig { params(related_formula_names: T::Array[String]).returns(T.nilable(Dependency)) }
+  def glibc_dep_if_needed(related_formula_names); end
+
   def git_dep_if_needed(tags)
+    require "utils/git"
     return if Utils::Git.available?
 
-    Dependency.new("git", tags)
+    Dependency.new("git", [*tags, :implicit])
   end
 
-  def brewed_curl_dep_if_needed(tags)
-    Dependency.new("curl", tags)
+  def curl_dep_if_needed(tags)
+    Dependency.new("curl", [*tags, :implicit])
   end
 
   def subversion_dep_if_needed(tags)
+    require "utils/svn"
     return if Utils::Svn.available?
 
-    Dependency.new("subversion", tags)
+    Dependency.new("subversion", [*tags, :implicit])
   end
 
   def cvs_dep_if_needed(tags)
-    Dependency.new("cvs", tags) unless which("cvs")
+    Dependency.new("cvs", [*tags, :implicit]) unless which("cvs")
   end
 
   def xz_dep_if_needed(tags)
-    Dependency.new("xz", tags) unless which("xz")
+    Dependency.new("xz", [*tags, :implicit]) unless which("xz")
   end
 
   def zstd_dep_if_needed(tags)
-    Dependency.new("zstd", tags) unless which("zstd")
+    Dependency.new("zstd", [*tags, :implicit]) unless which("zstd")
   end
 
   def unzip_dep_if_needed(tags)
-    Dependency.new("unzip", tags) unless which("unzip")
+    Dependency.new("unzip", [*tags, :implicit]) unless which("unzip")
   end
 
   def bzip2_dep_if_needed(tags)
-    Dependency.new("bzip2", tags) unless which("bzip2")
+    Dependency.new("bzip2", [*tags, :implicit]) unless which("bzip2")
   end
 
   def self.tar_needs_xz_dependency?
@@ -99,7 +130,16 @@ def self.tar_needs_xz_dependency?
 
   private
 
+  sig { void }
+  def init_global_dep_tree_if_needed!; end
+
+  sig {
+    params(spec: T.any(String, Resource, Symbol, Requirement, Dependency, Class),
+           tags: T::Array[Symbol]).returns(T.any(Dependency, Requirement, Array, NilClass))
+  }
   def parse_spec(spec, tags)
+    raise ArgumentError, "Implicit dependencies cannot be manually specified" if tags.include?(:implicit)
+
     case spec
     when String
       parse_string_spec(spec, tags)
@@ -111,20 +151,16 @@ def parse_spec(spec, tags)
       spec
     when Class
       parse_class_spec(spec, tags)
-    else
-      raise TypeError, "Unsupported type #{spec.class.name} for #{spec.inspect}"
     end
   end
 
   def parse_string_spec(spec, tags)
-    if spec.match?(HOMEBREW_TAP_FORMULA_REGEX)
-      TapDependency.new(spec, tags)
-    else
-      Dependency.new(spec, tags)
-    end
+    Dependency.new(spec, tags)
   end
 
   def parse_symbol_spec(spec, tags)
+    # When modifying this list of supported requirements, consider
+    # whether `Formulary::API_SUPPORTED_REQUIREMENTS` should also be changed.
     case spec
     when :arch          then ArchRequirement.new(tags)
     when :codesign      then CodesignRequirement.new(tags)
@@ -148,8 +184,9 @@ def resource_dep(spec, tags)
     strategy = spec.download_strategy
 
     if strategy <= HomebrewCurlDownloadStrategy
-      @deps << brewed_curl_dep_if_needed(tags)
-      parse_url_spec(spec.url, tags)
+      [curl_dep_if_needed(tags), parse_url_spec(spec.url, tags)]
+    elsif strategy <= NoUnzipCurlDownloadStrategy
+      # ensure NoUnzip never adds any dependencies
     elsif strategy <= CurlDownloadStrategy
       parse_url_spec(spec.url, tags)
     elsif strategy <= GitDownloadStrategy
@@ -157,18 +194,17 @@ def resource_dep(spec, tags)
     elsif strategy <= SubversionDownloadStrategy
       subversion_dep_if_needed(tags)
     elsif strategy <= MercurialDownloadStrategy
-      Dependency.new("mercurial", tags)
+      Dependency.new("mercurial", [*tags, :implicit])
     elsif strategy <= FossilDownloadStrategy
-      Dependency.new("fossil", tags)
+      Dependency.new("fossil", [*tags, :implicit])
     elsif strategy <= BazaarDownloadStrategy
-      Dependency.new("bazaar", tags)
+      Dependency.new("breezy", [*tags, :implicit])
     elsif strategy <= CVSDownloadStrategy
       cvs_dep_if_needed(tags)
     elsif strategy < AbstractDownloadStrategy
       # allow unknown strategies to pass through
     else
-      raise TypeError,
-            "#{strategy.inspect} is not an AbstractDownloadStrategy subclass"
+      raise TypeError, "#{strategy.inspect} is not an AbstractDownloadStrategy subclass"
     end
   end
 
@@ -178,10 +214,10 @@ def parse_url_spec(url, tags)
     when ".zst"         then zstd_dep_if_needed(tags)
     when ".zip"         then unzip_dep_if_needed(tags)
     when ".bz2"         then bzip2_dep_if_needed(tags)
-    when ".lha", ".lzh" then Dependency.new("lha", tags)
-    when ".lz"          then Dependency.new("lzip", tags)
-    when ".rar"         then Dependency.new("unrar", tags)
-    when ".7z"          then Dependency.new("p7zip", tags)
+    when ".lha", ".lzh" then Dependency.new("lha", [*tags, :implicit])
+    when ".lz"          then Dependency.new("lzip", [*tags, :implicit])
+    when ".rar"         then Dependency.new("libarchive", [*tags, :implicit])
+    when ".7z"          then Dependency.new("p7zip", [*tags, :implicit])
     end
   end
 end
diff --git a/Library/Homebrew/deprecate_disable.rb b/Library/Homebrew/deprecate_disable.rb
index 2b31d467a7627..c83f26ee74c3b 100644
--- a/Library/Homebrew/deprecate_disable.rb
+++ b/Library/Homebrew/deprecate_disable.rb
@@ -1,13 +1,12 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 # Helper module for handling `disable!` and `deprecate!`.
-#
-# @api private
+# @api internal
 module DeprecateDisable
   module_function
 
-  DEPRECATE_DISABLE_REASONS = {
+  FORMULA_DEPRECATE_DISABLE_REASONS = {
     does_not_build:      "does not build",
     no_license:          "has no license",
     repo_archived:       "has an archived upstream repository",
@@ -22,19 +21,69 @@ module DeprecateDisable
                          "We can re-package this once upstream has confirmed that they retagged their release",
   }.freeze
 
-  def deprecate_disable_info(formula)
-    if formula.deprecated?
-      type = :deprecated
-      reason = formula.deprecation_reason
-    elsif formula.disabled?
-      type = :disabled
-      reason = formula.disable_reason
+  CASK_DEPRECATE_DISABLE_REASONS = {
+    discontinued:             "is discontinued upstream",
+    moved_to_mas:             "is now exclusively distributed on the Mac App Store",
+    no_longer_available:      "is no longer available upstream",
+    no_longer_meets_criteria: "no longer meets the criteria for acceptable casks",
+    unmaintained:             "is not maintained upstream",
+    unsigned:                 "is unsigned or does not meet signature requirements",
+  }.freeze
+
+  # One year when << or >> to Date.today.
+  REMOVE_DISABLED_TIME_WINDOW = 12
+  REMOVE_DISABLED_BEFORE = (Date.today << REMOVE_DISABLED_TIME_WINDOW).freeze
+
+  def type(formula_or_cask)
+    return :deprecated if formula_or_cask.deprecated?
+
+    :disabled if formula_or_cask.disabled?
+  end
+
+  def message(formula_or_cask)
+    return if type(formula_or_cask).blank?
+
+    reason = if formula_or_cask.deprecated?
+      formula_or_cask.deprecation_reason
+    elsif formula_or_cask.disabled?
+      formula_or_cask.disable_reason
+    end
+
+    reason = if formula_or_cask.is_a?(Formula) && FORMULA_DEPRECATE_DISABLE_REASONS.key?(reason)
+      FORMULA_DEPRECATE_DISABLE_REASONS[reason]
+    elsif formula_or_cask.is_a?(Cask::Cask) && CASK_DEPRECATE_DISABLE_REASONS.key?(reason)
+      CASK_DEPRECATE_DISABLE_REASONS[reason]
     else
-      return
+      reason
     end
 
-    reason = DEPRECATE_DISABLE_REASONS[reason] if DEPRECATE_DISABLE_REASONS.key? reason
+    message = if reason.present?
+      "#{type(formula_or_cask)} because it #{reason}!"
+    else
+      "#{type(formula_or_cask)}!"
+    end
+
+    disable_date = formula_or_cask.disable_date
+    if !disable_date && formula_or_cask.deprecation_date
+      disable_date = formula_or_cask.deprecation_date >> REMOVE_DISABLED_TIME_WINDOW
+    end
+    if disable_date
+      message += if disable_date < Date.today
+        " It was disabled on #{disable_date}."
+      else
+        " It will be disabled on #{disable_date}."
+      end
+    end
+
+    message
+  end
+
+  def to_reason_string_or_symbol(string, type:)
+    if (type == :formula && FORMULA_DEPRECATE_DISABLE_REASONS.key?(string&.to_sym)) ||
+       (type == :cask && CASK_DEPRECATE_DISABLE_REASONS.key?(string&.to_sym))
+      return string.to_sym
+    end
 
-    [type, reason]
+    string
   end
 end
diff --git a/Library/Homebrew/description_cache_store.rb b/Library/Homebrew/description_cache_store.rb
index d94885cbe3f67..4804a2bfea314 100644
--- a/Library/Homebrew/description_cache_store.rb
+++ b/Library/Homebrew/description_cache_store.rb
@@ -1,17 +1,13 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "set"
 require "cache_store"
-require "searchable"
 
 #
 # {DescriptionCacheStore} provides methods to fetch and mutate formula descriptions used
 # by the `brew desc` and `brew search` commands.
 #
 class DescriptionCacheStore < CacheStore
-  include Searchable
-
   # Inserts a formula description into the cache if it does not exist or
   # updates the formula description if it does exist.
   #
@@ -33,11 +29,11 @@ def delete!(formula_name)
   # If the database is empty `update!` it with all known formulae.
   #
   # @return [nil]
-  def populate_if_empty!
+  def populate_if_empty!(eval_all: Homebrew::EnvConfig.eval_all?)
+    return unless eval_all
     return unless database.empty?
 
-    # TODO: 3.6.0: consider if we want to actually read all contents of all formulae or odeprecate.
-    Formula.all.each { |f| update!(f.full_name, f.desc) }
+    Formula.all(eval_all:).each { |f| update!(f.full_name, f.desc) }
   end
 
   # Use an update report to update the {DescriptionCacheStore}.
@@ -45,6 +41,10 @@ def populate_if_empty!
   # @param report [Report] an update report generated by cmd/update.rb
   # @return [nil]
   def update_from_report!(report)
+    unless Homebrew::EnvConfig.eval_all?
+      database.clear!
+      return
+    end
     return populate_if_empty! if database.empty?
     return if report.empty?
 
@@ -63,6 +63,10 @@ def update_from_report!(report)
   # @param formula_names [Array] the formulae to update
   # @return [nil]
   def update_from_formula_names!(formula_names)
+    unless Homebrew::EnvConfig.eval_all?
+      database.clear!
+      return
+    end
     return populate_if_empty! if database.empty?
 
     formula_names.each do |name|
@@ -83,8 +87,6 @@ def delete_from_formula_names!(formula_names)
   end
   alias delete_from_cask_tokens! delete_from_formula_names!
 
-  private
-
   # `select` from the underlying database.
   def select(&block)
     database.select(&block)
@@ -99,11 +101,12 @@ class CaskDescriptionCacheStore < DescriptionCacheStore
   # If the database is empty `update!` it with all known casks.
   #
   # @return [nil]
-  def populate_if_empty!
+  def populate_if_empty!(eval_all: Homebrew::EnvConfig.eval_all?)
+    return unless eval_all
     return unless database.empty?
 
-    # TODO: 3.6.0: consider if we want to actually read all contents of all casks or odeprecate.
-    Cask::Cask.all.each { |c| update!(c.full_name, [c.name.join(", "), c.desc.presence]) }
+    Cask::Cask.all(eval_all:)
+              .each { |c| update!(c.full_name, [c.name.join(", "), c.desc.presence]) }
   end
 
   # Use an update report to update the {CaskDescriptionCacheStore}.
@@ -111,6 +114,10 @@ def populate_if_empty!
   # @param report [Report] an update report generated by cmd/update.rb
   # @return [nil]
   def update_from_report!(report)
+    unless Homebrew::EnvConfig.eval_all?
+      database.clear!
+      return
+    end
     return populate_if_empty! if database.empty?
     return if report.empty?
 
@@ -126,6 +133,10 @@ def update_from_report!(report)
   # @param cask_tokens [Array] the casks to update
   # @return [nil]
   def update_from_cask_tokens!(cask_tokens)
+    unless Homebrew::EnvConfig.eval_all?
+      database.clear!
+      return
+    end
     return populate_if_empty! if database.empty?
 
     cask_tokens.each do |token|
diff --git a/Library/Homebrew/descriptions.rb b/Library/Homebrew/descriptions.rb
index 81d451e2f96e7..63b28cefa8be8 100644
--- a/Library/Homebrew/descriptions.rb
+++ b/Library/Homebrew/descriptions.rb
@@ -1,28 +1,25 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "formula"
 require "formula_versions"
 require "search"
-require "searchable"
 
 # Helper class for printing and searching descriptions.
-#
-# @api private
 class Descriptions
-  extend Homebrew::Search
-
   # Given a regex, find all formulae whose specified fields contain a match.
-  def self.search(string_or_regex, field, cache_store)
-    cache_store.populate_if_empty!
+  def self.search(string_or_regex, field, cache_store,
+                  eval_all = Homebrew::EnvConfig.eval_all?, cache_store_hash: false)
+
+    cache_store.populate_if_empty!(eval_all:) unless cache_store_hash
 
     results = case field
     when :name
-      cache_store.search(string_or_regex) { |name, _| name }
+      Homebrew::Search.search(cache_store, string_or_regex) { |name, _| name }
     when :desc
-      cache_store.search(string_or_regex) { |_, desc| desc }
+      Homebrew::Search.search(cache_store, string_or_regex) { |_, desc| desc }
     when :either
-      cache_store.search(string_or_regex)
+      Homebrew::Search.search(cache_store, string_or_regex)
     end
 
     new(results)
diff --git a/Library/Homebrew/dev-cmd/audit.rb b/Library/Homebrew/dev-cmd/audit.rb
index 082e9c01e9e66..21682ae9ed7cc 100644
--- a/Library/Homebrew/dev-cmd/audit.rb
+++ b/Library/Homebrew/dev-cmd/audit.rb
@@ -1,6 +1,7 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
 require "formula_versions"
 require "utils/curl"
@@ -14,285 +15,347 @@
 require "date"
 require "missing_formula"
 require "digest"
-require "cli/parser"
 require "json"
 require "formula_auditor"
 require "tap_auditor"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def audit_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Check <formula> for Homebrew coding style violations. This should be run before
-        submitting a new formula or cask. If no <formula>|<cask> are provided, check all
-        locally available formulae and casks and skip style checks. Will exit with a
-        non-zero status if any errors are found.
-      EOS
-      switch "--strict",
-             description: "Run additional, stricter style checks."
-      switch "--git",
-             description: "Run additional, slower style checks that navigate the Git repository."
-      switch "--online",
-             description: "Run additional, slower style checks that require a network connection."
-      switch "--installed",
-             description: "Only check formulae and casks that are currently installed."
-      switch "--all",
-             description: "Check all formulae and casks whether installed or not.",
-             hidden:      true
-      switch "--new", "--new-formula", "--new-cask",
-             description: "Run various additional style checks to determine if a new formula or cask is eligible " \
-                          "for Homebrew. This should be used when creating new formula and implies " \
-                          "`--strict` and `--online`."
-      switch "--[no-]appcast",
-             description: "Audit the appcast."
-      switch "--token-conflicts",
-             description: "Audit for token conflicts."
-      flag   "--tap=",
-             description: "Check the formulae within the given tap, specified as <user>`/`<repo>."
-      switch "--fix",
-             description: "Fix style violations automatically using RuboCop's auto-correct feature."
-      switch "--display-cop-names",
-             description: "Include the RuboCop cop name for each violation in the output."
-      switch "--display-filename",
-             description: "Prefix every line of output with the file or formula name being audited, to " \
-                          "make output easy to grep."
-      switch "--display-failures-only",
-             description: "Only display casks that fail the audit. This is the default for formulae."
-      switch "--skip-style",
-             description: "Skip running non-RuboCop style checks. Useful if you plan on running " \
-                          "`brew style` separately. Enabled by default unless a formula is specified by name."
-      switch "-D", "--audit-debug",
-             description: "Enable debugging and profiling of audit methods."
-      comma_array "--only",
-                  description: "Specify a comma-separated <method> list to only run the methods named " \
-                               "`audit_`<method>."
-      comma_array "--except",
-                  description: "Specify a comma-separated <method> list to skip running the methods named " \
-                               "`audit_`<method>."
-      comma_array "--only-cops",
-                  description: "Specify a comma-separated <cops> list to check for violations of only the listed " \
-                               "RuboCop cops."
-      comma_array "--except-cops",
-                  description: "Specify a comma-separated <cops> list to skip checking for violations of the " \
-                               "listed RuboCop cops."
-      switch "--formula", "--formulae",
-             description: "Treat all named arguments as formulae."
-      switch "--cask", "--casks",
-             description: "Treat all named arguments as casks."
-
-      conflicts "--only", "--except"
-      conflicts "--only-cops", "--except-cops", "--strict"
-      conflicts "--only-cops", "--except-cops", "--only"
-      conflicts "--display-cop-names", "--skip-style"
-      conflicts "--display-cop-names", "--only-cops"
-      conflicts "--display-cop-names", "--except-cops"
-      conflicts "--formula", "--cask"
-      conflicts "--installed", "--all"
-
-      named_args [:formula, :cask]
-    end
-  end
-
-  sig { void }
-  def audit
-    args = audit_args.parse
-
-    Homebrew.auditing = true
-    inject_dump_stats!(FormulaAuditor, /^audit_/) if args.audit_debug?
-
-    formula_count = 0
-    problem_count = 0
-    corrected_problem_count = 0
-    new_formula_problem_count = 0
-    new_formula = args.new_formula?
-    strict = new_formula || args.strict?
-    online = new_formula || args.online?
-    skip_style = args.skip_style? || args.no_named? || args.tap
-    no_named_args = false
-
-    ENV.activate_extensions!
-    ENV.setup_build_environment
-
-    # TODO: 3.6.0: odeprecate not specifying args.all?, require args.installed?
-
-    audit_formulae, audit_casks = if args.tap
-      Tap.fetch(args.tap).then do |tap|
-        [
-          tap.formula_names.map { |name| Formula[name] },
-          tap.cask_files.map { |path| Cask::CaskLoader.load(path) },
-        ]
+  module DevCmd
+    class Audit < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Check <formula> for Homebrew coding style violations. This should be run before
+          submitting a new formula or cask. If no <formula>|<cask> are provided, check all
+          locally available formulae and casks and skip style checks. Will exit with a
+          non-zero status if any errors are found.
+        EOS
+        flag   "--os=",
+               description: "Audit the given operating system. (Pass `all` to audit all operating systems.)"
+        flag   "--arch=",
+               description: "Audit the given CPU architecture. (Pass `all` to audit all architectures.)"
+        switch "--strict",
+               description: "Run additional, stricter style checks."
+        switch "--git",
+               description: "Run additional, slower style checks that navigate the Git repository."
+        switch "--online",
+               description: "Run additional, slower style checks that require a network connection."
+        switch "--installed",
+               description: "Only check formulae and casks that are currently installed."
+        switch "--eval-all",
+               description: "Evaluate all available formulae and casks, whether installed or not, to audit them. " \
+                            "Implied if `HOMEBREW_EVAL_ALL` is set."
+        switch "--new",
+               description: "Run various additional style checks to determine if a new formula or cask is eligible " \
+                            "for Homebrew. This should be used when creating new formulae or casks and implies " \
+                            "`--strict` and `--online`."
+        switch "--new-formula",
+               replacement: "--new",
+               disable:     true,
+               hidden:      true
+        switch "--new-cask",
+               replacement: "--new",
+               disable:     true,
+               hidden:      true
+        switch "--[no-]signing",
+               description: "Audit for signed apps, which are required on ARM"
+        switch "--token-conflicts",
+               description: "Audit for token conflicts."
+        flag   "--tap=",
+               description: "Check the formulae within the given tap, specified as <user>`/`<repo>."
+        switch "--fix",
+               description: "Fix style violations automatically using RuboCop's auto-correct feature."
+        switch "--display-cop-names",
+               description: "Include the RuboCop cop name for each violation in the output. This is the default.",
+               hidden:      true
+        switch "--display-filename",
+               description: "Prefix every line of output with the file or formula name being audited, to " \
+                            "make output easy to grep."
+        switch "--skip-style",
+               description: "Skip running non-RuboCop style checks. Useful if you plan on running " \
+                            "`brew style` separately. Enabled by default unless a formula is specified by name."
+        switch "-D", "--audit-debug",
+               description: "Enable debugging and profiling of audit methods."
+        comma_array "--only",
+                    description: "Specify a comma-separated <method> list to only run the methods named " \
+                                 "`audit_`<method>."
+        comma_array "--except",
+                    description: "Specify a comma-separated <method> list to skip running the methods named " \
+                                 "`audit_`<method>."
+        comma_array "--only-cops",
+                    description: "Specify a comma-separated <cops> list to check for violations of only the listed " \
+                                 "RuboCop cops."
+        comma_array "--except-cops",
+                    description: "Specify a comma-separated <cops> list to skip checking for violations of the " \
+                                 "listed RuboCop cops."
+        switch "--formula", "--formulae",
+               description: "Treat all named arguments as formulae."
+        switch "--cask", "--casks",
+               description: "Treat all named arguments as casks."
+
+        conflicts "--only", "--except"
+        conflicts "--only-cops", "--except-cops", "--strict"
+        conflicts "--only-cops", "--except-cops", "--only"
+        conflicts "--formula", "--cask"
+        conflicts "--installed", "--all"
+
+        named_args [:formula, :cask], without_api: true
       end
-    elsif args.installed?
-      no_named_args = true
-      [Formula.installed, Cask::Caskroom.casks]
-    elsif args.no_named?
-      no_named_args = true
-      [Formula.all, Cask::Cask.all]
-    else
-      args.named.to_formulae_and_casks
-          .partition { |formula_or_cask| formula_or_cask.is_a?(Formula) }
-    end
-    style_files = args.named.to_paths unless skip_style
-
-    only_cops = args.only_cops
-    except_cops = args.except_cops
-    style_options = { fix: args.fix?, debug: args.debug?, verbose: args.verbose? }
-
-    if only_cops
-      style_options[:only_cops] = only_cops
-    elsif args.new_formula?
-      nil
-    elsif except_cops
-      style_options[:except_cops] = except_cops
-    elsif !strict
-      style_options[:except_cops] = [:FormulaAuditStrict]
-    end
 
-    # Run tap audits first
-    tap_problem_count = 0
-    tap_count = 0
-    Tap.each do |tap|
-      next if args.tap && tap != args.tap
+      sig { override.void }
+      def run
+        Formulary.enable_factory_cache!
+
+        os_arch_combinations = args.os_arch_combinations
+
+        Homebrew.auditing = true
+        Homebrew.inject_dump_stats!(FormulaAuditor, /^audit_/) if args.audit_debug?
+
+        strict = args.new? || args.strict?
+        online = args.new? || args.online?
+        tap_audit = args.tap.present?
+        skip_style = args.skip_style? || args.no_named? || tap_audit
+        no_named_args = T.let(false, T::Boolean)
+
+        gem_groups = ["audit"]
+        gem_groups << "style" unless skip_style
+        Homebrew.install_bundler_gems!(groups: gem_groups)
+
+        ENV.activate_extensions!
+        ENV.setup_build_environment
+
+        audit_formulae, audit_casks = Homebrew.with_no_api_env do # audit requires full Ruby source
+          if args.tap
+            Tap.fetch(T.must(args.tap)).then do |tap|
+              [
+                tap.formula_files.map { |path| Formulary.factory(path) },
+                tap.cask_files.map { |path| Cask::CaskLoader.load(path) },
+              ]
+            end
+          elsif args.installed?
+            no_named_args = true
+            [Formula.installed, Cask::Caskroom.casks]
+          elsif args.no_named?
+            if !args.eval_all? && !Homebrew::EnvConfig.eval_all?
+              # This odisabled should probably stick around indefinitely.
+              odisabled "brew audit",
+                        "brew audit --eval-all or HOMEBREW_EVAL_ALL"
+            end
+            no_named_args = true
+            [
+              Formula.all(eval_all: args.eval_all?),
+              Cask::Cask.all(eval_all: args.eval_all?),
+            ]
+          else
+            if args.named.any? { |named_arg| named_arg.end_with?(".rb") }
+              # This odisabled should probably stick around indefinitely,
+              # until at least we have a way to exclude error on these in the CLI parser.
+              odisabled "brew audit [path ...]",
+                        "brew audit [name ...]"
+            end
+
+            args.named.to_formulae_and_casks_with_taps
+                .partition { |formula_or_cask| formula_or_cask.is_a?(Formula) }
+          end
+        end
 
-      ta = TapAuditor.new(tap, strict: args.strict?)
-      ta.audit
+        if audit_formulae.empty? && audit_casks.empty? && !args.tap
+          ofail "No matching formulae or casks to audit!"
+          return
+        end
 
-      next if ta.problems.blank?
+        style_files = args.named.to_paths unless skip_style
 
-      tap_count += 1
-      tap_problem_count += ta.problems.size
-      tap_problem_lines = format_problem_lines(ta.problems)
+        only_cops = args.only_cops
+        except_cops = args.except_cops
+        style_options = { fix: args.fix?, debug: args.debug?, verbose: args.verbose? }
 
-      puts "#{tap.name}:", tap_problem_lines.map { |s| "  #{s}" }
-    end
+        if only_cops
+          style_options[:only_cops] = only_cops
+        elsif args.new?
+          nil
+        elsif except_cops
+          style_options[:except_cops] = except_cops
+        elsif !strict
+          style_options[:except_cops] = [:FormulaAuditStrict]
+        end
+
+        # Run tap audits first
+        named_arg_taps = [*audit_formulae, *audit_casks].map(&:tap).uniq if !args.tap && !no_named_args
+        tap_problems = Tap.installed.each_with_object({}) do |tap, problems|
+          next if args.tap && tap != args.tap
+          next if named_arg_taps&.exclude?(tap)
 
-    # Check style in a single batch run up front for performance
-    style_offenses = Style.check_style_json(style_files, style_options) if style_files
-    # load licenses
-    spdx_license_data = SPDX.license_data
-    spdx_exception_data = SPDX.exception_data
-    new_formula_problem_lines = []
-    formula_results = audit_formulae.sort.to_h do |f|
-      only = only_cops ? ["style"] : args.only
-      options = {
-        new_formula:         new_formula,
-        strict:              strict,
-        online:              online,
-        git:                 args.git?,
-        only:                only,
-        except:              args.except,
-        spdx_license_data:   spdx_license_data,
-        spdx_exception_data: spdx_exception_data,
-        style_offenses:      style_offenses ? style_offenses.for_path(f.path) : nil,
-        display_cop_names:   args.display_cop_names?,
-      }.compact
-
-      fa = FormulaAuditor.new(f, **options)
-      fa.audit
-
-      if fa.problems.any? || fa.new_formula_problems.any?
-        formula_count += 1
-        problem_count += fa.problems.size
-        problem_lines = format_problem_lines(fa.problems)
-        corrected_problem_count += options.fetch(:style_offenses, []).count(&:corrected?)
-        new_formula_problem_lines += format_problem_lines(fa.new_formula_problems)
-        if args.display_filename?
-          puts problem_lines.map { |s| "#{f.path}: #{s}" }
-        else
-          puts "#{f.full_name}:", problem_lines.map { |s| "  #{s}" }
+          ta = TapAuditor.new(tap, strict: args.strict?)
+          ta.audit
+
+          problems[[tap.name, tap.path]] = ta.problems if ta.problems.any?
         end
-      end
 
-      [f.path, { errors: fa.problems + fa.new_formula_problems, warnings: [] }]
-    end
+        # Check style in a single batch run up front for performance
+        style_offenses = Style.check_style_json(style_files, **style_options) if style_files
+        # load licenses
+        spdx_license_data = SPDX.license_data
+        spdx_exception_data = SPDX.exception_data
+
+        formula_problems = audit_formulae.sort.each_with_object({}) do |f, problems|
+          path = f.path
+
+          only = only_cops ? ["style"] : args.only
+          options = {
+            new_formula:         args.new?,
+            strict:,
+            online:,
+            git:                 args.git?,
+            only:,
+            except:              args.except,
+            spdx_license_data:,
+            spdx_exception_data:,
+            style_offenses:      style_offenses&.for_path(f.path),
+            tap_audit:,
+          }.compact
+
+          errors = os_arch_combinations.flat_map do |os, arch|
+            SimulateSystem.with(os:, arch:) do
+              odebug "Auditing Formula #{f} on os #{os} and arch #{arch}"
+
+              audit_proc = proc { FormulaAuditor.new(Formulary.factory(path), **options).tap(&:audit) }
+
+              # Audit requires full Ruby source so disable API. We shouldn't do this for taps however so that we
+              # don't unnecessarily require a full Homebrew/core clone.
+              fa = if f.core_formula?
+                Homebrew.with_no_api_env(&audit_proc)
+              else
+                audit_proc.call
+              end
+
+              fa.problems + fa.new_formula_problems
+            end
+          end.uniq
+
+          problems[[f.full_name, path]] = errors if errors.any?
+        end
 
-    cask_results = if audit_casks.empty?
-      {}
-    else
-      require "cask/cmd/abstract_command"
-      require "cask/cmd/audit"
-
-      # For switches, we add `|| nil` so that `nil` will be passed instead of `false` if they aren't set.
-      # This way, we can distinguish between "not set" and "set to false".
-      Cask::Cmd::Audit.audit_casks(
-        *audit_casks,
-        download:              nil,
-        # No need for `|| nil` for `--[no-]appcast` because boolean switches are already `nil` if not passed
-        appcast:               args.appcast?,
-        online:                args.online? || nil,
-        strict:                args.strict? || nil,
-        new_cask:              args.new_cask? || nil,
-        token_conflicts:       args.token_conflicts? || nil,
-        quarantine:            nil,
-        any_named_args:        !no_named_args,
-        language:              nil,
-        display_passes:        args.verbose? || args.named.count == 1,
-        display_failures_only: args.display_failures_only?,
-      )
-    end
+        require "cask/auditor" if audit_casks.any?
+
+        cask_problems = audit_casks.each_with_object({}) do |cask, problems|
+          path = cask.sourcefile_path
+
+          errors = os_arch_combinations.flat_map do |os, arch|
+            next [] if os == :linux
+
+            SimulateSystem.with(os:, arch:) do
+              odebug "Auditing Cask #{cask} on os #{os} and arch #{arch}"
+
+              Cask::Auditor.audit(
+                Cask::CaskLoader.load(path),
+                # For switches, we add `|| nil` so that `nil` will be passed
+                # instead of `false` if they aren't set.
+                # This way, we can distinguish between "not set" and "set to false".
+                audit_online:          args.online? || nil,
+                audit_strict:          args.strict? || nil,
+
+                # No need for `|| nil` for `--[no-]signing`
+                # because boolean switches are already `nil` if not passed
+                audit_signing:         args.signing?,
+                audit_new_cask:        args.new? || nil,
+                audit_token_conflicts: args.token_conflicts? || nil,
+                quarantine:            true,
+                any_named_args:        !no_named_args,
+                only:                  args.only,
+                except:                args.except,
+              ).to_a
+            end
+          end.uniq
+
+          problems[[cask.full_name, path]] = errors if errors.any?
+        end
 
-    failed_casks = cask_results.reject { |_, result| result[:errors].empty? }
+        print_problems(tap_problems)
+        print_problems(formula_problems)
+        print_problems(cask_problems)
 
-    cask_count = failed_casks.count
+        tap_count = tap_problems.keys.count
+        formula_count = formula_problems.keys.count
+        cask_count = cask_problems.keys.count
 
-    cask_problem_count = failed_casks.sum { |_, result| result[:warnings].count + result[:errors].count }
-    new_formula_problem_count += new_formula_problem_lines.count
-    total_problems_count = problem_count + new_formula_problem_count + cask_problem_count + tap_problem_count
+        corrected_problem_count = (formula_problems.values + cask_problems.values)
+                                  .sum { |problems| problems.count { |problem| problem.fetch(:corrected) } }
 
-    if total_problems_count.positive?
-      puts new_formula_problem_lines.map { |s| "  #{s}" }
+        tap_problem_count = tap_problems.sum { |_, problems| problems.count }
+        formula_problem_count = formula_problems.sum { |_, problems| problems.count }
+        cask_problem_count = cask_problems.sum { |_, problems| problems.count }
+        total_problems_count = formula_problem_count + cask_problem_count + tap_problem_count
 
-      errors_summary = "#{total_problems_count} #{"problem".pluralize(total_problems_count)}"
+        if total_problems_count.positive?
+          errors_summary = Utils.pluralize("problem", total_problems_count, include_count: true)
 
-      error_sources = []
-      error_sources << "#{formula_count} #{"formula".pluralize(formula_count)}" if formula_count.positive?
-      error_sources << "#{cask_count} #{"cask".pluralize(cask_count)}" if cask_count.positive?
-      error_sources << "#{tap_count} #{"tap".pluralize(tap_count)}" if tap_count.positive?
+          error_sources = []
+          if formula_count.positive?
+            error_sources << Utils.pluralize("formula", formula_count, plural: "e", include_count: true)
+          end
+          error_sources << Utils.pluralize("cask", cask_count, include_count: true) if cask_count.positive?
+          error_sources << Utils.pluralize("tap", tap_count, include_count: true) if tap_count.positive?
 
-      errors_summary += " in #{error_sources.to_sentence}" if error_sources.any?
+          errors_summary += " in #{error_sources.to_sentence}" if error_sources.any?
 
-      errors_summary += " detected"
+          errors_summary += " detected"
 
-      if corrected_problem_count.positive?
-        errors_summary += ", #{corrected_problem_count} #{"problem".pluralize(corrected_problem_count)} corrected"
-      end
+          if corrected_problem_count.positive?
+            errors_summary +=
+              ", #{Utils.pluralize("problem", corrected_problem_count, include_count: true)} corrected"
+          end
 
-      ofail errors_summary
-    end
+          ofail "#{errors_summary}."
+        end
 
-    return unless ENV["GITHUB_ACTIONS"]
-
-    annotations = formula_results.merge(cask_results).flat_map do |path, result|
-      (
-        result[:warnings].map { |w| [:warning, w] } +
-        result[:errors].map { |e| [:error, e] }
-      ).map do |type, problem|
-        GitHub::Actions::Annotation.new(
-          type,
-          problem[:message],
-          file:   path,
-          line:   problem[:location]&.line,
-          column: problem[:location]&.column,
-        )
+        return unless GitHub::Actions.env_set?
+
+        annotations = formula_problems.merge(cask_problems).flat_map do |(_, path), problems|
+          problems.map do |problem|
+            GitHub::Actions::Annotation.new(
+              :error,
+              problem[:message],
+              file:   path,
+              line:   problem[:location]&.line,
+              column: problem[:location]&.column,
+            )
+          end
+        end.compact
+
+        annotations.each do |annotation|
+          puts annotation if annotation.relevant?
+        end
       end
-    end
 
-    annotations.each do |annotation|
-      puts annotation if annotation.relevant?
-    end
-  end
+      private
 
-  def format_problem_lines(problems)
-    problems.uniq
-            .map { |message:, location:| format_problem(message, location) }
-  end
+      sig { params(results: T::Hash[[Symbol, Pathname], T::Array[T::Hash[Symbol, T.untyped]]]).void }
+      def print_problems(results)
+        results.each do |(name, path), problems|
+          problem_lines = format_problem_lines(problems)
+
+          if args.display_filename?
+            problem_lines.each do |l|
+              puts "#{path}: #{l}"
+            end
+          else
+            puts name, problem_lines.map { |l| l.dup.prepend("  ") }
+          end
+        end
+      end
 
-  def format_problem(message, location)
-    "* #{location&.to_s&.dup&.concat(": ")}#{message.chomp.gsub("\n", "\n    ")}"
+      sig { params(problems: T::Array[T::Hash[Symbol, T.untyped]]).returns(T::Array[String]) }
+      def format_problem_lines(problems)
+        problems.map do |problem|
+          status = " #{Formatter.success("[corrected]")}" if problem.fetch(:corrected)
+          location = problem.fetch(:location)
+          if location
+            location = "#{location.line&.to_s&.prepend("line ")}#{location.column&.to_s&.prepend(", col ")}: "
+          end
+          message = problem.fetch(:message)
+          "* #{location}#{message.chomp.gsub("\n", "\n    ")}#{status}"
+        end
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/bottle.rb b/Library/Homebrew/dev-cmd/bottle.rb
index 38d62a7c8017b..b0c914ae01d39 100644
--- a/Library/Homebrew/dev-cmd/bottle.rb
+++ b/Library/Homebrew/dev-cmd/bottle.rb
@@ -1,18 +1,27 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
+require "fileutils"
 require "formula"
 require "utils/bottles"
 require "tab"
+require "sbom"
 require "keg"
 require "formula_versions"
-require "cli/parser"
 require "utils/inreplace"
 require "erb"
-require "zlib"
+require "utils/gzip"
 require "api"
+require "extend/hash/deep_merge"
+require "metafiles"
 
-BOTTLE_ERB = <<-EOS
+module Homebrew
+  module DevCmd
+    class Bottle < AbstractCommand
+      include FileUtils
+
+      BOTTLE_ERB = T.let(<<-EOS.freeze, String)
   bottle do
     <% if [HOMEBREW_BOTTLE_DEFAULT_DOMAIN.to_s,
            "#{HOMEBREW_BOTTLE_DEFAULT_DOMAIN}/bottles"].exclude?(root_url) %>
@@ -27,780 +36,865 @@
     <%= line %>
     <% end %>
   end
-EOS
-
-MAXIMUM_STRING_MATCHES = 100
-GZIP_BUFFER_SIZE = 64 * 1024
-
-ALLOWABLE_HOMEBREW_REPOSITORY_LINKS = [
-  %r{#{Regexp.escape(HOMEBREW_LIBRARY)}/Homebrew/os/(mac|linux)/pkgconfig},
-].freeze
-
-module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def bottle_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Generate a bottle (binary package) from a formula that was installed with
-        `--build-bottle`.
-        If the formula specifies a rebuild version, it will be incremented in the
-        generated DSL. Passing `--keep-old` will attempt to keep it at its original
-        value, while `--no-rebuild` will remove it.
       EOS
-      switch "--skip-relocation",
-             description: "Do not check if the bottle can be marked as relocatable."
-      switch "--force-core-tap",
-             description: "Build a bottle even if <formula> is not in `homebrew/core` or any installed taps."
-      switch "--no-rebuild",
-             description: "If the formula specifies a rebuild version, remove it from the generated DSL."
-      switch "--keep-old",
-             description: "If the formula specifies a rebuild version, attempt to preserve its value in the " \
-                          "generated DSL."
-      switch "--json",
-             description: "Write bottle information to a JSON file, which can be used as the value for " \
-                          "`--merge`."
-      switch "--merge",
-             description: "Generate an updated bottle block for a formula and optionally merge it into the " \
-                          "formula file. Instead of a formula name, requires the path to a JSON file generated " \
-                          "with `brew bottle --json` <formula>."
-      switch "--write",
-             depends_on:  "--merge",
-             description: "Write changes to the formula file. A new commit will be generated unless " \
-                          "`--no-commit` is passed."
-      switch "--no-commit",
-             depends_on:  "--write",
-             description: "When passed with `--write`, a new commit will not generated after writing changes " \
-                          "to the formula file."
-      switch "--only-json-tab",
-             depends_on:  "--json",
-             description: "When passed with `--json`, the tab will be written to the JSON file but not the bottle."
-      flag   "--committer=",
-             description: "Specify a committer name and email in `git`'s standard author format."
-      flag   "--root-url=",
-             description: "Use the specified <URL> as the root of the bottle's URL instead of Homebrew's default."
-      flag   "--root-url-using=",
-             description: "Use the specified download strategy class for downloading the bottle's URL instead of " \
-                          "Homebrew's default."
-
-      conflicts "--no-rebuild", "--keep-old"
-
-      named_args [:installed_formula, :file], min: 1
-    end
-  end
 
-  def bottle
-    args = bottle_args.parse
+      MAXIMUM_STRING_MATCHES = 100
 
-    if args.merge?
-      Homebrew.install_bundler_gems!
-      return merge(args: args)
-    end
+      ALLOWABLE_HOMEBREW_REPOSITORY_LINKS = T.let([
+        %r{#{Regexp.escape(HOMEBREW_LIBRARY)}/Homebrew/os/(mac|linux)/pkgconfig},
+      ].freeze, T::Array[Regexp])
 
-    args.named.to_resolved_formulae(uniq: false).each do |f|
-      bottle_formula f, args: args
-    end
-  end
-
-  def keg_contain?(string, keg, ignores, formula_and_runtime_deps_names = nil, args:)
-    @put_string_exists_header, @put_filenames = nil
-
-    print_filename = lambda do |str, filename|
-      unless @put_string_exists_header
-        opoo "String '#{str}' still exists in these files:"
-        @put_string_exists_header = true
+      cmd_args do
+        description <<~EOS
+          Generate a bottle (binary package) from a formula that was installed with
+          `--build-bottle`.
+          If the formula specifies a rebuild version, it will be incremented in the
+          generated DSL. Passing `--keep-old` will attempt to keep it at its original
+          value, while `--no-rebuild` will remove it.
+        EOS
+        switch "--skip-relocation",
+               description: "Do not check if the bottle can be marked as relocatable."
+        switch "--force-core-tap",
+               description: "Build a bottle even if <formula> is not in `homebrew/core` or any installed taps."
+        switch "--no-rebuild",
+               description: "If the formula specifies a rebuild version, remove it from the generated DSL."
+        switch "--keep-old",
+               description: "If the formula specifies a rebuild version, attempt to preserve its value in the " \
+                            "generated DSL."
+        switch "--json",
+               description: "Write bottle information to a JSON file, which can be used as the value for " \
+                            "`--merge`."
+        switch "--merge",
+               description: "Generate an updated bottle block for a formula and optionally merge it into the " \
+                            "formula file. Instead of a formula name, requires the path to a JSON file generated " \
+                            "with `brew bottle --json` <formula>."
+        switch "--write",
+               depends_on:  "--merge",
+               description: "Write changes to the formula file. A new commit will be generated unless " \
+                            "`--no-commit` is passed."
+        switch "--no-commit",
+               depends_on:  "--write",
+               description: "When passed with `--write`, a new commit will not generated after writing changes " \
+                            "to the formula file."
+        switch "--only-json-tab",
+               depends_on:  "--json",
+               description: "When passed with `--json`, the tab will be written to the JSON file but not the bottle."
+        switch "--no-all-checks",
+               depends_on:  "--merge",
+               description: "Don't try to create an `all` bottle or stop a no-change upload."
+        flag   "--committer=",
+               description: "Specify a committer name and email in `git`'s standard author format."
+        flag   "--root-url=",
+               description: "Use the specified <URL> as the root of the bottle's URL instead of Homebrew's default."
+        flag   "--root-url-using=",
+               description: "Use the specified download strategy class for downloading the bottle's URL instead of " \
+                            "Homebrew's default."
+
+        conflicts "--no-rebuild", "--keep-old"
+
+        named_args [:installed_formula, :file], min: 1, without_api: true
       end
 
-      @put_filenames ||= []
-
-      return if @put_filenames.include?(filename)
-
-      puts Formatter.error(filename.to_s)
-      @put_filenames << filename
-    end
+      sig { override.void }
+      def run
+        if args.merge?
+          Homebrew.install_bundler_gems!(groups: ["ast"])
+          return merge
+        end
 
-    result = false
+        Homebrew.install_bundler_gems!(groups: ["bottle"])
 
-    keg.each_unique_file_matching(string) do |file|
-      next if Metafiles::EXTENSIONS.include?(file.extname) # Skip document files.
+        gnu_tar_formula_ensure_installed_if_needed!
 
-      linked_libraries = Keg.file_linked_libraries(file, string)
-      result ||= !linked_libraries.empty?
+        args.named.to_resolved_formulae(uniq: false).each do |formula|
+          bottle_formula formula
+        end
+      end
 
-      if args.verbose?
-        print_filename.call(string, file) unless linked_libraries.empty?
-        linked_libraries.each do |lib|
-          puts " #{Tty.bold}-->#{Tty.reset} links to #{lib}"
+      sig {
+        params(tag: Symbol, digest: T.any(Checksum, String), cellar: T.nilable(T.any(String, Symbol)),
+               tag_column: Integer, digest_column: Integer).returns(String)
+      }
+      def generate_sha256_line(tag, digest, cellar, tag_column, digest_column)
+        line = "sha256 "
+        tag_column += line.length
+        digest_column += line.length
+        if cellar.is_a?(Symbol)
+          line += "cellar: :#{cellar},"
+        elsif cellar_parameter_needed?(cellar)
+          line += %Q(cellar: "#{cellar}",)
         end
+        line += " " * (tag_column - line.length)
+        line += "#{tag}:"
+        line += " " * (digest_column - line.length)
+        %Q(#{line}"#{digest}")
       end
 
-      text_matches = Keg.text_matches_in_file(file, string, ignores, linked_libraries, formula_and_runtime_deps_names)
-      result = true if text_matches.any?
+      sig { params(bottle: BottleSpecification, root_url_using: T.nilable(String)).returns(String) }
+      def bottle_output(bottle, root_url_using)
+        cellars = bottle.checksums.filter_map do |checksum|
+          cellar = checksum["cellar"]
+          next unless cellar_parameter_needed? cellar
+
+          case cellar
+          when String
+            %Q("#{cellar}")
+          when Symbol
+            ":#{cellar}"
+          end
+        end
+        tag_column = cellars.empty? ? 0 : "cellar: #{cellars.max_by(&:length)}, ".length
 
-      next if !args.verbose? || text_matches.empty?
+        tags = bottle.checksums.map { |checksum| checksum["tag"] }
+        # Start where the tag ends, add the max length of the tag, add two for the `: `
+        digest_column = tag_column + tags.max_by(&:length).length + 2
 
-      print_filename.call(string, file)
-      text_matches.first(MAXIMUM_STRING_MATCHES).each do |match, offset|
-        puts " #{Tty.bold}-->#{Tty.reset} match '#{match}' at offset #{Tty.bold}0x#{offset}#{Tty.reset}"
+        sha256_lines = bottle.checksums.map do |checksum|
+          generate_sha256_line(checksum["tag"], checksum["digest"], checksum["cellar"], tag_column, digest_column)
+        end
+        erb_binding = bottle.instance_eval { binding }
+        erb_binding.local_variable_set(:sha256_lines, sha256_lines)
+        erb_binding.local_variable_set(:root_url_using, root_url_using)
+        erb = ERB.new BOTTLE_ERB
+        erb.result(erb_binding).gsub(/^\s*$\n/, "")
       end
 
-      if text_matches.size > MAXIMUM_STRING_MATCHES
-        puts "Only the first #{MAXIMUM_STRING_MATCHES} matches were output."
+      sig { params(filenames: T::Array[String]).returns(T::Array[T::Hash[String, T.untyped]]) }
+      def parse_json_files(filenames)
+        filenames.map do |filename|
+          JSON.parse(File.read(filename))
+        end
       end
-    end
 
-    keg_contain_absolute_symlink_starting_with?(string, keg, args: args) || result
-  end
+      sig { params(json_files: T::Array[T::Hash[String, T.untyped]]).returns(T::Hash[String, T.untyped]) }
+      def merge_json_files(json_files)
+        json_files.reduce({}) do |hash, json_file|
+          json_file.each_value do |json_hash|
+            json_bottle = json_hash["bottle"]
+            cellar = json_bottle.delete("cellar")
+            json_bottle["tags"].each_value do |json_platform|
+              json_platform["cellar"] ||= cellar
+            end
+          end
+          hash.deep_merge(json_file)
+        end
+      end
 
-  def keg_contain_absolute_symlink_starting_with?(string, keg, args:)
-    absolute_symlinks_start_with_string = []
-    keg.find do |pn|
-      next if !pn.symlink? || !(link = pn.readlink).absolute?
+      sig {
+        params(old_keys: T::Array[String], old_bottle_spec: BottleSpecification,
+               new_bottle_hash: T::Hash[String, T.untyped]).returns(T::Array[T::Array[String]])
+      }
+      def merge_bottle_spec(old_keys, old_bottle_spec, new_bottle_hash)
+        mismatches = []
+        checksums = []
 
-      absolute_symlinks_start_with_string << pn if link.to_s.start_with?(string)
-    end
+        new_values = {
+          root_url: new_bottle_hash["root_url"],
+          rebuild:  new_bottle_hash["rebuild"],
+        }
 
-    if args.verbose? && absolute_symlinks_start_with_string.present?
-      opoo "Absolute symlink starting with #{string}:"
-      absolute_symlinks_start_with_string.each do |pn|
-        puts "  #{pn} -> #{pn.resolved_path}"
-      end
-    end
+        skip_keys = [:sha256, :cellar]
+        old_keys.each do |key|
+          next if skip_keys.include?(key)
 
-    !absolute_symlinks_start_with_string.empty?
-  end
+          old_value = old_bottle_spec.send(key).to_s
+          new_value = new_values[key].to_s
 
-  def cellar_parameter_needed?(cellar)
-    default_cellars = [
-      Homebrew::DEFAULT_MACOS_CELLAR,
-      Homebrew::DEFAULT_MACOS_ARM_CELLAR,
-      Homebrew::DEFAULT_LINUX_CELLAR,
-    ]
-    cellar.present? && default_cellars.exclude?(cellar)
-  end
+          next if old_value.present? && new_value == old_value
 
-  def generate_sha256_line(tag, digest, cellar, tag_column, digest_column)
-    line = "sha256 "
-    tag_column += line.length
-    digest_column += line.length
-    if cellar.is_a?(Symbol)
-      line += "cellar: :#{cellar},"
-    elsif cellar_parameter_needed?(cellar)
-      line += %Q(cellar: "#{cellar}",)
-    end
-    line += " " * (tag_column - line.length)
-    line += "#{tag}:"
-    line += " " * (digest_column - line.length)
-    %Q(#{line}"#{digest}")
-  end
+          mismatches << "#{key}: old: #{old_value.inspect}, new: #{new_value.inspect}"
+        end
 
-  def bottle_output(bottle, root_url_using)
-    cellars = bottle.checksums.map do |checksum|
-      cellar = checksum["cellar"]
-      next unless cellar_parameter_needed? cellar
+        return [mismatches, checksums] if old_keys.exclude? :sha256
 
-      case cellar
-      when String
-        %Q("#{cellar}")
-      when Symbol
-        ":#{cellar}"
-      end
-    end.compact
-    tag_column = cellars.empty? ? 0 : "cellar: #{cellars.max_by(&:length)}, ".length
+        old_bottle_spec.collector.each_tag do |tag|
+          old_tag_spec = old_bottle_spec.collector.specification_for(tag)
+          old_hexdigest = old_tag_spec.checksum.hexdigest
+          old_cellar = old_tag_spec.cellar
+          new_value = new_bottle_hash.dig("tags", tag.to_s)
+          if new_value.present? && new_value["sha256"] != old_hexdigest
+            mismatches << "sha256 #{tag}: old: #{old_hexdigest.inspect}, new: #{new_value["sha256"].inspect}"
+          elsif new_value.present? && new_value["cellar"] != old_cellar.to_s
+            mismatches << "cellar #{tag}: old: #{old_cellar.to_s.inspect}, new: #{new_value["cellar"].inspect}"
+          else
+            checksums << { cellar: old_cellar, tag.to_sym => old_hexdigest }
+          end
+        end
 
-    tags = bottle.checksums.map { |checksum| checksum["tag"] }
-    # Start where the tag ends, add the max length of the tag, add two for the `: `
-    digest_column = tag_column + tags.max_by(&:length).length + 2
+        [mismatches, checksums]
+      end
 
-    sha256_lines = bottle.checksums.map do |checksum|
-      generate_sha256_line(checksum["tag"], checksum["digest"], checksum["cellar"], tag_column, digest_column)
-    end
-    erb_binding = bottle.instance_eval { binding }
-    erb_binding.local_variable_set(:sha256_lines, sha256_lines)
-    erb_binding.local_variable_set(:root_url_using, root_url_using)
-    erb = ERB.new BOTTLE_ERB
-    erb.result(erb_binding).gsub(/^\s*$\n/, "")
-  end
+      private
 
-  def sudo_purge
-    return unless ENV["HOMEBREW_BOTTLE_SUDO_PURGE"]
+      sig {
+        params(string: String, keg: Keg, ignores: T::Array[String],
+               formula_and_runtime_deps_names: T.nilable(T::Array[String])).returns(T::Boolean)
+      }
+      def keg_contain?(string, keg, ignores, formula_and_runtime_deps_names = nil)
+        @put_string_exists_header, @put_filenames = nil
 
-    system "/usr/bin/sudo", "--non-interactive", "/usr/sbin/purge"
-  end
+        print_filename = lambda do |str, filename|
+          unless @put_string_exists_header
+            opoo "String '#{str}' still exists in these files:"
+            @put_string_exists_header = T.let(true, T.nilable(T::Boolean))
+          end
 
-  def setup_tar_and_args!(args)
-    # Without --only-json-tab bottles are never reproducible
-    default_tar_args = ["tar", [].freeze].freeze
-    return default_tar_args unless args.only_json_tab?
-
-    # Ensure tar is set up for reproducibility.
-    # https://reproducible-builds.org/docs/archives/
-    gnutar_args = [
-      "--format", "pax", "--owner", "0", "--group", "0", "--sort", "name",
-      # Set exthdr names to exclude PID (for GNU tar <1.33). Also don't store atime and ctime.
-      "--pax-option", "globexthdr.name=/GlobalHead.%n,exthdr.name=%d/PaxHeaders/%f,delete=atime,delete=ctime"
-    ].freeze
-
-    return ["tar", gnutar_args].freeze if OS.linux?
-
-    # Use gnu-tar on macOS as it can be set up for reproducibility better than libarchive.
-    begin
-      gnu_tar = Formula["gnu-tar"]
-    rescue FormulaUnavailableError
-      return default_tar_args
-    end
+          @put_filenames ||= T.let([], T.nilable(T::Array[T.any(String, Pathname)]))
 
-    ensure_formula_installed!(gnu_tar, reason: "bottling")
+          return false if @put_filenames.include?(filename)
 
-    ["#{gnu_tar.opt_bin}/gtar", gnutar_args].freeze
-  end
+          puts Formatter.error(filename.to_s)
+          @put_filenames << filename
+        end
 
-  def formula_ignores(f)
-    ignores = []
-    cellar_regex = Regexp.escape(HOMEBREW_CELLAR)
-    prefix_regex = Regexp.escape(HOMEBREW_PREFIX)
+        result = T.let(false, T::Boolean)
 
-    # Ignore matches to go keg, because all go binaries are statically linked.
-    any_go_deps = f.deps.any? do |dep|
-      dep.name =~ Version.formula_optionally_versioned_regex(:go)
-    end
-    if any_go_deps
-      go_regex = Version.formula_optionally_versioned_regex(:go, full: false)
-      ignores << %r{#{cellar_regex}/#{go_regex}/[\d.]+/libexec}
-    end
+        keg.each_unique_file_matching(string) do |file|
+          next if Metafiles::EXTENSIONS.include?(file.extname) # Skip document files.
 
-    ignores << case f.name
-    # On Linux, GCC installation can be moved so long as the whole directory tree is moved together:
-    # https://gcc-help.gcc.gnu.narkive.com/GnwuCA7l/moving-gcc-from-the-installation-path-is-it-allowed.
-    when Version.formula_optionally_versioned_regex(:gcc)
-      Regexp.union(%r{#{cellar_regex}/gcc}, %r{#{prefix_regex}/opt/gcc}) if OS.linux?
-    # binutils is relocatable for the same reason: https://github.com/Homebrew/brew/pull/11899#issuecomment-906804451.
-    when Version.formula_optionally_versioned_regex(:binutils)
-      %r{#{cellar_regex}/binutils} if OS.linux?
-    end
+          linked_libraries = Keg.file_linked_libraries(file, string)
+          result ||= !linked_libraries.empty?
 
-    ignores.compact
-  end
+          if args.verbose?
+            print_filename.call(string, file) unless linked_libraries.empty?
+            linked_libraries.each do |lib|
+              puts " #{Tty.bold}-->#{Tty.reset} links to #{lib}"
+            end
+          end
 
-  def bottle_formula(f, args:)
-    local_bottle_json = args.json? && f.local_bottle_path.present?
+          text_matches = Keg.text_matches_in_file(file, string, ignores, linked_libraries,
+                                                  formula_and_runtime_deps_names)
+          result = true if text_matches.any?
 
-    unless local_bottle_json
-      return ofail "Formula not installed or up-to-date: #{f.full_name}" unless f.latest_version_installed?
-      return ofail "Formula was not installed with --build-bottle: #{f.full_name}" unless Utils::Bottles.built_as? f
-    end
+          next if !args.verbose? || text_matches.empty?
 
-    tap = f.tap
-    if tap.nil?
-      return ofail "Formula not from core or any installed taps: #{f.full_name}" unless args.force_core_tap?
+          print_filename.call(string, file)
+          text_matches.first(MAXIMUM_STRING_MATCHES).each do |match, offset|
+            puts " #{Tty.bold}-->#{Tty.reset} match '#{match}' at offset #{Tty.bold}0x#{offset}#{Tty.reset}"
+          end
 
-      tap = CoreTap.instance
-    end
+          if text_matches.size > MAXIMUM_STRING_MATCHES
+            puts "Only the first #{MAXIMUM_STRING_MATCHES} matches were output."
+          end
+        end
 
-    return ofail "Formula has no stable version: #{f.full_name}" unless f.stable
+        keg_contain_absolute_symlink_starting_with?(string, keg) || result
+      end
 
-    bottle_tag, rebuild = if local_bottle_json
-      _, tag_string, rebuild_string = Utils::Bottles.extname_tag_rebuild(f.local_bottle_path.to_s)
-      [tag_string.to_sym, rebuild_string.to_i]
-    end
+      sig { params(string: String, keg: Keg).returns(T::Boolean) }
+      def keg_contain_absolute_symlink_starting_with?(string, keg)
+        absolute_symlinks_start_with_string = []
+        keg.find do |pn|
+          next if !pn.symlink? || !(link = pn.readlink).absolute?
 
-    bottle_tag = if bottle_tag
-      Utils::Bottles::Tag.from_symbol(bottle_tag)
-    else
-      Utils::Bottles.tag
-    end
+          absolute_symlinks_start_with_string << pn if link.to_s.start_with?(string)
+        end
 
-    rebuild ||= if args.no_rebuild? || !tap
-      0
-    elsif args.keep_old?
-      f.bottle_specification.rebuild
-    else
-      ohai "Determining #{f.full_name} bottle rebuild..."
-      FormulaVersions.new(f).formula_at_revision("origin/HEAD") do |upstream_f|
-        if f.pkg_version == upstream_f.pkg_version
-          upstream_f.bottle_specification.rebuild + 1
-        else
-          0
+        if args.verbose? && absolute_symlinks_start_with_string.present?
+          opoo "Absolute symlink starting with #{string}:"
+          absolute_symlinks_start_with_string.each do |pn|
+            puts "  #{pn} -> #{pn.resolved_path}"
+          end
         end
-      end || 0
-    end
 
-    filename = Bottle::Filename.create(f, bottle_tag.to_sym, rebuild)
-    local_filename = filename.to_s
-    bottle_path = Pathname.pwd/filename
+        !absolute_symlinks_start_with_string.empty?
+      end
+
+      sig { params(cellar: T.nilable(T.any(String, Symbol))).returns(T::Boolean) }
+      def cellar_parameter_needed?(cellar)
+        default_cellars = [
+          Homebrew::DEFAULT_MACOS_CELLAR,
+          Homebrew::DEFAULT_MACOS_ARM_CELLAR,
+          Homebrew::DEFAULT_LINUX_CELLAR,
+        ]
+        cellar.present? && default_cellars.exclude?(cellar)
+      end
+
+      sig { returns(T.nilable(T::Boolean)) }
+      def sudo_purge
+        return unless ENV["HOMEBREW_BOTTLE_SUDO_PURGE"]
 
-    tab = nil
-    keg = nil
+        system "/usr/bin/sudo", "--non-interactive", "/usr/sbin/purge"
+      end
 
-    tap_path = tap.path
-    tap_git_revision = tap.git_head
-    tap_git_remote = tap.remote
+      sig { returns(T::Array[String]) }
+      def tar_args
+        [].freeze
+      end
 
-    root_url = args.root_url
+      sig { params(gnu_tar_formula: Formula).returns(String) }
+      def gnu_tar(gnu_tar_formula)
+        "#{gnu_tar_formula.opt_bin}/tar"
+      end
 
-    relocatable = T.let(false, T::Boolean)
-    skip_relocation = T.let(false, T::Boolean)
+      sig { params(mtime: String).returns(T::Array[String]) }
+      def reproducible_gnutar_args(mtime)
+        # Ensure gnu tar is set up for reproducibility.
+        # https://reproducible-builds.org/docs/archives/
+        [
+          # File modification times
+          "--mtime=#{mtime}",
+          # File ordering
+          "--sort=name",
+          # Users, groups and numeric ids
+          "--owner=0", "--group=0", "--numeric-owner",
+          # PAX headers
+          "--format=pax",
+          # Set exthdr names to exclude PID (for GNU tar <1.33). Also don't store atime and ctime.
+          "--pax-option=globexthdr.name=/GlobalHead.%n,exthdr.name=%d/PaxHeaders/%f,delete=atime,delete=ctime"
+        ].freeze
+      end
 
-    prefix = HOMEBREW_PREFIX.to_s
-    cellar = HOMEBREW_CELLAR.to_s
+      sig { returns(T.nilable(Formula)) }
+      def gnu_tar_formula_ensure_installed_if_needed!
+        gnu_tar_formula = begin
+          Formula["gnu-tar"]
+        rescue FormulaUnavailableError
+          nil
+        end
+        return if gnu_tar_formula.blank?
 
-    if local_bottle_json
-      bottle_path = f.local_bottle_path
-      local_filename = bottle_path.basename.to_s
+        ensure_formula_installed!(gnu_tar_formula, reason: "bottling")
 
-      tab_path = Utils::Bottles.receipt_path(bottle_path)
-      raise "This bottle does not contain the file INSTALL_RECEIPT.json: #{bottle_path}" unless tab_path
+        gnu_tar_formula
+      end
 
-      tab_json = Utils::Bottles.file_from_bottle(bottle_path, tab_path)
-      tab = Tab.from_file_content(tab_json, tab_path)
+      sig { params(mtime: String, default_tar: T::Boolean).returns([String, T::Array[String]]) }
+      def setup_tar_and_args!(mtime, default_tar: false)
+        # Without --only-json-tab bottles are never reproducible
+        default_tar_args = ["tar", tar_args].freeze
+        return default_tar_args if !args.only_json_tab? || default_tar
 
-      tag_spec = Formula[f.name].bottle_specification.tag_specification_for(bottle_tag, no_older_versions: true)
-      relocatable = [:any, :any_skip_relocation].include?(tag_spec.cellar)
-      skip_relocation = tag_spec.cellar == :any_skip_relocation
+        # Use gnu-tar as it can be set up for reproducibility better than libarchive
+        # and to be consistent between macOS and Linux.
+        gnu_tar_formula = gnu_tar_formula_ensure_installed_if_needed!
+        return default_tar_args if gnu_tar_formula.blank?
 
-      prefix = bottle_tag.default_prefix
-      cellar = bottle_tag.default_cellar
-    else
-      tar_filename = filename.to_s.sub(/.gz$/, "")
-      tar_path = Pathname.pwd/tar_filename
+        [gnu_tar(gnu_tar_formula), reproducible_gnutar_args(mtime)].freeze
+      end
 
-      keg = Keg.new(f.prefix)
-    end
+      sig { params(formula: T.untyped).returns(T::Array[T.untyped]) }
+      def formula_ignores(formula)
+        ignores = []
+        cellar_regex = Regexp.escape(HOMEBREW_CELLAR)
+        prefix_regex = Regexp.escape(HOMEBREW_PREFIX)
 
-    ohai "Bottling #{local_filename}..."
-
-    formula_and_runtime_deps_names = [f.name] + f.runtime_dependencies.map(&:name)
-
-    # this will be nil when using a local bottle
-    keg&.lock do
-      original_tab = nil
-      changed_files = nil
-
-      begin
-        keg.delete_pyc_files!
-
-        changed_files = keg.replace_locations_with_placeholders unless args.skip_relocation?
-
-        Formula.clear_cache
-        Keg.clear_cache
-        Tab.clear_cache
-        Dependency.clear_cache
-        Requirement.clear_cache
-        tab = Tab.for_keg(keg)
-        original_tab = tab.dup
-        tab.poured_from_bottle = false
-        tab.HEAD = nil
-        tab.time = nil
-        tab.changed_files = changed_files.dup
-        if args.only_json_tab?
-          tab.changed_files.delete(Pathname.new(Tab::FILENAME))
-          tab.tabfile.unlink
-        else
-          tab.write
+        # Ignore matches to go keg, because all go binaries are statically linked.
+        any_go_deps = formula.deps.any? do |dep|
+          Version.formula_optionally_versioned_regex(:go).match?(dep.name)
+        end
+        if any_go_deps
+          go_regex = Version.formula_optionally_versioned_regex(:go, full: false)
+          ignores << %r{#{cellar_regex}/#{go_regex}/[\d.]+/libexec}
         end
 
-        keg.find do |file|
-          # Set the times for reproducible bottles.
-          if file.symlink?
-            # Need to make symlink permissions consistent on macOS and Linux
-            File.lchmod 0777, file if OS.mac?
-            File.lutime(tab.source_modified_time, tab.source_modified_time, file)
-          else
-            file.utime(tab.source_modified_time, tab.source_modified_time)
-          end
+        # TODO: Refactor and move to extend/os
+        # rubocop:disable Homebrew/MoveToExtendOS
+        ignores << case formula.name
+        # On Linux, GCC installation can be moved so long as the whole directory tree is moved together:
+        # https://gcc-help.gcc.gnu.narkive.com/GnwuCA7l/moving-gcc-from-the-installation-path-is-it-allowed.
+        when Version.formula_optionally_versioned_regex(:gcc)
+          Regexp.union(%r{#{cellar_regex}/gcc}, %r{#{prefix_regex}/opt/gcc}) if OS.linux?
+        # binutils is relocatable for the same reason: https://github.com/Homebrew/brew/pull/11899#issuecomment-906804451.
+        when Version.formula_optionally_versioned_regex(:binutils)
+          %r{#{cellar_regex}/binutils} if OS.linux?
         end
+        # rubocop:enable Homebrew/MoveToExtendOS
+
+        ignores.compact
+      end
+
+      sig { params(formula: Formula).void }
+      def bottle_formula(formula)
+        local_bottle_json = args.json? && formula.local_bottle_path.present?
 
-        cd cellar do
-          sudo_purge
-          # Tar then gzip for reproducible bottles.
-          tar, tar_args = setup_tar_and_args!(args)
-          safe_system tar, "--create", "--numeric-owner",
-                      *tar_args,
-                      "--file", tar_path, "#{f.name}/#{f.pkg_version}"
-          sudo_purge
-          # Set more times for reproducible bottles.
-          tar_path.utime(tab.source_modified_time, tab.source_modified_time)
-          relocatable_tar_path = "#{f}-bottle.tar"
-          mv tar_path, relocatable_tar_path
-          # Use gzip, faster to compress than bzip2, faster to uncompress than bzip2
-          # or an uncompressed tarball (and more bandwidth friendly).
-          gz = Zlib::GzipWriter.open(bottle_path)
-          gz.mtime = tab.source_modified_time
-          gz.orig_name = relocatable_tar_path
-          File.open(relocatable_tar_path, "rb") do |tarfile|
-            gz.write(tarfile.read(GZIP_BUFFER_SIZE)) until tarfile.eof?
+        unless local_bottle_json
+          unless formula.latest_version_installed?
+            return ofail "Formula not installed or up-to-date: #{formula.full_name}"
+          end
+          unless Utils::Bottles.built_as? formula
+            return ofail "Formula was not installed with `--build-bottle`: #{formula.full_name}"
           end
-          gz.close
-          rm_f relocatable_tar_path
-          sudo_purge
         end
 
-        ohai "Detecting if #{local_filename} is relocatable..." if bottle_path.size > 1 * 1024 * 1024
+        tap = formula.tap
+        if tap.nil?
+          return ofail "Formula not from core or any installed taps: #{formula.full_name}" unless args.force_core_tap?
 
-        prefix_check = if Homebrew.default_prefix?(prefix)
-          File.join(prefix, "opt")
-        else
-          prefix
+          tap = CoreTap.instance
         end
+        raise TapUnavailableError, tap.name unless tap.installed?
 
-        # Ignore matches to source code, which is not required at run time.
-        # These matches may be caused by debugging symbols.
-        ignores = [%r{/include/|\.(c|cc|cpp|h|hpp)$}]
+        return ofail "Formula has no stable version: #{formula.full_name}" unless formula.stable
 
-        # Add additional workarounds to ignore
-        ignores += formula_ignores(f)
+        bottle_tag, rebuild = if local_bottle_json
+          _, tag_string, rebuild_string = Utils::Bottles.extname_tag_rebuild(formula.local_bottle_path.to_s)
+          [tag_string.to_sym, rebuild_string.to_i]
+        end
 
-        repository_reference = if HOMEBREW_PREFIX == HOMEBREW_REPOSITORY
-          HOMEBREW_LIBRARY
+        bottle_tag = if bottle_tag
+          Utils::Bottles::Tag.from_symbol(bottle_tag)
         else
-          HOMEBREW_REPOSITORY
-        end.to_s
-        if keg_contain?(repository_reference, keg, ignores + ALLOWABLE_HOMEBREW_REPOSITORY_LINKS, args: args)
-          odie "Bottle contains non-relocatable reference to #{repository_reference}!"
+          Utils::Bottles.tag
         end
 
-        relocatable = true
-        if args.skip_relocation?
-          skip_relocation = true
+        rebuild ||= if args.no_rebuild? || !tap
+          0
+        elsif args.keep_old?
+          formula.bottle_specification.rebuild
         else
-          relocatable = false if keg_contain?(prefix_check, keg, ignores, formula_and_runtime_deps_names, args: args)
-          relocatable = false if keg_contain?(cellar, keg, ignores, formula_and_runtime_deps_names, args: args)
-          if keg_contain?(HOMEBREW_LIBRARY.to_s, keg, ignores, formula_and_runtime_deps_names, args: args)
-            relocatable = false
-          end
-          if prefix != prefix_check
-            relocatable = false if keg_contain_absolute_symlink_starting_with?(prefix, keg, args: args)
-            relocatable = false if keg_contain?("#{prefix}/etc", keg, ignores, args: args)
-            relocatable = false if keg_contain?("#{prefix}/var", keg, ignores, args: args)
-            relocatable = false if keg_contain?("#{prefix}/share/vim", keg, ignores, args: args)
-          end
-          skip_relocation = relocatable && !keg.require_relocation?
-        end
-        puts if !relocatable && args.verbose?
-      rescue Interrupt
-        ignore_interrupts { bottle_path.unlink if bottle_path.exist? }
-        raise
-      ensure
-        ignore_interrupts do
-          original_tab&.write
-          keg.replace_placeholders_with_locations changed_files unless args.skip_relocation?
+          ohai "Determining #{formula.full_name} bottle rebuild..."
+          FormulaVersions.new(formula).formula_at_revision("origin/HEAD") do |upstream_formula|
+            if formula.pkg_version == upstream_formula.pkg_version
+              upstream_formula.bottle_specification.rebuild + 1
+            else
+              0
+            end
+          end || 0
         end
-      end
-    end
 
-    bottle = BottleSpecification.new
-    bottle.tap = tap
-    bottle.root_url(root_url) if root_url
-    bottle_cellar = if relocatable
-      if skip_relocation
-        :any_skip_relocation
-      else
-        :any
-      end
-    else
-      cellar
-    end
-    bottle.rebuild rebuild
-    sha256 = bottle_path.sha256
-    bottle.sha256 cellar: bottle_cellar, bottle_tag.to_sym => sha256
-
-    old_spec = f.bottle_specification
-    if args.keep_old? && !old_spec.checksums.empty?
-      mismatches = [:root_url, :rebuild].reject do |key|
-        old_spec.send(key) == bottle.send(key)
-      end
-      unless mismatches.empty?
-        bottle_path.unlink if bottle_path.exist?
+        filename = ::Bottle::Filename.create(formula, bottle_tag, rebuild)
+        local_filename = filename.to_s
+        bottle_path = Pathname.pwd/local_filename
 
-        mismatches.map! do |key|
-          old_value = old_spec.send(key).inspect
-          value = bottle.send(key).inspect
-          "#{key}: old: #{old_value}, new: #{value}"
-        end
+        tab = nil
+        keg = nil
 
-        odie <<~EOS
-          `--keep-old` was passed but there are changes in:
-          #{mismatches.join("\n")}
-        EOS
-      end
-    end
+        tap_path = tap.path
+        tap_git_revision = tap.git_head
+        tap_git_remote = tap.remote
 
-    output = bottle_output(bottle, args.root_url_using)
-
-    puts "./#{local_filename}"
-    puts output
-
-    return unless args.json?
-
-    json = {
-      f.full_name => {
-        "formula" => {
-          "name"             => f.name,
-          "pkg_version"      => f.pkg_version.to_s,
-          "path"             => f.path.to_s.delete_prefix("#{HOMEBREW_REPOSITORY}/"),
-          "tap_git_path"     => f.path.to_s.delete_prefix("#{tap_path}/"),
-          "tap_git_revision" => tap_git_revision,
-          "tap_git_remote"   => tap_git_remote,
-          # descriptions can contain emoji. sigh.
-          "desc"             => f.desc.to_s.encode(
-            Encoding.find("ASCII"),
-            invalid: :replace, undef: :replace, replace: "",
-          ).strip,
-          "license"          => SPDX.license_expression_to_string(f.license),
-          "homepage"         => f.homepage,
-        },
-        "bottle"  => {
-          "root_url" => bottle.root_url,
-          "cellar"   => bottle_cellar.to_s,
-          "rebuild"  => bottle.rebuild,
-          "date"     => Pathname(filename.to_s).mtime.strftime("%F"),
-          "tags"     => {
-            bottle_tag.to_s => {
-              "filename"              => filename.url_encode,
-              "local_filename"        => filename.to_s,
-              "sha256"                => sha256,
-              "formulae_brew_sh_path" => Homebrew::API::Formula.formula_api_path,
-              "tab"                   => tab.to_bottle_hash,
-            },
-          },
-        },
-      },
-    }
-
-    puts "Writing #{filename.json}" if args.verbose?
-    json_path = Pathname(filename.json)
-    json_path.unlink if json_path.exist?
-    json_path.write(JSON.pretty_generate(json))
-  end
+        root_url = args.root_url
 
-  def parse_json_files(filenames)
-    filenames.map do |filename|
-      JSON.parse(File.read(filename))
-    end
-  end
+        relocatable = T.let(false, T::Boolean)
+        skip_relocation = T.let(false, T::Boolean)
 
-  def merge_json_files(json_files)
-    json_files.reduce({}) do |hash, json_file|
-      json_file.each_value do |json_hash|
-        json_bottle = json_hash["bottle"]
-        cellar = json_bottle.delete("cellar")
-        json_bottle["tags"].each_value do |json_platform|
-          json_platform["cellar"] ||= cellar
-        end
-      end
-      hash.deep_merge(json_file)
-    end
-  end
+        prefix = HOMEBREW_PREFIX.to_s
+        cellar = HOMEBREW_CELLAR.to_s
 
-  def merge(args:)
-    bottles_hash = merge_json_files(parse_json_files(args.named))
+        if local_bottle_json
+          bottle_path = formula.local_bottle_path
+          return if bottle_path.blank?
 
-    any_cellars = ["any", "any_skip_relocation"]
-    bottles_hash.each do |formula_name, bottle_hash|
-      ohai formula_name
+          local_filename = bottle_path.basename.to_s
 
-      bottle = BottleSpecification.new
-      bottle.root_url bottle_hash["bottle"]["root_url"]
-      bottle.rebuild bottle_hash["bottle"]["rebuild"]
+          tab_path = Utils::Bottles.receipt_path(bottle_path)
+          raise "This bottle does not contain the file INSTALL_RECEIPT.json: #{bottle_path}" unless tab_path
 
-      path = HOMEBREW_REPOSITORY/bottle_hash["formula"]["path"]
-      formula = Formulary.factory(path)
+          tab_json = Utils::Bottles.file_from_bottle(bottle_path, tab_path)
+          tab = Tab.from_file_content(tab_json, tab_path)
 
-      old_bottle_spec = formula.bottle_specification
-      old_pkg_version = formula.pkg_version
-      FormulaVersions.new(formula).formula_at_revision("origin/HEAD") do |upstream_f|
-        old_pkg_version = upstream_f.pkg_version
-      end
+          tag_spec = Formula[formula.name].bottle_specification
+                                          .tag_specification_for(bottle_tag, no_older_versions: true)
+          relocatable = [:any, :any_skip_relocation].include?(tag_spec.cellar)
+          skip_relocation = tag_spec.cellar == :any_skip_relocation
 
-      old_bottle_spec_matches = old_bottle_spec &&
-                                bottle_hash["formula"]["pkg_version"] == old_pkg_version.to_s &&
-                                bottle.root_url == old_bottle_spec.root_url &&
-                                old_bottle_spec.collector.tags.present?
+          prefix = bottle_tag.default_prefix
+          cellar = bottle_tag.default_cellar
+        else
+          tar_filename = filename.to_s.sub(/.gz$/, "")
+          tar_path = Pathname.pwd/tar_filename
+          return if tar_path.blank?
 
-      # if all the cellars and checksums are the same: we can create an
-      # `all: $SHA256` bottle.
-      tag_hashes = bottle_hash["bottle"]["tags"].values
-      all_bottle = (!old_bottle_spec_matches || bottle.rebuild != old_bottle_spec.rebuild) &&
-                   tag_hashes.count > 1 &&
-                   tag_hashes.uniq { |tag_hash| "#{tag_hash["cellar"]}-#{tag_hash["sha256"]}" }.count == 1
+          keg = Keg.new(formula.prefix)
+        end
 
-      bottle_hash["bottle"]["tags"].each do |tag, tag_hash|
-        cellar = tag_hash["cellar"]
-        cellar = cellar.to_sym if any_cellars.include?(cellar)
+        ohai "Bottling #{local_filename}..."
+
+        formula_and_runtime_deps_names = [formula.name] + formula.runtime_dependencies.map(&:name)
+
+        # this will be nil when using a local bottle
+        keg&.lock do
+          original_tab = nil
+          changed_files = nil
+
+          begin
+            keg.delete_pyc_files!
+
+            changed_files = keg.replace_locations_with_placeholders unless args.skip_relocation?
+
+            Formula.clear_cache
+            Keg.clear_cache
+            Tab.clear_cache
+            Dependency.clear_cache
+            Requirement.clear_cache
+
+            tab = keg.tab
+            original_tab = tab.dup
+            tab.poured_from_bottle = false
+            tab.time = nil
+            tab.changed_files = changed_files.dup
+            if args.only_json_tab?
+              tab.changed_files.delete(Pathname.new(AbstractTab::FILENAME))
+              tab.tabfile.unlink
+            else
+              tab.write
+            end
+
+            sbom = SBOM.create(formula, tab)
+            sbom.write(bottling: true)
+
+            keg.consistent_reproducible_symlink_permissions!
+
+            cd cellar do
+              sudo_purge
+              # Tar then gzip for reproducible bottles.
+              tar_mtime = tab.source_modified_time.strftime("%Y-%m-%d %H:%M:%S")
+              tar, tar_args = setup_tar_and_args!(tar_mtime, default_tar: formula.name == "gnu-tar")
+              safe_system tar, "--create", "--numeric-owner",
+                          *tar_args,
+                          "--file", tar_path, "#{formula.name}/#{formula.pkg_version}"
+              sudo_purge
+              # Set filename as it affects the tarball checksum.
+              relocatable_tar_path = "#{formula}-bottle.tar"
+              mv T.must(tar_path), relocatable_tar_path
+              # Use gzip, faster to compress than bzip2, faster to uncompress than bzip2
+              # or an uncompressed tarball (and more bandwidth friendly).
+              Utils::Gzip.compress_with_options(relocatable_tar_path,
+                                                mtime:     tab.source_modified_time,
+                                                orig_name: relocatable_tar_path,
+                                                output:    bottle_path)
+              sudo_purge
+            end
+
+            ohai "Detecting if #{local_filename} is relocatable..." if bottle_path.size > 1 * 1024 * 1024
+
+            prefix_check = if Homebrew.default_prefix?(prefix)
+              File.join(prefix, "opt")
+            else
+              prefix
+            end
+
+            # Ignore matches to source code, which is not required at run time.
+            # These matches may be caused by debugging symbols.
+            ignores = [%r{/include/|\.(c|cc|cpp|h|hpp)$}]
+
+            # Add additional workarounds to ignore
+            ignores += formula_ignores(formula)
+
+            repository_reference = if HOMEBREW_PREFIX == HOMEBREW_REPOSITORY
+              HOMEBREW_LIBRARY
+            else
+              HOMEBREW_REPOSITORY
+            end.to_s
+            if keg_contain?(repository_reference, keg, ignores + ALLOWABLE_HOMEBREW_REPOSITORY_LINKS)
+              odie "Bottle contains non-relocatable reference to #{repository_reference}!"
+            end
+
+            relocatable = true
+            if args.skip_relocation?
+              skip_relocation = true
+            else
+              relocatable = false if keg_contain?(prefix_check, keg, ignores, formula_and_runtime_deps_names)
+              relocatable = false if keg_contain?(cellar, keg, ignores, formula_and_runtime_deps_names)
+              relocatable = false if keg_contain?(HOMEBREW_LIBRARY.to_s, keg, ignores, formula_and_runtime_deps_names)
+              if prefix != prefix_check
+                relocatable = false if keg_contain_absolute_symlink_starting_with?(prefix, keg)
+                relocatable = false if keg_contain?("#{prefix}/etc", keg, ignores)
+                relocatable = false if keg_contain?("#{prefix}/var", keg, ignores)
+                relocatable = false if keg_contain?("#{prefix}/share/vim", keg, ignores)
+              end
+              skip_relocation = relocatable && !keg.require_relocation?
+            end
+            puts if !relocatable && args.verbose?
+          rescue Interrupt
+            ignore_interrupts { bottle_path.unlink if bottle_path.exist? }
+            raise
+          ensure
+            ignore_interrupts do
+              original_tab&.write
+              keg.replace_placeholders_with_locations changed_files unless args.skip_relocation?
+            end
+          end
+        end
 
-        tag_sym = if all_bottle
-          :all
+        bottle = BottleSpecification.new
+        bottle.tap = tap
+        bottle.root_url(root_url) if root_url
+        bottle_cellar = if relocatable
+          if skip_relocation
+            :any_skip_relocation
+          else
+            :any
+          end
         else
-          tag.to_sym
+          cellar
+        end
+        bottle.rebuild rebuild
+        sha256 = bottle_path.sha256
+        bottle.sha256 cellar: bottle_cellar, bottle_tag.to_sym => sha256
+
+        old_spec = formula.bottle_specification
+        if args.keep_old? && !old_spec.checksums.empty?
+          mismatches = [:root_url, :rebuild].reject do |key|
+            old_spec.send(key) == bottle.send(key)
+          end
+          unless mismatches.empty?
+            bottle_path.unlink if bottle_path.exist?
+
+            mismatches.map! do |key|
+              old_value = old_spec.send(key).inspect
+              value = bottle.send(key).inspect
+              "#{key}: old: #{old_value}, new: #{value}"
+            end
+
+            odie <<~EOS
+              `--keep-old` was passed but there are changes in:
+              #{mismatches.join("\n")}
+            EOS
+          end
         end
 
-        sha256_hash = { cellar: cellar, tag_sym => tag_hash["sha256"] }
-        bottle.sha256 sha256_hash
+        output = bottle_output(bottle, args.root_url_using)
 
-        break if all_bottle
-      end
+        puts "./#{local_filename}"
+        puts output
+
+        return unless args.json?
+
+        if keg
+          keg_prefix = "#{keg}/"
+          path_exec_files = [keg/"bin", keg/"sbin"].select(&:exist?)
+                                                   .flat_map(&:children)
+                                                   .select(&:executable?)
+                                                   .map { |path| path.to_s.delete_prefix(keg_prefix) }
+          all_files = keg.find
+                         .select(&:file?)
+                         .map { |path| path.to_s.delete_prefix(keg_prefix) }
+          installed_size = keg.disk_usage
+        end
+
+        json = {
+          formula.full_name => {
+            "formula" => {
+              "name"             => formula.name,
+              "pkg_version"      => formula.pkg_version.to_s,
+              "path"             => formula.path.to_s.delete_prefix("#{HOMEBREW_REPOSITORY}/"),
+              "tap_git_path"     => formula.path.to_s.delete_prefix("#{tap_path}/"),
+              "tap_git_revision" => tap_git_revision,
+              "tap_git_remote"   => tap_git_remote,
+              # descriptions can contain emoji. sigh.
+              "desc"             => formula.desc.to_s.encode(
+                Encoding.find("ASCII"),
+                invalid: :replace, undef: :replace, replace: "",
+              ).strip,
+              "license"          => SPDX.license_expression_to_string(formula.license),
+              "homepage"         => formula.homepage,
+            },
+            "bottle"  => {
+              "root_url" => bottle.root_url,
+              "cellar"   => bottle_cellar.to_s,
+              "rebuild"  => bottle.rebuild,
+              # date is used for org.opencontainers.image.created which is an RFC 3339 date-time.
+              # Time#iso8601 produces an XML Schema date-time that meets RFC 3339 ABNF.
+              "date"     => Pathname(filename.to_s).mtime.utc.iso8601,
+              "tags"     => {
+                bottle_tag.to_s => {
+                  "filename"        => filename.url_encode,
+                  "local_filename"  => filename.to_s,
+                  "sha256"          => sha256,
+                  "tab"             => tab.to_bottle_hash,
+                  "path_exec_files" => path_exec_files,
+                  "all_files"       => all_files,
+                  "installed_size"  => installed_size,
+                },
+              },
+            },
+          },
+        }
 
-      unless args.write?
-        puts bottle_output(bottle, args.root_url_using)
-        next
+        puts "Writing #{filename.json}" if args.verbose?
+        json_path = Pathname(filename.json)
+        json_path.unlink if json_path.exist?
+        json_path.write(JSON.pretty_generate(json))
       end
 
-      no_bottle_changes = if old_bottle_spec_matches && bottle.rebuild != old_bottle_spec.rebuild
-        bottle.collector.tags.all? do |tag|
-          tag_spec = bottle.collector.specification_for(tag)
-          next false if tag_spec.blank?
+      sig { returns(T::Hash[String, T.untyped]) }
+      def merge
+        bottles_hash = merge_json_files(parse_json_files(args.named))
 
-          old_tag_spec = old_bottle_spec.collector.specification_for(tag)
-          next false if old_tag_spec.blank?
+        any_cellars = ["any", "any_skip_relocation"]
+        bottles_hash.each do |formula_name, bottle_hash|
+          ohai formula_name
 
-          next false if tag_spec.cellar != old_tag_spec.cellar
+          bottle = BottleSpecification.new
+          bottle.root_url bottle_hash["bottle"]["root_url"]
+          bottle.rebuild bottle_hash["bottle"]["rebuild"]
 
-          tag_spec.checksum.hexdigest == old_tag_spec.checksum.hexdigest
-        end
-      end
+          path = HOMEBREW_REPOSITORY/bottle_hash["formula"]["path"]
+          formula = Formulary.factory(path)
 
-      all_bottle_hash = nil
-      bottle_hash["bottle"]["tags"].each do |tag, tag_hash|
-        filename = Bottle::Filename.new(
-          formula_name,
-          bottle_hash["formula"]["pkg_version"],
-          tag,
-          bottle_hash["bottle"]["rebuild"],
-        )
-
-        if all_bottle && all_bottle_hash.nil?
-          all_bottle_tag_hash = tag_hash.dup
-
-          all_filename = Bottle::Filename.new(
-            formula_name,
-            bottle_hash["formula"]["pkg_version"],
-            "all",
-            bottle_hash["bottle"]["rebuild"],
-          )
-
-          all_bottle_tag_hash["filename"] = all_filename.url_encode
-          all_bottle_tag_hash["local_filename"] = all_filename.to_s
-          cellar = all_bottle_tag_hash.delete("cellar")
-
-          all_bottle_formula_hash = bottle_hash.dup
-          all_bottle_formula_hash["bottle"]["cellar"] = cellar
-          all_bottle_formula_hash["bottle"]["tags"] = { all: all_bottle_tag_hash }
-
-          all_bottle_hash = { formula_name => all_bottle_formula_hash }
-
-          puts "Copying #{filename} to #{all_filename}" if args.verbose?
-          FileUtils.cp filename.to_s, all_filename.to_s
-
-          puts "Writing #{all_filename.json}" if args.verbose?
-          all_local_json_path = Pathname(all_filename.json)
-          all_local_json_path.unlink if all_local_json_path.exist?
-          all_local_json_path.write(JSON.pretty_generate(all_bottle_hash))
-        end
+          old_bottle_spec = formula.bottle_specification
+          old_pkg_version = formula.pkg_version
+          FormulaVersions.new(formula).formula_at_revision("origin/HEAD") do |upstream_formula|
+            old_pkg_version = upstream_formula.pkg_version
+          end
 
-        if all_bottle || no_bottle_changes
-          puts "Removing #{filename} and #{filename.json}" if args.verbose?
-          FileUtils.rm_f [filename.to_s, filename.json]
-        end
-      end
+          old_bottle_spec_matches = old_bottle_spec &&
+                                    bottle_hash["formula"]["pkg_version"] == old_pkg_version.to_s &&
+                                    bottle.root_url == old_bottle_spec.root_url &&
+                                    old_bottle_spec.collector.tags.present?
+
+          # if all the cellars and checksums are the same: we can create an
+          # `all: $SHA256` bottle.
+          tag_hashes = bottle_hash["bottle"]["tags"].values
+          all_bottle = !args.no_all_checks? &&
+                       (!old_bottle_spec_matches || bottle.rebuild != old_bottle_spec.rebuild) &&
+                       tag_hashes.count > 1 &&
+                       tag_hashes.uniq { |tag_hash| "#{tag_hash["cellar"]}-#{tag_hash["sha256"]}" }.count == 1
+
+          old_all_bottle = old_bottle_spec.tag?(Utils::Bottles.tag(:all))
+          if !all_bottle && old_all_bottle && !args.no_all_checks?
+            odie <<~ERROR
+              #{formula} should have an `:all` bottle but one cannot be created:
+              #{JSON.pretty_generate(tag_hashes)}
+            ERROR
+          end
 
-      next if no_bottle_changes
+          bottle_hash["bottle"]["tags"].each do |tag, tag_hash|
+            cellar = tag_hash["cellar"]
+            cellar = cellar.to_sym if any_cellars.include?(cellar)
 
-      require "utils/ast"
-      formula_ast = Utils::AST::FormulaAST.new(path.read)
-      checksums = old_checksums(formula, formula_ast, bottle_hash, args: args)
-      update_or_add = checksums.nil? ? "add" : "update"
+            tag_sym = if all_bottle
+              :all
+            else
+              tag.to_sym
+            end
 
-      checksums&.each(&bottle.method(:sha256))
-      output = bottle_output(bottle, args.root_url_using)
-      puts output
+            sha256_hash = { cellar:, tag_sym => tag_hash["sha256"] }
+            bottle.sha256 sha256_hash
 
-      case update_or_add
-      when "update"
-        formula_ast.replace_bottle_block(output)
-      when "add"
-        formula_ast.add_bottle_block(output)
-      end
-      path.atomic_write(formula_ast.process)
+            break if all_bottle
+          end
 
-      next if args.no_commit?
+          unless args.write?
+            puts bottle_output(bottle, args.root_url_using)
+            next
+          end
 
-      Utils::Git.set_name_email!(committer: args.committer.blank?)
-      Utils::Git.setup_gpg!
+          no_bottle_changes = if !args.no_all_checks? && old_bottle_spec_matches &&
+                                 bottle.rebuild != old_bottle_spec.rebuild
+            bottle.collector.tags.all? do |tag|
+              tag_spec = bottle.collector.specification_for(tag)
+              next false if tag_spec.blank?
 
-      if (committer = args.committer)
-        committer = Utils.parse_author!(committer)
-        ENV["GIT_COMMITTER_NAME"] = committer[:name]
-        ENV["GIT_COMMITTER_EMAIL"] = committer[:email]
-      end
+              old_tag_spec = old_bottle_spec.collector.specification_for(tag)
+              next false if old_tag_spec.blank?
 
-      short_name = formula_name.split("/", -1).last
-      pkg_version = bottle_hash["formula"]["pkg_version"]
+              next false if tag_spec.cellar != old_tag_spec.cellar
 
-      path.parent.cd do
-        safe_system "git", "commit", "--no-edit", "--verbose",
-                    "--message=#{short_name}: #{update_or_add} #{pkg_version} bottle.",
-                    "--", path
-      end
-    end
-  end
+              tag_spec.checksum.hexdigest == old_tag_spec.checksum.hexdigest
+            end
+          end
 
-  def merge_bottle_spec(old_keys, old_bottle_spec, new_bottle_hash)
-    mismatches = []
-    checksums = []
+          all_bottle_hash = T.let(nil, T.nilable(T::Hash[String, T.untyped]))
+          bottle_hash["bottle"]["tags"].each do |tag, tag_hash|
+            filename = ::Bottle::Filename.new(
+              formula_name,
+              PkgVersion.parse(bottle_hash["formula"]["pkg_version"]),
+              Utils::Bottles::Tag.from_symbol(tag.to_sym),
+              bottle_hash["bottle"]["rebuild"],
+            )
+
+            if all_bottle && all_bottle_hash.nil?
+              all_bottle_tag_hash = tag_hash.dup
+
+              all_filename = ::Bottle::Filename.new(
+                formula_name,
+                PkgVersion.parse(bottle_hash["formula"]["pkg_version"]),
+                Utils::Bottles::Tag.from_symbol(:all),
+                bottle_hash["bottle"]["rebuild"],
+              )
+
+              all_bottle_tag_hash["filename"] = all_filename.url_encode
+              all_bottle_tag_hash["local_filename"] = all_filename.to_s
+              cellar = all_bottle_tag_hash.delete("cellar")
+
+              all_bottle_formula_hash = bottle_hash.dup
+              all_bottle_formula_hash["bottle"]["cellar"] = cellar
+              all_bottle_formula_hash["bottle"]["tags"] = { all: all_bottle_tag_hash }
+
+              all_bottle_hash = { formula_name => all_bottle_formula_hash }
+
+              puts "Copying #{filename} to #{all_filename}" if args.verbose?
+              FileUtils.cp filename.to_s, all_filename.to_s
+
+              puts "Writing #{all_filename.json}" if args.verbose?
+              all_local_json_path = Pathname(all_filename.json)
+              all_local_json_path.unlink if all_local_json_path.exist?
+              all_local_json_path.write(JSON.pretty_generate(all_bottle_hash))
+            end
+
+            if all_bottle || no_bottle_changes
+              puts "Removing #{filename} and #{filename.json}" if args.verbose?
+              FileUtils.rm_f [filename.to_s, filename.json]
+            end
+          end
 
-    new_values = {
-      root_url: new_bottle_hash["root_url"],
-      rebuild:  new_bottle_hash["rebuild"],
-    }
+          next if no_bottle_changes
 
-    skip_keys = [:sha256, :cellar]
-    old_keys.each do |key|
-      next if skip_keys.include?(key)
+          require "utils/ast"
+          formula_ast = Utils::AST::FormulaAST.new(path.read)
+          checksums = old_checksums(formula, formula_ast, bottle_hash)
+          update_or_add = checksums.nil? ? "add" : "update"
 
-      old_value = old_bottle_spec.send(key).to_s
-      new_value = new_values[key].to_s
+          checksums&.each { |checksum| bottle.sha256(checksum) }
+          output = bottle_output(bottle, args.root_url_using)
+          puts output
 
-      next if old_value.present? && new_value == old_value
+          case update_or_add
+          when "update"
+            formula_ast.replace_bottle_block(output)
+          when "add"
+            formula_ast.add_bottle_block(output)
+          end
+          path.atomic_write(formula_ast.process)
 
-      mismatches << "#{key}: old: #{old_value.inspect}, new: #{new_value.inspect}"
-    end
+          next if args.no_commit?
 
-    return [mismatches, checksums] if old_keys.exclude? :sha256
-
-    old_bottle_spec.collector.each_tag do |tag|
-      old_tag_spec = old_bottle_spec.collector.specification_for(tag)
-      old_hexdigest = old_tag_spec.checksum.hexdigest
-      old_cellar = old_tag_spec.cellar
-      new_value = new_bottle_hash.dig("tags", tag.to_s)
-      if new_value.present? && new_value["sha256"] != old_hexdigest
-        mismatches << "sha256 #{tag}: old: #{old_hexdigest.inspect}, new: #{new_value["sha256"].inspect}"
-      elsif new_value.present? && new_value["cellar"] != old_cellar.to_s
-        mismatches << "cellar #{tag}: old: #{old_cellar.to_s.inspect}, new: #{new_value["cellar"].inspect}"
-      else
-        checksums << { cellar: old_cellar, tag.to_sym => old_hexdigest }
-      end
-    end
+          Utils::Git.set_name_email!(committer: args.committer.blank?)
+          Utils::Git.setup_gpg!
 
-    [mismatches, checksums]
-  end
+          if (committer = args.committer)
+            committer = Utils.parse_author!(committer)
+            ENV["GIT_COMMITTER_NAME"] = committer[:name]
+            ENV["GIT_COMMITTER_EMAIL"] = committer[:email]
+          end
 
-  def old_checksums(formula, formula_ast, bottle_hash, args:)
-    bottle_node = formula_ast.bottle_block
-    return if bottle_node.nil?
-    return [] unless args.keep_old?
-
-    old_keys = Utils::AST.body_children(bottle_node.body).map(&:method_name)
-    old_bottle_spec = formula.bottle_specification
-    mismatches, checksums = merge_bottle_spec(old_keys, old_bottle_spec, bottle_hash["bottle"])
-    if mismatches.present?
-      odie <<~EOS
-        `--keep-old` was passed but there are changes in:
-        #{mismatches.join("\n")}
-      EOS
+          short_name = formula_name.split("/", -1).last
+          pkg_version = bottle_hash["formula"]["pkg_version"]
+
+          path.parent.cd do
+            safe_system "git", "commit", "--no-edit", "--verbose",
+                        "--message=#{short_name}: #{update_or_add} #{pkg_version} bottle.",
+                        "--", path
+          end
+        end
+      end
+
+      sig {
+        params(formula: Formula, formula_ast: Utils::AST::FormulaAST,
+               bottle_hash: T::Hash[String, T.untyped]).returns(T.nilable(T::Array[String]))
+      }
+      def old_checksums(formula, formula_ast, bottle_hash)
+        bottle_node = T.cast(formula_ast.bottle_block, T.nilable(RuboCop::AST::BlockNode))
+        return if bottle_node.nil?
+        return [] unless args.keep_old?
+
+        old_keys = T.cast(Utils::AST.body_children(bottle_node.body), T::Array[RuboCop::AST::SendNode])
+                    .map(&:method_name)
+        old_bottle_spec = formula.bottle_specification
+        mismatches, checksums = merge_bottle_spec(old_keys, old_bottle_spec, bottle_hash["bottle"])
+        if mismatches.present?
+          odie <<~EOS
+            `--keep-old` was passed but there are changes in:
+            #{mismatches.join("\n")}
+          EOS
+        end
+        checksums
+      end
     end
-    checksums
   end
 end
+
+require "extend/os/dev-cmd/bottle"
diff --git a/Library/Homebrew/dev-cmd/bump-cask-pr.rb b/Library/Homebrew/dev-cmd/bump-cask-pr.rb
index d6b1586e0bbc3..953501321c300 100644
--- a/Library/Homebrew/dev-cmd/bump-cask-pr.rb
+++ b/Library/Homebrew/dev-cmd/bump-cask-pr.rb
@@ -1,265 +1,315 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
+require "bump_version_parser"
 require "cask"
 require "cask/download"
-require "cli/parser"
 require "utils/tar"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def bump_cask_pr_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Create a pull request to update <cask> with a new version.
-
-        A best effort to determine the <SHA-256> will be made if the value is not
-        supplied by the user.
-      EOS
-      switch "-n", "--dry-run",
-             description: "Print what would be done rather than doing it."
-      switch "--write-only",
-             description: "Make the expected file modifications without taking any Git actions."
-      switch "--commit",
-             depends_on:  "--write-only",
-             description: "When passed with `--write-only`, generate a new commit after writing changes " \
-                          "to the cask file."
-      switch "--no-audit",
-             description: "Don't run `brew audit` before opening the PR."
-      switch "--online",
-             description: "Run `brew audit --online` before opening the PR."
-      switch "--no-style",
-             description: "Don't run `brew style --fix` before opening the PR."
-      switch "--no-browse",
-             description: "Print the pull request URL instead of opening in a browser."
-      switch "--no-fork",
-             description: "Don't try to fork the repository."
-      flag   "--version=",
-             description: "Specify the new <version> for the cask."
-      flag   "--message=",
-             description: "Append <message> to the default pull request message."
-      flag   "--url=",
-             description: "Specify the <URL> for the new download."
-      flag   "--sha256=",
-             description: "Specify the <SHA-256> checksum of the new download."
-      flag   "--fork-org=",
-             description: "Use the specified GitHub organization for forking."
-      switch "-f", "--force",
-             description: "Ignore duplicate open PRs."
-
-      conflicts "--dry-run", "--write"
-      conflicts "--no-audit", "--online"
-
-      named_args :cask, number: 1
-    end
-  end
+  module DevCmd
+    class BumpCaskPr < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Create a pull request to update <cask> with a new version.
+
+          A best effort to determine the <SHA-256> will be made if the value is not
+          supplied by the user.
+        EOS
+        switch "-n", "--dry-run",
+               description: "Print what would be done rather than doing it."
+        switch "--write-only",
+               description: "Make the expected file modifications without taking any Git actions."
+        switch "--commit",
+               depends_on:  "--write-only",
+               description: "When passed with `--write-only`, generate a new commit after writing changes " \
+                            "to the cask file."
+        switch "--no-audit",
+               description: "Don't run `brew audit` before opening the PR."
+        switch "--no-style",
+               description: "Don't run `brew style --fix` before opening the PR."
+        switch "--no-browse",
+               description: "Print the pull request URL instead of opening in a browser."
+        switch "--no-fork",
+               description: "Don't try to fork the repository."
+        flag   "--version=",
+               description: "Specify the new <version> for the cask."
+        flag   "--version-arm=",
+               description: "Specify the new cask <version> for the ARM architecture."
+        flag   "--version-intel=",
+               description: "Specify the new cask <version> for the Intel architecture."
+        flag   "--message=",
+               description: "Prepend <message> to the default pull request message."
+        flag   "--url=",
+               description: "Specify the <URL> for the new download."
+        flag   "--sha256=",
+               description: "Specify the <SHA-256> checksum of the new download."
+        flag   "--fork-org=",
+               description: "Use the specified GitHub organization for forking."
+
+        conflicts "--dry-run", "--write"
+        conflicts "--no-audit", "--online"
+        conflicts "--version=", "--version-arm="
+        conflicts "--version=", "--version-intel="
+
+        named_args :cask, number: 1, without_api: true
+      end
 
-  def bump_cask_pr
-    args = bump_cask_pr_args.parse
+      sig { override.void }
+      def run
+        # This will be run by `brew audit` or `brew style` later so run it first to
+        # not start spamming during normal output.
+        gem_groups = []
+        gem_groups << "style" if !args.no_audit? || !args.no_style?
+        gem_groups << "audit" unless args.no_audit?
+        Homebrew.install_bundler_gems!(groups: gem_groups) unless gem_groups.empty?
 
-    # This will be run by `brew style` later so run it first to not start
-    # spamming during normal output.
-    Homebrew.install_bundler_gems!
+        # As this command is simplifying user-run commands then let's just use a
+        # user path, too.
+        ENV["PATH"] = PATH.new(ORIGINAL_PATHS).to_s
 
-    # As this command is simplifying user-run commands then let's just use a
-    # user path, too.
-    ENV["PATH"] = PATH.new(ORIGINAL_PATHS).to_s
+        # Use the user's browser, too.
+        ENV["BROWSER"] = EnvConfig.browser
 
-    # Use the user's browser, too.
-    ENV["BROWSER"] = Homebrew::EnvConfig.browser
+        cask = args.named.to_casks.first
 
-    cask = args.named.to_casks.first
+        odie "This cask is not in a tap!" if cask.tap.blank?
+        odie "This cask's tap is not a Git repository!" unless cask.tap.git?
 
-    odie "This cask is not in a tap!" if cask.tap.blank?
-    odie "This cask's tap is not a Git repository!" unless cask.tap.git?
+        odie <<~EOS unless cask.tap.allow_bump?(cask.token)
+          Whoops, the #{cask.token} cask has its version update
+          pull requests automatically opened by BrewTestBot every ~3 hours!
+          We'd still love your contributions, though, so try another one
+          that's not in the autobump list:
+            #{Formatter.url("#{cask.tap.remote}/blob/master/.github/autobump.txt")}
+        EOS
 
-    new_version = args.version
-    new_version = :latest if ["latest", ":latest"].include?(new_version)
-    new_version = Cask::DSL::Version.new(new_version) if new_version.present?
-    new_base_url = args.url
-    new_hash = args.sha256
-    new_hash = :no_check if ["no_check", ":no_check"].include? new_hash
+        odie "You have too many PRs open: close or merge some first!" if GitHub.too_many_open_prs?(cask.tap)
 
-    if new_version.nil? && new_base_url.nil? && new_hash.nil?
-      raise UsageError, "No --version=/--url=/--sha256= argument specified!"
-    end
+        new_version = BumpVersionParser.new(
+          general: args.version,
+          intel:   args.version_intel,
+          arm:     args.version_arm,
+        )
 
-    old_version = cask.version
-    old_hash = cask.sha256
+        new_hash = unless (new_hash = args.sha256).nil?
+          raise UsageError, "`--sha256` must not be empty." if new_hash.blank?
 
-    check_open_pull_requests(cask, args: args)
+          ["no_check", ":no_check"].include?(new_hash) ? :no_check : new_hash
+        end
 
-    old_contents = File.read(cask.sourcefile_path)
+        new_base_url = unless (new_base_url = args.url).nil?
+          raise UsageError, "`--url` must not be empty." if new_base_url.blank?
 
-    replacement_pairs = []
+          begin
+            URI(new_base_url)
+          rescue URI::InvalidURIError
+            raise UsageError, "`--url` is not valid."
+          end
+        end
 
-    if new_version.present?
-      old_version_regex = old_version.latest? ? ":latest" : "[\"']#{Regexp.escape(old_version.to_s)}[\"']"
+        if new_version.blank? && new_base_url.nil? && new_hash.nil?
+          raise UsageError, "No `--version`, `--url` or `--sha256` argument specified!"
+        end
 
-      replacement_pairs << [
-        /version\s+#{old_version_regex}/m,
-        "version #{new_version.latest? ? ":latest" : "\"#{new_version}\""}",
-      ]
-    end
+        check_pull_requests(cask, new_version:)
 
-    if new_base_url.present?
-      m = /^ +url "(.+?)"\n/m.match(old_contents)
-      odie "Could not find old URL in cask!" if m.nil?
+        replacement_pairs ||= []
+        branch_name = "bump-#{cask.token}"
+        commit_message = nil
 
-      old_base_url = m.captures.first
+        old_contents = File.read(cask.sourcefile_path)
 
-      replacement_pairs << [
-        /#{Regexp.escape(old_base_url)}/,
-        new_base_url,
-      ]
-    end
+        if new_base_url
+          commit_message ||= "#{cask.token}: update URL"
 
-    if new_version.present?
-      if new_version.latest?
-        opoo "Ignoring specified `--sha256=` argument." if new_hash.present?
-        new_hash = :no_check
-      elsif new_hash.nil? || cask.languages.present?
-        tmp_contents = Utils::Inreplace.inreplace_pairs(cask.sourcefile_path,
-                                                        replacement_pairs.uniq.compact,
-                                                        read_only_run: true,
-                                                        silent:        true)
+          m = /^ +url "(.+?)"\n/m.match(old_contents)
+          odie "Could not find old URL in cask!" if m.nil?
 
-        tmp_cask = Cask::CaskLoader.load(tmp_contents)
-        tmp_config = tmp_cask.config
+          old_base_url = m.captures.fetch(0)
 
-        new_hash = fetch_cask(tmp_contents)[1] if old_hash != :no_check && new_hash.nil?
+          replacement_pairs << [
+            /#{Regexp.escape(old_base_url)}/,
+            new_base_url.to_s,
+          ]
+        end
 
-        cask.languages.each do |language|
-          lang_config = tmp_config.merge(Cask::Config.new(explicit: { languages: [language] }))
-          replacement_pairs << fetch_cask(tmp_contents, config: lang_config)
+        if new_version.present?
+          # For simplicity, our naming defers to the arm version if we multiple architectures are specified
+          branch_version = new_version.arm || new_version.general
+          if branch_version.is_a?(Cask::DSL::Version)
+            commit_version = shortened_version(branch_version, cask:)
+            branch_name = "bump-#{cask.token}-#{branch_version.tr(",:", "-")}"
+            commit_message ||= "#{cask.token} #{commit_version}"
+          end
+          replacement_pairs = replace_version_and_checksum(cask, new_hash, new_version, replacement_pairs)
         end
+        # Now that we have all replacement pairs, we will replace them further down
+
+        commit_message ||= "#{cask.token}: update checksum" if new_hash
+
+        # Remove nested arrays where elements are identical
+        replacement_pairs = replacement_pairs.reject { |pair| pair[0] == pair[1] }.uniq.compact
+        Utils::Inreplace.inreplace_pairs(cask.sourcefile_path,
+                                         replacement_pairs,
+                                         read_only_run: args.dry_run?,
+                                         silent:        args.quiet?)
+
+        run_cask_audit(cask, old_contents)
+        run_cask_style(cask, old_contents)
+
+        pr_info = {
+          branch_name:,
+          commit_message:,
+          old_contents:,
+          pr_message:      "Created with `brew bump-cask-pr`.",
+          sourcefile_path: cask.sourcefile_path,
+          tap:             cask.tap,
+        }
+        GitHub.create_bump_pr(pr_info, args:)
+      end
 
-        if tmp_contents.include?("Hardware::CPU.intel?")
-          other_intel = !Hardware::CPU.intel?
-          other_contents = tmp_contents.gsub("Hardware::CPU.intel?", other_intel.to_s)
-          other_cask = Cask::CaskLoader.load(other_contents)
+      private
 
-          if other_cask.sha256 != :no_check && other_cask.language.blank?
-            replacement_pairs << fetch_cask(other_contents)
-          end
+      sig { params(version: Cask::DSL::Version, cask: Cask::Cask).returns(Cask::DSL::Version) }
+      def shortened_version(version, cask:)
+        if version.before_comma == cask.version.before_comma
+          version
+        else
+          version.before_comma
+        end
+      end
 
-          other_cask.languages.each do |language|
-            lang_config = other_cask.config.merge(Cask::Config.new(explicit: { languages: [language] }))
-            replacement_pairs << fetch_cask(other_contents, config: lang_config)
+      sig {
+        params(
+          cask:              Cask::Cask,
+          new_hash:          T.any(NilClass, String, Symbol),
+          new_version:       BumpVersionParser,
+          replacement_pairs: T::Array[[T.any(Regexp, String), T.any(Regexp, String)]],
+        ).returns(T::Array[[T.any(Regexp, String), T.any(Regexp, String)]])
+      }
+      def replace_version_and_checksum(cask, new_hash, new_version, replacement_pairs)
+        # When blocks are absent, arch is not relevant. For consistency, we simulate the arm architecture.
+        arch_options = cask.on_system_blocks_exist? ? OnSystem::ARCH_OPTIONS : [:arm]
+        arch_options.each do |arch|
+          SimulateSystem.with(arch:) do
+            old_cask     = Cask::CaskLoader.load(cask.sourcefile_path)
+            old_version  = old_cask.version
+            bump_version = new_version.send(arch) || new_version.general
+
+            old_version_regex = old_version.latest? ? ":latest" : %Q(["']#{Regexp.escape(old_version.to_s)}["'])
+            replacement_pairs << [/version\s+#{old_version_regex}/m,
+                                  "version #{bump_version.latest? ? ":latest" : %Q("#{bump_version}")}"]
+
+            # We are replacing our version here so we can get the new hash
+            tmp_contents = Utils::Inreplace.inreplace_pairs(cask.sourcefile_path,
+                                                            replacement_pairs.uniq.compact,
+                                                            read_only_run: true,
+                                                            silent:        true)
+
+            tmp_cask = Cask::CaskLoader::FromContentLoader.new(tmp_contents)
+                                                          .load(config: nil)
+            old_hash = tmp_cask.sha256
+            if tmp_cask.version.latest? || new_hash == :no_check
+              opoo "Ignoring specified `--sha256=` argument." if new_hash.is_a?(String)
+              replacement_pairs << [/"#{old_hash}"/, ":no_check"] if old_hash != :no_check
+            elsif old_hash == :no_check && new_hash != :no_check
+              replacement_pairs << [":no_check", "\"#{new_hash}\""] if new_hash.is_a?(String)
+            elsif new_hash && !cask.on_system_blocks_exist? && cask.languages.empty?
+              replacement_pairs << [old_hash.to_s, new_hash.to_s]
+            elsif old_hash != :no_check
+              opoo "Multiple checksum replacements required; ignoring specified `--sha256` argument." if new_hash
+              languages = if cask.languages.empty?
+                [nil]
+              else
+                cask.languages
+              end
+              languages.each do |language|
+                new_cask        = Cask::CaskLoader.load(tmp_contents)
+                new_cask.config = if language.blank?
+                  tmp_cask.config
+                else
+                  tmp_cask.config.merge(Cask::Config.new(explicit: { languages: [language] }))
+                end
+                download = Cask::Download.new(new_cask, quarantine: true).fetch(verify_download_integrity: false)
+                Utils::Tar.validate_file(download)
+
+                if new_cask.sha256.to_s != download.sha256
+                  replacement_pairs << [new_cask.sha256.to_s,
+                                        download.sha256]
+                end
+              end
+            end
           end
         end
+        replacement_pairs
       end
-    end
 
-    if new_hash.present? && cask.language.blank? # avoid repeated replacement for multilanguage cask
-      hash_regex = old_hash == :no_check ? ":no_check" : "[\"']#{Regexp.escape(old_hash.to_s)}[\"']"
-
-      replacement_pairs << [
-        /sha256\s+#{hash_regex}/m,
-        "sha256 #{new_hash == :no_check ? ":no_check" : "\"#{new_hash}\""}",
-      ]
-    end
+      sig { params(cask: Cask::Cask, new_version: BumpVersionParser).void }
+      def check_pull_requests(cask, new_version:)
+        tap_remote_repo = cask.tap.full_name || cask.tap.remote_repository
 
-    Utils::Inreplace.inreplace_pairs(cask.sourcefile_path,
-                                     replacement_pairs.uniq.compact,
-                                     read_only_run: args.dry_run?,
-                                     silent:        args.quiet?)
+        file = cask.sourcefile_path.relative_path_from(cask.tap.path).to_s
+        quiet = args.quiet?
+        GitHub.check_for_duplicate_pull_requests(cask.token, tap_remote_repo,
+                                                 state: "open", file:, quiet:)
 
-    run_cask_audit(cask, old_contents, args: args)
-    run_cask_style(cask, old_contents, args: args)
+        # if we haven't already found open requests, try for an exact match across all pull requests
+        new_version.instance_variables.each do |version_type|
+          version_type_version = new_version.instance_variable_get(version_type)
+          next if version_type_version.blank?
 
-    branch_name = "bump-#{cask.token}"
-    commit_message = "Update #{cask.token}"
-    if new_version.present?
-      if new_version.before_comma != old_version.before_comma
-        new_version = new_version.before_comma
-        old_version = old_version.before_comma
+          version = shortened_version(version_type_version, cask:)
+          GitHub.check_for_duplicate_pull_requests(cask.token, tap_remote_repo, version:, file:, quiet:)
+        end
       end
-      branch_name += "-#{new_version.tr(",:", "-")}"
-      commit_message += " from #{old_version} to #{new_version}"
-    end
-    pr_info = {
-      sourcefile_path: cask.sourcefile_path,
-      old_contents:    old_contents,
-      branch_name:     branch_name,
-      commit_message:  commit_message,
-      tap:             cask.tap,
-      pr_message:      "Created with `brew bump-cask-pr`.",
-    }
-    GitHub.create_bump_pr(pr_info, args: args)
-  end
-
-  def fetch_cask(contents, config: nil)
-    cask = Cask::CaskLoader.load(contents)
-    cask.config = config if config.present?
-    old_hash = cask.sha256.to_s
-
-    cask_download = Cask::Download.new(cask, quarantine: true)
-    download = cask_download.fetch(verify_download_integrity: false)
-    Utils::Tar.validate_file(download)
-    new_hash = download.sha256
 
-    [old_hash, new_hash]
-  end
-
-  def check_open_pull_requests(cask, args:)
-    tap_remote_repo = cask.tap.remote_repo || cask.tap.full_name
-    GitHub.check_for_duplicate_pull_requests(cask.token, tap_remote_repo,
-                                             state: "open",
-                                             file:  cask.sourcefile_path.relative_path_from(cask.tap.path).to_s,
-                                             args:  args)
-  end
+      sig { params(cask: Cask::Cask, old_contents: String).void }
+      def run_cask_audit(cask, old_contents)
+        if args.dry_run?
+          if args.no_audit?
+            ohai "Skipping `brew audit`"
+          else
+            ohai "brew audit --cask --online #{cask.full_name}"
+          end
+          return
+        end
+        failed_audit = false
+        if args.no_audit?
+          ohai "Skipping `brew audit`"
+        else
+          system HOMEBREW_BREW_FILE, "audit", "--cask", "--online", cask.full_name
+          failed_audit = !$CHILD_STATUS.success?
+        end
+        return unless failed_audit
 
-  def run_cask_audit(cask, old_contents, args:)
-    if args.dry_run?
-      if args.no_audit?
-        ohai "Skipping `brew audit`"
-      elsif args.online?
-        ohai "brew audit --cask --online #{cask.sourcefile_path.basename}"
-      else
-        ohai "brew audit --cask #{cask.sourcefile_path.basename}"
+        cask.sourcefile_path.atomic_write(old_contents)
+        odie "`brew audit` failed!"
       end
-      return
-    end
-    failed_audit = false
-    if args.no_audit?
-      ohai "Skipping `brew audit`"
-    elsif args.online?
-      system HOMEBREW_BREW_FILE, "audit", "--cask", "--online", cask.sourcefile_path
-      failed_audit = !$CHILD_STATUS.success?
-    else
-      system HOMEBREW_BREW_FILE, "audit", "--cask", cask.sourcefile_path
-      failed_audit = !$CHILD_STATUS.success?
-    end
-    return unless failed_audit
 
-    cask.sourcefile_path.atomic_write(old_contents)
-    odie "`brew audit` failed!"
-  end
+      sig { params(cask: Cask::Cask, old_contents: String).void }
+      def run_cask_style(cask, old_contents)
+        if args.dry_run?
+          if args.no_style?
+            ohai "Skipping `brew style --fix`"
+          else
+            ohai "brew style --fix #{cask.sourcefile_path.basename}"
+          end
+          return
+        end
+        failed_style = false
+        if args.no_style?
+          ohai "Skipping `brew style --fix`"
+        else
+          system HOMEBREW_BREW_FILE, "style", "--fix", cask.sourcefile_path
+          failed_style = !$CHILD_STATUS.success?
+        end
+        return unless failed_style
 
-  def run_cask_style(cask, old_contents, args:)
-    if args.dry_run?
-      if args.no_style?
-        ohai "Skipping `brew style --fix`"
-      else
-        ohai "brew style --fix #{cask.sourcefile_path.basename}"
+        cask.sourcefile_path.atomic_write(old_contents)
+        odie "`brew style --fix` failed!"
       end
-      return
     end
-    failed_style = false
-    if args.no_style?
-      ohai "Skipping `brew style --fix`"
-    else
-      system HOMEBREW_BREW_FILE, "style", "--fix", cask.sourcefile_path
-      failed_style = !$CHILD_STATUS.success?
-    end
-    return unless failed_style
-
-    cask.sourcefile_path.atomic_write(old_contents)
-    odie "`brew style --fix` failed!"
   end
 end
diff --git a/Library/Homebrew/dev-cmd/bump-formula-pr.rb b/Library/Homebrew/dev-cmd/bump-formula-pr.rb
index 1ad696ceefb9d..a924c07d01a2a 100644
--- a/Library/Homebrew/dev-cmd/bump-formula-pr.rb
+++ b/Library/Homebrew/dev-cmd/bump-formula-pr.rb
@@ -1,524 +1,572 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
+require "fileutils"
 require "formula"
-require "cli/parser"
+require "utils/inreplace"
 require "utils/pypi"
 require "utils/tar"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def bump_formula_pr_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Create a pull request to update <formula> with a new URL or a new tag.
-
-        If a <URL> is specified, the <SHA-256> checksum of the new download should also
-        be specified. A best effort to determine the <SHA-256> and <formula> name will
-        be made if either or both values are not supplied by the user.
-
-        If a <tag> is specified, the Git commit <revision> corresponding to that tag
-        should also be specified. A best effort to determine the <revision> will be made
-        if the value is not supplied by the user.
-
-        If a <version> is specified, a best effort to determine the <URL> and <SHA-256> or
-        the <tag> and <revision> will be made if both values are not supplied by the user.
-
-        *Note:* this command cannot be used to transition a formula from a
-        URL-and-SHA-256 style specification into a tag-and-revision style specification,
-        nor vice versa. It must use whichever style specification the formula already uses.
-      EOS
-      switch "-n", "--dry-run",
-             description: "Print what would be done rather than doing it."
-      switch "--all",
-             description: "Read all formulae if necessary to determine URL.",
-             hidden:      true
-      switch "--write-only",
-             description: "Make the expected file modifications without taking any Git actions."
-      switch "--write", hidden: true
-      switch "--commit",
-             depends_on:  "--write-only",
-             description: "When passed with `--write-only`, generate a new commit after writing changes " \
-                          "to the formula file."
-      switch "--no-audit",
-             description: "Don't run `brew audit` before opening the PR."
-      switch "--strict",
-             description: "Run `brew audit --strict` before opening the PR."
-      switch "--online",
-             description: "Run `brew audit --online` before opening the PR."
-      switch "--no-browse",
-             description: "Print the pull request URL instead of opening in a browser."
-      switch "--no-fork",
-             description: "Don't try to fork the repository."
-      comma_array "--mirror",
-                  description: "Use the specified <URL> as a mirror URL. If <URL> is a comma-separated list " \
-                               "of URLs, multiple mirrors will be added."
-      flag   "--fork-org=",
-             description: "Use the specified GitHub organization for forking."
-      flag   "--version=",
-             description: "Use the specified <version> to override the value parsed from the URL or tag. Note " \
-                          "that `--version=0` can be used to delete an existing version override from a " \
-                          "formula if it has become redundant."
-      flag   "--message=",
-             description: "Append <message> to the default pull request message."
-      flag   "--url=",
-             description: "Specify the <URL> for the new download. If a <URL> is specified, the <SHA-256> " \
-                          "checksum of the new download should also be specified."
-      flag   "--sha256=",
-             depends_on:  "--url=",
-             description: "Specify the <SHA-256> checksum of the new download."
-      flag   "--tag=",
-             description: "Specify the new git commit <tag> for the formula."
-      flag   "--revision=",
-             description: "Specify the new commit <revision> corresponding to the specified git <tag> " \
-                          "or specified <version>."
-      switch "-f", "--force",
-             description: "Ignore duplicate open PRs. Remove all mirrors if `--mirror` was not specified."
-      flag   "--python-package-name=",
-             description: "Use the specified <package-name> when finding Python resources for <formula>. " \
-                          "If no package name is specified, it will be inferred from the formula's stable URL."
-      comma_array "--python-extra-packages=",
-                  description: "Include these additional Python packages when finding resources."
-      comma_array "--python-exclude-packages=",
-                  description: "Exclude these Python packages when finding resources."
-
-      conflicts "--dry-run", "--write-only"
-      conflicts "--dry-run", "--write"
-      conflicts "--no-audit", "--strict"
-      conflicts "--no-audit", "--online"
-      conflicts "--url", "--tag"
-      conflicts "--installed", "--all"
-
-      named_args :formula, max: 1
-    end
-  end
+  module DevCmd
+    class BumpFormulaPr < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Create a pull request to update <formula> with a new URL or a new tag.
+
+          If a <URL> is specified, the <SHA-256> checksum of the new download should also
+          be specified. A best effort to determine the <SHA-256> will be made if not supplied
+          by the user.
+
+          If a <tag> is specified, the Git commit <revision> corresponding to that tag
+          should also be specified. A best effort to determine the <revision> will be made
+          if the value is not supplied by the user.
+
+          If a <version> is specified, a best effort to determine the <URL> and <SHA-256> or
+          the <tag> and <revision> will be made if both values are not supplied by the user.
+
+          *Note:* this command cannot be used to transition a formula from a
+          URL-and-SHA-256 style specification into a tag-and-revision style specification,
+          nor vice versa. It must use whichever style specification the formula already uses.
+        EOS
+        switch "-n", "--dry-run",
+               description: "Print what would be done rather than doing it."
+        switch "--write-only",
+               description: "Make the expected file modifications without taking any Git actions."
+        switch "--commit",
+               depends_on:  "--write-only",
+               description: "When passed with `--write-only`, generate a new commit after writing changes " \
+                            "to the formula file."
+        switch "--no-audit",
+               description: "Don't run `brew audit` before opening the PR."
+        switch "--strict",
+               description: "Run `brew audit --strict` before opening the PR."
+        switch "--online",
+               description: "Run `brew audit --online` before opening the PR."
+        switch "--no-browse",
+               description: "Print the pull request URL instead of opening in a browser."
+        switch "--no-fork",
+               description: "Don't try to fork the repository."
+        comma_array "--mirror",
+                    description: "Use the specified <URL> as a mirror URL. If <URL> is a comma-separated list " \
+                                 "of URLs, multiple mirrors will be added."
+        flag   "--fork-org=",
+               description: "Use the specified GitHub organization for forking."
+        flag   "--version=",
+               description: "Use the specified <version> to override the value parsed from the URL or tag. Note " \
+                            "that `--version=0` can be used to delete an existing version override from a " \
+                            "formula if it has become redundant."
+        flag   "--message=",
+               description: "Prepend <message> to the default pull request message."
+        flag   "--url=",
+               description: "Specify the <URL> for the new download. If a <URL> is specified, the <SHA-256> " \
+                            "checksum of the new download should also be specified."
+        flag   "--sha256=",
+               depends_on:  "--url=",
+               description: "Specify the <SHA-256> checksum of the new download."
+        flag   "--tag=",
+               description: "Specify the new git commit <tag> for the formula."
+        flag   "--revision=",
+               description: "Specify the new commit <revision> corresponding to the specified git <tag> " \
+                            "or specified <version>."
+        switch "-f", "--force",
+               description: "Remove all mirrors if `--mirror` was not specified."
+        switch "--install-dependencies",
+               description: "Install missing dependencies required to update resources."
+        flag   "--python-package-name=",
+               description: "Use the specified <package-name> when finding Python resources for <formula>. " \
+                            "If no package name is specified, it will be inferred from the formula's stable URL."
+        comma_array "--python-extra-packages=",
+                    description: "Include these additional Python packages when finding resources."
+        comma_array "--python-exclude-packages=",
+                    description: "Exclude these Python packages when finding resources."
+
+        conflicts "--dry-run", "--write-only"
+        conflicts "--no-audit", "--strict"
+        conflicts "--no-audit", "--online"
+        conflicts "--url", "--tag"
+
+        named_args :formula, max: 1, without_api: true
+      end
 
-  def bump_formula_pr
-    args = bump_formula_pr_args.parse
+      sig { override.void }
+      def run
+        if args.revision.present? && args.tag.nil? && args.version.nil?
+          raise UsageError, "`--revision` must be passed with either `--tag` or `--version`!"
+        end
 
-    odisabled "`brew bump-formula-pr --write`", "`brew bump-formula-pr --write-only`" if args.write?
+        # As this command is simplifying user-run commands then let's just use a
+        # user path, too.
+        ENV["PATH"] = PATH.new(ORIGINAL_PATHS).to_s
 
-    if args.revision.present? && args.tag.nil? && args.version.nil?
-      raise UsageError, "`--revision` must be passed with either `--tag` or `--version`!"
-    end
+        # Use the user's browser, too.
+        ENV["BROWSER"] = Homebrew::EnvConfig.browser
 
-    # As this command is simplifying user-run commands then let's just use a
-    # user path, too.
-    ENV["PATH"] = PATH.new(ORIGINAL_PATHS).to_s
+        formula = args.named.to_formulae.first
+        new_url = args.url
+        raise FormulaUnspecifiedError if formula.blank?
 
-    # Use the user's browser, too.
-    ENV["BROWSER"] = Homebrew::EnvConfig.browser
+        odie "This formula is disabled!" if formula.disabled?
+        odie "This formula is deprecated and does not build!" if formula.deprecation_reason == :does_not_build
+        odie "This formula is not in a tap!" if formula.tap.blank?
+        odie "This formula's tap is not a Git repository!" unless formula.tap.git?
 
-    formula = args.named.to_formulae.first
+        odie <<~EOS unless formula.tap.allow_bump?(formula.name)
+          Whoops, the #{formula.name} formula has its version update
+          pull requests automatically opened by BrewTestBot every ~3 hours!
+          We'd still love your contributions, though, so try another one
+          that's not in the autobump list:
+            #{Formatter.url("#{formula.tap.remote}/blob/master/.github/autobump.txt")}
+        EOS
 
-    new_url = args.url
-    formula ||= determine_formula_from_url(new_url) if new_url.present?
-    raise FormulaUnspecifiedError if formula.blank?
+        odie "You have too many PRs open: close or merge some first!" if GitHub.too_many_open_prs?(formula.tap)
 
-    odie "This formula is disabled!" if formula.disabled?
-    odie "This formula is deprecated and does not build!" if formula.deprecation_reason == :does_not_build
-    odie "This formula is not in a tap!" if formula.tap.blank?
-    odie "This formula's tap is not a Git repository!" unless formula.tap.git?
+        formula_spec = formula.stable
+        odie "#{formula}: no stable specification found!" if formula_spec.blank?
 
-    formula_spec = formula.stable
-    odie "#{formula}: no stable specification found!" if formula_spec.blank?
+        # This will be run by `brew audit` later so run it first to not start
+        # spamming during normal output.
+        Homebrew.install_bundler_gems!(groups: ["audit", "style"]) unless args.no_audit?
 
-    # This will be run by `brew audit` later so run it first to not start
-    # spamming during normal output.
-    Homebrew.install_bundler_gems!
+        tap_remote_repo = formula.tap.remote_repository
+        remote = "origin"
+        remote_branch = formula.tap.git_repository.origin_branch_name
+        previous_branch = "-"
 
-    tap_remote_repo = formula.tap.remote_repo
-    remote = "origin"
-    remote_branch = formula.tap.path.git_origin_branch
-    previous_branch = "-"
+        check_pull_requests(formula, tap_remote_repo, state: "open")
 
-    check_open_pull_requests(formula, tap_remote_repo, args: args)
+        new_version = args.version
+        check_new_version(formula, tap_remote_repo, version: new_version) if new_version.present?
 
-    new_version = args.version
-    check_new_version(formula, tap_remote_repo, version: new_version, args: args) if new_version.present?
+        opoo "This formula has patches that may be resolved upstream." if formula.patchlist.present?
+        if formula.resources.any? { |resource| !resource.name.start_with?("homebrew-") }
+          opoo "This formula has resources that may need to be updated."
+        end
 
-    opoo "This formula has patches that may be resolved upstream." if formula.patchlist.present?
-    if formula.resources.any? { |resource| !resource.name.start_with?("homebrew-") }
-      opoo "This formula has resources that may need to be updated."
-    end
+        old_mirrors = formula_spec.mirrors
+        new_mirrors ||= args.mirror
+        if new_url.present? && (new_mirror = determine_mirror(new_url))
+          new_mirrors ||= [new_mirror]
+          check_for_mirrors(formula.name, old_mirrors, new_mirrors)
+        end
 
-    old_mirrors = formula_spec.mirrors
-    new_mirrors ||= args.mirror
-    new_mirror ||= determine_mirror(new_url)
-    new_mirrors ||= [new_mirror] if new_mirror.present?
-
-    check_for_mirrors(formula, old_mirrors, new_mirrors, args: args) if new_url.present?
-
-    old_hash = formula_spec.checksum&.hexdigest
-    new_hash = args.sha256
-    new_tag = args.tag
-    new_revision = args.revision
-    old_url = formula_spec.url
-    old_tag = formula_spec.specs[:tag]
-    old_formula_version = formula_version(formula)
-    old_version = old_formula_version.to_s
-    forced_version = new_version.present?
-    new_url_hash = if new_url.present? && new_hash.present?
-      check_new_version(formula, tap_remote_repo, url: new_url, args: args) if new_version.blank?
-      true
-    elsif new_tag.present? && new_revision.present?
-      check_new_version(formula, tap_remote_repo, url: old_url, tag: new_tag, args: args) if new_version.blank?
-      false
-    elsif old_hash.blank?
-      if new_tag.blank? && new_version.blank? && new_revision.blank?
-        raise UsageError, "#{formula}: no --tag= or --version= argument specified!"
-      end
+        old_hash = formula_spec.checksum&.hexdigest
+        new_hash = args.sha256
+        new_tag = args.tag
+        new_revision = args.revision
+        old_url = formula_spec.url
+        old_tag = formula_spec.specs[:tag]
+        old_formula_version = formula_version(formula)
+        old_version = old_formula_version.to_s
+        forced_version = new_version.present?
+        new_url_hash = if new_url.present? && new_hash.present?
+          check_new_version(formula, tap_remote_repo, url: new_url) if new_version.blank?
+          true
+        elsif new_tag.present? && new_revision.present?
+          check_new_version(formula, tap_remote_repo, url: old_url, tag: new_tag) if new_version.blank?
+          false
+        elsif old_hash.blank?
+          if new_tag.blank? && new_version.blank? && new_revision.blank?
+            raise UsageError, "#{formula}: no `--tag` or `--version` argument specified!"
+          end
 
-      if old_tag.present?
-        new_tag ||= old_tag.gsub(old_version, new_version)
-        if new_tag == old_tag
-          odie <<~EOS
-            You need to bump this formula manually since the new tag
-            and old tag are both #{new_tag}.
-          EOS
+          if old_tag.present?
+            new_tag ||= old_tag.gsub(old_version, new_version)
+            if new_tag == old_tag
+              odie <<~EOS
+                You need to bump this formula manually since the new tag
+                and old tag are both #{new_tag}.
+              EOS
+            end
+            check_new_version(formula, tap_remote_repo, url: old_url, tag: new_tag) if new_version.blank?
+            resource_path, forced_version = fetch_resource_and_forced_version(formula, new_version, old_url,
+                                                                              tag: new_tag)
+            new_revision = Utils.popen_read("git", "-C", resource_path.to_s, "rev-parse", "-q", "--verify", "HEAD")
+            new_revision = new_revision.strip
+          elsif new_revision.blank?
+            odie "#{formula}: the current URL requires specifying a `--revision=` argument."
+          end
+          false
+        elsif new_url.blank? && new_version.blank?
+          raise UsageError, "#{formula}: no `--url` or `--version` argument specified!"
+        else
+          return unless new_version.present?
+
+          new_url ||= PyPI.update_pypi_url(old_url, new_version)
+          if new_url.blank?
+            new_url = update_url(old_url, old_version, new_version)
+            if new_mirrors.blank? && old_mirrors.present?
+              new_mirrors = old_mirrors.map do |old_mirror|
+                update_url(old_mirror, old_version, new_version)
+              end
+            end
+          end
+          if new_url == old_url
+            odie <<~EOS
+              You need to bump this formula manually since the new URL
+              and old URL are both:
+                #{new_url}
+            EOS
+          end
+          check_new_version(formula, tap_remote_repo, url: new_url) if new_version.blank?
+          resource_path, forced_version = fetch_resource_and_forced_version(formula, new_version, new_url)
+          Utils::Tar.validate_file(resource_path)
+          new_hash = resource_path.sha256
         end
-        check_new_version(formula, tap_remote_repo, url: old_url, tag: new_tag, args: args) if new_version.blank?
-        resource_path, forced_version = fetch_resource(formula, new_version, old_url, tag: new_tag)
-        new_revision = Utils.popen_read("git", "-C", resource_path.to_s, "rev-parse", "-q", "--verify", "HEAD")
-        new_revision = new_revision.strip
-      elsif new_revision.blank?
-        odie "#{formula}: the current URL requires specifying a `--revision=` argument."
-      end
-      false
-    elsif new_url.blank? && new_version.blank?
-      raise UsageError, "#{formula}: no --url= or --version= argument specified!"
-    else
-      new_url ||= PyPI.update_pypi_url(old_url, new_version)
-      if new_url.blank?
-        new_url = old_url.gsub(old_version, new_version)
-        if new_mirrors.blank? && old_mirrors.present?
-          new_mirrors = old_mirrors.map do |old_mirror|
-            old_mirror.gsub(old_version, new_version)
+
+        replacement_pairs = []
+        if formula.revision.nonzero?
+          replacement_pairs << [
+            /^  revision \d+\n(\n(  head "))?/m,
+            "\\2",
+          ]
+        end
+
+        replacement_pairs += formula_spec.mirrors.map do |mirror|
+          [
+            / +mirror "#{Regexp.escape(mirror)}"\n/m,
+            "",
+          ]
+        end
+
+        replacement_pairs += if new_url_hash.present?
+          [
+            [
+              /#{Regexp.escape(formula_spec.url)}/,
+              new_url,
+            ],
+            [
+              old_hash,
+              new_hash,
+            ],
+          ]
+        elsif new_tag.present?
+          [
+            [
+              /tag:(\s+")#{formula_spec.specs[:tag]}(?=")/,
+              "tag:\\1#{new_tag}\\2",
+            ],
+            [
+              formula_spec.specs[:revision],
+              new_revision,
+            ],
+          ]
+        elsif new_url.present?
+          [
+            [
+              /#{Regexp.escape(formula_spec.url)}/,
+              new_url,
+            ],
+            [
+              formula_spec.specs[:revision],
+              new_revision,
+            ],
+          ]
+        else
+          [
+            [
+              formula_spec.specs[:revision],
+              new_revision,
+            ],
+          ]
+        end
+
+        old_contents = formula.path.read
+
+        if new_mirrors.present? && new_url.present?
+          replacement_pairs << [
+            /^( +)(url "#{Regexp.escape(new_url)}"[^\n]*?\n)/m,
+            "\\1\\2\\1mirror \"#{new_mirrors.join("\"\n\\1mirror \"")}\"\n",
+          ]
+        end
+
+        if forced_version && new_version != "0"
+          replacement_pairs << if old_contents.include?("version \"#{old_formula_version}\"")
+            [
+              "version \"#{old_formula_version}\"",
+              "version \"#{new_version}\"",
+            ]
+          elsif new_mirrors.present?
+            [
+              /^( +)(mirror "#{Regexp.escape(new_mirrors.last)}"\n)/m,
+              "\\1\\2\\1version \"#{new_version}\"\n",
+            ]
+          elsif new_url.present?
+            [
+              /^( +)(url "#{Regexp.escape(new_url)}"[^\n]*?\n)/m,
+              "\\1\\2\\1version \"#{new_version}\"\n",
+            ]
+          elsif new_revision.present?
+            [
+              /^( {2})( +)(:revision => "#{new_revision}"\n)/m,
+              "\\1\\2\\3\\1version \"#{new_version}\"\n",
+            ]
           end
+        elsif forced_version && new_version == "0"
+          replacement_pairs << [
+            /^  version "[\w.\-+]+"\n/m,
+            "",
+          ]
         end
-      end
-      if new_url == old_url
-        odie <<~EOS
-          You need to bump this formula manually since the new URL
-          and old URL are both:
-            #{new_url}
-        EOS
-      end
-      check_new_version(formula, tap_remote_repo, url: new_url, args: args) if new_version.blank?
-      resource_path, forced_version = fetch_resource(formula, new_version, new_url)
-      Utils::Tar.validate_file(resource_path)
-      new_hash = resource_path.sha256
-    end
+        new_contents = Utils::Inreplace.inreplace_pairs(formula.path,
+                                                        replacement_pairs.uniq.compact,
+                                                        read_only_run: args.dry_run?,
+                                                        silent:        args.quiet?)
 
-    replacement_pairs = []
-    if formula.revision.nonzero?
-      replacement_pairs << [
-        /^  revision \d+\n(\n(  head "))?/m,
-        "\\2",
-      ]
-    end
+        new_formula_version = formula_version(formula, new_contents)
 
-    replacement_pairs += formula_spec.mirrors.map do |mirror|
-      [
-        / +mirror "#{Regexp.escape(mirror)}"\n/m,
-        "",
-      ]
-    end
+        if new_formula_version < old_formula_version
+          formula.path.atomic_write(old_contents) unless args.dry_run?
+          odie <<~EOS
+            You need to bump this formula manually since changing the version
+            from #{old_formula_version} to #{new_formula_version} would be a downgrade.
+          EOS
+        elsif new_formula_version == old_formula_version
+          formula.path.atomic_write(old_contents) unless args.dry_run?
+          odie <<~EOS
+            You need to bump this formula manually since the new version
+            and old version are both #{new_formula_version}.
+          EOS
+        end
 
-    replacement_pairs += if new_url_hash.present?
-      [
-        [
-          /#{Regexp.escape(formula_spec.url)}/,
-          new_url,
-        ],
-        [
-          old_hash,
-          new_hash,
-        ],
-      ]
-    elsif new_tag.present?
-      [
-        [
-          /#{formula_spec.specs[:tag]}(?=")/,
-          new_tag,
-        ],
-        [
-          formula_spec.specs[:revision],
-          new_revision,
-        ],
-      ]
-    elsif new_url.present?
-      [
-        [
-          /#{Regexp.escape(formula_spec.url)}/,
-          new_url,
-        ],
-        [
-          formula_spec.specs[:revision],
-          new_revision,
-        ],
-      ]
-    else
-      [
-        [
-          formula_spec.specs[:revision],
-          new_revision,
-        ],
-      ]
-    end
+        alias_rename = alias_update_pair(formula, new_formula_version)
+        if alias_rename.present?
+          ohai "Renaming alias #{alias_rename.first} to #{alias_rename.last}"
+          alias_rename.map! { |a| formula.tap.alias_dir/a }
+        end
 
-    old_contents = formula.path.read
+        unless args.dry_run?
+          resources_checked = PyPI.update_python_resources! formula,
+                                                            version:                  new_formula_version.to_s,
+                                                            package_name:             args.python_package_name,
+                                                            extra_packages:           args.python_extra_packages,
+                                                            exclude_packages:         args.python_exclude_packages,
+                                                            install_dependencies:     args.install_dependencies?,
+                                                            silent:                   args.quiet?,
+                                                            ignore_non_pypi_packages: true
+        end
 
-    if new_mirrors.present?
-      replacement_pairs << [
-        /^( +)(url "#{Regexp.escape(new_url)}"[^\n]*?\n)/m,
-        "\\1\\2\\1mirror \"#{new_mirrors.join("\"\n\\1mirror \"")}\"\n",
-      ]
-    end
+        run_audit(formula, alias_rename, old_contents)
 
-    if forced_version && new_version != "0"
-      replacement_pairs << if old_contents.include?("version \"#{old_formula_version}\"")
-        [
-          "version \"#{old_formula_version}\"",
-          "version \"#{new_version}\"",
-        ]
-      elsif new_mirrors.present?
-        [
-          /^( +)(mirror "#{Regexp.escape(new_mirrors.last)}"\n)/m,
-          "\\1\\2\\1version \"#{new_version}\"\n",
-        ]
-      elsif new_url.present?
-        [
-          /^( +)(url "#{Regexp.escape(new_url)}"[^\n]*?\n)/m,
-          "\\1\\2\\1version \"#{new_version}\"\n",
-        ]
-      elsif new_revision.present?
-        [
-          /^( {2})( +)(:revision => "#{new_revision}"\n)/m,
-          "\\1\\2\\3\\1version \"#{new_version}\"\n",
-        ]
-      end
-    elsif forced_version && new_version == "0"
-      replacement_pairs << [
-        /^  version "[\w.\-+]+"\n/m,
-        "",
-      ]
-    end
-    new_contents = Utils::Inreplace.inreplace_pairs(formula.path,
-                                                    replacement_pairs.uniq.compact,
-                                                    read_only_run: args.dry_run?,
-                                                    silent:        args.quiet?)
-
-    new_formula_version = formula_version(formula, new_contents)
-
-    if new_formula_version < old_formula_version
-      formula.path.atomic_write(old_contents) unless args.dry_run?
-      odie <<~EOS
-        You need to bump this formula manually since changing the version
-        from #{old_formula_version} to #{new_formula_version} would be a downgrade.
-      EOS
-    elsif new_formula_version == old_formula_version
-      formula.path.atomic_write(old_contents) unless args.dry_run?
-      odie <<~EOS
-        You need to bump this formula manually since the new version
-        and old version are both #{new_formula_version}.
-      EOS
-    end
+        pr_message = "Created with `brew bump-formula-pr`."
+        if resources_checked.nil? && formula.resources.any? { |resource| !resource.name.start_with?("homebrew-") }
+          pr_message += <<~EOS
 
-    alias_rename = alias_update_pair(formula, new_formula_version)
-    if alias_rename.present?
-      ohai "Renaming alias #{alias_rename.first} to #{alias_rename.last}"
-      alias_rename.map! { |a| formula.tap.alias_dir/a }
-    end
 
-    unless args.dry_run?
-      resources_checked = PyPI.update_python_resources! formula,
-                                                        version:                  new_formula_version,
-                                                        package_name:             args.python_package_name,
-                                                        extra_packages:           args.python_extra_packages,
-                                                        exclude_packages:         args.python_exclude_packages,
-                                                        silent:                   args.quiet?,
-                                                        ignore_non_pypi_packages: true
-    end
+            - [ ] `resource` blocks have been checked for updates.
+          EOS
+        end
 
-    run_audit(formula, alias_rename, old_contents, args: args)
+        if new_url =~ %r{^https://github\.com/([\w-]+)/([\w-]+)/archive/refs/tags/(v?[.0-9]+)\.tar\.}
+          owner = Regexp.last_match(1)
+          repo = Regexp.last_match(2)
+          tag = Regexp.last_match(3)
+          github_release_data = begin
+            GitHub::API.open_rest("#{GitHub::API_URL}/repos/#{owner}/#{repo}/releases/tags/#{tag}")
+          rescue GitHub::API::HTTPNotFoundError
+            # If this is a 404: we can't do anything.
+            nil
+          end
 
-    pr_message = "Created with `brew bump-formula-pr`."
-    if resources_checked.nil? && formula.resources.any? { |resource| !resource.name.start_with?("homebrew-") }
-      pr_message += <<~EOS
+          if github_release_data.present?
+            pre = "pre" if github_release_data["prerelease"].present?
+            pr_message += <<~XML
+              <details>
+                <summary>#{pre}release notes</summary>
+                <pre>#{github_release_data["body"]}</pre>
+              </details>
+            XML
+          end
+        end
 
+        pr_info = {
+          sourcefile_path:  formula.path,
+          old_contents:,
+          additional_files: alias_rename,
+          remote:,
+          remote_branch:,
+          branch_name:      "bump-#{formula.name}-#{new_formula_version}",
+          commit_message:   "#{formula.name} #{new_formula_version}",
+          previous_branch:,
+          tap:              formula.tap,
+          tap_remote_repo:,
+          pr_message:,
+        }
+        GitHub.create_bump_pr(pr_info, args:)
+      end
 
-        `resource` blocks may require updates.
-      EOS
-    end
+      private
+
+      sig { params(url: String).returns(T.nilable(String)) }
+      def determine_mirror(url)
+        case url
+        when %r{.*ftp\.gnu\.org/gnu.*}
+          url.sub "ftp.gnu.org/gnu", "ftpmirror.gnu.org"
+        when %r{.*download\.savannah\.gnu\.org/*}
+          url.sub "download.savannah.gnu.org", "download-mirror.savannah.gnu.org"
+        when %r{.*www\.apache\.org/dyn/closer\.lua\?path=.*}
+          url.sub "www.apache.org/dyn/closer.lua?path=", "archive.apache.org/dist/"
+        when %r{.*mirrors\.ocf\.berkeley\.edu/debian.*}
+          url.sub "mirrors.ocf.berkeley.edu/debian", "mirrorservice.org/sites/ftp.debian.org/debian"
+        end
+      end
 
-    pr_info = {
-      sourcefile_path:  formula.path,
-      old_contents:     old_contents,
-      additional_files: alias_rename,
-      remote:           remote,
-      remote_branch:    remote_branch,
-      branch_name:      "bump-#{formula.name}-#{new_formula_version}",
-      commit_message:   "#{formula.name} #{new_formula_version}",
-      previous_branch:  previous_branch,
-      tap:              formula.tap,
-      tap_remote_repo:  tap_remote_repo,
-      pr_message:       pr_message,
-    }
-    GitHub.create_bump_pr(pr_info, args: args)
-  end
+      sig { params(formula: String, old_mirrors: T::Array[String], new_mirrors: T::Array[String]).void }
+      def check_for_mirrors(formula, old_mirrors, new_mirrors)
+        return if new_mirrors.present? || old_mirrors.empty?
 
-  def determine_formula_from_url(url)
-    # Split the new URL on / and find any formulae that have the same URL
-    # except for the last component, but don't try to match any more than the
-    # first five components since sometimes the last component isn't the only
-    # one to change.
-    url_split = url.split("/")
-    maximum_url_components_to_match = 5
-    components_to_match = [url_split.count - 1, maximum_url_components_to_match].min
-    base_url = url_split.first(components_to_match).join("/")
-    base_url = /#{Regexp.escape(base_url)}/
-    guesses = []
-    # TODO: 3.6.0: odeprecate not specifying args.all?
-    Formula.all.each do |f|
-      guesses << f if f.stable&.url&.match(base_url)
-    end
-    return guesses.shift if guesses.count == 1
-    return if guesses.count <= 1
+        if args.force?
+          opoo "#{formula}: Removing all mirrors because a `--mirror=` argument was not specified."
+        else
+          odie <<~EOS
+            #{formula}: a `--mirror=` argument for updating the mirror URL(s) was not specified.
+            Use `--force` to remove all mirrors.
+          EOS
+        end
+      end
 
-    odie "Couldn't guess formula for sure; could be one of these:\n#{guesses.map(&:name).join(", ")}"
-  end
+      sig { params(old_url: String, old_version: String, new_version: String).returns(String) }
+      def update_url(old_url, old_version, new_version)
+        new_url = old_url.gsub(old_version, new_version)
+        return new_url if (old_version_parts = old_version.split(".")).length < 2
+        return new_url if (new_version_parts = new_version.split(".")).length != old_version_parts.length
 
-  def determine_mirror(url)
-    case url
-    when %r{.*ftp\.gnu\.org/gnu.*}
-      url.sub "ftp.gnu.org/gnu", "ftpmirror.gnu.org"
-    when %r{.*download\.savannah\.gnu\.org/*}
-      url.sub "download.savannah.gnu.org", "download-mirror.savannah.gnu.org"
-    when %r{.*www\.apache\.org/dyn/closer\.lua\?path=.*}
-      url.sub "www.apache.org/dyn/closer.lua?path=", "archive.apache.org/dist/"
-    when %r{.*mirrors\.ocf\.berkeley\.edu/debian.*}
-      url.sub "mirrors.ocf.berkeley.edu/debian", "mirrorservice.org/sites/ftp.debian.org/debian"
-    end
-  end
+        partial_old_version = old_version_parts[0..-2]&.join(".")
+        partial_new_version = new_version_parts[0..-2]&.join(".")
+        return new_url if partial_old_version.blank? || partial_new_version.blank?
 
-  def check_for_mirrors(formula, old_mirrors, new_mirrors, args:)
-    return if new_mirrors.present? || old_mirrors.empty?
+        new_url.gsub(%r{/(v?)#{Regexp.escape(partial_old_version)}/}, "/\\1#{partial_new_version}/")
+      end
 
-    if args.force?
-      opoo "#{formula}: Removing all mirrors because a `--mirror=` argument was not specified."
-    else
-      odie <<~EOS
-        #{formula}: a `--mirror=` argument for updating the mirror URL(s) was not specified.
-        Use `--force` to remove all mirrors.
-      EOS
-    end
-  end
+      sig {
+        params(formula: Formula, new_version: T.nilable(String), url: String,
+               specs: String).returns(T::Array[T.untyped])
+      }
+      def fetch_resource_and_forced_version(formula, new_version, url, **specs)
+        resource = Resource.new
+        resource.url(url, **specs)
+        resource.owner = Resource.new(formula.name)
+        forced_version = new_version && new_version != resource.version.to_s
+        resource.version(new_version) if forced_version
+        odie "Couldn't identify version, specify it using `--version=`." if resource.version.blank?
+        [resource.fetch, forced_version]
+      end
 
-  def fetch_resource(formula, new_version, url, **specs)
-    resource = Resource.new
-    resource.url(url, specs)
-    resource.owner = Resource.new(formula.name)
-    forced_version = new_version && new_version != resource.version
-    resource.version = new_version if forced_version
-    odie "Couldn't identify version, specify it using `--version=`." if resource.version.blank?
-    [resource.fetch, forced_version]
-  end
+      sig { params(formula: Formula, contents: T.nilable(String)).returns(Version) }
+      def formula_version(formula, contents = nil)
+        spec = :stable
+        name = formula.name
+        path = formula.path
+        if contents.present?
+          Formulary.from_contents(name, path, contents, spec).version
+        else
+          Formulary::FormulaLoader.new(name, path).get_formula(spec).version
+        end
+      end
 
-  def formula_version(formula, contents = nil)
-    spec = :stable
-    name = formula.name
-    path = formula.path
-    if contents.present?
-      Formulary.from_contents(name, path, contents, spec).version
-    else
-      Formulary::FormulaLoader.new(name, path).get_formula(spec).version
-    end
-  end
+      sig {
+        params(formula: Formula, tap_remote_repo: String, state: T.nilable(String),
+               version: T.nilable(String)).void
+      }
+      def check_pull_requests(formula, tap_remote_repo, state: nil, version: nil)
+        tap = formula.tap
+        return if tap.nil?
+
+        # if we haven't already found open requests, try for an exact match across all pull requests
+        GitHub.check_for_duplicate_pull_requests(
+          formula.name, tap_remote_repo,
+          version:,
+          state:,
+          file:    formula.path.relative_path_from(tap.path).to_s,
+          quiet:   args.quiet?
+        )
+      end
 
-  def check_open_pull_requests(formula, tap_remote_repo, args:)
-    GitHub.check_for_duplicate_pull_requests(formula.name, tap_remote_repo,
-                                             state: "open",
-                                             file:  formula.path.relative_path_from(formula.tap.path).to_s,
-                                             args:  args)
-  end
+      sig {
+        params(formula: Formula, tap_remote_repo: String, version: T.nilable(String), url: T.nilable(String),
+               tag: T.nilable(String)).void
+      }
+      def check_new_version(formula, tap_remote_repo, version: nil, url: nil, tag: nil)
+        if version.nil?
+          specs = {}
+          specs[:tag] = tag if tag.present?
+          return if url.blank?
+
+          version = Version.detect(url, **specs).to_s
+          return if version.blank?
+        end
 
-  def check_new_version(formula, tap_remote_repo, args:, version: nil, url: nil, tag: nil)
-    if version.nil?
-      specs = {}
-      specs[:tag] = tag if tag.present?
-      version = Version.detect(url, **specs)
-      return if version.null?
-    end
+        check_throttle(formula, version)
+        check_pull_requests(formula, tap_remote_repo, version:)
+      end
 
-    check_throttle(formula, version)
-    check_closed_pull_requests(formula, tap_remote_repo, args: args, version: version)
-  end
+      sig { params(formula: Formula, new_version: String).void }
+      def check_throttle(formula, new_version)
+        tap = formula.tap
+        return if tap.nil?
 
-  def check_throttle(formula, new_version)
-    throttled_rate = formula.tap.audit_exceptions.dig(:throttled_formulae, formula.name)
-    return if throttled_rate.blank?
+        throttled_rate = formula.livecheck.throttle
+        return if throttled_rate.blank?
 
-    formula_suffix = Version.new(new_version).patch.to_i
-    return if formula_suffix.modulo(throttled_rate).zero?
+        formula_suffix = Version.new(new_version).patch.to_i
+        return if formula_suffix.modulo(throttled_rate).zero?
 
-    odie "#{formula} should only be updated every #{throttled_rate} releases on multiples of #{throttled_rate}"
-  end
+        odie "#{formula} should only be updated every #{throttled_rate} releases on multiples of #{throttled_rate}"
+      end
 
-  def check_closed_pull_requests(formula, tap_remote_repo, args:, version:)
-    # if we haven't already found open requests, try for an exact match across closed requests
-    GitHub.check_for_duplicate_pull_requests(formula.name, tap_remote_repo,
-                                             version: version,
-                                             state:   "closed",
-                                             file:    formula.path.relative_path_from(formula.tap.path).to_s,
-                                             args:    args)
-  end
+      sig { params(formula: Formula, new_formula_version: Version).returns(T.nilable(T::Array[String])) }
+      def alias_update_pair(formula, new_formula_version)
+        versioned_alias = formula.aliases.grep(/^.*@\d+(\.\d+)?$/).first
+        return if versioned_alias.nil?
 
-  def alias_update_pair(formula, new_formula_version)
-    versioned_alias = formula.aliases.grep(/^.*@\d+(\.\d+)?$/).first
-    return if versioned_alias.nil?
+        name, old_alias_version = versioned_alias.split("@")
+        return if old_alias_version.blank?
 
-    name, old_alias_version = versioned_alias.split("@")
-    new_alias_regex = (old_alias_version.split(".").length == 1) ? /^\d+/ : /^\d+\.\d+/
-    new_alias_version, = *new_formula_version.to_s.match(new_alias_regex)
-    return if Version.create(new_alias_version) <= Version.create(old_alias_version)
+        new_alias_regex = (old_alias_version.split(".").length == 1) ? /^\d+/ : /^\d+\.\d+/
+        new_alias_version, = *new_formula_version.to_s.match(new_alias_regex)
+        return if new_alias_version.blank?
+        return if Version.new(new_alias_version) <= Version.new(old_alias_version)
 
-    [versioned_alias, "#{name}@#{new_alias_version}"]
-  end
+        [versioned_alias, "#{name}@#{new_alias_version}"]
+      end
+
+      sig { params(formula: Formula, alias_rename: T.nilable(T::Array[String]), old_contents: String).void }
+      def run_audit(formula, alias_rename, old_contents)
+        audit_args = ["--formula"]
+        audit_args << "--strict" if args.strict?
+        audit_args << "--online" if args.online?
+        if args.dry_run?
+          if args.no_audit?
+            ohai "Skipping `brew audit`"
+          elsif audit_args.present?
+            ohai "brew audit #{audit_args.join(" ")} #{formula.path.basename}"
+          else
+            ohai "brew audit #{formula.path.basename}"
+          end
+          return
+        end
+        if alias_rename && (source = alias_rename.first) && (destination = alias_rename.last)
+          FileUtils.mv source, destination
+        end
+        failed_audit = false
+        if args.no_audit?
+          ohai "Skipping `brew audit`"
+        elsif audit_args.present?
+          system HOMEBREW_BREW_FILE, "audit", *audit_args, formula.full_name
+          failed_audit = !$CHILD_STATUS.success?
+        else
+          system HOMEBREW_BREW_FILE, "audit", formula.full_name
+          failed_audit = !$CHILD_STATUS.success?
+        end
+        return unless failed_audit
 
-  def run_audit(formula, alias_rename, old_contents, args:)
-    audit_args = ["--formula"]
-    audit_args << "--strict" if args.strict?
-    audit_args << "--online" if args.online?
-    if args.dry_run?
-      if args.no_audit?
-        ohai "Skipping `brew audit`"
-      elsif audit_args.present?
-        ohai "brew audit #{audit_args.join(" ")} #{formula.path.basename}"
-      else
-        ohai "brew audit #{formula.path.basename}"
+        formula.path.atomic_write(old_contents)
+        if alias_rename && (source = alias_rename.first) && (destination = alias_rename.last)
+          FileUtils.mv source, destination
+        end
+        odie "`brew audit` failed!"
       end
-      return
-    end
-    FileUtils.mv alias_rename.first, alias_rename.last if alias_rename.present?
-    failed_audit = false
-    if args.no_audit?
-      ohai "Skipping `brew audit`"
-    elsif audit_args.present?
-      system HOMEBREW_BREW_FILE, "audit", *audit_args, formula.path
-      failed_audit = !$CHILD_STATUS.success?
-    else
-      system HOMEBREW_BREW_FILE, "audit", formula.path
-      failed_audit = !$CHILD_STATUS.success?
     end
-    return unless failed_audit
-
-    formula.path.atomic_write(old_contents)
-    FileUtils.mv alias_rename.last, alias_rename.first if alias_rename.present?
-    odie "`brew audit` failed!"
   end
 end
diff --git a/Library/Homebrew/dev-cmd/bump-revision.rb b/Library/Homebrew/dev-cmd/bump-revision.rb
index 897d8e67cb080..dd2034257b85b 100644
--- a/Library/Homebrew/dev-cmd/bump-revision.rb
+++ b/Library/Homebrew/dev-cmd/bump-revision.rb
@@ -1,78 +1,75 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
+  module DevCmd
+    class BumpRevision < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Create a commit to increment the revision of <formula>. If no revision is
+          present, "revision 1" will be added.
+        EOS
+        switch "-n", "--dry-run",
+               description: "Print what would be done rather than doing it."
+        switch "--remove-bottle-block",
+               description: "Remove the bottle block in addition to bumping the revision."
+        switch "--write-only",
+               description: "Make the expected file modifications without taking any Git actions."
+        flag   "--message=",
+               description: "Append <message> to the default commit message."
 
-  module_function
+        conflicts "--dry-run", "--write-only"
 
-  sig { returns(CLI::Parser) }
-  def bump_revision_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Create a commit to increment the revision of <formula>. If no revision is
-        present, "revision 1" will be added.
-      EOS
-      switch "-n", "--dry-run",
-             description: "Print what would be done rather than doing it."
-      switch "--remove-bottle-block",
-             description: "Remove the bottle block in addition to bumping the revision."
-      switch "--write-only",
-             description: "Make the expected file modifications without taking any Git actions."
-      flag   "--message=",
-             description: "Append <message> to the default commit message."
-
-      conflicts "--dry-run", "--write-only"
-
-      named_args :formula, min: 1
-    end
-  end
+        named_args :formula, min: 1, without_api: true
+      end
 
-  def bump_revision
-    args = bump_revision_args.parse
+      sig { override.void }
+      def run
+        # As this command is simplifying user-run commands then let's just use a
+        # user path, too.
+        ENV["PATH"] = PATH.new(ORIGINAL_PATHS).to_s
 
-    # As this command is simplifying user-run commands then let's just use a
-    # user path, too.
-    ENV["PATH"] = PATH.new(ORIGINAL_PATHS).to_s
+        Homebrew.install_bundler_gems!(groups: ["ast"]) unless args.dry_run?
 
-    args.named.to_formulae.each do |formula|
-      current_revision = formula.revision
-      new_revision = current_revision + 1
+        args.named.to_formulae.each do |formula|
+          current_revision = formula.revision
+          new_revision = current_revision + 1
 
-      if args.dry_run?
-        unless args.quiet?
-          old_text = "revision #{current_revision}"
-          new_text = "revision #{new_revision}"
-          if current_revision.zero?
-            ohai "add #{new_text.inspect}"
+          if args.dry_run?
+            unless args.quiet?
+              old_text = "revision #{current_revision}"
+              new_text = "revision #{new_revision}"
+              if current_revision.zero?
+                ohai "add #{new_text.inspect}"
+              else
+                ohai "replace #{old_text.inspect} with #{new_text.inspect}"
+              end
+            end
           else
-            ohai "replace #{old_text.inspect} with #{new_text.inspect}"
-          end
-        end
-      else
-        Homebrew.install_bundler_gems!
-        require "utils/ast"
+            require "utils/ast"
 
-        formula_ast = Utils::AST::FormulaAST.new(formula.path.read)
-        if current_revision.zero?
-          formula_ast.add_stanza(:revision, new_revision)
-        else
-          formula_ast.replace_stanza(:revision, new_revision)
-        end
-        formula_ast.remove_stanza(:bottle) if args.remove_bottle_block?
-        formula.path.atomic_write(formula_ast.process)
-      end
+            formula_ast = Utils::AST::FormulaAST.new(formula.path.read)
+            if current_revision.zero?
+              formula_ast.add_stanza(:revision, new_revision)
+            else
+              formula_ast.replace_stanza(:revision, new_revision)
+            end
+            formula_ast.remove_stanza(:bottle) if args.remove_bottle_block?
+            formula.path.atomic_write(formula_ast.process)
+          end
 
-      message = "#{formula.name}: revision bump #{args.message}"
-      if args.dry_run?
-        ohai "git commit --no-edit --verbose --message=#{message} -- #{formula.path}"
-      elsif !args.write_only?
-        formula.path.parent.cd do
-          safe_system "git", "commit", "--no-edit", "--verbose",
-                      "--message=#{message}", "--", formula.path
+          message = "#{formula.name}: revision bump #{args.message}"
+          if args.dry_run?
+            ohai "git commit --no-edit --verbose --message=#{message} -- #{formula.path}"
+          elsif !args.write_only?
+            formula.path.parent.cd do
+              safe_system "git", "commit", "--no-edit", "--verbose",
+                          "--message=#{message}", "--", formula.path
+            end
+          end
         end
       end
     end
diff --git a/Library/Homebrew/dev-cmd/bump-unversioned-casks.rb b/Library/Homebrew/dev-cmd/bump-unversioned-casks.rb
index fad44a815fea0..4d5bcdbbd93f5 100644
--- a/Library/Homebrew/dev-cmd/bump-unversioned-casks.rb
+++ b/Library/Homebrew/dev-cmd/bump-unversioned-casks.rb
@@ -1,174 +1,181 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 require "timeout"
 require "cask/download"
 require "cask/installer"
 require "cask/cask_loader"
-require "cli/parser"
+require "system_command"
 require "tap"
 require "unversioned_cask_checker"
 
 module Homebrew
-  extend T::Sig
-
-  extend SystemCommand::Mixin
-
-  sig { returns(CLI::Parser) }
-  def self.bump_unversioned_casks_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Check all casks with unversioned URLs in a given <tap> for updates.
-      EOS
-      switch "-n", "--dry-run",
-             description: "Do everything except caching state and opening pull requests."
-      flag   "--limit=",
-             description: "Maximum runtime in minutes."
-      flag   "--state-file=",
-             description: "File for caching state."
-
-      named_args [:cask, :tap], min: 1
-    end
-  end
+  module DevCmd
+    class BumpUnversionedCasks < AbstractCommand
+      include SystemCommand::Mixin
+
+      cmd_args do
+        description <<~EOS
+          Check all casks with unversioned URLs in a given <tap> for updates.
+        EOS
+        switch "-n", "--dry-run",
+               description: "Do everything except caching state and opening pull requests."
+        flag   "--limit=",
+               description: "Maximum runtime in minutes."
+        flag   "--state-file=",
+               description: "File for caching state."
+
+        named_args [:cask, :tap], min: 1, without_api: true
+      end
 
-  sig { void }
-  def self.bump_unversioned_casks
-    args = bump_unversioned_casks_args.parse
+      sig { override.void }
+      def run
+        Homebrew.install_bundler_gems!(groups: ["bump_unversioned_casks"])
 
-    state_file = if args.state_file.present?
-      Pathname(args.state_file).expand_path
-    else
-      HOMEBREW_CACHE/"bump_unversioned_casks.json"
-    end
-    state_file.dirname.mkpath
+        state_file = if args.state_file.present?
+          Pathname(T.must(args.state_file)).expand_path
+        else
+          HOMEBREW_CACHE/"bump_unversioned_casks.json"
+        end
+        state_file.dirname.mkpath
 
-    state = state_file.exist? ? JSON.parse(state_file.read) : {}
+        state = state_file.exist? ? JSON.parse(state_file.read) : {}
 
-    casks = args.named.to_paths(only: :cask, recurse_tap: true).map { |path| Cask::CaskLoader.load(path) }
+        casks = args.named.to_paths(only: :cask, recurse_tap: true).map { |path| Cask::CaskLoader.load(path) }
 
-    unversioned_casks = casks.select { |cask| cask.url&.unversioned? }
+        unversioned_casks = casks.select do |cask|
+          cask.url&.unversioned? && !cask.livecheckable?
+        end
 
-    ohai "Unversioned Casks: #{unversioned_casks.count} (#{state.size} cached)"
+        ohai "Unversioned Casks: #{unversioned_casks.count} (#{state.size} cached)"
 
-    checked, unchecked = unversioned_casks.partition { |c| state.key?(c.full_name) }
+        checked, unchecked = unversioned_casks.partition { |c| state.key?(c.full_name) }
 
-    queue = Queue.new
+        queue = Queue.new
 
-    # Start with random casks which have not been checked.
-    unchecked.shuffle.each do |c|
-      queue.enq c
-    end
+        # Start with random casks which have not been checked.
+        unchecked.shuffle.each do |c|
+          queue.enq c
+        end
 
-    # Continue with previously checked casks, ordered by when they were last checked.
-    checked.sort_by { |c| state.dig(c.full_name, "check_time") }.each do |c|
-      queue.enq c
-    end
+        # Continue with previously checked casks, ordered by when they were last checked.
+        checked.sort_by { |c| state.dig(c.full_name, "check_time") }.each do |c|
+          queue.enq c
+        end
 
-    limit = args.limit.presence&.to_i
-    end_time = Time.now + limit.minutes if limit
+        limit = args.limit.presence&.to_i
+        end_time = Time.now + (limit * 60) if limit
 
-    until queue.empty? || (end_time && end_time < Time.now)
-      cask = queue.deq
+        until queue.empty? || (end_time && end_time < Time.now)
+          cask = queue.deq
 
-      key = cask.full_name
+          key = cask.full_name
 
-      new_state = bump_unversioned_cask(cask, state: state.fetch(key, {}), dry_run: args.dry_run?)
+          new_state = bump_unversioned_cask(cask, state: state.fetch(key, {}))
 
-      next unless new_state
+          next unless new_state
 
-      state[key] = new_state
+          state[key] = new_state
 
-      state_file.atomic_write JSON.pretty_generate(state) unless args.dry_run?
-    end
-  end
+          state_file.atomic_write JSON.pretty_generate(state) unless args.dry_run?
+        end
+      end
 
-  sig {
-    params(cask: Cask::Cask, state: T::Hash[String, T.untyped], dry_run: T.nilable(T::Boolean))
-      .returns(T.nilable(T::Hash[String, T.untyped]))
-  }
-  def self.bump_unversioned_cask(cask, state:, dry_run:)
-    ohai "Checking #{cask.full_name}"
+      private
 
-    unversioned_cask_checker = UnversionedCaskChecker.new(cask)
+      sig {
+        params(cask: Cask::Cask, state: T::Hash[String, T.untyped])
+          .returns(T.nilable(T::Hash[String, T.untyped]))
+      }
+      def bump_unversioned_cask(cask, state:)
+        ohai "Checking #{cask.full_name}"
 
-    if !unversioned_cask_checker.single_app_cask? &&
-       !unversioned_cask_checker.single_pkg_cask? &&
-       !unversioned_cask_checker.single_qlplugin_cask?
-      opoo "Skipping, not a single-app or PKG cask."
-      return
-    end
+        unversioned_cask_checker = UnversionedCaskChecker.new(cask)
 
-    last_check_time = state["check_time"]&.then { |t| Time.parse(t) }
+        if !unversioned_cask_checker.single_app_cask? &&
+           !unversioned_cask_checker.single_pkg_cask? &&
+           !unversioned_cask_checker.single_qlplugin_cask?
+          opoo "Skipping, not a single-app or PKG cask."
+          return
+        end
 
-    check_time = Time.now
-    if last_check_time && check_time < (last_check_time + 1.day)
-      opoo "Skipping, already checked within the last 24 hours."
-      return
-    end
+        last_check_time = state["check_time"]&.then { |t| Time.parse(t) }
 
-    last_sha256 = state["sha256"]
-    last_time = state["time"]&.then { |t| Time.parse(t) }
-    last_file_size = state["file_size"]
+        check_time = Time.now
+        if last_check_time && (check_time - last_check_time) / 3600 < 24
+          opoo "Skipping, already checked within the last 24 hours."
+          return
+        end
 
-    download = Cask::Download.new(cask)
-    time, file_size = begin
-      download.time_file_size
-    rescue
-      [nil, nil]
-    end
+        last_sha256 = state["sha256"]
+        last_time = state["time"]&.then { |t| Time.parse(t) }
+        last_file_size = state["file_size"]
 
-    if last_time != time || last_file_size != file_size
-      sha256 = begin
-        Timeout.timeout(5.minutes) do
-          unversioned_cask_checker.installer.download.sha256
+        download = Cask::Download.new(cask)
+        time, file_size = begin
+          download.time_file_size
+        rescue
+          [nil, nil]
         end
-      rescue => e
-        onoe e
-      end
 
-      if sha256.present? && last_sha256 != sha256
-        version = begin
-          Timeout.timeout(1.minute) do
-            unversioned_cask_checker.guess_cask_version
+        if last_time != time || last_file_size != file_size
+          sha256 = begin
+            Timeout.timeout(5 * 60) do
+              unversioned_cask_checker.installer.download.sha256
+            end
+          rescue => e
+            onoe e
+
+            nil
           end
-        rescue Timeout::Error
-          onoe "Timed out guessing version for cask '#{cask}'."
-        end
 
-        if version
-          if cask.version == version
-            oh1 "Cask #{cask} is up-to-date at #{version}"
-          else
-            bump_cask_pr_args = [
-              "bump-cask-pr",
-              "--version", version.to_s,
-              "--sha256", ":no_check",
-              "--message", "Automatic update via `brew bump-unversioned-casks`.",
-              cask.sourcefile_path
-            ]
-
-            if dry_run
-              bump_cask_pr_args << "--dry-run"
-              oh1 "Would bump #{cask} from #{cask.version} to #{version}"
-            else
-              oh1 "Bumping #{cask} from #{cask.version} to #{version}"
+          if sha256.present? && last_sha256 != sha256
+            version = begin
+              Timeout.timeout(60) do
+                unversioned_cask_checker.guess_cask_version
+              end
+            rescue Timeout::Error
+              onoe "Timed out guessing version for cask '#{cask}'."
+
+              nil
             end
 
-            begin
-              system_command! HOMEBREW_BREW_FILE, args: bump_cask_pr_args
-            rescue ErrorDuringExecution => e
-              onoe e
+            if version
+              if cask.version == version
+                oh1 "Cask #{cask} is up-to-date at #{version}"
+              else
+                bump_cask_pr_args = [
+                  "bump-cask-pr",
+                  "--version", version.to_s,
+                  "--sha256", ":no_check",
+                  "--message", "Automatic update via `brew bump-unversioned-casks`.",
+                  cask.sourcefile_path
+                ]
+
+                if args.dry_run?
+                  bump_cask_pr_args << "--dry-run"
+                  oh1 "Would bump #{cask} from #{cask.version} to #{version}"
+                else
+                  oh1 "Bumping #{cask} from #{cask.version} to #{version}"
+                end
+
+                begin
+                  system_command! HOMEBREW_BREW_FILE, args: bump_cask_pr_args
+                rescue ErrorDuringExecution => e
+                  onoe e
+                end
+              end
             end
           end
         end
+
+        {
+          "sha256"     => sha256,
+          "check_time" => check_time.iso8601,
+          "time"       => time&.iso8601,
+          "file_size"  => file_size,
+        }
       end
     end
-
-    {
-      "sha256"     => sha256,
-      "check_time" => check_time.iso8601,
-      "time"       => time&.iso8601,
-      "file_size"  => file_size,
-    }
   end
 end
diff --git a/Library/Homebrew/dev-cmd/bump.rb b/Library/Homebrew/dev-cmd/bump.rb
index 009865c85d532..771d4c5644cbe 100644
--- a/Library/Homebrew/dev-cmd/bump.rb
+++ b/Library/Homebrew/dev-cmd/bump.rb
@@ -1,286 +1,527 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
+require "bump_version_parser"
 require "livecheck/livecheck"
+require "utils/repology"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def bump_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Display out-of-date brew formulae and the latest version available. If the
-        returned current and livecheck versions differ or when querying specific
-        formulae, also displays whether a pull request has been opened with the URL.
-      EOS
-      switch "--full-name",
-             description: "Print formulae/casks with fully-qualified names."
-      switch "--no-pull-requests",
-             description: "Do not retrieve pull requests from GitHub."
-      switch "--formula", "--formulae",
-             description: "Check only formulae."
-      switch "--cask", "--casks",
-             description: "Check only casks."
-      switch "--open-pr",
-             description: "Open a pull request for the new version if there are none already open."
-      flag   "--limit=",
-             description: "Limit number of package results returned."
-      flag   "--start-with=",
-             description: "Letter or word that the list of package results should alphabetically follow."
-
-      conflicts "--cask", "--formula"
-      conflicts "--no-pull-requests", "--open-pr"
-
-      named_args [:formula, :cask]
-    end
-  end
+  module DevCmd
+    class Bump < AbstractCommand
+      class VersionBumpInfo < T::Struct
+        const :type, Symbol
+        const :multiple_versions, T::Boolean
+        const :version_name, String
+        const :current_version, BumpVersionParser
+        const :repology_latest, T.any(String, Version)
+        const :new_version, BumpVersionParser
+        const :duplicate_pull_requests, T.nilable(T.any(T::Array[String], String))
+        const :maybe_duplicate_pull_requests, T.nilable(T.any(T::Array[String], String))
+      end
 
-  def bump
-    args = bump_args.parse
+      cmd_args do
+        description <<~EOS
+          Displays out-of-date packages and the latest version available. If the
+          returned current and livecheck versions differ or when querying specific
+          packages, also displays whether a pull request has been opened with the URL.
+        EOS
+        switch "--full-name",
+               description: "Print formulae/casks with fully-qualified names."
+        switch "--no-pull-requests",
+               description: "Do not retrieve pull requests from GitHub."
+        switch "--auto",
+               description: "Read the list of formulae/casks from the tap autobump list.",
+               hidden:      true
+        switch "--formula", "--formulae",
+               description: "Check only formulae."
+        switch "--cask", "--casks",
+               description: "Check only casks."
+        switch "--eval-all",
+               description: "Evaluate all formulae and casks."
+        switch "--repology",
+               description: "Use Repology to check for outdated packages."
+        flag   "--tap=",
+               description: "Check formulae and casks within the given tap, specified as <user>`/`<repo>."
+        switch "--installed",
+               description: "Check formulae and casks that are currently installed."
+        switch "--no-fork",
+               description: "Don't try to fork the repository."
+        switch "--open-pr",
+               description: "Open a pull request for the new version if none have been opened yet."
+        flag   "--start-with=",
+               description: "Letter or word that the list of package results should alphabetically follow."
+
+        conflicts "--cask", "--formula"
+        conflicts "--tap=", "--installed"
+        conflicts "--eval-all", "--installed"
+        conflicts "--installed", "--auto"
+        conflicts "--no-pull-requests", "--open-pr"
+
+        named_args [:formula, :cask], without_api: true
+      end
 
-    if args.limit.present? && !args.formula? && !args.cask?
-      raise UsageError, "`--limit` must be used with either `--formula` or `--cask`."
-    end
+      sig { override.void }
+      def run
+        Homebrew.install_bundler_gems!(groups: ["livecheck"])
 
-    formulae_and_casks = if args.formula?
-      args.named.to_formulae
-    elsif args.cask?
-      args.named.to_casks
-    else
-      args.named.to_formulae_and_casks
-    end
-    formulae_and_casks = formulae_and_casks&.sort_by do |formula_or_cask|
-      formula_or_cask.respond_to?(:token) ? formula_or_cask.token : formula_or_cask.name
-    end
+        Homebrew.with_no_api_env do
+          eval_all = args.eval_all? || Homebrew::EnvConfig.eval_all?
 
-    limit = args.limit.to_i if args.limit.present?
+          formulae_and_casks = if args.auto?
+            raise UsageError, "`--formula` or `--cask` must be passed with `--auto`." if !args.formula? && !args.cask?
 
-    unless Utils::Curl.curl_supports_tls13?
-      begin
-        ensure_formula_installed!("curl", reason: "Repology queries") unless HOMEBREW_BREWED_CURL_PATH.exist?
-      rescue FormulaUnavailableError
-        opoo "A newer `curl` is required for Repology queries."
-      end
-    end
+            tap_arg = args.tap
+            raise UsageError, "`--tap=` must be passed with `--auto`." if tap_arg.blank?
+
+            tap = Tap.fetch(tap_arg)
+            autobump_list = tap.autobump
+            what = args.cask? ? "casks" : "formulae"
+            raise UsageError, "No autobumped #{what} found." if autobump_list.blank?
+
+            autobump_list.map do |name|
+              qualified_name = "#{tap.name}/#{name}"
+              next Cask::CaskLoader.load(qualified_name) if args.cask?
+
+              Formulary.factory(qualified_name)
+            end
+          elsif args.tap
+            tap = Tap.fetch(T.must(args.tap))
+            raise UsageError, "`--tap` requires `--auto` for official taps." if tap.official?
+
+            formulae = args.cask? ? [] : tap.formula_files.map { |path| Formulary.factory(path) }
+            casks = args.formula? ? [] : tap.cask_files.map { |path| Cask::CaskLoader.load(path) }
+            formulae + casks
+          elsif args.installed?
+            formulae = args.cask? ? [] : Formula.installed
+            casks = args.formula? ? [] : Cask::Caskroom.casks
+            formulae + casks
+          elsif args.named.present?
+            args.named.to_formulae_and_casks_with_taps
+          elsif eval_all
+            formulae = args.cask? ? [] : Formula.all(eval_all:)
+            casks = args.formula? ? [] : Cask::Cask.all(eval_all:)
+            formulae + casks
+          else
+            raise UsageError,
+                  "`brew bump` without named arguments needs `--installed` or `--eval-all` passed or " \
+                  "`HOMEBREW_EVAL_ALL` set!"
+          end
 
-    if formulae_and_casks.present?
-      Livecheck.load_other_tap_strategies(formulae_and_casks)
+          if args.start_with
+            formulae_and_casks.select! do |formula_or_cask|
+              name = formula_or_cask.respond_to?(:token) ? formula_or_cask.token : formula_or_cask.name
+              name.start_with?(args.start_with)
+            end
+          end
+
+          formulae_and_casks = formulae_and_casks&.sort_by do |formula_or_cask|
+            formula_or_cask.respond_to?(:token) ? formula_or_cask.token : formula_or_cask.name
+          end
+
+          if args.repology? && !Utils::Curl.curl_supports_tls13?
+            begin
+              ensure_formula_installed!("curl", reason: "Repology queries") unless HOMEBREW_BREWED_CURL_PATH.exist?
+            rescue FormulaUnavailableError
+              opoo "A newer `curl` is required for Repology queries."
+            end
+          end
 
-      ambiguous_casks = []
-      if !args.formula? && !args.cask?
-        ambiguous_casks = formulae_and_casks.group_by { |item| Livecheck.formula_or_cask_name(item, full_name: true) }
-                                            .values
-                                            .select { |items| items.length > 1 }
-                                            .flatten
-                                            .select { |item| item.is_a?(Cask::Cask) }
+          handle_formulae_and_casks(formulae_and_casks)
+        end
       end
 
-      ambiguous_names = []
-      unless args.full_name?
-        ambiguous_names =
-          (formulae_and_casks - ambiguous_casks).group_by { |item| Livecheck.formula_or_cask_name(item) }
-                                                .values
-                                                .select { |items| items.length > 1 }
-                                                .flatten
+      private
+
+      sig { params(formula_or_cask: T.any(Formula, Cask::Cask)).returns(T::Boolean) }
+      def skip_repology?(formula_or_cask)
+        return true unless args.repology?
+
+        (ENV["CI"].present? && args.open_pr? && formula_or_cask.livecheckable?) ||
+          (formula_or_cask.is_a?(Formula) && formula_or_cask.versioned_formula?)
       end
 
-      formulae_and_casks.each_with_index do |formula_or_cask, i|
-        puts if i.positive?
+      sig { params(formulae_and_casks: T::Array[T.any(Formula, Cask::Cask)]).void }
+      def handle_formulae_and_casks(formulae_and_casks)
+        Livecheck.load_other_tap_strategies(formulae_and_casks)
+
+        ambiguous_casks = []
+        if !args.formula? && !args.cask?
+          ambiguous_casks = formulae_and_casks
+                            .group_by { |item| Livecheck.package_or_resource_name(item, full_name: true) }
+                            .values
+                            .select { |items| items.length > 1 }
+                            .flatten
+                            .select { |item| item.is_a?(Cask::Cask) }
+        end
 
-        use_full_name = args.full_name? || ambiguous_names.include?(formula_or_cask)
-        name = Livecheck.formula_or_cask_name(formula_or_cask, full_name: use_full_name)
-        repository = if formula_or_cask.is_a?(Formula)
-          if formula_or_cask.head_only?
-            ohai name
-            puts "Formula is HEAD-only."
-            next
+        ambiguous_names = []
+        unless args.full_name?
+          ambiguous_names = (formulae_and_casks - ambiguous_casks)
+                            .group_by { |item| Livecheck.package_or_resource_name(item) }
+                            .values
+                            .select { |items| items.length > 1 }
+                            .flatten
+        end
+
+        formulae_and_casks.each_with_index do |formula_or_cask, i|
+          puts if i.positive?
+          next if skip_ineligible_formulae(formula_or_cask)
+
+          use_full_name = args.full_name? || ambiguous_names.include?(formula_or_cask)
+          name = Livecheck.package_or_resource_name(formula_or_cask, full_name: use_full_name)
+          repository = if formula_or_cask.is_a?(Formula)
+            Repology::HOMEBREW_CORE
+          else
+            Repology::HOMEBREW_CASK
           end
 
-          Repology::HOMEBREW_CORE
-        else
-          Repology::HOMEBREW_CASK
+          package_data = Repology.single_package_query(name, repository:) unless skip_repology?(formula_or_cask)
+
+          retrieve_and_display_info_and_open_pr(
+            formula_or_cask,
+            name,
+            package_data&.values&.first || [],
+            ambiguous_cask: ambiguous_casks.include?(formula_or_cask),
+          )
         end
+      end
 
-        package_data = if formula_or_cask.is_a?(Formula) && formula_or_cask.versioned_formula?
-          nil
+      sig {
+        params(formula_or_cask: T.any(Formula, Cask::Cask)).returns(T::Boolean)
+      }
+      def skip_ineligible_formulae(formula_or_cask)
+        if formula_or_cask.is_a?(Formula)
+          skip = formula_or_cask.disabled? || formula_or_cask.head_only?
+          name = formula_or_cask.name
+          text = "Formula is #{formula_or_cask.disabled? ? "disabled" : "HEAD-only"} so not accepting updates.\n"
         else
-          Repology.single_package_query(name, repository: repository)
+          skip = formula_or_cask.disabled?
+          name = formula_or_cask.token
+          text = "Cask is disabled so not accepting updates.\n"
+        end
+        if (tap = formula_or_cask.tap) && !tap.allow_bump?(name)
+          skip = true
+          text = "#{text.split.first} is autobumped so will have bump PRs opened by BrewTestBot every ~3 hours.\n"
         end
+        return false unless skip
+
+        ohai name
+        puts text
+        true
+      end
 
-        retrieve_and_display_info_and_open_pr(
+      sig {
+        params(formula_or_cask: T.any(Formula, Cask::Cask)).returns(T.any(Version, String))
+      }
+      def livecheck_result(formula_or_cask)
+        name = Livecheck.package_or_resource_name(formula_or_cask)
+
+        referenced_formula_or_cask, = Livecheck.resolve_livecheck_reference(
           formula_or_cask,
-          name,
-          package_data&.values&.first,
-          args:           args,
-          ambiguous_cask: ambiguous_casks.include?(formula_or_cask),
+          full_name: false,
+          debug:     false,
         )
+
+        # Check skip conditions for a referenced formula/cask
+        if referenced_formula_or_cask
+          skip_info = Livecheck::SkipConditions.referenced_skip_information(
+            referenced_formula_or_cask,
+            name,
+            full_name: false,
+            verbose:   false,
+          )
+        end
+
+        skip_info ||= Livecheck::SkipConditions.skip_information(
+          formula_or_cask,
+          full_name: false,
+          verbose:   false,
+        )
+
+        if skip_info.present?
+          return "#{skip_info[:status]}" \
+                 "#{" - #{skip_info[:messages].join(", ")}" if skip_info[:messages].present?}"
+        end
+
+        version_info = Livecheck.latest_version(
+          formula_or_cask,
+          referenced_formula_or_cask:,
+          json: true, full_name: false, verbose: true, debug: false
+        )
+        return "unable to get versions" if version_info.blank?
+
+        if !version_info.key?(:latest_throttled)
+          Version.new(version_info[:latest])
+        elsif version_info[:latest_throttled].nil?
+          "unable to get throttled versions"
+        else
+          Version.new(version_info[:latest_throttled])
+        end
+      rescue => e
+        "error: #{e}"
       end
-    else
-      api_response = {}
-      unless args.cask?
-        api_response[:formulae] =
-          Repology.parse_api_response(limit, args.start_with, repository: Repology::HOMEBREW_CORE)
-      end
-      unless args.formula?
-        api_response[:casks] =
-          Repology.parse_api_response(limit, args.start_with, repository: Repology::HOMEBREW_CASK)
+
+      sig {
+        params(
+          formula_or_cask: T.any(Formula, Cask::Cask),
+          name:            String,
+          version:         T.nilable(String),
+        ).returns T.nilable(T.any(T::Array[String], String))
+      }
+      def retrieve_pull_requests(formula_or_cask, name, version: nil)
+        tap_remote_repo = formula_or_cask.tap&.remote_repository || formula_or_cask.tap&.full_name
+        pull_requests = begin
+          GitHub.fetch_pull_requests(name, tap_remote_repo, version:)
+        rescue GitHub::API::ValidationFailedError => e
+          odebug "Error fetching pull requests for #{formula_or_cask} #{name}: #{e}"
+          nil
+        end
+
+        pull_requests&.map { |pr| "#{pr["title"]} (#{Formatter.url(pr["html_url"])})" }&.join(", ")
       end
 
-      api_response.each_with_index do |(package_type, outdated_packages), idx|
-        repository = if package_type == :formulae
-          Repology::HOMEBREW_CORE
+      sig {
+        params(
+          formula_or_cask: T.any(Formula, Cask::Cask),
+          repositories:    T::Array[String],
+          name:            String,
+        ).returns(VersionBumpInfo)
+      }
+      def retrieve_versions_by_arch(formula_or_cask:, repositories:, name:)
+        is_cask_with_blocks = formula_or_cask.is_a?(Cask::Cask) && formula_or_cask.on_system_blocks_exist?
+        type, version_name = if formula_or_cask.is_a?(Formula)
+          [:formula, "formula version:"]
         else
-          Repology::HOMEBREW_CASK
+          [:cask, "cask version:   "]
         end
-        puts if idx.positive?
-        oh1 package_type.capitalize if api_response.size > 1
 
-        outdated_packages.each_with_index do |(_name, repositories), i|
-          break if limit && i >= limit
+        old_versions = {}
+        new_versions = {}
 
-          homebrew_repo = repositories.find do |repo|
-            repo["repo"] == repository
-          end
+        repology_latest = repositories.present? ? Repology.latest_version(repositories) : "not found"
+
+        # When blocks are absent, arch is not relevant. For consistency, we simulate the arm architecture.
+        arch_options = is_cask_with_blocks ? OnSystem::ARCH_OPTIONS : [:arm]
 
-          next if homebrew_repo.blank?
+        arch_options.each do |arch|
+          SimulateSystem.with(arch:) do
+            version_key = is_cask_with_blocks ? arch : :general
 
-          formula_or_cask = begin
-            if repository == Repology::HOMEBREW_CORE
-              Formula[homebrew_repo["srcname"]]
+            # We reload the formula/cask here to ensure we're getting the correct version for the current arch
+            if formula_or_cask.is_a?(Formula)
+              loaded_formula_or_cask = formula_or_cask
+              current_version_value = T.must(loaded_formula_or_cask.stable).version
             else
-              Cask::CaskLoader.load(homebrew_repo["srcname"])
+              loaded_formula_or_cask = Cask::CaskLoader.load(formula_or_cask.sourcefile_path)
+              current_version_value = Version.new(loaded_formula_or_cask.version)
             end
-          rescue
-            next
-          end
-          name = Livecheck.formula_or_cask_name(formula_or_cask)
-          ambiguous_cask = begin
-            formula_or_cask.is_a?(Cask::Cask) && !args.cask? && Formula[name]
-          rescue FormulaUnavailableError
-            false
+
+            livecheck_latest = livecheck_result(loaded_formula_or_cask)
+
+            new_version_value = if (livecheck_latest.is_a?(Version) &&
+                                    Livecheck::LivecheckVersion.create(formula_or_cask, livecheck_latest) >=
+                                    Livecheck::LivecheckVersion.create(formula_or_cask, current_version_value)) ||
+                                   current_version_value == "latest"
+              livecheck_latest
+            elsif livecheck_latest.is_a?(String) && livecheck_latest.start_with?("skipped")
+              "skipped"
+            elsif repology_latest.is_a?(Version) &&
+                  repology_latest > current_version_value &&
+                  !loaded_formula_or_cask.livecheckable? &&
+                  current_version_value != "latest"
+              repology_latest
+            end.presence
+
+            # Store old and new versions
+            old_versions[version_key] = current_version_value
+            new_versions[version_key] = new_version_value
           end
+        end
 
-          puts if i.positive?
-          retrieve_and_display_info_and_open_pr(
-            formula_or_cask,
-            name,
-            repositories,
-            args:           args,
-            ambiguous_cask: ambiguous_cask,
-          )
+        # If arm and intel versions are identical, as it happens with casks where only the checksums differ,
+        # we consolidate them into a single version.
+        if old_versions[:arm].present? && old_versions[:arm] == old_versions[:intel]
+          old_versions = { general: old_versions[:arm] }
+        end
+        if new_versions[:arm].present? && new_versions[:arm] == new_versions[:intel]
+          new_versions = { general: new_versions[:arm] }
+        end
+
+        multiple_versions = old_versions.values_at(:arm, :intel).all?(&:present?) ||
+                            new_versions.values_at(:arm, :intel).all?(&:present?)
+
+        current_version = BumpVersionParser.new(general: old_versions[:general],
+                                                arm:     old_versions[:arm],
+                                                intel:   old_versions[:intel])
+
+        begin
+          new_version = BumpVersionParser.new(general: new_versions[:general],
+                                              arm:     new_versions[:arm],
+                                              intel:   new_versions[:intel])
+        rescue
+          # When livecheck fails, we fail gracefully. Otherwise VersionParser will
+          # raise a usage error
+          new_version = BumpVersionParser.new(general: "unable to get versions")
+        end
+
+        # We use the arm version for the pull request version. This is consistent
+        # with the behavior of bump-cask-pr.
+        pull_request_version = if multiple_versions && new_version.general != "unable to get versions"
+          new_version.arm.to_s
+        else
+          new_version.general.to_s
         end
+
+        duplicate_pull_requests = unless args.no_pull_requests?
+          retrieve_pull_requests(formula_or_cask, name, version: pull_request_version)
+        end.presence
+
+        maybe_duplicate_pull_requests = if !args.no_pull_requests? && duplicate_pull_requests.blank?
+          retrieve_pull_requests(formula_or_cask, name)
+        end.presence
+
+        VersionBumpInfo.new(
+          type:,
+          multiple_versions:,
+          version_name:,
+          current_version:,
+          repology_latest:,
+          new_version:,
+          duplicate_pull_requests:,
+          maybe_duplicate_pull_requests:,
+        )
       end
-    end
-  end
 
-  def livecheck_result(formula_or_cask)
-    name = Livecheck.formula_or_cask_name(formula_or_cask)
+      sig {
+        params(
+          formula_or_cask: T.any(Formula, Cask::Cask),
+          name:            String,
+          repositories:    T::Array[String],
+          ambiguous_cask:  T::Boolean,
+        ).void
+      }
+      def retrieve_and_display_info_and_open_pr(formula_or_cask, name, repositories, ambiguous_cask: false)
+        version_info = retrieve_versions_by_arch(formula_or_cask:,
+                                                 repositories:,
+                                                 name:)
+
+        current_version = version_info.current_version
+        new_version = version_info.new_version
+        repology_latest = version_info.repology_latest
+
+        # Check if all versions are equal
+        versions_equal = [:arm, :intel, :general].all? do |key|
+          current_version.send(key) == new_version.send(key)
+        end
 
-    referenced_formula_or_cask, =
-      Livecheck.resolve_livecheck_reference(formula_or_cask, full_name: false, debug: false)
+        title_name = ambiguous_cask ? "#{name} (cask)" : name
+        title = if (repology_latest == current_version.general || !repology_latest.is_a?(Version)) && versions_equal
+          "#{title_name} #{Tty.green}is up to date!#{Tty.reset}"
+        else
+          title_name
+        end
 
-    # Check skip conditions for a referenced formula/cask
-    if referenced_formula_or_cask
-      skip_info = Livecheck::SkipConditions.referenced_skip_information(
-        referenced_formula_or_cask,
-        name,
-        full_name: false,
-        verbose:   false,
-      )
-    end
+        # Conditionally format output based on type of formula_or_cask
+        current_versions = if version_info.multiple_versions
+          "arm:   #{current_version.arm}
+                          intel: #{current_version.intel}"
+        else
+          current_version.general.to_s
+        end
+        current_versions << " (deprecated)" if formula_or_cask.deprecated?
 
-    skip_info ||= Livecheck::SkipConditions.skip_information(formula_or_cask, full_name: false, verbose: false)
-    if skip_info.present?
-      return "#{skip_info[:status]}#{" - #{skip_info[:messages].join(", ")}" if skip_info[:messages].present?}"
-    end
+        new_versions = if version_info.multiple_versions && new_version.arm && new_version.intel
+          "arm:   #{new_version.arm}
+                          intel: #{new_version.intel}"
+        else
+          new_version.general
+        end
 
-    version_info = Livecheck.latest_version(
-      formula_or_cask,
-      referenced_formula_or_cask: referenced_formula_or_cask,
-      json: true, full_name: false, verbose: true, debug: false
-    )
-    return "unable to get versions" if version_info.blank?
+        version_label = version_info.version_name
+        duplicate_pull_requests = version_info.duplicate_pull_requests.presence
+        maybe_duplicate_pull_requests = version_info.maybe_duplicate_pull_requests.presence
+
+        ohai title
+        puts <<~EOS
+          Current #{version_label}  #{current_versions}
+          Latest livecheck version: #{new_versions}#{" (throttled)" if formula_or_cask.livecheck.throttle}
+        EOS
+        puts <<~EOS unless skip_repology?(formula_or_cask)
+          Latest Repology version:  #{repology_latest}
+        EOS
+        if formula_or_cask.is_a?(Formula) && formula_or_cask.synced_with_other_formulae?
+          outdated_synced_formulae = synced_with(formula_or_cask, new_version.general)
+          puts <<~EOS if outdated_synced_formulae.present?
+            Version syncing:          #{title_name} version should be kept in sync with
+                                      #{outdated_synced_formulae.join(", ")}.
+          EOS
+        end
+        puts <<~EOS unless args.no_pull_requests?
+          Duplicate pull requests:       #{duplicate_pull_requests       || "none"}
+          Maybe duplicate pull requests: #{maybe_duplicate_pull_requests || "none"}
+        EOS
 
-    latest = version_info[:latest]
-    strategy = version_info[:meta][:strategy]
+        return unless args.open_pr?
 
-    [Version.new(latest), strategy]
-  rescue => e
-    "error: #{e}"
-  end
+        if GitHub.too_many_open_prs?(formula_or_cask.tap)
+          odie "You have too many PRs open: close or merge some first!"
+        end
 
-  def retrieve_pull_requests(formula_or_cask, name)
-    tap_remote_repo = formula_or_cask.tap&.remote_repo || formula_or_cask.tap&.full_name
-    pull_requests = GitHub.fetch_pull_requests(name, tap_remote_repo, state: "open")
-    if pull_requests.try(:any?)
-      pull_requests = pull_requests.map { |pr| "#{pr["title"]} (#{Formatter.url(pr["html_url"])})" }.join(", ")
-    end
+        if repology_latest.is_a?(Version) &&
+           repology_latest > current_version.general &&
+           repology_latest > new_version.general &&
+           formula_or_cask.livecheckable?
+          puts "#{title_name} was not bumped to the Repology version because it's livecheckable."
+        end
+        if new_version.blank? || versions_equal ||
+           (!new_version.general.is_a?(Version) && !version_info.multiple_versions)
+          return
+        end
 
-    pull_requests
-  end
+        return if duplicate_pull_requests.present?
 
-  def retrieve_and_display_info_and_open_pr(formula_or_cask, name, repositories, args:, ambiguous_cask: false)
-    if formula_or_cask.is_a?(Formula)
-      current_version = formula_or_cask.stable.version
-      type = :formula
-      version_name = "formula version"
-    else
-      current_version = Version.new(formula_or_cask.version)
-      type = :cask
-      version_name = "cask version   "
-    end
+        version_args = if version_info.multiple_versions
+          %W[--version-arm=#{new_version.arm} --version-intel=#{new_version.intel}]
+        else
+          "--version=#{new_version.general}"
+        end
 
-    livecheck_latest, livecheck_strategy = livecheck_result(formula_or_cask)
+        bump_cask_pr_args = [
+          "bump-#{version_info.type}-pr",
+          name,
+          *version_args,
+          "--no-browse",
+          "--message=Created by `brew bump`",
+        ]
 
-    repology_latest = if repositories.present?
-      Repology.latest_version(repositories)
-    else
-      "not found"
-    end
+        bump_cask_pr_args << "--no-fork" if args.no_fork?
 
-    new_version = if livecheck_latest.is_a?(Version) && livecheck_latest > current_version
-      livecheck_latest
-    elsif repology_latest.is_a?(Version) && repology_latest > current_version && livecheck_strategy != "GithubLatest"
-      repology_latest
-    end.presence
-
-    pull_requests = if !args.no_pull_requests? && (args.named.present? || new_version)
-      retrieve_pull_requests(formula_or_cask, name)
-    end.presence
-
-    title_name = ambiguous_cask ? "#{name} (cask)" : name
-    title = if current_version == repology_latest &&
-               current_version == livecheck_latest
-      "#{title_name} #{Tty.green}is up to date!#{Tty.reset}"
-    else
-      title_name
-    end
+        system HOMEBREW_BREW_FILE, *bump_cask_pr_args
+      end
 
-    ohai title
-    puts <<~EOS
-      Current #{version_name}:  #{current_version}
-      Latest livecheck version: #{livecheck_latest}
-      Latest Repology version:  #{repology_latest}
-      Open pull requests:       #{pull_requests || "none"}
-    EOS
-
-    return unless args.open_pr?
-
-    if repology_latest > current_version &&
-       repology_latest > livecheck_latest &&
-       livecheck_strategy == "GithubLatest"
-      puts "#{title_name} was not bumped to the Repology version because that " \
-           "version is not the latest release on GitHub."
-    end
+      sig {
+        params(
+          formula:     Formula,
+          new_version: T.nilable(T.any(Version, Cask::DSL::Version)),
+        ).returns(T::Array[String])
+      }
+      def synced_with(formula, new_version)
+        synced_with = []
 
-    return unless new_version
-    return if pull_requests
+        formula.tap&.synced_versions_formulae&.each do |synced_formulae|
+          next unless synced_formulae.include?(formula.name)
 
-    system HOMEBREW_BREW_FILE, "bump-#{type}-pr", "--no-browse",
-           "--message=Created by `brew bump`", "--version=#{new_version}", name
+          synced_formulae.each do |synced_formula|
+            synced_formula = Formulary.factory(synced_formula)
+            next if synced_formula == formula.name
+
+            synced_with << synced_formula.name if synced_formula.version != new_version
+          end
+        end
+
+        synced_with
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/cat.rb b/Library/Homebrew/dev-cmd/cat.rb
index 3960e5518ceae..a5e8180ca60db 100644
--- a/Library/Homebrew/dev-cmd/cat.rb
+++ b/Library/Homebrew/dev-cmd/cat.rb
@@ -1,49 +1,65 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
+require "fileutils"
 
 module Homebrew
-  extend T::Sig
+  module DevCmd
+    class Cat < AbstractCommand
+      include FileUtils
 
-  module_function
+      cmd_args do
+        description <<~EOS
+          Display the source of a <formula> or <cask>.
+        EOS
 
-  sig { returns(CLI::Parser) }
-  def cat_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Display the source of a <formula> or <cask>.
-      EOS
+        switch "--formula", "--formulae",
+               description: "Treat all named arguments as formulae."
+        switch "--cask", "--casks",
+               description: "Treat all named arguments as casks."
 
-      switch "--formula", "--formulae",
-             description: "Treat all named arguments as formulae."
-      switch "--cask", "--casks",
-             description: "Treat all named arguments as casks."
+        conflicts "--formula", "--cask"
 
-      conflicts "--formula", "--cask"
+        named_args [:formula, :cask], min: 1, without_api: true
+      end
 
-      named_args [:formula, :cask], number: 1
-    end
-  end
+      sig { override.void }
+      def run
+        cd HOMEBREW_REPOSITORY do
+          pager = if Homebrew::EnvConfig.bat?
+            ENV["BAT_CONFIG_PATH"] = Homebrew::EnvConfig.bat_config_path
+            ENV["BAT_THEME"] = Homebrew::EnvConfig.bat_theme
+            ensure_formula_installed!(
+              "bat",
+              reason:           "displaying <formula>/<cask> source",
+              # The user might want to capture the output of `brew cat ...`
+              # Redirect stdout to stderr
+              output_to_stderr: true,
+            ).opt_bin/"bat"
+          else
+            "cat"
+          end
 
-  def cat
-    args = cat_args.parse
-
-    cd HOMEBREW_REPOSITORY
-    pager = if Homebrew::EnvConfig.bat?
-      ENV["BAT_CONFIG_PATH"] = Homebrew::EnvConfig.bat_config_path
-      ENV["BAT_THEME"] = Homebrew::EnvConfig.bat_theme
-      ensure_formula_installed!(
-        "bat",
-        reason:           "displaying <formula>/<cask> source",
-        # The user might want to capture the output of `brew cat ...`
-        # Redirect stdout to stderr
-        output_to_stderr: true,
-      ).opt_bin/"bat"
-    else
-      "cat"
-    end
+          args.named.to_paths.each do |path|
+            next path if path.exist?
+
+            path = path.basename(".rb") if args.cask?
 
-    safe_system pager, args.named.to_paths.first
+            ofail "#{path}'s source doesn't exist on disk."
+          end
+
+          if Homebrew.failed?
+            $stderr.puts "The name may be wrong, or the tap hasn't been tapped. Instead try:"
+            treat_as = "--cask " if args.cask?
+            treat_as = "--formula " if args.formula?
+            $stderr.puts "  brew info --github #{treat_as}#{args.named.join(" ")}"
+            return
+          end
+
+          safe_system pager, *args.named.to_paths
+        end
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/command.rb b/Library/Homebrew/dev-cmd/command.rb
deleted file mode 100644
index 0a9aa85bfa052..0000000000000
--- a/Library/Homebrew/dev-cmd/command.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "commands"
-require "cli/parser"
-
-module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def command_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Display the path to the file being used when invoking `brew` <cmd>.
-      EOS
-
-      named_args :command, min: 1
-    end
-  end
-
-  def command
-    args = command_args.parse
-
-    args.named.each do |cmd|
-      path = Commands.path(cmd)
-      odie "Unknown command: #{cmd}" unless path
-      puts path
-    end
-  end
-end
diff --git a/Library/Homebrew/dev-cmd/contributions.rb b/Library/Homebrew/dev-cmd/contributions.rb
new file mode 100644
index 0000000000000..b4bf32a3a4f77
--- /dev/null
+++ b/Library/Homebrew/dev-cmd/contributions.rb
@@ -0,0 +1,241 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+
+module Homebrew
+  module DevCmd
+    class Contributions < AbstractCommand
+      PRIMARY_REPOS = T.let(%w[brew core cask].freeze, T::Array[String])
+      SUPPORTED_REPOS = T.let([
+        PRIMARY_REPOS,
+        OFFICIAL_CMD_TAPS.keys.map { |t| t.delete_prefix("homebrew/") },
+        OFFICIAL_CASK_TAPS.reject { |t| t == "cask" },
+      ].flatten.freeze, T::Array[String])
+      MAX_REPO_COMMITS = 1000
+
+      cmd_args do
+        usage_banner "`contributions` [--user=<email|username>] [<--repositories>`=`] [<--csv>]"
+        description <<~EOS
+          Summarise contributions to Homebrew repositories.
+        EOS
+
+        comma_array "--repositories",
+                    description: "Specify a comma-separated list of repositories to search. " \
+                                 "Supported repositories: #{SUPPORTED_REPOS.map { |t| "`#{t}`" }.to_sentence}. " \
+                                 "Omitting this flag, or specifying `--repositories=primary`, searches only the " \
+                                 "main repositories: brew,core,cask. " \
+                                 "Specifying `--repositories=all`, searches all repositories. "
+        flag "--from=",
+             description: "Date (ISO-8601 format) to start searching contributions. " \
+                          "Omitting this flag searches the last year."
+
+        flag "--to=",
+             description: "Date (ISO-8601 format) to stop searching contributions."
+
+        comma_array "--user=",
+                    description: "Specify a comma-separated list of GitHub usernames or email addresses to find " \
+                                 "contributions from. Omitting this flag searches maintainers."
+
+        switch "--csv",
+               description: "Print a CSV of contributions across repositories over the time period."
+      end
+
+      sig { override.void }
+      def run
+        results = {}
+        grand_totals = {}
+
+        repos = T.must(
+          if args.repositories.blank? || args.repositories&.include?("primary")
+            PRIMARY_REPOS
+          elsif args.repositories&.include?("all")
+            SUPPORTED_REPOS
+          else
+            args.repositories
+          end,
+        )
+
+        repos.each do |repo|
+          if SUPPORTED_REPOS.exclude?(repo)
+            odie "Unsupported repository: #{repo}. Try one of #{SUPPORTED_REPOS.join(", ")}."
+          end
+        end
+
+        from = args.from.presence || Date.today.prev_year.iso8601
+
+        contribution_types = [:author, :committer, :coauthor, :review]
+
+        require "utils/github"
+        users = args.user.presence || GitHub.members_by_team("Homebrew", "maintainers").keys
+        users.each do |username|
+          # TODO: Using the GitHub username to scan the `git log` undercounts some
+          # contributions as people might not always have configured their Git
+          # committer details to match the ones on GitHub.
+          # TODO: Switch to using the GitHub APIs instead of `git log` if
+          # they ever support trailers.
+          results[username] = scan_repositories(repos, username, from:)
+          grand_totals[username] = total(results[username])
+
+          contributions = contribution_types.filter_map do |type|
+            type_count = grand_totals[username][type]
+            next if type_count.to_i.zero?
+
+            "#{Utils.pluralize("time", type_count, include_count: true)} (#{type})"
+          end
+          contributions <<
+            "#{Utils.pluralize("time", grand_totals[username].values.sum, include_count: true)} (total)"
+
+          puts [
+            "#{username} contributed",
+            *contributions.to_sentence,
+            "#{time_period(from:, to: args.to)}.",
+          ].join(" ")
+        end
+
+        return unless args.csv?
+
+        puts
+        puts generate_csv(grand_totals)
+      end
+
+      private
+
+      sig { params(repo: String).returns(Pathname) }
+      def find_repo_path_for_repo(repo)
+        return HOMEBREW_REPOSITORY if repo == "brew"
+
+        require "tap"
+        Tap.fetch("homebrew", repo).path
+      end
+
+      sig { params(from: T.nilable(String), to: T.nilable(String)).returns(String) }
+      def time_period(from:, to:)
+        if from && to
+          "between #{from} and #{to}"
+        elsif from
+          "after #{from}"
+        elsif to
+          "before #{to}"
+        else
+          "in all time"
+        end
+      end
+
+      sig { params(totals: T::Hash[String, T::Hash[Symbol, Integer]]).returns(String) }
+      def generate_csv(totals)
+        require "csv" # TODO: this will be removed from Ruby 3.4
+
+        CSV.generate do |csv|
+          csv << %w[user repo author committer coauthor review total]
+
+          totals.sort_by { |_, v| -v.values.sum }.each do |user, total|
+            csv << grand_total_row(user, total)
+          end
+        end
+      end
+
+      sig {
+        params(
+          user:        String,
+          grand_total: T::Hash[Symbol, Integer],
+        ).returns(
+          [String, String, T.nilable(Integer), T.nilable(Integer), T.nilable(Integer), T.nilable(Integer), Integer],
+        )
+      }
+      def grand_total_row(user, grand_total)
+        [
+          user,
+          "all",
+          grand_total[:author],
+          grand_total[:committer],
+          grand_total[:coauthor],
+          grand_total[:review],
+          grand_total.values.sum,
+        ]
+      end
+
+      sig {
+        params(
+          repos:  T::Array[String],
+          person: String,
+          from:   String,
+        ).returns(T::Hash[Symbol, T.untyped])
+      }
+      def scan_repositories(repos, person, from:)
+        data = {}
+        return data if repos.blank?
+
+        require "tap"
+        require "utils/github"
+        repos.each do |repo|
+          repo_path = find_repo_path_for_repo(repo)
+          tap = Tap.fetch("homebrew", repo)
+          unless repo_path.exist?
+            opoo "Repository #{repo} not yet tapped! Tapping it now..."
+            tap.install
+          end
+
+          repo_full_name = if repo == "brew"
+            "homebrew/brew"
+          else
+            tap.full_name
+          end
+
+          puts "Determining contributions for #{person} on #{repo_full_name}..." if args.verbose?
+
+          author_commits, committer_commits = GitHub.count_repo_commits(repo_full_name, person,
+                                                                        from:, to: args.to, max: MAX_REPO_COMMITS)
+          data[repo] = {
+            author:    author_commits,
+            committer: committer_commits,
+            coauthor:  git_log_trailers_cmd(repo_path, person, "Co-authored-by", from:, to: args.to),
+            review:    count_reviews(repo_full_name, person, from:, to: args.to),
+          }
+        end
+
+        data
+      end
+
+      sig { params(results: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, Integer]) }
+      def total(results)
+        totals = { author: 0, committer: 0, coauthor: 0, review: 0 }
+
+        results.each_value do |counts|
+          counts.each do |kind, count|
+            totals[kind] += count
+          end
+        end
+
+        totals
+      end
+
+      sig {
+        params(repo_path: Pathname, person: String, trailer: String, from: T.nilable(String),
+               to: T.nilable(String)).returns(Integer)
+      }
+      def git_log_trailers_cmd(repo_path, person, trailer, from:, to:)
+        cmd = ["git", "-C", repo_path, "log", "--oneline"]
+        cmd << "--format='%(trailers:key=#{trailer}:)'"
+        cmd << "--before=#{to}" if to
+        cmd << "--after=#{from}" if from
+
+        Utils.safe_popen_read(*cmd).lines.count { |l| l.include?(person) }
+      end
+
+      sig {
+        params(repo_full_name: String, person: String, from: T.nilable(String),
+               to: T.nilable(String)).returns(Integer)
+      }
+      def count_reviews(repo_full_name, person, from:, to:)
+        require "utils/github"
+        GitHub.count_issues("", is: "pr", repo: repo_full_name, reviewed_by: person, review: "approved", from:, to:)
+      rescue GitHub::API::ValidationFailedError
+        if args.verbose?
+          onoe "Couldn't search GitHub for PRs by #{person}. Their profile might be private. Defaulting to 0."
+        end
+        0 # Users who have made their contributions private are not searchable to determine counts.
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/dev-cmd/create.rb b/Library/Homebrew/dev-cmd/create.rb
index cc96680ab6d75..13917b8439b28 100644
--- a/Library/Homebrew/dev-cmd/create.rb
+++ b/Library/Homebrew/dev-cmd/create.rb
@@ -1,212 +1,241 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "formula"
 require "formula_creator"
 require "missing_formula"
-require "cli/parser"
 require "utils/pypi"
 require "cask/cask_loader"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def create_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Generate a formula or, with `--cask`, a cask for the downloadable file at <URL>
-        and open it in the editor. Homebrew will attempt to automatically derive the
-        formula name and version, but if it fails, you'll have to make your own template.
-        The `wget` formula serves as a simple example. For the complete API, see:
-        <https://rubydoc.brew.sh/Formula>
-      EOS
-      switch "--autotools",
-             description: "Create a basic template for an Autotools-style build."
-      switch "--cask",
-             description: "Create a basic template for a cask."
-      switch "--cmake",
-             description: "Create a basic template for a CMake-style build."
-      switch "--crystal",
-             description: "Create a basic template for a Crystal build."
-      switch "--go",
-             description: "Create a basic template for a Go build."
-      switch "--meson",
-             description: "Create a basic template for a Meson-style build."
-      switch "--node",
-             description: "Create a basic template for a Node build."
-      switch "--perl",
-             description: "Create a basic template for a Perl build."
-      switch "--python",
-             description: "Create a basic template for a Python build."
-      switch "--ruby",
-             description: "Create a basic template for a Ruby build."
-      switch "--rust",
-             description: "Create a basic template for a Rust build."
-      switch "--no-fetch",
-             description: "Homebrew will not download <URL> to the cache and will thus not add its SHA-256 " \
-                          "to the formula for you, nor will it check the GitHub API for GitHub projects " \
-                          "(to fill out its description and homepage)."
-      switch "--HEAD",
-             description: "Indicate that <URL> points to the package's repository rather than a file."
-      flag   "--set-name=",
-             description: "Explicitly set the <name> of the new formula or cask."
-      flag   "--set-version=",
-             description: "Explicitly set the <version> of the new formula or cask."
-      flag   "--set-license=",
-             description: "Explicitly set the <license> of the new formula."
-      flag   "--tap=",
-             description: "Generate the new formula within the given tap, specified as <user>`/`<repo>."
-      switch "-f", "--force",
-             description: "Ignore errors for disallowed formula names and names that shadow aliases."
-
-      conflicts "--autotools", "--cmake", "--crystal", "--go", "--meson", "--node",
-                "--perl", "--python", "--ruby", "--rust", "--cask"
-      conflicts "--cask", "--HEAD"
-      conflicts "--cask", "--set-license"
-
-      named_args :url, number: 1
-    end
-  end
-
-  # Create a formula from a tarball URL.
-  def create
-    args = create_args.parse
-
-    path = if args.cask?
-      create_cask(args: args)
-    else
-      create_formula(args: args)
-    end
-
-    exec_editor path
-  end
-
-  def create_cask(args:)
-    raise UsageError, "The `--set-name` flag is required for creating casks." if args.set_name.blank?
-
-    url = args.named.first
-    name = args.set_name
-    token = Cask::Utils.token_from(args.set_name)
-
-    cask_tap = Tap.fetch(args.tap || "homebrew/cask")
-    raise TapUnavailableError, args.tap unless cask_tap.installed?
-
-    cask_path = Cask::CaskLoader.path("#{cask_tap}/#{token}")
-    cask_path.dirname.mkpath unless cask_path.dirname.exist?
-    raise Cask::CaskAlreadyCreatedError, token if cask_path.exist?
-
-    version = if args.set_version
-      Version.create(args.set_version)
-    else
-      Version.detect(url.gsub(token, "").gsub(/x86(_64)?/, ""))
-    end
-
-    interpolated_url, sha256 = if version.null?
-      [url, ""]
-    else
-      sha256 = if args.no_fetch?
-        ""
-      else
-        strategy = DownloadStrategyDetector.detect(url)
-        downloader = strategy.new(url, token, version.to_s, cache: Cask::Cache.path)
-        downloader.fetch
-        downloader.cached_location.sha256
+  module DevCmd
+    class Create < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Generate a formula or, with `--cask`, a cask for the downloadable file at <URL>
+          and open it in the editor. Homebrew will attempt to automatically derive the
+          formula name and version, but if it fails, you'll have to make your own template.
+          The `wget` formula serves as a simple example. For the complete API, see:
+          <https://rubydoc.brew.sh/Formula>
+        EOS
+        switch "--autotools",
+               description: "Create a basic template for an Autotools-style build."
+        switch "--cask",
+               description: "Create a basic template for a cask."
+        switch "--cmake",
+               description: "Create a basic template for a CMake-style build."
+        switch "--crystal",
+               description: "Create a basic template for a Crystal build."
+        switch "--go",
+               description: "Create a basic template for a Go build."
+        switch "--meson",
+               description: "Create a basic template for a Meson-style build."
+        switch "--node",
+               description: "Create a basic template for a Node build."
+        switch "--perl",
+               description: "Create a basic template for a Perl build."
+        switch "--python",
+               description: "Create a basic template for a Python build."
+        switch "--ruby",
+               description: "Create a basic template for a Ruby build."
+        switch "--rust",
+               description: "Create a basic template for a Rust build."
+        switch "--no-fetch",
+               description: "Homebrew will not download <URL> to the cache and will thus not add its SHA-256 " \
+                            "to the formula for you, nor will it check the GitHub API for GitHub projects " \
+                            "(to fill out its description and homepage)."
+        switch "--HEAD",
+               description: "Indicate that <URL> points to the package's repository rather than a file."
+        flag   "--set-name=",
+               description: "Explicitly set the <name> of the new formula or cask."
+        flag   "--set-version=",
+               description: "Explicitly set the <version> of the new formula or cask."
+        flag   "--set-license=",
+               description: "Explicitly set the <license> of the new formula."
+        flag   "--tap=",
+               description: "Generate the new formula within the given tap, specified as <user>`/`<repo>."
+        switch "-f", "--force",
+               description: "Ignore errors for disallowed formula names and names that shadow aliases."
+
+        conflicts "--autotools", "--cmake", "--crystal", "--go", "--meson", "--node",
+                  "--perl", "--python", "--ruby", "--rust", "--cask"
+        conflicts "--cask", "--HEAD"
+        conflicts "--cask", "--set-license"
+
+        named_args :url, number: 1
       end
 
-      [url.gsub(version.to_s, "\#{version}"), sha256]
-    end
-
-    cask_path.atomic_write <<~RUBY
-      cask "#{token}" do
-        version "#{version}"
-        sha256 "#{sha256}"
+      # Create a formula from a tarball URL.
+      sig { override.void }
+      def run
+        path = if args.cask?
+          create_cask
+        else
+          create_formula
+        end
 
-        url "#{interpolated_url}"
-        name "#{name}"
-        desc ""
-        homepage ""
-
-        app ""
+        exec_editor path
       end
-    RUBY
-
-    puts "Please run `brew audit --cask --new #{token}` before submitting, thanks."
-    cask_path
-  end
-
-  def create_formula(args:)
-    fc = FormulaCreator.new(args)
-    fc.name = args.set_name
-    fc.version = args.set_version
-    fc.license = args.set_license
-    fc.tap = Tap.fetch(args.tap || "homebrew/core")
-    raise TapUnavailableError, args.tap unless fc.tap.installed?
-
-    fc.url = args.named.first # Pull the first (and only) URL from ARGV
-
-    fc.mode = if args.autotools?
-      :autotools
-    elsif args.cmake?
-      :cmake
-    elsif args.crystal?
-      :crystal
-    elsif args.go?
-      :go
-    elsif args.meson?
-      :meson
-    elsif args.node?
-      :node
-    elsif args.perl?
-      :perl
-    elsif args.python?
-      :python
-    elsif args.ruby?
-      :ruby
-    elsif args.rust?
-      :rust
-    end
 
-    if fc.name.nil? || fc.name.strip.empty?
-      stem = Pathname.new(fc.url).stem.rpartition("=").last
-      print "Formula name [#{stem}]: "
-      fc.name = __gets || stem
-      fc.update_path
-    end
+      private
+
+      sig { returns(Pathname) }
+      def create_cask
+        url = args.named.first
+        name = if args.set_name.blank?
+          stem = Pathname.new(url).stem.rpartition("=").last
+          print "Cask name [#{stem}]: "
+          __gets || stem
+        else
+          args.set_name
+        end
+        token = Cask::Utils.token_from(T.must(name))
+
+        cask_tap = Tap.fetch(args.tap || "homebrew/cask")
+        raise TapUnavailableError, cask_tap.name unless cask_tap.installed?
+
+        cask_path = cask_tap.new_cask_path(token)
+        cask_path.dirname.mkpath unless cask_path.dirname.exist?
+        raise Cask::CaskAlreadyCreatedError, token if cask_path.exist?
+
+        version = if args.set_version
+          Version.new(T.must(args.set_version))
+        else
+          Version.detect(url.gsub(token, "").gsub(/x86(_64)?/, ""))
+        end
+
+        interpolated_url, sha256 = if version.null?
+          [url, ""]
+        else
+          sha256 = if args.no_fetch?
+            ""
+          else
+            strategy = DownloadStrategyDetector.detect(url)
+            downloader = strategy.new(url, token, version.to_s, cache: Cask::Cache.path)
+            downloader.fetch
+            downloader.cached_location.sha256
+          end
+
+          [url.gsub(version.to_s, "\#{version}"), sha256]
+        end
+
+        cask_path.atomic_write <<~RUBY
+          # Documentation: https://docs.brew.sh/Cask-Cookbook
+          #                https://docs.brew.sh/Adding-Software-to-Homebrew#cask-stanzas
+          # PLEASE REMOVE ALL GENERATED COMMENTS BEFORE SUBMITTING YOUR PULL REQUEST!
+          cask "#{token}" do
+            version "#{version}"
+            sha256 "#{sha256}"
+
+            url "#{interpolated_url}"
+            name "#{name}"
+            desc ""
+            homepage ""
+
+            # Documentation: https://docs.brew.sh/Brew-Livecheck
+            livecheck do
+              url ""
+              strategy ""
+            end
+
+            depends_on macos: ""
+
+            app ""
+
+            # Documentation: https://docs.brew.sh/Cask-Cookbook#stanza-zap
+            zap trash: ""
+          end
+        RUBY
+
+        puts "Please run `brew audit --cask --new #{token}` before submitting, thanks."
+        cask_path
+      end
 
-    # Check for disallowed formula, or names that shadow aliases,
-    # unless --force is specified.
-    unless args.force?
-      if (reason = MissingFormula.disallowed_reason(fc.name))
-        odie <<~EOS
-          The formula '#{fc.name}' is not allowed to be created.
-          #{reason}
-          If you really want to create this formula use `--force`.
+      sig { returns(Pathname) }
+      def create_formula
+        mode = if args.autotools?
+          :autotools
+        elsif args.cmake?
+          :cmake
+        elsif args.crystal?
+          :crystal
+        elsif args.go?
+          :go
+        elsif args.meson?
+          :meson
+        elsif args.node?
+          :node
+        elsif args.perl?
+          :perl
+        elsif args.python?
+          :python
+        elsif args.ruby?
+          :ruby
+        elsif args.rust?
+          :rust
+        end
+
+        fc = FormulaCreator.new(
+          args.set_name,
+          args.set_version,
+          tap:     args.tap,
+          url:     args.named.first,
+          mode:,
+          license: args.set_license,
+          fetch:   !args.no_fetch?,
+          head:    args.HEAD?,
+        )
+        fc.parse_url
+        # ask for confirmation if name wasn't passed explicitly
+        if args.set_name.blank?
+          print "Formula name [#{fc.name}]: "
+          fc.name = __gets || fc.name
+        end
+
+        fc.verify
+
+        # Check for disallowed formula, or names that shadow aliases,
+        # unless --force is specified.
+        unless args.force?
+          if (reason = MissingFormula.disallowed_reason(fc.name))
+            odie <<~EOS
+              The formula '#{fc.name}' is not allowed to be created.
+              #{reason}
+              If you really want to create this formula use `--force`.
+            EOS
+          end
+
+          Homebrew.with_no_api_env do
+            if Formula.aliases.include? fc.name
+              realname = Formulary.canonical_name(fc.name)
+              odie <<~EOS
+                The formula '#{realname}' is already aliased to '#{fc.name}'.
+                Please check that you are not creating a duplicate.
+                To force creation use `--force`.
+              EOS
+            end
+          end
+        end
+
+        path = fc.write_formula!
+
+        formula = Homebrew.with_no_api_env do
+          Formula[fc.name]
+        end
+        PyPI.update_python_resources! formula, ignore_non_pypi_packages: true if args.python?
+
+        puts <<~EOS
+          Please run the following command before submitting:
+            HOMEBREW_NO_INSTALL_FROM_API=1 brew audit --new #{fc.name}
         EOS
+        path
       end
 
-      if Formula.aliases.include? fc.name
-        realname = Formulary.canonical_name(fc.name)
-        odie <<~EOS
-          The formula '#{realname}' is already aliased to '#{fc.name}'.
-          Please check that you are not creating a duplicate.
-          To force creation use `--force`.
-        EOS
+      sig { returns(T.nilable(String)) }
+      def __gets
+        gots = $stdin.gets.chomp
+        gots.empty? ? nil : gots
       end
     end
-
-    fc.generate!
-
-    PyPI.update_python_resources! Formula[fc.name], ignore_non_pypi_packages: true if args.python?
-
-    puts "Please run `brew audit --new #{fc.name}` before submitting, thanks."
-    fc.path
-  end
-
-  def __gets
-    gots = $stdin.gets.chomp
-    gots.empty? ? nil : gots
   end
 end
diff --git a/Library/Homebrew/dev-cmd/debugger.rb b/Library/Homebrew/dev-cmd/debugger.rb
new file mode 100644
index 0000000000000..9783eafc635ca
--- /dev/null
+++ b/Library/Homebrew/dev-cmd/debugger.rb
@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  module DevCmd
+    class Debugger < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Run the specified Homebrew command in debug mode.
+
+          To pass flags to the command, use `--` to separate them from the `brew` flags.
+          For example: `brew debugger -- list --formula`.
+        EOS
+        switch "-O", "--open",
+               description: "Start remote debugging over a Unix socket."
+
+        named_args :command, min: 1
+      end
+
+      sig { override.void }
+      def run
+        raise UsageError, "Debugger is only supported with portable Ruby!" unless HOMEBREW_USING_PORTABLE_RUBY
+
+        unless Commands.valid_ruby_cmd?(args.named.first)
+          raise UsageError, "`#{args.named.first}` is not a valid Ruby command!"
+        end
+
+        brew_rb = (HOMEBREW_LIBRARY_PATH/"brew.rb").resolved_path
+        debugger_method = if args.open?
+          "open"
+        else
+          "start"
+        end
+
+        env = {}
+        env[:RUBY_DEBUG_FORK_MODE] = "parent"
+        env[:RUBY_DEBUG_NONSTOP] = "1" unless ENV["HOMEBREW_RDBG"]
+
+        with_env(**env) do
+          system(*HOMEBREW_RUBY_EXEC_ARGS,
+                 "-I", $LOAD_PATH.join(File::PATH_SEPARATOR),
+                 "-rdebug/#{debugger_method}",
+                 brew_rb, *args.named)
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/dev-cmd/determine-test-runners.rb b/Library/Homebrew/dev-cmd/determine-test-runners.rb
new file mode 100644
index 0000000000000..cba08ded8ec7a
--- /dev/null
+++ b/Library/Homebrew/dev-cmd/determine-test-runners.rb
@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "test_runner_formula"
+require "github_runner_matrix"
+
+module Homebrew
+  module DevCmd
+    class DetermineTestRunners < AbstractCommand
+      cmd_args do
+        usage_banner <<~EOS
+          `determine-test-runners` {<testing-formulae> [<deleted-formulae>]|--all-supported}
+
+          Determines the runners used to test formulae or their dependents. For internal use in Homebrew taps.
+        EOS
+        switch "--all-supported",
+               description: "Instead of selecting runners based on the chosen formula, return all supported runners."
+        switch "--eval-all",
+               description: "Evaluate all available formulae, whether installed or not, to determine testing " \
+                            "dependents.",
+               env:         :eval_all
+        switch "--dependents",
+               description: "Determine runners for testing dependents. Requires `--eval-all` or `HOMEBREW_EVAL_ALL`.",
+               depends_on:  "--eval-all"
+
+        named_args max: 2
+
+        conflicts "--all-supported", "--dependents"
+
+        hide_from_man_page!
+      end
+
+      sig { override.void }
+      def run
+        if args.no_named? && !args.all_supported?
+          raise Homebrew::CLI::MinNamedArgumentsError, 1
+        elsif args.all_supported? && !args.no_named?
+          raise UsageError, "`--all-supported` is mutually exclusive to other arguments."
+        end
+
+        testing_formulae = args.named.first&.split(",").to_a
+        testing_formulae.map! { |name| TestRunnerFormula.new(Formulary.factory(name), eval_all: args.eval_all?) }
+                        .freeze
+        deleted_formulae = args.named.second&.split(",").to_a.freeze
+        runner_matrix = GitHubRunnerMatrix.new(testing_formulae, deleted_formulae,
+                                               all_supported:    args.all_supported?,
+                                               dependent_matrix: args.dependents?)
+        runners = runner_matrix.active_runner_specs_hash
+
+        ohai "Runners", JSON.pretty_generate(runners)
+
+        github_output = ENV.fetch("GITHUB_OUTPUT")
+        File.open(github_output, "a") do |f|
+          f.puts("runners=#{runners.to_json}")
+          f.puts("runners_present=#{runners.present?}")
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/dev-cmd/dispatch-build-bottle.rb b/Library/Homebrew/dev-cmd/dispatch-build-bottle.rb
index 4fd2780245b07..0a9be38c9d57d 100644
--- a/Library/Homebrew/dev-cmd/dispatch-build-bottle.rb
+++ b/Library/Homebrew/dev-cmd/dispatch-build-bottle.rb
@@ -1,97 +1,94 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
+require "tap"
+require "utils/bottles"
 require "utils/github"
 
 module Homebrew
-  extend T::Sig
+  module DevCmd
+    class DispatchBuildBottle < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Build bottles for these formulae with GitHub Actions.
+        EOS
+        flag   "--tap=",
+               description: "Target tap repository (default: `homebrew/core`)."
+        flag   "--timeout=",
+               description: "Build timeout (in minutes, default: 60)."
+        flag   "--issue=",
+               description: "If specified, post a comment to this issue number if the job fails."
+        comma_array "--macos",
+                    description: "macOS version (or comma-separated list of versions) the bottle should be built for."
+        flag   "--workflow=",
+               description: "Dispatch specified workflow (default: `dispatch-build-bottle.yml`)."
+        switch "--upload",
+               description: "Upload built bottles."
+        switch "--linux",
+               description: "Dispatch bottle for Linux (using GitHub runners)."
+        switch "--linux-self-hosted",
+               description: "Dispatch bottle for Linux (using self-hosted runner)."
+        switch "--linux-wheezy",
+               description: "Use Debian Wheezy container for building the bottle on Linux."
 
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def dispatch_build_bottle_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Build bottles for these formulae with GitHub Actions.
-      EOS
-      flag   "--tap=",
-             description: "Target tap repository (default: `homebrew/core`)."
-      flag   "--timeout=",
-             description: "Build timeout (in minutes, default: 60)."
-      flag   "--issue=",
-             description: "If specified, post a comment to this issue number if the job fails."
-      comma_array "--macos=",
-                  description: "Version(s) of macOS the bottle should be built for."
-      flag   "--workflow=",
-             description: "Dispatch specified workflow (default: `dispatch-build-bottle.yml`)."
-      switch "--upload",
-             description: "Upload built bottles."
-      switch "--linux",
-             description: "Dispatch bottle for Linux (using GitHub runners)."
-      switch "--linux-self-hosted",
-             description: "Dispatch bottle for Linux (using self-hosted runner)."
-      switch "--linux-wheezy",
-             description: "Use Debian Wheezy container for building the bottle on Linux."
-
-      conflicts "--linux", "--linux-self-hosted"
-      named_args :formula, min: 1
-    end
-  end
+        conflicts "--linux", "--linux-self-hosted"
+        named_args :formula, min: 1
+      end
 
-  def dispatch_build_bottle
-    args = dispatch_build_bottle_args.parse
+      sig { override.void }
+      def run
+        tap = Tap.fetch(args.tap || CoreTap.instance.name)
+        user, repo = tap.full_name.split("/")
+        ref = "master"
+        workflow = args.workflow || "dispatch-build-bottle.yml"
 
-    tap = Tap.fetch(args.tap || CoreTap.instance.name)
-    user, repo = tap.full_name.split("/")
-    ref = "master"
-    workflow = args.workflow || "dispatch-build-bottle.yml"
+        runners = []
 
-    runners = []
+        if (macos = args.macos&.compact_blank) && macos.present?
+          runners += macos.map do |element|
+            # We accept runner name syntax (11-arm64) or bottle syntax (arm64_big_sur)
+            os, arch = element.then do |s|
+              tag = Utils::Bottles::Tag.from_symbol(s.to_sym)
+              [tag.to_macos_version, tag.arch]
+            rescue ArgumentError, MacOSVersion::Error
+              os, arch = s.split("-", 2)
+              [MacOSVersion.new(os), arch&.to_sym]
+            end
 
-    if (macos = args.macos&.compact_blank) && macos.present?
-      runners += macos.map do |element|
-        # We accept runner name syntax (11-arm64) or bottle syntax (arm64_big_sur)
-        os, arch = element.then do |s|
-          tag = Utils::Bottles::Tag.from_symbol(s.to_sym)
-          [tag.to_macos_version, tag.arch]
-        rescue ArgumentError, MacOSVersionError
-          os, arch = s.split("-", 2)
-          [MacOS::Version.new(os), arch&.to_sym]
+            if arch.present? && arch != :x86_64
+              "#{os}-#{arch}"
+            else
+              os.to_s
+            end
+          end
         end
 
-        if arch.present? && arch != :x86_64
-          "#{os}-#{arch}"
-        else
-          os.to_s
+        if args.linux?
+          runners << "ubuntu-22.04"
+        elsif args.linux_self_hosted?
+          runners << "linux-self-hosted-1"
         end
-      end
-    end
-
-    if args.linux?
-      runners << "ubuntu-latest"
-    elsif args.linux_self_hosted?
-      runners << "linux-self-hosted-1"
-    end
 
-    raise UsageError, "Must specify --macos or --linux or --linux-self-hosted option" if runners.empty?
+        raise UsageError, "Must specify `--macos`, `--linux` or `--linux-self-hosted` option." if runners.empty?
 
-    args.named.to_resolved_formulae.each do |formula|
-      # Required inputs
-      inputs = {
-        runner:  runners.join(","),
-        formula: formula.name,
-      }
+        args.named.to_resolved_formulae.each do |formula|
+          # Required inputs
+          inputs = {
+            runner:  runners.join(","),
+            formula: formula.name,
+          }
 
-      # Optional inputs
-      # These cannot be passed as nil to GitHub API
-      inputs[:timeout] = args.timeout if args.timeout
-      inputs[:issue] = args.issue if args.issue
-      inputs[:upload] = args.upload?.to_s if args.upload?
-      inputs[:wheezy] = args.linux_wheezy?.to_s if args.linux_wheezy?
+          # Optional inputs
+          # These cannot be passed as nil to GitHub API
+          inputs[:timeout] = args.timeout if args.timeout
+          inputs[:issue] = args.issue if args.issue
+          inputs[:upload] = args.upload?
 
-      ohai "Dispatching #{tap} bottling request of formula \"#{formula.name}\" for #{runners.join(", ")}"
-      GitHub.workflow_dispatch_event(user, repo, workflow, ref, inputs)
+          ohai "Dispatching #{tap} bottling request of formula \"#{formula.name}\" for #{runners.join(", ")}"
+          GitHub.workflow_dispatch_event(user, repo, workflow, ref, **inputs)
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/edit.rb b/Library/Homebrew/dev-cmd/edit.rb
index 5b185cf3f2558..9164c553d7e3a 100644
--- a/Library/Homebrew/dev-cmd/edit.rb
+++ b/Library/Homebrew/dev-cmd/edit.rb
@@ -1,82 +1,136 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
+  module DevCmd
+    class Edit < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Open a <formula>, <cask> or <tap> in the editor set by `EDITOR` or `HOMEBREW_EDITOR`,
+          or open the Homebrew repository for editing if no argument is provided.
+        EOS
 
-  module_function
+        switch "--formula", "--formulae",
+               description: "Treat all named arguments as formulae."
+        switch "--cask", "--casks",
+               description: "Treat all named arguments as casks."
+        switch "--print-path",
+               description: "Print the file path to be edited, without opening an editor."
 
-  sig { returns(CLI::Parser) }
-  def edit_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Open a <formula> or <cask> in the editor set by `EDITOR` or `HOMEBREW_EDITOR`,
-        or open the Homebrew repository for editing if no formula is provided.
-      EOS
+        conflicts "--formula", "--cask"
 
-      switch "--formula", "--formulae",
-             description: "Treat all named arguments as formulae."
-      switch "--cask", "--casks",
-             description: "Treat all named arguments as casks."
-      switch "--print-path",
-             description: "Print the file path to be edited, without opening an editor."
+        named_args [:formula, :cask, :tap], without_api: true
+      end
 
-      conflicts "--formula", "--cask"
+      sig { override.void }
+      def run
+        ENV["COLORTERM"] = ENV.fetch("HOMEBREW_COLORTERM", nil)
+        # Recover $TMPDIR for emacsclient
+        ENV["TMPDIR"] = ENV.fetch("HOMEBREW_TMPDIR", nil)
 
-      named_args [:formula, :cask]
-    end
-  end
+        unless (HOMEBREW_REPOSITORY/".git").directory?
+          odie <<~EOS
+            Changes will be lost!
+            The first time you `brew update`, all local changes will be lost; you should
+            thus `brew update` before you `brew edit`!
+          EOS
+        end
 
-  sig { void }
-  def edit
-    args = edit_args.parse
+        paths = if args.named.empty?
+          # Sublime requires opting into the project editing path,
+          # as opposed to VS Code which will infer from the .vscode path
+          if which_editor(silent: true) == "subl"
+            ["--project", HOMEBREW_REPOSITORY/".sublime/homebrew.sublime-project"]
+          else
+            # If no formulae are listed, open the project root in an editor.
+            [HOMEBREW_REPOSITORY]
+          end
+        else
+          expanded_paths = args.named.to_paths
+          expanded_paths.each do |path|
+            raise_with_message!(path, args.cask?) unless path.exist?
+          end
+          expanded_paths
+        end
 
-    unless (HOMEBREW_REPOSITORY/".git").directory?
-      odie <<~EOS
-        Changes will be lost!
-        The first time you `brew update`, all local changes will be lost; you should
-        thus `brew update` before you `brew edit`!
-      EOS
-    end
+        if args.print_path?
+          paths.each { puts _1 }
+          return
+        end
 
-    paths = if args.named.empty?
-      # Sublime requires opting into the project editing path,
-      # as opposed to VS Code which will infer from the .vscode path
-      if which_editor == "subl"
-        ["--project", "#{HOMEBREW_REPOSITORY}/.sublime/homebrew.sublime-project"]
-      else
-        # If no formulae are listed, open the project root in an editor.
-        [HOMEBREW_REPOSITORY]
-      end
-    else
-      args.named.to_paths.select do |path|
-        next path if path.exist?
-
-        message = if args.cask?
-          <<~EOS
-            #{path.basename(".rb")} doesn't exist on disk. \
-            Run #{Formatter.identifier("brew create --cask --set-name #{path.basename(".rb")} $URL")} \
-            to create a new cask!
+        exec_editor(*paths)
+
+        if paths.any? do |path|
+             next if path == "--project"
+
+             !Homebrew::EnvConfig.no_install_from_api? &&
+             !Homebrew::EnvConfig.no_env_hints? &&
+             (core_formula_path?(path) || core_cask_path?(path) || core_formula_tap?(path) || core_cask_tap?(path))
+           end
+          opoo <<~EOS
+            `brew install` ignores locally edited casks and formulae if
+            HOMEBREW_NO_INSTALL_FROM_API is not set.
           EOS
+        end
+      end
+
+      private
+
+      sig { params(path: Pathname).returns(T::Boolean) }
+      def core_formula_path?(path)
+        path.fnmatch?("**/homebrew-core/Formula/**.rb", File::FNM_DOTMATCH)
+      end
+
+      sig { params(path: Pathname).returns(T::Boolean) }
+      def core_cask_path?(path)
+        path.fnmatch?("**/homebrew-cask/Casks/**.rb", File::FNM_DOTMATCH)
+      end
+
+      sig { params(path: Pathname).returns(T::Boolean) }
+      def core_formula_tap?(path)
+        path == CoreTap.instance.path
+      end
+
+      sig { params(path: Pathname).returns(T::Boolean) }
+      def core_cask_tap?(path)
+        path == CoreCaskTap.instance.path
+      end
+
+      sig { params(path: Pathname, cask: T::Boolean).returns(T.noreturn) }
+      def raise_with_message!(path, cask)
+        name = path.basename(".rb").to_s
+
+        if (tap_match = Regexp.new("#{HOMEBREW_TAP_DIR_REGEX.source}$").match(path.to_s))
+          raise TapUnavailableError, CoreTap.instance.name if core_formula_tap?(path)
+          raise TapUnavailableError, CoreCaskTap.instance.name if core_cask_tap?(path)
+
+          raise TapUnavailableError, "#{tap_match[:user]}/#{tap_match[:repo]}"
+        elsif cask || core_cask_path?(path)
+          if !CoreCaskTap.instance.installed? && Homebrew::API::Cask.all_casks.key?(name)
+            command = "brew tap --force #{CoreCaskTap.instance.name}"
+            action = "tap #{CoreCaskTap.instance.name}"
+          else
+            command = "brew create --cask --set-name #{name} $URL"
+            action = "create a new cask"
+          end
+        elsif core_formula_path?(path) &&
+              !CoreTap.instance.installed? &&
+              Homebrew::API::Formula.all_formulae.key?(name)
+          command = "brew tap --force #{CoreTap.instance.name}"
+          action = "tap #{CoreTap.instance.name}"
         else
-          <<~EOS
-            #{path} doesn't exist on disk. \
-            Run #{Formatter.identifier("brew create --formula --set-name #{path.basename} $URL")} \
-            to create a new formula!
-          EOS
+          command = "brew create --set-name #{name} $URL"
+          action = "create a new formula"
         end
-        raise UsageError, message
-      end.presence
-    end
 
-    if args.print_path?
-      paths.each(&method(:puts))
-      return
+        raise UsageError, <<~EOS
+          #{name} doesn't exist on disk.
+          Run #{Formatter.identifier(command)} to #{action}!
+        EOS
+      end
     end
-
-    exec_editor(*paths)
   end
 end
diff --git a/Library/Homebrew/dev-cmd/extract.rb b/Library/Homebrew/dev-cmd/extract.rb
index 91ade54b16085..d186d4f0d1ced 100644
--- a/Library/Homebrew/dev-cmd/extract.rb
+++ b/Library/Homebrew/dev-cmd/extract.rb
@@ -1,218 +1,240 @@
-# typed: false
+# typed: true # rubocop:disable Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 require "utils/git"
 require "formulary"
 require "software_spec"
 require "tap"
 
-def with_monkey_patch
-  BottleSpecification.class_eval do
-    alias_method :old_method_missing, :method_missing if method_defined?(:method_missing)
-    define_method(:method_missing) { |*| }
-  end
-
-  Module.class_eval do
-    alias_method :old_method_missing, :method_missing if method_defined?(:method_missing)
-    define_method(:method_missing) { |*| }
-  end
+module Homebrew
+  module DevCmd
+    class Extract < AbstractCommand
+      BOTTLE_BLOCK_REGEX = /  bottle (?:do.+?end|:[a-z]+)\n\n/m
+
+      cmd_args do
+        usage_banner "`extract` [`--version=`] [`--git-revision=`] [`--force`] <formula> <tap>"
+        description <<~EOS
+          Look through repository history to find the most recent version of <formula> and
+          create a copy in <tap>. Specifically, the command will create the new
+          formula file at <tap>`/Formula/`<formula>`@`<version>`.rb`. If the tap is not
+          installed yet, attempt to install/clone the tap before continuing. To extract
+          a formula from a tap that is not `homebrew/core` use its fully-qualified form of
+          <user>`/`<repo>`/`<formula>.
+        EOS
+        flag   "--git-revision=",
+               description: "Search for the specified <version> of <formula> starting at <revision> instead of HEAD."
+        flag   "--version=",
+               description: "Extract the specified <version> of <formula> instead of the most recent."
+        switch "-f", "--force",
+               description: "Overwrite the destination formula if it already exists."
+
+        named_args [:formula, :tap], number: 2, without_api: true
+      end
 
-  Resource.class_eval do
-    alias_method :old_method_missing, :method_missing if method_defined?(:method_missing)
-    define_method(:method_missing) { |*| }
-  end
+      sig { override.void }
+      def run
+        if (tap_with_name = args.named.first&.then { Tap.with_formula_name(_1) })
+          source_tap, name = tap_with_name
+        else
+          name = args.named.first.downcase
+          source_tap = CoreTap.instance
+        end
+        raise TapFormulaUnavailableError.new(source_tap, name) unless source_tap.installed?
 
-  DependencyCollector.class_eval do
-    alias_method :old_parse_symbol_spec, :parse_symbol_spec if method_defined?(:parse_symbol_spec)
-    define_method(:parse_symbol_spec) { |*| }
-  end
+        destination_tap = Tap.fetch(args.named.second)
+        unless Homebrew::EnvConfig.developer?
+          odie "Cannot extract formula to homebrew/core!" if destination_tap.core_tap?
+          odie "Cannot extract formula to homebrew/cask!" if destination_tap.core_cask_tap?
+          odie "Cannot extract formula to the same tap!" if destination_tap == source_tap
+        end
+        destination_tap.install unless destination_tap.installed?
+
+        repo = source_tap.path
+        start_rev = args.git_revision || "HEAD"
+        pattern = if source_tap.core_tap?
+          [source_tap.new_formula_path(name), repo/"Formula/#{name}.rb"].uniq
+        else
+          # A formula can technically live in the root directory of a tap or in any of its subdirectories
+          [repo/"#{name}.rb", repo/"**/#{name}.rb"]
+        end
 
-  yield
-ensure
-  BottleSpecification.class_eval do
-    if method_defined?(:old_method_missing)
-      alias_method :method_missing, :old_method_missing
-      undef :old_method_missing
-    end
-  end
+        if args.version
+          ohai "Searching repository history"
+          version = args.version
+          version_segments = Gem::Version.new(version).segments if Gem::Version.correct?(version)
+          rev = T.let(nil, T.nilable(String))
+          test_formula = T.let(nil, T.nilable(Formula))
+          result = ""
+          loop do
+            rev = rev.nil? ? start_rev : "#{rev}~1"
+            rev, (path,) = Utils::Git.last_revision_commit_of_files(repo, pattern, before_commit: rev)
+            if rev.nil? && source_tap.shallow?
+              odie <<~EOS
+                Could not find #{name} but #{source_tap} is a shallow clone!
+                Try again after running:
+                  git -C "#{source_tap.path}" fetch --unshallow
+              EOS
+            elsif rev.nil?
+              odie "Could not find #{name}! The formula or version may not have existed."
+            end
+
+            file = repo/path
+            result = Utils::Git.last_revision_of_file(repo, file, before_commit: rev)
+            if result.empty?
+              odebug "Skipping revision #{rev} - file is empty at this revision"
+              next
+            end
+
+            test_formula = formula_at_revision(repo, name, file, rev)
+            break if test_formula.nil? || test_formula.version == version
+
+            if version_segments && Gem::Version.correct?(test_formula.version)
+              test_formula_version_segments = Gem::Version.new(test_formula.version).segments
+              if version_segments.length < test_formula_version_segments.length
+                odebug "Apply semantic versioning with #{test_formula_version_segments}"
+                break if version_segments == test_formula_version_segments.first(version_segments.length)
+              end
+            end
+
+            odebug "Trying #{test_formula.version} from revision #{rev} against desired #{version}"
+          end
+          odie "Could not find #{name}! The formula or version may not have existed." if test_formula.nil?
+        else
+          # Search in the root directory of `repository` as well as recursively in all of its subdirectories.
+          files = if start_rev == "HEAD"
+            Dir[repo/"{,**/}"].filter_map do |dir|
+              Pathname.glob("#{dir}/#{name}.rb").find(&:file?)
+            end
+          else
+            []
+          end
 
-  Module.class_eval do
-    if method_defined?(:old_method_missing)
-      alias_method :method_missing, :old_method_missing
-      undef :old_method_missing
-    end
-  end
+          if files.empty?
+            ohai "Searching repository history"
+            rev, (path,) = Utils::Git.last_revision_commit_of_files(repo, pattern, before_commit: start_rev)
+            odie "Could not find #{name}! The formula or version may not have existed." if rev.nil?
+            file = repo/path
+            version = T.must(formula_at_revision(repo, name, file, rev)).version
+            result = Utils::Git.last_revision_of_file(repo, file)
+          else
+            file = files.fetch(0).realpath
+            rev = T.let("HEAD", T.nilable(String))
+            version = Formulary.factory(file).version
+            result = File.read(file)
+          end
+        end
 
-  Resource.class_eval do
-    if method_defined?(:old_method_missing)
-      alias_method :method_missing, :old_method_missing
-      undef :old_method_missing
-    end
-  end
+        # The class name has to be renamed to match the new filename,
+        # e.g. Foo version 1.2.3 becomes FooAT123 and resides in Foo@1.2.3.rb.
+        class_name = Formulary.class_s(name)
+
+        # The version can only contain digits with decimals in between.
+        version_string = version.to_s
+                                .sub(/\D*(.+?)\D*$/, "\\1")
+                                .gsub(/\D+/, ".")
+
+        # Remove any existing version suffixes, as a new one will be added later.
+        name.sub!(/\b@(.*)\z\b/i, "")
+        versioned_name = Formulary.class_s("#{name}@#{version_string}")
+        result.sub!("class #{class_name} < Formula", "class #{versioned_name} < Formula")
+
+        # Remove bottle blocks, as they won't work.
+        result.sub!(BOTTLE_BLOCK_REGEX, "")
+
+        path = destination_tap.path/"Formula/#{name}@#{version_string}.rb"
+        if path.exist?
+          unless args.force?
+            odie <<~EOS
+              Destination formula already exists: #{path}
+              To overwrite it and continue anyways, run:
+                brew extract --force --version=#{version} #{name} #{destination_tap.name}
+            EOS
+          end
+          odebug "Overwriting existing formula at #{path}"
+          path.delete
+        end
+        ohai "Writing formula for #{name} at #{version} from revision #{rev} to:", path
+        path.dirname.mkpath
+        path.write result
+      end
 
-  DependencyCollector.class_eval do
-    if method_defined?(:old_parse_symbol_spec)
-      alias_method :parse_symbol_spec, :old_parse_symbol_spec
-      undef :old_parse_symbol_spec
-    end
-  end
-end
+      private
 
-module Homebrew
-  extend T::Sig
-
-  module_function
-
-  BOTTLE_BLOCK_REGEX = /  bottle (?:do.+?end|:[a-z]+)\n\n/m.freeze
-
-  sig { returns(CLI::Parser) }
-  def extract_args
-    Homebrew::CLI::Parser.new do
-      usage_banner "`extract` [<--version>`=`] [<--force>] <formula> <tap>"
-      description <<~EOS
-        Look through repository history to find the most recent version of <formula> and
-        create a copy in <tap>. Specifically, the command will create the new
-        formula file at <tap>`/Formula/`<formula>`@`<version>`.rb`. If the tap is not
-        installed yet, attempt to install/clone the tap before continuing. To extract
-        a formula from a tap that is not `homebrew/core` use its fully-qualified form of
-        <user>`/`<repo>`/`<formula>.
-      EOS
-      flag   "--version=",
-             description: "Extract the specified <version> of <formula> instead of the most recent."
-      switch "-f", "--force",
-             description: "Overwrite the destination formula if it already exists."
-
-      named_args [:formula, :tap], number: 2
-    end
-  end
+      sig { params(repo: Pathname, name: String, file: Pathname, rev: String).returns(T.nilable(Formula)) }
+      def formula_at_revision(repo, name, file, rev)
+        return if rev.empty?
 
-  def extract
-    args = extract_args.parse
+        contents = Utils::Git.last_revision_of_file(repo, file, before_commit: rev)
+        contents.gsub!("@url=", "url ")
+        contents.gsub!("require 'brewkit'", "require 'formula'")
+        contents.sub!(BOTTLE_BLOCK_REGEX, "")
+        with_monkey_patch { Formulary.from_contents(name, file, contents, ignore_errors: true) }
+      end
 
-    if (match = args.named.first.match(HOMEBREW_TAP_FORMULA_REGEX))
-      name = match[3].downcase
-      source_tap = Tap.fetch(match[1], match[2])
-      raise TapFormulaUnavailableError.new(source_tap, name) unless source_tap.installed?
-    else
-      name = args.named.first.downcase
-      source_tap = CoreTap.instance
-    end
+      def with_monkey_patch
+        # Since `method_defined?` is not a supported type guard, the use of `alias_method` below is not typesafe:
+        BottleSpecification.class_eval do
+          T.unsafe(self).alias_method :old_method_missing, :method_missing if method_defined?(:method_missing)
+          define_method(:method_missing) do |*_|
+            # do nothing
+          end
+        end
 
-    destination_tap = Tap.fetch(args.named.second)
-    unless Homebrew::EnvConfig.developer?
-      odie "Cannot extract formula to homebrew/core!" if destination_tap.core_tap?
-      odie "Cannot extract formula to the same tap!" if destination_tap == source_tap
-    end
-    destination_tap.install unless destination_tap.installed?
-
-    repo = source_tap.path
-    pattern = if source_tap.core_tap?
-      [repo/"Formula/#{name}.rb"]
-    else
-      # A formula can technically live in the root directory of a tap or in any of its subdirectories
-      [repo/"#{name}.rb", repo/"**/#{name}.rb"]
-    end
+        Module.class_eval do
+          T.unsafe(self).alias_method :old_method_missing, :method_missing if method_defined?(:method_missing)
+          define_method(:method_missing) do |*_|
+            # do nothing
+          end
+        end
 
-    if args.version
-      ohai "Searching repository history"
-      version = args.version
-      version_segments = Gem::Version.new(version).segments if Gem::Version.correct?(version)
-      rev = nil
-      test_formula = nil
-      result = ""
-      loop do
-        rev = rev.nil? ? "HEAD" : "#{rev}~1"
-        rev, (path,) = Utils::Git.last_revision_commit_of_files(repo, pattern, before_commit: rev)
-        if rev.nil? && source_tap.shallow?
-          odie <<~EOS
-            Could not find #{name} but #{source_tap} is a shallow clone!
-            Try again after running:
-              git -C "#{source_tap.path}" fetch --unshallow
-          EOS
-        elsif rev.nil?
-          odie "Could not find #{name}! The formula or version may not have existed."
+        Resource.class_eval do
+          T.unsafe(self).alias_method :old_method_missing, :method_missing if method_defined?(:method_missing)
+          define_method(:method_missing) do |*_|
+            # do nothing
+          end
         end
 
-        file = repo/path
-        result = Utils::Git.last_revision_of_file(repo, file, before_commit: rev)
-        if result.empty?
-          odebug "Skipping revision #{rev} - file is empty at this revision"
-          next
+        DependencyCollector.class_eval do
+          if method_defined?(:parse_symbol_spec)
+            T.unsafe(self).alias_method :old_parse_symbol_spec,
+                                        :parse_symbol_spec
+          end
+          define_method(:parse_symbol_spec) do |*_|
+            # do nothing
+          end
         end
 
-        test_formula = formula_at_revision(repo, name, file, rev)
-        break if test_formula.nil? || test_formula.version == version
+        yield
+      ensure
+        BottleSpecification.class_eval do
+          if method_defined?(:old_method_missing)
+            T.unsafe(self).alias_method :method_missing, :old_method_missing
+            undef :old_method_missing
+          end
+        end
 
-        if version_segments && Gem::Version.correct?(test_formula.version)
-          test_formula_version_segments = Gem::Version.new(test_formula.version).segments
-          if version_segments.length < test_formula_version_segments.length
-            odebug "Apply semantic versioning with #{test_formula_version_segments}"
-            break if version_segments == test_formula_version_segments.first(version_segments.length)
+        Module.class_eval do
+          if method_defined?(:old_method_missing)
+            T.unsafe(self).alias_method :method_missing, :old_method_missing
+            undef :old_method_missing
           end
         end
 
-        odebug "Trying #{test_formula.version} from revision #{rev} against desired #{version}"
-      end
-      odie "Could not find #{name}! The formula or version may not have existed." if test_formula.nil?
-    else
-      # Search in the root directory of <repo> as well as recursively in all of its subdirectories
-      files = Dir[repo/"{,**/}"].map do |dir|
-        Pathname.glob(["#{dir}/#{name}.rb"]).find(&:file?)
-      end.compact
-
-      if files.empty?
-        ohai "Searching repository history"
-        rev, (path,) = Utils::Git.last_revision_commit_of_files(repo, pattern)
-        odie "Could not find #{name}! The formula or version may not have existed." if rev.nil?
-        file = repo/path
-        version = formula_at_revision(repo, name, file, rev).version
-        result = Utils::Git.last_revision_of_file(repo, file)
-      else
-        file = files.first.realpath
-        rev = "HEAD"
-        version = Formulary.factory(file).version
-        result = File.read(file)
-      end
-    end
+        Resource.class_eval do
+          if method_defined?(:old_method_missing)
+            T.unsafe(self).alias_method :method_missing, :old_method_missing
+            undef :old_method_missing
+          end
+        end
 
-    # The class name has to be renamed to match the new filename,
-    # e.g. Foo version 1.2.3 becomes FooAT123 and resides in Foo@1.2.3.rb.
-    class_name = Formulary.class_s(name)
-
-    # Remove any existing version suffixes, as a new one will be added later
-    name.sub!(/\b@(.*)\z\b/i, "")
-    versioned_name = Formulary.class_s("#{name}@#{version}")
-    result.sub!("class #{class_name} < Formula", "class #{versioned_name} < Formula")
-
-    # Remove bottle blocks, they won't work.
-    result.sub!(BOTTLE_BLOCK_REGEX, "")
-
-    path = destination_tap.path/"Formula/#{name}@#{version.to_s.downcase}.rb"
-    if path.exist?
-      unless args.force?
-        odie <<~EOS
-          Destination formula already exists: #{path}
-          To overwrite it and continue anyways, run:
-            brew extract --force --version=#{version} #{name} #{destination_tap.name}
-        EOS
+        DependencyCollector.class_eval do
+          if method_defined?(:old_parse_symbol_spec)
+            T.unsafe(self).alias_method :parse_symbol_spec, :old_parse_symbol_spec
+            undef :old_parse_symbol_spec
+          end
+        end
       end
-      odebug "Overwriting existing formula at #{path}"
-      path.delete
     end
-    ohai "Writing formula for #{name} from revision #{rev} to:", path
-    path.dirname.mkpath
-    path.write result
-  end
-
-  # @private
-  def formula_at_revision(repo, name, file, rev)
-    return if rev.empty?
-
-    contents = Utils::Git.last_revision_of_file(repo, file, before_commit: rev)
-    contents.gsub!("@url=", "url ")
-    contents.gsub!("require 'brewkit'", "require 'formula'")
-    contents.sub!(BOTTLE_BLOCK_REGEX, "")
-    with_monkey_patch { Formulary.from_contents(name, file, contents, ignore_errors: true) }
   end
 end
diff --git a/Library/Homebrew/dev-cmd/formula.rb b/Library/Homebrew/dev-cmd/formula.rb
index ec5dca79975f1..47b0e9783e970 100644
--- a/Library/Homebrew/dev-cmd/formula.rb
+++ b/Library/Homebrew/dev-cmd/formula.rb
@@ -1,35 +1,30 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
+  module DevCmd
+    class FormulaCmd < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Display the path where <formula> is located.
+        EOS
 
-  module_function
+        named_args :formula, min: 1, without_api: true
+      end
 
-  sig { returns(CLI::Parser) }
-  def formula_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Display the path where <formula> is located.
-      EOS
-
-      named_args :formula, min: 1
-    end
-  end
-
-  def formula
-    args = formula_args.parse
-
-    formula_paths = args.named.to_paths(only: :formula).select(&:exist?)
-    if formula_paths.blank? && args.named
-                                   .to_paths(only: :cask)
-                                   .select(&:exist?)
-                                   .present?
-      odie "Found casks but did not find formulae!"
+      sig { override.void }
+      def run
+        formula_paths = args.named.to_paths(only: :formula).select(&:exist?)
+        if formula_paths.blank? && args.named
+                                       .to_paths(only: :cask)
+                                       .any?(&:exist?)
+          odie "Found casks but did not find formulae!"
+        end
+        formula_paths.each { puts _1 }
+      end
     end
-    formula_paths.each(&method(:puts))
   end
 end
diff --git a/Library/Homebrew/dev-cmd/generate-cask-api.rb b/Library/Homebrew/dev-cmd/generate-cask-api.rb
new file mode 100644
index 0000000000000..ac35895e3d75d
--- /dev/null
+++ b/Library/Homebrew/dev-cmd/generate-cask-api.rb
@@ -0,0 +1,86 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "cask/cask"
+require "fileutils"
+require "formula"
+
+module Homebrew
+  module DevCmd
+    class GenerateCaskApi < AbstractCommand
+      CASK_JSON_TEMPLATE = <<~EOS
+        ---
+        layout: cask_json
+        ---
+        {{ content }}
+      EOS
+
+      cmd_args do
+        description <<~EOS
+          Generate `homebrew/cask` API data files for <#{HOMEBREW_API_WWW}>.
+          The generated files are written to the current directory.
+        EOS
+
+        switch "-n", "--dry-run", description: "Generate API data without writing it to files."
+
+        named_args :none
+      end
+
+      sig { override.void }
+      def run
+        tap = CoreCaskTap.instance
+        raise TapUnavailableError, tap.name unless tap.installed?
+
+        unless args.dry_run?
+          directories = ["_data/cask", "api/cask", "api/cask-source", "cask", "api/internal/v3"].freeze
+          FileUtils.rm_rf directories
+          FileUtils.mkdir_p directories
+        end
+
+        Homebrew.with_no_api_env do
+          tap_migrations_json = JSON.dump(tap.tap_migrations)
+          File.write("api/cask_tap_migrations.json", tap_migrations_json) unless args.dry_run?
+
+          Cask::Cask.generating_hash!
+
+          tap.cask_files.each do |path|
+            cask = Cask::CaskLoader.load(path)
+            name = cask.token
+            json = JSON.pretty_generate(cask.to_hash_with_variations)
+            cask_source = path.read
+            html_template_name = html_template(name)
+
+            unless args.dry_run?
+              File.write("_data/cask/#{name.tr("+", "_")}.json", "#{json}\n")
+              File.write("api/cask/#{name}.json", CASK_JSON_TEMPLATE)
+              File.write("api/cask-source/#{name}.rb", cask_source)
+              File.write("cask/#{name}.html", html_template_name)
+            end
+          rescue
+            onoe "Error while generating data for cask '#{path.stem}'."
+            raise
+          end
+
+          homebrew_cask_tap_json = JSON.generate(tap.to_internal_api_hash)
+          File.write("api/internal/v3/homebrew-cask.json", homebrew_cask_tap_json) unless args.dry_run?
+          canonical_json = JSON.pretty_generate(tap.cask_renames)
+          File.write("_data/cask_canonical.json", "#{canonical_json}\n") unless args.dry_run?
+        end
+      end
+
+      private
+
+      sig { params(title: String).returns(String) }
+      def html_template(title)
+        <<~EOS
+          ---
+          title: '#{title}'
+          layout: cask
+          ---
+          {{ content }}
+        EOS
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/dev-cmd/generate-formula-api.rb b/Library/Homebrew/dev-cmd/generate-formula-api.rb
new file mode 100644
index 0000000000000..a3fe69de0d31a
--- /dev/null
+++ b/Library/Homebrew/dev-cmd/generate-formula-api.rb
@@ -0,0 +1,85 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "fileutils"
+require "formula"
+
+module Homebrew
+  module DevCmd
+    class GenerateFormulaApi < AbstractCommand
+      FORMULA_JSON_TEMPLATE = <<~EOS
+        ---
+        layout: formula_json
+        ---
+        {{ content }}
+      EOS
+
+      cmd_args do
+        description <<~EOS
+          Generate `homebrew/core` API data files for <#{HOMEBREW_API_WWW}>.
+          The generated files are written to the current directory.
+        EOS
+
+        switch "-n", "--dry-run", description: "Generate API data without writing it to files."
+
+        named_args :none
+      end
+
+      sig { override.void }
+      def run
+        tap = CoreTap.instance
+        raise TapUnavailableError, tap.name unless tap.installed?
+
+        unless args.dry_run?
+          directories = ["_data/formula", "api/formula", "formula", "api/internal/v3"]
+          FileUtils.rm_rf directories + ["_data/formula_canonical.json"]
+          FileUtils.mkdir_p directories
+        end
+
+        Homebrew.with_no_api_env do
+          tap_migrations_json = JSON.dump(tap.tap_migrations)
+          File.write("api/formula_tap_migrations.json", tap_migrations_json) unless args.dry_run?
+
+          Formulary.enable_factory_cache!
+          Formula.generating_hash!
+
+          tap.formula_names.each do |name|
+            formula = Formulary.factory(name)
+            name = formula.name
+            json = JSON.pretty_generate(formula.to_hash_with_variations)
+            html_template_name = html_template(name)
+
+            unless args.dry_run?
+              File.write("_data/formula/#{name.tr("+", "_")}.json", "#{json}\n")
+              File.write("api/formula/#{name}.json", FORMULA_JSON_TEMPLATE)
+              File.write("formula/#{name}.html", html_template_name)
+            end
+          rescue
+            onoe "Error while generating data for formula '#{name}'."
+            raise
+          end
+
+          homebrew_core_tap_json = JSON.generate(tap.to_internal_api_hash)
+          File.write("api/internal/v3/homebrew-core.json", homebrew_core_tap_json) unless args.dry_run?
+          canonical_json = JSON.pretty_generate(tap.formula_renames.merge(tap.alias_table))
+          File.write("_data/formula_canonical.json", "#{canonical_json}\n") unless args.dry_run?
+        end
+      end
+
+      private
+
+      sig { params(title: String).returns(String) }
+      def html_template(title)
+        <<~EOS
+          ---
+          title: '#{title}'
+          layout: formula
+          redirect_from: /formula-linux/#{title}
+          ---
+          {{ content }}
+        EOS
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/dev-cmd/generate-man-completions.rb b/Library/Homebrew/dev-cmd/generate-man-completions.rb
index e9c1f628b6d85..483e2322cc7b2 100644
--- a/Library/Homebrew/dev-cmd/generate-man-completions.rb
+++ b/Library/Homebrew/dev-cmd/generate-man-completions.rb
@@ -1,263 +1,41 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "formula"
-require "erb"
-require "ostruct"
-require "cli/parser"
 require "completions"
+require "manpages"
+require "system_command"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  SOURCE_PATH = (HOMEBREW_LIBRARY_PATH/"manpages").freeze
-  TARGET_MAN_PATH = (HOMEBREW_REPOSITORY/"manpages").freeze
-  TARGET_DOC_PATH = (HOMEBREW_REPOSITORY/"docs").freeze
-
-  sig { returns(CLI::Parser) }
-  def generate_man_completions_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Generate Homebrew's manpages and shell completions.
-      EOS
-      switch "--fail-if-not-changed",
-             description: "Return a failing status code if no changes are detected in the manpage outputs. " \
-                          "This can be used to notify CI when the manpages are out of date. Additionally, " \
-                          "the date used in new manpages will match those in the existing manpages (to allow " \
-                          "comparison without factoring in the date)."
-      named_args :none
-    end
-  end
-
-  def generate_man_completions
-    args = generate_man_completions_args.parse
-
-    Commands.rebuild_internal_commands_completion_list
-    regenerate_man_pages(preserve_date: args.fail_if_not_changed?, quiet: args.quiet?)
-    Completions.update_shell_completions!
-
-    diff = system_command "git", args: [
-      "-C", HOMEBREW_REPOSITORY, "diff", "--exit-code", "docs/Manpage.md", "manpages", "completions"
-    ]
-
-    return unless diff.status.success?
-
-    puts "No changes to manpage or completions output detected."
-    Homebrew.failed = true if args.fail_if_not_changed?
-  end
-
-  def regenerate_man_pages(preserve_date:, quiet:)
-    Homebrew.install_bundler_gems!
-
-    markup = build_man_page(quiet: quiet)
-    convert_man_page(markup, TARGET_DOC_PATH/"Manpage.md", preserve_date: preserve_date)
-    markup = I18n.transliterate(markup, locale: :en)
-    convert_man_page(markup, TARGET_MAN_PATH/"brew.1", preserve_date: preserve_date)
-  end
-
-  def build_man_page(quiet:)
-    template = (SOURCE_PATH/"brew.1.md.erb").read
-    variables = OpenStruct.new
-
-    variables[:commands] = generate_cmd_manpages(Commands.internal_commands_paths)
-    variables[:developer_commands] = generate_cmd_manpages(Commands.internal_developer_commands_paths)
-    variables[:official_external_commands] =
-      generate_cmd_manpages(Commands.official_external_commands_paths(quiet: quiet))
-    variables[:global_cask_options] = global_cask_options_manpage
-    variables[:global_options] = global_options_manpage
-    variables[:environment_variables] = env_vars_manpage
-
-    readme = HOMEBREW_REPOSITORY/"README.md"
-    variables[:lead] =
-      readme.read[/(Homebrew's \[Project Leader.*\.)/, 1]
-            .gsub(/\[([^\]]+)\]\([^)]+\)/, '\1')
-    variables[:plc] =
-      readme.read[/(Homebrew's \[Project Leadership Committee.*\.)/, 1]
-            .gsub(/\[([^\]]+)\]\([^)]+\)/, '\1')
-    variables[:tsc] =
-      readme.read[/(Homebrew's \[Technical Steering Committee.*\.)/, 1]
-            .gsub(/\[([^\]]+)\]\([^)]+\)/, '\1')
-    variables[:maintainers] =
-      readme.read[/(Homebrew's other current maintainers .*\.)/, 1]
-            .gsub(/\[([^\]]+)\]\([^)]+\)/, '\1')
-    variables[:alumni] =
-      readme.read[/(Former maintainers .*\.)/, 1]
-            .gsub(/\[([^\]]+)\]\([^)]+\)/, '\1')
-
-    ERB.new(template, trim_mode: ">").result(variables.instance_eval { binding })
-  end
-
-  def sort_key_for_path(path)
-    # Options after regular commands (`~` comes after `z` in ASCII table).
-    path.basename.to_s.sub(/\.(rb|sh)$/, "").sub(/^--/, "~~")
-  end
-
-  def convert_man_page(markup, target, preserve_date:)
-    manual = target.basename(".1")
-    organisation = "Homebrew"
-
-    # Set the manpage date to the existing one if we're checking for changes.
-    # This avoids the only change being e.g. a new date.
-    date = if preserve_date && target.extname == ".1" && target.exist?
-      /"(\d{1,2})" "([A-Z][a-z]+) (\d{4})" "#{organisation}" "#{manual}"/ =~ target.read
-      Date.parse("#{Regexp.last_match(1)} #{Regexp.last_match(2)} #{Regexp.last_match(3)}")
-    else
-      Date.today
-    end
-    date = date.strftime("%Y-%m-%d")
-
-    shared_args = %W[
-      --pipe
-      --organization=#{organisation}
-      --manual=#{target.basename(".1")}
-      --date=#{date}
-    ]
-
-    format_flag, format_desc = target_path_to_format(target)
-
-    puts "Writing #{format_desc} to #{target}"
-    Utils.popen(["ronn", format_flag] + shared_args, "rb+") do |ronn|
-      ronn.write markup
-      ronn.close_write
-      ronn_output = ronn.read
-      odie "Got no output from ronn!" if ronn_output.blank?
-      case format_flag
-      when "--markdown"
-        ronn_output = ronn_output.gsub(%r{<var>(.*?)</var>}, "*`\\1`*")
-                                 .gsub(/\n\n\n+/, "\n\n")
-                                 .gsub(/^(- `[^`]+`):/, "\\1") # drop trailing colons from definition lists
-                                 .gsub(/(?<=\n\n)([\[`].+):\n/, "\\1\n<br>") # replace colons with <br> on subcommands
-      when "--roff"
-        ronn_output = ronn_output.gsub(%r{<code>(.*?)</code>}, "\\fB\\1\\fR")
-                                 .gsub(%r{<var>(.*?)</var>}, "\\fI\\1\\fR")
-                                 .gsub(/(^\[?\\fB.+): /, "\\1\n    ")
-      end
-      target.atomic_write ronn_output
-    end
-  end
-
-  def target_path_to_format(target)
-    case target.basename
-    when /\.md$/    then ["--markdown", "markdown"]
-    when /\.\d$/    then ["--roff", "man page"]
-    else
-      odie "Failed to infer output format from '#{target.basename}'."
-    end
-  end
-
-  def generate_cmd_manpages(cmd_paths)
-    man_page_lines = []
-
-    # preserve existing manpage order
-    cmd_paths.sort_by(&method(:sort_key_for_path))
-             .each do |cmd_path|
-      cmd_man_page_lines = if (cmd_parser = CLI::Parser.from_cmd_path(cmd_path))
-        next if cmd_parser.hide_from_man_page
-
-        cmd_parser_manpage_lines(cmd_parser).join
-      else
-        cmd_comment_manpage_lines(cmd_path)
+  module DevCmd
+    class GenerateManCompletions < AbstractCommand
+      include SystemCommand::Mixin
+
+      cmd_args do
+        description <<~EOS
+          Generate Homebrew's manpages and shell completions.
+        EOS
+        named_args :none
       end
 
-      man_page_lines << cmd_man_page_lines
-    end
-
-    man_page_lines.compact.join("\n")
-  end
-
-  def cmd_parser_manpage_lines(cmd_parser)
-    lines = [format_usage_banner(cmd_parser.usage_banner_text)]
-    lines += cmd_parser.processed_options.map do |short, long, _, desc, hidden|
-      next if hidden
-
-      if long.present?
-        next if Homebrew::CLI::Parser.global_options.include?([short, long, desc])
-        next if Homebrew::CLI::Parser.global_cask_options.any? do |_, option, description:, **|
-                  [long, "#{long}="].include?(option) && description == desc
-                end
+      sig { override.void }
+      def run
+        Homebrew.install_bundler_gems!(groups: ["man"])
+
+        Commands.rebuild_internal_commands_completion_list
+        Manpages.regenerate_man_pages(quiet: args.quiet?)
+        Completions.update_shell_completions!
+
+        diff = system_command "git", args: [
+          "-C", HOMEBREW_REPOSITORY, "diff", "--exit-code", "docs/Manpage.md", "manpages", "completions"
+        ]
+        if diff.status.success?
+          ofail "No changes to manpage or completions."
+        else
+          puts "Manpage and completions updated."
+        end
       end
-
-      generate_option_doc(short, long, desc)
-    end.compact
-    lines
-  end
-
-  def cmd_comment_manpage_lines(cmd_path)
-    comment_lines = cmd_path.read.lines.grep(/^#:/)
-    return if comment_lines.empty?
-    return if comment_lines.first.include?("@hide_from_man_page")
-
-    lines = [format_usage_banner(comment_lines.first).chomp]
-    comment_lines.slice(1..-1)
-                 .each do |line|
-      line = line.slice(4..-2)
-      unless line
-        lines.last << "\n"
-        next
-      end
-
-      # Omit the common global_options documented separately in the man page.
-      next if line.match?(/--(debug|help|quiet|verbose) /)
-
-      # Format one option or a comma-separated pair of short and long options.
-      lines << line.gsub(/^ +(-+[a-z-]+), (-+[a-z-]+) +/, "* `\\1`, `\\2`:\n  ")
-                   .gsub(/^ +(-+[a-z-]+) +/, "* `\\1`:\n  ")
     end
-    lines.last << "\n"
-    lines
-  end
-
-  sig { returns(String) }
-  def global_cask_options_manpage
-    lines = ["These options are applicable to the `install`, `reinstall`, and `upgrade` " \
-             "subcommands with the `--cask` flag.\n"]
-    lines += Homebrew::CLI::Parser.global_cask_options.map do |_, long, description:, **|
-      generate_option_doc(nil, long.chomp("="), description)
-    end
-    lines.join("\n")
-  end
-
-  sig { returns(String) }
-  def global_options_manpage
-    lines = ["These options are applicable across multiple subcommands.\n"]
-    lines += Homebrew::CLI::Parser.global_options.map do |short, long, desc|
-      generate_option_doc(short, long, desc)
-    end
-    lines.join("\n")
-  end
-
-  sig { returns(String) }
-  def env_vars_manpage
-    lines = Homebrew::EnvConfig::ENVS.flat_map do |env, hash|
-      entry = "- `#{env}`:\n  <br>#{hash[:description]}\n"
-      default = hash[:default_text]
-      default ||= "`#{hash[:default]}`." if hash[:default]
-      entry += "\n\n  *Default:* #{default}\n" if default
-
-      entry
-    end
-    lines.join("\n")
-  end
-
-  def generate_option_doc(short, long, desc)
-    comma = (short && long) ? ", " : ""
-    <<~EOS
-      * #{format_short_opt(short)}#{comma}#{format_long_opt(long)}:
-        #{desc}
-    EOS
-  end
-
-  def format_short_opt(opt)
-    "`#{opt}`" unless opt.nil?
-  end
-
-  def format_long_opt(opt)
-    "`#{opt}`" unless opt.nil?
-  end
-
-  def format_usage_banner(usage_banner)
-    usage_banner&.sub(/^(#: *\* )?/, "### ")
   end
 end
diff --git a/Library/Homebrew/dev-cmd/install-bundler-gems.rb b/Library/Homebrew/dev-cmd/install-bundler-gems.rb
index 05e9a7d309627..a4e5956bcebe3 100644
--- a/Library/Homebrew/dev-cmd/install-bundler-gems.rb
+++ b/Library/Homebrew/dev-cmd/install-bundler-gems.rb
@@ -1,32 +1,39 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def install_bundler_gems_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Install Homebrew's Bundler gems.
-      EOS
-      comma_array "--groups=",
-                  description: "Installs the specified comma-separated list of gem groups (default: last used)."
-
-      named_args :none
+  module DevCmd
+    class InstallBundlerGems < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Install Homebrew's Bundler gems.
+        EOS
+        comma_array "--groups",
+                    description: "Installs the specified comma-separated list of gem groups (default: last used). " \
+                                 "Replaces any previously installed groups."
+        comma_array "--add-groups",
+                    description: "Installs the specified comma-separated list of gem groups, " \
+                                 "in addition to those already installed."
+
+        conflicts "--groups", "--add-groups"
+
+        named_args :none
+      end
+
+      sig { override.void }
+      def run
+        groups = args.groups || args.add_groups || []
+
+        if groups.delete("all")
+          groups |= Homebrew.valid_gem_groups
+        elsif args.groups # if we have been asked to replace
+          Homebrew.forget_user_gem_groups!
+        end
+
+        Homebrew.install_bundler_gems!(groups:)
+      end
     end
   end
-
-  def install_bundler_gems
-    args = install_bundler_gems_args.parse
-
-    # Clear previous settings. We want to fully replace - not append.
-    Homebrew::Settings.delete(:gemgroups) if args.groups
-
-    Homebrew.install_bundler_gems!(groups: args.groups || [])
-  end
 end
diff --git a/Library/Homebrew/dev-cmd/irb.rb b/Library/Homebrew/dev-cmd/irb.rb
index 3f032038befe6..40a3fd9fc9c27 100644
--- a/Library/Homebrew/dev-cmd/irb.rb
+++ b/Library/Homebrew/dev-cmd/irb.rb
@@ -1,71 +1,109 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
+require "formula"
 require "formulary"
-require "cli/parser"
+require "cask/cask_loader"
 
-class Symbol
+class String
+  # @!visibility private
+  sig { params(args: Integer).returns(Formula) }
   def f(*args)
-    Formulary.factory(to_s, *args)
+    Formulary.factory(self, *args)
+  end
+
+  # @!visibility private
+  sig { params(config: T.nilable(T::Hash[Symbol, T.untyped])).returns(Cask::Cask) }
+  def c(config: nil)
+    Cask::CaskLoader.load(self, config:)
   end
 end
 
-class String
+class Symbol
+  # @!visibility private
+  sig { params(args: Integer).returns(Formula) }
   def f(*args)
-    Formulary.factory(self, *args)
+    to_s.f(*args)
+  end
+
+  # @!visibility private
+  sig { params(config: T.nilable(T::Hash[Symbol, T.untyped])).returns(Cask::Cask) }
+  def c(config: nil)
+    to_s.c(config:)
   end
 end
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def irb_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Enter the interactive Homebrew Ruby shell.
-      EOS
-      switch "--examples",
-             description: "Show several examples."
-      switch "--pry",
-             env:         :pry,
-             description: "Use Pry instead of IRB. Implied if `HOMEBREW_PRY` is set."
-    end
-  end
+  module DevCmd
+    class Irb < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Enter the interactive Homebrew Ruby shell.
+        EOS
+        switch "--examples",
+               description: "Show several examples."
+        switch "--pry",
+               env:         :pry,
+               description: "Use Pry instead of IRB. Implied if `HOMEBREW_PRY` is set."
+      end
 
-  def irb
-    # work around IRB modifying ARGV.
-    args = irb_args.parse(ARGV.dup.freeze)
-
-    if args.examples?
-      puts <<~EOS
-        'v8'.f # => instance of the v8 formula
-        :hub.f.latest_version_installed?
-        :lua.f.methods - 1.methods
-        :mpd.f.recursive_dependencies.reject(&:installed?)
-      EOS
-      return
-    end
+      # work around IRB modifying ARGV.
+      sig { params(argv: T.nilable(T::Array[String])).void }
+      def initialize(argv = nil) = super(argv || ARGV.dup.freeze)
 
-    if args.pry?
-      Homebrew.install_gem_setup_path! "pry"
-      require "pry"
-      Pry.config.prompt_name = "brew"
-    else
-      require "irb"
-    end
+      sig { override.void }
+      def run
+        clean_argv
+
+        if args.examples?
+          puts <<~EOS
+            'v8'.f # => instance of the v8 formula
+            :hub.f.latest_version_installed?
+            :lua.f.methods - 1.methods
+            :mpd.f.recursive_dependencies.reject(&:installed?)
+
+            'vlc'.c # => instance of the vlc cask
+            :tsh.c.livecheckable?
+          EOS
+          return
+        end
+
+        if args.pry?
+          Homebrew.install_bundler_gems!(groups: ["pry"])
+          require "pry"
+        else
+          require "irb"
+        end
+
+        require "keg"
+        require "cask"
+
+        ohai "Interactive Homebrew Shell", "Example commands available with: `brew irb --examples`"
+        if args.pry?
+          Pry.config.should_load_rc = false # skip loading .pryrc
+          Pry.config.history_file = "#{Dir.home}/.brew_pry_history"
+          Pry.config.prompt_name = "brew"
+
+          Pry.start
+        else
+          ENV["IRBRC"] = (HOMEBREW_LIBRARY_PATH/"brew_irbrc").to_s
+
+          IRB.start
+        end
+      end
 
-    require "formula"
-    require "keg"
-    require "cask"
+      private
 
-    ohai "Interactive Homebrew Shell", "Example commands available with: `brew irb --examples`"
-    if args.pry?
-      Pry.start
-    else
-      IRB.start
+      # Remove the `--debug`, `--verbose` and `--quiet` options which cause problems
+      # for IRB and have already been parsed by the CLI::Parser.
+      sig { returns(T.nilable(T::Array[Symbol])) }
+      def clean_argv
+        global_options = Homebrew::CLI::Parser
+                         .global_options
+                         .flat_map { |options| options[0..1] }
+        ARGV.reject! { |arg| global_options.include?(arg) }
+      end
     end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/linkage.rb b/Library/Homebrew/dev-cmd/linkage.rb
index fcd3d0e7ce02c..23462cc98a38c 100644
--- a/Library/Homebrew/dev-cmd/linkage.rb
+++ b/Library/Homebrew/dev-cmd/linkage.rb
@@ -1,60 +1,56 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "cache_store"
 require "linkage_checker"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def linkage_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Check the library links from the given <formula> kegs. If no <formula> are
-        provided, check all kegs. Raises an error if run on uninstalled formulae.
-      EOS
-      switch "--test",
-             description: "Show only missing libraries and exit with a non-zero status if any missing " \
-                          "libraries are found."
-      switch "--strict",
-             depends_on:  "--test",
-             description: "Exit with a non-zero status if any undeclared dependencies with linkage are found."
-      switch "--reverse",
-             description: "For every library that a keg references, print its dylib path followed by the " \
-                          "binaries that link to it."
-      switch "--cached",
-             description: "Print the cached linkage values stored in `HOMEBREW_CACHE`, set by a previous " \
-                          "`brew linkage` run."
-
-      named_args :installed_formula
-    end
-  end
-
-  def linkage
-    args = linkage_args.parse
-
-    CacheStoreDatabase.use(:linkage) do |db|
-      kegs = if args.named.to_default_kegs.empty?
-        Formula.installed.map(&:any_installed_keg).compact
-      else
-        args.named.to_default_kegs
+  module DevCmd
+    class Linkage < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Check the library links from the given <formula> kegs. If no <formula> are
+          provided, check all kegs. Raises an error if run on uninstalled formulae.
+        EOS
+        switch "--test",
+               description: "Show only missing libraries and exit with a non-zero status if any missing " \
+                            "libraries are found."
+        switch "--strict",
+               depends_on:  "--test",
+               description: "Exit with a non-zero status if any undeclared dependencies with linkage are found."
+        switch "--reverse",
+               description: "For every library that a keg references, print its dylib path followed by the " \
+                            "binaries that link to it."
+        switch "--cached",
+               description: "Print the cached linkage values stored in `HOMEBREW_CACHE`, set by a previous " \
+                            "`brew linkage` run."
+
+        named_args :installed_formula
       end
-      kegs.each do |keg|
-        ohai "Checking #{keg.name} linkage" if kegs.size > 1
-
-        result = LinkageChecker.new(keg, cache_db: db)
 
-        if args.test?
-          result.display_test_output(strict: args.strict?)
-          Homebrew.failed = true if result.broken_library_linkage?(strict: args.strict?)
-        elsif args.reverse?
-          result.display_reverse_output
-        else
-          result.display_normal_output
+      sig { override.void }
+      def run
+        CacheStoreDatabase.use(:linkage) do |db|
+          kegs = if args.named.to_default_kegs.empty?
+            Formula.installed.filter_map(&:any_installed_keg)
+          else
+            args.named.to_default_kegs
+          end
+          kegs.each do |keg|
+            ohai "Checking #{keg.name} linkage" if kegs.size > 1
+
+            result = LinkageChecker.new(keg, cache_db: db)
+
+            if args.test?
+              result.display_test_output(strict: args.strict?)
+              Homebrew.failed = true if result.broken_library_linkage?(test: true, strict: args.strict?)
+            elsif args.reverse?
+              result.display_reverse_output
+            else
+              result.display_normal_output
+            end
+          end
         end
       end
     end
diff --git a/Library/Homebrew/dev-cmd/livecheck.rb b/Library/Homebrew/dev-cmd/livecheck.rb
index 0028cc83aab64..b2ffcbdb16205 100644
--- a/Library/Homebrew/dev-cmd/livecheck.rb
+++ b/Library/Homebrew/dev-cmd/livecheck.rb
@@ -1,114 +1,122 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 require "formula"
 require "livecheck/livecheck"
 require "livecheck/strategy"
 
 module Homebrew
-  extend T::Sig
+  module DevCmd
+    class LivecheckCmd < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Check for newer versions of formulae and/or casks from upstream.
+          If no formula or cask argument is passed, the list of formulae and
+          casks to check is taken from `HOMEBREW_LIVECHECK_WATCHLIST` or
+          `~/.homebrew/livecheck_watchlist.txt`.
+        EOS
+        switch "--full-name",
+               description: "Print formulae and casks with fully-qualified names."
+        flag   "--tap=",
+               description: "Check formulae and casks within the given tap, specified as <user>`/`<repo>."
+        switch "--eval-all",
+               description: "Evaluate all available formulae and casks, whether installed or not, to check them."
+        switch "--installed",
+               description: "Check formulae and casks that are currently installed."
+        switch "--newer-only",
+               description: "Show the latest version only if it's newer than the formula/cask."
+        switch "--json",
+               description: "Output information in JSON format."
+        switch "-r", "--resources",
+               description: "Also check resources for formulae."
+        switch "-q", "--quiet",
+               description: "Suppress warnings, don't print a progress bar for JSON output."
+        switch "--formula", "--formulae",
+               description: "Only check formulae."
+        switch "--cask", "--casks",
+               description: "Only check casks."
+        switch "--extract-plist",
+               description: "Enable checking multiple casks with ExtractPlist strategy."
 
-  module_function
+        conflicts "--debug", "--json"
+        conflicts "--tap=", "--eval-all", "--installed"
+        conflicts "--cask", "--formula"
+        conflicts "--formula", "--extract-plist"
 
-  WATCHLIST_PATH = File.expand_path(Homebrew::EnvConfig.livecheck_watchlist).freeze
+        named_args [:formula, :cask], without_api: true
+      end
 
-  sig { returns(CLI::Parser) }
-  def livecheck_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Check for newer versions of formulae and/or casks from upstream.
+      sig { override.void }
+      def run
+        Homebrew.install_bundler_gems!(groups: ["livecheck"])
 
-        If no formula or cask argument is passed, the list of formulae and
-        casks to check is taken from `HOMEBREW_LIVECHECK_WATCHLIST` or
-        `~/.brew_livecheck_watchlist`.
-      EOS
-      switch "--full-name",
-             description: "Print formulae/casks with fully-qualified names."
-      flag   "--tap=",
-             description: "Check formulae/casks within the given tap, specified as <user>`/`<repo>."
-      switch "--all",
-             description: "Check all available formulae/casks."
-      switch "--installed",
-             description: "Check formulae/casks that are currently installed."
-      switch "--newer-only",
-             description: "Show the latest version only if it's newer than the formula/cask."
-      switch "--json",
-             description: "Output information in JSON format."
-      switch "-q", "--quiet",
-             description: "Suppress warnings, don't print a progress bar for JSON output."
-      switch "--formula", "--formulae",
-             description: "Only check formulae."
-      switch "--cask", "--casks",
-             description: "Only check casks."
+        all = args.eval_all?
 
-      conflicts "--debug", "--json"
-      conflicts "--tap=", "--all", "--installed"
-      conflicts "--cask", "--formula"
+        if args.debug? && args.verbose?
+          puts args
+          puts Homebrew::EnvConfig.livecheck_watchlist if Homebrew::EnvConfig.livecheck_watchlist.present?
+        end
 
-      named_args [:formula, :cask]
-    end
-  end
+        formulae_and_casks_to_check = Homebrew.with_no_api_env do
+          if args.tap
+            tap = Tap.fetch(T.must(args.tap))
+            formulae = args.cask? ? [] : tap.formula_files.map { |path| Formulary.factory(path) }
+            casks = args.formula? ? [] : tap.cask_files.map { |path| Cask::CaskLoader.load(path) }
+            formulae + casks
+          elsif args.installed?
+            formulae = args.cask? ? [] : Formula.installed
+            casks = args.formula? ? [] : Cask::Caskroom.casks
+            formulae + casks
+          elsif all
+            formulae = args.cask? ? [] : Formula.all(eval_all: args.eval_all?)
+            casks = args.formula? ? [] : Cask::Cask.all(eval_all: args.eval_all?)
+            formulae + casks
+          elsif args.named.present?
+            args.named.to_formulae_and_casks_with_taps
+          elsif File.exist?(watchlist_path)
+            begin
+              names = Pathname.new(watchlist_path).read.lines
+                              .reject { |line| line.start_with?("#") || line.blank? }
+                              .map(&:strip)
 
-  def livecheck
-    args = livecheck_args.parse
+              named_args = CLI::NamedArgs.new(*names, parent: args)
+              named_args.to_formulae_and_casks(ignore_unavailable: true)
+            rescue Errno::ENOENT => e
+              onoe e
+            end
+          else
+            raise UsageError, "A watchlist file is required when no arguments are given."
+          end
+        end
 
-    if args.debug? && args.verbose?
-      puts args
-      puts Homebrew::EnvConfig.livecheck_watchlist if Homebrew::EnvConfig.livecheck_watchlist.present?
-    end
+        formulae_and_casks_to_check = formulae_and_casks_to_check.sort_by do |formula_or_cask|
+          formula_or_cask.respond_to?(:token) ? formula_or_cask.token : formula_or_cask.name
+        end
 
-    formulae_and_casks_to_check = if args.tap
-      tap = Tap.fetch(args.tap)
-      formulae = args.cask? ? [] : tap.formula_files.map { |path| Formulary.factory(path) }
-      casks = args.formula? ? [] : tap.cask_files.map { |path| Cask::CaskLoader.load(path) }
-      formulae + casks
-    elsif args.installed?
-      formulae = args.cask? ? [] : Formula.installed
-      casks = args.formula? ? [] : Cask::Caskroom.casks
-      formulae + casks
-    elsif args.all?
-      formulae = args.cask? ? [] : Formula.all
-      casks = args.formula? ? [] : Cask::Cask.all
-      formulae + casks
-    elsif args.named.present?
-      if args.formula?
-        args.named.to_formulae
-      elsif args.cask?
-        args.named.to_casks
-      else
-        args.named.to_formulae_and_casks
-      end
-    elsif File.exist?(WATCHLIST_PATH)
-      begin
-        names = Pathname.new(WATCHLIST_PATH).read.lines
-                        .reject { |line| line.start_with?("#") || line.blank? }
-                        .map(&:strip)
+        raise UsageError, "No formulae or casks to check." if formulae_and_casks_to_check.blank?
 
-        named_args = T.unsafe(CLI::NamedArgs).new(*names, parent: args)
-        named_args.to_formulae_and_casks(ignore_unavailable: true)
-      rescue Errno::ENOENT => e
-        onoe e
-      end
-    else
-      raise UsageError, "A watchlist file is required when no arguments are given."
-    end
-    formulae_and_casks_to_check = formulae_and_casks_to_check.sort_by do |formula_or_cask|
-      formula_or_cask.respond_to?(:token) ? formula_or_cask.token : formula_or_cask.name
-    end
+        options = {
+          json:                 args.json?,
+          full_name:            args.full_name?,
+          handle_name_conflict: !args.formula? && !args.cask?,
+          check_resources:      args.resources?,
+          newer_only:           args.newer_only?,
+          extract_plist:        args.extract_plist?,
+          quiet:                args.quiet?,
+          debug:                args.debug?,
+          verbose:              args.verbose?,
+        }.compact
 
-    raise UsageError, "No formulae or casks to check." if formulae_and_casks_to_check.blank?
+        Livecheck.run_checks(formulae_and_casks_to_check, **options)
+      end
 
-    options = {
-      json:                 args.json?,
-      full_name:            args.full_name?,
-      handle_name_conflict: !args.formula? && !args.cask?,
-      newer_only:           args.newer_only?,
-      quiet:                args.quiet?,
-      debug:                args.debug?,
-      verbose:              args.verbose?,
-    }.compact
+      private
 
-    Livecheck.run_checks(formulae_and_casks_to_check, **options)
+      sig { returns(String) }
+      def watchlist_path
+        @watchlist_path ||= T.let(File.expand_path(Homebrew::EnvConfig.livecheck_watchlist), T.nilable(String))
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/pr-automerge.rb b/Library/Homebrew/dev-cmd/pr-automerge.rb
index 4014b9a656dd2..819ca6aa50c7d 100644
--- a/Library/Homebrew/dev-cmd/pr-automerge.rb
+++ b/Library/Homebrew/dev-cmd/pr-automerge.rb
@@ -1,81 +1,81 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
+require "tap"
 require "utils/github"
 
 module Homebrew
-  extend T::Sig
+  module DevCmd
+    class PrAutomerge < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Find pull requests that can be automatically merged using `brew pr-publish`.
+        EOS
+        flag   "--tap=",
+               description: "Target tap repository (default: `homebrew/core`)."
+        flag   "--workflow=",
+               description: "Workflow file to use with `brew pr-publish`."
+        flag   "--with-label=",
+               description: "Pull requests must have this label."
+        comma_array "--without-labels",
+                    description: "Pull requests must not have these labels (default: " \
+                                 "`do not merge`, `new formula`, `automerge-skip`, " \
+                                 "`pre-release`, `CI-published-bottle-commits`)."
+        switch "--without-approval",
+               description: "Pull requests do not require approval to be merged."
+        switch "--publish",
+               description: "Run `brew pr-publish` on matching pull requests."
+        switch "--autosquash",
+               description: "Instruct `brew pr-publish` to automatically reformat and reword commits " \
+                            "in the pull request to the preferred format."
+        switch "--ignore-failures",
+               description: "Include pull requests that have failing status checks."
 
-  module_function
+        named_args :none
+      end
 
-  sig { returns(CLI::Parser) }
-  def pr_automerge_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Find pull requests that can be automatically merged using `brew pr-publish`.
-      EOS
-      flag   "--tap=",
-             description: "Target tap repository (default: `homebrew/core`)."
-      flag   "--workflow=",
-             description: "Workflow file to use with `brew pr-publish`."
-      flag   "--with-label=",
-             description: "Pull requests must have this label."
-      comma_array "--without-labels",
-                  description: "Pull requests must not have these labels (default: " \
-                               "`do not merge`, `new formula`, `automerge-skip`)."
-      switch "--without-approval",
-             description: "Pull requests do not require approval to be merged."
-      switch "--publish",
-             description: "Run `brew pr-publish` on matching pull requests."
-      switch "--no-autosquash",
-             description: "Instruct `brew pr-publish` to skip automatically reformatting and rewording commits " \
-                          "in the pull request to the preferred format."
-      switch "--ignore-failures",
-             description: "Include pull requests that have failing status checks."
+      sig { override.void }
+      def run
+        without_labels = args.without_labels || [
+          "do not merge",
+          "new formula",
+          "automerge-skip",
+          "pre-release",
+          "CI-published-bottle-commits",
+        ]
+        tap = Tap.fetch(args.tap || CoreTap.instance.name)
 
-      named_args :none
-    end
-  end
-
-  def pr_automerge
-    args = pr_automerge_args.parse
-
-    without_labels = args.without_labels || [
-      "do not merge",
-      "new formula",
-      "automerge-skip",
-    ]
-    tap = Tap.fetch(args.tap || CoreTap.instance.name)
+        query = "is:pr is:open repo:#{tap.full_name} draft:false"
+        query += args.ignore_failures? ? " -status:pending" : " status:success"
+        query += " review:approved" unless args.without_approval?
+        query += " label:\"#{args.with_label}\"" if args.with_label
+        without_labels.each { |label| query += " -label:\"#{label}\"" }
+        odebug "Searching: #{query}"
 
-    query = "is:pr is:open repo:#{tap.full_name} draft:false"
-    query += args.ignore_failures? ? " -status:pending" : " status:success"
-    query += " review:approved" unless args.without_approval?
-    query += " label:\"#{args.with_label}\"" if args.with_label
-    without_labels&.each { |label| query += " -label:\"#{label}\"" }
-    odebug "Searching: #{query}"
+        prs = GitHub.search_issues query
+        if prs.blank?
+          ohai "No matching pull requests!"
+          return
+        end
 
-    prs = GitHub.search_issues query
-    if prs.blank?
-      ohai "No matching pull requests!"
-      return
-    end
-
-    ohai "#{prs.count} matching pull #{"request".pluralize(prs.count)}:"
-    pr_urls = []
-    prs.each do |pr|
-      puts "#{tap.full_name unless tap.core_tap?}##{pr["number"]}: #{pr["title"]}"
-      pr_urls << pr["html_url"]
-    end
+        ohai "#{prs.count} matching pull #{Utils.pluralize("request", prs.count)}:"
+        pr_urls = []
+        prs.each do |pr|
+          puts "#{tap.full_name unless tap.core_tap?}##{pr["number"]}: #{pr["title"]}"
+          pr_urls << pr["html_url"]
+        end
 
-    publish_args = ["pr-publish"]
-    publish_args << "--tap=#{tap}" if tap
-    publish_args << "--workflow=#{args.workflow}" if args.workflow
-    publish_args << "--no-autosquash" if args.no_autosquash?
-    if args.publish?
-      safe_system HOMEBREW_BREW_FILE, *publish_args, *pr_urls
-    else
-      ohai "Now run:", "  brew #{publish_args.join " "} \\\n    #{pr_urls.join " \\\n    "}"
+        publish_args = ["pr-publish"]
+        publish_args << "--tap=#{tap}" if tap
+        publish_args << "--workflow=#{args.workflow}" if args.workflow
+        publish_args << "--autosquash" if args.autosquash?
+        if args.publish?
+          safe_system HOMEBREW_BREW_FILE, *publish_args, *pr_urls
+        else
+          ohai "Now run:", "  brew #{publish_args.join " "} \\\n    #{pr_urls.join " \\\n    "}"
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/pr-publish.rb b/Library/Homebrew/dev-cmd/pr-publish.rb
index 3e32ee7fefe1f..0f4d33735c6ab 100644
--- a/Library/Homebrew/dev-cmd/pr-publish.rb
+++ b/Library/Homebrew/dev-cmd/pr-publish.rb
@@ -1,62 +1,74 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
+require "tap"
 require "utils/github"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def pr_publish_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Publish bottles for a pull request with GitHub Actions.
-        Requires write access to the repository.
-      EOS
-      switch "--no-autosquash",
-             description: "Skip automatically reformatting and rewording commits in the pull request " \
-                          "to the preferred format, even if supported on the target tap."
-      flag   "--branch=",
-             description: "Branch to publish to (default: `master`)."
-      flag   "--message=",
-             description: "Message to include when autosquashing revision bumps, deletions, and rebuilds."
-      flag   "--tap=",
-             description: "Target tap repository (default: `homebrew/core`)."
-      flag   "--workflow=",
-             description: "Target workflow filename (default: `publish-commit-bottles.yml`)."
-
-      conflicts "--no-autosquash", "--message"
-
-      named_args :pull_request, min: 1
-    end
-  end
+  module DevCmd
+    class PrPublish < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Publish bottles for a pull request with GitHub Actions.
+          Requires write access to the repository.
+        EOS
+        switch "--autosquash",
+               description: "If supported on the target tap, automatically reformat and reword commits " \
+                            "to our preferred format."
+        switch "--large-runner",
+               description: "Run the upload job on a large runner."
+        flag   "--branch=",
+               description: "Branch to use the workflow from (default: `master`)."
+        flag   "--message=",
+               depends_on:  "--autosquash",
+               description: "Message to include when autosquashing revision bumps, deletions and rebuilds."
+        flag   "--tap=",
+               description: "Target tap repository (default: `homebrew/core`)."
+        flag   "--workflow=",
+               description: "Target workflow filename (default: `publish-commit-bottles.yml`)."
 
-  def pr_publish
-    args = pr_publish_args.parse
-
-    tap = Tap.fetch(args.tap || CoreTap.instance.name)
-    workflow = args.workflow || "publish-commit-bottles.yml"
-    ref = args.branch || "master"
-
-    extra_args = []
-    extra_args << "--no-autosquash" if args.no_autosquash?
-    extra_args << "--message='#{args.message}'" if args.message.presence
-    dispatch_args = extra_args.join " "
-
-    args.named.uniq.each do |arg|
-      arg = "#{tap.default_remote}/pull/#{arg}" if arg.to_i.positive?
-      url_match = arg.match HOMEBREW_PULL_OR_COMMIT_URL_REGEX
-      _, user, repo, issue = *url_match
-      odie "Not a GitHub pull request: #{arg}" unless issue
-      if args.tap.present? && !"#{user}/#{repo}".casecmp(tap.full_name).zero?
-        odie "Pull request URL is for #{user}/#{repo} but `--tap=#{tap.full_name}` was specified!"
+        named_args :pull_request, min: 1
       end
 
-      ohai "Dispatching #{tap} pull request ##{issue}"
-      GitHub.workflow_dispatch_event(user, repo, workflow, ref, pull_request: issue, args: dispatch_args)
+      sig { override.void }
+      def run
+        tap = Tap.fetch(args.tap || CoreTap.instance.name)
+        workflow = args.workflow || "publish-commit-bottles.yml"
+        ref = args.branch || "master"
+
+        inputs = {
+          autosquash:   args.autosquash?,
+          large_runner: args.large_runner?,
+        }
+        inputs[:message] = args.message if args.message.presence
+
+        args.named.uniq.each do |arg|
+          arg = "#{tap.default_remote}/pull/#{arg}" if arg.to_i.positive?
+          url_match = arg.match HOMEBREW_PULL_OR_COMMIT_URL_REGEX
+          _, user, repo, issue = *url_match
+          odie "Not a GitHub pull request: #{arg}" unless issue
+
+          inputs[:pull_request] = issue
+
+          pr_labels = GitHub.pull_request_labels(user, repo, issue)
+          if pr_labels.include?("autosquash")
+            oh1 "Found `autosquash` label on ##{issue}. Requesting autosquash."
+            inputs[:autosquash] = true
+          end
+          if pr_labels.include?("large-bottle-upload")
+            oh1 "Found `large-bottle-upload` label on ##{issue}. Requesting upload on large runner."
+            inputs[:large_runner] = true
+          end
+
+          if args.tap.present? && !T.must("#{user}/#{repo}".casecmp(tap.full_name)).zero?
+            odie "Pull request URL is for #{user}/#{repo} but `--tap=#{tap.full_name}` was specified!"
+          end
+
+          ohai "Dispatching #{tap} pull request ##{issue}"
+          GitHub.workflow_dispatch_event(user, repo, workflow, ref, **inputs)
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/pr-pull.rb b/Library/Homebrew/dev-cmd/pr-pull.rb
index 1c7fd73ba95fb..d3f8225109210 100644
--- a/Library/Homebrew/dev-cmd/pr-pull.rb
+++ b/Library/Homebrew/dev-cmd/pr-pull.rb
@@ -1,487 +1,559 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "download_strategy"
-require "cli/parser"
+require "abstract_command"
+require "fileutils"
 require "utils/github"
+require "utils/github/artifacts"
 require "tmpdir"
 require "formula"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def pr_pull_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Download and publish bottles, and apply the bottle commit from a
-        pull request with artifacts generated by GitHub Actions.
-        Requires write access to the repository.
-      EOS
-      switch "--no-upload",
-             description: "Download the bottles but don't upload them."
-      switch "--no-commit",
-             description: "Do not generate a new commit before uploading."
-      switch "-n", "--dry-run",
-             description: "Print what would be done rather than doing it."
-      switch "--clean",
-             depends_on:  "--no-autosquash",
-             description: "Do not amend the commits from pull requests."
-      switch "--keep-old",
-             description: "If the formula specifies a rebuild version, " \
-                          "attempt to preserve its value in the generated DSL."
-      switch "--no-autosquash",
-             description: "Skip automatically reformatting and rewording commits in the pull request to our " \
-                          "preferred format."
-      switch "--branch-okay",
-             description: "Do not warn if pulling to a branch besides the repository default (useful for testing)."
-      switch "--resolve",
-             description: "When a patch fails to apply, leave in progress and allow user to resolve, " \
-                          "instead of aborting."
-      switch "--warn-on-upload-failure",
-             description: "Warn instead of raising an error if the bottle upload fails. " \
-                          "Useful for repairing bottle uploads that previously failed."
-      flag   "--committer=",
-             description: "Specify a committer name and email in `git`'s standard author format."
-      flag   "--message=",
-             description: "Message to include when autosquashing revision bumps, deletions, and rebuilds."
-      flag   "--artifact=",
-             description: "Download artifacts with the specified name (default: `bottles`)."
-      flag   "--tap=",
-             description: "Target tap repository (default: `homebrew/core`)."
-      flag   "--root-url=",
-             description: "Use the specified <URL> as the root of the bottle's URL instead of Homebrew's default."
-      flag   "--root-url-using=",
-             description: "Use the specified download strategy class for downloading the bottle's URL instead of " \
-                          "Homebrew's default."
-      comma_array "--workflows=",
-                  description: "Retrieve artifacts from the specified workflow (default: `tests.yml`). " \
-                               "Can be a comma-separated list to include multiple workflows."
-      comma_array "--ignore-missing-artifacts=",
-                  description: "Comma-separated list of workflows which can be ignored if they have not been run."
-
-      conflicts "--no-autosquash", "--message"
-
-      named_args :pull_request, min: 1
-    end
-  end
-
-  # Separates a commit message into subject, body, and trailers.
-  def separate_commit_message(message)
-    subject = message.lines.first.strip
-
-    # Skip the subject and separate lines that look like trailers (e.g. "Co-authored-by")
-    # from lines that look like regular body text.
-    trailers, body = message.lines.drop(1).partition { |s| s.match?(/^[a-z-]+-by:/i) }
+  module DevCmd
+    class PrPull < AbstractCommand
+      include FileUtils
+
+      cmd_args do
+        description <<~EOS
+          Download and publish bottles and apply the bottle commit from a
+          pull request with artifacts generated by GitHub Actions.
+          Requires write access to the repository.
+        EOS
+        switch "--no-upload",
+               description: "Download the bottles but don't upload them."
+        switch "--no-commit",
+               description: "Do not generate a new commit before uploading."
+        switch "--no-cherry-pick",
+               description: "Do not cherry-pick commits from the pull request branch."
+        switch "-n", "--dry-run",
+               description: "Print what would be done rather than doing it."
+        switch "--clean",
+               description: "Do not amend the commits from pull requests."
+        switch "--keep-old",
+               description: "If the formula specifies a rebuild version, " \
+                            "attempt to preserve its value in the generated DSL."
+        switch "--autosquash",
+               description: "Automatically reformat and reword commits in the pull request to our " \
+                            "preferred format."
+        switch "--branch-okay",
+               description: "Do not warn if pulling to a branch besides the repository default (useful for testing)."
+        switch "--resolve",
+               description: "When a patch fails to apply, leave in progress and allow user to resolve, " \
+                            "instead of aborting."
+        switch "--warn-on-upload-failure",
+               description: "Warn instead of raising an error if the bottle upload fails. " \
+                            "Useful for repairing bottle uploads that previously failed."
+        switch "--retain-bottle-dir",
+               description: "Does not clean up the tmp directory for the bottle so it can be used later."
+        flag   "--committer=",
+               description: "Specify a committer name and email in `git`'s standard author format."
+        flag   "--message=",
+               depends_on:  "--autosquash",
+               description: "Message to include when autosquashing revision bumps, deletions and rebuilds."
+        flag   "--artifact-pattern=", "--artifact=",
+               description: "Download artifacts with the specified pattern (default: `bottles{,_*}`)."
+        flag   "--tap=",
+               description: "Target tap repository (default: `homebrew/core`)."
+        flag   "--root-url=",
+               description: "Use the specified <URL> as the root of the bottle's URL instead of Homebrew's default."
+        flag   "--root-url-using=",
+               description: "Use the specified download strategy class for downloading the bottle's URL instead of " \
+                            "Homebrew's default."
+        comma_array "--workflows",
+                    description: "Retrieve artifacts from the specified workflow (default: `tests.yml`). " \
+                                 "Can be a comma-separated list to include multiple workflows."
+        comma_array "--ignore-missing-artifacts",
+                    description: "Comma-separated list of workflows which can be ignored if they have not been run."
+
+        conflicts "--clean", "--autosquash"
+
+        named_args :pull_request, min: 1
+      end
 
-    trailers = trailers.uniq.join.strip
-    body = body.join.strip.gsub(/\n{3,}/, "\n\n")
+      sig { override.void }
+      def run
+        # Needed when extracting the CI artifact.
+        ensure_executable!("unzip", reason: "extracting CI artifacts")
 
-    [subject, body, trailers]
-  end
+        workflows = args.workflows.presence || ["tests.yml"]
+        artifact_pattern = args.artifact_pattern || "bottles{,_*}"
+        tap = Tap.fetch(args.tap || CoreTap.instance.name)
+        raise TapUnavailableError, tap.name unless tap.installed?
 
-  def signoff!(path, pr: nil, dry_run: false)
-    subject, body, trailers = separate_commit_message(path.git_commit_message)
+        Utils::Git.set_name_email!(committer: args.committer.blank?)
+        Utils::Git.setup_gpg!
 
-    if pr
-      # This is a tap pull request and approving reviewers should also sign-off.
-      tap = Tap.from_path(path)
-      review_trailers = GitHub.approved_reviews(tap.user, tap.full_name.split("/").last, pr).map do |r|
-        "Signed-off-by: #{r["name"]} <#{r["email"]}>"
-      end
-      trailers = trailers.lines.concat(review_trailers).map(&:strip).uniq.join("\n")
+        if (committer = args.committer)
+          committer = Utils.parse_author!(committer)
+          ENV["GIT_COMMITTER_NAME"] = committer[:name]
+          ENV["GIT_COMMITTER_EMAIL"] = committer[:email]
+        end
 
-      # Append the close message as well, unless the commit body already includes it.
-      close_message = "Closes ##{pr}."
-      body += "\n\n#{close_message}" unless body.include? close_message
-    end
+        args.named.uniq.each do |arg|
+          arg = "#{tap.default_remote}/pull/#{arg}" if arg.to_i.positive?
+          url_match = arg.match HOMEBREW_PULL_OR_COMMIT_URL_REGEX
+          _, user, repo, pr = *url_match
+          odie "Not a GitHub pull request: #{arg}" unless pr
 
-    git_args = Utils::Git.git, "-C", path, "commit", "--amend", "--signoff", "--allow-empty", "--quiet",
-               "--message", subject, "--message", body, "--message", trailers
+          git_repo = tap.git_repository
+          if !git_repo.default_origin_branch? && !args.branch_okay? && !args.no_commit? && !args.no_cherry_pick?
+            origin_branch_name = git_repo.origin_branch_name
+            opoo "Current branch is #{git_repo.branch_name}: do you need to pull inside #{origin_branch_name}?"
+          end
 
-    if dry_run
-      puts(*git_args)
-    else
-      safe_system(*git_args)
-    end
-  end
+          pr_labels = GitHub.pull_request_labels(user, repo, pr)
+          if pr_labels.include?("autosquash") && !args.autosquash?
+            opoo "Pull request is labelled `autosquash`: do you need to pass `--autosquash`?"
+          end
 
-  def get_package(tap, subject_name, subject_path, content)
-    if subject_path.dirname == tap.cask_dir
-      cask = begin
-        Cask::CaskLoader.load(content.dup)
-      rescue Cask::CaskUnavailableError
-        nil
+          pr_check_conflicts("#{user}/#{repo}", pr)
+
+          ohai "Fetching #{tap} pull request ##{pr}"
+          dir = Dir.mktmpdir("pr-pull-#{pr}-", HOMEBREW_TEMP)
+          begin
+            cd dir do
+              current_branch_head = ENV["GITHUB_SHA"] || tap.git_head
+              original_commit = if args.no_cherry_pick?
+                # TODO: Handle the case where `merge-base` returns multiple commits.
+                Utils.safe_popen_read("git", "-C", tap.path, "merge-base", "origin/HEAD",
+                                      current_branch_head).strip
+              else
+                current_branch_head
+              end
+              odebug "Pull request merge-base: #{original_commit}"
+
+              unless args.no_commit?
+                cherry_pick_pr!(user, repo, pr, path: tap.path) unless args.no_cherry_pick?
+                if args.autosquash? && !args.dry_run?
+                  autosquash!(original_commit, tap:, cherry_picked: !args.no_cherry_pick?,
+                              verbose: args.verbose?, resolve: args.resolve?, reason: args.message)
+                end
+                signoff!(git_repo, pull_request: pr, dry_run: args.dry_run?) unless args.clean?
+              end
+
+              unless formulae_need_bottles?(tap, original_commit, pr_labels)
+                ohai "Skipping artifacts for ##{pr} as the formulae don't need bottles"
+                next
+              end
+
+              workflows.each do |workflow|
+                workflow_run = GitHub.get_workflow_run(
+                  user, repo, pr, workflow_id: workflow, artifact_pattern:
+                )
+                if args.ignore_missing_artifacts.present? &&
+                   args.ignore_missing_artifacts&.include?(workflow) &&
+                   workflow_run.first.blank?
+                  # Ignore that workflow as it was not executed and we specified
+                  # that we could skip it.
+                  ohai "Ignoring workflow #{workflow} as requested by `--ignore-missing-artifacts`"
+                  next
+                end
+
+                ohai "Downloading bottles for workflow: #{workflow}"
+
+                urls = GitHub.get_artifact_urls(workflow_run)
+                urls.each { |url| GitHub.download_artifact(url, pr) }
+              end
+
+              next if args.no_upload?
+
+              upload_args = ["pr-upload"]
+              upload_args << "--debug" if args.debug?
+              upload_args << "--verbose" if args.verbose?
+              upload_args << "--no-commit" if args.no_commit?
+              upload_args << "--dry-run" if args.dry_run?
+              upload_args << "--keep-old" if args.keep_old?
+              upload_args << "--warn-on-upload-failure" if args.warn_on_upload_failure?
+              upload_args << "--committer=#{args.committer}" if args.committer
+              upload_args << "--root-url=#{args.root_url}" if args.root_url
+              upload_args << "--root-url-using=#{args.root_url_using}" if args.root_url_using
+              safe_system HOMEBREW_BREW_FILE, *upload_args
+            end
+          ensure
+            if args.retain_bottle_dir? && GitHub::Actions.env_set?
+              ohai "Bottle files retained at:", dir
+              File.open(ENV.fetch("GITHUB_OUTPUT"), "a") do |f|
+                f.puts "bottle_path=#{dir}"
+              end
+            else
+              FileUtils.remove_entry dir
+            end
+          end
+        end
       end
-      return cask
-    end
-
-    begin
-      Formulary.from_contents(subject_name, subject_path, content, :stable)
-    rescue FormulaUnavailableError
-      nil
-    end
-  end
-
-  def determine_bump_subject(old_contents, new_contents, subject_path, reason: nil)
-    subject_path = Pathname(subject_path)
-    tap          = Tap.from_path(subject_path)
-    subject_name = subject_path.basename.to_s.chomp(".rb")
-    is_cask      = subject_path.dirname == tap.cask_dir
-    name         = is_cask ? "cask" : "formula"
-
-    new_package = get_package(tap, subject_name, subject_path, new_contents)
-
-    return "#{subject_name}: delete #{reason}".strip if new_package.blank?
-
-    old_package = get_package(tap, subject_name, subject_path, old_contents)
-
-    if old_package.blank?
-      "#{subject_name} #{new_package.version} (new #{name})"
-    elsif old_package.version != new_package.version
-      "#{subject_name} #{new_package.version}"
-    elsif !is_cask && old_package.revision != new_package.revision
-      "#{subject_name}: revision #{reason}".strip
-    elsif is_cask && old_package.sha256 != new_package.sha256
-      "#{subject_name}: checksum update #{reason}".strip
-    else
-      "#{subject_name}: #{reason || "rebuild"}".strip
-    end
-  end
 
-  # Cherry picks a single commit that modifies a single file.
-  # Potentially rewords this commit using {determine_bump_subject}.
-  def reword_package_commit(commit, file, reason: "", verbose: false, resolve: false, path: ".")
-    package_file = Pathname.new(path) / file
-    package_name = package_file.basename.to_s.chomp(".rb")
+      # Separates a commit message into subject, body and trailers.
+      sig { params(message: String).returns([String, String, String]) }
+      def separate_commit_message(message)
+        first_line = message.lines.first
+        return ["", "", ""] unless first_line
 
-    odebug "Cherry-picking #{package_file}: #{commit}"
-    Utils::Git.cherry_pick!(path, commit, verbose: verbose, resolve: resolve)
+        # Skip the subject and separate lines that look like trailers (e.g. "Co-authored-by")
+        # from lines that look like regular body text.
+        trailers, body = message.lines.drop(1).partition { |s| s.match?(/^[a-z-]+-by:/i) }
 
-    old_package = Utils::Git.file_at_commit(path, file, "HEAD^")
-    new_package = Utils::Git.file_at_commit(path, file, "HEAD")
+        trailers = trailers.uniq.join.strip
+        body = body.join.strip.gsub(/\n{3,}/, "\n\n")
 
-    bump_subject = determine_bump_subject(old_package, new_package, package_file, reason: reason).strip
-    subject, body, trailers = separate_commit_message(path.git_commit_message)
+        [first_line.strip, body, trailers]
+      end
 
-    if subject != bump_subject && !subject.start_with?("#{package_name}:")
-      safe_system("git", "-C", path, "commit", "--amend", "-q",
-                  "-m", bump_subject, "-m", subject, "-m", body, "-m", trailers)
-      ohai bump_subject
-    else
-      ohai subject
-    end
-  end
+      sig { params(git_repo: GitRepository, pull_request: T.nilable(String), dry_run: T::Boolean).void }
+      def signoff!(git_repo, pull_request: nil, dry_run: false)
+        msg = git_repo.commit_message
+        return if msg.blank?
 
-  # Cherry picks multiple commits that each modify a single file.
-  # Words the commit according to {determine_bump_subject} with the body
-  # corresponding to all the original commit messages combined.
-  def squash_package_commits(commits, file, reason: "", verbose: false, resolve: false, path: ".")
-    odebug "Squashing #{file}: #{commits.join " "}"
-
-    # Format commit messages into something similar to `git fmt-merge-message`.
-    # * subject 1
-    # * subject 2
-    #   optional body
-    # * subject 3
-    messages = []
-    trailers = []
-    commits.each do |commit|
-      subject, body, trailer = separate_commit_message(path.git_commit_message(commit))
-      body = body.lines.map { |line| "  #{line.strip}" }.join("\n")
-      messages << "* #{subject}\n#{body}".strip
-      trailers << trailer
-    end
+        subject, body, trailers = separate_commit_message(msg)
 
-    # Get the set of authors in this series.
-    authors = Utils.safe_popen_read("git", "-C", path, "show",
-                                    "--no-patch", "--pretty=%an <%ae>", *commits).lines.map(&:strip).uniq.compact
-
-    # Get the author and date of the first commit of this series, which we use for the squashed commit.
-    original_author = authors.shift
-    original_date = Utils.safe_popen_read "git", "-C", path, "show", "--no-patch", "--pretty=%ad", commits.first
+        if pull_request
+          # This is a tap pull request and approving reviewers should also sign-off.
+          tap = Tap.from_path(git_repo.pathname)
+          review_trailers = GitHub.approved_reviews(tap.user, tap.full_name.split("/").last,
+                                                    pull_request).map do |r|
+            "Signed-off-by: #{r["name"]} <#{r["email"]}>"
+          end
+          trailers = trailers.lines.concat(review_trailers).map(&:strip).uniq.join("\n")
 
-    # Generate trailers for coauthors and combine them with the existing trailers.
-    co_author_trailers = authors.map { |au| "Co-authored-by: #{au}" }
-    trailers = [trailers + co_author_trailers].flatten.uniq.compact
+          # Append the close message as well, unless the commit body already includes it.
+          close_message = "Closes ##{pull_request}."
+          body.concat("\n\n#{close_message}") unless body.include?(close_message)
+        end
 
-    # Apply the patch series but don't commit anything yet.
-    Utils::Git.cherry_pick!(path, "--no-commit", *commits, verbose: verbose, resolve: resolve)
+        git_args = Utils::Git.git, "-C", git_repo.pathname, "commit", "--amend", "--signoff", "--allow-empty",
+                   "--quiet", "--message", subject, "--message", body, "--message", trailers
 
-    # Determine the bump subject by comparing the original state of the tree to its current state.
-    package_file = Pathname.new(path) / file
-    old_package = Utils::Git.file_at_commit(path, file, "#{commits.first}^")
-    new_package = package_file.read
-    bump_subject = determine_bump_subject(old_package, new_package, package_file, reason: reason)
+        if dry_run
+          puts(*git_args)
+        else
+          safe_system(*git_args)
+        end
+      end
 
-    # Commit with the new subject, body, and trailers.
-    safe_system("git", "-C", path, "commit", "--quiet",
-                "-m", bump_subject, "-m", messages.join("\n"), "-m", trailers.join("\n"),
-                "--author", original_author, "--date", original_date, "--", file)
-    ohai bump_subject
-  end
+      sig { params(tap: Tap, subject_name: String, subject_path: Pathname, content: String).returns(T.untyped) }
+      def get_package(tap, subject_name, subject_path, content)
+        if subject_path.to_s.start_with?("#{tap.cask_dir}/")
+          cask = begin
+            Cask::CaskLoader.load(content.dup)
+          rescue Cask::CaskUnavailableError
+            nil
+          end
+          return cask
+        end
 
-  def autosquash!(original_commit, tap:, reason: "", verbose: false, resolve: false)
-    original_head = tap.path.git_head
-
-    commits = Utils.safe_popen_read("git", "-C", tap.path, "rev-list",
-                                    "--reverse", "#{original_commit}..HEAD").lines.map(&:strip)
-
-    # Generate a bidirectional mapping of commits <=> formula/cask files.
-    files_to_commits = {}
-    commits_to_files = commits.to_h do |commit|
-      files = Utils.safe_popen_read("git", "-C", tap.path, "diff-tree", "--diff-filter=AMD",
-                                    "-r", "--name-only", "#{commit}^", commit).lines.map(&:strip)
-      files.each do |file|
-        files_to_commits[file] ||= []
-        files_to_commits[file] << commit
-        tap_file = tap.path/file
-        if (tap_file.dirname == tap.formula_dir || tap_file.dirname == tap.cask_dir) &&
-           File.extname(file) == ".rb"
-          next
+        begin
+          Formulary.from_contents(subject_name, subject_path, content, :stable)
+        rescue FormulaUnavailableError
+          nil
         end
+      end
 
-        odie <<~EOS
-          Autosquash can only squash commits that modify formula or cask files.
-            File:   #{file}
-            Commit: #{commit}
-        EOS
+      sig {
+        params(old_contents: String, new_contents: String, subject_path: T.any(String, Pathname),
+               reason: T.nilable(String)).returns(String)
+      }
+      def determine_bump_subject(old_contents, new_contents, subject_path, reason: nil)
+        subject_path = Pathname(subject_path)
+        tap          = Tap.from_path(subject_path)
+        subject_name = subject_path.basename.to_s.chomp(".rb")
+        is_cask      = subject_path.to_s.start_with?("#{tap.cask_dir}/")
+        name         = is_cask ? "cask" : "formula"
+
+        new_package = get_package(tap, subject_name, subject_path, new_contents)
+
+        return "#{subject_name}: delete #{reason}".strip if new_package.blank?
+
+        old_package = get_package(tap, subject_name, subject_path, old_contents)
+
+        if old_package.blank?
+          "#{subject_name} #{new_package.version} (new #{name})"
+        elsif old_package.version != new_package.version
+          "#{subject_name} #{new_package.version}"
+        elsif !is_cask && old_package.revision != new_package.revision
+          "#{subject_name}: revision #{reason}".strip
+        elsif is_cask && old_package.sha256 != new_package.sha256
+          "#{subject_name}: checksum update #{reason}".strip
+        else
+          "#{subject_name}: #{reason || "rebuild"}".strip
+        end
       end
-      [commit, files]
-    end
 
-    # Reset to state before cherry-picking.
-    safe_system "git", "-C", tap.path, "reset", "--hard", original_commit
-
-    # Iterate over every commit in the pull request series, but if we have to squash
-    # multiple commits into one, ensure that we skip over commits we've already squashed.
-    processed_commits = []
-    commits.each do |commit|
-      next if processed_commits.include? commit
-
-      files = commits_to_files[commit]
-      if files.length == 1 && files_to_commits[files.first].length == 1
-        # If there's a 1:1 mapping of commits to files, just cherry pick and (maybe) reword.
-        reword_package_commit(commit, files.first, path: tap.path, reason: reason, verbose: verbose, resolve: resolve)
-        processed_commits << commit
-      elsif files.length == 1 && files_to_commits[files.first].length > 1
-        # If multiple commits modify a single file, squash them down into a single commit.
-        file = files.first
-        commits = files_to_commits[file]
-        squash_package_commits(commits, file, path: tap.path, reason: reason, verbose: verbose, resolve: resolve)
-        processed_commits += commits
-      else
-        # We can't split commits (yet) so just raise an error.
-        odie <<~EOS
-          Autosquash can't split commits that modify multiple files.
-            Commit: #{commit}
-            Files:  #{files.join " "}
-        EOS
+      # Cherry picks a single commit that modifies a single file.
+      # Potentially rewords this commit using {determine_bump_subject}.
+      sig {
+        params(commit: String, file: String, git_repo: GitRepository, reason: T.nilable(String), verbose: T::Boolean,
+               resolve: T::Boolean).void
+      }
+      def reword_package_commit(commit, file, git_repo:, reason: "", verbose: false, resolve: false)
+        package_file = git_repo.pathname / file
+        package_name = package_file.basename.to_s.chomp(".rb")
+
+        odebug "Cherry-picking #{package_file}: #{commit}"
+        Utils::Git.cherry_pick!(git_repo.to_s, commit, verbose:, resolve:)
+
+        old_package = Utils::Git.file_at_commit(git_repo.to_s, file, "HEAD^")
+        new_package = Utils::Git.file_at_commit(git_repo.to_s, file, "HEAD")
+
+        bump_subject = determine_bump_subject(old_package, new_package, package_file, reason:).strip
+        msg = git_repo.commit_message
+        return if msg.blank?
+
+        subject, body, trailers = separate_commit_message(msg)
+
+        if subject != bump_subject && !subject.start_with?("#{package_name}:")
+          safe_system("git", "-C", git_repo.pathname, "commit", "--amend", "-q",
+                      "-m", bump_subject, "-m", subject, "-m", body, "-m", trailers)
+          ohai bump_subject
+        else
+          ohai subject
+        end
       end
-    end
-  rescue
-    opoo "Autosquash encountered an error; resetting to original cherry-picked state at #{original_head}"
-    system "git", "-C", tap.path, "reset", "--hard", original_head
-    system "git", "-C", tap.path, "cherry-pick", "--abort"
-    raise
-  end
 
-  def cherry_pick_pr!(user, repo, pr, args:, path: ".")
-    if args.dry_run?
-      puts <<~EOS
-        git fetch --force origin +refs/pull/#{pr}/head
-        git merge-base HEAD FETCH_HEAD
-        git cherry-pick --ff --allow-empty $merge_base..FETCH_HEAD
-      EOS
-      return
-    end
+      # Cherry picks multiple commits that each modify a single file.
+      # Words the commit according to {determine_bump_subject} with the body
+      # corresponding to all the original commit messages combined.
+      sig {
+        params(commits: T::Array[String], file: String, git_repo: GitRepository, reason: T.nilable(String),
+               verbose: T::Boolean, resolve: T::Boolean).void
+      }
+      def squash_package_commits(commits, file, git_repo:, reason: "", verbose: false, resolve: false)
+        odebug "Squashing #{file}: #{commits.join " "}"
+
+        # Format commit messages into something similar to `git fmt-merge-message`.
+        # * subject 1
+        # * subject 2
+        #   optional body
+        # * subject 3
+        messages = []
+        trailers = []
+        commits.each do |commit|
+          msg = git_repo.commit_message(commit)
+          next if msg.blank?
+
+          subject, body, trailer = separate_commit_message(msg)
+          body = body.lines.map { |line| "  #{line.strip}" }.join("\n")
+          messages << "* #{subject}\n#{body}".strip
+          trailers << trailer
+        end
 
-    commits = GitHub.pull_request_commits(user, repo, pr)
-    safe_system "git", "-C", path, "fetch", "--quiet", "--force", "origin", commits.last
-    ohai "Using #{commits.count} commit#{"s" unless commits.count == 1} from ##{pr}"
-    Utils::Git.cherry_pick!(path, "--ff", "--allow-empty", *commits, verbose: args.verbose?, resolve: args.resolve?)
-  end
+        # Get the set of authors in this series.
+        authors = Utils.safe_popen_read("git", "-C", git_repo.pathname, "show",
+                                        "--no-patch", "--pretty=%an <%ae>", *commits).lines.map(&:strip).uniq.compact
+
+        # Get the author and date of the first commit of this series, which we use for the squashed commit.
+        original_author = authors.shift
+        original_date = Utils.safe_popen_read "git", "-C", git_repo.pathname, "show", "--no-patch", "--pretty=%ad",
+                                              commits.first
+
+        # Generate trailers for coauthors and combine them with the existing trailers.
+        co_author_trailers = authors.map { |au| "Co-authored-by: #{au}" }
+        trailers = [trailers + co_author_trailers].flatten.uniq.compact
+
+        # Apply the patch series but don't commit anything yet.
+        Utils::Git.cherry_pick!(git_repo.pathname, "--no-commit", *commits, verbose:, resolve:)
+
+        # Determine the bump subject by comparing the original state of the tree to its current state.
+        package_file = git_repo.pathname / file
+        old_package = Utils::Git.file_at_commit(git_repo.pathname, file, "#{commits.first}^")
+        new_package = package_file.read
+        bump_subject = determine_bump_subject(old_package, new_package, package_file, reason:)
+
+        # Commit with the new subject, body and trailers.
+        safe_system("git", "-C", git_repo.pathname, "commit", "--quiet",
+                    "-m", bump_subject, "-m", messages.join("\n"), "-m", trailers.join("\n"),
+                    "--author", original_author, "--date", original_date, "--", file)
+        ohai bump_subject
+      end
 
-  def formulae_need_bottles?(tap, original_commit, user, repo, pr, args:)
-    return if args.dry_run?
+      # TODO: fix test in `test/dev-cmd/pr-pull_spec.rb` and assume `cherry_picked: false`.
+      sig {
+        params(original_commit: String, tap: Tap, reason: T.nilable(String), verbose: T::Boolean, resolve: T::Boolean,
+               cherry_picked: T::Boolean).void
+      }
+      def autosquash!(original_commit, tap:, reason: "", verbose: false, resolve: false, cherry_picked: true)
+        git_repo = tap.git_repository
+
+        commits = Utils.safe_popen_read("git", "-C", tap.path, "rev-list",
+                                        "--reverse", "#{original_commit}..HEAD").lines.map(&:strip)
+
+        # Generate a bidirectional mapping of commits <=> formula/cask files.
+        files_to_commits = {}
+        commits_to_files = commits.to_h do |commit|
+          files = Utils.safe_popen_read("git", "-C", tap.path, "diff-tree", "--diff-filter=AMD",
+                                        "-r", "--name-only", "#{commit}^", commit).lines.map(&:strip)
+          files.each do |file|
+            files_to_commits[file] ||= []
+            files_to_commits[file] << commit
+            tap_file = (tap.path/file).to_s
+            if (tap_file.start_with?("#{tap.formula_dir}/") || tap_file.start_with?("#{tap.cask_dir}/")) &&
+               File.extname(file) == ".rb"
+              next
+            end
 
-    labels = GitHub.pull_request_labels(user, repo, pr)
+            odie <<~EOS
+              Autosquash can only squash commits that modify formula or cask files.
+                File:   #{file}
+                Commit: #{commit}
+            EOS
+          end
+          [commit, files]
+        end
 
-    return false if labels.include?("CI-syntax-only") || labels.include?("CI-no-bottles")
+        # Reset to state before cherry-picking.
+        safe_system "git", "-C", tap.path, "reset", "--hard", original_commit
 
-    changed_packages(tap, original_commit).any? do |f|
-      !f.instance_of?(Cask::Cask)
-    end
-  end
+        # Iterate over every commit in the pull request series, but if we have to squash
+        # multiple commits into one, ensure that we skip over commits we've already squashed.
+        processed_commits = T.let([], T::Array[String])
+        commits.each do |commit|
+          next if processed_commits.include? commit
 
-  def changed_packages(tap, original_commit)
-    formulae = Utils.popen_read("git", "-C", tap.path, "diff-tree",
-                                "-r", "--name-only", "--diff-filter=AM",
-                                original_commit, "HEAD", "--", tap.formula_dir)
-                    .lines
-                    .map do |line|
-      next unless line.end_with? ".rb\n"
-
-      name = "#{tap.name}/#{File.basename(line.chomp, ".rb")}"
-      if Homebrew::EnvConfig.disable_load_formula?
-        opoo "Can't check if updated bottles are necessary as HOMEBREW_DISABLE_LOAD_FORMULA is set!"
-        break
-      end
-      begin
-        Formulary.resolve(name)
-      rescue FormulaUnavailableError
-        nil
-      end
-    end.compact
-    casks = Utils.popen_read("git", "-C", tap.path, "diff-tree",
-                             "-r", "--name-only", "--diff-filter=AM",
-                             original_commit, "HEAD", "--", tap.cask_dir)
-                 .lines
-                 .map do |line|
-      next unless line.end_with? ".rb\n"
-
-      name = "#{tap.name}/#{File.basename(line.chomp, ".rb")}"
-      begin
-        Cask::CaskLoader.load(name)
-      rescue Cask::CaskUnavailableError
-        nil
+          files = commits_to_files[commit]
+          if files.length == 1 && files_to_commits[files.first].length == 1
+            # If there's a 1:1 mapping of commits to files, just cherry pick and (maybe) reword.
+            reword_package_commit(
+              commit, files.first, git_repo:, reason:, verbose:, resolve:
+            )
+            processed_commits << commit
+          elsif files.length == 1 && files_to_commits[files.first].length > 1
+            # If multiple commits modify a single file, squash them down into a single commit.
+            file = files.first
+            commits = files_to_commits[file]
+            squash_package_commits(commits, file, git_repo:, reason:, verbose:, resolve:)
+            processed_commits += commits
+          else
+            # We can't split commits (yet) so just raise an error.
+            odie <<~EOS
+              Autosquash can't split commits that modify multiple files.
+                Commit: #{commit}
+                Files:  #{files.join " "}
+            EOS
+          end
+        end
+      rescue
+        original_head = git_repo&.head_ref
+        return if original_head.nil?
+
+        opoo "Autosquash encountered an error; resetting to original state at #{original_head}"
+        system "git", "-C", tap.path.to_s, "reset", "--hard", original_head
+        system "git", "-C", tap.path.to_s, "cherry-pick", "--abort" if cherry_picked
+        raise
       end
-    end.compact
-    formulae + casks
-  end
 
-  def download_artifact(url, dir, pr)
-    odie "Credentials must be set to access the Artifacts API" if GitHub::API.credentials_type == :none
-
-    token = GitHub::API.credentials
-    curl_args = ["--header", "Authorization: token #{token}"]
-
-    # Download the artifact as a zip file and unpack it into `dir`. This is
-    # preferred over system `curl` and `tar` as this leverages the Homebrew
-    # cache to avoid repeated downloads of (possibly large) bottles.
-    FileUtils.chdir dir do
-      downloader = GitHubArtifactDownloadStrategy.new(url, "artifact", pr, curl_args: curl_args, secrets: [token])
-      downloader.fetch
-      downloader.stage
-    end
-  end
-
-  def pr_pull
-    args = pr_pull_args.parse
-
-    # Needed when extracting the CI artifact.
-    ensure_executable!("unzip", reason: "extracting CI artifacts")
+      private
+
+      sig { params(user: String, repo: String, pull_request: String, path: T.any(String, Pathname)).void }
+      def cherry_pick_pr!(user, repo, pull_request, path: ".")
+        if args.dry_run?
+          puts <<~EOS
+            git fetch --force origin +refs/pull/#{pull_request}/head
+            git merge-base HEAD FETCH_HEAD
+            git cherry-pick --ff --allow-empty $merge_base..FETCH_HEAD
+          EOS
+          return
+        end
 
-    workflows = args.workflows.presence || ["tests.yml"]
-    artifact = args.artifact || "bottles"
-    tap = Tap.fetch(args.tap || CoreTap.instance.name)
+        commits = GitHub.pull_request_commits(user, repo, pull_request)
+        safe_system "git", "-C", path, "fetch", "--quiet", "--force", "origin", commits.last
+        ohai "Using #{commits.count} commit#{"s" if commits.count != 1} from ##{pull_request}"
+        Utils::Git.cherry_pick!(path, "--ff", "--allow-empty", *commits, verbose: args.verbose?,
+                                                                         resolve: args.resolve?)
+      end
 
-    Utils::Git.set_name_email!(committer: args.committer.blank?)
-    Utils::Git.setup_gpg!
+      sig { params(tap: Tap, original_commit: String, labels: T::Array[String]).returns(T::Boolean) }
+      def formulae_need_bottles?(tap, original_commit, labels)
+        return false if args.dry_run?
 
-    if (committer = args.committer)
-      committer = Utils.parse_author!(committer)
-      ENV["GIT_COMMITTER_NAME"] = committer[:name]
-      ENV["GIT_COMMITTER_EMAIL"] = committer[:email]
-    end
+        return false if labels.include?("CI-syntax-only") || labels.include?("CI-no-bottles")
 
-    args.named.uniq.each do |arg|
-      arg = "#{tap.default_remote}/pull/#{arg}" if arg.to_i.positive?
-      url_match = arg.match HOMEBREW_PULL_OR_COMMIT_URL_REGEX
-      _, user, repo, pr = *url_match
-      odie "Not a GitHub pull request: #{arg}" unless pr
+        changed_packages(tap, original_commit).any? do |f|
+          !f.instance_of?(Cask::Cask)
+        end
+      end
 
-      if !tap.path.git_default_origin_branch? || args.branch_okay? || args.clean?
-        opoo "Current branch is #{tap.path.git_branch}: do you need to pull inside #{tap.path.git_origin_branch}?"
+      sig { params(tap: Tap, original_commit: String).returns(T::Array[String]) }
+      def changed_packages(tap, original_commit)
+        formulae = Utils.popen_read("git", "-C", tap.path, "diff-tree",
+                                    "-r", "--name-only", "--diff-filter=AM",
+                                    original_commit, "HEAD", "--", tap.formula_dir)
+                        .lines
+                        .filter_map do |line|
+          next unless line.end_with? ".rb\n"
+
+          name = "#{tap.name}/#{File.basename(line.chomp, ".rb")}"
+          if Homebrew::EnvConfig.disable_load_formula?
+            opoo "Can't check if updated bottles are necessary as HOMEBREW_DISABLE_LOAD_FORMULA is set!"
+            break
+          end
+          begin
+            Formulary.resolve(name)
+          rescue FormulaUnavailableError
+            nil
+          end
+        end
+        casks = Utils.popen_read("git", "-C", tap.path, "diff-tree",
+                                 "-r", "--name-only", "--diff-filter=AM",
+                                 original_commit, "HEAD", "--", tap.cask_dir)
+                     .lines
+                     .filter_map do |line|
+          next unless line.end_with? ".rb\n"
+
+          name = "#{tap.name}/#{File.basename(line.chomp, ".rb")}"
+          begin
+            Cask::CaskLoader.load(name)
+          rescue Cask::CaskUnavailableError
+            nil
+          end
+        end
+        formulae + casks
       end
 
-      ohai "Fetching #{tap} pull request ##{pr}"
-      Dir.mktmpdir pr do |dir|
-        cd dir do
-          original_commit = ENV["GITHUB_SHA"].presence || tap.path.git_head
+      sig { params(repo: String, pull_request: String).void }
+      def pr_check_conflicts(repo, pull_request)
+        long_build_pr_files = GitHub.issues(
+          repo:, state: "open", labels: "no long build conflict",
+        ).each_with_object({}) do |long_build_pr, hash|
+          next unless long_build_pr.key?("pull_request")
 
-          unless args.no_commit?
-            cherry_pick_pr!(user, repo, pr, path: tap.path, args: args)
-            if !args.no_autosquash? && !args.dry_run?
-              autosquash!(original_commit, tap: tap,
-                          verbose: args.verbose?, resolve: args.resolve?, reason: args.message)
-            end
-            signoff!(tap.path, pr: pr, dry_run: args.dry_run?) unless args.clean?
-          end
+          number = long_build_pr["number"]
+          next if number == pull_request.to_i
 
-          unless formulae_need_bottles?(tap, original_commit, user, repo, pr, args: args)
-            ohai "Skipping artifacts for ##{pr} as the formulae don't need bottles"
-            next
+          GitHub.get_pull_request_changed_files(repo, number).each do |file|
+            key = file["filename"]
+            hash[key] ||= []
+            hash[key] << number
           end
+        end
 
-          workflows.each do |workflow|
-            workflow_run = GitHub.get_workflow_run(
-              user, repo, pr, workflow_id: workflow, artifact_name: artifact
-            )
-            if args.ignore_missing_artifacts.present? &&
-               args.ignore_missing_artifacts.include?(workflow) &&
-               workflow_run.first.blank?
-              # Ignore that workflow as it was not executed and we specified
-              # that we could skip it.
-              ohai "Ignoring workflow #{workflow} as requested by `--ignore-missing-artifacts`"
-              next
-            end
+        return if long_build_pr_files.blank?
 
-            ohai "Downloading bottles for workflow: #{workflow}"
-            url = GitHub.get_artifact_url(workflow_run)
-            download_artifact(url, dir, pr)
-          end
+        this_pr_files = GitHub.get_pull_request_changed_files(repo, pull_request)
+
+        conflicts = this_pr_files.each_with_object({}) do |file, hash|
+          filename = file["filename"]
+          next unless long_build_pr_files.key?(filename)
 
-          next if args.no_upload?
-
-          upload_args = ["pr-upload"]
-          upload_args << "--debug" if args.debug?
-          upload_args << "--verbose" if args.verbose?
-          upload_args << "--no-commit" if args.no_commit?
-          upload_args << "--dry-run" if args.dry_run?
-          upload_args << "--keep-old" if args.keep_old?
-          upload_args << "--warn-on-upload-failure" if args.warn_on_upload_failure?
-          upload_args << "--committer=#{args.committer}" if args.committer
-          upload_args << "--root-url=#{args.root_url}" if args.root_url
-          upload_args << "--root-url-using=#{args.root_url_using}" if args.root_url_using
-          safe_system HOMEBREW_BREW_FILE, *upload_args
+          long_build_pr_files[filename].each do |pr_number|
+            key = "#{repo}/pull/#{pr_number}"
+            hash[key] ||= []
+            hash[key] << filename
+          end
         end
-      end
-    end
-  end
-end
 
-class GitHubArtifactDownloadStrategy < AbstractFileDownloadStrategy
-  extend T::Sig
-
-  def fetch(timeout: nil)
-    ohai "Downloading #{url}"
-    if cached_location.exist?
-      puts "Already downloaded: #{cached_location}"
-    else
-      begin
-        curl "--location", "--create-dirs", "--output", temporary_path, url,
-             *meta.fetch(:curl_args, []),
-             secrets: meta.fetch(:secrets, []),
-             timeout: timeout
-      rescue ErrorDuringExecution
-        raise CurlDownloadStrategyError, url
-      end
-      ignore_interrupts do
-        cached_location.dirname.mkpath
-        temporary_path.rename(cached_location)
-        symlink_location.dirname.mkpath
+        return if conflicts.blank?
+
+        # Raise an error, display the conflicting PR. For example:
+        # Error: You are trying to merge a pull request that conflicts with a long running build in:
+        # {
+        #   "homebrew-core/pull/98809": [
+        #    "Formula/icu4c.rb",
+        #    "Formula/node@10.rb"
+        #   ]
+        # }
+        odie <<~EOS
+          You are trying to merge a pull request that conflicts with a long running build in:
+          #{JSON.pretty_generate(conflicts)}
+        EOS
       end
     end
-    FileUtils.ln_s cached_location.relative_path_from(symlink_location.dirname), symlink_location, force: true
-  end
-
-  private
-
-  sig { returns(String) }
-  def resolved_basename
-    "artifact.zip"
   end
 end
diff --git a/Library/Homebrew/dev-cmd/pr-upload.rb b/Library/Homebrew/dev-cmd/pr-upload.rb
index d1abdbc943ece..4217f27e08e2f 100644
--- a/Library/Homebrew/dev-cmd/pr-upload.rb
+++ b/Library/Homebrew/dev-cmd/pr-upload.rb
@@ -1,171 +1,171 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
+require "formula"
 require "github_packages"
 require "github_releases"
+require "extend/hash/deep_merge"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def pr_upload_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Apply the bottle commit and publish bottles to a host.
-      EOS
-      switch "--keep-old",
-             description: "If the formula specifies a rebuild version, " \
-                          "attempt to preserve its value in the generated DSL."
-      switch "-n", "--dry-run",
-             description: "Print what would be done rather than doing it."
-      switch "--no-commit",
-             description: "Do not generate a new commit before uploading."
-      switch "--warn-on-upload-failure",
-             description: "Warn instead of raising an error if the bottle upload fails. " \
-                          "Useful for repairing bottle uploads that previously failed."
-      switch "--upload-only",
-             description: "Skip running `brew bottle` before uploading."
-      flag   "--committer=",
-             description: "Specify a committer name and email in `git`'s standard author format."
-      flag   "--github-org=", hidden: true
-      flag   "--root-url=",
-             description: "Use the specified <URL> as the root of the bottle's URL instead of Homebrew's default."
-      flag   "--root-url-using=",
-             description: "Use the specified download strategy class for downloading the bottle's URL instead of " \
-                          "Homebrew's default."
-
-      conflicts "--upload-only", "--keep-old"
-      conflicts "--upload-only", "--no-commit"
-
-      named_args :none
-    end
-  end
+  module DevCmd
+    class PrUpload < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Apply the bottle commit and publish bottles to a host.
+        EOS
+        switch "--keep-old",
+               description: "If the formula specifies a rebuild version, " \
+                            "attempt to preserve its value in the generated DSL."
+        switch "-n", "--dry-run",
+               description: "Print what would be done rather than doing it."
+        switch "--no-commit",
+               description: "Do not generate a new commit before uploading."
+        switch "--warn-on-upload-failure",
+               description: "Warn instead of raising an error if the bottle upload fails. " \
+                            "Useful for repairing bottle uploads that previously failed."
+        switch "--upload-only",
+               description: "Skip running `brew bottle` before uploading."
+        flag   "--committer=",
+               description: "Specify a committer name and email in `git`'s standard author format."
+        flag   "--root-url=",
+               description: "Use the specified <URL> as the root of the bottle's URL instead of Homebrew's default."
+        flag   "--root-url-using=",
+               description: "Use the specified download strategy class for downloading the bottle's URL instead of " \
+                            "Homebrew's default."
+
+        conflicts "--upload-only", "--keep-old"
+        conflicts "--upload-only", "--no-commit"
+
+        named_args :none
+      end
 
-  def check_bottled_formulae!(bottles_hash)
-    bottles_hash.each do |name, bottle_hash|
-      formula_path = HOMEBREW_REPOSITORY/bottle_hash["formula"]["path"]
-      formula_version = Formulary.factory(formula_path).pkg_version
-      bottle_version = PkgVersion.parse bottle_hash["formula"]["pkg_version"]
-      next if formula_version == bottle_version
+      sig { override.void }
+      def run
+        json_files = Dir["*.bottle.json"]
+        odie "No bottle JSON files found in the current working directory" if json_files.blank?
+
+        Homebrew.install_bundler_gems!(groups: ["pr_upload"])
+
+        bottles_hash = bottles_hash_from_json_files(json_files, args)
+
+        unless args.upload_only?
+          bottle_args = ["bottle", "--merge", "--write"]
+          bottle_args << "--verbose" if args.verbose?
+          bottle_args << "--debug" if args.debug?
+          bottle_args << "--keep-old" if args.keep_old?
+          bottle_args << "--root-url=#{args.root_url}" if args.root_url
+          bottle_args << "--committer=#{args.committer}" if args.committer
+          bottle_args << "--no-commit" if args.no_commit?
+          bottle_args << "--root-url-using=#{args.root_url_using}" if args.root_url_using
+          bottle_args += json_files
+
+          if args.dry_run?
+            dry_run_service = if github_packages?(bottles_hash)
+              # GitHub Packages has its own --dry-run handling.
+              nil
+            elsif github_releases?(bottles_hash)
+              "GitHub Releases"
+            else
+              odie "Service specified by root_url is not recognized"
+            end
+
+            if dry_run_service
+              puts <<~EOS
+                brew #{bottle_args.join " "}
+                Upload bottles described by these JSON files to #{dry_run_service}:
+                  #{json_files.join("\n  ")}
+              EOS
+              return
+            end
+          end
+
+          check_bottled_formulae!(bottles_hash)
+
+          safe_system HOMEBREW_BREW_FILE, *bottle_args
+
+          json_files = Dir["*.bottle.json"]
+          if json_files.blank?
+            puts "No bottle JSON files after merge, no upload needed!"
+            return
+          end
+
+          # Reload the JSON files (in case `brew bottle --merge` generated
+          # `all: $SHA256` bottles)
+          bottles_hash = bottles_hash_from_json_files(json_files, args)
+
+          # Check the bottle commits did not break `brew audit`
+          unless args.no_commit?
+            audit_args = ["audit", "--skip-style"]
+            audit_args << "--verbose" if args.verbose?
+            audit_args << "--debug" if args.debug?
+            audit_args += bottles_hash.keys
+            safe_system HOMEBREW_BREW_FILE, *audit_args
+          end
+        end
 
-      odie "Bottles are for #{name} #{bottle_version} but formula is version #{formula_version}!"
-    end
-  end
+        if github_releases?(bottles_hash)
+          github_releases = GitHubReleases.new
+          github_releases.upload_bottles(bottles_hash)
+        elsif github_packages?(bottles_hash)
+          github_packages = GitHubPackages.new
+          github_packages.upload_bottles(bottles_hash,
+                                         keep_old:      args.keep_old?,
+                                         dry_run:       args.dry_run?,
+                                         warn_on_error: args.warn_on_upload_failure?)
+        else
+          odie "Service specified by root_url is not recognized"
+        end
+      end
 
-  def github_releases?(bottles_hash)
-    @github_releases ||= bottles_hash.values.all? do |bottle_hash|
-      root_url = bottle_hash["bottle"]["root_url"]
-      url_match = root_url.match GitHubReleases::URL_REGEX
-      _, _, _, tag = *url_match
+      private
 
-      tag
-    end
-  end
+      sig { params(bottles_hash: T::Hash[String, T.untyped]).void }
+      def check_bottled_formulae!(bottles_hash)
+        bottles_hash.each do |name, bottle_hash|
+          formula_path = HOMEBREW_REPOSITORY/bottle_hash["formula"]["path"]
+          formula_version = Formulary.factory(formula_path).pkg_version
+          bottle_version = PkgVersion.parse bottle_hash["formula"]["pkg_version"]
+          next if formula_version == bottle_version
 
-  def github_packages?(bottles_hash)
-    @github_packages ||= bottles_hash.values.all? do |bottle_hash|
-      bottle_hash["bottle"]["root_url"].match? GitHubPackages::URL_REGEX
-    end
-  end
+          odie "Bottles are for #{name} #{bottle_version} but formula is version #{formula_version}!"
+        end
+      end
 
-  def bottles_hash_from_json_files(json_files, args)
-    puts "Reading JSON files: #{json_files.join(", ")}" if args.verbose?
+      sig { params(bottles_hash: T::Hash[String, T.untyped]).returns(T::Boolean) }
+      def github_releases?(bottles_hash)
+        @github_releases ||= T.let(bottles_hash.values.all? do |bottle_hash|
+          root_url = bottle_hash["bottle"]["root_url"]
+          url_match = root_url.match GitHubReleases::URL_REGEX
+          _, _, _, tag = *url_match
 
-    bottles_hash = json_files.reduce({}) do |hash, json_file|
-      hash.deep_merge(JSON.parse(File.read(json_file)))
-    end
+          tag
+        end, T.nilable(T::Boolean))
+      end
 
-    if args.root_url
-      bottles_hash.each_value do |bottle_hash|
-        bottle_hash["bottle"]["root_url"] = args.root_url
+      sig { params(bottles_hash: T::Hash[String, T.untyped]).returns(T::Boolean) }
+      def github_packages?(bottles_hash)
+        @github_packages ||= T.let(bottles_hash.values.all? do |bottle_hash|
+          bottle_hash["bottle"]["root_url"].match? GitHubPackages::URL_REGEX
+        end, T.nilable(T::Boolean))
       end
-    end
 
-    bottles_hash
-  end
+      sig { params(json_files: T::Array[String], args: T.untyped).returns(T::Hash[String, T.untyped]) }
+      def bottles_hash_from_json_files(json_files, args)
+        puts "Reading JSON files: #{json_files.join(", ")}" if args.verbose?
 
-  def pr_upload
-    args = pr_upload_args.parse
-
-    odisabled "`brew pr-upload --github-org`", "`brew pr-upload` without `--github-org`" if args.github_org
-
-    json_files = Dir["*.bottle.json"]
-    odie "No bottle JSON files found in the current working directory" if json_files.blank?
-    bottles_hash = bottles_hash_from_json_files(json_files, args)
-
-    unless args.upload_only?
-      bottle_args = ["bottle", "--merge", "--write"]
-      bottle_args << "--verbose" if args.verbose?
-      bottle_args << "--debug" if args.debug?
-      bottle_args << "--keep-old" if args.keep_old?
-      bottle_args << "--root-url=#{args.root_url}" if args.root_url
-      bottle_args << "--committer=#{args.committer}" if args.committer
-      bottle_args << "--no-commit" if args.no_commit?
-      bottle_args << "--root-url-using=#{args.root_url_using}" if args.root_url_using
-      bottle_args += json_files
-
-      if args.dry_run?
-        dry_run_service = if github_packages?(bottles_hash)
-          # GitHub Packages has its own --dry-run handling.
-          nil
-        elsif github_releases?(bottles_hash)
-          "GitHub Releases"
-        else
-          odie "Service specified by root_url is not recognized"
+        bottles_hash = json_files.reduce({}) do |hash, json_file|
+          hash.deep_merge(JSON.parse(File.read(json_file)))
         end
 
-        if dry_run_service
-          puts <<~EOS
-            brew #{bottle_args.join " "}
-            Upload bottles described by these JSON files to #{dry_run_service}:
-              #{json_files.join("\n  ")}
-          EOS
-          return
+        if args.root_url
+          bottles_hash.each_value do |bottle_hash|
+            bottle_hash["bottle"]["root_url"] = args.root_url
+          end
         end
-      end
 
-      check_bottled_formulae!(bottles_hash)
-
-      # This will be run by `brew bottle` and `brew audit` later so run it first
-      # to not start spamming during normal output.
-      Homebrew.install_bundler_gems!
-
-      safe_system HOMEBREW_BREW_FILE, *bottle_args
-
-      json_files = Dir["*.bottle.json"]
-      if json_files.blank?
-        puts "No bottle JSON files after merge, no upload needed!"
-        return
+        bottles_hash
       end
-
-      # Reload the JSON files (in case `brew bottle --merge` generated
-      # `all: $SHA256` bottles)
-      bottles_hash = bottles_hash_from_json_files(json_files, args)
-
-      # Check the bottle commits did not break `brew audit`
-      unless args.no_commit?
-        audit_args = ["audit", "--skip-style"]
-        audit_args << "--verbose" if args.verbose?
-        audit_args << "--debug" if args.debug?
-        audit_args += bottles_hash.keys
-        safe_system HOMEBREW_BREW_FILE, *audit_args
-      end
-    end
-
-    if github_releases?(bottles_hash)
-      github_releases = GitHubReleases.new
-      github_releases.upload_bottles(bottles_hash)
-    elsif github_packages?(bottles_hash)
-      github_packages = GitHubPackages.new
-      github_packages.upload_bottles(bottles_hash,
-                                     keep_old:      args.keep_old?,
-                                     dry_run:       args.dry_run?,
-                                     warn_on_error: args.warn_on_upload_failure?)
-    else
-      odie "Service specified by root_url is not recognized"
     end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/prof.rb b/Library/Homebrew/dev-cmd/prof.rb
index d5b100c1656fb..f2ec8555b5c38 100644
--- a/Library/Homebrew/dev-cmd/prof.rb
+++ b/Library/Homebrew/dev-cmd/prof.rb
@@ -1,47 +1,73 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 
 module Homebrew
-  extend T::Sig
+  module DevCmd
+    class Prof < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Run Homebrew with a Ruby profiler. For example, `brew prof readall`.
+        EOS
+        switch "--stackprof",
+               description: "Use `stackprof` instead of `ruby-prof` (the default)."
+        switch "--vernier",
+               description: "Use `vernier` instead of `ruby-prof` (the default)."
 
-  module_function
+        named_args :command, min: 1
+      end
 
-  sig { returns(CLI::Parser) }
-  def prof_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Run Homebrew with a Ruby profiler. For example, `brew prof readall`.
-      EOS
-      switch "--stackprof",
-             description: "Use `stackprof` instead of `ruby-prof` (the default)."
+      sig { override.void }
+      def run
+        Homebrew.install_bundler_gems!(groups: ["prof"], setup_path: false)
 
-      named_args :command, min: 1
-    end
-  end
+        brew_rb = (HOMEBREW_LIBRARY_PATH/"brew.rb").resolved_path
+        FileUtils.mkdir_p "prof"
+        cmd = args.named.first
 
-  def prof
-    args = prof_args.parse
+        case Commands.path(cmd)&.extname
+        when ".rb"
+          # expected file extension so we do nothing
+        when ".sh"
+          raise UsageError, <<~EOS
+            `#{cmd}` is a Bash command!
+            Try `hyperfine` for benchmarking instead.
+          EOS
+        else
+          raise UsageError, "`#{cmd}` is an unknown command!"
+        end
 
-    brew_rb = (HOMEBREW_LIBRARY_PATH/"brew.rb").resolved_path
-    FileUtils.mkdir_p "prof"
-    cmd = args.named.first
-    raise UsageError, "#{cmd} is a Bash command!" if Commands.path(cmd).extname == ".sh"
+        Homebrew.setup_gem_environment!
 
-    if args.stackprof?
-      Homebrew.install_gem_setup_path! "stackprof"
-      with_env HOMEBREW_STACKPROF: "1" do
-        system RUBY_PATH, brew_rb, *args.named
+        if args.stackprof?
+          with_env HOMEBREW_STACKPROF: "1" do
+            system(*HOMEBREW_RUBY_EXEC_ARGS, brew_rb, *args.named)
+          end
+          output_filename = "prof/d3-flamegraph.html"
+          safe_system "stackprof --d3-flamegraph prof/stackprof.dump > #{output_filename}"
+          exec_browser output_filename
+        elsif args.vernier?
+          output_filename = "prof/vernier.json"
+          Process::UID.change_privilege(Process.euid) if Process.euid != Process.uid
+          safe_system "vernier", "run", "--output=#{output_filename}", "--allocation_sample_rate=500", "--",
+                      RUBY_PATH, brew_rb, *args.named
+          ohai "Profiling complete!"
+          puts "Upload the results from #{output_filename} to:"
+          puts "  #{Formatter.url("https://vernier.prof")}"
+        else
+          output_filename = "prof/call_stack.html"
+          safe_system "ruby-prof", "--printer=call_stack", "--file=#{output_filename}", brew_rb, "--", *args.named
+          exec_browser output_filename
+        end
+      rescue OptionParser::InvalidOption => e
+        ofail e
+
+        # The invalid option could have been meant for the subcommand.
+        # Suggest `brew prof list -r` -> `brew prof -- list -r`
+        args = ARGV - ["--"]
+        puts "Try `brew prof -- #{args.join(" ")}` instead."
       end
-      output_filename = "prof/d3-flamegraph.html"
-      safe_system "stackprof --d3-flamegraph prof/stackprof.dump > #{output_filename}"
-    else
-      Homebrew.install_gem_setup_path! "ruby-prof"
-      output_filename = "prof/call_stack.html"
-      safe_system "ruby-prof", "--printer=call_stack", "--file=#{output_filename}", brew_rb, "--", *args.named
     end
-
-    exec_browser output_filename
   end
 end
diff --git a/Library/Homebrew/dev-cmd/release.rb b/Library/Homebrew/dev-cmd/release.rb
old mode 100755
new mode 100644
index e7e87a4486ee0..86a0cbe075392
--- a/Library/Homebrew/dev-cmd/release.rb
+++ b/Library/Homebrew/dev-cmd/release.rb
@@ -1,102 +1,100 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def release_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Create a new draft Homebrew/brew release with the appropriate version number and release notes.
-
-        By default, `brew release` will bump the patch version number. Pass
-        `--major` or `--minor` to bump the major or minor version numbers, respectively.
-        The command will fail if the previous major or minor release was made less than
-        one month ago.
-
-        Requires write access to the Homebrew/brew repository.
-      EOS
-      switch "--major",
-             description: "Create a major release."
-      switch "--minor",
-             description: "Create a minor release."
-      conflicts "--major", "--minor"
-
-      named_args :none
-    end
-  end
-
-  def release
-    args = release_args.parse
-
-    safe_system "git", "-C", HOMEBREW_REPOSITORY, "fetch", "origin" if Homebrew::EnvConfig.no_auto_update?
-
-    begin
-      latest_release = GitHub.get_latest_release "Homebrew", "brew"
-    rescue GitHub::API::HTTPNotFoundError
-      odie "No existing releases found!"
-    end
-    latest_version = Version.new latest_release["tag_name"]
-
-    if args.major? || args.minor?
-      one_month_ago = Date.today << 1
-      latest_major_minor_release = begin
-        GitHub.get_release "Homebrew", "brew", "#{latest_version.major_minor}.0"
-      rescue GitHub::API::HTTPNotFoundError
-        nil
+  module DevCmd
+    class Release < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Create a new draft Homebrew/brew release with the appropriate version number and release notes.
+
+          By default, `brew release` will bump the patch version number. Pass
+          `--major` or `--minor` to bump the major or minor version numbers, respectively.
+          The command will fail if the previous major or minor release was made less than
+          one month ago.
+
+          *Note:* Requires write access to the Homebrew/brew repository.
+        EOS
+        switch "--major",
+               description: "Create a major release."
+        switch "--minor",
+               description: "Create a minor release."
+        conflicts "--major", "--minor"
+
+        named_args :none
       end
 
-      if latest_major_minor_release.blank?
-        opoo "Unable to determine the release date of the latest major/minor release."
-      elsif Date.parse(latest_major_minor_release["published_at"]) > one_month_ago
-        odie "The latest major/minor release was less than one month ago."
+      sig { override.void }
+      def run
+        safe_system "git", "-C", HOMEBREW_REPOSITORY, "fetch", "origin" if Homebrew::EnvConfig.no_auto_update?
+
+        require "utils/github"
+
+        begin
+          latest_release = GitHub.get_latest_release "Homebrew", "brew"
+        rescue GitHub::API::HTTPNotFoundError
+          odie "No existing releases found!"
+        end
+        latest_version = Version.new latest_release["tag_name"]
+
+        if args.major? || args.minor?
+          one_month_ago = Date.today << 1
+          latest_major_minor_release = begin
+            GitHub.get_release "Homebrew", "brew", "#{latest_version.major_minor}.0"
+          rescue GitHub::API::HTTPNotFoundError
+            nil
+          end
+
+          if latest_major_minor_release.blank?
+            opoo "Unable to determine the release date of the latest major/minor release."
+          elsif Date.parse(latest_major_minor_release["published_at"]) > one_month_ago
+            odie "The latest major/minor release was less than one month ago."
+          end
+        end
+
+        new_version = if args.major?
+          Version.new "#{latest_version.major.to_i + 1}.0.0"
+        elsif args.minor?
+          Version.new "#{latest_version.major}.#{latest_version.minor.to_i + 1}.0"
+        else
+          Version.new "#{latest_version.major}.#{latest_version.minor}.#{latest_version.patch.to_i + 1}"
+        end.to_s
+
+        if args.major? || args.minor?
+          latest_major_minor_version = "#{latest_version.major}.#{latest_version.minor.to_i}.0"
+          ohai "Release notes since #{latest_major_minor_version} for #{new_version} blog post:"
+          # release notes without usernames, new contributors, or extra lines
+          blog_post_notes = GitHub.generate_release_notes("Homebrew", "brew", new_version,
+                                                          previous_tag: latest_major_minor_version)["body"]
+          blog_post_notes = blog_post_notes.lines.filter_map do |line|
+            next unless (match = line.match(/^\* (.*) by @[\w-]+ in (.*)$/))
+
+            "- [#{match[1]}](#{match[2]})"
+          end.sort
+          puts blog_post_notes
+        end
+
+        ohai "Creating draft release for version #{new_version}"
+
+        release_notes = if args.major? || args.minor?
+          "Release notes for this release can be found on the [Homebrew blog](https://brew.sh/blog/#{new_version}).\n"
+        else
+          ""
+        end
+        release_notes += GitHub.generate_release_notes("Homebrew", "brew", new_version,
+                                                       previous_tag: latest_version)["body"]
+
+        begin
+          release = GitHub.create_or_update_release "Homebrew", "brew", new_version, body: release_notes, draft: true
+        rescue *GitHub::API::ERRORS => e
+          odie "Unable to create release: #{e.message}!"
+        end
+
+        puts release["html_url"]
+        exec_browser release["html_url"]
       end
     end
-
-    new_version = if args.major?
-      Version.new "#{latest_version.major.to_i + 1}.0.0"
-    elsif args.minor?
-      Version.new "#{latest_version.major}.#{latest_version.minor.to_i + 1}.0"
-    else
-      Version.new "#{latest_version.major}.#{latest_version.minor}.#{latest_version.patch.to_i + 1}"
-    end.to_s
-
-    if args.major? || args.minor?
-      latest_major_minor_version = "#{latest_version.major}.#{latest_version.minor.to_i}.0"
-      ohai "Release notes since #{latest_major_minor_version} for #{new_version} blog post:"
-      # release notes without usernames, new contributors, or extra lines
-      blog_post_notes = GitHub.generate_release_notes("Homebrew", "brew", new_version,
-                                                      previous_tag: latest_major_minor_version)["body"]
-      blog_post_notes = blog_post_notes.lines.map do |line|
-        next unless (match = line.match(/^\* (.*) by @[\w-]+ in (.*)$/))
-
-        "- [#{match[1]}](#{match[2]})"
-      end.compact.sort
-      puts blog_post_notes
-    end
-
-    ohai "Creating draft release for version #{new_version}"
-
-    release_notes = if args.major? || args.minor?
-      "Release notes for this release can be found on the [Homebrew blog](https://brew.sh/blog/#{new_version}).\n"
-    else
-      ""
-    end
-    release_notes += GitHub.generate_release_notes("Homebrew", "brew", new_version,
-                                                   previous_tag: latest_version)["body"]
-
-    begin
-      release = GitHub.create_or_update_release "Homebrew", "brew", new_version, body: release_notes, draft: true
-    rescue *GitHub::API::ERRORS => e
-      odie "Unable to create release: #{e.message}!"
-    end
-
-    puts release["html_url"]
-    exec_browser release["html_url"]
   end
 end
diff --git a/Library/Homebrew/dev-cmd/rubocop.rb b/Library/Homebrew/dev-cmd/rubocop.rb
new file mode 100644
index 0000000000000..aa33151bb9648
--- /dev/null
+++ b/Library/Homebrew/dev-cmd/rubocop.rb
@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "shell_command"
+
+module Homebrew
+  module DevCmd
+    class Rubocop < AbstractCommand
+      include ShellCommand
+
+      cmd_args do
+        description <<~EOS
+          Installs, configures and runs Homebrew's `rubocop`.
+        EOS
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/dev-cmd/rubocop.sh b/Library/Homebrew/dev-cmd/rubocop.sh
index bc1b8ca769fb6..11e5946f39d15 100644
--- a/Library/Homebrew/dev-cmd/rubocop.sh
+++ b/Library/Homebrew/dev-cmd/rubocop.sh
@@ -1,25 +1,22 @@
-#:  * `rubocop`
-#:
-#:  Installs, configures and runs Homebrew's `rubocop`.
+# Documentation defined in Library/Homebrew/dev-cmd/rubocop.rb
 
 # HOMEBREW_LIBRARY is from the user environment.
 # HOMEBREW_RUBY_PATH is set by utils/ruby.sh
-# RUBY_DISABLE_OPTIONS is set by brew.sh
 # HOMEBREW_BREW_FILE is set by extend/ENV/super.rb
 # shellcheck disable=SC2154
 homebrew-rubocop() {
   source "${HOMEBREW_LIBRARY}/Homebrew/utils/ruby.sh"
   setup-ruby-path
+  setup-gem-home-bundle-gemfile
 
-  GEM_VERSION="$("${HOMEBREW_RUBY_PATH}" "${RUBY_DISABLE_OPTIONS}" -rrbconfig -e 'puts RbConfig::CONFIG["ruby_version"]')"
-  GEM_HOME="${HOMEBREW_LIBRARY}/Homebrew/vendor/bundle/ruby/${GEM_VERSION}"
+  BUNDLE_WITH="style"
+  export BUNDLE_WITH
 
-  if ! [[ -f "${GEM_HOME}/bin/rubocop" ]]
+  if ! bundle check &>/dev/null
   then
-    "${HOMEBREW_BREW_FILE}" install-bundler-gems
+    "${HOMEBREW_BREW_FILE}" install-bundler-gems --add-groups="${BUNDLE_WITH}"
   fi
 
-  export GEM_HOME
   export PATH="${GEM_HOME}/bin:${PATH}"
 
   RUBOCOP="${HOMEBREW_LIBRARY}/Homebrew/utils/rubocop.rb"
diff --git a/Library/Homebrew/dev-cmd/ruby.rb b/Library/Homebrew/dev-cmd/ruby.rb
index ee0ddf6410eb4..db9c9be93c82f 100644
--- a/Library/Homebrew/dev-cmd/ruby.rb
+++ b/Library/Homebrew/dev-cmd/ruby.rb
@@ -1,41 +1,39 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def ruby_args
-    Homebrew::CLI::Parser.new do
-      usage_banner "`ruby` [<options>] (`-e` <text>|<file>)"
-      description <<~EOS
-        Run a Ruby instance with Homebrew's libraries loaded. For example,
-        `brew ruby -e "puts :gcc.f.deps"` or `brew ruby script.rb`.
-      EOS
-      flag "-r=",
-           description: "Load a library using `require`."
-      flag "-e=",
-           description: "Execute the given text string as a script."
-
-      named_args :file
+  module DevCmd
+    class Ruby < AbstractCommand
+      cmd_args do
+        usage_banner "`ruby` [<options>] (`-e` <text>|<file>)"
+        description <<~EOS
+          Run a Ruby instance with Homebrew's libraries loaded. For example,
+          `brew ruby -e "puts :gcc.f.deps"` or `brew ruby script.rb`.
+
+          Run e.g. `brew ruby -- --version` to pass arbitrary arguments to `ruby`.
+        EOS
+        flag "-r=",
+             description: "Load a library using `require`."
+        flag "-e=",
+             description: "Execute the given text string as a script."
+
+        named_args :file
+      end
+
+      sig { override.void }
+      def run
+        ruby_sys_args = []
+        ruby_sys_args << "-r#{args.r}" if args.r
+        ruby_sys_args << "-e #{args.e}" if args.e
+        ruby_sys_args += args.named
+
+        exec(*HOMEBREW_RUBY_EXEC_ARGS,
+             "-I", $LOAD_PATH.join(File::PATH_SEPARATOR),
+             "-rglobal", "-rdev-cmd/irb",
+             *ruby_sys_args)
+      end
     end
   end
-
-  def ruby
-    args = ruby_args.parse
-
-    ruby_sys_args = []
-    ruby_sys_args << "-r#{args.r}" if args.r
-    ruby_sys_args << "-e #{args.e}" if args.e
-    ruby_sys_args += args.named
-
-    exec(*HOMEBREW_RUBY_EXEC_ARGS,
-         "-I", $LOAD_PATH.join(File::PATH_SEPARATOR),
-         "-rglobal", "-rdev-cmd/irb",
-         *ruby_sys_args)
-  end
 end
diff --git a/Library/Homebrew/dev-cmd/rubydoc.rb b/Library/Homebrew/dev-cmd/rubydoc.rb
new file mode 100644
index 0000000000000..e7ca0e9d59e8c
--- /dev/null
+++ b/Library/Homebrew/dev-cmd/rubydoc.rb
@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+
+module Homebrew
+  module DevCmd
+    class Rubydoc < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Generate Homebrew's RubyDoc documentation.
+        EOS
+        switch "--only-public",
+               description: "Only generate public API documentation."
+        switch "--open",
+               description: "Open generated documentation in a browser."
+      end
+
+      sig { override.void }
+      def run
+        Homebrew.install_bundler_gems!(groups: ["doc"])
+
+        HOMEBREW_LIBRARY_PATH.cd do |dir|
+          no_api_args = if args.only_public?
+            ["--hide-api", "private", "--hide-api", "internal"]
+          else
+            []
+          end
+
+          output_dir = dir/"doc"
+
+          safe_system "bundle", "exec", "yard", "doc", "--fail-on-warning", *no_api_args, "--output", output_dir
+
+          exec_browser "file://#{output_dir}/index.html" if args.open?
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/dev-cmd/sh.rb b/Library/Homebrew/dev-cmd/sh.rb
index 71699997fd3f3..d7dbc389f5570 100644
--- a/Library/Homebrew/dev-cmd/sh.rb
+++ b/Library/Homebrew/dev-cmd/sh.rb
@@ -1,72 +1,72 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "extend/ENV"
 require "formula"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
+  module DevCmd
+    class Sh < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Enter an interactive shell for Homebrew's build environment. Use years-battle-hardened
+          build logic to help your `./configure && make && make install`
+          and even your `gem install` succeed. Especially handy if you run Homebrew
+          in an Xcode-only configuration since it adds tools like `make` to your `PATH`
+          which build systems would not find otherwise.
+        EOS
+        flag   "--env=",
+               description: "Use the standard `PATH` instead of superenv's when `std` is passed."
+        flag   "-c=", "--cmd=",
+               description: "Execute commands in a non-interactive shell."
 
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def sh_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Enter an interactive shell for Homebrew's build environment. Use years-battle-hardened
-        build logic to help your `./configure && make && make install`
-        and even your `gem install` succeed. Especially handy if you run Homebrew
-        in an Xcode-only configuration since it adds tools like `make` to your `PATH`
-        which build systems would not find otherwise.
-      EOS
-      flag   "--env=",
-             description: "Use the standard `PATH` instead of superenv's when `std` is passed."
-      flag   "-c=", "--cmd=",
-             description: "Execute commands in a non-interactive shell."
-
-      named_args :file, max: 1
-    end
-  end
+        named_args :file, max: 1
+      end
 
-  def sh
-    args = sh_args.parse
+      sig { override.void }
+      def run
+        ENV.activate_extensions!(env: args.env)
 
-    ENV.activate_extensions!(env: args.env)
+        if superenv?(args.env)
+          T.cast(ENV, Superenv).deps = Formula.installed.select { |f| f.keg_only? && f.opt_prefix.directory? }
+        end
+        ENV.setup_build_environment
+        if superenv?(args.env)
+          # superenv stopped adding brew's bin but generally users will want it
+          ENV["PATH"] = PATH.new(ENV.fetch("PATH")).insert(1, HOMEBREW_PREFIX/"bin").to_s
+        end
 
-    ENV.deps = Formula.installed.select { |f| f.keg_only? && f.opt_prefix.directory? } if superenv?(args.env)
-    ENV.setup_build_environment
-    if superenv?(args.env)
-      # superenv stopped adding brew's bin but generally users will want it
-      ENV["PATH"] = PATH.new(ENV.fetch("PATH")).insert(1, HOMEBREW_PREFIX/"bin")
-    end
+        ENV["VERBOSE"] = "1" if args.verbose?
 
-    ENV["VERBOSE"] = "1" if args.verbose?
+        preferred_shell = Utils::Shell.preferred_path(default: "/bin/bash")
 
-    if args.cmd.present?
-      safe_system(preferred_shell, "-c", args.cmd)
-    elsif args.named.present?
-      safe_system(preferred_shell, args.named.first)
-    else
-      shell_type = Utils::Shell.preferred
-      subshell = case shell_type
-      when :zsh
-        "PS1='brew %B%F{green}%~%f%b$ ' #{preferred_shell} -d -f"
-      when :bash
-        "PS1=\"brew \\[\\033[1;32m\\]\\w\\[\\033[0m\\]$ \" #{preferred_shell} --noprofile --norc"
-      else
-        "PS1=\"brew \\[\\033[1;32m\\]\\w\\[\\033[0m\\]$ \" #{preferred_shell}"
+        if args.cmd.present?
+          safe_system(preferred_shell, "-c", args.cmd)
+        elsif args.named.present?
+          safe_system(preferred_shell, args.named.first)
+        else
+          shell_type = Utils::Shell.preferred
+          subshell = case shell_type
+          when :zsh
+            "PS1='brew %B%F{green}%~%f%b$ ' #{preferred_shell} -d -f"
+          when :bash
+            "PS1=\"brew \\[\\033[1;32m\\]\\w\\[\\033[0m\\]$ \" #{preferred_shell} --noprofile --norc"
+          else
+            "PS1=\"brew \\[\\033[1;32m\\]\\w\\[\\033[0m\\]$ \" #{preferred_shell}"
+          end
+          puts <<~EOS
+            Your shell has been configured to use Homebrew's build environment;
+            this should help you build stuff. Notably though, the system versions of
+            gem and pip will ignore our configuration and insist on using the
+            environment they were built under (mostly). Sadly, scons will also
+            ignore our configuration.
+            When done, type `exit`.
+          EOS
+          $stdout.flush
+          safe_system subshell
+        end
       end
-      puts <<~EOS
-        Your shell has been configured to use Homebrew's build environment;
-        this should help you build stuff. Notably though, the system versions of
-        gem and pip will ignore our configuration and insist on using the
-        environment they were built under (mostly). Sadly, scons will also
-        ignore our configuration.
-        When done, type `exit`.
-      EOS
-      $stdout.flush
-      safe_system subshell
     end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/sponsors.rb b/Library/Homebrew/dev-cmd/sponsors.rb
deleted file mode 100644
index 8a51f50f9e57c..0000000000000
--- a/Library/Homebrew/dev-cmd/sponsors.rb
+++ /dev/null
@@ -1,76 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "cli/parser"
-require "utils/github"
-
-module Homebrew
-  extend T::Sig
-
-  module_function
-
-  NAMED_TIER_AMOUNT = 100
-  URL_TIER_AMOUNT = 1000
-
-  sig { returns(CLI::Parser) }
-  def sponsors_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Update the list of GitHub Sponsors in the `Homebrew/brew` README.
-      EOS
-
-      named_args :none
-    end
-  end
-
-  def sponsor_name(s)
-    s["name"] || s["login"]
-  end
-
-  def sponsor_logo(s)
-    "https://github.com/#{s["login"]}.png?size=64"
-  end
-
-  def sponsor_url(s)
-    "https://github.com/#{s["login"]}"
-  end
-
-  def sponsors
-    sponsors_args.parse
-
-    named_sponsors = []
-    logo_sponsors = []
-
-    GitHub.sponsors_by_tier("Homebrew").each do |tier|
-      if tier["tier"] >= NAMED_TIER_AMOUNT
-        named_sponsors += tier["sponsors"].map do |s|
-          "[#{sponsor_name(s)}](#{sponsor_url(s)})"
-        end
-      end
-
-      next if tier["tier"] < URL_TIER_AMOUNT
-
-      logo_sponsors += tier["sponsors"].map do |s|
-        "[![#{sponsor_name(s)}](#{sponsor_logo(s)})](#{sponsor_url(s)})"
-      end
-    end
-
-    named_sponsors << "many other users and organisations via [GitHub Sponsors](https://github.com/sponsors/Homebrew)"
-
-    readme = HOMEBREW_REPOSITORY/"README.md"
-    content = readme.read
-    content.gsub!(/(Homebrew is generously supported by) .*\Z/m, "\\1 #{named_sponsors.to_sentence}.\n")
-    content << "\n#{logo_sponsors.join}\n" if logo_sponsors.presence
-
-    File.write(readme, content)
-
-    diff = system_command "git", args: [
-      "-C", HOMEBREW_REPOSITORY, "diff", "--exit-code", "README.md"
-    ]
-    if diff.status.success?
-      puts "No changes to list of sponsors."
-    else
-      puts "List of sponsors updated in the README."
-    end
-  end
-end
diff --git a/Library/Homebrew/dev-cmd/style.rb b/Library/Homebrew/dev-cmd/style.rb
index 4c4867ae684b1..f9db3f42f1087 100644
--- a/Library/Homebrew/dev-cmd/style.rb
+++ b/Library/Homebrew/dev-cmd/style.rb
@@ -1,77 +1,75 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "json"
 require "open3"
 require "style"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
+  module DevCmd
+    class StyleCmd < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Check formulae or files for conformance to Homebrew style guidelines.
 
-  module_function
+          Lists of <file>, <tap> and <formula> may not be combined. If none are
+          provided, `style` will run style checks on the whole Homebrew library,
+          including core code and all formulae.
+        EOS
+        switch "--fix",
+               description: "Fix style violations automatically using RuboCop's auto-correct feature."
+        switch "--display-cop-names",
+               description: "Include the RuboCop cop name for each violation in the output.",
+               hidden:      true
+        switch "--reset-cache",
+               description: "Reset the RuboCop cache."
+        switch "--formula", "--formulae",
+               description: "Treat all named arguments as formulae."
+        switch "--cask", "--casks",
+               description: "Treat all named arguments as casks."
+        comma_array "--only-cops",
+                    description: "Specify a comma-separated <cops> list to check for violations of only the " \
+                                 "listed RuboCop cops."
+        comma_array "--except-cops",
+                    description: "Specify a comma-separated <cops> list to skip checking for violations of the " \
+                                 "listed RuboCop cops."
 
-  sig { returns(CLI::Parser) }
-  def style_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Check formulae or files for conformance to Homebrew style guidelines.
+        conflicts "--formula", "--cask"
+        conflicts "--only-cops", "--except-cops"
 
-        Lists of <file>, <tap> and <formula> may not be combined. If none are
-        provided, `style` will run style checks on the whole Homebrew library,
-        including core code and all formulae.
-      EOS
-      switch "--fix",
-             description: "Fix style violations automatically using RuboCop's auto-correct feature."
-      switch "--display-cop-names",
-             description: "Include the RuboCop cop name for each violation in the output."
-      switch "--reset-cache",
-             description: "Reset the RuboCop cache."
-      switch "--formula", "--formulae",
-             description: "Treat all named arguments as formulae."
-      switch "--cask", "--casks",
-             description: "Treat all named arguments as casks."
-      comma_array "--only-cops",
-                  description: "Specify a comma-separated <cops> list to check for violations of only the " \
-                               "listed RuboCop cops."
-      comma_array "--except-cops",
-                  description: "Specify a comma-separated <cops> list to skip checking for violations of the " \
-                               "listed RuboCop cops."
+        named_args [:file, :tap, :formula, :cask], without_api: true
+      end
 
-      conflicts "--formula", "--cask"
-      conflicts "--only-cops", "--except-cops"
+      sig { override.void }
+      def run
+        Homebrew.install_bundler_gems!(groups: ["style"])
 
-      named_args [:file, :tap, :formula, :cask]
-    end
-  end
+        target = if args.no_named?
+          nil
+        else
+          args.named.to_paths
+        end
 
-  def style
-    args = style_args.parse
+        only_cops = args.only_cops
+        except_cops = args.except_cops
 
-    target = if args.no_named?
-      nil
-    else
-      args.named.to_paths
-    end
+        options = {
+          fix:         args.fix?,
+          reset_cache: args.reset_cache?,
+          debug:       args.debug?,
+          verbose:     args.verbose?,
+        }
+        if only_cops
+          options[:only_cops] = only_cops
+        elsif except_cops
+          options[:except_cops] = except_cops
+        else
+          options[:except_cops] = %w[FormulaAuditStrict]
+        end
 
-    only_cops = args.only_cops
-    except_cops = args.except_cops
-
-    options = {
-      fix:               args.fix?,
-      display_cop_names: args.display_cop_names?,
-      reset_cache:       args.reset_cache?,
-      debug:             args.debug?,
-      verbose:           args.verbose?,
-    }
-    if only_cops
-      options[:only_cops] = only_cops
-    elsif except_cops
-      options[:except_cops] = except_cops
-    else
-      options[:except_cops] = %w[FormulaAuditStrict]
+        Homebrew.failed = !Style.check_style_and_print(target, **options)
+      end
     end
-
-    Homebrew.failed = !Style.check_style_and_print(target, options)
   end
 end
diff --git a/Library/Homebrew/dev-cmd/tap-new.rb b/Library/Homebrew/dev-cmd/tap-new.rb
index f09775fd0b5f8..6e59498428590 100644
--- a/Library/Homebrew/dev-cmd/tap-new.rb
+++ b/Library/Homebrew/dev-cmd/tap-new.rb
@@ -1,186 +1,210 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
+require "fileutils"
 require "tap"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def tap_new_args
-    Homebrew::CLI::Parser.new do
-      usage_banner "`tap-new` [<options>] <user>`/`<repo>"
-      description <<~EOS
-        Generate the template files for a new tap.
-      EOS
-
-      switch "--no-git",
-             description: "Don't initialize a Git repository for the tap."
-      flag   "--pull-label=",
-             description: "Label name for pull requests ready to be pulled (default: `pr-pull`)."
-      flag   "--branch=",
-             description: "Initialize Git repository and setup GitHub Actions workflows with the " \
-                          "specified branch name (default: `main`)."
-      switch "--github-packages",
-             description: "Upload bottles to GitHub Packages."
-
-      named_args :tap, number: 1
-    end
-  end
-
-  def tap_new
-    args = tap_new_args.parse
-
-    label = args.pull_label || "pr-pull"
-    branch = args.branch || "main"
-
-    tap = args.named.to_taps.first
-    odie "Invalid tap name '#{tap}'" unless tap.path.to_s.match?(HOMEBREW_TAP_PATH_REGEX)
-
-    titleized_user = tap.user.dup
-    titleized_repo = tap.repo.dup
-    titleized_user[0] = titleized_user[0].upcase
-    titleized_repo[0] = titleized_repo[0].upcase
-    root_url = GitHubPackages.root_url(tap.user, "homebrew-#{tap.repo}") if args.github_packages?
-
-    (tap.path/"Formula").mkpath
-
-    readme = <<~MARKDOWN
-      # #{titleized_user} #{titleized_repo}
-
-      ## How do I install these formulae?
-
-      `brew install #{tap}/<formula>`
-
-      Or `brew tap #{tap}` and then `brew install <formula>`.
-
-      ## Documentation
-
-      `brew help`, `man brew` or check [Homebrew's documentation](https://docs.brew.sh).
-    MARKDOWN
-    write_path(tap, "README.md", readme)
-
-    actions_main = <<~YAML
-      name: brew test-bot
-      on:
-        push:
-          branches:
-            - #{branch}
-        pull_request:
-      jobs:
-        test-bot:
-          strategy:
-            matrix:
-              os: [ubuntu-latest, macos-latest]
-          runs-on: ${{ matrix.os }}
-          steps:
-            - name: Set up Homebrew
-              id: set-up-homebrew
-              uses: Homebrew/actions/setup-homebrew@master
-
-            - name: Cache Homebrew Bundler RubyGems
-              id: cache
-              uses: actions/cache@v1
-              with:
-                path: ${{ steps.set-up-homebrew.outputs.gems-path }}
-                key: ${{ runner.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }}
-                restore-keys: ${{ runner.os }}-rubygems-
-
-            - name: Install Homebrew Bundler RubyGems
-              if: steps.cache.outputs.cache-hit != 'true'
-              run: brew install-bundler-gems
-
-            - run: brew test-bot --only-cleanup-before
-
-            - run: brew test-bot --only-setup
-
-            - run: brew test-bot --only-tap-syntax
-
-            - run: brew test-bot --only-formulae#{" --root-url=#{root_url}" if root_url}
-              if: github.event_name == 'pull_request'
-
-            - name: Upload bottles as artifact
-              if: always() && github.event_name == 'pull_request'
-              uses: actions/upload-artifact@main
-              with:
-                name: bottles
-                path: '*.bottle.*'
-    YAML
-
-    actions_publish = <<~YAML
-      name: brew pr-pull
-      on:
-        pull_request_target:
-          types:
-            - labeled
-      jobs:
-        pr-pull:
-          if: contains(github.event.pull_request.labels.*.name, '#{label}')
-          runs-on: ubuntu-latest
-          steps:
-            - name: Set up Homebrew
-              uses: Homebrew/actions/setup-homebrew@master
-
-            - name: Set up git
-              uses: Homebrew/actions/git-user-config@master
-
-            - name: Pull bottles
-              env:
-                HOMEBREW_GITHUB_API_TOKEN: ${{ github.token }}
-                HOMEBREW_GITHUB_PACKAGES_TOKEN: ${{ github.token }}
-                HOMEBREW_GITHUB_PACKAGES_USER: ${{ github.actor }}
-                PULL_REQUEST: ${{ github.event.pull_request.number }}
-              run: brew pr-pull --debug --tap=$GITHUB_REPOSITORY $PULL_REQUEST
-
-            - name: Push commits
-              uses: Homebrew/actions/git-try-push@master
-              with:
-                token: ${{ github.token }}
-                branch: #{branch}
-
-            - name: Delete branch
-              if: github.event.pull_request.head.repo.fork == false
-              env:
-                BRANCH: ${{ github.event.pull_request.head.ref }}
-              run: git push --delete origin $BRANCH
-    YAML
-
-    (tap.path/".github/workflows").mkpath
-    write_path(tap, ".github/workflows/tests.yml", actions_main)
-    write_path(tap, ".github/workflows/publish.yml", actions_publish)
-
-    unless args.no_git?
-      cd tap.path do
-        Utils::Git.set_name_email!
-        Utils::Git.setup_gpg!
-
-        # Would be nice to use --initial-branch here but it's not available in
-        # older versions of Git that we support.
-        safe_system "git", "-c", "init.defaultBranch=#{branch}", "init"
-        safe_system "git", "add", "--all"
-        safe_system "git", "commit", "-m", "Create #{tap} tap"
-        safe_system "git", "branch", "-m", branch
+  module DevCmd
+    class TapNew < AbstractCommand
+      include FileUtils
+
+      cmd_args do
+        usage_banner "`tap-new` [<options>] <user>`/`<repo>"
+        description <<~EOS
+          Generate the template files for a new tap.
+        EOS
+
+        switch "--no-git",
+               description: "Don't initialize a Git repository for the tap."
+        flag   "--pull-label=",
+               description: "Label name for pull requests ready to be pulled (default: `pr-pull`)."
+        flag   "--branch=",
+               description: "Initialize Git repository and setup GitHub Actions workflows with the " \
+                            "specified branch name (default: `main`)."
+        switch "--github-packages",
+               description: "Upload bottles to GitHub Packages."
+
+        named_args :tap, number: 1
       end
-    end
 
-    ohai "Created #{tap}"
-    puts <<~EOS
-      #{tap.path}
+      sig { override.void }
+      def run
+        label = args.pull_label || "pr-pull"
+        branch = args.branch || "main"
+
+        tap = args.named.to_taps.fetch(0)
+        odie "Invalid tap name '#{tap}'" unless tap.path.to_s.match?(HOMEBREW_TAP_PATH_REGEX)
+        odie "Tap is already installed!" if tap.installed?
+
+        titleized_user = tap.user.dup
+        titleized_repository = tap.repository.dup
+        titleized_user[0] = titleized_user[0].upcase
+        titleized_repository[0] = titleized_repository[0].upcase
+        root_url = GitHubPackages.root_url(tap.user, "homebrew-#{tap.repository}") if args.github_packages?
+
+        (tap.path/"Formula").mkpath
+
+        # FIXME: https://github.com/errata-ai/vale/issues/818
+        # <!-- vale off -->
+        readme = <<~MARKDOWN
+          # #{titleized_user} #{titleized_repository}
+
+          ## How do I install these formulae?
+
+          `brew install #{tap}/<formula>`
+
+          Or `brew tap #{tap}` and then `brew install <formula>`.
+
+          Or, in a [`brew bundle`](https://github.com/Homebrew/homebrew-bundle) `Brewfile`:
+
+          ```ruby
+          tap "#{tap}"
+          brew "<formula>"
+          ```
+
+          ## Documentation
+
+          `brew help`, `man brew` or check [Homebrew's documentation](https://docs.brew.sh).
+        MARKDOWN
+        # <!-- vale on -->
+        write_path(tap, "README.md", readme)
+
+        actions_main = <<~YAML
+          name: brew test-bot
+
+          on:
+            push:
+              branches:
+                - #{branch}
+            pull_request:
+
+          jobs:
+            test-bot:
+              strategy:
+                matrix:
+                  os: [ubuntu-22.04, macos-13, macos-15]
+              runs-on: ${{ matrix.os }}
+              steps:
+                - name: Set up Homebrew
+                  id: set-up-homebrew
+                  uses: Homebrew/actions/setup-homebrew@master
+
+                - name: Cache Homebrew Bundler RubyGems
+                  uses: actions/cache@v4
+                  with:
+                    path: ${{ steps.set-up-homebrew.outputs.gems-path }}
+                    key: ${{ matrix.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }}
+                    restore-keys: ${{ matrix.os }}-rubygems-
+
+                - run: brew test-bot --only-cleanup-before
+
+                - run: brew test-bot --only-setup
+
+                - run: brew test-bot --only-tap-syntax
+
+                - run: brew test-bot --only-formulae#{" --root-url='#{root_url}'" if root_url}
+                  if: github.event_name == 'pull_request'
+
+                - name: Upload bottles as artifact
+                  if: always() && github.event_name == 'pull_request'
+                  uses: actions/upload-artifact@v4
+                  with:
+                    name: bottles_${{ matrix.os }}
+                    path: '*.bottle.*'
+        YAML
+
+        pr_pull_permissions = {
+          "contents"      => "write",
+          "pull-requests" => "write",
+        }
+        pr_pull_env = {
+          "HOMEBREW_GITHUB_API_TOKEN" => "${{ github.token }}",
+        }
+        if args.github_packages?
+          pr_pull_permissions["packages"] = "write"
+          pr_pull_env["HOMEBREW_GITHUB_PACKAGES_TOKEN"] = "${{ github.token }}"
+          pr_pull_env["HOMEBREW_GITHUB_PACKAGES_USER"] = "${{ github.repository_owner }}"
+        end
+        actions_publish = <<~YAML
+          name: brew pr-pull
+
+          on:
+            pull_request_target:
+              types:
+                - labeled
+
+          jobs:
+            pr-pull:
+              if: contains(github.event.pull_request.labels.*.name, '#{label}')
+              runs-on: ubuntu-22.04
+              permissions:
+          #{pr_pull_permissions.sort.map { |k, v| "      #{k}: #{v}" }.join("\n")}
+              steps:
+                - name: Set up Homebrew
+                  uses: Homebrew/actions/setup-homebrew@master
+
+                - name: Set up git
+                  uses: Homebrew/actions/git-user-config@master
+
+                - name: Pull bottles
+                  env:
+          #{pr_pull_env.sort.map { |k, v| "          #{k}: #{v}" }.join("\n")}
+                    PULL_REQUEST: ${{ github.event.pull_request.number }}
+                  run: brew pr-pull --debug --tap="$GITHUB_REPOSITORY" "$PULL_REQUEST"
+
+                - name: Push commits
+                  uses: Homebrew/actions/git-try-push@master
+                  with:
+                    token: ${{ github.token }}
+                    branch: #{branch}
+
+                - name: Delete branch
+                  if: github.event.pull_request.head.repo.fork == false
+                  env:
+                    BRANCH: ${{ github.event.pull_request.head.ref }}
+                  run: git push --delete origin "$BRANCH"
+        YAML
+
+        (tap.path/".github/workflows").mkpath
+        write_path(tap, ".github/workflows/tests.yml", actions_main)
+        write_path(tap, ".github/workflows/publish.yml", actions_publish)
+
+        unless args.no_git?
+          cd tap.path do
+            Utils::Git.set_name_email!
+            Utils::Git.setup_gpg!
+
+            # Would be nice to use --initial-branch here but it's not available in
+            # older versions of Git that we support.
+            safe_system "git", "-c", "init.defaultBranch=#{branch}", "init"
+            safe_system "git", "add", "--all"
+            safe_system "git", "commit", "-m", "Create #{tap} tap"
+            safe_system "git", "branch", "-m", branch
+          end
+        end
+
+        ohai "Created #{tap}"
+        puts <<~EOS
+          #{tap.path}
+
+          When a pull request making changes to a formula (or formulae) becomes green
+          (all checks passed), then you can publish the built bottles.
+          To do so, label your PR as `#{label}` and the workflow will be triggered.
+        EOS
+      end
 
-      When a pull request making changes to a formula (or formulae) becomes green
-      (all checks passed), then you can publish the built bottles.
-      To do so, label your PR as `#{label}` and the workflow will be triggered.
-    EOS
-  end
+      private
 
-  def write_path(tap, filename, content)
-    path = tap.path/filename
-    tap.path.mkpath
-    odie "#{path} already exists" if path.exist?
+      sig { params(tap: Tap, filename: T.any(String, Pathname), content: String).void }
+      def write_path(tap, filename, content)
+        path = tap.path/filename
+        tap.path.mkpath
+        odie "#{path} already exists" if path.exist?
 
-    path.write content
+        path.write content
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/test.rb b/Library/Homebrew/dev-cmd/test.rb
index a03927cd48347..98556f4d5b716 100644
--- a/Library/Homebrew/dev-cmd/test.rb
+++ b/Library/Homebrew/dev-cmd/test.rb
@@ -1,128 +1,131 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
 require "extend/ENV"
 require "sandbox"
 require "timeout"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def test_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Run the test method provided by an installed formula.
-        There is no standard output or return code, but generally it should notify the
-        user if something is wrong with the installed formula.
-
-        *Example:* `brew install jruby && brew test jruby`
-      EOS
-      switch "-f", "--force",
-             description: "Test formulae even if they are unlinked."
-      switch "--HEAD",
-             description: "Test the head version of a formula."
-      switch "--keep-tmp",
-             description: "Retain the temporary files created for the test."
-      switch "--retry",
-             description: "Retry if a testing fails."
-
-      named_args :installed_formula, min: 1
-    end
-  end
+  module DevCmd
+    class Test < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Run the test method provided by an installed formula.
+          There is no standard output or return code, but generally it should notify the
+          user if something is wrong with the installed formula.
+
+          *Example:* `brew install jruby && brew test jruby`
+        EOS
+        switch "-f", "--force",
+               description: "Test formulae even if they are unlinked."
+        switch "--HEAD",
+               description: "Test the HEAD version of a formula."
+        switch "--keep-tmp",
+               description: "Retain the temporary files created for the test."
+        switch "--retry",
+               description: "Retry if a testing fails."
+
+        named_args :installed_formula, min: 1, without_api: true
+      end
 
-  def test
-    args = test_args.parse
+      sig { override.void }
+      def run
+        Homebrew.install_bundler_gems!(groups: ["formula_test"], setup_path: false)
 
-    Homebrew.install_bundler_gems!(setup_path: false)
+        require "formula_assertions"
+        require "formula_free_port"
+        require "utils/fork"
 
-    require "formula_assertions"
-    require "formula_free_port"
+        args.named.to_resolved_formulae.each do |f|
+          # Cannot test uninstalled formulae
+          unless f.latest_version_installed?
+            ofail "Testing requires the latest version of #{f.full_name}"
+            next
+          end
 
-    args.named.to_resolved_formulae.each do |f|
-      # Cannot test uninstalled formulae
-      unless f.latest_version_installed?
-        ofail "Testing requires the latest version of #{f.full_name}"
-        next
-      end
+          # Cannot test formulae without a test method
+          unless f.test_defined?
+            ofail "#{f.full_name} defines no test"
+            next
+          end
 
-      # Cannot test formulae without a test method
-      unless f.test_defined?
-        ofail "#{f.full_name} defines no test"
-        next
-      end
+          # Don't test unlinked formulae
+          if !args.force? && !f.keg_only? && !f.linked?
+            ofail "#{f.full_name} is not linked"
+            next
+          end
 
-      # Don't test unlinked formulae
-      if !args.force? && !f.keg_only? && !f.linked?
-        ofail "#{f.full_name} is not linked"
-        next
-      end
+          # Don't test formulae missing test dependencies
+          missing_test_deps = f.recursive_dependencies do |dependent, dependency|
+            Dependency.prune if dependency.installed?
+            next if dependency.test? && dependent == f
 
-      # Don't test formulae missing test dependencies
-      missing_test_deps = f.recursive_dependencies do |_, dependency|
-        Dependency.prune if dependency.installed?
-        next if dependency.test?
-
-        Dependency.prune if dependency.optional?
-        Dependency.prune if dependency.build?
-      end.map(&:to_s)
-      unless missing_test_deps.empty?
-        ofail "#{f.full_name} is missing test dependencies: #{missing_test_deps.join(" ")}"
-        next
-      end
+            Dependency.prune unless dependency.required?
+          end.map(&:to_s)
+          unless missing_test_deps.empty?
+            ofail "#{f.full_name} is missing test dependencies: #{missing_test_deps.join(" ")}"
+            next
+          end
 
-      oh1 "Testing #{f.full_name}"
-
-      env = ENV.to_hash
-
-      begin
-        exec_args = HOMEBREW_RUBY_EXEC_ARGS + %W[
-          --
-          #{HOMEBREW_LIBRARY_PATH}/test.rb
-          #{f.path}
-        ].concat(args.options_only)
-
-        exec_args << "--HEAD" if f.head?
-
-        Utils.safe_fork do
-          if Sandbox.available?
-            sandbox = Sandbox.new
-            f.logs.mkpath
-            sandbox.record_log(f.logs/"test.sandbox.log")
-            sandbox.allow_write_temp_and_cache
-            sandbox.allow_write_log(f)
-            sandbox.allow_write_xcode
-            sandbox.allow_write_path(HOMEBREW_PREFIX/"var/cache")
-            sandbox.allow_write_path(HOMEBREW_PREFIX/"var/homebrew/locks")
-            sandbox.allow_write_path(HOMEBREW_PREFIX/"var/log")
-            sandbox.allow_write_path(HOMEBREW_PREFIX/"var/run")
-            sandbox.exec(*exec_args)
-          else
-            exec(*exec_args)
+          oh1 "Testing #{f.full_name}"
+
+          env = ENV.to_hash
+
+          begin
+            exec_args = HOMEBREW_RUBY_EXEC_ARGS + %W[
+              --
+              #{HOMEBREW_LIBRARY_PATH}/test.rb
+              #{f.path}
+            ].concat(args.options_only)
+
+            exec_args << "--HEAD" if f.head?
+
+            if Sandbox.available?
+              sandbox = Sandbox.new
+              f.logs.mkpath
+              sandbox.record_log(f.logs/"test.sandbox.log")
+              sandbox.allow_write_temp_and_cache
+              sandbox.allow_write_log(f)
+              sandbox.allow_write_xcode
+              sandbox.allow_write_path(HOMEBREW_PREFIX/"var/cache")
+              sandbox.allow_write_path(HOMEBREW_PREFIX/"var/homebrew/locks")
+              sandbox.allow_write_path(HOMEBREW_PREFIX/"var/log")
+              sandbox.allow_write_path(HOMEBREW_PREFIX/"var/run")
+              sandbox.deny_all_network unless f.class.network_access_allowed?(:test)
+              sandbox.run(*exec_args)
+            else
+              Utils.safe_fork do
+                exec(*exec_args)
+              end
+            end
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            retry if retry_test?(f)
+
+            require "utils/backtrace"
+            ofail "#{f.full_name}: failed"
+            $stderr.puts e, Utils::Backtrace.clean(e)
+          ensure
+            ENV.replace(env)
           end
         end
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        retry if retry_test?(f, args: args)
-        ofail "#{f.full_name}: failed"
-        $stderr.puts e, e.backtrace
-      ensure
-        ENV.replace(env)
       end
-    end
-  end
 
-  def retry_test?(f, args:)
-    @test_failed ||= Set.new
-    if args.retry? && @test_failed.add?(f)
-      oh1 "Testing #{f.full_name} (again)"
-      f.clear_cache
-      true
-    else
-      Homebrew.failed = true
-      false
+      private
+
+      sig { params(formula: Formula).returns(T::Boolean) }
+      def retry_test?(formula)
+        @test_failed ||= T.let(Set.new, T.nilable(T::Set[T.untyped]))
+        if args.retry? && @test_failed.add?(formula)
+          oh1 "Testing #{formula.full_name} (again)"
+          formula.clear_cache
+          ENV["RUST_BACKTRACE"] = "full"
+          true
+        else
+          Homebrew.failed = true
+          false
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/tests.rb b/Library/Homebrew/dev-cmd/tests.rb
index a7ea3dc96ac57..b45df9ac942d7 100644
--- a/Library/Homebrew/dev-cmd/tests.rb
+++ b/Library/Homebrew/dev-cmd/tests.rb
@@ -1,237 +1,281 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 require "fileutils"
+require "system_command"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def tests_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Run Homebrew's unit and integration tests.
-      EOS
-      switch "--coverage",
-             description: "Generate code coverage reports."
-      switch "--generic",
-             description: "Run only OS-agnostic tests."
-      switch "--no-compat",
-             description: "Do not load the compatibility layer when running tests."
-      switch "--online",
-             description: "Include tests that use the GitHub API and tests that use any of the taps for " \
-                          "official external commands."
-      switch "--byebug",
-             description: "Enable debugging using byebug."
-      switch "--changed",
-             description: "Only runs tests on files that were changed from the master branch."
-      flag   "--only=",
-             description: "Run only <test_script>`_spec.rb`. Appending `:`<line_number> will start at a " \
-                          "specific line."
-      flag   "--seed=",
-             description: "Randomise tests with the specified <value> instead of a random seed."
-
-      conflicts "--changed", "--only"
-
-      named_args :none
-    end
-  end
-
-  def use_buildpulse?
-    return @use_buildpulse if defined?(@use_buildpulse)
-
-    @use_buildpulse = ENV["HOMEBREW_BUILDPULSE_ACCESS_KEY_ID"].present? &&
-                      ENV["HOMEBREW_BUILDPULSE_SECRET_ACCESS_KEY"].present? &&
-                      ENV["HOMEBREW_BUILDPULSE_ACCOUNT_ID"].present? &&
-                      ENV["HOMEBREW_BUILDPULSE_REPOSITORY_ID"].present?
-  end
-
-  def run_buildpulse
-    require "formula"
-
-    with_env(HOMEBREW_NO_AUTO_UPDATE: "1", HOMEBREW_NO_BOOTSNAP: "1") do
-      ensure_formula_installed!("buildpulse-test-reporter",
-                                reason: "reporting test flakiness")
-    end
-
-    ENV["BUILDPULSE_ACCESS_KEY_ID"] = ENV.fetch("HOMEBREW_BUILDPULSE_ACCESS_KEY_ID")
-    ENV["BUILDPULSE_SECRET_ACCESS_KEY"] = ENV.fetch("HOMEBREW_BUILDPULSE_SECRET_ACCESS_KEY")
-
-    ohai "Sending test results to BuildPulse"
-
-    safe_system Formula["buildpulse-test-reporter"].opt_bin/"buildpulse-test-reporter",
-                "submit", "#{HOMEBREW_LIBRARY_PATH}/test/junit",
-                "--account-id", ENV.fetch("HOMEBREW_BUILDPULSE_ACCOUNT_ID"),
-                "--repository-id", ENV.fetch("HOMEBREW_BUILDPULSE_REPOSITORY_ID")
-  end
-
-  def changed_test_files
-    changed_files = Utils.popen_read("git", "diff", "--name-only", "master")
-
-    raise UsageError, "No files have been changed from the master branch!" if changed_files.blank?
-
-    filestub_regex = %r{Library/Homebrew/([\w/-]+).rb}
-    changed_files.scan(filestub_regex).map(&:last).map do |filestub|
-      if filestub.start_with?("test/")
-        # Only run tests on *_spec.rb files in test/ folder
-        filestub.end_with?("_spec") ? Pathname("#{filestub}.rb") : nil
-      else
-        # For all other changed .rb files guess the associated test file name
-        Pathname("test/#{filestub}_spec.rb")
+  module DevCmd
+    class Tests < AbstractCommand
+      include SystemCommand::Mixin
+
+      cmd_args do
+        description <<~EOS
+          Run Homebrew's unit and integration tests.
+        EOS
+        switch "--coverage",
+               description: "Generate code coverage reports."
+        switch "--generic",
+               description: "Run only OS-agnostic tests."
+        switch "--online",
+               description: "Include tests that use the GitHub API and tests that use any of the taps for " \
+                            "official external commands."
+        switch "--debug",
+               description: "Enable debugging using `ruby/debug`, or surface the standard `odebug` output."
+        switch "--changed",
+               description: "Only runs tests on files that were changed from the master branch."
+        switch "--fail-fast",
+               description: "Exit early on the first failing test."
+        flag   "--only=",
+               description: "Run only `<test_script>_spec.rb`. Appending `:<line_number>` will start at a " \
+                            "specific line."
+        flag   "--profile=",
+               description: "Run the test suite serially to find the <n> slowest tests."
+        flag   "--seed=",
+               description: "Randomise tests with the specified <value> instead of a random seed."
+
+        conflicts "--changed", "--only"
+
+        named_args :none
       end
-    end.compact.select(&:exist?)
-  end
 
-  def tests
-    args = tests_args.parse
-
-    Homebrew.install_bundler_gems!
-
-    require "byebug" if args.byebug?
-
-    HOMEBREW_LIBRARY_PATH.cd do
-      # Cleanup any unwanted user configuration.
-      allowed_test_env = %w[
-        HOMEBREW_GITHUB_API_TOKEN
-        HOMEBREW_CACHE
-        HOMEBREW_LOGS
-        HOMEBREW_TEMP
-      ]
-      Homebrew::EnvConfig::ENVS.keys.map(&:to_s).each do |env|
-        next if allowed_test_env.include?(env)
-
-        ENV.delete(env)
+      sig { override.void }
+      def run
+        # Given we might be testing various commands, we probably want everything (except sorbet-static)
+        Homebrew.install_bundler_gems!(groups: Homebrew.valid_gem_groups - ["sorbet"])
+
+        HOMEBREW_LIBRARY_PATH.cd do
+          setup_environment!
+
+          parallel = true
+
+          only = args.only
+          files = if only
+            test_name, line = only.split(":", 2)
+
+            if line.nil?
+              Dir.glob("test/{#{test_name},#{test_name}/**/*}_spec.rb")
+            else
+              parallel = false
+              ["test/#{test_name}_spec.rb:#{line}"]
+            end
+          elsif args.changed?
+            changed_test_files
+          else
+            Dir.glob("test/**/*_spec.rb")
+          end
+
+          if files.blank?
+            raise UsageError, "The `--only` argument requires a valid file or folder name!" if only
+
+            if args.changed?
+              opoo "No tests are directly associated with the changed files!"
+              return
+            end
+          end
+
+          parallel = false if args.profile
+
+          parallel_rspec_log_name = "parallel_runtime_rspec"
+          parallel_rspec_log_name = "#{parallel_rspec_log_name}.generic" if args.generic?
+          parallel_rspec_log_name = "#{parallel_rspec_log_name}.online" if args.online?
+          parallel_rspec_log_name = "#{parallel_rspec_log_name}.log"
+
+          parallel_rspec_log_path = if ENV["CI"]
+            "tests/#{parallel_rspec_log_name}"
+          else
+            "#{HOMEBREW_CACHE}/#{parallel_rspec_log_name}"
+          end
+          ENV["PARALLEL_RSPEC_LOG_PATH"] = parallel_rspec_log_path
+
+          parallel_args = if ENV["CI"]
+            %W[
+              --combine-stderr
+              --serialize-stdout
+              --runtime-log #{parallel_rspec_log_path}
+            ]
+          else
+            %w[
+              --nice
+            ]
+          end
+
+          # Generate seed ourselves and output later to avoid multiple different
+          # seeds being output when running parallel tests.
+          seed = args.seed || rand(0xFFFF).to_i
+
+          bundle_args = ["-I", HOMEBREW_LIBRARY_PATH/"test"]
+          bundle_args += %W[
+            --seed #{seed}
+            --color
+            --require spec_helper
+          ]
+          bundle_args << "--fail-fast" if args.fail_fast?
+          bundle_args << "--profile" << args.profile if args.profile
+
+          # TODO: Refactor and move to extend/os
+          # rubocop:disable Homebrew/MoveToExtendOS
+          unless OS.mac?
+            bundle_args << "--tag" << "~needs_macos" << "--tag" << "~cask"
+            files = files.grep_v(%r{^test/(os/mac|cask)(/.*|_spec\.rb)$})
+          end
+
+          unless OS.linux?
+            bundle_args << "--tag" << "~needs_linux"
+            files = files.grep_v(%r{^test/os/linux(/.*|_spec\.rb)$})
+          end
+          # rubocop:enable Homebrew/MoveToExtendOS
+
+          bundle_args << "--tag" << "~needs_network" unless args.online?
+          unless ENV["CI"]
+            bundle_args << "--tag" << "~needs_ci" \
+                        << "--tag" << "~needs_svn"
+          end
+
+          puts "Randomized with seed #{seed}"
+
+          ENV["HOMEBREW_DEBUG"] = "1" if args.debug? # Used in spec_helper.rb to require the "debug" gem.
+
+          # Submit test flakiness information using BuildPulse
+          # BUILDPULSE used in spec_helper.rb
+          if use_buildpulse?
+            ENV["BUILDPULSE"] = "1"
+            ohai "Running tests with BuildPulse-friendly settings"
+          end
+
+          # Workaround for:
+          #
+          # ```
+          # ruby: no -r allowed while running setuid (SecurityError)
+          # ```
+          Process::UID.change_privilege(Process.euid) if Process.euid != Process.uid
+
+          if parallel
+            system "bundle", "exec", "parallel_rspec", *parallel_args, "--", *bundle_args, "--", *files
+          else
+            system "bundle", "exec", "rspec", *bundle_args, "--", *files
+          end
+          success = $CHILD_STATUS.success?
+
+          run_buildpulse if use_buildpulse?
+
+          return if success
+
+          Homebrew.failed = true
+        end
       end
 
-      ENV["HOMEBREW_NO_ANALYTICS_THIS_RUN"] = "1"
-      ENV["HOMEBREW_NO_COMPAT"] = "1" if args.no_compat?
-      ENV["HOMEBREW_TEST_GENERIC_OS"] = "1" if args.generic?
-      ENV["HOMEBREW_TEST_ONLINE"] = "1" if args.online?
-      ENV["HOMEBREW_SORBET_RUNTIME"] = "1"
+      private
 
-      ENV["USER"] ||= system_command!("id", args: ["-nu"]).stdout.chomp
+      sig { returns(T.nilable(T::Boolean)) }
+      def use_buildpulse?
+        return @use_buildpulse if defined?(@use_buildpulse)
 
-      # Avoid local configuration messing with tests, e.g. git being configured
-      # to use GPG to sign by default
-      ENV["HOME"] = "#{HOMEBREW_LIBRARY_PATH}/test"
-
-      # Print verbose output when requesting debug or verbose output.
-      ENV["HOMEBREW_VERBOSE_TESTS"] = "1" if args.debug? || args.verbose?
-
-      if args.coverage?
-        ENV["HOMEBREW_TESTS_COVERAGE"] = "1"
-        FileUtils.rm_f "test/coverage/.resultset.json"
-      end
-
-      # Override author/committer as global settings might be invalid and thus
-      # will cause silent failure during the setup of dummy Git repositories.
-      %w[AUTHOR COMMITTER].each do |role|
-        ENV["GIT_#{role}_NAME"] = "brew tests"
-        ENV["GIT_#{role}_EMAIL"] = "brew-tests@localhost"
-        ENV["GIT_#{role}_DATE"]  = "Sun Jan 22 19:59:13 2017 +0000"
+        @use_buildpulse = T.let(ENV["HOMEBREW_BUILDPULSE_ACCESS_KEY_ID"].present? &&
+                          ENV["HOMEBREW_BUILDPULSE_SECRET_ACCESS_KEY"].present? &&
+                          ENV["HOMEBREW_BUILDPULSE_ACCOUNT_ID"].present? &&
+                          ENV["HOMEBREW_BUILDPULSE_REPOSITORY_ID"].present?, T.nilable(T::Boolean))
       end
 
-      parallel = true
-
-      files = if args.only
-        test_name, line = args.only.split(":", 2)
+      sig { void }
+      def run_buildpulse
+        require "formula"
 
-        if line.nil?
-          Dir.glob("test/{#{test_name},#{test_name}/**/*}_spec.rb")
-        else
-          parallel = false
-          ["test/#{test_name}_spec.rb:#{line}"]
+        with_env(HOMEBREW_NO_AUTO_UPDATE: "1", HOMEBREW_NO_BOOTSNAP: "1") do
+          ensure_formula_installed!("buildpulse-test-reporter",
+                                    reason: "reporting test flakiness")
         end
-      elsif args.changed?
-        changed_test_files
-      else
-        Dir.glob("test/**/*_spec.rb")
-      end
 
-      if files.blank?
-        raise UsageError, "The --only= argument requires a valid file or folder name!" if args.only
+        ENV["BUILDPULSE_ACCESS_KEY_ID"] = ENV.fetch("HOMEBREW_BUILDPULSE_ACCESS_KEY_ID")
+        ENV["BUILDPULSE_SECRET_ACCESS_KEY"] = ENV.fetch("HOMEBREW_BUILDPULSE_SECRET_ACCESS_KEY")
 
-        if args.changed?
-          opoo "No tests are directly associated with the changed files!"
-          return
-        end
-      end
+        ohai "Sending test results to BuildPulse"
 
-      parallel_rspec_log_name = "parallel_runtime_rspec"
-      parallel_rspec_log_name = "#{parallel_rspec_log_name}.no_compat" if args.no_compat?
-      parallel_rspec_log_name = "#{parallel_rspec_log_name}.generic" if args.generic?
-      parallel_rspec_log_name = "#{parallel_rspec_log_name}.online" if args.online?
-      parallel_rspec_log_name = "#{parallel_rspec_log_name}.log"
+        system_command Formula["buildpulse-test-reporter"].opt_bin/"buildpulse-test-reporter",
+                       args: [
+                         "submit", "#{HOMEBREW_LIBRARY_PATH}/test/junit",
+                         "--account-id", ENV.fetch("HOMEBREW_BUILDPULSE_ACCOUNT_ID"),
+                         "--repository-id", ENV.fetch("HOMEBREW_BUILDPULSE_REPOSITORY_ID")
+                       ]
+      end
 
-      parallel_rspec_log_path = if ENV["CI"]
-        "tests/#{parallel_rspec_log_name}"
-      else
-        "#{HOMEBREW_CACHE}/#{parallel_rspec_log_name}"
+      sig { returns(T::Array[String]) }
+      def changed_test_files
+        changed_files = Utils.popen_read("git", "diff", "--name-only", "master")
+
+        raise UsageError, "No files have been changed from the master branch!" if changed_files.blank?
+
+        filestub_regex = %r{Library/Homebrew/([\w/-]+).rb}
+        changed_files.scan(filestub_regex).map(&:last).filter_map do |filestub|
+          if filestub.start_with?("test/")
+            # Only run tests on *_spec.rb files in test/ folder
+            filestub.end_with?("_spec") ? Pathname("#{filestub}.rb") : nil
+          else
+            # For all other changed .rb files guess the associated test file name
+            Pathname("test/#{filestub}_spec.rb")
+          end
+        end.select(&:exist?)
       end
-      ENV["PARALLEL_RSPEC_LOG_PATH"] = parallel_rspec_log_path
 
-      parallel_args = if ENV["CI"]
-        %W[
-          --combine-stderr
-          --serialize-stdout
-          --runtime-log #{parallel_rspec_log_path}
+      sig { returns(T::Array[String]) }
+      def setup_environment!
+        # Cleanup any unwanted user configuration.
+        allowed_test_env = %w[
+          HOMEBREW_GITHUB_API_TOKEN
+          HOMEBREW_CACHE
+          HOMEBREW_LOGS
+          HOMEBREW_TEMP
         ]
-      else
-        %w[
-          --nice
-        ]
-      end
+        allowed_test_env << "HOMEBREW_USE_RUBY_FROM_PATH" if Homebrew::EnvConfig.developer?
+        Homebrew::EnvConfig::ENVS.keys.map(&:to_s).each do |env|
+          next if allowed_test_env.include?(env)
 
-      # Generate seed ourselves and output later to avoid multiple different
-      # seeds being output when running parallel tests.
-      seed = args.seed || rand(0xFFFF).to_i
+          ENV.delete(env)
+        end
 
-      bundle_args = ["-I", HOMEBREW_LIBRARY_PATH/"test"]
-      bundle_args += %W[
-        --seed #{seed}
-        --color
-        --require spec_helper
-      ]
+        # Codespaces HOMEBREW_PREFIX and /tmp are mounted 755 which makes Ruby warn constantly.
+        if (ENV["HOMEBREW_CODESPACES"] == "true") && (HOMEBREW_TEMP.to_s == "/tmp")
+          # Need to keep this fairly short to avoid socket paths being too long in tests.
+          homebrew_prefix_tmp = "/home/linuxbrew/tmp"
+          ENV["HOMEBREW_TEMP"] = homebrew_prefix_tmp
+          FileUtils.mkdir_p homebrew_prefix_tmp
+          system "chmod", "-R", "g-w,o-w", HOMEBREW_PREFIX, homebrew_prefix_tmp
+        end
 
-      unless OS.mac?
-        bundle_args << "--tag" << "~needs_macos" << "--tag" << "~cask"
-        files = files.grep_v(%r{^test/(os/mac|cask)(/.*|_spec\.rb)$})
-      end
+        ENV["HOMEBREW_TESTS"] = "1"
+        ENV["HOMEBREW_NO_AUTO_UPDATE"] = "1"
+        ENV["HOMEBREW_NO_ANALYTICS_THIS_RUN"] = "1"
+        ENV["HOMEBREW_TEST_GENERIC_OS"] = "1" if args.generic?
+        ENV["HOMEBREW_TEST_ONLINE"] = "1" if args.online?
+        ENV["HOMEBREW_SORBET_RUNTIME"] = "1"
 
-      unless OS.linux?
-        bundle_args << "--tag" << "~needs_linux"
-        files = files.grep_v(%r{^test/os/linux(/.*|_spec\.rb)$})
-      end
+        # TODO: remove this and fix tests when possible.
+        ENV["HOMEBREW_NO_INSTALL_FROM_API"] = "1"
+        ENV.delete("HOMEBREW_INTERNAL_JSON_V3")
 
-      puts "Randomized with seed #{seed}"
+        ENV["USER"] ||= system_command!("id", args: ["-nu"]).stdout.chomp
 
-      # Let tests find `bundle` in the actual location.
-      ENV["HOMEBREW_TESTS_GEM_USER_DIR"] = gem_user_dir
+        # Avoid local configuration messing with tests, e.g. git being configured
+        # to use GPG to sign by default
+        ENV["HOME"] = "#{HOMEBREW_LIBRARY_PATH}/test"
 
-      # Let `bundle` in PATH find its gem.
-      ENV["GEM_PATH"] = "#{ENV.fetch("GEM_PATH")}:#{gem_user_dir}"
+        # Print verbose output when requesting debug or verbose output.
+        ENV["HOMEBREW_VERBOSE_TESTS"] = "1" if args.debug? || args.verbose?
 
-      # Submit test flakiness information using BuildPulse
-      # BUILDPULSE used in spec_helper.rb
-      if use_buildpulse?
-        ENV["BUILDPULSE"] = "1"
-        ohai "Running tests with BuildPulse-friendly settings"
-      end
+        if args.coverage?
+          ENV["HOMEBREW_TESTS_COVERAGE"] = "1"
+          FileUtils.rm_f "test/coverage/.resultset.json"
+        end
 
-      if parallel
-        system "bundle", "exec", "parallel_rspec", *parallel_args, "--", *bundle_args, "--", *files
-      else
-        system "bundle", "exec", "rspec", *bundle_args, "--", *files
+        # Override author/committer as global settings might be invalid and thus
+        # will cause silent failure during the setup of dummy Git repositories.
+        %w[AUTHOR COMMITTER].each do |role|
+          ENV["GIT_#{role}_NAME"] = "brew tests"
+          ENV["GIT_#{role}_EMAIL"] = "brew-tests@localhost"
+          ENV["GIT_#{role}_DATE"]  = "Sun Jan 22 19:59:13 2017 +0000"
+        end
       end
-
-      run_buildpulse if use_buildpulse?
-
-      return if $CHILD_STATUS.success?
-
-      Homebrew.failed = true
     end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/typecheck.rb b/Library/Homebrew/dev-cmd/typecheck.rb
index b9f00a5446277..3f16dae3179a9 100644
--- a/Library/Homebrew/dev-cmd/typecheck.rb
+++ b/Library/Homebrew/dev-cmd/typecheck.rb
@@ -1,133 +1,120 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
+require "fileutils"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def typecheck_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Check for typechecking errors using Sorbet.
-      EOS
-      switch "--fix",
-             description: "Automatically fix type errors."
-      switch "-q", "--quiet",
-             description: "Silence all non-critical errors."
-      switch "--update",
-             description: "Update RBI files."
-      switch "--all",
-             depends_on:  "--update",
-             description: "Regenerate all RBI files rather than just updated gems."
-      switch "--suggest-typed",
-             depends_on:  "--update",
-             description: "Try upgrading `typed` sigils."
-      switch "--fail-if-not-changed",
-             description: "Return a failing status code if all gems are up to date " \
-                          "and gem definitions do not need a tapioca update."
-      flag   "--dir=",
-             description: "Typecheck all files in a specific directory."
-      flag   "--file=",
-             description: "Typecheck a single file."
-      flag   "--ignore=",
-             description: "Ignores input files that contain the given string " \
-                          "in their paths (relative to the input path passed to Sorbet)."
-
-      conflicts "--dir", "--file"
-
-      named_args :none
-    end
-  end
-
-  sig { void }
-  def typecheck
-    args = typecheck_args.parse
-
-    Homebrew.install_bundler_gems!(groups: ["sorbet"])
-
-    HOMEBREW_LIBRARY_PATH.cd do
-      if args.update?
-        excluded_gems = [
-          "did_you_mean", # RBI file is already provided by Sorbet
-          "webrobots", # RBI file is bugged
-          "sorbet-static-and-runtime", # Unnecessary RBI - remove this entry with Tapioca 0.8
-        ]
-        typed_overrides = [
-          "msgpack:false", # Investigate removing this with Tapioca 0.8
-        ]
-        tapioca_args = ["--exclude", *excluded_gems, "--typed-overrides", *typed_overrides]
-        tapioca_args << "--all" if args.all?
-
-        ohai "Updating Tapioca RBI files..."
-        safe_system "bundle", "exec", "tapioca", "gem", *tapioca_args
-        safe_system "bundle", "exec", "parlour"
-        safe_system "bundle", "exec", "srb", "rbi", "hidden-definitions"
-        safe_system "bundle", "exec", "srb", "rbi", "todo"
-
-        if args.suggest_typed?
-          result = system_command(
-            "bundle",
-            args:         ["exec", "--", "srb", "tc", "--suggest-typed", "--typed=strict",
-                           "--isolate-error-code=7022"],
-            print_stderr: false,
-          )
-
-          allowed_changes = {
-            "false" => ["true", "strict"],
-            "true"  => ["strict"],
-          }
-
-          # Workaround for `srb tc rbi suggest-typed`, which currently fails get to a converging state.
-          result.stderr.scan(/^(.*\.rb):\d+:\s+You could add `#\s*typed:\s*(.*?)`/).each do |path, new_level|
-            path = Pathname(path)
-
-            next unless path.file?
-
-            contents = path.read
-
-            next unless (match = contents.match(/\A\s*#\s*typed:\s*([^\s]+)/))
-
-            existing_level = match[1]
+  module DevCmd
+    class Typecheck < AbstractCommand
+      include FileUtils
+
+      cmd_args do
+        description <<~EOS
+          Check for typechecking errors using Sorbet.
+        EOS
+        switch "--fix",
+               description: "Automatically fix type errors."
+        switch "-q", "--quiet",
+               description: "Silence all non-critical errors."
+        switch "--update",
+               description: "Update RBI files."
+        switch "--update-all",
+               description: "Update all RBI files rather than just updated gems."
+        switch "--suggest-typed",
+               depends_on:  "--update",
+               description: "Try upgrading `typed` sigils."
+        switch "--lsp",
+               description: "Start the Sorbet LSP server."
+        flag   "--dir=",
+               description: "Typecheck all files in a specific directory."
+        flag   "--file=",
+               description: "Typecheck a single file."
+        flag   "--ignore=",
+               description: "Ignores input files that contain the given string " \
+                            "in their paths (relative to the input path passed to Sorbet)."
+
+        conflicts "--dir", "--file"
+        conflicts "--lsp", "--update"
+        conflicts "--lsp", "--update-all"
+        conflicts "--lsp", "--fix"
+
+        named_args :tap
+      end
 
-            next unless allowed_changes.fetch(existing_level, []).include?(new_level)
+      sig { override.void }
+      def run
+        if (args.dir.present? || args.file.present?) && args.named.present?
+          raise UsageError, "Cannot use `--dir` or `--file` when specifying a tap."
+        elsif args.fix? && args.named.present?
+          raise UsageError, "Cannot use `--fix` when specifying a tap."
+        end
 
-            puts "#{path}: #{existing_level} -> #{new_level}"
-            path.atomic_write contents.sub(/\A(\s*#\s*typed:\s*)(?:[^\s]+)/, "\\1#{new_level}")
+        update = args.update? || args.update_all?
+        groups = update ? Homebrew.valid_gem_groups : ["typecheck"]
+        Homebrew.install_bundler_gems!(groups:)
+
+        # Sorbet doesn't use bash privileged mode so we align EUID and UID here.
+        Process::UID.change_privilege(Process.euid) if Process.euid != Process.uid
+
+        HOMEBREW_LIBRARY_PATH.cd do
+          if update
+            workers = args.debug? ? ["--workers=1"] : []
+            safe_system "bundle", "exec", "tapioca", "dsl", *workers
+            # Prefer adding args here: Library/Homebrew/sorbet/tapioca/config.yml
+            tapioca_args = args.update_all? ? ["--all"] : []
+
+            ohai "Updating Tapioca RBI files..."
+            safe_system "bundle", "exec", "tapioca", "gem", *tapioca_args
+
+            if args.suggest_typed?
+              ohai "Checking if we can bump Sorbet `typed` sigils..."
+              # --sorbet needed because of https://github.com/Shopify/spoom/issues/488
+              system "bundle", "exec", "spoom", "srb", "bump", "--from", "false", "--to", "true",
+                     "--sorbet", "#{Gem.bin_path("sorbet", "srb")} tc"
+              system "bundle", "exec", "spoom", "srb", "bump", "--from", "true", "--to", "strict",
+                     "--sorbet", "#{Gem.bin_path("sorbet", "srb")} tc"
+            end
+
+            return
           end
-        end
 
-        Homebrew.failed = system("git", "diff", "--stat", "--exit-code") if args.fail_if_not_changed?
+          srb_exec = %w[bundle exec srb tc]
 
-        return
-      end
+          srb_exec << "--quiet" if args.quiet?
 
-      srb_exec = %w[bundle exec srb tc]
+          if args.fix?
+            # Auto-correcting method names is almost always wrong.
+            srb_exec << "--suppress-error-code" << "7003"
 
-      srb_exec << "--quiet" if args.quiet?
+            srb_exec << "--autocorrect"
+          end
 
-      if args.fix?
-        # Auto-correcting method names is almost always wrong.
-        srb_exec << "--suppress-error-code" << "7003"
+          if args.lsp?
+            srb_exec << "--lsp"
+            if (watchman = which("watchman", ORIGINAL_PATHS))
+              srb_exec << "--watchman-path" << watchman
+            else
+              srb_exec << "--disable-watchman"
+            end
+          end
 
-        srb_exec << "--autocorrect"
-      end
+          srb_exec += ["--ignore", args.ignore] if args.ignore.present?
+          if args.file.present? || args.dir.present? || (tap_dir = args.named.to_paths(only: :tap).first).present?
+            cd("sorbet") do
+              srb_exec += ["--file", "../#{args.file}"] if args.file
+              srb_exec += ["--dir", "../#{args.dir}"] if args.dir
+              srb_exec += ["--dir", tap_dir.to_s] if tap_dir
+            end
+          end
+          success = system(*srb_exec)
+          return if success
 
-      srb_exec += ["--ignore", args.ignore] if args.ignore.present?
-      if args.file.present? || args.dir.present?
-        cd("sorbet")
-        srb_exec += ["--file", "../#{args.file}"] if args.file
-        srb_exec += ["--dir", "../#{args.dir}"] if args.dir
+          $stderr.puts "Check #{Formatter.url("https://docs.brew.sh/Typechecking")} for " \
+                       "more information on how to resolve these errors."
+          Homebrew.failed = true
+        end
       end
-      success = system(*srb_exec)
-      return if success
-
-      $stderr.puts "Check #{Formatter.url("https://docs.brew.sh/Typechecking")} for " \
-                   "more information on how to resolve these errors."
-      Homebrew.failed = true
     end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/unbottled.rb b/Library/Homebrew/dev-cmd/unbottled.rb
index 1880498277e93..0cb4cb1df7ba3 100644
--- a/Library/Homebrew/dev-cmd/unbottled.rb
+++ b/Library/Homebrew/dev-cmd/unbottled.rb
@@ -1,226 +1,337 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 require "formula"
 require "api"
+require "os/mac/xcode"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def unbottled_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Show the unbottled dependents of formulae.
-      EOS
-      flag   "--tag=",
-             description: "Use the specified bottle tag (e.g. `big_sur`) instead of the current OS."
-      switch "--dependents",
-             description: "Skip getting analytics data and sort by number of dependents instead."
-      switch "--all", "--total",
-             description: "Print the number of unbottled and total formulae."
-
-      conflicts "--dependents", "--all"
-      conflicts "--installed", "--all"
-
-      named_args :formula
-    end
-  end
-
-  sig { void }
-  def unbottled
-    args = unbottled_args.parse
+  module DevCmd
+    class Unbottled < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Show the unbottled dependents of formulae.
+        EOS
+        flag   "--tag=",
+               description: "Use the specified bottle tag (e.g. `big_sur`) instead of the current OS."
+        switch "--dependents",
+               description: "Skip getting analytics data and sort by number of dependents instead."
+        switch "--total",
+               description: "Print the number of unbottled and total formulae."
+        switch "--lost",
+               description: "Print the `homebrew/core` commits where bottles were lost in the last week."
+        switch "--eval-all",
+               description: "Evaluate all available formulae and casks, whether installed or not, to check them. " \
+                            "Implied if `HOMEBREW_EVAL_ALL` is set."
+
+        conflicts "--dependents", "--total", "--lost"
+
+        named_args :formula
+      end
 
-    Formulary.enable_factory_cache!
+      sig { override.void }
+      def run
+        Formulary.enable_factory_cache!
 
-    @bottle_tag = if (tag = args.tag)
-      Utils::Bottles::Tag.from_symbol(tag.to_sym)
-    else
-      Utils::Bottles.tag
-    end
+        @bottle_tag = T.let(
+          if (tag = args.tag)
+            Utils::Bottles::Tag.from_symbol(tag.to_sym)
+          else
+            Utils::Bottles.tag
+          end,
+          T.nilable(Utils::Bottles::Tag),
+        )
+        return unless @bottle_tag
+
+        if args.lost?
+          if args.named.present?
+            raise UsageError, "`brew unbottled --lost` cannot be used with formula arguments!"
+          elsif !CoreTap.instance.installed?
+            raise UsageError, "`brew unbottled --lost` requires `homebrew/core` to be tapped locally!"
+          else
+            output_lost_bottles
+            return
+          end
+        end
 
-    # TODO: 3.6.0: odeprecate args.total?
+        os = @bottle_tag.system
+        arch = if Hardware::CPU::INTEL_ARCHS.include?(@bottle_tag.arch)
+          :intel
+        elsif Hardware::CPU::ARM_ARCHS.include?(@bottle_tag.arch)
+          :arm
+        else
+          raise "Unknown arch #{@bottle_tag.arch}."
+        end
 
-    if args.named.blank?
-      ohai "Getting formulae..."
-    elsif args.all?
-      raise UsageError, "cannot specify `<formula>` and `--all`/`--total`."
-    end
+        Homebrew::SimulateSystem.with(os:, arch:) do
+          all = args.eval_all?
+          if args.total?
+            if !all && !Homebrew::EnvConfig.eval_all?
+              raise UsageError, "`brew unbottled --total` needs `--eval-all` passed or `HOMEBREW_EVAL_ALL` set!"
+            end
 
-    formulae, all_formulae, formula_installs =
-      formulae_all_installs_from_args(args)
-    deps_hash, uses_hash = deps_uses_from_formulae(all_formulae)
+            all = true
+          end
 
-    if args.dependents?
-      formula_dependents = {}
-      formulae = formulae.sort_by do |f|
-        dependents = uses_hash[f.name]&.length || 0
-        formula_dependents[f.name] ||= dependents
-      end.reverse
-    end
+          if args.named.blank?
+            ohai "Getting formulae..."
+          elsif all
+            raise UsageError, "Cannot specify formulae when using `--eval-all`/`--total`."
+          end
 
-    if args.all?
-      output_total(formulae)
-      return
-    end
+          formulae, all_formulae, formula_installs = formulae_all_installs_from_args(all)
+          deps_hash, uses_hash = deps_uses_from_formulae(all_formulae)
+
+          if args.dependents?
+            formula_dependents = {}
+            formulae = formulae.sort_by do |f|
+              dependents = uses_hash[f.name]&.length || 0
+              formula_dependents[f.name] ||= dependents
+            end.reverse
+          elsif all
+            output_total(formulae)
+            return
+          end
 
-    noun, hash = if args.named.present?
-      [nil, {}]
-    elsif args.dependents?
-      ["dependents", formula_dependents]
-    else
-      ["installs", formula_installs]
-    end
+          noun, hash = if args.named.present?
+            [nil, {}]
+          elsif args.dependents?
+            ["dependents", formula_dependents]
+          else
+            ["installs", formula_installs]
+          end
 
-    output_unbottled(formulae, deps_hash, noun, hash, args.named.present?)
-  end
+          return if hash.nil?
 
-  def formulae_all_installs_from_args(args)
-    if args.named.present?
-      formulae = all_formulae = args.named.to_formulae
-    elsif args.all?
-      formulae = all_formulae = Formula.all
-    elsif args.dependents?
-      # TODO: 3.6.0: odeprecate not specifying args.all? for args.dependents?
-      formulae = all_formulae = Formula.all
-
-      @sort = " (sorted by number of dependents)"
-    else
-      formula_installs = {}
-
-      ohai "Getting analytics data..."
-      analytics = Homebrew::API::Analytics.fetch "install", 90
-
-      if analytics.blank?
-        raise UsageError,
-              "default sort by analytics data requires " \
-              "`HOMEBREW_NO_GITHUB_API` and `HOMEBREW_NO_ANALYTICS` to be unset"
+          output_unbottled(formulae, deps_hash, noun, hash, args.named.present?)
+        end
       end
 
-      formulae = analytics["items"].map do |i|
-        f = i["formula"].split.first
-        next if f.include?("/")
-        next if formula_installs[f].present?
+      private
+
+      sig {
+        params(all: T::Boolean).returns([T::Array[Formula], T::Array[Formula], T.nilable(T::Hash[Symbol, Integer])])
+      }
+      def formulae_all_installs_from_args(all)
+        if args.named.present?
+          formulae = all_formulae = args.named.to_formulae
+        elsif args.dependents?
+          if !args.eval_all? && !Homebrew::EnvConfig.eval_all?
+            raise UsageError,
+                  "`brew unbottled --dependents` needs `--eval-all` passed or `HOMEBREW_EVAL_ALL` set!"
+          end
+
+          formulae = all_formulae = Formula.all(eval_all: args.eval_all?)
 
-        formula_installs[f] = i["count"]
-        begin
-          Formula[f]
-        rescue FormulaUnavailableError
-          nil
-        end
-      end.compact
-      @sort = " (sorted by installs in the last 90 days; top 10,000 only)"
+          @sort = T.let(" (sorted by number of dependents)", T.nilable(String))
+        elsif all
+          formulae = all_formulae = Formula.all(eval_all: args.eval_all?)
+        else
+          formula_installs = {}
 
-      all_formulae = Formula.all
-    end
+          ohai "Getting analytics data..."
+          analytics = Homebrew::API::Analytics.fetch "install", 90
 
-    [formulae, all_formulae, formula_installs]
-  end
+          if analytics.blank?
+            raise UsageError,
+                  "default sort by analytics data requires " \
+                  "`HOMEBREW_NO_GITHUB_API` and `HOMEBREW_NO_ANALYTICS` to be unset"
+          end
 
-  def deps_uses_from_formulae(all_formulae)
-    ohai "Populating dependency tree..."
+          formulae = analytics["items"].filter_map do |i|
+            f = i["formula"].split.first
+            next if f.include?("/")
+            next if formula_installs[f].present?
+
+            formula_installs[f] = i["count"]
+            begin
+              Formula[f]
+            rescue FormulaUnavailableError
+              nil
+            end
+          end
+          @sort = T.let(" (sorted by installs in the last 90 days; top 10,000 only)", T.nilable(String))
 
-    deps_hash = {}
-    uses_hash = {}
+          all_formulae = Formula.all(eval_all: args.eval_all?)
+        end
 
-    all_formulae.each do |f|
-      deps = f.recursive_dependencies do |_, dep|
-        Dependency.prune if dep.optional?
-      end.map(&:to_formula)
-      deps_hash[f.name] = deps
+        # Remove deprecated and disabled formulae as we do not care if they are unbottled
+        formulae = Array(formulae).reject { |f| f.deprecated? || f.disabled? } if formulae.present?
+        all_formulae = Array(all_formulae).reject { |f| f.deprecated? || f.disabled? } if all_formulae.present?
 
-      deps.each do |dep|
-        uses_hash[dep.name] ||= []
-        uses_hash[dep.name] << f
+        [T.let(formulae, T::Array[Formula]), T.let(all_formulae, T::Array[Formula]),
+         T.let(formula_installs, T.nilable(T::Hash[Symbol, Integer]))]
       end
-    end
 
-    [deps_hash, uses_hash]
-  end
+      sig {
+        params(all_formulae: T::Array[Formula]).returns([T::Hash[String, T.untyped], T::Hash[String, T.untyped]])
+      }
+      def deps_uses_from_formulae(all_formulae)
+        ohai "Populating dependency tree..."
 
-  def output_total(formulae)
-    ohai "Unbottled :#{@bottle_tag} formulae"
-    unbottled_formulae = 0
+        deps_hash = {}
+        uses_hash = {}
 
-    formulae.each do |f|
-      next if f.bottle_specification.tag?(@bottle_tag)
+        all_formulae.each do |f|
+          deps = Dependency.expand(f, cache_key: "unbottled") do |_, dep|
+            Dependency.prune if dep.optional?
+          end.map(&:to_formula)
+          deps_hash[f.name] = deps
 
-      unbottled_formulae += 1
-    end
+          deps.each do |dep|
+            uses_hash[dep.name] ||= []
+            uses_hash[dep.name] << f
+          end
+        end
 
-    puts "#{unbottled_formulae}/#{formulae.length} remaining."
-  end
+        [deps_hash, uses_hash]
+      end
 
-  def output_unbottled(formulae, deps_hash, noun, hash, any_named_args)
-    ohai ":#{@bottle_tag} bottle status#{@sort}"
-    any_found = T.let(false, T::Boolean)
+      sig { params(formulae: T::Array[Formula]).void }
+      def output_total(formulae)
+        return unless @bottle_tag
 
-    formulae.each do |f|
-      name = f.name.downcase
+        ohai "Unbottled :#{@bottle_tag} formulae"
+        unbottled_formulae = formulae.count do |f|
+          !f.bottle_specification.tag?(@bottle_tag, no_older_versions: true)
+        end
 
-      if f.disabled?
-        puts "#{Tty.bold}#{Tty.green}#{name}#{Tty.reset}: formula disabled" if any_named_args
-        next
+        puts "#{unbottled_formulae}/#{formulae.length} remaining."
       end
 
-      requirements = f.recursive_requirements
-      if @bottle_tag.linux?
-        if requirements.any? { |r| r.is_a?(MacOSRequirement) && !r.version }
-          puts "#{Tty.bold}#{Tty.red}#{name}#{Tty.reset}: requires macOS" if any_named_args
-          next
-        end
-      elsif requirements.any?(LinuxRequirement)
-        puts "#{Tty.bold}#{Tty.red}#{name}#{Tty.reset}: requires Linux" if any_named_args
-        next
-      else
-        macos_version = @bottle_tag.to_macos_version
-        macos_satisfied = requirements.all? do |r|
-          case r
-          when MacOSRequirement
-            next true unless r.version_specified?
-
-            macos_version.public_send(r.comparator, r.version)
-          when XcodeRequirement
-            next true unless r.version
-
-            Version.new(MacOS::Xcode.latest_version(macos: macos_version)) >= r.version
-          when ArchRequirement
-            r.arch == @bottle_tag.arch
+      sig {
+        params(formulae: T::Array[Formula], deps_hash: T::Hash[T.any(Symbol, String), T.untyped],
+               noun: T.nilable(String), hash: T::Hash[T.any(Symbol, String), T.untyped],
+               any_named_args: T::Boolean).void
+      }
+      def output_unbottled(formulae, deps_hash, noun, hash, any_named_args)
+        return unless @bottle_tag
+
+        ohai ":#{@bottle_tag} bottle status#{@sort}"
+        any_found = T.let(false, T::Boolean)
+
+        formulae.each do |f|
+          name = f.name.downcase
+
+          if f.disabled?
+            puts "#{Tty.bold}#{Tty.green}#{name}#{Tty.reset}: formula disabled" if any_named_args
+            next
+          end
+
+          requirements = f.recursive_requirements
+          if @bottle_tag.linux?
+            if requirements.any? { |r| r.is_a?(MacOSRequirement) && !r.version }
+              puts "#{Tty.bold}#{Tty.red}#{name}#{Tty.reset}: requires macOS" if any_named_args
+              next
+            end
+          elsif requirements.any?(LinuxRequirement)
+            puts "#{Tty.bold}#{Tty.red}#{name}#{Tty.reset}: requires Linux" if any_named_args
+            next
           else
-            true
+            macos_version = @bottle_tag.to_macos_version
+            macos_satisfied = requirements.all? do |r|
+              case r
+              when MacOSRequirement
+                next true unless r.version_specified?
+
+                macos_version.compare(r.comparator, r.version)
+              when XcodeRequirement
+                next true unless r.version
+
+                Version.new(MacOS::Xcode.latest_version(macos: macos_version)) >= r.version
+              when ArchRequirement
+                r.arch == @bottle_tag.arch
+              else
+                true
+              end
+            end
+            unless macos_satisfied
+              puts "#{Tty.bold}#{Tty.red}#{name}#{Tty.reset}: doesn't support this macOS" if any_named_args
+              next
+            end
           end
+
+          if f.bottle_specification.tag?(@bottle_tag, no_older_versions: true)
+            puts "#{Tty.bold}#{Tty.green}#{name}#{Tty.reset}: already bottled" if any_named_args
+            next
+          end
+
+          deps = Array(deps_hash[f.name]).reject do |dep|
+            dep.bottle_specification.tag?(@bottle_tag, no_older_versions: true)
+          end
+
+          if deps.blank?
+            count = " (#{hash[f.name]} #{noun})" if noun
+            puts "#{Tty.bold}#{Tty.green}#{name}#{Tty.reset}#{count}: ready to bottle"
+            next
+          end
+
+          any_found ||= true
+          count = " (#{hash[f.name]} #{noun})" if noun
+          puts "#{Tty.bold}#{Tty.yellow}#{name}#{Tty.reset}#{count}: unbottled deps: #{deps.join(" ")}"
         end
-        unless macos_satisfied
-          puts "#{Tty.bold}#{Tty.red}#{name}#{Tty.reset}: doesn't support this macOS" if any_named_args
-          next
-        end
-      end
+        return if any_found
+        return if any_named_args
 
-      if f.bottle_specification.tag?(@bottle_tag, no_older_versions: true)
-        puts "#{Tty.bold}#{Tty.green}#{name}#{Tty.reset}: already bottled" if any_named_args
-        next
+        puts "No unbottled dependencies found!"
       end
 
-      deps = Array(deps_hash[f.name]).reject do |dep|
-        dep.bottle_specification.tag?(@bottle_tag, no_older_versions: true)
-      end
+      sig { void }
+      def output_lost_bottles
+        ohai ":#{@bottle_tag} lost bottles"
+
+        bottle_tag_regex_fragment = " +sha256.* #{@bottle_tag}: "
+
+        # $ git log --patch --no-ext-diff -G'^ +sha256.* sonoma:' --since=@{'1 week ago'}
+        git_log = %w[git log --patch --no-ext-diff]
+        git_log << "-G^#{bottle_tag_regex_fragment}"
+        git_log << "--since=@{'1 week ago'}"
+
+        bottle_tag_sha_regex = /^[+-]#{bottle_tag_regex_fragment}/
+
+        processed_formulae = Set.new
+        commit = T.let(nil, T.nilable(String))
+        formula = T.let(nil, T.nilable(String))
+        lost_bottles = 0
+
+        CoreTap.instance.path.cd do
+          Utils.safe_popen_read(*git_log) do |io|
+            io.each_line do |line|
+              case line
+              when /^commit [0-9a-f]{40}$/
+                # Example match: `commit 7289b409b96a752540befef1a56b8a818baf1db7`
+                if commit && formula && lost_bottles.positive? && processed_formulae.exclude?(formula)
+                  puts "#{commit}: bottle lost for #{formula}"
+                end
+                processed_formulae << formula
+                commit = line.split.last
+                formula = nil
+              when %r{^diff --git a/Formula/}
+                # Example match: `diff --git a/Formula/a/aws-cdk.rb b/Formula/a/aws-cdk.rb`
+                formula = line.split("/").last.chomp(".rb\n")
+                formula = CoreTap.instance.formula_renames.fetch(formula, formula)
+                lost_bottles = 0
+              when bottle_tag_sha_regex
+                # Example match: `-    sha256 cellar: :any_skip_relocation, sonoma: "f0a4..."`
+                next if processed_formulae.include?(formula)
+
+                case line.chr
+                when "+" then lost_bottles -= 1
+                when "-" then lost_bottles += 1
+                end
+              when /^[+] +sha256.* all: /
+                # Example match: `+    sha256 cellar: :any_skip_relocation, all: "9e35..."`
+                lost_bottles -= 1
+              end
+            end
+          end
+        end
 
-      if deps.blank?
-        count = " (#{hash[f.name]} #{noun})" if noun
-        puts "#{Tty.bold}#{Tty.green}#{name}#{Tty.reset}#{count}: ready to bottle"
-        next
-      end
+        return if !commit || !formula || !lost_bottles.positive? || processed_formulae.include?(formula)
 
-      any_found ||= true
-      count = " (#{hash[f.name]} #{noun})" if noun
-      puts "#{Tty.bold}#{Tty.yellow}#{name}#{Tty.reset}#{count}: unbottled deps: #{deps.join(" ")}"
+        puts "#{commit}: bottle lost for #{formula}"
+      end
     end
-    return if any_found
-    return if any_named_args
-
-    puts "No unbottled dependencies found!"
   end
 end
diff --git a/Library/Homebrew/dev-cmd/unpack.rb b/Library/Homebrew/dev-cmd/unpack.rb
index f92faf1325bcf..8ecc1c1f2eac3 100644
--- a/Library/Homebrew/dev-cmd/unpack.rb
+++ b/Library/Homebrew/dev-cmd/unpack.rb
@@ -1,78 +1,78 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "abstract_command"
+require "fileutils"
 require "stringio"
 require "formula"
-require "cli/parser"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def unpack_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Unpack the source files for <formula> into subdirectories of the current
-        working directory.
-      EOS
-      flag   "--destdir=",
-             description: "Create subdirectories in the directory named by <path> instead."
-      switch "--patch",
-             description: "Patches for <formula> will be applied to the unpacked source."
-      switch "-g", "--git",
-             description: "Initialise a Git repository in the unpacked source. This is useful for creating " \
-                          "patches for the software."
-      switch "-f", "--force",
-             description: "Overwrite the destination directory if it already exists."
-
-      conflicts "--git", "--patch"
+  module DevCmd
+    class Unpack < AbstractCommand
+      include FileUtils
+
+      cmd_args do
+        description <<~EOS
+          Unpack the source files for <formula> into subdirectories of the current
+          working directory.
+        EOS
+        flag   "--destdir=",
+               description: "Create subdirectories in the directory named by <path> instead."
+        switch "--patch",
+               description: "Patches for <formula> will be applied to the unpacked source."
+        switch "-g", "--git",
+               description: "Initialise a Git repository in the unpacked source. This is useful for creating " \
+                            "patches for the software."
+        switch "-f", "--force",
+               description: "Overwrite the destination directory if it already exists."
+
+        conflicts "--git", "--patch"
+
+        named_args :formula, min: 1
+      end
 
-      named_args :formula, min: 1
-    end
-  end
+      sig { override.void }
+      def run
+        formulae = args.named.to_formulae
 
-  def unpack
-    args = unpack_args.parse
+        if (dir = args.destdir)
+          unpack_dir = Pathname.new(dir).expand_path
+          unpack_dir.mkpath
+        else
+          unpack_dir = Pathname.pwd
+        end
 
-    formulae = args.named.to_formulae
+        odie "Cannot write to #{unpack_dir}" unless unpack_dir.writable?
 
-    if (dir = args.destdir)
-      unpack_dir = Pathname.new(dir).expand_path
-      unpack_dir.mkpath
-    else
-      unpack_dir = Pathname.pwd
-    end
+        formulae.each do |f|
+          stage_dir = unpack_dir/"#{f.name}-#{f.version}"
 
-    odie "Cannot write to #{unpack_dir}" unless unpack_dir.writable_real?
+          if stage_dir.exist?
+            odie "Destination #{stage_dir} already exists!" unless args.force?
 
-    formulae.each do |f|
-      stage_dir = unpack_dir/"#{f.name}-#{f.version}"
+            rm_rf stage_dir
+          end
 
-      if stage_dir.exist?
-        odie "Destination #{stage_dir} already exists!" unless args.force?
+          oh1 "Unpacking #{Formatter.identifier(f.full_name)} to: #{stage_dir}"
 
-        rm_rf stage_dir
-      end
+          # show messages about tar
+          with_env VERBOSE: "1" do
+            f.brew do
+              f.patch if args.patch?
+              cp_r getwd, stage_dir, preserve: true
+            end
+          end
 
-      oh1 "Unpacking #{Formatter.identifier(f.full_name)} to: #{stage_dir}"
+          next unless args.git?
 
-      # show messages about tar
-      with_env VERBOSE: "1" do
-        f.brew do
-          f.patch if args.patch?
-          cp_r getwd, stage_dir, preserve: true
+          ohai "Setting up Git repository"
+          cd(stage_dir) do
+            system "git", "init", "-q"
+            system "git", "add", "-A"
+            system "git", "commit", "-q", "-m", "brew-unpack"
+          end
         end
       end
-
-      next unless args.git?
-
-      ohai "Setting up Git repository"
-      cd stage_dir
-      system "git", "init", "-q"
-      system "git", "add", "-A"
-      system "git", "commit", "-q", "-m", "brew-unpack"
     end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/update-license-data.rb b/Library/Homebrew/dev-cmd/update-license-data.rb
index 158596937cab4..5d2ed16ac70e4 100644
--- a/Library/Homebrew/dev-cmd/update-license-data.rb
+++ b/Library/Homebrew/dev-cmd/update-license-data.rb
@@ -1,35 +1,34 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 require "utils/spdx"
+require "system_command"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def update_license_data_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Update SPDX license data in the Homebrew repository.
-      EOS
-      switch "--fail-if-not-changed",
-             description: "Return a failing status code if current license data's version is the same as " \
-                          "the upstream. This can be used to notify CI when the SPDX license data is out of date."
-
-      named_args :none
+  module DevCmd
+    class UpdateLicenseData < AbstractCommand
+      include SystemCommand::Mixin
+
+      cmd_args do
+        description <<~EOS
+          Update SPDX license data in the Homebrew repository.
+        EOS
+        named_args :none
+      end
+
+      sig { override.void }
+      def run
+        SPDX.download_latest_license_data!
+        diff = system_command "git", args: [
+          "-C", HOMEBREW_REPOSITORY, "diff", "--exit-code", SPDX::DATA_PATH
+        ]
+        if diff.status.success?
+          ofail "No changes to SPDX license data."
+        else
+          puts "SPDX license data updated."
+        end
+      end
     end
   end
-
-  def update_license_data
-    args = update_license_data_args.parse
-    ohai "Updating SPDX license data..."
-
-    SPDX.download_latest_license_data!
-    return unless args.fail_if_not_changed?
-
-    Homebrew.failed = system("git", "diff", "--stat", "--exit-code", SPDX::DATA_PATH)
-  end
 end
diff --git a/Library/Homebrew/dev-cmd/update-maintainers.rb b/Library/Homebrew/dev-cmd/update-maintainers.rb
index 01d1ff582c9fa..4dcb92431a886 100644
--- a/Library/Homebrew/dev-cmd/update-maintainers.rb
+++ b/Library/Homebrew/dev-cmd/update-maintainers.rb
@@ -1,66 +1,63 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 require "utils/github"
-require "dev-cmd/generate-man-completions"
+require "manpages"
+require "system_command"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def update_maintainers_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Update the list of maintainers in the `Homebrew/brew` README.
-      EOS
-
-      named_args :none
-    end
-  end
-
-  def update_maintainers
-    update_maintainers_args.parse
-
-    # We assume that only public members wish to be included in the README
-    public_members = GitHub.public_member_usernames("Homebrew")
-
-    members = {
-      plc: GitHub.members_by_team("Homebrew", "plc"),
-      tsc: GitHub.members_by_team("Homebrew", "tsc"),
-    }
-    members[:other] = GitHub.members_by_team("Homebrew", "maintainers")
-                            .except(*members.values.map(&:keys).flatten.uniq)
-
-    sentences = {}
-    members.each do |group, hash|
-      hash.slice!(*public_members)
-      hash.each { |login, name| hash[login] = "[#{name}](https://github.com/#{login})" }
-      sentences[group] = hash.values.sort.to_sentence
-    end
-
-    readme = HOMEBREW_REPOSITORY/"README.md"
-
-    content = readme.read
-    content.gsub!(/(Homebrew's \[Project Leadership Committee.*) is .*\./,
-                  "\\1 is #{sentences[:plc]}.")
-    content.gsub!(/(Homebrew's \[Technical Steering Committee.*) is .*\./,
-                  "\\1 is #{sentences[:tsc]}.")
-    content.gsub!(/(Homebrew's other current maintainers are).*\./,
-                  "\\1 #{sentences[:other]}.")
-
-    File.write(readme, content)
-
-    diff = system_command "git", args: [
-      "-C", HOMEBREW_REPOSITORY, "diff", "--exit-code", "README.md"
-    ]
-    if diff.status.success?
-      puts "No changes to list of maintainers."
-    else
-      Homebrew.regenerate_man_pages(preserve_date: true, quiet: true)
-      puts "List of maintainers updated in the README and the generated man pages."
+  module DevCmd
+    class UpdateMaintainers < AbstractCommand
+      include SystemCommand::Mixin
+
+      cmd_args do
+        description <<~EOS
+          Update the list of maintainers in the `Homebrew/brew` README.
+        EOS
+
+        named_args :none
+      end
+
+      sig { override.void }
+      def run
+        # We assume that only public members wish to be included in the README
+        public_members = GitHub.public_member_usernames("Homebrew")
+        maintainers = GitHub.members_by_team("Homebrew", "maintainers")
+
+        members = {
+          plc:         GitHub.members_by_team("Homebrew", "plc"),
+          tsc:         GitHub.members_by_team("Homebrew", "tsc"),
+          maintainers:,
+        }
+
+        sentences = {}
+        members.each do |group, hash|
+          hash.replace(hash.slice(*public_members))
+          hash.each { |login, name| hash[login] = "[#{name}](https://github.com/#{login})" }
+          sentences[group] = hash.values.sort.to_sentence
+        end
+
+        readme = HOMEBREW_REPOSITORY/"README.md"
+
+        content = readme.read
+        content.gsub!(/(Homebrew's \[Project Leadership Committee.*) is .*\./,
+                      "\\1 is #{sentences[:plc]}.")
+        content.gsub!(/(Homebrew's \[Technical Steering Committee.*) is .*\./,
+                      "\\1 is #{sentences[:tsc]}.")
+        content.gsub!(/(Homebrew's maintainers are).*\./,
+                      "\\1 #{sentences[:maintainers]}.")
+
+        File.write(readme, content)
+
+        diff = system_command "git", args: ["-C", HOMEBREW_REPOSITORY, "diff", "--exit-code", "README.md"]
+        if diff.status.success?
+          ofail "No changes to list of maintainers."
+        else
+          Manpages.regenerate_man_pages(quiet: true)
+          puts "List of maintainers updated in the README and the generated man pages."
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/update-python-resources.rb b/Library/Homebrew/dev-cmd/update-python-resources.rb
index 8737b5a680f33..865103698f74a 100644
--- a/Library/Homebrew/dev-cmd/update-python-resources.rb
+++ b/Library/Homebrew/dev-cmd/update-python-resources.rb
@@ -1,53 +1,53 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
 require "utils/pypi"
 
 module Homebrew
-  extend T::Sig
+  module DevCmd
+    class UpdatePythonResources < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Update versions for PyPI resource blocks in <formula>.
+        EOS
+        switch "-p", "--print-only",
+               description: "Print the updated resource blocks instead of changing <formula>."
+        switch "-s", "--silent",
+               description: "Suppress any output."
+        switch "--ignore-non-pypi-packages",
+               description: "Don't fail if <formula> is not a PyPI package."
+        switch "--install-dependencies",
+               description: "Install missing dependencies required to update resources."
+        flag   "--version=",
+               description: "Use the specified <version> when finding resources for <formula>. " \
+                            "If no version is specified, the current version for <formula> will be used."
+        flag   "--package-name=",
+               description: "Use the specified <package-name> when finding resources for <formula>. " \
+                            "If no package name is specified, it will be inferred from the formula's stable URL."
+        comma_array "--extra-packages",
+                    description: "Include these additional packages when finding resources."
+        comma_array "--exclude-packages",
+                    description: "Exclude these packages when finding resources."
 
-  module_function
+        named_args :formula, min: 1, without_api: true
+      end
 
-  sig { returns(CLI::Parser) }
-  def update_python_resources_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Update versions for PyPI resource blocks in <formula>.
-      EOS
-      switch "-p", "--print-only",
-             description: "Print the updated resource blocks instead of changing <formula>."
-      switch "-s", "--silent",
-             description: "Suppress any output."
-      switch "--ignore-non-pypi-packages",
-             description: "Don't fail if <formula> is not a PyPI package."
-      flag   "--version=",
-             description: "Use the specified <version> when finding resources for <formula>. " \
-                          "If no version is specified, the current version for <formula> will be used."
-      flag   "--package-name=",
-             description: "Use the specified <package-name> when finding resources for <formula>. " \
-                          "If no package name is specified, it will be inferred from the formula's stable URL."
-      comma_array "--extra-packages=",
-                  description: "Include these additional packages when finding resources."
-      comma_array "--exclude-packages=",
-                  description: "Exclude these packages when finding resources."
-
-      named_args :formula, min: 1
-    end
-  end
-
-  def update_python_resources
-    args = update_python_resources_args.parse
-
-    args.named.to_formulae.each do |formula|
-      PyPI.update_python_resources! formula,
-                                    version:                  args.version,
-                                    package_name:             args.package_name,
-                                    extra_packages:           args.extra_packages,
-                                    exclude_packages:         args.exclude_packages,
-                                    print_only:               args.print_only?,
-                                    silent:                   args.silent?,
-                                    ignore_non_pypi_packages: args.ignore_non_pypi_packages?
+      sig { override.void }
+      def run
+        args.named.to_formulae.each do |formula|
+          PyPI.update_python_resources! formula,
+                                        version:                  args.version,
+                                        package_name:             args.package_name,
+                                        extra_packages:           args.extra_packages,
+                                        exclude_packages:         args.exclude_packages,
+                                        install_dependencies:     args.install_dependencies?,
+                                        print_only:               args.print_only?,
+                                        silent:                   args.silent?,
+                                        verbose:                  args.verbose?,
+                                        ignore_non_pypi_packages: args.ignore_non_pypi_packages?
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/dev-cmd/update-sponsors.rb b/Library/Homebrew/dev-cmd/update-sponsors.rb
new file mode 100644
index 0000000000000..7d87756910e74
--- /dev/null
+++ b/Library/Homebrew/dev-cmd/update-sponsors.rb
@@ -0,0 +1,80 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "abstract_command"
+require "utils/github"
+require "system_command"
+
+module Homebrew
+  module DevCmd
+    class UpdateSponsors < AbstractCommand
+      include SystemCommand::Mixin
+
+      NAMED_MONTHLY_AMOUNT = 100
+      URL_MONTHLY_AMOUNT = 1000
+
+      cmd_args do
+        description <<~EOS
+          Update the list of GitHub Sponsors in the `Homebrew/brew` README.
+        EOS
+
+        named_args :none
+      end
+
+      sig { override.void }
+      def run
+        named_sponsors = []
+        logo_sponsors = []
+        largest_monthly_amount = T.let(0, Integer)
+
+        GitHub.sponsorships("Homebrew").each do |s|
+          largest_monthly_amount = [s[:monthly_amount], s[:closest_tier_monthly_amount]].max
+          if largest_monthly_amount >= NAMED_MONTHLY_AMOUNT
+            named_sponsors << "[#{sponsor_name(s)}](#{sponsor_url(s)})"
+          end
+
+          next if largest_monthly_amount < URL_MONTHLY_AMOUNT
+
+          logo_sponsors << "[![#{sponsor_name(s)}](#{sponsor_logo(s)})](#{sponsor_url(s)})"
+        end
+
+        odie "No sponsorships amounts found! Ensure you have sufficient permissions!" if largest_monthly_amount.zero?
+
+        named_sponsors << "many other users and organisations via [GitHub Sponsors](https://github.com/sponsors/Homebrew)"
+
+        readme = HOMEBREW_REPOSITORY/"README.md"
+        content = readme.read
+        content.gsub!(/(Homebrew is generously supported by) .*\Z/m, "\\1 #{named_sponsors.to_sentence}.\n")
+        content << "\n#{logo_sponsors.join}\n" if logo_sponsors.presence
+
+        File.write(readme, content)
+
+        diff = system_command "git", args: [
+          "-C", HOMEBREW_REPOSITORY, "diff", "--exit-code", "README.md"
+        ]
+        if diff.status.success?
+          ofail "No changes to list of sponsors."
+        else
+          puts "List of sponsors updated in the README."
+        end
+      end
+
+      private
+
+      sig { params(sponsor: T::Hash[Symbol, String]).returns(T.nilable(String)) }
+      def sponsor_name(sponsor)
+        sponsor[:name] || sponsor[:login]
+      end
+
+      sig { params(sponsor: T::Hash[Symbol, String]).returns(String) }
+      def sponsor_logo(sponsor)
+        "https://github.com/#{sponsor[:login]}.png?size=64"
+      end
+
+      sig { params(sponsor: T::Hash[Symbol, String]).returns(String) }
+      def sponsor_url(sponsor)
+        "https://github.com/#{sponsor[:login]}"
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/dev-cmd/update-test.rb b/Library/Homebrew/dev-cmd/update-test.rb
index 69bfe66f0f708..eb975b73fd585 100644
--- a/Library/Homebrew/dev-cmd/update-test.rb
+++ b/Library/Homebrew/dev-cmd/update-test.rb
@@ -1,150 +1,159 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
+require "fileutils"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def update_test_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Run a test of `brew update` with a new repository clone.
-        If no options are passed, use `origin/master` as the start commit.
-      EOS
-      switch "--to-tag",
-             description: "Set `HOMEBREW_UPDATE_TO_TAG` to test updating between tags."
-      switch "--keep-tmp",
-             description: "Retain the temporary directory containing the new repository clone."
-      flag   "--commit=",
-             description: "Use the specified <commit> as the start commit."
-      flag   "--before=",
-             description: "Use the commit at the specified <date> as the start commit."
-
-      named_args :none
-    end
-  end
+  module DevCmd
+    class UpdateTest < AbstractCommand
+      include FileUtils
+
+      cmd_args do
+        description <<~EOS
+          Run a test of `brew update` with a new repository clone.
+          If no options are passed, use `origin/master` as the start commit.
+        EOS
+        switch "--to-tag",
+               description: "Set `HOMEBREW_UPDATE_TO_TAG` to test updating between tags."
+        switch "--keep-tmp",
+               description: "Retain the temporary directory containing the new repository clone."
+        flag   "--commit=",
+               description: "Use the specified <commit> as the start commit."
+        flag   "--before=",
+               description: "Use the commit at the specified <date> as the start commit."
+
+        named_args :none
+      end
 
-  def update_test
-    args = update_test_args.parse
+      sig { override.void }
+      def run
+        # Avoid `update-report.rb` tapping Homebrew/homebrew-core
+        ENV["HOMEBREW_UPDATE_TEST"] = "1"
+
+        # Avoid accidentally updating when we don't expect it.
+        ENV["HOMEBREW_NO_AUTO_UPDATE"] = "1"
+
+        # Use default behaviours
+        ENV["HOMEBREW_AUTO_UPDATE_SECS"] = nil
+        ENV["HOMEBREW_DEVELOPER"] = nil
+        ENV["HOMEBREW_DEV_CMD_RUN"] = nil
+        ENV["HOMEBREW_MERGE"] = nil
+        ENV["HOMEBREW_NO_UPDATE_CLEANUP"] = nil
+        ENV["HOMEBREW_UPDATE_TO_TAG"] = nil
+
+        branch = if args.to_tag?
+          ENV["HOMEBREW_UPDATE_TO_TAG"] = "1"
+          "stable"
+        else
+          ENV["HOMEBREW_DEV_CMD_RUN"] = "1"
+          "master"
+        end
 
-    # Avoid `update-report.rb` tapping Homebrew/homebrew-core
-    ENV["HOMEBREW_UPDATE_TEST"] = "1"
+        # Utils.popen_read returns a String without a block argument, but that isn't easily typed. We thus label this
+        # as untyped for now.
+        start_commit = T.let("", T.untyped)
+        end_commit = "HEAD"
+        cd HOMEBREW_REPOSITORY do
+          start_commit = if (commit = args.commit)
+            commit
+          elsif (date = args.before)
+            Utils.popen_read("git", "rev-list", "-n1", "--before=#{date}", "origin/master").chomp
+          elsif args.to_tag?
+            tags = git_tags
+            current_tag, previous_tag, = tags.lines
+            current_tag = current_tag.to_s.chomp
+            odie "Could not find current tag in:\n#{tags}" if current_tag.empty?
+            # ^0 ensures this points to the commit rather than the tag object.
+            end_commit = "#{current_tag}^0"
+
+            previous_tag = previous_tag.to_s.chomp
+            odie "Could not find previous tag in:\n#{tags}" if previous_tag.empty?
+            # ^0 ensures this points to the commit rather than the tag object.
+            "#{previous_tag}^0"
+          else
+            Utils.popen_read("git", "merge-base", "origin/master", end_commit).chomp
+          end
+          odie "Could not find start commit!" if start_commit.empty?
 
-    # Avoid accidentally updating when we don't expect it.
-    ENV["HOMEBREW_NO_AUTO_UPDATE"] = "1"
+          start_commit = Utils.popen_read("git", "rev-parse", start_commit).chomp
+          odie "Could not find start commit!" if start_commit.empty?
 
-    # Use default behaviours
-    ENV["HOMEBREW_AUTO_UPDATE_SECS"] = nil
-    ENV["HOMEBREW_DEVELOPER"] = nil
-    ENV["HOMEBREW_DEV_CMD_RUN"] = nil
-    ENV["HOMEBREW_MERGE"] = nil
-    ENV["HOMEBREW_NO_UPDATE_CLEANUP"] = nil
+          end_commit = T.cast(Utils.popen_read("git", "rev-parse", end_commit).chomp, String)
+          odie "Could not find end commit!" if end_commit.empty?
 
-    branch = if args.to_tag?
-      ENV["HOMEBREW_UPDATE_TO_TAG"] = "1"
-      "stable"
-    else
-      ENV["HOMEBREW_UPDATE_TO_TAG"] = nil
-      "master"
-    end
+          if Utils.popen_read("git", "branch", "--list", "master").blank?
+            safe_system "git", "branch", "master", "origin/master"
+          end
+        end
+
+        puts <<~EOS
+          Start commit: #{start_commit}
+            End commit: #{end_commit}
+        EOS
 
-    start_commit = nil
-    end_commit = "HEAD"
-    cd HOMEBREW_REPOSITORY do
-      start_commit = if (commit = args.commit)
-        commit
-      elsif (date = args.before)
-        Utils.popen_read("git", "rev-list", "-n1", "--before=#{date}", "origin/master").chomp
-      elsif args.to_tag?
+        mkdir "update-test"
+        chdir "update-test" do
+          curdir = Pathname.new(Dir.pwd)
+
+          oh1 "Preparing test environment..."
+          # copy Homebrew installation
+          safe_system "git", "clone", "#{HOMEBREW_REPOSITORY}/.git", ".",
+                      "--branch", "master", "--single-branch"
+
+          # set git origin to another copy
+          safe_system "git", "clone", "#{HOMEBREW_REPOSITORY}/.git", "remote.git",
+                      "--bare", "--branch", "master", "--single-branch"
+          safe_system "git", "config", "remote.origin.url", "#{curdir}/remote.git"
+          ENV["HOMEBREW_BREW_GIT_REMOTE"] = "#{curdir}/remote.git"
+
+          # force push origin to end_commit
+          safe_system "git", "checkout", "-B", "master", end_commit
+          safe_system "git", "push", "--force", "origin", "master"
+
+          # set test copy to start_commit
+          safe_system "git", "reset", "--hard", start_commit
+
+          # update ENV["PATH"]
+          ENV["PATH"] = PATH.new(ENV.fetch("PATH")).prepend(curdir/"bin").to_s
+
+          # Run `brew help` to install `portable-ruby` (if needed).
+          quiet_system "brew", "help"
+
+          # run brew update
+          oh1 "Running `brew update`..."
+          safe_system "brew", "update", "--verbose", "--debug"
+          actual_end_commit = Utils.popen_read("git", "rev-parse", branch).chomp
+          if actual_end_commit != end_commit
+            start_log = Utils.popen_read("git", "log", "-1", "--decorate", "--oneline", start_commit).chomp
+            end_log = Utils.popen_read("git", "log", "-1", "--decorate", "--oneline", end_commit).chomp
+            actual_log = Utils.popen_read("git", "log", "-1", "--decorate", "--oneline", actual_end_commit).chomp
+            odie <<~EOS
+              `brew update` didn't update #{branch}!
+              Start commit:        #{start_log}
+              Expected end commit: #{end_log}
+              Actual end commit:   #{actual_log}
+            EOS
+          end
+        end
+      ensure
+        FileUtils.rm_rf "update-test" unless args.keep_tmp?
+      end
+
+      private
+
+      def git_tags
         tags = Utils.popen_read("git", "tag", "--list", "--sort=-version:refname")
         if tags.blank?
           tags = if (HOMEBREW_REPOSITORY/".git/shallow").exist?
             safe_system "git", "fetch", "--tags", "--depth=1"
             Utils.popen_read("git", "tag", "--list", "--sort=-version:refname")
-          elsif OS.linux?
-            Utils.popen_read("git tag --list | sort -rV")
           end
         end
-        current_tag, previous_tag, = tags.lines
-        current_tag = current_tag.to_s.chomp
-        odie "Could not find current tag in:\n#{tags}" if current_tag.empty?
-        # ^0 ensures this points to the commit rather than the tag object.
-        end_commit = "#{current_tag}^0"
-
-        previous_tag = previous_tag.to_s.chomp
-        odie "Could not find previous tag in:\n#{tags}" if previous_tag.empty?
-        # ^0 ensures this points to the commit rather than the tag object.
-        "#{previous_tag}^0"
-      else
-        Utils.popen_read("git", "merge-base", "origin/master", end_commit).chomp
-      end
-      odie "Could not find start commit!" if start_commit.empty?
-
-      start_commit = Utils.popen_read("git", "rev-parse", start_commit).chomp
-      odie "Could not find start commit!" if start_commit.empty?
-
-      end_commit = Utils.popen_read("git", "rev-parse", end_commit).chomp
-      odie "Could not find end commit!" if end_commit.empty?
-
-      if Utils.popen_read("git", "branch", "--list", "master").blank?
-        safe_system "git", "branch", "master", "origin/master"
-      end
-    end
-
-    puts <<~EOS
-      Start commit: #{start_commit}
-        End commit: #{end_commit}
-    EOS
-
-    mkdir "update-test"
-    chdir "update-test" do
-      curdir = Pathname.new(Dir.pwd)
-
-      oh1 "Preparing test environment..."
-      # copy Homebrew installation
-      safe_system "git", "clone", "#{HOMEBREW_REPOSITORY}/.git", ".",
-                  "--branch", "master", "--single-branch"
-
-      # set git origin to another copy
-      safe_system "git", "clone", "#{HOMEBREW_REPOSITORY}/.git", "remote.git",
-                  "--bare", "--branch", "master", "--single-branch"
-      safe_system "git", "config", "remote.origin.url", "#{curdir}/remote.git"
-      ENV["HOMEBREW_BREW_GIT_REMOTE"] = "#{curdir}/remote.git"
-
-      # force push origin to end_commit
-      safe_system "git", "checkout", "-B", "master", end_commit
-      safe_system "git", "push", "--force", "origin", "master"
-
-      # set test copy to start_commit
-      safe_system "git", "reset", "--hard", start_commit
-
-      # update ENV["PATH"]
-      ENV["PATH"] = PATH.new(ENV.fetch("PATH")).prepend(curdir/"bin")
-
-      # run brew help to install portable-ruby (if needed)
-      quiet_system "brew", "help"
-
-      # run brew update
-      oh1 "Running `brew update`..."
-      safe_system "brew", "update", "--verbose", "--debug"
-      actual_end_commit = Utils.popen_read("git", "rev-parse", branch).chomp
-      if actual_end_commit != end_commit
-        start_log = Utils.popen_read("git", "log", "-1", "--decorate", "--oneline", start_commit).chomp
-        end_log = Utils.popen_read("git", "log", "-1", "--decorate", "--oneline", end_commit).chomp
-        actual_log = Utils.popen_read("git", "log", "-1", "--decorate", "--oneline", actual_end_commit).chomp
-        odie <<~EOS
-          `brew update` didn't update #{branch}!
-          Start commit:        #{start_log}
-          Expected end commit: #{end_log}
-          Actual end commit:   #{actual_log}
-        EOS
+        tags
       end
     end
-  ensure
-    FileUtils.rm_rf "update-test" unless args.keep_tmp?
   end
 end
+
+require "extend/os/dev-cmd/update-test"
diff --git a/Library/Homebrew/dev-cmd/vendor-gems.rb b/Library/Homebrew/dev-cmd/vendor-gems.rb
index 432e12ce20e8d..3587ab3ba9ab6 100644
--- a/Library/Homebrew/dev-cmd/vendor-gems.rb
+++ b/Library/Homebrew/dev-cmd/vendor-gems.rb
@@ -1,59 +1,106 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "cli/parser"
+require "abstract_command"
+require "utils/git"
 
 module Homebrew
-  extend T::Sig
-
-  module_function
-
-  sig { returns(CLI::Parser) }
-  def vendor_gems_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Install and commit Homebrew's vendored gems.
-      EOS
-
-      comma_array "--update",
-                  description: "Update all vendored Gems to the latest version."
-
-      named_args :none
-    end
-  end
-
-  sig { void }
-  def vendor_gems
-    args = vendor_gems_args.parse
-
-    Homebrew.install_bundler!
-
-    ENV["BUNDLE_WITH"] = "sorbet"
-
-    ohai "cd #{HOMEBREW_LIBRARY_PATH}"
-    HOMEBREW_LIBRARY_PATH.cd do
-      if args.update
-        ohai "bundle update"
-        safe_system "bundle", "update", *args.update
-
-        ohai "git add Gemfile.lock"
-        system "git", "add", "Gemfile.lock"
+  module DevCmd
+    class VendorGems < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Install and commit Homebrew's vendored gems.
+        EOS
+
+        comma_array "--update",
+                    description: "Update the specified list of vendored gems to the latest version."
+        switch      "--no-commit",
+                    description: "Do not generate a new commit upon completion."
+        switch     "--non-bundler-gems",
+                   description: "Update vendored gems that aren't using Bundler.",
+                   hidden:      true
+
+        named_args :none
       end
 
-      ohai "bundle install --standalone"
-      safe_system "bundle", "install", "--standalone"
-
-      ohai "bundle pristine"
-      safe_system "bundle", "pristine"
-
-      ohai "git add vendor/bundle"
-      system "git", "add", "vendor/bundle"
+      sig { override.void }
+      def run
+        Homebrew.install_bundler!
+
+        ENV["BUNDLE_WITH"] = Homebrew.valid_gem_groups.join(":")
+
+        ohai "cd #{HOMEBREW_LIBRARY_PATH}"
+        HOMEBREW_LIBRARY_PATH.cd do
+          if args.update
+            ohai "bundle update"
+            run_bundle "update", *args.update
+
+            unless args.no_commit?
+              ohai "git add Gemfile.lock"
+              system "git", "add", "Gemfile.lock"
+            end
+          end
+
+          ohai "bundle install --standalone"
+          run_bundle "install", "--standalone"
+
+          ohai "bundle pristine"
+          run_bundle "pristine"
+
+          ohai "bundle clean"
+          run_bundle "clean"
+
+          # Workaround Bundler 2.4.21 issue where platforms may be removed.
+          # Although we don't use 2.4.21, Dependabot does as it currently ignores your lockfile version.
+          # https://github.com/rubygems/rubygems/issues/7169
+          run_bundle "lock", "--add-platform", "aarch64-linux", "arm-linux"
+          system "git", "add", "Gemfile.lock" unless args.no_commit?
+
+          if args.non_bundler_gems?
+            %w[
+              mechanize
+            ].each do |gem|
+              (HOMEBREW_LIBRARY_PATH/"vendor/gems").cd do
+                Pathname.glob("#{gem}-*/").each { |path| FileUtils.rm_r(path) }
+              end
+              ohai "gem install #{gem}"
+              safe_system "gem", "install", gem, "--install-dir", "vendor",
+                          "--no-document", "--no-wrappers", "--ignore-dependencies", "--force"
+              (HOMEBREW_LIBRARY_PATH/"vendor/gems").cd do
+                source = Pathname.glob("#{gem}-*/").first
+                next if source.blank?
+
+                # We cannot use `#ln_sf` here because that has unintended consequences when
+                # the symlink we want to create exists and points to an existing directory.
+                FileUtils.rm_f gem
+                FileUtils.ln_s source, gem
+              end
+            end
+          end
+
+          unless args.no_commit?
+            ohai "git add vendor"
+            system "git", "add", "vendor"
+
+            Utils::Git.set_name_email!
+            Utils::Git.setup_gpg!
+
+            ohai "git commit"
+            system "git", "commit", "--message", "brew vendor-gems: commit updates."
+          end
+        end
+      end
 
-      Utils::Git.set_name_email!
-      Utils::Git.setup_gpg!
+      sig { params(args: String).void }
+      def run_bundle(*args)
+        Process.wait(fork do
+          # Native build scripts fail if EUID != UID
+          Process::UID.change_privilege(Process.euid) if Process.euid != Process.uid
+          exec "bundle", *args
+        end)
 
-      ohai "git commit"
-      system "git", "commit", "--message", "brew vendor-gems: commit updates."
+        raise ErrorDuringExecution.new(["bundle", *args], status: $CHILD_STATUS) unless $CHILD_STATUS.success?
+      end
     end
   end
 end
diff --git a/Library/Homebrew/development_tools.rb b/Library/Homebrew/development_tools.rb
index 003dbfa6ebbb9..84f743954a0dc 100644
--- a/Library/Homebrew/development_tools.rb
+++ b/Library/Homebrew/development_tools.rb
@@ -1,20 +1,23 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "version"
 
-# @private
+# Helper class for gathering information about development tools.
+#
+# @api public
 class DevelopmentTools
   class << self
-    extend T::Sig
-
-    sig { params(tool: String).returns(T.nilable(Pathname)) }
+    # Locate a development tool.
+    #
+    # @api public
+    sig { params(tool: T.any(String, Symbol)).returns(T.nilable(Pathname)) }
     def locate(tool)
       # Don't call tools (cc, make, strip, etc.) directly!
       # Give the name of the binary you look for as a string to this method
       # in order to get the full path back as a Pathname.
-      (@locate ||= {}).fetch(tool) do |key|
-        @locate[key] = if File.executable?(path = "/usr/bin/#{tool}")
+      (@locate ||= T.let({}, T.nilable(T::Hash[T.any(String, Symbol), T.untyped]))).fetch(tool) do |key|
+        @locate[key] = if File.executable?((path = "/usr/bin/#{tool}"))
           Pathname.new path
         # Homebrew GCCs most frequently; much faster to check this before xcrun
         elsif (path = HOMEBREW_PREFIX/"bin/#{tool}").executable?
@@ -38,64 +41,104 @@ def custom_installation_instructions
       installation_instructions
     end
 
+    sig { params(resource: String).returns(String) }
+    def insecure_download_warning(resource)
+      package = curl_handles_most_https_certificates? ? "ca-certificates" : "curl"
+      "Using `--insecure` with curl to download #{resource} because we need it to run " \
+        "`brew install #{package}` in order to download securely from now on. " \
+        "Checksums will still be verified."
+    end
+
+    # Get the default C compiler.
+    #
+    # @api public
     sig { returns(Symbol) }
     def default_compiler
       :clang
     end
 
+    # Get the Clang version.
+    #
+    # @api public
     sig { returns(Version) }
     def clang_version
-      @clang_version ||= if (path = locate("clang")) &&
-                            (build_version = `#{path} --version`[/(?:clang|LLVM) version (\d+\.\d(?:\.\d)?)/, 1])
-        Version.new build_version
-      else
-        Version::NULL
-      end
+      @clang_version ||= T.let(
+        if (path = locate("clang")) &&
+           (build_version = `#{path} --version`[/(?:clang|LLVM) version (\d+\.\d(?:\.\d)?)/, 1])
+          Version.new(build_version)
+        else
+          Version::NULL
+        end, T.nilable(Version)
+      )
     end
 
+    # Get the Clang build version.
+    #
+    # @api public
     sig { returns(Version) }
     def clang_build_version
-      @clang_build_version ||= if (path = locate("clang")) &&
-                                  (build_version = `#{path} --version`[
-%r{clang(-| version [^ ]+ \(tags/RELEASE_)(\d{2,})}, 2])
-        Version.new build_version
-      else
-        Version::NULL
-      end
+      @clang_build_version ||= T.let(
+        if (path = locate("clang")) &&
+          (build_version = `#{path} --version`[%r{clang(-| version [^ ]+ \(tags/RELEASE_)(\d{2,})}, 2])
+          Version.new(build_version)
+        else
+          Version::NULL
+        end, T.nilable(Version)
+      )
     end
 
+    # Get the LLVM Clang build version.
+    #
+    # @api public
     sig { returns(Version) }
     def llvm_clang_build_version
-      @llvm_clang_build_version ||= begin
+      @llvm_clang_build_version ||= T.let(begin
         path = Formulary.factory("llvm").opt_prefix/"bin/clang"
-        if path.executable? &&
-           (build_version = `#{path} --version`[/clang version (\d+\.\d\.\d)/, 1])
-          Version.new build_version
+        if path.executable? && (build_version = `#{path} --version`[/clang version (\d+\.\d\.\d)/, 1])
+          Version.new(build_version)
         else
           Version::NULL
         end
-      end
+      end, T.nilable(Version))
     end
 
+    # Get the GCC version.
+    #
+    # @api internal
     sig { params(cc: String).returns(Version) }
-    def non_apple_gcc_version(cc)
-      (@non_apple_gcc_version ||= {}).fetch(cc) do
+    def gcc_version(cc)
+      (@gcc_version ||= T.let({}, T.nilable(T::Hash[String, Version]))).fetch(cc) do
         path = HOMEBREW_PREFIX/"opt/#{CompilerSelector.preferred_gcc}/bin"/cc
         path = locate(cc) unless path.exist?
         version = if path &&
                      (build_version = `#{path} --version`[/gcc(?:(?:-\d+(?:\.\d)?)? \(.+\))? (\d+\.\d\.\d)/, 1])
-          Version.new build_version
+          Version.new(build_version)
         else
           Version::NULL
         end
-        @non_apple_gcc_version[cc] = version
+        @gcc_version[cc] = version
       end
     end
 
     sig { void }
     def clear_version_cache
-      @clang_version = @clang_build_version = nil
-      @non_apple_gcc_version = {}
+      @clang_version = @clang_build_version = T.let(nil, T.nilable(Version))
+      @gcc_version = T.let({}, T.nilable(T::Hash[String, Version]))
+    end
+
+    sig { returns(T::Boolean) }
+    def needs_build_formulae?
+      needs_libc_formula? || needs_compiler_formula?
+    end
+
+    sig { returns(T::Boolean) }
+    def needs_libc_formula?
+      false
+    end
+
+    sig { returns(T::Boolean) }
+    def needs_compiler_formula?
+      false
     end
 
     sig { returns(T::Boolean) }
@@ -110,6 +153,17 @@ def curl_handles_most_https_certificates?
       true
     end
 
+    sig { returns(T::Boolean) }
+    def ca_file_substitution_required?
+      (!ca_file_handles_most_https_certificates? || ENV["HOMEBREW_FORCE_BREWED_CA_CERTIFICATES"].present?) &&
+        !(HOMEBREW_PREFIX/"etc/ca-certificates/cert.pem").exist?
+    end
+
+    sig { returns(T::Boolean) }
+    def curl_substitution_required?
+      !curl_handles_most_https_certificates? && !HOMEBREW_BREWED_CURL_PATH.exist?
+    end
+
     sig { returns(T::Boolean) }
     def subversion_handles_most_https_certificates?
       true
@@ -123,7 +177,6 @@ def build_system_info
         "cpu_family" => Hardware::CPU.family.to_s,
       }
     end
-    alias generic_build_system_info build_system_info
   end
 end
 
diff --git a/Library/Homebrew/diagnostic.rb b/Library/Homebrew/diagnostic.rb
index ef978763927a0..c88b0b941227a 100644
--- a/Library/Homebrew/diagnostic.rb
+++ b/Library/Homebrew/diagnostic.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "keg"
@@ -11,16 +11,15 @@
 require "system_config"
 require "cask/caskroom"
 require "cask/quarantine"
+require "system_command"
 
 module Homebrew
   # Module containing diagnostic checks.
-  #
-  # @api private
   module Diagnostic
-    def self.missing_deps(ff, hide = nil)
+    def self.missing_deps(formulae, hide = nil)
       missing = {}
-      ff.each do |f|
-        missing_dependencies = f.missing_dependencies(hide: hide)
+      formulae.each do |f|
+        missing_dependencies = f.missing_dependencies(hide:)
         next if missing_dependencies.empty?
 
         yield f.full_name, missing_dependencies if block_given?
@@ -31,7 +30,7 @@ def self.missing_deps(ff, hide = nil)
 
     def self.checks(type, fatal: true)
       @checks ||= Checks.new
-      failed = false
+      failed = T.let(false, T::Boolean)
       @checks.public_send(type).each do |check|
         out = @checks.public_send(check)
         next if out.nil?
@@ -48,7 +47,7 @@ def self.checks(type, fatal: true)
 
     # Diagnostic checks.
     class Checks
-      extend T::Sig
+      include SystemCommand::Mixin
 
       def initialize(verbose: true)
         @verbose = verbose
@@ -64,6 +63,7 @@ def find_relative_paths(*relative_paths)
         end
       end
 
+      sig { params(list: T::Array[String], string: String).returns(String) }
       def inject_file_list(list, string)
         list.reduce(string.dup) { |acc, elem| acc << "  #{elem}\n" }
             .freeze
@@ -113,18 +113,23 @@ def build_error_checks
 
       def please_create_pull_requests(what = "unsupported configuration")
         <<~EOS
-          You will encounter build failures with some formulae.
-          Please create pull requests instead of asking for help on Homebrew's GitHub,
-          Twitter or any other official channels. You are responsible for resolving
-          any issues you experience while you are running this
-          #{what}.
+          It is expected behaviour that some formulae will fail to build in this #{what}.
+          It is expected behaviour that Homebrew will be buggy and slow.
+          Do not create any issues about this on Homebrew's GitHub repositories.
+          Do not create any issues even if you think this message is unrelated.
+          Any opened issues will be immediately closed without response.
+          Do not ask for help from Homebrew or its maintainers on social media.
+          You may ask for help in Homebrew's discussions but are unlikely to receive a response.
+          Try to figure out the problem yourself and submit a fix as a pull request.
+          We will review it but may or may not accept it.
         EOS
       end
 
+      sig { params(repository_path: GitRepository, desired_origin: String).returns(T.nilable(String)) }
       def examine_git_origin(repository_path, desired_origin)
-        return if !Utils::Git.available? || !repository_path.git?
+        return if !Utils::Git.available? || !repository_path.git_repository?
 
-        current_origin = repository_path.git_origin
+        current_origin = repository_path.origin_url
 
         if current_origin.nil?
           <<~EOS
@@ -150,8 +155,8 @@ def examine_git_origin(repository_path, desired_origin)
       def broken_tap(tap)
         return unless Utils::Git.available?
 
-        repo = HOMEBREW_REPOSITORY.dup.extend(GitRepositoryExtension)
-        return unless repo.git?
+        repo = GitRepository.new(HOMEBREW_REPOSITORY)
+        return unless repo.git_repository?
 
         message = <<~EOS
           #{tap.full_name} was not tapped properly! Run:
@@ -163,7 +168,7 @@ def broken_tap(tap)
 
         tap_head = tap.git_head
         return message if tap_head.blank?
-        return if tap_head != repo.git_head
+        return if tap_head != repo.head_ref
 
         message
       end
@@ -177,32 +182,6 @@ def check_for_installed_developer_tools
         EOS
       end
 
-      # Anaconda installs multiple system & brew dupes, including OpenSSL, Python,
-      # sqlite, libpng, Qt, etc. Regularly breaks compile on Vim, MacVim and others.
-      # Is flagged as part of the *-config script checks below, but people seem
-      # to ignore those as warnings rather than extremely likely breakage.
-      def check_for_anaconda
-        return unless which("anaconda")
-        return unless which("python")
-
-        anaconda_directory = which("anaconda").realpath.dirname
-        python_binary = Utils.popen_read(which("python"), "-c", "import sys; sys.stdout.write(sys.executable)")
-        python_directory = Pathname.new(python_binary).realpath.dirname
-
-        # Only warn if Python lives with Anaconda, since is most problematic case.
-        return unless python_directory == anaconda_directory
-
-        <<~EOS
-          Anaconda is known to frequently break Homebrew builds, including Vim and
-          MacVim, due to bundling many duplicates of system and Homebrew-provided
-          tools.
-
-          If you encounter a build failure please temporarily remove Anaconda
-          from your $PATH and attempt the build again prior to reporting the
-          failure to us. Thanks!
-        EOS
-      end
-
       def __check_stray_files(dir, pattern, allow_list, message)
         return unless File.directory?(dir)
 
@@ -242,7 +221,7 @@ def check_for_stray_dylibs
         __check_stray_files "/usr/local/lib", "*.dylib", allow_list, <<~EOS
           Unbrewed dylibs were found in /usr/local/lib.
           If you didn't put them there on purpose they could cause problems when
-          building Homebrew formulae, and may need to be deleted.
+          building Homebrew formulae and may need to be deleted.
 
           Unexpected dylibs:
         EOS
@@ -267,7 +246,7 @@ def check_for_stray_static_libs
         __check_stray_files "/usr/local/lib", "*.a", allow_list, <<~EOS
           Unbrewed static libraries were found in /usr/local/lib.
           If you didn't put them there on purpose they could cause problems when
-          building Homebrew formulae, and may need to be deleted.
+          building Homebrew formulae and may need to be deleted.
 
           Unexpected static libraries:
         EOS
@@ -287,7 +266,7 @@ def check_for_stray_pcs
         __check_stray_files "/usr/local/lib/pkgconfig", "*.pc", allow_list, <<~EOS
           Unbrewed '.pc' files were found in /usr/local/lib/pkgconfig.
           If you didn't put them there on purpose they could cause problems when
-          building Homebrew formulae, and may need to be deleted.
+          building Homebrew formulae and may need to be deleted.
 
           Unexpected '.pc' files:
         EOS
@@ -308,7 +287,7 @@ def check_for_stray_las
         __check_stray_files "/usr/local/lib", "*.la", allow_list, <<~EOS
           Unbrewed '.la' files were found in /usr/local/lib.
           If you didn't put them there on purpose they could cause problems when
-          building Homebrew formulae, and may need to be deleted.
+          building Homebrew formulae and may need to be deleted.
 
           Unexpected '.la' files:
         EOS
@@ -327,7 +306,7 @@ def check_for_stray_headers
         __check_stray_files "/usr/local/include", "**/*.h", allow_list, <<~EOS
           Unbrewed header files were found in /usr/local/include.
           If you didn't put them there on purpose they could cause problems when
-          building Homebrew formulae, and may need to be deleted.
+          building Homebrew formulae and may need to be deleted.
 
           Unexpected header files:
         EOS
@@ -336,7 +315,7 @@ def check_for_stray_headers
       def check_for_broken_symlinks
         broken_symlinks = []
 
-        Keg::MUST_EXIST_SUBDIRECTORIES.each do |d|
+        Keg.must_exist_subdirectories.each do |d|
           next unless d.directory?
 
           d.find do |path|
@@ -363,9 +342,9 @@ def check_tmpdir_sticky_bit
       alias generic_check_tmpdir_sticky_bit check_tmpdir_sticky_bit
 
       def check_exist_directories
-        return if HOMEBREW_PREFIX.writable_real?
+        return if HOMEBREW_PREFIX.writable?
 
-        not_exist_dirs = Keg::MUST_EXIST_DIRECTORIES.reject(&:exist?)
+        not_exist_dirs = Keg.must_exist_directories.reject(&:exist?)
         return if not_exist_dirs.empty?
 
         <<~EOS
@@ -374,14 +353,14 @@ def check_exist_directories
 
           You should create these directories and change their ownership to your user.
             sudo mkdir -p #{not_exist_dirs.join(" ")}
-            sudo chown -R $(whoami) #{not_exist_dirs.join(" ")}
+            sudo chown -R #{current_user} #{not_exist_dirs.join(" ")}
         EOS
       end
 
       def check_access_directories
         not_writable_dirs =
-          Keg::MUST_BE_WRITABLE_DIRECTORIES.select(&:exist?)
-                                           .reject(&:writable_real?)
+          Keg.must_be_writable_directories.select(&:exist?)
+             .reject(&:writable?)
         return if not_writable_dirs.empty?
 
         <<~EOS
@@ -389,7 +368,7 @@ def check_access_directories
           #{not_writable_dirs.join("\n")}
 
           You should change the ownership of these directories to your user.
-            sudo chown -R $(whoami) #{not_writable_dirs.join(" ")}
+            sudo chown -R #{current_user} #{not_writable_dirs.join(" ")}
 
           And make sure that your user has write permission.
             chmod u+w #{not_writable_dirs.join(" ")}
@@ -473,54 +452,6 @@ def check_user_path_3
         EOS
       end
 
-      def check_for_config_scripts
-        return unless HOMEBREW_CELLAR.exist?
-
-        real_cellar = HOMEBREW_CELLAR.realpath
-
-        scripts = []
-
-        allowlist = %W[
-          /bin /sbin
-          /usr/bin /usr/sbin
-          /usr/X11/bin /usr/X11R6/bin /opt/X11/bin
-          #{HOMEBREW_PREFIX}/bin #{HOMEBREW_PREFIX}/sbin
-          /Applications/Server.app/Contents/ServerRoot/usr/bin
-          /Applications/Server.app/Contents/ServerRoot/usr/sbin
-        ]
-        if OS.mac? && Hardware::CPU.physical_cpu_arm64?
-          allowlist += %W[
-            #{HOMEBREW_MACOS_ARM_DEFAULT_PREFIX}/bin
-            #{HOMEBREW_MACOS_ARM_DEFAULT_PREFIX}/sbin
-            #{HOMEBREW_DEFAULT_PREFIX}/bin
-            #{HOMEBREW_DEFAULT_PREFIX}/sbin
-          ]
-        end
-        allowlist.map!(&:downcase)
-
-        paths.each do |p|
-          next if allowlist.include?(p.downcase) || !File.directory?(p)
-
-          realpath = Pathname.new(p).realpath.to_s
-          next if realpath.start_with?(real_cellar.to_s, HOMEBREW_CELLAR.to_s)
-
-          scripts += Dir.chdir(p) { Dir["*-config"] }.map { |c| File.join(p, c) }
-        end
-
-        return if scripts.empty?
-
-        inject_file_list scripts, <<~EOS
-          "config" scripts exist outside your system or Homebrew directories.
-          `./configure` scripts often look for *-config scripts to determine if
-          software packages are installed, and which additional flags to use when
-          compiling and linking.
-
-          Having additional scripts in your path can confuse software installed via
-          Homebrew if the config script overrides a system or Homebrew-provided
-          script of the same name. We found the following "config" scripts:
-        EOS
-      end
-
       def check_for_symlinked_cellar
         return unless HOMEBREW_CELLAR.exist?
         return unless HOMEBREW_CELLAR.symlink?
@@ -543,7 +474,7 @@ def check_for_symlinked_cellar
       def check_git_version
         minimum_version = ENV.fetch("HOMEBREW_MINIMUM_GIT_VERSION")
         return unless Utils::Git.available?
-        return if Version.create(Utils::Git.version) >= Version.create(minimum_version)
+        return if Version.new(Utils::Git.version) >= Version.new(minimum_version)
 
         git = Formula["git"]
         git_upgrade_cmd = git.any_version_installed? ? "upgrade" : "install"
@@ -560,7 +491,7 @@ def check_for_git
 
         <<~EOS
           Git could not be found in your PATH.
-          Homebrew uses Git for several internal functions, and some formulae use Git
+          Homebrew uses Git for several internal functions and some formulae use Git
           checkouts instead of stable tarballs. You may want to install Git:
             brew install git
         EOS
@@ -570,7 +501,7 @@ def check_git_newline_settings
         return unless Utils::Git.available?
 
         autocrlf = HOMEBREW_REPOSITORY.cd { `git config --get core.autocrlf`.chomp }
-        return unless autocrlf == "true"
+        return if autocrlf != "true"
 
         <<~EOS
           Suspicious Git newline settings found.
@@ -585,22 +516,26 @@ def check_git_newline_settings
       end
 
       def check_brew_git_origin
-        repo = HOMEBREW_REPOSITORY.dup.extend(GitRepositoryExtension)
+        repo = GitRepository.new(HOMEBREW_REPOSITORY)
         examine_git_origin(repo, Homebrew::EnvConfig.brew_git_remote)
       end
 
       def check_coretap_integrity
-        coretap = CoreTap.instance
-        return if !coretap.installed? && EnvConfig.install_from_api?
+        core_tap = CoreTap.instance
+        unless core_tap.installed?
+          return unless EnvConfig.no_install_from_api?
 
-        broken_tap(coretap) || examine_git_origin(coretap.path, Homebrew::EnvConfig.core_git_remote)
+          core_tap.ensure_installed!
+        end
+
+        broken_tap(core_tap) || examine_git_origin(core_tap.git_repository, Homebrew::EnvConfig.core_git_remote)
       end
 
       def check_casktap_integrity
-        default_cask_tap = Tap.default_cask_tap
-        return unless default_cask_tap.installed?
+        core_cask_tap = CoreCaskTap.instance
+        return unless core_cask_tap.installed?
 
-        broken_tap(default_cask_tap) || examine_git_origin(default_cask_tap.path, default_cask_tap.remote)
+        broken_tap(core_cask_tap) || examine_git_origin(core_cask_tap.git_repository, core_cask_tap.remote)
       end
 
       sig { returns(T.nilable(String)) }
@@ -608,11 +543,11 @@ def check_tap_git_branch
         return if ENV["CI"]
         return unless Utils::Git.available?
 
-        commands = Tap.map do |tap|
-          next if tap.path.git_default_origin_branch?
+        commands = Tap.installed.filter_map do |tap|
+          next if tap.git_repository.default_origin_branch?
 
-          "git -C $(brew --repo #{tap.name}) checkout #{tap.path.git_origin_branch}"
-        end.compact
+          "git -C $(brew --repo #{tap.name}) checkout #{tap.git_repository.origin_branch_name}"
+        end
 
         return if commands.blank?
 
@@ -625,7 +560,7 @@ def check_tap_git_branch
 
       def check_deprecated_official_taps
         tapped_deprecated_taps =
-          Tap.select(&:official?).map(&:repo) & DEPRECATED_OFFICIAL_TAPS
+          Tap.select(&:official?).map(&:repository) & DEPRECATED_OFFICIAL_TAPS
         return if tapped_deprecated_taps.empty?
 
         <<~EOS
@@ -635,8 +570,8 @@ def check_deprecated_official_taps
         EOS
       end
 
-      def __check_linked_brew(f)
-        f.installed_prefixes.each do |prefix|
+      def __check_linked_brew(formula)
+        formula.installed_prefixes.each do |prefix|
           prefix.find do |src|
             next if src == prefix
 
@@ -708,17 +643,30 @@ def check_deprecated_disabled
         EOS
       end
 
+      def check_cask_deprecated_disabled
+        deprecated_or_disabled = Cask::Caskroom.casks.select(&:deprecated?)
+        deprecated_or_disabled += Cask::Caskroom.casks.select(&:disabled?)
+        return if deprecated_or_disabled.empty?
+
+        <<~EOS
+          Some installed casks are deprecated or disabled.
+          You should find replacements for the following casks:
+            #{deprecated_or_disabled.sort_by(&:token).uniq * "\n  "}
+        EOS
+      end
+
+      sig { returns(T.nilable(String)) }
       def check_git_status
         return unless Utils::Git.available?
 
-        message = nil
+        message = T.let(nil, T.nilable(String))
 
         repos = {
           "Homebrew/brew"          => HOMEBREW_REPOSITORY,
           "Homebrew/homebrew-core" => CoreTap.instance.path,
         }
 
-        %w[cask cask-drivers cask-fonts cask-versions].each do |tap|
+        OFFICIAL_CASK_TAPS.each do |tap|
           cask_tap = Tap.fetch "homebrew", tap
           repos[cask_tap.full_name] = cask_tap.path if cask_tap.installed?
         end
@@ -738,7 +686,7 @@ def check_git_status
             If this is a surprise to you, then you should stash these modifications.
             Stashing returns Homebrew to a pristine state but can be undone
             should you later need to do so for some reason.
-              cd #{path} && git stash && git clean -d -f
+              cd #{path} && git stash -u && git clean -d -f
           EOS
 
           modified = status.split("\n")
@@ -756,7 +704,7 @@ def check_for_non_prefixed_coreutils
         return unless coreutils.any_version_installed?
 
         gnubin = %W[#{coreutils.opt_libexec}/gnubin #{coreutils.libexec}/gnubin]
-        return if (paths & gnubin).empty?
+        return unless paths.intersect?(gnubin)
 
         <<~EOS
           Putting non-prefixed coreutils in your path can cause GMP builds to fail.
@@ -783,8 +731,7 @@ def check_for_unreadable_installed_formula
         rescue FormulaUnreadableError, FormulaClassUnavailableError,
                TapFormulaUnreadableError, TapFormulaClassUnavailableError => e
           formula_unavailable_exceptions << e
-        rescue FormulaUnavailableError,
-               TapFormulaAmbiguityError, TapFormulaWithOldnameAmbiguityError
+        rescue FormulaUnavailableError, TapFormulaAmbiguityError
           nil
         end
         return if formula_unavailable_exceptions.empty?
@@ -802,7 +749,7 @@ def check_for_unlinked_but_not_keg_only
           else
             begin
               Formulary.from_rack(rack).keg_only?
-            rescue FormulaUnavailableError, TapFormulaAmbiguityError, TapFormulaWithOldnameAmbiguityError
+            rescue FormulaUnavailableError, TapFormulaAmbiguityError
               false
             end
           end
@@ -817,7 +764,7 @@ def check_for_unlinked_but_not_keg_only
       end
 
       def check_for_external_cmd_name_conflict
-        cmds = Tap.cmd_directories.flat_map { |p| Dir["#{p}/brew-*"] }.uniq
+        cmds = Commands.tap_cmd_directories.flat_map { |p| Dir["#{p}/brew-*"] }.uniq
         cmds = cmds.select { |cmd| File.file?(cmd) && File.executable?(cmd) }
         cmd_map = {}
         cmds.each do |cmd|
@@ -845,13 +792,13 @@ def check_for_external_cmd_name_conflict
 
       def check_for_tap_ruby_files_locations
         bad_tap_files = {}
-        Tap.each do |tap|
+        Tap.installed.each do |tap|
           unused_formula_dirs = tap.potential_formula_dirs - [tap.formula_dir]
           unused_formula_dirs.each do |dir|
             next unless dir.exist?
 
             dir.children.each do |path|
-              next unless path.extname == ".rb"
+              next if path.extname != ".rb"
 
               bad_tap_files[tap] ||= []
               bad_tap_files[tap] << path
@@ -874,8 +821,9 @@ def check_homebrew_prefix
 
         <<~EOS
           Your Homebrew's prefix is not #{Homebrew::DEFAULT_PREFIX}.
-          Some of Homebrew's bottles (binary packages) can only be used with the default
-          prefix (#{Homebrew::DEFAULT_PREFIX}).
+
+          Many of Homebrew's bottles (binary packages) can only be used with the default prefix.
+          Consider uninstalling Homebrew and reinstalling into the default prefix.
           #{please_create_pull_requests}
         EOS
       end
@@ -883,18 +831,26 @@ def check_homebrew_prefix
       def check_deleted_formula
         kegs = Keg.all
 
-        deleted_formulae = kegs.map do |keg|
-          next if Formulary.tap_paths(keg.name).any?
+        deleted_formulae = kegs.filter_map do |keg|
+          tap = keg.tab.tap
+          tap_keg_name = tap ? "#{tap}/#{keg.name}" : keg.name
+
+          loadable = [
+            Formulary::FromAPILoader,
+            Formulary::FromTapLoader,
+            Formulary::FromNameLoader,
+          ].any? do |loader_class|
+            loader = begin
+              loader_class.try_new(tap_keg_name, warn: false)
+            rescue TapFormulaAmbiguityError => e
+              e.loaders.first
+            end
 
-          if !CoreTap.instance.installed? && EnvConfig.install_from_api?
-            # Formulae installed with HOMEBREW_INSTALL_FROM_API should not count as deleted formulae
-            # but may not have a tap listed in their tab
-            tap = Tab.for_keg(keg).tap
-            next if (tap.blank? || tap.core_tap?) && Homebrew::API::Formula.all_formulae.key?(keg.name)
+            loader.instance_of?(Formulary::FromTapLoader) ? loader.path.exist? : loader.present?
           end
 
-          keg.name
-        end.compact.uniq
+          keg.name unless loadable
+        end.uniq
 
         return if deleted_formulae.blank?
 
@@ -906,6 +862,36 @@ def check_deleted_formula
         EOS
       end
 
+      def check_for_unnecessary_core_tap
+        return if Homebrew::EnvConfig.developer?
+        return if Homebrew::EnvConfig.no_install_from_api?
+        return if Homebrew::EnvConfig.devcmdrun?
+        return unless CoreTap.instance.installed?
+
+        <<~EOS
+          You have an unnecessary local Core tap!
+          This can cause problems installing up-to-date formulae.
+          Please remove it by running:
+           brew untap #{CoreTap.instance.name}
+        EOS
+      end
+
+      def check_for_unnecessary_cask_tap
+        return if Homebrew::EnvConfig.developer?
+        return if Homebrew::EnvConfig.no_install_from_api?
+        return if Homebrew::EnvConfig.devcmdrun?
+
+        cask_tap = CoreCaskTap.instance
+        return unless cask_tap.installed?
+
+        <<~EOS
+          You have an unnecessary local Cask tap.
+          This can cause problems installing up-to-date casks.
+          Please remove it by running:
+            brew untap #{cask_tap.name}
+        EOS
+      end
+
       def check_cask_software_versions
         add_info "Homebrew Version", HOMEBREW_VERSION
         add_info "macOS", MacOS.full_version
@@ -917,7 +903,7 @@ def check_cask_software_versions
                  .gsub("This is an unsupported configuration, likely to break in " \
                        "the future and leave your machine in an unknown state.", "")
                  .gsub("System Integrity Protection status: ", "")
-                 .delete("\t\.")
+                 .delete("\t.")
                  .capitalize
                  .strip
           else
@@ -939,7 +925,7 @@ def check_cask_install_location
 
       def check_cask_staging_location
         # Skip this check when running CI since the staging path is not writable for security reasons
-        return if ENV["GITHUB_ACTIONS"]
+        return if GitHub::Actions.env_set?
 
         path = Cask::Caskroom.path
 
@@ -950,37 +936,34 @@ def check_cask_staging_location
         <<~EOS
           The staging path #{user_tilde(path.to_s)} is not writable by the current user.
           To fix, run:
-            sudo chown -R $(whoami):staff #{user_tilde(path.to_s)}
+            sudo chown -R #{current_user} #{user_tilde(path.to_s)}
         EOS
       end
 
       def check_cask_taps
-        default_cask_tap = Tap.default_cask_tap
-        alt_taps = Tap.select { |t| t.cask_dir.exist? && t != default_cask_tap }
-
         error_tap_paths = []
 
-        add_info "Homebrew Cask Taps:", ([default_cask_tap, *alt_taps].map do |tap|
-          if tap.path.blank?
-            none_string
-          else
-            cask_count = begin
-              tap.cask_files.count
-            rescue
-              error_tap_paths << tap.path
-              0
-            end
+        taps = (Tap.to_a + [CoreCaskTap.instance]).uniq
 
-            "#{tap.path} (#{cask_count} #{"cask".pluralize(cask_count)})"
+        taps_info = taps.filter_map do |tap|
+          cask_count = begin
+            tap.cask_files.count
+          rescue
+            error_tap_paths << tap.path
+            0
           end
-        end)
+          next if cask_count.zero?
 
-        taps = "tap".pluralize error_tap_paths.count
-        "Unable to read from cask #{taps}: #{error_tap_paths.to_sentence}" if error_tap_paths.present?
+          "#{tap.path} (#{Utils.pluralize("cask", cask_count, include_count: true)})"
+        end
+        add_info "Homebrew Cask Taps:", taps_info
+
+        taps_string = Utils.pluralize("tap", error_tap_paths.count)
+        "Unable to read from cask #{taps_string}: #{error_tap_paths.to_sentence}" if error_tap_paths.present?
       end
 
       def check_cask_load_path
-        paths = $LOAD_PATH.map(&method(:user_tilde))
+        paths = $LOAD_PATH.map { user_tilde(_1) }
 
         add_info "$LOAD_PATHS", paths.presence || none_string
 
@@ -1045,11 +1028,11 @@ def check_cask_quarantine_support
         when :quarantine_available
           nil
         when :xattr_broken
-          "There's no working version of `xattr` on this system."
+          "No Cask quarantine support available: there's no working version of `xattr` on this system."
         when :no_swift
-          "Swift is not available on this system."
+          "No Cask quarantine support available: there's no available version of `swift` on this system."
         else
-          "Unknown support status"
+          "No Cask quarantine support available: unknown reason."
         end
       end
 
@@ -1060,6 +1043,10 @@ def all
       def cask_checks
         all.grep(/^check_cask_/)
       end
+
+      def current_user
+        ENV.fetch("USER", "$(whoami)")
+      end
     end
   end
 end
diff --git a/Library/Homebrew/download_queue.rb b/Library/Homebrew/download_queue.rb
new file mode 100644
index 0000000000000..e591c3f2ae5e5
--- /dev/null
+++ b/Library/Homebrew/download_queue.rb
@@ -0,0 +1,45 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "downloadable"
+require "concurrent/promises"
+require "concurrent/executors"
+
+module Homebrew
+  class DownloadQueue
+    sig { returns(Concurrent::FixedThreadPool) }
+    attr_reader :pool
+    private :pool
+
+    sig { params(size: Integer).void }
+    def initialize(size = 1)
+      @pool = Concurrent::FixedThreadPool.new(size)
+    end
+
+    sig { params(downloadable: Downloadable, force: T::Boolean).returns(Concurrent::Promises::Future) }
+    def enqueue(downloadable, force: false)
+      quiet = pool.max_length > 1
+      # Passing in arguments from outside into the future is a common  `concurrent-ruby` pattern.
+      # rubocop:disable Lint/ShadowingOuterLocalVariable
+      Concurrent::Promises.future_on(pool, downloadable, force, quiet) do |downloadable, force, quiet|
+        downloadable.clear_cache if force
+        downloadable.fetch(quiet:)
+      end
+      # rubocop:enable Lint/ShadowingOuterLocalVariable
+    end
+
+    sig { void }
+    def cancel
+      # FIXME: Implement graceful cancellaction of running downloads based on
+      #        https://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Cancellation.html
+      #        instead of killing the whole thread pool.
+      pool.kill
+    end
+
+    sig { void }
+    def shutdown
+      pool.shutdown
+      pool.wait_for_termination
+    end
+  end
+end
diff --git a/Library/Homebrew/download_strategy.rb b/Library/Homebrew/download_strategy.rb
index a11c1776541f0..09858f5f6998f 100644
--- a/Library/Homebrew/download_strategy.rb
+++ b/Library/Homebrew/download_strategy.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "json"
@@ -7,31 +7,33 @@
 require "lazy_object"
 require "cgi"
 require "lock_file"
+require "system_command"
 
-require "mechanize/version"
-require "mechanize/http/content_disposition_parser"
+# Need to define this before requiring Mechanize to avoid:
+#   uninitialized constant Mechanize
+# rubocop:disable Lint/EmptyClass
+class Mechanize; end
+require "vendor/gems/mechanize/lib/mechanize/http/content_disposition_parser"
+# rubocop:enable Lint/EmptyClass
 
 require "utils/curl"
+require "utils/github"
+require "utils/timer"
 
 require "github_packages"
 
-require "extend/time"
-using TimeRemaining
-
 # @abstract Abstract superclass for all download strategies.
-#
-# @api private
 class AbstractDownloadStrategy
-  extend T::Sig
-
-  extend Forwardable
   include FileUtils
   include Context
+  include SystemCommand::Mixin
 
   # Extension for bottle downloads.
-  #
-  # @api private
   module Pourable
+    extend T::Helpers
+
+    requires_ancestor { AbstractDownloadStrategy }
+
     def stage
       ohai "Pouring #{basename}"
       super
@@ -71,11 +73,9 @@ def fetch(timeout: nil); end
 
   # Disable any output during downloading.
   #
-  # TODO: Deprecate once we have an explicitly documented alternative.
-  #
   # @api public
   sig { void }
-  def shutup!
+  def quiet!
     @quiet = true
   end
 
@@ -94,32 +94,31 @@ def quiet?
   # @api public
   def stage(&block)
     UnpackStrategy.detect(cached_location,
-                          prioritise_extension: true,
+                          prioritize_extension: true,
                           ref_type: @ref_type, ref: @ref)
-                  .extract_nestedly(basename:             basename,
-                                    prioritise_extension: true,
+                  .extract_nestedly(basename:,
+                                    prioritize_extension: true,
                                     verbose:              verbose? && !quiet?)
     chdir(&block) if block
   end
 
   def chdir(&block)
     entries = Dir["*"]
-    raise "Empty archive" if entries.length.zero?
+    raise "Empty archive" if entries.empty?
 
     if entries.length != 1
       yield
       return
     end
 
-    if File.directory? entries.first
-      Dir.chdir(entries.first, &block)
+    if File.directory? entries.fetch(0)
+      Dir.chdir(entries.fetch(0), &block)
     else
       yield
     end
   end
   private :chdir
 
-  # @!attribute [r] source_modified_time
   # Returns the most recent modified time for all files in the current working directory after stage.
   #
   # @api public
@@ -143,15 +142,15 @@ def basename
   private
 
   def puts(*args)
-    super(*args) unless quiet?
+    super unless quiet?
   end
 
   def ohai(*args)
-    super(*args) unless quiet?
+    super unless quiet?
   end
 
   def silent_command(*args, **options)
-    system_command(*args, print_stderr: false, env: env, **options)
+    system_command(*args, print_stderr: false, env:, **options)
   end
 
   def command!(*args, **options)
@@ -177,8 +176,6 @@ def env
 end
 
 # @abstract Abstract superclass for all download strategies downloading from a version control system.
-#
-# @api private
 class VCSDownloadStrategy < AbstractDownloadStrategy
   REF_TYPES = [:tag, :branch, :revisions, :revision].freeze
 
@@ -186,7 +183,7 @@ def initialize(url, name, version, **meta)
     super
     @ref_type, @ref = extract_ref(meta)
     @revision = meta[:revision]
-    @cached_location = @cache/"#{name}--#{cache_tag}"
+    @cached_location = @cache/Utils.safe_filename("#{name}--#{cache_tag}")
   end
 
   # Download and cache the repository at {#cached_location}.
@@ -199,7 +196,7 @@ def fetch(timeout: nil)
 
     if cached_location.exist? && repo_valid?
       puts "Updating #{cached_location}"
-      update(timeout: timeout)
+      update(timeout: end_time)
     elsif cached_location.exist?
       puts "Removing invalid repository from cache"
       clear_cache
@@ -232,9 +229,7 @@ def head?
     version.respond_to?(:head?) && version.head?
   end
 
-  # @!attribute [r] last_commit
-  # Return last commit's unique identifier for the repository.
-  # Return most recent modified timestamp unless overridden.
+  # Return the most recent modified timestamp.
   #
   # @api public
   sig { returns(String) }
@@ -267,8 +262,6 @@ def extract_ref(specs)
 end
 
 # @abstract Abstract superclass for all download strategies downloading a single file.
-#
-# @api private
 class AbstractFileDownloadStrategy < AbstractDownloadStrategy
   # Path for storing an incomplete download while the download is still in progress.
   #
@@ -285,7 +278,7 @@ def symlink_location
     return @symlink_location if defined?(@symlink_location)
 
     ext = Pathname(parse_basename(url)).extname
-    @symlink_location = @cache/"#{name}--#{version}#{ext}"
+    @symlink_location = @cache/Utils.safe_filename("#{name}--#{version}#{ext}")
   end
 
   # Path for storing the completed download.
@@ -301,7 +294,7 @@ def cached_location
     @cached_location = if downloads.count == 1
       downloads.first
     else
-      HOMEBREW_CACHE/"downloads/#{url_sha256}--#{resolved_basename}"
+      HOMEBREW_CACHE/"downloads/#{url_sha256}--#{Utils.safe_filename(resolved_basename)}"
     end
   end
 
@@ -327,8 +320,11 @@ def resolved_url_and_basename
     @resolved_url_and_basename = [url, parse_basename(url)]
   end
 
+  sig { params(url: String, search_query: T::Boolean).returns(String) }
   def parse_basename(url, search_query: true)
-    uri_path = if url.match?(URI::DEFAULT_PARSER.make_regexp)
+    components = { path: T.let([], T::Array[String]), query: T.let([], T::Array[String]) }
+
+    if url.match?(URI::DEFAULT_PARSER.make_regexp)
       uri = URI(url)
 
       if uri.query
@@ -339,29 +335,32 @@ def parse_basename(url, search_query: true)
         end
       end
 
-      if uri.query && search_query
-        "#{uri.path}?#{uri.query}"
-      else
-        uri.path
+      if (uri_path = uri.path.presence)
+        components[:path] = uri_path.split("/").filter_map do |part|
+          URI::DEFAULT_PARSER.unescape(part).presence
+        end
+      end
+
+      if search_query && (uri_query = uri.query.presence)
+        components[:query] = URI.decode_www_form(uri_query).map { _2 }
       end
     else
-      url
+      components[:path] = [url]
     end
 
-    uri_path = URI.decode_www_form_component(uri_path)
-    query_regex = /[^?&]+/
-
     # We need a Pathname because we've monkeypatched extname to support double
     # extensions (e.g. tar.gz).
     # Given a URL like https://example.com/download.php?file=foo-1.0.tar.gz
     # the basename we want is "foo-1.0.tar.gz", not "download.php".
-    Pathname.new(uri_path).ascend do |path|
-      ext = path.extname[query_regex]
-      return path.basename.to_s[/#{query_regex.source}#{Regexp.escape(ext)}/] if ext
+    [*components[:path], *components[:query]].reverse_each do |path|
+      path = Pathname(path)
+      return path.basename.to_s if path.extname.present?
     end
 
-    # Strip query string
-    File.basename(uri_path)[query_regex]
+    filename = components[:path].last
+    return "" if filename.blank?
+
+    File.basename(filename)
   end
 end
 
@@ -374,9 +373,16 @@ class CurlDownloadStrategy < AbstractFileDownloadStrategy
   attr_reader :mirrors
 
   def initialize(url, name, version, **meta)
-    super
     @try_partial = true
     @mirrors = meta.fetch(:mirrors, [])
+
+    # Merge `:header` with `:headers`.
+    if (header = meta.delete(:header))
+      meta[:headers] ||= []
+      meta[:headers] << header
+    end
+
+    super
   end
 
   # Download and cache the file at {#cached_location}.
@@ -385,7 +391,7 @@ def initialize(url, name, version, **meta)
   def fetch(timeout: nil)
     end_time = Time.now + timeout if timeout
 
-    download_lock = LockFile.new(temporary_path.basename)
+    download_lock = DownloadLock.new(temporary_path)
     download_lock.lock
 
     urls = [url, *mirrors]
@@ -393,36 +399,41 @@ def fetch(timeout: nil)
     begin
       url = urls.shift
 
+      if (domain = Homebrew::EnvConfig.artifact_domain)
+        url = url.sub(%r{^https?://#{GitHubPackages::URL_DOMAIN}/}o, "#{domain.chomp("/")}/")
+        urls = [] if Homebrew::EnvConfig.artifact_domain_no_fallback?
+      end
+
       ohai "Downloading #{url}"
 
-      resolved_url, _, url_time, _, is_redirection =
-        resolve_url_basename_time_file_size(url, timeout: end_time&.remaining!)
+      use_cached_location = cached_location.exist?
+      use_cached_location = false if version.respond_to?(:latest?) && version.latest?
+
+      resolved_url, _, last_modified, _, is_redirection = begin
+        resolve_url_basename_time_file_size(url, timeout: Utils::Timer.remaining!(end_time))
+      rescue ErrorDuringExecution
+        raise unless use_cached_location
+      end
+
       # Authorization is no longer valid after redirects
       meta[:headers]&.delete_if { |header| header.start_with?("Authorization") } if is_redirection
 
-      fresh = if cached_location.exist? && url_time
-        url_time <= cached_location.mtime
-      elsif version.respond_to?(:latest?)
-        !version.latest?
-      else
-        true
-      end
+      # The cached location is no longer fresh if Last-Modified is after the file's timestamp
+      use_cached_location = false if cached_location.exist? && last_modified && last_modified > cached_location.mtime
 
-      if cached_location.exist? && fresh
+      if use_cached_location
         puts "Already downloaded: #{cached_location}"
       else
         begin
-          _fetch(url: url, resolved_url: resolved_url, timeout: end_time&.remaining!)
+          _fetch(url:, resolved_url:, timeout: Utils::Timer.remaining!(end_time))
         rescue ErrorDuringExecution
           raise CurlDownloadStrategyError, url
         end
-        ignore_interrupts do
-          cached_location.dirname.mkpath
-          temporary_path.rename(cached_location)
-          symlink_location.dirname.mkpath
-        end
+        cached_location.dirname.mkpath
+        temporary_path.rename(cached_location)
       end
 
+      symlink_location.dirname.mkpath
       FileUtils.ln_s cached_location.relative_path_from(symlink_location.dirname), symlink_location, force: true
     rescue CurlDownloadStrategyError
       raise if urls.empty?
@@ -443,7 +454,7 @@ def clear_cache
   end
 
   def resolved_time_file_size(timeout: nil)
-    _, _, time, file_size = resolve_url_basename_time_file_size(url, timeout: timeout)
+    _, _, time, file_size = resolve_url_basename_time_file_size(url, timeout:)
     [time, file_size]
   end
 
@@ -458,20 +469,15 @@ def resolve_url_basename_time_file_size(url, timeout: nil)
     @resolved_info_cache ||= {}
     return @resolved_info_cache[url] if @resolved_info_cache.include?(url)
 
-    if (domain = Homebrew::EnvConfig.artifact_domain)
-      url = url.sub(%r{^https?://#{GitHubPackages::URL_DOMAIN}/}o, "#{domain.chomp("/")}/")
+    begin
+      parsed_output = curl_headers(url.to_s, wanted_headers: ["content-disposition"], timeout:)
+    rescue ErrorDuringExecution
+      return [url, parse_basename(url), nil, nil, false]
     end
 
-    output, _, _status = curl_output(
-      "--location", "--silent", "--head", "--request", "GET", url.to_s,
-      timeout: timeout
-    )
-    parsed_output = parse_curl_output(output)
-
-    lines = output.to_s.lines.map(&:chomp)
+    parsed_headers = parsed_output.fetch(:responses).map { |r| r.fetch(:headers) }
 
-    final_url = curl_response_last_location(parsed_output[:responses], absolutize: true, base_url: url)
-    final_url ||= url
+    final_url = curl_response_follow_redirections(parsed_output.fetch(:responses), url)
 
     content_disposition_parser = Mechanize::HTTP::ContentDispositionParser.new
 
@@ -482,33 +488,46 @@ def resolve_url_basename_time_file_size(url, timeout: nil)
 
       if (filename_with_encoding = content_disposition.parameters["filename*"])
         encoding, encoded_filename = filename_with_encoding.split("''", 2)
-        filename = URI.decode_www_form_component(encoded_filename).encode(encoding) if encoding && encoded_filename
+        # If the `filename*` has incorrectly added double quotes, e.g.
+        #   content-disposition: attachment; filename="myapp-1.2.3.pkg"; filename*=UTF-8''"myapp-1.2.3.pkg"
+        # Then the encoded_filename will come back as the empty string, in which case we should fall back to the
+        # `filename` parameter.
+        if encoding.present? && encoded_filename.present?
+          filename = URI.decode_www_form_component(encoded_filename).encode(encoding)
+        end
       end
 
+      filename = content_disposition.filename if filename.blank?
+      next if filename.blank?
+
       # Servers may include '/' in their Content-Disposition filename header. Take only the basename of this, because:
       # - Unpacking code assumes this is a single file - not something living in a subdirectory.
       # - Directory traversal attacks are possible without limiting this to just the basename.
-      File.basename(filename || content_disposition.filename)
+      File.basename(filename)
     end
 
-    filenames = lines.map(&parse_content_disposition).compact
+    filenames = parsed_headers.flat_map do |headers|
+      next [] unless (header = headers["content-disposition"])
 
-    time =
-      lines.map { |line| line[/^Last-Modified:\s*(.+)/i, 1] }
-           .compact
-           .map { |t| t.match?(/^\d+$/) ? Time.at(t.to_i) : Time.parse(t) }
-           .last
+      [*parse_content_disposition.call("Content-Disposition: #{header}")]
+    end
+
+    time =  parsed_headers
+            .flat_map { |headers| [*headers["last-modified"]] }
+            .filter_map do |t|
+              t.match?(/^\d+$/) ? Time.at(t.to_i) : Time.parse(t)
+            rescue ArgumentError # When `Time.parse` gets a badly formatted date.
+              nil
+            end
 
-    file_size =
-      lines.map { |line| line[/^Content-Length:\s*(\d+)/i, 1] }
-           .compact
-           .map(&:to_i)
-           .last
+    file_size = parsed_headers
+                .flat_map { |headers| [*headers["content-length"]&.to_i] }
+                .last
 
     is_redirection = url != final_url
     basename = filenames.last || parse_basename(final_url, search_query: !is_redirection)
 
-    @resolved_info_cache[url] = [final_url, basename, time, file_size, is_redirection]
+    @resolved_info_cache[url] = [final_url, basename, time.last, file_size, is_redirection]
   end
 
   def _fetch(url:, resolved_url:, timeout:)
@@ -524,7 +543,7 @@ def _fetch(url:, resolved_url:, timeout:)
   end
 
   def _curl_download(resolved_url, to, timeout)
-    curl_download resolved_url, to: to, try_partial: @try_partial, timeout: timeout
+    curl_download resolved_url, to:, try_partial: @try_partial, timeout:
   end
 
   # Curl options to be always passed to curl,
@@ -538,13 +557,11 @@ def _curl_args
 
     args += ["--user", meta.fetch(:user)] if meta.key?(:user)
 
-    args += [meta[:header], meta[:headers]].flatten.compact.flat_map { |h| ["--header", h.strip] }
+    args += meta.fetch(:headers, []).flat_map { |h| ["--header", h.strip] }
 
     if meta[:insecure]
       unless @insecure_warning_shown
-        opoo "Using --insecure with curl to download `ca-certificates` " \
-             "because we need it installed to download securely from now on. " \
-             "Checksums will still be verified."
+        opoo DevelopmentTools.insecure_download_warning("an updated certificates file")
         @insecure_warning_shown = true
       end
       args += ["--insecure"]
@@ -578,7 +595,14 @@ class HomebrewCurlDownloadStrategy < CurlDownloadStrategy
   def _curl_download(resolved_url, to, timeout)
     raise HomebrewCurlDownloadStrategyError, url unless Formula["curl"].any_version_installed?
 
-    curl_download resolved_url, to: to, try_partial: @try_partial, timeout: timeout, use_homebrew_curl: true
+    curl_download resolved_url, to:, try_partial: @try_partial, timeout:, use_homebrew_curl: true
+  end
+
+  def curl_output(*args, **options)
+    raise HomebrewCurlDownloadStrategyError, url unless Formula["curl"].any_version_installed?
+
+    options[:use_homebrew_curl] = true
+    super
   end
 end
 
@@ -589,18 +613,19 @@ class CurlGitHubPackagesDownloadStrategy < CurlDownloadStrategy
   attr_writer :resolved_basename
 
   def initialize(url, name, version, **meta)
-    meta ||= {}
     meta[:headers] ||= []
     # GitHub Packages authorization header.
     # HOMEBREW_GITHUB_PACKAGES_AUTH set in brew.sh
     meta[:headers] << "Authorization: #{HOMEBREW_GITHUB_PACKAGES_AUTH}"
-    super(url, name, version, meta)
+    super
   end
 
   private
 
-  def resolved_basename
-    @resolved_basename.presence || super
+  def resolve_url_basename_time_file_size(url, timeout: nil)
+    return super if @resolved_basename.blank?
+
+    [url, @resolved_basename, nil, nil, false]
   end
 end
 
@@ -617,15 +642,22 @@ def mirrors
   def combined_mirrors
     return @combined_mirrors if defined?(@combined_mirrors)
 
-    backup_mirrors = apache_mirrors.fetch("backup", [])
-                                   .map { |mirror| "#{mirror}#{apache_mirrors["path_info"]}" }
+    backup_mirrors = unless apache_mirrors["in_attic"]
+      apache_mirrors.fetch("backup", [])
+                    .map { |mirror| "#{mirror}#{apache_mirrors["path_info"]}" }
+    end
 
     @combined_mirrors = [*@mirrors, *backup_mirrors]
   end
 
   def resolve_url_basename_time_file_size(url, timeout: nil)
     if url == self.url
-      super("#{apache_mirrors["preferred"]}#{apache_mirrors["path_info"]}", timeout: timeout)
+      preferred = if apache_mirrors["in_attic"]
+        "https://archive.apache.org/dist/"
+      else
+        apache_mirrors["preferred"]
+      end
+      super("#{preferred}#{apache_mirrors["path_info"]}", timeout:)
     else
       super
     end
@@ -657,7 +689,7 @@ def _fetch(url:, resolved_url:, timeout:)
       query.nil? ? [url, "-X", "POST"] : [url, "-d", query]
     end
 
-    curl_download(*args, to: temporary_path, try_partial: @try_partial, timeout: timeout)
+    curl_download(*args, to: temporary_path, try_partial: @try_partial, timeout:)
   end
 end
 
@@ -668,28 +700,28 @@ def _fetch(url:, resolved_url:, timeout:)
 class NoUnzipCurlDownloadStrategy < CurlDownloadStrategy
   def stage
     UnpackStrategy::Uncompressed.new(cached_location)
-                                .extract(basename: basename,
+                                .extract(basename:,
                                          verbose:  verbose? && !quiet?)
     yield if block_given?
   end
 end
 
 # Strategy for extracting local binary packages.
-#
-# @api private
 class LocalBottleDownloadStrategy < AbstractFileDownloadStrategy
   def initialize(path) # rubocop:disable Lint/MissingSuper
     @cached_location = path
     extend Pourable
   end
+
+  def clear_cache
+    # Path is used directly and not cached.
+  end
 end
 
 # Strategy for downloading a Subversion repository.
 #
 # @api public
 class SubversionDownloadStrategy < VCSDownloadStrategy
-  extend T::Sig
-
   def initialize(url, name, version, **meta)
     super
     @url = @url.sub("svn+http://", "")
@@ -705,11 +737,14 @@ def fetch(timeout: nil)
     super
   end
 
-  # @see AbstractDownloadStrategy#source_modified_time
+  # Returns the most recent modified time for all files in the current working directory after stage.
+  #
   # @api public
   sig { returns(Time) }
   def source_modified_time
-    time = if Version.create(Utils::Svn.version) >= Version.create("1.9")
+    require "utils/svn"
+
+    time = if Version.new(T.must(Utils::Svn.version)) >= Version.new("1.9")
       out, = silent_command("svn", args: ["info", "--show-item", "last-changed-date"], chdir: cached_location)
       out
     else
@@ -719,7 +754,8 @@ def source_modified_time
     Time.parse time
   end
 
-  # @see VCSDownloadStrategy#last_commit
+  # Return last commit's unique identifier for the repository.
+  #
   # @api public
   sig { returns(String) }
   def last_commit
@@ -760,12 +796,13 @@ def fetch_repo(target, url, revision = nil, ignore_externals: false, timeout: ni
 
     args << "--ignore-externals" if ignore_externals
 
+    require "utils/svn"
     args.concat Utils::Svn.invalid_cert_flags if meta[:trust_cert] == true
 
     if target.directory?
-      command! "svn", args: ["update", *args], chdir: target.to_s, timeout: timeout&.remaining
+      command! "svn", args: ["update", *args], chdir: target.to_s, timeout: Utils::Timer.remaining(timeout)
     else
-      command! "svn", args: ["checkout", url, target, *args], timeout: timeout&.remaining
+      command! "svn", args: ["checkout", url, target, *args], timeout: Utils::Timer.remaining(timeout)
     end
   end
 
@@ -782,18 +819,18 @@ def repo_valid?
   def clone_repo(timeout: nil)
     case @ref_type
     when :revision
-      fetch_repo cached_location, @url, @ref, timeout: timeout
+      fetch_repo cached_location, @url, @ref, timeout:
     when :revisions
       # nil is OK for main_revision, as fetch_repo will then get latest
       main_revision = @ref[:trunk]
-      fetch_repo cached_location, @url, main_revision, ignore_externals: true, timeout: timeout
+      fetch_repo(cached_location, @url, main_revision, ignore_externals: true, timeout:)
 
       externals do |external_name, external_url|
         fetch_repo cached_location/external_name, external_url, @ref[external_name], ignore_externals: true,
-                                                                                     timeout:          timeout
+                                                                                     timeout:
       end
     else
-      fetch_repo cached_location, @url, timeout: timeout
+      fetch_repo cached_location, @url, timeout:
     end
   end
   alias update clone_repo
@@ -804,12 +841,23 @@ def clone_repo(timeout: nil)
 # @api public
 class GitDownloadStrategy < VCSDownloadStrategy
   def initialize(url, name, version, **meta)
+    # Needs to be before the call to `super`, as the VCSDownloadStrategy's
+    # constructor calls `cache_tag` and sets the cache path.
+    @only_path = meta[:only_path]
+
+    if @only_path.present?
+      # "Cone" mode of sparse checkout requires patterns to be directories
+      @only_path = "/#{@only_path}" unless @only_path.start_with?("/")
+      @only_path = "#{@only_path}/" unless @only_path.end_with?("/")
+    end
+
     super
     @ref_type ||= :branch
     @ref ||= "master"
   end
 
-  # @see AbstractDownloadStrategy#source_modified_time
+  # Returns the most recent modified time for all files in the current working directory after stage.
+  #
   # @api public
   sig { returns(Time) }
   def source_modified_time
@@ -817,9 +865,10 @@ def source_modified_time
     Time.parse(out)
   end
 
-  # @see VCSDownloadStrategy#last_commit
-  sig { returns(String) }
+  # Return last commit's unique identifier for the repository.
+  #
   # @api public
+  sig { returns(String) }
   def last_commit
     out, = silent_command("git", args: ["--git-dir", git_dir, "rev-parse", "--short=7", "HEAD"])
     out.chomp
@@ -829,7 +878,11 @@ def last_commit
 
   sig { returns(String) }
   def cache_tag
-    "git"
+    if partial_clone_sparse_checkout?
+      "git-sparse"
+    else
+      "git"
+    end
   end
 
   sig { returns(Integer) }
@@ -840,10 +893,10 @@ def cache_version
   sig { params(timeout: T.nilable(Time)).void }
   def update(timeout: nil)
     config_repo
-    update_repo(timeout: timeout)
-    checkout(timeout: timeout)
+    update_repo(timeout:)
+    checkout(timeout:)
     reset
-    update_submodules(timeout: timeout) if submodules?
+    update_submodules(timeout:) if submodules?
   end
 
   def shallow_dir?
@@ -873,6 +926,13 @@ def submodules?
     (cached_location/".gitmodules").exist?
   end
 
+  def partial_clone_sparse_checkout?
+    return false if @only_path.blank?
+
+    require "utils/git"
+    Utils::Git.supports_partial_clone_sparse_checkout?
+  end
+
   sig { returns(T::Array[String]) }
   def clone_args
     args = %w[clone]
@@ -882,8 +942,11 @@ def clone_args
       args << "--branch" << @ref
     end
 
-    args << "-c" << "advice.detachedHead=false" # silences detached head warning
-    args << @url << cached_location
+    args << "--no-checkout" << "--filter=blob:none" if partial_clone_sparse_checkout?
+
+    args << "--config" << "advice.detachedHead=false" # Silences “detached head” warning.
+    args << "--config" << "core.fsmonitor=false" # Prevent `fsmonitor` from watching this repository.
+    args << @url << cached_location.to_s
   end
 
   sig { returns(String) }
@@ -915,6 +978,16 @@ def config_repo
     command! "git",
              args:  ["config", "advice.detachedHead", "false"],
              chdir: cached_location
+    command! "git",
+             args:  ["config", "core.fsmonitor", "false"],
+             chdir: cached_location
+
+    return unless partial_clone_sparse_checkout?
+
+    command! "git",
+             args:  ["config", "origin.partialclonefilter", "blob:none"],
+             chdir: cached_location
+    configure_sparse_checkout
   end
 
   sig { params(timeout: T.nilable(Time)).void }
@@ -926,31 +999,35 @@ def update_repo(timeout: nil)
       command! "git",
                args:    ["fetch", "origin", "--unshallow"],
                chdir:   cached_location,
-               timeout: timeout&.remaining
+               timeout: Utils::Timer.remaining(timeout)
     else
       command! "git",
                args:    ["fetch", "origin"],
                chdir:   cached_location,
-               timeout: timeout&.remaining
+               timeout: Utils::Timer.remaining(timeout)
     end
   end
 
   sig { params(timeout: T.nilable(Time)).void }
   def clone_repo(timeout: nil)
-    command! "git", args: clone_args, timeout: timeout&.remaining
+    command! "git", args: clone_args, timeout: Utils::Timer.remaining(timeout)
 
     command! "git",
              args:    ["config", "homebrew.cacheversion", cache_version],
              chdir:   cached_location,
-             timeout: timeout&.remaining
-    checkout(timeout: timeout)
-    update_submodules(timeout: timeout) if submodules?
+             timeout: Utils::Timer.remaining(timeout)
+
+    configure_sparse_checkout if partial_clone_sparse_checkout?
+
+    checkout(timeout:)
+    update_submodules(timeout:) if submodules?
   end
 
   sig { params(timeout: T.nilable(Time)).void }
   def checkout(timeout: nil)
     ohai "Checking out #{@ref_type} #{@ref}" if @ref_type && @ref
-    command! "git", args: ["checkout", "-f", @ref, "--"], chdir: cached_location, timeout: timeout&.remaining
+    command! "git", args: ["checkout", "-f", @ref, "--"], chdir: cached_location,
+                    timeout: Utils::Timer.remaining(timeout)
   end
 
   sig { void }
@@ -970,13 +1047,15 @@ def reset
   sig { params(timeout: T.nilable(Time)).void }
   def update_submodules(timeout: nil)
     command! "git",
-             args:    ["submodule", "foreach", "--recursive", "git submodule sync"],
-             chdir:   cached_location,
-             timeout: timeout&.remaining
+             args:      ["submodule", "foreach", "--recursive", "git submodule sync"],
+             chdir:     cached_location,
+             timeout:   Utils::Timer.remaining(timeout),
+             reset_uid: true
     command! "git",
-             args:    ["submodule", "update", "--init", "--recursive"],
-             chdir:   cached_location,
-             timeout: timeout&.remaining
+             args:      ["submodule", "update", "--init", "--recursive"],
+             chdir:     cached_location,
+             timeout:   Utils::Timer.remaining(timeout),
+             reset_uid: true
     fix_absolute_submodule_gitdir_references!
   end
 
@@ -989,8 +1068,9 @@ def update_submodules(timeout: nil)
   # See https://github.com/Homebrew/homebrew-core/pull/1520 for an example.
   def fix_absolute_submodule_gitdir_references!
     submodule_dirs = command!("git",
-                              args:  ["submodule", "--quiet", "foreach", "--recursive", "pwd"],
-                              chdir: cached_location).stdout
+                              args:      ["submodule", "--quiet", "foreach", "--recursive", "pwd"],
+                              chdir:     cached_location,
+                              reset_uid: true).stdout
 
     submodule_dirs.lines.map(&:chomp).each do |submodule_dir|
       work_dir = Pathname.new(submodule_dir)
@@ -1013,6 +1093,18 @@ def fix_absolute_submodule_gitdir_references!
       dot_git.atomic_write("gitdir: #{relative_git_dir}\n")
     end
   end
+
+  def configure_sparse_checkout
+    command! "git",
+             args:  ["config", "core.sparseCheckout", "true"],
+             chdir: cached_location
+    command! "git",
+             args:  ["config", "core.sparseCheckoutCone", "true"],
+             chdir: cached_location
+
+    (git_dir/"info").mkpath
+    (git_dir/"info/sparse-checkout").atomic_write("#{@only_path}\n")
+  end
 end
 
 # Strategy for downloading a Git repository from GitHub.
@@ -1022,49 +1114,20 @@ class GitHubGitDownloadStrategy < GitDownloadStrategy
   def initialize(url, name, version, **meta)
     super
 
-    return unless %r{^https?://github\.com/(?<user>[^/]+)/(?<repo>[^/]+)\.git$} =~ @url
-
-    @user = user
-    @repo = repo
-  end
-
-  def github_last_commit
-    # TODO: move to Utils::GitHub
-    return if Homebrew::EnvConfig.no_github_api?
-
-    output, _, status = curl_output(
-      "--silent", "--head", "--location",
-      "-H", "Accept: application/vnd.github.v3.sha",
-      "https://api.github.com/repos/#{@user}/#{@repo}/commits/#{@ref}"
-    )
-
-    return unless status.success?
+    match_data = %r{^https?://github\.com/(?<user>[^/]+)/(?<repo>[^/]+)\.git$}.match(@url)
+    return unless match_data
 
-    commit = output[/^ETag: "(\h+)"/, 1]
-    version.update_commit(commit) if commit
-    commit
-  end
-
-  def multiple_short_commits_exist?(commit)
-    # TODO: move to Utils::GitHub
-    return if Homebrew::EnvConfig.no_github_api?
-
-    output, _, status = curl_output(
-      "--silent", "--head", "--location",
-      "-H", "Accept: application/vnd.github.v3.sha",
-      "https://api.github.com/repos/#{@user}/#{@repo}/commits/#{commit}"
-    )
-
-    !(status.success? && output && output[/^Status: (200)/, 1] == "200")
+    @user = match_data[:user]
+    @repo = match_data[:repo]
   end
 
   def commit_outdated?(commit)
-    @last_commit ||= github_last_commit
+    @last_commit ||= GitHub.last_commit(@user, @repo, @ref, version)
     if @last_commit
       return true unless commit
       return true unless @last_commit.start_with?(commit)
 
-      if multiple_short_commits_exist?(commit)
+      if GitHub.multiple_short_commits_exist?(@user, @repo, commit)
         true
       else
         version.update_commit(commit)
@@ -1084,7 +1147,7 @@ def default_refspec
     end
   end
 
-  sig { returns(String) }
+  sig { returns(T.nilable(String)) }
   def default_branch
     return @default_branch if defined?(@default_branch)
 
@@ -1104,8 +1167,6 @@ def default_branch
 #
 # @api public
 class CVSDownloadStrategy < VCSDownloadStrategy
-  extend T::Sig
-
   def initialize(url, name, version, **meta)
     super
     @url = @url.sub(%r{^cvs://}, "")
@@ -1119,7 +1180,8 @@ def initialize(url, name, version, **meta)
     end
   end
 
-  # @see AbstractDownloadStrategy#source_modified_time
+  # Returns the most recent modified time for all files in the current working directory after stage.
+  #
   # @api public
   sig { returns(Time) }
   def source_modified_time
@@ -1158,12 +1220,15 @@ def quiet_flag
   sig { params(timeout: T.nilable(Time)).void }
   def clone_repo(timeout: nil)
     # Login is only needed (and allowed) with pserver; skip for anoncvs.
-    command! "cvs", args: [*quiet_flag, "-d", @url, "login"], timeout: timeout&.remaining if @url.include? "pserver"
+    if @url.include? "pserver"
+      command! "cvs", args:    [*quiet_flag, "-d", @url, "login"],
+                      timeout: Utils::Timer.remaining(timeout)
+    end
 
     command! "cvs",
              args:    [*quiet_flag, "-d", @url, "checkout", "-d", cached_location.basename, @module],
              chdir:   cached_location.dirname,
-             timeout: timeout&.remaining
+             timeout: Utils::Timer.remaining(timeout)
   end
 
   sig { params(timeout: T.nilable(Time)).void }
@@ -1171,7 +1236,7 @@ def update(timeout: nil)
     command! "cvs",
              args:    [*quiet_flag, "update"],
              chdir:   cached_location,
-             timeout: timeout&.remaining
+             timeout: Utils::Timer.remaining(timeout)
   end
 
   def split_url(in_url)
@@ -1186,14 +1251,13 @@ def split_url(in_url)
 #
 # @api public
 class MercurialDownloadStrategy < VCSDownloadStrategy
-  extend T::Sig
-
   def initialize(url, name, version, **meta)
     super
     @url = @url.sub(%r{^hg://}, "")
   end
 
-  # @see AbstractDownloadStrategy#source_modified_time
+  # Returns the most recent modified time for all files in the current working directory after stage.
+  #
   # @api public
   sig { returns(Time) }
   def source_modified_time
@@ -1203,7 +1267,8 @@ def source_modified_time
     Time.parse(out)
   end
 
-  # @see VCSDownloadStrategy#last_commit
+  # Return last commit's unique identifier for the repository.
+  #
   # @api public
   sig { returns(String) }
   def last_commit
@@ -1228,21 +1293,46 @@ def repo_valid?
 
   sig { params(timeout: T.nilable(Time)).void }
   def clone_repo(timeout: nil)
-    command! "hg", args: ["clone", @url, cached_location], timeout: timeout&.remaining
+    clone_args = %w[clone]
+
+    case @ref_type
+    when :branch
+      clone_args << "--branch" << @ref
+    when :revision, :tag
+      clone_args << "--rev" << @ref
+    end
+
+    clone_args << @url << cached_location.to_s
+    command! "hg", args: clone_args, timeout: Utils::Timer.remaining(timeout)
   end
 
   sig { params(timeout: T.nilable(Time)).void }
   def update(timeout: nil)
-    command! "hg", args: ["--cwd", cached_location, "pull", "--update"], timeout: timeout&.remaining
+    pull_args = %w[pull]
+
+    case @ref_type
+    when :branch
+      pull_args << "--branch" << @ref
+    when :revision, :tag
+      pull_args << "--rev" << @ref
+    end
 
-    update_args = if @ref_type && @ref
+    command! "hg", args: ["--cwd", cached_location, *pull_args], timeout: Utils::Timer.remaining(timeout)
+
+    update_args = %w[update --clean]
+    update_args << if @ref_type && @ref
       ohai "Checking out #{@ref_type} #{@ref}"
-      [@ref]
+      @ref
     else
-      ["--clean"]
+      "default"
     end
 
-    command! "hg", args: ["--cwd", cached_location, "update", *update_args], timeout: timeout&.remaining
+    command! "hg", args: ["--cwd", cached_location, *update_args], timeout: Utils::Timer.remaining(timeout)
+  end
+
+  def current_revision
+    out, = silent_command("hg", args: ["--cwd", cached_location, "identify", "--id"])
+    out.strip
   end
 end
 
@@ -1250,14 +1340,13 @@ def update(timeout: nil)
 #
 # @api public
 class BazaarDownloadStrategy < VCSDownloadStrategy
-  extend T::Sig
-
   def initialize(url, name, version, **meta)
     super
-    @url.sub!(%r{^bzr://}, "")
+    @url = @url.sub(%r{^bzr://}, "")
   end
 
-  # @see AbstractDownloadStrategy#source_modified_time
+  # Returns the most recent modified time for all files in the current working directory after stage.
+  #
   # @api public
   sig { returns(Time) }
   def source_modified_time
@@ -1268,7 +1357,8 @@ def source_modified_time
     Time.parse(timestamp)
   end
 
-  # @see VCSDownloadStrategy#last_commit
+  # Return last commit's unique identifier for the repository.
+  #
   # @api public
   sig { returns(String) }
   def last_commit
@@ -1280,7 +1370,7 @@ def last_commit
 
   def env
     {
-      "PATH"     => PATH.new(Formula["bazaar"].opt_bin, ENV.fetch("PATH")),
+      "PATH"     => PATH.new(Formula["breezy"].opt_bin, ENV.fetch("PATH")),
       "BZR_HOME" => HOMEBREW_TEMP,
     }
   end
@@ -1299,7 +1389,7 @@ def clone_repo(timeout: nil)
     # "lightweight" means history-less
     command! "bzr",
              args:    ["checkout", "--lightweight", @url, cached_location],
-             timeout: timeout&.remaining
+             timeout: Utils::Timer.remaining(timeout)
   end
 
   sig { params(timeout: T.nilable(Time)).void }
@@ -1307,7 +1397,7 @@ def update(timeout: nil)
     command! "bzr",
              args:    ["update"],
              chdir:   cached_location,
-             timeout: timeout&.remaining
+             timeout: Utils::Timer.remaining(timeout)
   end
 end
 
@@ -1315,14 +1405,13 @@ def update(timeout: nil)
 #
 # @api public
 class FossilDownloadStrategy < VCSDownloadStrategy
-  extend T::Sig
-
   def initialize(url, name, version, **meta)
     super
     @url = @url.sub(%r{^fossil://}, "")
   end
 
-  # @see AbstractDownloadStrategy#source_modified_time
+  # Returns the most recent modified time for all files in the current working directory after stage.
+  #
   # @api public
   sig { returns(Time) }
   def source_modified_time
@@ -1330,7 +1419,8 @@ def source_modified_time
     Time.parse(out[/^uuid: +\h+ (.+)$/, 1])
   end
 
-  # @see VCSDownloadStrategy#last_commit
+  # Return last commit's unique identifier for the repository.
+  #
   # @api public
   sig { returns(String) }
   def last_commit
@@ -1355,18 +1445,16 @@ def cache_tag
 
   sig { params(timeout: T.nilable(Time)).void }
   def clone_repo(timeout: nil)
-    command! "fossil", args: ["clone", @url, cached_location], timeout: timeout&.remaining
+    command! "fossil", args: ["clone", @url, cached_location], timeout: Utils::Timer.remaining(timeout)
   end
 
   sig { params(timeout: T.nilable(Time)).void }
   def update(timeout: nil)
-    command! "fossil", args: ["pull", "-R", cached_location], timeout: timeout&.remaining
+    command! "fossil", args: ["pull", "-R", cached_location], timeout: Utils::Timer.remaining(timeout)
   end
 end
 
 # Helper class for detecting a download strategy from a URL.
-#
-# @api private
 class DownloadStrategyDetector
   def self.detect(url, using = nil)
     if using.nil?
@@ -1389,7 +1477,8 @@ def self.detect_from_url(url)
       GitHubGitDownloadStrategy
     when %r{^https?://.+\.git$},
          %r{^git://},
-         %r{^https?://git\.sr\.ht/[^/]+/[^/]+$}
+         %r{^https?://git\.sr\.ht/[^/]+/[^/]+$},
+         %r{^ssh://git}
       GitDownloadStrategy
     when %r{^https?://www\.apache\.org/dyn/closer\.cgi},
          %r{^https?://www\.apache\.org/dyn/closer\.lua}
diff --git a/Library/Homebrew/download_strategy.rbi b/Library/Homebrew/download_strategy.rbi
new file mode 100644
index 0000000000000..b46c90106143f
--- /dev/null
+++ b/Library/Homebrew/download_strategy.rbi
@@ -0,0 +1,19 @@
+# typed: strict
+
+# This is a third-party implementation
+# rubocop:disable Lint/StructNewOverride
+class Mechanize::HTTP
+  ContentDisposition = Struct.new :type, :filename, :creation_date,
+                                  :modification_date, :read_date, :size, :parameters
+end
+# rubocop:enable Lint/StructNewOverride
+
+# rubocop:disable Style/OptionalBooleanParameter
+class Mechanize::HTTP::ContentDispositionParser
+  sig {
+    params(content_disposition: String, header: T::Boolean)
+      .returns(T.nilable(Mechanize::HTTP::ContentDisposition))
+  }
+  def parse(content_disposition, header = false); end
+end
+# rubocop:enable Style/OptionalBooleanParameter
diff --git a/Library/Homebrew/downloadable.rb b/Library/Homebrew/downloadable.rb
new file mode 100644
index 0000000000000..037e9ad0d616b
--- /dev/null
+++ b/Library/Homebrew/downloadable.rb
@@ -0,0 +1,149 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "url"
+require "checksum"
+require "download_strategy"
+
+module Downloadable
+  include Context
+  extend T::Helpers
+
+  abstract!
+  requires_ancestor { Kernel }
+
+  sig { overridable.returns(T.nilable(URL)) }
+  attr_reader :url
+
+  sig { overridable.returns(T.nilable(Checksum)) }
+  attr_reader :checksum
+
+  sig { overridable.returns(T::Array[String]) }
+  attr_reader :mirrors
+
+  sig { void }
+  def initialize
+    @mirrors = T.let([], T::Array[String])
+  end
+
+  def initialize_dup(other)
+    super
+    @checksum = @checksum.dup
+    @mirrors = @mirrors.dup
+    @version = @version.dup
+  end
+
+  sig { overridable.returns(T.self_type) }
+  def freeze
+    @checksum.freeze
+    @mirrors.freeze
+    @version.freeze
+    super
+  end
+
+  sig { abstract.returns(String) }
+  def name; end
+
+  sig { returns(String) }
+  def download_type
+    T.must(self.class.name&.split("::")&.last).gsub(/([[:lower:]])([[:upper:]])/, '\1 \2').downcase
+  end
+
+  sig(:final) { returns(T::Boolean) }
+  def downloaded?
+    cached_download.exist?
+  end
+
+  sig { overridable.returns(Pathname) }
+  def cached_download
+    downloader.cached_location
+  end
+
+  sig { overridable.void }
+  def clear_cache
+    downloader.clear_cache
+  end
+
+  sig { overridable.returns(T.nilable(Version)) }
+  def version
+    return @version if @version && !@version.null?
+
+    version = determine_url&.version
+    version unless version&.null?
+  end
+
+  sig { overridable.returns(T.class_of(AbstractDownloadStrategy)) }
+  def download_strategy
+    @download_strategy ||= determine_url&.download_strategy
+  end
+
+  sig { overridable.returns(AbstractDownloadStrategy) }
+  def downloader
+    @downloader ||= begin
+      primary_url, *mirrors = determine_url_mirrors
+      raise ArgumentError, "attempted to use a `Downloadable` without a URL!" if primary_url.blank?
+
+      download_strategy.new(primary_url, download_name, version,
+                            mirrors:, cache:, **T.must(@url).specs)
+    end
+  end
+
+  sig {
+    overridable.params(
+      verify_download_integrity: T::Boolean,
+      timeout:                   T.nilable(T.any(Integer, Float)),
+      quiet:                     T::Boolean,
+    ).returns(Pathname)
+  }
+  def fetch(verify_download_integrity: true, timeout: nil, quiet: false)
+    cache.mkpath
+
+    begin
+      downloader.quiet! if quiet
+      downloader.fetch(timeout:)
+    rescue ErrorDuringExecution, CurlDownloadStrategyError => e
+      raise DownloadError.new(self, e)
+    end
+
+    download = cached_download
+    verify_download_integrity(download) if verify_download_integrity
+    download
+  end
+
+  sig { overridable.params(filename: Pathname).void }
+  def verify_download_integrity(filename)
+    if filename.file?
+      ohai "Verifying checksum for '#{filename.basename}'" if verbose?
+      filename.verify_checksum(checksum)
+    end
+  rescue ChecksumMissingError
+    opoo <<~EOS
+      Cannot verify integrity of '#{filename.basename}'.
+      No checksum was provided.
+      For your reference, the checksum is:
+        sha256 "#{filename.sha256}"
+    EOS
+  end
+
+  sig { overridable.returns(String) }
+  def download_name
+    @download_name ||= File.basename(determine_url.to_s)
+  end
+
+  private
+
+  sig { overridable.returns(T.nilable(URL)) }
+  def determine_url
+    @url
+  end
+
+  sig { overridable.returns(T::Array[String]) }
+  def determine_url_mirrors
+    [determine_url.to_s, *mirrors].uniq
+  end
+
+  sig { overridable.returns(Pathname) }
+  def cache
+    HOMEBREW_CACHE
+  end
+end
diff --git a/Library/Homebrew/env_config.rb b/Library/Homebrew/env_config.rb
index 6397f0abb43ee..a3b3124e36f0f 100644
--- a/Library/Homebrew/env_config.rb
+++ b/Library/Homebrew/env_config.rb
@@ -1,19 +1,31 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
   # Helper module for querying Homebrew-specific environment variables.
   #
-  # @api private
+  # @api internal
   module EnvConfig
-    extend T::Sig
-
     module_function
 
-    ENVS = {
-      HOMEBREW_ADDITIONAL_GOOGLE_ANALYTICS_ID:   {
-        description: "Additional Google Analytics tracking ID to emit user behaviour analytics to. " \
-                     "For more information, see: <https://docs.brew.sh/Analytics>",
+    ENVS = T.let({
+      HOMEBREW_ALLOWED_TAPS:                     {
+        description: "A space-separated list of taps. Homebrew will refuse to install a " \
+                     "formula unless it and all of its dependencies are in an official tap " \
+                     "or in a tap on this list.",
+      },
+      HOMEBREW_API_AUTO_UPDATE_SECS:             {
+        description: "Check Homebrew's API for new formulae or cask data every " \
+                     "`HOMEBREW_API_AUTO_UPDATE_SECS` seconds. Alternatively, disable API auto-update " \
+                     "checks entirely with `HOMEBREW_NO_AUTO_UPDATE`.",
+        default:     450,
+      },
+      HOMEBREW_API_DOMAIN:                       {
+        description:  "Use this URL as the download mirror for Homebrew JSON API. " \
+                      "If metadata files at that URL are temporarily unavailable, " \
+                      "the default API domain will be used as a fallback mirror.",
+        default_text: "`https://formulae.brew.sh/api`.",
+        default:      HOMEBREW_API_DEFAULT_DOMAIN,
       },
       HOMEBREW_ARCH:                             {
         description: "Linux only: Pass this value to a type name representing the compiler's `-march` option.",
@@ -30,11 +42,18 @@ module EnvConfig
                      "to instead be downloaded from " \
                      "`http://localhost:8080/v2/homebrew/core/gettext/manifests/0.21`",
       },
+      HOMEBREW_ARTIFACT_DOMAIN_NO_FALLBACK:      {
+        description: "If `HOMEBREW_ARTIFACT_DOMAIN` and `HOMEBREW_ARTIFACT_DOMAIN_NO_FALLBACK` are both set, " \
+                     "if the request to `HOMEBREW_ARTIFACT_DOMAIN` fails then it Homebrew will error rather than " \
+                     "trying any other/default URLs.",
+        boolean:     true,
+      },
       HOMEBREW_AUTO_UPDATE_SECS:                 {
-        description: "Run `brew update` once every `HOMEBREW_AUTO_UPDATE_SECS` seconds before some commands, " \
-                     "e.g. `brew install`, `brew upgrade` and `brew tap`. Alternatively, " \
-                     "disable auto-update entirely with HOMEBREW_NO_AUTO_UPDATE.",
-        default:     300,
+        description:  "Run `brew update` once every `HOMEBREW_AUTO_UPDATE_SECS` seconds before some commands, " \
+                      "e.g. `brew install`, `brew upgrade` and `brew tap`. Alternatively, " \
+                      "disable auto-update entirely with `HOMEBREW_NO_AUTO_UPDATE`.",
+        default_text: "`86400` (24 hours), `3600` (1 hour) if a developer command has been run " \
+                      "or `300` (5 minutes) if `HOMEBREW_NO_INSTALL_FROM_API` is set.",
       },
       HOMEBREW_BAT:                              {
         description: "If set, use `bat` for the `brew cat` command.",
@@ -42,7 +61,7 @@ module EnvConfig
       },
       HOMEBREW_BAT_CONFIG_PATH:                  {
         description:  "Use this as the `bat` configuration file.",
-        default_text: "`$HOME/.config/bat/config`.",
+        default_text: "`$BAT_CONFIG_PATH`.",
       },
       HOMEBREW_BAT_THEME:                        {
         description:  "Use this as the `bat` theme for syntax highlighting.",
@@ -50,7 +69,7 @@ module EnvConfig
       },
       HOMEBREW_BOOTSNAP:                         {
         description: "If set, use Bootsnap to speed up repeated `brew` calls. " \
-                     "A no-op when using Homebrew's vendored, relocatable Ruby on macOS (as it doesn't work).",
+                     "A no-op on Linux when not using Homebrew's vendored, relocatable Ruby.",
         boolean:     true,
       },
       HOMEBREW_BOTTLE_DOMAIN:                    {
@@ -72,6 +91,9 @@ module EnvConfig
         description:  "Use this as the browser when opening project homepages.",
         default_text: "`$BROWSER` or the OS's default browser.",
       },
+      HOMEBREW_BUNDLE_USER_CACHE:                {
+        description: "If set, use this directory as the `bundle`(1) user cache.",
+      },
       HOMEBREW_CACHE:                            {
         description:  "Use this directory as the download cache.",
         default_text: "macOS: `$HOME/Library/Caches/Homebrew`, " \
@@ -83,17 +105,17 @@ module EnvConfig
                      "`--language`, `--require-sha`, `--no-quarantine` and `--no-binaries` are supported. " \
                      "For example, you might add something like the following to your " \
                      "`~/.profile`, `~/.bash_profile`, or `~/.zshenv`:" \
-                     '\n\n    `export HOMEBREW_CASK_OPTS="--appdir=~/Applications --fontdir=/Library/Fonts"`',
+                     "\n\n    `export HOMEBREW_CASK_OPTS=\"--appdir=~/Applications --fontdir=/Library/Fonts\"`",
+      },
+      HOMEBREW_CLEANUP_MAX_AGE_DAYS:             {
+        description: "Cleanup all cached files older than this many days.",
+        default:     120,
       },
       HOMEBREW_CLEANUP_PERIODIC_FULL_DAYS:       {
         description: "If set, `brew install`, `brew upgrade` and `brew reinstall` will cleanup all formulae " \
                      "when this number of days has passed.",
         default:     30,
       },
-      HOMEBREW_CLEANUP_MAX_AGE_DAYS:             {
-        description: "Cleanup all cached files older than this many days.",
-        default:     120,
-      },
       HOMEBREW_COLOR:                            {
         description: "If set, force colour output on non-TTY outputs.",
         boolean:     true,
@@ -104,9 +126,10 @@ module EnvConfig
         default:      HOMEBREW_CORE_DEFAULT_GIT_REMOTE,
       },
       HOMEBREW_CURLRC:                           {
-        description: "If set, do not pass `--disable` when invoking `curl`(1), which disables the " \
-                     "use of `curlrc`.",
-        boolean:     true,
+        description: "If set to an absolute path (i.e. beginning with `/`), pass it with `--config` when invoking " \
+                     "`curl`(1). " \
+                     "If set but _not_ a valid path, do not pass `--disable`, which disables the " \
+                     "use of `.curlrc`.",
       },
       HOMEBREW_CURL_PATH:                        {
         description: "Linux only: Set this value to a new enough `curl` executable for Homebrew to use.",
@@ -120,11 +143,19 @@ module EnvConfig
         description: "If set, pass `--verbose` when invoking `curl`(1).",
         boolean:     true,
       },
+      HOMEBREW_DEBUG:                            {
+        description: "If set, always assume `--debug` when running commands.",
+        boolean:     true,
+      },
       HOMEBREW_DEVELOPER:                        {
         description: "If set, tweak behaviour to be more relevant for Homebrew developers (active or " \
                      "budding) by e.g. turning warnings into errors.",
         boolean:     true,
       },
+      HOMEBREW_DISABLE_DEBREW:                   {
+        description: "If set, the interactive formula debugger available via `--debug` will be disabled.",
+        boolean:     true,
+      },
       HOMEBREW_DISABLE_LOAD_FORMULA:             {
         description: "If set, refuse to load formulae. This is useful when formulae are not trusted (such " \
                      "as in pull requests).",
@@ -139,6 +170,14 @@ module EnvConfig
         description: "If set, print install times for each formula at the end of the run.",
         boolean:     true,
       },
+      HOMEBREW_DOCKER_REGISTRY_BASIC_AUTH_TOKEN: {
+        description: "Use this base64 encoded username and password for authenticating with a Docker registry " \
+                     "proxying GitHub Packages. If `HOMEBREW_DOCKER_REGISTRY_TOKEN` is set, it will be used instead.",
+      },
+      HOMEBREW_DOCKER_REGISTRY_TOKEN:            {
+        description: "Use this bearer token for authenticating with a Docker registry proxying GitHub Packages. " \
+                     "Preferred over `HOMEBREW_DOCKER_REGISTRY_BASIC_AUTH_TOKEN`.",
+      },
       HOMEBREW_EDITOR:                           {
         description:  "Use this editor when editing a single formula, or several formulae in the " \
                       "same directory." \
@@ -147,14 +186,43 @@ module EnvConfig
                       "editors will do strange things in this case.",
         default_text: "`$EDITOR` or `$VISUAL`.",
       },
+      HOMEBREW_EVAL_ALL:                         {
+        description: "If set, `brew` commands evaluate all formulae and casks, executing their arbitrary code, by " \
+                     "default without requiring `--eval-all`. Required to cache formula and cask descriptions.",
+        boolean:     true,
+      },
       HOMEBREW_FAIL_LOG_LINES:                   {
         description: "Output this many lines of output on formula `system` failures.",
         default:     15,
       },
+      HOMEBREW_FORBIDDEN_CASKS:                  {
+        description: "A space-separated list of casks. Homebrew will refuse to install a " \
+                     "cask if it or any of its dependencies is on this list.",
+      },
+      HOMEBREW_FORBIDDEN_FORMULAE:               {
+        description: "A space-separated list of formulae. Homebrew will refuse to install a " \
+                     "formula or cask if it or any of its dependencies is on this list.",
+      },
       HOMEBREW_FORBIDDEN_LICENSES:               {
-        description: "A space-separated list of licenses. Homebrew will refuse to install a " \
+        description: "A space-separated list of SPDX license identifiers. Homebrew will refuse to install a " \
                      "formula if it or any of its dependencies has a license on this list.",
       },
+      HOMEBREW_FORBIDDEN_OWNER:                  {
+        description: "The person who has set any `HOMEBREW_FORBIDDEN_*` variables.",
+        default:     "you",
+      },
+      HOMEBREW_FORBIDDEN_OWNER_CONTACT:          {
+        description: "How to contact the `HOMEBREW_FORBIDDEN_OWNER`, if set and necessary.",
+      },
+      HOMEBREW_FORBIDDEN_TAPS:                   {
+        description: "A space-separated list of taps. Homebrew will refuse to install a " \
+                     "formula if it or any of its dependencies is in a tap on this list.",
+      },
+      HOMEBREW_FORBID_PACKAGES_FROM_PATHS:       {
+        description: "If set, Homebrew will refuse to read formulae or casks provided from file paths, " \
+                     "e.g. `brew install ./package.rb`.",
+        boolean:     true,
+      },
       HOMEBREW_FORCE_BREWED_CA_CERTIFICATES:     {
         description: "If set, always use a Homebrew-installed `ca-certificates` rather than the system version. " \
                      "Automatically set if the system version is too old.",
@@ -175,11 +243,26 @@ module EnvConfig
                      "of Ruby is new enough.",
         boolean:     true,
       },
+      HOMEBREW_FORMULA_BUILD_NETWORK:            {
+        description: "If set, controls network access to the sandbox for formulae builds. Overrides any " \
+                     "controls set through DSL usage inside formulae. Must be `allow` or `deny`. If no value is " \
+                     "set through this environment variable or DSL usage, the default behavior is `allow`.",
+      },
+      HOMEBREW_FORMULA_POSTINSTALL_NETWORK:      {
+        description: "If set, controls network access to the sandbox for formulae postinstall. Overrides any " \
+                     "controls set through DSL usage inside formulae. Must be `allow` or `deny`. If no value is " \
+                     "set through this environment variable or DSL usage, the default behavior is `allow`.",
+      },
+      HOMEBREW_FORMULA_TEST_NETWORK:             {
+        description: "If set, controls network access to the sandbox for formulae test. Overrides any " \
+                     "controls set through DSL usage inside formulae. Must be `allow` or `deny`. If no value is " \
+                     "set through this environment variable or DSL usage, the default behavior is `allow`.",
+      },
       HOMEBREW_GITHUB_API_TOKEN:                 {
         description: "Use this personal access token for the GitHub API, for features such as " \
                      "`brew search`. You can create one at <https://github.com/settings/tokens>. If set, " \
                      "GitHub will allow you a greater number of API requests. For more information, see: " \
-                     "<https://docs.github.com/en/rest/overview/resources-in-the-rest-api#rate-limiting>" \
+                     "<https://docs.github.com/en/rest/overview/rate-limits-for-the-rest-api>" \
                      "\n\n    *Note:* Homebrew doesn't require permissions for any of the scopes, but some " \
                      "developer commands may require additional permissions.",
       },
@@ -187,14 +270,6 @@ module EnvConfig
         description: "Use this GitHub personal access token when accessing the GitHub Packages Registry " \
                      "(where bottles may be stored).",
       },
-      HOMEBREW_DOCKER_REGISTRY_BASIC_AUTH_TOKEN: {
-        description: "Use this base64 encoded username and password for authenticating with a Docker registry " \
-                     "proxying GitHub Packages. If HOMEBREW_DOCKER_REGISTRY_TOKEN is set, it will be used instead.",
-      },
-      HOMEBREW_DOCKER_REGISTRY_TOKEN:            {
-        description: "Use this bearer token for authenticating with a Docker registry proxying GitHub Packages. " \
-                     "Preferred over HOMEBREW_DOCKER_REGISTRY_TOKEN_BASIC.",
-      },
       HOMEBREW_GITHUB_PACKAGES_USER:             {
         description: "Use this username when accessing the GitHub Packages Registry (where bottles may be stored).",
       },
@@ -213,18 +288,16 @@ module EnvConfig
         default_text: 'The "Beer Mug" emoji.',
         default:      "🍺",
       },
-      HOMEBREW_INSTALL_FROM_API:                 {
-        description: "If set, install formulae and casks in homebrew/core and homebrew/cask taps using Homebrew's " \
-                     "API instead of needing (large, slow) local checkouts of these repositories." \
-                     "\n\n    *Note:* Setting HOMEBREW_INSTALL_FROM_API is not compatible with Homebrew's " \
-                     "developer mode so will error (as Homebrew development needs a full clone).",
-        boolean:     true,
-      },
       HOMEBREW_LIVECHECK_WATCHLIST:              {
         description:  "Consult this file for the list of formulae to check by default when no formula argument " \
                       "is passed to `brew livecheck`.",
-        default_text: "`$HOME/.brew_livecheck_watchlist`",
-        default:      "~/.brew_livecheck_watchlist",
+        default_text: "`$XDG_CONFIG_HOME/homebrew/livecheck_watchlist.txt` if `$XDG_CONFIG_HOME` is set " \
+                      "or `$HOME/.homebrew/livecheck_watchlist.txt` otherwise.",
+        default:      "#{ENV.fetch("HOMEBREW_USER_CONFIG_HOME")}/livecheck_watchlist.txt",
+      },
+      HOMEBREW_LOCK_CONTEXT:                     {
+        description: "If set, Homebrew will add this output as additional context for locking errors. " \
+                     "This is useful when running `brew` in the background.",
       },
       HOMEBREW_LOGS:                             {
         description:  "Use this directory to store log files.",
@@ -242,42 +315,38 @@ module EnvConfig
         },
       },
       HOMEBREW_NO_ANALYTICS:                     {
-        description: "If set, do not send analytics. For more information, see: <https://docs.brew.sh/Analytics>",
+        description: "If set, do not send analytics. Google Analytics were destroyed. " \
+                     "For more information, see: <https://docs.brew.sh/Analytics>",
+        boolean:     true,
+      },
+      HOMEBREW_NO_AUTOREMOVE:                    {
+        description: "If set, calls to `brew cleanup` and `brew uninstall` will not automatically " \
+                     "remove unused formula dependents.",
         boolean:     true,
       },
       HOMEBREW_NO_AUTO_UPDATE:                   {
         description: "If set, do not automatically update before running some commands, e.g. " \
-                     "`brew install`, `brew upgrade` and `brew tap`. Alternatively, " \
-                     "run this less often by setting HOMEBREW_AUTO_UPDATE_SECS to a value higher than the default.",
+                     "`brew install`, `brew upgrade` and `brew tap`. Preferably, " \
+                     "run this less often by setting `HOMEBREW_AUTO_UPDATE_SECS` to a value higher than the " \
+                     "default. Note that setting this and e.g. tapping new taps may result in a broken  " \
+                     "configuration. Please ensure you always run `brew update` before reporting any issues.",
         boolean:     true,
       },
       HOMEBREW_NO_BOOTSNAP:                      {
         description: "If set, do not use Bootsnap to speed up repeated `brew` calls.",
         boolean:     true,
       },
-      HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK:    {
-        description: "If set, do not check for broken linkage of dependents or outdated dependents after " \
-                     "installing, upgrading or reinstalling formulae. This will result in fewer dependents " \
-                     "(and their dependencies) being upgraded or reinstalled but may result in more breakage " \
-                     "from running `brew install <formula>` or `brew upgrade <formula>`.",
-        boolean:     true,
-      },
       HOMEBREW_NO_CLEANUP_FORMULAE:              {
-        description: "A comma-separated list of formulae. Homebrew will refuse to clean up a " \
-                     "formula if it appears on this list.",
+        description: "A comma-separated list of formulae. Homebrew will refuse to clean up " \
+                     "or autoremove a formula if it appears on this list.",
       },
       HOMEBREW_NO_COLOR:                         {
         description:  "If set, do not print text with colour added.",
         default_text: "`$NO_COLOR`.",
         boolean:      true,
       },
-      HOMEBREW_NO_COMPAT:                        {
-        description: "If set, disable all use of legacy compatibility code.",
-        boolean:     true,
-      },
       HOMEBREW_NO_EMOJI:                         {
-        description: "If set, do not print `HOMEBREW_INSTALL_BADGE` on a successful build." \
-                     "\n\n    *Note:* Will only try to print emoji on OS X Lion or newer.",
+        description: "If set, do not print `HOMEBREW_INSTALL_BADGE` on a successful build.",
         boolean:     true,
       },
       HOMEBREW_NO_ENV_HINTS:                     {
@@ -291,22 +360,47 @@ module EnvConfig
       },
       HOMEBREW_NO_INSECURE_REDIRECT:             {
         description: "If set, forbid redirects from secure HTTPS to insecure HTTP." \
-                     "\n\n    *Note:* While ensuring your downloads are fully secure, this is likely to cause " \
+                     "\n\n    *Note:* while ensuring your downloads are fully secure, this is likely to cause " \
                      "from-source SourceForge, some GNU & GNOME-hosted formulae to fail to download.",
         boolean:     true,
       },
+      HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK:    {
+        description: "If set, do not check for broken linkage of dependents or outdated dependents after " \
+                     "installing, upgrading or reinstalling formulae. This will result in fewer dependents " \
+                     "(and their dependencies) being upgraded or reinstalled but may result in more breakage " \
+                     "from running `brew install` <formula> or `brew upgrade` <formula>.",
+        boolean:     true,
+      },
       HOMEBREW_NO_INSTALL_CLEANUP:               {
         description: "If set, `brew install`, `brew upgrade` and `brew reinstall` will never automatically " \
                      "cleanup installed/upgraded/reinstalled formulae or all formulae every " \
-                     "`HOMEBREW_CLEANUP_PERIODIC_FULL_DAYS` days. Alternatively, HOMEBREW_NO_CLEANUP_FORMULAE " \
+                     "`HOMEBREW_CLEANUP_PERIODIC_FULL_DAYS` days. Alternatively, `HOMEBREW_NO_CLEANUP_FORMULAE` " \
                      "allows specifying specific formulae to not clean up.",
         boolean:     true,
       },
+      HOMEBREW_NO_INSTALL_FROM_API:              {
+        description: "If set, do not install formulae and casks in homebrew/core and homebrew/cask taps using " \
+                     "Homebrew's API and instead use (large, slow) local checkouts of these repositories.",
+        boolean:     true,
+      },
       HOMEBREW_NO_INSTALL_UPGRADE:               {
-        description: "If set, `brew install <formula>` will not upgrade `<formula>` if it is installed but " \
+        description: "If set, `brew install` <formula|cask> will not upgrade <formula|cask> if it is installed but " \
                      "outdated.",
         boolean:     true,
       },
+      HOMEBREW_NO_UPDATE_REPORT_NEW:             {
+        description: "If set, `brew update` will not show the list of newly added formulae/casks.",
+        boolean:     true,
+      },
+      HOMEBREW_NO_VERIFY_ATTESTATIONS:           {
+        description: "If set, Homebrew not verify cryptographic attestations of build provenance for bottles " \
+                     "from homebrew-core.",
+        boolean:     true,
+      },
+      HOMEBREW_PIP_INDEX_URL:                    {
+        description:  "If set, `brew install` <formula> will use this URL to download PyPI package resources.",
+        default_text: "`https://pypi.org/simple`.",
+      },
       HOMEBREW_PRY:                              {
         description: "If set, use Pry for the `brew irb` command.",
         boolean:     true,
@@ -316,24 +410,35 @@ module EnvConfig
                      "when auditing macOS formulae while on Linux.",
         boolean:     true,
       },
-      HOMEBREW_SSH_CONFIG_PATH:                  {
-        description:  "If set, Homebrew will use the given config file instead of `~/.ssh/config` when fetching " \
-                      "`git` repos over `ssh`.",
-        default_text: "`$HOME/.ssh/config`",
-      },
       HOMEBREW_SKIP_OR_LATER_BOTTLES:            {
         description: "If set along with `HOMEBREW_DEVELOPER`, do not use bottles from older versions " \
                      "of macOS. This is useful in development on new macOS versions.",
         boolean:     true,
       },
       HOMEBREW_SORBET_RUNTIME:                   {
-        description: "If set, enable runtime typechecking using Sorbet.",
+        description: "If set, enable runtime typechecking using Sorbet. " \
+                     "Set by default for `HOMEBREW_DEVELOPER` or when running some developer commands.",
+        boolean:     true,
+      },
+      HOMEBREW_SSH_CONFIG_PATH:                  {
+        description:  "If set, Homebrew will use the given config file instead of `~/.ssh/config` when fetching " \
+                      "Git repositories over SSH.",
+        default_text: "`$HOME/.ssh/config`",
+      },
+      HOMEBREW_SUDO_THROUGH_SUDO_USER:           {
+        description: "If set, Homebrew will use the `SUDO_USER` environment variable to define the user to " \
+                     "`sudo`(8) through when running `sudo`(8).",
         boolean:     true,
       },
       HOMEBREW_SVN:                              {
         description:  "Use this as the `svn`(1) binary.",
         default_text: "A Homebrew-built Subversion (if installed), or the system-provided binary.",
       },
+      HOMEBREW_SYSTEM_ENV_TAKES_PRIORITY:        {
+        description: "If set in Homebrew's system-wide environment file (`/etc/homebrew/brew.env`), " \
+                     "the system-wide environment file will be loaded last to override any prefix or user settings.",
+        boolean:     true,
+      },
       HOMEBREW_TEMP:                             {
         description:  "Use this path as the temporary directory for building packages. Changing " \
                       "this may be needed if your system temporary directory and Homebrew prefix are on " \
@@ -343,22 +448,17 @@ module EnvConfig
         default_text: "macOS: `/private/tmp`, Linux: `/tmp`.",
         default:      HOMEBREW_DEFAULT_TEMP,
       },
-      HOMEBREW_UPDATE_REPORT_ALL_FORMULAE:       {
-        description: "If set, `brew update` lists changes to all formulae and cask files rather than only showing " \
-                     "when they are new and not installed or outdated and installed.",
-        boolean:     true,
-      },
       HOMEBREW_UPDATE_TO_TAG:                    {
         description: "If set, always use the latest stable tag (even if developer commands " \
                      "have been run).",
         boolean:     true,
       },
-      HOMEBREW_VERBOSE:                          {
-        description: "If set, always assume `--verbose` when running commands.",
+      HOMEBREW_UPGRADE_GREEDY:                   {
+        description: "If set, pass `--greedy` to all cask upgrade commands.",
         boolean:     true,
       },
-      HOMEBREW_DEBUG:                            {
-        description: "If set, always assume `--debug` when running commands.",
+      HOMEBREW_VERBOSE:                          {
+        description: "If set, always assume `--verbose` when running commands.",
         boolean:     true,
       },
       HOMEBREW_VERBOSE_USING_DOTS:               {
@@ -366,6 +466,14 @@ module EnvConfig
                      "useful to avoid long-running Homebrew commands being killed due to no output.",
         boolean:     true,
       },
+      HOMEBREW_VERIFY_ATTESTATIONS:              {
+        description: "If set, Homebrew will use the `gh` tool to verify cryptographic attestations " \
+                     "of build provenance for bottles from homebrew-core.",
+        boolean:     true,
+      },
+      SUDO_ASKPASS:                              {
+        description: "If set, pass the `-A` option when calling `sudo`(8).",
+      },
       all_proxy:                                 {
         description: "Use this SOCKS5 proxy for `curl`(1), `git`(1) and `svn`(1) when downloading through Homebrew.",
       },
@@ -382,11 +490,9 @@ module EnvConfig
         description: "A comma-separated list of hostnames and domain names excluded " \
                      "from proxying by `curl`(1), `git`(1) and `svn`(1) when downloading through Homebrew.",
       },
-      SUDO_ASKPASS:                              {
-        description: "If set, pass the `-A` option when calling `sudo`(8).",
-      },
-    }.freeze
+    }.freeze, T::Hash[Symbol, T::Hash[Symbol, T.untyped]])
 
+    sig { params(env: Symbol, hash: T::Hash[Symbol, T.untyped]).returns(String) }
     def env_method_name(env, hash)
       method_name = env.to_s
                        .sub(/^HOMEBREW_/, "")
@@ -395,23 +501,34 @@ def env_method_name(env, hash)
       method_name
     end
 
-    CUSTOM_IMPLEMENTATIONS = %w[
-      HOMEBREW_MAKE_JOBS
-      HOMEBREW_CASK_OPTS
-    ].freeze
+    CUSTOM_IMPLEMENTATIONS = T.let(Set.new([
+      :HOMEBREW_MAKE_JOBS,
+      :HOMEBREW_CASK_OPTS,
+    ]).freeze, T::Set[Symbol])
 
     ENVS.each do |env, hash|
+      # Needs a custom implementation.
+      next if CUSTOM_IMPLEMENTATIONS.include?(env)
+
       method_name = env_method_name(env, hash)
       env = env.to_s
 
       if hash[:boolean]
         define_method(method_name) do
-          ENV[env].present?
+          env_value = ENV.fetch(env, nil)
+
+          falsy_values = %w[false no off nil 0]
+          if falsy_values.include?(env_value&.downcase)
+            odeprecated "#{env}=#{env_value}", <<~EOS
+              If you wish to enable #{env}, #{env}=1
+              If you wish to disable #{env}, #{env}=
+            EOS
+          end
+
+          # TODO: Uncomment the remaining part of the line below after the deprecation/disable cycle.
+          env_value.present? # && !falsy_values.include(env_value.downcase)
         end
       elsif hash[:default].present?
-        # Needs a custom implementation.
-        next if CUSTOM_IMPLEMENTATIONS.include?(env)
-
         define_method(method_name) do
           ENV[env].presence || hash.fetch(:default).to_s
         end
@@ -463,5 +580,15 @@ def cask_opts_quarantine?
     def cask_opts_require_sha?
       cask_opts.include?("--require-sha")
     end
+
+    sig { returns(T::Boolean) }
+    def automatically_set_no_install_from_api?
+      ENV["HOMEBREW_AUTOMATICALLY_SET_NO_INSTALL_FROM_API"].present?
+    end
+
+    sig { returns(T::Boolean) }
+    def devcmdrun?
+      Homebrew::Settings.read("devcmdrun") == "true"
+    end
   end
 end
diff --git a/Library/Homebrew/exceptions.rb b/Library/Homebrew/exceptions.rb
index 6f83563226ee8..c03f9569e953f 100644
--- a/Library/Homebrew/exceptions.rb
+++ b/Library/Homebrew/exceptions.rb
@@ -1,13 +1,10 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "shellwords"
-require "utils"
-
 # Raised when a command is used wrong.
+#
+# @api internal
 class UsageError < RuntimeError
-  extend T::Sig
-
   attr_reader :reason
 
   def initialize(reason = nil)
@@ -49,15 +46,21 @@ class UnsupportedInstallationMethod < RuntimeError; end
 
 class MultipleVersionsInstalledError < RuntimeError; end
 
+# Raised when a path is not a keg.
+#
+# @api internal
 class NotAKegError < RuntimeError; end
 
 # Raised when a keg doesn't exist.
 class NoSuchKegError < RuntimeError
-  attr_reader :name
+  attr_reader :name, :tap
 
-  def initialize(name)
+  def initialize(name, tap: nil)
     @name = name
-    super "No such keg: #{HOMEBREW_CELLAR}/#{name}"
+    @tap = tap
+    message = "No such keg: #{HOMEBREW_CELLAR}/#{name}"
+    message += " from tap #{tap}" if tap
+    super message
   end
 end
 
@@ -75,29 +78,31 @@ def initialize(formula, attr, value)
 class FormulaSpecificationError < StandardError; end
 
 # Raised when a deprecated method is used.
-#
-# @api private
 class MethodDeprecatedError < StandardError
   attr_accessor :issues_url
 end
 
 # Raised when neither a formula nor a cask with the given name is available.
 class FormulaOrCaskUnavailableError < RuntimeError
-  extend T::Sig
-
   attr_reader :name
 
   def initialize(name)
     super()
 
     @name = name
+
+    # Store the state of these envs at the time the exception is thrown.
+    # This is so we do the fuzzy search for "did you mean" etc under that same mode,
+    # in case the list of formulae are different.
+    @without_api = Homebrew::EnvConfig.no_install_from_api?
+    @auto_without_api = Homebrew::EnvConfig.automatically_set_no_install_from_api?
   end
 
   sig { returns(String) }
   def did_you_mean
     require "formula"
 
-    similar_formula_names = Formula.fuzzy_search(name)
+    similar_formula_names = Homebrew.with_no_api_env_if_needed(@without_api) { Formula.fuzzy_search(name) }
     return "" if similar_formula_names.blank?
 
     "Did you mean #{similar_formula_names.to_sentence two_words_connector: " or ", last_word_connector: " or "}?"
@@ -105,14 +110,16 @@ def did_you_mean
 
   sig { returns(String) }
   def to_s
-    "No available formula or cask with the name \"#{name}\". #{did_you_mean}".strip
+    s = "No available formula or cask with the name \"#{name}\". #{did_you_mean}".strip
+    if @auto_without_api && !CoreTap.instance.installed?
+      s += "\nA full git tap clone is required to use this command on core packages."
+    end
+    s
   end
 end
 
 # Raised when a formula or cask in a specific tap is not available.
 class TapFormulaOrCaskUnavailableError < FormulaOrCaskUnavailableError
-  extend T::Sig
-
   attr_reader :tap
 
   def initialize(tap, name)
@@ -129,9 +136,9 @@ def to_s
 end
 
 # Raised when a formula is not available.
+#
+# @api internal
 class FormulaUnavailableError < FormulaOrCaskUnavailableError
-  extend T::Sig
-
   attr_accessor :dependent
 
   sig { returns(T.nilable(String)) }
@@ -146,13 +153,10 @@ def to_s
 end
 
 # Shared methods for formula class errors.
-#
-# @api private
 module FormulaClassUnavailableErrorModule
-  extend T::Sig
-
   attr_reader :path, :class_name, :class_list
 
+  sig { returns(String) }
   def to_s
     s = super
     s += "\nIn formula file: #{path}"
@@ -192,10 +196,10 @@ def initialize(name, path, class_name, class_list)
 end
 
 # Shared methods for formula unreadable errors.
-#
-# @api private
 module FormulaUnreadableErrorModule
-  extend T::Sig
+  extend T::Helpers
+
+  requires_ancestor { FormulaOrCaskUnavailableError }
 
   attr_reader :formula_error
 
@@ -218,15 +222,16 @@ def initialize(name, error)
 
 # Raised when a formula in a specific tap is unavailable.
 class TapFormulaUnavailableError < FormulaUnavailableError
-  attr_reader :tap, :user, :repo
+  attr_reader :tap, :user, :repository
 
   def initialize(tap, name)
     @tap = tap
     @user = tap.user
-    @repo = tap.repo
+    @repository = tap.repository
     super "#{tap}/#{name}"
   end
 
+  sig { returns(String) }
   def to_s
     s = super
     s += "\nPlease tap it and then try again: brew tap #{tap}" unless tap.installed?
@@ -261,40 +266,20 @@ def initialize(tap, name, error)
 
 # Raised when a formula with the same name is found in multiple taps.
 class TapFormulaAmbiguityError < RuntimeError
-  attr_reader :name, :paths, :formulae
-
-  def initialize(name, paths)
-    @name = name
-    @paths = paths
-    @formulae = paths.map do |path|
-      "#{Tap.from_path(path).name}/#{path.basename(".rb")}"
-    end
-
-    super <<~EOS
-      Formulae found in multiple taps: #{formulae.map { |f| "\n       * #{f}" }.join}
+  attr_reader :name, :taps, :loaders
 
-      Please use the fully-qualified name (e.g. #{formulae.first}) to refer to the formula.
-    EOS
-  end
-end
-
-# Raised when a formula's old name in a specific tap is found in multiple taps.
-class TapFormulaWithOldnameAmbiguityError < RuntimeError
-  attr_reader :name, :possible_tap_newname_formulae, :taps
-
-  def initialize(name, possible_tap_newname_formulae)
+  def initialize(name, loaders)
     @name = name
-    @possible_tap_newname_formulae = possible_tap_newname_formulae
+    @loaders = loaders
+    @taps = loaders.map(&:tap)
 
-    @taps = possible_tap_newname_formulae.map do |newname|
-      newname =~ HOMEBREW_TAP_FORMULA_REGEX
-      "#{Regexp.last_match(1)}/#{Regexp.last_match(2)}"
-    end
+    formulae = taps.map { |tap| "#{tap}/#{name}" }
+    formula_list = formulae.map { |f| "\n       * #{f}" }.join
 
     super <<~EOS
-      Formulae with '#{name}' old name found in multiple taps: #{taps.map { |t| "\n       * #{t}" }.join}
+      Formulae found in multiple taps:#{formula_list}
 
-      Please use the fully-qualified name (e.g. #{taps.first}/#{name}) to refer to the formula or use its new name.
+      Please use the fully-qualified name (e.g. #{formulae.first}) to refer to a specific formula.
     EOS
   end
 end
@@ -306,9 +291,19 @@ class TapUnavailableError < RuntimeError
   def initialize(name)
     @name = name
 
-    super <<~EOS
-      No available tap #{name}.
-    EOS
+    message = "No available tap #{name}.\n"
+    if [CoreTap.instance.name, CoreCaskTap.instance.name].include?(name)
+      command = "brew tap --force #{name}"
+      message += <<~EOS
+        Run #{Formatter.identifier(command)} to tap #{name}!
+      EOS
+    else
+      command = "brew tap-new #{name}"
+      message += <<~EOS
+        Run #{Formatter.identifier(command)} to create a new #{name} tap!
+      EOS
+    end
+    super message.freeze
   end
 end
 
@@ -332,11 +327,11 @@ def message
   end
 end
 
-# Raised when the remote of Homebrew/core does not match HOMEBREW_CORE_GIT_REMOTE.
+# Raised when the remote of homebrew/core does not match HOMEBREW_CORE_GIT_REMOTE.
 class TapCoreRemoteMismatchError < TapRemoteMismatchError
   def message
     <<~EOS
-      Tap #{name} remote does mot match HOMEBREW_CORE_GIT_REMOTE.
+      Tap #{name} remote does not match HOMEBREW_CORE_GIT_REMOTE.
       #{expected_remote} != #{actual_remote}
       Please set HOMEBREW_CORE_GIT_REMOTE="#{actual_remote}" and run `brew update` instead.
     EOS
@@ -371,10 +366,14 @@ def initialize(name)
 
 # Raised when another Homebrew operation is already in progress.
 class OperationInProgressError < RuntimeError
-  def initialize(name)
+  sig { params(locked_path: Pathname).void }
+  def initialize(locked_path)
+    full_command = Homebrew.running_command_with_args.presence || "brew"
+    lock_context = if (env_lock_context = Homebrew::EnvConfig.lock_context.presence)
+      "\n#{env_lock_context}"
+    end
     message = <<~EOS
-      Operation already in progress for #{name}
-      Another active Homebrew process is already using #{name}.
+      A `#{full_command}` process has already locked #{locked_path}.#{lock_context}
       Please wait for it to finish or terminate it to continue.
     EOS
 
@@ -404,8 +403,6 @@ def initialize(reqs)
 
 # Raised when a formula conflicts with another one.
 class FormulaConflictError < RuntimeError
-  extend T::Sig
-
   attr_reader :formula, :conflicts
 
   def initialize(formula, conflicts)
@@ -430,7 +427,7 @@ def message
       Please `brew unlink #{conflicts.map(&:name) * " "}` before continuing.
 
       Unlinking removes a formula's symlinks from #{HOMEBREW_PREFIX}. You can
-      link the formula again after the install finishes. You can --force this
+      link the formula again after the install finishes. You can `--force` this
       install, but the build may fail or cause obscure side effects in the
       resulting software.
     EOS
@@ -469,6 +466,14 @@ class BuildError < RuntimeError
   attr_reader :cmd, :args, :env
   attr_accessor :formula, :options
 
+  sig {
+    params(
+      formula: T.nilable(Formula),
+      cmd:     T.any(String, Pathname),
+      args:    T::Array[T.any(String, Integer, Pathname, Symbol)],
+      env:     T::Hash[String, T.untyped],
+    ).void
+  }
   def initialize(formula, cmd, args, env)
     @formula = formula
     @cmd = cmd
@@ -478,17 +483,22 @@ def initialize(formula, cmd, args, env)
     super "Failed executing: #{cmd} #{pretty_args}".strip
   end
 
+  sig { returns(T::Array[T.untyped]) }
   def issues
     @issues ||= fetch_issues
   end
 
+  sig { returns(T::Array[T.untyped]) }
   def fetch_issues
-    GitHub.issues_for_formula(formula.name, tap: formula.tap, state: "open")
-  rescue GitHub::API::RateLimitExceededError => e
-    opoo e.message
+    return [] if ENV["HOMEBREW_NO_BUILD_ERROR_ISSUES"].present?
+
+    GitHub.issues_for_formula(formula.name, tap: formula.tap, state: "open", type: "issue")
+  rescue GitHub::API::Error => e
+    opoo "Unable to query GitHub for recent issues on the tap\n#{e.message}"
     []
   end
 
+  sig { params(verbose: T::Boolean).void }
   def dump(verbose: false)
     puts
 
@@ -511,23 +521,23 @@ def dump(verbose: false)
       end
     end
 
-    if formula.tap && defined?(OS::ISSUES_URL)
+    if formula.tap && !OS.unsupported_configuration?
       if formula.tap.official?
         puts Formatter.error(Formatter.url(OS::ISSUES_URL), label: "READ THIS")
       elsif (issues_url = formula.tap.issues_url)
         puts <<~EOS
-          If reporting this issue please do so at (not Homebrew/brew or Homebrew/core):
+          If reporting this issue please do so at (not Homebrew/brew or Homebrew/homebrew-core):
             #{Formatter.url(issues_url)}
         EOS
       else
         puts <<~EOS
-          If reporting this issue please do so to (not Homebrew/brew or Homebrew/core):
+          If reporting this issue please do so to (not Homebrew/brew or Homebrew/homebrew-core):
             #{formula.tap}
         EOS
       end
     else
       puts <<~EOS
-        Do not report this issue to Homebrew/brew or Homebrew/core!
+        Do not report this issue to Homebrew/brew or Homebrew/homebrew-core!
       EOS
     end
 
@@ -554,8 +564,10 @@ def dump(verbose: false)
 # installed in a situation where a bottle is required.
 class UnbottledError < RuntimeError
   def initialize(formulae)
-    msg = +<<~EOS
-      The following #{"formula".pluralize(formulae.count)} cannot be installed from #{"bottle".pluralize(formulae.count)} and must be
+    require "utils"
+
+    msg = <<~EOS
+      The following #{Utils.pluralize("formula", formulae.count, plural: "e")} cannot be installed from #{Utils.pluralize("bottle", formulae.count)} and must be
       built from source.
         #{formulae.to_sentence}
     EOS
@@ -565,7 +577,7 @@ def initialize(formulae)
   end
 end
 
-# Raised by Homebrew.install, Homebrew.reinstall, and Homebrew.upgrade
+# Raised by `Homebrew.install`, `Homebrew.reinstall` and `Homebrew.upgrade`
 # if the user passes any flags/environment that would case a bottle-only
 # installation on a system without build tools to fail.
 class BuildFlagsError < RuntimeError
@@ -606,13 +618,16 @@ def initialize(formula)
   end
 end
 
-# Raised in {Resource#fetch}.
+# Raised in {Downloadable#fetch}.
 class DownloadError < RuntimeError
-  def initialize(resource, cause)
+  attr_reader :cause
+
+  def initialize(downloadable, cause)
     super <<~EOS
-      Failed to download resource #{resource.download_name.inspect}
+      Failed to download resource #{downloadable.download_name.inspect}
       #{cause.message}
     EOS
+    @cause = cause
     set_backtrace(cause.backtrace)
   end
 end
@@ -638,8 +653,6 @@ def initialize(url)
 
 # Raised by {Kernel#safe_system} in `utils.rb`.
 class ErrorDuringExecution < RuntimeError
-  extend T::Sig
-
   attr_reader :cmd, :status, :output
 
   def initialize(cmd, status:, output: nil, secrets: [])
@@ -677,7 +690,7 @@ def initialize(cmd, status:, output: nil, secrets: [])
       raise ArgumentError, "Status neither has `exitstatus` nor `termsig`."
     end
 
-    s = +"Failure while executing; `#{redacted_cmd}` #{reason}."
+    s = "Failure while executing; `#{redacted_cmd}` #{reason}."
 
     if Array(output).present?
       format_output_line = lambda do |type_line|
@@ -751,31 +764,14 @@ def initialize(bottle_path, formula_path)
   end
 end
 
-# Raised when a child process sends us an exception over its error pipe.
+# Raised when a `Utils.safe_fork` exits with a non-zero code.
 class ChildProcessError < RuntimeError
-  attr_reader :inner, :inner_class
-
-  def initialize(inner)
-    @inner = inner
-    @inner_class = Object.const_get inner["json_class"]
+  attr_reader :status
 
-    super <<~EOS
-      An exception occurred within a child process:
-        #{inner_class}: #{inner["m"]}
-    EOS
-
-    # Clobber our real (but irrelevant) backtrace with that of the inner exception.
-    set_backtrace inner["b"]
-  end
-end
-
-# Raised when a macOS version is unsupported.
-class MacOSVersionError < RuntimeError
-  attr_reader :version
+  def initialize(status)
+    @status = status
 
-  def initialize(version)
-    @version = version
-    super "unknown or unsupported macOS version: #{version.inspect}"
+    super "Forked child process failed: #{status}"
   end
 end
 
diff --git a/Library/Homebrew/extend/ENV.rb b/Library/Homebrew/extend/ENV.rb
index 12ef1af60d2c5..b7a9afb644464 100644
--- a/Library/Homebrew/extend/ENV.rb
+++ b/Library/Homebrew/extend/ENV.rb
@@ -8,8 +8,6 @@
 require "extend/ENV/super"
 
 module Kernel
-  extend T::Sig
-
   sig { params(env: T.nilable(String)).returns(T::Boolean) }
   def superenv?(env)
     return false if env == "std"
@@ -19,9 +17,17 @@ def superenv?(env)
   private :superenv?
 end
 
-module EnvActivation
-  extend T::Sig
+# <!-- vale off -->
+# @!parse
+#   # `ENV` is not actually a class, but this makes YARD happy
+#   # @see https://rubydoc.info/stdlib/core/ENV
+#   #   <code>ENV</code> core documentation
+#   # @see Superenv
+#   # @see Stdenv
+#   class ENV; end
+# <!-- vale on -->
 
+module EnvActivation
   sig { params(env: T.nilable(String)).void }
   def activate_extensions!(env: nil)
     if superenv?(env)
@@ -33,19 +39,21 @@ def activate_extensions!(env: nil)
 
   sig {
     params(
-      env:          T.nilable(String),
-      cc:           T.nilable(String),
-      build_bottle: T::Boolean,
-      bottle_arch:  T.nilable(String),
-      _block:       T.proc.returns(T.untyped),
+      env:           T.nilable(String),
+      cc:            T.nilable(String),
+      build_bottle:  T::Boolean,
+      bottle_arch:   T.nilable(String),
+      debug_symbols: T.nilable(T::Boolean),
+      _block:        T.proc.returns(T.untyped),
     ).returns(T.untyped)
   }
-  def with_build_environment(env: nil, cc: nil, build_bottle: false, bottle_arch: nil, &_block)
+  def with_build_environment(env: nil, cc: nil, build_bottle: false, bottle_arch: nil, debug_symbols: false, &_block)
     old_env = to_hash.dup
     tmp_env = to_hash.dup.extend(EnvActivation)
-    T.cast(tmp_env, EnvActivation).activate_extensions!(env: env)
+    T.cast(tmp_env, EnvActivation).activate_extensions!(env:)
     T.cast(tmp_env, T.any(Superenv, Stdenv))
-     .setup_build_environment(cc: cc, build_bottle: build_bottle, bottle_arch: bottle_arch)
+     .setup_build_environment(cc:, build_bottle:, bottle_arch:,
+                              debug_symbols:)
     replace(tmp_env)
 
     begin
diff --git a/Library/Homebrew/extend/ENV.rbi b/Library/Homebrew/extend/ENV.rbi
index f1fa0b4dcff5d..24711f725fa26 100644
--- a/Library/Homebrew/extend/ENV.rbi
+++ b/Library/Homebrew/extend/ENV.rbi
@@ -1,43 +1,10 @@
 # typed: strict
 
-module EnvMethods
-  include Kernel
-
-  sig { params(key: String).returns(T::Boolean) }
-  def key?(key); end
-
-  sig { params(key: String).returns(T.nilable(String)) }
-  def [](key); end
-
-  sig { params(key: String).returns(String) }
-  def fetch(key); end
-
-  sig { params(key: String, value: T.nilable(T.any(String, PATH))).returns(T.nilable(String)) }
-  def []=(key, value); end
-
-  sig { params(block: T.proc.params(arg0: [String, String]).returns(T::Boolean)).returns(T::Hash[String, String]) }
-  def select(&block); end
-
-  sig { params(block: T.proc.params(arg0: String).void).void }
-  def each_key(&block); end
-
-  sig { params(key: String).returns(T.nilable(String)) }
-  def delete(key); end
-
-  sig {
-    params(other: T.any(T::Hash[String, String], Sorbet::Private::Static::ENVClass))
-      .returns(Sorbet::Private::Static::ENVClass)
-  }
-  def replace(other); end
-
-  sig { returns(T::Hash[String, String]) }
-  def to_hash; end
-end
-
 module EnvActivation
-  include EnvMethods
+  include SharedEnvExtension
 end
 
+# @!visibility private
 class Sorbet
   module Private
     module Static
diff --git a/Library/Homebrew/extend/ENV/shared.rb b/Library/Homebrew/extend/ENV/shared.rb
index 381ceccfdb8ff..d80724a8fa54f 100644
--- a/Library/Homebrew/extend/ENV/shared.rb
+++ b/Library/Homebrew/extend/ENV/shared.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "compilers"
@@ -11,10 +11,11 @@
 # @see Stdenv
 # @see https://www.rubydoc.info/stdlib/Env Ruby's ENV API
 module SharedEnvExtension
-  extend T::Sig
-
+  extend T::Helpers
   include CompilerConstants
 
+  requires_ancestor { Sorbet::Private::Static::ENVClass }
+
   CC_FLAG_VARS = %w[CFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS].freeze
   private_constant :CC_FLAG_VARS
 
@@ -30,6 +31,7 @@ module SharedEnvExtension
     CMAKE_PREFIX_PATH CMAKE_INCLUDE_PATH CMAKE_FRAMEWORK_PATH
     GOBIN GOPATH GOROOT PERL_MB_OPT PERL_MM_OPT
     LIBRARY_PATH LD_LIBRARY_PATH LD_PRELOAD LD_RUN_PATH
+    RUSTFLAGS
   ].freeze
   private_constant :SANITIZED_VARS
 
@@ -40,17 +42,20 @@ module SharedEnvExtension
       build_bottle:    T.nilable(T::Boolean),
       bottle_arch:     T.nilable(String),
       testing_formula: T::Boolean,
+      debug_symbols:   T.nilable(T::Boolean),
     ).void
   }
-  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false)
+  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false,
+                              debug_symbols: false)
     @formula = formula
     @cc = cc
     @build_bottle = build_bottle
     @bottle_arch = bottle_arch
+    @debug_symbols = debug_symbols
     reset
   end
-  private :setup_build_environment
   alias generic_shared_setup_build_environment setup_build_environment
+  private :generic_shared_setup_build_environment
 
   sig { void }
   def reset
@@ -58,7 +63,7 @@ def reset
   end
   private :reset
 
-  sig { returns(T::Hash[String, String]) }
+  sig { returns(T::Hash[String, T.nilable(String)]) }
   def remove_cc_etc
     keys = %w[CC CXX OBJC OBJCXX LD CPP CFLAGS CXXFLAGS OBJCFLAGS OBJCXXFLAGS LDFLAGS CPPFLAGS]
     keys.to_h { |key| [key, delete(key)] }
@@ -269,7 +274,6 @@ def fortran
     set_cpu_flags(flags)
   end
 
-  # @private
   sig { returns(Symbol) }
   def effective_arch
     if @build_bottle && @bottle_arch
@@ -279,21 +283,20 @@ def effective_arch
     end
   end
 
-  # @private
   sig { params(name: String).returns(Formula) }
   def gcc_version_formula(name)
     version = name[GNU_GCC_REGEXP, 1]
     gcc_version_name = "gcc@#{version}"
 
     gcc = Formulary.factory("gcc")
-    if gcc.version_suffix == version
+    if gcc.respond_to?(:version_suffix) && T.unsafe(gcc).version_suffix == version
       gcc
     else
       Formulary.factory(gcc_version_name)
     end
   end
+  private :gcc_version_formula
 
-  # @private
   sig { params(name: String).void }
   def warn_about_non_apple_gcc(name)
     begin
@@ -311,16 +314,19 @@ def warn_about_non_apple_gcc(name)
         brew install #{gcc_formula.full_name}
     EOS
   end
+  private :warn_about_non_apple_gcc
 
   sig { void }
   def permit_arch_flags; end
 
-  # @private
-  sig { params(cc: T.any(Symbol, String)).returns(T::Boolean) }
-  def compiler_any_clang?(cc = compiler)
-    %w[clang llvm_clang].include?(cc.to_s)
+  sig { returns(Integer) }
+  def make_jobs
+    Homebrew::EnvConfig.make_jobs.to_i
   end
 
+  sig { void }
+  def refurbish_args; end
+
   private
 
   sig { params(_flags: T::Array[String], _map: T::Hash[Symbol, String]).void }
@@ -346,7 +352,7 @@ def fetch_compiler(value, source)
     COMPILER_SYMBOL_MAP.fetch(value) do |other|
       case other
       when GNU_GCC_REGEXP
-        other
+        other.to_sym
       else
         raise "Invalid value for #{source}: #{other}"
       end
diff --git a/Library/Homebrew/extend/ENV/shared.rbi b/Library/Homebrew/extend/ENV/shared.rbi
index b1eac4cd3e919..971159b7e4f6a 100644
--- a/Library/Homebrew/extend/ENV/shared.rbi
+++ b/Library/Homebrew/extend/ENV/shared.rbi
@@ -1,15 +1,12 @@
 # typed: strict
 
 module SharedEnvExtension
-  include EnvMethods
-end
-
-class Sorbet
-  module Private
-    module Static
-      class ENVClass
-        include SharedEnvExtension
-      end
-    end
-  end
+  # Overload to allow `PATH` values.
+  sig {
+    type_parameters(:U).params(
+      key:   String,
+      value: T.all(T.type_parameter(:U), T.nilable(T.any(String, PATH))),
+    ).returns(T.type_parameter(:U))
+  }
+  def []=(key, value); end
 end
diff --git a/Library/Homebrew/extend/ENV/std.rb b/Library/Homebrew/extend/ENV/std.rb
index ba4caa1a800f1..b0c312c24a86c 100644
--- a/Library/Homebrew/extend/ENV/std.rb
+++ b/Library/Homebrew/extend/ENV/std.rb
@@ -4,16 +4,12 @@
 require "hardware"
 require "extend/ENV/shared"
 
-# @api private
 module Stdenv
-  extend T::Sig
-
   include SharedEnvExtension
 
-  # @private
   SAFE_CFLAGS_FLAGS = "-w -pipe"
+  private_constant :SAFE_CFLAGS_FLAGS
 
-  # @private
   sig {
     params(
       formula:         T.nilable(Formula),
@@ -21,9 +17,11 @@ module Stdenv
       build_bottle:    T.nilable(T::Boolean),
       bottle_arch:     T.nilable(String),
       testing_formula: T::Boolean,
+      debug_symbols:   T.nilable(T::Boolean),
     ).void
   }
-  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false)
+  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false,
+                              debug_symbols: false)
     super
 
     self["HOMEBREW_ENV"] = "std"
@@ -36,8 +34,9 @@ def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_a
     self["PKG_CONFIG_LIBDIR"] = determine_pkg_config_libdir
 
     self["MAKEFLAGS"] = "-j#{make_jobs}"
+    self["RUSTFLAGS"] = Hardware.rustflags_target_cpu(effective_arch)
 
-    unless HOMEBREW_PREFIX.to_s == "/usr/local"
+    if HOMEBREW_PREFIX.to_s != "/usr/local"
       # /usr/local is already an -isystem and -L directory so we skip it
       self["CPPFLAGS"] = "-isystem#{HOMEBREW_PREFIX}/include"
       self["LDFLAGS"] = "-L#{HOMEBREW_PREFIX}/lib"
@@ -55,7 +54,14 @@ def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_a
     # Os is the default Apple uses for all its stuff so let's trust them
     define_cflags "-Os #{SAFE_CFLAGS_FLAGS}"
 
-    send(compiler)
+    begin
+      send(compiler)
+    rescue CompilerSelectionError
+      # We don't care if our compiler fails to build the formula during `brew test`.
+      raise unless testing_formula
+
+      send(DevelopmentTools.default_compiler)
+    end
 
     return unless cc&.match?(GNU_GCC_REGEXP)
 
@@ -64,11 +70,6 @@ def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_a
   end
   alias generic_setup_build_environment setup_build_environment
 
-  sig { returns(T::Array[Pathname]) }
-  def homebrew_extra_pkg_config_paths
-    []
-  end
-
   sig { returns(T.nilable(PATH)) }
   def determine_pkg_config_libdir
     PATH.new(
@@ -127,7 +128,7 @@ def determine_cxx
 
   sig { void }
   def clang
-    super()
+    super
     replace_in_cflags(/-Xarch_#{Hardware::CPU.arch_32_bit} (-march=\S*)/, '\1')
     map = Hardware::CPU.optimization_flags.dup
     if DevelopmentTools.clang_build_version < 700
@@ -148,7 +149,8 @@ def libcxx
     append "CXX", "-stdlib=libc++" if compiler == :clang
   end
 
-  # @private
+  private
+
   sig { params(before: Regexp, after: String).void }
   def replace_in_cflags(before, after)
     CC_FLAG_VARS.each do |key|
@@ -164,7 +166,6 @@ def define_cflags(val)
 
   # Sets architecture-specific flags for every environment variable
   # given in the list `flags`.
-  # @private
   sig { params(flags: T::Array[String], map: T::Hash[Symbol, String]).void }
   def set_cpu_flags(flags, map = Hardware::CPU.optimization_flags)
     cflags =~ /(-Xarch_#{Hardware::CPU.arch_32_bit} )-march=/
@@ -177,21 +178,15 @@ def set_cpu_flags(flags, map = Hardware::CPU.optimization_flags)
     append flags, map.fetch(effective_arch)
   end
 
-  # @private
-  sig { params(map: T::Hash[Symbol, String]).void }
-  def set_cpu_cflags(map = Hardware::CPU.optimization_flags) # rubocop:disable Naming/AccessorMethodName
-    set_cpu_flags(CC_FLAG_VARS, map)
+  sig { returns(T::Array[Pathname]) }
+  def homebrew_extra_pkg_config_paths
+    []
   end
 
-  sig { returns(Integer) }
-  def make_jobs
-    Homebrew::EnvConfig.make_jobs.to_i
+  sig { params(map: T::Hash[Symbol, String]).void }
+  def set_cpu_cflags(map = Hardware::CPU.optimization_flags)
+    set_cpu_flags(CC_FLAG_VARS, map)
   end
-
-  # This method does nothing in stdenv since there's no arg refurbishment
-  # @private
-  sig { void }
-  def refurbish_args; end
 end
 
 require "extend/os/extend/ENV/std"
diff --git a/Library/Homebrew/extend/ENV/super.rb b/Library/Homebrew/extend/ENV/super.rb
index c89a4604c5097..c21bd3ce846f2 100644
--- a/Library/Homebrew/extend/ENV/super.rb
+++ b/Library/Homebrew/extend/ENV/super.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "extend/ENV/shared"
@@ -15,11 +15,8 @@
 # 7. Simpler formulae that *just work*
 # 8. Build-system agnostic configuration of the toolchain
 module Superenv
-  extend T::Sig
-
   include SharedEnvExtension
 
-  # @private
   attr_accessor :keg_only_deps, :deps, :run_time_deps
 
   sig { params(base: Superenv).void }
@@ -29,13 +26,14 @@ def self.extended(base)
     base.run_time_deps = []
   end
 
-  # The location of Homebrew's shims on this OS.
+  # The location of Homebrew's shims.
+  #
+  # @api public
   sig { returns(Pathname) }
   def self.shims_path
     HOMEBREW_SHIMS_PATH/"super"
   end
 
-  # @private
   sig { returns(T.nilable(Pathname)) }
   def self.bin; end
 
@@ -47,7 +45,6 @@ def reset
     delete("as_nl")
   end
 
-  # @private
   sig {
     params(
       formula:         T.nilable(Formula),
@@ -55,14 +52,17 @@ def reset
       build_bottle:    T.nilable(T::Boolean),
       bottle_arch:     T.nilable(String),
       testing_formula: T::Boolean,
+      debug_symbols:   T.nilable(T::Boolean),
     ).void
   }
-  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false)
+  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false,
+                              debug_symbols: false)
     super
     send(compiler)
 
     self["HOMEBREW_ENV"] = "super"
     self["MAKEFLAGS"] ||= "-j#{determine_make_jobs}"
+    self["RUSTFLAGS"] = Hardware.rustflags_target_cpu(effective_arch)
     self["PATH"] = determine_path
     self["PKG_CONFIG_PATH"] = determine_pkg_config_path
     self["PKG_CONFIG_LIBDIR"] = determine_pkg_config_libdir
@@ -75,6 +75,7 @@ def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_a
     self["HOMEBREW_TEMP"] = HOMEBREW_TEMP.to_s
     self["HOMEBREW_OPTFLAGS"] = determine_optflags
     self["HOMEBREW_ARCHFLAGS"] = ""
+    self["HOMEBREW_MAKE_JOBS"] = determine_make_jobs.to_s
     self["CMAKE_PREFIX_PATH"] = determine_cmake_prefix_path
     self["CMAKE_FRAMEWORK_PATH"] = determine_cmake_frameworks_path
     self["CMAKE_INCLUDE_PATH"] = determine_cmake_include_path
@@ -86,6 +87,19 @@ def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_a
     self["HOMEBREW_LIBRARY_PATHS"] = determine_library_paths
     self["HOMEBREW_DEPENDENCIES"] = determine_dependencies
     self["HOMEBREW_FORMULA_PREFIX"] = @formula.prefix unless @formula.nil?
+    # Prevent the OpenSSL rust crate from building a vendored OpenSSL.
+    # https://github.com/sfackler/rust-openssl/blob/994e5ff8c63557ab2aa85c85cc6956b0b0216ca7/openssl/src/lib.rs#L65
+    self["OPENSSL_NO_VENDOR"] = "1"
+    # Prevent Go from automatically downloading a newer toolchain than the one that we have.
+    # https://tip.golang.org/doc/toolchain
+    self["GOTOOLCHAIN"] = "local"
+    # Prevent Python packages from using bundled libraries by default.
+    # Currently for hidapi, pyzmq and pynacl
+    self["HIDAPI_SYSTEM_HIDAPI"] = "1"
+    self["PYZMQ_NO_BUNDLE"] = "1"
+    self["SODIUM_INSTALL"] = "system"
+
+    set_debug_symbols if debug_symbols
 
     # The HOMEBREW_CCCFG ENV variable is used by the ENV/cc tool to control
     # compiler flag stripping. It consists of a string of characters which act
@@ -99,7 +113,13 @@ def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_a
     # K - Don't strip -arch <arch>, -m32, or -m64
     # d - Don't strip -march=<target>. Use only in formulae that
     #     have runtime detection of CPU features.
-    # w - Pass -no_weak_imports to the linker
+    # D - Generate debugging information
+    # w - Pass `-no_weak_imports` to the linker
+    # f - Pass `-no_fixup_chains` to `ld` whenever it
+    #     is invoked with `-undefined dynamic_lookup`
+    # o - Pass `-oso_prefix` to `ld` whenever it is invoked
+    # c - Pass `-ld_classic` to `ld` whenever it is invoked
+    #     with `-dead_strip_dylibs`
     #
     # These flags will also be present:
     # a - apply fix for apr-1-config path
@@ -125,8 +145,13 @@ def determine_cxx
 
   sig { returns(T::Array[Pathname]) }
   def homebrew_extra_paths
-    []
+    # Reverse sort by version so that we prefer the newest when there are multiple.
+    deps.select { |d| d.name.match? Version.formula_optionally_versioned_regex(:python) }
+        .sort_by(&:version)
+        .reverse
+        .map { |d| d.opt_libexec/"bin" }
   end
+  alias generic_homebrew_extra_paths homebrew_extra_paths
 
   sig { returns(T.nilable(PATH)) }
   def determine_path
@@ -214,7 +239,9 @@ def determine_library_paths
       end
     end
 
-    paths << keg_only_deps.map(&:opt_lib)
+    # Don't add `llvm` to library paths; this leads to undesired linkage to LLVM's `libunwind`
+    paths << keg_only_deps.reject { |dep| dep.name.match?(/^llvm(@\d+)?$/) }
+                          .map(&:opt_lib)
     paths << (HOMEBREW_PREFIX/"lib")
 
     paths += homebrew_extra_library_paths
@@ -290,18 +317,21 @@ def determine_cccfg
   # Removes the MAKEFLAGS environment variable, causing make to use a single job.
   # This is useful for makefiles with race conditions.
   # When passed a block, MAKEFLAGS is removed only for the duration of the block and is restored after its completion.
-  sig { params(block: T.proc.returns(T.untyped)).returns(T.untyped) }
+  sig { params(block: T.nilable(T.proc.returns(T.untyped))).returns(T.untyped) }
   def deparallelize(&block)
-    old = delete("MAKEFLAGS")
+    old_makeflags = delete("MAKEFLAGS")
+    old_make_jobs = delete("HOMEBREW_MAKE_JOBS")
+    self["HOMEBREW_MAKE_JOBS"] = "1"
     if block
       begin
         yield
       ensure
-        self["MAKEFLAGS"] = old
+        self["MAKEFLAGS"] = old_makeflags
+        self["HOMEBREW_MAKE_JOBS"] = old_make_jobs
       end
     end
 
-    old
+    old_makeflags
   end
 
   sig { returns(Integer) }
@@ -331,7 +361,11 @@ def libcxx
     append_to_cccfg "g" if compiler == :clang
   end
 
-  # @private
+  sig { void }
+  def set_debug_symbols
+    append_to_cccfg "D"
+  end
+
   sig { void }
   def refurbish_args
     append_to_cccfg "O"
@@ -356,6 +390,15 @@ def O1(&block)
       self["HOMEBREW_OPTIMIZATION_LEVEL"] = "O1"
     end
   end
+
+  sig { params(block: T.nilable(T.proc.void)).void }
+  def O3(&block)
+    if block
+      with_env(HOMEBREW_OPTIMIZATION_LEVEL: "O3", &block)
+    else
+      self["HOMEBREW_OPTIMIZATION_LEVEL"] = "O3"
+    end
+  end
   # rubocop: enable Naming/MethodName
 end
 
diff --git a/Library/Homebrew/extend/api_hashable.rb b/Library/Homebrew/extend/api_hashable.rb
new file mode 100644
index 0000000000000..e1e4098e9516b
--- /dev/null
+++ b/Library/Homebrew/extend/api_hashable.rb
@@ -0,0 +1,35 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+# Used to substitute common paths with generic placeholders when generating JSON for the API.
+module APIHashable
+  def generating_hash!
+    return if generating_hash?
+
+    # Apply monkeypatches for API generation
+    @old_homebrew_prefix = HOMEBREW_PREFIX
+    @old_homebrew_cellar = HOMEBREW_CELLAR
+    @old_home = Dir.home
+    Object.send(:remove_const, :HOMEBREW_PREFIX)
+    Object.const_set(:HOMEBREW_PREFIX, Pathname.new(HOMEBREW_PREFIX_PLACEHOLDER))
+    ENV["HOME"] = HOMEBREW_HOME_PLACEHOLDER
+
+    @generating_hash = true
+  end
+
+  def generated_hash!
+    return unless generating_hash?
+
+    # Revert monkeypatches for API generation
+    Object.send(:remove_const, :HOMEBREW_PREFIX)
+    Object.const_set(:HOMEBREW_PREFIX, @old_homebrew_prefix)
+    ENV["HOME"] = @old_home
+
+    @generating_hash = false
+  end
+
+  def generating_hash?
+    @generating_hash ||= false
+    @generating_hash == true
+  end
+end
diff --git a/Library/Homebrew/extend/array.rb b/Library/Homebrew/extend/array.rb
new file mode 100644
index 0000000000000..7382084b699bd
--- /dev/null
+++ b/Library/Homebrew/extend/array.rb
@@ -0,0 +1,106 @@
+# typed: strict
+# frozen_string_literal: true
+
+class Array
+  # Equal to `self[1]`.
+  #
+  # ### Example
+  #
+  # ```ruby
+  # %w( a b c d e ).second # => "b"
+  # ```
+  def second = self[1]
+
+  # Equal to `self[2]`.
+  #
+  # ### Example
+  #
+  # ```ruby
+  # %w( a b c d e ).third # => "c"
+  # ```
+  def third = self[2]
+
+  # Equal to `self[3]`.
+  #
+  # ### Example
+  #
+  # ```ruby
+  # %w( a b c d e ).fourth # => "d"
+  # ```
+  def fourth = self[3]
+
+  # Equal to `self[4]`.
+  #
+  # ### Example
+  #
+  # ```ruby
+  # %w( a b c d e ).fifth # => "e"
+  # ```
+  def fifth = self[4]
+
+  # Converts the array to a comma-separated sentence where the last element is
+  # joined by the connector word.
+  #
+  # ### Examples
+  #
+  # ```ruby
+  # [].to_sentence                      # => ""
+  # ['one'].to_sentence                 # => "one"
+  # ['one', 'two'].to_sentence          # => "one and two"
+  # ['one', 'two', 'three'].to_sentence # => "one, two and three"
+  # ['one', 'two'].to_sentence(two_words_connector: '-')
+  # # => "one-two"
+  # ```
+  #
+  # ```
+  # ['one', 'two', 'three'].to_sentence(words_connector: ' or ', last_word_connector: ' or at least ')
+  # # => "one or two or at least three"
+  # ```
+  #
+  # @see https://github.com/rails/rails/blob/v7.0.4.2/activesupport/lib/active_support/core_ext/array/conversions.rb#L8-L84
+  #   ActiveSupport Array#to_sentence monkey-patch
+  #
+  #
+  # Copyright (c) David Heinemeier Hansson
+  #
+  # Permission is hereby granted, free of charge, to any person obtaining
+  # a copy of this software and associated documentation files (the
+  # "Software"), to deal in the Software without restriction, including
+  # without limitation the rights to use, copy, modify, merge, publish,
+  # distribute, sublicense and/or sell copies of the Software and to
+  # permit persons to whom the Software is furnished to do so, subject to
+  # the following conditions:
+  #
+  # The above copyright notice and this permission notice shall be
+  # included in all copies or substantial portions of the Software.
+  #
+  # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+  # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+  # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+  # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+  #
+  #
+  # @param [String] words_connector The sign or word used to join all but the last
+  #   element in arrays with three or more elements (default: `", "`).
+  # @param [String] last_word_connector The sign or word used to join the last element
+  #   in arrays with three or more elements (default: `" and "`).
+  # @param [String] two_words_connector The sign or word used to join the elements
+  #   in arrays with two elements (default: `" and "`).
+  sig { params(words_connector: String, two_words_connector: String, last_word_connector: String).returns(String) }
+  def to_sentence(words_connector: ", ", two_words_connector: " and ", last_word_connector: " and ")
+    case length
+    when 0
+      +""
+    when 1
+      # This is not typesafe, if the array contains a BasicObject
+      +T.unsafe(self[0]).to_s
+    when 2
+      "#{self[0]}#{two_words_connector}#{self[1]}"
+    else
+      "#{T.must(self[0...-1]).join(words_connector)}#{last_word_connector}#{self[-1]}"
+    end
+  end
+end
diff --git a/Library/Homebrew/extend/array.rbi b/Library/Homebrew/extend/array.rbi
new file mode 100644
index 0000000000000..3d9e293bd459b
--- /dev/null
+++ b/Library/Homebrew/extend/array.rbi
@@ -0,0 +1,15 @@
+# typed: strict
+
+class Array
+  sig { returns(T.nilable(Elem)) }
+  def second; end
+
+  sig { returns(T.nilable(Elem)) }
+  def third; end
+
+  sig { returns(T.nilable(Elem)) }
+  def fourth; end
+
+  sig { returns(T.nilable(Elem)) }
+  def fifth; end
+end
diff --git a/Library/Homebrew/extend/blank.rb b/Library/Homebrew/extend/blank.rb
new file mode 100644
index 0000000000000..85c5ea55b4761
--- /dev/null
+++ b/Library/Homebrew/extend/blank.rb
@@ -0,0 +1,199 @@
+# typed: strict
+# frozen_string_literal: true
+
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  #
+  # For example, `nil`, `''`, `'   '`, `[]`, `{}` and `false` are all blank.
+  #
+  # ### Example
+  #
+  # ```ruby
+  # !address || address.empty?
+  # ```
+  #
+  # can be simplified to
+  #
+  # ```ruby
+  # address.blank?
+  # ```
+  sig { returns(T::Boolean) }
+  def blank?
+    respond_to?(:empty?) ? !!T.unsafe(self).empty? : false
+  end
+
+  # An object is present if it's not blank.
+  sig { returns(T::Boolean) }
+  def present? = !blank?
+
+  # Returns the receiver if it's present, otherwise returns `nil`.
+  #
+  # `object.presence` is equivalent to `object.present? ? object : nil`.
+  #
+  # ### Example
+  #
+  # ```ruby
+  # state   = params[:state]   if params[:state].present?
+  # country = params[:country] if params[:country].present?
+  # region  = state || country || 'US'
+  # ```
+  #
+  # can be simplified to
+  #
+  # ```ruby
+  # region = params[:state].presence || params[:country].presence || 'US'
+  # ```
+  sig { returns(T.nilable(T.self_type)) }
+  def presence
+    self if present?
+  end
+end
+
+class NilClass
+  # `nil` is blank:
+  #
+  # ```ruby
+  # nil.blank? # => true
+  # ```
+  sig { returns(TrueClass) }
+  def blank? = true
+
+  sig { returns(FalseClass) }
+  def present? = false # :nodoc:
+end
+
+class FalseClass
+  # `false` is blank:
+  #
+  # ```ruby
+  # false.blank? # => true
+  # ```
+  sig { returns(TrueClass) }
+  def blank? = true
+
+  sig { returns(FalseClass) }
+  def present? = false # :nodoc:
+end
+
+class TrueClass
+  # `true` is not blank:
+  #
+  # ```ruby
+  # true.blank? # => false
+  # ```
+  sig { returns(FalseClass) }
+  def blank? = false
+
+  sig { returns(TrueClass) }
+  def present? = true # :nodoc:
+end
+
+class Array
+  # An array is blank if it's empty:
+  #
+  # ```ruby
+  # [].blank?      # => true
+  # [1,2,3].blank? # => false
+  # ```
+  sig { returns(T::Boolean) }
+  def blank? = empty?
+
+  sig { returns(T::Boolean) }
+  def present? = !empty? # :nodoc:
+end
+
+class Hash
+  # A hash is blank if it's empty:
+  #
+  #
+  # ```ruby
+  # {}.blank?                # => true
+  # { key: 'value' }.blank?  # => false
+  # ```
+  sig { returns(T::Boolean) }
+  def blank? = empty?
+
+  sig { returns(T::Boolean) }
+  def present? = !empty? # :nodoc:
+end
+
+class Symbol
+  # A Symbol is blank if it's empty:
+  #
+  # ```ruby
+  # :''.blank?     # => true
+  # :symbol.blank? # => false
+  # ```
+  sig { returns(T::Boolean) }
+  def blank? = empty?
+
+  sig { returns(T::Boolean) }
+  def present? = !empty? # :nodoc:
+end
+
+class String
+  BLANK_RE = /\A[[:space:]]*\z/
+  # This is a cache that is intentionally mutable
+  # rubocop:disable Style/MutableConstant
+  ENCODED_BLANKS_ = T.let(Hash.new do |h, enc|
+    h[enc] = Regexp.new(BLANK_RE.source.encode(enc), BLANK_RE.options | Regexp::FIXEDENCODING)
+  end, T::Hash[Encoding, Regexp])
+  # rubocop:enable Style/MutableConstant
+
+  # A string is blank if it's empty or contains whitespaces only:
+  #
+  # ```ruby
+  # ''.blank?       # => true
+  # '   '.blank?    # => true
+  # "\t\n\r".blank? # => true
+  # ' blah '.blank? # => false
+  # ```
+  #
+  # Unicode whitespace is supported:
+  #
+  # ```ruby
+  # "\u00a0".blank? # => true
+  # ```
+  sig { returns(T::Boolean) }
+  def blank?
+    # The regexp that matches blank strings is expensive. For the case of empty
+    # strings we can speed up this method (~3.5x) with an empty? call. The
+    # penalty for the rest of strings is marginal.
+    empty? ||
+      begin
+        BLANK_RE.match?(self)
+      rescue Encoding::CompatibilityError
+        T.must(ENCODED_BLANKS_[encoding]).match?(self)
+      end
+  end
+
+  sig { returns(T::Boolean) }
+  def present? = !blank? # :nodoc:
+end
+
+class Numeric # :nodoc:
+  # No number is blank:
+  #
+  # ```ruby
+  # 1.blank? # => false
+  # 0.blank? # => false
+  # ```
+  sig { returns(FalseClass) }
+  def blank? = false
+
+  sig { returns(TrueClass) }
+  def present? = true
+end
+
+class Time # :nodoc:
+  # No Time is blank:
+  #
+  # ```ruby
+  # Time.now.blank? # => false
+  # ```
+  sig { returns(FalseClass) }
+  def blank? = false
+
+  sig { returns(TrueClass) }
+  def present? = true
+end
diff --git a/Library/Homebrew/extend/cachable.rb b/Library/Homebrew/extend/cachable.rb
index c90e9ca474e0b..d3d2794bc38a4 100644
--- a/Library/Homebrew/extend/cachable.rb
+++ b/Library/Homebrew/extend/cachable.rb
@@ -1,12 +1,22 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Cachable
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
   def cache
-    @cache ||= {}
+    @cache ||= T.let({}, T.nilable(T::Hash[T.untyped, T.untyped]))
   end
 
+  # NOTE: We overwrite here instead of using `Hash#clear` to handle frozen hashes.
+  sig { void }
   def clear_cache
-    cache.clear
+    overwrite_cache!({})
+  end
+
+  private
+
+  sig { params(hash: T::Hash[T.untyped, T.untyped]).void }
+  def overwrite_cache!(hash)
+    @cache = hash
   end
 end
diff --git a/Library/Homebrew/extend/enumerable.rb b/Library/Homebrew/extend/enumerable.rb
new file mode 100644
index 0000000000000..5f8ca22f17e09
--- /dev/null
+++ b/Library/Homebrew/extend/enumerable.rb
@@ -0,0 +1,38 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Enumerable
+  # The negative of the {Enumerable#include?}. Returns `true` if the
+  # collection does not include the object.
+  sig { params(object: T.untyped).returns(T::Boolean) }
+  def exclude?(object) = !include?(object)
+
+  # Returns a new +Array+ without the blank items.
+  # Uses Object#blank? for determining if an item is blank.
+  #
+  # ### Examples
+  #
+  # ```
+  # [1, "", nil, 2, " ", [], {}, false, true].compact_blank
+  # # =>  [1, 2, true]
+  # ```
+  #
+  # ```ruby
+  # Set.new([nil, "", 1, false]).compact_blank
+  # # => [1]
+  # ```
+  #
+  # When called on a {Hash}, returns a new {Hash} without the blank values.
+  #
+  # ```ruby
+  # { a: "", b: 1, c: nil, d: [], e: false, f: true }.compact_blank
+  # # => { b: 1, f: true }
+  # ```
+  sig { returns(T.self_type) }
+  def compact_blank = T.unsafe(self).reject(&:blank?)
+end
+
+class Hash
+  # {Hash#reject} has its own definition, so this needs one too.
+  def compact_blank = reject { |_k, v| T.unsafe(v).blank? }
+end
diff --git a/Library/Homebrew/extend/enumerable.rbi b/Library/Homebrew/extend/enumerable.rbi
new file mode 100644
index 0000000000000..207de60eb603d
--- /dev/null
+++ b/Library/Homebrew/extend/enumerable.rbi
@@ -0,0 +1,6 @@
+# typed: strict
+
+class Hash
+  sig { returns(T::Hash[Hash::K, Hash::V]) }
+  def compact_blank; end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/file/atomic.rb b/Library/Homebrew/extend/file/atomic.rb
similarity index 75%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/file/atomic.rb
rename to Library/Homebrew/extend/file/atomic.rb
index 9deceb1bb44d5..b57c9cc8504c9 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/file/atomic.rb
+++ b/Library/Homebrew/extend/file/atomic.rb
@@ -1,3 +1,4 @@
+# typed: strict
 # frozen_string_literal: true
 
 require "fileutils"
@@ -18,7 +19,14 @@ class File
   #   File.atomic_write('/data/something.important', '/data/tmp') do |file|
   #     file.write('hello')
   #   end
-  def self.atomic_write(file_name, temp_dir = dirname(file_name))
+  sig {
+    type_parameters(:out).params(
+      file_name: T.any(Pathname, String),
+      temp_dir:  String,
+      _block:    T.proc.params(arg0: Tempfile).returns(T.type_parameter(:out)),
+    ).returns(T.type_parameter(:out))
+  }
+  def self.atomic_write(file_name, temp_dir = dirname(file_name), &_block)
     require "tempfile" unless defined?(Tempfile)
 
     Tempfile.open(".#{basename(file_name)}", temp_dir) do |temp_file|
@@ -38,32 +46,35 @@ def self.atomic_write(file_name, temp_dir = dirname(file_name))
       if old_stat
         # Set correct permissions on new file
         begin
-          chown(old_stat.uid, old_stat.gid, temp_file.path)
+          chown(old_stat.uid, old_stat.gid, T.must(temp_file.path))
           # This operation will affect filesystem ACL's
-          chmod(old_stat.mode, temp_file.path)
+          chmod(old_stat.mode, T.must(temp_file.path))
         rescue Errno::EPERM, Errno::EACCES
           # Changing file ownership failed, moving on.
         end
       end
 
       # Overwrite original file with temp file
-      rename(temp_file.path, file_name)
+      rename(T.must(temp_file.path), file_name)
       return_val
     end
   end
 
   # Private utility method.
-  def self.probe_stat_in(dir) #:nodoc:
+  sig { params(dir: String).returns(T.nilable(File::Stat)) }
+  private_class_method def self.probe_stat_in(dir) # :nodoc:
     basename = [
       ".permissions_check",
       Thread.current.object_id,
       Process.pid,
-      rand(1000000)
+      rand(1_000_000),
     ].join(".")
 
     file_name = join(dir, basename)
     FileUtils.touch(file_name)
     stat(file_name)
+  rescue Errno::ENOENT
+    file_name = nil
   ensure
     FileUtils.rm_f(file_name) if file_name
   end
diff --git a/Library/Homebrew/extend/git_repository.rb b/Library/Homebrew/extend/git_repository.rb
deleted file mode 100644
index a91ec91704529..0000000000000
--- a/Library/Homebrew/extend/git_repository.rb
+++ /dev/null
@@ -1,122 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "utils/git"
-require "utils/popen"
-
-# Extensions to {Pathname} for querying Git repository information.
-# @see Utils::Git
-# @api private
-module GitRepositoryExtension
-  extend T::Sig
-
-  sig { returns(T::Boolean) }
-  def git?
-    join(".git").exist?
-  end
-
-  # Gets the URL of the Git origin remote.
-  sig { returns(T.nilable(String)) }
-  def git_origin
-    popen_git("config", "--get", "remote.origin.url")
-  end
-
-  # Sets the URL of the Git origin remote.
-  sig { params(origin: String).returns(T.nilable(T::Boolean)) }
-  def git_origin=(origin)
-    return if !git? || !Utils::Git.available?
-
-    safe_system Utils::Git.git, "remote", "set-url", "origin", origin, chdir: self
-  end
-
-  # Gets the full commit hash of the HEAD commit.
-  sig { params(safe: T::Boolean).returns(T.nilable(String)) }
-  def git_head(safe: false)
-    popen_git("rev-parse", "--verify", "--quiet", "HEAD", safe: safe)
-  end
-
-  # Gets a short commit hash of the HEAD commit.
-  sig { params(length: T.nilable(Integer), safe: T::Boolean).returns(T.nilable(String)) }
-  def git_short_head(length: nil, safe: false)
-    short_arg = length.present? ? "--short=#{length}" : "--short"
-    popen_git("rev-parse", short_arg, "--verify", "--quiet", "HEAD", safe: safe)
-  end
-
-  # Gets the relative date of the last commit, e.g. "1 hour ago"
-  sig { returns(T.nilable(String)) }
-  def git_last_commit
-    popen_git("show", "-s", "--format=%cr", "HEAD")
-  end
-
-  # Gets the name of the currently checked-out branch, or HEAD if the repository is in a detached HEAD state.
-  sig { params(safe: T::Boolean).returns(T.nilable(String)) }
-  def git_branch(safe: false)
-    popen_git("rev-parse", "--abbrev-ref", "HEAD", safe: safe)
-  end
-
-  # Change the name of a local branch
-  sig { params(old: String, new: String).void }
-  def git_rename_branch(old:, new:)
-    popen_git("branch", "-m", old, new)
-  end
-
-  # Set an upstream branch for a local branch to track
-  sig { params(local: String, origin: String).void }
-  def git_branch_set_upstream(local:, origin:)
-    popen_git("branch", "-u", "origin/#{origin}", local)
-  end
-
-  # Gets the name of the default origin HEAD branch.
-  sig { returns(T.nilable(String)) }
-  def git_origin_branch
-    popen_git("symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD")&.split("/")&.last
-  end
-
-  # Returns true if the repository's current branch matches the default origin branch.
-  sig { returns(T.nilable(T::Boolean)) }
-  def git_default_origin_branch?
-    git_origin_branch == git_branch
-  end
-
-  # Returns the date of the last commit, in YYYY-MM-DD format.
-  sig { returns(T.nilable(String)) }
-  def git_last_commit_date
-    popen_git("show", "-s", "--format=%cd", "--date=short", "HEAD")
-  end
-
-  # Returns true if the given branch exists on origin
-  sig { params(branch: String).returns(T::Boolean) }
-  def git_origin_has_branch?(branch)
-    popen_git("ls-remote", "--heads", "origin", branch).present?
-  end
-
-  sig { void }
-  def git_origin_set_head_auto
-    popen_git("remote", "set-head", "origin", "--auto")
-  end
-
-  # Gets the full commit message of the specified commit, or of the HEAD commit if unspecified.
-  sig { params(commit: String, safe: T::Boolean).returns(T.nilable(String)) }
-  def git_commit_message(commit = "HEAD", safe: false)
-    popen_git("log", "-1", "--pretty=%B", commit, "--", safe: safe, err: :out)&.strip
-  end
-
-  private
-
-  sig { params(args: T.untyped, safe: T::Boolean, err: T.nilable(Symbol)).returns(T.nilable(String)) }
-  def popen_git(*args, safe: false, err: nil)
-    unless git?
-      return unless safe
-
-      raise "Not a Git repository: #{self}"
-    end
-
-    unless Utils::Git.available?
-      return unless safe
-
-      raise "Git is unavailable"
-    end
-
-    T.unsafe(Utils).popen_read(Utils::Git.git, *args, safe: safe, chdir: self, err: err).chomp.presence
-  end
-end
diff --git a/Library/Homebrew/extend/git_repository.rbi b/Library/Homebrew/extend/git_repository.rbi
deleted file mode 100644
index 534b936b966dc..0000000000000
--- a/Library/Homebrew/extend/git_repository.rbi
+++ /dev/null
@@ -1,8 +0,0 @@
-# typed: strict
-
-module GitRepositoryExtension
-  include Kernel
-
-  sig { params(args: T.any(String, Pathname)).returns(Pathname) }
-  def join(*args); end
-end
diff --git a/Library/Homebrew/extend/hash/deep_merge.rb b/Library/Homebrew/extend/hash/deep_merge.rb
new file mode 100644
index 0000000000000..527e36076bc2b
--- /dev/null
+++ b/Library/Homebrew/extend/hash/deep_merge.rb
@@ -0,0 +1,41 @@
+# typed: strict
+# frozen_string_literal: true
+
+class Hash
+  # Returns a new hash with `self` and `other_hash` merged recursively.
+  #
+  # ### Examples
+  #
+  # ```ruby
+  # h1 = { a: true, b: { c: [1, 2, 3] } }
+  # h2 = { a: false, b: { x: [3, 4, 5] } }
+  #
+  # h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+  # ```
+  #
+  # Like with Hash#merge in the standard library, a block can be provided
+  # to merge values:
+  #
+  # ```ruby
+  # h1 = { a: 100, b: 200, c: { c1: 100 } }
+  # h2 = { b: 250, c: { c1: 200 } }
+  # h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
+  # # => { a: 100, b: 450, c: { c1: 300 } }
+  # ```
+  def deep_merge(other_hash, &block)
+    dup.deep_merge!(other_hash, &block)
+  end
+
+  # Same as {#deep_merge}, but modifies `self`.
+  def deep_merge!(other_hash, &block)
+    merge!(other_hash) do |key, this_val, other_val|
+      if T.unsafe(this_val).is_a?(Hash) && other_val.is_a?(Hash)
+        T.unsafe(this_val).deep_merge(other_val, &block)
+      elsif block
+        yield(key, this_val, other_val)
+      else
+        other_val
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/extend/hash/deep_merge.rbi b/Library/Homebrew/extend/hash/deep_merge.rbi
new file mode 100644
index 0000000000000..a2a316e1b54e3
--- /dev/null
+++ b/Library/Homebrew/extend/hash/deep_merge.rbi
@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+class Hash
+  sig {
+    type_parameters(:k2).params(
+      other_hash: T::Hash[T.type_parameter(:k2), T.untyped],
+      block:      T.nilable(T.proc.params(k: T.untyped, v1: T.untyped, v2: T.untyped).returns(T.untyped)),
+    ).returns(T::Hash[T.any(Hash::K, T.type_parameter(:k2)), T.untyped])
+  }
+  def deep_merge(other_hash, &block); end
+
+  sig {
+    type_parameters(:k2).params(
+      other_hash: T::Hash[T.type_parameter(:k2), T.untyped],
+      block:      T.nilable(T.proc.params(k: T.untyped, v1: T.untyped, v2: T.untyped).returns(T.untyped)),
+    ).returns(T::Hash[T.any(Hash::K, T.type_parameter(:k2)), T.untyped])
+  }
+  def deep_merge!(other_hash, &block); end
+end
diff --git a/Library/Homebrew/extend/hash/deep_transform_values.rb b/Library/Homebrew/extend/hash/deep_transform_values.rb
new file mode 100644
index 0000000000000..be366f1b140bc
--- /dev/null
+++ b/Library/Homebrew/extend/hash/deep_transform_values.rb
@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+class Hash
+  # Returns a new hash with all values converted by the block operation.
+  # This includes the values from the root hash and from all
+  # nested hashes and arrays.
+  #
+  # ### Example
+  #
+  # ```ruby
+  # hash = { person: { name: 'Rob', age: '28' } }
+  #
+  # hash.deep_transform_values{ |value| value.to_s.upcase }
+  # # => {person: {name: "ROB", age: "28"}}
+  # ```
+  def deep_transform_values(&block) = _deep_transform_values_in_object(self, &block)
+
+  # Destructively converts all values by using the block operation.
+  # This includes the values from the root hash and from all
+  # nested hashes and arrays.
+  def deep_transform_values!(&block) = _deep_transform_values_in_object!(self, &block)
+
+  private
+
+  # Support methods for deep transforming nested hashes and arrays.
+  sig { params(object: T.anything, block: T.proc.params(v: T.untyped).returns(T.untyped)).returns(T.untyped) }
+  def _deep_transform_values_in_object(object, &block)
+    case object
+    when Hash
+      object.transform_values { |value| _deep_transform_values_in_object(value, &block) }
+    when Array
+      object.map { |e| _deep_transform_values_in_object(e, &block) }
+    else
+      yield(object)
+    end
+  end
+
+  sig { params(object: T.anything, block: T.proc.params(v: T.untyped).returns(T.untyped)).returns(T.untyped) }
+  def _deep_transform_values_in_object!(object, &block)
+    case object
+    when Hash
+      object.transform_values! { |value| _deep_transform_values_in_object!(value, &block) }
+    when Array
+      object.map! { |e| _deep_transform_values_in_object!(e, &block) }
+    else
+      yield(object)
+    end
+  end
+end
diff --git a/Library/Homebrew/extend/hash/deep_transform_values.rbi b/Library/Homebrew/extend/hash/deep_transform_values.rbi
new file mode 100644
index 0000000000000..8eece3e2dc95e
--- /dev/null
+++ b/Library/Homebrew/extend/hash/deep_transform_values.rbi
@@ -0,0 +1,17 @@
+# typed: strict
+
+class Hash
+  sig {
+    type_parameters(:out).params(
+      block: T.proc.params(o: Hash::V).returns(T.type_parameter(:out)),
+    ).returns(T::Hash[Hash::K, T.type_parameter(:out)])
+  }
+  def deep_transform_values(&block); end
+
+  sig {
+    type_parameters(:out).params(
+      block: T.proc.params(o: Hash::V).returns(T.type_parameter(:out)),
+    ).returns(T::Hash[Hash::K, T.type_parameter(:out)])
+  }
+  def deep_transform_values!(&block); end
+end
diff --git a/Library/Homebrew/extend/hash/keys.rb b/Library/Homebrew/extend/hash/keys.rb
new file mode 100644
index 0000000000000..eb4b88e33e1c9
--- /dev/null
+++ b/Library/Homebrew/extend/hash/keys.rb
@@ -0,0 +1,133 @@
+# typed: strict
+# frozen_string_literal: true
+
+class Hash
+  # Validates all keys in a hash match `*valid_keys`, raising
+  # `ArgumentError` on a mismatch.
+  #
+  # Note that keys are treated differently than `HashWithIndifferentAccess`,
+  # meaning that string and symbol keys will not match.
+  #
+  # ### Example#
+  #
+  # ```ruby
+  # { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age)
+  # # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
+  # { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age')
+  # # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
+  # { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
+  # ```
+  sig { params(valid_keys: T.untyped).void }
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+    each_key do |k|
+      next if valid_keys.include?(k)
+
+      raise ArgumentError,
+            "Unknown key: #{T.unsafe(k).inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(", ")}"
+    end
+  end
+
+  # Returns a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  # ### Example
+  #
+  # ```ruby
+  # hash = { person: { name: 'Rob', age: '28' } }
+  #
+  # hash.deep_transform_keys{ |key| key.to_s.upcase }
+  # # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  # ```
+  def deep_transform_keys(&block) = _deep_transform_keys_in_object(self, &block)
+
+  # Destructively converts all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_transform_keys!(&block) = _deep_transform_keys_in_object!(self, &block)
+
+  # Returns a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  # ### Example
+  #
+  # ```ruby
+  # hash = { person: { name: 'Rob', age: '28' } }
+  #
+  # hash.deep_stringify_keys
+  # # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
+  # ```
+  def deep_stringify_keys = T.unsafe(self).deep_transform_keys(&:to_s)
+
+  # Destructively converts all keys to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_stringify_keys! = T.unsafe(self).deep_transform_keys!(&:to_s)
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to `to_sym`. This includes the keys from the root hash
+  # and from all nested hashes and arrays.
+  #
+  # ### Example
+  #
+  # ```ruby
+  # hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  # hash.deep_symbolize_keys
+  # # => {:person=>{:name=>"Rob", :age=>"28"}}
+  # ```
+  def deep_symbolize_keys
+    deep_transform_keys do |key|
+      T.unsafe(key).to_sym
+    rescue
+      key
+    end
+  end
+
+  # Destructively converts all keys to symbols, as long as they respond
+  # to `to_sym`. This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_symbolize_keys!
+    deep_transform_keys! do |key|
+      T.unsafe(key).to_sym
+    rescue
+      key
+    end
+  end
+
+  private
+
+  # Support methods for deep transforming nested hashes and arrays.
+  sig { params(object: T.anything, block: T.proc.params(k: T.untyped).returns(T.untyped)).returns(T.untyped) }
+  def _deep_transform_keys_in_object(object, &block)
+    case object
+    when Hash
+      object.each_with_object({}) do |(key, value), result|
+        result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+      end
+    when Array
+      object.map { |e| _deep_transform_keys_in_object(e, &block) }
+    else
+      object
+    end
+  end
+
+  sig { params(object: T.anything, block: T.proc.params(k: T.untyped).returns(T.untyped)).returns(T.untyped) }
+  def _deep_transform_keys_in_object!(object, &block)
+    case object
+    when Hash
+      # We can't use `each_key` here because we're updating the hash in-place.
+      object.keys.each do |key|
+        value = object.delete(key)
+        object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+      end
+      object
+    when Array
+      object.map! { |e| _deep_transform_keys_in_object!(e, &block) }
+    else
+      object
+    end
+  end
+end
diff --git a/Library/Homebrew/extend/hash/keys.rbi b/Library/Homebrew/extend/hash/keys.rbi
new file mode 100644
index 0000000000000..ed4e6a6eb8cc9
--- /dev/null
+++ b/Library/Homebrew/extend/hash/keys.rbi
@@ -0,0 +1,30 @@
+# typed: strict
+# frozen_string_literal: true
+
+class Hash
+  sig {
+    type_parameters(:out).params(
+      block: T.proc.params(o: K).returns(T.type_parameter(:out)),
+    ).returns(T::Hash[T.type_parameter(:out), V])
+  }
+  def deep_transform_keys(&block); end
+
+  sig {
+    type_parameters(:out).params(
+      block: T.proc.params(o: K).returns(T.type_parameter(:out)),
+    ).returns(T::Hash[T.type_parameter(:out), V])
+  }
+  def deep_transform_keys!(&block); end
+
+  sig { returns(T::Hash[String, V]) }
+  def deep_stringify_keys; end
+
+  sig { returns(T::Hash[String, V]) }
+  def deep_stringify_keys!; end
+
+  sig { returns(T::Hash[Symbol, V]) }
+  def deep_symbolize_keys; end
+
+  sig { returns(T::Hash[Symbol, V]) }
+  def deep_symbolize_keys!; end
+end
diff --git a/Library/Homebrew/extend/hash_validator.rb b/Library/Homebrew/extend/hash_validator.rb
deleted file mode 100644
index 09cfbe68a3923..0000000000000
--- a/Library/Homebrew/extend/hash_validator.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-module HashValidator
-  refine Hash do
-    def assert_valid_keys!(*valid_keys)
-      unknown_keys = keys - valid_keys
-      return if unknown_keys.empty?
-
-      raise ArgumentError, "invalid keys: #{unknown_keys.map(&:inspect).join(", ")}"
-    end
-  end
-end
diff --git a/Library/Homebrew/extend/hash_validator.rbi b/Library/Homebrew/extend/hash_validator.rbi
deleted file mode 100644
index 715b783813ac5..0000000000000
--- a/Library/Homebrew/extend/hash_validator.rbi
+++ /dev/null
@@ -1,6 +0,0 @@
-# typed: strict
-
-class Hash
-  sig { params(valid_keys: T.untyped).void }
-  def assert_valid_keys!(*valid_keys); end
-end
diff --git a/Library/Homebrew/extend/io.rb b/Library/Homebrew/extend/io.rb
index f5d36dfc84f8b..a6eb7d4b70a4a 100644
--- a/Library/Homebrew/extend/io.rb
+++ b/Library/Homebrew/extend/io.rb
@@ -1,22 +1,25 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 class IO
+  sig { params(sep: String).returns(String) }
   def readline_nonblock(sep = $INPUT_RECORD_SEPARATOR)
     line = +""
     buffer = +""
 
-    loop do
-      break if buffer == sep
+    begin
+      loop do
+        break if buffer == sep
 
-      read_nonblock(1, buffer)
-      line.concat(buffer)
-    end
+        read_nonblock(1, buffer)
+        line.concat(buffer)
+      end
 
-    line.freeze
-  rescue IO::WaitReadable, EOFError => e
-    raise e if line.empty?
+      line.freeze
+    rescue IO::WaitReadable, EOFError
+      raise if line.empty?
 
-    line.freeze
+      line.freeze
+    end
   end
 end
diff --git a/Library/Homebrew/extend/kernel.rb b/Library/Homebrew/extend/kernel.rb
new file mode 100644
index 0000000000000..50484d47de70c
--- /dev/null
+++ b/Library/Homebrew/extend/kernel.rb
@@ -0,0 +1,562 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+# Contains shorthand Homebrew utility methods like `ohai`, `opoo`, `odisabled`.
+# TODO: move these out of `Kernel`.
+
+module Kernel
+  def require?(path)
+    return false if path.nil?
+
+    require path
+    true
+  rescue LoadError => e
+    # we should raise on syntax errors but not if the file doesn't exist.
+    raise unless e.message.include?(path)
+  end
+
+  def ohai_title(title)
+    verbose = if respond_to?(:verbose?)
+      T.unsafe(self).verbose?
+    else
+      Context.current.verbose?
+    end
+
+    title = Tty.truncate(title.to_s) if $stdout.tty? && !verbose
+    Formatter.headline(title, color: :blue)
+  end
+
+  def ohai(title, *sput)
+    puts ohai_title(title)
+    puts sput
+  end
+
+  def odebug(title, *sput, always_display: false)
+    debug = if respond_to?(:debug)
+      T.unsafe(self).debug?
+    else
+      Context.current.debug?
+    end
+
+    return if !debug && !always_display
+
+    $stderr.puts Formatter.headline(title, color: :magenta)
+    $stderr.puts sput unless sput.empty?
+  end
+
+  def oh1_title(title, truncate: :auto)
+    verbose = if respond_to?(:verbose?)
+      T.unsafe(self).verbose?
+    else
+      Context.current.verbose?
+    end
+
+    title = Tty.truncate(title.to_s) if $stdout.tty? && !verbose && truncate == :auto
+    Formatter.headline(title, color: :green)
+  end
+
+  def oh1(title, truncate: :auto)
+    puts oh1_title(title, truncate:)
+  end
+
+  # Print a warning message.
+  #
+  # @api public
+  sig { params(message: T.any(String, Exception)).void }
+  def opoo(message)
+    require "utils/github/actions"
+    return if GitHub::Actions.puts_annotation_if_env_set(:warning, message.to_s)
+
+    require "utils/formatter"
+
+    Tty.with($stderr) do |stderr|
+      stderr.puts Formatter.warning(message, label: "Warning")
+    end
+  end
+
+  # Print an error message.
+  #
+  # @api public
+  sig { params(message: T.any(String, Exception)).void }
+  def onoe(message)
+    require "utils/github/actions"
+    return if GitHub::Actions.puts_annotation_if_env_set(:error, message.to_s)
+
+    require "utils/formatter"
+
+    Tty.with($stderr) do |stderr|
+      stderr.puts Formatter.error(message, label: "Error")
+    end
+  end
+
+  # Print an error message and fail at the end of the program.
+  #
+  # @api public
+  sig { params(error: T.any(String, Exception)).void }
+  def ofail(error)
+    onoe error
+    Homebrew.failed = true
+  end
+
+  # Print an error message and fail immediately.
+  #
+  # @api public
+  sig { params(error: T.any(String, Exception)).returns(T.noreturn) }
+  def odie(error)
+    onoe error
+    exit 1
+  end
+
+  # Output a deprecation warning/error message.
+  def odeprecated(method, replacement = nil,
+                  disable:                false,
+                  disable_on:             nil,
+                  disable_for_developers: true,
+                  caller:                 send(:caller))
+    replacement_message = if replacement
+      "Use #{replacement} instead."
+    else
+      "There is no replacement."
+    end
+
+    unless disable_on.nil?
+      if disable_on > Time.now
+        will_be_disabled_message = " and will be disabled on #{disable_on.strftime("%Y-%m-%d")}"
+      else
+        disable = true
+      end
+    end
+
+    verb = if disable
+      "disabled"
+    else
+      "deprecated#{will_be_disabled_message}"
+    end
+
+    # Try to show the most relevant location in message, i.e. (if applicable):
+    # - Location in a formula.
+    # - Location of caller of deprecated method (if all else fails).
+    backtrace = caller
+
+    # Don't throw deprecations at all for cached, .brew or .metadata files.
+    return if backtrace.any? do |line|
+      next true if line.include?(HOMEBREW_CACHE.to_s)
+      next true if line.include?("/.brew/")
+      next true if line.include?("/.metadata/")
+
+      next false unless line.match?(HOMEBREW_TAP_PATH_REGEX)
+
+      path = Pathname(line.split(":", 2).first)
+      next false unless path.file?
+      next false unless path.readable?
+
+      formula_contents = path.read
+      formula_contents.include?(" deprecate! ") || formula_contents.include?(" disable! ")
+    end
+
+    tap_message = T.let(nil, T.nilable(String))
+
+    backtrace.each do |line|
+      next unless (match = line.match(HOMEBREW_TAP_PATH_REGEX))
+
+      require "tap"
+
+      tap = Tap.fetch(match[:user], match[:repository])
+      tap_message = "\nPlease report this issue to the #{tap.full_name} tap"
+      tap_message += " (not Homebrew/brew or Homebrew/homebrew-core)" unless tap.official?
+      tap_message += ", or even better, submit a PR to fix it" if replacement
+      tap_message << ":\n  #{line.sub(/^(.*:\d+):.*$/, '\1')}\n\n"
+      break
+    end
+    file, line, = backtrace.first.split(":")
+    line = line.to_i if line.present?
+
+    message = "Calling #{method} is #{verb}! #{replacement_message}"
+    message << tap_message if tap_message
+    message.freeze
+
+    disable = true if disable_for_developers && Homebrew::EnvConfig.developer?
+    if disable || Homebrew.raise_deprecation_exceptions?
+      require "utils/github/actions"
+      GitHub::Actions.puts_annotation_if_env_set(:error, message, file:, line:)
+      exception = MethodDeprecatedError.new(message)
+      exception.set_backtrace(backtrace)
+      raise exception
+    elsif !Homebrew.auditing?
+      opoo message
+    end
+  end
+
+  def odisabled(method, replacement = nil, **options)
+    options = { disable: true, caller: }.merge(options)
+    # This odeprecated should stick around indefinitely.
+    odeprecated(method, replacement, **options)
+  end
+
+  def pretty_installed(formula)
+    if !$stdout.tty?
+      formula.to_s
+    elsif Homebrew::EnvConfig.no_emoji?
+      Formatter.success("#{Tty.bold}#{formula} (installed)#{Tty.reset}")
+    else
+      "#{Tty.bold}#{formula} #{Formatter.success("✔")}#{Tty.reset}"
+    end
+  end
+
+  def pretty_outdated(formula)
+    if !$stdout.tty?
+      formula.to_s
+    elsif Homebrew::EnvConfig.no_emoji?
+      Formatter.error("#{Tty.bold}#{formula} (outdated)#{Tty.reset}")
+    else
+      "#{Tty.bold}#{formula} #{Formatter.warning("⚠")}#{Tty.reset}"
+    end
+  end
+
+  def pretty_uninstalled(formula)
+    if !$stdout.tty?
+      formula.to_s
+    elsif Homebrew::EnvConfig.no_emoji?
+      Formatter.error("#{Tty.bold}#{formula} (uninstalled)#{Tty.reset}")
+    else
+      "#{Tty.bold}#{formula} #{Formatter.error("✘")}#{Tty.reset}"
+    end
+  end
+
+  def pretty_duration(seconds)
+    seconds = seconds.to_i
+    res = +""
+
+    if seconds > 59
+      minutes = seconds / 60
+      seconds %= 60
+      res = +Utils.pluralize("minute", minutes, include_count: true)
+      return res.freeze if seconds.zero?
+
+      res << " "
+    end
+
+    res << Utils.pluralize("second", seconds, include_count: true)
+    res.freeze
+  end
+
+  def interactive_shell(formula = nil)
+    unless formula.nil?
+      ENV["HOMEBREW_DEBUG_PREFIX"] = formula.prefix
+      ENV["HOMEBREW_DEBUG_INSTALL"] = formula.full_name
+    end
+
+    if Utils::Shell.preferred == :zsh && (home = Dir.home).start_with?(HOMEBREW_TEMP.resolved_path.to_s)
+      FileUtils.mkdir_p home
+      FileUtils.touch "#{home}/.zshrc"
+    end
+
+    Process.wait fork { exec Utils::Shell.preferred_path(default: "/bin/bash") }
+
+    return if $CHILD_STATUS.success?
+    raise "Aborted due to non-zero exit status (#{$CHILD_STATUS.exitstatus})" if $CHILD_STATUS.exited?
+
+    raise $CHILD_STATUS.inspect
+  end
+
+  def with_homebrew_path(&block)
+    with_env(PATH: PATH.new(ORIGINAL_PATHS), &block)
+  end
+
+  def with_custom_locale(locale, &block)
+    with_env(LC_ALL: locale, &block)
+  end
+
+  # Kernel.system but with exceptions.
+  def safe_system(cmd, *args, **options)
+    require "utils"
+
+    return if Homebrew.system(cmd, *args, **options)
+
+    raise ErrorDuringExecution.new([cmd, *args], status: $CHILD_STATUS)
+  end
+
+  # Run a system command without any output.
+  #
+  # @api internal
+  def quiet_system(cmd, *args)
+    require "utils"
+
+    Homebrew._system(cmd, *args) do
+      # Redirect output streams to `/dev/null` instead of closing as some programs
+      # will fail to execute if they can't write to an open stream.
+      $stdout.reopen("/dev/null")
+      $stderr.reopen("/dev/null")
+    end
+  end
+
+  # Find a command.
+  #
+  # @api public
+  def which(cmd, path = ENV.fetch("PATH"))
+    PATH.new(path).each do |p|
+      begin
+        pcmd = File.expand_path(cmd, p)
+      rescue ArgumentError
+        # File.expand_path will raise an ArgumentError if the path is malformed.
+        # See https://github.com/Homebrew/legacy-homebrew/issues/32789
+        next
+      end
+      return Pathname.new(pcmd) if File.file?(pcmd) && File.executable?(pcmd)
+    end
+    nil
+  end
+
+  def which_all(cmd, path = ENV.fetch("PATH"))
+    PATH.new(path).filter_map do |p|
+      begin
+        pcmd = File.expand_path(cmd, p)
+      rescue ArgumentError
+        # File.expand_path will raise an ArgumentError if the path is malformed.
+        # See https://github.com/Homebrew/legacy-homebrew/issues/32789
+        next
+      end
+      Pathname.new(pcmd) if File.file?(pcmd) && File.executable?(pcmd)
+    end.uniq
+  end
+
+  def which_editor(silent: false)
+    editor = Homebrew::EnvConfig.editor
+    return editor if editor
+
+    # Find VS Code, Sublime Text, Textmate, BBEdit, or vim
+    editor = %w[code subl mate bbedit vim].find do |candidate|
+      candidate if which(candidate, ORIGINAL_PATHS)
+    end
+    editor ||= "vim"
+
+    unless silent
+      opoo <<~EOS
+        Using #{editor} because no editor was set in the environment.
+        This may change in the future, so we recommend setting EDITOR
+        or HOMEBREW_EDITOR to your preferred text editor.
+      EOS
+    end
+
+    editor
+  end
+
+  def exec_editor(*args)
+    puts "Editing #{args.join "\n"}"
+    with_homebrew_path { safe_system(*which_editor.shellsplit, *args) }
+  end
+
+  def exec_browser(*args)
+    browser = Homebrew::EnvConfig.browser
+    browser ||= OS::PATH_OPEN if defined?(OS::PATH_OPEN)
+    return unless browser
+
+    ENV["DISPLAY"] = Homebrew::EnvConfig.display
+
+    with_env(DBUS_SESSION_BUS_ADDRESS: ENV.fetch("HOMEBREW_DBUS_SESSION_BUS_ADDRESS", nil)) do
+      safe_system(browser, *args)
+    end
+  end
+
+  IGNORE_INTERRUPTS_MUTEX = Thread::Mutex.new.freeze
+
+  def ignore_interrupts
+    IGNORE_INTERRUPTS_MUTEX.synchronize do
+      interrupted = T.let(false, T::Boolean)
+      old_sigint_handler = trap(:INT) do
+        interrupted = true
+
+        $stderr.print "\n"
+        $stderr.puts "One sec, cleaning up..."
+      end
+
+      begin
+        yield
+      ensure
+        trap(:INT, old_sigint_handler)
+
+        raise Interrupt if interrupted
+      end
+    end
+  end
+
+  def redirect_stdout(file)
+    out = $stdout.dup
+    $stdout.reopen(file)
+    yield
+  ensure
+    $stdout.reopen(out)
+    out.close
+  end
+
+  # Ensure the given formula is installed
+  # This is useful for installing a utility formula (e.g. `shellcheck` for `brew style`)
+  def ensure_formula_installed!(formula_or_name, reason: "", latest: false,
+                                output_to_stderr: true, quiet: false)
+    if output_to_stderr || quiet
+      file = if quiet
+        File::NULL
+      else
+        $stderr
+      end
+      # Call this method itself with redirected stdout
+      redirect_stdout(file) do
+        return ensure_formula_installed!(formula_or_name, latest:,
+                                         reason:, output_to_stderr: false)
+      end
+    end
+
+    require "formula"
+
+    formula = if formula_or_name.is_a?(Formula)
+      formula_or_name
+    else
+      Formula[formula_or_name]
+    end
+
+    reason = " for #{reason}" if reason.present?
+
+    unless formula.any_version_installed?
+      ohai "Installing `#{formula.name}`#{reason}..."
+      safe_system HOMEBREW_BREW_FILE, "install", "--formula", formula.full_name
+    end
+
+    if latest && !formula.latest_version_installed?
+      ohai "Upgrading `#{formula.name}`#{reason}..."
+      safe_system HOMEBREW_BREW_FILE, "upgrade", "--formula", formula.full_name
+    end
+
+    formula
+  end
+
+  # Ensure the given executable is exist otherwise install the brewed version
+  def ensure_executable!(name, formula_name = nil, reason: "", latest: false)
+    formula_name ||= name
+
+    executable = [
+      which(name),
+      which(name, ORIGINAL_PATHS),
+      # We prefer the opt_bin path to a formula's executable over the prefix
+      # path where available, since the former is stable during upgrades.
+      HOMEBREW_PREFIX/"opt/#{formula_name}/bin/#{name}",
+      HOMEBREW_PREFIX/"bin/#{name}",
+    ].compact.first
+    return executable if executable.exist?
+
+    ensure_formula_installed!(formula_name, reason:, latest:).opt_bin/name
+  end
+
+  def paths
+    @paths ||= ORIGINAL_PATHS.uniq.map(&:to_s)
+  end
+
+  def disk_usage_readable(size_in_bytes)
+    if size_in_bytes >= 1_073_741_824
+      size = size_in_bytes.to_f / 1_073_741_824
+      unit = "GB"
+    elsif size_in_bytes >= 1_048_576
+      size = size_in_bytes.to_f / 1_048_576
+      unit = "MB"
+    elsif size_in_bytes >= 1_024
+      size = size_in_bytes.to_f / 1_024
+      unit = "KB"
+    else
+      size = size_in_bytes
+      unit = "B"
+    end
+
+    # avoid trailing zero after decimal point
+    if ((size * 10).to_i % 10).zero?
+      "#{size.to_i}#{unit}"
+    else
+      "#{format("%<size>.1f", size:)}#{unit}"
+    end
+  end
+
+  def number_readable(number)
+    numstr = number.to_i.to_s
+    (numstr.size - 3).step(1, -3) { |i| numstr.insert(i, ",") }
+    numstr
+  end
+
+  # Truncates a text string to fit within a byte size constraint,
+  # preserving character encoding validity. The returned string will
+  # be not much longer than the specified max_bytes, though the exact
+  # shortfall or overrun may vary.
+  def truncate_text_to_approximate_size(str, max_bytes, options = {})
+    front_weight = options.fetch(:front_weight, 0.5)
+    raise "opts[:front_weight] must be between 0.0 and 1.0" if front_weight < 0.0 || front_weight > 1.0
+    return str if str.bytesize <= max_bytes
+
+    glue = "\n[...snip...]\n"
+    max_bytes_in = [max_bytes - glue.bytesize, 1].max
+    bytes = str.dup.force_encoding("BINARY")
+    glue_bytes = glue.encode("BINARY")
+    n_front_bytes = (max_bytes_in * front_weight).floor
+    n_back_bytes = max_bytes_in - n_front_bytes
+    if n_front_bytes.zero?
+      front = bytes[1..0]
+      back = bytes[-max_bytes_in..]
+    elsif n_back_bytes.zero?
+      front = bytes[0..(max_bytes_in - 1)]
+      back = bytes[1..0]
+    else
+      front = bytes[0..(n_front_bytes - 1)]
+      back = bytes[-n_back_bytes..]
+    end
+    out = front + glue_bytes + back
+    out.force_encoding("UTF-8")
+    out.encode!("UTF-16", invalid: :replace)
+    out.encode!("UTF-8")
+    out
+  end
+
+  # Calls the given block with the passed environment variables
+  # added to `ENV`, then restores `ENV` afterwards.
+  #
+  # NOTE: This method is **not** thread-safe – other threads
+  #       which happen to be scheduled during the block will also
+  #       see these environment variables.
+  #
+  # ### Example
+  #
+  # ```ruby
+  # with_env(PATH: "/bin") do
+  #   system "echo $PATH"
+  # end
+  # ```
+  #
+  # @api public
+  def with_env(hash)
+    old_values = {}
+    begin
+      hash.each do |key, value|
+        key = key.to_s
+        old_values[key] = ENV.delete(key)
+        ENV[key] = value
+      end
+
+      yield if block_given?
+    ensure
+      ENV.update(old_values)
+    end
+  end
+
+  def tap_and_name_comparison
+    proc do |a, b|
+      if a.include?("/") && b.exclude?("/")
+        1
+      elsif a.exclude?("/") && b.include?("/")
+        -1
+      else
+        a <=> b
+      end
+    end
+  end
+
+  def redact_secrets(input, secrets)
+    secrets.compact
+           .reduce(input) { |str, secret| str.gsub secret, "******" }
+           .freeze
+  end
+end
diff --git a/Library/Homebrew/extend/module.rb b/Library/Homebrew/extend/module.rb
index 91264a1498499..ea5d1f5d4cfe9 100644
--- a/Library/Homebrew/extend/module.rb
+++ b/Library/Homebrew/extend/module.rb
@@ -1,16 +1,6 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class Module
-  def attr_rw(*attrs)
-    attrs.each do |attr|
-      module_eval <<-EOS, __FILE__, __LINE__+1
-        def #{attr}(val=nil)           # def prefix(val=nil)
-          @#{attr} ||= nil             #   @prefix ||= nil
-          return @#{attr} if val.nil?  #   return @prefix if val.nil?
-          @#{attr} = val               #   @prefix = val
-        end                            # end
-      EOS
-    end
-  end
+  include T::Sig
 end
diff --git a/Library/Homebrew/extend/object/deep_dup.rb b/Library/Homebrew/extend/object/deep_dup.rb
new file mode 100644
index 0000000000000..24262d1a5a155
--- /dev/null
+++ b/Library/Homebrew/extend/object/deep_dup.rb
@@ -0,0 +1,77 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "extend/object/duplicable"
+
+class Object
+  # Returns a deep copy of object if it's duplicable. If it's
+  # not duplicable, returns +self+.
+  #
+  #   object = Object.new
+  #   dup    = object.deep_dup
+  #   dup.instance_variable_set(:@a, 1)
+  #
+  #   object.instance_variable_defined?(:@a) # => false
+  #   dup.instance_variable_defined?(:@a)    # => true
+  sig { returns(T.self_type) }
+  def deep_dup
+    duplicable? ? dup : self
+  end
+end
+
+class Array
+  # Returns a deep copy of array.
+  #
+  #   array = [1, [2, 3]]
+  #   dup   = array.deep_dup
+  #   dup[1][2] = 4
+  #
+  #   array[1][2] # => nil
+  #   dup[1][2]   # => 4
+  sig { returns(T.self_type) }
+  def deep_dup
+    T.unsafe(self).map(&:deep_dup)
+  end
+end
+
+class Hash
+  # Returns a deep copy of hash.
+  #
+  #   hash = { a: { b: 'b' } }
+  #   dup  = hash.deep_dup
+  #   dup[:a][:c] = 'c'
+  #
+  #   hash[:a][:c] # => nil
+  #   dup[:a][:c]  # => "c"
+  sig { returns(T.self_type) }
+  def deep_dup
+    hash = dup
+    each_pair do |key, value|
+      case key
+      when ::String, ::Symbol
+        hash[key] = T.unsafe(value).deep_dup
+      else
+        hash.delete(key)
+        hash[T.unsafe(key).deep_dup] = T.unsafe(value).deep_dup
+      end
+    end
+    hash
+  end
+end
+
+class Module
+  # Returns a copy of module or class if it's anonymous. If it's
+  # named, returns +self+.
+  #
+  #   Object.deep_dup == Object # => true
+  #   klass = Class.new
+  #   klass.deep_dup == klass # => false
+  sig { returns(T.self_type) }
+  def deep_dup
+    if name.nil?
+      super
+    else
+      self
+    end
+  end
+end
diff --git a/Library/Homebrew/extend/object/duplicable.rb b/Library/Homebrew/extend/object/duplicable.rb
new file mode 100644
index 0000000000000..a0f0462084ce5
--- /dev/null
+++ b/Library/Homebrew/extend/object/duplicable.rb
@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+# Most objects are cloneable, but not all. For example you can't dup methods:
+#
+# ```ruby
+# method(:puts).dup # => TypeError: allocator undefined for Method
+# ```
+#
+# Classes may signal their instances are not duplicable removing +dup+/+clone+
+# or raising exceptions from them. So, to dup an arbitrary object you normally
+# use an optimistic approach and are ready to catch an exception, say:
+#
+# ```ruby
+# arbitrary_object.dup rescue object
+# ```
+#
+# Rails dups objects in a few critical spots where they are not that arbitrary.
+# That `rescue` is very expensive (like 40 times slower than a predicate) and it
+# is often triggered.
+#
+# That's why we hardcode the following cases and check duplicable? instead of
+# using that rescue idiom.
+# rubocop:disable Layout/EmptyLines
+
+
+# rubocop:enable Layout/EmptyLines
+class Object
+  # Can you safely dup this object?
+  #
+  # False for method objects;
+  # true otherwise.
+  sig { returns(T::Boolean) }
+  def duplicable? = true
+end
+
+class Method
+  # Methods are not duplicable:
+  #
+  # ```ruby
+  # method(:puts).duplicable? # => false
+  # method(:puts).dup         # => TypeError: allocator undefined for Method
+  # ```
+  sig { returns(FalseClass) }
+  def duplicable? = false
+end
+
+class UnboundMethod
+  # Unbound methods are not duplicable:
+  #
+  # ```ruby
+  # method(:puts).unbind.duplicable? # => false
+  # method(:puts).unbind.dup         # => TypeError: allocator undefined for UnboundMethod
+  # ```
+  sig { returns(FalseClass) }
+  def duplicable? = false
+end
+
+require "singleton"
+
+module Singleton
+  # Singleton instances are not duplicable:
+  #
+  # ```ruby
+  # Class.new.include(Singleton).instance.dup # TypeError (can't dup instance of singleton
+  # ```
+  sig { returns(FalseClass) }
+  def duplicable? = false
+end
diff --git a/Library/Homebrew/extend/on_system.rb b/Library/Homebrew/extend/on_system.rb
index 5ec59cbdfa6a4..3d6b97b95f1ac 100644
--- a/Library/Homebrew/extend/on_system.rb
+++ b/Library/Homebrew/extend/on_system.rb
@@ -1,50 +1,41 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "simulate_system"
 
 module OnSystem
-  extend T::Sig
-
   ARCH_OPTIONS = [:intel, :arm].freeze
   BASE_OS_OPTIONS = [:macos, :linux].freeze
-
-  module_function
+  ALL_OS_OPTIONS = [*MacOSVersion::SYMBOLS.keys, :linux].freeze
+  ALL_OS_ARCH_COMBINATIONS = ALL_OS_OPTIONS.product(ARCH_OPTIONS).freeze
 
   sig { params(arch: Symbol).returns(T::Boolean) }
-  def arch_condition_met?(arch)
+  def self.arch_condition_met?(arch)
     raise ArgumentError, "Invalid arch condition: #{arch.inspect}" if ARCH_OPTIONS.exclude?(arch)
 
-    current_arch = Homebrew::SimulateSystem.arch || Hardware::CPU.type
-    arch == current_arch
+    arch == Homebrew::SimulateSystem.current_arch
   end
 
   sig { params(os_name: Symbol, or_condition: T.nilable(Symbol)).returns(T::Boolean) }
-  def os_condition_met?(os_name, or_condition = nil)
-    if Homebrew::EnvConfig.simulate_macos_on_linux?
-      return false if os_name == :linux
-      return true if [:macos, *MacOSVersions::SYMBOLS.keys].include?(os_name)
-    end
-
-    if BASE_OS_OPTIONS.include?(os_name)
-      if Homebrew::SimulateSystem.none?
-        return OS.linux? if os_name == :linux
-        return OS.mac? if os_name == :macos
-      end
+  def self.os_condition_met?(os_name, or_condition = nil)
+    return Homebrew::SimulateSystem.send(:"simulating_or_running_on_#{os_name}?") if BASE_OS_OPTIONS.include?(os_name)
 
-      return Homebrew::SimulateSystem.send("#{os_name}?")
-    end
-
-    raise ArgumentError, "Invalid OS condition: #{os_name.inspect}" unless MacOSVersions::SYMBOLS.key?(os_name)
+    raise ArgumentError, "Invalid OS condition: #{os_name.inspect}" unless MacOSVersion::SYMBOLS.key?(os_name)
 
     if or_condition.present? && [:or_newer, :or_older].exclude?(or_condition)
       raise ArgumentError, "Invalid OS `or_*` condition: #{or_condition.inspect}"
     end
 
-    return false if Homebrew::SimulateSystem.linux? || (Homebrew::SimulateSystem.none? && OS.linux?)
+    return false if Homebrew::SimulateSystem.simulating_or_running_on_linux?
 
-    base_os = MacOS::Version.from_symbol(os_name)
-    current_os = MacOS::Version.from_symbol(Homebrew::SimulateSystem.os || MacOS.version.to_sym)
+    base_os = MacOSVersion.from_symbol(os_name)
+    current_os = if Homebrew::SimulateSystem.current_os == :macos
+      # Assume the oldest macOS version when simulating a generic macOS version
+      # Version::NULL is always treated as less than any other version.
+      Version::NULL
+    else
+      MacOSVersion.from_symbol(Homebrew::SimulateSystem.current_os)
+    end
 
     return current_os >= base_os if or_condition == :or_newer
     return current_os <= base_os if or_condition == :or_older
@@ -53,17 +44,17 @@ def os_condition_met?(os_name, or_condition = nil)
   end
 
   sig { params(method_name: Symbol).returns(Symbol) }
-  def condition_from_method_name(method_name)
+  def self.condition_from_method_name(method_name)
     method_name.to_s.sub(/^on_/, "").to_sym
   end
 
   sig { params(base: Class).void }
-  def setup_arch_methods(base)
+  def self.setup_arch_methods(base)
     ARCH_OPTIONS.each do |arch|
-      base.define_method("on_#{arch}") do |&block|
+      base.define_method(:"on_#{arch}") do |&block|
         @on_system_blocks_exist = true
 
-        return unless OnSystem.arch_condition_met? OnSystem.condition_from_method_name(__method__)
+        return unless OnSystem.arch_condition_met? OnSystem.condition_from_method_name(T.must(__method__))
 
         @called_in_on_system_block = true
         result = block.call
@@ -72,15 +63,25 @@ def setup_arch_methods(base)
         result
       end
     end
+
+    base.define_method(:on_arch_conditional) do |arm: nil, intel: nil|
+      @on_system_blocks_exist = true
+
+      if OnSystem.arch_condition_met? :arm
+        arm
+      elsif OnSystem.arch_condition_met? :intel
+        intel
+      end
+    end
   end
 
   sig { params(base: Class).void }
-  def setup_base_os_methods(base)
+  def self.setup_base_os_methods(base)
     BASE_OS_OPTIONS.each do |base_os|
-      base.define_method("on_#{base_os}") do |&block|
+      base.define_method(:"on_#{base_os}") do |&block|
         @on_system_blocks_exist = true
 
-        return unless OnSystem.os_condition_met? OnSystem.condition_from_method_name(__method__)
+        return unless OnSystem.os_condition_met? OnSystem.condition_from_method_name(T.must(__method__))
 
         @called_in_on_system_block = true
         result = block.call
@@ -108,17 +109,32 @@ def setup_base_os_methods(base)
 
       result
     end
+
+    base.define_method(:on_system_conditional) do |macos: nil, linux: nil|
+      @on_system_blocks_exist = true
+
+      if OnSystem.os_condition_met?(:macos) && macos.present?
+        macos
+      elsif OnSystem.os_condition_met?(:linux) && linux.present?
+        linux
+      end
+    end
   end
 
   sig { params(base: Class).void }
-  def setup_macos_methods(base)
-    MacOSVersions::SYMBOLS.each_key do |os_name|
-      base.define_method("on_#{os_name}") do |or_condition = nil, &block|
+  def self.setup_macos_methods(base)
+    MacOSVersion::SYMBOLS.each_key do |os_name|
+      base.define_method(:"on_#{os_name}") do |or_condition = nil, &block|
         @on_system_blocks_exist = true
 
-        os_condition = OnSystem.condition_from_method_name __method__
+        os_condition = OnSystem.condition_from_method_name T.must(__method__)
         return unless OnSystem.os_condition_met? os_condition, or_condition
 
+        @on_system_block_min_os = if or_condition == :or_older
+          @called_in_on_system_block ? @on_system_block_min_os : MacOSVersion.new(HOMEBREW_MACOS_OLDEST_ALLOWED)
+        else
+          MacOSVersion.from_symbol(os_condition)
+        end
         @called_in_on_system_block = true
         result = block.call
         @called_in_on_system_block = false
@@ -134,8 +150,6 @@ def self.included(_base)
   end
 
   module MacOSAndLinux
-    extend T::Sig
-
     sig { params(base: Class).void }
     def self.included(base)
       OnSystem.setup_arch_methods(base)
@@ -145,8 +159,6 @@ def self.included(base)
   end
 
   module MacOSOnly
-    extend T::Sig
-
     sig { params(base: Class).void }
     def self.included(base)
       OnSystem.setup_arch_methods(base)
diff --git a/Library/Homebrew/extend/on_system.rbi b/Library/Homebrew/extend/on_system.rbi
new file mode 100644
index 0000000000000..15534bb4b4dbc
--- /dev/null
+++ b/Library/Homebrew/extend/on_system.rbi
@@ -0,0 +1,6 @@
+# typed: strict
+
+module OnSystem::MacOSOnly
+  sig { params(arm: T.nilable(String), intel: T.nilable(String)).returns(T.nilable(String)) }
+  def on_arch_conditional(arm: nil, intel: nil); end
+end
diff --git a/Library/Homebrew/extend/os/cleanup.rb b/Library/Homebrew/extend/os/cleanup.rb
new file mode 100644
index 0000000000000..2018cbb911cc6
--- /dev/null
+++ b/Library/Homebrew/extend/os/cleanup.rb
@@ -0,0 +1,8 @@
+# typed: strict
+# frozen_string_literal: true
+
+if OS.mac?
+  require "extend/os/mac/cleanup"
+elsif OS.linux?
+  require "extend/os/linux/cleanup"
+end
diff --git a/Library/Homebrew/extend/os/cmd/update-report.rb b/Library/Homebrew/extend/os/cmd/update-report.rb
new file mode 100644
index 0000000000000..59a67f04ce42b
--- /dev/null
+++ b/Library/Homebrew/extend/os/cmd/update-report.rb
@@ -0,0 +1,4 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "extend/os/linux/cmd/update-report" if OS.linux?
diff --git a/Library/Homebrew/extend/os/dependency_collector.rb b/Library/Homebrew/extend/os/dependency_collector.rb
index 32a246693360e..58a3f23994dc4 100644
--- a/Library/Homebrew/extend/os/dependency_collector.rb
+++ b/Library/Homebrew/extend/os/dependency_collector.rb
@@ -1,4 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "extend/os/mac/dependency_collector" if OS.mac?
+if OS.mac?
+  require "extend/os/mac/dependency_collector"
+elsif OS.linux?
+  require "extend/os/linux/dependency_collector"
+end
diff --git a/Library/Homebrew/extend/os/dev-cmd/bottle.rb b/Library/Homebrew/extend/os/dev-cmd/bottle.rb
new file mode 100644
index 0000000000000..7aec276a06fd8
--- /dev/null
+++ b/Library/Homebrew/extend/os/dev-cmd/bottle.rb
@@ -0,0 +1,4 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "extend/os/mac/dev-cmd/bottle" if OS.mac?
diff --git a/Library/Homebrew/extend/os/dev-cmd/update-test.rb b/Library/Homebrew/extend/os/dev-cmd/update-test.rb
new file mode 100644
index 0000000000000..e4f62b0057279
--- /dev/null
+++ b/Library/Homebrew/extend/os/dev-cmd/update-test.rb
@@ -0,0 +1,4 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "extend/os/linux/dev-cmd/update-test" if OS.linux?
diff --git a/Library/Homebrew/extend/os/formula.rb b/Library/Homebrew/extend/os/formula.rb
index aef771325f32c..5a520cf8a33fd 100644
--- a/Library/Homebrew/extend/os/formula.rb
+++ b/Library/Homebrew/extend/os/formula.rb
@@ -1,4 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "extend/os/linux/formula" if OS.linux?
+if OS.mac?
+  require "extend/os/mac/formula"
+elsif OS.linux?
+  require "extend/os/linux/formula"
+end
diff --git a/Library/Homebrew/extend/os/formula_installer.rb b/Library/Homebrew/extend/os/formula_installer.rb
new file mode 100644
index 0000000000000..b4ce658527952
--- /dev/null
+++ b/Library/Homebrew/extend/os/formula_installer.rb
@@ -0,0 +1,8 @@
+# typed: strict
+# frozen_string_literal: true
+
+if OS.mac?
+  require "extend/os/mac/formula_installer"
+elsif OS.linux?
+  require "extend/os/linux/formula_installer"
+end
diff --git a/Library/Homebrew/extend/os/keg.rb b/Library/Homebrew/extend/os/keg.rb
index 5e3cdd073ac68..733768bff3cd3 100644
--- a/Library/Homebrew/extend/os/keg.rb
+++ b/Library/Homebrew/extend/os/keg.rb
@@ -1,4 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "extend/os/mac/keg" if OS.mac?
+if OS.mac?
+  require "extend/os/mac/keg"
+elsif OS.linux?
+  require "extend/os/linux/keg"
+end
diff --git a/Library/Homebrew/extend/os/linkage_checker.rb b/Library/Homebrew/extend/os/linkage_checker.rb
index 3e8904e5eb0ef..175e201324b0e 100644
--- a/Library/Homebrew/extend/os/linkage_checker.rb
+++ b/Library/Homebrew/extend/os/linkage_checker.rb
@@ -1,4 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "extend/os/linux/linkage_checker" if OS.linux?
+if OS.mac?
+  require "extend/os/mac/linkage_checker"
+else
+  require "extend/os/linux/linkage_checker"
+end
diff --git a/Library/Homebrew/extend/os/linux/cleaner.rb b/Library/Homebrew/extend/os/linux/cleaner.rb
index 8ac06950da69c..e1e34f09ad1af 100644
--- a/Library/Homebrew/extend/os/linux/cleaner.rb
+++ b/Library/Homebrew/extend/os/linux/cleaner.rb
@@ -4,8 +4,7 @@
 class Cleaner
   private
 
-  extend T::Sig
-  sig { params(path: Pathname).returns(T.nilable(T::Boolean)) }
+  sig { params(path: Pathname).returns(T::Boolean) }
   def executable_path?(path)
     path.elf? || path.text_executable?
   end
diff --git a/Library/Homebrew/extend/os/linux/cleanup.rb b/Library/Homebrew/extend/os/linux/cleanup.rb
new file mode 100644
index 0000000000000..be63e0e558298
--- /dev/null
+++ b/Library/Homebrew/extend/os/linux/cleanup.rb
@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OS
+  module Linux
+    module Cleanup
+      extend T::Helpers
+
+      requires_ancestor { Homebrew::Cleanup }
+
+      sig { returns(T::Boolean) }
+      def use_system_ruby?
+        return false if Homebrew::EnvConfig.force_vendor_ruby?
+
+        rubies = [which("ruby"), which("ruby", ORIGINAL_PATHS)].compact
+        system_ruby = Pathname.new("/usr/bin/ruby")
+        rubies << system_ruby if system_ruby.exist?
+
+        check_ruby_version = HOMEBREW_LIBRARY_PATH/"utils/ruby_check_version_script.rb"
+        rubies.uniq.any? do |ruby|
+          quiet_system ruby, "--enable-frozen-string-literal", "--disable=gems,did_you_mean,rubyopt",
+                       check_ruby_version, RUBY_VERSION
+        end
+      end
+    end
+  end
+end
+
+Homebrew::Cleanup.prepend(OS::Linux::Cleanup)
diff --git a/Library/Homebrew/extend/os/linux/cli/parser.rb b/Library/Homebrew/extend/os/linux/cli/parser.rb
new file mode 100644
index 0000000000000..e5fd59e146cb9
--- /dev/null
+++ b/Library/Homebrew/extend/os/linux/cli/parser.rb
@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OS
+  module Linux
+    module CLI
+      module Parser
+        extend T::Helpers
+
+        requires_ancestor { Homebrew::CLI::Parser }
+
+        sig { void }
+        def set_default_options
+          args["formula?"] = true if args.respond_to?(:formula?)
+        end
+
+        sig { void }
+        def validate_options
+          return unless args.respond_to?(:cask?)
+          return unless args.cask?
+
+          # NOTE: We don't raise an error here because we don't want
+          #       to print the help page or a stack trace.
+          odie "Invalid `--cask` usage: Casks do not work on Linux"
+        end
+      end
+    end
+  end
+end
+
+Homebrew::CLI::Parser.prepend(OS::Linux::CLI::Parser)
diff --git a/Library/Homebrew/extend/os/linux/cmd/update-report.rb b/Library/Homebrew/extend/os/linux/cmd/update-report.rb
new file mode 100644
index 0000000000000..25947f07c40a2
--- /dev/null
+++ b/Library/Homebrew/extend/os/linux/cmd/update-report.rb
@@ -0,0 +1,38 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  module_function
+
+  sig { returns(String) }
+  def no_changes_message
+    "No changes to formulae."
+  end
+
+  sig { void }
+  def migrate_gcc_dependents_if_needed
+    return if Settings.read("gcc-rpaths.fixed") == "true"
+
+    Formula.installed.each do |formula|
+      next unless formula.tap&.core_tap?
+
+      recursive_runtime_dependencies = Dependency.expand(
+        formula,
+        cache_key: "update-report",
+      ) do |_, dependency|
+        Dependency.prune if dependency.build? || dependency.test?
+      end
+      next unless recursive_runtime_dependencies.map(&:name).include? "gcc"
+
+      keg = formula.installed_kegs.last
+      tab = keg.tab
+      # Force reinstallation upon `brew upgrade` to fix the bottle RPATH.
+      tab.source["versions"]["version_scheme"] = -1
+      tab.write
+    rescue TapFormulaUnavailableError
+      nil
+    end
+
+    Settings.write "gcc-rpaths.fixed", true
+  end
+end
diff --git a/Library/Homebrew/extend/os/linux/compilers.rb b/Library/Homebrew/extend/os/linux/compilers.rb
index 21ac0954d5936..8965b15100b81 100644
--- a/Library/Homebrew/extend/os/linux/compilers.rb
+++ b/Library/Homebrew/extend/os/linux/compilers.rb
@@ -4,8 +4,6 @@
 class CompilerSelector
   sig { returns(String) }
   def self.preferred_gcc
-    # gcc-5 is the lowest gcc version we support on Linux.
-    # gcc-5 is the default gcc in Ubuntu 16.04 (used for our CI)
-    "gcc@5"
+    OS::LINUX_PREFERRED_GCC_COMPILER_FORMULA
   end
 end
diff --git a/Library/Homebrew/extend/os/linux/dependency_collector.rb b/Library/Homebrew/extend/os/linux/dependency_collector.rb
new file mode 100644
index 0000000000000..2f7485eef2f0e
--- /dev/null
+++ b/Library/Homebrew/extend/os/linux/dependency_collector.rb
@@ -0,0 +1,103 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "os/linux/glibc"
+
+module OS
+  module Linux
+    module DependencyCollector
+      sig { params(related_formula_names: T::Set[String]).returns(T.nilable(Dependency)) }
+      def gcc_dep_if_needed(related_formula_names)
+        # gcc is required for libgcc_s.so.1 if glibc or gcc are too old
+        return unless ::DevelopmentTools.needs_build_formulae?
+        return if building_global_dep_tree?
+        return if related_formula_names.include?(GCC)
+        return if global_dep_tree[GCC]&.intersect?(related_formula_names)
+        return unless formula_for(GCC)
+
+        Dependency.new(GCC, [:implicit])
+      end
+
+      sig { params(related_formula_names: T::Set[String]).returns(T.nilable(Dependency)) }
+      def glibc_dep_if_needed(related_formula_names)
+        return unless ::DevelopmentTools.needs_libc_formula?
+        return if building_global_dep_tree?
+        return if related_formula_names.include?(GLIBC)
+        return if global_dep_tree[GLIBC]&.intersect?(related_formula_names)
+        return unless formula_for(GLIBC)
+
+        Dependency.new(GLIBC, [:implicit])
+      end
+
+      private
+
+      GLIBC = "glibc"
+      GCC = OS::LINUX_PREFERRED_GCC_RUNTIME_FORMULA
+
+      sig { void }
+      def init_global_dep_tree_if_needed!
+        return unless ::DevelopmentTools.needs_build_formulae?
+        return if building_global_dep_tree?
+        return unless global_dep_tree.empty?
+
+        building_global_dep_tree!
+        global_dep_tree[GLIBC] = Set.new(global_deps_for(GLIBC))
+        # gcc depends on glibc
+        global_dep_tree[GCC] = Set.new([*global_deps_for(GCC), GLIBC, *@@global_dep_tree[GLIBC]])
+        built_global_dep_tree!
+      end
+
+      sig { params(name: String).returns(T.nilable(Formula)) }
+      def formula_for(name)
+        @formula_for ||= T.let({}, T.nilable(T::Hash[String, Formula]))
+        @formula_for[name] ||= ::Formula[name]
+      rescue FormulaUnavailableError
+        nil
+      end
+
+      sig { params(name: String).returns(T::Array[String]) }
+      def global_deps_for(name)
+        @global_deps_for ||= T.let({}, T.nilable(T::Hash[String, T::Array[String]]))
+        # Always strip out glibc and gcc from all parts of dependency tree when
+        # we're calculating their dependency trees. Other parts of Homebrew will
+        # catch any circular dependencies.
+        @global_deps_for[name] ||= if (formula = formula_for(name))
+          formula.deps.map(&:name).flat_map do |dep|
+            [dep, *global_deps_for(dep)].compact
+          end.uniq
+        else
+          []
+        end
+      end
+
+      # Use class variables to avoid this expensive logic needing to be done more
+      # than once.
+      # rubocop:disable Style/ClassVars
+      @@global_dep_tree = T.let({}, T::Hash[String, T::Set[String]])
+      @@building_global_dep_tree = T.let(false, T::Boolean)
+
+      sig { returns(T::Hash[String, T::Set[String]]) }
+      def global_dep_tree
+        @@global_dep_tree
+      end
+
+      sig { void }
+      def building_global_dep_tree!
+        @@building_global_dep_tree = true
+      end
+
+      sig { void }
+      def built_global_dep_tree!
+        @@building_global_dep_tree = false
+      end
+
+      sig { returns(T::Boolean) }
+      def building_global_dep_tree?
+        @@building_global_dep_tree.present?
+      end
+      # rubocop:enable Style/ClassVars
+    end
+  end
+end
+
+DependencyCollector.prepend(OS::Linux::DependencyCollector)
diff --git a/Library/Homebrew/extend/os/linux/dev-cmd/update-test.rb b/Library/Homebrew/extend/os/linux/dev-cmd/update-test.rb
new file mode 100644
index 0000000000000..836a80c7028fa
--- /dev/null
+++ b/Library/Homebrew/extend/os/linux/dev-cmd/update-test.rb
@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  module DevCmd
+    class UpdateTest < AbstractCommand
+      alias generic_git_tags git_tags
+
+      private
+
+      sig { returns(String) }
+      def git_tags
+        tags = generic_git_tags
+        tags = Utils.popen_read("git tag --list | sort -rV") if tags.blank?
+        tags
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/extend/os/linux/development_tools.rb b/Library/Homebrew/extend/os/linux/development_tools.rb
index 2648ebca686b4..bd07e5d03ac45 100644
--- a/Library/Homebrew/extend/os/linux/development_tools.rb
+++ b/Library/Homebrew/extend/os/linux/development_tools.rb
@@ -1,32 +1,64 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-class DevelopmentTools
-  class << self
-    extend T::Sig
-
-    sig { params(tool: String).returns(T.nilable(Pathname)) }
-    def locate(tool)
-      (@locate ||= {}).fetch(tool) do |key|
-        @locate[key] = if (path = HOMEBREW_PREFIX/"bin/#{tool}").executable?
-          path
-        elsif File.executable?(path = "/usr/bin/#{tool}")
-          Pathname.new path
+module OS
+  module Linux
+    module DevelopmentTools
+      extend T::Helpers
+
+      requires_ancestor { ::DevelopmentTools }
+
+      sig { params(tool: T.any(String, Symbol)).returns(T.nilable(Pathname)) }
+      def locate(tool)
+        @locate ||= T.let({}, T.nilable(T::Hash[T.any(String, Symbol), Pathname]))
+        @locate.fetch(tool) do |key|
+          @locate[key] = if ::DevelopmentTools.needs_build_formulae? &&
+                            (binutils_path = HOMEBREW_PREFIX/"opt/binutils/bin/#{tool}").executable?
+            binutils_path
+          elsif ::DevelopmentTools.needs_build_formulae? &&
+                (glibc_path = HOMEBREW_PREFIX/"opt/glibc/bin/#{tool}").executable?
+            glibc_path
+          elsif (homebrew_path = HOMEBREW_PREFIX/"bin/#{tool}").executable?
+            homebrew_path
+          elsif File.executable?((system_path = "/usr/bin/#{tool}"))
+            Pathname.new system_path
+          end
         end
       end
-    end
 
-    sig { returns(Symbol) }
-    def default_compiler
-      :gcc
-    end
+      sig { returns(Symbol) }
+      def default_compiler = :gcc
+
+      sig { returns(T::Boolean) }
+      def needs_libc_formula?
+        return @needs_libc_formula unless @needs_libc_formula.nil?
+
+        @needs_libc_formula = T.let(OS::Linux::Glibc.below_ci_version?, T.nilable(T::Boolean))
+        @needs_libc_formula = !!@needs_libc_formula
+      end
+
+      sig { returns(T::Boolean) }
+      def needs_compiler_formula?
+        return @needs_compiler_formula unless @needs_compiler_formula.nil?
+
+        gcc = "/usr/bin/gcc"
+        @needs_compiler_formula = T.let(if File.exist?(gcc)
+                                          ::DevelopmentTools.gcc_version(gcc) < OS::LINUX_GCC_CI_VERSION
+                                        else
+                                          true
+        end, T.nilable(T::Boolean))
+        !!@needs_compiler_formula
+      end
 
-    sig { returns(T::Hash[String, T.nilable(String)]) }
-    def build_system_info
-      generic_build_system_info.merge({
-        "glibc_version"     => OS::Linux::Glibc.version.to_s.presence,
-        "oldest_cpu_family" => Hardware.oldest_cpu.to_s,
-      })
+      sig { returns(T::Hash[String, T.nilable(String)]) }
+      def build_system_info
+        super.merge({
+          "glibc_version"     => OS::Linux::Glibc.version.to_s.presence,
+          "oldest_cpu_family" => Hardware.oldest_cpu.to_s,
+        })
+      end
     end
   end
 end
+
+DevelopmentTools.singleton_class.prepend(OS::Linux::DevelopmentTools)
diff --git a/Library/Homebrew/extend/os/linux/diagnostic.rb b/Library/Homebrew/extend/os/linux/diagnostic.rb
index 35eb83ff1055e..6393c2b39e503 100644
--- a/Library/Homebrew/extend/os/linux/diagnostic.rb
+++ b/Library/Homebrew/extend/os/linux/diagnostic.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:disable Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "tempfile"
@@ -7,138 +7,160 @@
 require "os/linux/glibc"
 require "os/linux/kernel"
 
-module Homebrew
-  module Diagnostic
-    class Checks
-      undef fatal_preinstall_checks, supported_configuration_checks
-
-      def fatal_preinstall_checks
-        %w[
-          check_access_directories
-          check_linuxbrew_core
-          check_linuxbrew_bottle_domain
-        ].freeze
-      end
-
-      def supported_configuration_checks
-        %w[
-          check_glibc_minimum_version
-          check_kernel_minimum_version
-          check_supported_architecture
-        ].freeze
-      end
-
-      def check_tmpdir_sticky_bit
-        message = generic_check_tmpdir_sticky_bit
-        return if message.nil?
-
-        message + <<~EOS
-          If you don't have administrative privileges on this machine,
-          create a directory and set the HOMEBREW_TEMP environment variable,
-          for example:
-            install -d -m 1755 ~/tmp
-            #{Utils::Shell.set_variable_in_profile("HOMEBREW_TEMP", "~/tmp")}
-        EOS
-      end
-
-      def check_tmpdir_executable
-        f = Tempfile.new(%w[homebrew_check_tmpdir_executable .sh], HOMEBREW_TEMP)
-        f.write "#!/bin/sh\n"
-        f.chmod 0700
-        f.close
-        return if system f.path
-
-        <<~EOS
-          The directory #{HOMEBREW_TEMP} does not permit executing
-          programs. It is likely mounted as "noexec". Please set HOMEBREW_TEMP
-          in your #{shell_profile} to a different directory, for example:
-            export HOMEBREW_TEMP=~/tmp
-            echo 'export HOMEBREW_TEMP=~/tmp' >> #{shell_profile}
-        EOS
-      ensure
-        f.unlink
-      end
-
-      def check_xdg_data_dirs
-        return if ENV["XDG_DATA_DIRS"].blank?
-        return if ENV["XDG_DATA_DIRS"].split("/").include?(HOMEBREW_PREFIX/"share")
-
-        <<~EOS
-          Homebrew's share was not found in your XDG_DATA_DIRS but you have
-          this variable set to include other locations.
-          Some programs like `vapigen` may not work correctly.
-          Consider adding Homebrew's share directory to XDG_DATA_DIRS like so:
-            echo 'export XDG_DATA_DIRS="#{HOMEBREW_PREFIX}/share:$XDG_DATA_DIRS"' >> #{shell_profile}
-        EOS
-      end
-
-      def check_umask_not_zero
-        return unless File.umask.zero?
-
-        <<~EOS
-          umask is currently set to 000. Directories created by Homebrew cannot
-          be world-writable. This issue can be resolved by adding "umask 002" to
-          your #{shell_profile}:
-            echo 'umask 002' >> #{shell_profile}
-        EOS
-      end
-
-      def check_supported_architecture
-        return if Hardware::CPU.arch == :x86_64
-
-        <<~EOS
-          Your CPU architecture (#{Hardware::CPU.arch}) is not supported. We only support
-          x86_64 CPU architectures. You will be unable to use binary packages (bottles).
-          #{please_create_pull_requests}
-        EOS
-      end
-
-      def check_glibc_minimum_version
-        return unless OS::Linux::Glibc.below_minimum_version?
-
-        <<~EOS
-          Your system glibc #{OS::Linux::Glibc.system_version} is too old.
-          We only support glibc #{OS::Linux::Glibc.minimum_version} or later.
-          #{please_create_pull_requests}
-          We recommend updating to a newer version via your distribution's
-          package manager, upgrading your distribution to the latest version,
-          or changing distributions.
-        EOS
-      end
-
-      def check_kernel_minimum_version
-        return unless OS::Linux::Kernel.below_minimum_version?
-
-        <<~EOS
-          Your Linux kernel #{OS.kernel_version} is too old.
-          We only support kernel #{OS::Linux::Kernel.minimum_version} or later.
-          You will be unable to use binary packages (bottles).
-          #{please_create_pull_requests}
-          We recommend updating to a newer version via your distribution's
-          package manager, upgrading your distribution to the latest version,
-          or changing distributions.
-        EOS
-      end
-
-      def check_linuxbrew_core
-        return if Homebrew::EnvConfig.install_from_api?
-        return unless CoreTap.instance.linuxbrew_core?
-
-        <<~EOS
-          Your Linux Homebrew/core repository is still linuxbrew-core.
-          You must `brew update` to update to homebrew-core.
-        EOS
-      end
-
-      def check_linuxbrew_bottle_domain
-        return unless Homebrew::EnvConfig.bottle_domain.include?("linuxbrew")
-
-        <<~EOS
-          Your HOMEBREW_BOTTLE_DOMAIN still contains "linuxbrew".
-          You must unset it (or adjust it to not contain linuxbrew
-          e.g. by using homebrew instead).
-        EOS
+module OS
+  module Linux
+    module Diagnostic
+      module Checks
+        extend T::Helpers
+
+        requires_ancestor { Homebrew::Diagnostic::Checks }
+
+        def fatal_preinstall_checks
+          %w[
+            check_access_directories
+            check_linuxbrew_core
+            check_linuxbrew_bottle_domain
+          ].freeze
+        end
+
+        def supported_configuration_checks
+          %w[
+            check_glibc_minimum_version
+            check_kernel_minimum_version
+            check_supported_architecture
+          ].freeze
+        end
+
+        def check_tmpdir_sticky_bit
+          message = generic_check_tmpdir_sticky_bit
+          return if message.nil?
+
+          message + <<~EOS
+            If you don't have administrative privileges on this machine,
+            create a directory and set the HOMEBREW_TEMP environment variable,
+            for example:
+              install -d -m 1755 ~/tmp
+              #{Utils::Shell.set_variable_in_profile("HOMEBREW_TEMP", "~/tmp")}
+          EOS
+        end
+
+        def check_tmpdir_executable
+          f = Tempfile.new(%w[homebrew_check_tmpdir_executable .sh], HOMEBREW_TEMP)
+          f.write "#!/bin/sh\n"
+          f.chmod 0700
+          f.close
+          return if system T.must(f.path)
+
+          <<~EOS
+            The directory #{HOMEBREW_TEMP} does not permit executing
+            programs. It is likely mounted as "noexec". Please set HOMEBREW_TEMP
+            in your #{Utils::Shell.profile} to a different directory, for example:
+              export HOMEBREW_TEMP=~/tmp
+              echo 'export HOMEBREW_TEMP=~/tmp' >> #{Utils::Shell.profile}
+          EOS
+        ensure
+          f&.unlink
+        end
+
+        def check_umask_not_zero
+          return unless File.umask.zero?
+
+          <<~EOS
+            umask is currently set to 000. Directories created by Homebrew cannot
+            be world-writable. This issue can be resolved by adding "umask 002" to
+            your #{Utils::Shell.profile}:
+              echo 'umask 002' >> #{Utils::Shell.profile}
+          EOS
+        end
+
+        def check_supported_architecture
+          return if Hardware::CPU.arch == :x86_64
+
+          <<~EOS
+            Your CPU architecture (#{Hardware::CPU.arch}) is not supported. We only support
+            x86_64 CPU architectures. You will be unable to use binary packages (bottles).
+            #{please_create_pull_requests}
+          EOS
+        end
+
+        def check_glibc_minimum_version
+          return unless OS::Linux::Glibc.below_minimum_version?
+
+          <<~EOS
+            Your system glibc #{OS::Linux::Glibc.system_version} is too old.
+            We only support glibc #{OS::Linux::Glibc.minimum_version} or later.
+            #{please_create_pull_requests}
+            We recommend updating to a newer version via your distribution's
+            package manager, upgrading your distribution to the latest version,
+            or changing distributions.
+          EOS
+        end
+
+        def check_kernel_minimum_version
+          return unless OS::Linux::Kernel.below_minimum_version?
+
+          <<~EOS
+            Your Linux kernel #{OS.kernel_version} is too old.
+            We only support kernel #{OS::Linux::Kernel.minimum_version} or later.
+            You will be unable to use binary packages (bottles).
+            #{please_create_pull_requests}
+            We recommend updating to a newer version via your distribution's
+            package manager, upgrading your distribution to the latest version,
+            or changing distributions.
+          EOS
+        end
+
+        def check_linuxbrew_core
+          return unless Homebrew::EnvConfig.no_install_from_api?
+          return unless CoreTap.instance.linuxbrew_core?
+
+          <<~EOS
+            Your Linux core repository is still linuxbrew-core.
+            You must `brew update` to update to homebrew-core.
+          EOS
+        end
+
+        def check_linuxbrew_bottle_domain
+          return unless Homebrew::EnvConfig.bottle_domain.include?("linuxbrew")
+
+          <<~EOS
+            Your HOMEBREW_BOTTLE_DOMAIN still contains "linuxbrew".
+            You must unset it (or adjust it to not contain linuxbrew
+            e.g. by using homebrew instead).
+          EOS
+        end
+
+        def check_gcc_dependent_linkage
+          gcc_dependents = ::Formula.installed.select do |formula|
+            next false unless formula.tap&.core_tap?
+
+            # FIXME: This includes formulae that have no runtime dependency on GCC.
+            formula.recursive_dependencies.map(&:name).include? "gcc"
+          rescue TapFormulaUnavailableError
+            false
+          end
+          return if gcc_dependents.empty?
+
+          badly_linked = gcc_dependents.select do |dependent|
+            keg = Keg.new(dependent.prefix)
+            keg.binary_executable_or_library_files.any? do |binary|
+              paths = binary.rpaths
+              versioned_linkage = paths.any? { |path| path.match?(%r{lib/gcc/\d+$}) }
+              unversioned_linkage = paths.any? { |path| path.match?(%r{lib/gcc/current$}) }
+
+              versioned_linkage && !unversioned_linkage
+            end
+          end
+          return if badly_linked.empty?
+
+          inject_file_list badly_linked, <<~EOS
+            Formulae which link to GCC through a versioned path were found. These formulae
+            are prone to breaking when GCC is updated. You should `brew reinstall` these formulae:
+          EOS
+        end
       end
     end
   end
 end
+
+Homebrew::Diagnostic::Checks.prepend(OS::Linux::Diagnostic::Checks)
diff --git a/Library/Homebrew/extend/os/linux/extend/ENV/shared.rb b/Library/Homebrew/extend/os/linux/extend/ENV/shared.rb
index 661725a6d2174..2d42c97b9c652 100644
--- a/Library/Homebrew/extend/os/linux/extend/ENV/shared.rb
+++ b/Library/Homebrew/extend/os/linux/extend/ENV/shared.rb
@@ -1,8 +1,7 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module SharedEnvExtension
-  # @private
   def effective_arch
     if @build_bottle && @bottle_arch
       @bottle_arch.to_sym
diff --git a/Library/Homebrew/extend/os/linux/extend/ENV/std.rb b/Library/Homebrew/extend/os/linux/extend/ENV/std.rb
index 76d564cd59114..ba2fa12309d4a 100644
--- a/Library/Homebrew/extend/os/linux/extend/ENV/std.rb
+++ b/Library/Homebrew/extend/os/linux/extend/ENV/std.rb
@@ -1,12 +1,21 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module Stdenv
-  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false)
-    generic_setup_build_environment(
-      formula: formula, cc: cc, build_bottle: build_bottle,
-      bottle_arch: bottle_arch, testing_formula: testing_formula
-    )
+  sig {
+    params(
+      formula:         T.nilable(Formula),
+      cc:              T.nilable(String),
+      build_bottle:    T.nilable(T::Boolean),
+      bottle_arch:     T.nilable(String),
+      testing_formula: T::Boolean,
+      debug_symbols:   T.nilable(T::Boolean),
+    ).void
+  }
+  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false,
+                              debug_symbols: false)
+    generic_setup_build_environment(formula:, cc:, build_bottle:, bottle_arch:,
+                                    testing_formula:, debug_symbols:)
 
     prepend_path "CPATH", HOMEBREW_PREFIX/"include"
     prepend_path "LIBRARY_PATH", HOMEBREW_PREFIX/"lib"
diff --git a/Library/Homebrew/extend/os/linux/extend/ENV/super.rb b/Library/Homebrew/extend/os/linux/extend/ENV/super.rb
index 8dd6f95c8d90a..f0aa87920edad 100644
--- a/Library/Homebrew/extend/os/linux/extend/ENV/super.rb
+++ b/Library/Homebrew/extend/os/linux/extend/ENV/super.rb
@@ -1,25 +1,31 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module Superenv
-  extend T::Sig
-
-  # The location of Homebrew's shims on Linux.
+  sig { returns(Pathname) }
   def self.shims_path
     HOMEBREW_SHIMS_PATH/"linux/super"
   end
 
-  # @private
+  sig { returns(T.nilable(Pathname)) }
   def self.bin
     shims_path.realpath
   end
 
-  # @private
-  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false)
-    generic_setup_build_environment(
-      formula: formula, cc: cc, build_bottle: build_bottle,
-      bottle_arch: bottle_arch, testing_formula: testing_formula
-    )
+  sig {
+    params(
+      formula:         T.nilable(Formula),
+      cc:              T.nilable(String),
+      build_bottle:    T.nilable(T::Boolean),
+      bottle_arch:     T.nilable(String),
+      testing_formula: T::Boolean,
+      debug_symbols:   T.nilable(T::Boolean),
+    ).void
+  }
+  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false,
+                              debug_symbols: false)
+    generic_setup_build_environment(formula:, cc:, build_bottle:, bottle_arch:,
+                                    testing_formula:, debug_symbols:)
     self["HOMEBREW_OPTIMIZATION_LEVEL"] = "O2"
     self["HOMEBREW_DYNAMIC_LINKER"] = determine_dynamic_linker_path
     self["HOMEBREW_RPATH_PATHS"] = determine_rpath_paths(@formula)
@@ -27,13 +33,13 @@ def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_a
   end
 
   def homebrew_extra_paths
-    paths = []
-    paths += %w[binutils make].map do |f|
+    paths = generic_homebrew_extra_paths
+    paths += %w[binutils make].filter_map do |f|
       bin = Formulary.factory(f).opt_bin
       bin if bin.directory?
     rescue FormulaUnavailableError
       nil
-    end.compact
+    end
     paths
   end
 
@@ -51,6 +57,7 @@ def homebrew_extra_isystem_paths
   def determine_rpath_paths(formula)
     PATH.new(
       *formula&.lib,
+      "#{HOMEBREW_PREFIX}/opt/gcc/lib/gcc/current",
       PATH.new(run_time_deps.map { |dep| dep.opt_lib.to_s }).existing,
       "#{HOMEBREW_PREFIX}/lib",
     )
diff --git a/Library/Homebrew/extend/os/linux/extend/pathname.rbi b/Library/Homebrew/extend/os/linux/extend/pathname.rbi
new file mode 100644
index 0000000000000..988e9ac4cfa37
--- /dev/null
+++ b/Library/Homebrew/extend/os/linux/extend/pathname.rbi
@@ -0,0 +1,5 @@
+# typed: strict
+
+class Pathname
+  include ELFShim
+end
diff --git a/Library/Homebrew/extend/os/linux/formula.rb b/Library/Homebrew/extend/os/linux/formula.rb
index da2d162bdfabe..46489c1c0d862 100644
--- a/Library/Homebrew/extend/os/linux/formula.rb
+++ b/Library/Homebrew/extend/os/linux/formula.rb
@@ -1,39 +1,56 @@
-# typed: true
+# typed: true # rubocop:disable Sorbet/StrictSigil
 # frozen_string_literal: true
 
-class Formula
-  undef shared_library
-  undef rpath
-  undef deuniversalize_machos
-
-  sig { params(name: String, version: T.nilable(T.any(String, Integer))).returns(String) }
-  def shared_library(name, version = nil)
-    suffix = if version == "*" || (name == "*" && version.blank?)
-      "{,.*}"
-    elsif version.present?
-      ".#{version}"
-    end
-    "#{name}.so#{suffix}"
-  end
+module OS
+  module Linux
+    module Formula
+      extend T::Helpers
 
-  sig { returns(String) }
-  def rpath
-    "'$ORIGIN/../lib'"
-  end
+      requires_ancestor { ::Formula }
 
-  sig { params(targets: T.nilable(T.any(Pathname, String))).void }
-  def deuniversalize_machos(*targets); end
+      sig { params(name: String, version: T.nilable(T.any(String, Integer))).returns(String) }
+      def shared_library(name, version = nil)
+        suffix = if version == "*" || (name == "*" && version.blank?)
+          "{,.*}"
+        elsif version.present?
+          ".#{version}"
+        end
+        "#{name}.so#{suffix}"
+      end
 
-  class << self
-    undef ignore_missing_libraries
+      sig { returns(String) }
+      def loader_path
+        "$ORIGIN"
+      end
 
-    def ignore_missing_libraries(*libs)
-      libraries = libs.flatten
-      if libraries.any? { |x| !x.is_a?(String) && !x.is_a?(Regexp) }
-        raise FormulaSpecificationError, "#{__method__} can handle Strings and Regular Expressions only"
+      sig { params(targets: T.nilable(T.any(Pathname, String))).void }
+      def deuniversalize_machos(*targets); end
+
+      sig { params(spec: SoftwareSpec).void }
+      def add_global_deps_to_spec(spec)
+        return unless ::DevelopmentTools.needs_build_formulae?
+
+        @global_deps ||= begin
+          dependency_collector = spec.dependency_collector
+          related_formula_names = Set.new([
+            name,
+            *aliases,
+            *versioned_formulae_names,
+          ])
+          [
+            dependency_collector.gcc_dep_if_needed(related_formula_names),
+            dependency_collector.glibc_dep_if_needed(related_formula_names),
+          ].compact.freeze
+        end
+        @global_deps.each { |dep| spec.dependency_collector.add(dep) }
       end
 
-      allowed_missing_libraries.merge(libraries)
+      sig { returns(T::Boolean) }
+      def valid_platform?
+        requirements.none?(MacOSRequirement)
+      end
     end
   end
 end
+
+Formula.prepend(OS::Linux::Formula)
diff --git a/Library/Homebrew/extend/os/linux/formula_cellar_checks.rb b/Library/Homebrew/extend/os/linux/formula_cellar_checks.rb
index 11eb2a0db0484..b08411fb1bf14 100644
--- a/Library/Homebrew/extend/os/linux/formula_cellar_checks.rb
+++ b/Library/Homebrew/extend/os/linux/formula_cellar_checks.rb
@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 module FormulaCellarChecks
-  extend T::Sig
   sig { params(filename: Pathname).returns(T::Boolean) }
   def valid_library_extension?(filename)
     generic_valid_library_extension?(filename) || filename.basename.to_s.include?(".so.")
diff --git a/Library/Homebrew/extend/os/linux/formula_installer.rb b/Library/Homebrew/extend/os/linux/formula_installer.rb
new file mode 100644
index 0000000000000..6cae06010d8c4
--- /dev/null
+++ b/Library/Homebrew/extend/os/linux/formula_installer.rb
@@ -0,0 +1,10 @@
+# typed: strict
+# frozen_string_literal: true
+
+class FormulaInstaller
+  sig { params(formula: Formula).returns(T.nilable(T::Boolean)) }
+  def fresh_install?(formula)
+    !Homebrew::EnvConfig.developer? &&
+      (!installed_as_dependency? || !formula.any_version_installed?)
+  end
+end
diff --git a/Library/Homebrew/extend/os/linux/hardware/cpu.rb b/Library/Homebrew/extend/os/linux/hardware/cpu.rb
index 0e6805a6e0bbf..c90bd86de895d 100644
--- a/Library/Homebrew/extend/os/linux/hardware/cpu.rb
+++ b/Library/Homebrew/extend/os/linux/hardware/cpu.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module Hardware
@@ -111,7 +111,10 @@ def features
       end
 
       %w[aes altivec avx avx2 lm ssse3 sse4_2].each do |flag|
-        define_method("#{flag}?") { flags.include? flag }
+        define_method(:"#{flag}?") do
+          T.bind(self, T.class_of(Hardware::CPU))
+          flags.include? flag
+        end
       end
 
       def sse3?
diff --git a/Library/Homebrew/extend/os/linux/install.rb b/Library/Homebrew/extend/os/linux/install.rb
index a905cbca7a9b4..0fc3cd16dcc49 100644
--- a/Library/Homebrew/extend/os/linux/install.rb
+++ b/Library/Homebrew/extend/os/linux/install.rb
@@ -1,28 +1,49 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module Homebrew
   module Install
-    module_function
-
-    DYNAMIC_LINKERS = [
-      "/lib64/ld-linux-x86-64.so.2",
-      "/lib64/ld64.so.2",
-      "/lib/ld-linux.so.3",
-      "/lib/ld-linux.so.2",
-      "/lib/ld-linux-aarch64.so.1",
-      "/lib/ld-linux-armhf.so.3",
-      "/system/bin/linker64",
-      "/system/bin/linker",
+    # This is a list of known paths to the host dynamic linker on Linux if
+    # the host glibc is new enough. The symlink_ld_so method will fail if
+    # the host linker cannot be found in this list.
+    DYNAMIC_LINKERS = %w[
+      /lib64/ld-linux-x86-64.so.2
+      /lib64/ld64.so.2
+      /lib/ld-linux.so.3
+      /lib/ld-linux.so.2
+      /lib/ld-linux-aarch64.so.1
+      /lib/ld-linux-armhf.so.3
+      /system/bin/linker64
+      /system/bin/linker
     ].freeze
     private_constant :DYNAMIC_LINKERS
 
-    def perform_preinstall_checks(all_fatal: false, cc: nil)
-      generic_perform_preinstall_checks(all_fatal: all_fatal, cc: cc)
+    # We link GCC runtime libraries that are not specifically used for Fortran,
+    # which are linked by the GCC formula. We only use the versioned shared libraries
+    # as the other shared and static libraries are only used at build time where
+    # GCC can find its own libraries.
+    GCC_RUNTIME_LIBS = %w[
+      libatomic.so.1
+      libgcc_s.so.1
+      libgomp.so.1
+      libstdc++.so.6
+    ].freeze
+    private_constant :GCC_RUNTIME_LIBS
+
+    def self.perform_preinstall_checks(all_fatal: false)
+      generic_perform_preinstall_checks(all_fatal:)
+      symlink_ld_so
+      setup_preferred_gcc_libs
+    end
+    private_class_method :perform_preinstall_checks
+
+    def self.global_post_install
+      generic_global_post_install
       symlink_ld_so
+      setup_preferred_gcc_libs
     end
 
-    def check_cpu
+    def self.check_cpu
       return if Hardware::CPU.intel? && Hardware::CPU.is_64_bit?
       return if Hardware::CPU.arm?
 
@@ -37,19 +58,75 @@ def check_cpu
     end
     private_class_method :check_cpu
 
-    def symlink_ld_so
+    def self.symlink_ld_so
       brew_ld_so = HOMEBREW_PREFIX/"lib/ld.so"
-      return if brew_ld_so.readable?
 
-      ld_so = HOMEBREW_PREFIX/"opt/glibc/lib/ld-linux-x86-64.so.2"
+      ld_so = HOMEBREW_PREFIX/"opt/glibc/bin/ld.so"
       unless ld_so.readable?
         ld_so = DYNAMIC_LINKERS.find { |s| File.executable? s }
-        raise "Unable to locate the system's dynamic linker" unless ld_so
+        if ld_so.blank?
+          raise "Unable to locate the system's dynamic linker" unless brew_ld_so.readable?
+
+          return
+        end
       end
 
+      return if brew_ld_so.readable? && (brew_ld_so.readlink == ld_so)
+
       FileUtils.mkdir_p HOMEBREW_PREFIX/"lib"
       FileUtils.ln_sf ld_so, brew_ld_so
     end
     private_class_method :symlink_ld_so
+
+    def self.setup_preferred_gcc_libs
+      gcc_opt_prefix = HOMEBREW_PREFIX/"opt/#{OS::LINUX_PREFERRED_GCC_RUNTIME_FORMULA}"
+      glibc_installed = (HOMEBREW_PREFIX/"opt/glibc/bin/ld.so").readable?
+
+      return unless gcc_opt_prefix.readable?
+
+      if glibc_installed
+        ld_so_conf_d = HOMEBREW_PREFIX/"etc/ld.so.conf.d"
+        unless ld_so_conf_d.exist?
+          ld_so_conf_d.mkpath
+          FileUtils.chmod "go-w", ld_so_conf_d
+        end
+
+        # Add gcc to ld search paths
+        ld_gcc_conf = ld_so_conf_d/"50-homebrew-preferred-gcc.conf"
+        ld_gcc_conf_content = <<~EOS
+          # This file is generated by Homebrew. Do not modify.
+          #{gcc_opt_prefix}/lib/gcc/current
+        EOS
+
+        if !ld_gcc_conf.exist? || (ld_gcc_conf.read != ld_gcc_conf_content)
+          ld_gcc_conf.atomic_write ld_gcc_conf_content
+          FileUtils.chmod "u=rw,go-wx", ld_gcc_conf
+
+          FileUtils.rm_f HOMEBREW_PREFIX/"etc/ld.so.cache"
+          system HOMEBREW_PREFIX/"opt/glibc/sbin/ldconfig"
+        end
+      else
+        odie "#{HOMEBREW_PREFIX}/lib does not exist!" unless (HOMEBREW_PREFIX/"lib").readable?
+      end
+
+      GCC_RUNTIME_LIBS.each do |library|
+        gcc_library_symlink = HOMEBREW_PREFIX/"lib/#{library}"
+
+        if glibc_installed
+          # Remove legacy symlinks
+          FileUtils.rm gcc_library_symlink if gcc_library_symlink.symlink?
+        else
+          gcc_library = gcc_opt_prefix/"lib/gcc/current/#{library}"
+          # Skip if the link target doesn't exist.
+          next unless gcc_library.readable?
+
+          # Also skip if the symlink already exists.
+          next if gcc_library_symlink.readable? && (gcc_library_symlink.readlink == gcc_library)
+
+          FileUtils.ln_sf gcc_library, gcc_library_symlink
+        end
+      end
+    end
+    private_class_method :setup_preferred_gcc_libs
   end
 end
diff --git a/Library/Homebrew/extend/os/linux/keg.rb b/Library/Homebrew/extend/os/linux/keg.rb
new file mode 100644
index 0000000000000..657afa3e52983
--- /dev/null
+++ b/Library/Homebrew/extend/os/linux/keg.rb
@@ -0,0 +1,9 @@
+# typed: strict
+# frozen_string_literal: true
+
+class Keg
+  sig { returns(T::Array[Pathname]) }
+  def binary_executable_or_library_files
+    elf_files
+  end
+end
diff --git a/Library/Homebrew/extend/os/linux/keg_relocate.rb b/Library/Homebrew/extend/os/linux/keg_relocate.rb
index ee1537910cdf5..6b53cd5e15943 100644
--- a/Library/Homebrew/extend/os/linux/keg_relocate.rb
+++ b/Library/Homebrew/extend/os/linux/keg_relocate.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "compilers"
@@ -8,9 +8,6 @@ def relocate_dynamic_linkage(relocation)
     # Patching the dynamic linker of glibc breaks it.
     return if name.match? Version.formula_optionally_versioned_regex(:glibc)
 
-    # Patching patchelf fails with "Text file busy" or SIGBUS.
-    return if name == "patchelf"
-
     old_prefix, new_prefix = relocation.replacement_pair_for(:prefix)
 
     elf_files.each do |file|
@@ -21,7 +18,7 @@ def relocate_dynamic_linkage(relocation)
   end
 
   def change_rpath(file, old_prefix, new_prefix)
-    return if !file.elf? || !file.dynamic_elf?
+    return false if !file.elf? || !file.dynamic_elf?
 
     updated = {}
     old_rpath = file.rpath
@@ -33,6 +30,12 @@ def change_rpath(file, old_prefix, new_prefix)
       lib_path = "#{new_prefix}/lib"
       rpath << lib_path unless rpath.include? lib_path
 
+      # Add GCC's lib directory (as of GCC 12+) to RPATH when there is existing versioned linkage.
+      # This prevents broken linkage when pouring bottles built with an old GCC formula.
+      unless name.match?(Version.formula_optionally_versioned_regex(:gcc))
+        rpath.map! { |rp| rp.sub(%r{lib/gcc/\d+$}, "lib/gcc/current") }
+      end
+
       rpath.join(":")
     end
     updated[:rpath] = new_rpath if old_rpath != new_rpath
@@ -48,6 +51,7 @@ def change_rpath(file, old_prefix, new_prefix)
     updated[:interpreter] = new_interpreter if old_interpreter != new_interpreter
 
     file.patch!(interpreter: updated[:interpreter], rpath: updated[:rpath])
+    true
   end
 
   def detect_cxx_stdlibs(options = {})
@@ -80,16 +84,4 @@ def elf_files
     end
     elf_files
   end
-
-  def self.bottle_dependencies
-    @bottle_dependencies ||= begin
-      formulae = []
-      gcc = Formulary.factory(CompilerSelector.preferred_gcc)
-      if !Homebrew::EnvConfig.simulate_macos_on_linux? &&
-         DevelopmentTools.non_apple_gcc_version("gcc") < gcc.version.to_i
-        formulae << gcc
-      end
-      formulae
-    end
-  end
 end
diff --git a/Library/Homebrew/extend/os/linux/linkage_checker.rb b/Library/Homebrew/extend/os/linux/linkage_checker.rb
index 4e2bbf557bdb1..c2392f7d7b512 100644
--- a/Library/Homebrew/extend/os/linux/linkage_checker.rb
+++ b/Library/Homebrew/extend/os/linux/linkage_checker.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "compilers"
@@ -7,14 +7,13 @@ class LinkageChecker
   # Libraries provided by glibc and gcc.
   SYSTEM_LIBRARY_ALLOWLIST = %w[
     ld-linux-x86-64.so.2
+    ld-linux-aarch64.so.1
     libanl.so.1
     libatomic.so.1
     libc.so.6
-    libcrypt.so.1
     libdl.so.2
     libm.so.6
     libmvec.so.1
-    libnsl.so.1
     libnss_files.so.2
     libpthread.so.0
     libresolv.so.2
@@ -24,54 +23,28 @@ class LinkageChecker
     libgcc_s.so.1
     libgomp.so.1
     libstdc++.so.6
+    libquadmath.so.0
   ].freeze
 
-  def display_deprecated_warning(strict: false)
-    return unless @libcrypt_found
-
-    # Steps when moving this to `odisabled`:
-    # - Remove `libcrypt.so.1` from SYSTEM_LIBRARY_ALLOWLIST above.
-    # - Remove the `disable` and `disable_for_developer` kwargs here.
-    # - Remove `broken_library_linkage?` override below and the generic alias in HOMEBREW_LIBRARY/linkage_checker.rb.
-    # - Remove `fail_on_libcrypt1?`.
-    # Steps when removing this entirely (assuming the above has already been done):
-    # - Remove the `display_` overrides here and the associated generic aliases in HOMEBREW_LIBRARY/linkage_checker.rb
-    # - Remove the setting of `@libcrypt_found` in `check_dylibs` below.
-    odeprecated "linkage to libcrypt.so.1", "libcrypt.so.2 in the libxcrypt formula",
-                disable:                fail_on_libcrypt1?(strict: strict),
-                disable_for_developers: false
-  end
-
-  def display_normal_output
-    generic_display_normal_output
-    display_deprecated_warning
-  end
-
-  def display_test_output(puts_output: true, strict: false)
-    generic_display_test_output(puts_output: puts_output, strict: strict)
-    display_deprecated_warning(strict: strict)
-  end
-
-  def broken_library_linkage?(strict: false)
-    generic_broken_library_linkage?(strict: strict) || (fail_on_libcrypt1?(strict: strict) && @libcrypt_found)
-  end
-
   private
 
-  def fail_on_libcrypt1?(strict:)
-    strict || ENV["HOMEBREW_DISALLOW_LIBCRYPT1"].present?
-  end
-
   def check_dylibs(rebuild_cache:)
-    generic_check_dylibs(rebuild_cache: rebuild_cache)
-
-    @libcrypt_found = true if @system_dylibs.any? { |s| File.basename(s) == "libcrypt.so.1" }
+    generic_check_dylibs(rebuild_cache:)
 
     # glibc and gcc are implicit dependencies.
     # No other linkage to system libraries is expected or desired.
     @unwanted_system_dylibs = @system_dylibs.reject do |s|
       SYSTEM_LIBRARY_ALLOWLIST.include? File.basename(s)
     end
-    @undeclared_deps -= [CompilerSelector.preferred_gcc, "glibc"]
+
+    # We build all formulae with an RPATH that includes the gcc formula's runtime lib directory.
+    # See: https://github.com/Homebrew/brew/blob/e689cc07/Library/Homebrew/extend/os/linux/extend/ENV/super.rb#L53
+    # This results in formulae showing linkage with gcc whenever it is installed, even if no dependency is declared.
+    # See discussions at:
+    #   https://github.com/Homebrew/brew/pull/13659
+    #   https://github.com/Homebrew/brew/pull/13796
+    # TODO: Find a nicer way to handle this. (e.g. examining the ELF file to determine the required libstdc++.)
+    @undeclared_deps.delete("gcc")
+    @indirect_deps.delete("gcc")
   end
 end
diff --git a/Library/Homebrew/extend/os/linux/readall.rb b/Library/Homebrew/extend/os/linux/readall.rb
deleted file mode 100644
index 62c23532505c0..0000000000000
--- a/Library/Homebrew/extend/os/linux/readall.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Readall
-  class << self
-    def valid_casks?(*)
-      true
-    end
-  end
-end
diff --git a/Library/Homebrew/extend/os/linux/requirements/xcode_requirement.rb b/Library/Homebrew/extend/os/linux/requirements/xcode_requirement.rb
index 8ebc4ecd726ed..296663fbcad66 100644
--- a/Library/Homebrew/extend/os/linux/requirements/xcode_requirement.rb
+++ b/Library/Homebrew/extend/os/linux/requirements/xcode_requirement.rb
@@ -4,8 +4,6 @@
 require "requirement"
 
 class XcodeRequirement < Requirement
-  extend T::Sig
-
   sig { returns(T::Boolean) }
   def xcode_installed_version
     true
diff --git a/Library/Homebrew/extend/os/linux/simulate_system.rb b/Library/Homebrew/extend/os/linux/simulate_system.rb
new file mode 100644
index 0000000000000..248ee7e2a56d1
--- /dev/null
+++ b/Library/Homebrew/extend/os/linux/simulate_system.rb
@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OS
+  module Linux
+    module SimulateSystem
+      sig { returns(T.nilable(Symbol)) }
+      def os
+        @os ||= T.let(nil, T.nilable(Symbol))
+        return :macos if @os.blank? && Homebrew::EnvConfig.simulate_macos_on_linux?
+
+        @os
+      end
+
+      sig { returns(T::Boolean) }
+      def simulating_or_running_on_linux?
+        os.blank? || os == :linux
+      end
+
+      sig { returns(Symbol) }
+      def current_os
+        os || :linux
+      end
+    end
+  end
+end
+
+Homebrew::SimulateSystem.singleton_class.prepend(OS::Linux::SimulateSystem)
diff --git a/Library/Homebrew/extend/os/linux/software_spec.rb b/Library/Homebrew/extend/os/linux/software_spec.rb
index 7f5b4d289091c..fca4a667aff2d 100644
--- a/Library/Homebrew/extend/os/linux/software_spec.rb
+++ b/Library/Homebrew/extend/os/linux/software_spec.rb
@@ -2,8 +2,6 @@
 # frozen_string_literal: true
 
 class BottleSpecification
-  extend T::Sig
-
   sig { params(tag: Utils::Bottles::Tag).returns(T::Boolean) }
   def skip_relocation?(tag: Utils::Bottles.tag)
     false
diff --git a/Library/Homebrew/extend/os/linux/system_config.rb b/Library/Homebrew/extend/os/linux/system_config.rb
index fee1f439d6ad0..8f991634547ba 100644
--- a/Library/Homebrew/extend/os/linux/system_config.rb
+++ b/Library/Homebrew/extend/os/linux/system_config.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "compilers"
@@ -26,9 +26,9 @@ def host_gcc_version
     end
 
     def formula_linked_version(formula)
-      return "N/A" unless CoreTap.instance.installed?
+      return "N/A" if Homebrew::EnvConfig.no_install_from_api? && !CoreTap.instance.installed?
 
-      Formulary.factory(formula).linked_version || "N/A"
+      Formulary.factory(formula).any_installed_version || "N/A"
     rescue FormulaUnavailableError
       "N/A"
     end
@@ -41,13 +41,15 @@ def host_ruby_version
     end
 
     def dump_verbose_config(out = $stdout)
+      kernel = Utils.safe_popen_read("uname", "-mors").chomp
       dump_generic_verbose_config(out)
-      out.puts "Kernel: #{`uname -mors`.chomp}"
+      out.puts "Kernel: #{kernel}"
       out.puts "OS: #{OS::Linux.os_version}"
+      out.puts "WSL: #{OS::Linux.wsl_version}" if OS::Linux.wsl?
       out.puts "Host glibc: #{host_glibc_version}"
       out.puts "/usr/bin/gcc: #{host_gcc_version}"
       out.puts "/usr/bin/ruby: #{host_ruby_version}" if RUBY_PATH != HOST_RUBY_PATH
-      ["glibc", CompilerSelector.preferred_gcc, "xorg"].each do |f|
+      ["glibc", CompilerSelector.preferred_gcc, OS::LINUX_PREFERRED_GCC_RUNTIME_FORMULA, "xorg"].each do |f|
         out.puts "#{f}: #{formula_linked_version(f)}"
       end
     end
diff --git a/Library/Homebrew/extend/os/mac/cleaner.rb b/Library/Homebrew/extend/os/mac/cleaner.rb
index 9f2425ca284a9..303500fa5e1f6 100644
--- a/Library/Homebrew/extend/os/mac/cleaner.rb
+++ b/Library/Homebrew/extend/os/mac/cleaner.rb
@@ -1,12 +1,17 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-class Cleaner
-  private
+module OS
+  module Mac
+    module Cleaner
+      private
 
-  undef executable_path?
-
-  def executable_path?(path)
-    path.mach_o_executable? || path.text_executable?
+      sig { params(path: Pathname).returns(T::Boolean) }
+      def executable_path?(path)
+        path.mach_o_executable? || path.text_executable?
+      end
+    end
   end
 end
+
+Cleaner.prepend(OS::Mac::Cleaner)
diff --git a/Library/Homebrew/extend/os/mac/cleanup.rb b/Library/Homebrew/extend/os/mac/cleanup.rb
new file mode 100644
index 0000000000000..8779780d36dd6
--- /dev/null
+++ b/Library/Homebrew/extend/os/mac/cleanup.rb
@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OS
+  module Mac
+    module Cleanup
+      sig { returns(T::Boolean) }
+      def use_system_ruby?
+        return false if Homebrew::EnvConfig.force_vendor_ruby?
+
+        ::Homebrew::EnvConfig.developer? && ENV["HOMEBREW_USE_RUBY_FROM_PATH"].present?
+      end
+    end
+  end
+end
+
+Homebrew::Cleanup.prepend(OS::Mac::Cleanup)
diff --git a/Library/Homebrew/extend/os/mac/dependency_collector.rb b/Library/Homebrew/extend/os/mac/dependency_collector.rb
index 9387bbe50fa8b..da245f7e0f4d4 100644
--- a/Library/Homebrew/extend/os/mac/dependency_collector.rb
+++ b/Library/Homebrew/extend/os/mac/dependency_collector.rb
@@ -1,23 +1,26 @@
-# typed: true
+# typed: true # rubocop:disable Sorbet/StrictSigil
 # frozen_string_literal: true
 
-class DependencyCollector
-  undef git_dep_if_needed, subversion_dep_if_needed, cvs_dep_if_needed,
-        xz_dep_if_needed, unzip_dep_if_needed, bzip2_dep_if_needed
+module OS
+  module Mac
+    module DependencyCollector
+      def git_dep_if_needed(tags); end
 
-  def git_dep_if_needed(tags); end
+      def subversion_dep_if_needed(tags)
+        Dependency.new("subversion", [*tags, :implicit])
+      end
 
-  def subversion_dep_if_needed(tags)
-    Dependency.new("subversion", tags)
-  end
-
-  def cvs_dep_if_needed(tags)
-    Dependency.new("cvs", tags)
-  end
+      def cvs_dep_if_needed(tags)
+        Dependency.new("cvs", [*tags, :implicit])
+      end
 
-  def xz_dep_if_needed(tags); end
+      def xz_dep_if_needed(tags); end
 
-  def unzip_dep_if_needed(tags); end
+      def unzip_dep_if_needed(tags); end
 
-  def bzip2_dep_if_needed(tags); end
+      def bzip2_dep_if_needed(tags); end
+    end
+  end
 end
+
+DependencyCollector.prepend(OS::Mac::DependencyCollector)
diff --git a/Library/Homebrew/extend/os/mac/dev-cmd/bottle.rb b/Library/Homebrew/extend/os/mac/dev-cmd/bottle.rb
new file mode 100644
index 0000000000000..9d07b436956cd
--- /dev/null
+++ b/Library/Homebrew/extend/os/mac/dev-cmd/bottle.rb
@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OS
+  module Mac
+    module DevCmd
+      module Bottle
+        sig { returns(T::Array[String]) }
+        def tar_args
+          if MacOS.version >= :catalina
+            ["--no-mac-metadata", "--no-acls", "--no-xattrs"].freeze
+          else
+            [].freeze
+          end
+        end
+
+        sig { params(gnu_tar_formula: Formula).returns(String) }
+        def gnu_tar(gnu_tar_formula)
+          "#{gnu_tar_formula.opt_bin}/gtar"
+        end
+      end
+    end
+  end
+end
+
+Homebrew::DevCmd::Bottle.prepend(OS::Mac::DevCmd::Bottle)
diff --git a/Library/Homebrew/extend/os/mac/development_tools.rb b/Library/Homebrew/extend/os/mac/development_tools.rb
index 353ae30428a68..0ee2c31c957a9 100644
--- a/Library/Homebrew/extend/os/mac/development_tools.rb
+++ b/Library/Homebrew/extend/os/mac/development_tools.rb
@@ -1,77 +1,91 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "os/mac/xcode"
 
-# @private
-class DevelopmentTools
-  class << self
-    extend T::Sig
+module OS
+  module Mac
+    module DevelopmentTools
+      extend T::Helpers
 
-    alias generic_locate locate
-    undef installed?, default_compiler, curl_handles_most_https_certificates?,
-          subversion_handles_most_https_certificates?
+      requires_ancestor { ::DevelopmentTools }
 
-    sig { params(tool: String).returns(T.nilable(Pathname)) }
-    def locate(tool)
-      (@locate ||= {}).fetch(tool) do |key|
-        @locate[key] = if (located_tool = generic_locate(tool))
-          located_tool
-        else
-          path = Utils.popen_read("/usr/bin/xcrun", "-no-cache", "-find", tool, err: :close).chomp
-          Pathname.new(path) if File.executable?(path)
+      sig { params(tool: T.any(String, Symbol)).returns(T.nilable(Pathname)) }
+      def locate(tool)
+        @locate ||= T.let({}, T.nilable(T::Hash[T.any(String, Symbol), Pathname]))
+        @locate.fetch(tool) do |key|
+          @locate[key] = if (located_tool = super(tool))
+            located_tool
+          else
+            path = Utils.popen_read("/usr/bin/xcrun", "-no-cache", "-find", tool, err: :close).chomp
+            Pathname.new(path) if File.executable?(path)
+          end
         end
       end
-    end
 
-    # Checks if the user has any developer tools installed, either via Xcode
-    # or the CLT. Convenient for guarding against formula builds when building
-    # is impossible.
-    sig { returns(T::Boolean) }
-    def installed?
-      MacOS::Xcode.installed? || MacOS::CLT.installed?
-    end
+      # Checks if the user has any developer tools installed, either via Xcode
+      # or the CLT. Convenient for guarding against formula builds when building
+      # is impossible.
+      sig { returns(T::Boolean) }
+      def installed?
+        MacOS::Xcode.installed? || MacOS::CLT.installed?
+      end
 
-    sig { returns(Symbol) }
-    def default_compiler
-      :clang
-    end
+      sig { returns(Symbol) }
+      def default_compiler
+        :clang
+      end
 
-    sig { returns(T::Boolean) }
-    def curl_handles_most_https_certificates?
-      # The system Curl is too old for some modern HTTPS certificates on
-      # older macOS versions.
-      ENV["HOMEBREW_SYSTEM_CURL_TOO_OLD"].nil?
-    end
+      sig { returns(Version) }
+      def self.ld64_version
+        @ld64_version ||= T.let(begin
+          json = Utils.popen_read("/usr/bin/ld", "-version_details")
+          if $CHILD_STATUS.success?
+            Version.parse(JSON.parse(json)["version"])
+          else
+            Version::NULL
+          end
+        end, T.nilable(Version))
+      end
 
-    sig { returns(T::Boolean) }
-    def subversion_handles_most_https_certificates?
-      # The system Subversion is too old for some HTTPS certificates on
-      # older macOS versions.
-      MacOS.version >= :sierra
-    end
+      sig { returns(T::Boolean) }
+      def curl_handles_most_https_certificates?
+        # The system Curl is too old for some modern HTTPS certificates on
+        # older macOS versions.
+        ENV["HOMEBREW_SYSTEM_CURL_TOO_OLD"].nil?
+      end
 
-    sig { returns(String) }
-    def installation_instructions
-      MacOS::CLT.installation_instructions
-    end
+      sig { returns(T::Boolean) }
+      def subversion_handles_most_https_certificates?
+        # The system Subversion is too old for some HTTPS certificates on
+        # older macOS versions.
+        MacOS.version >= :sierra
+      end
 
-    sig { returns(String) }
-    def custom_installation_instructions
-      <<~EOS
-        Install GNU's GCC:
-          brew install gcc
-      EOS
-    end
+      sig { returns(String) }
+      def installation_instructions
+        MacOS::CLT.installation_instructions
+      end
 
-    sig { returns(T::Hash[String, T.nilable(String)]) }
-    def build_system_info
-      build_info = {
-        "xcode"          => MacOS::Xcode.version.to_s.presence,
-        "clt"            => MacOS::CLT.version.to_s.presence,
-        "preferred_perl" => MacOS.preferred_perl_version,
-      }
-      generic_build_system_info.merge build_info
+      sig { returns(String) }
+      def custom_installation_instructions
+        <<~EOS
+          Install GNU's GCC:
+            brew install gcc
+        EOS
+      end
+
+      sig { returns(T::Hash[String, T.nilable(String)]) }
+      def build_system_info
+        build_info = {
+          "xcode"          => MacOS::Xcode.version.to_s.presence,
+          "clt"            => MacOS::CLT.version.to_s.presence,
+          "preferred_perl" => MacOS.preferred_perl_version,
+        }
+        super.merge build_info
+      end
     end
   end
 end
+
+DevelopmentTools.singleton_class.prepend(OS::Mac::DevelopmentTools)
diff --git a/Library/Homebrew/extend/os/mac/diagnostic.rb b/Library/Homebrew/extend/os/mac/diagnostic.rb
index 0e733677e5a2c..0b993813a8ca3 100644
--- a/Library/Homebrew/extend/os/mac/diagnostic.rb
+++ b/Library/Homebrew/extend/os/mac/diagnostic.rb
@@ -1,493 +1,471 @@
-# typed: false
+# typed: true # rubocop:disable Sorbet/StrictSigil
 # frozen_string_literal: true
 
-module Homebrew
-  module Diagnostic
-    class Volumes
-      def initialize
-        @volumes = get_mounts
-      end
+module OS
+  module Mac
+    module Diagnostic
+      class Volumes
+        def initialize
+          @volumes = get_mounts
+        end
 
-      def which(path)
-        vols = get_mounts path
+        def which(path)
+          vols = get_mounts path
 
-        # no volume found
-        return -1 if vols.empty?
+          # no volume found
+          return -1 if vols.empty?
 
-        vol_index = @volumes.index(vols[0])
-        # volume not found in volume list
-        return -1 if vol_index.nil?
+          vol_index = @volumes.index(vols[0])
+          # volume not found in volume list
+          return -1 if vol_index.nil?
 
-        vol_index
-      end
+          vol_index
+        end
 
-      def get_mounts(path = nil)
-        vols = []
-        # get the volume of path, if path is nil returns all volumes
+        def get_mounts(path = nil)
+          vols = []
+          # get the volume of path, if path is nil returns all volumes
 
-        args = %w[/bin/df -P]
-        args << path if path
+          args = %w[/bin/df -P]
+          args << path if path
 
-        Utils.popen_read(*args) do |io|
-          io.each_line do |line|
-            case line.chomp
-              # regex matches: /dev/disk0s2   489562928 440803616  48247312    91%    /
-            when /^.+\s+[0-9]+\s+[0-9]+\s+[0-9]+\s+[0-9]{1,3}%\s+(.+)/
-              vols << Regexp.last_match(1)
+          Utils.popen_read(*args) do |io|
+            io.each_line do |line|
+              case line.chomp
+                # regex matches: /dev/disk0s2   489562928 440803616  48247312    91%    /
+              when /^.+\s+[0-9]+\s+[0-9]+\s+[0-9]+\s+[0-9]{1,3}%\s+(.+)/
+                vols << Regexp.last_match(1)
+              end
             end
           end
+          vols
         end
-        vols
       end
-    end
-
-    class Checks
-      undef fatal_preinstall_checks, fatal_build_from_source_checks,
-            fatal_setup_build_environment_checks, supported_configuration_checks,
-            build_from_source_checks
 
-      def fatal_preinstall_checks
-        checks = %w[
-          check_access_directories
-        ]
+      module Checks
+        extend T::Helpers
 
-        # We need the developer tools for `codesign`.
-        checks << "check_for_installed_developer_tools" if Hardware::CPU.arm?
+        requires_ancestor { Homebrew::Diagnostic::Checks }
 
-        checks.freeze
-      end
+        def fatal_preinstall_checks
+          checks = %w[
+            check_access_directories
+          ]
 
-      def fatal_build_from_source_checks
-        %w[
-          check_xcode_license_approved
-          check_xcode_minimum_version
-          check_clt_minimum_version
-          check_if_xcode_needs_clt_installed
-          check_if_supported_sdk_available
-          check_broken_sdks
-        ].freeze
-      end
+          # We need the developer tools for `codesign`.
+          checks << "check_for_installed_developer_tools" if ::Hardware::CPU.arm?
 
-      def fatal_setup_build_environment_checks
-        %w[
-          check_xcode_minimum_version
-          check_clt_minimum_version
-          check_if_supported_sdk_available
-        ].freeze
-      end
+          checks.freeze
+        end
 
-      def supported_configuration_checks
-        %w[
-          check_for_unsupported_macos
-        ].freeze
-      end
+        def fatal_build_from_source_checks
+          %w[
+            check_xcode_license_approved
+            check_xcode_minimum_version
+            check_clt_minimum_version
+            check_if_xcode_needs_clt_installed
+            check_if_supported_sdk_available
+            check_broken_sdks
+          ].freeze
+        end
 
-      def build_from_source_checks
-        %w[
-          check_for_installed_developer_tools
-          check_xcode_up_to_date
-          check_clt_up_to_date
-        ].freeze
-      end
+        def fatal_setup_build_environment_checks
+          %w[
+            check_xcode_minimum_version
+            check_clt_minimum_version
+            check_if_supported_sdk_available
+          ].freeze
+        end
 
-      def check_for_non_prefixed_findutils
-        findutils = Formula["findutils"]
-        return unless findutils.any_version_installed?
+        def supported_configuration_checks
+          %w[
+            check_for_unsupported_macos
+          ].freeze
+        end
 
-        gnubin = %W[#{findutils.opt_libexec}/gnubin #{findutils.libexec}/gnubin]
-        default_names = Tab.for_name("findutils").with? "default-names"
-        return if !default_names && (paths & gnubin).empty?
+        def build_from_source_checks
+          %w[
+            check_for_installed_developer_tools
+            check_xcode_up_to_date
+            check_clt_up_to_date
+          ].freeze
+        end
 
-        <<~EOS
-          Putting non-prefixed findutils in your path can cause python builds to fail.
-        EOS
-      rescue FormulaUnavailableError
-        nil
-      end
+        def check_for_non_prefixed_findutils
+          findutils = ::Formula["findutils"]
+          return unless findutils.any_version_installed?
 
-      def check_for_unsupported_macos
-        return if Homebrew::EnvConfig.developer?
-        return if ENV["HOMEBREW_INTEGRATION_TEST"]
+          gnubin = %W[#{findutils.opt_libexec}/gnubin #{findutils.libexec}/gnubin]
+          default_names = Tab.for_name("findutils").with? "default-names"
+          return if !default_names && !paths.intersect?(gnubin)
 
-        who = +"We"
-        what = if OS::Mac.version.prerelease?
-          "pre-release version"
-        elsif OS::Mac.version.outdated_release?
-          who << " (and Apple)"
-          "old version"
+          <<~EOS
+            Putting non-prefixed findutils in your path can cause python builds to fail.
+          EOS
+        rescue FormulaUnavailableError
+          nil
         end
-        return if what.blank?
 
-        who.freeze
+        def check_for_unsupported_macos
+          return if Homebrew::EnvConfig.developer?
+          return if ENV["HOMEBREW_INTEGRATION_TEST"]
 
-        <<~EOS
-          You are using macOS #{MacOS.version}.
-          #{who} do not provide support for this #{what}.
-          #{please_create_pull_requests(what)}
-        EOS
-      end
+          who = +"We"
+          what = if OS::Mac.version.prerelease?
+            "pre-release version"
+          elsif OS::Mac.version.outdated_release?
+            who << " (and Apple)"
+            "old version"
+          end
+          return if what.blank?
 
-      def check_xcode_up_to_date
-        return unless MacOS::Xcode.outdated?
-
-        # CI images are going to end up outdated so don't complain when
-        # `brew test-bot` runs `brew doctor` in the CI for the Homebrew/brew
-        # repository. This only needs to support whatever CI providers
-        # Homebrew/brew is currently using.
-        return if ENV["GITHUB_ACTIONS"]
-
-        # With fake El Capitan for Portable Ruby, we are intentionally not using Xcode 8.
-        # This is because we are not using the CLT and Xcode 8 has the 10.12 SDK.
-        return if ENV["HOMEBREW_FAKE_EL_CAPITAN"]
-
-        message = <<~EOS
-          Your Xcode (#{MacOS::Xcode.version}) is outdated.
-          Please update to Xcode #{MacOS::Xcode.latest_version} (or delete it).
-          #{MacOS::Xcode.update_instructions}
-        EOS
-
-        if OS::Mac.version.prerelease?
-          current_path = Utils.popen_read("/usr/bin/xcode-select", "-p")
-          message += <<~EOS
-            If #{MacOS::Xcode.latest_version} is installed, you may need to:
-              sudo xcode-select --switch /Applications/Xcode.app
-            Current developer directory is:
-              #{current_path}
+          who.freeze
+
+          <<~EOS
+            You are using macOS #{MacOS.version}.
+            #{who} do not provide support for this #{what}.
+            #{please_create_pull_requests(what)}
           EOS
         end
-        message
-      end
 
-      def check_clt_up_to_date
-        return unless MacOS::CLT.outdated?
+        def check_xcode_up_to_date
+          return unless MacOS::Xcode.outdated?
 
-        # CI images are going to end up outdated so don't complain when
-        # `brew test-bot` runs `brew doctor` in the CI for the Homebrew/brew
-        # repository. This only needs to support whatever CI providers
-        # Homebrew/brew is currently using.
-        return if ENV["GITHUB_ACTIONS"]
+          # avoid duplicate very similar messages
+          return if MacOS::Xcode.below_minimum_version?
 
-        <<~EOS
-          A newer Command Line Tools release is available.
-          #{MacOS::CLT.update_instructions}
-        EOS
-      end
-
-      def check_xcode_minimum_version
-        return unless MacOS::Xcode.below_minimum_version?
+          # CI images are going to end up outdated so don't complain when
+          # `brew test-bot` runs `brew doctor` in the CI for the Homebrew/brew
+          # repository. This only needs to support whatever CI providers
+          # Homebrew/brew is currently using.
+          return if GitHub::Actions.env_set?
 
-        xcode = MacOS::Xcode.version.to_s
-        xcode += " => #{MacOS::Xcode.prefix}" unless MacOS::Xcode.default_prefix?
+          # With fake El Capitan for Portable Ruby, we are intentionally not using Xcode 8.
+          # This is because we are not using the CLT and Xcode 8 has the 10.12 SDK.
+          return if ENV["HOMEBREW_FAKE_MACOS"]
 
-        <<~EOS
-          Your Xcode (#{xcode}) is too outdated.
-          Please update to Xcode #{MacOS::Xcode.latest_version} (or delete it).
-          #{MacOS::Xcode.update_instructions}
-        EOS
-      end
+          message = <<~EOS
+            Your Xcode (#{MacOS::Xcode.version}) is outdated.
+            Please update to Xcode #{MacOS::Xcode.latest_version} (or delete it).
+            #{MacOS::Xcode.update_instructions}
+          EOS
 
-      def check_clt_minimum_version
-        return unless MacOS::CLT.below_minimum_version?
+          if OS::Mac.version.prerelease?
+            current_path = Utils.popen_read("/usr/bin/xcode-select", "-p")
+            message += <<~EOS
+              If #{MacOS::Xcode.latest_version} is installed, you may need to:
+                sudo xcode-select --switch /Applications/Xcode.app
+              Current developer directory is:
+                #{current_path}
+            EOS
+          end
+          message
+        end
 
-        <<~EOS
-          Your Command Line Tools are too outdated.
-          #{MacOS::CLT.update_instructions}
-        EOS
-      end
+        def check_clt_up_to_date
+          return unless MacOS::CLT.outdated?
 
-      def check_if_xcode_needs_clt_installed
-        return unless MacOS::Xcode.needs_clt_installed?
+          # avoid duplicate very similar messages
+          return if MacOS::CLT.below_minimum_version?
 
-        <<~EOS
-          Xcode alone is not sufficient on #{MacOS.version.pretty_name}.
-          #{DevelopmentTools.installation_instructions}
-        EOS
-      end
+          # CI images are going to end up outdated so don't complain when
+          # `brew test-bot` runs `brew doctor` in the CI for the Homebrew/brew
+          # repository. This only needs to support whatever CI providers
+          # Homebrew/brew is currently using.
+          return if GitHub::Actions.env_set?
 
-      def check_ruby_version
-        # TODO: update portable-ruby to 2.6.9 when Ventura reaches RC
-        required_version = if MacOS.version >= :ventura &&
-                              ENV["HOMEBREW_RUBY_PATH"].to_s.exclude?("/vendor/portable-ruby/")
-          "2.6.9"
-        else
-          HOMEBREW_REQUIRED_RUBY_VERSION
+          <<~EOS
+            A newer Command Line Tools release is available.
+            #{MacOS::CLT.update_instructions}
+          EOS
         end
-        return if RUBY_VERSION == required_version
-        return if Homebrew::EnvConfig.developer? && OS::Mac.version.prerelease?
-
-        <<~EOS
-          Ruby version #{RUBY_VERSION} is unsupported on macOS #{MacOS.version}. Homebrew
-          is developed and tested on Ruby #{required_version}, and may not work correctly
-          on other Rubies. Patches are accepted as long as they don't cause breakage
-          on supported Rubies.
-        EOS
-      end
 
-      def check_xcode_prefix
-        prefix = MacOS::Xcode.prefix
-        return if prefix.nil?
-        return unless prefix.to_s.include?(" ")
+        def check_xcode_minimum_version
+          return unless MacOS::Xcode.below_minimum_version?
 
-        <<~EOS
-          Xcode is installed to a directory with a space in the name.
-          This will cause some formulae to fail to build.
-        EOS
-      end
+          xcode = MacOS::Xcode.version.to_s
+          xcode += " => #{MacOS::Xcode.prefix}" unless MacOS::Xcode.default_prefix?
 
-      def check_xcode_prefix_exists
-        prefix = MacOS::Xcode.prefix
-        return if prefix.nil? || prefix.exist?
+          <<~EOS
+            Your Xcode (#{xcode}) at #{MacOS::Xcode.bundle_path} is too outdated.
+            Please update to Xcode #{MacOS::Xcode.latest_version} (or delete it).
+            #{MacOS::Xcode.update_instructions}
+          EOS
+        end
 
-        <<~EOS
-          The directory Xcode is reportedly installed to doesn't exist:
-            #{prefix}
-          You may need to `xcode-select` the proper path if you have moved Xcode.
-        EOS
-      end
+        def check_clt_minimum_version
+          return unless MacOS::CLT.below_minimum_version?
 
-      def check_xcode_select_path
-        return if MacOS::CLT.installed?
-        return unless MacOS::Xcode.installed?
-        return if File.file?("#{MacOS.active_developer_dir}/usr/bin/xcodebuild")
-
-        path = MacOS::Xcode.bundle_path
-        path = "/Developer" if path.nil? || !path.directory?
-        <<~EOS
-          Your Xcode is configured with an invalid path.
-          You should change it to the correct path:
-            sudo xcode-select --switch #{path}
-        EOS
-      end
+          <<~EOS
+            Your Command Line Tools are too outdated.
+            #{MacOS::CLT.update_instructions}
+          EOS
+        end
 
-      def check_xcode_license_approved
-        # If the user installs Xcode-only, they have to approve the
-        # license or no "xc*" tool will work.
-        return unless `/usr/bin/xcrun clang 2>&1`.include?("license")
-        return if $CHILD_STATUS.success?
-
-        <<~EOS
-          You have not agreed to the Xcode license.
-          Agree to the license by opening Xcode.app or running:
-            sudo xcodebuild -license
-        EOS
-      end
+        def check_if_xcode_needs_clt_installed
+          return unless MacOS::Xcode.needs_clt_installed?
 
-      def check_filesystem_case_sensitive
-        dirs_to_check = [
-          HOMEBREW_PREFIX,
-          HOMEBREW_REPOSITORY,
-          HOMEBREW_CELLAR,
-          HOMEBREW_TEMP,
-        ]
-        case_sensitive_dirs = dirs_to_check.select do |dir|
-          # We select the dir as being case-sensitive if either the UPCASED or the
-          # downcased variant is missing.
-          # Of course, on a case-insensitive fs, both exist because the os reports so.
-          # In the rare situation when the user has indeed a downcased and an upcased
-          # dir (e.g. /TMP and /tmp) this check falsely thinks it is case-insensitive
-          # but we don't care because: 1. there is more than one dir checked, 2. the
-          # check is not vital and 3. we would have to touch files otherwise.
-          upcased = Pathname.new(dir.to_s.upcase)
-          downcased = Pathname.new(dir.to_s.downcase)
-          dir.exist? && !(upcased.exist? && downcased.exist?)
+          <<~EOS
+            Xcode alone is not sufficient on #{MacOS.version.pretty_name}.
+            #{::DevelopmentTools.installation_instructions}
+          EOS
         end
-        return if case_sensitive_dirs.empty?
 
-        volumes = Volumes.new
-        case_sensitive_vols = case_sensitive_dirs.map do |case_sensitive_dir|
-          volumes.get_mounts(case_sensitive_dir)
+        def check_xcode_prefix
+          prefix = MacOS::Xcode.prefix
+          return if prefix.nil?
+          return unless prefix.to_s.include?(" ")
+
+          <<~EOS
+            Xcode is installed to a directory with a space in the name.
+            This will cause some formulae to fail to build.
+          EOS
         end
-        case_sensitive_vols.uniq!
 
-        <<~EOS
-          The filesystem on #{case_sensitive_vols.join(",")} appears to be case-sensitive.
-          The default macOS filesystem is case-insensitive. Please report any apparent problems.
-        EOS
-      end
+        def check_xcode_prefix_exists
+          prefix = MacOS::Xcode.prefix
+          return if prefix.nil? || prefix.exist?
 
-      def check_for_gettext
-        find_relative_paths("lib/libgettextlib.dylib",
-                            "lib/libintl.dylib",
-                            "include/libintl.h")
-        return if @found.empty?
+          <<~EOS
+            The directory Xcode is reportedly installed to doesn't exist:
+              #{prefix}
+            You may need to `xcode-select` the proper path if you have moved Xcode.
+          EOS
+        end
 
-        # Our gettext formula will be caught by check_linked_keg_only_brews
-        gettext = begin
-          Formulary.factory("gettext")
-        rescue
-          nil
+        def check_xcode_select_path
+          return if MacOS::CLT.installed?
+          return unless MacOS::Xcode.installed?
+          return if File.file?("#{MacOS.active_developer_dir}/usr/bin/xcodebuild")
+
+          path = MacOS::Xcode.bundle_path
+          path = "/Developer" if path.nil? || !path.directory?
+          <<~EOS
+            Your Xcode is configured with an invalid path.
+            You should change it to the correct path:
+              sudo xcode-select --switch #{path}
+          EOS
+        end
+
+        def check_xcode_license_approved
+          # If the user installs Xcode-only, they have to approve the
+          # license or no "xc*" tool will work.
+          return unless `/usr/bin/xcrun clang 2>&1`.include?("license")
+          return if $CHILD_STATUS.success?
+
+          <<~EOS
+            You have not agreed to the Xcode license.
+            Agree to the license by opening Xcode.app or running:
+              sudo xcodebuild -license
+          EOS
         end
 
-        if gettext&.linked_keg&.directory?
-          allowlist = ["#{HOMEBREW_CELLAR}/gettext"]
-          if Hardware::CPU.physical_cpu_arm64?
-            allowlist += %W[
-              #{HOMEBREW_MACOS_ARM_DEFAULT_PREFIX}/Cellar/gettext
-              #{HOMEBREW_DEFAULT_PREFIX}/Cellar/gettext
-            ]
+        def check_filesystem_case_sensitive
+          dirs_to_check = [
+            HOMEBREW_PREFIX,
+            HOMEBREW_REPOSITORY,
+            HOMEBREW_CELLAR,
+            HOMEBREW_TEMP,
+          ]
+          case_sensitive_dirs = dirs_to_check.select do |dir|
+            # We select the dir as being case-sensitive if either the UPCASED or the
+            # downcased variant is missing.
+            # Of course, on a case-insensitive fs, both exist because the os reports so.
+            # In the rare situation when the user has indeed a downcased and an upcased
+            # dir (e.g. /TMP and /tmp) this check falsely thinks it is case-insensitive
+            # but we don't care because: 1. there is more than one dir checked, 2. the
+            # check is not vital and 3. we would have to touch files otherwise.
+            upcased = Pathname.new(dir.to_s.upcase)
+            downcased = Pathname.new(dir.to_s.downcase)
+            dir.exist? && !(upcased.exist? && downcased.exist?)
           end
+          return if case_sensitive_dirs.empty?
 
-          return if @found.all? do |path|
-            realpath = Pathname.new(path).realpath.to_s
-            allowlist.any? { |rack| realpath.start_with?(rack) }
+          volumes = Volumes.new
+          case_sensitive_vols = case_sensitive_dirs.map do |case_sensitive_dir|
+            volumes.get_mounts(case_sensitive_dir)
           end
+          case_sensitive_vols.uniq!
+
+          <<~EOS
+            The filesystem on #{case_sensitive_vols.join(",")} appears to be case-sensitive.
+            The default macOS filesystem is case-insensitive. Please report any apparent problems.
+          EOS
         end
 
-        inject_file_list @found, <<~EOS
-          gettext files detected at a system prefix.
-          These files can cause compilation and link failures, especially if they
-          are compiled with improper architectures. Consider removing these files:
-        EOS
-      end
+        def check_for_gettext
+          find_relative_paths("lib/libgettextlib.dylib",
+                              "lib/libintl.dylib",
+                              "include/libintl.h")
+          return if @found.empty?
+
+          # Our gettext formula will be caught by check_linked_keg_only_brews
+          gettext = begin
+            Formulary.factory("gettext")
+          rescue
+            nil
+          end
 
-      def check_for_iconv
-        find_relative_paths("lib/libiconv.dylib", "include/iconv.h")
-        return if @found.empty?
+          if gettext&.linked_keg&.directory?
+            allowlist = ["#{HOMEBREW_CELLAR}/gettext"]
+            if ::Hardware::CPU.physical_cpu_arm64?
+              allowlist += %W[
+                #{HOMEBREW_MACOS_ARM_DEFAULT_PREFIX}/Cellar/gettext
+                #{HOMEBREW_DEFAULT_PREFIX}/Cellar/gettext
+              ]
+            end
 
-        libiconv = begin
-          Formulary.factory("libiconv")
-        rescue
-          nil
-        end
-        if libiconv&.linked_keg&.directory?
-          unless libiconv.keg_only?
-            <<~EOS
-              A libiconv formula is installed and linked.
-              This will break stuff. For serious. Unlink it.
-            EOS
+            return if @found.all? do |path|
+              realpath = Pathname.new(path).realpath.to_s
+              allowlist.any? { |rack| realpath.start_with?(rack) }
+            end
           end
-        else
+
           inject_file_list @found, <<~EOS
-            libiconv files detected at a system prefix other than /usr.
-            Homebrew doesn't provide a libiconv formula, and expects to link against
-            the system version in /usr. libiconv in other prefixes can cause
-            compile or link failure, especially if compiled with improper
-            architectures. macOS itself never installs anything to /usr/local so
-            it was either installed by a user or some other third party software.
-
-            tl;dr: delete these files:
+            gettext files detected at a system prefix.
+            These files can cause compilation and link failures, especially if they
+            are compiled with improper architectures. Consider removing these files:
           EOS
         end
-      end
 
-      def check_for_bitdefender
-        if !Pathname("/Library/Bitdefender/AVP/EndpointSecurityforMac.app").exist? &&
-           !Pathname("/Library/Bitdefender/AVP/BDLDaemon").exist?
-          return
-        end
+        def check_for_iconv
+          find_relative_paths("lib/libiconv.dylib", "include/iconv.h")
+          return if @found.empty?
 
-        <<~EOS
-          You have installed Bitdefender. The "Traffic Scan" option interferes with
-          Homebrew's ability to download packages. See:
-            #{Formatter.url("https://github.com/Homebrew/brew/issues/5558")}
-        EOS
-      end
+          libiconv = begin
+            Formulary.factory("libiconv")
+          rescue
+            nil
+          end
+          if libiconv&.linked_keg&.directory?
+            unless libiconv&.keg_only?
+              <<~EOS
+                A libiconv formula is installed and linked.
+                This will break stuff. For serious. Unlink it.
+              EOS
+            end
+          else
+            inject_file_list @found, <<~EOS
+              libiconv files detected at a system prefix other than /usr.
+              Homebrew doesn't provide a libiconv formula and expects to link against
+              the system version in /usr. libiconv in other prefixes can cause
+              compile or link failure, especially if compiled with improper
+              architectures. macOS itself never installs anything to /usr/local so
+              it was either installed by a user or some other third party software.
+
+              tl;dr: delete these files:
+            EOS
+          end
+        end
 
-      def check_for_multiple_volumes
-        return unless HOMEBREW_CELLAR.exist?
+        def check_for_multiple_volumes
+          return unless HOMEBREW_CELLAR.exist?
 
-        volumes = Volumes.new
+          volumes = Volumes.new
 
-        # Find the volumes for the TMP folder & HOMEBREW_CELLAR
-        real_cellar = HOMEBREW_CELLAR.realpath
-        where_cellar = volumes.which real_cellar
+          # Find the volumes for the TMP folder & HOMEBREW_CELLAR
+          real_cellar = HOMEBREW_CELLAR.realpath
+          where_cellar = volumes.which real_cellar
 
-        begin
-          tmp = Pathname.new(Dir.mktmpdir("doctor", HOMEBREW_TEMP))
           begin
-            real_tmp = tmp.realpath.parent
-            where_tmp = volumes.which real_tmp
-          ensure
-            Dir.delete tmp
+            tmp = Pathname.new(Dir.mktmpdir("doctor", HOMEBREW_TEMP))
+            begin
+              real_tmp = tmp.realpath.parent
+              where_tmp = volumes.which real_tmp
+            ensure
+              Dir.delete tmp.to_s
+            end
+          rescue
+            return
           end
-        rescue
-          return
-        end
 
-        return if where_cellar == where_tmp
+          return if where_cellar == where_tmp
 
-        <<~EOS
-          Your Cellar and TEMP directories are on different volumes.
-          macOS won't move relative symlinks across volumes unless the target file already
-          exists. Brews known to be affected by this are Git and Narwhal.
+          <<~EOS
+            Your Cellar and TEMP directories are on different volumes.
+            macOS won't move relative symlinks across volumes unless the target file already
+            exists. Brews known to be affected by this are Git and Narwhal.
 
-          You should set the "HOMEBREW_TEMP" environment variable to a suitable
-          directory on the same volume as your Cellar.
-        EOS
-      end
+            You should set the "HOMEBREW_TEMP" environment variable to a suitable
+            directory on the same volume as your Cellar.
+          EOS
+        end
 
-      def check_deprecated_caskroom_taps
-        tapped_caskroom_taps = Tap.select { |t| t.user == "caskroom" || t.name == "phinze/cask" }
-                                  .map(&:name)
-        return if tapped_caskroom_taps.empty?
+        def check_deprecated_caskroom_taps
+          tapped_caskroom_taps = Tap.select { |t| t.user == "caskroom" || t.name == "phinze/cask" }
+                                    .map(&:name)
+          return if tapped_caskroom_taps.empty?
 
-        <<~EOS
-          You have the following deprecated, cask taps tapped:
-            #{tapped_caskroom_taps.join("\n  ")}
-          Untap them with `brew untap`.
-        EOS
-      end
+          <<~EOS
+            You have the following deprecated, cask taps tapped:
+              #{tapped_caskroom_taps.join("\n  ")}
+            Untap them with `brew untap`.
+          EOS
+        end
 
-      def check_if_supported_sdk_available
-        return unless DevelopmentTools.installed?
-        return unless MacOS.sdk_root_needed?
-        return if MacOS.sdk
+        def check_if_supported_sdk_available
+          return unless ::DevelopmentTools.installed?
+          return unless MacOS.sdk_root_needed?
+          return if MacOS.sdk
 
-        locator = MacOS.sdk_locator
+          locator = MacOS.sdk_locator
 
-        source = if locator.source == :clt
-          return if MacOS::CLT.below_minimum_version? # Handled by other diagnostics.
+          source = if locator.source == :clt
+            return if MacOS::CLT.below_minimum_version? # Handled by other diagnostics.
 
-          update_instructions = MacOS::CLT.update_instructions
-          "Command Line Tools (CLT)"
-        else
-          return if MacOS::Xcode.below_minimum_version? # Handled by other diagnostics.
+            update_instructions = MacOS::CLT.update_instructions
+            "Command Line Tools (CLT)"
+          else
+            return if MacOS::Xcode.below_minimum_version? # Handled by other diagnostics.
 
-          update_instructions = MacOS::Xcode.update_instructions
-          "Xcode"
-        end
+            update_instructions = MacOS::Xcode.update_instructions
+            "Xcode"
+          end
 
-        <<~EOS
-          Your #{source} does not support macOS #{MacOS.version}.
-          It is either outdated or was modified.
-          Please update your #{source} or delete it if no updates are available.
-          #{update_instructions}
-        EOS
-      end
+          <<~EOS
+            Your #{source} does not support macOS #{MacOS.version}.
+            It is either outdated or was modified.
+            Please update your #{source} or delete it if no updates are available.
+            #{update_instructions}
+          EOS
+        end
 
-      # The CLT 10.x -> 11.x upgrade process on 10.14 contained a bug which broke the SDKs.
-      # Notably, MacOSX10.14.sdk would indirectly symlink to MacOSX10.15.sdk.
-      # This diagnostic was introduced to check for this and recommend a full reinstall.
-      def check_broken_sdks
-        locator = MacOS.sdk_locator
+        # The CLT 10.x -> 11.x upgrade process on 10.14 contained a bug which broke the SDKs.
+        # Notably, MacOSX10.14.sdk would indirectly symlink to MacOSX10.15.sdk.
+        # This diagnostic was introduced to check for this and recommend a full reinstall.
+        def check_broken_sdks
+          locator = MacOS.sdk_locator
 
-        return if locator.all_sdks.all? do |sdk|
-          path_version = sdk.path.basename.to_s[MacOS::SDK::VERSIONED_SDK_REGEX, 1]
-          next true if path_version.blank?
+          return if locator.all_sdks.all? do |sdk|
+            path_version = sdk.path.basename.to_s[MacOS::SDK::VERSIONED_SDK_REGEX, 1]
+            next true if path_version.blank?
 
-          sdk.version == MacOS::Version.new(path_version).strip_patch
-        end
+            sdk.version == MacOSVersion.new(path_version).strip_patch
+          end
 
-        if locator.source == :clt
-          source = "Command Line Tools (CLT)"
-          path_to_remove = MacOS::CLT::PKG_PATH
-          installation_instructions = MacOS::CLT.installation_instructions
-        else
-          source = "Xcode"
-          path_to_remove = MacOS::Xcode.bundle_path
-          installation_instructions = MacOS::Xcode.installation_instructions
-        end
+          if locator.source == :clt
+            source = "Command Line Tools (CLT)"
+            path_to_remove = MacOS::CLT::PKG_PATH
+            installation_instructions = MacOS::CLT.installation_instructions
+          else
+            source = "Xcode"
+            path_to_remove = MacOS::Xcode.bundle_path
+            installation_instructions = MacOS::Xcode.installation_instructions
+          end
 
-        <<~EOS
-          The contents of the SDKs in your #{source} installation do not match the SDK folder names.
-          A clean reinstall of #{source} should fix this.
+          <<~EOS
+            The contents of the SDKs in your #{source} installation do not match the SDK folder names.
+            A clean reinstall of #{source} should fix this.
 
-          Remove the broken installation before reinstalling:
-            sudo rm -rf #{path_to_remove}
+            Remove the broken installation before reinstalling:
+              sudo rm -rf #{path_to_remove}
 
-          #{installation_instructions}
-        EOS
+            #{installation_instructions}
+          EOS
+        end
       end
     end
   end
 end
+
+Homebrew::Diagnostic::Checks.prepend(OS::Mac::Diagnostic::Checks)
diff --git a/Library/Homebrew/extend/os/mac/extend/ENV/shared.rb b/Library/Homebrew/extend/os/mac/extend/ENV/shared.rb
index a690791acc6c0..42a2cea1c7a1f 100644
--- a/Library/Homebrew/extend/os/mac/extend/ENV/shared.rb
+++ b/Library/Homebrew/extend/os/mac/extend/ENV/shared.rb
@@ -2,13 +2,21 @@
 # frozen_string_literal: true
 
 module SharedEnvExtension
-  extend T::Sig
-
-  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false)
-    generic_shared_setup_build_environment(
-      formula: formula, cc: cc, build_bottle: build_bottle,
-      bottle_arch: bottle_arch, testing_formula: testing_formula
-    )
+  sig {
+    params(
+      formula:         T.nilable(Formula),
+      cc:              T.nilable(String),
+      build_bottle:    T.nilable(T::Boolean),
+      bottle_arch:     T.nilable(String),
+      testing_formula: T::Boolean,
+      debug_symbols:   T.nilable(T::Boolean),
+    ).void
+  }
+  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false,
+                              debug_symbols: false)
+    generic_shared_setup_build_environment(formula:, cc:, build_bottle:,
+                                           bottle_arch:, testing_formula:,
+                                           debug_symbols:)
 
     # Normalise the system Perl version used, where multiple may be available
     self["VERSIONER_PERL_VERSION"] = MacOS.preferred_perl_version
@@ -16,11 +24,19 @@ def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_a
 
   sig { returns(T::Boolean) }
   def no_weak_imports_support?
-    return false unless compiler == :clang
+    return false if compiler != :clang
 
     return false if !MacOS::Xcode.version.null? && MacOS::Xcode.version < "8.0"
     return false if !MacOS::CLT.version.null? && MacOS::CLT.version < "8.0"
 
     true
   end
+
+  sig { returns(T::Boolean) }
+  def no_fixup_chains_support?
+    # This is supported starting Xcode 13, which ships ld64-711.
+    # https://developer.apple.com/documentation/xcode-release-notes/xcode-13-release-notes
+    # https://en.wikipedia.org/wiki/Xcode#Xcode_11.0_-_14.x_(since_SwiftUI_framework)_2
+    OS::Mac::DevelopmentTools.ld64_version >= 711
+  end
 end
diff --git a/Library/Homebrew/extend/os/mac/extend/ENV/std.rb b/Library/Homebrew/extend/os/mac/extend/ENV/std.rb
index d40fcec5002b1..c312eb1125234 100644
--- a/Library/Homebrew/extend/os/mac/extend/ENV/std.rb
+++ b/Library/Homebrew/extend/os/mac/extend/ENV/std.rb
@@ -1,30 +1,38 @@
-# typed: false
+# typed: true # rubocop:disable Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module Stdenv
-  # @private
-
   undef homebrew_extra_pkg_config_paths
 
+  sig { returns(T::Array[Pathname]) }
   def homebrew_extra_pkg_config_paths
-    ["#{HOMEBREW_LIBRARY}/Homebrew/os/mac/pkgconfig/#{MacOS.version}"]
+    [Pathname("#{HOMEBREW_LIBRARY}/Homebrew/os/mac/pkgconfig/#{MacOS.version}")]
   end
-
-  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false)
-    generic_setup_build_environment(
-      formula: formula, cc: cc, build_bottle: build_bottle,
-      bottle_arch: bottle_arch, testing_formula: testing_formula
-    )
+  private :homebrew_extra_pkg_config_paths
+
+  sig {
+    params(
+      formula:         T.nilable(Formula),
+      cc:              T.nilable(String),
+      build_bottle:    T.nilable(T::Boolean),
+      bottle_arch:     T.nilable(String),
+      testing_formula: T::Boolean,
+      debug_symbols:   T.nilable(T::Boolean),
+    ).void
+  }
+  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false,
+                              debug_symbols: false)
+    generic_setup_build_environment(formula:, cc:, build_bottle:, bottle_arch:,
+                                    testing_formula:, debug_symbols:)
 
     append "LDFLAGS", "-Wl,-headerpad_max_install_names"
 
-    # sed is strict, and errors out when it encounters files with
-    # mixed character sets
+    # `sed` is strict and errors out when it encounters files with mixed character sets.
     delete("LC_ALL")
     self["LC_CTYPE"] = "C"
 
-    # Add lib and include etc. from the current macosxsdk to compiler flags:
-    macosxsdk(formula: @formula, testing_formula: testing_formula)
+    # Add `lib` and `include` etc. from the current `macosxsdk` to compiler flags:
+    macosxsdk(formula: @formula, testing_formula:)
 
     return unless MacOS::Xcode.without_clt?
 
@@ -33,8 +41,8 @@ def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_a
   end
 
   def remove_macosxsdk(version = nil)
-    # Clear all lib and include dirs from CFLAGS, CPPFLAGS, LDFLAGS that were
-    # previously added by macosxsdk
+    # Clear all `lib` and `include` dirs from `CFLAGS`, `CPPFLAGS`, `LDFLAGS` that were
+    # previously added by `macosxsdk`.
     remove_from_cflags(/ ?-mmacosx-version-min=\d+\.\d+/)
     delete("CPATH")
     remove "LDFLAGS", "-L#{HOMEBREW_PREFIX}/lib"
@@ -49,14 +57,14 @@ def remove_macosxsdk(version = nil)
     if HOMEBREW_PREFIX.to_s == "/usr/local"
       delete("CMAKE_PREFIX_PATH")
     else
-      # It was set in setup_build_environment, so we have to restore it here.
+      # It was set in `setup_build_environment`, so we have to restore it here.
       self["CMAKE_PREFIX_PATH"] = HOMEBREW_PREFIX.to_s
     end
     remove "CMAKE_FRAMEWORK_PATH", "#{sdk}/System/Library/Frameworks"
   end
 
   def macosxsdk(version = nil, formula: nil, testing_formula: false)
-    # Sets all needed lib and include dirs to CFLAGS, CPPFLAGS, LDFLAGS.
+    # Sets all needed `lib` and `include` dirs to `CFLAGS`, `CPPFLAGS`, `LDFLAGS`.
     remove_macosxsdk
     min_version = version || MacOS.version
     append_to_cflags("-mmacosx-version-min=#{min_version}")
@@ -102,4 +110,8 @@ def libxml2
   def no_weak_imports
     append "LDFLAGS", "-Wl,-no_weak_imports" if no_weak_imports_support?
   end
+
+  def no_fixup_chains
+    append "LDFLAGS", "-Wl,-no_fixup_chains" if no_fixup_chains_support?
+  end
 end
diff --git a/Library/Homebrew/extend/os/mac/extend/ENV/super.rb b/Library/Homebrew/extend/os/mac/extend/ENV/super.rb
index c05535a800868..940bb6e744646 100644
--- a/Library/Homebrew/extend/os/mac/extend/ENV/super.rb
+++ b/Library/Homebrew/extend/os/mac/extend/ENV/super.rb
@@ -1,9 +1,7 @@
-# typed: false
+# typed: true # rubocop:disable Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module Superenv
-  extend T::Sig
-
   class << self
     # The location of Homebrew's shims on macOS.
     def shims_path
@@ -12,7 +10,6 @@ def shims_path
 
     undef bin
 
-    # @private
     def bin
       return unless DevelopmentTools.installed?
 
@@ -27,12 +24,12 @@ def bin
         homebrew_extra_cmake_frameworks_paths,
         determine_cccfg
 
-  # @private
+  sig { returns(T::Array[Pathname]) }
   def homebrew_extra_pkg_config_paths
-    ["/usr/lib/pkgconfig", "#{HOMEBREW_LIBRARY}/Homebrew/os/mac/pkgconfig/#{MacOS.version}"]
+    [Pathname("/usr/lib/pkgconfig"), Pathname("#{HOMEBREW_LIBRARY}/Homebrew/os/mac/pkgconfig/#{MacOS.version}")]
   end
+  private :homebrew_extra_pkg_config_paths
 
-  # @private
   sig { returns(T::Boolean) }
   def libxml2_include_needed?
     return false if deps.any? { |d| d.name == "libxml2" }
@@ -40,6 +37,7 @@ def libxml2_include_needed?
 
     true
   end
+  private :libxml2_include_needed?
 
   def homebrew_extra_isystem_paths
     paths = []
@@ -68,7 +66,7 @@ def homebrew_extra_cmake_include_paths
   end
 
   def homebrew_extra_cmake_library_paths
-    ["#{self["HOMEBREW_SDKROOT"]}/System/Library/Frameworks/OpenGL.framework/Versions/Current/Libraries"]
+    [Pathname("#{self["HOMEBREW_SDKROOT"]}/System/Library/Frameworks/OpenGL.framework/Versions/Current/Libraries")]
   end
 
   def homebrew_extra_cmake_frameworks_paths
@@ -85,25 +83,34 @@ def determine_cccfg
   end
 
   # @private
-  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false)
+  def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_arch: nil, testing_formula: false,
+                              debug_symbols: false)
     sdk = formula ? MacOS.sdk_for_formula(formula) : MacOS.sdk
     is_xcode_sdk = sdk&.source == :xcode
 
-    self["HOMEBREW_SDKROOT"] = if is_xcode_sdk || MacOS.sdk_root_needed?
+    if is_xcode_sdk || MacOS.sdk_root_needed?
       Homebrew::Diagnostic.checks(:fatal_setup_build_environment_checks)
-      sdk.path
+      self["HOMEBREW_SDKROOT"] = sdk.path if sdk
     end
 
     self["HOMEBREW_DEVELOPER_DIR"] = if is_xcode_sdk
-      MacOS::Xcode.prefix
+      MacOS::Xcode.prefix.to_s
     else
       MacOS::CLT::PKG_PATH
     end
 
-    generic_setup_build_environment(
-      formula: formula, cc: cc, build_bottle: build_bottle,
-      bottle_arch: bottle_arch, testing_formula: testing_formula
-    )
+    # This is a workaround for the missing `m4` in Xcode CLT 15.3, which was
+    # reported in FB13679972. Apple has fixed this in Xcode CLT 16.0.
+    # See https://github.com/Homebrew/homebrew-core/issues/165388
+    if deps.none? { |d| d.name == "m4" } &&
+       MacOS.active_developer_dir == MacOS::CLT::PKG_PATH &&
+       !File.exist?("#{MacOS::CLT::PKG_PATH}/usr/bin/m4") &&
+       (gm4 = DevelopmentTools.locate("gm4").to_s).present?
+      self["M4"] = gm4
+    end
+
+    generic_setup_build_environment(formula:, cc:, build_bottle:, bottle_arch:,
+                                    testing_formula:, debug_symbols:)
 
     # Filter out symbols known not to be defined since GNU Autotools can't
     # reliably figure this out with Xcode 8 and above.
@@ -123,6 +130,12 @@ def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_a
       ENV["ac_have_clock_syscall"] = "no"
     end
 
+    # On macOS Sonoma (at least release candidate), iconv() is generally
+    # present and working, but has a minor regression that defeats the
+    # test implemented in gettext's configure script (and used by many
+    # gettext dependents).
+    ENV["am_cv_func_iconv_works"] = "yes" if MacOS.version == "14"
+
     # The tools in /usr/bin proxy to the active developer directory.
     # This means we can use them for any combination of CLT and Xcode.
     self["HOMEBREW_PREFER_CLT_PROXIES"] = "1"
@@ -132,9 +145,27 @@ def setup_build_environment(formula: nil, cc: nil, build_bottle: false, bottle_a
     # Notably, Xcode 10.2 fixes issues where ZERO_AR_DATE affected file mtimes.
     # Xcode 11.0 contains fixes for lldb reading things built with ZERO_AR_DATE.
     self["ZERO_AR_DATE"] = "1" if MacOS::Xcode.version >= "11.0" || MacOS::CLT.version >= "11.0"
+
+    # Pass `-no_fixup_chains` whenever the linker is invoked with `-undefined dynamic_lookup`.
+    # See: https://github.com/python/cpython/issues/97524
+    #      https://github.com/pybind/pybind11/pull/4301
+    no_fixup_chains
+
+    # Strip build prefixes from linker where supported, for deterministic builds.
+    append_to_cccfg "o" if OS::Mac::DevelopmentTools.ld64_version >= 512
+
+    # Pass `-ld_classic` whenever the linker is invoked with `-dead_strip_dylibs`
+    # on `ld` versions that don't properly handle that option.
+    if OS::Mac::DevelopmentTools.ld64_version >= "1015.7" && OS::Mac::DevelopmentTools.ld64_version <= "1022.1"
+      append_to_cccfg "c"
+    end
   end
 
   def no_weak_imports
     append_to_cccfg "w" if no_weak_imports_support?
   end
+
+  def no_fixup_chains
+    append_to_cccfg "f" if no_fixup_chains_support?
+  end
 end
diff --git a/Library/Homebrew/extend/os/mac/extend/pathname.rbi b/Library/Homebrew/extend/os/mac/extend/pathname.rbi
new file mode 100644
index 0000000000000..01f544c3f9308
--- /dev/null
+++ b/Library/Homebrew/extend/os/mac/extend/pathname.rbi
@@ -0,0 +1,5 @@
+# typed: strict
+
+class Pathname
+  include MachOShim
+end
diff --git a/Library/Homebrew/extend/os/mac/formula.rb b/Library/Homebrew/extend/os/mac/formula.rb
new file mode 100644
index 0000000000000..c802e318064e8
--- /dev/null
+++ b/Library/Homebrew/extend/os/mac/formula.rb
@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OS
+  module Mac
+    module Formula
+      extend T::Helpers
+
+      requires_ancestor { ::Formula }
+
+      sig { returns(T::Boolean) }
+      def valid_platform?
+        requirements.none?(LinuxRequirement)
+      end
+
+      sig {
+        params(
+          install_prefix: T.any(String, Pathname),
+          install_libdir: T.any(String, Pathname),
+          find_framework: String,
+        ).returns(T::Array[String])
+      }
+      def std_cmake_args(install_prefix: prefix, install_libdir: "lib", find_framework: "LAST")
+        args = super
+
+        # Avoid false positives for clock_gettime support on 10.11.
+        # CMake cache entries for other weak symbols may be added here as needed.
+        args << "-DHAVE_CLOCK_GETTIME:INTERNAL=0" if MacOS.version == "10.11" && MacOS::Xcode.version >= "8.0"
+
+        # Ensure CMake is using the same SDK we are using.
+        args << "-DCMAKE_OSX_SYSROOT=#{MacOS.sdk_for_formula(self).path}" if MacOS.sdk_root_needed?
+
+        args
+      end
+    end
+  end
+end
+
+Formula.prepend(OS::Mac::Formula)
diff --git a/Library/Homebrew/extend/os/mac/formula_cellar_checks.rb b/Library/Homebrew/extend/os/mac/formula_cellar_checks.rb
index 322f4de60b100..324748d4d979a 100644
--- a/Library/Homebrew/extend/os/mac/formula_cellar_checks.rb
+++ b/Library/Homebrew/extend/os/mac/formula_cellar_checks.rb
@@ -1,16 +1,17 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 require "cache_store"
 require "linkage_checker"
 
 module FormulaCellarChecks
+  sig { returns(T.nilable(String)) }
   def check_shadowed_headers
     return if ["libtool", "subversion", "berkeley-db"].any? do |formula_name|
       formula.name.start_with?(formula_name)
     end
 
-    return if formula.name&.match?(Version.formula_optionally_versioned_regex(:php))
+    return if formula.name.match?(Version.formula_optionally_versioned_regex(:php))
     return if formula.keg_only? || !formula.include.directory?
 
     files  = relative_glob(formula.include, "**/*.h")
@@ -26,13 +27,14 @@ def check_shadowed_headers
     EOS
   end
 
+  sig { returns(T.nilable(String)) }
   def check_openssl_links
     return unless formula.prefix.directory?
 
     keg = Keg.new(formula.prefix)
     system_openssl = keg.mach_o_files.select do |obj|
       dlls = obj.dynamically_linked_libraries
-      dlls.any? { |dll| %r{/usr/lib/lib(crypto|ssl|tls)\..*dylib}.match dll }
+      dlls.any? { |dll| %r{/usr/lib/lib(crypto|ssl|tls)\..*dylib}.match? dll }
     end
     return if system_openssl.empty?
 
@@ -45,11 +47,12 @@ def check_openssl_links
     EOS
   end
 
+  sig { params(lib: Pathname).returns(T.nilable(String)) }
   def check_python_framework_links(lib)
     python_modules = Pathname.glob lib/"python*/site-packages/**/*.so"
     framework_links = python_modules.select do |obj|
       dlls = obj.dynamically_linked_libraries
-      dlls.any? { |dll| /Python\.framework/.match dll }
+      dlls.any? { |dll| dll.include?("Python.framework") }
     end
     return if framework_links.empty?
 
@@ -62,6 +65,7 @@ def check_python_framework_links(lib)
     EOS
   end
 
+  sig { void }
   def check_linkage
     return unless formula.prefix.directory?
 
@@ -76,23 +80,24 @@ def check_linkage
           #{checker.display_test_output}
       EOS
 
-      tab = Tab.for_keg(keg)
+      tab = keg.tab
       if tab.poured_from_bottle
         output += <<~EOS
           Rebuild this from source with:
             brew reinstall --build-from-source #{formula}
-          If that's successful, file an issue#{formula.tap ? " here:\n  #{formula.tap.issues_url}" : "."}
+          If that's successful, file an issue#{formula.tap ? " here:\n  #{T.must(formula.tap).issues_url}" : "."}
         EOS
       end
       problem_if_output output
     end
   end
 
+  sig { params(formula: Formula).returns(T.nilable(String)) }
   def check_flat_namespace(formula)
     return unless formula.prefix.directory?
-    return if formula.tap.present? && formula.tap.audit_exception(:flat_namespace_allowlist, formula.name)
+    return if formula.tap&.audit_exception(:flat_namespace_allowlist, formula.name)
 
-    keg = Keg.new(formula.prefix)
+    keg = ::Keg.new(formula.prefix)
     flat_namespace_files = keg.mach_o_files.reject do |file|
       next true unless file.dylib?
 
@@ -107,12 +112,13 @@ def check_flat_namespace(formula)
 
     <<~EOS
       Libraries were compiled with a flat namespace.
-      This can cause linker errors due to name collisions, and
+      This can cause linker errors due to name collisions and
       is often due to a bug in detecting the macOS version.
         #{flat_namespace_files * "\n  "}
     EOS
   end
 
+  sig { void }
   def audit_installed
     generic_audit_installed
     problem_if_output(check_shadowed_headers)
@@ -122,6 +128,7 @@ def audit_installed
     problem_if_output(check_flat_namespace(formula))
   end
 
+  sig { params(filename: Pathname).returns(T::Boolean) }
   def valid_library_extension?(filename)
     macos_lib_extensions = %w[.dylib .framework]
     generic_valid_library_extension?(filename) || macos_lib_extensions.include?(filename.extname)
diff --git a/Library/Homebrew/extend/os/mac/formula_installer.rb b/Library/Homebrew/extend/os/mac/formula_installer.rb
new file mode 100644
index 0000000000000..a59e532f2fbfb
--- /dev/null
+++ b/Library/Homebrew/extend/os/mac/formula_installer.rb
@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OS
+  module Mac
+    module FormulaInstaller
+      extend T::Helpers
+
+      requires_ancestor { ::FormulaInstaller }
+
+      sig { params(formula: Formula).returns(T.nilable(T::Boolean)) }
+      def fresh_install?(formula)
+        !::Homebrew::EnvConfig.developer? && !OS::Mac.version.outdated_release? &&
+          (!installed_as_dependency? || !formula.any_version_installed?)
+      end
+    end
+  end
+end
+
+FormulaInstaller.prepend(OS::Mac::FormulaInstaller)
diff --git a/Library/Homebrew/extend/os/mac/formula_support.rb b/Library/Homebrew/extend/os/mac/formula_support.rb
index 64e8d14726403..563f652d74c1e 100644
--- a/Library/Homebrew/extend/os/mac/formula_support.rb
+++ b/Library/Homebrew/extend/os/mac/formula_support.rb
@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 class KegOnlyReason
-  extend T::Sig
   sig { returns(T::Boolean) }
   def applicable?
     true
diff --git a/Library/Homebrew/extend/os/mac/hardware.rb b/Library/Homebrew/extend/os/mac/hardware.rb
index 43adfa1dea3eb..d984567c6945a 100644
--- a/Library/Homebrew/extend/os/mac/hardware.rb
+++ b/Library/Homebrew/extend/os/mac/hardware.rb
@@ -2,23 +2,20 @@
 # frozen_string_literal: true
 
 module Hardware
-  extend T::Sig
   sig { params(version: T.nilable(Version)).returns(Symbol) }
   def self.oldest_cpu(version = nil)
     version = if version
-      MacOS::Version.new(version.to_s)
+      MacOSVersion.new(version.to_s)
     else
       MacOS.version
     end
     if CPU.arch == :arm64
       :arm_vortex_tempest
-    # TODO: this cannot be re-enabled until either Rosetta 2 supports AVX
-    # instructions in bottles or Homebrew refuses to run under Rosetta 2 (when
-    # ARM support is sufficiently complete):
+    # This cannot use a newer CPU e.g. haswell because Rosetta 2 does not
+    # support AVX instructions in bottles:
     #   https://github.com/Homebrew/homebrew-core/issues/67713
-    #
-    # elsif version >= :big_sur
-    #   :ivybridge
+    elsif version >= :ventura
+      :westmere
     elsif version >= :mojave
       :nehalem
     else
diff --git a/Library/Homebrew/extend/os/mac/hardware/cpu.rb b/Library/Homebrew/extend/os/mac/hardware/cpu.rb
index 7d08694d85f99..35fe32d11684c 100644
--- a/Library/Homebrew/extend/os/mac/hardware/cpu.rb
+++ b/Library/Homebrew/extend/os/mac/hardware/cpu.rb
@@ -1,56 +1,66 @@
-# typed: false
+# typed: true # rubocop:disable Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "macho"
 
-module Hardware
-  class CPU
-    class << self
-      undef type, family, features, sse4?
-
-      # These methods use info spewed out by sysctl.
-      # Look in <mach/machine.h> for decoding info.
-      def type
-        case sysctl_int("hw.cputype")
-        when MachO::Headers::CPU_TYPE_I386
-          :intel
-        when MachO::Headers::CPU_TYPE_ARM64
-          :arm
-        else
-          :dunno
+module OS
+  module Mac
+    module Hardware
+      module CPU
+        extend T::Helpers
+
+        # These methods use info spewed out by sysctl.
+        # Look in <mach/machine.h> for decoding info.
+        def type
+          case ::Hardware::CPU.sysctl_int("hw.cputype")
+          when MachO::Headers::CPU_TYPE_I386
+            :intel
+          when MachO::Headers::CPU_TYPE_ARM64
+            :arm
+          else
+            :dunno
+          end
         end
-      end
 
-      def family
-        if arm?
-          arm_family
-        elsif intel?
-          intel_family
-        else
-          :dunno
+        def family
+          if ::Hardware::CPU.arm?
+            ::Hardware::CPU.arm_family
+          elsif ::Hardware::CPU.intel?
+            ::Hardware::CPU.intel_family
+          else
+            :dunno
+          end
         end
-      end
 
-      # True when running under an Intel-based shell via Rosetta 2 on an
-      # Apple Silicon Mac. This can be detected via seeing if there's a
-      # conflict between what `uname` reports and the underlying `sysctl` flags,
-      # since the `sysctl` flags don't change behaviour under Rosetta 2.
-      def in_rosetta2?
-        sysctl_bool("sysctl.proc_translated")
-      end
+        # True when running under an Intel-based shell via Rosetta 2 on an
+        # Apple Silicon Mac. This can be detected via seeing if there's a
+        # conflict between what `uname` reports and the underlying `sysctl` flags,
+        # since the `sysctl` flags don't change behaviour under Rosetta 2.
+        def in_rosetta2?
+          ::Hardware::CPU.sysctl_bool("sysctl.proc_translated")
+        end
 
-      def features
-        @features ||= sysctl_n(
-          "machdep.cpu.features",
-          "machdep.cpu.extfeatures",
-          "machdep.cpu.leaf7_features",
-        ).split.map { |s| s.downcase.to_sym }
-      end
+        def features
+          @features ||= ::Hardware::CPU.sysctl_n(
+            "machdep.cpu.features",
+            "machdep.cpu.extfeatures",
+            "machdep.cpu.leaf7_features",
+          ).split.map { |s| s.downcase.to_sym }
+        end
 
-      def sse4?
-        sysctl_bool("hw.optional.sse4_1")
+        def sse4?
+          ::Hardware::CPU.sysctl_bool("hw.optional.sse4_1")
+        end
       end
+    end
+  end
+end
 
+Hardware::CPU.singleton_class.prepend(OS::Mac::Hardware::CPU)
+
+module Hardware
+  class CPU
+    class << self
       def extmodel
         sysctl_int("machdep.cpu.extmodel")
       end
@@ -83,13 +93,15 @@ def sse4_2?
         sysctl_bool("hw.optional.sse4_2")
       end
 
-      # NOTE: this is more reliable than checking uname.
-      # `sysctl` returns the right answer even when running in Rosetta 2.
+      # NOTE: This is more reliable than checking `uname`. `sysctl` returns
+      #       the right answer even when running in Rosetta 2.
       def physical_cpu_arm64?
         sysctl_bool("hw.optional.arm64")
       end
 
-      private
+      def virtualized?
+        sysctl_bool("kern.hv_vmm_present")
+      end
 
       def arm_family
         case sysctl_int("hw.cpufamily")
@@ -109,12 +121,20 @@ def arm_family
           :arm_firestorm_icestorm
         when 0xda33d83d             # ARMv8.5-A (Blizzard, Avalanche)
           :arm_blizzard_avalanche
+        when 0xfa33415e             # ARMv8.6-A (M3, Ibiza)
+          :arm_ibiza
+        when 0x5f4dea93             # ARMv8.6-A (M3 Pro, Lobos)
+          :arm_lobos
+        when 0x72015832             # ARMv8.6-A (M3 Max, Palma)
+          :arm_palma
         else
+          # When adding new ARM CPU families, please also update
+          # test/hardware/cpu_spec.rb to include the new families.
           :dunno
         end
       end
 
-      def intel_family
+      def intel_family(_family = nil, _cpu_model = nil)
         case sysctl_int("hw.cpufamily")
         when 0x73d67300 # Yonah: Core Solo/Duo
           :core
@@ -152,7 +172,7 @@ def sysctl_bool(key)
       end
 
       def sysctl_int(key)
-        sysctl_n(key).to_i
+        sysctl_n(key).to_i & 0xffffffff
       end
 
       def sysctl_n(*keys)
diff --git a/Library/Homebrew/extend/os/mac/keg.rb b/Library/Homebrew/extend/os/mac/keg.rb
index 67abdc6ab3161..aae4eb6ad3552 100644
--- a/Library/Homebrew/extend/os/mac/keg.rb
+++ b/Library/Homebrew/extend/os/mac/keg.rb
@@ -1,65 +1,131 @@
-# typed: true
+# typed: true # rubocop:disable Sorbet/StrictSigil
 # frozen_string_literal: true
 
-class Keg
-  GENERIC_KEG_LINK_DIRECTORIES = (remove_const :KEG_LINK_DIRECTORIES).freeze
-  KEG_LINK_DIRECTORIES = (GENERIC_KEG_LINK_DIRECTORIES + ["Frameworks"]).freeze
-  GENERIC_MUST_EXIST_SUBDIRECTORIES = (remove_const :MUST_EXIST_SUBDIRECTORIES).freeze
-  MUST_EXIST_SUBDIRECTORIES = (
-    GENERIC_MUST_EXIST_SUBDIRECTORIES +
-    [HOMEBREW_PREFIX/"Frameworks"]
-  ).sort.uniq.freeze
-  GENERIC_MUST_EXIST_DIRECTORIES = (remove_const :MUST_EXIST_DIRECTORIES).freeze
-  MUST_EXIST_DIRECTORIES = (
-    GENERIC_MUST_EXIST_DIRECTORIES +
-    [HOMEBREW_PREFIX/"Frameworks"]
-  ).sort.uniq.freeze
-  GENERIC_MUST_BE_WRITABLE_DIRECTORIES = (remove_const :MUST_BE_WRITABLE_DIRECTORIES).freeze
-  MUST_BE_WRITABLE_DIRECTORIES = (
-    GENERIC_MUST_BE_WRITABLE_DIRECTORIES +
-    [HOMEBREW_PREFIX/"Frameworks"]
-  ).sort.uniq.freeze
-
-  undef binary_executable_or_library_files
-
-  def binary_executable_or_library_files
-    mach_o_files
-  end
+require "system_command"
 
-  def codesign_patched_binary(file)
-    return if MacOS.version < :big_sur
-    return unless Hardware::CPU.arm?
-
-    odebug "Codesigning #{file}"
-    # Use quiet_system to squash notifications about resigning binaries
-    # which already have valid signatures.
-    return if quiet_system("codesign", "--sign", "-", "--force",
-                           "--preserve-metadata=entitlements,requirements,flags,runtime",
-                           file)
-
-    # If the codesigning fails, it may be a bug in Apple's codesign utility
-    # A known workaround is to copy the file to another inode, then move it back
-    # erasing the previous file. Then sign again.
-    #
-    # TODO: remove this once the bug in Apple's codesign utility is fixed
-    Dir::Tmpname.create("workaround") do |tmppath|
-      FileUtils.cp file, tmppath
-      FileUtils.mv tmppath, file, force: true
-    end
+module OS
+  module Mac
+    module Keg
+      include SystemCommand::Mixin
+
+      module ClassMethods
+        def keg_link_directories
+          @keg_link_directories ||= (super + ["Frameworks"]).freeze
+        end
+
+        def must_exist_subdirectories
+          @must_exist_subdirectories ||= (
+            super +
+            [HOMEBREW_PREFIX/"Frameworks"]
+          ).sort.uniq.freeze
+        end
+
+        def must_exist_directories
+          @must_exist_directories = (
+            super +
+            [HOMEBREW_PREFIX/"Frameworks"]
+          ).sort.uniq.freeze
+        end
+
+        def must_be_writable_directories
+          @must_be_writable_directories ||= (
+            super +
+            [HOMEBREW_PREFIX/"Frameworks"]
+          ).sort.uniq.freeze
+        end
+      end
+
+      def binary_executable_or_library_files = mach_o_files
+
+      def codesign_patched_binary(file)
+        return if MacOS.version < :big_sur
+
+        unless ::Hardware::CPU.arm?
+          result = system_command("codesign", args: ["--verify", file], print_stderr: false)
+          return unless result.stderr.match?(/invalid signature/i)
+        end
+
+        odebug "Codesigning #{file}"
+        prepare_codesign_writable_files(file) do
+          # Use quiet_system to squash notifications about resigning binaries
+          # which already have valid signatures.
+          return if quiet_system("codesign", "--sign", "-", "--force",
+                                 "--preserve-metadata=entitlements,requirements,flags,runtime",
+                                 file)
 
-    # Try signing again
-    odebug "Codesigning (2nd try) #{file}"
-    result = system_command("codesign", args: [
-      "--sign", "-", "--force",
-      "--preserve-metadata=entitlements,requirements,flags,runtime",
-      file
-    ], print_stderr: false)
-    return if result.success?
-
-    # If it fails again, error out
-    onoe <<~EOS
-      Failed applying an ad-hoc signature to #{file}:
-      #{result.stderr}
-    EOS
+          # If the codesigning fails, it may be a bug in Apple's codesign utility
+          # A known workaround is to copy the file to another inode, then move it back
+          # erasing the previous file. Then sign again.
+          #
+          # TODO: remove this once the bug in Apple's codesign utility is fixed
+          Dir::Tmpname.create("workaround") do |tmppath|
+            FileUtils.cp file, tmppath
+            FileUtils.mv tmppath, file, force: true
+          end
+
+          # Try signing again
+          odebug "Codesigning (2nd try) #{file}"
+          result = system_command("codesign", args: [
+            "--sign", "-", "--force",
+            "--preserve-metadata=entitlements,requirements,flags,runtime",
+            file
+          ], print_stderr: false)
+          return if result.success?
+
+          # If it fails again, error out
+          onoe <<~EOS
+            Failed applying an ad-hoc signature to #{file}:
+            #{result.stderr}
+          EOS
+        end
+      end
+
+      def prepare_codesign_writable_files(file)
+        result = system_command("codesign", args: [
+          "--display", "--file-list", "-", file
+        ], print_stderr: false)
+        return unless result.success?
+
+        files = result.stdout.lines.map { |f| Pathname(f.chomp) }
+        saved_perms = {}
+        files.each do |f|
+          unless f.writable?
+            saved_perms[f] = f.stat.mode
+            FileUtils.chmod "u+rw", f.to_path
+          end
+        end
+        yield
+      ensure
+        saved_perms&.each do |f, p|
+          f.chmod p if p
+        end
+      end
+
+      def prepare_debug_symbols
+        binary_executable_or_library_files.each do |file|
+          odebug "Extracting symbols #{file}"
+
+          result = system_command("dsymutil", args: [file], print_stderr: false)
+          next if result.success?
+
+          # If it fails again, error out
+          ofail <<~EOS
+            Failed to extract symbols from #{file}:
+            #{result.stderr}
+          EOS
+        end
+      end
+
+      # Needed to make symlink permissions consistent on macOS and Linux for
+      # reproducible bottles.
+      def consistent_reproducible_symlink_permissions!
+        path.find do |file|
+          File.lchmod 0777, file if file.symlink?
+        end
+      end
+    end
   end
 end
+
+Keg.singleton_class.prepend(OS::Mac::Keg::ClassMethods)
+Keg.prepend(OS::Mac::Keg)
diff --git a/Library/Homebrew/extend/os/mac/keg_relocate.rb b/Library/Homebrew/extend/os/mac/keg_relocate.rb
index a58c3bd6f0057..be6928a15a2b7 100644
--- a/Library/Homebrew/extend/os/mac/keg_relocate.rb
+++ b/Library/Homebrew/extend/os/mac/keg_relocate.rb
@@ -1,192 +1,266 @@
-# typed: true
+# typed: true # rubocop:disable Sorbet/StrictSigil
 # frozen_string_literal: true
 
-class Keg
-  class << self
-    undef file_linked_libraries
-
-    def file_linked_libraries(file, string)
-      # Check dynamic library linkage. Importantly, do not perform for static
-      # libraries, which will falsely report "linkage" to themselves.
-      if file.mach_o_executable? || file.dylib? || file.mach_o_bundle?
-        file.dynamically_linked_libraries.select { |lib| lib.include? string }
-      else
-        []
+module OS
+  module Mac
+    module Keg
+      extend T::Helpers
+
+      requires_ancestor { ::Keg }
+
+      module ClassMethods
+        def file_linked_libraries(file, string)
+          # Check dynamic library linkage. Importantly, do not perform for static
+          # libraries, which will falsely report "linkage" to themselves.
+          if file.mach_o_executable? || file.dylib? || file.mach_o_bundle?
+            file.dynamically_linked_libraries.select { |lib| lib.include? string }
+          else
+            []
+          end
+        end
       end
-    end
-  end
 
-  undef relocate_dynamic_linkage
+      def relocate_dynamic_linkage(relocation)
+        mach_o_files.each do |file|
+          file.ensure_writable do
+            modified = T.let(false, T::Boolean)
+            needs_codesigning = T.let(false, T::Boolean)
+
+            if file.dylib?
+              id = relocated_name_for(file.dylib_id, relocation)
+              modified = change_dylib_id(id, file) if id
+              needs_codesigning ||= modified
+            end
+
+            each_linkage_for(file, :dynamically_linked_libraries) do |old_name|
+              new_name = relocated_name_for(old_name, relocation)
+              modified = change_install_name(old_name, new_name, file) if new_name
+              needs_codesigning ||= modified
+            end
+
+            each_linkage_for(file, :rpaths) do |old_name|
+              new_name = relocated_name_for(old_name, relocation)
+              modified = change_rpath(old_name, new_name, file) if new_name
+              needs_codesigning ||= modified
+            end
+
+            # codesign the file if needed
+            codesign_patched_binary(file) if needs_codesigning
+          end
+        end
+      end
 
-  def relocate_dynamic_linkage(relocation)
-    mach_o_files.each do |file|
-      file.ensure_writable do
-        if file.dylib?
-          id = relocated_name_for(file.dylib_id, relocation)
-          change_dylib_id(id, file)
+      def fix_dynamic_linkage
+        mach_o_files.each do |file|
+          file.ensure_writable do
+            modified = T.let(false, T::Boolean)
+            needs_codesigning = T.let(false, T::Boolean)
+
+            modified = change_dylib_id(dylib_id_for(file), file) if file.dylib?
+            needs_codesigning ||= modified
+
+            each_linkage_for(file, :dynamically_linked_libraries) do |bad_name|
+              # Don't fix absolute paths unless they are rooted in the build directory.
+              new_name = if bad_name.start_with?("/") && !rooted_in_build_directory?(bad_name)
+                bad_name
+              else
+                fixed_name(file, bad_name)
+              end
+              loader_name = loader_name_for(file, new_name)
+              modified = change_install_name(bad_name, loader_name, file) if loader_name != bad_name
+              needs_codesigning ||= modified
+            end
+
+            each_linkage_for(file, :rpaths) do |bad_name|
+              new_name = opt_name_for(bad_name)
+              loader_name = loader_name_for(file, new_name)
+              next if loader_name == bad_name
+
+              modified = change_rpath(bad_name, loader_name, file)
+              needs_codesigning ||= modified
+            end
+
+            # Strip duplicate rpaths and rpaths rooted in the build directory.
+            # We do this separately from the rpath relocation above to avoid
+            # failing to relocate an rpath whose variable duplicate we deleted.
+            each_linkage_for(file, :rpaths, resolve_variable_references: true) do |bad_name|
+              next if !rooted_in_build_directory?(bad_name) && file.rpaths.count(bad_name) == 1
+
+              modified = delete_rpath(bad_name, file)
+              needs_codesigning ||= modified
+            end
+
+            # codesign the file if needed
+            codesign_patched_binary(file) if needs_codesigning
+          end
         end
 
-        each_linkage_for(file, :dynamically_linked_libraries) do |old_name|
-          new_name = relocated_name_for(old_name, relocation)
-          change_install_name(old_name, new_name, file) if new_name
+        generic_fix_dynamic_linkage
+      end
+
+      def loader_name_for(file, target)
+        # Use @loader_path-relative install names for other Homebrew-installed binaries.
+        if ENV["HOMEBREW_RELOCATABLE_INSTALL_NAMES"] && target.start_with?(HOMEBREW_PREFIX)
+          dylib_suffix = find_dylib_suffix_from(target)
+          target_dir = Pathname.new(target.delete_suffix(dylib_suffix)).cleanpath
+
+          "@loader_path/#{target_dir.relative_path_from(file.dirname)/dylib_suffix}"
+        else
+          target
         end
+      end
 
-        each_linkage_for(file, :rpaths) do |old_name|
-          new_name = relocated_name_for(old_name, relocation)
-          change_rpath(old_name, new_name, file) if new_name
+      # If file is a dylib or bundle itself, look for the dylib named by
+      # bad_name relative to the lib directory, so that we can skip the more
+      # expensive recursive search if possible.
+      def fixed_name(file, bad_name)
+        if bad_name.start_with? ::Keg::PREFIX_PLACEHOLDER
+          bad_name.sub(::Keg::PREFIX_PLACEHOLDER, HOMEBREW_PREFIX)
+        elsif bad_name.start_with? ::Keg::CELLAR_PLACEHOLDER
+          bad_name.sub(::Keg::CELLAR_PLACEHOLDER, HOMEBREW_CELLAR)
+        elsif (file.dylib? || file.mach_o_bundle?) && (file.dirname/bad_name).exist?
+          "@loader_path/#{bad_name}"
+        elsif file.mach_o_executable? && (lib/bad_name).exist?
+          "#{lib}/#{bad_name}"
+        elsif file.mach_o_executable? && (libexec/"lib"/bad_name).exist?
+          "#{libexec}/lib/#{bad_name}"
+        elsif (abs_name = find_dylib(bad_name)) && abs_name.exist?
+          abs_name.to_s
+        else
+          opoo "Could not fix #{bad_name} in #{file}"
+          bad_name
         end
       end
-    end
-  end
 
-  def fix_dynamic_linkage
-    mach_o_files.each do |file|
-      file.ensure_writable do
-        change_dylib_id(dylib_id_for(file), file) if file.dylib?
+      VARIABLE_REFERENCE_RX = /^@(loader_|executable_|r)path/
 
-        each_linkage_for(file, :dynamically_linked_libraries) do |bad_name|
-          # Don't fix absolute paths unless they are rooted in the build directory
-          next if bad_name.start_with?("/") &&
-                  !bad_name.start_with?(HOMEBREW_TEMP.to_s) &&
-                  !bad_name.start_with?(HOMEBREW_TEMP.realpath.to_s)
+      def each_linkage_for(file, linkage_type, resolve_variable_references: false, &block)
+        file.public_send(linkage_type, resolve_variable_references:)
+            .grep_v(VARIABLE_REFERENCE_RX)
+            .each(&block)
+      end
 
-          new_name = fixed_name(file, bad_name)
-          change_install_name(bad_name, new_name, file) unless new_name == bad_name
-        end
+      def dylib_id_for(file)
+        # Swift dylib IDs should be /usr/lib/swift
+        return file.dylib_id if file.dylib_id.start_with?("/usr/lib/swift/libswift")
+
+        # The new dylib ID should have the same basename as the old dylib ID, not
+        # the basename of the file itself.
+        basename = File.basename(file.dylib_id)
+        relative_dirname = file.dirname.relative_path_from(path)
+        (opt_record/relative_dirname/basename).to_s
+      end
 
-        each_linkage_for(file, :rpaths) do |bad_name|
-          # Strip duplicate rpaths and rpaths rooted in the build directory.
-          next if !bad_name.start_with?(HOMEBREW_TEMP.to_s) &&
-                  !bad_name.start_with?(HOMEBREW_TEMP.realpath.to_s) &&
-                  (file.rpaths.count(bad_name) == 1)
+      sig { params(old_name: String, relocation: ::Keg::Relocation).returns(T.nilable(String)) }
+      def relocated_name_for(old_name, relocation)
+        old_prefix, new_prefix = relocation.replacement_pair_for(:prefix)
+        old_cellar, new_cellar = relocation.replacement_pair_for(:cellar)
 
-          delete_rpath(bad_name, file)
+        if old_name.start_with? old_cellar
+          old_name.sub(old_cellar, new_cellar)
+        elsif old_name.start_with? old_prefix
+          old_name.sub(old_prefix, new_prefix)
         end
       end
-    end
 
-    generic_fix_dynamic_linkage
-  end
+      # Matches framework references like `XXX.framework/Versions/YYY/XXX` and
+      # `XXX.framework/XXX`, both with or without a slash-delimited prefix.
+      FRAMEWORK_RX = %r{(?:^|/)(([^/]+)\.framework/(?:Versions/[^/]+/)?\2)$}
 
-  # If file is a dylib or bundle itself, look for the dylib named by
-  # bad_name relative to the lib directory, so that we can skip the more
-  # expensive recursive search if possible.
-  def fixed_name(file, bad_name)
-    if bad_name.start_with? PREFIX_PLACEHOLDER
-      bad_name.sub(PREFIX_PLACEHOLDER, HOMEBREW_PREFIX)
-    elsif bad_name.start_with? CELLAR_PLACEHOLDER
-      bad_name.sub(CELLAR_PLACEHOLDER, HOMEBREW_CELLAR)
-    elsif (file.dylib? || file.mach_o_bundle?) && (file.dirname/bad_name).exist?
-      "@loader_path/#{bad_name}"
-    elsif file.mach_o_executable? && (lib/bad_name).exist?
-      "#{lib}/#{bad_name}"
-    elsif file.mach_o_executable? && (libexec/"lib"/bad_name).exist?
-      "#{libexec}/lib/#{bad_name}"
-    elsif (abs_name = find_dylib(bad_name)) && abs_name.exist?
-      abs_name.to_s
-    else
-      opoo "Could not fix #{bad_name} in #{file}"
-      bad_name
-    end
-  end
+      def find_dylib_suffix_from(bad_name)
+        if (framework = bad_name.match(FRAMEWORK_RX))
+          framework[1]
+        else
+          File.basename(bad_name)
+        end
+      end
 
-  def each_linkage_for(file, linkage_type, &block)
-    links = file.method(linkage_type)
-                .call
-                .grep_v(/^@(loader_|executable_|r)path/)
-    links.each(&block)
-  end
+      def find_dylib(bad_name)
+        return unless lib.directory?
 
-  def dylib_id_for(file)
-    # The new dylib ID should have the same basename as the old dylib ID, not
-    # the basename of the file itself.
-    basename = File.basename(file.dylib_id)
-    relative_dirname = file.dirname.relative_path_from(path)
-    (opt_record/relative_dirname/basename).to_s
-  end
+        suffix = "/#{find_dylib_suffix_from(bad_name)}"
+        lib.find { |pn| break pn if pn.to_s.end_with?(suffix) }
+      end
 
-  def relocated_name_for(old_name, relocation)
-    old_prefix, new_prefix = relocation.replacement_pair_for(:prefix)
-    old_cellar, new_cellar = relocation.replacement_pair_for(:cellar)
+      def mach_o_files
+        hardlinks = Set.new
+        mach_o_files = []
+        path.find do |pn|
+          next if pn.symlink? || pn.directory?
+          next if !pn.dylib? && !pn.mach_o_bundle? && !pn.mach_o_executable?
+          # if we've already processed a file, ignore its hardlinks (which have the same dev ID and inode)
+          # this prevents relocations from being performed on a binary more than once
+          next unless hardlinks.add? [pn.stat.dev, pn.stat.ino]
+
+          mach_o_files << pn
+        end
 
-    if old_name.start_with? old_cellar
-      old_name.sub(old_cellar, new_cellar)
-    elsif old_name.start_with? old_prefix
-      old_name.sub(old_prefix, new_prefix)
-    end
-  end
+        mach_o_files
+      end
 
-  # Matches framework references like `XXX.framework/Versions/YYY/XXX` and
-  # `XXX.framework/XXX`, both with or without a slash-delimited prefix.
-  FRAMEWORK_RX = %r{(?:^|/)(([^/]+)\.framework/(?:Versions/[^/]+/)?\2)$}.freeze
+      def prepare_relocation_to_locations
+        relocation = generic_prepare_relocation_to_locations
 
-  def find_dylib_suffix_from(bad_name)
-    if (framework = bad_name.match(FRAMEWORK_RX))
-      framework[1]
-    else
-      File.basename(bad_name)
-    end
-  end
+        brewed_perl = runtime_dependencies&.any? { |dep| dep["full_name"] == "perl" && dep["declared_directly"] }
+        perl_path = if brewed_perl || name == "perl"
+          "#{HOMEBREW_PREFIX}/opt/perl/bin/perl"
+        elsif tab.built_on.present?
+          perl_path = "/usr/bin/perl#{tab.built_on["preferred_perl"]}"
 
-  def find_dylib(bad_name)
-    return unless lib.directory?
+          # For `:all` bottles, we could have built this bottle with a Perl we don't have.
+          # Such bottles typically don't have strict version requirements.
+          perl_path = "/usr/bin/perl#{MacOS.preferred_perl_version}" unless File.exist?(perl_path)
 
-    suffix = "/#{find_dylib_suffix_from(bad_name)}"
-    lib.find { |pn| break pn if pn.to_s.end_with?(suffix) }
-  end
+          perl_path
+        else
+          "/usr/bin/perl#{MacOS.preferred_perl_version}"
+        end
+        relocation.add_replacement_pair(:perl, ::Keg::PERL_PLACEHOLDER, perl_path)
 
-  def mach_o_files
-    hardlinks = Set.new
-    mach_o_files = []
-    path.find do |pn|
-      next if pn.symlink? || pn.directory?
-      next if !pn.dylib? && !pn.mach_o_bundle? && !pn.mach_o_executable?
-      # if we've already processed a file, ignore its hardlinks (which have the same dev ID and inode)
-      # this prevents relocations from being performed on a binary more than once
-      next unless hardlinks.add? [pn.stat.dev, pn.stat.ino]
-
-      mach_o_files << pn
-    end
+        if (openjdk = openjdk_dep_name_if_applicable)
+          openjdk_path = HOMEBREW_PREFIX/"opt"/openjdk/"libexec/openjdk.jdk/Contents/Home"
+          relocation.add_replacement_pair(:java, ::Keg::JAVA_PLACEHOLDER, openjdk_path.to_s)
+        end
 
-    mach_o_files
-  end
+        relocation
+      end
 
-  def prepare_relocation_to_locations
-    relocation = generic_prepare_relocation_to_locations
+      def recursive_fgrep_args
+        # Don't recurse into symlinks; the man page says this is the default, but
+        # it's wrong. -O is a BSD-grep-only option.
+        "-lrO"
+      end
 
-    brewed_perl = runtime_dependencies&.any? { |dep| dep["full_name"] == "perl" && dep["declared_directly"] }
-    perl_path = if brewed_perl || name == "perl"
-      "#{HOMEBREW_PREFIX}/opt/perl/bin/perl"
-    elsif tab["built_on"].present?
-      perl_path = "/usr/bin/perl#{tab["built_on"]["preferred_perl"]}"
+      def egrep_args
+        grep_bin = "egrep"
+        grep_args = "--files-with-matches"
+        [grep_bin, grep_args]
+      end
 
-      # For `:all` bottles, we could have built this bottle with a Perl we don't have.
-      # Such bottles typically don't have strict version requirements.
-      perl_path = "/usr/bin/perl#{MacOS.preferred_perl_version}" unless File.exist?(perl_path)
+      private
 
-      perl_path
-    else
-      "/usr/bin/perl#{MacOS.preferred_perl_version}"
-    end
-    relocation.add_replacement_pair(:perl, PERL_PLACEHOLDER, perl_path)
+      CELLAR_RX = %r{\A#{HOMEBREW_CELLAR}/(?<formula_name>[^/]+)/[^/]+}
 
-    if (openjdk = openjdk_dep_name_if_applicable)
-      openjdk_path = HOMEBREW_PREFIX/"opt"/openjdk/"libexec/openjdk.jdk/Contents/Home"
-      relocation.add_replacement_pair(:java, JAVA_PLACEHOLDER, openjdk_path.to_s)
-    end
+      # Replace HOMEBREW_CELLAR references with HOMEBREW_PREFIX/opt references
+      # if the Cellar reference is to a different keg.
+      def opt_name_for(filename)
+        return filename unless filename.start_with?(HOMEBREW_PREFIX.to_s)
+        return filename if filename.start_with?(path.to_s)
+        return filename if (matches = CELLAR_RX.match(filename)).blank?
 
-    relocation
-  end
+        filename.sub(CELLAR_RX, "#{HOMEBREW_PREFIX}/opt/#{matches[:formula_name]}")
+      end
 
-  def recursive_fgrep_args
-    # Don't recurse into symlinks; the man page says this is the default, but
-    # it's wrong. -O is a BSD-grep-only option.
-    "-lrO"
-  end
+      def rooted_in_build_directory?(filename)
+        # CMake normalises `/private/tmp` to `/tmp`.
+        # https://gitlab.kitware.com/cmake/cmake/-/issues/23251
+        return true if HOMEBREW_TEMP.to_s == "/private/tmp" && filename.start_with?("/tmp/")
 
-  def egrep_args
-    grep_bin = "egrep"
-    grep_args = "--files-with-matches"
-    [grep_bin, grep_args]
+        filename.start_with?(HOMEBREW_TEMP.to_s) || filename.start_with?(HOMEBREW_TEMP.realpath.to_s)
+      end
+    end
   end
 end
+
+Keg.singleton_class.prepend(OS::Mac::Keg::ClassMethods)
+Keg.prepend(OS::Mac::Keg)
diff --git a/Library/Homebrew/extend/os/mac/linkage_checker.rb b/Library/Homebrew/extend/os/mac/linkage_checker.rb
new file mode 100644
index 0000000000000..b82af034b2121
--- /dev/null
+++ b/Library/Homebrew/extend/os/mac/linkage_checker.rb
@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OS
+  module Mac
+    module LinkageChecker
+      private
+
+      sig { returns(T::Boolean) }
+      def system_libraries_exist_in_cache?
+        # In macOS Big Sur and later, system libraries do not exist on-disk and instead exist in a cache.
+        MacOS.version >= :big_sur
+      end
+    end
+  end
+end
+
+LinkageChecker.prepend(OS::Mac::LinkageChecker)
diff --git a/Library/Homebrew/extend/os/mac/missing_formula.rb b/Library/Homebrew/extend/os/mac/missing_formula.rb
index 3b294e3663e90..8721980e76370 100644
--- a/Library/Homebrew/extend/os/mac/missing_formula.rb
+++ b/Library/Homebrew/extend/os/mac/missing_formula.rb
@@ -1,16 +1,13 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "cask/cmd/abstract_command"
-require "cask/cmd/info"
+require "cask/info"
 require "cask/cask_loader"
 require "cask/caskroom"
 
 module Homebrew
   module MissingFormula
-    extend T::Sig
     class << self
-      extend T::Sig
       sig { params(name: String).returns(T.nilable(String)) }
       def disallowed_reason(name)
         case name.downcase
@@ -48,7 +45,7 @@ def suggest_command(name, command)
           suggestion = <<~EOS
             Found a cask named "#{name}" instead.
 
-            #{Cask::Cmd::Info.get_info(cask)}
+            #{Cask::Info.get_info(cask)}
           EOS
         else
           return
diff --git a/Library/Homebrew/extend/os/mac/readall.rb b/Library/Homebrew/extend/os/mac/readall.rb
new file mode 100644
index 0000000000000..69a4bd2727e0a
--- /dev/null
+++ b/Library/Homebrew/extend/os/mac/readall.rb
@@ -0,0 +1,46 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OS
+  module Mac
+    module Readall
+      extend T::Helpers
+
+      requires_ancestor { Kernel }
+
+      sig { params(tap: Tap, os_name: T.nilable(Symbol), arch: T.nilable(Symbol)).returns(T::Boolean) }
+      def valid_casks?(tap, os_name: nil, arch: ::Hardware::CPU.type)
+        return true if os_name == :linux
+
+        current_macos_version = if os_name.is_a?(Symbol)
+          MacOSVersion.from_symbol(os_name)
+        else
+          MacOS.version
+        end
+
+        success = T.let(true, T::Boolean)
+        tap.cask_files.each do |file|
+          cask = Cask::CaskLoader.load(file)
+
+          # Fine to have missing URLs for unsupported macOS
+          macos_req = cask.depends_on.macos
+          next if macos_req&.version && Array(macos_req.version).none? do |macos_version|
+            current_macos_version.compare(macos_req.comparator, macos_version)
+          end
+
+          raise "Missing URL" if cask.url.nil?
+        rescue Interrupt
+          raise
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          os_and_arch = "macOS #{current_macos_version} on #{arch}"
+          onoe "Invalid cask (#{os_and_arch}): #{file}"
+          $stderr.puts e
+          success = false
+        end
+        success
+      end
+    end
+  end
+end
+
+Readall.singleton_class.prepend(OS::Mac::Readall)
diff --git a/Library/Homebrew/extend/os/mac/sandbox.rb b/Library/Homebrew/extend/os/mac/sandbox.rb
new file mode 100644
index 0000000000000..976ede4716fe4
--- /dev/null
+++ b/Library/Homebrew/extend/os/mac/sandbox.rb
@@ -0,0 +1,9 @@
+# typed: strict
+# frozen_string_literal: true
+
+class Sandbox
+  sig { returns(T::Boolean) }
+  def self.available?
+    File.executable?(SANDBOX_EXEC)
+  end
+end
diff --git a/Library/Homebrew/extend/os/mac/search.rb b/Library/Homebrew/extend/os/mac/search.rb
deleted file mode 100644
index 6e5e6df789a55..0000000000000
--- a/Library/Homebrew/extend/os/mac/search.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "cask/cask"
-require "cask/cask_loader"
-
-module Homebrew
-  module Search
-    module Extension
-      def search_descriptions(string_or_regex, args)
-        super
-
-        return if args.formula?
-
-        puts unless args.cask?
-        ohai "Casks"
-        CacheStoreDatabase.use(:cask_descriptions) do |db|
-          cache_store = CaskDescriptionCacheStore.new(db)
-          Descriptions.search(string_or_regex, :desc, cache_store).print
-        end
-      end
-
-      def search_casks(string_or_regex)
-        if string_or_regex.is_a?(String) && string_or_regex.match?(HOMEBREW_TAP_CASK_REGEX)
-          return begin
-            [Cask::CaskLoader.load(string_or_regex).token]
-          rescue Cask::CaskUnavailableError
-            []
-          end
-        end
-
-        cask_tokens = Tap.flat_map(&:cask_tokens).map do |c|
-          c.sub(%r{^homebrew/cask.*/}, "")
-        end
-
-        results = cask_tokens.extend(Searchable)
-                             .search(string_or_regex)
-
-        cask_names = Cask::Cask.all.map(&:full_name)
-        results += DidYouMean::SpellChecker.new(dictionary: cask_names)
-                                           .correct(string_or_regex)
-
-        results.sort.map do |name|
-          cask = Cask::CaskLoader.load(name)
-          if cask.installed?
-            pretty_installed(cask.full_name)
-          else
-            cask.full_name
-          end
-        end.uniq
-      end
-    end
-
-    prepend Extension
-  end
-end
diff --git a/Library/Homebrew/extend/os/mac/simulate_system.rb b/Library/Homebrew/extend/os/mac/simulate_system.rb
new file mode 100644
index 0000000000000..a8e3329e198ea
--- /dev/null
+++ b/Library/Homebrew/extend/os/mac/simulate_system.rb
@@ -0,0 +1,22 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OS
+  module Mac
+    module SimulateSystem
+      sig { returns(T::Boolean) }
+      def simulating_or_running_on_macos?
+        return true if Homebrew::SimulateSystem.os.blank?
+
+        [:macos, *MacOSVersion::SYMBOLS.keys].include?(Homebrew::SimulateSystem.os)
+      end
+
+      sig { returns(Symbol) }
+      def current_os
+        ::Homebrew::SimulateSystem.os || MacOS.version.to_sym
+      end
+    end
+  end
+end
+
+Homebrew::SimulateSystem.singleton_class.prepend(OS::Mac::SimulateSystem)
diff --git a/Library/Homebrew/extend/os/mac/software_spec.rb b/Library/Homebrew/extend/os/mac/software_spec.rb
deleted file mode 100644
index 1be80083e286e..0000000000000
--- a/Library/Homebrew/extend/os/mac/software_spec.rb
+++ /dev/null
@@ -1,27 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-# The Library/Homebrew/extend/os/software_spec.rb conditional logic will need to be more nuanced
-# if this file ever includes more than `uses_from_macos`.
-class SoftwareSpec
-  undef uses_from_macos
-
-  def uses_from_macos(deps, bounds = {})
-    if deps.is_a?(Hash)
-      bounds = deps.dup
-      deps = [bounds.shift].to_h
-    end
-
-    @uses_from_macos_elements << deps
-
-    bounds = bounds.transform_values { |v| MacOS::Version.from_symbol(v) }
-
-    # Linux simulating macOS. Assume oldest macOS version.
-    return if Homebrew::EnvConfig.simulate_macos_on_linux? && !bounds.key?(:since)
-
-    # macOS new enough for dependency to not be required.
-    return if MacOS.version >= bounds[:since]
-
-    depends_on deps
-  end
-end
diff --git a/Library/Homebrew/extend/os/mac/system_config.rb b/Library/Homebrew/extend/os/mac/system_config.rb
index 552a58266eec7..0f84aca104ead 100644
--- a/Library/Homebrew/extend/os/mac/system_config.rb
+++ b/Library/Homebrew/extend/os/mac/system_config.rb
@@ -1,30 +1,27 @@
-# typed: true
+# typed: true # rubocop:disable Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "system_command"
 
-module SystemConfig
-  class << self
-    include SystemCommand::Mixin
-
-    undef describe_homebrew_ruby, describe_clang
+module OS
+  module Mac
+    module SystemConfig
+      sig { returns(String) }
+      def describe_clang
+        return "N/A" if ::SystemConfig.clang.null?
 
-    def describe_homebrew_ruby
-      s = describe_homebrew_ruby_version
-
-      if RUBY_PATH.to_s.match?(%r{^/System/Library/Frameworks/Ruby\.framework/Versions/[12]\.[089]/usr/bin/ruby})
-        s
-      else
-        "#{s} => #{RUBY_PATH}"
+        clang_build_info = ::SystemConfig.clang_build.null? ? "(parse error)" : ::SystemConfig.clang_build
+        "#{::SystemConfig.clang} build #{clang_build_info}"
       end
     end
+  end
+end
 
-    def describe_clang
-      return "N/A" if clang.null?
+SystemConfig.prepend(OS::Mac::SystemConfig)
 
-      clang_build_info = clang_build.null? ? "(parse error)" : clang_build
-      "#{clang} build #{clang_build_info}"
-    end
+module SystemConfig
+  class << self
+    include SystemCommand::Mixin
 
     def xcode
       @xcode ||= if MacOS::Xcode.installed?
@@ -38,12 +35,17 @@ def clt
       @clt ||= MacOS::CLT.version if MacOS::CLT.installed?
     end
 
-    def dump_verbose_config(f = $stdout)
-      dump_generic_verbose_config(f)
-      f.puts "macOS: #{MacOS.full_version}-#{kernel}"
-      f.puts "CLT: #{clt || "N/A"}"
-      f.puts "Xcode: #{xcode || "N/A"}"
-      f.puts "Rosetta 2: #{Hardware::CPU.in_rosetta2?}" if Hardware::CPU.physical_cpu_arm64?
+    def core_tap_config(out = $stdout)
+      dump_tap_config(CoreTap.instance, out)
+      dump_tap_config(CoreCaskTap.instance, out)
+    end
+
+    def dump_verbose_config(out = $stdout)
+      dump_generic_verbose_config(out)
+      out.puts "macOS: #{MacOS.full_version}-#{kernel}"
+      out.puts "CLT: #{clt || "N/A"}"
+      out.puts "Xcode: #{xcode || "N/A"}"
+      out.puts "Rosetta 2: #{Hardware::CPU.in_rosetta2?}" if Hardware::CPU.physical_cpu_arm64?
     end
   end
 end
diff --git a/Library/Homebrew/extend/os/mac/tap.rb b/Library/Homebrew/extend/os/mac/tap.rb
deleted file mode 100644
index b6a9e7b63eeaf..0000000000000
--- a/Library/Homebrew/extend/os/mac/tap.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-class Tap
-  def self.install_default_cask_tap_if_necessary(force: false)
-    return false if default_cask_tap.installed?
-    return false if Homebrew::EnvConfig.install_from_api?
-    return false if !force && Tap.untapped_official_taps.include?(default_cask_tap.name)
-
-    default_cask_tap.install
-    true
-  end
-end
diff --git a/Library/Homebrew/extend/os/mac/unpack_strategy/zip.rb b/Library/Homebrew/extend/os/mac/unpack_strategy/zip.rb
index 65585d3cd0073..959578c08bcd5 100644
--- a/Library/Homebrew/extend/os/mac/unpack_strategy/zip.rb
+++ b/Library/Homebrew/extend/os/mac/unpack_strategy/zip.rb
@@ -6,14 +6,13 @@
 module UnpackStrategy
   class Zip
     module MacOSZipExtension
-      extend T::Sig
+      extend T::Helpers
 
-      include UnpackStrategy
-      include SystemCommand::Mixin
+      requires_ancestor { UnpackStrategy }
 
-      using Magic
+      private
 
-      sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+      sig { params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
       def extract_to_dir(unpack_dir, basename:, verbose:)
         with_env(TZ: "UTC") do
           if merge_xattrs && contains_extended_attributes?(path)
@@ -22,7 +21,7 @@ def extract_to_dir(unpack_dir, basename:, verbose:)
             # (Also, Homebrew's ZIP artifact automatically deletes this folder.)
             return system_command! "ditto",
                                    args:         ["-x", "-k", path, unpack_dir],
-                                   verbose:      verbose,
+                                   verbose:,
                                    print_stderr: false
           end
 
@@ -31,9 +30,9 @@ def extract_to_dir(unpack_dir, basename:, verbose:)
           rescue ErrorDuringExecution => e
             raise unless e.stderr.include?("End-of-central-directory signature not found.")
 
-            system_command! "ditto",
+            system_command!("ditto",
                             args:    ["-x", "-k", path, unpack_dir],
-                            verbose: verbose
+                            verbose:)
             nil
           end
 
@@ -41,29 +40,26 @@ def extract_to_dir(unpack_dir, basename:, verbose:)
 
           volumes = result.stderr.chomp
                           .split("\n")
-                          .map { |l| l[/\A   skipping: (.+)  volume label\Z/, 1] }
-                          .compact
+                          .filter_map { |l| l[/\A   skipping: (.+)  volume label\Z/, 1] }
 
           return if volumes.empty?
 
-          Dir.mktmpdir do |tmp_unpack_dir|
+          Dir.mktmpdir("homebrew-zip", HOMEBREW_TEMP) do |tmp_unpack_dir|
             tmp_unpack_dir = Pathname(tmp_unpack_dir)
 
             # `ditto` keeps Finder attributes intact and does not skip volume labels
             # like `unzip` does, which can prevent disk images from being unzipped.
-            system_command! "ditto",
+            system_command!("ditto",
                             args:    ["-x", "-k", path, tmp_unpack_dir],
-                            verbose: verbose
+                            verbose:)
 
             volumes.each do |volume|
-              FileUtils.mv tmp_unpack_dir/volume, unpack_dir/volume, verbose: verbose
+              FileUtils.mv tmp_unpack_dir/volume, unpack_dir/volume, verbose:
             end
           end
         end
       end
 
-      private
-
       sig { params(path: Pathname).returns(T::Boolean) }
       def contains_extended_attributes?(path)
         path.zipinfo.grep(/(^__MACOSX|\._)/).any?
diff --git a/Library/Homebrew/extend/os/mac/unpack_strategy/zip.rbi b/Library/Homebrew/extend/os/mac/unpack_strategy/zip.rbi
deleted file mode 100644
index ee404163821ca..0000000000000
--- a/Library/Homebrew/extend/os/mac/unpack_strategy/zip.rbi
+++ /dev/null
@@ -1,9 +0,0 @@
-# typed: strict
-
-module UnpackStrategy
-  class Zip
-    module MacOSZipExtension
-      include Kernel
-    end
-  end
-end
diff --git a/Library/Homebrew/extend/os/mac/utils/analytics.rb b/Library/Homebrew/extend/os/mac/utils/analytics.rb
deleted file mode 100644
index cd5e227916727..0000000000000
--- a/Library/Homebrew/extend/os/mac/utils/analytics.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Utils
-  module Analytics
-    class << self
-      extend T::Sig
-
-      sig { returns(String) }
-      def custom_prefix_label
-        return generic_custom_prefix_label if Hardware::CPU.arm?
-
-        "non-/usr/local"
-      end
-
-      sig { returns(String) }
-      def arch_label
-        if Hardware::CPU.arm?
-          "ARM"
-        elsif Hardware::CPU.in_rosetta2?
-          "Rosetta"
-        else
-          ""
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/extend/os/mac/utils/bottles.rb b/Library/Homebrew/extend/os/mac/utils/bottles.rb
index 7d601f14f46d5..754aeaec64ef7 100644
--- a/Library/Homebrew/extend/os/mac/utils/bottles.rb
+++ b/Library/Homebrew/extend/os/mac/utils/bottles.rb
@@ -1,16 +1,19 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Utils
   module Bottles
     class << self
-      undef tag
+      module MacOSOverride
+        sig { params(tag: T.nilable(T.any(Symbol, Tag))).returns(Tag) }
+        def tag(tag = nil)
+          return Tag.new(system: MacOS.version.to_sym, arch: Hardware::CPU.arch) if tag.nil?
 
-      def tag(symbol = nil)
-        return Utils::Bottles::Tag.from_symbol(symbol) if symbol.present?
-
-        Utils::Bottles::Tag.new(system: MacOS.version.to_sym, arch: Hardware::CPU.arch)
+          super
+        end
       end
+
+      prepend MacOSOverride
     end
 
     class Collector
@@ -18,6 +21,7 @@ class Collector
 
       alias generic_find_matching_tag find_matching_tag
 
+      sig { params(tag: Utils::Bottles::Tag, no_older_versions: T::Boolean).returns(T.nilable(Utils::Bottles::Tag)) }
       def find_matching_tag(tag, no_older_versions: false)
         # Used primarily by developers testing beta macOS releases.
         if no_older_versions ||
@@ -32,10 +36,11 @@ def find_matching_tag(tag, no_older_versions: false)
       end
 
       # Find a bottle built for a previous version of macOS.
+      sig { params(tag: Utils::Bottles::Tag).returns(T.nilable(Utils::Bottles::Tag)) }
       def find_older_compatible_tag(tag)
         tag_version = begin
           tag.to_macos_version
-        rescue MacOSVersionError
+        rescue MacOSVersion::Error
           nil
         end
 
@@ -45,7 +50,7 @@ def find_older_compatible_tag(tag)
           next if candidate.arch != tag.arch
 
           candidate.to_macos_version <= tag_version
-        rescue MacOSVersionError
+        rescue MacOSVersion::Error
           false
         end
       end
diff --git a/Library/Homebrew/extend/os/mac/utils/socket.rb b/Library/Homebrew/extend/os/mac/utils/socket.rb
new file mode 100644
index 0000000000000..563a9b86d496a
--- /dev/null
+++ b/Library/Homebrew/extend/os/mac/utils/socket.rb
@@ -0,0 +1,30 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "socket"
+
+module OS
+  module Mac
+    # Wrapper around UNIXSocket to allow > 104 characters on macOS.
+    module UNIXSocketExt
+      extend T::Helpers
+
+      requires_ancestor { Kernel }
+
+      sig { params(path: String).returns(String) }
+      def sockaddr_un(path)
+        if path.bytesize > 252 # largest size that can fit into a single-byte length
+          raise ArgumentError, "too long unix socket path (#{path.bytesize} bytes given but 252 bytes max)"
+        end
+
+        [
+          path.bytesize + 3, # = length (1 byte) + family (1 byte) + path (variable) + null terminator (1 byte)
+          1, # AF_UNIX
+          path,
+        ].pack("CCZ*")
+      end
+    end
+  end
+end
+
+Utils::UNIXSocketExt.singleton_class.prepend(OS::Mac::UNIXSocketExt)
diff --git a/Library/Homebrew/extend/os/parser.rb b/Library/Homebrew/extend/os/parser.rb
new file mode 100644
index 0000000000000..fcf79902524d1
--- /dev/null
+++ b/Library/Homebrew/extend/os/parser.rb
@@ -0,0 +1,4 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "extend/os/linux/cli/parser" if OS.linux?
diff --git a/Library/Homebrew/extend/os/readall.rb b/Library/Homebrew/extend/os/readall.rb
index af407f1c44951..132f0062e0468 100644
--- a/Library/Homebrew/extend/os/readall.rb
+++ b/Library/Homebrew/extend/os/readall.rb
@@ -1,4 +1,4 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "extend/os/linux/readall" if OS.linux?
+require "extend/os/mac/readall" if OS.mac?
diff --git a/Library/Homebrew/extend/os/sandbox.rb b/Library/Homebrew/extend/os/sandbox.rb
new file mode 100644
index 0000000000000..f34ef2b4b228a
--- /dev/null
+++ b/Library/Homebrew/extend/os/sandbox.rb
@@ -0,0 +1,4 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "extend/os/mac/sandbox" if OS.mac?
diff --git a/Library/Homebrew/extend/os/search.rb b/Library/Homebrew/extend/os/search.rb
deleted file mode 100644
index 96e7ff28ecb15..0000000000000
--- a/Library/Homebrew/extend/os/search.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "extend/os/mac/search" if OS.mac?
diff --git a/Library/Homebrew/extend/os/simulate_system.rb b/Library/Homebrew/extend/os/simulate_system.rb
new file mode 100644
index 0000000000000..5558a82de239d
--- /dev/null
+++ b/Library/Homebrew/extend/os/simulate_system.rb
@@ -0,0 +1,8 @@
+# typed: strict
+# frozen_string_literal: true
+
+if OS.mac?
+  require "extend/os/mac/simulate_system"
+elsif OS.linux?
+  require "extend/os/linux/simulate_system"
+end
diff --git a/Library/Homebrew/extend/os/software_spec.rb b/Library/Homebrew/extend/os/software_spec.rb
index 32f46468f7d89..1e6f8f529c6aa 100644
--- a/Library/Homebrew/extend/os/software_spec.rb
+++ b/Library/Homebrew/extend/os/software_spec.rb
@@ -1,9 +1,4 @@
 # typed: strict
 # frozen_string_literal: true
 
-# This logic will need to be more nuanced if this file includes more than `uses_from_macos`.
-if OS.mac? || Homebrew::EnvConfig.simulate_macos_on_linux?
-  require "extend/os/mac/software_spec"
-elsif OS.linux?
-  require "extend/os/linux/software_spec"
-end
+require "extend/os/linux/software_spec" if OS.linux?
diff --git a/Library/Homebrew/extend/os/tap.rb b/Library/Homebrew/extend/os/tap.rb
deleted file mode 100644
index e6662ff7043f6..0000000000000
--- a/Library/Homebrew/extend/os/tap.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "extend/os/mac/tap" if OS.mac?
diff --git a/Library/Homebrew/extend/os/unpack_strategy/zip.rb b/Library/Homebrew/extend/os/unpack_strategy/zip.rb
new file mode 100644
index 0000000000000..007300b114f3c
--- /dev/null
+++ b/Library/Homebrew/extend/os/unpack_strategy/zip.rb
@@ -0,0 +1,4 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "extend/os/mac/unpack_strategy/zip" if OS.mac?
diff --git a/Library/Homebrew/extend/os/utils/analytics.rb b/Library/Homebrew/extend/os/utils/analytics.rb
deleted file mode 100644
index 3cdaffacb6c58..0000000000000
--- a/Library/Homebrew/extend/os/utils/analytics.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "extend/os/mac/utils/analytics" if OS.mac?
diff --git a/Library/Homebrew/extend/os/utils/socket.rb b/Library/Homebrew/extend/os/utils/socket.rb
new file mode 100644
index 0000000000000..97c060d894e32
--- /dev/null
+++ b/Library/Homebrew/extend/os/utils/socket.rb
@@ -0,0 +1,4 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "extend/os/mac/utils/socket" if OS.mac?
diff --git a/Library/Homebrew/extend/pathname.rb b/Library/Homebrew/extend/pathname.rb
index 7b6cb276c167a..c98c746579992 100644
--- a/Library/Homebrew/extend/pathname.rb
+++ b/Library/Homebrew/extend/pathname.rb
@@ -1,12 +1,10 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "context"
-require "resource"
-require "metafiles"
-
 module DiskUsageExtension
-  extend T::Sig
+  extend T::Helpers
+
+  requires_ancestor { Pathname }
 
   sig { returns(Integer) }
   def disk_usage
@@ -75,14 +73,17 @@ def compute_disk_usage
   end
 end
 
+require "system_command"
+
 # Homebrew extends Ruby's `Pathname` to make our code more readable.
 # @see https://ruby-doc.org/stdlib-2.6.3/libdoc/pathname/rdoc/Pathname.html Ruby's Pathname API
 class Pathname
-  extend T::Sig
-
+  include SystemCommand::Mixin
   include DiskUsageExtension
 
   # Moves a file from the original location to the {Pathname}'s.
+  #
+  # @api public
   sig {
     params(sources: T.any(
       Resource, Resource::Partial, String, Pathname,
@@ -125,12 +126,13 @@ def install_p(src, new_basename)
 
     mkpath
 
-    # Use FileUtils.mv over File.rename to handle filesystem boundaries. If src
-    # is a symlink, and its target is moved first, FileUtils.mv will fail:
-    #   https://bugs.ruby-lang.org/issues/7707
-    # In that case, use the system "mv" command.
+    # Use `FileUtils.mv` over `File.rename` to handle filesystem boundaries. If `src`
+    # is a symlink and its target is moved first, `FileUtils.mv` will fail
+    # (https://bugs.ruby-lang.org/issues/7707).
+    #
+    # In that case, use the system `mv` command.
     if src.symlink?
-      raise unless Kernel.system "mv", src, dst
+      raise unless Kernel.system "mv", src.to_s, dst
     else
       FileUtils.mv src, dst
     end
@@ -138,6 +140,8 @@ def install_p(src, new_basename)
   private :install_p
 
   # Creates symlinks to sources in this folder.
+  #
+  # @api public
   sig {
     params(
       sources: T.any(String, Pathname, T::Array[T.any(String, Pathname)], T::Hash[T.any(String, Pathname), String]),
@@ -166,6 +170,8 @@ def install_symlink_p(src, new_basename)
   private :install_symlink_p
 
   # Only appends to a file that is already created.
+  #
+  # @api public
   sig { params(content: String, open_args: T.untyped).void }
   def append_lines(content, **open_args)
     raise "Cannot append file that doesn't exist: #{self}" unless exist?
@@ -173,9 +179,15 @@ def append_lines(content, **open_args)
     T.unsafe(self).open("a", **open_args) { |f| f.puts(content) }
   end
 
-  # @note This always overwrites.
+  # Write to a file atomically.
+  #
+  # NOTE: This always overwrites.
+  #
+  # @api public
   sig { params(content: String).void }
   def atomic_write(content)
+    require "extend/file/atomic"
+
     old_stat = stat if exist?
     File.atomic_write(self) do |file|
       file.write(content)
@@ -194,6 +206,7 @@ def atomic_write(content)
       # Changing file ownership failed, moving on.
       nil
     end
+
     begin
       # This operation will affect filesystem ACL's
       chmod(old_stat.mode)
@@ -203,7 +216,6 @@ def atomic_write(content)
     end
   end
 
-  # @private
   def cp_path_sub(pattern, replacement)
     raise "#{self} does not exist" unless exist?
 
@@ -220,10 +232,9 @@ def cp_path_sub(pattern, replacement)
     end
   end
 
-  # @private
-  alias extname_old extname
-
   # Extended to support common double extensions.
+  #
+  # @api public
   sig { returns(String) }
   def extname
     basename = File.basename(self)
@@ -241,6 +252,8 @@ def extname
   end
 
   # For filetypes we support, returns basename without extension.
+  #
+  # @api public
   sig { returns(String) }
   def stem
     File.basename(self, extname)
@@ -249,7 +262,6 @@ def stem
   # I don't trust the children.length == 0 check particularly, not to mention
   # it is slow to enumerate the whole directory just to see if it is empty,
   # instead rely on good ol' libc and the filesystem
-  # @private
   sig { returns(T::Boolean) }
   def rmdir_if_possible
     rmdir
@@ -265,17 +277,15 @@ def rmdir_if_possible
     false
   end
 
-  # @private
   sig { returns(Version) }
   def version
     require "version"
     Version.parse(basename)
   end
 
-  # @private
   sig { returns(T::Boolean) }
   def text_executable?
-    /^#!\s*\S+/.match?(open("r") { |f| f.read(1024) })
+    /\A#!\s*\S+/.match?(open("r") { |f| f.read(1024) })
   end
 
   sig { returns(String) }
@@ -289,11 +299,14 @@ def verify_checksum(expected)
     raise ChecksumMissingError if expected.blank?
 
     actual = Checksum.new(sha256.downcase)
-    raise ChecksumMismatchError.new(self, expected, actual) unless expected == actual
+    raise ChecksumMismatchError.new(self, expected, actual) if expected != actual
   end
 
   alias to_str to_s
 
+  # Change to this directory, optionally executing the given block.
+  #
+  # @api public
   sig {
     type_parameters(:U).params(
       _block: T.proc.params(path: Pathname).returns(T.type_parameter(:U)),
@@ -303,18 +316,19 @@ def cd(&_block)
     Dir.chdir(self) { yield self }
   end
 
+  # Get all sub-directories of this directory.
+  #
+  # @api public
   sig { returns(T::Array[Pathname]) }
   def subdirs
     children.select(&:directory?)
   end
 
-  # @private
   sig { returns(Pathname) }
   def resolved_path
     symlink? ? dirname.join(readlink) : self
   end
 
-  # @private
   sig { returns(T::Boolean) }
   def resolved_path_exists?
     link = readlink
@@ -325,16 +339,14 @@ def resolved_path_exists?
     dirname.join(link).exist?
   end
 
-  # @private
   def make_relative_symlink(src)
     dirname.mkpath
     File.symlink(src.relative_path_from(dirname), self)
   end
 
-  # @private
   def ensure_writable
     saved_perms = nil
-    unless writable_real?
+    unless writable?
       saved_perms = stat.mode
       FileUtils.chmod "u+rw", to_path
     end
@@ -343,14 +355,21 @@ def ensure_writable
     chmod saved_perms if saved_perms
   end
 
-  # @private
+  def which_install_info
+    @which_install_info ||=
+      if File.executable?("/usr/bin/install-info")
+        "/usr/bin/install-info"
+      elsif Formula["texinfo"].any_version_installed?
+        Formula["texinfo"].opt_bin/"install-info"
+      end
+  end
+
   def install_info
-    quiet_system "/usr/bin/install-info", "--quiet", to_s, "#{dirname}/dir"
+    quiet_system(which_install_info, "--quiet", to_s, "#{dirname}/dir")
   end
 
-  # @private
   def uninstall_info
-    quiet_system "/usr/bin/install-info", "--delete", "--quiet", to_s, "#{dirname}/dir"
+    quiet_system(which_install_info, "--delete", "--quiet", to_s, "#{dirname}/dir")
   end
 
   # Writes an exec script in this folder for each target pathname.
@@ -416,9 +435,11 @@ def write_jar_script(target_jar, script_name, java_opts = "", java_version: nil)
   end
 
   def install_metafiles(from = Pathname.pwd)
+    require "metafiles"
+
     Pathname(from).children.each do |p|
       next if p.directory?
-      next if File.zero?(p)
+      next if File.empty?(p)
       next unless Metafiles.copy?(p.basename.to_s)
 
       # Some software symlinks these files (see help2man.rb)
@@ -452,21 +473,66 @@ def dylib?
     false
   end
 
+  sig { params(_wanted_arch: Symbol).returns(T::Boolean) }
+  def arch_compatible?(_wanted_arch)
+    true
+  end
+
   sig { returns(T::Array[String]) }
   def rpaths
     []
   end
-end
 
+  sig { returns(String) }
+  def magic_number
+    @magic_number ||= if directory?
+      ""
+    else
+      # Length of the longest regex (currently Tar).
+      max_magic_number_length = 262
+      binread(max_magic_number_length) || ""
+    end
+  end
+
+  sig { returns(String) }
+  def file_type
+    @file_type ||= system_command("file", args: ["-b", self], print_stderr: false)
+                   .stdout.chomp
+  end
+
+  sig { returns(T::Array[String]) }
+  def zipinfo
+    @zipinfo ||= system_command("zipinfo", args: ["-1", self], print_stderr: false)
+                 .stdout
+                 .encode(Encoding::UTF_8, invalid: :replace)
+                 .split("\n")
+  end
+
+  # Like regular `rmtree`, except it never ignores errors.
+  #
+  # This was the default behaviour in Ruby 3.1 and earlier.
+  #
+  # @api public
+  def rmtree(noop: nil, verbose: nil, secure: nil)
+    # Ideally we'd odeprecate this but probably can't given gems so let's
+    # create a RuboCop autocorrect instead soon.
+    # This is why monkeypatching is non-ideal (but right solution to get
+    # Ruby 3.3 over the line).
+    odeprecated "rmtree", "FileUtils#rm_r"
+    FileUtils.rm_r(@path, noop:, verbose:, secure:)
+    nil
+  end
+end
 require "extend/os/pathname"
 
-# @private
+require "context"
+
 module ObserverPathnameExtension
-  extend T::Sig
+  extend T::Helpers
 
-  class << self
-    extend T::Sig
+  requires_ancestor { Pathname }
 
+  class << self
     include Context
 
     sig { returns(Integer) }
@@ -484,7 +550,6 @@ def total
     end
 
     sig { returns([Integer, Integer]) }
-
     def counts
       [n, d]
     end
diff --git a/Library/Homebrew/extend/pathname.rbi b/Library/Homebrew/extend/pathname.rbi
deleted file mode 100644
index 12a94cd3eb784..0000000000000
--- a/Library/Homebrew/extend/pathname.rbi
+++ /dev/null
@@ -1,19 +0,0 @@
-# typed: strict
-
-module DiskUsageExtension
-  include Kernel
-
-  def exist?; end
-
-  def symlink?; end
-
-  def resolved_path; end
-end
-
-module ObserverPathnameExtension
-  include Kernel
-
-  def dirname; end
-
-  def basename; end
-end
diff --git a/Library/Homebrew/extend/predicable.rb b/Library/Homebrew/extend/predicable.rb
deleted file mode 100644
index 914244d5d3801..0000000000000
--- a/Library/Homebrew/extend/predicable.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-module Predicable
-  def attr_predicate(*attrs)
-    attrs.each do |attr|
-      define_method attr do
-        instance_variable_get("@#{attr.to_s.sub(/\?$/, "")}") == true
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/extend/string.rb b/Library/Homebrew/extend/string.rb
index 21105e71f4e8e..6beadc7272f67 100644
--- a/Library/Homebrew/extend/string.rb
+++ b/Library/Homebrew/extend/string.rb
@@ -1,4 +1,13 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "active_support/core_ext/object/blank"
+class String
+  # The inverse of <tt>String#include?</tt>. Returns true if the string
+  # does not include the other string.
+  #
+  #   "hello".exclude? "lo" # => false
+  #   "hello".exclude? "ol" # => true
+  #   "hello".exclude? ?h   # => false
+  sig { params(string: String).returns(T::Boolean) }
+  def exclude?(string) = !include?(string)
+end
diff --git a/Library/Homebrew/extend/time.rb b/Library/Homebrew/extend/time.rb
index 81779cd8dcd6f..75a79b864b47c 100644
--- a/Library/Homebrew/extend/time.rb
+++ b/Library/Homebrew/extend/time.rb
@@ -1,18 +1,9 @@
-# typed: false
+# typed: strong
 # frozen_string_literal: true
 
-module TimeRemaining
-  refine Time do
-    def remaining
-      [0, self - Time.now].max
-    end
+require "time"
 
-    def remaining!
-      r = remaining
-
-      raise Timeout::Error if r <= 0
-
-      r
-    end
-  end
+class Time
+  # Backwards compatibility for formulae that used this ActiveSupport extension
+  alias rfc3339 xmlschema
 end
diff --git a/Library/Homebrew/extend/time.rbi b/Library/Homebrew/extend/time.rbi
deleted file mode 100644
index ab1c7254f9ebd..0000000000000
--- a/Library/Homebrew/extend/time.rbi
+++ /dev/null
@@ -1,9 +0,0 @@
-# typed: strict
-
-class Time
-  sig { returns(T.any(Integer, Float)) }
-  def remaining; end
-
-  sig { returns(T.any(Integer, Float)) }
-  def remaining!; end
-end
diff --git a/Library/Homebrew/fetch.rb b/Library/Homebrew/fetch.rb
index 28244def2a28b..9bbd8047e95b2 100644
--- a/Library/Homebrew/fetch.rb
+++ b/Library/Homebrew/fetch.rb
@@ -2,20 +2,33 @@
 # frozen_string_literal: true
 
 module Homebrew
-  # @api private
   module Fetch
-    extend T::Sig
+    sig {
+      params(
+        formula:                    Formula,
+        force_bottle:               T::Boolean,
+        bottle_tag:                 T.nilable(Symbol),
+        build_from_source_formulae: T::Array[String],
+        os:                         T.nilable(Symbol),
+        arch:                       T.nilable(Symbol),
+      ).returns(T::Boolean)
+    }
+    def fetch_bottle?(formula, force_bottle:, bottle_tag:, build_from_source_formulae:, os:, arch:)
+      bottle = formula.bottle
 
-    sig { params(f: Formula, args: CLI::Args).returns(T::Boolean) }
-    def fetch_bottle?(f, args:)
-      bottle = f.bottle
-
-      return true if args.force_bottle? && bottle.present?
-      return true if args.bottle_tag.present? && f.bottled?(args.bottle_tag)
+      return true if force_bottle && bottle.present?
+      if os.present?
+        return true
+      elsif ENV["HOMEBREW_TEST_GENERIC_OS"].present?
+        # `:generic` bottles don't exist and `--os` flag is not specified.
+        return false
+      end
+      return true if arch.present?
+      return true if bottle_tag.present? && formula.bottled?(bottle_tag)
 
       bottle.present? &&
-        f.pour_bottle? &&
-        args.build_from_source_formulae.exclude?(f.full_name) &&
+        formula.pour_bottle? &&
+        build_from_source_formulae.exclude?(formula.full_name) &&
         bottle.compatible_locations?
     end
   end
diff --git a/Library/Homebrew/formula.rb b/Library/Homebrew/formula.rb
index f52caa36508c8..ceac979995011 100644
--- a/Library/Homebrew/formula.rb
+++ b/Library/Homebrew/formula.rb
@@ -1,15 +1,20 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "attrable"
 require "cache_store"
 require "did_you_mean"
 require "formula_support"
 require "lock_file"
 require "formula_pin"
 require "hardware"
+require "utils"
 require "utils/bottles"
+require "utils/gzip"
+require "utils/inreplace"
 require "utils/shebang"
 require "utils/shell"
+require "utils/git_repository"
 require "build_environment"
 require "build_options"
 require "formulary"
@@ -30,6 +35,7 @@
 require "utils/spdx"
 require "extend/on_system"
 require "api"
+require "extend/api_hashable"
 
 # A formula provides instructions and metadata for Homebrew to install a piece
 # of software. Every Homebrew formula is a {Formula}.
@@ -46,7 +52,10 @@
 # @see https://docs.brew.sh/Formula-Cookbook Formula Cookbook
 # @see https://rubystyle.guide Ruby Style Guide
 #
-# <pre>class Wget < Formula
+# ### Example
+#
+# ```ruby
+# class Wget < Formula
 #   homepage "https://www.gnu.org/software/wget/"
 #   url "https://ftp.gnu.org/gnu/wget/wget-1.15.tar.gz"
 #   sha256 "52126be8cf1bddd7536886e74c053ad7d0ed2aa89b4b630f76785bac21695fcd"
@@ -55,58 +64,76 @@
 #     system "./configure", "--prefix=#{prefix}"
 #     system "make", "install"
 #   end
-# end</pre>
+# end
+# ```
 class Formula
-  extend T::Sig
-
   include FileUtils
-  include Utils::Inreplace
   include Utils::Shebang
   include Utils::Shell
   include Context
   include OnSystem::MacOSAndLinux
+  include Homebrew::Livecheck::Constants
   extend Forwardable
   extend Cachable
-  extend Predicable
+  extend Attrable
+  extend APIHashable
 
-  # @!method inreplace(paths, before = nil, after = nil)
-  # @see Utils::Inreplace.inreplace
+  SUPPORTED_NETWORK_ACCESS_PHASES = [:build, :test, :postinstall].freeze
+  private_constant :SUPPORTED_NETWORK_ACCESS_PHASES
+  DEFAULT_NETWORK_ACCESS_ALLOWED = true
+  private_constant :DEFAULT_NETWORK_ACCESS_ALLOWED
 
   # The name of this {Formula}.
   # e.g. `this-formula`
+  #
+  # @api public
+  sig { returns(String) }
   attr_reader :name
 
   # The path to the alias that was used to identify this {Formula}.
   # e.g. `/usr/local/Library/Taps/homebrew/homebrew-core/Aliases/another-name-for-this-formula`
+  sig { returns(T.nilable(Pathname)) }
   attr_reader :alias_path
 
   # The name of the alias that was used to identify this {Formula}.
   # e.g. `another-name-for-this-formula`
+  sig { returns(T.nilable(String)) }
   attr_reader :alias_name
 
   # The fully-qualified name of this {Formula}.
-  # For core formula it's the same as {#name}.
+  # For core formulae it's the same as {#name}.
   # e.g. `homebrew/tap-name/this-formula`
+  #
+  # @api public
+  sig { returns(String) }
   attr_reader :full_name
 
   # The fully-qualified alias referring to this {Formula}.
-  # For core formula it's the same as {#alias_name}.
+  # For core formulae it's the same as {#alias_name}.
   # e.g. `homebrew/tap-name/another-name-for-this-formula`
+  sig { returns(T.nilable(String)) }
   attr_reader :full_alias_name
 
   # The full path to this {Formula}.
-  # e.g. `/usr/local/Library/Taps/homebrew/homebrew-core/Formula/this-formula.rb`
+  # e.g. `/usr/local/Library/Taps/homebrew/homebrew-core/Formula/t/this-formula.rb`
+  #
+  # @api public
+  sig { returns(Pathname) }
   attr_reader :path
 
   # The {Tap} instance associated with this {Formula}.
   # If it's `nil`, then this formula is loaded from a path or URL.
-  # @private
+  #
+  # @api internal
+  sig { returns(T.nilable(Tap)) }
   attr_reader :tap
 
   # The stable (and default) {SoftwareSpec} for this {Formula}.
   # This contains all the attributes (e.g. URL, checksum) that apply to the
   # stable version of this formula.
-  # @private
+  #
+  # @api internal
+  sig { returns(T.nilable(SoftwareSpec)) }
   attr_reader :stable
 
   # The HEAD {SoftwareSpec} for this {Formula}.
@@ -114,8 +141,9 @@ class Formula
   # This is always installed with the version `HEAD` and taken from the latest
   # commit in the version control system.
   # `nil` if there is no HEAD version.
+  #
   # @see #stable
-  # @private
+  sig { returns(T.nilable(SoftwareSpec)) }
   attr_reader :head
 
   # The currently active {SoftwareSpec}.
@@ -128,64 +156,79 @@ class Formula
   # A symbol to indicate currently active {SoftwareSpec}.
   # It's either :stable or :head
   # @see #active_spec
-  # @private
+  sig { returns(Symbol) }
   attr_reader :active_spec_sym
 
   # most recent modified time for source files
-  # @private
+  sig { returns(T.nilable(Time)) }
   attr_reader :source_modified_time
 
   # Used for creating new Homebrew versions of software without new upstream
   # versions.
   # @see .revision=
+  sig { returns(Integer) }
   attr_reader :revision
 
   # Used to change version schemes for packages.
   # @see .version_scheme=
+  sig { returns(Integer) }
   attr_reader :version_scheme
 
   # The current working directory during builds.
   # Will only be non-`nil` inside {#install}.
+  sig { returns(T.nilable(Pathname)) }
   attr_reader :buildpath
 
   # The current working directory during tests.
   # Will only be non-`nil` inside {.test}.
+  sig { returns(T.nilable(Pathname)) }
   attr_reader :testpath
 
   # When installing a bottle (binary package) from a local path this will be
   # set to the full path to the bottle tarball. If not, it will be `nil`.
-  # @private
+  sig { returns(T.nilable(Pathname)) }
   attr_accessor :local_bottle_path
 
   # When performing a build, test, or other loggable action, indicates which
   # log file location to use.
-  # @private
+  sig { returns(T.nilable(String)) }
   attr_reader :active_log_type
 
-  # The {BuildOptions} for this {Formula}. Lists the arguments passed and any
-  # {.option}s in the {Formula}. Note that these may differ at different times
-  # during the installation of a {Formula}. This is annoying but the result of
-  # state that we're trying to eliminate.
-  # @return [BuildOptions]
+  # The {BuildOptions} or {Tab} for this {Formula}. Lists the arguments passed
+  # and any {.option}s in the {Formula}. Note that these may differ at
+  # different times during the installation of a {Formula}. This is annoying
+  # but the result of state that we're trying to eliminate.
+  sig { returns(T.any(BuildOptions, Tab)) }
   attr_reader :build
 
   # Whether this formula should be considered outdated
   # if the target of the alias it was installed with has since changed.
   # Defaults to true.
-  # @return [Boolean]
+  sig { returns(T::Boolean) }
   attr_accessor :follow_installed_alias
 
   alias follow_installed_alias? follow_installed_alias
 
   # Whether or not to force the use of a bottle.
-  # @return [Boolean]
-  # @private
+  sig { returns(T::Boolean) }
   attr_accessor :force_bottle
 
-  # @private
-  def initialize(name, path, spec, alias_path: nil, force_bottle: false)
+  sig {
+    params(name: String, path: Pathname, spec: Symbol, alias_path: T.nilable(Pathname),
+           tap: T.nilable(Tap), force_bottle: T::Boolean).void
+  }
+  def initialize(name, path, spec, alias_path: nil, tap: nil, force_bottle: false)
+    # Only allow instances of subclasses. The base class does not hold any spec information (URLs etc).
+    raise "Do not call `Formula.new' directly without a subclass." unless self.class < Formula
+
+    # Stop any subsequent modification of a formula's definition.
+    # Changes do not propagate to existing instances of formulae.
+    # Now that we have an instance, it's too late to make any changes to the class-level definition.
+    self.class.freeze
+
     @name = name
-    @path = path
+    @unresolved_path = path
+    @path = path.resolved_path
     @alias_path = alias_path
     @alias_name = (File.basename(alias_path) if alias_path)
     @revision = self.class.revision || 0
@@ -193,7 +236,8 @@ def initialize(name, path, spec, alias_path: nil, force_bottle: false)
 
     @force_bottle = force_bottle
 
-    @tap = if path == Formulary.core_path(name)
+    @tap = tap
+    @tap ||= if path == Formulary.core_path(name)
       CoreTap.instance
     else
       Tap.from_path(path)
@@ -202,8 +246,9 @@ def initialize(name, path, spec, alias_path: nil, force_bottle: false)
     @full_name = full_name_with_optional_tap(name)
     @full_alias_name = full_name_with_optional_tap(@alias_name)
 
-    spec_eval :stable
-    spec_eval :head
+    self.class.spec_syms.each do |sym|
+      spec_eval sym
+    end
 
     @active_spec = determine_active_spec(spec)
     @active_spec_sym = if head?
@@ -216,10 +261,9 @@ def initialize(name, path, spec, alias_path: nil, force_bottle: false)
     @pin = FormulaPin.new(self)
     @follow_installed_alias = true
     @prefix_returns_versioned_prefix = false
-    @oldname_lock = nil
+    @oldname_locks = []
   end
 
-  # @private
   def active_spec=(spec_sym)
     spec = send(spec_sym)
     raise FormulaSpecificationError, "#{spec_sym} spec is not available for #{full_name}" unless spec
@@ -236,7 +280,6 @@ def active_spec=(spec_sym)
     Requirement.clear_cache
   end
 
-  # @private
   def build=(build_options)
     old_options = @build
     @build = build_options
@@ -250,8 +293,7 @@ def build=(build_options)
 
   private
 
-  # Allow full name logic to be re-used between names, aliases,
-  # and installed aliases.
+  # Allow full name logic to be re-used between names, aliases and installed aliases.
   def full_name_with_optional_tap(name)
     if name.nil? || @tap.nil? || @tap.core_tap?
       name
@@ -265,22 +307,28 @@ def spec_eval(name)
     return unless spec.url
 
     spec.owner = self
-    instance_variable_set("@#{name}", spec)
+    add_global_deps_to_spec(spec)
+    instance_variable_set(:"@#{name}", spec)
   end
 
+  sig { params(spec: SoftwareSpec).void }
+  def add_global_deps_to_spec(spec); end
+
   def determine_active_spec(requested)
     spec = send(requested) || stable || head
-    spec || raise(FormulaSpecificationError, "formulae require at least a URL")
+    spec || raise(FormulaSpecificationError, "#{full_name}: formula requires at least a URL")
   end
 
   def validate_attributes!
-    raise FormulaValidationError.new(full_name, :name, name) if name.blank? || name.match?(/\s/)
+    if name.blank? || name.match?(/\s/) || !Utils.safe_filename?(name)
+      raise FormulaValidationError.new(full_name, :name, name)
+    end
 
     url = active_spec.url
     raise FormulaValidationError.new(full_name, :url, url) if url.blank? || url.match?(/\s/)
 
     val = version.respond_to?(:to_str) ? version.to_str : version
-    return if val.present? && !val.match?(/\s/)
+    return if val.present? && !val.match?(/\s/) && Utils.safe_filename?(val)
 
     raise FormulaValidationError.new(full_name, :version, val)
   end
@@ -290,17 +338,22 @@ def validate_attributes!
   # The alias path that was used to install this formula, if it exists.
   # Can differ from {#alias_path}, which is the alias used to find the formula,
   # and is specified to this instance.
+  sig { returns(T.nilable(Pathname)) }
   def installed_alias_path
-    path = build.source["path"] if build.is_a?(Tab)
+    build_tab = build
+    path = build_tab.source["path"] if build_tab.is_a?(Tab)
+
     return unless path&.match?(%r{#{HOMEBREW_TAP_DIR_REGEX}/Aliases}o)
-    return unless File.symlink?(path)
+
+    path = Pathname(path)
+    return unless path.symlink?
 
     path
   end
 
   sig { returns(T.nilable(String)) }
   def installed_alias_name
-    File.basename(installed_alias_path) if installed_alias_path
+    installed_alias_path&.basename&.to_s
   end
 
   def full_installed_alias_name
@@ -309,13 +362,14 @@ def full_installed_alias_name
 
   # The path that was specified to find this formula.
   def specified_path
-    default_specified_path = Pathname(alias_path) if alias_path.present?
-    default_specified_path ||= path
+    return Homebrew::API::Formula.cached_json_file_path if loaded_from_api?
+    return alias_path if alias_path&.exist?
+
+    return @unresolved_path if @unresolved_path.exist?
 
-    return default_specified_path if default_specified_path.presence&.exist?
     return local_bottle_path if local_bottle_path.presence&.exist?
 
-    default_specified_path
+    alias_path || @unresolved_path
   end
 
   # The name specified to find this formula.
@@ -339,23 +393,24 @@ def full_installed_specified_name
   end
 
   # Is the currently active {SoftwareSpec} a {#stable} build?
-  # @private
+  sig { returns(T::Boolean) }
   def stable?
     active_spec == stable
   end
 
   # Is the currently active {SoftwareSpec} a {#head} build?
-  # @private
+  sig { returns(T::Boolean) }
   def head?
     active_spec == head
   end
 
   # Is this formula HEAD-only?
-  # @private
+  sig { returns(T::Boolean) }
   def head_only?
-    head && !stable
+    !!head && !stable
   end
 
+  # Stop RuboCop from erroneously indenting hash target
   delegate [ # rubocop:disable Layout/HashAlignment
     :bottle_defined?,
     :bottle_tag?,
@@ -365,15 +420,13 @@ def head_only?
   ] => :active_spec
 
   # The Bottle object for the currently active {SoftwareSpec}.
-  # @private
   sig { returns(T.nilable(Bottle)) }
   def bottle
     @bottle ||= Bottle.new(self, bottle_specification) if bottled?
   end
 
   # The Bottle object for given tag.
-  # @private
-  sig { params(tag: T.nilable(Symbol)).returns(T.nilable(Bottle)) }
+  sig { params(tag: T.nilable(Utils::Bottles::Tag)).returns(T.nilable(Bottle)) }
   def bottle_for_tag(tag = nil)
     Bottle.new(self, bottle_specification, tag) if bottled?(tag)
   end
@@ -415,10 +468,25 @@ def bottle_for_tag(tag = nil)
   # @see .version
   delegate version: :active_spec
 
+  # Stop RuboCop from erroneously indenting hash target
+  delegate [ # rubocop:disable Layout/HashAlignment
+    :allow_network_access!,
+    :deny_network_access!,
+    :network_access_allowed?,
+  ] => :"self.class"
+
+  # Whether this formula was loaded using the formulae.brew.sh API
+  # @!method loaded_from_api?
+  # @see .loaded_from_api?
+  delegate loaded_from_api?: :"self.class"
+
+  sig { void }
   def update_head_version
     return unless head?
-    return unless head.downloader.is_a?(VCSDownloadStrategy)
-    return unless head.downloader.cached_location.exist?
+
+    head_spec = T.must(head)
+    return unless head_spec.downloader.is_a?(VCSDownloadStrategy)
+    return unless head_spec.downloader.cached_location.exist?
 
     path = if ENV["HOMEBREW_ENV"]
       ENV.fetch("PATH")
@@ -427,7 +495,7 @@ def update_head_version
     end
 
     with_env(PATH: path) do
-      head.version.update_commit(head.downloader.last_commit)
+      head_spec.version.update_commit(head_spec.downloader.last_commit)
     end
   end
 
@@ -438,59 +506,107 @@ def pkg_version
   end
 
   # If this is a `@`-versioned formula.
+  sig { returns(T::Boolean) }
   def versioned_formula?
     name.include?("@")
   end
 
-  # Returns any `@`-versioned formulae for any formula (including versioned formulae).
-  def versioned_formulae
-    Pathname.glob(path.to_s.gsub(/(@[\d.]+)?\.rb$/, "@*.rb")).map do |versioned_path|
-      next if versioned_path == path
+  # Returns any other `@`-versioned formulae names for any formula (including versioned formulae).
+  sig { returns(T::Array[String]) }
+  def versioned_formulae_names
+    versioned_names = if tap
+      name_prefix = name.gsub(/(@[\d.]+)?$/, "")
+      T.must(tap).prefix_to_versioned_formulae_names.fetch(name_prefix, [])
+    elsif path.exist?
+      Pathname.glob(path.to_s.gsub(/(@[\d.]+)?\.rb$/, "@*.rb"))
+              .map { |path| path.basename(".rb").to_s }
+              .sort
+    else
+      raise "Either tap or path is required to list versioned formulae"
+    end
+
+    versioned_names.reject do |versioned_name|
+      versioned_name == name
+    end
+  end
 
-      Formula[versioned_path.basename(".rb").to_s]
+  # Returns any `@`-versioned Formula objects for any Formula (including versioned formulae).
+  sig { returns(T::Array[Formula]) }
+  def versioned_formulae
+    versioned_formulae_names.filter_map do |name|
+      Formula[name]
     rescue FormulaUnavailableError
       nil
-    end.compact.sort_by(&:version).reverse
+    end.sort_by(&:version).reverse
+  end
+
+  # Whether this {Formula} is version-synced with other formulae.
+  sig { returns(T::Boolean) }
+  def synced_with_other_formulae?
+    return false if @tap.nil?
+
+    @tap.synced_versions_formulae.any? { |synced_formulae| synced_formulae.include?(name) }
   end
 
   # A named {Resource} for the currently active {SoftwareSpec}.
   # Additional downloads can be defined as {#resource}s.
   # {Resource#stage} will create a temporary directory and yield to a block.
-  # <pre>resource("additional_files").stage { bin.install "my/extra/tool" }</pre>
-  # @!method resource
-  delegate resource: :active_spec
-
-  # An old name for the formula.
-  def oldname
-    @oldname ||= if tap
-      formula_renames = tap.formula_renames
-      formula_renames.to_a.rassoc(name).first if formula_renames.value?(name)
+  #
+  # ### Example
+  #
+  # ```ruby
+  # resource("additional_files").stage { bin.install "my/extra/tool" }
+  # ```
+  #
+  # FIXME: This should not actually take a block. All resources should be defined
+  #        at the top-level using {Formula.resource} instead
+  #        (see https://github.com/Homebrew/brew/issues/17203#issuecomment-2093654431).
+  #
+  # @api public
+  sig {
+    params(name: String, klass: T.class_of(Resource), block: T.nilable(T.proc.bind(Resource).void))
+      .returns(T.nilable(Resource))
+  }
+  def resource(name = T.unsafe(nil), klass = T.unsafe(nil), &block)
+    if klass.nil?
+      active_spec.resource(*name, &block)
+    else
+      active_spec.resource(name, klass, &block)
     end
   end
 
-  # All aliases for the formula.
-  def aliases
-    @aliases ||= if tap
-      tap.alias_reverse_table[full_name].to_a.map do |a|
-        a.split("/").last
-      end
+  # Old names for the formula.
+  #
+  # @api internal
+  sig { returns(T::Array[String]) }
+  def oldnames
+    @oldnames ||= if (tap = self.tap)
+      Tap.tap_migration_oldnames(tap, name) +
+        tap.formula_reverse_renames.fetch(name, [])
     else
       []
     end
   end
 
+  # All aliases for the formula.
+  #
+  # @api internal
+  sig { returns(T::Array[String]) }
+  def aliases
+    @aliases ||= tap&.alias_reverse_table&.dig(full_name)&.map { _1.split("/").last } || []
+  end
+
   # The {Resource}s for the currently active {SoftwareSpec}.
   # @!method resources
   def_delegator :"active_spec.resources", :values, :resources
 
   # The {Dependency}s for the currently active {SoftwareSpec}.
+  #
+  # @api internal
   delegate deps: :active_spec
 
-  # Dependencies provided by macOS for the currently active {SoftwareSpec}.
-  delegate uses_from_macos_elements: :active_spec
-
-  # Dependency names provided by macOS for the currently active {SoftwareSpec}.
-  delegate uses_from_macos_names: :active_spec
+  # The declared {Dependency}s for the currently active {SoftwareSpec} (i.e. including those provided by macOS)
+  delegate declared_deps: :active_spec
 
   # The {Requirement}s for the currently active {SoftwareSpec}.
   delegate requirements: :active_spec
@@ -523,20 +639,21 @@ def aliases
   # If this {Formula} is installed.
   # This is actually just a check for if the {#latest_installed_prefix} directory
   # exists and is not empty.
-  # @private
+  sig { returns(T::Boolean) }
   def latest_version_installed?
     (dir = latest_installed_prefix).directory? && !dir.children.empty?
   end
 
   # If at least one version of {Formula} is installed.
-  # @private
+  sig { returns(T::Boolean) }
   def any_version_installed?
-    installed_prefixes.any? { |keg| (keg/Tab::FILENAME).file? }
+    installed_prefixes.any? { |keg| (keg/AbstractTab::FILENAME).file? }
   end
 
-  # @private
   # The link status symlink directory for this {Formula}.
   # You probably want {#opt_prefix} instead.
+  #
+  # @api internal
   def linked_keg
     linked_keg = possible_names.map { |name| HOMEBREW_LINKED_KEGS/name }
                                .find(&:directory?)
@@ -546,13 +663,13 @@ def linked_keg
   end
 
   def latest_head_version
-    head_versions = installed_prefixes.map do |pn|
+    head_versions = installed_prefixes.filter_map do |pn|
       pn_pkgversion = PkgVersion.parse(pn.basename.to_s)
       pn_pkgversion if pn_pkgversion.head?
-    end.compact
+    end
 
     head_versions.max_by do |pn_pkgversion|
-      [Tab.for_keg(prefix(pn_pkgversion)).source_modified_time, pn_pkgversion.revision]
+      [Keg.new(prefix(pn_pkgversion)).tab.source_modified_time, pn_pkgversion.revision]
     end
   end
 
@@ -565,11 +682,11 @@ def head_version_outdated?(version, fetch_head: false)
     tab = Tab.for_keg(prefix(version))
 
     return true if tab.version_scheme < version_scheme
-    return true if stable && tab.stable_version && tab.stable_version < stable.version
+    return true if stable && tab.stable_version && tab.stable_version < T.must(stable).version
     return false unless fetch_head
     return false unless head&.downloader.is_a?(VCSDownloadStrategy)
 
-    downloader = head.downloader
+    downloader = T.must(head).downloader
 
     with_context quiet: true do
       downloader.commit_outdated?(version.version.commit)
@@ -577,11 +694,10 @@ def head_version_outdated?(version, fetch_head: false)
   end
 
   # The latest prefix for this formula. Checks for {#head} and then {#stable}'s {#prefix}
-  # @private
   def latest_installed_prefix
     if head && (head_version = latest_head_version) && !head_version_outdated?(head_version)
       latest_head_prefix
-    elsif stable && (stable_prefix = prefix(PkgVersion.new(stable.version, revision))).directory?
+    elsif stable && (stable_prefix = prefix(PkgVersion.new(T.must(stable).version, revision))).directory?
       stable_prefix
     else
       prefix
@@ -589,12 +705,12 @@ def latest_installed_prefix
   end
 
   # The directory in the cellar that the formula is installed to.
-  # This directory points to {#opt_prefix} if it exists and if #{prefix} is not
+  # This directory points to {#opt_prefix} if it exists and if {#prefix} is not
   # called from within the same formula's {#install} or {#post_install} methods.
   # Otherwise, return the full path to the formula's versioned cellar.
-  def prefix(v = pkg_version)
-    versioned_prefix = versioned_prefix(v)
-    if !@prefix_returns_versioned_prefix && v == pkg_version &&
+  def prefix(version = pkg_version)
+    versioned_prefix = versioned_prefix(version)
+    if !@prefix_returns_versioned_prefix && version == pkg_version &&
        versioned_prefix.directory? && Keg.new(versioned_prefix).optlinked?
       opt_prefix
     else
@@ -603,20 +719,24 @@ def prefix(v = pkg_version)
   end
 
   # Is the formula linked?
+  #
+  # @api internal
+  sig { returns(T::Boolean) }
   def linked?
     linked_keg.symlink?
   end
 
   # Is the formula linked to `opt`?
+  sig { returns(T::Boolean) }
   def optlinked?
     opt_prefix.symlink?
   end
 
   # If a formula's linked keg points to the prefix.
-  def prefix_linked?(v = pkg_version)
+  def prefix_linked?(version = pkg_version)
     return false unless linked?
 
-    linked_keg.resolved_path == versioned_prefix(v)
+    linked_keg.resolved_path == versioned_prefix(version)
   end
 
   # {PkgVersion} of the linked keg for the formula.
@@ -629,14 +749,12 @@ def linked_version
 
   # The parent of the prefix; the named directory in the cellar containing all
   # installed versions of this software.
-  # @private
   sig { returns(Pathname) }
   def rack
     HOMEBREW_CELLAR/name
   end
 
   # All currently installed prefix directories.
-  # @private
   def installed_prefixes
     possible_names.map { |name| HOMEBREW_CELLAR/name }
                   .select(&:directory?)
@@ -645,7 +763,7 @@ def installed_prefixes
   end
 
   # All currently installed kegs.
-  # @private
+  sig { returns(T::Array[Keg]) }
   def installed_kegs
     installed_prefixes.map { |dir| Keg.new(dir) }
   end
@@ -654,11 +772,22 @@ def installed_kegs
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
   #
+  # ### Examples
+  #
   # Need to install into the {.bin} but the makefile doesn't `mkdir -p prefix/bin`?
-  # <pre>bin.mkpath</pre>
+  #
+  # ```ruby
+  # bin.mkpath
+  # ```
   #
   # No `make install` available?
-  # <pre>bin.install "binary1"</pre>
+  #
+  # ```ruby
+  # bin.install "binary1"
+  # ```
+  #
+  # @api public
+  sig { returns(Pathname) }
   def bin
     prefix/"bin"
   end
@@ -666,6 +795,9 @@ def bin
   # The directory where the formula's documentation should be installed.
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def doc
     share/"doc"/name
   end
@@ -674,8 +806,16 @@ def doc
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
   #
+  # ### Example
+  #
   # No `make install` available?
-  # <pre>include.install "example.h"</pre>
+  #
+  # ```ruby
+  # include.install "example.h"
+  # ```
+  #
+  # @api public
+  sig { returns(Pathname) }
   def include
     prefix/"include"
   end
@@ -683,6 +823,9 @@ def include
   # The directory where the formula's info files should be installed.
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def info
     share/"info"
   end
@@ -691,8 +834,16 @@ def info
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
   #
+  # ### Example
+  #
   # No `make install` available?
-  # <pre>lib.install "example.dylib"</pre>
+  #
+  # ```ruby
+  # lib.install "example.dylib"
+  # ```
+  #
+  # @api public
+  sig { returns(Pathname) }
   def lib
     prefix/"lib"
   end
@@ -702,9 +853,16 @@ def lib
   # It is commonly used to install files that we do not wish to be
   # symlinked into `HOMEBREW_PREFIX` from one of the other directories and
   # instead manually create symlinks or wrapper scripts into e.g. {#bin}.
-  # <pre>libexec.install "foo.jar"
+  #
+  # ### Example
+  #
+  # ```ruby
+  # libexec.install "foo.jar"
   # bin.write_jar_script libexec/"foo.jar", "foo"
-  # </pre>
+  # ```
+  #
+  # @api public
+  sig { returns(Pathname) }
   def libexec
     prefix/"libexec"
   end
@@ -714,6 +872,9 @@ def libexec
   # `brew link` for formulae that are not keg-only.
   # Often one of the more specific `man` functions should be used instead,
   # e.g. {#man1}.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def man
     share/"man"
   end
@@ -722,8 +883,16 @@ def man
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
   #
+  # ### Example
+  #
   # No `make install` available?
-  # <pre>man1.install "example.1"</pre>
+  #
+  # ```ruby
+  # man1.install "example.1"
+  # ```
+  #
+  # @api public
+  sig { returns(Pathname) }
   def man1
     man/"man1"
   end
@@ -731,6 +900,9 @@ def man1
   # The directory where the formula's man2 pages should be installed.
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def man2
     man/"man2"
   end
@@ -739,8 +911,16 @@ def man2
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
   #
+  # ### Example
+  #
   # No `make install` available?
-  # <pre>man3.install "man.3"</pre>
+  #
+  # ```ruby
+  # man3.install "man.3"
+  # ```
+  #
+  # @api public
+  sig { returns(Pathname) }
   def man3
     man/"man3"
   end
@@ -748,6 +928,9 @@ def man3
   # The directory where the formula's man4 pages should be installed.
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def man4
     man/"man4"
   end
@@ -755,6 +938,9 @@ def man4
   # The directory where the formula's man5 pages should be installed.
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def man5
     man/"man5"
   end
@@ -762,6 +948,9 @@ def man5
   # The directory where the formula's man6 pages should be installed.
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def man6
     man/"man6"
   end
@@ -769,6 +958,9 @@ def man6
   # The directory where the formula's man7 pages should be installed.
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def man7
     man/"man7"
   end
@@ -776,6 +968,9 @@ def man7
   # The directory where the formula's man8 pages should be installed.
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def man8
     man/"man8"
   end
@@ -784,6 +979,9 @@ def man8
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
   # Generally we try to migrate these to {#bin} instead.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def sbin
     prefix/"sbin"
   end
@@ -792,17 +990,34 @@ def sbin
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
   #
+  # ### Examples
+  #
   # Need a custom directory?
-  # <pre>(share/"concept").mkpath</pre>
+  #
+  # ```ruby
+  # (share/"concept").mkpath
+  # ```
   #
   # Installing something into another custom directory?
-  # <pre>(share/"concept2").install "ducks.txt"</pre>
+  #
+  # ```ruby
+  # (share/"concept2").install "ducks.txt"
+  # ```
   #
   # Install `./example_code/simple/ones` to `share/demos`:
-  # <pre>(share/"demos").install "example_code/simple/ones"</pre>
+  #
+  # ```ruby
+  # (share/"demos").install "example_code/simple/ones"
+  # ```
   #
   # Install `./example_code/simple/ones` to `share/demos/examples`:
-  # <pre>(share/"demos").install "example_code/simple/ones" => "examples"</pre>
+  #
+  # ```ruby
+  # (share/"demos").install "example_code/simple/ones" => "examples"
+  # ```
+  #
+  # @api public
+  sig { returns(Pathname) }
   def share
     prefix/"share"
   end
@@ -812,8 +1027,16 @@ def share
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
   #
+  # ### Example
+  #
   # No `make install` available?
-  # <pre>pkgshare.install "examples"</pre>
+  #
+  # ```ruby
+  # pkgshare.install "examples"
+  # ```
+  #
+  # @api public
+  sig { returns(Pathname) }
   def pkgshare
     prefix/"share"/name
   end
@@ -821,8 +1044,16 @@ def pkgshare
   # The directory where Emacs Lisp files should be installed, with the
   # formula name appended to avoid linking conflicts.
   #
+  # ### Example
+  #
   # To install an Emacs mode included with a software package:
-  # <pre>elisp.install "contrib/emacs/example-mode.el"</pre>
+  #
+  # ```ruby
+  # elisp.install "contrib/emacs/example-mode.el"
+  # ```
+  #
+  # @api public
+  sig { returns(Pathname) }
   def elisp
     prefix/"share/emacs/site-lisp"/name
   end
@@ -831,6 +1062,9 @@ def elisp
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
   # This is not symlinked into `HOMEBREW_PREFIX`.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def frameworks
     prefix/"Frameworks"
   end
@@ -839,6 +1073,9 @@ def frameworks
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
   # This is not symlinked into `HOMEBREW_PREFIX`.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def kext_prefix
     prefix/"Library/Extensions"
   end
@@ -848,6 +1085,9 @@ def kext_prefix
   # but will write a new file named `*.default`.
   # This directory is not inside the `HOMEBREW_CELLAR` so it persists
   # across upgrades.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def etc
     (HOMEBREW_PREFIX/"etc").extend(InstallRenamed)
   end
@@ -856,6 +1096,9 @@ def etc
   # e.g. `$HOMEBREW_PREFIX/etc/openssl@1.1`
   # Anything using `pkgetc.install` will not overwrite other files on
   # e.g. upgrades but will write a new file named `*.default`.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def pkgetc
     (HOMEBREW_PREFIX/"etc"/name).extend(InstallRenamed)
   end
@@ -863,6 +1106,9 @@ def pkgetc
   # The directory where the formula's variable files should be installed.
   # This directory is not inside the `HOMEBREW_CELLAR` so it persists
   # across upgrades.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def var
     HOMEBREW_PREFIX/"var"
   end
@@ -871,6 +1117,9 @@ def var
   # installed.
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def zsh_function
     share/"zsh/site-functions"
   end
@@ -879,6 +1128,9 @@ def zsh_function
   # installed.
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def fish_function
     share/"fish/vendor_functions.d"
   end
@@ -887,6 +1139,9 @@ def fish_function
   # installed.
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def bash_completion
     prefix/"etc/bash_completion.d"
   end
@@ -895,6 +1150,9 @@ def bash_completion
   # installed.
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def zsh_completion
     share/"zsh/site-functions"
   end
@@ -903,6 +1161,9 @@ def zsh_completion
   # installed.
   # This is symlinked into `HOMEBREW_PREFIX` after installation or with
   # `brew link` for formulae that are not keg-only.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def fish_completion
     share/"fish/vendor_completions.d"
   end
@@ -910,13 +1171,13 @@ def fish_completion
   # The directory used for as the prefix for {#etc} and {#var} files on
   # installation so, despite not being in `HOMEBREW_CELLAR`, they are installed
   # there after pouring a bottle.
-  # @private
+  sig { returns(Pathname) }
   def bottle_prefix
     prefix/".bottle"
   end
 
   # The directory where the formula's installation or test logs will be written.
-  # @private
+  sig { returns(Pathname) }
   def logs
     HOMEBREW_LOGS + name
   end
@@ -941,8 +1202,11 @@ def with_logging(log_type)
   end
 
   # This method can be overridden to provide a plist.
-  # @see https://www.unix.com/man-page/all/5/plist/ Apple's plist(5) man page
-  # <pre>def plist; <<~EOS
+  #
+  # ### Example
+  #
+  # ```ruby
+  # def plist; <<~EOS
   #   <?xml version="1.0" encoding="UTF-8"?>
   #   <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
   #   <plist version="1.0">
@@ -965,26 +1229,30 @@ def with_logging(log_type)
   #   </dict>
   #   </plist>
   #   EOS
-  # end</pre>
+  # end
+  # ```
+  #
+  # @see https://www.unix.com/man-page/all/5/plist/ <code>plist(5)</code> man page
   def plist
+    odisabled "`Formula#plist`", "`Homebrew::Service`"
     nil
   end
 
   # The generated launchd {.plist} service name.
   sig { returns(String) }
   def plist_name
-    "homebrew.mxcl.#{name}"
+    service.plist_name
   end
 
   # The generated service name.
   sig { returns(String) }
   def service_name
-    "homebrew.#{name}"
+    service.service_name
   end
 
-  # The generated launchd {.plist} file path.
+  # The generated launchd {.service} file path.
   sig { returns(Pathname) }
-  def plist_path
+  def launchd_service_path
     opt_prefix/"#{plist_name}.plist"
   end
 
@@ -1002,69 +1270,95 @@ def systemd_timer_path
 
   # The service specification of the software.
   def service
-    return unless service?
-
-    Homebrew::Service.new(self, &self.class.service)
+    @service ||= Homebrew::Service.new(self, &self.class.service)
   end
 
-  # @private
-  delegate plist_manual: :"self.class"
-
-  # @private
-  delegate plist_startup: :"self.class"
-
   # A stable path for this formula, when installed. Contains the formula name
   # but no version number. Only the active version will be linked here if
   # multiple versions are installed.
   #
   # This is the preferred way to refer to a formula in plists or from another
   # formula, as the path is stable even when the software is updated.
-  # <pre>args << "--with-readline=#{Formula["readline"].opt_prefix}" if build.with? "readline"</pre>
+  #
+  # ### Example
+  #
+  # ```ruby
+  # args << "--with-readline=#{Formula["readline"].opt_prefix}" if build.with? "readline"
+  # ```
+  #
+  # @api public
   sig { returns(Pathname) }
   def opt_prefix
     HOMEBREW_PREFIX/"opt"/name
   end
 
+  # Same as {#bin}, but relative to {#opt_prefix} instead of {#prefix}.
+  #
+  # @api public
   sig { returns(Pathname) }
   def opt_bin
     opt_prefix/"bin"
   end
 
+  # Same as {#include}, but relative to {#opt_prefix} instead of {#prefix}.
+  #
+  # @api public
   sig { returns(Pathname) }
   def opt_include
     opt_prefix/"include"
   end
 
+  # Same as {#lib}, but relative to {#opt_prefix} instead of {#prefix}.
+  #
+  # @api public
   sig { returns(Pathname) }
   def opt_lib
     opt_prefix/"lib"
   end
 
+  # Same as {#libexec}, but relative to {#opt_prefix} instead of {#prefix}.
+  #
+  # @api public
   sig { returns(Pathname) }
   def opt_libexec
     opt_prefix/"libexec"
   end
 
+  # Same as {#sbin}, but relative to {#opt_prefix} instead of {#prefix}.
+  #
+  # @api public
   sig { returns(Pathname) }
   def opt_sbin
     opt_prefix/"sbin"
   end
 
+  # Same as {#share}, but relative to {#opt_prefix} instead of {#prefix}.
+  #
+  # @api public
   sig { returns(Pathname) }
   def opt_share
     opt_prefix/"share"
   end
 
+  # Same as {#pkgshare}, but relative to {#opt_prefix} instead of {#prefix}.
+  #
+  # @api public
   sig { returns(Pathname) }
   def opt_pkgshare
     opt_prefix/"share"/name
   end
 
+  # Same as {#elisp}, but relative to {#opt_prefix} instead of {#prefix}.
+  #
+  # @api public
   sig { returns(Pathname) }
   def opt_elisp
     opt_prefix/"share/emacs/site-lisp"/name
   end
 
+  # Same as {#frameworks}, but relative to {#opt_prefix} instead of {#prefix}.
+  #
+  # @api public
   sig { returns(Pathname) }
   def opt_frameworks
     opt_prefix/"Frameworks"
@@ -1081,14 +1375,27 @@ def pour_bottle?
     true
   end
 
-  # @private
   delegate pour_bottle_check_unsatisfied_reason: :"self.class"
 
   # Can be overridden to run commands on both source and bottle installation.
   sig { overridable.void }
   def post_install; end
 
-  # @private
+  sig { returns(T::Boolean) }
+  def post_install_defined?
+    method(:post_install).owner != Formula
+  end
+
+  sig { void }
+  def install_etc_var
+    etc_var_dirs = [bottle_prefix/"etc", bottle_prefix/"var"]
+    Find.find(*etc_var_dirs.select(&:directory?)) do |path|
+      path = Pathname.new(path)
+      path.extend(InstallRenamed)
+      path.cp_path_sub(bottle_prefix, HOMEBREW_PREFIX)
+    end
+  end
+
   sig { void }
   def run_post_install
     @prefix_returns_versioned_prefix = true
@@ -1110,13 +1417,6 @@ def run_post_install
         ENV.clear_sensitive_environment!
         ENV.activate_extensions!
 
-        etc_var_dirs = [bottle_prefix/"etc", bottle_prefix/"var"]
-        T.unsafe(Find).find(*etc_var_dirs.select(&:directory?)) do |path|
-          path = Pathname.new(path)
-          path.extend(InstallRenamed)
-          path.cp_path_sub(bottle_prefix, HOMEBREW_PREFIX)
-        end
-
         with_logging("post_install") do
           post_install
         end
@@ -1130,14 +1430,19 @@ def run_post_install
   # Warn the user about any Homebrew-specific issues or quirks for this package.
   # These should not contain setup instructions that would apply to installation
   # through a different package manager on a different OS.
-  # @return [String]
-  # <pre>def caveats
+  #
+  # ### Example
+  #
+  # ```ruby
+  # def caveats
   #   <<~EOS
   #     Are optional. Something the user must be warned about?
   #   EOS
-  # end</pre>
+  # end
+  # ```
   #
-  # <pre>def caveats
+  # ```ruby
+  # def caveats
   #   s = <<~EOS
   #     Print some important notice to the user when `brew info [formula]` is
   #     called or when brewing a formula.
@@ -1145,7 +1450,8 @@ def run_post_install
   #   EOS
   #   s += "Some issue only on older systems" if MacOS.version < :el_capitan
   #   s
-  # end</pre>
+  # end
+  # ```
   sig { overridable.returns(T.nilable(String)) }
   def caveats
     nil
@@ -1154,17 +1460,18 @@ def caveats
   # Rarely, you don't want your library symlinked into the main prefix.
   # See `gettext.rb` for an example.
   # @see .keg_only
+  #
+  # @api internal
+  sig { returns(T::Boolean) }
   def keg_only?
     return false unless keg_only_reason
 
     keg_only_reason.applicable?
   end
 
-  # @private
   delegate keg_only_reason: :"self.class"
 
   # @see .skip_clean
-  # @private
   sig { params(path: Pathname).returns(T::Boolean) }
   def skip_clean?(path)
     return true if path.extname == ".la" && self.class.skip_clean_paths.include?(:la)
@@ -1174,10 +1481,9 @@ def skip_clean?(path)
   end
 
   # @see .link_overwrite
-  # @private
   def link_overwrite?(path)
     # Don't overwrite files not created by Homebrew.
-    return false unless path.stat.uid == HOMEBREW_BREW_FILE.stat.uid
+    return false if path.stat.uid != HOMEBREW_BREW_FILE.stat.uid
 
     # Don't overwrite files belong to other keg except when that
     # keg's formula is deleted.
@@ -1186,7 +1492,7 @@ def link_overwrite?(path)
     rescue NotAKegError, Errno::ENOENT
       # file doesn't belong to any keg.
     else
-      tab_tap = Tab.for_keg(keg).tap
+      tab_tap = keg.tab.tap
       # this keg doesn't below to any core/tap formula, most likely coming from a DIY install.
       return false if tab_tap.nil?
 
@@ -1194,7 +1500,7 @@ def link_overwrite?(path)
         f = Formulary.factory(keg.name)
       rescue FormulaUnavailableError
         # formula for this keg is deleted, so defer to allowlist
-      rescue TapFormulaAmbiguityError, TapFormulaWithOldnameAmbiguityError
+      rescue TapFormulaAmbiguityError
         return false # this keg belongs to another formula
       else
         # this keg belongs to another unrelated formula
@@ -1205,7 +1511,7 @@ def link_overwrite?(path)
     self.class.link_overwrite_paths.any? do |p|
       p == to_check ||
         to_check.start_with?("#{p.chomp("/")}/") ||
-        to_check =~ /^#{Regexp.escape(p).gsub('\*', ".*?")}$/
+        /^#{Regexp.escape(p).gsub('\*', ".*?")}$/.match?(to_check)
     end
   end
 
@@ -1256,13 +1562,11 @@ def skip_cxxstdlib_check?
     false
   end
 
-  # @private
   sig { returns(T::Boolean) }
   def require_universal_deps?
     false
   end
 
-  # @private
   def patch
     return if patchlist.empty?
 
@@ -1272,12 +1576,11 @@ def patch
 
   # Yields |self,staging| with current working directory set to the uncompressed tarball
   # where staging is a {Mktemp} staging context.
-  # @private
-  def brew(fetch: true, keep_tmp: false, interactive: false)
+  def brew(fetch: true, keep_tmp: false, debug_symbols: false, interactive: false)
     @prefix_returns_versioned_prefix = true
     active_spec.fetch if fetch
-    stage(interactive: interactive) do |staging|
-      staging.retain! if keep_tmp
+    stage(interactive:, debug_symbols:) do |staging|
+      staging.retain! if keep_tmp || debug_symbols
 
       prepare_patches
       fetch_patches if fetch
@@ -1291,8 +1594,7 @@ def brew(fetch: true, keep_tmp: false, interactive: false)
         %w[
           config.log
           CMakeCache.txt
-          CMakeOutput.log
-          CMakeError.log
+          CMakeConfigureLog.yaml
           meson-log.txt
         ].each do |logfile|
           Dir["**/#{logfile}"].each do |logpath|
@@ -1307,38 +1609,43 @@ def brew(fetch: true, keep_tmp: false, interactive: false)
     @prefix_returns_versioned_prefix = false
   end
 
-  # @private
   def lock
     @lock = FormulaLock.new(name)
     @lock.lock
-    return unless oldname
-    return unless (oldname_rack = HOMEBREW_CELLAR/oldname).exist?
-    return unless oldname_rack.resolved_path == rack
 
-    @oldname_lock = FormulaLock.new(oldname)
-    @oldname_lock.lock
+    oldnames.each do |oldname|
+      next unless (oldname_rack = HOMEBREW_CELLAR/oldname).exist?
+      next if oldname_rack.resolved_path != rack
+
+      oldname_lock = FormulaLock.new(oldname)
+      oldname_lock.lock
+      @oldname_locks << oldname_lock
+    end
   end
 
-  # @private
   def unlock
     @lock&.unlock
-    @oldname_lock&.unlock
+    @oldname_locks.each(&:unlock)
   end
 
-  def migration_needed?
-    return false unless oldname
-    return false if rack.exist?
+  sig { returns(T::Array[String]) }
+  def oldnames_to_migrate
+    oldnames.select do |oldname|
+      old_rack = HOMEBREW_CELLAR/oldname
+      next false unless old_rack.directory?
+      next false if old_rack.subdirs.empty?
 
-    old_rack = HOMEBREW_CELLAR/oldname
-    return false unless old_rack.directory?
-    return false if old_rack.subdirs.empty?
+      tap == Tab.for_keg(old_rack.subdirs.min).tap
+    end
+  end
 
-    tap == Tab.for_keg(old_rack.subdirs.min).tap
+  sig { returns(T::Boolean) }
+  def migration_needed?
+    !oldnames_to_migrate.empty? && !rack.exist?
   end
 
-  # @private
   def outdated_kegs(fetch_head: false)
-    raise Migrator::MigrationNeededError, self if migration_needed?
+    raise Migrator::MigrationNeededError.new(oldnames_to_migrate.first, name) if migration_needed?
 
     cache_key = "#{full_name}-#{fetch_head}"
     Formula.cache[:outdated_kegs] ||= {}
@@ -1351,9 +1658,8 @@ def outdated_kegs(fetch_head: false)
         version = keg.version
         next if version.head?
 
-        tab = Tab.for_keg(keg)
-        next if version_scheme > tab.version_scheme && pkg_version != version
-        next if version_scheme == tab.version_scheme && pkg_version > version
+        next if version_scheme > keg.version_scheme && pkg_version != version
+        next if version_scheme == keg.version_scheme && pkg_version > version
 
         # don't consider this keg current if there's a newer formula available
         next if follow_installed_alias? && new_formula_available?
@@ -1364,25 +1670,27 @@ def outdated_kegs(fetch_head: false)
       end
 
       if current_version ||
-         ((head_version = latest_head_version) && !head_version_outdated?(head_version, fetch_head: fetch_head))
+         ((head_version = latest_head_version) && !head_version_outdated?(head_version, fetch_head:))
         []
       else
         all_kegs += old_installed_formulae.flat_map(&:installed_kegs)
-        all_kegs.sort_by(&:version)
+        all_kegs.sort_by(&:scheme_and_version)
       end
     end
   end
 
+  sig { returns(T::Boolean) }
   def new_formula_available?
     installed_alias_target_changed? && !latest_formula.latest_version_installed?
   end
 
   def current_installed_alias_target
-    Formulary.factory(installed_alias_path) if installed_alias_path
+    Formulary.factory(T.must(installed_alias_name)) if installed_alias_path
   end
 
   # Has the target of the alias used to install this formula changed?
   # Returns false if the formula wasn't installed with an alias.
+  sig { returns(T::Boolean) }
   def installed_alias_target_changed?
     target = current_installed_alias_target
     return false unless target
@@ -1391,12 +1699,14 @@ def installed_alias_target_changed?
   end
 
   # Is this formula the target of an alias used to install an old formula?
+  sig { returns(T::Boolean) }
   def supersedes_an_installed_formula?
     old_installed_formulae.any?
   end
 
   # Has the alias used to install the formula changed, or are different
   # formulae already installed with this alias?
+  sig { returns(T::Boolean) }
   def alias_changed?
     installed_alias_target_changed? || supersedes_an_installed_formula?
   end
@@ -1416,29 +1726,28 @@ def old_installed_formulae
     self.class.installed_with_alias_path(alias_path).reject { |f| f.name == name }
   end
 
-  # @private
+  # Check whether the installed formula is outdated.
+  #
+  # @api internal
+  sig { params(fetch_head: T::Boolean).returns(T::Boolean) }
   def outdated?(fetch_head: false)
-    !outdated_kegs(fetch_head: fetch_head).empty?
+    !outdated_kegs(fetch_head:).empty?
   rescue Migrator::MigrationNeededError
     true
   end
 
-  # @private
   delegate pinnable?: :@pin
 
-  # @private
+  # !attr[r] pinned?
+  # @api internal
   delegate pinned?: :@pin
 
-  # @private
   delegate pinned_version: :@pin
 
-  # @private
   delegate pin: :@pin
 
-  # @private
   delegate unpin: :@pin
 
-  # @private
   def ==(other)
     self.class == other.class &&
       name == other.name &&
@@ -1446,43 +1755,47 @@ def ==(other)
   end
   alias eql? ==
 
-  # @private
   def hash
     name.hash
   end
 
-  # @private
   def <=>(other)
     return unless other.is_a?(Formula)
 
     name <=> other.name
   end
 
-  # @private
   def possible_names
-    [name, oldname, *aliases].compact
+    [name, *oldnames, *aliases].compact
   end
 
-  def to_s
-    name
-  end
+  # @api public
+  sig { returns(String) }
+  def to_s = name
 
-  # @private
   sig { returns(String) }
   def inspect
     "#<Formula #{name} (#{active_spec_sym}) #{path}>"
   end
 
-  # Standard parameters for configure builds.
+  # Standard parameters for cabal-v2 builds.
   sig { returns(T::Array[String]) }
-  def std_configure_args
-    ["--disable-debug", "--disable-dependency-tracking", "--prefix=#{prefix}", "--libdir=#{lib}"]
+  def std_cabal_v2_args
+    # cabal-install's dependency-resolution backtracking strategy can
+    # easily need more than the default 2,000 maximum number of
+    # "backjumps," since Hackage is a fast-moving, rolling-release
+    # target. The highest known needed value by a formula was 43,478
+    # for git-annex, so 100,000 should be enough to avoid most
+    # gratuitous backjumps build failures.
+    ["--jobs=#{ENV.make_jobs}", "--max-backjumps=100000", "--install-method=copy", "--installdir=#{bin}"]
   end
 
   # Standard parameters for cargo builds.
-  sig { params(root: T.any(String, Pathname), path: String).returns(T::Array[T.any(String, Pathname)]) }
+  sig {
+    params(root: T.any(String, Pathname), path: T.any(String, Pathname)).returns(T::Array[String])
+  }
   def std_cargo_args(root: prefix, path: ".")
-    ["--locked", "--root", root, "--path", path]
+    ["--jobs", ENV.make_jobs.to_s, "--locked", "--root=#{root}", "--path=#{path}"]
   end
 
   # Standard parameters for CMake builds.
@@ -1493,62 +1806,78 @@ def std_cargo_args(root: prefix, path: ".")
   sig {
     params(
       install_prefix: T.any(String, Pathname),
-      install_libdir: String,
+      install_libdir: T.any(String, Pathname),
       find_framework: String,
     ).returns(T::Array[String])
   }
   def std_cmake_args(install_prefix: prefix, install_libdir: "lib", find_framework: "LAST")
-    args = %W[
+    %W[
       -DCMAKE_INSTALL_PREFIX=#{install_prefix}
       -DCMAKE_INSTALL_LIBDIR=#{install_libdir}
       -DCMAKE_BUILD_TYPE=Release
       -DCMAKE_FIND_FRAMEWORK=#{find_framework}
       -DCMAKE_VERBOSE_MAKEFILE=ON
+      -DCMAKE_PROJECT_TOP_LEVEL_INCLUDES=#{HOMEBREW_LIBRARY_PATH}/cmake/trap_fetchcontent_provider.cmake
       -Wno-dev
       -DBUILD_TESTING=OFF
     ]
+  end
 
-    # Avoid false positives for clock_gettime support on 10.11.
-    # CMake cache entries for other weak symbols may be added here as needed.
-    args << "-DHAVE_CLOCK_GETTIME:INTERNAL=0" if MacOS.version == "10.11" && MacOS::Xcode.version >= "8.0"
-
-    # Ensure CMake is using the same SDK we are using.
-    args << "-DCMAKE_OSX_SYSROOT=#{MacOS.sdk_for_formula(self).path}" if MacOS.sdk_root_needed?
-
-    args
+  # Standard parameters for configure builds.
+  sig {
+    params(
+      prefix: T.any(String, Pathname),
+      libdir: T.any(String, Pathname),
+    ).returns(T::Array[String])
+  }
+  def std_configure_args(prefix: self.prefix, libdir: "lib")
+    libdir = Pathname(libdir).expand_path(prefix)
+    ["--disable-debug", "--disable-dependency-tracking", "--prefix=#{prefix}", "--libdir=#{libdir}"]
   end
 
   # Standard parameters for Go builds.
   sig {
-    params(output:  T.any(String, Pathname),
-           ldflags: T.nilable(T.any(String, T::Array[String]))).returns(T::Array[String])
+    params(
+      output:  T.any(String, Pathname),
+      ldflags: T.nilable(T.any(String, T::Array[String])),
+      gcflags: T.nilable(T.any(String, T::Array[String])),
+    ).returns(T::Array[String])
   }
-  def std_go_args(output: bin/name, ldflags: nil)
+  def std_go_args(output: bin/name, ldflags: nil, gcflags: nil)
     args = ["-trimpath", "-o=#{output}"]
     args += ["-ldflags=#{Array(ldflags).join(" ")}"] if ldflags
+    args += ["-gcflags=#{Array(gcflags).join(" ")}"] if gcflags
     args
   end
 
-  # Standard parameters for cabal-v2 builds.
-  sig { returns(T::Array[String]) }
-  def std_cabal_v2_args
-    env = T.cast(ENV, T.any(Stdenv, Superenv))
-
-    # cabal-install's dependency-resolution backtracking strategy can
-    # easily need more than the default 2,000 maximum number of
-    # "backjumps," since Hackage is a fast-moving, rolling-release
-    # target. The highest known needed value by a formula was 43,478
-    # for git-annex, so 100,000 should be enough to avoid most
-    # gratuitous backjumps build failures.
-    ["--jobs=#{env.make_jobs}", "--max-backjumps=100000", "--install-method=copy", "--installdir=#{bin}"]
-  end
-
   # Standard parameters for meson builds.
   sig { returns(T::Array[String]) }
   def std_meson_args
     ["--prefix=#{prefix}", "--libdir=#{lib}", "--buildtype=release", "--wrap-mode=nofallback"]
   end
 
+  # Standard parameters for npm builds.
+  sig { params(prefix: T.any(String, Pathname, FalseClass)).returns(T::Array[String]) }
+  def std_npm_args(prefix: libexec)
+    require "language/node"
+
+    return Language::Node.std_npm_install_args(Pathname(prefix)) if prefix
+
+    Language::Node.local_npm_install_args
+  end
+
+  # Standard parameters for pip builds.
+  sig {
+    params(prefix:          T.any(String, Pathname, FalseClass),
+           build_isolation: T::Boolean).returns(T::Array[String])
+  }
+  def std_pip_args(prefix: self.prefix, build_isolation: false)
+    args = ["--verbose", "--no-deps", "--no-binary=:all:", "--ignore-installed", "--no-compile"]
+    args << "--prefix=#{prefix}" if prefix
+    args << "--no-build-isolation" unless build_isolation
+    args
+  end
+
   # Shared library names according to platform conventions.
   #
   # Optionally specify a `version` to restrict the shared library to a specific
@@ -1556,12 +1885,14 @@ def std_meson_args
   #
   # If `name` is specified as "*", match any shared library of any version.
   #
-  # <pre>
+  # ### Example
+  #
+  # ```ruby
   # shared_library("foo")      #=> foo.dylib
   # shared_library("foo", 1)   #=> foo.1.dylib
   # shared_library("foo", "*") #=> foo.2.dylib, foo.1.dylib, foo.dylib
   # shared_library("*")        #=> foo.dylib, bar.dylib
-  # </pre>
+  # ```
   sig { params(name: String, version: T.nilable(T.any(String, Integer))).returns(String) }
   def shared_library(name, version = nil)
     return "*.dylib" if name == "*" && (version.blank? || version == "*")
@@ -1575,14 +1906,34 @@ def shared_library(name, version = nil)
   end
 
   # Executable/Library RPATH according to platform conventions.
-  sig { returns(String) }
-  def rpath
-    "@loader_path/../lib"
-  end
-
-  # Creates a new `Time` object for use in the formula as the build time.
   #
-  # @see https://www.rubydoc.info/stdlib/time/Time Time
+  # Optionally specify a `source` or `target` depending on the location
+  # of the file containing the RPATH command and where its target is located.
+  #
+  # ### Example
+  #
+  # ```ruby
+  # rpath #=> "@loader_path/../lib"
+  # rpath(target: frameworks) #=> "@loader_path/../Frameworks"
+  # rpath(source: libexec/"bin") #=> "@loader_path/../../lib"
+  # ```
+  sig { params(source: Pathname, target: Pathname).returns(String) }
+  def rpath(source: bin, target: lib)
+    unless target.to_s.start_with?(HOMEBREW_PREFIX)
+      raise "rpath `target` should only be used for paths inside HOMEBREW_PREFIX!"
+    end
+
+    "#{loader_path}/#{target.relative_path_from(source)}"
+  end
+
+  sig { returns(String) }
+  def loader_path
+    "@loader_path"
+  end
+
+  # Creates a new `Time` object for use in the formula as the build time.
+  #
+  # @see https://www.rubydoc.info/stdlib/time/Time Time
   sig { returns(Time) }
   def time
     if ENV["SOURCE_DATE_EPOCH"].present?
@@ -1598,15 +1949,17 @@ def time
   # universal binaries in a {Formula}'s {Keg}.
   sig { params(targets: T.nilable(T.any(Pathname, String))).void }
   def deuniversalize_machos(*targets)
-    targets = nil if targets.blank?
-    targets ||= any_installed_keg.mach_o_files.select do |file|
-      file.arch == :universal && file.archs.include?(Hardware::CPU.arch)
+    if targets.none?
+      targets = any_installed_keg&.mach_o_files&.select do |file|
+        file.arch == :universal && file.archs.include?(Hardware::CPU.arch)
+      end
     end
 
-    targets.each { |t| extract_macho_slice_from(Pathname.new(t), Hardware::CPU.arch) }
+    targets&.each do |target|
+      extract_macho_slice_from(Pathname(target), Hardware::CPU.arch)
+    end
   end
 
-  # @private
   sig { params(file: Pathname, arch: T.nilable(Symbol)).void }
   def extract_macho_slice_from(file, arch = Hardware::CPU.arch)
     odebug "Extracting #{arch} slice from #{file}"
@@ -1625,67 +1978,183 @@ def extract_macho_slice_from(file, arch = Hardware::CPU.arch)
   end
   private :extract_macho_slice_from
 
+  # Generate shell completions for a formula for `bash`, `zsh` and `fish`, using the formula's executable.
+  #
+  # ### Examples
+  #
+  # Using default values for optional arguments.
+  #
+  # ```ruby
+  # generate_completions_from_executable(bin/"foo", "completions")
+  #
+  # # translates to
+  # (bash_completion/"foo").write Utils.safe_popen_read({ "SHELL" => "bash" }, bin/"foo", "completions", "bash")
+  # (zsh_completion/"_foo").write Utils.safe_popen_read({ "SHELL" => "zsh" }, bin/"foo", "completions", "zsh")
+  # (fish_completion/"foo.fish").write Utils.safe_popen_read({ "SHELL" => "fish" }, bin/"foo",
+  #                                                          "completions", "fish")
+  # ```
+  #
+  # Selecting shells and using a different `base_name`.
+  #
+  # ```ruby
+  # generate_completions_from_executable(bin/"foo", "completions", shells: [:bash, :zsh], base_name: "bar")
+  #
+  # # translates to
+  # (bash_completion/"bar").write Utils.safe_popen_read({ "SHELL" => "bash" }, bin/"foo", "completions", "bash")
+  # (zsh_completion/"_bar").write Utils.safe_popen_read({ "SHELL" => "zsh" }, bin/"foo", "completions", "zsh")
+  # ```
+  #
+  # Using predefined `shell_parameter_format :flag`.
+  #
+  # ```ruby
+  # generate_completions_from_executable(bin/"foo", "completions", shell_parameter_format: :flag, shells: [:bash])
+  #
+  # # translates to
+  # (bash_completion/"foo").write Utils.safe_popen_read({ "SHELL" => "bash" }, bin/"foo", "completions", "--bash")
+  # ```
+  #
+  # Using predefined `shell_parameter_format :arg`.
+  #
+  # ```ruby
+  # generate_completions_from_executable(bin/"foo", "completions", shell_parameter_format: :arg, shells: [:bash])
+  #
+  # # translates to
+  # (bash_completion/"foo").write Utils.safe_popen_read({ "SHELL" => "bash" }, bin/"foo",
+  #                                                     "completions", "--shell=bash")
+  # ```
+  #
+  # Using predefined `shell_parameter_format :none`.
+  #
+  # ```ruby
+  # generate_completions_from_executable(bin/"foo", "completions", shell_parameter_format: :none, shells: [:bash])
+  #
+  # # translates to
+  # (bash_completion/"foo").write Utils.safe_popen_read({ "SHELL" => "bash" }, bin/"foo", "completions")
+  # ```
+  #
+  # Using predefined `shell_parameter_format :click`.
+  #
+  # ```ruby
+  # generate_completions_from_executable(bin/"foo", shell_parameter_format: :click, shells: [:zsh])
+  #
+  # # translates to
+  # (zsh_completion/"_foo").write Utils.safe_popen_read({ "SHELL" => "zsh", "_FOO_COMPLETE" => "zsh_source" },
+  #                                                     bin/"foo")
+  # ```
+  #
+  # Using custom `shell_parameter_format`.
+  #
+  # ```ruby
+  # generate_completions_from_executable(bin/"foo", "completions", shell_parameter_format: "--selected-shell=",
+  #                                      shells: [:bash])
+  #
+  # # translates to
+  # (bash_completion/"foo").write Utils.safe_popen_read({ "SHELL" => "bash" }, bin/"foo",
+  #                                                     "completions", "--selected-shell=bash")
+  # ```
+  #
+  # @param commands [Pathname, String]
+  #   the path to the executable and any passed subcommand(s) to use for generating the completion scripts.
+  # @param base_name [String]
+  #   the base name of the generated completion script. Defaults to the formula name.
+  # @param shells [Array<Symbol>]
+  #   the shells to generate completion scripts for. Defaults to `[:bash, :zsh, :fish]`.
+  # @param shell_parameter_format [String, Symbol]
+  #   specify how `shells` should each be passed to the `executable`. Takes either a String representing a
+  #   prefix, or one of `[:flag, :arg, :none, :click]`. Defaults to plainly passing the shell.
+  sig {
+    params(
+      commands: T.any(Pathname, String),
+      base_name: String, shells: T::Array[Symbol],
+      shell_parameter_format: T.nilable(T.any(Symbol, String))
+    ).void
+  }
+  def generate_completions_from_executable(*commands,
+                                           base_name: name,
+                                           shells: [:bash, :zsh, :fish],
+                                           shell_parameter_format: nil)
+    completion_script_path_map = {
+      bash: bash_completion/base_name,
+      zsh:  zsh_completion/"_#{base_name}",
+      fish: fish_completion/"#{base_name}.fish",
+    }
+
+    shells.each do |shell|
+      popen_read_env = { "SHELL" => shell.to_s }
+      script_path = completion_script_path_map[shell]
+      shell_parameter = if shell_parameter_format.nil?
+        shell.to_s
+      elsif shell_parameter_format == :flag
+        "--#{shell}"
+      elsif shell_parameter_format == :arg
+        "--shell=#{shell}"
+      elsif shell_parameter_format == :none
+        nil
+      elsif shell_parameter_format == :click
+        prog_name = File.basename(commands.first.to_s).upcase.tr("-", "_")
+        popen_read_env["_#{prog_name}_COMPLETE"] = "#{shell}_source"
+        nil
+      else
+        "#{shell_parameter_format}#{shell}"
+      end
+
+      popen_read_args = %w[]
+      popen_read_args << commands
+      popen_read_args << shell_parameter if shell_parameter.present?
+      popen_read_args.flatten!
+
+      popen_read_options = {}
+      popen_read_options[:err] = :err unless ENV["HOMEBREW_STDERR"]
+
+      script_path.dirname.mkpath
+      script_path.write Utils.safe_popen_read(popen_read_env, *popen_read_args, **popen_read_options)
+    end
+  end
+
   # an array of all core {Formula} names
-  # @private
   def self.core_names
     CoreTap.instance.formula_names
   end
 
-  # an array of all core {Formula} files
-  # @private
-  def self.core_files
-    CoreTap.instance.formula_files
-  end
-
   # an array of all tap {Formula} names
-  # @private
   def self.tap_names
     @tap_names ||= Tap.reject(&:core_tap?).flat_map(&:formula_names).sort
   end
 
   # an array of all tap {Formula} files
-  # @private
   def self.tap_files
     @tap_files ||= Tap.reject(&:core_tap?).flat_map(&:formula_files)
   end
 
   # an array of all {Formula} names
-  # @private
   def self.names
     @names ||= (core_names + tap_names.map { |name| name.split("/").last }).uniq.sort
   end
 
-  # an array of all {Formula} files
-  # @private
-  def self.files
-    @files ||= core_files + tap_files
-  end
-
   # an array of all {Formula} names, which the tap formulae have the fully-qualified name
-  # @private
   def self.full_names
     @full_names ||= core_names + tap_names
   end
 
   # an array of all {Formula}
   # this should only be used when users specify `--all` to a command
-  # @private
-  def self.all
-    # TODO: 3.6.0: consider checking ARGV for --all
+  def self.all(eval_all: false)
+    if !eval_all && !Homebrew::EnvConfig.eval_all?
+      raise ArgumentError, "Formula#all without `--eval-all` or HOMEBREW_EVAL_ALL"
+    end
 
-    files.map do |file|
-      Formulary.factory(file)
+    (core_names + tap_files).filter_map do |name_or_file|
+      Formulary.factory(name_or_file)
     rescue FormulaUnavailableError, FormulaUnreadableError => e
       # Don't let one broken formula break commands. But do complain.
-      onoe "Failed to import: #{file}"
+      onoe "Failed to import: #{name_or_file}"
       $stderr.puts e
 
       nil
-    end.compact
+    end
   end
 
   # An array of all racks currently installed.
-  # @private
   def self.racks
     Formula.cache[:racks] ||= if HOMEBREW_CELLAR.directory?
       HOMEBREW_CELLAR.subdirs.reject do |rack|
@@ -1696,8 +2165,13 @@ def self.racks
     end
   end
 
+  # An array of all currently installed formula names.
+  sig { returns(T::Array[String]) }
+  def self.installed_formula_names
+    racks.map { |rack| rack.basename.to_s }
+  end
+
   # An array of all installed {Formula}
-  # @private
   def self.installed
     Formula.cache[:installed] ||= racks.flat_map do |rack|
       Formulary.from_rack(rack)
@@ -1706,14 +2180,6 @@ def self.installed
     end.uniq(&:name)
   end
 
-  # An array of all installed {Formula} without dependents
-  # @private
-  def self.installed_formulae_with_no_dependents(formulae = installed)
-    return [] if formulae.blank?
-
-    formulae - formulae.flat_map(&:runtime_formula_dependencies)
-  end
-
   def self.installed_with_alias_path(alias_path)
     return [] if alias_path.nil?
 
@@ -1721,49 +2187,31 @@ def self.installed_with_alias_path(alias_path)
   end
 
   # an array of all alias files of core {Formula}
-  # @private
   def self.core_alias_files
     CoreTap.instance.alias_files
   end
 
   # an array of all core aliases
-  # @private
   def self.core_aliases
     CoreTap.instance.aliases
   end
 
   # an array of all tap aliases
-  # @private
   def self.tap_aliases
     @tap_aliases ||= Tap.reject(&:core_tap?).flat_map(&:aliases).sort
   end
 
   # an array of all aliases
-  # @private
   def self.aliases
     @aliases ||= (core_aliases + tap_aliases.map { |name| name.split("/").last }).uniq.sort
   end
 
   # an array of all aliases as fully-qualified names
-  # @private
   def self.alias_full_names
     @alias_full_names ||= core_aliases + tap_aliases
   end
 
-  # a table mapping core alias to formula name
-  # @private
-  def self.core_alias_table
-    CoreTap.instance.alias_table
-  end
-
-  # a table mapping core formula name to aliases
-  # @private
-  def self.core_alias_reverse_table
-    CoreTap.instance.alias_reverse_table
-  end
-
   # Returns a list of approximately matching formula names, but not the complete match
-  # @private
   def self.fuzzy_search(name)
     @spell_checker ||= DidYouMean::SpellChecker.new(dictionary: Set.new(names + full_names).to_a)
     @spell_checker.correct(name)
@@ -1774,20 +2222,26 @@ def self.[](name)
   end
 
   # True if this formula is provided by Homebrew itself
-  # @private
+  sig { returns(T::Boolean) }
   def core_formula?
-    tap&.core_tap?
+    !!tap&.core_tap?
   end
 
   # True if this formula is provided by external Tap
-  # @private
+  sig { returns(T::Boolean) }
   def tap?
     return false unless tap
 
-    !tap.core_tap?
+    !T.must(tap).core_tap?
+  end
+
+  # True if this formula can be installed on this platform
+  # Redefined in extend/os.
+  sig { returns(T::Boolean) }
+  def valid_platform?
+    requirements.none?(MacOSRequirement) && requirements.none?(LinuxRequirement)
   end
 
-  # @private
   def print_tap_action(options = {})
     return unless tap?
 
@@ -1795,30 +2249,39 @@ def print_tap_action(options = {})
     ohai "#{verb} #{name} from #{tap}"
   end
 
-  # @private
+  def tap_git_head
+    tap&.git_head
+  rescue TapUnavailableError
+    nil
+  end
+
   delegate env: :"self.class"
 
-  # @private
-  delegate conflicts: :"self.class"
+  # !attr[r] conflicts
+  # @api internal
+  sig { returns(T::Array[FormulaConflict]) }
+  def conflicts = self.class.conflicts
 
   # Returns a list of Dependency objects in an installable order, which
   # means if a depends on b then b will be ordered before a in this list
-  # @private
+  #
+  # @api internal
   def recursive_dependencies(&block)
     cache_key = "Formula#recursive_dependencies" unless block
-    Dependency.expand(self, cache_key: cache_key, &block)
+    Dependency.expand(self, cache_key:, &block)
   end
 
   # The full set of Requirements for this formula's dependency tree.
-  # @private
+  #
+  # @api internal
   def recursive_requirements(&block)
     cache_key = "Formula#recursive_requirements" unless block
-    Requirement.expand(self, cache_key: cache_key, &block)
+    Requirement.expand(self, cache_key:, &block)
   end
 
   # Returns a Keg for the opt_prefix or installed_prefix if they exist.
   # If not, return `nil`.
-  # @private
+  sig { returns(T.nilable(Keg)) }
   def any_installed_keg
     Formula.cache[:any_installed_keg] ||= {}
     Formula.cache[:any_installed_keg][full_name] ||= if (installed_prefix = any_installed_prefix)
@@ -1826,6 +2289,10 @@ def any_installed_keg
     end
   end
 
+  # Get the path of any installed prefix.
+  #
+  # @api internal
+  sig { returns(T.nilable(Pathname)) }
   def any_installed_prefix
     if optlinked? && opt_prefix.exist?
       opt_prefix
@@ -1841,16 +2308,17 @@ def any_installed_version
   end
 
   # Returns a list of Dependency objects that are required at runtime.
-  # @private
+  #
+  # @api internal
   def runtime_dependencies(read_from_tab: true, undeclared: true)
     deps = if read_from_tab && undeclared &&
               (tab_deps = any_installed_keg&.runtime_dependencies)
-      tab_deps.map do |d|
+      tab_deps.filter_map do |d|
         full_name = d["full_name"]
         next unless full_name
 
         Dependency.new full_name
-      end.compact
+      end
     end
     begin
       deps ||= declared_runtime_dependencies unless undeclared
@@ -1863,26 +2331,25 @@ def runtime_dependencies(read_from_tab: true, undeclared: true)
   end
 
   # Returns a list of {Formula} objects that are required at runtime.
-  # @private
   def runtime_formula_dependencies(read_from_tab: true, undeclared: true)
     cache_key = "#{full_name}-#{read_from_tab}-#{undeclared}"
 
     Formula.cache[:runtime_formula_dependencies] ||= {}
     Formula.cache[:runtime_formula_dependencies][cache_key] ||= runtime_dependencies(
-      read_from_tab: read_from_tab,
-      undeclared:    undeclared,
-    ).map do |d|
+      read_from_tab:,
+      undeclared:,
+    ).filter_map do |d|
       d.to_formula
     rescue FormulaUnavailableError
       nil
-    end.compact
+    end
   end
 
   def runtime_installed_formula_dependents
     # `any_installed_keg` and `runtime_dependencies` `select`s ensure
     # that we don't end up with something `Formula#runtime_dependencies` can't
     # read from a `Tab`.
-    Formula.cache[:runtime_installed_formula_dependents] = {}
+    Formula.cache[:runtime_installed_formula_dependents] ||= {}
     Formula.cache[:runtime_installed_formula_dependents][full_name] ||= Formula.installed
                                                                                .select(&:any_installed_keg)
                                                                                .select(&:runtime_dependencies)
@@ -1908,15 +2375,37 @@ def missing_dependencies(hide: nil)
     []
   end
 
-  # @private
-  def to_hash
-    dependencies = deps
+  sig { returns(T.nilable(String)) }
+  def ruby_source_path
+    path.relative_path_from(T.must(tap).path).to_s if tap && path.exist?
+  end
+
+  sig { returns(T.nilable(Checksum)) }
+  def ruby_source_checksum
+    Checksum.new(Digest::SHA256.file(path).hexdigest) if path.exist?
+  end
+
+  def merge_spec_dependables(dependables)
+    # We have a hash of specs names (stable/head) to dependency lists.
+    # Merge all of the dependency lists together, removing any duplicates.
+    all_dependables = [].union(*dependables.values.map(&:to_a))
+
+    all_dependables.map do |dependable|
+      {
+        dependable:,
+        # Now find the list of specs each dependency was a part of.
+        specs:      dependables.filter_map { |spec, spec_deps| spec if spec_deps&.include?(dependable) },
+      }
+    end
+  end
+  private :merge_spec_dependables
 
+  def to_hash
     hsh = {
       "name"                     => name,
       "full_name"                => full_name,
       "tap"                      => tap&.name,
-      "oldname"                  => oldname,
+      "oldnames"                 => oldnames,
       "aliases"                  => aliases.sort,
       "versioned_formulae"       => versioned_formulae.map(&:name),
       "desc"                     => desc,
@@ -1925,34 +2414,29 @@ def to_hash
       "versions"                 => {
         "stable" => stable&.version&.to_s,
         "head"   => head&.version&.to_s,
-        "bottle" => !bottle_specification.checksums.empty?,
+        "bottle" => bottle_defined?,
       },
-      "urls"                     => {},
+      "urls"                     => urls_hash,
       "revision"                 => revision,
       "version_scheme"           => version_scheme,
       "bottle"                   => {},
+      "pour_bottle_only_if"      => self.class.pour_bottle_only_if&.to_s,
       "keg_only"                 => keg_only?,
       "keg_only_reason"          => keg_only_reason&.to_hash,
       "options"                  => [],
-      "build_dependencies"       => dependencies.select(&:build?)
-                                                .map(&:name)
-                                                .uniq,
-      "dependencies"             => dependencies.reject(&:optional?)
-                                                .reject(&:recommended?)
-                                                .reject(&:build?)
-                                                .map(&:name)
-                                                .uniq,
-      "recommended_dependencies" => dependencies.select(&:recommended?)
-                                                .map(&:name)
-                                                .uniq,
-      "optional_dependencies"    => dependencies.select(&:optional?)
-                                                .map(&:name)
-                                                .uniq,
-      "uses_from_macos"          => uses_from_macos_elements.uniq,
-      "requirements"             => [],
+      "build_dependencies"       => [],
+      "dependencies"             => [],
+      "test_dependencies"        => [],
+      "recommended_dependencies" => [],
+      "optional_dependencies"    => [],
+      "uses_from_macos"          => [],
+      "uses_from_macos_bounds"   => [],
+      "requirements"             => serialized_requirements,
       "conflicts_with"           => conflicts.map(&:name),
-      "caveats"                  => caveats&.gsub(HOMEBREW_PREFIX, "$(brew --prefix)"),
-      "installed"                => [],
+      "conflicts_with_reasons"   => conflicts.map(&:reason),
+      "link_overwrite"           => self.class.link_overwrite_paths.to_a,
+      "caveats"                  => caveats_with_placeholders,
+      "installed"                => T.let([], T::Array[T::Hash[String, T.untyped]]),
       "linked_keg"               => linked_version&.to_s,
       "pinned"                   => pinned?,
       "outdated"                 => outdated?,
@@ -1962,73 +2446,146 @@ def to_hash
       "disabled"                 => disabled?,
       "disable_date"             => disable_date,
       "disable_reason"           => disable_reason,
+      "post_install_defined"     => post_install_defined?,
+      "service"                  => (service.to_hash if service?),
+      "tap_git_head"             => tap_git_head,
+      "ruby_source_path"         => ruby_source_path,
+      "ruby_source_checksum"     => {},
     }
 
-    if stable
-      hsh["urls"]["stable"] = {
-        "url"      => stable.url,
-        "tag"      => stable.specs[:tag],
-        "revision" => stable.specs[:revision],
-      }
-
-      hsh["bottle"]["stable"] = bottle_hash if bottle_defined?
-    end
+    hsh["bottle"]["stable"] = bottle_hash if stable && bottle_defined?
 
     hsh["options"] = options.map do |opt|
       { "option" => opt.flag, "description" => opt.description }
     end
 
-    hsh["requirements"] = requirements.map do |req|
-      req.name.prepend("maximum_") if req.try(:comparator) == "<="
-      {
-        "name"     => req.name,
-        "cask"     => req.cask,
-        "download" => req.download,
-        "version"  => req.try(:version) || req.try(:arch),
-        "contexts" => req.tags,
-      }
-    end
+    hsh.merge!(dependencies_hash)
 
-    hsh["installed"] = installed_kegs.sort_by(&:version).map do |keg|
-      tab = Tab.for_keg keg
+    hsh["installed"] = installed_kegs.sort_by(&:scheme_and_version).map do |keg|
+      tab = keg.tab
       {
         "version"                 => keg.version.to_s,
         "used_options"            => tab.used_options.as_flags,
         "built_as_bottle"         => tab.built_as_bottle,
         "poured_from_bottle"      => tab.poured_from_bottle,
+        "time"                    => tab.time,
         "runtime_dependencies"    => tab.runtime_dependencies,
         "installed_as_dependency" => tab.installed_as_dependency,
         "installed_on_request"    => tab.installed_on_request,
       }
     end
 
+    if (source_checksum = ruby_source_checksum)
+      hsh["ruby_source_checksum"] = {
+        "sha256" => source_checksum.hexdigest,
+      }
+    end
+
     hsh
   end
 
-  # @private
-  def to_hash_with_variations
-    hash = to_hash
-    variations = {}
+  def to_internal_api_hash
+    api_hash = {
+      "desc"                 => desc,
+      "license"              => SPDX.license_expression_to_string(license),
+      "homepage"             => homepage,
+      "urls"                 => urls_hash.transform_values(&:compact),
+      "post_install_defined" => post_install_defined?,
+      "ruby_source_path"     => ruby_source_path,
+      "ruby_source_sha256"   => ruby_source_checksum&.hexdigest,
+    }
 
-    os_versions = [*MacOSVersions::SYMBOLS.keys, :linux]
+    # Exclude default values.
+    api_hash["revision"] = revision unless revision.zero?
+    api_hash["version_scheme"] = version_scheme unless version_scheme.zero?
 
-    if path.exist? && self.class.on_system_blocks_exist?
-      formula_contents = path.read
-      [:arm, :intel].each do |arch|
-        os_versions.each do |os_name|
-          bottle_tag = Utils::Bottles::Tag.new(system: os_name, arch: arch)
-          next unless bottle_tag.valid_combination?
+    # Optional values.
+    api_hash["keg_only_reason"] = keg_only_reason.to_hash if keg_only_reason
+    api_hash["pour_bottle_only_if"] = self.class.pour_bottle_only_if.to_s if self.class.pour_bottle_only_if
+    api_hash["link_overwrite"] = self.class.link_overwrite_paths.to_a if self.class.link_overwrite_paths.present?
+    api_hash["caveats"] = caveats_with_placeholders if caveats
+    api_hash["service"] = service.to_hash if service?
+
+    if stable
+      api_hash["version"] = stable&.version&.to_s
+      api_hash["bottle"] = bottle_hash(compact_for_api: true) if bottle_defined?
+    end
+
+    if (versioned_formulae_list = versioned_formulae.presence)
+      # Could we just use `versioned_formulae_names` here instead?
+      api_hash["versioned_formulae"] = versioned_formulae_list.map(&:name)
+    end
+
+    if (dependencies = internal_dependencies_hash(:stable).presence)
+      api_hash["dependencies"] = dependencies
+    end
 
-          Homebrew::SimulateSystem.os = os_name
-          Homebrew::SimulateSystem.arch = arch
+    if (head_dependencies = internal_dependencies_hash(:head).presence)
+      api_hash["head_dependencies"] = head_dependencies
+    end
 
-          variations_namespace = Formulary.class_s("Variations#{bottle_tag.to_sym.capitalize}")
+    if (requirements_array = serialized_requirements.presence)
+      api_hash["requirements"] = requirements_array
+    end
+
+    if conflicts.present?
+      api_hash["conflicts_with"] = conflicts.map(&:name)
+      api_hash["conflicts_with_reasons"] = conflicts.map(&:reason)
+    end
+
+    if deprecation_date
+      api_hash["deprecation_date"] = deprecation_date
+      api_hash["deprecation_reason"] = deprecation_reason
+    end
+
+    if disable_date
+      api_hash["disable_date"] = disable_date
+      api_hash["disable_reason"] = disable_reason
+    end
+
+    api_hash
+  end
+
+  def to_hash_with_variations(hash_method: :to_hash)
+    if loaded_from_api? && hash_method == :to_internal_api_hash
+      raise ArgumentError, "API Hash must be generated from Ruby source files"
+    end
+
+    namespace_prefix = case hash_method
+    when :to_hash
+      "Variations"
+    when :to_internal_api_hash
+      "APIVariations"
+    else
+      raise ArgumentError, "Unknown hash method #{hash_method.inspect}"
+    end
+
+    hash = public_send(hash_method)
+
+    # Take from API, merging in local install status.
+    if loaded_from_api? && !Homebrew::EnvConfig.no_install_from_api?
+      json_formula = Homebrew::API::Formula.all_formulae.fetch(name).dup
+      return json_formula.merge(
+        hash.slice("name", "installed", "linked_keg", "pinned", "outdated"),
+      )
+    end
+
+    variations = {}
+
+    if path.exist? && on_system_blocks_exist?
+      formula_contents = path.read
+      OnSystem::ALL_OS_ARCH_COMBINATIONS.each do |os, arch|
+        bottle_tag = Utils::Bottles::Tag.new(system: os, arch:)
+        next unless bottle_tag.valid_combination?
+
+        Homebrew::SimulateSystem.with(os:, arch:) do
+          variations_namespace = Formulary.class_s("#{namespace_prefix}#{bottle_tag.to_sym.capitalize}")
           variations_formula_class = Formulary.load_formula(name, path, formula_contents, variations_namespace,
                                                             flags: self.class.build_flags, ignore_errors: true)
           variations_formula = variations_formula_class.new(name, path, :stable,
-                                                            alias_path: alias_path, force_bottle: force_bottle)
+                                                            alias_path:, force_bottle:)
 
-          variations_formula.to_hash.each do |key, value|
+          variations_formula.public_send(hash_method).each do |key, value|
             next if value.to_s == hash[key].to_s
 
             variations[bottle_tag.to_sym] ||= {}
@@ -2038,76 +2595,201 @@ def to_hash_with_variations
       end
     end
 
-    Homebrew::SimulateSystem.clear
-
-    hash["variations"] = variations
+    hash["variations"] = variations if hash_method != :to_internal_api_hash || variations.present?
     hash
   end
 
-  # @api private
-  # Generate a hash to be used to install a formula from a JSON file
-  def to_recursive_bottle_hash(top_level: true)
-    bottle = bottle_hash
+  # Returns the bottle information for a formula.
+  def bottle_hash(compact_for_api: false)
+    hash = {}
+    stable_spec = stable
+    return hash unless stable_spec
+    return hash unless bottle_defined?
+
+    bottle_spec = stable_spec.bottle_specification
+
+    hash["rebuild"] = bottle_spec.rebuild if !compact_for_api || !bottle_spec.rebuild.zero?
+    hash["root_url"] = bottle_spec.root_url unless compact_for_api
+    hash["files"] = {}
+
+    bottle_spec.collector.each_tag do |tag|
+      tag_spec = bottle_spec.collector.specification_for(tag, no_older_versions: true)
+      os_cellar = tag_spec.cellar
+      os_cellar = os_cellar.inspect if os_cellar.is_a?(Symbol)
+      checksum = tag_spec.checksum.hexdigest
+
+      file_hash = {}
+      file_hash["cellar"] = os_cellar
+      unless compact_for_api
+        filename = Bottle::Filename.create(self, tag, bottle_spec.rebuild)
+        path, = Utils::Bottles.path_resolved_basename(bottle_spec.root_url, name, checksum, filename)
+        file_hash["url"] = "#{bottle_spec.root_url}/#{path}"
+      end
+      file_hash["sha256"] = checksum
 
-    bottles = bottle["files"].to_h do |tag, file|
-      info = { "url" => file["url"] }
-      info["sha256"] = file["sha256"] if tap.name != "homebrew/core"
-      [tag.to_s, info]
+      hash["files"][tag.to_sym] = file_hash
     end
+    hash
+  end
 
-    hash = {
-      "name"        => name,
-      "pkg_version" => pkg_version,
-      "rebuild"     => bottle["rebuild"],
-      "bottles"     => bottles,
-    }
+  def urls_hash
+    hash = {}
 
-    return hash unless top_level
+    if stable
+      stable_spec = T.must(stable)
+      hash["stable"] = {
+        "url"      => stable_spec.url,
+        "tag"      => stable_spec.specs[:tag],
+        "revision" => stable_spec.specs[:revision],
+        "using"    => (stable_spec.using if stable_spec.using.is_a?(Symbol)),
+        "checksum" => stable_spec.checksum&.to_s,
+      }
+    end
 
-    hash["dependencies"] = declared_runtime_dependencies.map do |dep|
-      dep.to_formula.to_recursive_bottle_hash(top_level: false)
+    if head
+      hash["head"] = {
+        "url"    => T.must(head).url,
+        "branch" => T.must(head).specs[:branch],
+        "using"  => (T.must(head).using if T.must(head).using.is_a?(Symbol)),
+      }
     end
+
     hash
   end
 
-  # Returns the bottle information for a formula
-  def bottle_hash
-    bottle_spec = stable.bottle_specification
-    hash = {
-      "rebuild"  => bottle_spec.rebuild,
-      "root_url" => bottle_spec.root_url,
-      "files"    => {},
-    }
-    bottle_spec.collector.each_tag do |tag|
-      tag_spec = bottle_spec.collector.specification_for(tag)
-      os_cellar = tag_spec.cellar
-      os_cellar = os_cellar.inspect if os_cellar.is_a?(Symbol)
+  def serialized_requirements
+    requirements = self.class.spec_syms.to_h do |sym|
+      [sym, send(sym)&.requirements]
+    end
 
-      checksum = tag_spec.checksum.hexdigest
-      filename = Bottle::Filename.create(self, tag, bottle_spec.rebuild)
-      path, = Utils::Bottles.path_resolved_basename(bottle_spec.root_url, name, checksum, filename)
-      url = "#{bottle_spec.root_url}/#{path}"
-
-      hash["files"][tag.to_sym] = {
-        "cellar" => os_cellar,
-        "url"    => url,
-        "sha256" => checksum,
+    merge_spec_dependables(requirements).map do |data|
+      req = data[:dependable]
+      req_name = req.name.dup
+      req_name.prepend("maximum_") if req.respond_to?(:comparator) && req.comparator == "<="
+      req_version = if req.respond_to?(:version)
+        req.version
+      elsif req.respond_to?(:arch)
+        req.arch
+      end
+      {
+        "name"     => req_name,
+        "cask"     => req.cask,
+        "download" => req.download,
+        "version"  => req_version,
+        "contexts" => req.tags,
+        "specs"    => data[:specs],
       }
     end
+  end
+
+  def caveats_with_placeholders
+    caveats&.gsub(HOMEBREW_PREFIX, HOMEBREW_PREFIX_PLACEHOLDER)
+           &.gsub(HOMEBREW_CELLAR, HOMEBREW_CELLAR_PLACEHOLDER)
+  end
+
+  def dependencies_hash
+    # Create a hash of spec names (stable/head) to the list of dependencies under each
+    dependencies = self.class.spec_syms.to_h do |sym|
+      [sym, send(sym)&.declared_deps]
+    end
+
+    # Implicit dependencies are only needed when installing from source
+    # since they are only used to download and unpack source files.
+    # @see DependencyCollector
+    dependencies.transform_values! { |deps| deps&.reject(&:implicit?) }
+
+    hash = {}
+
+    dependencies.each do |spec_sym, spec_deps|
+      next if spec_deps.nil?
+
+      dep_hash = if spec_sym == :stable
+        hash
+      else
+        next if spec_deps == dependencies[:stable]
+
+        hash["#{spec_sym}_dependencies"] ||= {}
+      end
+
+      dep_hash["build_dependencies"] = spec_deps.select(&:build?)
+                                                .reject(&:uses_from_macos?)
+                                                .map(&:name)
+                                                .uniq
+      dep_hash["dependencies"] = spec_deps.reject(&:optional?)
+                                          .reject(&:recommended?)
+                                          .reject(&:build?)
+                                          .reject(&:test?)
+                                          .reject(&:uses_from_macos?)
+                                          .map(&:name)
+                                          .uniq
+      dep_hash["test_dependencies"] = spec_deps.select(&:test?)
+                                               .reject(&:uses_from_macos?)
+                                               .map(&:name)
+                                               .uniq
+      dep_hash["recommended_dependencies"] = spec_deps.select(&:recommended?)
+                                                      .reject(&:uses_from_macos?)
+                                                      .map(&:name)
+                                                      .uniq
+      dep_hash["optional_dependencies"] = spec_deps.select(&:optional?)
+                                                   .reject(&:uses_from_macos?)
+                                                   .map(&:name)
+                                                   .uniq
+
+      uses_from_macos_deps = spec_deps.select(&:uses_from_macos?).uniq
+      dep_hash["uses_from_macos"] = uses_from_macos_deps.map do |dep|
+        if dep.tags.length >= 2
+          { dep.name => dep.tags }
+        elsif dep.tags.present?
+          { dep.name => dep.tags.first }
+        else
+          dep.name
+        end
+      end
+      dep_hash["uses_from_macos_bounds"] = uses_from_macos_deps.map(&:bounds)
+    end
+
     hash
   end
 
-  # @private
-  def fetch(verify_download_integrity: true)
-    active_spec.fetch(verify_download_integrity: verify_download_integrity)
+  def internal_dependencies_hash(spec_symbol)
+    raise ArgumentError, "Unsupported spec: #{spec_symbol}" unless [:stable, :head].include?(spec_symbol)
+    return unless (spec = public_send(spec_symbol))
+
+    spec.declared_deps.each_with_object({}) do |dep, dep_hash|
+      # Implicit dependencies are only needed when installing from source
+      # since they are only used to download and unpack source files.
+      # @see DependencyCollector
+      next if dep.implicit?
+
+      metadata_hash = {}
+      metadata_hash[:tags] = dep.tags if dep.tags.present?
+      metadata_hash[:uses_from_macos] = dep.bounds.presence if dep.uses_from_macos?
+
+      dep_hash[dep.name] = metadata_hash.presence
+    end
   end
 
-  # @private
-  def verify_download_integrity(fn)
-    active_spec.verify_download_integrity(fn)
+  def on_system_blocks_exist?
+    self.class.on_system_blocks_exist? || @on_system_blocks_exist
+  end
+
+  sig {
+    params(
+      verify_download_integrity: T::Boolean,
+      timeout:                   T.nilable(T.any(Integer, Float)),
+      quiet:                     T::Boolean,
+    ).returns(Pathname)
+  }
+  def fetch(verify_download_integrity: true, timeout: nil, quiet: false)
+    odeprecated "Formula#fetch", "Resource#fetch on Formula#resource"
+    active_spec.fetch(verify_download_integrity:, timeout:, quiet:)
+  end
+
+  def verify_download_integrity(filename)
+    odeprecated "Formula#verify_download_integrity", "Resource#verify_download_integrity on Formula#resource"
+    active_spec.verify_download_integrity(filename)
   end
 
-  # @private
   def run_test(keep_tmp: false)
     @prefix_returns_versioned_prefix = true
 
@@ -2126,7 +2808,7 @@ def run_test(keep_tmp: false)
 
     mktemp("#{name}-test") do |staging|
       staging.retain! if keep_tmp
-      @testpath = staging.tmpdir
+      @testpath = T.must(staging.tmpdir)
       test_env[:HOME] = @testpath
       setup_home @testpath
       begin
@@ -2145,16 +2827,13 @@ def run_test(keep_tmp: false)
     @testpath = nil
   end
 
-  # @private
   sig { returns(T::Boolean) }
   def test_defined?
     false
   end
 
-  # @private
   def test; end
 
-  # @private
   def test_fixtures(file)
     HOMEBREW_LIBRARY_PATH/"test/support/fixtures"/file
   end
@@ -2163,31 +2842,77 @@ def test_fixtures(file)
   # installation instructions. The sources (from {.url}) are downloaded,
   # hash-checked and then Homebrew changes into a temporary directory where the
   # archive is unpacked or repository cloned.
-  # <pre>def install
+  #
+  # ### Example
+  #
+  # ```ruby
+  # def install
   #   system "./configure", "--prefix=#{prefix}"
   #   system "make", "install"
-  # end</pre>
+  # end
+  # ```
   def install; end
 
+  # Sometimes we have to change a bit before we install. Mostly we
+  # prefer a patch, but if you need the {Formula#prefix prefix} of
+  # this formula in the patch you have to resort to `inreplace`,
+  # because in the patch you don't have access to any variables
+  # defined by the formula, as only `HOMEBREW_PREFIX` is available
+  # in the {DATAPatch embedded patch}.
+  #
+  # ### Examples
+  #
+  # `inreplace` supports regular expressions:
+  #
+  # ```ruby
+  # inreplace "somefile.cfg", /look[for]what?/, "replace by #{bin}/tool"
+  # ```
+  #
+  # `inreplace` supports blocks:
+  #
+  # ```ruby
+  # inreplace "Makefile" do |s|
+  #   s.gsub! "/usr/local", HOMEBREW_PREFIX.to_s
+  # end
+  # ```
+  #
+  # @see Utils::Inreplace.inreplace
+  # @api public
+  sig {
+    params(
+      paths:            T.any(T::Enumerable[T.any(String, Pathname)], String, Pathname),
+      before:           T.nilable(T.any(Pathname, Regexp, String)),
+      after:            T.nilable(T.any(Pathname, String, Symbol)),
+      old_audit_result: T.nilable(T::Boolean),
+      audit_result:     T::Boolean,
+      block:            T.nilable(T.proc.params(s: StringInreplaceExtension).void),
+    ).void
+  }
+  def inreplace(paths, before = nil, after = nil, old_audit_result = nil, audit_result: true, &block)
+    # NOTE: must check for `#nil?` and not `#blank?`, or else `old_audit_result = false` will not call `odeprecated`.
+    unless old_audit_result.nil?
+      odeprecated "inreplace(paths, before, after, #{old_audit_result})",
+                  "inreplace(paths, before, after, audit_result: #{old_audit_result})"
+      audit_result = old_audit_result
+    end
+    Utils::Inreplace.inreplace(paths, before, after, audit_result:, &block)
+  rescue Utils::Inreplace::Error => e
+    onoe e.to_s
+    raise BuildError.new(self, "inreplace", Array(paths), {})
+  end
+
   protected
 
+  sig { params(home: Pathname).void }
   def setup_home(home)
-    # keep Homebrew's site-packages in sys.path when using system Python
-    user_site_packages = home/"Library/Python/2.7/lib/python/site-packages"
-    user_site_packages.mkpath
-    (user_site_packages/"homebrew.pth").write <<~PYTHON
-      import site; site.addsitedir("#{HOMEBREW_PREFIX}/lib/python2.7/site-packages")
-      import sys, os; sys.path = (os.environ["PYTHONPATH"].split(os.pathsep) if "PYTHONPATH" in os.environ else []) + ["#{HOMEBREW_PREFIX}/lib/python2.7/site-packages"] + sys.path
-    PYTHON
-
     # Don't let bazel write to tmp directories we don't control or clean.
     (home/".bazelrc").write "startup --output_user_root=#{home}/_bazel"
   end
 
   # Returns a list of Dependency objects that are declared in the formula.
-  # @private
   def declared_runtime_dependencies
-    recursive_dependencies do |_, dependency|
+    cache_key = "Formula#declared_runtime_dependencies" unless build.any_args_or_options?
+    Dependency.expand(self, cache_key:) do |_, dependency|
       Dependency.prune if dependency.build?
       next if dependency.required?
 
@@ -2201,7 +2926,6 @@ def declared_runtime_dependencies
 
   # Returns a list of Dependency objects that are not declared in the formula
   # but the formula links to.
-  # @private
   def undeclared_runtime_dependencies
     keg = any_installed_keg
     return [] unless keg
@@ -2217,27 +2941,44 @@ def undeclared_runtime_dependencies
   # To call out to the system, we use the `system` method and we prefer
   # you give the args separately as in the line below, otherwise a subshell
   # has to be opened first.
-  # <pre>system "./bootstrap.sh", "--arg1", "--prefix=#{prefix}"</pre>
+  #
+  # ### Examples
+  #
+  # ```ruby
+  # system "./bootstrap.sh", "--arg1", "--prefix=#{prefix}"
+  # ```
   #
   # For CMake and other build systems we have some necessary defaults in e.g.
   # {#std_cmake_args}:
-  # <pre>system "cmake", ".", *std_cmake_args</pre>
+  #
+  # ```ruby
+  # system "cmake", ".", *std_cmake_args
+  # ```
   #
   # If the arguments given to `configure` (or `make` or `cmake`) are depending
   # on options defined above, we usually make a list first and then
   # use the `args << if <condition>` to append each:
-  # <pre>args = ["--with-option1", "--with-option2"]
+  #
+  # ```ruby
+  # args = ["--with-option1", "--with-option2"]
   # args << "--without-gcc" if ENV.compiler == :clang
+  # ```
   #
-  # # Most software still uses `configure` and `make`.
-  # # Check with `./configure --help` for what our options are.
+  # Most software still uses `configure` and `make`.
+  # Check with `./configure --help` for what our options are.
+  #
+  # ```ruby
   # system "./configure", "--disable-debug", "--disable-dependency-tracking",
   #                       "--disable-silent-rules", "--prefix=#{prefix}",
   #                       *args # our custom arg list (needs `*` to unpack)
+  # ```
+  #
+  # If there is a "make install" available, please use it!
   #
-  # # If there is a "make install" available, please use it!
-  # system "make", "install"</pre>
-  sig { params(cmd: T.any(String, Pathname), args: T.any(String, Pathname, Integer)).void }
+  # ```ruby
+  # system "make", "install"
+  # ```
+  sig { params(cmd: T.any(String, Pathname), args: T.any(String, Integer, Pathname, Symbol)).void }
   def system(cmd, *args)
     verbose_using_dots = Homebrew::EnvConfig.verbose_using_dots?
 
@@ -2247,13 +2988,19 @@ def system(cmd, *args)
     unless verbose?
       case cmd
       when "./configure"
-        pretty_args -= %w[--disable-dependency-tracking --disable-debug --disable-silent-rules]
+        pretty_args -= std_configure_args
+      when "cabal"
+        pretty_args -= std_cabal_v2_args
       when "cargo"
         pretty_args -= std_cargo_args
       when "cmake"
         pretty_args -= std_cmake_args
       when "go"
         pretty_args -= std_go_args
+      when "meson"
+        pretty_args -= std_meson_args
+      when %r{(^|/)(pip|python)(?:[23](?:\.\d{1,2})?)?$}
+        pretty_args -= std_pip_args
       end
     end
     pretty_args.each_index do |i|
@@ -2287,7 +3034,7 @@ def system(cmd, *args)
             while (buf = rd.gets)
               log.puts buf
               # make sure dots printed with interval of at least 1 min.
-              next unless (Time.now - last_dot) > 60
+              next if (Time.now - last_dot) <= 60
 
               print "."
               $stdout.flush
@@ -2319,7 +3066,7 @@ def system(cmd, *args)
         log.flush
         if !verbose? || verbose_using_dots
           puts "Last #{log_lines} lines from #{logfn}:"
-          Kernel.system "/usr/bin/tail", "-n", log_lines, logfn
+          Kernel.system "/usr/bin/tail", "-n", log_lines.to_s, logfn
         end
         log.puts
 
@@ -2337,17 +3084,17 @@ def system(cmd, *args)
     end
   end
 
-  # @private
   def eligible_kegs_for_cleanup(quiet: false)
     eligible_for_cleanup = []
     if latest_version_installed?
       eligible_kegs = if head? && (head_prefix = latest_head_prefix)
-        head, stable = installed_kegs.partition { |k| k.version.head? }
-        # Remove newest head and stable kegs
-        head - [Keg.new(head_prefix)] + stable.sort_by(&:version).slice(0...-1)
+        head, stable = installed_kegs.partition { |keg| keg.version.head? }
+
+        # Remove newest head and stable kegs.
+        head - [Keg.new(head_prefix)] + T.must(stable.sort_by(&:scheme_and_version).slice(0...-1))
       else
         installed_kegs.select do |keg|
-          tab = Tab.for_keg(keg)
+          tab = keg.tab
           if version_scheme > tab.version_scheme
             true
           elsif version_scheme == tab.version_scheme
@@ -2382,8 +3129,16 @@ def eligible_kegs_for_cleanup(quiet: false)
   # recursively delete the temporary directory. Passing `opts[:retain]`
   # or calling `do |staging| ... staging.retain!` in the block will skip
   # the deletion and retain the temporary directory's contents.
-  def mktemp(prefix = name, opts = {}, &block)
-    Mktemp.new(prefix, opts).run(&block)
+  sig {
+    params(
+      prefix:          String,
+      retain:          T::Boolean,
+      retain_in_cache: T::Boolean,
+      block:           T.proc.params(arg0: Mktemp).void,
+    ).void
+  }
+  def mktemp(prefix = name, retain: false, retain_in_cache: false, &block)
+    Mktemp.new(prefix, retain:, retain_in_cache:).run(&block)
   end
 
   # A version of `FileUtils.mkdir` that also changes to that folder in
@@ -2396,12 +3151,12 @@ def mkdir(name, &block)
   end
 
   # Runs `xcodebuild` without Homebrew's compiler environment variables set.
-  sig { params(args: T.any(String, Pathname)).void }
+  sig { params(args: T.any(String, Integer, Pathname, Symbol)).void }
   def xcodebuild(*args)
     removed = ENV.remove_cc_etc
 
     begin
-      T.unsafe(self).system("xcodebuild", *args)
+      self.system("xcodebuild", *args)
     ensure
       ENV.update(removed)
     end
@@ -2432,9 +3187,8 @@ def prepare_patches
   end
 
   # Returns the prefix for a given formula version number.
-  # @private
-  def versioned_prefix(v)
-    rack/v
+  def versioned_prefix(version)
+    rack/version
   end
 
   def exec_cmd(cmd, args, out, logfn)
@@ -2448,8 +3202,7 @@ def exec_cmd(cmd, args, out, logfn)
     if cmd == "python"
       setup_py_in_args = %w[setup.py build.py].include?(args.first)
       setuptools_shim_in_args = args.any? { |a| a.to_s.start_with? "import setuptools" }
-      env = T.cast(ENV, T.any(Stdenv, Superenv))
-      env.refurbish_args if setup_py_in_args || setuptools_shim_in_args
+      ENV.refurbish_args if setup_py_in_args || setuptools_shim_in_args
     end
 
     $stdout.reopen(out)
@@ -2457,7 +3210,7 @@ def exec_cmd(cmd, args, out, logfn)
     out.close
     args.map!(&:to_s)
     begin
-      T.unsafe(Kernel).exec(cmd, *args)
+      Kernel.exec(cmd, *args)
     rescue
       nil
     end
@@ -2468,19 +3221,21 @@ def exec_cmd(cmd, args, out, logfn)
   # Common environment variables used at both build and test time.
   def common_stage_test_env
     {
-      _JAVA_OPTIONS: "-Duser.home=#{HOMEBREW_CACHE}/java_cache",
-      GOCACHE:       "#{HOMEBREW_CACHE}/go_cache",
-      GOPATH:        "#{HOMEBREW_CACHE}/go_mod_cache",
-      CARGO_HOME:    "#{HOMEBREW_CACHE}/cargo_cache",
-      CURL_HOME:     ENV.fetch("CURL_HOME") { Dir.home },
+      _JAVA_OPTIONS:           "-Duser.home=#{HOMEBREW_CACHE}/java_cache",
+      GOCACHE:                 "#{HOMEBREW_CACHE}/go_cache",
+      GOPATH:                  "#{HOMEBREW_CACHE}/go_mod_cache",
+      CARGO_HOME:              "#{HOMEBREW_CACHE}/cargo_cache",
+      PIP_CACHE_DIR:           "#{HOMEBREW_CACHE}/pip_cache",
+      CURL_HOME:               ENV.fetch("CURL_HOME") { Dir.home },
+      PYTHONDONTWRITEBYTECODE: "1",
     }
   end
 
-  def stage(interactive: false)
-    active_spec.stage do |staging|
+  def stage(interactive: false, debug_symbols: false)
+    active_spec.stage(debug_symbols:) do |staging|
       @source_modified_time = active_spec.source_modified_time
       @buildpath = Pathname.pwd
-      env_home = buildpath/".brew_home"
+      env_home = T.must(buildpath)/".brew_home"
       mkdir_p env_home
 
       stage_env = {
@@ -2493,6 +3248,8 @@ def stage(interactive: false)
       end
 
       setup_home env_home
+      # Don't dirty the git tree for git clones.
+      (env_home/".gitignore").write "*"
 
       ENV.clear_sensitive_environment!
 
@@ -2508,10 +3265,30 @@ def stage(interactive: false)
 
   # The methods below define the formula DSL.
   class << self
-    extend Predicable
+    extend Attrable
+
     include BuildEnvironment::DSL
     include OnSystem::MacOSAndLinux
 
+    # Initialise instance variables for each subclass. These need to be initialised before the class is frozen,
+    # and some DSL may never be called so it can't be done lazily.
+    def inherited(child)
+      super
+      child.instance_eval do
+        # Ensure this is synced with `freeze`
+        @stable = SoftwareSpec.new(flags: build_flags)
+        @head = HeadSoftwareSpec.new(flags: build_flags)
+        @livecheck = Livecheck.new(self)
+        @conflicts = []
+        @skip_clean_paths = Set.new
+        @link_overwrite_paths = Set.new
+        @loaded_from_api = false
+        @network_access_allowed = SUPPORTED_NETWORK_ACCESS_PHASES.to_h do |phase|
+          [phase, DEFAULT_NETWORK_ACCESS_ALLOWED]
+        end
+      end
+    end
+
     def method_added(method)
       super
 
@@ -2523,47 +3300,89 @@ def method_added(method)
       end
     end
 
+    def freeze
+      specs.each(&:freeze)
+      @livecheck.freeze
+      @conflicts.freeze
+      @skip_clean_paths.freeze
+      @link_overwrite_paths.freeze
+      super
+    end
+
+    # Whether this formula was loaded using the formulae.brew.sh API
+    attr_predicate :loaded_from_api?
+
     # Whether this formula contains OS/arch-specific blocks
     # (e.g. `on_macos`, `on_arm`, `on_monterey :or_older`, `on_system :linux, macos: :big_sur_or_newer`).
-    # @private
     attr_predicate :on_system_blocks_exist?
 
-    # The reason for why this software is not linked (by default) to
-    # {::HOMEBREW_PREFIX}.
-    # @private
+    # The reason for why this software is not linked (by default) to {::HOMEBREW_PREFIX}.
     attr_reader :keg_only_reason
 
-    # @!attribute [w] desc
     # A one-line description of the software. Used by users to get an overview
     # of the software and Homebrew maintainers.
     # Shows when running `brew info`.
     #
-    # <pre>desc "Example formula"</pre>
+    # ### Example
+    #
+    # ```ruby
+    # desc "Example formula"
+    # ```
+    #
+    # @!attribute [w] desc
+    # @api public
     attr_rw :desc
 
-    # @!attribute [w] license
     # The SPDX ID of the open-source license that the formula uses.
     # Shows when running `brew info`.
+    #
     # Use `:any_of`, `:all_of` or `:with` to describe complex license expressions.
     # `:any_of` should be used when the user can choose which license to use.
     # `:all_of` should be used when the user must use all licenses.
     # `:with` should be used to specify a valid SPDX exception.
+    #
     # Add `+` to an identifier to indicate that the formulae can be
     # licensed under later versions of the same license.
-    # @see https://docs.brew.sh/License-Guidelines Homebrew License Guidelines
-    # @see https://spdx.github.io/spdx-spec/appendix-IV-SPDX-license-expressions/ SPDX license expression guide
-    # <pre>license "BSD-2-Clause"</pre>
-    # <pre>license "EPL-1.0+"</pre>
-    # <pre>license any_of: ["MIT", "GPL-2.0-only"]</pre>
-    # <pre>license all_of: ["MIT", "GPL-2.0-only"]</pre>
-    # <pre>license "GPL-2.0-only" => { with: "LLVM-exception" }</pre>
-    # <pre>license :public_domain</pre>
-    # <pre>license any_of: [
+    #
+    # ### Examples
+    #
+    # ```ruby
+    # license "BSD-2-Clause"
+    # ```
+    #
+    # ```ruby
+    # license "EPL-1.0+"
+    # ```
+    #
+    # ```ruby
+    # license any_of: ["MIT", "GPL-2.0-only"]
+    # ```
+    #
+    # ```ruby
+    # license all_of: ["MIT", "GPL-2.0-only"]
+    # ```
+    #
+    # ```ruby
+    # license "GPL-2.0-only" => { with: "LLVM-exception" }
+    # ```
+    #
+    # ```ruby
+    # license :public_domain
+    # ```
+    #
+    # ```ruby
+    # license any_of: [
     #   "MIT",
     #   :public_domain,
     #   all_of: ["0BSD", "Zlib", "Artistic-1.0+"],
     #   "Apache-2.0" => { with: "LLVM-exception" },
-    # ]</pre>
+    # ]
+    # ```
+    #
+    # @!attribute [w] license
+    # @see https://docs.brew.sh/License-Guidelines Homebrew License Guidelines
+    # @see https://spdx.github.io/spdx-spec/latest/annexes/spdx-license-expressions/ SPDX license expression guide
+    # @api public
     def license(args = nil)
       if args.nil?
         @licenses
@@ -2572,40 +3391,123 @@ def license(args = nil)
       end
     end
 
-    # @!attribute [w] homepage
+    # The phases for which network access is allowed. By default, network
+    # access is allowed for all phases. Valid phases are `:build`, `:test`,
+    # and `:postinstall`. When no argument is passed, network access will be
+    # allowed for all phases.
+    #
+    # ### Examples
+    #
+    # ```ruby
+    # allow_network_access!
+    # ```
+    #
+    # ```ruby
+    # allow_network_access! :build
+    # ```
+    #
+    # ```ruby
+    # allow_network_access! [:build, :test]
+    # ```
+    #
+    # @!attribute [w] allow_network_access!
+    sig { params(phases: T.any(Symbol, T::Array[Symbol])).void }
+    def allow_network_access!(phases = [])
+      phases_array = Array(phases)
+      if phases_array.empty?
+        @network_access_allowed.each_key { |phase| @network_access_allowed[phase] = true }
+      else
+        phases_array.each do |phase|
+          raise ArgumentError, "Unknown phase: #{phase}" unless SUPPORTED_NETWORK_ACCESS_PHASES.include?(phase)
+
+          @network_access_allowed[phase] = true
+        end
+      end
+    end
+
+    # The phases for which network access is denied. By default, network
+    # access is allowed for all phases. Valid phases are `:build`, `:test`,
+    # and `:postinstall`. When no argument is passed, network access will be
+    # denied for all phases.
+    #
+    # ### Examples
+    #
+    # ```ruby
+    # deny_network_access!
+    # ```
+    #
+    # ```ruby
+    # deny_network_access! :build
+    # ```
+    #
+    # ```ruby
+    # deny_network_access! [:build, :test]
+    # ```
+    #
+    # @!attribute [w] deny_network_access!
+    sig { params(phases: T.any(Symbol, T::Array[Symbol])).void }
+    def deny_network_access!(phases = [])
+      phases_array = Array(phases)
+      if phases_array.empty?
+        @network_access_allowed.each_key { |phase| @network_access_allowed[phase] = false }
+      else
+        phases_array.each do |phase|
+          raise ArgumentError, "Unknown phase: #{phase}" unless SUPPORTED_NETWORK_ACCESS_PHASES.include?(phase)
+
+          @network_access_allowed[phase] = false
+        end
+      end
+    end
+
+    # Whether the specified phase should be forced offline.
+    sig { params(phase: Symbol).returns(T::Boolean) }
+    def network_access_allowed?(phase)
+      raise ArgumentError, "Unknown phase: #{phase}" unless SUPPORTED_NETWORK_ACCESS_PHASES.include?(phase)
+
+      env_var = Homebrew::EnvConfig.send(:"formula_#{phase}_network")
+      env_var.nil? ? @network_access_allowed[phase] : env_var == "allow"
+    end
+
     # The homepage for the software. Used by users to get more information
     # about the software and Homebrew maintainers as a point of contact for
     # e.g. submitting patches.
     # Can be opened with running `brew home`.
     #
-    # <pre>homepage "https://www.example.com"</pre>
+    # ### Example
+    #
+    # ```ruby
+    # homepage "https://www.example.com"
+    # ```
+    #
+    # @!attribute [w] homepage
+    # @api public
     attr_rw :homepage
 
-    # Whether a livecheck specification is defined or not.
-    # It returns true when a livecheck block is present in the {Formula} and
-    # false otherwise, and is used by livecheck.
+    # Checks whether a `livecheck` specification is defined or not.
+    #
+    # It returns `true` when a `livecheck` block is present in the {Formula}
+    # and `false` otherwise.
+    sig { returns(T::Boolean) }
     def livecheckable?
       @livecheckable == true
     end
 
-    # Whether a service specification is defined or not.
-    # It returns true when a service block is present in the {Formula} and
-    # false otherwise, and is used by service.
+    # Checks whether a service specification is defined or not.
+    #
+    # It returns `true` when a service block is present in the {Formula}
+    # and `false` otherwise.
+    sig { returns(T::Boolean) }
     def service?
       @service_block.present?
     end
 
-    # The `:startup` attribute set by {.plist_options}.
-    # @private
-    attr_reader :plist_startup
+    sig { returns(T::Array[FormulaConflict]) }
+    attr_reader :conflicts
 
-    # The `:manual` attribute set by {.plist_options}.
-    # @private
-    attr_reader :plist_manual
+    attr_reader :skip_clean_paths, :link_overwrite_paths, :pour_bottle_only_if
 
     # If `pour_bottle?` returns `false` the user-visible reason to display for
     # why they cannot use the bottle.
-    # @private
     attr_accessor :pour_bottle_check_unsatisfied_reason
 
     # @!attribute [w] revision
@@ -2615,7 +3517,13 @@ def service?
     # {Formula} to install a new version linked against the new library version.
     # `0` if unset.
     #
-    # <pre>revision 1</pre>
+    # ### Example
+    #
+    # ```ruby
+    # revision 1
+    # ```
+    #
+    # @api public
     attr_rw :revision
 
     # @!attribute [w] version_scheme
@@ -2627,30 +3535,50 @@ def service?
     # higher version.
     # `0` if unset.
     #
-    # <pre>version_scheme 1</pre>
+    # ### Example
+    #
+    # ```ruby
+    # version_scheme 1
+    # ```
+    #
+    # @api public
     attr_rw :version_scheme
 
+    def spec_syms
+      [:stable, :head].freeze
+    end
+
     # A list of the {.stable} and {.head} {SoftwareSpec}s.
-    # @private
     def specs
-      @specs ||= [stable, head].freeze
+      spec_syms.map do |sym|
+        send(sym)
+      end.freeze
     end
 
-    # @!attribute [w] url
     # The URL used to download the source for the {.stable} version of the formula.
     # We prefer `https` for security and proxy reasons.
-    # If not inferrable, specify the download strategy with `using: ...`.
+    # If not inferable, specify the download strategy with `using: ...`.
     #
     # - `:git`, `:hg`, `:svn`, `:bzr`, `:fossil`, `:cvs`,
     # - `:curl` (normal file download, will also extract)
     # - `:nounzip` (without extracting)
     # - `:post` (download via an HTTP POST)
     #
-    # <pre>url "https://packed.sources.and.we.prefer.https.example.com/archive-1.2.3.tar.bz2"</pre>
-    # <pre>url "https://some.dont.provide.archives.example.com",
+    # ### Examples
+    #
+    # ```ruby
+    # url "https://packed.sources.and.we.prefer.https.example.com/archive-1.2.3.tar.bz2"
+    # ```
+    #
+    # ```ruby
+    # url "https://some.dont.provide.archives.example.com",
     #     using:    :git,
     #     tag:      "1.2.3",
-    #     revision: "db8e4de5b2d6653f66aea53094624468caad15d2"</pre>
+    #     revision: "db8e4de5b2d6653f66aea53094624468caad15d2"
+    # ```
+    #
+    # @!attribute [w] url
+    # @api public
     def url(val, specs = {})
       stable.url(val, specs)
     end
@@ -2660,7 +3588,13 @@ def url(val, specs = {})
     # The version is autodetected from the URL and/or tag so only needs to be
     # declared if it cannot be autodetected correctly.
     #
-    # <pre>version "1.2-final"</pre>
+    # ### Example
+    #
+    # ```ruby
+    # version "1.2-final"
+    # ```
+    #
+    # @api public
     def version(val = nil)
       stable.version(val)
     end
@@ -2672,8 +3606,14 @@ def version(val = nil)
     # is unreliable. If {.url} is really unreliable then we may swap the
     # {.mirror} and {.url}.
     #
-    # <pre>mirror "https://in.case.the.host.is.down.example.com"
-    # mirror "https://in.case.the.mirror.is.down.example.com</pre>
+    # ### Example
+    #
+    # ```ruby
+    # mirror "https://in.case.the.host.is.down.example.com"
+    # mirror "https://in.case.the.mirror.is.down.example.com
+    # ```
+    #
+    # @api public
     def mirror(val)
       stable.mirror(val)
     end
@@ -2685,12 +3625,17 @@ def mirror(val)
     # this value you can leave it blank and run `brew fetch --force` and it'll
     # tell you the currently valid value.
     #
-    # <pre>sha256 "2a2ba417eebaadcb4418ee7b12fe2998f26d6e6f7fda7983412ff66a741ab6f7"</pre>
+    # ### Example
+    #
+    # ```ruby
+    # sha256 "2a2ba417eebaadcb4418ee7b12fe2998f26d6e6f7fda7983412ff66a741ab6f7"
+    # ```
+    #
+    # @api public
     def sha256(val)
       stable.sha256(val)
     end
 
-    # @!attribute [w] bottle
     # Adds a {.bottle} {SoftwareSpec}.
     # This provides a pre-built binary package built by the Homebrew maintainers for you.
     # It will be installed automatically if there is a binary package for your platform
@@ -2701,33 +3646,30 @@ def sha256(val)
     # You can ignore this block entirely if submitting to Homebrew/homebrew-core.
     # It'll be handled for you by the Brew Test Bot.
     #
-    # <pre>bottle do
+    # ```ruby
+    # bottle do
     #   root_url "https://example.com" # Optional root to calculate bottle URLs.
     #   rebuild 1 # Marks the old bottle as outdated without bumping the version/revision of the formula.
     #   # Optionally specify the HOMEBREW_CELLAR in which the bottles were built.
     #   sha256 cellar: "/brew/Cellar", catalina:    "ef65c759c5097a36323fa9c77756468649e8d1980a3a4e05695c05e39568967c"
     #   sha256 cellar: :any,           mojave:      "28f4090610946a4eb207df102d841de23ced0d06ba31cb79e040d883906dcd4f"
     #   sha256                         high_sierra: "91dd0caca9bd3f38c439d5a7b6f68440c4274945615fae035ff0a369264b8a2f"
-    # end</pre>
-    #
-    # Homebrew maintainers aim to bottle all formulae that require compilation.
+    # end
+    # ```
     #
-    # Formulae that can be installed without compilation should be tagged with:
-    # <pre>bottle :unneeded</pre>
+    # Homebrew maintainers aim to bottle all formulae.
     #
-    # Formulae which should not be bottled should be tagged with:
-    # <pre>bottle :disable, "reasons"</pre>
-    def bottle(*args, &block)
-      stable.bottle(*args, &block)
+    # @api public
+    sig { params(block: T.proc.bind(BottleSpecification).void).void }
+    def bottle(&block)
+      stable.bottle(&block)
     end
 
-    # @private
     def build
       stable.build
     end
 
     # Get the `BUILD_FLAGS` from the formula's namespace set in `Formulary::load_formula`.
-    # @private
     def build_flags
       namespace = T.must(to_s.split("::")[0..-2]).join("::")
       return [] if namespace.empty?
@@ -2739,17 +3681,22 @@ def build_flags
     # @!attribute [w] stable
     # Allows adding {.depends_on} and {Patch}es just to the {.stable} {SoftwareSpec}.
     # This is required instead of using a conditional.
-    # It is preferrable to also pull the {url} and {sha256= sha256} into the block if one is added.
+    # It is preferable to also pull the {url} and {sha256= sha256} into the block if one is added.
+    #
+    # ### Example
     #
-    # <pre>stable do
+    # ```ruby
+    # stable do
     #   url "https://example.com/foo-1.0.tar.gz"
     #   sha256 "2a2ba417eebaadcb4418ee7b12fe2998f26d6e6f7fda7983412ff66a741ab6f7"
     #
     #   depends_on "libxml2"
     #   depends_on "libffi"
-    # end</pre>
+    # end
+    # ```
+    #
+    # @api public
     def stable(&block)
-      @stable ||= SoftwareSpec.new(flags: build_flags)
       return @stable unless block
 
       @stable.instance_eval(&block)
@@ -2763,12 +3710,23 @@ def stable(&block)
     # If a block is provided you can also add {.depends_on} and {Patch}es just to the {.head} {SoftwareSpec}.
     # The download strategies (e.g. `:using =>`) are the same as for {url}.
     # `master` is the default branch and doesn't need stating with a `branch:` parameter.
-    # <pre>head "https://we.prefer.https.over.git.example.com/.git"</pre>
-    # <pre>head "https://example.com/.git", branch: "name_of_branch"</pre>
+    #
+    # ### Example
+    #
+    # ```ruby
+    # head "https://we.prefer.https.over.git.example.com/.git"
+    # ```
+    #
+    # ```ruby
+    # head "https://example.com/.git", branch: "name_of_branch"
+    # ```
+    #
     # or (if autodetect fails):
-    # <pre>head "https://hg.is.awesome.but.git.has.won.example.com/", using: :hg</pre>
+    #
+    # ```ruby
+    # head "https://hg.is.awesome.but.git.has.won.example.com/", using: :hg
+    # ```
     def head(val = nil, specs = {}, &block)
-      @head ||= HeadSoftwareSpec.new(flags: build_flags)
       if block
         @head.instance_eval(&block)
       elsif val
@@ -2781,17 +3739,29 @@ def head(val = nil, specs = {}, &block)
     # Additional downloads can be defined as {resource}s and accessed in the
     # install method. Resources can also be defined inside a {.stable} or
     # {.head} block. This mechanism replaces ad-hoc "subformula" classes.
-    # <pre>resource "additional_files" do
+    #
+    # ### Example
+    #
+    # ```ruby
+    # resource "additional_files" do
     #   url "https://example.com/additional-stuff.tar.gz"
     #   sha256 "c6bc3f48ce8e797854c4b865f6a8ff969867bbcaebd648ae6fd825683e59fef2"
-    # end</pre>
+    # end
+    # ```
+    #
+    # @api public
+    sig { params(name: String, klass: T.class_of(Resource), block: T.nilable(T.proc.bind(Resource).void)).void }
     def resource(name, klass = Resource, &block)
       specs.each do |spec|
         spec.resource(name, klass, &block) unless spec.resource_defined?(name)
       end
     end
 
+    # Specify a Go resource.
+    #
+    # @api public
     def go_resource(name, &block)
+      odisabled "`Formula.go_resource`", "Go modules"
       specs.each { |spec| spec.go_resource(name, &block) }
     end
 
@@ -2800,44 +3770,80 @@ def go_resource(name, &block)
     # that needs extra handling (often changing some ENV vars or
     # deciding whether to use the system provided version).
     #
+    # ### Examples
+    #
     # `:build` means this dependency is only needed during build.
-    # <pre>depends_on "cmake" => :build</pre>
+    #
+    # ```ruby
+    # depends_on "cmake" => :build
+    # ```
     #
     # `:test` means this dependency is only needed during testing.
-    # <pre>depends_on "node" => :test</pre>
+    #
+    # ```ruby
+    # depends_on "node" => :test
+    # ```
     #
     # `:recommended` dependencies are built by default.
     # But a `--without-...` option is generated to opt-out.
-    # <pre>depends_on "readline" => :recommended</pre>
+    #
+    # ```ruby
+    # depends_on "readline" => :recommended
+    # ```
     #
     # `:optional` dependencies are NOT built by default unless the
     # auto-generated `--with-...` option is passed.
-    # <pre>depends_on "glib" => :optional</pre>
+    #
+    # ```ruby
+    # depends_on "glib" => :optional
+    # ```
     #
     # If you need to specify that another formula has to be built with/out
     # certain options (note, no `--` needed before the option):
-    # <pre>depends_on "zeromq" => "with-pgm"
-    # depends_on "qt" => ["with-qtdbus", "developer"] # Multiple options.</pre>
     #
-    # Optional and enforce that "boost" is built with `--with-c++11`.
-    # <pre>depends_on "boost" => [:optional, "with-c++11"]</pre>
+    # ```ruby
+    # depends_on "zeromq" => "with-pgm"
+    # depends_on "qt" => ["with-qtdbus", "developer"] # Multiple options.
+    # ```
+    #
+    # Optional and enforce that "boost" is built using `--with-c++11`.
+    #
+    # ```ruby
+    # depends_on "boost" => [:optional, "with-c++11"]
+    # ```
     #
     # If a dependency is only needed in certain cases:
-    # <pre>depends_on "sqlite" if MacOS.version >= :catalina
+    #
+    # ```ruby
+    # depends_on "sqlite" if MacOS.version >= :catalina
     # depends_on xcode: :build # If the formula really needs full Xcode to compile.
     # depends_on macos: :mojave # Needs at least macOS Mojave (10.14) to run.
-    # </pre>
+    # ```
     #
     # It is possible to only depend on something if
     # `build.with?` or `build.without? "another_formula"`:
-    # <pre>depends_on "postgresql" if build.without? "sqlite"</pre>
+    #
+    # ```ruby
+    # depends_on "postgresql" if build.without? "sqlite"
+    # ```
+    #
+    # @api public
     def depends_on(dep)
       specs.each { |spec| spec.depends_on(dep) }
     end
 
     # Indicates use of dependencies provided by macOS.
-    # On macOS this is a no-op (as we use the provided system libraries).
+    # On macOS this is a no-op (as we use the provided system libraries) unless
+    # `:since` specifies a minimum macOS version.
     # On Linux this will act as {.depends_on}.
+    #
+    # @api public
+    sig {
+      params(
+        dep:    T.any(String, T::Hash[T.any(String, Symbol), T.any(Symbol, T::Array[Symbol])]),
+        bounds: T::Hash[Symbol, Symbol],
+      ).void
+    }
     def uses_from_macos(dep, bounds = {})
       specs.each { |spec| spec.uses_from_macos(dep, bounds) }
     end
@@ -2853,9 +3859,22 @@ def uses_from_macos(dep, bounds = {})
     #
     # - `:universal`: build a universal binary/library (e.g. on newer Intel Macs
     #   this means a combined x86_64/x86 binary/library).
-    # <pre>option "with-spam", "The description goes here without a dot at the end"</pre>
-    # <pre>option "with-qt", "Text here overwrites what's autogenerated by 'depends_on "qt" => :optional'"</pre>
-    # <pre>option :universal</pre>
+    #
+    # ### Examples
+    #
+    # ```ruby
+    # option "with-spam", "The description goes here without a dot at the end"
+    # ```
+    #
+    # ```ruby
+    # option "with-qt", "Text here overwrites what's autogenerated by 'depends_on "qt" => :optional'"
+    # ```
+    #
+    # ```ruby
+    # option :universal
+    # ```
+    #
+    # @api public
     def option(name, description = "")
       specs.each { |spec| spec.option(name, description) }
     end
@@ -2864,68 +3883,81 @@ def option(name, description = "")
     # Deprecated options are used to rename options and migrate users who used
     # them to newer ones. They are mostly used for migrating non-`with` options
     # (e.g. `enable-debug`) to `with` options (e.g. `with-debug`).
-    # <pre>deprecated_option "enable-debug" => "with-debug"</pre>
+    #
+    # ### Example
+    #
+    # ```ruby
+    # deprecated_option "enable-debug" => "with-debug"
+    # ```
+    #
+    # @api public
     def deprecated_option(hash)
       specs.each { |spec| spec.deprecated_option(hash) }
     end
 
     # External patches can be declared using resource-style blocks.
-    # <pre>patch do
+    #
+    # ### Examples
+    #
+    # ```ruby
+    # patch do
     #   url "https://example.com/example_patch.diff"
     #   sha256 "c6bc3f48ce8e797854c4b865f6a8ff969867bbcaebd648ae6fd825683e59fef2"
-    # end</pre>
+    # end
+    # ```
     #
     # A strip level of `-p1` is assumed. It can be overridden using a symbol
     # argument:
-    # <pre>patch :p0 do
+    #
+    # ```ruby
+    # patch :p0 do
     #   url "https://example.com/example_patch.diff"
     #   sha256 "c6bc3f48ce8e797854c4b865f6a8ff969867bbcaebd648ae6fd825683e59fef2"
-    # end</pre>
+    # end
+    # ```
     #
     # Patches can be declared in stable and head blocks. This form is
     # preferred over using conditionals.
-    # <pre>stable do
+    #
+    # ```ruby
+    # stable do
     #   patch do
     #     url "https://example.com/example_patch.diff"
     #     sha256 "c6bc3f48ce8e797854c4b865f6a8ff969867bbcaebd648ae6fd825683e59fef2"
     #   end
-    # end</pre>
+    # end
+    # ```
     #
     # Embedded (`__END__`) patches are declared like so:
-    # <pre>patch :DATA
-    # patch :p0, :DATA</pre>
+    #
+    # ```ruby
+    # patch :DATA
+    # patch :p0, :DATA
+    # ```
     #
     # Patches can also be embedded by passing a string. This makes it possible
     # to provide multiple embedded patches while making only some of them
     # conditional.
-    # <pre>patch :p0, "..."</pre>
+    #
+    # ```ruby
+    # patch :p0, "..."
+    # ```
+    #
     # @see https://docs.brew.sh/Formula-Cookbook#patches Patches
+    # @api public
     def patch(strip = :p1, src = nil, &block)
       specs.each { |spec| spec.patch(strip, src, &block) }
     end
 
-    # Defines launchd plist handling.
+    # One or more formulae that conflict with this one and why.
     #
-    # Does your plist need to be loaded at startup?
-    # <pre>plist_options startup: true</pre>
+    # ### Example
     #
-    # Or only when necessary or desired by the user?
-    # <pre>plist_options manual: "foo"</pre>
+    # ```ruby
+    # conflicts_with "imagemagick", because: "both install `convert` binaries"
+    # ```
     #
-    # Or perhaps you'd like to give the user a choice? Ooh fancy.
-    # <pre>plist_options startup: true, manual: "foo start"</pre>
-    def plist_options(options)
-      @plist_startup = options[:startup]
-      @plist_manual = options[:manual]
-    end
-
-    # @private
-    def conflicts
-      @conflicts ||= []
-    end
-
-    # One or more formulae that conflict with this one and why.
-    # <pre>conflicts_with "imagemagick", because: "both install `convert` binaries"</pre>
+    # @api public
     def conflicts_with(*names)
       opts = names.last.is_a?(Hash) ? names.pop : {}
       names.each { |name| conflicts << FormulaConflict.new(name, opts[:because]) }
@@ -2934,49 +3966,77 @@ def conflicts_with(*names)
     # Skip cleaning paths in a formula.
     #
     # Sometimes the formula {Cleaner cleaner} breaks things.
+    #
+    # ### Examples
+    #
     # Preserve cleaned paths with:
-    # <pre>skip_clean "bin/foo", "lib/bar"</pre>
+    #
+    # ```ruby
+    # skip_clean "bin/foo", "lib/bar"
+    # ```
+    #
     # Keep .la files with:
-    # <pre>skip_clean :la</pre>
+    #
+    # ```ruby
+    # skip_clean :la
+    # ```
+    #
+    # @api public
     def skip_clean(*paths)
       paths.flatten!
       # Specifying :all is deprecated and will become an error
       skip_clean_paths.merge(paths)
     end
 
-    # @private
-    def skip_clean_paths
-      @skip_clean_paths ||= Set.new
-    end
-
     # Software that will not be symlinked into the `brew --prefix` and will
     # only live in its Cellar. Other formulae can depend on it and Homebrew
-    # will add the necessary includes, libraries, and other paths while
+    # will add the necessary includes, libraries and other paths while
     # building that other formula.
     #
     # Keg-only formulae are not in your PATH and are not seen by compilers
     # if you build your own software outside of Homebrew. This way, we
     # don't shadow software provided by macOS.
-    # <pre>keg_only :provided_by_macos</pre>
-    # <pre>keg_only :versioned_formulae</pre>
-    # <pre>keg_only "because I want it so"</pre>
+    #
+    # ### Examples
+    #
+    # ```ruby
+    # keg_only :provided_by_macos
+    # ```
+    #
+    # ```ruby
+    # keg_only :versioned_formulae
+    # ```
+    #
+    # ```ruby
+    # keg_only "because I want it so"
+    # ```
+    #
+    # @api public
     def keg_only(reason, explanation = "")
       @keg_only_reason = KegOnlyReason.new(reason, explanation)
     end
 
     # Pass `:skip` to this method to disable post-install stdlib checking.
+    #
+    # @api public
     def cxxstdlib_check(check_type)
       define_method(:skip_cxxstdlib_check?) { true } if check_type == :skip
     end
 
     # Marks the {Formula} as failing with a particular compiler so it will fall back to others.
+    #
+    # ### Examples
+    #
     # For Apple compilers, this should be in the format:
-    # <pre>fails_with :clang do
+    #
+    # ```ruby
+    # fails_with :clang do
     #   build 600
     #   cause "multiple configure and compile errors"
-    # end</pre>
+    # end
+    # ```
     #
-    # The block may be omitted, and if present the build may be omitted;
+    # The block may be omitted and if present, the build may be omitted;
     # if so, then the compiler will not be allowed for *all* versions.
     #
     # `major_version` should be the major release number only, for instance
@@ -2987,9 +4047,13 @@ def cxxstdlib_check(check_type)
     # For example, if a bug is only triggered on GCC 7.1 but is not
     # encountered on 7.2:
     #
-    # <pre>fails_with :gcc => '7' do
+    # ```ruby
+    # fails_with :gcc => '7' do
     #   version '7.1'
-    # end</pre>
+    # end
+    # ```
+    #
+    # @api public
     def fails_with(compiler, &block)
       specs.each { |spec| spec.fails_with(compiler, &block) }
     end
@@ -3002,13 +4066,14 @@ def fails_with(compiler, &block)
     # explicitly use that compiler in a formula's {#install} block,
     # rather than implicitly finding a suitable compiler with `needs`.
     #
-    # @see #fails_with
+    # @see .fails_with
+    #
+    # @api public
     def needs(*standards)
       specs.each { |spec| spec.needs(*standards) }
     end
 
     # A test is required for new formulae and makes us happy.
-    # @return [Boolean]
     #
     # The block will create, run in and delete a temporary directory.
     #
@@ -3018,56 +4083,76 @@ def needs(*standards)
     # and `foo --version` or `foo --help` are bad tests.
     # However, a bad test is better than no test at all.
     #
-    # @see https://docs.brew.sh/Formula-Cookbook#add-a-test-to-the-formula Tests
+    # ### Examples
     #
-    # <pre>(testpath/"test.file").write <<~EOS
+    # ```ruby
+    # (testpath/"test.file").write <<~EOS
     #   writing some test file, if you need to
     # EOS
-    # assert_equal "OK", shell_output("test_command test.file").strip</pre>
+    # assert_equal "OK", shell_output("test_command test.file").strip
+    # ```
     #
     # Need complete control over stdin, stdout?
-    # <pre>require "open3"
+    #
+    # ```ruby
+    # require "open3"
     # Open3.popen3("#{bin}/example", "argument") do |stdin, stdout, _|
     #   stdin.write("some text")
     #   stdin.close
     #   assert_equal "result", stdout.read
-    # end</pre>
+    # end
+    # ```
     #
     # The test will fail if it returns false, or if an exception is raised.
     # Failed assertions and failed `system` commands will raise exceptions.
+    #
+    # @see https://docs.brew.sh/Formula-Cookbook#add-a-test-to-the-formula Tests
+    # @return [Boolean]
+    # @api public
     def test(&block)
       define_method(:test, &block)
     end
 
-    # @!attribute [w] livecheck
     # {Livecheck} can be used to check for newer versions of the software.
     # This method evaluates the DSL specified in the livecheck block of the
     # {Formula} (if it exists) and sets the instance variables of a {Livecheck}
     # object accordingly. This is used by `brew livecheck` to check for newer
     # versions of the software.
     #
-    # <pre>livecheck do
+    # ### Example
+    #
+    # ```ruby
+    # livecheck do
     #   skip "Not maintained"
     #   url "https://example.com/foo/releases"
     #   regex /foo-(\d+(?:\.\d+)+)\.tar/
-    # end</pre>
+    # end
+    # ```
+    #
+    # @!attribute [w] livecheck
+    # @api public
     def livecheck(&block)
-      @livecheck ||= Livecheck.new(self)
       return @livecheck unless block
 
       @livecheckable = true
       @livecheck.instance_eval(&block)
     end
 
-    # @!attribute [w] service
     # Service can be used to define services.
     # This method evaluates the DSL specified in the service block of the
     # {Formula} (if it exists) and sets the instance variables of a Service
-    # object accordingly. This is used by `brew install` to generate a plist.
+    # object accordingly. This is used by `brew install` to generate a service file.
+    #
+    # ### Example
     #
-    # <pre>service do
+    # ```ruby
+    # service do
     #   run [opt_bin/"foo"]
-    # end</pre>
+    # end
+    # ```
+    #
+    # @!attribute [w] service
+    # @api public
     def service(&block)
       return @service_block unless block
 
@@ -3077,20 +4162,31 @@ def service(&block)
     # Defines whether the {Formula}'s bottle can be used on the given Homebrew
     # installation.
     #
-    # For example, if the bottle requires the Xcode CLT to be installed a
+    # ### Examples
+    #
+    # If the bottle requires the Xcode CLT to be installed a
     # {Formula} would declare:
-    # <pre>pour_bottle? do
+    #
+    # ```ruby
+    # pour_bottle? do
     #   reason "The bottle needs the Xcode CLT to be installed."
     #   satisfy { MacOS::CLT.installed? }
-    # end</pre>
+    # end
+    # ```
     #
     # If `satisfy` returns `false` then a bottle will not be used and instead
     # the {Formula} will be built from source and `reason` will be printed.
     #
     # Alternatively, a preset reason can be passed as a symbol:
-    # <pre>pour_bottle? only_if: :clt_installed</pre>
+    #
+    # ```ruby
+    # pour_bottle? only_if: :clt_installed
+    # ```
+    #
+    # @api public
     def pour_bottle?(only_if: nil, &block)
       @pour_bottle_check = PourBottleCheck.new(self)
+      @pour_bottle_only_if = only_if
 
       if only_if.present? && block.present?
         raise ArgumentError, "Do not pass both a preset condition and a block to `pour_bottle?`"
@@ -3100,20 +4196,22 @@ def pour_bottle?(only_if: nil, &block)
       when :clt_installed
         lambda do |_|
           on_macos do
-            T.cast(self, PourBottleCheck).reason(+<<~EOS)
+            T.bind(self, PourBottleCheck)
+            reason(+<<~EOS)
               The bottle needs the Apple Command Line Tools to be installed.
                 You can install them, if desired, with:
                   xcode-select --install
             EOS
-            T.cast(self, PourBottleCheck).satisfy { MacOS::CLT.installed? }
+            satisfy { MacOS::CLT.installed? }
           end
         end
       when :default_prefix
         lambda do |_|
-          T.cast(self, PourBottleCheck).reason(+<<~EOS)
-            The bottle needs to be installed into #{Homebrew::DEFAULT_PREFIX}.
+          T.bind(self, PourBottleCheck)
+          reason(<<~EOS)
+            The bottle (and many others) needs to be installed into #{Homebrew::DEFAULT_PREFIX}.
           EOS
-          T.cast(self, PourBottleCheck).satisfy { HOMEBREW_PREFIX.to_s == Homebrew::DEFAULT_PREFIX }
+          satisfy { HOMEBREW_PREFIX.to_s == Homebrew::DEFAULT_PREFIX }
         end
       else
         raise ArgumentError, "Invalid preset `pour_bottle?` condition" if only_if.present?
@@ -3125,10 +4223,20 @@ def pour_bottle?(only_if: nil, &block)
     # Deprecates a {Formula} (on the given date) so a warning is
     # shown on each installation. If the date has not yet passed the formula
     # will not be deprecated.
-    # <pre>deprecate! date: "2020-08-27", because: :unmaintained</pre>
-    # <pre>deprecate! date: "2020-08-27", because: "has been replaced by foo"</pre>
+    #
+    # ### Examples
+    #
+    # ```ruby
+    # deprecate! date: "2020-08-27", because: :unmaintained
+    # ```
+    #
+    # ```ruby
+    # deprecate! date: "2020-08-27", because: "has been replaced by foo"
+    # ```
+    #
     # @see https://docs.brew.sh/Deprecating-Disabling-and-Removing-Formulae
-    # @see DeprecateDisable::DEPRECATE_DISABLE_REASONS
+    # @see DeprecateDisable::FORMULA_DEPRECATE_DISABLE_REASONS
+    # @api public
     def deprecate!(date:, because:)
       @deprecation_date = Date.parse(date)
       return if @deprecation_date > Date.today
@@ -3139,19 +4247,21 @@ def deprecate!(date:, because:)
 
     # Whether this {Formula} is deprecated (i.e. warns on installation).
     # Defaults to false.
-    # @return [Boolean]
     # @see .deprecate!
+    sig { returns(T::Boolean) }
     def deprecated?
       @deprecated == true
     end
 
     # The date that this {Formula} was or becomes deprecated.
     # Returns `nil` if no date is specified.
+    #
     # @return Date
     # @see .deprecate!
     attr_reader :deprecation_date
 
     # The reason for deprecation of a {Formula}.
+    #
     # @return [nil] if no reason was provided or the formula is not deprecated.
     # @return [String, Symbol]
     # @see .deprecate!
@@ -3160,10 +4270,20 @@ def deprecated?
     # Disables a {Formula} (on the given date) so it cannot be
     # installed. If the date has not yet passed the formula
     # will be deprecated instead of disabled.
-    # <pre>disable! date: "2020-08-27", because: :does_not_build</pre>
-    # <pre>disable! date: "2020-08-27", because: "has been replaced by foo"</pre>
+    #
+    # ### Examples
+    #
+    # ```ruby
+    # disable! date: "2020-08-27", because: :does_not_build
+    # ```
+    #
+    # ```ruby
+    # disable! date: "2020-08-27", because: "has been replaced by foo"
+    # ```
+    #
     # @see https://docs.brew.sh/Deprecating-Disabling-and-Removing-Formulae
-    # @see DeprecateDisable::DEPRECATE_DISABLE_REASONS
+    # @see DeprecateDisable::FORMULA_DEPRECATE_DISABLE_REASONS
+    # @api public
     def disable!(date:, because:)
       @disable_date = Date.parse(date)
 
@@ -3179,51 +4299,45 @@ def disable!(date:, because:)
 
     # Whether this {Formula} is disabled (i.e. cannot be installed).
     # Defaults to false.
-    # @return [Boolean]
+    #
     # @see .disable!
+    sig { returns(T::Boolean) }
     def disabled?
       @disabled == true
     end
 
     # The date that this {Formula} was or becomes disabled.
     # Returns `nil` if no date is specified.
+    #
     # @return Date
     # @see .disable!
     attr_reader :disable_date
 
     # The reason this {Formula} is disabled.
     # Returns `nil` if no reason was provided or the formula is not disabled.
+    #
     # @return [String, Symbol]
     # @see .disable!
     attr_reader :disable_reason
 
     # Permit overwriting certain files while linking.
     #
-    # Sometimes we accidentally install files outside prefix. Once we fix that,
+    # ### Examples
+    #
+    # Sometimes we accidentally install files outside the prefix. Once we fix that,
     # users will get a link conflict error. Overwrite those files with:
-    # <pre>link_overwrite "bin/foo", "lib/bar"</pre>
-    # <pre>link_overwrite "share/man/man1/baz-*"</pre>
+    #
+    # ```ruby
+    # link_overwrite "bin/foo", "lib/bar"
+    # ```
+    #
+    # ```ruby
+    # link_overwrite "share/man/man1/baz-*"
+    # ```
     def link_overwrite(*paths)
       paths.flatten!
       link_overwrite_paths.merge(paths)
     end
-
-    # @private
-    def link_overwrite_paths
-      @link_overwrite_paths ||= Set.new
-    end
-
-    # Permit links to certain libraries that don't exist. Available on Linux only.
-    def ignore_missing_libraries(*)
-      return if Homebrew::SimulateSystem.linux?
-
-      raise FormulaSpecificationError, "#{__method__} is available on Linux only"
-    end
-
-    # @private
-    def allowed_missing_libraries
-      @allowed_missing_libraries ||= Set.new
-    end
   end
 end
 
diff --git a/Library/Homebrew/formula.rbi b/Library/Homebrew/formula.rbi
index fc8d6c255ca12..85be1bf27e4fb 100644
--- a/Library/Homebrew/formula.rbi
+++ b/Library/Homebrew/formula.rbi
@@ -3,52 +3,6 @@
 # This file provides definitions for Forwardable#delegate, which is currently not supported by Sorbet.
 
 class Formula
-  def bottle_defined?; end
-  def bottle_tag?(tag = nil); end
-  def bottled?(tag = nil); end
-  def bottle_specification; end
-  def downloader; end
-
-  def desc; end
-  def license; end
-  def homepage; end
-  def livecheck; end
-  def livecheckable?; end
-  def service?; end
-  def version; end
-
-  def resource; end
-  def deps; end
-  def uses_from_macos_elements; end
-  def requirements; end
-  def cached_download; end
-  def clear_cache; end
-  def options; end
-  def deprecated_options; end
-  def deprecated_flags; end
-  def option_defined?; end
-  def compiler_failures; end
-
-  def plist_manual; end
-  def plist_startup; end
-  def pour_bottle_check_unsatisfied_reason; end
-  def keg_only_reason; end
-  def deprecated?; end
-  def deprecation_date; end
-  def deprecation_reason; end
-  def disabled?; end
-  def disable_date; end
-  def disable_reason; end
-
-  def pinnable?; end
-  def pinned?; end
-  def pinned_version; end
-  def pin; end
-  def unpin; end
-
-  def env; end
-  def conflicts; end
-
   def self.on_system_blocks_exist?; end
   # This method is included by `OnSystem`
   def self.on_macos(&block); end
diff --git a/Library/Homebrew/formula_assertions.rb b/Library/Homebrew/formula_assertions.rb
index 382bb085ca247..ed24d9d1b5957 100644
--- a/Library/Homebrew/formula_assertions.rb
+++ b/Library/Homebrew/formula_assertions.rb
@@ -1,25 +1,30 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
   # Helper functions available in formula `test` blocks.
-  #
-  # @api private
   module Assertions
     include Context
+    extend T::Helpers
+
+    requires_ancestor { Kernel }
 
     require "minitest"
     require "minitest/assertions"
     include ::Minitest::Assertions
 
+    sig { params(assertions: Integer).returns(Integer) }
     attr_writer :assertions
 
+    sig { returns(Integer) }
     def assertions
-      @assertions ||= 0
+      @assertions ||= T.let(0, T.nilable(Integer))
     end
 
-    # Returns the output of running cmd, and asserts the exit status.
+    # Returns the output of running cmd and asserts the exit status.
+    #
     # @api public
+    sig { params(cmd: T.any(Pathname, String), result: Integer).returns(String) }
     def shell_output(cmd, result = 0)
       ohai cmd
       output = `#{cmd}`
@@ -30,9 +35,11 @@ def shell_output(cmd, result = 0)
       raise
     end
 
-    # Returns the output of running the cmd with the optional input, and
+    # Returns the output of running the cmd with the optional input and
     # optionally asserts the exit status.
+    #
     # @api public
+    sig { params(cmd: T.any(String, Pathname), input: T.nilable(String), result: T.nilable(Integer)).returns(String) }
     def pipe_output(cmd, input = nil, result = nil)
       ohai cmd
       output = IO.popen(cmd, "w+") do |pipe|
diff --git a/Library/Homebrew/formula_auditor.rb b/Library/Homebrew/formula_auditor.rb
index a06941104d432..ff23f1f9dd541 100644
--- a/Library/Homebrew/formula_auditor.rb
+++ b/Library/Homebrew/formula_auditor.rb
@@ -1,16 +1,17 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "deprecate_disable"
-require "formula_text_auditor"
+require "formula_versions"
+require "formula_name_cask_token_auditor"
 require "resource_auditor"
+require "utils/shared_audits"
 
 module Homebrew
   # Auditor for checking common violations in {Formula}e.
-  #
-  # @api private
   class FormulaAuditor
     include FormulaCellarChecks
+    include Utils::Curl
 
     attr_reader :formula, :text, :problems, :new_formula_problems
 
@@ -31,37 +32,39 @@ def initialize(formula, options = {})
       @core_tap = formula.tap&.core_tap? || options[:core_tap]
       @problems = []
       @new_formula_problems = []
-      @text = FormulaTextAuditor.new(formula.path)
-      @specs = %w[stable head].map { |s| formula.send(s) }.compact
+      @text = formula.path.open("rb", &:read)
+      @specs = %w[stable head].filter_map { |s| formula.send(s) }
       @spdx_license_data = options[:spdx_license_data]
       @spdx_exception_data = options[:spdx_exception_data]
+      @tap_audit = options[:tap_audit]
+      @previous_committed = {}
+      @newest_committed = {}
     end
 
     def audit_style
       return unless @style_offenses
 
       @style_offenses.each do |offense|
-        correction_status = "#{Tty.green}[Corrected]#{Tty.reset} " if offense.corrected?
-
         cop_name = "#{offense.cop_name}: " if @display_cop_names
-        message = "#{cop_name}#{correction_status}#{offense.message}"
+        message = "#{cop_name}#{offense.message}"
 
-        problem message, location: offense.location
+        problem message, location: offense.location, corrected: offense.corrected?
       end
     end
 
     def audit_file
       if formula.core_formula? && @versioned_formula
+        unversioned_name = formula.name.gsub(/@.*$/, "")
+
+        # ignore when an unversioned formula doesn't exist after an explicit rename
+        return if formula.tap.formula_renames.key?(unversioned_name)
+
+        # build this ourselves as we want e.g. homebrew/core to be present
+        full_name = "#{formula.tap}/#{unversioned_name}"
+
         unversioned_formula = begin
-          # build this ourselves as we want e.g. homebrew/core to be present
-          full_name = if formula.tap
-            "#{formula.tap}/#{formula.name}"
-          else
-            formula.name
-          end
-          Formulary.factory(full_name.gsub(/@.*$/, "")).path
-        rescue FormulaUnavailableError, TapFormulaAmbiguityError,
-               TapFormulaWithOldnameAmbiguityError
+          Formulary.factory(full_name).path
+        rescue FormulaUnavailableError, TapFormulaAmbiguityError
           Pathname.new formula.path.to_s.gsub(/@.*\.rb$/, ".rb")
         end
         unless unversioned_formula.exist?
@@ -72,7 +75,7 @@ def audit_file
             !@versioned_formula &&
             (versioned_formulae = formula.versioned_formulae - [formula]) &&
             versioned_formulae.present?
-        versioned_aliases, unversioned_aliases = formula.aliases.partition { |a| a =~ /.@\d/ }
+        versioned_aliases, unversioned_aliases = formula.aliases.partition { |a| /.@\d/.match?(a) }
         _, last_alias_version = versioned_formulae.map(&:name).last.split("@")
 
         alias_name_major = "#{formula.name}@#{formula.version.major}"
@@ -122,6 +125,14 @@ def audit_file
           EOS
         end
       end
+
+      return if !formula.core_formula? || formula.path == formula.tap.new_formula_path(formula.name)
+
+      problem <<~EOS
+        Formula is in wrong path:
+          Expected: #{formula.tap.new_formula_path(formula.name)}
+            Actual: #{formula.path}
+      EOS
     end
 
     def self.aliases
@@ -129,20 +140,14 @@ def self.aliases
       @aliases ||= Formula.aliases + Formula.tap_aliases
     end
 
-    SYNCED_VERSIONS_FORMULAE_FILE = "synced_versions_formulae.json"
-
     def audit_synced_versions_formulae
-      return unless formula.tap
-
-      synced_versions_formulae_file = formula.tap.path/SYNCED_VERSIONS_FORMULAE_FILE
-      return unless synced_versions_formulae_file.file?
+      return unless formula.synced_with_other_formulae?
 
       name = formula.name
       version = formula.version
 
-      synced_versions_formulae = JSON.parse(synced_versions_formulae_file.read)
-      synced_versions_formulae.each do |synced_version_formulae|
-        next unless synced_version_formulae.include? name
+      formula.tap.synced_versions_formulae.each do |synced_version_formulae|
+        next unless synced_version_formulae.include?(name)
 
         synced_version_formulae.each do |synced_formula|
           next if synced_formula == name
@@ -156,10 +161,14 @@ def audit_synced_versions_formulae
       end
     end
 
-    def audit_formula_name
+    def audit_name
       name = formula.name
 
-      problem "Formula name '#{name}' must not contain uppercase letters." if name != name.downcase
+      name_auditor = Homebrew::FormulaNameCaskTokenAuditor.new(name)
+      if (errors = name_auditor.errors).any?
+        problem "Formula name '#{name}' must not contain #{errors.to_sentence(two_words_connector: " or ",
+                                                                              last_word_connector: " or ")}."
+      end
 
       return unless @strict
       return unless @core_tap
@@ -190,10 +199,37 @@ def audit_formula_name
       "LGPL-3.0" => ["LGPL-3.0-only", "LGPL-3.0-or-later"],
     }.freeze
 
+    # The following licenses are non-free/open based on multiple sources (e.g. Debian, Fedora, FSF, OSI, ...)
+    INCOMPATIBLE_LICENSES = [
+      "Aladdin",    # https://www.gnu.org/licenses/license-list.html#Aladdin
+      "CPOL-1.02",  # https://www.gnu.org/licenses/license-list.html#cpol
+      "gSOAP-1.3b", # https://salsa.debian.org/ellert/gsoap/-/blob/master/debian/copyright
+      "JSON",       # https://wiki.debian.org/DFSGLicenses#JSON_evil_license
+      "MS-LPL",     # https://github.com/spdx/license-list-XML/issues/1432#issuecomment-1077680709
+      "OPL-1.0",    # https://wiki.debian.org/DFSGLicenses#Open_Publication_License_.28OPL.29_v1.0
+    ].freeze
+    INCOMPATIBLE_LICENSE_PREFIXES = [
+      "BUSL",     # https://spdx.org/licenses/BUSL-1.1.html#notes
+      "CC-BY-NC", # https://people.debian.org/~bap/dfsg-faq.html#no_commercial
+      "Elastic",  # https://www.elastic.co/licensing/elastic-license#Limitations
+      "SSPL",     # https://fedoraproject.org/wiki/Licensing/SSPL#License_Notes
+    ].freeze
+
     def audit_license
       if formula.license.present?
         licenses, exceptions = SPDX.parse_license_expression formula.license
 
+        incompatible_licenses = licenses.select do |license|
+          license.to_s.start_with?(*INCOMPATIBLE_LICENSE_PREFIXES) || INCOMPATIBLE_LICENSES.include?(license.to_s)
+        end
+        if incompatible_licenses.present? && @core_tap
+          problem <<~EOS
+            Formula #{formula.name} contains incompatible licenses: #{incompatible_licenses}.
+            Formulae in homebrew/core must either use a Debian Free Software Guidelines license
+            or be released into the public domain. See #{Formatter.url("https://docs.brew.sh/License-Guidelines")}
+          EOS
+        end
+
         non_standard_licenses = licenses.reject { |license| SPDX.valid_license? license }
         if non_standard_licenses.present?
           problem <<~EOS
@@ -202,7 +238,7 @@ def audit_license
           EOS
         end
 
-        if @strict
+        if @strict || @core_tap
           deprecated_licenses = licenses.select do |license|
             SPDX.deprecated_license? license
           end
@@ -229,7 +265,9 @@ def audit_license
         user, repo = get_repo_data(%r{https?://github\.com/([^/]+)/([^/]+)/?.*})
         return if user.blank?
 
-        github_license = GitHub.get_repo_license(user, repo)
+        tag = SharedAudits.github_tag_from_url(formula.stable.url)
+        tag ||= formula.stable.specs[:tag]
+        github_license = GitHub.get_repo_license(user, repo, ref: tag)
         return unless github_license
         return if (licenses + ["NOASSERTION"]).include?(github_license)
         return if PERMITTED_LICENSE_MISMATCHES[github_license]&.any? { |license| licenses.include? license }
@@ -237,7 +275,7 @@ def audit_license
 
         problem "Formula license #{licenses} does not match GitHub license #{Array(github_license)}."
 
-      elsif @new_formula && @core_tap
+      elsif @core_tap && !formula.disabled?
         problem "Formulae in homebrew/core must specify a license."
       end
     end
@@ -246,29 +284,27 @@ def audit_deps
       @specs.each do |spec|
         # Check for things we don't like to depend on.
         # We allow non-Homebrew installs whenever possible.
-        spec.deps.each do |dep|
+        spec.declared_deps.each do |dep|
           begin
             dep_f = dep.to_formula
           rescue TapFormulaUnavailableError
             # Don't complain about missing cross-tap dependencies
             next
           rescue FormulaUnavailableError
-            problem "Can't find dependency '#{dep.name.inspect}'."
+            problem "Can't find dependency '#{dep.name}'."
             next
           rescue TapFormulaAmbiguityError
-            problem "Ambiguous dependency '#{dep.name.inspect}'."
-            next
-          rescue TapFormulaWithOldnameAmbiguityError
-            problem "Ambiguous oldname dependency '#{dep.name.inspect}'."
+            problem "Ambiguous dependency '#{dep.name}'."
             next
           end
 
-          if dep_f.oldname && dep.name.split("/").last == dep_f.oldname
+          if dep_f.oldnames.include?(dep.name.split("/").last)
             problem "Dependency '#{dep.name}' was renamed; use new name '#{dep_f.name}'."
           end
 
           if @core_tap &&
              @new_formula &&
+             !dep.uses_from_macos? &&
              dep_f.keg_only? &&
              dep_f.keg_only_reason.provided_by_macos? &&
              dep_f.keg_only_reason.applicable? &&
@@ -300,15 +336,33 @@ def audit_deps
 
           next unless @core_tap
 
-          unless dep_f.tap.core_tap?
+          if dep_f.tap.nil?
+            problem <<~EOS
+              Dependency '#{dep.name}' does not exist in any tap.
+            EOS
+          elsif !dep_f.tap.core_tap?
             problem <<~EOS
               Dependency '#{dep.name}' is not in homebrew/core. Formulae in homebrew/core
               should not have dependencies in external taps.
             EOS
           end
 
+          if dep_f.deprecated? && !formula.deprecated? && !formula.disabled?
+            problem <<~EOS
+              Dependency '#{dep.name}' is deprecated but has un-deprecated dependents. Either
+              un-deprecate '#{dep.name}' or deprecate it and all of its dependents.
+            EOS
+          end
+
+          if dep_f.disabled? && !formula.disabled?
+            problem <<~EOS
+              Dependency '#{dep.name}' is disabled but has un-disabled dependents. Either
+              un-disable '#{dep.name}' or disable it and all of its dependents.
+            EOS
+          end
+
           # we want to allow uses_from_macos for aliases but not bare dependencies
-          if self.class.aliases.include?(dep.name) && spec.uses_from_macos_names.exclude?(dep.name)
+          if self.class.aliases.include?(dep.name) && !dep.uses_from_macos?
             problem "Dependency '#{dep.name}' is an alias; use the canonical name '#{dep.to_formula.full_name}'."
           end
 
@@ -329,7 +383,27 @@ def audit_deps
 
       # The number of conflicts on Linux is absurd.
       # TODO: remove this and check these there too.
-      return if OS.linux? && !Homebrew::EnvConfig.simulate_macos_on_linux?
+      return if Homebrew::SimulateSystem.simulating_or_running_on_linux?
+
+      # Skip the versioned dependencies conflict audit for *-staging branches.
+      # This will allow us to migrate dependents of formulae like Python or OpenSSL
+      # gradually over separate PRs which target a *-staging branch. See:
+      #   https://github.com/Homebrew/homebrew-core/pull/134260
+      ignore_formula_conflict, staging_formula =
+        if @tap_audit && (github_event_path = ENV.fetch("GITHUB_EVENT_PATH", nil)).present?
+          event_payload = JSON.parse(File.read(github_event_path))
+          base_info = event_payload.dig("pull_request", "base").to_h # handle `nil`
+
+          # We need to read the head ref from `GITHUB_EVENT_PATH` because
+          # `git branch --show-current` returns `master` on PR branches.
+          staging_branch = base_info["ref"]&.end_with?("-staging")
+          homebrew_owned_repo = base_info.dig("repo", "owner", "login") == "Homebrew"
+          homebrew_core_pr = base_info.dig("repo", "name") == "homebrew-core"
+          # Support staging branches named `formula-staging` or `formula@version-staging`.
+          base_formula = base_info["ref"]&.split(/-|@/, 2)&.first
+
+          [staging_branch && homebrew_owned_repo && homebrew_core_pr, base_formula]
+        end
 
       recursive_runtime_formulae = formula.runtime_formula_dependencies(undeclared: false)
       version_hash = {}
@@ -337,6 +411,11 @@ def audit_deps
       recursive_runtime_formulae.each do |f|
         name = f.name
         unversioned_name, = name.split("@")
+        next if ignore_formula_conflict && unversioned_name == staging_formula
+        # Allow use of the full versioned name (e.g. `python@3.99`) or an unversioned alias (`python`).
+        next if formula.tap&.audit_exception :versioned_formula_dependent_conflicts_allowlist, name
+        next if formula.tap&.audit_exception :versioned_formula_dependent_conflicts_allowlist, unversioned_name
+
         version_hash[unversioned_name] ||= Set.new
         version_hash[unversioned_name] << name
         next if version_hash[unversioned_name].length < 2
@@ -349,7 +428,7 @@ def audit_deps
       return if formula.disabled?
 
       return if formula.deprecated? &&
-                formula.deprecation_reason != DeprecateDisable::DEPRECATE_DISABLE_REASONS[:versioned_formula]
+                formula.deprecation_reason != DeprecateDisable::FORMULA_DEPRECATE_DISABLE_REASONS[:versioned_formula]
 
       problem <<~EOS
         #{formula.full_name} contains conflicting version recursive dependencies:
@@ -366,15 +445,16 @@ def audit_conflicts
 
         problem "Formula should not conflict with itself" if formula == conflicting_formula
 
-        if tap.formula_renames.key?(conflict.name) || tap.aliases.include?(conflict.name)
+        if T.must(tap).formula_renames.key?(conflict.name) || T.must(tap).aliases.include?(conflict.name)
           problem "Formula conflict should be declared using " \
                   "canonical name (#{conflicting_formula.name}) instead of #{conflict.name}"
         end
 
-        reverse_conflict_found = false
+        reverse_conflict_found = T.let(false, T::Boolean)
         conflicting_formula.conflicts.each do |reverse_conflict|
           reverse_conflict_formula = Formulary.factory(reverse_conflict.name)
-          if tap.formula_renames.key?(reverse_conflict.name) || tap.aliases.include?(reverse_conflict.name)
+          if T.must(tap).formula_renames.key?(reverse_conflict.name) ||
+             T.must(tap).aliases.include?(reverse_conflict.name)
             problem "Formula #{conflicting_formula.name} conflict should be declared using " \
                     "canonical name (#{reverse_conflict_formula.name}) instead of #{reverse_conflict.name}"
           end
@@ -389,13 +469,24 @@ def audit_conflicts
         next
       rescue FormulaUnavailableError
         problem "Can't find conflicting formula #{conflict.name.inspect}."
-      rescue TapFormulaAmbiguityError, TapFormulaWithOldnameAmbiguityError
+      rescue TapFormulaAmbiguityError
         problem "Ambiguous conflicting formula #{conflict.name.inspect}."
       end
     end
 
+    def audit_gcc_dependency
+      return unless @core_tap
+      return unless Homebrew::SimulateSystem.simulating_or_running_on_linux?
+      return unless linux_only_gcc_dep?(formula)
+      # https://github.com/Homebrew/homebrew-core/pull/171634
+      # https://github.com/nghttp2/nghttp2/issues/2194
+      return if formula.tap&.audit_exception(:linux_only_gcc_dependency_allowlist, formula.name)
+
+      problem "Formulae in homebrew/core should not have a Linux-only dependency on GCC."
+    end
+
     def audit_postgresql
-      return unless formula.name == "postgresql"
+      return if formula.name != "postgresql"
       return unless @core_tap
 
       major_version = formula.version.major.to_i
@@ -410,26 +501,40 @@ def audit_postgresql
     end
 
     def audit_glibc
-      return if formula.name != "glibc"
       return unless @core_tap
+      return if formula.name != "glibc"
+      # Also allow LINUX_GLIBC_NEXT_CI_VERSION for when we're upgrading.
+      return if [OS::LINUX_GLIBC_CI_VERSION, OS::LINUX_GLIBC_NEXT_CI_VERSION].include?(formula.version.to_s)
 
-      version = formula.version.to_s
-      return if version == OS::CI_GLIBC_VERSION
-
-      problem "The glibc version must be #{version}, as this is the version used by our CI on Linux. " \
-              "Glibc is for users who have a system Glibc with a lower version, " \
-              "which allows them to use our Linux bottles, which were compiled against system Glibc on CI."
+      problem "The glibc version must be #{OS::LINUX_GLIBC_CI_VERSION}, as needed by our CI on Linux. " \
+              "The glibc formula is for users who have a system glibc with a lower version, " \
+              "which allows them to use our Linux bottles, which were compiled against system glibc on CI."
     end
 
-    ELASTICSEARCH_KIBANA_RELICENSED_VERSION = "7.11"
+    RELICENSED_FORMULAE_VERSIONS = {
+      "boundary"           => "0.14",
+      "consul"             => "1.17",
+      "elasticsearch"      => "7.11",
+      "kibana"             => "7.11",
+      "nomad"              => "1.7",
+      "packer"             => "1.10",
+      "redis"              => "7.4",
+      "terraform"          => "1.6",
+      "vagrant"            => "2.4",
+      "vagrant-completion" => "2.4",
+      "vault"              => "1.15",
+      "waypoint"           => "0.12",
+    }.freeze
 
-    def audit_elasticsearch_kibana
-      return if formula.name != "elasticsearch" && formula.name != "kibana"
+    def audit_relicensed_formulae
+      return unless RELICENSED_FORMULAE_VERSIONS.key? formula.name
       return unless @core_tap
-      return if formula.version < Version.new(ELASTICSEARCH_KIBANA_RELICENSED_VERSION)
 
-      problem "Elasticsearch and Kibana were relicensed to a non-open-source license from version 7.11. " \
-              "They must not be upgraded to version 7.11 or newer."
+      relicensed_version = Version.new(RELICENSED_FORMULAE_VERSIONS[formula.name])
+      return if formula.version < relicensed_version
+
+      problem "#{formula.name} was relicensed to a non-open-source license from version #{relicensed_version}. " \
+              "It must not be upgraded to version #{relicensed_version} or newer."
     end
 
     def audit_versioned_keg_only
@@ -457,21 +562,20 @@ def audit_homepage
 
       return unless DevelopmentTools.curl_handles_most_https_certificates?
 
-      use_homebrew_curl = false
-      %w[Stable HEAD].each do |name|
-        spec_name = name.downcase.to_sym
-        next unless (spec = formula.send(spec_name))
+      use_homebrew_curl = [:stable, :head].any? do |spec_name|
+        next false unless (spec = formula.send(spec_name))
 
-        use_homebrew_curl = spec.using == :homebrew_curl
-        break if use_homebrew_curl
+        spec.using == :homebrew_curl
       end
 
-      if (http_content_problem = curl_check_http_content(homepage,
-                                                         "homepage URL",
-                                                         user_agents:       [:browser, :default],
-                                                         check_content:     true,
-                                                         strict:            @strict,
-                                                         use_homebrew_curl: use_homebrew_curl))
+      if (http_content_problem = curl_check_http_content(
+        homepage,
+        SharedAudits::URL_TYPE_HOMEPAGE,
+        user_agents:       [:browser, :default],
+        check_content:     true,
+        strict:            @strict,
+        use_homebrew_curl:,
+      ))
         problem http_content_problem
       end
     end
@@ -486,6 +590,56 @@ def audit_bottle_spec
       new_formula_problem "New formulae in homebrew/core should not have a `bottle do` block"
     end
 
+    def audit_eol
+      return unless @online
+      return unless @core_tap
+
+      return if formula.deprecated? || formula.disabled?
+
+      name = if formula.versioned_formula?
+        formula.name.split("@").first
+      else
+        formula.name
+      end
+
+      return if formula.tap&.audit_exception :eol_date_blocklist, name
+
+      metadata = SharedAudits.eol_data(name, formula.version.major.to_s)
+      metadata ||= SharedAudits.eol_data(name, formula.version.major_minor.to_s)
+
+      return if metadata.blank? || (eol = metadata["eol"]).blank?
+
+      is_eol = eol == true
+      is_eol ||= eol.is_a?(String) && (eol_date = Date.parse(eol)) <= Date.today
+      return unless is_eol
+
+      message = "Product is EOL"
+      message += " since #{eol_date}" if eol_date.present?
+      message += ", see #{Formatter.url("https://endoflife.date/#{name}")}"
+
+      problem message
+    end
+
+    def audit_wayback_url
+      return unless @core_tap
+      return if formula.deprecated? || formula.disabled?
+
+      regex = %r{^https?://web\.archive\.org}
+      problem_prefix = "Formula with a Internet Archive Wayback Machine"
+
+      problem "#{problem_prefix} `url` should be deprecated with `:repo_removed`" if regex.match?(formula.stable.url)
+
+      if regex.match?(formula.homepage)
+        problem "#{problem_prefix} `homepage` should find an alternative `homepage` or be deprecated."
+      end
+
+      return unless formula.head
+
+      return unless regex.match?(formula.head.url)
+
+      problem "Remove Internet Archive Wayback Machine `head` URL"
+    end
+
     def audit_github_repository_archived
       return if formula.deprecated? || formula.disabled?
 
@@ -570,7 +724,7 @@ def audit_specs
 
         ra = ResourceAuditor.new(
           spec, spec_name,
-          online: @online, strict: @strict, only: @only, except: except,
+          online: @online, strict: @strict, only: @only, except:,
           use_homebrew_curl: spec.using == :homebrew_curl
         ).audit
         ra.problems.each do |message|
@@ -611,7 +765,7 @@ def audit_specs
       return unless stable.url
 
       version = stable.version
-      problem "Stable: version (#{version}) is set to a string without a digit" if version.to_s !~ /\d/
+      problem "Stable: version (#{version}) is set to a string without a digit" unless /\d/.match?(version.to_s)
 
       stable_version_string = version.to_s
       if stable_version_string.start_with?("HEAD")
@@ -622,7 +776,7 @@ def audit_specs
       stable_url_minor_version = stable_url_version.minor.to_i
 
       formula_suffix = stable.version.patch.to_i
-      throttled_rate = formula.tap&.audit_exception(:throttled_formulae, formula.name)
+      throttled_rate = formula.livecheck.throttle
       if throttled_rate && formula_suffix.modulo(throttled_rate).nonzero?
         problem "should only be updated every #{throttled_rate} releases on multiples of #{throttled_rate}"
       end
@@ -638,10 +792,10 @@ def audit_specs
       when %r{download\.gnome\.org/sources}, %r{ftp\.gnome\.org/pub/GNOME/sources}i
         version_prefix = stable.version.major_minor
         return if formula.tap&.audit_exception :gnome_devel_allowlist, formula.name, version_prefix
-        return if stable_url_version < Version.create("1.0")
+        return if stable_url_version < Version.new("1.0")
         # All minor versions are stable in the new GNOME version scheme (which starts at version 40.0)
         # https://discourse.gnome.org/t/new-gnome-versioning-scheme/4235
-        return if stable_url_version >= Version.create("40.0")
+        return if stable_url_version >= Version.new("40.0")
         return if stable_url_minor_version.even?
 
         problem "#{stable.version} is a development release"
@@ -651,31 +805,49 @@ def audit_specs
         problem "#{stable.version} is a development release"
 
       when %r{https?://gitlab\.com/([\w-]+)/([\w-]+)}
-        owner = Regexp.last_match(1)
-        repo = Regexp.last_match(2)
+        owner = T.must(Regexp.last_match(1))
+        repo = T.must(Regexp.last_match(2))
 
         tag = SharedAudits.gitlab_tag_from_url(url)
         tag ||= stable.specs[:tag]
-        tag ||= stable.version
+        tag ||= stable.version.to_s
 
         if @online
-          error = SharedAudits.gitlab_release(owner, repo, tag, formula: formula)
+          error = SharedAudits.gitlab_release(owner, repo, tag, formula:)
           problem error if error
         end
       when %r{^https://github.com/([\w-]+)/([\w-]+)}
-        owner = Regexp.last_match(1)
-        repo = Regexp.last_match(2)
+        owner = T.must(Regexp.last_match(1))
+        repo = T.must(Regexp.last_match(2))
         tag = SharedAudits.github_tag_from_url(url)
         tag ||= formula.stable.specs[:tag]
 
-        if @online
-          error = SharedAudits.github_release(owner, repo, tag, formula: formula)
+        if @online && !tag.nil?
+          error = SharedAudits.github_release(owner, repo, tag, formula:)
           problem error if error
         end
       end
     end
 
-    def audit_revision_and_version_scheme
+    def audit_stable_version
+      return unless @git
+      return unless formula.tap # skip formula not from core or any taps
+      return unless formula.tap.git? # git log is required
+      return if formula.stable.blank?
+
+      current_version = formula.stable.version
+      current_version_scheme = formula.version_scheme
+
+      previous_committed, newest_committed = committed_version_info
+
+      if !newest_committed[:version].nil? &&
+         current_version < newest_committed[:version] &&
+         current_version_scheme == previous_committed[:version_scheme]
+        problem "stable version should not decrease (from #{newest_committed[:version]} to #{current_version})"
+      end
+    end
+
+    def audit_revision
       new_formula_problem("New formulae should not define a revision.") if @new_formula && !formula.revision.zero?
 
       return unless @git
@@ -683,87 +855,69 @@ def audit_revision_and_version_scheme
       return unless formula.tap.git? # git log is required
       return if formula.stable.blank?
 
-      fv = FormulaVersions.new(formula)
-
       current_version = formula.stable.version
-      current_checksum = formula.stable.checksum
-      current_version_scheme = formula.version_scheme
       current_revision = formula.revision
-      current_url = formula.stable.url
 
-      previous_version = nil
-      previous_version_scheme = nil
-      previous_revision = nil
+      previous_committed, newest_committed = committed_version_info
 
-      newest_committed_version = nil
-      newest_committed_checksum = nil
-      newest_committed_revision = nil
-      newest_committed_url = nil
+      if (previous_committed[:version] != newest_committed[:version] ||
+         current_version != newest_committed[:version]) &&
+         !current_revision.zero? &&
+         current_revision == newest_committed[:revision] &&
+         current_revision == previous_committed[:revision]
+        problem "'revision #{current_revision}' should be removed"
+      elsif current_version == previous_committed[:version] &&
+            !previous_committed[:revision].nil? &&
+            current_revision < previous_committed[:revision]
+        problem "revision should not decrease (from #{previous_committed[:revision]} to #{current_revision})"
+      elsif newest_committed[:revision] &&
+            current_revision > (newest_committed[:revision] + 1)
+        problem "revisions should only increment by 1"
+      end
+    end
 
-      fv.rev_list("origin/master") do |rev|
-        begin
-          fv.formula_at_revision(rev) do |f|
-            stable = f.stable
-            next if stable.blank?
+    def audit_version_scheme
+      return unless @git
+      return unless formula.tap # skip formula not from core or any taps
+      return unless formula.tap.git? # git log is required
+      return if formula.stable.blank?
 
-            previous_version = stable.version
-            previous_checksum = stable.checksum
-            previous_version_scheme = f.version_scheme
-            previous_revision = f.revision
+      current_version_scheme = formula.version_scheme
 
-            newest_committed_version ||= previous_version
-            newest_committed_checksum ||= previous_checksum
-            newest_committed_revision ||= previous_revision
-            newest_committed_url ||= stable.url
-          end
-        rescue MacOSVersionError
-          break
-        end
+      previous_committed, = committed_version_info
+
+      return if previous_committed[:version_scheme].nil?
 
-        break if previous_version && current_version != previous_version
-        break if previous_revision && current_revision != previous_revision
+      if current_version_scheme < previous_committed[:version_scheme]
+        problem "version_scheme should not decrease (from #{previous_committed[:version_scheme]} " \
+                "to #{current_version_scheme})"
+      elsif current_version_scheme > (previous_committed[:version_scheme] + 1)
+        problem "version_schemes should only increment by 1"
       end
+    end
 
-      if current_version == newest_committed_version &&
-         current_url == newest_committed_url &&
-         current_checksum != newest_committed_checksum &&
-         current_checksum.present? && newest_committed_checksum.present?
+    def audit_unconfirmed_checksum_change
+      return unless @git
+      return unless formula.tap # skip formula not from core or any taps
+      return unless formula.tap.git? # git log is required
+      return if formula.stable.blank?
+
+      current_version = formula.stable.version
+      current_checksum = formula.stable.checksum
+      current_url = formula.stable.url
+
+      _, newest_committed = committed_version_info
+
+      if current_version == newest_committed[:version] &&
+         current_url == newest_committed[:url] &&
+         current_checksum != newest_committed[:checksum] &&
+         current_checksum.present? && newest_committed[:checksum].present?
         problem(
           "stable sha256 changed without the url/version also changing; " \
           "please create an issue upstream to rule out malicious " \
           "circumstances and to find out why the file changed.",
         )
       end
-
-      if !newest_committed_version.nil? &&
-         current_version < newest_committed_version &&
-         current_version_scheme == previous_version_scheme
-        problem "stable version should not decrease (from #{newest_committed_version} to #{current_version})"
-      end
-
-      unless previous_version_scheme.nil?
-        if current_version_scheme < previous_version_scheme
-          problem "version_scheme should not decrease (from #{previous_version_scheme} " \
-                  "to #{current_version_scheme})"
-        elsif current_version_scheme > (previous_version_scheme + 1)
-          problem "version_schemes should only increment by 1"
-        end
-      end
-
-      if (previous_version != newest_committed_version ||
-         current_version != newest_committed_version) &&
-         !current_revision.zero? &&
-         current_revision == newest_committed_revision &&
-         current_revision == previous_revision
-        problem "'revision #{current_revision}' should be removed"
-      elsif current_version == previous_version &&
-            !previous_revision.nil? &&
-            current_revision < previous_revision
-        problem "revision should not decrease (from #{previous_revision} to #{current_revision})"
-      elsif newest_committed_revision &&
-            current_revision > (newest_committed_revision + 1)
-        problem "revisions should only increment by 1"
-      end
     end
 
     def audit_text
@@ -773,7 +927,7 @@ def audit_text
       [formula.bin, formula.sbin].each do |dir|
         next unless dir.exist?
 
-        bin_names += dir.children.map(&:basename).map(&:to_s)
+        bin_names += dir.children.map { |child| child.basename.to_s }
       end
       shell_commands = ["system", "shell_output", "pipe_output"]
       bin_names.each do |name|
@@ -794,7 +948,7 @@ def audit_reverse_migration
       problem <<~EOS
         #{formula.name} seems to be listed in tap_migrations.json!
         Please remove #{formula.name} from present tap & tap_migrations.json
-        before submitting it to Homebrew/homebrew-#{formula.tap.repo}.
+        before submitting it to Homebrew/homebrew-#{formula.tap.repository}.
       EOS
     end
 
@@ -809,6 +963,11 @@ def audit_prefix_has_contents
       EOS
     end
 
+    def audit_deprecate_disable
+      error = SharedAudits.check_deprecate_disable_reason(formula)
+      problem error if error
+    end
+
     def quote_dep(dep)
       dep.is_a?(Symbol) ? dep.inspect : "'#{dep}'"
     end
@@ -832,16 +991,83 @@ def audit
 
     private
 
-    def problem(message, location: nil)
-      @problems << ({ message: message, location: location })
+    def problem(message, location: nil, corrected: false)
+      @problems << ({ message:, location:, corrected: })
     end
 
-    def new_formula_problem(message, location: nil)
-      @new_formula_problems << ({ message: message, location: location })
+    def new_formula_problem(message, location: nil, corrected: false)
+      @new_formula_problems << ({ message:, location:, corrected: })
     end
 
     def head_only?(formula)
       formula.head && formula.stable.nil?
     end
+
+    def linux_only_gcc_dep?(formula)
+      odie "`#linux_only_gcc_dep?` works only on Linux!" if Homebrew::SimulateSystem.simulating_or_running_on_macos?
+      return false if formula.deps.map(&:name).exclude?("gcc")
+
+      variations = formula.to_hash_with_variations["variations"]
+      # The formula has no variations, so all OS-version-arch triples depend on GCC.
+      return false if variations.blank?
+
+      MacOSVersion::SYMBOLS.keys.product(OnSystem::ARCH_OPTIONS).each do |os, arch|
+        bottle_tag = Utils::Bottles::Tag.new(system: os, arch:)
+        next unless bottle_tag.valid_combination?
+
+        variation_dependencies = variations.dig(bottle_tag.to_sym, "dependencies")
+        # This variation either:
+        #   1. does not exist
+        #   2. has no variation-specific dependencies
+        # In either case, it matches Linux. We must check for `nil` because an empty
+        # array indicates that this variation does not depend on GCC.
+        return false if variation_dependencies.nil?
+        # We found a non-Linux variation that depends on GCC.
+        return false if variation_dependencies.include?("gcc")
+      end
+
+      true
+    end
+
+    def committed_version_info
+      return [] unless @git
+      return [] unless formula.tap # skip formula not from core or any taps
+      return [] unless formula.tap.git? # git log is required
+      return [] if formula.stable.blank?
+      return [@previous_committed, @newest_committed] if @previous_committed.present? || @newest_committed.present?
+
+      current_version = formula.stable.version
+      current_revision = formula.revision
+
+      fv = FormulaVersions.new(formula)
+      fv.rev_list("origin/HEAD") do |revision, path|
+        begin
+          fv.formula_at_revision(revision, path) do |f|
+            stable = f.stable
+            next if stable.blank?
+
+            @previous_committed[:version] = stable.version
+            @previous_committed[:checksum] = stable.checksum
+            @previous_committed[:version_scheme] = f.version_scheme
+            @previous_committed[:revision] = f.revision
+
+            @newest_committed[:version] ||= @previous_committed[:version]
+            @newest_committed[:checksum] ||= @previous_committed[:checksum]
+            @newest_committed[:revision] ||= @previous_committed[:revision]
+            @newest_committed[:url] ||= stable.url
+          end
+        rescue MacOSVersion::Error
+          break
+        end
+
+        break if @previous_committed[:version] && current_version != @previous_committed[:version]
+        break if @previous_committed[:revision] && current_revision != @previous_committed[:revision]
+      end
+
+      @previous_committed.compact!
+      @newest_committed.compact!
+
+      [@previous_committed, @newest_committed]
+    end
   end
 end
diff --git a/Library/Homebrew/formula_cellar_checks.rb b/Library/Homebrew/formula_cellar_checks.rb
index 8045e2c968452..26e4f2f0665b8 100644
--- a/Library/Homebrew/formula_cellar_checks.rb
+++ b/Library/Homebrew/formula_cellar_checks.rb
@@ -1,13 +1,25 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 require "utils/shell"
 
 # Checks to perform on a formula's cellar.
-#
-# @api private
 module FormulaCellarChecks
+  extend T::Helpers
+
+  abstract!
+  requires_ancestor { Kernel }
+
+  sig { abstract.returns(Formula) }
+  def formula; end
+
+  sig { abstract.params(output: T.nilable(String)).void }
+  def problem_if_output(output); end
+
+  sig { params(bin: Pathname).returns(T.nilable(String)) }
   def check_env_path(bin)
+    return if Homebrew::EnvConfig.no_env_hints?
+
     # warn the user if stuff was installed outside of their PATH
     return unless bin.directory?
     return if bin.children.empty?
@@ -24,6 +36,7 @@ def check_env_path(bin)
     EOS
   end
 
+  sig { returns(T.nilable(String)) }
   def check_manpages
     # Check for man pages that aren't in share/man
     return unless (formula.prefix/"man").directory?
@@ -35,6 +48,7 @@ def check_manpages
     EOS
   end
 
+  sig { returns(T.nilable(String)) }
   def check_infopages
     # Check for info pages that aren't in share/info
     return unless (formula.prefix/"info").directory?
@@ -46,6 +60,7 @@ def check_infopages
     EOS
   end
 
+  sig { returns(T.nilable(String)) }
   def check_jars
     return unless formula.lib.directory?
 
@@ -65,11 +80,13 @@ def check_jars
 
   VALID_LIBRARY_EXTENSIONS = %w[.a .jnilib .la .o .so .jar .prl .pm .sh].freeze
 
+  sig { params(filename: Pathname).returns(T::Boolean) }
   def valid_library_extension?(filename)
     VALID_LIBRARY_EXTENSIONS.include? filename.extname
   end
   alias generic_valid_library_extension? valid_library_extension?
 
+  sig { returns(T.nilable(String)) }
   def check_non_libraries
     return unless formula.lib.directory?
 
@@ -88,6 +105,7 @@ def check_non_libraries
     EOS
   end
 
+  sig { params(bin: Pathname).returns(T.nilable(String)) }
   def check_non_executables(bin)
     return unless bin.directory?
 
@@ -101,6 +119,7 @@ def check_non_executables(bin)
     EOS
   end
 
+  sig { params(bin: Pathname).returns(T.nilable(String)) }
   def check_generic_executables(bin)
     return unless bin.directory?
 
@@ -118,19 +137,21 @@ def check_generic_executables(bin)
     EOS
   end
 
+  sig { params(lib: Pathname).returns(T.nilable(String)) }
   def check_easy_install_pth(lib)
-    pth_found = Dir["#{lib}/python{2.7,3}*/site-packages/easy-install.pth"].map { |f| File.dirname(f) }
+    pth_found = Dir["#{lib}/python3*/site-packages/easy-install.pth"].map { |f| File.dirname(f) }
     return if pth_found.empty?
 
     <<~EOS
       'easy-install.pth' files were found.
       These '.pth' files are likely to cause link conflicts.
-      Please invoke `setup.py` using 'Language::Python.setup_install_args'.
+      Easy install is now deprecated, do not use it.
       The offending files are:
         #{pth_found * "\n  "}
     EOS
   end
 
+  sig { params(share: Pathname, name: String).returns(T.nilable(String)) }
   def check_elisp_dirname(share, name)
     return unless (share/"emacs/site-lisp").directory?
     # Emacs itself can do what it wants
@@ -149,6 +170,7 @@ def check_elisp_dirname(share, name)
     EOS
   end
 
+  sig { params(share: Pathname, name: String).returns(T.nilable(String)) }
   def check_elisp_root(share, name)
     return unless (share/"emacs/site-lisp").directory?
     # Emacs itself can do what it wants
@@ -169,6 +191,7 @@ def check_elisp_root(share, name)
     EOS
   end
 
+  sig { params(lib: Pathname, deps: Dependencies).returns(T.nilable(String)) }
   def check_python_packages(lib, deps)
     return unless lib.directory?
 
@@ -176,20 +199,20 @@ def check_python_packages(lib, deps)
                      .select(&:directory?)
                      .map(&:basename)
 
-    pythons = lib_subdirs.map do |p|
+    pythons = lib_subdirs.filter_map do |p|
       match = p.to_s.match(/^python(\d+\.\d+)$/)
       next if match.blank?
       next if match.captures.blank?
 
       match.captures.first
-    end.compact
+    end
 
     return if pythons.blank?
 
-    python_deps = deps.map(&:name)
+    python_deps = deps.to_a
+                      .map(&:name)
                       .grep(/^python(@.*)?$/)
-                      .map { |d| Formula[d].version.to_s[/^\d+\.\d+/] }
-                      .compact
+                      .filter_map { |d| Formula[d].version.to_s[/^\d+\.\d+/] }
 
     return if python_deps.blank?
     return if pythons.any? { |v| python_deps.include? v }
@@ -205,6 +228,7 @@ def check_python_packages(lib, deps)
     EOS
   end
 
+  sig { params(prefix: Pathname).returns(T.nilable(String)) }
   def check_shim_references(prefix)
     return unless prefix.directory?
 
@@ -228,11 +252,12 @@ def check_shim_references(prefix)
     EOS
   end
 
+  sig { params(prefix: Pathname, plist: Pathname).returns(T.nilable(String)) }
   def check_plist(prefix, plist)
     return unless prefix.directory?
 
     plist = begin
-      Plist.parse_xml(plist)
+      Plist.parse_xml(plist, marshal: false)
     rescue
       nil
     end
@@ -263,6 +288,7 @@ def check_plist(prefix, plist)
     EOS
   end
 
+  sig { params(name: String, keg_only: T::Boolean).returns(T.nilable(String)) }
   def check_python_symlinks(name, keg_only)
     return unless keg_only
     return unless name.start_with? "python"
@@ -275,15 +301,16 @@ def check_python_symlinks(name, keg_only)
     "Python formulae that are keg-only should not create `pip3` and `wheel3` symlinks."
   end
 
+  sig { params(formula: Formula).returns(T.nilable(String)) }
   def check_service_command(formula)
     return unless formula.prefix.directory?
     return unless formula.service?
-
-    return "Service command blank" if formula.service.command.blank?
+    return unless formula.service.command?
 
     "Service command does not exist" unless File.exist?(formula.service.command.first)
   end
 
+  sig { params(formula: Formula).returns(T.nilable(String)) }
   def check_cpuid_instruction(formula)
     # Checking for `cpuid` only makes sense on Intel:
     # https://en.wikipedia.org/wiki/CPUID
@@ -313,37 +340,56 @@ def check_cpuid_instruction(formula)
       cpuid_instruction?(file, objdump)
     end
 
+    hardlinks = Set.new
+    return if formula.lib.directory? && formula.lib.find.any? do |pn|
+      next false if pn.symlink? || pn.directory? || pn.extname != ".a"
+      next false unless hardlinks.add? [pn.stat.dev, pn.stat.ino]
+
+      cpuid_instruction?(pn, objdump)
+    end
+
     "No `cpuid` instruction detected. #{formula} should not use `ENV.runtime_cpu_detection`."
   end
 
+  sig { params(formula: Formula).returns(T.nilable(String)) }
   def check_binary_arches(formula)
     return unless formula.prefix.directory?
-    # There is no `binary_executable_or_library_files` method for the generic OS
-    return if !OS.mac? && !OS.linux?
 
     keg = Keg.new(formula.prefix)
     mismatches = {}
     keg.binary_executable_or_library_files.each do |file|
       farch = file.arch
-      mismatches[file] = farch unless farch == Hardware::CPU.arch
+      mismatches[file] = farch if farch != Hardware::CPU.arch
     end
     return if mismatches.empty?
 
     compatible_universal_binaries, mismatches = mismatches.partition do |file, arch|
       arch == :universal && file.archs.include?(Hardware::CPU.arch)
-    end.map(&:to_h) # To prevent transformation into nested arrays
+    end
+    # To prevent transformation into nested arrays
+    compatible_universal_binaries = compatible_universal_binaries.to_h
+    mismatches = mismatches.to_h
 
-    universal_binaries_expected = if formula.tap.present? && formula.tap.core_tap?
-      formula.tap.audit_exception(:universal_binary_allowlist, formula.name)
+    universal_binaries_expected = if (formula_tap = formula.tap).present? && formula_tap.core_tap?
+      formula_tap.audit_exception(:universal_binary_allowlist, formula.name)
     else
       true
     end
-    return if mismatches.empty? && universal_binaries_expected
 
-    mismatches_expected = formula.tap.blank? ||
-                          formula.tap.audit_exception(:mismatched_binary_allowlist, formula.name)
-    return if compatible_universal_binaries.empty? && mismatches_expected
+    mismatches_expected = (formula_tap = formula.tap).blank? ||
+                          formula_tap.audit_exception(:mismatched_binary_allowlist, formula.name)
+    mismatches_expected = [mismatches_expected] if mismatches_expected.is_a?(String)
+    if mismatches_expected.is_a?(Array)
+      glob_flags = File::FNM_DOTMATCH | File::FNM_EXTGLOB | File::FNM_PATHNAME
+      mismatches.delete_if do |file, _arch|
+        mismatches_expected.any? { |pattern| file.fnmatch?("#{formula.prefix.realpath}/#{pattern}", glob_flags) }
+      end
+      mismatches_expected = false
+      return if mismatches.empty? && compatible_universal_binaries.empty?
+    end
 
+    return if mismatches.empty? && universal_binaries_expected
+    return if compatible_universal_binaries.empty? && mismatches_expected
     return if universal_binaries_expected && mismatches_expected
 
     s = ""
@@ -367,8 +413,9 @@ def check_binary_arches(formula)
     s
   end
 
+  sig { void }
   def audit_installed
-    @new_formula ||= false
+    @new_formula ||= T.let(false, T.nilable(T::Boolean))
 
     problem_if_output(check_manpages)
     problem_if_output(check_infopages)
@@ -384,7 +431,7 @@ def audit_installed
     problem_if_output(check_elisp_root(formula.share, formula.name))
     problem_if_output(check_python_packages(formula.lib, formula.deps))
     problem_if_output(check_shim_references(formula.prefix))
-    problem_if_output(check_plist(formula.prefix, formula.plist))
+    problem_if_output(check_plist(formula.prefix, formula.launchd_service_path))
     problem_if_output(check_python_symlinks(formula.name, formula.keg_only?))
     problem_if_output(check_cpuid_instruction(formula))
     problem_if_output(check_binary_arches(formula))
@@ -393,12 +440,14 @@ def audit_installed
 
   private
 
+  sig { params(dir: T.any(Pathname, String), pattern: String).returns(T::Array[String]) }
   def relative_glob(dir, pattern)
     File.directory?(dir) ? Dir.chdir(dir) { Dir[pattern] } : []
   end
 
-  def cpuid_instruction?(file, objdump = "objdump")
-    @instruction_column_index ||= {}
+  sig { params(file: T.any(Pathname, String), objdump: Pathname).returns(T::Boolean) }
+  def cpuid_instruction?(file, objdump)
+    @instruction_column_index ||= T.let({}, T.nilable(T::Hash[Pathname, Integer]))
     @instruction_column_index[objdump] ||= begin
       objdump_version = Utils.popen_read(objdump, "--version")
 
@@ -410,7 +459,7 @@ def cpuid_instruction?(file, objdump = "objdump")
       end
     end
 
-    has_cpuid_instruction = false
+    has_cpuid_instruction = T.let(false, T::Boolean)
     Utils.popen_read(objdump, "--disassemble", file) do |io|
       until io.eof?
         instruction = io.readline.split("\t")[@instruction_column_index[objdump]]&.strip
diff --git a/Library/Homebrew/formula_creator.rb b/Library/Homebrew/formula_creator.rb
index bca36922c5f4a..0a110481867b2 100644
--- a/Library/Homebrew/formula_creator.rb
+++ b/Library/Homebrew/formula_creator.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "digest"
@@ -6,144 +6,148 @@
 
 module Homebrew
   # Class for generating a formula from a template.
-  #
-  # @api private
   class FormulaCreator
-    extend T::Sig
-
-    attr_reader :args, :url, :sha256, :desc, :homepage
-    attr_accessor :name, :version, :tap, :path, :mode, :license
+    attr_accessor :name
+
+    sig {
+      params(name: T.nilable(String), version: T.nilable(String), tap: T.nilable(String), url: String,
+             mode: T.nilable(Symbol), license: T.nilable(String), fetch: T::Boolean, head: T::Boolean).void
+    }
+    def initialize(name, version, tap:, url:, mode:, license:, fetch:, head:)
+      @name = name
+      @version = Version.new(version) if version
+      @tap = Tap.fetch(tap || "homebrew/core")
+      @url = url
+      @mode = mode
+      @license = license
+      @fetch = fetch
+      @head = head
+    end
 
-    def initialize(args)
-      @args = args
+    sig { void }
+    def verify
+      raise TapUnavailableError, @tap.name unless @tap.installed?
     end
 
-    def url=(url)
-      @url = url
-      path = Pathname.new(url)
-      if @name.nil?
-        case url
-        when %r{github\.com/(\S+)/(\S+)\.git}
-          @user = Regexp.last_match(1)
-          @name = Regexp.last_match(2)
-          @head = true
-          @github = true
-        when %r{github\.com/(\S+)/(\S+)/(archive|releases)/}
-          @user = Regexp.last_match(1)
-          @name = Regexp.last_match(2)
-          @github = true
-        else
-          @name = path.basename.to_s[/(.*?)[-_.]?#{Regexp.escape(path.version.to_s)}/, 1]
-        end
-      end
-      update_path
-      @version = if @version
-        Version.create(@version)
+    sig { params(url: String).returns(T.nilable(String)) }
+    def self.name_from_url(url)
+      stem = Pathname.new(url).stem
+      # special cases first
+      if stem.start_with? "index.cgi"
+        # gitweb URLs e.g. http://www.codesrc.com/gitweb/index.cgi?p=libzipper.git;a=summary
+        stem.rpartition("=").last
+      elsif url =~ %r{github\.com/\S+/(\S+)/(archive|releases)/}
+        # e.g. https://github.com/stella-emu/stella/releases/download/6.7/stella-6.7-src.tar.xz
+        Regexp.last_match(1)
       else
-        Version.detect(url)
+        # e.g. http://digit-labs.org/files/tools/synscan/releases/synscan-5.02.tar.gz
+        pathver = Version.parse(stem).to_s
+        stem.sub(/[-_.]?#{Regexp.escape(pathver)}$/, "")
       end
     end
 
-    def update_path
-      return if @name.nil? || @tap.nil?
-
-      @path = Formulary.path "#{@tap}/#{@name}"
-    end
-
-    def fetch?
-      !args.no_fetch?
+    sig { void }
+    def parse_url
+      @name = FormulaCreator.name_from_url(@url) if @name.blank?
+      odebug "name_from_url: #{@name}"
+      @version = Version.detect(@url) if @version.nil?
+
+      case @url
+      when %r{github\.com/(\S+)/(\S+)\.git}
+        @head = true
+        user = Regexp.last_match(1)
+        repo = Regexp.last_match(2)
+        @github = GitHub.repository(user, repo) if @fetch
+      when %r{github\.com/(\S+)/(\S+)/(archive|releases)/}
+        user = Regexp.last_match(1)
+        repo = Regexp.last_match(2)
+        @github = GitHub.repository(user, repo) if @fetch
+      end
     end
 
-    def head?
-      @head || args.HEAD?
-    end
+    sig { returns(Pathname) }
+    def write_formula!
+      raise ArgumentError, "name is blank!" if @name.blank?
+      raise ArgumentError, "tap is blank!" if @tap.blank?
 
-    def generate!
+      path = @tap.new_formula_path(@name)
       raise "#{path} already exists" if path.exist?
 
-      if version.nil? || version.null?
-        opoo "Version cannot be determined from URL."
-        puts "You'll need to add an explicit 'version' to the formula."
-      elsif fetch?
-        unless head?
+      if @version.nil? || @version.null?
+        odie "Version cannot be determined from URL. Explicitly set the version with `--set-version` instead."
+      end
+
+      if @fetch
+        unless @head
           r = Resource.new
-          r.url(url)
-          r.version(version)
+          r.url(@url)
           r.owner = self
           @sha256 = r.fetch.sha256 if r.download_strategy == CurlDownloadStrategy
         end
 
-        if @user && @name
-          begin
-            metadata = GitHub.repository(@user, @name)
-            @desc = metadata["description"]
-            @homepage = metadata["homepage"]
-            @license = metadata["license"]["spdx_id"] if metadata["license"]
-          rescue GitHub::API::HTTPNotFoundError
-            # If there was no repository found assume the network connection is at
-            # fault rather than the input URL.
-            nil
-          end
+        if @github
+          @desc = @github["description"]
+          @homepage = @github["homepage"]
+          @license = @github["license"]["spdx_id"] if @github["license"]
         end
       end
 
       path.dirname.mkpath
       path.write ERB.new(template, trim_mode: ">").result(binding)
+      path
     end
 
     sig { returns(String) }
     def template
+      # FIXME: https://github.com/errata-ai/vale/issues/818
+      # <!-- vale off -->
       <<~ERB
         # Documentation: https://docs.brew.sh/Formula-Cookbook
         #                https://rubydoc.brew.sh/Formula
         # PLEASE REMOVE ALL GENERATED COMMENTS BEFORE SUBMITTING YOUR PULL REQUEST!
-        <% if mode == :node %>
-        require "language/node"
-
-        <% end %>
         class #{Formulary.class_s(name)} < Formula
-        <% if mode == :python %>
+        <% if @mode == :python %>
           include Language::Python::Virtualenv
 
         <% end %>
-          desc "#{desc}"
-          homepage "#{homepage}"
-        <% unless head? %>
-          url "#{url}"
-        <% unless version.nil? or version.detected_from_url? %>
-          version "#{version}"
+          desc "#{@desc}"
+          homepage "#{@homepage}"
+        <% unless @head %>
+          url "#{@url}"
+        <% unless @version.detected_from_url? %>
+          version "#{@version}"
         <% end %>
-          sha256 "#{sha256}"
+          sha256 "#{@sha256}"
         <% end %>
-          license "#{license}"
-        <% if head? %>
-          head "#{url}"
+          license "#{@license}"
+        <% if @head %>
+          head "#{@url}"
         <% end %>
 
-        <% if mode == :cmake %>
+        <% if @mode == :cmake %>
           depends_on "cmake" => :build
-        <% elsif mode == :crystal %>
+        <% elsif @mode == :crystal %>
           depends_on "crystal" => :build
-        <% elsif mode == :go %>
+        <% elsif @mode == :go %>
           depends_on "go" => :build
-        <% elsif mode == :meson %>
+        <% elsif @mode == :meson %>
           depends_on "meson" => :build
           depends_on "ninja" => :build
-        <% elsif mode == :node %>
+        <% elsif @mode == :node %>
           depends_on "node"
-        <% elsif mode == :perl %>
+        <% elsif @mode == :perl %>
           uses_from_macos "perl"
-        <% elsif mode == :python %>
+        <% elsif @mode == :python %>
           depends_on "python"
-        <% elsif mode == :ruby %>
+        <% elsif @mode == :ruby %>
           uses_from_macos "ruby"
-        <% elsif mode == :rust %>
+        <% elsif @mode == :rust %>
           depends_on "rust" => :build
-        <% elsif mode.nil? %>
+        <% elsif @mode.nil? %>
           # depends_on "cmake" => :build
         <% end %>
 
-        <% if mode == :perl %>
+        <% if @mode == :perl %>
           # Additional dependency
           # resource "" do
           #   url ""
@@ -152,42 +156,39 @@ class #{Formulary.class_s(name)} < Formula
 
         <% end %>
           def install
-            # ENV.deparallelize  # if your formula fails when building in parallel
-        <% if mode == :cmake %>
+        <% if @mode == :cmake %>
             system "cmake", "-S", ".", "-B", "build", *std_cmake_args
             system "cmake", "--build", "build"
             system "cmake", "--install", "build"
-        <% elsif mode == :autotools %>
-            # Remove unrecognized options if warned by configure
+        <% elsif @mode == :autotools %>
+            # Remove unrecognized options if they cause configure to fail
             # https://rubydoc.brew.sh/Formula.html#std_configure_args-instance_method
-            system "./configure", *std_configure_args, "--disable-silent-rules"
+            system "./configure", "--disable-silent-rules", *std_configure_args
             system "make", "install" # if this fails, try separate make/make install steps
-        <% elsif mode == :crystal %>
+        <% elsif @mode == :crystal %>
             system "shards", "build", "--release"
             bin.install "bin/#{name}"
-        <% elsif mode == :go %>
+        <% elsif @mode == :go %>
             system "go", "build", *std_go_args(ldflags: "-s -w")
-        <% elsif mode == :meson %>
-            mkdir "build" do
-              system "meson", *std_meson_args, ".."
-              system "ninja", "-v"
-              system "ninja", "install", "-v"
-            end
-        <% elsif mode == :node %>
-            system "npm", "install", *Language::Node.std_npm_install_args(libexec)
+        <% elsif @mode == :meson %>
+            system "meson", "setup", "build", *std_meson_args
+            system "meson", "compile", "-C", "build", "--verbose"
+            system "meson", "install", "-C", "build"
+        <% elsif @mode == :node %>
+            system "npm", "install", *std_npm_args
             bin.install_symlink Dir["\#{libexec}/bin/*"]
-        <% elsif mode == :perl %>
+        <% elsif @mode == :perl %>
             ENV.prepend_create_path "PERL5LIB", libexec/"lib/perl5"
             ENV.prepend_path "PERL5LIB", libexec/"lib"
 
-            # Stage additional dependency (Makefile.PL style)
+            # Stage additional dependency (`Makefile.PL` style).
             # resource("").stage do
             #   system "perl", "Makefile.PL", "INSTALL_BASE=\#{libexec}"
             #   system "make"
             #   system "make", "install"
             # end
 
-            # Stage additional dependency (Build.PL style)
+            # Stage additional dependency (`Build.PL` style).
             # resource("").stage do
             #   system "perl", "Build.PL", "--install_base", libexec
             #   system "./Build"
@@ -196,20 +197,20 @@ def install
 
             bin.install name
             bin.env_script_all_files(libexec/"bin", PERL5LIB: ENV["PERL5LIB"])
-        <% elsif mode == :python %>
+        <% elsif @mode == :python %>
             virtualenv_install_with_resources
-        <% elsif mode == :ruby %>
+        <% elsif @mode == :ruby %>
             ENV["GEM_HOME"] = libexec
             system "gem", "build", "\#{name}.gemspec"
-            system "gem", "install", "\#{name}-\#{version}.gem"
+            system "gem", "install", "\#{name}-\#{@version}.gem"
             bin.install libexec/"bin/\#{name}"
             bin.env_script_all_files(libexec/"bin", GEM_HOME: ENV["GEM_HOME"])
-        <% elsif mode == :rust %>
+        <% elsif @mode == :rust %>
             system "cargo", "install", *std_cargo_args
         <% else %>
-            # Remove unrecognized options if warned by configure
+            # Remove unrecognized options if they cause configure to fail
             # https://rubydoc.brew.sh/Formula.html#std_configure_args-instance_method
-            system "./configure", *std_configure_args, "--disable-silent-rules"
+            system "./configure", "--disable-silent-rules", *std_configure_args
             # system "cmake", "-S", ".", "-B", "build", *std_cmake_args
         <% end %>
           end
@@ -223,11 +224,12 @@ def install
             # to `brew install` such as `--HEAD` also need to be provided to `brew test`.
             #
             # The installed folder is not in the path, so use the entire path to any
-            # executables being tested: `system "\#{bin}/program", "do", "something"`.
+            # executables being tested: `system bin/"program", "do", "something"`.
             system "false"
           end
         end
       ERB
+      # <!-- vale on -->
     end
   end
 end
diff --git a/Library/Homebrew/formula_free_port.rb b/Library/Homebrew/formula_free_port.rb
index 91e94da6094f6..d47b8a40a00bb 100644
--- a/Library/Homebrew/formula_free_port.rb
+++ b/Library/Homebrew/formula_free_port.rb
@@ -1,15 +1,14 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "socket"
 
 module Homebrew
   # Helper function for finding a free port.
-  #
-  # @api private
   module FreePort
     # Returns a free port.
     # @api public
+    sig { returns(Integer) }
     def free_port
       server = TCPServer.new 0
       _, port, = server.addr
diff --git a/Library/Homebrew/formula_info.rb b/Library/Homebrew/formula_info.rb
index 1059fb5c2ad59..7ec8734e4e5d4 100644
--- a/Library/Homebrew/formula_info.rb
+++ b/Library/Homebrew/formula_info.rb
@@ -1,9 +1,7 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 # Formula information drawn from an external `brew info --json` call.
-#
-# @api private
 class FormulaInfo
   # The whole info structure parsed from the JSON.
   attr_accessor :info
@@ -57,7 +55,7 @@ def any_bottle_tag
 
   def version(spec_type)
     version_str = info["versions"][spec_type.to_s]
-    version_str && Version.create(version_str)
+    version_str && Version.new(version_str)
   end
 
   def pkg_version(spec_type = :stable)
diff --git a/Library/Homebrew/formula_installer.rb b/Library/Homebrew/formula_installer.rb
index 03486bb730ec6..c26e12b424013 100644
--- a/Library/Homebrew/formula_installer.rb
+++ b/Library/Homebrew/formula_installer.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 require "formula"
@@ -22,25 +22,64 @@
 require "deprecate_disable"
 require "unlink"
 require "service"
+require "attestation"
+require "sbom"
+require "utils/fork"
 
 # Installer for a formula.
-#
-# @api private
 class FormulaInstaller
-  extend T::Sig
-
   include FormulaCellarChecks
-  extend Predicable
+  extend Attrable
+
+  ETC_VAR_DIRS = T.let([HOMEBREW_PREFIX/"etc", HOMEBREW_PREFIX/"var"].freeze, T::Array[Pathname])
 
+  sig { override.returns(Formula) }
   attr_reader :formula
 
-  attr_accessor :options, :link_keg
+  sig { returns(T::Hash[String, T::Hash[String, String]]) }
+  attr_reader :bottle_tab_runtime_dependencies
+
+  sig { returns(Options) }
+  attr_accessor :options
+
+  sig { returns(T::Boolean) }
+  attr_accessor :link_keg
 
   attr_predicate :installed_as_dependency?, :installed_on_request?
   attr_predicate :show_summary_heading?, :show_header?
   attr_predicate :force_bottle?, :ignore_deps?, :only_deps?, :interactive?, :git?, :force?, :overwrite?, :keep_tmp?
+  attr_predicate :debug_symbols?
   attr_predicate :verbose?, :debug?, :quiet?
 
+  sig {
+    params(
+      formula:                    Formula,
+      link_keg:                   T::Boolean,
+      installed_as_dependency:    T::Boolean,
+      installed_on_request:       T::Boolean,
+      show_header:                T::Boolean,
+      build_bottle:               T::Boolean,
+      skip_post_install:          T::Boolean,
+      force_bottle:               T::Boolean,
+      bottle_arch:                T.nilable(String),
+      ignore_deps:                T::Boolean,
+      only_deps:                  T::Boolean,
+      include_test_formulae:      T::Array[Formula],
+      build_from_source_formulae: T::Array[Formula],
+      env:                        T.nilable(String),
+      git:                        T::Boolean,
+      interactive:                T::Boolean,
+      keep_tmp:                   T::Boolean,
+      debug_symbols:              T::Boolean,
+      cc:                         T.nilable(String),
+      options:                    Options,
+      force:                      T::Boolean,
+      overwrite:                  T::Boolean,
+      debug:                      T::Boolean,
+      quiet:                      T::Boolean,
+      verbose:                    T::Boolean,
+    ).void
+  }
   def initialize(
     formula,
     link_keg: false,
@@ -48,6 +87,7 @@ def initialize(
     installed_on_request: true,
     show_header: false,
     build_bottle: false,
+    skip_post_install: false,
     force_bottle: false,
     bottle_arch: nil,
     ignore_deps: false,
@@ -58,6 +98,7 @@ def initialize(
     git: false,
     interactive: false,
     keep_tmp: false,
+    debug_symbols: false,
     cc: nil,
     options: Options.new,
     force: false,
@@ -71,15 +112,17 @@ def initialize(
     @force = force
     @overwrite = overwrite
     @keep_tmp = keep_tmp
-    @link_keg = !formula.keg_only? || link_keg
+    @debug_symbols = debug_symbols
+    @link_keg = T.let(!formula.keg_only? || link_keg, T::Boolean)
     @show_header = show_header
     @ignore_deps = ignore_deps
     @only_deps = only_deps
     @build_from_source_formulae = build_from_source_formulae
     @build_bottle = build_bottle
+    @skip_post_install = skip_post_install
     @bottle_arch = bottle_arch
     @formula.force_bottle ||= force_bottle
-    @force_bottle = @formula.force_bottle
+    @force_bottle = T.let(@formula.force_bottle, T::Boolean)
     @include_test_formulae = include_test_formulae
     @interactive = interactive
     @git = git
@@ -90,36 +133,46 @@ def initialize(
     @installed_as_dependency = installed_as_dependency
     @installed_on_request = installed_on_request
     @options = options
-    @requirement_messages = []
-    @poured_bottle = false
-    @start_time = nil
+    @requirement_messages = T.let([], T::Array[String])
+    @poured_bottle = T.let(false, T::Boolean)
+    @start_time = T.let(nil, T.nilable(Time))
+    @bottle_tab_runtime_dependencies = T.let({}.freeze, T::Hash[String, T::Hash[String, String]])
+    @hold_locks = T.let(false, T::Boolean)
+    @show_summary_heading = T.let(false, T::Boolean)
+    @etc_var_preinstall = T.let([], T::Array[Pathname])
+
+    # Take the original formula instance, which might have been swapped from an API instance to a source instance
+    @formula = T.let(T.must(previously_fetched_formula), Formula) if previously_fetched_formula
   end
 
+  sig { returns(T::Set[Formula]) }
   def self.attempted
-    @attempted ||= Set.new
+    @attempted ||= T.let(Set.new, T.nilable(T::Set[Formula]))
   end
 
   sig { void }
   def self.clear_attempted
-    @attempted = Set.new
+    @attempted = T.let(Set.new, T.nilable(T::Set[Formula]))
   end
 
+  sig { returns(T::Set[Formula]) }
   def self.installed
-    @installed ||= Set.new
+    @installed ||= T.let(Set.new, T.nilable(T::Set[Formula]))
   end
 
   sig { void }
   def self.clear_installed
-    @installed = Set.new
+    @installed = T.let(Set.new, T.nilable(T::Set[Formula]))
   end
 
+  sig { returns(T::Set[Formula]) }
   def self.fetched
-    @fetched ||= Set.new
+    @fetched ||= T.let(Set.new, T.nilable(T::Set[Formula]))
   end
 
   sig { void }
   def self.clear_fetched
-    @fetched = Set.new
+    @fetched = T.let(Set.new, T.nilable(T::Set[Formula]))
   end
 
   sig { returns(T::Boolean) }
@@ -137,6 +190,11 @@ def build_bottle?
     @build_bottle.present?
   end
 
+  sig { returns(T::Boolean) }
+  def skip_post_install?
+    @skip_post_install.present?
+  end
+
   sig { params(output_warning: T::Boolean).returns(T::Boolean) }
   def pour_bottle?(output_warning: false)
     return false if !formula.bottle_tag? && !formula.local_bottle_path
@@ -157,12 +215,12 @@ def pour_bottle?(output_warning: false)
 
     return true if formula.local_bottle_path.present?
 
-    bottle = formula.bottle_for_tag(Utils::Bottles.tag.to_sym)
+    bottle = formula.bottle_for_tag(Utils::Bottles.tag)
     return false if bottle.nil?
 
     unless bottle.compatible_locations?
       if output_warning
-        prefix = Pathname(bottle.cellar).parent
+        prefix = Pathname(bottle.cellar.to_s).parent
         opoo <<~EOS
           Building #{formula.full_name} from source as the bottle needs:
           - HOMEBREW_CELLAR: #{bottle.cellar} (yours is #{HOMEBREW_CELLAR})
@@ -188,27 +246,26 @@ def install_bottle_for?(dep, build)
 
   sig { void }
   def prelude
-    type, reason = DeprecateDisable.deprecate_disable_info formula
-    if type.present?
-      case type
+    deprecate_disable_type = DeprecateDisable.type(formula)
+    if deprecate_disable_type.present?
+      message = "#{formula.full_name} has been #{DeprecateDisable.message(formula)}"
+
+      case deprecate_disable_type
       when :deprecated
-        if reason.present?
-          opoo "#{formula.full_name} has been deprecated because it #{reason}!"
-        else
-          opoo "#{formula.full_name} has been deprecated!"
-        end
+        opoo message
       when :disabled
-        if reason.present?
-          raise CannotInstallFormulaError, "#{formula.full_name} has been disabled because it #{reason}!"
-        end
-
-        raise CannotInstallFormulaError, "#{formula.full_name} has been disabled!"
+        GitHub::Actions.puts_annotation_if_env_set(:error, message)
+        raise CannotInstallFormulaError, message
       end
     end
 
     Tab.clear_cache
+
     verify_deps_exist unless ignore_deps?
+
     forbidden_license_check
+    forbidden_tap_check
+    forbidden_formula_check
 
     check_install_sanity
     install_fetch_deps unless ignore_deps?
@@ -221,18 +278,20 @@ def verify_deps_exist
     rescue TapFormulaUnavailableError => e
       raise if e.tap.installed?
 
-      e.tap.install
-      retry
+      e.tap.ensure_installed!
+      retry if e.tap.installed? # It may have not installed if it's a core tap.
     end
   rescue FormulaUnavailableError => e
     e.dependent = formula.full_name
     raise
   end
 
+  sig { void }
   def check_installation_already_attempted
     raise FormulaInstallationAlreadyAttemptedError, formula if self.class.attempted.include?(formula)
   end
 
+  sig { void }
   def check_install_sanity
     check_installation_already_attempted
 
@@ -243,7 +302,7 @@ def check_install_sanity
     if Homebrew.default_prefix? &&
        !build_from_source? && !build_bottle? && !formula.head? && formula.tap&.core_tap? &&
        # Integration tests override homebrew-core locations
-       ENV["HOMEBREW_TEST_TMPDIR"].nil? &&
+       ENV["HOMEBREW_INTEGRATION_TEST"].nil? &&
        !pour_bottle?
       message = if !formula.pour_bottle? && formula.pour_bottle_check_unsatisfied_reason
         formula_message = formula.pour_bottle_check_unsatisfied_reason
@@ -255,9 +314,7 @@ def check_install_sanity
       # don't want to complain about no bottle available if doing an
       # upgrade/reinstall/dependency install (but do in the case the bottle
       # check fails)
-      elsif !Homebrew::EnvConfig.developer? &&
-            (!installed_as_dependency? || !formula.any_version_installed?) &&
-            (!OS.mac? || !OS::Mac.version.outdated_release?)
+      elsif fresh_install?(formula)
         <<~EOS
           #{formula}: no bottle available!
         EOS
@@ -265,12 +322,18 @@ def check_install_sanity
 
       if message
         message += <<~EOS
-          You can try to install from source with:
+          If you're feeling brave, you can try to install from source with:
             brew install --build-from-source #{formula}
-          Please note building from source is unsupported. You will encounter build
-          failures with some formulae. If you experience any issues please create pull
-          requests instead of asking for help on Homebrew's GitHub, Twitter or any other
-          official channels.
+
+          It is expected behaviour that most formulae will fail to build from source.
+          It is expected behaviour that Homebrew will be buggy and slow when building from source.
+          Do not create any issues about failures building from source on Homebrew's GitHub repositories.
+          Do not create any issues building from source even if you think this message is unrelated.
+          Any opened issues will be immediately closed without response.
+          Do not ask for help from Homebrew or its maintainers on social media.
+          You may ask for help building from source in Homebrew's discussions but are unlikely to receive a response.
+          If building from source fails, try to figure out the problem yourself and submit a fix as a pull request.
+          We will review it but may or may not accept it.
         EOS
         raise CannotInstallFormulaError, message
       end
@@ -316,6 +379,7 @@ def check_install_sanity
       next unless dep.to_formula.pinned?
       next if dep.satisfied?(inherited_options_for(dep))
       next if dep.build? && pour_bottle?
+      next if dep.test?
 
       pinned_unsatisfied_deps << dep
     end
@@ -334,12 +398,15 @@ def check_install_sanity
           "#{formula.full_name} requires the latest version of pinned dependencies"
   end
 
+  sig { params(_formula: Formula).returns(T.nilable(T::Boolean)) }
+  def fresh_install?(_formula) = false
+
   sig { void }
   def install_fetch_deps
     return if @compute_dependencies.blank?
 
     compute_dependencies(use_cache: false) if @compute_dependencies.any? do |dep, options|
-      next false unless dep.tags == [:build, :test]
+      next false unless dep.implicit?
 
       fetch_dependencies
       install_dependency(dep, options)
@@ -347,14 +414,15 @@ def install_fetch_deps
     end
   end
 
+  sig { void }
   def build_bottle_preinstall
-    @etc_var_dirs ||= [HOMEBREW_PREFIX/"etc", HOMEBREW_PREFIX/"var"]
-    @etc_var_preinstall = Find.find(*@etc_var_dirs.select(&:directory?)).to_a
+    @etc_var_preinstall = Find.find(*ETC_VAR_DIRS.select(&:directory?)).to_a
   end
 
+  sig { void }
   def build_bottle_postinstall
-    @etc_var_postinstall = Find.find(*@etc_var_dirs.select(&:directory?)).to_a
-    (@etc_var_postinstall - @etc_var_preinstall).each do |file|
+    etc_var_postinstall = Find.find(*ETC_VAR_DIRS.select(&:directory?)).to_a
+    (etc_var_postinstall - @etc_var_preinstall).each do |file|
       Pathname.new(file).cp_path_sub(HOMEBREW_PREFIX, formula.bottle_prefix)
     end
   end
@@ -402,11 +470,9 @@ def install
     options = display_options(formula).join(" ")
     oh1 "Installing #{Formatter.identifier(formula.full_name)} #{options}".strip if show_header?
 
-    if formula.tap&.installed? && !formula.tap&.private?
-      action = "#{formula.full_name} #{options}".strip
-      Utils::Analytics.report_event("install", action)
-
-      Utils::Analytics.report_event("install_on_request", action) if installed_on_request?
+    if (tap = formula.tap) && tap.should_report_analytics?
+      Utils::Analytics.report_package_event(:formula_install, package_name: formula.name, tap_name: tap.name,
+on_request: installed_on_request?, options:)
     end
 
     self.class.attempted << formula
@@ -418,7 +484,7 @@ def install
         # any exceptions must leave us with nothing installed
         ignore_interrupts do
           begin
-            formula.prefix.rmtree if formula.prefix.directory?
+            FileUtils.rm_r(formula.prefix) if formula.prefix.directory?
           rescue Errno::EACCES, Errno::ENOTEMPTY
             odie <<~EOS
               Could not remove #{formula.prefix.basename} keg! Do so manually:
@@ -453,7 +519,7 @@ def install
       Pathname(brew_prefix/"#{formula.name}.rb").atomic_write(s)
 
       keg = Keg.new(formula.prefix)
-      tab = Tab.for_keg(keg)
+      tab = keg.tab
       tab.installed_as_dependency = installed_as_dependency?
       tab.installed_on_request = installed_on_request?
       tab.write
@@ -466,6 +532,7 @@ def install
     Homebrew.messages.package_installed(formula.name, end_time - start_time)
   end
 
+  sig { void }
   def check_conflicts
     return if force?
 
@@ -481,12 +548,13 @@ def check_conflicts
       # stop installation from continuing.
       opoo <<~EOS
         #{formula}: #{e.message}
-        'conflicts_with \"#{c.name}\"' should be removed from #{formula.path.basename}.
+        'conflicts_with "#{c.name}"' should be removed from #{formula.path.basename}.
       EOS
 
       raise if Homebrew::EnvConfig.developer?
 
-      $stderr.puts "Please report this issue to the #{formula.tap} tap (not Homebrew/brew or Homebrew/core)!"
+      $stderr.puts "Please report this issue to the #{formula.tap&.full_name} tap".squeeze(" ")
+      $stderr.puts " (not Homebrew/brew or Homebrew/homebrew-core)!" unless formula.core_formula?
       false
     else
       f.linked_keg.exist? && f.opt_prefix.exist?
@@ -497,34 +565,41 @@ def check_conflicts
 
   # Compute and collect the dependencies needed by the formula currently
   # being installed.
+  sig { params(use_cache: T::Boolean).returns(T::Array[[Dependency, Options]]) }
   def compute_dependencies(use_cache: true)
-    @compute_dependencies = nil unless use_cache
+    @compute_dependencies = T.let(nil, T.nilable(T::Array[[Dependency, Options]])) unless use_cache
     @compute_dependencies ||= begin
+      # Needs to be done before expand_dependencies
+      fetch_bottle_tab if pour_bottle?
+
       check_requirements(expand_requirements)
       expand_dependencies
     end
   end
 
+  sig { params(deps: T::Array[[Dependency, Options]]).returns(T::Array[Formula]) }
   def unbottled_dependencies(deps)
-    deps.map(&:first).map(&:to_formula).reject do |dep_f|
+    deps.map { |(dep, _options)| dep.to_formula }.reject do |dep_f|
       next false unless dep_f.pour_bottle?
 
       dep_f.bottled?
     end
   end
 
+  sig { void }
   def compute_and_install_dependencies
     deps = compute_dependencies
     install_dependencies(deps)
   end
 
+  sig { params(req_map: T::Hash[Formula, T::Array[Requirement]]).void }
   def check_requirements(req_map)
     @requirement_messages = []
     fatals = []
 
     req_map.each_pair do |dependent, reqs|
       reqs.each do |req|
-        next if dependent.latest_version_installed? && req.name == "macos" && req.comparator == "<="
+        next if dependent.latest_version_installed? && req.is_a?(MacOSRequirement) && req.comparator == "<="
 
         @requirement_messages << "#{dependent}: #{req.message}"
         fatals << req if req.fatal?
@@ -537,6 +612,7 @@ def check_requirements(req_map)
     raise UnsatisfiedRequirements, fatals
   end
 
+  sig { params(formula: Formula).returns(T::Array[Requirement]) }
   def runtime_requirements(formula)
     runtime_deps = formula.runtime_formula_dependencies(undeclared: false)
     recursive_requirements = formula.recursive_requirements do |dependent, _|
@@ -545,11 +621,12 @@ def runtime_requirements(formula)
     (recursive_requirements.to_a + formula.requirements.to_a).reject(&:build?).uniq
   end
 
+  sig { returns(T::Hash[Formula, T::Array[Requirement]]) }
   def expand_requirements
     unsatisfied_reqs = Hash.new { |h, k| h[k] = [] }
     formulae = [formula]
     formula_deps_map = formula.recursive_dependencies
-                              .index_by(&:name)
+                              .each_with_object({}) { |dep, h| h[dep.name] = dep }
 
     while (f = formulae.pop)
       runtime_requirements = runtime_requirements(f)
@@ -577,16 +654,15 @@ def expand_requirements
     unsatisfied_reqs
   end
 
+  sig { params(formula: Formula, inherited_options: T::Hash[String, Options]).returns(T::Array[Dependency]) }
   def expand_dependencies_for_formula(formula, inherited_options)
-    any_bottle_used = false
-
     # Cache for this expansion only. FormulaInstaller has a lot of inputs which can alter expansion.
     cache_key = "FormulaInstaller-#{formula.full_name}-#{Time.now.to_f}"
-    expanded_deps = Dependency.expand(formula, cache_key: cache_key) do |dependent, dep|
+    Dependency.expand(formula, cache_key:) do |dependent, dep|
       inherited_options[dep.name] |= inherited_options_for(dep)
       build = effective_build_options_for(
         dependent,
-        inherited_options.fetch(dependent.name, []),
+        inherited_options.fetch(dependent.name, Options.new),
       )
 
       keep_build_test = false
@@ -594,45 +670,30 @@ def expand_dependencies_for_formula(formula, inherited_options)
       keep_build_test ||= dep.build? && !install_bottle_for?(dependent, build) &&
                           (formula.head? || !dependent.latest_version_installed?)
 
+      bottle_runtime_version = @bottle_tab_runtime_dependencies.dig(dep.name, "version").presence
+      bottle_runtime_version = Version.new(bottle_runtime_version) if bottle_runtime_version
+      bottle_runtime_revision = @bottle_tab_runtime_dependencies.dig(dep.name, "revision")
+
       if dep.prune_from_option?(build) || ((dep.build? || dep.test?) && !keep_build_test)
         Dependency.prune
-      elsif dep.satisfied?(inherited_options[dep.name])
+      elsif dep.satisfied?(inherited_options[dep.name], minimum_version:  bottle_runtime_version,
+                                                        minimum_revision: bottle_runtime_revision)
         Dependency.skip
-      else
-        any_bottle_used ||= install_bottle_for?(dep.to_formula, build)
       end
     end
-
-    [expanded_deps, any_bottle_used]
   end
 
+  sig { returns(T::Array[[Dependency, Options]]) }
   def expand_dependencies
     inherited_options = Hash.new { |hash, key| hash[key] = Options.new }
-    any_bottle_used = pour_bottle?
 
-    expanded_deps, any_dep_bottle_used = expand_dependencies_for_formula(formula, inherited_options)
-    any_bottle_used ||= any_dep_bottle_used
-
-    # We require some dependencies (glibc, GCC 5, etc.) if binaries were built.
-    # Native binaries shouldn't exist in cross-platform `all` bottles.
-    if any_bottle_used && !formula.bottled?(:all) && !Keg.bottle_dependencies.empty?
-      all_bottle_deps = Keg.bottle_dependencies.flat_map do |bottle_dep|
-        bottle_dep.recursive_dependencies.map(&:name) + [bottle_dep.name]
-      end
-
-      if all_bottle_deps.exclude?(formula.name)
-        bottle_deps = Keg.bottle_dependencies.flat_map do |bottle_dep|
-          expanded_bottle_deps, = expand_dependencies_for_formula(bottle_dep, inherited_options)
-          expanded_bottle_deps
-        end
-        expanded_deps = Dependency.merge_repeats(bottle_deps + expanded_deps)
-      end
-    end
+    expanded_deps = expand_dependencies_for_formula(formula, inherited_options)
 
     expanded_deps.map { |dep| [dep, inherited_options[dep.name]] }
   end
 
-  def effective_build_options_for(dependent, inherited_options = [])
+  sig { params(dependent: Formula, inherited_options: Options).returns(BuildOptions) }
+  def effective_build_options_for(dependent, inherited_options = Options.new)
     args  = dependent.build.used_options
     args |= (dependent == formula) ? options : inherited_options
     args |= Tab.for_formula(dependent).used_options
@@ -640,6 +701,7 @@ def effective_build_options_for(dependent, inherited_options = [])
     BuildOptions.new(args, dependent.options)
   end
 
+  sig { params(formula: Formula).returns(T::Array[String]) }
   def display_options(formula)
     options = if formula.head?
       ["--HEAD"]
@@ -660,13 +722,13 @@ def inherited_options_for(dep)
     inherited_options
   end
 
-  sig { params(deps: T::Array[[Formula, Options]]).void }
+  sig { params(deps: T::Array[[Dependency, Options]]).void }
   def install_dependencies(deps)
     if deps.empty? && only_deps?
       puts "All dependencies for #{formula.full_name} are satisfied."
     elsif !deps.empty?
       oh1 "Installing dependencies for #{formula.full_name}: " \
-          "#{deps.map(&:first).map(&Formatter.method(:identifier)).to_sentence}",
+          "#{deps.map(&:first).map { Formatter.identifier(_1) }.to_sentence}",
           truncate: false
       deps.each { |dep, options| install_dependency(dep, options) }
     end
@@ -683,11 +745,13 @@ def fetch_dependency(dep)
       # When fetching we don't need to recurse the dependency tree as it's already
       # been done for us in `compute_dependencies` and there's no requirement to
       # fetch in a particular order.
-      ignore_deps:                true,
+      # Note, this tree can vary when pouring bottles so we need to check it then.
+      ignore_deps:                !pour_bottle?,
       installed_as_dependency:    true,
       include_test_formulae:      @include_test_formulae,
       build_from_source_formulae: @build_from_source_formulae,
       keep_tmp:                   keep_tmp?,
+      debug_symbols:              debug_symbols?,
       force:                      force?,
       debug:                      debug?,
       quiet:                      quiet?,
@@ -703,15 +767,17 @@ def install_dependency(dep, inherited_options)
 
     if df.linked_keg.directory?
       linked_keg = Keg.new(df.linked_keg.resolved_path)
-      tab = Tab.for_keg(linked_keg)
+      tab = linked_keg.tab
       keg_had_linked_keg = true
       keg_was_linked = linked_keg.linked?
       linked_keg.unlink
+    else
+      keg_had_linked_keg = false
     end
 
     if df.latest_version_installed?
       installed_keg = Keg.new(df.prefix)
-      tab ||= Tab.for_keg(installed_keg)
+      tab ||= installed_keg.tab
       tmp_keg = Pathname.new("#{installed_keg}.tmp")
       installed_keg.rename(tmp_keg)
     end
@@ -732,27 +798,26 @@ def install_dependency(dep, inherited_options)
 
     fi = FormulaInstaller.new(
       df,
-      **{
-        options:                    options,
-        link_keg:                   keg_had_linked_keg ? keg_was_linked : nil,
-        installed_as_dependency:    true,
-        installed_on_request:       df.any_version_installed? && tab.present? && tab.installed_on_request,
-        force_bottle:               false,
-        include_test_formulae:      @include_test_formulae,
-        build_from_source_formulae: @build_from_source_formulae,
-        keep_tmp:                   keep_tmp?,
-        force:                      force?,
-        debug:                      debug?,
-        quiet:                      quiet?,
-        verbose:                    verbose?,
-      },
+      options:,
+      link_keg:                   keg_had_linked_keg && keg_was_linked,
+      installed_as_dependency:    true,
+      installed_on_request:       df.any_version_installed? && tab.present? && tab.installed_on_request,
+      force_bottle:               false,
+      include_test_formulae:      @include_test_formulae,
+      build_from_source_formulae: @build_from_source_formulae,
+      keep_tmp:                   keep_tmp?,
+      debug_symbols:              debug_symbols?,
+      force:                      force?,
+      debug:                      debug?,
+      quiet:                      quiet?,
+      verbose:                    verbose?,
     )
     oh1 "Installing #{formula.full_name} dependency: #{Formatter.identifier(dep.name)}"
     fi.install
     fi.finish
   rescue Exception => e # rubocop:disable Lint/RescueException
     ignore_interrupts do
-      tmp_keg.rename(installed_keg) if tmp_keg && !installed_keg.directory?
+      tmp_keg.rename(installed_keg.to_path) if tmp_keg && !installed_keg.directory?
       linked_keg.link(verbose: verbose?) if keg_was_linked
     end
     raise unless e.is_a? FormulaInstallationAlreadyAttemptedError
@@ -761,7 +826,7 @@ def install_dependency(dep, inherited_options)
     # dependency tree. In that case, don't generate an error, just move on.
     nil
   else
-    ignore_interrupts { tmp_keg.rmtree if tmp_keg&.directory? }
+    ignore_interrupts { FileUtils.rm_r(tmp_keg) if tmp_keg&.directory? }
   end
 
   sig { void }
@@ -794,14 +859,23 @@ def finish
 
     fix_dynamic_linkage(keg) if !@poured_bottle || !formula.bottle_specification.skip_relocation?
 
-    if build_bottle?
-      ohai "Not running 'post_install' as we're building a bottle"
+    Homebrew::Install.global_post_install
+
+    if build_bottle? || skip_post_install?
+      if build_bottle?
+        ohai "Not running 'post_install' as we're building a bottle"
+      elsif skip_post_install?
+        ohai "Skipping 'post_install' on request"
+      end
       puts "You can run it manually using:"
       puts "  brew postinstall #{formula.full_name}"
     else
-      post_install
+      formula.install_etc_var
+      post_install if formula.post_install_defined?
     end
 
+    keg.prepare_debug_symbols if debug_symbols?
+
     # Updates the cache for a particular formula after doing an install
     CacheStoreDatabase.use(:linkage) do |db|
       break unless db.created?
@@ -810,26 +884,32 @@ def finish
     end
 
     # Update tab with actual runtime dependencies
-    tab = Tab.for_keg(keg)
+    tab = keg.tab
     Tab.clear_cache
     f_runtime_deps = formula.runtime_dependencies(read_from_tab: false)
     tab.runtime_dependencies = Tab.runtime_deps_hash(formula, f_runtime_deps)
     tab.write
 
+    # write/update a SBOM file (if we aren't bottling)
+    unless build_bottle?
+      sbom = SBOM.create(formula, tab)
+      sbom.write(validate: Homebrew::EnvConfig.developer?)
+    end
+
     # let's reset Utils::Git.available? if we just installed git
     Utils::Git.clear_available_cache if formula.name == "git"
 
     # use installed ca-certificates when it's needed and available
     if formula.name == "ca-certificates" &&
        !DevelopmentTools.ca_file_handles_most_https_certificates?
-      ENV["SSL_CERT_FILE"] = ENV["GIT_SSL_CAINFO"] = formula.pkgetc/"cert.pem"
-      ENV["GIT_SSL_CAPATH"] = formula.pkgetc
+      ENV["SSL_CERT_FILE"] = ENV["GIT_SSL_CAINFO"] = (formula.pkgetc/"cert.pem").to_s
+      ENV["GIT_SSL_CAPATH"] = formula.pkgetc.to_s
     end
 
     # use installed curl when it's needed and available
     if formula.name == "curl" &&
        !DevelopmentTools.curl_handles_most_https_certificates?
-      ENV["HOMEBREW_CURL"] = formula.opt_bin/"curl"
+      ENV["HOMEBREW_CURL"] = (formula.opt_bin/"curl").to_s
       Utils::Curl.clear_path_cache
     end
 
@@ -852,8 +932,9 @@ def summary
     s.freeze
   end
 
+  sig { returns(T.nilable(Float)) }
   def build_time
-    @build_time ||= Time.now - @start_time if @start_time && !interactive?
+    @build_time ||= T.let(Time.now - @start_time, T.nilable(Float)) if @start_time && !interactive?
   end
 
   sig { returns(T::Array[String]) }
@@ -873,6 +954,11 @@ def sanitized_argv_options
     args << "--cc=#{@cc}" if @cc
     args << "--keep-tmp" if keep_tmp?
 
+    if debug_symbols?
+      args << "--debug-symbols"
+      args << "--build-from-source"
+    end
+
     if @env.present?
       args << "--env=#{@env}"
     elsif formula.env.std? || formula.deps.select(&:build?).any? { |d| d.name == "scons" }
@@ -885,9 +971,7 @@ def sanitized_argv_options
   end
 
   sig { returns(T::Array[String]) }
-  def build_argv
-    sanitized_argv_options + options.as_flags
-  end
+  def build_argv = sanitized_argv_options + options.as_flags
 
   sig { void }
   def build
@@ -906,20 +990,21 @@ def build
       formula.specified_path,
     ].concat(build_argv)
 
-    Utils.safe_fork do
-      if Sandbox.available?
-        sandbox = Sandbox.new
-        formula.logs.mkpath
-        sandbox.record_log(formula.logs/"build.sandbox.log")
-        sandbox.allow_write_path(Dir.home) if interactive?
-        sandbox.allow_write_temp_and_cache
-        sandbox.allow_write_log(formula)
-        sandbox.allow_cvs
-        sandbox.allow_fossil
-        sandbox.allow_write_xcode
-        sandbox.allow_write_cellar(formula)
-        sandbox.exec(*args)
-      else
+    if Sandbox.available?
+      sandbox = Sandbox.new
+      formula.logs.mkpath
+      sandbox.record_log(formula.logs/"build.sandbox.log")
+      sandbox.allow_write_path(Dir.home) if interactive?
+      sandbox.allow_write_temp_and_cache
+      sandbox.allow_write_log(formula)
+      sandbox.allow_cvs
+      sandbox.allow_fossil
+      sandbox.allow_write_xcode
+      sandbox.allow_write_cellar(formula)
+      sandbox.deny_all_network unless formula.network_access_allowed?(:build)
+      sandbox.run(*args)
+    else
+      Utils.safe_fork do
         exec(*args)
       end
     end
@@ -936,7 +1021,7 @@ def build
     ignore_interrupts do
       # any exceptions must leave us with nothing installed
       formula.update_head_version
-      formula.prefix.rmtree if formula.prefix.directory?
+      FileUtils.rm_r(formula.prefix) if formula.prefix.directory?
       formula.rack.rmdir_if_possible
     end
     raise e
@@ -958,7 +1043,7 @@ def link(keg)
     end
 
     cask_installed_with_formula_name = begin
-      Cask::CaskLoader.load(formula.name).installed?
+      Cask::CaskLoader.load(formula.name, warn: false).installed?
     rescue Cask::CaskUnavailableError, Cask::CaskInvalidError
       false
     end
@@ -1008,7 +1093,12 @@ def link(keg)
       ofail "An unexpected error occurred during the `brew link` step"
       puts "The formula built, but is not symlinked into #{HOMEBREW_PREFIX}"
       puts e
-      puts e.backtrace if debug?
+
+      if debug?
+        require "utils/backtrace"
+        puts Utils::Backtrace.clean(e)
+      end
+
       @show_summary_heading = true
       ignore_interrupts do
         keg.unlink
@@ -1031,12 +1121,7 @@ def link(keg)
 
   sig { void }
   def install_service
-    if formula.service? && formula.plist
-      ofail "Formula specified both service and plist"
-      return
-    end
-
-    if formula.service?
+    service = if formula.service? && formula.service.command?
       service_path = formula.systemd_service_path
       service_path.atomic_write(formula.service.to_systemd_unit)
       service_path.chmod 0644
@@ -1046,24 +1131,22 @@ def install_service
         timer_path.atomic_write(formula.service.to_systemd_timer)
         timer_path.chmod 0644
       end
-    end
 
-    service = if formula.service?
       formula.service.to_plist
-    elsif formula.plist
-      formula.plist
     end
-
     return unless service
 
-    plist_path = formula.plist_path
-    plist_path.atomic_write(service)
-    plist_path.chmod 0644
+    launchd_service_path = formula.launchd_service_path
+    launchd_service_path.atomic_write(service)
+    launchd_service_path.chmod 0644
     log = formula.var/"log"
     log.mkpath if service.include? log.to_s
   rescue Exception => e # rubocop:disable Lint/RescueException
+    puts e
     ofail "Failed to install service files"
-    odebug e, e.backtrace
+
+    require "utils/backtrace"
+    odebug e, Utils::Backtrace.clean(e)
   end
 
   sig { params(keg: Keg).void }
@@ -1073,7 +1156,10 @@ def fix_dynamic_linkage(keg)
     ofail "Failed to fix install linkage"
     puts "The formula built, but you may encounter issues using it or linking other"
     puts "formulae against it."
-    odebug e, e.backtrace
+
+    require "utils/backtrace"
+    odebug e, Utils::Backtrace.clean(e)
+
     @show_summary_heading = true
   end
 
@@ -1084,11 +1170,44 @@ def clean
   rescue Exception => e # rubocop:disable Lint/RescueException
     opoo "The cleaning step did not complete successfully"
     puts "Still, the installation was successful, so we will link it into your prefix."
-    odebug e, e.backtrace
+
+    require "utils/backtrace"
+    odebug e, Utils::Backtrace.clean(e)
+
     Homebrew.failed = true
     @show_summary_heading = true
   end
 
+  sig { returns(Pathname) }
+  def post_install_formula_path
+    # Use the formula from the keg when any of the following is true:
+    # * We're installing from the JSON API
+    # * We're installing a local bottle file
+    # * The formula doesn't exist in the tap (or the tap isn't installed)
+    # * The formula in the tap has a different `pkg_version``.
+    #
+    # In all other cases, including if the formula from the keg is unreadable
+    # (third-party taps may `require` some of their own libraries) or if there
+    # is no formula present in the keg (as is the case with very old bottles),
+    # use the formula from the tap.
+    keg_formula_path = formula.opt_prefix/".brew/#{formula.name}.rb"
+    return keg_formula_path if formula.loaded_from_api?
+    return keg_formula_path if formula.local_bottle_path.present?
+
+    tap_formula_path = formula.specified_path
+    return keg_formula_path unless tap_formula_path.exist?
+
+    begin
+      keg_formula = Formulary.factory(keg_formula_path)
+      tap_formula = Formulary.factory(tap_formula_path)
+      return keg_formula_path if keg_formula.pkg_version != tap_formula.pkg_version
+
+      tap_formula_path
+    rescue FormulaUnavailableError, FormulaUnreadableError
+      tap_formula_path
+    end
+  end
+
   sig { void }
   def post_install
     args = [
@@ -1099,50 +1218,24 @@ def post_install
       HOMEBREW_LIBRARY_PATH/"postinstall.rb"
     ]
 
-    # Use the formula from the keg if:
-    # * Installing from a local bottle, or
-    # * The formula doesn't exist in the tap (or the tap isn't installed), or
-    # * The formula in the tap has a different pkg_version.
-    #
-    # In all other cases, including if the formula from the keg is unreadable
-    # (third-party taps may `require` some of their own libraries) or if there
-    # is no formula present in the keg (as is the case with old bottles), use
-    # the formula from the tap.
-    formula_path = begin
-      keg_formula_path = formula.opt_prefix/".brew/#{formula.name}.rb"
-      tap_formula_path = formula.path
-      keg_formula = Formulary.factory(keg_formula_path)
-      tap_formula = Formulary.factory(tap_formula_path) if tap_formula_path.exist?
-      other_version_installed = (keg_formula.pkg_version != tap_formula&.pkg_version)
-
-      if formula.local_bottle_path.present? ||
-         !tap_formula_path.exist? ||
-         other_version_installed
-        keg_formula_path
-      else
-        tap_formula_path
+    args << post_install_formula_path
+
+    if Sandbox.available?
+      sandbox = Sandbox.new
+      formula.logs.mkpath
+      sandbox.record_log(formula.logs/"postinstall.sandbox.log")
+      sandbox.allow_write_temp_and_cache
+      sandbox.allow_write_log(formula)
+      sandbox.allow_write_xcode
+      sandbox.deny_write_homebrew_repository
+      sandbox.allow_write_cellar(formula)
+      sandbox.deny_all_network unless formula.network_access_allowed?(:postinstall)
+      Keg.keg_link_directories.each do |dir|
+        sandbox.allow_write_path "#{HOMEBREW_PREFIX}/#{dir}"
       end
-    rescue FormulaUnavailableError, FormulaUnreadableError
-      tap_formula_path
-    end
-
-    args << formula_path
-
-    Utils.safe_fork do
-      if Sandbox.available?
-        sandbox = Sandbox.new
-        formula.logs.mkpath
-        sandbox.record_log(formula.logs/"postinstall.sandbox.log")
-        sandbox.allow_write_temp_and_cache
-        sandbox.allow_write_log(formula)
-        sandbox.allow_write_xcode
-        sandbox.deny_write_homebrew_repository
-        sandbox.allow_write_cellar(formula)
-        Keg::KEG_LINK_DIRECTORIES.each do |dir|
-          sandbox.allow_write_path "#{HOMEBREW_PREFIX}/#{dir}"
-        end
-        sandbox.exec(*args)
-      else
+      sandbox.run(*args)
+    else
+      Utils.safe_fork do
         exec(*args)
       end
     end
@@ -1150,7 +1243,10 @@ def post_install
     opoo "The post-install step did not complete successfully"
     puts "You can try again using:"
     puts "  brew postinstall #{formula.full_name}"
-    odebug e, e.backtrace, always_display: Homebrew::EnvConfig.developer?
+
+    require "utils/backtrace"
+    odebug e, Utils::Backtrace.clean(e), always_display: Homebrew::EnvConfig.developer?
+
     Homebrew.failed = true
     @show_summary_heading = true
   end
@@ -1159,45 +1255,165 @@ def post_install
   def fetch_dependencies
     return if ignore_deps?
 
-    deps = compute_dependencies
+    # Don't output dependencies if we're explicitly installing them.
+    deps = compute_dependencies.reject do |(dep, _options)|
+      self.class.fetched.include?(dep.to_formula)
+    end
+
     return if deps.empty?
 
-    deps.each { |dep, _options| fetch_dependency(dep) }
+    oh1 "Fetching dependencies for #{formula.full_name}: " \
+        "#{deps.map(&:first).map { Formatter.identifier(_1) }.to_sentence}",
+        truncate: false
+
+    deps.each { |(dep, _options)| fetch_dependency(dep) }
+  end
+
+  sig { returns(T.nilable(Formula)) }
+  def previously_fetched_formula
+    # We intentionally don't compare classes here:
+    # from-API-JSON and from-source formula classes are not equal but we
+    # want to equate them to be the same thing here given mixing bottle and
+    # from-source installs of the same formula within the same operation
+    # doesn't make sense.
+    self.class.fetched.find do |fetched_formula|
+      fetched_formula.full_name == formula.full_name && fetched_formula.active_spec_sym == formula.active_spec_sym
+    end
+  end
+
+  sig { void }
+  def fetch_bottle_tab
+    return if @fetch_bottle_tab
+
+    begin
+      formula.fetch_bottle_tab
+      @bottle_tab_runtime_dependencies = formula.bottle_tab_attributes
+                                                .fetch("runtime_dependencies", []).then { |deps| deps || [] }
+                                                .each_with_object({}) { |dep, h| h[dep["full_name"]] = dep }
+                                                .freeze
+    rescue DownloadError, Resource::BottleManifest::Error
+      # do nothing
+    end
+    @fetch_bottle_tab = T.let(true, T.nilable(TrueClass))
   end
 
   sig { void }
   def fetch
-    return if self.class.fetched.include?(formula)
+    return if previously_fetched_formula
 
     fetch_dependencies
 
     return if only_deps?
 
-    if pour_bottle?(output_warning: true)
-      formula.fetch_bottle_tab
+    oh1 "Fetching #{Formatter.identifier(formula.full_name)}".strip
+
+    downloadable_object = downloadable
+    check_attestation = if pour_bottle?(output_warning: true)
+      fetch_bottle_tab
+
+      !downloadable_object.cached_download.exist?
     else
+      @formula = Homebrew::API::Formula.source_download(formula) if formula.loaded_from_api?
+
       formula.fetch_patches
       formula.resources.each(&:fetch)
+
+      false
+    end
+    downloadable_object.fetch
+
+    # We skip `gh` to avoid a bootstrapping cycle, in the off-chance a user attempts
+    # to explicitly `brew install gh` without already having a version for bootstrapping.
+    # We also skip bottle installs from local bottle paths, as these are done in CI
+    # as part of the build lifecycle before attestations are produced.
+    if check_attestation &&
+       Homebrew::Attestation.enabled? &&
+       formula.tap&.core_tap? &&
+       formula.name != "gh" &&
+       formula.local_bottle_path.blank?
+      ohai "Verifying attestation for #{formula.name}"
+      begin
+        Homebrew::Attestation.check_core_attestation T.cast(downloadable_object, Bottle)
+      rescue Homebrew::Attestation::GhIncompatible
+        # A small but significant number of users have developer mode enabled
+        # but *also* haven't upgraded in a long time, meaning that their `gh`
+        # version is too old to perform attestations.
+        raise CannotInstallFormulaError, <<~EOS
+          The bottle for #{formula.name} could not be verified.
+
+          This typically indicates an outdated or incompatible `gh` CLI.
+
+          Please confirm that you're running the latest version of `gh`
+          by performing an upgrade before retrying:
+
+            brew update
+            brew upgrade gh
+        EOS
+      rescue Homebrew::Attestation::GhAuthInvalid
+        # Only raise an error if we explicitly opted-in to verification.
+        raise CannotInstallFormulaError, <<~EOS if Homebrew::EnvConfig.verify_attestations?
+          The bottle for #{formula.name} could not be verified.
+
+          This typically indicates an invalid GitHub API token.
+
+          If you have `HOMEBREW_GITHUB_API_TOKEN` set, check it is correct
+          or unset it and instead run:
+
+            gh auth login
+        EOS
+
+        # If we didn't explicitly opt-in, then quietly opt-out in the case of invalid credentials.
+        # Based on user reports, a significant number of users are running with stale tokens.
+        ENV["HOMEBREW_NO_VERIFY_ATTESTATIONS"] = "1"
+      rescue Homebrew::Attestation::GhAuthNeeded
+        raise CannotInstallFormulaError, <<~EOS
+          The bottle for #{formula.name} could not be verified.
+
+          This typically indicates a missing GitHub API token, which you
+          can resolve either by setting `HOMEBREW_GITHUB_API_TOKEN` or
+          by running:
+
+            gh auth login
+        EOS
+      rescue Homebrew::Attestation::MissingAttestationError, Homebrew::Attestation::InvalidAttestationError => e
+        raise CannotInstallFormulaError, <<~EOS
+          The bottle for #{formula.name} has an invalid build provenance attestation.
+
+          This may indicate that the bottle was not produced by the expected
+          tap, or was maliciously inserted into the expected tap's bottle
+          storage.
+
+          Additional context:
+
+          #{e}
+        EOS
+      end
     end
-    downloader.fetch
 
     self.class.fetched << formula
+  rescue CannotInstallFormulaError
+    if (cached_download = downloadable_object&.cached_download)&.exist?
+      cached_download.unlink
+    end
+
+    raise
   end
 
-  def downloader
+  sig { returns(Downloadable) }
+  def downloadable
     if (bottle_path = formula.local_bottle_path)
-      LocalBottleDownloadStrategy.new(bottle_path)
+      Resource::Local.new(bottle_path)
     elsif pour_bottle?
-      formula.bottle
+      T.must(formula.bottle)
     else
-      formula
+      T.must(formula.resource)
     end
   end
 
   sig { void }
   def pour
     HOMEBREW_CELLAR.cd do
-      downloader.stage
+      downloadable.downloader.stage
     end
 
     Tab.clear_cache
@@ -1205,17 +1421,18 @@ def pour
     tab = Utils::Bottles.load_tab(formula)
 
     # fill in missing/outdated parts of the tab
-    # keep in sync with Tab#to_bottle_json
+    # keep in sync with Tab#to_bottle_hash
     tab.used_options = []
     tab.unused_options = []
     tab.built_as_bottle = true
     tab.poured_from_bottle = true
+    tab.loaded_from_api = formula.loaded_from_api?
     tab.installed_as_dependency = installed_as_dependency?
     tab.installed_on_request = installed_on_request?
     tab.time = Time.now.to_i
     tab.aliases = formula.aliases
     tab.arch = Hardware::CPU.arch
-    tab.source["versions"]["stable"] = formula.stable.version.to_s
+    tab.source["versions"]["stable"] = T.must(formula.stable).version&.to_s
     tab.source["versions"]["version_scheme"] = formula.version_scheme
     tab.source["path"] = formula.specified_path.to_s
     tab.source["tap_git_head"] = formula.tap&.installed? ? formula.tap&.git_head : nil
@@ -1224,7 +1441,7 @@ def pour
 
     keg = Keg.new(formula.prefix)
     skip_linkage = formula.bottle_specification.skip_relocation?
-    keg.replace_placeholders_with_locations tab.changed_files, skip_linkage: skip_linkage
+    keg.replace_placeholders_with_locations(tab.changed_files, skip_linkage:)
 
     cellar = formula.bottle_specification.tag_to_cellar(Utils::Bottles.tag)
     return if [:any, :any_skip_relocation].include?(cellar)
@@ -1237,7 +1454,7 @@ def pour
     keg.relocate_build_prefix(keg, prefix, HOMEBREW_PREFIX)
   end
 
-  sig { params(output: T.nilable(String)).void }
+  sig { override.params(output: T.nilable(String)).void }
   def problem_if_output(output)
     return unless output
 
@@ -1245,6 +1462,7 @@ def problem_if_output(output)
     @show_summary_heading = true
   end
 
+  sig { void }
   def audit_installed
     unless formula.keg_only?
       problem_if_output(check_env_path(formula.bin))
@@ -1253,13 +1471,155 @@ def audit_installed
     super
   end
 
+  sig { returns(T::Array[Formula]) }
   def self.locked
-    @locked ||= []
+    @locked ||= T.let([], T.nilable(T::Array[Formula]))
   end
 
-  private
+  sig { void }
+  def forbidden_license_check
+    forbidden_licenses = Homebrew::EnvConfig.forbidden_licenses.to_s.dup
+    SPDX::ALLOWED_LICENSE_SYMBOLS.each do |s|
+      pattern = /#{s.to_s.tr("_", " ")}/i
+      forbidden_licenses.sub!(pattern, s.to_s)
+    end
 
-  attr_predicate :hold_locks?
+    invalid_licenses = []
+    forbidden_licenses = forbidden_licenses.split.each_with_object({}) do |license, hash|
+      unless SPDX.valid_license?(license)
+        invalid_licenses << license
+        next
+      end
+
+      hash[license] = SPDX.license_version_info(license)
+    end
+
+    if invalid_licenses.present?
+      opoo <<~EOS
+        HOMEBREW_FORBIDDEN_LICENSES contains invalid license identifiers: #{invalid_licenses.to_sentence}
+        These licenses will not be forbidden. See the valid SPDX license identifiers at:
+          #{Formatter.url("https://spdx.org/licenses/")}
+        And the licenses for a formula with:
+          brew info <formula>
+      EOS
+    end
+
+    return if forbidden_licenses.blank?
+
+    owner = Homebrew::EnvConfig.forbidden_owner
+    owner_contact = if (contact = Homebrew::EnvConfig.forbidden_owner_contact.presence)
+      "\n#{contact}"
+    end
+
+    unless ignore_deps?
+      compute_dependencies.each do |(dep, _options)|
+        dep_f = dep.to_formula
+        next unless SPDX.licenses_forbid_installation? dep_f.license, forbidden_licenses
+
+        raise CannotInstallFormulaError, <<~EOS
+          The installation of #{formula.name} has a dependency on #{dep.name} where all
+          its licenses were forbidden by #{owner} in `HOMEBREW_FORBIDDEN_LICENSES`:
+            #{SPDX.license_expression_to_string dep_f.license}#{owner_contact}
+        EOS
+      end
+    end
+
+    return if only_deps?
+
+    return unless SPDX.licenses_forbid_installation? formula.license, forbidden_licenses
+
+    raise CannotInstallFormulaError, <<~EOS
+      #{formula.name}'s licenses are all forbidden by #{owner} in `HOMEBREW_FORBIDDEN_LICENSES`:
+        #{SPDX.license_expression_to_string formula.license}#{owner_contact}
+    EOS
+  end
+
+  sig { void }
+  def forbidden_tap_check
+    return if Tap.allowed_taps.blank? && Tap.forbidden_taps.blank?
+
+    owner = Homebrew::EnvConfig.forbidden_owner
+    owner_contact = if (contact = Homebrew::EnvConfig.forbidden_owner_contact.presence)
+      "\n#{contact}"
+    end
+
+    unless ignore_deps?
+      compute_dependencies.each do |(dep, _options)|
+        dep_tap = dep.tap
+        next if dep_tap.blank? || (dep_tap.allowed_by_env? && !dep_tap.forbidden_by_env?)
+
+        error_message = "The installation of #{formula.name} has a dependency #{dep.name}\n" \
+                        "from the #{dep_tap} tap but #{owner} "
+        error_message << "has not allowed this tap in `HOMEBREW_ALLOWED_TAPS`" unless dep_tap.allowed_by_env?
+        error_message << " and\n" if !dep_tap.allowed_by_env? && dep_tap.forbidden_by_env?
+        error_message << "has forbidden this tap in `HOMEBREW_FORBIDDEN_TAPS`" if dep_tap.forbidden_by_env?
+        error_message << ".#{owner_contact}"
+
+        raise CannotInstallFormulaError, error_message
+      end
+    end
+
+    return if only_deps?
+
+    formula_tap = formula.tap
+    return if formula_tap.blank? || (formula_tap.allowed_by_env? && !formula_tap.forbidden_by_env?)
+
+    error_message = "The installation of #{formula.full_name} has the tap #{formula_tap}\n" \
+                    "but #{owner} "
+    error_message << "has not allowed this tap in `HOMEBREW_ALLOWED_TAPS`" unless formula_tap.allowed_by_env?
+    error_message << " and\n" if !formula_tap.allowed_by_env? && formula_tap.forbidden_by_env?
+    error_message << "has forbidden this tap in `HOMEBREW_FORBIDDEN_TAPS`" if formula_tap.forbidden_by_env?
+    error_message << ".#{owner_contact}"
+
+    raise CannotInstallFormulaError, error_message
+  end
+
+  sig { void }
+  def forbidden_formula_check
+    forbidden_formulae = Set.new(Homebrew::EnvConfig.forbidden_formulae.to_s.split)
+    return if forbidden_formulae.blank?
+
+    owner = Homebrew::EnvConfig.forbidden_owner
+    owner_contact = if (contact = Homebrew::EnvConfig.forbidden_owner_contact.presence)
+      "\n#{contact}"
+    end
+
+    unless ignore_deps?
+      compute_dependencies.each do |(dep, _options)|
+        dep_name = if forbidden_formulae.include?(dep.name)
+          dep.name
+        elsif dep.tap.present? &&
+              (dep_full_name = "#{dep.tap}/#{dep.name}") &&
+              forbidden_formulae.include?(dep_full_name)
+          dep_full_name
+        else
+          next
+        end
+
+        raise CannotInstallFormulaError, <<~EOS
+          The installation of #{formula.name} has a dependency #{dep_name}
+          but the #{dep_name} formula was forbidden by #{owner} in `HOMEBREW_FORBIDDEN_FORMULAE`.#{owner_contact}
+        EOS
+      end
+    end
+
+    return if only_deps?
+
+    formula_name = if forbidden_formulae.include?(formula.name)
+      formula.name
+    elsif forbidden_formulae.include?(formula.full_name)
+      formula.full_name
+    else
+      return
+    end
+
+    raise CannotInstallFormulaError, <<~EOS
+      The installation of #{formula_name} was forbidden by #{owner}
+      in `HOMEBREW_FORBIDDEN_FORMULAE`.#{owner_contact}
+    EOS
+  end
+
+  private
 
   sig { void }
   def lock
@@ -1278,52 +1638,19 @@ def lock
 
   sig { void }
   def unlock
-    return unless hold_locks?
+    return unless @hold_locks
 
     self.class.locked.each(&:unlock)
     self.class.locked.clear
     @hold_locks = false
   end
 
+  sig { void }
   def puts_requirement_messages
-    return unless @requirement_messages
     return if @requirement_messages.empty?
 
     $stderr.puts @requirement_messages
   end
-
-  sig { void }
-  def forbidden_license_check
-    forbidden_licenses = Homebrew::EnvConfig.forbidden_licenses.to_s.dup
-    SPDX::ALLOWED_LICENSE_SYMBOLS.each do |s|
-      pattern = /#{s.to_s.tr("_", " ")}/i
-      forbidden_licenses.sub!(pattern, s.to_s)
-    end
-    forbidden_licenses = forbidden_licenses.split.to_h do |license|
-      [license, SPDX.license_version_info(license)]
-    end
-
-    return if forbidden_licenses.blank?
-    return if ignore_deps?
-
-    compute_dependencies.each do |dep, _|
-      dep_f = dep.to_formula
-      next unless SPDX.licenses_forbid_installation? dep_f.license, forbidden_licenses
-
-      raise CannotInstallFormulaError, <<~EOS
-        The installation of #{formula.name} has a dependency on #{dep.name} where all
-        its licenses are forbidden by HOMEBREW_FORBIDDEN_LICENSES:
-          #{SPDX.license_expression_to_string dep_f.license}.
-      EOS
-    end
-
-    return if only_deps?
-
-    return unless SPDX.licenses_forbid_installation? formula.license, forbidden_licenses
-
-    raise CannotInstallFormulaError, <<~EOS
-      #{formula.name}'s licenses are all forbidden by HOMEBREW_FORBIDDEN_LICENSES:
-        #{SPDX.license_expression_to_string formula.license}.
-    EOS
-  end
 end
+
+require "extend/os/formula_installer"
diff --git a/Library/Homebrew/formula_name_cask_token_auditor.rb b/Library/Homebrew/formula_name_cask_token_auditor.rb
new file mode 100644
index 0000000000000..4262a4953e8f0
--- /dev/null
+++ b/Library/Homebrew/formula_name_cask_token_auditor.rb
@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  class FormulaNameCaskTokenAuditor
+    sig { returns(String) }
+    attr_reader :token
+
+    sig { params(token: String).void }
+    def initialize(token)
+      @token = token
+    end
+
+    sig { returns(T::Array[String]) }
+    def errors
+      errors = []
+
+      errors << "uppercase letters" if token.match?(/[A-Z]/)
+      errors << "whitespace" if token.match?(/\s/)
+      errors << "non-ASCII characters" unless token.ascii_only?
+      errors << "double hyphens" if token.include?("--")
+
+      errors << "a leading @" if token.start_with?("@")
+      errors << "a trailing @" if token.end_with?("@")
+      errors << "a leading hyphen" if token.start_with?("-")
+      errors << "a trailing hyphen" if token.end_with?("-")
+
+      errors << "multiple @ symbols" if token.count("@") > 1
+
+      errors << "a hyphen followed by an @" if token.include? "-@"
+      errors << "an @ followed by a hyphen" if token.include? "@-"
+
+      errors
+    end
+  end
+end
diff --git a/Library/Homebrew/formula_path.sh b/Library/Homebrew/formula_path.sh
new file mode 100644
index 0000000000000..c23174971c91a
--- /dev/null
+++ b/Library/Homebrew/formula_path.sh
@@ -0,0 +1,89 @@
+# does the quickest output of brew --prefix/--cellar possible for the basic cases:
+# - `brew --prefix` (output HOMEBREW_PREFIX)
+# - `brew --cellar` (output HOMEBREW_CELLAR)
+# - `brew --prefix <formula>` (output HOMEBREW_PREFIX/opt/<formula>)
+# - `brew --cellar <formula>` (output HOMEBREW_CELLAR/<formula>)
+# anything else? delegate to the slower cmd/--prefix.rb and cmd/--cellar.rb
+# HOMEBREW_PREFIX and HOMEBREW_REPOSITORY are set by brew.sh
+# shellcheck disable=SC2154
+homebrew-formula-path() {
+  while [[ "$#" -gt 0 ]]
+  do
+    case "$1" in
+      # check we actually have --prefix and not e.g. --prefixsomething
+      --prefix)
+        local prefix="1"
+        shift
+        ;;
+      --cellar)
+        local cellar="1"
+        shift
+        ;;
+      # reject all other flags
+      -*) return 1 ;;
+      *)
+        [[ -n "${formula}" ]] && return 1
+        local formula="$1"
+        shift
+        ;;
+    esac
+  done
+  [[ -z "${prefix}" && -z "${cellar}" ]] && return 1
+  [[ -n "${prefix}" && -n "${cellar}" ]] && return 1 # don't allow both!
+  if [[ -z "${formula}" ]]
+  then
+    if [[ -n "${prefix}" ]]
+    then
+      echo "${HOMEBREW_PREFIX}"
+    else
+      echo "${HOMEBREW_CELLAR}"
+    fi
+    return 0
+  fi
+
+  local formula_exists
+  if [[ -f "${HOMEBREW_REPOSITORY}/Library/Taps/homebrew/homebrew-core/Formula/${formula}.rb" ]]
+  then
+    formula_exists="1"
+  else
+    local formula_path
+    formula_path="$(
+      shopt -s nullglob
+      echo "${HOMEBREW_REPOSITORY}/Library/Taps"/*/*/{Formula/,HomebrewFormula/,Formula/*/,}"${formula}.rb"
+    )"
+    [[ -n "${formula_path}" ]] && formula_exists="1"
+  fi
+
+  if [[ -z "${formula_exists}" &&
+        -z "${HOMEBREW_NO_INSTALL_FROM_API}" ]]
+  then
+    if [[ -f "${HOMEBREW_CACHE}/api/formula_names.txt" ]] &&
+       grep -Fxq "${formula}" "${HOMEBREW_CACHE}/api/formula_names.txt"
+    then
+      formula_exists="1"
+    elif [[ -f "${HOMEBREW_CACHE}/api/formula_aliases.txt" ]]
+    then
+      while IFS="|" read -r alias_name real_name
+      do
+        case "${alias_name}" in
+          "${formula}")
+            formula_exists="1"
+            formula="${real_name}"
+            break
+            ;;
+          *) ;;
+        esac
+      done <"${HOMEBREW_CACHE}/api/formula_aliases.txt"
+    fi
+  fi
+
+  [[ -z "${formula_exists}" ]] && return 1
+
+  if [[ -n "${prefix}" ]]
+  then
+    echo "${HOMEBREW_PREFIX}/opt/${formula}"
+  else
+    echo "${HOMEBREW_CELLAR}/${formula}"
+  fi
+  return 0
+}
diff --git a/Library/Homebrew/formula_pin.rb b/Library/Homebrew/formula_pin.rb
index 8c63cb01e0f62..141b30bad2540 100644
--- a/Library/Homebrew/formula_pin.rb
+++ b/Library/Homebrew/formula_pin.rb
@@ -1,43 +1,52 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "keg"
 
 # Helper functions for pinning a formula.
-#
-# @api private
 class FormulaPin
-  def initialize(f)
-    @f = f
+  sig { params(formula: Formula).void }
+  def initialize(formula)
+    @formula = formula
   end
 
+  sig { returns(Pathname) }
   def path
-    HOMEBREW_PINNED_KEGS/@f.name
+    HOMEBREW_PINNED_KEGS/@formula.name
   end
 
+  sig { params(version: PkgVersion).void }
   def pin_at(version)
     HOMEBREW_PINNED_KEGS.mkpath
-    version_path = @f.rack/version
+    version_path = @formula.rack/version.to_s
     path.make_relative_symlink(version_path) if !pinned? && version_path.exist?
   end
 
+  sig { void }
   def pin
-    pin_at(@f.installed_kegs.map(&:version).max)
+    latest_keg = @formula.installed_kegs.max_by(&:scheme_and_version)
+    return if latest_keg.nil?
+
+    pin_at(latest_keg.version)
   end
 
+  sig { void }
   def unpin
     path.unlink if pinned?
     HOMEBREW_PINNED_KEGS.rmdir_if_possible
   end
 
+  sig { returns(T::Boolean) }
   def pinned?
     path.symlink?
   end
 
+  sig { returns(T::Boolean) }
   def pinnable?
-    !@f.installed_prefixes.empty?
+    !@formula.installed_prefixes.empty?
   end
 
+  sig { returns(T.nilable(PkgVersion)) }
   def pinned_version
     Keg.new(path.resolved_path).version if pinned?
   end
diff --git a/Library/Homebrew/formula_support.rb b/Library/Homebrew/formula_support.rb
index 4859606c9b357..9380275617328 100644
--- a/Library/Homebrew/formula_support.rb
+++ b/Library/Homebrew/formula_support.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 # Used to track formulae that cannot be installed at the same time.
@@ -7,8 +7,6 @@
 # Used to annotate formulae that duplicate macOS-provided software
 # or cause conflicts when linked in.
 class KegOnlyReason
-  extend T::Sig
-
   attr_reader :reason
 
   def initialize(reason, explanation)
@@ -39,6 +37,7 @@ def applicable?
     !by_macos?
   end
 
+  sig { returns(String) }
   def to_s
     return @explanation unless @explanation.empty?
 
diff --git a/Library/Homebrew/formula_text_auditor.rb b/Library/Homebrew/formula_text_auditor.rb
deleted file mode 100644
index b4bcc52453efb..0000000000000
--- a/Library/Homebrew/formula_text_auditor.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module Homebrew
-  # Auditor for checking common violations in {Formula} text content.
-  #
-  # @api private
-  class FormulaTextAuditor
-    def initialize(path)
-      @text = path.open("rb", &:read)
-      @lines = @text.lines.to_a
-    end
-
-    def without_patch
-      @text.split("\n__END__").first
-    end
-
-    def trailing_newline?
-      /\Z\n/ =~ @text
-    end
-
-    def =~(other)
-      other =~ @text
-    end
-
-    def include?(s)
-      @text.include? s
-    end
-
-    def line_number(regex, skip = 0)
-      index = @lines.drop(skip).index { |line| line =~ regex }
-      index ? index + 1 : nil
-    end
-
-    def reverse_line_number(regex)
-      index = @lines.reverse.index { |line| line =~ regex }
-      index ? @lines.count - index : nil
-    end
-  end
-end
diff --git a/Library/Homebrew/formula_versions.rb b/Library/Homebrew/formula_versions.rb
index 281e9f8be04c9..62a650fd0b96d 100644
--- a/Library/Homebrew/formula_versions.rb
+++ b/Library/Homebrew/formula_versions.rb
@@ -1,11 +1,11 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "formula"
 
 # Helper class for traversing a formula's previous versions.
 #
-# @api private
+# @api internal
 class FormulaVersions
   include Context
 
@@ -15,47 +15,71 @@ class FormulaVersions
     ErrorDuringExecution, LoadError, MethodDeprecatedError
   ].freeze
 
-  MAX_VERSIONS_DEPTH = 2
-
-  attr_reader :name, :path, :repository, :entry_name
-
+  sig { params(formula: Formula).void }
   def initialize(formula)
     @name = formula.name
     @path = formula.path
-    @repository = formula.tap.path
-    @entry_name = @path.relative_path_from(repository).to_s
-    @current_formula = formula
+    @repository = T.must(formula.tap).path
+    @relative_path = @path.relative_path_from(repository).to_s
+    # Also look at e.g. older homebrew-core paths before sharding.
+    if (match = @relative_path.match(%r{^(HomebrewFormula|Formula)/([a-z]|lib)/(.+)}))
+      @old_relative_path = "#{match[1]}/#{match[3]}"
+    end
     @formula_at_revision = {}
   end
 
   def rev_list(branch)
     repository.cd do
       rev_list_cmd = ["git", "rev-list", "--abbrev-commit", "--remove-empty"]
-      rev_list_cmd << "--first-parent" if repository != CoreTap.instance.path
-      Utils.popen_read(*rev_list_cmd, branch, "--", entry_name) do |io|
-        yield io.readline.chomp until io.eof?
+      [relative_path, old_relative_path].compact.each do |entry|
+        Utils.popen_read(*rev_list_cmd, branch, "--", entry) do |io|
+          yield [io.readline.chomp, entry] until io.eof?
+        end
       end
     end
   end
 
-  def file_contents_at_revision(rev)
-    repository.cd { Utils.popen_read("git", "cat-file", "blob", "#{rev}:#{entry_name}") }
-  end
-
-  def formula_at_revision(rev)
+  sig {
+    type_parameters(:U)
+      .params(
+        revision:              String,
+        formula_relative_path: String,
+        _block:                T.proc.params(arg0: Formula).returns(T.type_parameter(:U)),
+      ).returns(T.nilable(T.type_parameter(:U)))
+  }
+  def formula_at_revision(revision, formula_relative_path = relative_path, &_block)
     Homebrew.raise_deprecation_exceptions = true
 
-    yield @formula_at_revision[rev] ||= begin
-      contents = file_contents_at_revision(rev)
+    yield @formula_at_revision[revision] ||= begin
+      contents = file_contents_at_revision(revision, formula_relative_path)
       nostdout { Formulary.from_contents(name, path, contents, ignore_errors: true) }
     end
   rescue *IGNORED_EXCEPTIONS => e
+    require "utils/backtrace"
+
     # We rescue these so that we can skip bad versions and
     # continue walking the history
-    odebug "#{e} in #{name} at revision #{rev}", e.backtrace
+    odebug "#{e} in #{name} at revision #{revision}", Utils::Backtrace.clean(e)
   rescue FormulaUnavailableError
     nil
   ensure
     Homebrew.raise_deprecation_exceptions = false
   end
+
+  private
+
+  attr_reader :name, :path, :repository, :relative_path, :old_relative_path
+
+  sig { params(revision: String, relative_path: String).returns(String) }
+  def file_contents_at_revision(revision, relative_path)
+    repository.cd { Utils.popen_read("git", "cat-file", "blob", "#{revision}:#{relative_path}") }
+  end
+
+  def nostdout(&block)
+    if verbose?
+      yield
+    else
+      redirect_stdout(File::NULL, &block)
+    end
+  end
 end
diff --git a/Library/Homebrew/formulary.rb b/Library/Homebrew/formulary.rb
index df7bfff951e05..67ae6b78ad7c7 100644
--- a/Library/Homebrew/formulary.rb
+++ b/Library/Homebrew/formulary.rb
@@ -1,24 +1,34 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "digest/md5"
+require "digest/sha2"
 require "extend/cachable"
 require "tab"
+require "utils"
 require "utils/bottles"
-
-require "active_support/core_ext/hash/deep_transform_values"
+require "service"
+require "utils/curl"
+require "deprecate_disable"
+require "extend/hash/deep_transform_values"
+require "extend/hash/keys"
+require "tap"
 
 # The {Formulary} is responsible for creating instances of {Formula}.
 # It is not meant to be used directly from formulae.
-#
-# @api private
 module Formulary
-  extend T::Sig
-
+  extend Context
   extend Cachable
 
-  URL_START_REGEX = %r{(https?|ftp|file)://}.freeze
+  ALLOWED_URL_SCHEMES = %w[file].freeze
+  private_constant :ALLOWED_URL_SCHEMES
 
+  # `:codesign` and custom requirement classes are not supported.
+  API_SUPPORTED_REQUIREMENTS = [:arch, :linux, :macos, :maximum_macos, :xcode].freeze
+  private_constant :API_SUPPORTED_REQUIREMENTS
+
+  # Enable the factory cache.
+  #
+  # @api internal
   sig { void }
   def self.enable_factory_cache!
     @factory_cache = true
@@ -28,41 +38,50 @@ def self.factory_cached?
     !@factory_cache.nil?
   end
 
+  def self.platform_cache
+    cache["#{Homebrew::SimulateSystem.current_os}_#{Homebrew::SimulateSystem.current_arch}"] ||= {}
+  end
+
   def self.formula_class_defined_from_path?(path)
-    cache.key?(:path) && cache[:path].key?(path)
+    platform_cache.key?(:path) && platform_cache[:path].key?(path)
   end
 
   def self.formula_class_defined_from_api?(name)
-    cache.key?(:api) && cache[:api].key?(name)
+    platform_cache.key?(:api) && platform_cache[:api].key?(name)
   end
 
   def self.formula_class_get_from_path(path)
-    cache[:path].fetch(path)
+    platform_cache[:path].fetch(path)
   end
 
   def self.formula_class_get_from_api(name)
-    cache[:api].fetch(name)
+    platform_cache[:api].fetch(name)
   end
 
   def self.clear_cache
-    cache.each do |type, cached_objects|
+    platform_cache.each do |type, cached_objects|
       next if type == :formulary_factory
 
       cached_objects.each_value do |klass|
-        namespace = klass.name.deconstantize
-        next if namespace.deconstantize != name
+        class_name = klass.name
+
+        # Already removed from namespace.
+        next if class_name.nil?
 
-        remove_const(namespace.demodulize)
+        namespace = Utils.deconstantize(class_name)
+        next if Utils.deconstantize(namespace) != name
+
+        remove_const(Utils.demodulize(namespace).to_sym)
       end
     end
 
     super
   end
 
-  # @private
   module PathnameWriteMkpath
     refine Pathname do
       def write(content, offset = nil, **open_args)
+        T.bind(self, Pathname)
         raise "Will not overwrite #{self}" if exist? && !offset && !open_args[:mode]&.match?(/^a\+?$/)
 
         dirname.mkpath
@@ -88,7 +107,7 @@ def self.load_formula(name, path, contents, namespace, flags:, ignore_errors:)
       # access them from within the formula's class scope.
       mod.const_set(:BUILD_FLAGS, flags)
       mod.module_eval(contents, path)
-    rescue NameError, ArgumentError, ScriptError, MethodDeprecatedError, MacOSVersionError => e
+    rescue NameError, ArgumentError, ScriptError, MethodDeprecatedError, MacOSVersion::Error => e
       if e.is_a?(Ignorable::ExceptionMixin)
         e.ignore
       else
@@ -116,16 +135,28 @@ def self.load_formula(name, path, contents, namespace, flags:, ignore_errors:)
     end
   end
 
+  sig { params(identifier: String).returns(String) }
+  def self.namespace_key(identifier)
+    Digest::SHA2.hexdigest(
+      "#{Homebrew::SimulateSystem.current_os}_#{Homebrew::SimulateSystem.current_arch}:#{identifier}",
+    )
+  end
+
+  sig {
+    params(name: String, path: Pathname, flags: T::Array[String], ignore_errors: T::Boolean)
+      .returns(T.class_of(Formula))
+  }
   def self.load_formula_from_path(name, path, flags:, ignore_errors:)
     contents = path.open("r") { |f| ensure_utf8_encoding(f).read }
-    namespace = "FormulaNamespace#{Digest::MD5.hexdigest(path.to_s)}"
-    klass = load_formula(name, path, contents, namespace, flags: flags, ignore_errors: ignore_errors)
-    cache[:path] ||= {}
-    cache[:path][path] = klass
+    namespace = "FormulaNamespace#{namespace_key(path.to_s)}"
+    klass = load_formula(name, path, contents, namespace, flags:, ignore_errors:)
+    platform_cache[:path] ||= {}
+    platform_cache[:path][path] = klass
   end
 
+  sig { params(name: String, flags: T::Array[String]).returns(T.class_of(Formula)) }
   def self.load_formula_from_api(name, flags:)
-    namespace = "FormulaNamespaceAPI#{Digest::MD5.hexdigest(name)}"
+    namespace = :"FormulaNamespaceAPI#{namespace_key(name)}"
 
     mod = Module.new
     remove_const(namespace) if const_defined?(namespace)
@@ -133,89 +164,326 @@ def self.load_formula_from_api(name, flags:)
 
     mod.const_set(:BUILD_FLAGS, flags)
 
-    class_s = Formulary.class_s(name)
+    class_name = class_s(name)
     json_formula = Homebrew::API::Formula.all_formulae[name]
+    raise FormulaUnavailableError, name if json_formula.nil?
+
+    json_formula = Homebrew::API.merge_variations(json_formula)
+
+    uses_from_macos_names = json_formula.fetch("uses_from_macos", []).map do |dep|
+      next dep unless dep.is_a? Hash
+
+      dep.keys.first
+    end
+
+    requirements = {}
+    json_formula["requirements"]&.map do |req|
+      req_name = req["name"].to_sym
+      next if API_SUPPORTED_REQUIREMENTS.exclude?(req_name)
+
+      req_version = case req_name
+      when :arch
+        req["version"]&.to_sym
+      when :macos, :maximum_macos
+        MacOSVersion::SYMBOLS.key(req["version"])
+      else
+        req["version"]
+      end
+
+      req_tags = []
+      req_tags << req_version if req_version.present?
+      req_tags += req["contexts"]&.map do |tag|
+        case tag
+        when String
+          tag.to_sym
+        when Hash
+          tag.deep_transform_keys(&:to_sym)
+        else
+          tag
+        end
+      end
+
+      spec_hash = req_tags.empty? ? req_name : { req_name => req_tags }
+
+      specs = req["specs"]
+      specs ||= ["stable", "head"] # backwards compatibility
+      specs.each do |spec|
+        requirements[spec.to_sym] ||= []
+        requirements[spec.to_sym] << spec_hash
+      end
+    end
+
+    add_deps = if Homebrew::API.internal_json_v3?
+      lambda do |deps|
+        T.bind(self, SoftwareSpec)
+
+        deps&.each do |name, info|
+          tags = case info&.dig("tags")
+          in Array => tag_list
+            tag_list.map(&:to_sym)
+          in String => tag
+            tag.to_sym
+          else
+            nil
+          end
+
+          if info&.key?("uses_from_macos")
+            bounds = info["uses_from_macos"].dup || {}
+            bounds.deep_transform_keys!(&:to_sym)
+            bounds.deep_transform_values!(&:to_sym)
+
+            if tags
+              uses_from_macos name => tags, **bounds
+            else
+              uses_from_macos name, **bounds
+            end
+          elsif tags
+            depends_on name => tags
+          else
+            depends_on name
+          end
+        end
+      end
+    else
+      lambda do |spec|
+        T.bind(self, SoftwareSpec)
+
+        dep_json = json_formula.fetch("#{spec}_dependencies", json_formula)
+
+        dep_json["dependencies"]&.each do |dep|
+          # Backwards compatibility check - uses_from_macos used to be a part of dependencies on Linux
+          next if !json_formula.key?("uses_from_macos_bounds") && uses_from_macos_names.include?(dep) &&
+                  !Homebrew::SimulateSystem.simulating_or_running_on_macos?
+
+          depends_on dep
+        end
+
+        [:build, :test, :recommended, :optional].each do |type|
+          dep_json["#{type}_dependencies"]&.each do |dep|
+            # Backwards compatibility check - uses_from_macos used to be a part of dependencies on Linux
+            next if !json_formula.key?("uses_from_macos_bounds") && uses_from_macos_names.include?(dep) &&
+                    !Homebrew::SimulateSystem.simulating_or_running_on_macos?
+
+            depends_on dep => type
+          end
+        end
+
+        dep_json["uses_from_macos"]&.each_with_index do |dep, index|
+          bounds = dep_json.fetch("uses_from_macos_bounds", [])[index].dup || {}
+          bounds.deep_transform_keys!(&:to_sym)
+          bounds.deep_transform_values!(&:to_sym)
+
+          if dep.is_a?(Hash)
+            uses_from_macos dep.deep_transform_values(&:to_sym).merge(bounds)
+          else
+            uses_from_macos dep, bounds
+          end
+        end
+      end
+    end
 
     klass = Class.new(::Formula) do
+      @loaded_from_api = true
+
       desc json_formula["desc"]
       homepage json_formula["homepage"]
-      license json_formula["license"]
-      revision json_formula["revision"]
-      version_scheme json_formula["version_scheme"]
+      license SPDX.string_to_license_expression(json_formula["license"])
+      revision json_formula.fetch("revision", 0)
+      version_scheme json_formula.fetch("version_scheme", 0)
 
-      if (urls_stable = json_formula["urls"]["stable"]).present?
+      if (urls_stable = json_formula["urls"]["stable"].presence)
         stable do
-          url urls_stable["url"]
-          version json_formula["versions"]["stable"]
+          url_spec = {
+            tag:      urls_stable["tag"],
+            revision: urls_stable["revision"],
+            using:    urls_stable["using"]&.to_sym,
+          }.compact
+          url urls_stable["url"], **url_spec
+          version Homebrew::API.internal_json_v3? ? json_formula["version"] : json_formula["versions"]["stable"]
+          sha256 urls_stable["checksum"] if urls_stable["checksum"].present?
+
+          if Homebrew::API.internal_json_v3?
+            instance_exec(json_formula["dependencies"], &add_deps)
+          else
+            instance_exec(:stable, &add_deps)
+          end
+
+          requirements[:stable]&.each do |req|
+            depends_on req
+          end
         end
       end
 
-      if (bottles_stable = json_formula["bottle"]["stable"]).present?
+      if (urls_head = json_formula["urls"]["head"].presence)
+        head do
+          url_spec = {
+            branch: urls_head["branch"],
+            using:  urls_head["using"]&.to_sym,
+          }.compact
+          url urls_head["url"], **url_spec
+
+          if Homebrew::API.internal_json_v3?
+            instance_exec(json_formula["head_dependencies"], &add_deps)
+          else
+            instance_exec(:head, &add_deps)
+          end
+
+          requirements[:head]&.each do |req|
+            depends_on req
+          end
+        end
+      end
+
+      bottles_stable = if Homebrew::API.internal_json_v3?
+        json_formula["bottle"]
+      else
+        json_formula["bottle"]["stable"]
+      end.presence
+
+      if bottles_stable
         bottle do
-          root_url bottles_stable["root_url"]
+          if Homebrew::EnvConfig.bottle_domain == HOMEBREW_BOTTLE_DEFAULT_DOMAIN
+            root_url HOMEBREW_BOTTLE_DEFAULT_DOMAIN
+          else
+            root_url Homebrew::EnvConfig.bottle_domain
+          end
           rebuild bottles_stable["rebuild"]
           bottles_stable["files"].each do |tag, bottle_spec|
             cellar = Formulary.convert_to_string_or_symbol bottle_spec["cellar"]
-            sha256 cellar: cellar, tag.to_sym => bottle_spec["sha256"]
+            sha256 cellar:, tag.to_sym => bottle_spec["sha256"]
           end
         end
       end
 
-      if (keg_only_reason = json_formula["keg_only_reason"]).present?
+      if (pour_bottle_only_if = json_formula["pour_bottle_only_if"])
+        pour_bottle? only_if: pour_bottle_only_if.to_sym
+      end
+
+      if (keg_only_reason = json_formula["keg_only_reason"].presence)
         reason = Formulary.convert_to_string_or_symbol keg_only_reason["reason"]
         keg_only reason, keg_only_reason["explanation"]
       end
 
-      if (deprecation_date = json_formula["deprecation_date"]).present?
-        reason = Formulary.convert_to_deprecate_disable_reason_string_or_symbol json_formula["deprecation_reason"]
+      if (deprecation_date = json_formula["deprecation_date"].presence)
+        reason = DeprecateDisable.to_reason_string_or_symbol json_formula["deprecation_reason"], type: :formula
         deprecate! date: deprecation_date, because: reason
       end
 
-      if (disable_date = json_formula["disable_date"]).present?
-        reason = Formulary.convert_to_deprecate_disable_reason_string_or_symbol json_formula["disable_reason"]
+      if (disable_date = json_formula["disable_date"].presence)
+        reason = DeprecateDisable.to_reason_string_or_symbol json_formula["disable_reason"], type: :formula
         disable! date: disable_date, because: reason
       end
 
-      json_formula["build_dependencies"].each do |dep|
-        depends_on dep => :build
+      json_formula["conflicts_with"]&.each_with_index do |conflict, index|
+        conflicts_with conflict, because: json_formula.dig("conflicts_with_reasons", index)
       end
 
-      json_formula["dependencies"].each do |dep|
-        depends_on dep
+      json_formula["link_overwrite"]&.each do |overwrite_path|
+        link_overwrite overwrite_path
       end
 
-      json_formula["recommended_dependencies"].each do |dep|
-        depends_on dep => :recommended
+      def install
+        raise "Cannot build from source from abstract formula."
       end
 
-      json_formula["optional_dependencies"].each do |dep|
-        depends_on dep => :optional
+      @post_install_defined_boolean = json_formula["post_install_defined"]
+      @post_install_defined_boolean = true if @post_install_defined_boolean.nil? # Backwards compatibility
+      def post_install_defined?
+        self.class.instance_variable_get(:@post_install_defined_boolean)
       end
 
-      json_formula["uses_from_macos"].each do |dep|
-        dep = dep.deep_transform_values(&:to_sym) if dep.is_a?(Hash)
-        uses_from_macos dep
-      end
+      if (service_hash = json_formula["service"].presence)
+        service_hash = Homebrew::Service.from_hash(service_hash)
+        service do
+          T.bind(self, Homebrew::Service)
+
+          if (run_params = service_hash.delete(:run).presence)
+            case run_params
+            when Hash
+              run(**run_params)
+            when Array, String
+              run run_params
+            end
+          end
 
-      def install
-        raise "Cannot build from source from abstract formula."
+          if (name_params = service_hash.delete(:name).presence)
+            name(**name_params)
+          end
+
+          service_hash.each do |key, arg|
+            public_send(key, arg)
+          end
+        end
       end
 
       @caveats_string = json_formula["caveats"]
       def caveats
         self.class.instance_variable_get(:@caveats_string)
+            &.gsub(HOMEBREW_PREFIX_PLACEHOLDER, HOMEBREW_PREFIX)
+            &.gsub(HOMEBREW_CELLAR_PLACEHOLDER, HOMEBREW_CELLAR)
+            &.gsub(HOMEBREW_HOME_PLACEHOLDER, Dir.home)
+      end
+
+      @tap_git_head_string = if Homebrew::API.internal_json_v3?
+        Homebrew::API::Formula.tap_git_head
+      else
+        json_formula["tap_git_head"]
+      end
+
+      def tap_git_head
+        self.class.instance_variable_get(:@tap_git_head_string)
+      end
+
+      unless Homebrew::API.internal_json_v3?
+        @oldnames_array = json_formula["oldnames"] || [json_formula["oldname"]].compact
+        def oldnames
+          self.class.instance_variable_get(:@oldnames_array)
+        end
+
+        @aliases_array = json_formula.fetch("aliases", [])
+        def aliases
+          self.class.instance_variable_get(:@aliases_array)
+        end
+      end
+
+      @versioned_formulae_array = json_formula.fetch("versioned_formulae", [])
+      def versioned_formulae_names
+        self.class.instance_variable_get(:@versioned_formulae_array)
+      end
+
+      @ruby_source_path_string = json_formula["ruby_source_path"]
+      def ruby_source_path
+        self.class.instance_variable_get(:@ruby_source_path_string)
+      end
+
+      @ruby_source_checksum_string = json_formula.dig("ruby_source_checksum", "sha256")
+      @ruby_source_checksum_string ||= json_formula["ruby_source_sha256"]
+      def ruby_source_checksum
+        checksum = self.class.instance_variable_get(:@ruby_source_checksum_string)
+        Checksum.new(checksum) if checksum
       end
     end
 
-    mod.const_set(class_s, klass)
+    mod.const_set(class_name, klass)
 
-    cache[:api] ||= {}
-    cache[:api][name] = klass
+    platform_cache[:api] ||= {}
+    platform_cache[:api][name] = klass
   end
 
-  def self.resolve(name, spec: nil, force_bottle: false, flags: [])
+  sig { params(name: String, spec: Symbol, force_bottle: T::Boolean, flags: T::Array[String]).returns(Formula) }
+  def self.resolve(
+    name,
+    spec: T.unsafe(nil),
+    force_bottle: T.unsafe(nil),
+    flags: T.unsafe(nil)
+  )
+    options = {
+      force_bottle:,
+      flags:,
+    }.compact
+
     if name.include?("/") || File.exist?(name)
-      f = factory(name, *spec, force_bottle: force_bottle, flags: flags)
+      f = factory(name, *spec, **options)
       if f.any_version_installed?
         tab = Tab.for_formula(f)
         resolved_spec = spec || tab.spec
@@ -228,8 +496,10 @@ def self.resolve(name, spec: nil, force_bottle: false, flags: [])
       end
     else
       rack = to_rack(name)
-      alias_path = factory(name, force_bottle: force_bottle, flags: flags).alias_path
-      f = from_rack(rack, *spec, alias_path: alias_path, force_bottle: force_bottle, flags: flags)
+      if (alias_path = factory(name, **options).alias_path)
+        options[:alias_path] = alias_path
+      end
+      f = from_rack(rack, *spec, **options)
     end
 
     # If this formula was installed with an alias that has since changed,
@@ -251,7 +521,7 @@ def self.ensure_utf8_encoding(io)
 
   def self.class_s(name)
     class_name = name.capitalize
-    class_name.gsub!(/[-_.\s]([a-zA-Z0-9])/) { Regexp.last_match(1).upcase }
+    class_name.gsub!(/[-_.\s]([a-zA-Z0-9])/) { T.must(Regexp.last_match(1)).upcase }
     class_name.tr!("+", "x")
     class_name.sub!(/(.)@(\d)/, "\\1AT\\2")
     class_name
@@ -263,28 +533,33 @@ def self.convert_to_string_or_symbol(string)
     string
   end
 
-  def self.convert_to_deprecate_disable_reason_string_or_symbol(string)
-    require "deprecate_disable"
-    return string unless DeprecateDisable::DEPRECATE_DISABLE_REASONS.keys.map(&:to_s).include?(string)
-
-    string.to_sym
-  end
-
   # A {FormulaLoader} returns instances of formulae.
   # Subclasses implement loaders for particular sources of formulae.
   class FormulaLoader
     include Context
 
-    # The formula's name
+    # The formula's name.
+    sig { returns(String) }
     attr_reader :name
-    # The formula's ruby file's path or filename
+
+    # The formula file's path.
+    sig { returns(Pathname) }
     attr_reader :path
-    # The name used to install the formula
+
+    # The name used to install the formula.
+    sig { returns(T.nilable(Pathname)) }
     attr_reader :alias_path
 
-    def initialize(name, path)
+    # The formula's tap (`nil` if it should be implicitly determined).
+    sig { returns(T.nilable(Tap)) }
+    attr_reader :tap
+
+    sig { params(name: String, path: Pathname, alias_path: Pathname, tap: Tap).void }
+    def initialize(name, path, alias_path: T.unsafe(nil), tap: T.unsafe(nil))
       @name = name
-      @path = path.resolved_path
+      @path = path
+      @alias_path = alias_path
+      @tap = tap
     end
 
     # Gets the formula instance.
@@ -292,54 +567,52 @@ def initialize(name, path)
     # a formula that was loaded in another way.
     def get_formula(spec, alias_path: nil, force_bottle: false, flags: [], ignore_errors: false)
       alias_path ||= self.alias_path
-      klass(flags: flags, ignore_errors: ignore_errors)
-        .new(name, path, spec, alias_path: alias_path, force_bottle: force_bottle)
+      klass(flags:, ignore_errors:)
+        .new(name, path, spec, alias_path:, tap:, force_bottle:)
     end
 
     def klass(flags:, ignore_errors:)
-      load_file(flags: flags, ignore_errors: ignore_errors) unless Formulary.formula_class_defined_from_path?(path)
+      load_file(flags:, ignore_errors:) unless Formulary.formula_class_defined_from_path?(path)
       Formulary.formula_class_get_from_path(path)
     end
 
     private
 
     def load_file(flags:, ignore_errors:)
-      $stderr.puts "#{$PROGRAM_NAME} (#{self.class.name}): loading #{path}" if debug?
       raise FormulaUnavailableError, name unless path.file?
 
-      Formulary.load_formula_from_path(name, path, flags: flags, ignore_errors: ignore_errors)
+      Formulary.load_formula_from_path(name, path, flags:, ignore_errors:)
     end
   end
 
   # Loads a formula from a bottle.
-  class BottleLoader < FormulaLoader
-    def initialize(bottle_name)
-      case bottle_name
-      when URL_START_REGEX
-        # The name of the formula is found between the last slash and the last hyphen.
-        formula_name = File.basename(bottle_name)[/(.+)-/, 1]
-        resource = Resource.new(formula_name) { url bottle_name }
-        resource.specs[:bottle] = true
-        downloader = resource.downloader
-        cached = downloader.cached_location.exist?
-        downloader.fetch
-        ohai "Pouring the cached bottle" if cached
-        @bottle_filename = downloader.cached_location
-      else
-        @bottle_filename = Pathname(bottle_name).realpath
-      end
-      name, full_name = Utils::Bottles.resolve_formula_names @bottle_filename
+  class FromBottleLoader < FormulaLoader
+    sig {
+      params(ref: T.any(String, Pathname, URI::Generic), from: Symbol, warn: T::Boolean)
+        .returns(T.nilable(T.attached_class))
+    }
+    def self.try_new(ref, from: T.unsafe(nil), warn: false)
+      return if Homebrew::EnvConfig.forbid_packages_from_paths?
+
+      ref = ref.to_s
+
+      new(ref) if HOMEBREW_BOTTLES_EXTNAME_REGEX.match?(ref) && File.exist?(ref)
+    end
+
+    def initialize(bottle_name, warn: false)
+      @bottle_path = Pathname(bottle_name).realpath
+      name, full_name = Utils::Bottles.resolve_formula_names(@bottle_path)
       super name, Formulary.path(full_name)
     end
 
     def get_formula(spec, force_bottle: false, flags: [], ignore_errors: false, **)
       formula = begin
-        contents = Utils::Bottles.formula_contents @bottle_filename, name: name
-        Formulary.from_contents(name, path, contents, spec, force_bottle: force_bottle,
-                                flags: flags, ignore_errors: ignore_errors)
+        contents = Utils::Bottles.formula_contents(@bottle_path, name:)
+        Formulary.from_contents(name, path, contents, spec, force_bottle:,
+                                flags:, ignore_errors:)
       rescue FormulaUnreadableError => e
         opoo <<~EOS
-          Unreadable formula in #{@bottle_filename}:
+          Unreadable formula in #{@bottle_path}:
           #{e}
         EOS
         super
@@ -350,49 +623,118 @@ def get_formula(spec, force_bottle: false, flags: [], ignore_errors: false, **)
         EOS
         super
       end
-      formula.local_bottle_path = @bottle_filename
+      formula.local_bottle_path = @bottle_path
       formula
     end
   end
 
-  # Loads a formula from a path to an alias.
-  class AliasLoader < FormulaLoader
-    def initialize(alias_path)
-      path = alias_path.resolved_path
-      name = path.basename(".rb").to_s
-      super name, path
-      @alias_path = alias_path.to_s
-    end
-  end
-
   # Loads formulae from disk using a path.
   class FromPathLoader < FormulaLoader
-    def initialize(path)
-      path = Pathname.new(path).expand_path
-      super path.basename(".rb").to_s, path
+    sig {
+      params(ref: T.any(String, Pathname, URI::Generic), from: Symbol, warn: T::Boolean)
+        .returns(T.nilable(T.attached_class))
+    }
+    def self.try_new(ref, from: T.unsafe(nil), warn: false)
+      path = case ref
+      when String
+        Pathname(ref)
+      when Pathname
+        ref
+      else
+        return
+      end
+
+      return unless path.expand_path.exist?
+
+      return if Homebrew::EnvConfig.forbid_packages_from_paths? &&
+                !path.realpath.to_s.start_with?("#{HOMEBREW_CELLAR}/", "#{HOMEBREW_LIBRARY}/Taps/")
+
+      options = if (tap = Tap.from_path(path))
+        # Only treat symlinks in taps as aliases.
+        if path.symlink?
+          alias_path = path
+          path = alias_path.resolved_path
+
+          {
+            alias_path:,
+            tap:,
+          }
+        else
+          {
+            tap:,
+          }
+        end
+      elsif (tap = Homebrew::API.tap_from_source_download(path))
+        # Don't treat cache symlinks as aliases.
+        {
+          tap:,
+        }
+      else
+        {}
+      end
+
+      return if path.extname != ".rb"
+
+      new(path, **options)
+    end
+
+    sig { params(path: T.any(Pathname, String), alias_path: Pathname, tap: Tap).void }
+    def initialize(path, alias_path: T.unsafe(nil), tap: T.unsafe(nil))
+      path = Pathname(path).expand_path
+      name = path.basename(".rb").to_s
+      alias_path = alias_path&.expand_path
+      alias_dir = alias_path&.dirname
+
+      options = {
+        alias_path: (alias_path if alias_dir == tap&.alias_dir),
+        tap:,
+      }.compact
+
+      super(name, path, **options)
     end
   end
 
-  # Loads formulae from URLs.
-  class FromUrlLoader < FormulaLoader
-    extend T::Sig
+  # Loads formula from a URI.
+  class FromURILoader < FormulaLoader
+    sig {
+      params(ref: T.any(String, Pathname, URI::Generic), from: Symbol, warn: T::Boolean)
+        .returns(T.nilable(T.attached_class))
+    }
+    def self.try_new(ref, from: T.unsafe(nil), warn: false)
+      return if Homebrew::EnvConfig.forbid_packages_from_paths?
+
+      # Cache compiled regex
+      @uri_regex ||= begin
+        uri_regex = ::URI::DEFAULT_PARSER.make_regexp
+        Regexp.new("\\A#{uri_regex.source}\\Z", uri_regex.options)
+      end
+
+      uri = ref.to_s
+      return unless uri.match?(@uri_regex)
+
+      uri = URI(uri)
+      return unless uri.path
+      return unless uri.scheme.present?
+
+      new(uri, from:)
+    end
 
     attr_reader :url
 
-    sig { params(url: T.any(URI::Generic, String)).void }
-    def initialize(url)
+    sig { params(url: T.any(URI::Generic, String), from: T.nilable(Symbol)).void }
+    def initialize(url, from: nil)
       @url = url
-      uri = URI(url)
-      formula = File.basename(uri.path, ".rb")
-      super formula, HOMEBREW_CACHE_FORMULA/File.basename(uri.path)
+      @from = from
+      uri_path = URI(url).path
+      raise ArgumentError, "URL has no path component" unless uri_path
+
+      formula = File.basename(uri_path, ".rb")
+      super formula, HOMEBREW_CACHE_FORMULA/File.basename(uri_path)
     end
 
     def load_file(flags:, ignore_errors:)
-      if %r{githubusercontent.com/[\w-]+/[\w-]+/[a-f0-9]{40}(?:/Formula)?/(?<formula_name>[\w+-.@]+).rb} =~ url
-        raise UnsupportedInstallationMethod,
-              "Installation of #{formula_name} from a GitHub commit URL is unsupported! " \
-              "`brew extract #{formula_name}` to a stable tap on GitHub instead."
-      elsif url.match?(%r{^(https?|ftp)://})
+      url_scheme = URI(url).scheme
+      if ALLOWED_URL_SCHEMES.exclude?(url_scheme)
         raise UnsupportedInstallationMethod,
               "Non-checksummed download of #{name} formula file from an arbitrary URL is unsupported! " \
               "`brew extract` or `brew create` and `brew tap-new` to create a formula file in a tap " \
@@ -400,57 +742,58 @@ def load_file(flags:, ignore_errors:)
       end
       HOMEBREW_CACHE_FORMULA.mkpath
       FileUtils.rm_f(path)
-      curl_download url, to: path
+      Utils::Curl.curl_download url, to: path
       super
     rescue MethodDeprecatedError => e
-      if %r{github.com/(?<user>[\w-]+)/(?<repo>[\w-]+)/} =~ url
-        e.issues_url = "https://github.com/#{user}/#{repo}/issues/new"
+      if (match_data = url.match(%r{github.com/(?<user>[\w-]+)/(?<repo>[\w-]+)/}).presence)
+        e.issues_url = "https://github.com/#{match_data[:user]}/#{match_data[:repo]}/issues/new"
       end
       raise
     end
   end
 
   # Loads tapped formulae.
-  class TapLoader < FormulaLoader
+  class FromTapLoader < FormulaLoader
+    sig { returns(Tap) }
     attr_reader :tap
 
-    def initialize(tapped_name, from: nil)
-      warn = [:keg, :rack].exclude?(from)
-      name, path = formula_name_path(tapped_name, warn: warn)
-      super name, path
-    end
+    sig { returns(Pathname) }
+    attr_reader :path
 
-    def formula_name_path(tapped_name, warn: true)
-      user, repo, name = tapped_name.split("/", 3).map(&:downcase)
-      @tap = Tap.fetch user, repo
-      formula_dir = @tap.formula_dir || @tap.path
-      path = formula_dir/"#{name}.rb"
-
-      unless path.file?
-        if (possible_alias = @tap.alias_dir/name).file?
-          path = possible_alias.resolved_path
-          name = path.basename(".rb").to_s
-        elsif (new_name = @tap.formula_renames[name]) &&
-              (new_path = formula_dir/"#{new_name}.rb").file?
-          old_name = name
-          path = new_path
-          name = new_name
-          new_name = @tap.core_tap? ? name : "#{@tap}/#{name}"
-        elsif (new_tap_name = @tap.tap_migrations[name])
-          new_tap_user, new_tap_repo, = new_tap_name.split("/")
-          new_tap_name = "#{new_tap_user}/#{new_tap_repo}"
-          new_tap = Tap.fetch new_tap_name
-          new_tap.install unless new_tap.installed?
-          new_tapped_name = "#{new_tap_name}/#{name}"
-          name, path = formula_name_path(new_tapped_name, warn: false)
-          old_name = tapped_name
-          new_name = new_tap.core_tap? ? name : new_tapped_name
-        end
+    sig {
+      params(ref: T.any(String, Pathname, URI::Generic), from: Symbol, warn: T::Boolean)
+        .returns(T.nilable(FormulaLoader))
+    }
+    def self.try_new(ref, from: T.unsafe(nil), warn: false)
+      ref = ref.to_s
 
-        opoo "Use #{new_name} instead of deprecated #{old_name}" if warn && old_name && new_name
+      return unless (name_tap_type = Formulary.tap_formula_name_type(ref, warn:))
+
+      name, tap, type = name_tap_type
+      path = Formulary.find_formula_in_tap(name, tap)
+
+      options = if type == :alias
+        # TODO: Simplify this by making `tap_formula_name_type` return the alias name.
+        { alias_name: T.must(ref[HOMEBREW_TAP_FORMULA_REGEX, :name]).downcase }
+      else
+        {}
       end
 
-      [name, path]
+      if type == :migration && tap.core_tap? && (loader = FromAPILoader.try_new(name))
+        loader
+      else
+        new(name, path, tap:, **options)
+      end
+    end
+
+    sig { params(name: String, path: Pathname, tap: Tap, alias_name: String).void }
+    def initialize(name, path, tap:, alias_name: T.unsafe(nil))
+      options = {
+        alias_path: (tap.alias_dir/alias_name if alias_name),
+        tap:,
+      }.compact
+
+      super(name, path, **options)
     end
 
     def get_formula(spec, alias_path: nil, force_bottle: false, flags: [], ignore_errors: false)
@@ -471,9 +814,83 @@ def load_file(flags:, ignore_errors:)
     end
   end
 
+  # Loads a formula from a name, as long as it exists only in a single tap.
+  class FromNameLoader < FromTapLoader
+    sig {
+      params(ref: T.any(String, Pathname, URI::Generic), from: Symbol, warn: T::Boolean)
+        .returns(T.nilable(FormulaLoader))
+    }
+    def self.try_new(ref, from: T.unsafe(nil), warn: false)
+      return unless ref.is_a?(String)
+      return unless ref.match?(/\A#{HOMEBREW_TAP_FORMULA_NAME_REGEX}\Z/o)
+
+      name = ref
+
+      # If it exists in the default tap, never treat it as ambiguous with another tap.
+      if (core_tap = CoreTap.instance).installed? &&
+         (core_loader = super("#{core_tap}/#{name}", warn:))&.path&.exist?
+        return core_loader
+      end
+
+      loaders = Tap.select { |tap| tap.installed? && !tap.core_tap? }
+                   .filter_map { |tap| super("#{tap}/#{name}", warn:) }
+                   .uniq(&:path)
+                   .select { |loader| loader.is_a?(FromAPILoader) || loader.path.exist? }
+
+      case loaders.count
+      when 1
+        loaders.first
+      when 2..Float::INFINITY
+        raise TapFormulaAmbiguityError.new(name, loaders)
+      end
+    end
+  end
+
+  # Loads a formula from a formula file in a keg.
+  class FromKegLoader < FormulaLoader
+    sig {
+      params(ref: T.any(String, Pathname, URI::Generic), from: Symbol, warn: T::Boolean)
+        .returns(T.nilable(T.attached_class))
+    }
+    def self.try_new(ref, from: T.unsafe(nil), warn: false)
+      ref = ref.to_s
+
+      return unless (keg_formula = HOMEBREW_PREFIX/"opt/#{ref}/.brew/#{ref}.rb").file?
+
+      new(ref, keg_formula)
+    end
+  end
+
+  # Loads a formula from a cached formula file.
+  class FromCacheLoader < FormulaLoader
+    sig {
+      params(ref: T.any(String, Pathname, URI::Generic), from: Symbol, warn: T::Boolean)
+        .returns(T.nilable(T.attached_class))
+    }
+    def self.try_new(ref, from: T.unsafe(nil), warn: false)
+      ref = ref.to_s
+
+      return unless (cached_formula = HOMEBREW_CACHE_FORMULA/"#{ref}.rb").file?
+
+      new(ref, cached_formula)
+    end
+  end
+
   # Pseudo-loader which will raise a {FormulaUnavailableError} when trying to load the corresponding formula.
   class NullLoader < FormulaLoader
-    def initialize(name)
+    sig {
+      params(ref: T.any(String, Pathname, URI::Generic), from: Symbol, warn: T::Boolean)
+        .returns(T.nilable(T.attached_class))
+    }
+    def self.try_new(ref, from: T.unsafe(nil), warn: false)
+      return if ref.is_a?(URI::Generic)
+
+      new(ref)
+    end
+
+    sig { params(ref: T.any(String, Pathname)).void }
+    def initialize(ref)
+      name = File.basename(ref, ".rb")
       super name, Formulary.core_path(name)
     end
 
@@ -493,29 +910,63 @@ def initialize(name, path, contents)
     end
 
     def klass(flags:, ignore_errors:)
-      $stderr.puts "#{$PROGRAM_NAME} (#{self.class.name}): loading #{path}" if debug?
       namespace = "FormulaNamespace#{Digest::MD5.hexdigest(contents.to_s)}"
-      Formulary.load_formula(name, path, contents, namespace, flags: flags, ignore_errors: ignore_errors)
+      Formulary.load_formula(name, path, contents, namespace, flags:, ignore_errors:)
     end
   end
 
-  # Load formulae from the API.
-  class FormulaAPILoader < FormulaLoader
-    def initialize(name)
-      super name, Formulary.core_path(name)
+  # Load a formula from the API.
+  class FromAPILoader < FormulaLoader
+    sig {
+      params(ref: T.any(String, Pathname, URI::Generic), from: Symbol, warn: T::Boolean)
+        .returns(T.nilable(T.attached_class))
+    }
+    def self.try_new(ref, from: T.unsafe(nil), warn: false)
+      return if Homebrew::EnvConfig.no_install_from_api?
+      return unless ref.is_a?(String)
+      return unless (name = ref[HOMEBREW_DEFAULT_TAP_FORMULA_REGEX, :name])
+      if !Homebrew::API::Formula.all_formulae.key?(name) &&
+         !Homebrew::API::Formula.all_aliases.key?(name) &&
+         !Homebrew::API::Formula.all_renames.key?(name)
+        return
+      end
+
+      alias_name = name
+
+      ref = "#{CoreTap.instance}/#{name}"
+
+      return unless (name_tap_type = Formulary.tap_formula_name_type(ref, warn:))
+
+      name, tap, type = name_tap_type
+
+      options =  if type == :alias
+        { alias_name: alias_name.downcase }
+      else
+        {}
+      end
+
+      new(name, tap:, **options)
+    end
+
+    sig { params(name: String, tap: Tap, alias_name: String).void }
+    def initialize(name, tap: T.unsafe(nil), alias_name: T.unsafe(nil))
+      options = {
+        alias_path: (CoreTap.instance.alias_dir/alias_name if alias_name),
+        tap:,
+      }.compact
+
+      super(name, Formulary.core_path(name), **options)
     end
 
     def klass(flags:, ignore_errors:)
-      load_from_api(flags: flags) unless Formulary.formula_class_defined_from_api?(name)
+      load_from_api(flags:) unless Formulary.formula_class_defined_from_api?(name)
       Formulary.formula_class_get_from_api(name)
     end
 
     private
 
     def load_from_api(flags:)
-      $stderr.puts "#{$PROGRAM_NAME} (#{self.class.name}): loading #{name} from API" if debug?
-
-      Formulary.load_formula_from_api(name, flags: flags)
+      Formulary.load_formula_from_api(name, flags:)
     end
   end
 
@@ -526,88 +977,175 @@ def load_from_api(flags:)
   # * a formula pathname
   # * a formula URL
   # * a local bottle reference
+  #
+  # @api internal
+  sig {
+    params(
+      ref:           T.any(Pathname, String),
+      spec:          Symbol,
+      alias_path:    T.any(NilClass, Pathname, String),
+      from:          Symbol,
+      warn:          T::Boolean,
+      force_bottle:  T::Boolean,
+      flags:         T::Array[String],
+      ignore_errors: T::Boolean,
+    ).returns(Formula)
+  }
   def self.factory(
-    ref, spec = :stable, alias_path: nil, from: nil,
-    force_bottle: false, flags: [], ignore_errors: false
+    ref,
+    spec = :stable,
+    alias_path: nil,
+    from: T.unsafe(nil),
+    warn: T.unsafe(nil),
+    force_bottle: T.unsafe(nil),
+    flags: T.unsafe(nil),
+    ignore_errors: T.unsafe(nil)
   )
-    raise ArgumentError, "Formulae must have a ref!" unless ref
-
     cache_key = "#{ref}-#{spec}-#{alias_path}-#{from}"
-    if factory_cached? && cache[:formulary_factory] &&
-       cache[:formulary_factory][cache_key]
-      return cache[:formulary_factory][cache_key]
+    if factory_cached? && platform_cache[:formulary_factory]&.key?(cache_key)
+      return platform_cache[:formulary_factory][cache_key]
     end
 
-    formula = loader_for(ref, from: from).get_formula(spec, alias_path: alias_path,
-                                                      force_bottle: force_bottle, flags: flags,
-                                                      ignore_errors: ignore_errors)
+    loader_options = { from:, warn: }.compact
+    formula_options = { alias_path:,
+                        force_bottle:,
+                        flags:,
+                        ignore_errors: }.compact
+
+    formula = loader_for(ref, **loader_options)
+              .get_formula(spec, **formula_options)
+
     if factory_cached?
-      cache[:formulary_factory] ||= {}
-      cache[:formulary_factory][cache_key] ||= formula
+      platform_cache[:formulary_factory] ||= {}
+      platform_cache[:formulary_factory][cache_key] ||= formula
     end
+
     formula
   end
 
   # Return a {Formula} instance for the given rack.
   #
   # @param spec when nil, will auto resolve the formula's spec.
-  # @param :alias_path will be used if the formula is found not to be
-  #   installed, and discarded if it is installed because the `alias_path` used
+  # @param alias_path will be used if the formula is found not to be
+  #   installed and discarded if it is installed because the `alias_path` used
   #   to install the formula will be set instead.
-  def self.from_rack(rack, spec = nil, alias_path: nil, force_bottle: false, flags: [])
+  sig {
+    params(
+      rack:         Pathname,
+      # Automatically resolves the formula's spec if not specified.
+      spec:         Symbol,
+      alias_path:   T.any(Pathname, String),
+      force_bottle: T::Boolean,
+      flags:        T::Array[String],
+    ).returns(Formula)
+  }
+  def self.from_rack(
+    rack, spec = T.unsafe(nil),
+    alias_path: T.unsafe(nil),
+    force_bottle: T.unsafe(nil),
+    flags: T.unsafe(nil)
+  )
     kegs = rack.directory? ? rack.subdirs.map { |d| Keg.new(d) } : []
-    keg = kegs.find(&:linked?) || kegs.find(&:optlinked?) || kegs.max_by(&:version)
+    keg = kegs.find(&:linked?) || kegs.find(&:optlinked?) || kegs.max_by(&:scheme_and_version)
+
+    options = {
+      alias_path:,
+      force_bottle:,
+      flags:,
+    }.compact
 
     if keg
-      from_keg(keg, spec, alias_path: alias_path, force_bottle: force_bottle, flags: flags)
+      from_keg(keg, *spec, **options)
     else
-      factory(rack.basename.to_s, spec || :stable, alias_path: alias_path, from: :rack,
-              force_bottle: force_bottle, flags: flags)
+      factory(rack.basename.to_s, *spec, from: :rack, warn: false, **options)
     end
   end
 
   # Return whether given rack is keg-only.
   def self.keg_only?(rack)
     Formulary.from_rack(rack).keg_only?
-  rescue FormulaUnavailableError, TapFormulaAmbiguityError, TapFormulaWithOldnameAmbiguityError
+  rescue FormulaUnavailableError, TapFormulaAmbiguityError
     false
   end
 
   # Return a {Formula} instance for the given keg.
-  #
-  # @param spec when nil, will auto resolve the formula's spec.
-  def self.from_keg(keg, spec = nil, alias_path: nil, force_bottle: false, flags: [])
-    tab = Tab.for_keg(keg)
+  sig {
+    params(
+      keg:          Keg,
+      # Automatically resolves the formula's spec if not specified.
+      spec:         Symbol,
+      alias_path:   T.any(Pathname, String),
+      force_bottle: T::Boolean,
+      flags:        T::Array[String],
+    ).returns(Formula)
+  }
+  def self.from_keg(
+    keg,
+    spec = T.unsafe(nil),
+    alias_path: T.unsafe(nil),
+    force_bottle: T.unsafe(nil),
+    flags: T.unsafe(nil)
+  )
+    tab = keg.tab
     tap = tab.tap
     spec ||= tab.spec
 
+    formula_name = keg.rack.basename.to_s
+
+    options = {
+      alias_path:,
+      from:         :keg,
+      warn:         false,
+      force_bottle:,
+      flags:,
+    }.compact
+
     f = if tap.nil?
-      factory(keg.rack.basename.to_s, spec, alias_path: alias_path, from: :keg,
-              force_bottle: force_bottle, flags: flags)
+      factory(formula_name, spec, **options)
     else
       begin
-        factory("#{tap}/#{keg.rack.basename}", spec, alias_path: alias_path, from: :keg,
-                force_bottle: force_bottle, flags: flags)
+        factory("#{tap}/#{formula_name}", spec, **options)
       rescue FormulaUnavailableError
         # formula may be migrated to different tap. Try to search in core and all taps.
-        factory(keg.rack.basename.to_s, spec, alias_path: alias_path, from: :keg,
-                force_bottle: force_bottle, flags: flags)
+        factory(formula_name, spec, **options)
       end
     end
     f.build = tab
-    f.build.used_options = Tab.remap_deprecated_options(f.deprecated_options, tab.used_options).as_flags
+    T.cast(f.build, Tab).used_options = Tab.remap_deprecated_options(f.deprecated_options, tab.used_options).as_flags
     f.version.update_commit(keg.version.version.commit) if f.head? && keg.version.head?
     f
   end
 
   # Return a {Formula} instance directly from contents.
+  sig {
+    params(
+      name:          String,
+      path:          Pathname,
+      contents:      String,
+      spec:          Symbol,
+      alias_path:    Pathname,
+      force_bottle:  T::Boolean,
+      flags:         T::Array[String],
+      ignore_errors: T::Boolean,
+    ).returns(Formula)
+  }
   def self.from_contents(
-    name, path, contents, spec = :stable, alias_path: nil,
-    force_bottle: false, flags: [], ignore_errors: false
+    name,
+    path,
+    contents,
+    spec = :stable,
+    alias_path: T.unsafe(nil),
+    force_bottle: T.unsafe(nil),
+    flags: T.unsafe(nil),
+    ignore_errors: T.unsafe(nil)
   )
-    FormulaContentsLoader.new(name, path, contents)
-                         .get_formula(spec, alias_path: alias_path, force_bottle: force_bottle,
-                                      flags: flags, ignore_errors: ignore_errors)
+    options = {
+      alias_path:,
+      force_bottle:,
+      flags:,
+      ignore_errors:,
+    }.compact
+    FormulaContentsLoader.new(name, path, contents).get_formula(spec, **options)
   end
 
   def self.to_rack(ref)
@@ -635,75 +1173,83 @@ def self.path(ref)
     loader_for(ref).path
   end
 
-  def self.loader_for(ref, from: nil)
-    case ref
-    when HOMEBREW_BOTTLES_EXTNAME_REGEX
-      return BottleLoader.new(ref)
-    when URL_START_REGEX
-      return FromUrlLoader.new(ref)
-    when HOMEBREW_TAP_FORMULA_REGEX
-      if ref.start_with?("homebrew/core/") && Homebrew::EnvConfig.install_from_api?
-        name = ref.split("/", 3).last
-        return FormulaAPILoader.new(name) if Homebrew::API::Formula.all_formulae.key?(name)
-      end
-
-      return TapLoader.new(ref, from: from)
-    end
+  sig { params(tapped_name: String, warn: T::Boolean).returns(T.nilable([String, Tap, T.nilable(Symbol)])) }
+  def self.tap_formula_name_type(tapped_name, warn:)
+    return unless (tap_with_name = Tap.with_formula_name(tapped_name))
+
+    tap, name = tap_with_name
+
+    type = nil
+
+    # FIXME: Remove the need to do this here.
+    alias_table_key = tap.core_tap? ? name : "#{tap}/#{name}"
+
+    if (possible_alias = tap.alias_table[alias_table_key].presence)
+      # FIXME: Remove the need to split the name and instead make
+      #        the alias table only contain short names.
+      name = T.must(possible_alias.split("/").last)
+      type = :alias
+    elsif (new_name = tap.formula_renames[name].presence)
+      old_name = tap.core_tap? ? name : tapped_name
+      name = new_name
+      new_name = tap.core_tap? ? name : "#{tap}/#{name}"
+      type = :rename
+    elsif (new_tap_name = tap.tap_migrations[name].presence)
+      new_tap, new_name = Tap.with_formula_name(new_tap_name) || [Tap.fetch(new_tap_name), name]
+      new_tap.ensure_installed!
+      new_tapped_name = "#{new_tap}/#{new_name}"
+
+      if tapped_name == new_tapped_name
+        opoo "Tap migration for #{tapped_name} points to itself, stopping recursion."
+      else
+        old_name = tap.core_tap? ? name : tapped_name
+        return unless (name_tap_type = tap_formula_name_type(new_tapped_name, warn: false))
 
-    return FromPathLoader.new(ref) if File.extname(ref) == ".rb" && Pathname.new(ref).expand_path.exist?
+        name, tap, = name_tap_type
 
-    if Homebrew::EnvConfig.install_from_api? && Homebrew::API::Formula.all_formulae.key?(ref)
-      return FormulaAPILoader.new(ref)
+        new_name = new_tap.core_tap? ? name : "#{tap}/#{name}"
+        type = :migration
+      end
     end
 
-    formula_with_that_name = core_path(ref)
-    return FormulaLoader.new(ref, formula_with_that_name) if formula_with_that_name.file?
+    opoo "Formula #{old_name} was renamed to #{new_name}." if warn && old_name && new_name
 
-    possible_alias = CoreTap.instance.alias_dir/ref
-    return AliasLoader.new(possible_alias) if possible_alias.file?
-
-    possible_tap_formulae = tap_paths(ref)
-    raise TapFormulaAmbiguityError.new(ref, possible_tap_formulae) if possible_tap_formulae.size > 1
+    [name, tap, type]
+  end
 
-    if possible_tap_formulae.size == 1
-      path = possible_tap_formulae.first.resolved_path
-      name = path.basename(".rb").to_s
-      return FormulaLoader.new(name, path)
+  def self.loader_for(ref, from: T.unsafe(nil), warn: true)
+    options = { from:, warn: }.compact
+
+    [
+      FromBottleLoader,
+      FromURILoader,
+      FromAPILoader,
+      FromTapLoader,
+      FromPathLoader,
+      FromNameLoader,
+      FromKegLoader,
+      FromCacheLoader,
+      NullLoader,
+    ].each do |loader_class|
+      if (loader = loader_class.try_new(ref, **options))
+        $stderr.puts "#{$PROGRAM_NAME} (#{loader_class}): loading #{ref}" if debug?
+        return loader
+      end
     end
+  end
 
-    return TapLoader.new("#{CoreTap.instance}/#{ref}", from: from) if CoreTap.instance.formula_renames.key?(ref)
-
-    possible_taps = Tap.select { |tap| tap.formula_renames.key?(ref) }
+  def self.core_path(name)
+    find_formula_in_tap(name.to_s.downcase, CoreTap.instance)
+  end
 
-    if possible_taps.size > 1
-      possible_tap_newname_formulae = possible_taps.map { |tap| "#{tap}/#{tap.formula_renames[ref]}" }
-      raise TapFormulaWithOldnameAmbiguityError.new(ref, possible_tap_newname_formulae)
+  sig { params(name: String, tap: Tap).returns(Pathname) }
+  def self.find_formula_in_tap(name, tap)
+    filename = if name.end_with?(".rb")
+      name
+    else
+      "#{name}.rb"
     end
 
-    return TapLoader.new("#{possible_taps.first}/#{ref}", from: from) unless possible_taps.empty?
-
-    possible_keg_formula = Pathname.new("#{HOMEBREW_PREFIX}/opt/#{ref}/.brew/#{ref}.rb")
-    return FormulaLoader.new(ref, possible_keg_formula) if possible_keg_formula.file?
-
-    possible_cached_formula = Pathname.new("#{HOMEBREW_CACHE_FORMULA}/#{ref}.rb")
-    return FormulaLoader.new(ref, possible_cached_formula) if possible_cached_formula.file?
-
-    NullLoader.new(ref)
-  end
-
-  def self.core_path(name)
-    CoreTap.instance.formula_dir/"#{name.to_s.downcase}.rb"
-  end
-
-  def self.tap_paths(name, taps = Dir[HOMEBREW_LIBRARY/"Taps/*/*/"])
-    name = name.to_s.downcase
-    taps.map do |tap|
-      Pathname.glob([
-        "#{tap}Formula/#{name}.rb",
-        "#{tap}HomebrewFormula/#{name}.rb",
-        "#{tap}#{name}.rb",
-        "#{tap}Aliases/#{name}",
-      ]).find(&:file?)
-    end.compact
+    tap.formula_files_by_name.fetch(name, tap.formula_dir/filename)
   end
 end
diff --git a/Library/Homebrew/formulary.rbi b/Library/Homebrew/formulary.rbi
new file mode 100644
index 0000000000000..5c149eeb10705
--- /dev/null
+++ b/Library/Homebrew/formulary.rbi
@@ -0,0 +1,5 @@
+# typed: strict
+
+module Formulary
+  include Kernel
+end
diff --git a/Library/Homebrew/git_repository.rb b/Library/Homebrew/git_repository.rb
new file mode 100644
index 0000000000000..f8d1dfc79d440
--- /dev/null
+++ b/Library/Homebrew/git_repository.rb
@@ -0,0 +1,137 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "utils/git"
+require "utils/popen"
+
+# Given a {Pathname}, provides methods for querying Git repository information.
+# @see Utils::Git
+class GitRepository
+  sig { returns(Pathname) }
+  attr_reader :pathname
+
+  sig { params(pathname: Pathname).void }
+  def initialize(pathname)
+    @pathname = pathname
+  end
+
+  sig { returns(T::Boolean) }
+  def git_repository?
+    pathname.join(".git").exist?
+  end
+
+  sig { returns(T::Boolean) }
+  def git_repo?
+    # delete this whole function when removing odisabled
+    odeprecated "GitRepository#git_repo?", "GitRepository#git_repository?"
+    git_repository?
+  end
+
+  # Gets the URL of the Git origin remote.
+  sig { returns(T.nilable(String)) }
+  def origin_url
+    popen_git("config", "--get", "remote.origin.url")
+  end
+
+  # Sets the URL of the Git origin remote.
+  sig { params(origin: String).returns(T.nilable(T::Boolean)) }
+  def origin_url=(origin)
+    return if !git_repository? || !Utils::Git.available?
+
+    safe_system Utils::Git.git, "remote", "set-url", "origin", origin, chdir: pathname
+  end
+
+  # Gets the full commit hash of the HEAD commit.
+  sig { params(safe: T::Boolean).returns(T.nilable(String)) }
+  def head_ref(safe: false)
+    popen_git("rev-parse", "--verify", "--quiet", "HEAD", safe:)
+  end
+
+  # Gets a short commit hash of the HEAD commit.
+  sig { params(length: T.nilable(Integer), safe: T::Boolean).returns(T.nilable(String)) }
+  def short_head_ref(length: nil, safe: false)
+    short_arg = length.present? ? "--short=#{length}" : "--short"
+    popen_git("rev-parse", short_arg, "--verify", "--quiet", "HEAD", safe:)
+  end
+
+  # Gets the relative date of the last commit, e.g. "1 hour ago"
+  sig { returns(T.nilable(String)) }
+  def last_committed
+    popen_git("show", "-s", "--format=%cr", "HEAD")
+  end
+
+  # Gets the name of the currently checked-out branch, or HEAD if the repository is in a detached HEAD state.
+  sig { params(safe: T::Boolean).returns(T.nilable(String)) }
+  def branch_name(safe: false)
+    popen_git("rev-parse", "--abbrev-ref", "HEAD", safe:)
+  end
+
+  # Change the name of a local branch
+  sig { params(old: String, new: String).void }
+  def rename_branch(old:, new:)
+    popen_git("branch", "-m", old, new)
+  end
+
+  # Set an upstream branch for a local branch to track
+  sig { params(local: String, origin: String).void }
+  def set_upstream_branch(local:, origin:)
+    popen_git("branch", "-u", "origin/#{origin}", local)
+  end
+
+  # Gets the name of the default origin HEAD branch.
+  sig { returns(T.nilable(String)) }
+  def origin_branch_name
+    popen_git("symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD")&.split("/")&.last
+  end
+
+  # Returns true if the repository's current branch matches the default origin branch.
+  sig { returns(T.nilable(T::Boolean)) }
+  def default_origin_branch?
+    origin_branch_name == branch_name
+  end
+
+  # Returns the date of the last commit, in YYYY-MM-DD format.
+  sig { returns(T.nilable(String)) }
+  def last_commit_date
+    popen_git("show", "-s", "--format=%cd", "--date=short", "HEAD")
+  end
+
+  # Returns true if the given branch exists on origin
+  sig { params(branch: String).returns(T::Boolean) }
+  def origin_has_branch?(branch)
+    popen_git("ls-remote", "--heads", "origin", branch).present?
+  end
+
+  sig { void }
+  def set_head_origin_auto
+    popen_git("remote", "set-head", "origin", "--auto")
+  end
+
+  # Gets the full commit message of the specified commit, or of the HEAD commit if unspecified.
+  sig { params(commit: String, safe: T::Boolean).returns(T.nilable(String)) }
+  def commit_message(commit = "HEAD", safe: false)
+    popen_git("log", "-1", "--pretty=%B", commit, "--", safe:, err: :out)&.strip
+  end
+
+  sig { returns(String) }
+  def to_s = pathname.to_s
+
+  private
+
+  sig { params(args: T.untyped, safe: T::Boolean, err: T.nilable(Symbol)).returns(T.nilable(String)) }
+  def popen_git(*args, safe: false, err: nil)
+    unless git_repository?
+      return unless safe
+
+      raise "Not a Git repository: #{pathname}"
+    end
+
+    unless Utils::Git.available?
+      return unless safe
+
+      raise "Git is unavailable"
+    end
+
+    Utils.popen_read(Utils::Git.git, *args, safe:, chdir: pathname, err:).chomp.presence
+  end
+end
diff --git a/Library/Homebrew/github_packages.rb b/Library/Homebrew/github_packages.rb
index 7943752790d98..a3cde6b1ec6db 100644
--- a/Library/Homebrew/github_packages.rb
+++ b/Library/Homebrew/github_packages.rb
@@ -1,26 +1,30 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "utils/curl"
 require "json"
 require "zlib"
+require "extend/hash/keys"
+require "system_command"
 
 # GitHub Packages client.
-#
-# @api private
 class GitHubPackages
-  extend T::Sig
-
   include Context
+  include SystemCommand::Mixin
 
   URL_DOMAIN = "ghcr.io"
-  URL_PREFIX = "https://#{URL_DOMAIN}/v2/"
-  DOCKER_PREFIX = "docker://#{URL_DOMAIN}/"
+  URL_PREFIX = "https://#{URL_DOMAIN}/v2/".freeze
+  DOCKER_PREFIX = "docker://#{URL_DOMAIN}/".freeze
   public_constant :URL_DOMAIN
   private_constant :URL_PREFIX
   private_constant :DOCKER_PREFIX
 
-  URL_REGEX = %r{(?:#{Regexp.escape(URL_PREFIX)}|#{Regexp.escape(DOCKER_PREFIX)})([\w-]+)/([\w-]+)}.freeze
+  URL_REGEX = %r{(?:#{Regexp.escape(URL_PREFIX)}|#{Regexp.escape(DOCKER_PREFIX)})([\w-]+)/([\w-]+)}
+
+  # Valid OCI tag characters
+  # https://github.com/opencontainers/distribution-spec/blob/main/spec.md#workflow-categories
+  VALID_OCI_TAG_REGEX = /^[a-zA-Z0-9_][a-zA-Z0-9._-]{0,127}$/
+  INVALID_OCI_TAG_CHARS_REGEX = /[^a-zA-Z0-9._-]/
 
   GZIP_BUFFER_SIZE = 64 * 1024
   private_constant :GZIP_BUFFER_SIZE
@@ -59,9 +63,20 @@ def upload_bottles(bottles_hash, keep_old:, dry_run:, warn_on_error:)
     load_schemas!
 
     bottles_hash.each do |formula_full_name, bottle_hash|
+      # First, check that we won't encounter an error in the middle of uploading bottles.
+      preupload_check(user, token, skopeo, formula_full_name, bottle_hash,
+                      keep_old:, dry_run:, warn_on_error:)
+    end
+
+    # We intentionally iterate over `bottles_hash` twice to
+    # avoid erroring out in the middle of uploading bottles.
+    # rubocop:disable Style/CombinableLoops
+    bottles_hash.each do |formula_full_name, bottle_hash|
+      # Next, upload the bottles after checking them all.
       upload_bottle(user, token, skopeo, formula_full_name, bottle_hash,
-                    keep_old: keep_old, dry_run: dry_run, warn_on_error: warn_on_error)
+                    keep_old:, dry_run:, warn_on_error:)
     end
+    # rubocop:enable Style/CombinableLoops
   end
 
   def self.version_rebuild(version, rebuild, bottle_tag = nil)
@@ -79,12 +94,12 @@ def self.version_rebuild(version, rebuild, bottle_tag = nil)
   end
 
   def self.repo_without_prefix(repo)
-    # remove redundant repo prefix for a shorter name
+    # Remove redundant repository prefix for a shorter name.
     repo.delete_prefix("homebrew-")
   end
 
   def self.root_url(org, repo, prefix = URL_PREFIX)
-    # docker/skopeo insist on lowercase org ("repository name")
+    # `docker`/`skopeo` insist on lowercase organisation (“repository name”).
     org = org.downcase
 
     "#{prefix}#{org}/#{repo_without_prefix(repo)}"
@@ -100,18 +115,19 @@ def self.root_url_if_match(url)
   end
 
   def self.image_formula_name(formula_name)
-    # invalid docker name characters
-    # / makes sense because we already use it to separate repo/formula
-    # x makes sense because we already use it in Formulary
+    # Invalid docker name characters:
+    # - `/` makes sense because we already use it to separate repository/formula.
+    # - `x` makes sense because we already use it in `Formulary`.
     formula_name.tr("@", "/")
                 .tr("+", "x")
   end
 
   def self.image_version_rebuild(version_rebuild)
-    # invalid docker tag characters
-    # TODO: consider changing the actual versions here and make an audit to
-    # avoid these weird characters being used
-    version_rebuild.gsub(/[+#~]/, ".")
+    unless version_rebuild.match?(VALID_OCI_TAG_REGEX)
+      raise ArgumentError, "GitHub Packages versions must match #{VALID_OCI_TAG_REGEX.source}!"
+    end
+
+    version_rebuild
   end
 
   private
@@ -155,7 +171,7 @@ def schema_uri(basename, uris)
     # Going forward, this should probably be pinned to tags.
     # We currently use features newer than the last one (v1.0.2).
     url = "https://raw.githubusercontent.com/opencontainers/image-spec/170393e57ed656f7f81c3070bfa8c3346eaa0a5a/schema/#{basename}.json"
-    out, = curl_output(url)
+    out, = Utils::Curl.curl_output(url)
     json = JSON.parse(out)
 
     @schema_json ||= {}
@@ -176,9 +192,9 @@ def validate_schema!(schema_uri, json)
     puts
     ofail "#{Formatter.url(schema_uri)} JSON schema validation failed!"
     oh1 "Errors"
-    pp schema.validate(json).to_a
+    puts schema.validate(json).to_a.inspect
     oh1 "JSON"
-    pp json
+    puts json.inspect
     exit 1
   end
 
@@ -189,11 +205,11 @@ def download(user, token, skopeo, image_uri, root, dry_run:)
       puts "#{skopeo} #{args.join(" ")} --src-creds=#{user}:$HOMEBREW_GITHUB_PACKAGES_TOKEN"
     else
       args << "--src-creds=#{user}:#{token}"
-      system_command!(skopeo, verbose: true, print_stdout: true, args: args)
+      system_command!(skopeo, verbose: true, print_stdout: true, args:)
     end
   end
 
-  def upload_bottle(user, token, skopeo, formula_full_name, bottle_hash, keep_old:, dry_run:, warn_on_error:)
+  def preupload_check(user, token, skopeo, _formula_full_name, bottle_hash, keep_old:, dry_run:, warn_on_error:)
     formula_name = bottle_hash["formula"]["name"]
 
     _, org, repo, = *bottle_hash["bottle"]["root_url"].match(URL_REGEX)
@@ -215,9 +231,9 @@ def upload_bottle(user, token, skopeo, formula_full_name, bottle_hash, keep_old:
       inspect_args << "--creds=#{user}:#{token}"
       inspect_result = system_command(skopeo, print_stderr: false, args: inspect_args)
 
-      # Order here is important
+      # Order here is important.
       if !inspect_result.status.success? && !inspect_result.stderr.match?(/(name|manifest) unknown/)
-        # We got an error, and it was not about the tag or package being unknown.
+        # We got an error and it was not about the tag or package being unknown.
         if warn_on_error
           opoo "#{image_uri} inspection returned an error, skipping upload!\n#{inspect_result.stderr}"
           return
@@ -225,11 +241,11 @@ def upload_bottle(user, token, skopeo, formula_full_name, bottle_hash, keep_old:
           odie "#{image_uri} inspection returned an error!\n#{inspect_result.stderr}"
         end
       elsif keep_old
-        # If the tag doesn't exist, ignore --keep-old.
+        # If the tag doesn't exist, ignore `--keep-old`.
         keep_old = false unless inspect_result.status.success?
         # Otherwise, do nothing - the tag already existing is expected behaviour for --keep-old.
       elsif inspect_result.status.success?
-        # The tag already exists, and we are not passing --keep-old.
+        # The tag already exists and we are not passing `--keep-old`.
         if warn_on_error
           opoo "#{image_uri} already exists, skipping upload!"
           return
@@ -239,12 +255,22 @@ def upload_bottle(user, token, skopeo, formula_full_name, bottle_hash, keep_old:
       end
     end
 
+    [formula_name, org, repo, version, rebuild, version_rebuild, image_name, image_uri, keep_old]
+  end
+
+  def upload_bottle(user, token, skopeo, formula_full_name, bottle_hash, keep_old:, dry_run:, warn_on_error:)
+    # We run the preupload check twice to prevent TOCTOU bugs.
+    result = preupload_check(user, token, skopeo, formula_full_name, bottle_hash,
+                             keep_old:, dry_run:, warn_on_error:)
+
+    formula_name, org, repo, version, rebuild, version_rebuild, image_name, image_uri, keep_old = *result
+
     root = Pathname("#{formula_name}--#{version_rebuild}")
     FileUtils.rm_rf root
     root.mkpath
 
     if keep_old
-      download(user, token, skopeo, image_uri, root, dry_run: dry_run)
+      download(user, token, skopeo, image_uri, root, dry_run:)
     else
       write_image_layout(root)
     end
@@ -265,6 +291,7 @@ def upload_bottle(user, token, skopeo, formula_full_name, bottle_hash, keep_old:
       remote
     end
 
+    license = bottle_hash["formula"]["license"].to_s
     created_date = bottle_hash["bottle"]["date"]
     if keep_old
       index = JSON.parse((root/"index.json").read)
@@ -275,12 +302,20 @@ def upload_bottle(user, token, skopeo, formula_full_name, bottle_hash, keep_old:
       formula_annotations_hash = image_index["annotations"]
       manifests = image_index["manifests"]
     else
+      image_license = if license.length <= 256
+        license
+      else
+        # TODO: Consider generating a truncated license when over the limit
+        require "utils/spdx"
+        SPDX.license_expression_to_string(:cannot_represent)
+      end
+
       formula_annotations_hash = {
         "com.github.package.type"                => GITHUB_PACKAGE_TYPE,
         "org.opencontainers.image.created"       => created_date,
         "org.opencontainers.image.description"   => bottle_hash["formula"]["desc"],
         "org.opencontainers.image.documentation" => documentation,
-        "org.opencontainers.image.license"       => bottle_hash["formula"]["license"],
+        "org.opencontainers.image.licenses"      => image_license,
         "org.opencontainers.image.ref.name"      => version_rebuild,
         "org.opencontainers.image.revision"      => git_revision,
         "org.opencontainers.image.source"        => source,
@@ -288,7 +323,7 @@ def upload_bottle(user, token, skopeo, formula_full_name, bottle_hash, keep_old:
         "org.opencontainers.image.url"           => bottle_hash["formula"]["homepage"],
         "org.opencontainers.image.vendor"        => org,
         "org.opencontainers.image.version"       => version,
-      }.reject { |_, v| v.blank? }
+      }.compact_blank
       manifests = []
     end
 
@@ -333,17 +368,17 @@ def upload_bottle(user, token, skopeo, formula_full_name, bottle_hash, keep_old:
         os_version ||= "macOS #{bottle_tag.to_macos_version}"
       when "linux"
         os_version&.delete_suffix!(" LTS")
-        os_version ||= OS::CI_OS_VERSION
+        os_version ||= OS::LINUX_CI_OS_VERSION
         glibc_version = tab["built_on"]["glibc_version"].presence if tab["built_on"].present?
-        glibc_version ||= OS::CI_GLIBC_VERSION
+        glibc_version ||= OS::LINUX_GLIBC_CI_VERSION
         cpu_variant = tab["oldest_cpu_family"] || Hardware::CPU::INTEL_64BIT_OLDEST_CPU.to_s
       end
 
       platform_hash = {
-        architecture: architecture,
-        os: os,
+        architecture:,
+        os:,
         "os.version" => os_version,
-      }.reject { |_, v| v.blank? }
+      }.compact_blank
 
       tar_sha256 = Digest::SHA256.new
       Zlib::GzipReader.open(local_file) do |gz|
@@ -354,16 +389,27 @@ def upload_bottle(user, token, skopeo, formula_full_name, bottle_hash, keep_old:
 
       config_json_sha256, config_json_size = write_image_config(platform_hash, tar_sha256.hexdigest, blobs)
 
-      formulae_dir = tag_hash["formulae_brew_sh_path"]
-      documentation = "https://formulae.brew.sh/#{formulae_dir}/#{formula_name}" if formula_core_tap
+      documentation = "https://formulae.brew.sh/formula/#{formula_name}" if formula_core_tap
+
+      local_file_size = File.size(local_file)
+
+      path_exec_files_string = if (path_exec_files = tag_hash["path_exec_files"].presence)
+        path_exec_files.join(",")
+      end
 
       descriptor_annotations_hash = {
         "org.opencontainers.image.ref.name" => tag,
         "sh.brew.bottle.cpu.variant"        => cpu_variant,
         "sh.brew.bottle.digest"             => tar_gz_sha256,
         "sh.brew.bottle.glibc.version"      => glibc_version,
+        "sh.brew.bottle.size"               => local_file_size.to_s,
+        "sh.brew.bottle.installed_size"     => tag_hash["installed_size"].to_s,
+        "sh.brew.license"                   => license,
         "sh.brew.tab"                       => tab.to_json,
-      }.reject { |_, v| v.blank? }
+        "sh.brew.path_exec_files"           => path_exec_files_string,
+      }.compact_blank
+
+      # TODO: upload/add tag_hash["all_files"] somewhere.
 
       annotations_hash = formula_annotations_hash.merge(descriptor_annotations_hash).merge(
         {
@@ -371,7 +417,7 @@ def upload_bottle(user, token, skopeo, formula_full_name, bottle_hash, keep_old:
           "org.opencontainers.image.documentation" => documentation,
           "org.opencontainers.image.title"         => "#{formula_full_name} #{tag}",
         },
-      ).reject { |_, v| v.blank? }.sort.to_h
+      ).compact_blank.sort.to_h
 
       image_manifest = {
         schemaVersion: 2,
@@ -403,17 +449,27 @@ def upload_bottle(user, token, skopeo, formula_full_name, bottle_hash, keep_old:
     end
 
     index_json_sha256, index_json_size = write_image_index(manifests, blobs, formula_annotations_hash)
+    raise "Image index too large!" if index_json_size >= 4 * 1024 * 1024 # GitHub will error 500 if too large
 
     write_index_json(index_json_sha256, index_json_size, root,
                      "org.opencontainers.image.ref.name" => version_rebuild)
 
     puts
-    args = ["copy", "--all", "oci:#{root}", image_uri.to_s]
+    args = ["copy", "--retry-times=3", "--format=oci", "--all", "oci:#{root}", image_uri.to_s]
     if dry_run
       puts "#{skopeo} #{args.join(" ")} --dest-creds=#{user}:$HOMEBREW_GITHUB_PACKAGES_TOKEN"
     else
       args << "--dest-creds=#{user}:#{token}"
-      system_command!(skopeo, verbose: true, print_stdout: true, args: args)
+      retry_count = 0
+      begin
+        system_command!(skopeo, verbose: true, print_stdout: true, args:)
+      rescue ErrorDuringExecution
+        retry_count += 1
+        odie "Cannot perform an upload to registry after retrying multiple times!" if retry_count >= 10
+        sleep 2 ** retry_count
+        retry
+      end
+
       package_name = "#{GitHubPackages.repo_without_prefix(repo)}/#{image_name}"
       ohai "Uploaded to https://github.com/orgs/#{org}/packages/container/package/#{package_name}"
     end
@@ -428,7 +484,7 @@ def write_image_layout(root)
   def write_tar_gz(local_file, blobs)
     tar_gz_sha256 = Digest::SHA256.file(local_file)
                                   .hexdigest
-    FileUtils.cp local_file, blobs/tar_gz_sha256
+    FileUtils.ln local_file, blobs/tar_gz_sha256, force: true
     tar_gz_sha256
   end
 
@@ -446,8 +502,8 @@ def write_image_config(platform_hash, tar_sha256, blobs)
   def write_image_index(manifests, blobs, annotations)
     image_index = {
       schemaVersion: 2,
-      manifests:     manifests,
-      annotations:   annotations,
+      manifests:,
+      annotations:,
     }
     validate_schema!(IMAGE_INDEX_SCHEMA_URI, image_index)
     write_hash(blobs, image_index)
@@ -460,7 +516,7 @@ def write_index_json(index_json_sha256, index_json_size, root, annotations)
         mediaType:   "application/vnd.oci.image.index.v1+json",
         digest:      "sha256:#{index_json_sha256}",
         size:        index_json_size,
-        annotations: annotations,
+        annotations:,
       }],
     }
     validate_schema!(IMAGE_INDEX_SCHEMA_URI, index_json)
diff --git a/Library/Homebrew/github_releases.rb b/Library/Homebrew/github_releases.rb
index e59d268991a9a..e11f5e61c5ede 100644
--- a/Library/Homebrew/github_releases.rb
+++ b/Library/Homebrew/github_releases.rb
@@ -1,19 +1,14 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "utils/github"
 require "json"
 
 # GitHub Releases client.
-#
-# @api private
 class GitHubReleases
-  extend T::Sig
-
   include Context
-  include Utils::Curl
 
-  URL_REGEX = %r{https://github\.com/([\w-]+)/([\w-]+)?/releases/download/(.+)}.freeze
+  URL_REGEX = %r{https://github\.com/([\w-]+)/([\w-]+)?/releases/download/(.+)}
 
   sig { params(bottles_hash: T::Hash[String, T.untyped]).void }
   def upload_bottles(bottles_hash)
@@ -37,7 +32,7 @@ def upload_bottles(bottles_hash)
         remote_file = tag_hash["filename"]
         local_file = tag_hash["local_filename"]
         odebug "Uploading #{remote_file}"
-        GitHub.upload_release_asset user, repo, release["id"], local_file: local_file, remote_file: remote_file
+        GitHub.upload_release_asset user, repo, release["id"], local_file:, remote_file:
       end
     end
   end
diff --git a/Library/Homebrew/github_runner.rb b/Library/Homebrew/github_runner.rb
new file mode 100644
index 0000000000000..46086288c374c
--- /dev/null
+++ b/Library/Homebrew/github_runner.rb
@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "linux_runner_spec"
+require "macos_runner_spec"
+
+class GitHubRunner < T::Struct
+  const :platform, Symbol
+  const :arch, Symbol
+  const :spec, T.any(LinuxRunnerSpec, MacOSRunnerSpec)
+  const :macos_version, T.nilable(MacOSVersion)
+  prop  :active, T::Boolean, default: false
+
+  sig { returns(T::Boolean) }
+  def macos?
+    platform == :macos
+  end
+
+  sig { returns(T::Boolean) }
+  def linux?
+    platform == :linux
+  end
+
+  sig { returns(T::Boolean) }
+  def x86_64?
+    arch == :x86_64
+  end
+
+  sig { returns(T::Boolean) }
+  def arm64?
+    arch == :arm64
+  end
+end
diff --git a/Library/Homebrew/github_runner_matrix.rb b/Library/Homebrew/github_runner_matrix.rb
new file mode 100644
index 0000000000000..492faf73c4eb4
--- /dev/null
+++ b/Library/Homebrew/github_runner_matrix.rb
@@ -0,0 +1,266 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "test_runner_formula"
+require "github_runner"
+
+class GitHubRunnerMatrix
+  RunnerSpec = T.type_alias { T.any(LinuxRunnerSpec, MacOSRunnerSpec) }
+  private_constant :RunnerSpec
+
+  MacOSRunnerSpecHash = T.type_alias do
+    {
+      name:             String,
+      runner:           String,
+      timeout:          Integer,
+      cleanup:          T::Boolean,
+      testing_formulae: String,
+    }
+  end
+  private_constant :MacOSRunnerSpecHash
+
+  LinuxRunnerSpecHash = T.type_alias do
+    {
+      name:             String,
+      runner:           String,
+      container:        T::Hash[Symbol, String],
+      workdir:          String,
+      timeout:          Integer,
+      cleanup:          T::Boolean,
+      testing_formulae: String,
+    }
+  end
+  private_constant :LinuxRunnerSpecHash
+
+  RunnerSpecHash = T.type_alias { T.any(LinuxRunnerSpecHash, MacOSRunnerSpecHash) }
+  private_constant :RunnerSpecHash
+  sig { returns(T::Array[GitHubRunner]) }
+  attr_reader :runners
+
+  sig {
+    params(
+      testing_formulae: T::Array[TestRunnerFormula],
+      deleted_formulae: T::Array[String],
+      all_supported:    T::Boolean,
+      dependent_matrix: T::Boolean,
+    ).void
+  }
+  def initialize(testing_formulae, deleted_formulae, all_supported:, dependent_matrix:)
+    if all_supported && (testing_formulae.present? || deleted_formulae.present? || dependent_matrix)
+      raise ArgumentError, "all_supported is mutually exclusive to other arguments"
+    end
+
+    @testing_formulae = T.let(testing_formulae, T::Array[TestRunnerFormula])
+    @deleted_formulae = T.let(deleted_formulae, T::Array[String])
+    @all_supported = T.let(all_supported, T::Boolean)
+    @dependent_matrix = T.let(dependent_matrix, T::Boolean)
+    @compatible_testing_formulae = T.let({}, T::Hash[GitHubRunner, T::Array[TestRunnerFormula]])
+    @formulae_with_untested_dependents = T.let({}, T::Hash[GitHubRunner, T::Array[TestRunnerFormula]])
+
+    @runners = T.let([], T::Array[GitHubRunner])
+    generate_runners!
+
+    freeze
+  end
+
+  sig { returns(T::Array[RunnerSpecHash]) }
+  def active_runner_specs_hash
+    runners.select(&:active)
+           .map(&:spec)
+           .map(&:to_h)
+  end
+
+  private
+
+  SELF_HOSTED_LINUX_RUNNER = "linux-self-hosted-1"
+  # ARM macOS timeout, keep this under 1/2 of GitHub's job execution time limit for self-hosted runners.
+  # https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/about-self-hosted-runners#usage-limits
+  GITHUB_ACTIONS_LONG_TIMEOUT = 2160 # 36 hours
+  GITHUB_ACTIONS_SHORT_TIMEOUT = 60
+
+  sig { returns(LinuxRunnerSpec) }
+  def linux_runner_spec
+    linux_runner = ENV.fetch("HOMEBREW_LINUX_RUNNER")
+
+    LinuxRunnerSpec.new(
+      name:      "Linux",
+      runner:    linux_runner,
+      container: {
+        image:   "ghcr.io/homebrew/ubuntu22.04:master",
+        options: "--user=linuxbrew -e GITHUB_ACTIONS_HOMEBREW_SELF_HOSTED",
+      },
+      workdir:   "/github/home",
+      timeout:   GITHUB_ACTIONS_LONG_TIMEOUT,
+      cleanup:   linux_runner == SELF_HOSTED_LINUX_RUNNER,
+    )
+  end
+
+  VALID_PLATFORMS = T.let([:macos, :linux].freeze, T::Array[Symbol])
+  VALID_ARCHES = T.let([:arm64, :x86_64].freeze, T::Array[Symbol])
+
+  sig {
+    params(
+      platform:      Symbol,
+      arch:          Symbol,
+      spec:          RunnerSpec,
+      macos_version: T.nilable(MacOSVersion),
+    ).returns(GitHubRunner)
+  }
+  def create_runner(platform, arch, spec, macos_version = nil)
+    raise "Unexpected platform: #{platform}" if VALID_PLATFORMS.exclude?(platform)
+    raise "Unexpected arch: #{arch}" if VALID_ARCHES.exclude?(arch)
+
+    runner = GitHubRunner.new(platform:, arch:, spec:, macos_version:)
+    runner.spec.testing_formulae += testable_formulae(runner)
+    runner.active = active_runner?(runner)
+    runner.freeze
+  end
+
+  NEWEST_HOMEBREW_CORE_MACOS_RUNNER = :sequoia
+  OLDEST_HOMEBREW_CORE_MACOS_RUNNER = :ventura
+  NEWEST_HOMEBREW_CORE_INTEL_MACOS_RUNNER = :sonoma
+
+  sig { params(macos_version: MacOSVersion).returns(T::Boolean) }
+  def runner_enabled?(macos_version)
+    macos_version <= NEWEST_HOMEBREW_CORE_MACOS_RUNNER && macos_version >= OLDEST_HOMEBREW_CORE_MACOS_RUNNER
+  end
+
+  NEWEST_GITHUB_ACTIONS_INTEL_MACOS_RUNNER = :ventura
+  OLDEST_GITHUB_ACTIONS_INTEL_MACOS_RUNNER = :monterey
+  NEWEST_GITHUB_ACTIONS_ARM_MACOS_RUNNER = :sequoia
+  OLDEST_GITHUB_ACTIONS_ARM_MACOS_RUNNER = :sonoma
+  GITHUB_ACTIONS_RUNNER_TIMEOUT = 360
+
+  sig { void }
+  def generate_runners!
+    return if @runners.present?
+
+    if !@all_supported || ENV.key?("HOMEBREW_LINUX_RUNNER")
+      @runners << create_runner(:linux, :x86_64, linux_runner_spec)
+    end
+
+    github_run_id      = ENV.fetch("GITHUB_RUN_ID")
+    long_timeout       = ENV.fetch("HOMEBREW_MACOS_LONG_TIMEOUT", "false") == "true"
+    use_github_runner  = ENV.fetch("HOMEBREW_MACOS_BUILD_ON_GITHUB_RUNNER", "false") == "true"
+
+    runner_timeout = long_timeout ? GITHUB_ACTIONS_LONG_TIMEOUT : GITHUB_ACTIONS_SHORT_TIMEOUT
+
+    # Use GitHub Actions macOS Runner for testing dependents if compatible with timeout.
+    use_github_runner ||= @dependent_matrix
+    use_github_runner &&= runner_timeout <= GITHUB_ACTIONS_RUNNER_TIMEOUT
+
+    ephemeral_suffix = "-#{github_run_id}"
+    ephemeral_suffix << "-deps" if @dependent_matrix
+    ephemeral_suffix << "-long" if runner_timeout == GITHUB_ACTIONS_LONG_TIMEOUT
+    ephemeral_suffix.freeze
+
+    MacOSVersion::SYMBOLS.each_value do |version|
+      macos_version = MacOSVersion.new(version)
+      next unless runner_enabled?(macos_version)
+
+      github_runner_available = macos_version <= NEWEST_GITHUB_ACTIONS_ARM_MACOS_RUNNER &&
+                                macos_version >= OLDEST_GITHUB_ACTIONS_ARM_MACOS_RUNNER
+
+      runner, timeout = if use_github_runner && github_runner_available
+        ["macos-#{version}", GITHUB_ACTIONS_RUNNER_TIMEOUT]
+      elsif macos_version >= :monterey
+        ["#{version}-arm64#{ephemeral_suffix}", runner_timeout]
+      else
+        ["#{version}-arm64", runner_timeout]
+      end
+
+      # We test recursive dependents on ARM macOS, so they can be slower than our Intel runners.
+      timeout *= 2 if @dependent_matrix && timeout < GITHUB_ACTIONS_RUNNER_TIMEOUT
+      spec = MacOSRunnerSpec.new(
+        name:    "macOS #{version}-arm64",
+        runner:,
+        timeout:,
+        cleanup: !runner.end_with?(ephemeral_suffix),
+      )
+      @runners << create_runner(:macos, :arm64, spec, macos_version)
+
+      next if !@all_supported && macos_version > NEWEST_HOMEBREW_CORE_INTEL_MACOS_RUNNER
+
+      github_runner_available = macos_version <= NEWEST_GITHUB_ACTIONS_INTEL_MACOS_RUNNER &&
+                                macos_version >= OLDEST_GITHUB_ACTIONS_INTEL_MACOS_RUNNER
+
+      runner, timeout = if use_github_runner && github_runner_available
+        ["macos-#{version}", GITHUB_ACTIONS_RUNNER_TIMEOUT]
+      else
+        ["#{version}-x86_64#{ephemeral_suffix}", runner_timeout]
+      end
+
+      # macOS 12-x86_64 is usually slower.
+      timeout += 30 if macos_version <= :monterey
+      # The ARM runners are typically over twice as fast as the Intel runners.
+      timeout *= 2 if !(use_github_runner && github_runner_available) && timeout < GITHUB_ACTIONS_LONG_TIMEOUT
+      spec = MacOSRunnerSpec.new(
+        name:    "macOS #{version}-x86_64",
+        runner:,
+        timeout:,
+        cleanup: !runner.end_with?(ephemeral_suffix),
+      )
+      @runners << create_runner(:macos, :x86_64, spec, macos_version)
+    end
+
+    @runners.freeze
+  end
+
+  sig { params(runner: GitHubRunner).returns(T::Array[String]) }
+  def testable_formulae(runner)
+    formulae = if @dependent_matrix
+      formulae_with_untested_dependents(runner)
+    else
+      compatible_testing_formulae(runner)
+    end
+
+    formulae.map(&:name)
+  end
+
+  sig { params(runner: GitHubRunner).returns(T::Boolean) }
+  def active_runner?(runner)
+    return true if @all_supported
+    return true if @deleted_formulae.present? && !@dependent_matrix
+
+    runner.spec.testing_formulae.present?
+  end
+
+  sig { params(runner: GitHubRunner).returns(T::Array[TestRunnerFormula]) }
+  def compatible_testing_formulae(runner)
+    @compatible_testing_formulae[runner] ||= begin
+      platform = runner.platform
+      arch = runner.arch
+      macos_version = runner.macos_version
+
+      @testing_formulae.select do |formula|
+        next false if macos_version && !formula.compatible_with?(macos_version)
+
+        formula.public_send(:"#{platform}_compatible?") &&
+          formula.public_send(:"#{arch}_compatible?")
+      end
+    end
+  end
+
+  sig { params(runner: GitHubRunner).returns(T::Array[TestRunnerFormula]) }
+  def formulae_with_untested_dependents(runner)
+    @formulae_with_untested_dependents[runner] ||= begin
+      platform = runner.platform
+      arch = runner.arch
+      macos_version = runner.macos_version
+
+      compatible_testing_formulae(runner).select do |formula|
+        compatible_dependents = formula.dependents(platform:, arch:, macos_version: macos_version&.to_sym)
+                                       .select do |dependent_f|
+          next false if macos_version && !dependent_f.compatible_with?(macos_version)
+
+          dependent_f.public_send(:"#{platform}_compatible?") &&
+            dependent_f.public_send(:"#{arch}_compatible?")
+        end
+
+        # These arrays will generally have been generated by different Formulary caches,
+        # so we can only compare them by name and not directly.
+        (compatible_dependents.map(&:name) - @testing_formulae.map(&:name)).present?
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/global.rb b/Library/Homebrew/global.rb
index 1a11464f69a5f..46ab618ab5231 100644
--- a/Library/Homebrew/global.rb
+++ b/Library/Homebrew/global.rb
@@ -1,39 +1,11 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require_relative "startup"
 
-require "English"
-require "fileutils"
-require "json"
-require "json/add/exception"
-require "ostruct"
-require "pp"
-require "forwardable"
-
-# Only require "core_ext" here to ensure we're only requiring the minimum of
-# what we need.
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/numeric/time"
-require "active_support/core_ext/object/try"
-require "active_support/core_ext/array/access"
-require "active_support/core_ext/string/inflections"
-require "active_support/core_ext/array/conversions"
-require "active_support/core_ext/hash/deep_merge"
-require "active_support/core_ext/file/atomic"
-require "active_support/core_ext/enumerable"
-require "active_support/core_ext/string/exclude"
-require "active_support/core_ext/string/indent"
-
-I18n.backend.available_locales # Initialize locales so they can be overwritten.
-I18n.backend.store_translations :en, support: { array: { last_word_connector: " and " } }
-
-ActiveSupport::Inflector.inflections(:en) do |inflect|
-  inflect.irregular "formula", "formulae"
-  inflect.irregular "is", "are"
-  inflect.irregular "it", "they"
-end
+HOMEBREW_HELP_MESSAGE = ENV.fetch("HOMEBREW_HELP_MESSAGE").freeze
 
+HOMEBREW_API_DEFAULT_DOMAIN = ENV.fetch("HOMEBREW_API_DEFAULT_DOMAIN").freeze
 HOMEBREW_BOTTLE_DEFAULT_DOMAIN = ENV.fetch("HOMEBREW_BOTTLE_DEFAULT_DOMAIN").freeze
 HOMEBREW_BREW_DEFAULT_GIT_REMOTE = ENV.fetch("HOMEBREW_BREW_DEFAULT_GIT_REMOTE").freeze
 HOMEBREW_CORE_DEFAULT_GIT_REMOTE = ENV.fetch("HOMEBREW_CORE_DEFAULT_GIT_REMOTE").freeze
@@ -45,49 +17,62 @@
 HOMEBREW_PRODUCT = ENV.fetch("HOMEBREW_PRODUCT").freeze
 HOMEBREW_VERSION = ENV.fetch("HOMEBREW_VERSION").freeze
 HOMEBREW_WWW = "https://brew.sh"
+HOMEBREW_API_WWW = "https://formulae.brew.sh"
+HOMEBREW_DOCS_WWW = "https://docs.brew.sh"
 HOMEBREW_SYSTEM = ENV.fetch("HOMEBREW_SYSTEM").freeze
 HOMEBREW_PROCESSOR = ENV.fetch("HOMEBREW_PROCESSOR").freeze
+HOMEBREW_PHYSICAL_PROCESSOR = ENV.fetch("HOMEBREW_PHYSICAL_PROCESSOR").freeze
 
 HOMEBREW_BREWED_CURL_PATH = Pathname(ENV.fetch("HOMEBREW_BREWED_CURL_PATH")).freeze
 HOMEBREW_USER_AGENT_CURL = ENV.fetch("HOMEBREW_USER_AGENT_CURL").freeze
 HOMEBREW_USER_AGENT_RUBY =
-  "#{ENV.fetch("HOMEBREW_USER_AGENT")} ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
+  "#{ENV.fetch("HOMEBREW_USER_AGENT")} ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}".freeze
 HOMEBREW_USER_AGENT_FAKE_SAFARI =
-  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/602.4.8 " \
-  "(KHTML, like Gecko) Version/10.0.3 Safari/602.4.8"
+  # Don't update this beyond 10.15.7 until Safari actually updates their
+  # user agent to be beyond 10.15.7 (not the case as-of macOS 14)
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 " \
+  "(KHTML, like Gecko) Version/17.0 Safari/605.1.15"
 HOMEBREW_GITHUB_PACKAGES_AUTH = ENV.fetch("HOMEBREW_GITHUB_PACKAGES_AUTH").freeze
 
-HOMEBREW_DEFAULT_PREFIX = "/usr/local"
-HOMEBREW_DEFAULT_REPOSITORY = "#{HOMEBREW_DEFAULT_PREFIX}/Homebrew"
-HOMEBREW_MACOS_ARM_DEFAULT_PREFIX = "/opt/homebrew"
-HOMEBREW_MACOS_ARM_DEFAULT_REPOSITORY = HOMEBREW_MACOS_ARM_DEFAULT_PREFIX
-HOMEBREW_LINUX_DEFAULT_PREFIX = "/home/linuxbrew/.linuxbrew"
-HOMEBREW_LINUX_DEFAULT_REPOSITORY = "#{HOMEBREW_LINUX_DEFAULT_PREFIX}/Homebrew"
+HOMEBREW_DEFAULT_PREFIX = ENV.fetch("HOMEBREW_GENERIC_DEFAULT_PREFIX").freeze
+HOMEBREW_DEFAULT_REPOSITORY = ENV.fetch("HOMEBREW_GENERIC_DEFAULT_REPOSITORY").freeze
+HOMEBREW_MACOS_ARM_DEFAULT_PREFIX = ENV.fetch("HOMEBREW_MACOS_ARM_DEFAULT_PREFIX").freeze
+HOMEBREW_MACOS_ARM_DEFAULT_REPOSITORY = ENV.fetch("HOMEBREW_MACOS_ARM_DEFAULT_REPOSITORY").freeze
+HOMEBREW_LINUX_DEFAULT_PREFIX = ENV.fetch("HOMEBREW_LINUX_DEFAULT_PREFIX").freeze
+HOMEBREW_LINUX_DEFAULT_REPOSITORY = ENV.fetch("HOMEBREW_LINUX_DEFAULT_REPOSITORY").freeze
+HOMEBREW_PREFIX_PLACEHOLDER = "$HOMEBREW_PREFIX"
+HOMEBREW_CELLAR_PLACEHOLDER = "$HOMEBREW_CELLAR"
+# Needs a leading slash to avoid `File.expand.path` complaining about non-absolute home.
+HOMEBREW_HOME_PLACEHOLDER = "/$HOME"
+HOMEBREW_CASK_APPDIR_PLACEHOLDER = "$APPDIR"
+
+HOMEBREW_MACOS_NEWEST_UNSUPPORTED = ENV.fetch("HOMEBREW_MACOS_NEWEST_UNSUPPORTED").freeze
+HOMEBREW_MACOS_OLDEST_SUPPORTED = ENV.fetch("HOMEBREW_MACOS_OLDEST_SUPPORTED").freeze
+HOMEBREW_MACOS_OLDEST_ALLOWED = ENV.fetch("HOMEBREW_MACOS_OLDEST_ALLOWED").freeze
 
 HOMEBREW_PULL_API_REGEX =
-  %r{https://api\.github\.com/repos/([\w-]+)/([\w-]+)?/pulls/(\d+)}.freeze
+  %r{https://api\.github\.com/repos/([\w-]+)/([\w-]+)?/pulls/(\d+)}
 HOMEBREW_PULL_OR_COMMIT_URL_REGEX =
-  %r[https://github\.com/([\w-]+)/([\w-]+)?/(?:pull/(\d+)|commit/[0-9a-fA-F]{4,40})].freeze
-HOMEBREW_BOTTLES_EXTNAME_REGEX = /\.([a-z0-9_]+)\.bottle\.(?:(\d+)\.)?tar\.gz$/.freeze
-
-require "env_config"
-require "compat/early" unless Homebrew::EnvConfig.no_compat?
-require "macos_versions"
-require "os"
-require "messages"
-require "default_prefix"
+  %r[https://github\.com/([\w-]+)/([\w-]+)?/(?:pull/(\d+)|commit/[0-9a-fA-F]{4,40})]
+HOMEBREW_BOTTLES_EXTNAME_REGEX = /\.([a-z0-9_]+)\.bottle\.(?:(\d+)\.)?tar\.gz$/
 
 module Homebrew
   extend FileUtils
 
-  DEFAULT_CELLAR = "#{DEFAULT_PREFIX}/Cellar"
-  DEFAULT_MACOS_CELLAR = "#{HOMEBREW_DEFAULT_PREFIX}/Cellar"
-  DEFAULT_MACOS_ARM_CELLAR = "#{HOMEBREW_MACOS_ARM_DEFAULT_PREFIX}/Cellar"
-  DEFAULT_LINUX_CELLAR = "#{HOMEBREW_LINUX_DEFAULT_PREFIX}/Cellar"
+  DEFAULT_PREFIX = T.let(ENV.fetch("HOMEBREW_DEFAULT_PREFIX").freeze, String)
+  DEFAULT_REPOSITORY = T.let(ENV.fetch("HOMEBREW_DEFAULT_REPOSITORY").freeze, String)
+  DEFAULT_CELLAR = "#{DEFAULT_PREFIX}/Cellar".freeze
+  DEFAULT_MACOS_CELLAR = "#{HOMEBREW_DEFAULT_PREFIX}/Cellar".freeze
+  DEFAULT_MACOS_ARM_CELLAR = "#{HOMEBREW_MACOS_ARM_DEFAULT_PREFIX}/Cellar".freeze
+  DEFAULT_LINUX_CELLAR = "#{HOMEBREW_LINUX_DEFAULT_PREFIX}/Cellar".freeze
 
   class << self
     attr_writer :failed, :raise_deprecation_exceptions, :auditing
 
+    # Check whether Homebrew is using the default prefix.
+    #
+    # @api internal
+    sig { params(prefix: T.any(Pathname, String)).returns(T::Boolean) }
     def default_prefix?(prefix = HOMEBREW_PREFIX)
       prefix.to_s == DEFAULT_PREFIX
     end
@@ -108,35 +93,55 @@ def raise_deprecation_exceptions?
     def auditing?
       @auditing == true
     end
+
+    def running_as_root?
+      @process_euid ||= Process.euid
+      @process_euid.zero?
+    end
+
+    def owner_uid
+      @owner_uid ||= HOMEBREW_BREW_FILE.stat.uid
+    end
+
+    def running_as_root_but_not_owned_by_root?
+      running_as_root? && !owner_uid.zero?
+    end
+
+    def auto_update_command?
+      ENV.fetch("HOMEBREW_AUTO_UPDATE_COMMAND", false).present?
+    end
+
+    sig { params(cmd: T.nilable(String)).void }
+    def running_command=(cmd)
+      @running_command_with_args = "#{cmd} #{ARGV.join(" ")}"
+    end
+
+    sig { returns String }
+    def running_command_with_args
+      "brew #{@running_command_with_args}".strip
+    end
   end
 end
 
-require "context"
-require "extend/git_repository"
-require "extend/pathname"
-require "extend/predicable"
-require "extend/module"
-require "cli/args"
-
 require "PATH"
-
 ENV["HOMEBREW_PATH"] ||= ENV.fetch("PATH")
-ORIGINAL_PATHS = PATH.new(ENV.fetch("HOMEBREW_PATH")).map do |p|
+ORIGINAL_PATHS = PATH.new(ENV.fetch("HOMEBREW_PATH")).filter_map do |p|
   Pathname.new(p).expand_path
 rescue
   nil
-end.compact.freeze
+end.freeze
 
-require "set"
+require "extend/blank"
+require "extend/kernel"
+require "os"
 
+require "extend/array"
+require "extend/cachable"
+require "extend/enumerable"
 require "extend/string"
+require "extend/pathname"
 
-require "system_command"
 require "exceptions"
-require "utils"
 
-require "official_taps"
-require "tap"
 require "tap_constants"
-
-require "compat/late" unless Homebrew::EnvConfig.no_compat?
+require "official_taps"
diff --git a/Library/Homebrew/global.rbi b/Library/Homebrew/global.rbi
deleted file mode 100644
index 1557c3b769d56..0000000000000
--- a/Library/Homebrew/global.rbi
+++ /dev/null
@@ -1,5 +0,0 @@
-# typed: strict
-
-module Homebrew
-  include Kernel
-end
diff --git a/Library/Homebrew/hardware.rb b/Library/Homebrew/hardware.rb
index 52bf2e5e88630..d970ced6f2379 100644
--- a/Library/Homebrew/hardware.rb
+++ b/Library/Homebrew/hardware.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "utils/popen"
@@ -9,36 +9,37 @@ module Hardware
   class CPU
     INTEL_32BIT_ARCHS = [:i386].freeze
     INTEL_64BIT_ARCHS = [:x86_64].freeze
+    INTEL_ARCHS       = T.let((INTEL_32BIT_ARCHS + INTEL_64BIT_ARCHS).freeze, T::Array[Symbol])
     PPC_32BIT_ARCHS   = [:ppc, :ppc32, :ppc7400, :ppc7450, :ppc970].freeze
     PPC_64BIT_ARCHS   = [:ppc64, :ppc64le, :ppc970].freeze
-    ARM_64BIT_ARCHS   = [:arm64].freeze
-    ALL_ARCHS = [
-      *INTEL_32BIT_ARCHS,
-      *INTEL_64BIT_ARCHS,
-      *PPC_32BIT_ARCHS,
-      *PPC_64BIT_ARCHS,
-      *ARM_64BIT_ARCHS,
-    ].freeze
+    PPC_ARCHS         = T.let((PPC_32BIT_ARCHS + PPC_64BIT_ARCHS).freeze, T::Array[Symbol])
+    ARM_64BIT_ARCHS   = [:arm64, :aarch64].freeze
+    ARM_ARCHS         = ARM_64BIT_ARCHS
+    ALL_ARCHS = T.let([
+      *INTEL_ARCHS,
+      *PPC_ARCHS,
+      *ARM_ARCHS,
+    ].freeze, T::Array[Symbol])
 
     INTEL_64BIT_OLDEST_CPU = :core2
 
     class << self
-      extend T::Sig
-
+      sig { returns(T::Hash[Symbol, String]) }
       def optimization_flags
-        @optimization_flags ||= {
+        @optimization_flags ||= T.let({
           native:             arch_flag("native"),
           ivybridge:          "-march=ivybridge",
           sandybridge:        "-march=sandybridge",
+          westmere:           "-march=westmere",
           nehalem:            "-march=nehalem",
           core2:              "-march=core2",
           core:               "-march=prescott",
-          arm_vortex_tempest: "",
+          arm_vortex_tempest: "", # TODO: -mcpu=apple-m1 when we've patched all our GCCs to support it
           armv6:              "-march=armv6",
           armv8:              "-march=armv8-a",
           ppc64:              "-mcpu=powerpc64",
           ppc64le:            "-mcpu=powerpc64le",
-        }.freeze
+        }.freeze, T.nilable(T::Hash[Symbol, String]))
       end
       alias generic_optimization_flags optimization_flags
 
@@ -70,6 +71,7 @@ def arch_64_bit
         end
       end
 
+      sig { returns(Symbol) }
       def arch
         case bits
         when 32
@@ -96,19 +98,21 @@ def family
         :dunno
       end
 
+      sig { returns(Integer) }
       def cores
         return @cores if @cores
 
         @cores = Utils.popen_read("getconf", "_NPROCESSORS_ONLN").chomp.to_i
-        @cores = 1 unless $CHILD_STATUS.success?
+        @cores = T.let(1, T.nilable(Integer)) unless $CHILD_STATUS.success?
         @cores
       end
 
+      sig { returns(T.nilable(Integer)) }
       def bits
-        @bits ||= case RUBY_PLATFORM
+        @bits ||= T.let(case RUBY_PLATFORM
         when /x86_64/, /ppc64|powerpc64/, /aarch64|arm64/ then 64
         when /i\d86/, /ppc/, /arm/ then 32
-        end
+        end, T.nilable(Integer))
       end
 
       sig { returns(T::Boolean) }
@@ -116,54 +120,75 @@ def sse4?
         RUBY_PLATFORM.to_s.include?("x86_64")
       end
 
+      sig { returns(T::Boolean) }
       def is_32_bit?
         bits == 32
       end
 
+      sig { returns(T::Boolean) }
       def is_64_bit?
         bits == 64
       end
 
+      sig { returns(T::Boolean) }
       def intel?
         type == :intel
       end
 
+      sig { returns(T::Boolean) }
       def ppc?
         type == :ppc
       end
 
+      sig { returns(T::Boolean) }
       def ppc32?
         ppc? && is_32_bit?
       end
 
+      sig { returns(T::Boolean) }
       def ppc64le?
         ppc? && is_64_bit? && little_endian?
       end
 
+      sig { returns(T::Boolean) }
       def ppc64?
         ppc? && is_64_bit? && big_endian?
       end
 
+      # Check whether the CPU architecture is ARM.
+      #
+      # @api internal
+      sig { returns(T::Boolean) }
       def arm?
         type == :arm
       end
 
+      sig { returns(T::Boolean) }
       def little_endian?
         !big_endian?
       end
 
+      sig { returns(T::Boolean) }
       def big_endian?
         [1].pack("I") == [1].pack("N")
       end
 
+      sig { returns(FalseClass) }
+      def virtualized?
+        false
+      end
+
+      sig { returns(T::Array[Symbol]) }
       def features
         []
       end
 
+      sig { params(name: Symbol).returns(T::Boolean) }
       def feature?(name)
         features.include?(name)
       end
 
+      sig { params(arch: T.any(String, Symbol)).returns(String) }
       def arch_flag(arch)
         return "-mcpu=#{arch}" if ppc?
 
@@ -178,6 +203,7 @@ def in_rosetta2?
   end
 
   class << self
+    sig { returns(String) }
     def cores_as_words
       case Hardware::CPU.cores
       when 1 then "single"
@@ -187,7 +213,7 @@ def cores_as_words
       when 8 then "octa"
       when 12 then "dodeca"
       else
-        Hardware::CPU.cores
+        Hardware::CPU.cores.to_s
       end
     end
 
@@ -215,6 +241,24 @@ def oldest_cpu(_version = nil)
       end
     end
     alias generic_oldest_cpu oldest_cpu
+
+    # Returns a Rust flag to set the target CPU if necessary.
+    # Defaults to nil.
+    sig { params(arch: Symbol).returns(T.nilable(String)) }
+    def rustflags_target_cpu(arch)
+      # Rust already defaults to the oldest supported cpu for each target-triplet
+      # so it's safe to ignore generic archs such as :armv6 here.
+      # Rust defaults to apple-m1 since Rust 1.71 for aarch64-apple-darwin.
+      @target_cpu ||= T.let(case arch
+      when :core
+        :prescott
+      when :native, :ivybridge, :sandybridge, :westmere, :nehalem, :core2
+        arch
+      end, T.nilable(Symbol))
+      return if @target_cpu.blank?
+
+      "--codegen target-cpu=#{@target_cpu}"
+    end
   end
 end
 
diff --git a/Library/Homebrew/help.rb b/Library/Homebrew/help.rb
index fba154d8e01ca..ef6d975f50221 100644
--- a/Library/Homebrew/help.rb
+++ b/Library/Homebrew/help.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "cli/parser"
@@ -6,53 +6,25 @@
 
 module Homebrew
   # Helper module for printing help output.
-  #
-  # @api private
   module Help
-    # NOTE: Keep the length of vanilla `--help` less than 25 lines!
-    #       This is because the default Terminal height is 25 lines. Scrolling sucks
-    #       and concision is important. If more help is needed we should start
-    #       specialising help like the gem command does.
-    # NOTE: Keep lines less than 80 characters! Wrapping is just not cricket.
-    HOMEBREW_HELP = <<~EOS
-      Example usage:
-        brew search TEXT|/REGEX/
-        brew info [FORMULA|CASK...]
-        brew install FORMULA|CASK...
-        brew update
-        brew upgrade [FORMULA|CASK...]
-        brew uninstall FORMULA|CASK...
-        brew list [FORMULA|CASK...]
-
-      Troubleshooting:
-        brew config
-        brew doctor
-        brew install --verbose --debug FORMULA|CASK
-
-      Contributing:
-        brew create URL [--no-fetch]
-        brew edit [FORMULA|CASK...]
-
-      Further help:
-        brew commands
-        brew help [COMMAND]
-        man brew
-        https://docs.brew.sh
-    EOS
-    private_constant :HOMEBREW_HELP
-
-    module_function
-
-    def help(cmd = nil, empty_argv: false, usage_error: nil, remaining_args: [])
+    sig {
+      params(
+        cmd:            T.nilable(String),
+        empty_argv:     T::Boolean,
+        usage_error:    T.nilable(String),
+        remaining_args: T::Array[String],
+      ).void
+    }
+    def self.help(cmd = nil, empty_argv: false, usage_error: nil, remaining_args: [])
       if cmd.nil?
         # Handle `brew` (no arguments).
         if empty_argv
-          $stderr.puts HOMEBREW_HELP
+          $stderr.puts HOMEBREW_HELP_MESSAGE
           exit 1
         end
 
         # Handle `brew (-h|--help|--usage|-?|help)` (no other arguments).
-        puts HOMEBREW_HELP
+        puts HOMEBREW_HELP_MESSAGE
         exit 0
       end
 
@@ -61,7 +33,7 @@ def help(cmd = nil, empty_argv: false, usage_error: nil, remaining_args: [])
 
       # Display command-specific (or generic) help in response to `UsageError`.
       if usage_error
-        $stderr.puts path ? command_help(cmd, path, remaining_args: remaining_args) : HOMEBREW_HELP
+        $stderr.puts path ? command_help(cmd, path, remaining_args:) : HOMEBREW_HELP_MESSAGE
         $stderr.puts
         onoe usage_error
         exit 1
@@ -71,30 +43,43 @@ def help(cmd = nil, empty_argv: false, usage_error: nil, remaining_args: [])
       return if path.nil?
 
       # Display help for internal command (or generic help if undocumented).
-      puts command_help(cmd, path, remaining_args: remaining_args)
+      puts command_help(cmd, path, remaining_args:)
       exit 0
     end
 
-    def command_help(cmd, path, remaining_args:)
+    sig {
+      params(
+        cmd:            String,
+        path:           Pathname,
+        remaining_args: T::Array[String],
+      ).returns(String)
+    }
+    def self.command_help(cmd, path, remaining_args:)
       # Only some types of commands can have a parser.
       output = if Commands.valid_internal_cmd?(cmd) ||
                   Commands.valid_internal_dev_cmd?(cmd) ||
                   Commands.external_ruby_v2_cmd_path(cmd)
-        parser_help(path, remaining_args: remaining_args)
+        parser_help(path, remaining_args:)
       end
 
       output ||= comment_help(path)
 
       output ||= if output.blank?
         opoo "No help text in: #{path}" if Homebrew::EnvConfig.developer?
-        HOMEBREW_HELP
+        HOMEBREW_HELP_MESSAGE
       end
 
       output
     end
     private_class_method :command_help
 
-    def parser_help(path, remaining_args:)
+    sig {
+      params(
+        path:           Pathname,
+        remaining_args: T::Array[String],
+      ).returns(T.nilable(String))
+    }
+    def self.parser_help(path, remaining_args:)
       # Let OptionParser generate help text for commands which have a parser.
       cmd_parser = CLI::Parser.from_cmd_path(path)
       return unless cmd_parser
@@ -105,20 +90,22 @@ def parser_help(path, remaining_args:)
     end
     private_class_method :parser_help
 
-    def command_help_lines(path)
+    sig { params(path: Pathname).returns(T::Array[String]) }
+    def self.command_help_lines(path)
       path.read
           .lines
           .grep(/^#:/)
-          .map { |line| line.slice(2..-1).delete_prefix("  ") }
+          .filter_map { |line| line.slice(2..-1)&.delete_prefix("  ") }
     end
     private_class_method :command_help_lines
 
-    def comment_help(path)
+    sig { params(path: Pathname).returns(T.nilable(String)) }
+    def self.comment_help(path)
       # Otherwise read #: lines from the file.
       help_lines = command_help_lines(path)
       return if help_lines.blank?
 
-      Formatter.format_help_text(help_lines.join, width: COMMAND_DESC_WIDTH)
+      Formatter.format_help_text(help_lines.join, width: Formatter::COMMAND_DESC_WIDTH)
                .sub("@hide_from_man_page ", "")
                .sub(/^\* /, "#{Tty.bold}Usage: brew#{Tty.reset} ")
                .gsub(/`(.*?)`/m, "#{Tty.bold}\\1#{Tty.reset}")
diff --git a/Library/Homebrew/help.rbi b/Library/Homebrew/help.rbi
deleted file mode 100644
index 9db873c525c58..0000000000000
--- a/Library/Homebrew/help.rbi
+++ /dev/null
@@ -1,7 +0,0 @@
-# typed: strict
-
-module Homebrew
-  module Help
-    include Kernel
-  end
-end
diff --git a/Library/Homebrew/help.sh b/Library/Homebrew/help.sh
new file mode 100644
index 0000000000000..f2a9ccd8867a8
--- /dev/null
+++ b/Library/Homebrew/help.sh
@@ -0,0 +1,48 @@
+#:  * `help`
+#:
+#:  Outputs the usage instructions for `brew`.
+#:
+
+# NOTE: Keep the length of vanilla `--help` less than 25 lines!
+#       This is because the default Terminal height is 25 lines. Scrolling sucks
+#       and concision is important. If more help is needed we should start
+#       specialising help like the gem command does.
+# NOTE: Keep lines less than 80 characters! Wrapping is just not cricket.
+HOMEBREW_HELP_MESSAGE=$(
+  cat <<'EOS'
+Example usage:
+  brew search TEXT|/REGEX/
+  brew info [FORMULA|CASK...]
+  brew install FORMULA|CASK...
+  brew update
+  brew upgrade [FORMULA|CASK...]
+  brew uninstall FORMULA|CASK...
+  brew list [FORMULA|CASK...]
+
+Troubleshooting:
+  brew config
+  brew doctor
+  brew install --verbose --debug FORMULA|CASK
+
+Contributing:
+  brew create URL [--no-fetch]
+  brew edit [FORMULA|CASK...]
+
+Further help:
+  brew commands
+  brew help [COMMAND]
+  man brew
+  https://docs.brew.sh
+EOS
+)
+
+homebrew-help() {
+  if [[ -z "$*" ]]
+  then
+    echo "${HOMEBREW_HELP_MESSAGE}" >&2
+    exit 1
+  fi
+
+  echo "${HOMEBREW_HELP_MESSAGE}"
+  return 0
+}
diff --git a/Library/Homebrew/ignorable.rb b/Library/Homebrew/ignorable.rb
index 4ede76f392a37..624dd2269c177 100644
--- a/Library/Homebrew/ignorable.rb
+++ b/Library/Homebrew/ignorable.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "warnings"
@@ -7,8 +7,6 @@
 end
 
 # Provides the ability to optionally ignore errors raised and continue execution.
-#
-# @api private
 module Ignorable
   # Marks exceptions which can be ignored and provides
   # the ability to jump back to where it was raised.
@@ -30,7 +28,7 @@ def raise(*)
         rescue Exception => e # rubocop:disable Lint/RescueException
           unless e.is_a?(ScriptError)
             e.extend(ExceptionMixin)
-            e.continuation = continuation
+            T.cast(e, ExceptionMixin).continuation = continuation
           end
           super(e)
         end
@@ -47,11 +45,8 @@ def raise(*)
 
   def self.unhook_raise
     Object.class_eval do
-      # False positive - https://github.com/rubocop/rubocop/issues/5022
-      # rubocop:disable Lint/DuplicateMethods
       alias_method :raise, :original_raise
       alias_method :fail, :original_raise
-      # rubocop:enable Lint/DuplicateMethods
       undef :original_raise
     end
   end
diff --git a/Library/Homebrew/ignorable.rbi b/Library/Homebrew/ignorable.rbi
new file mode 100644
index 0000000000000..f8b29fefac11d
--- /dev/null
+++ b/Library/Homebrew/ignorable.rbi
@@ -0,0 +1,8 @@
+# typed: strict
+
+module Ignorable
+  include Kernel
+  # This is a workaround to enable `raise` to be aliased
+  # @see https://github.com/sorbet/sorbet/issues/2378#issuecomment-569474238
+  def self.raise(*); end
+end
diff --git a/Library/Homebrew/install.rb b/Library/Homebrew/install.rb
index 9ab565d431c03..bf03c18c070fb 100644
--- a/Library/Homebrew/install.rb
+++ b/Library/Homebrew/install.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "diagnostic"
@@ -9,324 +9,356 @@
 
 module Homebrew
   # Helper module for performing (pre-)install checks.
-  #
-  # @api private
   module Install
-    module_function
-
-    def perform_preinstall_checks(all_fatal: false, cc: nil)
-      check_prefix
-      check_cpu
-      attempt_directory_creation
-      check_cc_argv(cc)
-      Diagnostic.checks(:supported_configuration_checks, fatal: all_fatal)
-      Diagnostic.checks(:fatal_preinstall_checks)
-    end
-    alias generic_perform_preinstall_checks perform_preinstall_checks
-    module_function :generic_perform_preinstall_checks
-
-    def perform_build_from_source_checks(all_fatal: false)
-      Diagnostic.checks(:fatal_build_from_source_checks)
-      Diagnostic.checks(:build_from_source_checks, fatal: all_fatal)
-    end
-
-    def check_prefix
-      if (Hardware::CPU.intel? || Hardware::CPU.in_rosetta2?) &&
-         HOMEBREW_PREFIX.to_s == HOMEBREW_MACOS_ARM_DEFAULT_PREFIX
-        if Hardware::CPU.in_rosetta2?
-          odie <<~EOS
-            Cannot install under Rosetta 2 in ARM default prefix (#{HOMEBREW_PREFIX})!
-            To rerun under ARM use:
-                arch -arm64 brew install ...
-            To install under x86_64, install Homebrew into #{HOMEBREW_DEFAULT_PREFIX}.
-          EOS
-        else
-          odie "Cannot install on Intel processor in ARM default prefix (#{HOMEBREW_PREFIX})!"
+    class << self
+      sig { params(all_fatal: T::Boolean).void }
+      def perform_preinstall_checks_once(all_fatal: false)
+        @perform_preinstall_checks_once ||= {}
+        @perform_preinstall_checks_once[all_fatal] ||= begin
+          perform_preinstall_checks(all_fatal:)
+          true
         end
-      elsif Hardware::CPU.arm? && HOMEBREW_PREFIX.to_s == HOMEBREW_DEFAULT_PREFIX
-        odie <<~EOS
-          Cannot install in Homebrew on ARM processor in Intel default prefix (#{HOMEBREW_PREFIX})!
-          Please create a new installation in #{HOMEBREW_MACOS_ARM_DEFAULT_PREFIX} using one of the
-          "Alternative Installs" from:
-            #{Formatter.url("https://docs.brew.sh/Installation")}
-          You can migrate your previously installed formula list with:
-            brew bundle dump
-        EOS
       end
-    end
 
-    def check_cpu
-      return unless Hardware::CPU.ppc?
+      def check_cc_argv(cc)
+        return unless cc
 
-      odie <<~EOS
-        Sorry, Homebrew does not support your computer's CPU architecture!
-        For PowerPC Mac (PPC32/PPC64BE) support, see:
-          #{Formatter.url("https://github.com/mistydemeo/tigerbrew")}
-      EOS
-    end
-    private_class_method :check_cpu
-
-    def attempt_directory_creation
-      Keg::MUST_EXIST_DIRECTORIES.each do |dir|
-        FileUtils.mkdir_p(dir) unless dir.exist?
-
-        # Create these files to ensure that these directories aren't removed
-        # by the Catalina installer.
-        # (https://github.com/Homebrew/brew/issues/6263)
-        keep_file = dir/".keepme"
-        FileUtils.touch(keep_file) unless keep_file.exist?
-      rescue
-        nil
+        @checks ||= Diagnostic::Checks.new
+        opoo <<~EOS
+          You passed `--cc=#{cc}`.
+          #{@checks.please_create_pull_requests}
+        EOS
       end
-    end
-    private_class_method :attempt_directory_creation
-
-    def check_cc_argv(cc)
-      return unless cc
 
-      @checks ||= Diagnostic::Checks.new
-      opoo <<~EOS
-        You passed `--cc=#{cc}`.
-        #{@checks.please_create_pull_requests}
-      EOS
-    end
-    private_class_method :check_cc_argv
-
-    def install_formula?(
-      f,
-      head: false,
-      fetch_head: false,
-      only_dependencies: false,
-      force: false,
-      quiet: false
-    )
-      # head-only without --HEAD is an error
-      if !head && f.stable.nil?
-        odie <<~EOS
-          #{f.full_name} is a head-only formula.
-          To install it, run:
-            brew install --HEAD #{f.full_name}
-        EOS
+      def perform_build_from_source_checks(all_fatal: false)
+        Diagnostic.checks(:fatal_build_from_source_checks)
+        Diagnostic.checks(:build_from_source_checks, fatal: all_fatal)
       end
 
-      # --HEAD, fail with no head defined
-      odie "No head is defined for #{f.full_name}" if head && f.head.nil?
+      def global_post_install; end
+      alias generic_global_post_install global_post_install
 
-      installed_head_version = f.latest_head_version
-      if installed_head_version &&
-         !f.head_version_outdated?(installed_head_version, fetch_head: fetch_head)
-        new_head_installed = true
-      end
-      prefix_installed = f.prefix.exist? && !f.prefix.children.empty?
-
-      if f.keg_only? && f.any_version_installed? && f.optlinked? && !force
-        # keg-only install is only possible when no other version is
-        # linked to opt, because installing without any warnings can break
-        # dependencies. Therefore before performing other checks we need to be
-        # sure --force flag is passed.
-        if f.outdated?
-          if !Homebrew::EnvConfig.no_install_upgrade? && !f.pinned?
-            puts "#{f.name} #{f.linked_version} is already installed but outdated (so it will be upgraded)."
-            return true
+      def check_prefix
+        if (Hardware::CPU.intel? || Hardware::CPU.in_rosetta2?) &&
+           HOMEBREW_PREFIX.to_s == HOMEBREW_MACOS_ARM_DEFAULT_PREFIX
+          if Hardware::CPU.in_rosetta2?
+            odie <<~EOS
+              Cannot install under Rosetta 2 in ARM default prefix (#{HOMEBREW_PREFIX})!
+              To rerun under ARM use:
+                  arch -arm64 brew install ...
+              To install under x86_64, install Homebrew into #{HOMEBREW_DEFAULT_PREFIX}.
+            EOS
+          else
+            odie "Cannot install on Intel processor in ARM default prefix (#{HOMEBREW_PREFIX})!"
           end
-
-          unpin_cmd_if_needed = ("brew unpin #{f.full_name} && " if f.pinned?)
-          optlinked_version = Keg.for(f.opt_prefix).version
-          onoe <<~EOS
-            #{f.full_name} #{optlinked_version} is already installed.
-            To upgrade to #{f.version}, run:
-              #{unpin_cmd_if_needed}brew upgrade #{f.full_name}
+        elsif Hardware::CPU.arm? && HOMEBREW_PREFIX.to_s == HOMEBREW_DEFAULT_PREFIX
+          odie <<~EOS
+            Cannot install in Homebrew on ARM processor in Intel default prefix (#{HOMEBREW_PREFIX})!
+            Please create a new installation in #{HOMEBREW_MACOS_ARM_DEFAULT_PREFIX} using one of the
+            "Alternative Installs" from:
+              #{Formatter.url("https://docs.brew.sh/Installation")}
+            You can migrate your previously installed formula list with:
+              brew bundle dump
           EOS
-        elsif only_dependencies
-          return true
-        elsif !quiet
-          opoo <<~EOS
-            #{f.full_name} #{f.pkg_version} is already installed and up-to-date.
-            To reinstall #{f.pkg_version}, run:
-              brew reinstall #{f.name}
+        end
+      end
+
+      def install_formula?(
+        formula,
+        head: false,
+        fetch_head: false,
+        only_dependencies: false,
+        force: false,
+        quiet: false,
+        overwrite: false
+      )
+        # head-only without --HEAD is an error
+        if !head && formula.stable.nil?
+          odie <<~EOS
+            #{formula.full_name} is a head-only formula.
+            To install it, run:
+              brew install --HEAD #{formula.full_name}
           EOS
         end
-      elsif (head && new_head_installed) || prefix_installed
-        # After we're sure that --force flag is passed for linked to opt
-        # keg-only we need to be sure that the version we're attempting to
-        # install is not already installed.
 
-        installed_version = if head
-          f.latest_head_version
-        else
-          f.pkg_version
+        # --HEAD, fail with no head defined
+        odie "No head is defined for #{formula.full_name}" if head && formula.head.nil?
+
+        installed_head_version = formula.latest_head_version
+        if installed_head_version &&
+           !formula.head_version_outdated?(installed_head_version, fetch_head:)
+          new_head_installed = true
         end
+        prefix_installed = formula.prefix.exist? && !formula.prefix.children.empty?
 
-        msg = "#{f.full_name} #{installed_version} is already installed"
-        linked_not_equals_installed = f.linked_version != installed_version
-        if f.linked? && linked_not_equals_installed
-          msg = if quiet
-            nil
+        if formula.keg_only? && formula.any_version_installed? && formula.optlinked? && !force
+          # keg-only install is only possible when no other version is
+          # linked to opt, because installing without any warnings can break
+          # dependencies. Therefore before performing other checks we need to be
+          # sure the --force switch is passed.
+          if formula.outdated?
+            if !Homebrew::EnvConfig.no_install_upgrade? && !formula.pinned?
+              name = formula.name
+              version = formula.linked_version
+              puts "#{name} #{version} is already installed but outdated (so it will be upgraded)."
+              return true
+            end
+
+            unpin_cmd_if_needed = ("brew unpin #{formula.full_name} && " if formula.pinned?)
+            optlinked_version = Keg.for(formula.opt_prefix).version
+            onoe <<~EOS
+              #{formula.full_name} #{optlinked_version} is already installed.
+              To upgrade to #{formula.version}, run:
+                #{unpin_cmd_if_needed}brew upgrade #{formula.full_name}
+            EOS
+          elsif only_dependencies
+            return true
+          elsif !quiet
+            opoo <<~EOS
+              #{formula.full_name} #{formula.pkg_version} is already installed and up-to-date.
+              To reinstall #{formula.pkg_version}, run:
+                brew reinstall #{formula.name}
+            EOS
+          end
+        elsif (head && new_head_installed) || prefix_installed
+          # After we're sure the --force switch was passed for linking to opt
+          # keg-only we need to be sure that the version we're attempting to
+          # install is not already installed.
+
+          installed_version = if head
+            formula.latest_head_version
           else
+            formula.pkg_version
+          end
+
+          msg = "#{formula.full_name} #{installed_version} is already installed"
+          linked_not_equals_installed = formula.linked_version != installed_version
+          if formula.linked? && linked_not_equals_installed
+            msg = if quiet
+              nil
+            else
+              <<~EOS
+                #{msg}.
+                The currently linked version is: #{formula.linked_version}
+              EOS
+            end
+          elsif only_dependencies || (!formula.linked? && overwrite)
+            msg = nil
+            return true
+          elsif !formula.linked? || formula.keg_only?
+            msg = <<~EOS
+              #{msg}, it's just not linked.
+              To link this version, run:
+                brew link #{formula}
+            EOS
+          else
+            msg = if quiet
+              nil
+            else
+              <<~EOS
+                #{msg} and up-to-date.
+                To reinstall #{formula.pkg_version}, run:
+                  brew reinstall #{formula.name}
+              EOS
+            end
+          end
+          opoo msg if msg
+        elsif !formula.any_version_installed? && (old_formula = formula.old_installed_formulae.first)
+          msg = "#{old_formula.full_name} #{old_formula.any_installed_version} already installed"
+          msg = if !old_formula.linked? && !old_formula.keg_only?
             <<~EOS
-              #{msg}.
-              The currently linked version is: #{f.linked_version}
+              #{msg}, it's just not linked.
+              To link this version, run:
+                brew link #{old_formula.full_name}
             EOS
+          elsif quiet
+            nil
+          else
+            "#{msg}."
           end
-        elsif !f.linked? || f.keg_only?
-          msg = <<~EOS
-            #{msg}, it's just not linked.
-            To link this version, run:
-              brew link #{f}
+          opoo msg if msg
+        elsif formula.migration_needed? && !force
+          # Check if the formula we try to install is the same as installed
+          # but not migrated one. If --force is passed then install anyway.
+          opoo <<~EOS
+            #{formula.oldnames_to_migrate.first} is already installed, it's just not migrated.
+            To migrate this formula, run:
+              brew migrate #{formula}
+            Or to force-install it, run:
+              brew install #{formula} --force
           EOS
-        elsif only_dependencies
-          msg = nil
-          return true
-        else
-          msg = if quiet
-            nil
+        elsif formula.linked?
+          message = "#{formula.name} #{formula.linked_version} is already installed"
+          if formula.outdated? && !head
+            if !Homebrew::EnvConfig.no_install_upgrade? && !formula.pinned?
+              puts "#{message} but outdated (so it will be upgraded)."
+              return true
+            end
+
+            unpin_cmd_if_needed = ("brew unpin #{formula.full_name} && " if formula.pinned?)
+            onoe <<~EOS
+              #{message}
+              To upgrade to #{formula.pkg_version}, run:
+                #{unpin_cmd_if_needed}brew upgrade #{formula.full_name}
+            EOS
+          elsif only_dependencies
+            return true
           else
-            <<~EOS
-              #{msg} and up-to-date.
-              To reinstall #{f.pkg_version}, run:
-                brew reinstall #{f.name}
+            onoe <<~EOS
+              #{message}
+              To install #{formula.pkg_version}, first run:
+                brew unlink #{formula.name}
             EOS
           end
-        end
-        opoo msg if msg
-      elsif !f.any_version_installed? && (old_formula = f.old_installed_formulae.first)
-        msg = "#{old_formula.full_name} #{old_formula.any_installed_version} already installed"
-        msg = if !old_formula.linked? && !old_formula.keg_only?
-          <<~EOS
-            #{msg}, it's just not linked.
-            To link this version, run:
-              brew link #{old_formula.full_name}
-          EOS
-        elsif quiet
-          nil
         else
-          "#{msg}."
+          # If none of the above is true and the formula is linked, then
+          # FormulaInstaller will handle this case.
+          return true
         end
-        opoo msg if msg
-      elsif f.migration_needed? && !force
-        # Check if the formula we try to install is the same as installed
-        # but not migrated one. If --force is passed then install anyway.
-        opoo <<~EOS
-          #{f.oldname} is already installed, it's just not migrated.
-          To migrate this formula, run:
-            brew migrate #{f}
-          Or to force-install it, run:
-            brew install #{f} --force
-        EOS
-      elsif f.linked?
-        message = "#{f.name} #{f.linked_version} is already installed"
-        if f.outdated? && !head
-          if !Homebrew::EnvConfig.no_install_upgrade? && !f.pinned?
-            puts "#{message} but outdated (so it will be upgraded)."
-            return true
+
+        # Even if we don't install this formula mark it as no longer just
+        # installed as a dependency.
+        return false unless formula.opt_prefix.directory?
+
+        keg = Keg.new(formula.opt_prefix.resolved_path)
+        tab = keg.tab
+        unless tab.installed_on_request
+          tab.installed_on_request = true
+          tab.write
+        end
+
+        false
+      end
+
+      def install_formulae(
+        formulae_to_install,
+        build_bottle: false,
+        force_bottle: false,
+        bottle_arch: nil,
+        ignore_deps: false,
+        only_deps: false,
+        include_test_formulae: [],
+        build_from_source_formulae: [],
+        cc: nil,
+        git: false,
+        interactive: false,
+        keep_tmp: false,
+        debug_symbols: false,
+        force: false,
+        overwrite: false,
+        debug: false,
+        quiet: false,
+        verbose: false,
+        dry_run: false,
+        skip_post_install: false
+      )
+        formula_installers = formulae_to_install.filter_map do |formula|
+          Migrator.migrate_if_needed(formula, force:, dry_run:)
+          build_options = formula.build
+
+          formula_installer = FormulaInstaller.new(
+            formula,
+            options:                    build_options.used_options,
+            build_bottle:,
+            force_bottle:,
+            bottle_arch:,
+            ignore_deps:,
+            only_deps:,
+            include_test_formulae:,
+            build_from_source_formulae:,
+            cc:,
+            git:,
+            interactive:,
+            keep_tmp:,
+            debug_symbols:,
+            force:,
+            overwrite:,
+            debug:,
+            quiet:,
+            verbose:,
+            skip_post_install:,
+          )
+
+          begin
+            unless dry_run
+              formula_installer.prelude
+              formula_installer.fetch
+            end
+            formula_installer
+          rescue CannotInstallFormulaError => e
+            ofail e.message
+            nil
+          rescue UnsatisfiedRequirements, DownloadError, ChecksumMismatchError => e
+            ofail "#{formula}: #{e}"
+            nil
           end
+        end
 
-          unpin_cmd_if_needed = ("brew unpin #{f.full_name} && " if f.pinned?)
-          onoe <<~EOS
-            #{message}
-            To upgrade to #{f.pkg_version}, run:
-              #{unpin_cmd_if_needed}brew upgrade #{f.full_name}
-          EOS
-        elsif only_dependencies
-          return true
-        else
-          onoe <<~EOS
-            #{message}
-            To install #{f.pkg_version}, first run:
-              brew unlink #{f.name}
-          EOS
+        if dry_run
+          if (formulae_name_to_install = formulae_to_install.map(&:name))
+            ohai "Would install #{Utils.pluralize("formula", formulae_name_to_install.count,
+                                                  plural: "e", include_count: true)}:"
+            puts formulae_name_to_install.join(" ")
+
+            formula_installers.each do |fi|
+              print_dry_run_dependencies(fi.formula, fi.compute_dependencies, &:name)
+            end
+          end
+          return
+        end
+
+        formula_installers.each do |fi|
+          install_formula(fi)
+          Cleanup.install_formula_clean!(fi.formula)
         end
-      else
-        # If none of the above is true and the formula is linked, then
-        # FormulaInstaller will handle this case.
-        return true
       end
 
-      # Even if we don't install this formula mark it as no longer just
-      # installed as a dependency.
-      return false unless f.opt_prefix.directory?
+      def print_dry_run_dependencies(formula, dependencies)
+        return if dependencies.empty?
 
-      keg = Keg.new(f.opt_prefix.resolved_path)
-      tab = Tab.for_keg(keg)
-      unless tab.installed_on_request
-        tab.installed_on_request = true
-        tab.write
+        ohai "Would install #{Utils.pluralize("dependenc", dependencies.count, plural: "ies", singular: "y",
+                                            include_count: true)} for #{formula.name}:"
+        formula_names = dependencies.map { |(dep, _options)| yield dep.to_formula }
+        puts formula_names.join(" ")
       end
 
-      false
-    end
+      private
 
-    def install_formulae(
-      formulae_to_install,
-      build_bottle: false,
-      force_bottle: false,
-      bottle_arch: nil,
-      ignore_deps: false,
-      only_deps: false,
-      include_test_formulae: [],
-      build_from_source_formulae: [],
-      cc: nil,
-      git: false,
-      interactive: false,
-      keep_tmp: false,
-      force: false,
-      overwrite: false,
-      debug: false,
-      quiet: false,
-      verbose: false
-    )
-      formula_installers = formulae_to_install.map do |f|
-        Migrator.migrate_if_needed(f, force: force)
-        build_options = f.build
-
-        fi = FormulaInstaller.new(
-          f,
-          options:                    build_options.used_options,
-          build_bottle:               build_bottle,
-          force_bottle:               force_bottle,
-          bottle_arch:                bottle_arch,
-          ignore_deps:                ignore_deps,
-          only_deps:                  only_deps,
-          include_test_formulae:      include_test_formulae,
-          build_from_source_formulae: build_from_source_formulae,
-          cc:                         cc,
-          git:                        git,
-          interactive:                interactive,
-          keep_tmp:                   keep_tmp,
-          force:                      force,
-          overwrite:                  overwrite,
-          debug:                      debug,
-          quiet:                      quiet,
-          verbose:                    verbose,
-        )
-
-        begin
-          fi.prelude
-          fi.fetch
-          fi
-        rescue CannotInstallFormulaError => e
-          ofail e.message
-          nil
-        rescue UnsatisfiedRequirements, DownloadError, ChecksumMismatchError => e
-          ofail "#{f}: #{e}"
+      def perform_preinstall_checks(all_fatal: false)
+        check_prefix
+        check_cpu
+        attempt_directory_creation
+        Diagnostic.checks(:supported_configuration_checks, fatal: all_fatal)
+        Diagnostic.checks(:fatal_preinstall_checks)
+      end
+      alias generic_perform_preinstall_checks perform_preinstall_checks
+
+      def attempt_directory_creation
+        Keg.must_exist_directories.each do |dir|
+          FileUtils.mkdir_p(dir) unless dir.exist?
+        rescue
           nil
         end
-      end.compact
+      end
 
-      formula_installers.each do |fi|
-        install_formula(fi)
-        Cleanup.install_formula_clean!(fi.formula)
+      def check_cpu
+        return unless Hardware::CPU.ppc?
+
+        odie <<~EOS
+          Sorry, Homebrew does not support your computer's CPU architecture!
+          For PowerPC Mac (PPC32/PPC64BE) support, see:
+            #{Formatter.url("https://github.com/mistydemeo/tigerbrew")}
+        EOS
       end
-    end
 
-    def install_formula(formula_installer)
-      f = formula_installer.formula
+      def install_formula(formula_installer)
+        formula = formula_installer.formula
 
-      upgrade = f.linked? && f.outdated? && !f.head? && !Homebrew::EnvConfig.no_install_upgrade?
+        upgrade = formula.linked? && formula.outdated? && !formula.head? && !Homebrew::EnvConfig.no_install_upgrade?
 
-      Upgrade.install_formula(formula_installer, upgrade: upgrade)
+        Upgrade.install_formula(formula_installer, upgrade:)
+      end
     end
-    private_class_method :install_formula
   end
 end
 
diff --git a/Library/Homebrew/install.rbi b/Library/Homebrew/install.rbi
deleted file mode 100644
index 5208127284167..0000000000000
--- a/Library/Homebrew/install.rbi
+++ /dev/null
@@ -1,7 +0,0 @@
-# typed: strict
-
-module Homebrew
-  module Install
-    include Kernel
-  end
-end
diff --git a/Library/Homebrew/install_renamed.rb b/Library/Homebrew/install_renamed.rb
index 6018da8102a0c..5e4b0fd40b412 100644
--- a/Library/Homebrew/install_renamed.rb
+++ b/Library/Homebrew/install_renamed.rb
@@ -1,9 +1,7 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 # Helper module for installing default files.
-#
-# @api private
 module InstallRenamed
   def install_p(_, new_basename)
     super do |src, dst|
@@ -23,11 +21,11 @@ def cp_path_sub(pattern, replacement)
   end
 
   def +(other)
-    super(other).extend(InstallRenamed)
+    super.extend(InstallRenamed)
   end
 
   def /(other)
-    super(other).extend(InstallRenamed)
+    super.extend(InstallRenamed)
   end
 
   private
diff --git a/Library/Homebrew/installed_dependents.rb b/Library/Homebrew/installed_dependents.rb
index 7977dea71dedc..14eaf239a0eb2 100644
--- a/Library/Homebrew/installed_dependents.rb
+++ b/Library/Homebrew/installed_dependents.rb
@@ -1,14 +1,10 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cask_dependent"
 
 # Helper functions for installed dependents.
-#
-# @api private
 module InstalledDependents
-  extend T::Sig
-
   module_function
 
   # Given an array of kegs, this method will try to find some other kegs
@@ -54,12 +50,12 @@ def find_some_installed_dependents(kegs, casks: [])
         CaskDependent.new(dependent).runtime_dependencies.map(&:to_formula)
       end
 
-      required_kegs = required.map do |f|
+      required_kegs = required.filter_map do |f|
         f_kegs = kegs_by_source[[f.name, f.tap]]
         next unless f_kegs
 
-        f_kegs.max_by(&:version)
-      end.compact
+        f_kegs.max_by(&:scheme_and_version)
+      end
 
       next if required_kegs.empty?
 
diff --git a/Library/Homebrew/items.sh b/Library/Homebrew/items.sh
index 838ef5f6e2363..9a31aa92f4647 100644
--- a/Library/Homebrew/items.sh
+++ b/Library/Homebrew/items.sh
@@ -1,32 +1,38 @@
 homebrew-items() {
   local items
   local sed_extended_regex_flag
-  local find_filter="$1"
-  local sed_filter="$2"
-  local grep_filter="$3"
+  local find_args
+  local find_include_filter="$1"
+  local find_exclude_filter="$2"
+  local sed_filter="$3"
+  local grep_filter="$4"
 
   # HOMEBREW_MACOS is set by brew.sh
   # shellcheck disable=SC2154
   if [[ -n "${HOMEBREW_MACOS}" ]]
   then
     sed_extended_regex_flag="-E"
+    find_args=("-E" "${HOMEBREW_REPOSITORY}/Library/Taps")
   else
     sed_extended_regex_flag="-r"
+    find_args=("${HOMEBREW_REPOSITORY}/Library/Taps" "-regextype" "posix-extended")
   fi
 
   # HOMEBREW_REPOSITORY is set by brew.sh
   # shellcheck disable=SC2154
+  [[ -d "${HOMEBREW_REPOSITORY}/Library/Taps" ]] || return
   items="$(
-    find "${HOMEBREW_REPOSITORY}/Library/Taps" \
+    find "${find_args[@]}" \
       -type d \( \
-      -name "${find_filter}" -o \
+      -regex "${find_exclude_filter}" -o \
       -name cmd -o \
       -name .github -o \
       -name lib -o \
       -name spec -o \
-      -name vendor \
+      -name vendor -o \
+      -name .git \
       \) \
-      -prune -false -o -name '*\.rb' |
+      -prune -false -o -path "${find_include_filter}" |
       sed "${sed_extended_regex_flag}" \
         -e 's/\.rb//g' \
         -e 's_.*/Taps/(.*)/(home|linux)brew-_\1/_' \
diff --git a/Library/Homebrew/keg.rb b/Library/Homebrew/keg.rb
index c0ef58fc89dd7..0b0f67d2564cd 100644
--- a/Library/Homebrew/keg.rb
+++ b/Library/Homebrew/keg.rb
@@ -1,18 +1,13 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "keg_relocate"
 require "language/python"
 require "lock_file"
-require "ostruct"
 require "extend/cachable"
 
 # Installation prefix of a formula.
-#
-# @api private
 class Keg
-  extend T::Sig
-
   extend Cachable
 
   # Error for when a keg is already linked.
@@ -41,8 +36,6 @@ def initialize(keg, src, dst, cause)
 
   # Error for when a file already exists or belongs to another keg.
   class ConflictError < LinkError
-    extend T::Sig
-
     sig { returns(String) }
     def suggestion
       conflict = Keg.for(dst)
@@ -65,7 +58,7 @@ def to_s
           brew link --overwrite #{keg.name}
 
         To list all files that would be deleted:
-          brew link --overwrite --dry-run #{keg.name}
+          brew link --overwrite #{keg.name} --dry-run
       EOS
       s.join("\n")
     end
@@ -73,8 +66,6 @@ def to_s
 
   # Error for when a directory is not writable.
   class DirectoryNotWritableError < LinkError
-    extend T::Sig
-
     sig { returns(String) }
     def to_s
       <<~EOS
@@ -85,40 +76,8 @@ def to_s
   end
 
   # Locale-specific directories have the form `language[_territory][.codeset][@modifier]`
-  LOCALEDIR_RX = %r{(locale|man)/([a-z]{2}|C|POSIX)(_[A-Z]{2})?(\.[a-zA-Z\-0-9]+(@.+)?)?}.freeze
-  INFOFILE_RX = %r{info/([^.].*?\.info|dir)$}.freeze
-  KEG_LINK_DIRECTORIES = %w[
-    bin etc include lib sbin share var
-  ].freeze
-  MUST_EXIST_SUBDIRECTORIES = (
-    KEG_LINK_DIRECTORIES - %w[var] + %w[
-      opt
-      var/homebrew/linked
-    ]
-  ).map { |dir| HOMEBREW_PREFIX/dir }.sort.uniq.freeze
-
-  # Keep relatively in sync with
-  # {https://github.com/Homebrew/install/blob/HEAD/install.sh}
-  MUST_EXIST_DIRECTORIES = (MUST_EXIST_SUBDIRECTORIES + [
-    HOMEBREW_CELLAR,
-  ].sort.uniq).freeze
-  MUST_BE_WRITABLE_DIRECTORIES = (
-    %w[
-      etc/bash_completion.d lib/pkgconfig
-      share/aclocal share/doc share/info share/locale share/man
-      share/man/man1 share/man/man2 share/man/man3 share/man/man4
-      share/man/man5 share/man/man6 share/man/man7 share/man/man8
-      share/zsh share/zsh/site-functions
-      var/log
-    ].map { |dir| HOMEBREW_PREFIX/dir } + MUST_EXIST_SUBDIRECTORIES + [
-      HOMEBREW_CACHE,
-      HOMEBREW_CELLAR,
-      HOMEBREW_LOCKS,
-      HOMEBREW_LOGS,
-      HOMEBREW_REPOSITORY,
-      Language::Python.homebrew_site_packages,
-    ]
-  ).sort.uniq.freeze
+  LOCALEDIR_RX = %r{(locale|man)/([a-z]{2}|C|POSIX)(_[A-Z]{2})?(\.[a-zA-Z\-0-9]+(@.+)?)?}
+  INFOFILE_RX = %r{info/([^.].*?\.info(\.gz)?|dir)$}
 
   # These paths relative to the keg's share directory should always be real
   # directories in the prefix, never symlinks.
@@ -155,6 +114,51 @@ def self.all
     Formula.racks.flat_map(&:subdirs).map { |d| new(d) }
   end
 
+  def self.keg_link_directories
+    @keg_link_directories ||= %w[
+      bin etc include lib sbin share var
+    ].freeze
+  end
+
+  def self.must_exist_subdirectories
+    @must_exist_subdirectories ||= (
+    keg_link_directories - %w[var] + %w[
+      opt
+      var/homebrew/linked
+    ]
+  ).map { |dir| HOMEBREW_PREFIX/dir }.sort.uniq.freeze
+  end
+
+  # Keep relatively in sync with
+  # {https://github.com/Homebrew/install/blob/HEAD/install.sh}
+  def self.must_exist_directories
+    @must_exist_directories ||= (must_exist_subdirectories + [
+      HOMEBREW_CELLAR,
+    ].sort.uniq).freeze
+  end
+
+  # Keep relatively in sync with
+  # {https://github.com/Homebrew/install/blob/HEAD/install.sh}
+  def self.must_be_writable_directories
+    @must_be_writable_directories ||= (
+    %w[
+      etc/bash_completion.d lib/pkgconfig
+      share/aclocal share/doc share/info share/locale share/man
+      share/man/man1 share/man/man2 share/man/man3 share/man/man4
+      share/man/man5 share/man/man6 share/man/man7 share/man/man8
+      share/zsh share/zsh/site-functions
+      var/log
+    ].map { |dir| HOMEBREW_PREFIX/dir } + must_exist_subdirectories + [
+      HOMEBREW_CACHE,
+      HOMEBREW_CELLAR,
+      HOMEBREW_LOCKS,
+      HOMEBREW_LOGS,
+      HOMEBREW_REPOSITORY,
+      Language::Python.homebrew_site_packages,
+    ]
+  ).sort.uniq.freeze
+  end
+
   attr_reader :path, :name, :linked_keg_record, :opt_record
 
   protected :path
@@ -162,9 +166,10 @@ def self.all
   extend Forwardable
 
   def_delegators :path,
-                 :to_s, :hash, :abv, :disk_usage, :file_count, :directory?, :exist?, :/,
+                 :to_path, :hash, :abv, :disk_usage, :file_count, :directory?, :exist?, :/,
                  :join, :rename, :find
 
+  sig { params(path: Pathname).void }
   def initialize(path)
     path = path.resolved_path if path.to_s.start_with?("#{HOMEBREW_PREFIX}/opt/")
     raise "#{path} is not a valid keg" if path.parent.parent.realpath != HOMEBREW_CELLAR.realpath
@@ -174,6 +179,7 @@ def initialize(path)
     @name = path.parent.basename.to_s
     @linked_keg_record = HOMEBREW_LINKED_KEGS/name
     @opt_record = HOMEBREW_PREFIX/"opt/#{name}"
+    @oldname_opt_records = []
     @require_relocation = false
   end
 
@@ -181,7 +187,8 @@ def rack
     path.parent
   end
 
-  alias to_path to_s
+  sig { returns(String) }
+  def to_s = path.to_s
 
   sig { returns(String) }
   def inspect
@@ -199,6 +206,8 @@ def empty_installation?
       return false if file.directory? && !file.children.reject(&:ds_store?).empty?
 
       basename = file.basename.to_s
+
+      require "metafiles"
       next if Metafiles.copy?(basename)
       next if %w[.DS_Store INSTALL_RECEIPT.json].include?(basename)
 
@@ -272,12 +281,12 @@ def uninstall(raise_failures: false)
       LinkageCacheStore.new(path, db).delete!
     end
 
-    path.rmtree
+    FileUtils.rm_r(path)
     path.parent.rmdir_if_possible
     remove_opt_record if optlinked?
     remove_linked_keg_record if linked?
     remove_old_aliases
-    remove_oldname_opt_record
+    remove_oldname_opt_records
   rescue Errno::EACCES, Errno::ENOTEMPTY
     raise if raise_failures
 
@@ -292,8 +301,8 @@ def unlink(verbose: false, dry_run: false)
 
     dirs = []
 
-    keg_directories = KEG_LINK_DIRECTORIES.map { |d| path/d }
-                                          .select(&:exist?)
+    keg_directories = self.class.keg_link_directories.map { |d| path/d }
+                          .select(&:exist?)
     keg_directories.each do |dir|
       dir.find do |src|
         dst = HOMEBREW_PREFIX + src.relative_path_from(path)
@@ -320,29 +329,31 @@ def unlink(verbose: false, dry_run: false)
     unless dry_run
       remove_old_aliases
       remove_linked_keg_record if linked?
-      dirs.reverse_each(&:rmdir_if_possible)
+      (dirs - self.class.must_exist_subdirectories).reverse_each(&:rmdir_if_possible)
     end
 
     ObserverPathnameExtension.n
   end
 
-  def lock(&block)
+  def lock
     FormulaLock.new(name).with_lock do
-      if oldname_opt_record
-        FormulaLock.new(oldname_opt_record.basename.to_s).with_lock(&block)
-      else
-        yield
+      oldname_locks = oldname_opt_records.map do |record|
+        FormulaLock.new(record.basename.to_s)
       end
+      oldname_locks.each(&:lock)
+      yield
+    ensure
+      oldname_locks&.each(&:unlock)
     end
   end
 
   def completion_installed?(shell)
     dir = case shell
     when :bash then path/"etc/bash_completion.d"
+    when :fish then path/"share/fish/vendor_completions.d"
     when :zsh
       dir = path/"share/zsh/site-functions"
       dir if dir.directory? && dir.children.any? { |f| f.basename.to_s.start_with?("_") }
-    when :fish then path/"share/fish/vendor_completions.d"
     end
     dir&.directory? && !dir.children.empty?
   end
@@ -365,15 +376,6 @@ def plist_installed?
     !Dir["#{path}/*.plist"].empty?
   end
 
-  def python_site_packages_installed?
-    (path/"lib/python2.7/site-packages").directory?
-  end
-
-  sig { returns(T::Boolean) }
-  def python_pth_files_installed?
-    !Dir["#{path}/lib/python2.7/site-packages/*.pth"].empty?
-  end
-
   sig { returns(T::Array[Pathname]) }
   def apps
     app_prefix = optlinked? ? opt_record : path
@@ -391,15 +393,29 @@ def version
     PkgVersion.parse(path.basename.to_s)
   end
 
+  def version_scheme
+    @version_scheme ||= tab.version_scheme
+  end
+
+  # For ordering kegs by version with `.sort_by`, `.max_by`, etc.
+  # @see Formula.version_scheme
+  def scheme_and_version
+    [version_scheme, version]
+  end
+
   def to_formula
     Formulary.from_keg(self)
   end
 
-  def oldname_opt_record
-    @oldname_opt_record ||= if (opt_dir = HOMEBREW_PREFIX/"opt").directory?
-      opt_dir.subdirs.find do |dir|
+  def oldname_opt_records
+    return @oldname_opt_records unless @oldname_opt_records.empty?
+
+    @oldname_opt_records = if (opt_dir = HOMEBREW_PREFIX/"opt").directory?
+      opt_dir.subdirs.select do |dir|
         dir.symlink? && dir != opt_record && path.parent == dir.resolved_path.parent
       end
+    else
+      []
     end
   end
 
@@ -408,16 +424,23 @@ def link(verbose: false, dry_run: false, overwrite: false)
 
     ObserverPathnameExtension.reset_counts!
 
-    optlink(verbose: verbose, dry_run: dry_run, overwrite: overwrite) unless dry_run
+    optlink(verbose:, dry_run:, overwrite:) unless dry_run
 
     # yeah indeed, you have to force anything you need in the main tree into
     # these dirs REMEMBER that *NOT* everything needs to be in the main tree
-    link_dir("etc", verbose: verbose, dry_run: dry_run, overwrite: overwrite) { :mkpath }
-    link_dir("bin", verbose: verbose, dry_run: dry_run, overwrite: overwrite) { :skip_dir }
-    link_dir("sbin", verbose: verbose, dry_run: dry_run, overwrite: overwrite) { :skip_dir }
-    link_dir("include", verbose: verbose, dry_run: dry_run, overwrite: overwrite) { :link }
+    link_dir("etc", verbose:, dry_run:, overwrite:) { :mkpath }
+    link_dir("bin", verbose:, dry_run:, overwrite:) { :skip_dir }
+    link_dir("sbin", verbose:, dry_run:, overwrite:) { :skip_dir }
+    link_dir("include", verbose:, dry_run:, overwrite:) do |relative_path|
+      case relative_path.to_s
+      when /^postgresql@\d+/
+        :mkpath
+      else
+        :link
+      end
+    end
 
-    link_dir("share", verbose: verbose, dry_run: dry_run, overwrite: overwrite) do |relative_path|
+    link_dir("share", verbose:, dry_run:, overwrite:) do |relative_path|
       case relative_path.to_s
       when INFOFILE_RX then :info
       when "locale/locale.alias",
@@ -429,6 +452,7 @@ def link(verbose: false, dry_run: false, overwrite: false)
            /^fish/,
            %r{^lua/}, #  Lua, Lua51, Lua53 all need the same handling.
            %r{^guile/},
+           /^postgresql@\d+/,
            *SHARE_PATHS
         :mkpath
       else
@@ -436,7 +460,7 @@ def link(verbose: false, dry_run: false, overwrite: false)
       end
     end
 
-    link_dir("lib", verbose: verbose, dry_run: dry_run, overwrite: overwrite) do |relative_path|
+    link_dir("lib", verbose:, dry_run:, overwrite:) do |relative_path|
       case relative_path.to_s
       when "charset.alias"
         :skip_file
@@ -452,6 +476,7 @@ def link(verbose: false, dry_run: false, overwrite: false)
            /^ocaml/,
            /^perl5/,
            "php",
+           /^postgresql@\d+/,
            /^python[23]\.\d+/,
            /^R/,
            /^ruby/
@@ -462,7 +487,7 @@ def link(verbose: false, dry_run: false, overwrite: false)
       end
     end
 
-    link_dir("Frameworks", verbose: verbose, dry_run: dry_run, overwrite: overwrite) do |relative_path|
+    link_dir("Frameworks", verbose:, dry_run:, overwrite:) do |relative_path|
       # Frameworks contain symlinks pointing into a subdir, so we have to use
       # the :link strategy. However, for Foo.framework and
       # Foo.framework/Versions we have to use :mkpath so that multiple formulae
@@ -473,25 +498,29 @@ def link(verbose: false, dry_run: false, overwrite: false)
         :link
       end
     end
-    unless dry_run
-      make_relative_symlink(linked_keg_record, path, verbose: verbose, dry_run: dry_run, overwrite: overwrite)
-    end
+    make_relative_symlink(linked_keg_record, path, verbose:, dry_run:, overwrite:) unless dry_run
   rescue LinkError
-    unlink(verbose: verbose)
+    unlink(verbose:)
     raise
   else
     ObserverPathnameExtension.n
   end
 
-  def remove_oldname_opt_record
-    return unless oldname_opt_record
-    return if oldname_opt_record.resolved_path != path
+  def prepare_debug_symbols; end
 
-    @oldname_opt_record.unlink
-    @oldname_opt_record.parent.rmdir_if_possible
-    @oldname_opt_record = nil
+  def consistent_reproducible_symlink_permissions!; end
+
+  def remove_oldname_opt_records
+    oldname_opt_records.reject! do |record|
+      return false if record.resolved_path != path
+
+      record.unlink
+      record.parent.rmdir_if_possible
+      true
+    end
   end
 
+  sig { returns(Tab) }
   def tab
     Tab.for_keg(self)
   end
@@ -507,26 +536,26 @@ def aliases
 
   def optlink(verbose: false, dry_run: false, overwrite: false)
     opt_record.delete if opt_record.symlink? || opt_record.exist?
-    make_relative_symlink(opt_record, path, verbose: verbose, dry_run: dry_run, overwrite: overwrite)
+    make_relative_symlink(opt_record, path, verbose:, dry_run:, overwrite:)
     aliases.each do |a|
       alias_opt_record = opt_record.parent/a
       alias_opt_record.delete if alias_opt_record.symlink? || alias_opt_record.exist?
-      make_relative_symlink(alias_opt_record, path, verbose: verbose, dry_run: dry_run, overwrite: overwrite)
+      make_relative_symlink(alias_opt_record, path, verbose:, dry_run:, overwrite:)
     end
 
-    return unless oldname_opt_record
-
-    oldname_opt_record.delete
-    make_relative_symlink(oldname_opt_record, path, verbose: verbose, dry_run: dry_run, overwrite: overwrite)
+    oldname_opt_records.each do |record|
+      record.delete
+      make_relative_symlink(record, path, verbose:, dry_run:, overwrite:)
+    end
   end
 
   def delete_pyc_files!
-    find { |pn| pn.delete if PYC_EXTENSIONS.include?(pn.extname) }
-    find { |pn| FileUtils.rm_rf pn if pn.basename.to_s == "__pycache__" }
+    path.find { |pn| pn.delete if PYC_EXTENSIONS.include?(pn.extname) }
+    path.find { |pn| FileUtils.rm_rf pn if pn.basename.to_s == "__pycache__" }
   end
 
   def binary_executable_or_library_files
-    elf_files
+    []
   end
 
   def codesign_patched_binary(file); end
@@ -538,8 +567,8 @@ def resolve_any_conflicts(dst, dry_run: false, verbose: false, overwrite: false)
 
     src = dst.resolved_path
 
-    # src itself may be a symlink, so check lstat to ensure we are dealing with
-    # a directory, and not a symlink pointing at a directory (which needs to be
+    # `src` itself may be a symlink, so check lstat to ensure we are dealing with
+    # a directory and not a symlink pointing to a directory (which needs to be
     # treated as a file). In other words, we only want to resolve one symlink.
 
     begin
@@ -636,10 +665,10 @@ def link_dir(relative_dir, verbose: false, dry_run: false, overwrite: false)
         when :info
           next if File.basename(src) == "dir" # skip historical local 'dir' files
 
-          make_relative_symlink dst, src, verbose: verbose, dry_run: dry_run, overwrite: overwrite
+          make_relative_symlink(dst, src, verbose:, dry_run:, overwrite:)
           dst.install_info
         else
-          make_relative_symlink dst, src, verbose: verbose, dry_run: dry_run, overwrite: overwrite
+          make_relative_symlink dst, src, verbose:, dry_run:, overwrite:
         end
       elsif src.directory?
         # if the dst dir already exists, then great! walk the rest of the tree tho
@@ -653,10 +682,10 @@ def link_dir(relative_dir, verbose: false, dry_run: false, overwrite: false)
         when :skip_dir
           Find.prune
         when :mkpath
-          dst.mkpath unless resolve_any_conflicts(dst, verbose: verbose, dry_run: dry_run, overwrite: overwrite)
+          dst.mkpath unless resolve_any_conflicts(dst, verbose:, dry_run:, overwrite:)
         else
-          unless resolve_any_conflicts(dst, verbose: verbose, dry_run: dry_run, overwrite: overwrite)
-            make_relative_symlink dst, src, verbose: verbose, dry_run: dry_run, overwrite: overwrite
+          unless resolve_any_conflicts(dst, verbose:, dry_run:, overwrite:)
+            make_relative_symlink(dst, src, verbose:, dry_run:, overwrite:)
             Find.prune
           end
         end
diff --git a/Library/Homebrew/keg.rbi b/Library/Homebrew/keg.rbi
new file mode 100644
index 0000000000000..6305c81715350
--- /dev/null
+++ b/Library/Homebrew/keg.rbi
@@ -0,0 +1,6 @@
+# typed: strict
+
+class Keg
+  # This is only true under MacOS, so can lead to true negative type errors
+  include OS::Mac::Keg
+end
diff --git a/Library/Homebrew/keg_relocate.rb b/Library/Homebrew/keg_relocate.rb
index 1df8ee86a4893..5ae085f7699e6 100644
--- a/Library/Homebrew/keg_relocate.rb
+++ b/Library/Homebrew/keg_relocate.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 class Keg
@@ -12,12 +12,10 @@ class Keg
   NULL_BYTE_STRING = "\\x00"
 
   class Relocation
-    extend T::Sig
-
-    RELOCATABLE_PATH_REGEX_PREFIX = /(?:(?<=-F|-I|-L|-isystem)|(?<![a-zA-Z0-9]))/.freeze
+    RELOCATABLE_PATH_REGEX_PREFIX = /(?:(?<=-F|-I|-L|-isystem)|(?<![a-zA-Z0-9]))/
 
     def initialize
-      @replacement_map = {}
+      @replacement_map = T.let({}, T::Hash[Symbol, [T.any(String, Regexp), String]])
     end
 
     def freeze
@@ -31,12 +29,12 @@ def add_replacement_pair(key, old_value, new_value, path: false)
       @replacement_map[key] = [old_value, new_value]
     end
 
-    sig { params(key: Symbol).returns(T::Array[T.any(String, Regexp)]) }
+    sig { params(key: Symbol).returns([T.any(String, Regexp), String]) }
     def replacement_pair_for(key)
       @replacement_map.fetch(key)
     end
 
-    sig { params(text: String).void }
+    sig { params(text: String).returns(T::Boolean) }
     def replace_text(text)
       replacements = @replacement_map.values.to_h
 
@@ -44,12 +42,12 @@ def replace_text(text)
         key.is_a?(String) ? key.length : 999
       end.reverse
 
-      any_changed = false
+      any_changed = T.let(nil, T.nilable(String))
       sorted_keys.each do |key|
-        changed = text.gsub!(key, replacements[key])
+        changed = text.gsub!(key, replacements.fetch(key))
         any_changed ||= changed
       end
-      any_changed
+      !any_changed.nil?
     end
 
     sig { params(path: T.any(String, Regexp)).returns(Regexp) }
@@ -85,7 +83,7 @@ def relocate_dynamic_linkage(_relocation)
     []
   end
 
-  JAVA_REGEX = %r{#{HOMEBREW_PREFIX}/opt/openjdk(@\d+(\.\d+)*)?/libexec(/openjdk\.jdk/Contents/Home)?}.freeze
+  JAVA_REGEX = %r{#{HOMEBREW_PREFIX}/opt/openjdk(@\d+(\.\d+)*)?/libexec(/openjdk\.jdk/Contents/Home)?}
 
   def prepare_relocation_to_placeholders
     relocation = Relocation.new
@@ -98,7 +96,7 @@ def prepare_relocation_to_placeholders
     end
     relocation.add_replacement_pair(:library, HOMEBREW_LIBRARY.to_s, LIBRARY_PLACEHOLDER, path: true)
     relocation.add_replacement_pair(:perl,
-                                    %r{\A#!(?:/usr/bin/perl\d\.\d+|#{HOMEBREW_PREFIX}/opt/perl/bin/perl)( |$)}o,
+                                    %r{\A#![ \t]*(?:/usr/bin/perl\d\.\d+|#{HOMEBREW_PREFIX}/opt/perl/bin/perl)( |$)}o,
                                     "#!#{PERL_PLACEHOLDER}\\1")
     relocation.add_replacement_pair(:java, JAVA_REGEX, JAVA_PLACEHOLDER)
 
@@ -130,7 +128,7 @@ def prepare_relocation_to_locations
   def replace_placeholders_with_locations(files, skip_linkage: false)
     relocation = prepare_relocation_to_locations.freeze
     relocate_dynamic_linkage(relocation) unless skip_linkage
-    replace_text_in_files(relocation, files: files)
+    replace_text_in_files(relocation, files:)
   end
 
   def openjdk_dep_name_if_applicable
@@ -144,8 +142,8 @@ def openjdk_dep_name_if_applicable
   def replace_text_in_files(relocation, files: nil)
     files ||= text_files | libtool_files
 
-    changed_files = []
-    files.map(&path.method(:join)).group_by { |f| f.stat.ino }.each_value do |first, *rest|
+    changed_files = T.let([], Array)
+    files.map { path.join(_1) }.group_by { |f| f.stat.ino }.each_value do |first, *rest|
       s = first.open("rb", &:read)
 
       next unless relocation.replace_text(s)
@@ -179,11 +177,11 @@ def relocate_build_prefix(keg, old_prefix, new_prefix)
         binary = File.binread file
         odebug "Replacing build prefix in: #{file}"
         binary_strings = binary.split(/#{NULL_BYTE}/o, -1)
-        match_indices = binary_strings.each_index.select { |i| binary_strings[i].include?(old_prefix) }
+        match_indices = binary_strings.each_index.select { |i| binary_strings.fetch(i).include?(old_prefix) }
 
         # Only perform substitution on strings which match prefix regex.
         match_indices.each do |i|
-          s = binary_strings[i]
+          s = binary_strings.fetch(i)
           binary_strings[i] = s.gsub(old_prefix, new_prefix)
                                .ljust(s.size, NULL_BYTE)
         end
@@ -212,7 +210,6 @@ def recursive_fgrep_args
     # for GNU grep; overridden for BSD grep on OS X
     "-lr"
   end
-  alias generic_recursive_fgrep_args recursive_fgrep_args
 
   def egrep_args
     grep_bin = "grep"
@@ -273,6 +270,8 @@ def text_files
         next true if pn.directory?
         next false if pn.basename.to_s == "orig-prefix.txt" # for python virtualenvs
         next true if pn == self/".brew/#{name}.rb"
+
+        require "metafiles"
         next true if Metafiles::EXTENSIONS.include?(pn.extname)
 
         if pn.text_executable?
@@ -330,7 +329,7 @@ def self.text_matches_in_file(file, string, ignores, linked_libraries, formula_a
     Utils.popen_read("strings", "-t", "x", "-", file.to_s) do |io|
       until io.eof?
         str = io.readline.chomp
-        next if ignores.any? { |i| i =~ str }
+        next if ignores.any? { |i| str.match?(i) }
         next unless str.match? path_regex
 
         offset, match = str.split(" ", 2)
@@ -366,10 +365,6 @@ def self.text_matches_in_file(file, string, ignores, linked_libraries, formula_a
   def self.file_linked_libraries(_file, _string)
     []
   end
-
-  def self.bottle_dependencies
-    []
-  end
 end
 
 require "extend/os/keg_relocate"
diff --git a/Library/Homebrew/language/go.rb b/Library/Homebrew/language/go.rb
index 90bd711dd9cc1..2dc65920e5de4 100644
--- a/Library/Homebrew/language/go.rb
+++ b/Library/Homebrew/language/go.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "resource"
@@ -12,7 +12,9 @@ module Go
     # building Go software.
     # The resource names should be the import name of the package,
     # e.g. `resource "github.com/foo/bar"`.
+    sig { params(resources: T::Array[Resource], target: T.any(String, Pathname)).void }
     def self.stage_deps(resources, target)
+      odisabled "`Language::Go.stage_deps`", "Go modules"
       if resources.empty?
         if Homebrew::EnvConfig.developer?
           odie "Tried to stage empty Language::Go resources array"
diff --git a/Library/Homebrew/language/java.rb b/Library/Homebrew/language/java.rb
index c7ffdffd7c153..c89cbe7334b07 100644
--- a/Library/Homebrew/language/java.rb
+++ b/Library/Homebrew/language/java.rb
@@ -6,8 +6,6 @@ module Language
   #
   # @api public
   module Java
-    extend T::Sig
-
     sig { params(version: T.nilable(String)).returns(T.nilable(Formula)) }
     def self.find_openjdk_formula(version = nil)
       can_be_newer = version&.end_with?("+")
@@ -30,6 +28,13 @@ def self.find_openjdk_formula(version = nil)
     end
     private_class_method :find_openjdk_formula
 
+    # Returns the directory of the newest matching OpenJDK installation or
+    # `nil` if none is available. When used in a {Formula}, there should be
+    # a dependency and corresponding `version` for reproducible output.
+    #
+    # @api public
+    # @param version OpenJDK version constraint which can be specific
+    #   (e.g. `"21"`) or a lower-bounded range (e.g. `"21+"`)
     sig { params(version: T.nilable(String)).returns(T.nilable(Pathname)) }
     def self.java_home(version = nil)
       find_openjdk_formula(version)&.opt_libexec
@@ -41,11 +46,36 @@ def self.java_home_shell(version = nil)
     end
     private_class_method :java_home_shell
 
+    # Returns a `JAVA_HOME` environment variable to use a specific OpenJDK.
+    # Usually combined with either {Pathname#write_env_script} or
+    # {Pathname#env_script_all_files}.
+    #
+    # ### Example
+    #
+    # Use `openjdk@21` for all commands:
+    #
+    # ```ruby
+    # bin.env_script_all_files libexec/"bin", Language::Java.java_home_env("21")
+    # ```
+    #
+    # @api public
     sig { params(version: T.nilable(String)).returns({ JAVA_HOME: String }) }
     def self.java_home_env(version = nil)
       { JAVA_HOME: java_home_shell(version) }
     end
 
+    # Returns a `JAVA_HOME` environment variable to use a default OpenJDK.
+    # Unlike {.java_home_env} the OpenJDK can be overridden at runtime.
+    #
+    # ### Example
+    #
+    # Use latest `openjdk` as default:
+    #
+    # ```ruby
+    # bin.env_script_all_files libexec/"bin", Language::Java.overridable_java_home_env
+    # ```
+    #
+    # @api public
     sig { params(version: T.nilable(String)).returns({ JAVA_HOME: String }) }
     def self.overridable_java_home_env(version = nil)
       { JAVA_HOME: "${JAVA_HOME:-#{java_home_shell(version)}}" }
diff --git a/Library/Homebrew/language/node.rb b/Library/Homebrew/language/node.rb
index 4421b0f9e88ac..de08fffd4aecd 100644
--- a/Library/Homebrew/language/node.rb
+++ b/Library/Homebrew/language/node.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Language
@@ -6,20 +6,20 @@ module Language
   #
   # @api public
   module Node
-    extend T::Sig
-
     sig { returns(String) }
     def self.npm_cache_config
       "cache=#{HOMEBREW_CACHE}/npm_cache"
     end
 
+    sig { returns(String) }
     def self.pack_for_installation
       # Homebrew assumes the buildpath/testpath will always be disposable
       # and from npm 5.0.0 the logic changed so that when a directory is
       # fed to `npm install` only symlinks are created linking back to that
       # directory, consequently breaking that assumption. We require a tarball
       # because npm install creates a "real" installation when fed a tarball.
-      if (package = Pathname("package.json")) && package.exist?
+      package = Pathname("package.json")
+      if package.exist?
         begin
           pkg_json = JSON.parse(package.read)
         rescue JSON::ParserError
@@ -37,11 +37,12 @@ def self.pack_for_installation
       output.lines.last.chomp
     end
 
+    sig { void }
     def self.setup_npm_environment
       # guard that this is only run once
       return if @env_set
 
-      @env_set = true
+      @env_set = T.let(true, T.nilable(T::Boolean))
       # explicitly use our npm and node-gyp executables instead of the user
       # managed ones in HOMEBREW_PREFIX/lib/node_modules which might be broken
       begin
@@ -51,11 +52,9 @@ def self.setup_npm_environment
       end
     end
 
+    sig { params(libexec: Pathname).returns(T::Array[String]) }
     def self.std_npm_install_args(libexec)
       setup_npm_environment
-      # tell npm to not install .brew_home by adding it to the .npmignore file
-      # (or creating a new one if no .npmignore file already exists)
-      open(".npmignore", "a") { |f| f.write("\n.brew_home\n") }
 
       pack = pack_for_installation
 
@@ -87,5 +86,39 @@ def self.local_npm_install_args
         --#{npm_cache_config}
       ]
     end
+
+    # Mixin module for {Formula} adding shebang rewrite features.
+    module Shebang
+      extend T::Helpers
+
+      requires_ancestor { Formula }
+
+      module_function
+
+      # A regex to match potential shebang permutations.
+      NODE_SHEBANG_REGEX = %r{^#! ?/usr/bin/(?:env )?node( |$)}
+
+      # The length of the longest shebang matching `SHEBANG_REGEX`.
+      NODE_SHEBANG_MAX_LENGTH = T.let("#! /usr/bin/env node ".length, Integer)
+
+      # @private
+      sig { params(node_path: T.any(String, Pathname)).returns(Utils::Shebang::RewriteInfo) }
+      def node_shebang_rewrite_info(node_path)
+        Utils::Shebang::RewriteInfo.new(
+          NODE_SHEBANG_REGEX,
+          NODE_SHEBANG_MAX_LENGTH,
+          "#{node_path}\\1",
+        )
+      end
+
+      sig { params(formula: Formula).returns(Utils::Shebang::RewriteInfo) }
+      def detected_node_shebang(formula = T.cast(self, Formula))
+        node_deps = formula.deps.select(&:required?).map(&:name).grep(/^node(@.+)?$/)
+        raise ShebangDetectionError.new("Node", "formula does not depend on Node") if node_deps.empty?
+        raise ShebangDetectionError.new("Node", "formula has multiple Node dependencies") if node_deps.length > 1
+
+        node_shebang_rewrite_info(Formula[node_deps.first].opt_bin/"node")
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/language/perl.rb b/Library/Homebrew/language/perl.rb
index f4822239add02..4c08aef894b9b 100644
--- a/Library/Homebrew/language/perl.rb
+++ b/Library/Homebrew/language/perl.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Language
@@ -8,23 +8,41 @@ module Language
   module Perl
     # Helper module for replacing `perl` shebangs.
     module Shebang
+      extend T::Helpers
+
+      requires_ancestor { Formula }
+
       module_function
 
-      def detected_perl_shebang(formula = self)
-        perl_path = if formula.deps.map(&:name).include? "perl"
-          Formula["perl"].opt_bin/"perl"
-        elsif formula.uses_from_macos_names.include? "perl"
-          "/usr/bin/perl#{MacOS.preferred_perl_version}"
-        else
-          raise ShebangDetectionError.new("Perl", "formula does not depend on Perl")
-        end
+      # A regex to match potential shebang permutations.
+      PERL_SHEBANG_REGEX = %r{^#! ?/usr/bin/(?:env )?perl( |$)}
 
+      # The length of the longest shebang matching `SHEBANG_REGEX`.
+      PERL_SHEBANG_MAX_LENGTH = T.let("#! /usr/bin/env perl ".length, Integer)
+
+      # @private
+      sig { params(perl_path: T.any(String, Pathname)).returns(Utils::Shebang::RewriteInfo) }
+      def perl_shebang_rewrite_info(perl_path)
         Utils::Shebang::RewriteInfo.new(
-          %r{^#! ?/usr/bin/(?:env )?perl( |$)},
-          21, # the length of "#! /usr/bin/env perl "
+          PERL_SHEBANG_REGEX,
+          PERL_SHEBANG_MAX_LENGTH,
           "#{perl_path}\\1",
         )
       end
+
+      sig { params(formula: Formula).returns(Utils::Shebang::RewriteInfo) }
+      def detected_perl_shebang(formula = T.cast(self, Formula))
+        perl_deps = formula.declared_deps.select { |dep| dep.required? && dep.name == "perl" }
+        raise ShebangDetectionError.new("Perl", "formula does not depend on Perl") if perl_deps.empty?
+
+        perl_path = if perl_deps.any? { |dep| !dep.uses_from_macos? || !dep.use_macos_install? }
+          Formula["perl"].opt_bin/"perl"
+        else
+          "/usr/bin/perl#{MacOS.preferred_perl_version}"
+        end
+
+        perl_shebang_rewrite_info(perl_path)
+      end
     end
   end
 end
diff --git a/Library/Homebrew/language/perl.rbi b/Library/Homebrew/language/perl.rbi
deleted file mode 100644
index 9be98f1896413..0000000000000
--- a/Library/Homebrew/language/perl.rbi
+++ /dev/null
@@ -1,9 +0,0 @@
-# typed: strict
-
-module Language
-  module Perl
-    module Shebang
-      include Kernel
-    end
-  end
-end
diff --git a/Library/Homebrew/language/python.rb b/Library/Homebrew/language/python.rb
index 958dbc248774c..e0244f4d1ff1e 100644
--- a/Library/Homebrew/language/python.rb
+++ b/Library/Homebrew/language/python.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 module Language
@@ -6,17 +6,20 @@ module Language
   #
   # @api public
   module Python
+    sig { params(python: T.any(String, Pathname)).returns(T.nilable(Version)) }
     def self.major_minor_version(python)
-      version = /\d\.\d+/.match `#{python} --version 2>&1`
+      version = `#{python} --version 2>&1`.chomp[/(\d\.\d+)/, 1]
       return unless version
 
-      Version.create(version.to_s)
+      Version.new(version)
     end
 
+    sig { params(python: T.any(String, Pathname)).returns(Pathname) }
     def self.homebrew_site_packages(python = "python3.7")
       HOMEBREW_PREFIX/site_packages(python)
     end
 
+    sig { params(python: T.any(String, Pathname)).returns(String) }
     def self.site_packages(python = "python3.7")
       if (python == "pypy") || (python == "pypy3")
         "site-packages"
@@ -25,6 +28,12 @@ def self.site_packages(python = "python3.7")
       end
     end
 
+    sig {
+      params(
+        build: T.any(BuildOptions, Tab),
+        block: T.nilable(T.proc.params(python: String, version: T.nilable(Version)).void),
+      ).void
+    }
     def self.each_python(build, &block)
       original_pythonpath = ENV.fetch("PYTHONPATH", nil)
       pythons = { "python@3" => "python3",
@@ -38,16 +47,17 @@ def self.each_python(build, &block)
         ENV["PYTHONPATH"] = if python_formula.latest_version_installed?
           nil
         else
-          homebrew_site_packages(python)
+          homebrew_site_packages(python).to_s
         end
         block&.call python, version
       end
       ENV["PYTHONPATH"] = original_pythonpath
     end
 
+    sig { params(python: T.any(String, Pathname)).returns(T::Boolean) }
     def self.reads_brewed_pth_files?(python)
-      return unless homebrew_site_packages(python).directory?
-      return unless homebrew_site_packages(python).writable_real?
+      return false unless homebrew_site_packages(python).directory?
+      return false unless homebrew_site_packages(python).writable?
 
       probe_file = homebrew_site_packages(python)/"homebrew-pth-probe.pth"
       begin
@@ -58,10 +68,12 @@ def self.reads_brewed_pth_files?(python)
       end
     end
 
+    sig { params(python: T.any(String, Pathname)).returns(Pathname) }
     def self.user_site_packages(python)
       Pathname.new(`#{python} -c "import site; print(site.getusersitepackages())"`.chomp)
     end
 
+    sig { params(python: T.any(String, Pathname), path: T.any(String, Pathname)).returns(T::Boolean) }
     def self.in_sys_path?(python, path)
       script = <<~PYTHON
         import os, sys
@@ -70,6 +82,7 @@ def self.in_sys_path?(python, path)
       quiet_system python, "-c", script
     end
 
+    sig { params(prefix: Pathname, python: T.any(String, Pathname)).returns(T::Array[String]) }
     def self.setup_install_args(prefix, python = "python3")
       shim = <<~PYTHON
         import setuptools, tokenize
@@ -92,76 +105,116 @@ def self.setup_install_args(prefix, python = "python3")
 
     # Mixin module for {Formula} adding shebang rewrite features.
     module Shebang
+      extend T::Helpers
+
+      requires_ancestor { Formula }
+
       module_function
 
+      # A regex to match potential shebang permutations.
+      PYTHON_SHEBANG_REGEX = %r{^#! ?/usr/bin/(?:env )?python(?:[23](?:\.\d{1,2})?)?( |$)}
+
+      # The length of the longest shebang matching `SHEBANG_REGEX`.
+      PYTHON_SHEBANG_MAX_LENGTH = T.let("#! /usr/bin/env pythonx.yyy ".length, Integer)
+
       # @private
+      sig { params(python_path: T.any(String, Pathname)).returns(Utils::Shebang::RewriteInfo) }
       def python_shebang_rewrite_info(python_path)
         Utils::Shebang::RewriteInfo.new(
-          %r{^#! ?/usr/bin/(?:env )?python(?:[23](?:\.\d{1,2})?)?( |$)},
-          28, # the length of "#! /usr/bin/env pythonx.yyy "
+          PYTHON_SHEBANG_REGEX,
+          PYTHON_SHEBANG_MAX_LENGTH,
           "#{python_path}\\1",
         )
       end
 
-      def detected_python_shebang(formula = self)
-        python_deps = formula.deps.map(&:name).grep(/^python(@.*)?$/)
+      sig { params(formula: Formula, use_python_from_path: T::Boolean).returns(Utils::Shebang::RewriteInfo) }
+      def detected_python_shebang(formula = T.cast(self, Formula), use_python_from_path: false)
+        python_path = if use_python_from_path
+          "/usr/bin/env python3"
+        else
+          python_deps = formula.deps.select(&:required?).map(&:name).grep(/^python(@.+)?$/)
+          raise ShebangDetectionError.new("Python", "formula does not depend on Python") if python_deps.empty?
+          if python_deps.length > 1
+            raise ShebangDetectionError.new("Python", "formula has multiple Python dependencies")
+          end
 
-        raise ShebangDetectionError.new("Python", "formula does not depend on Python") if python_deps.empty?
-        if python_deps.length > 1
-          raise ShebangDetectionError.new("Python", "formula has multiple Python dependencies")
+          python_dep = python_deps.first
+          Formula[python_dep].opt_bin/python_dep.sub("@", "")
         end
 
-        python_shebang_rewrite_info(Formula[python_deps.first].opt_bin/"python3")
+        python_shebang_rewrite_info(python_path)
       end
     end
 
     # Mixin module for {Formula} adding virtualenv support features.
     module Virtualenv
-      extend T::Sig
+      extend T::Helpers
 
-      # Instantiates, creates, and yields a {Virtualenv} object for use from
+      requires_ancestor { Formula }
+
+      # Instantiates, creates and yields a {Virtualenv} object for use from
       # {Formula#install}, which provides helper methods for instantiating and
       # installing packages into a Python virtualenv.
       #
       # @param venv_root [Pathname, String] the path to the root of the virtualenv
       #   (often `libexec/"venv"`)
-      # @param python [String] which interpreter to use (e.g. "python3"
-      #   or "python3.x")
+      # @param python [String, Pathname] which interpreter to use (e.g. `"python3"`
+      #   or `"python3.x"`)
       # @param formula [Formula] the active {Formula}
       # @return [Virtualenv] a {Virtualenv} instance
-      def virtualenv_create(venv_root, python = "python", formula = self, system_site_packages: true)
+      sig {
+        params(
+          venv_root:            T.any(String, Pathname),
+          python:               T.any(String, Pathname),
+          formula:              Formula,
+          system_site_packages: T::Boolean,
+          without_pip:          T::Boolean,
+        ).returns(Virtualenv)
+      }
+      def virtualenv_create(venv_root, python = "python", formula = T.cast(self, Formula),
+                            system_site_packages: true, without_pip: true)
+        # Limit deprecation to 3.12+ for now (or if we can't determine the version).
+        # Some used this argument for `setuptools`, which we no longer bundle since 3.12.
+        unless without_pip
+          python_version = Language::Python.major_minor_version(python)
+          if python_version.nil? || python_version.null? || python_version >= "3.12"
+            raise ArgumentError, "virtualenv_create's without_pip is deprecated starting with Python 3.12"
+          end
+        end
+
         ENV.refurbish_args
         venv = Virtualenv.new formula, venv_root, python
-        venv.create(system_site_packages: system_site_packages)
+        venv.create(system_site_packages:, without_pip:)
 
         # Find any Python bindings provided by recursive dependencies
-        formula_deps = formula.recursive_dependencies
-        pth_contents = formula_deps.map do |d|
-          next if d.build? || d.test?
+        pth_contents = []
+        formula.recursive_dependencies do |dependent, dep|
+          Dependency.prune if dep.build? || dep.test?
+          # Apply default filter
+          Dependency.prune if (dep.optional? || dep.recommended?) && !dependent.build.with?(dep)
           # Do not add the main site-package provided by the brewed
           # Python formula, to keep the virtual-env's site-package pristine
-          next if python_names.include? d.name
+          Dependency.prune if python_names.include? dep.name
+          # Skip uses_from_macos dependencies as these imply no Python bindings
+          Dependency.prune if dep.uses_from_macos?
 
-          dep_site_packages = Formula[d.name].opt_prefix/Language::Python.site_packages(python)
-          next unless dep_site_packages.exist?
+          dep_site_packages = dep.to_formula.opt_prefix/Language::Python.site_packages(python)
+          Dependency.prune unless dep_site_packages.exist?
 
-          "import site; site.addsitedir('#{dep_site_packages}')\n"
-        end.compact
-        unless pth_contents.empty?
-          (venv_root/Language::Python.site_packages(python)/"homebrew_deps.pth").write pth_contents.join
+          pth_contents << "import site; site.addsitedir('#{dep_site_packages}')\n"
         end
+        (venv.site_packages/"homebrew_deps.pth").write pth_contents.join unless pth_contents.empty?
 
         venv
       end
 
       # Returns true if a formula option for the specified python is currently
       # active or if the specified python is required by the formula. Valid
-      # inputs are "python", "python2", and :python3. Note that
-      # "with-python", "without-python", "with-python@2", and "without-python@2"
+      # inputs are `"python"`, `"python2"` and `:python3`. Note that
+      # `"with-python"`, `"without-python"`, `"with-python@2"` and `"without-python@2"`
       # formula options are handled correctly even if not associated with any
       # corresponding depends_on statement.
-      #
-      # @api private
+      sig { params(python: String).returns(T::Boolean) }
       def needs_python?(python)
         return true if build.with?(python)
 
@@ -170,24 +223,50 @@ def needs_python?(python)
 
       # Helper method for the common case of installing a Python application.
       # Creates a virtualenv in `libexec`, installs all `resource`s defined
-      # on the formula, and then installs the formula. An options hash may be
+      # on the formula and then installs the formula. An options hash may be
       # passed (e.g. `:using => "python"`) to override the default, guessed
       # formula preference for python or python@x.y, or to resolve an ambiguous
       # case where it's not clear whether python or python@x.y should be the
       # default guess.
-      def virtualenv_install_with_resources(using: nil, system_site_packages: true)
+      sig {
+        params(
+          using:                T.nilable(String),
+          system_site_packages: T::Boolean,
+          without_pip:          T::Boolean,
+          link_manpages:        T::Boolean,
+          without:              T.nilable(T.any(String, T::Array[String])),
+          start_with:           T.nilable(T.any(String, T::Array[String])),
+          end_with:             T.nilable(T.any(String, T::Array[String])),
+        ).returns(Virtualenv)
+      }
+      def virtualenv_install_with_resources(using: nil, system_site_packages: true, without_pip: true,
+                                            link_manpages: false, without: nil, start_with: nil, end_with: nil)
         python = using
         if python.nil?
           wanted = python_names.select { |py| needs_python?(py) }
           raise FormulaUnknownPythonError, self if wanted.empty?
           raise FormulaAmbiguousPythonError, self if wanted.size > 1
 
-          python = wanted.first
+          python = T.must(wanted.first)
           python = "python3" if python == "python"
         end
-        venv = virtualenv_create(libexec, python.delete("@"), system_site_packages: system_site_packages)
-        venv.pip_install resources
-        venv.pip_install_and_link buildpath
+
+        venv_resources = if without.nil? && start_with.nil? && end_with.nil?
+          resources
+        else
+          remaining_resources = resources.to_h { |resource| [resource.name, resource] }
+
+          slice_resources!(remaining_resources, Array(without))
+          start_with_resources = slice_resources!(remaining_resources, Array(start_with))
+          end_with_resources = slice_resources!(remaining_resources, Array(end_with))
+
+          start_with_resources + remaining_resources.values + end_with_resources
+        end
+
+        venv = virtualenv_create(libexec, python.delete("@"), system_site_packages:,
+                                                              without_pip:)
+        venv.pip_install venv_resources
+        venv.pip_install_and_link(T.must(buildpath), link_manpages:)
         venv
       end
 
@@ -196,6 +275,22 @@ def python_names
         %w[python python3 pypy pypy3] + Formula.names.select { |name| name.start_with? "python@" }
       end
 
+      private
+
+      sig {
+        params(
+          resources_hash: T::Hash[String, Resource],
+          resource_names: T::Array[String],
+        ).returns(T::Array[Resource])
+      }
+      def slice_resources!(resources_hash, resource_names)
+        resource_names.map do |resource_name|
+          resources_hash.delete(resource_name) do
+            raise ArgumentError, "Resource \"#{resource_name}\" is not defined in formula or is already used"
+          end
+        end
+      end
+
       # Convenience wrapper for creating and installing packages into Python
       # virtualenvs.
       class Virtualenv
@@ -205,29 +300,43 @@ class Virtualenv
         # @param formula [Formula] the active {Formula}
         # @param venv_root [Pathname, String] the path to the root of the
         #   virtualenv
-        # @param python [String] which interpreter to use, e.g. "python" or
-        #   "python2"
+        # @param python [String, Pathname] which interpreter to use, e.g.
+        #   "python" or "python2"
+        sig { params(formula: Formula, venv_root: T.any(String, Pathname), python: T.any(String, Pathname)).void }
         def initialize(formula, venv_root, python)
           @formula = formula
-          @venv_root = Pathname.new(venv_root)
+          @venv_root = T.let(Pathname(venv_root), Pathname)
           @python = python
         end
 
+        sig { returns(Pathname) }
+        def root
+          @venv_root
+        end
+
+        sig { returns(Pathname) }
+        def site_packages
+          @venv_root/Language::Python.site_packages(@python)
+        end
+
         # Obtains a copy of the virtualenv library and creates a new virtualenv on disk.
         #
         # @return [void]
-        def create(system_site_packages: true)
+        sig { params(system_site_packages: T::Boolean, without_pip: T::Boolean).void }
+        def create(system_site_packages: true, without_pip: true)
           return if (@venv_root/"bin/python").exist?
 
           args = ["-m", "venv"]
           args << "--system-site-packages" if system_site_packages
+          args << "--without-pip" if without_pip
           @formula.system @python, *args, @venv_root
 
           # Robustify symlinks to survive python patch upgrades
           @venv_root.find do |f|
             next unless f.symlink?
-            next unless (rp = f.realpath.to_s).start_with? HOMEBREW_CELLAR
+            next unless f.readlink.expand_path.to_s.start_with? HOMEBREW_CELLAR
 
+            rp = f.realpath.to_s
             version = rp.match %r{^#{HOMEBREW_CELLAR}/python@(.*?)/}o
             version = "@#{version.captures.first}" unless version.nil?
 
@@ -245,6 +354,21 @@ def create(system_site_packages: true)
             prefix_path.sub! %r{^#{HOMEBREW_CELLAR}/python#{version}/[^/]+}, Formula["python#{version}"].opt_prefix
             prefix_file.atomic_write prefix_path
           end
+
+          # Reduce some differences between macOS and Linux venv
+          lib64 = @venv_root/"lib64"
+          lib64.make_symlink "lib" unless lib64.exist?
+          if (cfg_file = @venv_root/"pyvenv.cfg").exist?
+            cfg = cfg_file.read
+            framework = "Frameworks/Python.framework/Versions"
+            cfg.match(%r{= *(#{HOMEBREW_CELLAR}/(python@[\d.]+)/[^/]+(?:/#{framework}/[\d.]+)?/bin)}) do |match|
+              cfg.sub! match[1].to_s, Formula[match[2]].opt_bin
+              cfg_file.atomic_write cfg
+            end
+          end
+
+          # Remove unnecessary activate scripts
+          (@venv_root/"bin").glob("[Aa]ctivate*").map(&:unlink)
         end
 
         # Installs packages represented by `targets` into the virtualenv.
@@ -257,14 +381,24 @@ def create(system_site_packages: true)
         #   Multiline strings are allowed and treated as though they represent
         #   the contents of a `requirements.txt`.
         # @return [void]
-        def pip_install(targets)
+        sig {
+          params(
+            targets:         T.any(String, Pathname, Resource, T::Array[T.any(String, Pathname, Resource)]),
+            build_isolation: T::Boolean,
+          ).void
+        }
+        def pip_install(targets, build_isolation: true)
           targets = Array(targets)
           targets.each do |t|
-            if t.respond_to? :stage
-              t.stage { do_install Pathname.pwd }
+            if t.is_a?(Resource)
+              t.stage do
+                target = Pathname.pwd
+                target /= t.downloader.basename if t.url&.end_with?("-none-any.whl")
+                do_install(target, build_isolation:)
+              end
             else
-              t = t.lines.map(&:strip) if t.respond_to?(:lines) && t.include?("\n")
-              do_install t
+              t = t.lines.map(&:strip) if t.is_a?(String) && t.include?("\n")
+              do_install(t, build_isolation:)
             end
           end
         end
@@ -274,23 +408,43 @@ def pip_install(targets)
         #
         # @param (see #pip_install)
         # @return (see #pip_install)
-        def pip_install_and_link(targets)
+        sig {
+          params(
+            targets:         T.any(String, Pathname, Resource, T::Array[T.any(String, Pathname, Resource)]),
+            link_manpages:   T::Boolean,
+            build_isolation: T::Boolean,
+          ).void
+        }
+        def pip_install_and_link(targets, link_manpages: false, build_isolation: true)
           bin_before = Dir[@venv_root/"bin/*"].to_set
+          man_before = Dir[@venv_root/"share/man/man*/*"].to_set if link_manpages
 
-          pip_install(targets)
+          pip_install(targets, build_isolation:)
 
           bin_after = Dir[@venv_root/"bin/*"].to_set
           bin_to_link = (bin_after - bin_before).to_a
           @formula.bin.install_symlink(bin_to_link)
+          return unless link_manpages
+
+          man_after = Dir[@venv_root/"share/man/man*/*"].to_set
+          man_to_link = (man_after - man_before).to_a
+          man_to_link.each do |manpage|
+            (@formula.man/Pathname.new(manpage).dirname.basename).install_symlink manpage
+          end
         end
 
         private
 
-        def do_install(targets)
+        sig {
+          params(
+            targets:         T.any(String, Pathname, T::Array[T.any(String, Pathname)]),
+            build_isolation: T::Boolean,
+          ).void
+        }
+        def do_install(targets, build_isolation: true)
           targets = Array(targets)
-          @formula.system @venv_root/"bin/pip", "install",
-                          "-v", "--no-deps", "--no-binary", ":all:",
-                          "--ignore-installed", *targets
+          args = @formula.std_pip_args(prefix: false, build_isolation:)
+          @formula.system @python, "-m", "pip", "--python=#{@venv_root}/bin/python", "install", *args, *targets
         end
       end
     end
diff --git a/Library/Homebrew/lazy_object.rb b/Library/Homebrew/lazy_object.rb
index 550c6963873f3..9f755d9faa13b 100644
--- a/Library/Homebrew/lazy_object.rb
+++ b/Library/Homebrew/lazy_object.rb
@@ -1,26 +1,35 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "delegate"
+
 # An object which lazily evaluates its inner block only once a method is called on it.
-#
-# @api private
 class LazyObject < Delegator
   def initialize(&callable)
     super(callable)
   end
 
   def __getobj__
+    # rubocop:disable Naming/MemoizedInstanceVariableName
     return @__delegate__ if defined?(@__delegate__)
 
     @__delegate__ = @__callable__.call
+    # rubocop:enable Naming/MemoizedInstanceVariableName
   end
+  private :__getobj__
 
   def __setobj__(callable)
     @__callable__ = callable
   end
+  private :__setobj__
 
   # Forward to the inner object to make lazy objects type-checkable.
+  #
+  # @!visibility private
   def is_a?(klass)
+    # see https://sorbet.org/docs/faq#how-can-i-fix-type-errors-that-arise-from-super
+    T.bind(self, T.untyped)
+
     __getobj__.is_a?(klass) || super
   end
 end
diff --git a/Library/Homebrew/linkage_cache_store.rb b/Library/Homebrew/linkage_cache_store.rb
index 45bb9bc3d0640..5a9c251535995 100644
--- a/Library/Homebrew/linkage_cache_store.rb
+++ b/Library/Homebrew/linkage_cache_store.rb
@@ -1,7 +1,6 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "set"
 require "cache_store"
 
 #
diff --git a/Library/Homebrew/linkage_checker.rb b/Library/Homebrew/linkage_checker.rb
index 7887ffe7de27a..6d11765b2b99f 100644
--- a/Library/Homebrew/linkage_checker.rb
+++ b/Library/Homebrew/linkage_checker.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "keg"
@@ -7,11 +7,7 @@
 require "fiddle"
 
 # Check for broken/missing linkage in a formula's keg.
-#
-# @api private
 class LinkageChecker
-  extend T::Sig
-
   attr_reader :undeclared_deps, :keg, :formula, :store
 
   def initialize(keg, formula = nil, cache_db:, rebuild_cache: false)
@@ -21,8 +17,6 @@ def initialize(keg, formula = nil, cache_db:, rebuild_cache: false)
 
     @system_dylibs    = Set.new
     @broken_dylibs    = Set.new
-    @unexpected_broken_dylibs = nil
-    @unexpected_present_dylibs = nil
     @variable_dylibs  = Set.new
     @brewed_dylibs    = Hash.new { |h, k| h[k] = Set.new }
     @reverse_links    = Hash.new { |h, k| h[k] = Set.new }
@@ -33,24 +27,24 @@ def initialize(keg, formula = nil, cache_db:, rebuild_cache: false)
     @unwanted_system_dylibs = []
     @version_conflict_deps = []
     @files_missing_rpaths = []
+    @executable_path_dylibs = []
 
-    check_dylibs(rebuild_cache: rebuild_cache)
+    check_dylibs(rebuild_cache:)
   end
 
   def display_normal_output
     display_items "System libraries", @system_dylibs
     display_items "Homebrew libraries", @brewed_dylibs
     display_items "Indirect dependencies with linkage", @indirect_deps
-    display_items "Variable-referenced libraries", @variable_dylibs
+    display_items "@rpath-referenced libraries", @variable_dylibs
     display_items "Missing libraries", @broken_dylibs
     display_items "Broken dependencies", @broken_deps
     display_items "Undeclared dependencies with linkage", @undeclared_deps
     display_items "Dependencies with no linkage", @unnecessary_deps
     display_items "Unwanted system libraries", @unwanted_system_dylibs
     display_items "Files with missing rpath", @files_missing_rpaths
+    display_items "@executable_path references in libraries", @executable_path_dylibs
   end
-  alias generic_display_normal_output display_normal_output
-  private :generic_display_normal_output
 
   def display_reverse_output
     return if @reverse_links.empty?
@@ -67,66 +61,28 @@ def display_reverse_output
   end
 
   def display_test_output(puts_output: true, strict: false)
-    display_items "Missing libraries", broken_dylibs_with_expectations, puts_output: puts_output
-    display_items "Unused missing linkage information", unexpected_present_dylibs, puts_output: puts_output
-    display_items "Broken dependencies", @broken_deps, puts_output: puts_output
-    display_items "Unwanted system libraries", @unwanted_system_dylibs, puts_output: puts_output
-    display_items "Conflicting libraries", @version_conflict_deps, puts_output: puts_output
+    display_items("Missing libraries", @broken_dylibs, puts_output:)
+    display_items("Broken dependencies", @broken_deps, puts_output:)
+    display_items("Unwanted system libraries", @unwanted_system_dylibs, puts_output:)
+    display_items("Conflicting libraries", @version_conflict_deps, puts_output:)
     return unless strict
 
-    display_items "Undeclared dependencies with linkage", @undeclared_deps, puts_output: puts_output
-    display_items "Files with missing rpath", @files_missing_rpaths, puts_output: puts_output
-  end
-  alias generic_display_test_output display_test_output
-  private :generic_display_test_output
-
-  sig { params(strict: T::Boolean).returns(T::Boolean) }
-  def broken_library_linkage?(strict: false)
-    issues = [@broken_deps, @unwanted_system_dylibs, @version_conflict_deps]
-    issues += [@undeclared_deps, @files_missing_rpaths] if strict
-    [issues, unexpected_broken_dylibs, unexpected_present_dylibs].flatten.any?(&:present?)
-  end
-  alias generic_broken_library_linkage? broken_library_linkage?
-  private :generic_broken_library_linkage?
-
-  def unexpected_broken_dylibs
-    return @unexpected_broken_dylibs if @unexpected_broken_dylibs
-
-    @unexpected_broken_dylibs = @broken_dylibs.reject do |broken_lib|
-      @formula.class.allowed_missing_libraries.any? do |allowed_missing_lib|
-        case allowed_missing_lib
-        when Regexp
-          allowed_missing_lib.match? broken_lib
-        when String
-          broken_lib.include? allowed_missing_lib
-        end
-      end
-    end
+    display_items("Indirect dependencies with linkage", @indirect_deps, puts_output:)
+    display_items("Undeclared dependencies with linkage", @undeclared_deps, puts_output:)
+    display_items("Files with missing rpath", @files_missing_rpaths, puts_output:)
+    display_items "@executable_path references in libraries", @executable_path_dylibs, puts_output:
   end
 
-  def unexpected_present_dylibs
-    @unexpected_present_dylibs ||= @formula.class.allowed_missing_libraries.reject do |allowed_missing_lib|
-      @broken_dylibs.any? do |broken_lib|
-        case allowed_missing_lib
-        when Regexp
-          allowed_missing_lib.match? broken_lib
-        when String
-          broken_lib.include? allowed_missing_lib
-        end
-      end
-    end
-  end
+  sig { params(test: T::Boolean, strict: T::Boolean).returns(T::Boolean) }
+  def broken_library_linkage?(test: false, strict: false)
+    raise ArgumentError, "Strict linkage checking requires test mode to be enabled." if strict && !test
 
-  def broken_dylibs_with_expectations
-    output = {}
-    @broken_dylibs.each do |broken_lib|
-      output[broken_lib] = if unexpected_broken_dylibs.include? broken_lib
-        ["unexpected"]
-      else
-        ["expected"]
-      end
+    issues = [@broken_deps, @broken_dylibs]
+    if test
+      issues += [@unwanted_system_dylibs, @version_conflict_deps]
+      issues += [@indirect_deps, @undeclared_deps, @files_missing_rpaths, @executable_path_dylibs] if strict
     end
-    output
+    issues.any?(&:present?)
   end
 
   private
@@ -136,6 +92,13 @@ def dylib_to_dep(dylib)
     Regexp.last_match(2)
   end
 
+  sig { params(file: String).returns(T::Boolean) }
+  def broken_dylibs_allowed?(file)
+    return false if formula.name != "julia"
+
+    file.start_with?("#{formula.prefix.realpath}/share/julia/compiled/")
+  end
+
   def check_dylibs(rebuild_cache:)
     keg_files_dylibs = nil
 
@@ -152,11 +115,12 @@ def check_dylibs(rebuild_cache:)
       @keg.find do |file|
         next if file.symlink? || file.directory?
         next if !file.dylib? && !file.binary_executable? && !file.mach_o_bundle?
+        next unless file.arch_compatible?(Hardware::CPU.arch)
 
         # weakly loaded dylibs may not actually exist on disk, so skip them
         # when checking for broken linkage
         keg_files_dylibs[file] =
-          file.dynamically_linked_libraries(except: :LC_LOAD_WEAK_DYLIB)
+          file.dynamically_linked_libraries(except: :DYLIB_USE_WEAK_LINK)
       end
     end
 
@@ -172,20 +136,23 @@ def check_dylibs(rebuild_cache:)
         if !file_has_any_rpath_dylibs && (dylib.start_with? "@rpath/")
           file_has_any_rpath_dylibs = true
           pathname = Pathname(file)
-          @files_missing_rpaths << file if pathname.rpaths.empty?
+          @files_missing_rpaths << file if pathname.rpaths.empty? && !broken_dylibs_allowed?(file.to_s)
         end
 
         next if checked_dylibs.include? dylib
 
         checked_dylibs << dylib
 
-        if dylib.start_with? "@"
+        if dylib.start_with? "@rpath"
           @variable_dylibs << dylib
           next
+        elsif dylib.start_with?("@executable_path") && !Pathname(file).binary_executable?
+          @executable_path_dylibs << dylib
+          next
         end
 
         begin
-          owner = Keg.for Pathname.new(dylib)
+          owner = Keg.for(Pathname(dylib))
         rescue NotAKegError
           @system_dylibs << dylib
         rescue Errno::ENOENT
@@ -193,16 +160,15 @@ def check_dylibs(rebuild_cache:)
 
           if (dep = dylib_to_dep(dylib))
             @broken_deps[dep] |= [dylib]
-          elsif MacOS.version >= :big_sur && dylib_found_via_dlopen(dylib)
+          elsif system_libraries_exist_in_cache? && dylib_found_in_shared_cache?(dylib)
             # If we cannot associate the dylib with a dependency, then it may be a system library.
-            # In macOS Big Sur and later, system libraries do not exist on-disk and instead exist in a cache.
-            # If dlopen finds the dylib, then the linkage is not broken.
+            # Check the dylib shared cache for the library to verify this.
             @system_dylibs << dylib
-          elsif !system_framework?(dylib)
+          elsif !system_framework?(dylib) && !broken_dylibs_allowed?(file.to_s)
             @broken_dylibs << dylib
           end
         else
-          tap = Tab.for_keg(owner).tap
+          tap = owner.tab.tap
           f = if tap.nil? || tap.core_tap?
             owner.name
           else
@@ -220,20 +186,32 @@ def check_dylibs(rebuild_cache:)
 
     return unless keg_files_dylibs_was_empty
 
-    store&.update!(keg_files_dylibs: keg_files_dylibs)
+    store&.update!(keg_files_dylibs:)
   end
   alias generic_check_dylibs check_dylibs
 
-  def dylib_found_via_dlopen(dylib)
-    Fiddle.dlopen(dylib).close
-    true
-  rescue Fiddle::DLError
+  def system_libraries_exist_in_cache?
     false
   end
+  alias generic_system_libraries_exist_in_cache? system_libraries_exist_in_cache?
+
+  def dylib_found_in_shared_cache?(dylib)
+    @dyld_shared_cache_contains_path ||= begin
+      libc = Fiddle.dlopen("/usr/lib/libSystem.B.dylib")
+
+      Fiddle::Function.new(
+        libc["_dyld_shared_cache_contains_path"],
+        [Fiddle::TYPE_CONST_STRING],
+        Fiddle::TYPE_BOOL,
+      )
+    end
+
+    @dyld_shared_cache_contains_path.call(dylib)
+  end
 
   def check_formula_deps
     filter_out = proc do |dep|
-      next true if dep.build?
+      next true if dep.build? || dep.test?
 
       (dep.optional? || dep.recommended?) && formula.build.without?(dep)
     end
@@ -306,9 +284,12 @@ def sort_by_formula_full_name!(arr)
   def harmless_broken_link?(dylib)
     # libgcc_s_* is referenced by programs that use the Java Service Wrapper,
     # and is harmless on x86(_64) machines
+    # dyld will fall back to Apple libc++ if LLVM's is not available.
     [
       "/usr/lib/libgcc_s_ppc64.1.dylib",
       "/opt/local/lib/libgcc/libgcc_s.1.dylib",
+      # TODO: Report linkage with `/usr/lib/libc++.1.dylib` when this link is broken.
+      "#{HOMEBREW_PREFIX}/opt/llvm/lib/libc++.1.dylib",
     ].include?(dylib)
   end
 
diff --git a/Library/Homebrew/linux_runner_spec.rb b/Library/Homebrew/linux_runner_spec.rb
new file mode 100644
index 0000000000000..be097267fc32d
--- /dev/null
+++ b/Library/Homebrew/linux_runner_spec.rb
@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+class LinuxRunnerSpec < T::Struct
+  const :name, String
+  const :runner, String
+  const :container, T::Hash[Symbol, String]
+  const :workdir, String
+  const :timeout, Integer
+  const :cleanup, T::Boolean
+  prop  :testing_formulae, T::Array[String], default: []
+
+  sig {
+    returns({
+      name:             String,
+      runner:           String,
+      container:        T::Hash[Symbol, String],
+      workdir:          String,
+      timeout:          Integer,
+      cleanup:          T::Boolean,
+      testing_formulae: String,
+    })
+  }
+  def to_h
+    {
+      name:,
+      runner:,
+      container:,
+      workdir:,
+      timeout:,
+      cleanup:,
+      testing_formulae: testing_formulae.join(","),
+    }
+  end
+end
diff --git a/Library/Homebrew/linuxbrew-core-migration.rb b/Library/Homebrew/linuxbrew-core-migration.rb
index 22f879a915fd3..ef05bef22e774 100644
--- a/Library/Homebrew/linuxbrew-core-migration.rb
+++ b/Library/Homebrew/linuxbrew-core-migration.rb
@@ -1,9 +1,9 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 # List of formulae that had a revision in linuxbrew-core
 # that was different than in homebrew-core
-# We will use this list to modify the version_sheme
+# We will use this list to modify the version_scheme
 # during the migration from linuxbrew-core to homebrew-core.
 
 LINUXBREW_CORE_MIGRATION_LIST = %w[
diff --git a/Library/Homebrew/list.sh b/Library/Homebrew/list.sh
new file mode 100644
index 0000000000000..234b7f3b76aa0
--- /dev/null
+++ b/Library/Homebrew/list.sh
@@ -0,0 +1,88 @@
+# does the quickest output of brew list possible for no named arguments.
+# HOMEBREW_CELLAR, HOMEBREW_PREFIX are set by brew.sh
+# shellcheck disable=SC2154
+homebrew-list() {
+  case "$1" in
+    # check we actually have list and not e.g. listsomething
+    list | ls) ;;
+    list* | ls*) return 1 ;;
+    *) ;;
+  esac
+
+  local ls_env=()
+  local ls_args=()
+
+  local tty
+  if [[ -t 1 ]]
+  then
+    tty=1
+    ls_args+=("-Cq")
+    source "${HOMEBREW_LIBRARY}/Homebrew/utils/helpers.sh"
+    ls_env+=("COLUMNS=$(columns)")
+  fi
+
+  local formula=""
+  local cask=""
+
+  # `OPTIND` is used internally by `getopts` to track parsing position
+  local OPTIND=2 # skip $1 (and localise OPTIND to this function)
+  while getopts ":1lrt-:" arg
+  do
+    case "${arg}" in
+      # check for flags passed to ls
+      1 | l | r | t) ls_args+=("-${arg}") ;;
+      -)
+        local parsed_index=$((OPTIND - 1)) # Parse full arg to reject e.g. -r-formula
+        case "${!parsed_index}" in
+          --formula | --formulae) formula=1 ;;
+          --cask | --casks) cask=1 ;;
+          *) return 1 ;;
+        esac
+        ;;
+      # reject all other flags
+      *) return 1 ;;
+    esac
+  done
+  # If we haven't reached the end of the arg list, we have named args.
+  if ((OPTIND - 1 != $#))
+  then
+    return 1
+  fi
+
+  if [[ -z "${cask}" && -d "${HOMEBREW_CELLAR}" ]]
+  then
+    if [[ -n "${tty}" && -z "${formula}" ]]
+    then
+      ohai "Formulae"
+    fi
+
+    local formula_output
+    formula_output="$(/usr/bin/env "${ls_env[@]}" ls "${ls_args[@]}" "${HOMEBREW_CELLAR}")" || exit 1
+    if [[ -n "${formula_output}" ]]
+    then
+      echo "${formula_output}"
+    fi
+
+    if [[ -n "${tty}" && -z "${formula}" ]]
+    then
+      echo
+    fi
+  fi
+
+  if [[ -z "${formula}" && -d "${HOMEBREW_CASKROOM}" ]]
+  then
+    if [[ -n "${tty}" && -z "${cask}" ]]
+    then
+      ohai "Casks"
+    fi
+
+    local cask_output
+    cask_output="$(/usr/bin/env "${ls_env[@]}" ls "${ls_args[@]}" "${HOMEBREW_CASKROOM}")" || exit 1
+    if [[ -n "${cask_output}" ]]
+    then
+      echo "${cask_output}"
+    fi
+
+    return 0
+  fi
+}
diff --git a/Library/Homebrew/livecheck.rb b/Library/Homebrew/livecheck.rb
index 66abd5142f285..2b2aef45ed50a 100644
--- a/Library/Homebrew/livecheck.rb
+++ b/Library/Homebrew/livecheck.rb
@@ -1,6 +1,9 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "livecheck/constants"
+require "cask/cask"
+
 # The {Livecheck} class implements the DSL methods used in a formula's, cask's
 # or resource's `livecheck` block and stores related instance variables. Most
 # of these methods also return the related instance variable when no argument
@@ -14,35 +17,39 @@ class Livecheck
 
   # A very brief description of why the formula/cask/resource is skipped (e.g.
   # `No longer developed or maintained`).
-  # @return [String, nil]
+  sig { returns(T.nilable(String)) }
   attr_reader :skip_msg
 
+  sig { params(package_or_resource: T.any(Cask::Cask, T.class_of(Formula), Resource)).void }
   def initialize(package_or_resource)
     @package_or_resource = package_or_resource
-    @referenced_cask_name = nil
-    @referenced_formula_name = nil
-    @regex = nil
-    @skip = false
-    @skip_msg = nil
-    @strategy = nil
-    @url = nil
+    @referenced_cask_name = T.let(nil, T.nilable(String))
+    @referenced_formula_name = T.let(nil, T.nilable(String))
+    @regex = T.let(nil, T.nilable(Regexp))
+    @skip = T.let(false, T::Boolean)
+    @skip_msg = T.let(nil, T.nilable(String))
+    @strategy = T.let(nil, T.nilable(Symbol))
+    @strategy_block = T.let(nil, T.nilable(Proc))
+    @throttle = T.let(nil, T.nilable(Integer))
+    @url = T.let(nil, T.any(NilClass, String, Symbol))
   end
 
   # Sets the `@referenced_cask_name` instance variable to the provided `String`
   # or returns the `@referenced_cask_name` instance variable when no argument
   # is provided. Inherited livecheck values from the referenced cask
   # (e.g. regex) can be overridden in the livecheck block.
-  #
-  # @param cask_name [String] name of cask to inherit livecheck info from
-  # @return [String, nil]
-  def cask(cask_name = nil)
+  sig {
+    params(
+      # Name of cask to inherit livecheck info from.
+      cask_name: String,
+    ).returns(T.nilable(String))
+  }
+  def cask(cask_name = T.unsafe(nil))
     case cask_name
     when nil
       @referenced_cask_name
     when String
       @referenced_cask_name = cask_name
-    else
-      raise TypeError, "Livecheck#cask expects a String"
     end
   end
 
@@ -50,33 +57,35 @@ def cask(cask_name = nil)
   # `String` or returns the `@referenced_formula_name` instance variable when
   # no argument is provided. Inherited livecheck values from the referenced
   # formula (e.g. regex) can be overridden in the livecheck block.
-  #
-  # @param formula_name [String] name of formula to inherit livecheck info from
-  # @return [String, nil]
-  def formula(formula_name = nil)
+  sig {
+    params(
+      # Name of formula to inherit livecheck info from.
+      formula_name: String,
+    ).returns(T.nilable(String))
+  }
+  def formula(formula_name = T.unsafe(nil))
     case formula_name
     when nil
       @referenced_formula_name
     when String
       @referenced_formula_name = formula_name
-    else
-      raise TypeError, "Livecheck#formula expects a String"
     end
   end
 
   # Sets the `@regex` instance variable to the provided `Regexp` or returns the
   # `@regex` instance variable when no argument is provided.
-  #
-  # @param pattern [Regexp] regex to use for matching versions in content
-  # @return [Regexp, nil]
-  def regex(pattern = nil)
+  sig {
+    params(
+      # Regex to use for matching versions in content.
+      pattern: Regexp,
+    ).returns(T.nilable(Regexp))
+  }
+  def regex(pattern = T.unsafe(nil))
     case pattern
     when nil
       @regex
     when Regexp
       @regex = pattern
-    else
-      raise TypeError, "Livecheck#regex expects a Regexp"
     end
   end
 
@@ -85,20 +94,20 @@ def regex(pattern = nil)
   # that the formula/cask/resource should be skipped and the `skip_msg` very
   # briefly describes why it is skipped (e.g. "No longer developed or
   # maintained").
-  #
-  # @param skip_msg [String] string describing why the formula/cask is skipped
-  # @return [Boolean]
-  def skip(skip_msg = nil)
-    if skip_msg.is_a?(String)
-      @skip_msg = skip_msg
-    elsif skip_msg.present?
-      raise TypeError, "Livecheck#skip expects a String"
-    end
+  sig {
+    params(
+      # String describing why the formula/cask is skipped.
+      skip_msg: String,
+    ).returns(T::Boolean)
+  }
+  def skip(skip_msg = T.unsafe(nil))
+    @skip_msg = skip_msg if skip_msg.is_a?(String)
 
     @skip = true
   end
 
   # Should `livecheck` skip this formula/cask/resource?
+  sig { returns(T::Boolean) }
   def skip?
     @skip
   end
@@ -107,10 +116,14 @@ def skip?
   # the `@strategy` instance variable when no argument is provided. The strategy
   # symbols use snake case (e.g. `:page_match`) and correspond to the strategy
   # file name.
-  #
-  # @param symbol [Symbol] symbol for the desired strategy
-  # @return [Symbol, nil]
-  def strategy(symbol = nil, &block)
+  sig {
+    params(
+      # Symbol for the desired strategy.
+      symbol: Symbol,
+      block:  T.nilable(Proc),
+    ).returns(T.nilable(Symbol))
+  }
+  def strategy(symbol = T.unsafe(nil), &block)
     @strategy_block = block if block
 
     case symbol
@@ -118,35 +131,57 @@ def strategy(symbol = nil, &block)
       @strategy
     when Symbol
       @strategy = symbol
-    else
-      raise TypeError, "Livecheck#strategy expects a Symbol"
     end
   end
 
+  sig { returns(T.nilable(Proc)) }
   attr_reader :strategy_block
 
+  # Sets the `@throttle` instance variable to the provided `Integer` or returns
+  # the `@throttle` instance variable when no argument is provided.
+  sig {
+    params(
+      # Throttle rate of version patch number to use for bumpable versions.
+      rate: Integer,
+    ).returns(T.nilable(Integer))
+  }
+  def throttle(rate = T.unsafe(nil))
+    case rate
+    when nil
+      @throttle
+    when Integer
+      @throttle = rate
+    end
+  end
+
   # Sets the `@url` instance variable to the provided argument or returns the
   # `@url` instance variable when no argument is provided. The argument can be
   # a `String` (a URL) or a supported `Symbol` corresponding to a URL in the
   # formula/cask/resource (e.g. `:stable`, `:homepage`, `:head`, `:url`).
-  # @param val [String, Symbol] URL to check for version information
-  # @return [String, nil]
-  def url(val = nil)
-    case val
+  sig {
+    params(
+      # URL to check for version information.
+      url: T.any(String, Symbol),
+    ).returns(T.nilable(T.any(String, Symbol)))
+  }
+  def url(url = T.unsafe(nil))
+    case url
     when nil
       @url
     when String, :head, :homepage, :stable, :url
-      @url = val
-    else
-      raise TypeError, "Livecheck#url expects a String or valid Symbol"
+      @url = url
+    when Symbol
+      raise ArgumentError, "#{url.inspect} is not a valid URL shorthand"
     end
   end
 
   delegate version: :@package_or_resource
-  private :version
+  delegate arch: :@package_or_resource
+  private :version, :arch
 
   # Returns a `Hash` of all instance variable values.
   # @return [Hash]
+  sig { returns(T::Hash[String, T.untyped]) }
   def to_hash
     {
       "cask"     => @referenced_cask_name,
@@ -155,6 +190,7 @@ def to_hash
       "skip"     => @skip,
       "skip_msg" => @skip_msg,
       "strategy" => @strategy,
+      "throttle" => @throttle,
       "url"      => @url,
     }
   end
diff --git a/Library/Homebrew/livecheck/constants.rb b/Library/Homebrew/livecheck/constants.rb
new file mode 100644
index 0000000000000..09645c4229fe4
--- /dev/null
+++ b/Library/Homebrew/livecheck/constants.rb
@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  module Livecheck
+    # The {Constants} module provides constants that are intended to be used
+    # in `livecheck` block values (e.g. `url`, `regex`).
+    module Constants
+      # A placeholder string used in resource `livecheck` block URLs that will
+      # be replaced with the latest version from the main formula check.
+      LATEST_VERSION = "<FORMULA_LATEST_VERSION>"
+    end
+  end
+end
diff --git a/Library/Homebrew/livecheck/error.rb b/Library/Homebrew/livecheck/error.rb
index 8cbd8ff28e295..1c0be81b4cbe7 100644
--- a/Library/Homebrew/livecheck/error.rb
+++ b/Library/Homebrew/livecheck/error.rb
@@ -4,8 +4,6 @@
 module Homebrew
   module Livecheck
     # Error during a livecheck run.
-    #
-    # @api private
     class Error < RuntimeError
     end
   end
diff --git a/Library/Homebrew/livecheck/livecheck.rb b/Library/Homebrew/livecheck/livecheck.rb
index bdc25c33715d0..ac20b4c74cfcc 100644
--- a/Library/Homebrew/livecheck/livecheck.rb
+++ b/Library/Homebrew/livecheck/livecheck.rb
@@ -1,46 +1,19 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "livecheck/constants"
 require "livecheck/error"
 require "livecheck/livecheck_version"
 require "livecheck/skip_conditions"
 require "livecheck/strategy"
 require "addressable"
-require "ruby-progressbar"
-require "uri"
 
 module Homebrew
-  # rubocop:disable Metrics/ModuleLength
-
   # The {Livecheck} module consists of methods used by the `brew livecheck`
   # command. These methods print the requested livecheck information
   # for formulae.
-  #
-  # @api private
   module Livecheck
-    extend T::Sig
-
-    module_function
-
-    GITEA_INSTANCES = %w[
-      codeberg.org
-      gitea.com
-      opendev.org
-      tildegit.org
-    ].freeze
-
-    GOGS_INSTANCES = %w[
-      lolg.it
-    ].freeze
-
-    STRATEGY_SYMBOLS_TO_SKIP_PREPROCESS_URL = [
-      :github_latest,
-      :page_match,
-      :header_match,
-      :sparkle,
-    ].freeze
-
-    UNSTABLE_VERSION_KEYWORDS = %w[
+    UNSTABLE_VERSION_KEYWORDS = T.let(%w[
       alpha
       beta
       bpo
@@ -49,32 +22,33 @@ module Livecheck
       prerelease
       preview
       rc
-    ].freeze
+    ].freeze, T::Array[String])
+    private_constant :UNSTABLE_VERSION_KEYWORDS
 
-    sig { returns(T::Hash[Class, String]) }
-    def livecheck_strategy_names
-      return @livecheck_strategy_names if defined?(@livecheck_strategy_names)
+    sig { returns(T::Hash[T::Class[T.anything], String]) }
+    private_class_method def self.livecheck_strategy_names
+      return T.must(@livecheck_strategy_names) if defined?(@livecheck_strategy_names)
 
       # Cache demodulized strategy names, to avoid repeating this work
-      @livecheck_strategy_names = {}
+      @livecheck_strategy_names = T.let({}, T.nilable(T::Hash[T::Class[T.anything], String]))
       Strategy.constants.sort.each do |const_symbol|
         constant = Strategy.const_get(const_symbol)
         next unless constant.is_a?(Class)
 
-        @livecheck_strategy_names[constant] = T.must(constant.name).demodulize
+        T.must(@livecheck_strategy_names)[constant] = Utils.demodulize(T.must(constant.name))
       end
-      @livecheck_strategy_names.freeze
+      T.must(@livecheck_strategy_names).freeze
     end
 
     # Uses `formulae_and_casks_to_check` to identify taps in use other than
     # homebrew/core and homebrew/cask and loads strategies from them.
     sig { params(formulae_and_casks_to_check: T::Array[T.any(Formula, Cask::Cask)]).void }
-    def load_other_tap_strategies(formulae_and_casks_to_check)
+    def self.load_other_tap_strategies(formulae_and_casks_to_check)
       other_taps = {}
       formulae_and_casks_to_check.each do |formula_or_cask|
         next if formula_or_cask.tap.blank?
-        next if formula_or_cask.tap.name == CoreTap.instance.name
-        next if formula_or_cask.tap.name == "homebrew/cask"
+        next if formula_or_cask.tap.core_tap?
+        next if formula_or_cask.tap.core_cask_tap?
         next if other_taps[formula_or_cask.tap.name]
 
         other_taps[formula_or_cask.tap.name] = formula_or_cask.tap
@@ -83,7 +57,7 @@ def load_other_tap_strategies(formulae_and_casks_to_check)
 
       other_taps.each_value do |tap|
         tap_strategy_path = "#{tap.path}/livecheck/strategy"
-        Dir["#{tap_strategy_path}/*.rb"].sort.each(&method(:require)) if Dir.exist?(tap_strategy_path)
+        Dir["#{tap_strategy_path}/*.rb"].each { require(_1) } if Dir.exist?(tap_strategy_path)
       end
     end
 
@@ -98,7 +72,7 @@ def load_other_tap_strategies(formulae_and_casks_to_check)
         debug:                 T::Boolean,
       ).returns(T.nilable(T::Array[T.untyped]))
     }
-    def resolve_livecheck_reference(
+    def self.resolve_livecheck_reference(
       formula_or_cask,
       first_formula_or_cask = formula_or_cask,
       references = [],
@@ -112,10 +86,12 @@ def resolve_livecheck_reference(
       return [nil, references] if livecheck_formula.blank? && livecheck_cask.blank?
 
       # Load the referenced formula or cask
-      referenced_formula_or_cask = if livecheck_formula
-        Formulary.factory(livecheck_formula)
-      elsif livecheck_cask
-        Cask::CaskLoader.load(livecheck_cask)
+      referenced_formula_or_cask = Homebrew.with_no_api_env do
+        if livecheck_formula
+          Formulary.factory(livecheck_formula)
+        elsif livecheck_cask
+          Cask::CaskLoader.load(livecheck_cask)
+        end
       end
 
       # Error if a `livecheck` block references a formula/cask that was already
@@ -126,11 +102,11 @@ def resolve_livecheck_reference(
         if debug
           # Print the chain of references for debugging
           puts "Reference Chain:"
-          puts formula_or_cask_name(first_formula_or_cask, full_name: full_name)
+          puts package_or_resource_name(first_formula_or_cask, full_name:)
 
           references << referenced_formula_or_cask
           references.each do |ref_formula_or_cask|
-            puts formula_or_cask_name(ref_formula_or_cask, full_name: full_name)
+            puts package_or_resource_name(ref_formula_or_cask, full_name:)
           end
         end
 
@@ -143,8 +119,8 @@ def resolve_livecheck_reference(
         referenced_formula_or_cask,
         first_formula_or_cask,
         references,
-        full_name: full_name,
-        debug:     debug,
+        full_name:,
+        debug:,
       )
 
       # Returning references along with the final referenced formula/cask
@@ -162,33 +138,36 @@ def resolve_livecheck_reference(
         formulae_and_casks_to_check: T::Array[T.any(Formula, Cask::Cask)],
         full_name:                   T::Boolean,
         handle_name_conflict:        T::Boolean,
+        check_resources:             T::Boolean,
         json:                        T::Boolean,
         newer_only:                  T::Boolean,
+        extract_plist:               T::Boolean,
         debug:                       T::Boolean,
         quiet:                       T::Boolean,
         verbose:                     T::Boolean,
       ).void
     }
-    def run_checks(
+    def self.run_checks(
       formulae_and_casks_to_check,
-      full_name: false, handle_name_conflict: false, json: false, newer_only: false,
-      debug: false, quiet: false, verbose: false
+      full_name: false, handle_name_conflict: false, check_resources: false, json: false, newer_only: false,
+      extract_plist: false, debug: false, quiet: false, verbose: false
     )
       load_other_tap_strategies(formulae_and_casks_to_check)
 
       ambiguous_casks = []
       if handle_name_conflict
-        ambiguous_casks = formulae_and_casks_to_check.group_by { |item| formula_or_cask_name(item, full_name: true) }
-                                                     .values
-                                                     .select { |items| items.length > 1 }
-                                                     .flatten
-                                                     .select { |item| item.is_a?(Cask::Cask) }
+        ambiguous_casks = formulae_and_casks_to_check
+                          .group_by { |item| package_or_resource_name(item, full_name: true) }
+                          .values
+                          .select { |items| items.length > 1 }
+                          .flatten
+                          .select { |item| item.is_a?(Cask::Cask) }
       end
 
       ambiguous_names = []
       unless full_name
         ambiguous_names =
-          (formulae_and_casks_to_check - ambiguous_casks).group_by { |item| formula_or_cask_name(item) }
+          (formulae_and_casks_to_check - ambiguous_casks).group_by { |item| package_or_resource_name(item) }
                                                          .values
                                                          .select { |items| items.length > 1 }
                                                          .flatten
@@ -196,13 +175,13 @@ def run_checks(
 
       has_a_newer_upstream_version = T.let(false, T::Boolean)
 
+      formulae_and_casks_total = formulae_and_casks_to_check.count
       if json && !quiet && $stderr.tty?
-        formulae_and_casks_total = formulae_and_casks_to_check.count
-
         Tty.with($stderr) do |stderr|
           stderr.puts Formatter.headline("Running checks", color: :blue)
         end
 
+        require "ruby-progressbar"
         progress = ProgressBar.create(
           total:          formulae_and_casks_total,
           progress_mark:  "#",
@@ -212,16 +191,18 @@ def run_checks(
         )
       end
 
-      # rubocop:disable Metrics/BlockLength
+      # Allow ExtractPlist strategy if only one formula/cask is being checked.
+      extract_plist = true if formulae_and_casks_total == 1
+
       formulae_checked = formulae_and_casks_to_check.map.with_index do |formula_or_cask, i|
         formula = formula_or_cask if formula_or_cask.is_a?(Formula)
         cask = formula_or_cask if formula_or_cask.is_a?(Cask::Cask)
 
         use_full_name = full_name || ambiguous_names.include?(formula_or_cask)
-        name = formula_or_cask_name(formula_or_cask, full_name: use_full_name)
+        name = package_or_resource_name(formula_or_cask, full_name: use_full_name)
 
         referenced_formula_or_cask, livecheck_references =
-          resolve_livecheck_reference(formula_or_cask, full_name: use_full_name, debug: debug)
+          resolve_livecheck_reference(formula_or_cask, full_name: use_full_name, debug:)
 
         if debug && i.positive?
           puts <<~EOS
@@ -238,12 +219,18 @@ def run_checks(
           skip_info = SkipConditions.referenced_skip_information(
             referenced_formula_or_cask,
             name,
-            full_name: use_full_name,
-            verbose:   verbose,
+            full_name:     use_full_name,
+            verbose:,
+            extract_plist:,
           )
         end
 
-        skip_info ||= SkipConditions.skip_information(formula_or_cask, full_name: use_full_name, verbose: verbose)
+        skip_info ||= SkipConditions.skip_information(
+          formula_or_cask,
+          full_name:     use_full_name,
+          verbose:,
+          extract_plist:,
+        )
         if skip_info.present?
           next skip_info if json && !newer_only
 
@@ -251,7 +238,7 @@ def run_checks(
           next
         end
 
-        formula&.head&.downloader&.shutup!
+        formula&.head&.downloader&.quiet!
 
         # Use the `stable` version for comparison except for installed
         # head-only formulae. A formula with `stable` and `head` that's
@@ -259,9 +246,9 @@ def run_checks(
         # comparison.
         current = if formula
           if formula.head_only?
-            formula.any_installed_version.version.commit
+            Version.new(formula.any_installed_version.version.commit)
           else
-            formula.stable.version
+            T.must(formula.stable).version
           end
         else
           Version.new(formula_or_cask.version)
@@ -271,17 +258,42 @@ def run_checks(
         current = LivecheckVersion.create(formula_or_cask, current)
 
         latest = if formula&.head_only?
-          formula.head.downloader.fetch_last_commit
+          Version.new(T.must(formula.head).downloader.fetch_last_commit)
         else
           version_info = latest_version(
             formula_or_cask,
-            referenced_formula_or_cask: referenced_formula_or_cask,
-            livecheck_references: livecheck_references,
-            json: json, full_name: use_full_name, verbose: verbose, debug: debug
+            referenced_formula_or_cask:,
+            livecheck_references:,
+            json:, full_name: use_full_name, verbose:, debug:
           )
           version_info[:latest] if version_info.present?
         end
 
+        check_for_resources = check_resources && formula_or_cask.is_a?(Formula) && formula_or_cask.resources.present?
+        if check_for_resources
+          resource_version_info = formula_or_cask.resources.map do |resource|
+            res_skip_info ||= SkipConditions.skip_information(resource, verbose:)
+            if res_skip_info.present?
+              res_skip_info
+            else
+              res_version_info = resource_version(
+                resource,
+                latest.to_s,
+                json:,
+                debug:,
+                quiet:,
+                verbose:,
+              )
+              if res_version_info.empty?
+                status_hash(resource, "error", ["Unable to get versions"], verbose:)
+              else
+                res_version_info
+              end
+            end
+          end.compact_blank
+          Homebrew.failed = true if resource_version_info.any? { |info| info[:status] == "error" }
+        end
+
         if latest.blank?
           no_versions_msg = "Unable to get versions"
           raise Livecheck::Error, no_versions_msg unless json
@@ -289,7 +301,19 @@ def run_checks(
 
           next version_info if version_info.is_a?(Hash) && version_info[:status] && version_info[:messages]
 
-          next status_hash(formula_or_cask, "error", [no_versions_msg], full_name: use_full_name, verbose: verbose)
+          latest_info = status_hash(formula_or_cask, "error", [no_versions_msg], full_name: use_full_name,
+                                                                                 verbose:)
+          if check_for_resources
+            unless verbose
+              resource_version_info.map! do |info|
+                info.delete(:meta)
+                info
+              end
+            end
+            latest_info[:resources] = resource_version_info
+          end
+
+          next latest_info
         end
 
         if (m = latest.to_s.match(/(.*)-release$/)) && !current.to_s.match(/.*-release$/)
@@ -315,26 +339,36 @@ def run_checks(
         info[:version] = {
           current:             current_str,
           latest:              latest_str,
+          latest_throttled:    version_info&.dig(:latest_throttled),
           outdated:            is_outdated,
           newer_than_upstream: is_newer_than_upstream,
-        }
+        }.compact
         info[:meta] = {
           livecheckable: formula_or_cask.livecheckable?,
         }
         info[:meta][:head_only] = true if formula&.head_only?
         info[:meta].merge!(version_info[:meta]) if version_info.present? && version_info.key?(:meta)
 
+        info[:resources] = resource_version_info if check_for_resources
+
         next if newer_only && !info[:version][:outdated]
 
         has_a_newer_upstream_version ||= true
 
         if json
           progress&.increment
-          info.except!(:meta) unless verbose
+          info.delete(:meta) unless verbose
+          if check_for_resources && !verbose
+            resource_version_info.map! do |info|
+              info.delete(:meta)
+              info
+            end
+          end
           next info
         end
-
-        print_latest_version(info, verbose: verbose, ambiguous_cask: ambiguous_casks.include?(formula_or_cask))
+        puts if debug
+        print_latest_version(info, verbose:, ambiguous_cask: ambiguous_casks.include?(formula_or_cask))
+        print_resources_info(resource_version_info, verbose:) if check_for_resources
         nil
       rescue => e
         Homebrew.failed = true
@@ -342,19 +376,25 @@ def run_checks(
 
         if json
           progress&.increment
-          status_hash(formula_or_cask, "error", [e.to_s], full_name: use_full_name, verbose: verbose) unless quiet
+          unless quiet
+            status_hash(formula_or_cask, "error", [e.to_s], full_name: use_full_name,
+                                                            verbose:)
+          end
         elsif !quiet
-          name = formula_or_cask_name(formula_or_cask, full_name: use_full_name)
+          name = package_or_resource_name(formula_or_cask, full_name: use_full_name)
           name += " (cask)" if ambiguous_casks.include?(formula_or_cask)
 
           onoe "#{Tty.blue}#{name}#{Tty.reset}: #{e}"
-          $stderr.puts e.backtrace if debug && !e.is_a?(Livecheck::Error)
+          if debug && !e.is_a?(Livecheck::Error)
+            require "utils/backtrace"
+            $stderr.puts Utils::Backtrace.clean(e)
+          end
+          print_resources_info(resource_version_info, verbose:) if check_for_resources
           nil
         end
       end
-      # rubocop:enable Metrics/BlockLength
 
-      puts "No newer upstream versions." if newer_only && !has_a_newer_upstream_version && !debug && !json
+      puts "No newer upstream versions." if newer_only && !has_a_newer_upstream_version && !debug && !json && !quiet
 
       return unless json
 
@@ -368,68 +408,74 @@ def run_checks(
       puts JSON.pretty_generate(formulae_checked.compact)
     end
 
-    sig { params(formula_or_cask: T.any(Formula, Cask::Cask), full_name: T::Boolean).returns(String) }
-    def formula_or_cask_name(formula_or_cask, full_name: false)
-      case formula_or_cask
+    sig { params(package_or_resource: T.any(Formula, Cask::Cask, Resource), full_name: T::Boolean).returns(String) }
+    def self.package_or_resource_name(package_or_resource, full_name: false)
+      case package_or_resource
       when Formula
-        formula_name(formula_or_cask, full_name: full_name)
+        formula_name(package_or_resource, full_name:)
       when Cask::Cask
-        cask_name(formula_or_cask, full_name: full_name)
+        cask_name(package_or_resource, full_name:)
+      when Resource
+        package_or_resource.name
       else
-        T.absurd(formula_or_cask)
+        T.absurd(package_or_resource)
       end
     end
 
     # Returns the fully-qualified name of a cask if the `full_name` argument is
     # provided; returns the name otherwise.
     sig { params(cask: Cask::Cask, full_name: T::Boolean).returns(String) }
-    def cask_name(cask, full_name: false)
+    private_class_method def self.cask_name(cask, full_name: false)
       full_name ? cask.full_name : cask.token
     end
 
     # Returns the fully-qualified name of a formula if the `full_name` argument is
     # provided; returns the name otherwise.
     sig { params(formula: Formula, full_name: T::Boolean).returns(String) }
-    def formula_name(formula, full_name: false)
+    private_class_method def self.formula_name(formula, full_name: false)
       full_name ? formula.full_name : formula.name
     end
 
     sig {
       params(
-        formula_or_cask: T.any(Formula, Cask::Cask),
-        status_str:      String,
-        messages:        T.nilable(T::Array[String]),
-        full_name:       T::Boolean,
-        verbose:         T::Boolean,
-      ).returns(Hash)
+        package_or_resource: T.any(Formula, Cask::Cask, Resource),
+        status_str:          String,
+        messages:            T.nilable(T::Array[String]),
+        full_name:           T::Boolean,
+        verbose:             T::Boolean,
+      ).returns(T::Hash[Symbol, T.untyped])
     }
-    def status_hash(formula_or_cask, status_str, messages = nil, full_name: false, verbose: false)
-      formula = formula_or_cask if formula_or_cask.is_a?(Formula)
-      cask = formula_or_cask if formula_or_cask.is_a?(Cask::Cask)
+    def self.status_hash(package_or_resource, status_str, messages = nil, full_name: false, verbose: false)
+      formula = package_or_resource if package_or_resource.is_a?(Formula)
+      cask = package_or_resource if package_or_resource.is_a?(Cask::Cask)
+      resource = package_or_resource if package_or_resource.is_a?(Resource)
 
       status_hash = {}
       if formula
-        status_hash[:formula] = formula_name(formula, full_name: full_name)
+        status_hash[:formula] = formula_name(formula, full_name:)
       elsif cask
-        status_hash[:cask] = cask_name(formula_or_cask, full_name: full_name)
+        status_hash[:cask] = cask_name(cask, full_name:)
+      elsif resource
+        status_hash[:resource] = resource.name
       end
       status_hash[:status] = status_str
       status_hash[:messages] = messages if messages.is_a?(Array)
 
       status_hash[:meta] = {
-        livecheckable: formula_or_cask.livecheckable?,
+        livecheckable: package_or_resource.livecheckable?,
       }
       status_hash[:meta][:head_only] = true if formula&.head_only?
 
       status_hash
     end
 
-    # Formats and prints the livecheck result for a formula.
-    sig { params(info: Hash, verbose: T::Boolean, ambiguous_cask: T::Boolean).void }
-    def print_latest_version(info, verbose:, ambiguous_cask: false)
-      formula_or_cask_s = "#{Tty.blue}#{info[:formula] || info[:cask]}#{Tty.reset}"
-      formula_or_cask_s += " (cask)" if ambiguous_cask
-      formula_or_cask_s += " (guessed)" if !info[:meta][:livecheckable] && verbose
+    # Formats and prints the livecheck result for a formula/cask/resource.
+    sig { params(info: T::Hash[Symbol, T.untyped], verbose: T::Boolean, ambiguous_cask: T::Boolean).void }
+    private_class_method def self.print_latest_version(info, verbose: false, ambiguous_cask: false)
+      package_or_resource_s = info[:resource].present? ? "  " : ""
+      package_or_resource_s += "#{Tty.blue}#{info[:formula] || info[:cask] || info[:resource]}#{Tty.reset}"
+      package_or_resource_s += " (cask)" if ambiguous_cask
+      package_or_resource_s += " (guessed)" if verbose && !info[:meta][:livecheckable]
 
       current_s = if info[:version][:newer_than_upstream]
         "#{Tty.red}#{info[:version][:current]}#{Tty.reset}"
@@ -443,100 +489,76 @@ def print_latest_version(info, verbose:, ambiguous_cask: false)
         info[:version][:latest]
       end
 
-      puts "#{formula_or_cask_s}: #{current_s} ==> #{latest_s}"
+      puts "#{package_or_resource_s}: #{current_s} ==> #{latest_s}"
+    end
+
+    # Prints the livecheck result for the resources of a given Formula.
+    sig { params(info: T::Array[T::Hash[Symbol, T.untyped]], verbose: T::Boolean).void }
+    private_class_method def self.print_resources_info(info, verbose: false)
+      info.each do |r_info|
+        if r_info[:status] && r_info[:messages]
+          SkipConditions.print_skip_information(r_info)
+        else
+          print_latest_version(r_info, verbose:)
+        end
+      end
     end
 
     sig {
       params(
-        livecheck_url:   T.any(String, Symbol),
-        formula_or_cask: T.any(Formula, Cask::Cask),
-      ).returns(T.nilable(String))
+        livecheck_url:       T.any(String, Symbol),
+        package_or_resource: T.any(Formula, Cask::Cask, Resource),
+      ).returns(String)
     }
-    def livecheck_url_to_string(livecheck_url, formula_or_cask)
-      case livecheck_url
+    def self.livecheck_url_to_string(livecheck_url, package_or_resource)
+      livecheck_url_string = case livecheck_url
       when String
         livecheck_url
       when :url
-        formula_or_cask.url&.to_s if formula_or_cask.is_a?(Cask::Cask)
+        package_or_resource.url&.to_s if package_or_resource.is_a?(Cask::Cask) || package_or_resource.is_a?(Resource)
       when :head, :stable
-        formula_or_cask.send(livecheck_url)&.url if formula_or_cask.is_a?(Formula)
+        package_or_resource.send(livecheck_url)&.url if package_or_resource.is_a?(Formula)
       when :homepage
-        formula_or_cask.homepage
+        package_or_resource.homepage unless package_or_resource.is_a?(Resource)
+      end
+
+      if livecheck_url.is_a?(Symbol) && !livecheck_url_string
+        raise ArgumentError, "`url #{livecheck_url.inspect}` does not reference a checkable URL"
       end
+
+      livecheck_url_string
     end
 
-    # Returns an Array containing the formula/cask URLs that can be used by livecheck.
-    sig { params(formula_or_cask: T.any(Formula, Cask::Cask)).returns(T::Array[String]) }
-    def checkable_urls(formula_or_cask)
+    # Returns an Array containing the formula/cask/resource URLs that can be used by livecheck.
+    sig { params(package_or_resource: T.any(Formula, Cask::Cask, Resource)).returns(T::Array[String]) }
+    def self.checkable_urls(package_or_resource)
       urls = []
 
-      case formula_or_cask
+      case package_or_resource
       when Formula
-        if formula_or_cask.stable
-          urls << formula_or_cask.stable.url
-          urls.concat(formula_or_cask.stable.mirrors)
+        if package_or_resource.stable
+          urls << T.must(package_or_resource.stable).url
+          urls.concat(T.must(package_or_resource.stable).mirrors)
         end
-        urls << formula_or_cask.head.url if formula_or_cask.head
-        urls << formula_or_cask.homepage if formula_or_cask.homepage
+        urls << T.must(package_or_resource.head).url if package_or_resource.head
+        urls << package_or_resource.homepage if package_or_resource.homepage
       when Cask::Cask
-        urls << formula_or_cask.appcast.to_s if formula_or_cask.appcast
-        urls << formula_or_cask.url.to_s if formula_or_cask.url
-        urls << formula_or_cask.homepage if formula_or_cask.homepage
+        urls << package_or_resource.url.to_s if package_or_resource.url
+        urls << package_or_resource.homepage if package_or_resource.homepage
+      when Resource
+        urls << package_or_resource.url
       else
-        T.absurd(formula_or_cask)
+        T.absurd(package_or_resource)
       end
 
       urls.compact.uniq
     end
 
-    # Preprocesses and returns the URL used by livecheck.
-    sig { params(url: String).returns(String) }
-    def preprocess_url(url)
-      begin
-        uri = Addressable::URI.parse url
-      rescue Addressable::URI::InvalidURIError
-        return url
-      end
-
-      host = uri.host
-      domain = uri.domain
-      path = uri.path
-      return url if host.nil? || path.nil?
-
-      domain = host = "github.com" if host == "github.s3.amazonaws.com"
-      path = path.delete_prefix("/").delete_suffix(".git")
-      scheme = uri.scheme
-
-      if domain == "github.com"
-        return url if path.match? %r{/releases/latest/?$}
-
-        owner, repo = path.delete_prefix("downloads/").split("/")
-        url = "#{scheme}://#{host}/#{owner}/#{repo}.git"
-      elsif GITEA_INSTANCES.include?(domain)
-        return url if path.match? %r{/releases/latest/?$}
-
-        owner, repo = path.split("/")
-        url = "#{scheme}://#{host}/#{owner}/#{repo}.git"
-      elsif GOGS_INSTANCES.include?(domain)
-        owner, repo = path.split("/")
-        url = "#{scheme}://#{host}/#{owner}/#{repo}.git"
-      # sourcehut
-      elsif host == "git.sr.ht"
-        owner, repo = path.split("/")
-        url = "#{scheme}://#{host}/#{owner}/#{repo}"
-      # GitLab (gitlab.com or self-hosted)
-      elsif path.include?("/-/archive/")
-        url = url.sub(%r{/-/archive/.*$}i, ".git")
-      end
-
-      url
-    end
-
     # livecheck should fetch a URL using brewed curl if the formula/cask
     # contains a `stable`/`url` or `head` URL `using: :homebrew_curl` that
     # shares the same root domain.
     sig { params(formula_or_cask: T.any(Formula, Cask::Cask), url: String).returns(T::Boolean) }
-    def use_homebrew_curl?(formula_or_cask, url)
+    def self.use_homebrew_curl?(formula_or_cask, url)
       url_root_domain = Addressable::URI.parse(url)&.domain
       return false if url_root_domain.blank?
 
@@ -546,13 +568,13 @@ def use_homebrew_curl?(formula_or_cask, url)
       when Formula
         [:stable, :head].each do |spec_name|
           next unless (spec = formula_or_cask.send(spec_name))
-          next unless spec.using == :homebrew_curl
+          next if spec.using != :homebrew_curl
 
           domain = Addressable::URI.parse(spec.url)&.domain
           homebrew_curl_root_domains << domain if domain.present?
         end
       when Cask::Cask
-        return false unless formula_or_cask.url.using == :homebrew_curl
+        return false if formula_or_cask.url&.using != :homebrew_curl
 
         domain = Addressable::URI.parse(formula_or_cask.url.to_s)&.domain
         homebrew_curl_root_domains << domain if domain.present?
@@ -561,9 +583,8 @@ def use_homebrew_curl?(formula_or_cask, url)
       homebrew_curl_root_domains.include?(url_root_domain)
     end
 
-    # Identifies the latest version of the formula and returns a Hash containing
+    # Identifies the latest version of the formula/cask and returns a Hash containing
     # the version information. Returns nil if a latest version couldn't be found.
-    # rubocop:disable Metrics/CyclomaticComplexity
     sig {
       params(
         formula_or_cask:            T.any(Formula, Cask::Cask),
@@ -573,9 +594,9 @@ def use_homebrew_curl?(formula_or_cask, url)
         full_name:                  T::Boolean,
         verbose:                    T::Boolean,
         debug:                      T::Boolean,
-      ).returns(T.nilable(Hash))
+      ).returns(T.nilable(T::Hash[Symbol, T.untyped]))
     }
-    def latest_version(
+    def self.latest_version(
       formula_or_cask,
       referenced_formula_or_cask: nil,
       livecheck_references: [],
@@ -592,55 +613,54 @@ def latest_version(
       livecheck_regex = livecheck.regex || referenced_livecheck&.regex
       livecheck_strategy = livecheck.strategy || referenced_livecheck&.strategy
       livecheck_strategy_block = livecheck.strategy_block || referenced_livecheck&.strategy_block
+      livecheck_throttle = livecheck.throttle || referenced_livecheck&.throttle
 
-      livecheck_url_string = livecheck_url_to_string(
-        livecheck_url,
-        referenced_formula_or_cask || formula_or_cask,
-      )
+      referenced_package = referenced_formula_or_cask || formula_or_cask
+
+      livecheck_url_string = livecheck_url_to_string(livecheck_url, referenced_package) if livecheck_url
 
       urls = [livecheck_url_string] if livecheck_url_string
-      urls ||= checkable_urls(referenced_formula_or_cask || formula_or_cask)
+      urls ||= checkable_urls(referenced_package)
 
       if debug
         if formula
-          puts "Formula:          #{formula_name(formula, full_name: full_name)}"
+          puts "Formula:          #{formula_name(formula, full_name:)}"
           puts "Head only?:       true" if formula.head_only?
         elsif cask
-          puts "Cask:             #{cask_name(formula_or_cask, full_name: full_name)}"
+          puts "Cask:             #{cask_name(formula_or_cask, full_name:)}"
         end
         puts "Livecheckable?:   #{has_livecheckable ? "Yes" : "No"}"
+        puts "Throttle:         #{livecheck_throttle}" if livecheck_throttle
 
         livecheck_references.each do |ref_formula_or_cask|
           case ref_formula_or_cask
           when Formula
-            puts "Formula Ref:      #{formula_name(ref_formula_or_cask, full_name: full_name)}"
+            puts "Formula Ref:      #{formula_name(ref_formula_or_cask, full_name:)}"
           when Cask::Cask
-            puts "Cask Ref:         #{cask_name(ref_formula_or_cask, full_name: full_name)}"
+            puts "Cask Ref:         #{cask_name(ref_formula_or_cask, full_name:)}"
           end
         end
       end
 
       checked_urls = []
-      # rubocop:disable Metrics/BlockLength
       urls.each_with_index do |original_url, i|
-        # Only preprocess the URL when it's appropriate
-        url = if STRATEGY_SYMBOLS_TO_SKIP_PREPROCESS_URL.include?(livecheck_strategy)
-          original_url
-        else
-          preprocess_url(original_url)
-        end
+        url = original_url
         next if checked_urls.include?(url)
 
         strategies = Strategy.from_url(
           url,
-          livecheck_strategy: livecheck_strategy,
-          url_provided:       livecheck_url.present?,
+          livecheck_strategy:,
           regex_provided:     livecheck_regex.present?,
           block_provided:     livecheck_strategy_block.present?,
         )
         strategy = Strategy.from_symbol(livecheck_strategy) || strategies.first
         strategy_name = livecheck_strategy_names[strategy]
 
+        if strategy.respond_to?(:preprocess_url)
+          url = strategy.preprocess_url(url)
+          next if checked_urls.include?(url)
+        end
+
         if debug
           puts
           if livecheck_url.is_a?(Symbol)
@@ -671,17 +691,23 @@ def latest_version(
 
         homebrew_curl = case strategy_name
         when "PageMatch", "HeaderMatch"
-          use_homebrew_curl?((referenced_formula_or_cask || formula_or_cask), url)
+          use_homebrew_curl?(referenced_package, url)
         end
         puts "Homebrew curl?:   Yes" if debug && homebrew_curl.present?
 
-        strategy_data = strategy.find_versions(
-          url:           url,
+        strategy_args = {
           regex:         livecheck_regex,
-          homebrew_curl: homebrew_curl,
-          cask:          cask,
-          &livecheck_strategy_block
-        )
+          homebrew_curl:,
+        }
+        # TODO: Set `cask`/`url` args based on the presence of the keyword arg
+        # in the strategy's `#find_versions` method once we figure out why
+        # `strategy.method(:find_versions).parameters` isn't working as
+        # expected.
+        strategy_args[:cask] = cask if strategy_name == "ExtractPlist" && cask.present?
+        strategy_args[:url] = url
+        strategy_args.compact!
+
+        strategy_data = strategy.find_versions(**strategy_args, &livecheck_strategy_block)
         match_version_map = strategy_data[:matches]
         regex = strategy_data[:regex]
         messages = strategy_data[:messages]
@@ -691,7 +717,7 @@ def latest_version(
           puts messages unless json
           next if i + 1 < urls.length
 
-          return status_hash(formula_or_cask, "error", messages, full_name: full_name, verbose: verbose)
+          return status_hash(formula_or_cask, "error", messages, full_name:, verbose:)
         end
 
         if debug
@@ -713,7 +739,6 @@ def latest_version(
             version.to_s.include?(rejection)
           end
         end
-
         next if match_version_map.blank?
 
         if debug
@@ -733,6 +758,28 @@ def latest_version(
           latest: Version.new(match_version_map.values.max_by { |v| LivecheckVersion.create(formula_or_cask, v) }),
         }
 
+        if livecheck_throttle
+          match_version_map.keep_if { |_match, version| version.patch.to_i.modulo(livecheck_throttle).zero? }
+          version_info[:latest_throttled] = if match_version_map.blank?
+            nil
+          else
+            Version.new(match_version_map.values.max_by { |v| LivecheckVersion.create(formula_or_cask, v) })
+          end
+
+          if debug
+            puts
+            puts "Matched Throttled Versions:"
+
+            if verbose
+              match_version_map.each do |match, version|
+                puts "#{match} => #{version.inspect}"
+              end
+            else
+              puts match_version_map.values.join(", ")
+            end
+          end
+        end
+
         if json && verbose
           version_info[:meta] = {}
 
@@ -740,9 +787,9 @@ def latest_version(
             version_info[:meta][:references] = livecheck_references.map do |ref_formula_or_cask|
               case ref_formula_or_cask
               when Formula
-                { formula: formula_name(ref_formula_or_cask, full_name: full_name) }
+                { formula: formula_name(ref_formula_or_cask, full_name:) }
               when Cask::Cask
-                { cask: cask_name(ref_formula_or_cask, full_name: full_name) }
+                { cask: cask_name(ref_formula_or_cask, full_name:) }
               end
             end
           end
@@ -761,15 +808,203 @@ def latest_version(
           version_info[:meta][:strategies] = strategies.map { |s| livecheck_strategy_names[s] } if strategies.present?
           version_info[:meta][:regex] = regex.inspect if regex.present?
           version_info[:meta][:cached] = true if strategy_data[:cached] == true
+          version_info[:meta][:throttle] = livecheck_throttle if livecheck_throttle
         end
 
         return version_info
       end
-      # rubocop:enable Metrics/BlockLength
-
       nil
     end
-    # rubocop:enable Metrics/CyclomaticComplexity
+
+    # Identifies the latest version of a resource and returns a Hash containing the
+    # version information. Returns nil if a latest version couldn't be found.
+    sig {
+      params(
+        resource:       Resource,
+        formula_latest: String,
+        json:           T::Boolean,
+        debug:          T::Boolean,
+        quiet:          T::Boolean,
+        verbose:        T::Boolean,
+      ).returns(T::Hash[Symbol, T.untyped])
+    }
+    def self.resource_version(
+      resource,
+      formula_latest,
+      json: false,
+      debug: false,
+      quiet: false,
+      verbose: false
+    )
+      has_livecheckable = resource.livecheckable?
+
+      if debug
+        puts "\n\n"
+        puts "Resource:         #{resource.name}"
+        puts "Livecheckable?:   #{has_livecheckable ? "Yes" : "No"}"
+      end
+
+      resource_version_info = {}
+
+      livecheck = resource.livecheck
+      livecheck_url = livecheck.url
+      livecheck_regex = livecheck.regex
+      livecheck_strategy = livecheck.strategy
+      livecheck_strategy_block = livecheck.strategy_block
+
+      livecheck_url_string = livecheck_url_to_string(livecheck_url, resource) if livecheck_url
+
+      urls = [livecheck_url_string] if livecheck_url_string
+      urls ||= checkable_urls(resource)
+
+      checked_urls = []
+      urls.each_with_index do |original_url, i|
+        url = original_url.gsub(Constants::LATEST_VERSION, formula_latest)
+        next if checked_urls.include?(url)
+
+        strategies = Strategy.from_url(
+          url,
+          livecheck_strategy:,
+          regex_provided:     livecheck_regex.present?,
+          block_provided:     livecheck_strategy_block.present?,
+        )
+        strategy = Strategy.from_symbol(livecheck_strategy) || strategies.first
+        strategy_name = livecheck_strategy_names[strategy]
+
+        if strategy.respond_to?(:preprocess_url)
+          url = strategy.preprocess_url(url)
+          next if checked_urls.include?(url)
+        end
+
+        if debug
+          puts
+          if livecheck_url.is_a?(Symbol)
+            # This assumes the URL symbol will fit within the available space
+            puts "URL (#{livecheck_url}):".ljust(18, " ") + original_url
+          else
+            puts "URL:              #{original_url}"
+          end
+          puts "URL (processed):  #{url}" if url != original_url
+          if strategies.present? && verbose
+            puts "Strategies:       #{strategies.map { |s| livecheck_strategy_names[s] }.join(", ")}"
+          end
+          puts "Strategy:         #{strategy.blank? ? "None" : strategy_name}"
+          puts "Regex:            #{livecheck_regex.inspect}" if livecheck_regex.present?
+        end
+
+        if livecheck_strategy.present?
+          if livecheck_url.blank? && strategy.method(:find_versions).parameters.include?([:keyreq, :url])
+            odebug "#{strategy_name} strategy requires a URL"
+            next
+          elsif livecheck_strategy != :page_match && strategies.exclude?(strategy)
+            odebug "#{strategy_name} strategy does not apply to this URL"
+            next
+          end
+        end
+        puts if debug && strategy.blank?
+        next if strategy.blank?
+
+        strategy_args = {
+          url:,
+          regex:         livecheck_regex,
+          homebrew_curl: false,
+        }.compact
+
+        strategy_data = strategy.find_versions(**strategy_args, &livecheck_strategy_block)
+        match_version_map = strategy_data[:matches]
+        regex = strategy_data[:regex]
+        messages = strategy_data[:messages]
+        checked_urls << url
+
+        if messages.is_a?(Array) && match_version_map.blank?
+          puts messages unless json
+          next if i + 1 < urls.length
+
+          return status_hash(resource, "error", messages, verbose:)
+        end
+
+        if debug
+          if strategy_data[:url].present? && strategy_data[:url] != url
+            puts "URL (strategy):   #{strategy_data[:url]}"
+          end
+          puts "URL (final):      #{strategy_data[:final_url]}" if strategy_data[:final_url].present?
+          if strategy_data[:regex].present? && strategy_data[:regex] != livecheck_regex
+            puts "Regex (strategy): #{strategy_data[:regex].inspect}"
+          end
+          puts "Cached?:          Yes" if strategy_data[:cached] == true
+        end
+
+        match_version_map.delete_if do |_match, version|
+          next true if version.blank?
+          next false if has_livecheckable
+
+          UNSTABLE_VERSION_KEYWORDS.any? do |rejection|
+            version.to_s.include?(rejection)
+          end
+        end
+        next if match_version_map.blank?
+
+        if debug
+          puts
+          puts "Matched Versions:"
+
+          if verbose
+            match_version_map.each do |match, version|
+              puts "#{match} => #{version.inspect}"
+            end
+          else
+            puts match_version_map.values.join(", ")
+          end
+        end
+
+        res_current = T.must(resource.version)
+        res_latest = Version.new(match_version_map.values.max_by { |v| LivecheckVersion.create(resource, v) })
+
+        return status_hash(resource, "error", ["Unable to get versions"], verbose:) if res_latest.blank?
+
+        is_outdated = res_current < res_latest
+        is_newer_than_upstream = res_current > res_latest
+
+        resource_version_info = {
+          resource: resource.name,
+          version:  {
+            current:             res_current.to_s,
+            latest:              res_latest.to_s,
+            outdated:            is_outdated,
+            newer_than_upstream: is_newer_than_upstream,
+          },
+        }
+
+        resource_version_info[:meta] = { livecheckable: has_livecheckable, url: {} }
+        if livecheck_url.is_a?(Symbol) && livecheck_url_string
+          resource_version_info[:meta][:url][:symbol] = livecheck_url
+        end
+        resource_version_info[:meta][:url][:original] = original_url
+        resource_version_info[:meta][:url][:processed] = url if url != original_url
+        if strategy_data[:url].present? && strategy_data[:url] != url
+          resource_version_info[:meta][:url][:strategy] = strategy_data[:url]
+        end
+        resource_version_info[:meta][:url][:final] = strategy_data[:final_url] if strategy_data[:final_url]
+        resource_version_info[:meta][:strategy] = strategy.present? ? strategy_name : nil
+        if strategies.present?
+          resource_version_info[:meta][:strategies] = strategies.map { |s| livecheck_strategy_names[s] }
+        end
+        resource_version_info[:meta][:regex] = regex.inspect if regex.present?
+        resource_version_info[:meta][:cached] = true if strategy_data[:cached] == true
+      rescue => e
+        Homebrew.failed = true
+        if json
+          status_hash(resource, "error", [e.to_s], verbose:)
+        elsif !quiet
+          onoe "#{Tty.blue}#{resource.name}#{Tty.reset}: #{e}"
+          if debug && !e.is_a?(Livecheck::Error)
+            require "utils/backtrace"
+            $stderr.puts Utils::Backtrace.clean(e)
+          end
+          nil
+        end
+      end
+      resource_version_info
+    end
   end
-  # rubocop:enable Metrics/ModuleLength
 end
diff --git a/Library/Homebrew/livecheck/livecheck.rbi b/Library/Homebrew/livecheck/livecheck.rbi
deleted file mode 100644
index b47d360b8055c..0000000000000
--- a/Library/Homebrew/livecheck/livecheck.rbi
+++ /dev/null
@@ -1,11 +0,0 @@
-# typed: strict
-
-module Homebrew
-  module Livecheck
-    include ::Kernel
-
-    module SkipConditions
-      include ::Kernel
-    end
-  end
-end
diff --git a/Library/Homebrew/livecheck/livecheck_version.rb b/Library/Homebrew/livecheck/livecheck_version.rb
index 80336076e755a..8c06b80722e2d 100644
--- a/Library/Homebrew/livecheck/livecheck_version.rb
+++ b/Library/Homebrew/livecheck/livecheck_version.rb
@@ -4,22 +4,20 @@
 module Homebrew
   module Livecheck
     # A formula or cask version, split into its component sub-versions.
-    #
-    # @api private
     class LivecheckVersion
-      extend T::Sig
-
       include Comparable
 
-      sig { params(formula_or_cask: T.any(Formula, Cask::Cask), version: Version).returns(LivecheckVersion) }
-      def self.create(formula_or_cask, version)
-        versions = case formula_or_cask
-        when Formula
+      sig {
+        params(package_or_resource: T.any(Formula, Cask::Cask, Resource), version: Version).returns(LivecheckVersion)
+      }
+      def self.create(package_or_resource, version)
+        versions = case package_or_resource
+        when Formula, Resource
           [version]
         when Cask::Cask
-          version.to_s.split(/[,:]/).map { |s| Version.new(s) }
+          version.to_s.split(",").map { |s| Version.new(s) }
         else
-          T.absurd(formula_or_cask)
+          T.absurd(package_or_resource)
         end
         new(versions)
       end
diff --git a/Library/Homebrew/livecheck/skip_conditions.rb b/Library/Homebrew/livecheck/skip_conditions.rb
index f5d2f0835853b..e8fc9a9ebd83e 100644
--- a/Library/Homebrew/livecheck/skip_conditions.rb
+++ b/Library/Homebrew/livecheck/skip_conditions.rb
@@ -1,29 +1,26 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "livecheck/livecheck"
-
 module Homebrew
   module Livecheck
     # The `Livecheck::SkipConditions` module primarily contains methods that
-    # check for various formula/cask conditions where a check should be skipped.
-    #
-    # @api private
+    # check for various formula/cask/resource conditions where a check should be skipped.
     module SkipConditions
-      extend T::Sig
-
-      module_function
-
       sig {
         params(
-          formula_or_cask: T.any(Formula, Cask::Cask),
-          livecheckable:   T::Boolean,
-          full_name:       T::Boolean,
-          verbose:         T::Boolean,
-        ).returns(Hash)
+          package_or_resource: T.any(Formula, Cask::Cask, Resource),
+          livecheckable:       T::Boolean,
+          full_name:           T::Boolean,
+          verbose:             T::Boolean,
+        ).returns(T::Hash[Symbol, T.untyped])
       }
-      def formula_or_cask_skip(formula_or_cask, livecheckable, full_name: false, verbose: false)
-        formula = formula_or_cask if formula_or_cask.is_a?(Formula)
+      private_class_method def self.package_or_resource_skip(
+        package_or_resource,
+        livecheckable,
+        full_name: false,
+        verbose: false
+      )
+        formula = package_or_resource if package_or_resource.is_a?(Formula)
 
         if (stable_url = formula&.stable&.url)
           stable_is_gist = stable_url.match?(%r{https?://gist\.github(?:usercontent)?\.com/}i)
@@ -33,8 +30,8 @@ def formula_or_cask_skip(formula_or_cask, livecheckable, full_name: false, verbo
           stable_from_internet_archive = stable_url.match?(%r{https?://web\.archive\.org/}i)
         end
 
-        skip_message = if formula_or_cask.livecheck.skip_msg.present?
-          formula_or_cask.livecheck.skip_msg
+        skip_message = if package_or_resource.livecheck.skip_msg.present?
+          package_or_resource.livecheck.skip_msg
         elsif !livecheckable
           if stable_from_google_code_archive
             "Stable URL is from Google Code Archive"
@@ -45,10 +42,10 @@ def formula_or_cask_skip(formula_or_cask, livecheckable, full_name: false, verbo
           end
         end
 
-        return {} if !formula_or_cask.livecheck.skip? && skip_message.blank?
+        return {} if !package_or_resource.livecheck.skip? && skip_message.blank?
 
         skip_messages = skip_message ? [skip_message] : nil
-        Livecheck.status_hash(formula_or_cask, "skipped", skip_messages, full_name: full_name, verbose: verbose)
+        Livecheck.status_hash(package_or_resource, "skipped", skip_messages, full_name:, verbose:)
       end
 
       sig {
@@ -57,17 +54,17 @@ def formula_or_cask_skip(formula_or_cask, livecheckable, full_name: false, verbo
           _livecheckable: T::Boolean,
           full_name:      T::Boolean,
           verbose:        T::Boolean,
-        ).returns(Hash)
+        ).returns(T::Hash[Symbol, T.untyped])
       }
-      def formula_head_only(formula, _livecheckable, full_name: false, verbose: false)
+      private_class_method def self.formula_head_only(formula, _livecheckable, full_name: false, verbose: false)
         return {} if !formula.head_only? || formula.any_version_installed?
 
         Livecheck.status_hash(
           formula,
           "error",
           ["HEAD only formula must be installed to be livecheckable"],
-          full_name: full_name,
-          verbose:   verbose,
+          full_name:,
+          verbose:,
         )
       end
 
@@ -77,12 +74,12 @@ def formula_head_only(formula, _livecheckable, full_name: false, verbose: false)
           livecheckable: T::Boolean,
           full_name:     T::Boolean,
           verbose:       T::Boolean,
-        ).returns(Hash)
+        ).returns(T::Hash[Symbol, T.untyped])
       }
-      def formula_deprecated(formula, livecheckable, full_name: false, verbose: false)
+      private_class_method def self.formula_deprecated(formula, livecheckable, full_name: false, verbose: false)
         return {} if !formula.deprecated? || livecheckable
 
-        Livecheck.status_hash(formula, "deprecated", full_name: full_name, verbose: verbose)
+        Livecheck.status_hash(formula, "deprecated", full_name:, verbose:)
       end
 
       sig {
@@ -91,12 +88,12 @@ def formula_deprecated(formula, livecheckable, full_name: false, verbose: false)
           livecheckable: T::Boolean,
           full_name:     T::Boolean,
           verbose:       T::Boolean,
-        ).returns(Hash)
+        ).returns(T::Hash[Symbol, T.untyped])
       }
-      def formula_disabled(formula, livecheckable, full_name: false, verbose: false)
+      private_class_method def self.formula_disabled(formula, livecheckable, full_name: false, verbose: false)
         return {} if !formula.disabled? || livecheckable
 
-        Livecheck.status_hash(formula, "disabled", full_name: full_name, verbose: verbose)
+        Livecheck.status_hash(formula, "disabled", full_name:, verbose:)
       end
 
       sig {
@@ -105,12 +102,12 @@ def formula_disabled(formula, livecheckable, full_name: false, verbose: false)
           livecheckable: T::Boolean,
           full_name:     T::Boolean,
           verbose:       T::Boolean,
-        ).returns(Hash)
+        ).returns(T::Hash[Symbol, T.untyped])
       }
-      def formula_versioned(formula, livecheckable, full_name: false, verbose: false)
+      private_class_method def self.formula_versioned(formula, livecheckable, full_name: false, verbose: false)
         return {} if !formula.versioned_formula? || livecheckable
 
-        Livecheck.status_hash(formula, "versioned", full_name: full_name, verbose: verbose)
+        Livecheck.status_hash(formula, "versioned", full_name:, verbose:)
       end
 
       sig {
@@ -119,12 +116,12 @@ def formula_versioned(formula, livecheckable, full_name: false, verbose: false)
           livecheckable: T::Boolean,
           full_name:     T::Boolean,
           verbose:       T::Boolean,
-        ).returns(Hash)
+        ).returns(T::Hash[Symbol, T.untyped])
       }
-      def cask_discontinued(cask, livecheckable, full_name: false, verbose: false)
-        return {} if !cask.discontinued? || livecheckable
+      private_class_method def self.cask_deprecated(cask, livecheckable, full_name: false, verbose: false)
+        return {} if !cask.deprecated? || livecheckable
 
-        Livecheck.status_hash(cask, "discontinued", full_name: full_name, verbose: verbose)
+        Livecheck.status_hash(cask, "deprecated", full_name:, verbose:)
       end
 
       sig {
@@ -133,12 +130,53 @@ def cask_discontinued(cask, livecheckable, full_name: false, verbose: false)
           livecheckable: T::Boolean,
           full_name:     T::Boolean,
           verbose:       T::Boolean,
-        ).returns(Hash)
+        ).returns(T::Hash[Symbol, T.untyped])
       }
-      def cask_version_latest(cask, livecheckable, full_name: false, verbose: false)
+      private_class_method def self.cask_disabled(cask, livecheckable, full_name: false, verbose: false)
+        return {} if !cask.disabled? || livecheckable
+
+        Livecheck.status_hash(cask, "disabled", full_name:, verbose:)
+      end
+
+      sig {
+        params(
+          cask:           Cask::Cask,
+          _livecheckable: T::Boolean,
+          full_name:      T::Boolean,
+          verbose:        T::Boolean,
+          extract_plist:  T::Boolean,
+        ).returns(T::Hash[Symbol, T.untyped])
+      }
+      private_class_method def self.cask_extract_plist(
+        cask,
+        _livecheckable,
+        full_name: false,
+        verbose: false,
+        extract_plist: false
+      )
+        return {} if extract_plist || cask.livecheck.strategy != :extract_plist
+
+        Livecheck.status_hash(
+          cask,
+          "skipped",
+          ["Use `--extract-plist` to enable checking multiple casks with ExtractPlist strategy"],
+          full_name:,
+          verbose:,
+        )
+      end
+
+      sig {
+        params(
+          cask:          Cask::Cask,
+          livecheckable: T::Boolean,
+          full_name:     T::Boolean,
+          verbose:       T::Boolean,
+        ).returns(T::Hash[Symbol, T.untyped])
+      }
+      private_class_method def self.cask_version_latest(cask, livecheckable, full_name: false, verbose: false)
         return {} if !(cask.present? && cask.version&.latest?) || livecheckable
 
-        Livecheck.status_hash(cask, "latest", full_name: full_name, verbose: verbose)
+        Livecheck.status_hash(cask, "latest", full_name:, verbose:)
       end
 
       sig {
@@ -147,95 +185,117 @@ def cask_version_latest(cask, livecheckable, full_name: false, verbose: false)
           livecheckable: T::Boolean,
           full_name:     T::Boolean,
           verbose:       T::Boolean,
-        ).returns(Hash)
+        ).returns(T::Hash[Symbol, T.untyped])
       }
-      def cask_url_unversioned(cask, livecheckable, full_name: false, verbose: false)
+      private_class_method def self.cask_url_unversioned(cask, livecheckable, full_name: false, verbose: false)
         return {} if !(cask.present? && cask.url&.unversioned?) || livecheckable
 
-        Livecheck.status_hash(cask, "unversioned", full_name: full_name, verbose: verbose)
+        Livecheck.status_hash(cask, "unversioned", full_name:, verbose:)
       end
 
       # Skip conditions for formulae.
-      FORMULA_CHECKS = [
-        :formula_or_cask_skip,
+      FORMULA_CHECKS = T.let([
+        :package_or_resource_skip,
         :formula_head_only,
         :formula_deprecated,
         :formula_disabled,
         :formula_versioned,
-      ].freeze
+      ].freeze, T::Array[Symbol])
+      private_constant :FORMULA_CHECKS
 
       # Skip conditions for casks.
-      CASK_CHECKS = [
-        :formula_or_cask_skip,
-        :cask_discontinued,
+      CASK_CHECKS = T.let([
+        :package_or_resource_skip,
+        :cask_deprecated,
+        :cask_disabled,
+        :cask_extract_plist,
         :cask_version_latest,
         :cask_url_unversioned,
-      ].freeze
+      ].freeze, T::Array[Symbol])
+      private_constant :CASK_CHECKS
 
-      # If a formula/cask should be skipped, we return a hash from
+      # Skip conditions for resources.
+      RESOURCE_CHECKS = T.let([
+        :package_or_resource_skip,
+      ].freeze, T::Array[Symbol])
+      private_constant :RESOURCE_CHECKS
+
+      # If a formula/cask/resource should be skipped, we return a hash from
       # `Livecheck#status_hash`, which contains a `status` type and sometimes
       # error `messages`.
       sig {
         params(
-          formula_or_cask: T.any(Formula, Cask::Cask),
-          full_name:       T::Boolean,
-          verbose:         T::Boolean,
-        ).returns(Hash)
+          package_or_resource: T.any(Formula, Cask::Cask, Resource),
+          full_name:           T::Boolean,
+          verbose:             T::Boolean,
+          extract_plist:       T::Boolean,
+        ).returns(T::Hash[Symbol, T.untyped])
       }
-      def skip_information(formula_or_cask, full_name: false, verbose: false)
-        livecheckable = formula_or_cask.livecheckable?
+      def self.skip_information(package_or_resource, full_name: false, verbose: false, extract_plist: true)
+        livecheckable = package_or_resource.livecheckable?
 
-        checks = case formula_or_cask
+        checks = case package_or_resource
         when Formula
           FORMULA_CHECKS
         when Cask::Cask
           CASK_CHECKS
+        when Resource
+          RESOURCE_CHECKS
         end
-        return {} unless checks
 
         checks.each do |method_name|
-          skip_hash = send(method_name, formula_or_cask, livecheckable, full_name: full_name, verbose: verbose)
+          skip_hash = case method_name
+          when :cask_extract_plist
+            send(method_name, package_or_resource, livecheckable, full_name:, verbose:, extract_plist:)
+          else
+            send(method_name, package_or_resource, livecheckable, full_name:, verbose:)
+          end
           return skip_hash if skip_hash.present?
         end
 
         {}
       end
 
-      # Skip conditions for formulae/casks referenced in a `livecheck` block
+      # Skip conditions for formulae/casks/resources referenced in a `livecheck` block
       # are treated differently than normal. We only respect certain skip
       # conditions (returning the related hash) and others are treated as
       # errors.
       sig {
         params(
-          livecheck_formula_or_cask:     T.any(Formula, Cask::Cask),
-          original_formula_or_cask_name: String,
-          full_name:                     T::Boolean,
-          verbose:                       T::Boolean,
-        ).returns(T.nilable(Hash))
+          livecheck_package_or_resource:     T.any(Formula, Cask::Cask, Resource),
+          original_package_or_resource_name: String,
+          full_name:                         T::Boolean,
+          verbose:                           T::Boolean,
+          extract_plist:                     T::Boolean,
+        ).returns(T.nilable(T::Hash[Symbol, T.untyped]))
       }
-      def referenced_skip_information(
-        livecheck_formula_or_cask,
-        original_formula_or_cask_name,
+      def self.referenced_skip_information(
+        livecheck_package_or_resource,
+        original_package_or_resource_name,
         full_name: false,
-        verbose: false
+        verbose: false,
+        extract_plist: true
       )
         skip_info = SkipConditions.skip_information(
-          livecheck_formula_or_cask,
-          full_name: full_name,
-          verbose:   verbose,
+          livecheck_package_or_resource,
+          full_name:,
+          verbose:,
+          extract_plist:,
         )
         return if skip_info.blank?
 
-        referenced_name = Livecheck.formula_or_cask_name(livecheck_formula_or_cask, full_name: full_name)
-        referenced_type = case livecheck_formula_or_cask
+        referenced_name = Livecheck.package_or_resource_name(livecheck_package_or_resource, full_name:)
+        referenced_type = case livecheck_package_or_resource
         when Formula
           :formula
         when Cask::Cask
           :cask
+        when Resource
+          :resource
         end
 
         if skip_info[:status] != "error" &&
-           !(skip_info[:status] == "skipped" && livecheck_formula_or_cask.livecheck.skip?)
+           !(skip_info[:status] == "skipped" && livecheck_package_or_resource.livecheck.skip?)
           error_msg_end = if skip_info[:status] == "skipped"
             "automatically skipped"
           else
@@ -245,19 +305,21 @@ def referenced_skip_information(
           raise "Referenced #{referenced_type} (#{referenced_name}) is #{error_msg_end}"
         end
 
-        skip_info[referenced_type] = original_formula_or_cask_name
+        skip_info[referenced_type] = original_package_or_resource_name
         skip_info
       end
 
       # Prints default livecheck output in relation to skip conditions.
-      sig { params(skip_hash: Hash).void }
-      def print_skip_information(skip_hash)
+      sig { params(skip_hash: T::Hash[Symbol, T.untyped]).void }
+      def self.print_skip_information(skip_hash)
         return unless skip_hash.is_a?(Hash)
 
         name = if skip_hash[:formula].is_a?(String)
           skip_hash[:formula]
         elsif skip_hash[:cask].is_a?(String)
           skip_hash[:cask]
+        elsif skip_hash[:resource].is_a?(String)
+          "  #{skip_hash[:resource]}"
         end
         return unless name
 
diff --git a/Library/Homebrew/livecheck/strategy.rb b/Library/Homebrew/livecheck/strategy.rb
index baa2eea270753..be885df754c58 100644
--- a/Library/Homebrew/livecheck/strategy.rb
+++ b/Library/Homebrew/livecheck/strategy.rb
@@ -1,16 +1,16 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "utils/curl"
+
 module Homebrew
   module Livecheck
     # The `Livecheck::Strategy` module contains the various strategies as well
     # as some general-purpose methods for working with them. Within the context
     # of the `brew livecheck` command, strategies are established procedures
     # for finding new software versions at a given source.
-    #
-    # @api private
     module Strategy
-      extend T::Sig
+      extend Utils::Curl
 
       module_function
 
@@ -27,13 +27,13 @@ module Strategy
 
       # cURL does not set a default `--max-time` value, so we provide a value
       # to ensure cURL will time out in a reasonable amount of time.
-      CURL_MAX_TIME = CURL_CONNECT_TIMEOUT + 5
+      CURL_MAX_TIME = T.let(CURL_CONNECT_TIMEOUT + 5, Integer)
 
       # The `curl` process will sometimes hang indefinitely (despite setting
       # the `--max-time` argument) and it needs to be quit for livecheck to
       # continue. This value is used to set the `timeout` argument on
       # `Utils::Curl` method calls in {Strategy}.
-      CURL_PROCESS_TIMEOUT = CURL_MAX_TIME + 5
+      CURL_PROCESS_TIMEOUT = T.let(CURL_MAX_TIME + 5, Integer)
 
       # The maximum number of redirections that `curl` should allow.
       MAX_REDIRECTIONS = 5
@@ -43,36 +43,31 @@ module Strategy
       # number of responses in this context. The `+ 1` here accounts for the
       # situation where there are exactly `MAX_REDIRECTIONS` number of
       # redirections, followed by a final `200 OK` response.
-      MAX_PARSE_ITERATIONS = MAX_REDIRECTIONS + 1
+      MAX_PARSE_ITERATIONS = T.let(MAX_REDIRECTIONS + 1, Integer)
 
       # Baseline `curl` arguments used in {Strategy} methods.
-      DEFAULT_CURL_ARGS = [
+      DEFAULT_CURL_ARGS = T.let([
         # Follow redirections to handle mirrors, relocations, etc.
         "--location",
         "--max-redirs", MAX_REDIRECTIONS.to_s,
         # Avoid progress bar text, so we can reliably identify `curl` error
         # messages in output
         "--silent"
-      ].freeze
-
-      # `curl` arguments used in `Strategy#page_headers` method.
-      PAGE_HEADERS_CURL_ARGS = ([
-        # We only need the response head (not the body)
-        "--head",
-        # Some servers may not allow a HEAD request, so we use GET
-        "--request", "GET"
-      ] + DEFAULT_CURL_ARGS).freeze
+      ].freeze, T::Array[String])
 
       # `curl` arguments used in `Strategy#page_content` method.
-      PAGE_CONTENT_CURL_ARGS = ([
+      PAGE_CONTENT_CURL_ARGS = T.let(([
         "--compressed",
+        # Return an error when the HTTP response code is 400 or greater but
+        # continue to return body content
+        "--fail-with-body",
         # Include HTTP response headers in output, so we can identify the
         # final URL after any redirections
         "--include",
-      ] + DEFAULT_CURL_ARGS).freeze
+      ] + DEFAULT_CURL_ARGS).freeze, T::Array[String])
 
       # Baseline `curl` options used in {Strategy} methods.
-      DEFAULT_CURL_OPTIONS = {
+      DEFAULT_CURL_OPTIONS = T.let({
         print_stdout:    false,
         print_stderr:    false,
         debug:           false,
@@ -81,7 +76,7 @@ module Strategy
         connect_timeout: CURL_CONNECT_TIMEOUT,
         max_time:        CURL_MAX_TIME,
         retries:         0,
-      }.freeze
+      }.freeze, T::Hash[Symbol, T.untyped])
 
       # A regex used to identify a tarball extension at the end of a string.
       TARBALL_EXTENSION_REGEX = /
@@ -89,7 +84,7 @@ module Strategy
         (?:ar(?:\.(?:bz2|gz|lz|lzma|lzo|xz|Z|zst))?|
         b2|bz2?|z2|az|gz|lz|lzma|xz|Z|aZ|zst)
         $
-      /ix.freeze
+      /ix
 
       # An error message to use when a `strategy` block returns a value of
       # an inappropriate type.
@@ -104,17 +99,13 @@ module Strategy
       # @return [Hash]
       sig { returns(T::Hash[Symbol, T.untyped]) }
       def strategies
-        return @strategies if defined? @strategies
-
-        @strategies = {}
-        Strategy.constants.sort.each do |const_symbol|
+        @strategies ||= T.let(Strategy.constants.sort.each_with_object({}) do |const_symbol, hash|
           constant = Strategy.const_get(const_symbol)
           next unless constant.is_a?(Class)
 
-          key = const_symbol.to_s.underscore.to_sym
-          @strategies[key] = constant
-        end
-        @strategies
+          key = Utils.underscore(const_symbol).to_sym
+          hash[key] = constant
+        end, T.nilable(T::Hash[Symbol, T.untyped]))
       end
       private_class_method :strategies
 
@@ -134,8 +125,6 @@ def from_symbol(symbol)
       # @param url [String] the URL to check for matching strategies
       # @param livecheck_strategy [Symbol] a strategy symbol from the
       #   `livecheck` block
-      # @param url_provided [Boolean] whether a url is provided in the
-      #   `livecheck` block
       # @param regex_provided [Boolean] whether a regex is provided in the
       #   `livecheck` block
       # @param block_provided [Boolean] whether a `strategy` block is provided
@@ -145,32 +134,35 @@ def from_symbol(symbol)
         params(
           url:                String,
           livecheck_strategy: T.nilable(Symbol),
-          url_provided:       T::Boolean,
           regex_provided:     T::Boolean,
           block_provided:     T::Boolean,
         ).returns(T::Array[T.untyped])
       }
-      def from_url(url, livecheck_strategy: nil, url_provided: false, regex_provided: false, block_provided: false)
-        usable_strategies = strategies.values.select do |strategy|
+      def from_url(url, livecheck_strategy: nil, regex_provided: false, block_provided: false)
+        usable_strategies = strategies.select do |strategy_symbol, strategy|
           if strategy == PageMatch
-            # Only treat the `PageMatch` strategy as usable if a regex is
-            # present in the `livecheck` block
+            # Only treat the strategy as usable if the `livecheck` block
+            # contains a regex and/or `strategy` block
             next if !regex_provided && !block_provided
+          elsif [Json, Xml, Yaml].include?(strategy)
+            # Only treat the strategy as usable if the `livecheck` block
+            # specifies the strategy and contains a `strategy` block
+            next if (livecheck_strategy != strategy_symbol) || !block_provided
           elsif strategy.const_defined?(:PRIORITY) &&
-                !strategy::PRIORITY.positive? &&
-                from_symbol(livecheck_strategy) != strategy
+                !strategy.const_get(:PRIORITY).positive? &&
+                livecheck_strategy != strategy_symbol
             # Ignore strategies with a priority of 0 or lower, unless the
             # strategy is specified in the `livecheck` block
             next
           end
 
           strategy.respond_to?(:match?) && strategy.match?(url)
-        end
+        end.values
 
         # Sort usable strategies in descending order by priority, using the
         # DEFAULT_PRIORITY when a strategy doesn't contain a PRIORITY constant
         usable_strategies.sort_by do |strategy|
-          (strategy.const_defined?(:PRIORITY) ? -strategy::PRIORITY : -DEFAULT_PRIORITY)
+          (strategy.const_defined?(:PRIORITY) ? -strategy.const_get(:PRIORITY) : -DEFAULT_PRIORITY)
         end
       end
 
@@ -186,15 +178,20 @@ def self.page_headers(url, homebrew_curl: false)
         headers = []
 
         [:default, :browser].each do |user_agent|
-          output, _, status = curl_with_workarounds(
-            *PAGE_HEADERS_CURL_ARGS, url,
-            **DEFAULT_CURL_OPTIONS,
-            use_homebrew_curl: homebrew_curl,
-            user_agent:        user_agent
-          )
-          next unless status.success?
+          begin
+            parsed_output = curl_headers(
+              "--max-redirs",
+              MAX_REDIRECTIONS.to_s,
+              url,
+              wanted_headers:    ["location", "content-disposition"],
+              use_homebrew_curl: homebrew_curl,
+              user_agent:,
+              **DEFAULT_CURL_OPTIONS,
+            )
+          rescue ErrorDuringExecution
+            next
+          end
 
-          parsed_output = parse_curl_output(output, max_iterations: MAX_PARSE_ITERATIONS)
           parsed_output[:responses].each { |response| headers << response[:headers] }
           break if headers.present?
         end
@@ -212,13 +209,13 @@ def self.page_headers(url, homebrew_curl: false)
       # @return [Hash]
       sig { params(url: String, homebrew_curl: T::Boolean).returns(T::Hash[Symbol, T.untyped]) }
       def self.page_content(url, homebrew_curl: false)
-        stderr = nil
+        stderr = T.let(nil, T.nilable(String))
         [:default, :browser].each do |user_agent|
-          stdout, stderr, status = curl_with_workarounds(
+          stdout, stderr, status = curl_output(
             *PAGE_CONTENT_CURL_ARGS, url,
             **DEFAULT_CURL_OPTIONS,
-            use_homebrew_curl: homebrew_curl,
-            user_agent:        user_agent
+            use_homebrew_curl: homebrew_curl || !curl_supports_fail_with_body?,
+            user_agent:
           )
           next unless status.success?
 
@@ -265,18 +262,23 @@ def self.handle_block_return(value)
 require_relative "strategy/apache"
 require_relative "strategy/bitbucket"
 require_relative "strategy/cpan"
+require_relative "strategy/crate"
 require_relative "strategy/electron_builder"
 require_relative "strategy/extract_plist"
 require_relative "strategy/git"
 require_relative "strategy/github_latest"
+require_relative "strategy/github_releases"
 require_relative "strategy/gnome"
 require_relative "strategy/gnu"
 require_relative "strategy/hackage"
 require_relative "strategy/header_match"
+require_relative "strategy/json"
 require_relative "strategy/launchpad"
 require_relative "strategy/npm"
 require_relative "strategy/page_match"
 require_relative "strategy/pypi"
 require_relative "strategy/sourceforge"
 require_relative "strategy/sparkle"
+require_relative "strategy/xml"
 require_relative "strategy/xorg"
+require_relative "strategy/yaml"
diff --git a/Library/Homebrew/livecheck/strategy/apache.rb b/Library/Homebrew/livecheck/strategy/apache.rb
index fd77fda4ca8b0..9c3554d3983a0 100644
--- a/Library/Homebrew/livecheck/strategy/apache.rb
+++ b/Library/Homebrew/livecheck/strategy/apache.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -26,8 +26,6 @@ module Strategy
       #
       # @api public
       class Apache
-        extend T::Sig
-
         # The `Regexp` used to determine if the strategy applies to the URL.
         URL_MATCH_REGEX = %r{
           ^https?://
@@ -39,7 +37,7 @@ class Apache
           (?<prefix>[^/]*?)  # Any text in filename or directory before version
           v?\d+(?:\.\d+)+    # The numeric version
           (?<suffix>/|[^/]*) # Any text in filename or directory after version
-        }ix.freeze
+        }ix
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -70,7 +68,7 @@ def self.generate_input_values(url)
           regex_prefix = Regexp.escape(match[:prefix] || "").gsub("\\-", "-")
 
           # Use `\.t` instead of specific tarball extensions (e.g. .tar.gz)
-          suffix = match[:suffix]&.sub(Strategy::TARBALL_EXTENSION_REGEX, "\.t")
+          suffix = match[:suffix]&.sub(Strategy::TARBALL_EXTENSION_REGEX, ".t")
           regex_suffix = Regexp.escape(suffix || "").gsub("\\-", "-")
 
           # Example directory regex: `%r{href=["']?v?(\d+(?:\.\d+)+)/}i`
@@ -92,14 +90,14 @@ def self.generate_input_values(url)
           params(
             url:    String,
             regex:  T.nilable(Regexp),
-            unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:  T.untyped,
+            unused: T.untyped,
+            block:  T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url:, regex: nil, **unused, &block)
           generated = generate_input_values(url)
 
-          T.unsafe(PageMatch).find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
+          PageMatch.find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/bitbucket.rb b/Library/Homebrew/livecheck/strategy/bitbucket.rb
index 0d4fef5a55cd5..56a53b18c579b 100644
--- a/Library/Homebrew/livecheck/strategy/bitbucket.rb
+++ b/Library/Homebrew/livecheck/strategy/bitbucket.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -28,8 +28,6 @@ module Strategy
       #
       # @api public
       class Bitbucket
-        extend T::Sig
-
         # The `Regexp` used to determine if the strategy applies to the URL.
         URL_MATCH_REGEX = %r{
           ^https?://bitbucket\.org
@@ -38,7 +36,7 @@ class Bitbucket
           /(?<prefix>(?:[^/]+?[_-])?) # Filename text before the version
           v?\d+(?:\.\d+)+ # The numeric version
           (?<suffix>[^/]+) # Filename text after the version
-        }ix.freeze
+        }ix
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -63,24 +61,29 @@ def self.generate_input_values(url)
           match = url.match(URL_MATCH_REGEX)
           return values if match.blank?
 
+          regex_prefix = Regexp.escape(T.must(match[:prefix])).gsub("\\-", "-")
+
           # `/get/` archives are Git tag snapshots, so we need to check that tab
           # instead of the main `/downloads/` page
-          values[:url] = if match[:dl_type] == "get"
-            "https://bitbucket.org/#{match[:path]}/downloads/?tab=tags"
-          else
-            "https://bitbucket.org/#{match[:path]}/downloads/"
-          end
+          if match[:dl_type] == "get"
+            values[:url] = "https://bitbucket.org/#{match[:path]}/downloads/?tab=tags"
 
-          regex_prefix = Regexp.escape(T.must(match[:prefix])).gsub("\\-", "-")
+            # Example tag regexes:
+            # * `/<td[^>]*?class="name"[^>]*?>\s*v?(\d+(?:\.\d+)+)\s*?</im`
+            # * `/<td[^>]*?class="name"[^>]*?>\s*abc-v?(\d+(?:\.\d+)+)\s*?</im`
+            values[:regex] = /<td[^>]*?class="name"[^>]*?>\s*#{regex_prefix}v?(\d+(?:\.\d+)+)\s*?</im
+          else
+            values[:url] = "https://bitbucket.org/#{match[:path]}/downloads/"
 
-          # Use `\.t` instead of specific tarball extensions (e.g. .tar.gz)
-          suffix = T.must(match[:suffix]).sub(Strategy::TARBALL_EXTENSION_REGEX, "\.t")
-          regex_suffix = Regexp.escape(suffix).gsub("\\-", "-")
+            # Use `\.t` instead of specific tarball extensions (e.g. .tar.gz)
+            suffix = T.must(match[:suffix]).sub(Strategy::TARBALL_EXTENSION_REGEX, ".t")
+            regex_suffix = Regexp.escape(suffix).gsub("\\-", "-")
 
-          # Example regexes:
-          # * `/href=.*?v?(\d+(?:\.\d+)+)\.t/i`
-          # * `/href=.*?example-v?(\d+(?:\.\d+)+)\.t/i`
-          values[:regex] = /href=.*?#{regex_prefix}v?(\d+(?:\.\d+)+)#{regex_suffix}/i
+            # Example file regexes:
+            # * `/href=.*?v?(\d+(?:\.\d+)+)\.t/i`
+            # * `/href=.*?abc-v?(\d+(?:\.\d+)+)\.t/i`
+            values[:regex] = /href=.*?#{regex_prefix}v?(\d+(?:\.\d+)+)#{regex_suffix}/i
+          end
 
           values
         end
@@ -95,14 +98,14 @@ def self.generate_input_values(url)
           params(
             url:    String,
             regex:  T.nilable(Regexp),
-            unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:  T.untyped,
+            unused: T.untyped,
+            block:  T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url:, regex: nil, **unused, &block)
           generated = generate_input_values(url)
 
-          T.unsafe(PageMatch).find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
+          PageMatch.find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/cpan.rb b/Library/Homebrew/livecheck/strategy/cpan.rb
index 84e58e83539e6..828e4034d3384 100644
--- a/Library/Homebrew/livecheck/strategy/cpan.rb
+++ b/Library/Homebrew/livecheck/strategy/cpan.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -18,8 +18,6 @@ module Strategy
       #
       # @api public
       class Cpan
-        extend T::Sig
-
         NICE_NAME = "CPAN"
 
         # The `Regexp` used to determine if the strategy applies to the URL.
@@ -29,7 +27,7 @@ class Cpan
           (?<prefix>[^/]+) # Filename text before the version
           -v?\d+(?:\.\d+)* # The numeric version
           (?<suffix>[^/]+) # Filename text after the version
-        }ix.freeze
+        }ix
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -60,7 +58,7 @@ def self.generate_input_values(url)
           regex_prefix = Regexp.escape(T.must(match[:prefix])).gsub("\\-", "-")
 
           # Use `\.t` instead of specific tarball extensions (e.g. .tar.gz)
-          suffix = T.must(match[:suffix]).sub(Strategy::TARBALL_EXTENSION_REGEX, "\.t")
+          suffix = T.must(match[:suffix]).sub(Strategy::TARBALL_EXTENSION_REGEX, ".t")
           regex_suffix = Regexp.escape(suffix).gsub("\\-", "-")
 
           # Example regex: `/href=.*?Brew[._-]v?(\d+(?:\.\d+)*)\.t/i`
@@ -79,14 +77,14 @@ def self.generate_input_values(url)
           params(
             url:    String,
             regex:  T.nilable(Regexp),
-            unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:  T.untyped,
+            unused: T.untyped,
+            block:  T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url:, regex: nil, **unused, &block)
           generated = generate_input_values(url)
 
-          T.unsafe(PageMatch).find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
+          PageMatch.find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/crate.rb b/Library/Homebrew/livecheck/strategy/crate.rb
new file mode 100644
index 0000000000000..7c6f942353b35
--- /dev/null
+++ b/Library/Homebrew/livecheck/strategy/crate.rb
@@ -0,0 +1,114 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  module Livecheck
+    module Strategy
+      # The {Crate} strategy identifies versions of a Rust crate by checking
+      # the information from the `versions` API endpoint.
+      #
+      # Crate URLs have the following format:
+      #   `https://static.crates.io/crates/example/example-1.2.3.crate`
+      #
+      # The default regex identifies versions like `1.2.3`/`v1.2.3` from the
+      # version `num` field. This is a common version format but a different
+      # regex can be provided in a `livecheck` block to override the default
+      # if a package uses a different format (e.g. `1.2.3d`, `1.2.3-4`, etc.).
+      #
+      # @api public
+      class Crate
+        # The default regex used to identify versions when a regex isn't
+        # provided.
+        DEFAULT_REGEX = /^v?(\d+(?:\.\d+)+)$/i
+
+        # The default `strategy` block used to extract version information when
+        # a `strategy` block isn't provided.
+        DEFAULT_BLOCK = T.let(proc do |json, regex|
+          json["versions"]&.map do |version|
+            next if version["yanked"]
+            next unless (match = version["num"]&.match(regex))
+
+            match[1]
+          end
+        end.freeze, T.proc.params(
+          arg0: T::Hash[String, T.untyped],
+          arg1: Regexp,
+        ).returns(T.any(String, T::Array[String])))
+
+        # The `Regexp` used to determine if the strategy applies to the URL.
+        URL_MATCH_REGEX = %r{
+          ^https?://static\.crates\.io/crates
+          /(?<package>[^/]+) # The name of the package
+          /.+\.crate # The crate filename
+        }ix
+
+        # Whether the strategy can be applied to the provided URL.
+        #
+        # @param url [String] the URL to match against
+        # @return [Boolean]
+        sig { params(url: String).returns(T::Boolean) }
+        def self.match?(url)
+          URL_MATCH_REGEX.match?(url)
+        end
+
+        # Extracts information from a provided URL and uses it to generate
+        # various input values used by the strategy to check for new versions.
+        #
+        # @param url [String] the URL used to generate values
+        # @return [Hash]
+        sig { params(url: String).returns(T::Hash[Symbol, T.untyped]) }
+        def self.generate_input_values(url)
+          values = {}
+          return values unless (match = url.match(URL_MATCH_REGEX))
+
+          values[:url] = "https://crates.io/api/v1/crates/#{match[:package]}/versions"
+
+          values
+        end
+
+        # Generates a URL and checks the content at the URL for new versions
+        # using {Json#versions_from_content}.
+        #
+        # @param url [String] the URL of the content to check
+        # @param regex [Regexp, nil] a regex for matching versions in content
+        # @param provided_content [String, nil] content to check instead of
+        #   fetching
+        # @param homebrew_curl [Boolean] whether to use brewed curl with the URL
+        # @return [Hash]
+        sig {
+          params(
+            url:              String,
+            regex:            T.nilable(Regexp),
+            provided_content: T.nilable(String),
+            homebrew_curl:    T::Boolean,
+            _unused:          T.untyped,
+            block:            T.nilable(Proc),
+          ).returns(T::Hash[Symbol, T.untyped])
+        }
+        def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: false, **_unused, &block)
+          match_data = { matches: {}, regex:, url: }
+          match_data[:cached] = true if provided_content.is_a?(String)
+
+          generated = generate_input_values(url)
+          return match_data if generated.blank?
+
+          match_data[:url] = generated[:url]
+
+          content = if provided_content
+            provided_content
+          else
+            match_data.merge!(Strategy.page_content(match_data[:url], homebrew_curl:))
+            match_data[:content]
+          end
+          return match_data unless content
+
+          Json.versions_from_content(content, regex || DEFAULT_REGEX, &block || DEFAULT_BLOCK).each do |match_text|
+            match_data[:matches][match_text] = Version.new(match_text)
+          end
+
+          match_data
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/livecheck/strategy/electron_builder.rb b/Library/Homebrew/livecheck/strategy/electron_builder.rb
index 3d0a4c7437849..ea68ab04edcc1 100644
--- a/Library/Homebrew/livecheck/strategy/electron_builder.rb
+++ b/Library/Homebrew/livecheck/strategy/electron_builder.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -9,11 +9,7 @@ module Strategy
       #
       # This strategy is not applied automatically and it's necessary to use
       # `strategy :electron_builder` in a `livecheck` block to apply it.
-      #
-      # @api private
       class ElectronBuilder
-        extend T::Sig
-
         NICE_NAME = "electron-builder"
 
         # A priority of zero causes livecheck to skip the strategy. We do this
@@ -21,7 +17,7 @@ class ElectronBuilder
         PRIORITY = 0
 
         # The `Regexp` used to determine if the strategy applies to the URL.
-        URL_MATCH_REGEX = %r{^https?://.+/[^/]+\.ya?ml(?:\?[^/?]+)?$}i.freeze
+        URL_MATCH_REGEX = %r{^https?://.+/[^/]+\.ya?ml(?:\?[^/?]+)?$}i
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -32,60 +28,35 @@ def self.match?(url)
           URL_MATCH_REGEX.match?(url)
         end
 
-        # Parses YAML text and identifies versions in it.
-        #
-        # @param content [String] the YAML text to parse and check
-        # @param regex [Regexp, nil] a regex for use in a strategy block
-        # @return [Array]
-        sig {
-          params(
-            content: String,
-            regex:   T.nilable(Regexp),
-            block:   T.untyped,
-          ).returns(T::Array[String])
-        }
-        def self.versions_from_content(content, regex = nil, &block)
-          require "yaml"
-
-          yaml = YAML.safe_load(content)
-          return [] if yaml.blank?
-
-          if block
-            block_return_value = regex.present? ? yield(yaml, regex) : yield(yaml)
-            return Strategy.handle_block_return(block_return_value)
-          end
-
-          version = yaml["version"]
-          version.present? ? [version] : []
-        end
-
         # Checks the YAML content at the URL for new versions.
         #
         # @param url [String] the URL of the content to check
+        # @param regex [Regexp, nil] a regex used for matching versions
+        # @param provided_content [String, nil] content to use in place of
+        #   fetching via `Strategy#page_content`
         # @return [Hash]
         sig {
           params(
-            url:     String,
-            regex:   T.nilable(Regexp),
-            _unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:   T.untyped,
+            url:              String,
+            regex:            T.nilable(Regexp),
+            provided_content: T.nilable(String),
+            unused:           T.untyped,
+            block:            T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, **_unused, &block)
+        def self.find_versions(url:, regex: nil, provided_content: nil, **unused, &block)
           if regex.present? && block.blank?
-            raise ArgumentError, "#{T.must(name).demodulize} only supports a regex when using a `strategy` block"
-          end
-
-          match_data = { matches: {}, regex: regex, url: url }
-
-          match_data.merge!(Strategy.page_content(url))
-          content = match_data.delete(:content)
-
-          versions_from_content(content, regex, &block).each do |version_text|
-            match_data[:matches][version_text] = Version.new(version_text)
+            raise ArgumentError,
+                  "#{Utils.demodulize(T.must(name))} only supports a regex when using a `strategy` block"
           end
 
-          match_data
+          Yaml.find_versions(
+            url:,
+            regex:,
+            provided_content:,
+            **unused,
+            &block || proc { |yaml| yaml["version"] }
+          )
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/extract_plist.rb b/Library/Homebrew/livecheck/strategy/extract_plist.rb
index 2486a545bc82a..e0778d01bc981 100644
--- a/Library/Homebrew/livecheck/strategy/extract_plist.rb
+++ b/Library/Homebrew/livecheck/strategy/extract_plist.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "bundle_version"
@@ -16,17 +16,13 @@ module Strategy
       #
       # This strategy is not applied automatically and it's necessary to use
       # `strategy :extract_plist` in a `livecheck` block to apply it.
-      #
-      # @api private
       class ExtractPlist
-        extend T::Sig
-
         # A priority of zero causes livecheck to skip the strategy. We do this
         # for {ExtractPlist} so we can selectively apply it when appropriate.
         PRIORITY = 0
 
         # The `Regexp` used to determine if the strategy applies to the URL.
-        URL_MATCH_REGEX = %r{^https?://}i.freeze
+        URL_MATCH_REGEX = %r{^https?://}i
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -37,19 +33,17 @@ def self.match?(url)
           URL_MATCH_REGEX.match?(url)
         end
 
-        # @api private
         Item = Struct.new(
-          # @api private
           :bundle_version,
           keyword_init: true,
         ) do
-          extend T::Sig
-
           extend Forwardable
 
+          # @!attribute [r] version
           # @api public
           delegate version: :bundle_version
 
+          # @!attribute [r] short_version
           # @api public
           delegate short_version: :bundle_version
         end
@@ -64,7 +58,7 @@ def self.match?(url)
           params(
             items: T::Hash[String, Item],
             regex: T.nilable(Regexp),
-            block: T.untyped,
+            block: T.nilable(Proc),
           ).returns(T::Array[String])
         }
         def self.versions_from_items(items, regex = nil, &block)
@@ -73,9 +67,9 @@ def self.versions_from_items(items, regex = nil, &block)
             return Strategy.handle_block_return(block_return_value)
           end
 
-          items.map do |_key, item|
+          items.filter_map do |_key, item|
             item.bundle_version.nice_version
-          end.compact.uniq
+          end.uniq
         end
 
         # Uses {UnversionedCaskChecker} on the provided cask to identify
@@ -91,23 +85,26 @@ def self.versions_from_items(items, regex = nil, &block)
             cask:    Cask::Cask,
             url:     T.nilable(String),
             regex:   T.nilable(Regexp),
-            _unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:   T.untyped,
+            _unused: T.untyped,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(cask:, url: nil, regex: nil, **_unused, &block)
           if regex.present? && block.blank?
-            raise ArgumentError, "#{T.must(name).demodulize} only supports a regex when using a `strategy` block"
+            raise ArgumentError,
+                  "#{Utils.demodulize(T.must(name))} only supports a regex when using a `strategy` block"
+          end
+          unless T.unsafe(cask)
+            raise ArgumentError, "The #{Utils.demodulize(T.must(name))} strategy only supports casks."
           end
-          raise ArgumentError, "The #{T.must(name).demodulize} strategy only supports casks." unless T.unsafe(cask)
 
-          match_data = { matches: {}, regex: regex, url: url }
+          match_data = { matches: {}, regex:, url: }
 
           unversioned_cask_checker = if url.present? && url != cask.url.to_s
             # Create a copy of the `cask` that uses the `livecheck` block URL
-            cask_copy = Cask::CaskLoader.load(cask.full_name)
+            cask_copy = Cask::CaskLoader.load(cask.sourcefile_path)
             cask_copy.allow_reassignment = true
-            cask_copy.url { url }
+            cask_copy.url url
             UnversionedCaskChecker.new(cask_copy)
           else
             UnversionedCaskChecker.new(cask)
diff --git a/Library/Homebrew/livecheck/strategy/git.rb b/Library/Homebrew/livecheck/strategy/git.rb
index 8dcd410d3a075..b263404888cfc 100644
--- a/Library/Homebrew/livecheck/strategy/git.rb
+++ b/Library/Homebrew/livecheck/strategy/git.rb
@@ -1,7 +1,8 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-require "open3"
+require "addressable"
+require "system_command"
 
 module Homebrew
   module Livecheck
@@ -12,7 +13,7 @@ module Strategy
       # Livecheck has historically prioritized the {Git} strategy over others
       # and this behavior was continued when the priority setup was created.
       # This is partly related to Livecheck checking formula URLs in order of
-      # `head`, `stable`, and then `homepage`. The higher priority here may
+      # `head`, `stable` and then `homepage`. The higher priority here may
       # be removed (or altered) in the future if we reevaluate this particular
       # behavior.
       #
@@ -24,7 +25,10 @@ module Strategy
       #
       # @api public
       class Git
-        extend T::Sig
+        extend SystemCommand::Mixin
+
+        # Used to cache processed URLs, to avoid duplicating effort.
+        @processed_urls = T.let({}, T::Hash[String, String])
 
         # The priority of the strategy on an informal scale of 1 to 10 (from
         # lowest to highest).
@@ -32,7 +36,69 @@ class Git
 
         # The default regex used to naively identify versions from tags when a
         # regex isn't provided.
-        DEFAULT_REGEX = /\D*(.+)/.freeze
+        DEFAULT_REGEX = /\D*(.+)/
+
+        GITEA_INSTANCES = T.let(%w[
+          codeberg.org
+          gitea.com
+          opendev.org
+          tildegit.org
+        ].freeze, T::Array[String])
+        private_constant :GITEA_INSTANCES
+
+        GOGS_INSTANCES = T.let(%w[
+          lolg.it
+        ].freeze, T::Array[String])
+        private_constant :GOGS_INSTANCES
+
+        # Processes and returns the URL used by livecheck.
+        sig { params(url: String).returns(String) }
+        def self.preprocess_url(url)
+          processed_url = @processed_urls[url]
+          return processed_url if processed_url
+
+          begin
+            uri = Addressable::URI.parse url
+          rescue Addressable::URI::InvalidURIError
+            return url
+          end
+
+          host = uri.host
+          path = uri.path
+          return url if host.nil? || path.nil?
+
+          host = "github.com" if host == "github.s3.amazonaws.com"
+          path = path.delete_prefix("/").delete_suffix(".git")
+          scheme = uri.scheme
+
+          if host == "github.com"
+            return url if path.match? %r{/releases/latest/?$}
+
+            owner, repo = path.delete_prefix("downloads/").split("/")
+            processed_url = "#{scheme}://#{host}/#{owner}/#{repo}.git"
+          elsif GITEA_INSTANCES.include?(host)
+            return url if path.match? %r{/releases/latest/?$}
+
+            owner, repo = path.split("/")
+            processed_url = "#{scheme}://#{host}/#{owner}/#{repo}.git"
+          elsif GOGS_INSTANCES.include?(host)
+            owner, repo = path.split("/")
+            processed_url = "#{scheme}://#{host}/#{owner}/#{repo}.git"
+          # sourcehut
+          elsif host == "git.sr.ht"
+            owner, repo = path.split("/")
+            processed_url = "#{scheme}://#{host}/#{owner}/#{repo}"
+          # GitLab (gitlab.com or self-hosted)
+          elsif path.include?("/-/archive/")
+            processed_url = url.sub(%r{/-/archive/.*$}i, ".git")
+          end
+
+          if processed_url && (processed_url != url)
+            @processed_urls[url] = processed_url
+          else
+            url
+          end
+        end
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -40,6 +106,7 @@ class Git
         # @return [Boolean]
         sig { params(url: String).returns(T::Boolean) }
         def self.match?(url)
+          url = preprocess_url(url)
           (DownloadStrategyDetector.detect(url) <= GitDownloadStrategy) == true
         end
 
@@ -68,7 +135,7 @@ def self.tag_info(url, regex = nil)
 
           # Isolate tag strings and filter by regex
           tags = stdout.gsub(%r{^.*\trefs/tags/|\^{}$}, "").split("\n").uniq.sort
-          tags.select! { |t| t =~ regex } if regex
+          tags.select! { |t| regex.match?(t) } if regex
           tags_data[:tags] = tags
 
           tags_data
@@ -85,7 +152,7 @@ def self.tag_info(url, regex = nil)
           params(
             tags:  T::Array[String],
             regex: T.nilable(Regexp),
-            block: T.untyped,
+            block: T.nilable(Proc),
           ).returns(T::Array[String])
         }
         def self.versions_from_tags(tags, regex = nil, &block)
@@ -100,16 +167,17 @@ def self.versions_from_tags(tags, regex = nil, &block)
             return Strategy.handle_block_return(block_return_value)
           end
 
-          tags.map do |tag|
+          tags.filter_map do |tag|
             if regex
               # Use the first capture group (the version)
-              tag.scan(regex).first&.first
+              # This code is not typesafe unless the regex includes a capture group
+              T.unsafe(tag.scan(regex).first)&.first
             else
               # Remove non-digits from the start of the tag and use that as the
               # version text
               tag[DEFAULT_REGEX, 1]
             end
-          end.compact.uniq
+          end.uniq
         end
 
         # Checks the Git tags for new versions. When a regex isn't provided,
@@ -123,12 +191,12 @@ def self.versions_from_tags(tags, regex = nil, &block)
           params(
             url:     String,
             regex:   T.nilable(Regexp),
-            _unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:   T.untyped,
+            _unused: T.untyped,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url:, regex: nil, **_unused, &block)
-          match_data = { matches: {}, regex: regex, url: url }
+          match_data = { matches: {}, regex:, url: }
 
           tags_data = tag_info(url, regex)
           tags = tags_data[:tags]
diff --git a/Library/Homebrew/livecheck/strategy/github_latest.rb b/Library/Homebrew/livecheck/strategy/github_latest.rb
index f9d8482cdacdf..4655ce1d1faed 100644
--- a/Library/Homebrew/livecheck/strategy/github_latest.rb
+++ b/Library/Homebrew/livecheck/strategy/github_latest.rb
@@ -1,11 +1,12 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
   module Livecheck
     module Strategy
       # The {GithubLatest} strategy identifies versions of software at
-      # github.com by checking a repository's "latest" release page.
+      # github.com by checking a repository's "latest" release using the
+      # GitHub API.
       #
       # GitHub URLs take a few different formats:
       #
@@ -13,27 +14,20 @@ module Strategy
       # * `https://github.com/example/example/archive/v1.2.3.tar.gz`
       # * `https://github.com/downloads/example/example/example-1.2.3.tar.gz`
       #
-      # A repository's `/releases/latest` URL normally redirects to a release
-      # tag (e.g., `/releases/tag/1.2.3`). When there isn't a "latest" release,
-      # it will redirect to the `/releases` page.
+      # {GithubLatest} should only be used when the upstream repository has a
+      # "latest" release for a suitable version and the strategy is necessary
+      # or appropriate (e.g. the formula/cask uses a release asset or the
+      # {Git} strategy returns an unreleased version). The strategy can only
+      # be applied by using `strategy :github_latest` in a `livecheck` block.
       #
-      # This strategy should only be used when we know the upstream repository
-      # has a "latest" release and the tagged release is appropriate to use
-      # (e.g., "latest" isn't wrongly pointing to an unstable version, not
-      # picking up the actual latest version, etc.). The strategy can only be
-      # applied by using `strategy :github_latest` in a `livecheck` block.
-      #
-      # The default regex identifies versions like `1.2.3`/`v1.2.3` in `href`
-      # attributes containing the tag URL (e.g.,
-      # `/example/example/releases/tag/v1.2.3`). This is a common tag format
-      # but a modified regex can be provided in a `livecheck` block to override
-      # the default if a repository uses a different format (e.g.,
-      # `example-1.2.3`, `1.2.3d`, `1.2.3-4`, etc.).
+      # The default regex identifies versions like `1.2.3`/`v1.2.3` in a
+      # release's tag or title. This is a common tag format but a modified
+      # regex can be provided in a `livecheck` block to override the default
+      # if a repository uses a different format (e.g. `1.2.3d`, `1.2.3-4`,
+      # etc.).
       #
       # @api public
       class GithubLatest
-        extend T::Sig
-
         NICE_NAME = "GitHub - Latest"
 
         # A priority of zero causes livecheck to skip the strategy. We do this
@@ -41,24 +35,13 @@ class GithubLatest
         # `strategy :github_latest` in a `livecheck` block.
         PRIORITY = 0
 
-        # The `Regexp` used to determine if the strategy applies to the URL.
-        URL_MATCH_REGEX = %r{
-          ^https?://github\.com
-          /(?:downloads/)?(?<username>[^/]+) # The GitHub username
-          /(?<repository>[^/]+)              # The GitHub repository name
-        }ix.freeze
-
-        # The default regex used to identify a version from a tag when a regex
-        # isn't provided.
-        DEFAULT_REGEX = %r{href=.*?/tag/v?(\d+(?:\.\d+)+)["' >]}i.freeze
-
         # Whether the strategy can be applied to the provided URL.
         #
         # @param url [String] the URL to match against
         # @return [Boolean]
         sig { params(url: String).returns(T::Boolean) }
         def self.match?(url)
-          URL_MATCH_REGEX.match?(url)
+          GithubReleases.match?(url)
         end
 
         # Extracts information from a provided URL and uses it to generate
@@ -72,35 +55,47 @@ def self.match?(url)
         def self.generate_input_values(url)
           values = {}
 
-          match = url.sub(/\.git$/i, "").match(URL_MATCH_REGEX)
+          match = url.delete_suffix(".git").match(GithubReleases::URL_MATCH_REGEX)
           return values if match.blank?
 
-          # Example URL: `https://github.com/example/example/releases/latest`
-          values[:url] = "https://github.com/#{match[:username]}/#{match[:repository]}/releases/latest"
+          values[:url] = "https://api.github.com/repos/#{match[:username]}/#{match[:repository]}/releases/latest"
+          values[:username] = match[:username]
+          values[:repository] = match[:repository]
 
           values
         end
 
-        # Generates a URL and regex (if one isn't provided) and passes them
-        # to {PageMatch.find_versions} to identify versions in the content.
+        # Generates the GitHub API URL for the repository's "latest" release
+        # and identifies the version from the JSON response.
         #
         # @param url [String] the URL of the content to check
         # @param regex [Regexp] a regex used for matching versions in content
         # @return [Hash]
         sig {
           params(
-            url:    String,
-            regex:  T.nilable(Regexp),
-            unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:  T.untyped,
+            url:     String,
+            regex:   Regexp,
+            _unused: T.untyped,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, **unused, &block)
+        def self.find_versions(url:, regex: GithubReleases::DEFAULT_REGEX, **_unused, &block)
+          match_data = { matches: {}, regex:, url: }
+
           generated = generate_input_values(url)
+          return match_data if generated.blank?
+
+          match_data[:url] = generated[:url]
+
+          release = GitHub.get_latest_release(generated[:username], generated[:repository])
+          GithubReleases.versions_from_content(release, regex, &block).each do |match_text|
+            match_data[:matches][match_text] = Version.new(match_text)
+          end
 
-          T.unsafe(PageMatch).find_versions(url: generated[:url], regex: regex || DEFAULT_REGEX, **unused, &block)
+          match_data
         end
       end
     end
+    GitHubLatest = Homebrew::Livecheck::Strategy::GithubLatest
   end
 end
diff --git a/Library/Homebrew/livecheck/strategy/github_releases.rb b/Library/Homebrew/livecheck/strategy/github_releases.rb
new file mode 100644
index 0000000000000..a37b3a561152f
--- /dev/null
+++ b/Library/Homebrew/livecheck/strategy/github_releases.rb
@@ -0,0 +1,155 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  module Livecheck
+    module Strategy
+      # The {GithubReleases} strategy identifies versions of software at
+      # github.com by checking a repository's recent releases using the
+      # GitHub API.
+      #
+      # GitHub URLs take a few different formats:
+      #
+      # * `https://github.com/example/example/releases/download/1.2.3/example-1.2.3.tar.gz`
+      # * `https://github.com/example/example/archive/v1.2.3.tar.gz`
+      # * `https://github.com/downloads/example/example/example-1.2.3.tar.gz`
+      #
+      # {GithubReleases} should only be used when the upstream repository has
+      # releases for suitable versions and the strategy is necessary or
+      # appropriate (e.g. the formula/cask uses a release asset and the
+      # {GithubLatest} strategy isn't sufficient to identify the newest version.
+      # The strategy can only be applied by using `strategy :github_releases`
+      # in a `livecheck` block.
+      #
+      # The default regex identifies versions like `1.2.3`/`v1.2.3` in each
+      # release's tag or title. This is a common tag format but a modified
+      # regex can be provided in a `livecheck` block to override the default
+      # if a repository uses a different format (e.g. `1.2.3d`, `1.2.3-4`,
+      # etc.).
+      #
+      # @api public
+      class GithubReleases
+        NICE_NAME = "GitHub - Releases"
+
+        # A priority of zero causes livecheck to skip the strategy. We do this
+        # for {GithubReleases} so we can selectively apply the strategy using
+        # `strategy :github_releases` in a `livecheck` block.
+        PRIORITY = 0
+
+        # The `Regexp` used to determine if the strategy applies to the URL.
+        URL_MATCH_REGEX = %r{
+          ^https?://github\.com
+          /(?:downloads/)?(?<username>[^/]+) # The GitHub username
+          /(?<repository>[^/]+)              # The GitHub repository name
+        }ix
+
+        # The default regex used to identify a version from a tag when a regex
+        # isn't provided.
+        DEFAULT_REGEX = /v?(\d+(?:\.\d+)+)/i
+
+        # Keys in the release JSON that could contain the version.
+        # The tag name is checked first, to better align with the {Git}
+        # strategy.
+        VERSION_KEYS = T.let(["tag_name", "name"].freeze, T::Array[String])
+
+        # Whether the strategy can be applied to the provided URL.
+        #
+        # @param url [String] the URL to match against
+        # @return [Boolean]
+        sig { params(url: String).returns(T::Boolean) }
+        def self.match?(url)
+          URL_MATCH_REGEX.match?(url)
+        end
+
+        # Extracts information from a provided URL and uses it to generate
+        # various input values used by the strategy to check for new versions.
+        # Some of these values act as defaults and can be overridden in a
+        # `livecheck` block.
+        #
+        # @param url [String] the URL used to generate values
+        # @return [Hash]
+        sig { params(url: String).returns(T::Hash[Symbol, T.untyped]) }
+        def self.generate_input_values(url)
+          values = {}
+
+          match = url.delete_suffix(".git").match(URL_MATCH_REGEX)
+          return values if match.blank?
+
+          values[:url] = "#{GitHub::API_URL}/repos/#{match[:username]}/#{match[:repository]}/releases"
+          values[:username] = match[:username]
+          values[:repository] = match[:repository]
+
+          values
+        end
+
+        # Uses a regex to match versions from release JSON or, if a block is
+        # provided, passes the JSON to the block to handle matching. With
+        # either approach, an array of unique matches is returned.
+        #
+        # @param content [Array, Hash] array of releases or a single release
+        # @param regex [Regexp] a regex used for matching versions in the
+        # content
+        # @param block [Proc, nil] a block to match the content
+        # @return [Array]
+        sig {
+          params(
+            content: T.any(T::Array[T::Hash[String, T.untyped]], T::Hash[String, T.untyped]),
+            regex:   Regexp,
+            block:   T.nilable(Proc),
+          ).returns(T::Array[String])
+        }
+        def self.versions_from_content(content, regex, &block)
+          if block.present?
+            block_return_value = yield(content, regex)
+            return Strategy.handle_block_return(block_return_value)
+          end
+
+          content = [content] unless content.is_a?(Array)
+          content.compact_blank.filter_map do |release|
+            next if release["draft"] || release["prerelease"]
+
+            value = T.let(nil, T.untyped)
+            VERSION_KEYS.find do |key|
+              match = release[key]&.match(regex)
+              next if match.blank?
+
+              value = match[1]
+            end
+            value
+          end.uniq
+        end
+
+        # Generates the GitHub API URL for the repository's recent releases
+        # and identifies versions from the JSON response.
+        #
+        # @param url [String] the URL of the content to check
+        # @param regex [Regexp] a regex used for matching versions in content
+        # @return [Hash]
+        sig {
+          params(
+            url:     String,
+            regex:   Regexp,
+            _unused: T.untyped,
+            block:   T.nilable(Proc),
+          ).returns(T::Hash[Symbol, T.untyped])
+        }
+        def self.find_versions(url:, regex: DEFAULT_REGEX, **_unused, &block)
+          match_data = { matches: {}, regex:, url: }
+
+          generated = generate_input_values(url)
+          return match_data if generated.blank?
+
+          match_data[:url] = generated[:url]
+
+          releases = GitHub::API.open_rest(generated[:url])
+          versions_from_content(releases, regex, &block).each do |match_text|
+            match_data[:matches][match_text] = Version.new(match_text)
+          end
+
+          match_data
+        end
+      end
+    end
+    GitHubReleases = Homebrew::Livecheck::Strategy::GithubReleases
+  end
+end
diff --git a/Library/Homebrew/livecheck/strategy/gnome.rb b/Library/Homebrew/livecheck/strategy/gnome.rb
index ecf11c7d25ef0..9a8828d9922ba 100644
--- a/Library/Homebrew/livecheck/strategy/gnome.rb
+++ b/Library/Homebrew/livecheck/strategy/gnome.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -15,18 +15,16 @@ module Strategy
       # Before version 40, GNOME used a version scheme where unstable releases
       # were indicated with a minor that's 90+ or odd. The newer version scheme
       # uses trailing alpha/beta/rc text to identify unstable versions
-      # (e.g., `40.alpha`).
+      # (e.g. `40.alpha`).
       #
       # When a regex isn't provided in a `livecheck` block, the strategy uses
       # a default regex that matches versions which don't include trailing text
-      # after the numeric version (e.g., `40.0` instead of `40.alpha`) and it
+      # after the numeric version (e.g. `40.0` instead of `40.alpha`) and it
       # selectively filters out unstable versions below 40 using the rules for
       # the older version scheme.
       #
       # @api public
       class Gnome
-        extend T::Sig
-
         NICE_NAME = "GNOME"
 
         # The `Regexp` used to determine if the strategy applies to the URL.
@@ -34,7 +32,7 @@ class Gnome
           ^https?://download\.gnome\.org
           /sources
           /(?<package_name>[^/]+)/ # The GNOME package name
-        }ix.freeze
+        }ix
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -81,14 +79,14 @@ def self.generate_input_values(url)
           params(
             url:    String,
             regex:  T.nilable(Regexp),
-            unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:  T.untyped,
+            unused: T.untyped,
+            block:  T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url:, regex: nil, **unused, &block)
           generated = generate_input_values(url)
 
-          version_data = T.unsafe(PageMatch).find_versions(
+          version_data = PageMatch.find_versions(
             url:   generated[:url],
             regex: regex || generated[:regex],
             **unused,
diff --git a/Library/Homebrew/livecheck/strategy/gnu.rb b/Library/Homebrew/livecheck/strategy/gnu.rb
index 0077974717f19..027c689506d32 100644
--- a/Library/Homebrew/livecheck/strategy/gnu.rb
+++ b/Library/Homebrew/livecheck/strategy/gnu.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -29,16 +29,14 @@ module Strategy
       #
       # @api public
       class Gnu
-        extend T::Sig
-
         NICE_NAME = "GNU"
 
         # The `Regexp` used to determine if the strategy applies to the URL.
-        URL_MATCH_REGEX = %r{
+        URL_MATCH_REGEX = T.let(%r{
           ^https?://
           (?:(?:[^/]+?\.)*gnu\.org/(?:gnu|software)/(?<project_name>[^/]+)/
           |(?<project_name>[^/]+)\.gnu\.org/?$)
-        }ix.freeze
+        }ix, Regexp)
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -91,14 +89,14 @@ def self.generate_input_values(url)
           params(
             url:    String,
             regex:  T.nilable(Regexp),
-            unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:  T.untyped,
+            unused: T.untyped,
+            block:  T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url:, regex: nil, **unused, &block)
           generated = generate_input_values(url)
 
-          T.unsafe(PageMatch).find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
+          PageMatch.find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/hackage.rb b/Library/Homebrew/livecheck/strategy/hackage.rb
index e303e2ea7c31b..fea597c1a036e 100644
--- a/Library/Homebrew/livecheck/strategy/hackage.rb
+++ b/Library/Homebrew/livecheck/strategy/hackage.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -17,21 +17,19 @@ module Strategy
       #
       # @api public
       class Hackage
-        extend T::Sig
-
         # A `Regexp` used in determining if the strategy applies to the URL and
         # also as part of extracting the package name from the URL basename.
-        PACKAGE_NAME_REGEX = /(?<package_name>.+?)-\d+/i.freeze
+        PACKAGE_NAME_REGEX = /(?<package_name>.+?)-\d+/i
 
         # A `Regexp` used to extract the package name from the URL basename.
-        FILENAME_REGEX = /^#{PACKAGE_NAME_REGEX.source.strip}/i.freeze
+        FILENAME_REGEX = /^#{PACKAGE_NAME_REGEX.source.strip}/i
 
         # A `Regexp` used in determining if the strategy applies to the URL.
         URL_MATCH_REGEX = %r{
           ^https?://(?:downloads|hackage)\.haskell\.org
           (?:/[^/]+)+ # Path before the filename
           #{PACKAGE_NAME_REGEX.source.strip}
-        }ix.freeze
+        }ix
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -77,14 +75,14 @@ def self.generate_input_values(url)
           params(
             url:    String,
             regex:  T.nilable(Regexp),
-            unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:  T.untyped,
+            unused: T.untyped,
+            block:  T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url:, regex: nil, **unused, &block)
           generated = generate_input_values(url)
 
-          T.unsafe(PageMatch).find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
+          PageMatch.find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/header_match.rb b/Library/Homebrew/livecheck/strategy/header_match.rb
index a54c19abb4ea5..460f8025f79ca 100644
--- a/Library/Homebrew/livecheck/strategy/header_match.rb
+++ b/Library/Homebrew/livecheck/strategy/header_match.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -9,11 +9,7 @@ module Strategy
       #
       # This strategy is not applied automatically and it's necessary to use
       # `strategy :header_match` in a `livecheck` block to apply it.
-      #
-      # @api private
       class HeaderMatch
-        extend T::Sig
-
         NICE_NAME = "Header match"
 
         # A priority of zero causes livecheck to skip the strategy. We do this
@@ -21,10 +17,10 @@ class HeaderMatch
         PRIORITY = 0
 
         # The `Regexp` used to determine if the strategy applies to the URL.
-        URL_MATCH_REGEX = %r{^https?://}i.freeze
+        URL_MATCH_REGEX = %r{^https?://}i
 
         # The header fields to check when a `strategy` block isn't provided.
-        DEFAULT_HEADERS_TO_CHECK = ["content-disposition", "location"].freeze
+        DEFAULT_HEADERS_TO_CHECK = T.let(["content-disposition", "location"].freeze, T::Array[String])
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -44,7 +40,7 @@ def self.match?(url)
           params(
             headers: T::Hash[String, String],
             regex:   T.nilable(Regexp),
-            block:   T.untyped,
+            block:   T.nilable(Proc),
           ).returns(T::Array[String])
         }
         def self.versions_from_headers(headers, regex = nil, &block)
@@ -53,7 +49,7 @@ def self.versions_from_headers(headers, regex = nil, &block)
             return Strategy.handle_block_return(block_return_value)
           end
 
-          DEFAULT_HEADERS_TO_CHECK.map do |header_name|
+          DEFAULT_HEADERS_TO_CHECK.filter_map do |header_name|
             header_value = headers[header_name]
             next if header_value.blank?
 
@@ -63,7 +59,7 @@ def self.versions_from_headers(headers, regex = nil, &block)
               v = Version.parse(header_value, detected_from_url: true)
               v.null? ? nil : v.to_s
             end
-          end.compact.uniq
+          end.uniq
         end
 
         # Checks the final URL for new versions after following all redirections,
@@ -78,14 +74,14 @@ def self.versions_from_headers(headers, regex = nil, &block)
             url:           String,
             regex:         T.nilable(Regexp),
             homebrew_curl: T::Boolean,
-            _unused:       T.nilable(T::Hash[Symbol, T.untyped]),
-            block:         T.untyped,
+            _unused:       T.untyped,
+            block:         T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url:, regex: nil, homebrew_curl: false, **_unused, &block)
-          match_data = { matches: {}, regex: regex, url: url }
+          match_data = { matches: {}, regex:, url: }
 
-          headers = Strategy.page_headers(url, homebrew_curl: homebrew_curl)
+          headers = Strategy.page_headers(url, homebrew_curl:)
 
           # Merge the headers from all responses into one hash
           merged_headers = headers.reduce(&:merge)
diff --git a/Library/Homebrew/livecheck/strategy/json.rb b/Library/Homebrew/livecheck/strategy/json.rb
new file mode 100644
index 0000000000000..a4631c58e2327
--- /dev/null
+++ b/Library/Homebrew/livecheck/strategy/json.rb
@@ -0,0 +1,133 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  module Livecheck
+    module Strategy
+      # The {Json} strategy fetches content at a URL, parses it as JSON and
+      # provides the parsed data to a `strategy` block. If a regex is present
+      # in the `livecheck` block, it should be passed as the second argument to
+      # the `strategy` block.
+      #
+      # This is a generic strategy that doesn't contain any logic for finding
+      # versions, as the structure of JSON data varies. Instead, a `strategy`
+      # block must be used to extract version information from the JSON data.
+      #
+      # This strategy is not applied automatically and it is necessary to use
+      # `strategy :json` in a `livecheck` block (in conjunction with a
+      # `strategy` block) to use it.
+      #
+      # This strategy's {find_versions} method can be used in other strategies
+      # that work with JSON content, so it should only be necessary to write
+      # the version-finding logic that works with the parsed JSON data.
+      #
+      # @api public
+      class Json
+        NICE_NAME = "JSON"
+
+        # A priority of zero causes livecheck to skip the strategy. We do this
+        # for {Json} so we can selectively apply it only when a strategy block
+        # is provided in a `livecheck` block.
+        PRIORITY = 0
+
+        # The `Regexp` used to determine if the strategy applies to the URL.
+        URL_MATCH_REGEX = %r{^https?://}i
+
+        # Whether the strategy can be applied to the provided URL.
+        # {Json} will technically match any HTTP URL but is only usable with
+        # a `livecheck` block containing a `strategy` block.
+        #
+        # @param url [String] the URL to match against
+        # @return [Boolean]
+        sig { params(url: String).returns(T::Boolean) }
+        def self.match?(url)
+          URL_MATCH_REGEX.match?(url)
+        end
+
+        # Parses JSON text and returns the parsed data.
+        # @param content [String] the JSON text to parse
+        sig { params(content: String).returns(T.untyped) }
+        def self.parse_json(content)
+          require "json"
+
+          begin
+            JSON.parse(content)
+          rescue JSON::ParserError
+            raise "Content could not be parsed as JSON."
+          end
+        end
+
+        # Parses JSON text and identifies versions using a `strategy` block.
+        # If a regex is provided, it will be passed as the second argument to
+        # the  `strategy` block (after the parsed JSON data).
+        # @param content [String] the JSON text to parse and check
+        # @param regex [Regexp, nil] a regex used for matching versions in the
+        #   content
+        # @return [Array]
+        sig {
+          params(
+            content: String,
+            regex:   T.nilable(Regexp),
+            block:   T.nilable(Proc),
+          ).returns(T::Array[String])
+        }
+        def self.versions_from_content(content, regex = nil, &block)
+          return [] if content.blank? || block.blank?
+
+          json = parse_json(content)
+          return [] if json.blank?
+
+          block_return_value = if regex.present?
+            yield(json, regex)
+          elsif block.arity == 2
+            raise "Two arguments found in `strategy` block but no regex provided."
+          else
+            yield(json)
+          end
+          Strategy.handle_block_return(block_return_value)
+        end
+
+        # Checks the JSON content at the URL for versions, using the provided
+        # `strategy` block to extract version information.
+        #
+        # @param url [String] the URL of the content to check
+        # @param regex [Regexp, nil] a regex used for matching versions
+        # @param provided_content [String, nil] page content to use in place of
+        #   fetching via `Strategy#page_content`
+        # @param homebrew_curl [Boolean] whether to use brewed curl with the URL
+        # @return [Hash]
+        sig {
+          params(
+            url:              String,
+            regex:            T.nilable(Regexp),
+            provided_content: T.nilable(String),
+            homebrew_curl:    T::Boolean,
+            _unused:          T.untyped,
+            block:            T.nilable(Proc),
+          ).returns(T::Hash[Symbol, T.untyped])
+        }
+        def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: false, **_unused, &block)
+          raise ArgumentError, "#{Utils.demodulize(T.must(name))} requires a `strategy` block" if block.blank?
+
+          match_data = { matches: {}, regex:, url: }
+          return match_data if url.blank? || block.blank?
+
+          content = if provided_content.is_a?(String)
+            match_data[:cached] = true
+            provided_content
+          else
+            match_data.merge!(Strategy.page_content(url, homebrew_curl:))
+            match_data[:content]
+          end
+          return match_data if content.blank?
+
+          versions_from_content(content, regex, &block).each do |match_text|
+            match_data[:matches][match_text] = Version.new(match_text)
+          end
+
+          match_data
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/livecheck/strategy/launchpad.rb b/Library/Homebrew/livecheck/strategy/launchpad.rb
index 3f1c278e81545..8fc33cfea198b 100644
--- a/Library/Homebrew/livecheck/strategy/launchpad.rb
+++ b/Library/Homebrew/livecheck/strategy/launchpad.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -23,17 +23,15 @@ module Strategy
       #
       # @api public
       class Launchpad
-        extend T::Sig
-
         # The `Regexp` used to determine if the strategy applies to the URL.
         URL_MATCH_REGEX = %r{
           ^https?://(?:[^/]+?\.)*launchpad\.net
           /(?<project_name>[^/]+) # The Launchpad project name
-        }ix.freeze
+        }ix
 
         # The default regex used to identify the latest version when a regex
         # isn't provided.
-        DEFAULT_REGEX = %r{class="[^"]*version[^"]*"[^>]*>\s*Latest version is (.+)\s*</}.freeze
+        DEFAULT_REGEX = %r{class="[^"]*version[^"]*"[^>]*>\s*Latest version is (.+)\s*</}
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -73,15 +71,15 @@ def self.generate_input_values(url)
         sig {
           params(
             url:    String,
-            regex:  T.nilable(Regexp),
-            unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:  T.untyped,
+            regex:  Regexp,
+            unused: T.untyped,
+            block:  T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
-        def self.find_versions(url:, regex: nil, **unused, &block)
+        def self.find_versions(url:, regex: DEFAULT_REGEX, **unused, &block)
           generated = generate_input_values(url)
 
-          T.unsafe(PageMatch).find_versions(url: generated[:url], regex: regex || DEFAULT_REGEX, **unused, &block)
+          PageMatch.find_versions(url: generated[:url], regex:, **unused, &block)
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/npm.rb b/Library/Homebrew/livecheck/strategy/npm.rb
index 8fedeb84e4afd..b020e6a48ead9 100644
--- a/Library/Homebrew/livecheck/strategy/npm.rb
+++ b/Library/Homebrew/livecheck/strategy/npm.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -17,15 +17,13 @@ module Strategy
       #
       # @api public
       class Npm
-        extend T::Sig
-
         NICE_NAME = "npm"
 
         # The `Regexp` used to determine if the strategy applies to the URL.
         URL_MATCH_REGEX = %r{
           ^https?://registry\.npmjs\.org
           /(?<package_name>.+?)/-/ # The npm package name
-        }ix.freeze
+        }ix
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -72,14 +70,14 @@ def self.generate_input_values(url)
           params(
             url:    String,
             regex:  T.nilable(Regexp),
-            unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:  T.untyped,
+            unused: T.untyped,
+            block:  T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url:, regex: nil, **unused, &block)
           generated = generate_input_values(url)
 
-          T.unsafe(PageMatch).find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
+          PageMatch.find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/page_match.rb b/Library/Homebrew/livecheck/strategy/page_match.rb
index d18a924cae036..8f68676b5415c 100644
--- a/Library/Homebrew/livecheck/strategy/page_match.rb
+++ b/Library/Homebrew/livecheck/strategy/page_match.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -11,13 +11,11 @@ module Strategy
       # strategies apply to a given URL. Though {PageMatch} will technically
       # match any HTTP URL, the strategy also requires a regex to function.
       #
-      # The {find_versions} method is also used within other strategies,
-      # to handle the process of identifying version text in content.
+      # The {find_versions} method can be used within other strategies, to
+      # handle the process of identifying version text in content.
       #
       # @api public
       class PageMatch
-        extend T::Sig
-
         NICE_NAME = "Page match"
 
         # A priority of zero causes livecheck to skip the strategy. We do this
@@ -26,7 +24,7 @@ class PageMatch
         PRIORITY = 0
 
         # The `Regexp` used to determine if the strategy applies to the URL.
-        URL_MATCH_REGEX = %r{^https?://}i.freeze
+        URL_MATCH_REGEX = %r{^https?://}i
 
         # Whether the strategy can be applied to the provided URL.
         # {PageMatch} will technically match any HTTP URL but is only
@@ -51,7 +49,7 @@ def self.match?(url)
           params(
             content: String,
             regex:   T.nilable(Regexp),
-            block:   T.untyped,
+            block:   T.nilable(Proc),
           ).returns(T::Array[String])
         }
         def self.versions_from_content(content, regex, &block)
@@ -62,14 +60,14 @@ def self.versions_from_content(content, regex, &block)
 
           return [] if regex.blank?
 
-          content.scan(regex).map do |match|
+          content.scan(regex).filter_map do |match|
             case match
             when String
               match
             when Array
               match.first
             end
-          end.compact.uniq
+          end.uniq
         end
 
         # Checks the content at the URL for new versions, using the provided
@@ -78,7 +76,7 @@ def self.versions_from_content(content, regex, &block)
         # @param url [String] the URL of the content to check
         # @param regex [Regexp, nil] a regex used for matching versions
         # @param provided_content [String, nil] page content to use in place of
-        #   fetching via Strategy#page_content
+        #   fetching via `Strategy#page_content`
         # @param homebrew_curl [Boolean] whether to use brewed curl with the URL
         # @return [Hash]
         sig {
@@ -87,23 +85,23 @@ def self.versions_from_content(content, regex, &block)
             regex:            T.nilable(Regexp),
             provided_content: T.nilable(String),
             homebrew_curl:    T::Boolean,
-            _unused:          T.nilable(T::Hash[Symbol, T.untyped]),
-            block:            T.untyped,
+            _unused:          T.untyped,
+            block:            T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: false, **_unused, &block)
           if regex.blank? && block.blank?
-            raise ArgumentError, "#{T.must(name).demodulize} requires a regex or `strategy` block"
+            raise ArgumentError, "#{Utils.demodulize(T.must(name))} requires a regex or `strategy` block"
           end
 
-          match_data = { matches: {}, regex: regex, url: url }
+          match_data = { matches: {}, regex:, url: }
           return match_data if url.blank? || (regex.blank? && block.blank?)
 
           content = if provided_content.is_a?(String)
             match_data[:cached] = true
             provided_content
           else
-            match_data.merge!(Strategy.page_content(url, homebrew_curl: homebrew_curl))
+            match_data.merge!(Strategy.page_content(url, homebrew_curl:))
             match_data[:content]
           end
           return match_data if content.blank?
diff --git a/Library/Homebrew/livecheck/strategy/pypi.rb b/Library/Homebrew/livecheck/strategy/pypi.rb
index 256e4f713b133..86f27df8a8d2d 100644
--- a/Library/Homebrew/livecheck/strategy/pypi.rb
+++ b/Library/Homebrew/livecheck/strategy/pypi.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -17,17 +17,15 @@ module Strategy
       #
       # @api public
       class Pypi
-        extend T::Sig
-
         NICE_NAME = "PyPI"
 
-        # The `Regexp` used to extract the package name and suffix (e.g., file
+        # The `Regexp` used to extract the package name and suffix (e.g. file
         # extension) from the URL basename.
         FILENAME_REGEX = /
           (?<package_name>.+)- # The package name followed by a hyphen
           .*? # The version string
           (?<suffix>\.tar\.[a-z0-9]+|\.[a-z0-9]+)$ # Filename extension
-        /ix.freeze
+        /ix
 
         # The `Regexp` used to determine if the strategy applies to the URL.
         URL_MATCH_REGEX = %r{
@@ -35,7 +33,7 @@ class Pypi
           /packages
           (?:/[^/]+)+ # The hexadecimal paths before the filename
           /#{FILENAME_REGEX.source.strip} # The filename
-        }ix.freeze
+        }ix
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -65,11 +63,11 @@ def self.generate_input_values(url)
           values[:url] = "https://pypi.org/project/#{T.must(match[:package_name]).gsub(/%20|_/, "-")}/#files"
 
           # Use `\.t` instead of specific tarball extensions (e.g. .tar.gz)
-          suffix = T.must(match[:suffix]).sub(Strategy::TARBALL_EXTENSION_REGEX, "\.t")
+          suffix = T.must(match[:suffix]).sub(Strategy::TARBALL_EXTENSION_REGEX, ".t")
           regex_suffix = Regexp.escape(suffix).gsub("\\-", "-")
 
           # Example regex: `%r{href=.*?/packages.*?/example[._-]v?(\d+(?:\.\d+)*(?:[._-]post\d+)?)\.t}i`
-          regex_name = Regexp.escape(T.must(match[:package_name])).gsub("\\-", "-")
+          regex_name = Regexp.escape(T.must(match[:package_name])).gsub(/\\[_-]/, "[_-]")
           values[:regex] =
             %r{href=.*?/packages.*?/#{regex_name}[._-]v?(\d+(?:\.\d+)*(?:[._-]post\d+)?)#{regex_suffix}}i
 
@@ -86,14 +84,14 @@ def self.generate_input_values(url)
           params(
             url:    String,
             regex:  T.nilable(Regexp),
-            unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:  T.untyped,
+            unused: T.untyped,
+            block:  T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url:, regex: nil, **unused, &block)
           generated = generate_input_values(url)
 
-          T.unsafe(PageMatch).find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
+          PageMatch.find_versions(url: generated[:url], regex: regex || generated[:regex], **unused, &block)
         end
       end
     end
diff --git a/Library/Homebrew/livecheck/strategy/sourceforge.rb b/Library/Homebrew/livecheck/strategy/sourceforge.rb
index a0050b7486219..539000b4f210c 100644
--- a/Library/Homebrew/livecheck/strategy/sourceforge.rb
+++ b/Library/Homebrew/livecheck/strategy/sourceforge.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -31,8 +31,6 @@ module Strategy
       #
       # @api public
       class Sourceforge
-        extend T::Sig
-
         NICE_NAME = "SourceForge"
 
         # The `Regexp` used to determine if the strategy applies to the URL.
@@ -41,7 +39,7 @@ class Sourceforge
           (?:/projects?/(?<project_name>[^/]+)/
           |/p/(?<project_name>[^/]+)/
           |(?::/cvsroot)?/(?<project_name>[^/]+))
-        }ix.freeze
+        }ix
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -91,14 +89,14 @@ def self.generate_input_values(url)
           params(
             url:    String,
             regex:  T.nilable(Regexp),
-            unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:  T.untyped,
+            unused: T.untyped,
+            block:  T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url:, regex: nil, **unused, &block)
           generated = generate_input_values(url)
 
-          T.unsafe(PageMatch).find_versions(
+          PageMatch.find_versions(
             url:   generated[:url] || url,
             regex: regex || generated[:regex],
             **unused,
diff --git a/Library/Homebrew/livecheck/strategy/sparkle.rb b/Library/Homebrew/livecheck/strategy/sparkle.rb
index ae1e30567efa5..de16eaec18bce 100644
--- a/Library/Homebrew/livecheck/strategy/sparkle.rb
+++ b/Library/Homebrew/livecheck/strategy/sparkle.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "bundle_version"
@@ -11,17 +11,16 @@ module Strategy
       #
       # This strategy is not applied automatically and it's necessary to use
       # `strategy :sparkle` in a `livecheck` block to apply it.
-      #
-      # @api private
       class Sparkle
-        extend T::Sig
-
         # A priority of zero causes livecheck to skip the strategy. We do this
         # for {Sparkle} so we can selectively apply it when appropriate.
         PRIORITY = 0
 
         # The `Regexp` used to determine if the strategy applies to the URL.
-        URL_MATCH_REGEX = %r{^https?://}i.freeze
+        URL_MATCH_REGEX = %r{^https?://}i
+
+        # Common `os` values used in appcasts to refer to macOS.
+        APPCAST_MACOS_STRINGS = T.let(["macos", "osx"].freeze, T::Array[String])
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -32,30 +31,38 @@ def self.match?(url)
           URL_MATCH_REGEX.match?(url)
         end
 
-        # @api private
         Item = Struct.new(
           # @api public
           :title,
           # @api public
+          :link,
+          # @api public
           :channel,
-          # @api private
+          # @api public
+          :release_notes_link,
+          # @api public
           :pub_date,
           # @api public
+          :os,
+          # @api public
           :url,
           # @api private
           :bundle_version,
+          # @api public
+          :minimum_system_version,
           keyword_init: true,
         ) do
-          extend T::Sig
-
           extend Forwardable
 
+          # @!attribute [r] version
           # @api public
           delegate version: :bundle_version
 
+          # @!attribute [r] short_version
           # @api public
           delegate short_version: :bundle_version
 
+          # @!attribute [r] nice_version
           # @api public
           delegate nice_version: :bundle_version
         end
@@ -67,24 +74,8 @@ def self.match?(url)
         sig { params(content: String).returns(T::Array[Item]) }
         def self.items_from_content(content)
           require "rexml/document"
-
-          parsing_tries = 0
-          xml = begin
-            REXML::Document.new(content)
-          rescue REXML::UndefinedNamespaceException => e
-            undefined_prefix = e.to_s[/Undefined prefix ([^ ]+) found/i, 1]
-            raise if undefined_prefix.blank?
-
-            # Only retry parsing once after removing prefix from content
-            parsing_tries += 1
-            raise if parsing_tries > 1
-
-            # When an XML document contains a prefix without a corresponding
-            # namespace, it's necessary to remove the prefix from the content
-            # to be able to successfully parse it using REXML
-            content = content.gsub(%r{(</?| )#{Regexp.escape(undefined_prefix)}:}, '\1')
-            retry
-          end
+          xml = Xml.parse_xml(content)
+          return [] if xml.blank?
 
           # Remove prefixes, so we can reliably identify elements and attributes
           xml.root&.each_recursive do |node|
@@ -94,26 +85,38 @@ def self.items_from_content(content)
             end
           end
 
-          xml.get_elements("//rss//channel//item").map do |item|
+          xml.get_elements("//rss//channel//item").filter_map do |item|
             enclosure = item.elements["enclosure"]
 
             if enclosure
-              url = enclosure["url"]
-              short_version = enclosure["shortVersionString"]
-              version = enclosure["version"]
-              os = enclosure["os"]
+              url = enclosure["url"].presence
+              short_version = enclosure["shortVersionString"].presence
+              version = enclosure["version"].presence
+              os = enclosure["os"].presence
             end
 
-            channel = item.elements["channel"]&.text
-            url ||= item.elements["link"]&.text
-            short_version ||= item.elements["shortVersionString"]&.text&.strip
-            version ||= item.elements["version"]&.text&.strip
+            title = Xml.element_text(item, "title")
+            link = Xml.element_text(item, "link")
+            url ||= link
+            channel = Xml.element_text(item, "channel")
+            release_notes_link = Xml.element_text(item, "releaseNotesLink")
+            short_version ||= Xml.element_text(item, "shortVersionString")
+            version ||= Xml.element_text(item, "version")
+
+            minimum_system_version_text =
+              Xml.element_text(item, "minimumSystemVersion")&.gsub(/\A\D+|\D+\z/, "")
+            if minimum_system_version_text.present?
+              minimum_system_version = begin
+                MacOSVersion.new(minimum_system_version_text)
+              rescue MacOSVersion::Error
+                nil
+              end
+            end
 
-            title = item.elements["title"]&.text&.strip
-            pub_date = item.elements["pubDate"]&.text&.strip&.presence&.then do |date_string|
+            pub_date = Xml.element_text(item, "pubDate")&.then do |date_string|
               Time.parse(date_string)
             rescue ArgumentError
-              # Omit unparseable strings (e.g. non-English dates)
+              # Omit unparsable strings (e.g. non-English dates)
               nil
             end
 
@@ -124,24 +127,16 @@ def self.items_from_content(content)
 
             bundle_version = BundleVersion.new(short_version, version) if short_version || version
 
-            next if os && os != "osx"
-
-            if (minimum_system_version = item.elements["minimumSystemVersion"]&.text&.gsub(/\A\D+|\D+\z/, ""))
-              macos_minimum_system_version = begin
-                OS::Mac::Version.new(minimum_system_version).strip_patch
-              rescue MacOSVersionError
-                nil
-              end
-
-              next if macos_minimum_system_version&.prerelease?
-            end
-
             data = {
-              title:          title,
-              channel:        channel,
-              pub_date:       pub_date,
-              url:            url,
-              bundle_version: bundle_version,
+              title:,
+              link:,
+              channel:,
+              release_notes_link:,
+              pub_date:,
+              os:,
+              url:,
+              bundle_version:,
+              minimum_system_version:,
             }.compact
             next if data.empty?
 
@@ -149,9 +144,36 @@ def self.items_from_content(content)
             data[:pub_date] ||= Time.new(0)
 
             Item.new(**data)
+          end
+        end
+
+        # Filters out items that aren't suitable for Homebrew.
+        #
+        # @param items [Array] appcast items
+        # @return [Array]
+        sig { params(items: T::Array[Item]).returns(T::Array[Item]) }
+        def self.filter_items(items)
+          items.select do |item|
+            # Omit items with an explicit `os` value that isn't macOS
+            next false if item.os && APPCAST_MACOS_STRINGS.none?(item.os)
+
+            # Omit items for prerelease macOS versions
+            next false if item.minimum_system_version&.strip_patch&.prerelease?
+
+            true
           end.compact
         end
 
+        # Sorts items from newest to oldest.
+        #
+        # @param items [Array] appcast items
+        # @return [Array]
+        sig { params(items: T::Array[Item]).returns(T::Array[Item]) }
+        def self.sort_items(items)
+          items.sort_by { |item| [item.pub_date, item.bundle_version] }
+               .reverse
+        end
+
         # Uses `#items_from_content` to identify versions from the Sparkle
         # appcast content or, if a block is provided, passes the content to
         # the block to handle matching.
@@ -163,18 +185,18 @@ def self.items_from_content(content)
           params(
             content: String,
             regex:   T.nilable(Regexp),
-            block:   T.untyped,
+            block:   T.nilable(Proc),
           ).returns(T::Array[String])
         }
         def self.versions_from_content(content, regex = nil, &block)
-          items = items_from_content(content).sort_by { |item| [item.pub_date, item.bundle_version] }.reverse
+          items = sort_items(filter_items(items_from_content(content)))
           return [] if items.blank?
 
           item = items.first
 
           if block
             block_return_value = case block.parameters[0]
-            when [:opt, :item], [:rest]
+            when [:opt, :item], [:rest], [:req]
               regex.present? ? yield(item, regex) : yield(item)
             when [:opt, :items]
               regex.present? ? yield(items, regex) : yield(items)
@@ -197,19 +219,21 @@ def self.versions_from_content(content, regex = nil, &block)
           params(
             url:     String,
             regex:   T.nilable(Regexp),
-            _unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:   T.untyped,
+            _unused: T.untyped,
+            block:   T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url:, regex: nil, **_unused, &block)
           if regex.present? && block.blank?
-            raise ArgumentError, "#{T.must(name).demodulize} only supports a regex when using a `strategy` block"
+            raise ArgumentError,
+                  "#{Utils.demodulize(T.must(name))} only supports a regex when using a `strategy` block"
           end
 
-          match_data = { matches: {}, regex: regex, url: url }
+          match_data = { matches: {}, regex:, url: }
 
           match_data.merge!(Strategy.page_content(url))
           content = match_data.delete(:content)
+          return match_data if content.blank?
 
           versions_from_content(content, regex, &block).each do |version_text|
             match_data[:matches][version_text] = Version.new(version_text)
diff --git a/Library/Homebrew/livecheck/strategy/xml.rb b/Library/Homebrew/livecheck/strategy/xml.rb
new file mode 100644
index 0000000000000..e8b741e9ffa37
--- /dev/null
+++ b/Library/Homebrew/livecheck/strategy/xml.rb
@@ -0,0 +1,173 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  module Livecheck
+    module Strategy
+      # The {Xml} strategy fetches content at a URL, parses it as XML using
+      # `REXML` and provides the `REXML::Document` to a `strategy` block.
+      # If a regex is present in the `livecheck` block, it should be passed
+      # as the second argument to the `strategy` block.
+      #
+      # This is a generic strategy that doesn't contain any logic for finding
+      # versions, as the structure of XML data varies. Instead, a `strategy`
+      # block must be used to extract version information from the XML data.
+      # For more information on how to work with an `REXML::Document` object,
+      # please refer to the [`REXML::Document`](https://ruby.github.io/rexml/REXML/Document.html)
+      # and [`REXML::Element`](https://ruby.github.io/rexml/REXML/Element.html)
+      # documentation.
+      #
+      # This strategy is not applied automatically and it is necessary to use
+      # `strategy :xml` in a `livecheck` block (in conjunction with a
+      # `strategy` block) to use it.
+      #
+      # This strategy's {find_versions} method can be used in other strategies
+      # that work with XML content, so it should only be necessary to write
+      # the version-finding logic that works with the parsed XML data.
+      #
+      # @api public
+      class Xml
+        NICE_NAME = "XML"
+
+        # A priority of zero causes livecheck to skip the strategy. We do this
+        # for {Xml} so we can selectively apply it only when a strategy block
+        # is provided in a `livecheck` block.
+        PRIORITY = 0
+
+        # The `Regexp` used to determine if the strategy applies to the URL.
+        URL_MATCH_REGEX = %r{^https?://}i
+
+        # Whether the strategy can be applied to the provided URL.
+        # {Xml} will technically match any HTTP URL but is only usable with
+        # a `livecheck` block containing a `strategy` block.
+        #
+        # @param url [String] the URL to match against
+        # @return [Boolean]
+        sig { params(url: String).returns(T::Boolean) }
+        def self.match?(url)
+          URL_MATCH_REGEX.match?(url)
+        end
+
+        # Parses XML text and returns an `REXML::Document` object.
+        # @param content [String] the XML text to parse
+        # @return [REXML::Document, nil]
+        sig { params(content: String).returns(T.nilable(REXML::Document)) }
+        def self.parse_xml(content)
+          parsing_tries = 0
+          begin
+            REXML::Document.new(content)
+          rescue REXML::UndefinedNamespaceException => e
+            undefined_prefix = e.to_s[/Undefined prefix ([^ ]+) found/i, 1]
+            raise "Could not identify undefined prefix." if undefined_prefix.blank?
+
+            # Only retry parsing once after removing prefix from content
+            parsing_tries += 1
+            raise "Could not parse XML after removing undefined prefix." if parsing_tries > 1
+
+            # When an XML document contains a prefix without a corresponding
+            # namespace, it's necessary to remove the prefix from the content
+            # to be able to successfully parse it using REXML
+            content = content.gsub(%r{(</?| )#{Regexp.escape(undefined_prefix)}:}, '\1')
+            retry
+          end
+        end
+
+        # Retrieves the stripped inner text of an `REXML` element. Returns
+        # `nil` if the optional child element doesn't exist or the text is
+        # blank.
+        # @param element [REXML::Element] an `REXML` element to retrieve text
+        #   from, either directly or from a child element
+        # @param child_path [String, nil] the XPath of a child element to
+        #   retrieve text from
+        # @return [String, nil]
+        sig {
+          params(
+            element:    REXML::Element,
+            child_path: T.nilable(String),
+          ).returns(T.nilable(String))
+        }
+        def self.element_text(element, child_path = nil)
+          element = element.get_elements(child_path).first if child_path.present?
+          return if element.nil?
+
+          text = element.text
+          return if text.blank?
+
+          text.strip
+        end
+
+        # Parses XML text and identifies versions using a `strategy` block.
+        # If a regex is provided, it will be passed as the second argument to
+        # the  `strategy` block (after the parsed XML data).
+        # @param content [String] the XML text to parse and check
+        # @param regex [Regexp, nil] a regex used for matching versions in the
+        #   content
+        # @return [Array]
+        sig {
+          params(
+            content: String,
+            regex:   T.nilable(Regexp),
+            block:   T.nilable(Proc),
+          ).returns(T::Array[String])
+        }
+        def self.versions_from_content(content, regex = nil, &block)
+          return [] if content.blank? || block.blank?
+
+          require "rexml"
+          xml = parse_xml(content)
+          return [] if xml.blank?
+
+          block_return_value = if regex.present?
+            yield(xml, regex)
+          elsif block.arity == 2
+            raise "Two arguments found in `strategy` block but no regex provided."
+          else
+            yield(xml)
+          end
+          Strategy.handle_block_return(block_return_value)
+        end
+
+        # Checks the XML content at the URL for versions, using the provided
+        # `strategy` block to extract version information.
+        #
+        # @param url [String] the URL of the content to check
+        # @param regex [Regexp, nil] a regex used for matching versions
+        # @param provided_content [String, nil] page content to use in place of
+        #   fetching via `Strategy#page_content`
+        # @param homebrew_curl [Boolean] whether to use brewed curl with the URL
+        # @return [Hash]
+        sig {
+          params(
+            url:              String,
+            regex:            T.nilable(Regexp),
+            provided_content: T.nilable(String),
+            homebrew_curl:    T::Boolean,
+            _unused:          T.untyped,
+            block:            T.nilable(Proc),
+          ).returns(T::Hash[Symbol, T.untyped])
+        }
+        def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: false, **_unused, &block)
+          raise ArgumentError, "#{Utils.demodulize(T.must(name))} requires a `strategy` block" if block.blank?
+
+          match_data = { matches: {}, regex:, url: }
+          return match_data if url.blank? || block.blank?
+
+          content = if provided_content.is_a?(String)
+            match_data[:cached] = true
+            provided_content
+          else
+            match_data.merge!(Strategy.page_content(url, homebrew_curl:))
+            match_data[:content]
+          end
+          return match_data if content.blank?
+
+          versions_from_content(content, regex, &block).each do |match_text|
+            match_data[:matches][match_text] = Version.new(match_text)
+          end
+
+          match_data
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/livecheck/strategy/xorg.rb b/Library/Homebrew/livecheck/strategy/xorg.rb
index 25e1ae0510c84..cd1999c5ce3ce 100644
--- a/Library/Homebrew/livecheck/strategy/xorg.rb
+++ b/Library/Homebrew/livecheck/strategy/xorg.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
@@ -38,27 +38,25 @@ module Strategy
       #
       # @api public
       class Xorg
-        extend T::Sig
-
         NICE_NAME = "X.Org"
 
         # A `Regexp` used in determining if the strategy applies to the URL and
         # also as part of extracting the module name from the URL basename.
-        MODULE_REGEX = /(?<module_name>.+)-\d+/i.freeze
+        MODULE_REGEX = /(?<module_name>.+)-\d+/i
 
         # A `Regexp` used to extract the module name from the URL basename.
-        FILENAME_REGEX = /^#{MODULE_REGEX.source.strip}/i.freeze
+        FILENAME_REGEX = /^#{MODULE_REGEX.source.strip}/i
 
         # The `Regexp` used to determine if the strategy applies to the URL.
         URL_MATCH_REGEX = %r{
           ^https?://(?:[^/]+?\.)* # Scheme and any leading subdomains
           (?:x\.org/(?:[^/]+/)*individual/(?:[^/]+/)*#{MODULE_REGEX.source.strip}
           |freedesktop\.org/(?:archive|dist|software)/(?:[^/]+/)*#{MODULE_REGEX.source.strip})
-        }ix.freeze
+        }ix
 
         # Used to cache page content, so we don't fetch the same pages
         # repeatedly.
-        @page_data = {}
+        @page_data = T.let({}, T::Hash[String, String])
 
         # Whether the strategy can be applied to the provided URL.
         #
@@ -113,8 +111,8 @@ def self.generate_input_values(url)
           params(
             url:    String,
             regex:  T.nilable(Regexp),
-            unused: T.nilable(T::Hash[Symbol, T.untyped]),
-            block:  T.untyped,
+            unused: T.untyped,
+            block:  T.nilable(Proc),
           ).returns(T::Hash[Symbol, T.untyped])
         }
         def self.find_versions(url:, regex: nil, **unused, &block)
@@ -123,7 +121,7 @@ def self.find_versions(url:, regex: nil, **unused, &block)
 
           # Use the cached page content to avoid duplicate fetches
           cached_content = @page_data[generated_url]
-          match_data = T.unsafe(PageMatch).find_versions(
+          match_data = PageMatch.find_versions(
             url:              generated_url,
             regex:            regex || generated[:regex],
             provided_content: cached_content,
diff --git a/Library/Homebrew/livecheck/strategy/yaml.rb b/Library/Homebrew/livecheck/strategy/yaml.rb
new file mode 100644
index 0000000000000..371128a7a989e
--- /dev/null
+++ b/Library/Homebrew/livecheck/strategy/yaml.rb
@@ -0,0 +1,133 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  module Livecheck
+    module Strategy
+      # The {Yaml} strategy fetches content at a URL, parses it as YAML and
+      # provides the parsed data to a `strategy` block. If a regex is present
+      # in the `livecheck` block, it should be passed as the second argument to
+      # the `strategy` block.
+      #
+      # This is a generic strategy that doesn't contain any logic for finding
+      # versions, as the structure of YAML data varies. Instead, a `strategy`
+      # block must be used to extract version information from the YAML data.
+      #
+      # This strategy is not applied automatically and it is necessary to use
+      # `strategy :yaml` in a `livecheck` block (in conjunction with a
+      # `strategy` block) to use it.
+      #
+      # This strategy's {find_versions} method can be used in other strategies
+      # that work with YAML content, so it should only be necessary to write
+      # the version-finding logic that works with the parsed YAML data.
+      #
+      # @api public
+      class Yaml
+        NICE_NAME = "YAML"
+
+        # A priority of zero causes livecheck to skip the strategy. We do this
+        # for {Yaml} so we can selectively apply it only when a strategy block
+        # is provided in a `livecheck` block.
+        PRIORITY = 0
+
+        # The `Regexp` used to determine if the strategy applies to the URL.
+        URL_MATCH_REGEX = %r{^https?://}i
+
+        # Whether the strategy can be applied to the provided URL.
+        # {Yaml} will technically match any HTTP URL but is only usable with
+        # a `livecheck` block containing a `strategy` block.
+        #
+        # @param url [String] the URL to match against
+        # @return [Boolean]
+        sig { params(url: String).returns(T::Boolean) }
+        def self.match?(url)
+          URL_MATCH_REGEX.match?(url)
+        end
+
+        # Parses YAML text and returns the parsed data.
+        # @param content [String] the YAML text to parse
+        sig { params(content: String).returns(T.untyped) }
+        def self.parse_yaml(content)
+          require "yaml"
+
+          begin
+            YAML.safe_load(content, permitted_classes: [Date, Time])
+          rescue Psych::SyntaxError
+            raise "Content could not be parsed as YAML."
+          end
+        end
+
+        # Parses YAML text and identifies versions using a `strategy` block.
+        # If a regex is provided, it will be passed as the second argument to
+        # the  `strategy` block (after the parsed YAML data).
+        # @param content [String] the YAML text to parse and check
+        # @param regex [Regexp, nil] a regex used for matching versions in the
+        #   content
+        # @return [Array]
+        sig {
+          params(
+            content: String,
+            regex:   T.nilable(Regexp),
+            block:   T.nilable(Proc),
+          ).returns(T::Array[String])
+        }
+        def self.versions_from_content(content, regex = nil, &block)
+          return [] if content.blank? || block.blank?
+
+          yaml = parse_yaml(content)
+          return [] if yaml.blank?
+
+          block_return_value = if regex.present?
+            yield(yaml, regex)
+          elsif block.arity == 2
+            raise "Two arguments found in `strategy` block but no regex provided."
+          else
+            yield(yaml)
+          end
+          Strategy.handle_block_return(block_return_value)
+        end
+
+        # Checks the YAML content at the URL for versions, using the provided
+        # `strategy` block to extract version information.
+        #
+        # @param url [String] the URL of the content to check
+        # @param regex [Regexp, nil] a regex used for matching versions
+        # @param provided_content [String, nil] page content to use in place of
+        #   fetching via `Strategy#page_content`
+        # @param homebrew_curl [Boolean] whether to use brewed curl with the URL
+        # @return [Hash]
+        sig {
+          params(
+            url:              String,
+            regex:            T.nilable(Regexp),
+            provided_content: T.nilable(String),
+            homebrew_curl:    T::Boolean,
+            _unused:          T.untyped,
+            block:            T.nilable(Proc),
+          ).returns(T::Hash[Symbol, T.untyped])
+        }
+        def self.find_versions(url:, regex: nil, provided_content: nil, homebrew_curl: false, **_unused, &block)
+          raise ArgumentError, "#{Utils.demodulize(T.must(name))} requires a `strategy` block" if block.blank?
+
+          match_data = { matches: {}, regex:, url: }
+          return match_data if url.blank? || block.blank?
+
+          content = if provided_content.is_a?(String)
+            match_data[:cached] = true
+            provided_content
+          else
+            match_data.merge!(Strategy.page_content(url, homebrew_curl:))
+            match_data[:content]
+          end
+          return match_data if content.blank?
+
+          versions_from_content(content, regex, &block).each do |match_text|
+            match_data[:matches][match_text] = Version.new(match_text)
+          end
+
+          match_data
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/locale.rb b/Library/Homebrew/locale.rb
index eefbc464f857e..49b28c0795a09 100644
--- a/Library/Homebrew/locale.rb
+++ b/Library/Homebrew/locale.rb
@@ -1,31 +1,27 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 # Representation of a system locale.
 #
 # Used to compare the system language and languages defined using the cask `language` stanza.
-#
-# @api private
 class Locale
-  extend T::Sig
-
   # Error when a string cannot be parsed to a `Locale`.
   class ParserError < StandardError
   end
 
   # ISO 639-1 or ISO 639-2
-  LANGUAGE_REGEX = /(?:[a-z]{2,3})/.freeze
+  LANGUAGE_REGEX = /(?:[a-z]{2,3})/
   private_constant :LANGUAGE_REGEX
 
-  # ISO 3166-1 or UN M.49
-  REGION_REGEX = /(?:[A-Z]{2}|\d{3})/.freeze
-  private_constant :REGION_REGEX
-
   # ISO 15924
-  SCRIPT_REGEX = /(?:[A-Z][a-z]{3})/.freeze
+  SCRIPT_REGEX = /(?:[A-Z][a-z]{3})/
   private_constant :SCRIPT_REGEX
 
-  LOCALE_REGEX = /\A((?:#{LANGUAGE_REGEX}|#{REGION_REGEX}|#{SCRIPT_REGEX})(?:-|$)){1,3}\Z/.freeze
+  # ISO 3166-1 or UN M.49
+  REGION_REGEX = /(?:[A-Z]{2}|\d{3})/
+  private_constant :REGION_REGEX
+
+  LOCALE_REGEX = /\A((?:#{LANGUAGE_REGEX}|#{REGION_REGEX}|#{SCRIPT_REGEX})(?:-|$)){1,3}\Z/
   private_constant :LOCALE_REGEX
 
   def self.parse(string)
@@ -43,35 +39,35 @@ def self.try_parse(string)
     scanner = StringScanner.new(string)
 
     if (language = scanner.scan(LANGUAGE_REGEX))
-      sep = scanner.scan(/-/)
+      sep = scanner.scan("-")
       return if (sep && scanner.eos?) || (sep.nil? && !scanner.eos?)
     end
 
-    if (region = scanner.scan(REGION_REGEX))
-      sep = scanner.scan(/-/)
+    if (script = scanner.scan(SCRIPT_REGEX))
+      sep = scanner.scan("-")
       return if (sep && scanner.eos?) || (sep.nil? && !scanner.eos?)
     end
 
-    script = scanner.scan(SCRIPT_REGEX)
+    region = scanner.scan(REGION_REGEX)
 
     return unless scanner.eos?
 
-    new(language, region, script)
+    new(language, script, region)
   end
 
-  attr_reader :language, :region, :script
+  attr_reader :language, :script, :region
 
-  def initialize(language, region, script)
+  def initialize(language, script, region)
     raise ArgumentError, "#{self.class} cannot be empty" if language.nil? && region.nil? && script.nil?
 
     {
-      language: language,
-      region:   region,
-      script:   script,
+      language:,
+      script:,
+      region:,
     }.each do |key, value|
       next if value.nil?
 
-      regex = self.class.const_get("#{key.upcase}_REGEX")
+      regex = self.class.const_get(:"#{key.upcase}_REGEX")
       raise ParserError, "'#{value}' does not match #{regex}" unless value&.match?(regex)
 
       instance_variable_set(:"@#{key}", value)
@@ -84,7 +80,7 @@ def include?(other)
       return false if other.nil?
     end
 
-    [:language, :region, :script].all? do |var|
+    [:language, :script, :region].all? do |var|
       if other.public_send(var).nil?
         true
       else
@@ -99,7 +95,7 @@ def eql?(other)
       return false if other.nil?
     end
 
-    [:language, :region, :script].all? do |var|
+    [:language, :script, :region].all? do |var|
       public_send(var) == other.public_send(var)
     end
   end
@@ -112,6 +108,6 @@ def detect(locale_groups)
 
   sig { returns(String) }
   def to_s
-    [@language, @region, @script].compact.join("-")
+    [@language, @script, @region].compact.join("-")
   end
 end
diff --git a/Library/Homebrew/lock_file.rb b/Library/Homebrew/lock_file.rb
index 4ea97b04cd150..3f37bddaaf58d 100644
--- a/Library/Homebrew/lock_file.rb
+++ b/Library/Homebrew/lock_file.rb
@@ -1,17 +1,17 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "fcntl"
 
-# A lock file.
-#
-# @api private
+# A lock file to prevent multiple Homebrew processes from modifying the same path.
 class LockFile
   attr_reader :path
 
-  def initialize(name)
-    @name = name.to_s
-    @path = HOMEBREW_LOCKS/"#{@name}.lock"
+  sig { params(type: Symbol, locked_path: Pathname).void }
+  def initialize(type, locked_path)
+    @locked_path = locked_path
+    lock_name = locked_path.basename.to_s
+    @path = HOMEBREW_LOCKS/"#{lock_name}.#{type}.lock"
     @lockfile = nil
   end
 
@@ -20,7 +20,7 @@ def lock
     create_lockfile
     return if @lockfile.flock(File::LOCK_EX | File::LOCK_NB)
 
-    raise OperationInProgressError, @name
+    raise OperationInProgressError, @locked_path
   end
 
   def unlock
@@ -42,25 +42,35 @@ def with_lock
   def create_lockfile
     return if @lockfile.present? && !@lockfile.closed?
 
-    @lockfile = @path.open(File::RDWR | File::CREAT)
+    begin
+      @lockfile = @path.open(File::RDWR | File::CREAT)
+    rescue Errno::EMFILE
+      odie "The maximum number of open files on this system has been reached. Use `ulimit -n` to increase this limit."
+    end
     @lockfile.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
   end
 end
 
 # A lock file for a formula.
-#
-# @api private
 class FormulaLock < LockFile
-  def initialize(name)
-    super("#{name}.formula")
+  sig { params(rack_name: String).void }
+  def initialize(rack_name)
+    super(:formula, HOMEBREW_CELLAR/rack_name)
   end
 end
 
 # A lock file for a cask.
-#
-# @api private
 class CaskLock < LockFile
-  def initialize(name)
-    super("#{name}.cask")
+  sig { params(cask_token: String).void }
+  def initialize(cask_token)
+    super(:cask, HOMEBREW_PREFIX/"Caskroom/#{cask_token}")
+  end
+end
+
+# A lock file for a download.
+class DownloadLock < LockFile
+  sig { params(download_path: Pathname).void }
+  def initialize(download_path)
+    super(:download, download_path)
   end
 end
diff --git a/Library/Homebrew/macos_runner_spec.rb b/Library/Homebrew/macos_runner_spec.rb
new file mode 100644
index 0000000000000..40cd561e6242c
--- /dev/null
+++ b/Library/Homebrew/macos_runner_spec.rb
@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+class MacOSRunnerSpec < T::Struct
+  const :name, String
+  const :runner, String
+  const :timeout, Integer
+  const :cleanup, T::Boolean
+  prop  :testing_formulae, T::Array[String], default: []
+
+  sig {
+    returns({
+      name:             String,
+      runner:           String,
+      timeout:          Integer,
+      cleanup:          T::Boolean,
+      testing_formulae: String,
+    })
+  }
+  def to_h
+    {
+      name:,
+      runner:,
+      timeout:,
+      cleanup:,
+      testing_formulae: testing_formulae.join(","),
+    }
+  end
+end
diff --git a/Library/Homebrew/macos_version.rb b/Library/Homebrew/macos_version.rb
new file mode 100644
index 0000000000000..9c1cd7117fd08
--- /dev/null
+++ b/Library/Homebrew/macos_version.rb
@@ -0,0 +1,155 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "version"
+
+# A macOS version.
+class MacOSVersion < Version
+  # Raised when a macOS version is unsupported.
+  class Error < RuntimeError
+    sig { returns(T.nilable(T.any(String, Symbol))) }
+    attr_reader :version
+
+    def initialize(version)
+      @version = version
+      super "unknown or unsupported macOS version: #{version.inspect}"
+    end
+  end
+
+  # NOTE: When removing symbols here, ensure that they are added
+  #       to `DEPRECATED_MACOS_VERSIONS` in `MacOSRequirement`.
+  SYMBOLS = {
+    sequoia:     "15",
+    sonoma:      "14",
+    ventura:     "13",
+    monterey:    "12",
+    big_sur:     "11",
+    catalina:    "10.15",
+    mojave:      "10.14",
+    high_sierra: "10.13",
+    sierra:      "10.12",
+    el_capitan:  "10.11",
+  }.freeze
+
+  sig { params(macos_version: MacOSVersion).returns(Version) }
+  def self.kernel_major_version(macos_version)
+    version_major = macos_version.major.to_i
+    if version_major > 10
+      Version.new((version_major + 9).to_s)
+    else
+      version_minor = macos_version.minor.to_i
+      Version.new((version_minor + 4).to_s)
+    end
+  end
+
+  sig { params(version: Symbol).returns(T.attached_class) }
+  def self.from_symbol(version)
+    str = SYMBOLS.fetch(version) { raise MacOSVersion::Error, version }
+    new(str)
+  end
+
+  sig { params(version: T.nilable(String)).void }
+  def initialize(version)
+    raise MacOSVersion::Error, version unless /\A1\d+(?:\.\d+){0,2}\Z/.match?(version)
+
+    super(T.must(version))
+
+    @comparison_cache = {}
+  end
+
+  sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
+  def <=>(other)
+    return @comparison_cache[other] if @comparison_cache.key?(other)
+
+    result = case other
+    when Symbol
+      if SYMBOLS.key?(other) && to_sym == other
+        0
+      else
+        v = SYMBOLS.fetch(other) { other.to_s }
+        super(v)
+      end
+    else
+      super
+    end
+
+    @comparison_cache[other] = result unless frozen?
+
+    result
+  end
+
+  sig { returns(T.self_type) }
+  def strip_patch
+    return self if null?
+
+    # Big Sur is 11.x but Catalina is 10.15.x.
+    if T.must(major) >= 11
+      self.class.new(major.to_s)
+    else
+      major_minor
+    end
+  end
+
+  sig { returns(Symbol) }
+  def to_sym
+    return @sym if defined?(@sym)
+
+    sym = SYMBOLS.invert.fetch(strip_patch.to_s, :dunno)
+
+    @sym = sym unless frozen?
+
+    sym
+  end
+
+  sig { returns(String) }
+  def pretty_name
+    return @pretty_name if defined?(@pretty_name)
+
+    pretty_name = to_sym.to_s.split("_").map(&:capitalize).join(" ").freeze
+
+    @pretty_name = pretty_name unless frozen?
+
+    pretty_name
+  end
+
+  sig { returns(String) }
+  def inspect
+    "#<#{self.class.name}: #{to_s.inspect}>"
+  end
+
+  sig { returns(T::Boolean) }
+  def outdated_release?
+    self < HOMEBREW_MACOS_OLDEST_SUPPORTED
+  end
+
+  sig { returns(T::Boolean) }
+  def prerelease?
+    self >= HOMEBREW_MACOS_NEWEST_UNSUPPORTED
+  end
+
+  sig { returns(T::Boolean) }
+  def unsupported_release?
+    outdated_release? || prerelease?
+  end
+
+  sig { returns(T::Boolean) }
+  def requires_nehalem_cpu?
+    return false if null?
+
+    require "hardware"
+
+    return Hardware.oldest_cpu(self) == :nehalem if Hardware::CPU.intel?
+
+    raise ArgumentError, "Unexpected architecture: #{Hardware::CPU.arch}. This only works with Intel architecture."
+  end
+  # https://en.wikipedia.org/wiki/Nehalem_(microarchitecture)
+  alias requires_sse4? requires_nehalem_cpu?
+  alias requires_sse41? requires_nehalem_cpu?
+  alias requires_sse42? requires_nehalem_cpu?
+  alias requires_popcnt? requires_nehalem_cpu?
+
+  # Represents the absence of a version.
+  #
+  # NOTE: Constructor needs to called with an arbitrary macOS-like version which is then set to `nil`.
+  NULL = MacOSVersion.new("10.0").tap { |v| v.instance_variable_set(:@version, nil) }.freeze
+end
diff --git a/Library/Homebrew/macos_versions.rb b/Library/Homebrew/macos_versions.rb
deleted file mode 100644
index 16d4bd47e4ad3..0000000000000
--- a/Library/Homebrew/macos_versions.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-# Helper functions for querying operating system information.
-#
-# @api private
-module MacOSVersions
-  # TODO: when removing symbols here, ensure that they are added to
-  # DEPRECATED_MACOS_VERSIONS in MacOSRequirement.
-  SYMBOLS = {
-    ventura:     "13",
-    monterey:    "12",
-    big_sur:     "11",
-    catalina:    "10.15",
-    mojave:      "10.14",
-    high_sierra: "10.13",
-    sierra:      "10.12",
-    el_capitan:  "10.11",
-  }.freeze
-end
diff --git a/Library/Homebrew/manpages.rb b/Library/Homebrew/manpages.rb
new file mode 100644
index 0000000000000..3b3048017faff
--- /dev/null
+++ b/Library/Homebrew/manpages.rb
@@ -0,0 +1,195 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "cli/parser"
+require "erb"
+
+SOURCE_PATH = (HOMEBREW_LIBRARY_PATH/"manpages").freeze
+TARGET_MAN_PATH = (HOMEBREW_REPOSITORY/"manpages").freeze
+TARGET_DOC_PATH = (HOMEBREW_REPOSITORY/"docs").freeze
+module Homebrew
+  # Helper functions for generating homebrew manual.
+  module Manpages
+    Variables = Struct.new(
+      :alumni,
+      :commands,
+      :developer_commands,
+      :environment_variables,
+      :global_cask_options,
+      :global_options,
+      :lead,
+      :maintainers,
+      :official_external_commands,
+      :plc,
+      :tsc,
+      keyword_init: true,
+    )
+
+    def self.regenerate_man_pages(quiet:)
+      require "kramdown"
+      require "manpages/parser/ronn"
+      require "manpages/converter/kramdown"
+      require "manpages/converter/roff"
+
+      markup = build_man_page(quiet:)
+      root, warnings = Parser::Ronn.parse(markup)
+      $stderr.puts(warnings)
+
+      roff, warnings = Converter::Kramdown.convert(root)
+      $stderr.puts(warnings)
+      File.write(TARGET_DOC_PATH/"Manpage.md", roff)
+
+      roff, warnings = Converter::Roff.convert(root)
+      $stderr.puts(warnings)
+      File.write(TARGET_MAN_PATH/"brew.1", roff)
+    end
+
+    def self.build_man_page(quiet:)
+      template = (SOURCE_PATH/"brew.1.md.erb").read
+      readme = HOMEBREW_REPOSITORY/"README.md"
+      variables = Variables.new(
+        commands:                   generate_cmd_manpages(Commands.internal_commands_paths),
+        developer_commands:         generate_cmd_manpages(Commands.internal_developer_commands_paths),
+        official_external_commands: generate_cmd_manpages(Commands.official_external_commands_paths(quiet:)),
+        global_cask_options:        global_cask_options_manpage,
+        global_options:             global_options_manpage,
+        environment_variables:      env_vars_manpage,
+        lead:                       readme.read[/(Homebrew's \[Project Leader.*\.)/, 1]
+                                      .gsub(/\[([^\]]+)\]\([^)]+\)/, '\1'),
+        plc:                        readme.read[/(Homebrew's \[Project Leadership Committee.*\.)/, 1]
+                                      .gsub(/\[([^\]]+)\]\([^)]+\)/, '\1'),
+        tsc:                        readme.read[/(Homebrew's \[Technical Steering Committee.*\.)/, 1]
+                                      .gsub(/\[([^\]]+)\]\([^)]+\)/, '\1'),
+        maintainers:                readme.read[/(Homebrew's maintainers .*\.)/, 1]
+                                      .gsub(/\[([^\]]+)\]\([^)]+\)/, '\1'),
+        alumni:                     readme.read[/(Former maintainers .*\.)/, 1]
+                                      .gsub(/\[([^\]]+)\]\([^)]+\)/, '\1'),
+      )
+
+      ERB.new(template, trim_mode: ">").result(variables.instance_eval { binding })
+    end
+
+    def self.sort_key_for_path(path)
+      # Options after regular commands (`~` comes after `z` in ASCII table).
+      path.basename.to_s.sub(/\.(rb|sh)$/, "").sub(/^--/, "~~")
+    end
+
+    def self.generate_cmd_manpages(cmd_paths)
+      man_page_lines = []
+
+      # preserve existing manpage order
+      cmd_paths.sort_by { sort_key_for_path(_1) }
+               .each do |cmd_path|
+        cmd_man_page_lines = if (cmd_parser = Homebrew::CLI::Parser.from_cmd_path(cmd_path))
+          next if cmd_parser.hide_from_man_page
+
+          cmd_parser_manpage_lines(cmd_parser).join
+        else
+          cmd_comment_manpage_lines(cmd_path)&.join("\n")
+        end
+        # Convert subcommands to definition lists
+        cmd_man_page_lines&.gsub!(/(?<=\n\n)([\\?\[`].+):\n/, "\\1\n\n: ")
+
+        man_page_lines << cmd_man_page_lines
+      end
+
+      man_page_lines.compact.join("\n")
+    end
+
+    sig { params(cmd_parser: CLI::Parser).returns(T::Array[String]) }
+    def self.cmd_parser_manpage_lines(cmd_parser)
+      lines = [format_usage_banner(cmd_parser.usage_banner_text)]
+      lines += cmd_parser.processed_options.filter_map do |short, long, desc, hidden|
+        next if hidden
+
+        if long.present?
+          next if Homebrew::CLI::Parser.global_options.include?([short, long, desc])
+          next if Homebrew::CLI::Parser.global_cask_options.any? do |_, option, kwargs|
+                    [long, "#{long}="].include?(option) && kwargs.fetch(:description) == desc
+                  end
+        end
+
+        generate_option_doc(short, long, desc)
+      end
+      lines
+    end
+
+    def self.cmd_comment_manpage_lines(cmd_path)
+      comment_lines = cmd_path.read.lines.grep(/^#:/)
+      return if comment_lines.empty?
+      return if comment_lines.first.include?("@hide_from_man_page")
+
+      lines = [format_usage_banner(comment_lines.first).chomp]
+      comment_lines.slice(1..-1)
+                   .each do |line|
+        line = line.slice(4..-2)
+        unless line
+          lines.last << "\n"
+          next
+        end
+
+        # Omit the common global_options documented separately in the man page.
+        next if line.match?(/--(debug|help|quiet|verbose) /)
+
+        # Format one option or a comma-separated pair of short and long options.
+        line.gsub!(/^ +(-+[a-z-]+), (-+[a-z-]+) +(.*)$/, "`\\1`, `\\2`\n\n: \\3\n")
+        line.gsub!(/^ +(-+[a-z-]+) +(.*)$/, "`\\1`\n\n: \\2\n")
+
+        lines << line
+      end
+      lines.last << "\n"
+      lines
+    end
+
+    sig { returns(String) }
+    def self.global_cask_options_manpage
+      lines = ["These options are applicable to the `install`, `reinstall` and `upgrade` " \
+               "subcommands with the `--cask` switch.\n"]
+      lines += Homebrew::CLI::Parser.global_cask_options.map do |_, long, kwargs|
+        generate_option_doc(nil, long.chomp("="), kwargs.fetch(:description))
+      end
+      lines.join("\n")
+    end
+
+    sig { returns(String) }
+    def self.global_options_manpage
+      lines = ["These options are applicable across multiple subcommands.\n"]
+      lines += Homebrew::CLI::Parser.global_options.map do |short, long, desc|
+        generate_option_doc(short, long, desc)
+      end
+      lines.join("\n")
+    end
+
+    sig { returns(String) }
+    def self.env_vars_manpage
+      lines = Homebrew::EnvConfig::ENVS.flat_map do |env, hash|
+        entry = "`#{env}`\n\n: #{hash[:description]}\n"
+        default = hash[:default_text]
+        default ||= "`#{hash[:default]}`." if hash[:default]
+        entry += "\n\n    *Default:* #{default}\n" if default
+
+        entry
+      end
+      lines.join("\n")
+    end
+
+    def self.format_opt(opt)
+      "`#{opt}`" unless opt.nil?
+    end
+
+    def self.generate_option_doc(short, long, desc)
+      comma = (short && long) ? ", " : ""
+      <<~EOS
+        #{format_opt(short)}#{comma}#{format_opt(long)}
+
+        : #{desc}
+
+      EOS
+    end
+
+    def self.format_usage_banner(usage_banner)
+      usage_banner&.sub(/^(#: *\* )?/, "### ")
+                  &.gsub(/(?<!`)\[([^\[\]]*)\](?!`)/, "\\[\\1\\]") # escape [] character (except those in code spans)
+    end
+  end
+end
diff --git a/Library/Homebrew/manpages/brew.1.md.erb b/Library/Homebrew/manpages/brew.1.md.erb
index bd0d68ea7c617..838842ff765f9 100644
--- a/Library/Homebrew/manpages/brew.1.md.erb
+++ b/Library/Homebrew/manpages/brew.1.md.erb
@@ -20,35 +20,63 @@ brew(1) -- The Missing Package Manager for macOS (or Linux)
 ## SYNOPSIS
 
 `brew` `--version`<br>
-`brew` <command> [`--verbose`|`-v`] [<options>] [<formula>] ...
+`brew` <command> \[`--verbose`\|`-v`\] \[<options>\] \[<formula>\] ...
 
 ## DESCRIPTION
 
 Homebrew is the easiest and most flexible way to install the UNIX tools Apple
 didn't include with macOS. It can also install software not packaged for your
-Linux distribution to your home directory without requiring `sudo`.
+Linux distribution without requiring `sudo`.
 
 ## TERMINOLOGY
 
-**formula**: Homebrew package definition built from upstream sources
+**formula**
 
-**cask**: Homebrew package definition that installs macOS native applications
+: Homebrew package definition that builds from upstream sources
 
-**keg**: installation destination directory of a given **formula** version e.g. `/usr/local/Cellar/foo/0.1`
+**cask**
 
-**rack**: directory containing one or more versioned kegs e.g. `/usr/local/Cellar/foo`
+: Homebrew package definition that installs macOS native applications
 
-**keg-only**: a **formula** is **keg-only** if it is not symlinked into Homebrew's prefix (e.g. `/usr/local`)
+**prefix**
 
-**cellar**: directory containing one or more named **racks** e.g. `/usr/local/Cellar`
+: path in which Homebrew is installed, e.g. `/usr/local`
 
-**Caskroom**: directory containing one or more named **casks** e.g. `/usr/local/Caskroom`
+**keg**
 
-**external command**: `brew` subcommand defined outside of the Homebrew/brew GitHub repository
+: installation destination directory of a given **formula** version, e.g. `/usr/local/Cellar/foo/0.1`
 
-**tap**: directory (and usually Git repository) of **formulae**, **casks** and/or **external commands**
+**rack**
 
-**bottle**: pre-built **keg** poured into the **cellar**/**rack** instead of building from upstream sources
+: directory containing one or more versioned **kegs**, e.g. `/usr/local/Cellar/foo`
+
+**keg-only**
+
+: a **formula** is *keg-only* if it is not symlinked into Homebrew's prefix
+
+**opt prefix**
+
+: a symlink to the active version of a **keg**, e.g. `/usr/local/opt/foo`
+
+**Cellar**
+
+: directory containing one or more named **racks**, e.g. `/usr/local/Cellar`
+
+**Caskroom**
+
+: directory containing one or more named **casks**, e.g. `/usr/local/Caskroom`
+
+**external command**
+
+: `brew` subcommand defined outside of the Homebrew/brew GitHub repository
+
+**tap**
+
+: directory (and usually Git repository) of **formulae**, **casks** and/or **external commands**
+
+**bottle**
+
+: pre-built **keg** poured into a **rack** of the **Cellar** instead of building from upstream sources
 
 ## ESSENTIAL COMMANDS
 
@@ -75,11 +103,11 @@ Uninstall <formula>.
 
 List all installed formulae.
 
-### `search` [<text>|`/`<text>`/`]
+### `search` \[<text>\|`/`<text>`/`\]
 
 Perform a substring search of cask tokens and formula names for <text>. If
-<text> is flanked by slashes, it is interpreted as a regular expression.
-The search for <text> is extended online to `homebrew/core` and `homebrew/cask`.
+<text> is flanked by slashes, it is interpreted as a regular expression. The
+search for <text> is extended online to `homebrew/core` and `homebrew/cask`.
 If no search term is provided, all locally available formulae are listed.
 
 ## COMMANDS
@@ -106,8 +134,8 @@ If no search term is provided, all locally available formulae are listed.
 
 Homebrew, like `git`(1), supports external commands. These are executable
 scripts that reside somewhere in the `PATH`, named `brew-`<cmdname> or
-`brew-`<cmdname>`.rb`, which can be invoked like `brew` <cmdname>. This allows
-you to create your own commands without modifying Homebrew's internals.
+`brew-`<cmdname>`.rb`, which can be invoked like `brew` <cmdname>. This
+allows you to create your own commands without modifying Homebrew's internals.
 
 Instructions for creating your own commands can be found in the docs:
 <https://docs.brew.sh/External-Commands>
@@ -144,6 +172,23 @@ Note that environment variables must have a value set to be detected. For
 example, run `export HOMEBREW_NO_INSECURE_REDIRECT=1` rather than just
 `export HOMEBREW_NO_INSECURE_REDIRECT`.
 
+`HOMEBREW_*` environment variables can also be set in Homebrew's environment
+files:
+
+* `/etc/homebrew/brew.env` (system-wide)
+
+* `$HOMEBREW_PREFIX/etc/homebrew/brew.env` (prefix-specific)
+
+* `$XDG_CONFIG_HOME/homebrew/brew.env` if `$XDG_CONFIG_HOME` is set or
+  `$HOME/.homebrew/brew.env` otherwise (user-specific)
+
+User-specific environment files take precedence over prefix-specific files and
+prefix-specific files take precedence over system-wide files (unless
+`HOMEBREW_SYSTEM_ENV_TAKES_PRIORITY` is set, see below).
+
+Note that these files do not support shell variable expansion e.g. `$HOME` or
+command execution e.g. `$(cat file)`.
+
 <%= environment_variables %>
 
 ## USING HOMEBREW BEHIND A PROXY
@@ -185,11 +230,14 @@ Homebrew API: <https://rubydoc.brew.sh>
 
 See our issues on GitHub:
 
-  * **Homebrew/brew**:
-    <br><https://github.com/Homebrew/brew/issues>
+**Homebrew/brew**
+
+: <https://github.com/Homebrew/brew/issues>
+
+**Homebrew/homebrew-core**
+
+: <https://github.com/Homebrew/homebrew-core/issues>
 
-  * **Homebrew/homebrew-core**:
-    <br><https://github.com/Homebrew/homebrew-core/issues>
+**Homebrew/homebrew-cask**
 
-  * **Homebrew/homebrew-cask**:
-    <br><https://github.com/Homebrew/homebrew-cask/issues>
+: <https://github.com/Homebrew/homebrew-cask/issues>
diff --git a/Library/Homebrew/manpages/converter/kramdown.rb b/Library/Homebrew/manpages/converter/kramdown.rb
new file mode 100644
index 0000000000000..448d4d45a3d3d
--- /dev/null
+++ b/Library/Homebrew/manpages/converter/kramdown.rb
@@ -0,0 +1,31 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "kramdown/converter/kramdown"
+
+module Homebrew
+  module Manpages
+    module Converter
+      # Converts our Kramdown-like input to pure Kramdown.
+      class Kramdown < ::Kramdown::Converter::Kramdown
+        def initialize(root, options)
+          super(root, options.merge(line_width: 80))
+        end
+
+        def convert_variable(element, _options)
+          "*`#{element.value}`*"
+        end
+
+        def convert_a(element, options)
+          text = inner(element, options)
+          if element.attr["href"] == text
+            # Don't duplicate the URL if the link text is the same as the URL.
+            "<#{text}>"
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/manpages/converter/roff.rb b/Library/Homebrew/manpages/converter/roff.rb
new file mode 100644
index 0000000000000..602336536873f
--- /dev/null
+++ b/Library/Homebrew/manpages/converter/roff.rb
@@ -0,0 +1,54 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "kramdown/converter/man"
+
+module Homebrew
+  module Manpages
+    module Converter
+      # Converts our Kramdown-like input to roff.
+      class Roff < ::Kramdown::Converter::Man
+        # Override that adds Homebrew metadata for the top level header
+        # and doesn't escape the text inside subheaders.
+        def convert_header(element, options)
+          if element.options[:level] == 1
+            element.attr["data-date"] = Date.today.strftime("%B %Y")
+            element.attr["data-extra"] = "Homebrew"
+            return super
+          end
+
+          result = +""
+          inner(element, options.merge(result:))
+          result.gsub!(" [", ' \fR[') # make args not bold
+
+          options[:result] << if element.options[:level] == 2
+            macro("SH", quote(result))
+          else
+            macro("SS", quote(result))
+          end
+        end
+
+        def convert_variable(element, options)
+          options[:result] << "\\fI#{escape(element.value)}\\fP"
+        end
+
+        def convert_a(element, options)
+          if element.attr["href"].chr == "#"
+            # Hide internal links - just make them italicised
+            convert_em(element, options)
+          else
+            super
+            # Remove the space after links if the next character is not a space
+            if options[:result].end_with?(".UE\n") &&
+               (next_element = options[:next]) &&
+               next_element.type == :text &&
+               next_element.value.chr.present? # i.e. not a space character
+              options[:result].chomp!
+              options[:result] << " "
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/manpages/parser/ronn.rb b/Library/Homebrew/manpages/parser/ronn.rb
new file mode 100644
index 0000000000000..36cddd6111cce
--- /dev/null
+++ b/Library/Homebrew/manpages/parser/ronn.rb
@@ -0,0 +1,41 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "kramdown/parser/kramdown"
+
+module Homebrew
+  module Manpages
+    module Parser
+      # Kramdown parser with compatiblity for ronn variable syntax.
+      class Ronn < ::Kramdown::Parser::Kramdown
+        def initialize(*)
+          super
+          # Disable HTML parsing and replace it with variable parsing.
+          # Also disable table parsing too because it depends on HTML parsing
+          # and existing command descriptions may get misinterpreted as tables.
+          # Typographic symbols is disabled as it detects `--` as en-dash.
+          @block_parsers.delete(:block_html)
+          @block_parsers.delete(:table)
+          @span_parsers.delete(:span_html)
+          @span_parsers.delete(:typographic_syms)
+          @span_parsers << :variable
+        end
+
+        # HTML-like tags denote variables instead, except <br>.
+        VARIABLE_REGEX = /<([\w\-\|]+)>/
+        def parse_variable
+          start_line_number = @src.current_line_number
+          @src.scan(VARIABLE_REGEX)
+          variable = @src[1]
+          if variable == "br"
+            @src.skip(/\n/)
+            @tree.children << Element.new(:br, nil, nil, location: start_line_number)
+          else
+            @tree.children << Element.new(:variable, variable, nil, location: start_line_number)
+          end
+        end
+        define_parser(:variable, VARIABLE_REGEX, "<")
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/messages.rb b/Library/Homebrew/messages.rb
index 89e03b551aacc..cdbf7059e9015 100644
--- a/Library/Homebrew/messages.rb
+++ b/Library/Homebrew/messages.rb
@@ -1,34 +1,43 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 # A {Messages} object collects messages that may need to be displayed together
 # at the end of a multi-step `brew` command run.
 class Messages
-  extend T::Sig
+  sig { returns(T::Array[T::Hash[Symbol, Symbol]]) }
+  attr_reader :caveats
 
-  attr_reader :caveats, :package_count, :install_times
+  sig { returns(Integer) }
+  attr_reader :package_count
+
+  sig { returns(T::Array[T::Hash[String, Float]]) }
+  attr_reader :install_times
 
   sig { void }
   def initialize
-    @caveats = []
-    @package_count = 0
-    @install_times = []
+    @caveats = T.let([], T::Array[T::Hash[Symbol, Symbol]])
+    @package_count = T.let(0, Integer)
+    @install_times = T.let([], T::Array[T::Hash[String, Float]])
   end
 
+  sig { params(package: String, caveats: T.any(String, Caveats)).void }
   def record_caveats(package, caveats)
-    @caveats.push(package: package, caveats: caveats)
+    @caveats.push(package:, caveats:)
   end
 
+  sig { params(package: String, elapsed_time: Float).void }
   def package_installed(package, elapsed_time)
     @package_count += 1
-    @install_times.push(package: package, time: elapsed_time)
+    @install_times.push(package:, time: elapsed_time)
   end
 
+  sig { params(force_caveats: T::Boolean, display_times: T::Boolean).void }
   def display_messages(force_caveats: false, display_times: false)
     display_caveats(force: force_caveats)
     display_install_times if display_times
   end
 
+  sig { params(force: T::Boolean).void }
   def display_caveats(force: false)
     return if @package_count.zero?
     return if @package_count == 1 && !force
@@ -40,6 +49,7 @@ def display_caveats(force: false)
     end
   end
 
+  sig { void }
   def display_install_times
     return if install_times.empty?
 
diff --git a/Library/Homebrew/metafiles.rb b/Library/Homebrew/metafiles.rb
index e7e71963df088..a321874cf2007 100644
--- a/Library/Homebrew/metafiles.rb
+++ b/Library/Homebrew/metafiles.rb
@@ -1,29 +1,33 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 # Helper for checking if a file is considered a metadata file.
-#
-# @api private
 module Metafiles
-  LICENSES = Set.new(%w[copying copyright license licence]).freeze
+  LICENSES = T.let(Set.new(%w[copying copyright license licence]).freeze, T::Set[String])
   # {https://github.com/github/markup#markups}
-  EXTENSIONS = Set.new(%w[
+  EXTENSIONS = T.let(Set.new(%w[
     .adoc .asc .asciidoc .creole .html .markdown .md .mdown .mediawiki .mkdn
     .org .pod .rdoc .rst .rtf .textile .txt .wiki
-  ]).freeze
-  BASENAMES = Set.new(%w[about authors changelog changes history news notes notice readme todo]).freeze
+  ]).freeze, T::Set[String])
+  BASENAMES = T.let(Set.new(%w[
+    about authors changelog changes history news notes notice readme todo
+  ]).freeze, T::Set[String])
 
   module_function
 
+  sig { params(file: String).returns(T::Boolean) }
   def list?(file)
     return false if %w[.DS_Store INSTALL_RECEIPT.json].include?(file)
 
     !copy?(file)
   end
 
+  sig { params(file: String).returns(T::Boolean) }
   def copy?(file)
     file = file.downcase
-    return true if LICENSES.include? file.split(/\.|-/).first
+    license = file.split(/\.|-/).first
+    return false unless license
+    return true if LICENSES.include?(license)
 
     ext  = File.extname(file)
     file = File.basename(file, ext) if EXTENSIONS.include?(ext)
diff --git a/Library/Homebrew/migrator.rb b/Library/Homebrew/migrator.rb
index ee60d5e2428b6..f44517d4572ad 100644
--- a/Library/Homebrew/migrator.rb
+++ b/Library/Homebrew/migrator.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "lock_file"
@@ -6,50 +6,39 @@
 require "tab"
 
 # Helper class for migrating a formula from an old to a new name.
-#
-# @api private
 class Migrator
-  extend T::Sig
-
   include Context
 
   # Error for when a migration is necessary.
   class MigrationNeededError < RuntimeError
-    def initialize(formula)
+    def initialize(oldname, newname)
       super <<~EOS
-        #{formula.oldname} was renamed to #{formula.name} and needs to be migrated by running:
-          brew migrate #{formula.oldname}
+        #{oldname} was renamed to #{newname} and needs to be migrated by running:
+          brew migrate #{oldname}
       EOS
     end
   end
 
-  # Error for when a formula does not replace another formula.
-  class MigratorNoOldnameError < RuntimeError
-    def initialize(formula)
-      super "#{formula.name} doesn't replace any formula."
-    end
-  end
-
   # Error for when the old name's path does not exist.
   class MigratorNoOldpathError < RuntimeError
-    def initialize(formula)
-      super "#{HOMEBREW_CELLAR/formula.oldname} doesn't exist."
+    def initialize(oldname)
+      super "#{HOMEBREW_CELLAR/oldname} doesn't exist."
     end
   end
 
   # Error for when a formula is migrated to a different tap without explicitly using its fully-qualified name.
   class MigratorDifferentTapsError < RuntimeError
-    def initialize(formula, tap)
+    def initialize(formula, oldname, tap)
       msg = if tap.core_tap?
-        "Please try to use #{formula.oldname} to refer to the formula.\n"
+        "Please try to use #{oldname} to refer to the formula.\n"
       elsif tap
-        "Please try to use fully-qualified #{tap}/#{formula.oldname} to refer to the formula.\n"
+        "Please try to use fully-qualified #{tap}/#{oldname} to refer to the formula.\n"
       end
 
       super <<~EOS
-        #{formula.name} from #{formula.tap} is given, but old name #{formula.oldname} was installed from #{tap || "path or url"}.
+        #{formula.name} from #{formula.tap} is given, but old name #{oldname} was installed from #{tap || "path or url"}.
         #{msg}To force migration, run:
-          brew migrate --force #{formula.oldname}
+          brew migrate --force #{oldname}
       EOS
     end
   end
@@ -67,13 +56,13 @@ def initialize(formula, tap)
   attr_reader :old_pin_record
 
   # Path to oldname opt.
-  attr_reader :old_opt_record
+  attr_reader :old_opt_records
 
-  # Oldname linked keg.
-  attr_reader :old_linked_keg
+  # Oldname linked kegs.
+  attr_reader :old_linked_kegs
 
-  # Path to oldname's linked keg.
-  attr_reader :old_linked_keg_record
+  # Oldname linked kegs that were fully linked.
+  attr_reader :old_full_linked_kegs
 
   # Tabs from oldname kegs.
   attr_reader :old_tabs
@@ -99,53 +88,63 @@ def initialize(formula, tap)
   # Path to newname keg that will be linked if old_linked_keg isn't nil.
   attr_reader :new_linked_keg_record
 
-  def self.needs_migration?(formula)
-    oldname = formula.oldname
-    return false unless oldname
+  def self.oldnames_needing_migration(formula)
+    formula.oldnames.select do |oldname|
+      oldname_rack = HOMEBREW_CELLAR/oldname
+      next false if oldname_rack.symlink?
+      next false unless oldname_rack.directory?
 
-    oldname_rack = HOMEBREW_CELLAR/oldname
-    return false if oldname_rack.symlink?
-    return false unless oldname_rack.directory?
+      true
+    end
+  end
 
-    true
+  def self.needs_migration?(formula)
+    !oldnames_needing_migration(formula).empty?
   end
 
   def self.migrate_if_needed(formula, force:, dry_run: false)
-    return unless Migrator.needs_migration?(formula)
+    oldnames = Migrator.oldnames_needing_migration(formula)
 
     begin
-      if dry_run
-        ohai "Would migrate #{formula.oldname} to #{formula.name}"
-        return
+      oldnames.each do |oldname|
+        if dry_run
+          oh1 "Would migrate formula #{Formatter.identifier(oldname)} to #{Formatter.identifier(formula.name)}"
+          next
+        end
+
+        migrator = Migrator.new(formula, oldname, force:)
+        migrator.migrate
       end
-      migrator = Migrator.new(formula, force: force)
-      migrator.migrate
     rescue => e
       onoe e
     end
   end
 
-  def initialize(formula, force: false)
-    @oldname = formula.oldname
+  def initialize(formula, oldname, force: false)
+    @oldname = oldname
     @newname = formula.name
-    raise MigratorNoOldnameError, formula unless oldname
 
     @formula = formula
-    @old_cellar = HOMEBREW_CELLAR/formula.oldname
-    raise MigratorNoOldpathError, formula unless old_cellar.exist?
+    @old_cellar = HOMEBREW_CELLAR/oldname
+    raise MigratorNoOldpathError, oldname unless old_cellar.exist?
 
-    @old_tabs = old_cellar.subdirs.map { |d| Tab.for_keg(Keg.new(d)) }
+    @old_tabs = old_cellar.subdirs.map { |d| Keg.new(d).tab }
     @old_tap = old_tabs.first.tap
 
-    raise MigratorDifferentTapsError.new(formula, old_tap) if !force && !from_same_tap_user?
+    raise MigratorDifferentTapsError.new(formula, oldname, old_tap) if !force && !from_same_tap_user?
 
     @new_cellar = HOMEBREW_CELLAR/formula.name
     @new_cellar_existed = @new_cellar.exist?
 
-    if (@old_linked_keg = linked_old_linked_keg)
-      @old_linked_keg_record = old_linked_keg.linked_keg_record if old_linked_keg.linked?
-      @old_opt_record = old_linked_keg.opt_record if old_linked_keg.optlinked?
-      @new_linked_keg_record = HOMEBREW_CELLAR/"#{newname}/#{File.basename(old_linked_keg)}"
+    @old_linked_kegs = linked_old_linked_kegs
+    @old_full_linked_kegs = []
+    @old_opt_records = []
+    old_linked_kegs.each do |old_linked_keg|
+      @old_full_linked_kegs << old_linked_keg if old_linked_keg.linked?
+      @old_opt_records << old_linked_keg.opt_record if old_linked_keg.optlinked?
+    end
+    unless old_linked_kegs.empty?
+      @new_linked_keg_record = HOMEBREW_CELLAR/"#{newname}/#{File.basename(old_linked_kegs.first)}"
     end
 
     @old_pin_record = HOMEBREW_PINNED_KEGS/oldname
@@ -169,7 +168,7 @@ def from_same_tap_user?
 
     new_tap = if old_tap
       old_tap_user, = old_tap.user
-      if (migrate_tap = old_tap.tap_migrations[formula.oldname])
+      if (migrate_tap = old_tap.tap_migrations[oldname])
         new_tap_user, new_tap_repo = migrate_tap.split("/")
         "#{new_tap_user}/#{new_tap_repo}"
       end
@@ -190,12 +189,12 @@ def from_same_tap_user?
     end
   end
 
-  def linked_old_linked_keg
+  def linked_old_linked_kegs
     keg_dirs = []
     keg_dirs += new_cellar.subdirs if new_cellar.exist?
     keg_dirs += old_cellar.subdirs
     kegs = keg_dirs.map { |d| Keg.new(d) }
-    kegs.find(&:linked?) || kegs.find(&:optlinked?)
+    kegs.select { |keg| keg.linked? || keg.optlinked? }
   end
 
   def pinned?
@@ -203,7 +202,7 @@ def pinned?
   end
 
   def migrate
-    oh1 "Processing #{Formatter.identifier(oldname)} formula rename to #{Formatter.identifier(newname)}"
+    oh1 "Migrating formula #{Formatter.identifier(oldname)} to #{Formatter.identifier(newname)}"
     lock
     unlink_oldname
     unlink_newname if new_cellar.exist?
@@ -211,7 +210,7 @@ def migrate
     move_to_new_directory
     link_oldname_cellar
     link_oldname_opt
-    link_newname unless old_linked_keg.nil?
+    link_newname unless old_linked_kegs.empty?
     update_tabs
     return unless formula.outdated?
 
@@ -227,21 +226,24 @@ def migrate
   rescue Exception => e # rubocop:disable Lint/RescueException
     onoe "The migration did not complete successfully."
     puts e
-    puts e.backtrace if debug?
+    if debug?
+      require "utils/backtrace"
+      puts Utils::Backtrace.clean(e)
+    end
     puts "Backing up..."
     ignore_interrupts { backup_oldname }
   ensure
     unlock
   end
 
-  # Move everything from `Cellar/oldname` to `Cellar/newname`.
-  def move_to_new_directory
-    return unless old_cellar.exist?
+  def remove_conflicts(directory)
+    conflicted = T.let(false, T::Boolean)
 
-    if new_cellar.exist?
-      conflicted = T.let(false, T::Boolean)
-      old_cellar.each_child do |c|
-        next unless (new_cellar/c.basename).exist?
+    directory.each_child do |c|
+      if c.directory? && !c.symlink?
+        conflicted ||= remove_conflicts(c)
+      else
+        next unless (new_cellar/c.relative_path_from(old_cellar)).exist?
 
         begin
           FileUtils.rm_rf c
@@ -250,13 +252,36 @@ def move_to_new_directory
           onoe "#{new_cellar/c.basename} already exists."
         end
       end
+    end
+
+    conflicted
+  end
+
+  def merge_directory(directory)
+    directory.each_child do |c|
+      new_path = new_cellar/c.relative_path_from(old_cellar)
+
+      if c.directory? && !c.symlink? && new_path.exist?
+        merge_directory(c)
+        c.unlink
+      else
+        FileUtils.mv(c, new_path)
+      end
+    end
+  end
 
-      odie "Remove #{new_cellar} manually and run `brew migrate #{oldname}`." if conflicted
+  # Move everything from `Cellar/oldname` to `Cellar/newname`.
+  def move_to_new_directory
+    return unless old_cellar.exist?
+
+    if new_cellar.exist?
+      conflicted = remove_conflicts(old_cellar)
+      odie "Remove #{new_cellar} and #{old_cellar} manually and run `brew reinstall #{newname}`." if conflicted
     end
 
     oh1 "Moving #{Formatter.identifier(oldname)} versions to #{new_cellar}"
     if new_cellar.exist?
-      FileUtils.mv(old_cellar.children, new_cellar)
+      merge_directory(old_cellar)
     else
       FileUtils.mv(old_cellar, new_cellar)
     end
@@ -265,17 +290,18 @@ def move_to_new_directory
   def repin
     return unless pinned?
 
-    # old_pin_record is a relative symlink and when we try to to read it
+    # `old_pin_record` is a relative symlink and when we try to to read it
     # from <dir> we actually try to find file
     # <dir>/../<...>/../Cellar/name/version.
     # To repin formula we need to update the link thus that it points to
     # the right directory.
-    # NOTE: old_pin_record.realpath.sub(oldname, newname) is unacceptable
-    # here, because it resolves every symlink for old_pin_record and then
+    #
+    # NOTE: `old_pin_record.realpath.sub(oldname, newname)` is unacceptable
+    # here, because it resolves every symlink for `old_pin_record` and then
     # substitutes oldname with newname. It breaks things like
-    # Pathname#make_relative_symlink, where Pathname#relative_path_from
-    # is used to find relative path from source to destination parent and
-    # it assumes no symlinks.
+    # `Pathname#make_relative_symlink`, where `Pathname#relative_path_from`
+    # is used to find the relative path from source to destination parent
+    # and it assumes no symlinks.
     src_oldname = (old_pin_record.dirname/old_pin_link_record).expand_path
     new_pin_record.make_relative_symlink(src_oldname.sub(oldname, newname))
     old_pin_record.delete
@@ -304,7 +330,7 @@ def link_newname
     # If old_keg wasn't linked then we just optlink a keg.
     # If old keg wasn't optlinked and linked, we don't call this method at all.
     # If formula is keg-only we also optlink it.
-    if formula.keg_only? || !old_linked_keg_record
+    if formula.keg_only? || old_full_linked_kegs.empty?
       begin
         new_keg.optlink(verbose: verbose?)
       rescue Keg::LinkError => e
@@ -334,7 +360,10 @@ def link_newname
     rescue Exception => e # rubocop:disable Lint/RescueException
       onoe "An unexpected error occurred during linking"
       puts e
-      puts e.backtrace if debug?
+      if debug?
+        require "utils/backtrace"
+        puts Utils::Backtrace.clean(e)
+      end
       ignore_interrupts { new_keg.unlink(verbose: verbose?) }
       raise
     end
@@ -342,16 +371,16 @@ def link_newname
 
   # Link keg to opt if it was linked before migrating.
   def link_oldname_opt
-    return unless old_opt_record
-
-    old_opt_record.delete if old_opt_record.symlink?
-    old_opt_record.make_relative_symlink(new_linked_keg_record)
+    old_opt_records.each do |old_opt_record|
+      old_opt_record.delete if old_opt_record.symlink?
+      old_opt_record.make_relative_symlink(new_linked_keg_record)
+    end
   end
 
   # After migration every `INSTALL_RECEIPT.json` has the wrong path to the formula
   # so we must update `INSTALL_RECEIPT`s.
   def update_tabs
-    new_tabs = new_cellar.subdirs.map { |d| Tab.for_keg(Keg.new(d)) }
+    new_tabs = new_cellar.subdirs.map { |d| Keg.new(d).tab }
     new_tabs.each do |tab|
       tab.source["path"] = formula.path.to_s if tab.source["path"]
       tab.write
@@ -360,11 +389,13 @@ def update_tabs
 
   # Remove `opt/oldname` link if it belongs to newname.
   def unlink_oldname_opt
-    return unless old_opt_record
+    return unless new_linked_keg_record.exist?
+
+    old_opt_records.each do |old_opt_record|
+      next unless old_opt_record.symlink?
+      next unless old_opt_record.exist?
+      next if new_linked_keg_record.realpath != old_opt_record.realpath
 
-    if old_opt_record.symlink? && old_opt_record.exist? \
-        && new_linked_keg_record.exist? \
-        && new_linked_keg_record.realpath == old_opt_record.realpath
       old_opt_record.unlink
       old_opt_record.parent.rmdir_if_possible
     end
@@ -378,8 +409,8 @@ def link_oldname_cellar
 
   # Remove `Cellar/oldname` link if it belongs to newname.
   def unlink_oldname_cellar
-    if (old_cellar.symlink? && !old_cellar.exist?) || (old_cellar.symlink? \
-          && formula.rack.exist? && formula.rack.realpath == old_cellar.realpath)
+    if (old_cellar.symlink? && !old_cellar.exist?) ||
+       (old_cellar.symlink? && formula.rack.exist? && formula.rack.realpath == old_cellar.realpath)
       old_cellar.unlink
     end
   end
@@ -401,26 +432,25 @@ def backup_oldname
       new_cellar.subdirs.each do |d|
         newname_keg = Keg.new(d)
         newname_keg.unlink(verbose: verbose?)
-        newname_keg.uninstall if new_cellar_existed
+        newname_keg.uninstall unless new_cellar_existed
       end
     end
 
-    return if old_linked_keg.nil?
+    return if old_linked_kegs.empty?
 
     # The keg used to be linked and when we backup everything we restore
     # Cellar/oldname, the target also gets restored, so we are able to
     # create a keg using its old path
-    if old_linked_keg_record
-      begin
-        old_linked_keg.link(verbose: verbose?)
-      rescue Keg::LinkError
-        old_linked_keg.unlink(verbose: verbose?)
-        raise
-      rescue Keg::AlreadyLinkedError
-        old_linked_keg.unlink(verbose: verbose?)
-        retry
-      end
-    else
+    old_full_linked_kegs.each do |old_linked_keg|
+      old_linked_keg.link(verbose: verbose?)
+    rescue Keg::LinkError
+      old_linked_keg.unlink(verbose: verbose?)
+      raise
+    rescue Keg::AlreadyLinkedError
+      old_linked_keg.unlink(verbose: verbose?)
+      retry
+    end
+    (old_linked_kegs - old_full_linked_kegs).each do |old_linked_keg|
       old_linked_keg.optlink(verbose: verbose?)
     end
   end
diff --git a/Library/Homebrew/missing_formula.rb b/Library/Homebrew/missing_formula.rb
index c2bfa50f6e562..4b9dbdaee4309 100644
--- a/Library/Homebrew/missing_formula.rb
+++ b/Library/Homebrew/missing_formula.rb
@@ -1,19 +1,19 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "formulary"
 
 module Homebrew
   # Helper module for checking if there is a reason a formula is missing.
-  #
-  # @api private
   module MissingFormula
     class << self
+      sig { params(name: String, silent: T::Boolean, show_info: T::Boolean).returns(T.nilable(String)) }
       def reason(name, silent: false, show_info: false)
-        cask_reason(name, silent: silent, show_info: show_info) || disallowed_reason(name) ||
-          tap_migration_reason(name) || deleted_reason(name, silent: silent)
+        cask_reason(name, silent:, show_info:) || disallowed_reason(name) ||
+          tap_migration_reason(name) || deleted_reason(name, silent:)
       end
 
+      sig { params(name: String).returns(T.nilable(String)) }
       def disallowed_reason(name)
         case name.downcase
         when "gem", /^rubygems?$/ then <<~EOS
@@ -26,7 +26,7 @@ def disallowed_reason(name)
         EOS
         when "pil" then <<~EOS
           Instead of PIL, consider pillow:
-            pip2 install pillow
+            brew install pillow
         EOS
         when "macruby" then <<~EOS
           MacRuby has been discontinued. Consider RubyMotion:
@@ -36,13 +36,9 @@ def disallowed_reason(name)
           lzma is now part of the xz formula:
             brew install xz
         EOS
-        when "sshpass" then <<~EOS
-          We won't add sshpass because it makes it too easy for novice SSH users to
-          ruin SSH's security.
-        EOS
         when "gsutil" then <<~EOS
           gsutil is available through pip:
-            pip2 install gsutil
+            pip3 install gsutil
         EOS
         when "gfortran" then <<~EOS
           GNU Fortran is part of the GCC formula:
@@ -89,10 +85,17 @@ def disallowed_reason(name)
           uconv is part of the icu4c formula:
             brew install icu4c
         EOS
+        when "postgresql", "postgres" then <<~EOS
+          postgresql breaks existing databases on upgrade without human intervention.
+
+          See a more specific version to install with:
+            brew formulae | grep postgresql@
+        EOS
         end
       end
       alias generic_disallowed_reason disallowed_reason
 
+      sig { params(name: String).returns(T.nilable(String)) }
       def tap_migration_reason(name)
         message = T.let(nil, T.nilable(String))
 
@@ -127,6 +130,7 @@ def tap_migration_reason(name)
         message
       end
 
+      sig { params(name: String, silent: T::Boolean).returns(T.nilable(String)) }
       def deleted_reason(name, silent: false)
         path = Formulary.path name
         return if File.exist? path
@@ -148,6 +152,20 @@ def deleted_reason(name, silent: false)
             end
           end
 
+          # Optimization for the core tap which has many monthly commits
+          if tap.core_tap?
+            # Check if the formula has been deleted in the last month.
+            diff_command = ["git", "diff", "--diff-filter=D", "--name-only",
+                            "@{'1 month ago'}", "--", relative_path]
+            deleted_formula = Utils.popen_read(*diff_command)
+
+            if deleted_formula.blank?
+              ofail "No previously deleted formula found." unless silent
+              return
+            end
+          end
+
+          # Find commit where formula was deleted in the last month.
           log_command = "git log --since='1 month ago' --diff-filter=D " \
                         "--name-only --max-count=1 " \
                         "--format=%H\\\\n%h\\\\n%B -- #{relative_path}"
diff --git a/Library/Homebrew/mktemp.rb b/Library/Homebrew/mktemp.rb
index c95f6241bd442..181f1d3aadba0 100644
--- a/Library/Homebrew/mktemp.rb
+++ b/Library/Homebrew/mktemp.rb
@@ -1,20 +1,23 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
-# Performs {Formula#mktemp}'s functionality, and tracks the results.
+# Performs {Formula#mktemp}'s functionality and tracks the results.
 # Each instance is only intended to be used once.
+# Can also be used to create a temporary directory with the brew instance's group.
 class Mktemp
-  extend T::Sig
-
   include FileUtils
 
-  # Path to the tmpdir used in this run, as a {Pathname}.
+  # Path to the tmpdir used in this run
+  sig { returns(T.nilable(Pathname)) }
   attr_reader :tmpdir
 
-  def initialize(prefix, opts = {})
+  sig { params(prefix: String, retain: T::Boolean, retain_in_cache: T::Boolean).void }
+  def initialize(prefix, retain: false, retain_in_cache: false)
     @prefix = prefix
-    @retain = opts[:retain]
-    @quiet = false
+    @retain_in_cache = T.let(retain_in_cache, T::Boolean)
+    @retain = T.let(retain || @retain_in_cache, T::Boolean)
+    @quiet = T.let(false, T::Boolean)
+    @tmpdir = T.let(nil, T.nilable(Pathname))
   end
 
   # Instructs this {Mktemp} to retain the staged files.
@@ -24,10 +27,17 @@ def retain!
   end
 
   # True if the staged temporary files should be retained.
+  sig { returns(T::Boolean) }
   def retain?
     @retain
   end
 
+  # True if the source files should be retained.
+  sig { returns(T::Boolean) }
+  def retain_in_cache?
+    @retain_in_cache
+  end
+
   # Instructs this Mktemp to not emit messages when retention is triggered.
   sig { void }
   def quiet!
@@ -39,8 +49,17 @@ def to_s
     "[Mktemp: #{tmpdir} retain=#{@retain} quiet=#{@quiet}]"
   end
 
-  def run
-    @tmpdir = Pathname.new(Dir.mktmpdir("#{@prefix.tr "@", "AT"}-", HOMEBREW_TEMP))
+  sig { params(chdir: T::Boolean, _block: T.proc.params(arg0: Mktemp).void).void }
+  def run(chdir: true, &_block)
+    prefix_name = @prefix.tr "@", "AT"
+    @tmpdir = if retain_in_cache?
+      tmp_dir = HOMEBREW_CACHE/"Sources/#{prefix_name}"
+      chmod_rm_rf(tmp_dir) # clear out previous staging directory
+      tmp_dir.mkpath
+      tmp_dir
+    else
+      Pathname.new(Dir.mktmpdir("#{prefix_name}-", HOMEBREW_TEMP))
+    end
 
     # Make sure files inside the temporary directory have the same group as the
     # brew instance.
@@ -54,22 +73,37 @@ def run
       Process.gid
     end
     begin
-      chown(nil, group_id, tmpdir)
+      @tmpdir.chown(nil, group_id)
     rescue Errno::EPERM
-      opoo "Failed setting group \"#{Etc.getgrgid(group_id).name}\" on #{tmpdir}"
+      require "etc"
+      group_name = begin
+        Etc.getgrgid(group_id)&.name
+      rescue ArgumentError
+        # Cover for misconfigured NSS setups
+        nil
+      end
+      opoo "Failed setting group \"#{group_name || group_id}\" on #{@tmpdir}"
     end
 
     begin
-      Dir.chdir(tmpdir) { yield self }
+      if chdir
+        Dir.chdir(@tmpdir) { yield self }
+      else
+        yield self
+      end
     ensure
-      ignore_interrupts { chmod_rm_rf(tmpdir) } unless retain?
+      ignore_interrupts { chmod_rm_rf(@tmpdir) } unless retain?
     end
   ensure
-    ohai "Temporary files retained at:", @tmpdir.to_s if retain? && !@tmpdir.nil? && !@quiet
+    if retain? && @tmpdir.present? && !@quiet
+      message = retain_in_cache? ? "Source files for debugging available at:" : "Temporary files retained at:"
+      ohai message, @tmpdir.to_s
+    end
   end
 
   private
 
+  sig { params(path: Pathname).void }
   def chmod_rm_rf(path)
     if path.directory? && !path.symlink?
       chmod("u+rw", path) if path.owned? # Need permissions in order to see the contents
diff --git a/Library/Homebrew/official_taps.rb b/Library/Homebrew/official_taps.rb
index 8e574a3747e7f..65c0473342280 100644
--- a/Library/Homebrew/official_taps.rb
+++ b/Library/Homebrew/official_taps.rb
@@ -1,24 +1,25 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 OFFICIAL_CASK_TAPS = %w[
   cask
-  versions
 ].freeze
 
-OFFICIAL_CMD_TAPS = {
+OFFICIAL_CMD_TAPS = T.let({
   "homebrew/aliases"           => ["alias", "unalias"],
-  "homebrew/autoupdate"        => ["autoupdate"],
   "homebrew/bundle"            => ["bundle"],
   "homebrew/command-not-found" => ["command-not-found-init", "which-formula", "which-update"],
   "homebrew/test-bot"          => ["test-bot"],
   "homebrew/services"          => ["services"],
-}.freeze
+}.freeze, T::Hash[String, T::Array[String]])
 
 DEPRECATED_OFFICIAL_TAPS = %w[
   apache
   binary
+  cask-drivers
   cask-eid
+  cask-fonts
+  cask-versions
   completions
   devel-only
   dupes
diff --git a/Library/Homebrew/options.rb b/Library/Homebrew/options.rb
index 70c537a0f5607..e1d5653db9d83 100644
--- a/Library/Homebrew/options.rb
+++ b/Library/Homebrew/options.rb
@@ -1,12 +1,8 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 # A formula option.
-#
-# @api private
 class Option
-  extend T::Sig
-
   attr_reader :name, :description, :flag
 
   def initialize(name, description = "")
@@ -15,9 +11,8 @@ def initialize(name, description = "")
     @description = description
   end
 
-  def to_s
-    flag
-  end
+  sig { returns(String) }
+  def to_s = flag
 
   def <=>(other)
     return unless other.is_a?(Option)
@@ -41,11 +36,7 @@ def inspect
 end
 
 # A deprecated formula option.
-#
-# @api private
 class DeprecatedOption
-  extend T::Sig
-
   attr_reader :old, :current
 
   def initialize(old, current)
@@ -70,11 +61,7 @@ def ==(other)
 end
 
 # A collection of formula options.
-#
-# @api private
 class Options
-  extend T::Sig
-
   include Enumerable
 
   def self.create(array)
@@ -82,9 +69,20 @@ def self.create(array)
   end
 
   def initialize(*args)
+    # Ensure this is synced with `initialize_dup` and `freeze` (excluding simple objects like integers and booleans)
     @options = Set.new(*args)
   end
 
+  def initialize_dup(other)
+    super
+    @options = @options.dup
+  end
+
+  def freeze
+    @options.dup
+    super
+  end
+
   def each(*args, &block)
     @options.each(*args, &block)
   end
@@ -128,21 +126,26 @@ def as_flags
     map(&:flag)
   end
 
-  def include?(o)
-    any? { |opt| opt == o || opt.name == o || opt.flag == o }
+  def include?(option)
+    any? { |opt| opt == option || opt.name == option || opt.flag == option }
   end
 
   alias to_ary to_a
 
+  sig { returns(String) }
+  def to_s
+    @options.map(&:to_s).join(" ")
+  end
+
   sig { returns(String) }
   def inspect
     "#<#{self.class.name}: #{to_a.inspect}>"
   end
 
-  def self.dump_for_formula(f)
-    f.options.sort_by(&:flag).each do |opt|
+  def self.dump_for_formula(formula)
+    formula.options.sort_by(&:flag).each do |opt|
       puts "#{opt.flag}\n\t#{opt.description}"
     end
-    puts "--HEAD\n\tInstall HEAD version" if f.head
+    puts "--HEAD\n\tInstall HEAD version" if formula.head
   end
 end
diff --git a/Library/Homebrew/options.rbi b/Library/Homebrew/options.rbi
new file mode 100644
index 0000000000000..b11d6cd088d0b
--- /dev/null
+++ b/Library/Homebrew/options.rbi
@@ -0,0 +1,8 @@
+# typed: strict
+
+class Options
+  # This is a workaround to enable `alias to_ary to_a`
+  # @see https://github.com/sorbet/sorbet/issues/2378#issuecomment-569474238
+  sig { returns(T::Array[Option]) }
+  def to_a; end
+end
diff --git a/Library/Homebrew/os.rb b/Library/Homebrew/os.rb
index 52945a402a875..899db97692825 100644
--- a/Library/Homebrew/os.rb
+++ b/Library/Homebrew/os.rb
@@ -1,13 +1,11 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "version"
+
 # Helper functions for querying operating system information.
-#
-# @api private
 module OS
-  extend T::Sig
-
-  # Check if the operating system is macOS.
+  # Check whether the operating system is macOS.
   #
   # @api public
   sig { returns(T::Boolean) }
@@ -17,7 +15,7 @@ def self.mac?
     RbConfig::CONFIG["host_os"].include? "darwin"
   end
 
-  # Check if the operating system is Linux.
+  # Check whether the operating system is Linux.
   #
   # @api public
   sig { returns(T::Boolean) }
@@ -32,7 +30,8 @@ def self.linux?
   # @api public
   sig { returns(Version) }
   def self.kernel_version
-    @kernel_version ||= Version.new(Utils.safe_popen_read("uname", "-r").chomp)
+    require "etc"
+    @kernel_version ||= T.let(Version.new(Etc.uname.fetch(:release)), T.nilable(Version))
   end
 
   # Get the kernel name.
@@ -40,28 +39,44 @@ def self.kernel_version
   # @api public
   sig { returns(String) }
   def self.kernel_name
-    @kernel_name ||= Utils.safe_popen_read("uname", "-s").chomp
+    require "etc"
+    @kernel_name ||= T.let(Etc.uname.fetch(:sysname), T.nilable(String))
   end
 
-  ::OS_VERSION = ENV.fetch("HOMEBREW_OS_VERSION").freeze
+  ::OS_VERSION = T.let(ENV.fetch("HOMEBREW_OS_VERSION").freeze, String)
 
-  CI_GLIBC_VERSION = "2.23"
-  CI_OS_VERSION = "Ubuntu 16.04"
+  # See Linux-CI.md
+  LINUX_CI_OS_VERSION = "Ubuntu 22.04"
+  LINUX_GLIBC_CI_VERSION = "2.35"
+  LINUX_GLIBC_NEXT_CI_VERSION = "2.35"
+  LINUX_GCC_CI_VERSION = "11.0"
+  LINUX_PREFERRED_GCC_COMPILER_FORMULA = "gcc@11" # https://packages.ubuntu.com/jammy/gcc
+  LINUX_PREFERRED_GCC_RUNTIME_FORMULA = "gcc"
 
   if OS.mac?
     require "os/mac"
+    require "hardware"
     # Don't tell people to report issues on unsupported configurations.
     if !OS::Mac.version.prerelease? &&
        !OS::Mac.version.outdated_release? &&
        ARGV.none? { |v| v.start_with?("--cc=") } &&
-       (HOMEBREW_PREFIX == HOMEBREW_DEFAULT_PREFIX ||
-       (HOMEBREW_PREFIX == HOMEBREW_MACOS_ARM_DEFAULT_PREFIX && Hardware::CPU.arm?))
+       (HOMEBREW_PREFIX.to_s == HOMEBREW_DEFAULT_PREFIX ||
+       (HOMEBREW_PREFIX.to_s == HOMEBREW_MACOS_ARM_DEFAULT_PREFIX && Hardware::CPU.arm?))
       ISSUES_URL = "https://docs.brew.sh/Troubleshooting"
     end
     PATH_OPEN = "/usr/bin/open"
   elsif OS.linux?
     require "os/linux"
     ISSUES_URL = "https://docs.brew.sh/Troubleshooting"
-    PATH_OPEN = "xdg-open"
+    PATH_OPEN = if OS::Linux.wsl? && (wslview = which("wslview").presence)
+      wslview.to_s
+    else
+      "xdg-open"
+    end.freeze
+  end
+
+  sig { returns(T::Boolean) }
+  def self.unsupported_configuration?
+    !defined?(OS::ISSUES_URL)
   end
 end
diff --git a/Library/Homebrew/os/linux.rb b/Library/Homebrew/os/linux.rb
index 277e3de3a9584..e8f4832843707 100644
--- a/Library/Homebrew/os/linux.rb
+++ b/Library/Homebrew/os/linux.rb
@@ -1,15 +1,23 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "utils"
+
 module OS
   # Helper module for querying system information on Linux.
   module Linux
-    extend T::Sig
+    raise "Loaded OS::Linux on generic OS!" if ENV["HOMEBREW_TEST_GENERIC_OS"]
 
-    module_function
+    # This check is the only acceptable or necessary one in this file.
+    # rubocop:disable Homebrew/MoveToExtendOS
+    raise "Loaded OS::Linux on macOS!" if OS.mac?
+    # rubocop:enable Homebrew/MoveToExtendOS
 
+    # Get the OS version.
+    #
+    # @api internal
     sig { returns(String) }
-    def os_version
+    def self.os_version
       if which("lsb_release")
         lsb_info = Utils.popen_read("lsb_release", "-a")
         description = lsb_info[/^Description:\s*(.*)$/, 1].force_encoding("UTF-8")
@@ -21,71 +29,32 @@ def os_version
         end
       elsif (redhat_release = Pathname.new("/etc/redhat-release")).readable?
         redhat_release.read.chomp
+      elsif ::OS_VERSION.present?
+        ::OS_VERSION
       else
         "Unknown"
       end
     end
-  end
-
-  # rubocop:disable Style/Documentation
-  module Mac
-    module_function
-
-    ::MacOS = OS::Mac
-
-    raise "Loaded OS::Linux on generic OS!" if ENV["HOMEBREW_TEST_GENERIC_OS"]
-
-    def version
-      ::Version::NULL
-    end
-
-    def full_version
-      ::Version::NULL
-    end
-
-    def languages
-      @languages ||= Array(ENV["LANG"]&.slice(/[a-z]+/)).uniq
-    end
-
-    def language
-      languages.first
-    end
-
-    def sdk_root_needed?
-      false
-    end
-
-    def sdk_path_if_needed(_v = nil)
-      nil
-    end
-
-    def sdk_path
-      nil
-    end
 
-    module Xcode
-      module_function
-
-      def version
-        ::Version::NULL
-      end
-
-      def installed?
-        false
-      end
+    sig { returns(T::Boolean) }
+    def self.wsl?
+      /-microsoft/i.match?(OS.kernel_version.to_s)
     end
 
-    module CLT
-      module_function
+    sig { returns(Version) }
+    def self.wsl_version
+      return Version::NULL unless wsl?
 
-      def version
-        ::Version::NULL
-      end
-
-      def installed?
-        false
+      kernel = OS.kernel_version.to_s
+      if Version.new(T.must(kernel[/^([0-9.]*)-.*/, 1])) > Version.new("5.15")
+        Version.new("2 (Microsoft Store)")
+      elsif kernel.include?("-microsoft")
+        Version.new("2")
+      elsif kernel.include?("-Microsoft")
+        Version.new("1")
+      else
+        Version::NULL
       end
     end
   end
-  # rubocop:enable Style/Documentation
 end
diff --git a/Library/Homebrew/os/linux.rbi b/Library/Homebrew/os/linux.rbi
deleted file mode 100644
index b6f31646830cd..0000000000000
--- a/Library/Homebrew/os/linux.rbi
+++ /dev/null
@@ -1,7 +0,0 @@
-# typed: strict
-
-module OS
-  module Linux
-    include ::Kernel
-  end
-end
diff --git a/Library/Homebrew/os/linux/elf.rb b/Library/Homebrew/os/linux/elf.rb
index 73dd1b016e9ed..4a7a1cb06cbc9 100644
--- a/Library/Homebrew/os/linux/elf.rb
+++ b/Library/Homebrew/os/linux/elf.rb
@@ -1,11 +1,13 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "os/linux/ld"
+
 # {Pathname} extension for dealing with ELF files.
 # @see https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header
-#
-# @api private
 module ELFShim
+  extend T::Helpers
+
   MAGIC_NUMBER_OFFSET = 0
   private_constant :MAGIC_NUMBER_OFFSET
   MAGIC_NUMBER_ASCII = "\x7fELF"
@@ -31,6 +33,8 @@ module ELFShim
   private_constant :ARCHITECTURE_I386
   ARCHITECTURE_POWERPC = 0x14
   private_constant :ARCHITECTURE_POWERPC
+  ARCHITECTURE_POWERPC64 = 0x15
+  private_constant :ARCHITECTURE_POWERPC64
   ARCHITECTURE_ARM = 0x28
   private_constant :ARCHITECTURE_ARM
   ARCHITECTURE_X86_64 = 0x3E
@@ -38,6 +42,8 @@ module ELFShim
   ARCHITECTURE_AARCH64 = 0xB7
   private_constant :ARCHITECTURE_AARCH64
 
+  requires_ancestor { Pathname }
+
   def read_uint8(offset)
     read(1, offset).unpack1("C")
   end
@@ -48,7 +54,7 @@ def read_uint16(offset)
 
   def elf?
     return @elf if defined? @elf
-    return @elf = false unless read(MAGIC_NUMBER_ASCII.size, MAGIC_NUMBER_OFFSET) == MAGIC_NUMBER_ASCII
+    return @elf = false if read(MAGIC_NUMBER_ASCII.size, MAGIC_NUMBER_OFFSET) != MAGIC_NUMBER_ASCII
 
     # Check that this ELF file is for Linux or System V.
     # OS_ABI is often set to 0 (System V), regardless of the target platform.
@@ -61,13 +67,23 @@ def arch
     @arch ||= case read_uint16(ARCHITECTURE_OFFSET)
     when ARCHITECTURE_I386 then :i386
     when ARCHITECTURE_X86_64 then :x86_64
-    when ARCHITECTURE_POWERPC then :powerpc
+    when ARCHITECTURE_POWERPC then :ppc32
+    when ARCHITECTURE_POWERPC64 then :ppc64
     when ARCHITECTURE_ARM then :arm
     when ARCHITECTURE_AARCH64 then :arm64
     else :dunno
     end
   end
 
+  def arch_compatible?(wanted_arch)
+    return true unless elf?
+
+    # Treat ppc64le and ppc64 the same
+    wanted_arch = :ppc64 if wanted_arch == :ppc64le
+
+    wanted_arch == arch
+  end
+
   def elf_type
     return :dunno unless elf?
 
@@ -97,7 +113,7 @@ def rpath
   # An array of runtime search path entries, such as:
   # ["/lib", "/usr/lib", "/usr/local/lib"]
   def rpaths
-    rpath.split(":")
+    Array(rpath&.split(":"))
   end
 
   def interpreter
@@ -119,8 +135,6 @@ def dynamic_elf?
   end
 
   # Helper class for reading metadata from an ELF file.
-  #
-  # @api private
   class Metadata
     attr_reader :path, :dylib_id, :dylibs
 
@@ -130,19 +144,7 @@ def initialize(path)
       @dylib_id, needed = needed_libraries path
       return if needed.empty?
 
-      ldd = DevelopmentTools.locate "ldd"
-      ldd_output = Utils.popen_read(ldd, path.expand_path.to_s).split("\n")
-      return unless $CHILD_STATUS.success?
-
-      ldd_paths = ldd_output.map do |line|
-        match = line.match(/\t.+ => (.+) \(.+\)|\t(.+) => not found/)
-        next unless match
-
-        match.captures.compact.first
-      end.compact
-      @dylibs = ldd_paths.select do |ldd_path|
-        needed.include? File.basename(ldd_path)
-      end
+      @dylibs = needed.map { |lib| find_full_lib_path(lib).to_s }
     end
 
     private
@@ -157,6 +159,53 @@ def needed_libraries_using_patchelf_rb(path)
       patcher = path.patchelf_patcher
       [patcher.soname, patcher.needed]
     end
+
+    def find_full_lib_path(basename)
+      local_paths = (path.patchelf_patcher.runpath || path.patchelf_patcher.rpath)&.split(":")
+
+      # Search for dependencies in the runpath/rpath first
+      local_paths&.each do |local_path|
+        local_path = OS::Linux::Elf.expand_elf_dst(local_path, "ORIGIN", path.parent)
+        candidate = Pathname(local_path)/basename
+        return candidate if candidate.exist? && candidate.elf?
+      end
+
+      # Check if DF_1_NODEFLIB is set
+      dt_flags_1 = path.patchelf_patcher.elf.segment_by_type(:dynamic)&.tag_by_type(:flags_1)
+      nodeflib_flag = if dt_flags_1.nil?
+        false
+      else
+        dt_flags_1.value & ELFTools::Constants::DF::DF_1_NODEFLIB != 0
+      end
+
+      linker_library_paths = OS::Linux::Ld.library_paths
+      linker_system_dirs = OS::Linux::Ld.system_dirs
+
+      # If DF_1_NODEFLIB is set, exclude any library paths that are subdirectories
+      # of the system dirs
+      if nodeflib_flag
+        linker_library_paths = linker_library_paths.reject do |lib_path|
+          linker_system_dirs.any? { |system_dir| Utils::Path.child_of? system_dir, lib_path }
+        end
+      end
+
+      # If not found, search recursively in the paths listed in ld.so.conf (skipping
+      # paths that are subdirectories of the system dirs if DF_1_NODEFLIB is set)
+      linker_library_paths.each do |linker_library_path|
+        candidate = Pathname(linker_library_path)/basename
+        return candidate if candidate.exist? && candidate.elf?
+      end
+
+      # If not found, search in the system dirs, unless DF_1_NODEFLIB is set
+      unless nodeflib_flag
+        linker_system_dirs.each do |linker_system_dir|
+          candidate = Pathname(linker_system_dir)/basename
+          return candidate if candidate.exist? && candidate.elf?
+        end
+      end
+
+      basename
+    end
   end
   private_constant :Metadata
 
@@ -189,3 +238,37 @@ def dynamically_linked_libraries(*)
     metadata.dylibs
   end
 end
+
+module OS
+  module Linux
+    # Helper functions for working with ELF objects.
+    #
+    # @api private
+    module Elf
+      sig { params(str: String, ref: String, repl: T.any(String, Pathname)).returns(String) }
+      def self.expand_elf_dst(str, ref, repl)
+        # ELF gABI rules for DSTs:
+        #   - Longest possible sequence using the rules (greedy).
+        #   - Must start with a $ (enforced by caller).
+        #   - Must follow $ with one underscore or ASCII [A-Za-z] (caller
+        #     follows these rules for REF) or '{' (start curly quoted name).
+        #   - Must follow first two characters with zero or more [A-Za-z0-9_]
+        #     (enforced by caller) or '}' (end curly quoted name).
+        # (from https://github.com/bminor/glibc/blob/41903cb6f460d62ba6dd2f4883116e2a624ee6f8/elf/dl-load.c#L182-L228)
+
+        # In addition to capturing a token, also attempt to capture opening/closing braces and check that they are not
+        # mismatched before expanding.
+        str.gsub(/\$({?)([a-zA-Z_][a-zA-Z0-9_]*)(}?)/) do |orig_str|
+          has_opening_brace = ::Regexp.last_match(1).present?
+          matched_text = ::Regexp.last_match(2)
+          has_closing_brace = ::Regexp.last_match(3).present?
+          if (matched_text == ref) && (has_opening_brace == has_closing_brace)
+            repl
+          else
+            orig_str
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/os/linux/glibc.rb b/Library/Homebrew/os/linux/glibc.rb
index 7478701223282..eff5a25a8e9da 100644
--- a/Library/Homebrew/os/linux/glibc.rb
+++ b/Library/Homebrew/os/linux/glibc.rb
@@ -1,14 +1,10 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module OS
   module Linux
     # Helper functions for querying `glibc` information.
-    #
-    # @api private
     module Glibc
-      extend T::Sig
-
       module_function
 
       sig { returns(Version) }
@@ -44,6 +40,11 @@ def minimum_version
       def below_minimum_version?
         system_version < minimum_version
       end
+
+      sig { returns(T::Boolean) }
+      def below_ci_version?
+        system_version < LINUX_GLIBC_CI_VERSION
+      end
     end
   end
 end
diff --git a/Library/Homebrew/os/linux/kernel.rb b/Library/Homebrew/os/linux/kernel.rb
index d74a7412a4e5a..b64056460e043 100644
--- a/Library/Homebrew/os/linux/kernel.rb
+++ b/Library/Homebrew/os/linux/kernel.rb
@@ -1,21 +1,18 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module OS
   module Linux
     # Helper functions for querying Linux kernel information.
-    #
-    # @api private
     module Kernel
-      extend T::Sig
-
       module_function
 
       sig { returns(Version) }
       def minimum_version
-        Version.new "2.6.32"
+        Version.new "3.2"
       end
 
+      sig { returns(T::Boolean) }
       def below_minimum_version?
         OS.kernel_version < minimum_version
       end
diff --git a/Library/Homebrew/os/linux/ld.rb b/Library/Homebrew/os/linux/ld.rb
new file mode 100644
index 0000000000000..b4a033b96244f
--- /dev/null
+++ b/Library/Homebrew/os/linux/ld.rb
@@ -0,0 +1,79 @@
+# typed: strict
+# frozen_string_literal: true
+
+module OS
+  module Linux
+    # Helper functions for querying `ld` information.
+    module Ld
+      sig { returns(String) }
+      def self.brewed_ld_so_diagnostics
+        @brewed_ld_so_diagnostics ||= T.let({}, T.nilable(T::Hash[Pathname, String]))
+
+        brewed_ld_so = HOMEBREW_PREFIX/"lib/ld.so"
+        return "" unless brewed_ld_so.exist?
+
+        brewed_ld_so_target = brewed_ld_so.readlink
+        @brewed_ld_so_diagnostics[brewed_ld_so_target] ||= begin
+          ld_so_output = Utils.popen_read(brewed_ld_so, "--list-diagnostics")
+          ld_so_output if $CHILD_STATUS.success?
+        end
+
+        @brewed_ld_so_diagnostics[brewed_ld_so_target].to_s
+      end
+
+      sig { returns(String) }
+      def self.sysconfdir
+        fallback_sysconfdir = "/etc"
+
+        match = brewed_ld_so_diagnostics.match(/path.sysconfdir="(.+)"/)
+        return fallback_sysconfdir unless match
+
+        match.captures.compact.first || fallback_sysconfdir
+      end
+
+      sig { returns(T::Array[String]) }
+      def self.system_dirs
+        dirs = []
+
+        brewed_ld_so_diagnostics.split("\n").each do |line|
+          match = line.match(/path.system_dirs\[0x.*\]="(.*)"/)
+          next unless match
+
+          dirs << match.captures.compact.first
+        end
+
+        dirs
+      end
+
+      sig { params(conf_path: T.any(Pathname, String)).returns(T::Array[String]) }
+      def self.library_paths(conf_path = Pathname(sysconfdir)/"ld.so.conf")
+        conf_file = Pathname(conf_path)
+        return [] unless conf_file.exist?
+
+        paths = Set.new
+        directory = conf_file.realpath.dirname
+
+        conf_file.readlines.each do |line|
+          # Remove comments and leading/trailing whitespace
+          line.strip!
+          line.sub!(/\s*#.*$/, "")
+
+          if line.start_with?(/\s*include\s+/)
+            include_path = Pathname(line.sub(/^\s*include\s+/, "")).expand_path
+            wildcard = include_path.absolute? ? include_path : directory/include_path
+
+            Dir.glob(wildcard.to_s).each do |include_file|
+              paths += library_paths(include_file)
+            end
+          elsif line.empty?
+            next
+          else
+            paths << line
+          end
+        end
+
+        paths.to_a
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/os/mac.rb b/Library/Homebrew/os/mac.rb
index 5f422450e9166..29fa508f3f04e 100644
--- a/Library/Homebrew/os/mac.rb
+++ b/Library/Homebrew/os/mac.rb
@@ -1,7 +1,8 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "os/mac/version"
+require "macos_version"
+
 require "os/mac/xcode"
 require "os/mac/sdk"
 require "os/mac/keg"
@@ -9,59 +10,66 @@
 module OS
   # Helper module for querying system information on macOS.
   module Mac
-    extend T::Sig
+    raise "Loaded OS::Mac on generic OS!" if ENV["HOMEBREW_TEST_GENERIC_OS"]
 
-    module_function
+    # This check is the only acceptable or necessary one in this file.
+    # rubocop:disable Homebrew/MoveToExtendOS
+    raise "Loaded OS::Mac on Linux!" if OS.linux?
+    # rubocop:enable Homebrew/MoveToExtendOS
 
+    # Provide MacOS alias for backwards compatibility and nicer APIs.
     ::MacOS = OS::Mac
 
-    raise "Loaded OS::Mac on generic OS!" if ENV["HOMEBREW_TEST_GENERIC_OS"]
-
     VERSION = ENV.fetch("HOMEBREW_MACOS_VERSION").chomp.freeze
     private_constant :VERSION
 
     # This can be compared to numerics, strings, or symbols
     # using the standard Ruby Comparable methods.
-    sig { returns(Version) }
-    def version
+    #
+    # @api internal
+    sig { returns(MacOSVersion) }
+    def self.version
       @version ||= full_version.strip_patch
     end
 
     # This can be compared to numerics, strings, or symbols
     # using the standard Ruby Comparable methods.
-    sig { returns(Version) }
-    def full_version
-      @full_version ||= if ENV["HOMEBREW_FAKE_EL_CAPITAN"] # for Portable Ruby building
-        Version.new("10.11.6")
+    #
+    # @api internal
+    sig { returns(MacOSVersion) }
+    def self.full_version
+      @full_version ||= if (fake_macos = ENV.fetch("HOMEBREW_FAKE_MACOS", nil)) # for Portable Ruby building
+        MacOSVersion.new(fake_macos)
       else
-        Version.new(VERSION)
+        MacOSVersion.new(VERSION)
       end
     end
 
-    sig { params(version: Version).void }
-    def full_version=(version)
-      @full_version = Version.new(version.chomp)
+    sig { params(version: String).void }
+    def self.full_version=(version)
+      @full_version = MacOSVersion.new(version.chomp)
       @version = nil
     end
 
     sig { returns(::Version) }
-    def latest_sdk_version
+    def self.latest_sdk_version
       # TODO: bump version when new Xcode macOS SDK is released
       # NOTE: We only track the major version of the SDK.
-      ::Version.new("12")
+      ::Version.new("15")
     end
-    private :latest_sdk_version
 
     sig { returns(String) }
-    def preferred_perl_version
-      if version >= :big_sur
+    def self.preferred_perl_version
+      if version >= :sonoma
+        "5.34"
+      elsif version >= :big_sur
         "5.30"
       else
         "5.18"
       end
     end
 
-    def languages
+    def self.languages
       return @languages if @languages
 
       os_langs = Utils.popen_read("defaults", "read", "-g", "AppleLanguages")
@@ -74,17 +82,17 @@ def languages
       @languages = os_langs
     end
 
-    def language
+    def self.language
       languages.first
     end
 
     sig { returns(String) }
-    def active_developer_dir
+    def self.active_developer_dir
       @active_developer_dir ||= Utils.popen_read("/usr/bin/xcode-select", "-print-path").strip
     end
 
     sig { returns(T::Boolean) }
-    def sdk_root_needed?
+    def self.sdk_root_needed?
       if MacOS::CLT.installed?
         # If there's no CLT SDK, return false
         return false unless MacOS::CLT.provides_sdk?
@@ -105,7 +113,7 @@ def sdk_root_needed?
     # If no specific SDK is requested, the SDK matching the OS version is returned,
     # if available. Otherwise, the latest SDK is returned.
 
-    def sdk_locator
+    def self.sdk_locator
       if CLT.installed? && CLT.provides_sdk?
         CLT.sdk_locator
       else
@@ -113,31 +121,31 @@ def sdk_locator
       end
     end
 
-    def sdk(v = nil)
-      sdk_locator.sdk_if_applicable(v)
+    def self.sdk(version = nil)
+      sdk_locator.sdk_if_applicable(version)
     end
 
-    def sdk_for_formula(f, v = nil, check_only_runtime_requirements: false)
+    def self.sdk_for_formula(formula, version = nil, check_only_runtime_requirements: false)
       # If the formula requires Xcode, don't return the CLT SDK
       # If check_only_runtime_requirements is true, don't necessarily return the
       # Xcode SDK if the XcodeRequirement is only a build or test requirement.
-      return Xcode.sdk if f.requirements.any? do |req|
+      return Xcode.sdk if formula.requirements.any? do |req|
         next false unless req.is_a? XcodeRequirement
         next false if check_only_runtime_requirements && req.build? && !req.test?
 
         true
       end
 
-      sdk(v)
+      sdk(version)
     end
 
     # Returns the path to an SDK or nil, following the rules set by {sdk}.
-    def sdk_path(v = nil)
-      s = sdk(v)
+    def self.sdk_path(version = nil)
+      s = sdk(version)
       s&.path
     end
 
-    def sdk_path_if_needed(v = nil)
+    def self.sdk_path_if_needed(version = nil)
       # Prefer CLT SDK when both Xcode and the CLT are installed.
       # Expected results:
       # 1. On Xcode-only systems, return the Xcode SDK.
@@ -148,7 +156,7 @@ def sdk_path_if_needed(v = nil)
 
       return unless sdk_root_needed?
 
-      sdk_path(v)
+      sdk_path(version)
     end
 
     # See these issues for some history:
@@ -156,7 +164,7 @@ def sdk_path_if_needed(v = nil)
     # - {https://github.com/Homebrew/legacy-homebrew/issues/13}
     # - {https://github.com/Homebrew/legacy-homebrew/issues/41}
     # - {https://github.com/Homebrew/legacy-homebrew/issues/48}
-    def macports_or_fink
+    def self.macports_or_fink
       paths = []
 
       # First look in the path because MacPorts is relocatable and Fink
@@ -186,7 +194,7 @@ def macports_or_fink
     end
 
     sig { params(ids: String).returns(T.nilable(Pathname)) }
-    def app_with_bundle_id(*ids)
+    def self.app_with_bundle_id(*ids)
       path = mdfind(*ids)
              .reject { |p| p.include?("/Backups.backupdb/") }
              .first
@@ -194,20 +202,20 @@ def app_with_bundle_id(*ids)
     end
 
     sig { params(ids: String).returns(T::Array[String]) }
-    def mdfind(*ids)
+    def self.mdfind(*ids)
       (@mdfind ||= {}).fetch(ids) do
         @mdfind[ids] = Utils.popen_read("/usr/bin/mdfind", mdfind_query(*ids)).split("\n")
       end
     end
 
-    def pkgutil_info(id)
+    def self.pkgutil_info(id)
       (@pkginfo ||= {}).fetch(id) do |key|
         @pkginfo[key] = Utils.popen_read("/usr/sbin/pkgutil", "--pkg-info", key).strip
       end
     end
 
     sig { params(ids: String).returns(String) }
-    def mdfind_query(*ids)
+    def self.mdfind_query(*ids)
       ids.map! { |id| "kMDItemCFBundleIdentifier == #{id}" }.join(" || ")
     end
   end
diff --git a/Library/Homebrew/os/mac.rbi b/Library/Homebrew/os/mac.rbi
deleted file mode 100644
index 85a546f554d48..0000000000000
--- a/Library/Homebrew/os/mac.rbi
+++ /dev/null
@@ -1,7 +0,0 @@
-# typed: strict
-
-module OS
-  module Mac
-    include Kernel
-  end
-end
diff --git a/Library/Homebrew/os/mac/keg.rb b/Library/Homebrew/os/mac/keg.rb
index 0ee328dc27a4f..127633ee8775b 100644
--- a/Library/Homebrew/os/mac/keg.rb
+++ b/Library/Homebrew/os/mac/keg.rb
@@ -1,14 +1,15 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 class Keg
+  sig { params(id: String, file: Pathname).returns(T::Boolean) }
   def change_dylib_id(id, file)
-    return if file.dylib_id == id
+    return false if file.dylib_id == id
 
     @require_relocation = true
     odebug "Changing dylib ID of #{file}\n  from #{file.dylib_id}\n    to #{id}"
     file.change_dylib_id(id, strict: false)
-    codesign_patched_binary(file)
+    true
   rescue MachO::MachOError
     onoe <<~EOS
       Failed changing dylib ID of #{file}
@@ -18,13 +19,14 @@ def change_dylib_id(id, file)
     raise
   end
 
+  sig { params(old: String, new: String, file: Pathname).returns(T::Boolean) }
   def change_install_name(old, new, file)
-    return if old == new
+    return false if old == new
 
     @require_relocation = true
     odebug "Changing install name in #{file}\n  from #{old}\n    to #{new}"
     file.change_install_name(old, new, strict: false)
-    codesign_patched_binary(file)
+    true
   rescue MachO::MachOError
     onoe <<~EOS
       Failed changing install name in #{file}
@@ -35,12 +37,12 @@ def change_install_name(old, new, file)
   end
 
   def change_rpath(old, new, file)
-    return if old == new
+    return false if old == new
 
     @require_relocation = true
     odebug "Changing rpath in #{file}\n  from #{old}\n    to #{new}"
     file.change_rpath(old, new, strict: false)
-    codesign_patched_binary(file)
+    true
   rescue MachO::MachOError
     onoe <<~EOS
       Failed changing rpath in #{file}
@@ -50,10 +52,11 @@ def change_rpath(old, new, file)
     raise
   end
 
+  sig { params(rpath: String, file: MachOShim).returns(T::Boolean) }
   def delete_rpath(rpath, file)
     odebug "Deleting rpath #{rpath} in #{file}"
     file.delete_rpath(rpath, strict: false)
-    codesign_patched_binary(file)
+    true
   rescue MachO::MachOError
     onoe <<~EOS
       Failed deleting rpath #{rpath} in #{file}
diff --git a/Library/Homebrew/os/mac/mach.rb b/Library/Homebrew/os/mac/mach.rb
index abadcf8fd68ab..d3e87cf8599f6 100644
--- a/Library/Homebrew/os/mac/mach.rb
+++ b/Library/Homebrew/os/mac/mach.rb
@@ -1,15 +1,16 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "macho"
 
 # {Pathname} extension for dealing with Mach-O files.
-#
-# @api private
 module MachOShim
   extend Forwardable
+  extend T::Helpers
 
-  delegate [:dylib_id, :rpaths] => :macho
+  requires_ancestor { Pathname }
+
+  delegate [:dylib_id] => :macho
 
   def macho
     @macho ||= MachO.open(to_s)
@@ -40,7 +41,7 @@ def mach_data
         else :dunno
         end
 
-        mach_data << { arch: arch, type: type }
+        mach_data << { arch:, type: }
       end
 
       mach_data
@@ -60,7 +61,15 @@ def mach_data
   # TODO: See if the `#write!` call can be delayed until
   # we know we're not making any changes to the rpaths.
   def delete_rpath(rpath, **options)
-    macho.delete_rpath(rpath, options)
+    candidates = rpaths(resolve_variable_references: false).select do |r|
+      resolve_variable_name(r) == resolve_variable_name(rpath)
+    end
+
+    # Delete the last instance to avoid changing the order in which rpaths are searched.
+    rpath_to_delete = candidates.last
+    options[:last] = true
+
+    macho.delete_rpath(rpath_to_delete, options)
     macho.write!
   end
 
@@ -79,10 +88,42 @@ def change_install_name(old, new, **options)
     macho.write!
   end
 
-  def dynamically_linked_libraries(except: :none)
-    lcs = macho.dylib_load_commands.reject { |lc| lc.type == except }
+  def dynamically_linked_libraries(except: :none, resolve_variable_references: true)
+    lcs = macho.dylib_load_commands
+    lcs.reject! { |lc| lc.flag?(except) } if except != :none
+    names = lcs.map { |lc| lc.name.to_s }.uniq
+    names.map! { resolve_variable_name(_1) } if resolve_variable_references
+
+    names
+  end
+
+  def rpaths(resolve_variable_references: true)
+    names = macho.rpaths
+    # Don't recursively resolve rpaths to avoid infinite loops.
+    names.map! { |name| resolve_variable_name(name, resolve_rpaths: false) } if resolve_variable_references
+
+    names
+  end
+
+  def resolve_variable_name(name, resolve_rpaths: true)
+    if name.start_with? "@loader_path"
+      Pathname(name.sub("@loader_path", dirname)).cleanpath.to_s
+    elsif name.start_with?("@executable_path") && binary_executable?
+      Pathname(name.sub("@executable_path", dirname)).cleanpath.to_s
+    elsif resolve_rpaths && name.start_with?("@rpath") && (target = resolve_rpath(name)).present?
+      target
+    else
+      name
+    end
+  end
+
+  def resolve_rpath(name)
+    target = T.let(nil, T.nilable(String))
+    return unless rpaths(resolve_variable_references: true).find do |rpath|
+      File.exist?(target = File.join(rpath, name.delete_prefix("@rpath")))
+    end
 
-    lcs.map(&:name).map(&:to_s).uniq
+    target
   end
 
   def archs
diff --git a/Library/Homebrew/os/mac/pkgconfig/10.11/bzip2.pc b/Library/Homebrew/os/mac/pkgconfig/10.11/bzip2.pc
new file mode 100644
index 0000000000000..e4c07a896a27e
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/10.11/bzip2.pc
@@ -0,0 +1,11 @@
+prefix=/usr
+exec_prefix=${prefix}
+bindir=${exec_prefix}/bin
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: bzip2
+Description: Lossless, block-sorting data compression
+Version: 1.0.6
+Libs: -L${libdir} -lbz2
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/10.12/bzip2.pc b/Library/Homebrew/os/mac/pkgconfig/10.12/bzip2.pc
new file mode 100644
index 0000000000000..e4c07a896a27e
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/10.12/bzip2.pc
@@ -0,0 +1,11 @@
+prefix=/usr
+exec_prefix=${prefix}
+bindir=${exec_prefix}/bin
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: bzip2
+Description: Lossless, block-sorting data compression
+Version: 1.0.6
+Libs: -L${libdir} -lbz2
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/10.13/bzip2.pc b/Library/Homebrew/os/mac/pkgconfig/10.13/bzip2.pc
new file mode 100644
index 0000000000000..e4c07a896a27e
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/10.13/bzip2.pc
@@ -0,0 +1,11 @@
+prefix=/usr
+exec_prefix=${prefix}
+bindir=${exec_prefix}/bin
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: bzip2
+Description: Lossless, block-sorting data compression
+Version: 1.0.6
+Libs: -L${libdir} -lbz2
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/10.14/bzip2.pc b/Library/Homebrew/os/mac/pkgconfig/10.14/bzip2.pc
new file mode 100644
index 0000000000000..8809f5af26a57
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/10.14/bzip2.pc
@@ -0,0 +1,12 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+bindir=${exec_prefix}/bin
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: bzip2
+Description: Lossless, block-sorting data compression
+Version: 1.0.6
+Libs: -L${libdir} -lbz2
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/10.15/bzip2.pc b/Library/Homebrew/os/mac/pkgconfig/10.15/bzip2.pc
new file mode 100644
index 0000000000000..b568b6eaf3155
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/10.15/bzip2.pc
@@ -0,0 +1,12 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX10.15.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+bindir=${exec_prefix}/bin
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: bzip2
+Description: Lossless, block-sorting data compression
+Version: 1.0.6
+Libs: -L${libdir} -lbz2
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/11/bzip2.pc b/Library/Homebrew/os/mac/pkgconfig/11/bzip2.pc
new file mode 100644
index 0000000000000..474ef60248f48
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/11/bzip2.pc
@@ -0,0 +1,12 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX11.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+bindir=${exec_prefix}/bin
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: bzip2
+Description: Lossless, block-sorting data compression
+Version: 1.0.6
+Libs: -L${libdir} -lbz2
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/12/bzip2.pc b/Library/Homebrew/os/mac/pkgconfig/12/bzip2.pc
new file mode 100644
index 0000000000000..e9422cfe6e1ff
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/12/bzip2.pc
@@ -0,0 +1,12 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX12.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+bindir=${exec_prefix}/bin
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: bzip2
+Description: Lossless, block-sorting data compression
+Version: 1.0.8
+Libs: -L${libdir} -lbz2
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/13/bzip2.pc b/Library/Homebrew/os/mac/pkgconfig/13/bzip2.pc
new file mode 100644
index 0000000000000..34e0fd4620660
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/13/bzip2.pc
@@ -0,0 +1,12 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX13.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+bindir=${exec_prefix}/bin
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: bzip2
+Description: Lossless, block-sorting data compression
+Version: 1.0.8
+Libs: -L${libdir} -lbz2
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/13/expat.pc b/Library/Homebrew/os/mac/pkgconfig/13/expat.pc
index a22716c64365f..25c8d0a8babc9 100644
--- a/Library/Homebrew/os/mac/pkgconfig/13/expat.pc
+++ b/Library/Homebrew/os/mac/pkgconfig/13/expat.pc
@@ -5,8 +5,9 @@ libdir=${exec_prefix}/lib
 includedir=${prefix}/include
 
 Name: expat
-Version: 2.4.1
+Version: 2.5.0
 Description: expat XML parser
-URL: http://www.libexpat.org
+URL: https://libexpat.github.io/
 Libs: -L${libdir} -lexpat
+Libs.private:
 Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/13/libcurl.pc b/Library/Homebrew/os/mac/pkgconfig/13/libcurl.pc
index dbf9f0f27b7f5..8745777ab02a0 100644
--- a/Library/Homebrew/os/mac/pkgconfig/13/libcurl.pc
+++ b/Library/Homebrew/os/mac/pkgconfig/13/libcurl.pc
@@ -5,7 +5,7 @@
 #                            | (__| |_| |  _ <| |___
 #                             \___|\___/|_| \_\_____|
 #
-# Copyright (C) 2001 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
+# Copyright (C) 2001 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
 #
 # This software is licensed as described in the file COPYING, which
 # you should have received as part of this distribution. The terms
@@ -18,6 +18,8 @@
 # This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 # KIND, either express or implied.
 #
+# SPDX-License-Identifier: curl
+#
 ###########################################################################
 
 # This should most probably benefit from getting a "Requires:" field added
@@ -29,12 +31,12 @@ exec_prefix=/usr
 libdir=${exec_prefix}/lib
 includedir=${prefix}/include
 supported_protocols="DICT FILE FTP FTPS GOPHER GOPHERS HTTP HTTPS IMAP IMAPS LDAP LDAPS MQTT POP3 POP3S RTSP SMB SMBS SMTP SMTPS TELNET TFTP"
-supported_features="alt-svc AsynchDNS GSS-API HSTS HTTP2 HTTPS-proxy IPv6 Kerberos Largefile libz MultiSSL NTLM NTLM_WB SPNEGO SSL UnixSockets"
+supported_features="alt-svc AsynchDNS GSS-API HSTS HTTP2 HTTPS-proxy IPv6 Kerberos Largefile libz MultiSSL NTLM NTLM_WB SPNEGO SSL threadsafe UnixSockets"
 
 Name: libcurl
 URL: https://curl.se/
 Description: Library to transfer files with ftp, http, etc.
-Version: 7.79.1
+Version: 7.87.0
 Libs: -L${libdir} -lcurl
 Libs.private: -lldap -lz
 Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/13/libexslt.pc b/Library/Homebrew/os/mac/pkgconfig/13/libexslt.pc
index 9c3b1be35fbe5..75f17f232fb85 100644
--- a/Library/Homebrew/os/mac/pkgconfig/13/libexslt.pc
+++ b/Library/Homebrew/os/mac/pkgconfig/13/libexslt.pc
@@ -8,6 +8,7 @@ includedir=${prefix}/include
 Name: libexslt
 Version: 0.8.20
 Description: EXSLT Extension library
-Requires: libxml-2.0
-Libs: -L${libdir} -lexslt -lxslt  -lxml2 -lz -lpthread -licucore -lm
+Requires: libxml-2.0, libxslt
 Cflags:
+Libs: -L${libdir} -lexslt
+Libs.private:
diff --git a/Library/Homebrew/os/mac/pkgconfig/13/libxslt.pc b/Library/Homebrew/os/mac/pkgconfig/13/libxslt.pc
index 7c7c57f42fe91..63f2409298836 100644
--- a/Library/Homebrew/os/mac/pkgconfig/13/libxslt.pc
+++ b/Library/Homebrew/os/mac/pkgconfig/13/libxslt.pc
@@ -9,5 +9,6 @@ Name: libxslt
 Version: 1.1.35
 Description: XSLT library version 2.
 Requires: libxml-2.0
-Libs: -L${libdir} -lxslt  -lxml2 -lz -lpthread -licucore -lm
 Cflags:
+Libs: -L${libdir} -lxslt
+Libs.private:
diff --git a/Library/Homebrew/os/mac/pkgconfig/13/sqlite3.pc b/Library/Homebrew/os/mac/pkgconfig/13/sqlite3.pc
index dac932dad78c8..cc7c4618805e6 100644
--- a/Library/Homebrew/os/mac/pkgconfig/13/sqlite3.pc
+++ b/Library/Homebrew/os/mac/pkgconfig/13/sqlite3.pc
@@ -6,7 +6,7 @@ includedir=${prefix}/include
 
 Name: SQLite
 Description: SQL database engine
-Version: 3.37.0
+Version: 3.39.5
 Libs: -L${libdir} -lsqlite3
 Libs.private:
 Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/14/bzip2.pc b/Library/Homebrew/os/mac/pkgconfig/14/bzip2.pc
new file mode 100644
index 0000000000000..a6e80ca8d0290
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/14/bzip2.pc
@@ -0,0 +1,12 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+bindir=${exec_prefix}/bin
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: bzip2
+Description: Lossless, block-sorting data compression
+Version: 1.0.8
+Libs: -L${libdir} -lbz2
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/14/expat.pc b/Library/Homebrew/os/mac/pkgconfig/14/expat.pc
new file mode 100644
index 0000000000000..b2a17239f3025
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/14/expat.pc
@@ -0,0 +1,13 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: expat
+Version: 2.5.0
+Description: expat XML parser
+URL: https://libexpat.github.io/
+Libs: -L${libdir} -lexpat
+Libs.private:
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/14/libcurl.pc b/Library/Homebrew/os/mac/pkgconfig/14/libcurl.pc
new file mode 100644
index 0000000000000..1577f58047145
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/14/libcurl.pc
@@ -0,0 +1,42 @@
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at https://curl.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+# SPDX-License-Identifier: curl
+#
+###########################################################################
+
+# This should most probably benefit from getting a "Requires:" field added
+# dynamically by configure.
+#
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+supported_protocols="DICT FILE FTP FTPS GOPHER GOPHERS HTTP HTTPS IMAP IMAPS IPFS IPNS LDAP LDAPS MQTT POP3 POP3S RTSP SMB SMBS SMTP SMTPS TELNET TFTP"
+supported_features="alt-svc AsynchDNS GSS-API HSTS HTTP2 HTTPS-proxy IPv6 Kerberos Largefile libz MultiSSL NTLM SPNEGO SSL threadsafe UnixSockets"
+
+Name: libcurl
+URL: https://curl.se/
+Description: Library to transfer files with ftp, http, etc.
+Version: 8.6.0
+Libs: -L${libdir} -lcurl
+Libs.private: -lldap -lz
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/14/libedit.pc b/Library/Homebrew/os/mac/pkgconfig/14/libedit.pc
new file mode 100644
index 0000000000000..102ea434d03fa
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/14/libedit.pc
@@ -0,0 +1,12 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: libedit
+Description: command line editor library provides generic line editing, history, and tokenization functions.
+Version: 3.0
+Requires:
+Libs: -L${libdir} -ledit
+Cflags: -I${includedir}/editline
diff --git a/Library/Homebrew/os/mac/pkgconfig/14/libexslt.pc b/Library/Homebrew/os/mac/pkgconfig/14/libexslt.pc
new file mode 100644
index 0000000000000..d977f7c424141
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/14/libexslt.pc
@@ -0,0 +1,14 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+
+Name: libexslt
+Version: 0.8.20
+Description: EXSLT Extension library
+Requires: libxml-2.0, libxslt
+Cflags:
+Libs: -L${libdir} -lexslt
+Libs.private:
diff --git a/Library/Homebrew/os/mac/pkgconfig/14/libffi.pc b/Library/Homebrew/os/mac/pkgconfig/14/libffi.pc
new file mode 100644
index 0000000000000..77ffd38c0e599
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/14/libffi.pc
@@ -0,0 +1,12 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+toolexeclibdir=${libdir}
+includedir=${prefix}/include/ffi
+
+Name: libffi
+Description: Library supporting Foreign Function Interfaces
+Version: 3.4-rc1
+Libs: -L${toolexeclibdir} -lffi
+Cflags: -I${includedir}
diff --git a/Library/Homebrew/os/mac/pkgconfig/14/libxml-2.0.pc b/Library/Homebrew/os/mac/pkgconfig/14/libxml-2.0.pc
new file mode 100644
index 0000000000000..9af71c4f4e808
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/14/libxml-2.0.pc
@@ -0,0 +1,14 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+modules=1
+
+Name: libXML
+Version: 2.9.13
+Description: libXML library version2.
+Requires:
+Libs: -L${libdir} -lxml2
+Libs.private: -lz -lpthread -licucore -lm
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/14/libxslt.pc b/Library/Homebrew/os/mac/pkgconfig/14/libxslt.pc
new file mode 100644
index 0000000000000..75f3d2724037d
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/14/libxslt.pc
@@ -0,0 +1,14 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+
+Name: libxslt
+Version: 1.1.35
+Description: XSLT library version 2.
+Requires: libxml-2.0
+Cflags:
+Libs: -L${libdir} -lxslt
+Libs.private:
diff --git a/Library/Homebrew/os/mac/pkgconfig/14/ncurses.pc b/Library/Homebrew/os/mac/pkgconfig/14/ncurses.pc
new file mode 100644
index 0000000000000..962a6f165329b
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/14/ncurses.pc
@@ -0,0 +1,17 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+abi_version=5.4
+major_version=6
+version=6.0.20150808
+
+Name: ncurses
+Description: ncurses 6.0 library
+Version: ${version}
+URL: http://invisible-island.net/ncurses
+Requires.private:
+Libs: -L${libdir} -lncurses
+Libs.private:
+Cflags: -D_DARWIN_C_SOURCE
diff --git a/Library/Homebrew/os/mac/pkgconfig/14/ncursesw.pc b/Library/Homebrew/os/mac/pkgconfig/14/ncursesw.pc
new file mode 100644
index 0000000000000..1322afb2054a8
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/14/ncursesw.pc
@@ -0,0 +1,17 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+abi_version=5.4
+major_version=6
+version=6.0.20150808
+
+Name: ncursesw
+Description: ncurses 6.0 library
+Version: ${version}
+URL: http://invisible-island.net/ncurses
+Requires.private:
+Libs: -L${libdir} -lncurses
+Libs.private:
+Cflags: -D_DARWIN_C_SOURCE
diff --git a/Library/Homebrew/os/mac/pkgconfig/14/sqlite3.pc b/Library/Homebrew/os/mac/pkgconfig/14/sqlite3.pc
new file mode 100644
index 0000000000000..a00482b6136cf
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/14/sqlite3.pc
@@ -0,0 +1,12 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: SQLite
+Description: SQL database engine
+Version: 3.43.2
+Libs: -L${libdir} -lsqlite3
+Libs.private:
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/14/uuid.pc b/Library/Homebrew/os/mac/pkgconfig/14/uuid.pc
new file mode 100644
index 0000000000000..cd698830c19ab
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/14/uuid.pc
@@ -0,0 +1,14 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+sharedlibdir=${libdir}
+includedir=${prefix}/include/uuid
+
+Name: uuid
+Description: Universally unique id library
+Version: 1.0
+
+Requires:
+Libs:
+Cflags: -I${includedir}
diff --git a/Library/Homebrew/os/mac/pkgconfig/14/zlib.pc b/Library/Homebrew/os/mac/pkgconfig/14/zlib.pc
new file mode 100644
index 0000000000000..1930766436424
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/14/zlib.pc
@@ -0,0 +1,14 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX14.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+sharedlibdir=${libdir}
+includedir=${prefix}/include
+
+Name: zlib
+Description: zlib compression library
+Version: 1.2.12
+
+Requires:
+Libs: -L${libdir} -L${sharedlibdir} -lz
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/15/bzip2.pc b/Library/Homebrew/os/mac/pkgconfig/15/bzip2.pc
new file mode 100644
index 0000000000000..e7546dd58acab
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/15/bzip2.pc
@@ -0,0 +1,12 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX15.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+bindir=${exec_prefix}/bin
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: bzip2
+Description: Lossless, block-sorting data compression
+Version: 1.0.8
+Libs: -L${libdir} -lbz2
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/15/expat.pc b/Library/Homebrew/os/mac/pkgconfig/15/expat.pc
new file mode 100644
index 0000000000000..0160794162aa9
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/15/expat.pc
@@ -0,0 +1,14 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX15.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: expat
+Version: 2.6.1
+Description: expat XML parser
+URL: https://libexpat.github.io/
+Libs: -L${libdir} -lexpat
+Libs.private:
+Cflags:
+Cflags.private: -DXML_STATIC
diff --git a/Library/Homebrew/os/mac/pkgconfig/15/libcurl.pc b/Library/Homebrew/os/mac/pkgconfig/15/libcurl.pc
new file mode 100644
index 0000000000000..25ee94de98a5c
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/15/libcurl.pc
@@ -0,0 +1,42 @@
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at https://curl.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+# SPDX-License-Identifier: curl
+#
+###########################################################################
+
+# This should most probably benefit from getting a "Requires:" field added
+# dynamically by configure.
+#
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX15.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+supported_protocols="DICT FILE FTP FTPS GOPHER GOPHERS HTTP HTTPS IMAP IMAPS IPFS IPNS LDAP LDAPS MQTT POP3 POP3S RTSP SMB SMBS SMTP SMTPS TELNET TFTP"
+supported_features="alt-svc AsynchDNS GSS-API HSTS HTTP2 HTTPS-proxy IPv6 Kerberos Largefile libz MultiSSL NTLM SPNEGO SSL threadsafe UnixSockets"
+
+Name: libcurl
+URL: https://curl.se/
+Description: Library to transfer files with ftp, http, etc.
+Version: 8.7.1
+Libs: -L${libdir} -lcurl
+Libs.private: -lldap -lz
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/15/libedit.pc b/Library/Homebrew/os/mac/pkgconfig/15/libedit.pc
new file mode 100644
index 0000000000000..b9e29b70c92ee
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/15/libedit.pc
@@ -0,0 +1,12 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX15.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: libedit
+Description: command line editor library provides generic line editing, history, and tokenization functions.
+Version: 3.0
+Requires:
+Libs: -L${libdir} -ledit
+Cflags: -I${includedir}/editline
diff --git a/Library/Homebrew/os/mac/pkgconfig/15/libexslt.pc b/Library/Homebrew/os/mac/pkgconfig/15/libexslt.pc
new file mode 100644
index 0000000000000..e06b1fded2a0b
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/15/libexslt.pc
@@ -0,0 +1,14 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX15.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+
+Name: libexslt
+Version: 0.8.20
+Description: EXSLT Extension library
+Requires: libxml-2.0, libxslt
+Cflags:
+Libs: -L${libdir} -lexslt
+Libs.private:
diff --git a/Library/Homebrew/os/mac/pkgconfig/15/libffi.pc b/Library/Homebrew/os/mac/pkgconfig/15/libffi.pc
new file mode 100644
index 0000000000000..07442f421f3f6
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/15/libffi.pc
@@ -0,0 +1,12 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX15.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+toolexeclibdir=${libdir}
+includedir=${prefix}/include/ffi
+
+Name: libffi
+Description: Library supporting Foreign Function Interfaces
+Version: 3.4-rc1
+Libs: -L${toolexeclibdir} -lffi
+Cflags: -I${includedir}
diff --git a/Library/Homebrew/os/mac/pkgconfig/15/libxml-2.0.pc b/Library/Homebrew/os/mac/pkgconfig/15/libxml-2.0.pc
new file mode 100644
index 0000000000000..211dcdd03b64a
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/15/libxml-2.0.pc
@@ -0,0 +1,14 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX15.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+modules=1
+
+Name: libXML
+Version: 2.9.13
+Description: libXML library version2.
+Requires:
+Libs: -L${libdir} -lxml2
+Libs.private: -lz -lpthread -licucore -lm
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/15/libxslt.pc b/Library/Homebrew/os/mac/pkgconfig/15/libxslt.pc
new file mode 100644
index 0000000000000..cdb0bab9d7dc2
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/15/libxslt.pc
@@ -0,0 +1,14 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX15.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+
+Name: libxslt
+Version: 1.1.35
+Description: XSLT library version 2.
+Requires: libxml-2.0
+Cflags:
+Libs: -L${libdir} -lxslt
+Libs.private:
diff --git a/Library/Homebrew/os/mac/pkgconfig/15/ncurses.pc b/Library/Homebrew/os/mac/pkgconfig/15/ncurses.pc
new file mode 100644
index 0000000000000..abeb1e0bdba92
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/15/ncurses.pc
@@ -0,0 +1,17 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX15.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+abi_version=5.4
+major_version=6
+version=6.0.20150808
+
+Name: ncurses
+Description: ncurses 6.0 library
+Version: ${version}
+URL: http://invisible-island.net/ncurses
+Requires.private:
+Libs: -L${libdir} -lncurses
+Libs.private:
+Cflags: -D_DARWIN_C_SOURCE
diff --git a/Library/Homebrew/os/mac/pkgconfig/15/ncursesw.pc b/Library/Homebrew/os/mac/pkgconfig/15/ncursesw.pc
new file mode 100644
index 0000000000000..282d60ae91343
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/15/ncursesw.pc
@@ -0,0 +1,17 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX15.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+abi_version=5.4
+major_version=6
+version=6.0.20150808
+
+Name: ncursesw
+Description: ncurses 6.0 library
+Version: ${version}
+URL: http://invisible-island.net/ncurses
+Requires.private:
+Libs: -L${libdir} -lncurses
+Libs.private:
+Cflags: -D_DARWIN_C_SOURCE
diff --git a/Library/Homebrew/os/mac/pkgconfig/15/sqlite3.pc b/Library/Homebrew/os/mac/pkgconfig/15/sqlite3.pc
new file mode 100644
index 0000000000000..e054da03ea3c3
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/15/sqlite3.pc
@@ -0,0 +1,12 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX15.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: SQLite
+Description: SQL database engine
+Version: 3.43.2
+Libs: -L${libdir} -lsqlite3
+Libs.private:
+Cflags:
diff --git a/Library/Homebrew/os/mac/pkgconfig/15/uuid.pc b/Library/Homebrew/os/mac/pkgconfig/15/uuid.pc
new file mode 100644
index 0000000000000..06ff8ce3971ea
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/15/uuid.pc
@@ -0,0 +1,14 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX15.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+sharedlibdir=${libdir}
+includedir=${prefix}/include/uuid
+
+Name: uuid
+Description: Universally unique id library
+Version: 1.0
+
+Requires:
+Libs:
+Cflags: -I${includedir}
diff --git a/Library/Homebrew/os/mac/pkgconfig/15/zlib.pc b/Library/Homebrew/os/mac/pkgconfig/15/zlib.pc
new file mode 100644
index 0000000000000..d2be681dbfd89
--- /dev/null
+++ b/Library/Homebrew/os/mac/pkgconfig/15/zlib.pc
@@ -0,0 +1,14 @@
+homebrew_sdkroot=/Library/Developer/CommandLineTools/SDKs/MacOSX15.sdk
+prefix=${homebrew_sdkroot}/usr
+exec_prefix=/usr
+libdir=${exec_prefix}/lib
+sharedlibdir=${libdir}
+includedir=${prefix}/include
+
+Name: zlib
+Description: zlib compression library
+Version: 1.2.12
+
+Requires:
+Libs: -L${libdir} -L${sharedlibdir} -lz
+Cflags:
diff --git a/Library/Homebrew/os/mac/sdk.rb b/Library/Homebrew/os/mac/sdk.rb
index 28f838cfdcc20..1584941c99585 100644
--- a/Library/Homebrew/os/mac/sdk.rb
+++ b/Library/Homebrew/os/mac/sdk.rb
@@ -1,20 +1,16 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "os/mac/version"
+require "system_command"
 
 module OS
   module Mac
     # Class representing a macOS SDK.
-    #
-    # @api private
     class SDK
-      extend T::Sig
-
       # 11.x SDKs are explicitly excluded - we want the MacOSX11.sdk symlink instead.
-      VERSIONED_SDK_REGEX = /MacOSX(10\.\d+|\d+)\.sdk$/.freeze
+      VERSIONED_SDK_REGEX = /MacOSX(10\.\d+|\d+)\.sdk$/
 
-      sig { returns(OS::Mac::Version) }
+      sig { returns(MacOSVersion) }
       attr_reader :version
 
       sig { returns(Pathname) }
@@ -23,7 +19,7 @@ class SDK
       sig { returns(Symbol) }
       attr_reader :source
 
-      sig { params(version: OS::Mac::Version, path: T.any(String, Pathname), source: Symbol).void }
+      sig { params(version: MacOSVersion, path: T.any(String, Pathname), source: Symbol).void }
       def initialize(version, path, source)
         @version = version
         @path = Pathname.new(path)
@@ -32,19 +28,17 @@ def initialize(version, path, source)
     end
 
     # Base class for SDK locators.
-    #
-    # @api private
     class BaseSDKLocator
-      extend T::Sig
       extend T::Helpers
+      include SystemCommand::Mixin
 
       abstract!
 
       class NoSDKError < StandardError; end
 
-      sig { params(v: OS::Mac::Version).returns(SDK) }
-      def sdk_for(v)
-        sdk = all_sdks.find { |s| s.version == v }
+      sig { params(version: MacOSVersion).returns(SDK) }
+      def sdk_for(version)
+        sdk = all_sdks.find { |s| s.version == version }
         raise NoSDKError if sdk.nil?
 
         sdk
@@ -80,13 +74,13 @@ def all_sdks
         @all_sdks
       end
 
-      sig { params(v: T.nilable(OS::Mac::Version)).returns(T.nilable(SDK)) }
-      def sdk_if_applicable(v = nil)
+      sig { params(version: T.nilable(MacOSVersion)).returns(T.nilable(SDK)) }
+      def sdk_if_applicable(version = nil)
         sdk = begin
-          if v.blank?
+          if version.blank?
             sdk_for OS::Mac.version
           else
-            sdk_for v
+            sdk_for version
           end
         rescue NoSDKError
           latest_sdk
@@ -95,7 +89,7 @@ def sdk_if_applicable(v = nil)
 
         # On OSs lower than 11, whenever the major versions don't match,
         # only return an SDK older than the OS version if it was specifically requested
-        return if v.blank? && sdk.version < OS::Mac.version
+        return if version.blank? && sdk.version < OS::Mac.version
 
         sdk
       end
@@ -113,7 +107,7 @@ def latest_sdk
         all_sdks.max_by(&:version)
       end
 
-      sig { params(sdk_path: Pathname).returns(T.nilable(OS::Mac::Version)) }
+      sig { params(sdk_path: Pathname).returns(T.nilable(MacOSVersion)) }
       def read_sdk_version(sdk_path)
         sdk_settings = sdk_path/"SDKSettings.json"
         sdk_settings_string = sdk_settings.read if sdk_settings.exist?
@@ -134,8 +128,8 @@ def read_sdk_version(sdk_path)
         return if version_string.blank?
 
         begin
-          OS::Mac::Version.new(version_string).strip_patch
-        rescue MacOSVersionError
+          MacOSVersion.new(version_string).strip_patch
+        rescue MacOSVersion::Error
           nil
         end
       end
@@ -143,11 +137,7 @@ def read_sdk_version(sdk_path)
     private_constant :BaseSDKLocator
 
     # Helper class for locating the Xcode SDK.
-    #
-    # @api private
     class XcodeSDKLocator < BaseSDKLocator
-      extend T::Sig
-
       sig { override.returns(Symbol) }
       def source
         :xcode
@@ -161,7 +151,7 @@ def sdk_prefix
           # Xcode.prefix is pretty smart, so let's look inside to find the sdk
           sdk_prefix = "#{Xcode.prefix}/Platforms/MacOSX.platform/Developer/SDKs"
           # Finally query Xcode itself (this is slow, so check it last)
-          sdk_platform_path = Utils.popen_read(DevelopmentTools.locate("xcrun"), "--show-sdk-platform-path").chomp
+          sdk_platform_path = Utils.popen_read(::DevelopmentTools.locate("xcrun"), "--show-sdk-platform-path").chomp
           sdk_prefix = File.join(sdk_platform_path, "Developer", "SDKs") unless File.directory? sdk_prefix
 
           sdk_prefix
@@ -170,11 +160,7 @@ def sdk_prefix
     end
 
     # Helper class for locating the macOS Command Line Tools SDK.
-    #
-    # @api private
     class CLTSDKLocator < BaseSDKLocator
-      extend T::Sig
-
       sig { override.returns(Symbol) }
       def source
         :clt
@@ -187,8 +173,8 @@ def source
       # using that.
       # As of Xcode 10, the Unix-style headers are installed via a
       # separate package, so we can't rely on their being present.
-      # This will only look up SDKs on Xcode 10 or newer, and still
-      # return nil SDKs for Xcode 9 and older.
+      # This will only look up SDKs on Xcode 10 or newer and still
+      # return `nil` SDKs for Xcode 9 and older.
       sig { override.returns(String) }
       def sdk_prefix
         @sdk_prefix ||= if CLT.provides_sdk?
diff --git a/Library/Homebrew/os/mac/version.rb b/Library/Homebrew/os/mac/version.rb
deleted file mode 100644
index 5f86f697a2bd8..0000000000000
--- a/Library/Homebrew/os/mac/version.rb
+++ /dev/null
@@ -1,107 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "exceptions"
-require "hardware"
-require "version"
-
-module OS
-  module Mac
-    # A macOS version.
-    #
-    # @api private
-    class Version < ::Version
-      extend T::Sig
-
-      # TODO: bump version when new macOS is released or announced
-      # and also update references in docs/Installation.md,
-      # https://github.com/Homebrew/install/blob/HEAD/install.sh and
-      # MacOSVersions::SYMBOLS
-      NEWEST_UNSUPPORTED = "13"
-      private_constant :NEWEST_UNSUPPORTED
-
-      # TODO: bump version when new macOS is released and also update
-      # references in docs/Installation.md and
-      # https://github.com/Homebrew/install/blob/HEAD/install.sh
-      OLDEST_SUPPORTED = "10.15"
-      private_constant :OLDEST_SUPPORTED
-
-      OLDEST_ALLOWED = "10.11"
-
-      sig { params(version: Symbol).returns(T.attached_class) }
-      def self.from_symbol(version)
-        str = MacOSVersions::SYMBOLS.fetch(version) { raise MacOSVersionError, version }
-        new(str)
-      end
-
-      sig { params(value: T.nilable(String)).void }
-      def initialize(value)
-        version ||= value
-
-        raise MacOSVersionError, version unless /\A1\d+(?:\.\d+){0,2}\Z/.match?(version)
-
-        super(version)
-
-        @comparison_cache = {}
-      end
-
-      sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
-      def <=>(other)
-        @comparison_cache.fetch(other) do
-          if MacOSVersions::SYMBOLS.key?(other) && to_sym == other
-            0
-          else
-            v = MacOSVersions::SYMBOLS.fetch(other) { other.to_s }
-            @comparison_cache[other] = super(::Version.new(v))
-          end
-        end
-      end
-
-      sig { returns(T.self_type) }
-      def strip_patch
-        # Big Sur is 11.x but Catalina is 10.15.x.
-        if major >= 11
-          self.class.new(major.to_s)
-        else
-          major_minor
-        end
-      end
-
-      sig { returns(Symbol) }
-      def to_sym
-        @to_sym ||= MacOSVersions::SYMBOLS.invert.fetch(strip_patch.to_s, :dunno)
-      end
-
-      sig { returns(String) }
-      def pretty_name
-        @pretty_name ||= to_sym.to_s.split("_").map(&:capitalize).join(" ").freeze
-      end
-
-      sig { returns(T::Boolean) }
-      def outdated_release?
-        self < OLDEST_SUPPORTED
-      end
-
-      sig { returns(T::Boolean) }
-      def prerelease?
-        self >= NEWEST_UNSUPPORTED
-      end
-
-      # For {OS::Mac::Version} compatibility.
-      sig { returns(T::Boolean) }
-      def requires_nehalem_cpu?
-        unless Hardware::CPU.intel?
-          raise "Unexpected architecture: #{Hardware::CPU.arch}. This only works with Intel architecture."
-        end
-
-        Hardware.oldest_cpu(self) == :nehalem
-      end
-      # https://en.wikipedia.org/wiki/Nehalem_(microarchitecture)
-      # Ensure any extra methods are also added to version/null.rb
-      alias requires_sse4? requires_nehalem_cpu?
-      alias requires_sse41? requires_nehalem_cpu?
-      alias requires_sse42? requires_nehalem_cpu?
-      alias requires_popcnt? requires_nehalem_cpu?
-    end
-  end
-end
diff --git a/Library/Homebrew/os/mac/version.rbi b/Library/Homebrew/os/mac/version.rbi
deleted file mode 100644
index dc7c90848ae92..0000000000000
--- a/Library/Homebrew/os/mac/version.rbi
+++ /dev/null
@@ -1,10 +0,0 @@
-# typed: strict
-
-module OS
-  module Mac
-    class Version
-      sig { returns(Token) }
-      def major; end
-    end
-  end
-end
diff --git a/Library/Homebrew/os/mac/xcode.rb b/Library/Homebrew/os/mac/xcode.rb
old mode 100755
new mode 100644
index 6a22216d88d1f..5af295fcf69eb
--- a/Library/Homebrew/os/mac/xcode.rb
+++ b/Library/Homebrew/os/mac/xcode.rb
@@ -1,16 +1,10 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module OS
   module Mac
     # Helper module for querying Xcode information.
-    #
-    # @api private
     module Xcode
-      extend T::Sig
-
-      module_function
-
       DEFAULT_BUNDLE_PATH = Pathname("/Applications/Xcode.app").freeze
       BUNDLE_ID = "com.apple.dt.Xcode"
       OLD_BUNDLE_ID = "com.apple.Xcode"
@@ -19,12 +13,14 @@ module Xcode
       # Bump these when a new version is available from the App Store and our
       # CI systems have been updated.
       # This may be a beta version for a beta macOS.
-      sig { params(macos: MacOS::Version).returns(String) }
-      def latest_version(macos: MacOS.version)
-        latest_stable = "13.4"
+      sig { params(macos: MacOSVersion).returns(String) }
+      def self.latest_version(macos: MacOS.version)
+        latest_stable = "15.4"
         case macos
-        when "13" then "14.0"
-        when "12" then latest_stable
+        when "15" then "16.0"
+        when "14" then latest_stable
+        when "13" then "15.2"
+        when "12" then "14.2"
         when "11" then "13.2.1"
         when "10.15" then "12.4"
         when "10.14" then "11.3.1"
@@ -44,83 +40,81 @@ def latest_version(macos: MacOS.version)
       # macOS version (which may initially be a beta if that version of macOS is
       # also in beta).
       sig { returns(String) }
-      def minimum_version
+      def self.minimum_version
         case MacOS.version
-        when "13" then "14.0"
+        when "15" then "16.0"
+        when "14" then "15.0"
+        when "13" then "14.1"
         when "12" then "13.1"
         when "11" then "12.2"
         when "10.15" then "11.0"
         when "10.14" then "10.2"
         when "10.13" then "9.0"
         when "10.12" then "8.0"
-        else "2.0"
+        else "7.3"
         end
       end
 
       sig { returns(T::Boolean) }
-      def below_minimum_version?
+      def self.below_minimum_version?
         return false unless installed?
 
         version < minimum_version
       end
 
       sig { returns(T::Boolean) }
-      def latest_sdk_version?
+      def self.latest_sdk_version?
         OS::Mac.full_version >= OS::Mac.latest_sdk_version
       end
 
       sig { returns(T::Boolean) }
-      def needs_clt_installed?
+      def self.needs_clt_installed?
         return false if latest_sdk_version?
 
         # With fake El Capitan for Portable Ruby, we want the full 10.11 SDK so that we can link
         # against the correct set of libraries in the SDK sysroot rather than the system's copies.
         # We therefore do not use the CLT under this setup, which installs to /usr/include.
-        return false if ENV["HOMEBREW_FAKE_EL_CAPITAN"]
+        return false if ENV["HOMEBREW_FAKE_MACOS"]
 
         without_clt?
       end
 
       sig { returns(T::Boolean) }
-      def outdated?
+      def self.outdated?
         return false unless installed?
 
         version < latest_version
       end
 
       sig { returns(T::Boolean) }
-      def without_clt?
+      def self.without_clt?
         !MacOS::CLT.installed?
       end
 
       # Returns a Pathname object corresponding to Xcode.app's Developer
       # directory or nil if Xcode.app is not installed.
       sig { returns(T.nilable(Pathname)) }
-      def prefix
-        return @prefix if defined?(@prefix)
-
-        @prefix = T.let(@prefix, T.nilable(Pathname))
-        @prefix ||=
-          begin
-            dir = MacOS.active_developer_dir
-
-            if dir.empty? || dir == CLT::PKG_PATH || !File.directory?(dir)
-              path = bundle_path
-              path/"Contents/Developer" if path
-            else
-              # Use cleanpath to avoid pathological trailing slash
-              Pathname.new(dir).cleanpath
-            end
+      def self.prefix
+        @prefix ||= begin
+          dir = MacOS.active_developer_dir
+
+          if dir.empty? || dir == CLT::PKG_PATH || !File.directory?(dir)
+            path = bundle_path
+            path/"Contents/Developer" if path
+          else
+            # Use cleanpath to avoid pathological trailing slash
+            Pathname.new(dir).cleanpath
           end
+        end
       end
 
       sig { returns(Pathname) }
-      def toolchain_path
+      def self.toolchain_path
         Pathname("#{prefix}/Toolchains/XcodeDefault.xctoolchain")
       end
 
       sig { returns(T.nilable(Pathname)) }
-      def bundle_path
+      def self.bundle_path
         # Use the default location if it exists.
         return DEFAULT_BUNDLE_PATH if DEFAULT_BUNDLE_PATH.exist?
 
@@ -131,27 +125,27 @@ def bundle_path
       end
 
       sig { returns(T::Boolean) }
-      def installed?
+      def self.installed?
         !prefix.nil?
       end
 
       sig { returns(XcodeSDKLocator) }
-      def sdk_locator
+      def self.sdk_locator
         @sdk_locator ||= XcodeSDKLocator.new
       end
 
-      sig { params(v: T.nilable(MacOS::Version)).returns(T.nilable(SDK)) }
-      def sdk(v = nil)
-        sdk_locator.sdk_if_applicable(v)
+      sig { params(version: T.nilable(MacOSVersion)).returns(T.nilable(SDK)) }
+      def self.sdk(version = nil)
+        sdk_locator.sdk_if_applicable(version)
       end
 
-      sig { params(v: T.nilable(MacOS::Version)).returns(T.nilable(Pathname)) }
-      def sdk_path(v = nil)
-        sdk(v)&.path
+      sig { params(version: T.nilable(MacOSVersion)).returns(T.nilable(Pathname)) }
+      def self.sdk_path(version = nil)
+        sdk(version)&.path
       end
 
       sig { returns(String) }
-      def installation_instructions
+      def self.installation_instructions
         if OS::Mac.version.prerelease?
           <<~EOS
             Xcode can be installed from:
@@ -165,7 +159,7 @@ def installation_instructions
       end
 
       sig { returns(String) }
-      def update_instructions
+      def self.update_instructions
         if OS::Mac.version.prerelease?
           <<~EOS
             Xcode can be updated from:
@@ -178,8 +172,11 @@ def update_instructions
         end
       end
 
+      # Get the Xcode version.
+      #
+      # @api internal
       sig { returns(::Version) }
-      def version
+      def self.version
         # may return a version string
         # that is guessed based on the compiler, so do not
         # use it in order to check if Xcode is installed.
@@ -191,27 +188,37 @@ def version
       end
 
       sig { returns(T.nilable(String)) }
-      def detect_version
+      def self.detect_version
         # This is a separate function as you can't cache the value out of a block
         # if return is used in the middle, which we do many times in here.
         return if !MacOS::Xcode.installed? && !MacOS::CLT.installed?
 
-        %W[
-          #{prefix}/usr/bin/xcodebuild
-          #{which("xcodebuild")}
-        ].uniq.each do |xcodebuild_path|
-          next unless File.executable? xcodebuild_path
+        if MacOS::Xcode.installed?
+          # Fast path that will probably almost always work unless `xcode-select -p` is misconfigured
+          version_plist = T.must(prefix).parent/"version.plist"
+          if version_plist.file?
+            data = Plist.parse_xml(version_plist, marshal: false)
+            version = data["CFBundleShortVersionString"] if data
+            return version if version
+          end
+
+          %W[
+            #{prefix}/usr/bin/xcodebuild
+            #{which("xcodebuild")}
+          ].uniq.each do |xcodebuild_path|
+            next unless File.executable? xcodebuild_path
 
-          xcodebuild_output = Utils.popen_read(xcodebuild_path, "-version")
-          next unless $CHILD_STATUS.success?
+            xcodebuild_output = Utils.popen_read(xcodebuild_path, "-version")
+            next unless $CHILD_STATUS.success?
 
-          xcode_version = xcodebuild_output[/Xcode (\d+(\.\d+)*)/, 1]
-          return xcode_version if xcode_version
+            xcode_version = xcodebuild_output[/Xcode (\d+(\.\d+)*)/, 1]
+            return xcode_version if xcode_version
 
-          # Xcode 2.x's xcodebuild has a different version string
-          case xcodebuild_output[/DevToolsCore-(\d+\.\d)/, 1]
-          when "798.0" then return "2.5"
-          when "515.0" then return "2.0"
+            # Xcode 2.x's xcodebuild has a different version string
+            case xcodebuild_output[/DevToolsCore-(\d+\.\d)/, 1]
+            when "798.0" then return "2.5"
+            when "515.0" then return "2.0"
+            end
           end
         end
 
@@ -219,8 +226,8 @@ def detect_version
       end
 
       sig { returns(String) }
-      def detect_version_from_clang_version
-        version = DevelopmentTools.clang_version
+      def self.detect_version_from_clang_version
+        version = ::DevelopmentTools.clang_version
 
         return "dunno" if version.null?
 
@@ -245,25 +252,22 @@ def detect_version_from_clang_version
         when "12.0.0" then "12.4"
         when "12.0.5" then "12.5.1"
         when "13.0.0" then "13.2.1"
-        when "14.0.0" then "14.0"
-        else               "13.4"
+        when "13.1.6" then "13.4.1"
+        when "14.0.0" then "14.2"
+        when "14.0.3" then "14.3.1"
+        when "16.0.0" then "16.0"
+        else               "15.4"
         end
       end
 
       sig { returns(T::Boolean) }
-      def default_prefix?
+      def self.default_prefix?
         prefix.to_s == "/Applications/Xcode.app/Contents/Developer"
       end
     end
 
     # Helper module for querying macOS Command Line Tools information.
-    #
-    # @api private
     module CLT
-      extend T::Sig
-
-      module_function
-
       # The original Mavericks CLT package ID
       EXECUTABLE_PKG_ID = "com.apple.pkg.CLTools_Executables"
       MAVERICKS_NEW_PKG_ID = "com.apple.pkg.CLTools_Base" # obsolete
@@ -271,43 +275,48 @@ module CLT
 
       # Returns true even if outdated tools are installed.
       sig { returns(T::Boolean) }
-      def installed?
+      def self.installed?
         !version.null?
       end
 
       sig { returns(T::Boolean) }
-      def separate_header_package?
+      def self.separate_header_package?
         version >= "10" && MacOS.version >= "10.14"
       end
 
       sig { returns(T::Boolean) }
-      def provides_sdk?
+      def self.provides_sdk?
         version >= "8"
       end
 
       sig { returns(CLTSDKLocator) }
-      def sdk_locator
+      def self.sdk_locator
         @sdk_locator ||= CLTSDKLocator.new
       end
 
-      sig { params(v: T.nilable(MacOS::Version)).returns(T.nilable(SDK)) }
-      def sdk(v = nil)
-        sdk_locator.sdk_if_applicable(v)
+      sig { params(version: T.nilable(MacOSVersion)).returns(T.nilable(SDK)) }
+      def self.sdk(version = nil)
+        sdk_locator.sdk_if_applicable(version)
       end
 
-      sig { params(v: T.nilable(MacOS::Version)).returns(T.nilable(Pathname)) }
-      def sdk_path(v = nil)
-        sdk(v)&.path
+      sig { params(version: T.nilable(MacOSVersion)).returns(T.nilable(Pathname)) }
+      def self.sdk_path(version = nil)
+        sdk(version)&.path
       end
 
       sig { returns(String) }
-      def installation_instructions
+      def self.installation_instructions
         if MacOS.version == "10.14"
           # This is not available from `xcode-select`
           <<~EOS
             Install the Command Line Tools for Xcode 11.3.1 from:
               #{Formatter.url(MacOS::Xcode::APPLE_DEVELOPER_DOWNLOAD_URL)}
           EOS
+        elsif OS::Mac.version.prerelease?
+          <<~EOS
+            Install the Command Line Tools for Xcode #{minimum_version.split(".").first} from:
+              #{Formatter.url(MacOS::Xcode::APPLE_DEVELOPER_DOWNLOAD_URL)}
+          EOS
         else
           <<~EOS
             Install the Command Line Tools:
@@ -317,16 +326,19 @@ def installation_instructions
       end
 
       sig { returns(String) }
-      def update_instructions
-        software_update_location = if MacOS.version >= "10.14"
+      def self.update_instructions
+        return installation_instructions if OS::Mac.version.prerelease?
+
+        software_update_location = if MacOS.version >= "13"
+          "System Settings"
+        elsif MacOS.version >= "10.14"
           "System Preferences"
         else
           "the App Store"
         end
 
         <<~EOS
-          Update them from Software Update in #{software_update_location} or run:
-            softwareupdate --all --install --force
+          Update them from Software Update in #{software_update_location}.
 
           If that doesn't show you any updates, run:
             sudo rm -rf /Library/Developer/CommandLineTools
@@ -341,10 +353,12 @@ def update_instructions
       # Bump these when the new version is distributed through Software Update
       # and our CI systems have been updated.
       sig { returns(String) }
-      def latest_clang_version
+      def self.latest_clang_version
         case MacOS.version
-        when "13"    then "1400.0.17.3.1"
-        when "12"    then "1316.0.21.2.5"
+        when "15" then "1600.0.20.10"
+        when "14" then "1500.3.9.4"
+        when "13" then "1500.1.0.2.5"
+        when "12"    then "1400.0.29.202"
         when "11"    then "1300.0.29.30"
         when "10.15" then "1200.0.32.29"
         when "10.14" then "1100.0.33.17"
@@ -358,8 +372,10 @@ def latest_clang_version
       # without this. Generally this will be the first stable CLT release on
       # that macOS version.
       sig { returns(String) }
-      def minimum_version
+      def self.minimum_version
         case MacOS.version
+        when "15" then "16.0.0"
+        when "14" then "15.0.0"
         when "13" then "14.0.0"
         when "12" then "13.0.0"
         when "11" then "12.5.0"
@@ -367,19 +383,19 @@ def minimum_version
         when "10.14" then "10.0.0"
         when "10.13" then "9.0.0"
         when "10.12" then "8.0.0"
-        else              "1.0.0"
+        else              "7.3.0"
         end
       end
 
       sig { returns(T::Boolean) }
-      def below_minimum_version?
+      def self.below_minimum_version?
         return false unless installed?
 
         version < minimum_version
       end
 
       sig { returns(T::Boolean) }
-      def outdated?
+      def self.outdated?
         clang_version = detect_clang_version
         return false unless clang_version
 
@@ -387,21 +403,23 @@ def outdated?
       end
 
       sig { returns(T.nilable(String)) }
-      def detect_clang_version
+      def self.detect_clang_version
         version_output = Utils.popen_read("#{PKG_PATH}/usr/bin/clang", "--version")
         version_output[/clang-(\d+(\.\d+)+)/, 1]
       end
 
       sig { returns(T.nilable(String)) }
-      def detect_version_from_clang_version
+      def self.detect_version_from_clang_version
         detect_clang_version&.sub(/^(\d+)0(\d)\./, "\\1.\\2.")
       end
 
       # Version string (a pretty long one) of the CLT package.
       # Note that the different ways of installing the CLTs lead to different
       # version numbers.
+      #
+      # @api internal
       sig { returns(::Version) }
-      def version
+      def self.version
         if @version ||= detect_version
           ::Version.new @version
         else
@@ -410,7 +428,7 @@ def version
       end
 
       sig { returns(T.nilable(String)) }
-      def detect_version
+      def self.detect_version
         version = T.let(nil, T.nilable(String))
         [EXECUTABLE_PKG_ID, MAVERICKS_NEW_PKG_ID].each do |id|
           next unless File.exist?("#{PKG_PATH}/usr/bin/clang")
diff --git a/Library/Homebrew/os/mac/xcode.rbi b/Library/Homebrew/os/mac/xcode.rbi
deleted file mode 100644
index b0707a034e35d..0000000000000
--- a/Library/Homebrew/os/mac/xcode.rbi
+++ /dev/null
@@ -1,9 +0,0 @@
-# typed: strict
-
-module OS
-  module Mac
-    module Xcode
-      include Kernel
-    end
-  end
-end
diff --git a/Library/Homebrew/patch.rb b/Library/Homebrew/patch.rb
index 01cae78d8ebbe..488982bf8eaec 100644
--- a/Library/Homebrew/patch.rb
+++ b/Library/Homebrew/patch.rb
@@ -1,12 +1,10 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "resource"
 require "erb"
 
 # Helper module for creating patches.
-#
-# @api private
 module Patch
   def self.create(strip, src, &block)
     case strip
@@ -26,17 +24,13 @@ def self.create(strip, src, &block)
     when nil
       raise ArgumentError, "nil value for strip"
     else
-      raise ArgumentError, "unexpected value #{strip.inspect} for strip"
+      raise ArgumentError, "Unexpected value #{strip.inspect} for strip"
     end
   end
 end
 
 # An abstract class representing a patch embedded into a formula.
-#
-# @api private
 class EmbeddedPatch
-  extend T::Sig
-
   attr_writer :owner
   attr_reader :strip
 
@@ -64,11 +58,7 @@ def inspect
 end
 
 # A patch at the `__END__` of a formula file.
-#
-# @api private
 class DATAPatch < EmbeddedPatch
-  extend T::Sig
-
   attr_accessor :path
 
   def initialize(strip)
@@ -82,7 +72,7 @@ def contents
     path.open("rb") do |f|
       loop do
         line = f.gets
-        break if line.nil? || line =~ /^__END__$/
+        break if line.nil? || /^__END__$/.match?(line)
       end
       while (line = f.gets)
         data << line
@@ -93,8 +83,6 @@ def contents
 end
 
 # A string containing a patch.
-#
-# @api private
 class StringPatch < EmbeddedPatch
   def initialize(strip, str)
     super(strip)
@@ -106,12 +94,8 @@ def contents
   end
 end
 
-# A string containing a patch.
-#
-# @api private
+# A file containing a patch.
 class ExternalPatch
-  extend T::Sig
-
   extend Forwardable
 
   attr_reader :resource, :strip
@@ -122,7 +106,7 @@ class ExternalPatch
 
   def initialize(strip, &block)
     @strip    = strip
-    @resource = Resource::PatchResource.new(&block)
+    @resource = Resource::Patch.new(&block)
   end
 
   sig { returns(T::Boolean) }
@@ -131,8 +115,8 @@ def external?
   end
 
   def owner=(owner)
-    resource.owner   = owner
-    resource.version = resource.checksum || ERB::Util.url_encode(resource.url)
+    resource.owner = owner
+    resource.version(resource.checksum&.hexdigest || ERB::Util.url_encode(resource.url))
   end
 
   def apply
@@ -141,14 +125,14 @@ def apply
       patch_dir = Pathname.pwd
       if patch_files.empty?
         children = patch_dir.children
-        if children.length != 1 || !children.first.file?
+        if children.length != 1 || !children.fetch(0).file?
           raise MissingApplyError, <<~EOS
             There should be exactly one patch file in the staging directory unless
             the "apply" method was used one or more times in the patch-do block.
           EOS
         end
 
-        patch_files << children.first.basename
+        patch_files << children.fetch(0).basename
       end
       dir = base_dir
       dir /= resource.directory if resource.directory.present?
@@ -156,7 +140,12 @@ def apply
         patch_files.each do |patch_file|
           ohai "Applying #{patch_file}"
           patch_file = patch_dir/patch_file
-          safe_system "patch", "-g", "0", "-f", "-#{strip}", "-i", patch_file
+          Utils.safe_popen_write("patch", "-g", "0", "-f", "-#{strip}") do |p|
+            File.foreach(patch_file) do |line|
+              data = line.gsub("@@HOMEBREW_PREFIX@@", HOMEBREW_PREFIX)
+              p.write(data)
+            end
+          end
         end
       end
     end
diff --git a/Library/Homebrew/pkg_version.rb b/Library/Homebrew/pkg_version.rb
index 56e7e819e43ac..6e29244d0e51e 100644
--- a/Library/Homebrew/pkg_version.rb
+++ b/Library/Homebrew/pkg_version.rb
@@ -1,16 +1,14 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "version"
 
 # Combination of a version and a revision.
-#
-# @api private
 class PkgVersion
   include Comparable
   extend Forwardable
 
-  REGEX = /\A(.+?)(?:_(\d+))?\z/.freeze
+  REGEX = /\A(.+?)(?:_(\d+))?\z/
   private_constant :REGEX
 
   attr_reader :version, :revision
@@ -19,7 +17,7 @@ class PkgVersion
 
   def self.parse(path)
     _, version, revision = *path.match(REGEX)
-    version = Version.create(version)
+    version = Version.new(version)
     new(version, revision.to_i)
   end
 
@@ -32,14 +30,17 @@ def head?
     version.head?
   end
 
-  def to_s
+  sig { returns(String) }
+  def to_str
     if revision.positive?
       "#{version}_#{revision}"
     else
       version.to_s
     end
   end
-  alias to_str to_s
+
+  sig { returns(String) }
+  def to_s = to_str
 
   def <=>(other)
     return unless other.is_a?(PkgVersion)
diff --git a/Library/Homebrew/pkg_version.rbi b/Library/Homebrew/pkg_version.rbi
new file mode 100644
index 0000000000000..41f19badd37e5
--- /dev/null
+++ b/Library/Homebrew/pkg_version.rbi
@@ -0,0 +1,8 @@
+# typed: strict
+
+class PkgVersion
+  # This is a workaround to enable `alias eql? ==`
+  # @see https://github.com/sorbet/sorbet/issues/2378#issuecomment-569474238
+  sig { params(other: BasicObject).returns(T::Boolean) }
+  def ==(other); end
+end
diff --git a/Library/Homebrew/postinstall.rb b/Library/Homebrew/postinstall.rb
index bd836db12ad99..5b4db3f545267 100644
--- a/Library/Homebrew/postinstall.rb
+++ b/Library/Homebrew/postinstall.rb
@@ -1,24 +1,31 @@
 # typed: strict
 # frozen_string_literal: true
 
+raise "#{__FILE__} must not be loaded via `require`." if $PROGRAM_NAME != __FILE__
+
 old_trap = trap("INT") { exit! 130 }
 
 require_relative "global"
-require "debrew"
+
 require "fcntl"
-require "socket"
+require "utils/socket"
 require "cli/parser"
 require "cmd/postinstall"
+require "json/add/exception"
 
 begin
-  args = Homebrew.postinstall_args.parse
-  error_pipe = UNIXSocket.open(ENV.fetch("HOMEBREW_ERROR_PIPE"), &:recv_io)
+  ENV.delete("HOMEBREW_FORBID_PACKAGES_FROM_PATHS")
+  args = Homebrew::Cmd::Postinstall.new.args
+  error_pipe = Utils::UNIXSocketExt.open(ENV.fetch("HOMEBREW_ERROR_PIPE"), &:recv_io)
   error_pipe.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 
   trap("INT", old_trap)
 
   formula = T.must(args.named.to_resolved_formulae.first)
-  formula.extend(Debrew::Formula) if args.debug?
+  if args.debug? && !Homebrew::EnvConfig.disable_debrew?
+    require "debrew"
+    formula.extend(Debrew::Formula)
+  end
   formula.run_post_install
 rescue Exception => e # rubocop:disable Lint/RescueException
   error_pipe.puts e.to_json
diff --git a/Library/Homebrew/prefix.sh b/Library/Homebrew/prefix.sh
deleted file mode 100644
index b35f0e791c77f..0000000000000
--- a/Library/Homebrew/prefix.sh
+++ /dev/null
@@ -1,42 +0,0 @@
-# does the quickest output of brew --prefix possible for the basic cases:
-# - `brew --prefix` (output HOMEBREW_PREFIX)
-# - `brew --prefix <formula>` (output HOMEBREW_PREFIX/opt/<formula>)
-# anything else? delegate to the slower cmd/--prefix.rb
-# HOMEBREW_PREFIX and HOMEBREW_REPOSITORY are set by brew.sh
-# shellcheck disable=SC2154
-homebrew-prefix() {
-  while [[ "$#" -gt 0 ]]
-  do
-    case "$1" in
-      # check we actually have --prefix and not e.g. --prefixsomething
-      --prefix)
-        local prefix="1"
-        shift
-        ;;
-      # reject all other flags
-      -*) return 1 ;;
-      *)
-        [[ -n "${formula}" ]] && return 1
-        local formula="$1"
-        shift
-        ;;
-    esac
-  done
-  [[ -z "${prefix}" ]] && return 1
-  [[ -z "${formula}" ]] && echo "${HOMEBREW_PREFIX}" && return 0
-
-  local formula_path
-  if [[ -f "${HOMEBREW_REPOSITORY}/Library/Taps/homebrew/homebrew-core/Formula/${formula}.rb" ]]
-  then
-    formula_path="${HOMEBREW_REPOSITORY}/Library/Taps/homebrew/homebrew-core/Formula/${formula}.rb"
-  else
-    formula_path="$(
-      shopt -s nullglob
-      echo "${HOMEBREW_REPOSITORY}/Library/Taps"/*/*/{Formula/,HomebrewFormula/,}"${formula}.rb"
-    )"
-  fi
-  [[ -z "${formula_path}" ]] && return 1
-
-  echo "${HOMEBREW_PREFIX}/opt/${formula}"
-  return 0
-}
diff --git a/Library/Homebrew/readall.rb b/Library/Homebrew/readall.rb
index 47d493d8489e3..8966214a5cf0c 100644
--- a/Library/Homebrew/readall.rb
+++ b/Library/Homebrew/readall.rb
@@ -1,102 +1,140 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 require "formula"
 require "cask/cask_loader"
+require "system_command"
 
 # Helper module for validating syntax in taps.
-#
-# @api private
 module Readall
-  class << self
-    def valid_ruby_syntax?(ruby_files)
-      failed = T.let(false, T::Boolean)
-      ruby_files.each do |ruby_file|
-        # As a side effect, print syntax errors/warnings to `$stderr`.
-        failed = true if syntax_errors_or_warnings?(ruby_file)
-      end
-      !failed
+  extend Cachable
+  extend SystemCommand::Mixin
+
+  # TODO: remove this once the `MacOS` module is undefined on Linux
+  MACOS_MODULE_REGEX = /\b(MacOS|OS::Mac)(\.|::)\b/
+  private_constant :MACOS_MODULE_REGEX
+
+  private_class_method :cache
+
+  sig { params(ruby_files: T::Array[Pathname]).returns(T::Boolean) }
+  def self.valid_ruby_syntax?(ruby_files)
+    failed = T.let(false, T::Boolean)
+    ruby_files.each do |ruby_file|
+      # As a side effect, print syntax errors/warnings to `$stderr`.
+      failed = true if syntax_errors_or_warnings?(ruby_file)
     end
+    !failed
+  end
 
-    def valid_aliases?(alias_dir, formula_dir)
-      return true unless alias_dir.directory?
-
-      failed = T.let(false, T::Boolean)
-      alias_dir.each_child do |f|
-        if !f.symlink?
-          onoe "Non-symlink alias: #{f}"
-          failed = true
-        elsif !f.file?
-          onoe "Non-file alias: #{f}"
-          failed = true
-        end
+  sig { params(alias_dir: Pathname, formula_dir: Pathname).returns(T::Boolean) }
+  def self.valid_aliases?(alias_dir, formula_dir)
+    return true unless alias_dir.directory?
 
-        if (formula_dir/"#{f.basename}.rb").exist?
-          onoe "Formula duplicating alias: #{f}"
-          failed = true
-        end
+    failed = T.let(false, T::Boolean)
+    alias_dir.each_child do |f|
+      if !f.symlink?
+        onoe "Non-symlink alias: #{f}"
+        failed = true
+      elsif !f.file?
+        onoe "Non-file alias: #{f}"
+        failed = true
       end
-      !failed
-    end
 
-    def valid_formulae?(formulae)
-      success = T.let(true, T::Boolean)
-      formulae.each do |file|
-        Formulary.factory(file)
-      rescue Interrupt
-        raise
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        onoe "Invalid formula: #{file}"
-        $stderr.puts e
-        success = false
+      if formula_dir.glob("**/#{f.basename}.rb").any?(&:exist?)
+        onoe "Formula duplicating alias: #{f}"
+        failed = true
       end
-      success
     end
+    !failed
+  end
+
+  sig { params(tap: Tap, bottle_tag: T.nilable(Utils::Bottles::Tag)).returns(T::Boolean) }
+  def self.valid_formulae?(tap, bottle_tag: nil)
+    cache[:valid_formulae] ||= {}
+
+    success = T.let(true, T::Boolean)
+    tap.formula_files.each do |file|
+      valid = cache[:valid_formulae][file]
+      next if valid == true || valid&.include?(bottle_tag)
 
-    def valid_casks?(casks)
-      success = T.let(true, T::Boolean)
-      casks.each do |file|
-        Cask::CaskLoader.load(file)
-      rescue Interrupt
-        raise
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        onoe "Invalid cask: #{file}"
-        $stderr.puts e
-        success = false
+      formula_name = file.basename(".rb").to_s
+      formula_contents = file.read.force_encoding("UTF-8")
+
+      readall_namespace = "ReadallNamespace"
+      readall_formula_class = Formulary.load_formula(formula_name, file, formula_contents, readall_namespace,
+                                                     flags: [], ignore_errors: false)
+      readall_formula = readall_formula_class.new(formula_name, file, :stable, tap:)
+      readall_formula.to_hash
+      # TODO: Remove check for MACOS_MODULE_REGEX once the `MacOS` module is undefined on Linux
+      cache[:valid_formulae][file] = if readall_formula.on_system_blocks_exist? ||
+                                        formula_contents.match?(MACOS_MODULE_REGEX)
+        [bottle_tag, *cache[:valid_formulae][file]]
+      else
+        true
       end
-      success
+    rescue Interrupt
+      raise
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      onoe "Invalid formula (#{bottle_tag}): #{file}"
+      $stderr.puts e
+      success = false
     end
+    success
+  end
+
+  sig { params(_tap: Tap, os_name: T.nilable(Symbol), arch: T.nilable(Symbol)).returns(T::Boolean) }
+  def self.valid_casks?(_tap, os_name: nil, arch: nil)
+    true
+  end
+
+  sig {
+    params(
+      tap: Tap, aliases: T::Boolean, no_simulate: T::Boolean, os_arch_combinations: T::Array[T::Array[String]],
+    ).returns(T::Boolean)
+  }
+  def self.valid_tap?(tap, aliases: false, no_simulate: false,
+                      os_arch_combinations: OnSystem::ALL_OS_ARCH_COMBINATIONS)
+    success = true
 
-    def valid_tap?(tap, options = {})
-      success = true
-      if options[:aliases]
-        valid_aliases = valid_aliases?(tap.alias_dir, tap.formula_dir)
-        success = false unless valid_aliases
+    if aliases
+      valid_aliases = valid_aliases?(tap.alias_dir, tap.formula_dir)
+      success = false unless valid_aliases
+    end
+
+    if no_simulate
+      success = false unless valid_formulae?(tap)
+      success = false unless valid_casks?(tap)
+    else
+      os_arch_combinations.each do |os, arch|
+        bottle_tag = Utils::Bottles::Tag.new(system: os, arch:)
+        next unless bottle_tag.valid_combination?
+
+        Homebrew::SimulateSystem.with(os:, arch:) do
+          success = false unless valid_formulae?(tap, bottle_tag:)
+          success = false unless valid_casks?(tap, os_name: os, arch:)
+        end
       end
-      valid_formulae = valid_formulae?(tap.formula_files)
-      valid_casks = valid_casks?(tap.cask_files)
-      success = false if !valid_formulae || !valid_casks
-      success
     end
 
-    private
+    success
+  end
 
-    def syntax_errors_or_warnings?(rb)
-      # Retrieve messages about syntax errors/warnings printed to `$stderr`.
-      _, err, status = system_command(RUBY_PATH, args: ["-c", "-w", rb], print_stderr: false)
+  sig { params(filename: Pathname).returns(T::Boolean) }
+  private_class_method def self.syntax_errors_or_warnings?(filename)
+    # Retrieve messages about syntax errors/warnings printed to `$stderr`.
+    _, err, status = system_command(RUBY_PATH, args: ["-c", "-w", filename], print_stderr: false)
 
-      # Ignore unnecessary warning about named capture conflicts.
-      # See https://bugs.ruby-lang.org/issues/12359.
-      messages = err.lines
-                    .grep_v(/named capture conflicts a local variable/)
-                    .join
+    # Ignore unnecessary warning about named capture conflicts.
+    # See https://bugs.ruby-lang.org/issues/12359.
+    messages = err.lines
+                  .grep_v(/named capture conflicts a local variable/)
+                  .join
 
-      $stderr.print messages
+    $stderr.print messages
 
-      # Only syntax errors result in a non-zero status code. To detect syntax
-      # warnings we also need to inspect the output to `$stderr`.
-      !status.success? || !messages.chomp.empty?
-    end
+    # Only syntax errors result in a non-zero status code. To detect syntax
+    # warnings we also need to inspect the output to `$stderr`.
+    !status.success? || !messages.chomp.empty?
   end
 end
 
diff --git a/Library/Homebrew/reinstall.rb b/Library/Homebrew/reinstall.rb
index 2c9c0ee430988..6e5ba2613144e 100644
--- a/Library/Homebrew/reinstall.rb
+++ b/Library/Homebrew/reinstall.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "formula_installer"
@@ -6,101 +6,106 @@
 require "messages"
 
 module Homebrew
-  module_function
-
-  def reinstall_formula(
-    formula,
-    flags:,
-    installed_on_request: false,
-    force_bottle: false,
-    build_from_source_formulae: [],
-    interactive: false,
-    keep_tmp: false,
-    force: false,
-    debug: false,
-    quiet: false,
-    verbose: false,
-    git: false
-  )
-    if formula.opt_prefix.directory?
-      keg = Keg.new(formula.opt_prefix.resolved_path)
-      tab = Tab.for_keg(keg)
-      keg_had_linked_opt = true
-      keg_was_linked = keg.linked?
-      backup keg
-    end
-
-    build_options = BuildOptions.new(Options.create(flags), formula.options)
-    options = build_options.used_options
-    options |= formula.build.used_options
-    options &= formula.options
-
-    fi = FormulaInstaller.new(
+  module Reinstall
+    def self.reinstall_formula(
       formula,
-      **{
-        options:                    options,
-        link_keg:                   keg_had_linked_opt ? keg_was_linked : nil,
-        installed_as_dependency:    tab&.installed_as_dependency,
-        installed_on_request:       installed_on_request || tab&.installed_on_request,
-        build_bottle:               tab&.built_bottle?,
-        force_bottle:               force_bottle,
-        build_from_source_formulae: build_from_source_formulae,
-        git:                        git,
-        interactive:                interactive,
-        keep_tmp:                   keep_tmp,
-        force:                      force,
-        debug:                      debug,
-        quiet:                      quiet,
-        verbose:                    verbose,
-      }.compact,
+      flags:,
+      installed_on_request: false,
+      force_bottle: false,
+      build_from_source_formulae: [],
+      interactive: false,
+      keep_tmp: false,
+      debug_symbols: false,
+      force: false,
+      debug: false,
+      quiet: false,
+      verbose: false,
+      git: false
     )
-    fi.prelude
-    fi.fetch
+      if formula.opt_prefix.directory?
+        keg = Keg.new(formula.opt_prefix.resolved_path)
+        tab = keg.tab
+        keg_had_linked_opt = true
+        keg_was_linked = keg.linked?
+        backup keg
+      end
+
+      build_options = BuildOptions.new(Options.create(flags), formula.options)
+      options = build_options.used_options
+      options |= formula.build.used_options
+      options &= formula.options
+
+      fi = FormulaInstaller.new(
+        formula,
+        **{
+          options:,
+          link_keg:                   keg_had_linked_opt ? keg_was_linked : nil,
+          installed_as_dependency:    tab&.installed_as_dependency,
+          installed_on_request:       installed_on_request || tab&.installed_on_request,
+          build_bottle:               tab&.built_bottle?,
+          force_bottle:,
+          build_from_source_formulae:,
+          git:,
+          interactive:,
+          keep_tmp:,
+          debug_symbols:,
+          force:,
+          debug:,
+          quiet:,
+          verbose:,
+        }.compact,
+      )
+      fi.prelude
+      fi.fetch
 
-    oh1 "Reinstalling #{Formatter.identifier(formula.full_name)} #{options.to_a.join " "}"
+      oh1 "Reinstalling #{Formatter.identifier(formula.full_name)} #{options.to_a.join " "}"
 
-    fi.install
-    fi.finish
-  rescue FormulaInstallationAlreadyAttemptedError
-    nil
-  rescue Exception # rubocop:disable Lint/RescueException
-    ignore_interrupts { restore_backup(keg, keg_was_linked, verbose: verbose) }
-    raise
-  else
-    begin
-      backup_path(keg).rmtree if backup_path(keg).exist?
-    rescue Errno::EACCES, Errno::ENOTEMPTY
-      odie <<~EOS
-        Could not remove #{backup_path(keg).parent.basename} backup keg! Do so manually:
-          sudo rm -rf #{backup_path(keg)}
-      EOS
+      fi.install
+      fi.finish
+    rescue FormulaInstallationAlreadyAttemptedError
+      nil
+    rescue Exception # rubocop:disable Lint/RescueException
+      ignore_interrupts { restore_backup(keg, keg_was_linked, verbose:) }
+      raise
+    else
+      begin
+        FileUtils.rm_r(backup_path(keg)) if backup_path(keg).exist?
+      rescue Errno::EACCES, Errno::ENOTEMPTY
+        odie <<~EOS
+          Could not remove #{backup_path(keg).parent.basename} backup keg! Do so manually:
+            sudo rm -rf #{backup_path(keg)}
+        EOS
+      end
     end
-  end
 
-  def backup(keg)
-    keg.unlink
-    begin
-      keg.rename backup_path(keg)
-    rescue Errno::EACCES, Errno::ENOTEMPTY
-      odie <<~EOS
-        Could not rename #{keg.name} keg! Check/fix its permissions:
-          sudo chown -R $(whoami) #{keg}
-      EOS
+    def self.backup(keg)
+      keg.unlink
+      begin
+        keg.rename backup_path(keg)
+      rescue Errno::EACCES, Errno::ENOTEMPTY
+        odie <<~EOS
+          Could not rename #{keg.name} keg! Check/fix its permissions:
+            sudo chown -R #{ENV.fetch("USER", "$(whoami)")} #{keg}
+        EOS
+      end
     end
-  end
+    private_class_method :backup
 
-  def restore_backup(keg, keg_was_linked, verbose:)
-    path = backup_path(keg)
+    def self.restore_backup(keg, keg_was_linked, verbose:)
+      path = backup_path(keg)
 
-    return unless path.directory?
+      return unless path.directory?
 
-    Pathname.new(keg).rmtree if keg.exist?
+      FileUtils.rm_r(Pathname.new(keg)) if keg.exist?
 
-    path.rename keg
-    keg.link(verbose: verbose) if keg_was_linked
-  end
+      path.rename keg
+      keg.link(verbose:) if keg_was_linked
+    end
+    private_class_method :restore_backup
 
-  def backup_path(path)
-    Pathname.new "#{path}.reinstall"
+    def self.backup_path(path)
+      Pathname.new "#{path}.reinstall"
+    end
+    private_class_method :backup_path
   end
 end
diff --git a/Library/Homebrew/requirement.rb b/Library/Homebrew/requirement.rb
index de890cc9e0c4c..9edd6a9a2306c 100644
--- a/Library/Homebrew/requirement.rb
+++ b/Library/Homebrew/requirement.rb
@@ -1,6 +1,7 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "attrable"
 require "dependable"
 require "dependency"
 require "dependencies"
@@ -9,17 +10,17 @@
 # A base class for non-formula requirements needed by formulae.
 # A fatal requirement is one that will fail the build if it is not present.
 # By default, requirements are non-fatal.
-#
-# @api private
 class Requirement
-  extend T::Sig
-
   include Dependable
   extend Cachable
 
-  attr_reader :tags, :name, :cask, :download
+  attr_reader :name, :cask, :download
 
   def initialize(tags = [])
+    # Only allow instances of subclasses. This base class enforces no constraints on its own.
+    # Individual subclasses use the `satisfy` DSL to define those constraints.
+    raise "Do not call `Requirement.new' directly without a subclass." unless self.class < Requirement
+
     @cask = self.class.cask
     @download = self.class.download
     tags.each do |tag|
@@ -58,14 +59,21 @@ def message
     s
   end
 
-  # Overriding {#satisfied?} is unsupported.
-  # Pass a block or boolean to the satisfy DSL method instead.
+  # Pass a block or boolean to the satisfy DSL method instead of overriding.
+  sig(:final) {
+    params(
+      env:          T.nilable(String),
+      cc:           T.nilable(String),
+      build_bottle: T::Boolean,
+      bottle_arch:  T.nilable(String),
+    ).returns(T::Boolean)
+  }
   def satisfied?(env: nil, cc: nil, build_bottle: false, bottle_arch: nil)
     satisfy = self.class.satisfy
     return true unless satisfy
 
     @satisfied_result =
-      satisfy.yielder(env: env, cc: cc, build_bottle: build_bottle, bottle_arch: bottle_arch) do |p|
+      satisfy.yielder(env:, cc:, build_bottle:, bottle_arch:) do |p|
         instance_eval(&p)
       end
     return false unless @satisfied_result
@@ -73,8 +81,8 @@ def satisfied?(env: nil, cc: nil, build_bottle: false, bottle_arch: nil)
     true
   end
 
-  # Overriding {#fatal?} is unsupported.
-  # Pass a boolean to the fatal DSL method instead.
+  # Pass a boolean to the fatal DSL method instead of overriding.
+  sig(:final) { returns(T::Boolean) }
   def fatal?
     self.class.fatal || false
   end
@@ -89,10 +97,17 @@ def satisfied_result_parent
     parent
   end
 
-  # Overriding {#modify_build_environment} is unsupported.
-  # Pass a block to the env DSL method instead.
+  # Pass a block to the env DSL method instead of overriding.
+  sig(:final) {
+    params(
+      env:          T.nilable(String),
+      cc:           T.nilable(String),
+      build_bottle: T::Boolean,
+      bottle_arch:  T.nilable(String),
+    ).void
+  }
   def modify_build_environment(env: nil, cc: nil, build_bottle: false, bottle_arch: nil)
-    satisfied?(env: env, cc: cc, build_bottle: build_bottle, bottle_arch: bottle_arch)
+    satisfied?(env:, cc:, build_bottle:, bottle_arch:)
     instance_eval(&env_proc) if env_proc
 
     # XXX If the satisfy block returns a Pathname, then make sure that it
@@ -122,7 +137,7 @@ def ==(other)
   alias eql? ==
 
   def hash
-    [name, tags].hash
+    [self.class, name, tags].hash
   end
 
   sig { returns(String) }
@@ -141,9 +156,9 @@ def mktemp(&block)
   private
 
   def infer_name
-    klass = self.class.name || self.class.to_s
-    klass = klass.sub(/(Dependency|Requirement)$/, "")
-                 .sub(/^(\w+::)*/, "")
+    klass = self.class.name
+    klass = klass&.sub(/(Dependency|Requirement)$/, "")
+                 &.sub(/^(\w+::)*/, "")
     return klass.downcase if klass.present?
 
     return @cask if @cask.present?
@@ -160,9 +175,8 @@ def which_all(cmd)
   end
 
   class << self
-    extend T::Sig
-
     include BuildEnvironment::DSL
+    extend Attrable
 
     attr_reader :env_proc, :build
 
@@ -203,7 +217,7 @@ def yielder(env: nil, cc: nil, build_bottle: false, bottle_arch: nil)
       elsif @options[:build_env]
         require "extend/ENV"
         ENV.with_build_environment(
-          env: env, cc: cc, build_bottle: build_bottle, bottle_arch: bottle_arch,
+          env:, cc:, build_bottle:, bottle_arch:,
         ) do
           yield @proc
         end
@@ -219,7 +233,7 @@ class << self
     # `[dependent, req]` pairs to allow callers to apply arbitrary filters to
     # the list.
     # The default filter, which is applied when a block is not given, omits
-    # optionals and recommendeds based on what the dependent has asked for.
+    # optionals and recommends based on what the dependent has asked for.
     def expand(dependent, cache_key: nil, &block)
       if cache_key.present?
         cache[cache_key] ||= {}
@@ -239,7 +253,13 @@ def expand(dependent, cache_key: nil, &block)
         end
       end
 
-      cache[cache_key][cache_id dependent] = reqs.dup if cache_key.present?
+      if cache_key.present?
+        # Even though we setup the cache above
+        # 'dependent.recursive_dependencies.map(&:to_formula)'
+        # is invalidating the singleton cache
+        cache[cache_key] ||= {}
+        cache[cache_key][cache_id dependent] = reqs.dup
+      end
       reqs
     end
 
diff --git a/Library/Homebrew/requirements/arch_requirement.rb b/Library/Homebrew/requirements/arch_requirement.rb
index 8c65b44fa6146..65940a994619a 100644
--- a/Library/Homebrew/requirements/arch_requirement.rb
+++ b/Library/Homebrew/requirements/arch_requirement.rb
@@ -1,21 +1,17 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "requirement"
 
 # A requirement on a specific architecture.
-#
-# @api private
 class ArchRequirement < Requirement
-  extend T::Sig
-
   fatal true
 
   attr_reader :arch
 
   def initialize(tags)
     @arch = tags.shift
-    super(tags)
+    super
   end
 
   satisfy(build_env: false) do
@@ -31,6 +27,7 @@ def message
     "The #{@arch} architecture is required for this software."
   end
 
+  sig { returns(String) }
   def inspect
     "#<#{self.class.name}: arch=#{@arch.to_s.inspect} #{tags.inspect}>"
   end
diff --git a/Library/Homebrew/requirements/codesign_requirement.rb b/Library/Homebrew/requirements/codesign_requirement.rb
index 06caebda7128f..d486fec2b8af7 100644
--- a/Library/Homebrew/requirements/codesign_requirement.rb
+++ b/Library/Homebrew/requirements/codesign_requirement.rb
@@ -1,26 +1,23 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 # A requirement on a code-signing identity.
-#
-# @api private
 class CodesignRequirement < Requirement
-  extend T::Sig
-
   fatal true
 
   def initialize(tags)
     options = tags.shift
-    raise ArgumentError("CodesignRequirement requires an options Hash!") unless options.is_a?(Hash)
-    raise ArgumentError("CodesignRequirement requires an identity key!") unless options.key?(:identity)
+    raise ArgumentError, "CodesignRequirement requires an options Hash!" unless options.is_a?(Hash)
+    raise ArgumentError, "CodesignRequirement requires an identity key!" unless options.key?(:identity)
 
     @identity = options.fetch(:identity)
     @with = options.fetch(:with, "code signing")
     @url = options.fetch(:url, nil)
-    super(tags)
+    super
   end
 
   satisfy(build_env: false) do
+    T.bind(self, CodesignRequirement)
     mktemp do
       FileUtils.cp "/usr/bin/false", "codesign_check"
       quiet_system "/usr/bin/codesign", "-f", "-s", @identity,
diff --git a/Library/Homebrew/requirements/linux_requirement.rb b/Library/Homebrew/requirements/linux_requirement.rb
index 36b70585ac74c..e0aa5def4900a 100644
--- a/Library/Homebrew/requirements/linux_requirement.rb
+++ b/Library/Homebrew/requirements/linux_requirement.rb
@@ -2,11 +2,7 @@
 # frozen_string_literal: true
 
 # A requirement on Linux.
-#
-# @api private
 class LinuxRequirement < Requirement
-  extend T::Sig
-
   fatal true
 
   satisfy(build_env: false) { OS.linux? }
diff --git a/Library/Homebrew/requirements/macos_requirement.rb b/Library/Homebrew/requirements/macos_requirement.rb
index f900a626d0631..3189259b8a41e 100644
--- a/Library/Homebrew/requirements/macos_requirement.rb
+++ b/Library/Homebrew/requirements/macos_requirement.rb
@@ -1,37 +1,35 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "requirement"
 
 # A requirement on macOS.
-#
-# @api private
 class MacOSRequirement < Requirement
-  extend T::Sig
-
   fatal true
 
   attr_reader :comparator, :version
 
   # TODO: when Yosemite is removed here, keep these around as empty arrays so we
   # can keep the deprecation/disabling code the same.
-  DISABLED_MACOS_VERSIONS = [].freeze
-  DEPRECATED_MACOS_VERSIONS = [
+  DISABLED_MACOS_VERSIONS = [
     :yosemite,
   ].freeze
+  DEPRECATED_MACOS_VERSIONS = [].freeze
 
   def initialize(tags = [], comparator: ">=")
     @version = begin
       if comparator == "==" && tags.first.respond_to?(:map)
-        tags.first.map { |s| MacOS::Version.from_symbol(s) }
+        tags.first.map { |s| MacOSVersion.from_symbol(s) }
       else
-        MacOS::Version.from_symbol(tags.first) unless tags.empty?
+        MacOSVersion.from_symbol(tags.first) unless tags.empty?
       end
-    rescue MacOSVersionError => e
+    rescue MacOSVersion::Error => e
       if DISABLED_MACOS_VERSIONS.include?(e.version)
-        odisabled "depends_on :macos => :#{e.version}"
+        # This odisabled should stick around indefinitely.
+        odisabled "`depends_on macos: :#{e.version}`"
       elsif DEPRECATED_MACOS_VERSIONS.include?(e.version)
-        odeprecated "depends_on :macos => :#{e.version}"
+        # This odeprecated should stick around indefinitely.
+        odeprecated "`depends_on macos: :#{e.version}`"
       else
         raise
       end
@@ -43,7 +41,7 @@ def initialize(tags = [], comparator: ">=")
       end
 
       # Otherwise fallback to the oldest allowed if comparator is >=.
-      MacOS::Version.new(MacOS::Version::OLDEST_ALLOWED) if comparator == ">="
+      MacOSVersion.new(HOMEBREW_MACOS_OLDEST_ALLOWED) if comparator == ">="
     end
 
     @comparator = comparator
@@ -51,23 +49,44 @@ def initialize(tags = [], comparator: ">=")
   end
 
   def version_specified?
-    OS.mac? && @version
+    @version.present?
   end
 
   satisfy(build_env: false) do
-    next Array(@version).any? { |v| MacOS.version.public_send(@comparator, v) } if version_specified?
+    T.bind(self, MacOSRequirement)
+    next Array(@version).any? { |v| OS::Mac.version.compare(@comparator, v) } if OS.mac? && version_specified?
     next true if OS.mac?
     next true if @version
 
     false
   end
 
+  def minimum_version
+    return MacOSVersion.new(HOMEBREW_MACOS_OLDEST_ALLOWED) if @comparator == "<=" || !version_specified?
+    return @version.min if @version.respond_to?(:to_ary)
+
+    @version
+  end
+
+  def allows?(other)
+    return true unless version_specified?
+
+    case @comparator
+    when ">=" then other >= @version
+    when "<=" then other <= @version
+    else
+      return @version.include?(other) if @version.respond_to?(:to_ary)
+
+      @version == other
+    end
+  end
+
   def message(type: :formula)
     return "macOS is required for this software." unless version_specified?
 
     case @comparator
     when ">="
-      "macOS #{@version.pretty_name} or newer is required for this software."
+      "This software does not run on macOS versions older than #{@version.pretty_name}."
     when "<="
       case type
       when :formula
@@ -81,13 +100,22 @@ def message(type: :formula)
     else
       if @version.respond_to?(:to_ary)
         *versions, last = @version.map(&:pretty_name)
-        return "macOS #{versions.join(", ")} or #{last} is required for this software."
+        return "This software does not run on macOS versions other than #{versions.join(", ")} and #{last}."
       end
 
-      "macOS #{@version.pretty_name} is required for this software."
+      "This software does not run on macOS versions other than #{@version.pretty_name}."
     end
   end
 
+  def ==(other)
+    super && comparator == other.comparator && version == other.version
+  end
+  alias eql? ==
+
+  def hash
+    [super, comparator, version].hash
+  end
+
   sig { returns(String) }
   def inspect
     "#<#{self.class.name}: version#{@comparator}#{@version.to_s.inspect} #{tags.inspect}>"
@@ -97,19 +125,19 @@ def inspect
   def display_s
     if version_specified?
       if @version.respond_to?(:to_ary)
-        "macOS #{@comparator} #{version.join(" / ")}"
+        "macOS #{@comparator} #{version.join(" / ")} (or Linux)"
       else
-        "macOS #{@comparator} #{@version}"
+        "macOS #{@comparator} #{@version} (or Linux)"
       end
     else
       "macOS"
     end
   end
 
-  def to_json(*args)
+  def to_json(options)
     comp = @comparator.to_s
-    return { comp => @version.map(&:to_s) }.to_json(*args) if @version.is_a?(Array)
+    return { comp => @version.map(&:to_s) }.to_json(options) if @version.is_a?(Array)
 
-    { comp => [@version.to_s] }.to_json(*args)
+    { comp => [@version.to_s] }.to_json(options)
   end
 end
diff --git a/Library/Homebrew/requirements/xcode_requirement.rb b/Library/Homebrew/requirements/xcode_requirement.rb
index ccc8412b847ab..0d74f0e945520 100644
--- a/Library/Homebrew/requirements/xcode_requirement.rb
+++ b/Library/Homebrew/requirements/xcode_requirement.rb
@@ -1,23 +1,22 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "requirement"
 
 # A requirement on Xcode.
-#
-# @api private
 class XcodeRequirement < Requirement
-  extend T::Sig
-
   fatal true
 
   attr_reader :version
 
-  satisfy(build_env: false) { xcode_installed_version }
+  satisfy(build_env: false) do
+    T.bind(self, XcodeRequirement)
+    xcode_installed_version
+  end
 
   def initialize(tags = [])
     @version = tags.shift if tags.first.to_s.match?(/(\d\.)+\d/)
-    super(tags)
+    super
   end
 
   sig { returns(T::Boolean) }
@@ -55,9 +54,9 @@ def inspect
   end
 
   def display_s
-    return name.capitalize unless @version
+    return "#{name.capitalize} (on macOS)" unless @version
 
-    "#{name.capitalize} >= #{@version}"
+    "#{name.capitalize} >= #{@version} (on macOS)"
   end
 end
 
diff --git a/Library/Homebrew/resource.rb b/Library/Homebrew/resource.rb
index a8e5f712c339c..c8c3058cc0d11 100644
--- a/Library/Homebrew/resource.rb
+++ b/Library/Homebrew/resource.rb
@@ -1,9 +1,7 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "download_strategy"
-require "checksum"
-require "version"
+require "downloadable"
 require "mktemp"
 require "livecheck"
 require "extend/on_system"
@@ -11,37 +9,45 @@
 # Resource is the fundamental representation of an external resource. The
 # primary formula download, along with other declared resources, are instances
 # of this class.
-#
-# @api private
 class Resource
-  extend T::Sig
-
-  include Context
+  include Downloadable
   include FileUtils
   include OnSystem::MacOSAndLinux
 
-  attr_reader :mirrors, :specs, :using, :source_modified_time, :patches, :owner
-  attr_writer :version
-  attr_accessor :download_strategy, :checksum
+  attr_reader :source_modified_time, :patches, :owner
+  attr_writer :checksum
+  attr_accessor :download_strategy
 
   # Formula name must be set after the DSL, as we have no access to the
   # formula name before initialization of the formula.
   attr_accessor :name
 
+  sig { params(name: T.nilable(String), block: T.nilable(T.proc.bind(Resource).void)).void }
   def initialize(name = nil, &block)
+    super()
+    # Ensure this is synced with `initialize_dup` and `freeze` (excluding simple objects like integers and booleans)
     @name = name
-    @url = nil
-    @version = nil
-    @mirrors = []
-    @specs = {}
-    @checksum = nil
-    @using = nil
     @patches = []
-    @livecheck = nil
+    @livecheck = Livecheck.new(self)
     @livecheckable = false
+    @insecure = false
     instance_eval(&block) if block
   end
 
+  def initialize_dup(other)
+    super
+    @name = @name.dup
+    @patches = @patches.dup
+    @livecheck = @livecheck.dup
+  end
+
+  def freeze
+    @name.freeze
+    @patches.freeze
+    @livecheck.freeze
+    super
+  end
+
   def owner=(owner)
     @owner = owner
     patches.each { |p| p.owner = owner }
@@ -49,12 +55,16 @@ def owner=(owner)
     return if !owner.respond_to?(:full_name) || owner.full_name != "ca-certificates"
     return if Homebrew::EnvConfig.no_insecure_redirect?
 
-    @specs[:insecure] = !specs[:bottle] && !DevelopmentTools.ca_file_handles_most_https_certificates?
-  end
+    @insecure = !specs[:bottle] && (DevelopmentTools.ca_file_substitution_required? ||
+                                    DevelopmentTools.curl_substitution_required?)
+    return if @url.nil?
 
-  def downloader
-    @downloader ||= download_strategy.new(url, download_name, version,
-                                          mirrors: mirrors.dup, **specs)
+    specs = if @insecure
+      @url.specs.merge({ insecure: true })
+    else
+      @url.specs.except(:insecure)
+    end
+    @url = URL.new(@url.to_s, specs)
   end
 
   # Removes /s from resource names; this allows Go package names
@@ -71,32 +81,20 @@ def download_name
     "#{owner.name}--#{escaped_name}"
   end
 
-  def downloaded?
-    cached_download.exist?
-  end
-
-  def cached_download
-    downloader.cached_location
-  end
-
-  def clear_cache
-    downloader.clear_cache
-  end
-
   # Verifies download and unpacks it.
   # The block may call `|resource, staging| staging.retain!` to retain the staging
   # directory. Subclasses that override stage should implement the tmp
   # dir using {Mktemp} so that works with all subtypes.
   #
   # @api public
-  def stage(target = nil, &block)
-    raise ArgumentError, "target directory or block is required" if !target && block.blank?
+  def stage(target = nil, debug_symbols: false, &block)
+    raise ArgumentError, "Target directory or block is required" if !target && block.blank?
 
     prepare_patches
     fetch_patches(skip_downloaded: true)
     fetch unless downloaded?
 
-    unpack(target, &block)
+    unpack(target, debug_symbols:, &block)
   end
 
   def prepare_patches
@@ -120,9 +118,9 @@ def apply_patches
   # If block is given, yield to that block with `|stage|`, where stage
   # is a {ResourceStageContext}.
   # A target or a block must be given, but not both.
-  def unpack(target = nil)
+  def unpack(target = nil, debug_symbols: false)
     current_working_directory = Pathname.pwd
-    mktemp(download_name) do |staging|
+    stage_resource(download_name, debug_symbols:) do |staging|
       downloader.stage do
         @source_modified_time = downloader.source_modified_time
         apply_patches
@@ -143,49 +141,37 @@ def files(*files)
     Partial.new(self, files)
   end
 
-  def fetch(verify_download_integrity: true)
-    HOMEBREW_CACHE.mkpath
-
+  sig {
+    override
+      .params(
+        verify_download_integrity: T::Boolean,
+        timeout:                   T.nilable(T.any(Integer, Float)),
+        quiet:                     T::Boolean,
+      ).returns(Pathname)
+  }
+  def fetch(verify_download_integrity: true, timeout: nil, quiet: false)
     fetch_patches
 
-    begin
-      downloader.fetch
-    rescue ErrorDuringExecution, CurlDownloadStrategyError => e
-      raise DownloadError.new(self, e)
-    end
-
-    download = cached_download
-    verify_download_integrity(download) if verify_download_integrity
-    download
-  end
-
-  def verify_download_integrity(fn)
-    if fn.file?
-      ohai "Verifying checksum for '#{fn.basename}'" if verbose?
-      fn.verify_checksum(checksum)
-    end
-  rescue ChecksumMissingError
-    opoo <<~EOS
-      Cannot verify integrity of '#{fn.basename}'.
-      No checksum was provided for this resource.
-      For your reference, the checksum is:
-        sha256 "#{fn.sha256}"
-    EOS
+    super
   end
 
-  # @!attribute [w] livecheck
   # {Livecheck} can be used to check for newer versions of the software.
   # This method evaluates the DSL specified in the livecheck block of the
   # {Resource} (if it exists) and sets the instance variables of a {Livecheck}
   # object accordingly. This is used by `brew livecheck` to check for newer
   # versions of the software.
   #
-  # <pre>livecheck do
+  # ### Example
+  #
+  # ```ruby
+  # livecheck do
   #   url "https://example.com/foo/releases"
   #   regex /foo-(\d+(?:\.\d+)+)\.tar/
-  # end</pre>
+  # end
+  # ```
+  #
+  # @!attribute [w] livecheck
   def livecheck(&block)
-    @livecheck ||= Livecheck.new(self) if block
     return @livecheck unless block
 
     @livecheckable = true
@@ -193,8 +179,8 @@ def livecheck(&block)
   end
 
   # Whether a livecheck specification is defined or not.
-  # It returns true when a livecheck block is present in the {Resource} and
-  # false otherwise, and is used by livecheck.
+  # It returns true when a `livecheck` block is present in the {Resource} and
+  # false otherwise and is used by livecheck.
   def livecheckable?
     @livecheckable == true
   end
@@ -204,23 +190,28 @@ def sha256(val)
   end
 
   def url(val = nil, **specs)
-    return @url if val.nil?
+    return @url&.to_s if val.nil?
 
     specs = specs.dup
     # Don't allow this to be set.
     specs.delete(:insecure)
 
-    @url = val
-    @using = specs.delete(:using)
-    @download_strategy = DownloadStrategyDetector.detect(url, using)
-    @specs.merge!(specs)
+    specs[:insecure] = true if @insecure
+
+    @url = URL.new(val, specs)
     @downloader = nil
+    @download_strategy = @url.download_strategy
   end
 
+  sig { override.params(val: T.nilable(T.any(String, Version))).returns(T.nilable(Version)) }
   def version(val = nil)
-    @version ||= begin
-      version = detect_version(val)
-      version.null? ? nil : version
+    return super() if val.nil?
+
+    @version = case val
+    when String
+      val.blank? ? Version::NULL : Version.new(val)
+    when Version
+      val
     end
   end
 
@@ -229,27 +220,73 @@ def mirror(val)
   end
 
   def patch(strip = :p1, src = nil, &block)
-    p = Patch.create(strip, src, &block)
+    p = ::Patch.create(strip, src, &block)
     patches << p
   end
 
+  def using
+    @url&.using
+  end
+
+  def specs
+    @url&.specs || {}.freeze
+  end
+
   protected
 
-  def mktemp(prefix, &block)
-    Mktemp.new(prefix).run(&block)
+  def stage_resource(prefix, debug_symbols: false, &block)
+    Mktemp.new(prefix, retain_in_cache: debug_symbols).run(&block)
   end
 
   private
 
-  def detect_version(val)
-    return Version::NULL if val.nil? && url.nil?
+  def determine_url_mirrors
+    extra_urls = []
 
-    case val
-    when nil     then Version.detect(url, **specs)
-    when String  then Version.create(val)
-    when Version then val
-    else
-      raise TypeError, "version '#{val.inspect}' should be a string"
+    # glibc-bootstrap
+    if url.start_with?("https://github.com/Homebrew/glibc-bootstrap/releases/download")
+      if (artifact_domain = Homebrew::EnvConfig.artifact_domain.presence)
+        artifact_url = url.sub("https://github.com", artifact_domain)
+        return [artifact_url] if Homebrew::EnvConfig.artifact_domain_no_fallback?
+
+        extra_urls << artifact_url
+      end
+
+      if Homebrew::EnvConfig.bottle_domain != HOMEBREW_BOTTLE_DEFAULT_DOMAIN
+        tag, filename = url.split("/").last(2)
+        extra_urls << "#{Homebrew::EnvConfig.bottle_domain}/glibc-bootstrap/#{tag}/#{filename}"
+      end
+    end
+
+    # PyPI packages: PEP 503 – Simple Repository API <https://peps.python.org/pep-0503>
+    if (pip_index_url = Homebrew::EnvConfig.pip_index_url.presence)
+      pip_index_base_url = pip_index_url.chomp("/").chomp("/simple")
+      %w[https://files.pythonhosted.org https://pypi.org].each do |base_url|
+        extra_urls << url.sub(base_url, pip_index_base_url) if url.start_with?("#{base_url}/packages")
+      end
+    end
+
+    [*extra_urls, *super].uniq
+  end
+
+  # A local resource that doesn't need to be downloaded.
+  class Local < Resource
+    def initialize(path)
+      super(File.basename(path))
+      @downloader = LocalBottleDownloadStrategy.new(path)
+    end
+  end
+
+  # A resource for a formula.
+  class Formula < Resource
+    sig { override.returns(String) }
+    def name
+      T.must(owner).name
+    end
+
+    sig { override.returns(String) }
+    def download_name
+      name
     end
   end
 
@@ -260,8 +297,77 @@ def stage(target, &block)
     end
   end
 
+  # A resource for a bottle manifest.
+  class BottleManifest < Resource
+    class Error < RuntimeError; end
+
+    attr_reader :bottle
+
+    def initialize(bottle)
+      super("#{bottle.name}_bottle_manifest")
+      @bottle = bottle
+      @manifest_annotations = nil
+    end
+
+    def verify_download_integrity(_filename)
+      # We don't have a checksum, but we can at least try parsing it.
+      tab
+    end
+
+    def tab
+      tab = manifest_annotations["sh.brew.tab"]
+      raise Error, "Couldn't find tab from manifest." if tab.blank?
+
+      begin
+        JSON.parse(tab)
+      rescue JSON::ParserError
+        raise Error, "Couldn't parse tab JSON."
+      end
+    end
+
+    sig { returns(T.nilable(Integer)) }
+    def bottle_size
+      manifest_annotations["sh.brew.bottle.size"]&.to_i
+    end
+
+    sig { returns(T.nilable(Integer)) }
+    def installed_size
+      manifest_annotations["sh.brew.bottle.installed_size"]&.to_i
+    end
+
+    private
+
+    def manifest_annotations
+      return @manifest_annotations unless @manifest_annotations.nil?
+
+      json = begin
+        JSON.parse(cached_download.read)
+      rescue JSON::ParserError
+        raise Error, "The downloaded GitHub Packages manifest was corrupted or modified (it is not valid JSON): " \
+                     "\n#{cached_download}"
+      end
+
+      manifests = json["manifests"]
+      raise Error, "Missing 'manifests' section." if manifests.blank?
+
+      manifests_annotations = manifests.filter_map { |m| m["annotations"] }
+      raise Error, "Missing 'annotations' section." if manifests_annotations.blank?
+
+      bottle_digest = bottle.resource.checksum.hexdigest
+      image_ref = GitHubPackages.version_rebuild(bottle.resource.version, bottle.rebuild, bottle.tag.to_s)
+      manifest_annotations = manifests_annotations.find do |m|
+        next if m["sh.brew.bottle.digest"] != bottle_digest
+
+        m["org.opencontainers.image.ref.name"] == image_ref
+      end
+      raise Error, "Couldn't find manifest matching bottle checksum." if manifest_annotations.blank?
+
+      @manifest_annotations = manifest_annotations
+    end
+  end
+
   # A resource containing a patch.
-  class PatchResource < Resource
+  class Patch < Resource
     attr_reader :patch_files
 
     def initialize(&block)
@@ -287,15 +393,12 @@ def directory(val = nil)
 # The context in which a {Resource#stage} occurs. Supports access to both
 # the {Resource} and associated {Mktemp} in a single block argument. The interface
 # is back-compatible with {Resource} itself as used in that context.
-#
-# @api private
 class ResourceStageContext
-  extend T::Sig
-
   extend Forwardable
 
   # The {Resource} that is being staged.
   attr_reader :resource
+
   # The {Mktemp} in which {#resource} is staged.
   attr_reader :staging
 
diff --git a/Library/Homebrew/resource_auditor.rb b/Library/Homebrew/resource_auditor.rb
index 8155d311c0ae3..ce92f9d9b39e2 100644
--- a/Library/Homebrew/resource_auditor.rb
+++ b/Library/Homebrew/resource_auditor.rb
@@ -1,11 +1,13 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "utils/svn"
+
 module Homebrew
   # Auditor for checking common violations in {Resource}s.
-  #
-  # @api private
   class ResourceAuditor
+    include Utils::Curl
+
     attr_reader :name, :version, :checksum, :url, :mirrors, :using, :specs, :owner, :spec_name, :problems
 
     def initialize(resource, spec_name, options = {})
@@ -44,6 +46,10 @@ def audit
     def audit_version
       if version.nil?
         problem "missing version"
+      elsif owner.is_a?(Formula) && !version.to_s.match?(GitHubPackages::VALID_OCI_TAG_REGEX) &&
+            (owner.core_formula? ||
+            (owner.bottle_defined? && GitHubPackages::URL_REGEX.match?(owner.bottle_specification.root_url)))
+        problem "version #{version} does not match #{GitHubPackages::VALID_OCI_TAG_REGEX.source}"
       elsif !version.detected_from_url?
         version_text = version
         version_url = Version.detect(url, **specs)
@@ -78,14 +84,16 @@ def audit_download_strategy
         end
       end
 
-      return unless url_strategy == DownloadStrategyDetector.detect("", using)
+      return if url_strategy != DownloadStrategyDetector.detect("", using)
 
       problem "Redundant :using value in URL"
     end
 
     def audit_checksum
       return if spec_name == :head
+      # rubocop:disable Style/InvertibleUnlessCondition (non-invertible)
       return unless DownloadStrategyDetector.detect(url, using) <= CurlDownloadStrategy
+      # rubocop:enable Style/InvertibleUnlessCondition
 
       problem "Checksum is missing" if checksum.blank?
     end
@@ -98,6 +106,27 @@ def self.curl_deps
       end
     end
 
+    def audit_resource_name_matches_pypi_package_name_in_url
+      return unless url.match?(%r{^https?://files\.pythonhosted\.org/packages/})
+      return if name == owner.name # Skip the top-level package name as we only care about `resource "foo"` blocks.
+
+      if url.end_with? ".whl"
+        path = URI(url).path
+        return unless path.present?
+
+        pypi_package_name, = File.basename(path).split("-", 2)
+      else
+        url =~ %r{/(?<package_name>[^/]+)-}
+        pypi_package_name = Regexp.last_match(:package_name).to_s
+      end
+
+      T.must(pypi_package_name).gsub!(/[_.]/, "-")
+
+      return if name.casecmp(pypi_package_name).zero?
+
+      problem "resource name should be `#{pypi_package_name}` to match the PyPI package name"
+    end
+
     def audit_urls
       urls = [url] + mirrors
 
@@ -105,7 +134,7 @@ def audit_urls
       # Ideally `ca-certificates` would not be excluded here, but sourcing a HTTP mirror was tricky.
       # Instead, we have logic elsewhere to pass `--insecure` to curl when downloading the certs.
       # TODO: try remove the OS/env conditional
-      if (OS.mac? || Homebrew::EnvConfig.simulate_macos_on_linux?) && spec_name == :stable &&
+      if Homebrew::SimulateSystem.simulating_or_running_on_macos? && spec_name == :stable &&
          owner.name != "ca-certificates" && curl_dep && !urls.find { |u| u.start_with?("http://") }
         problem "should always include at least one HTTP mirror"
       end
@@ -121,14 +150,22 @@ def audit_urls
           raise HomebrewCurlDownloadStrategyError, url if
             strategy <= HomebrewCurlDownloadStrategy && !Formula["curl"].any_version_installed?
 
-          if (http_content_problem = curl_check_http_content(url,
-                                                             "source URL",
-                                                             specs:             specs,
-                                                             use_homebrew_curl: @use_homebrew_curl))
+          if (http_content_problem = curl_check_http_content(
+            url,
+            "source URL",
+            specs:,
+            use_homebrew_curl: @use_homebrew_curl,
+          ))
             problem http_content_problem
           end
         elsif strategy <= GitDownloadStrategy
-          problem "The URL #{url} is not a valid git URL" unless Utils::Git.remote_exists? url
+          attempts = 0
+          remote_exists = T.let(false, T::Boolean)
+          while !remote_exists && attempts < Homebrew::EnvConfig.curl_retries.to_i
+            remote_exists = Utils::Git.remote_exists?(url)
+            attempts += 1
+          end
+          problem "The URL #{url} is not a valid git URL" unless remote_exists
         elsif strategy <= SubversionDownloadStrategy
           next unless DevelopmentTools.subversion_handles_most_https_certificates?
           next unless Utils::Svn.available?
@@ -144,11 +181,11 @@ def audit_head_branch
       return if spec_name != :head
       return unless Utils::Git.remote_exists?(url)
       return if specs[:tag].present?
+      return if specs[:revision].present?
 
       branch = Utils.popen_read("git", "ls-remote", "--symref", url, "HEAD")
-                    .match(%r{ref: refs/heads/(.*?)\s+HEAD})[1]
-
-      return if branch == specs[:branch]
+                    .match(%r{ref: refs/heads/(.*?)\s+HEAD})&.to_a&.second
+      return if branch.blank? || branch == specs[:branch]
 
       problem "Use `branch: \"#{branch}\"` to specify the default branch"
     end
diff --git a/Library/Homebrew/retryable_download.rb b/Library/Homebrew/retryable_download.rb
new file mode 100644
index 0000000000000..0f647b88358d3
--- /dev/null
+++ b/Library/Homebrew/retryable_download.rb
@@ -0,0 +1,96 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module Homebrew
+  class RetryableDownload
+    include Downloadable
+
+    sig { returns(Downloadable) }
+    attr_reader :downloadable
+    private :downloadable
+
+    sig { override.returns(T.nilable(URL)) }
+    def url = downloadable.url
+
+    sig { override.returns(T.nilable(Checksum)) }
+    def checksum = downloadable.checksum
+
+    sig { override.returns(T::Array[String]) }
+    def mirrors = downloadable.mirrors
+
+    sig { params(downloadable: Downloadable, tries: Integer).void }
+    def initialize(downloadable, tries: 3)
+      super()
+
+      @downloadable = downloadable
+      @try = 0
+      @tries = tries
+    end
+
+    sig { override.returns(String) }
+    def name = downloadable.name
+
+    sig { override.returns(String) }
+    def download_type = downloadable.download_type
+
+    sig { override.returns(Pathname) }
+    def cached_download = downloadable.cached_download
+
+    sig { override.void }
+    def clear_cache = downloadable.clear_cache
+
+    sig { override.returns(T.nilable(Version)) }
+    def version = downloadable.version
+
+    sig { override.returns(T.class_of(AbstractDownloadStrategy)) }
+    def download_strategy = downloadable.download_strategy
+
+    sig { override.returns(AbstractDownloadStrategy) }
+    def downloader = downloadable.downloader
+
+    sig {
+      override.params(
+        verify_download_integrity: T::Boolean,
+        timeout:                   T.nilable(T.any(Integer, Float)),
+        quiet:                     T::Boolean,
+      ).returns(Pathname)
+    }
+    def fetch(verify_download_integrity: true, timeout: nil, quiet: false)
+      @try += 1
+
+      already_downloaded = downloadable.downloaded?
+
+      download = downloadable.fetch(verify_download_integrity: false, timeout:, quiet:)
+
+      return download unless download.file?
+
+      unless quiet
+        puts "Downloaded to: #{download}" unless already_downloaded
+        puts "SHA256: #{download.sha256}"
+      end
+
+      downloadable.verify_download_integrity(download) if verify_download_integrity
+
+      download
+    rescue DownloadError, ChecksumMismatchError
+      tries_remaining = @tries - @try
+      raise if tries_remaining.zero?
+
+      wait = 2 ** @try
+      unless quiet
+        what = Utils.pluralize("tr", tries_remaining, plural: "ies", singular: "y")
+        ohai "Retrying download in #{wait}s... (#{tries_remaining} #{what} left)"
+      end
+      sleep wait
+
+      downloadable.clear_cache
+      retry
+    end
+
+    sig { override.params(filename: Pathname).void }
+    def verify_download_integrity(filename) = downloadable.verify_download_integrity(filename)
+
+    sig { override.returns(String) }
+    def download_name = downloadable.download_name
+  end
+end
diff --git a/Library/Homebrew/rubocops/all.rb b/Library/Homebrew/rubocops/all.rb
index 0f0ce7e0e1728..deb66f66a5ff4 100644
--- a/Library/Homebrew/rubocops/all.rb
+++ b/Library/Homebrew/rubocops/all.rb
@@ -1,40 +1,45 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "active_support/core_ext/array/conversions"
-
-require "rubocop-performance"
-require "rubocop-rails"
-require "rubocop-rspec"
-
-require_relative "../warnings"
-Warnings.ignore :parser_syntax do
-  require "rubocop-sorbet"
-end
-
+require_relative "../extend/array"
+require_relative "../extend/blank"
+require_relative "blank"
+require_relative "compact_blank"
+require_relative "extend/mutable_constant_exclude_unfreezable"
 require_relative "io_read"
+require_relative "move_to_extend_os"
+require_relative "negate_include"
+require_relative "no_fileutils_rmrf"
+require_relative "presence"
+require_relative "present"
+require_relative "safe_navigation_with_blank"
+require_relative "shell_command_stub"
 require_relative "shell_commands"
+require_relative "install_bundler_gems"
 
-require_relative "formula_desc"
+# formula audit cops
+require_relative "bottle"
+require_relative "caveats"
+require_relative "checksum"
+require_relative "class"
 require_relative "components_order"
 require_relative "components_redundancy"
+require_relative "conflicts"
 require_relative "dependency_order"
+require_relative "deprecate_disable"
+require_relative "desc"
+require_relative "files"
 require_relative "homepage"
-require_relative "text"
-require_relative "caveats"
-require_relative "checksum"
-require_relative "patches"
-require_relative "conflicts"
-require_relative "options"
-require_relative "urls"
+require_relative "keg_only"
 require_relative "lines"
 require_relative "livecheck"
-require_relative "class"
+require_relative "options"
+require_relative "patches"
+require_relative "resource_requires_dependencies"
+require_relative "service"
+require_relative "text"
+require_relative "urls"
 require_relative "uses_from_macos"
-require_relative "files"
-require_relative "keg_only"
 require_relative "version"
-require_relative "deprecate_disable"
-require_relative "bottle"
 
 require_relative "rubocop-cask"
diff --git a/Library/Homebrew/rubocops/blank.rb b/Library/Homebrew/rubocops/blank.rb
new file mode 100644
index 0000000000000..f71839eafb5fe
--- /dev/null
+++ b/Library/Homebrew/rubocops/blank.rb
@@ -0,0 +1,72 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Homebrew
+      # Checks for code that can be simplified using `Object#blank?`.
+      #
+      # NOTE: Auto-correction for this cop is unsafe because `' '.empty?` returns `false`,
+      #       but `' '.blank?` returns `true`. Therefore, auto-correction is not compatible
+      #       if the receiver is a non-empty blank string.
+      #
+      # ### Example
+      #
+      # ```ruby
+      # # bad
+      # foo.nil? || foo.empty?
+      # foo == nil || foo.empty?
+      #
+      # # good
+      # foo.blank?
+      # ```
+      class Blank < Base
+        extend AutoCorrector
+
+        MSG = "Use `%<prefer>s` instead of `%<current>s`."
+
+        # `(send nil $_)` is not actually a valid match for an offense. Nodes
+        # that have a single method call on the left hand side
+        # (`bar || foo.empty?`) will blow up when checking
+        # `(send (:nil) :== $_)`.
+        def_node_matcher :nil_or_empty?, <<~PATTERN
+          (or
+              {
+                (send $_ :!)
+                (send $_ :nil?)
+                (send $_ :== nil)
+                (send nil :== $_)
+              }
+              {
+                (send $_ :empty?)
+                (send (send (send $_ :empty?) :!) :!)
+              }
+          )
+        PATTERN
+
+        def on_or(node)
+          nil_or_empty?(node) do |var1, var2|
+            return if var1 != var2
+
+            message = format(MSG, prefer: replacement(var1), current: node.source)
+            add_offense(node, message:) do |corrector|
+              autocorrect(corrector, node)
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          variable1, _variable2 = nil_or_empty?(node)
+          range = node.source_range
+          corrector.replace(range, replacement(variable1))
+        end
+
+        def replacement(node)
+          node.respond_to?(:source) ? "#{node.source}.blank?" : "blank?"
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/bottle.rb b/Library/Homebrew/rubocops/bottle.rb
index fd69556cb6466..0255f1e4ae3c7 100644
--- a/Library/Homebrew/rubocops/bottle.rb
+++ b/Library/Homebrew/rubocops/bottle.rb
@@ -1,19 +1,18 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
     module FormulaAudit
       # This cop audits the `bottle` block in formulae.
-      #
-      # @api private
       class BottleFormat < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          bottle_node = find_block(body_node, :bottle)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          bottle_node = find_block(formula_nodes.body_node, :bottle)
           return if bottle_node.nil?
 
           sha256_nodes = find_method_calls_by_name(bottle_node.body, :sha256)
@@ -54,13 +53,12 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
       end
 
       # This cop audits the indentation of the bottle tags in the `bottle` block in formulae.
-      #
-      # @api private
       class BottleTagIndentation < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          bottle_node = find_block(body_node, :bottle)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          bottle_node = find_block(formula_nodes.body_node, :bottle)
           return if bottle_node.nil?
 
           sha256_nodes = find_method_calls_by_name(bottle_node.body, :sha256)
@@ -90,13 +88,12 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
       end
 
       # This cop audits the indentation of the sha256 digests in the`bottle` block in formulae.
-      #
-      # @api private
       class BottleDigestIndentation < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          bottle_node = find_block(body_node, :bottle)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          bottle_node = find_block(formula_nodes.body_node, :bottle)
           return if bottle_node.nil?
 
           sha256_nodes = find_method_calls_by_name(bottle_node.body, :sha256)
@@ -126,13 +123,12 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
       end
 
       # This cop audits the order of the `bottle` block in formulae.
-      #
-      # @api private
       class BottleOrder < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          bottle_node = find_block(body_node, :bottle)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          bottle_node = find_block(formula_nodes.body_node, :bottle)
           return if bottle_node.nil?
           return if bottle_node.child_nodes.blank?
 
diff --git a/Library/Homebrew/rubocops/cask/array_alphabetization.rb b/Library/Homebrew/rubocops/cask/array_alphabetization.rb
new file mode 100644
index 0000000000000..2237052fce384
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/array_alphabetization.rb
@@ -0,0 +1,71 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Cask
+      class ArrayAlphabetization < Base
+        extend AutoCorrector
+
+        def on_send(node)
+          return unless [:zap, :uninstall].include?(node.method_name)
+
+          node.each_descendant(:pair).each do |pair|
+            symbols = pair.children.select(&:sym_type?).map(&:value)
+            next if symbols.intersect?([:signal, :script, :early_script, :args, :input])
+
+            pair.each_descendant(:array).each do |array|
+              if array.children.length == 1
+                add_offense(array, message: "Avoid single-element arrays by removing the []") do |corrector|
+                  corrector.replace(array.source_range, array.children.first.source)
+                end
+              end
+
+              next if array.children.length <= 1
+
+              sorted_array = sort_array(array.source.split("\n")).join("\n")
+
+              next if array.source == sorted_array
+
+              add_offense(array, message: "The array elements should be ordered alphabetically") do |corrector|
+                corrector.replace(array.source_range, sorted_array)
+              end
+            end
+          end
+        end
+
+        def sort_array(source)
+          # Combine each comment with the line(s) below so that they remain in the same relative location
+          combined_source = source.each_with_index.filter_map do |line, index|
+            next if line.blank?
+            next if line.strip.start_with?("#")
+
+            next recursively_find_comments(source, index, line)
+          end
+
+          # Separate the lines into those that should be sorted and those that should not
+          # i.e. skip the opening and closing brackets of the array.
+          to_sort, to_keep = combined_source.partition { |line| !line.include?("[") && !line.include?("]") }
+
+          # Sort the lines that should be sorted
+          to_sort.sort! do |a, b|
+            a_non_comment = a.split("\n").reject { |line| line.strip.start_with?("#") }.first
+            b_non_comment = b.split("\n").reject { |line| line.strip.start_with?("#") }.first
+            a_non_comment.downcase <=> b_non_comment.downcase
+          end
+
+          # Merge the sorted lines and the unsorted lines, preserving the original positions of the unsorted lines
+          combined_source.map { |line| to_keep.include?(line) ? line : to_sort.shift }
+        end
+
+        def recursively_find_comments(source, index, line)
+          if source[index - 1].strip.start_with?("#")
+            return recursively_find_comments(source, index - 1, "#{source[index - 1]}\n#{line}")
+          end
+
+          line
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/cask/ast/cask_block.rb b/Library/Homebrew/rubocops/cask/ast/cask_block.rb
index c05f109723ae5..943c09185a14d 100644
--- a/Library/Homebrew/rubocops/cask/ast/cask_block.rb
+++ b/Library/Homebrew/rubocops/cask/ast/cask_block.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "forwardable"
@@ -6,70 +6,75 @@
 module RuboCop
   module Cask
     module AST
-      # This class wraps the AST block node that represents the entire cask
-      # definition. It includes various helper methods to aid cops in their
-      # analysis.
-      class CaskBlock
-        extend Forwardable
+      class StanzaBlock
+        extend T::Helpers
 
+        sig { returns(RuboCop::AST::BlockNode) }
+        attr_reader :block_node
+
+        sig { returns(T::Array[Parser::Source::Comment]) }
+        attr_reader :comments
+
+        sig { params(block_node: RuboCop::AST::BlockNode, comments: T::Array[Parser::Source::Comment]).void }
         def initialize(block_node, comments)
           @block_node = block_node
           @comments = comments
         end
 
-        attr_reader :block_node, :comments
+        sig { returns(T::Array[Stanza]) }
+        def stanzas
+          return [] unless (block_body = block_node.block_body)
+
+          # If a block only contains one stanza, it is that stanza's direct parent, otherwise
+          # stanzas are grouped in a nested block and the block is that nested block's parent.
+          is_stanza = if block_body.begin_block?
+            ->(node) { node.parent.parent == block_node }
+          else
+            ->(node) { node.parent == block_node }
+          end
 
-        alias cask_node block_node
+          @stanzas ||= block_body.each_node
+                                 .select(&:stanza?)
+                                 .select(&is_stanza)
+                                 .map { |node| Stanza.new(node, comments) }
+        end
+      end
+
+      # This class wraps the AST block node that represents the entire cask
+      # definition. It includes various helper methods to aid cops in their
+      # analysis.
+      class CaskBlock < StanzaBlock
+        extend Forwardable
+
+        def cask_node
+          block_node
+        end
 
         def_delegator :cask_node, :block_body, :cask_body
 
         def header
-          @header ||= CaskHeader.new(cask_node.method_node)
+          @header ||= CaskHeader.new(block_node.method_node)
         end
 
+        # TODO: Use `StanzaBlock#stanzas` for all cops, where possible.
         def stanzas
           return [] unless cask_body
 
           @stanzas ||= cask_body.each_node
                                 .select(&:stanza?)
-                                .map { |node| Stanza.new(node, stanza_comments(node)) }
+                                .map { |node| Stanza.new(node, comments) }
         end
 
         def toplevel_stanzas
-          @toplevel_stanzas ||= stanzas.select(&:toplevel_stanza?)
-        end
-
-        def sorted_toplevel_stanzas
-          @sorted_toplevel_stanzas ||= sort_stanzas(toplevel_stanzas)
-        end
-
-        private
-
-        def sort_stanzas(stanzas)
-          stanzas.sort do |s1, s2|
-            i1 = stanza_order_index(s1)
-            i2 = stanza_order_index(s2)
-            if i1 == i2
-              i1 = stanzas.index(s1)
-              i2 = stanzas.index(s2)
-            end
-            i1 - i2
+          # If a `cask` block only contains one stanza, it is that stanza's direct parent,
+          # otherwise stanzas are grouped in a block and `cask` is that block's parent.
+          is_toplevel_stanza = if cask_body.begin_block?
+            ->(stanza) { stanza.parent_node.parent.cask_block? }
+          else
+            ->(stanza) { stanza.parent_node.cask_block? }
           end
-        end
-
-        def stanza_order_index(stanza)
-          Constants::STANZA_ORDER.index(stanza.stanza_name)
-        end
-
-        def stanza_comments(stanza_node)
-          stanza_node.each_node.reduce([]) do |comments, node|
-            comments | comments_hash[node.loc]
-          end
-        end
 
-        def comments_hash
-          @comments_hash ||= Parser::Source::Comment
-                             .associate_locations(cask_node, comments)
+          @toplevel_stanzas ||= stanzas.select(&is_toplevel_stanza)
         end
       end
     end
diff --git a/Library/Homebrew/rubocops/cask/ast/cask_header.rb b/Library/Homebrew/rubocops/cask/ast/cask_header.rb
index 01386a46675ca..2b4ed0ef1e2cc 100644
--- a/Library/Homebrew/rubocops/cask/ast/cask_header.rb
+++ b/Library/Homebrew/rubocops/cask/ast/cask_header.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module RuboCop
@@ -7,18 +7,12 @@ module AST
       # This class wraps the AST method node that represents the cask header. It
       # includes various helper methods to aid cops in their analysis.
       class CaskHeader
-        extend T::Sig
-
         def initialize(method_node)
           @method_node = method_node
         end
 
         attr_reader :method_node
 
-        def dsl_version?
-          hash_node
-        end
-
         def header_str
           @header_str ||= source_range.source
         end
@@ -33,11 +27,7 @@ def preferred_header_str
         end
 
         def cask_token
-          @cask_token ||= if dsl_version?
-            pair_node.val_node.children.first
-          else
-            method_node.first_argument.str_content
-          end
+          @cask_token ||= method_node.first_argument.str_content
         end
 
         def hash_node
diff --git a/Library/Homebrew/rubocops/cask/ast/stanza.rb b/Library/Homebrew/rubocops/cask/ast/stanza.rb
index e17e849e74c5e..a85ceecd5201f 100644
--- a/Library/Homebrew/rubocops/cask/ast/stanza.rb
+++ b/Library/Homebrew/rubocops/cask/ast/stanza.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "forwardable"
@@ -12,20 +12,21 @@ module AST
       class Stanza
         extend Forwardable
 
-        def initialize(method_node, comments)
+        def initialize(method_node, all_comments)
           @method_node = method_node
-          @comments = comments
+          @all_comments = all_comments
         end
 
-        attr_reader :method_node, :comments
+        attr_reader :method_node, :all_comments
 
         alias stanza_node method_node
 
-        def_delegator :stanza_node, :method_name, :stanza_name
         def_delegator :stanza_node, :parent, :parent_node
+        def_delegator :stanza_node, :arch_variable?
+        def_delegator :stanza_node, :on_system_block?
 
         def source_range
-          stanza_node.expression
+          stanza_node.location_expression
         end
 
         def source_range_with_comments
@@ -38,29 +39,44 @@ def source_range_with_comments
         def_delegator :source_range_with_comments, :source,
                       :source_with_comments
 
+        def stanza_name
+          return :on_arch_conditional if arch_variable?
+
+          stanza_node.method_name
+        end
+
         def stanza_group
           Constants::STANZA_GROUP_HASH[stanza_name]
         end
 
+        def stanza_index
+          Constants::STANZA_ORDER.index(stanza_name)
+        end
+
         def same_group?(other)
           stanza_group == other.stanza_group
         end
 
-        def toplevel_stanza?
-          parent_node.cask_block? || parent_node.parent.cask_block?
+        def comments
+          @comments ||= stanza_node.each_node.reduce([]) do |comments, node|
+            comments | comments_hash[node.loc]
+          end
+        end
+
+        def comments_hash
+          @comments_hash ||= Parser::Source::Comment.associate_locations(stanza_node.parent, all_comments)
         end
 
         def ==(other)
           self.class == other.class && stanza_node == other.stanza_node
         end
-
         alias eql? ==
 
         Constants::STANZA_ORDER.each do |stanza_name|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{stanza_name}?               # def url?
-              stanza_name == :#{stanza_name}  #   stanza_name == :url
-            end                               # end
+            def #{stanza_name.to_s.chomp("!")}?               # def url?
+              stanza_name == :#{stanza_name}                  #   stanza_name == :url
+            end                                               # end
           RUBY
         end
       end
diff --git a/Library/Homebrew/rubocops/cask/constants/stanza.rb b/Library/Homebrew/rubocops/cask/constants/stanza.rb
index 93a9b67d553a8..2e911fc9e2de2 100644
--- a/Library/Homebrew/rubocops/cask/constants/stanza.rb
+++ b/Library/Homebrew/rubocops/cask/constants/stanza.rb
@@ -1,15 +1,25 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module RuboCop
   module Cask
     # Constants available globally for use in all cask cops.
     module Constants
+      ON_SYSTEM_METHODS = [:arm, :intel, *MacOSVersion::SYMBOLS.keys].map { |option| :"on_#{option}" }.freeze
+      ON_SYSTEM_METHODS_STANZA_ORDER = [
+        :arm,
+        :intel,
+        *MacOSVersion::SYMBOLS.reverse_each.to_h.keys, # Oldest OS blocks first since that's more common in Casks.
+      ].map { |option, _| :"on_#{option}" }.freeze
+
       STANZA_GROUPS = [
+        [:arch, :on_arch_conditional],
         [:version, :sha256],
+        ON_SYSTEM_METHODS_STANZA_ORDER,
         [:language],
         [:url, :appcast, :name, :desc, :homepage],
         [:livecheck],
+        [:deprecate!, :disable!],
         [
           :auto_updates,
           :conflicts_with,
@@ -28,6 +38,7 @@ module Constants
           :font,
           :input_method,
           :internet_plugin,
+          :keyboard_layout,
           :prefpane,
           :qlplugin,
           :mdimporter,
@@ -54,6 +65,20 @@ module Constants
         end.freeze
 
       STANZA_ORDER = STANZA_GROUPS.flatten.freeze
+
+      UNINSTALL_METHODS_ORDER = [
+        :early_script,
+        :launchctl,
+        :quit,
+        :signal,
+        :login_item,
+        :kext,
+        :script,
+        :pkgutil,
+        :delete,
+        :trash,
+        :rmdir,
+      ].freeze
     end
   end
 end
diff --git a/Library/Homebrew/rubocops/cask/desc.rb b/Library/Homebrew/rubocops/cask/desc.rb
index 9b33d476d763d..64149fc0eb5d5 100644
--- a/Library/Homebrew/rubocops/cask/desc.rb
+++ b/Library/Homebrew/rubocops/cask/desc.rb
@@ -1,8 +1,6 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "forwardable"
-require "uri"
 require "rubocops/cask/mixin/on_desc_stanza"
 require "rubocops/shared/desc_helper"
 
diff --git a/Library/Homebrew/rubocops/cask/discontinued.rb b/Library/Homebrew/rubocops/cask/discontinued.rb
new file mode 100644
index 0000000000000..76bd287ada9a0
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/discontinued.rb
@@ -0,0 +1,42 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Cask
+      # This cop corrects `caveats { discontinued }` to `deprecate!`.
+      class Discontinued < Base
+        include CaskHelp
+        extend AutoCorrector
+
+        MESSAGE = "Use `deprecate!` instead of `caveats { discontinued }`."
+
+        def on_cask_stanza_block(stanza_block)
+          stanza_block.stanzas.select(&:caveats?).each do |stanza|
+            find_discontinued_method_call(stanza.stanza_node) do |node|
+              if caveats_contains_only_discontinued?(node.parent)
+                add_offense(node.parent, message: MESSAGE) do |corrector|
+                  corrector.replace(node.parent.source_range,
+                                    "deprecate! date: \"#{Date.today}\", because: :discontinued")
+                end
+              else
+                add_offense(node, message: MESSAGE)
+              end
+            end
+          end
+        end
+
+        def_node_matcher :caveats_contains_only_discontinued?, <<~EOS
+          (block
+            (send nil? :caveats)
+            (args)
+            (send nil? :discontinued))
+        EOS
+
+        def_node_search :find_discontinued_method_call, <<~EOS
+          $(send nil? :discontinued)
+        EOS
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/cask/discontinued.rbi b/Library/Homebrew/rubocops/cask/discontinued.rbi
new file mode 100644
index 0000000000000..e344d37727fd2
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/discontinued.rbi
@@ -0,0 +1,25 @@
+# typed: strict
+
+module RuboCop
+  module Cop
+    module Cask
+      class Discontinued < Base
+        sig {
+          params(
+            base_node: RuboCop::AST::BlockNode,
+            block:     T.nilable(T.proc.params(node: RuboCop::AST::SendNode).void),
+          ).returns(T::Boolean)
+        }
+        def caveats_contains_only_discontinued?(base_node, &block); end
+
+        sig {
+          params(
+            base_node: RuboCop::AST::BlockNode,
+            block:     T.proc.params(node: RuboCop::AST::SendNode).void,
+          ).void
+        }
+        def find_discontinued_method_call(base_node, &block); end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/cask/extend/node.rb b/Library/Homebrew/rubocops/cask/extend/node.rb
index 906518db49de2..8abc568ec0855 100644
--- a/Library/Homebrew/rubocops/cask/extend/node.rb
+++ b/Library/Homebrew/rubocops/cask/extend/node.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,23 +8,33 @@ class Node
       include RuboCop::Cask::Constants
 
       def_node_matcher :method_node, "{$(send ...) (block $(send ...) ...)}"
-      def_node_matcher :block_args,  "(block _ $_ _)"
       def_node_matcher :block_body,  "(block _ _ $_)"
+      def_node_matcher :cask_block?, "(block (send nil? :cask ...) args ...)"
+      def_node_matcher :on_system_block?,
+                       "(block (send nil? {#{ON_SYSTEM_METHODS.map(&:inspect).join(" ")}} ...) args ...)"
+      def_node_matcher :arch_variable?, "(lvasgn _ (send nil? :on_arch_conditional ...))"
+      def_node_matcher :begin_block?, "(begin ...)"
 
-      def_node_matcher :key_node,    "{(pair $_ _) (hash (pair $_ _) ...)}"
-      def_node_matcher :val_node,    "{(pair _ $_) (hash (pair _ $_) ...)}"
-
-      def_node_matcher :cask_block?, "(block (send nil? :cask _) args ...)"
+      sig { returns(T::Boolean) }
+      def cask_on_system_block?
+        (on_system_block? && each_ancestor.any?(&:cask_block?)) || false
+      end
 
       def stanza?
-        (send_type? || block_type?) && STANZA_ORDER.include?(method_name)
+        return true if arch_variable?
+
+        case self
+        when RuboCop::AST::BlockNode, RuboCop::AST::SendNode
+          ON_SYSTEM_METHODS.include?(method_name) || STANZA_ORDER.include?(method_name)
+        else false
+        end
       end
 
       def heredoc?
         loc.is_a?(Parser::Source::Map::Heredoc)
       end
 
-      def expression
+      def location_expression
         base_expression = loc.expression
         descendants.select(&:heredoc?).reduce(base_expression) do |expr, node|
           expr.join(node.loc.heredoc_end)
diff --git a/Library/Homebrew/rubocops/cask/extend/node.rbi b/Library/Homebrew/rubocops/cask/extend/node.rbi
new file mode 100644
index 0000000000000..d5850b29bdd07
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/extend/node.rbi
@@ -0,0 +1,21 @@
+# typed: strict
+
+class RuboCop::AST::Node
+  sig { returns(T.nilable(RuboCop::AST::SendNode)) }
+  def method_node; end
+
+  sig { returns(T.nilable(RuboCop::AST::Node)) }
+  def block_body; end
+
+  sig { returns(T::Boolean) }
+  def cask_block?; end
+
+  sig { returns(T::Boolean) }
+  def on_system_block?; end
+
+  sig { returns(T::Boolean) }
+  def arch_variable?; end
+
+  sig { returns(T::Boolean) }
+  def begin_block?; end
+end
diff --git a/Library/Homebrew/rubocops/cask/extend/string.rb b/Library/Homebrew/rubocops/cask/extend/string.rb
deleted file mode 100644
index 3f71c87c2f09d..0000000000000
--- a/Library/Homebrew/rubocops/cask/extend/string.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-# Utility method extensions for String.
-class String
-  extend T::Sig
-
-  sig { returns(String) }
-  def undent
-    gsub(/^.{#{(slice(/^ +/) || '').length}}/, "")
-  end
-end
diff --git a/Library/Homebrew/rubocops/cask/homepage_url_styling.rb b/Library/Homebrew/rubocops/cask/homepage_url_styling.rb
new file mode 100644
index 0000000000000..98820f5c739cb
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/homepage_url_styling.rb
@@ -0,0 +1,50 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "forwardable"
+require "uri"
+require "rubocops/shared/homepage_helper"
+
+module RuboCop
+  module Cop
+    module Cask
+      # This cop audits the `homepage` URL in casks.
+      class HomepageUrlStyling < Base
+        include OnHomepageStanza
+        include HelperFunctions
+        include HomepageHelper
+        extend AutoCorrector
+
+        MSG_NO_SLASH = "'%<url>s' must have a slash after the domain."
+
+        def on_homepage_stanza(stanza)
+          @name = cask_block.header.cask_token
+          desc_call = stanza.stanza_node
+          url_node = desc_call.first_argument
+
+          url = if url_node.dstr_type?
+            # Remove quotes from interpolated string.
+            url_node.source[1..-2]
+          else
+            url_node.str_content
+          end
+
+          audit_homepage(:cask, url, desc_call, url_node)
+
+          return unless url&.match?(%r{^.+://[^/]+$})
+
+          domain = URI(string_content(url_node, strip_dynamic: true)).host
+          return if domain.blank?
+
+          # This also takes URLs like 'https://example.org?path'
+          # and 'https://example.org#path' into account.
+          corrected_source = url_node.source.sub("://#{domain}", "://#{domain}/")
+
+          add_offense(url_node.loc.expression, message: format(MSG_NO_SLASH, url:)) do |corrector|
+            corrector.replace(url_node.source_range, corrected_source)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/cask/homepage_url_trailing_slash.rb b/Library/Homebrew/rubocops/cask/homepage_url_trailing_slash.rb
deleted file mode 100644
index c26c1848e76a5..0000000000000
--- a/Library/Homebrew/rubocops/cask/homepage_url_trailing_slash.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "forwardable"
-require "uri"
-
-module RuboCop
-  module Cop
-    module Cask
-      # This cop checks that a cask's homepage ends with a slash
-      # if it does not have a path component.
-      class HomepageUrlTrailingSlash < Base
-        include OnHomepageStanza
-        include HelperFunctions
-        extend AutoCorrector
-
-        MSG_NO_SLASH = "'%<url>s' must have a slash after the domain."
-
-        def on_homepage_stanza(stanza)
-          url_node = stanza.stanza_node.first_argument
-
-          url = if url_node.dstr_type?
-            # Remove quotes from interpolated string.
-            url_node.source[1..-2]
-          else
-            url_node.str_content
-          end
-
-          return unless url&.match?(%r{^.+://[^/]+$})
-
-          domain = URI(string_content(url_node, strip_dynamic: true)).host
-          return if domain.blank?
-
-          # This also takes URLs like 'https://example.org?path'
-          # and 'https://example.org#path' into account.
-          corrected_source = url_node.source.sub("://#{domain}", "://#{domain}/")
-
-          add_offense(url_node.loc.expression, message: format(MSG_NO_SLASH, url: url)) do |corrector|
-            corrector.replace(url_node.source_range, corrected_source)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/rubocops/cask/mixin/cask_help.rb b/Library/Homebrew/rubocops/cask/mixin/cask_help.rb
index 192e72c99c5dd..a173e6e027a5f 100644
--- a/Library/Homebrew/rubocops/cask/mixin/cask_help.rb
+++ b/Library/Homebrew/rubocops/cask/mixin/cask_help.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,15 +6,48 @@ module Cop
     module Cask
       # Common functionality for cops checking casks.
       module CaskHelp
+        prepend CommentsHelp # Update the rbi file if changing this: https://github.com/sorbet/sorbet/issues/259
+
+        sig { overridable.params(cask_block: RuboCop::Cask::AST::CaskBlock).void }
+        def on_cask(cask_block); end
+
+        sig { overridable.params(cask_stanza_block: RuboCop::Cask::AST::StanzaBlock).void }
+        def on_cask_stanza_block(cask_stanza_block); end
+
+        sig { params(block_node: RuboCop::AST::BlockNode).void }
         def on_block(block_node)
           super if defined? super
-          return unless respond_to?(:on_cask)
+
+          return if !block_node.cask_block? && !block_node.cask_on_system_block?
+
+          comments = comments_in_range(block_node).to_a
+          stanza_block = RuboCop::Cask::AST::StanzaBlock.new(block_node, comments)
+          on_cask_stanza_block(stanza_block)
+
           return unless block_node.cask_block?
 
-          comments = processed_source.comments
+          @file_path = processed_source.file_path
+
           cask_block = RuboCop::Cask::AST::CaskBlock.new(block_node, comments)
           on_cask(cask_block)
         end
+
+        def on_system_methods(cask_stanzas)
+          cask_stanzas.select(&:on_system_block?)
+        end
+
+        def inner_stanzas(block_node, comments)
+          block_contents = block_node.child_nodes.select(&:begin_type?)
+          inner_nodes = block_contents.map(&:child_nodes).flatten.select(&:send_type?)
+          inner_nodes.map { |n| RuboCop::Cask::AST::Stanza.new(n, comments) }
+        end
+
+        sig { returns(T.nilable(String)) }
+        def cask_tap
+          return unless (match_obj = @file_path.match(%r{/(homebrew-\w+)/}))
+
+          match_obj[1]
+        end
       end
     end
   end
diff --git a/Library/Homebrew/rubocops/cask/mixin/cask_help.rbi b/Library/Homebrew/rubocops/cask/mixin/cask_help.rbi
new file mode 100644
index 0000000000000..134eae355e96e
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/mixin/cask_help.rbi
@@ -0,0 +1,7 @@
+# typed: strict
+
+module RuboCop::Cop::Cask::CaskHelp
+  # Sorbet doesn't understand `prepend`: https://github.com/sorbet/sorbet/issues/259
+  include RuboCop::Cop::CommentsHelp
+  requires_ancestor { RuboCop::Cop::Base }
+end
diff --git a/Library/Homebrew/rubocops/cask/mixin/on_desc_stanza.rb b/Library/Homebrew/rubocops/cask/mixin/on_desc_stanza.rb
index 759b899d67b1f..032a900095a8c 100644
--- a/Library/Homebrew/rubocops/cask/mixin/on_desc_stanza.rb
+++ b/Library/Homebrew/rubocops/cask/mixin/on_desc_stanza.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module RuboCop
diff --git a/Library/Homebrew/rubocops/cask/mixin/on_desc_stanza.rbi b/Library/Homebrew/rubocops/cask/mixin/on_desc_stanza.rbi
new file mode 100644
index 0000000000000..f1e8ae8be4ebb
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/mixin/on_desc_stanza.rbi
@@ -0,0 +1,5 @@
+# typed: strict
+
+module RuboCop::Cop::Cask::OnDescStanza
+  requires_ancestor { RuboCop::Cop::Cask::Desc }
+end
diff --git a/Library/Homebrew/rubocops/cask/mixin/on_homepage_stanza.rb b/Library/Homebrew/rubocops/cask/mixin/on_homepage_stanza.rb
index 97607aa56875d..26b6bd2191b81 100644
--- a/Library/Homebrew/rubocops/cask/mixin/on_homepage_stanza.rb
+++ b/Library/Homebrew/rubocops/cask/mixin/on_homepage_stanza.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module RuboCop
diff --git a/Library/Homebrew/rubocops/cask/mixin/on_homepage_stanza.rbi b/Library/Homebrew/rubocops/cask/mixin/on_homepage_stanza.rbi
new file mode 100644
index 0000000000000..16240f863d35f
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/mixin/on_homepage_stanza.rbi
@@ -0,0 +1,5 @@
+# typed: strict
+
+module RuboCop::Cop::Cask::OnHomepageStanza
+  requires_ancestor { RuboCop::Cop::Cask::HomepageUrlStyling }
+end
diff --git a/Library/Homebrew/rubocops/cask/mixin/on_url_stanza.rb b/Library/Homebrew/rubocops/cask/mixin/on_url_stanza.rb
index ad26e67a110f7..ad2223644bdfd 100644
--- a/Library/Homebrew/rubocops/cask/mixin/on_url_stanza.rb
+++ b/Library/Homebrew/rubocops/cask/mixin/on_url_stanza.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module RuboCop
diff --git a/Library/Homebrew/rubocops/cask/mixin/on_url_stanza.rbi b/Library/Homebrew/rubocops/cask/mixin/on_url_stanza.rbi
new file mode 100644
index 0000000000000..e414839c89043
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/mixin/on_url_stanza.rbi
@@ -0,0 +1,5 @@
+# typed: strict
+
+module RuboCop::Cop::Cask::OnUrlStanza
+  requires_ancestor { RuboCop::Cop::Cask::Url }
+end
diff --git a/Library/Homebrew/rubocops/cask/no_dsl_version.rb b/Library/Homebrew/rubocops/cask/no_dsl_version.rb
deleted file mode 100644
index 63dbda85e6911..0000000000000
--- a/Library/Homebrew/rubocops/cask/no_dsl_version.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "forwardable"
-
-module RuboCop
-  module Cop
-    module Cask
-      # Do not use the deprecated DSL version syntax in your cask header.
-      #
-      # @example
-      #   # bad
-      #   cask :v1 => 'foo' do
-      #     ...
-      #   end
-      #
-      #   # good
-      #   cask 'foo' do
-      #     ...
-      #   end
-      class NoDslVersion < Base
-        extend T::Sig
-
-        extend Forwardable
-        extend AutoCorrector
-        include CaskHelp
-
-        MESSAGE = "Use `%<preferred>s` instead of `%<current>s`"
-
-        def on_cask(cask_block)
-          @cask_header = cask_block.header
-          return unless offense?
-
-          offense
-        end
-
-        private
-
-        def_delegator :@cask_header, :source_range, :header_range
-        def_delegators :@cask_header, :header_str, :preferred_header_str
-
-        def cask_header(method_node)
-          RuboCop::Cask::AST::CaskHeader.new(method_node)
-        end
-
-        def offense?
-          @cask_header.dsl_version?
-        end
-
-        def offense
-          add_offense(header_range, message: error_msg) do |corrector|
-            corrector.replace(header_range, preferred_header_str)
-          end
-        end
-
-        sig { returns(String) }
-        def error_msg
-          format(MESSAGE, preferred: preferred_header_str, current: header_str)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/rubocops/cask/no_overrides.rb b/Library/Homebrew/rubocops/cask/no_overrides.rb
new file mode 100644
index 0000000000000..0493246252b20
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/no_overrides.rb
@@ -0,0 +1,73 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Cask
+      class NoOverrides < Base
+        include CaskHelp
+
+        # These stanzas can be overridden by `on_*` blocks, so take them into account.
+        # TODO: Update this list if new stanzas are added to `Cask::DSL` that call `set_unique_stanza`.
+        OVERRIDEABLE_METHODS = [
+          :appcast, :arch, :auto_updates, :conflicts_with, :container,
+          :desc, :homepage, :sha256, :url, :version
+        ].freeze
+        MESSAGE = "Do not use a top-level `%<stanza>s` stanza as the default. " \
+                  "Add it to an `on_{system}` block instead. " \
+                  "Use `:or_older` or `:or_newer` to specify a range of macOS versions."
+
+        def on_cask(cask_block)
+          cask_stanzas = cask_block.toplevel_stanzas
+
+          return if (on_blocks = on_system_methods(cask_stanzas)).none?
+
+          stanzas_in_blocks = on_system_stanzas(on_blocks)
+
+          cask_stanzas.each do |stanza|
+            # Skip if the stanza is not allowed to be overridden.
+            next unless OVERRIDEABLE_METHODS.include?(stanza.stanza_name)
+            # Skip if the stanza outside of a block is not also in an `on_*` block.
+            next unless stanzas_in_blocks.include?(stanza.stanza_name)
+
+            add_offense(stanza.source_range, message: format(MESSAGE, stanza: stanza.stanza_name))
+          end
+        end
+
+        def on_system_stanzas(on_system)
+          names = Set.new
+          method_nodes = on_system.map(&:method_node)
+          method_nodes.select(&:block_type?).each do |node|
+            node.child_nodes.each do |child|
+              child.each_node(:send) do |send_node|
+                # Skip (nested) livecheck blocks as its `url` is different to a download `url`.
+                next if send_node.method_name == :livecheck || inside_livecheck_block?(send_node)
+                # Skip string interpolations.
+                if send_node.ancestors.drop_while { |a| !a.begin_type? }.any? { |a| a.dstr_type? || a.regexp_type? }
+                  next
+                end
+                next if RuboCop::Cask::Constants::ON_SYSTEM_METHODS.include?(send_node.method_name)
+
+                names.add(send_node.method_name)
+              end
+            end
+          end
+          names
+        end
+
+        def inside_livecheck_block?(node)
+          single_stanza_livecheck_block?(node) || multi_stanza_livecheck_block?(node)
+        end
+
+        def single_stanza_livecheck_block?(node)
+          node.parent.block_type? && node.parent.method_name == :livecheck
+        end
+
+        def multi_stanza_livecheck_block?(node)
+          grandparent_node = node.parent.parent
+          node.parent.begin_type? && grandparent_node.block_type? && grandparent_node.method_name == :livecheck
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/cask/on_system_conditionals.rb b/Library/Homebrew/rubocops/cask/on_system_conditionals.rb
new file mode 100644
index 0000000000000..eab312a8b5d32
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/on_system_conditionals.rb
@@ -0,0 +1,86 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "forwardable"
+require "rubocops/shared/on_system_conditionals_helper"
+
+module RuboCop
+  module Cop
+    module Cask
+      # This cop makes sure that OS conditionals are consistent.
+      #
+      # ### Example
+      #
+      # ```ruby
+      # # bad
+      # cask 'foo' do
+      #   if MacOS.version == :high_sierra
+      #     sha256 "..."
+      #   end
+      # end
+      #
+      # # good
+      # cask 'foo' do
+      #   on_high_sierra do
+      #     sha256 "..."
+      #   end
+      # end
+      # ```
+      class OnSystemConditionals < Base
+        extend Forwardable
+        extend AutoCorrector
+        include OnSystemConditionalsHelper
+        include CaskHelp
+
+        FLIGHT_STANZA_NAMES = [:preflight, :postflight, :uninstall_preflight, :uninstall_postflight].freeze
+
+        def on_cask(cask_block)
+          @cask_block = cask_block
+
+          toplevel_stanzas.each do |stanza|
+            next unless FLIGHT_STANZA_NAMES.include? stanza.stanza_name
+
+            audit_on_system_blocks(stanza.stanza_node, stanza.stanza_name)
+          end
+
+          audit_arch_conditionals(cask_body, allowed_blocks: FLIGHT_STANZA_NAMES)
+          audit_macos_version_conditionals(cask_body, recommend_on_system: false)
+          simplify_sha256_stanzas
+        end
+
+        private
+
+        attr_reader :cask_block
+
+        def_delegators :cask_block, :toplevel_stanzas, :cask_body
+
+        def simplify_sha256_stanzas
+          nodes = {}
+
+          sha256_on_arch_stanzas(cask_body) do |node, method, value|
+            nodes[method.to_s.delete_prefix("on_").to_sym] = { node:, value: }
+          end
+
+          return if !nodes.key?(:arm) || !nodes.key?(:intel)
+
+          offending_node(nodes[:arm][:node])
+          replacement_string = "sha256 arm: #{nodes[:arm][:value].inspect}, intel: #{nodes[:intel][:value].inspect}"
+
+          problem "Use `#{replacement_string}` instead of nesting the `sha256` stanzas in " \
+                  "`on_intel` and `on_arm` blocks" do |corrector|
+            corrector.replace(nodes[:arm][:node].source_range, replacement_string)
+            corrector.replace(nodes[:intel][:node].source_range, "")
+          end
+        end
+
+        def_node_search :sha256_on_arch_stanzas, <<~PATTERN
+          $(block
+            (send nil? ${:on_intel :on_arm})
+            (args)
+            (send nil? :sha256
+              (str $_)))
+        PATTERN
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/cask/on_system_conditionals.rbi b/Library/Homebrew/rubocops/cask/on_system_conditionals.rbi
new file mode 100644
index 0000000000000..3ca40d52d9bc6
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/on_system_conditionals.rbi
@@ -0,0 +1,17 @@
+# typed: strict
+
+module RuboCop
+  module Cop
+    module Cask
+      class OnSystemConditionals < Base
+        sig {
+          params(
+            base_node: Parser::AST::Node,
+            block:     T.proc.params(node: Parser::AST::Node, method: Symbol, value: String).void,
+          ).void
+        }
+        def sha256_on_arch_stanzas(base_node, &block); end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/cask/shared_filelist_glob.rb b/Library/Homebrew/rubocops/cask/shared_filelist_glob.rb
new file mode 100644
index 0000000000000..bd4122dcd35a7
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/shared_filelist_glob.rb
@@ -0,0 +1,37 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Cask
+      class SharedFilelistGlob < Base
+        extend AutoCorrector
+
+        def on_send(node)
+          return if node.method_name != :zap
+
+          node.each_descendant(:pair).each do |pair|
+            symbols = pair.children.select(&:sym_type?).map(&:value)
+            next unless symbols.include?(:trash)
+
+            pair.each_descendant(:array).each do |array|
+              regex = /\.sfl\d"$/
+              message = "Use a glob (*) instead of a specific version (ie. sfl2) for trashing Shared File List paths"
+
+              array.children.each do |item|
+                next unless item.source.match?(regex)
+
+                corrected_item = item.source.sub(/sfl\d"$/, "sfl*\"")
+
+                add_offense(item,
+                            message:) do |corrector|
+                  corrector.replace(item, corrected_item)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/cask/stanza_grouping.rb b/Library/Homebrew/rubocops/cask/stanza_grouping.rb
index 65bc380e39aa4..dacf4694046a7 100644
--- a/Library/Homebrew/rubocops/cask/stanza_grouping.rb
+++ b/Library/Homebrew/rubocops/cask/stanza_grouping.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "forwardable"
@@ -6,7 +6,7 @@
 module RuboCop
   module Cop
     module Cask
-      # This cop checks that a cask's stanzas are grouped correctly.
+      # This cop checks that a cask's stanzas are grouped correctly, including nested within `on_*` blocks.
       # @see https://docs.brew.sh/Cask-Cookbook#stanza-order
       class StanzaGrouping < Base
         extend Forwardable
@@ -14,16 +14,21 @@ class StanzaGrouping < Base
         include CaskHelp
         include RangeHelp
 
-        MISSING_LINE_MSG = "stanza groups should be separated by a single " \
-                           "empty line"
-
-        EXTRA_LINE_MSG = "stanzas within the same group should have no lines " \
-                         "between them"
+        MISSING_LINE_MSG = "stanza groups should be separated by a single empty line"
+        EXTRA_LINE_MSG = "stanzas within the same group should have no lines between them"
 
         def on_cask(cask_block)
           @cask_block = cask_block
           @line_ops = {}
-          add_offenses
+          cask_stanzas = cask_block.toplevel_stanzas
+          add_offenses(cask_stanzas)
+
+          return if (on_blocks = on_system_methods(cask_stanzas)).none?
+
+          on_blocks.map(&:method_node).select(&:block_type?).each do |on_block|
+            stanzas = inner_stanzas(on_block, processed_source.comments)
+            add_offenses(stanzas)
+          end
         end
 
         private
@@ -32,8 +37,8 @@ def on_cask(cask_block)
 
         def_delegators :cask_block, :cask_node, :toplevel_stanzas
 
-        def add_offenses
-          toplevel_stanzas.each_cons(2) do |stanza, next_stanza|
+        def add_offenses(stanzas)
+          stanzas.each_cons(2) do |stanza, next_stanza|
             next unless next_stanza
 
             if missing_line_after?(stanza, next_stanza)
@@ -86,7 +91,7 @@ def add_offense(line_index, message:)
           line_length = [processed_source[line_index].size, 1].max
           @range = source_range(processed_source.buffer, line_index + 1, 0,
                                 line_length)
-          super(@range, message: message)
+          super(@range, message:)
         end
       end
     end
diff --git a/Library/Homebrew/rubocops/cask/stanza_order.rb b/Library/Homebrew/rubocops/cask/stanza_order.rb
index 662fd8f08adf3..8de4858936f62 100644
--- a/Library/Homebrew/rubocops/cask/stanza_order.rb
+++ b/Library/Homebrew/rubocops/cask/stanza_order.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "forwardable"
@@ -6,46 +6,67 @@
 module RuboCop
   module Cop
     module Cask
-      # This cop checks that a cask's stanzas are ordered correctly.
+      # This cop checks that a cask's stanzas are ordered correctly, including nested within `on_*` blocks.
       # @see https://docs.brew.sh/Cask-Cookbook#stanza-order
       class StanzaOrder < Base
-        extend Forwardable
+        include IgnoredNode
         extend AutoCorrector
         include CaskHelp
 
         MESSAGE = "`%<stanza>s` stanza out of order"
 
-        def on_cask(cask_block)
-          @cask_block = cask_block
-          add_offenses
-        end
+        def on_cask_stanza_block(stanza_block)
+          stanzas = stanza_block.stanzas
+          ordered_stanzas = sort_stanzas(stanzas)
 
-        private
+          return if stanzas == ordered_stanzas
 
-        attr_reader :cask_block
+          stanzas.zip(ordered_stanzas).each do |stanza_before, stanza_after|
+            next if stanza_before == stanza_after
 
-        def_delegators :cask_block, :cask_node, :toplevel_stanzas,
-                       :sorted_toplevel_stanzas
+            add_offense(
+              stanza_before.method_node,
+              message: format(MESSAGE, stanza: stanza_before.stanza_name),
+            ) do |corrector|
+              next if part_of_ignored_node?(stanza_before.method_node)
 
-        def add_offenses
-          offending_stanzas.each do |stanza|
-            message = format(MESSAGE, stanza: stanza.stanza_name)
-            add_offense(stanza.source_range_with_comments, message: message) do |corrector|
-              correct_stanza_index = toplevel_stanzas.index(stanza)
-              correct_stanza = sorted_toplevel_stanzas[correct_stanza_index]
-              corrector.replace(stanza.source_range_with_comments,
-                                correct_stanza.source_with_comments)
+              corrector.replace(
+                stanza_before.source_range_with_comments,
+                stanza_after.source_with_comments,
+              )
+
+              # Ignore node so that nested content is not auto-corrected and clobbered.
+              ignore_node(stanza_before.method_node)
             end
           end
         end
 
-        def offending_stanzas
-          stanza_pairs = toplevel_stanzas.zip(sorted_toplevel_stanzas)
-          stanza_pairs.each_with_object([]) do |stanza_pair, offending_stanzas|
-            stanza, sorted_stanza = *stanza_pair
-            offending_stanzas << stanza unless stanza == sorted_stanza
+        def on_new_investigation
+          super
+
+          ignored_nodes.clear
+        end
+
+        private
+
+        def sort_stanzas(stanzas)
+          stanzas.sort do |stanza1, stanza2|
+            i1 = stanza1.stanza_index
+            i2 = stanza2.stanza_index
+
+            if i1 == i2
+              i1 = stanzas.index(stanza1)
+              i2 = stanzas.index(stanza2)
+            end
+
+            i1 - i2
           end
         end
+
+        def stanza_order_index(stanza)
+          stanza_name = stanza.respond_to?(:method_name) ? stanza.method_name : stanza.stanza_name
+          RuboCop::Cask::Constants::STANZA_ORDER.index(stanza_name)
+        end
       end
     end
   end
diff --git a/Library/Homebrew/rubocops/cask/uninstall_methods_order.rb b/Library/Homebrew/rubocops/cask/uninstall_methods_order.rb
new file mode 100644
index 0000000000000..ae252485af95b
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/uninstall_methods_order.rb
@@ -0,0 +1,65 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rubocops/shared/helper_functions"
+
+module RuboCop
+  module Cop
+    module Cask
+      # This cop checks for the correct order of methods within the 'uninstall' and 'zap' stanzas.
+      class UninstallMethodsOrder < Base
+        extend AutoCorrector
+        include HelperFunctions
+
+        MSG = T.let("`%<method>s` method out of order", String)
+
+        sig { params(node: AST::SendNode).void }
+        def on_send(node)
+          return unless [:zap, :uninstall].include?(node.method_name)
+
+          hash_node = node.arguments.first
+          return if hash_node.nil? || (!hash_node.is_a?(AST::Node) && !hash_node.hash_type?)
+
+          method_nodes = hash_node.pairs.map(&:key)
+          expected_order = method_nodes.sort_by { |method| method_order_index(method) }
+          comments = processed_source.comments
+
+          method_nodes.each_with_index do |method, index|
+            next if method == expected_order[index]
+
+            report_and_correct_offense(method, hash_node, expected_order, comments)
+          end
+        end
+
+        sig {
+          params(method:         AST::Node,
+                 hash_node:      AST::HashNode,
+                 expected_order: T::Array[AST::Node],
+                 comments:       T::Array[Parser::Source::Comment]).void
+        }
+        def report_and_correct_offense(method, hash_node, expected_order, comments)
+          add_offense(method, message: format(MSG, method: method.children.first)) do |corrector|
+            indentation = " " * (start_column(method) - line_start_column(method))
+            new_code = expected_order.map do |expected_method|
+              method_pair = hash_node.pairs.find { |pair| pair.key == expected_method }
+              source = method_pair.source
+
+              # Find and attach a comment on the same line as the method_pair, if any
+              inline_comment = comments.find do |comment|
+                comment.location.line == method_pair.loc.line && comment.location.column > method_pair.loc.column
+              end
+              inline_comment ? "#{source} #{inline_comment.text}" : source
+            end.join(",\n#{indentation}")
+            corrector.replace(hash_node.source_range, new_code)
+          end
+        end
+
+        sig { params(method_node: AST::SymbolNode).returns(Integer) }
+        def method_order_index(method_node)
+          method_name = method_node.children.first
+          RuboCop::Cask::Constants::UNINSTALL_METHODS_ORDER.index(method_name) || -1
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/cask/url.rb b/Library/Homebrew/rubocops/cask/url.rb
new file mode 100644
index 0000000000000..eb13ea093602b
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/url.rb
@@ -0,0 +1,73 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "rubocops/shared/url_helper"
+
+module RuboCop
+  module Cop
+    module Cask
+      # This cop checks that a cask's `url` stanza is formatted correctly.
+      #
+      # ### Example
+      #
+      # ```ruby
+      # # bad
+      # url "https://example.com/download/foo.dmg",
+      #     verified: "https://example.com/download"
+      #
+      # # good
+      # url "https://example.com/download/foo.dmg",
+      #     verified: "example.com/download/"
+      # ```
+      class Url < Base
+        extend AutoCorrector
+        include OnUrlStanza
+        include UrlHelper
+
+        def on_url_stanza(stanza)
+          if stanza.stanza_node.block_type?
+            if cask_tap == "homebrew-cask"
+              add_offense(stanza.stanza_node, message: 'Do not use `url "..." do` blocks in Homebrew/homebrew-cask.')
+            end
+            return
+          end
+
+          url_stanza = stanza.stanza_node.first_argument
+          hash_node = stanza.stanza_node.last_argument
+
+          audit_url(:cask, [stanza.stanza_node], [], livecheck_url: false)
+
+          return unless hash_node.hash_type?
+
+          hash_node.each_pair do |key_node, value_node|
+            next if key_node.source != "verified"
+            next unless value_node.str_type?
+
+            if value_node.source.start_with?(%r{^"https?://})
+              add_offense(
+                value_node.source_range,
+                message: "Verified URL parameter value should not contain a URL scheme.",
+              ) do |corrector|
+                corrector.replace(value_node.source_range, value_node.source.gsub(%r{^"https?://}, "\""))
+              end
+            end
+
+            # Skip if the URL and the verified value are the same.
+            next if value_node.source == url_stanza.source.gsub(%r{^"https?://}, "\"")
+            # Skip if the URL has two path components, e.g. `https://github.com/google/fonts.git`.
+            next if url_stanza.source.gsub(%r{^"https?://}, "\"").count("/") == 2
+            # Skip if the verified value ends with a slash.
+            next if value_node.str_content.end_with?("/")
+
+            add_offense(
+              value_node.source_range,
+              message: "Verified URL parameter value should end with a /.",
+            ) do |corrector|
+              corrector.replace(value_node.source_range, value_node.source.gsub(/"$/, "/\""))
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/cask/url_legacy_comma_separators.rb b/Library/Homebrew/rubocops/cask/url_legacy_comma_separators.rb
index d164e625a2b4f..3111361a50e80 100644
--- a/Library/Homebrew/rubocops/cask/url_legacy_comma_separators.rb
+++ b/Library/Homebrew/rubocops/cask/url_legacy_comma_separators.rb
@@ -1,19 +1,16 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "forwardable"
-require "uri"
-
 module RuboCop
   module Cop
     module Cask
-      # This cop checks for version.before_comma and version.after_comma
-      class UrlLegacyCommaSeparators < Base
+      # This cop checks for `version.before_comma` and `version.after_comma`.
+      class UrlLegacyCommaSeparators < Url
         include OnUrlStanza
         extend AutoCorrector
 
-        MSG_CSV = "Use 'version.csv.first' instead of 'version.before_comma' " \
-                  "and 'version.csv.second' instead of 'version.after_comma'"
+        MSG_CSV = "Use `version.csv.first` instead of `version.before_comma` " \
+                  "and `version.csv.second` instead of `version.after_comma`."
 
         def on_url_stanza(stanza)
           return if stanza.stanza_node.type == :block
@@ -28,7 +25,7 @@ def on_url_stanza(stanza)
 
           corrected_url = url.sub("before_comma", "csv.first")&.sub("after_comma", "csv.second")
 
-          add_offense(url_node.loc.expression, message: format(MSG_CSV, url: url)) do |corrector|
+          add_offense(url_node.loc.expression, message: format(MSG_CSV, url:)) do |corrector|
             corrector.replace(url_node.source_range, corrected_url)
           end
         end
diff --git a/Library/Homebrew/rubocops/cask/variables.rb b/Library/Homebrew/rubocops/cask/variables.rb
new file mode 100644
index 0000000000000..adf73e6889b92
--- /dev/null
+++ b/Library/Homebrew/rubocops/cask/variables.rb
@@ -0,0 +1,79 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "forwardable"
+
+module RuboCop
+  module Cop
+    module Cask
+      # This cop audits variables in casks.
+      #
+      # ### Example
+      #
+      # ```ruby
+      # # bad
+      # cask do
+      #   arch = Hardware::CPU.intel? ? "darwin" : "darwin-arm64"
+      # end
+      #
+      # # good
+      # cask 'foo' do
+      #   arch arm: "darwin-arm64", intel: "darwin"
+      # end
+      # ```
+      class Variables < Base
+        extend Forwardable
+        extend AutoCorrector
+        include CaskHelp
+
+        def on_cask(cask_block)
+          @cask_block = cask_block
+          add_offenses
+        end
+
+        private
+
+        def_delegator :@cask_block, :cask_node
+
+        def add_offenses
+          variable_assignment(cask_node) do |node, var_name, arch_condition, true_node, false_node|
+            arm_node, intel_node = if arch_condition == :arm?
+              [true_node, false_node]
+            else
+              [false_node, true_node]
+            end
+
+            replacement_string = if var_name == :arch
+              "arch "
+            else
+              "#{var_name} = on_arch_conditional "
+            end
+            replacement_parameters = []
+            replacement_parameters << "arm: #{arm_node.source}" unless blank_node?(arm_node)
+            replacement_parameters << "intel: #{intel_node.source}" unless blank_node?(intel_node)
+            replacement_string += replacement_parameters.join(", ")
+
+            add_offense(node, message: "Use `#{replacement_string}` instead of `#{node.source}`.") do |corrector|
+              corrector.replace(node, replacement_string)
+            end
+          end
+        end
+
+        def blank_node?(node)
+          case node.type
+          when :str
+            node.value.empty?
+          when :nil
+            true
+          else
+            false
+          end
+        end
+
+        def_node_search :variable_assignment, <<~PATTERN
+          $(lvasgn $_ (if (send (const (const nil? :Hardware) :CPU) ${:arm? :intel?}) $_ $_))
+        PATTERN
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/caveats.rb b/Library/Homebrew/rubocops/caveats.rb
index 577f49ac7959e..b4045c604890e 100644
--- a/Library/Homebrew/rubocops/caveats.rb
+++ b/Library/Homebrew/rubocops/caveats.rb
@@ -1,35 +1,39 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
     module FormulaAudit
-      # This cop makes sure that caveats don't recommend unsupported or unsafe operations.
+      # This cop ensures that caveats don't recommend unsupported or unsafe operations.
       #
-      # @example
-      #   # bad
-      #   def caveats
-      #     <<~EOS
-      #       Use `setuid` to allow running the exeutable by non-root users.
-      #     EOS
-      #   end
+      # ### Example
       #
-      #   # good
-      #   def caveats
-      #     <<~EOS
-      #       Use `sudo` to run the executable.
-      #     EOS
-      #   end
+      # ```ruby
+      # # bad
+      # def caveats
+      #   <<~EOS
+      #     Use `setuid` to allow running the exeutable by non-root users.
+      #   EOS
+      # end
       #
-      # @api private
+      # # good
+      # def caveats
+      #   <<~EOS
+      #     Use `sudo` to run the executable.
+      #   EOS
+      # end
+      # ```
       class Caveats < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, _body_node)
+        sig { override.params(_formula_nodes: FormulaNodes).void }
+        def audit_formula(_formula_nodes)
           caveats_strings.each do |n|
-            next unless regex_match_group(n, /\bsetuid\b/i)
+            if regex_match_group(n, /\bsetuid\b/i)
+              problem "Don't recommend `setuid` in the caveats, suggest `sudo` instead."
+            end
 
-            problem "Don't recommend setuid in the caveats, suggest sudo instead."
+            problem "Don't use ANSI escape codes in the caveats." if regex_match_group(n, /\e/)
           end
         end
       end
diff --git a/Library/Homebrew/rubocops/checksum.rb b/Library/Homebrew/rubocops/checksum.rb
index e8035b8ee36c0..c1776b2d74db6 100644
--- a/Library/Homebrew/rubocops/checksum.rb
+++ b/Library/Homebrew/rubocops/checksum.rb
@@ -1,17 +1,16 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
     module FormulaAudit
       # This cop makes sure that deprecated checksums are not used.
-      #
-      # @api private
       class Checksum < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          return if body_node.nil?
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          body_node = formula_nodes.body_node
 
           problem "MD5 checksums are deprecated, please use SHA-256" if method_called_ever?(body_node, :md5)
 
@@ -43,15 +42,12 @@ def audit_sha256(checksum)
       end
 
       # This cop makes sure that checksum strings are lowercase.
-      #
-      # @api private
       class ChecksumCase < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          return if body_node.nil?
-
-          sha256_calls = find_every_method_call_by_name(body_node, :sha256)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          sha256_calls = find_every_method_call_by_name(formula_nodes.body_node, :sha256)
           sha256_calls.each do |sha256_call|
             checksum = get_checksum_node(sha256_call)
             next if checksum.nil?
diff --git a/Library/Homebrew/rubocops/class.rb b/Library/Homebrew/rubocops/class.rb
index bea3bc055f0d3..2088ef1a5989a 100644
--- a/Library/Homebrew/rubocops/class.rb
+++ b/Library/Homebrew/rubocops/class.rb
@@ -1,14 +1,12 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
     module FormulaAudit
       # This cop makes sure that {Formula} is used as superclass.
-      #
-      # @api private
       class ClassName < FormulaCop
         extend AutoCorrector
 
@@ -18,7 +16,10 @@ class ClassName < FormulaCop
           AmazonWebServicesFormula
         ].freeze
 
-        def audit_formula(_node, _class_node, parent_class_node, _body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          parent_class_node = formula_nodes.parent_class_node
+
           parent_class = class_name(parent_class_node)
           return unless DEPRECATED_CLASSES.include?(parent_class)
 
@@ -29,13 +30,12 @@ def audit_formula(_node, _class_node, parent_class_node, _body_node)
       end
 
       # This cop makes sure that a `test` block contains a proper test.
-      #
-      # @api private
       class Test < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          test = find_block(body_node, :test)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          test = find_block(formula_nodes.body_node, :test)
           return unless test
 
           if test.body.nil?
@@ -72,12 +72,14 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
 
     module FormulaAuditStrict
       # This cop makes sure that a `test` block exists.
-      #
-      # @api private
       class TestPresent < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          body_node = formula_nodes.body_node
           return if find_block(body_node, :test)
+          return if find_node_method_by_name(body_node, :disable!)
 
+          offending_node(formula_nodes.class_node) if body_node.nil?
           problem "A `test do` test block should be added"
         end
       end
diff --git a/Library/Homebrew/rubocops/compact_blank.rb b/Library/Homebrew/rubocops/compact_blank.rb
new file mode 100644
index 0000000000000..b020db3447bfd
--- /dev/null
+++ b/Library/Homebrew/rubocops/compact_blank.rb
@@ -0,0 +1,112 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Homebrew
+      # Checks if collection can be blank-compacted with `compact_blank`.
+      #
+      # NOTE: It is unsafe by default because false positives may occur in the
+      #       blank check of block arguments to the receiver object.
+      #
+      #       For example, `[[1, 2], [3, nil]].reject { |first, second| second.blank? }` and
+      #       `[[1, 2], [3, nil]].compact_blank` are not compatible. The same is true for `blank?`.
+      #       This will work fine when the receiver is a hash object.
+      #
+      #       And `compact_blank!` has different implementations for `Array`, `Hash` and
+      #       `ActionController::Parameters`.
+      #       `Array#compact_blank!`, `Hash#compact_blank!` are equivalent to `delete_if(&:blank?)`.
+      #       `ActionController::Parameters#compact_blank!` is equivalent to `reject!(&:blank?)`.
+      #       If the cop makes a mistake, autocorrected code may get unexpected behavior.
+      #
+      # ### Examples
+      #
+      # ```ruby
+      # # bad
+      # collection.reject(&:blank?)
+      # collection.reject { |_k, v| v.blank? }
+      #
+      # # good
+      # collection.compact_blank
+      # ```
+      #
+      # ```ruby
+      # # bad
+      # collection.delete_if(&:blank?)           # Same behavior as `Array#compact_blank!` and `Hash#compact_blank!`
+      # collection.delete_if { |_, v| v.blank? } # Same behavior as `Array#compact_blank!` and `Hash#compact_blank!`
+      # collection.reject!(&:blank?)             # Same behavior as `ActionController::Parameters#compact_blank!`
+      # collection.reject! { |_k, v| v.blank? }  # Same behavior as `ActionController::Parameters#compact_blank!`
+      #
+      # # good
+      # collection.compact_blank!
+      # ```
+      class CompactBlank < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = "Use `%<preferred_method>s` instead."
+
+        RESTRICT_ON_SEND = [:reject, :delete_if, :reject!].freeze
+
+        def_node_matcher :reject_with_block?, <<~PATTERN
+          (block
+            (send _ {:reject :delete_if :reject!})
+            $(args ...)
+            (send
+              $(lvar _) :blank?))
+        PATTERN
+
+        def_node_matcher :reject_with_block_pass?, <<~PATTERN
+          (send _ {:reject :delete_if :reject!}
+            (block_pass
+              (sym :blank?)))
+        PATTERN
+
+        def on_send(node)
+          return unless bad_method?(node)
+
+          range = offense_range(node)
+          preferred_method = preferred_method(node)
+          add_offense(range, message: format(MSG, preferred_method:)) do |corrector|
+            corrector.replace(range, preferred_method)
+          end
+        end
+
+        private
+
+        def bad_method?(node)
+          return true if reject_with_block_pass?(node)
+
+          if (arguments, receiver_in_block = reject_with_block?(node.parent))
+            return use_single_value_block_argument?(arguments, receiver_in_block) ||
+                   use_hash_value_block_argument?(arguments, receiver_in_block)
+          end
+
+          false
+        end
+
+        def use_single_value_block_argument?(arguments, receiver_in_block)
+          arguments.length == 1 && arguments[0].source == receiver_in_block.source
+        end
+
+        def use_hash_value_block_argument?(arguments, receiver_in_block)
+          arguments.length == 2 && arguments[1].source == receiver_in_block.source
+        end
+
+        def offense_range(node)
+          end_pos = if node.parent&.block_type? && node.parent&.send_node == node
+            node.parent.source_range.end_pos
+          else
+            node.source_range.end_pos
+          end
+
+          range_between(node.loc.selector.begin_pos, end_pos)
+        end
+
+        def preferred_method(node)
+          node.method?(:reject) ? "compact_blank" : "compact_blank!"
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/components_order.rb b/Library/Homebrew/rubocops/components_order.rb
index 094ef0bfce239..14ccb3973e8e9 100644
--- a/Library/Homebrew/rubocops/components_order.rb
+++ b/Library/Homebrew/rubocops/components_order.rb
@@ -1,8 +1,8 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "ast_constants"
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
@@ -14,13 +14,10 @@ module FormulaAudit
       class ComponentsOrder < FormulaCop
         extend AutoCorrector
 
-        def on_system_methods
-          @on_system_methods ||= [:intel, :arm, :macos, :linux, *MacOSVersions::SYMBOLS.keys].map do |m|
-            :"on_#{m}"
-          end
-        end
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
           @present_components, @offensive_nodes = check_order(FORMULA_COMPONENT_PRECEDENCE_LIST, body_node)
 
           component_problem @offensive_nodes[0], @offensive_nodes[1] if @offensive_nodes
@@ -31,6 +28,11 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
             [{ name: :patch, type: :method_call }, { name: :patch, type: :block_call }],
           ]
 
+          head_blocks = find_blocks(body_node, :head)
+          head_blocks.each do |head_block|
+            check_block_component_order(FORMULA_COMPONENT_PRECEDENCE_LIST, head_block)
+          end
+
           on_system_methods.each do |on_method|
             on_method_blocks = find_blocks(body_node, on_method)
             next if on_method_blocks.empty?
@@ -45,6 +47,8 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
 
           resource_blocks = find_blocks(body_node, :resource)
           resource_blocks.each do |resource_block|
+            check_block_component_order(FORMULA_COMPONENT_PRECEDENCE_LIST, resource_block)
+
             on_system_blocks = {}
 
             on_system_methods.each do |on_method|
@@ -62,7 +66,7 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
 
             @offensive_node = resource_block
 
-            on_system_bodies = []
+            on_system_bodies = T.let([], T::Array[[RuboCop::AST::BlockNode, RuboCop::AST::Node]])
 
             on_system_blocks.each_value do |blocks|
               blocks.each do |on_system_block|
@@ -72,7 +76,7 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
               end
             end
 
-            message = nil
+            message = T.let(nil, T.nilable(String))
             allowed_methods = [
               [:url, :sha256],
               [:url, :mirror, :sha256],
@@ -86,13 +90,13 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
               method_name = on_system_block.method_name
               child_nodes = on_system_body.begin_type? ? on_system_body.child_nodes : [on_system_body]
               if child_nodes.all? { |n| n.send_type? || n.block_type? || n.lvasgn_type? }
-                method_names = child_nodes.map do |node|
+                method_names = child_nodes.filter_map do |node|
                   next if node.lvasgn_type?
                   next if node.method_name == :patch
                   next if on_system_methods.include? node.method_name
 
                   node.method_name
-                end.compact
+                end
                 next if method_names.empty? || allowed_methods.include?(method_names)
               end
               offending_node(on_system_block)
@@ -101,7 +105,7 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
               break
             end
 
-            if message.present?
+            if message
               problem message
               next
             end
@@ -115,17 +119,31 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
           end
         end
 
+        def check_block_component_order(component_precedence_list, block)
+          @present_components, offensive_node = check_order(component_precedence_list, block.body)
+          component_problem(*offensive_node) if offensive_node
+        end
+
         def check_on_system_block_content(component_precedence_list, on_system_block)
+          if on_system_block.body.block_type? && !on_system_methods.include?(on_system_block.body.method_name)
+            offending_node(on_system_block)
+            problem "Nest `#{on_system_block.method_name}` blocks inside `#{on_system_block.body.method_name}` " \
+                    "blocks when there is only one inner block." do |corrector|
+              original_source = on_system_block.source.split("\n")
+              new_source = [original_source.second, original_source.first, *original_source.drop(2)]
+              corrector.replace(on_system_block.source_range, new_source.join("\n"))
+            end
+          end
           on_system_allowed_methods = %w[
-            depends_on
-            patch
-            resource
-            deprecate!
+            livecheck
+            keg_only
             disable!
+            deprecate!
+            depends_on
             conflicts_with
             fails_with
-            keg_only
-            ignore_missing_libraries
+            resource
+            patch
           ]
           on_system_allowed_methods += on_system_methods.map(&:to_s)
           _, offensive_node = check_order(component_precedence_list, on_system_block.body)
@@ -194,7 +212,7 @@ def check_order(component_precedence_list, body_node)
           end
 
           # Check if each present_components is above rest of the present_components
-          offensive_nodes = nil
+          offensive_nodes = T.let(nil, T.nilable(T::Array[RuboCop::AST::Node]))
           present_components.take(present_components.size - 1).each_with_index do |preceding_component, p_idx|
             next if preceding_component.empty?
 
@@ -209,13 +227,13 @@ def check_order(component_precedence_list, body_node)
         end
 
         # Method to report and correct component precedence violations.
-        def component_problem(c1, c2)
+        def component_problem(component1, component2)
           return if tap_style_exception? :components_order_exceptions
 
-          problem "`#{format_component(c1)}` (line #{line_number(c1)}) " \
-                  "should be put before `#{format_component(c2)}` " \
-                  "(line #{line_number(c2)})" do |corrector|
-            reorder_components(corrector, c1, c2)
+          problem "`#{format_component(component1)}` (line #{line_number(component1)}) " \
+                  "should be put before `#{format_component(component2)}` " \
+                  "(line #{line_number(component2)})" do |corrector|
+            reorder_components(corrector, component1, component2)
           end
         end
 
diff --git a/Library/Homebrew/rubocops/components_redundancy.rb b/Library/Homebrew/rubocops/components_redundancy.rb
index 767306c7596da..50557ab187cf4 100644
--- a/Library/Homebrew/rubocops/components_redundancy.rb
+++ b/Library/Homebrew/rubocops/components_redundancy.rb
@@ -1,25 +1,29 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
     module FormulaAudit
       # This cop checks if redundant components are present and for other component errors.
       #
-      # - `url|checksum|mirror` should be inside `stable` block
+      # - `url|checksum|mirror|version` should be inside `stable` block
       # - `head` and `head do` should not be simultaneously present
       # - `bottle :unneeded`/`:disable` and `bottle do` should not be simultaneously present
       # - `stable do` should not be present without a `head` spec
-      #
-      # @api private
+      # - `stable do` should not be present with only `url|checksum|mirror|version`
+      # - `head do` should not be present with only `url`
       class ComponentsRedundancy < FormulaCop
         HEAD_MSG = "`head` and `head do` should not be simultaneously present"
         BOTTLE_MSG = "`bottle :modifier` and `bottle do` should not be simultaneously present"
         STABLE_MSG = "`stable do` should not be present without a `head` spec"
+        STABLE_BLOCK_METHODS = [:url, :sha256, :mirror, :version].freeze
+
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
           urls = find_method_calls_by_name(body_node, :url)
 
           urls.each do |url|
@@ -35,9 +39,24 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
 
           stable_block = find_block(body_node, :stable)
           if stable_block
-            [:url, :sha256, :mirror].each do |method_name|
+            STABLE_BLOCK_METHODS.each do |method_name|
               problem "`#{method_name}` should be put inside `stable` block" if method_called?(body_node, method_name)
             end
+
+            unless stable_block.body.nil?
+              child_nodes = stable_block.body.begin_type? ? stable_block.body.child_nodes : [stable_block.body]
+              if child_nodes.all? { |n| n.send_type? && STABLE_BLOCK_METHODS.include?(n.method_name) }
+                problem "`stable do` should not be present with only #{STABLE_BLOCK_METHODS.join("/")}"
+              end
+            end
+          end
+
+          head_block = find_block(body_node, :head)
+          if head_block && !head_block.body.nil?
+            child_nodes = head_block.body.begin_type? ? head_block.body.child_nodes : [head_block.body]
+            if child_nodes.all? { |n| n.send_type? && n.method_name == :url }
+              problem "`head do` should not be present with only `url`"
+            end
           end
 
           problem HEAD_MSG if method_called?(body_node, :head) &&
diff --git a/Library/Homebrew/rubocops/conflicts.rb b/Library/Homebrew/rubocops/conflicts.rb
index 35bcf870965e8..36eadf0465acf 100644
--- a/Library/Homebrew/rubocops/conflicts.rb
+++ b/Library/Homebrew/rubocops/conflicts.rb
@@ -1,8 +1,7 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
-require "extend/string"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
@@ -14,7 +13,10 @@ class Conflicts < FormulaCop
         MSG = "Versioned formulae should not use `conflicts_with`. " \
               "Use `keg_only :versioned_formula` instead."
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
           find_method_calls_by_name(body_node, :conflicts_with).each do |conflicts_with_call|
             next unless parameters(conflicts_with_call).last.respond_to? :values
 
diff --git a/Library/Homebrew/rubocops/dependency_order.rb b/Library/Homebrew/rubocops/dependency_order.rb
index fc12fe4119a19..3f9a343d6d64f 100644
--- a/Library/Homebrew/rubocops/dependency_order.rb
+++ b/Library/Homebrew/rubocops/dependency_order.rb
@@ -1,7 +1,7 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
@@ -13,10 +13,13 @@ module FormulaAudit
       class DependencyOrder < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          body_node = formula_nodes.body_node
+
           check_dependency_nodes_order(body_node)
           check_uses_from_macos_nodes_order(body_node)
-          [:head, :stable].each do |block_name|
+          ([:head, :stable] + on_system_methods).each do |block_name|
             block = find_block(body_node, block_name)
             next unless block
 
@@ -65,15 +68,17 @@ def sort_dependencies_by_type(dependency_nodes)
         # `depends_on :apple if build.with? "foo"` should always be defined
         #  after `depends_on :foo`.
         # This method reorders the dependencies array according to the above rule.
+        sig { params(ordered: T::Array[RuboCop::AST::Node]).returns(T::Array[RuboCop::AST::Node]) }
         def sort_conditional_dependencies!(ordered)
           length = ordered.size
           idx = 0
           while idx < length
-            idx1, idx2 = nil
+            idx1 = T.let(nil, T.nilable(Integer))
+            idx2 = T.let(nil, T.nilable(Integer))
             ordered.each_with_index do |dep, pos|
               idx = pos+1
               match_nodes = build_with_dependency_name(dep)
-              next if !match_nodes || match_nodes.empty?
+              next if match_nodes.blank?
 
               idx1 = pos
               ordered.drop(idx1+1).each_with_index do |dep2, pos2|
@@ -83,7 +88,7 @@ def sort_conditional_dependencies!(ordered)
               end
               break if idx2
             end
-            insert_after!(ordered, idx1, idx2+idx1) if idx2
+            insert_after!(ordered, idx1, idx2 + T.must(idx1)) if idx2
           end
           ordered
         end
@@ -93,8 +98,8 @@ def sort_conditional_dependencies!(ordered)
         def verify_order_in_source(ordered)
           ordered.each_with_index do |node_1, idx|
             l1 = line_number(node_1)
-            l2 = nil
-            node_2 = nil
+            l2 = T.let(nil, T.nilable(Integer))
+            node_2 = T.let(nil, T.nilable(RuboCop::AST::Node))
             ordered.drop(idx + 1).each do |test_node|
               l2 = line_number(test_node)
               node_2 = test_node if l2 < l1
@@ -153,7 +158,7 @@ def insert_after!(arr, idx1, idx2)
 
         def build_with_dependency_name(node)
           match_nodes = build_with_dependency_node(node)
-          match_nodes = match_nodes.to_a.delete_if(&:nil?)
+          match_nodes = match_nodes.to_a.compact
           match_nodes.map { |n| string_content(n) } unless match_nodes.empty?
         end
 
diff --git a/Library/Homebrew/rubocops/deprecate_disable.rb b/Library/Homebrew/rubocops/deprecate_disable.rb
index 53c714123af08..127ec5de57fac 100644
--- a/Library/Homebrew/rubocops/deprecate_disable.rb
+++ b/Library/Homebrew/rubocops/deprecate_disable.rb
@@ -1,7 +1,7 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
@@ -10,7 +10,10 @@ module FormulaAudit
       class DeprecateDisableDate < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          body_node = formula_nodes.body_node
+
           [:deprecate!, :disable!].each do |method|
             node = find_node_method_by_name(body_node, method)
 
@@ -39,7 +42,10 @@ class DeprecateDisableReason < FormulaCop
 
         PUNCTUATION_MARKS = %w[. ! ?].freeze
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          body_node = formula_nodes.body_node
+
           [:deprecate!, :disable!].each do |method|
             node = find_node_method_by_name(body_node, method)
 
diff --git a/Library/Homebrew/rubocops/desc.rb b/Library/Homebrew/rubocops/desc.rb
new file mode 100644
index 0000000000000..c68ac5d8e8511
--- /dev/null
+++ b/Library/Homebrew/rubocops/desc.rb
@@ -0,0 +1,28 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "rubocops/extend/formula_cop"
+require "rubocops/shared/desc_helper"
+
+module RuboCop
+  module Cop
+    module FormulaAudit
+      # This cop audits `desc` in formulae.
+      # See the {DescHelper} module for details of the checks.
+      class Desc < FormulaCop
+        include DescHelper
+        extend AutoCorrector
+
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          body_node = formula_nodes.body_node
+
+          @name = @formula_name
+          desc_call = find_node_method_by_name(body_node, :desc)
+          offending_node(formula_nodes.class_node) if body_node.nil?
+          audit_desc(:formula, @name, desc_call)
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/extend/formula.rb b/Library/Homebrew/rubocops/extend/formula.rb
deleted file mode 100644
index e6cc658350527..0000000000000
--- a/Library/Homebrew/rubocops/extend/formula.rb
+++ /dev/null
@@ -1,203 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "extend/string"
-require "rubocops/shared/helper_functions"
-
-module RuboCop
-  module Cop
-    # Superclass for all formula cops.
-    #
-    # @api private
-    class FormulaCop < Base
-      include RangeHelp
-      include HelperFunctions
-
-      attr_accessor :file_path
-
-      @registry = Cop.registry
-
-      # This method is called by RuboCop and is the main entry point.
-      def on_class(node)
-        @file_path = processed_source.buffer.name
-        return unless file_path_allowed?
-        return unless formula_class?(node)
-        return unless respond_to?(:audit_formula)
-
-        class_node, parent_class_node, @body = *node
-        @formula_name = Pathname.new(@file_path).basename(".rb").to_s
-        @tap_style_exceptions = nil
-        audit_formula(node, class_node, parent_class_node, @body)
-      end
-
-      # Yields to block when there is a match.
-      #
-      # @param urls [Array] url/mirror method call nodes
-      # @param regex [Regexp] pattern to match URLs
-      def audit_urls(urls, regex)
-        urls.each_with_index do |url_node, index|
-          url_string_node = parameters(url_node).first
-          url_string = string_content(url_string_node)
-          match_object = regex_match_group(url_string_node, regex)
-          next unless match_object
-
-          offending_node(url_string_node.parent)
-          yield match_object, url_string, index
-        end
-      end
-
-      # Returns nil if does not depend on dependency_name.
-      #
-      # @param dependency_name dependency's name
-      def depends_on?(dependency_name, *types)
-        types = [:any] if types.empty?
-        dependency_nodes = find_every_method_call_by_name(@body, :depends_on)
-        idx = dependency_nodes.index do |n|
-          types.any? { |type| depends_on_name_type?(n, dependency_name, type) }
-        end
-        return if idx.nil?
-
-        @offensive_node = dependency_nodes[idx]
-      end
-
-      # Returns true if given dependency name and dependency type exist in given dependency method call node.
-      # TODO: Add case where key of hash is an array
-      def depends_on_name_type?(node, name = nil, type = :required)
-        name_match = if name
-          false
-        else
-          true # Match only by type when name is nil
-        end
-
-        case type
-        when :required
-          type_match = required_dependency?(node)
-          name_match ||= required_dependency_name?(node, name) if type_match
-        when :build, :test, :optional, :recommended
-          type_match = dependency_type_hash_match?(node, type)
-          name_match ||= dependency_name_hash_match?(node, name) if type_match
-        when :any
-          type_match = true
-          name_match ||= required_dependency_name?(node, name)
-          name_match ||= dependency_name_hash_match?(node, name)
-        else
-          type_match = false
-        end
-
-        @offensive_node = node if type_match || name_match
-        type_match && name_match
-      end
-
-      def_node_search :required_dependency?, <<~EOS
-        (send nil? :depends_on ({str sym} _))
-      EOS
-
-      def_node_search :required_dependency_name?, <<~EOS
-        (send nil? :depends_on ({str sym} %1))
-      EOS
-
-      def_node_search :dependency_type_hash_match?, <<~EOS
-        (hash (pair ({str sym} _) ({str sym} %1)))
-      EOS
-
-      def_node_search :dependency_name_hash_match?, <<~EOS
-        (hash (pair ({str sym} %1) (...)))
-      EOS
-
-      # Return all the caveats' string nodes in an array.
-      def caveats_strings
-        find_strings(find_method_def(@body, :caveats))
-      end
-
-      # Returns the sha256 str node given a sha256 call node.
-      def get_checksum_node(call)
-        return if parameters(call).empty? || parameters(call).nil?
-
-        if parameters(call).first.str_type?
-          parameters(call).first
-        # sha256 is passed as a key-value pair in bottle blocks
-        elsif parameters(call).first.hash_type?
-          if parameters(call).first.keys.first.value == :cellar
-            # sha256 :cellar :any, :tag "hexdigest"
-            parameters(call).first.values.last
-          elsif parameters(call).first.keys.first.is_a?(RuboCop::AST::SymbolNode)
-            # sha256 :tag "hexdigest"
-            parameters(call).first.values.first
-          else
-            # Legacy bottle block syntax
-            # sha256 "hexdigest" => :tag
-            parameters(call).first.keys.first
-          end
-        end
-      end
-
-      # Yields to a block with comment text as parameter.
-      def audit_comments
-        processed_source.comments.each do |comment_node|
-          @offensive_node = comment_node
-          yield comment_node.text
-        end
-      end
-
-      # Returns true if the formula is versioned.
-      def versioned_formula?
-        @formula_name.include?("@")
-      end
-
-      # Returns the formula tap.
-      def formula_tap
-        return unless (match_obj = @file_path.match(%r{/(homebrew-\w+)/}))
-
-        match_obj[1]
-      end
-
-      # Returns whether the given formula exists in the given style exception list.
-      # Defaults to the current formula being checked.
-      def tap_style_exception?(list, formula = nil)
-        if @tap_style_exceptions.nil? && !formula_tap.nil?
-          @tap_style_exceptions = {}
-
-          style_exceptions_dir = "#{File.dirname(File.dirname(@file_path))}/style_exceptions/*.json"
-          Pathname.glob(style_exceptions_dir).each do |exception_file|
-            list_name = exception_file.basename.to_s.chomp(".json").to_sym
-            list_contents = begin
-              JSON.parse exception_file.read
-            rescue JSON::ParserError
-              nil
-            end
-            next if list_contents.nil? || list_contents.count.zero?
-
-            @tap_style_exceptions[list_name] = list_contents
-          end
-        end
-
-        return false if @tap_style_exceptions.nil? || @tap_style_exceptions.count.zero?
-        return false unless @tap_style_exceptions.key? list
-
-        @tap_style_exceptions[list].include?(formula || @formula_name)
-      end
-
-      private
-
-      def formula_class?(node)
-        _, class_node, = *node
-        class_names = %w[
-          Formula
-          GithubGistFormula
-          ScriptFileFormula
-          AmazonWebServicesFormula
-        ]
-
-        class_node && class_names.include?(string_content(class_node))
-      end
-
-      def file_path_allowed?
-        paths_to_exclude = [%r{/Library/Homebrew/compat/},
-                            %r{/Library/Homebrew/test/}]
-        return true if @file_path.nil? # file_path is nil when source is directly passed to the cop, e.g. in specs
-
-        @file_path !~ Regexp.union(paths_to_exclude)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/rubocops/extend/formula_cop.rb b/Library/Homebrew/rubocops/extend/formula_cop.rb
new file mode 100644
index 0000000000000..bc771d852340d
--- /dev/null
+++ b/Library/Homebrew/rubocops/extend/formula_cop.rb
@@ -0,0 +1,242 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "rubocops/shared/helper_functions"
+
+module RuboCop
+  module Cop
+    # Abstract base class for all formula cops.
+    class FormulaCop < Base
+      extend T::Helpers
+      include RangeHelp
+      include HelperFunctions
+
+      abstract!
+      exclude_from_registry
+
+      attr_accessor :file_path
+
+      @registry = Registry.global
+
+      class FormulaNodes < T::Struct
+        prop :node, RuboCop::AST::ClassNode
+        prop :class_node, RuboCop::AST::ConstNode
+        prop :parent_class_node, RuboCop::AST::ConstNode
+        prop :body_node, RuboCop::AST::Node
+      end
+
+      # This method is called by RuboCop and is the main entry point.
+      def on_class(node)
+        @file_path = processed_source.file_path
+        return unless file_path_allowed?
+        return unless formula_class?(node)
+
+        class_node, parent_class_node, @body = *node
+        @formula_name = Pathname.new(@file_path).basename(".rb").to_s
+        @tap_style_exceptions = nil
+        audit_formula(FormulaNodes.new(node:, class_node:, parent_class_node:, body_node: @body))
+      end
+
+      sig { abstract.params(formula_nodes: FormulaNodes).void }
+      def audit_formula(formula_nodes); end
+
+      # Yields to block when there is a match.
+      #
+      # @param urls [Array] url/mirror method call nodes
+      # @param regex [Regexp] pattern to match URLs
+      def audit_urls(urls, regex)
+        urls.each_with_index do |url_node, index|
+          url_string_node = parameters(url_node).first
+          url_string = string_content(url_string_node)
+          match_object = regex_match_group(url_string_node, regex)
+          next unless match_object
+
+          offending_node(url_string_node.parent)
+          yield match_object, url_string, index
+        end
+      end
+
+      # Returns if the formula depends on dependency_name.
+      #
+      # @param dependency_name dependency's name
+      def depends_on?(dependency_name, *types)
+        return false if @body.nil?
+
+        types = [:any] if types.empty?
+        dependency_nodes = find_every_method_call_by_name(@body, :depends_on)
+        idx = dependency_nodes.index do |n|
+          types.any? { |type| depends_on_name_type?(n, dependency_name, type) }
+        end
+        return false if idx.nil?
+
+        @offensive_node = dependency_nodes[idx]
+
+        true
+      end
+
+      # Returns true if given dependency name and dependency type exist in given dependency method call node.
+      # TODO: Add case where key of hash is an array
+      def depends_on_name_type?(node, name = nil, type = :required)
+        name_match = !name # Match only by type when name is nil
+
+        case type
+        when :required
+          type_match = required_dependency?(node)
+          name_match ||= required_dependency_name?(node, name) if type_match
+        when :build, :test, :optional, :recommended
+          type_match = dependency_type_hash_match?(node, type)
+          name_match ||= dependency_name_hash_match?(node, name) if type_match
+        when :any
+          type_match = true
+          name_match ||= required_dependency_name?(node, name)
+          name_match ||= dependency_name_hash_match?(node, name)
+        else
+          type_match = false
+        end
+
+        @offensive_node = node if type_match || name_match
+        type_match && name_match
+      end
+
+      def_node_search :required_dependency?, <<~EOS
+        (send nil? :depends_on ({str sym} _))
+      EOS
+
+      def_node_search :required_dependency_name?, <<~EOS
+        (send nil? :depends_on ({str sym} %1))
+      EOS
+
+      def_node_search :dependency_type_hash_match?, <<~EOS
+        (hash (pair ({str sym} _) ({str sym} %1)))
+      EOS
+
+      def_node_search :dependency_name_hash_match?, <<~EOS
+        (hash (pair ({str sym} %1) (...)))
+      EOS
+
+      # Return all the caveats' string nodes in an array.
+      def caveats_strings
+        return [] if @body.nil?
+
+        find_strings(find_method_def(@body, :caveats))
+      end
+
+      # Returns the sha256 str node given a sha256 call node.
+      def get_checksum_node(call)
+        return if parameters(call).empty? || parameters(call).nil?
+
+        if parameters(call).first.str_type?
+          parameters(call).first
+        # sha256 is passed as a key-value pair in bottle blocks
+        elsif parameters(call).first.hash_type?
+          if parameters(call).first.keys.first.value == :cellar
+            # sha256 :cellar :any, :tag "hexdigest"
+            parameters(call).first.values.last
+          elsif parameters(call).first.keys.first.is_a?(RuboCop::AST::SymbolNode)
+            # sha256 :tag "hexdigest"
+            parameters(call).first.values.first
+          else
+            # Legacy bottle block syntax
+            # sha256 "hexdigest" => :tag
+            parameters(call).first.keys.first
+          end
+        end
+      end
+
+      # Yields to a block with comment text as parameter.
+      def audit_comments
+        processed_source.comments.each do |comment_node|
+          @offensive_node = comment_node
+          yield comment_node.text
+        end
+      end
+
+      # Returns true if the formula is versioned.
+      def versioned_formula?
+        @formula_name.include?("@")
+      end
+
+      # Returns the formula tap.
+      def formula_tap
+        return unless (match_obj = @file_path.match(%r{/(homebrew-\w+)/}))
+
+        match_obj[1]
+      end
+
+      # Returns the style exceptions directory from the file path.
+      def style_exceptions_dir
+        file_directory = File.dirname(@file_path)
+
+        # if we're in a sharded subdirectory, look below that.
+        directory_name = File.basename(file_directory)
+        formula_directory = if directory_name.length == 1 || directory_name == "lib"
+          File.dirname(file_directory)
+        else
+          file_directory
+        end
+
+        # if we're in a Formula or HomebrewFormula subdirectory, look below that.
+        formula_directory_names = ["Formula", "HomebrewFormula"].freeze
+        directory_name = File.basename(formula_directory)
+        tap_root_directory = if formula_directory_names.include?(directory_name)
+          File.dirname(formula_directory)
+        else
+          formula_directory
+        end
+
+        "#{tap_root_directory}/style_exceptions"
+      end
+
+      # Returns whether the given formula exists in the given style exception list.
+      # Defaults to the current formula being checked.
+      def tap_style_exception?(list, formula = nil)
+        if @tap_style_exceptions.nil? && !formula_tap.nil?
+          @tap_style_exceptions = {}
+
+          Pathname.glob("#{style_exceptions_dir}/*.json").each do |exception_file|
+            list_name = exception_file.basename.to_s.chomp(".json").to_sym
+            list_contents = begin
+              JSON.parse exception_file.read
+            rescue JSON::ParserError
+              nil
+            end
+            next if list_contents.nil? || list_contents.count.zero?
+
+            @tap_style_exceptions[list_name] = list_contents
+          end
+        end
+
+        return false if @tap_style_exceptions.nil? || @tap_style_exceptions.count.zero?
+        return false unless @tap_style_exceptions.key? list
+
+        @tap_style_exceptions[list].include?(formula || @formula_name)
+      end
+
+      private
+
+      def formula_class?(node)
+        _, class_node, = *node
+        class_names = %w[
+          Formula
+          GithubGistFormula
+          ScriptFileFormula
+          AmazonWebServicesFormula
+        ]
+
+        class_node && class_names.include?(string_content(class_node))
+      end
+
+      def file_path_allowed?
+        return true if @file_path.nil? # file_path is nil when source is directly passed to the cop, e.g. in specs
+
+        !@file_path.include?("/Library/Homebrew/test/")
+      end
+
+      def on_system_methods
+        @on_system_methods ||= [:intel, :arm, :macos, :linux, :system, *MacOSVersion::SYMBOLS.keys].map do |m|
+          :"on_#{m}"
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/extend/mutable_constant_exclude_unfreezable.rb b/Library/Homebrew/rubocops/extend/mutable_constant_exclude_unfreezable.rb
new file mode 100644
index 0000000000000..5c261a4c36417
--- /dev/null
+++ b/Library/Homebrew/rubocops/extend/mutable_constant_exclude_unfreezable.rb
@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rubocop/cop/style/mutable_constant"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # TODO: delete this file when https://github.com/Shopify/rubocop-sorbet/pull/256 is available
+      module MutableConstantExcludeUnfreezable
+        class << self
+          sig { params(base: RuboCop::AST::NodePattern::Macros).void }
+          def prepended(base)
+            base.def_node_matcher(:t_let, <<~PATTERN)
+              (send (const nil? :T) :let $_constant _type)
+            PATTERN
+
+            base.def_node_matcher(:t_type_alias?, <<~PATTERN)
+              (block (send (const {nil? cbase} :T) :type_alias ...) ...)
+            PATTERN
+
+            base.def_node_matcher(:type_member?, <<~PATTERN)
+              (block (send nil? :type_member ...) ...)
+            PATTERN
+          end
+        end
+
+        sig { params(value: RuboCop::AST::Node).void }
+        def on_assignment(value)
+          T.unsafe(self).t_let(value) do |constant|
+            value = T.let(constant, RuboCop::AST::Node)
+          end
+          return if T.unsafe(self).t_type_alias?(value)
+          return if T.unsafe(self).type_member?(value)
+
+          super
+        end
+      end
+    end
+  end
+end
+
+RuboCop::Cop::Style::MutableConstant.prepend(
+  RuboCop::Cop::Sorbet::MutableConstantExcludeUnfreezable,
+)
diff --git a/Library/Homebrew/rubocops/files.rb b/Library/Homebrew/rubocops/files.rb
index 7ee1de87d5037..ef1e6b6091913 100644
--- a/Library/Homebrew/rubocops/files.rb
+++ b/Library/Homebrew/rubocops/files.rb
@@ -1,25 +1,27 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
     module FormulaAudit
       # This cop makes sure that a formula's file permissions are correct.
-      #
-      # @api private
       class Files < FormulaCop
-        def audit_formula(node, _class_node, _parent_class_node, _body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
           return unless file_path
 
-          offending_node(node)
+          # Codespaces routinely screws up all permissions so don't complain there.
+          return if ENV["CODESPACES"] || ENV["HOMEBREW_CODESPACES"]
+
+          offending_node(formula_nodes.node)
           actual_mode = File.stat(file_path).mode
           # Check that the file is world-readable.
           if actual_mode & 0444 != 0444
             problem format("Incorrect file permissions (%03<actual>o): chmod %<wanted>s %<path>s",
                            actual: actual_mode & 0777,
-                           wanted: "+r",
+                           wanted: "a+r",
                            path:   file_path)
           end
           # Check that the file is user-writeable.
diff --git a/Library/Homebrew/rubocops/formula_desc.rb b/Library/Homebrew/rubocops/formula_desc.rb
deleted file mode 100644
index 11dfefd3b0c42..0000000000000
--- a/Library/Homebrew/rubocops/formula_desc.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "rubocops/extend/formula"
-require "rubocops/shared/desc_helper"
-require "extend/string"
-
-module RuboCop
-  module Cop
-    module FormulaAudit
-      # This cop audits `desc` in formulae.
-      # See the {DescHelper} module for details of the checks.
-      class Desc < FormulaCop
-        include DescHelper
-        extend AutoCorrector
-
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          @name = @formula_name
-          desc_call = find_node_method_by_name(body_node, :desc)
-          audit_desc(:formula, @name, desc_call)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/rubocops/homepage.rb b/Library/Homebrew/rubocops/homepage.rb
index 700060ed81bbc..618fc800f8afe 100644
--- a/Library/Homebrew/rubocops/homepage.rb
+++ b/Library/Homebrew/rubocops/homepage.rb
@@ -1,103 +1,33 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
+require "rubocops/shared/homepage_helper"
 
 module RuboCop
   module Cop
     module FormulaAudit
       # This cop audits the `homepage` URL in formulae.
       class Homepage < FormulaCop
+        include HomepageHelper
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          body_node = formula_nodes.body_node
           homepage_node = find_node_method_by_name(body_node, :homepage)
 
           if homepage_node.nil?
+            offending_node(formula_nodes.class_node) if body_node.nil?
             problem "Formula should have a homepage."
             return
           end
 
           homepage_parameter_node = parameters(homepage_node).first
           offending_node(homepage_parameter_node)
-          homepage = string_content(homepage_parameter_node)
+          content = string_content(homepage_parameter_node)
 
-          problem "Formula should have a homepage." if homepage.empty?
-
-          problem "The homepage should start with http or https." unless homepage.match?(%r{^https?://})
-
-          case homepage
-          # Freedesktop is complicated to handle - It has SSL/TLS, but only on certain subdomains.
-          # To enable https Freedesktop change the URL from http://project.freedesktop.org/wiki to
-          # https://wiki.freedesktop.org/project_name.
-          # "Software" is redirected to https://wiki.freedesktop.org/www/Software/project_name
-          when %r{^http://((?:www|nice|libopenraw|liboil|telepathy|xorg)\.)?freedesktop\.org/(?:wiki/)?}
-            if homepage.include?("Software")
-              problem "Freedesktop homepages should be styled " \
-                      "`https://wiki.freedesktop.org/www/Software/project_name`"
-            else
-              problem "Freedesktop homepages should be styled `https://wiki.freedesktop.org/project_name`"
-            end
-
-          # Google Code homepages should end in a slash
-          when %r{^https?://code\.google\.com/p/[^/]+[^/]$}
-            problem "Google Code homepages should end with a slash" do |corrector|
-              corrector.replace(homepage_parameter_node.source_range, "\"#{homepage}/\"")
-            end
-
-          when %r{^http://([^/]*)\.(sf|sourceforge)\.net(/|$)}
-            fixed = "https://#{Regexp.last_match(1)}.sourceforge.io/"
-            problem "Sourceforge homepages should be `#{fixed}`" do |corrector|
-              corrector.replace(homepage_parameter_node.source_range, "\"#{fixed}\"")
-            end
-
-          when /readthedocs\.org/
-            fixed = homepage.sub("readthedocs.org", "readthedocs.io")
-            problem "Readthedocs homepages should be `#{fixed}`" do |corrector|
-              corrector.replace(homepage_parameter_node.source_range, "\"#{fixed}\"")
-            end
-
-          when %r{^https://github.com.*\.git$}
-            problem "GitHub homepages should not end with .git" do |corrector|
-              corrector.replace(homepage_parameter_node.source_range, "\"#{homepage.delete_suffix(".git")}\"")
-            end
-
-          # People will run into mixed content sometimes, but we should enforce and then add
-          # exemptions as they are discovered. Treat mixed content on homepages as a bug.
-          # Justify each exemptions with a code comment so we can keep track here.
-          #
-          # Compact the above into this list as we're able to remove detailed notations, etc over time.
-          when
-               # Check for http:// GitHub homepage URLs, https:// is preferred.
-               # Note: only check homepages that are repo pages, not *.github.com hosts
-               %r{^http://github\.com/},
-               %r{^http://[^/]*\.github\.io/},
-
-               # Savannah has full SSL/TLS support but no auto-redirect.
-               # Doesn't apply to the download URLs, only the homepage.
-               %r{^http://savannah\.nongnu\.org/},
-
-               %r{^http://[^/]*\.sourceforge\.io/},
-               # There's an auto-redirect here, but this mistake is incredibly common too.
-               # Only applies to the homepage and subdomains for now, not the FTP URLs.
-               %r{^http://((?:build|cloud|developer|download|extensions|git|
-                               glade|help|library|live|nagios|news|people|
-                               projects|rt|static|wiki|www)\.)?gnome\.org}x,
-               %r{^http://[^/]*\.apache\.org},
-               %r{^http://packages\.debian\.org},
-               %r{^http://wiki\.freedesktop\.org/},
-               %r{^http://((?:www)\.)?gnupg\.org/},
-               %r{^http://ietf\.org},
-               %r{^http://[^/.]+\.ietf\.org},
-               %r{^http://[^/.]+\.tools\.ietf\.org},
-               %r{^http://www\.gnu\.org/},
-               %r{^http://code\.google\.com/},
-               %r{^http://bitbucket\.org/},
-               %r{^http://(?:[^/]*\.)?archive\.org}
-            problem "Please use https:// for #{homepage}" do |corrector|
-              corrector.replace(homepage_parameter_node.source_range, "\"#{homepage.sub("http", "https")}\"")
-            end
-          end
+          audit_homepage(:formula, content, homepage_node, homepage_parameter_node)
         end
       end
     end
diff --git a/Library/Homebrew/rubocops/install_bundler_gems.rb b/Library/Homebrew/rubocops/install_bundler_gems.rb
new file mode 100644
index 0000000000000..f10bf15f9d2f1
--- /dev/null
+++ b/Library/Homebrew/rubocops/install_bundler_gems.rb
@@ -0,0 +1,21 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Homebrew
+      # Enforces the use of `Homebrew.install_bundler_gems!` in dev-cmd.
+      class InstallBundlerGems < Base
+        MSG = "Only use `Homebrew.install_bundler_gems!` in dev-cmd."
+        RESTRICT_ON_SEND = [:install_bundler_gems!].freeze
+
+        def on_send(node)
+          file_path = processed_source.file_path
+          return if file_path.match?(%r{/(dev-cmd/.+|standalone/init|startup/bootsnap)\.rb\z})
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/io_read.rb b/Library/Homebrew/rubocops/io_read.rb
index 3db249031e469..7e20f3e7b5598 100644
--- a/Library/Homebrew/rubocops/io_read.rb
+++ b/Library/Homebrew/rubocops/io_read.rb
@@ -1,14 +1,13 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Homebrew
-      # This cop restricts usage of IO.read functions for security reasons.
-      #
-      # @api private
+      # This cop restricts usage of `IO.read` functions for security reasons.
       class IORead < Base
         MSG = "The use of `IO.%<method>s` is a security risk."
+
         RESTRICT_ON_SEND = [:read, :readlines].freeze
 
         def on_send(node)
diff --git a/Library/Homebrew/rubocops/keg_only.rb b/Library/Homebrew/rubocops/keg_only.rb
index ea2bd9131d877..765f05ba3b56d 100644
--- a/Library/Homebrew/rubocops/keg_only.rb
+++ b/Library/Homebrew/rubocops/keg_only.rb
@@ -1,19 +1,18 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
     module FormulaAudit
       # This cop makes sure that a `keg_only` reason has the correct format.
-      #
-      # @api private
       class KegOnly < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          keg_only_node = find_node_method_by_name(body_node, :keg_only)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          keg_only_node = find_node_method_by_name(formula_nodes.body_node, :keg_only)
           return unless keg_only_node
 
           allowlist = %w[
@@ -34,7 +33,7 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
           reason = string_content(reason).sub(name, "")
           first_word = reason.split.first
 
-          if reason =~ /\A[A-Z]/ && !reason.start_with?(*allowlist)
+          if /\A[A-Z]/.match?(reason) && !reason.start_with?(*allowlist)
             problem "'#{first_word}' from the `keg_only` reason should be '#{first_word.downcase}'." do |corrector|
               reason[0] = reason[0].downcase
               corrector.replace(@offensive_node.source_range, "\"#{reason}\"")
diff --git a/Library/Homebrew/rubocops/lines.rb b/Library/Homebrew/rubocops/lines.rb
index e8c7a631a3128..599e31d6505c1 100644
--- a/Library/Homebrew/rubocops/lines.rb
+++ b/Library/Homebrew/rubocops/lines.rb
@@ -1,17 +1,17 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "macos_versions"
-require "rubocops/extend/formula"
+require "macos_version"
+require "rubocops/extend/formula_cop"
+require "rubocops/shared/on_system_conditionals_helper"
 
 module RuboCop
   module Cop
     module FormulaAudit
       # This cop checks for various miscellaneous Homebrew coding styles.
-      #
-      # @api private
       class Lines < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, _body_node)
+        sig { override.params(_formula_nodes: FormulaNodes).void }
+        def audit_formula(_formula_nodes)
           [:automake, :ant, :autoconf, :emacs, :expat, :libtool, :mysql, :perl,
            :postgresql, :python, :python3, :rbenv, :ruby].each do |dependency|
             next unless depends_on?(dependency)
@@ -31,13 +31,13 @@ def audit_formula(_node, _class_node, _parent_class_node, _body_node)
       end
 
       # This cop makes sure that a space is used for class inheritance.
-      #
-      # @api private
       class ClassInheritance < FormulaCop
-        def audit_formula(_node, class_node, parent_class_node, _body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          parent_class_node = formula_nodes.parent_class_node
           begin_pos = start_column(parent_class_node)
-          end_pos = end_column(class_node)
-          return unless begin_pos-end_pos != 3
+          end_pos = end_column(formula_nodes.class_node)
+          return if begin_pos-end_pos == 3
 
           problem "Use a space in class inheritance: " \
                   "class #{@formula_name.capitalize} < #{class_name(parent_class_node)}"
@@ -45,10 +45,9 @@ def audit_formula(_node, class_node, parent_class_node, _body_node)
       end
 
       # This cop makes sure that template comments are removed.
-      #
-      # @api private
       class Comments < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, _body_node)
+        sig { override.params(_formula_nodes: FormulaNodes).void }
+        def audit_formula(_formula_nodes)
           audit_comments do |comment|
             [
               "# PLEASE REMOVE",
@@ -86,10 +85,11 @@ def audit_formula(_node, _class_node, _parent_class_node, _body_node)
       end
 
       # This cop makes sure that idiomatic `assert_*` statements are used.
-      #
-      # @api private
       class AssertStatements < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
           find_every_method_call_by_name(body_node, :assert).each do |method|
             if method_called_ever?(method, :include?) && !method_called_ever?(method, :!)
               problem "Use `assert_match` instead of `assert ...include?`"
@@ -111,10 +111,11 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
       end
 
       # This cop makes sure that `option`s are used idiomatically.
-      #
-      # @api private
       class OptionDeclarations < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
           problem "Use new-style option definitions" if find_method_def(body_node, :options)
 
           if formula_tap == "homebrew-core"
@@ -194,14 +195,15 @@ def unless_modifier?(node)
       end
 
       # This cop makes sure that formulae depend on `open-mpi` instead of `mpich`.
-      #
-      # @api private
       class MpiCheck < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
           # Enforce use of OpenMPI for MPI dependency in core
-          return unless formula_tap == "homebrew-core"
+          return if formula_tap != "homebrew-core"
 
           find_method_with_args(body_node, :depends_on, "mpich") do
             problem "Formulae in homebrew/core should use 'depends_on \"open-mpi\"' " \
@@ -212,39 +214,85 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
         end
       end
 
-      # This cop makes sure that formulae do not depend on `pyoxidizer` at build-time
-      # or run-time.
-      #
-      # @api private
-      class PyoxidizerCheck < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          # Disallow use of PyOxidizer as a dependency in core
-          return unless formula_tap == "homebrew-core"
+      # This cop makes sure that formulae use `std_npm_args` instead of older
+      # `local_npm_install_args` and `std_npm_install_args`.
+      class StdNpmArgs < FormulaCop
+        extend AutoCorrector
 
-          find_method_with_args(body_node, :depends_on, "pyoxidizer") do
-            problem "Formulae in homebrew/core should not use '#{@offensive_node.source}'."
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
+          find_method_with_args(body_node, :local_npm_install_args) do
+            problem "Use 'std_npm_args' instead of '#{@offensive_node.method_name}'." do |corrector|
+              corrector.replace(@offensive_node.source_range, "std_npm_args(prefix: false)")
+            end
           end
 
-          [
-            :build,
-            [:build],
-            [:build, :test],
-            [:test, :build],
-          ].each do |type|
-            find_method_with_args(body_node, :depends_on, "pyoxidizer" => type) do
-              problem "Formulae in homebrew/core should not use '#{@offensive_node.source}'."
+          find_method_with_args(body_node, :std_npm_install_args) do |method|
+            problem "Use 'std_npm_args' instead of '#{@offensive_node.method_name}'." do |corrector|
+              if (param = parameters(method).first.source) == "libexec"
+                corrector.replace(@offensive_node.source_range, "std_npm_args")
+              else
+                corrector.replace(@offensive_node.source_range, "std_npm_args(prefix: #{param})")
+              end
             end
           end
+
+          find_every_method_call_by_name(body_node, :system).each do |method|
+            first_param, second_param = parameters(method)
+            next if !node_equals?(first_param, "npm") ||
+                    !node_equals?(second_param, "install") ||
+                    method.source.match(/(std_npm_args|local_npm_install_args|std_npm_install_args)/)
+
+            offending_node(method)
+            problem "Use `std_npm_args` for npm install"
+          end
+        end
+      end
+
+      # This cop makes sure that formulae depend on `openssl` instead of `quictls`.
+      class QuicTLSCheck < FormulaCop
+        extend AutoCorrector
+
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
+          # Enforce use of OpenSSL for TLS dependency in core
+          return if formula_tap != "homebrew-core"
+
+          find_method_with_args(body_node, :depends_on, "quictls") do
+            problem "Formulae in homebrew/core should use 'depends_on \"openssl@3\"' " \
+                    "instead of '#{@offensive_node.source}'." do |corrector|
+              corrector.replace(@offensive_node.source_range, "depends_on \"openssl@3\"")
+            end
+          end
+        end
+      end
+
+      # This cop makes sure that formulae do not depend on `pyoxidizer` at build-time
+      # or run-time.
+      class PyoxidizerCheck < FormulaCop
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if formula_nodes.body_node.nil?
+          # Disallow use of PyOxidizer as a dependency in core
+          return if formula_tap != "homebrew-core"
+          return unless depends_on?("pyoxidizer")
+
+          problem "Formulae in homebrew/core should not use '#{@offensive_node.source}'."
         end
       end
 
       # This cop makes sure that the safe versions of `popen_*` calls are used.
-      #
-      # @api private
       class SafePopenCommands < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
           test = find_block(body_node, :test)
 
           [:popen_read, :popen_write].each do |unsafe_command|
@@ -268,12 +316,13 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
       end
 
       # This cop makes sure that environment variables are passed correctly to `popen_*` calls.
-      #
-      # @api private
       class ShellVariables < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
           popen_commands = [
             :popen,
             :popen_read,
@@ -289,8 +338,7 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
               good_args = "Utils.#{command}({ \"#{match[1]}\" => \"#{match[2]}\" }, \"#{match[3]}\")"
 
               problem "Use `#{good_args}` instead of `#{method.source}`" do |corrector|
-                corrector.replace(@offensive_node.source_range,
-                                  "{ \"#{match[1]}\" => \"#{match[2]}\" }, \"#{match[3]}\"")
+                corrector.replace(method.source_range, good_args)
               end
             end
           end
@@ -298,12 +346,13 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
       end
 
       # This cop makes sure that `license` has the correct format.
-      #
-      # @api private
       class LicenseArrays < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
           license_node = find_node_method_by_name(body_node, :license)
           return unless license_node
 
@@ -317,10 +366,11 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
       end
 
       # This cop makes sure that nested `license` declarations are split onto multiple lines.
-      #
-      # @api private
       class Licenses < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
           license_node = find_node_method_by_name(body_node, :license)
           return unless license_node
           return if license_node.source.include?("\n")
@@ -338,19 +388,28 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
       end
 
       # This cop makes sure that Python versions are consistent.
-      #
-      # @api private
       class PythonVersions < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
           python_formula_node = find_every_method_call_by_name(body_node, :depends_on).find do |dep|
             string_content(parameters(dep).first).start_with? "python@"
           end
 
-          return if python_formula_node.blank?
+          python_version = if python_formula_node.blank?
+            other_python_nodes = find_every_method_call_by_name(body_node, :depends_on).select do |dep|
+              parameters(dep).first.instance_of?(RuboCop::AST::HashNode) &&
+                string_content(parameters(dep).first.keys.first).start_with?("python@")
+            end
+            return if other_python_nodes.size != 1
 
-          python_version = string_content(parameters(python_formula_node).first).split("@").last
+            string_content(parameters(other_python_nodes.first).first.keys.first).split("@").last
+          else
+            string_content(parameters(python_formula_node).first).split("@").last
+          end
 
           find_strings(body_node).each do |str|
             content = string_content(str)
@@ -374,107 +433,24 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
       end
 
       # This cop makes sure that OS conditionals are consistent.
-      #
-      # @api private
       class OnSystemConditionals < FormulaCop
+        include OnSystemConditionalsHelper
         extend AutoCorrector
 
         NO_ON_SYSTEM_METHOD_NAMES = [:install, :post_install].freeze
         NO_ON_SYSTEM_BLOCK_NAMES = [:service, :test].freeze
 
-        ON_ARCH_OPTIONS = [:intel, :arm].freeze
-        ON_BASE_OS_OPTIONS = [:macos, :linux].freeze
-        ON_MACOS_VERSION_OPTIONS = MacOSVersions::SYMBOLS.keys.freeze
-        ALL_SYSTEM_OPTIONS = [*ON_ARCH_OPTIONS, *ON_BASE_OS_OPTIONS, *ON_MACOS_VERSION_OPTIONS, :system].freeze
-
-        MACOS_VERSION_CONDITIONALS = {
-          "==" => nil,
-          "<=" => :or_older,
-          ">=" => :or_newer,
-        }.freeze
-
-        ON_SYSTEM_CONDITIONALS = [:<, :<=].freeze
-
-        def on_system_method_info(on_system_option)
-          info = {}
-          info[:method] = :"on_#{on_system_option}"
-          info[:if_module], info[:if_method] = if ON_ARCH_OPTIONS.include?(on_system_option)
-            ["Hardware::CPU", :"#{on_system_option}?"]
-          elsif ON_BASE_OS_OPTIONS.include?(on_system_option)
-            ["OS", on_system_option == :macos ? :mac? : :linux?]
-          else
-            ["MacOS", :version]
-          end
-          info[:on_system_string] = "on_#{on_system_option}"
-          info[:if_string] = if on_system_option == :system
-            "if OS.linux? || MacOS.version"
-          else
-            "if #{info[:if_module]}.#{info[:if_method]}"
-          end
-
-          info
-        end
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          body_node = formula_nodes.body_node
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          top_level_nodes_to_check = []
           NO_ON_SYSTEM_METHOD_NAMES.each do |formula_method_name|
             method_node = find_method_def(body_node, formula_method_name)
-            top_level_nodes_to_check << [formula_method_name, method_node] if method_node
+            audit_on_system_blocks(method_node, formula_method_name) if method_node
           end
           NO_ON_SYSTEM_BLOCK_NAMES.each do |formula_block_name|
             block_node = find_block(body_node, formula_block_name)
-            top_level_nodes_to_check << [formula_block_name, block_node] if block_node
-          end
-
-          ALL_SYSTEM_OPTIONS.each do |on_system_option|
-            method_info = on_system_method_info(on_system_option)
-
-            top_level_nodes_to_check.each do |top_level_name, top_level_node|
-              top_level_node_string = if top_level_node.def_type?
-                "def #{top_level_name}"
-              else
-                "#{top_level_name} do"
-              end
-
-              find_every_method_call_by_name(top_level_node, method_info[:method]).each do |method|
-                if ON_MACOS_VERSION_OPTIONS.include?(on_system_option)
-                  on_macos_version_method_call(method, on_method: method_info[:method]) do |on_method_parameters|
-                    if on_method_parameters.empty?
-                      method_info[:if_string] = "if MacOS.version == :#{on_system_option}"
-                    else
-                      method_info[:on_system_string] = "#{method_info[:method]} :#{on_method_parameters.first}"
-                      if_condition_operator = MACOS_VERSION_CONDITIONALS.key(on_method_parameters.first)
-                      method_info[:if_string] = "if MacOS.version #{if_condition_operator} :#{on_system_option}"
-                    end
-                  end
-                elsif method_info[:method] == :on_system
-                  on_system_method_call(method) do |macos_symbol|
-                    base_os, condition = macos_symbol.to_s.split(/_(?=or_)/).map(&:to_sym)
-                    method_info[:on_system_string] = if condition.present?
-                      "on_system :linux, macos: :#{base_os}_#{condition}"
-                    else
-                      "on_system :linux, macos: :#{base_os}"
-                    end
-                    if_condition_operator = MACOS_VERSION_CONDITIONALS.key(condition)
-                    method_info[:if_string] = "if OS.linux? || MacOS.version #{if_condition_operator} :#{base_os}"
-                  end
-                end
-
-                offending_node(method)
-
-                problem "Don't use `#{method_info[:on_system_string]}` in `#{top_level_node_string}`, " \
-                        "use `#{method_info[:if_string]}` instead." do |corrector|
-                  block_node = offending_node.parent
-                  next if block_node.type != :block
-
-                  # TODO: could fix corrector to handle this but punting for now.
-                  next if block_node.single_line?
-
-                  source_range = offending_node.source_range.join(offending_node.parent.loc.begin)
-                  corrector.replace(source_range, method_info[:if_string])
-                end
-              end
-            end
+            audit_on_system_blocks(block_node, formula_block_name) if block_node
           end
 
           # Don't restrict OS.mac? or OS.linux? usage in taps; they don't care
@@ -483,122 +459,184 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
           # that case.
           return if formula_tap != "homebrew-core"
 
-          ALL_SYSTEM_OPTIONS.each do |on_system_option|
-            method_info = on_system_method_info(on_system_option)
+          audit_arch_conditionals(body_node,
+                                  allowed_methods: NO_ON_SYSTEM_METHOD_NAMES,
+                                  allowed_blocks:  NO_ON_SYSTEM_BLOCK_NAMES)
 
-            if_nodes_to_check = []
+          audit_base_os_conditionals(body_node,
+                                     allowed_methods: NO_ON_SYSTEM_METHOD_NAMES,
+                                     allowed_blocks:  NO_ON_SYSTEM_BLOCK_NAMES)
 
-            if ON_ARCH_OPTIONS.include?(on_system_option)
-              if_arch_node_search(body_node, arch: method_info[:if_method]) do |if_node, else_node|
-                else_info = if else_node.present?
-                  {
-                    can_autocorrect:  true,
-                    on_system_method: on_system_option == :intel ? "on_arm" : "on_intel",
-                    node:             else_node,
-                  }
-                end
+          audit_macos_version_conditionals(body_node,
+                                           allowed_methods:     NO_ON_SYSTEM_METHOD_NAMES,
+                                           allowed_blocks:      NO_ON_SYSTEM_BLOCK_NAMES,
+                                           recommend_on_system: true)
+        end
+      end
 
-                if_nodes_to_check << [if_node, else_info]
-              end
-            elsif ON_BASE_OS_OPTIONS.include?(on_system_option)
-              if_base_os_node_search(body_node, base_os: method_info[:if_method]) do |if_node, else_node|
-                else_info = if else_node.present?
-                  {
-                    can_autocorrect:  true,
-                    on_system_method: on_system_option == :macos ? "on_linux" : "on_macos",
-                    node:             else_node,
-                  }
-                end
+      # This cop makes sure the `MacOS` module is not used in Linux-facing formula code
+      class MacOSOnLinux < FormulaCop
+        include OnSystemConditionalsHelper
 
-                if_nodes_to_check << [if_node, else_info]
-              end
+        ON_MACOS_BLOCKS = [:macos, *MACOS_VERSION_OPTIONS].map { |os| :"on_#{os}" }.freeze
+
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          audit_macos_references(formula_nodes.body_node,
+                                 allowed_methods: OnSystemConditionals::NO_ON_SYSTEM_METHOD_NAMES,
+                                 allowed_blocks:  OnSystemConditionals::NO_ON_SYSTEM_BLOCK_NAMES + ON_MACOS_BLOCKS)
+        end
+      end
+
+      # This cop makes sure that the `generate_completions_from_executable` DSL is used.
+      class GenerateCompletionsDSL < FormulaCop
+        extend AutoCorrector
+
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          install = find_method_def(formula_nodes.body_node, :install)
+          return if install.blank?
+
+          correctable_shell_completion_node(install) do |node, shell, base_name, executable, subcmd, shell_parameter|
+            # generate_completions_from_executable only applicable if shell is passed
+            next unless shell_parameter.match?(/(bash|zsh|fish)/)
+
+            base_name = base_name.delete_prefix("_").delete_suffix(".fish")
+            shell = shell.to_s.delete_suffix("_completion").to_sym
+            shell_parameter_stripped = shell_parameter
+                                       .delete_suffix("bash")
+                                       .delete_suffix("zsh")
+                                       .delete_suffix("fish")
+            shell_parameter_format = if shell_parameter_stripped.empty?
+              nil
+            elsif shell_parameter_stripped == "--"
+              :flag
+            elsif shell_parameter_stripped == "--shell="
+              :arg
             else
-              if_macos_version_node_search(body_node, os_name: on_system_option) do |if_node, operator, else_node|
-                if operator == :<
-                  method_info[:on_system_string] = "on_system"
-                elsif operator == :<=
-                  method_info[:on_system_string] = "on_system :linux, macos: :#{on_system_option}_or_older"
-                elsif operator != :== && MACOS_VERSION_CONDITIONALS.key?(operator.to_s)
-                  method_info[:on_system_string] = "#{method_info[:method]} " \
-                                                   ":#{MACOS_VERSION_CONDITIONALS[operator.to_s]}"
-                end
-                method_info[:if_string] = "if #{method_info[:if_module]}.#{method_info[:if_method]} #{operator} " \
-                                          ":#{on_system_option}"
-                if else_node.present? || !MACOS_VERSION_CONDITIONALS.key?(operator.to_s)
-                  else_info = { can_autocorrect: false }
-                end
+              shell_parameter_stripped
+            end
 
-                if_nodes_to_check << [if_node, else_info]
-              end
+            replacement_args = %w[]
+            replacement_args << executable.source
+            replacement_args << subcmd.source
+            replacement_args << "base_name: \"#{base_name}\"" if base_name != @formula_name
+            replacement_args << "shells: [:#{shell}]"
+            unless shell_parameter_format.nil?
+              replacement_args << "shell_parameter_format: #{shell_parameter_format.inspect}"
             end
 
-            if_nodes_to_check.each do |if_node, else_info|
-              # TODO: check to see if it's legal
-              valid = T.let(false, T::Boolean)
-              if_node.each_ancestor do |ancestor|
-                valid_method_names = case ancestor.type
-                when :def
-                  NO_ON_SYSTEM_METHOD_NAMES
-                when :block
-                  NO_ON_SYSTEM_BLOCK_NAMES
-                else
-                  next
-                end
-                next unless valid_method_names.include?(ancestor.method_name)
+            offending_node(node)
+            replacement = "generate_completions_from_executable(#{replacement_args.join(", ")})"
 
-                valid = true
-                break
-              end
-              next if valid
+            problem "Use `#{replacement}` instead of `#{@offensive_node.source}`." do |corrector|
+              corrector.replace(@offensive_node.source_range, replacement)
+            end
+          end
 
-              offending_node(if_node)
+          shell_completion_node(install) do |node|
+            next if node.source.include?("<<~") # skip heredoc completion scripts
+            next if node.source.match?(/{.*=>.*}/) # skip commands needing custom ENV variables
 
-              problem "Don't use `#{method_info[:if_string]}`, " \
-                      "use `#{method_info[:on_system_string]} do` instead." do |corrector|
-                # TODO: could fix corrector to handle this but punting for now.
-                next if if_node.unless?
+            offending_node(node)
+            problem "Use `generate_completions_from_executable` DSL instead of `#{@offensive_node.source}`."
+          end
+        end
 
-                if else_info.present?
-                  next unless else_info[:can_autocorrect]
+        # match ({bash,zsh,fish}_completion/"_?foo{.fish}?").write Utils.safe_popen_read(foo, subcmd, shell_parameter)
+        def_node_search :correctable_shell_completion_node, <<~EOS
+          $(send
+          (begin
+            (send
+              (send nil? ${:bash_completion :zsh_completion :fish_completion}) :/
+              (str $_))) :write
+          (send
+            (const nil? :Utils) :safe_popen_read
+            $(send
+              (send nil? :bin) :/
+              (str _))
+            $(str _)
+            (str $_)))
+        EOS
 
-                  corrector.replace(if_node.source_range,
-                                    "#{method_info[:on_system_string]} do\n#{if_node.body.source}\nend\n" \
-                                    "#{else_info[:on_system_method]} do\n#{else_info[:node].source}\nend")
-                else
-                  corrector.replace(if_node.source_range,
-                                    "#{method_info[:on_system_string]} do\n#{if_node.body.source}\nend")
-                end
-              end
-            end
+        # matches ({bash,zsh,fish}_completion/"_?foo{.fish}?").write output
+        def_node_search :shell_completion_node, <<~EOS
+          $(send
+            (begin
+              (send
+                (send nil? {:bash_completion :zsh_completion :fish_completion}) :/
+                (str _))) :write _)
+        EOS
+      end
+
+      # This cop makes sure that the `generate_completions_from_executable` DSL is used with only
+      # a single, combined call for all shells.
+      class SingleGenerateCompletionsDSLCall < FormulaCop
+        extend AutoCorrector
+
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          install = find_method_def(formula_nodes.body_node, :install)
+          return if install.blank?
+
+          methods = find_every_method_call_by_name(install, :generate_completions_from_executable)
+          return if methods.length <= 1
+
+          offenses = []
+          shells = []
+          methods.each do |method|
+            next unless method.source.include?("shells:")
+
+            shells << method.source.match(/shells: \[(:bash|:zsh|:fish)\]/).captures.first
+            offenses << method
           end
-        end
 
-        def_node_matcher :on_macos_version_method_call, <<~PATTERN
-          (send nil? %on_method (sym ${:or_newer :or_older})?)
-        PATTERN
+          return if offenses.blank?
 
-        def_node_matcher :on_system_method_call, <<~PATTERN
-          (send nil? :on_system (sym :linux) (hash (pair (sym :macos) (sym $_))))
-        PATTERN
+          T.must(offenses[0...-1]).each_with_index do |node, i|
+            # commands have to be the same to be combined
+            # send_type? matches `bin/"foo"`, str_type? matches remaining command parts,
+            # the rest are kwargs we need to filter out
+            method_commands = node.arguments.filter { |arg| arg.send_type? || arg.str_type? }
+            next_method_commands = offenses[i + 1].arguments.filter { |arg| arg.send_type? || arg.str_type? }
+            if method_commands != next_method_commands
+              shells.delete_at(i)
+              next
+            end
+
+            offending_node(node)
+            problem "Use a single `generate_completions_from_executable` " \
+                    "call combining all specified shells." do |corrector|
+              # adjust range by -4 and +1 to also include & remove leading spaces and trailing \n
+              corrector.replace(@offensive_node.source_range.adjust(begin_pos: -4, end_pos: 1), "")
+            end
+          end
 
-        def_node_search :if_arch_node_search, <<~PATTERN
-          $(if (send (const (const nil? :Hardware) :CPU) %arch) _ $_)
-        PATTERN
+          return if shells.length <= 1 # no shells to combine left
 
-        def_node_search :if_base_os_node_search, <<~PATTERN
-          $(if (send (const nil? :OS) %base_os) _ $_)
-        PATTERN
+          offending_node(offenses.last)
+          replacement = if (%w[:bash :zsh :fish] - shells).empty?
+            @offensive_node.source.sub(/shells: \[(:bash|:zsh|:fish)\]/, "")
+                           .sub(", )", ")") # clean up dangling trailing comma
+                           .sub("(, ", "(") # clean up dangling leading comma
+                           .sub(", , ", ", ") # clean up dangling enclosed comma
+          else
+            @offensive_node.source.sub(/shells: \[(:bash|:zsh|:fish)\]/,
+                                       "shells: [#{shells.join(", ")}]")
+          end
 
-        def_node_search :if_macos_version_node_search, <<~PATTERN
-          $(if (send (send (const nil? :MacOS) :version) ${:== :<= :< :>= :> :!=} (sym %os_name)) _ $_)
-        PATTERN
+          problem "Use `#{replacement}` instead of `#{@offensive_node.source}`." do |corrector|
+            corrector.replace(@offensive_node.source_range, replacement)
+          end
+        end
       end
 
       # This cop checks for other miscellaneous style violations.
-      #
-      # @api private
       class Miscellaneous < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
           # FileUtils is included in Formula
           # encfs modifies a file with this name, so check for some leading characters
           find_instance_method_call(body_node, "FileUtils", nil) do |method_node|
@@ -608,7 +646,7 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
           # Check for long inreplace block vars
           find_all_blocks(body_node, :inreplace) do |node|
             block_arg = node.arguments.children.first
-            next unless block_arg.source.size > 1
+            next if block_arg.source.size <= 1
 
             problem "\"inreplace <filenames> do |s|\" is preferred over \"|#{block_arg.source}|\"."
           end
@@ -631,19 +669,23 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
 
           # Avoid hard-coding compilers
           find_every_method_call_by_name(body_node, :system).each do |method|
+            next if @formula_name == "bazel" # TODO: Remove shim bypass in bazel.
+
             param = parameters(method).first
-            if (match = regex_match_group(param, %r{^(/usr/bin/)?(gcc|llvm-gcc|clang)(\s|$)}))
+            if (match = regex_match_group(param, %r{^(/usr/bin/)?(gcc|clang|cc|c[89]9)(\s|$)}))
               problem "Use \"\#{ENV.cc}\" instead of hard-coding \"#{match[2]}\""
-            elsif (match = regex_match_group(param, %r{^(/usr/bin/)?((g|llvm-g|clang)\+\+)(\s|$)}))
+            elsif (match = regex_match_group(param, %r{^(/usr/bin/)?((g|clang|c)\+\+)(\s|$)}))
               problem "Use \"\#{ENV.cxx}\" instead of hard-coding \"#{match[2]}\""
             end
           end
 
           find_instance_method_call(body_node, "ENV", :[]=) do |method|
+            next if @formula_name == "bazel" # TODO: Remove shim bypass in bazel.
+
             param = parameters(method)[1]
-            if (match = regex_match_group(param, %r{^(/usr/bin/)?(gcc|llvm-gcc|clang)(\s|$)}))
+            if (match = regex_match_group(param, %r{^(/usr/bin/)?(gcc|clang|cc|c[89]9)(\s|$)}))
               problem "Use \"\#{ENV.cc}\" instead of hard-coding \"#{match[2]}\""
-            elsif (match = regex_match_group(param, %r{^(/usr/bin/)?((g|llvm-g|clang)\+\+)(\s|$)}))
+            elsif (match = regex_match_group(param, %r{^(/usr/bin/)?((g|clang|c)\+\+)(\s|$)}))
               problem "Use \"\#{ENV.cxx}\" instead of hard-coding \"#{match[2]}\""
             end
           end
@@ -657,13 +699,13 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
 
           formula_path_strings(body_node, :prefix) do |p|
             if (match = regex_match_group(p, %r{^(/share/(info|man))$}))
-              problem "\"\#\{prefix}#{match[1]}\" should be \"\#{#{match[2]}}\""
+              problem ['"#', "{prefix}", match[1], '" should be "#{', match[2], '}"'].join
             end
             if (match = regex_match_group(p, %r{^((/share/man/)(man[1-8]))}))
-              problem "\"\#\{prefix}#{match[1]}\" should be \"\#{#{match[3]}}\""
+              problem ['"#', "{prefix}", match[1], '" should be "#{', match[3], '}"'].join
             end
             if (match = regex_match_group(p, %r{^(/(bin|include|libexec|lib|sbin|share|Frameworks))}i))
-              problem "\"\#\{prefix}#{match[1]}\" should be \"\#{#{match[2].downcase}}\""
+              problem ['"#', "{prefix}", match[1], '" should be "#{', match[2].downcase, '}"'].join
             end
           end
 
@@ -696,13 +738,13 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
           end
 
           find_instance_method_call(body_node, :version, :==) do |method|
-            next unless parameters_passed?(method, "HEAD")
+            next unless parameters_passed?(method, ["HEAD"])
 
             problem "Use 'build.head?' instead of inspecting 'version'"
           end
 
           find_instance_method_call(body_node, "ARGV", :include?) do |method|
-            next unless parameters_passed?(method, "--HEAD")
+            next unless parameters_passed?(method, ["--HEAD"])
 
             problem "Use \"if build.head?\" instead"
           end
@@ -744,18 +786,6 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
             problem "Use ruby-macho instead of calling #{@offensive_node.source}"
           end
 
-          find_every_method_call_by_name(body_node, :system).each do |method_node|
-            # Skip Kibana: npm cache edge (see formula for more details)
-            next if @formula_name.match?(/^kibana(@\d[\d.]*)?$/)
-
-            first_param, second_param = parameters(method_node)
-            next if !node_equals?(first_param, "npm") ||
-                    !node_equals?(second_param, "install")
-
-            offending_node(method_node)
-            problem "Use Language::Node for npm install args" unless languageNodeModule?(method_node)
-          end
-
           problem "Use new-style test definitions (test do)" if find_method_def(body_node, :test)
 
           find_method_with_args(body_node, :skip_clean, :all) do
@@ -802,7 +832,7 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
           end
 
           find_instance_method_call(body_node, "Dir", :[]) do |method|
-            next unless parameters(method).size == 1
+            next if parameters(method).size != 1
 
             path = parameters(method).first
             next unless path.str_type?
@@ -850,24 +880,18 @@ def modifier?(node)
           {(dstr (begin (send nil? %1)) $(str _ ))
            (dstr _ (begin (send nil? %1)) $(str _ ))}
         EOS
-
-        # Node Pattern search for Language::Node
-        def_node_search :languageNodeModule?, <<~EOS
-          (const (const nil? :Language) :Node)
-        EOS
       end
     end
 
     module FormulaAuditStrict
       # This cop makes sure that no build-time checks are performed.
-      #
-      # @api private
       class MakeCheck < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
           return if formula_tap != "homebrew-core"
 
           # Avoid build-time checks in homebrew/core
-          find_every_method_call_by_name(body_node, :system).each do |method|
+          find_every_method_call_by_name(formula_nodes.body_node, :system).each do |method|
             next if @formula_name.start_with?("lib")
             next if tap_style_exception? :make_check_allowlist
 
@@ -887,13 +911,57 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
 
       # This cop ensures that new formulae depending on removed Requirements are not used
       class Requirements < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, _body_node)
+        sig { override.params(_formula_nodes: FormulaNodes).void }
+        def audit_formula(_formula_nodes)
           problem "Formulae should depend on a versioned `openjdk` instead of :java" if depends_on? :java
           problem "Formulae should depend on specific X libraries instead of :x11" if depends_on? :x11
           problem "Formulae should not depend on :osxfuse" if depends_on? :osxfuse
           problem "Formulae should not depend on :tuntap" if depends_on? :tuntap
         end
       end
+
+      # This cop makes sure that formulae build with `rust` instead of `rustup`.
+      class RustCheck < FormulaCop
+        extend AutoCorrector
+
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
+          # Enforce use of `rust` for rust dependency in core
+          return if formula_tap != "homebrew-core"
+
+          find_method_with_args(body_node, :depends_on, "rustup") do
+            problem "Formulae in homebrew/core should use 'depends_on \"rust\"' " \
+                    "instead of '#{@offensive_node.source}'." do |corrector|
+              corrector.replace(@offensive_node.source_range, "depends_on \"rust\"")
+            end
+          end
+
+          # TODO: Enforce order of dependency types so we don't need to check for
+          #       depends_on "rustup" => [:test, :build]
+          [:build, [:build, :test], [:test, :build]].each do |type|
+            find_method_with_args(body_node, :depends_on, "rustup" => type) do
+              problem "Formulae in homebrew/core should use 'depends_on \"rust\" => #{type}' " \
+                      "instead of '#{@offensive_node.source}'." do |corrector|
+                corrector.replace(@offensive_node.source_range, "depends_on \"rust\" => #{type}")
+              end
+            end
+          end
+
+          install_node = find_method_def(body_node, :install)
+          return if install_node.blank?
+
+          find_every_method_call_by_name(install_node, :system).each do |method|
+            param = parameters(method).first
+            next if param.blank?
+            # FIXME: Handle Pathname parameters (e.g. `system bin/"rustup"`).
+            next if regex_match_group(param, /rustup$/).blank?
+
+            problem "Formula in homebrew/core should not use `rustup` at build-time."
+          end
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/rubocops/lines.rbi b/Library/Homebrew/rubocops/lines.rbi
deleted file mode 100644
index 4036b6dd7be52..0000000000000
--- a/Library/Homebrew/rubocops/lines.rbi
+++ /dev/null
@@ -1,24 +0,0 @@
-# typed: strict
-
-module RuboCop
-  module Cop
-    module FormulaAudit
-      class OnSystemConditionals < FormulaCop
-        sig { params(node: T.any, on_method: Symbol, block: T.proc.params(parameters: T::Array[T.any]).void).void }
-        def on_macos_version_method_call(node, on_method:, &block); end
-
-        sig { params(node: T.any, block: T.proc.params(macos_symbol: Symbol).void).void }
-        def on_system_method_call(node, &block); end
-
-        sig { params(node: T.any, arch: Symbol, block: T.proc.params(node: T.any, else_node: T.any).void).void }
-        def if_arch_node_search(node, arch:, &block); end
-
-        sig { params(node: T.any, base_os: Symbol, block: T.proc.params(node: T.any, else_node: T.any).void).void }
-        def if_base_os_node_search(node, base_os:, &block); end
-
-        sig { params(node: T.any, os_name: Symbol, block: T.proc.params(node: T.any, operator: Symbol, else_node: T.any).void).void }
-        def if_macos_version_node_search(node, os_name:, &block); end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/rubocops/livecheck.rb b/Library/Homebrew/rubocops/livecheck.rb
index 8ff8122f903a8..bc0740c400ae7 100644
--- a/Library/Homebrew/rubocops/livecheck.rb
+++ b/Library/Homebrew/rubocops/livecheck.rb
@@ -1,20 +1,19 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
     module FormulaAudit
       # This cop ensures that no other livecheck information is provided for
       # skipped formulae.
-      #
-      # @api private
       class LivecheckSkip < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          livecheck_node = find_block(body_node, :livecheck)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          livecheck_node = find_block(formula_nodes.body_node, :livecheck)
           return if livecheck_node.blank?
 
           skip = find_every_method_call_by_name(livecheck_node, :skip).first
@@ -40,36 +39,34 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
       end
 
       # This cop ensures that a `url` is specified in the `livecheck` block.
-      #
-      # @api private
       class LivecheckUrlProvided < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          livecheck_node = find_block(body_node, :livecheck)
-          return if livecheck_node.blank?
-
-          skip = find_every_method_call_by_name(livecheck_node, :skip).first
-          return if skip.present?
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          livecheck_node = find_block(formula_nodes.body_node, :livecheck)
+          return unless livecheck_node
 
-          formula_node = find_every_method_call_by_name(livecheck_node, :formula).first
-          cask_node = find_every_method_call_by_name(livecheck_node, :cask).first
-          return if formula_node.present? || cask_node.present?
+          url_node = find_every_method_call_by_name(livecheck_node, :url).first
+          return if url_node
 
-          livecheck_url = find_every_method_call_by_name(livecheck_node, :url).first
-          return if livecheck_url.present?
+          # A regex and/or strategy is specific to a particular URL, so we
+          # should require an explicit URL.
+          regex_node = find_every_method_call_by_name(livecheck_node, :regex).first
+          strategy_node = find_every_method_call_by_name(livecheck_node, :strategy).first
+          return if !regex_node && !strategy_node
 
           offending_node(livecheck_node)
-          problem "A `url` must be provided to livecheck."
+          problem "A `url` should be provided when `regex` or `strategy` are used."
         end
       end
 
       # This cop ensures that a supported symbol (`head`, `stable, `homepage`)
       # is used when the livecheck `url` is identical to one of these formula URLs.
-      #
-      # @api private
       class LivecheckUrlSymbol < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          body_node = formula_nodes.body_node
           livecheck_node = find_block(body_node, :livecheck)
           return if livecheck_node.blank?
 
@@ -121,13 +118,12 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
       end
 
       # This cop ensures that the `regex` call in the `livecheck` block uses parentheses.
-      #
-      # @api private
       class LivecheckRegexParentheses < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          livecheck_node = find_block(body_node, :livecheck)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          livecheck_node = find_block(formula_nodes.body_node, :livecheck)
           return if livecheck_node.blank?
 
           skip = find_every_method_call_by_name(livecheck_node, :skip).first.present?
@@ -148,15 +144,14 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
 
       # This cop ensures that the pattern provided to livecheck's `regex` uses `\.t` instead of
       # `\.tgz`, `\.tar.gz` and variants.
-      #
-      # @api private
       class LivecheckRegexExtension < FormulaCop
         extend AutoCorrector
 
-        TAR_PATTERN = /\\?\.t(ar|(g|l|x)z$|[bz2]{2,4}$)(\\?\.((g|l|x)z)|[bz2]{2,4}|Z)?$/i.freeze
+        TAR_PATTERN = /\\?\.t(ar|(g|l|x)z$|[bz2]{2,4}$)(\\?\.((g|l|x)z)|[bz2]{2,4}|Z)?$/i
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          livecheck_node = find_block(body_node, :livecheck)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          livecheck_node = find_block(formula_nodes.body_node, :livecheck)
           return if livecheck_node.blank?
 
           skip = find_every_method_call_by_name(livecheck_node, :skip).first.present?
@@ -181,11 +176,10 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
 
       # This cop ensures that a `regex` is provided when `strategy :page_match` is specified
       # in the `livecheck` block.
-      #
-      # @api private
       class LivecheckRegexIfPageMatch < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          livecheck_node = find_block(body_node, :livecheck)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          livecheck_node = find_block(formula_nodes.body_node, :livecheck)
           return if livecheck_node.blank?
 
           skip = find_every_method_call_by_name(livecheck_node, :skip).first.present?
@@ -207,17 +201,16 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
 
       # This cop ensures that the `regex` provided to livecheck is case-insensitive,
       # unless sensitivity is explicitly required for proper matching.
-      #
-      # @api private
       class LivecheckRegexCaseInsensitive < FormulaCop
         extend AutoCorrector
 
         MSG = "Regexes should be case-insensitive unless sensitivity is explicitly required for proper matching."
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
           return if tap_style_exception? :regex_case_sensitive_allowlist
 
-          livecheck_node = find_block(body_node, :livecheck)
+          livecheck_node = find_block(formula_nodes.body_node, :livecheck)
           return if livecheck_node.blank?
 
           skip = find_every_method_call_by_name(livecheck_node, :skip).first.present?
diff --git a/Library/Homebrew/rubocops/move_to_extend_os.rb b/Library/Homebrew/rubocops/move_to_extend_os.rb
new file mode 100644
index 0000000000000..00aa8742c661c
--- /dev/null
+++ b/Library/Homebrew/rubocops/move_to_extend_os.rb
@@ -0,0 +1,23 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Homebrew
+      # This cop ensures that platform specific code ends up in `extend/os`.
+      class MoveToExtendOS < Base
+        MSG = "Move `OS.linux?` and `OS.mac?` calls to `extend/os`."
+
+        def_node_matcher :os_check?, <<~PATTERN
+          (send (const nil? :OS) {:mac? | :linux?})
+        PATTERN
+
+        def on_send(node)
+          return unless os_check?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/negate_include.rb b/Library/Homebrew/rubocops/negate_include.rb
new file mode 100644
index 0000000000000..37ffd6092c51d
--- /dev/null
+++ b/Library/Homebrew/rubocops/negate_include.rb
@@ -0,0 +1,45 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Homebrew
+      # Enforces the use of `collection.exclude?(obj)`
+      # over `!collection.include?(obj)`.
+      #
+      # NOTE: This cop is unsafe because false positives will occur for
+      #       receiver objects that do not have an `#exclude?` method (e.g. `IPAddr`).
+      #
+      # ### Example
+      #
+      # ```ruby
+      # # bad
+      # !array.include?(2)
+      # !hash.include?(:key)
+      #
+      # # good
+      # array.exclude?(2)
+      # hash.exclude?(:key)
+      # ```
+      class NegateInclude < Base
+        extend AutoCorrector
+
+        MSG = "Use `.exclude?` and remove the negation part."
+
+        RESTRICT_ON_SEND = [:!].freeze
+
+        def_node_matcher :negate_include_call?, <<~PATTERN
+          (send (send $!nil? :include? $_) :!)
+        PATTERN
+
+        def on_send(node)
+          return unless (receiver, obj = negate_include_call?(node))
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, "#{receiver.source}.exclude?(#{obj.source})")
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/no_fileutils_rmrf.rb b/Library/Homebrew/rubocops/no_fileutils_rmrf.rb
new file mode 100644
index 0000000000000..7ddf6ca5eee03
--- /dev/null
+++ b/Library/Homebrew/rubocops/no_fileutils_rmrf.rb
@@ -0,0 +1,61 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Homebrew
+      # This cop checks for the use of `FileUtils.rm_f`, `FileUtils.rm_rf`, or `{FileUtils,instance}.rmtree`
+      # and recommends the safer versions.
+      class NoFileutilsRmrf < Base
+        extend AutoCorrector
+
+        MSG = "Use `rm` or `rm_r` instead of `rm_rf`, `rm_f`, or `rmtree`."
+
+        def_node_matcher :any_receiver_rm_r_f?, <<~PATTERN
+          (send
+            {(const {nil? cbase} :FileUtils) (self)}
+            {:rm_rf :rm_f}
+            ...)
+        PATTERN
+
+        def_node_matcher :no_receiver_rm_r_f?, <<~PATTERN
+          (send nil? {:rm_rf :rm_f} ...)
+        PATTERN
+
+        def_node_matcher :no_receiver_rmtree?, <<~PATTERN
+          (send nil? :rmtree ...)
+        PATTERN
+
+        def_node_matcher :any_receiver_rmtree?, <<~PATTERN
+          (send !nil? :rmtree ...)
+        PATTERN
+
+        def on_send(node)
+          return if neither_rm_rf_nor_rmtree?(node)
+
+          add_offense(node) do |corrector|
+            class_name = "FileUtils." if any_receiver_rm_r_f?(node) || any_receiver_rmtree?(node)
+            new_method = if node.method?(:rm_rf) || node.method?(:rmtree)
+              "rm_r"
+            else
+              "rm"
+            end
+
+            args = if any_receiver_rmtree?(node)
+              node.receiver&.source || node.arguments.first&.source
+            else
+              node.arguments.first.source
+            end
+            args = "(#{args})" unless args.start_with?("(")
+            corrector.replace(node.loc.expression, "#{class_name}#{new_method}#{args}")
+          end
+        end
+
+        def neither_rm_rf_nor_rmtree?(node)
+          !any_receiver_rm_r_f?(node) && !no_receiver_rm_r_f?(node) &&
+            !any_receiver_rmtree?(node) && !no_receiver_rmtree?(node)
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/options.rb b/Library/Homebrew/rubocops/options.rb
index a255297eab9fe..8958b94dd8fc1 100644
--- a/Library/Homebrew/rubocops/options.rb
+++ b/Library/Homebrew/rubocops/options.rb
@@ -1,7 +1,7 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
@@ -14,7 +14,10 @@ class Options < FormulaCop
         DEP_OPTION = "Formulae in homebrew/core should not use `deprecated_option`."
         OPTION = "Formulae in homebrew/core should not use `option`."
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
           option_call_nodes = find_every_method_call_by_name(body_node, :option)
           option_call_nodes.each do |option_call|
             option = parameters(option_call).first
@@ -24,7 +27,7 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
             option = string_content(option)
             problem UNI_DEPRECATION_MSG if option == "universal"
 
-            if option !~ /with(out)?-/ &&
+            if !/with(out)?-/.match?(option) &&
                option != "cxx11" &&
                option != "universal"
               problem "Options should begin with with/without. " \
diff --git a/Library/Homebrew/rubocops/patches.rb b/Library/Homebrew/rubocops/patches.rb
index 79ffc873c621f..32d2f87e9e82d 100644
--- a/Library/Homebrew/rubocops/patches.rb
+++ b/Library/Homebrew/rubocops/patches.rb
@@ -1,8 +1,7 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
-require "extend/string"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
@@ -10,20 +9,23 @@ module FormulaAudit
       # This cop audits `patch`es in formulae.
       # TODO: Many of these could be auto-corrected.
       class Patches < FormulaCop
-        extend T::Sig
         extend AutoCorrector
 
-        def audit_formula(node, _class_node, _parent_class_node, body)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          node = formula_nodes.node
           @full_source_content = source_buffer(node).source
 
-          external_patches = find_all_blocks(body, :patch)
+          return if (body_node = formula_nodes.body_node).nil?
+
+          external_patches = find_all_blocks(body_node, :patch)
           external_patches.each do |patch_block|
             url_node = find_every_method_call_by_name(patch_block, :url).first
             url_string = parameters(url_node).first
             patch_problems(url_string)
           end
 
-          inline_patches = find_every_method_call_by_name(body, :patch)
+          inline_patches = find_every_method_call_by_name(body_node, :patch)
           inline_patches.each { |patch| inline_patch_problems(patch) }
 
           if inline_patches.empty? && patch_end?
@@ -31,7 +33,7 @@ def audit_formula(node, _class_node, _parent_class_node, body)
             add_offense(@offense_source_range, message: "patch is missing 'DATA'")
           end
 
-          patches_node = find_method_def(body, :patches)
+          patches_node = find_method_def(body_node, :patches)
           return if patches_node.nil?
 
           legacy_patches = find_strings(patches_node)
diff --git a/Library/Homebrew/rubocops/presence.rb b/Library/Homebrew/rubocops/presence.rb
new file mode 100644
index 0000000000000..c924de724ee32
--- /dev/null
+++ b/Library/Homebrew/rubocops/presence.rb
@@ -0,0 +1,157 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Homebrew
+      # Checks code that can be written more easily using
+      # `Object#presence` defined by Active Support.
+      #
+      # ### Examples
+      #
+      # ```ruby
+      # # bad
+      # a.present? ? a : nil
+      #
+      # # bad
+      # !a.present? ? nil : a
+      #
+      # # bad
+      # a.blank? ? nil : a
+      #
+      # # bad
+      # !a.blank? ? a : nil
+      #
+      # # good
+      # a.presence
+      # ```
+      #
+      # ```ruby
+      # # bad
+      # a.present? ? a : b
+      #
+      # # bad
+      # !a.present? ? b : a
+      #
+      # # bad
+      # a.blank? ? b : a
+      #
+      # # bad
+      # !a.blank? ? a : b
+      #
+      # # good
+      # a.presence || b
+      # ```
+      class Presence < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = "Use `%<prefer>s` instead of `%<current>s`."
+
+        def_node_matcher :redundant_receiver_and_other, <<~PATTERN
+          {
+            (if
+              (send $_recv :present?)
+              _recv
+              $!begin
+            )
+            (if
+              (send $_recv :blank?)
+              $!begin
+              _recv
+            )
+          }
+        PATTERN
+
+        def_node_matcher :redundant_negative_receiver_and_other, <<~PATTERN
+          {
+            (if
+              (send (send $_recv :present?) :!)
+              $!begin
+              _recv
+            )
+            (if
+              (send (send $_recv :blank?) :!)
+              _recv
+              $!begin
+            )
+          }
+        PATTERN
+
+        def on_if(node)
+          return if ignore_if_node?(node)
+
+          redundant_receiver_and_other(node) do |receiver, other|
+            return if ignore_other_node?(other) || receiver.nil?
+
+            register_offense(node, receiver, other)
+          end
+
+          redundant_negative_receiver_and_other(node) do |receiver, other|
+            return if ignore_other_node?(other) || receiver.nil?
+
+            register_offense(node, receiver, other)
+          end
+        end
+
+        private
+
+        def register_offense(node, receiver, other)
+          add_offense(node, message: message(node, receiver, other)) do |corrector|
+            corrector.replace(node, replacement(receiver, other, node.left_sibling))
+          end
+        end
+
+        def ignore_if_node?(node)
+          node.elsif?
+        end
+
+        def ignore_other_node?(node)
+          node && (node.if_type? || node.rescue_type? || node.while_type?)
+        end
+
+        def message(node, receiver, other)
+          prefer = replacement(receiver, other, node.left_sibling).gsub(/^\s*|\n/, "")
+          current = current(node).gsub(/^\s*|\n/, "")
+          format(MSG, prefer:, current:)
+        end
+
+        def current(node)
+          if !node.ternary? && node.source.include?("\n")
+            "#{node.loc.keyword.with(end_pos: node.condition.loc.selector.end_pos).source} ... end"
+          else
+            node.source.gsub(/\n\s*/, " ")
+          end
+        end
+
+        def replacement(receiver, other, left_sibling)
+          or_source = if other&.send_type?
+            build_source_for_or_method(other)
+          elsif other.nil? || other.nil_type?
+            ""
+          else
+            " || #{other.source}"
+          end
+
+          replaced = "#{receiver.source}.presence#{or_source}"
+          left_sibling ? "(#{replaced})" : replaced
+        end
+
+        def build_source_for_or_method(other)
+          if other.parenthesized? || other.method?("[]") || other.arithmetic_operation? || !other.arguments?
+            " || #{other.source}"
+          else
+            method = method_range(other).source
+            arguments = other.arguments.map(&:source).join(", ")
+
+            " || #{method}(#{arguments})"
+          end
+        end
+
+        def method_range(node)
+          range_between(node.source_range.begin_pos, node.first_argument.source_range.begin_pos - 1)
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/present.rb b/Library/Homebrew/rubocops/present.rb
new file mode 100644
index 0000000000000..c77a2eed5a7ea
--- /dev/null
+++ b/Library/Homebrew/rubocops/present.rb
@@ -0,0 +1,76 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Homebrew
+      # Checks for code that can be simplified using `Object#present?`.
+      #
+      # ### Example
+      #
+      # ```ruby
+      # # bad
+      # !foo.nil? && !foo.empty?
+      #
+      # # bad
+      # foo != nil && !foo.empty?
+      #
+      # # good
+      # foo.present?
+      # ```
+      class Present < Base
+        extend AutoCorrector
+
+        MSG = "Use `%<prefer>s` instead of `%<current>s`."
+
+        def_node_matcher :exists_and_not_empty?, <<~PATTERN
+          (and
+              {
+                (send (send $_ :nil?) :!)
+                (send (send $_ :!) :!)
+                (send $_ :!= nil)
+                $_
+              }
+              {
+                (send (send $_ :empty?) :!)
+              }
+          )
+        PATTERN
+
+        def on_and(node)
+          exists_and_not_empty?(node) do |var1, var2|
+            return if var1 != var2
+
+            message = format(MSG, prefer: replacement(var1), current: node.source)
+
+            add_offense(node, message:) do |corrector|
+              autocorrect(corrector, node)
+            end
+          end
+        end
+
+        def on_or(node)
+          exists_and_not_empty?(node) do |var1, var2|
+            return if var1 != var2
+
+            add_offense(node, message: MSG) do |corrector|
+              autocorrect(corrector, node)
+            end
+          end
+        end
+
+        def autocorrect(corrector, node)
+          variable1, _variable2 = exists_and_not_empty?(node)
+          range = node.source_range
+          corrector.replace(range, replacement(variable1))
+        end
+
+        private
+
+        def replacement(node)
+          node.respond_to?(:source) ? "#{node.source}.present?" : "present?"
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/resource_requires_dependencies.rb b/Library/Homebrew/rubocops/resource_requires_dependencies.rb
new file mode 100644
index 0000000000000..4ed34dc05f99c
--- /dev/null
+++ b/Library/Homebrew/rubocops/resource_requires_dependencies.rb
@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rubocops/extend/formula_cop"
+
+module RuboCop
+  module Cop
+    module FormulaAudit
+      # This cop audits Python formulae that include certain resources
+      # to ensure that they also have the correct `uses_from_macos`
+      # dependencies.
+      class ResourceRequiresDependencies < FormulaCop
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
+          resource_nodes = find_every_method_call_by_name(body_node, :resource)
+          return if resource_nodes.empty?
+
+          %w[lxml pyyaml].each do |resource_name|
+            found = resource_nodes.find { |node| node.arguments&.first&.str_content == resource_name }
+            next unless found
+
+            uses_from_macos_nodes = find_every_method_call_by_name(body_node, :uses_from_macos)
+            depends_on_nodes = find_every_method_call_by_name(body_node, :depends_on)
+            uses_from_macos_or_depends_on = (uses_from_macos_nodes + depends_on_nodes).filter_map do |node|
+              if (dep = node.arguments.first).hash_type?
+                dep_types = dep.values.first
+                dep_types = dep_types.array_type? ? dep_types.values : [dep_types]
+                dep.keys.first.str_content if dep_types.select(&:sym_type?).map(&:value).include?(:build)
+              else
+                dep.str_content
+              end
+            end
+
+            required_deps = case resource_name
+            when "lxml"
+              kind = depends_on?(:linux) ? "depends_on" : "uses_from_macos"
+              ["libxml2", "libxslt"]
+            when "pyyaml"
+              kind = "depends_on"
+              ["libyaml"]
+            else
+              []
+            end
+            next if required_deps.all? { |dep| uses_from_macos_or_depends_on.include?(dep) }
+
+            offending_node(found)
+            problem "Add `#{kind}` lines above for #{required_deps.map { |req| "`\"#{req}\"`" }.join(" and ")}."
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/rubocop-cask.rb b/Library/Homebrew/rubocops/rubocop-cask.rb
index 63b02b0e195fb..668fcea57d18f 100644
--- a/Library/Homebrew/rubocops/rubocop-cask.rb
+++ b/Library/Homebrew/rubocops/rubocop-cask.rb
@@ -8,14 +8,20 @@
 require_relative "cask/ast/stanza"
 require_relative "cask/ast/cask_header"
 require_relative "cask/ast/cask_block"
-require_relative "cask/extend/string"
 require_relative "cask/extend/node"
 require_relative "cask/mixin/cask_help"
 require_relative "cask/mixin/on_homepage_stanza"
 require_relative "cask/mixin/on_url_stanza"
+require_relative "cask/array_alphabetization"
 require_relative "cask/desc"
-require_relative "cask/homepage_url_trailing_slash"
-require_relative "cask/no_dsl_version"
+require_relative "cask/discontinued"
+require_relative "cask/homepage_url_styling"
+require_relative "cask/no_overrides"
+require_relative "cask/on_system_conditionals"
+require_relative "cask/shared_filelist_glob"
 require_relative "cask/stanza_order"
 require_relative "cask/stanza_grouping"
+require_relative "cask/uninstall_methods_order"
+require_relative "cask/url"
 require_relative "cask/url_legacy_comma_separators"
+require_relative "cask/variables"
diff --git a/Library/Homebrew/rubocops/safe_navigation_with_blank.rb b/Library/Homebrew/rubocops/safe_navigation_with_blank.rb
new file mode 100644
index 0000000000000..74f83fe32ad0a
--- /dev/null
+++ b/Library/Homebrew/rubocops/safe_navigation_with_blank.rb
@@ -0,0 +1,49 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Homebrew
+      # Checks to make sure safe navigation isn't used with `blank?` in
+      # a conditional.
+      #
+      # NOTE: While the safe navigation operator is generally a good idea, when
+      #       checking `foo&.blank?` in a conditional, `foo` being `nil` will actually
+      #       do the opposite of what the author intends:
+      #
+      #       ```ruby
+      #       foo&.blank? #=> nil
+      #       foo.blank? #=> true
+      #       ```
+      #
+      # ### Example
+      #
+      # ```ruby
+      # # bad
+      # do_something if foo&.blank?
+      # do_something unless foo&.blank?
+      #
+      # # good
+      # do_something if foo.blank?
+      # do_something unless foo.blank?
+      # ```
+      class SafeNavigationWithBlank < Base
+        extend AutoCorrector
+
+        MSG = "Avoid calling `blank?` with the safe navigation operator in conditionals."
+
+        def_node_matcher :safe_navigation_blank_in_conditional?, <<~PATTERN
+          (if $(csend ... :blank?) ...)
+        PATTERN
+
+        def on_if(node)
+          return unless safe_navigation_blank_in_conditional?(node)
+
+          add_offense(node) do |corrector|
+            corrector.replace(safe_navigation_blank_in_conditional?(node).location.dot, ".")
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/service.rb b/Library/Homebrew/rubocops/service.rb
new file mode 100644
index 0000000000000..d7f76b17add58
--- /dev/null
+++ b/Library/Homebrew/rubocops/service.rb
@@ -0,0 +1,62 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "rubocops/extend/formula_cop"
+
+module RuboCop
+  module Cop
+    module FormulaAudit
+      # This cop audits the service block.
+      class Service < FormulaCop
+        extend AutoCorrector
+
+        CELLAR_PATH_AUDIT_CORRECTIONS = {
+          bin:      :opt_bin,
+          libexec:  :opt_libexec,
+          pkgshare: :opt_pkgshare,
+          prefix:   :opt_prefix,
+          sbin:     :opt_sbin,
+          share:    :opt_share,
+        }.freeze
+
+        # At least one of these methods must be defined in a service block.
+        REQUIRED_METHOD_CALLS = [:run, :name].freeze
+
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          service_node = find_block(formula_nodes.body_node, :service)
+          return if service_node.blank?
+
+          method_calls = service_node.each_descendant(:send).group_by(&:method_name)
+          method_calls.delete(:service)
+
+          # NOTE: Solving the first problem here might solve the second one too
+          #       so we don't show both of them at the same time.
+          if !method_calls.keys.intersect?(REQUIRED_METHOD_CALLS)
+            offending_node(service_node)
+            problem "Service blocks require `run` or `name` to be defined."
+          elsif !method_calls.key?(:run)
+            other_method_calls = method_calls.keys - [:name, :require_root]
+            if other_method_calls.any?
+              offending_node(service_node)
+              problem "`run` must be defined to use methods other than `name` like #{other_method_calls}."
+            end
+          end
+
+          # This check ensures that cellar paths like `bin` are not referenced
+          # because their `opt_` variants are more portable and work with the API.
+          CELLAR_PATH_AUDIT_CORRECTIONS.each do |path, opt_path|
+            next unless method_calls.key?(path)
+
+            method_calls.fetch(path).each do |node|
+              offending_node(node)
+              problem "Use `#{opt_path}` instead of `#{path}` in service blocks." do |corrector|
+                corrector.replace(node.source_range, opt_path)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/shared/desc_helper.rb b/Library/Homebrew/rubocops/shared/desc_helper.rb
index f095efd8a89a8..ac2504a5f73ae 100644
--- a/Library/Homebrew/rubocops/shared/desc_helper.rb
+++ b/Library/Homebrew/rubocops/shared/desc_helper.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "rubocops/shared/helper_functions"
@@ -6,8 +6,6 @@
 module RuboCop
   module Cop
     # This module performs common checks the `desc` field in both formulae and casks.
-    #
-    # @api private
     module DescHelper
       include HelperFunctions
 
@@ -53,8 +51,7 @@ def audit_desc(type, name, desc_call)
         desc_problem "Description shouldn't start with an article." if regex_match_group(desc, /^(the|an?)(?=\s)/i)
 
         # Check if invalid lowercase words are at the start of a desc.
-        if !VALID_LOWERCASE_WORDS.include?(string_content(desc).split.first) &&
-           regex_match_group(desc, /^[a-z]/)
+        if !VALID_LOWERCASE_WORDS.include?(string_content(desc).split.first) && regex_match_group(desc, /^[a-z]/)
           desc_problem "Description should start with a capital letter."
         end
 
@@ -67,7 +64,7 @@ def audit_desc(type, name, desc_call)
         if type == :cask &&
            (match = regex_match_group(desc, /\b(macOS|Mac( ?OS( ?X)?)?|OS ?X)(?! virtual machines?)\b/i)) &&
            match[1] != "MAC"
-          desc_problem "Description shouldn't contain the platform."
+          add_offense(@offensive_source_range, message: "Description shouldn't contain the platform.")
         end
 
         # Check if a full stop is used at the end of a desc (apart from in the case of "etc.").
@@ -75,6 +72,9 @@ def audit_desc(type, name, desc_call)
           desc_problem "Description shouldn't end with a full stop."
         end
 
+        # Check if the desc contains Unicode emojis or symbols (Unicode Other Symbols category).
+        desc_problem "Description shouldn't contain Unicode emojis or symbols." if regex_match_group(desc, /\p{So}/)
+
         # Check if the desc length exceeds maximum length.
         return if desc_length <= MAX_DESC_LENGTH
 
@@ -84,8 +84,10 @@ def audit_desc(type, name, desc_call)
 
       # Auto correct desc problems. `regex_match_group` must be called before this to populate @offense_source_range.
       def desc_problem(message)
-        add_offense(@offensive_source_range, message: message) do |corrector|
-          /\A(?<quote>["'])(?<correction>.*)(?:\k<quote>)\Z/ =~ @offensive_node.source
+        add_offense(@offensive_source_range, message:) do |corrector|
+          match_data = @offensive_node.source.match(/\A(?<quote>["'])(?<correction>.*)(?:\k<quote>)\Z/)
+          correction = match_data[:correction]
+          quote = match_data[:quote]
 
           next if correction.nil?
 
@@ -102,10 +104,13 @@ def desc_problem(message)
 
           correction.gsub!(/(ommand ?line)/i, "ommand-line")
           correction.gsub!(/(^|[^a-z])#{@name}([^a-z]|$)/i, "\\1\\2")
+          correction.gsub!(/\s?\p{So}/, "")
           correction.gsub!(/^\s+/, "")
           correction.gsub!(/\s+$/, "")
           correction.gsub!(/\.$/, "")
 
+          next if correction == match_data[:correction]
+
           corrector.replace(@offensive_node.source_range, "#{quote}#{correction}#{quote}")
         end
       end
diff --git a/Library/Homebrew/rubocops/shared/desc_helper.rbi b/Library/Homebrew/rubocops/shared/desc_helper.rbi
new file mode 100644
index 0000000000000..ee694db1f127b
--- /dev/null
+++ b/Library/Homebrew/rubocops/shared/desc_helper.rbi
@@ -0,0 +1,5 @@
+# typed: strict
+
+module RuboCop::Cop::DescHelper
+  requires_ancestor { RuboCop::Cop::Base }
+end
diff --git a/Library/Homebrew/rubocops/shared/helper_functions.rb b/Library/Homebrew/rubocops/shared/helper_functions.rb
index 83f8c04b532d1..823d4c26c0dc2 100644
--- a/Library/Homebrew/rubocops/shared/helper_functions.rb
+++ b/Library/Homebrew/rubocops/shared/helper_functions.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "rubocop"
@@ -11,8 +11,6 @@
 module RuboCop
   module Cop
     # Helper functions for cops.
-    #
-    # @api private
     module HelperFunctions
       include RangeHelp
 
@@ -49,6 +47,7 @@ def start_column(node)
       end
 
       # Returns the line number of the node.
+      sig { params(node: RuboCop::AST::Node).returns(Integer) }
       def line_number(node)
         node.loc.line
       end
@@ -108,7 +107,7 @@ def find_node_method_by_name(node, method_name)
         return if node.nil?
 
         node.each_child_node(:send) do |method_node|
-          next unless method_node.method_name == method_name
+          next if method_node.method_name != method_name
 
           @offensive_node = method_node
           return method_node
@@ -166,7 +165,7 @@ def find_every_func_call_by_name(node, func_name = nil)
       def find_method_with_args(node, method_name, *args)
         methods = find_every_method_call_by_name(node, method_name)
         methods.each do |method|
-          next unless parameters_passed?(method, *args)
+          next unless parameters_passed?(method, args)
           return true unless block_given?
 
           yield method
@@ -175,10 +174,19 @@ def find_method_with_args(node, method_name, *args)
 
       # Matches a method with a receiver. Yields to a block with matching method node.
       #
-      # @example to match `Formula.factory(name)`
-      #   find_instance_method_call(node, "Formula", :factory)
-      # @example to match `build.head?`
-      #   find_instance_method_call(node, :build, :head?)
+      # ### Examples
+      #
+      # Match `Formula.factory(name)`.
+      #
+      # ```ruby
+      # find_instance_method_call(node, "Formula", :factory)
+      # ```
+      #
+      # Match `build.head?`.
+      #
+      # ```ruby
+      # find_instance_method_call(node, :build, :head?)
+      # ```
       def find_instance_method_call(node, instance, method_name)
         methods = find_every_method_call_by_name(node, method_name)
         methods.each do |method|
@@ -195,8 +203,13 @@ def find_instance_method_call(node, instance, method_name)
 
       # Matches receiver part of method. Yields to a block with parent node of receiver.
       #
-      # @example to match `ARGV.<whatever>()`
-      #   find_instance_call(node, "ARGV")
+      # ### Example
+      #
+      # Match `ARGV.<whatever>()`.
+      #
+      # ```ruby
+      # find_instance_call(node, "ARGV")
+      # ```
       def find_instance_call(node, name)
         node.each_descendant(:send) do |method_node|
           next if method_node.receiver.nil?
@@ -216,7 +229,7 @@ def find_const(node, const_name)
         return if node.nil?
 
         node.each_descendant(:const) do |const_node|
-          next unless const_node.const_name == const_name
+          next if const_node.const_name != const_name
 
           @offensive_node = const_node
           yield const_node if block_given?
@@ -289,7 +302,7 @@ def find_method_def(node, method_name = nil)
       def block_method_called_in_block?(node, method_name)
         node.body.each_child_node do |call_node|
           next if !call_node.block_type? && !call_node.send_type?
-          next unless call_node.method_name == method_name
+          next if call_node.method_name != method_name
 
           @offensive_node = call_node
           return true
@@ -305,7 +318,7 @@ def method_called?(node, method_name)
           return true
         end
         node.each_child_node(:send) do |call_node|
-          next unless call_node.method_name == method_name
+          next if call_node.method_name != method_name
 
           offending_node(call_node)
           return true
@@ -316,7 +329,7 @@ def method_called?(node, method_name)
       # Check if method_name is called among every descendant node of given node.
       def method_called_ever?(node, method_name)
         node.each_descendant(:send) do |call_node|
-          next unless call_node.method_name == method_name
+          next if call_node.method_name != method_name
 
           @offensive_node = call_node
           return true
@@ -358,7 +371,7 @@ def parameters(method_node)
       # Returns true if the given parameters are present in method call
       # and sets the method call as the offending node.
       # Params can be string, symbol, array, hash, matching regex.
-      def parameters_passed?(method_node, *params)
+      def parameters_passed?(method_node, params)
         method_params = parameters(method_node)
         @offensive_node = method_node
         params.all? do |given_param|
diff --git a/Library/Homebrew/rubocops/shared/helper_functions.rbi b/Library/Homebrew/rubocops/shared/helper_functions.rbi
new file mode 100644
index 0000000000000..e6adcd194a953
--- /dev/null
+++ b/Library/Homebrew/rubocops/shared/helper_functions.rbi
@@ -0,0 +1,5 @@
+# typed: strict
+
+module RuboCop::Cop::HelperFunctions
+  requires_ancestor { RuboCop::Cop::Base }
+end
diff --git a/Library/Homebrew/rubocops/shared/homepage_helper.rb b/Library/Homebrew/rubocops/shared/homepage_helper.rb
new file mode 100644
index 0000000000000..b0f743190c143
--- /dev/null
+++ b/Library/Homebrew/rubocops/shared/homepage_helper.rb
@@ -0,0 +1,95 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "rubocops/shared/helper_functions"
+
+module RuboCop
+  module Cop
+    # This module performs common checks the `homepage` field in both formulae and casks.
+    module HomepageHelper
+      include HelperFunctions
+
+      def audit_homepage(type, content, homepage_node, homepage_parameter_node)
+        @offensive_node = homepage_node
+
+        problem "#{type.to_s.capitalize} should have a homepage." if content.empty?
+
+        @offensive_node = homepage_parameter_node
+        problem "The homepage should start with http or https." unless content.match?(%r{^https?://})
+
+        case content
+          # Freedesktop is complicated to handle - It has SSL/TLS, but only on certain subdomains.
+          # To enable https Freedesktop change the URL from http://project.freedesktop.org/wiki to
+          # https://wiki.freedesktop.org/project_name.
+          # "Software" is redirected to https://wiki.freedesktop.org/www/Software/project_name
+        when %r{^http://((?:www|nice|libopenraw|liboil|telepathy|xorg)\.)?freedesktop\.org/(?:wiki/)?}
+          if content.include?("Software")
+            problem "Freedesktop homepages should be styled " \
+                    "`https://wiki.freedesktop.org/www/Software/project_name`"
+          else
+            problem "Freedesktop homepages should be styled `https://wiki.freedesktop.org/project_name`"
+          end
+
+          # Google Code homepages should end in a slash
+        when %r{^https?://code\.google\.com/p/[^/]+[^/]$}
+          problem "Google Code homepages should end with a slash" do |corrector|
+            corrector.replace(homepage_parameter_node.source_range, "\"#{content}/\"")
+          end
+
+        when %r{^http://([^/]*)\.(sf|sourceforge)\.net(/|$)}
+          fixed = "https://#{Regexp.last_match(1)}.sourceforge.io/"
+          problem "Sourceforge homepages should be `#{fixed}`" do |corrector|
+            corrector.replace(homepage_parameter_node.source_range, "\"#{fixed}\"")
+          end
+
+        when /readthedocs\.org/
+          fixed = content.sub("readthedocs.org", "readthedocs.io")
+          problem "Readthedocs homepages should be `#{fixed}`" do |corrector|
+            corrector.replace(homepage_parameter_node.source_range, "\"#{fixed}\"")
+          end
+
+        when %r{^https://github.com.*\.git$}
+          problem "GitHub homepages should not end with .git" do |corrector|
+            corrector.replace(homepage_parameter_node.source_range, "\"#{content.delete_suffix(".git")}\"")
+          end
+
+          # People will run into mixed content sometimes, but we should enforce and then add
+          # exemptions as they are discovered. Treat mixed content on homepages as a bug.
+          # Justify each exemptions with a code comment so we can keep track here.
+          #
+          # Compact the above into this list as we're able to remove detailed notations, etc over time.
+        when
+               # Check for `http://` GitHub homepage URLs, `https://` is preferred.
+               # NOTE: Only check homepages that are repository pages, not `*.github.com` hosts.
+               %r{^http://github\.com/},
+               %r{^http://[^/]*\.github\.io/},
+
+               # Savannah has full SSL/TLS support but no auto-redirect.
+               # Doesn't apply to the download URLs, only the homepage.
+               %r{^http://savannah\.nongnu\.org/},
+
+               %r{^http://[^/]*\.sourceforge\.io/},
+               # There's an auto-redirect here, but this mistake is incredibly common too.
+               # Only applies to the homepage and subdomains for now, not the FTP URLs.
+               %r{^http://((?:build|cloud|developer|download|extensions|git|
+                               glade|help|library|live|nagios|news|people|
+                               projects|rt|static|wiki|www)\.)?gnome\.org}x,
+               %r{^http://[^/]*\.apache\.org},
+               %r{^http://packages\.debian\.org},
+               %r{^http://wiki\.freedesktop\.org/},
+               %r{^http://((?:www)\.)?gnupg\.org/},
+               %r{^http://ietf\.org},
+               %r{^http://[^/.]+\.ietf\.org},
+               %r{^http://[^/.]+\.tools\.ietf\.org},
+               %r{^http://www\.gnu\.org/},
+               %r{^http://code\.google\.com/},
+               %r{^http://bitbucket\.org/},
+               %r{^http://(?:[^/]*\.)?archive\.org}
+          problem "Please use https:// for #{content}" do |corrector|
+            corrector.replace(homepage_parameter_node.source_range, "\"#{content.sub("http", "https")}\"")
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/shared/on_system_conditionals_helper.rb b/Library/Homebrew/rubocops/shared/on_system_conditionals_helper.rb
new file mode 100644
index 0000000000000..8d074add7ab6e
--- /dev/null
+++ b/Library/Homebrew/rubocops/shared/on_system_conditionals_helper.rb
@@ -0,0 +1,234 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "macos_version"
+require "rubocops/shared/helper_functions"
+
+module RuboCop
+  module Cop
+    # This module performs common checks on `on_{system}` blocks in both formulae and casks.
+    module OnSystemConditionalsHelper
+      extend NodePattern::Macros
+      include HelperFunctions
+
+      ARCH_OPTIONS = [:arm, :intel].freeze
+      BASE_OS_OPTIONS = [:macos, :linux].freeze
+      MACOS_VERSION_OPTIONS = MacOSVersion::SYMBOLS.keys.freeze
+      ON_SYSTEM_OPTIONS = [*ARCH_OPTIONS, *BASE_OS_OPTIONS, *MACOS_VERSION_OPTIONS, :system].freeze
+      MACOS_MODULE_NAMES = ["MacOS", "OS::Mac"].freeze
+
+      MACOS_VERSION_CONDITIONALS = {
+        "==" => nil,
+        "<=" => :or_older,
+        ">=" => :or_newer,
+      }.freeze
+
+      def audit_on_system_blocks(body_node, parent_name)
+        parent_string = if body_node.def_type?
+          "def #{parent_name}"
+        else
+          "#{parent_name} do"
+        end
+
+        ON_SYSTEM_OPTIONS.each do |on_system_option|
+          on_system_method = :"on_#{on_system_option}"
+          if_statement_string = if ARCH_OPTIONS.include?(on_system_option)
+            "if Hardware::CPU.#{on_system_option}?"
+          elsif BASE_OS_OPTIONS.include?(on_system_option)
+            "if OS.#{(on_system_option == :macos) ? "mac" : "linux"}?"
+          elsif on_system_option == :system
+            "if OS.linux? || MacOS.version"
+          else
+            "if MacOS.version"
+          end
+
+          find_every_method_call_by_name(body_node, on_system_method).each do |on_system_node|
+            if_conditional = ""
+            if MACOS_VERSION_OPTIONS.include? on_system_option
+              on_macos_version_method_call(on_system_node, on_method: on_system_method) do |on_method_parameters|
+                if on_method_parameters.empty?
+                  if_conditional = " == :#{on_system_option}"
+                else
+                  if_condition_operator = MACOS_VERSION_CONDITIONALS.key(on_method_parameters.first)
+                  if_conditional = " #{if_condition_operator} :#{on_system_option}"
+                end
+              end
+            elsif on_system_option == :system
+              on_system_method_call(on_system_node) do |macos_symbol|
+                base_os, condition = macos_symbol.to_s.split(/_(?=or_)/).map(&:to_sym)
+                if_condition_operator = MACOS_VERSION_CONDITIONALS.key(condition)
+                if_conditional = " #{if_condition_operator} :#{base_os}"
+              end
+            end
+
+            offending_node(on_system_node)
+            problem "Don't use `#{on_system_node.source}` in `#{parent_string}`, " \
+                    "use `#{if_statement_string}#{if_conditional}` instead." do |corrector|
+              block_node = offending_node.parent
+              next if block_node.type != :block
+
+              # TODO: could fix corrector to handle this but punting for now.
+              next if block_node.single_line?
+
+              source_range = offending_node.source_range.join(offending_node.parent.loc.begin)
+              corrector.replace(source_range, "#{if_statement_string}#{if_conditional}")
+            end
+          end
+        end
+      end
+
+      def audit_arch_conditionals(body_node, allowed_methods: [], allowed_blocks: [])
+        ARCH_OPTIONS.each do |arch_option|
+          else_method = (arch_option == :arm) ? :on_intel : :on_arm
+          if_arch_node_search(body_node, arch: :"#{arch_option}?") do |if_node, else_node|
+            next if node_is_allowed?(if_node, allowed_methods:, allowed_blocks:)
+
+            if_statement_problem(if_node, "if Hardware::CPU.#{arch_option}?", "on_#{arch_option}",
+                                 else_method:, else_node:)
+          end
+        end
+
+        [:arch, :arm?, :intel?].each do |method|
+          hardware_cpu_search(body_node, method:) do |method_node|
+            # These should already be caught by `if_arch_node_search`
+            next if method_node.parent.source.start_with? "if #{method_node.source}"
+            next if node_is_allowed?(method_node, allowed_methods:, allowed_blocks:)
+
+            offending_node(method_node)
+            problem "Don't use `#{method_node.source}`, use `on_arm` and `on_intel` blocks instead."
+          end
+        end
+      end
+
+      def audit_base_os_conditionals(body_node, allowed_methods: [], allowed_blocks: [])
+        BASE_OS_OPTIONS.each do |base_os_option|
+          os_method, else_method = if base_os_option == :macos
+            [:mac?, :on_linux]
+          else
+            [:linux?, :on_macos]
+          end
+          if_base_os_node_search(body_node, base_os: os_method) do |if_node, else_node|
+            next if node_is_allowed?(if_node, allowed_methods:, allowed_blocks:)
+
+            if_statement_problem(if_node, "if OS.#{os_method}", "on_#{base_os_option}",
+                                 else_method:, else_node:)
+          end
+        end
+      end
+
+      def audit_macos_version_conditionals(body_node, allowed_methods: [], allowed_blocks: [],
+                                           recommend_on_system: true)
+        MACOS_VERSION_OPTIONS.each do |macos_version_option|
+          if_macos_version_node_search(body_node, os_version: macos_version_option) do |if_node, operator, else_node|
+            next if node_is_allowed?(if_node, allowed_methods:, allowed_blocks:)
+
+            autocorrect = else_node.blank? && MACOS_VERSION_CONDITIONALS.key?(operator.to_s)
+            on_system_method_string = if recommend_on_system && operator == :<
+              "on_system"
+            elsif recommend_on_system && operator == :<=
+              "on_system :linux, macos: :#{macos_version_option}_or_older"
+            elsif operator != :== && MACOS_VERSION_CONDITIONALS.key?(operator.to_s)
+              "on_#{macos_version_option} :#{MACOS_VERSION_CONDITIONALS[operator.to_s]}"
+            else
+              "on_#{macos_version_option}"
+            end
+
+            if_statement_problem(if_node, "if MacOS.version #{operator} :#{macos_version_option}",
+                                 on_system_method_string, autocorrect:)
+          end
+
+          macos_version_comparison_search(body_node, os_version: macos_version_option) do |method_node|
+            # These should already be caught by `if_macos_version_node_search`
+            next if method_node.parent.source.start_with? "if #{method_node.source}"
+            next if node_is_allowed?(method_node, allowed_methods:, allowed_blocks:)
+
+            offending_node(method_node)
+            problem "Don't use `#{method_node.source}`, use `on_{macos_version}` blocks instead."
+          end
+        end
+      end
+
+      def audit_macos_references(body_node, allowed_methods: [], allowed_blocks: [])
+        MACOS_MODULE_NAMES.each do |macos_module_name|
+          find_const(body_node, macos_module_name) do |node|
+            next if node_is_allowed?(node, allowed_methods:, allowed_blocks:)
+
+            offending_node(node)
+            problem "Don't use `#{macos_module_name}` where it could be called on Linux."
+          end
+        end
+      end
+
+      private
+
+      def if_statement_problem(if_node, if_statement_string, on_system_method_string,
+                               else_method: nil, else_node: nil, autocorrect: true)
+        offending_node(if_node)
+        problem "Don't use `#{if_statement_string}`, " \
+                "use `#{on_system_method_string} do` instead." do |corrector|
+          next unless autocorrect
+          # TODO: could fix corrector to handle this but punting for now.
+          next if if_node.unless?
+
+          if else_method.present? && else_node.present?
+            corrector.replace(if_node.source_range,
+                              "#{on_system_method_string} do\n#{if_node.body.source}\nend\n" \
+                              "#{else_method} do\n#{else_node.source}\nend")
+          else
+            corrector.replace(if_node.source_range, "#{on_system_method_string} do\n#{if_node.body.source}\nend")
+          end
+        end
+      end
+
+      def node_is_allowed?(node, allowed_methods: [], allowed_blocks: [])
+        # TODO: check to see if it's legal
+        valid = T.let(false, T::Boolean)
+        node.each_ancestor do |ancestor|
+          valid_method_names = case ancestor.type
+          when :def
+            allowed_methods
+          when :block
+            allowed_blocks
+          else
+            next
+          end
+          next unless valid_method_names.include?(ancestor.method_name)
+
+          valid = true
+          break
+        end
+        return true if valid
+
+        false
+      end
+
+      def_node_matcher :on_macos_version_method_call, <<~PATTERN
+        (send nil? %on_method (sym ${:or_newer :or_older})?)
+      PATTERN
+
+      def_node_matcher :on_system_method_call, <<~PATTERN
+        (send nil? :on_system (sym :linux) (hash (pair (sym :macos) (sym $_))))
+      PATTERN
+
+      def_node_search :hardware_cpu_search, <<~PATTERN
+        (send (const (const nil? :Hardware) :CPU) %method)
+      PATTERN
+
+      def_node_search :macos_version_comparison_search, <<~PATTERN
+        (send (send (const nil? :MacOS) :version) {:== :<= :< :>= :> :!=} (sym %os_version))
+      PATTERN
+
+      def_node_search :if_arch_node_search, <<~PATTERN
+        $(if (send (const (const nil? :Hardware) :CPU) %arch) _ $_)
+      PATTERN
+
+      def_node_search :if_base_os_node_search, <<~PATTERN
+        $(if (send (const nil? :OS) %base_os) _ $_)
+      PATTERN
+
+      def_node_search :if_macos_version_node_search, <<~PATTERN
+        $(if (send (send (const nil? :MacOS) :version) ${:== :<= :< :>= :> :!=} (sym %os_version)) _ $_)
+      PATTERN
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/shared/url_helper.rb b/Library/Homebrew/rubocops/shared/url_helper.rb
new file mode 100644
index 0000000000000..1d5e6a32ff943
--- /dev/null
+++ b/Library/Homebrew/rubocops/shared/url_helper.rb
@@ -0,0 +1,272 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "rubocops/shared/helper_functions"
+
+module RuboCop
+  module Cop
+    # This module performs common checks the `homepage` field in both formulae and casks.
+    module UrlHelper
+      include HelperFunctions
+
+      # Yields to block when there is a match.
+      #
+      # @param urls [Array] url/mirror method call nodes
+      # @param regex [Regexp] pattern to match URLs
+      def audit_urls(urls, regex)
+        urls.each_with_index do |url_node, index|
+          if @type == :cask
+            url_string_node = url_node.first_argument
+            url_string = url_node.source
+          else
+            url_string_node = parameters(url_node).first
+            url_string = string_content(url_string_node)
+          end
+
+          match_object = regex_match_group(url_string_node, regex)
+          next unless match_object
+
+          offending_node(url_string_node.parent)
+
+          yield match_object, url_string, index
+        end
+      end
+
+      def audit_url(type, urls, mirrors, livecheck_url: false)
+        @type = type
+
+        # GNU URLs; doesn't apply to mirrors
+        gnu_pattern = %r{^(?:https?|ftp)://ftpmirror\.gnu\.org/(.*)}
+        audit_urls(urls, gnu_pattern) do |match, url|
+          problem "Please use \"https://ftp.gnu.org/gnu/#{match[1]}\" instead of #{url}."
+        end
+
+        # Fossies upstream requests they aren't used as primary URLs
+        # https://github.com/Homebrew/homebrew-core/issues/14486#issuecomment-307753234
+        fossies_pattern = %r{^https?://fossies\.org/}
+        audit_urls(urls, fossies_pattern) do
+          problem "Please don't use fossies.org in the url (using as a mirror is fine)"
+        end
+
+        apache_pattern = %r{^https?://(?:[^/]*\.)?apache\.org/(?:dyn/closer\.cgi\?path=/?|dist/)(.*)}i
+        audit_urls(urls, apache_pattern) do |match, url|
+          next if url == livecheck_url
+
+          problem "#{url} should be `https://www.apache.org/dyn/closer.lua?path=#{match[1]}`"
+        end
+
+        version_control_pattern = %r{^(cvs|bzr|hg|fossil)://}
+        audit_urls(urls, version_control_pattern) do |match, _|
+          problem "Use of the #{match[1]}:// scheme is deprecated, pass `:using => :#{match[1]}` instead"
+        end
+
+        svn_pattern = %r{^svn\+http://}
+        audit_urls(urls, svn_pattern) do |_, _|
+          problem "Use of the svn+http:// scheme is deprecated, pass `:using => :svn` instead"
+        end
+
+        audit_urls(mirrors, /.*/) do |_, mirror|
+          urls.each do |url|
+            url_string = string_content(parameters(url).first)
+            next unless url_string.eql?(mirror)
+
+            problem "URL should not be duplicated as a mirror: #{url_string}"
+          end
+        end
+
+        urls += mirrors
+
+        # Check a variety of SSL/TLS URLs that don't consistently auto-redirect
+        # or are overly common errors that need to be reduced & fixed over time.
+        http_to_https_patterns = Regexp.union([%r{^http://ftp\.gnu\.org/},
+                                               %r{^http://ftpmirror\.gnu\.org/},
+                                               %r{^http://download\.savannah\.gnu\.org/},
+                                               %r{^http://download-mirror\.savannah\.gnu\.org/},
+                                               %r{^http://(?:[^/]*\.)?apache\.org/},
+                                               %r{^http://code\.google\.com/},
+                                               %r{^http://fossies\.org/},
+                                               %r{^http://mirrors\.kernel\.org/},
+                                               %r{^http://mirrors\.ocf\.berkeley\.edu/},
+                                               %r{^http://(?:[^/]*\.)?bintray\.com/},
+                                               %r{^http://tools\.ietf\.org/},
+                                               %r{^http://launchpad\.net/},
+                                               %r{^http://github\.com/},
+                                               %r{^http://bitbucket\.org/},
+                                               %r{^http://anonscm\.debian\.org/},
+                                               %r{^http://cpan\.metacpan\.org/},
+                                               %r{^http://hackage\.haskell\.org/},
+                                               %r{^http://(?:[^/]*\.)?archive\.org},
+                                               %r{^http://(?:[^/]*\.)?freedesktop\.org},
+                                               %r{^http://(?:[^/]*\.)?mirrorservice\.org/},
+                                               %r{^http://downloads?\.sourceforge\.net/}])
+        audit_urls(urls, http_to_https_patterns) do |_, url, index|
+          # It's fine to have a plain HTTP mirror further down the mirror list.
+          https_url = url.dup.insert(4, "s")
+          https_index = T.let(nil, T.nilable(Integer))
+          audit_urls(urls, https_url) do |_, _, found_https_index|
+            https_index = found_https_index
+          end
+          problem "Please use https:// for #{url}" if !https_index || https_index > index
+        end
+
+        apache_mirror_pattern = %r{^https?://(?:[^/]*\.)?apache\.org/dyn/closer\.(?:cgi|lua)\?path=/?(.*)}i
+        audit_urls(mirrors, apache_mirror_pattern) do |match, mirror|
+          problem "Please use `https://archive.apache.org/dist/#{match[1]}` as a mirror instead of #{mirror}."
+        end
+
+        cpan_pattern = %r{^http://search\.mcpan\.org/CPAN/(.*)}i
+        audit_urls(urls, cpan_pattern) do |match, url|
+          problem "#{url} should be `https://cpan.metacpan.org/#{match[1]}`"
+        end
+
+        gnome_pattern = %r{^(http|ftp)://ftp\.gnome\.org/pub/gnome/(.*)}i
+        audit_urls(urls, gnome_pattern) do |match, url|
+          problem "#{url} should be `https://download.gnome.org/#{match[2]}`"
+        end
+
+        debian_pattern = %r{^git://anonscm\.debian\.org/users/(.*)}i
+        audit_urls(urls, debian_pattern) do |match, url|
+          problem "#{url} should be `https://anonscm.debian.org/git/users/#{match[1]}`"
+        end
+
+        # Prefer HTTP/S when possible over FTP protocol due to possible firewalls.
+        mirror_service_pattern = %r{^ftp://ftp\.mirrorservice\.org}
+        audit_urls(urls, mirror_service_pattern) do |_, url|
+          problem "Please use https:// for #{url}"
+        end
+
+        cpan_ftp_pattern = %r{^ftp://ftp\.cpan\.org/pub/CPAN(.*)}i
+        audit_urls(urls, cpan_ftp_pattern) do |match_obj, url|
+          problem "#{url} should be `http://search.cpan.org/CPAN#{match_obj[1]}`"
+        end
+
+        # SourceForge url patterns
+        sourceforge_patterns = %r{^https?://.*\b(sourceforge|sf)\.(com|net)}
+        audit_urls(urls, sourceforge_patterns) do |_, url|
+          # Skip if the URL looks like a SVN repository.
+          next if url.include? "/svnroot/"
+          next if url.include? "svn.sourceforge"
+          next if url.include? "/p/"
+
+          if url =~ /(\?|&)use_mirror=/
+            problem "Don't use #{Regexp.last_match(1)}use_mirror in SourceForge urls (url is #{url})."
+          end
+
+          problem "Don't use /download in SourceForge urls (url is #{url})." if url.end_with?("/download")
+
+          if url.match?(%r{^https?://(sourceforge|sf)\.}) && url != livecheck_url
+            problem "Use https://downloads.sourceforge.net to get geolocation (url is #{url})."
+          end
+
+          if url.match?(%r{^https?://prdownloads\.})
+            problem "Don't use prdownloads in SourceForge urls (url is #{url})."
+          end
+
+          if url.match?(%r{^http://\w+\.dl\.})
+            problem "Don't use specific dl mirrors in SourceForge urls (url is #{url})."
+          end
+
+          # sf.net does HTTPS -> HTTP redirects.
+          if url.match?(%r{^https?://downloads?\.sf\.net})
+            problem "Use https://downloads.sourceforge.net instead of downloads.sf.net (url is #{url})"
+          end
+        end
+
+        # Debian has an abundance of secure mirrors. Let's not pluck the insecure
+        # one out of the grab bag.
+        unsecure_deb_pattern = %r{^http://http\.debian\.net/debian/(.*)}i
+        audit_urls(urls, unsecure_deb_pattern) do |match, _|
+          problem <<~EOS
+            Please use a secure mirror for Debian URLs.
+            We recommend:
+              https://deb.debian.org/debian/#{match[1]}
+          EOS
+        end
+
+        # Check to use canonical URLs for Debian packages
+        noncanon_deb_pattern =
+          Regexp.union([%r{^https://mirrors\.kernel\.org/debian/},
+                        %r{^https://mirrors\.ocf\.berkeley\.edu/debian/},
+                        %r{^https://(?:[^/]*\.)?mirrorservice\.org/sites/ftp\.debian\.org/debian/}])
+        audit_urls(urls, noncanon_deb_pattern) do |_, url|
+          problem "Please use https://deb.debian.org/debian/ for #{url}"
+        end
+
+        # Check for new-url Google Code download URLs, https:// is preferred
+        google_code_pattern = Regexp.union([%r{^http://[A-Za-z0-9\-.]*\.googlecode\.com/files.*},
+                                            %r{^http://code\.google\.com/}])
+        audit_urls(urls, google_code_pattern) do |_, url|
+          problem "Please use https:// for #{url}"
+        end
+
+        # Check for `git://` GitHub repository URLs, https:// is preferred.
+        git_gh_pattern = %r{^git://[^/]*github\.com/}
+        audit_urls(urls, git_gh_pattern) do |_, url|
+          problem "Please use https:// for #{url}"
+        end
+
+        # Check for `git://` Gitorious repository URLs, https:// is preferred.
+        git_gitorious_pattern = %r{^git://[^/]*gitorious\.org/}
+        audit_urls(urls, git_gitorious_pattern) do |_, url|
+          problem "Please use https:// for #{url}"
+        end
+
+        # Check for `http://` GitHub repository URLs, https:// is preferred.
+        gh_pattern = %r{^http://github\.com/.*\.git$}
+        audit_urls(urls, gh_pattern) do |_, url|
+          problem "Please use https:// for #{url}"
+        end
+
+        # Check for master branch GitHub archives.
+        if type == :formula
+          tarball_gh_pattern = %r{^https://github\.com/.*archive/master\.(tar\.gz|zip)$}
+          audit_urls(urls, tarball_gh_pattern) do
+            problem "Use versioned rather than branch tarballs for stable checksums."
+          end
+        end
+
+        # Use new-style archive downloads.
+        archive_gh_pattern = %r{https://.*github.*/(?:tar|zip)ball/}
+        audit_urls(urls, archive_gh_pattern) do |_, url|
+          next if url.end_with?(".git")
+
+          problem "Use /archive/ URLs for GitHub tarballs (url is #{url})."
+        end
+
+        archive_refs_gh_pattern = %r{https://.*github.+/archive/(?![a-fA-F0-9]{40})(?!refs/(tags|heads)/)(.*)\.tar\.gz$}
+        audit_urls(urls, archive_refs_gh_pattern) do |match, url|
+          next if url.end_with?(".git")
+
+          problem "Use refs/tags/#{match[2]} or refs/heads/#{match[2]} for GitHub references (url is #{url})."
+        end
+
+        # Don't use GitHub .zip files
+        zip_gh_pattern = %r{https://.*github.*/(archive|releases)/.*\.zip$}
+        audit_urls(urls, zip_gh_pattern) do |_, url|
+          next if url.match? %r{raw.githubusercontent.com/.*/.*/(main|master|HEAD)/}
+          next if url.include?("releases/download")
+          next if url.include?("desktop.githubusercontent.com/releases/")
+
+          problem "Use GitHub tarballs rather than zipballs (url is #{url})."
+        end
+
+        # Don't use GitHub codeload URLs
+        codeload_gh_pattern = %r{https?://codeload\.github\.com/(.+)/(.+)/(?:tar\.gz|zip)/(.+)}
+        audit_urls(urls, codeload_gh_pattern) do |match, url|
+          problem <<~EOS
+            Use GitHub archive URLs:
+              https://github.com/#{match[1]}/#{match[2]}/archive/#{match[3]}.tar.gz
+            Rather than codeload:
+              #{url}
+          EOS
+        end
+
+        # Check for Maven Central URLs, prefer HTTPS redirector over specific host
+        maven_pattern = %r{https?://(?:central|repo\d+)\.maven\.org/maven2/(.+)$}
+        audit_urls(urls, maven_pattern) do |match, url|
+          problem "#{url} should be `https://search.maven.org/remotecontent?filepath=#{match[1]}`"
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/shell_command_stub.rb b/Library/Homebrew/rubocops/shell_command_stub.rb
new file mode 100644
index 0000000000000..34d19999054c8
--- /dev/null
+++ b/Library/Homebrew/rubocops/shell_command_stub.rb
@@ -0,0 +1,24 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Homebrew
+      class ShellCommandStub < Base
+        MSG = "Shell command stubs must have a `.sh` counterpart."
+        RESTRICT_ON_SEND = [:include].freeze
+
+        sig { params(node: AST::SendNode).void }
+        def on_send(node)
+          return if node.first_argument&.const_name != "ShellCommand"
+
+          stub_path = Pathname.new(processed_source.file_path)
+          sh_cmd_path = Pathname.new("#{stub_path.dirname}/#{stub_path.basename(".rb")}.sh")
+          return if sh_cmd_path.exist?
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/rubocops/shell_commands.rb b/Library/Homebrew/rubocops/shell_commands.rb
index f1352365a64d0..a776e58e8b98c 100644
--- a/Library/Homebrew/rubocops/shell_commands.rb
+++ b/Library/Homebrew/rubocops/shell_commands.rb
@@ -1,8 +1,9 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "active_support/core_ext/array/access"
+require "extend/array"
 require "rubocops/shared/helper_functions"
+require "shellwords"
 
 module RuboCop
   module Cop
@@ -39,13 +40,13 @@ module Homebrew
         until
         while
       ].freeze
+      private_constant :SHELL_BUILTINS
 
       # https://github.com/ruby/ruby/blob/v2_6_3/process.c#L2495
       SHELL_METACHARACTERS = %W[* ? { } [ ] < > ( ) ~ & | \\ $ ; ' ` " \n #].freeze
+      private_constant :SHELL_METACHARACTERS
 
       # This cop makes sure that shell command arguments are separated.
-      #
-      # @api private
       class ShellCommands < Base
         include HelperFunctions
         extend AutoCorrector
@@ -61,11 +62,13 @@ class ShellCommands < Base
           [:Utils, :popen_write],
           [:Utils, :safe_popen_write],
         ].freeze
+        private_constant :TARGET_METHODS
+
         RESTRICT_ON_SEND = TARGET_METHODS.map(&:second).uniq.freeze
 
         def on_send(node)
           TARGET_METHODS.each do |target_class, target_method|
-            next unless node.method_name == target_method
+            next if node.method_name != target_method
 
             target_receivers = if target_class.nil?
               [nil, s(:const, nil, :Kernel), s(:const, nil, :Homebrew)]
@@ -100,7 +103,7 @@ def on_send(node)
             else
               target_method.to_s
             end
-            add_offense(first_arg, message: format(MSG, method: method_string, good_args: good_args)) do |corrector|
+            add_offense(first_arg, message: format(MSG, method: method_string, good_args:)) do |corrector|
               corrector.replace(first_arg.source_range, good_args)
             end
           end
@@ -108,8 +111,6 @@ def on_send(node)
       end
 
       # This cop disallows shell metacharacters in `exec` calls.
-      #
-      # @api private
       class ExecShellMetacharacters < Base
         include HelperFunctions
 
diff --git a/Library/Homebrew/rubocops/text.rb b/Library/Homebrew/rubocops/text.rb
index 67a6f70f2c760..d7f0101fea002 100644
--- a/Library/Homebrew/rubocops/text.rb
+++ b/Library/Homebrew/rubocops/text.rb
@@ -1,38 +1,46 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
     module FormulaAudit
       # This cop checks for various problems in a formula's source code.
-      #
-      # @api private
       class Text < FormulaCop
         extend AutoCorrector
 
-        def audit_formula(node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          node = formula_nodes.node
           full_source_content = source_buffer(node).source
 
           if (match = full_source_content.match(/^require ['"]formula['"]$/))
             range = source_range(source_buffer(node), match.pre_match.count("\n") + 1, 0, match[0].length)
             add_offense(range, message: "`#{match}` is now unnecessary") do |corrector|
-              corrector.remove(range_with_surrounding_space(range: range))
+              corrector.remove(range_with_surrounding_space(range:))
             end
           end
 
-          if !find_node_method_by_name(body_node, :plist_options) &&
-             find_method_def(body_node, :plist)
-            problem "Please set plist_options when using a formula-defined plist."
+          return if (body_node = formula_nodes.body_node).nil?
+
+          if find_method_def(body_node, :plist)
+            problem "`def plist` is deprecated. Please use services instead: https://docs.brew.sh/Formula-Cookbook#service-files"
           end
 
-          if (depends_on?("openssl") || depends_on?("openssl@1.1")) && depends_on?("libressl")
+          if (depends_on?("openssl") || depends_on?("openssl@3")) && depends_on?("libressl")
             problem "Formulae should not depend on both OpenSSL and LibreSSL (even optionally)."
           end
 
-          if formula_tap == "homebrew-core" && (depends_on?("veclibfort") || depends_on?("lapack"))
-            problem "Formulae in homebrew/core should use OpenBLAS as the default serial linear algebra library."
+          if formula_tap == "homebrew-core"
+            if depends_on?("veclibfort") || depends_on?("lapack")
+              problem "Formulae in homebrew/core should use OpenBLAS as the default serial linear algebra library."
+            end
+
+            if find_node_method_by_name(body_node, :keg_only)&.source&.include?("HOMEBREW_PREFIX")
+              problem "`keg_only` reason should not include `HOMEBREW_PREFIX` " \
+                      "as it creates confusing `brew info` output."
+            end
           end
 
           unless method_called_ever?(body_node, :go_resource)
@@ -46,31 +54,39 @@ def audit_formula(node, _class_node, _parent_class_node, body_node)
             problem "\"Formula.factory(name)\" is deprecated in favor of \"Formula[name]\""
           end
 
+          find_method_with_args(body_node, :revision, 0) do
+            problem "\"revision 0\" is unnecessary"
+          end
+
           find_method_with_args(body_node, :system, "xcodebuild") do
             problem %q(use "xcodebuild *args" instead of "system 'xcodebuild', *args")
           end
 
+          if !depends_on?(:xcode) && method_called_ever?(body_node, :xcodebuild)
+            problem "`xcodebuild` needs an Xcode dependency"
+          end
+
           if (method_node = find_method_def(body_node, :install))
             find_method_with_args(method_node, :system, "go", "get") do
               problem "Do not use `go get`. Please ask upstream to implement Go vendoring"
             end
+
+            find_method_with_args(method_node, :system, "cargo", "build") do |m|
+              next if parameters_passed?(m, [/--lib/])
+
+              problem "use \"cargo\", \"install\", *std_cargo_args"
+            end
           end
 
           find_method_with_args(body_node, :system, "dep", "ensure") do |d|
-            next if parameters_passed?(d, /vendor-only/)
+            next if parameters_passed?(d, [/vendor-only/])
             next if @formula_name == "goose" # needed in 2.3.0
 
             problem "use \"dep\", \"ensure\", \"-vendor-only\""
           end
 
-          find_method_with_args(body_node, :system, "cargo", "build") do |m|
-            next if parameters_passed?(m, /--lib/)
-
-            problem "use \"cargo\", \"install\", *std_cargo_args"
-          end
-
           find_every_method_call_by_name(body_node, :system).each do |m|
-            next unless parameters_passed?(m, /make && make/)
+            next unless parameters_passed?(m, [/make && make/])
 
             offending_node(m)
             problem "Use separate `make` calls"
@@ -102,10 +118,13 @@ def audit_formula(node, _class_node, _parent_class_node, body_node)
 
     module FormulaAuditStrict
       # This cop contains stricter checks for various problems in a formula's source code.
-      #
-      # @api private
       class Text < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        extend AutoCorrector
+
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
           find_method_with_args(body_node, :go_resource) do
             problem "`go_resource`s are deprecated. Please ask upstream to implement Go vendoring"
           end
@@ -124,7 +143,17 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
             problem "Use `\#{pkgshare}` instead of `\#{share}/#{@formula_name}`"
           end
 
-          return unless formula_tap == "homebrew-core"
+          interpolated_bin_path_starts_with(body_node, "/#{@formula_name}") do |bin_node|
+            next if bin_node.ancestors.any?(&:array_type?)
+
+            offending_node(bin_node)
+            cmd = bin_node.source.match(%r{\#{bin}/(\S+)})[1]&.delete_suffix('"') || @formula_name
+            problem "Use `bin/\"#{cmd}\"` instead of `\"\#{bin}/#{cmd}\"`" do |corrector|
+              corrector.replace(bin_node.loc.expression, "bin/\"#{cmd}\"")
+            end
+          end
+
+          return if formula_tap != "homebrew-core"
 
           find_method_with_args(body_node, :env, :std) do
             problem "`env :std` in homebrew/core formulae is deprecated"
@@ -132,8 +161,16 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
         end
 
         # Check whether value starts with the formula name and then a "/", " " or EOS.
-        def path_starts_with?(path, starts_with)
-          path.match?(%r{^#{Regexp.escape(starts_with)}(/| |$)})
+        # If we're checking for "#{bin}", we also check for "-" since similar binaries also don't need interpolation.
+        def path_starts_with?(path, starts_with, bin: false)
+          ending = bin ? "/|-|$" : "/| |$"
+          path.match?(/^#{Regexp.escape(starts_with)}(#{ending})/)
+        end
+
+        def path_starts_with_bin?(path, starts_with)
+          return false if path.include?(" ")
+
+          path_starts_with?(path, starts_with, bin: true)
         end
 
         # Find "#{share}/foo"
@@ -141,6 +178,11 @@ def path_starts_with?(path, starts_with)
           $(dstr (begin (send nil? :share)) (str #path_starts_with?(%1)))
         EOS
 
+        # Find "#{bin}/foo" and "#{bin}/foo-bar"
+        def_node_search :interpolated_bin_path_starts_with, <<~EOS
+          $(dstr (begin (send nil? :bin)) (str #path_starts_with_bin?(%1)))
+        EOS
+
         # Find share/"foo"
         def_node_search :share_path_starts_with, <<~EOS
           $(send (send nil? :share) :/ (str #path_starts_with?(%1)))
diff --git a/Library/Homebrew/rubocops/urls.rb b/Library/Homebrew/rubocops/urls.rb
index 67860051d427b..af13b6cfb5a08 100644
--- a/Library/Homebrew/rubocops/urls.rb
+++ b/Library/Homebrew/rubocops/urls.rb
@@ -1,16 +1,20 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
+require "rubocops/shared/url_helper"
 
 module RuboCop
   module Cop
     module FormulaAudit
       # This cop audits `url`s and `mirror`s in formulae.
-      #
-      # @api private
       class Urls < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        include UrlHelper
+
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
           urls = find_every_func_call_by_name(body_node, :url)
           mirrors = find_every_func_call_by_name(body_node, :mirror)
 
@@ -20,225 +24,7 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
             string_content(parameters(livecheck_url).first)
           end
 
-          # GNU URLs; doesn't apply to mirrors
-          gnu_pattern = %r{^(?:https?|ftp)://ftpmirror\.gnu\.org/(.*)}
-          audit_urls(urls, gnu_pattern) do |match, url|
-            problem "Please use \"https://ftp.gnu.org/gnu/#{match[1]}\" instead of #{url}."
-          end
-
-          # Fossies upstream requests they aren't used as primary URLs
-          # https://github.com/Homebrew/homebrew-core/issues/14486#issuecomment-307753234
-          fossies_pattern = %r{^https?://fossies\.org/}
-          audit_urls(urls, fossies_pattern) do
-            problem "Please don't use fossies.org in the url (using as a mirror is fine)"
-          end
-
-          apache_pattern = %r{^https?://(?:[^/]*\.)?apache\.org/(?:dyn/closer\.cgi\?path=/?|dist/)(.*)}i
-          audit_urls(urls, apache_pattern) do |match, url|
-            next if url == livecheck_url
-
-            problem "#{url} should be `https://www.apache.org/dyn/closer.lua?path=#{match[1]}`"
-          end
-
-          version_control_pattern = %r{^(cvs|bzr|hg|fossil)://}
-          audit_urls(urls, version_control_pattern) do |match, _|
-            problem "Use of the #{match[1]}:// scheme is deprecated, pass `:using => :#{match[1]}` instead"
-          end
-
-          svn_pattern = %r{^svn\+http://}
-          audit_urls(urls, svn_pattern) do |_, _|
-            problem "Use of the svn+http:// scheme is deprecated, pass `:using => :svn` instead"
-          end
-
-          audit_urls(mirrors, /.*/) do |_, mirror|
-            urls.each do |url|
-              url_string = string_content(parameters(url).first)
-              next unless url_string.eql?(mirror)
-
-              problem "URL should not be duplicated as a mirror: #{url_string}"
-            end
-          end
-
-          urls += mirrors
-
-          # Check a variety of SSL/TLS URLs that don't consistently auto-redirect
-          # or are overly common errors that need to be reduced & fixed over time.
-          http_to_https_patterns = Regexp.union([%r{^http://ftp\.gnu\.org/},
-                                                 %r{^http://ftpmirror\.gnu\.org/},
-                                                 %r{^http://download\.savannah\.gnu\.org/},
-                                                 %r{^http://download-mirror\.savannah\.gnu\.org/},
-                                                 %r{^http://(?:[^/]*\.)?apache\.org/},
-                                                 %r{^http://code\.google\.com/},
-                                                 %r{^http://fossies\.org/},
-                                                 %r{^http://mirrors\.kernel\.org/},
-                                                 %r{^http://mirrors\.ocf\.berkeley\.edu/},
-                                                 %r{^http://(?:[^/]*\.)?bintray\.com/},
-                                                 %r{^http://tools\.ietf\.org/},
-                                                 %r{^http://launchpad\.net/},
-                                                 %r{^http://github\.com/},
-                                                 %r{^http://bitbucket\.org/},
-                                                 %r{^http://anonscm\.debian\.org/},
-                                                 %r{^http://cpan\.metacpan\.org/},
-                                                 %r{^http://hackage\.haskell\.org/},
-                                                 %r{^http://(?:[^/]*\.)?archive\.org},
-                                                 %r{^http://(?:[^/]*\.)?freedesktop\.org},
-                                                 %r{^http://(?:[^/]*\.)?mirrorservice\.org/}])
-          audit_urls(urls, http_to_https_patterns) do |_, url, index|
-            # It's fine to have a plain HTTP mirror further down the mirror list.
-            https_url = url.dup.insert(4, "s")
-            https_index = nil
-            audit_urls(urls, https_url) do |_, _, found_https_index|
-              https_index = found_https_index
-            end
-            problem "Please use https:// for #{url}" if !https_index || https_index > index
-          end
-
-          apache_mirror_pattern = %r{^https?://(?:[^/]*\.)?apache\.org/dyn/closer\.(?:cgi|lua)\?path=/?(.*)}i
-          audit_urls(mirrors, apache_mirror_pattern) do |match, mirror|
-            problem "Please use `https://archive.apache.org/dist/#{match[1]}` as a mirror instead of #{mirror}."
-          end
-
-          cpan_pattern = %r{^http://search\.mcpan\.org/CPAN/(.*)}i
-          audit_urls(urls, cpan_pattern) do |match, url|
-            problem "#{url} should be `https://cpan.metacpan.org/#{match[1]}`"
-          end
-
-          gnome_pattern = %r{^(http|ftp)://ftp\.gnome\.org/pub/gnome/(.*)}i
-          audit_urls(urls, gnome_pattern) do |match, url|
-            problem "#{url} should be `https://download.gnome.org/#{match[2]}`"
-          end
-
-          debian_pattern = %r{^git://anonscm\.debian\.org/users/(.*)}i
-          audit_urls(urls, debian_pattern) do |match, url|
-            problem "#{url} should be `https://anonscm.debian.org/git/users/#{match[1]}`"
-          end
-
-          # Prefer HTTP/S when possible over FTP protocol due to possible firewalls.
-          mirror_service_pattern = %r{^ftp://ftp\.mirrorservice\.org}
-          audit_urls(urls, mirror_service_pattern) do |_, url|
-            problem "Please use https:// for #{url}"
-          end
-
-          cpan_ftp_pattern = %r{^ftp://ftp\.cpan\.org/pub/CPAN(.*)}i
-          audit_urls(urls, cpan_ftp_pattern) do |match_obj, url|
-            problem "#{url} should be `http://search.cpan.org/CPAN#{match_obj[1]}`"
-          end
-
-          # SourceForge url patterns
-          sourceforge_patterns = %r{^https?://.*\b(sourceforge|sf)\.(com|net)}
-          audit_urls(urls, sourceforge_patterns) do |_, url|
-            # Skip if the URL looks like a SVN repo
-            next if url.include? "/svnroot/"
-            next if url.include? "svn.sourceforge"
-            next if url.include? "/p/"
-
-            if url =~ /(\?|&)use_mirror=/
-              problem "Don't use #{Regexp.last_match(1)}use_mirror in SourceForge urls (url is #{url})."
-            end
-
-            problem "Don't use /download in SourceForge urls (url is #{url})." if url.end_with?("/download")
-
-            if url.match?(%r{^https?://sourceforge\.}) && url != livecheck_url
-              problem "Use https://downloads.sourceforge.net to get geolocation (url is #{url})."
-            end
-
-            if url.match?(%r{^https?://prdownloads\.})
-              problem <<~EOS.chomp
-                Don't use prdownloads in SourceForge urls (url is #{url}).
-                        See: http://librelist.com/browser/homebrew/2011/1/12/prdownloads-is-bad/
-              EOS
-            end
-
-            if url.match?(%r{^http://\w+\.dl\.})
-              problem "Don't use specific dl mirrors in SourceForge urls (url is #{url})."
-            end
-
-            problem "Please use https:// for #{url}" if url.start_with? "http://downloads"
-          end
-
-          # Debian has an abundance of secure mirrors. Let's not pluck the insecure
-          # one out of the grab bag.
-          unsecure_deb_pattern = %r{^http://http\.debian\.net/debian/(.*)}i
-          audit_urls(urls, unsecure_deb_pattern) do |match, _|
-            problem <<~EOS
-              Please use a secure mirror for Debian URLs.
-              We recommend:
-                https://deb.debian.org/debian/#{match[1]}
-            EOS
-          end
-
-          # Check to use canonical URLs for Debian packages
-          noncanon_deb_pattern =
-            Regexp.union([%r{^https://mirrors\.kernel\.org/debian/},
-                          %r{^https://mirrors\.ocf\.berkeley\.edu/debian/},
-                          %r{^https://(?:[^/]*\.)?mirrorservice\.org/sites/ftp\.debian\.org/debian/}])
-          audit_urls(urls, noncanon_deb_pattern) do |_, url|
-            problem "Please use https://deb.debian.org/debian/ for #{url}"
-          end
-
-          # Check for new-url Google Code download URLs, https:// is preferred
-          google_code_pattern = Regexp.union([%r{^http://[A-Za-z0-9\-.]*\.googlecode\.com/files.*},
-                                              %r{^http://code\.google\.com/}])
-          audit_urls(urls, google_code_pattern) do |_, url|
-            problem "Please use https:// for #{url}"
-          end
-
-          # Check for git:// GitHub repo URLs, https:// is preferred.
-          git_gh_pattern = %r{^git://[^/]*github\.com/}
-          audit_urls(urls, git_gh_pattern) do |_, url|
-            problem "Please use https:// for #{url}"
-          end
-
-          # Check for git:// Gitorious repo URLs, https:// is preferred.
-          git_gitorious_pattern = %r{^git://[^/]*gitorious\.org/}
-          audit_urls(urls, git_gitorious_pattern) do |_, url|
-            problem "Please use https:// for #{url}"
-          end
-
-          # Check for http:// GitHub repo URLs, https:// is preferred.
-          gh_pattern = %r{^http://github\.com/.*\.git$}
-          audit_urls(urls, gh_pattern) do |_, url|
-            problem "Please use https:// for #{url}"
-          end
-
-          # Check for master branch GitHub archives.
-          tarball_gh_pattern = %r{^https://github\.com/.*archive/master\.(tar\.gz|zip)$}
-          audit_urls(urls, tarball_gh_pattern) do
-            problem "Use versioned rather than branch tarballs for stable checksums."
-          end
-
-          # Use new-style archive downloads
-          archive_gh_pattern = %r{https://.*github.*/(?:tar|zip)ball/}
-          audit_urls(urls, archive_gh_pattern) do |_, url|
-            next if url.end_with?(".git")
-
-            problem "Use /archive/ URLs for GitHub tarballs (url is #{url})."
-          end
-
-          # Don't use GitHub .zip files
-          zip_gh_pattern = %r{https://.*github.*/(archive|releases)/.*\.zip$}
-          audit_urls(urls, zip_gh_pattern) do |_, url|
-            next if url.include?("releases/download")
-
-            problem "Use GitHub tarballs rather than zipballs (url is #{url})."
-          end
-
-          # Don't use GitHub codeload URLs
-          codeload_gh_pattern = %r{https?://codeload\.github\.com/(.+)/(.+)/(?:tar\.gz|zip)/(.+)}
-          audit_urls(urls, codeload_gh_pattern) do |match, url|
-            problem <<~EOS
-              Use GitHub archive URLs:
-                https://github.com/#{match[1]}/#{match[2]}/archive/#{match[3]}.tar.gz
-              Rather than codeload:
-                #{url}
-            EOS
-          end
-
-          # Check for Maven Central URLs, prefer HTTPS redirector over specific host
-          maven_pattern = %r{https?://(?:central|repo\d+)\.maven\.org/maven2/(.+)$}
-          audit_urls(urls, maven_pattern) do |match, url|
-            problem "#{url} should be `https://search.maven.org/remotecontent?filepath=#{match[1]}`"
-          end
+          audit_url(:formula, urls, mirrors, livecheck_url:)
 
           return if formula_tap != "homebrew-core"
 
@@ -256,12 +42,11 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
       end
 
       # This cop makes sure that the correct format for PyPI URLs is used.
-      #
-      # @api private
       class PyPiUrls < FormulaCop
-        extend T::Sig
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
           urls = find_every_func_call_by_name(body_node, :url)
           mirrors = find_every_func_call_by_name(body_node, :mirror)
           urls += mirrors
@@ -282,17 +67,17 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
         sig { params(url: String).returns(String) }
         def get_pypi_url(url)
           package_file = File.basename(url)
-          package_name = package_file.match(/^(.+)-[a-z0-9.]+$/)[1]
+          package_name = T.must(package_file.match(/^(.+)-[a-z0-9.]+$/))[1]
           "https://pypi.org/project/#{package_name}/#files"
         end
       end
 
       # This cop makes sure that git URLs have a `revision`.
-      #
-      # @api private
       class GitUrls < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          return unless formula_tap == "homebrew-core"
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+          return if formula_tap != "homebrew-core"
 
           find_method_calls_by_name(body_node, :url).each do |url|
             next unless string_content(parameters(url).first).match?(/\.git$/)
@@ -311,11 +96,11 @@ def audit_formula(_node, _class_node, _parent_class_node, body_node)
 
     module FormulaAuditStrict
       # This cop makes sure that git URLs have a `tag`.
-      #
-      # @api private
       class GitUrls < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          return unless formula_tap == "homebrew-core"
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+          return if formula_tap != "homebrew-core"
 
           find_method_calls_by_name(body_node, :url).each do |url|
             next unless string_content(parameters(url).first).match?(/\.git$/)
diff --git a/Library/Homebrew/rubocops/uses_from_macos.rb b/Library/Homebrew/rubocops/uses_from_macos.rb
index d719d42e1dbb0..0e298032e16fa 100644
--- a/Library/Homebrew/rubocops/uses_from_macos.rb
+++ b/Library/Homebrew/rubocops/uses_from_macos.rb
@@ -1,7 +1,7 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
@@ -11,6 +11,7 @@ class ProvidedByMacos < FormulaCop
         PROVIDED_BY_MACOS_FORMULAE = %w[
           apr
           bc
+          bc-gh
           berkeley-db
           bison
           bzip2
@@ -22,7 +23,6 @@ class ProvidedByMacos < FormulaCop
           expat
           file-formula
           flex
-          gnu-getopt
           gperf
           icu4c
           krb5
@@ -46,13 +46,11 @@ class ProvidedByMacos < FormulaCop
           pax
           pcsc-lite
           pod2man
-          rpcgen
           ruby
           sqlite
           ssh-copy-id
           swift
           tcl-tk
-          texinfo
           unifdef
           unzip
           whois
@@ -60,7 +58,10 @@ class ProvidedByMacos < FormulaCop
           zlib
         ].freeze
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
           find_method_with_args(body_node, :keg_only, :provided_by_macos) do
             return if PROVIDED_BY_MACOS_FORMULAE.include? @formula_name
 
@@ -83,6 +84,7 @@ class UsesFromMacos < FormulaCop
           groff
           gzip
           less
+          mandoc
           openssl
           perl
           php
@@ -93,8 +95,16 @@ class UsesFromMacos < FormulaCop
           zsh
         ].freeze
 
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          return if (body_node = formula_nodes.body_node).nil?
+
+          depends_on_linux = depends_on?(:linux)
+
           find_method_with_args(body_node, :uses_from_macos, /^"(.+)"/).each do |method|
+            @offensive_node = method
+            problem "`uses_from_macos` should not be used when Linux is required." if depends_on_linux
+
             dep = if parameters(method).first.instance_of?(RuboCop::AST::StrNode)
               parameters(method).first
             elsif parameters(method).first.instance_of?(RuboCop::AST::HashNode)
diff --git a/Library/Homebrew/rubocops/version.rb b/Library/Homebrew/rubocops/version.rb
index a6afb74449dc8..82863ab3a187d 100644
--- a/Library/Homebrew/rubocops/version.rb
+++ b/Library/Homebrew/rubocops/version.rb
@@ -1,17 +1,16 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "rubocops/extend/formula"
+require "rubocops/extend/formula_cop"
 
 module RuboCop
   module Cop
     module FormulaAudit
       # This cop makes sure that a `version` is in the correct format.
-      #
-      # @api private
       class Version < FormulaCop
-        def audit_formula(_node, _class_node, _parent_class_node, body_node)
-          version_node = find_node_method_by_name(body_node, :version)
+        sig { override.params(formula_nodes: FormulaNodes).void }
+        def audit_formula(formula_nodes)
+          version_node = find_node_method_by_name(formula_nodes.body_node, :version)
           return unless version_node
 
           version = string_content(parameters(version_node).first)
diff --git a/Library/Homebrew/sandbox.rb b/Library/Homebrew/sandbox.rb
index f601b801c5b17..d668288b0f71c 100644
--- a/Library/Homebrew/sandbox.rb
+++ b/Library/Homebrew/sandbox.rb
@@ -1,72 +1,88 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "erb"
 require "io/console"
 require "pty"
 require "tempfile"
+require "utils/fork"
 
 # Helper class for running a sub-process inside of a sandboxed environment.
-#
-# @api private
 class Sandbox
-  extend T::Sig
-
   SANDBOX_EXEC = "/usr/bin/sandbox-exec"
   private_constant :SANDBOX_EXEC
 
+  # This is defined in the macOS SDK but Ruby unfortunately does not expose it.
+  # This value can be found by compiling a C program that prints TIOCSCTTY.
+  # The value is different on Linux but that's not a problem as we only support macOS in this file.
+  TIOCSCTTY = 0x20007461
+  private_constant :TIOCSCTTY
+
   sig { returns(T::Boolean) }
   def self.available?
-    OS.mac? && File.executable?(SANDBOX_EXEC)
+    false
   end
 
   sig { void }
   def initialize
-    @profile = SandboxProfile.new
+    @profile = T.let(SandboxProfile.new, SandboxProfile)
+    @failed = T.let(false, T::Boolean)
   end
 
+  sig { params(file: T.any(String, Pathname)).void }
   def record_log(file)
-    @logfile = file
+    @logfile = T.let(file, T.nilable(T.any(String, Pathname)))
   end
 
-  def add_rule(rule)
+  sig { params(allow: T::Boolean, operation: String, filter: T.nilable(String), modifier: T.nilable(String)).void }
+  def add_rule(allow:, operation:, filter: nil, modifier: nil)
+    rule = SandboxRule.new(allow:, operation:, filter:, modifier:)
     @profile.add_rule(rule)
   end
 
-  def allow_write(path, options = {})
-    add_rule allow: true, operation: "file-write*", filter: path_filter(path, options[:type])
-    add_rule allow: true, operation: "file-write-setugid", filter: path_filter(path, options[:type])
+  sig { params(path: T.any(String, Pathname), type: Symbol).void }
+  def allow_write(path:, type: :literal)
+    add_rule allow: true, operation: "file-write*", filter: path_filter(path, type)
+    add_rule allow: true, operation: "file-write-setugid", filter: path_filter(path, type)
+    add_rule allow: true, operation: "file-write-mode", filter: path_filter(path, type)
   end
 
-  def deny_write(path, options = {})
-    add_rule allow: false, operation: "file-write*", filter: path_filter(path, options[:type])
+  sig { params(path: T.any(String, Pathname), type: Symbol).void }
+  def deny_write(path:, type: :literal)
+    add_rule allow: false, operation: "file-write*", filter: path_filter(path, type)
   end
 
+  sig { params(path: T.any(String, Pathname)).void }
   def allow_write_path(path)
-    allow_write path, type: :subpath
+    allow_write path:, type: :subpath
   end
 
+  sig { params(path: T.any(String, Pathname)).void }
   def deny_write_path(path)
-    deny_write path, type: :subpath
+    deny_write path:, type: :subpath
   end
 
+  sig { void }
   def allow_write_temp_and_cache
     allow_write_path "/private/tmp"
     allow_write_path "/private/var/tmp"
-    allow_write "^/private/var/folders/[^/]+/[^/]+/[C,T]/", type: :regex
+    allow_write path: "^/private/var/folders/[^/]+/[^/]+/[C,T]/", type: :regex
     allow_write_path HOMEBREW_TEMP
     allow_write_path HOMEBREW_CACHE
   end
 
+  sig { void }
   def allow_cvs
     allow_write_path "#{Dir.home(ENV.fetch("USER"))}/.cvspass"
   end
 
+  sig { void }
   def allow_fossil
     allow_write_path "#{Dir.home(ENV.fetch("USER"))}/.fossil"
     allow_write_path "#{Dir.home(ENV.fetch("USER"))}/.fossil-journal"
   end
 
+  sig { params(formula: Formula).void }
   def allow_write_cellar(formula)
     allow_write_path formula.rack
     allow_write_path formula.etc
@@ -74,16 +90,20 @@ def allow_write_cellar(formula)
   end
 
   # Xcode projects expect access to certain cache/archive dirs.
+  sig { void }
   def allow_write_xcode
     allow_write_path "#{Dir.home(ENV.fetch("USER"))}/Library/Developer"
+    allow_write_path "#{Dir.home(ENV.fetch("USER"))}/Library/Caches/org.swift.swiftpm"
   end
 
+  sig { params(formula: Formula).void }
   def allow_write_log(formula)
     allow_write_path formula.logs
   end
 
+  sig { void }
   def deny_write_homebrew_repository
-    deny_write HOMEBREW_BREW_FILE
+    deny_write path: HOMEBREW_BREW_FILE
     if HOMEBREW_PREFIX.to_s == HOMEBREW_REPOSITORY.to_s
       deny_write_path HOMEBREW_LIBRARY
       deny_write_path HOMEBREW_REPOSITORY/".git"
@@ -92,126 +112,197 @@ def deny_write_homebrew_repository
     end
   end
 
-  def exec(*args)
-    seatbelt = Tempfile.new(["homebrew", ".sb"], HOMEBREW_TEMP)
-    seatbelt.write(@profile.dump)
-    seatbelt.close
-    @start = Time.now
-
-    begin
-      command = [SANDBOX_EXEC, "-f", seatbelt.path, *args]
-      # Start sandbox in a pseudoterminal to prevent access of the parent terminal.
-      T.unsafe(PTY).spawn(*command) do |r, w, pid|
-        # Set the PTY's window size to match the parent terminal.
-        # Some formula tests are sensitive to the terminal size and fail if this is not set.
-        winch = proc do |_sig|
-          w.winsize = if $stdout.tty?
-            # We can only use IO#winsize if the IO object is a TTY.
-            $stdout.winsize
-          else
-            # Otherwise, default to tput, if available.
-            # This relies on ncurses rather than the system's ioctl.
-            [Utils.popen_read("tput", "lines").to_i, Utils.popen_read("tput", "cols").to_i]
-          end
-        end
-
-        write_to_pty = proc do
-          # Don't hang if stdin is not able to be used - throw EIO instead.
-          old_ttin = trap(:TTIN, "IGNORE")
+  sig { params(path: T.any(String, Pathname), type: Symbol).void }
+  def allow_network(path:, type: :literal)
+    add_rule allow: true, operation: "network*", filter: path_filter(path, type)
+  end
 
-          # Update the window size whenever the parent terminal's window size changes.
-          old_winch = trap(:WINCH, &winch)
-          winch.call(nil)
+  sig { params(path: T.any(String, Pathname), type: Symbol).void }
+  def deny_network(path:, type: :literal)
+    add_rule allow: false, operation: "network*", filter: path_filter(path, type)
+  end
 
-          stdin_thread = Thread.new do
-            IO.copy_stream($stdin, w)
-          rescue Errno::EIO
-            # stdin is unavailable - move on.
-          end
+  sig { void }
+  def allow_all_network
+    add_rule allow: true, operation: "network*"
+  end
 
-          r.each_char { |c| print(c) }
+  sig { void }
+  def deny_all_network
+    add_rule allow: false, operation: "network*"
+  end
 
-          Process.wait(pid)
-        ensure
-          stdin_thread&.kill
-          trap(:TTIN, old_ttin)
-          trap(:WINCH, old_winch)
-        end
+  sig { params(args: T.any(String, Pathname)).void }
+  def run(*args)
+    Dir.mktmpdir("homebrew-sandbox", HOMEBREW_TEMP) do |tmpdir|
+      allow_network path: File.join(tmpdir, "socket"), type: :literal # Make sure we have access to the error pipe.
+
+      seatbelt = File.new(File.join(tmpdir, "homebrew.sb"), "wx")
+      seatbelt.write(@profile.dump)
+      seatbelt.close
+      @start = T.let(Time.now, T.nilable(Time))
+
+      begin
+        command = [SANDBOX_EXEC, "-f", seatbelt.path, *args]
+        # Start sandbox in a pseudoterminal to prevent access of the parent terminal.
+        PTY.open do |controller, worker|
+          # Set the PTY's window size to match the parent terminal.
+          # Some formula tests are sensitive to the terminal size and fail if this is not set.
+          winch = proc do |_sig|
+            controller.winsize = if $stdout.tty?
+              # We can only use IO#winsize if the IO object is a TTY.
+              $stdout.winsize
+            else
+              # Otherwise, default to tput, if available.
+              # This relies on ncurses rather than the system's ioctl.
+              [Utils.popen_read("tput", "lines").to_i, Utils.popen_read("tput", "cols").to_i]
+            end
+          end
 
-        if $stdin.tty?
-          # If stdin is a TTY, use io.raw to set stdin to a raw, passthrough
-          # mode while we copy the input/output of the process spawned in the
-          # PTY. After we've finished copying to/from the PTY process, io.raw
-          # will restore the stdin TTY to its original state.
-          begin
-            # Ignore SIGTTOU as setting raw mode will hang if the process is in the background.
-            old_ttou = trap(:TTOU, "IGNORE")
-            $stdin.raw(&write_to_pty)
+          write_to_pty = proc do
+            # Don't hang if stdin is not able to be used - throw EIO instead.
+            old_ttin = trap(:TTIN, "IGNORE")
+
+            # Update the window size whenever the parent terminal's window size changes.
+            old_winch = trap(:WINCH, &winch)
+            winch.call(nil)
+
+            stdin_thread = Thread.new do
+              IO.copy_stream($stdin, controller)
+            rescue Errno::EIO
+              # stdin is unavailable - move on.
+            end
+
+            stdout_thread = Thread.new do
+              controller.each_char { |c| print(c) }
+            end
+
+            Utils.safe_fork(directory: tmpdir, yield_parent: true) do |error_pipe|
+              if error_pipe
+                # Child side
+                Process.setsid
+                controller.close
+                worker.ioctl(TIOCSCTTY, 0) # Make this the controlling terminal.
+                File.open("/dev/tty", Fcntl::O_WRONLY).close # Workaround for https://developer.apple.com/forums/thread/663632
+                worker.close_on_exec = true
+                exec(*command, in: worker, out: worker, err: worker) # And map everything to the PTY.
+              else
+                # Parent side
+                worker.close
+              end
+            end
+          rescue ChildProcessError => e
+            raise ErrorDuringExecution.new(command, status: e.status)
           ensure
-            trap(:TTOU, old_ttou)
+            stdin_thread&.kill
+            stdout_thread&.kill
+            trap(:TTIN, old_ttin)
+            trap(:WINCH, old_winch)
           end
-        else
-          write_to_pty.call
-        end
-      end
-      raise ErrorDuringExecution.new(command, status: $CHILD_STATUS) unless $CHILD_STATUS.success?
-    rescue
-      @failed = true
-      raise
-    ensure
-      seatbelt.unlink
-      sleep 0.1 # wait for a bit to let syslog catch up the latest events.
-      syslog_args = [
-        "-F", "$((Time)(local)) $(Sender)[$(PID)]: $(Message)",
-        "-k", "Time", "ge", @start.to_i.to_s,
-        "-k", "Message", "S", "deny",
-        "-k", "Sender", "kernel",
-        "-o",
-        "-k", "Time", "ge", @start.to_i.to_s,
-        "-k", "Message", "S", "deny",
-        "-k", "Sender", "sandboxd"
-      ]
-      logs = Utils.popen_read("syslog", *syslog_args)
-
-      # These messages are confusing and non-fatal, so don't report them.
-      logs = logs.lines.reject { |l| l.match(/^.*Python\(\d+\) deny file-write.*pyc$/) }.join
-
-      unless logs.empty?
-        if @logfile
-          File.open(@logfile, "w") do |log|
-            log.write logs
-            log.write "\nWe use time to filter sandbox log. Therefore, unrelated logs may be recorded.\n"
+
+          if $stdin.tty?
+            # If stdin is a TTY, use io.raw to set stdin to a raw, passthrough
+            # mode while we copy the input/output of the process spawned in the
+            # PTY. After we've finished copying to/from the PTY process, io.raw
+            # will restore the stdin TTY to its original state.
+            begin
+              # Ignore SIGTTOU as setting raw mode will hang if the process is in the background.
+              old_ttou = trap(:TTOU, "IGNORE")
+              $stdin.raw(&write_to_pty)
+            ensure
+              trap(:TTOU, old_ttou)
+            end
+          else
+            write_to_pty.call
           end
         end
+      rescue
+        @failed = true
+        raise
+      ensure
+        sleep 0.1 # wait for a bit to let syslog catch up the latest events.
+        syslog_args = [
+          "-F", "$((Time)(local)) $(Sender)[$(PID)]: $(Message)",
+          "-k", "Time", "ge", @start.to_i.to_s,
+          "-k", "Message", "S", "deny",
+          "-k", "Sender", "kernel",
+          "-o",
+          "-k", "Time", "ge", @start.to_i.to_s,
+          "-k", "Message", "S", "deny",
+          "-k", "Sender", "sandboxd"
+        ]
+        logs = Utils.popen_read("syslog", *syslog_args)
+
+        # These messages are confusing and non-fatal, so don't report them.
+        logs = logs.lines.grep_v(/^.*Python\(\d+\) deny file-write.*pyc$/).join
+
+        unless logs.empty?
+          if @logfile
+            File.open(@logfile, "w") do |log|
+              log.write logs
+              log.write "\nWe use time to filter sandbox log. Therefore, unrelated logs may be recorded.\n"
+            end
+          end
 
-        if @failed && Homebrew::EnvConfig.verbose?
-          ohai "Sandbox Log", logs
-          $stdout.flush # without it, brew test-bot would fail to catch the log
+          if @failed && Homebrew::EnvConfig.verbose?
+            ohai "Sandbox Log", logs
+            $stdout.flush # without it, brew test-bot would fail to catch the log
+          end
         end
       end
     end
   end
 
+  # @api private
+  sig { params(path: T.any(String, Pathname), type: Symbol).returns(String) }
+  def path_filter(path, type)
+    invalid_char = ['"', "'", "(", ")", "\n", "\\"].find do |c|
+      path.to_s.include?(c)
+    end
+    raise ArgumentError, "Invalid character #{invalid_char} in path: #{path}" if invalid_char
+
+    case type
+    when :regex   then "regex #\"#{path}\""
+    when :subpath then "subpath \"#{expand_realpath(Pathname.new(path))}\""
+    when :literal then "literal \"#{expand_realpath(Pathname.new(path))}\""
+    else raise ArgumentError, "Invalid path filter type: #{type}"
+    end
+  end
+
   private
 
+  sig { params(path: Pathname).returns(Pathname) }
   def expand_realpath(path)
     raise unless path.absolute?
 
     path.exist? ? path.realpath : expand_realpath(path.parent)/path.basename
   end
 
-  def path_filter(path, type)
-    case type
-    when :regex        then "regex \#\"#{path}\""
-    when :subpath      then "subpath \"#{expand_realpath(Pathname.new(path))}\""
-    when :literal, nil then "literal \"#{expand_realpath(Pathname.new(path))}\""
+  class SandboxRule
+    sig { returns(T::Boolean) }
+    attr_reader :allow
+
+    sig { returns(String) }
+    attr_reader :operation
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :filter
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :modifier
+
+    sig { params(allow: T::Boolean, operation: String, filter: T.nilable(String), modifier: T.nilable(String)).void }
+    def initialize(allow:, operation:, filter:, modifier:)
+      @allow = allow
+      @operation = operation
+      @filter = filter
+      @modifier = modifier
     end
   end
+  private_constant :SandboxRule
 
   # Configuration profile for a sandbox.
   class SandboxProfile
-    extend T::Sig
-
     SEATBELT_ERB = <<~ERB
       (version 1)
       (debug deny) ; log all denied operations to /var/log/system.log
@@ -226,6 +317,8 @@ class SandboxProfile
           (regex #"^/dev/tty[a-z0-9]*$")
           )
       (deny file-write*) ; deny non-allowlist file write operations
+      (deny file-write-setugid) ; deny non-allowlist file write SUID/SGID operations
+      (deny file-write-mode) ; deny non-allowlist file write mode operations
       (allow process-exec
           (literal "/bin/ps")
           (with no-sandbox)
@@ -233,26 +326,31 @@ class SandboxProfile
       (allow default) ; allow everything else
     ERB
 
+    sig { returns(T::Array[String]) }
     attr_reader :rules
 
     sig { void }
     def initialize
-      @rules = []
+      @rules = T.let([], T::Array[String])
     end
 
+    sig { params(rule: SandboxRule).void }
     def add_rule(rule)
       s = +"("
-      s << (rule[:allow] ? "allow" : "deny")
-      s << " #{rule[:operation]}"
-      s << " (#{rule[:filter]})" if rule[:filter]
-      s << " (with #{rule[:modifier]})" if rule[:modifier]
+      s << (rule.allow ? "allow" : "deny")
+      s << " #{rule.operation}"
+      s << " (#{rule.filter})" if rule.filter
+      s << " (with #{rule.modifier})" if rule.modifier
       s << ")"
       @rules << s.freeze
     end
 
+    sig { returns(String) }
     def dump
       ERB.new(SEATBELT_ERB).result(binding)
     end
   end
   private_constant :SandboxProfile
 end
+
+require "extend/os/sandbox"
diff --git a/Library/Homebrew/sbom.rb b/Library/Homebrew/sbom.rb
new file mode 100644
index 0000000000000..6e3e0c2a55486
--- /dev/null
+++ b/Library/Homebrew/sbom.rb
@@ -0,0 +1,402 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "cxxstdlib"
+require "json"
+require "development_tools"
+require "extend/cachable"
+require "utils/curl"
+
+# Rather than calling `new` directly, use one of the class methods like {SBOM.create}.
+class SBOM
+  FILENAME = "sbom.spdx.json"
+  SCHEMA_FILE = (HOMEBREW_LIBRARY_PATH/"data/schemas/sbom.json").freeze
+
+  # Instantiates a {SBOM} for a new installation of a formula.
+  sig { params(formula: Formula, tab: Tab).returns(T.attached_class) }
+  def self.create(formula, tab)
+    active_spec = if formula.stable?
+      T.must(formula.stable)
+    else
+      T.must(formula.head)
+    end
+    active_spec_sym = formula.active_spec_sym
+
+    attributes = {
+      name:                 formula.name,
+      homebrew_version:     HOMEBREW_VERSION,
+      spdxfile:             SBOM.spdxfile(formula),
+      time:                 tab.time || Time.now,
+      source_modified_time: tab.source_modified_time.to_i,
+      compiler:             tab.compiler,
+      stdlib:               tab.stdlib,
+      runtime_dependencies: SBOM.runtime_deps_hash(Array(tab.runtime_dependencies)),
+      license:              SPDX.license_expression_to_string(formula.license),
+      built_on:             DevelopmentTools.build_system_info,
+      source:               {
+        path:         formula.specified_path.to_s,
+        tap:          formula.tap&.name,
+        tap_git_head: nil, # Filled in later if possible
+        spec:         active_spec_sym.to_s,
+        patches:      active_spec.patches,
+        bottle:       formula.bottle_hash,
+        active_spec_sym =>       {
+          version:  active_spec.version,
+          url:      active_spec.url,
+          checksum: active_spec.checksum,
+        },
+      },
+    }
+
+    # We can only get `tap_git_head` if the tap is installed locally
+    attributes[:source][:tap_git_head] = T.must(formula.tap).git_head if formula.tap&.installed?
+
+    new(attributes)
+  end
+
+  sig { params(formula: Formula).returns(Pathname) }
+  def self.spdxfile(formula)
+    formula.prefix/FILENAME
+  end
+
+  sig { params(deps: T::Array[T::Hash[String, String]]).returns(T::Array[T::Hash[String, String]]) }
+  def self.runtime_deps_hash(deps)
+    deps.map do |dep|
+      full_name = dep.fetch("full_name")
+      dep_formula = Formula[full_name]
+      {
+        "full_name"           => full_name,
+        "pkg_version"         => dep.fetch("pkg_version"),
+        "name"                => dep_formula.name,
+        "license"             => SPDX.license_expression_to_string(dep_formula.license),
+        "bottle"              => dep_formula.bottle_hash,
+        "formula_pkg_version" => dep_formula.pkg_version.to_s,
+      }
+    end
+  end
+
+  sig { params(formula: Formula).returns(T::Boolean) }
+  def self.exist?(formula)
+    spdxfile(formula).exist?
+  end
+
+  sig { returns(T::Hash[String, T.untyped]) }
+  def self.schema
+    @schema ||= JSON.parse(SCHEMA_FILE.read, freeze: true)
+  end
+
+  sig { params(bottling: T::Boolean).returns(T::Array[T::Hash[String, T.untyped]]) }
+  def schema_validation_errors(bottling: false)
+    unless require? "json_schemer"
+      error_message = "Need json_schemer to validate SBOM, run `brew install-bundler-gems --add-groups=bottle`!"
+      odie error_message if ENV["HOMEBREW_ENFORCE_SBOM"]
+      return []
+    end
+
+    schemer = JSONSchemer.schema(SBOM.schema)
+    data = to_spdx_sbom(bottling:)
+
+    schemer.validate(data).map { |error| error["error"] }
+  end
+
+  sig { params(bottling: T::Boolean).returns(T::Boolean) }
+  def valid?(bottling: false)
+    validation_errors = schema_validation_errors(bottling:)
+    return true if validation_errors.empty?
+
+    opoo "SBOM validation errors:"
+    validation_errors.each(&:puts)
+
+    odie "Failed to validate SBOM against JSON schema!" if ENV["HOMEBREW_ENFORCE_SBOM"]
+
+    false
+  end
+
+  sig { params(validate: T::Boolean, bottling: T::Boolean).void }
+  def write(validate: true, bottling: false)
+    # If this is a new installation, the cache of installed formulae
+    # will no longer be valid.
+    Formula.clear_cache unless spdxfile.exist?
+
+    if validate && !valid?(bottling:)
+      opoo "SBOM is not valid, not writing to disk!"
+      return
+    end
+
+    spdxfile.atomic_write(JSON.pretty_generate(to_spdx_sbom(bottling:)))
+  end
+
+  private
+
+  attr_reader :name, :homebrew_version, :time, :stdlib, :source, :built_on, :license
+  attr_accessor :spdxfile
+
+  sig { params(attributes: Hash).void }
+  def initialize(attributes = {})
+    attributes.each { |key, value| instance_variable_set(:"@#{key}", value) }
+  end
+
+  sig {
+    params(
+      runtime_dependency_declaration: T::Array[Hash],
+      compiler_declaration:           Hash,
+      bottling:                       T::Boolean,
+    ).returns(T::Array[Hash])
+  }
+  def generate_relations_json(runtime_dependency_declaration, compiler_declaration, bottling:)
+    runtime = runtime_dependency_declaration.map do |dependency|
+      {
+        spdxElementId:      dependency[:SPDXID],
+        relationshipType:   "RUNTIME_DEPENDENCY_OF",
+        relatedSpdxElement: "SPDXRef-Bottle-#{name}",
+      }
+    end
+
+    patches = source[:patches].each_with_index.map do |_patch, index|
+      {
+        spdxElementId:      "SPDXRef-Patch-#{name}-#{index}",
+        relationshipType:   "PATCH_APPLIED",
+        relatedSpdxElement: "SPDXRef-Archive-#{name}-src",
+      }
+    end
+
+    base = T.let([{
+      spdxElementId:      "SPDXRef-File-#{name}",
+      relationshipType:   "PACKAGE_OF",
+      relatedSpdxElement: "SPDXRef-Archive-#{name}-src",
+    }], T::Array[Hash])
+
+    unless bottling
+      base << {
+        spdxElementId:      "SPDXRef-Compiler",
+        relationshipType:   "BUILD_TOOL_OF",
+        relatedSpdxElement: "SPDXRef-Package-#{name}-src",
+      }
+
+      if compiler_declaration["SPDXRef-Stdlib"].present?
+        base << {
+          spdxElementId:      "SPDXRef-Stdlib",
+          relationshipType:   "DEPENDENCY_OF",
+          relatedSpdxElement: "SPDXRef-Bottle-#{name}",
+        }
+      end
+    end
+
+    runtime + patches + base
+  end
+
+  sig {
+    params(runtime_dependency_declaration: T::Array[Hash],
+           compiler_declaration:           Hash,
+           bottling:                       T::Boolean).returns(
+             T::Array[
+              T::Hash[
+                Symbol,
+                T.any(String, T::Array[T::Hash[Symbol, String]])
+              ],
+            ],
+           )
+  }
+  def generate_packages_json(runtime_dependency_declaration, compiler_declaration, bottling:)
+    bottle = []
+    if !bottling && (bottle_info = get_bottle_info(source[:bottle])) &&
+       (stable_version = source.dig(:stable, :version))
+      bottle << {
+        SPDXID:           "SPDXRef-Bottle-#{name}",
+        name:             name.to_s,
+        versionInfo:      stable_version.to_s,
+        filesAnalyzed:    false,
+        licenseDeclared:  assert_value(nil),
+        builtDate:        source_modified_time.to_s,
+        licenseConcluded: assert_value(license),
+        downloadLocation: bottle_info.fetch("url"),
+        copyrightText:    assert_value(nil),
+        externalRefs:     [
+          {
+            referenceCategory: "PACKAGE-MANAGER",
+            referenceLocator:  "pkg:brew/#{tap}/#{name}@#{stable_version}",
+            referenceType:     "purl",
+          },
+        ],
+        checksums:        [
+          {
+            algorithm:     "SHA256",
+            checksumValue: bottle_info.fetch("sha256"),
+          },
+        ],
+      }
+    end
+
+    compiler_declarations = if bottling
+      []
+    else
+      compiler_declaration.values
+    end
+
+    [
+      {
+        SPDXID:           "SPDXRef-Archive-#{name}-src",
+        name:             name.to_s,
+        versionInfo:      spec_version.to_s,
+        filesAnalyzed:    false,
+        licenseDeclared:  assert_value(nil),
+        builtDate:        source_modified_time.to_s,
+        licenseConcluded: assert_value(license),
+        downloadLocation: source[spec_symbol][:url],
+        copyrightText:    assert_value(nil),
+        externalRefs:     [],
+        checksums:        [
+          {
+            algorithm:     "SHA256",
+            checksumValue: source[spec_symbol][:checksum].to_s,
+          },
+        ],
+      },
+    ] + runtime_dependency_declaration + compiler_declarations + bottle
+  end
+
+  sig {
+    params(bottling: T::Boolean).returns(T::Array[T::Hash[Symbol,
+                                                          T.any(T::Boolean, String,
+                                                                T::Array[T::Hash[Symbol, String]])]])
+  }
+  def full_spdx_runtime_dependencies(bottling:)
+    return [] if bottling || @runtime_dependencies.blank?
+
+    @runtime_dependencies.compact.filter_map do |dependency|
+      next unless dependency.present?
+
+      bottle_info = get_bottle_info(dependency["bottle"])
+      next unless bottle_info.present?
+
+      # Only set bottle URL if the dependency is the same version as the formula/bottle.
+      bottle_url = bottle_info["url"] if dependency["pkg_version"] == dependency["formula_pkg_version"]
+
+      dependency_json = {
+        SPDXID:           "SPDXRef-Package-SPDXRef-#{dependency["name"].tr("/", "-")}-#{dependency["pkg_version"]}",
+        name:             dependency["name"],
+        versionInfo:      dependency["pkg_version"],
+        filesAnalyzed:    false,
+        licenseDeclared:  assert_value(nil),
+        licenseConcluded: assert_value(dependency["license"]),
+        downloadLocation: assert_value(bottle_url),
+        copyrightText:    assert_value(nil),
+        checksums:        [
+          {
+            algorithm:     "SHA256",
+            checksumValue: assert_value(bottle_info["sha256"]),
+          },
+        ],
+        externalRefs:     [
+          {
+            referenceCategory: "PACKAGE-MANAGER",
+            referenceLocator:  "pkg:brew/#{dependency["full_name"]}@#{dependency["pkg_version"]}",
+            referenceType:     "purl",
+          },
+        ],
+      }
+      dependency_json
+    end
+  end
+
+  sig { params(bottling: T::Boolean).returns(T::Hash[Symbol, T.any(String, T::Array[T::Hash[Symbol, String]])]) }
+  def to_spdx_sbom(bottling:)
+    runtime_full = full_spdx_runtime_dependencies(bottling:)
+
+    compiler_info = {
+      "SPDXRef-Compiler" => {
+        SPDXID:           "SPDXRef-Compiler",
+        name:             compiler.to_s,
+        versionInfo:      assert_value(built_on["xcode"]),
+        filesAnalyzed:    false,
+        licenseDeclared:  assert_value(nil),
+        licenseConcluded: assert_value(nil),
+        copyrightText:    assert_value(nil),
+        downloadLocation: assert_value(nil),
+        checksums:        [],
+        externalRefs:     [],
+      },
+    }
+
+    if stdlib.present?
+      compiler_info["SPDXRef-Stdlib"] = {
+        SPDXID:           "SPDXRef-Stdlib",
+        name:             stdlib.to_s,
+        versionInfo:      stdlib.to_s,
+        filesAnalyzed:    false,
+        licenseDeclared:  assert_value(nil),
+        licenseConcluded: assert_value(nil),
+        copyrightText:    assert_value(nil),
+        downloadLocation: assert_value(nil),
+        checksums:        [],
+        externalRefs:     [],
+      }
+    end
+
+    # Improve reproducibility when bottling.
+    if bottling
+      created = source_modified_time.iso8601
+      creators = ["Tool: https://github.com/Homebrew/brew"]
+    else
+      created = Time.at(time).utc.iso8601
+      creators = ["Tool: https://github.com/Homebrew/brew@#{homebrew_version}"]
+    end
+
+    packages = generate_packages_json(runtime_full, compiler_info, bottling:)
+    {
+      SPDXID:            "SPDXRef-DOCUMENT",
+      spdxVersion:       "SPDX-2.3",
+      name:              "SBOM-SPDX-#{name}-#{spec_version}",
+      creationInfo:      { created:, creators: },
+      dataLicense:       "CC0-1.0",
+      documentNamespace: "https://formulae.brew.sh/spdx/#{name}-#{spec_version}.json",
+      documentDescribes: packages.map { |dependency| dependency[:SPDXID] },
+      files:             [],
+      packages:,
+      relationships:     generate_relations_json(runtime_full, compiler_info, bottling:),
+    }
+  end
+
+  sig { params(base: T.nilable(T::Hash[String, Hash])).returns(T.nilable(T::Hash[String, String])) }
+  def get_bottle_info(base)
+    return unless base.present?
+
+    files = base["files"].presence
+    return unless files
+
+    files[Utils::Bottles.tag.to_sym] || files[:all]
+  end
+
+  sig { returns(Symbol) }
+  def compiler
+    @compiler.presence&.to_sym || DevelopmentTools.default_compiler
+  end
+
+  sig { returns(T.nilable(Tap)) }
+  def tap
+    tap_name = source[:tap]
+    Tap.fetch(tap_name) if tap_name
+  end
+
+  sig { returns(Symbol) }
+  def spec_symbol
+    source.fetch(:spec).to_sym
+  end
+
+  sig { returns(T.nilable(Version)) }
+  def spec_version
+    source.fetch(spec_symbol)[:version]
+  end
+
+  sig { returns(Time) }
+  def source_modified_time
+    Time.at(@source_modified_time).utc
+  end
+
+  sig { params(val: T.untyped).returns(T.any(String, Symbol)) }
+  def assert_value(val)
+    return :NOASSERTION.to_s unless val.present?
+
+    val
+  end
+end
diff --git a/Library/Homebrew/search.rb b/Library/Homebrew/search.rb
index 06c04e7497d89..b33a4ccbf1250 100644
--- a/Library/Homebrew/search.rb
+++ b/Library/Homebrew/search.rb
@@ -1,15 +1,12 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "searchable"
 require "description_cache_store"
 
 module Homebrew
   # Helper module for searching formulae or casks.
-  #
-  # @api private
   module Search
-    def query_regexp(query)
+    def self.query_regexp(query)
       if (m = query.match(%r{^/(.*)/$}))
         Regexp.new(m[1])
       else
@@ -19,62 +16,49 @@ def query_regexp(query)
       raise "#{query} is not a valid regex."
     end
 
-    def search_descriptions(string_or_regex, args)
-      return if args.cask?
-
-      ohai "Formulae"
-      CacheStoreDatabase.use(:descriptions) do |db|
-        cache_store = DescriptionCacheStore.new(db)
-        Descriptions.search(string_or_regex, :desc, cache_store).print
-      end
-    end
-
-    def search_taps(query, silent: false)
-      if query.match?(Regexp.union(HOMEBREW_TAP_FORMULA_REGEX, HOMEBREW_TAP_CASK_REGEX))
-        _, _, query = query.split("/", 3)
-      end
-
-      results = { formulae: [], casks: [] }
-
-      return results if Homebrew::EnvConfig.no_github_api?
-
-      unless silent
-        # Use stderr to avoid breaking parsed output
-        $stderr.puts Formatter.headline("Searching taps on GitHub...", color: :blue)
-      end
-
-      matches = begin
-        GitHub.search_code(
-          user:      "Homebrew",
-          path:      ["Formula", "Casks", "."],
-          filename:  query,
-          extension: "rb",
-        )
-      rescue GitHub::API::Error => e
-        opoo "Error searching on GitHub: #{e}\n"
-        nil
+    def self.search_descriptions(string_or_regex, args, search_type: :desc)
+      both = !args.formula? && !args.cask?
+      eval_all = args.eval_all? || Homebrew::EnvConfig.eval_all?
+
+      if args.formula? || both
+        ohai "Formulae"
+        if eval_all
+          CacheStoreDatabase.use(:descriptions) do |db|
+            cache_store = DescriptionCacheStore.new(db)
+            Descriptions.search(string_or_regex, search_type, cache_store, eval_all).print
+          end
+        else
+          unofficial = Tap.all.sum { |tap| tap.official? ? 0 : tap.formula_files.size }
+          if unofficial.positive?
+            opoo "Use `--eval-all` to search #{unofficial} additional " \
+                 "#{Utils.pluralize("formula", unofficial, plural: "e")} in third party taps."
+          end
+          descriptions = Homebrew::API::Formula.all_formulae.transform_values { |data| data["desc"] }
+          Descriptions.search(string_or_regex, search_type, descriptions, eval_all, cache_store_hash: true).print
+        end
       end
+      return if !args.cask? && !both
 
-      return results if matches.blank?
-
-      matches.each do |match|
-        name = File.basename(match["path"], ".rb")
-        tap = Tap.fetch(match["repository"]["full_name"])
-        full_name = "#{tap.name}/#{name}"
-
-        next if tap.installed?
+      puts if both
 
-        if match["path"].start_with?("Casks/")
-          results[:casks] = [*results[:casks], full_name].sort
-        else
-          results[:formulae] = [*results[:formulae], full_name].sort
+      ohai "Casks"
+      if eval_all
+        CacheStoreDatabase.use(:cask_descriptions) do |db|
+          cache_store = CaskDescriptionCacheStore.new(db)
+          Descriptions.search(string_or_regex, search_type, cache_store, eval_all).print
+        end
+      else
+        unofficial = Tap.all.sum { |tap| tap.official? ? 0 : tap.cask_files.size }
+        if unofficial.positive?
+          opoo "Use `--eval-all` to search #{unofficial} additional " \
+               "#{Utils.pluralize("cask", unofficial)} in third party taps."
         end
+        descriptions = Homebrew::API::Cask.all_casks.transform_values { |c| [c["name"].join(", "), c["desc"]] }
+        Descriptions.search(string_or_regex, search_type, descriptions, eval_all, cache_store_hash: true).print
       end
-
-      results
     end
 
-    def search_formulae(string_or_regex)
+    def self.search_formulae(string_or_regex)
       if string_or_regex.is_a?(String) && string_or_regex.match?(HOMEBREW_TAP_FORMULA_REGEX)
         return begin
           [Formulary.factory(string_or_regex).name]
@@ -84,14 +68,10 @@ def search_formulae(string_or_regex)
       end
 
       aliases = Formula.alias_full_names
-      results = (Formula.full_names + aliases)
-                .extend(Searchable)
-                .search(string_or_regex)
-                .sort
-
+      results = search(Formula.full_names + aliases, string_or_regex).sort
       results |= Formula.fuzzy_search(string_or_regex).map { |n| Formulary.factory(n).full_name }
 
-      results.map do |name|
+      results.filter_map do |name|
         formula, canonical_full_name = begin
           f = Formulary.factory(name)
           [f, f.full_name]
@@ -104,16 +84,90 @@ def search_formulae(string_or_regex)
 
         if formula&.any_version_installed?
           pretty_installed(name)
-        else
+        elsif formula.nil? || formula.valid_platform?
           name
         end
-      end.compact
+      end
+    end
+
+    def self.search_casks(string_or_regex)
+      if string_or_regex.is_a?(String) && string_or_regex.match?(HOMEBREW_TAP_CASK_REGEX)
+        return begin
+          [Cask::CaskLoader.load(string_or_regex).token]
+        rescue Cask::CaskUnavailableError
+          []
+        end
+      end
+
+      cask_tokens = Tap.each_with_object([]) do |tap, array|
+        # We can exclude the core cask tap because `CoreCaskTap#cask_tokens` returns short names by default.
+        if tap.official? && !tap.core_cask_tap?
+          tap.cask_tokens.each { |token| array << token.sub(%r{^homebrew/cask.*/}, "") }
+        else
+          tap.cask_tokens.each { |token| array << token }
+        end
+      end.uniq
+
+      results = search(cask_tokens, string_or_regex)
+      results += DidYouMean::SpellChecker.new(dictionary: cask_tokens)
+                                         .correct(string_or_regex)
+
+      results.sort.map do |name|
+        cask = Cask::CaskLoader.load(name)
+        if cask.installed?
+          pretty_installed(cask.full_name)
+        else
+          cask.full_name
+        end
+      end.uniq
     end
 
-    def search_casks(_string_or_regex)
-      []
+    def self.search_names(string_or_regex, args)
+      both = !args.formula? && !args.cask?
+
+      all_formulae = if args.formula? || both
+        search_formulae(string_or_regex)
+      else
+        []
+      end
+
+      all_casks = if args.cask? || both
+        search_casks(string_or_regex)
+      else
+        []
+      end
+
+      [all_formulae, all_casks]
+    end
+
+    def self.search(selectable, string_or_regex, &block)
+      case string_or_regex
+      when Regexp
+        search_regex(selectable, string_or_regex, &block)
+      else
+        search_string(selectable, string_or_regex.to_str, &block)
+      end
+    end
+
+    def self.simplify_string(string)
+      string.downcase.gsub(/[^a-z\d@+]/i, "")
+    end
+
+    def self.search_regex(selectable, regex)
+      selectable.select do |*args|
+        args = yield(*args) if block_given?
+        args = Array(args).flatten.compact
+        args.any? { |arg| arg.match?(regex) }
+      end
+    end
+
+    def self.search_string(selectable, string)
+      simplified_string = simplify_string(string)
+      selectable.select do |*args|
+        args = yield(*args) if block_given?
+        args = Array(args).flatten.compact
+        args.any? { |arg| simplify_string(arg).include?(simplified_string) }
+      end
     end
   end
 end
-
-require "extend/os/search"
diff --git a/Library/Homebrew/searchable.rb b/Library/Homebrew/searchable.rb
deleted file mode 100644
index 18dd8e25a5844..0000000000000
--- a/Library/Homebrew/searchable.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-# Helper module for making a class searchable with both regular expressions and strings.
-#
-# @api private
-module Searchable
-  def search(string_or_regex, &block)
-    case string_or_regex
-    when Regexp
-      search_regex(string_or_regex, &block)
-    else
-      search_string(string_or_regex.to_str, &block)
-    end
-  end
-
-  private
-
-  def simplify_string(string)
-    string.downcase.gsub(/[^a-z\d]/i, "")
-  end
-
-  def search_regex(regex)
-    select do |*args|
-      args = yield(*args) if block_given?
-      args = Array(args).flatten.compact
-      args.any? { |arg| arg.match?(regex) }
-    end
-  end
-
-  def search_string(string)
-    simplified_string = simplify_string(string)
-    select do |*args|
-      args = yield(*args) if block_given?
-      args = Array(args).flatten.compact
-      args.any? { |arg| simplify_string(arg).include?(simplified_string) }
-    end
-  end
-end
diff --git a/Library/Homebrew/service.rb b/Library/Homebrew/service.rb
index f40cff066fb0b..e4f27fd73c0ed 100644
--- a/Library/Homebrew/service.rb
+++ b/Library/Homebrew/service.rb
@@ -1,13 +1,16 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "ipaddr"
+require "extend/on_system"
+
 module Homebrew
   # The {Service} class implements the DSL methods used in a formula's
   # `service` block and stores related instance variables. Most of these methods
   # also return the related instance variable when no argument is provided.
   class Service
-    extend T::Sig
     extend Forwardable
+    include OnSystem::MacOSAndLinux
 
     RUN_TYPE_IMMEDIATE = :immediate
     RUN_TYPE_INTERVAL = :interval
@@ -24,81 +27,117 @@ class Service
     def initialize(formula, &block)
       @formula = formula
       @run_type = RUN_TYPE_IMMEDIATE
+      @run_at_load = true
       @environment_variables = {}
-      @service_block = block
+      instance_eval(&block) if block
+    end
+
+    sig { returns(Formula) }
+    def f
+      @formula
     end
 
-    sig { params(command: T.nilable(T.any(T::Array[String], String, Pathname))).returns(T.nilable(Array)) }
-    def run(command = nil)
-      case T.unsafe(command)
+    sig { returns(String) }
+    def default_plist_name
+      "homebrew.mxcl.#{@formula.name}"
+    end
+
+    sig { returns(String) }
+    def plist_name
+      @plist_name ||= default_plist_name
+    end
+
+    sig { returns(String) }
+    def default_service_name
+      "homebrew.#{@formula.name}"
+    end
+
+    sig { returns(String) }
+    def service_name
+      @service_name ||= default_service_name
+    end
+
+    sig { params(macos: T.nilable(String), linux: T.nilable(String)).void }
+    def name(macos: nil, linux: nil)
+      raise TypeError, "Service#name expects at least one String" if [macos, linux].none?(String)
+
+      @plist_name = macos if macos
+      @service_name = linux if linux
+    end
+
+    sig {
+      params(
+        command: T.nilable(T.any(T::Array[T.any(String, Pathname)], String, Pathname)),
+        macos:   T.nilable(T.any(T::Array[T.any(String, Pathname)], String, Pathname)),
+        linux:   T.nilable(T.any(T::Array[T.any(String, Pathname)], String, Pathname)),
+      ).returns(T.nilable(T::Array[T.any(String, Pathname)]))
+    }
+    def run(command = nil, macos: nil, linux: nil)
+      # Save parameters for serialization
+      if command
+        @run_params = command
+      elsif macos || linux
+        @run_params = { macos:, linux: }.compact
+      end
+
+      command ||= on_system_conditional(macos:, linux:)
+      case command
       when nil
         @run
       when String, Pathname
         @run = [command]
       when Array
         @run = command
-      else
-        raise TypeError, "Service#run expects an Array"
       end
     end
 
     sig { params(path: T.nilable(T.any(String, Pathname))).returns(T.nilable(String)) }
     def working_dir(path = nil)
-      case T.unsafe(path)
+      case path
       when nil
         @working_dir
       when String, Pathname
         @working_dir = path.to_s
-      else
-        raise TypeError, "Service#working_dir expects a String"
       end
     end
 
     sig { params(path: T.nilable(T.any(String, Pathname))).returns(T.nilable(String)) }
     def root_dir(path = nil)
-      case T.unsafe(path)
+      case path
       when nil
         @root_dir
       when String, Pathname
         @root_dir = path.to_s
-      else
-        raise TypeError, "Service#root_dir expects a String or Pathname"
       end
     end
 
     sig { params(path: T.nilable(T.any(String, Pathname))).returns(T.nilable(String)) }
     def input_path(path = nil)
-      case T.unsafe(path)
+      case path
       when nil
         @input_path
       when String, Pathname
         @input_path = path.to_s
-      else
-        raise TypeError, "Service#input_path expects a String or Pathname"
       end
     end
 
     sig { params(path: T.nilable(T.any(String, Pathname))).returns(T.nilable(String)) }
     def log_path(path = nil)
-      case T.unsafe(path)
+      case path
       when nil
         @log_path
       when String, Pathname
         @log_path = path.to_s
-      else
-        raise TypeError, "Service#log_path expects a String"
       end
     end
 
     sig { params(path: T.nilable(T.any(String, Pathname))).returns(T.nilable(String)) }
     def error_log_path(path = nil)
-      case T.unsafe(path)
+      case path
       when nil
         @error_log_path
       when String, Pathname
         @error_log_path = path.to_s
-      else
-        raise TypeError, "Service#error_log_path expects a String"
       end
     end
 
@@ -107,36 +146,74 @@ def error_log_path(path = nil)
         .returns(T.nilable(T::Hash[Symbol, T.untyped]))
     }
     def keep_alive(value = nil)
-      case T.unsafe(value)
+      case value
       when nil
         @keep_alive
       when true, false
         @keep_alive = { always: value }
       when Hash
-        hash = T.cast(value, Hash)
-        unless (hash.keys - KEEP_ALIVE_KEYS).empty?
+        unless (value.keys - KEEP_ALIVE_KEYS).empty?
           raise TypeError, "Service#keep_alive allows only #{KEEP_ALIVE_KEYS}"
         end
 
         @keep_alive = value
-      else
-        raise TypeError, "Service#keep_alive expects a Boolean or Hash"
       end
     end
 
-    sig { params(value: T.nilable(String)).returns(T.nilable(T::Hash[Symbol, String])) }
-    def sockets(value = nil)
-      case T.unsafe(value)
+    sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+    def require_root(value = nil)
+      case value
+      when nil
+        @require_root
+      when true, false
+        @require_root = value
+      end
+    end
+
+    # Returns a `Boolean` describing if a service requires root access.
+    # @return [Boolean]
+    sig { returns(T::Boolean) }
+    def requires_root?
+      @require_root.present? && @require_root == true
+    end
+
+    sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+    def run_at_load(value = nil)
+      case value
       when nil
-        @sockets
+        @run_at_load
+      when true, false
+        @run_at_load = value
+      end
+    end
+
+    SOCKET_STRING_REGEX = %r{^([a-z]+)://(.+):([0-9]+)$}i
+
+    sig {
+      params(value: T.nilable(T.any(String, T::Hash[Symbol, String])))
+        .returns(T.nilable(T::Hash[Symbol, T::Hash[Symbol, String]]))
+    }
+    def sockets(value = nil)
+      return @sockets if value.nil?
+
+      @sockets = case value
       when String
-        match = T.must(value).match(%r{([a-z]+)://([a-z0-9.]+):([0-9]+)}i)
+        { listeners: value }
+      when Hash
+        value
+      end.transform_values do |socket_string|
+        match = socket_string.match(SOCKET_STRING_REGEX)
         raise TypeError, "Service#sockets a formatted socket definition as <type>://<host>:<port>" if match.blank?
 
         type, host, port = match.captures
-        @sockets = { host: host, port: port, type: type }
-      else
-        raise TypeError, "Service#sockets expects a String"
+
+        begin
+          IPAddr.new(host)
+        rescue IPAddr::InvalidAddressError
+          raise TypeError, "Service#sockets expects a valid ipv4 or ipv6 host address"
+        end
+
+        { host:, port:, type: }
       end
     end
 
@@ -144,37 +221,32 @@ def sockets(value = nil)
     # @return [Boolean]
     sig { returns(T::Boolean) }
     def keep_alive?
-      instance_eval(&@service_block)
       @keep_alive.present? && @keep_alive[:always] != false
     end
 
     sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
     def launch_only_once(value = nil)
-      case T.unsafe(value)
+      case value
       when nil
         @launch_only_once
       when true, false
         @launch_only_once = value
-      else
-        raise TypeError, "Service#launch_only_once expects a Boolean"
       end
     end
 
     sig { params(value: T.nilable(Integer)).returns(T.nilable(Integer)) }
     def restart_delay(value = nil)
-      case T.unsafe(value)
+      case value
       when nil
         @restart_delay
       when Integer
         @restart_delay = value
-      else
-        raise TypeError, "Service#restart_delay expects an Integer"
       end
     end
 
     sig { params(value: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
     def process_type(value = nil)
-      case T.unsafe(value)
+      case value
       when nil
         @process_type
       when :background, :standard, :interactive, :adaptive
@@ -183,46 +255,38 @@ def process_type(value = nil)
         raise TypeError, "Service#process_type allows: " \
                          "'#{PROCESS_TYPE_BACKGROUND}'/'#{PROCESS_TYPE_STANDARD}'/" \
                          "'#{PROCESS_TYPE_INTERACTIVE}'/'#{PROCESS_TYPE_ADAPTIVE}'"
-      else
-        raise TypeError, "Service#process_type expects a Symbol"
       end
     end
 
     sig { params(value: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
     def run_type(value = nil)
-      case T.unsafe(value)
+      case value
       when nil
         @run_type
       when :immediate, :interval, :cron
         @run_type = value
       when Symbol
         raise TypeError, "Service#run_type allows: '#{RUN_TYPE_IMMEDIATE}'/'#{RUN_TYPE_INTERVAL}'/'#{RUN_TYPE_CRON}'"
-      else
-        raise TypeError, "Service#run_type expects a Symbol"
       end
     end
 
     sig { params(value: T.nilable(Integer)).returns(T.nilable(Integer)) }
     def interval(value = nil)
-      case T.unsafe(value)
+      case value
       when nil
         @interval
       when Integer
         @interval = value
-      else
-        raise TypeError, "Service#interval expects an Integer"
       end
     end
 
     sig { params(value: T.nilable(String)).returns(T.nilable(Hash)) }
     def cron(value = nil)
-      case T.unsafe(value)
+      case value
       when nil
         @cron
       when String
         @cron = parse_cron(T.must(value))
-      else
-        raise TypeError, "Service#cron expects a String"
       end
     end
 
@@ -272,25 +336,21 @@ def parse_cron(cron_statement)
       parsed
     end
 
-    sig { params(variables: T::Hash[String, String]).returns(T.nilable(T::Hash[String, String])) }
+    sig { params(variables: T::Hash[Symbol, String]).returns(T.nilable(T::Hash[Symbol, String])) }
     def environment_variables(variables = {})
-      case T.unsafe(variables)
+      case variables
       when Hash
         @environment_variables = variables.transform_values(&:to_s)
-      else
-        raise TypeError, "Service#environment_variables expects a hash"
       end
     end
 
     sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
     def macos_legacy_timers(value = nil)
-      case T.unsafe(value)
+      case value
       when nil
         @macos_legacy_timers
       when true, false
         @macos_legacy_timers = value
-      else
-        raise TypeError, "Service#macos_legacy_timers expects a Boolean"
       end
     end
 
@@ -301,21 +361,24 @@ def std_service_path_env
       "#{HOMEBREW_PREFIX}/bin:#{HOMEBREW_PREFIX}/sbin:/usr/bin:/bin:/usr/sbin:/sbin"
     end
 
-    sig { returns(T::Array[String]) }
+    sig { returns(T.nilable(T::Array[String])) }
     def command
-      instance_eval(&@service_block)
-      @run.map(&:to_s)
+      @run&.map(&:to_s)&.map { |arg| arg.start_with?("~") ? File.expand_path(arg) : arg }
+    end
+
+    sig { returns(T::Boolean) }
+    def command?
+      @run.present?
     end
 
     # Returns the `String` command to run manually instead of the service.
     # @return [String]
     sig { returns(String) }
     def manual_command
-      instance_eval(&@service_block)
       vars = @environment_variables.except(:PATH)
                                    .map { |k, v| "#{k}=\"#{v}\"" }
 
-      out = vars + command
+      out = vars + T.must(command).map { |arg| Utils::Shell.sh_quote(arg) } if command?
       out.join(" ")
     end
 
@@ -323,7 +386,6 @@ def manual_command
     # @return [Boolean]
     sig { returns(T::Boolean) }
     def timed?
-      instance_eval(&@service_block)
       @run_type == RUN_TYPE_CRON || @run_type == RUN_TYPE_INTERVAL
     end
 
@@ -333,9 +395,9 @@ def timed?
     def to_plist
       # command needs to be first because it initializes all other values
       base = {
-        Label:            @formula.plist_name,
+        Label:            plist_name,
         ProgramArguments: command,
-        RunAtLoad:        @run_type == RUN_TYPE_IMMEDIATE,
+        RunAtLoad:        @run_at_load == true,
       }
 
       base[:LaunchOnlyOnce] = @launch_only_once if @launch_only_once == true
@@ -343,11 +405,11 @@ def to_plist
       base[:TimeOut] = @restart_delay if @restart_delay.present?
       base[:ProcessType] = @process_type.to_s.capitalize if @process_type.present?
       base[:StartInterval] = @interval if @interval.present? && @run_type == RUN_TYPE_INTERVAL
-      base[:WorkingDirectory] = @working_dir if @working_dir.present?
-      base[:RootDirectory] = @root_dir if @root_dir.present?
-      base[:StandardInPath] = @input_path if @input_path.present?
-      base[:StandardOutPath] = @log_path if @log_path.present?
-      base[:StandardErrorPath] = @error_log_path if @error_log_path.present?
+      base[:WorkingDirectory] = File.expand_path(@working_dir) if @working_dir.present?
+      base[:RootDirectory] = File.expand_path(@root_dir) if @root_dir.present?
+      base[:StandardInPath] = File.expand_path(@input_path) if @input_path.present?
+      base[:StandardOutPath] = File.expand_path(@log_path) if @log_path.present?
+      base[:StandardErrorPath] = File.expand_path(@error_log_path) if @error_log_path.present?
       base[:EnvironmentVariables] = @environment_variables unless @environment_variables.empty?
 
       if keep_alive?
@@ -364,12 +426,13 @@ def to_plist
 
       if @sockets.present?
         base[:Sockets] = {}
-        base[:Sockets][:Listeners] = {
-          SockNodeName:    @sockets[:host],
-          SockServiceName: @sockets[:port],
-          SockProtocol:    @sockets[:type].upcase,
-          SockFamily:      "IPv4v6",
-        }
+        @sockets.each do |name, info|
+          base[:Sockets][name] = {
+            SockNodeName:    info[:host],
+            SockServiceName: info[:port],
+            SockProtocol:    info[:type].upcase,
+          }
+        end
       end
 
       if @cron.present? && @run_type == RUN_TYPE_CRON
@@ -396,25 +459,26 @@ def to_systemd_unit
         Description=Homebrew generated unit for #{@formula.name}
 
         [Install]
-        WantedBy=multi-user.target
+        WantedBy=default.target
 
         [Service]
       EOS
 
       # command needs to be first because it initializes all other values
-      cmd = command.join(" ")
+      cmd = command&.map { |arg| Utils::Shell.sh_quote(arg) }
+                   &.join(" ")
 
       options = []
-      options << "Type=#{@launch_only_once == true ? "oneshot" : "simple"}"
+      options << "Type=#{(@launch_only_once == true) ? "oneshot" : "simple"}"
       options << "ExecStart=#{cmd}"
 
       options << "Restart=always" if @keep_alive.present? && @keep_alive[:always].present?
       options << "RestartSec=#{restart_delay}" if @restart_delay.present?
-      options << "WorkingDirectory=#{@working_dir}" if @working_dir.present?
-      options << "RootDirectory=#{@root_dir}" if @root_dir.present?
-      options << "StandardInput=file:#{@input_path}" if @input_path.present?
-      options << "StandardOutput=append:#{@log_path}" if @log_path.present?
-      options << "StandardError=append:#{@error_log_path}" if @error_log_path.present?
+      options << "WorkingDirectory=#{File.expand_path(@working_dir)}" if @working_dir.present?
+      options << "RootDirectory=#{File.expand_path(@root_dir)}" if @root_dir.present?
+      options << "StandardInput=file:#{File.expand_path(@input_path)}" if @input_path.present?
+      options << "StandardOutput=append:#{File.expand_path(@log_path)}" if @log_path.present?
+      options << "StandardError=append:#{File.expand_path(@error_log_path)}" if @error_log_path.present?
       options += @environment_variables.map { |k, v| "Environment=\"#{k}=#{v}\"" } if @environment_variables.present?
 
       unit + options.join("\n")
@@ -432,21 +496,148 @@ def to_systemd_timer
         WantedBy=timers.target
 
         [Timer]
-        Unit=#{@formula.service_name}
+        Unit=#{service_name}
       EOS
 
-      instance_eval(&@service_block)
       options = []
       options << "Persistent=true" if @run_type == RUN_TYPE_CRON
       options << "OnUnitActiveSec=#{@interval}" if @run_type == RUN_TYPE_INTERVAL
 
       if @run_type == RUN_TYPE_CRON
-        minutes = @cron[:Minute] == "*" ? "*" : format("%02d", @cron[:Minute])
-        hours   = @cron[:Hour] == "*" ? "*" : format("%02d", @cron[:Hour])
+        minutes = (@cron[:Minute] == "*") ? "*" : format("%02d", @cron[:Minute])
+        hours   = (@cron[:Hour] == "*") ? "*" : format("%02d", @cron[:Hour])
         options << "OnCalendar=#{@cron[:Weekday]}-*-#{@cron[:Month]}-#{@cron[:Day]} #{hours}:#{minutes}:00"
       end
 
       timer + options.join("\n")
     end
+
+    # Prepare the service hash for inclusion in the formula API JSON.
+    sig { returns(Hash) }
+    def to_hash
+      name_params = {
+        macos: (plist_name if plist_name != default_plist_name),
+        linux: (service_name if service_name != default_service_name),
+      }.compact
+
+      return { name: name_params }.compact_blank if @run_params.blank?
+
+      cron_string = if @cron.present?
+        [:Minute, :Hour, :Day, :Month, :Weekday]
+          .map { |key| @cron[key].to_s }
+          .join(" ")
+      end
+
+      sockets_var = if @sockets.present?
+        @sockets.transform_values { |info| "#{info[:type]}://#{info[:host]}:#{info[:port]}" }
+                .then do |sockets_hash|
+                  # TODO: Remove this code when all users are running on versions of Homebrew
+                  # that can process sockets hashes (this commit or later).
+                  if sockets_hash.size == 1 && sockets_hash.key?(:listeners)
+                    # When original #sockets argument was a string: `sockets "tcp://127.0.0.1:80"`
+                    sockets_hash.fetch(:listeners)
+                  else
+                    # When original #sockets argument was a hash: `sockets http: "tcp://0.0.0.0:80"`
+                    sockets_hash
+                  end
+                end
+      end
+
+      {
+        name:                  name_params.presence,
+        run:                   @run_params,
+        run_type:              @run_type,
+        interval:              @interval,
+        cron:                  cron_string,
+        keep_alive:            @keep_alive,
+        launch_only_once:      @launch_only_once,
+        require_root:          @require_root,
+        environment_variables: @environment_variables.presence,
+        working_dir:           @working_dir,
+        root_dir:              @root_dir,
+        input_path:            @input_path,
+        log_path:              @log_path,
+        error_log_path:        @error_log_path,
+        restart_delay:         @restart_delay,
+        process_type:          @process_type,
+        macos_legacy_timers:   @macos_legacy_timers,
+        sockets:               sockets_var,
+      }.compact
+    end
+
+    # Turn the service API hash values back into what is expected by the formula DSL.
+    sig { params(api_hash: Hash).returns(Hash) }
+    def self.from_hash(api_hash)
+      hash = {}
+      hash[:name] = api_hash["name"].transform_keys(&:to_sym) if api_hash.key?("name")
+
+      # The service hash might not have a "run" command if it only documents
+      # an existing service file with the "name" command.
+      return hash unless api_hash.key?("run")
+
+      hash[:run] =
+        case api_hash["run"]
+        when String
+          replace_placeholders(api_hash["run"])
+        when Array
+          api_hash["run"].map { replace_placeholders(_1) }
+        when Hash
+          api_hash["run"].to_h do |key, elem|
+            run_cmd = if elem.is_a?(Array)
+              elem.map { replace_placeholders(_1) }
+            else
+              replace_placeholders(elem)
+            end
+
+            [key.to_sym, run_cmd]
+          end
+        else
+          raise ArgumentError, "Unexpected run command: #{api_hash["run"]}"
+        end
+
+      if api_hash.key?("environment_variables")
+        hash[:environment_variables] = api_hash["environment_variables"].to_h do |key, value|
+          [key.to_sym, replace_placeholders(value)]
+        end
+      end
+
+      %w[run_type process_type].each do |key|
+        next unless (value = api_hash[key])
+
+        hash[key.to_sym] = value.to_sym
+      end
+
+      %w[working_dir root_dir input_path log_path error_log_path].each do |key|
+        next unless (value = api_hash[key])
+
+        hash[key.to_sym] = replace_placeholders(value)
+      end
+
+      %w[interval cron launch_only_once require_root restart_delay macos_legacy_timers].each do |key|
+        next if (value = api_hash[key]).nil?
+
+        hash[key.to_sym] = value
+      end
+
+      %w[sockets keep_alive].each do |key|
+        next unless (value = api_hash[key])
+
+        hash[key.to_sym] = if value.is_a?(Hash)
+          value.transform_keys(&:to_sym)
+        else
+          value
+        end
+      end
+
+      hash
+    end
+
+    # Replace API path placeholders with local paths.
+    sig { params(string: String).returns(String) }
+    def self.replace_placeholders(string)
+      string.gsub(HOMEBREW_PREFIX_PLACEHOLDER, HOMEBREW_PREFIX)
+            .gsub(HOMEBREW_CELLAR_PLACEHOLDER, HOMEBREW_CELLAR)
+            .gsub(HOMEBREW_HOME_PLACEHOLDER, Dir.home)
+    end
   end
 end
diff --git a/Library/Homebrew/service.rbi b/Library/Homebrew/service.rbi
new file mode 100644
index 0000000000000..5777dab11bb10
--- /dev/null
+++ b/Library/Homebrew/service.rbi
@@ -0,0 +1,7 @@
+# typed: strict
+
+module Homebrew
+  class Service
+    def on_system_conditional(macos: nil, linux: nil); end
+  end
+end
diff --git a/Library/Homebrew/settings.rb b/Library/Homebrew/settings.rb
index f04820eef2c06..6aee3015da737 100644
--- a/Library/Homebrew/settings.rb
+++ b/Library/Homebrew/settings.rb
@@ -1,16 +1,12 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "utils/popen"
 
 module Homebrew
   # Helper functions for reading and writing settings.
-  #
-  # @api private
   module Settings
-    module_function
-
-    def read(setting, repo: HOMEBREW_REPOSITORY)
+    def self.read(setting, repo: HOMEBREW_REPOSITORY)
       return unless (repo/".git/config").exist?
 
       value = Utils.popen_read("git", "-C", repo.to_s, "config", "--get", "homebrew.#{setting}").chomp
@@ -20,20 +16,20 @@ def read(setting, repo: HOMEBREW_REPOSITORY)
       value
     end
 
-    def write(setting, value, repo: HOMEBREW_REPOSITORY)
+    def self.write(setting, value, repo: HOMEBREW_REPOSITORY)
       return unless (repo/".git/config").exist?
 
       value = value.to_s
 
-      return if read(setting, repo: repo) == value
+      return if read(setting, repo:) == value
 
       Kernel.system("git", "-C", repo.to_s, "config", "--replace-all", "homebrew.#{setting}", value, exception: true)
     end
 
-    def delete(setting, repo: HOMEBREW_REPOSITORY)
+    def self.delete(setting, repo: HOMEBREW_REPOSITORY)
       return unless (repo/".git/config").exist?
 
-      return if read(setting, repo: repo).blank?
+      return if read(setting, repo:).nil?
 
       Kernel.system("git", "-C", repo.to_s, "config", "--unset-all", "homebrew.#{setting}", exception: true)
     end
diff --git a/Library/Homebrew/settings.rbi b/Library/Homebrew/settings.rbi
deleted file mode 100644
index d902c06acb7c8..0000000000000
--- a/Library/Homebrew/settings.rbi
+++ /dev/null
@@ -1,16 +0,0 @@
-# typed: strict
-
-module Homebrew
-  module Settings
-    include Kernel
-
-    sig { params(setting: T.any(String, Symbol), repo: Pathname).returns(T.nilable(String)) }
-    def read(setting, repo: HOMEBREW_REPOSITORY); end
-
-    sig { params(setting: T.any(String, Symbol), value: T.any(String, T::Boolean), repo: Pathname).void }
-    def write(setting, value, repo: HOMEBREW_REPOSITORY); end
-
-    sig { params(setting: T.any(String, Symbol), repo: Pathname).void }
-    def delete(setting, repo: HOMEBREW_REPOSITORY); end
-  end
-end
diff --git a/Library/Homebrew/shell_command.rb b/Library/Homebrew/shell_command.rb
new file mode 100644
index 0000000000000..905cd50b23fa3
--- /dev/null
+++ b/Library/Homebrew/shell_command.rb
@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  module ShellCommand
+    extend T::Helpers
+
+    requires_ancestor { AbstractCommand }
+
+    sig { void }
+    def run
+      T.bind(self, AbstractCommand)
+
+      sh_cmd_path = "#{self.class.dev_cmd? ? "dev-cmd" : "cmd"}/#{self.class.command_name}.sh"
+      raise StandardError,
+            "This command is just here for completions generation. " \
+            "It's actually defined in `#{sh_cmd_path}` instead."
+    end
+  end
+end
diff --git a/Library/Homebrew/shims/gems/rdbg b/Library/Homebrew/shims/gems/rdbg
new file mode 100755
index 0000000000000..3c4f3b0b283de
--- /dev/null
+++ b/Library/Homebrew/shims/gems/rdbg
@@ -0,0 +1,6 @@
+#!/bin/bash
+
+export HOMEBREW_RDBG="1"
+
+HOMEBREW_PORTABLE_RUBY_BIN="$(cd "$(dirname "$0")"/../../ && pwd)/vendor/portable-ruby/current/bin/"
+exec "${HOMEBREW_PORTABLE_RUBY_BIN}"rdbg "$@"
diff --git a/Library/Homebrew/shims/gems/rubocop b/Library/Homebrew/shims/gems/rubocop
index 4cfafc2e0775d..e1e251669ecef 100755
--- a/Library/Homebrew/shims/gems/rubocop
+++ b/Library/Homebrew/shims/gems/rubocop
@@ -1,2 +1,3 @@
 #!/bin/bash
-exec brew rubocop "$@"
+HOMEBREW_PREFIX_BIN="$(cd "$(dirname "$0")"/../../../../ && pwd)/bin/"
+exec "${HOMEBREW_PREFIX_BIN}"brew rubocop "$@"
diff --git a/Library/Homebrew/shims/linux/super/gcc-4.2 b/Library/Homebrew/shims/linux/super/g++-13
similarity index 100%
rename from Library/Homebrew/shims/linux/super/gcc-4.2
rename to Library/Homebrew/shims/linux/super/g++-13
diff --git a/Library/Homebrew/shims/linux/super/gcc-4.9 b/Library/Homebrew/shims/linux/super/g++-14
similarity index 100%
rename from Library/Homebrew/shims/linux/super/gcc-4.9
rename to Library/Homebrew/shims/linux/super/g++-14
diff --git a/Library/Homebrew/shims/linux/super/gcc-5 b/Library/Homebrew/shims/linux/super/gcc-13
similarity index 100%
rename from Library/Homebrew/shims/linux/super/gcc-5
rename to Library/Homebrew/shims/linux/super/gcc-13
diff --git a/Library/Homebrew/shims/linux/super/gcc-6 b/Library/Homebrew/shims/linux/super/gcc-14
similarity index 100%
rename from Library/Homebrew/shims/linux/super/gcc-6
rename to Library/Homebrew/shims/linux/super/gcc-14
diff --git a/Library/Homebrew/shims/linux/super/gmake b/Library/Homebrew/shims/linux/super/gmake
new file mode 120000
index 0000000000000..ac08cdcf9508e
--- /dev/null
+++ b/Library/Homebrew/shims/linux/super/gmake
@@ -0,0 +1 @@
+make
\ No newline at end of file
diff --git a/Library/Homebrew/shims/linux/super/gnumake b/Library/Homebrew/shims/linux/super/gnumake
new file mode 120000
index 0000000000000..ac08cdcf9508e
--- /dev/null
+++ b/Library/Homebrew/shims/linux/super/gnumake
@@ -0,0 +1 @@
+make
\ No newline at end of file
diff --git a/Library/Homebrew/shims/mac/super/bsdmake b/Library/Homebrew/shims/mac/super/bsdmake
deleted file mode 100755
index 893e19f7f6bb9..0000000000000
--- a/Library/Homebrew/shims/mac/super/bsdmake
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/bash
-
-export HOMEBREW_CCCFG="O${HOMEBREW_CCCFG}"
-exec xcrun bsdmake "$@"
diff --git a/Library/Homebrew/shims/mac/super/bsdmake b/Library/Homebrew/shims/mac/super/bsdmake
new file mode 120000
index 0000000000000..ac08cdcf9508e
--- /dev/null
+++ b/Library/Homebrew/shims/mac/super/bsdmake
@@ -0,0 +1 @@
+make
\ No newline at end of file
diff --git a/Library/Homebrew/shims/linux/super/llvm-g++ b/Library/Homebrew/shims/mac/super/g++-13
similarity index 100%
rename from Library/Homebrew/shims/linux/super/llvm-g++
rename to Library/Homebrew/shims/mac/super/g++-13
diff --git a/Library/Homebrew/shims/linux/super/llvm-g++-4.2 b/Library/Homebrew/shims/mac/super/g++-14
similarity index 100%
rename from Library/Homebrew/shims/linux/super/llvm-g++-4.2
rename to Library/Homebrew/shims/mac/super/g++-14
diff --git a/Library/Homebrew/shims/linux/super/llvm-gcc b/Library/Homebrew/shims/mac/super/gcc-13
similarity index 100%
rename from Library/Homebrew/shims/linux/super/llvm-gcc
rename to Library/Homebrew/shims/mac/super/gcc-13
diff --git a/Library/Homebrew/shims/linux/super/llvm-gcc-4.2 b/Library/Homebrew/shims/mac/super/gcc-14
similarity index 100%
rename from Library/Homebrew/shims/linux/super/llvm-gcc-4.2
rename to Library/Homebrew/shims/mac/super/gcc-14
diff --git a/Library/Homebrew/shims/mac/super/i686-apple-darwin11-llvm-g++-4.2 b/Library/Homebrew/shims/mac/super/i686-apple-darwin11-llvm-g++-4.2
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/mac/super/i686-apple-darwin11-llvm-g++-4.2
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/mac/super/i686-apple-darwin11-llvm-gcc-4.2 b/Library/Homebrew/shims/mac/super/i686-apple-darwin11-llvm-gcc-4.2
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/mac/super/i686-apple-darwin11-llvm-gcc-4.2
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/mac/super/llvm-g++ b/Library/Homebrew/shims/mac/super/llvm-g++
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/mac/super/llvm-g++
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/mac/super/llvm-g++-4.2 b/Library/Homebrew/shims/mac/super/llvm-g++-4.2
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/mac/super/llvm-g++-4.2
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/mac/super/llvm-gcc b/Library/Homebrew/shims/mac/super/llvm-gcc
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/mac/super/llvm-gcc
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/mac/super/llvm-gcc-4.2 b/Library/Homebrew/shims/mac/super/llvm-gcc-4.2
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/mac/super/llvm-gcc-4.2
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/mac/super/make b/Library/Homebrew/shims/mac/super/make
index 6677f67329744..4ee9aca02a7bc 100755
--- a/Library/Homebrew/shims/mac/super/make
+++ b/Library/Homebrew/shims/mac/super/make
@@ -1,4 +1,10 @@
 #!/bin/bash
 
+# HOMEBREW_LIBRARY is set by bin/brew
+# shellcheck disable=SC2154
+source "${HOMEBREW_LIBRARY}/Homebrew/shims/utils.sh"
+
 export HOMEBREW_CCCFG="O${HOMEBREW_CCCFG}"
-exec xcrun "make" "$@"
+
+try_exec_non_system "${SHIM_FILE}" "$@"
+safe_exec "/usr/bin/make" "$@"
diff --git a/Library/Homebrew/shims/shared/curl b/Library/Homebrew/shims/shared/curl
index 4476dc782c769..790bca07ce610 100755
--- a/Library/Homebrew/shims/shared/curl
+++ b/Library/Homebrew/shims/shared/curl
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/bash -p
 
 # Make our $HOMEBREW_CURL selection universal - including in formulae usage.
 
diff --git a/Library/Homebrew/shims/shared/git b/Library/Homebrew/shims/shared/git
index a96937647946f..d7193d3041a04 100755
--- a/Library/Homebrew/shims/shared/git
+++ b/Library/Homebrew/shims/shared/git
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/bash -p
 
 # This script because we support $HOMEBREW_GIT, $HOMEBREW_SVN, etc., Xcode-only and
 # no Xcode/CLT configurations. Order is careful to be what the user would want.
diff --git a/Library/Homebrew/shims/super/cc b/Library/Homebrew/shims/super/cc
index 7b607f5215b53..458a5dc236fa2 100755
--- a/Library/Homebrew/shims/super/cc
+++ b/Library/Homebrew/shims/super/cc
@@ -1,10 +1,18 @@
 #!/bin/bash
+# vim: ft=ruby
 # Make sure this shim uses the same Ruby interpreter that is used by Homebrew.
 if [[ -z "${HOMEBREW_RUBY_PATH}" ]]
 then
   echo "${0##*/}: The build tool has reset ENV; --env=std required." >&2
   exit 1
 fi
+unset HOMEBREW_LD_LIBRARY_PATH
+if [[ -n "${LD_LIBRARY_PATH+set}" ]]
+then
+  export HOMEBREW_LD_LIBRARY_PATH="${LD_LIBRARY_PATH}"
+fi
+unset LD_LIBRARY_PATH
+unset RUBYLIB
 exec "${HOMEBREW_RUBY_PATH}" --enable-frozen-string-literal --disable=gems,did_you_mean,rubyopt -x "$0" "$@"
 #!/usr/bin/env ruby -W0
 
@@ -28,7 +36,7 @@ class Cmd
   CXX_REGEX = /(?:c|g|clang)\+\+/.freeze
 
   attr_reader :config, :prefix, :cellar, :opt, :cachedir, :tmpdir, :sysroot, :deps
-  attr_reader :archflags, :optflags, :keg_regex, :formula_prefix
+  attr_reader :archflags, :optflags, :keg_regex, :formula_prefix, :formula_buildpath
 
   def initialize(arg0, args)
     @arg0 = arg0
@@ -44,6 +52,7 @@ class Cmd
     @optflags = ENV.fetch("HOMEBREW_OPTFLAGS", "").split
     @deps = Set.new(ENV.fetch("HOMEBREW_DEPENDENCIES", "").split(","))
     @formula_prefix = ENV["HOMEBREW_FORMULA_PREFIX"]
+    @formula_buildpath = ENV["HOMEBREW_FORMULA_BUILDPATH"]
     # matches opt or cellar prefix and formula name
     @keg_regex = %r{(#{Regexp.escape(opt)}|#{Regexp.escape(cellar)})/([\w+-.@]+)}
   end
@@ -83,8 +92,6 @@ class Cmd
         "#{ENV["HOMEBREW_PREFIX"]}/opt/swift/libexec/bin/clang++"
       when /clang/
         "clang++"
-      when /llvm-gcc/
-        "llvm-g++-4.2"
       when /(g)?cc(-\d+(\.\d)?)?$/
         "g++#{Regexp.last_match(2)}"
       end
@@ -220,7 +227,7 @@ class Cmd
       args << "-Wl,-undefined,dynamic_lookup"
     when /^-isysroot=/, /^--sysroot=/
       if mac?
-        sdk = arg.split("=")[1..-1].join("=")
+        sdk = arg.split("=", 2).last
         # We set the sysroot for macOS SDKs
         args << arg unless sdk.downcase.include? "osx"
       else
@@ -286,12 +293,12 @@ class Cmd
 
     return args if !refurbish_args? && !configure?
 
-    args << "-pipe"
     args << "-w" unless configure?
     args << "-#{ENV["HOMEBREW_OPTIMIZATION_LEVEL"]}"
     args.concat(optflags) unless runtime_cpu_detection?
     args.concat(archflags)
     args << "-std=#{@arg0}" if /c[89]9/.match?(@arg0)
+    args << "-g" if debug_symbols?
     args
   end
 
@@ -308,6 +315,9 @@ class Cmd
     args += path_flags("-isystem", isystem_paths) + path_flags("-I", include_paths)
     # Add -nostdinc when building against glibc@2.13 to avoid mixing system and brewed glibc headers.
     args << "-nostdinc" if @deps.include?("glibc@2.13")
+    # Ideally this would be -ffile-prefix-map, but that requires a minimum of GCC 8, LLVM Clang 10 or Apple Clang 12
+    # and detecting the version dynamically based on what `HOMEBREW_CC` may have been rewritten to point to is awkward
+    args << "-fdebug-prefix-map=#{formula_buildpath}=." if formula_buildpath && !debug_symbols?
     args
   end
 
@@ -316,9 +326,15 @@ class Cmd
     when :ld
       args << "-headerpad_max_install_names"
       args << "-no_weak_imports" if no_weak_imports?
+      args << "-no_fixup_chains" if no_fixup_chains?
+      args << "-oso_prefix" << formula_buildpath if oso_prefix? && formula_buildpath
+      args << "-ld_classic" if ld_classic?
     when :ccld, :cxxld
       args << "-Wl,-headerpad_max_install_names"
       args << "-Wl,-no_weak_imports" if no_weak_imports?
+      args << "-Wl,-no_fixup_chains" if no_fixup_chains?
+      args << "-Wl,-oso_prefix,#{formula_buildpath}" if oso_prefix? && formula_buildpath
+      args << "-Wl,-ld_classic" if ld_classic?
     end
     args
   end
@@ -410,6 +426,49 @@ class Cmd
     config.include?("w")
   end
 
+  def debug_symbols?
+    config.include?("D")
+  end
+
+  def linker_flags
+    @args.select { |arg| arg.start_with?("-Wl,") }
+         .flat_map { |arg| arg.delete_prefix("-Wl,").split(",") }
+  end
+
+  def no_fixup_chains?
+    return false unless config.include?("f")
+    return false unless calls_ld?
+    return true if @args.each_cons(2).include?(["-undefined", "dynamic_lookup"])
+    return true if linker_flags.each_cons(2).include?(["-undefined", "dynamic_lookup"])
+
+    # The next flag would produce an error, but we fix it in `refurbish_arg`.
+    @args.include?("-undefineddynamic_lookup")
+  end
+
+  def oso_prefix?
+    config.include?("o") && !configure? && !debug_symbols?
+  end
+
+  def ld_classic?
+    return false unless config.include?("c")
+    return false unless calls_ld?
+
+    @args.include?("-dead_strip_dylibs") || linker_flags.include?("-dead_strip_dylibs")
+  end
+
+  def calls_ld?
+    return true if mode == :ld
+    return false unless [:ccld, :cxxld].include?(mode)
+
+    fuse_ld_flags = @args.find_all { |arg| arg.match?(/^-fuse-ld=/) }
+    return true if fuse_ld_flags.empty?
+
+    fuse_ld_flag = fuse_ld_flags.last.strip
+    fuse_ld_arg = fuse_ld_flag.split("=", 2).last
+
+    (fuse_ld_arg == "ld") || fuse_ld_arg.end_with?("/usr/bin/ld")
+  end
+
   def canonical_path(path)
     path = Pathname.new(path)
     path = path.realpath if path.exist?
@@ -469,6 +528,8 @@ if __FILE__ == $PROGRAM_NAME
     ENV["HOMEBREW_CC"] = "clang"
   end
 
+  ENV["LD_LIBRARY_PATH"] = ENV["HOMEBREW_LD_LIBRARY_PATH"]
+
   ####################################################################### main
 
   dirname, basename = File.split($PROGRAM_NAME)
diff --git a/Library/Homebrew/shims/mac/super/gcc-4.2 b/Library/Homebrew/shims/super/g++-13
similarity index 100%
rename from Library/Homebrew/shims/mac/super/gcc-4.2
rename to Library/Homebrew/shims/super/g++-13
diff --git a/Library/Homebrew/shims/mac/super/gcc-4.9 b/Library/Homebrew/shims/super/g++-14
similarity index 100%
rename from Library/Homebrew/shims/mac/super/gcc-4.9
rename to Library/Homebrew/shims/super/g++-14
diff --git a/Library/Homebrew/shims/mac/super/gcc-5 b/Library/Homebrew/shims/super/gcc-13
similarity index 100%
rename from Library/Homebrew/shims/mac/super/gcc-5
rename to Library/Homebrew/shims/super/gcc-13
diff --git a/Library/Homebrew/shims/mac/super/gcc-6 b/Library/Homebrew/shims/super/gcc-14
similarity index 100%
rename from Library/Homebrew/shims/mac/super/gcc-6
rename to Library/Homebrew/shims/super/gcc-14
diff --git a/Library/Homebrew/shims/super/gcc-4.9 b/Library/Homebrew/shims/super/gcc-4.9
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/super/gcc-4.9
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/super/gcc-5 b/Library/Homebrew/shims/super/gcc-5
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/super/gcc-5
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/super/gcc-6 b/Library/Homebrew/shims/super/gcc-6
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/super/gcc-6
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/super/i686-apple-darwin11-llvm-g++-4.2 b/Library/Homebrew/shims/super/i686-apple-darwin11-llvm-g++-4.2
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/super/i686-apple-darwin11-llvm-g++-4.2
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/super/i686-apple-darwin11-llvm-gcc-4.2 b/Library/Homebrew/shims/super/i686-apple-darwin11-llvm-gcc-4.2
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/super/i686-apple-darwin11-llvm-gcc-4.2
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/super/llvm-g++ b/Library/Homebrew/shims/super/llvm-g++
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/super/llvm-g++
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/super/llvm-g++-4.2 b/Library/Homebrew/shims/super/llvm-g++-4.2
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/super/llvm-g++-4.2
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/super/llvm-gcc b/Library/Homebrew/shims/super/llvm-gcc
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/super/llvm-gcc
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/super/llvm-gcc-4.2 b/Library/Homebrew/shims/super/llvm-gcc-4.2
deleted file mode 120000
index 2652f5f42c003..0000000000000
--- a/Library/Homebrew/shims/super/llvm-gcc-4.2
+++ /dev/null
@@ -1 +0,0 @@
-cc
\ No newline at end of file
diff --git a/Library/Homebrew/shims/super/ninja b/Library/Homebrew/shims/super/ninja
index 5e5da7581c83b..bee8ac53f6801 100755
--- a/Library/Homebrew/shims/super/ninja
+++ b/Library/Homebrew/shims/super/ninja
@@ -11,9 +11,15 @@ fi
 
 source "${HOMEBREW_LIBRARY}/Homebrew/shims/utils.sh"
 
+parallel_args=()
+if [[ -n "${HOMEBREW_MAKE_JOBS}" ]]
+then
+  parallel_args+=(-j "${HOMEBREW_MAKE_JOBS}")
+fi
+
 # shellcheck disable=SC2154
 export HOMEBREW_CCCFG="O${HOMEBREW_CCCFG}"
-try_exec_non_system "ninja" "$@"
+try_exec_non_system "ninja" "${parallel_args[@]}" "$@"
 
 echo "ninja: Shim failed to find ninja in PATH."
 exit 1
diff --git a/Library/Homebrew/simulate_system.rb b/Library/Homebrew/simulate_system.rb
index d52a2af752733..e1b80b84150fb 100644
--- a/Library/Homebrew/simulate_system.rb
+++ b/Library/Homebrew/simulate_system.rb
@@ -1,19 +1,41 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "macos_version"
+
 module Homebrew
-  # Helper module for simulating different system condfigurations.
-  #
-  # @api private
+  # Helper module for simulating different system configurations.
   class SimulateSystem
     class << self
-      extend T::Sig
+      attr_reader :arch, :os
+
+      sig {
+        type_parameters(:U).params(
+          os:     Symbol,
+          arch:   Symbol,
+          _block: T.proc.returns(T.type_parameter(:U)),
+        ).returns(T.type_parameter(:U))
+      }
+      def with(os: T.unsafe(nil), arch: T.unsafe(nil), &_block)
+        raise ArgumentError, "At least one of `os` or `arch` must be specified." if !os && !arch
+
+        old_os = self.os
+        old_arch = self.arch
 
-      attr_reader :os, :arch
+        begin
+          self.os = os if os && os != current_os
+          self.arch = arch if arch && arch != current_arch
+
+          yield
+        ensure
+          @os = old_os
+          @arch = old_arch
+        end
+      end
 
       sig { params(new_os: Symbol).void }
       def os=(new_os)
-        os_options = [:macos, :linux, *MacOSVersions::SYMBOLS.keys]
+        os_options = [:macos, :linux, *MacOSVersion::SYMBOLS.keys]
         raise "Unknown OS: #{new_os}" unless os_options.include?(new_os)
 
         @os = new_os
@@ -21,7 +43,7 @@ def os=(new_os)
 
       sig { params(new_arch: Symbol).void }
       def arch=(new_arch)
-        raise "New arch must be :arm or :intel" unless [:arm, :intel].include?(new_arch)
+        raise "New arch must be :arm or :intel" unless OnSystem::ARCH_OPTIONS.include?(new_arch)
 
         @arch = new_arch
       end
@@ -32,19 +54,26 @@ def clear
       end
 
       sig { returns(T::Boolean) }
-      def none?
-        @os.nil? && @arch.nil?
+      def simulating_or_running_on_macos?
+        [:macos, *MacOSVersion::SYMBOLS.keys].include?(os)
       end
 
       sig { returns(T::Boolean) }
-      def macos?
-        [:macos, *MacOSVersions::SYMBOLS.keys].include?(@os)
+      def simulating_or_running_on_linux?
+        os == :linux
       end
 
-      sig { returns(T::Boolean) }
-      def linux?
-        @os == :linux
+      sig { returns(Symbol) }
+      def current_arch
+        @arch || Hardware::CPU.type
+      end
+
+      sig { returns(Symbol) }
+      def current_os
+        os || :generic
       end
     end
   end
 end
+
+require "extend/os/simulate_system"
diff --git a/Library/Homebrew/software_spec.rb b/Library/Homebrew/software_spec.rb
index c27f124aa6dc9..cb7969a7dab90 100644
--- a/Library/Homebrew/software_spec.rb
+++ b/Library/Homebrew/software_spec.rb
@@ -1,6 +1,7 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "attrable"
 require "resource"
 require "download_strategy"
 require "checksum"
@@ -11,11 +12,11 @@
 require "utils/bottles"
 require "patch"
 require "compilers"
-require "os/mac/version"
+require "macos_version"
 require "extend/on_system"
 
 class SoftwareSpec
-  extend T::Sig
+  include Downloadable
 
   extend Forwardable
   include OnSystem::MacOSAndLinux
@@ -26,8 +27,7 @@ class SoftwareSpec
   }.freeze
 
   attr_reader :name, :full_name, :owner, :build, :resources, :patches, :options, :deprecated_flags,
-              :deprecated_options, :dependency_collector, :bottle_specification, :compiler_failures,
-              :uses_from_macos_elements
+              :deprecated_options, :dependency_collector, :bottle_specification, :compiler_failures
 
   def_delegators :@resource, :stage, :fetch, :verify_download_integrity, :source_modified_time, :download_name,
                  :cached_download, :clear_cache, :checksum, :mirrors, :specs, :using, :version, :mirror,
@@ -36,7 +36,10 @@ class SoftwareSpec
   def_delegators :@resource, :sha256
 
   def initialize(flags: [])
-    @resource = Resource.new
+    super()
+
+    # Ensure this is synced with `initialize_dup` and `freeze` (excluding simple objects like integers and booleans)
+    @resource = Resource::Formula.new
     @resources = {}
     @dependency_collector = DependencyCollector.new
     @bottle_specification = BottleSpecification.new
@@ -47,7 +50,41 @@ def initialize(flags: [])
     @deprecated_options = []
     @build = BuildOptions.new(Options.create(@flags), options)
     @compiler_failures = []
-    @uses_from_macos_elements = []
+  end
+
+  def initialize_dup(other)
+    super
+    @resource = @resource.dup
+    @resources = @resources.dup
+    @dependency_collector = @dependency_collector.dup
+    @bottle_specification = @bottle_specification.dup
+    @patches = @patches.dup
+    @options = @options.dup
+    @flags = @flags.dup
+    @deprecated_flags = @deprecated_flags.dup
+    @deprecated_options = @deprecated_options.dup
+    @build = @build.dup
+    @compiler_failures = @compiler_failures.dup
+  end
+
+  def freeze
+    @resource.freeze
+    @resources.freeze
+    @dependency_collector.freeze
+    @bottle_specification.freeze
+    @patches.freeze
+    @options.freeze
+    @flags.freeze
+    @deprecated_flags.freeze
+    @deprecated_options.freeze
+    @build.freeze
+    @compiler_failures.freeze
+    super
+  end
+
+  sig { override.returns(String) }
+  def download_type
+    "formula"
   end
 
   def owner=(owner)
@@ -58,15 +95,10 @@ def owner=(owner)
     @resource.owner = self
     resources.each_value do |r|
       r.owner = self
-      r.version ||= begin
-        raise "#{full_name}: version missing for \"#{r.name}\" resource!" if version.nil?
+      next if r.version
+      next if version.nil?
 
-        if version.head?
-          Version.create("HEAD")
-        else
-          version.dup
-        end
-      end
+      r.version(version.head? ? Version.new("HEAD") : version.dup)
     end
     patches.each { |p| p.owner = self }
   end
@@ -74,7 +106,7 @@ def owner=(owner)
   def url(val = nil, specs = {})
     return @resource.url if val.nil?
 
-    @resource.url(val, specs)
+    @resource.url(val, **specs)
     dependency_collector.add(@resource)
   end
 
@@ -87,7 +119,7 @@ def bottle_tag?(tag = nil)
   end
 
   def bottled?(tag = nil)
-    bottle_tag?(tag) && \
+    bottle_tag?(tag) &&
       (tag.present? || bottle_specification.compatible_locations? || owner.force_bottle)
   end
 
@@ -99,8 +131,13 @@ def resource_defined?(name)
     resources.key?(name)
   end
 
-  def resource(name, klass = Resource, &block)
+  sig {
+    params(name: String, klass: T.class_of(Resource), block: T.nilable(T.proc.bind(Resource).void))
+      .returns(T.nilable(Resource))
+  }
+  def resource(name = T.unsafe(nil), klass = Resource, &block)
     if block
+      raise ArgumentError, "Resource must have a name." if name.nil?
       raise DuplicateResourceError, name if resource_defined?(name)
 
       res = klass.new(name, &block)
@@ -108,12 +145,16 @@ def resource(name, klass = Resource, &block)
 
       resources[name] = res
       dependency_collector.add(res)
+      res
     else
+      return @resource if name.nil?
+
       resources.fetch(name) { raise ResourceMissingError.new(owner, name) }
     end
   end
 
   def go_resource(name, &block)
+    odisabled "`SoftwareSpec#go_resource`", "Go modules"
     resource name, Resource::Go, &block
   end
 
@@ -127,7 +168,7 @@ def option(name, description = "")
         raise ArgumentError, "option name must be string or symbol; got a #{name.class}: #{name}"
       end
       raise ArgumentError, "option name is required" if name.empty?
-      raise ArgumentError, "option name must be longer than one character: #{name}" unless name.length > 1
+      raise ArgumentError, "option name must be longer than one character: #{name}" if name.length <= 1
       raise ArgumentError, "option name must not start with dashes: #{name}" if name.start_with?("-")
 
       Option.new(name, description)
@@ -162,31 +203,43 @@ def depends_on(spec)
     add_dep_option(dep) if dep
   end
 
-  def uses_from_macos(spec, _bounds = {})
-    spec = [spec.dup.shift].to_h if spec.is_a?(Hash)
-
-    @uses_from_macos_elements << spec
+  sig {
+    params(
+      dep:    T.any(String, T::Hash[T.any(String, Symbol), T.any(Symbol, T::Array[Symbol])]),
+      bounds: T::Hash[Symbol, Symbol],
+    ).void
+  }
+  def uses_from_macos(dep, bounds = {})
+    if dep.is_a?(Hash)
+      bounds = dep.dup
+      dep, tags = bounds.shift
+      dep = T.cast(dep, String)
+      tags = [*tags]
+      bounds = T.cast(bounds, T::Hash[Symbol, Symbol])
+    else
+      tags = []
+    end
 
-    depends_on(spec)
+    depends_on UsesFromMacOSDependency.new(dep, tags, bounds:)
   end
 
-  def uses_from_macos_names
-    uses_from_macos_elements.flat_map { |e| e.is_a?(Hash) ? e.keys : e }
+  def deps
+    dependency_collector.deps.dup_without_system_deps
   end
 
-  def deps
+  def declared_deps
     dependency_collector.deps
   end
 
   def recursive_dependencies
     deps_f = []
-    recursive_dependencies = deps.map do |dep|
+    recursive_dependencies = deps.filter_map do |dep|
       deps_f << dep.to_formula
       dep
     rescue TapFormulaUnavailableError
       # Don't complain about missing cross-tap dependencies
       next
-    end.compact.uniq
+    end.uniq
     deps_f.compact.each do |f|
       f.recursive_dependencies.each do |dep|
         recursive_dependencies << dep unless recursive_dependencies.include?(dep)
@@ -235,36 +288,44 @@ def add_dep_option(dep)
 class HeadSoftwareSpec < SoftwareSpec
   def initialize(flags: [])
     super
-    @resource.version = Version.create("HEAD")
+    @resource.version(Version.new("HEAD"))
   end
 
-  def verify_download_integrity(_fn)
+  def verify_download_integrity(_filename)
     # no-op
   end
 end
 
 class Bottle
-  class Filename
-    extend T::Sig
+  include Downloadable
 
+  class Filename
     attr_reader :name, :version, :tag, :rebuild
 
+    sig { params(formula: Formula, tag: Utils::Bottles::Tag, rebuild: Integer).returns(T.attached_class) }
     def self.create(formula, tag, rebuild)
       new(formula.name, formula.pkg_version, tag, rebuild)
     end
 
+    sig { params(name: String, version: PkgVersion, tag: Utils::Bottles::Tag, rebuild: Integer).void }
     def initialize(name, version, tag, rebuild)
       @name = File.basename name
+
+      raise ArgumentError, "Invalid bottle name" unless Utils.safe_filename?(@name)
+      raise ArgumentError, "Invalid bottle version" unless Utils.safe_filename?(version.to_s)
+
       @version = version
       @tag = tag.to_s
       @rebuild = rebuild
     end
 
     sig { returns(String) }
-    def to_s
+    def to_str
       "#{name}--#{version}#{extname}"
     end
-    alias to_str to_s
+
+    sig { returns(String) }
+    def to_s = to_str
 
     sig { returns(String) }
     def json
@@ -288,15 +349,16 @@ def extname
 
   extend Forwardable
 
-  attr_reader :name, :resource, :cellar, :rebuild
+  attr_reader :name, :resource, :tag, :cellar, :rebuild
 
   def_delegators :resource, :url, :verify_download_integrity
-  def_delegators :resource, :cached_download
+  def_delegators :resource, :cached_download, :downloader
 
   def initialize(formula, spec, tag = nil)
+    super()
+
     @name = formula.name
     @resource = Resource.new
-    @resource.specs[:bottle] = true
     @resource.owner = formula
     @spec = spec
 
@@ -306,7 +368,7 @@ def initialize(formula, spec, tag = nil)
     @cellar = tag_spec.cellar
     @rebuild = spec.rebuild
 
-    @resource.version = formula.pkg_version
+    @resource.version(formula.pkg_version.to_s)
     @resource.checksum = tag_spec.checksum
 
     @fetch_tab_retried = false
@@ -314,8 +376,15 @@ def initialize(formula, spec, tag = nil)
     root_url(spec.root_url, spec.root_url_specs)
   end
 
-  def fetch(verify_download_integrity: true)
-    @resource.fetch(verify_download_integrity: verify_download_integrity)
+  sig {
+    override.params(
+      verify_download_integrity: T::Boolean,
+      timeout:                   T.nilable(T.any(Integer, Float)),
+      quiet:                     T.nilable(T::Boolean),
+    ).returns(Pathname)
+  }
+  def fetch(verify_download_integrity: true, timeout: nil, quiet: false)
+    resource.fetch(verify_download_integrity:, timeout:, quiet:)
   rescue DownloadError
     raise unless fallback_on_error
 
@@ -323,6 +392,7 @@ def fetch(verify_download_integrity: true)
     retry
   end
 
+  sig { override.void }
   def clear_cache
     @resource.clear_cache
     github_packages_manifest_resource&.clear_cache
@@ -338,98 +408,83 @@ def skip_relocation?
     @spec.skip_relocation?(tag: @tag)
   end
 
-  def stage
-    resource.downloader.stage
-  end
-
-  def fetch_tab
-    return if github_packages_manifest_resource.blank?
+  def stage = downloader.stage
 
-    # a checksum is used later identifying the correct tab but we do not have the checksum for the manifest/tab
-    github_packages_manifest_resource.fetch(verify_download_integrity: false)
+  def fetch_tab(timeout: nil, quiet: false)
+    return unless (resource = github_packages_manifest_resource)
 
     begin
-      github_packages_manifest_resource_tab(github_packages_manifest_resource)
-    rescue RuntimeError => e
-      raise DownloadError.new(github_packages_manifest_resource, e)
-    end
-  rescue DownloadError
-    raise unless fallback_on_error
+      resource.fetch(timeout:, quiet:)
+    rescue DownloadError
+      raise unless fallback_on_error
 
-    retry
-  rescue ArgumentError
-    raise if @fetch_tab_retried
+      retry
+    rescue Resource::BottleManifest::Error
+      raise if @fetch_tab_retried
 
-    @fetch_tab_retried = true
-    github_packages_manifest_resource.clear_cache
-    retry
+      @fetch_tab_retried = true
+      resource.clear_cache
+      retry
+    end
   end
 
   def tab_attributes
-    return {} unless github_packages_manifest_resource&.downloaded?
-
-    github_packages_manifest_resource_tab(github_packages_manifest_resource)
-  end
-
-  private
-
-  def github_packages_manifest_resource_tab(github_packages_manifest_resource)
-    manifest_json = github_packages_manifest_resource.cached_download.read
-
-    json = begin
-      JSON.parse(manifest_json)
-    rescue JSON::ParserError
-      raise "The downloaded GitHub Packages manifest was corrupted or modified (it is not valid JSON): " \
-            "\n#{github_packages_manifest_resource.cached_download}"
+    if (resource = github_packages_manifest_resource) && resource.downloaded?
+      return resource.tab
     end
 
-    manifests = json["manifests"]
-    raise ArgumentError, "Missing 'manifests' section." if manifests.blank?
+    {}
+  end
 
-    manifests_annotations = manifests.map { |m| m["annotations"] }.compact
-    raise ArgumentError, "Missing 'annotations' section." if manifests_annotations.blank?
+  sig { returns(T.nilable(Integer)) }
+  def bottle_size
+    resource = github_packages_manifest_resource
+    return unless resource&.downloaded?
 
-    bottle_digest = @resource.checksum.hexdigest
-    image_ref = GitHubPackages.version_rebuild(@resource.version, rebuild, @tag.to_s)
-    manifest_annotations = manifests_annotations.find do |m|
-      next if m["sh.brew.bottle.digest"] != bottle_digest
+    resource.bottle_size
+  end
 
-      m["org.opencontainers.image.ref.name"] == image_ref
-    end
-    raise ArgumentError, "Couldn't find manifest matching bottle checksum." if manifest_annotations.blank?
+  sig { returns(T.nilable(Integer)) }
+  def installed_size
+    resource = github_packages_manifest_resource
+    return unless resource&.downloaded?
 
-    tab = manifest_annotations["sh.brew.tab"]
-    raise ArgumentError, "Couldn't find tab from manifest." if tab.blank?
+    resource.installed_size
+  end
 
-    begin
-      JSON.parse(tab)
-    rescue JSON::ParserError
-      raise ArgumentError, "Couldn't parse tab JSON."
-    end
+  sig { returns(Filename) }
+  def filename
+    Filename.create(resource.owner, @tag, @spec.rebuild)
   end
 
+  sig { returns(T.nilable(Resource::BottleManifest)) }
   def github_packages_manifest_resource
     return if @resource.download_strategy != CurlGitHubPackagesDownloadStrategy
 
     @github_packages_manifest_resource ||= begin
-      resource = Resource.new("#{name}_bottle_manifest")
+      resource = Resource::BottleManifest.new(self)
 
       version_rebuild = GitHubPackages.version_rebuild(@resource.version, rebuild)
       resource.version(version_rebuild)
 
       image_name = GitHubPackages.image_formula_name(@name)
       image_tag = GitHubPackages.image_version_rebuild(version_rebuild)
-      resource.url("#{root_url}/#{image_name}/manifests/#{image_tag}", {
+      resource.url(
+        "#{root_url}/#{image_name}/manifests/#{image_tag}",
         using:   CurlGitHubPackagesDownloadStrategy,
         headers: ["Accept: application/vnd.oci.image.index.v1+json"],
-      })
-      resource.downloader.resolved_basename = "#{name}-#{version_rebuild}.bottle_manifest.json"
+      )
+      T.cast(resource.downloader, CurlGitHubPackagesDownloadStrategy).resolved_basename =
+        "#{name}-#{version_rebuild}.bottle_manifest.json"
       resource
     end
   end
 
+  private
+
   def select_download_strategy(specs)
     specs[:using] ||= DownloadStrategyDetector.detect(@root_url)
+    specs[:bottle] = true
     specs
   end
 
@@ -453,16 +508,15 @@ def root_url(val = nil, specs = {})
 
     filename = Filename.create(resource.owner, @tag, @spec.rebuild)
     path, resolved_basename = Utils::Bottles.path_resolved_basename(val, name, resource.checksum, filename)
-    @resource.url("#{val}/#{path}", select_download_strategy(specs))
+    @resource.url("#{val}/#{path}", **select_download_strategy(specs))
     @resource.downloader.resolved_basename = resolved_basename if resolved_basename.present?
   end
 end
 
 class BottleSpecification
+  extend Attrable
   RELOCATABLE_CELLARS = [:any, :any_skip_relocation].freeze
 
-  extend T::Sig
-
   attr_rw :rebuild
   attr_accessor :tap
   attr_reader :collector, :root_url_specs, :repository
@@ -492,6 +546,12 @@ def root_url(var = nil, specs = {})
     end
   end
 
+  def ==(other)
+    self.class == other.class && rebuild == other.rebuild && collector == other.collector &&
+      root_url == other.root_url && root_url_specs == other.root_url_specs && tap == other.tap
+  end
+  alias eql? ==
+
   sig { params(tag: Utils::Bottles::Tag).returns(T.any(Symbol, String)) }
   def tag_to_cellar(tag = Utils::Bottles.tag)
     spec = collector.specification_for(tag)
@@ -508,7 +568,7 @@ def compatible_locations?(tag: Utils::Bottles.tag)
 
     return true if RELOCATABLE_CELLARS.include?(cellar)
 
-    prefix = Pathname(cellar).parent.to_s
+    prefix = Pathname(cellar.to_s).parent.to_s
 
     cellar_relocatable = cellar.size >= HOMEBREW_CELLAR.to_s.size && ENV["HOMEBREW_RELOCATE_BUILD_PREFIX"].present?
     prefix_relocatable = prefix.size >= HOMEBREW_PREFIX.to_s.size && ENV["HOMEBREW_RELOCATE_BUILD_PREFIX"].present?
@@ -528,7 +588,7 @@ def skip_relocation?(tag: Utils::Bottles.tag)
 
   sig { params(tag: T.any(Symbol, Utils::Bottles::Tag), no_older_versions: T::Boolean).returns(T::Boolean) }
   def tag?(tag, no_older_versions: false)
-    collector.tag?(tag, no_older_versions: no_older_versions)
+    collector.tag?(tag, no_older_versions:)
   end
 
   # Checksum methods in the DSL's bottle block take
@@ -552,7 +612,7 @@ def sha256(hash)
 
     cellar ||= tag.default_cellar
 
-    collector.add(tag, checksum: Checksum.new(digest), cellar: cellar)
+    collector.add(tag, checksum: Checksum.new(digest), cellar:)
   end
 
   sig {
@@ -560,17 +620,17 @@ def sha256(hash)
       .returns(T.nilable(Utils::Bottles::TagSpecification))
   }
   def tag_specification_for(tag, no_older_versions: false)
-    collector.specification_for(tag, no_older_versions: no_older_versions)
+    collector.specification_for(tag, no_older_versions:)
   end
 
   def checksums
     tags = collector.tags.sort_by do |tag|
       version = tag.to_macos_version
-      # Give arm64 bottles a higher priority so they are first
-      priority = tag.arch == :arm64 ? "2" : "1"
+      # Give `arm64` bottles a higher priority so they are first.
+      priority = (tag.arch == :arm64) ? 2 : 1
       "#{priority}.#{version}_#{tag}"
-    rescue MacOSVersionError
-      # Sort non-MacOS tags below MacOS tags.
+    rescue MacOSVersion::Error
+      # Sort non-macOS tags below macOS tags.
       "0.#{tag}"
     end
     tags.reverse.map do |tag|
diff --git a/Library/Homebrew/sorbet/config b/Library/Homebrew/sorbet/config
index 02fbf5ab02d69..a55c8dfed4c73 100644
--- a/Library/Homebrew/sorbet/config
+++ b/Library/Homebrew/sorbet/config
@@ -1,8 +1,9 @@
---dir
-.
-
---ignore
-/vendor
-
---ignore
-/test/.gem
+--dir=.
+--enable-experimental-requires-ancestor
+--ignore=/vendor/bundle
+--ignore=/vendor/gems
+--ignore=/vendor/portable-ruby
+--ignore=/test/.gem
+--ignore=Formula
+--ignore=Casks
+--suppress-error-code=7019
diff --git a/Library/Homebrew/sorbet/parlour.rb b/Library/Homebrew/sorbet/parlour.rb
deleted file mode 100644
index 102df8981968e..0000000000000
--- a/Library/Homebrew/sorbet/parlour.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require_relative "../warnings"
-Warnings.ignore :parser_syntax do
-  require "parser/current"
-end
-
-module Homebrew
-  # Parlour type signature generator helper class for Homebrew.
-  module Parlour
-    extend T::Sig
-
-    ROOT_DIR = T.let(Pathname(__dir__).parent.realpath.freeze, Pathname).freeze
-
-    sig { returns(T::Array[Parser::AST::Node]) }
-    def self.ast_list
-      @ast_list ||= begin
-        ast_list = []
-        parser = Parser::CurrentRuby.new
-        prune_dirs = %w[sorbet shims test vendor].freeze
-
-        ROOT_DIR.find do |path|
-          Find.prune if path.directory? && prune_dirs.any? { |subdir| path == ROOT_DIR/subdir }
-
-          Find.prune if path.file? && path.extname != ".rb"
-
-          next unless path.file?
-
-          buffer = Parser::Source::Buffer.new(path, source: path.read)
-
-          parser.reset
-          ast = parser.parse(buffer)
-          ast_list << ast if ast
-        end
-
-        ast_list
-      end
-    end
-  end
-end
-
-require "parlour"
-require_relative "parlour/attr"
diff --git a/Library/Homebrew/sorbet/parlour/attr.rb b/Library/Homebrew/sorbet/parlour/attr.rb
deleted file mode 100644
index 8737806de89b6..0000000000000
--- a/Library/Homebrew/sorbet/parlour/attr.rb
+++ /dev/null
@@ -1,115 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-# Parlour type signature generator plugin for Homebrew DSL attributes.
-class Attr < Parlour::Plugin
-  sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
-  def generate(root)
-    tree = T.let([], T::Array[T.untyped])
-    Homebrew::Parlour.ast_list.each do |node|
-      tree += find_custom_attr(node)
-    end
-    process_custom_attr(tree, root)
-  end
-
-  sig { override.returns(T.nilable(String)) }
-  def strictness
-    "strict"
-  end
-
-  private
-
-  sig { params(node: Parser::AST::Node, list: T::Array[String]).returns(T::Array[String]) }
-  def traverse_module_name(node, list = [])
-    parent, name = node.children
-    list = traverse_module_name(parent, list) if parent
-    list << name.to_s
-    list
-  end
-
-  sig { params(node: T.nilable(Parser::AST::Node)).returns(T.nilable(String)) }
-  def extract_module_name(node)
-    return if node.nil?
-
-    traverse_module_name(node).join("::")
-  end
-
-  sig { params(node: Parser::AST::Node).returns(T::Array[T.untyped]) }
-  def find_custom_attr(node)
-    tree = T.let([], T::Array[T.untyped])
-    children = node.children.dup
-
-    if node.type == :begin
-      children.each do |child|
-        subtree = find_custom_attr(child)
-        tree += subtree unless subtree.empty?
-      end
-    elsif node.type == :sclass
-      subtree = find_custom_attr(node.children[1])
-      return tree if subtree.empty?
-
-      tree << [:sclass, subtree]
-    elsif node.type == :class || node.type == :module
-      element = []
-      case node.type
-      when :class
-        element << :class
-        element << extract_module_name(children.shift)
-        element << extract_module_name(children.shift)
-      when :module
-        element << :module
-        element << extract_module_name(children.shift)
-      end
-
-      body = children.shift
-      return tree if body.nil?
-
-      subtree = find_custom_attr(body)
-      return tree if subtree.empty?
-
-      element << subtree
-      tree << element
-    elsif node.type == :send && children.shift.nil?
-      method_name = children.shift
-      if [:attr_rw, :attr_predicate].include?(method_name)
-        children.each do |name_node|
-          tree << [method_name, name_node.children.first.to_s]
-        end
-      end
-    end
-
-    tree
-  end
-
-  sig { params(tree: T::Array[T.untyped], namespace: Parlour::RbiGenerator::Namespace, sclass: T::Boolean).void }
-  def process_custom_attr(tree, namespace, sclass: false)
-    tree.each do |node|
-      type = node.shift
-      case type
-      when :sclass
-        process_custom_attr(node.shift, namespace, sclass: true)
-      when :class
-        class_namespace = namespace.create_class(node.shift, superclass: node.shift)
-        process_custom_attr(node.shift, class_namespace)
-      when :module
-        module_namespace = namespace.create_module(node.shift)
-        process_custom_attr(node.shift, module_namespace)
-      when :attr_rw
-        name = node.shift
-        name = "self.#{name}" if sclass
-        namespace.create_method(name,
-                                parameters:  [
-                                  Parlour::RbiGenerator::Parameter.new("arg", type:    "T.untyped",
-                                                                              default: "T.unsafe(nil)"),
-                                ],
-                                return_type: "T.untyped")
-      when :attr_predicate
-        name = node.shift
-        name = "self.#{name}" if sclass
-        namespace.create_method(name, return_type: "T::Boolean")
-      else
-        raise "Malformed tree."
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/.gitattributes b/Library/Homebrew/sorbet/rbi/dsl/.gitattributes
new file mode 100644
index 0000000000000..d9bb82a4de2cf
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/.gitattributes
@@ -0,0 +1 @@
+**/*.rbi linguist-generated=true
diff --git a/Library/Homebrew/sorbet/rbi/dsl/arch_requirement.rbi b/Library/Homebrew/sorbet/rbi/dsl/arch_requirement.rbi
new file mode 100644
index 0000000000000..5de043433f898
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/arch_requirement.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `ArchRequirement`.
+# Please instead update this file by running `bin/tapioca dsl ArchRequirement`.
+
+
+class ArchRequirement; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/bottle.rbi b/Library/Homebrew/sorbet/rbi/dsl/bottle.rbi
new file mode 100644
index 0000000000000..89b7235fc3b09
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/bottle.rbi
@@ -0,0 +1,20 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Bottle`.
+# Please instead update this file by running `bin/tapioca dsl Bottle`.
+
+
+class Bottle
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def cached_download(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def downloader(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def url(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def verify_download_integrity(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/bottle_specification.rbi b/Library/Homebrew/sorbet/rbi/dsl/bottle_specification.rbi
new file mode 100644
index 0000000000000..d076578f16f35
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/bottle_specification.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `BottleSpecification`.
+# Please instead update this file by running `bin/tapioca dsl BottleSpecification`.
+
+
+class BottleSpecification
+  sig { params(arg: T.untyped).returns(T.untyped) }
+  def rebuild(arg = nil); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/cask/audit.rbi b/Library/Homebrew/sorbet/rbi/dsl/cask/audit.rbi
new file mode 100644
index 0000000000000..9f9cb7d83a8ca
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/cask/audit.rbi
@@ -0,0 +1,23 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Cask::Audit`.
+# Please instead update this file by running `bin/tapioca dsl Cask::Audit`.
+
+
+class Cask::Audit
+  sig { returns(T::Boolean) }
+  def new_cask?; end
+
+  sig { returns(T::Boolean) }
+  def online?; end
+
+  sig { returns(T::Boolean) }
+  def signing?; end
+
+  sig { returns(T::Boolean) }
+  def strict?; end
+
+  sig { returns(T::Boolean) }
+  def token_conflicts?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/cask/cask.rbi b/Library/Homebrew/sorbet/rbi/dsl/cask/cask.rbi
new file mode 100644
index 0000000000000..0c1b092222aa9
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/cask/cask.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Cask::Cask`.
+# Please instead update this file by running `bin/tapioca dsl Cask::Cask`.
+
+
+class Cask::Cask
+  sig { returns(T::Boolean) }
+  def loaded_from_api?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/cask/dsl.rbi b/Library/Homebrew/sorbet/rbi/dsl/cask/dsl.rbi
new file mode 100644
index 0000000000000..ecc5e8731a629
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/cask/dsl.rbi
@@ -0,0 +1,23 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Cask::DSL`.
+# Please instead update this file by running `bin/tapioca dsl Cask::DSL`.
+
+
+class Cask::DSL
+  sig { returns(T::Boolean) }
+  def depends_on_set_in_block?; end
+
+  sig { returns(T::Boolean) }
+  def deprecated?; end
+
+  sig { returns(T::Boolean) }
+  def disabled?; end
+
+  sig { returns(T::Boolean) }
+  def livecheckable?; end
+
+  sig { returns(T::Boolean) }
+  def on_system_blocks_exist?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/base.rbi b/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/base.rbi
new file mode 100644
index 0000000000000..87efd856f10c3
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/base.rbi
@@ -0,0 +1,29 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Cask::DSL::Base`.
+# Please instead update this file by running `bin/tapioca dsl Cask::DSL::Base`.
+
+
+class Cask::DSL::Base
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def appdir(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def arch(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def caskroom_path(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def language(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def staged_path(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def token(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def version(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/caveats.rbi b/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/caveats.rbi
new file mode 100644
index 0000000000000..8a9839ac27d54
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/caveats.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Cask::DSL::Caveats`.
+# Please instead update this file by running `bin/tapioca dsl Cask::DSL::Caveats`.
+
+
+class Cask::DSL::Caveats
+  sig { returns(T::Boolean) }
+  def discontinued?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/postflight.rbi b/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/postflight.rbi
new file mode 100644
index 0000000000000..5de4699c10eff
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/postflight.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Cask::DSL::Postflight`.
+# Please instead update this file by running `bin/tapioca dsl Cask::DSL::Postflight`.
+
+
+class Cask::DSL::Postflight; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/preflight.rbi b/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/preflight.rbi
new file mode 100644
index 0000000000000..ef713a5dfaa55
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/preflight.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Cask::DSL::Preflight`.
+# Please instead update this file by running `bin/tapioca dsl Cask::DSL::Preflight`.
+
+
+class Cask::DSL::Preflight; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/uninstall_postflight.rbi b/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/uninstall_postflight.rbi
new file mode 100644
index 0000000000000..45115cd0982c0
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/uninstall_postflight.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Cask::DSL::UninstallPostflight`.
+# Please instead update this file by running `bin/tapioca dsl Cask::DSL::UninstallPostflight`.
+
+
+class Cask::DSL::UninstallPostflight; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/uninstall_preflight.rbi b/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/uninstall_preflight.rbi
new file mode 100644
index 0000000000000..55f2f51cc9e42
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/cask/dsl/uninstall_preflight.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Cask::DSL::UninstallPreflight`.
+# Please instead update this file by running `bin/tapioca dsl Cask::DSL::UninstallPreflight`.
+
+
+class Cask::DSL::UninstallPreflight; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/cask/installer.rbi b/Library/Homebrew/sorbet/rbi/dsl/cask/installer.rbi
new file mode 100644
index 0000000000000..6fafb9717974c
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/cask/installer.rbi
@@ -0,0 +1,47 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Cask::Installer`.
+# Please instead update this file by running `bin/tapioca dsl Cask::Installer`.
+
+
+class Cask::Installer
+  sig { returns(T::Boolean) }
+  def adopt?; end
+
+  sig { returns(T::Boolean) }
+  def binaries?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def installed_as_dependency?; end
+
+  sig { returns(T::Boolean) }
+  def installed_on_request?; end
+
+  sig { returns(T::Boolean) }
+  def quarantine?; end
+
+  sig { returns(T::Boolean) }
+  def quiet?; end
+
+  sig { returns(T::Boolean) }
+  def reinstall?; end
+
+  sig { returns(T::Boolean) }
+  def require_sha?; end
+
+  sig { returns(T::Boolean) }
+  def skip_cask_deps?; end
+
+  sig { returns(T::Boolean) }
+  def upgrade?; end
+
+  sig { returns(T::Boolean) }
+  def verbose?; end
+
+  sig { returns(T::Boolean) }
+  def zap?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/cask/url.rbi b/Library/Homebrew/sorbet/rbi/dsl/cask/url.rbi
new file mode 100644
index 0000000000000..2cd61a1d6fc0c
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/cask/url.rbi
@@ -0,0 +1,64 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Cask::URL`.
+# Please instead update this file by running `bin/tapioca dsl Cask::URL`.
+
+
+class Cask::URL
+  include Kernel
+
+  sig { returns(T.untyped) }
+  def branch; end
+
+  sig { returns(T.untyped) }
+  def cookies; end
+
+  sig { returns(T.untyped) }
+  def data; end
+
+  sig { returns(T.untyped) }
+  def header; end
+
+  sig { returns(T.untyped) }
+  def only_path; end
+
+  sig { returns(T.untyped) }
+  def path; end
+
+  sig { returns(T.nilable(T.any(::String, ::URI::Generic))) }
+  def referer; end
+
+  sig { returns(T.untyped) }
+  def revision; end
+
+  sig { returns(T.untyped) }
+  def revisions; end
+
+  sig { returns(T.untyped) }
+  def scheme; end
+
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def specs; end
+
+  sig { returns(T.untyped) }
+  def tag; end
+
+  sig { returns(T.untyped) }
+  def to_s; end
+
+  sig { returns(T.untyped) }
+  def trust_cert; end
+
+  sig { returns(T.untyped) }
+  def uri; end
+
+  sig { returns(T.nilable(T.any(::String, ::Symbol))) }
+  def user_agent; end
+
+  sig { returns(T.nilable(T.any(::Symbol, T::Class[T.anything]))) }
+  def using; end
+
+  sig { returns(T.nilable(::String)) }
+  def verified; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/cask/url/dsl.rbi b/Library/Homebrew/sorbet/rbi/dsl/cask/url/dsl.rbi
new file mode 100644
index 0000000000000..4ae15d814f7b0
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/cask/url/dsl.rbi
@@ -0,0 +1,17 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Cask::URL::DSL`.
+# Please instead update this file by running `bin/tapioca dsl Cask::URL::DSL`.
+
+
+class Cask::URL::DSL
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def path(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def scheme(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(String) }
+  def to_s(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/caveats.rbi b/Library/Homebrew/sorbet/rbi/dsl/caveats.rbi
new file mode 100644
index 0000000000000..dbe807aa31a0a
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/caveats.rbi
@@ -0,0 +1,14 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Caveats`.
+# Please instead update this file by running `bin/tapioca dsl Caveats`.
+
+
+class Caveats
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def empty?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(String) }
+  def to_s(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/checksum.rbi b/Library/Homebrew/sorbet/rbi/dsl/checksum.rbi
new file mode 100644
index 0000000000000..8f2fe586755cd
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/checksum.rbi
@@ -0,0 +1,20 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Checksum`.
+# Please instead update this file by running `bin/tapioca dsl Checksum`.
+
+
+class Checksum
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def [](*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def empty?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def length(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(String) }
+  def to_s(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/codesign_requirement.rbi b/Library/Homebrew/sorbet/rbi/dsl/codesign_requirement.rbi
new file mode 100644
index 0000000000000..a15cb3779fe6e
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/codesign_requirement.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `CodesignRequirement`.
+# Please instead update this file by running `bin/tapioca dsl CodesignRequirement`.
+
+
+class CodesignRequirement; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/debrew.rbi b/Library/Homebrew/sorbet/rbi/dsl/debrew.rbi
new file mode 100644
index 0000000000000..89b6cf74129e2
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/debrew.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Debrew`.
+# Please instead update this file by running `bin/tapioca dsl Debrew`.
+
+
+module Debrew
+  class << self
+    sig { returns(T::Boolean) }
+    def active?; end
+  end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/external_patch.rbi b/Library/Homebrew/sorbet/rbi/dsl/external_patch.rbi
new file mode 100644
index 0000000000000..d60c0560a03f3
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/external_patch.rbi
@@ -0,0 +1,29 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `ExternalPatch`.
+# Please instead update this file by running `bin/tapioca dsl ExternalPatch`.
+
+
+class ExternalPatch
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def cached_download(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def clear_cache(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def downloaded?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def fetch(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def patch_files(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def url(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def verify_download_integrity(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/formula.rbi b/Library/Homebrew/sorbet/rbi/dsl/formula.rbi
new file mode 100644
index 0000000000000..06810994c33f3
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/formula.rbi
@@ -0,0 +1,154 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Formula`.
+# Please instead update this file by running `bin/tapioca dsl Formula`.
+
+
+class Formula
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def allow_network_access!(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def bottle_defined?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def bottle_specification(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def bottle_tag?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def bottled?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def cached_download(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def clear_cache(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def compiler_failures(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def declared_deps(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def deny_network_access!(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def deprecated?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def deprecated_flags(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def deprecated_options(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def deprecation_date(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def deprecation_reason(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def deps(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def desc(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def disable_date(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def disable_reason(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def disabled?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def downloader(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def env(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def homepage(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def keg_only_reason(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def license(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def livecheck(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def livecheckable?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def loaded_from_api?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def network_access_allowed?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def option_defined?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def options(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def patchlist(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def pin(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def pinnable?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def pinned?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def pinned_version(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def pour_bottle_check_unsatisfied_reason(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def requirements(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def resources(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def service?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def unpin(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def version(*args, &block); end
+
+  class << self
+    sig { params(arg: T.untyped).returns(T.untyped) }
+    def desc(arg = nil); end
+
+    sig { params(arg: T.untyped).returns(T.untyped) }
+    def homepage(arg = nil); end
+
+    sig { returns(T::Boolean) }
+    def loaded_from_api?; end
+
+    sig { returns(T::Boolean) }
+    def on_system_blocks_exist?; end
+
+    sig { params(arg: T.untyped).returns(T.untyped) }
+    def revision(arg = nil); end
+
+    sig { params(arg: T.untyped).returns(T.untyped) }
+    def version_scheme(arg = nil); end
+  end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/formula_installer.rbi b/Library/Homebrew/sorbet/rbi/dsl/formula_installer.rbi
new file mode 100644
index 0000000000000..e6cdede310cd1
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/formula_installer.rbi
@@ -0,0 +1,56 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `FormulaInstaller`.
+# Please instead update this file by running `bin/tapioca dsl FormulaInstaller`.
+
+
+class FormulaInstaller
+  sig { returns(T::Boolean) }
+  def debug?; end
+
+  sig { returns(T::Boolean) }
+  def debug_symbols?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def force_bottle?; end
+
+  sig { returns(T::Boolean) }
+  def git?; end
+
+  sig { returns(T::Boolean) }
+  def ignore_deps?; end
+
+  sig { returns(T::Boolean) }
+  def installed_as_dependency?; end
+
+  sig { returns(T::Boolean) }
+  def installed_on_request?; end
+
+  sig { returns(T::Boolean) }
+  def interactive?; end
+
+  sig { returns(T::Boolean) }
+  def keep_tmp?; end
+
+  sig { returns(T::Boolean) }
+  def only_deps?; end
+
+  sig { returns(T::Boolean) }
+  def overwrite?; end
+
+  sig { returns(T::Boolean) }
+  def quiet?; end
+
+  sig { returns(T::Boolean) }
+  def show_header?; end
+
+  sig { returns(T::Boolean) }
+  def show_summary_heading?; end
+
+  sig { returns(T::Boolean) }
+  def verbose?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/head_software_spec.rbi b/Library/Homebrew/sorbet/rbi/dsl/head_software_spec.rbi
new file mode 100644
index 0000000000000..e539f5f1f31d1
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/head_software_spec.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `HeadSoftwareSpec`.
+# Please instead update this file by running `bin/tapioca dsl HeadSoftwareSpec`.
+
+
+class HeadSoftwareSpec; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cleanup.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cleanup.rbi
new file mode 100644
index 0000000000000..852b2b5cc732b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cleanup.rbi
@@ -0,0 +1,17 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cleanup`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cleanup`.
+
+
+class Homebrew::Cleanup
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T::Boolean) }
+  def prune?; end
+
+  sig { returns(T::Boolean) }
+  def scrub?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/analytics.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/analytics.rbi
new file mode 100644
index 0000000000000..535219222ca45
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/analytics.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Analytics`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Analytics`.
+
+
+class Homebrew::Cmd::Analytics
+  sig { returns(Homebrew::Cmd::Analytics::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Analytics::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/autoremove.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/autoremove.rbi
new file mode 100644
index 0000000000000..97fbdecb18d82
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/autoremove.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Autoremove`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Autoremove`.
+
+
+class Homebrew::Cmd::Autoremove
+  sig { returns(Homebrew::Cmd::Autoremove::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Autoremove::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/cache.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/cache.rbi
new file mode 100644
index 0000000000000..29a25e7ce9d99
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/cache.rbi
@@ -0,0 +1,46 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Cache`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Cache`.
+
+
+class Homebrew::Cmd::Cache
+  sig { returns(Homebrew::Cmd::Cache::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Cache::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def HEAD?; end
+
+  sig { returns(T.nilable(String)) }
+  def arch; end
+
+  sig { returns(T.nilable(String)) }
+  def bottle_tag; end
+
+  sig { returns(T::Boolean) }
+  def build_from_source?; end
+
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def force_bottle?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T.nilable(String)) }
+  def os; end
+
+  sig { returns(T::Boolean) }
+  def s?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/caskroom.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/caskroom.rbi
new file mode 100644
index 0000000000000..3c5a182c8cf79
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/caskroom.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Caskroom`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Caskroom`.
+
+
+class Homebrew::Cmd::Caskroom
+  sig { returns(Homebrew::Cmd::Caskroom::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Caskroom::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/casks.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/casks.rbi
new file mode 100644
index 0000000000000..017195881e450
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/casks.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Casks`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Casks`.
+
+
+class Homebrew::Cmd::Casks
+  sig { returns(Homebrew::Cmd::Casks::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Casks::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/cellar.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/cellar.rbi
new file mode 100644
index 0000000000000..f3ab794f4e617
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/cellar.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Cellar`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Cellar`.
+
+
+class Homebrew::Cmd::Cellar
+  sig { returns(Homebrew::Cmd::Cellar::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Cellar::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/cleanup_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/cleanup_cmd.rbi
new file mode 100644
index 0000000000000..6a4ef24dfaf98
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/cleanup_cmd.rbi
@@ -0,0 +1,31 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::CleanupCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::CleanupCmd`.
+
+
+class Homebrew::Cmd::CleanupCmd
+  sig { returns(Homebrew::Cmd::CleanupCmd::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::CleanupCmd::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+
+  sig { returns(T.nilable(String)) }
+  def prune; end
+
+  sig { returns(T::Boolean) }
+  def prune_prefix?; end
+
+  sig { returns(T::Boolean) }
+  def s?; end
+
+  sig { returns(T::Boolean) }
+  def scrub?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/command.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/command.rbi
new file mode 100644
index 0000000000000..c6f7c66aeccb6
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/command.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Command`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Command`.
+
+
+class Homebrew::Cmd::Command
+  sig { returns(Homebrew::Cmd::Command::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Command::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/commands_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/commands_cmd.rbi
new file mode 100644
index 0000000000000..6495cb3433f6a
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/commands_cmd.rbi
@@ -0,0 +1,16 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::CommandsCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::CommandsCmd`.
+
+
+class Homebrew::Cmd::CommandsCmd
+  sig { returns(Homebrew::Cmd::CommandsCmd::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::CommandsCmd::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def include_aliases?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/completions_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/completions_cmd.rbi
new file mode 100644
index 0000000000000..e4ea71f451c28
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/completions_cmd.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::CompletionsCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::CompletionsCmd`.
+
+
+class Homebrew::Cmd::CompletionsCmd
+  sig { returns(Homebrew::Cmd::CompletionsCmd::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::CompletionsCmd::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/config.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/config.rbi
new file mode 100644
index 0000000000000..a2545b2b79ce8
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/config.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Config`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Config`.
+
+
+class Homebrew::Cmd::Config
+  sig { returns(Homebrew::Cmd::Config::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Config::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/deps.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/deps.rbi
new file mode 100644
index 0000000000000..bb861fb4943db
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/deps.rbi
@@ -0,0 +1,91 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Deps`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Deps`.
+
+
+class Homebrew::Cmd::Deps
+  sig { returns(Homebrew::Cmd::Deps::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Deps::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def HEAD?; end
+
+  sig { returns(T::Boolean) }
+  def annotate?; end
+
+  sig { returns(T.nilable(String)) }
+  def arch; end
+
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def declared?; end
+
+  sig { returns(T::Boolean) }
+  def direct?; end
+
+  sig { returns(T::Boolean) }
+  def dot?; end
+
+  sig { returns(T::Boolean) }
+  def eval_all?; end
+
+  sig { returns(T::Boolean) }
+  def for_each?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def full_name?; end
+
+  sig { returns(T::Boolean) }
+  def graph?; end
+
+  sig { returns(T::Boolean) }
+  def include_build?; end
+
+  sig { returns(T::Boolean) }
+  def include_optional?; end
+
+  sig { returns(T::Boolean) }
+  def include_requirements?; end
+
+  sig { returns(T::Boolean) }
+  def include_test?; end
+
+  sig { returns(T::Boolean) }
+  def installed?; end
+
+  sig { returns(T::Boolean) }
+  def missing?; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+
+  sig { returns(T.nilable(String)) }
+  def os; end
+
+  sig { returns(T::Boolean) }
+  def skip_recommended?; end
+
+  sig { returns(T::Boolean) }
+  def topological?; end
+
+  sig { returns(T::Boolean) }
+  def tree?; end
+
+  sig { returns(T::Boolean) }
+  def union?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/desc.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/desc.rbi
new file mode 100644
index 0000000000000..e2e5891c0d206
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/desc.rbi
@@ -0,0 +1,43 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Desc`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Desc`.
+
+
+class Homebrew::Cmd::Desc
+  sig { returns(Homebrew::Cmd::Desc::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Desc::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def description?; end
+
+  sig { returns(T::Boolean) }
+  def eval_all?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+
+  sig { returns(T::Boolean) }
+  def name?; end
+
+  sig { returns(T::Boolean) }
+  def s?; end
+
+  sig { returns(T::Boolean) }
+  def search?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/developer.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/developer.rbi
new file mode 100644
index 0000000000000..260ccdbc5f90d
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/developer.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Developer`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Developer`.
+
+
+class Homebrew::Cmd::Developer
+  sig { returns(Homebrew::Cmd::Developer::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Developer::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/docs.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/docs.rbi
new file mode 100644
index 0000000000000..78d78c0ac8cee
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/docs.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Docs`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Docs`.
+
+
+class Homebrew::Cmd::Docs
+  sig { returns(Homebrew::Cmd::Docs::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Docs::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/doctor.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/doctor.rbi
new file mode 100644
index 0000000000000..76369fc38b7b2
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/doctor.rbi
@@ -0,0 +1,22 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Doctor`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Doctor`.
+
+
+class Homebrew::Cmd::Doctor
+  sig { returns(Homebrew::Cmd::Doctor::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Doctor::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def D?; end
+
+  sig { returns(T::Boolean) }
+  def audit_debug?; end
+
+  sig { returns(T::Boolean) }
+  def list_checks?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/env.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/env.rbi
new file mode 100644
index 0000000000000..3c31a31aff852
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/env.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Env`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Env`.
+
+
+class Homebrew::Cmd::Env
+  sig { returns(Homebrew::Cmd::Env::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Env::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def plain?; end
+
+  sig { returns(T.nilable(String)) }
+  def shell; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/fetch_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/fetch_cmd.rbi
new file mode 100644
index 0000000000000..b90b857ce7bbf
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/fetch_cmd.rbi
@@ -0,0 +1,67 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::FetchCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::FetchCmd`.
+
+
+class Homebrew::Cmd::FetchCmd
+  sig { returns(Homebrew::Cmd::FetchCmd::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::FetchCmd::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def HEAD?; end
+
+  sig { returns(T.nilable(String)) }
+  def arch; end
+
+  sig { returns(T.nilable(String)) }
+  def bottle_tag; end
+
+  sig { returns(T::Boolean) }
+  def build_bottle?; end
+
+  sig { returns(T::Boolean) }
+  def build_from_source?; end
+
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T.nilable(String)) }
+  def concurrency; end
+
+  sig { returns(T::Boolean) }
+  def deps?; end
+
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def force_bottle?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T.nilable(String)) }
+  def os; end
+
+  sig { returns(T::Boolean) }
+  def quarantine?; end
+
+  sig { returns(T::Boolean) }
+  def retry?; end
+
+  sig { returns(T::Boolean) }
+  def s?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/formulae.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/formulae.rbi
new file mode 100644
index 0000000000000..a6ce3fcc772f9
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/formulae.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Formulae`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Formulae`.
+
+
+class Homebrew::Cmd::Formulae
+  sig { returns(Homebrew::Cmd::Formulae::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Formulae::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/gist_logs.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/gist_logs.rbi
new file mode 100644
index 0000000000000..39009bc6e5494
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/gist_logs.rbi
@@ -0,0 +1,28 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::GistLogs`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::GistLogs`.
+
+
+class Homebrew::Cmd::GistLogs
+  sig { returns(Homebrew::Cmd::GistLogs::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::GistLogs::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def n?; end
+
+  sig { returns(T::Boolean) }
+  def new_issue?; end
+
+  sig { returns(T::Boolean) }
+  def p?; end
+
+  sig { returns(T::Boolean) }
+  def private?; end
+
+  sig { returns(T::Boolean) }
+  def with_hostname?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/help_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/help_cmd.rbi
new file mode 100644
index 0000000000000..1eb149197a86b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/help_cmd.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::HelpCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::HelpCmd`.
+
+
+class Homebrew::Cmd::HelpCmd
+  sig { returns(Homebrew::Cmd::HelpCmd::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::HelpCmd::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/home.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/home.rbi
new file mode 100644
index 0000000000000..5d86d875f247c
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/home.rbi
@@ -0,0 +1,25 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Home`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Home`.
+
+
+class Homebrew::Cmd::Home
+  sig { returns(Homebrew::Cmd::Home::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Home::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/info.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/info.rbi
new file mode 100644
index 0000000000000..db897357c803c
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/info.rbi
@@ -0,0 +1,55 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Info`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Info`.
+
+
+class Homebrew::Cmd::Info
+  sig { returns(Homebrew::Cmd::Info::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Info::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def analytics?; end
+
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T.nilable(String)) }
+  def category; end
+
+  sig { returns(T.nilable(String)) }
+  def days; end
+
+  sig { returns(T::Boolean) }
+  def eval_all?; end
+
+  sig { returns(T::Boolean) }
+  def fetch_manifest?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def github?; end
+
+  sig { returns(T::Boolean) }
+  def github_packages_downloads?; end
+
+  sig { returns(T::Boolean) }
+  def installed?; end
+
+  sig { returns(T.nilable(String)) }
+  def json; end
+
+  sig { returns(T::Boolean) }
+  def variations?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/install_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/install_cmd.rbi
new file mode 100644
index 0000000000000..e83974293fef1
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/install_cmd.rbi
@@ -0,0 +1,166 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::InstallCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::InstallCmd`.
+
+
+class Homebrew::Cmd::InstallCmd
+  sig { returns(Homebrew::Cmd::InstallCmd::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::InstallCmd::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def HEAD?; end
+
+  sig { returns(T::Boolean) }
+  def adopt?; end
+
+  sig { returns(T.nilable(String)) }
+  def appdir; end
+
+  sig { returns(T.nilable(String)) }
+  def audio_unit_plugindir; end
+
+  sig { returns(T::Boolean) }
+  def binaries?; end
+
+  sig { returns(T.nilable(String)) }
+  def bottle_arch; end
+
+  sig { returns(T::Boolean) }
+  def build_bottle?; end
+
+  sig { returns(T::Boolean) }
+  def build_from_source?; end
+
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T.nilable(String)) }
+  def cc; end
+
+  sig { returns(T.nilable(String)) }
+  def colorpickerdir; end
+
+  sig { returns(T::Boolean) }
+  def debug_symbols?; end
+
+  sig { returns(T.nilable(String)) }
+  def dictionarydir; end
+
+  sig { returns(T::Boolean) }
+  def display_times?; end
+
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T.nilable(String)) }
+  def env; end
+
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T::Boolean) }
+  def fetch_HEAD?; end
+
+  sig { returns(T.nilable(String)) }
+  def fontdir; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def force_bottle?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def g?; end
+
+  sig { returns(T::Boolean) }
+  def git?; end
+
+  sig { returns(T::Boolean) }
+  def i?; end
+
+  sig { returns(T::Boolean) }
+  def ignore_dependencies?; end
+
+  sig { returns(T::Boolean) }
+  def include_test?; end
+
+  sig { returns(T.nilable(String)) }
+  def input_methoddir; end
+
+  sig { returns(T::Boolean) }
+  def interactive?; end
+
+  sig { returns(T.nilable(String)) }
+  def internet_plugindir; end
+
+  sig { returns(T::Boolean) }
+  def keep_tmp?; end
+
+  sig { returns(T.nilable(String)) }
+  def keyboard_layoutdir; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def language; end
+
+  sig { returns(T.nilable(String)) }
+  def mdimporterdir; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+
+  sig { returns(T::Boolean) }
+  def only_dependencies?; end
+
+  sig { returns(T::Boolean) }
+  def overwrite?; end
+
+  sig { returns(T.nilable(String)) }
+  def prefpanedir; end
+
+  sig { returns(T.nilable(String)) }
+  def qlplugindir; end
+
+  sig { returns(T::Boolean) }
+  def quarantine?; end
+
+  sig { returns(T::Boolean) }
+  def require_sha?; end
+
+  sig { returns(T::Boolean) }
+  def s?; end
+
+  sig { returns(T.nilable(String)) }
+  def screen_saverdir; end
+
+  sig { returns(T.nilable(String)) }
+  def servicedir; end
+
+  sig { returns(T::Boolean) }
+  def skip_cask_deps?; end
+
+  sig { returns(T::Boolean) }
+  def skip_post_install?; end
+
+  sig { returns(T.nilable(String)) }
+  def vst3_plugindir; end
+
+  sig { returns(T.nilable(String)) }
+  def vst_plugindir; end
+
+  sig { returns(T::Boolean) }
+  def zap?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/leaves.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/leaves.rbi
new file mode 100644
index 0000000000000..9282af0c83ee2
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/leaves.rbi
@@ -0,0 +1,25 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Leaves`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Leaves`.
+
+
+class Homebrew::Cmd::Leaves
+  sig { returns(Homebrew::Cmd::Leaves::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Leaves::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def installed_as_dependency?; end
+
+  sig { returns(T::Boolean) }
+  def installed_on_request?; end
+
+  sig { returns(T::Boolean) }
+  def p?; end
+
+  sig { returns(T::Boolean) }
+  def r?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/link.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/link.rbi
new file mode 100644
index 0000000000000..43bdbf123b603
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/link.rbi
@@ -0,0 +1,31 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Link`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Link`.
+
+
+class Homebrew::Cmd::Link
+  sig { returns(Homebrew::Cmd::Link::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Link::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def HEAD?; end
+
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+
+  sig { returns(T::Boolean) }
+  def overwrite?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/list.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/list.rbi
new file mode 100644
index 0000000000000..b5c89fcc76cde
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/list.rbi
@@ -0,0 +1,58 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::List`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::List`.
+
+
+class Homebrew::Cmd::List
+  sig { returns(Homebrew::Cmd::List::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::List::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def built_from_source?; end
+
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def full_name?; end
+
+  sig { returns(T::Boolean) }
+  def installed_as_dependency?; end
+
+  sig { returns(T::Boolean) }
+  def installed_on_request?; end
+
+  sig { returns(T::Boolean) }
+  def l?; end
+
+  sig { returns(T::Boolean) }
+  def multiple?; end
+
+  sig { returns(T::Boolean) }
+  def pinned?; end
+
+  sig { returns(T::Boolean) }
+  def poured_from_bottle?; end
+
+  sig { returns(T::Boolean) }
+  def r?; end
+
+  sig { returns(T::Boolean) }
+  def t?; end
+
+  sig { returns(T::Boolean) }
+  def versions?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/log.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/log.rbi
new file mode 100644
index 0000000000000..3b3717edc8c7c
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/log.rbi
@@ -0,0 +1,46 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Log`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Log`.
+
+
+class Homebrew::Cmd::Log
+  sig { returns(Homebrew::Cmd::Log::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Log::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T.nilable(String)) }
+  def max_count; end
+
+  sig { returns(T.nilable(String)) }
+  def n; end
+
+  sig { returns(T::Boolean) }
+  def oneline?; end
+
+  sig { returns(T::Boolean) }
+  def p?; end
+
+  sig { returns(T::Boolean) }
+  def patch?; end
+
+  sig { returns(T::Boolean) }
+  def stat?; end
+
+  sig { returns(T::Boolean) }
+  def u?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/migrate.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/migrate.rbi
new file mode 100644
index 0000000000000..76b0319915dcb
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/migrate.rbi
@@ -0,0 +1,37 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Migrate`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Migrate`.
+
+
+class Homebrew::Cmd::Migrate
+  sig { returns(Homebrew::Cmd::Migrate::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Migrate::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/missing.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/missing.rbi
new file mode 100644
index 0000000000000..9a47a1177e2cc
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/missing.rbi
@@ -0,0 +1,16 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Missing`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Missing`.
+
+
+class Homebrew::Cmd::Missing
+  sig { returns(Homebrew::Cmd::Missing::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Missing::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(T::Array[String])) }
+  def hide; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/nodenv_sync.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/nodenv_sync.rbi
new file mode 100644
index 0000000000000..f840a3fd1a7c1
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/nodenv_sync.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::NodenvSync`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::NodenvSync`.
+
+
+class Homebrew::Cmd::NodenvSync
+  sig { returns(Homebrew::Cmd::NodenvSync::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::NodenvSync::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/options_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/options_cmd.rbi
new file mode 100644
index 0000000000000..136d0c4263012
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/options_cmd.rbi
@@ -0,0 +1,25 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::OptionsCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::OptionsCmd`.
+
+
+class Homebrew::Cmd::OptionsCmd
+  sig { returns(Homebrew::Cmd::OptionsCmd::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::OptionsCmd::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(String)) }
+  def command; end
+
+  sig { returns(T::Boolean) }
+  def compact?; end
+
+  sig { returns(T::Boolean) }
+  def eval_all?; end
+
+  sig { returns(T::Boolean) }
+  def installed?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/outdated.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/outdated.rbi
new file mode 100644
index 0000000000000..9e1d46f0e4d47
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/outdated.rbi
@@ -0,0 +1,43 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Outdated`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Outdated`.
+
+
+class Homebrew::Cmd::Outdated
+  sig { returns(Homebrew::Cmd::Outdated::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Outdated::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def fetch_HEAD?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def g?; end
+
+  sig { returns(T::Boolean) }
+  def greedy?; end
+
+  sig { returns(T::Boolean) }
+  def greedy_auto_updates?; end
+
+  sig { returns(T::Boolean) }
+  def greedy_latest?; end
+
+  sig { returns(T.nilable(String)) }
+  def json; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/pin.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/pin.rbi
new file mode 100644
index 0000000000000..36fa101d83a2b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/pin.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Pin`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Pin`.
+
+
+class Homebrew::Cmd::Pin
+  sig { returns(Homebrew::Cmd::Pin::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Pin::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/postinstall.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/postinstall.rbi
new file mode 100644
index 0000000000000..4cab85f3b17b5
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/postinstall.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Postinstall`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Postinstall`.
+
+
+class Homebrew::Cmd::Postinstall
+  sig { returns(Homebrew::Cmd::Postinstall::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Postinstall::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/prefix.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/prefix.rbi
new file mode 100644
index 0000000000000..abb7751895e65
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/prefix.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Prefix`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Prefix`.
+
+
+class Homebrew::Cmd::Prefix
+  sig { returns(Homebrew::Cmd::Prefix::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Prefix::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def installed?; end
+
+  sig { returns(T::Boolean) }
+  def unbrewed?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/pyenv_sync.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/pyenv_sync.rbi
new file mode 100644
index 0000000000000..4de8aa68ec279
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/pyenv_sync.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::PyenvSync`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::PyenvSync`.
+
+
+class Homebrew::Cmd::PyenvSync
+  sig { returns(Homebrew::Cmd::PyenvSync::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::PyenvSync::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/rbenv_sync.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/rbenv_sync.rbi
new file mode 100644
index 0000000000000..69973a58c935d
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/rbenv_sync.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::RbenvSync`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::RbenvSync`.
+
+
+class Homebrew::Cmd::RbenvSync
+  sig { returns(Homebrew::Cmd::RbenvSync::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::RbenvSync::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/readall_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/readall_cmd.rbi
new file mode 100644
index 0000000000000..08140c7fce0b2
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/readall_cmd.rbi
@@ -0,0 +1,31 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::ReadallCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::ReadallCmd`.
+
+
+class Homebrew::Cmd::ReadallCmd
+  sig { returns(Homebrew::Cmd::ReadallCmd::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::ReadallCmd::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def aliases?; end
+
+  sig { returns(T.nilable(String)) }
+  def arch; end
+
+  sig { returns(T::Boolean) }
+  def eval_all?; end
+
+  sig { returns(T::Boolean) }
+  def no_simulate?; end
+
+  sig { returns(T.nilable(String)) }
+  def os; end
+
+  sig { returns(T::Boolean) }
+  def syntax?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/reinstall.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/reinstall.rbi
new file mode 100644
index 0000000000000..10f9c8fb8f6f6
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/reinstall.rbi
@@ -0,0 +1,127 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Reinstall`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Reinstall`.
+
+
+class Homebrew::Cmd::Reinstall
+  sig { returns(Homebrew::Cmd::Reinstall::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Reinstall::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def adopt?; end
+
+  sig { returns(T.nilable(String)) }
+  def appdir; end
+
+  sig { returns(T.nilable(String)) }
+  def audio_unit_plugindir; end
+
+  sig { returns(T::Boolean) }
+  def binaries?; end
+
+  sig { returns(T::Boolean) }
+  def build_from_source?; end
+
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T.nilable(String)) }
+  def colorpickerdir; end
+
+  sig { returns(T::Boolean) }
+  def debug_symbols?; end
+
+  sig { returns(T.nilable(String)) }
+  def dictionarydir; end
+
+  sig { returns(T::Boolean) }
+  def display_times?; end
+
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T.nilable(String)) }
+  def fontdir; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def force_bottle?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def g?; end
+
+  sig { returns(T::Boolean) }
+  def git?; end
+
+  sig { returns(T::Boolean) }
+  def i?; end
+
+  sig { returns(T.nilable(String)) }
+  def input_methoddir; end
+
+  sig { returns(T::Boolean) }
+  def interactive?; end
+
+  sig { returns(T.nilable(String)) }
+  def internet_plugindir; end
+
+  sig { returns(T::Boolean) }
+  def keep_tmp?; end
+
+  sig { returns(T.nilable(String)) }
+  def keyboard_layoutdir; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def language; end
+
+  sig { returns(T.nilable(String)) }
+  def mdimporterdir; end
+
+  sig { returns(T.nilable(String)) }
+  def prefpanedir; end
+
+  sig { returns(T.nilable(String)) }
+  def qlplugindir; end
+
+  sig { returns(T::Boolean) }
+  def quarantine?; end
+
+  sig { returns(T::Boolean) }
+  def require_sha?; end
+
+  sig { returns(T::Boolean) }
+  def s?; end
+
+  sig { returns(T.nilable(String)) }
+  def screen_saverdir; end
+
+  sig { returns(T.nilable(String)) }
+  def servicedir; end
+
+  sig { returns(T::Boolean) }
+  def skip_cask_deps?; end
+
+  sig { returns(T.nilable(String)) }
+  def vst3_plugindir; end
+
+  sig { returns(T.nilable(String)) }
+  def vst_plugindir; end
+
+  sig { returns(T::Boolean) }
+  def zap?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/repository.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/repository.rbi
new file mode 100644
index 0000000000000..7c98aeab74f93
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/repository.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Repository`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Repository`.
+
+
+class Homebrew::Cmd::Repository
+  sig { returns(Homebrew::Cmd::Repository::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Repository::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/search_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/search_cmd.rbi
new file mode 100644
index 0000000000000..ac00e830cfcd3
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/search_cmd.rbi
@@ -0,0 +1,64 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::SearchCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::SearchCmd`.
+
+
+class Homebrew::Cmd::SearchCmd
+  sig { returns(Homebrew::Cmd::SearchCmd::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::SearchCmd::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def archlinux?; end
+
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def closed?; end
+
+  sig { returns(T::Boolean) }
+  def debian?; end
+
+  sig { returns(T::Boolean) }
+  def desc?; end
+
+  sig { returns(T::Boolean) }
+  def eval_all?; end
+
+  sig { returns(T::Boolean) }
+  def fedora?; end
+
+  sig { returns(T::Boolean) }
+  def fink?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def macports?; end
+
+  sig { returns(T::Boolean) }
+  def open?; end
+
+  sig { returns(T::Boolean) }
+  def opensuse?; end
+
+  sig { returns(T::Boolean) }
+  def pull_request?; end
+
+  sig { returns(T::Boolean) }
+  def repology?; end
+
+  sig { returns(T::Boolean) }
+  def ubuntu?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/setup_ruby.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/setup_ruby.rbi
new file mode 100644
index 0000000000000..1b41c0faac633
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/setup_ruby.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::SetupRuby`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::SetupRuby`.
+
+
+class Homebrew::Cmd::SetupRuby
+  sig { returns(Homebrew::Cmd::SetupRuby::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::SetupRuby::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/shellenv.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/shellenv.rbi
new file mode 100644
index 0000000000000..e549928e5ffca
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/shellenv.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Shellenv`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Shellenv`.
+
+
+class Homebrew::Cmd::Shellenv
+  sig { returns(Homebrew::Cmd::Shellenv::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Shellenv::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/tab_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/tab_cmd.rbi
new file mode 100644
index 0000000000000..5ca2794df5bbd
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/tab_cmd.rbi
@@ -0,0 +1,31 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::TabCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::TabCmd`.
+
+
+class Homebrew::Cmd::TabCmd
+  sig { returns(Homebrew::Cmd::TabCmd::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::TabCmd::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def installed_on_request?; end
+
+  sig { returns(T::Boolean) }
+  def no_installed_on_request?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/tap_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/tap_cmd.rbi
new file mode 100644
index 0000000000000..2372f2207a684
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/tap_cmd.rbi
@@ -0,0 +1,28 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::TapCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::TapCmd`.
+
+
+class Homebrew::Cmd::TapCmd
+  sig { returns(Homebrew::Cmd::TapCmd::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::TapCmd::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def custom_remote?; end
+
+  sig { returns(T::Boolean) }
+  def eval_all?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T.nilable(String)) }
+  def force_auto_update?; end
+
+  sig { returns(T::Boolean) }
+  def repair?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/tap_info.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/tap_info.rbi
new file mode 100644
index 0000000000000..38bb6ace65390
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/tap_info.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::TapInfo`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::TapInfo`.
+
+
+class Homebrew::Cmd::TapInfo
+  sig { returns(Homebrew::Cmd::TapInfo::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::TapInfo::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def installed?; end
+
+  sig { returns(T.nilable(String)) }
+  def json; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/uninstall_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/uninstall_cmd.rbi
new file mode 100644
index 0000000000000..c5852070da61b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/uninstall_cmd.rbi
@@ -0,0 +1,37 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::UninstallCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::UninstallCmd`.
+
+
+class Homebrew::Cmd::UninstallCmd
+  sig { returns(Homebrew::Cmd::UninstallCmd::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::UninstallCmd::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def ignore_dependencies?; end
+
+  sig { returns(T::Boolean) }
+  def zap?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/unlink_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/unlink_cmd.rbi
new file mode 100644
index 0000000000000..3adbfecd36fc0
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/unlink_cmd.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::UnlinkCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::UnlinkCmd`.
+
+
+class Homebrew::Cmd::UnlinkCmd
+  sig { returns(Homebrew::Cmd::UnlinkCmd::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::UnlinkCmd::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/unpin.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/unpin.rbi
new file mode 100644
index 0000000000000..167d1faebd736
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/unpin.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Unpin`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Unpin`.
+
+
+class Homebrew::Cmd::Unpin
+  sig { returns(Homebrew::Cmd::Unpin::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Unpin::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/untap.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/untap.rbi
new file mode 100644
index 0000000000000..ec20c4102ab5d
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/untap.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Untap`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Untap`.
+
+
+class Homebrew::Cmd::Untap
+  sig { returns(Homebrew::Cmd::Untap::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Untap::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/update.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/update.rbi
new file mode 100644
index 0000000000000..e630aad867767
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/update.rbi
@@ -0,0 +1,25 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Update`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Update`.
+
+
+class Homebrew::Cmd::Update
+  sig { returns(Homebrew::Cmd::Update::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Update::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def auto_update?; end
+
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def merge?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/update_report.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/update_report.rbi
new file mode 100644
index 0000000000000..fd7eed381ed5e
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/update_report.rbi
@@ -0,0 +1,25 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::UpdateReport`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::UpdateReport`.
+
+
+class Homebrew::Cmd::UpdateReport
+  sig { returns(Homebrew::Cmd::UpdateReport::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::UpdateReport::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def auto_update?; end
+
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def preinstall?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/update_reset.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/update_reset.rbi
new file mode 100644
index 0000000000000..cb1ef43c6d7f8
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/update_reset.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::UpdateReset`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::UpdateReset`.
+
+
+class Homebrew::Cmd::UpdateReset
+  sig { returns(Homebrew::Cmd::UpdateReset::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::UpdateReset::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/upgrade_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/upgrade_cmd.rbi
new file mode 100644
index 0000000000000..bc2ba6224b1f7
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/upgrade_cmd.rbi
@@ -0,0 +1,139 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::UpgradeCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::UpgradeCmd`.
+
+
+class Homebrew::Cmd::UpgradeCmd
+  sig { returns(Homebrew::Cmd::UpgradeCmd::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::UpgradeCmd::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(String)) }
+  def appdir; end
+
+  sig { returns(T.nilable(String)) }
+  def audio_unit_plugindir; end
+
+  sig { returns(T::Boolean) }
+  def binaries?; end
+
+  sig { returns(T::Boolean) }
+  def build_from_source?; end
+
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T.nilable(String)) }
+  def colorpickerdir; end
+
+  sig { returns(T::Boolean) }
+  def debug_symbols?; end
+
+  sig { returns(T.nilable(String)) }
+  def dictionarydir; end
+
+  sig { returns(T::Boolean) }
+  def display_times?; end
+
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T::Boolean) }
+  def fetch_HEAD?; end
+
+  sig { returns(T.nilable(String)) }
+  def fontdir; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def force_bottle?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def g?; end
+
+  sig { returns(T::Boolean) }
+  def greedy?; end
+
+  sig { returns(T::Boolean) }
+  def greedy_auto_updates?; end
+
+  sig { returns(T::Boolean) }
+  def greedy_latest?; end
+
+  sig { returns(T::Boolean) }
+  def i?; end
+
+  sig { returns(T.nilable(String)) }
+  def input_methoddir; end
+
+  sig { returns(T::Boolean) }
+  def interactive?; end
+
+  sig { returns(T.nilable(String)) }
+  def internet_plugindir; end
+
+  sig { returns(T::Boolean) }
+  def keep_tmp?; end
+
+  sig { returns(T.nilable(String)) }
+  def keyboard_layoutdir; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def language; end
+
+  sig { returns(T.nilable(String)) }
+  def mdimporterdir; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+
+  sig { returns(T::Boolean) }
+  def overwrite?; end
+
+  sig { returns(T.nilable(String)) }
+  def prefpanedir; end
+
+  sig { returns(T.nilable(String)) }
+  def qlplugindir; end
+
+  sig { returns(T::Boolean) }
+  def quarantine?; end
+
+  sig { returns(T::Boolean) }
+  def require_sha?; end
+
+  sig { returns(T::Boolean) }
+  def s?; end
+
+  sig { returns(T.nilable(String)) }
+  def screen_saverdir; end
+
+  sig { returns(T.nilable(String)) }
+  def servicedir; end
+
+  sig { returns(T::Boolean) }
+  def skip_cask_deps?; end
+
+  sig { returns(T.nilable(String)) }
+  def vst3_plugindir; end
+
+  sig { returns(T.nilable(String)) }
+  def vst_plugindir; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/uses.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/uses.rbi
new file mode 100644
index 0000000000000..f73b850e32910
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/uses.rbi
@@ -0,0 +1,49 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Uses`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Uses`.
+
+
+class Homebrew::Cmd::Uses
+  sig { returns(Homebrew::Cmd::Uses::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Uses::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def eval_all?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def include_build?; end
+
+  sig { returns(T::Boolean) }
+  def include_optional?; end
+
+  sig { returns(T::Boolean) }
+  def include_test?; end
+
+  sig { returns(T::Boolean) }
+  def installed?; end
+
+  sig { returns(T::Boolean) }
+  def missing?; end
+
+  sig { returns(T::Boolean) }
+  def recursive?; end
+
+  sig { returns(T::Boolean) }
+  def skip_recommended?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/vendor_install.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/vendor_install.rbi
new file mode 100644
index 0000000000000..028082ee1fcf2
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/vendor_install.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::VendorInstall`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::VendorInstall`.
+
+
+class Homebrew::Cmd::VendorInstall
+  sig { returns(Homebrew::Cmd::VendorInstall::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::VendorInstall::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/version.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/version.rbi
new file mode 100644
index 0000000000000..238544b7f6e0a
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/cmd/version.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Cmd::Version`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Cmd::Version`.
+
+
+class Homebrew::Cmd::Version
+  sig { returns(Homebrew::Cmd::Version::Args) }
+  def args; end
+end
+
+class Homebrew::Cmd::Version::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/audit.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/audit.rbi
new file mode 100644
index 0000000000000..146719a333f8b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/audit.rbi
@@ -0,0 +1,88 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Audit`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Audit`.
+
+
+class Homebrew::DevCmd::Audit
+  sig { returns(Homebrew::DevCmd::Audit::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Audit::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def D?; end
+
+  sig { returns(T.nilable(String)) }
+  def arch; end
+
+  sig { returns(T::Boolean) }
+  def audit_debug?; end
+
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def display_cop_names?; end
+
+  sig { returns(T::Boolean) }
+  def display_filename?; end
+
+  sig { returns(T::Boolean) }
+  def eval_all?; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def except; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def except_cops; end
+
+  sig { returns(T::Boolean) }
+  def fix?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def git?; end
+
+  sig { returns(T::Boolean) }
+  def installed?; end
+
+  sig { returns(T::Boolean) }
+  def new?; end
+
+  sig { returns(T::Boolean) }
+  def online?; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def only; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def only_cops; end
+
+  sig { returns(T.nilable(String)) }
+  def os; end
+
+  sig { returns(T.nilable(String)) }
+  def signing?; end
+
+  sig { returns(T::Boolean) }
+  def skip_style?; end
+
+  sig { returns(T::Boolean) }
+  def strict?; end
+
+  sig { returns(T.nilable(String)) }
+  def tap; end
+
+  sig { returns(T::Boolean) }
+  def token_conflicts?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bottle.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bottle.rbi
new file mode 100644
index 0000000000000..4713b4fb89f64
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bottle.rbi
@@ -0,0 +1,52 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Bottle`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Bottle`.
+
+
+class Homebrew::DevCmd::Bottle
+  sig { returns(Homebrew::DevCmd::Bottle::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Bottle::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(String)) }
+  def committer; end
+
+  sig { returns(T::Boolean) }
+  def force_core_tap?; end
+
+  sig { returns(T::Boolean) }
+  def json?; end
+
+  sig { returns(T::Boolean) }
+  def keep_old?; end
+
+  sig { returns(T::Boolean) }
+  def merge?; end
+
+  sig { returns(T::Boolean) }
+  def no_all_checks?; end
+
+  sig { returns(T::Boolean) }
+  def no_commit?; end
+
+  sig { returns(T::Boolean) }
+  def no_rebuild?; end
+
+  sig { returns(T::Boolean) }
+  def only_json_tab?; end
+
+  sig { returns(T.nilable(String)) }
+  def root_url; end
+
+  sig { returns(T.nilable(String)) }
+  def root_url_using; end
+
+  sig { returns(T::Boolean) }
+  def skip_relocation?; end
+
+  sig { returns(T::Boolean) }
+  def write?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump.rbi
new file mode 100644
index 0000000000000..a44d6ec9556a6
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump.rbi
@@ -0,0 +1,55 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Bump`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Bump`.
+
+
+class Homebrew::DevCmd::Bump
+  sig { returns(Homebrew::DevCmd::Bump::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Bump::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def auto?; end
+
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def eval_all?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def full_name?; end
+
+  sig { returns(T::Boolean) }
+  def installed?; end
+
+  sig { returns(T::Boolean) }
+  def no_fork?; end
+
+  sig { returns(T::Boolean) }
+  def no_pull_requests?; end
+
+  sig { returns(T::Boolean) }
+  def open_pr?; end
+
+  sig { returns(T::Boolean) }
+  def repology?; end
+
+  sig { returns(T.nilable(String)) }
+  def start_with; end
+
+  sig { returns(T.nilable(String)) }
+  def tap; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump_cask_pr.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump_cask_pr.rbi
new file mode 100644
index 0000000000000..32aa0f75cc0a8
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump_cask_pr.rbi
@@ -0,0 +1,58 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::BumpCaskPr`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::BumpCaskPr`.
+
+
+class Homebrew::DevCmd::BumpCaskPr
+  sig { returns(Homebrew::DevCmd::BumpCaskPr::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::BumpCaskPr::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def commit?; end
+
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T.nilable(String)) }
+  def fork_org; end
+
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+
+  sig { returns(T::Boolean) }
+  def no_audit?; end
+
+  sig { returns(T::Boolean) }
+  def no_browse?; end
+
+  sig { returns(T::Boolean) }
+  def no_fork?; end
+
+  sig { returns(T::Boolean) }
+  def no_style?; end
+
+  sig { returns(T.nilable(String)) }
+  def sha256; end
+
+  sig { returns(T.nilable(String)) }
+  def url; end
+
+  sig { returns(T.nilable(String)) }
+  def version; end
+
+  sig { returns(T.nilable(String)) }
+  def version_arm; end
+
+  sig { returns(T.nilable(String)) }
+  def version_intel; end
+
+  sig { returns(T::Boolean) }
+  def write_only?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump_formula_pr.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump_formula_pr.rbi
new file mode 100644
index 0000000000000..b0368c6db8147
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump_formula_pr.rbi
@@ -0,0 +1,82 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::BumpFormulaPr`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::BumpFormulaPr`.
+
+
+class Homebrew::DevCmd::BumpFormulaPr
+  sig { returns(Homebrew::DevCmd::BumpFormulaPr::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::BumpFormulaPr::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def commit?; end
+
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T.nilable(String)) }
+  def fork_org; end
+
+  sig { returns(T::Boolean) }
+  def install_dependencies?; end
+
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def mirror; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+
+  sig { returns(T::Boolean) }
+  def no_audit?; end
+
+  sig { returns(T::Boolean) }
+  def no_browse?; end
+
+  sig { returns(T::Boolean) }
+  def no_fork?; end
+
+  sig { returns(T::Boolean) }
+  def online?; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def python_exclude_packages; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def python_extra_packages; end
+
+  sig { returns(T.nilable(String)) }
+  def python_package_name; end
+
+  sig { returns(T.nilable(String)) }
+  def revision; end
+
+  sig { returns(T.nilable(String)) }
+  def sha256; end
+
+  sig { returns(T::Boolean) }
+  def strict?; end
+
+  sig { returns(T.nilable(String)) }
+  def tag; end
+
+  sig { returns(T.nilable(String)) }
+  def url; end
+
+  sig { returns(T.nilable(String)) }
+  def version; end
+
+  sig { returns(T::Boolean) }
+  def write_only?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump_revision.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump_revision.rbi
new file mode 100644
index 0000000000000..8f234768c0f24
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump_revision.rbi
@@ -0,0 +1,28 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::BumpRevision`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::BumpRevision`.
+
+
+class Homebrew::DevCmd::BumpRevision
+  sig { returns(Homebrew::DevCmd::BumpRevision::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::BumpRevision::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+
+  sig { returns(T::Boolean) }
+  def remove_bottle_block?; end
+
+  sig { returns(T::Boolean) }
+  def write_only?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump_unversioned_casks.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump_unversioned_casks.rbi
new file mode 100644
index 0000000000000..c3089e3f34f05
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/bump_unversioned_casks.rbi
@@ -0,0 +1,25 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::BumpUnversionedCasks`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::BumpUnversionedCasks`.
+
+
+class Homebrew::DevCmd::BumpUnversionedCasks
+  sig { returns(Homebrew::DevCmd::BumpUnversionedCasks::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::BumpUnversionedCasks::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T.nilable(String)) }
+  def limit; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+
+  sig { returns(T.nilable(String)) }
+  def state_file; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/cat.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/cat.rbi
new file mode 100644
index 0000000000000..f6a5b0de533b7
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/cat.rbi
@@ -0,0 +1,25 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Cat`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Cat`.
+
+
+class Homebrew::DevCmd::Cat
+  sig { returns(Homebrew::DevCmd::Cat::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Cat::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/contributions.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/contributions.rbi
new file mode 100644
index 0000000000000..8d6f0b0b80dab
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/contributions.rbi
@@ -0,0 +1,28 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Contributions`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Contributions`.
+
+
+class Homebrew::DevCmd::Contributions
+  sig { returns(Homebrew::DevCmd::Contributions::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Contributions::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def csv?; end
+
+  sig { returns(T.nilable(String)) }
+  def from; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def repositories; end
+
+  sig { returns(T.nilable(String)) }
+  def to; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def user; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/create.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/create.rbi
new file mode 100644
index 0000000000000..bbfe7510c9c8f
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/create.rbi
@@ -0,0 +1,70 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Create`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Create`.
+
+
+class Homebrew::DevCmd::Create
+  sig { returns(Homebrew::DevCmd::Create::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Create::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def HEAD?; end
+
+  sig { returns(T::Boolean) }
+  def autotools?; end
+
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def cmake?; end
+
+  sig { returns(T::Boolean) }
+  def crystal?; end
+
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def go?; end
+
+  sig { returns(T::Boolean) }
+  def meson?; end
+
+  sig { returns(T::Boolean) }
+  def no_fetch?; end
+
+  sig { returns(T::Boolean) }
+  def node?; end
+
+  sig { returns(T::Boolean) }
+  def perl?; end
+
+  sig { returns(T::Boolean) }
+  def python?; end
+
+  sig { returns(T::Boolean) }
+  def ruby?; end
+
+  sig { returns(T::Boolean) }
+  def rust?; end
+
+  sig { returns(T.nilable(String)) }
+  def set_license; end
+
+  sig { returns(T.nilable(String)) }
+  def set_name; end
+
+  sig { returns(T.nilable(String)) }
+  def set_version; end
+
+  sig { returns(T.nilable(String)) }
+  def tap; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/debugger.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/debugger.rbi
new file mode 100644
index 0000000000000..8927123012eff
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/debugger.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Debugger`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Debugger`.
+
+
+class Homebrew::DevCmd::Debugger
+  sig { returns(Homebrew::DevCmd::Debugger::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Debugger::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def O?; end
+
+  sig { returns(T::Boolean) }
+  def open?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/determine_test_runners.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/determine_test_runners.rbi
new file mode 100644
index 0000000000000..71badb241887a
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/determine_test_runners.rbi
@@ -0,0 +1,22 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::DetermineTestRunners`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::DetermineTestRunners`.
+
+
+class Homebrew::DevCmd::DetermineTestRunners
+  sig { returns(Homebrew::DevCmd::DetermineTestRunners::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::DetermineTestRunners::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def all_supported?; end
+
+  sig { returns(T::Boolean) }
+  def dependents?; end
+
+  sig { returns(T::Boolean) }
+  def eval_all?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/dispatch_build_bottle.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/dispatch_build_bottle.rbi
new file mode 100644
index 0000000000000..1b71f8cc0fd8b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/dispatch_build_bottle.rbi
@@ -0,0 +1,40 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::DispatchBuildBottle`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::DispatchBuildBottle`.
+
+
+class Homebrew::DevCmd::DispatchBuildBottle
+  sig { returns(Homebrew::DevCmd::DispatchBuildBottle::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::DispatchBuildBottle::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(String)) }
+  def issue; end
+
+  sig { returns(T::Boolean) }
+  def linux?; end
+
+  sig { returns(T::Boolean) }
+  def linux_self_hosted?; end
+
+  sig { returns(T::Boolean) }
+  def linux_wheezy?; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def macos; end
+
+  sig { returns(T.nilable(String)) }
+  def tap; end
+
+  sig { returns(T.nilable(String)) }
+  def timeout; end
+
+  sig { returns(T::Boolean) }
+  def upload?; end
+
+  sig { returns(T.nilable(String)) }
+  def workflow; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/edit.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/edit.rbi
new file mode 100644
index 0000000000000..ea757589d5d7d
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/edit.rbi
@@ -0,0 +1,28 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Edit`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Edit`.
+
+
+class Homebrew::DevCmd::Edit
+  sig { returns(Homebrew::DevCmd::Edit::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Edit::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def print_path?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/extract.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/extract.rbi
new file mode 100644
index 0000000000000..513182b0a0e51
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/extract.rbi
@@ -0,0 +1,25 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Extract`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Extract`.
+
+
+class Homebrew::DevCmd::Extract
+  sig { returns(Homebrew::DevCmd::Extract::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Extract::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T.nilable(String)) }
+  def git_revision; end
+
+  sig { returns(T.nilable(String)) }
+  def version; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/formula_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/formula_cmd.rbi
new file mode 100644
index 0000000000000..9e398c3532861
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/formula_cmd.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::FormulaCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::FormulaCmd`.
+
+
+class Homebrew::DevCmd::FormulaCmd
+  sig { returns(Homebrew::DevCmd::FormulaCmd::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::FormulaCmd::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/generate_cask_api.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/generate_cask_api.rbi
new file mode 100644
index 0000000000000..fb0c9b00dbf43
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/generate_cask_api.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::GenerateCaskApi`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::GenerateCaskApi`.
+
+
+class Homebrew::DevCmd::GenerateCaskApi
+  sig { returns(Homebrew::DevCmd::GenerateCaskApi::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::GenerateCaskApi::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/generate_formula_api.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/generate_formula_api.rbi
new file mode 100644
index 0000000000000..5594e07fe75e8
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/generate_formula_api.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::GenerateFormulaApi`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::GenerateFormulaApi`.
+
+
+class Homebrew::DevCmd::GenerateFormulaApi
+  sig { returns(Homebrew::DevCmd::GenerateFormulaApi::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::GenerateFormulaApi::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/generate_man_completions.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/generate_man_completions.rbi
new file mode 100644
index 0000000000000..ffa3636d07534
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/generate_man_completions.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::GenerateManCompletions`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::GenerateManCompletions`.
+
+
+class Homebrew::DevCmd::GenerateManCompletions
+  sig { returns(Homebrew::DevCmd::GenerateManCompletions::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::GenerateManCompletions::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/install_bundler_gems.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/install_bundler_gems.rbi
new file mode 100644
index 0000000000000..e4f61371b337a
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/install_bundler_gems.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::InstallBundlerGems`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::InstallBundlerGems`.
+
+
+class Homebrew::DevCmd::InstallBundlerGems
+  sig { returns(Homebrew::DevCmd::InstallBundlerGems::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::InstallBundlerGems::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(T::Array[String])) }
+  def add_groups; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def groups; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/irb.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/irb.rbi
new file mode 100644
index 0000000000000..0288e203fcca0
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/irb.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Irb`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Irb`.
+
+
+class Homebrew::DevCmd::Irb
+  sig { returns(Homebrew::DevCmd::Irb::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Irb::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def examples?; end
+
+  sig { returns(T::Boolean) }
+  def pry?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/linkage.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/linkage.rbi
new file mode 100644
index 0000000000000..830939764d84e
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/linkage.rbi
@@ -0,0 +1,25 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Linkage`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Linkage`.
+
+
+class Homebrew::DevCmd::Linkage
+  sig { returns(Homebrew::DevCmd::Linkage::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Linkage::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def cached?; end
+
+  sig { returns(T::Boolean) }
+  def reverse?; end
+
+  sig { returns(T::Boolean) }
+  def strict?; end
+
+  sig { returns(T::Boolean) }
+  def test?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/livecheck_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/livecheck_cmd.rbi
new file mode 100644
index 0000000000000..747ea49b71de2
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/livecheck_cmd.rbi
@@ -0,0 +1,52 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::LivecheckCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::LivecheckCmd`.
+
+
+class Homebrew::DevCmd::LivecheckCmd
+  sig { returns(Homebrew::DevCmd::LivecheckCmd::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::LivecheckCmd::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def eval_all?; end
+
+  sig { returns(T::Boolean) }
+  def extract_plist?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T::Boolean) }
+  def full_name?; end
+
+  sig { returns(T::Boolean) }
+  def installed?; end
+
+  sig { returns(T::Boolean) }
+  def json?; end
+
+  sig { returns(T::Boolean) }
+  def newer_only?; end
+
+  sig { returns(T::Boolean) }
+  def r?; end
+
+  sig { returns(T::Boolean) }
+  def resources?; end
+
+  sig { returns(T.nilable(String)) }
+  def tap; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/pr_automerge.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/pr_automerge.rbi
new file mode 100644
index 0000000000000..d2b63c6ab001d
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/pr_automerge.rbi
@@ -0,0 +1,37 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::PrAutomerge`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::PrAutomerge`.
+
+
+class Homebrew::DevCmd::PrAutomerge
+  sig { returns(Homebrew::DevCmd::PrAutomerge::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::PrAutomerge::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def autosquash?; end
+
+  sig { returns(T::Boolean) }
+  def ignore_failures?; end
+
+  sig { returns(T::Boolean) }
+  def publish?; end
+
+  sig { returns(T.nilable(String)) }
+  def tap; end
+
+  sig { returns(T.nilable(String)) }
+  def with_label; end
+
+  sig { returns(T::Boolean) }
+  def without_approval?; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def without_labels; end
+
+  sig { returns(T.nilable(String)) }
+  def workflow; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/pr_publish.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/pr_publish.rbi
new file mode 100644
index 0000000000000..c1eff16f78afc
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/pr_publish.rbi
@@ -0,0 +1,31 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::PrPublish`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::PrPublish`.
+
+
+class Homebrew::DevCmd::PrPublish
+  sig { returns(Homebrew::DevCmd::PrPublish::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::PrPublish::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def autosquash?; end
+
+  sig { returns(T.nilable(String)) }
+  def branch; end
+
+  sig { returns(T::Boolean) }
+  def large_runner?; end
+
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  sig { returns(T.nilable(String)) }
+  def tap; end
+
+  sig { returns(T.nilable(String)) }
+  def workflow; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/pr_pull.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/pr_pull.rbi
new file mode 100644
index 0000000000000..8a8ac7add7222
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/pr_pull.rbi
@@ -0,0 +1,76 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::PrPull`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::PrPull`.
+
+
+class Homebrew::DevCmd::PrPull
+  sig { returns(Homebrew::DevCmd::PrPull::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::PrPull::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(String)) }
+  def artifact; end
+
+  sig { returns(T.nilable(String)) }
+  def artifact_pattern; end
+
+  sig { returns(T::Boolean) }
+  def autosquash?; end
+
+  sig { returns(T::Boolean) }
+  def branch_okay?; end
+
+  sig { returns(T::Boolean) }
+  def clean?; end
+
+  sig { returns(T.nilable(String)) }
+  def committer; end
+
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def ignore_missing_artifacts; end
+
+  sig { returns(T::Boolean) }
+  def keep_old?; end
+
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+
+  sig { returns(T::Boolean) }
+  def no_cherry_pick?; end
+
+  sig { returns(T::Boolean) }
+  def no_commit?; end
+
+  sig { returns(T::Boolean) }
+  def no_upload?; end
+
+  sig { returns(T::Boolean) }
+  def resolve?; end
+
+  sig { returns(T::Boolean) }
+  def retain_bottle_dir?; end
+
+  sig { returns(T.nilable(String)) }
+  def root_url; end
+
+  sig { returns(T.nilable(String)) }
+  def root_url_using; end
+
+  sig { returns(T.nilable(String)) }
+  def tap; end
+
+  sig { returns(T::Boolean) }
+  def warn_on_upload_failure?; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def workflows; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/pr_upload.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/pr_upload.rbi
new file mode 100644
index 0000000000000..4a9212859ac21
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/pr_upload.rbi
@@ -0,0 +1,40 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::PrUpload`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::PrUpload`.
+
+
+class Homebrew::DevCmd::PrUpload
+  sig { returns(Homebrew::DevCmd::PrUpload::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::PrUpload::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(String)) }
+  def committer; end
+
+  sig { returns(T::Boolean) }
+  def dry_run?; end
+
+  sig { returns(T::Boolean) }
+  def keep_old?; end
+
+  sig { returns(T::Boolean) }
+  def n?; end
+
+  sig { returns(T::Boolean) }
+  def no_commit?; end
+
+  sig { returns(T.nilable(String)) }
+  def root_url; end
+
+  sig { returns(T.nilable(String)) }
+  def root_url_using; end
+
+  sig { returns(T::Boolean) }
+  def upload_only?; end
+
+  sig { returns(T::Boolean) }
+  def warn_on_upload_failure?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/prof.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/prof.rbi
new file mode 100644
index 0000000000000..b039be17b43ee
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/prof.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Prof`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Prof`.
+
+
+class Homebrew::DevCmd::Prof
+  sig { returns(Homebrew::DevCmd::Prof::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Prof::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def stackprof?; end
+
+  sig { returns(T::Boolean) }
+  def vernier?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/release.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/release.rbi
new file mode 100644
index 0000000000000..6ae65260dac39
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/release.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Release`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Release`.
+
+
+class Homebrew::DevCmd::Release
+  sig { returns(Homebrew::DevCmd::Release::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Release::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def major?; end
+
+  sig { returns(T::Boolean) }
+  def minor?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/rubocop.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/rubocop.rbi
new file mode 100644
index 0000000000000..90864ea3b6589
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/rubocop.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Rubocop`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Rubocop`.
+
+
+class Homebrew::DevCmd::Rubocop
+  sig { returns(Homebrew::DevCmd::Rubocop::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Rubocop::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/ruby.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/ruby.rbi
new file mode 100644
index 0000000000000..e2cab0f2e5c81
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/ruby.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Ruby`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Ruby`.
+
+
+class Homebrew::DevCmd::Ruby
+  sig { returns(Homebrew::DevCmd::Ruby::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Ruby::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(String)) }
+  def e; end
+
+  sig { returns(T.nilable(String)) }
+  def r; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/rubydoc.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/rubydoc.rbi
new file mode 100644
index 0000000000000..c20741167156e
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/rubydoc.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Rubydoc`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Rubydoc`.
+
+
+class Homebrew::DevCmd::Rubydoc
+  sig { returns(Homebrew::DevCmd::Rubydoc::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Rubydoc::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def only_public?; end
+
+  sig { returns(T::Boolean) }
+  def open?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/sh.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/sh.rbi
new file mode 100644
index 0000000000000..05ba7e4371878
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/sh.rbi
@@ -0,0 +1,22 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Sh`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Sh`.
+
+
+class Homebrew::DevCmd::Sh
+  sig { returns(Homebrew::DevCmd::Sh::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Sh::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(String)) }
+  def c; end
+
+  sig { returns(T.nilable(String)) }
+  def cmd; end
+
+  sig { returns(T.nilable(String)) }
+  def env; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/style_cmd.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/style_cmd.rbi
new file mode 100644
index 0000000000000..14eaec8d4695c
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/style_cmd.rbi
@@ -0,0 +1,40 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::StyleCmd`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::StyleCmd`.
+
+
+class Homebrew::DevCmd::StyleCmd
+  sig { returns(Homebrew::DevCmd::StyleCmd::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::StyleCmd::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def cask?; end
+
+  sig { returns(T::Boolean) }
+  def casks?; end
+
+  sig { returns(T::Boolean) }
+  def display_cop_names?; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def except_cops; end
+
+  sig { returns(T::Boolean) }
+  def fix?; end
+
+  sig { returns(T::Boolean) }
+  def formula?; end
+
+  sig { returns(T::Boolean) }
+  def formulae?; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def only_cops; end
+
+  sig { returns(T::Boolean) }
+  def reset_cache?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/tap_new.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/tap_new.rbi
new file mode 100644
index 0000000000000..703e855d52326
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/tap_new.rbi
@@ -0,0 +1,25 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::TapNew`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::TapNew`.
+
+
+class Homebrew::DevCmd::TapNew
+  sig { returns(Homebrew::DevCmd::TapNew::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::TapNew::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(String)) }
+  def branch; end
+
+  sig { returns(T::Boolean) }
+  def github_packages?; end
+
+  sig { returns(T::Boolean) }
+  def no_git?; end
+
+  sig { returns(T.nilable(String)) }
+  def pull_label; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/test.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/test.rbi
new file mode 100644
index 0000000000000..a5fcb5aaf65b5
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/test.rbi
@@ -0,0 +1,28 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Test`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Test`.
+
+
+class Homebrew::DevCmd::Test
+  sig { returns(Homebrew::DevCmd::Test::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Test::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def HEAD?; end
+
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def keep_tmp?; end
+
+  sig { returns(T::Boolean) }
+  def retry?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/tests.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/tests.rbi
new file mode 100644
index 0000000000000..863665ee933cc
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/tests.rbi
@@ -0,0 +1,37 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Tests`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Tests`.
+
+
+class Homebrew::DevCmd::Tests
+  sig { returns(Homebrew::DevCmd::Tests::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Tests::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def changed?; end
+
+  sig { returns(T::Boolean) }
+  def coverage?; end
+
+  sig { returns(T::Boolean) }
+  def fail_fast?; end
+
+  sig { returns(T::Boolean) }
+  def generic?; end
+
+  sig { returns(T::Boolean) }
+  def online?; end
+
+  sig { returns(T.nilable(String)) }
+  def only; end
+
+  sig { returns(T.nilable(String)) }
+  def profile; end
+
+  sig { returns(T.nilable(String)) }
+  def seed; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/typecheck.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/typecheck.rbi
new file mode 100644
index 0000000000000..0ff0433940949
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/typecheck.rbi
@@ -0,0 +1,37 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Typecheck`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Typecheck`.
+
+
+class Homebrew::DevCmd::Typecheck
+  sig { returns(Homebrew::DevCmd::Typecheck::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Typecheck::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(String)) }
+  def dir; end
+
+  sig { returns(T.nilable(String)) }
+  def file; end
+
+  sig { returns(T::Boolean) }
+  def fix?; end
+
+  sig { returns(T.nilable(String)) }
+  def ignore; end
+
+  sig { returns(T::Boolean) }
+  def lsp?; end
+
+  sig { returns(T::Boolean) }
+  def suggest_typed?; end
+
+  sig { returns(T::Boolean) }
+  def update?; end
+
+  sig { returns(T::Boolean) }
+  def update_all?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/unbottled.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/unbottled.rbi
new file mode 100644
index 0000000000000..15bf5b93732a2
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/unbottled.rbi
@@ -0,0 +1,28 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Unbottled`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Unbottled`.
+
+
+class Homebrew::DevCmd::Unbottled
+  sig { returns(Homebrew::DevCmd::Unbottled::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Unbottled::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def dependents?; end
+
+  sig { returns(T::Boolean) }
+  def eval_all?; end
+
+  sig { returns(T::Boolean) }
+  def lost?; end
+
+  sig { returns(T.nilable(String)) }
+  def tag; end
+
+  sig { returns(T::Boolean) }
+  def total?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/unpack.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/unpack.rbi
new file mode 100644
index 0000000000000..b1d7bbd6af220
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/unpack.rbi
@@ -0,0 +1,31 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::Unpack`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::Unpack`.
+
+
+class Homebrew::DevCmd::Unpack
+  sig { returns(Homebrew::DevCmd::Unpack::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::Unpack::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(String)) }
+  def destdir; end
+
+  sig { returns(T::Boolean) }
+  def f?; end
+
+  sig { returns(T::Boolean) }
+  def force?; end
+
+  sig { returns(T::Boolean) }
+  def g?; end
+
+  sig { returns(T::Boolean) }
+  def git?; end
+
+  sig { returns(T::Boolean) }
+  def patch?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_license_data.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_license_data.rbi
new file mode 100644
index 0000000000000..9250b4262f545
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_license_data.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::UpdateLicenseData`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::UpdateLicenseData`.
+
+
+class Homebrew::DevCmd::UpdateLicenseData
+  sig { returns(Homebrew::DevCmd::UpdateLicenseData::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::UpdateLicenseData::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_maintainers.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_maintainers.rbi
new file mode 100644
index 0000000000000..da7e37090f4e0
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_maintainers.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::UpdateMaintainers`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::UpdateMaintainers`.
+
+
+class Homebrew::DevCmd::UpdateMaintainers
+  sig { returns(Homebrew::DevCmd::UpdateMaintainers::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::UpdateMaintainers::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_python_resources.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_python_resources.rbi
new file mode 100644
index 0000000000000..f5adb35b4f02b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_python_resources.rbi
@@ -0,0 +1,43 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::UpdatePythonResources`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::UpdatePythonResources`.
+
+
+class Homebrew::DevCmd::UpdatePythonResources
+  sig { returns(Homebrew::DevCmd::UpdatePythonResources::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::UpdatePythonResources::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(T::Array[String])) }
+  def exclude_packages; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def extra_packages; end
+
+  sig { returns(T::Boolean) }
+  def ignore_non_pypi_packages?; end
+
+  sig { returns(T::Boolean) }
+  def install_dependencies?; end
+
+  sig { returns(T::Boolean) }
+  def p?; end
+
+  sig { returns(T.nilable(String)) }
+  def package_name; end
+
+  sig { returns(T::Boolean) }
+  def print_only?; end
+
+  sig { returns(T::Boolean) }
+  def s?; end
+
+  sig { returns(T::Boolean) }
+  def silent?; end
+
+  sig { returns(T.nilable(String)) }
+  def version; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_sponsors.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_sponsors.rbi
new file mode 100644
index 0000000000000..9e51a8a04fc6b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_sponsors.rbi
@@ -0,0 +1,13 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::UpdateSponsors`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::UpdateSponsors`.
+
+
+class Homebrew::DevCmd::UpdateSponsors
+  sig { returns(Homebrew::DevCmd::UpdateSponsors::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::UpdateSponsors::Args < Homebrew::CLI::Args; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_test.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_test.rbi
new file mode 100644
index 0000000000000..f06b881974bcf
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/update_test.rbi
@@ -0,0 +1,25 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::UpdateTest`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::UpdateTest`.
+
+
+class Homebrew::DevCmd::UpdateTest
+  sig { returns(Homebrew::DevCmd::UpdateTest::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::UpdateTest::Args < Homebrew::CLI::Args
+  sig { returns(T.nilable(String)) }
+  def before; end
+
+  sig { returns(T.nilable(String)) }
+  def commit; end
+
+  sig { returns(T::Boolean) }
+  def keep_tmp?; end
+
+  sig { returns(T::Boolean) }
+  def to_tag?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/vendor_gems.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/vendor_gems.rbi
new file mode 100644
index 0000000000000..4cd1fcea6197a
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/dev_cmd/vendor_gems.rbi
@@ -0,0 +1,22 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::DevCmd::VendorGems`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::DevCmd::VendorGems`.
+
+
+class Homebrew::DevCmd::VendorGems
+  sig { returns(Homebrew::DevCmd::VendorGems::Args) }
+  def args; end
+end
+
+class Homebrew::DevCmd::VendorGems::Args < Homebrew::CLI::Args
+  sig { returns(T::Boolean) }
+  def no_commit?; end
+
+  sig { returns(T::Boolean) }
+  def non_bundler_gems?; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def update; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/env_config.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/env_config.rbi
new file mode 100644
index 0000000000000..d8e7fbb8b290b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/env_config.rbi
@@ -0,0 +1,298 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::EnvConfig`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::EnvConfig`.
+
+
+module Homebrew::EnvConfig
+  class << self
+    sig { returns(T.nilable(::String)) }
+    def all_proxy; end
+
+    sig { returns(T.nilable(::String)) }
+    def allowed_taps; end
+
+    sig { returns(Integer) }
+    def api_auto_update_secs; end
+
+    sig { returns(String) }
+    def api_domain; end
+
+    sig { returns(String) }
+    def arch; end
+
+    sig { returns(T.nilable(::String)) }
+    def artifact_domain; end
+
+    sig { returns(T::Boolean) }
+    def artifact_domain_no_fallback?; end
+
+    sig { returns(T.nilable(::String)) }
+    def auto_update_secs; end
+
+    sig { returns(T::Boolean) }
+    def bat?; end
+
+    sig { returns(T.nilable(::String)) }
+    def bat_config_path; end
+
+    sig { returns(T.nilable(::String)) }
+    def bat_theme; end
+
+    sig { returns(T::Boolean) }
+    def bootsnap?; end
+
+    sig { returns(String) }
+    def bottle_domain; end
+
+    sig { returns(String) }
+    def brew_git_remote; end
+
+    sig { returns(T.nilable(::String)) }
+    def browser; end
+
+    sig { returns(T.nilable(::String)) }
+    def bundle_user_cache; end
+
+    sig { returns(String) }
+    def cache; end
+
+    sig { returns(Integer) }
+    def cleanup_max_age_days; end
+
+    sig { returns(Integer) }
+    def cleanup_periodic_full_days; end
+
+    sig { returns(T::Boolean) }
+    def color?; end
+
+    sig { returns(String) }
+    def core_git_remote; end
+
+    sig { returns(String) }
+    def curl_path; end
+
+    sig { returns(Integer) }
+    def curl_retries; end
+
+    sig { returns(T::Boolean) }
+    def curl_verbose?; end
+
+    sig { returns(T.nilable(::String)) }
+    def curlrc; end
+
+    sig { returns(T::Boolean) }
+    def debug?; end
+
+    sig { returns(T::Boolean) }
+    def developer?; end
+
+    sig { returns(T::Boolean) }
+    def disable_debrew?; end
+
+    sig { returns(T::Boolean) }
+    def disable_load_formula?; end
+
+    sig { returns(T.nilable(::String)) }
+    def display; end
+
+    sig { returns(T::Boolean) }
+    def display_install_times?; end
+
+    sig { returns(T.nilable(::String)) }
+    def docker_registry_basic_auth_token; end
+
+    sig { returns(T.nilable(::String)) }
+    def docker_registry_token; end
+
+    sig { returns(T.nilable(::String)) }
+    def editor; end
+
+    sig { returns(T::Boolean) }
+    def eval_all?; end
+
+    sig { returns(Integer) }
+    def fail_log_lines; end
+
+    sig { returns(T::Boolean) }
+    def forbid_packages_from_paths?; end
+
+    sig { returns(T.nilable(::String)) }
+    def forbidden_casks; end
+
+    sig { returns(T.nilable(::String)) }
+    def forbidden_formulae; end
+
+    sig { returns(T.nilable(::String)) }
+    def forbidden_licenses; end
+
+    sig { returns(String) }
+    def forbidden_owner; end
+
+    sig { returns(T.nilable(::String)) }
+    def forbidden_owner_contact; end
+
+    sig { returns(T.nilable(::String)) }
+    def forbidden_taps; end
+
+    sig { returns(T::Boolean) }
+    def force_brewed_ca_certificates?; end
+
+    sig { returns(T::Boolean) }
+    def force_brewed_curl?; end
+
+    sig { returns(T::Boolean) }
+    def force_brewed_git?; end
+
+    sig { returns(T::Boolean) }
+    def force_vendor_ruby?; end
+
+    sig { returns(T.nilable(::String)) }
+    def formula_build_network; end
+
+    sig { returns(T.nilable(::String)) }
+    def formula_postinstall_network; end
+
+    sig { returns(T.nilable(::String)) }
+    def formula_test_network; end
+
+    sig { returns(T.nilable(::String)) }
+    def ftp_proxy; end
+
+    sig { returns(T.nilable(::String)) }
+    def git_email; end
+
+    sig { returns(T.nilable(::String)) }
+    def git_name; end
+
+    sig { returns(String) }
+    def git_path; end
+
+    sig { returns(T.nilable(::String)) }
+    def github_api_token; end
+
+    sig { returns(T.nilable(::String)) }
+    def github_packages_token; end
+
+    sig { returns(T.nilable(::String)) }
+    def github_packages_user; end
+
+    sig { returns(T.nilable(::String)) }
+    def http_proxy; end
+
+    sig { returns(T.nilable(::String)) }
+    def https_proxy; end
+
+    sig { returns(String) }
+    def install_badge; end
+
+    sig { returns(String) }
+    def livecheck_watchlist; end
+
+    sig { returns(T.nilable(::String)) }
+    def lock_context; end
+
+    sig { returns(String) }
+    def logs; end
+
+    sig { returns(T::Boolean) }
+    def no_analytics?; end
+
+    sig { returns(T::Boolean) }
+    def no_auto_update?; end
+
+    sig { returns(T::Boolean) }
+    def no_autoremove?; end
+
+    sig { returns(T::Boolean) }
+    def no_bootsnap?; end
+
+    sig { returns(T.nilable(::String)) }
+    def no_cleanup_formulae; end
+
+    sig { returns(T::Boolean) }
+    def no_color?; end
+
+    sig { returns(T::Boolean) }
+    def no_emoji?; end
+
+    sig { returns(T::Boolean) }
+    def no_env_hints?; end
+
+    sig { returns(T::Boolean) }
+    def no_github_api?; end
+
+    sig { returns(T::Boolean) }
+    def no_insecure_redirect?; end
+
+    sig { returns(T::Boolean) }
+    def no_install_cleanup?; end
+
+    sig { returns(T::Boolean) }
+    def no_install_from_api?; end
+
+    sig { returns(T::Boolean) }
+    def no_install_upgrade?; end
+
+    sig { returns(T::Boolean) }
+    def no_installed_dependents_check?; end
+
+    sig { returns(T.nilable(::String)) }
+    def no_proxy; end
+
+    sig { returns(T::Boolean) }
+    def no_update_report_new?; end
+
+    sig { returns(T::Boolean) }
+    def no_verify_attestations?; end
+
+    sig { returns(T.nilable(::String)) }
+    def pip_index_url; end
+
+    sig { returns(T::Boolean) }
+    def pry?; end
+
+    sig { returns(T::Boolean) }
+    def simulate_macos_on_linux?; end
+
+    sig { returns(T::Boolean) }
+    def skip_or_later_bottles?; end
+
+    sig { returns(T::Boolean) }
+    def sorbet_runtime?; end
+
+    sig { returns(T.nilable(::String)) }
+    def ssh_config_path; end
+
+    sig { returns(T.nilable(::String)) }
+    def sudo_askpass; end
+
+    sig { returns(T::Boolean) }
+    def sudo_through_sudo_user?; end
+
+    sig { returns(T.nilable(::String)) }
+    def svn; end
+
+    sig { returns(T::Boolean) }
+    def system_env_takes_priority?; end
+
+    sig { returns(String) }
+    def temp; end
+
+    sig { returns(T::Boolean) }
+    def update_to_tag?; end
+
+    sig { returns(T::Boolean) }
+    def upgrade_greedy?; end
+
+    sig { returns(T::Boolean) }
+    def verbose?; end
+
+    sig { returns(T::Boolean) }
+    def verbose_using_dots?; end
+
+    sig { returns(T::Boolean) }
+    def verify_attestations?; end
+  end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/livecheck/strategy/extract_plist/item.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/livecheck/strategy/extract_plist/item.rbi
new file mode 100644
index 0000000000000..2b7646998678e
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/livecheck/strategy/extract_plist/item.rbi
@@ -0,0 +1,14 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Livecheck::Strategy::ExtractPlist::Item`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Livecheck::Strategy::ExtractPlist::Item`.
+
+
+class Homebrew::Livecheck::Strategy::ExtractPlist::Item
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def short_version(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def version(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/livecheck/strategy/sparkle/item.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/livecheck/strategy/sparkle/item.rbi
new file mode 100644
index 0000000000000..f6e1e7c3d3672
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/livecheck/strategy/sparkle/item.rbi
@@ -0,0 +1,17 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Livecheck::Strategy::Sparkle::Item`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Livecheck::Strategy::Sparkle::Item`.
+
+
+class Homebrew::Livecheck::Strategy::Sparkle::Item
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def nice_version(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def short_version(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def version(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/homebrew/service.rbi b/Library/Homebrew/sorbet/rbi/dsl/homebrew/service.rbi
new file mode 100644
index 0000000000000..aa0f69559d603
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/homebrew/service.rbi
@@ -0,0 +1,35 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Homebrew::Service`.
+# Please instead update this file by running `bin/tapioca dsl Homebrew::Service`.
+
+
+class Homebrew::Service
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def bin(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def etc(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def libexec(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def opt_bin(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def opt_libexec(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def opt_pkgshare(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def opt_prefix(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def opt_sbin(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def var(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/keg.rbi b/Library/Homebrew/sorbet/rbi/dsl/keg.rbi
new file mode 100644
index 0000000000000..5b8d1808deacf
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/keg.rbi
@@ -0,0 +1,41 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Keg`.
+# Please instead update this file by running `bin/tapioca dsl Keg`.
+
+
+class Keg
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def /(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def abv(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def directory?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def disk_usage(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def exist?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def file_count(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def find(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def hash(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def join(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def rename(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def to_path(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/linux_requirement.rbi b/Library/Homebrew/sorbet/rbi/dsl/linux_requirement.rbi
new file mode 100644
index 0000000000000..6ad28e5e60521
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/linux_requirement.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `LinuxRequirement`.
+# Please instead update this file by running `bin/tapioca dsl LinuxRequirement`.
+
+
+class LinuxRequirement; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/livecheck.rbi b/Library/Homebrew/sorbet/rbi/dsl/livecheck.rbi
new file mode 100644
index 0000000000000..f900f942d95ab
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/livecheck.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Livecheck`.
+# Please instead update this file by running `bin/tapioca dsl Livecheck`.
+
+
+class Livecheck; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/mac_os_requirement.rbi b/Library/Homebrew/sorbet/rbi/dsl/mac_os_requirement.rbi
new file mode 100644
index 0000000000000..9e31d54eb8490
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/mac_os_requirement.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `MacOSRequirement`.
+# Please instead update this file by running `bin/tapioca dsl MacOSRequirement`.
+
+
+class MacOSRequirement; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/mach_o_shim.rbi b/Library/Homebrew/sorbet/rbi/dsl/mach_o_shim.rbi
new file mode 100644
index 0000000000000..9ebe8128989d7
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/mach_o_shim.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `MachOShim`.
+# Please instead update this file by running `bin/tapioca dsl MachOShim`.
+
+
+module MachOShim
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def dylib_id(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/path.rbi b/Library/Homebrew/sorbet/rbi/dsl/path.rbi
new file mode 100644
index 0000000000000..03ee37fd3f91c
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/path.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `PATH`.
+# Please instead update this file by running `bin/tapioca dsl PATH`.
+
+
+class PATH
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def each(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/pkg_version.rbi b/Library/Homebrew/sorbet/rbi/dsl/pkg_version.rbi
new file mode 100644
index 0000000000000..a3a57114d297d
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/pkg_version.rbi
@@ -0,0 +1,23 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `PkgVersion`.
+# Please instead update this file by running `bin/tapioca dsl PkgVersion`.
+
+
+class PkgVersion
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def major(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def major_minor(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def major_minor_patch(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def minor(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def patch(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/requirement.rbi b/Library/Homebrew/sorbet/rbi/dsl/requirement.rbi
new file mode 100644
index 0000000000000..e755f8ef2492e
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/requirement.rbi
@@ -0,0 +1,19 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Requirement`.
+# Please instead update this file by running `bin/tapioca dsl Requirement`.
+
+
+class Requirement
+  class << self
+    sig { params(arg: T.untyped).returns(T.untyped) }
+    def cask(arg = nil); end
+
+    sig { params(arg: T.untyped).returns(T.untyped) }
+    def download(arg = nil); end
+
+    sig { params(arg: T.untyped).returns(T.untyped) }
+    def fatal(arg = nil); end
+  end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/resource_stage_context.rbi b/Library/Homebrew/sorbet/rbi/dsl/resource_stage_context.rbi
new file mode 100644
index 0000000000000..74beb32c183e7
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/resource_stage_context.rbi
@@ -0,0 +1,29 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `ResourceStageContext`.
+# Please instead update this file by running `bin/tapioca dsl ResourceStageContext`.
+
+
+class ResourceStageContext
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def mirrors(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def retain!(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def source_modified_time(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def specs(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def url(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def using(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def version(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cask/ast/cask_block.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cask/ast/cask_block.rbi
new file mode 100644
index 0000000000000..f018145a54de4
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cask/ast/cask_block.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cask::AST::CaskBlock`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cask::AST::CaskBlock`.
+
+
+class RuboCop::Cask::AST::CaskBlock
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def cask_body(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cask/ast/stanza.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cask/ast/stanza.rbi
new file mode 100644
index 0000000000000..0d0b3a1d2318e
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cask/ast/stanza.rbi
@@ -0,0 +1,23 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cask::AST::Stanza`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cask::AST::Stanza`.
+
+
+class RuboCop::Cask::AST::Stanza
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def arch_variable?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T::Boolean) }
+  def on_system_block?(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def parent_node(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def source(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def source_with_comments(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/on_desc_stanza.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/on_desc_stanza.rbi
new file mode 100644
index 0000000000000..738033eb688e6
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/on_desc_stanza.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Cask::OnDescStanza`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Cask::OnDescStanza`.
+
+
+module RuboCop::Cop::Cask::OnDescStanza
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def toplevel_stanzas(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/on_homepage_stanza.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/on_homepage_stanza.rbi
new file mode 100644
index 0000000000000..7b79b7afd8dad
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/on_homepage_stanza.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Cask::OnHomepageStanza`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Cask::OnHomepageStanza`.
+
+
+module RuboCop::Cop::Cask::OnHomepageStanza
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def toplevel_stanzas(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/on_system_conditionals.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/on_system_conditionals.rbi
new file mode 100644
index 0000000000000..2e9e23d8f37a5
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/on_system_conditionals.rbi
@@ -0,0 +1,14 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Cask::OnSystemConditionals`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Cask::OnSystemConditionals`.
+
+
+class RuboCop::Cop::Cask::OnSystemConditionals
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def cask_body(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def toplevel_stanzas(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/on_url_stanza.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/on_url_stanza.rbi
new file mode 100644
index 0000000000000..dc95164e2b24c
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/on_url_stanza.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Cask::OnUrlStanza`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Cask::OnUrlStanza`.
+
+
+module RuboCop::Cop::Cask::OnUrlStanza
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def toplevel_stanzas(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/stanza_grouping.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/stanza_grouping.rbi
new file mode 100644
index 0000000000000..e0f1e73ea6a56
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/stanza_grouping.rbi
@@ -0,0 +1,14 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Cask::StanzaGrouping`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Cask::StanzaGrouping`.
+
+
+class RuboCop::Cop::Cask::StanzaGrouping
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def cask_node(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def toplevel_stanzas(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/variables.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/variables.rbi
new file mode 100644
index 0000000000000..0a98151863272
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/cask/variables.rbi
@@ -0,0 +1,21 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Cask::Variables`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Cask::Variables`.
+
+
+class RuboCop::Cop::Cask::Variables
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def cask_node(*args, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def variable_assignment(node, *pattern, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/assert_statements.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/assert_statements.rbi
new file mode 100644
index 0000000000000..5e8f9ee4ec576
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/assert_statements.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::AssertStatements`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::AssertStatements`.
+
+
+class RuboCop::Cop::FormulaAudit::AssertStatements; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/class_inheritance.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/class_inheritance.rbi
new file mode 100644
index 0000000000000..d5be430a99c4c
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/class_inheritance.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::ClassInheritance`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::ClassInheritance`.
+
+
+class RuboCop::Cop::FormulaAudit::ClassInheritance; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/class_name.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/class_name.rbi
new file mode 100644
index 0000000000000..9a36ff4696e52
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/class_name.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::ClassName`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::ClassName`.
+
+
+class RuboCop::Cop::FormulaAudit::ClassName; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/comments.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/comments.rbi
new file mode 100644
index 0000000000000..28d3f06d36d03
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/comments.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Comments`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Comments`.
+
+
+class RuboCop::Cop::FormulaAudit::Comments; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/components_order.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/components_order.rbi
new file mode 100644
index 0000000000000..11e2f4d008791
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/components_order.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::ComponentsOrder`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::ComponentsOrder`.
+
+
+class RuboCop::Cop::FormulaAudit::ComponentsOrder
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def depends_on_node?(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/dependency_order.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/dependency_order.rbi
new file mode 100644
index 0000000000000..3b6e005f3ce1b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/dependency_order.rbi
@@ -0,0 +1,84 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::DependencyOrder`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::DependencyOrder`.
+
+
+class RuboCop::Cop::FormulaAudit::DependencyOrder
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def build_with_dependency_node(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T::Boolean)
+  end
+  def buildtime_dependency?(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def dependency_name_node(node, *pattern, **kwargs, &block); end
+
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def depends_on_node?(node, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T::Boolean)
+  end
+  def negate_normal_dependency?(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T::Boolean)
+  end
+  def optional_dependency?(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T::Boolean)
+  end
+  def recommended_dependency?(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T::Boolean)
+  end
+  def test_dependency?(node, *pattern, **kwargs, &block); end
+
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def uses_from_macos_node?(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_date.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_date.rbi
new file mode 100644
index 0000000000000..59de044d50c3c
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_date.rbi
@@ -0,0 +1,18 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::DeprecateDisableDate`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::DeprecateDisableDate`.
+
+
+class RuboCop::Cop::FormulaAudit::DeprecateDisableDate
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def date(node, *pattern, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_reason.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_reason.rbi
new file mode 100644
index 0000000000000..ed977a09bf00b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/deprecate_disable_reason.rbi
@@ -0,0 +1,18 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::DeprecateDisableReason`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::DeprecateDisableReason`.
+
+
+class RuboCop::Cop::FormulaAudit::DeprecateDisableReason
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def reason(node, *pattern, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/generate_completions_dsl.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/generate_completions_dsl.rbi
new file mode 100644
index 0000000000000..2f13d41418b43
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/generate_completions_dsl.rbi
@@ -0,0 +1,28 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL`.
+
+
+class RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def correctable_shell_completion_node(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def shell_completion_node(node, *pattern, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/git_urls.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/git_urls.rbi
new file mode 100644
index 0000000000000..e0f1bbc65ca28
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/git_urls.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::GitUrls`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::GitUrls`.
+
+
+class RuboCop::Cop::FormulaAudit::GitUrls
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def url_has_revision?(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/license_arrays.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/license_arrays.rbi
new file mode 100644
index 0000000000000..a0851948126ca
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/license_arrays.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::LicenseArrays`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::LicenseArrays`.
+
+
+class RuboCop::Cop::FormulaAudit::LicenseArrays; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/licenses.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/licenses.rbi
new file mode 100644
index 0000000000000..403bf477c03da
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/licenses.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Licenses`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Licenses`.
+
+
+class RuboCop::Cop::FormulaAudit::Licenses
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def license_exception?(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/lines.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/lines.rbi
new file mode 100644
index 0000000000000..dfa8a71f10e71
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/lines.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Lines`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Lines`.
+
+
+class RuboCop::Cop::FormulaAudit::Lines; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/mac_os_on_linux.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/mac_os_on_linux.rbi
new file mode 100644
index 0000000000000..12944203ead57
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/mac_os_on_linux.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::MacOSOnLinux`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::MacOSOnLinux`.
+
+
+class RuboCop::Cop::FormulaAudit::MacOSOnLinux; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/miscellaneous.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/miscellaneous.rbi
new file mode 100644
index 0000000000000..4590441837cc8
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/miscellaneous.rbi
@@ -0,0 +1,34 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Miscellaneous`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Miscellaneous`.
+
+
+class RuboCop::Cop::FormulaAudit::Miscellaneous
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def conditional_dependencies(node, *pattern, **kwargs, &block); end
+
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def destructure_hash(node, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def formula_path_strings(node, *pattern, **kwargs, &block); end
+
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def hash_dep(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/mpi_check.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/mpi_check.rbi
new file mode 100644
index 0000000000000..5d5bc52307086
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/mpi_check.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::MpiCheck`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::MpiCheck`.
+
+
+class RuboCop::Cop::FormulaAudit::MpiCheck; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/on_system_conditionals.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/on_system_conditionals.rbi
new file mode 100644
index 0000000000000..a8fa9bffdc216
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/on_system_conditionals.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::OnSystemConditionals`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::OnSystemConditionals`.
+
+
+class RuboCop::Cop::FormulaAudit::OnSystemConditionals; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/option_declarations.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/option_declarations.rbi
new file mode 100644
index 0000000000000..ce3a97992cb8c
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/option_declarations.rbi
@@ -0,0 +1,18 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::OptionDeclarations`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::OptionDeclarations`.
+
+
+class RuboCop::Cop::FormulaAudit::OptionDeclarations
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def depends_on_build_with(node, *pattern, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/patches.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/patches.rbi
new file mode 100644
index 0000000000000..f2527d167e5b8
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/patches.rbi
@@ -0,0 +1,18 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Patches`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Patches`.
+
+
+class RuboCop::Cop::FormulaAudit::Patches
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T::Boolean)
+  end
+  def patch_data?(node, *pattern, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/py_pi_urls.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/py_pi_urls.rbi
new file mode 100644
index 0000000000000..5178d64a44bea
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/py_pi_urls.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::PyPiUrls`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::PyPiUrls`.
+
+
+class RuboCop::Cop::FormulaAudit::PyPiUrls; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/pyoxidizer_check.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/pyoxidizer_check.rbi
new file mode 100644
index 0000000000000..915fed6b88dd6
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/pyoxidizer_check.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::PyoxidizerCheck`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::PyoxidizerCheck`.
+
+
+class RuboCop::Cop::FormulaAudit::PyoxidizerCheck; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/python_versions.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/python_versions.rbi
new file mode 100644
index 0000000000000..06111f9a28c39
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/python_versions.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::PythonVersions`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::PythonVersions`.
+
+
+class RuboCop::Cop::FormulaAudit::PythonVersions; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/quic_tls_check.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/quic_tls_check.rbi
new file mode 100644
index 0000000000000..6d280fd0c5e52
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/quic_tls_check.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::QuicTLSCheck`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::QuicTLSCheck`.
+
+
+class RuboCop::Cop::FormulaAudit::QuicTLSCheck; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/safe_popen_commands.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/safe_popen_commands.rbi
new file mode 100644
index 0000000000000..8d56ed5e1ed16
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/safe_popen_commands.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::SafePopenCommands`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::SafePopenCommands`.
+
+
+class RuboCop::Cop::FormulaAudit::SafePopenCommands; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/shell_variables.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/shell_variables.rbi
new file mode 100644
index 0000000000000..f95c8e1096a08
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/shell_variables.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::ShellVariables`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::ShellVariables`.
+
+
+class RuboCop::Cop::FormulaAudit::ShellVariables; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/single_generate_completions_dsl_call.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/single_generate_completions_dsl_call.rbi
new file mode 100644
index 0000000000000..f00c56577eb3b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/single_generate_completions_dsl_call.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::SingleGenerateCompletionsDSLCall`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::SingleGenerateCompletionsDSLCall`.
+
+
+class RuboCop::Cop::FormulaAudit::SingleGenerateCompletionsDSLCall; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/std_npm_args.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/std_npm_args.rbi
new file mode 100644
index 0000000000000..53d3abafcbccf
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/std_npm_args.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::StdNpmArgs`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::StdNpmArgs`.
+
+
+class RuboCop::Cop::FormulaAudit::StdNpmArgs; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/test.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/test.rbi
new file mode 100644
index 0000000000000..104a2609b08be
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/test.rbi
@@ -0,0 +1,18 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Test`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Test`.
+
+
+class RuboCop::Cop::FormulaAudit::Test
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def test_calls(node, *pattern, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/text.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/text.rbi
new file mode 100644
index 0000000000000..6107e5dc64c86
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/text.rbi
@@ -0,0 +1,18 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Text`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Text`.
+
+
+class RuboCop::Cop::FormulaAudit::Text
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def prefix_path(node, *pattern, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/urls.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/urls.rbi
new file mode 100644
index 0000000000000..e9e002cd5623b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit/urls.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAudit::Urls`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAudit::Urls`.
+
+
+class RuboCop::Cop::FormulaAudit::Urls; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/git_urls.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/git_urls.rbi
new file mode 100644
index 0000000000000..1fb85b464e75d
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/git_urls.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAuditStrict::GitUrls`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAuditStrict::GitUrls`.
+
+
+class RuboCop::Cop::FormulaAuditStrict::GitUrls
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def url_has_tag?(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/make_check.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/make_check.rbi
new file mode 100644
index 0000000000000..f757bd0bdc617
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/make_check.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAuditStrict::MakeCheck`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAuditStrict::MakeCheck`.
+
+
+class RuboCop::Cop::FormulaAuditStrict::MakeCheck; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/requirements.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/requirements.rbi
new file mode 100644
index 0000000000000..6a835f3c39d61
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/requirements.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAuditStrict::Requirements`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAuditStrict::Requirements`.
+
+
+class RuboCop::Cop::FormulaAuditStrict::Requirements; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/rust_check.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/rust_check.rbi
new file mode 100644
index 0000000000000..4a48a5ac892b9
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/rust_check.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAuditStrict::RustCheck`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAuditStrict::RustCheck`.
+
+
+class RuboCop::Cop::FormulaAuditStrict::RustCheck; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/test_present.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/test_present.rbi
new file mode 100644
index 0000000000000..dcb027f2d07cb
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/test_present.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAuditStrict::TestPresent`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAuditStrict::TestPresent`.
+
+
+class RuboCop::Cop::FormulaAuditStrict::TestPresent; end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/text.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/text.rbi
new file mode 100644
index 0000000000000..7a0b12502c576
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_audit_strict/text.rbi
@@ -0,0 +1,38 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaAuditStrict::Text`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaAuditStrict::Text`.
+
+
+class RuboCop::Cop::FormulaAuditStrict::Text
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def interpolated_bin_path_starts_with(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def interpolated_share_path_starts_with(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def share_path_starts_with(node, *pattern, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi
new file mode 100644
index 0000000000000..e5811ec47cf6b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/formula_cop.rbi
@@ -0,0 +1,48 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::FormulaCop`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::FormulaCop`.
+
+
+class RuboCop::Cop::FormulaCop
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T::Boolean)
+  end
+  def dependency_name_hash_match?(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T::Boolean)
+  end
+  def dependency_type_hash_match?(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T::Boolean)
+  end
+  def required_dependency?(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T::Boolean)
+  end
+  def required_dependency_name?(node, *pattern, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/blank.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/blank.rbi
new file mode 100644
index 0000000000000..1b39cab98c81c
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/blank.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::Blank`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::Blank`.
+
+
+class RuboCop::Cop::Homebrew::Blank
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def nil_or_empty?(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/compact_blank.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/compact_blank.rbi
new file mode 100644
index 0000000000000..2f1cd574c8b18
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/compact_blank.rbi
@@ -0,0 +1,14 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::CompactBlank`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::CompactBlank`.
+
+
+class RuboCop::Cop::Homebrew::CompactBlank
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def reject_with_block?(node, **kwargs, &block); end
+
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def reject_with_block_pass?(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/move_to_extend_os.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/move_to_extend_os.rbi
new file mode 100644
index 0000000000000..dabed747e4271
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/move_to_extend_os.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::MoveToExtendOS`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::MoveToExtendOS`.
+
+
+class RuboCop::Cop::Homebrew::MoveToExtendOS
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def os_check?(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/negate_include.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/negate_include.rbi
new file mode 100644
index 0000000000000..f1f1ee1b6651e
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/negate_include.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::NegateInclude`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::NegateInclude`.
+
+
+class RuboCop::Cop::Homebrew::NegateInclude
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def negate_include_call?(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/no_fileutils_rmrf.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/no_fileutils_rmrf.rbi
new file mode 100644
index 0000000000000..b6d9c6a094994
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/no_fileutils_rmrf.rbi
@@ -0,0 +1,20 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::NoFileutilsRmrf`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::NoFileutilsRmrf`.
+
+
+class RuboCop::Cop::Homebrew::NoFileutilsRmrf
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def any_receiver_rm_r_f?(node, **kwargs, &block); end
+
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def any_receiver_rmtree?(node, **kwargs, &block); end
+
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def no_receiver_rm_r_f?(node, **kwargs, &block); end
+
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def no_receiver_rmtree?(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/presence.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/presence.rbi
new file mode 100644
index 0000000000000..b3781be0af485
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/presence.rbi
@@ -0,0 +1,14 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::Presence`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::Presence`.
+
+
+class RuboCop::Cop::Homebrew::Presence
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def redundant_negative_receiver_and_other(node, **kwargs, &block); end
+
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def redundant_receiver_and_other(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/present.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/present.rbi
new file mode 100644
index 0000000000000..8166f53efa83e
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/present.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::Present`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::Present`.
+
+
+class RuboCop::Cop::Homebrew::Present
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def exists_and_not_empty?(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/safe_navigation_with_blank.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/safe_navigation_with_blank.rbi
new file mode 100644
index 0000000000000..91e4e37b8207b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/homebrew/safe_navigation_with_blank.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::Homebrew::SafeNavigationWithBlank`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::Homebrew::SafeNavigationWithBlank`.
+
+
+class RuboCop::Cop::Homebrew::SafeNavigationWithBlank
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def safe_navigation_blank_in_conditional?(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/on_system_conditionals_helper.rbi b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/on_system_conditionals_helper.rbi
new file mode 100644
index 0000000000000..548ad707b27b1
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/rubo_cop/cop/on_system_conditionals_helper.rbi
@@ -0,0 +1,64 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `RuboCop::Cop::OnSystemConditionalsHelper`.
+# Please instead update this file by running `bin/tapioca dsl RuboCop::Cop::OnSystemConditionalsHelper`.
+
+
+module RuboCop::Cop::OnSystemConditionalsHelper
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def hardware_cpu_search(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def if_arch_node_search(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def if_base_os_node_search(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def if_macos_version_node_search(node, *pattern, **kwargs, &block); end
+
+  sig do
+    params(
+      node: RuboCop::AST::Node,
+      pattern: T.any(String, Symbol),
+      kwargs: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def macos_version_comparison_search(node, *pattern, **kwargs, &block); end
+
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def on_macos_version_method_call(node, **kwargs, &block); end
+
+  sig { params(node: RuboCop::AST::Node, kwargs: T.untyped, block: T.untyped).returns(T.untyped) }
+  def on_system_method_call(node, **kwargs, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/software_spec.rbi b/Library/Homebrew/sorbet/rbi/dsl/software_spec.rbi
new file mode 100644
index 0000000000000..7901841a4fb54
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/software_spec.rbi
@@ -0,0 +1,53 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `SoftwareSpec`.
+# Please instead update this file by running `bin/tapioca dsl SoftwareSpec`.
+
+
+class SoftwareSpec
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def cached_download(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def checksum(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def clear_cache(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def download_name(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def downloader(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def fetch(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def mirror(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def mirrors(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def sha256(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def source_modified_time(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def specs(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def stage(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def using(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def verify_download_integrity(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def version(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/system_command.rbi b/Library/Homebrew/sorbet/rbi/dsl/system_command.rbi
new file mode 100644
index 0000000000000..e2e8a6a2aab67
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/system_command.rbi
@@ -0,0 +1,20 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `SystemCommand`.
+# Please instead update this file by running `bin/tapioca dsl SystemCommand`.
+
+
+class SystemCommand
+  sig { returns(T::Boolean) }
+  def must_succeed?; end
+
+  sig { returns(T::Boolean) }
+  def reset_uid?; end
+
+  sig { returns(T::Boolean) }
+  def sudo?; end
+
+  sig { returns(T::Boolean) }
+  def sudo_as_root?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/tty.rbi b/Library/Homebrew/sorbet/rbi/dsl/tty.rbi
new file mode 100644
index 0000000000000..49fc2de4160bc
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/tty.rbi
@@ -0,0 +1,67 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Tty`.
+# Please instead update this file by running `bin/tapioca dsl Tty`.
+
+
+module Tty
+  class << self
+    sig { returns(String) }
+    def blue; end
+
+    sig { returns(String) }
+    def bold; end
+
+    sig { returns(String) }
+    def cyan; end
+
+    sig { returns(String) }
+    def default; end
+
+    sig { returns(String) }
+    def down; end
+
+    sig { returns(String) }
+    def erase_char; end
+
+    sig { returns(String) }
+    def erase_line; end
+
+    sig { returns(String) }
+    def green; end
+
+    sig { returns(String) }
+    def italic; end
+
+    sig { returns(String) }
+    def left; end
+
+    sig { returns(String) }
+    def magenta; end
+
+    sig { returns(String) }
+    def no_underline; end
+
+    sig { returns(String) }
+    def red; end
+
+    sig { returns(String) }
+    def reset; end
+
+    sig { returns(String) }
+    def right; end
+
+    sig { returns(String) }
+    def strikethrough; end
+
+    sig { returns(String) }
+    def underline; end
+
+    sig { returns(String) }
+    def up; end
+
+    sig { returns(String) }
+    def yellow; end
+  end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/utils/ast/formula_ast.rbi b/Library/Homebrew/sorbet/rbi/dsl/utils/ast/formula_ast.rbi
new file mode 100644
index 0000000000000..0c02809ef63ef
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/utils/ast/formula_ast.rbi
@@ -0,0 +1,11 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `Utils::AST::FormulaAST`.
+# Please instead update this file by running `bin/tapioca dsl Utils::AST::FormulaAST`.
+
+
+class Utils::AST::FormulaAST
+  sig { params(args: T.untyped, block: T.untyped).returns(T.untyped) }
+  def process(*args, &block); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/dsl/xcode_requirement.rbi b/Library/Homebrew/sorbet/rbi/dsl/xcode_requirement.rbi
new file mode 100644
index 0000000000000..6a812e438dc23
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/dsl/xcode_requirement.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `XcodeRequirement`.
+# Please instead update this file by running `bin/tapioca dsl XcodeRequirement`.
+
+
+class XcodeRequirement; end
diff --git a/Library/Homebrew/sorbet/rbi/gems/.gitattributes b/Library/Homebrew/sorbet/rbi/gems/.gitattributes
new file mode 100644
index 0000000000000..d9bb82a4de2cf
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/.gitattributes
@@ -0,0 +1 @@
+**/*.rbi linguist-generated=true
diff --git a/Library/Homebrew/sorbet/rbi/gems/activesupport@6.1.6.1.rbi b/Library/Homebrew/sorbet/rbi/gems/activesupport@6.1.6.1.rbi
deleted file mode 100644
index f6a0423fa58ff..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/activesupport@6.1.6.1.rbi
+++ /dev/null
@@ -1,3578 +0,0 @@
-# typed: false
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `activesupport` gem.
-# Please instead update this file by running `bin/tapioca gem activesupport`.
-
-::RUBY19 = T.let(T.unsafe(nil), TrueClass)
-
-module ActiveSupport
-  extend ::ActiveSupport::LazyLoadHooks
-  extend ::ActiveSupport::Autoload
-
-  def parse_json_times; end
-  def parse_json_times=(val); end
-  def test_order; end
-  def test_order=(val); end
-
-  class << self
-    def eager_load!; end
-    def escape_html_entities_in_json(*args, &block); end
-    def escape_html_entities_in_json=(arg); end
-    def gem_version; end
-    def json_encoder(*args, &block); end
-    def json_encoder=(arg); end
-    def parse_json_times; end
-    def parse_json_times=(val); end
-    def test_order; end
-    def test_order=(val); end
-    def time_precision(*args, &block); end
-    def time_precision=(arg); end
-    def to_time_preserves_timezone; end
-    def to_time_preserves_timezone=(value); end
-    def use_standard_json_time_format(*args, &block); end
-    def use_standard_json_time_format=(arg); end
-    def utc_to_local_returns_utc_offset_times; end
-    def utc_to_local_returns_utc_offset_times=(value); end
-    def version; end
-  end
-end
-
-module ActiveSupport::ActionableError
-  extend ::ActiveSupport::Concern
-  include GeneratedInstanceMethods
-
-  mixes_in_class_methods GeneratedClassMethods
-  mixes_in_class_methods ::ActiveSupport::ActionableError::ClassMethods
-
-  class << self
-    def actions(error); end
-    def dispatch(error, name); end
-  end
-
-  module GeneratedClassMethods
-    def _actions; end
-    def _actions=(value); end
-    def _actions?; end
-  end
-
-  module GeneratedInstanceMethods
-    def _actions; end
-    def _actions=(value); end
-    def _actions?; end
-  end
-end
-
-module ActiveSupport::ActionableError::ClassMethods
-  def action(name, &block); end
-end
-
-class ActiveSupport::ActionableError::NonActionable < ::StandardError; end
-
-class ActiveSupport::ArrayInquirer < ::Array
-  def any?(*candidates); end
-
-  private
-
-  def method_missing(name, *args); end
-  def respond_to_missing?(name, include_private = T.unsafe(nil)); end
-end
-
-module ActiveSupport::Autoload
-  def autoload(const_name, path = T.unsafe(nil)); end
-  def autoload_at(path); end
-  def autoload_under(path); end
-  def autoloads; end
-  def eager_autoload; end
-  def eager_load!; end
-
-  class << self
-    def extended(base); end
-  end
-end
-
-class ActiveSupport::BacktraceCleaner
-  def initialize; end
-
-  def add_filter(&block); end
-  def add_silencer(&block); end
-  def clean(backtrace, kind = T.unsafe(nil)); end
-  def filter(backtrace, kind = T.unsafe(nil)); end
-  def remove_filters!; end
-  def remove_silencers!; end
-
-  private
-
-  def add_gem_filter; end
-  def add_gem_silencer; end
-  def add_stdlib_silencer; end
-  def filter_backtrace(backtrace); end
-  def noise(backtrace); end
-  def silence(backtrace); end
-end
-
-ActiveSupport::BacktraceCleaner::FORMATTED_GEMS_PATTERN = T.let(T.unsafe(nil), Regexp)
-
-module ActiveSupport::Benchmarkable
-  def benchmark(message = T.unsafe(nil), options = T.unsafe(nil)); end
-end
-
-module ActiveSupport::BigDecimalWithDefaultFormat
-  def to_s(format = T.unsafe(nil)); end
-end
-
-module ActiveSupport::Cache
-  class << self
-    def expand_cache_key(key, namespace = T.unsafe(nil)); end
-    def lookup_store(store = T.unsafe(nil), *parameters); end
-
-    private
-
-    def retrieve_cache_key(key); end
-    def retrieve_store_class(store); end
-  end
-end
-
-class ActiveSupport::Cache::Entry
-  def initialize(value, compress: T.unsafe(nil), compress_threshold: T.unsafe(nil), version: T.unsafe(nil), expires_in: T.unsafe(nil), **_arg5); end
-
-  def bytesize; end
-  def dup_value!; end
-  def expired?; end
-  def expires_at; end
-  def expires_at=(value); end
-  def mismatched?(version); end
-  def value; end
-  def version; end
-
-  private
-
-  def compress!(compress_threshold); end
-  def compressed?; end
-  def uncompress(value); end
-end
-
-ActiveSupport::Cache::Entry::DEFAULT_COMPRESS_LIMIT = T.let(T.unsafe(nil), Integer)
-
-class ActiveSupport::Cache::FileStore < ::ActiveSupport::Cache::Store
-  include ::ActiveSupport::Cache::Strategy::LocalCache
-
-  def initialize(cache_path, **options); end
-
-  def cache_path; end
-
-  private
-
-  def delete_empty_directories(dir); end
-  def ensure_cache_path(path); end
-  def file_path_key(path); end
-  def lock_file(file_name, &block); end
-  def modify_value(name, amount, options); end
-  def normalize_key(key, options); end
-  def search_dir(dir, &callback); end
-
-  class << self
-    def supports_cache_versioning?; end
-  end
-end
-
-ActiveSupport::Cache::FileStore::DIR_FORMATTER = T.let(T.unsafe(nil), String)
-ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE = T.let(T.unsafe(nil), Integer)
-ActiveSupport::Cache::FileStore::FILEPATH_MAX_SIZE = T.let(T.unsafe(nil), Integer)
-ActiveSupport::Cache::FileStore::GITKEEP_FILES = T.let(T.unsafe(nil), Array)
-
-class ActiveSupport::Cache::MemoryStore < ::ActiveSupport::Cache::Store
-  def initialize(options = T.unsafe(nil)); end
-
-  def cleanup(options = T.unsafe(nil)); end
-  def clear(options = T.unsafe(nil)); end
-  def decrement(name, amount = T.unsafe(nil), options = T.unsafe(nil)); end
-  def delete_matched(matcher, options = T.unsafe(nil)); end
-  def increment(name, amount = T.unsafe(nil), options = T.unsafe(nil)); end
-  def inspect; end
-  def prune(target_size, max_time = T.unsafe(nil)); end
-  def pruning?; end
-  def synchronize(&block); end
-
-  private
-
-  def cached_size(key, payload); end
-  def delete_entry(key, **options); end
-  def modify_value(name, amount, options); end
-  def read_entry(key, **options); end
-  def write_entry(key, entry, **options); end
-
-  class << self
-    def supports_cache_versioning?; end
-  end
-end
-
-ActiveSupport::Cache::MemoryStore::DEFAULT_CODER = ActiveSupport::Cache::MemoryStore::DupCoder
-
-module ActiveSupport::Cache::MemoryStore::DupCoder
-  class << self
-    def dump(entry); end
-    def load(entry); end
-  end
-end
-
-ActiveSupport::Cache::MemoryStore::PER_ENTRY_OVERHEAD = T.let(T.unsafe(nil), Integer)
-
-module ActiveSupport::Cache::NullCoder
-  class << self
-    def dump(entry); end
-    def load(payload); end
-  end
-end
-
-class ActiveSupport::Cache::NullStore < ::ActiveSupport::Cache::Store
-  include ::ActiveSupport::Cache::Strategy::LocalCache
-
-  class << self
-    def supports_cache_versioning?; end
-  end
-end
-
-class ActiveSupport::Cache::Store
-  def initialize(options = T.unsafe(nil)); end
-
-  def cleanup(options = T.unsafe(nil)); end
-  def clear(options = T.unsafe(nil)); end
-  def decrement(name, amount = T.unsafe(nil), options = T.unsafe(nil)); end
-  def delete(name, options = T.unsafe(nil)); end
-  def delete_matched(matcher, options = T.unsafe(nil)); end
-  def delete_multi(names, options = T.unsafe(nil)); end
-  def exist?(name, options = T.unsafe(nil)); end
-  def fetch(name, options = T.unsafe(nil), &block); end
-  def fetch_multi(*names); end
-  def increment(name, amount = T.unsafe(nil), options = T.unsafe(nil)); end
-  def logger; end
-  def logger=(val); end
-  def mute; end
-  def options; end
-  def read(name, options = T.unsafe(nil)); end
-  def read_multi(*names); end
-  def silence; end
-  def silence!; end
-  def silence?; end
-  def write(name, value, options = T.unsafe(nil)); end
-  def write_multi(hash, options = T.unsafe(nil)); end
-
-  private
-
-  def delete_entry(key, **options); end
-  def delete_multi_entries(entries, **options); end
-  def deserialize_entry(payload); end
-  def expanded_key(key); end
-  def expanded_version(key); end
-  def get_entry_value(entry, name, options); end
-  def handle_expired_entry(entry, key, options); end
-  def instrument(operation, key, options = T.unsafe(nil)); end
-  def key_matcher(pattern, options); end
-  def merged_options(call_options); end
-  def namespace_key(key, options = T.unsafe(nil)); end
-  def normalize_key(key, options = T.unsafe(nil)); end
-  def normalize_version(key, options = T.unsafe(nil)); end
-  def read_entry(key, **options); end
-  def read_multi_entries(names, **options); end
-  def save_block_result_to_cache(name, options); end
-  def serialize_entry(entry); end
-  def write_entry(key, entry, **options); end
-  def write_multi_entries(hash, **options); end
-
-  class << self
-    def logger; end
-    def logger=(val); end
-
-    private
-
-    def ensure_connection_pool_added!; end
-    def retrieve_pool_options(options); end
-  end
-end
-
-ActiveSupport::Cache::Store::DEFAULT_CODER = Marshal
-module ActiveSupport::Cache::Strategy; end
-
-module ActiveSupport::Cache::Strategy::LocalCache
-  def cleanup(**options); end
-  def clear(**options); end
-  def decrement(name, amount = T.unsafe(nil), **options); end
-  def delete_matched(matcher, options = T.unsafe(nil)); end
-  def increment(name, amount = T.unsafe(nil), **options); end
-  def middleware; end
-  def with_local_cache; end
-
-  private
-
-  def bypass_local_cache; end
-  def delete_entry(key, **options); end
-  def local_cache; end
-  def local_cache_key; end
-  def read_entry(key, **options); end
-  def read_multi_entries(keys, **options); end
-  def use_temporary_local_cache(temporary_cache); end
-  def write_cache_value(name, value, **options); end
-  def write_entry(key, entry, **options); end
-end
-
-class ActiveSupport::Cache::Strategy::LocalCache::LocalCacheRegistry
-  extend ::ActiveSupport::PerThreadRegistry
-
-  def initialize; end
-
-  def cache_for(local_cache_key); end
-  def set_cache_for(local_cache_key, value); end
-
-  class << self
-    def cache_for(l); end
-    def set_cache_for(l, v); end
-  end
-end
-
-class ActiveSupport::Cache::Strategy::LocalCache::LocalStore < ::ActiveSupport::Cache::Store
-  def initialize; end
-
-  def clear(options = T.unsafe(nil)); end
-  def delete_entry(key, **options); end
-  def fetch_entry(key, options = T.unsafe(nil)); end
-  def read_entry(key, **options); end
-  def read_multi_entries(keys, **options); end
-  def synchronize; end
-  def write_entry(key, entry, **options); end
-end
-
-class ActiveSupport::Cache::Strategy::LocalCache::Middleware
-  def initialize(name, local_cache_key); end
-
-  def call(env); end
-  def local_cache_key; end
-  def name; end
-  def new(app); end
-end
-
-ActiveSupport::Cache::UNIVERSAL_OPTIONS = T.let(T.unsafe(nil), Array)
-
-class ActiveSupport::CachingKeyGenerator
-  def initialize(key_generator); end
-
-  def generate_key(*args); end
-end
-
-module ActiveSupport::Callbacks
-  extend ::ActiveSupport::Concern
-  include GeneratedInstanceMethods
-
-  mixes_in_class_methods GeneratedClassMethods
-  mixes_in_class_methods ::ActiveSupport::Callbacks::ClassMethods
-  mixes_in_class_methods ::ActiveSupport::DescendantsTracker
-
-  def run_callbacks(kind); end
-
-  private
-
-  def halted_callback_hook(filter, name); end
-
-  module GeneratedClassMethods
-    def __callbacks; end
-    def __callbacks=(value); end
-    def __callbacks?; end
-  end
-
-  module GeneratedInstanceMethods
-    def __callbacks; end
-    def __callbacks?; end
-  end
-end
-
-ActiveSupport::Callbacks::CALLBACK_FILTER_TYPES = T.let(T.unsafe(nil), Array)
-
-class ActiveSupport::Callbacks::CallTemplate
-  def initialize(target, method, arguments, block); end
-
-  def expand(target, value, block); end
-  def inverted_lambda; end
-  def make_lambda; end
-
-  class << self
-    def build(filter, callback); end
-  end
-end
-
-class ActiveSupport::Callbacks::Callback
-  def initialize(name, filter, kind, options, chain_config); end
-
-  def apply(callback_sequence); end
-  def chain_config; end
-  def current_scopes; end
-  def duplicates?(other); end
-  def filter; end
-  def kind; end
-  def kind=(_arg0); end
-  def matches?(_kind, _filter); end
-  def merge_conditional_options(chain, if_option:, unless_option:); end
-  def name; end
-  def name=(_arg0); end
-  def raw_filter; end
-
-  private
-
-  def check_conditionals(conditionals); end
-  def compute_identifier(filter); end
-  def conditions_lambdas; end
-
-  class << self
-    def build(chain, filter, kind, options); end
-  end
-end
-
-ActiveSupport::Callbacks::Callback::EMPTY_ARRAY = T.let(T.unsafe(nil), Array)
-
-class ActiveSupport::Callbacks::CallbackChain
-  include ::Enumerable
-
-  def initialize(name, config); end
-
-  def append(*callbacks); end
-  def clear; end
-  def compile; end
-  def config; end
-  def delete(o); end
-  def each(&block); end
-  def empty?; end
-  def index(o); end
-  def insert(index, o); end
-  def name; end
-  def prepend(*callbacks); end
-
-  protected
-
-  def chain; end
-
-  private
-
-  def append_one(callback); end
-  def default_terminator; end
-  def initialize_copy(other); end
-  def prepend_one(callback); end
-  def remove_duplicates(callback); end
-end
-
-class ActiveSupport::Callbacks::CallbackSequence
-  def initialize(nested = T.unsafe(nil), call_template = T.unsafe(nil), user_conditions = T.unsafe(nil)); end
-
-  def after(&after); end
-  def around(call_template, user_conditions); end
-  def before(&before); end
-  def expand_call_template(arg, block); end
-  def final?; end
-  def invoke_after(arg); end
-  def invoke_before(arg); end
-  def nested; end
-  def skip?(arg); end
-end
-
-module ActiveSupport::Callbacks::ClassMethods
-  def __update_callbacks(name); end
-  def define_callbacks(*names); end
-  def normalize_callback_params(filters, block); end
-  def reset_callbacks(name); end
-  def set_callback(name, *filter_list, &block); end
-  def skip_callback(name, *filter_list, &block); end
-
-  protected
-
-  def get_callbacks(name); end
-  def set_callbacks(name, callbacks); end
-end
-
-module ActiveSupport::Callbacks::Conditionals; end
-
-class ActiveSupport::Callbacks::Conditionals::Value
-  def initialize(&block); end
-
-  def call(target, value); end
-end
-
-module ActiveSupport::Callbacks::Filters; end
-
-class ActiveSupport::Callbacks::Filters::After
-  class << self
-    def build(callback_sequence, user_callback, user_conditions, chain_config); end
-
-    private
-
-    def conditional(callback_sequence, user_callback, user_conditions); end
-    def halting(callback_sequence, user_callback); end
-    def halting_and_conditional(callback_sequence, user_callback, user_conditions); end
-    def simple(callback_sequence, user_callback); end
-  end
-end
-
-class ActiveSupport::Callbacks::Filters::Before
-  class << self
-    def build(callback_sequence, user_callback, user_conditions, chain_config, filter, name); end
-
-    private
-
-    def halting(callback_sequence, user_callback, halted_lambda, filter, name); end
-    def halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter, name); end
-  end
-end
-
-class ActiveSupport::Callbacks::Filters::Environment < ::Struct
-  def halted; end
-  def halted=(_); end
-  def target; end
-  def target=(_); end
-  def value; end
-  def value=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-module ActiveSupport::Concern
-  def append_features(base); end
-  def class_methods(&class_methods_module_definition); end
-  def included(base = T.unsafe(nil), &block); end
-  def prepend_features(base); end
-  def prepended(base = T.unsafe(nil), &block); end
-
-  class << self
-    def extended(base); end
-  end
-end
-
-class ActiveSupport::Concern::MultipleIncludedBlocks < ::StandardError
-  def initialize; end
-end
-
-class ActiveSupport::Concern::MultiplePrependBlocks < ::StandardError
-  def initialize; end
-end
-
-module ActiveSupport::Concurrency; end
-
-class ActiveSupport::Concurrency::ShareLock
-  include ::MonitorMixin
-
-  def initialize; end
-
-  def exclusive(purpose: T.unsafe(nil), compatible: T.unsafe(nil), after_compatible: T.unsafe(nil), no_wait: T.unsafe(nil)); end
-  def raw_state; end
-  def sharing; end
-  def start_exclusive(purpose: T.unsafe(nil), compatible: T.unsafe(nil), no_wait: T.unsafe(nil)); end
-  def start_sharing; end
-  def stop_exclusive(compatible: T.unsafe(nil)); end
-  def stop_sharing; end
-  def yield_shares(purpose: T.unsafe(nil), compatible: T.unsafe(nil), block_share: T.unsafe(nil)); end
-
-  private
-
-  def busy_for_exclusive?(purpose); end
-  def busy_for_sharing?(purpose); end
-  def eligible_waiters?(compatible); end
-  def wait_for(method); end
-end
-
-module ActiveSupport::Configurable
-  extend ::ActiveSupport::Concern
-
-  mixes_in_class_methods ::ActiveSupport::Configurable::ClassMethods
-
-  def config; end
-end
-
-module ActiveSupport::Configurable::ClassMethods
-  def config; end
-  def configure; end
-
-  private
-
-  def config_accessor(*names, instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil)); end
-end
-
-class ActiveSupport::Configurable::Configuration < ::ActiveSupport::InheritableOptions
-  def compile_methods!; end
-
-  class << self
-    def compile_methods!(keys); end
-  end
-end
-
-class ActiveSupport::ConfigurationFile
-  def initialize(content_path); end
-
-  def parse(context: T.unsafe(nil), **options); end
-
-  private
-
-  def read(content_path); end
-  def render(context); end
-
-  class << self
-    def parse(content_path, **options); end
-  end
-end
-
-class ActiveSupport::ConfigurationFile::FormatError < ::StandardError; end
-
-class ActiveSupport::CurrentAttributes
-  include ::ActiveSupport::Callbacks
-  extend ::ActiveSupport::Callbacks::ClassMethods
-  extend ::ActiveSupport::DescendantsTracker
-
-  def initialize; end
-
-  def __callbacks; end
-  def __callbacks?; end
-  def _reset_callbacks; end
-  def _run_reset_callbacks(&block); end
-  def attributes; end
-  def attributes=(_arg0); end
-  def reset; end
-  def set(set_attributes); end
-
-  private
-
-  def assign_attributes(new_attributes); end
-  def compute_attributes(keys); end
-
-  class << self
-    def __callbacks; end
-    def __callbacks=(value); end
-    def __callbacks?; end
-    def _reset_callbacks; end
-    def _reset_callbacks=(value); end
-    def after_reset(&block); end
-    def attribute(*names); end
-    def before_reset(&block); end
-    def clear_all; end
-    def instance; end
-    def reset(*args, &block); end
-    def reset_all; end
-    def resets(&block); end
-    def set(*args, &block); end
-
-    private
-
-    def current_instances; end
-    def current_instances_key; end
-    def generated_attribute_methods; end
-    def method_missing(name, *args, &block); end
-  end
-end
-
-module ActiveSupport::Dependencies
-  extend ::ActiveSupport::Dependencies
-
-  def _eager_load_paths; end
-  def _eager_load_paths=(val); end
-  def autoload_module!(into, const_name, qualified_name, path_suffix); end
-  def autoload_once_paths; end
-  def autoload_once_paths=(val); end
-  def autoload_paths; end
-  def autoload_paths=(val); end
-  def autoloadable_module?(path_suffix); end
-  def autoloaded?(desc); end
-  def autoloaded_constants; end
-  def autoloaded_constants=(val); end
-  def clear; end
-  def constant_watch_stack; end
-  def constant_watch_stack=(val); end
-  def constantize(name); end
-  def depend_on(file_name, message = T.unsafe(nil)); end
-  def explicitly_unloadable_constants; end
-  def explicitly_unloadable_constants=(val); end
-  def history; end
-  def history=(val); end
-  def hook!; end
-  def interlock; end
-  def interlock=(val); end
-  def load?; end
-  def load_file(path, const_paths = T.unsafe(nil)); end
-  def load_missing_constant(from_mod, const_name); end
-  def load_once_path?(path); end
-  def loadable_constants_for_path(path, bases = T.unsafe(nil)); end
-  def loaded; end
-  def loaded=(val); end
-  def loading; end
-  def loading=(val); end
-  def log(message); end
-  def logger; end
-  def logger=(val); end
-  def mark_for_unload(const_desc); end
-  def mechanism; end
-  def mechanism=(val); end
-  def new_constants_in(*descs); end
-  def qualified_const_defined?(path); end
-  def qualified_name_for(mod, name); end
-  def reference(klass); end
-  def remove_constant(const); end
-  def remove_unloadable_constants!; end
-  def require_or_load(file_name, const_path = T.unsafe(nil)); end
-  def safe_constantize(name); end
-  def search_for_file(path_suffix); end
-  def to_constant_name(desc); end
-  def unhook!; end
-  def verbose; end
-  def verbose=(val); end
-  def warnings_on_first_load; end
-  def warnings_on_first_load=(val); end
-  def will_unload?(const_desc); end
-
-  private
-
-  def real_mod_name(mod); end
-  def uninitialized_constant(qualified_name, const_name, receiver:); end
-
-  class << self
-    def _eager_load_paths; end
-    def _eager_load_paths=(val); end
-    def autoload_once_paths; end
-    def autoload_once_paths=(val); end
-    def autoload_paths; end
-    def autoload_paths=(val); end
-    def autoloaded_constants; end
-    def autoloaded_constants=(val); end
-    def constant_watch_stack; end
-    def constant_watch_stack=(val); end
-    def explicitly_unloadable_constants; end
-    def explicitly_unloadable_constants=(val); end
-    def history; end
-    def history=(val); end
-    def interlock; end
-    def interlock=(val); end
-    def load_interlock; end
-    def loaded; end
-    def loaded=(val); end
-    def loading; end
-    def loading=(val); end
-    def logger; end
-    def logger=(val); end
-    def mechanism; end
-    def mechanism=(val); end
-    def run_interlock; end
-    def unload_interlock; end
-    def verbose; end
-    def verbose=(val); end
-    def warnings_on_first_load; end
-    def warnings_on_first_load=(val); end
-  end
-end
-
-module ActiveSupport::Dependencies::Blamable
-  def blame_file!(file); end
-  def blamed_files; end
-  def copy_blame!(exc); end
-  def describe_blame; end
-end
-
-class ActiveSupport::Dependencies::ClassCache
-  def initialize; end
-
-  def [](key); end
-  def clear!; end
-  def empty?; end
-  def get(key); end
-  def key?(key); end
-  def safe_get(key); end
-  def store(klass); end
-end
-
-class ActiveSupport::Dependencies::Interlock
-  def initialize; end
-
-  def done_running; end
-  def done_unloading; end
-  def loading; end
-  def permit_concurrent_loads; end
-  def raw_state(&block); end
-  def running; end
-  def start_running; end
-  def start_unloading; end
-  def unloading; end
-end
-
-module ActiveSupport::Dependencies::Loadable
-  def load_dependency(file); end
-  def require_dependency(file_name, message = T.unsafe(nil)); end
-  def require_or_load(file_name); end
-  def unloadable(const_desc); end
-
-  private
-
-  def load(file, wrap = T.unsafe(nil)); end
-  def require(file); end
-
-  class << self
-    def exclude_from(base); end
-    def include_into(base); end
-  end
-end
-
-module ActiveSupport::Dependencies::ModuleConstMissing
-  def const_missing(const_name); end
-  def guess_for_anonymous(const_name); end
-  def unloadable(const_desc = T.unsafe(nil)); end
-
-  class << self
-    def append_features(base); end
-    def exclude_from(base); end
-    def include_into(base); end
-  end
-end
-
-ActiveSupport::Dependencies::Reference = T.let(T.unsafe(nil), ActiveSupport::Dependencies::ClassCache)
-ActiveSupport::Dependencies::UNBOUND_METHOD_MODULE_NAME = T.let(T.unsafe(nil), UnboundMethod)
-
-class ActiveSupport::Dependencies::WatchStack
-  include ::Enumerable
-
-  def initialize; end
-
-  def each(&block); end
-  def new_constants; end
-  def watch_namespaces(namespaces); end
-  def watching; end
-  def watching?; end
-
-  private
-
-  def pop_modules(modules); end
-end
-
-class ActiveSupport::Deprecation
-  include ::Singleton
-  include ::ActiveSupport::Deprecation::InstanceDelegator
-  include ::ActiveSupport::Deprecation::Behavior
-  include ::ActiveSupport::Deprecation::Reporting
-  include ::ActiveSupport::Deprecation::Disallowed
-  include ::ActiveSupport::Deprecation::MethodWrapper
-  extend ::Singleton::SingletonClassMethods
-  extend ::ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
-  extend ::ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
-
-  def initialize(deprecation_horizon = T.unsafe(nil), gem_name = T.unsafe(nil)); end
-
-  def deprecation_horizon; end
-  def deprecation_horizon=(_arg0); end
-
-  class << self
-    def allow(*args, &block); end
-    def behavior(*args, &block); end
-    def behavior=(arg); end
-    def debug(*args, &block); end
-    def debug=(arg); end
-    def deprecate_methods(*args, &block); end
-    def deprecation_horizon(*args, &block); end
-    def deprecation_horizon=(arg); end
-    def disallowed_behavior(*args, &block); end
-    def disallowed_behavior=(arg); end
-    def disallowed_warnings(*args, &block); end
-    def disallowed_warnings=(arg); end
-    def gem_name(*args, &block); end
-    def gem_name=(arg); end
-    def instance; end
-    def silence(*args, &block); end
-    def silenced(*args, &block); end
-    def silenced=(arg); end
-  end
-end
-
-module ActiveSupport::Deprecation::Behavior
-  def behavior; end
-  def behavior=(behavior); end
-  def debug; end
-  def debug=(_arg0); end
-  def disallowed_behavior; end
-  def disallowed_behavior=(behavior); end
-
-  private
-
-  def arity_coerce(behavior); end
-end
-
-ActiveSupport::Deprecation::DEFAULT_BEHAVIORS = T.let(T.unsafe(nil), Hash)
-
-module ActiveSupport::Deprecation::DeprecatedConstantAccessor
-  class << self
-    def included(base); end
-  end
-end
-
-class ActiveSupport::Deprecation::DeprecatedConstantProxy < ::Module
-  def initialize(old_const, new_const, deprecator = T.unsafe(nil), message: T.unsafe(nil)); end
-
-  def class; end
-  def hash(*args, &block); end
-  def inspect; end
-  def instance_methods(*args, &block); end
-  def name(*args, &block); end
-  def respond_to?(*args, &block); end
-
-  private
-
-  def const_missing(name); end
-  def method_missing(called, *args, &block); end
-  def target; end
-
-  class << self
-    def new(*args, **options, &block); end
-  end
-end
-
-class ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy < ::ActiveSupport::Deprecation::DeprecationProxy
-  def initialize(instance, method, var = T.unsafe(nil), deprecator = T.unsafe(nil)); end
-
-  private
-
-  def target; end
-  def warn(callstack, called, args); end
-end
-
-class ActiveSupport::Deprecation::DeprecatedObjectProxy < ::ActiveSupport::Deprecation::DeprecationProxy
-  def initialize(object, message, deprecator = T.unsafe(nil)); end
-
-  private
-
-  def target; end
-  def warn(callstack, called, args); end
-end
-
-class ActiveSupport::Deprecation::DeprecationProxy
-  def inspect; end
-
-  private
-
-  def method_missing(called, *args, &block); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-module ActiveSupport::Deprecation::Disallowed
-  def disallowed_warnings; end
-  def disallowed_warnings=(_arg0); end
-
-  private
-
-  def deprecation_disallowed?(message); end
-  def explicitly_allowed?(message); end
-end
-
-module ActiveSupport::Deprecation::InstanceDelegator
-  mixes_in_class_methods ::ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
-  mixes_in_class_methods ::ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
-
-  class << self
-    def included(base); end
-  end
-end
-
-module ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
-  def include(included_module); end
-  def method_added(method_name); end
-end
-
-module ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
-  def deprecation_warning(deprecated_method_name, message = T.unsafe(nil), caller_backtrace = T.unsafe(nil)); end
-  def warn(message = T.unsafe(nil), callstack = T.unsafe(nil)); end
-end
-
-module ActiveSupport::Deprecation::MethodWrapper
-  def deprecate_methods(target_module, *method_names); end
-end
-
-module ActiveSupport::Deprecation::Reporting
-  def allow(allowed_warnings = T.unsafe(nil), if: T.unsafe(nil), &block); end
-  def deprecation_warning(deprecated_method_name, message = T.unsafe(nil), caller_backtrace = T.unsafe(nil)); end
-  def gem_name; end
-  def gem_name=(_arg0); end
-  def silence(&block); end
-  def silenced; end
-  def silenced=(_arg0); end
-  def warn(message = T.unsafe(nil), callstack = T.unsafe(nil)); end
-
-  private
-
-  def _extract_callstack(callstack); end
-  def deprecated_method_warning(method_name, message = T.unsafe(nil)); end
-  def deprecation_caller_message(callstack); end
-  def deprecation_message(callstack, message = T.unsafe(nil)); end
-  def extract_callstack(callstack); end
-  def ignored_callstack(path); end
-end
-
-ActiveSupport::Deprecation::Reporting::RAILS_GEM_ROOT = T.let(T.unsafe(nil), String)
-class ActiveSupport::DeprecationException < ::StandardError; end
-
-module ActiveSupport::DescendantsTracker
-  def descendants; end
-  def direct_descendants; end
-  def inherited(base); end
-  def subclasses; end
-
-  class << self
-    def clear; end
-    def descendants(klass); end
-    def direct_descendants(klass); end
-    def store_inherited(klass, descendant); end
-    def subclasses(klass); end
-
-    private
-
-    def accumulate_descendants(klass, acc); end
-  end
-end
-
-class ActiveSupport::DescendantsTracker::DescendantsArray
-  include ::Enumerable
-
-  def initialize; end
-
-  def <<(klass); end
-  def cleanup!; end
-  def each; end
-  def refs_size; end
-  def reject!; end
-
-  private
-
-  def initialize_copy(orig); end
-end
-
-class ActiveSupport::Digest
-  class << self
-    def hash_digest_class; end
-    def hash_digest_class=(klass); end
-    def hexdigest(arg); end
-  end
-end
-
-class ActiveSupport::Duration
-  def initialize(value, parts); end
-
-  def %(other); end
-  def *(other); end
-  def +(other); end
-  def +@; end
-  def -(other); end
-  def -@; end
-  def /(other); end
-  def <=>(other); end
-  def ==(other); end
-  def after(time = T.unsafe(nil)); end
-  def ago(time = T.unsafe(nil)); end
-  def as_json(options = T.unsafe(nil)); end
-  def before(time = T.unsafe(nil)); end
-  def coerce(other); end
-  def encode_with(coder); end
-  def eql?(other); end
-  def from_now(time = T.unsafe(nil)); end
-  def hash; end
-  def in_days; end
-  def in_hours; end
-  def in_minutes; end
-  def in_months; end
-  def in_seconds; end
-  def in_weeks; end
-  def in_years; end
-  def init_with(coder); end
-  def inspect; end
-  def instance_of?(klass); end
-  def is_a?(klass); end
-  def iso8601(precision: T.unsafe(nil)); end
-  def kind_of?(klass); end
-  def parts; end
-  def parts=(_arg0); end
-  def since(time = T.unsafe(nil)); end
-  def to_i; end
-  def to_s; end
-  def until(time = T.unsafe(nil)); end
-  def value; end
-  def value=(_arg0); end
-
-  private
-
-  def method_missing(method, *args, &block); end
-  def raise_type_error(other); end
-  def respond_to_missing?(method, _); end
-  def sum(sign, time = T.unsafe(nil)); end
-
-  class << self
-    def ===(other); end
-    def build(value); end
-    def days(value); end
-    def hours(value); end
-    def minutes(value); end
-    def months(value); end
-    def parse(iso8601duration); end
-    def seconds(value); end
-    def weeks(value); end
-    def years(value); end
-
-    private
-
-    def calculate_total_seconds(parts); end
-  end
-end
-
-class ActiveSupport::Duration::ISO8601Parser
-  def initialize(string); end
-
-  def mode; end
-  def mode=(_arg0); end
-  def parse!; end
-  def parts; end
-  def scanner; end
-  def sign; end
-  def sign=(_arg0); end
-
-  private
-
-  def finished?; end
-  def number; end
-  def raise_parsing_error(reason = T.unsafe(nil)); end
-  def scan(pattern); end
-  def validate!; end
-end
-
-ActiveSupport::Duration::ISO8601Parser::COMMA = T.let(T.unsafe(nil), String)
-ActiveSupport::Duration::ISO8601Parser::DATE_COMPONENT = T.let(T.unsafe(nil), Regexp)
-ActiveSupport::Duration::ISO8601Parser::DATE_COMPONENTS = T.let(T.unsafe(nil), Array)
-ActiveSupport::Duration::ISO8601Parser::DATE_MARKER = T.let(T.unsafe(nil), Regexp)
-ActiveSupport::Duration::ISO8601Parser::DATE_TO_PART = T.let(T.unsafe(nil), Hash)
-ActiveSupport::Duration::ISO8601Parser::PERIOD = T.let(T.unsafe(nil), String)
-ActiveSupport::Duration::ISO8601Parser::PERIOD_OR_COMMA = T.let(T.unsafe(nil), Regexp)
-class ActiveSupport::Duration::ISO8601Parser::ParsingError < ::ArgumentError; end
-ActiveSupport::Duration::ISO8601Parser::SIGN_MARKER = T.let(T.unsafe(nil), Regexp)
-ActiveSupport::Duration::ISO8601Parser::TIME_COMPONENT = T.let(T.unsafe(nil), Regexp)
-ActiveSupport::Duration::ISO8601Parser::TIME_COMPONENTS = T.let(T.unsafe(nil), Array)
-ActiveSupport::Duration::ISO8601Parser::TIME_MARKER = T.let(T.unsafe(nil), Regexp)
-ActiveSupport::Duration::ISO8601Parser::TIME_TO_PART = T.let(T.unsafe(nil), Hash)
-
-class ActiveSupport::Duration::ISO8601Serializer
-  def initialize(duration, precision: T.unsafe(nil)); end
-
-  def serialize; end
-
-  private
-
-  def normalize; end
-  def week_mixed_with_date?(parts); end
-end
-
-ActiveSupport::Duration::ISO8601Serializer::DATE_COMPONENTS = T.let(T.unsafe(nil), Array)
-ActiveSupport::Duration::PARTS = T.let(T.unsafe(nil), Array)
-ActiveSupport::Duration::PARTS_IN_SECONDS = T.let(T.unsafe(nil), Hash)
-ActiveSupport::Duration::SECONDS_PER_DAY = T.let(T.unsafe(nil), Integer)
-ActiveSupport::Duration::SECONDS_PER_HOUR = T.let(T.unsafe(nil), Integer)
-ActiveSupport::Duration::SECONDS_PER_MINUTE = T.let(T.unsafe(nil), Integer)
-ActiveSupport::Duration::SECONDS_PER_MONTH = T.let(T.unsafe(nil), Integer)
-ActiveSupport::Duration::SECONDS_PER_WEEK = T.let(T.unsafe(nil), Integer)
-ActiveSupport::Duration::SECONDS_PER_YEAR = T.let(T.unsafe(nil), Integer)
-
-class ActiveSupport::Duration::Scalar < ::Numeric
-  def initialize(value); end
-
-  def %(other); end
-  def *(other); end
-  def +(other); end
-  def -(other); end
-  def -@; end
-  def /(other); end
-  def <=>(other); end
-  def coerce(other); end
-  def to_f(*args, &block); end
-  def to_i(*args, &block); end
-  def to_s(*args, &block); end
-  def value; end
-
-  private
-
-  def calculate(op, other); end
-  def raise_type_error(other); end
-end
-
-class ActiveSupport::EnvironmentInquirer < ::ActiveSupport::StringInquirer
-  def initialize(env); end
-
-  def development?; end
-  def production?; end
-  def test?; end
-end
-
-ActiveSupport::EnvironmentInquirer::DEFAULT_ENVIRONMENTS = T.let(T.unsafe(nil), Array)
-
-class ActiveSupport::ExecutionWrapper
-  include ::ActiveSupport::Callbacks
-  extend ::ActiveSupport::Callbacks::ClassMethods
-  extend ::ActiveSupport::DescendantsTracker
-
-  def __callbacks; end
-  def __callbacks?; end
-  def _complete_callbacks; end
-  def _run_callbacks; end
-  def _run_complete_callbacks(&block); end
-  def _run_run_callbacks(&block); end
-  def complete!; end
-  def run!; end
-
-  private
-
-  def hook_state; end
-
-  class << self
-    def __callbacks; end
-    def __callbacks=(value); end
-    def __callbacks?; end
-    def _complete_callbacks; end
-    def _complete_callbacks=(value); end
-    def _run_callbacks; end
-    def _run_callbacks=(value); end
-    def active; end
-    def active=(_arg0); end
-    def active?; end
-    def inherited(other); end
-    def register_hook(hook, outer: T.unsafe(nil)); end
-    def run!(reset: T.unsafe(nil)); end
-    def to_complete(*args, &block); end
-    def to_run(*args, &block); end
-    def wrap; end
-  end
-end
-
-class ActiveSupport::ExecutionWrapper::CompleteHook < ::Struct
-  def after(target); end
-  def before(target); end
-  def hook; end
-  def hook=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-ActiveSupport::ExecutionWrapper::Null = T.let(T.unsafe(nil), Object)
-
-class ActiveSupport::ExecutionWrapper::RunHook < ::Struct
-  def before(target); end
-  def hook; end
-  def hook=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class ActiveSupport::Executor < ::ActiveSupport::ExecutionWrapper; end
-
-class ActiveSupport::FileUpdateChecker
-  def initialize(files, dirs = T.unsafe(nil), &block); end
-
-  def execute; end
-  def execute_if_updated; end
-  def updated?; end
-
-  private
-
-  def compile_ext(array); end
-  def compile_glob(hash); end
-  def escape(key); end
-  def max_mtime(paths); end
-  def updated_at(paths); end
-  def watched; end
-end
-
-module ActiveSupport::ForkTracker
-  class << self
-    def after_fork(&block); end
-    def check!; end
-    def hook!; end
-    def unregister(callback); end
-  end
-end
-
-module ActiveSupport::ForkTracker::CoreExt
-  def fork(*_arg0); end
-end
-
-module ActiveSupport::ForkTracker::CoreExtPrivate
-  private
-
-  def fork(*_arg0); end
-end
-
-module ActiveSupport::Gzip
-  class << self
-    def compress(source, level = T.unsafe(nil), strategy = T.unsafe(nil)); end
-    def decompress(source); end
-  end
-end
-
-class ActiveSupport::Gzip::Stream < ::StringIO
-  def initialize(*_arg0); end
-
-  def close; end
-end
-
-module ActiveSupport::Inflector
-  extend ::ActiveSupport::Inflector
-
-  def camelize(term, uppercase_first_letter = T.unsafe(nil)); end
-  def classify(table_name); end
-  def constantize(camel_cased_word); end
-  def dasherize(underscored_word); end
-  def deconstantize(path); end
-  def demodulize(path); end
-  def foreign_key(class_name, separate_class_name_and_id_with_underscore = T.unsafe(nil)); end
-  def humanize(lower_case_and_underscored_word, capitalize: T.unsafe(nil), keep_id_suffix: T.unsafe(nil)); end
-  def inflections(locale = T.unsafe(nil)); end
-  def ordinal(number); end
-  def ordinalize(number); end
-  def parameterize(string, separator: T.unsafe(nil), preserve_case: T.unsafe(nil), locale: T.unsafe(nil)); end
-  def pluralize(word, locale = T.unsafe(nil)); end
-  def safe_constantize(camel_cased_word); end
-  def singularize(word, locale = T.unsafe(nil)); end
-  def tableize(class_name); end
-  def titleize(word, keep_id_suffix: T.unsafe(nil)); end
-  def transliterate(string, replacement = T.unsafe(nil), locale: T.unsafe(nil)); end
-  def underscore(camel_cased_word); end
-  def upcase_first(string); end
-
-  private
-
-  def apply_inflections(word, rules, locale = T.unsafe(nil)); end
-  def const_regexp(camel_cased_word); end
-end
-
-ActiveSupport::Inflector::ALLOWED_ENCODINGS_FOR_TRANSLITERATE = T.let(T.unsafe(nil), Array)
-
-class ActiveSupport::Inflector::Inflections
-  def initialize; end
-
-  def acronym(word); end
-  def acronyms; end
-  def acronyms_camelize_regex; end
-  def acronyms_underscore_regex; end
-  def clear(scope = T.unsafe(nil)); end
-  def human(rule, replacement); end
-  def humans; end
-  def irregular(singular, plural); end
-  def plural(rule, replacement); end
-  def plurals; end
-  def singular(rule, replacement); end
-  def singulars; end
-  def uncountable(*words); end
-  def uncountables; end
-
-  private
-
-  def define_acronym_regex_patterns; end
-  def initialize_dup(orig); end
-
-  class << self
-    def instance(locale = T.unsafe(nil)); end
-  end
-end
-
-class ActiveSupport::Inflector::Inflections::Uncountables < ::Array
-  def initialize; end
-
-  def <<(*word); end
-  def add(words); end
-  def delete(entry); end
-  def uncountable?(str); end
-
-  private
-
-  def to_regex(string); end
-end
-
-class ActiveSupport::InheritableOptions < ::ActiveSupport::OrderedOptions
-  def initialize(parent = T.unsafe(nil)); end
-
-  def inheritable_copy; end
-end
-
-module ActiveSupport::JSON
-  class << self
-    def decode(json); end
-    def encode(value, options = T.unsafe(nil)); end
-    def parse_error; end
-
-    private
-
-    def convert_dates_from(data); end
-  end
-end
-
-ActiveSupport::JSON::DATETIME_REGEX = T.let(T.unsafe(nil), Regexp)
-ActiveSupport::JSON::DATE_REGEX = T.let(T.unsafe(nil), Regexp)
-
-module ActiveSupport::JSON::Encoding
-  class << self
-    def escape_html_entities_in_json; end
-    def escape_html_entities_in_json=(_arg0); end
-    def json_encoder; end
-    def json_encoder=(_arg0); end
-    def time_precision; end
-    def time_precision=(_arg0); end
-    def use_standard_json_time_format; end
-    def use_standard_json_time_format=(_arg0); end
-  end
-end
-
-class ActiveSupport::JSON::Encoding::JSONGemEncoder
-  def initialize(options = T.unsafe(nil)); end
-
-  def encode(value); end
-  def options; end
-
-  private
-
-  def jsonify(value); end
-  def stringify(jsonified); end
-end
-
-ActiveSupport::JSON::Encoding::JSONGemEncoder::ESCAPED_CHARS = T.let(T.unsafe(nil), Hash)
-ActiveSupport::JSON::Encoding::JSONGemEncoder::ESCAPE_REGEX_WITHOUT_HTML_ENTITIES = T.let(T.unsafe(nil), Regexp)
-ActiveSupport::JSON::Encoding::JSONGemEncoder::ESCAPE_REGEX_WITH_HTML_ENTITIES = T.let(T.unsafe(nil), Regexp)
-
-class ActiveSupport::JSON::Encoding::JSONGemEncoder::EscapedString < ::String
-  def to_json(*_arg0); end
-  def to_s; end
-end
-
-class ActiveSupport::KeyGenerator
-  def initialize(secret, options = T.unsafe(nil)); end
-
-  def generate_key(salt, key_size = T.unsafe(nil)); end
-end
-
-module ActiveSupport::LazyLoadHooks
-  def on_load(name, options = T.unsafe(nil), &block); end
-  def run_load_hooks(name, base = T.unsafe(nil)); end
-
-  private
-
-  def execute_hook(name, base, options, block); end
-  def with_execution_control(name, block, once); end
-
-  class << self
-    def extended(base); end
-  end
-end
-
-class ActiveSupport::LogSubscriber < ::ActiveSupport::Subscriber
-  def colorize_logging; end
-  def colorize_logging=(val); end
-  def debug(progname = T.unsafe(nil), &block); end
-  def error(progname = T.unsafe(nil), &block); end
-  def fatal(progname = T.unsafe(nil), &block); end
-  def finish(name, id, payload); end
-  def info(progname = T.unsafe(nil), &block); end
-  def logger; end
-  def start(name, id, payload); end
-  def unknown(progname = T.unsafe(nil), &block); end
-  def warn(progname = T.unsafe(nil), &block); end
-
-  private
-
-  def color(text, color, bold = T.unsafe(nil)); end
-
-  class << self
-    def colorize_logging; end
-    def colorize_logging=(val); end
-    def flush_all!; end
-    def log_subscribers; end
-    def logger; end
-    def logger=(_arg0); end
-
-    private
-
-    def fetch_public_methods(subscriber, inherit_all); end
-  end
-end
-
-ActiveSupport::LogSubscriber::BLACK = T.let(T.unsafe(nil), String)
-ActiveSupport::LogSubscriber::BLUE = T.let(T.unsafe(nil), String)
-ActiveSupport::LogSubscriber::BOLD = T.let(T.unsafe(nil), String)
-ActiveSupport::LogSubscriber::CLEAR = T.let(T.unsafe(nil), String)
-ActiveSupport::LogSubscriber::CYAN = T.let(T.unsafe(nil), String)
-ActiveSupport::LogSubscriber::GREEN = T.let(T.unsafe(nil), String)
-ActiveSupport::LogSubscriber::MAGENTA = T.let(T.unsafe(nil), String)
-ActiveSupport::LogSubscriber::RED = T.let(T.unsafe(nil), String)
-ActiveSupport::LogSubscriber::WHITE = T.let(T.unsafe(nil), String)
-ActiveSupport::LogSubscriber::YELLOW = T.let(T.unsafe(nil), String)
-
-class ActiveSupport::Logger < ::Logger
-  include ::ActiveSupport::LoggerSilence
-  include ::ActiveSupport::LoggerThreadSafeLevel
-
-  def initialize(*args, **kwargs); end
-
-  def silencer; end
-  def silencer=(val); end
-
-  class << self
-    def broadcast(logger); end
-    def local_levels; end
-    def local_levels=(val); end
-    def logger_outputs_to?(logger, *sources); end
-    def silencer; end
-    def silencer=(val); end
-  end
-end
-
-class ActiveSupport::Logger::SimpleFormatter < ::Logger::Formatter
-  def call(severity, timestamp, progname, msg); end
-end
-
-module ActiveSupport::LoggerSilence
-  extend ::ActiveSupport::Concern
-  include ::ActiveSupport::LoggerThreadSafeLevel
-
-  def silence(severity = T.unsafe(nil)); end
-end
-
-module ActiveSupport::LoggerThreadSafeLevel
-  extend ::ActiveSupport::Concern
-
-  def add(severity, message = T.unsafe(nil), progname = T.unsafe(nil), &block); end
-  def debug?; end
-  def error?; end
-  def fatal?; end
-  def info?; end
-  def level; end
-  def local_level; end
-  def local_level=(level); end
-  def local_log_id; end
-  def log_at(level); end
-  def unknown?; end
-  def warn?; end
-end
-
-module ActiveSupport::MarshalWithAutoloading
-  def load(source, proc = T.unsafe(nil)); end
-end
-
-class ActiveSupport::MessageEncryptor
-  include ::ActiveSupport::Messages::Rotator
-  include ::ActiveSupport::Messages::Rotator::Encryptor
-
-  def encrypt_and_sign(value, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
-
-  private
-
-  def _decrypt(encrypted_message, purpose); end
-  def _encrypt(value, **metadata_options); end
-  def aead_mode?; end
-  def new_cipher; end
-  def resolve_verifier; end
-  def verifier; end
-
-  class << self
-    def default_cipher; end
-    def key_len(cipher = T.unsafe(nil)); end
-    def use_authenticated_message_encryption; end
-    def use_authenticated_message_encryption=(val); end
-  end
-end
-
-class ActiveSupport::MessageEncryptor::InvalidMessage < ::StandardError; end
-
-module ActiveSupport::MessageEncryptor::NullSerializer
-  class << self
-    def dump(value); end
-    def load(value); end
-  end
-end
-
-module ActiveSupport::MessageEncryptor::NullVerifier
-  class << self
-    def generate(value); end
-    def verify(value); end
-  end
-end
-
-ActiveSupport::MessageEncryptor::OpenSSLCipherError = OpenSSL::Cipher::CipherError
-
-class ActiveSupport::MessageVerifier
-  include ::ActiveSupport::Messages::Rotator
-  include ::ActiveSupport::Messages::Rotator::Verifier
-
-  def generate(value, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
-  def valid_message?(signed_message); end
-  def verify(*args, **options); end
-
-  private
-
-  def decode(data); end
-  def encode(data); end
-  def generate_digest(data); end
-end
-
-class ActiveSupport::MessageVerifier::InvalidSignature < ::StandardError; end
-module ActiveSupport::Messages; end
-
-class ActiveSupport::Messages::Metadata
-  def initialize(message, expires_at = T.unsafe(nil), purpose = T.unsafe(nil)); end
-
-  def as_json(options = T.unsafe(nil)); end
-  def verify(purpose); end
-
-  private
-
-  def fresh?; end
-  def match?(purpose); end
-  def parse_expires_at(expires_at); end
-
-  class << self
-    def verify(message, purpose); end
-    def wrap(message, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
-
-    private
-
-    def decode(message); end
-    def encode(message); end
-    def extract_metadata(message); end
-    def pick_expiry(expires_at, expires_in); end
-  end
-end
-
-module ActiveSupport::Messages::Rotator
-  def initialize(*secrets, on_rotation: T.unsafe(nil), **options); end
-
-  def rotate(*secrets, **options); end
-
-  private
-
-  def run_rotations(on_rotation); end
-end
-
-module ActiveSupport::Messages::Rotator::Encryptor
-  include ::ActiveSupport::Messages::Rotator
-
-  def decrypt_and_verify(*args, on_rotation: T.unsafe(nil), **options); end
-
-  private
-
-  def build_rotation(secret = T.unsafe(nil), sign_secret = T.unsafe(nil), options); end
-end
-
-module ActiveSupport::Messages::Rotator::Verifier
-  include ::ActiveSupport::Messages::Rotator
-
-  def verified(*args, on_rotation: T.unsafe(nil), **options); end
-
-  private
-
-  def build_rotation(secret = T.unsafe(nil), options); end
-end
-
-module ActiveSupport::Multibyte
-  class << self
-    def proxy_class; end
-    def proxy_class=(klass); end
-  end
-end
-
-class ActiveSupport::Multibyte::Chars
-  include ::Comparable
-
-  def initialize(string); end
-
-  def <=>(*args, &block); end
-  def =~(*args, &block); end
-  def acts_like_string?(*args, &block); end
-  def as_json(options = T.unsafe(nil)); end
-  def compose; end
-  def decompose; end
-  def grapheme_length; end
-  def limit(limit); end
-  def match?(*args, &block); end
-  def method_missing(method, *args, &block); end
-  def reverse; end
-  def reverse!(*args); end
-  def slice!(*args); end
-  def split(*args); end
-  def tidy_bytes(force = T.unsafe(nil)); end
-  def tidy_bytes!(*args); end
-  def titlecase; end
-  def titleize; end
-  def to_s; end
-  def to_str; end
-  def wrapped_string; end
-
-  private
-
-  def chars(string); end
-  def respond_to_missing?(method, include_private); end
-end
-
-module ActiveSupport::Multibyte::Unicode
-  extend ::ActiveSupport::Multibyte::Unicode
-
-  def compose(codepoints); end
-  def decompose(type, codepoints); end
-  def default_normalization_form; end
-  def default_normalization_form=(_); end
-  def tidy_bytes(string, force = T.unsafe(nil)); end
-
-  private
-
-  def recode_windows1252_chars(string); end
-end
-
-ActiveSupport::Multibyte::Unicode::UNICODE_VERSION = T.let(T.unsafe(nil), String)
-
-module ActiveSupport::Notifications
-  class << self
-    def instrument(name, payload = T.unsafe(nil)); end
-    def instrumenter; end
-    def monotonic_subscribe(pattern = T.unsafe(nil), callback = T.unsafe(nil), &block); end
-    def notifier; end
-    def notifier=(_arg0); end
-    def publish(name, *args); end
-    def subscribe(pattern = T.unsafe(nil), callback = T.unsafe(nil), &block); end
-    def subscribed(callback, pattern = T.unsafe(nil), monotonic: T.unsafe(nil), &block); end
-    def unsubscribe(subscriber_or_name); end
-  end
-end
-
-class ActiveSupport::Notifications::Event
-  def initialize(name, start, ending, transaction_id, payload); end
-
-  def <<(event); end
-  def allocations; end
-  def children; end
-  def cpu_time; end
-  def duration; end
-  def end; end
-  def finish!; end
-  def idle_time; end
-  def name; end
-  def parent_of?(event); end
-  def payload; end
-  def payload=(_arg0); end
-  def start!; end
-  def time; end
-  def transaction_id; end
-
-  private
-
-  def now; end
-  def now_allocations; end
-  def now_cpu; end
-end
-
-class ActiveSupport::Notifications::Fanout
-  include ::Mutex_m
-
-  def initialize; end
-
-  def finish(name, id, payload, listeners = T.unsafe(nil)); end
-  def listeners_for(name); end
-  def listening?(name); end
-  def lock; end
-  def locked?; end
-  def publish(name, *args); end
-  def start(name, id, payload); end
-  def subscribe(pattern = T.unsafe(nil), callable = T.unsafe(nil), monotonic: T.unsafe(nil), &block); end
-  def synchronize(&block); end
-  def try_lock; end
-  def unlock; end
-  def unsubscribe(subscriber_or_name); end
-  def wait; end
-end
-
-module ActiveSupport::Notifications::Fanout::Subscribers
-  class << self
-    def new(pattern, listener, monotonic); end
-    def wrap_all(pattern, subscriber); end
-  end
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::AllMessages
-  def initialize(delegate); end
-
-  def finish(name, id, payload); end
-  def matches?(_arg0); end
-  def publish(name, *args); end
-  def start(name, id, payload); end
-  def subscribed_to?(name); end
-  def unsubscribe!(*_arg0); end
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::EventObject < ::ActiveSupport::Notifications::Fanout::Subscribers::Evented
-  def finish(name, id, payload); end
-  def start(name, id, payload); end
-
-  private
-
-  def build_event(name, id, payload); end
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::Evented
-  def initialize(pattern, delegate); end
-
-  def finish(name, id, payload); end
-  def matches?(name); end
-  def pattern; end
-  def publish(name, *args); end
-  def start(name, id, payload); end
-  def subscribed_to?(name); end
-  def unsubscribe!(name); end
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::Matcher
-  def initialize(pattern); end
-
-  def ===(name); end
-  def exclusions; end
-  def pattern; end
-  def unsubscribe!(name); end
-
-  class << self
-    def wrap(pattern); end
-  end
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::MonotonicTimed < ::ActiveSupport::Notifications::Fanout::Subscribers::Evented
-  def finish(name, id, payload); end
-  def publish(name, *args); end
-  def start(name, id, payload); end
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::Timed < ::ActiveSupport::Notifications::Fanout::Subscribers::Evented
-  def finish(name, id, payload); end
-  def publish(name, *args); end
-  def start(name, id, payload); end
-end
-
-class ActiveSupport::Notifications::InstrumentationRegistry
-  extend ::ActiveSupport::PerThreadRegistry
-
-  def initialize; end
-
-  def instrumenter_for(notifier); end
-end
-
-class ActiveSupport::Notifications::Instrumenter
-  def initialize(notifier); end
-
-  def finish(name, payload); end
-  def finish_with_state(listeners_state, name, payload); end
-  def id; end
-  def instrument(name, payload = T.unsafe(nil)); end
-  def start(name, payload); end
-
-  private
-
-  def unique_id; end
-end
-
-module ActiveSupport::NumberHelper
-  extend ::ActiveSupport::Autoload
-  extend ::ActiveSupport::NumberHelper
-
-  def number_to_currency(number, options = T.unsafe(nil)); end
-  def number_to_delimited(number, options = T.unsafe(nil)); end
-  def number_to_human(number, options = T.unsafe(nil)); end
-  def number_to_human_size(number, options = T.unsafe(nil)); end
-  def number_to_percentage(number, options = T.unsafe(nil)); end
-  def number_to_phone(number, options = T.unsafe(nil)); end
-  def number_to_rounded(number, options = T.unsafe(nil)); end
-end
-
-class ActiveSupport::NumberHelper::NumberConverter
-  def initialize(number, options); end
-
-  def execute; end
-  def namespace; end
-  def namespace=(_arg0); end
-  def namespace?; end
-  def number; end
-  def opts; end
-  def validate_float; end
-  def validate_float=(_arg0); end
-  def validate_float?; end
-
-  private
-
-  def default_format_options; end
-  def default_value(key); end
-  def format_options; end
-  def i18n_format_options; end
-  def options; end
-  def translate_in_locale(key, **i18n_options); end
-  def translate_number_value_with_default(key, **i18n_options); end
-  def valid_float?; end
-
-  class << self
-    def convert(number, options); end
-    def namespace; end
-    def namespace=(value); end
-    def namespace?; end
-    def validate_float; end
-    def validate_float=(value); end
-    def validate_float?; end
-  end
-end
-
-ActiveSupport::NumberHelper::NumberConverter::DEFAULTS = T.let(T.unsafe(nil), Hash)
-
-class ActiveSupport::NumberHelper::NumberToCurrencyConverter < ::ActiveSupport::NumberHelper::NumberConverter
-  def convert; end
-
-  private
-
-  def i18n_opts; end
-  def options; end
-
-  class << self
-    def namespace; end
-  end
-end
-
-class ActiveSupport::NumberHelper::NumberToDelimitedConverter < ::ActiveSupport::NumberHelper::NumberConverter
-  def convert; end
-
-  private
-
-  def delimiter_pattern; end
-  def parts; end
-
-  class << self
-    def validate_float; end
-  end
-end
-
-ActiveSupport::NumberHelper::NumberToDelimitedConverter::DEFAULT_DELIMITER_REGEX = T.let(T.unsafe(nil), Regexp)
-
-class ActiveSupport::NumberHelper::NumberToHumanConverter < ::ActiveSupport::NumberHelper::NumberConverter
-  def convert; end
-
-  private
-
-  def calculate_exponent(units); end
-  def determine_unit(units, exponent); end
-  def format; end
-  def unit_exponents(units); end
-
-  class << self
-    def namespace; end
-    def validate_float; end
-  end
-end
-
-ActiveSupport::NumberHelper::NumberToHumanConverter::DECIMAL_UNITS = T.let(T.unsafe(nil), Hash)
-ActiveSupport::NumberHelper::NumberToHumanConverter::INVERTED_DECIMAL_UNITS = T.let(T.unsafe(nil), Hash)
-
-class ActiveSupport::NumberHelper::NumberToHumanSizeConverter < ::ActiveSupport::NumberHelper::NumberConverter
-  def convert; end
-
-  private
-
-  def base; end
-  def conversion_format; end
-  def exponent; end
-  def smaller_than_base?; end
-  def storage_unit_key; end
-  def unit; end
-
-  class << self
-    def namespace; end
-    def validate_float; end
-  end
-end
-
-ActiveSupport::NumberHelper::NumberToHumanSizeConverter::STORAGE_UNITS = T.let(T.unsafe(nil), Array)
-
-class ActiveSupport::NumberHelper::NumberToPercentageConverter < ::ActiveSupport::NumberHelper::NumberConverter
-  def convert; end
-
-  class << self
-    def namespace; end
-  end
-end
-
-class ActiveSupport::NumberHelper::NumberToPhoneConverter < ::ActiveSupport::NumberHelper::NumberConverter
-  def convert; end
-
-  private
-
-  def convert_to_phone_number(number); end
-  def convert_with_area_code(number); end
-  def convert_without_area_code(number); end
-  def country_code(code); end
-  def delimiter; end
-  def phone_ext(ext); end
-  def regexp_pattern(default_pattern); end
-  def start_with_delimiter?(number); end
-end
-
-class ActiveSupport::NumberHelper::NumberToRoundedConverter < ::ActiveSupport::NumberHelper::NumberConverter
-  def convert; end
-
-  private
-
-  def format_number(number); end
-  def strip_insignificant_zeros; end
-
-  class << self
-    def namespace; end
-    def validate_float; end
-  end
-end
-
-class ActiveSupport::NumberHelper::RoundingHelper
-  def initialize(options); end
-
-  def digit_count(number); end
-  def options; end
-  def round(number); end
-
-  private
-
-  def absolute_precision(number); end
-  def convert_to_decimal(number); end
-  def significant; end
-end
-
-class ActiveSupport::OptionMerger
-  def initialize(context, options); end
-
-  private
-
-  def invoke_method(method, arguments, options, &block); end
-  def method_missing(method, *arguments, &block); end
-end
-
-class ActiveSupport::OrderedHash < ::Hash
-  def encode_with(coder); end
-  def extractable_options?; end
-  def nested_under_indifferent_access; end
-  def reject(*args, &block); end
-  def select(*args, &block); end
-  def to_yaml_type; end
-end
-
-class ActiveSupport::OrderedOptions < ::Hash
-  def [](key); end
-  def []=(key, value); end
-  def extractable_options?; end
-  def inspect; end
-  def method_missing(name, *args); end
-
-  protected
-
-  def _get(_arg0); end
-
-  private
-
-  def respond_to_missing?(name, include_private); end
-end
-
-module ActiveSupport::PerThreadRegistry
-  def instance; end
-
-  private
-
-  def method_missing(name, *args, &block); end
-
-  class << self
-    def extended(object); end
-  end
-end
-
-class ActiveSupport::ProxyObject < ::BasicObject
-  def raise(*args); end
-end
-
-class ActiveSupport::Reloader < ::ActiveSupport::ExecutionWrapper
-  def initialize; end
-
-  def _class_unload_callbacks; end
-  def _prepare_callbacks; end
-  def _run_class_unload_callbacks(&block); end
-  def _run_prepare_callbacks(&block); end
-  def check; end
-  def check=(_arg0); end
-  def check?; end
-  def class_unload!(&block); end
-  def complete!; end
-  def executor; end
-  def executor=(_arg0); end
-  def executor?; end
-  def release_unload_lock!; end
-  def require_unload_lock!; end
-  def run!; end
-
-  class << self
-    def __callbacks; end
-    def _class_unload_callbacks; end
-    def _class_unload_callbacks=(value); end
-    def _prepare_callbacks; end
-    def _prepare_callbacks=(value); end
-    def after_class_unload(*args, &block); end
-    def before_class_unload(*args, &block); end
-    def check; end
-    def check!; end
-    def check=(value); end
-    def check?; end
-    def executor; end
-    def executor=(value); end
-    def executor?; end
-    def prepare!; end
-    def reload!; end
-    def reloaded!; end
-    def run!(reset: T.unsafe(nil)); end
-    def to_prepare(*args, &block); end
-    def wrap; end
-  end
-end
-
-module ActiveSupport::Rescuable
-  extend ::ActiveSupport::Concern
-  include GeneratedInstanceMethods
-
-  mixes_in_class_methods GeneratedClassMethods
-  mixes_in_class_methods ::ActiveSupport::Rescuable::ClassMethods
-
-  def handler_for_rescue(exception); end
-  def rescue_with_handler(exception); end
-
-  module GeneratedClassMethods
-    def rescue_handlers; end
-    def rescue_handlers=(value); end
-    def rescue_handlers?; end
-  end
-
-  module GeneratedInstanceMethods
-    def rescue_handlers; end
-    def rescue_handlers=(value); end
-    def rescue_handlers?; end
-  end
-end
-
-module ActiveSupport::Rescuable::ClassMethods
-  def handler_for_rescue(exception, object: T.unsafe(nil)); end
-  def rescue_from(*klasses, with: T.unsafe(nil), &block); end
-  def rescue_with_handler(exception, object: T.unsafe(nil), visited_exceptions: T.unsafe(nil)); end
-
-  private
-
-  def constantize_rescue_handler_class(class_or_name); end
-  def find_rescue_handler(exception); end
-end
-
-class ActiveSupport::SafeBuffer < ::String
-  def initialize(str = T.unsafe(nil)); end
-
-  def %(args); end
-  def *(*_arg0); end
-  def +(other); end
-  def <<(value); end
-  def [](*args); end
-  def []=(*args); end
-  def capitalize(*args, &block); end
-  def capitalize!(*args); end
-  def chomp(*args, &block); end
-  def chomp!(*args); end
-  def chop(*args, &block); end
-  def chop!(*args); end
-  def clone_empty; end
-  def concat(value); end
-  def delete(*args, &block); end
-  def delete!(*args); end
-  def delete_prefix(*args, &block); end
-  def delete_prefix!(*args); end
-  def delete_suffix(*args, &block); end
-  def delete_suffix!(*args); end
-  def downcase(*args, &block); end
-  def downcase!(*args); end
-  def encode_with(coder); end
-  def gsub(*args, &block); end
-  def gsub!(*args, &block); end
-  def html_safe?; end
-  def insert(index, value); end
-  def lstrip(*args, &block); end
-  def lstrip!(*args); end
-  def next(*args, &block); end
-  def next!(*args); end
-  def prepend(value); end
-  def replace(value); end
-  def reverse(*args, &block); end
-  def reverse!(*args); end
-  def rstrip(*args, &block); end
-  def rstrip!(*args); end
-  def safe_concat(value); end
-  def scrub(*args, &block); end
-  def scrub!(*args); end
-  def slice(*args, &block); end
-  def slice!(*args); end
-  def squeeze(*args, &block); end
-  def squeeze!(*args); end
-  def strip(*args, &block); end
-  def strip!(*args); end
-  def sub(*args, &block); end
-  def sub!(*args, &block); end
-  def succ(*args, &block); end
-  def succ!(*args); end
-  def swapcase(*args, &block); end
-  def swapcase!(*args); end
-  def to_param; end
-  def to_s; end
-  def tr(*args, &block); end
-  def tr!(*args); end
-  def tr_s(*args, &block); end
-  def tr_s!(*args); end
-  def unicode_normalize(*args, &block); end
-  def unicode_normalize!(*args); end
-  def upcase(*args, &block); end
-  def upcase!(*args); end
-
-  private
-
-  def html_escape_interpolated_argument(arg); end
-  def initialize_copy(other); end
-  def original_concat(*_arg0); end
-  def set_block_back_references(block, match_data); end
-end
-
-class ActiveSupport::SafeBuffer::SafeConcatError < ::StandardError
-  def initialize; end
-end
-
-ActiveSupport::SafeBuffer::UNSAFE_STRING_METHODS = T.let(T.unsafe(nil), Array)
-ActiveSupport::SafeBuffer::UNSAFE_STRING_METHODS_WITH_BACKREF = T.let(T.unsafe(nil), Array)
-
-class ActiveSupport::SecureCompareRotator
-  include ::ActiveSupport::Messages::Rotator
-  include ::ActiveSupport::SecurityUtils
-
-  def secure_compare!(other_value, on_rotation: T.unsafe(nil)); end
-
-  private
-
-  def build_rotation(previous_value, _options); end
-end
-
-class ActiveSupport::SecureCompareRotator::InvalidMatch < ::StandardError; end
-
-module ActiveSupport::SecurityUtils
-  private
-
-  def fixed_length_secure_compare(a, b); end
-  def secure_compare(a, b); end
-
-  class << self
-    def fixed_length_secure_compare(a, b); end
-    def secure_compare(a, b); end
-  end
-end
-
-class ActiveSupport::StringInquirer < ::String
-  private
-
-  def method_missing(method_name, *arguments); end
-  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
-end
-
-class ActiveSupport::Subscriber
-  def initialize; end
-
-  def finish(name, id, payload); end
-  def patterns; end
-  def start(name, id, payload); end
-
-  private
-
-  def event_stack; end
-
-  class << self
-    def attach_to(namespace, subscriber = T.unsafe(nil), notifier = T.unsafe(nil), inherit_all: T.unsafe(nil)); end
-    def detach_from(namespace, notifier = T.unsafe(nil)); end
-    def method_added(event); end
-    def subscribers; end
-
-    private
-
-    def add_event_subscriber(event); end
-    def fetch_public_methods(subscriber, inherit_all); end
-    def find_attached_subscriber; end
-    def invalid_event?(event); end
-    def namespace; end
-    def notifier; end
-    def pattern_subscribed?(pattern); end
-    def prepare_pattern(event); end
-    def remove_event_subscriber(event); end
-    def subscriber; end
-  end
-end
-
-class ActiveSupport::SubscriberQueueRegistry
-  extend ::ActiveSupport::PerThreadRegistry
-
-  def initialize; end
-
-  def get_queue(queue_key); end
-end
-
-module ActiveSupport::TaggedLogging
-  def clear_tags!(*args, &block); end
-  def flush; end
-  def pop_tags(*args, &block); end
-  def push_tags(*args, &block); end
-  def tagged(*tags); end
-
-  class << self
-    def new(logger); end
-  end
-end
-
-module ActiveSupport::TaggedLogging::Formatter
-  def call(severity, timestamp, progname, msg); end
-  def clear_tags!; end
-  def current_tags; end
-  def pop_tags(size = T.unsafe(nil)); end
-  def push_tags(*tags); end
-  def tagged(*tags); end
-  def tags_text; end
-end
-
-module ActiveSupport::TaggedLogging::LocalTagStorage
-  def current_tags; end
-  def current_tags=(_arg0); end
-
-  class << self
-    def extended(base); end
-  end
-end
-
-class ActiveSupport::TestCase < ::Minitest::Test
-  include ::ActiveSupport::Testing::SetupAndTeardown
-  include ::ActiveSupport::Testing::TaggedLogging
-  include ::ActiveSupport::Callbacks
-  include ::ActiveSupport::Testing::Assertions
-  include ::ActiveSupport::Testing::Deprecation
-  include ::ActiveSupport::Testing::TimeHelpers
-  include ::ActiveSupport::Testing::FileFixtures
-  extend ::ActiveSupport::Callbacks::ClassMethods
-  extend ::ActiveSupport::DescendantsTracker
-  extend ::ActiveSupport::Testing::SetupAndTeardown::ClassMethods
-  extend ::ActiveSupport::Testing::Declarative
-
-  def __callbacks; end
-  def __callbacks?; end
-  def _run_setup_callbacks(&block); end
-  def _run_teardown_callbacks(&block); end
-  def _setup_callbacks; end
-  def _teardown_callbacks; end
-  def assert_no_match(matcher, obj, msg = T.unsafe(nil)); end
-  def assert_not_empty(obj, msg = T.unsafe(nil)); end
-  def assert_not_equal(exp, act, msg = T.unsafe(nil)); end
-  def assert_not_in_delta(exp, act, delta = T.unsafe(nil), msg = T.unsafe(nil)); end
-  def assert_not_in_epsilon(a, b, epsilon = T.unsafe(nil), msg = T.unsafe(nil)); end
-  def assert_not_includes(collection, obj, msg = T.unsafe(nil)); end
-  def assert_not_instance_of(cls, obj, msg = T.unsafe(nil)); end
-  def assert_not_kind_of(cls, obj, msg = T.unsafe(nil)); end
-  def assert_not_nil(obj, msg = T.unsafe(nil)); end
-  def assert_not_operator(o1, op, o2 = T.unsafe(nil), msg = T.unsafe(nil)); end
-  def assert_not_predicate(o1, op, msg = T.unsafe(nil)); end
-  def assert_not_respond_to(obj, meth, msg = T.unsafe(nil)); end
-  def assert_not_same(exp, act, msg = T.unsafe(nil)); end
-  def assert_raise(*exp); end
-  def file_fixture_path; end
-  def file_fixture_path?; end
-  def method_name; end
-
-  class << self
-    def __callbacks; end
-    def __callbacks=(value); end
-    def __callbacks?; end
-    def _setup_callbacks; end
-    def _setup_callbacks=(value); end
-    def _teardown_callbacks; end
-    def _teardown_callbacks=(value); end
-    def file_fixture_path; end
-    def file_fixture_path=(value); end
-    def file_fixture_path?; end
-    def parallelize(workers: T.unsafe(nil), with: T.unsafe(nil)); end
-    def parallelize_setup(&block); end
-    def parallelize_teardown(&block); end
-    def test_order; end
-    def test_order=(new_order); end
-  end
-end
-
-ActiveSupport::TestCase::Assertion = Minitest::Assertion
-module ActiveSupport::Testing; end
-
-module ActiveSupport::Testing::Assertions
-  def assert_changes(expression, message = T.unsafe(nil), from: T.unsafe(nil), to: T.unsafe(nil), &block); end
-  def assert_difference(expression, *args, &block); end
-  def assert_no_changes(expression, message = T.unsafe(nil), &block); end
-  def assert_no_difference(expression, message = T.unsafe(nil), &block); end
-  def assert_not(object, message = T.unsafe(nil)); end
-  def assert_nothing_raised; end
-end
-
-ActiveSupport::Testing::Assertions::UNTRACKED = T.let(T.unsafe(nil), Object)
-
-module ActiveSupport::Testing::ConstantLookup
-  extend ::ActiveSupport::Concern
-
-  mixes_in_class_methods ::ActiveSupport::Testing::ConstantLookup::ClassMethods
-end
-
-module ActiveSupport::Testing::ConstantLookup::ClassMethods
-  def determine_constant_from_test_name(test_name); end
-end
-
-module ActiveSupport::Testing::Declarative
-  def test(name, &block); end
-end
-
-module ActiveSupport::Testing::Deprecation
-  def assert_deprecated(match = T.unsafe(nil), deprecator = T.unsafe(nil), &block); end
-  def assert_not_deprecated(deprecator = T.unsafe(nil), &block); end
-  def collect_deprecations(deprecator = T.unsafe(nil)); end
-end
-
-module ActiveSupport::Testing::FileFixtures
-  extend ::ActiveSupport::Concern
-  include GeneratedInstanceMethods
-
-  mixes_in_class_methods GeneratedClassMethods
-
-  def file_fixture(fixture_name); end
-
-  module GeneratedClassMethods
-    def file_fixture_path; end
-    def file_fixture_path=(value); end
-    def file_fixture_path?; end
-  end
-
-  module GeneratedInstanceMethods
-    def file_fixture_path; end
-    def file_fixture_path?; end
-  end
-end
-
-module ActiveSupport::Testing::Isolation
-  include ::ActiveSupport::Testing::Isolation::Forking
-
-  def run; end
-
-  class << self
-    def forking_env?; end
-    def included(klass); end
-  end
-end
-
-module ActiveSupport::Testing::Isolation::Forking
-  def run_in_isolation(&blk); end
-end
-
-module ActiveSupport::Testing::Isolation::Subprocess
-  def run_in_isolation(&blk); end
-end
-
-ActiveSupport::Testing::Isolation::Subprocess::ORIG_ARGV = T.let(T.unsafe(nil), Array)
-
-class ActiveSupport::Testing::Parallelization
-  def initialize(worker_count); end
-
-  def <<(work); end
-  def after_fork_hooks; end
-  def run_cleanup_hooks; end
-  def shutdown; end
-  def start; end
-
-  class << self
-    def after_fork_hook(&blk); end
-    def after_fork_hooks; end
-    def run_cleanup_hook(&blk); end
-    def run_cleanup_hooks; end
-  end
-end
-
-class ActiveSupport::Testing::Parallelization::Server
-  include ::DRb::DRbUndumped
-
-  def initialize; end
-
-  def <<(o); end
-  def active_workers?; end
-  def pop; end
-  def record(reporter, result); end
-  def shutdown; end
-  def start_worker(worker_id); end
-  def stop_worker(worker_id); end
-end
-
-class ActiveSupport::Testing::Parallelization::Worker
-  def initialize(number, url); end
-
-  def after_fork; end
-  def perform_job(job); end
-  def run_cleanup; end
-  def safe_record(reporter, result); end
-  def start; end
-  def work_from_queue; end
-
-  private
-
-  def add_setup_exception(result); end
-  def set_process_title(status); end
-end
-
-module ActiveSupport::Testing::SetupAndTeardown
-  def after_teardown; end
-  def before_setup; end
-
-  class << self
-    def prepended(klass); end
-  end
-end
-
-module ActiveSupport::Testing::SetupAndTeardown::ClassMethods
-  def setup(*args, &block); end
-  def teardown(*args, &block); end
-end
-
-class ActiveSupport::Testing::SimpleStubs
-  def initialize; end
-
-  def stub_object(object, method_name, &block); end
-  def stubbed?; end
-  def stubbing(object, method_name); end
-  def unstub_all!; end
-
-  private
-
-  def unstub_object(stub); end
-end
-
-class ActiveSupport::Testing::SimpleStubs::Stub < ::Struct
-  def method_name; end
-  def method_name=(_); end
-  def object; end
-  def object=(_); end
-  def original_method; end
-  def original_method=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-module ActiveSupport::Testing::TaggedLogging
-  def before_setup; end
-  def tagged_logger=(_arg0); end
-
-  private
-
-  def tagged_logger; end
-end
-
-module ActiveSupport::Testing::TimeHelpers
-  def after_teardown; end
-  def freeze_time(&block); end
-  def travel(duration, &block); end
-  def travel_back; end
-  def travel_to(date_or_time); end
-  def unfreeze_time; end
-
-  private
-
-  def simple_stubs; end
-end
-
-class ActiveSupport::TimeWithZone
-  include ::DateAndTime::Compatibility
-  include ::Comparable
-
-  def initialize(utc_time, time_zone, local_time = T.unsafe(nil), period = T.unsafe(nil)); end
-
-  def +(other); end
-  def -(other); end
-  def <=>(other); end
-  def acts_like_time?; end
-  def advance(options); end
-  def after?(_arg0); end
-  def ago(other); end
-  def as_json(options = T.unsafe(nil)); end
-  def before?(_arg0); end
-  def between?(min, max); end
-  def blank?; end
-  def change(options); end
-  def comparable_time; end
-  def day; end
-  def dst?; end
-  def encode_with(coder); end
-  def eql?(other); end
-  def formatted_offset(colon = T.unsafe(nil), alternate_utc_string = T.unsafe(nil)); end
-  def freeze; end
-  def future?; end
-  def getgm; end
-  def getlocal(utc_offset = T.unsafe(nil)); end
-  def getutc; end
-  def gmt?; end
-  def gmt_offset; end
-  def gmtime; end
-  def gmtoff; end
-  def hash; end
-  def hour; end
-  def httpdate; end
-  def in(other); end
-  def in_time_zone(new_zone = T.unsafe(nil)); end
-  def init_with(coder); end
-  def inspect; end
-  def is_a?(klass); end
-  def isdst; end
-  def iso8601(fraction_digits = T.unsafe(nil)); end
-  def kind_of?(klass); end
-  def localtime(utc_offset = T.unsafe(nil)); end
-  def marshal_dump; end
-  def marshal_load(variables); end
-  def mday; end
-  def method_missing(sym, *args, &block); end
-  def min; end
-  def mon; end
-  def month; end
-  def next_day?; end
-  def nsec; end
-  def past?; end
-  def period; end
-  def prev_day?; end
-  def respond_to?(sym, include_priv = T.unsafe(nil)); end
-  def rfc2822; end
-  def rfc3339(fraction_digits = T.unsafe(nil)); end
-  def rfc822; end
-  def sec; end
-  def since(other); end
-  def strftime(format); end
-  def time; end
-  def time_zone; end
-  def to_a; end
-  def to_date; end
-  def to_datetime; end
-  def to_f; end
-  def to_formatted_s(format = T.unsafe(nil)); end
-  def to_i; end
-  def to_r; end
-  def to_s(format = T.unsafe(nil)); end
-  def to_time; end
-  def today?; end
-  def tomorrow?; end
-  def tv_sec; end
-  def usec; end
-  def utc; end
-  def utc?; end
-  def utc_offset; end
-  def wday; end
-  def xmlschema(fraction_digits = T.unsafe(nil)); end
-  def yday; end
-  def year; end
-  def yesterday?; end
-  def zone; end
-
-  private
-
-  def duration_of_variable_length?(obj); end
-  def get_period_and_ensure_valid_local_time(period); end
-  def incorporate_utc_offset(time, offset); end
-  def respond_to_missing?(sym, include_priv); end
-  def transfer_time_values_to_utc_constructor(time); end
-  def wrap_with_time_zone(time); end
-
-  class << self
-    def name; end
-  end
-end
-
-ActiveSupport::TimeWithZone::PRECISIONS = T.let(T.unsafe(nil), Hash)
-ActiveSupport::TimeWithZone::SECONDS_PER_DAY = T.let(T.unsafe(nil), Integer)
-
-class ActiveSupport::TimeZone
-  include ::Comparable
-
-  def initialize(name, utc_offset = T.unsafe(nil), tzinfo = T.unsafe(nil)); end
-
-  def <=>(zone); end
-  def =~(re); end
-  def at(*args); end
-  def encode_with(coder); end
-  def formatted_offset(colon = T.unsafe(nil), alternate_utc_string = T.unsafe(nil)); end
-  def init_with(coder); end
-  def iso8601(str); end
-  def local(*args); end
-  def local_to_utc(time, dst = T.unsafe(nil)); end
-  def match?(re); end
-  def name; end
-  def now; end
-  def parse(str, now = T.unsafe(nil)); end
-  def period_for_local(time, dst = T.unsafe(nil)); end
-  def period_for_utc(time); end
-  def periods_for_local(time); end
-  def rfc3339(str); end
-  def strptime(str, format, now = T.unsafe(nil)); end
-  def to_s; end
-  def today; end
-  def tomorrow; end
-  def tzinfo; end
-  def utc_offset; end
-  def utc_to_local(time); end
-  def yesterday; end
-
-  private
-
-  def parts_to_time(parts, now); end
-  def time_now; end
-
-  class << self
-    def [](arg); end
-    def all; end
-    def clear; end
-    def country_zones(country_code); end
-    def create(*_arg0); end
-    def find_tzinfo(name); end
-    def new(name); end
-    def seconds_to_utc_offset(seconds, colon = T.unsafe(nil)); end
-    def us_zones; end
-
-    private
-
-    def load_country_zones(code); end
-    def zones_map; end
-  end
-end
-
-ActiveSupport::TimeZone::MAPPING = T.let(T.unsafe(nil), Hash)
-ActiveSupport::TimeZone::UTC_OFFSET_WITHOUT_COLON = T.let(T.unsafe(nil), String)
-ActiveSupport::TimeZone::UTC_OFFSET_WITH_COLON = T.let(T.unsafe(nil), String)
-
-module ActiveSupport::ToJsonWithActiveSupportEncoder
-  def to_json(options = T.unsafe(nil)); end
-end
-
-module ActiveSupport::Tryable
-  def try(method_name = T.unsafe(nil), *args, &b); end
-  def try!(method_name = T.unsafe(nil), *args, &b); end
-end
-
-module ActiveSupport::VERSION; end
-ActiveSupport::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
-ActiveSupport::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
-ActiveSupport::VERSION::PRE = T.let(T.unsafe(nil), String)
-ActiveSupport::VERSION::STRING = T.let(T.unsafe(nil), String)
-ActiveSupport::VERSION::TINY = T.let(T.unsafe(nil), Integer)
-
-module ActiveSupport::XmlMini
-  extend ::ActiveSupport::XmlMini
-
-  def backend; end
-  def backend=(name); end
-  def depth; end
-  def depth=(_arg0); end
-  def parse(*args, &block); end
-  def rename_key(key, options = T.unsafe(nil)); end
-  def to_tag(key, value, options); end
-  def with_backend(name); end
-
-  private
-
-  def _dasherize(key); end
-  def _parse_binary(bin, entity); end
-  def _parse_file(file, entity); end
-  def cast_backend_name_to_module(name); end
-  def current_thread_backend; end
-  def current_thread_backend=(name); end
-end
-
-ActiveSupport::XmlMini::DEFAULT_ENCODINGS = T.let(T.unsafe(nil), Hash)
-ActiveSupport::XmlMini::FORMATTING = T.let(T.unsafe(nil), Hash)
-
-module ActiveSupport::XmlMini::FileLike
-  def content_type; end
-  def content_type=(_arg0); end
-  def original_filename; end
-  def original_filename=(_arg0); end
-end
-
-ActiveSupport::XmlMini::PARSING = T.let(T.unsafe(nil), Hash)
-ActiveSupport::XmlMini::TYPE_NAMES = T.let(T.unsafe(nil), Hash)
-
-module ActiveSupport::XmlMini_REXML
-  extend ::ActiveSupport::XmlMini_REXML
-
-  def parse(data); end
-
-  private
-
-  def collapse(element, depth); end
-  def empty_content?(element); end
-  def get_attributes(element); end
-  def merge!(hash, key, value); end
-  def merge_element!(hash, element, depth); end
-  def merge_texts!(hash, element); end
-  def require_rexml; end
-end
-
-ActiveSupport::XmlMini_REXML::CONTENT_KEY = T.let(T.unsafe(nil), String)
-
-class Array
-  include ::Enumerable
-  include ::JSON::Ext::Generator::GeneratorMethods::Array
-  include ::Plist::Emit
-  include ::MessagePack::CoreExt
-
-  def as_json(options = T.unsafe(nil)); end
-  def compact_blank!; end
-  def extract_options!; end
-  def sum(init = T.unsafe(nil), &block); end
-  def to_formatted_s(format = T.unsafe(nil)); end
-  def to_param; end
-  def to_query(key); end
-  def to_s(format = T.unsafe(nil)); end
-  def to_sentence(options = T.unsafe(nil)); end
-  def to_xml(options = T.unsafe(nil)); end
-
-  class << self
-    def wrap(object); end
-  end
-end
-
-class BigDecimal < ::Numeric
-  include ::ActiveSupport::BigDecimalWithDefaultFormat
-
-  def as_json(options = T.unsafe(nil)); end
-end
-
-BigDecimal::EXCEPTION_NaN = T.let(T.unsafe(nil), Integer)
-BigDecimal::VERSION = T.let(T.unsafe(nil), String)
-
-class Class < ::Module
-  def class_attribute(*attrs, instance_accessor: T.unsafe(nil), instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_predicate: T.unsafe(nil), default: T.unsafe(nil)); end
-end
-
-class Date
-  include ::Comparable
-  include ::DateAndTime::Zones
-  include ::DateAndTime::Calculations
-
-  def +(other); end
-  def -(other); end
-  def <=>(other); end
-  def acts_like_date?; end
-  def advance(options); end
-  def ago(seconds); end
-  def as_json(options = T.unsafe(nil)); end
-  def at_beginning_of_day; end
-  def at_end_of_day; end
-  def at_midday; end
-  def at_middle_of_day; end
-  def at_midnight; end
-  def at_noon; end
-  def beginning_of_day; end
-  def change(options); end
-  def compare_with_coercion(other); end
-  def end_of_day; end
-  def in(seconds); end
-  def inspect; end
-  def midday; end
-  def middle_of_day; end
-  def midnight; end
-  def minus_with_duration(other); end
-  def noon; end
-  def plus_with_duration(other); end
-  def readable_inspect; end
-  def since(seconds); end
-  def to_formatted_s(format = T.unsafe(nil)); end
-  def to_s(format = T.unsafe(nil)); end
-  def to_time(form = T.unsafe(nil)); end
-  def xmlschema; end
-
-  class << self
-    def beginning_of_week; end
-    def beginning_of_week=(week_start); end
-    def beginning_of_week_default; end
-    def beginning_of_week_default=(_arg0); end
-    def current; end
-    def find_beginning_of_week!(week_start); end
-    def tomorrow; end
-    def yesterday; end
-  end
-end
-
-Date::DATE_FORMATS = T.let(T.unsafe(nil), Hash)
-module DateAndTime; end
-
-module DateAndTime::Calculations
-  def after?(date_or_time); end
-  def all_day; end
-  def all_month; end
-  def all_quarter; end
-  def all_week(start_day = T.unsafe(nil)); end
-  def all_year; end
-  def at_beginning_of_month; end
-  def at_beginning_of_quarter; end
-  def at_beginning_of_week(start_day = T.unsafe(nil)); end
-  def at_beginning_of_year; end
-  def at_end_of_month; end
-  def at_end_of_quarter; end
-  def at_end_of_week(start_day = T.unsafe(nil)); end
-  def at_end_of_year; end
-  def before?(date_or_time); end
-  def beginning_of_month; end
-  def beginning_of_quarter; end
-  def beginning_of_week(start_day = T.unsafe(nil)); end
-  def beginning_of_year; end
-  def days_ago(days); end
-  def days_since(days); end
-  def days_to_week_start(start_day = T.unsafe(nil)); end
-  def end_of_month; end
-  def end_of_quarter; end
-  def end_of_week(start_day = T.unsafe(nil)); end
-  def end_of_year; end
-  def future?; end
-  def last_month; end
-  def last_quarter; end
-  def last_week(start_day = T.unsafe(nil), same_time: T.unsafe(nil)); end
-  def last_weekday; end
-  def last_year; end
-  def monday; end
-  def months_ago(months); end
-  def months_since(months); end
-  def next_day?; end
-  def next_occurring(day_of_week); end
-  def next_quarter; end
-  def next_week(given_day_in_next_week = T.unsafe(nil), same_time: T.unsafe(nil)); end
-  def next_weekday; end
-  def on_weekday?; end
-  def on_weekend?; end
-  def past?; end
-  def prev_day?; end
-  def prev_occurring(day_of_week); end
-  def prev_quarter; end
-  def prev_week(start_day = T.unsafe(nil), same_time: T.unsafe(nil)); end
-  def prev_weekday; end
-  def sunday; end
-  def today?; end
-  def tomorrow; end
-  def tomorrow?; end
-  def weeks_ago(weeks); end
-  def weeks_since(weeks); end
-  def years_ago(years); end
-  def years_since(years); end
-  def yesterday; end
-  def yesterday?; end
-
-  private
-
-  def copy_time_to(other); end
-  def days_span(day); end
-  def first_hour(date_or_time); end
-  def last_hour(date_or_time); end
-end
-
-DateAndTime::Calculations::DAYS_INTO_WEEK = T.let(T.unsafe(nil), Hash)
-DateAndTime::Calculations::WEEKEND_DAYS = T.let(T.unsafe(nil), Array)
-
-module DateAndTime::Compatibility
-  def preserve_timezone; end
-  def utc_to_local_returns_utc_offset_times; end
-
-  class << self
-    def preserve_timezone; end
-    def preserve_timezone=(val); end
-    def utc_to_local_returns_utc_offset_times; end
-    def utc_to_local_returns_utc_offset_times=(val); end
-  end
-end
-
-module DateAndTime::Zones
-  def in_time_zone(zone = T.unsafe(nil)); end
-
-  private
-
-  def time_with_zone(time, zone); end
-end
-
-class DateTime < ::Date
-  def <=>(other); end
-  def advance(options); end
-  def ago(seconds); end
-  def as_json(options = T.unsafe(nil)); end
-  def at_beginning_of_day; end
-  def at_beginning_of_hour; end
-  def at_beginning_of_minute; end
-  def at_end_of_day; end
-  def at_end_of_hour; end
-  def at_end_of_minute; end
-  def at_midday; end
-  def at_middle_of_day; end
-  def at_midnight; end
-  def at_noon; end
-  def beginning_of_day; end
-  def beginning_of_hour; end
-  def beginning_of_minute; end
-  def change(options); end
-  def end_of_day; end
-  def end_of_hour; end
-  def end_of_minute; end
-  def formatted_offset(colon = T.unsafe(nil), alternate_utc_string = T.unsafe(nil)); end
-  def getgm; end
-  def getlocal(utc_offset = T.unsafe(nil)); end
-  def getutc; end
-  def gmtime; end
-  def in(seconds); end
-  def inspect; end
-  def localtime(utc_offset = T.unsafe(nil)); end
-  def midday; end
-  def middle_of_day; end
-  def midnight; end
-  def noon; end
-  def nsec; end
-  def readable_inspect; end
-  def seconds_since_midnight; end
-  def seconds_until_end_of_day; end
-  def since(seconds); end
-  def subsec; end
-  def to_f; end
-  def to_formatted_s(format = T.unsafe(nil)); end
-  def to_i; end
-  def to_s(format = T.unsafe(nil)); end
-  def usec; end
-  def utc; end
-  def utc?; end
-  def utc_offset; end
-
-  private
-
-  def offset_in_seconds; end
-  def seconds_since_unix_epoch; end
-
-  class << self
-    def civil_from_format(utc_or_local, year, month = T.unsafe(nil), day = T.unsafe(nil), hour = T.unsafe(nil), min = T.unsafe(nil), sec = T.unsafe(nil)); end
-    def current; end
-  end
-end
-
-module ERB::Util
-  private
-
-  def h(s); end
-  def html_escape(s); end
-  def html_escape_once(s); end
-  def json_escape(s); end
-  def unwrapped_html_escape(s); end
-  def xml_name_escape(name); end
-
-  class << self
-    def h(s); end
-    def html_escape(s); end
-    def html_escape_once(s); end
-    def json_escape(s); end
-    def unwrapped_html_escape(s); end
-    def xml_name_escape(name); end
-  end
-end
-
-ERB::Util::HTML_ESCAPE = T.let(T.unsafe(nil), Hash)
-ERB::Util::HTML_ESCAPE_ONCE_REGEXP = T.let(T.unsafe(nil), Regexp)
-ERB::Util::JSON_ESCAPE = T.let(T.unsafe(nil), Hash)
-ERB::Util::JSON_ESCAPE_REGEXP = T.let(T.unsafe(nil), Regexp)
-ERB::Util::TAG_NAME_FOLLOWING_REGEXP = T.let(T.unsafe(nil), Regexp)
-ERB::Util::TAG_NAME_REPLACEMENT_CHAR = T.let(T.unsafe(nil), String)
-ERB::Util::TAG_NAME_START_REGEXP = T.let(T.unsafe(nil), Regexp)
-ERB::Util::TAG_NAME_START_REGEXP_SET = T.let(T.unsafe(nil), String)
-
-module Enumerable
-  def as_json(options = T.unsafe(nil)); end
-  def compact_blank; end
-  def exclude?(object); end
-  def excluding(*elements); end
-  def including(*elements); end
-  def index_by; end
-  def index_with(default = T.unsafe(nil)); end
-  def many?; end
-  def pick(*keys); end
-  def pluck(*keys); end
-  def sum(identity = T.unsafe(nil), &block); end
-  def without(*elements); end
-end
-
-Enumerable::INDEX_WITH_DEFAULT = T.let(T.unsafe(nil), Object)
-
-class Exception
-  include ::ActiveSupport::Dependencies::Blamable
-
-  def as_json(options = T.unsafe(nil)); end
-end
-
-class FalseClass
-  include ::JSON::Ext::Generator::GeneratorMethods::FalseClass
-  include ::MessagePack::CoreExt
-
-  def as_json(options = T.unsafe(nil)); end
-  def blank?; end
-  def to_param; end
-end
-
-class Float < ::Numeric
-  include ::JSON::Ext::Generator::GeneratorMethods::Float
-  include ::MessagePack::CoreExt
-
-  def as_json(options = T.unsafe(nil)); end
-end
-
-class Hash
-  include ::Enumerable
-  include ::JSON::Ext::Generator::GeneratorMethods::Hash
-  include ::Plist::Emit
-  include ::MessagePack::CoreExt
-
-  def as_json(options = T.unsafe(nil)); end
-  def assert_valid_keys(*valid_keys); end
-  def compact_blank; end
-  def compact_blank!; end
-  def deep_merge(other_hash, &block); end
-  def deep_merge!(other_hash, &block); end
-  def deep_stringify_keys; end
-  def deep_stringify_keys!; end
-  def deep_symbolize_keys; end
-  def deep_symbolize_keys!; end
-  def deep_transform_keys(&block); end
-  def deep_transform_keys!(&block); end
-  def except(*keys); end
-  def except!(*keys); end
-  def extract!(*keys); end
-  def extractable_options?; end
-  def slice!(*keys); end
-  def stringify_keys; end
-  def stringify_keys!; end
-  def symbolize_keys; end
-  def symbolize_keys!; end
-  def to_options; end
-  def to_options!; end
-  def to_param(namespace = T.unsafe(nil)); end
-  def to_query(namespace = T.unsafe(nil)); end
-
-  private
-
-  def _deep_transform_keys_in_object(object, &block); end
-  def _deep_transform_keys_in_object!(object, &block); end
-end
-
-class IO
-  include ::Enumerable
-  include ::File::Constants
-
-  def as_json(options = T.unsafe(nil)); end
-end
-
-class IO::EAGAINWaitReadable < ::Errno::EAGAIN
-  include ::IO::WaitReadable
-end
-
-class IO::EAGAINWaitWritable < ::Errno::EAGAIN
-  include ::IO::WaitWritable
-end
-
-class IO::EINPROGRESSWaitReadable < ::Errno::EINPROGRESS
-  include ::IO::WaitReadable
-end
-
-class IO::EINPROGRESSWaitWritable < ::Errno::EINPROGRESS
-  include ::IO::WaitWritable
-end
-
-IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable
-IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable
-
-class IPAddr
-  include ::Comparable
-
-  def as_json(options = T.unsafe(nil)); end
-end
-
-module Kernel
-  extend ::Forwardable
-
-  private
-
-  def enable_warnings; end
-  def silence_warnings; end
-  def suppress(*exception_classes); end
-  def with_warnings(flag); end
-
-  class << self
-    def enable_warnings; end
-    def silence_warnings; end
-    def suppress(*exception_classes); end
-    def with_warnings(flag); end
-  end
-end
-
-class LoadError < ::ScriptError
-  def is_missing?(location); end
-end
-
-class Module
-  include ::ActiveSupport::Dependencies::ModuleConstMissing
-
-  def alias_attribute(new_name, old_name); end
-  def anonymous?; end
-  def cattr_accessor(*syms, instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), &blk); end
-  def cattr_reader(*syms, instance_reader: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end
-  def cattr_writer(*syms, instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end
-  def delegate(*methods, to: T.unsafe(nil), prefix: T.unsafe(nil), allow_nil: T.unsafe(nil), private: T.unsafe(nil)); end
-  def delegate_missing_to(target, allow_nil: T.unsafe(nil)); end
-  def deprecate(*method_names); end
-  def mattr_accessor(*syms, instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), &blk); end
-  def mattr_reader(*syms, instance_reader: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end
-  def mattr_writer(*syms, instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end
-  def method_visibility(method); end
-  def module_parent; end
-  def module_parent_name; end
-  def module_parents; end
-  def redefine_method(method, &block); end
-  def redefine_singleton_method(method, &block); end
-  def remove_possible_method(method); end
-  def remove_possible_singleton_method(method); end
-  def silence_redefinition_of_method(method); end
-end
-
-Module::DELEGATION_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
-Module::DELEGATION_RESERVED_METHOD_NAMES = T.let(T.unsafe(nil), Set)
-class Module::DelegationError < ::NoMethodError; end
-Module::RUBY_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
-
-class NameError < ::StandardError
-  include ::DidYouMean::Correctable
-
-  def missing_name; end
-  def missing_name?(name); end
-
-  private
-
-  def real_mod_name(mod); end
-end
-
-NameError::UNBOUND_METHOD_MODULE_NAME = T.let(T.unsafe(nil), UnboundMethod)
-
-class NilClass
-  include ::JSON::Ext::Generator::GeneratorMethods::NilClass
-  include ::MessagePack::CoreExt
-
-  def as_json(options = T.unsafe(nil)); end
-  def blank?; end
-  def to_param; end
-  def try(_method_name = T.unsafe(nil), *_arg1); end
-  def try!(_method_name = T.unsafe(nil), *_arg1); end
-end
-
-class Numeric
-  include ::Comparable
-
-  def as_json(options = T.unsafe(nil)); end
-  def blank?; end
-  def byte; end
-  def bytes; end
-  def day; end
-  def days; end
-  def exabyte; end
-  def exabytes; end
-  def fortnight; end
-  def fortnights; end
-  def gigabyte; end
-  def gigabytes; end
-  def hour; end
-  def hours; end
-  def html_safe?; end
-  def in_milliseconds; end
-  def kilobyte; end
-  def kilobytes; end
-  def megabyte; end
-  def megabytes; end
-  def minute; end
-  def minutes; end
-  def petabyte; end
-  def petabytes; end
-  def second; end
-  def seconds; end
-  def terabyte; end
-  def terabytes; end
-  def week; end
-  def weeks; end
-end
-
-Numeric::EXABYTE = T.let(T.unsafe(nil), Integer)
-Numeric::GIGABYTE = T.let(T.unsafe(nil), Integer)
-Numeric::KILOBYTE = T.let(T.unsafe(nil), Integer)
-Numeric::MEGABYTE = T.let(T.unsafe(nil), Integer)
-Numeric::PETABYTE = T.let(T.unsafe(nil), Integer)
-Numeric::TERABYTE = T.let(T.unsafe(nil), Integer)
-
-class Object < ::BasicObject
-  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
-  include ::ActiveSupport::ForkTracker::CoreExt
-  include ::ActiveSupport::ForkTracker::CoreExtPrivate
-  include ::Kernel
-  include ::JSON::Ext::Generator::GeneratorMethods::Object
-  include ::PP::ObjectMixin
-  include ::ActiveSupport::Dependencies::Loadable
-  include ::ActiveSupport::Tryable
-
-  def acts_like?(duck); end
-  def as_json(options = T.unsafe(nil)); end
-  def blank?; end
-  def html_safe?; end
-  def instance_values; end
-  def instance_variable_names; end
-  def presence; end
-  def present?; end
-  def to_param; end
-  def to_query(key); end
-end
-
-class Pathname
-  def as_json(options = T.unsafe(nil)); end
-end
-
-class Process::Status
-  def as_json(options = T.unsafe(nil)); end
-end
-
-class Range
-  include ::Enumerable
-
-  def as_json(options = T.unsafe(nil)); end
-  def sum(identity = T.unsafe(nil)); end
-end
-
-class Regexp
-  def as_json(options = T.unsafe(nil)); end
-end
-
-Regexp::TOKEN_KEYS = T.let(T.unsafe(nil), Array)
-
-class Regexp::Token < ::Struct
-  def conditional_level; end
-  def conditional_level=(_); end
-  def length; end
-  def level; end
-  def level=(_); end
-  def next; end
-  def next=(_arg0); end
-  def offset; end
-  def previous; end
-  def previous=(_arg0); end
-  def set_level; end
-  def set_level=(_); end
-  def te; end
-  def te=(_); end
-  def text; end
-  def text=(_); end
-  def token; end
-  def token=(_); end
-  def ts; end
-  def ts=(_); end
-  def type; end
-  def type=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class String
-  include ::Comparable
-  include ::JSON::Ext::Generator::GeneratorMethods::String
-  include ::MessagePack::CoreExt
-  extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
-
-  def acts_like_string?; end
-  def as_json(options = T.unsafe(nil)); end
-  def at(position); end
-  def blank?; end
-  def camelcase(first_letter = T.unsafe(nil)); end
-  def camelize(first_letter = T.unsafe(nil)); end
-  def classify; end
-  def constantize; end
-  def dasherize; end
-  def deconstantize; end
-  def demodulize; end
-  def first(limit = T.unsafe(nil)); end
-  def foreign_key(separate_class_name_and_id_with_underscore = T.unsafe(nil)); end
-  def from(position); end
-  def html_safe; end
-  def humanize(capitalize: T.unsafe(nil), keep_id_suffix: T.unsafe(nil)); end
-  def is_utf8?; end
-  def last(limit = T.unsafe(nil)); end
-  def mb_chars; end
-  def parameterize(separator: T.unsafe(nil), preserve_case: T.unsafe(nil), locale: T.unsafe(nil)); end
-  def pluralize(count = T.unsafe(nil), locale = T.unsafe(nil)); end
-  def remove(*patterns); end
-  def remove!(*patterns); end
-  def safe_constantize; end
-  def singularize(locale = T.unsafe(nil)); end
-  def squish; end
-  def squish!; end
-  def tableize; end
-  def titlecase(keep_id_suffix: T.unsafe(nil)); end
-  def titleize(keep_id_suffix: T.unsafe(nil)); end
-  def to(position); end
-  def to_date; end
-  def to_datetime; end
-  def to_time(form = T.unsafe(nil)); end
-  def truncate(truncate_at, options = T.unsafe(nil)); end
-  def truncate_bytes(truncate_at, omission: T.unsafe(nil)); end
-  def truncate_words(words_count, options = T.unsafe(nil)); end
-  def underscore; end
-  def upcase_first; end
-end
-
-String::BLANK_RE = T.let(T.unsafe(nil), Regexp)
-String::ENCODED_BLANKS = T.let(T.unsafe(nil), Concurrent::Map)
-
-class Struct
-  include ::Enumerable
-
-  def as_json(options = T.unsafe(nil)); end
-end
-
-Struct::Group = Etc::Group
-Struct::HTMLElementDescription = Struct
-Struct::Passwd = Etc::Passwd
-Struct::Tms = Process::Tms
-
-class Symbol
-  include ::Comparable
-  include ::MessagePack::CoreExt
-
-  def as_json(options = T.unsafe(nil)); end
-  def end_with?(*suffixes); end
-  def ends_with?(*suffixes); end
-  def start_with?(*prefixes); end
-  def starts_with?(*prefixes); end
-end
-
-class Time
-  include ::Comparable
-  include ::DateAndTime::Zones
-  include ::DateAndTime::Calculations
-
-  def +(other); end
-  def -(other); end
-  def <=>(other); end
-  def acts_like_time?; end
-  def advance(options); end
-  def ago(seconds); end
-  def as_json(options = T.unsafe(nil)); end
-  def at_beginning_of_day; end
-  def at_beginning_of_hour; end
-  def at_beginning_of_minute; end
-  def at_end_of_day; end
-  def at_end_of_hour; end
-  def at_end_of_minute; end
-  def at_midday; end
-  def at_middle_of_day; end
-  def at_midnight; end
-  def at_noon; end
-  def beginning_of_day; end
-  def beginning_of_hour; end
-  def beginning_of_minute; end
-  def blank?; end
-  def ceil(precision = T.unsafe(nil)); end
-  def change(options); end
-  def compare_with_coercion(other); end
-  def end_of_day; end
-  def end_of_hour; end
-  def end_of_minute; end
-  def eql?(other); end
-  def eql_with_coercion(other); end
-  def floor(precision = T.unsafe(nil)); end
-  def formatted_offset(colon = T.unsafe(nil), alternate_utc_string = T.unsafe(nil)); end
-  def in(seconds); end
-  def midday; end
-  def middle_of_day; end
-  def midnight; end
-  def minus_with_coercion(other); end
-  def minus_with_duration(other); end
-  def minus_without_coercion(other); end
-  def next_day(days = T.unsafe(nil)); end
-  def next_month(months = T.unsafe(nil)); end
-  def next_year(years = T.unsafe(nil)); end
-  def noon; end
-  def plus_with_duration(other); end
-  def prev_day(days = T.unsafe(nil)); end
-  def prev_month(months = T.unsafe(nil)); end
-  def prev_year(years = T.unsafe(nil)); end
-  def sec_fraction; end
-  def seconds_since_midnight; end
-  def seconds_until_end_of_day; end
-  def since(seconds); end
-  def to_formatted_s(format = T.unsafe(nil)); end
-  def to_s(format = T.unsafe(nil)); end
-
-  class << self
-    def ===(other); end
-    def at(*args); end
-    def at_with_coercion(*args); end
-    def current; end
-    def days_in_month(month, year = T.unsafe(nil)); end
-    def days_in_year(year = T.unsafe(nil)); end
-    def find_zone(time_zone); end
-    def find_zone!(time_zone); end
-    def rfc3339(str); end
-    def use_zone(time_zone); end
-    def zone; end
-    def zone=(time_zone); end
-    def zone_default; end
-    def zone_default=(_arg0); end
-  end
-end
-
-Time::COMMON_YEAR_DAYS_IN_MONTH = T.let(T.unsafe(nil), Array)
-Time::DATE_FORMATS = T.let(T.unsafe(nil), Hash)
-
-class TrueClass
-  include ::JSON::Ext::Generator::GeneratorMethods::TrueClass
-  include ::MessagePack::CoreExt
-
-  def as_json(options = T.unsafe(nil)); end
-  def blank?; end
-  def to_param; end
-end
-
-class URI::Generic
-  include ::URI::RFC2396_REGEXP
-  include ::URI
-
-  def as_json(options = T.unsafe(nil)); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/addressable@2.8.0.rbi b/Library/Homebrew/sorbet/rbi/gems/addressable@2.8.0.rbi
deleted file mode 100644
index 6537967e4f822..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/addressable@2.8.0.rbi
+++ /dev/null
@@ -1,290 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `addressable` gem.
-# Please instead update this file by running `bin/tapioca gem addressable`.
-
-module Addressable; end
-
-module Addressable::IDNA
-  class << self
-    def to_ascii(input); end
-    def to_unicode(input); end
-    def unicode_normalize_kc(input); end
-
-    private
-
-    def lookup_unicode_combining_class(codepoint); end
-    def lookup_unicode_compatibility(codepoint); end
-    def lookup_unicode_composition(unpacked); end
-    def lookup_unicode_lowercase(codepoint); end
-    def punycode_adapt(delta, numpoints, firsttime); end
-    def punycode_basic?(codepoint); end
-    def punycode_decode(punycode); end
-    def punycode_decode_digit(codepoint); end
-    def punycode_delimiter?(codepoint); end
-    def punycode_encode(unicode); end
-    def punycode_encode_digit(d); end
-    def ucs4_to_utf8(char, buffer); end
-    def unicode_compose(unpacked); end
-    def unicode_compose_pair(ch_one, ch_two); end
-    def unicode_decompose(unpacked); end
-    def unicode_decompose_hangul(codepoint); end
-    def unicode_downcase(input); end
-    def unicode_sort_canonical(unpacked); end
-  end
-end
-
-Addressable::IDNA::ACE_MAX_LENGTH = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::ACE_PREFIX = T.let(T.unsafe(nil), String)
-Addressable::IDNA::COMPOSITION_TABLE = T.let(T.unsafe(nil), Hash)
-Addressable::IDNA::HANGUL_LBASE = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::HANGUL_LCOUNT = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::HANGUL_NCOUNT = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::HANGUL_SBASE = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::HANGUL_SCOUNT = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::HANGUL_TBASE = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::HANGUL_TCOUNT = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::HANGUL_VBASE = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::HANGUL_VCOUNT = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::PUNYCODE_BASE = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::PUNYCODE_DAMP = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::PUNYCODE_DELIMITER = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::PUNYCODE_INITIAL_BIAS = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::PUNYCODE_INITIAL_N = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::PUNYCODE_MAXINT = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::PUNYCODE_PRINT_ASCII = T.let(T.unsafe(nil), String)
-Addressable::IDNA::PUNYCODE_SKEW = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::PUNYCODE_TMAX = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::PUNYCODE_TMIN = T.let(T.unsafe(nil), Integer)
-class Addressable::IDNA::PunycodeBadInput < ::StandardError; end
-class Addressable::IDNA::PunycodeBigOutput < ::StandardError; end
-class Addressable::IDNA::PunycodeOverflow < ::StandardError; end
-Addressable::IDNA::UNICODE_DATA = T.let(T.unsafe(nil), Hash)
-Addressable::IDNA::UNICODE_DATA_CANONICAL = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::UNICODE_DATA_COMBINING_CLASS = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::UNICODE_DATA_COMPATIBILITY = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::UNICODE_DATA_EXCLUSION = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::UNICODE_DATA_LOWERCASE = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::UNICODE_DATA_TITLECASE = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::UNICODE_DATA_UPPERCASE = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::UNICODE_MAX_LENGTH = T.let(T.unsafe(nil), Integer)
-Addressable::IDNA::UNICODE_TABLE = T.let(T.unsafe(nil), String)
-Addressable::IDNA::UTF8_REGEX = T.let(T.unsafe(nil), Regexp)
-Addressable::IDNA::UTF8_REGEX_MULTIBYTE = T.let(T.unsafe(nil), Regexp)
-
-class Addressable::Template
-  def initialize(pattern); end
-
-  def ==(template); end
-  def eql?(template); end
-  def expand(mapping, processor = T.unsafe(nil), normalize_values = T.unsafe(nil)); end
-  def extract(uri, processor = T.unsafe(nil)); end
-  def freeze; end
-  def inspect; end
-  def keys; end
-  def match(uri, processor = T.unsafe(nil)); end
-  def named_captures; end
-  def names; end
-  def partial_expand(mapping, processor = T.unsafe(nil), normalize_values = T.unsafe(nil)); end
-  def pattern; end
-  def source; end
-  def to_regexp; end
-  def variable_defaults; end
-  def variables; end
-
-  private
-
-  def join_values(operator, return_value); end
-  def normalize_keys(mapping); end
-  def normalize_value(value); end
-  def ordered_variable_defaults; end
-  def parse_new_template_pattern(pattern, processor = T.unsafe(nil)); end
-  def parse_template_pattern(pattern, processor = T.unsafe(nil)); end
-  def transform_capture(mapping, capture, processor = T.unsafe(nil), normalize_values = T.unsafe(nil)); end
-  def transform_partial_capture(mapping, capture, processor = T.unsafe(nil), normalize_values = T.unsafe(nil)); end
-end
-
-Addressable::Template::EXPRESSION = T.let(T.unsafe(nil), Regexp)
-class Addressable::Template::InvalidTemplateOperatorError < ::StandardError; end
-class Addressable::Template::InvalidTemplateValueError < ::StandardError; end
-Addressable::Template::JOINERS = T.let(T.unsafe(nil), Hash)
-Addressable::Template::LEADERS = T.let(T.unsafe(nil), Hash)
-
-class Addressable::Template::MatchData
-  def initialize(uri, template, mapping); end
-
-  def [](key, len = T.unsafe(nil)); end
-  def captures; end
-  def inspect; end
-  def keys; end
-  def mapping; end
-  def names; end
-  def post_match; end
-  def pre_match; end
-  def string; end
-  def template; end
-  def to_a; end
-  def to_s; end
-  def uri; end
-  def values; end
-  def values_at(*indexes); end
-  def variables; end
-end
-
-Addressable::Template::RESERVED = T.let(T.unsafe(nil), String)
-class Addressable::Template::TemplateOperatorAbortedError < ::StandardError; end
-Addressable::Template::UNRESERVED = T.let(T.unsafe(nil), String)
-Addressable::Template::VARIABLE_LIST = T.let(T.unsafe(nil), Regexp)
-Addressable::Template::VARNAME = T.let(T.unsafe(nil), Regexp)
-Addressable::Template::VARSPEC = T.let(T.unsafe(nil), Regexp)
-
-class Addressable::URI
-  def initialize(options = T.unsafe(nil)); end
-
-  def +(uri); end
-  def ==(uri); end
-  def ===(uri); end
-  def absolute?; end
-  def authority; end
-  def authority=(new_authority); end
-  def basename; end
-  def default_port; end
-  def defer_validation; end
-  def display_uri; end
-  def domain; end
-  def dup; end
-  def empty?; end
-  def eql?(uri); end
-  def extname; end
-  def fragment; end
-  def fragment=(new_fragment); end
-  def freeze; end
-  def hash; end
-  def host; end
-  def host=(new_host); end
-  def hostname; end
-  def hostname=(new_hostname); end
-  def inferred_port; end
-  def inspect; end
-  def ip_based?; end
-  def join(uri); end
-  def join!(uri); end
-  def merge(hash); end
-  def merge!(uri); end
-  def normalize; end
-  def normalize!; end
-  def normalized_authority; end
-  def normalized_fragment; end
-  def normalized_host; end
-  def normalized_password; end
-  def normalized_path; end
-  def normalized_port; end
-  def normalized_query(*flags); end
-  def normalized_scheme; end
-  def normalized_site; end
-  def normalized_user; end
-  def normalized_userinfo; end
-  def omit(*components); end
-  def omit!(*components); end
-  def origin; end
-  def origin=(new_origin); end
-  def password; end
-  def password=(new_password); end
-  def path; end
-  def path=(new_path); end
-  def port; end
-  def port=(new_port); end
-  def query; end
-  def query=(new_query); end
-  def query_values(return_type = T.unsafe(nil)); end
-  def query_values=(new_query_values); end
-  def relative?; end
-  def request_uri; end
-  def request_uri=(new_request_uri); end
-  def route_from(uri); end
-  def route_to(uri); end
-  def scheme; end
-  def scheme=(new_scheme); end
-  def site; end
-  def site=(new_site); end
-  def tld; end
-  def tld=(new_tld); end
-  def to_hash; end
-  def to_s; end
-  def to_str; end
-  def user; end
-  def user=(new_user); end
-  def userinfo; end
-  def userinfo=(new_userinfo); end
-
-  protected
-
-  def remove_composite_values; end
-  def replace_self(uri); end
-  def split_path(path); end
-  def validate; end
-
-  class << self
-    def convert_path(path); end
-    def encode(uri, return_type = T.unsafe(nil)); end
-    def encode_component(component, character_class = T.unsafe(nil), upcase_encoded = T.unsafe(nil)); end
-    def escape(uri, return_type = T.unsafe(nil)); end
-    def escape_component(component, character_class = T.unsafe(nil), upcase_encoded = T.unsafe(nil)); end
-    def form_encode(form_values, sort = T.unsafe(nil)); end
-    def form_unencode(encoded_value); end
-    def heuristic_parse(uri, hints = T.unsafe(nil)); end
-    def ip_based_schemes; end
-    def join(*uris); end
-    def normalize_component(component, character_class = T.unsafe(nil), leave_encoded = T.unsafe(nil)); end
-    def normalize_path(path); end
-    def normalized_encode(uri, return_type = T.unsafe(nil)); end
-    def parse(uri); end
-    def port_mapping; end
-    def unencode(uri, return_type = T.unsafe(nil), leave_encoded = T.unsafe(nil)); end
-    def unencode_component(uri, return_type = T.unsafe(nil), leave_encoded = T.unsafe(nil)); end
-    def unescape(uri, return_type = T.unsafe(nil), leave_encoded = T.unsafe(nil)); end
-    def unescape_component(uri, return_type = T.unsafe(nil), leave_encoded = T.unsafe(nil)); end
-  end
-end
-
-module Addressable::URI::CharacterClasses; end
-Addressable::URI::CharacterClasses::ALPHA = T.let(T.unsafe(nil), String)
-Addressable::URI::CharacterClasses::AUTHORITY = T.let(T.unsafe(nil), String)
-Addressable::URI::CharacterClasses::DIGIT = T.let(T.unsafe(nil), String)
-Addressable::URI::CharacterClasses::FRAGMENT = T.let(T.unsafe(nil), String)
-Addressable::URI::CharacterClasses::GEN_DELIMS = T.let(T.unsafe(nil), String)
-Addressable::URI::CharacterClasses::HOST = T.let(T.unsafe(nil), String)
-Addressable::URI::CharacterClasses::PATH = T.let(T.unsafe(nil), String)
-Addressable::URI::CharacterClasses::PCHAR = T.let(T.unsafe(nil), String)
-Addressable::URI::CharacterClasses::QUERY = T.let(T.unsafe(nil), String)
-Addressable::URI::CharacterClasses::RESERVED = T.let(T.unsafe(nil), String)
-Addressable::URI::CharacterClasses::SCHEME = T.let(T.unsafe(nil), String)
-Addressable::URI::CharacterClasses::SUB_DELIMS = T.let(T.unsafe(nil), String)
-Addressable::URI::CharacterClasses::UNRESERVED = T.let(T.unsafe(nil), String)
-Addressable::URI::EMPTY_STR = T.let(T.unsafe(nil), String)
-class Addressable::URI::InvalidURIError < ::StandardError; end
-Addressable::URI::NORMPATH = T.let(T.unsafe(nil), Regexp)
-module Addressable::URI::NormalizeCharacterClasses; end
-Addressable::URI::NormalizeCharacterClasses::FRAGMENT = T.let(T.unsafe(nil), Regexp)
-Addressable::URI::NormalizeCharacterClasses::HOST = T.let(T.unsafe(nil), Regexp)
-Addressable::URI::NormalizeCharacterClasses::PCHAR = T.let(T.unsafe(nil), Regexp)
-Addressable::URI::NormalizeCharacterClasses::QUERY = T.let(T.unsafe(nil), Regexp)
-Addressable::URI::NormalizeCharacterClasses::SCHEME = T.let(T.unsafe(nil), Regexp)
-Addressable::URI::NormalizeCharacterClasses::UNRESERVED = T.let(T.unsafe(nil), Regexp)
-Addressable::URI::PARENT = T.let(T.unsafe(nil), String)
-Addressable::URI::PORT_MAPPING = T.let(T.unsafe(nil), Hash)
-Addressable::URI::RULE_2A = T.let(T.unsafe(nil), Regexp)
-Addressable::URI::RULE_2B_2C = T.let(T.unsafe(nil), Regexp)
-Addressable::URI::RULE_2D = T.let(T.unsafe(nil), Regexp)
-Addressable::URI::RULE_PREFIXED_PARENT = T.let(T.unsafe(nil), Regexp)
-Addressable::URI::SELF_REF = T.let(T.unsafe(nil), String)
-Addressable::URI::SEQUENCE_ENCODING_TABLE = T.let(T.unsafe(nil), Hash)
-Addressable::URI::SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE = T.let(T.unsafe(nil), Hash)
-Addressable::URI::SLASH = T.let(T.unsafe(nil), String)
-Addressable::URI::URIREGEX = T.let(T.unsafe(nil), Regexp)
-module Addressable::VERSION; end
-Addressable::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
-Addressable::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
-Addressable::VERSION::STRING = T.let(T.unsafe(nil), String)
-Addressable::VERSION::TINY = T.let(T.unsafe(nil), Integer)
diff --git a/Library/Homebrew/sorbet/rbi/gems/addressable@2.8.7.rbi b/Library/Homebrew/sorbet/rbi/gems/addressable@2.8.7.rbi
new file mode 100644
index 0000000000000..eb8dae4207bb1
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/addressable@2.8.7.rbi
@@ -0,0 +1,1994 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `addressable` gem.
+# Please instead update this file by running `bin/tapioca gem addressable`.
+
+
+# Addressable is a library for processing links and URIs.
+#
+# source://addressable//lib/addressable/version.rb#22
+module Addressable; end
+
+# source://addressable//lib/addressable/idna/pure.rb#21
+module Addressable::IDNA
+  class << self
+    # source://addressable//lib/addressable/idna/pure.rb#117
+    def _deprecated_unicode_normalize_kc(value); end
+
+    # Converts from a Unicode internationalized domain name to an ASCII
+    # domain name as described in RFC 3490.
+    #
+    # source://addressable//lib/addressable/idna/pure.rb#67
+    def to_ascii(input); end
+
+    # Converts from an ASCII domain name to a Unicode internationalized
+    # domain name as described in RFC 3490.
+    #
+    # source://addressable//lib/addressable/idna/pure.rb#93
+    def to_unicode(input); end
+
+    # @deprecated Use {String#unicode_normalize(:nfkc)} instead
+    def unicode_normalize_kc(*args, **_arg1, &block); end
+
+    private
+
+    # source://addressable//lib/addressable/idna/pure.rb#140
+    def lookup_unicode_lowercase(codepoint); end
+
+    # Bias adaptation method
+    #
+    # source://addressable//lib/addressable/idna/pure.rb#488
+    def punycode_adapt(delta, numpoints, firsttime); end
+
+    # @return [Boolean]
+    #
+    # source://addressable//lib/addressable/idna/pure.rb#456
+    def punycode_basic?(codepoint); end
+
+    # source://addressable//lib/addressable/idna/pure.rb#334
+    def punycode_decode(punycode); end
+
+    # Returns the numeric value of a basic codepoint
+    # (for use in representing integers) in the range 0 to
+    # base - 1, or PUNYCODE_BASE if codepoint does not represent a value.
+    #
+    # source://addressable//lib/addressable/idna/pure.rb#474
+    def punycode_decode_digit(codepoint); end
+
+    # @return [Boolean]
+    #
+    # source://addressable//lib/addressable/idna/pure.rb#461
+    def punycode_delimiter?(codepoint); end
+
+    # source://addressable//lib/addressable/idna/pure.rb#213
+    def punycode_encode(unicode); end
+
+    # source://addressable//lib/addressable/idna/pure.rb#466
+    def punycode_encode_digit(d); end
+
+    # Unicode aware downcase method.
+    #
+    # @api private
+    # @param input [String] The input string.
+    # @return [String] The downcased result.
+    #
+    # source://addressable//lib/addressable/idna/pure.rb#132
+    def unicode_downcase(input); end
+  end
+end
+
+# source://addressable//lib/addressable/idna/pure.rb#183
+Addressable::IDNA::ACE_MAX_LENGTH = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#40
+Addressable::IDNA::ACE_PREFIX = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/idna/pure.rb#172
+Addressable::IDNA::COMPOSITION_TABLE = T.let(T.unsafe(nil), Hash)
+
+# source://addressable//lib/addressable/idna/pure.rb#185
+Addressable::IDNA::PUNYCODE_BASE = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#189
+Addressable::IDNA::PUNYCODE_DAMP = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#192
+Addressable::IDNA::PUNYCODE_DELIMITER = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#190
+Addressable::IDNA::PUNYCODE_INITIAL_BIAS = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#191
+Addressable::IDNA::PUNYCODE_INITIAL_N = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#194
+Addressable::IDNA::PUNYCODE_MAXINT = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#196
+Addressable::IDNA::PUNYCODE_PRINT_ASCII = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/idna/pure.rb#188
+Addressable::IDNA::PUNYCODE_SKEW = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#187
+Addressable::IDNA::PUNYCODE_TMAX = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#186
+Addressable::IDNA::PUNYCODE_TMIN = T.let(T.unsafe(nil), Integer)
+
+# Input is invalid.
+#
+# source://addressable//lib/addressable/idna/pure.rb#207
+class Addressable::IDNA::PunycodeBadInput < ::StandardError; end
+
+# Output would exceed the space provided.
+#
+# source://addressable//lib/addressable/idna/pure.rb#209
+class Addressable::IDNA::PunycodeBigOutput < ::StandardError; end
+
+# Input needs wider integers to process.
+#
+# source://addressable//lib/addressable/idna/pure.rb#211
+class Addressable::IDNA::PunycodeOverflow < ::StandardError; end
+
+# source://addressable//lib/addressable/idna/pure.rb#163
+Addressable::IDNA::UNICODE_DATA = T.let(T.unsafe(nil), Hash)
+
+# source://addressable//lib/addressable/idna/pure.rb#150
+Addressable::IDNA::UNICODE_DATA_CANONICAL = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#148
+Addressable::IDNA::UNICODE_DATA_COMBINING_CLASS = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#151
+Addressable::IDNA::UNICODE_DATA_COMPATIBILITY = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#149
+Addressable::IDNA::UNICODE_DATA_EXCLUSION = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#153
+Addressable::IDNA::UNICODE_DATA_LOWERCASE = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#154
+Addressable::IDNA::UNICODE_DATA_TITLECASE = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#152
+Addressable::IDNA::UNICODE_DATA_UPPERCASE = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#182
+Addressable::IDNA::UNICODE_MAX_LENGTH = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/idna/pure.rb#36
+Addressable::IDNA::UNICODE_TABLE = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/idna/pure.rb#42
+Addressable::IDNA::UTF8_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/idna/pure.rb#53
+Addressable::IDNA::UTF8_REGEX_MULTIBYTE = T.let(T.unsafe(nil), Regexp)
+
+# This is an implementation of a URI template based on
+# RFC 6570 (http://tools.ietf.org/html/rfc6570).
+#
+# source://addressable//lib/addressable/template.rb#27
+class Addressable::Template
+  # Creates a new <tt>Addressable::Template</tt> object.
+  #
+  # @param pattern [#to_str] The URI Template pattern.
+  # @return [Addressable::Template] The initialized Template object.
+  #
+  # source://addressable//lib/addressable/template.rb#234
+  def initialize(pattern); end
+
+  # Returns <code>true</code> if the Template objects are equal. This method
+  # does NOT normalize either Template before doing the comparison.
+  #
+  # @param template [Object] The Template to compare.
+  # @return [TrueClass, FalseClass] <code>true</code> if the Templates are equivalent, <code>false</code>
+  #   otherwise.
+  #
+  # source://addressable//lib/addressable/template.rb#274
+  def ==(template); end
+
+  # Returns <code>true</code> if the Template objects are equal. This method
+  # does NOT normalize either Template before doing the comparison.
+  # Addressable::Template makes no distinction between `==` and `eql?`.
+  #
+  # @param template [Object] The Template to compare.
+  # @return [TrueClass, FalseClass] <code>true</code> if the Templates are equivalent, <code>false</code>
+  #   otherwise.
+  # @see #==
+  #
+  # source://addressable//lib/addressable/template.rb#274
+  def eql?(template); end
+
+  # Expands a URI template into a full URI.
+  #
+  # The object should respond to either the <tt>validate</tt> or
+  # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
+  # <tt>transform</tt> methods should take two parameters: <tt>name</tt> and
+  # <tt>value</tt>. The <tt>validate</tt> method should return <tt>true</tt>
+  # or <tt>false</tt>; <tt>true</tt> if the value of the variable is valid,
+  # <tt>false</tt> otherwise. An <tt>InvalidTemplateValueError</tt>
+  # exception will be raised if the value is invalid. The <tt>transform</tt>
+  # method should return the transformed variable value as a <tt>String</tt>.
+  # If a <tt>transform</tt> method is used, the value will not be percent
+  # encoded automatically. Unicode normalization will be performed both
+  # before and after sending the value to the transform method.
+  #
+  # @example
+  #   class ExampleProcessor
+  #   def self.validate(name, value)
+  #   return !!(value =~ /^[\w ]+$/) if name == "query"
+  #   return true
+  #   end
+  #
+  #   def self.transform(name, value)
+  #   return value.gsub(/ /, "+") if name == "query"
+  #   return value
+  #   end
+  #   end
+  #
+  #   Addressable::Template.new(
+  #   "http://example.com/search/{query}/"
+  #   ).expand(
+  #   {"query" => "an example search query"},
+  #   ExampleProcessor
+  #   ).to_str
+  #   #=> "http://example.com/search/an+example+search+query/"
+  #
+  #   Addressable::Template.new(
+  #   "http://example.com/search/{query}/"
+  #   ).expand(
+  #   {"query" => "an example search query"}
+  #   ).to_str
+  #   #=> "http://example.com/search/an%20example%20search%20query/"
+  #
+  #   Addressable::Template.new(
+  #   "http://example.com/search/{query}/"
+  #   ).expand(
+  #   {"query" => "bogus!"},
+  #   ExampleProcessor
+  #   ).to_str
+  #   #=> Addressable::Template::InvalidTemplateValueError
+  # @param mapping [Hash] The mapping that corresponds to the pattern.
+  # @param processor [#validate, #transform] An optional processor object may be supplied.
+  # @param normalize_values [Boolean] Optional flag to enable/disable unicode normalization. Default: true
+  # @return [Addressable::URI] The expanded URI template.
+  #
+  # source://addressable//lib/addressable/template.rb#591
+  def expand(mapping, processor = T.unsafe(nil), normalize_values = T.unsafe(nil)); end
+
+  # Extracts a mapping from the URI using a URI Template pattern.
+  #
+  # @example
+  #   class ExampleProcessor
+  #   def self.restore(name, value)
+  #   return value.gsub(/\+/, " ") if name == "query"
+  #   return value
+  #   end
+  #
+  #   def self.match(name)
+  #   return ".*?" if name == "first"
+  #   return ".*"
+  #   end
+  #   end
+  #
+  #   uri = Addressable::URI.parse(
+  #   "http://example.com/search/an+example+search+query/"
+  #   )
+  #   Addressable::Template.new(
+  #   "http://example.com/search/{query}/"
+  #   ).extract(uri, ExampleProcessor)
+  #   #=> {"query" => "an example search query"}
+  #
+  #   uri = Addressable::URI.parse("http://example.com/a/b/c/")
+  #   Addressable::Template.new(
+  #   "http://example.com/{first}/{second}/"
+  #   ).extract(uri, ExampleProcessor)
+  #   #=> {"first" => "a", "second" => "b/c"}
+  #
+  #   uri = Addressable::URI.parse("http://example.com/a/b/c/")
+  #   Addressable::Template.new(
+  #   "http://example.com/{first}/{-list|/|second}/"
+  #   ).extract(uri)
+  #   #=> {"first" => "a", "second" => ["b", "c"]}
+  # @param uri [Addressable::URI, #to_str] The URI to extract from.
+  # @param processor [#restore, #match] A template processor object may optionally be supplied.
+  #
+  #   The object should respond to either the <tt>restore</tt> or
+  #   <tt>match</tt> messages or both. The <tt>restore</tt> method should
+  #   take two parameters: `[String] name` and `[String] value`.
+  #   The <tt>restore</tt> method should reverse any transformations that
+  #   have been performed on the value to ensure a valid URI.
+  #   The <tt>match</tt> method should take a single
+  #   parameter: `[String] name`.  The <tt>match</tt> method should return
+  #   a <tt>String</tt> containing a regular expression capture group for
+  #   matching on that particular variable. The default value is `".*?"`.
+  #   The <tt>match</tt> method has no effect on multivariate operator
+  #   expansions.
+  # @return [Hash, NilClass] The <tt>Hash</tt> mapping that was extracted from the URI, or
+  #   <tt>nil</tt> if the URI didn't match the template.
+  #
+  # source://addressable//lib/addressable/template.rb#342
+  def extract(uri, processor = T.unsafe(nil)); end
+
+  # Freeze URI, initializing instance variables.
+  #
+  # @return [Addressable::URI] The frozen URI object.
+  #
+  # source://addressable//lib/addressable/template.rb#245
+  def freeze; end
+
+  # Returns a <tt>String</tt> representation of the Template object's state.
+  #
+  # @return [String] The Template object's state, as a <tt>String</tt>.
+  #
+  # source://addressable//lib/addressable/template.rb#260
+  def inspect; end
+
+  # Returns an Array of variables used within the template pattern.
+  # The variables are listed in the Array in the order they appear within
+  # the pattern.  Multiple occurrences of a variable within a pattern are
+  # not represented in this Array.
+  #
+  # @return [Array] The variables present in the template's pattern.
+  #
+  # source://addressable//lib/addressable/template.rb#607
+  def keys; end
+
+  # Extracts match data from the URI using a URI Template pattern.
+  #
+  # @example
+  #   class ExampleProcessor
+  #   def self.restore(name, value)
+  #   return value.gsub(/\+/, " ") if name == "query"
+  #   return value
+  #   end
+  #
+  #   def self.match(name)
+  #   return ".*?" if name == "first"
+  #   return ".*"
+  #   end
+  #   end
+  #
+  #   uri = Addressable::URI.parse(
+  #   "http://example.com/search/an+example+search+query/"
+  #   )
+  #   match = Addressable::Template.new(
+  #   "http://example.com/search/{query}/"
+  #   ).match(uri, ExampleProcessor)
+  #   match.variables
+  #   #=> ["query"]
+  #   match.captures
+  #   #=> ["an example search query"]
+  #
+  #   uri = Addressable::URI.parse("http://example.com/a/b/c/")
+  #   match = Addressable::Template.new(
+  #   "http://example.com/{first}/{+second}/"
+  #   ).match(uri, ExampleProcessor)
+  #   match.variables
+  #   #=> ["first", "second"]
+  #   match.captures
+  #   #=> ["a", "b/c"]
+  #
+  #   uri = Addressable::URI.parse("http://example.com/a/b/c/")
+  #   match = Addressable::Template.new(
+  #   "http://example.com/{first}{/second*}/"
+  #   ).match(uri)
+  #   match.variables
+  #   #=> ["first", "second"]
+  #   match.captures
+  #   #=> ["a", ["b", "c"]]
+  # @param uri [Addressable::URI, #to_str] The URI to extract from.
+  # @param processor [#restore, #match] A template processor object may optionally be supplied.
+  #
+  #   The object should respond to either the <tt>restore</tt> or
+  #   <tt>match</tt> messages or both. The <tt>restore</tt> method should
+  #   take two parameters: `[String] name` and `[String] value`.
+  #   The <tt>restore</tt> method should reverse any transformations that
+  #   have been performed on the value to ensure a valid URI.
+  #   The <tt>match</tt> method should take a single
+  #   parameter: `[String] name`. The <tt>match</tt> method should return
+  #   a <tt>String</tt> containing a regular expression capture group for
+  #   matching on that particular variable. The default value is `".*?"`.
+  #   The <tt>match</tt> method has no effect on multivariate operator
+  #   expansions.
+  # @return [Hash, NilClass] The <tt>Hash</tt> mapping that was extracted from the URI, or
+  #   <tt>nil</tt> if the URI didn't match the template.
+  #
+  # source://addressable//lib/addressable/template.rb#413
+  def match(uri, processor = T.unsafe(nil)); end
+
+  # Returns the named captures of the coerced `Regexp`.
+  #
+  # @api private
+  # @return [Hash] The named captures of the `Regexp` given by {#to_regexp}.
+  #
+  # source://addressable//lib/addressable/template.rb#651
+  def named_captures; end
+
+  # Returns an Array of variables used within the template pattern.
+  # The variables are listed in the Array in the order they appear within
+  # the pattern.  Multiple occurrences of a variable within a pattern are
+  # not represented in this Array.
+  #
+  # @return [Array] The variables present in the template's pattern.
+  #
+  # source://addressable//lib/addressable/template.rb#607
+  def names; end
+
+  # Expands a URI template into another URI template.
+  #
+  # The object should respond to either the <tt>validate</tt> or
+  # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
+  # <tt>transform</tt> methods should take two parameters: <tt>name</tt> and
+  # <tt>value</tt>. The <tt>validate</tt> method should return <tt>true</tt>
+  # or <tt>false</tt>; <tt>true</tt> if the value of the variable is valid,
+  # <tt>false</tt> otherwise. An <tt>InvalidTemplateValueError</tt>
+  # exception will be raised if the value is invalid. The <tt>transform</tt>
+  # method should return the transformed variable value as a <tt>String</tt>.
+  # If a <tt>transform</tt> method is used, the value will not be percent
+  # encoded automatically. Unicode normalization will be performed both
+  # before and after sending the value to the transform method.
+  #
+  # @example
+  #   Addressable::Template.new(
+  #   "http://example.com/{one}/{two}/"
+  #   ).partial_expand({"one" => "1"}).pattern
+  #   #=> "http://example.com/1/{two}/"
+  #
+  #   Addressable::Template.new(
+  #   "http://example.com/{?one,two}/"
+  #   ).partial_expand({"one" => "1"}).pattern
+  #   #=> "http://example.com/?one=1{&two}/"
+  #
+  #   Addressable::Template.new(
+  #   "http://example.com/{?one,two,three}/"
+  #   ).partial_expand({"one" => "1", "three" => 3}).pattern
+  #   #=> "http://example.com/?one=1{&two}&three=3"
+  # @param mapping [Hash] The mapping that corresponds to the pattern.
+  # @param processor [#validate, #transform] An optional processor object may be supplied.
+  # @param normalize_values [Boolean] Optional flag to enable/disable unicode normalization. Default: true
+  # @return [Addressable::Template] The partially expanded URI template.
+  #
+  # source://addressable//lib/addressable/template.rb#524
+  def partial_expand(mapping, processor = T.unsafe(nil), normalize_values = T.unsafe(nil)); end
+
+  # @return [String] The Template object's pattern.
+  #
+  # source://addressable//lib/addressable/template.rb#254
+  def pattern; end
+
+  # Returns the source of the coerced `Regexp`.
+  #
+  # @api private
+  # @return [String] The source of the `Regexp` given by {#to_regexp}.
+  #
+  # source://addressable//lib/addressable/template.rb#641
+  def source; end
+
+  # Coerces a template into a `Regexp` object. This regular expression will
+  # behave very similarly to the actual template, and should match the same
+  # URI values, but it cannot fully handle, for example, values that would
+  # extract to an `Array`.
+  #
+  # @return [Regexp] A regular expression which should match the template.
+  #
+  # source://addressable//lib/addressable/template.rb#630
+  def to_regexp; end
+
+  # Returns a mapping of variables to their default values specified
+  # in the template. Variables without defaults are not returned.
+  #
+  # @return [Hash] Mapping of template variables to their defaults
+  #
+  # source://addressable//lib/addressable/template.rb#618
+  def variable_defaults; end
+
+  # Returns an Array of variables used within the template pattern.
+  # The variables are listed in the Array in the order they appear within
+  # the pattern.  Multiple occurrences of a variable within a pattern are
+  # not represented in this Array.
+  #
+  # @return [Array] The variables present in the template's pattern.
+  #
+  # source://addressable//lib/addressable/template.rb#607
+  def variables; end
+
+  private
+
+  # Takes a set of values, and joins them together based on the
+  # operator.
+  #
+  # @param operator [String, Nil] One of the operators from the set
+  #   (?,&,+,#,;,/,.), or nil if there wasn't one.
+  # @param return_value [Array] The set of return values (as [variable_name, value] tuples) that will
+  #   be joined together.
+  # @return [String] The transformed mapped value
+  #
+  # source://addressable//lib/addressable/template.rb#861
+  def join_values(operator, return_value); end
+
+  # Generates a hash with string keys
+  #
+  # @param mapping [Hash] A mapping hash to normalize
+  # @return [Hash] A hash with stringified keys
+  #
+  # source://addressable//lib/addressable/template.rb#924
+  def normalize_keys(mapping); end
+
+  # Takes a set of values, and joins them together based on the
+  # operator.
+  #
+  # @param value [Hash, Array, String] Normalizes unicode keys and values with String#unicode_normalize (NFC)
+  # @return [Hash, Array, String] The normalized values
+  #
+  # source://addressable//lib/addressable/template.rb#898
+  def normalize_value(value); end
+
+  # source://addressable//lib/addressable/template.rb#656
+  def ordered_variable_defaults; end
+
+  # Generates the <tt>Regexp</tt> that parses a template pattern.
+  #
+  # @param pattern [String] The URI template pattern.
+  # @param processor [#match] The template processor to use.
+  # @return [Array, Regexp] An array of expansion variables nad a regular expression which may be
+  #   used to parse a template pattern
+  #
+  # source://addressable//lib/addressable/template.rb#968
+  def parse_new_template_pattern(pattern, processor = T.unsafe(nil)); end
+
+  # Generates the <tt>Regexp</tt> that parses a template pattern. Memoizes the
+  # value if template processor not set (processors may not be deterministic)
+  #
+  # @param pattern [String] The URI template pattern.
+  # @param processor [#match] The template processor to use.
+  # @return [Array, Regexp] An array of expansion variables nad a regular expression which may be
+  #   used to parse a template pattern
+  #
+  # source://addressable//lib/addressable/template.rb#950
+  def parse_template_pattern(pattern, processor = T.unsafe(nil)); end
+
+  # Transforms a mapped value so that values can be substituted into the
+  # template.
+  #
+  # The object should respond to either the <tt>validate</tt> or
+  # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
+  # <tt>transform</tt> methods should take two parameters: <tt>name</tt> and
+  # <tt>value</tt>. The <tt>validate</tt> method should return <tt>true</tt>
+  # or <tt>false</tt>; <tt>true</tt> if the value of the variable is valid,
+  # <tt>false</tt> otherwise. An <tt>InvalidTemplateValueError</tt> exception
+  # will be raised if the value is invalid. The <tt>transform</tt> method
+  # should return the transformed variable value as a <tt>String</tt>. If a
+  # <tt>transform</tt> method is used, the value will not be percent encoded
+  # automatically. Unicode normalization will be performed both before and
+  # after sending the value to the transform method.
+  #
+  # @param mapping [Hash] The mapping to replace captures
+  # @param capture [String] The expression to replace
+  # @param processor [#validate, #transform] An optional processor object may be supplied.
+  # @param normalize_values [Boolean] Optional flag to enable/disable unicode normalization. Default: true
+  # @return [String] The expanded expression
+  #
+  # source://addressable//lib/addressable/template.rb#753
+  def transform_capture(mapping, capture, processor = T.unsafe(nil), normalize_values = T.unsafe(nil)); end
+
+  # Loops through each capture and expands any values available in mapping
+  #
+  # The object should respond to either the <tt>validate</tt> or
+  # <tt>transform</tt> messages or both. Both the <tt>validate</tt> and
+  # <tt>transform</tt> methods should take two parameters: <tt>name</tt> and
+  # <tt>value</tt>. The <tt>validate</tt> method should return <tt>true</tt>
+  # or <tt>false</tt>; <tt>true</tt> if the value of the variable is valid,
+  # <tt>false</tt> otherwise. An <tt>InvalidTemplateValueError</tt> exception
+  # will be raised if the value is invalid. The <tt>transform</tt> method
+  # should return the transformed variable value as a <tt>String</tt>. If a
+  # <tt>transform</tt> method is used, the value will not be percent encoded
+  # automatically. Unicode normalization will be performed both before and
+  # after sending the value to the transform method.
+  #
+  # @param mapping [Hash] Set of keys to expand
+  # @param capture [String] The expression to expand
+  # @param processor [#validate, #transform] An optional processor object may be supplied.
+  # @param normalize_values [Boolean] Optional flag to enable/disable unicode normalization. Default: true
+  # @return [String] The expanded expression
+  #
+  # source://addressable//lib/addressable/template.rb#694
+  def transform_partial_capture(mapping, capture, processor = T.unsafe(nil), normalize_values = T.unsafe(nil)); end
+end
+
+# source://addressable//lib/addressable/template.rb#58
+Addressable::Template::EXPRESSION = T.let(T.unsafe(nil), Regexp)
+
+# Raised if an invalid template operator is used in a pattern.
+#
+# source://addressable//lib/addressable/template.rb#85
+class Addressable::Template::InvalidTemplateOperatorError < ::StandardError; end
+
+# Raised if an invalid template value is supplied.
+#
+# source://addressable//lib/addressable/template.rb#80
+class Addressable::Template::InvalidTemplateValueError < ::StandardError; end
+
+# source://addressable//lib/addressable/template.rb#70
+Addressable::Template::JOINERS = T.let(T.unsafe(nil), Hash)
+
+# source://addressable//lib/addressable/template.rb#62
+Addressable::Template::LEADERS = T.let(T.unsafe(nil), Hash)
+
+# This class represents the data that is extracted when a Template
+# is matched against a URI.
+#
+# source://addressable//lib/addressable/template.rb#96
+class Addressable::Template::MatchData
+  # Creates a new MatchData object.
+  # MatchData objects should never be instantiated directly.
+  #
+  # @param uri [Addressable::URI] The URI that the template was matched against.
+  # @return [MatchData] a new instance of MatchData
+  #
+  # source://addressable//lib/addressable/template.rb#103
+  def initialize(uri, template, mapping); end
+
+  # Accesses captured values by name or by index.
+  #
+  # @param key [String, Symbol, Fixnum] Capture index or name. Note that when accessing by with index
+  #   of 0, the full URI will be returned. The intention is to mimic
+  #   the ::MatchData#[] behavior.
+  # @param len [#to_int, nil] If provided, an array of values will be returned with the given
+  #   parameter used as length.
+  # @return [Array, String, nil] The captured value corresponding to the index or name. If the
+  #   value was not provided or the key is unknown, nil will be
+  #   returned.
+  #
+  #   If the second parameter is provided, an array of that length will
+  #   be returned instead.
+  #
+  # source://addressable//lib/addressable/template.rb#170
+  def [](key, len = T.unsafe(nil)); end
+
+  # @return [Array] The list of values that were captured by the Template.
+  #   Note that this list will include nils for any variables which
+  #   were in the Template, but did not appear in the URI.
+  #
+  # source://addressable//lib/addressable/template.rb#143
+  def captures; end
+
+  # Returns a <tt>String</tt> representation of the MatchData's state.
+  #
+  # @return [String] The MatchData's state, as a <tt>String</tt>.
+  #
+  # source://addressable//lib/addressable/template.rb#213
+  def inspect; end
+
+  # @return [Array] The list of variables that were present in the Template.
+  #   Note that this list will include variables which do not appear
+  #   in the mapping because they were not present in URI.
+  #
+  # source://addressable//lib/addressable/template.rb#132
+  def keys; end
+
+  # @return [Hash] The mapping that resulted from the match.
+  #   Note that this mapping does not include keys or values for
+  #   variables that appear in the Template, but are not present
+  #   in the URI.
+  #
+  # source://addressable//lib/addressable/template.rb#125
+  def mapping; end
+
+  # @return [Array] The list of variables that were present in the Template.
+  #   Note that this list will include variables which do not appear
+  #   in the mapping because they were not present in URI.
+  #
+  # source://addressable//lib/addressable/template.rb#132
+  def names; end
+
+  # Dummy method for code expecting a ::MatchData instance
+  #
+  # @return [String] An empty string.
+  #
+  # source://addressable//lib/addressable/template.rb#222
+  def post_match; end
+
+  # Dummy method for code expecting a ::MatchData instance
+  #
+  # @return [String] An empty string.
+  #
+  # source://addressable//lib/addressable/template.rb#222
+  def pre_match; end
+
+  # @return [String] The matched URI as String.
+  #
+  # source://addressable//lib/addressable/template.rb#191
+  def string; end
+
+  # @return [Addressable::Template] The Template used for the match.
+  #
+  # source://addressable//lib/addressable/template.rb#117
+  def template; end
+
+  # @return [Array] Array with the matched URI as first element followed by the captured
+  #   values.
+  #
+  # source://addressable//lib/addressable/template.rb#184
+  def to_a; end
+
+  # @return [String] The matched URI as String.
+  #
+  # source://addressable//lib/addressable/template.rb#191
+  def to_s; end
+
+  # @return [Addressable::URI] The URI that the Template was matched against.
+  #
+  # source://addressable//lib/addressable/template.rb#112
+  def uri; end
+
+  # @return [Array] The list of values that were captured by the Template.
+  #   Note that this list will include nils for any variables which
+  #   were in the Template, but did not appear in the URI.
+  #
+  # source://addressable//lib/addressable/template.rb#143
+  def values; end
+
+  # Returns multiple captured values at once.
+  #
+  # @param *indexes [String, Symbol, Fixnum] Indices of the captures to be returned
+  # @return [Array] Values corresponding to given indices.
+  # @see Addressable::Template::MatchData#[]
+  #
+  # source://addressable//lib/addressable/template.rb#205
+  def values_at(*indexes); end
+
+  # @return [Array] The list of variables that were present in the Template.
+  #   Note that this list will include variables which do not appear
+  #   in the mapping because they were not present in URI.
+  #
+  # source://addressable//lib/addressable/template.rb#132
+  def variables; end
+end
+
+# source://addressable//lib/addressable/template.rb#40
+Addressable::Template::RESERVED = T.let(T.unsafe(nil), String)
+
+# Raised if an invalid template operator is used in a pattern.
+#
+# source://addressable//lib/addressable/template.rb#90
+class Addressable::Template::TemplateOperatorAbortedError < ::StandardError; end
+
+# source://addressable//lib/addressable/template.rb#42
+Addressable::Template::UNRESERVED = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/template.rb#54
+Addressable::Template::VARIABLE_LIST = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/template.rb#50
+Addressable::Template::VARNAME = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/template.rb#52
+Addressable::Template::VARSPEC = T.let(T.unsafe(nil), Regexp)
+
+# This is an implementation of a URI parser based on
+# <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>,
+# <a href="http://www.ietf.org/rfc/rfc3987.txt">RFC 3987</a>.
+#
+# source://addressable//lib/addressable/uri.rb#31
+class Addressable::URI
+  # Creates a new uri object from component parts.
+  #
+  # @option [String,
+  # @option [String,
+  # @option [String,
+  # @option [String,
+  # @option [String,
+  # @option [String,
+  # @option [String,
+  # @option [String,
+  # @option [String,
+  # @option [String,
+  # @param [String, [Hash] a customizable set of options
+  # @return [Addressable::URI] The constructed URI object.
+  #
+  # source://addressable//lib/addressable/uri.rb#830
+  def initialize(options = T.unsafe(nil)); end
+
+  # Joins two URIs together.
+  #
+  # @param The [String, Addressable::URI, #to_str] URI to join with.
+  # @return [Addressable::URI] The joined URI.
+  #
+  # source://addressable//lib/addressable/uri.rb#1889
+  def +(uri); end
+
+  # Returns <code>true</code> if the URI objects are equal. This method
+  # normalizes both URIs before doing the comparison.
+  #
+  # @param uri [Object] The URI to compare.
+  # @return [TrueClass, FalseClass] <code>true</code> if the URIs are equivalent, <code>false</code>
+  #   otherwise.
+  #
+  # source://addressable//lib/addressable/uri.rb#2239
+  def ==(uri); end
+
+  # Returns <code>true</code> if the URI objects are equal. This method
+  # normalizes both URIs before doing the comparison, and allows comparison
+  # against <code>Strings</code>.
+  #
+  # @param uri [Object] The URI to compare.
+  # @return [TrueClass, FalseClass] <code>true</code> if the URIs are equivalent, <code>false</code>
+  #   otherwise.
+  #
+  # source://addressable//lib/addressable/uri.rb#2217
+  def ===(uri); end
+
+  # Determines if the URI is absolute.
+  #
+  # @return [TrueClass, FalseClass] <code>true</code> if the URI is absolute. <code>false</code>
+  #   otherwise.
+  #
+  # source://addressable//lib/addressable/uri.rb#1879
+  def absolute?; end
+
+  # The authority component for this URI.
+  # Combines the user, password, host, and port components.
+  #
+  # @return [String] The authority component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1234
+  def authority; end
+
+  # Sets the authority component for this URI.
+  #
+  # @param new_authority [String, #to_str] The new authority component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1274
+  def authority=(new_authority); end
+
+  # The basename, if any, of the file in the path component.
+  #
+  # @return [String] The path's basename.
+  #
+  # source://addressable//lib/addressable/uri.rb#1588
+  def basename; end
+
+  # The default port for this URI's scheme.
+  # This method will always returns the default port for the URI's scheme
+  # regardless of the presence of an explicit port in the URI.
+  #
+  # @return [Integer] The default port.
+  #
+  # source://addressable//lib/addressable/uri.rb#1454
+  def default_port; end
+
+  # This method allows you to make several changes to a URI simultaneously,
+  # which separately would cause validation errors, but in conjunction,
+  # are valid.  The URI will be revalidated as soon as the entire block has
+  # been executed.
+  #
+  # @param block [Proc] A set of operations to perform on a given URI.
+  #
+  # source://addressable//lib/addressable/uri.rb#2396
+  def defer_validation; end
+
+  # Creates a URI suitable for display to users. If semantic attacks are
+  # likely, the application should try to detect these and warn the user.
+  # See <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>,
+  # section 7.6 for more information.
+  #
+  # @return [Addressable::URI] A URI suitable for display purposes.
+  #
+  # source://addressable//lib/addressable/uri.rb#2201
+  def display_uri; end
+
+  # Returns the public suffix domain for this host.
+  #
+  # @example
+  #   Addressable::URI.parse("http://www.example.co.uk").domain # => "example.co.uk"
+  #
+  # source://addressable//lib/addressable/uri.rb#1225
+  def domain; end
+
+  # Clones the URI object.
+  #
+  # @return [Addressable::URI] The cloned URI.
+  #
+  # source://addressable//lib/addressable/uri.rb#2271
+  def dup; end
+
+  # Determines if the URI is an empty string.
+  #
+  # @return [TrueClass, FalseClass] Returns <code>true</code> if empty, <code>false</code> otherwise.
+  #
+  # source://addressable//lib/addressable/uri.rb#2333
+  def empty?; end
+
+  # source://addressable//lib/addressable/uri.rb#2406
+  def encode_with(coder); end
+
+  # Returns <code>true</code> if the URI objects are equal. This method
+  # does NOT normalize either URI before doing the comparison.
+  #
+  # @param uri [Object] The URI to compare.
+  # @return [TrueClass, FalseClass] <code>true</code> if the URIs are equivalent, <code>false</code>
+  #   otherwise.
+  #
+  # source://addressable//lib/addressable/uri.rb#2253
+  def eql?(uri); end
+
+  # The extname, if any, of the file in the path component.
+  # Empty string if there is no extension.
+  #
+  # @return [String] The path's extname.
+  #
+  # source://addressable//lib/addressable/uri.rb#1598
+  def extname; end
+
+  # The fragment component for this URI.
+  #
+  # @return [String] The fragment component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1810
+  def fragment; end
+
+  # Sets the fragment component for this URI.
+  #
+  # @param new_fragment [String, #to_str] The new fragment component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1835
+  def fragment=(new_fragment); end
+
+  # Freeze URI, initializing instance variables.
+  #
+  # @return [Addressable::URI] The frozen URI object.
+  #
+  # source://addressable//lib/addressable/uri.rb#870
+  def freeze; end
+
+  # A hash value that will make a URI equivalent to its normalized
+  # form.
+  #
+  # @return [Integer] A hash of the URI.
+  #
+  # source://addressable//lib/addressable/uri.rb#2263
+  def hash; end
+
+  # The host component for this URI.
+  #
+  # @return [String] The host component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1120
+  def host; end
+
+  # Sets the host component for this URI.
+  #
+  # @param new_host [String, #to_str] The new host component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1156
+  def host=(new_host); end
+
+  # This method is same as URI::Generic#host except
+  # brackets for IPv6 (and 'IPvFuture') addresses are removed.
+  #
+  # @return [String] The hostname for this URI.
+  # @see Addressable::URI#host
+  #
+  # source://addressable//lib/addressable/uri.rb#1178
+  def hostname; end
+
+  # This method is same as URI::Generic#host= except
+  # the argument can be a bare IPv6 address (or 'IPvFuture').
+  #
+  # @param new_hostname [String, #to_str] The new hostname for this URI.
+  # @see Addressable::URI#host=
+  #
+  # source://addressable//lib/addressable/uri.rb#1190
+  def hostname=(new_hostname); end
+
+  # The inferred port component for this URI.
+  # This method will normalize to the default port for the URI's scheme if
+  # the port isn't explicitly specified in the URI.
+  #
+  # @return [Integer] The inferred port component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1440
+  def inferred_port; end
+
+  # source://addressable//lib/addressable/uri.rb#2417
+  def init_with(coder); end
+
+  # Returns a <code>String</code> representation of the URI object's state.
+  #
+  # @return [String] The URI object's state, as a <code>String</code>.
+  #
+  # source://addressable//lib/addressable/uri.rb#2384
+  def inspect; end
+
+  # Determines if the scheme indicates an IP-based protocol.
+  #
+  # @return [TrueClass, FalseClass] <code>true</code> if the scheme indicates an IP-based protocol.
+  #   <code>false</code> otherwise.
+  #
+  # source://addressable//lib/addressable/uri.rb#1855
+  def ip_based?; end
+
+  # Joins two URIs together.
+  #
+  # @param The [String, Addressable::URI, #to_str] URI to join with.
+  # @return [Addressable::URI] The joined URI.
+  #
+  # source://addressable//lib/addressable/uri.rb#1889
+  def join(uri); end
+
+  # Destructive form of <code>join</code>.
+  #
+  # @param The [String, Addressable::URI, #to_str] URI to join with.
+  # @return [Addressable::URI] The joined URI.
+  # @see Addressable::URI#join
+  #
+  # source://addressable//lib/addressable/uri.rb#1992
+  def join!(uri); end
+
+  # Merges a URI with a <code>Hash</code> of components.
+  # This method has different behavior from <code>join</code>. Any
+  # components present in the <code>hash</code> parameter will override the
+  # original components. The path component is not treated specially.
+  #
+  # @param The [Hash, Addressable::URI, #to_hash] components to merge with.
+  # @return [Addressable::URI] The merged URI.
+  # @see Hash#merge
+  #
+  # source://addressable//lib/addressable/uri.rb#2007
+  def merge(hash); end
+
+  # Destructive form of <code>merge</code>.
+  #
+  # @param The [Hash, Addressable::URI, #to_hash] components to merge with.
+  # @return [Addressable::URI] The merged URI.
+  # @see Addressable::URI#merge
+  #
+  # source://addressable//lib/addressable/uri.rb#2072
+  def merge!(uri); end
+
+  # Returns a normalized URI object.
+  #
+  # NOTE: This method does not attempt to fully conform to specifications.
+  # It exists largely to correct other people's failures to read the
+  # specifications, and also to deal with caching issues since several
+  # different URIs may represent the same resource and should not be
+  # cached multiple times.
+  #
+  # @return [Addressable::URI] The normalized URI.
+  #
+  # source://addressable//lib/addressable/uri.rb#2164
+  def normalize; end
+
+  # Destructively normalizes this URI object.
+  #
+  # @return [Addressable::URI] The normalized URI.
+  # @see Addressable::URI#normalize
+  #
+  # source://addressable//lib/addressable/uri.rb#2190
+  def normalize!; end
+
+  # The authority component for this URI, normalized.
+  #
+  # @return [String] The authority component, normalized.
+  #
+  # source://addressable//lib/addressable/uri.rb#1252
+  def normalized_authority; end
+
+  # The fragment component for this URI, normalized.
+  #
+  # @return [String] The fragment component, normalized.
+  #
+  # source://addressable//lib/addressable/uri.rb#1816
+  def normalized_fragment; end
+
+  # The host component for this URI, normalized.
+  #
+  # @return [String] The host component, normalized.
+  #
+  # source://addressable//lib/addressable/uri.rb#1126
+  def normalized_host; end
+
+  # The password component for this URI, normalized.
+  #
+  # @return [String] The password component, normalized.
+  #
+  # source://addressable//lib/addressable/uri.rb#1002
+  def normalized_password; end
+
+  # The path component for this URI, normalized.
+  #
+  # @return [String] The path component, normalized.
+  #
+  # source://addressable//lib/addressable/uri.rb#1535
+  def normalized_path; end
+
+  # The port component for this URI, normalized.
+  #
+  # @return [Integer] The port component, normalized.
+  #
+  # source://addressable//lib/addressable/uri.rb#1392
+  def normalized_port; end
+
+  # The query component for this URI, normalized.
+  #
+  # @return [String] The query component, normalized.
+  #
+  # source://addressable//lib/addressable/uri.rb#1613
+  def normalized_query(*flags); end
+
+  # The scheme component for this URI, normalized.
+  #
+  # @return [String] The scheme component, normalized.
+  #
+  # source://addressable//lib/addressable/uri.rb#896
+  def normalized_scheme; end
+
+  # The normalized combination of components that represent a site.
+  # Combines the scheme, user, password, host, and port components.
+  # Primarily useful for HTTP and HTTPS.
+  #
+  # For example, <code>"http://example.com/path?query"</code> would have a
+  # <code>site</code> value of <code>"http://example.com"</code>.
+  #
+  # @return [String] The normalized components that identify a site.
+  #
+  # source://addressable//lib/addressable/uri.rb#1485
+  def normalized_site; end
+
+  # The user component for this URI, normalized.
+  #
+  # @return [String] The user component, normalized.
+  #
+  # source://addressable//lib/addressable/uri.rb#947
+  def normalized_user; end
+
+  # The userinfo component for this URI, normalized.
+  #
+  # @return [String] The userinfo component, normalized.
+  #
+  # source://addressable//lib/addressable/uri.rb#1068
+  def normalized_userinfo; end
+
+  # Omits components from a URI.
+  #
+  # @example
+  #   uri = Addressable::URI.parse("http://example.com/path?query")
+  #   #=> #<Addressable::URI:0xcc5e7a URI:http://example.com/path?query>
+  #   uri.omit(:scheme, :authority)
+  #   #=> #<Addressable::URI:0xcc4d86 URI:/path?query>
+  # @param *components [Symbol] The components to be omitted.
+  # @return [Addressable::URI] The URI with components omitted.
+  #
+  # source://addressable//lib/addressable/uri.rb#2297
+  def omit(*components); end
+
+  # Destructive form of omit.
+  #
+  # @param *components [Symbol] The components to be omitted.
+  # @return [Addressable::URI] The URI with components omitted.
+  # @see Addressable::URI#omit
+  #
+  # source://addressable//lib/addressable/uri.rb#2324
+  def omit!(*components); end
+
+  # The origin for this URI, serialized to ASCII, as per
+  # RFC 6454, section 6.2.
+  #
+  # @return [String] The serialized origin.
+  #
+  # source://addressable//lib/addressable/uri.rb#1314
+  def origin; end
+
+  # Sets the origin for this URI, serialized to ASCII, as per
+  # RFC 6454, section 6.2. This assignment will reset the `userinfo`
+  # component.
+  #
+  # @param new_origin [String, #to_str] The new origin component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1333
+  def origin=(new_origin); end
+
+  # The password component for this URI.
+  #
+  # @return [String] The password component.
+  #
+  # source://addressable//lib/addressable/uri.rb#996
+  def password; end
+
+  # Sets the password component for this URI.
+  #
+  # @param new_password [String, #to_str] The new password component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1025
+  def password=(new_password); end
+
+  # The path component for this URI.
+  #
+  # @return [String] The path component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1528
+  def path; end
+
+  # Sets the path component for this URI.
+  #
+  # @param new_path [String, #to_str] The new path component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1567
+  def path=(new_path); end
+
+  # The port component for this URI.
+  # This is the port number actually given in the URI. This does not
+  # infer port numbers from default values.
+  #
+  # @return [Integer] The port component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1386
+  def port; end
+
+  # Sets the port component for this URI.
+  #
+  # @param new_port [String, Integer, #to_s] The new port component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1408
+  def port=(new_port); end
+
+  # The query component for this URI.
+  #
+  # @return [String] The query component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1607
+  def query; end
+
+  # Sets the query component for this URI.
+  #
+  # @param new_query [String, #to_str] The new query component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1641
+  def query=(new_query); end
+
+  # Converts the query component to a Hash value.
+  #
+  # @example
+  #   Addressable::URI.parse("?one=1&two=2&three=3").query_values
+  #   #=> {"one" => "1", "two" => "2", "three" => "3"}
+  #   Addressable::URI.parse("?one=two&one=three").query_values(Array)
+  #   #=> [["one", "two"], ["one", "three"]]
+  #   Addressable::URI.parse("?one=two&one=three").query_values(Hash)
+  #   #=> {"one" => "three"}
+  #   Addressable::URI.parse("?").query_values
+  #   #=> {}
+  #   Addressable::URI.parse("").query_values
+  #   #=> nil
+  # @param return_type [Class] The return type desired. Value must be either
+  #   `Hash` or `Array`.
+  # @return [Hash, Array, nil] The query string parsed as a Hash or Array
+  #   or nil if the query string is blank.
+  #
+  # source://addressable//lib/addressable/uri.rb#1672
+  def query_values(return_type = T.unsafe(nil)); end
+
+  # Sets the query component for this URI from a Hash object.
+  # An empty Hash or Array will result in an empty query string.
+  #
+  # @example
+  #   uri.query_values = {:a => "a", :b => ["c", "d", "e"]}
+  #   uri.query
+  #   # => "a=a&b=c&b=d&b=e"
+  #   uri.query_values = [['a', 'a'], ['b', 'c'], ['b', 'd'], ['b', 'e']]
+  #   uri.query
+  #   # => "a=a&b=c&b=d&b=e"
+  #   uri.query_values = [['a', 'a'], ['b', ['c', 'd', 'e']]]
+  #   uri.query
+  #   # => "a=a&b=c&b=d&b=e"
+  #   uri.query_values = [['flag'], ['key', 'value']]
+  #   uri.query
+  #   # => "flag&key=value"
+  # @param new_query_values [Hash, #to_hash, Array] The new query values.
+  #
+  # source://addressable//lib/addressable/uri.rb#1723
+  def query_values=(new_query_values); end
+
+  # Determines if the URI is relative.
+  #
+  # @return [TrueClass, FalseClass] <code>true</code> if the URI is relative. <code>false</code>
+  #   otherwise.
+  #
+  # source://addressable//lib/addressable/uri.rb#1869
+  def relative?; end
+
+  # The HTTP request URI for this URI.  This is the path and the
+  # query string.
+  #
+  # @return [String] The request URI required for an HTTP request.
+  #
+  # source://addressable//lib/addressable/uri.rb#1774
+  def request_uri; end
+
+  # Sets the HTTP request URI for this URI.
+  #
+  # @param new_request_uri [String, #to_str] The new HTTP request URI.
+  #
+  # source://addressable//lib/addressable/uri.rb#1786
+  def request_uri=(new_request_uri); end
+
+  # Returns the shortest normalized relative form of this URI that uses the
+  # supplied URI as a base for resolution. Returns an absolute URI if
+  # necessary. This is effectively the opposite of <code>route_to</code>.
+  #
+  # @param uri [String, Addressable::URI, #to_str] The URI to route from.
+  # @return [Addressable::URI] The normalized relative URI that is equivalent to the original URI.
+  #
+  # source://addressable//lib/addressable/uri.rb#2085
+  def route_from(uri); end
+
+  # Returns the shortest normalized relative form of the supplied URI that
+  # uses this URI as a base for resolution. Returns an absolute URI if
+  # necessary. This is effectively the opposite of <code>route_from</code>.
+  #
+  # @param uri [String, Addressable::URI, #to_str] The URI to route to.
+  # @return [Addressable::URI] The normalized relative URI that is equivalent to the supplied URI.
+  #
+  # source://addressable//lib/addressable/uri.rb#2150
+  def route_to(uri); end
+
+  # The scheme component for this URI.
+  #
+  # @return [String] The scheme component.
+  #
+  # source://addressable//lib/addressable/uri.rb#890
+  def scheme; end
+
+  # Sets the scheme component for this URI.
+  #
+  # @param new_scheme [String, #to_str] The new scheme component.
+  #
+  # source://addressable//lib/addressable/uri.rb#917
+  def scheme=(new_scheme); end
+
+  # The combination of components that represent a site.
+  # Combines the scheme, user, password, host, and port components.
+  # Primarily useful for HTTP and HTTPS.
+  #
+  # For example, <code>"http://example.com/path?query"</code> would have a
+  # <code>site</code> value of <code>"http://example.com"</code>.
+  #
+  # @return [String] The components that identify a site.
+  #
+  # source://addressable//lib/addressable/uri.rb#1467
+  def site; end
+
+  # Sets the site value for this URI.
+  #
+  # @param new_site [String, #to_str] The new site value.
+  #
+  # source://addressable//lib/addressable/uri.rb#1506
+  def site=(new_site); end
+
+  # Returns the top-level domain for this host.
+  #
+  # @example
+  #   Addressable::URI.parse("http://www.example.co.uk").tld # => "co.uk"
+  #
+  # source://addressable//lib/addressable/uri.rb#1207
+  def tld; end
+
+  # Sets the top-level domain for this URI.
+  #
+  # @param new_tld [String, #to_str] The new top-level domain.
+  #
+  # source://addressable//lib/addressable/uri.rb#1215
+  def tld=(new_tld); end
+
+  # Returns a Hash of the URI components.
+  #
+  # @return [Hash] The URI as a <code>Hash</code> of components.
+  #
+  # source://addressable//lib/addressable/uri.rb#2367
+  def to_hash; end
+
+  # Converts the URI to a <code>String</code>.
+  #
+  # @return [String] The URI's <code>String</code> representation.
+  #
+  # source://addressable//lib/addressable/uri.rb#2341
+  def to_s; end
+
+  # Converts the URI to a <code>String</code>.
+  # URI's are glorified <code>Strings</code>. Allow implicit conversion.
+  #
+  # @return [String] The URI's <code>String</code> representation.
+  #
+  # source://addressable//lib/addressable/uri.rb#2341
+  def to_str; end
+
+  # The user component for this URI.
+  #
+  # @return [String] The user component.
+  #
+  # source://addressable//lib/addressable/uri.rb#941
+  def user; end
+
+  # Sets the user component for this URI.
+  #
+  # @param new_user [String, #to_str] The new user component.
+  #
+  # source://addressable//lib/addressable/uri.rb#970
+  def user=(new_user); end
+
+  # The userinfo component for this URI.
+  # Combines the user and password components.
+  #
+  # @return [String] The userinfo component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1052
+  def userinfo; end
+
+  # Sets the userinfo component for this URI.
+  #
+  # @param new_userinfo [String, #to_str] The new userinfo component.
+  #
+  # source://addressable//lib/addressable/uri.rb#1091
+  def userinfo=(new_userinfo); end
+
+  protected
+
+  # Converts the string to be UTF-8 if it is not already UTF-8
+  #
+  # @api private
+  #
+  # source://addressable//lib/addressable/uri.rb#2561
+  def force_utf8_encoding_if_needed(str); end
+
+  # Resets composite values for the entire URI
+  #
+  # @api private
+  #
+  # source://addressable//lib/addressable/uri.rb#2552
+  def remove_composite_values; end
+
+  # Replaces the internal state of self with the specified URI's state.
+  # Used in destructive operations to avoid massive code repetition.
+  #
+  # @param uri [Addressable::URI] The URI to replace <code>self</code> with.
+  # @return [Addressable::URI] <code>self</code>.
+  #
+  # source://addressable//lib/addressable/uri.rb#2519
+  def replace_self(uri); end
+
+  # Splits path string with "/" (slash).
+  # It is considered that there is empty string after last slash when
+  # path ends with slash.
+  #
+  # @param path [String] The path to split.
+  # @return [Array<String>] An array of parts of path.
+  #
+  # source://addressable//lib/addressable/uri.rb#2542
+  def split_path(path); end
+
+  # Ensures that the URI is valid.
+  #
+  # source://addressable//lib/addressable/uri.rb#2476
+  def validate; end
+
+  private
+
+  # Resets instance variables
+  #
+  # @api private
+  #
+  # source://addressable//lib/addressable/uri.rb#2573
+  def reset_ivs; end
+
+  class << self
+    # Converts a path to a file scheme URI. If the path supplied is
+    # relative, it will be returned as a relative URI. If the path supplied
+    # is actually a non-file URI, it will parse the URI as if it had been
+    # parsed with <code>Addressable::URI.parse</code>. Handles all of the
+    # various Microsoft-specific formats for specifying paths.
+    #
+    # @example
+    #   base = Addressable::URI.convert_path("/absolute/path/")
+    #   uri = Addressable::URI.convert_path("relative/path")
+    #   (base + uri).to_s
+    #   #=> "file:///absolute/path/relative/path"
+    #
+    #   Addressable::URI.convert_path(
+    #   "c:\\windows\\My Documents 100%20\\foo.txt"
+    #   ).to_s
+    #   #=> "file:///c:/windows/My%20Documents%20100%20/foo.txt"
+    #
+    #   Addressable::URI.convert_path("http://example.com/").to_s
+    #   #=> "http://example.com/"
+    # @param path [String, Addressable::URI, #to_str] Typically a <code>String</code> path to a file or directory, but
+    #   will return a sensible return value if an absolute URI is supplied
+    #   instead.
+    # @return [Addressable::URI] The parsed file scheme URI or the original URI if some other URI
+    #   scheme was provided.
+    #
+    # source://addressable//lib/addressable/uri.rb#292
+    def convert_path(path); end
+
+    # Percent encodes any special characters in the URI.
+    #
+    # @param uri [String, Addressable::URI, #to_str] The URI to encode.
+    # @param return_type [Class] The type of object to return.
+    #   This value may only be set to <code>String</code> or
+    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
+    #   to <code>String</code>.
+    # @return [String, Addressable::URI] The encoded URI.
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    #
+    # source://addressable//lib/addressable/uri.rb#616
+    def encode(uri, return_type = T.unsafe(nil)); end
+
+    # Percent encodes a URI component.
+    #
+    #  '9' to be percent encoded. If a <code>Regexp</code> is passed, the
+    #   value <code>/[^b-zB-Z0-9]/</code> would have the same effect. A set of
+    #   useful <code>String</code> values may be found in the
+    #   <code>Addressable::URI::CharacterClasses</code> module. The default
+    #   value is the reserved plus unreserved character classes specified in
+    #   <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
+    #
+    # @example
+    #   Addressable::URI.encode_component("simple/example", "b-zB-Z0-9")
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.encode_component("simple/example", /[^b-zB-Z0-9]/)
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.encode_component(
+    #   "simple/example", Addressable::URI::CharacterClasses::UNRESERVED
+    #   )
+    #   => "simple%2Fexample"
+    # @param component [String, #to_str] The URI component to encode.
+    # @param character_class [String, Regexp] The characters which are not percent encoded. If a <code>String</code>
+    #   is passed, the <code>String</code> must be formatted as a regular
+    #   expression character class. (Do not include the surrounding square
+    #   brackets.)  For example, <code>"b-zB-Z0-9"</code> would cause
+    #   everything but the letters 'b' through 'z' and the numbers '0' through
+    # @param upcase_encoded [Regexp] A string of characters that may already be percent encoded, and whose
+    #   encodings should be upcased. This allows normalization of percent
+    #   encodings for characters not included in the
+    #   <code>character_class</code>.
+    # @return [String] The encoded component.
+    #
+    # source://addressable//lib/addressable/uri.rb#403
+    def encode_component(component, character_class = T.unsafe(nil), upcase_encoded = T.unsafe(nil)); end
+
+    # Percent encodes any special characters in the URI.
+    #
+    # @param uri [String, Addressable::URI, #to_str] The URI to encode.
+    # @param return_type [Class] The type of object to return.
+    #   This value may only be set to <code>String</code> or
+    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
+    #   to <code>String</code>.
+    # @return [String, Addressable::URI] The encoded URI.
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    #
+    # source://addressable//lib/addressable/uri.rb#616
+    def escape(uri, return_type = T.unsafe(nil)); end
+
+    # Percent encodes a URI component.
+    #
+    #  '9' to be percent encoded. If a <code>Regexp</code> is passed, the
+    #   value <code>/[^b-zB-Z0-9]/</code> would have the same effect. A set of
+    #   useful <code>String</code> values may be found in the
+    #   <code>Addressable::URI::CharacterClasses</code> module. The default
+    #   value is the reserved plus unreserved character classes specified in
+    #   <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
+    #
+    # @example
+    #   Addressable::URI.encode_component("simple/example", "b-zB-Z0-9")
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.encode_component("simple/example", /[^b-zB-Z0-9]/)
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.encode_component(
+    #   "simple/example", Addressable::URI::CharacterClasses::UNRESERVED
+    #   )
+    #   => "simple%2Fexample"
+    # @param component [String, #to_str] The URI component to encode.
+    # @param character_class [String, Regexp] The characters which are not percent encoded. If a <code>String</code>
+    #   is passed, the <code>String</code> must be formatted as a regular
+    #   expression character class. (Do not include the surrounding square
+    #   brackets.)  For example, <code>"b-zB-Z0-9"</code> would cause
+    #   everything but the letters 'b' through 'z' and the numbers '0' through
+    # @param upcase_encoded [Regexp] A string of characters that may already be percent encoded, and whose
+    #   encodings should be upcased. This allows normalization of percent
+    #   encodings for characters not included in the
+    #   <code>character_class</code>.
+    # @return [String] The encoded component.
+    #
+    # source://addressable//lib/addressable/uri.rb#403
+    def escape_component(component, character_class = T.unsafe(nil), upcase_encoded = T.unsafe(nil)); end
+
+    # Encodes a set of key/value pairs according to the rules for the
+    # <code>application/x-www-form-urlencoded</code> MIME type.
+    #
+    # @param form_values [#to_hash, #to_ary] The form values to encode.
+    # @param sort [TrueClass, FalseClass] Sort the key/value pairs prior to encoding.
+    #   Defaults to <code>false</code>.
+    # @return [String] The encoded value.
+    #
+    # source://addressable//lib/addressable/uri.rb#740
+    def form_encode(form_values, sort = T.unsafe(nil)); end
+
+    # Decodes a <code>String</code> according to the rules for the
+    # <code>application/x-www-form-urlencoded</code> MIME type.
+    #
+    # @param encoded_value [String, #to_str] The form values to decode.
+    # @return [Array] The decoded values.
+    #   This is not a <code>Hash</code> because of the possibility for
+    #   duplicate keys.
+    #
+    # source://addressable//lib/addressable/uri.rb#793
+    def form_unencode(encoded_value); end
+
+    # Converts an input to a URI. The input does not have to be a valid
+    # URI — the method will use heuristics to guess what URI was intended.
+    # This is not standards-compliant, merely user-friendly.
+    #
+    # @param uri [String, Addressable::URI, #to_str] The URI string to parse.
+    #   No parsing is performed if the object is already an
+    #   <code>Addressable::URI</code>.
+    # @param hints [Hash] A <code>Hash</code> of hints to the heuristic parser.
+    #   Defaults to <code>{:scheme => "http"}</code>.
+    # @return [Addressable::URI] The parsed URI.
+    #
+    # source://addressable//lib/addressable/uri.rb#191
+    def heuristic_parse(uri, hints = T.unsafe(nil)); end
+
+    # Returns an array of known ip-based schemes. These schemes typically
+    # use a similar URI form:
+    # <code>//<user>:<password>@<host>:<port>/<url-path></code>
+    #
+    # source://addressable//lib/addressable/uri.rb#1369
+    def ip_based_schemes; end
+
+    # Joins several URIs together.
+    #
+    # @example
+    #   base = "http://example.com/"
+    #   uri = Addressable::URI.parse("relative/path")
+    #   Addressable::URI.join(base, uri)
+    #   #=> #<Addressable::URI:0xcab390 URI:http://example.com/relative/path>
+    # @param *uris [String, Addressable::URI, #to_str] The URIs to join.
+    # @return [Addressable::URI] The joined URI.
+    #
+    # source://addressable//lib/addressable/uri.rb#343
+    def join(*uris); end
+
+    # Normalizes the encoding of a URI component.
+    #
+    # @example
+    #   Addressable::URI.normalize_component("simpl%65/%65xampl%65", "b-zB-Z")
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.normalize_component(
+    #   "simpl%65/%65xampl%65", /[^b-zB-Z]/
+    #   )
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.normalize_component(
+    #   "simpl%65/%65xampl%65",
+    #   Addressable::URI::CharacterClasses::UNRESERVED
+    #   )
+    #   => "simple%2Fexample"
+    #   Addressable::URI.normalize_component(
+    #   "one%20two%2fthree%26four",
+    #   "0-9a-zA-Z &/",
+    #   "/"
+    #   )
+    #   => "one two%2Fthree&four"
+    # @param component [String, #to_str] The URI component to encode.
+    # @param character_class [String, Regexp] The characters which are not percent encoded. If a <code>String</code>
+    #   is passed, the <code>String</code> must be formatted as a regular
+    #   expression character class. (Do not include the surrounding square
+    #   brackets.)  For example, <code>"b-zB-Z0-9"</code> would cause
+    #   everything but the letters 'b' through 'z' and the numbers '0'
+    #   through '9' to be percent encoded. If a <code>Regexp</code> is passed,
+    #   the value <code>/[^b-zB-Z0-9]/</code> would have the same effect. A
+    #   set of useful <code>String</code> values may be found in the
+    #   <code>Addressable::URI::CharacterClasses</code> module. The default
+    #   value is the reserved plus unreserved character classes specified in
+    #   <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
+    # @param leave_encoded [String] When <code>character_class</code> is a <code>String</code> then
+    #   <code>leave_encoded</code> is a string of characters that should remain
+    #   percent encoded while normalizing the component; if they appear percent
+    #   encoded in the original component, then they will be upcased ("%2f"
+    #   normalized to "%2F") but otherwise left alone.
+    # @return [String] The normalized component.
+    #
+    # source://addressable//lib/addressable/uri.rb#552
+    def normalize_component(component, character_class = T.unsafe(nil), leave_encoded = T.unsafe(nil)); end
+
+    # Resolves paths to their simplest form.
+    #
+    # @param path [String] The path to normalize.
+    # @return [String] The normalized path.
+    #
+    # source://addressable//lib/addressable/uri.rb#2440
+    def normalize_path(path); end
+
+    # Normalizes the encoding of a URI. Characters within a hostname are
+    # not percent encoded to allow for internationalized domain names.
+    #
+    # @param uri [String, Addressable::URI, #to_str] The URI to encode.
+    # @param return_type [Class] The type of object to return.
+    #   This value may only be set to <code>String</code> or
+    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
+    #   to <code>String</code>.
+    # @return [String, Addressable::URI] The encoded URI.
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    #
+    # source://addressable//lib/addressable/uri.rb#671
+    def normalized_encode(uri, return_type = T.unsafe(nil)); end
+
+    # Returns a URI object based on the parsed string.
+    #
+    # @param uri [String, Addressable::URI, #to_str] The URI string to parse.
+    #   No parsing is performed if the object is already an
+    #   <code>Addressable::URI</code>.
+    # @return [Addressable::URI] The parsed URI.
+    #
+    # source://addressable//lib/addressable/uri.rb#114
+    def parse(uri); end
+
+    # Returns a hash of common IP-based schemes and their default port
+    # numbers. Adding new schemes to this hash, as necessary, will allow
+    # for better URI normalization.
+    #
+    # source://addressable//lib/addressable/uri.rb#1376
+    def port_mapping; end
+
+    # Unencodes any percent encoded characters within a URI component.
+    # This method may be used for unencoding either components or full URIs,
+    # however, it is recommended to use the <code>unencode_component</code>
+    # alias when unencoding components.
+    #
+    # @param uri [String, Addressable::URI, #to_str] The URI or component to unencode.
+    # @param return_type [Class] The type of object to return.
+    #   This value may only be set to <code>String</code> or
+    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
+    #   to <code>String</code>.
+    # @param leave_encoded [String] A string of characters to leave encoded. If a percent encoded character
+    #   in this list is encountered then it will remain percent encoded.
+    # @return [String, Addressable::URI] The unencoded component or URI.
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    #
+    # source://addressable//lib/addressable/uri.rb#472
+    def unencode(uri, return_type = T.unsafe(nil), leave_encoded = T.unsafe(nil)); end
+
+    # Unencodes any percent encoded characters within a URI component.
+    # This method may be used for unencoding either components or full URIs,
+    # however, it is recommended to use the <code>unencode_component</code>
+    # alias when unencoding components.
+    #
+    # @param uri [String, Addressable::URI, #to_str] The URI or component to unencode.
+    # @param return_type [Class] The type of object to return.
+    #   This value may only be set to <code>String</code> or
+    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
+    #   to <code>String</code>.
+    # @param leave_encoded [String] A string of characters to leave encoded. If a percent encoded character
+    #   in this list is encountered then it will remain percent encoded.
+    # @return [String, Addressable::URI] The unencoded component or URI.
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    #
+    # source://addressable//lib/addressable/uri.rb#472
+    def unencode_component(uri, return_type = T.unsafe(nil), leave_encoded = T.unsafe(nil)); end
+
+    # Unencodes any percent encoded characters within a URI component.
+    # This method may be used for unencoding either components or full URIs,
+    # however, it is recommended to use the <code>unencode_component</code>
+    # alias when unencoding components.
+    #
+    # @param uri [String, Addressable::URI, #to_str] The URI or component to unencode.
+    # @param return_type [Class] The type of object to return.
+    #   This value may only be set to <code>String</code> or
+    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
+    #   to <code>String</code>.
+    # @param leave_encoded [String] A string of characters to leave encoded. If a percent encoded character
+    #   in this list is encountered then it will remain percent encoded.
+    # @return [String, Addressable::URI] The unencoded component or URI.
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    #
+    # source://addressable//lib/addressable/uri.rb#472
+    def unescape(uri, return_type = T.unsafe(nil), leave_encoded = T.unsafe(nil)); end
+
+    # Unencodes any percent encoded characters within a URI component.
+    # This method may be used for unencoding either components or full URIs,
+    # however, it is recommended to use the <code>unencode_component</code>
+    # alias when unencoding components.
+    #
+    # @param uri [String, Addressable::URI, #to_str] The URI or component to unencode.
+    # @param return_type [Class] The type of object to return.
+    #   This value may only be set to <code>String</code> or
+    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
+    #   to <code>String</code>.
+    # @param leave_encoded [String] A string of characters to leave encoded. If a percent encoded character
+    #   in this list is encountered then it will remain percent encoded.
+    # @return [String, Addressable::URI] The unencoded component or URI.
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    #
+    # source://addressable//lib/addressable/uri.rb#472
+    def unescape_component(uri, return_type = T.unsafe(nil), leave_encoded = T.unsafe(nil)); end
+  end
+end
+
+# Container for the character classes specified in
+# <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
+#
+# Note: Concatenated and interpolated `String`s are not affected by the
+#       `frozen_string_literal` directive and must be frozen explicitly.
+#
+#       Interpolated `String`s *were* frozen this way before Ruby 3.0:
+#       https://bugs.ruby-lang.org/issues/17104
+#
+# source://addressable//lib/addressable/uri.rb#46
+module Addressable::URI::CharacterClasses; end
+
+# source://addressable//lib/addressable/uri.rb#47
+Addressable::URI::CharacterClasses::ALPHA = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#57
+Addressable::URI::CharacterClasses::AUTHORITY = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#48
+Addressable::URI::CharacterClasses::DIGIT = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#60
+Addressable::URI::CharacterClasses::FRAGMENT = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#49
+Addressable::URI::CharacterClasses::GEN_DELIMS = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#56
+Addressable::URI::CharacterClasses::HOST = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#58
+Addressable::URI::CharacterClasses::PATH = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#54
+Addressable::URI::CharacterClasses::PCHAR = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#59
+Addressable::URI::CharacterClasses::QUERY = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#51
+Addressable::URI::CharacterClasses::RESERVED = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#53
+Addressable::URI::CharacterClasses::RESERVED_AND_UNRESERVED = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#55
+Addressable::URI::CharacterClasses::SCHEME = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#50
+Addressable::URI::CharacterClasses::SUB_DELIMS = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#52
+Addressable::URI::CharacterClasses::UNRESERVED = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#72
+module Addressable::URI::CharacterClassesRegexps; end
+
+# source://addressable//lib/addressable/uri.rb#73
+Addressable::URI::CharacterClassesRegexps::AUTHORITY = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#74
+Addressable::URI::CharacterClassesRegexps::FRAGMENT = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#75
+Addressable::URI::CharacterClassesRegexps::HOST = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#76
+Addressable::URI::CharacterClassesRegexps::PATH = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#77
+Addressable::URI::CharacterClassesRegexps::QUERY = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#78
+Addressable::URI::CharacterClassesRegexps::RESERVED = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#79
+Addressable::URI::CharacterClassesRegexps::RESERVED_AND_UNRESERVED = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#80
+Addressable::URI::CharacterClassesRegexps::SCHEME = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#81
+Addressable::URI::CharacterClassesRegexps::UNRESERVED = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#85
+Addressable::URI::EMPTY_STR = T.let(T.unsafe(nil), String)
+
+# Raised if something other than a uri is supplied.
+#
+# source://addressable//lib/addressable/uri.rb#34
+class Addressable::URI::InvalidURIError < ::StandardError; end
+
+# source://addressable//lib/addressable/uri.rb#2598
+module Addressable::URI::NONE; end
+
+# source://addressable//lib/addressable/uri.rb#1530
+Addressable::URI::NORMPATH = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#63
+module Addressable::URI::NormalizeCharacterClasses; end
+
+# source://addressable//lib/addressable/uri.rb#68
+Addressable::URI::NormalizeCharacterClasses::FRAGMENT = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#64
+Addressable::URI::NormalizeCharacterClasses::HOST = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#66
+Addressable::URI::NormalizeCharacterClasses::PCHAR = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#69
+Addressable::URI::NormalizeCharacterClasses::QUERY = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#67
+Addressable::URI::NormalizeCharacterClasses::SCHEME = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#65
+Addressable::URI::NormalizeCharacterClasses::UNRESERVED = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#2427
+Addressable::URI::PARENT = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#89
+Addressable::URI::PORT_MAPPING = T.let(T.unsafe(nil), Hash)
+
+# source://addressable//lib/addressable/uri.rb#2429
+Addressable::URI::RULE_2A = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#2430
+Addressable::URI::RULE_2B_2C = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#2431
+Addressable::URI::RULE_2D = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#2432
+Addressable::URI::RULE_PREFIXED_PARENT = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/uri.rb#2426
+Addressable::URI::SELF_REF = T.let(T.unsafe(nil), String)
+
+# Tables used to optimize encoding operations in `self.encode_component`
+# and `self.normalize_component`
+#
+# source://addressable//lib/addressable/uri.rb#360
+Addressable::URI::SEQUENCE_ENCODING_TABLE = T.let(T.unsafe(nil), Array)
+
+# source://addressable//lib/addressable/uri.rb#364
+Addressable::URI::SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE = T.let(T.unsafe(nil), Array)
+
+# source://addressable//lib/addressable/uri.rb#84
+Addressable::URI::SLASH = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/uri.rb#87
+Addressable::URI::URIREGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://addressable//lib/addressable/version.rb#23
+module Addressable::VERSION; end
+
+# source://addressable//lib/addressable/version.rb#24
+Addressable::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/version.rb#25
+Addressable::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
+
+# source://addressable//lib/addressable/version.rb#28
+Addressable::VERSION::STRING = T.let(T.unsafe(nil), String)
+
+# source://addressable//lib/addressable/version.rb#26
+Addressable::VERSION::TINY = T.let(T.unsafe(nil), Integer)
diff --git a/Library/Homebrew/sorbet/rbi/gems/ast@2.4.2.rbi b/Library/Homebrew/sorbet/rbi/gems/ast@2.4.2.rbi
index 687dae5b0e7ce..3fc4495da71a7 100644
--- a/Library/Homebrew/sorbet/rbi/gems/ast@2.4.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/ast@2.4.2.rbi
@@ -4,34 +4,263 @@
 # This is an autogenerated file for types exported from the `ast` gem.
 # Please instead update this file by running `bin/tapioca gem ast`.
 
+# {AST} is a library for manipulating abstract syntax trees.
+#
+# It embraces immutability; each AST node is inherently frozen at
+# creation, and updating a child node requires recreating that node
+# and its every parent, recursively.
+# This is a design choice. It does create some pressure on
+# garbage collector, but completely eliminates all concurrency
+# and aliasing problems.
+#
+# See also {AST::Node}, {AST::Processor::Mixin} and {AST::Sexp} for
+# additional recommendations and design patterns.
+#
+# source://ast//lib/ast.rb#13
 module AST; end
 
+# Node is an immutable class, instances of which represent abstract
+# syntax tree nodes. It combines semantic information (i.e. anything
+# that affects the algorithmic properties of a program) with
+# meta-information (line numbers or compiler intermediates).
+#
+# Notes on inheritance
+# ====================
+#
+# The distinction between semantics and metadata is important. Complete
+# semantic information should be contained within just the {#type} and
+# {#children} of a Node instance; in other words, if an AST was to be
+# stripped of all meta-information, it should remain a valid AST which
+# could be successfully processed to yield a result with the same
+# algorithmic properties.
+#
+# Thus, Node should never be inherited in order to define methods which
+# affect or return semantic information, such as getters for `class_name`,
+# `superclass` and `body` in the case of a hypothetical `ClassNode`. The
+# correct solution is to use a generic Node with a {#type} of `:class`
+# and three children. See also {Processor} for tips on working with such
+# ASTs.
+#
+# On the other hand, Node can and should be inherited to define
+# application-specific metadata (see also {#initialize}) or customize the
+# printing format. It is expected that an application would have one or two
+# such classes and use them across the entire codebase.
+#
+# The rationale for this pattern is extensibility and maintainability.
+# Unlike static ones, dynamic languages do not require the presence of a
+# predefined, rigid structure, nor does it improve dispatch efficiency,
+# and while such a structure can certainly be defined, it does not add
+# any value but incurs a maintaining cost.
+# For example, extending the AST even with a transformation-local
+# temporary node type requires making globally visible changes to
+# the codebase.
+#
+# source://ast//lib/ast/node.rb#40
 class AST::Node
+  # Constructs a new instance of Node.
+  #
+  # The arguments `type` and `children` are converted with `to_sym` and
+  # `to_a` respectively. Additionally, the result of converting `children`
+  # is frozen. While mutating the arguments is generally considered harmful,
+  # the most common case is to pass an array literal to the constructor. If
+  # your code does not expect the argument to be frozen, use `#dup`.
+  #
+  # The `properties` hash is passed to {#assign_properties}.
+  #
+  # @return [Node] a new instance of Node
+  #
+  # source://ast//lib/ast/node.rb#72
   def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
 
+  # Concatenates `array` with `children` and returns the resulting node.
+  #
+  # @return [AST::Node]
+  #
+  # source://ast//lib/ast/node.rb#168
   def +(array); end
+
+  # Appends `element` to `children` and returns the resulting node.
+  #
+  # @return [AST::Node]
+  #
+  # source://ast//lib/ast/node.rb#177
   def <<(element); end
+
+  # Compares `self` to `other`, possibly converting with `to_ast`. Only
+  # `type` and `children` are compared; metadata is deliberately ignored.
+  #
+  # @return [Boolean]
+  #
+  # source://ast//lib/ast/node.rb#153
   def ==(other); end
+
+  # Appends `element` to `children` and returns the resulting node.
+  #
+  # @return [AST::Node]
+  #
+  # source://ast//lib/ast/node.rb#177
   def append(element); end
+
+  # Returns the children of this node.
+  # The returned value is frozen.
+  # The to_a alias is useful for decomposing nodes concisely.
+  # For example:
+  #
+  #     node = s(:gasgn, :$foo, s(:integer, 1))
+  #     var_name, value = *node
+  #     p var_name # => :$foo
+  #     p value    # => (integer 1)
+  #
+  # @return [Array]
+  #
+  # source://ast//lib/ast/node.rb#56
   def children; end
+
+  # Nodes are already frozen, so there is no harm in returning the
+  # current node as opposed to initializing from scratch and freezing
+  # another one.
+  #
+  # @return self
+  #
+  # source://ast//lib/ast/node.rb#115
   def clone; end
+
+  # Concatenates `array` with `children` and returns the resulting node.
+  #
+  # @return [AST::Node]
+  #
+  # source://ast//lib/ast/node.rb#168
   def concat(array); end
+
+  # Enables matching for Node, where type is the first element
+  # and the children are remaining items.
+  #
+  # @return [Array]
+  #
+  # source://ast//lib/ast/node.rb#253
   def deconstruct; end
+
+  # Nodes are already frozen, so there is no harm in returning the
+  # current node as opposed to initializing from scratch and freezing
+  # another one.
+  #
+  # @return self
+  #
+  # source://ast//lib/ast/node.rb#115
   def dup; end
+
+  # Test if other object is equal to
+  #
+  # @param other [Object]
+  # @return [Boolean]
+  #
+  # source://ast//lib/ast/node.rb#85
   def eql?(other); end
+
+  # Returns the precomputed hash value for this node
+  #
+  # @return [Fixnum]
+  #
+  # source://ast//lib/ast/node.rb#61
   def hash; end
+
+  # Converts `self` to a s-expression ruby string.
+  # The code return will recreate the node, using the sexp module s()
+  #
+  # @param indent [Integer] Base indentation level.
+  # @return [String]
+  #
+  # source://ast//lib/ast/node.rb#211
   def inspect(indent = T.unsafe(nil)); end
+
+  # Returns the children of this node.
+  # The returned value is frozen.
+  # The to_a alias is useful for decomposing nodes concisely.
+  # For example:
+  #
+  #     node = s(:gasgn, :$foo, s(:integer, 1))
+  #     var_name, value = *node
+  #     p var_name # => :$foo
+  #     p value    # => (integer 1)
+  #
+  # @return [Array]
+  #
+  # source://ast//lib/ast/node.rb#56
   def to_a; end
+
+  # @return [AST::Node] self
+  #
+  # source://ast//lib/ast/node.rb#229
   def to_ast; end
+
+  # Converts `self` to a pretty-printed s-expression.
+  #
+  # @param indent [Integer] Base indentation level.
+  # @return [String]
+  #
+  # source://ast//lib/ast/node.rb#187
   def to_s(indent = T.unsafe(nil)); end
+
+  # Converts `self` to a pretty-printed s-expression.
+  #
+  # @param indent [Integer] Base indentation level.
+  # @return [String]
+  #
+  # source://ast//lib/ast/node.rb#187
   def to_sexp(indent = T.unsafe(nil)); end
+
+  # Converts `self` to an Array where the first element is the type as a Symbol,
+  # and subsequent elements are the same representation of its children.
+  #
+  # @return [Array<Symbol, [...Array]>]
+  #
+  # source://ast//lib/ast/node.rb#237
   def to_sexp_array; end
+
+  # Returns the type of this node.
+  #
+  # @return [Symbol]
+  #
+  # source://ast//lib/ast/node.rb#43
   def type; end
+
+  # Returns a new instance of Node where non-nil arguments replace the
+  # corresponding fields of `self`.
+  #
+  # For example, `Node.new(:foo, [ 1, 2 ]).updated(:bar)` would yield
+  # `(bar 1 2)`, and `Node.new(:foo, [ 1, 2 ]).updated(nil, [])` would
+  # yield `(foo)`.
+  #
+  # If the resulting node would be identical to `self`, does nothing.
+  #
+  # @param type [Symbol, nil]
+  # @param children [Array, nil]
+  # @param properties [Hash, nil]
+  # @return [AST::Node]
+  #
+  # source://ast//lib/ast/node.rb#133
   def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
 
   protected
 
+  # By default, each entry in the `properties` hash is assigned to
+  # an instance variable in this instance of Node. A subclass should define
+  # attribute readers for such variables. The values passed in the hash
+  # are not frozen or whitelisted; such behavior can also be implemented
+  # by subclassing Node and overriding this method.
+  #
+  # @return [nil]
+  #
+  # source://ast//lib/ast/node.rb#98
   def assign_properties(properties); end
+
+  # Returns `@type` with all underscores replaced by dashes. This allows
+  # to write symbol literals without quotes in Ruby sources and yet have
+  # nicely looking s-expressions.
+  #
+  # @return [String]
+  #
+  # source://ast//lib/ast/node.rb#264
   def fancy_type; end
 
   private
@@ -39,16 +268,317 @@ class AST::Node
   def original_dup; end
 end
 
+# This class includes {AST::Processor::Mixin}; however, it is
+# deprecated, since the module defines all of the behaviors that
+# the processor includes.  Any new libraries should use
+# {AST::Processor::Mixin} instead of subclassing this.
+#
+# @deprecated Use {AST::Processor::Mixin} instead.
+#
+# source://ast//lib/ast/processor.rb#8
 class AST::Processor
   include ::AST::Processor::Mixin
 end
 
+# The processor module is a module which helps transforming one
+# AST into another.  In a nutshell, the {#process} method accepts
+# a {Node} and dispatches it to a handler corresponding to its
+# type, and returns a (possibly) updated variant of the node.
+#
+# The processor module has a set of associated design patterns.
+# They are best explained with a concrete example. Let's define a
+# simple arithmetic language and an AST format for it:
+#
+# Terminals (AST nodes which do not have other AST nodes inside):
+#
+#   * `(integer <int-literal>)`,
+#
+# Nonterminals (AST nodes with other nodes as children):
+#
+#   * `(add <node> <node>)`,
+#   * `(multiply <node> <node>)`,
+#   * `(divide <node> <node>)`,
+#   * `(negate <node>)`,
+#   * `(store <node> <string-literal>)`: stores value of `<node>`
+#     into a variable named `<string-literal>`,
+#   * `(load <string-literal>)`: loads value of a variable named
+#     `<string-literal>`,
+#   * `(each <node> ...)`: computes each of the `<node>`s and
+#     prints the result.
+#
+# All AST nodes have the same Ruby class, and therefore they don't
+# know how to traverse themselves. (A solution which dynamically
+# checks the type of children is possible, but is slow and
+# error-prone.) So, a class including the module which knows how
+# to traverse the entire tree should be defined.  Such classes
+# have a handler for each nonterminal node which recursively
+# processes children nodes:
+#
+#     require 'ast'
+#
+#     class ArithmeticsProcessor
+#       include AST::Processor::Mixin
+#       # This method traverses any binary operators such as (add)
+#       # or (multiply).
+#       def process_binary_op(node)
+#         # Children aren't decomposed automatically; it is
+#         # suggested to use Ruby multiple assignment expansion,
+#         # as it is very convenient here.
+#         left_expr, right_expr = *node
+#
+#         # AST::Node#updated won't change node type if nil is
+#         # passed as a first argument, which allows to reuse the
+#         # same handler for multiple node types using `alias'
+#         # (below).
+#         node.updated(nil, [
+#           process(left_expr),
+#           process(right_expr)
+#         ])
+#       end
+#       alias_method :on_add,      :process_binary_op
+#       alias_method :on_multiply, :process_binary_op
+#       alias_method :on_divide,   :process_binary_op
+#
+#       def on_negate(node)
+#         # It is also possible to use #process_all for more
+#         # compact code if every child is a Node.
+#         node.updated(nil, process_all(node))
+#       end
+#
+#       def on_store(node)
+#         expr, variable_name = *node
+#
+#         # Note that variable_name is not a Node and thus isn't
+#         # passed to #process.
+#         node.updated(nil, [
+#           process(expr),
+#           variable_name
+#         ])
+#       end
+#
+#       # (load) is effectively a terminal node, and so it does
+#       # not need an explicit handler, as the following is the
+#       # default behavior.  Essentially, for any nodes that don't
+#       # have a defined handler, the node remains unchanged.
+#       def on_load(node)
+#         nil
+#       end
+#
+#       def on_each(node)
+#         node.updated(nil, process_all(node))
+#       end
+#     end
+#
+# Let's test our ArithmeticsProcessor:
+#
+#     include AST::Sexp
+#     expr = s(:add, s(:integer, 2), s(:integer, 2))
+#
+#     p ArithmeticsProcessor.new.process(expr) == expr # => true
+#
+# As expected, it does not change anything at all. This isn't
+# actually very useful, so let's now define a Calculator, which
+# will compute the expression values:
+#
+#     # This Processor folds nonterminal nodes and returns an
+#     # (integer) terminal node.
+#     class ArithmeticsCalculator < ArithmeticsProcessor
+#       def compute_op(node)
+#         # First, node children are processed and then unpacked
+#         # to local variables.
+#         nodes = process_all(node)
+#
+#         if nodes.all? { |node| node.type == :integer }
+#           # If each of those nodes represents a literal, we can
+#           # fold this node!
+#           values = nodes.map { |node| node.children.first }
+#           AST::Node.new(:integer, [
+#             yield(values)
+#           ])
+#         else
+#           # Otherwise, we can just leave the current node in the
+#           # tree and only update it with processed children
+#           # nodes, which can be partially folded.
+#           node.updated(nil, nodes)
+#         end
+#       end
+#
+#       def on_add(node)
+#         compute_op(node) { |left, right| left + right }
+#       end
+#
+#       def on_multiply(node)
+#         compute_op(node) { |left, right| left * right }
+#       end
+#     end
+#
+# Let's check:
+#
+#     p ArithmeticsCalculator.new.process(expr) # => (integer 4)
+#
+# Excellent, the calculator works! Now, a careful reader could
+# notice that the ArithmeticsCalculator does not know how to
+# divide numbers. What if we pass an expression with division to
+# it?
+#
+#     expr_with_division = \
+#       s(:add,
+#         s(:integer, 1),
+#         s(:divide,
+#           s(:add, s(:integer, 8), s(:integer, 4)),
+#           s(:integer, 3))) # 1 + (8 + 4) / 3
+#
+#     folded_expr_with_division = ArithmeticsCalculator.new.process(expr_with_division)
+#     p folded_expr_with_division
+#     # => (add
+#     #      (integer 1)
+#     #      (divide
+#     #        (integer 12)
+#     #        (integer 3)))
+#
+# As you can see, the expression was folded _partially_: the inner
+# `(add)` node which could be computed was folded to
+# `(integer 12)`, the `(divide)` node is left as-is because there
+# is no computing handler for it, and the root `(add)` node was
+# also left as it is because some of its children were not
+# literals.
+#
+# Note that this partial folding is only possible because the
+# _data_ format, i.e. the format in which the computed values of
+# the nodes are represented, is the same as the AST itself.
+#
+# Let's extend our ArithmeticsCalculator class further.
+#
+#     class ArithmeticsCalculator
+#       def on_divide(node)
+#         compute_op(node) { |left, right| left / right }
+#       end
+#
+#       def on_negate(node)
+#         # Note how #compute_op works regardless of the operator
+#         # arity.
+#         compute_op(node) { |value| -value }
+#       end
+#     end
+#
+# Now, let's apply our renewed ArithmeticsCalculator to a partial
+# result of previous evaluation:
+#
+#     p ArithmeticsCalculator.new.process(expr_with_division) # => (integer 5)
+#
+# Five! Excellent. This is also pretty much how CRuby 1.8 executed
+# its programs.
+#
+# Now, let's do some automated bug searching. Division by zero is
+# an error, right? So if we could detect that someone has divided
+# by zero before the program is even run, that could save some
+# debugging time.
+#
+#     class DivisionByZeroVerifier < ArithmeticsProcessor
+#       class VerificationFailure < Exception; end
+#
+#       def on_divide(node)
+#         # You need to process the children to handle nested divisions
+#         # such as:
+#         # (divide
+#         #   (integer 1)
+#         #   (divide (integer 1) (integer 0))
+#         left, right = process_all(node)
+#
+#         if right.type == :integer &&
+#            right.children.first == 0
+#           raise VerificationFailure, "Ouch! This code divides by zero."
+#         end
+#       end
+#
+#       def divides_by_zero?(ast)
+#         process(ast)
+#         false
+#       rescue VerificationFailure
+#         true
+#       end
+#     end
+#
+#     nice_expr = \
+#       s(:divide,
+#         s(:add, s(:integer, 10), s(:integer, 2)),
+#         s(:integer, 4))
+#
+#     p DivisionByZeroVerifier.new.divides_by_zero?(nice_expr)
+#     # => false. Good.
+#
+#     bad_expr = \
+#       s(:add, s(:integer, 10),
+#         s(:divide, s(:integer, 1), s(:integer, 0)))
+#
+#     p DivisionByZeroVerifier.new.divides_by_zero?(bad_expr)
+#     # => true. WHOOPS. DO NOT RUN THIS.
+#
+# Of course, this won't detect more complex cases... unless you
+# use some partial evaluation before! The possibilites are
+# endless. Have fun.
+#
+# source://ast//lib/ast/processor/mixin.rb#240
 module AST::Processor::Mixin
+  # Default handler. Does nothing.
+  #
+  # @param node [AST::Node]
+  # @return [AST::Node, nil]
+  #
+  # source://ast//lib/ast/processor/mixin.rb#284
   def handler_missing(node); end
+
+  # Dispatches `node`. If a node has type `:foo`, then a handler
+  # named `on_foo` is invoked with one argument, the `node`; if
+  # there isn't such a handler, {#handler_missing} is invoked
+  # with the same argument.
+  #
+  # If the handler returns `nil`, `node` is returned; otherwise,
+  # the return value of the handler is passed along.
+  #
+  # @param node [AST::Node, nil]
+  # @return [AST::Node, nil]
+  #
+  # source://ast//lib/ast/processor/mixin.rb#251
   def process(node); end
+
+  # {#process}es each node from `nodes` and returns an array of
+  # results.
+  #
+  # @param nodes [Array<AST::Node>]
+  # @return [Array<AST::Node>]
+  #
+  # source://ast//lib/ast/processor/mixin.rb#274
   def process_all(nodes); end
 end
 
+# This simple module is very useful in the cases where one needs
+# to define deeply nested ASTs from Ruby code, for example, in
+# tests. It should be used like this:
+#
+#     describe YourLanguage::AST do
+#       include Sexp
+#
+#       it "should correctly parse expressions" do
+#         YourLanguage.parse("1 + 2 * 3").should ==
+#             s(:add,
+#               s(:integer, 1),
+#               s(:multiply,
+#                 s(:integer, 2),
+#                 s(:integer, 3)))
+#       end
+#     end
+#
+# This way the amount of boilerplate code is greatly reduced.
+#
+# source://ast//lib/ast/sexp.rb#20
 module AST::Sexp
+  # Creates a {Node} with type `type` and children `children`.
+  # Note that the resulting node is of the type AST::Node and not a
+  # subclass.
+  # This would not pose a problem with comparisons, as {Node#==}
+  # ignores metadata.
+  #
+  # source://ast//lib/ast/sexp.rb#26
   def s(type, *children); end
 end
diff --git a/Library/Homebrew/sorbet/rbi/gems/bigdecimal@3.1.8.rbi b/Library/Homebrew/sorbet/rbi/gems/bigdecimal@3.1.8.rbi
new file mode 100644
index 0000000000000..c52d9ff8798ed
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/bigdecimal@3.1.8.rbi
@@ -0,0 +1,9 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `bigdecimal` gem.
+# Please instead update this file by running `bin/tapioca gem bigdecimal`.
+
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem
diff --git a/Library/Homebrew/sorbet/rbi/gems/bindata@2.4.10.rbi b/Library/Homebrew/sorbet/rbi/gems/bindata@2.4.10.rbi
deleted file mode 100644
index 2bf86efb7f000..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/bindata@2.4.10.rbi
+++ /dev/null
@@ -1,1177 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `bindata` gem.
-# Please instead update this file by running `bin/tapioca gem bindata`.
-
-module BinData
-  extend ::BinData::BitFieldFactory
-  extend ::BinData::IntFactory
-
-  private
-
-  def trace_message; end
-  def trace_reading(io = T.unsafe(nil)); end
-
-  class << self
-    def trace_message; end
-    def trace_reading(io = T.unsafe(nil)); end
-  end
-end
-
-module BinData::AcceptedParametersPlugin
-  def accepted_parameters; end
-  def default_parameter(*args); end
-  def default_parameters(*args); end
-  def mandatory_parameter(*args); end
-  def mandatory_parameters(*args); end
-  def mutually_exclusive_parameters(*args); end
-  def optional_parameter(*args); end
-  def optional_parameters(*args); end
-end
-
-class BinData::AcceptedParametersPlugin::AcceptedParameters
-  def initialize(ancestor_parameters = T.unsafe(nil)); end
-
-  def all; end
-  def default(args = T.unsafe(nil)); end
-  def mandatory(*args); end
-  def mutually_exclusive(*args); end
-  def optional(*args); end
-
-  private
-
-  def ensure_valid_names(names); end
-  def to_syms(args); end
-
-  class << self
-    def invalid_parameter_names; end
-  end
-end
-
-class BinData::Array < ::BinData::Base
-  include ::Enumerable
-  extend ::BinData::DSLMixin
-
-  def <<(*args); end
-  def [](arg1, arg2 = T.unsafe(nil)); end
-  def []=(index, value); end
-  def assign(array); end
-  def at(index); end
-  def clear?; end
-  def concat(array); end
-  def debug_name_of(child); end
-  def do_num_bytes; end
-  def do_write(io); end
-  def each; end
-  def empty?; end
-  def find_index(obj); end
-  def find_index_of(obj); end
-  def first(n = T.unsafe(nil)); end
-  def index(obj); end
-  def initialize_instance; end
-  def initialize_shared_instance; end
-  def insert(index, *objs); end
-  def last(n = T.unsafe(nil)); end
-  def length; end
-  def offset_of(child); end
-  def push(*args); end
-  def size; end
-  def slice(arg1, arg2 = T.unsafe(nil)); end
-  def snapshot; end
-  def to_ary; end
-  def unshift(*args); end
-
-  private
-
-  def append_new_element; end
-  def elements; end
-  def extend_array(max_index); end
-  def new_element; end
-  def slice_index(index); end
-  def slice_range(range); end
-  def slice_start_length(start, length); end
-  def sum_num_bytes_below_index(index); end
-  def sum_num_bytes_for_all_elements; end
-end
-
-class BinData::ArrayArgProcessor < ::BinData::BaseArgProcessor
-  def sanitize_parameters!(obj_class, params); end
-end
-
-class BinData::Base
-  include ::BinData::Framework
-  include ::BinData::RegisterNamePlugin
-  extend ::BinData::AcceptedParametersPlugin
-
-  def initialize(*args); end
-
-  def ==(other); end
-  def =~(other); end
-  def abs_offset; end
-  def base_respond_to?(*_arg0); end
-  def clear; end
-  def debug_name; end
-  def eval_parameter(key, overrides = T.unsafe(nil)); end
-  def get_parameter(key); end
-  def has_parameter?(key); end
-  def initialize_instance(*args); end
-  def initialize_with_warning(*args); end
-  def inspect; end
-  def lazy_evaluator; end
-  def new(value = T.unsafe(nil), parent = T.unsafe(nil)); end
-  def num_bytes; end
-  def parent; end
-  def pretty_print(pp); end
-  def read(io, &block); end
-  def rel_offset; end
-  def safe_respond_to?(symbol, include_private = T.unsafe(nil)); end
-  def to_binary_s(&block); end
-  def to_hex(&block); end
-  def to_s; end
-  def write(io, &block); end
-
-  protected
-
-  def parent=(_arg0); end
-
-  private
-
-  def binary_string(str); end
-  def extract_args(args); end
-  def initialize_without_warning(*args); end
-  def reading?; end
-  def start_read; end
-  def top_level; end
-  def top_level_get(sym); end
-  def top_level_set(sym, value); end
-
-  class << self
-    def arg_processor(name = T.unsafe(nil)); end
-    def auto_call_delayed_io; end
-    def bindata_name; end
-    def inherited(subclass); end
-    def read(io, *args, &block); end
-
-    private
-
-    def register_subclasses; end
-    def unregister_self; end
-  end
-end
-
-module BinData::Base::AutoCallDelayedIO
-  def initialize_shared_instance; end
-  def num_bytes; end
-  def read(io); end
-  def write(io, *_); end
-end
-
-class BinData::BaseArgProcessor
-  def extract_args(obj_class, obj_args); end
-  def sanitize_parameters!(obj_class, obj_params); end
-  def separate_args(_obj_class, obj_args); end
-end
-
-class BinData::BasePrimitive < ::BinData::Base
-  def <=>(other); end
-  def assign(val); end
-  def clear?; end
-  def do_num_bytes; end
-  def do_read(io); end
-  def do_read_with_hook(io); end
-  def do_write(io); end
-  def eql?(other); end
-  def hash; end
-  def initialize_instance; end
-  def initialize_shared_instance; end
-  def method_missing(symbol, *args, &block); end
-  def respond_to?(symbol, include_private = T.unsafe(nil)); end
-  def snapshot; end
-  def trace_value; end
-  def value; end
-  def value=(val); end
-
-  private
-
-  def _value; end
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-
-  class << self
-    def bit_aligned; end
-    def inherited(subclass); end
-    def turn_off_tracing; end
-    def turn_on_tracing; end
-  end
-end
-
-module BinData::BasePrimitive::AssertPlugin
-  def assert!; end
-  def assign(val); end
-  def do_read(io); end
-end
-
-module BinData::BasePrimitive::AssertedValuePlugin
-  def _value; end
-  def assert!; end
-  def assert_value(current_value); end
-  def assign(val); end
-  def do_read(io); end
-end
-
-module BinData::BasePrimitive::InitialValuePlugin
-  def _value; end
-end
-
-module BinData::BasePrimitive::ValuePlugin
-  def _value; end
-  def assign(val); end
-end
-
-class BinData::Bit < ::BinData::BasePrimitive
-  def assign(val); end
-  def bit_aligned?; end
-  def do_num_bytes; end
-  def do_write(io); end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-end
-
-module BinData::BitAligned
-  def bit_aligned?; end
-  def do_num_bytes; end
-  def do_write(io); end
-  def read_and_return_value(io); end
-end
-
-class BinData::BitAligned::BitAlignedIO
-  def initialize(io); end
-
-  def readbytes(n); end
-end
-
-module BinData::BitField
-  class << self
-    def create_clamp_code(nbits, signed); end
-    def create_do_num_bytes_code(nbits); end
-    def create_dynamic_clamp_code(signed); end
-    def create_fixed_clamp_code(nbits, signed); end
-    def create_int2uint_code(nbits, signed); end
-    def create_nbits_code(nbits); end
-    def create_params_code(nbits); end
-    def create_uint2int_code(nbits, signed); end
-    def define_class(name, nbits, endian, signed = T.unsafe(nil)); end
-    def define_methods(bit_class, nbits, endian, signed); end
-  end
-end
-
-module BinData::BitFieldFactory
-  def const_missing(name); end
-end
-
-class BinData::BitLe < ::BinData::BasePrimitive
-  def assign(val); end
-  def bit_aligned?; end
-  def do_num_bytes; end
-  def do_write(io); end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-end
-
-class BinData::Buffer < ::BinData::Base
-  extend ::BinData::DSLMixin
-
-  def assign(val); end
-  def clear?; end
-  def do_num_bytes; end
-  def do_read(io); end
-  def do_write(io); end
-  def initialize_instance; end
-  def method_missing(symbol, *args, &block); end
-  def raw_num_bytes; end
-  def respond_to?(symbol, include_private = T.unsafe(nil)); end
-  def snapshot; end
-end
-
-class BinData::BufferArgProcessor < ::BinData::BaseArgProcessor
-  include ::BinData::MultiFieldArgSeparator
-
-  def sanitize_parameters!(obj_class, params); end
-end
-
-module BinData::ByteAlignPlugin
-  def align_obj?(obj); end
-  def bytes_to_align(obj, rel_offset); end
-  def do_read(io); end
-  def do_write(io); end
-  def sum_num_bytes_below_index(index); end
-end
-
-class BinData::Choice < ::BinData::Base
-  extend ::BinData::DSLMixin
-
-  def assign(*args); end
-  def clear?(*args); end
-  def do_num_bytes(*args); end
-  def do_read(*args); end
-  def do_read_with_hook(io); end
-  def do_write(*args); end
-  def initialize_instance; end
-  def initialize_shared_instance; end
-  def method_missing(symbol, *args, &block); end
-  def respond_to?(symbol, include_private = T.unsafe(nil)); end
-  def selection; end
-  def snapshot(*args); end
-  def trace_selection; end
-
-  private
-
-  def current_choice; end
-  def instantiate_choice(selection); end
-
-  class << self
-    def turn_off_tracing; end
-    def turn_on_tracing; end
-  end
-end
-
-class BinData::ChoiceArgProcessor < ::BinData::BaseArgProcessor
-  def sanitize_parameters!(obj_class, params); end
-
-  private
-
-  def choices_as_hash(choices); end
-  def ensure_valid_keys(choices); end
-  def key_array_by_index(array); end
-end
-
-module BinData::CopyOnChangePlugin
-  def copy_previous_value(obj); end
-  def current_choice; end
-  def get_previous_choice(selection); end
-  def remember_current_selection(selection); end
-end
-
-class BinData::CountBytesRemaining < ::BinData::BasePrimitive
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-module BinData::DSLMixin
-  def dsl_parser(parser_type = T.unsafe(nil)); end
-  def method_missing(symbol, *args, &block); end
-  def to_ary; end
-  def to_str; end
-end
-
-class BinData::DSLMixin::DSLBigAndLittleEndianHandler
-  class << self
-    def class_with_endian(class_name, endian); end
-    def create_subclasses_with_endian(bnl_class); end
-    def delegate_field_creation(bnl_class); end
-    def fixup_subclass_hierarchy(bnl_class); end
-    def handle(bnl_class); end
-    def make_class_abstract(bnl_class); end
-    def obj_attribute(obj, attr); end
-    def override_new_in_class(bnl_class); end
-  end
-end
-
-class BinData::DSLMixin::DSLFieldParser
-  def initialize(hints, symbol, *args, &block); end
-
-  def name; end
-  def name_from_field_declaration(args); end
-  def params; end
-  def params_from_args(args); end
-  def params_from_block(&block); end
-  def params_from_field_declaration(args, &block); end
-  def type; end
-end
-
-class BinData::DSLMixin::DSLFieldValidator
-  def initialize(the_class, parser); end
-
-  def all_or_none_names_failed?(name); end
-  def duplicate_name?(name); end
-  def ensure_valid_name(name); end
-  def fields; end
-  def malformed_name?(name); end
-  def must_have_a_name_failed?(name); end
-  def must_not_have_a_name_failed?(name); end
-  def name_is_reserved?(name); end
-  def name_shadows_method?(name); end
-  def option?(opt); end
-  def validate_field(name); end
-end
-
-class BinData::DSLMixin::DSLParser
-  def initialize(the_class, parser_type); end
-
-  def dsl_params; end
-  def endian(endian = T.unsafe(nil)); end
-  def fields; end
-  def hide(*args); end
-  def method_missing(*args, &block); end
-  def parser_type; end
-  def search_prefix(*args); end
-
-  private
-
-  def append_field(type, name, params); end
-  def dsl_raise(exception, msg); end
-  def ensure_hints; end
-  def fields?; end
-  def hints; end
-  def option?(opt); end
-  def parent_attribute(attr, default = T.unsafe(nil)); end
-  def parent_fields; end
-  def parse_and_append_field(*args, &block); end
-  def parser_abilities; end
-  def set_endian(endian); end
-  def to_choice_params(key); end
-  def to_object_params(key); end
-  def to_struct_params(*unused); end
-  def valid_endian?(endian); end
-end
-
-class BinData::DelayedIO < ::BinData::Base
-  extend ::BinData::DSLMixin
-
-  def abs_offset; end
-  def abs_offset=(offset); end
-  def assign(val); end
-  def clear?; end
-  def do_num_bytes; end
-  def do_read(io); end
-  def do_write(io); end
-  def initialize_instance; end
-  def method_missing(symbol, *args, &block); end
-  def num_bytes; end
-  def read_now!; end
-  def rel_offset; end
-  def respond_to?(symbol, include_private = T.unsafe(nil)); end
-  def snapshot; end
-  def write_now!; end
-end
-
-class BinData::DelayedIoArgProcessor < ::BinData::BaseArgProcessor
-  include ::BinData::MultiFieldArgSeparator
-
-  def sanitize_parameters!(obj_class, params); end
-end
-
-class BinData::DoubleBe < ::BinData::BasePrimitive
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::DoubleLe < ::BinData::BasePrimitive
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::FloatBe < ::BinData::BasePrimitive
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::FloatLe < ::BinData::BasePrimitive
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-module BinData::FloatingPoint
-  class << self
-    def create_num_bytes_code(precision); end
-    def create_read_code(precision, endian); end
-    def create_to_binary_s_code(precision, endian); end
-    def define_methods(float_class, precision, endian); end
-  end
-end
-
-module BinData::Framework
-  def assign(val); end
-  def bit_aligned?; end
-  def clear?; end
-  def debug_name_of(child); end
-  def offset_of(child); end
-  def snapshot; end
-
-  protected
-
-  def do_num_bytes; end
-  def do_read(io); end
-  def do_write(io); end
-  def initialize_instance; end
-  def initialize_shared_instance; end
-end
-
-module BinData::IO
-  class << self
-    def create_string_io(str = T.unsafe(nil)); end
-  end
-end
-
-module BinData::IO::Common
-  def initialize(io); end
-
-  private
-
-  def buffer_limited_n(n); end
-  def seek(n); end
-  def seekable?; end
-  def with_buffer_common(n); end
-end
-
-module BinData::IO::Common::SeekableStream
-  def num_bytes_remaining; end
-  def with_readahead; end
-
-  private
-
-  def offset_raw; end
-  def read_raw(n); end
-  def seek_raw(n); end
-  def stream_init; end
-  def write_raw(data); end
-end
-
-module BinData::IO::Common::UnSeekableStream
-  def num_bytes_remaining; end
-  def offset_raw; end
-  def with_readahead; end
-
-  private
-
-  def read_raw(n); end
-  def read_raw_with_readahead(n); end
-  def seek_raw(n); end
-  def stream_init; end
-  def write_raw(data); end
-end
-
-class BinData::IO::Read
-  include ::BinData::IO::Common
-
-  def initialize(io); end
-
-  def offset; end
-  def read_all_bytes; end
-  def readbits(nbits, endian); end
-  def readbytes(n); end
-  def reset_read_bits; end
-  def seekbytes(n); end
-  def with_buffer(n); end
-
-  private
-
-  def accumulate_big_endian_bits; end
-  def accumulate_little_endian_bits; end
-  def mask(nbits); end
-  def read(n = T.unsafe(nil)); end
-  def read_big_endian_bits(nbits); end
-  def read_little_endian_bits(nbits); end
-end
-
-class BinData::IO::Write
-  include ::BinData::IO::Common
-
-  def initialize(io); end
-
-  def flush; end
-  def flushbits; end
-  def offset; end
-  def seekbytes(n); end
-  def with_buffer(n); end
-  def writebits(val, nbits, endian); end
-  def writebytes(str); end
-
-  private
-
-  def mask(nbits); end
-  def write(data); end
-  def write_big_endian_bits(val, nbits); end
-  def write_little_endian_bits(val, nbits); end
-end
-
-module BinData::InitialLengthPlugin
-  def do_read(io); end
-  def elements; end
-end
-
-module BinData::Int
-  class << self
-    def define_class(name, nbits, endian, signed); end
-    def define_methods(int_class, nbits, endian, signed); end
-
-    private
-
-    def bits_per_word(nbits); end
-    def create_clamp_code(nbits, signed); end
-    def create_int2uint_code(nbits); end
-    def create_raw_read_code(nbits, endian, signed); end
-    def create_read_assemble_code(nbits, endian, signed); end
-    def create_read_code(nbits, endian, signed); end
-    def create_read_unpack_code(nbits, endian, signed); end
-    def create_to_binary_s_code(nbits, endian, signed); end
-    def create_uint2int_code(nbits); end
-    def need_signed_conversion_code?(nbits, signed); end
-    def pack_directive(nbits, endian, signed); end
-    def val_as_packed_words(nbits, endian, signed); end
-  end
-end
-
-class BinData::Int32be < ::BinData::BasePrimitive
-  def assign(val); end
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::Int32le < ::BinData::BasePrimitive
-  def assign(val); end
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::Int64be < ::BinData::BasePrimitive
-  def assign(val); end
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::Int64le < ::BinData::BasePrimitive
-  def assign(val); end
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::Int8 < ::BinData::BasePrimitive
-  def assign(val); end
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-module BinData::IntFactory
-  def const_missing(name); end
-end
-
-class BinData::LazyEvaluator
-  def initialize(obj); end
-
-  def index; end
-  def lazy_eval(val, overrides = T.unsafe(nil)); end
-  def method_missing(symbol, *args); end
-  def parent; end
-
-  private
-
-  def callable?(obj); end
-  def eval_symbol_in_parent_context(symbol, args); end
-  def recursively_eval(val, args); end
-  def resolve_symbol_in_parent_context(symbol, args); end
-end
-
-module BinData::MultiFieldArgSeparator
-  def field_names_in_parameters?(obj_class, parameters); end
-  def parameters_is_value?(obj_class, value, parameters); end
-  def separate_args(obj_class, obj_args); end
-end
-
-class BinData::Primitive < ::BinData::BasePrimitive
-  extend ::BinData::DSLMixin
-
-  def assign(val); end
-  def debug_name_of(child); end
-  def do_num_bytes; end
-  def do_write(io); end
-  def initialize_instance; end
-  def method_missing(symbol, *args, &block); end
-  def respond_to?(symbol, include_private = T.unsafe(nil)); end
-
-  private
-
-  def get; end
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def set(v); end
-
-  class << self
-    def bit_aligned; end
-  end
-end
-
-class BinData::PrimitiveArgProcessor < ::BinData::BaseArgProcessor
-  def sanitize_parameters!(obj_class, params); end
-end
-
-module BinData::ReadUntilEOFPlugin
-  def do_read(io); end
-end
-
-module BinData::ReadUntilPlugin
-  def do_read(io); end
-end
-
-class BinData::Record < ::BinData::Struct
-  extend ::BinData::DSLMixin
-
-  class << self
-    def inherited(subclass); end
-  end
-end
-
-class BinData::RecordArgProcessor < ::BinData::StructArgProcessor
-  include ::BinData::MultiFieldArgSeparator
-
-  def sanitize_parameters!(obj_class, params); end
-end
-
-module BinData::RegisterNamePlugin
-  def initialize_shared_instance; end
-
-  class << self
-    def included(base); end
-  end
-end
-
-BinData::RegisteredClasses = T.let(T.unsafe(nil), BinData::Registry)
-
-class BinData::Registry
-  def initialize; end
-
-  def lookup(name, hints = T.unsafe(nil)); end
-  def register(name, class_to_register); end
-  def underscore_name(name); end
-  def unregister(name); end
-
-  private
-
-  def name_with_endian(name, endian); end
-  def name_with_prefix(name, prefix); end
-  def normalize_name(name, hints); end
-  def register_dynamic_class(name); end
-  def registered?(name); end
-  def warn_if_name_is_already_registered(name, class_to_register); end
-end
-
-class BinData::Rest < ::BinData::BasePrimitive
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::ResumeByteAlignment < ::BinData::Base
-  def assign(val); end
-  def clear?; end
-  def do_num_bytes; end
-  def do_read(io); end
-  def do_write(io); end
-  def snapshot; end
-end
-
-class BinData::SanitizedBigEndian < ::BinData::SanitizedParameter
-  def endian; end
-end
-
-class BinData::SanitizedChoices < ::BinData::SanitizedParameter
-  def initialize(choices, hints); end
-
-  def [](key); end
-end
-
-class BinData::SanitizedField < ::BinData::SanitizedParameter
-  def initialize(name, field_type, field_params, hints); end
-
-  def has_parameter?(param); end
-  def instantiate(value = T.unsafe(nil), parent = T.unsafe(nil)); end
-  def name; end
-  def name_as_sym; end
-  def prototype; end
-end
-
-class BinData::SanitizedFields < ::BinData::SanitizedParameter
-  include ::Enumerable
-
-  def initialize(hints, base_fields = T.unsafe(nil)); end
-
-  def [](idx); end
-  def add_field(type, name, params); end
-  def all_field_names_blank?; end
-  def any_field_has_parameter?(parameter); end
-  def each(&block); end
-  def empty?; end
-  def field_name?(name); end
-  def field_names; end
-  def length; end
-  def no_field_names_blank?; end
-  def raw_fields; end
-end
-
-class BinData::SanitizedLittleEndian < ::BinData::SanitizedParameter
-  def endian; end
-end
-
-class BinData::SanitizedParameter; end
-
-class BinData::SanitizedParameters < ::Hash
-  def initialize(parameters, the_class, hints); end
-
-  def create_sanitized_params(params, the_class); end
-  def has_at_least_one_of?(*keys); end
-  def has_parameter?(_arg0); end
-  def hints; end
-  def must_be_integer(*keys); end
-  def rename_parameter(old_key, new_key); end
-  def sanitize(key, &block); end
-  def sanitize_choices(key, &block); end
-  def sanitize_endian(key); end
-  def sanitize_fields(key, &block); end
-  def sanitize_object_prototype(key); end
-  def warn_replacement_parameter(bad_key, suggested_key); end
-
-  private
-
-  def create_sanitized_choices(choices); end
-  def create_sanitized_endian(endian); end
-  def create_sanitized_fields; end
-  def create_sanitized_object_prototype(obj_type, obj_params); end
-  def ensure_mandatory_parameters_exist; end
-  def ensure_mutual_exclusion_of_parameters; end
-  def ensure_no_nil_values; end
-  def merge_default_parameters!; end
-  def needs_sanitizing?(key); end
-  def sanitize!; end
-
-  class << self
-    def sanitize(parameters, the_class); end
-  end
-end
-
-BinData::SanitizedParameters::BIG_ENDIAN = T.let(T.unsafe(nil), BinData::SanitizedBigEndian)
-BinData::SanitizedParameters::LITTLE_ENDIAN = T.let(T.unsafe(nil), BinData::SanitizedLittleEndian)
-
-class BinData::SanitizedPrototype < ::BinData::SanitizedParameter
-  def initialize(obj_type, obj_params, hints); end
-
-  def has_parameter?(param); end
-  def instantiate(value = T.unsafe(nil), parent = T.unsafe(nil)); end
-end
-
-class BinData::Sbit < ::BinData::BasePrimitive
-  def assign(val); end
-  def bit_aligned?; end
-  def do_num_bytes; end
-  def do_write(io); end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-end
-
-class BinData::SbitLe < ::BinData::BasePrimitive
-  def assign(val); end
-  def bit_aligned?; end
-  def do_num_bytes; end
-  def do_write(io); end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-end
-
-class BinData::Skip < ::BinData::BasePrimitive
-  def initialize_shared_instance; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::SkipArgProcessor < ::BinData::BaseArgProcessor
-  def sanitize_parameters!(obj_class, params); end
-end
-
-module BinData::SkipLengthPlugin
-  def skip_length; end
-end
-
-module BinData::SkipToAbsOffsetPlugin
-  def skip_length; end
-end
-
-module BinData::SkipUntilValidPlugin
-  def read_and_return_value(io); end
-  def skip_length; end
-end
-
-class BinData::String < ::BinData::BasePrimitive
-  def assign(val); end
-  def initialize_shared_instance; end
-  def snapshot; end
-
-  private
-
-  def clamp_to_length(str); end
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def trim_padding(str); end
-  def value_to_binary_string(val); end
-end
-
-class BinData::StringArgProcessor < ::BinData::BaseArgProcessor
-  def sanitize_parameters!(obj_class, params); end
-
-  private
-
-  def sanitized_pad_byte(byte); end
-end
-
-class BinData::Stringz < ::BinData::BasePrimitive
-  def assign(val); end
-  def snapshot; end
-
-  private
-
-  def append_zero_byte_if_needed!(str); end
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def trim_and_zero_terminate(str); end
-  def trim_to!(str, max_length = T.unsafe(nil)); end
-  def truncate_after_first_zero_byte!(str); end
-  def value_to_binary_string(val); end
-end
-
-class BinData::Struct < ::BinData::Base
-  def [](key); end
-  def []=(key, value); end
-  def assign(val); end
-  def clear; end
-  def clear?; end
-  def debug_name_of(child); end
-  def do_num_bytes; end
-  def do_read(io); end
-  def do_write(io); end
-  def each_pair; end
-  def field_names(include_hidden = T.unsafe(nil)); end
-  def has_key?(key); end
-  def initialize_instance; end
-  def initialize_shared_instance; end
-  def key?(key); end
-  def offset_of(child); end
-  def snapshot; end
-
-  private
-
-  def as_stringified_hash(val); end
-  def assign_fields(val); end
-  def base_field_name(name); end
-  def define_field_accessors; end
-  def define_field_accessors_for(name, index); end
-  def find_index_of(obj); end
-  def find_obj_for_name(name); end
-  def include_obj?(obj); end
-  def instantiate_all_objs; end
-  def instantiate_obj_at(index); end
-  def sum_num_bytes_below_index(index); end
-  def sum_num_bytes_for_all_fields; end
-
-  class << self
-    def inherited(subclass); end
-  end
-end
-
-BinData::Struct::RESERVED = T.let(T.unsafe(nil), Hash)
-
-class BinData::Struct::Snapshot < ::Hash
-  def []=(key, value); end
-  def method_missing(symbol, *args); end
-  def respond_to?(symbol, include_private = T.unsafe(nil)); end
-end
-
-class BinData::StructArgProcessor < ::BinData::BaseArgProcessor
-  def sanitize_parameters!(obj_class, params); end
-
-  private
-
-  def ensure_field_names_are_valid(obj_class, field_names); end
-  def hidden_field_names(hidden); end
-  def sanitize_endian(params); end
-  def sanitize_fields(obj_class, params); end
-  def sanitize_hide(params); end
-  def sanitize_search_prefix(params); end
-  def sanitized_field_names(sanitized_fields); end
-end
-
-class BinData::Tracer
-  def initialize(io); end
-
-  def trace(msg); end
-  def trace_obj(obj_name, val); end
-end
-
-class BinData::Uint16be < ::BinData::BasePrimitive
-  def assign(val); end
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::Uint16le < ::BinData::BasePrimitive
-  def assign(val); end
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::Uint32be < ::BinData::BasePrimitive
-  def assign(val); end
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::Uint32le < ::BinData::BasePrimitive
-  def assign(val); end
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::Uint64be < ::BinData::BasePrimitive
-  def assign(val); end
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::Uint64le < ::BinData::BasePrimitive
-  def assign(val); end
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::Uint8 < ::BinData::BasePrimitive
-  def assign(val); end
-  def do_num_bytes; end
-
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::Uint8Array < ::BinData::BasePrimitive
-  private
-
-  def read_and_return_value(io); end
-  def sensible_default; end
-  def value_to_binary_string(val); end
-end
-
-class BinData::Uint8ArrayArgProcessor < ::BinData::BaseArgProcessor
-  def sanitize_parameters!(obj_class, params); end
-end
-
-class BinData::UnRegisteredTypeError < ::StandardError; end
-BinData::VERSION = T.let(T.unsafe(nil), String)
-class BinData::ValidityError < ::StandardError; end
-
-class BinData::Virtual < ::BinData::BasePrimitive
-  def do_num_bytes; end
-  def do_read(io); end
-  def do_write(io); end
-  def sensible_default; end
-end
-
-module BinData::WarnNoReadLengthPlugin
-  def read_and_return_value(io); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/bindata@2.5.0.rbi b/Library/Homebrew/sorbet/rbi/gems/bindata@2.5.0.rbi
new file mode 100644
index 0000000000000..e348c271d35e6
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/bindata@2.5.0.rbi
@@ -0,0 +1,3626 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `bindata` gem.
+# Please instead update this file by running `bin/tapioca gem bindata`.
+
+# source://bindata//lib/bindata/version.rb#1
+module BinData
+  extend ::BinData::BitFieldFactory
+  extend ::BinData::IntFactory
+
+  private
+
+  # @yield [@tracer]
+  #
+  # source://bindata//lib/bindata/trace.rb#41
+  def trace_message; end
+
+  # Turn on trace information when reading a BinData object.
+  # If +block+ is given then the tracing only occurs for that block.
+  # This is useful for debugging a BinData declaration.
+  #
+  # source://bindata//lib/bindata/trace.rb#6
+  def trace_reading(io = T.unsafe(nil)); end
+
+  class << self
+    # @yield [@tracer]
+    #
+    # source://bindata//lib/bindata/trace.rb#41
+    def trace_message; end
+
+    # Turn on trace information when reading a BinData object.
+    # If +block+ is given then the tracing only occurs for that block.
+    # This is useful for debugging a BinData declaration.
+    #
+    # source://bindata//lib/bindata/trace.rb#6
+    def trace_reading(io = T.unsafe(nil)); end
+  end
+end
+
+# source://bindata//lib/bindata/params.rb#4
+module BinData::AcceptedParametersPlugin
+  # source://bindata//lib/bindata/params.rb#30
+  def accepted_parameters; end
+
+  # Default parameters can be overridden when instantiating a data object.
+  #
+  # source://bindata//lib/bindata/params.rb#16
+  def default_parameter(*args); end
+
+  # Default parameters can be overridden when instantiating a data object.
+  #
+  # source://bindata//lib/bindata/params.rb#16
+  def default_parameters(*args); end
+
+  # Mandatory parameters must be present when instantiating a data object.
+  #
+  # source://bindata//lib/bindata/params.rb#6
+  def mandatory_parameter(*args); end
+
+  # Mandatory parameters must be present when instantiating a data object.
+  #
+  # source://bindata//lib/bindata/params.rb#6
+  def mandatory_parameters(*args); end
+
+  # Mutually exclusive parameters may not all be present when
+  # instantiating a data object.
+  #
+  # source://bindata//lib/bindata/params.rb#22
+  def mutually_exclusive_parameters(*args); end
+
+  # Optional parameters may be present when instantiating a data object.
+  #
+  # source://bindata//lib/bindata/params.rb#11
+  def optional_parameter(*args); end
+
+  # Optional parameters may be present when instantiating a data object.
+  #
+  # source://bindata//lib/bindata/params.rb#11
+  def optional_parameters(*args); end
+end
+
+# BinData objects accept parameters when initializing.  AcceptedParameters
+# allow a BinData class to declaratively identify accepted parameters as
+# mandatory, optional, default or mutually exclusive.
+#
+# source://bindata//lib/bindata/params.rb#41
+class BinData::AcceptedParametersPlugin::AcceptedParameters
+  # @return [AcceptedParameters] a new instance of AcceptedParameters
+  #
+  # source://bindata//lib/bindata/params.rb#42
+  def initialize(ancestor_parameters = T.unsafe(nil)); end
+
+  # source://bindata//lib/bindata/params.rb#94
+  def all; end
+
+  # source://bindata//lib/bindata/params.rb#72
+  def default(args = T.unsafe(nil)); end
+
+  # source://bindata//lib/bindata/params.rb#56
+  def mandatory(*args); end
+
+  # source://bindata//lib/bindata/params.rb#82
+  def mutually_exclusive(*args); end
+
+  # source://bindata//lib/bindata/params.rb#64
+  def optional(*args); end
+
+  private
+
+  # source://bindata//lib/bindata/params.rb#107
+  def ensure_valid_names(names); end
+
+  # source://bindata//lib/bindata/params.rb#101
+  def to_syms(args); end
+
+  class << self
+    # source://bindata//lib/bindata/params.rb#118
+    def invalid_parameter_names; end
+  end
+end
+
+# An Array is a list of data objects of the same type.
+#
+#   require 'bindata'
+#
+#   data = "\x03\x04\x05\x06\x07\x08\x09"
+#
+#   obj = BinData::Array.new(type: :int8, initial_length: 6)
+#   obj.read(data) #=> [3, 4, 5, 6, 7, 8]
+#
+#   obj = BinData::Array.new(type: :int8,
+#                            read_until: -> { index == 1 })
+#   obj.read(data) #=> [3, 4]
+#
+#   obj = BinData::Array.new(type: :int8,
+#                            read_until: -> { element >= 6 })
+#   obj.read(data) #=> [3, 4, 5, 6]
+#
+#   obj = BinData::Array.new(type: :int8,
+#           read_until: -> { array[index] + array[index - 1] == 13 })
+#   obj.read(data) #=> [3, 4, 5, 6, 7]
+#
+#   obj = BinData::Array.new(type: :int8, read_until: :eof)
+#   obj.read(data) #=> [3, 4, 5, 6, 7, 8, 9]
+#
+# == Parameters
+#
+# Parameters may be provided at initialisation to control the behaviour of
+# an object.  These params are:
+#
+# <tt>:type</tt>::           The symbol representing the data type of the
+#                            array elements.  If the type is to have params
+#                            passed to it, then it should be provided as
+#                            <tt>[type_symbol, hash_params]</tt>.
+# <tt>:initial_length</tt>:: The initial length of the array.
+# <tt>:read_until</tt>::     While reading, elements are read until this
+#                            condition is true.  This is typically used to
+#                            read an array until a sentinel value is found.
+#                            The variables +index+, +element+ and +array+
+#                            are made available to any lambda assigned to
+#                            this parameter.  If the value of this parameter
+#                            is the symbol :eof, then the array will read
+#                            as much data from the stream as possible.
+#
+# Each data object in an array has the variable +index+ made available
+# to any lambda evaluated as a parameter of that data object.
+#
+# source://bindata//lib/bindata/array.rb#50
+class BinData::Array < ::BinData::Base
+  include ::Enumerable
+  extend ::BinData::DSLMixin
+
+  # source://bindata//lib/bindata/array.rb#106
+  def <<(*args); end
+
+  # Returns the element at +index+.
+  #
+  # source://bindata//lib/bindata/array.rb#139
+  def [](arg1, arg2 = T.unsafe(nil)); end
+
+  # Sets the element at +index+.
+  #
+  # source://bindata//lib/bindata/array.rb#174
+  def []=(index, value); end
+
+  # @raise [ArgumentError]
+  #
+  # source://bindata//lib/bindata/array.rb#82
+  def assign(array); end
+
+  # Returns the element at +index+.  Unlike +slice+, if +index+ is out
+  # of range the array will not be automatically extended.
+  #
+  # source://bindata//lib/bindata/array.rb#169
+  def at(index); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/array.rb#78
+  def clear?; end
+
+  # source://bindata//lib/bindata/array.rb#117
+  def concat(array); end
+
+  # source://bindata//lib/bindata/array.rb#223
+  def debug_name_of(child); end
+
+  # source://bindata//lib/bindata/array.rb#239
+  def do_num_bytes; end
+
+  # source://bindata//lib/bindata/array.rb#235
+  def do_write(io); end
+
+  # source://bindata//lib/bindata/array.rb#219
+  def each; end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/array.rb#210
+  def empty?; end
+
+  # source://bindata//lib/bindata/array.rb#94
+  def find_index(obj); end
+
+  # Returns the first index of +obj+ in self.
+  #
+  # Uses equal? for the comparator.
+  #
+  # source://bindata//lib/bindata/array.rb#102
+  def find_index_of(obj); end
+
+  # Returns the first element, or the first +n+ elements, of the array.
+  # If the array is empty, the first form returns nil, and the second
+  # form returns an empty array.
+  #
+  # source://bindata//lib/bindata/array.rb#182
+  def first(n = T.unsafe(nil)); end
+
+  # source://bindata//lib/bindata/array.rb#94
+  def index(obj); end
+
+  # source://bindata//lib/bindata/array.rb#74
+  def initialize_instance; end
+
+  # source://bindata//lib/bindata/array.rb#61
+  def initialize_shared_instance; end
+
+  # source://bindata//lib/bindata/array.rb#122
+  def insert(index, *objs); end
+
+  # Returns the last element, or the last +n+ elements, of the array.
+  # If the array is empty, the first form returns nil, and the second
+  # form returns an empty array.
+  #
+  # source://bindata//lib/bindata/array.rb#196
+  def last(n = T.unsafe(nil)); end
+
+  # source://bindata//lib/bindata/array.rb#205
+  def length; end
+
+  # source://bindata//lib/bindata/array.rb#228
+  def offset_of(child); end
+
+  # source://bindata//lib/bindata/array.rb#106
+  def push(*args); end
+
+  # source://bindata//lib/bindata/array.rb#205
+  def size; end
+
+  # Returns the element at +index+.
+  #
+  # source://bindata//lib/bindata/array.rb#139
+  def slice(arg1, arg2 = T.unsafe(nil)); end
+
+  # source://bindata//lib/bindata/array.rb#90
+  def snapshot; end
+
+  # Allow this object to be used in array context.
+  #
+  # source://bindata//lib/bindata/array.rb#215
+  def to_ary; end
+
+  # source://bindata//lib/bindata/array.rb#112
+  def unshift(*args); end
+
+  private
+
+  # source://bindata//lib/bindata/array.rb#257
+  def append_new_element; end
+
+  # source://bindata//lib/bindata/array.rb#253
+  def elements; end
+
+  # source://bindata//lib/bindata/array.rb#246
+  def extend_array(max_index); end
+
+  # source://bindata//lib/bindata/array.rb#263
+  def new_element; end
+
+  # source://bindata//lib/bindata/array.rb#153
+  def slice_index(index); end
+
+  # source://bindata//lib/bindata/array.rb#162
+  def slice_range(range); end
+
+  # source://bindata//lib/bindata/array.rb#158
+  def slice_start_length(start, length); end
+
+  # source://bindata//lib/bindata/array.rb#271
+  def sum_num_bytes_below_index(index); end
+
+  # source://bindata//lib/bindata/array.rb#267
+  def sum_num_bytes_for_all_elements; end
+end
+
+# Logic for the :initial_length parameter
+#
+# source://bindata//lib/bindata/array.rb#311
+module BinData::Array::InitialLengthPlugin
+  # source://bindata//lib/bindata/array.rb#312
+  def do_read(io); end
+
+  # source://bindata//lib/bindata/array.rb#316
+  def elements; end
+end
+
+# Logic for the read_until: :eof parameter
+#
+# source://bindata//lib/bindata/array.rb#296
+module BinData::Array::ReadUntilEOFPlugin
+  # source://bindata//lib/bindata/array.rb#297
+  def do_read(io); end
+end
+
+# Logic for the :read_until parameter
+#
+# source://bindata//lib/bindata/array.rb#284
+module BinData::Array::ReadUntilPlugin
+  # source://bindata//lib/bindata/array.rb#285
+  def do_read(io); end
+end
+
+# source://bindata//lib/bindata/array.rb#329
+class BinData::ArrayArgProcessor < ::BinData::BaseArgProcessor
+  # source://bindata//lib/bindata/array.rb#330
+  def sanitize_parameters!(obj_class, params); end
+end
+
+# This is the abstract base class for all data objects.
+#
+# source://bindata//lib/bindata/base.rb#11
+class BinData::Base
+  include ::BinData::Framework
+  include ::BinData::RegisterNamePlugin
+  extend ::BinData::AcceptedParametersPlugin
+
+  # source://bindata//lib/bindata/warnings.rb#12
+  def initialize(*args); end
+
+  # source://bindata//lib/bindata/base.rb#221
+  def ==(other); end
+
+  # Override and delegate =~ as it is defined in Object.
+  #
+  # source://bindata//lib/bindata/base.rb#201
+  def =~(other); end
+
+  # Returns the offset (in bytes) of this object with respect to its most
+  # distant ancestor.
+  #
+  # source://bindata//lib/bindata/base.rb#212
+  def abs_offset; end
+
+  def base_respond_to?(*_arg0); end
+
+  # Resets the internal state to that of a newly created object.
+  #
+  # source://bindata//lib/bindata/base.rb#139
+  def clear; end
+
+  # Returns a user friendly name of this object for debugging purposes.
+  #
+  # source://bindata//lib/bindata/base.rb#206
+  def debug_name; end
+
+  # Returns the result of evaluating the parameter identified by +key+.
+  #
+  # +overrides+ is an optional +parameters+ like hash that allow the
+  # parameters given at object construction to be overridden.
+  #
+  # Returns nil if +key+ does not refer to any parameter.
+  #
+  # source://bindata//lib/bindata/base.rb#112
+  def eval_parameter(key, overrides = T.unsafe(nil)); end
+
+  # Returns the parameter referenced by +key+.
+  # Use this method if you are sure the parameter is not to be evaluated.
+  # You most likely want #eval_parameter.
+  #
+  # source://bindata//lib/bindata/base.rb#129
+  def get_parameter(key); end
+
+  # Returns whether +key+ exists in the +parameters+ hash.
+  #
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/base.rb#134
+  def has_parameter?(key); end
+
+  # source://bindata//lib/bindata/warnings.rb#25
+  def initialize_instance(*args); end
+
+  # source://bindata//lib/bindata/warnings.rb#12
+  def initialize_with_warning(*args); end
+
+  # Return a human readable representation of this data object.
+  #
+  # source://bindata//lib/bindata/base.rb#186
+  def inspect; end
+
+  # Returns a lazy evaluator for this object.
+  #
+  # source://bindata//lib/bindata/base.rb#122
+  def lazy_evaluator; end
+
+  # Creates a new data object based on this instance.
+  #
+  # This implements the prototype design pattern.
+  #
+  # All parameters will be be duplicated.  Use this method
+  # when creating multiple objects with the same parameters.
+  #
+  # source://bindata//lib/bindata/base.rb#97
+  def new(value = T.unsafe(nil), parent = T.unsafe(nil)); end
+
+  # Returns the number of bytes it will take to write this data object.
+  #
+  # source://bindata//lib/bindata/base.rb#169
+  def num_bytes; end
+
+  # Returns the value of attribute parent.
+  #
+  # source://bindata//lib/bindata/base.rb#88
+  def parent; end
+
+  # Work with Ruby's pretty-printer library.
+  #
+  # source://bindata//lib/bindata/base.rb#196
+  def pretty_print(pp); end
+
+  # Reads data into this data object.
+  #
+  # source://bindata//lib/bindata/base.rb#144
+  def read(io, &block); end
+
+  # Returns the offset (in bytes) of this object with respect to its parent.
+  #
+  # source://bindata//lib/bindata/base.rb#217
+  def rel_offset; end
+
+  # A version of +respond_to?+ used by the lazy evaluator.  It doesn't
+  # reinvoke the evaluator so as to avoid infinite evaluation loops.
+  #
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/base.rb#228
+  def safe_respond_to?(symbol, include_private = T.unsafe(nil)); end
+
+  # Returns the string representation of this data object.
+  #
+  # source://bindata//lib/bindata/base.rb#174
+  def to_binary_s(&block); end
+
+  # Returns the hexadecimal string representation of this data object.
+  #
+  # source://bindata//lib/bindata/base.rb#181
+  def to_hex(&block); end
+
+  # Return a string representing this data object.
+  #
+  # source://bindata//lib/bindata/base.rb#191
+  def to_s; end
+
+  # Writes the value for this data object to +io+.
+  #
+  # source://bindata//lib/bindata/base.rb#157
+  def write(io, &block); end
+
+  protected
+
+  # Sets the attribute parent
+  #
+  # @param value the value to set the attribute parent to.
+  #
+  # source://bindata//lib/bindata/base.rb#88
+  def parent=(_arg0); end
+
+  private
+
+  # source://bindata//lib/bindata/base.rb#274
+  def binary_string(str); end
+
+  # source://bindata//lib/bindata/base.rb#237
+  def extract_args(args); end
+
+  # Creates a new data object.
+  #
+  # Args are optional, but if present, must be in the following order.
+  #
+  # +value+ is a value that is +assign+ed immediately after initialization.
+  #
+  # +parameters+ is a hash containing symbol keys.  Some parameters may
+  # reference callable objects (methods or procs).
+  #
+  # +parent+ is the parent data object (e.g. struct, array, choice) this
+  # object resides under.
+  # Don't override initialize.  If you are defining a new kind of datatype
+  # (list, array, choice etc) then put your initialization code in
+  # #initialize_instance.  BinData objects might be initialized as prototypes
+  # and your initialization code may not be called.
+  #
+  # If you're subclassing BinData::Record, you are definitely doing the wrong
+  # thing.  Read the documentation on how to use BinData.
+  # http://github.com/dmendel/bindata/wiki/Records
+  #
+  # @return [Base] a new instance of Base
+  #
+  # source://bindata//lib/bindata/base.rb#80
+  def initialize_without_warning(*args); end
+
+  # Is this object tree currently being read?  Used by BasePrimitive.
+  #
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/base.rb#249
+  def reading?; end
+
+  # source://bindata//lib/bindata/base.rb#241
+  def start_read; end
+
+  # source://bindata//lib/bindata/base.rb#263
+  def top_level; end
+
+  # source://bindata//lib/bindata/base.rb#257
+  def top_level_get(sym); end
+
+  # source://bindata//lib/bindata/base.rb#253
+  def top_level_set(sym, value); end
+
+  class << self
+    # The arg processor for this class.
+    #
+    # source://bindata//lib/bindata/base.rb#26
+    def arg_processor(name = T.unsafe(nil)); end
+
+    # The +auto_call_delayed_io+ keyword sets a data object tree to perform
+    # multi pass I/O automatically.
+    #
+    # source://bindata//lib/bindata/delayed_io.rb#161
+    def auto_call_delayed_io; end
+
+    # The name of this class as used by Records, Arrays etc.
+    #
+    # source://bindata//lib/bindata/base.rb#41
+    def bindata_name; end
+
+    # source://bindata//lib/bindata/base.rb#53
+    def inherited(subclass); end
+
+    # Instantiates this class and reads from +io+, returning the newly
+    # created data object.  +args+ will be used when instantiating.
+    #
+    # source://bindata//lib/bindata/base.rb#19
+    def read(io, *args, &block); end
+
+    private
+
+    # Registers all subclasses of this class for use
+    #
+    # source://bindata//lib/bindata/base.rb#51
+    def register_subclasses; end
+
+    # Call this method if this class is abstract and not to be used.
+    #
+    # source://bindata//lib/bindata/base.rb#46
+    def unregister_self; end
+  end
+end
+
+# source://bindata//lib/bindata/delayed_io.rb#179
+module BinData::Base::AutoCallDelayedIO
+  # source://bindata//lib/bindata/delayed_io.rb#180
+  def initialize_shared_instance; end
+
+  # source://bindata//lib/bindata/delayed_io.rb#193
+  def num_bytes; end
+
+  # source://bindata//lib/bindata/delayed_io.rb#185
+  def read(io); end
+
+  # source://bindata//lib/bindata/delayed_io.rb#189
+  def write(io, *_); end
+end
+
+# ArgProcessors process the arguments passed to BinData::Base.new into
+# the form required to initialise the BinData object.
+#
+# Any passed parameters are sanitized so the BinData object doesn't
+# need to perform error checking on the parameters.
+#
+# source://bindata//lib/bindata/base.rb#284
+class BinData::BaseArgProcessor
+  # Takes the arguments passed to BinData::Base.new and
+  # extracts [value, sanitized_parameters, parent].
+  #
+  # source://bindata//lib/bindata/base.rb#289
+  def extract_args(obj_class, obj_args); end
+
+  # Performs sanity checks on the given parameters.
+  # This method converts the parameters to the form expected
+  # by the data object.
+  #
+  # source://bindata//lib/bindata/base.rb#322
+  def sanitize_parameters!(obj_class, obj_params); end
+
+  # Separates the arguments passed to BinData::Base.new into
+  # [value, parameters, parent].  Called by #extract_args.
+  #
+  # source://bindata//lib/bindata/base.rb#298
+  def separate_args(_obj_class, obj_args); end
+end
+
+# A BinData::BasePrimitive object is a container for a value that has a
+# particular binary representation.  A value corresponds to a primitive type
+# such as as integer, float or string.  Only one value can be contained by
+# this object.  This value can be read from or written to an IO stream.
+#
+#   require 'bindata'
+#
+#   obj = BinData::Uint8.new(initial_value: 42)
+#   obj #=> 42
+#   obj.assign(5)
+#   obj #=> 5
+#   obj.clear
+#   obj #=> 42
+#
+#   obj = BinData::Uint8.new(value: 42)
+#   obj #=> 42
+#   obj.assign(5)
+#   obj #=> 42
+#
+#   obj = BinData::Uint8.new(assert: 3)
+#   obj.read("\005") #=> BinData::ValidityError: value is '5' but expected '3'
+#
+#   obj = BinData::Uint8.new(assert: -> { value < 5 })
+#   obj.read("\007") #=> BinData::ValidityError: value not as expected
+#
+# == Parameters
+#
+# Parameters may be provided at initialisation to control the behaviour of
+# an object.  These params include those for BinData::Base as well as:
+#
+# [<tt>:initial_value</tt>]  This is the initial value to use before one is
+#                            either #read or explicitly set with #value=.
+# [<tt>:value</tt>]          The object will always have this value.
+#                            Calls to #value= are ignored when
+#                            using this param.  While reading, #value
+#                            will return the value of the data read from the
+#                            IO, not the result of the <tt>:value</tt> param.
+# [<tt>:assert</tt>]         Raise an error unless the value read or assigned
+#                            meets this criteria.  The variable +value+ is
+#                            made available to any lambda assigned to this
+#                            parameter.  A boolean return indicates success
+#                            or failure.  Any other return is compared to
+#                            the value just read in.
+# [<tt>:asserted_value</tt>] Equivalent to <tt>:assert</tt> and <tt>:value</tt>.
+#
+# source://bindata//lib/bindata/base_primitive.rb#49
+class BinData::BasePrimitive < ::BinData::Base
+  extend ::BinData::TraceHook
+
+  # source://bindata//lib/bindata/base_primitive.rb#110
+  def <=>(other); end
+
+  # @raise [ArgumentError]
+  #
+  # source://bindata//lib/bindata/base_primitive.rb#72
+  def assign(val); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/base_primitive.rb#68
+  def clear?; end
+
+  # source://bindata//lib/bindata/base_primitive.rb#131
+  def do_num_bytes; end
+
+  # source://bindata//lib/bindata/base_primitive.rb#123
+  def do_read(io); end
+
+  # source://bindata//lib/bindata/trace.rb#66
+  def do_read_with_hook(io); end
+
+  # source://bindata//lib/bindata/base_primitive.rb#127
+  def do_write(io); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/base_primitive.rb#114
+  def eql?(other); end
+
+  # source://bindata//lib/bindata/base_primitive.rb#119
+  def hash; end
+
+  # source://bindata//lib/bindata/base_primitive.rb#64
+  def initialize_instance; end
+
+  # source://bindata//lib/bindata/base_primitive.rb#56
+  def initialize_shared_instance; end
+
+  # source://bindata//lib/bindata/base_primitive.rb#96
+  def method_missing(symbol, *args, &block); end
+
+  # source://bindata//lib/bindata/base_primitive.rb#79
+  def snapshot; end
+
+  # source://bindata//lib/bindata/base_primitive.rb#83
+  def value; end
+
+  # source://bindata//lib/bindata/base_primitive.rb#87
+  def value=(val); end
+
+  private
+
+  # The unmodified value of this data object.  Note that #snapshot calls this
+  # method.  This indirection is so that #snapshot can be overridden in
+  # subclasses to modify the presentation value.
+  #
+  # source://bindata//lib/bindata/base_primitive.rb#141
+  def _value; end
+
+  # Read a number of bytes from +io+ and return the value they represent.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://bindata//lib/bindata/base_primitive.rb#240
+  def read_and_return_value(io); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/base_primitive.rb#91
+  def respond_to_missing?(symbol, include_all = T.unsafe(nil)); end
+
+  # Return a sensible default for this data.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://bindata//lib/bindata/base_primitive.rb#245
+  def sensible_default; end
+
+  # Return the string representation that +val+ will take when written.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://bindata//lib/bindata/base_primitive.rb#235
+  def value_to_binary_string(val); end
+
+  class << self
+    # source://bindata//lib/bindata/alignment.rb#80
+    def bit_aligned; end
+
+    # source://bindata//lib/bindata/base.rb#53
+    def inherited(subclass); end
+  end
+end
+
+# Logic for the :assert parameter
+#
+# source://bindata//lib/bindata/base_primitive.rb#164
+module BinData::BasePrimitive::AssertPlugin
+  # @raise [ValidityError]
+  #
+  # source://bindata//lib/bindata/base_primitive.rb#175
+  def assert!; end
+
+  # source://bindata//lib/bindata/base_primitive.rb#165
+  def assign(val); end
+
+  # source://bindata//lib/bindata/base_primitive.rb#170
+  def do_read(io); end
+end
+
+# Logic for the :asserted_value parameter
+#
+# source://bindata//lib/bindata/base_primitive.rb#193
+module BinData::BasePrimitive::AssertedValuePlugin
+  # source://bindata//lib/bindata/base_primitive.rb#199
+  def _value; end
+
+  # source://bindata//lib/bindata/base_primitive.rb#217
+  def assert!; end
+
+  # source://bindata//lib/bindata/base_primitive.rb#221
+  def assert_value(current_value); end
+
+  # The asserted value as a binary string.
+  #
+  # Rationale: while reading, +#to_binary_s+ will use the
+  # value read in, rather than the +:asserted_value+.
+  # This feature is used by Skip.
+  #
+  # source://bindata//lib/bindata/base_primitive.rb#208
+  def asserted_binary_s; end
+
+  # source://bindata//lib/bindata/base_primitive.rb#194
+  def assign(val); end
+
+  # source://bindata//lib/bindata/base_primitive.rb#212
+  def do_read(io); end
+end
+
+# Logic for the :initial_value parameter
+#
+# source://bindata//lib/bindata/base_primitive.rb#157
+module BinData::BasePrimitive::InitialValuePlugin
+  # source://bindata//lib/bindata/base_primitive.rb#158
+  def _value; end
+end
+
+# Logic for the :value parameter
+#
+# source://bindata//lib/bindata/base_primitive.rb#146
+module BinData::BasePrimitive::ValuePlugin
+  # source://bindata//lib/bindata/base_primitive.rb#151
+  def _value; end
+
+  # source://bindata//lib/bindata/base_primitive.rb#147
+  def assign(val); end
+end
+
+# source://bindata//lib/bindata/bits.rb#15
+class BinData::Bit < ::BinData::BasePrimitive
+  def assign(val); end
+  def bit_aligned?; end
+  def do_num_bytes; end
+  def do_write(io); end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+end
+
+# A monkey patch to force byte-aligned primitives to
+# become bit-aligned.  This allows them to be used at
+# non byte based boundaries.
+#
+#     class BitString < BinData::String
+#       bit_aligned
+#     end
+#
+#     class MyRecord < BinData::Record
+#       bit4       :preamble
+#       bit_string :str, length: 2
+#     end
+#
+# source://bindata//lib/bindata/alignment.rb#43
+module BinData::BitAligned
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/alignment.rb#63
+  def bit_aligned?; end
+
+  # source://bindata//lib/bindata/alignment.rb#71
+  def do_num_bytes; end
+
+  # source://bindata//lib/bindata/alignment.rb#67
+  def do_read(io); end
+
+  # source://bindata//lib/bindata/alignment.rb#75
+  def do_write(io); end
+end
+
+# source://bindata//lib/bindata/alignment.rb#44
+class BinData::BitAligned::BitAlignedIO
+  # @return [BitAlignedIO] a new instance of BitAlignedIO
+  #
+  # source://bindata//lib/bindata/alignment.rb#45
+  def initialize(io); end
+
+  # source://bindata//lib/bindata/alignment.rb#49
+  def binary_string(str); end
+
+  # source://bindata//lib/bindata/alignment.rb#53
+  def readbytes(n); end
+
+  # source://bindata//lib/bindata/alignment.rb#58
+  def writebytes(str); end
+end
+
+# Defines a number of classes that contain a bit based integer.
+# The integer is defined by endian and number of bits.
+#
+# source://bindata//lib/bindata/bits.rb#8
+module BinData::BitField
+  class << self
+    # source://bindata//lib/bindata/bits.rb#92
+    def create_clamp_code(nbits, signed); end
+
+    # source://bindata//lib/bindata/bits.rb#84
+    def create_do_num_bytes_code(nbits); end
+
+    # source://bindata//lib/bindata/bits.rb#100
+    def create_dynamic_clamp_code(signed); end
+
+    # source://bindata//lib/bindata/bits.rb#112
+    def create_fixed_clamp_code(nbits, signed); end
+
+    # source://bindata//lib/bindata/bits.rb#135
+    def create_int2uint_code(nbits, signed); end
+
+    # source://bindata//lib/bindata/bits.rb#76
+    def create_nbits_code(nbits); end
+
+    # source://bindata//lib/bindata/bits.rb#68
+    def create_params_code(nbits); end
+
+    # source://bindata//lib/bindata/bits.rb#145
+    def create_uint2int_code(nbits, signed); end
+
+    # source://bindata//lib/bindata/bits.rb#12
+    def define_class(name, nbits, endian, signed = T.unsafe(nil)); end
+
+    # source://bindata//lib/bindata/bits.rb#26
+    def define_methods(bit_class, nbits, endian, signed); end
+  end
+end
+
+# Create classes on demand
+#
+# source://bindata//lib/bindata/bits.rb#166
+module BinData::BitFieldFactory
+  # source://bindata//lib/bindata/bits.rb#167
+  def const_missing(name); end
+end
+
+# source://bindata//lib/bindata/bits.rb#15
+class BinData::BitLe < ::BinData::BasePrimitive
+  def assign(val); end
+  def bit_aligned?; end
+  def do_num_bytes; end
+  def do_write(io); end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+end
+
+# A Buffer is conceptually a substream within a data stream.  It has a
+# defined size and it will always read or write the exact number of bytes to
+# fill the buffer.  Short reads will skip over unused bytes and short writes
+# will pad the substream with "\0" bytes.
+#
+#   require 'bindata'
+#
+#   obj = BinData::Buffer.new(length: 5, type: [:string, {value: "abc"}])
+#   obj.to_binary_s #=> "abc\000\000"
+#
+#
+#   class MyBuffer < BinData::Buffer
+#     default_parameter length: 8
+#
+#     endian :little
+#
+#     uint16 :num1
+#     uint16 :num2
+#     # padding occurs here
+#   end
+#
+#   obj = MyBuffer.read("\001\000\002\000\000\000\000\000")
+#   obj.num1 #=> 1
+#   obj.num1 #=> 2
+#   obj.raw_num_bytes #=> 4
+#   obj.num_bytes #=> 8
+#
+#
+#   class StringTable < BinData::Record
+#     endian :little
+#
+#     uint16 :table_size_in_bytes
+#     buffer :strings, length: :table_size_in_bytes do
+#       array read_until: :eof do
+#         uint8 :len
+#         string :str, length: :len
+#       end
+#     end
+#   end
+#
+#
+# == Parameters
+#
+# Parameters may be provided at initialisation to control the behaviour of
+# an object.  These params are:
+#
+# <tt>:length</tt>::   The number of bytes in the buffer.
+# <tt>:type</tt>::     The single type inside the buffer.  Use a struct if
+#                      multiple fields are required.
+#
+# source://bindata//lib/bindata/buffer.rb#54
+class BinData::Buffer < ::BinData::Base
+  extend ::BinData::DSLMixin
+
+  # source://bindata//lib/bindata/buffer.rb#75
+  def assign(val); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/buffer.rb#71
+  def clear?; end
+
+  # source://bindata//lib/bindata/buffer.rb#105
+  def do_num_bytes; end
+
+  # source://bindata//lib/bindata/buffer.rb#91
+  def do_read(io); end
+
+  # source://bindata//lib/bindata/buffer.rb#98
+  def do_write(io); end
+
+  # source://bindata//lib/bindata/buffer.rb#62
+  def initialize_instance; end
+
+  # source://bindata//lib/bindata/buffer.rb#87
+  def method_missing(symbol, *args, &block); end
+
+  # The number of bytes used, ignoring the padding imposed by the buffer.
+  #
+  # source://bindata//lib/bindata/buffer.rb#67
+  def raw_num_bytes; end
+
+  # source://bindata//lib/bindata/buffer.rb#79
+  def snapshot; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/buffer.rb#83
+  def respond_to_missing?(symbol, include_all = T.unsafe(nil)); end
+end
+
+# Transforms the IO stream to restrict access inside
+# a buffer of specified length.
+#
+# source://bindata//lib/bindata/buffer.rb#111
+class BinData::Buffer::BufferIO < ::BinData::IO::Transform
+  # @return [BufferIO] a new instance of BufferIO
+  #
+  # source://bindata//lib/bindata/buffer.rb#112
+  def initialize(length); end
+
+  # source://bindata//lib/bindata/buffer.rb#161
+  def after_read_transform; end
+
+  # source://bindata//lib/bindata/buffer.rb#165
+  def after_write_transform; end
+
+  # source://bindata//lib/bindata/buffer.rb#117
+  def before_transform; end
+
+  # source://bindata//lib/bindata/buffer.rb#169
+  def buffer_limited_n(n); end
+
+  # source://bindata//lib/bindata/buffer.rb#122
+  def num_bytes_remaining; end
+
+  # source://bindata//lib/bindata/buffer.rb#144
+  def read(n); end
+
+  # source://bindata//lib/bindata/buffer.rb#135
+  def seek_abs(n); end
+
+  # source://bindata//lib/bindata/buffer.rb#128
+  def skip(n); end
+
+  # source://bindata//lib/bindata/buffer.rb#151
+  def write(data); end
+end
+
+# source://bindata//lib/bindata/buffer.rb#186
+class BinData::BufferArgProcessor < ::BinData::BaseArgProcessor
+  include ::BinData::MultiFieldArgSeparator
+
+  # source://bindata//lib/bindata/buffer.rb#189
+  def sanitize_parameters!(obj_class, params); end
+end
+
+# A Choice is a collection of data objects of which only one is active
+# at any particular time.  Method calls will be delegated to the active
+# choice.
+#
+#   require 'bindata'
+#
+#   type1 = [:string, {value: "Type1"}]
+#   type2 = [:string, {value: "Type2"}]
+#
+#   choices = {5 => type1, 17 => type2}
+#   a = BinData::Choice.new(choices: choices, selection: 5)
+#   a # => "Type1"
+#
+#   choices = [ type1, type2 ]
+#   a = BinData::Choice.new(choices: choices, selection: 1)
+#   a # => "Type2"
+#
+#   choices = [ nil, nil, nil, type1, nil, type2 ]
+#   a = BinData::Choice.new(choices: choices, selection: 3)
+#   a # => "Type1"
+#
+#
+#   Chooser = Struct.new(:choice)
+#   mychoice = Chooser.new
+#   mychoice.choice = 'big'
+#
+#   choices = {'big' => :uint16be, 'little' => :uint16le}
+#   a = BinData::Choice.new(choices: choices, copy_on_change: true,
+#                           selection: -> { mychoice.choice })
+#   a.assign(256)
+#   a.to_binary_s #=> "\001\000"
+#
+#   mychoice.choice = 'little'
+#   a.to_binary_s #=> "\000\001"
+#
+# == Parameters
+#
+# Parameters may be provided at initialisation to control the behaviour of
+# an object.  These params are:
+#
+# <tt>:choices</tt>::        Either an array or a hash specifying the possible
+#                            data objects.  The format of the
+#                            array/hash.values is a list of symbols
+#                            representing the data object type.  If a choice
+#                            is to have params passed to it, then it should
+#                            be provided as [type_symbol, hash_params].  An
+#                            implementation constraint is that the hash may
+#                            not contain symbols as keys, with the exception
+#                            of :default.  :default is to be used when then
+#                            :selection does not exist in the :choices hash.
+# <tt>:selection</tt>::      An index/key into the :choices array/hash which
+#                            specifies the currently active choice.
+# <tt>:copy_on_change</tt>:: If set to true, copy the value of the previous
+#                            selection to the current selection whenever the
+#                            selection changes.  Default is false.
+#
+# source://bindata//lib/bindata/choice.rb#60
+class BinData::Choice < ::BinData::Base
+  extend ::BinData::DSLMixin
+  extend ::BinData::TraceHook
+
+  def assign(*args); end
+  def clear?(*args); end
+  def do_num_bytes(*args); end
+  def do_read(*args); end
+
+  # source://bindata//lib/bindata/trace.rb#79
+  def do_read_with_hook(io); end
+
+  def do_write(*args); end
+
+  # source://bindata//lib/bindata/choice.rb#74
+  def initialize_instance; end
+
+  # source://bindata//lib/bindata/choice.rb#69
+  def initialize_shared_instance; end
+
+  # source://bindata//lib/bindata/choice.rb#93
+  def method_missing(symbol, *args, &block); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/choice.rb#89
+  def respond_to?(symbol, include_all = T.unsafe(nil)); end
+
+  # Returns the current selection.
+  #
+  # source://bindata//lib/bindata/choice.rb#80
+  def selection; end
+
+  def snapshot(*args); end
+
+  private
+
+  # source://bindata//lib/bindata/choice.rb#108
+  def current_choice; end
+
+  # source://bindata//lib/bindata/choice.rb#113
+  def instantiate_choice(selection); end
+end
+
+# source://bindata//lib/bindata/choice.rb#124
+class BinData::ChoiceArgProcessor < ::BinData::BaseArgProcessor
+  # source://bindata//lib/bindata/choice.rb#125
+  def sanitize_parameters!(obj_class, params); end
+
+  private
+
+  # source://bindata//lib/bindata/choice.rb#138
+  def choices_as_hash(choices); end
+
+  # source://bindata//lib/bindata/choice.rb#154
+  def ensure_valid_keys(choices); end
+
+  # source://bindata//lib/bindata/choice.rb#146
+  def key_array_by_index(array); end
+end
+
+# Logic for the :copy_on_change parameter
+#
+# source://bindata//lib/bindata/choice.rb#165
+module BinData::CopyOnChangePlugin
+  # source://bindata//lib/bindata/choice.rb#172
+  def copy_previous_value(obj); end
+
+  # source://bindata//lib/bindata/choice.rb#166
+  def current_choice; end
+
+  # source://bindata//lib/bindata/choice.rb#179
+  def get_previous_choice(selection); end
+
+  # source://bindata//lib/bindata/choice.rb#185
+  def remember_current_selection(selection); end
+end
+
+# Counts the number of bytes remaining in the input stream from the current
+# position to the end of the stream.  This only makes sense for seekable
+# streams.
+#
+#   require 'bindata'
+#
+#   class A < BinData::Record
+#     count_bytes_remaining :bytes_remaining
+#     string :all_data, read_length: :bytes_remaining
+#   end
+#
+#   obj = A.read("abcdefghij")
+#   obj.all_data #=> "abcdefghij"
+#
+# source://bindata//lib/bindata/count_bytes_remaining.rb#19
+class BinData::CountBytesRemaining < ::BinData::BasePrimitive
+  private
+
+  # source://bindata//lib/bindata/count_bytes_remaining.rb#26
+  def read_and_return_value(io); end
+
+  # source://bindata//lib/bindata/count_bytes_remaining.rb#30
+  def sensible_default; end
+
+  # source://bindata//lib/bindata/count_bytes_remaining.rb#22
+  def value_to_binary_string(val); end
+end
+
+# BinData classes that are part of the DSL must be extended by this.
+#
+# source://bindata//lib/bindata/dsl.rb#37
+module BinData::DSLMixin
+  # source://bindata//lib/bindata/dsl.rb#38
+  def dsl_parser(parser_type = T.unsafe(nil)); end
+
+  # source://bindata//lib/bindata/dsl.rb#45
+  def method_missing(symbol, *args, &block); end
+
+  # Assert object is not an array or string.
+  #
+  # source://bindata//lib/bindata/dsl.rb#50
+  def to_ary; end
+
+  # source://bindata//lib/bindata/dsl.rb#51
+  def to_str; end
+end
+
+# Handles the :big_and_little endian option.
+# This option creates two subclasses, each handling
+# :big or :little endian.
+#
+# source://bindata//lib/bindata/dsl.rb#256
+class BinData::DSLMixin::DSLBigAndLittleEndianHandler
+  class << self
+    # source://bindata//lib/bindata/dsl.rb#324
+    def class_with_endian(class_name, endian); end
+
+    # source://bindata//lib/bindata/dsl.rb#270
+    def create_subclasses_with_endian(bnl_class); end
+
+    # source://bindata//lib/bindata/dsl.rb#291
+    def delegate_field_creation(bnl_class); end
+
+    # source://bindata//lib/bindata/dsl.rb#304
+    def fixup_subclass_hierarchy(bnl_class); end
+
+    # source://bindata//lib/bindata/dsl.rb#258
+    def handle(bnl_class); end
+
+    # source://bindata//lib/bindata/dsl.rb#266
+    def make_class_abstract(bnl_class); end
+
+    # source://bindata//lib/bindata/dsl.rb#332
+    def obj_attribute(obj, attr); end
+
+    # source://bindata//lib/bindata/dsl.rb#275
+    def override_new_in_class(bnl_class); end
+  end
+end
+
+# Extracts the details from a field declaration.
+#
+# source://bindata//lib/bindata/dsl.rb#339
+class BinData::DSLMixin::DSLFieldParser
+  # @return [DSLFieldParser] a new instance of DSLFieldParser
+  #
+  # source://bindata//lib/bindata/dsl.rb#340
+  def initialize(hints, symbol, *args, &block); end
+
+  # Returns the value of attribute name.
+  #
+  # source://bindata//lib/bindata/dsl.rb#347
+  def name; end
+
+  # source://bindata//lib/bindata/dsl.rb#349
+  def name_from_field_declaration(args); end
+
+  # Returns the value of attribute params.
+  #
+  # source://bindata//lib/bindata/dsl.rb#347
+  def params; end
+
+  # source://bindata//lib/bindata/dsl.rb#368
+  def params_from_args(args); end
+
+  # source://bindata//lib/bindata/dsl.rb#375
+  def params_from_block(&block); end
+
+  # source://bindata//lib/bindata/dsl.rb#358
+  def params_from_field_declaration(args, &block); end
+
+  # Returns the value of attribute type.
+  #
+  # source://bindata//lib/bindata/dsl.rb#347
+  def type; end
+end
+
+# Validates a field defined in a DSLMixin.
+#
+# source://bindata//lib/bindata/dsl.rb#400
+class BinData::DSLMixin::DSLFieldValidator
+  # @return [DSLFieldValidator] a new instance of DSLFieldValidator
+  #
+  # source://bindata//lib/bindata/dsl.rb#401
+  def initialize(the_class, parser); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/dsl.rb#450
+  def all_or_none_names_failed?(name); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/dsl.rb#465
+  def duplicate_name?(name); end
+
+  # source://bindata//lib/bindata/dsl.rb#422
+  def ensure_valid_name(name); end
+
+  # source://bindata//lib/bindata/dsl.rb#477
+  def fields; end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/dsl.rb#461
+  def malformed_name?(name); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/dsl.rb#446
+  def must_have_a_name_failed?(name); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/dsl.rb#442
+  def must_not_have_a_name_failed?(name); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/dsl.rb#473
+  def name_is_reserved?(name); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/dsl.rb#469
+  def name_shadows_method?(name); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/dsl.rb#481
+  def option?(opt); end
+
+  # source://bindata//lib/bindata/dsl.rb#406
+  def validate_field(name); end
+end
+
+# A DSLParser parses and accumulates field definitions of the form
+#
+#   type name, params
+#
+# where:
+#   * +type+ is the under_scored name of a registered type
+#   * +name+ is the (possible optional) name of the field
+#   * +params+ is a hash containing any parameters
+#
+# source://bindata//lib/bindata/dsl.rb#62
+class BinData::DSLMixin::DSLParser
+  # @return [DSLParser] a new instance of DSLParser
+  #
+  # source://bindata//lib/bindata/dsl.rb#63
+  def initialize(the_class, parser_type); end
+
+  # source://bindata//lib/bindata/dsl.rb#113
+  def dsl_params; end
+
+  # source://bindata//lib/bindata/dsl.rb#74
+  def endian(endian = T.unsafe(nil)); end
+
+  # source://bindata//lib/bindata/dsl.rb#109
+  def fields; end
+
+  # source://bindata//lib/bindata/dsl.rb#98
+  def hide(*args); end
+
+  # source://bindata//lib/bindata/dsl.rb#118
+  def method_missing(*args, &block); end
+
+  # Returns the value of attribute parser_type.
+  #
+  # source://bindata//lib/bindata/dsl.rb#72
+  def parser_type; end
+
+  # source://bindata//lib/bindata/dsl.rb#83
+  def search_prefix(*args); end
+
+  private
+
+  # source://bindata//lib/bindata/dsl.rb#191
+  def append_field(type, name, params); end
+
+  # @raise [exception]
+  #
+  # source://bindata//lib/bindata/dsl.rb#207
+  def dsl_raise(exception, msg); end
+
+  # source://bindata//lib/bindata/dsl.rb#143
+  def ensure_hints; end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/dsl.rb#177
+  def fields?; end
+
+  # source://bindata//lib/bindata/dsl.rb#148
+  def hints; end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/dsl.rb#139
+  def option?(opt); end
+
+  # source://bindata//lib/bindata/dsl.rb#197
+  def parent_attribute(attr, default = T.unsafe(nil)); end
+
+  # source://bindata//lib/bindata/dsl.rb#173
+  def parent_fields; end
+
+  # source://bindata//lib/bindata/dsl.rb#181
+  def parse_and_append_field(*args, &block); end
+
+  # source://bindata//lib/bindata/dsl.rb#126
+  def parser_abilities; end
+
+  # source://bindata//lib/bindata/dsl.rb#152
+  def set_endian(endian); end
+
+  # source://bindata//lib/bindata/dsl.rb#225
+  def to_choice_params(key); end
+
+  # source://bindata//lib/bindata/dsl.rb#214
+  def to_object_params(key); end
+
+  # source://bindata//lib/bindata/dsl.rb#237
+  def to_struct_params(*_); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/dsl.rb#169
+  def valid_endian?(endian); end
+end
+
+# BinData declarations are evaluated in a single pass.
+# However, some binary formats require multi pass processing.  A common
+# reason is seeking backwards in the input stream.
+#
+# DelayedIO supports multi pass processing.  It works by ignoring the normal
+# #read or #write calls.  The user must explicitly call the #read_now! or
+# #write_now! methods to process an additional pass.  This additional pass
+# must specify the abs_offset of the I/O operation.
+#
+#   require 'bindata'
+#
+#   obj = BinData::DelayedIO.new(read_abs_offset: 3, type: :uint16be)
+#   obj.read("\x00\x00\x00\x11\x12")
+#   obj #=> 0
+#
+#   obj.read_now!
+#   obj #=> 0x1112
+#
+#   - OR -
+#
+#   obj.read("\x00\x00\x00\x11\x12") { obj.read_now! } #=> 0x1122
+#
+#   obj.to_binary_s { obj.write_now! } #=> "\x00\x00\x00\x11\x12"
+#
+# You can use the +auto_call_delayed_io+ keyword to cause #read and #write to
+# automatically perform the extra passes.
+#
+#   class ReversePascalString < BinData::Record
+#     auto_call_delayed_io
+#
+#     delayed_io :str, read_abs_offset: 0 do
+#       string read_length: :len
+#     end
+#     count_bytes_remaining :total_size
+#     skip to_abs_offset: -> { total_size - 1 }
+#     uint8  :len, value: -> { str.length }
+#   end
+#
+#   s = ReversePascalString.read("hello\x05")
+#   s.to_binary_s #=> "hello\x05"
+#
+#
+# == Parameters
+#
+# Parameters may be provided at initialisation to control the behaviour of
+# an object.  These params are:
+#
+# <tt>:read_abs_offset</tt>::   The abs_offset to start reading at.
+# <tt>:type</tt>::              The single type inside the delayed io.  Use
+#                               a struct if multiple fields are required.
+#
+# source://bindata//lib/bindata/delayed_io.rb#55
+class BinData::DelayedIO < ::BinData::Base
+  extend ::BinData::DSLMixin
+
+  # source://bindata//lib/bindata/delayed_io.rb#94
+  def abs_offset; end
+
+  # Sets the +abs_offset+ to use when writing this object.
+  #
+  # source://bindata//lib/bindata/delayed_io.rb#99
+  def abs_offset=(offset); end
+
+  # source://bindata//lib/bindata/delayed_io.rb#74
+  def assign(val); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/delayed_io.rb#70
+  def clear?; end
+
+  # source://bindata//lib/bindata/delayed_io.rb#115
+  def do_num_bytes; end
+
+  # source://bindata//lib/bindata/delayed_io.rb#107
+  def do_read(io); end
+
+  # source://bindata//lib/bindata/delayed_io.rb#111
+  def do_write(io); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/delayed_io.rb#119
+  def include_obj?; end
+
+  # source://bindata//lib/bindata/delayed_io.rb#63
+  def initialize_instance; end
+
+  # source://bindata//lib/bindata/delayed_io.rb#90
+  def method_missing(symbol, *args, &block); end
+
+  # source://bindata//lib/bindata/delayed_io.rb#82
+  def num_bytes; end
+
+  # DelayedIO objects aren't read when #read is called.
+  # The reading is delayed until this method is called.
+  #
+  # @raise [IOError]
+  #
+  # source://bindata//lib/bindata/delayed_io.rb#125
+  def read_now!; end
+
+  # source://bindata//lib/bindata/delayed_io.rb#103
+  def rel_offset; end
+
+  # source://bindata//lib/bindata/delayed_io.rb#78
+  def snapshot; end
+
+  # DelayedIO objects aren't written when #write is called.
+  # The writing is delayed until this method is called.
+  #
+  # @raise [IOError]
+  #
+  # source://bindata//lib/bindata/delayed_io.rb#137
+  def write_now!; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/delayed_io.rb#86
+  def respond_to_missing?(symbol, include_all = T.unsafe(nil)); end
+end
+
+# source://bindata//lib/bindata/delayed_io.rb#146
+class BinData::DelayedIoArgProcessor < ::BinData::BaseArgProcessor
+  include ::BinData::MultiFieldArgSeparator
+
+  # source://bindata//lib/bindata/delayed_io.rb#149
+  def sanitize_parameters!(obj_class, params); end
+end
+
+# Double precision floating point number in big endian format
+#
+# source://bindata//lib/bindata/float.rb#80
+class BinData::DoubleBe < ::BinData::BasePrimitive
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+# Double precision floating point number in little endian format
+#
+# source://bindata//lib/bindata/float.rb#75
+class BinData::DoubleLe < ::BinData::BasePrimitive
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+# Single precision floating point number in big endian format
+#
+# source://bindata//lib/bindata/float.rb#70
+class BinData::FloatBe < ::BinData::BasePrimitive
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+# Single precision floating point number in little endian format
+#
+# source://bindata//lib/bindata/float.rb#65
+class BinData::FloatLe < ::BinData::BasePrimitive
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+# Defines a number of classes that contain a floating point number.
+# The float is defined by precision and endian.
+#
+# source://bindata//lib/bindata/float.rb#7
+module BinData::FloatingPoint
+  class << self
+    # source://bindata//lib/bindata/float.rb#44
+    def create_num_bytes_code(precision); end
+
+    # source://bindata//lib/bindata/float.rb#48
+    def create_read_code(precision, endian); end
+
+    # source://bindata//lib/bindata/float.rb#55
+    def create_to_binary_s_code(precision, endian); end
+
+    # source://bindata//lib/bindata/float.rb#21
+    def define_methods(float_class, precision, endian); end
+  end
+end
+
+# All methods provided by the framework are to be implemented or overridden
+# by subclasses of BinData::Base.
+#
+# source://bindata//lib/bindata/framework.rb#7
+module BinData::Framework
+  # Assigns the value of +val+ to this data object.  Note that +val+ must
+  # always be deep copied to ensure no aliasing problems can occur.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://bindata//lib/bindata/framework.rb#27
+  def assign(val); end
+
+  # Is this object aligned on non-byte boundaries?
+  #
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/framework.rb#49
+  def bit_aligned?; end
+
+  # Returns true if the object has not been changed since creation.
+  #
+  # @raise [NotImplementedError]
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/framework.rb#21
+  def clear?; end
+
+  # Returns the debug name of +child+.  This only needs to be implemented
+  # by objects that contain child objects.
+  #
+  # source://bindata//lib/bindata/framework.rb#38
+  def debug_name_of(child); end
+
+  # Returns the offset of +child+.  This only needs to be implemented
+  # by objects that contain child objects.
+  #
+  # source://bindata//lib/bindata/framework.rb#44
+  def offset_of(child); end
+
+  # Returns a snapshot of this data object.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://bindata//lib/bindata/framework.rb#32
+  def snapshot; end
+
+  protected
+
+  # Returns the number of bytes it will take to write this data.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://bindata//lib/bindata/framework.rb#64
+  def do_num_bytes; end
+
+  # Reads the data for this data object from +io+.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://bindata//lib/bindata/framework.rb#54
+  def do_read(io); end
+
+  # Writes the value for this data to +io+.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://bindata//lib/bindata/framework.rb#59
+  def do_write(io); end
+
+  # Initializes the state of the object.  All instance variables that
+  # are used by the object must be initialized here.
+  #
+  # source://bindata//lib/bindata/framework.rb#10
+  def initialize_instance; end
+
+  # Initialises state that is shared by objects with the same parameters.
+  #
+  # This should only be used when optimising for performance.  Instance
+  # variables set here, and changes to the singleton class will be shared
+  # between all objects that are initialized with the same parameters.
+  # This method is called only once for a particular set of parameters.
+  #
+  # source://bindata//lib/bindata/framework.rb#18
+  def initialize_shared_instance; end
+end
+
+# A wrapper around an IO object.  The wrapper provides a consistent
+# interface for BinData objects to use when accessing the IO.
+#
+# source://bindata//lib/bindata/io.rb#6
+module BinData::IO
+  class << self
+    # Creates a StringIO around +str+.
+    #
+    # source://bindata//lib/bindata/io.rb#9
+    def create_string_io(str = T.unsafe(nil)); end
+  end
+end
+
+# API used to access the raw data stream.
+#
+# source://bindata//lib/bindata/io.rb#315
+class BinData::IO::RawIO
+  # @return [RawIO] a new instance of RawIO
+  #
+  # source://bindata//lib/bindata/io.rb#316
+  def initialize(io); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/io.rb#327
+  def is_seekable?(io); end
+
+  # source://bindata//lib/bindata/io.rb#337
+  def num_bytes_remaining; end
+
+  # source://bindata//lib/bindata/io.rb#346
+  def offset; end
+
+  # source://bindata//lib/bindata/io.rb#361
+  def read(n); end
+
+  # source://bindata//lib/bindata/io.rb#356
+  def seek_abs(n); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/io.rb#333
+  def seekable?; end
+
+  # @raise [IOError]
+  #
+  # source://bindata//lib/bindata/io.rb#350
+  def skip(n); end
+
+  # source://bindata//lib/bindata/io.rb#365
+  def write(data); end
+end
+
+# Create a new IO Read wrapper around +io+.  +io+ must provide #read,
+# #pos if reading the current stream position and #seek if setting the
+# current stream position.  If +io+ is a string it will be automatically
+# wrapped in an StringIO object.
+#
+# The IO can handle bitstreams in either big or little endian format.
+#
+#      M  byte1   L      M  byte2   L
+#      S 76543210 S      S fedcba98 S
+#      B          B      B          B
+#
+# In big endian format:
+#   readbits(6), readbits(5) #=> [765432, 10fed]
+#
+# In little endian format:
+#   readbits(6), readbits(5) #=> [543210, a9876]
+#
+# source://bindata//lib/bindata/io.rb#31
+class BinData::IO::Read
+  # @return [Read] a new instance of Read
+  #
+  # source://bindata//lib/bindata/io.rb#32
+  def initialize(io); end
+
+  # The number of bytes remaining in the io steam.
+  #
+  # source://bindata//lib/bindata/io.rb#68
+  def num_bytes_remaining; end
+
+  # Reads all remaining bytes from the stream.
+  #
+  # source://bindata//lib/bindata/io.rb#95
+  def read_all_bytes; end
+
+  # Reads exactly +nbits+ bits from the stream. +endian+ specifies whether
+  # the bits are stored in +:big+ or +:little+ endian format.
+  #
+  # source://bindata//lib/bindata/io.rb#102
+  def readbits(nbits, endian); end
+
+  # Reads exactly +n+ bytes from +io+.
+  #
+  # If the data read is nil an EOFError is raised.
+  #
+  # If the data read is too short an IOError is raised.
+  #
+  # source://bindata//lib/bindata/io.rb#89
+  def readbytes(n); end
+
+  # Discards any read bits so the stream becomes aligned at the
+  # next byte boundary.
+  #
+  # source://bindata//lib/bindata/io.rb#118
+  def reset_read_bits; end
+
+  # Seek to an absolute offset within the io stream.
+  #
+  # source://bindata//lib/bindata/io.rb#79
+  def seek_to_abs_offset(n); end
+
+  # Seek +n+ bytes from the current position in the io stream.
+  #
+  # source://bindata//lib/bindata/io.rb#73
+  def skipbytes(n); end
+
+  # Allow transforming data in the input stream.
+  # See +BinData::Buffer+ as an example.
+  #
+  # +io+ must be an instance of +Transform+.
+  #
+  # yields +self+ and +io+ to the given block
+  #
+  # source://bindata//lib/bindata/io.rb#56
+  def transform(io); end
+
+  private
+
+  # source://bindata//lib/bindata/io.rb#147
+  def accumulate_big_endian_bits; end
+
+  # source://bindata//lib/bindata/io.rb#165
+  def accumulate_little_endian_bits; end
+
+  # source://bindata//lib/bindata/io.rb#171
+  def mask(nbits); end
+
+  # source://bindata//lib/bindata/io.rb#126
+  def read(n = T.unsafe(nil)); end
+
+  # source://bindata//lib/bindata/io.rb#135
+  def read_big_endian_bits(nbits); end
+
+  # source://bindata//lib/bindata/io.rb#153
+  def read_little_endian_bits(nbits); end
+end
+
+# An IO stream may be transformed before processing.
+# e.g. encoding, compression, buffered.
+#
+# Multiple transforms can be chained together.
+#
+# To create a new transform layer, subclass +Transform+.
+# Override the public methods +#read+ and +#write+ at a minimum.
+# Additionally the hook, +#before_transform+, +#after_read_transform+
+# and +#after_write_transform+ are available as well.
+#
+# IMPORTANT!  If your transform changes the size of the underlying
+# data stream (e.g. compression), then call
+# +::transform_changes_stream_length!+ in your subclass.
+#
+# source://bindata//lib/bindata/io.rb#383
+class BinData::IO::Transform
+  # @return [Transform] a new instance of Transform
+  #
+  # source://bindata//lib/bindata/io.rb#392
+  def initialize; end
+
+  # Flushes the input stream.
+  #
+  # Called after the final read operation.
+  #
+  # source://bindata//lib/bindata/io.rb#404
+  def after_read_transform; end
+
+  # Flushes the output stream.
+  #
+  # Called after the final write operation.
+  #
+  # source://bindata//lib/bindata/io.rb#409
+  def after_write_transform; end
+
+  # Initialises this transform.
+  #
+  # Called before any IO operations.
+  #
+  # source://bindata//lib/bindata/io.rb#399
+  def before_transform; end
+
+  # How many bytes are available for reading?
+  #
+  # source://bindata//lib/bindata/io.rb#426
+  def num_bytes_remaining; end
+
+  # The current offset within the stream.
+  #
+  # source://bindata//lib/bindata/io.rb#431
+  def offset; end
+
+  # Prepends this transform to the given +chain+.
+  #
+  # Returns self (the new head of chain).
+  #
+  # source://bindata//lib/bindata/io.rb#414
+  def prepend_to_chain(chain); end
+
+  # Reads +n+ bytes from the stream.
+  #
+  # source://bindata//lib/bindata/io.rb#446
+  def read(n); end
+
+  # Seeks to the given absolute position.
+  #
+  # source://bindata//lib/bindata/io.rb#441
+  def seek_abs(n); end
+
+  # Is the IO seekable?
+  #
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/io.rb#421
+  def seekable?; end
+
+  # Skips forward +n+ bytes in the input stream.
+  #
+  # source://bindata//lib/bindata/io.rb#436
+  def skip(n); end
+
+  # Writes +data+ to the stream.
+  #
+  # source://bindata//lib/bindata/io.rb#451
+  def write(data); end
+
+  private
+
+  # source://bindata//lib/bindata/io.rb#466
+  def chain_num_bytes_remaining; end
+
+  # source://bindata//lib/bindata/io.rb#470
+  def chain_offset; end
+
+  # source://bindata//lib/bindata/io.rb#482
+  def chain_read(n); end
+
+  # source://bindata//lib/bindata/io.rb#478
+  def chain_seek_abs(n); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/io.rb#462
+  def chain_seekable?; end
+
+  # source://bindata//lib/bindata/io.rb#474
+  def chain_skip(n); end
+
+  # source://bindata//lib/bindata/io.rb#486
+  def chain_write(data); end
+
+  # source://bindata//lib/bindata/io.rb#458
+  def create_empty_binary_string; end
+
+  class << self
+    # Indicates that this transform changes the length of the
+    # underlying data. e.g. performs compression or error correction
+    #
+    # source://bindata//lib/bindata/io.rb#387
+    def transform_changes_stream_length!; end
+  end
+end
+
+# A module to be prepended to +RawIO+ or +Transform+ when the data
+# stream is not seekable.  This is either due to underlying stream
+# being unseekable or the transform changes the number of bytes.
+#
+# source://bindata//lib/bindata/io.rb#494
+module BinData::IO::UnSeekableIO
+  # @raise [IOError]
+  #
+  # source://bindata//lib/bindata/io.rb#499
+  def num_bytes_remaining; end
+
+  # source://bindata//lib/bindata/io.rb#514
+  def seek_abs(n); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/io.rb#495
+  def seekable?; end
+
+  # @raise [IOError]
+  #
+  # source://bindata//lib/bindata/io.rb#503
+  def skip(n); end
+end
+
+# Create a new IO Write wrapper around +io+.  +io+ must provide #write.
+# If +io+ is a string it will be automatically wrapped in an StringIO
+# object.
+#
+# The IO can handle bitstreams in either big or little endian format.
+#
+# See IO::Read for more information.
+#
+# source://bindata//lib/bindata/io.rb#183
+class BinData::IO::Write
+  # @return [Write] a new instance of Write
+  #
+  # source://bindata//lib/bindata/io.rb#184
+  def initialize(io); end
+
+  # To be called after all +writebits+ have been applied.
+  #
+  # source://bindata//lib/bindata/io.rb#251
+  def flush; end
+
+  # To be called after all +writebits+ have been applied.
+  #
+  # source://bindata//lib/bindata/io.rb#251
+  def flushbits; end
+
+  # Seek to an absolute offset within the io stream.
+  #
+  # @raise [IOError]
+  #
+  # source://bindata//lib/bindata/io.rb#219
+  def seek_to_abs_offset(n); end
+
+  # Allow transforming data in the output stream.
+  # See +BinData::Buffer+ as an example.
+  #
+  # +io+ must be an instance of +Transform+.
+  #
+  # yields +self+ and +io+ to the given block
+  #
+  # source://bindata//lib/bindata/io.rb#207
+  def transform(io); end
+
+  # Writes +nbits+ bits from +val+ to the stream. +endian+ specifies whether
+  # the bits are to be stored in +:big+ or +:little+ endian format.
+  #
+  # source://bindata//lib/bindata/io.rb#234
+  def writebits(val, nbits, endian); end
+
+  # Writes the given string of bytes to the io stream.
+  #
+  # source://bindata//lib/bindata/io.rb#227
+  def writebytes(str); end
+
+  private
+
+  # source://bindata//lib/bindata/io.rb#309
+  def mask(nbits); end
+
+  # source://bindata//lib/bindata/io.rb#263
+  def write(data); end
+
+  # source://bindata//lib/bindata/io.rb#267
+  def write_big_endian_bits(val, nbits); end
+
+  # source://bindata//lib/bindata/io.rb#288
+  def write_little_endian_bits(val, nbits); end
+end
+
+# Defines a number of classes that contain an integer.  The integer
+# is defined by endian, signedness and number of bytes.
+#
+# source://bindata//lib/bindata/int.rb#8
+module BinData::Int
+  class << self
+    # source://bindata//lib/bindata/int.rb#12
+    def define_class(name, nbits, endian, signed); end
+
+    # source://bindata//lib/bindata/int.rb#26
+    def define_methods(int_class, nbits, endian, signed); end
+
+    private
+
+    # source://bindata//lib/bindata/int.rb#150
+    def bits_per_word(nbits); end
+
+    # source://bindata//lib/bindata/int.rb#60
+    def create_clamp_code(nbits, signed); end
+
+    # source://bindata//lib/bindata/int.rb#142
+    def create_int2uint_code(nbits); end
+
+    # source://bindata//lib/bindata/int.rb#82
+    def create_raw_read_code(nbits, endian, signed); end
+
+    # source://bindata//lib/bindata/int.rb#101
+    def create_read_assemble_code(nbits, endian); end
+
+    # source://bindata//lib/bindata/int.rb#72
+    def create_read_code(nbits, endian, signed); end
+
+    # source://bindata//lib/bindata/int.rb#94
+    def create_read_unpack_code(nbits, endian, signed); end
+
+    # source://bindata//lib/bindata/int.rb#115
+    def create_to_binary_s_code(nbits, endian, signed); end
+
+    # source://bindata//lib/bindata/int.rb#146
+    def create_uint2int_code(nbits); end
+
+    # @return [Boolean]
+    #
+    # source://bindata//lib/bindata/int.rb#172
+    def need_signed_conversion_code?(nbits, signed); end
+
+    # source://bindata//lib/bindata/int.rb#157
+    def pack_directive(nbits, endian, signed); end
+
+    # source://bindata//lib/bindata/int.rb#130
+    def val_as_packed_words(nbits, endian); end
+  end
+end
+
+# Signed 1 byte integer.
+#
+# source://bindata//lib/bindata/int.rb#185
+class BinData::Int8 < ::BinData::BasePrimitive
+  def assign(val); end
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+# Create classes on demand
+#
+# source://bindata//lib/bindata/int.rb#190
+module BinData::IntFactory
+  # source://bindata//lib/bindata/int.rb#191
+  def const_missing(name); end
+end
+
+# A LazyEvaluator is bound to a data object.  The evaluator will evaluate
+# lambdas in the context of this data object.  These lambdas
+# are those that are passed to data objects as parameters, e.g.:
+#
+#    BinData::String.new(value: -> { %w(a test message).join(" ") })
+#
+# As a shortcut, :foo is the equivalent of lambda { foo }.
+#
+# When evaluating lambdas, unknown methods are resolved in the context of the
+# parent of the bound data object.  Resolution is attempted firstly as keys
+# in #parameters, and secondly as methods in this parent.  This
+# resolution propagates up the chain of parent data objects.
+#
+# An evaluation will recurse until it returns a result that is not
+# a lambda or a symbol.
+#
+# This resolution process makes the lambda easier to read as we just write
+# <tt>field</tt> instead of <tt>obj.field</tt>.
+#
+# source://bindata//lib/bindata/lazy.rb#20
+class BinData::LazyEvaluator
+  # Creates a new evaluator.  All lazy evaluation is performed in the
+  # context of +obj+.
+  #
+  # @return [LazyEvaluator] a new instance of LazyEvaluator
+  #
+  # source://bindata//lib/bindata/lazy.rb#24
+  def initialize(obj); end
+
+  # Returns the index of this data object inside it's nearest container
+  # array.
+  #
+  # @raise [NoMethodError]
+  #
+  # source://bindata//lib/bindata/lazy.rb#50
+  def index; end
+
+  # source://bindata//lib/bindata/lazy.rb#28
+  def lazy_eval(val, overrides = T.unsafe(nil)); end
+
+  # source://bindata//lib/bindata/lazy.rb#65
+  def method_missing(symbol, *args); end
+
+  # Returns a LazyEvaluator for the parent of this data object.
+  #
+  # source://bindata//lib/bindata/lazy.rb#40
+  def parent; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/lazy.rb#105
+  def callable?(obj); end
+
+  # source://bindata//lib/bindata/lazy.rb#78
+  def eval_symbol_in_parent_context(symbol, args); end
+
+  # source://bindata//lib/bindata/lazy.rb#95
+  def recursively_eval(val, args); end
+
+  # source://bindata//lib/bindata/lazy.rb#83
+  def resolve_symbol_in_parent_context(symbol, args); end
+end
+
+# Extracts args for Records and Buffers.
+#
+# Foo.new(bar: "baz) is ambiguous as to whether :bar is a value or parameter.
+#
+# BaseArgExtractor always assumes :bar is parameter.  This extractor correctly
+# identifies it as value or parameter.
+#
+# source://bindata//lib/bindata/dsl.rb#8
+module BinData::MultiFieldArgSeparator
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/dsl.rb#28
+  def field_names_in_parameters?(obj_class, parameters); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/dsl.rb#20
+  def parameters_is_value?(obj_class, value, parameters); end
+
+  # source://bindata//lib/bindata/dsl.rb#9
+  def separate_args(obj_class, obj_args); end
+end
+
+# A Primitive is a declarative way to define a new BinData data type.
+# The data type must contain a primitive value only, i.e numbers or strings.
+# For new data types that contain multiple values see BinData::Record.
+#
+# To define a new data type, set fields as if for Record and add a
+# #get and #set method to extract / convert the data between the fields
+# and the #value of the object.
+#
+#    require 'bindata'
+#
+#    class PascalString < BinData::Primitive
+#      uint8  :len,  value: -> { data.length }
+#      string :data, read_length: :len
+#
+#      def get
+#        self.data
+#      end
+#
+#      def set(v)
+#        self.data = v
+#      end
+#    end
+#
+#    ps = PascalString.new(initial_value: "hello")
+#    ps.to_binary_s #=> "\005hello"
+#    ps.read("\003abcde")
+#    ps #=> "abc"
+#
+#    # Unsigned 24 bit big endian integer
+#    class Uint24be < BinData::Primitive
+#      uint8 :byte1
+#      uint8 :byte2
+#      uint8 :byte3
+#
+#      def get
+#        (self.byte1 << 16) | (self.byte2 << 8) | self.byte3
+#      end
+#
+#      def set(v)
+#        v = 0 if v < 0
+#        v = 0xffffff if v > 0xffffff
+#
+#        self.byte1 = (v >> 16) & 0xff
+#        self.byte2 = (v >>  8) & 0xff
+#        self.byte3 =  v        & 0xff
+#      end
+#    end
+#
+#    u24 = Uint24be.new
+#    u24.read("\x12\x34\x56")
+#    "0x%x" % u24 #=> 0x123456
+#
+# == Parameters
+#
+# Primitive objects accept all the parameters that BinData::BasePrimitive do.
+#
+# source://bindata//lib/bindata/primitive.rb#62
+class BinData::Primitive < ::BinData::BasePrimitive
+  extend ::BinData::DSLMixin
+
+  # source://bindata//lib/bindata/primitive.rb#88
+  def assign(val); end
+
+  # source://bindata//lib/bindata/primitive.rb#94
+  def debug_name_of(child); end
+
+  # source://bindata//lib/bindata/primitive.rb#103
+  def do_num_bytes; end
+
+  # source://bindata//lib/bindata/primitive.rb#98
+  def do_write(io); end
+
+  # source://bindata//lib/bindata/primitive.rb#71
+  def initialize_instance; end
+
+  # source://bindata//lib/bindata/primitive.rb#80
+  def method_missing(symbol, *args, &block); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/primitive.rb#76
+  def respond_to?(symbol, include_private = T.unsafe(nil)); end
+
+  private
+
+  # Extracts the value for this data object from the fields of the
+  # internal struct.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://bindata//lib/bindata/primitive.rb#125
+  def get; end
+
+  # source://bindata//lib/bindata/primitive.rb#115
+  def read_and_return_value(io); end
+
+  # source://bindata//lib/bindata/primitive.rb#111
+  def sensible_default; end
+
+  # Sets the fields of the internal struct to represent +v+.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://bindata//lib/bindata/primitive.rb#130
+  def set(v); end
+
+  class << self
+    # source://bindata//lib/bindata/alignment.rb#84
+    def bit_aligned; end
+  end
+end
+
+# source://bindata//lib/bindata/primitive.rb#138
+class BinData::PrimitiveArgProcessor < ::BinData::BaseArgProcessor
+  # source://bindata//lib/bindata/primitive.rb#139
+  def sanitize_parameters!(obj_class, params); end
+end
+
+# A Record is a declarative wrapper around Struct.
+#
+# See +Struct+ for more info.
+#
+# source://bindata//lib/bindata/record.rb#8
+class BinData::Record < ::BinData::Struct
+  extend ::BinData::DSLMixin
+
+  class << self
+    # source://bindata//lib/bindata/base.rb#53
+    def inherited(subclass); end
+  end
+end
+
+# source://bindata//lib/bindata/record.rb#16
+class BinData::RecordArgProcessor < ::BinData::StructArgProcessor
+  include ::BinData::MultiFieldArgSeparator
+
+  # source://bindata//lib/bindata/record.rb#19
+  def sanitize_parameters!(obj_class, params); end
+end
+
+# == Parameters
+#
+# Parameters may be provided at initialisation to control the behaviour of
+# an object.  These parameters are:
+#
+# <tt>:name</tt>:: The name that this object can be referred to may be
+#                  set explicitly.  This is only useful when dynamically
+#                  generating types.
+#                  <code><pre>
+#                    BinData::Struct.new(name: :my_struct, fields: ...)
+#                    array = BinData::Array.new(type: :my_struct)
+#                  </pre></code>
+#
+# source://bindata//lib/bindata/name.rb#14
+module BinData::RegisterNamePlugin
+  # source://bindata//lib/bindata/name.rb#21
+  def initialize_shared_instance; end
+
+  class << self
+    # source://bindata//lib/bindata/name.rb#16
+    def included(base); end
+  end
+end
+
+# A singleton registry of all registered classes.
+#
+# source://bindata//lib/bindata/registry.rb#133
+BinData::RegisteredClasses = T.let(T.unsafe(nil), BinData::Registry)
+
+# This registry contains a register of name -> class mappings.
+#
+# Numerics (integers and floating point numbers) have an endian property as
+# part of their name (e.g. int32be, float_le).
+#
+# Classes can be looked up based on their full name or an abbreviated +name+
+# with +hints+.
+#
+# There are two hints supported, :endian and :search_prefix.
+#
+#   #lookup("int32", { endian: :big }) will return Int32Be.
+#
+#   #lookup("my_type", { search_prefix: :ns }) will return NsMyType.
+#
+# Names are stored in under_score_style, not camelCase.
+#
+# source://bindata//lib/bindata/registry.rb#20
+class BinData::Registry
+  # @return [Registry] a new instance of Registry
+  #
+  # source://bindata//lib/bindata/registry.rb#21
+  def initialize; end
+
+  # source://bindata//lib/bindata/registry.rb#38
+  def lookup(name, hints = T.unsafe(nil)); end
+
+  # source://bindata//lib/bindata/registry.rb#25
+  def register(name, class_to_register); end
+
+  # Convert CamelCase +name+ to underscore style.
+  #
+  # source://bindata//lib/bindata/registry.rb#50
+  def underscore_name(name); end
+
+  # source://bindata//lib/bindata/registry.rb#34
+  def unregister(name); end
+
+  private
+
+  # source://bindata//lib/bindata/registry.rb#95
+  def name_with_endian(name, endian); end
+
+  # source://bindata//lib/bindata/registry.rb#86
+  def name_with_prefix(name, prefix); end
+
+  # source://bindata//lib/bindata/registry.rb#63
+  def normalize_name(name, hints); end
+
+  # source://bindata//lib/bindata/registry.rb#112
+  def register_dynamic_class(name); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/registry.rb#106
+  def registered?(name); end
+
+  # source://bindata//lib/bindata/registry.rb#123
+  def warn_if_name_is_already_registered(name, class_to_register); end
+end
+
+# Rest will consume the input stream from the current position to the end of
+# the stream.  This will mainly be useful for debugging and developing.
+#
+#   require 'bindata'
+#
+#   class A < BinData::Record
+#     string :a, read_length: 5
+#     rest   :rest
+#   end
+#
+#   obj = A.read("abcdefghij")
+#   obj.a #=> "abcde"
+#   obj.rest #=" "fghij"
+#
+# source://bindata//lib/bindata/rest.rb#19
+class BinData::Rest < ::BinData::BasePrimitive
+  private
+
+  # source://bindata//lib/bindata/rest.rb#26
+  def read_and_return_value(io); end
+
+  # source://bindata//lib/bindata/rest.rb#30
+  def sensible_default; end
+
+  # source://bindata//lib/bindata/rest.rb#22
+  def value_to_binary_string(val); end
+end
+
+# Resets the stream alignment to the next byte.  This is
+# only useful when using bit-based primitives.
+#
+#    class MyRec < BinData::Record
+#      bit4 :a
+#      resume_byte_alignment
+#      bit4 :b
+#    end
+#
+#    MyRec.read("\x12\x34") #=> {"a" => 1, "b" => 3}
+#
+# source://bindata//lib/bindata/alignment.rb#15
+class BinData::ResumeByteAlignment < ::BinData::Base
+  # source://bindata//lib/bindata/alignment.rb#17
+  def assign(val); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/alignment.rb#16
+  def clear?; end
+
+  # source://bindata//lib/bindata/alignment.rb#19
+  def do_num_bytes; end
+
+  # source://bindata//lib/bindata/alignment.rb#21
+  def do_read(io); end
+
+  # source://bindata//lib/bindata/alignment.rb#25
+  def do_write(io); end
+
+  # source://bindata//lib/bindata/alignment.rb#18
+  def snapshot; end
+end
+
+# ----------------------------------------------------------------------------
+#
+# source://bindata//lib/bindata/sanitize.rb#149
+class BinData::SanitizedBigEndian < ::BinData::SanitizedParameter
+  # source://bindata//lib/bindata/sanitize.rb#150
+  def endian; end
+end
+
+# ----------------------------------------------------------------------------
+#
+# source://bindata//lib/bindata/sanitize.rb#124
+class BinData::SanitizedChoices < ::BinData::SanitizedParameter
+  # @return [SanitizedChoices] a new instance of SanitizedChoices
+  #
+  # source://bindata//lib/bindata/sanitize.rb#125
+  def initialize(choices, hints); end
+
+  # source://bindata//lib/bindata/sanitize.rb#143
+  def [](key); end
+end
+
+# ----------------------------------------------------------------------------
+#
+# source://bindata//lib/bindata/sanitize.rb#46
+class BinData::SanitizedField < ::BinData::SanitizedParameter
+  # @return [SanitizedField] a new instance of SanitizedField
+  #
+  # source://bindata//lib/bindata/sanitize.rb#47
+  def initialize(name, field_type, field_params, hints); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/sanitize.rb#58
+  def has_parameter?(param); end
+
+  # source://bindata//lib/bindata/sanitize.rb#62
+  def instantiate(value = T.unsafe(nil), parent = T.unsafe(nil)); end
+
+  # Returns the value of attribute name.
+  #
+  # source://bindata//lib/bindata/sanitize.rb#52
+  def name; end
+
+  # source://bindata//lib/bindata/sanitize.rb#54
+  def name_as_sym; end
+
+  # Returns the value of attribute prototype.
+  #
+  # source://bindata//lib/bindata/sanitize.rb#52
+  def prototype; end
+end
+
+# ----------------------------------------------------------------------------
+#
+# source://bindata//lib/bindata/sanitize.rb#68
+class BinData::SanitizedFields < ::BinData::SanitizedParameter
+  include ::Enumerable
+
+  # @return [SanitizedFields] a new instance of SanitizedFields
+  #
+  # source://bindata//lib/bindata/sanitize.rb#71
+  def initialize(hints, base_fields = T.unsafe(nil)); end
+
+  # source://bindata//lib/bindata/sanitize.rb#86
+  def [](idx); end
+
+  # source://bindata//lib/bindata/sanitize.rb#76
+  def add_field(type, name, params); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/sanitize.rb#110
+  def all_field_names_blank?; end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/sanitize.rb#118
+  def any_field_has_parameter?(parameter); end
+
+  # source://bindata//lib/bindata/sanitize.rb#98
+  def each(&block); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/sanitize.rb#90
+  def empty?; end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/sanitize.rb#106
+  def field_name?(name); end
+
+  # source://bindata//lib/bindata/sanitize.rb#102
+  def field_names; end
+
+  # source://bindata//lib/bindata/sanitize.rb#94
+  def length; end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/sanitize.rb#114
+  def no_field_names_blank?; end
+
+  # source://bindata//lib/bindata/sanitize.rb#82
+  def raw_fields; end
+end
+
+# source://bindata//lib/bindata/sanitize.rb#155
+class BinData::SanitizedLittleEndian < ::BinData::SanitizedParameter
+  # source://bindata//lib/bindata/sanitize.rb#156
+  def endian; end
+end
+
+# Subclasses of this are sanitized
+#
+# source://bindata//lib/bindata/sanitize.rb#6
+class BinData::SanitizedParameter; end
+
+# BinData objects are instantiated with parameters to determine their
+# behaviour.  These parameters must be sanitized to ensure their values
+# are valid.  When instantiating many objects with identical parameters,
+# such as an array of records, there is much duplicated sanitizing.
+#
+# The purpose of the sanitizing code is to eliminate the duplicated
+# validation.
+#
+# SanitizedParameters is a hash-like collection of parameters.  Its purpose
+# is to recursively sanitize the parameters of an entire BinData object chain
+# at a single time.
+#
+# source://bindata//lib/bindata/sanitize.rb#174
+class BinData::SanitizedParameters < ::Hash
+  # @return [SanitizedParameters] a new instance of SanitizedParameters
+  #
+  # source://bindata//lib/bindata/sanitize.rb#188
+  def initialize(parameters, the_class, hints); end
+
+  # source://bindata//lib/bindata/sanitize.rb#280
+  def create_sanitized_params(params, the_class); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/sanitize.rb#206
+  def has_at_least_one_of?(*keys); end
+
+  def has_parameter?(_arg0); end
+
+  # source://bindata//lib/bindata/sanitize.rb#284
+  def hints; end
+
+  # def warn_renamed_parameter(old_key, new_key)
+  #      val = delete(old_key)
+  #      if val
+  #        self[new_key] = val
+  #        Kernel.warn ":#{old_key} has been renamed to :#{new_key} in #{@the_class}.  " \
+  #        "Using :#{old_key} is now deprecated and will be removed in the future"
+  #      end
+  #    end
+  #
+  # source://bindata//lib/bindata/sanitize.rb#230
+  def must_be_integer(*keys); end
+
+  # source://bindata//lib/bindata/sanitize.rb#244
+  def rename_parameter(old_key, new_key); end
+
+  # source://bindata//lib/bindata/sanitize.rb#274
+  def sanitize(key, &block); end
+
+  # source://bindata//lib/bindata/sanitize.rb#264
+  def sanitize_choices(key, &block); end
+
+  # source://bindata//lib/bindata/sanitize.rb#270
+  def sanitize_endian(key); end
+
+  # source://bindata//lib/bindata/sanitize.rb#256
+  def sanitize_fields(key, &block); end
+
+  # source://bindata//lib/bindata/sanitize.rb#250
+  def sanitize_object_prototype(key); end
+
+  # source://bindata//lib/bindata/sanitize.rb#214
+  def warn_replacement_parameter(bad_key, suggested_key); end
+
+  private
+
+  # source://bindata//lib/bindata/sanitize.rb#352
+  def create_sanitized_choices(choices); end
+
+  # source://bindata//lib/bindata/sanitize.rb#340
+  def create_sanitized_endian(endian); end
+
+  # source://bindata//lib/bindata/sanitize.rb#356
+  def create_sanitized_fields; end
+
+  # source://bindata//lib/bindata/sanitize.rb#360
+  def create_sanitized_object_prototype(obj_type, obj_params); end
+
+  # source://bindata//lib/bindata/sanitize.rb#320
+  def ensure_mandatory_parameters_exist; end
+
+  # source://bindata//lib/bindata/sanitize.rb#329
+  def ensure_mutual_exclusion_of_parameters; end
+
+  # source://bindata//lib/bindata/sanitize.rb#305
+  def ensure_no_nil_values; end
+
+  # source://bindata//lib/bindata/sanitize.rb#314
+  def merge_default_parameters!; end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/sanitize.rb#301
+  def needs_sanitizing?(key); end
+
+  # source://bindata//lib/bindata/sanitize.rb#291
+  def sanitize!; end
+
+  class << self
+    # source://bindata//lib/bindata/sanitize.rb#179
+    def sanitize(parameters, the_class); end
+  end
+end
+
+# Memoized constants
+#
+# source://bindata//lib/bindata/sanitize.rb#175
+BinData::SanitizedParameters::BIG_ENDIAN = T.let(T.unsafe(nil), BinData::SanitizedBigEndian)
+
+# source://bindata//lib/bindata/sanitize.rb#176
+BinData::SanitizedParameters::LITTLE_ENDIAN = T.let(T.unsafe(nil), BinData::SanitizedLittleEndian)
+
+# source://bindata//lib/bindata/sanitize.rb#8
+class BinData::SanitizedPrototype < ::BinData::SanitizedParameter
+  # @return [SanitizedPrototype] a new instance of SanitizedPrototype
+  #
+  # source://bindata//lib/bindata/sanitize.rb#9
+  def initialize(obj_type, obj_params, hints); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/sanitize.rb#30
+  def has_parameter?(param); end
+
+  # source://bindata//lib/bindata/sanitize.rb#38
+  def instantiate(value = T.unsafe(nil), parent = T.unsafe(nil)); end
+end
+
+# source://bindata//lib/bindata/bits.rb#15
+class BinData::Sbit < ::BinData::BasePrimitive
+  def assign(val); end
+  def bit_aligned?; end
+  def do_num_bytes; end
+  def do_write(io); end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+end
+
+# source://bindata//lib/bindata/bits.rb#15
+class BinData::SbitLe < ::BinData::BasePrimitive
+  def assign(val); end
+  def bit_aligned?; end
+  def do_num_bytes; end
+  def do_write(io); end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+end
+
+# A Section is a layer on top of a stream that transforms the underlying
+# data.  This allows BinData to process a stream that has multiple
+# encodings.  e.g.  Some data data is compressed or encrypted.
+#
+#   require 'bindata'
+#
+#   class XorTransform < BinData::IO::Transform
+#      def initialize(xor)
+#        super()
+#        @xor = xor
+#      end
+#
+#      def read(n)
+#        chain_read(n).bytes.map { |byte| (byte ^ @xor).chr }.join
+#      end
+#
+#      def write(data)
+#        chain_write(data.bytes.map { |byte| (byte ^ @xor).chr }.join)
+#      end
+#   end
+#
+#   obj = BinData::Section.new(transform: -> { XorTransform.new(0xff) },
+#                              type: [:string, read_length: 5])
+#
+#   obj.read("\x97\x9A\x93\x93\x90") #=> "hello"
+#
+#
+# == Parameters
+#
+# Parameters may be provided at initialisation to control the behaviour of
+# an object.  These params are:
+#
+# <tt>:transform</tt>:: A callable that returns a new BinData::IO::Transform.
+# <tt>:type</tt>::      The single type inside the buffer.  Use a struct if
+#                       multiple fields are required.
+#
+# source://bindata//lib/bindata/section.rb#40
+class BinData::Section < ::BinData::Base
+  extend ::BinData::DSLMixin
+
+  # source://bindata//lib/bindata/section.rb#56
+  def assign(val); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/section.rb#52
+  def clear?; end
+
+  # source://bindata//lib/bindata/section.rb#84
+  def do_num_bytes; end
+
+  # source://bindata//lib/bindata/section.rb#72
+  def do_read(io); end
+
+  # source://bindata//lib/bindata/section.rb#78
+  def do_write(io); end
+
+  # source://bindata//lib/bindata/section.rb#48
+  def initialize_instance; end
+
+  # source://bindata//lib/bindata/section.rb#68
+  def method_missing(symbol, *args, &block); end
+
+  # source://bindata//lib/bindata/section.rb#60
+  def snapshot; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/section.rb#64
+  def respond_to_missing?(symbol, include_all = T.unsafe(nil)); end
+end
+
+# source://bindata//lib/bindata/section.rb#89
+class BinData::SectionArgProcessor < ::BinData::BaseArgProcessor
+  include ::BinData::MultiFieldArgSeparator
+
+  # source://bindata//lib/bindata/section.rb#92
+  def sanitize_parameters!(obj_class, params); end
+end
+
+# Skip will skip over bytes from the input stream.  If the stream is not
+# seekable, then the bytes are consumed and discarded.
+#
+# When writing, skip will write the appropriate number of zero bytes.
+#
+#   require 'bindata'
+#
+#   class A < BinData::Record
+#     skip length: 5
+#     string :a, read_length: 5
+#   end
+#
+#   obj = A.read("abcdefghij")
+#   obj.a #=> "fghij"
+#
+#
+#   class B < BinData::Record
+#     skip do
+#       string read_length: 2, assert: 'ef'
+#     end
+#     string :s, read_length: 5
+#   end
+#
+#   obj = B.read("abcdefghij")
+#   obj.s #=> "efghi"
+#
+#
+# == Parameters
+#
+# Skip objects accept all the params that BinData::BasePrimitive
+# does, as well as the following:
+#
+# <tt>:length</tt>::        The number of bytes to skip.
+# <tt>:to_abs_offset</tt>:: Skips to the given absolute offset.
+# <tt>:until_valid</tt>::   Skips until a given byte pattern is matched.
+#                           This parameter contains a type that will raise
+#                           a BinData::ValidityError unless an acceptable byte
+#                           sequence is found.  The type is represented by a
+#                           Symbol, or if the type is to have params
+#                           passed to it, then it should be provided as
+#                           <tt>[type_symbol, hash_params]</tt>.
+#
+# source://bindata//lib/bindata/skip.rb#47
+class BinData::Skip < ::BinData::BasePrimitive
+  extend ::BinData::DSLMixin
+
+  # source://bindata//lib/bindata/skip.rb#56
+  def initialize_shared_instance; end
+
+  private
+
+  # source://bindata//lib/bindata/skip.rb#76
+  def read_and_return_value(io); end
+
+  # source://bindata//lib/bindata/skip.rb#87
+  def sensible_default; end
+
+  # source://bindata//lib/bindata/skip.rb#66
+  def value_to_binary_string(_); end
+end
+
+# Logic for the :length parameter
+#
+# source://bindata//lib/bindata/skip.rb#92
+module BinData::Skip::SkipLengthPlugin
+  # source://bindata//lib/bindata/skip.rb#93
+  def skip_length; end
+end
+
+# Logic for the :to_abs_offset parameter
+#
+# source://bindata//lib/bindata/skip.rb#99
+module BinData::Skip::SkipToAbsOffsetPlugin
+  # source://bindata//lib/bindata/skip.rb#100
+  def skip_length; end
+end
+
+# Logic for the :until_valid parameter
+#
+# source://bindata//lib/bindata/skip.rb#106
+module BinData::Skip::SkipUntilValidPlugin
+  # source://bindata//lib/bindata/skip.rb#145
+  def fast_search_for(obj); end
+
+  # If a search object has an +asserted_value+ field then we
+  # perform a faster search for a valid object.
+  #
+  # source://bindata//lib/bindata/skip.rb#155
+  def fast_search_for_obj(obj); end
+
+  # source://bindata//lib/bindata/skip.rb#170
+  def next_search_index(io, fs); end
+
+  # source://bindata//lib/bindata/skip.rb#111
+  def read_and_return_value(io); end
+
+  # source://bindata//lib/bindata/skip.rb#137
+  def seek_to_pos(pos, io); end
+
+  # source://bindata//lib/bindata/skip.rb#107
+  def skip_length; end
+end
+
+# A fast search has a pattern string at a specific offset.
+#
+# source://bindata//lib/bindata/skip.rb#143
+BinData::Skip::SkipUntilValidPlugin::FastSearch = Struct
+
+# source://bindata//lib/bindata/skip.rb#193
+class BinData::Skip::SkipUntilValidPlugin::ReadaheadIO < ::BinData::IO::Transform
+  # source://bindata//lib/bindata/skip.rb#194
+  def before_transform; end
+
+  # source://bindata//lib/bindata/skip.rb#202
+  def rollback; end
+end
+
+# source://bindata//lib/bindata/skip.rb#168
+BinData::Skip::SkipUntilValidPlugin::SEARCH_SIZE = T.let(T.unsafe(nil), Integer)
+
+# source://bindata//lib/bindata/skip.rb#209
+class BinData::SkipArgProcessor < ::BinData::BaseArgProcessor
+  # source://bindata//lib/bindata/skip.rb#210
+  def sanitize_parameters!(obj_class, params); end
+end
+
+# A String is a sequence of bytes.  This is the same as strings in Ruby 1.8.
+# The issue of character encoding is ignored by this class.
+#
+#   require 'bindata'
+#
+#   data = "abcdefghij"
+#
+#   obj = BinData::String.new(read_length: 5)
+#   obj.read(data)
+#   obj #=> "abcde"
+#
+#   obj = BinData::String.new(length: 6)
+#   obj.read(data)
+#   obj #=> "abcdef"
+#   obj.assign("abcdefghij")
+#   obj #=> "abcdef"
+#   obj.assign("abcd")
+#   obj #=> "abcd\000\000"
+#
+#   obj = BinData::String.new(length: 6, trim_padding: true)
+#   obj.assign("abcd")
+#   obj #=> "abcd"
+#   obj.to_binary_s #=> "abcd\000\000"
+#
+#   obj = BinData::String.new(length: 6, pad_byte: 'A')
+#   obj.assign("abcd")
+#   obj #=> "abcdAA"
+#   obj.to_binary_s #=> "abcdAA"
+#
+# == Parameters
+#
+# String objects accept all the params that BinData::BasePrimitive
+# does, as well as the following:
+#
+# <tt>:read_length</tt>::    The length in bytes to use when reading a value.
+# <tt>:length</tt>::         The fixed length of the string.  If a shorter
+#                            string is set, it will be padded to this length.
+# <tt>:pad_byte</tt>::       The byte to use when padding a string to a
+#                            set length.  Valid values are Integers and
+#                            Strings of length 1.  "\0" is the default.
+# <tt>:pad_front</tt>::      Signifies that the padding occurs at the front
+#                            of the string rather than the end.  Default
+#                            is false.
+# <tt>:trim_padding</tt>::   Boolean, default false.  If set, #value will
+#                            return the value with all pad_bytes trimmed
+#                            from the end of the string.  The value will
+#                            not be trimmed when writing.
+#
+# source://bindata//lib/bindata/string.rb#51
+class BinData::String < ::BinData::BasePrimitive
+  # source://bindata//lib/bindata/string.rb#67
+  def assign(val); end
+
+  # source://bindata//lib/bindata/string.rb#59
+  def initialize_shared_instance; end
+
+  # source://bindata//lib/bindata/string.rb#71
+  def snapshot; end
+
+  private
+
+  # source://bindata//lib/bindata/string.rb#86
+  def clamp_to_length(str); end
+
+  # source://bindata//lib/bindata/string.rb#116
+  def read_and_return_value(io); end
+
+  # source://bindata//lib/bindata/string.rb#121
+  def sensible_default; end
+
+  # source://bindata//lib/bindata/string.rb#104
+  def trim_padding(str); end
+
+  # source://bindata//lib/bindata/string.rb#112
+  def value_to_binary_string(val); end
+end
+
+# Warns when reading if :value && no :read_length
+#
+# source://bindata//lib/bindata/string.rb#126
+module BinData::String::WarnNoReadLengthPlugin
+  # source://bindata//lib/bindata/string.rb#127
+  def read_and_return_value(io); end
+end
+
+# source://bindata//lib/bindata/string.rb#134
+class BinData::StringArgProcessor < ::BinData::BaseArgProcessor
+  # source://bindata//lib/bindata/string.rb#135
+  def sanitize_parameters!(obj_class, params); end
+
+  private
+
+  # source://bindata//lib/bindata/string.rb#145
+  def sanitized_pad_byte(byte); end
+end
+
+# A BinData::Stringz object is a container for a zero ("\0") terminated
+# string.
+#
+# For convenience, the zero terminator is not necessary when setting the
+# value.  Likewise, the returned value will not be zero terminated.
+#
+#   require 'bindata'
+#
+#   data = "abcd\x00efgh"
+#
+#   obj = BinData::Stringz.new
+#   obj.read(data)
+#   obj.snapshot #=> "abcd"
+#   obj.num_bytes #=> 5
+#   obj.to_binary_s #=> "abcd\000"
+#
+# == Parameters
+#
+# Stringz objects accept all the params that BinData::BasePrimitive
+# does, as well as the following:
+#
+# <tt>:max_length</tt>:: The maximum length of the string including the zero
+#                        byte.
+#
+# source://bindata//lib/bindata/stringz.rb#27
+class BinData::Stringz < ::BinData::BasePrimitive
+  # source://bindata//lib/bindata/stringz.rb#30
+  def assign(val); end
+
+  # source://bindata//lib/bindata/stringz.rb#34
+  def snapshot; end
+
+  private
+
+  # source://bindata//lib/bindata/stringz.rb#92
+  def append_zero_byte_if_needed!(str); end
+
+  # source://bindata//lib/bindata/stringz.rb#47
+  def read_and_return_value(io); end
+
+  # source://bindata//lib/bindata/stringz.rb#63
+  def sensible_default; end
+
+  # source://bindata//lib/bindata/stringz.rb#67
+  def trim_and_zero_terminate(str); end
+
+  # source://bindata//lib/bindata/stringz.rb#85
+  def trim_to!(str, max_length = T.unsafe(nil)); end
+
+  # source://bindata//lib/bindata/stringz.rb#81
+  def truncate_after_first_zero_byte!(str); end
+
+  # source://bindata//lib/bindata/stringz.rb#43
+  def value_to_binary_string(val); end
+end
+
+# A Struct is an ordered collection of named data objects.
+#
+#    require 'bindata'
+#
+#    class Tuple < BinData::Record
+#      int8  :x
+#      int8  :y
+#      int8  :z
+#    end
+#
+#    obj = BinData::Struct.new(hide: :a,
+#                              fields: [ [:int32le, :a],
+#                                        [:int16le, :b],
+#                                        [:tuple, :s] ])
+#    obj.field_names   =># [:b, :s]
+#
+#
+# == Parameters
+#
+# Parameters may be provided at initialisation to control the behaviour of
+# an object.  These params are:
+#
+# <tt>:fields</tt>::   An array specifying the fields for this struct.
+#                      Each element of the array is of the form [type, name,
+#                      params].  Type is a symbol representing a registered
+#                      type.  Name is the name of this field.  Params is an
+#                      optional hash of parameters to pass to this field
+#                      when instantiating it.  If name is "" or nil, then
+#                      that field is anonymous and behaves as a hidden field.
+# <tt>:hide</tt>::     A list of the names of fields that are to be hidden
+#                      from the outside world.  Hidden fields don't appear
+#                      in #snapshot or #field_names but are still accessible
+#                      by name.
+# <tt>:endian</tt>::   Either :little or :big.  This specifies the default
+#                      endian of any numerics in this struct, or in any
+#                      nested data objects.
+# <tt>:search_prefix</tt>::  Allows abbreviated type names.  If a type is
+#                            unrecognised, then each prefix is applied until
+#                            a match is found.
+#
+# == Field Parameters
+#
+# Fields may have have extra parameters as listed below:
+#
+# [<tt>:onlyif</tt>]     Used to indicate a data object is optional.
+#                        if +false+, this object will not be included in any
+#                        calls to #read, #write, #num_bytes or #snapshot.
+# [<tt>:byte_align</tt>] This field's rel_offset must be a multiple of
+#                        <tt>:byte_align</tt>.
+#
+# source://bindata//lib/bindata/struct.rb#58
+class BinData::Struct < ::BinData::Base
+  # source://bindata//lib/bindata/struct.rb#154
+  def [](key); end
+
+  # source://bindata//lib/bindata/struct.rb#158
+  def []=(key, value); end
+
+  # source://bindata//lib/bindata/struct.rb#102
+  def assign(val); end
+
+  # source://bindata//lib/bindata/struct.rb#94
+  def clear; end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/struct.rb#98
+  def clear?; end
+
+  # source://bindata//lib/bindata/struct.rb#128
+  def debug_name_of(child); end
+
+  # source://bindata//lib/bindata/struct.rb#149
+  def do_num_bytes; end
+
+  # source://bindata//lib/bindata/struct.rb#139
+  def do_read(io); end
+
+  # source://bindata//lib/bindata/struct.rb#144
+  def do_write(io); end
+
+  # Calls the given block for each field_name-field_obj pair.
+  #
+  # Does not include anonymous or hidden fields unless
+  # +include_all+ is true.
+  #
+  # source://bindata//lib/bindata/struct.rb#170
+  def each_pair(include_all = T.unsafe(nil)); end
+
+  # Returns a list of the names of all fields accessible through this
+  # object.  +include_hidden+ specifies whether to include hidden names
+  # in the listing.
+  #
+  # source://bindata//lib/bindata/struct.rb#119
+  def field_names(include_hidden = T.unsafe(nil)); end
+
+  # has_key? is deprecated
+  #
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/struct.rb#162
+  def has_key?(key); end
+
+  # source://bindata//lib/bindata/struct.rb#90
+  def initialize_instance; end
+
+  # source://bindata//lib/bindata/struct.rb#82
+  def initialize_shared_instance; end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/struct.rb#162
+  def key?(key); end
+
+  # source://bindata//lib/bindata/struct.rb#133
+  def offset_of(child); end
+
+  # source://bindata//lib/bindata/struct.rb#107
+  def snapshot; end
+
+  private
+
+  # source://bindata//lib/bindata/struct.rb#247
+  def as_stringified_hash(val); end
+
+  # source://bindata//lib/bindata/struct.rb#236
+  def assign_fields(val); end
+
+  # source://bindata//lib/bindata/struct.rb#221
+  def base_field_name(name); end
+
+  # source://bindata//lib/bindata/struct.rb#187
+  def define_field_accessors; end
+
+  # source://bindata//lib/bindata/struct.rb#194
+  def define_field_accessors_for(name, index); end
+
+  # source://bindata//lib/bindata/struct.rb#209
+  def find_index_of(obj); end
+
+  # source://bindata//lib/bindata/struct.rb#213
+  def find_obj_for_name(name); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/struct.rb#281
+  def include_obj?(obj); end
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/struct.rb#275
+  def include_obj_for_io?(obj); end
+
+  # source://bindata//lib/bindata/struct.rb#225
+  def instantiate_all_objs; end
+
+  # source://bindata//lib/bindata/struct.rb#229
+  def instantiate_obj_at(index); end
+
+  # source://bindata//lib/bindata/struct.rb#263
+  def sum_num_bytes_below_index(index); end
+
+  # source://bindata//lib/bindata/struct.rb#259
+  def sum_num_bytes_for_all_fields; end
+
+  class << self
+    # source://bindata//lib/bindata/base.rb#53
+    def inherited(subclass); end
+  end
+end
+
+# Align fields to a multiple of :byte_align
+#
+# source://bindata//lib/bindata/struct.rb#301
+module BinData::Struct::ByteAlignPlugin
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/struct.rb#361
+  def align_obj?(obj); end
+
+  # source://bindata//lib/bindata/struct.rb#356
+  def bytes_to_align(obj, rel_offset); end
+
+  # source://bindata//lib/bindata/struct.rb#302
+  def do_read(io); end
+
+  # source://bindata//lib/bindata/struct.rb#320
+  def do_write(io); end
+
+  # source://bindata//lib/bindata/struct.rb#338
+  def sum_num_bytes_below_index(index); end
+end
+
+# These reserved words may not be used as field names
+#
+# source://bindata//lib/bindata/struct.rb#65
+BinData::Struct::RESERVED = T.let(T.unsafe(nil), Hash)
+
+# A hash that can be accessed via attributes.
+#
+# source://bindata//lib/bindata/struct.rb#286
+class BinData::Struct::Snapshot < ::Hash
+  # source://bindata//lib/bindata/struct.rb#287
+  def []=(key, value); end
+
+  # source://bindata//lib/bindata/struct.rb#295
+  def method_missing(symbol, *args); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://bindata//lib/bindata/struct.rb#291
+  def respond_to_missing?(symbol, include_all = T.unsafe(nil)); end
+end
+
+# source://bindata//lib/bindata/struct.rb#367
+class BinData::StructArgProcessor < ::BinData::BaseArgProcessor
+  # source://bindata//lib/bindata/struct.rb#368
+  def sanitize_parameters!(obj_class, params); end
+
+  private
+
+  # source://bindata//lib/bindata/struct.rb#420
+  def ensure_field_names_are_valid(obj_class, field_names); end
+
+  # source://bindata//lib/bindata/struct.rb#416
+  def hidden_field_names(hidden); end
+
+  # source://bindata//lib/bindata/struct.rb#378
+  def sanitize_endian(params); end
+
+  # source://bindata//lib/bindata/struct.rb#392
+  def sanitize_fields(obj_class, params); end
+
+  # source://bindata//lib/bindata/struct.rb#403
+  def sanitize_hide(params); end
+
+  # source://bindata//lib/bindata/struct.rb#382
+  def sanitize_search_prefix(params); end
+
+  # source://bindata//lib/bindata/struct.rb#412
+  def sanitized_field_names(sanitized_fields); end
+end
+
+# source://bindata//lib/bindata/trace.rb#47
+module BinData::TraceHook
+  # source://bindata//lib/bindata/trace.rb#55
+  def turn_off_tracing; end
+
+  # source://bindata//lib/bindata/trace.rb#48
+  def turn_on_tracing; end
+end
+
+# source://bindata//lib/bindata/trace.rb#23
+class BinData::Tracer
+  # @return [Tracer] a new instance of Tracer
+  #
+  # source://bindata//lib/bindata/trace.rb#24
+  def initialize(io); end
+
+  # source://bindata//lib/bindata/trace.rb#28
+  def trace(msg); end
+
+  # source://bindata//lib/bindata/trace.rb#32
+  def trace_obj(obj_name, val); end
+end
+
+# Unsigned 1 byte integer.
+#
+# source://bindata//lib/bindata/int.rb#180
+class BinData::Uint8 < ::BinData::BasePrimitive
+  def assign(val); end
+  def do_num_bytes; end
+
+  private
+
+  def read_and_return_value(io); end
+  def sensible_default; end
+  def value_to_binary_string(val); end
+end
+
+# Uint8Array is a specialised type of array that only contains
+# bytes (Uint8).  It is a faster and more memory efficient version
+# of `BinData::Array.new(:type => :uint8)`.
+#
+#   require 'bindata'
+#
+#   obj = BinData::Uint8Array.new(initial_length: 5)
+#   obj.read("abcdefg") #=> [97, 98, 99, 100, 101]
+#   obj[2] #=> 99
+#   obj.collect { |x| x.chr }.join #=> "abcde"
+#
+# == Parameters
+#
+# Parameters may be provided at initialisation to control the behaviour of
+# an object.  These params are:
+#
+# <tt>:initial_length</tt>:: The initial length of the array.
+# <tt>:read_until</tt>::     May only have a value of `:eof`.  This parameter
+#                            instructs the array to read as much data from
+#                            the stream as possible.
+#
+# source://bindata//lib/bindata/uint8_array.rb#24
+class BinData::Uint8Array < ::BinData::BasePrimitive
+  private
+
+  # source://bindata//lib/bindata/uint8_array.rb#36
+  def read_and_return_value(io); end
+
+  # source://bindata//lib/bindata/uint8_array.rb#46
+  def sensible_default; end
+
+  # source://bindata//lib/bindata/uint8_array.rb#32
+  def value_to_binary_string(val); end
+end
+
+# source://bindata//lib/bindata/uint8_array.rb#51
+class BinData::Uint8ArrayArgProcessor < ::BinData::BaseArgProcessor
+  # source://bindata//lib/bindata/uint8_array.rb#52
+  def sanitize_parameters!(obj_class, params); end
+end
+
+# Raised when #lookup fails.
+#
+# source://bindata//lib/bindata/registry.rb#3
+class BinData::UnRegisteredTypeError < ::StandardError; end
+
+# source://bindata//lib/bindata/version.rb#2
+BinData::VERSION = T.let(T.unsafe(nil), String)
+
+# Error raised when unexpected results occur when reading data from IO.
+#
+# source://bindata//lib/bindata/framework.rb#3
+class BinData::ValidityError < ::StandardError; end
+
+# A virtual field is one that is neither read, written nor occupies space in
+# the data stream.  It is used to make assertions or as a convenient label
+# for determining offsets or storing values.
+#
+#   require 'bindata'
+#
+#   class A < BinData::Record
+#     string  :a, read_length: 5
+#     string  :b, read_length: 5
+#     virtual :c, assert: -> { a == b }
+#   end
+#
+#   obj = A.read("abcdeabcde")
+#   obj.a #=> "abcde"
+#   obj.c.rel_offset #=> 10
+#
+#   obj = A.read("abcdeABCDE") #=> BinData::ValidityError: assertion failed for obj.c
+#
+# == Parameters
+#
+# Parameters may be provided at initialisation to control the behaviour of
+# an object.  These params include those for BinData::Base as well as:
+#
+# [<tt>:assert</tt>]    Raise an error when reading or assigning if the value
+#                       of this evaluated parameter is false.
+# [<tt>:value</tt>]     The virtual object will always have this value.
+#
+# source://bindata//lib/bindata/virtual.rb#31
+class BinData::Virtual < ::BinData::BasePrimitive
+  # source://bindata//lib/bindata/virtual.rb#36
+  def do_num_bytes; end
+
+  # source://bindata//lib/bindata/virtual.rb#32
+  def do_read(io); end
+
+  # source://bindata//lib/bindata/virtual.rb#34
+  def do_write(io); end
+
+  # source://bindata//lib/bindata/virtual.rb#40
+  def sensible_default; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/bootsnap@1.12.0.rbi b/Library/Homebrew/sorbet/rbi/gems/bootsnap@1.12.0.rbi
deleted file mode 100644
index 7d53df97d8ae4..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/bootsnap@1.12.0.rbi
+++ /dev/null
@@ -1,212 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `bootsnap` gem.
-# Please instead update this file by running `bin/tapioca gem bootsnap`.
-
-module Bootsnap
-  extend ::Bootsnap
-
-  def bundler?; end
-
-  class << self
-    def _instrument(event, path); end
-    def absolute_path?(path); end
-    def default_setup; end
-    def instrumentation=(callback); end
-    def iseq_cache_supported?; end
-    def log!; end
-    def logger; end
-    def logger=(logger); end
-    def rb_get_path(fname); end
-    def setup(cache_dir:, development_mode: T.unsafe(nil), load_path_cache: T.unsafe(nil), autoload_paths_cache: T.unsafe(nil), disable_trace: T.unsafe(nil), compile_cache_iseq: T.unsafe(nil), compile_cache_yaml: T.unsafe(nil), compile_cache_json: T.unsafe(nil)); end
-  end
-end
-
-module Bootsnap::CompileCache
-  class << self
-    def permission_error(path); end
-    def setup(cache_dir:, iseq:, yaml:, json:); end
-    def supported?; end
-  end
-end
-
-class Bootsnap::CompileCache::Error < ::StandardError; end
-class Bootsnap::CompileCache::PermissionError < ::Bootsnap::CompileCache::Error; end
-Bootsnap::CompileCache::UNCOMPILABLE = T.let(T.unsafe(nil), BasicObject)
-
-module Bootsnap::ExplicitRequire
-  class << self
-    def from_archdir(feature); end
-    def from_rubylibdir(feature); end
-    def from_self(feature); end
-    def with_gems(*gems); end
-  end
-end
-
-Bootsnap::ExplicitRequire::ARCHDIR = T.let(T.unsafe(nil), String)
-Bootsnap::ExplicitRequire::DLEXT = T.let(T.unsafe(nil), String)
-Bootsnap::ExplicitRequire::RUBYLIBDIR = T.let(T.unsafe(nil), String)
-class Bootsnap::InvalidConfiguration < ::StandardError; end
-
-module Bootsnap::LoadPathCache
-  class << self
-    def load_path_cache; end
-    def loaded_features_index; end
-    def setup(cache_path:, development_mode:); end
-    def supported?; end
-  end
-end
-
-Bootsnap::LoadPathCache::CACHED_EXTENSIONS = T.let(T.unsafe(nil), Array)
-
-class Bootsnap::LoadPathCache::Cache
-  def initialize(store, path_obj, development_mode: T.unsafe(nil)); end
-
-  def find(feature, try_extensions: T.unsafe(nil)); end
-  def load_dir(dir); end
-  def push_paths(sender, *paths); end
-  def reinitialize(path_obj = T.unsafe(nil)); end
-  def unshift_paths(sender, *paths); end
-
-  private
-
-  def dir_changed?; end
-  def expand_path(feature); end
-  def maybe_append_extension(feature); end
-  def now; end
-  def push_paths_locked(*paths); end
-  def search_index(feature, try_extensions: T.unsafe(nil)); end
-  def stale?; end
-  def try_ext(feature); end
-  def try_index(feature); end
-  def unshift_paths_locked(*paths); end
-end
-
-Bootsnap::LoadPathCache::Cache::AGE_THRESHOLD = T.let(T.unsafe(nil), Integer)
-Bootsnap::LoadPathCache::Cache::BUILTIN_FEATURES = T.let(T.unsafe(nil), Hash)
-
-module Bootsnap::LoadPathCache::ChangeObserver
-  class << self
-    def register(observer, arr); end
-  end
-end
-
-module Bootsnap::LoadPathCache::ChangeObserver::ArrayMixin
-  def <<(entry); end
-  def []=(*args, &block); end
-  def append(*entries); end
-  def clear(*args, &block); end
-  def collect!(*args, &block); end
-  def compact!(*args, &block); end
-  def concat(entries); end
-  def delete(*args, &block); end
-  def delete_at(*args, &block); end
-  def delete_if(*args, &block); end
-  def fill(*args, &block); end
-  def flatten!(*args, &block); end
-  def insert(*args, &block); end
-  def keep_if(*args, &block); end
-  def map!(*args, &block); end
-  def pop(*args, &block); end
-  def prepend(*entries); end
-  def push(*entries); end
-  def reject!(*args, &block); end
-  def replace(*args, &block); end
-  def reverse!(*args, &block); end
-  def rotate!(*args, &block); end
-  def select!(*args, &block); end
-  def shift(*args, &block); end
-  def shuffle!(*args, &block); end
-  def slice!(*args, &block); end
-  def sort!(*args, &block); end
-  def sort_by!(*args, &block); end
-  def uniq!(*args); end
-  def unshift(*entries); end
-end
-
-Bootsnap::LoadPathCache::DLEXT = T.let(T.unsafe(nil), String)
-Bootsnap::LoadPathCache::DL_EXTENSIONS = T.let(T.unsafe(nil), Array)
-Bootsnap::LoadPathCache::DOT_RB = T.let(T.unsafe(nil), String)
-Bootsnap::LoadPathCache::DOT_SO = T.let(T.unsafe(nil), String)
-Bootsnap::LoadPathCache::FALLBACK_SCAN = T.let(T.unsafe(nil), BasicObject)
-
-class Bootsnap::LoadPathCache::LoadedFeaturesIndex
-  def initialize; end
-
-  def cursor(short); end
-  def identify(short, cursor); end
-  def key?(feature); end
-  def purge(feature); end
-  def purge_multi(features); end
-  def register(short, long); end
-
-  private
-
-  def extension_elidable?(feature); end
-  def strip_extension_if_elidable(feature); end
-end
-
-Bootsnap::LoadPathCache::LoadedFeaturesIndex::STRIP_EXTENSION = T.let(T.unsafe(nil), Regexp)
-
-class Bootsnap::LoadPathCache::Path
-  def initialize(path, real: T.unsafe(nil)); end
-
-  def entries_and_dirs(store); end
-  def expanded_path; end
-  def non_directory?; end
-  def path; end
-  def relative?; end
-  def stable?; end
-  def to_realpath; end
-  def volatile?; end
-
-  private
-
-  def latest_mtime(path, dirs); end
-  def scan!; end
-  def stability; end
-end
-
-Bootsnap::LoadPathCache::Path::RUBY_LIBDIR = T.let(T.unsafe(nil), String)
-Bootsnap::LoadPathCache::Path::RUBY_SITEDIR = T.let(T.unsafe(nil), String)
-Bootsnap::LoadPathCache::Path::STABLE = T.let(T.unsafe(nil), Symbol)
-Bootsnap::LoadPathCache::Path::VOLATILE = T.let(T.unsafe(nil), Symbol)
-
-module Bootsnap::LoadPathCache::PathScanner
-  class << self
-    def call(path); end
-    def os_path(path); end
-    def walk(absolute_dir_path, relative_dir_path, &block); end
-  end
-end
-
-Bootsnap::LoadPathCache::PathScanner::ALTERNATIVE_NATIVE_EXTENSIONS_PATTERN = T.let(T.unsafe(nil), Regexp)
-Bootsnap::LoadPathCache::PathScanner::BUNDLE_PATH = T.let(T.unsafe(nil), String)
-Bootsnap::LoadPathCache::PathScanner::NORMALIZE_NATIVE_EXTENSIONS = T.let(T.unsafe(nil), TrueClass)
-Bootsnap::LoadPathCache::PathScanner::REQUIRABLE_EXTENSIONS = T.let(T.unsafe(nil), Array)
-Bootsnap::LoadPathCache::SLASH = T.let(T.unsafe(nil), String)
-
-class Bootsnap::LoadPathCache::Store
-  def initialize(store_path); end
-
-  def fetch(key); end
-  def get(key); end
-  def set(key, value); end
-  def transaction; end
-
-  private
-
-  def commit_transaction; end
-  def default_data; end
-  def dump_data; end
-  def load_data; end
-  def mark_for_mutation!; end
-  def mkdir_p(path); end
-end
-
-Bootsnap::LoadPathCache::Store::CURRENT_VERSION = T.let(T.unsafe(nil), String)
-class Bootsnap::LoadPathCache::Store::NestedTransactionError < ::StandardError; end
-class Bootsnap::LoadPathCache::Store::SetOutsideTransactionNotAllowed < ::StandardError; end
-Bootsnap::LoadPathCache::Store::VERSION_KEY = T.let(T.unsafe(nil), String)
-Bootsnap::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi
deleted file mode 100644
index da405adea8fed..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi
+++ /dev/null
@@ -1,20 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `byebug` gem.
-# Please instead update this file by running `bin/tapioca gem byebug`.
-
-module Byebug
-  class << self
-    def attach; end
-    def spawn(host = T.unsafe(nil), port = T.unsafe(nil)); end
-  end
-end
-
-module Kernel
-  extend ::Forwardable
-
-  def byebug; end
-  def debugger; end
-  def remote_byebug(host = T.unsafe(nil), port = T.unsafe(nil)); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi
deleted file mode 100644
index 1cf355998aeda..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi
+++ /dev/null
@@ -1,1005 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `coderay` gem.
-# Please instead update this file by running `bin/tapioca gem coderay`.
-
-module CodeRay
-  class << self
-    def coderay_path(*path); end
-    def encode(code, lang, format, options = T.unsafe(nil)); end
-    def encode_file(filename, format, options = T.unsafe(nil)); end
-    def encode_tokens(tokens, format, options = T.unsafe(nil)); end
-    def encoder(format, options = T.unsafe(nil)); end
-    def get_scanner_options(options); end
-    def highlight(code, lang, options = T.unsafe(nil), format = T.unsafe(nil)); end
-    def highlight_file(filename, options = T.unsafe(nil), format = T.unsafe(nil)); end
-    def scan(code, lang, options = T.unsafe(nil), &block); end
-    def scan_file(filename, lang = T.unsafe(nil), options = T.unsafe(nil), &block); end
-    def scanner(lang, options = T.unsafe(nil), &block); end
-  end
-end
-
-CodeRay::CODERAY_PATH = T.let(T.unsafe(nil), String)
-
-class CodeRay::Duo
-  def initialize(lang = T.unsafe(nil), format = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def call(code, options = T.unsafe(nil)); end
-  def encode(code, options = T.unsafe(nil)); end
-  def encoder; end
-  def format; end
-  def format=(_arg0); end
-  def highlight(code, options = T.unsafe(nil)); end
-  def lang; end
-  def lang=(_arg0); end
-  def options; end
-  def options=(_arg0); end
-  def scanner; end
-
-  class << self
-    def [](*_arg0); end
-  end
-end
-
-module CodeRay::Encoders
-  extend ::CodeRay::PluginHost
-end
-
-class CodeRay::Encoders::CommentFilter < ::CodeRay::Encoders::TokenKindFilter; end
-CodeRay::Encoders::CommentFilter::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-
-class CodeRay::Encoders::Count < ::CodeRay::Encoders::Encoder
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def end_group(kind); end
-  def end_line(kind); end
-  def text_token(text, kind); end
-
-  protected
-
-  def finish(options); end
-  def setup(options); end
-end
-
-class CodeRay::Encoders::Debug < ::CodeRay::Encoders::Encoder
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def end_group(kind); end
-  def end_line(kind); end
-  def text_token(text, kind); end
-end
-
-CodeRay::Encoders::Debug::FILE_EXTENSION = T.let(T.unsafe(nil), String)
-
-class CodeRay::Encoders::DebugLint < ::CodeRay::Encoders::Debug
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def end_group(kind); end
-  def end_line(kind); end
-  def text_token(text, kind); end
-
-  protected
-
-  def finish(options); end
-  def setup(options); end
-end
-
-class CodeRay::Encoders::Div < ::CodeRay::Encoders::HTML; end
-CodeRay::Encoders::Div::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-CodeRay::Encoders::Div::FILE_EXTENSION = T.let(T.unsafe(nil), String)
-
-class CodeRay::Encoders::Encoder
-  extend ::CodeRay::Plugin
-
-  def initialize(options = T.unsafe(nil)); end
-
-  def <<(token); end
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def encode(code, lang, options = T.unsafe(nil)); end
-  def encode_tokens(tokens, options = T.unsafe(nil)); end
-  def end_group(kind); end
-  def end_line(kind); end
-  def file_extension; end
-  def highlight(code, lang, options = T.unsafe(nil)); end
-  def options; end
-  def options=(_arg0); end
-  def scanner; end
-  def scanner=(_arg0); end
-  def text_token(text, kind); end
-  def token(content, kind); end
-  def tokens(tokens, options = T.unsafe(nil)); end
-
-  protected
-
-  def compile(tokens, options = T.unsafe(nil)); end
-  def finish(options); end
-  def get_output(options); end
-  def output(data); end
-  def setup(options); end
-
-  class << self
-    def const_missing(sym); end
-    def file_extension; end
-  end
-end
-
-CodeRay::Encoders::Encoder::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-CodeRay::Encoders::Encoder::PLUGIN_HOST = CodeRay::Encoders
-
-class CodeRay::Encoders::Filter < ::CodeRay::Encoders::Encoder
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def end_group(kind); end
-  def end_line(kind); end
-  def text_token(text, kind); end
-
-  protected
-
-  def finish(options); end
-  def setup(options); end
-end
-
-class CodeRay::Encoders::HTML < ::CodeRay::Encoders::Encoder
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def css; end
-  def end_group(kind); end
-  def end_line(kind); end
-  def text_token(text, kind); end
-
-  protected
-
-  def break_lines(text, style); end
-  def check_group_nesting(name, kind); end
-  def check_options!(options); end
-  def close_span; end
-  def css_class_for_kinds(kinds); end
-  def finish(options); end
-  def make_span_for_kinds(method, hint); end
-  def setup(options); end
-  def style_for_kinds(kinds); end
-
-  class << self
-    def make_html_escape_hash; end
-    def token_path_to_hint(hint, kinds); end
-  end
-end
-
-class CodeRay::Encoders::HTML::CSS
-  def initialize(style = T.unsafe(nil)); end
-
-  def get_style_for_css_classes(css_classes); end
-  def stylesheet; end
-
-  private
-
-  def parse(stylesheet); end
-
-  class << self
-    def load_stylesheet(style = T.unsafe(nil)); end
-  end
-end
-
-CodeRay::Encoders::HTML::CSS::CSS_CLASS_PATTERN = T.let(T.unsafe(nil), Regexp)
-CodeRay::Encoders::HTML::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-CodeRay::Encoders::HTML::FILE_EXTENSION = T.let(T.unsafe(nil), String)
-CodeRay::Encoders::HTML::HTML_ESCAPE = T.let(T.unsafe(nil), Hash)
-CodeRay::Encoders::HTML::HTML_ESCAPE_PATTERN = T.let(T.unsafe(nil), Regexp)
-
-module CodeRay::Encoders::HTML::Numbering
-  class << self
-    def number!(output, mode = T.unsafe(nil), options = T.unsafe(nil)); end
-  end
-end
-
-module CodeRay::Encoders::HTML::Output
-  def apply_title!(title); end
-  def css; end
-  def css=(_arg0); end
-  def stylesheet(in_tag = T.unsafe(nil)); end
-  def wrap!(element, *args); end
-  def wrap_in!(template); end
-  def wrapped_in; end
-  def wrapped_in=(_arg0); end
-  def wrapped_in?(element); end
-
-  class << self
-    def extended(o); end
-    def make_stylesheet(css, in_tag = T.unsafe(nil)); end
-    def page_template_for_css(css); end
-  end
-end
-
-CodeRay::Encoders::HTML::Output::DIV = T.let(T.unsafe(nil), CodeRay::Encoders::HTML::Output::Template)
-CodeRay::Encoders::HTML::Output::PAGE = T.let(T.unsafe(nil), CodeRay::Encoders::HTML::Output::Template)
-CodeRay::Encoders::HTML::Output::SPAN = T.let(T.unsafe(nil), CodeRay::Encoders::HTML::Output::Template)
-CodeRay::Encoders::HTML::Output::TABLE = T.let(T.unsafe(nil), CodeRay::Encoders::HTML::Output::Template)
-
-class CodeRay::Encoders::HTML::Output::Template < ::String
-  def apply(target, replacement); end
-
-  class << self
-    def wrap!(str, template, target); end
-  end
-end
-
-CodeRay::Encoders::HTML::TOKEN_KIND_TO_INFO = T.let(T.unsafe(nil), Hash)
-CodeRay::Encoders::HTML::TRANSPARENT_TOKEN_KINDS = T.let(T.unsafe(nil), Set)
-
-class CodeRay::Encoders::JSON < ::CodeRay::Encoders::Encoder
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def end_group(kind); end
-  def end_line(kind); end
-  def text_token(text, kind); end
-
-  protected
-
-  def append(data); end
-  def finish(options); end
-  def setup(options); end
-end
-
-CodeRay::Encoders::JSON::FILE_EXTENSION = T.let(T.unsafe(nil), String)
-
-class CodeRay::Encoders::LinesOfCode < ::CodeRay::Encoders::TokenKindFilter
-  protected
-
-  def finish(options); end
-  def setup(options); end
-end
-
-CodeRay::Encoders::LinesOfCode::NON_EMPTY_LINE = T.let(T.unsafe(nil), Regexp)
-
-class CodeRay::Encoders::Lint < ::CodeRay::Encoders::Debug
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def end_group(kind); end
-  def end_line(kind); end
-  def text_token(text, kind); end
-
-  protected
-
-  def finish(options); end
-  def setup(options); end
-end
-
-class CodeRay::Encoders::Lint::EmptyToken < ::CodeRay::Encoders::Lint::InvalidTokenStream; end
-class CodeRay::Encoders::Lint::IncorrectTokenGroupNesting < ::CodeRay::Encoders::Lint::InvalidTokenStream; end
-class CodeRay::Encoders::Lint::InvalidTokenStream < ::StandardError; end
-class CodeRay::Encoders::Lint::UnknownTokenKind < ::CodeRay::Encoders::Lint::InvalidTokenStream; end
-
-class CodeRay::Encoders::Null < ::CodeRay::Encoders::Encoder
-  def text_token(text, kind); end
-end
-
-class CodeRay::Encoders::Page < ::CodeRay::Encoders::HTML; end
-CodeRay::Encoders::Page::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-CodeRay::Encoders::Page::FILE_EXTENSION = T.let(T.unsafe(nil), String)
-class CodeRay::Encoders::Span < ::CodeRay::Encoders::HTML; end
-CodeRay::Encoders::Span::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-CodeRay::Encoders::Span::FILE_EXTENSION = T.let(T.unsafe(nil), String)
-
-class CodeRay::Encoders::Statistic < ::CodeRay::Encoders::Encoder
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def block_token(action, kind); end
-  def end_group(kind); end
-  def end_line(kind); end
-  def real_token_count; end
-  def text_token(text, kind); end
-  def type_stats; end
-
-  protected
-
-  def finish(options); end
-  def setup(options); end
-end
-
-CodeRay::Encoders::Statistic::STATS = T.let(T.unsafe(nil), String)
-CodeRay::Encoders::Statistic::TOKEN_TYPES_ROW = T.let(T.unsafe(nil), String)
-
-class CodeRay::Encoders::Statistic::TypeStats < ::Struct
-  def count; end
-  def count=(_); end
-  def size; end
-  def size=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class CodeRay::Encoders::Terminal < ::CodeRay::Encoders::Encoder
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def end_group(kind); end
-  def end_line(kind); end
-  def text_token(text, kind); end
-
-  protected
-
-  def setup(options); end
-
-  private
-
-  def open_token(kind); end
-end
-
-CodeRay::Encoders::Terminal::TOKEN_COLORS = T.let(T.unsafe(nil), Hash)
-
-class CodeRay::Encoders::Text < ::CodeRay::Encoders::Encoder
-  def text_token(text, kind); end
-
-  protected
-
-  def setup(options); end
-end
-
-CodeRay::Encoders::Text::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-CodeRay::Encoders::Text::FILE_EXTENSION = T.let(T.unsafe(nil), String)
-
-class CodeRay::Encoders::TokenKindFilter < ::CodeRay::Encoders::Filter
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def end_group(kind); end
-  def end_line(kind); end
-  def text_token(text, kind); end
-
-  protected
-
-  def include_group?(kind); end
-  def include_text_token?(text, kind); end
-  def setup(options); end
-end
-
-CodeRay::Encoders::TokenKindFilter::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-
-class CodeRay::Encoders::XML < ::CodeRay::Encoders::Encoder
-  def begin_group(kind); end
-  def end_group(kind); end
-  def text_token(text, kind); end
-
-  protected
-
-  def finish(options); end
-  def setup(options); end
-end
-
-CodeRay::Encoders::XML::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-CodeRay::Encoders::XML::FILE_EXTENSION = T.let(T.unsafe(nil), String)
-
-class CodeRay::Encoders::YAML < ::CodeRay::Encoders::Encoder
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def end_group(kind); end
-  def end_line(kind); end
-  def text_token(text, kind); end
-
-  protected
-
-  def finish(options); end
-  def setup(options); end
-end
-
-CodeRay::Encoders::YAML::FILE_EXTENSION = T.let(T.unsafe(nil), String)
-
-module CodeRay::FileType
-  class << self
-    def [](filename, read_shebang = T.unsafe(nil)); end
-    def fetch(filename, default = T.unsafe(nil), read_shebang = T.unsafe(nil)); end
-
-    protected
-
-    def type_from_shebang(filename); end
-  end
-end
-
-CodeRay::FileType::TypeFromExt = T.let(T.unsafe(nil), Hash)
-CodeRay::FileType::TypeFromName = T.let(T.unsafe(nil), Hash)
-CodeRay::FileType::TypeFromShebang = T.let(T.unsafe(nil), Regexp)
-class CodeRay::FileType::UnknownFileType < ::Exception; end
-
-module CodeRay::Plugin
-  def aliases; end
-  def plugin_host(host = T.unsafe(nil)); end
-  def plugin_id; end
-  def register_for(id); end
-  def title(title = T.unsafe(nil)); end
-end
-
-module CodeRay::PluginHost
-  def [](id, *args, &blk); end
-  def all_plugins; end
-  def const_missing(const); end
-  def default(id = T.unsafe(nil)); end
-  def list; end
-  def load(id, *args, &blk); end
-  def load_all; end
-  def load_plugin_map; end
-  def map(hash); end
-  def plugin_hash; end
-  def plugin_path(*args); end
-  def register(plugin, id); end
-
-  protected
-
-  def make_plugin_hash; end
-  def path_to(plugin_id); end
-  def validate_id(id); end
-
-  class << self
-    def extended(mod); end
-  end
-end
-
-class CodeRay::PluginHost::HostNotFound < ::LoadError; end
-CodeRay::PluginHost::PLUGIN_HOSTS = T.let(T.unsafe(nil), Array)
-CodeRay::PluginHost::PLUGIN_HOSTS_BY_ID = T.let(T.unsafe(nil), Hash)
-class CodeRay::PluginHost::PluginNotFound < ::LoadError; end
-
-module CodeRay::Scanners
-  extend ::CodeRay::PluginHost
-end
-
-class CodeRay::Scanners::C < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-end
-
-CodeRay::Scanners::C::DIRECTIVES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::C::ESCAPE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::C::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::C::KEYWORDS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::C::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::C::PREDEFINED_TYPES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::C::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CPlusPlus = CodeRay::Scanners::Text
-
-class CodeRay::Scanners::CSS < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-  def setup; end
-end
-
-CodeRay::Scanners::CSS::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
-module CodeRay::Scanners::CSS::RE; end
-CodeRay::Scanners::CSS::RE::AtKeyword = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::AttributeSelector = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::Class = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::Dimension = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::Escape = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::Function = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::Hex = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::HexColor = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::Id = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::Ident = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::NMChar = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::NMStart = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::Name = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::Num = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::Percentage = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::PseudoClass = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::String = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::String1 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::String2 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::Unicode = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::CSS::RE::Unit = T.let(T.unsafe(nil), Regexp)
-
-class CodeRay::Scanners::Clojure < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-end
-
-CodeRay::Scanners::Clojure::BASIC_IDENTIFIER = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::COMPLEX10 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::COMPLEX16 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::COMPLEX2 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::COMPLEX8 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::CORE_FORMS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Clojure::DECIMAL = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::DIGIT = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::DIGIT10 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::DIGIT16 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::DIGIT2 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::DIGIT8 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::EXACTNESS = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::EXP = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::EXP_MARK = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::IDENTIFIER = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::Clojure::IMAG10 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::IMAG16 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::IMAG2 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::IMAG8 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::KEYWORD_NEXT_TOKEN_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::Clojure::NUM = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::NUM10 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::NUM16 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::NUM2 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::NUM8 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Clojure::PREFIX10 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::PREFIX16 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::PREFIX2 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::PREFIX8 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::RADIX10 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::RADIX16 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::RADIX2 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::RADIX8 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::REAL10 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::REAL16 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::REAL2 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::REAL8 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::SIGN = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::SPECIAL_FORMS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Clojure::SUFFIX = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::SYMBOL = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::UINT10 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::UINT16 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::UINT2 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::UINT8 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::UREAL10 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::UREAL16 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::UREAL2 = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Clojure::UREAL8 = T.let(T.unsafe(nil), Regexp)
-
-class CodeRay::Scanners::Debug < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-  def setup; end
-end
-
-class CodeRay::Scanners::Delphi < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-end
-
-CodeRay::Scanners::Delphi::DIRECTIVES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Delphi::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring)
-CodeRay::Scanners::Delphi::KEYWORDS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Delphi::NAME_FOLLOWS = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring)
-
-class CodeRay::Scanners::Diff < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-
-  private
-
-  def diff(a, b); end
-end
-
-CodeRay::Scanners::Diff::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-
-class CodeRay::Scanners::ERB < ::CodeRay::Scanners::Scanner
-  protected
-
-  def reset_instance; end
-  def scan_tokens(encoder, options); end
-  def setup; end
-end
-
-CodeRay::Scanners::ERB::ERB_RUBY_BLOCK = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::ERB::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::ERB::START_OF_ERB = T.let(T.unsafe(nil), Regexp)
-
-class CodeRay::Scanners::Go < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-end
-
-CodeRay::Scanners::Go::ESCAPE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Go::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::Go::KEYWORDS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Go::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Go::PREDEFINED_FUNCTIONS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Go::PREDEFINED_TYPES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Go::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
-
-class CodeRay::Scanners::Groovy < ::CodeRay::Scanners::Java
-  protected
-
-  def scan_tokens(encoder, options); end
-  def setup; end
-end
-
-CodeRay::Scanners::Groovy::ESCAPE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Groovy::GROOVY_KEYWORDS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Groovy::GROOVY_MAGIC_VARIABLES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Groovy::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::Groovy::KEYWORDS_EXPECTING_VALUE = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::Groovy::REGEXP_ESCAPE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Groovy::STRING_CONTENT_PATTERN = T.let(T.unsafe(nil), Hash)
-CodeRay::Scanners::Groovy::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
-
-class CodeRay::Scanners::HAML < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-  def setup; end
-end
-
-CodeRay::Scanners::HAML::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
-
-class CodeRay::Scanners::HTML < ::CodeRay::Scanners::Scanner
-  def reset; end
-
-  protected
-
-  def scan_css(encoder, code, state = T.unsafe(nil)); end
-  def scan_java_script(encoder, code); end
-  def scan_tokens(encoder, options); end
-  def setup; end
-end
-
-CodeRay::Scanners::HTML::ATTR_NAME = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::HTML::ENTITY = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::HTML::EVENT_ATTRIBUTES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::HTML::HEX = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::HTML::IN_ATTRIBUTE = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring)
-CodeRay::Scanners::HTML::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::HTML::PLAIN_STRING_CONTENT = T.let(T.unsafe(nil), Hash)
-CodeRay::Scanners::HTML::TAG_END = T.let(T.unsafe(nil), Regexp)
-
-class CodeRay::Scanners::JSON < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-  def setup; end
-end
-
-CodeRay::Scanners::JSON::ESCAPE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::JSON::KEY = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::JSON::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::JSON::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
-
-class CodeRay::Scanners::Java < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-end
-
-module CodeRay::Scanners::Java::BuiltinTypes; end
-CodeRay::Scanners::Java::BuiltinTypes::List = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Java::CONSTANTS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Java::DIRECTIVES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Java::ESCAPE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Java::IDENT = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Java::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::Java::KEYWORDS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Java::MAGIC_VARIABLES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Java::RESERVED = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Java::STRING_CONTENT_PATTERN = T.let(T.unsafe(nil), Hash)
-CodeRay::Scanners::Java::TYPES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Java::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
-
-class CodeRay::Scanners::JavaScript < ::CodeRay::Scanners::Scanner
-  protected
-
-  def reset_instance; end
-  def scan_tokens(encoder, options); end
-  def setup; end
-  def xml_scanner; end
-end
-
-CodeRay::Scanners::JavaScript::ESCAPE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::JavaScript::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::JavaScript::KEYWORDS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::JavaScript::KEYWORDS_EXPECTING_VALUE = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::JavaScript::KEY_CHECK_PATTERN = T.let(T.unsafe(nil), Hash)
-CodeRay::Scanners::JavaScript::MAGIC_VARIABLES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::JavaScript::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::JavaScript::REGEXP_ESCAPE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::JavaScript::RESERVED_WORDS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::JavaScript::STRING_CONTENT_PATTERN = T.let(T.unsafe(nil), Hash)
-CodeRay::Scanners::JavaScript::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
-
-class CodeRay::Scanners::Lua < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-  def setup; end
-end
-
-CodeRay::Scanners::Lua::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::Lua::KEYWORDS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Lua::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Lua::PREDEFINED_EXPRESSIONS = T.let(T.unsafe(nil), Array)
-
-class CodeRay::Scanners::PHP < ::CodeRay::Scanners::Scanner
-  protected
-
-  def reset_instance; end
-  def scan_tokens(encoder, options); end
-  def setup; end
-end
-
-CodeRay::Scanners::PHP::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
-module CodeRay::Scanners::PHP::RE; end
-CodeRay::Scanners::PHP::RE::HTML_INDICATOR = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::PHP::RE::IDENTIFIER = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::PHP::RE::OPERATOR = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::PHP::RE::PHP_END = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::PHP::RE::PHP_START = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::PHP::RE::VARIABLE = T.let(T.unsafe(nil), Regexp)
-module CodeRay::Scanners::PHP::Words; end
-CodeRay::Scanners::PHP::Words::BUILTIN_FUNCTIONS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::PHP::Words::CLASSES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::PHP::Words::CONSTANTS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::PHP::Words::EXCEPTIONS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::PHP::Words::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring)
-CodeRay::Scanners::PHP::Words::KEYWORDS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::PHP::Words::LANGUAGE_CONSTRUCTS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::PHP::Words::PREDEFINED = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::PHP::Words::TYPES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::PHP::Words::VARIABLE_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
-
-class CodeRay::Scanners::Python < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-end
-
-CodeRay::Scanners::Python::DEF_NEW_STATE = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::Python::DESCRIPTOR = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Python::DOCSTRING_COMING = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Python::ESCAPE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Python::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::Python::KEYWORDS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Python::NAME = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Python::OLD_KEYWORDS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Python::OPERATOR = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Python::PREDEFINED_EXCEPTIONS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Python::PREDEFINED_METHODS_AND_TYPES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Python::PREDEFINED_VARIABLES_AND_CONSTANTS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Python::STRING_CONTENT_REGEXP = T.let(T.unsafe(nil), Hash)
-CodeRay::Scanners::Python::STRING_DELIMITER_REGEXP = T.let(T.unsafe(nil), Hash)
-CodeRay::Scanners::Python::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
-
-class CodeRay::Scanners::Raydebug < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-  def setup; end
-end
-
-class CodeRay::Scanners::Ruby < ::CodeRay::Scanners::Scanner
-  def interpreted_string_state; end
-
-  protected
-
-  def scan_tokens(encoder, options); end
-  def setup; end
-end
-
-module CodeRay::Scanners::Ruby::Patterns; end
-CodeRay::Scanners::Ruby::Patterns::BINARY = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::CHARACTER = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::CLASS_VARIABLE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::CONTROL_META_ESCAPE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::DATA = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::DECIMAL = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::ESCAPE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::EXPONENT = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::FANCY_STRING_INTERPRETED = T.let(T.unsafe(nil), Hash)
-CodeRay::Scanners::Ruby::Patterns::FANCY_STRING_KIND = T.let(T.unsafe(nil), Hash)
-CodeRay::Scanners::Ruby::Patterns::FANCY_STRING_START = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::FLOAT_OR_INT = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::FLOAT_SUFFIX = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::GLOBAL_VARIABLE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::HEREDOC_OPEN = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::HEXADECIMAL = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::IDENT = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::Ruby::Patterns::INSTANCE_VARIABLE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::KEYWORDS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Ruby::Patterns::KEYWORDS_EXPECTING_VALUE = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::Ruby::Patterns::KEYWORD_NEW_STATE = T.let(T.unsafe(nil), CodeRay::WordList)
-CodeRay::Scanners::Ruby::Patterns::METHOD_AFTER_DOT = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::METHOD_NAME = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::METHOD_NAME_EX = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::METHOD_NAME_OPERATOR = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::METHOD_NAME_OR_SYMBOL = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::METHOD_SUFFIX = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::NUMERIC = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::OBJECT_VARIABLE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::OCTAL = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Ruby::Patterns::PREFIX_VARIABLE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::QUOTE_TO_TYPE = T.let(T.unsafe(nil), Hash)
-CodeRay::Scanners::Ruby::Patterns::REGEXP_MODIFIERS = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::RUBYDOC = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::RUBYDOC_OR_DATA = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::SIMPLE_ESCAPE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::SYMBOL = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::VALUE_FOLLOWS = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::Ruby::Patterns::VARIABLE = T.let(T.unsafe(nil), Regexp)
-
-class CodeRay::Scanners::Ruby::StringState < ::Struct
-  def initialize(kind, interpreted, delim, heredoc = T.unsafe(nil)); end
-
-  def heredoc_pattern(delim, interpreted, indented); end
-
-  class << self
-    def simple_key_pattern(delim); end
-  end
-end
-
-CodeRay::Scanners::Ruby::StringState::CLOSING_PAREN = T.let(T.unsafe(nil), Hash)
-CodeRay::Scanners::Ruby::StringState::STRING_PATTERN = T.let(T.unsafe(nil), Hash)
-
-class CodeRay::Scanners::SQL < ::CodeRay::Scanners::Scanner
-  def scan_tokens(encoder, options); end
-end
-
-CodeRay::Scanners::SQL::COMMANDS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::SQL::DIRECTIVES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::SQL::ESCAPE = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::SQL::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring)
-CodeRay::Scanners::SQL::KEYWORDS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::SQL::OBJECTS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::SQL::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::SQL::PREDEFINED_FUNCTIONS = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::SQL::PREDEFINED_TYPES = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::SQL::STRING_CONTENT_PATTERN = T.let(T.unsafe(nil), Hash)
-CodeRay::Scanners::SQL::STRING_PREFIXES = T.let(T.unsafe(nil), Regexp)
-CodeRay::Scanners::SQL::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
-
-class CodeRay::Scanners::Sass < ::CodeRay::Scanners::CSS
-  protected
-
-  def scan_tokens(encoder, options); end
-  def setup; end
-end
-
-class CodeRay::Scanners::Scanner < ::StringScanner
-  include ::Enumerable
-  extend ::CodeRay::Plugin
-
-  def initialize(code = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def binary_string; end
-  def column(pos = T.unsafe(nil)); end
-  def each(&block); end
-  def file_extension; end
-  def lang; end
-  def line(pos = T.unsafe(nil)); end
-  def reset; end
-  def state; end
-  def state=(_arg0); end
-  def string=(code); end
-  def tokenize(source = T.unsafe(nil), options = T.unsafe(nil)); end
-  def tokens; end
-
-  protected
-
-  def raise_inspect(message, tokens, state = T.unsafe(nil), ambit = T.unsafe(nil), backtrace = T.unsafe(nil)); end
-  def raise_inspect_arguments(message, tokens, state, ambit); end
-  def reset_instance; end
-  def scan_rest; end
-  def scan_tokens(tokens, options); end
-  def scanner_state_info(state); end
-  def set_string_from_source(source); end
-  def set_tokens_from_options(options); end
-  def setup; end
-  def tokens_last(tokens, n); end
-  def tokens_size(tokens); end
-
-  class << self
-    def encoding(name = T.unsafe(nil)); end
-    def file_extension(extension = T.unsafe(nil)); end
-    def lang; end
-    def normalize(code); end
-
-    protected
-
-    def encode_with_encoding(code, target_encoding); end
-    def guess_encoding(s); end
-    def to_unix(code); end
-  end
-end
-
-CodeRay::Scanners::Scanner::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-CodeRay::Scanners::Scanner::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
-CodeRay::Scanners::Scanner::PLUGIN_HOST = CodeRay::Scanners
-CodeRay::Scanners::Scanner::SCANNER_STATE_INFO = T.let(T.unsafe(nil), String)
-CodeRay::Scanners::Scanner::SCAN_ERROR_MESSAGE = T.let(T.unsafe(nil), String)
-class CodeRay::Scanners::Scanner::ScanError < ::StandardError; end
-
-class CodeRay::Scanners::Taskpaper < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-end
-
-class CodeRay::Scanners::Text < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-end
-
-CodeRay::Scanners::Text::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
-class CodeRay::Scanners::XML < ::CodeRay::Scanners::HTML; end
-
-class CodeRay::Scanners::YAML < ::CodeRay::Scanners::Scanner
-  protected
-
-  def scan_tokens(encoder, options); end
-end
-
-CodeRay::Scanners::YAML::KINDS_NOT_LOC = T.let(T.unsafe(nil), Symbol)
-
-module CodeRay::Styles
-  extend ::CodeRay::PluginHost
-end
-
-class CodeRay::Styles::Alpha < ::CodeRay::Styles::Style; end
-CodeRay::Styles::Alpha::CSS_MAIN_STYLES = T.let(T.unsafe(nil), String)
-CodeRay::Styles::Alpha::TOKEN_COLORS = T.let(T.unsafe(nil), String)
-
-class CodeRay::Styles::Style
-  extend ::CodeRay::Plugin
-end
-
-CodeRay::Styles::Style::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-CodeRay::Styles::Style::PLUGIN_HOST = CodeRay::Styles
-CodeRay::TokenKinds = T.let(T.unsafe(nil), Hash)
-
-class CodeRay::Tokens < ::Array
-  def begin_group(kind); end
-  def begin_line(kind); end
-  def count; end
-  def encode(encoder, options = T.unsafe(nil)); end
-  def end_group(kind); end
-  def end_line(kind); end
-  def method_missing(meth, options = T.unsafe(nil)); end
-  def scanner; end
-  def scanner=(_arg0); end
-  def split_into_parts(*sizes); end
-  def text_token(*_arg0); end
-  def to_s; end
-  def tokens(*_arg0); end
-end
-
-class CodeRay::TokensProxy
-  def initialize(input, lang, options = T.unsafe(nil), block = T.unsafe(nil)); end
-
-  def block; end
-  def block=(_arg0); end
-  def each(*args, &blk); end
-  def encode(encoder, options = T.unsafe(nil)); end
-  def input; end
-  def input=(_arg0); end
-  def lang; end
-  def lang=(_arg0); end
-  def method_missing(method, *args, &blk); end
-  def options; end
-  def options=(_arg0); end
-  def scanner; end
-  def tokens; end
-end
-
-CodeRay::VERSION = T.let(T.unsafe(nil), String)
-
-class CodeRay::WordList < ::Hash
-  def initialize(default = T.unsafe(nil)); end
-
-  def add(words, value = T.unsafe(nil)); end
-end
-
-class CodeRay::WordList::CaseIgnoring < ::CodeRay::WordList
-  def [](key); end
-  def []=(key, value); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/commander@4.6.0.rbi b/Library/Homebrew/sorbet/rbi/gems/commander@4.6.0.rbi
deleted file mode 100644
index a0da6d393ca4a..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/commander@4.6.0.rbi
+++ /dev/null
@@ -1,268 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `commander` gem.
-# Please instead update this file by running `bin/tapioca gem commander`.
-
-::RUBY19 = T.let(T.unsafe(nil), TrueClass)
-
-module Blank
-  class << self
-    def included(base); end
-  end
-end
-
-module Commander
-  private
-
-  def configure(*configuration_opts, &configuration_block); end
-
-  class << self
-    def configure(*configuration_opts, &configuration_block); end
-  end
-end
-
-class Commander::Command
-  def initialize(name); end
-
-  def action(*args, &block); end
-  def call(args = T.unsafe(nil)); end
-  def description; end
-  def description=(_arg0); end
-  def example(description, command); end
-  def examples; end
-  def examples=(_arg0); end
-  def global_options; end
-  def inspect; end
-  def name; end
-  def name=(_arg0); end
-  def option(*args, &block); end
-  def option_proc(switches); end
-  def options; end
-  def options=(_arg0); end
-  def parse_options_and_call_procs(*args); end
-  def proxy_option_struct; end
-  def proxy_options; end
-  def proxy_options=(_arg0); end
-  def run(*args); end
-  def summary; end
-  def summary=(_arg0); end
-  def syntax; end
-  def syntax=(_arg0); end
-  def when_called(*args, &block); end
-end
-
-class Commander::Command::Options
-  include ::Blank
-
-  def initialize; end
-
-  def __hash__; end
-  def default(defaults = T.unsafe(nil)); end
-  def inspect; end
-  def method_missing(meth, *args); end
-end
-
-module Commander::Delegates
-  def add_command(*args, &block); end
-  def alias_command(*args, &block); end
-  def always_trace!(*args, &block); end
-  def command(*args, &block); end
-  def default_command(*args, &block); end
-  def defined_commands(*args, &block); end
-  def global_option(*args, &block); end
-  def never_trace!(*args, &block); end
-  def program(*args, &block); end
-  def run!(*args, &block); end
-end
-
-module Commander::HelpFormatter
-  private
-
-  def indent(amount, text); end
-
-  class << self
-    def indent(amount, text); end
-  end
-end
-
-class Commander::HelpFormatter::Base
-  def initialize(runner); end
-
-  def render; end
-  def render_command(command); end
-end
-
-class Commander::HelpFormatter::Context
-  def initialize(target); end
-
-  def decorate_binding(_bind); end
-  def get_binding; end
-end
-
-class Commander::HelpFormatter::ProgramContext < ::Commander::HelpFormatter::Context
-  def decorate_binding(bind); end
-  def max_aliases_length(bind); end
-  def max_command_length(bind); end
-  def max_key_length(hash, default = T.unsafe(nil)); end
-end
-
-class Commander::HelpFormatter::Terminal < ::Commander::HelpFormatter::Base
-  def render; end
-  def render_command(command); end
-  def template(name); end
-end
-
-class Commander::HelpFormatter::TerminalCompact < ::Commander::HelpFormatter::Terminal
-  def template(name); end
-end
-
-module Commander::Methods
-  include ::Commander::UI
-  include ::Commander::UI::AskForClass
-  include ::Commander::Delegates
-end
-
-module Commander::Platform
-  class << self
-    def jruby?; end
-  end
-end
-
-class Commander::Runner
-  def initialize(args = T.unsafe(nil)); end
-
-  def active_command; end
-  def add_command(command); end
-  def alias?(name); end
-  def alias_command(alias_name, name, *args); end
-  def always_trace!; end
-  def args_without_command_name; end
-  def command(name, &block); end
-  def command_exists?(name); end
-  def command_name_from_args; end
-  def commands; end
-  def create_default_commands; end
-  def default_command(name); end
-  def expand_optionally_negative_switches(switches); end
-  def global_option(*args, &block); end
-  def global_option_proc(switches, &block); end
-  def help_formatter; end
-  def help_formatter_alias_defaults; end
-  def help_formatter_aliases; end
-  def never_trace!; end
-  def options; end
-  def parse_global_options; end
-  def program(key, *args, &block); end
-  def program_defaults; end
-  def remove_global_options(options, args); end
-  def require_program(*keys); end
-  def require_valid_command(command = T.unsafe(nil)); end
-  def run!; end
-  def run_active_command; end
-  def say(*args); end
-  def valid_command_names_from(*args); end
-  def version; end
-
-  private
-
-  def longest_valid_command_name_from(args); end
-
-  class << self
-    def instance; end
-    def separate_switches_from_description(*args); end
-    def switch_to_sym(switch); end
-  end
-end
-
-class Commander::Runner::CommandError < ::StandardError; end
-class Commander::Runner::InvalidCommandError < ::Commander::Runner::CommandError; end
-
-module Commander::UI
-  private
-
-  def applescript(script); end
-  def ask_editor(input = T.unsafe(nil), preferred_editor = T.unsafe(nil)); end
-  def available_editor(preferred = T.unsafe(nil)); end
-  def choose(message = T.unsafe(nil), *choices, &block); end
-  def color(*args); end
-  def converse(prompt, responses = T.unsafe(nil)); end
-  def enable_paging; end
-  def io(input = T.unsafe(nil), output = T.unsafe(nil), &block); end
-  def log(action, *args); end
-  def password(message = T.unsafe(nil), mask = T.unsafe(nil)); end
-  def progress(arr, options = T.unsafe(nil)); end
-  def replace_tokens(str, hash); end
-  def say_error(*args); end
-  def say_ok(*args); end
-  def say_warning(*args); end
-  def speak(message, voice = T.unsafe(nil), rate = T.unsafe(nil)); end
-
-  class << self
-    def applescript(script); end
-    def ask_editor(input = T.unsafe(nil), preferred_editor = T.unsafe(nil)); end
-    def available_editor(preferred = T.unsafe(nil)); end
-    def choose(message = T.unsafe(nil), *choices, &block); end
-    def color(*args); end
-    def converse(prompt, responses = T.unsafe(nil)); end
-    def enable_paging; end
-    def io(input = T.unsafe(nil), output = T.unsafe(nil), &block); end
-    def log(action, *args); end
-    def password(message = T.unsafe(nil), mask = T.unsafe(nil)); end
-    def progress(arr, options = T.unsafe(nil)); end
-    def replace_tokens(str, hash); end
-    def say_error(*args); end
-    def say_ok(*args); end
-    def say_warning(*args); end
-    def speak(message, voice = T.unsafe(nil), rate = T.unsafe(nil)); end
-  end
-end
-
-module Commander::UI::AskForClass
-  def ask_for_array(prompt); end
-  def ask_for_file(prompt); end
-  def ask_for_float(prompt); end
-  def ask_for_integer(prompt); end
-  def ask_for_pathname(prompt); end
-  def ask_for_regexp(prompt); end
-  def ask_for_string(prompt); end
-  def ask_for_symbol(prompt); end
-  def method_missing(method_name, *arguments, &block); end
-
-  private
-
-  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
-end
-
-Commander::UI::AskForClass::DEPRECATED_CONSTANTS = T.let(T.unsafe(nil), Array)
-
-class Commander::UI::ProgressBar
-  def initialize(total, options = T.unsafe(nil)); end
-
-  def completed?; end
-  def erase_line; end
-  def finished?; end
-  def generate_tokens; end
-  def increment(tokens = T.unsafe(nil)); end
-  def percent_complete; end
-  def progress_bar; end
-  def show; end
-  def steps_remaining; end
-  def time_elapsed; end
-  def time_remaining; end
-end
-
-Commander::VERSION = T.let(T.unsafe(nil), String)
-
-class Object < ::BasicObject
-  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
-  include ::ActiveSupport::ForkTracker::CoreExt
-  include ::ActiveSupport::ForkTracker::CoreExtPrivate
-  include ::Kernel
-  include ::JSON::Ext::Generator::GeneratorMethods::Object
-  include ::PP::ObjectMixin
-  include ::ActiveSupport::Dependencies::Loadable
-  include ::ActiveSupport::Tryable
-
-  def get_binding; end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/concurrent-ruby@1.1.10.rbi b/Library/Homebrew/sorbet/rbi/gems/concurrent-ruby@1.1.10.rbi
deleted file mode 100644
index 3c8ddd94ee6a5..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/concurrent-ruby@1.1.10.rbi
+++ /dev/null
@@ -1,2398 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `concurrent-ruby` gem.
-# Please instead update this file by running `bin/tapioca gem concurrent-ruby`.
-
-module Concurrent
-  extend ::Concurrent::Utility::EngineDetector
-  extend ::Concurrent::Utility::NativeExtensionLoader
-  extend ::Logger::Severity
-  extend ::Concurrent::Concern::Logging
-  extend ::Concurrent::Concern::Deprecation
-
-  private
-
-  def abort_transaction; end
-  def atomically; end
-  def call_dataflow(method, executor, *inputs, &block); end
-  def dataflow(*inputs, &block); end
-  def dataflow!(*inputs, &block); end
-  def dataflow_with(executor, *inputs, &block); end
-  def dataflow_with!(executor, *inputs, &block); end
-  def leave_transaction; end
-  def monotonic_time(unit = T.unsafe(nil)); end
-
-  class << self
-    def abort_transaction; end
-    def atomically; end
-    def call_dataflow(method, executor, *inputs, &block); end
-    def create_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
-    def create_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
-    def dataflow(*inputs, &block); end
-    def dataflow!(*inputs, &block); end
-    def dataflow_with(executor, *inputs, &block); end
-    def dataflow_with!(executor, *inputs, &block); end
-    def disable_at_exit_handlers!; end
-    def executor(executor_identifier); end
-    def global_fast_executor; end
-    def global_immediate_executor; end
-    def global_io_executor; end
-    def global_logger; end
-    def global_logger=(value); end
-    def global_timer_set; end
-    def leave_transaction; end
-    def monotonic_time(unit = T.unsafe(nil)); end
-    def new_fast_executor(opts = T.unsafe(nil)); end
-    def new_io_executor(opts = T.unsafe(nil)); end
-    def physical_processor_count; end
-    def processor_count; end
-    def processor_counter; end
-    def use_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
-    def use_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
-  end
-end
-
-class Concurrent::AbstractExchanger < ::Concurrent::Synchronization::Object
-  def initialize; end
-
-  def exchange(value, timeout = T.unsafe(nil)); end
-  def exchange!(value, timeout = T.unsafe(nil)); end
-  def try_exchange(value, timeout = T.unsafe(nil)); end
-
-  private
-
-  def do_exchange(value, timeout); end
-end
-
-Concurrent::AbstractExchanger::CANCEL = T.let(T.unsafe(nil), Object)
-
-class Concurrent::AbstractExecutorService < ::Concurrent::Synchronization::LockableObject
-  include ::Logger::Severity
-  include ::Concurrent::Concern::Logging
-  include ::Concurrent::ExecutorService
-  include ::Concurrent::Concern::Deprecation
-
-  def initialize(opts = T.unsafe(nil), &block); end
-
-  def auto_terminate=(value); end
-  def auto_terminate?; end
-  def fallback_policy; end
-  def kill; end
-  def name; end
-  def running?; end
-  def shutdown; end
-  def shutdown?; end
-  def shuttingdown?; end
-  def to_s; end
-  def wait_for_termination(timeout = T.unsafe(nil)); end
-
-  private
-
-  def fallback_action(*args); end
-  def ns_auto_terminate?; end
-  def ns_execute(*args, &task); end
-  def ns_kill_execution; end
-  def ns_shutdown_execution; end
-end
-
-Concurrent::AbstractExecutorService::FALLBACK_POLICIES = T.let(T.unsafe(nil), Array)
-
-class Concurrent::AbstractThreadLocalVar
-  def initialize(default = T.unsafe(nil), &default_block); end
-
-  def bind(value, &block); end
-  def value; end
-  def value=(value); end
-
-  protected
-
-  def allocate_storage; end
-  def default; end
-end
-
-class Concurrent::Agent < ::Concurrent::Synchronization::LockableObject
-  include ::Concurrent::Concern::Observable
-
-  def initialize(initial, opts = T.unsafe(nil)); end
-
-  def <<(action); end
-  def await; end
-  def await_for(timeout); end
-  def await_for!(timeout); end
-  def deref; end
-  def error; end
-  def error_mode; end
-  def failed?; end
-  def post(*args, &action); end
-  def reason; end
-  def restart(new_value, opts = T.unsafe(nil)); end
-  def send(*args, &action); end
-  def send!(*args, &action); end
-  def send_off(*args, &action); end
-  def send_off!(*args, &action); end
-  def send_via(executor, *args, &action); end
-  def send_via!(executor, *args, &action); end
-  def stopped?; end
-  def value; end
-  def wait(timeout = T.unsafe(nil)); end
-
-  private
-
-  def enqueue_action_job(action, args, executor); end
-  def enqueue_await_job(latch); end
-  def execute_next_job; end
-  def handle_error(error); end
-  def ns_enqueue_job(job, index = T.unsafe(nil)); end
-  def ns_find_last_job_for_thread; end
-  def ns_initialize(initial, opts); end
-  def ns_post_next_job; end
-  def ns_validate(value); end
-
-  class << self
-    def await(*agents); end
-    def await_for(timeout, *agents); end
-    def await_for!(timeout, *agents); end
-  end
-end
-
-Concurrent::Agent::AWAIT_ACTION = T.let(T.unsafe(nil), Proc)
-Concurrent::Agent::AWAIT_FLAG = T.let(T.unsafe(nil), Object)
-Concurrent::Agent::DEFAULT_ERROR_HANDLER = T.let(T.unsafe(nil), Proc)
-Concurrent::Agent::DEFAULT_VALIDATOR = T.let(T.unsafe(nil), Proc)
-Concurrent::Agent::ERROR_MODES = T.let(T.unsafe(nil), Array)
-
-class Concurrent::Agent::Error < ::StandardError
-  def initialize(message = T.unsafe(nil)); end
-end
-
-class Concurrent::Agent::Job < ::Struct
-  def action; end
-  def action=(_); end
-  def args; end
-  def args=(_); end
-  def caller; end
-  def caller=(_); end
-  def executor; end
-  def executor=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class Concurrent::Agent::ValidationError < ::Concurrent::Agent::Error
-  def initialize(message = T.unsafe(nil)); end
-end
-
-class Concurrent::Array < ::Array; end
-Concurrent::ArrayImplementation = Array
-
-module Concurrent::Async
-  mixes_in_class_methods ::Concurrent::Async::ClassMethods
-
-  def async; end
-  def await; end
-  def call; end
-  def cast; end
-  def init_synchronization; end
-
-  class << self
-    def included(base); end
-    def validate_argc(obj, method, *args); end
-  end
-end
-
-class Concurrent::Async::AsyncDelegator < ::Concurrent::Synchronization::LockableObject
-  def initialize(delegate); end
-
-  def method_missing(method, *args, &block); end
-  def perform; end
-  def reset_if_forked; end
-
-  private
-
-  def respond_to_missing?(method, include_private = T.unsafe(nil)); end
-end
-
-class Concurrent::Async::AwaitDelegator
-  def initialize(delegate); end
-
-  def method_missing(method, *args, &block); end
-
-  private
-
-  def respond_to_missing?(method, include_private = T.unsafe(nil)); end
-end
-
-module Concurrent::Async::ClassMethods
-  def new(*args, &block); end
-end
-
-class Concurrent::Atom < ::Concurrent::Synchronization::Object
-  include ::Concurrent::Concern::Observable
-
-  def initialize(value, opts = T.unsafe(nil)); end
-
-  def __initialize_atomic_fields__; end
-  def compare_and_set(old_value, new_value); end
-  def deref; end
-  def reset(new_value); end
-  def swap(*args); end
-  def value; end
-
-  private
-
-  def compare_and_set_value(expected, value); end
-  def swap_value(value); end
-  def update_value(&block); end
-  def valid?(new_value); end
-  def value=(value); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-class Concurrent::AtomicBoolean < ::Concurrent::MutexAtomicBoolean
-  def inspect; end
-  def to_s; end
-end
-
-Concurrent::AtomicBooleanImplementation = Concurrent::MutexAtomicBoolean
-
-module Concurrent::AtomicDirectUpdate
-  def try_update; end
-  def try_update!; end
-  def update; end
-end
-
-class Concurrent::AtomicFixnum < ::Concurrent::MutexAtomicFixnum
-  def inspect; end
-  def to_s; end
-end
-
-Concurrent::AtomicFixnumImplementation = Concurrent::MutexAtomicFixnum
-
-class Concurrent::AtomicMarkableReference < ::Concurrent::Synchronization::Object
-  def initialize(value = T.unsafe(nil), mark = T.unsafe(nil)); end
-
-  def __initialize_atomic_fields__; end
-  def compare_and_set(expected_val, new_val, expected_mark, new_mark); end
-  def compare_and_swap(expected_val, new_val, expected_mark, new_mark); end
-  def get; end
-  def mark; end
-  def marked?; end
-  def set(new_val, new_mark); end
-  def try_update; end
-  def try_update!; end
-  def update; end
-  def value; end
-
-  private
-
-  def compare_and_set_reference(expected, value); end
-  def immutable_array(*args); end
-  def reference; end
-  def reference=(value); end
-  def swap_reference(value); end
-  def update_reference(&block); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-module Concurrent::AtomicNumericCompareAndSetWrapper
-  def compare_and_set(old_value, new_value); end
-end
-
-class Concurrent::AtomicReference < ::Concurrent::MutexAtomicReference
-  def inspect; end
-  def to_s; end
-end
-
-Concurrent::AtomicReferenceImplementation = Concurrent::MutexAtomicReference
-
-class Concurrent::CRubySet < ::Set
-  def initialize(*args, &block); end
-
-  def &(*args); end
-  def +(*args); end
-  def -(*args); end
-  def <(*args); end
-  def <<(*args); end
-  def <=(*args); end
-  def ==(*args); end
-  def ===(*args); end
-  def >(*args); end
-  def >=(*args); end
-  def ^(*args); end
-  def add(*args); end
-  def add?(*args); end
-  def classify(*args); end
-  def clear(*args); end
-  def collect!(*args); end
-  def compare_by_identity(*args); end
-  def compare_by_identity?(*args); end
-  def delete(*args); end
-  def delete?(*args); end
-  def delete_if(*args); end
-  def difference(*args); end
-  def disjoint?(*args); end
-  def divide(*args); end
-  def each(*args); end
-  def empty?(*args); end
-  def eql?(*args); end
-  def filter!(*args); end
-  def flatten(*args); end
-  def flatten!(*args); end
-  def flatten_merge(*args); end
-  def freeze(*args); end
-  def hash(*args); end
-  def include?(*args); end
-  def inspect(*args); end
-  def intersect?(*args); end
-  def intersection(*args); end
-  def keep_if(*args); end
-  def length(*args); end
-  def map!(*args); end
-  def member?(*args); end
-  def merge(*args); end
-  def pretty_print(*args); end
-  def pretty_print_cycle(*args); end
-  def proper_subset?(*args); end
-  def proper_superset?(*args); end
-  def reject!(*args); end
-  def replace(*args); end
-  def reset(*args); end
-  def select!(*args); end
-  def size(*args); end
-  def subset?(*args); end
-  def subtract(*args); end
-  def superset?(*args); end
-  def taint(*args); end
-  def to_a(*args); end
-  def to_s(*args); end
-  def to_set(*args); end
-  def union(*args); end
-  def untaint(*args); end
-  def |(*args); end
-
-  private
-
-  def initialize_copy(other); end
-end
-
-class Concurrent::CachedThreadPool < ::Concurrent::ThreadPoolExecutor
-  def initialize(opts = T.unsafe(nil)); end
-
-  private
-
-  def ns_initialize(opts); end
-end
-
-class Concurrent::CancelledOperationError < ::Concurrent::Error; end
-module Concurrent::Collection; end
-
-class Concurrent::Collection::CopyOnNotifyObserverSet < ::Concurrent::Synchronization::LockableObject
-  def initialize; end
-
-  def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
-  def count_observers; end
-  def delete_observer(observer); end
-  def delete_observers; end
-  def notify_and_delete_observers(*args, &block); end
-  def notify_observers(*args, &block); end
-
-  protected
-
-  def ns_initialize; end
-
-  private
-
-  def duplicate_and_clear_observers; end
-  def duplicate_observers; end
-  def notify_to(observers, *args); end
-end
-
-class Concurrent::Collection::CopyOnWriteObserverSet < ::Concurrent::Synchronization::LockableObject
-  def initialize; end
-
-  def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
-  def count_observers; end
-  def delete_observer(observer); end
-  def delete_observers; end
-  def notify_and_delete_observers(*args, &block); end
-  def notify_observers(*args, &block); end
-
-  protected
-
-  def ns_initialize; end
-
-  private
-
-  def clear_observers_and_return_old; end
-  def notify_to(observers, *args); end
-  def observers; end
-  def observers=(new_set); end
-end
-
-Concurrent::Collection::MapImplementation = Concurrent::Collection::MriMapBackend
-
-class Concurrent::Collection::MriMapBackend < ::Concurrent::Collection::NonConcurrentMapBackend
-  def initialize(options = T.unsafe(nil)); end
-
-  def []=(key, value); end
-  def clear; end
-  def compute(key); end
-  def compute_if_absent(key); end
-  def compute_if_present(key); end
-  def delete(key); end
-  def delete_pair(key, value); end
-  def get_and_set(key, value); end
-  def merge_pair(key, value); end
-  def replace_if_exists(key, new_value); end
-  def replace_pair(key, old_value, new_value); end
-end
-
-class Concurrent::Collection::NonConcurrentMapBackend
-  def initialize(options = T.unsafe(nil)); end
-
-  def [](key); end
-  def []=(key, value); end
-  def clear; end
-  def compute(key); end
-  def compute_if_absent(key); end
-  def compute_if_present(key); end
-  def delete(key); end
-  def delete_pair(key, value); end
-  def each_pair; end
-  def get_and_set(key, value); end
-  def get_or_default(key, default_value); end
-  def key?(key); end
-  def merge_pair(key, value); end
-  def replace_if_exists(key, new_value); end
-  def replace_pair(key, old_value, new_value); end
-  def size; end
-
-  private
-
-  def _get(key); end
-  def _set(key, value); end
-  def dupped_backend; end
-  def initialize_copy(other); end
-  def pair?(key, expected_value); end
-  def store_computed_value(key, new_value); end
-end
-
-class Concurrent::Collection::NonConcurrentPriorityQueue < ::Concurrent::Collection::RubyNonConcurrentPriorityQueue
-  def <<(item); end
-  def deq; end
-  def enq(item); end
-  def has_priority?(item); end
-  def shift; end
-  def size; end
-end
-
-Concurrent::Collection::NonConcurrentPriorityQueueImplementation = Concurrent::Collection::RubyNonConcurrentPriorityQueue
-
-class Concurrent::Collection::RubyNonConcurrentPriorityQueue
-  def initialize(opts = T.unsafe(nil)); end
-
-  def <<(item); end
-  def clear; end
-  def delete(item); end
-  def deq; end
-  def empty?; end
-  def enq(item); end
-  def has_priority?(item); end
-  def include?(item); end
-  def length; end
-  def peek; end
-  def pop; end
-  def push(item); end
-  def shift; end
-  def size; end
-
-  private
-
-  def ordered?(x, y); end
-  def sink(k); end
-  def swap(x, y); end
-  def swim(k); end
-
-  class << self
-    def from_list(list, opts = T.unsafe(nil)); end
-  end
-end
-
-module Concurrent::Concern; end
-
-module Concurrent::Concern::Deprecation
-  include ::Logger::Severity
-  include ::Concurrent::Concern::Logging
-  extend ::Logger::Severity
-  extend ::Concurrent::Concern::Logging
-  extend ::Concurrent::Concern::Deprecation
-
-  def deprecated(message, strip = T.unsafe(nil)); end
-  def deprecated_method(old_name, new_name); end
-end
-
-module Concurrent::Concern::Dereferenceable
-  def deref; end
-  def value; end
-
-  protected
-
-  def apply_deref_options(value); end
-  def ns_set_deref_options(opts); end
-  def set_deref_options(opts = T.unsafe(nil)); end
-  def value=(value); end
-end
-
-module Concurrent::Concern::Logging
-  include ::Logger::Severity
-
-  def log(level, progname, message = T.unsafe(nil), &block); end
-end
-
-module Concurrent::Concern::Obligation
-  include ::Concurrent::Concern::Dereferenceable
-
-  def complete?; end
-  def exception(*args); end
-  def fulfilled?; end
-  def incomplete?; end
-  def no_error!(timeout = T.unsafe(nil)); end
-  def pending?; end
-  def realized?; end
-  def reason; end
-  def rejected?; end
-  def state; end
-  def unscheduled?; end
-  def value(timeout = T.unsafe(nil)); end
-  def value!(timeout = T.unsafe(nil)); end
-  def wait(timeout = T.unsafe(nil)); end
-  def wait!(timeout = T.unsafe(nil)); end
-
-  protected
-
-  def compare_and_set_state(next_state, *expected_current); end
-  def event; end
-  def get_arguments_from(opts = T.unsafe(nil)); end
-  def if_state(*expected_states); end
-  def init_obligation; end
-  def ns_check_state?(expected); end
-  def ns_set_state(value); end
-  def set_state(success, value, reason); end
-  def state=(value); end
-end
-
-module Concurrent::Concern::Observable
-  def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
-  def count_observers; end
-  def delete_observer(observer); end
-  def delete_observers; end
-  def with_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
-
-  protected
-
-  def observers; end
-  def observers=(_arg0); end
-end
-
-class Concurrent::ConcurrentUpdateError < ::ThreadError; end
-Concurrent::ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE = T.let(T.unsafe(nil), Array)
-class Concurrent::ConfigurationError < ::Concurrent::Error; end
-class Concurrent::CountDownLatch < ::Concurrent::MutexCountDownLatch; end
-Concurrent::CountDownLatchImplementation = Concurrent::MutexCountDownLatch
-
-class Concurrent::CyclicBarrier < ::Concurrent::Synchronization::LockableObject
-  def initialize(parties, &block); end
-
-  def broken?; end
-  def number_waiting; end
-  def parties; end
-  def reset; end
-  def wait(timeout = T.unsafe(nil)); end
-
-  protected
-
-  def ns_generation_done(generation, status, continue = T.unsafe(nil)); end
-  def ns_initialize(parties, &block); end
-  def ns_next_generation; end
-end
-
-class Concurrent::CyclicBarrier::Generation < ::Struct
-  def status; end
-  def status=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class Concurrent::Delay < ::Concurrent::Synchronization::LockableObject
-  include ::Concurrent::Concern::Dereferenceable
-  include ::Concurrent::Concern::Obligation
-
-  def initialize(opts = T.unsafe(nil), &block); end
-
-  def reconfigure(&block); end
-  def value(timeout = T.unsafe(nil)); end
-  def value!(timeout = T.unsafe(nil)); end
-  def wait(timeout = T.unsafe(nil)); end
-
-  protected
-
-  def ns_initialize(opts, &block); end
-
-  private
-
-  def execute_task_once; end
-end
-
-class Concurrent::DependencyCounter
-  def initialize(count, &block); end
-
-  def update(time, value, reason); end
-end
-
-class Concurrent::Error < ::StandardError; end
-
-class Concurrent::Event < ::Concurrent::Synchronization::LockableObject
-  def initialize; end
-
-  def reset; end
-  def set; end
-  def set?; end
-  def try?; end
-  def wait(timeout = T.unsafe(nil)); end
-
-  protected
-
-  def ns_initialize; end
-  def ns_set; end
-end
-
-class Concurrent::Exchanger < ::Concurrent::RubyExchanger; end
-Concurrent::ExchangerImplementation = Concurrent::RubyExchanger
-
-module Concurrent::ExecutorService
-  include ::Logger::Severity
-  include ::Concurrent::Concern::Logging
-
-  def <<(task); end
-  def can_overflow?; end
-  def post(*args, &task); end
-  def serialized?; end
-end
-
-class Concurrent::FixedThreadPool < ::Concurrent::ThreadPoolExecutor
-  def initialize(num_threads, opts = T.unsafe(nil)); end
-end
-
-class Concurrent::Future < ::Concurrent::IVar
-  def initialize(opts = T.unsafe(nil), &block); end
-
-  def cancel; end
-  def cancelled?; end
-  def execute; end
-  def set(value = T.unsafe(nil), &block); end
-  def wait_or_cancel(timeout); end
-
-  protected
-
-  def ns_initialize(value, opts); end
-
-  class << self
-    def execute(opts = T.unsafe(nil), &block); end
-  end
-end
-
-Concurrent::GLOBAL_FAST_EXECUTOR = T.let(T.unsafe(nil), Concurrent::Delay)
-Concurrent::GLOBAL_IMMEDIATE_EXECUTOR = T.let(T.unsafe(nil), Concurrent::ImmediateExecutor)
-Concurrent::GLOBAL_IO_EXECUTOR = T.let(T.unsafe(nil), Concurrent::Delay)
-Concurrent::GLOBAL_LOGGER = T.let(T.unsafe(nil), Concurrent::AtomicReference)
-Concurrent::GLOBAL_TIMER_SET = T.let(T.unsafe(nil), Concurrent::Delay)
-class Concurrent::Hash < ::Hash; end
-Concurrent::HashImplementation = Hash
-
-class Concurrent::IVar < ::Concurrent::Synchronization::LockableObject
-  include ::Concurrent::Concern::Dereferenceable
-  include ::Concurrent::Concern::Obligation
-  include ::Concurrent::Concern::Observable
-
-  def initialize(value = T.unsafe(nil), opts = T.unsafe(nil), &block); end
-
-  def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
-  def fail(reason = T.unsafe(nil)); end
-  def set(value = T.unsafe(nil)); end
-  def try_set(value = T.unsafe(nil), &block); end
-
-  protected
-
-  def check_for_block_or_value!(block_given, value); end
-  def complete(success, value, reason); end
-  def complete_without_notification(success, value, reason); end
-  def notify_observers(value, reason); end
-  def ns_complete_without_notification(success, value, reason); end
-  def ns_initialize(value, opts); end
-  def safe_execute(task, args = T.unsafe(nil)); end
-end
-
-class Concurrent::IllegalOperationError < ::Concurrent::Error; end
-
-class Concurrent::ImmediateExecutor < ::Concurrent::AbstractExecutorService
-  include ::Concurrent::SerialExecutorService
-
-  def initialize; end
-
-  def <<(task); end
-  def kill; end
-  def post(*args, &task); end
-  def running?; end
-  def shutdown; end
-  def shutdown?; end
-  def shuttingdown?; end
-  def wait_for_termination(timeout = T.unsafe(nil)); end
-end
-
-class Concurrent::ImmutabilityError < ::Concurrent::Error; end
-
-module Concurrent::ImmutableStruct
-  include ::Concurrent::Synchronization::AbstractStruct
-
-  def ==(other); end
-  def [](member); end
-  def each(&block); end
-  def each_pair(&block); end
-  def inspect; end
-  def merge(other, &block); end
-  def select(&block); end
-  def to_a; end
-  def to_h; end
-  def to_s; end
-  def values; end
-  def values_at(*indexes); end
-
-  private
-
-  def initialize_copy(original); end
-
-  class << self
-    def included(base); end
-    def new(*args, &block); end
-  end
-end
-
-Concurrent::ImmutableStruct::FACTORY = T.let(T.unsafe(nil), T.untyped)
-
-class Concurrent::IndirectImmediateExecutor < ::Concurrent::ImmediateExecutor
-  def initialize; end
-
-  def post(*args, &task); end
-end
-
-class Concurrent::InitializationError < ::Concurrent::Error; end
-class Concurrent::LifecycleError < ::Concurrent::Error; end
-
-class Concurrent::LockFreeStack < ::Concurrent::Synchronization::Object
-  include ::Enumerable
-
-  def initialize(head = T.unsafe(nil)); end
-
-  def __initialize_atomic_fields__; end
-  def clear; end
-  def clear_each(&block); end
-  def clear_if(head); end
-  def compare_and_clear(head); end
-  def compare_and_pop(head); end
-  def compare_and_push(head, value); end
-  def each(head = T.unsafe(nil)); end
-  def empty?(head = T.unsafe(nil)); end
-  def inspect; end
-  def peek; end
-  def pop; end
-  def push(value); end
-  def replace_if(head, new_head); end
-  def to_s; end
-
-  private
-
-  def compare_and_set_head(expected, value); end
-  def head; end
-  def head=(value); end
-  def swap_head(value); end
-  def update_head(&block); end
-
-  class << self
-    def new(*args, &block); end
-    def of1(value); end
-    def of2(value1, value2); end
-  end
-end
-
-Concurrent::LockFreeStack::EMPTY = T.let(T.unsafe(nil), Concurrent::LockFreeStack::Node)
-
-class Concurrent::LockFreeStack::Node
-  def initialize(value, next_node); end
-
-  def next_node; end
-  def value; end
-  def value=(_arg0); end
-
-  class << self
-    def [](*_arg0); end
-  end
-end
-
-class Concurrent::MVar < ::Concurrent::Synchronization::Object
-  include ::Concurrent::Concern::Dereferenceable
-
-  def initialize(value = T.unsafe(nil), opts = T.unsafe(nil)); end
-
-  def borrow(timeout = T.unsafe(nil)); end
-  def empty?; end
-  def full?; end
-  def modify(timeout = T.unsafe(nil)); end
-  def modify!; end
-  def put(value, timeout = T.unsafe(nil)); end
-  def set!(value); end
-  def take(timeout = T.unsafe(nil)); end
-  def try_put!(value); end
-  def try_take!; end
-
-  protected
-
-  def synchronize(&block); end
-
-  private
-
-  def unlocked_empty?; end
-  def unlocked_full?; end
-  def wait_for_empty(timeout); end
-  def wait_for_full(timeout); end
-  def wait_while(condition, timeout); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-Concurrent::MVar::EMPTY = T.let(T.unsafe(nil), Object)
-Concurrent::MVar::TIMEOUT = T.let(T.unsafe(nil), Object)
-
-class Concurrent::Map < ::Concurrent::Collection::MriMapBackend
-  def initialize(options = T.unsafe(nil), &block); end
-
-  def [](key); end
-  def []=(key, value); end
-  def each; end
-  def each_key; end
-  def each_pair; end
-  def each_value; end
-  def empty?; end
-  def fetch(key, default_value = T.unsafe(nil)); end
-  def fetch_or_store(key, default_value = T.unsafe(nil)); end
-  def get(key); end
-  def inspect; end
-  def key(value); end
-  def keys; end
-  def marshal_dump; end
-  def marshal_load(hash); end
-  def put(key, value); end
-  def put_if_absent(key, value); end
-  def value?(value); end
-  def values; end
-
-  private
-
-  def initialize_copy(other); end
-  def populate_from(hash); end
-  def raise_fetch_no_key; end
-  def validate_options_hash!(options); end
-end
-
-class Concurrent::MaxRestartFrequencyError < ::Concurrent::Error; end
-
-class Concurrent::Maybe < ::Concurrent::Synchronization::Object
-  include ::Comparable
-
-  def initialize(just, nothing); end
-
-  def <=>(other); end
-  def fulfilled?; end
-  def just; end
-  def just?; end
-  def nothing; end
-  def nothing?; end
-  def or(other); end
-  def reason; end
-  def rejected?; end
-  def value; end
-
-  class << self
-    def from(*args); end
-    def just(value); end
-    def nothing(error = T.unsafe(nil)); end
-
-    private
-
-    def new(*args, &block); end
-  end
-end
-
-Concurrent::Maybe::NONE = T.let(T.unsafe(nil), Object)
-
-class Concurrent::MultipleAssignmentError < ::Concurrent::Error
-  def initialize(message = T.unsafe(nil), inspection_data = T.unsafe(nil)); end
-
-  def inspect; end
-  def inspection_data; end
-end
-
-class Concurrent::MultipleErrors < ::Concurrent::Error
-  def initialize(errors, message = T.unsafe(nil)); end
-
-  def errors; end
-end
-
-module Concurrent::MutableStruct
-  include ::Concurrent::Synchronization::AbstractStruct
-
-  def ==(other); end
-  def [](member); end
-  def []=(member, value); end
-  def each(&block); end
-  def each_pair(&block); end
-  def inspect; end
-  def merge(other, &block); end
-  def select(&block); end
-  def to_a; end
-  def to_h; end
-  def to_s; end
-  def values; end
-  def values_at(*indexes); end
-
-  private
-
-  def initialize_copy(original); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-Concurrent::MutableStruct::FACTORY = T.let(T.unsafe(nil), T.untyped)
-
-class Concurrent::MutexAtomicBoolean < ::Concurrent::Synchronization::LockableObject
-  def initialize(initial = T.unsafe(nil)); end
-
-  def false?; end
-  def make_false; end
-  def make_true; end
-  def true?; end
-  def value; end
-  def value=(value); end
-
-  protected
-
-  def ns_initialize(initial); end
-
-  private
-
-  def ns_make_value(value); end
-end
-
-class Concurrent::MutexAtomicFixnum < ::Concurrent::Synchronization::LockableObject
-  def initialize(initial = T.unsafe(nil)); end
-
-  def compare_and_set(expect, update); end
-  def decrement(delta = T.unsafe(nil)); end
-  def down(delta = T.unsafe(nil)); end
-  def increment(delta = T.unsafe(nil)); end
-  def up(delta = T.unsafe(nil)); end
-  def update; end
-  def value; end
-  def value=(value); end
-
-  protected
-
-  def ns_initialize(initial); end
-
-  private
-
-  def ns_set(value); end
-end
-
-class Concurrent::MutexAtomicReference < ::Concurrent::Synchronization::LockableObject
-  include ::Concurrent::AtomicDirectUpdate
-  include ::Concurrent::AtomicNumericCompareAndSetWrapper
-
-  def initialize(value = T.unsafe(nil)); end
-
-  def _compare_and_set(old_value, new_value); end
-  def compare_and_swap(old_value, new_value); end
-  def get; end
-  def get_and_set(new_value); end
-  def set(new_value); end
-  def swap(new_value); end
-  def value; end
-  def value=(new_value); end
-
-  protected
-
-  def ns_initialize(value); end
-end
-
-class Concurrent::MutexCountDownLatch < ::Concurrent::Synchronization::LockableObject
-  def initialize(count = T.unsafe(nil)); end
-
-  def count; end
-  def count_down; end
-  def wait(timeout = T.unsafe(nil)); end
-
-  protected
-
-  def ns_initialize(count); end
-end
-
-class Concurrent::MutexSemaphore < ::Concurrent::Synchronization::LockableObject
-  def initialize(count); end
-
-  def acquire(permits = T.unsafe(nil)); end
-  def available_permits; end
-  def drain_permits; end
-  def reduce_permits(reduction); end
-  def release(permits = T.unsafe(nil)); end
-  def try_acquire(permits = T.unsafe(nil), timeout = T.unsafe(nil)); end
-
-  protected
-
-  def ns_initialize(count); end
-
-  private
-
-  def try_acquire_now(permits); end
-  def try_acquire_timed(permits, timeout); end
-end
-
-Concurrent::NULL = T.let(T.unsafe(nil), Object)
-Concurrent::NULL_LOGGER = T.let(T.unsafe(nil), Proc)
-
-module Concurrent::Options
-  class << self
-    def executor(executor_identifier); end
-    def executor_from_options(opts = T.unsafe(nil)); end
-  end
-end
-
-class Concurrent::Promise < ::Concurrent::IVar
-  def initialize(opts = T.unsafe(nil), &block); end
-
-  def catch(&block); end
-  def execute; end
-  def fail(reason = T.unsafe(nil)); end
-  def flat_map(&block); end
-  def on_error(&block); end
-  def on_success(&block); end
-  def rescue(&block); end
-  def set(value = T.unsafe(nil), &block); end
-  def then(*args, &block); end
-  def zip(*others); end
-
-  protected
-
-  def complete(success, value, reason); end
-  def notify_child(child); end
-  def ns_initialize(value, opts); end
-  def on_fulfill(result); end
-  def on_reject(reason); end
-  def realize(task); end
-  def root?; end
-  def set_pending; end
-  def set_state!(success, value, reason); end
-  def synchronized_set_state!(success, value, reason); end
-
-  class << self
-    def aggregate(method, *promises); end
-    def all?(*promises); end
-    def any?(*promises); end
-    def execute(opts = T.unsafe(nil), &block); end
-    def fulfill(value, opts = T.unsafe(nil)); end
-    def reject(reason, opts = T.unsafe(nil)); end
-    def zip(*promises); end
-  end
-end
-
-class Concurrent::PromiseExecutionError < ::StandardError; end
-
-module Concurrent::Promises
-  extend ::Concurrent::Promises::FactoryMethods::Configuration
-  extend ::Concurrent::Promises::FactoryMethods
-end
-
-class Concurrent::Promises::AbstractAnyPromise < ::Concurrent::Promises::BlockedPromise; end
-
-class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization::Object
-  include ::Concurrent::Promises::InternalStates
-
-  def initialize(promise, default_executor); end
-
-  def __initialize_atomic_fields__; end
-  def add_callback_clear_delayed_node(node); end
-  def add_callback_notify_blocked(promise, index); end
-  def blocks; end
-  def callbacks; end
-  def chain(*args, &task); end
-  def chain_on(executor, *args, &task); end
-  def chain_resolvable(resolvable); end
-  def default_executor; end
-  def inspect; end
-  def internal_state; end
-  def on_resolution(*args, &callback); end
-  def on_resolution!(*args, &callback); end
-  def on_resolution_using(executor, *args, &callback); end
-  def pending?; end
-  def promise; end
-  def resolve_with(state, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
-  def resolved?; end
-  def state; end
-  def tangle(resolvable); end
-  def to_s; end
-  def touch; end
-  def touched?; end
-  def wait(timeout = T.unsafe(nil)); end
-  def waiting_threads; end
-  def with_default_executor(executor); end
-  def with_hidden_resolvable; end
-
-  private
-
-  def add_callback(method, *args); end
-  def async_callback_on_resolution(state, executor, args, callback); end
-  def call_callback(method, state, args); end
-  def call_callbacks(state); end
-  def callback_clear_delayed_node(state, node); end
-  def callback_notify_blocked(state, promise, index); end
-  def compare_and_set_internal_state(expected, value); end
-  def internal_state=(value); end
-  def swap_internal_state(value); end
-  def update_internal_state(&block); end
-  def wait_until_resolved(timeout); end
-  def with_async(executor, *args, &block); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-class Concurrent::Promises::AbstractFlatPromise < ::Concurrent::Promises::BlockedPromise
-  def initialize(delayed_because, blockers_count, event_or_future); end
-
-  def touch; end
-
-  private
-
-  def add_delayed_of(future); end
-  def on_resolvable(resolved_future, index); end
-  def resolvable?(countdown, future, index); end
-  def touched?; end
-end
-
-class Concurrent::Promises::AbstractPromise < ::Concurrent::Synchronization::Object
-  include ::Concurrent::Promises::InternalStates
-
-  def initialize(future); end
-
-  def default_executor; end
-  def delayed_because; end
-  def event; end
-  def future; end
-  def inspect; end
-  def state; end
-  def to_s; end
-  def touch; end
-
-  private
-
-  def evaluate_to(*args, block); end
-  def resolve_with(new_state, raise_on_reassign = T.unsafe(nil)); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-class Concurrent::Promises::AnyFulfilledFuturePromise < ::Concurrent::Promises::AnyResolvedFuturePromise
-  private
-
-  def resolvable?(countdown, future, index); end
-end
-
-class Concurrent::Promises::AnyResolvedEventPromise < ::Concurrent::Promises::AbstractAnyPromise
-  def initialize(delayed, blockers_count, default_executor); end
-
-  private
-
-  def on_resolvable(resolved_future, index); end
-  def resolvable?(countdown, future, index); end
-end
-
-class Concurrent::Promises::AnyResolvedFuturePromise < ::Concurrent::Promises::AbstractAnyPromise
-  def initialize(delayed, blockers_count, default_executor); end
-
-  private
-
-  def on_resolvable(resolved_future, index); end
-  def resolvable?(countdown, future, index); end
-end
-
-class Concurrent::Promises::BlockedPromise < ::Concurrent::Promises::InnerPromise
-  def initialize(delayed, blockers_count, future); end
-
-  def blocked_by; end
-  def delayed_because; end
-  def on_blocker_resolution(future, index); end
-  def touch; end
-
-  private
-
-  def clear_and_propagate_touch(stack_or_element = T.unsafe(nil)); end
-  def on_resolvable(resolved_future, index); end
-  def process_on_blocker_resolution(future, index); end
-  def resolvable?(countdown, future, index); end
-
-  class << self
-    def add_delayed(delayed1, delayed2); end
-    def new_blocked_by(blockers, *args, &block); end
-    def new_blocked_by1(blocker, *args, &block); end
-    def new_blocked_by2(blocker1, blocker2, *args, &block); end
-  end
-end
-
-class Concurrent::Promises::BlockedTaskPromise < ::Concurrent::Promises::BlockedPromise
-  def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
-
-  def executor; end
-end
-
-class Concurrent::Promises::ChainPromise < ::Concurrent::Promises::BlockedTaskPromise
-  private
-
-  def on_resolvable(resolved_future, index); end
-end
-
-class Concurrent::Promises::DelayPromise < ::Concurrent::Promises::InnerPromise
-  def initialize(default_executor); end
-
-  def delayed_because; end
-  def touch; end
-end
-
-class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture
-  def &(other); end
-  def any(event_or_future); end
-  def delay; end
-  def schedule(intended_time); end
-  def then(*args, &task); end
-  def to_event; end
-  def to_future; end
-  def with_default_executor(executor); end
-  def zip(other); end
-  def |(event_or_future); end
-
-  private
-
-  def callback_on_resolution(state, args, callback); end
-  def rejected_resolution(raise_on_reassign, state); end
-end
-
-class Concurrent::Promises::EventWrapperPromise < ::Concurrent::Promises::BlockedPromise
-  def initialize(delayed, blockers_count, default_executor); end
-
-  private
-
-  def on_resolvable(resolved_future, index); end
-end
-
-module Concurrent::Promises::FactoryMethods
-  include ::Concurrent::Promises::FactoryMethods::Configuration
-  extend ::Concurrent::ReInclude
-  extend ::Concurrent::Promises::FactoryMethods
-  extend ::Concurrent::Promises::FactoryMethods::Configuration
-
-  def any(*futures_and_or_events); end
-  def any_event(*futures_and_or_events); end
-  def any_event_on(default_executor, *futures_and_or_events); end
-  def any_fulfilled_future(*futures_and_or_events); end
-  def any_fulfilled_future_on(default_executor, *futures_and_or_events); end
-  def any_resolved_future(*futures_and_or_events); end
-  def any_resolved_future_on(default_executor, *futures_and_or_events); end
-  def delay(*args, &task); end
-  def delay_on(default_executor, *args, &task); end
-  def fulfilled_future(value, default_executor = T.unsafe(nil)); end
-  def future(*args, &task); end
-  def future_on(default_executor, *args, &task); end
-  def make_future(argument = T.unsafe(nil), default_executor = T.unsafe(nil)); end
-  def rejected_future(reason, default_executor = T.unsafe(nil)); end
-  def resolvable_event; end
-  def resolvable_event_on(default_executor = T.unsafe(nil)); end
-  def resolvable_future; end
-  def resolvable_future_on(default_executor = T.unsafe(nil)); end
-  def resolved_event(default_executor = T.unsafe(nil)); end
-  def resolved_future(fulfilled, value, reason, default_executor = T.unsafe(nil)); end
-  def schedule(intended_time, *args, &task); end
-  def schedule_on(default_executor, intended_time, *args, &task); end
-  def zip(*futures_and_or_events); end
-  def zip_events(*futures_and_or_events); end
-  def zip_events_on(default_executor, *futures_and_or_events); end
-  def zip_futures(*futures_and_or_events); end
-  def zip_futures_on(default_executor, *futures_and_or_events); end
-end
-
-module Concurrent::Promises::FactoryMethods::Configuration
-  def default_executor; end
-end
-
-class Concurrent::Promises::FlatEventPromise < ::Concurrent::Promises::AbstractFlatPromise
-  def initialize(delayed, blockers_count, default_executor); end
-
-  private
-
-  def process_on_blocker_resolution(future, index); end
-end
-
-class Concurrent::Promises::FlatFuturePromise < ::Concurrent::Promises::AbstractFlatPromise
-  def initialize(delayed, blockers_count, levels, default_executor); end
-
-  private
-
-  def process_on_blocker_resolution(future, index); end
-end
-
-class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
-  def &(other); end
-  def any(event_or_future); end
-  def apply(args, block); end
-  def delay; end
-  def exception(*args); end
-  def flat(level = T.unsafe(nil)); end
-  def flat_event; end
-  def flat_future(level = T.unsafe(nil)); end
-  def fulfilled?; end
-  def inspect; end
-  def on_fulfillment(*args, &callback); end
-  def on_fulfillment!(*args, &callback); end
-  def on_fulfillment_using(executor, *args, &callback); end
-  def on_rejection(*args, &callback); end
-  def on_rejection!(*args, &callback); end
-  def on_rejection_using(executor, *args, &callback); end
-  def reason(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
-  def rejected?; end
-  def rescue(*args, &task); end
-  def rescue_on(executor, *args, &task); end
-  def result(timeout = T.unsafe(nil)); end
-  def run(run_test = T.unsafe(nil)); end
-  def schedule(intended_time); end
-  def then(*args, &task); end
-  def then_on(executor, *args, &task); end
-  def to_event; end
-  def to_future; end
-  def to_s; end
-  def value(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
-  def value!(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
-  def wait!(timeout = T.unsafe(nil)); end
-  def with_default_executor(executor); end
-  def zip(other); end
-  def |(event_or_future); end
-
-  private
-
-  def async_callback_on_fulfillment(state, executor, args, callback); end
-  def async_callback_on_rejection(state, executor, args, callback); end
-  def callback_on_fulfillment(state, args, callback); end
-  def callback_on_rejection(state, args, callback); end
-  def callback_on_resolution(state, args, callback); end
-  def rejected_resolution(raise_on_reassign, state); end
-  def run_test(v); end
-  def wait_until_resolved!(timeout = T.unsafe(nil)); end
-end
-
-class Concurrent::Promises::FutureWrapperPromise < ::Concurrent::Promises::BlockedPromise
-  def initialize(delayed, blockers_count, default_executor); end
-
-  private
-
-  def on_resolvable(resolved_future, index); end
-end
-
-class Concurrent::Promises::ImmediateEventPromise < ::Concurrent::Promises::InnerPromise
-  def initialize(default_executor); end
-end
-
-class Concurrent::Promises::ImmediateFuturePromise < ::Concurrent::Promises::InnerPromise
-  def initialize(default_executor, fulfilled, value, reason); end
-end
-
-class Concurrent::Promises::InnerPromise < ::Concurrent::Promises::AbstractPromise; end
-module Concurrent::Promises::InternalStates; end
-
-class Concurrent::Promises::InternalStates::Fulfilled < ::Concurrent::Promises::InternalStates::ResolvedWithResult
-  def initialize(value); end
-
-  def apply(args, block); end
-  def fulfilled?; end
-  def reason; end
-  def to_sym; end
-  def value; end
-end
-
-class Concurrent::Promises::InternalStates::FulfilledArray < ::Concurrent::Promises::InternalStates::Fulfilled
-  def apply(args, block); end
-end
-
-Concurrent::Promises::InternalStates::PENDING = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Pending)
-
-class Concurrent::Promises::InternalStates::PartiallyRejected < ::Concurrent::Promises::InternalStates::ResolvedWithResult
-  def initialize(value, reason); end
-
-  def apply(args, block); end
-  def fulfilled?; end
-  def reason; end
-  def to_sym; end
-  def value; end
-end
-
-class Concurrent::Promises::InternalStates::Pending < ::Concurrent::Promises::InternalStates::State
-  def resolved?; end
-  def to_sym; end
-end
-
-Concurrent::Promises::InternalStates::RESERVED = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Reserved)
-Concurrent::Promises::InternalStates::RESOLVED = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Fulfilled)
-
-class Concurrent::Promises::InternalStates::Rejected < ::Concurrent::Promises::InternalStates::ResolvedWithResult
-  def initialize(reason); end
-
-  def apply(args, block); end
-  def fulfilled?; end
-  def reason; end
-  def to_sym; end
-  def value; end
-end
-
-class Concurrent::Promises::InternalStates::Reserved < ::Concurrent::Promises::InternalStates::Pending; end
-
-class Concurrent::Promises::InternalStates::ResolvedWithResult < ::Concurrent::Promises::InternalStates::State
-  def apply; end
-  def fulfilled?; end
-  def reason; end
-  def resolved?; end
-  def result; end
-  def to_sym; end
-  def value; end
-end
-
-class Concurrent::Promises::InternalStates::State
-  def resolved?; end
-  def to_sym; end
-end
-
-class Concurrent::Promises::RescuePromise < ::Concurrent::Promises::BlockedTaskPromise
-  def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
-
-  private
-
-  def on_resolvable(resolved_future, index); end
-end
-
-module Concurrent::Promises::Resolvable
-  include ::Concurrent::Promises::InternalStates
-end
-
-class Concurrent::Promises::ResolvableEvent < ::Concurrent::Promises::Event
-  include ::Concurrent::Promises::Resolvable
-
-  def resolve(raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
-  def wait(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
-  def with_hidden_resolvable; end
-end
-
-class Concurrent::Promises::ResolvableEventPromise < ::Concurrent::Promises::AbstractPromise
-  def initialize(default_executor); end
-end
-
-class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
-  include ::Concurrent::Promises::Resolvable
-
-  def evaluate_to(*args, &block); end
-  def evaluate_to!(*args, &block); end
-  def fulfill(value, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
-  def reason(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
-  def reject(reason, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
-  def resolve(fulfilled = T.unsafe(nil), value = T.unsafe(nil), reason = T.unsafe(nil), raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
-  def result(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
-  def value(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
-  def value!(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
-  def wait(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
-  def wait!(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
-  def with_hidden_resolvable; end
-end
-
-class Concurrent::Promises::ResolvableFuturePromise < ::Concurrent::Promises::AbstractPromise
-  def initialize(default_executor); end
-end
-
-class Concurrent::Promises::RunFuturePromise < ::Concurrent::Promises::AbstractFlatPromise
-  def initialize(delayed, blockers_count, default_executor, run_test); end
-
-  private
-
-  def process_on_blocker_resolution(future, index); end
-end
-
-class Concurrent::Promises::ScheduledPromise < ::Concurrent::Promises::InnerPromise
-  def initialize(default_executor, intended_time); end
-
-  def inspect; end
-  def intended_time; end
-end
-
-class Concurrent::Promises::ThenPromise < ::Concurrent::Promises::BlockedTaskPromise
-  def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
-
-  private
-
-  def on_resolvable(resolved_future, index); end
-end
-
-class Concurrent::Promises::ZipEventEventPromise < ::Concurrent::Promises::BlockedPromise
-  def initialize(delayed, blockers_count, default_executor); end
-
-  private
-
-  def on_resolvable(resolved_future, index); end
-end
-
-class Concurrent::Promises::ZipEventsPromise < ::Concurrent::Promises::BlockedPromise
-  def initialize(delayed, blockers_count, default_executor); end
-
-  private
-
-  def on_resolvable(resolved_future, index); end
-end
-
-class Concurrent::Promises::ZipFutureEventPromise < ::Concurrent::Promises::BlockedPromise
-  def initialize(delayed, blockers_count, default_executor); end
-
-  private
-
-  def on_resolvable(resolved_future, index); end
-  def process_on_blocker_resolution(future, index); end
-end
-
-class Concurrent::Promises::ZipFuturesPromise < ::Concurrent::Promises::BlockedPromise
-  def initialize(delayed, blockers_count, default_executor); end
-
-  private
-
-  def on_resolvable(resolved_future, index); end
-  def process_on_blocker_resolution(future, index); end
-end
-
-module Concurrent::ReInclude
-  def extended(base); end
-  def include(*modules); end
-  def included(base); end
-end
-
-class Concurrent::ReadWriteLock < ::Concurrent::Synchronization::Object
-  def initialize; end
-
-  def acquire_read_lock; end
-  def acquire_write_lock; end
-  def has_waiters?; end
-  def release_read_lock; end
-  def release_write_lock; end
-  def with_read_lock; end
-  def with_write_lock; end
-  def write_locked?; end
-
-  private
-
-  def max_readers?(c = T.unsafe(nil)); end
-  def max_writers?(c = T.unsafe(nil)); end
-  def running_readers(c = T.unsafe(nil)); end
-  def running_readers?(c = T.unsafe(nil)); end
-  def running_writer?(c = T.unsafe(nil)); end
-  def waiting_writer?(c = T.unsafe(nil)); end
-  def waiting_writers(c = T.unsafe(nil)); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-Concurrent::ReadWriteLock::MAX_READERS = T.let(T.unsafe(nil), Integer)
-Concurrent::ReadWriteLock::MAX_WRITERS = T.let(T.unsafe(nil), Integer)
-Concurrent::ReadWriteLock::RUNNING_WRITER = T.let(T.unsafe(nil), Integer)
-Concurrent::ReadWriteLock::WAITING_WRITER = T.let(T.unsafe(nil), Integer)
-
-class Concurrent::ReentrantReadWriteLock < ::Concurrent::Synchronization::Object
-  def initialize; end
-
-  def acquire_read_lock; end
-  def acquire_write_lock; end
-  def release_read_lock; end
-  def release_write_lock; end
-  def try_read_lock; end
-  def try_write_lock; end
-  def with_read_lock; end
-  def with_write_lock; end
-
-  private
-
-  def max_readers?(c = T.unsafe(nil)); end
-  def max_writers?(c = T.unsafe(nil)); end
-  def running_readers(c = T.unsafe(nil)); end
-  def running_readers?(c = T.unsafe(nil)); end
-  def running_writer?(c = T.unsafe(nil)); end
-  def waiting_or_running_writer?(c = T.unsafe(nil)); end
-  def waiting_writers(c = T.unsafe(nil)); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-Concurrent::ReentrantReadWriteLock::MAX_READERS = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::MAX_WRITERS = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::READER_BITS = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::READ_LOCK_MASK = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::RUNNING_WRITER = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::WAITING_WRITER = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::WRITER_BITS = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::WRITE_LOCK_HELD = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::WRITE_LOCK_MASK = T.let(T.unsafe(nil), Integer)
-class Concurrent::RejectedExecutionError < ::Concurrent::Error; end
-class Concurrent::ResourceLimitError < ::Concurrent::Error; end
-
-class Concurrent::RubyExchanger < ::Concurrent::AbstractExchanger
-  def initialize; end
-
-  def __initialize_atomic_fields__; end
-  def compare_and_set_slot(expected, value); end
-  def slot; end
-  def slot=(value); end
-  def swap_slot(value); end
-  def update_slot(&block); end
-
-  private
-
-  def do_exchange(value, timeout); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-class Concurrent::RubyExchanger::Node < ::Concurrent::Synchronization::Object
-  def initialize(item); end
-
-  def __initialize_atomic_fields__; end
-  def compare_and_set_value(expected, value); end
-  def item; end
-  def latch; end
-  def swap_value(value); end
-  def update_value(&block); end
-  def value; end
-  def value=(value); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-class Concurrent::RubyExecutorService < ::Concurrent::AbstractExecutorService
-  def initialize(*args, &block); end
-
-  def kill; end
-  def post(*args, &task); end
-  def shutdown; end
-  def wait_for_termination(timeout = T.unsafe(nil)); end
-
-  private
-
-  def ns_running?; end
-  def ns_shutdown?; end
-  def ns_shutdown_execution; end
-  def ns_shuttingdown?; end
-  def stop_event; end
-  def stopped_event; end
-end
-
-class Concurrent::RubySingleThreadExecutor < ::Concurrent::RubyThreadPoolExecutor
-  def initialize(opts = T.unsafe(nil)); end
-end
-
-class Concurrent::RubyThreadLocalVar < ::Concurrent::AbstractThreadLocalVar
-  def value; end
-  def value=(value); end
-
-  protected
-
-  def allocate_storage; end
-
-  private
-
-  def get_default; end
-  def get_threadlocal_array(thread = T.unsafe(nil)); end
-  def next_index; end
-  def set_threadlocal_array(array, thread = T.unsafe(nil)); end
-  def value_for(thread); end
-
-  class << self
-    def semi_sync(&block); end
-    def thread_finalizer(id); end
-    def thread_local_finalizer(index); end
-  end
-end
-
-Concurrent::RubyThreadLocalVar::FREE = T.let(T.unsafe(nil), Array)
-Concurrent::RubyThreadLocalVar::LOCK = T.let(T.unsafe(nil), Thread::Mutex)
-Concurrent::RubyThreadLocalVar::THREAD_LOCAL_ARRAYS = T.let(T.unsafe(nil), Hash)
-
-class Concurrent::RubyThreadPoolExecutor < ::Concurrent::RubyExecutorService
-  def initialize(opts = T.unsafe(nil)); end
-
-  def can_overflow?; end
-  def completed_task_count; end
-  def idletime; end
-  def largest_length; end
-  def length; end
-  def max_length; end
-  def max_queue; end
-  def min_length; end
-  def prune_pool; end
-  def queue_length; end
-  def ready_worker(worker, last_message); end
-  def remaining_capacity; end
-  def remove_busy_worker(worker); end
-  def scheduled_task_count; end
-  def synchronous; end
-  def worker_died(worker); end
-  def worker_task_completed; end
-
-  private
-
-  def ns_add_busy_worker; end
-  def ns_assign_worker(*args, &task); end
-  def ns_enqueue(*args, &task); end
-  def ns_execute(*args, &task); end
-  def ns_initialize(opts); end
-  def ns_kill_execution; end
-  def ns_limited_queue?; end
-  def ns_prune_pool; end
-  def ns_ready_worker(worker, last_message, success = T.unsafe(nil)); end
-  def ns_remove_busy_worker(worker); end
-  def ns_reset_if_forked; end
-  def ns_shutdown_execution; end
-  def ns_worker_died(worker); end
-end
-
-Concurrent::RubyThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE = T.let(T.unsafe(nil), Integer)
-Concurrent::RubyThreadPoolExecutor::DEFAULT_MAX_QUEUE_SIZE = T.let(T.unsafe(nil), Integer)
-Concurrent::RubyThreadPoolExecutor::DEFAULT_MIN_POOL_SIZE = T.let(T.unsafe(nil), Integer)
-Concurrent::RubyThreadPoolExecutor::DEFAULT_THREAD_IDLETIMEOUT = T.let(T.unsafe(nil), Integer)
-
-class Concurrent::RubyThreadPoolExecutor::Worker
-  include ::Logger::Severity
-  include ::Concurrent::Concern::Logging
-
-  def initialize(pool, id); end
-
-  def <<(message); end
-  def kill; end
-  def stop; end
-
-  private
-
-  def create_worker(queue, pool, idletime); end
-  def run_task(pool, task, args); end
-end
-
-class Concurrent::SafeTaskExecutor < ::Concurrent::Synchronization::LockableObject
-  def initialize(task, opts = T.unsafe(nil)); end
-
-  def execute(*args); end
-end
-
-class Concurrent::ScheduledTask < ::Concurrent::IVar
-  include ::Comparable
-
-  def initialize(delay, opts = T.unsafe(nil), &task); end
-
-  def <=>(other); end
-  def cancel; end
-  def cancelled?; end
-  def execute; end
-  def executor; end
-  def initial_delay; end
-  def process_task; end
-  def processing?; end
-  def reschedule(delay); end
-  def reset; end
-  def schedule_time; end
-
-  protected
-
-  def ns_reschedule(delay); end
-  def ns_schedule(delay); end
-
-  class << self
-    def execute(delay, opts = T.unsafe(nil), &task); end
-  end
-end
-
-class Concurrent::Semaphore < ::Concurrent::MutexSemaphore; end
-Concurrent::SemaphoreImplementation = Concurrent::MutexSemaphore
-
-module Concurrent::SerialExecutorService
-  include ::Logger::Severity
-  include ::Concurrent::Concern::Logging
-  include ::Concurrent::ExecutorService
-
-  def serialized?; end
-end
-
-class Concurrent::SerializedExecution < ::Concurrent::Synchronization::LockableObject
-  include ::Logger::Severity
-  include ::Concurrent::Concern::Logging
-
-  def initialize; end
-
-  def post(executor, *args, &task); end
-  def posts(posts); end
-
-  private
-
-  def call_job(job); end
-  def ns_initialize; end
-  def work(job); end
-end
-
-class Concurrent::SerializedExecution::Job < ::Struct
-  def args; end
-  def args=(_); end
-  def block; end
-  def block=(_); end
-  def call; end
-  def executor; end
-  def executor=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class Concurrent::SerializedExecutionDelegator < ::SimpleDelegator
-  include ::Logger::Severity
-  include ::Concurrent::Concern::Logging
-  include ::Concurrent::ExecutorService
-  include ::Concurrent::SerialExecutorService
-
-  def initialize(executor); end
-
-  def post(*args, &task); end
-end
-
-class Concurrent::Set < ::Concurrent::CRubySet; end
-Concurrent::SetImplementation = Concurrent::CRubySet
-
-module Concurrent::SettableStruct
-  include ::Concurrent::Synchronization::AbstractStruct
-
-  def ==(other); end
-  def [](member); end
-  def []=(member, value); end
-  def each(&block); end
-  def each_pair(&block); end
-  def inspect; end
-  def merge(other, &block); end
-  def select(&block); end
-  def to_a; end
-  def to_h; end
-  def to_s; end
-  def values; end
-  def values_at(*indexes); end
-
-  private
-
-  def initialize_copy(original); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-Concurrent::SettableStruct::FACTORY = T.let(T.unsafe(nil), T.untyped)
-
-class Concurrent::SimpleExecutorService < ::Concurrent::RubyExecutorService
-  def <<(task); end
-  def kill; end
-  def post(*args, &task); end
-  def running?; end
-  def shutdown; end
-  def shutdown?; end
-  def shuttingdown?; end
-  def wait_for_termination(timeout = T.unsafe(nil)); end
-
-  private
-
-  def ns_initialize(*args); end
-
-  class << self
-    def <<(task); end
-    def post(*args); end
-  end
-end
-
-class Concurrent::SingleThreadExecutor < ::Concurrent::RubySingleThreadExecutor; end
-Concurrent::SingleThreadExecutorImplementation = Concurrent::RubySingleThreadExecutor
-module Concurrent::Synchronization; end
-
-class Concurrent::Synchronization::AbstractLockableObject < ::Concurrent::Synchronization::Object
-  protected
-
-  def ns_broadcast; end
-  def ns_signal; end
-  def ns_wait(timeout = T.unsafe(nil)); end
-  def ns_wait_until(timeout = T.unsafe(nil), &condition); end
-  def synchronize; end
-end
-
-class Concurrent::Synchronization::AbstractObject
-  def initialize; end
-
-  def full_memory_barrier; end
-
-  class << self
-    def attr_volatile(*names); end
-  end
-end
-
-module Concurrent::Synchronization::AbstractStruct
-  def initialize(*values); end
-
-  def length; end
-  def members; end
-  def size; end
-
-  protected
-
-  def ns_each; end
-  def ns_each_pair; end
-  def ns_equality(other); end
-  def ns_get(member); end
-  def ns_initialize_copy; end
-  def ns_inspect; end
-  def ns_merge(other, &block); end
-  def ns_select; end
-  def ns_to_h; end
-  def ns_values; end
-  def ns_values_at(indexes); end
-  def pr_underscore(clazz); end
-
-  class << self
-    def define_struct_class(parent, base, name, members, &block); end
-  end
-end
-
-class Concurrent::Synchronization::Condition < ::Concurrent::Synchronization::LockableObject
-  def initialize(lock); end
-
-  def broadcast; end
-  def ns_broadcast; end
-  def ns_signal; end
-  def ns_wait(timeout = T.unsafe(nil)); end
-  def ns_wait_until(timeout = T.unsafe(nil), &condition); end
-  def signal; end
-  def wait(timeout = T.unsafe(nil)); end
-  def wait_until(timeout = T.unsafe(nil), &condition); end
-
-  class << self
-    def private_new(*args, &block); end
-  end
-end
-
-module Concurrent::Synchronization::ConditionSignalling
-  protected
-
-  def ns_broadcast; end
-  def ns_signal; end
-end
-
-class Concurrent::Synchronization::Lock < ::Concurrent::Synchronization::LockableObject
-  def broadcast; end
-  def signal; end
-  def wait(timeout = T.unsafe(nil)); end
-  def wait_until(timeout = T.unsafe(nil), &condition); end
-end
-
-class Concurrent::Synchronization::LockableObject < ::Concurrent::Synchronization::MutexLockableObject
-  def new_condition; end
-end
-
-Concurrent::Synchronization::LockableObjectImplementation = Concurrent::Synchronization::MutexLockableObject
-
-class Concurrent::Synchronization::MonitorLockableObject < ::Concurrent::Synchronization::AbstractLockableObject
-  include ::Concurrent::Synchronization::ConditionSignalling
-
-  def initialize(*defaults); end
-
-  protected
-
-  def ns_wait(timeout = T.unsafe(nil)); end
-  def synchronize; end
-
-  private
-
-  def initialize_copy(other); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-module Concurrent::Synchronization::MriAttrVolatile
-  mixes_in_class_methods ::Concurrent::Synchronization::MriAttrVolatile::ClassMethods
-
-  def full_memory_barrier; end
-
-  class << self
-    def included(base); end
-  end
-end
-
-module Concurrent::Synchronization::MriAttrVolatile::ClassMethods
-  def attr_volatile(*names); end
-end
-
-class Concurrent::Synchronization::MriObject < ::Concurrent::Synchronization::AbstractObject
-  include ::Concurrent::Synchronization::MriAttrVolatile
-  extend ::Concurrent::Synchronization::MriAttrVolatile::ClassMethods
-
-  def initialize; end
-end
-
-class Concurrent::Synchronization::MutexLockableObject < ::Concurrent::Synchronization::AbstractLockableObject
-  include ::Concurrent::Synchronization::ConditionSignalling
-
-  def initialize(*defaults); end
-
-  protected
-
-  def ns_wait(timeout = T.unsafe(nil)); end
-  def synchronize; end
-
-  private
-
-  def initialize_copy(other); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-class Concurrent::Synchronization::Object < ::Concurrent::Synchronization::MriObject
-  def initialize; end
-
-  private
-
-  def __initialize_atomic_fields__; end
-
-  class << self
-    def atomic_attribute?(name); end
-    def atomic_attributes(inherited = T.unsafe(nil)); end
-    def attr_atomic(*names); end
-    def ensure_safe_initialization_when_final_fields_are_present; end
-    def safe_initialization!; end
-    def safe_initialization?; end
-
-    private
-
-    def define_initialize_atomic_fields; end
-  end
-end
-
-Concurrent::Synchronization::ObjectImplementation = Concurrent::Synchronization::MriObject
-
-module Concurrent::Synchronization::RbxAttrVolatile
-  mixes_in_class_methods ::Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
-
-  def full_memory_barrier; end
-
-  class << self
-    def included(base); end
-  end
-end
-
-module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
-  def attr_volatile(*names); end
-end
-
-class Concurrent::Synchronization::RbxLockableObject < ::Concurrent::Synchronization::AbstractLockableObject
-  def initialize(*defaults); end
-
-  protected
-
-  def ns_broadcast; end
-  def ns_signal; end
-  def ns_wait(timeout = T.unsafe(nil)); end
-  def synchronize(&block); end
-
-  private
-
-  def initialize_copy(other); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-class Concurrent::Synchronization::RbxObject < ::Concurrent::Synchronization::AbstractObject
-  include ::Concurrent::Synchronization::RbxAttrVolatile
-  extend ::Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
-
-  def initialize; end
-end
-
-module Concurrent::Synchronization::TruffleRubyAttrVolatile
-  mixes_in_class_methods ::Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
-
-  def full_memory_barrier; end
-
-  class << self
-    def included(base); end
-  end
-end
-
-module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
-  def attr_volatile(*names); end
-end
-
-class Concurrent::Synchronization::TruffleRubyObject < ::Concurrent::Synchronization::AbstractObject
-  include ::Concurrent::Synchronization::TruffleRubyAttrVolatile
-  extend ::Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
-
-  def initialize; end
-end
-
-Concurrent::Synchronization::Volatile = Concurrent::Synchronization::MriAttrVolatile
-
-class Concurrent::SynchronizedDelegator < ::SimpleDelegator
-  def initialize(obj); end
-
-  def method_missing(method, *args, &block); end
-  def setup; end
-  def teardown; end
-end
-
-class Concurrent::TVar < ::Concurrent::Synchronization::Object
-  def initialize(value); end
-
-  def unsafe_lock; end
-  def unsafe_value; end
-  def unsafe_value=(value); end
-  def value; end
-  def value=(value); end
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-class Concurrent::ThreadLocalVar < ::Concurrent::RubyThreadLocalVar; end
-Concurrent::ThreadLocalVarImplementation = Concurrent::RubyThreadLocalVar
-class Concurrent::ThreadPoolExecutor < ::Concurrent::RubyThreadPoolExecutor; end
-Concurrent::ThreadPoolExecutorImplementation = Concurrent::RubyThreadPoolExecutor
-module Concurrent::ThreadSafe; end
-
-module Concurrent::ThreadSafe::Util
-  class << self
-    def make_synchronized_on_cruby(klass); end
-    def make_synchronized_on_rbx(klass); end
-    def make_synchronized_on_truffleruby(klass); end
-  end
-end
-
-Concurrent::ThreadSafe::Util::CPU_COUNT = T.let(T.unsafe(nil), Integer)
-Concurrent::ThreadSafe::Util::FIXNUM_BIT_SIZE = T.let(T.unsafe(nil), Integer)
-Concurrent::ThreadSafe::Util::MAX_INT = T.let(T.unsafe(nil), Integer)
-class Concurrent::TimeoutError < ::Concurrent::Error; end
-
-class Concurrent::TimerSet < ::Concurrent::RubyExecutorService
-  def initialize(opts = T.unsafe(nil)); end
-
-  def kill; end
-  def post(delay, *args, &task); end
-
-  private
-
-  def ns_initialize(opts); end
-  def ns_post_task(task); end
-  def ns_reset_if_forked; end
-  def ns_shutdown_execution; end
-  def post_task(task); end
-  def process_tasks; end
-  def remove_task(task); end
-end
-
-class Concurrent::TimerTask < ::Concurrent::RubyExecutorService
-  include ::Concurrent::Concern::Dereferenceable
-  include ::Concurrent::Concern::Observable
-
-  def initialize(opts = T.unsafe(nil), &task); end
-
-  def execute; end
-  def execution_interval; end
-  def execution_interval=(value); end
-  def running?; end
-  def timeout_interval; end
-  def timeout_interval=(value); end
-
-  private
-
-  def execute_task(completion); end
-  def ns_initialize(opts, &task); end
-  def ns_kill_execution; end
-  def ns_shutdown_execution; end
-  def schedule_next_task(interval = T.unsafe(nil)); end
-
-  class << self
-    def execute(opts = T.unsafe(nil), &task); end
-  end
-end
-
-Concurrent::TimerTask::EXECUTION_INTERVAL = T.let(T.unsafe(nil), Integer)
-Concurrent::TimerTask::TIMEOUT_INTERVAL = T.let(T.unsafe(nil), Integer)
-
-class Concurrent::Transaction
-  def initialize; end
-
-  def abort; end
-  def commit; end
-  def open(tvar); end
-  def read(tvar); end
-  def unlock; end
-  def write(tvar, value); end
-
-  class << self
-    def current; end
-    def current=(transaction); end
-  end
-end
-
-Concurrent::Transaction::ABORTED = T.let(T.unsafe(nil), Object)
-class Concurrent::Transaction::AbortError < ::StandardError; end
-class Concurrent::Transaction::LeaveError < ::StandardError; end
-
-class Concurrent::Transaction::OpenEntry < ::Struct
-  def modified; end
-  def modified=(_); end
-  def value; end
-  def value=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class Concurrent::Tuple
-  include ::Enumerable
-
-  def initialize(size); end
-
-  def cas(i, old_value, new_value); end
-  def compare_and_set(i, old_value, new_value); end
-  def each; end
-  def get(i); end
-  def set(i, value); end
-  def size; end
-  def volatile_get(i); end
-  def volatile_set(i, value); end
-end
-
-Concurrent::Tuple::Tuple = Array
-module Concurrent::Utility; end
-
-module Concurrent::Utility::EngineDetector
-  def on_cruby?; end
-  def on_jruby?; end
-  def on_jruby_9000?; end
-  def on_linux?; end
-  def on_osx?; end
-  def on_rbx?; end
-  def on_truffleruby?; end
-  def on_windows?; end
-  def ruby_engine; end
-  def ruby_version(version = T.unsafe(nil), comparison, major, minor, patch); end
-end
-
-module Concurrent::Utility::NativeExtensionLoader
-  def allow_c_extensions?; end
-  def c_extensions_loaded?; end
-  def java_extensions_loaded?; end
-  def load_native_extensions; end
-
-  private
-
-  def load_error_path(error); end
-  def set_c_extensions_loaded; end
-  def set_java_extensions_loaded; end
-  def try_load_c_extension(path); end
-end
-
-module Concurrent::Utility::NativeInteger
-  extend ::Concurrent::Utility::NativeInteger
-
-  def ensure_integer(value); end
-  def ensure_integer_and_bounds(value); end
-  def ensure_lower_bound(value); end
-  def ensure_positive(value); end
-  def ensure_positive_and_no_zero(value); end
-  def ensure_upper_bound(value); end
-end
-
-Concurrent::Utility::NativeInteger::MAX_VALUE = T.let(T.unsafe(nil), Integer)
-Concurrent::Utility::NativeInteger::MIN_VALUE = T.let(T.unsafe(nil), Integer)
-
-class Concurrent::Utility::ProcessorCounter
-  def initialize; end
-
-  def physical_processor_count; end
-  def processor_count; end
-
-  private
-
-  def compute_physical_processor_count; end
-  def compute_processor_count; end
-end
-
-Concurrent::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/concurrent-ruby@1.3.4.rbi b/Library/Homebrew/sorbet/rbi/gems/concurrent-ruby@1.3.4.rbi
new file mode 100644
index 0000000000000..7116a2c6d19e0
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/concurrent-ruby@1.3.4.rbi
@@ -0,0 +1,11645 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `concurrent-ruby` gem.
+# Please instead update this file by running `bin/tapioca gem concurrent-ruby`.
+
+
+# {include:file:README.md}
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/version.rb#1
+module Concurrent
+  extend ::Concurrent::Utility::EngineDetector
+  extend ::Concurrent::Utility::NativeExtensionLoader
+  extend ::Logger::Severity
+  extend ::Concurrent::Concern::Logging
+  extend ::Concurrent::Concern::Deprecation
+
+  private
+
+  # Abort a currently running transaction - see `Concurrent::atomically`.
+  #
+  # @raise [Transaction::AbortError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#139
+  def abort_transaction; end
+
+  # Run a block that reads and writes `TVar`s as a single atomic transaction.
+  # With respect to the value of `TVar` objects, the transaction is atomic, in
+  # that it either happens or it does not, consistent, in that the `TVar`
+  # objects involved will never enter an illegal state, and isolated, in that
+  # transactions never interfere with each other. You may recognise these
+  # properties from database transactions.
+  #
+  # There are some very important and unusual semantics that you must be aware of:
+  #
+  # * Most importantly, the block that you pass to atomically may be executed
+  #     more than once. In most cases your code should be free of
+  #     side-effects, except for via TVar.
+  #
+  # * If an exception escapes an atomically block it will abort the transaction.
+  #
+  # * It is undefined behaviour to use callcc or Fiber with atomically.
+  #
+  # * If you create a new thread within an atomically, it will not be part of
+  #     the transaction. Creating a thread counts as a side-effect.
+  #
+  # Transactions within transactions are flattened to a single transaction.
+  #
+  # @example
+  #   a = new TVar(100_000)
+  #   b = new TVar(100)
+  #
+  #   Concurrent::atomically do
+  #   a.value -= 10
+  #   b.value += 10
+  #   end
+  # @raise [ArgumentError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#82
+  def atomically; end
+
+  # @raise [ArgumentError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#56
+  def call_dataflow(method, executor, *inputs, &block); end
+
+  # Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
+  # {include:file:docs-source/dataflow.md}
+  #
+  # @param inputs [Future] zero or more `Future` operations that this dataflow depends upon
+  # @raise [ArgumentError] if no block is given
+  # @raise [ArgumentError] if any of the inputs are not `IVar`s
+  # @return [Object] the result of all the operations
+  # @yield The operation to perform once all the dependencies are met
+  # @yieldparam inputs [Future] each of the `Future` inputs to the dataflow
+  # @yieldreturn [Object] the result of the block operation
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#34
+  def dataflow(*inputs, &block); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#44
+  def dataflow!(*inputs, &block); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#39
+  def dataflow_with(executor, *inputs, &block); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#49
+  def dataflow_with!(executor, *inputs, &block); end
+
+  # Leave a transaction without committing or aborting - see `Concurrent::atomically`.
+  #
+  # @raise [Transaction::LeaveError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#144
+  def leave_transaction; end
+
+  # Returns the current time as tracked by the application monotonic clock.
+  #
+  # @param unit [Symbol] the time unit to be returned, can be either
+  #   :float_second, :float_millisecond, :float_microsecond, :second,
+  #   :millisecond, :microsecond, or :nanosecond default to :float_second.
+  # @return [Float] The current monotonic time since some unspecified
+  #   starting point
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/monotonic_time.rb#15
+  def monotonic_time(unit = T.unsafe(nil)); end
+
+  class << self
+    # Abort a currently running transaction - see `Concurrent::atomically`.
+    #
+    # @raise [Transaction::AbortError]
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#139
+    def abort_transaction; end
+
+    # Run a block that reads and writes `TVar`s as a single atomic transaction.
+    # With respect to the value of `TVar` objects, the transaction is atomic, in
+    # that it either happens or it does not, consistent, in that the `TVar`
+    # objects involved will never enter an illegal state, and isolated, in that
+    # transactions never interfere with each other. You may recognise these
+    # properties from database transactions.
+    #
+    # There are some very important and unusual semantics that you must be aware of:
+    #
+    # * Most importantly, the block that you pass to atomically may be executed
+    #     more than once. In most cases your code should be free of
+    #     side-effects, except for via TVar.
+    #
+    # * If an exception escapes an atomically block it will abort the transaction.
+    #
+    # * It is undefined behaviour to use callcc or Fiber with atomically.
+    #
+    # * If you create a new thread within an atomically, it will not be part of
+    #     the transaction. Creating a thread counts as a side-effect.
+    #
+    # Transactions within transactions are flattened to a single transaction.
+    #
+    # @example
+    #   a = new TVar(100_000)
+    #   b = new TVar(100)
+    #
+    #   Concurrent::atomically do
+    #   a.value -= 10
+    #   b.value += 10
+    #   end
+    # @raise [ArgumentError]
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#82
+    def atomically; end
+
+    # Number of processors cores available for process scheduling.
+    # This method takes in account the CPU quota if the process is inside a cgroup with a
+    # dedicated CPU quota (typically Docker).
+    # Otherwise it returns the same value as #processor_count but as a Float.
+    #
+    # For performance reasons the calculated value will be memoized on the first
+    # call.
+    #
+    # @return [Float] number of available processors
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#194
+    def available_processor_count; end
+
+    # @raise [ArgumentError]
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#56
+    def call_dataflow(method, executor, *inputs, &block); end
+
+    # The maximum number of processors cores available for process scheduling.
+    # Returns `nil` if there is no enforced limit, or a `Float` if the
+    # process is inside a cgroup with a dedicated CPU quota (typically Docker).
+    #
+    # Note that nothing prevents setting a CPU quota higher than the actual number of
+    # cores on the system.
+    #
+    # For performance reasons the calculated value will be memoized on the first
+    # call.
+    #
+    # @return [nil, Float] Maximum number of available processors as set by a cgroup CPU quota, or nil if none set
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#209
+    def cpu_quota; end
+
+    # The CPU shares requested by the process. For performance reasons the calculated
+    # value will be memoized on the first call.
+    #
+    # @return [Float, nil] CPU shares requested by the process, or nil if not set
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#217
+    def cpu_shares; end
+
+    # @return [Logger] Logger with provided level and output.
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#37
+    def create_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
+
+    # @deprecated
+    # @return [Logger] Logger with provided level and output.
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#69
+    def create_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
+
+    # Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
+    # {include:file:docs-source/dataflow.md}
+    #
+    # @param inputs [Future] zero or more `Future` operations that this dataflow depends upon
+    # @raise [ArgumentError] if no block is given
+    # @raise [ArgumentError] if any of the inputs are not `IVar`s
+    # @return [Object] the result of all the operations
+    # @yield The operation to perform once all the dependencies are met
+    # @yieldparam inputs [Future] each of the `Future` inputs to the dataflow
+    # @yieldreturn [Object] the result of the block operation
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#34
+    def dataflow(*inputs, &block); end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#44
+    def dataflow!(*inputs, &block); end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#39
+    def dataflow_with(executor, *inputs, &block); end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#49
+    def dataflow_with!(executor, *inputs, &block); end
+
+    # Disables AtExit handlers including pool auto-termination handlers.
+    # When disabled it will be the application programmer's responsibility
+    # to ensure that the handlers are shutdown properly prior to application
+    # exit by calling `AtExit.run` method.
+    #
+    # @deprecated Has no effect since it is no longer needed, see https://github.com/ruby-concurrency/concurrent-ruby/pull/841.
+    # @note this option should be needed only because of `at_exit` ordering
+    #   issues which may arise when running some of the testing frameworks.
+    #   E.g. Minitest's test-suite runs itself in `at_exit` callback which
+    #   executes after the pools are already terminated. Then auto termination
+    #   needs to be disabled and called manually after test-suite ends.
+    # @note This method should *never* be called
+    #   from within a gem. It should *only* be used from within the main
+    #   application and even then it should be used only when necessary.
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#48
+    def disable_at_exit_handlers!; end
+
+    # General access point to global executors.
+    #
+    # @param executor_identifier [Symbol, Executor] symbols:
+    #   - :fast - {Concurrent.global_fast_executor}
+    #   - :io - {Concurrent.global_io_executor}
+    #   - :immediate - {Concurrent.global_immediate_executor}
+    # @return [Executor]
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#83
+    def executor(executor_identifier); end
+
+    # Global thread pool optimized for short, fast *operations*.
+    #
+    # @return [ThreadPoolExecutor] the thread pool
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#55
+    def global_fast_executor; end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#66
+    def global_immediate_executor; end
+
+    # Global thread pool optimized for long, blocking (IO) *tasks*.
+    #
+    # @return [ThreadPoolExecutor] the thread pool
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#62
+    def global_io_executor; end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#109
+    def global_logger; end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#113
+    def global_logger=(value); end
+
+    # Global thread pool user for global *timers*.
+    #
+    # @return [Concurrent::TimerSet] the thread pool
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#73
+    def global_timer_set; end
+
+    # Leave a transaction without committing or aborting - see `Concurrent::atomically`.
+    #
+    # @raise [Transaction::LeaveError]
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#144
+    def leave_transaction; end
+
+    # Returns the current time as tracked by the application monotonic clock.
+    #
+    # @param unit [Symbol] the time unit to be returned, can be either
+    #   :float_second, :float_millisecond, :float_microsecond, :second,
+    #   :millisecond, :microsecond, or :nanosecond default to :float_second.
+    # @return [Float] The current monotonic time since some unspecified
+    #   starting point
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/monotonic_time.rb#15
+    def monotonic_time(unit = T.unsafe(nil)); end
+
+    # @return [Boolean]
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/lock_local_var.rb#7
+    def mutex_owned_per_thread?; end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#87
+    def new_fast_executor(opts = T.unsafe(nil)); end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#98
+    def new_io_executor(opts = T.unsafe(nil)); end
+
+    # Number of physical processor cores on the current system. For performance
+    # reasons the calculated value will be memoized on the first call.
+    #
+    # On Windows the Win32 API will be queried for the `NumberOfCores from
+    # Win32_Processor`. This will return the total number "of cores for the
+    # current instance of the processor." On Unix-like operating systems either
+    # the `hwprefs` or `sysctl` utility will be called in a subshell and the
+    # returned value will be used. In the rare case where none of these methods
+    # work or an exception is raised the function will simply return 1.
+    #
+    # @return [Integer] number physical processor cores on the current system
+    # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
+    # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
+    # @see http://www.unix.com/man-page/osx/1/HWPREFS/
+    # @see http://linux.die.net/man/8/sysctl
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#181
+    def physical_processor_count; end
+
+    # Number of processors seen by the OS and used for process scheduling. For
+    # performance reasons the calculated value will be memoized on the first
+    # call.
+    #
+    # When running under JRuby the Java runtime call
+    # `java.lang.Runtime.getRuntime.availableProcessors` will be used. According
+    # to the Java documentation this "value may change during a particular
+    # invocation of the virtual machine... [applications] should therefore
+    # occasionally poll this property." We still memoize this value once under
+    # JRuby.
+    #
+    # Otherwise Ruby's Etc.nprocessors will be used.
+    #
+    # @return [Integer] number of processors seen by the OS or Java runtime
+    # @see http://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html#availableProcessors()
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#160
+    def processor_count; end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#142
+    def processor_counter; end
+
+    # Use logger created by #create_simple_logger to log concurrent-ruby messages.
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#63
+    def use_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
+
+    # Use logger created by #create_stdlib_logger to log concurrent-ruby messages.
+    #
+    # @deprecated
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#96
+    def use_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
+  end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#38
+class Concurrent::AbstractExchanger < ::Concurrent::Synchronization::Object
+  # @return [AbstractExchanger] a new instance of AbstractExchanger
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#44
+  def initialize; end
+
+  # Waits for another thread to arrive at this exchange point (unless the
+  # current thread is interrupted), and then transfers the given object to
+  # it, receiving its object in return. The timeout value indicates the
+  # approximate number of seconds the method should block while waiting
+  # for the exchange. When the timeout value is `nil` the method will
+  # block indefinitely.
+  #
+  #
+  # In some edge cases when a `timeout` is given a return value of `nil` may be
+  # ambiguous. Specifically, if `nil` is a valid value in the exchange it will
+  # be impossible to tell whether `nil` is the actual return value or if it
+  # signifies timeout. When `nil` is a valid value in the exchange consider
+  # using {#exchange!} or {#try_exchange} instead.
+  #
+  # @param value [Object] the value to exchange with another thread
+  # @param timeout [Numeric, nil] in seconds, `nil` blocks indefinitely
+  # @return [Object] the value exchanged by the other thread or `nil` on timeout
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#69
+  def exchange(value, timeout = T.unsafe(nil)); end
+
+  # Waits for another thread to arrive at this exchange point (unless the
+  # current thread is interrupted), and then transfers the given object to
+  # it, receiving its object in return. The timeout value indicates the
+  # approximate number of seconds the method should block while waiting
+  # for the exchange. When the timeout value is `nil` the method will
+  # block indefinitely.
+  #
+  #
+  # On timeout a {Concurrent::TimeoutError} exception will be raised.
+  #
+  # @param value [Object] the value to exchange with another thread
+  # @param timeout [Numeric, nil] in seconds, `nil` blocks indefinitely
+  # @raise [Concurrent::TimeoutError] on timeout
+  # @return [Object] the value exchanged by the other thread
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#80
+  def exchange!(value, timeout = T.unsafe(nil)); end
+
+  # Waits for another thread to arrive at this exchange point (unless the
+  # current thread is interrupted), and then transfers the given object to
+  # it, receiving its object in return. The timeout value indicates the
+  # approximate number of seconds the method should block while waiting
+  # for the exchange. When the timeout value is `nil` the method will
+  # block indefinitely.
+  #
+  #
+  # The return value will be a {Concurrent::Maybe} set to `Just` on success or
+  # `Nothing` on timeout.
+  #
+  # @example
+  #
+  #   exchanger = Concurrent::Exchanger.new
+  #
+  #   result = exchanger.exchange(:foo, 0.5)
+  #
+  #   if result.just?
+  #   puts result.value #=> :bar
+  #   else
+  #   puts 'timeout'
+  #   end
+  # @param value [Object] the value to exchange with another thread
+  # @param timeout [Numeric, nil] in seconds, `nil` blocks indefinitely
+  # @return [Concurrent::Maybe] on success a `Just` maybe will be returned with
+  #   the item exchanged by the other thread as `#value`; on timeout a
+  #   `Nothing` maybe will be returned with {Concurrent::TimeoutError} as `#reason`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#109
+  def try_exchange(value, timeout = T.unsafe(nil)); end
+
+  private
+
+  # Waits for another thread to arrive at this exchange point (unless the
+  # current thread is interrupted), and then transfers the given object to
+  # it, receiving its object in return. The timeout value indicates the
+  # approximate number of seconds the method should block while waiting
+  # for the exchange. When the timeout value is `nil` the method will
+  # block indefinitely.
+  #
+  # @param value [Object] the value to exchange with another thread
+  # @param timeout [Numeric, nil] in seconds, `nil` blocks indefinitely
+  # @raise [NotImplementedError]
+  # @return [Object, CANCEL] the value exchanged by the other thread; {CANCEL} on timeout
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#122
+  def do_exchange(value, timeout); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#41
+Concurrent::AbstractExchanger::CANCEL = T.let(T.unsafe(nil), Object)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#10
+class Concurrent::AbstractExecutorService < ::Concurrent::Synchronization::LockableObject
+  include ::Logger::Severity
+  include ::Concurrent::Concern::Logging
+  include ::Concurrent::ExecutorService
+  include ::Concurrent::Concern::Deprecation
+
+  # Create a new thread pool.
+  #
+  # @return [AbstractExecutorService] a new instance of AbstractExecutorService
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#23
+  def initialize(opts = T.unsafe(nil), &block); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#72
+  def auto_terminate=(value); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#67
+  def auto_terminate?; end
+
+  # Returns the value of attribute fallback_policy.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#18
+  def fallback_policy; end
+
+  # @raise [NotImplementedError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#42
+  def kill; end
+
+  # Returns the value of attribute name.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#20
+  def name; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#52
+  def running?; end
+
+  # @raise [NotImplementedError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#37
+  def shutdown; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#62
+  def shutdown?; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#57
+  def shuttingdown?; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#32
+  def to_s; end
+
+  # @raise [NotImplementedError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#47
+  def wait_for_termination(timeout = T.unsafe(nil)); end
+
+  private
+
+  # Returns an action which executes the `fallback_policy` once the queue
+  # size reaches `max_queue`. The reason for the indirection of an action
+  # is so that the work can be deferred outside of synchronization.
+  #
+  # @param args [Array] the arguments to the task which is being handled.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#85
+  def fallback_action(*args); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#126
+  def ns_auto_terminate?; end
+
+  # @raise [NotImplementedError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#106
+  def ns_execute(*args, &task); end
+
+  # Callback method called when the executor has been killed.
+  # The default behavior is to do nothing.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#122
+  def ns_kill_execution; end
+
+  # Callback method called when an orderly shutdown has completed.
+  # The default behavior is to signal all waiting threads.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#114
+  def ns_shutdown_execution; end
+end
+
+# The set of possible fallback policies that may be set at thread pool creation.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#15
+Concurrent::AbstractExecutorService::FALLBACK_POLICIES = T.let(T.unsafe(nil), Array)
+
+# An abstract implementation of local storage, with sub-classes for
+# per-thread and per-fiber locals.
+#
+# Each execution context (EC, thread or fiber) has a lazily initialized array
+# of local variable values. Each time a new local variable is created, we
+# allocate an "index" for it.
+#
+# For example, if the allocated index is 1, that means slot #1 in EVERY EC's
+# locals array will be used for the value of that variable.
+#
+# The good thing about using a per-EC structure to hold values, rather than
+# a global, is that no synchronization is needed when reading and writing
+# those values (since the structure is only ever accessed by a single
+# thread).
+#
+# Of course, when a local variable is GC'd, 1) we need to recover its index
+# for use by other new local variables (otherwise the locals arrays could
+# get bigger and bigger with time), and 2) we need to null out all the
+# references held in the now-unused slots (both to avoid blocking GC of those
+# objects, and also to prevent "stale" values from being passed on to a new
+# local when the index is reused).
+#
+# Because we need to null out freed slots, we need to keep references to
+# ALL the locals arrays, so we can null out the appropriate slots in all of
+# them. This is why we need to use a finalizer to clean up the locals array
+# when the EC goes out of scope.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#35
+class Concurrent::AbstractLocals
+  # @return [AbstractLocals] a new instance of AbstractLocals
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#36
+  def initialize; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#89
+  def fetch(index); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#71
+  def free_index(index); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#55
+  def next_index(local); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#102
+  def set(index, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#43
+  def synchronize; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#48
+  def weak_synchronize; end
+
+  private
+
+  # When the local goes out of scope, clean up that slot across all locals currently assigned.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#112
+  def local_finalizer(index); end
+
+  # Returns the locals for the current scope, or nil if none exist.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#128
+  def locals; end
+
+  # Returns the locals for the current scope, creating them if necessary.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#133
+  def locals!; end
+
+  # When a thread/fiber goes out of scope, remove the array from @all_arrays.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#119
+  def thread_fiber_finalizer(array_object_id); end
+end
+
+# `Agent` is inspired by Clojure's [agent](http://clojure.org/agents)
+# function. An agent is a shared, mutable variable providing independent,
+# uncoordinated, *asynchronous* change of individual values. Best used when
+# the value will undergo frequent, complex updates. Suitable when the result
+# of an update does not need to be known immediately. `Agent` is (mostly)
+# functionally equivalent to Clojure's agent, except where the runtime
+# prevents parity.
+#
+# Agents are reactive, not autonomous - there is no imperative message loop
+# and no blocking receive. The state of an Agent should be itself immutable
+# and the `#value` of an Agent is always immediately available for reading by
+# any thread without any messages, i.e. observation does not require
+# cooperation or coordination.
+#
+# Agent action dispatches are made using the various `#send` methods. These
+# methods always return immediately. At some point later, in another thread,
+# the following will happen:
+#
+# 1. The given `action` will be applied to the state of the Agent and the
+#    `args`, if any were supplied.
+# 2. The return value of `action` will be passed to the validator lambda,
+#    if one has been set on the Agent.
+# 3. If the validator succeeds or if no validator was given, the return value
+#    of the given `action` will become the new `#value` of the Agent. See
+#    `#initialize` for details.
+# 4. If any observers were added to the Agent, they will be notified. See
+#    `#add_observer` for details.
+# 5. If during the `action` execution any other dispatches are made (directly
+#    or indirectly), they will be held until after the `#value` of the Agent
+#    has been changed.
+#
+# If any exceptions are thrown by an action function, no nested dispatches
+# will occur, and the exception will be cached in the Agent itself. When an
+# Agent has errors cached, any subsequent interactions will immediately throw
+# an exception, until the agent's errors are cleared. Agent errors can be
+# examined with `#error` and the agent restarted with `#restart`.
+#
+# The actions of all Agents get interleaved amongst threads in a thread pool.
+# At any point in time, at most one action for each Agent is being executed.
+# Actions dispatched to an agent from another single agent or thread will
+# occur in the order they were sent, potentially interleaved with actions
+# dispatched to the same agent from other sources. The `#send` method should
+# be used for actions that are CPU limited, while the `#send_off` method is
+# appropriate for actions that may block on IO.
+#
+# Unlike in Clojure, `Agent` cannot participate in `Concurrent::TVar` transactions.
+#
+# ## Example
+#
+# ```
+# def next_fibonacci(set = nil)
+#   return [0, 1] if set.nil?
+#   set + [set[-2..-1].reduce{|sum,x| sum + x }]
+# end
+#
+# # create an agent with an initial value
+# agent = Concurrent::Agent.new(next_fibonacci)
+#
+# # send a few update requests
+# 5.times do
+#   agent.send{|set| next_fibonacci(set) }
+# end
+#
+# # wait for them to complete
+# agent.await
+#
+# # get the current value
+# agent.value #=> [0, 1, 1, 2, 3, 5, 8]
+# ```
+#
+# ## Observation
+#
+# Agents support observers through the {Concurrent::Observable} mixin module.
+# Notification of observers occurs every time an action dispatch returns and
+# the new value is successfully validated. Observation will *not* occur if the
+# action raises an exception, if validation fails, or when a {#restart} occurs.
+#
+# When notified the observer will receive three arguments: `time`, `old_value`,
+# and `new_value`. The `time` argument is the time at which the value change
+# occurred. The `old_value` is the value of the Agent when the action began
+# processing. The `new_value` is the value to which the Agent was set when the
+# action completed. Note that `old_value` and `new_value` may be the same.
+# This is not an error. It simply means that the action returned the same
+# value.
+#
+# ## Nested Actions
+#
+# It is possible for an Agent action to post further actions back to itself.
+# The nested actions will be enqueued normally then processed *after* the
+# outer action completes, in the order they were sent, possibly interleaved
+# with action dispatches from other threads. Nested actions never deadlock
+# with one another and a failure in a nested action will never affect the
+# outer action.
+#
+# Nested actions can be called using the Agent reference from the enclosing
+# scope or by passing the reference in as a "send" argument. Nested actions
+# cannot be post using `self` from within the action block/proc/lambda; `self`
+# in this context will not reference the Agent. The preferred method for
+# dispatching nested actions is to pass the Agent as an argument. This allows
+# Ruby to more effectively manage the closing scope.
+#
+# Prefer this:
+#
+# ```
+# agent = Concurrent::Agent.new(0)
+# agent.send(agent) do |value, this|
+#   this.send {|v| v + 42 }
+#   3.14
+# end
+# agent.value #=> 45.14
+# ```
+#
+# Over this:
+#
+# ```
+# agent = Concurrent::Agent.new(0)
+# agent.send do |value|
+#   agent.send {|v| v + 42 }
+#   3.14
+# end
+# ```
+#
+#
+# **NOTE** Never, *under any circumstances*, call any of the "await" methods
+# ({#await}, {#await_for}, {#await_for!}, and {#wait}) from within an action
+# block/proc/lambda. The call will block the Agent and will always fail.
+# Calling either {#await} or {#wait} (with a timeout of `nil`) will
+# hopelessly deadlock the Agent with no possibility of recovery.
+#
+# @see http://clojure.org/Agents Clojure Agents
+# @see http://clojure.org/state Values and Change - Clojure's approach to Identity and State
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#145
+class Concurrent::Agent < ::Concurrent::Synchronization::LockableObject
+  include ::Concurrent::Concern::Observable
+
+  # Create a new `Agent` with the given initial value and options.
+  #
+  # The `:validator` option must be `nil` or a side-effect free proc/lambda
+  # which takes one argument. On any intended value change the validator, if
+  # provided, will be called. If the new value is invalid the validator should
+  # return `false` or raise an error.
+  #
+  # The `:error_handler` option must be `nil` or a proc/lambda which takes two
+  # arguments. When an action raises an error or validation fails, either by
+  # returning false or raising an error, the error handler will be called. The
+  # arguments to the error handler will be a reference to the agent itself and
+  # the error object which was raised.
+  #
+  # The `:error_mode` may be either `:continue` (the default if an error
+  # handler is given) or `:fail` (the default if error handler nil or not
+  # given).
+  #
+  # If an action being run by the agent throws an error or doesn't pass
+  # validation the error handler, if present, will be called. After the
+  # handler executes if the error mode is `:continue` the Agent will continue
+  # as if neither the action that caused the error nor the error itself ever
+  # happened.
+  #
+  # If the mode is `:fail` the Agent will become {#failed?} and will stop
+  # accepting new action dispatches. Any previously queued actions will be
+  # held until {#restart} is called. The {#value} method will still work,
+  # returning the value of the Agent before the error.
+  #
+  # @option opts
+  # @option opts
+  # @option opts
+  # @param initial [Object] the initial value
+  # @param opts [Hash] the configuration options
+  # @return [Agent] a new instance of Agent
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#220
+  def initialize(initial, opts = T.unsafe(nil)); end
+
+  # Dispatches an action to the Agent and returns immediately. Subsequently,
+  # in a thread from a thread pool, the {#value} will be set to the return
+  # value of the action. Appropriate for actions that may block on IO.
+  #
+  # @param action [Proc] the action dispatch to be enqueued
+  # @return [Concurrent::Agent] self
+  # @see #send_off
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#331
+  def <<(action); end
+
+  # Blocks the current thread (indefinitely!) until all actions dispatched
+  # thus far, from this thread or nested by the Agent, have occurred. Will
+  # block when {#failed?}. Will never return if a failed Agent is {#restart}
+  # with `:clear_actions` true.
+  #
+  # Returns a reference to `self` to support method chaining:
+  #
+  # ```
+  # current_value = agent.await.value
+  # ```
+  #
+  #
+  # **NOTE** Never, *under any circumstances*, call any of the "await" methods
+  # ({#await}, {#await_for}, {#await_for!}, and {#wait}) from within an action
+  # block/proc/lambda. The call will block the Agent and will always fail.
+  # Calling either {#await} or {#wait} (with a timeout of `nil`) will
+  # hopelessly deadlock the Agent with no possibility of recovery.
+  #
+  # @return [Boolean] self
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#350
+  def await; end
+
+  # Blocks the current thread until all actions dispatched thus far, from this
+  # thread or nested by the Agent, have occurred, or the timeout (in seconds)
+  # has elapsed.
+  #
+  #
+  # **NOTE** Never, *under any circumstances*, call any of the "await" methods
+  # ({#await}, {#await_for}, {#await_for!}, and {#wait}) from within an action
+  # block/proc/lambda. The call will block the Agent and will always fail.
+  # Calling either {#await} or {#wait} (with a timeout of `nil`) will
+  # hopelessly deadlock the Agent with no possibility of recovery.
+  #
+  # @param timeout [Float] the maximum number of seconds to wait
+  # @return [Boolean] true if all actions complete before timeout else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#363
+  def await_for(timeout); end
+
+  # Blocks the current thread until all actions dispatched thus far, from this
+  # thread or nested by the Agent, have occurred, or the timeout (in seconds)
+  # has elapsed.
+  #
+  #
+  # **NOTE** Never, *under any circumstances*, call any of the "await" methods
+  # ({#await}, {#await_for}, {#await_for!}, and {#wait}) from within an action
+  # block/proc/lambda. The call will block the Agent and will always fail.
+  # Calling either {#await} or {#wait} (with a timeout of `nil`) will
+  # hopelessly deadlock the Agent with no possibility of recovery.
+  #
+  # @param timeout [Float] the maximum number of seconds to wait
+  # @raise [Concurrent::TimeoutError] when timout is reached
+  # @return [Boolean] true if all actions complete before timeout
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#377
+  def await_for!(timeout); end
+
+  # The current value (state) of the Agent, irrespective of any pending or
+  # in-progress actions. The value is always available and is non-blocking.
+  #
+  # @return [Object] the current value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#229
+  def deref; end
+
+  # When {#failed?} and {#error_mode} is `:fail`, returns the error object
+  # which caused the failure, else `nil`. When {#error_mode} is `:continue`
+  # will *always* return `nil`.
+  #
+  # @return [nil, Error] the error which caused the failure when {#failed?}
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#240
+  def error; end
+
+  # The error mode this Agent is operating in. See {#initialize} for details.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#184
+  def error_mode; end
+
+  # Is the Agent in a failed state?
+  #
+  # @return [Boolean]
+  # @see #restart
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#402
+  def failed?; end
+
+  # Dispatches an action to the Agent and returns immediately. Subsequently,
+  # in a thread from a thread pool, the {#value} will be set to the return
+  # value of the action. Action dispatches are only allowed when the Agent
+  # is not {#failed?}.
+  #
+  # The action must be a block/proc/lambda which takes 1 or more arguments.
+  # The first argument is the current {#value} of the Agent. Any arguments
+  # passed to the send method via the `args` parameter will be passed to the
+  # action as the remaining arguments. The action must return the new value
+  # of the Agent.
+  #
+  # * {#send} and {#send!} should be used for actions that are CPU limited
+  # * {#send_off}, {#send_off!}, and {#<<} are appropriate for actions that
+  #   may block on IO
+  # * {#send_via} and {#send_via!} are used when a specific executor is to
+  #   be used for the action
+  #
+  # @param args [Array<Object>] zero or more arguments to be passed to
+  #   the action
+  # @param action [Proc] the action dispatch to be enqueued
+  # @return [Boolean] true if the action is successfully enqueued, false if
+  #   the Agent is {#failed?}
+  # @yield [agent, value, *args] process the old value and return the new
+  # @yieldparam value [Object] the current {#value} of the Agent
+  # @yieldparam args [Array<Object>] zero or more arguments to pass to the
+  #   action
+  # @yieldreturn [Object] the new value of the Agent
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#294
+  def post(*args, &action); end
+
+  # When {#failed?} and {#error_mode} is `:fail`, returns the error object
+  # which caused the failure, else `nil`. When {#error_mode} is `:continue`
+  # will *always* return `nil`.
+  #
+  # @return [nil, Error] the error which caused the failure when {#failed?}
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#240
+  def reason; end
+
+  # When an Agent is {#failed?}, changes the Agent {#value} to `new_value`
+  # then un-fails the Agent so that action dispatches are allowed again. If
+  # the `:clear_actions` option is give and true, any actions queued on the
+  # Agent that were being held while it was failed will be discarded,
+  # otherwise those held actions will proceed. The `new_value` must pass the
+  # validator if any, or `restart` will raise an exception and the Agent will
+  # remain failed with its old {#value} and {#error}. Observers, if any, will
+  # not be notified of the new state.
+  #
+  # @option opts
+  # @param new_value [Object] the new value for the Agent once restarted
+  # @param opts [Hash] the configuration options
+  # @raise [Concurrent:AgentError] when not failed
+  # @return [Boolean] true
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#424
+  def restart(new_value, opts = T.unsafe(nil)); end
+
+  # Dispatches an action to the Agent and returns immediately. Subsequently,
+  # in a thread from a thread pool, the {#value} will be set to the return
+  # value of the action. Action dispatches are only allowed when the Agent
+  # is not {#failed?}.
+  #
+  # The action must be a block/proc/lambda which takes 1 or more arguments.
+  # The first argument is the current {#value} of the Agent. Any arguments
+  # passed to the send method via the `args` parameter will be passed to the
+  # action as the remaining arguments. The action must return the new value
+  # of the Agent.
+  #
+  # * {#send} and {#send!} should be used for actions that are CPU limited
+  # * {#send_off}, {#send_off!}, and {#<<} are appropriate for actions that
+  #   may block on IO
+  # * {#send_via} and {#send_via!} are used when a specific executor is to
+  #   be used for the action
+  #
+  # @param args [Array<Object>] zero or more arguments to be passed to
+  #   the action
+  # @param action [Proc] the action dispatch to be enqueued
+  # @return [Boolean] true if the action is successfully enqueued, false if
+  #   the Agent is {#failed?}
+  # @yield [agent, value, *args] process the old value and return the new
+  # @yieldparam value [Object] the current {#value} of the Agent
+  # @yieldparam args [Array<Object>] zero or more arguments to pass to the
+  #   action
+  # @yieldreturn [Object] the new value of the Agent
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#278
+  def send(*args, &action); end
+
+  # Dispatches an action to the Agent and returns immediately. Subsequently,
+  # in a thread from a thread pool, the {#value} will be set to the return
+  # value of the action. Action dispatches are only allowed when the Agent
+  # is not {#failed?}.
+  #
+  # The action must be a block/proc/lambda which takes 1 or more arguments.
+  # The first argument is the current {#value} of the Agent. Any arguments
+  # passed to the send method via the `args` parameter will be passed to the
+  # action as the remaining arguments. The action must return the new value
+  # of the Agent.
+  #
+  # * {#send} and {#send!} should be used for actions that are CPU limited
+  # * {#send_off}, {#send_off!}, and {#<<} are appropriate for actions that
+  #   may block on IO
+  # * {#send_via} and {#send_via!} are used when a specific executor is to
+  #   be used for the action
+  #
+  # @param args [Array<Object>] zero or more arguments to be passed to
+  #   the action
+  # @param action [Proc] the action dispatch to be enqueued
+  # @raise [Concurrent::Agent::Error] if the Agent is {#failed?}
+  # @return [Boolean] true if the action is successfully enqueued
+  # @yield [agent, value, *args] process the old value and return the new
+  # @yieldparam value [Object] the current {#value} of the Agent
+  # @yieldparam args [Array<Object>] zero or more arguments to pass to the
+  #   action
+  # @yieldreturn [Object] the new value of the Agent
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#287
+  def send!(*args, &action); end
+
+  # Dispatches an action to the Agent and returns immediately. Subsequently,
+  # in a thread from a thread pool, the {#value} will be set to the return
+  # value of the action. Action dispatches are only allowed when the Agent
+  # is not {#failed?}.
+  #
+  # The action must be a block/proc/lambda which takes 1 or more arguments.
+  # The first argument is the current {#value} of the Agent. Any arguments
+  # passed to the send method via the `args` parameter will be passed to the
+  # action as the remaining arguments. The action must return the new value
+  # of the Agent.
+  #
+  # * {#send} and {#send!} should be used for actions that are CPU limited
+  # * {#send_off}, {#send_off!}, and {#<<} are appropriate for actions that
+  #   may block on IO
+  # * {#send_via} and {#send_via!} are used when a specific executor is to
+  #   be used for the action
+  #
+  # @param args [Array<Object>] zero or more arguments to be passed to
+  #   the action
+  # @param action [Proc] the action dispatch to be enqueued
+  # @return [Boolean] true if the action is successfully enqueued, false if
+  #   the Agent is {#failed?}
+  # @yield [agent, value, *args] process the old value and return the new
+  # @yieldparam value [Object] the current {#value} of the Agent
+  # @yieldparam args [Array<Object>] zero or more arguments to pass to the
+  #   action
+  # @yieldreturn [Object] the new value of the Agent
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#294
+  def send_off(*args, &action); end
+
+  # Dispatches an action to the Agent and returns immediately. Subsequently,
+  # in a thread from a thread pool, the {#value} will be set to the return
+  # value of the action. Action dispatches are only allowed when the Agent
+  # is not {#failed?}.
+  #
+  # The action must be a block/proc/lambda which takes 1 or more arguments.
+  # The first argument is the current {#value} of the Agent. Any arguments
+  # passed to the send method via the `args` parameter will be passed to the
+  # action as the remaining arguments. The action must return the new value
+  # of the Agent.
+  #
+  # * {#send} and {#send!} should be used for actions that are CPU limited
+  # * {#send_off}, {#send_off!}, and {#<<} are appropriate for actions that
+  #   may block on IO
+  # * {#send_via} and {#send_via!} are used when a specific executor is to
+  #   be used for the action
+  #
+  # @param args [Array<Object>] zero or more arguments to be passed to
+  #   the action
+  # @param action [Proc] the action dispatch to be enqueued
+  # @raise [Concurrent::Agent::Error] if the Agent is {#failed?}
+  # @return [Boolean] true if the action is successfully enqueued
+  # @yield [agent, value, *args] process the old value and return the new
+  # @yieldparam value [Object] the current {#value} of the Agent
+  # @yieldparam args [Array<Object>] zero or more arguments to pass to the
+  #   action
+  # @yieldreturn [Object] the new value of the Agent
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#302
+  def send_off!(*args, &action); end
+
+  # Dispatches an action to the Agent and returns immediately. Subsequently,
+  # in a thread from a thread pool, the {#value} will be set to the return
+  # value of the action. Action dispatches are only allowed when the Agent
+  # is not {#failed?}.
+  #
+  # The action must be a block/proc/lambda which takes 1 or more arguments.
+  # The first argument is the current {#value} of the Agent. Any arguments
+  # passed to the send method via the `args` parameter will be passed to the
+  # action as the remaining arguments. The action must return the new value
+  # of the Agent.
+  #
+  # * {#send} and {#send!} should be used for actions that are CPU limited
+  # * {#send_off}, {#send_off!}, and {#<<} are appropriate for actions that
+  #   may block on IO
+  # * {#send_via} and {#send_via!} are used when a specific executor is to
+  #   be used for the action
+  #
+  # @param args [Array<Object>] zero or more arguments to be passed to
+  #   the action
+  # @param action [Proc] the action dispatch to be enqueued
+  # @param executor [Concurrent::ExecutorService] the executor on which the
+  #   action is to be dispatched
+  # @return [Boolean] true if the action is successfully enqueued, false if
+  #   the Agent is {#failed?}
+  # @yield [agent, value, *args] process the old value and return the new
+  # @yieldparam value [Object] the current {#value} of the Agent
+  # @yieldparam args [Array<Object>] zero or more arguments to pass to the
+  #   action
+  # @yieldreturn [Object] the new value of the Agent
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#311
+  def send_via(executor, *args, &action); end
+
+  # Dispatches an action to the Agent and returns immediately. Subsequently,
+  # in a thread from a thread pool, the {#value} will be set to the return
+  # value of the action. Action dispatches are only allowed when the Agent
+  # is not {#failed?}.
+  #
+  # The action must be a block/proc/lambda which takes 1 or more arguments.
+  # The first argument is the current {#value} of the Agent. Any arguments
+  # passed to the send method via the `args` parameter will be passed to the
+  # action as the remaining arguments. The action must return the new value
+  # of the Agent.
+  #
+  # * {#send} and {#send!} should be used for actions that are CPU limited
+  # * {#send_off}, {#send_off!}, and {#<<} are appropriate for actions that
+  #   may block on IO
+  # * {#send_via} and {#send_via!} are used when a specific executor is to
+  #   be used for the action
+  #
+  # @param args [Array<Object>] zero or more arguments to be passed to
+  #   the action
+  # @param action [Proc] the action dispatch to be enqueued
+  # @param executor [Concurrent::ExecutorService] the executor on which the
+  #   action is to be dispatched
+  # @raise [Concurrent::Agent::Error] if the Agent is {#failed?}
+  # @return [Boolean] true if the action is successfully enqueued
+  # @yield [agent, value, *args] process the old value and return the new
+  # @yieldparam value [Object] the current {#value} of the Agent
+  # @yieldparam args [Array<Object>] zero or more arguments to pass to the
+  #   action
+  # @yieldreturn [Object] the new value of the Agent
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#319
+  def send_via!(executor, *args, &action); end
+
+  # Is the Agent in a failed state?
+  #
+  # @return [Boolean]
+  # @see #restart
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#402
+  def stopped?; end
+
+  # The current value (state) of the Agent, irrespective of any pending or
+  # in-progress actions. The value is always available and is non-blocking.
+  #
+  # @return [Object] the current value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#229
+  def value; end
+
+  # Blocks the current thread until all actions dispatched thus far, from this
+  # thread or nested by the Agent, have occurred, or the timeout (in seconds)
+  # has elapsed. Will block indefinitely when timeout is nil or not given.
+  #
+  # Provided mainly for consistency with other classes in this library. Prefer
+  # the various `await` methods instead.
+  #
+  #
+  # **NOTE** Never, *under any circumstances*, call any of the "await" methods
+  # ({#await}, {#await_for}, {#await_for!}, and {#wait}) from within an action
+  # block/proc/lambda. The call will block the Agent and will always fail.
+  # Calling either {#await} or {#wait} (with a timeout of `nil`) will
+  # hopelessly deadlock the Agent with no possibility of recovery.
+  #
+  # @param timeout [Float] the maximum number of seconds to wait
+  # @return [Boolean] true if all actions complete before timeout else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#393
+  def wait(timeout = T.unsafe(nil)); end
+
+  private
+
+  # @raise [ArgumentError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#510
+  def enqueue_action_job(action, args, executor); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#516
+  def enqueue_await_job(latch); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#543
+  def execute_next_job; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#576
+  def handle_error(error); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#529
+  def ns_enqueue_job(job, index = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#584
+  def ns_find_last_job_for_thread; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#490
+  def ns_initialize(initial, opts); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#539
+  def ns_post_next_job; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#570
+  def ns_validate(value); end
+
+  class << self
+    # Blocks the current thread (indefinitely!) until all actions dispatched
+    # thus far to all the given Agents, from this thread or nested by the
+    # given Agents, have occurred. Will block when any of the agents are
+    # failed. Will never return if a failed Agent is restart with
+    # `:clear_actions` true.
+    #
+    #
+    # **NOTE** Never, *under any circumstances*, call any of the "await" methods
+    # ({#await}, {#await_for}, {#await_for!}, and {#wait}) from within an action
+    # block/proc/lambda. The call will block the Agent and will always fail.
+    # Calling either {#await} or {#wait} (with a timeout of `nil`) will
+    # hopelessly deadlock the Agent with no possibility of recovery.
+    #
+    # @param agents [Array<Concurrent::Agent>] the Agents on which to wait
+    # @return [Boolean] true
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#449
+    def await(*agents); end
+
+    # Blocks the current thread until all actions dispatched thus far to all
+    # the given Agents, from this thread or nested by the given Agents, have
+    # occurred, or the timeout (in seconds) has elapsed.
+    #
+    #
+    # **NOTE** Never, *under any circumstances*, call any of the "await" methods
+    # ({#await}, {#await_for}, {#await_for!}, and {#wait}) from within an action
+    # block/proc/lambda. The call will block the Agent and will always fail.
+    # Calling either {#await} or {#wait} (with a timeout of `nil`) will
+    # hopelessly deadlock the Agent with no possibility of recovery.
+    #
+    # @param timeout [Float] the maximum number of seconds to wait
+    # @param agents [Array<Concurrent::Agent>] the Agents on which to wait
+    # @return [Boolean] true if all actions complete before timeout else false
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#463
+    def await_for(timeout, *agents); end
+
+    # Blocks the current thread until all actions dispatched thus far to all
+    # the given Agents, from this thread or nested by the given Agents, have
+    # occurred, or the timeout (in seconds) has elapsed.
+    #
+    #
+    # **NOTE** Never, *under any circumstances*, call any of the "await" methods
+    # ({#await}, {#await_for}, {#await_for!}, and {#wait}) from within an action
+    # block/proc/lambda. The call will block the Agent and will always fail.
+    # Calling either {#await} or {#wait} (with a timeout of `nil`) will
+    # hopelessly deadlock the Agent with no possibility of recovery.
+    #
+    # @param timeout [Float] the maximum number of seconds to wait
+    # @param agents [Array<Concurrent::Agent>] the Agents on which to wait
+    # @raise [Concurrent::TimeoutError] when timout is reached
+    # @return [Boolean] true if all actions complete before timeout
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#482
+    def await_for!(timeout, *agents); end
+  end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#154
+Concurrent::Agent::AWAIT_ACTION = T.let(T.unsafe(nil), Proc)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#151
+Concurrent::Agent::AWAIT_FLAG = T.let(T.unsafe(nil), Object)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#157
+Concurrent::Agent::DEFAULT_ERROR_HANDLER = T.let(T.unsafe(nil), Proc)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#160
+Concurrent::Agent::DEFAULT_VALIDATOR = T.let(T.unsafe(nil), Proc)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#148
+Concurrent::Agent::ERROR_MODES = T.let(T.unsafe(nil), Array)
+
+# Raised during action processing or any other time in an Agent's lifecycle.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#167
+class Concurrent::Agent::Error < ::StandardError
+  # @return [Error] a new instance of Error
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#168
+  def initialize(message = T.unsafe(nil)); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#163
+class Concurrent::Agent::Job < ::Struct
+  # Returns the value of attribute action
+  #
+  # @return [Object] the current value of action
+  def action; end
+
+  # Sets the attribute action
+  #
+  # @param value [Object] the value to set the attribute action to.
+  # @return [Object] the newly set value
+  def action=(_); end
+
+  # Returns the value of attribute args
+  #
+  # @return [Object] the current value of args
+  def args; end
+
+  # Sets the attribute args
+  #
+  # @param value [Object] the value to set the attribute args to.
+  # @return [Object] the newly set value
+  def args=(_); end
+
+  # Returns the value of attribute caller
+  #
+  # @return [Object] the current value of caller
+  def caller; end
+
+  # Sets the attribute caller
+  #
+  # @param value [Object] the value to set the attribute caller to.
+  # @return [Object] the newly set value
+  def caller=(_); end
+
+  # Returns the value of attribute executor
+  #
+  # @return [Object] the current value of executor
+  def executor; end
+
+  # Sets the attribute executor
+  #
+  # @param value [Object] the value to set the attribute executor to.
+  # @return [Object] the newly set value
+  def executor=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# Raised when a new value obtained during action processing or at `#restart`
+# fails validation.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#176
+class Concurrent::Agent::ValidationError < ::Concurrent::Agent::Error
+  # @return [ValidationError] a new instance of ValidationError
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#177
+  def initialize(message = T.unsafe(nil)); end
+end
+
+# A thread-safe subclass of Array. This version locks against the object
+# itself for every method call, ensuring only one thread can be reading
+# or writing at a time. This includes iteration methods like `#each`.
+#
+# @note `a += b` is **not** a **thread-safe** operation on
+#   `Concurrent::Array`. It reads array `a`, then it creates new `Concurrent::Array`
+#   which is concatenation of `a` and `b`, then it writes the concatenation to `a`.
+#   The read and write are independent operations they do not form a single atomic
+#   operation therefore when two `+=` operations are executed concurrently updates
+#   may be lost. Use `#concat` instead.
+# @see http://ruby-doc.org/core/Array.html Ruby standard library `Array`
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/array.rb#53
+class Concurrent::Array < ::Array; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/array.rb#22
+Concurrent::ArrayImplementation = Array
+
+# A mixin module that provides simple asynchronous behavior to a class,
+# turning it into a simple actor. Loosely based on Erlang's
+# [gen_server](http://www.erlang.org/doc/man/gen_server.html), but without
+# supervision or linking.
+#
+# A more feature-rich {Concurrent::Actor} is also available when the
+# capabilities of `Async` are too limited.
+#
+# ```cucumber
+# Feature:
+#   As a stateful, plain old Ruby class
+#   I want safe, asynchronous behavior
+#   So my long-running methods don't block the main thread
+# ```
+#
+# The `Async` module is a way to mix simple yet powerful asynchronous
+# capabilities into any plain old Ruby object or class, turning each object
+# into a simple Actor. Method calls are processed on a background thread. The
+# caller is free to perform other actions while processing occurs in the
+# background.
+#
+# Method calls to the asynchronous object are made via two proxy methods:
+# `async` (alias `cast`) and `await` (alias `call`). These proxy methods post
+# the method call to the object's background thread and return a "future"
+# which will eventually contain the result of the method call.
+#
+# This behavior is loosely patterned after Erlang's `gen_server` behavior.
+# When an Erlang module implements the `gen_server` behavior it becomes
+# inherently asynchronous. The `start` or `start_link` function spawns a
+# process (similar to a thread but much more lightweight and efficient) and
+# returns the ID of the process. Using the process ID, other processes can
+# send messages to the `gen_server` via the `cast` and `call` methods. Unlike
+# Erlang's `gen_server`, however, `Async` classes do not support linking or
+# supervision trees.
+#
+# ## Basic Usage
+#
+# When this module is mixed into a class, objects of the class become inherently
+# asynchronous. Each object gets its own background thread on which to post
+# asynchronous method calls. Asynchronous method calls are executed in the
+# background one at a time in the order they are received.
+#
+# To create an asynchronous class, simply mix in the `Concurrent::Async` module:
+#
+# ```
+# class Hello
+#   include Concurrent::Async
+#
+#   def hello(name)
+#     "Hello, #{name}!"
+#   end
+# end
+# ```
+#
+# Mixing this module into a class provides each object two proxy methods:
+# `async` and `await`. These methods are thread safe with respect to the
+# enclosing object. The former proxy allows methods to be called
+# asynchronously by posting to the object's internal thread. The latter proxy
+# allows a method to be called synchronously but does so safely with respect
+# to any pending asynchronous method calls and ensures proper ordering. Both
+# methods return a {Concurrent::IVar} which can be inspected for the result
+# of the proxied method call. Calling a method with `async` will return a
+# `:pending` `IVar` whereas `await` will return a `:complete` `IVar`.
+#
+# ```
+# class Echo
+#   include Concurrent::Async
+#
+#   def echo(msg)
+#     print "#{msg}\n"
+#   end
+# end
+#
+# horn = Echo.new
+# horn.echo('zero')      # synchronous, not thread-safe
+#                        # returns the actual return value of the method
+#
+# horn.async.echo('one') # asynchronous, non-blocking, thread-safe
+#                        # returns an IVar in the :pending state
+#
+# horn.await.echo('two') # synchronous, blocking, thread-safe
+#                        # returns an IVar in the :complete state
+# ```
+#
+# ## Let It Fail
+#
+# The `async` and `await` proxy methods have built-in error protection based
+# on Erlang's famous "let it fail" philosophy. Instance methods should not be
+# programmed defensively. When an exception is raised by a delegated method
+# the proxy will rescue the exception, expose it to the caller as the `reason`
+# attribute of the returned future, then process the next method call.
+#
+# ## Calling Methods Internally
+#
+# External method calls should *always* use the `async` and `await` proxy
+# methods. When one method calls another method, the `async` proxy should
+# rarely be used and the `await` proxy should *never* be used.
+#
+# When an object calls one of its own methods using the `await` proxy the
+# second call will be enqueued *behind* the currently running method call.
+# Any attempt to wait on the result will fail as the second call will never
+# run until after the current call completes.
+#
+# Calling a method using the `await` proxy from within a method that was
+# itself called using `async` or `await` will irreversibly deadlock the
+# object. Do *not* do this, ever.
+#
+# ## Instance Variables and Attribute Accessors
+#
+# Instance variables do not need to be thread-safe so long as they are private.
+# Asynchronous method calls are processed in the order they are received and
+# are processed one at a time. Therefore private instance variables can only
+# be accessed by one thread at a time. This is inherently thread-safe.
+#
+# When using private instance variables within asynchronous methods, the best
+# practice is to read the instance variable into a local variable at the start
+# of the method then update the instance variable at the *end* of the method.
+# This way, should an exception be raised during method execution the internal
+# state of the object will not have been changed.
+#
+# ### Reader Attributes
+#
+# The use of `attr_reader` is discouraged. Internal state exposed externally,
+# when necessary, should be done through accessor methods. The instance
+# variables exposed by these methods *must* be thread-safe, or they must be
+# called using the `async` and `await` proxy methods. These two approaches are
+# subtly different.
+#
+# When internal state is accessed via the `async` and `await` proxy methods,
+# the returned value represents the object's state *at the time the call is
+# processed*, which may *not* be the state of the object at the time the call
+# is made.
+#
+# To get the state *at the current* time, irrespective of an enqueued method
+# calls, a reader method must be called directly. This is inherently unsafe
+# unless the instance variable is itself thread-safe, preferably using one
+# of the thread-safe classes within this library. Because the thread-safe
+# classes within this library are internally-locking or non-locking, they can
+# be safely used from within asynchronous methods without causing deadlocks.
+#
+# Generally speaking, the best practice is to *not* expose internal state via
+# reader methods. The best practice is to simply use the method's return value.
+#
+# ### Writer Attributes
+#
+# Writer attributes should never be used with asynchronous classes. Changing
+# the state externally, even when done in the thread-safe way, is not logically
+# consistent. Changes to state need to be timed with respect to all asynchronous
+# method calls which my be in-process or enqueued. The only safe practice is to
+# pass all necessary data to each method as arguments and let the method update
+# the internal state as necessary.
+#
+# ## Class Constants, Variables, and Methods
+#
+# ### Class Constants
+#
+# Class constants do not need to be thread-safe. Since they are read-only and
+# immutable they may be safely read both externally and from within
+# asynchronous methods.
+#
+# ### Class Variables
+#
+# Class variables should be avoided. Class variables represent shared state.
+# Shared state is anathema to concurrency. Should there be a need to share
+# state using class variables they *must* be thread-safe, preferably
+# using the thread-safe classes within this library. When updating class
+# variables, never assign a new value/object to the variable itself. Assignment
+# is not thread-safe in Ruby. Instead, use the thread-safe update functions
+# of the variable itself to change the value.
+#
+# The best practice is to *never* use class variables with `Async` classes.
+#
+# ### Class Methods
+#
+# Class methods which are pure functions are safe. Class methods which modify
+# class variables should be avoided, for all the reasons listed above.
+#
+# ## An Important Note About Thread Safe Guarantees
+#
+# > Thread safe guarantees can only be made when asynchronous method calls
+# > are not mixed with direct method calls. Use only direct method calls
+# > when the object is used exclusively on a single thread. Use only
+# > `async` and `await` when the object is shared between threads. Once you
+# > call a method using `async` or `await`, you should no longer call methods
+# > directly on the object. Use `async` and `await` exclusively from then on.
+#
+# @example
+#
+#   class Echo
+#   include Concurrent::Async
+#
+#   def echo(msg)
+#   print "#{msg}\n"
+#   end
+#   end
+#
+#   horn = Echo.new
+#   horn.echo('zero')      # synchronous, not thread-safe
+#   # returns the actual return value of the method
+#
+#   horn.async.echo('one') # asynchronous, non-blocking, thread-safe
+#   # returns an IVar in the :pending state
+#
+#   horn.await.echo('two') # synchronous, blocking, thread-safe
+#   # returns an IVar in the :complete state
+# @see Concurrent::Actor
+# @see https://en.wikipedia.org/wiki/Actor_model "Actor Model" at Wikipedia
+# @see http://www.erlang.org/doc/man/gen_server.html Erlang gen_server
+# @see http://c2.com/cgi/wiki?LetItCrash "Let It Crash" at http://c2.com/
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#217
+module Concurrent::Async
+  mixes_in_class_methods ::Concurrent::Async::ClassMethods
+
+  # Causes the chained method call to be performed asynchronously on the
+  # object's thread. The delegated method will return a future in the
+  # `:pending` state and the method call will have been scheduled on the
+  # object's thread. The final disposition of the method call can be obtained
+  # by inspecting the returned future.
+  #
+  # @note The method call is guaranteed to be thread safe with respect to
+  #   all other method calls against the same object that are called with
+  #   either `async` or `await`. The mutable nature of Ruby references
+  #   (and object orientation in general) prevent any other thread safety
+  #   guarantees. Do NOT mix direct method calls with delegated method calls.
+  #   Use *only* delegated method calls when sharing the object between threads.
+  # @raise [NameError] the object does not respond to the requested method
+  # @raise [ArgumentError] the given `args` do not match the arity of
+  #   the requested method
+  # @return [Concurrent::IVar] the pending result of the asynchronous operation
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#412
+  def async; end
+
+  # Causes the chained method call to be performed synchronously on the
+  # current thread. The delegated will return a future in either the
+  # `:fulfilled` or `:rejected` state and the delegated method will have
+  # completed. The final disposition of the delegated method can be obtained
+  # by inspecting the returned future.
+  #
+  # @note The method call is guaranteed to be thread safe with respect to
+  #   all other method calls against the same object that are called with
+  #   either `async` or `await`. The mutable nature of Ruby references
+  #   (and object orientation in general) prevent any other thread safety
+  #   guarantees. Do NOT mix direct method calls with delegated method calls.
+  #   Use *only* delegated method calls when sharing the object between threads.
+  # @raise [NameError] the object does not respond to the requested method
+  # @raise [ArgumentError] the given `args` do not match the arity of the
+  #   requested method
+  # @return [Concurrent::IVar] the completed result of the synchronous operation
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#430
+  def await; end
+
+  # Causes the chained method call to be performed synchronously on the
+  # current thread. The delegated will return a future in either the
+  # `:fulfilled` or `:rejected` state and the delegated method will have
+  # completed. The final disposition of the delegated method can be obtained
+  # by inspecting the returned future.
+  #
+  # @note The method call is guaranteed to be thread safe with respect to
+  #   all other method calls against the same object that are called with
+  #   either `async` or `await`. The mutable nature of Ruby references
+  #   (and object orientation in general) prevent any other thread safety
+  #   guarantees. Do NOT mix direct method calls with delegated method calls.
+  #   Use *only* delegated method calls when sharing the object between threads.
+  # @raise [NameError] the object does not respond to the requested method
+  # @raise [ArgumentError] the given `args` do not match the arity of the
+  #   requested method
+  # @return [Concurrent::IVar] the completed result of the synchronous operation
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#430
+  def call; end
+
+  # Causes the chained method call to be performed asynchronously on the
+  # object's thread. The delegated method will return a future in the
+  # `:pending` state and the method call will have been scheduled on the
+  # object's thread. The final disposition of the method call can be obtained
+  # by inspecting the returned future.
+  #
+  # @note The method call is guaranteed to be thread safe with respect to
+  #   all other method calls against the same object that are called with
+  #   either `async` or `await`. The mutable nature of Ruby references
+  #   (and object orientation in general) prevent any other thread safety
+  #   guarantees. Do NOT mix direct method calls with delegated method calls.
+  #   Use *only* delegated method calls when sharing the object between threads.
+  # @raise [NameError] the object does not respond to the requested method
+  # @raise [ArgumentError] the given `args` do not match the arity of
+  #   the requested method
+  # @return [Concurrent::IVar] the pending result of the asynchronous operation
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#412
+  def cast; end
+
+  # Initialize the internal serializer and other stnchronization mechanisms.
+  #
+  # @note This method *must* be called immediately upon object construction.
+  #   This is the only way thread-safe initialization can be guaranteed.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#441
+  def init_synchronization; end
+
+  class << self
+    # @private
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#262
+    def included(base); end
+
+    # Check for the presence of a method on an object and determine if a given
+    # set of arguments matches the required arity.
+    #
+    # @note This check is imperfect because of the way Ruby reports the arity of
+    #   methods with a variable number of arguments. It is possible to determine
+    #   if too few arguments are given but impossible to determine if too many
+    #   arguments are given. This check may also fail to recognize dynamic behavior
+    #   of the object, such as methods simulated with `method_missing`.
+    # @param obj [Object] the object to check against
+    # @param method [Symbol] the method to check the object for
+    # @param args [Array] zero or more arguments for the arity check
+    # @raise [NameError] the object does not respond to `method` method
+    # @raise [ArgumentError] the given `args` do not match the arity of `method`
+    # @see http://www.ruby-doc.org/core-2.1.1/Method.html#method-i-arity Method#arity
+    # @see http://ruby-doc.org/core-2.1.0/Object.html#method-i-respond_to-3F Object#respond_to?
+    # @see http://www.ruby-doc.org/core-2.1.0/BasicObject.html#method-i-method_missing BasicObject#method_missing
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#250
+    def validate_argc(obj, method, *args); end
+  end
+end
+
+# Delegates asynchronous, thread-safe method calls to the wrapped object.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#282
+class Concurrent::Async::AsyncDelegator < ::Concurrent::Synchronization::LockableObject
+  # Create a new delegator object wrapping the given delegate.
+  #
+  # @param delegate [Object] the object to wrap and delegate method calls to
+  # @return [AsyncDelegator] a new instance of AsyncDelegator
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#288
+  def initialize(delegate); end
+
+  # Delegates method calls to the wrapped object.
+  #
+  # @param method [Symbol] the method being called
+  # @param args [Array] zero or more arguments to the method
+  # @raise [NameError] the object does not respond to `method` method
+  # @raise [ArgumentError] the given `args` do not match the arity of `method`
+  # @return [IVar] the result of the method call
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#305
+  def method_missing(method, *args, &block); end
+
+  # Perform all enqueued tasks.
+  #
+  # This method must be called from within the executor. It must not be
+  # called while already running. It will loop until the queue is empty.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#330
+  def perform; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#348
+  def reset_if_forked; end
+
+  private
+
+  # Check whether the method is responsive
+  #
+  # @param method [Symbol] the method being called
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#322
+  def respond_to_missing?(method, include_private = T.unsafe(nil)); end
+end
+
+# Delegates synchronous, thread-safe method calls to the wrapped object.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#360
+class Concurrent::Async::AwaitDelegator
+  # Create a new delegator object wrapping the given delegate.
+  #
+  # @param delegate [AsyncDelegator] the object to wrap and delegate method calls to
+  # @return [AwaitDelegator] a new instance of AwaitDelegator
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#365
+  def initialize(delegate); end
+
+  # Delegates method calls to the wrapped object.
+  #
+  # @param method [Symbol] the method being called
+  # @param args [Array] zero or more arguments to the method
+  # @raise [NameError] the object does not respond to `method` method
+  # @raise [ArgumentError] the given `args` do not match the arity of `method`
+  # @return [IVar] the result of the method call
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#378
+  def method_missing(method, *args, &block); end
+
+  private
+
+  # Check whether the method is responsive
+  #
+  # @param method [Symbol] the method being called
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#387
+  def respond_to_missing?(method, include_private = T.unsafe(nil)); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#269
+module Concurrent::Async::ClassMethods
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/async.rb#270
+  def new(*args, **_arg1, &block); end
+end
+
+# Atoms provide a way to manage shared, synchronous, independent state.
+#
+# An atom is initialized with an initial value and an optional validation
+# proc. At any time the value of the atom can be synchronously and safely
+# changed. If a validator is given at construction then any new value
+# will be checked against the validator and will be rejected if the
+# validator returns false or raises an exception.
+#
+# There are two ways to change the value of an atom: {#compare_and_set} and
+# {#swap}. The former will set the new value if and only if it validates and
+# the current value matches the new value. The latter will atomically set the
+# new value to the result of running the given block if and only if that
+# value validates.
+#
+# ## Example
+#
+# ```
+# def next_fibonacci(set = nil)
+#   return [0, 1] if set.nil?
+#   set + [set[-2..-1].reduce{|sum,x| sum + x }]
+# end
+#
+# # create an atom with an initial value
+# atom = Concurrent::Atom.new(next_fibonacci)
+#
+# # send a few update requests
+# 5.times do
+#   atom.swap{|set| next_fibonacci(set) }
+# end
+#
+# # get the current value
+# atom.value #=> [0, 1, 1, 2, 3, 5, 8]
+# ```
+#
+# ## Observation
+#
+# Atoms support observers through the {Concurrent::Observable} mixin module.
+# Notification of observers occurs every time the value of the Atom changes.
+# When notified the observer will receive three arguments: `time`, `old_value`,
+# and `new_value`. The `time` argument is the time at which the value change
+# occurred. The `old_value` is the value of the Atom when the change began
+# The `new_value` is the value to which the Atom was set when the change
+# completed. Note that `old_value` and `new_value` may be the same. This is
+# not an error. It simply means that the change operation returned the same
+# value.
+#
+# Unlike in Clojure, `Atom` cannot participate in {Concurrent::TVar} transactions.
+#
+#
+# ## Thread-safe Variable Classes
+#
+# Each of the thread-safe variable classes is designed to solve a different
+# problem. In general:
+#
+# * *{Concurrent::Agent}:* Shared, mutable variable providing independent,
+#   uncoordinated, *asynchronous* change of individual values. Best used when
+#   the value will undergo frequent, complex updates. Suitable when the result
+#   of an update does not need to be known immediately.
+# * *{Concurrent::Atom}:* Shared, mutable variable providing independent,
+#   uncoordinated, *synchronous* change of individual values. Best used when
+#   the value will undergo frequent reads but only occasional, though complex,
+#   updates. Suitable when the result of an update must be known immediately.
+# * *{Concurrent::AtomicReference}:* A simple object reference that can be updated
+#   atomically. Updates are synchronous but fast. Best used when updates a
+#   simple set operations. Not suitable when updates are complex.
+#   {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar
+#   but optimized for the given data type.
+# * *{Concurrent::Exchanger}:* Shared, stateless synchronization point. Used
+#   when two or more threads need to exchange data. The threads will pair then
+#   block on each other until the exchange is complete.
+# * *{Concurrent::MVar}:* Shared synchronization point. Used when one thread
+#   must give a value to another, which must take the value. The threads will
+#   block on each other until the exchange is complete.
+# * *{Concurrent::ThreadLocalVar}:* Shared, mutable, isolated variable which
+#   holds a different value for each thread which has access. Often used as
+#   an instance variable in objects which must maintain different state
+#   for different threads.
+# * *{Concurrent::TVar}:* Shared, mutable variables which provide
+#   *coordinated*, *synchronous*, change of *many* stated. Used when multiple
+#   value must change together, in an all-or-nothing transaction.
+#
+# @see http://clojure.org/atoms Clojure Atoms
+# @see http://clojure.org/state Values and Change - Clojure's approach to Identity and State
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atom.rb#95
+class Concurrent::Atom < ::Concurrent::Synchronization::Object
+  include ::Concurrent::Concern::Observable
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # Create a new atom with the given initial value.
+  #
+  # @option opts
+  # @param value [Object] The initial value
+  # @param opts [Hash] The options used to configure the atom
+  # @raise [ArgumentError] if the validator is not a `Proc` (when given)
+  # @return [Atom] a new instance of Atom
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atom.rb#121
+  def initialize(value, opts = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#137
+  def __initialize_atomic_fields__; end
+
+  # Atomically sets the value of atom to the new value if and only if the
+  # current value of the atom is identical to the old value and the new
+  # value successfully validates against the (optional) validator given
+  # at construction.
+  #
+  # @param old_value [Object] The expected current value.
+  # @param new_value [Object] The intended new value.
+  # @return [Boolean] True if the value is changed else false.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atom.rb#181
+  def compare_and_set(old_value, new_value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#93
+  def deref; end
+
+  # Atomically sets the value of atom to the new value without regard for the
+  # current value so long as the new value successfully validates against the
+  # (optional) validator given at construction.
+  #
+  # @param new_value [Object] The intended new value.
+  # @return [Object] The final value of the atom after all operations and
+  #   validations are complete.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atom.rb#198
+  def reset(new_value); end
+
+  # Atomically swaps the value of atom using the given block. The current
+  # value will be passed to the block, as will any arguments passed as
+  # arguments to the function. The new value will be validated against the
+  # (optional) validator proc given at construction. If validation fails the
+  # value will not be changed.
+  #
+  # Internally, {#swap} reads the current value, applies the block to it, and
+  # attempts to compare-and-set it in. Since another thread may have changed
+  # the value in the intervening time, it may have to retry, and does so in a
+  # spin loop. The net effect is that the value will always be the result of
+  # the application of the supplied block to a current value, atomically.
+  # However, because the block might be called multiple times, it must be free
+  # of side effects.
+  #
+  # @note The given block may be called multiple times, and thus should be free
+  #   of side effects.
+  # @param args [Object] Zero or more arguments passed to the block.
+  # @raise [ArgumentError] When no block is given.
+  # @return [Object] The final value of the atom after all operations and
+  #   validations are complete.
+  # @yield [value, args] Calculates a new value for the atom based on the
+  #   current value and any supplied arguments.
+  # @yieldparam value [Object] The current value of the atom.
+  # @yieldparam args [Object] All arguments passed to the function, in order.
+  # @yieldreturn [Object] The intended new value of the atom.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atom.rb#157
+  def swap(*args); end
+
+  # The current value of the atom.
+  #
+  # @return [Object] The current value.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#93
+  def value; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#105
+  def compare_and_set_value(expected, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#101
+  def swap_value(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#109
+  def update_value(&block); end
+
+  # Is the new value valid?
+  #
+  # @param new_value [Object] The intended new value.
+  # @return [Boolean] false if the validator function returns false or raises
+  #   an exception else true
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atom.rb#216
+  def valid?(new_value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#97
+  def value=(value); end
+end
+
+# A boolean value that can be updated atomically. Reads and writes to an atomic
+# boolean and thread-safe and guaranteed to succeed. Reads and writes may block
+# briefly but no explicit locking is required.
+#
+#
+# ## Thread-safe Variable Classes
+#
+# Each of the thread-safe variable classes is designed to solve a different
+# problem. In general:
+#
+# * *{Concurrent::Agent}:* Shared, mutable variable providing independent,
+#   uncoordinated, *asynchronous* change of individual values. Best used when
+#   the value will undergo frequent, complex updates. Suitable when the result
+#   of an update does not need to be known immediately.
+# * *{Concurrent::Atom}:* Shared, mutable variable providing independent,
+#   uncoordinated, *synchronous* change of individual values. Best used when
+#   the value will undergo frequent reads but only occasional, though complex,
+#   updates. Suitable when the result of an update must be known immediately.
+# * *{Concurrent::AtomicReference}:* A simple object reference that can be updated
+#   atomically. Updates are synchronous but fast. Best used when updates a
+#   simple set operations. Not suitable when updates are complex.
+#   {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar
+#   but optimized for the given data type.
+# * *{Concurrent::Exchanger}:* Shared, stateless synchronization point. Used
+#   when two or more threads need to exchange data. The threads will pair then
+#   block on each other until the exchange is complete.
+# * *{Concurrent::MVar}:* Shared synchronization point. Used when one thread
+#   must give a value to another, which must take the value. The threads will
+#   block on each other until the exchange is complete.
+# * *{Concurrent::ThreadLocalVar}:* Shared, mutable, isolated variable which
+#   holds a different value for each thread which has access. Often used as
+#   an instance variable in objects which must maintain different state
+#   for different threads.
+# * *{Concurrent::TVar}:* Shared, mutable variables which provide
+#   *coordinated*, *synchronous*, change of *many* stated. Used when multiple
+#   value must change together, in an all-or-nothing transaction.
+# Performance:
+#
+# ```
+# Testing with ruby 2.1.2
+# Testing with Concurrent::MutexAtomicBoolean...
+#   2.790000   0.000000   2.790000 (  2.791454)
+# Testing with Concurrent::CAtomicBoolean...
+#   0.740000   0.000000   0.740000 (  0.740206)
+#
+# Testing with jruby 1.9.3
+# Testing with Concurrent::MutexAtomicBoolean...
+#   5.240000   2.520000   7.760000 (  3.683000)
+# Testing with Concurrent::JavaAtomicBoolean...
+#   3.340000   0.010000   3.350000 (  0.855000)
+# ```
+#
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicBoolean.html java.util.concurrent.atomic.AtomicBoolean
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb#119
+class Concurrent::AtomicBoolean < ::Concurrent::MutexAtomicBoolean
+  # @return [String] Short string representation.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb#121
+  def inspect; end
+
+  # @return [String] Short string representation.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb#121
+  def to_s; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb#82
+Concurrent::AtomicBooleanImplementation = Concurrent::MutexAtomicBoolean
+
+# Define update methods that use direct paths
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/atomic_direct_update.rb#9
+module Concurrent::AtomicDirectUpdate
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/atomic_direct_update.rb#15
+  def try_update; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/atomic_direct_update.rb#24
+  def try_update!; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/atomic_direct_update.rb#10
+  def update; end
+end
+
+# A numeric value that can be updated atomically. Reads and writes to an atomic
+# fixnum and thread-safe and guaranteed to succeed. Reads and writes may block
+# briefly but no explicit locking is required.
+#
+#
+# ## Thread-safe Variable Classes
+#
+# Each of the thread-safe variable classes is designed to solve a different
+# problem. In general:
+#
+# * *{Concurrent::Agent}:* Shared, mutable variable providing independent,
+#   uncoordinated, *asynchronous* change of individual values. Best used when
+#   the value will undergo frequent, complex updates. Suitable when the result
+#   of an update does not need to be known immediately.
+# * *{Concurrent::Atom}:* Shared, mutable variable providing independent,
+#   uncoordinated, *synchronous* change of individual values. Best used when
+#   the value will undergo frequent reads but only occasional, though complex,
+#   updates. Suitable when the result of an update must be known immediately.
+# * *{Concurrent::AtomicReference}:* A simple object reference that can be updated
+#   atomically. Updates are synchronous but fast. Best used when updates a
+#   simple set operations. Not suitable when updates are complex.
+#   {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar
+#   but optimized for the given data type.
+# * *{Concurrent::Exchanger}:* Shared, stateless synchronization point. Used
+#   when two or more threads need to exchange data. The threads will pair then
+#   block on each other until the exchange is complete.
+# * *{Concurrent::MVar}:* Shared synchronization point. Used when one thread
+#   must give a value to another, which must take the value. The threads will
+#   block on each other until the exchange is complete.
+# * *{Concurrent::ThreadLocalVar}:* Shared, mutable, isolated variable which
+#   holds a different value for each thread which has access. Often used as
+#   an instance variable in objects which must maintain different state
+#   for different threads.
+# * *{Concurrent::TVar}:* Shared, mutable variables which provide
+#   *coordinated*, *synchronous*, change of *many* stated. Used when multiple
+#   value must change together, in an all-or-nothing transaction.
+# Performance:
+#
+# ```
+# Testing with ruby 2.1.2
+# Testing with Concurrent::MutexAtomicFixnum...
+#   3.130000   0.000000   3.130000 (  3.136505)
+# Testing with Concurrent::CAtomicFixnum...
+#   0.790000   0.000000   0.790000 (  0.785550)
+#
+# Testing with jruby 1.9.3
+# Testing with Concurrent::MutexAtomicFixnum...
+#   5.460000   2.460000   7.920000 (  3.715000)
+# Testing with Concurrent::JavaAtomicFixnum...
+#   4.520000   0.030000   4.550000 (  1.187000)
+# ```
+#
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicLong.html java.util.concurrent.atomic.AtomicLong
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb#136
+class Concurrent::AtomicFixnum < ::Concurrent::MutexAtomicFixnum
+  # @return [String] Short string representation.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb#138
+  def inspect; end
+
+  # @return [String] Short string representation.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb#138
+  def to_s; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb#99
+Concurrent::AtomicFixnumImplementation = Concurrent::MutexAtomicFixnum
+
+# An atomic reference which maintains an object reference along with a mark bit
+# that can be updated atomically.
+#
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicMarkableReference.html java.util.concurrent.atomic.AtomicMarkableReference
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb#10
+class Concurrent::AtomicMarkableReference < ::Concurrent::Synchronization::Object
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # @return [AtomicMarkableReference] a new instance of AtomicMarkableReference
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb#15
+  def initialize(value = T.unsafe(nil), mark = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#137
+  def __initialize_atomic_fields__; end
+
+  # Atomically sets the value and mark to the given updated value and
+  # mark given both:
+  #   - the current value == the expected value &&
+  #   - the current mark == the expected mark
+  #
+  # that the actual value was not equal to the expected value or the
+  # actual mark was not equal to the expected mark
+  #
+  # @param expected_val [Object] the expected value
+  # @param new_val [Object] the new value
+  # @param expected_mark [Boolean] the expected mark
+  # @param new_mark [Boolean] the new mark
+  # @return [Boolean] `true` if successful. A `false` return indicates
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb#33
+  def compare_and_set(expected_val, new_val, expected_mark, new_mark); end
+
+  # Atomically sets the value and mark to the given updated value and
+  # mark given both:
+  #   - the current value == the expected value &&
+  #   - the current mark == the expected mark
+  #
+  # that the actual value was not equal to the expected value or the
+  # actual mark was not equal to the expected mark
+  #
+  # @param expected_val [Object] the expected value
+  # @param new_val [Object] the new value
+  # @param expected_mark [Boolean] the expected mark
+  # @param new_mark [Boolean] the new mark
+  # @return [Boolean] `true` if successful. A `false` return indicates
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb#33
+  def compare_and_swap(expected_val, new_val, expected_mark, new_mark); end
+
+  # Gets the current reference and marked values.
+  #
+  # @return [Array] the current reference and marked values
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb#64
+  def get; end
+
+  # Gets the current marked value
+  #
+  # @return [Boolean] the current marked value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb#78
+  def mark; end
+
+  # Gets the current marked value
+  #
+  # @return [Boolean] the current marked value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb#78
+  def marked?; end
+
+  # _Unconditionally_ sets to the given value of both the reference and
+  # the mark.
+  #
+  # @param new_val [Object] the new value
+  # @param new_mark [Boolean] the new mark
+  # @return [Array] both the new value and the new mark
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb#91
+  def set(new_val, new_mark); end
+
+  # Pass the current value to the given block, replacing it with the
+  # block's result. Simply return nil if update fails.
+  #
+  # the update failed
+  #
+  # @return [Array] the new value and marked state, or nil if
+  # @yield [Object] Calculate a new value and marked state for the atomic
+  #   reference using given (old) value and (old) marked
+  # @yieldparam old_val [Object] the starting value of the atomic reference
+  # @yieldparam old_mark [Boolean] the starting state of marked
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb#152
+  def try_update; end
+
+  # Pass the current value to the given block, replacing it
+  # with the block's result. Raise an exception if the update
+  # fails.
+  #
+  # @raise [Concurrent::ConcurrentUpdateError] if the update fails
+  # @return [Array] the new value and marked state
+  # @yield [Object] Calculate a new value and marked state for the atomic
+  #   reference using given (old) value and (old) marked
+  # @yieldparam old_val [Object] the starting value of the atomic reference
+  # @yieldparam old_mark [Boolean] the starting state of marked
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb#128
+  def try_update!; end
+
+  # Pass the current value and marked state to the given block, replacing it
+  # with the block's results. May retry if the value changes during the
+  # block's execution.
+  #
+  # @return [Array] the new value and new mark
+  # @yield [Object] Calculate a new value and marked state for the atomic
+  #   reference using given (old) value and (old) marked
+  # @yieldparam old_val [Object] the starting value of the atomic reference
+  # @yieldparam old_mark [Boolean] the starting state of marked
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb#105
+  def update; end
+
+  # Gets the current value of the reference
+  #
+  # @return [Object] the current value of the reference
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb#71
+  def value; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#105
+  def compare_and_set_reference(expected, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb#163
+  def immutable_array(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#93
+  def reference; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#97
+  def reference=(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#101
+  def swap_reference(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#109
+  def update_reference(&block); end
+end
+
+# Special "compare and set" handling of numeric values.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/numeric_cas_wrapper.rb#7
+module Concurrent::AtomicNumericCompareAndSetWrapper
+  # Atomically sets the value to the given updated value if
+  # the current value == the expected value.
+  #
+  # that the actual value was not equal to the expected value.
+  #
+  # @param old_value [Object] the expected value
+  # @param new_value [Object] the new value
+  # @return [Boolean] `true` if successful. A `false` return indicates
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/numeric_cas_wrapper.rb#10
+  def compare_and_set(old_value, new_value); end
+end
+
+# An object reference that may be updated atomically. All read and write
+# operations have java volatile semantic.
+#
+#
+# ## Thread-safe Variable Classes
+#
+# Each of the thread-safe variable classes is designed to solve a different
+# problem. In general:
+#
+# * *{Concurrent::Agent}:* Shared, mutable variable providing independent,
+#   uncoordinated, *asynchronous* change of individual values. Best used when
+#   the value will undergo frequent, complex updates. Suitable when the result
+#   of an update does not need to be known immediately.
+# * *{Concurrent::Atom}:* Shared, mutable variable providing independent,
+#   uncoordinated, *synchronous* change of individual values. Best used when
+#   the value will undergo frequent reads but only occasional, though complex,
+#   updates. Suitable when the result of an update must be known immediately.
+# * *{Concurrent::AtomicReference}:* A simple object reference that can be updated
+#   atomically. Updates are synchronous but fast. Best used when updates a
+#   simple set operations. Not suitable when updates are complex.
+#   {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar
+#   but optimized for the given data type.
+# * *{Concurrent::Exchanger}:* Shared, stateless synchronization point. Used
+#   when two or more threads need to exchange data. The threads will pair then
+#   block on each other until the exchange is complete.
+# * *{Concurrent::MVar}:* Shared synchronization point. Used when one thread
+#   must give a value to another, which must take the value. The threads will
+#   block on each other until the exchange is complete.
+# * *{Concurrent::ThreadLocalVar}:* Shared, mutable, isolated variable which
+#   holds a different value for each thread which has access. Often used as
+#   an instance variable in objects which must maintain different state
+#   for different threads.
+# * *{Concurrent::TVar}:* Shared, mutable variables which provide
+#   *coordinated*, *synchronous*, change of *many* stated. Used when multiple
+#   value must change together, in an all-or-nothing transaction.
+#
+# @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html
+# @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_reference.rb#126
+class Concurrent::AtomicReference < ::Concurrent::MutexAtomicReference
+  # @return [String] Short string representation.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_reference.rb#129
+  def inspect; end
+
+  # @return [String] Short string representation.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_reference.rb#129
+  def to_s; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/atomic_reference.rb#18
+Concurrent::AtomicReferenceImplementation = Concurrent::MutexAtomicReference
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/set.rb#30
+class Concurrent::CRubySet < ::Set
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#18
+  def initialize(*args, &block); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def &(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def +(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def -(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def <(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def <<(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def <=(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def <=>(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def ==(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def ===(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def >(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def >=(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def ^(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def add(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def add?(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def classify(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def clear(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def collect!(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def compare_by_identity(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def compare_by_identity?(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def delete(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def delete?(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def delete_if(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def difference(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def disjoint?(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def divide(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def each(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def empty?(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def eql?(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def filter!(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def flatten(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def flatten!(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def flatten_merge(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def freeze(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def hash(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def include?(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def inspect(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def intersect?(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def intersection(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def join(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def keep_if(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def length(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def map!(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def member?(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def merge(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def pretty_print(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def pretty_print_cycle(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def proper_subset?(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def proper_superset?(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def reject!(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def replace(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def reset(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def select!(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def size(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def subset?(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def subtract(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def superset?(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def to_a(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def to_s(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def to_set(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def union(*args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#32
+  def |(*args); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#23
+  def initialize_copy(other); end
+end
+
+# A thread pool that dynamically grows and shrinks to fit the current workload.
+# New threads are created as needed, existing threads are reused, and threads
+# that remain idle for too long are killed and removed from the pool. These
+# pools are particularly suited to applications that perform a high volume of
+# short-lived tasks.
+#
+# On creation a `CachedThreadPool` has zero running threads. New threads are
+# created on the pool as new operations are `#post`. The size of the pool
+# will grow until `#max_length` threads are in the pool or until the number
+# of threads exceeds the number of running and pending operations. When a new
+# operation is post to the pool the first available idle thread will be tasked
+# with the new operation.
+#
+# Should a thread crash for any reason the thread will immediately be removed
+# from the pool. Similarly, threads which remain idle for an extended period
+# of time will be killed and reclaimed. Thus these thread pools are very
+# efficient at reclaiming unused resources.
+#
+# The API and behavior of this class are based on Java's `CachedThreadPool`
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/cached_thread_pool.rb#27
+class Concurrent::CachedThreadPool < ::Concurrent::ThreadPoolExecutor
+  # Create a new thread pool.
+  #
+  # @option opts
+  # @param opts [Hash] the options defining pool behavior.
+  # @raise [ArgumentError] if `fallback_policy` is not a known policy
+  # @return [CachedThreadPool] a new instance of CachedThreadPool
+  # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newCachedThreadPool--
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/cached_thread_pool.rb#39
+  def initialize(opts = T.unsafe(nil)); end
+
+  private
+
+  # Create a new thread pool.
+  #
+  # @option opts
+  # @param opts [Hash] the options defining pool behavior.
+  # @raise [ArgumentError] if `fallback_policy` is not a known policy
+  # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newCachedThreadPool--
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/cached_thread_pool.rb#51
+  def ns_initialize(opts); end
+end
+
+# Raised when an asynchronous operation is cancelled before execution.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#9
+class Concurrent::CancelledOperationError < ::Concurrent::Error; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb#4
+module Concurrent::Collection; end
+
+# A thread safe observer set implemented using copy-on-read approach:
+# observers are added and removed from a thread safe collection; every time
+# a notification is required the internal data structure is copied to
+# prevent concurrency issues
+#
+# @api private
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb#12
+class Concurrent::Collection::CopyOnNotifyObserverSet < ::Concurrent::Synchronization::LockableObject
+  # @api private
+  # @return [CopyOnNotifyObserverSet] a new instance of CopyOnNotifyObserverSet
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb#14
+  def initialize; end
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb#20
+  def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb#55
+  def count_observers; end
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb#39
+  def delete_observer(observer); end
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb#47
+  def delete_observers; end
+
+  # Notifies all registered observers with optional args and deletes them.
+  #
+  # @api private
+  # @param args [Object] arguments to be passed to each observer
+  # @return [CopyOnWriteObserverSet] self
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb#72
+  def notify_and_delete_observers(*args, &block); end
+
+  # Notifies all registered observers with optional args
+  #
+  # @api private
+  # @param args [Object] arguments to be passed to each observer
+  # @return [CopyOnWriteObserverSet] self
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb#62
+  def notify_observers(*args, &block); end
+
+  protected
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb#80
+  def ns_initialize; end
+
+  private
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb#86
+  def duplicate_and_clear_observers; end
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb#94
+  def duplicate_observers; end
+
+  # @api private
+  # @raise [ArgumentError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb#98
+  def notify_to(observers, *args); end
+end
+
+# A thread safe observer set implemented using copy-on-write approach:
+# every time an observer is added or removed the whole internal data structure is
+# duplicated and replaced with a new one.
+#
+# @api private
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb#11
+class Concurrent::Collection::CopyOnWriteObserverSet < ::Concurrent::Synchronization::LockableObject
+  # @api private
+  # @return [CopyOnWriteObserverSet] a new instance of CopyOnWriteObserverSet
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb#13
+  def initialize; end
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb#19
+  def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb#56
+  def count_observers; end
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb#40
+  def delete_observer(observer); end
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb#50
+  def delete_observers; end
+
+  # Notifies all registered observers with optional args and deletes them.
+  #
+  # @api private
+  # @param args [Object] arguments to be passed to each observer
+  # @return [CopyOnWriteObserverSet] self
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb#72
+  def notify_and_delete_observers(*args, &block); end
+
+  # Notifies all registered observers with optional args
+  #
+  # @api private
+  # @param args [Object] arguments to be passed to each observer
+  # @return [CopyOnWriteObserverSet] self
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb#63
+  def notify_observers(*args, &block); end
+
+  protected
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb#80
+  def ns_initialize; end
+
+  private
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb#102
+  def clear_observers_and_return_old; end
+
+  # @api private
+  # @raise [ArgumentError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb#86
+  def notify_to(observers, *args); end
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb#94
+  def observers; end
+
+  # @api private
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb#98
+  def observers=(new_set); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#10
+Concurrent::Collection::MapImplementation = Concurrent::Collection::MriMapBackend
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb#10
+class Concurrent::Collection::MriMapBackend < ::Concurrent::Collection::NonConcurrentMapBackend
+  # @return [MriMapBackend] a new instance of MriMapBackend
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb#12
+  def initialize(options = T.unsafe(nil), &default_proc); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb#17
+  def []=(key, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb#61
+  def clear; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb#33
+  def compute(key); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb#21
+  def compute_if_absent(key); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb#29
+  def compute_if_present(key); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb#53
+  def delete(key); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb#57
+  def delete_pair(key, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb#49
+  def get_and_set(key, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb#37
+  def merge_pair(key, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb#45
+  def replace_if_exists(key, new_value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb#41
+  def replace_pair(key, old_value, new_value); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#9
+class Concurrent::Collection::NonConcurrentMapBackend
+  # WARNING: all public methods of the class must operate on the @backend
+  # directly without calling each other. This is important because of the
+  # SynchronizedMapBackend which uses a non-reentrant mutex for performance
+  # reasons.
+  #
+  # @return [NonConcurrentMapBackend] a new instance of NonConcurrentMapBackend
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#15
+  def initialize(options = T.unsafe(nil), &default_proc); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#21
+  def [](key); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#25
+  def []=(key, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#94
+  def clear; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#59
+  def compute(key); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#29
+  def compute_if_absent(key); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#53
+  def compute_if_present(key); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#81
+  def delete(key); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#85
+  def delete_pair(key, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#99
+  def each_pair; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#71
+  def get_and_set(key, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#110
+  def get_or_default(key, default_value); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#77
+  def key?(key); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#63
+  def merge_pair(key, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#46
+  def replace_if_exists(key, new_value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#37
+  def replace_pair(key, old_value, new_value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#106
+  def size; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#130
+  def dupped_backend; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#124
+  def initialize_copy(other); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#134
+  def pair?(key, expected_value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#116
+  def set_backend(default_proc); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#138
+  def store_computed_value(key, new_value); end
+end
+
+# A queue collection in which the elements are sorted based on their
+# comparison (spaceship) operator `<=>`. Items are added to the queue
+# at a position relative to their priority. On removal the element
+# with the "highest" priority is removed. By default the sort order is
+# from highest to lowest, but a lowest-to-highest sort order can be
+# set on construction.
+#
+# The API is based on the `Queue` class from the Ruby standard library.
+#
+# The pure Ruby implementation, `RubyNonConcurrentPriorityQueue` uses a heap algorithm
+# stored in an array. The algorithm is based on the work of Robert Sedgewick
+# and Kevin Wayne.
+#
+# The JRuby native implementation is a thin wrapper around the standard
+# library `java.util.NonConcurrentPriorityQueue`.
+#
+# When running under JRuby the class `NonConcurrentPriorityQueue` extends `JavaNonConcurrentPriorityQueue`.
+# When running under all other interpreters it extends `RubyNonConcurrentPriorityQueue`.
+#
+# @note This implementation is *not* thread safe.
+# @see http://en.wikipedia.org/wiki/Priority_queue
+# @see http://ruby-doc.org/stdlib-2.0.0/libdoc/thread/rdoc/Queue.html
+# @see http://algs4.cs.princeton.edu/24pq/index.php#2.6
+# @see http://algs4.cs.princeton.edu/24pq/MaxPQ.java.html
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/non_concurrent_priority_queue.rb#50
+class Concurrent::Collection::NonConcurrentPriorityQueue < ::Concurrent::Collection::RubyNonConcurrentPriorityQueue
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#78
+  def <<(item); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#65
+  def deq; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#78
+  def enq(item); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#48
+  def has_priority?(item); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#65
+  def shift; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#54
+  def size; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/non_concurrent_priority_queue.rb#10
+Concurrent::Collection::NonConcurrentPriorityQueueImplementation = Concurrent::Collection::RubyNonConcurrentPriorityQueue
+
+# A queue collection in which the elements are sorted based on their
+# comparison (spaceship) operator `<=>`. Items are added to the queue
+# at a position relative to their priority. On removal the element
+# with the "highest" priority is removed. By default the sort order is
+# from highest to lowest, but a lowest-to-highest sort order can be
+# set on construction.
+#
+# The API is based on the `Queue` class from the Ruby standard library.
+#
+# The pure Ruby implementation, `RubyNonConcurrentPriorityQueue` uses a heap algorithm
+# stored in an array. The algorithm is based on the work of Robert Sedgewick
+# and Kevin Wayne.
+#
+# The JRuby native implementation is a thin wrapper around the standard
+# library `java.util.NonConcurrentPriorityQueue`.
+#
+# When running under JRuby the class `NonConcurrentPriorityQueue` extends `JavaNonConcurrentPriorityQueue`.
+# When running under all other interpreters it extends `RubyNonConcurrentPriorityQueue`.
+#
+# @note This implementation is *not* thread safe.
+# @see http://en.wikipedia.org/wiki/Priority_queue
+# @see http://ruby-doc.org/stdlib-2.0.0/libdoc/thread/rdoc/Queue.html
+# @see http://algs4.cs.princeton.edu/24pq/index.php#2.6
+# @see http://algs4.cs.princeton.edu/24pq/MaxPQ.java.html
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#8
+class Concurrent::Collection::RubyNonConcurrentPriorityQueue
+  # Create a new priority queue with no items.
+  #
+  # @option opts
+  # @param opts [Hash] the options for creating the queue
+  # @return [RubyNonConcurrentPriorityQueue] a new instance of RubyNonConcurrentPriorityQueue
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#11
+  def initialize(opts = T.unsafe(nil)); end
+
+  # Inserts the specified element into this priority queue.
+  #
+  # @param item [Object] the item to insert onto the queue
+  # @raise [ArgumentError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#78
+  def <<(item); end
+
+  # Removes all of the elements from this priority queue.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#18
+  def clear; end
+
+  # Deletes all items from `self` that are equal to `item`.
+  #
+  # @param item [Object] the item to be removed from the queue
+  # @return [Object] true if the item is found else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#25
+  def delete(item); end
+
+  # Retrieves and removes the head of this queue, or returns `nil` if this
+  # queue is empty.
+  #
+  # @return [Object] the head of the queue or `nil` when empty
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#65
+  def deq; end
+
+  # Returns `true` if `self` contains no elements.
+  #
+  # @return [Boolean] true if there are no items in the queue else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#43
+  def empty?; end
+
+  # Inserts the specified element into this priority queue.
+  #
+  # @param item [Object] the item to insert onto the queue
+  # @raise [ArgumentError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#78
+  def enq(item); end
+
+  # Returns `true` if the given item is present in `self` (that is, if any
+  # element == `item`), otherwise returns false.
+  #
+  # @param item [Object] the item to search for
+  # @return [Boolean] true if the item is found else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#48
+  def has_priority?(item); end
+
+  # Returns `true` if the given item is present in `self` (that is, if any
+  # element == `item`), otherwise returns false.
+  #
+  # @param item [Object] the item to search for
+  # @return [Boolean] true if the item is found else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#48
+  def include?(item); end
+
+  # The current length of the queue.
+  #
+  # @return [Fixnum] the number of items in the queue
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#54
+  def length; end
+
+  # Retrieves, but does not remove, the head of this queue, or returns `nil`
+  # if this queue is empty.
+  #
+  # @return [Object] the head of the queue or `nil` when empty
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#60
+  def peek; end
+
+  # Retrieves and removes the head of this queue, or returns `nil` if this
+  # queue is empty.
+  #
+  # @return [Object] the head of the queue or `nil` when empty
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#65
+  def pop; end
+
+  # Inserts the specified element into this priority queue.
+  #
+  # @param item [Object] the item to insert onto the queue
+  # @raise [ArgumentError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#78
+  def push(item); end
+
+  # Retrieves and removes the head of this queue, or returns `nil` if this
+  # queue is empty.
+  #
+  # @return [Object] the head of the queue or `nil` when empty
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#65
+  def shift; end
+
+  # The current length of the queue.
+  #
+  # @return [Fixnum] the number of items in the queue
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#54
+  def size; end
+
+  private
+
+  # Are the items at the given indexes ordered based on the priority
+  # order specified at construction?
+  #
+  # @param x [Integer] the first index from which to retrieve a comparable value
+  # @param y [Integer] the second index from which to retrieve a comparable value
+  # @return [Boolean] true if the two elements are in the correct priority order
+  #   else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#119
+  def ordered?(x, y); end
+
+  # Percolate down to maintain heap invariant.
+  #
+  # @param k [Integer] the index at which to start the percolation
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#128
+  def sink(k); end
+
+  # Exchange the values at the given indexes within the internal array.
+  #
+  # @param x [Integer] the first index to swap
+  # @param y [Integer] the second index to swap
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#103
+  def swap(x, y); end
+
+  # Percolate up to maintain heap invariant.
+  #
+  # @param k [Integer] the index at which to start the percolation
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#147
+  def swim(k); end
+
+  class << self
+    # @!macro priority_queue_method_from_list
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb#89
+    def from_list(list, opts = T.unsafe(nil)); end
+  end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/dereferenceable.rb#2
+module Concurrent::Concern; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/deprecation.rb#8
+module Concurrent::Concern::Deprecation
+  include ::Logger::Severity
+  include ::Concurrent::Concern::Logging
+  extend ::Logger::Severity
+  extend ::Concurrent::Concern::Logging
+  extend ::Concurrent::Concern::Deprecation
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/deprecation.rb#12
+  def deprecated(message, strip = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/deprecation.rb#27
+  def deprecated_method(old_name, new_name); end
+end
+
+# Object references in Ruby are mutable. This can lead to serious problems when
+# the `#value` of a concurrent object is a mutable reference. Which is always the
+# case unless the value is a `Fixnum`, `Symbol`, or similar "primitive" data type.
+# Most classes in this library that expose a `#value` getter method do so using the
+# `Dereferenceable` mixin module.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/dereferenceable.rb#11
+module Concurrent::Concern::Dereferenceable
+  # Return the value this object represents after applying the options specified
+  # by the `#set_deref_options` method.
+  #
+  # @return [Object] the current value of the object
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/dereferenceable.rb#21
+  def deref; end
+
+  # Return the value this object represents after applying the options specified
+  # by the `#set_deref_options` method.
+  #
+  # @return [Object] the current value of the object
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/dereferenceable.rb#21
+  def value; end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/dereferenceable.rb#63
+  def apply_deref_options(value); end
+
+  # Set the options which define the operations #value performs before
+  # returning data to the caller (dereferencing).
+  #
+  # @note Most classes that include this module will call `#set_deref_options`
+  #   from within the constructor, thus allowing these options to be set at
+  #   object creation.
+  # @option opts
+  # @option opts
+  # @option opts
+  # @param opts [Hash] the options defining dereference behavior.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/dereferenceable.rb#54
+  def ns_set_deref_options(opts); end
+
+  # Set the options which define the operations #value performs before
+  # returning data to the caller (dereferencing).
+  #
+  # @note Most classes that include this module will call `#set_deref_options`
+  #   from within the constructor, thus allowing these options to be set at
+  #   object creation.
+  # @option opts
+  # @option opts
+  # @option opts
+  # @param opts [Hash] the options defining dereference behavior.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/dereferenceable.rb#48
+  def set_deref_options(opts = T.unsafe(nil)); end
+
+  # Set the internal value of this object
+  #
+  # @param value [Object] the new value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/dereferenceable.rb#31
+  def value=(value); end
+end
+
+# Include where logging is needed
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#10
+module Concurrent::Concern::Logging
+  include ::Logger::Severity
+
+  # Logs through {Concurrent.global_logger}, it can be overridden by setting @logger
+  #
+  # @param level [Integer] one of Logger::Severity constants
+  # @param progname [String] e.g. a path of an Actor
+  # @param message [String, nil] when nil block is used to generate the message
+  # @yieldreturn [String] a message
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#18
+  def log(level, progname, message = T.unsafe(nil), &block); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#10
+module Concurrent::Concern::Obligation
+  include ::Concurrent::Concern::Dereferenceable
+
+  # Has the obligation completed processing?
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#49
+  def complete?; end
+
+  # @example allows Obligation to be risen
+  #   rejected_ivar = Ivar.new.fail
+  #   raise rejected_ivar
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#126
+  def exception(*args); end
+
+  # Has the obligation been fulfilled?
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#20
+  def fulfilled?; end
+
+  # Is the obligation still awaiting completion of processing?
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#56
+  def incomplete?; end
+
+  # Wait until obligation is complete or the timeout is reached. Will re-raise
+  # any exceptions raised during processing (but will not raise an exception
+  # on timeout).
+  #
+  # @param timeout [Numeric] the maximum time in seconds to wait.
+  # @raise [Exception] raises the reason when rejected
+  # @return [Obligation] self
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#86
+  def no_error!(timeout = T.unsafe(nil)); end
+
+  # Is obligation completion still pending?
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#35
+  def pending?; end
+
+  # Has the obligation been fulfilled?
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#20
+  def realized?; end
+
+  # If an exception was raised during processing this will return the
+  # exception object. Will return `nil` when the state is pending or if
+  # the obligation has been successfully fulfilled.
+  #
+  # @return [Exception] the exception raised during processing or `nil`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#119
+  def reason; end
+
+  # Has the obligation been rejected?
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#28
+  def rejected?; end
+
+  # The current state of the obligation.
+  #
+  # @return [Symbol] the current state
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#110
+  def state; end
+
+  # Is the obligation still unscheduled?
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#42
+  def unscheduled?; end
+
+  # The current value of the obligation. Will be `nil` while the state is
+  # pending or the operation has been rejected.
+  #
+  # @param timeout [Numeric] the maximum time in seconds to wait.
+  # @return [Object] see Dereferenceable#deref
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#65
+  def value(timeout = T.unsafe(nil)); end
+
+  # The current value of the obligation. Will be `nil` while the state is
+  # pending or the operation has been rejected. Will re-raise any exceptions
+  # raised during processing (but will not raise an exception on timeout).
+  #
+  # @param timeout [Numeric] the maximum time in seconds to wait.
+  # @raise [Exception] raises the reason when rejected
+  # @return [Object] see Dereferenceable#deref
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#98
+  def value!(timeout = T.unsafe(nil)); end
+
+  # Wait until obligation is complete or the timeout has been reached.
+  #
+  # @param timeout [Numeric] the maximum time in seconds to wait.
+  # @return [Obligation] self
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#74
+  def wait(timeout = T.unsafe(nil)); end
+
+  # Wait until obligation is complete or the timeout is reached. Will re-raise
+  # any exceptions raised during processing (but will not raise an exception
+  # on timeout).
+  #
+  # @param timeout [Numeric] the maximum time in seconds to wait.
+  # @raise [Exception] raises the reason when rejected
+  # @return [Obligation] self
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#86
+  def wait!(timeout = T.unsafe(nil)); end
+
+  protected
+
+  # Atomic compare and set operation
+  # State is set to `next_state` only if `current state == expected_current`.
+  #
+  # @param next_state [Symbol]
+  # @param expected_current [Symbol]
+  # @return [Boolean] true is state is changed, false otherwise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#174
+  def compare_and_set_state(next_state, *expected_current); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#145
+  def event; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#134
+  def get_arguments_from(opts = T.unsafe(nil)); end
+
+  # Executes the block within mutex if current state is included in expected_states
+  #
+  # @return block value if executed, false otherwise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#190
+  def if_state(*expected_states); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#139
+  def init_obligation; end
+
+  # Am I in the current state?
+  #
+  # @param expected [Symbol] The state to check against
+  # @return [Boolean] true if in the expected state else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#210
+  def ns_check_state?(expected); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#215
+  def ns_set_state(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#150
+  def set_state(success, value, reason); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/obligation.rb#161
+  def state=(value); end
+end
+
+# The [observer pattern](http://en.wikipedia.org/wiki/Observer_pattern) is one
+# of the most useful design patterns.
+#
+# The workflow is very simple:
+# - an `observer` can register itself to a `subject` via a callback
+# - many `observers` can be registered to the same `subject`
+# - the `subject` notifies all registered observers when its status changes
+# - an `observer` can deregister itself when is no more interested to receive
+#     event notifications
+#
+# In a single threaded environment the whole pattern is very easy: the
+# `subject` can use a simple data structure to manage all its subscribed
+# `observer`s and every `observer` can react directly to every event without
+# caring about synchronization.
+#
+# In a multi threaded environment things are more complex. The `subject` must
+# synchronize the access to its data structure and to do so currently we're
+# using two specialized ObserverSet: {Concurrent::Concern::CopyOnWriteObserverSet}
+# and {Concurrent::Concern::CopyOnNotifyObserverSet}.
+#
+# When implementing and `observer` there's a very important rule to remember:
+# **there are no guarantees about the thread that will execute the callback**
+#
+# Let's take this example
+# ```
+# class Observer
+#   def initialize
+#     @count = 0
+#   end
+#
+#   def update
+#     @count += 1
+#   end
+# end
+#
+# obs = Observer.new
+# [obj1, obj2, obj3, obj4].each { |o| o.add_observer(obs) }
+# # execute [obj1, obj2, obj3, obj4]
+# ```
+#
+# `obs` is wrong because the variable `@count` can be accessed by different
+# threads at the same time, so it should be synchronized (using either a Mutex
+# or an AtomicFixum)
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/observable.rb#50
+module Concurrent::Concern::Observable
+  # Adds an observer to this set. If a block is passed, the observer will be
+  # created by this method and no other params should be passed.
+  #
+  # @param observer [Object] the observer to add
+  # @param func [Symbol] the function to call on the observer during notification.
+  #   Default is :update
+  # @return [Object] the added observer
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/observable.rb#61
+  def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
+
+  # Return the number of observers associated with this object.
+  #
+  # @return [Integer] the observers count
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/observable.rb#101
+  def count_observers; end
+
+  # Remove `observer` as an observer on this object so that it will no
+  # longer receive notifications.
+  #
+  # @param observer [Object] the observer to remove
+  # @return [Object] the deleted observer
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/observable.rb#82
+  def delete_observer(observer); end
+
+  # Remove all observers associated with this object.
+  #
+  # @return [Observable] self
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/observable.rb#91
+  def delete_observers; end
+
+  # As `#add_observer` but can be used for chaining.
+  #
+  # @param observer [Object] the observer to add
+  # @param func [Symbol] the function to call on the observer during notification.
+  # @return [Observable] self
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/observable.rb#70
+  def with_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
+
+  protected
+
+  # Returns the value of attribute observers.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/observable.rb#107
+  def observers; end
+
+  # Sets the attribute observers
+  #
+  # @param value the value to set the attribute observers to.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/observable.rb#107
+  def observers=(_arg0); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#70
+class Concurrent::ConcurrentUpdateError < ::ThreadError; end
+
+# frozen pre-allocated backtrace to speed ConcurrentUpdateError
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#72
+Concurrent::ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE = T.let(T.unsafe(nil), Array)
+
+# Raised when errors occur during configuration.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#6
+class Concurrent::ConfigurationError < ::Concurrent::Error; end
+
+# A synchronization object that allows one thread to wait on multiple other threads.
+# The thread that will wait creates a `CountDownLatch` and sets the initial value
+# (normally equal to the number of other threads). The initiating thread passes the
+# latch to the other threads then waits for the other threads by calling the `#wait`
+# method. Each of the other threads calls `#count_down` when done with its work.
+# When the latch counter reaches zero the waiting thread is unblocked and continues
+# with its work. A `CountDownLatch` can be used only once. Its value cannot be reset.
+#
+# @example Waiter and Decrementer
+#   latch = Concurrent::CountDownLatch.new(3)
+#
+#   waiter = Thread.new do
+#   latch.wait()
+#   puts ("Waiter released")
+#   end
+#
+#   decrementer = Thread.new do
+#   sleep(1)
+#   latch.count_down
+#   puts latch.count
+#
+#   sleep(1)
+#   latch.count_down
+#   puts latch.count
+#
+#   sleep(1)
+#   latch.count_down
+#   puts latch.count
+#   end
+#
+#   [waiter, decrementer].each(&:join)
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/count_down_latch.rb#98
+class Concurrent::CountDownLatch < ::Concurrent::MutexCountDownLatch; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/count_down_latch.rb#56
+Concurrent::CountDownLatchImplementation = Concurrent::MutexCountDownLatch
+
+# A synchronization aid that allows a set of threads to all wait for each
+# other to reach a common barrier point.
+#
+# @example
+#   barrier = Concurrent::CyclicBarrier.new(3)
+#   jobs    = Array.new(3) { |i| -> { sleep i; p done: i } }
+#   process = -> (i) do
+#   # waiting to start at the same time
+#   barrier.wait
+#   # execute job
+#   jobs[i].call
+#   # wait for others to finish
+#   barrier.wait
+#   end
+#   threads = 2.times.map do |i|
+#   Thread.new(i, &process)
+#   end
+#
+#   # use main as well
+#   process.call 2
+#
+#   # here we can be sure that all jobs are processed
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb#27
+class Concurrent::CyclicBarrier < ::Concurrent::Synchronization::LockableObject
+  # Create a new `CyclicBarrier` that waits for `parties` threads
+  #
+  # @param parties [Fixnum] the number of parties
+  # @raise [ArgumentError] if `parties` is not an integer or is less than zero
+  # @return [CyclicBarrier] a new instance of CyclicBarrier
+  # @yield an optional block that will be executed that will be executed after
+  #   the last thread arrives and before the others are released
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb#40
+  def initialize(parties, &block); end
+
+  # A barrier can be broken when:
+  # - a thread called the `reset` method while at least one other thread was waiting
+  # - at least one thread timed out on `wait` method
+  #
+  # A broken barrier can be restored using `reset` it's safer to create a new one
+  #
+  # @return [Boolean] true if the barrier is broken otherwise false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb#105
+  def broken?; end
+
+  # @return [Fixnum] the number of threads currently waiting on the barrier
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb#54
+  def number_waiting; end
+
+  # @return [Fixnum] the number of threads needed to pass the barrier
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb#49
+  def parties; end
+
+  # resets the barrier to its initial state
+  # If there is at least one waiting thread, it will be woken up, the `wait`
+  # method will return false and the barrier will be broken
+  # If the barrier is broken, this method restores it to the original state
+  #
+  # @return [nil]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb#95
+  def reset; end
+
+  # Blocks on the barrier until the number of waiting threads is equal to
+  # `parties` or until `timeout` is reached or `reset` is called
+  # If a block has been passed to the constructor, it will be executed once by
+  #  the last arrived thread before releasing the others
+  #
+  # @param timeout [Fixnum] the number of seconds to wait for the counter or
+  #   `nil` to block indefinitely
+  # @return [Boolean] `true` if the `count` reaches zero else false on
+  #   `timeout` or on `reset` or if the barrier is broken
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb#66
+  def wait(timeout = T.unsafe(nil)); end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb#111
+  def ns_generation_done(generation, status, continue = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb#122
+  def ns_initialize(parties, &block); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb#117
+  def ns_next_generation; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb#30
+class Concurrent::CyclicBarrier::Generation < ::Struct
+  # Returns the value of attribute status
+  #
+  # @return [Object] the current value of status
+  def status; end
+
+  # Sets the attribute status
+  #
+  # @param value [Object] the value to set the attribute status to.
+  # @return [Object] the newly set value
+  def status=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# Lazy evaluation of a block yielding an immutable result. Useful for
+# expensive operations that may never be needed. It may be non-blocking,
+# supports the `Concern::Obligation` interface, and accepts the injection of
+# custom executor upon which to execute the block. Processing of
+# block will be deferred until the first time `#value` is called.
+# At that time the caller can choose to return immediately and let
+# the block execute asynchronously, block indefinitely, or block
+# with a timeout.
+#
+# When a `Delay` is created its state is set to `pending`. The value and
+# reason are both `nil`. The first time the `#value` method is called the
+# enclosed opration will be run and the calling thread will block. Other
+# threads attempting to call `#value` will block as well. Once the operation
+# is complete the *value* will be set to the result of the operation or the
+# *reason* will be set to the raised exception, as appropriate. All threads
+# blocked on `#value` will return. Subsequent calls to `#value` will immediately
+# return the cached value. The operation will only be run once. This means that
+# any side effects created by the operation will only happen once as well.
+#
+# `Delay` includes the `Concurrent::Concern::Dereferenceable` mixin to support thread
+# safety of the reference returned by `#value`.
+#
+# @note The default behavior of `Delay` is to block indefinitely when
+#   calling either `value` or `wait`, executing the delayed operation on
+#   the current thread. This makes the `timeout` value completely
+#   irrelevant. To enable non-blocking behavior, use the `executor`
+#   constructor option. This will cause the delayed operation to be
+#   execute on the given executor, allowing the call to timeout.
+# @see Concurrent::Concern::Dereferenceable
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/delay.rb#44
+class Concurrent::Delay < ::Concurrent::Synchronization::LockableObject
+  include ::Concurrent::Concern::Dereferenceable
+  include ::Concurrent::Concern::Obligation
+
+  # Create a new `Delay` in the `:pending` state.
+  #
+  # @raise [ArgumentError] if no block is given
+  # @return [Delay] a new instance of Delay
+  # @yield the delayed operation to perform
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/delay.rb#62
+  def initialize(opts = T.unsafe(nil), &block); end
+
+  # Reconfigures the block returning the value if still `#incomplete?`
+  #
+  # @return [true, false] if success
+  # @yield the delayed operation to perform
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/delay.rb#146
+  def reconfigure(&block); end
+
+  # Return the value this object represents after applying the options
+  # specified by the `#set_deref_options` method. If the delayed operation
+  # raised an exception this method will return nil. The exception object
+  # can be accessed via the `#reason` method.
+  #
+  # @note The default behavior of `Delay` is to block indefinitely when
+  #   calling either `value` or `wait`, executing the delayed operation on
+  #   the current thread. This makes the `timeout` value completely
+  #   irrelevant. To enable non-blocking behavior, use the `executor`
+  #   constructor option. This will cause the delayed operation to be
+  #   execute on the given executor, allowing the call to timeout.
+  # @param timeout [Numeric] the maximum number of seconds to wait
+  # @return [Object] the current value of the object
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/delay.rb#77
+  def value(timeout = T.unsafe(nil)); end
+
+  # Return the value this object represents after applying the options
+  # specified by the `#set_deref_options` method. If the delayed operation
+  # raised an exception, this method will raise that exception (even when)
+  # the operation has already been executed).
+  #
+  # @note The default behavior of `Delay` is to block indefinitely when
+  #   calling either `value` or `wait`, executing the delayed operation on
+  #   the current thread. This makes the `timeout` value completely
+  #   irrelevant. To enable non-blocking behavior, use the `executor`
+  #   constructor option. This will cause the delayed operation to be
+  #   execute on the given executor, allowing the call to timeout.
+  # @param timeout [Numeric] the maximum number of seconds to wait
+  # @raise [Exception] when `#rejected?` raises `#reason`
+  # @return [Object] the current value of the object
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/delay.rb#113
+  def value!(timeout = T.unsafe(nil)); end
+
+  # Return the value this object represents after applying the options
+  # specified by the `#set_deref_options` method.
+  #
+  # @note The default behavior of `Delay` is to block indefinitely when
+  #   calling either `value` or `wait`, executing the delayed operation on
+  #   the current thread. This makes the `timeout` value completely
+  #   irrelevant. To enable non-blocking behavior, use the `executor`
+  #   constructor option. This will cause the delayed operation to be
+  #   execute on the given executor, allowing the call to timeout.
+  # @param timeout [Integer] (nil) the maximum number of seconds to wait for
+  #   the value to be computed. When `nil` the caller will block indefinitely.
+  # @return [Object] self
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/delay.rb#132
+  def wait(timeout = T.unsafe(nil)); end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/delay.rb#160
+  def ns_initialize(opts, &block); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/delay.rb#173
+  def execute_task_once; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#7
+class Concurrent::DependencyCounter
+  # @return [DependencyCounter] a new instance of DependencyCounter
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#9
+  def initialize(count, &block); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#14
+  def update(time, value, reason); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#3
+class Concurrent::Error < ::StandardError; end
+
+# Old school kernel-style event reminiscent of Win32 programming in C++.
+#
+# When an `Event` is created it is in the `unset` state. Threads can choose to
+# `#wait` on the event, blocking until released by another thread. When one
+# thread wants to alert all blocking threads it calls the `#set` method which
+# will then wake up all listeners. Once an `Event` has been set it remains set.
+# New threads calling `#wait` will return immediately. An `Event` may be
+# `#reset` at any time once it has been set.
+#
+# @example
+#   event = Concurrent::Event.new
+#
+#   t1 = Thread.new do
+#   puts "t1 is waiting"
+#   event.wait(1)
+#   puts "event occurred"
+#   end
+#
+#   t2 = Thread.new do
+#   puts "t2 calling set"
+#   event.set
+#   end
+#
+#   [t1, t2].each(&:join)
+#
+#   # prints:
+#   # t1 is waiting
+#   # t2 calling set
+#   # event occurred
+# @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms682655.aspx
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/event.rb#36
+class Concurrent::Event < ::Concurrent::Synchronization::LockableObject
+  # Creates a new `Event` in the unset state. Threads calling `#wait` on the
+  # `Event` will block.
+  #
+  # @return [Event] a new instance of Event
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/event.rb#40
+  def initialize; end
+
+  # Reset a previously set event back to the `unset` state.
+  # Has no effect if the `Event` has not yet been set.
+  #
+  # @return [Boolean] should always return `true`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/event.rb#68
+  def reset; end
+
+  # Trigger the event, setting the state to `set` and releasing all threads
+  # waiting on the event. Has no effect if the `Event` has already been set.
+  #
+  # @return [Boolean] should always return `true`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/event.rb#56
+  def set; end
+
+  # Is the object in the set state?
+  #
+  # @return [Boolean] indicating whether or not the `Event` has been set
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/event.rb#48
+  def set?; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/event.rb#60
+  def try?; end
+
+  # Wait a given number of seconds for the `Event` to be set by another
+  # thread. Will wait forever when no `timeout` value is given. Returns
+  # immediately if the `Event` has already been set.
+  #
+  # @return [Boolean] true if the `Event` was set before timeout else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/event.rb#83
+  def wait(timeout = T.unsafe(nil)); end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/event.rb#104
+  def ns_initialize; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/event.rb#96
+  def ns_set; end
+end
+
+# A synchronization point at which threads can pair and swap elements within
+# pairs. Each thread presents some object on entry to the exchange method,
+# matches with a partner thread, and receives its partner's object on return.
+#
+#
+# ## Thread-safe Variable Classes
+#
+# Each of the thread-safe variable classes is designed to solve a different
+# problem. In general:
+#
+# * *{Concurrent::Agent}:* Shared, mutable variable providing independent,
+#   uncoordinated, *asynchronous* change of individual values. Best used when
+#   the value will undergo frequent, complex updates. Suitable when the result
+#   of an update does not need to be known immediately.
+# * *{Concurrent::Atom}:* Shared, mutable variable providing independent,
+#   uncoordinated, *synchronous* change of individual values. Best used when
+#   the value will undergo frequent reads but only occasional, though complex,
+#   updates. Suitable when the result of an update must be known immediately.
+# * *{Concurrent::AtomicReference}:* A simple object reference that can be updated
+#   atomically. Updates are synchronous but fast. Best used when updates a
+#   simple set operations. Not suitable when updates are complex.
+#   {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar
+#   but optimized for the given data type.
+# * *{Concurrent::Exchanger}:* Shared, stateless synchronization point. Used
+#   when two or more threads need to exchange data. The threads will pair then
+#   block on each other until the exchange is complete.
+# * *{Concurrent::MVar}:* Shared synchronization point. Used when one thread
+#   must give a value to another, which must take the value. The threads will
+#   block on each other until the exchange is complete.
+# * *{Concurrent::ThreadLocalVar}:* Shared, mutable, isolated variable which
+#   holds a different value for each thread which has access. Often used as
+#   an instance variable in objects which must maintain different state
+#   for different threads.
+# * *{Concurrent::TVar}:* Shared, mutable variables which provide
+#   *coordinated*, *synchronous*, change of *many* stated. Used when multiple
+#   value must change together, in an all-or-nothing transaction.
+# This implementation is very simple, using only a single slot for each
+# exchanger (unlike more advanced implementations which use an "arena").
+# This approach will work perfectly fine when there are only a few threads
+# accessing a single `Exchanger`. Beyond a handful of threads the performance
+# will degrade rapidly due to contention on the single slot, but the algorithm
+# will remain correct.
+#
+# @example
+#
+#   exchanger = Concurrent::Exchanger.new
+#
+#   threads = [
+#   Thread.new { puts "first: " << exchanger.exchange('foo', 1) }, #=> "first: bar"
+#   Thread.new { puts "second: " << exchanger.exchange('bar', 1) } #=> "second: foo"
+#   ]
+#   threads.each {|t| t.join(2) }
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Exchanger.html java.util.concurrent.Exchanger
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#336
+class Concurrent::Exchanger < ::Concurrent::RubyExchanger; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#327
+Concurrent::ExchangerImplementation = Concurrent::RubyExchanger
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/executor_service.rb#157
+module Concurrent::ExecutorService
+  include ::Logger::Severity
+  include ::Concurrent::Concern::Logging
+
+  # Submit a task to the executor for asynchronous processing.
+  #
+  # @param task [Proc] the asynchronous task to perform
+  # @return [self] returns itself
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/executor_service.rb#166
+  def <<(task); end
+
+  # Does the task queue have a maximum size?
+  #
+  # @note Always returns `false`
+  # @return [Boolean] True if the task queue has a maximum size else false.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/executor_service.rb#174
+  def can_overflow?; end
+
+  # Submit a task to the executor for asynchronous processing.
+  #
+  # @param args [Array] zero or more arguments to be passed to the task
+  # @raise [ArgumentError] if no task is given
+  # @return [Boolean] `true` if the task is queued, `false` if the executor
+  #   is not running
+  # @yield the asynchronous task to perform
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/executor_service.rb#161
+  def post(*args, &task); end
+
+  # Does this executor guarantee serialization of its operations?
+  #
+  # @note Always returns `false`
+  # @return [Boolean] True if the executor guarantees that all operations
+  #   will be post in the order they are received and no two operations may
+  #   occur simultaneously. Else false.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/executor_service.rb#181
+  def serialized?; end
+end
+
+# A `FiberLocalVar` is a variable where the value is different for each fiber.
+# Each variable may have a default value, but when you modify the variable only
+# the current fiber will ever see that change.
+#
+# This is similar to Ruby's built-in fiber-local variables (`Thread.current[:name]`),
+# but with these major advantages:
+# * `FiberLocalVar` has its own identity, it doesn't need a Symbol.
+# * Each Ruby's built-in fiber-local variable leaks some memory forever (it's a Symbol held forever on the fiber),
+#   so it's only OK to create a small amount of them.
+#   `FiberLocalVar` has no such issue and it is fine to create many of them.
+# * Ruby's built-in fiber-local variables leak forever the value set on each fiber (unless set to nil explicitly).
+#   `FiberLocalVar` automatically removes the mapping for each fiber once the `FiberLocalVar` instance is GC'd.
+#
+# @example
+#   v = FiberLocalVar.new(14)
+#   v.value #=> 14
+#   v.value = 2
+#   v.value #=> 2
+# @example
+#   v = FiberLocalVar.new(14)
+#
+#   Fiber.new do
+#   v.value #=> 14
+#   v.value = 1
+#   v.value #=> 1
+#   end.resume
+#
+#   Fiber.new do
+#   v.value #=> 14
+#   v.value = 2
+#   v.value #=> 2
+#   end.resume
+#
+#   v.value #=> 14
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/fiber_local_var.rb#41
+class Concurrent::FiberLocalVar
+  # Creates a fiber local variable.
+  #
+  # @param default [Object] the default value when otherwise unset
+  # @param default_block [Proc] Optional block that gets called to obtain the
+  #   default value for each fiber
+  # @return [FiberLocalVar] a new instance of FiberLocalVar
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/fiber_local_var.rb#49
+  def initialize(default = T.unsafe(nil), &default_block); end
+
+  # Bind the given value to fiber local storage during
+  # execution of the given block.
+  #
+  # @param value [Object] the value to bind
+  # @return [Object] the value
+  # @yield the operation to be performed with the bound variable
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/fiber_local_var.rb#86
+  def bind(value); end
+
+  # Returns the value in the current fiber's copy of this fiber-local variable.
+  #
+  # @return [Object] the current value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/fiber_local_var.rb#68
+  def value; end
+
+  # Sets the current fiber's copy of this fiber-local variable to the specified value.
+  #
+  # @param value [Object] the value to set
+  # @return [Object] the new value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/fiber_local_var.rb#76
+  def value=(value); end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/fiber_local_var.rb#101
+  def default; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/fiber_local_var.rb#42
+Concurrent::FiberLocalVar::LOCALS = T.let(T.unsafe(nil), Concurrent::FiberLocals)
+
+# An array-backed storage of indexed variables per fiber.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#166
+class Concurrent::FiberLocals < ::Concurrent::AbstractLocals
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#167
+  def locals; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#171
+  def locals!; end
+end
+
+# A thread pool that reuses a fixed number of threads operating off an unbounded queue.
+# At any point, at most `num_threads` will be active processing tasks. When all threads are busy new
+# tasks `#post` to the thread pool are enqueued until a thread becomes available.
+# Should a thread crash for any reason the thread will immediately be removed
+# from the pool and replaced.
+#
+# The API and behavior of this class are based on Java's `FixedThreadPool`
+#
+# **Thread Pool Options**
+#
+# Thread pools support several configuration options:
+#
+# * `idletime`: The number of seconds that a thread may be idle before being reclaimed.
+# * `name`: The name of the executor (optional). Printed in the executor's `#to_s` output and
+#   a `<name>-worker-<id>` name is given to its threads if supported by used Ruby
+#   implementation. `<id>` is uniq for each thread.
+# * `max_queue`: The maximum number of tasks that may be waiting in the work queue at
+#   any one time. When the queue size reaches `max_queue` and no new threads can be created,
+#   subsequent tasks will be rejected in accordance with the configured `fallback_policy`.
+# * `auto_terminate`: When true (default), the threads started will be marked as daemon.
+# * `fallback_policy`: The policy defining how rejected tasks are handled.
+#
+# Three fallback policies are supported:
+#
+# * `:abort`: Raise a `RejectedExecutionError` exception and discard the task.
+# * `:discard`: Discard the task and return false.
+# * `:caller_runs`: Execute the task on the calling thread.
+#
+# **Shutting Down Thread Pools**
+#
+# Killing a thread pool while tasks are still being processed, either by calling
+# the `#kill` method or at application exit, will have unpredictable results. There
+# is no way for the thread pool to know what resources are being used by the
+# in-progress tasks. When those tasks are killed the impact on those resources
+# cannot be predicted. The *best* practice is to explicitly shutdown all thread
+# pools using the provided methods:
+#
+# * Call `#shutdown` to initiate an orderly termination of all in-progress tasks
+# * Call `#wait_for_termination` with an appropriate timeout interval an allow
+#   the orderly shutdown to complete
+# * Call `#kill` *only when* the thread pool fails to shutdown in the allotted time
+#
+# On some runtime platforms (most notably the JVM) the application will not
+# exit until all thread pools have been shutdown. To prevent applications from
+# "hanging" on exit, all threads can be marked as daemon according to the
+# `:auto_terminate` option.
+#
+# ```ruby
+# pool1 = Concurrent::FixedThreadPool.new(5) # threads will be marked as daemon
+# pool2 = Concurrent::FixedThreadPool.new(5, auto_terminate: false) # mark threads as non-daemon
+# ```
+#
+# @note Failure to properly shutdown a thread pool can lead to unpredictable results.
+#   Please read *Shutting Down Thread Pools* for more information.
+# @see http://docs.oracle.com/javase/tutorial/essential/concurrency/pools.html Java Tutorials: Thread Pools
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executors.html Java Executors class
+# @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html Java ExecutorService interface
+# @see https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html#setDaemon-boolean-
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb#201
+class Concurrent::FixedThreadPool < ::Concurrent::ThreadPoolExecutor
+  # Create a new thread pool.
+  #
+  # @option opts
+  # @param num_threads [Integer] the number of threads to allocate
+  # @param opts [Hash] the options defining pool behavior.
+  # @raise [ArgumentError] if `num_threads` is less than or equal to zero
+  # @raise [ArgumentError] if `fallback_policy` is not a known policy
+  # @return [FixedThreadPool] a new instance of FixedThreadPool
+  # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newFixedThreadPool-int-
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb#215
+  def initialize(num_threads, opts = T.unsafe(nil)); end
+end
+
+# {include:file:docs-source/future.md}
+#
+# @see http://ruby-doc.org/stdlib-2.1.1/libdoc/observer/rdoc/Observable.html Ruby Observable module
+# @see http://clojuredocs.org/clojure_core/clojure.core/future Clojure's future function
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Future.html java.util.concurrent.Future
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/future.rb#21
+class Concurrent::Future < ::Concurrent::IVar
+  # Create a new `Future` in the `:unscheduled` state.
+  #
+  # @option opts
+  # @param opts [Hash] a customizable set of options
+  # @raise [ArgumentError] if no block is given
+  # @return [Future] a new instance of Future
+  # @yield the asynchronous operation to perform
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/future.rb#33
+  def initialize(opts = T.unsafe(nil), &block); end
+
+  # Attempt to cancel the operation if it has not already processed.
+  # The operation can only be cancelled while still `pending`. It cannot
+  # be cancelled once it has begun processing or has completed.
+  #
+  # @return [Boolean] was the operation successfully cancelled.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/future.rb#99
+  def cancel; end
+
+  # Has the operation been successfully cancelled?
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/future.rb#111
+  def cancelled?; end
+
+  # Execute an `:unscheduled` `Future`. Immediately sets the state to `:pending` and
+  # passes the block to a new thread/thread pool for eventual execution.
+  # Does nothing if the `Future` is in any state other than `:unscheduled`.
+  #
+  # @example Instance and execute in separate steps
+  #   future = Concurrent::Future.new{ sleep(1); 42 }
+  #   future.state #=> :unscheduled
+  #   future.execute
+  #   future.state #=> :pending
+  # @example Instance and execute in one line
+  #   future = Concurrent::Future.new{ sleep(1); 42 }.execute
+  #   future.state #=> :pending
+  # @return [Future] a reference to `self`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/future.rb#53
+  def execute; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/future.rb#82
+  def set(value = T.unsafe(nil), &block); end
+
+  # Wait the given number of seconds for the operation to complete.
+  # On timeout attempt to cancel the operation.
+  #
+  # @param timeout [Numeric] the maximum time in seconds to wait.
+  # @return [Boolean] true if the operation completed before the timeout
+  #   else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/future.rb#121
+  def wait_or_cancel(timeout); end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/future.rb#133
+  def ns_initialize(value, opts); end
+
+  class << self
+    # Create a new `Future` object with the given block, execute it, and return the
+    # `:pending` object.
+    #
+    # @example
+    #   future = Concurrent::Future.execute{ sleep(1); 42 }
+    #   future.state #=> :pending
+    # @option opts
+    # @param opts [Hash] a customizable set of options
+    # @raise [ArgumentError] if no block is given
+    # @return [Future] the newly created `Future` in the `:pending` state
+    # @yield the asynchronous operation to perform
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/future.rb#77
+    def execute(opts = T.unsafe(nil), &block); end
+  end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#18
+Concurrent::GLOBAL_FAST_EXECUTOR = T.let(T.unsafe(nil), Concurrent::Delay)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#30
+Concurrent::GLOBAL_IMMEDIATE_EXECUTOR = T.let(T.unsafe(nil), Concurrent::ImmediateExecutor)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#22
+Concurrent::GLOBAL_IO_EXECUTOR = T.let(T.unsafe(nil), Concurrent::Delay)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#106
+Concurrent::GLOBAL_LOGGER = T.let(T.unsafe(nil), Concurrent::AtomicReference)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#26
+Concurrent::GLOBAL_TIMER_SET = T.let(T.unsafe(nil), Concurrent::Delay)
+
+# A thread-safe subclass of Hash. This version locks against the object
+# itself for every method call, ensuring only one thread can be reading
+# or writing at a time. This includes iteration methods like `#each`,
+# which takes the lock repeatedly when reading an item.
+#
+# @see http://ruby-doc.org/core/Hash.html Ruby standard library `Hash`
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/hash.rb#49
+class Concurrent::Hash < ::Hash; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/hash.rb#16
+Concurrent::HashImplementation = Hash
+
+# An `IVar` is like a future that you can assign. As a future is a value that
+# is being computed that you can wait on, an `IVar` is a value that is waiting
+# to be assigned, that you can wait on. `IVars` are single assignment and
+# deterministic.
+#
+# Then, express futures as an asynchronous computation that assigns an `IVar`.
+# The `IVar` becomes the primitive on which [futures](Future) and
+# [dataflow](Dataflow) are built.
+#
+# An `IVar` is a single-element container that is normally created empty, and
+# can only be set once. The I in `IVar` stands for immutable. Reading an
+# `IVar` normally blocks until it is set. It is safe to set and read an `IVar`
+# from different threads.
+#
+# If you want to have some parallel task set the value in an `IVar`, you want
+# a `Future`. If you want to create a graph of parallel tasks all executed
+# when the values they depend on are ready you want `dataflow`. `IVar` is
+# generally a low-level primitive.
+#
+# ## Examples
+#
+# Create, set and get an `IVar`
+#
+# ```ruby
+# ivar = Concurrent::IVar.new
+# ivar.set 14
+# ivar.value #=> 14
+# ivar.set 2 # would now be an error
+# ```
+#
+# ## See Also
+#
+# 1. For the theory: Arvind, R. Nikhil, and K. Pingali.
+#    [I-Structures: Data structures for parallel computing](http://dl.acm.org/citation.cfm?id=69562).
+#    In Proceedings of Workshop on Graph Reduction, 1986.
+# 2. For recent application:
+#    [DataDrivenFuture in Habanero Java from Rice](http://www.cs.rice.edu/~vs3/hjlib/doc/edu/rice/hj/api/HjDataDrivenFuture.html).
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#48
+class Concurrent::IVar < ::Concurrent::Synchronization::LockableObject
+  include ::Concurrent::Concern::Dereferenceable
+  include ::Concurrent::Concern::Obligation
+  include ::Concurrent::Concern::Observable
+
+  # Create a new `IVar` in the `:pending` state with the (optional) initial value.
+  #
+  # @option opts
+  # @option opts
+  # @option opts
+  # @param value [Object] the initial value
+  # @param opts [Hash] the options to create a message with
+  # @return [IVar] a new instance of IVar
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#62
+  def initialize(value = T.unsafe(nil), opts = T.unsafe(nil), &block); end
+
+  # Add an observer on this object that will receive notification on update.
+  #
+  # Upon completion the `IVar` will notify all observers in a thread-safe way.
+  # The `func` method of the observer will be called with three arguments: the
+  # `Time` at which the `Future` completed the asynchronous operation, the
+  # final `value` (or `nil` on rejection), and the final `reason` (or `nil` on
+  # fulfillment).
+  #
+  # @param observer [Object] the object that will be notified of changes
+  # @param func [Symbol] symbol naming the method to call when this
+  #   `Observable` has changes`
+  # @raise [ArgumentError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#81
+  def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
+
+  # Set the `IVar` to failed due to some error and wake or notify all threads waiting on it.
+  #
+  # @param reason [Object] for the failure
+  # @raise [Concurrent::MultipleAssignmentError] if the `IVar` has already
+  #   been set or otherwise completed
+  # @return [IVar] self
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#135
+  def fail(reason = T.unsafe(nil)); end
+
+  # Set the `IVar` to a value and wake or notify all threads waiting on it.
+  #
+  # @param value [Object] the value to store in the `IVar`
+  # @raise [ArgumentError] if both a value and a block are given
+  # @raise [Concurrent::MultipleAssignmentError] if the `IVar` has already
+  #   been set or otherwise completed
+  # @return [IVar] self
+  # @yield A block operation to use for setting the value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#113
+  def set(value = T.unsafe(nil)); end
+
+  # Attempt to set the `IVar` with the given value or block. Return a
+  # boolean indicating the success or failure of the set operation.
+  #
+  # @param value [Object] the value to store in the `IVar`
+  # @raise [ArgumentError] if both a value and a block are given
+  # @raise [Concurrent::MultipleAssignmentError] if the `IVar` has already
+  #   been set or otherwise completed
+  # @return [Boolean] true if the value was set else false
+  # @yield A block operation to use for setting the value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#145
+  def try_set(value = T.unsafe(nil), &block); end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#202
+  def check_for_block_or_value!(block_given, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#177
+  def complete(success, value, reason); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#184
+  def complete_without_notification(success, value, reason); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#190
+  def notify_observers(value, reason); end
+
+  # @raise [MultipleAssignmentError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#195
+  def ns_complete_without_notification(success, value, reason); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#155
+  def ns_initialize(value, opts); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#168
+  def safe_execute(task, args = T.unsafe(nil)); end
+end
+
+# Raised when an operation is attempted which is not legal given the
+# receiver's current state
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#20
+class Concurrent::IllegalOperationError < ::Concurrent::Error; end
+
+# An executor service which runs all operations on the current thread,
+# blocking as necessary. Operations are performed in the order they are
+# received and no two operations can be performed simultaneously.
+#
+# This executor service exists mainly for testing an debugging. When used
+# it immediately runs every `#post` operation on the current thread, blocking
+# that thread until the operation is complete. This can be very beneficial
+# during testing because it makes all operations deterministic.
+#
+# @note Intended for use primarily in testing and debugging.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/immediate_executor.rb#17
+class Concurrent::ImmediateExecutor < ::Concurrent::AbstractExecutorService
+  include ::Concurrent::SerialExecutorService
+
+  # Creates a new executor
+  #
+  # @return [ImmediateExecutor] a new instance of ImmediateExecutor
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/immediate_executor.rb#21
+  def initialize; end
+
+  # Submit a task to the executor for asynchronous processing.
+  #
+  # @param task [Proc] the asynchronous task to perform
+  # @return [self] returns itself
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/immediate_executor.rb#34
+  def <<(task); end
+
+  # Begin an orderly shutdown. Tasks already in the queue will be executed,
+  # but no new tasks will be accepted. Has no additional effect if the
+  # thread pool is not running.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/immediate_executor.rb#55
+  def kill; end
+
+  # Submit a task to the executor for asynchronous processing.
+  #
+  # @param args [Array] zero or more arguments to be passed to the task
+  # @raise [ArgumentError] if no task is given
+  # @return [Boolean] `true` if the task is queued, `false` if the executor
+  #   is not running
+  # @yield the asynchronous task to perform
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/immediate_executor.rb#26
+  def post(*args, &task); end
+
+  # Is the executor running?
+  #
+  # @return [Boolean] `true` when running, `false` when shutting down or shutdown
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/immediate_executor.rb#40
+  def running?; end
+
+  # Begin an orderly shutdown. Tasks already in the queue will be executed,
+  # but no new tasks will be accepted. Has no additional effect if the
+  # thread pool is not running.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/immediate_executor.rb#55
+  def shutdown; end
+
+  # Is the executor shutdown?
+  #
+  # @return [Boolean] `true` when shutdown, `false` when shutting down or running
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/immediate_executor.rb#50
+  def shutdown?; end
+
+  # Is the executor shuttingdown?
+  #
+  # @return [Boolean] `true` when not running and not shutdown, else `false`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/immediate_executor.rb#45
+  def shuttingdown?; end
+
+  # Block until executor shutdown is complete or until `timeout` seconds have
+  # passed.
+  #
+  # @note Does not initiate shutdown or termination. Either `shutdown` or `kill`
+  #   must be called before this method (or on another thread).
+  # @param timeout [Integer] the maximum number of seconds to wait for shutdown to complete
+  # @return [Boolean] `true` if shutdown complete or false on `timeout`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/immediate_executor.rb#62
+  def wait_for_termination(timeout = T.unsafe(nil)); end
+end
+
+# Raised when an attempt is made to violate an immutability guarantee.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#16
+class Concurrent::ImmutabilityError < ::Concurrent::Error; end
+
+# A thread-safe, immutable variation of Ruby's standard `Struct`.
+#
+# @see http://ruby-doc.org/core/Struct.html Ruby standard library `Struct`
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#9
+module Concurrent::ImmutableStruct
+  include ::Concurrent::Synchronization::AbstractStruct
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#51
+  def ==(other); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#46
+  def [](member); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#56
+  def each(&block); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#62
+  def each_pair(&block); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#29
+  def inspect; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#36
+  def merge(other, &block); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#68
+  def select(&block); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#17
+  def to_a; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#41
+  def to_h; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#29
+  def to_s; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#17
+  def values; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#24
+  def values_at(*indexes); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#76
+  def initialize_copy(original); end
+
+  class << self
+    # @private
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#12
+    def included(base); end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#82
+    def new(*args, &block); end
+  end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/immutable_struct.rb#92
+Concurrent::ImmutableStruct::FACTORY = T.let(T.unsafe(nil), T.untyped)
+
+# An executor service which runs all operations on a new thread, blocking
+# until it completes. Operations are performed in the order they are received
+# and no two operations can be performed simultaneously.
+#
+# This executor service exists mainly for testing an debugging. When used it
+# immediately runs every `#post` operation on a new thread, blocking the
+# current thread until the operation is complete. This is similar to how the
+# ImmediateExecutor works, but the operation has the full stack of the new
+# thread at its disposal. This can be helpful when the operations will spawn
+# more operations on the same executor and so on - such a situation might
+# overflow the single stack in case of an ImmediateExecutor, which is
+# inconsistent with how it would behave for a threaded executor.
+#
+# @note Intended for use primarily in testing and debugging.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/indirect_immediate_executor.rb#19
+class Concurrent::IndirectImmediateExecutor < ::Concurrent::ImmediateExecutor
+  # Creates a new executor
+  #
+  # @return [IndirectImmediateExecutor] a new instance of IndirectImmediateExecutor
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/indirect_immediate_executor.rb#21
+  def initialize; end
+
+  # Submit a task to the executor for asynchronous processing.
+  #
+  # @param args [Array] zero or more arguments to be passed to the task
+  # @raise [ArgumentError] if no task is given
+  # @return [Boolean] `true` if the task is queued, `false` if the executor
+  #   is not running
+  # @yield the asynchronous task to perform
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/indirect_immediate_executor.rb#27
+  def post(*args, &task); end
+end
+
+# Raised when an object's methods are called when it has not been
+# properly initialized.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#24
+class Concurrent::InitializationError < ::Concurrent::Error; end
+
+# Raised when a lifecycle method (such as `stop`) is called in an improper
+# sequence or when the object is in an inappropriate state.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#13
+class Concurrent::LifecycleError < ::Concurrent::Error; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#6
+class Concurrent::LockFreeStack < ::Concurrent::Synchronization::Object
+  include ::Enumerable
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # @param head [Node]
+  # @return [LockFreeStack] a new instance of LockFreeStack
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#51
+  def initialize(head = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#137
+  def __initialize_atomic_fields__; end
+
+  # @return [true, false]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#118
+  def clear; end
+
+  # @return [self]
+  # @yield over the cleared stack
+  # @yieldparam value [Object]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#142
+  def clear_each(&block); end
+
+  # @param head [Node]
+  # @return [true, false]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#128
+  def clear_if(head); end
+
+  # @param head [Node]
+  # @return [true, false]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#99
+  def compare_and_clear(head); end
+
+  # @param head [Node]
+  # @return [true, false]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#85
+  def compare_and_pop(head); end
+
+  # @param head [Node]
+  # @param value [Object]
+  # @return [true, false]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#65
+  def compare_and_push(head, value); end
+
+  # @param head [Node]
+  # @return [self]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#107
+  def each(head = T.unsafe(nil)); end
+
+  # @param head [Node]
+  # @return [true, false]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#58
+  def empty?(head = T.unsafe(nil)); end
+
+  # @return [String] Short string representation.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#154
+  def inspect; end
+
+  # @return [Node]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#79
+  def peek; end
+
+  # @return [Object]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#90
+  def pop; end
+
+  # @param value [Object]
+  # @return [self]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#71
+  def push(value); end
+
+  # @param head [Node]
+  # @param new_head [Node]
+  # @return [true, false]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#135
+  def replace_if(head, new_head); end
+
+  # @return [String] Short string representation.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#154
+  def to_s; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#105
+  def compare_and_set_head(expected, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#93
+  def head; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#97
+  def head=(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#101
+  def swap_head(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#109
+  def update_head(&block); end
+
+  class << self
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#41
+    def of1(value); end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#46
+    def of2(value1, value2); end
+  end
+end
+
+# The singleton for empty node
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#32
+Concurrent::LockFreeStack::EMPTY = T.let(T.unsafe(nil), Concurrent::LockFreeStack::Node)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#10
+class Concurrent::LockFreeStack::Node
+  # @return [Node] a new instance of Node
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#23
+  def initialize(value, next_node); end
+
+  # @return [Node]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#14
+  def next_node; end
+
+  # @return [Object]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#17
+  def value; end
+
+  # allow to nil-ify to free GC when the entry is no longer relevant, not synchronised
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb#21
+  def value=(_arg0); end
+
+  class << self
+    def [](*_arg0); end
+  end
+end
+
+# Either {FiberLocalVar} or {ThreadLocalVar} depending on whether Mutex (and Monitor)
+# are held, respectively, per Fiber or per Thread.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/lock_local_var.rb#21
+Concurrent::LockLocalVar = Concurrent::FiberLocalVar
+
+# An `MVar` is a synchronized single element container. They are empty or
+# contain one item. Taking a value from an empty `MVar` blocks, as does
+# putting a value into a full one. You can either think of them as blocking
+# queue of length one, or a special kind of mutable variable.
+#
+# On top of the fundamental `#put` and `#take` operations, we also provide a
+# `#mutate` that is atomic with respect to operations on the same instance.
+# These operations all support timeouts.
+#
+# We also support non-blocking operations `#try_put!` and `#try_take!`, a
+# `#set!` that ignores existing values, a `#value` that returns the value
+# without removing it or returns `MVar::EMPTY`, and a `#modify!` that yields
+# `MVar::EMPTY` if the `MVar` is empty and can be used to set `MVar::EMPTY`.
+# You shouldn't use these operations in the first instance.
+#
+# `MVar` is a [Dereferenceable](Dereferenceable).
+#
+# `MVar` is related to M-structures in Id, `MVar` in Haskell and `SyncVar` in Scala.
+#
+# Note that unlike the original Haskell paper, our `#take` is blocking. This is how
+# Haskell and Scala do it today.
+#
+# ## See Also
+#
+# 1. P. Barth, R. Nikhil, and Arvind. [M-Structures: Extending a parallel, non- strict, functional language with state](http://dl.acm.org/citation.cfm?id=652538). In Proceedings of the 5th
+#    ACM Conference on Functional Programming Languages and Computer Architecture (FPCA), 1991.
+#
+# 2. S. Peyton Jones, A. Gordon, and S. Finne. [Concurrent Haskell](http://dl.acm.org/citation.cfm?id=237794).
+#    In Proceedings of the 23rd Symposium on Principles of Programming Languages
+#    (PoPL), 1996.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#38
+class Concurrent::MVar < ::Concurrent::Synchronization::Object
+  include ::Concurrent::Concern::Dereferenceable
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # Create a new `MVar`, either empty or with an initial value.
+  #
+  # @param opts [Hash] the options controlling how the future will be processed
+  # @return [MVar] a new instance of MVar
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#54
+  def initialize(value = T.unsafe(nil), opts = T.unsafe(nil)); end
+
+  # acquires lock on the from an `MVAR`, yields the value to provided block,
+  # and release lock. A timeout can be set to limit the time spent blocked,
+  # in which case it returns `TIMEOUT` if the time is exceeded.
+  #
+  # @return [Object] the value returned by the block, or `TIMEOUT`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#86
+  def borrow(timeout = T.unsafe(nil)); end
+
+  # Returns if the `MVar` is currently empty.
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#195
+  def empty?; end
+
+  # Returns if the `MVar` currently contains a value.
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#200
+  def full?; end
+
+  # Atomically `take`, yield the value to a block for transformation, and then
+  # `put` the transformed value. Returns the transformed value. A timeout can
+  # be set to limit the time spent blocked, in which case it returns `TIMEOUT`
+  # if the time is exceeded.
+  #
+  # @raise [ArgumentError]
+  # @return [Object] the transformed value, or `TIMEOUT`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#123
+  def modify(timeout = T.unsafe(nil)); end
+
+  # Non-blocking version of `modify` that will yield with `EMPTY` if there is no value yet.
+  #
+  # @raise [ArgumentError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#179
+  def modify!; end
+
+  # Put a value into an `MVar`, blocking if there is already a value until
+  # it is empty. A timeout can be set to limit the time spent blocked, in
+  # which case it returns `TIMEOUT` if the time is exceeded.
+  #
+  # @return [Object] the value that was put, or `TIMEOUT`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#103
+  def put(value, timeout = T.unsafe(nil)); end
+
+  # Non-blocking version of `put` that will overwrite an existing value.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#169
+  def set!(value); end
+
+  # Remove the value from an `MVar`, leaving it empty, and blocking if there
+  # isn't a value. A timeout can be set to limit the time spent blocked, in
+  # which case it returns `TIMEOUT` if the time is exceeded.
+  #
+  # @return [Object] the value that was taken, or `TIMEOUT`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#66
+  def take(timeout = T.unsafe(nil)); end
+
+  # Non-blocking version of `put`, that returns whether or not it was successful.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#156
+  def try_put!(value); end
+
+  # Non-blocking version of `take`, that returns `EMPTY` instead of blocking.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#142
+  def try_take!; end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#206
+  def synchronize(&block); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#212
+  def unlocked_empty?; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#216
+  def unlocked_full?; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#224
+  def wait_for_empty(timeout); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#220
+  def wait_for_full(timeout); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#228
+  def wait_while(condition, timeout); end
+end
+
+# Unique value that represents that an `MVar` was empty
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#43
+Concurrent::MVar::EMPTY = T.let(T.unsafe(nil), Object)
+
+# Unique value that represents that an `MVar` timed out before it was able
+# to produce a value.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/mvar.rb#47
+Concurrent::MVar::TIMEOUT = T.let(T.unsafe(nil), Object)
+
+# `Concurrent::Map` is a hash-like object and should have much better performance
+# characteristics, especially under high concurrency, than `Concurrent::Hash`.
+# However, `Concurrent::Map `is not strictly semantically equivalent to a ruby `Hash`
+# -- for instance, it does not necessarily retain ordering by insertion time as `Hash`
+# does. For most uses it should do fine though, and we recommend you consider
+# `Concurrent::Map` instead of `Concurrent::Hash` for your concurrency-safe hash needs.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#39
+class Concurrent::Map < ::Concurrent::Collection::MriMapBackend
+  # Iterates over each key value pair.
+  # This method is atomic.
+  #
+  # @note Atomic methods taking a block do not allow the `self` instance
+  #   to be used within the block. Doing so will cause a deadlock.
+  # @return [self]
+  # @yield for each key value pair in the map
+  # @yieldparam key [Object]
+  # @yieldparam value [Object]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#274
+  def each; end
+
+  # Iterates over each key.
+  # This method is atomic.
+  #
+  # @note Atomic methods taking a block do not allow the `self` instance
+  #   to be used within the block. Doing so will cause a deadlock.
+  # @return [self]
+  # @yield for each key in the map
+  # @yieldparam key [Object]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#255
+  def each_key; end
+
+  # Iterates over each key value pair.
+  # This method is atomic.
+  #
+  # @note Atomic methods taking a block do not allow the `self` instance
+  #   to be used within the block. Doing so will cause a deadlock.
+  # @return [self]
+  # @yield for each key value pair in the map
+  # @yieldparam key [Object]
+  # @yieldparam value [Object]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#274
+  def each_pair; end
+
+  # Iterates over each value.
+  # This method is atomic.
+  #
+  # @note Atomic methods taking a block do not allow the `self` instance
+  #   to be used within the block. Doing so will cause a deadlock.
+  # @return [self]
+  # @yield for each value in the map
+  # @yieldparam value [Object]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#264
+  def each_value; end
+
+  # Is map empty?
+  #
+  # @return [true, false]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#291
+  def empty?; end
+
+  # Get a value with key, or default_value when key is absent,
+  # or fail when no default_value is given.
+  #
+  # @note The "fetch-then-act" methods of `Map` are not atomic. `Map` is intended
+  #   to be use as a concurrency primitive with strong happens-before
+  #   guarantees. It is not intended to be used as a high-level abstraction
+  #   supporting complex operations. All read and write operations are
+  #   thread safe, but no guarantees are made regarding race conditions
+  #   between the fetch operation and yielding to the block. Additionally,
+  #   this method does not support recursion. This is due to internal
+  #   constraints that are very unlikely to change in the near future.
+  # @param key [Object]
+  # @param default_value [Object]
+  # @raise [KeyError] when key is missing and no default_value is provided
+  # @return [Object] the value or default value
+  # @yield default value for a key
+  # @yieldparam key [Object]
+  # @yieldreturn [Object] default value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#183
+  def fetch(key, default_value = T.unsafe(nil)); end
+
+  # Fetch value with key, or store default value when key is absent,
+  # or fail when no default_value is given. This is a two step operation,
+  # therefore not atomic. The store can overwrite other concurrently
+  # stored value.
+  #
+  # @param key [Object]
+  # @param default_value [Object]
+  # @return [Object] the value or default value
+  # @yield default value for a key
+  # @yieldparam key [Object]
+  # @yieldreturn [Object] default value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#205
+  def fetch_or_store(key, default_value = T.unsafe(nil)); end
+
+  # Get a value with key
+  #
+  # @param key [Object]
+  # @return [Object] the value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb#21
+  def get(key); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#321
+  def inspect; end
+
+  # Find key of a value.
+  #
+  # @param value [Object]
+  # @return [Object, nil] key or nil when not found
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#284
+  def key(value); end
+
+  # All keys
+  #
+  # @return [::Array<Object>] keys
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#236
+  def keys; end
+
+  # @raise [TypeError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#305
+  def marshal_dump; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#313
+  def marshal_load(hash); end
+
+  # Set a value with key
+  #
+  # @param key [Object]
+  # @param value [Object]
+  # @return [Object] the new value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb#17
+  def put(key, value); end
+
+  # Insert value into map with key if key is absent in one atomic step.
+  #
+  # @param key [Object]
+  # @param value [Object]
+  # @return [Object, nil] the previous value when key was present or nil when there was no key
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#215
+  def put_if_absent(key, value); end
+
+  # Is the value stored in the map. Iterates over all values.
+  #
+  # @param value [Object]
+  # @return [true, false]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#227
+  def value?(value); end
+
+  # All values
+  #
+  # @return [::Array<Object>] values
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#244
+  def values; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#331
+  def initialize_copy(other); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#336
+  def populate_from(hash); end
+
+  # @raise [KeyError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#327
+  def raise_fetch_no_key; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/map.rb#341
+  def validate_options_hash!(options); end
+end
+
+# Raised when an object with a start/stop lifecycle has been started an
+# excessive number of times. Often used in conjunction with a restart
+# policy or strategy.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#29
+class Concurrent::MaxRestartFrequencyError < ::Concurrent::Error; end
+
+# A `Maybe` encapsulates an optional value. A `Maybe` either contains a value
+# of (represented as `Just`), or it is empty (represented as `Nothing`). Using
+# `Maybe` is a good way to deal with errors or exceptional cases without
+# resorting to drastic measures such as exceptions.
+#
+# `Maybe` is a replacement for the use of `nil` with better type checking.
+#
+# For compatibility with {Concurrent::Concern::Obligation} the predicate and
+# accessor methods are aliased as `fulfilled?`, `rejected?`, `value`, and
+# `reason`.
+#
+# ## Motivation
+#
+# A common pattern in languages with pattern matching, such as Erlang and
+# Haskell, is to return *either* a value *or* an error from a function
+# Consider this Erlang code:
+#
+# ```erlang
+# case file:consult("data.dat") of
+#   {ok, Terms} -> do_something_useful(Terms);
+#   {error, Reason} -> lager:error(Reason)
+# end.
+# ```
+#
+# In this example the standard library function `file:consult` returns a
+# [tuple](http://erlang.org/doc/reference_manual/data_types.html#id69044)
+# with two elements: an [atom](http://erlang.org/doc/reference_manual/data_types.html#id64134)
+# (similar to a ruby symbol) and a variable containing ancillary data. On
+# success it returns the atom `ok` and the data from the file. On failure it
+# returns `error` and a string with an explanation of the problem. With this
+# pattern there is no ambiguity regarding success or failure. If the file is
+# empty the return value cannot be misinterpreted as an error. And when an
+# error occurs the return value provides useful information.
+#
+# In Ruby we tend to return `nil` when an error occurs or else we raise an
+# exception. Both of these idioms are problematic. Returning `nil` is
+# ambiguous because `nil` may also be a valid value. It also lacks
+# information pertaining to the nature of the error. Raising an exception
+# is both expensive and usurps the normal flow of control. All of these
+# problems can be solved with the use of a `Maybe`.
+#
+# A `Maybe` is unambiguous with regard to whether or not it contains a value.
+# When `Just` it contains a value, when `Nothing` it does not. When `Just`
+# the value it contains may be `nil`, which is perfectly valid. When
+# `Nothing` the reason for the lack of a value is contained as well. The
+# previous Erlang example can be duplicated in Ruby in a principled way by
+# having functions return `Maybe` objects:
+#
+# ```ruby
+# result = MyFileUtils.consult("data.dat") # returns a Maybe
+# if result.just?
+#   do_something_useful(result.value)      # or result.just
+# else
+#   logger.error(result.reason)            # or result.nothing
+# end
+# ```
+#
+# @example Returning a Maybe from a Function
+#   module MyFileUtils
+#   def self.consult(path)
+#   file = File.open(path, 'r')
+#   Concurrent::Maybe.just(file.read)
+#   rescue => ex
+#   return Concurrent::Maybe.nothing(ex)
+#   ensure
+#   file.close if file
+#   end
+#   end
+#
+#   maybe = MyFileUtils.consult('bogus.file')
+#   maybe.just?    #=> false
+#   maybe.nothing? #=> true
+#   maybe.reason   #=> #<Errno::ENOENT: No such file or directory @ rb_sysopen - bogus.file>
+#
+#   maybe = MyFileUtils.consult('README.md')
+#   maybe.just?    #=> true
+#   maybe.nothing? #=> false
+#   maybe.value    #=> "# Concurrent Ruby\n[![Gem Version..."
+# @example Using Maybe with a Block
+#   result = Concurrent::Maybe.from do
+#   Client.find(10) # Client is an ActiveRecord model
+#   end
+#
+#   # -- if the record was found
+#   result.just? #=> true
+#   result.value #=> #<Client id: 10, first_name: "Ryan">
+#
+#   # -- if the record was not found
+#   result.just?  #=> false
+#   result.reason #=> ActiveRecord::RecordNotFound
+# @example Using Maybe with the Null Object Pattern
+#   # In a Rails controller...
+#   result = ClientService.new(10).find    # returns a Maybe
+#   render json: result.or(NullClient.new)
+# @see https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Maybe.html Haskell Data.Maybe
+# @see https://github.com/purescript/purescript-maybe/blob/master/docs/Data.Maybe.md PureScript Data.Maybe
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#104
+class Concurrent::Maybe < ::Concurrent::Synchronization::Object
+  include ::Comparable
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # Create a new `Maybe` with the given attributes.
+  #
+  # @param just [Object] The value when `Just` else `NONE`.
+  # @param nothing [Exception, Object] The exception when `Nothing` else `NONE`.
+  # @return [Maybe] The new `Maybe`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#224
+  def initialize(just, nothing); end
+
+  # Comparison operator.
+  #
+  # @return [Integer] 0 if self and other are both `Nothing`;
+  #   -1 if self is `Nothing` and other is `Just`;
+  #   1 if self is `Just` and other is nothing;
+  #   `self.just <=> other.just` if both self and other are `Just`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#199
+  def <=>(other); end
+
+  # Is this `Maybe` a `Just` (successfully fulfilled with a value)?
+  #
+  # @return [Boolean] True if `Just` or false if `Nothing`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#176
+  def fulfilled?; end
+
+  # The value of a `Maybe` when `Just`. Will be `NONE` when `Nothing`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#114
+  def just; end
+
+  # Is this `Maybe` a `Just` (successfully fulfilled with a value)?
+  #
+  # @return [Boolean] True if `Just` or false if `Nothing`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#176
+  def just?; end
+
+  # The reason for the `Maybe` when `Nothing`. Will be `NONE` when `Just`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#117
+  def nothing; end
+
+  # Is this `Maybe` a `nothing` (rejected with an exception upon fulfillment)?
+  #
+  # @return [Boolean] True if `Nothing` or false if `Just`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#184
+  def nothing?; end
+
+  # Return either the value of self or the given default value.
+  #
+  # @return [Object] The value of self when `Just`; else the given default.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#210
+  def or(other); end
+
+  # The reason for the `Maybe` when `Nothing`. Will be `NONE` when `Just`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#117
+  def reason; end
+
+  # Is this `Maybe` a `nothing` (rejected with an exception upon fulfillment)?
+  #
+  # @return [Boolean] True if `Nothing` or false if `Just`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#184
+  def rejected?; end
+
+  # The value of a `Maybe` when `Just`. Will be `NONE` when `Nothing`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#114
+  def value; end
+
+  class << self
+    # Create a new `Maybe` using the given block.
+    #
+    # Runs the given block passing all function arguments to the block as block
+    # arguments. If the block runs to completion without raising an exception
+    # a new `Just` is created with the value set to the return value of the
+    # block. If the block raises an exception a new `Nothing` is created with
+    # the reason being set to the raised exception.
+    #
+    # @param args [Array<Object>] Zero or more arguments to pass to the block.
+    # @raise [ArgumentError] when no block given.
+    # @return [Maybe] The newly created object.
+    # @yield The block from which to create a new `Maybe`.
+    # @yieldparam args [Array<Object>] Zero or more block arguments passed as
+    #   arguments to the function.
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#137
+    def from(*args); end
+
+    # Create a new `Just` with the given value.
+    #
+    # @param value [Object] The value to set for the new `Maybe` object.
+    # @return [Maybe] The newly created object.
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#152
+    def just(value); end
+
+    # Create a new `Nothing` with the given (optional) reason.
+    #
+    # @param error [Exception] The reason to set for the new `Maybe` object.
+    #   When given a string a new `StandardError` will be created with the
+    #   argument as the message. When no argument is given a new
+    #   `StandardError` with an empty message will be created.
+    # @return [Maybe] The newly created object.
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#164
+    def nothing(error = T.unsafe(nil)); end
+
+    private
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/safe_initialization.rb#29
+    def new(*args, &block); end
+  end
+end
+
+# Indicates that the given attribute has not been set.
+# When `Just` the {#nothing} getter will return `NONE`.
+# When `Nothing` the {#just} getter will return `NONE`.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/maybe.rb#111
+Concurrent::Maybe::NONE = T.let(T.unsafe(nil), Object)
+
+# Raised when an attempt is made to modify an immutable object
+# (such as an `IVar`) after its final state has been set.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#33
+class Concurrent::MultipleAssignmentError < ::Concurrent::Error
+  # @return [MultipleAssignmentError] a new instance of MultipleAssignmentError
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#36
+  def initialize(message = T.unsafe(nil), inspection_data = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#41
+  def inspect; end
+
+  # Returns the value of attribute inspection_data.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#34
+  def inspection_data; end
+end
+
+# Aggregates multiple exceptions.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#58
+class Concurrent::MultipleErrors < ::Concurrent::Error
+  # @return [MultipleErrors] a new instance of MultipleErrors
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#61
+  def initialize(errors, message = T.unsafe(nil)); end
+
+  # Returns the value of attribute errors.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#59
+  def errors; end
+end
+
+# An thread-safe variation of Ruby's standard `Struct`. Values can be set at
+# construction or safely changed at any time during the object's lifecycle.
+#
+# @see http://ruby-doc.org/core/Struct.html Ruby standard library `Struct`
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#10
+module Concurrent::MutableStruct
+  include ::Concurrent::Synchronization::AbstractStruct
+
+  # Equality
+  #
+  # @return [Boolean] true if other has the same struct subclass and has
+  #   equal member values (according to `Object#==`)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#128
+  def ==(other); end
+
+  # Attribute Reference
+  #
+  # @param member [Symbol, String, Integer] the string or symbol name of the member
+  #   for which to obtain the value or the member's index
+  # @raise [NameError] if the member does not exist
+  # @raise [IndexError] if the index is out of range.
+  # @return [Object] the value of the given struct member or the member at the given index.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#118
+  def [](member); end
+
+  # Attribute Assignment
+  #
+  # Sets the value of the given struct member or the member at the given index.
+  #
+  # @param member [Symbol, String, Integer] the string or symbol name of the member
+  #   for which to obtain the value or the member's index
+  # @raise [NameError] if the name does not exist
+  # @raise [IndexError] if the index is out of range.
+  # @return [Object] the value of the given struct member or the member at the given index.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#185
+  def []=(member, value); end
+
+  # Yields the value of each struct member in order. If no block is given
+  # an enumerator is returned.
+  #
+  # @yield the operation to be performed on each struct member
+  # @yieldparam value [Object] each struct value (in order)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#139
+  def each(&block); end
+
+  # Yields the name and value of each struct member in order. If no block is
+  # given an enumerator is returned.
+  #
+  # @yield the operation to be performed on each struct member/value pair
+  # @yieldparam member [Object] each struct member (in order)
+  # @yieldparam value [Object] each struct value (in order)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#152
+  def each_pair(&block); end
+
+  # Describe the contents of this struct in a string.
+  #
+  # @return [String] the contents of this struct in a string
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#72
+  def inspect; end
+
+  # Returns a new struct containing the contents of `other` and the contents
+  # of `self`. If no block is specified, the value for entries with duplicate
+  # keys will be that of `other`. Otherwise the value for each duplicate key
+  # is determined by calling the block with the key, its value in `self` and
+  # its value in `other`.
+  #
+  # @param other [Hash] the hash from which to set the new values
+  # @raise [ArgumentError] of given a member that is not defined in the struct
+  # @return [Synchronization::AbstractStruct] a new struct with the new values
+  # @yield an options block for resolving duplicate keys
+  # @yieldparam member [String, Symbol] the name of the member which is duplicated
+  # @yieldparam selfvalue [Object] the value of the member in `self`
+  # @yieldparam othervalue [Object] the value of the member in `other`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#94
+  def merge(other, &block); end
+
+  # Yields each member value from the struct to the block and returns an Array
+  # containing the member values from the struct for which the given block
+  # returns a true value (equivalent to `Enumerable#select`).
+  #
+  # @return [Array] an array containing each value for which the block returns true
+  # @yield the operation to be performed on each struct member
+  # @yieldparam value [Object] each struct value (in order)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#167
+  def select(&block); end
+
+  # Returns the values for this struct as an Array.
+  #
+  # @return [Array] the values for this struct
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#51
+  def to_a; end
+
+  # Returns a hash containing the names and values for the struct’s members.
+  #
+  # @return [Hash] the names and values for the struct’s members
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#103
+  def to_h; end
+
+  # Describe the contents of this struct in a string.
+  #
+  # @return [String] the contents of this struct in a string
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#72
+  def to_s; end
+
+  # Returns the values for this struct as an Array.
+  #
+  # @return [Array] the values for this struct
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#51
+  def values; end
+
+  # Returns the struct member values for each selector as an Array.
+  #
+  # A selector may be either an Integer offset or a Range of offsets (as in `Array#values_at`).
+  #
+  # @param indexes [Fixnum, Range] the index(es) from which to obatin the values (in order)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#63
+  def values_at(*indexes); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#202
+  def initialize_copy(original); end
+
+  class << self
+    # Factory for creating new struct classes.
+    #
+    # ```
+    # new([class_name] [, member_name]+>) -> StructClass click to toggle source
+    # new([class_name] [, member_name]+>) {|StructClass| block } -> StructClass
+    # new(value, ...) -> obj
+    # StructClass[value, ...] -> obj
+    # ```
+    #
+    # The first two forms are used to create a new struct subclass `class_name`
+    # that can contain a value for each   member_name . This subclass can be
+    # used to create instances of the structure like any other  Class .
+    #
+    # If the `class_name` is omitted an anonymous struct class will be created.
+    # Otherwise, the name of this struct will appear as a constant in the struct class,
+    # so it must be unique for all structs under this base class and must start with a
+    # capital letter. Assigning a struct class to a constant also gives the class
+    # the name of the constant.
+    #
+    # If a block is given it will be evaluated in the context of `StructClass`, passing
+    # the created class as a parameter. This is the recommended way to customize a struct.
+    # Subclassing an anonymous struct creates an extra anonymous class that will never be used.
+    #
+    # The last two forms create a new instance of a struct subclass. The number of value
+    # parameters must be less than or equal to the number of attributes defined for the
+    # struct. Unset parameters default to nil. Passing more parameters than number of attributes
+    # will raise an `ArgumentError`.
+    #
+    # @see http://ruby-doc.org/core/Struct.html#method-c-new Ruby standard library `Struct#new`
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#210
+    def new(*args, &block); end
+  end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/mutable_struct.rb#220
+Concurrent::MutableStruct::FACTORY = T.let(T.unsafe(nil), T.untyped)
+
+# A boolean value that can be updated atomically. Reads and writes to an atomic
+# boolean and thread-safe and guaranteed to succeed. Reads and writes may block
+# briefly but no explicit locking is required.
+#
+#
+# ## Thread-safe Variable Classes
+#
+# Each of the thread-safe variable classes is designed to solve a different
+# problem. In general:
+#
+# * *{Concurrent::Agent}:* Shared, mutable variable providing independent,
+#   uncoordinated, *asynchronous* change of individual values. Best used when
+#   the value will undergo frequent, complex updates. Suitable when the result
+#   of an update does not need to be known immediately.
+# * *{Concurrent::Atom}:* Shared, mutable variable providing independent,
+#   uncoordinated, *synchronous* change of individual values. Best used when
+#   the value will undergo frequent reads but only occasional, though complex,
+#   updates. Suitable when the result of an update must be known immediately.
+# * *{Concurrent::AtomicReference}:* A simple object reference that can be updated
+#   atomically. Updates are synchronous but fast. Best used when updates a
+#   simple set operations. Not suitable when updates are complex.
+#   {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar
+#   but optimized for the given data type.
+# * *{Concurrent::Exchanger}:* Shared, stateless synchronization point. Used
+#   when two or more threads need to exchange data. The threads will pair then
+#   block on each other until the exchange is complete.
+# * *{Concurrent::MVar}:* Shared synchronization point. Used when one thread
+#   must give a value to another, which must take the value. The threads will
+#   block on each other until the exchange is complete.
+# * *{Concurrent::ThreadLocalVar}:* Shared, mutable, isolated variable which
+#   holds a different value for each thread which has access. Often used as
+#   an instance variable in objects which must maintain different state
+#   for different threads.
+# * *{Concurrent::TVar}:* Shared, mutable variables which provide
+#   *coordinated*, *synchronous*, change of *many* stated. Used when multiple
+#   value must change together, in an all-or-nothing transaction.
+# Performance:
+#
+# ```
+# Testing with ruby 2.1.2
+# Testing with Concurrent::MutexAtomicBoolean...
+#   2.790000   0.000000   2.790000 (  2.791454)
+# Testing with Concurrent::CAtomicBoolean...
+#   0.740000   0.000000   0.740000 (  0.740206)
+#
+# Testing with jruby 1.9.3
+# Testing with Concurrent::MutexAtomicBoolean...
+#   5.240000   2.520000   7.760000 (  3.683000)
+# Testing with Concurrent::JavaAtomicBoolean...
+#   3.340000   0.010000   3.350000 (  0.855000)
+# ```
+#
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicBoolean.html java.util.concurrent.atomic.AtomicBoolean
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb#8
+class Concurrent::MutexAtomicBoolean
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # Creates a new `AtomicBoolean` with the given initial value.
+  #
+  # @param initial [Boolean] the initial value
+  # @return [MutexAtomicBoolean] a new instance of MutexAtomicBoolean
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb#12
+  def initialize(initial = T.unsafe(nil)); end
+
+  # Is the current value `false`
+  #
+  # @return [Boolean] true if the current value is `false`, else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb#34
+  def false?; end
+
+  # Explicitly sets the value to false.
+  #
+  # @return [Boolean] true if value has changed, otherwise false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb#44
+  def make_false; end
+
+  # Explicitly sets the value to true.
+  #
+  # @return [Boolean] true if value has changed, otherwise false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb#39
+  def make_true; end
+
+  # Is the current value `true`
+  #
+  # @return [Boolean] true if the current value is `true`, else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb#29
+  def true?; end
+
+  # Retrieves the current `Boolean` value.
+  #
+  # @return [Boolean] the current value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb#19
+  def value; end
+
+  # Explicitly sets the value.
+  #
+  # @param value [Boolean] the new value to be set
+  # @return [Boolean] the current value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb#24
+  def value=(value); end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb#51
+  def synchronize; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb#62
+  def ns_make_value(value); end
+end
+
+# A numeric value that can be updated atomically. Reads and writes to an atomic
+# fixnum and thread-safe and guaranteed to succeed. Reads and writes may block
+# briefly but no explicit locking is required.
+#
+#
+# ## Thread-safe Variable Classes
+#
+# Each of the thread-safe variable classes is designed to solve a different
+# problem. In general:
+#
+# * *{Concurrent::Agent}:* Shared, mutable variable providing independent,
+#   uncoordinated, *asynchronous* change of individual values. Best used when
+#   the value will undergo frequent, complex updates. Suitable when the result
+#   of an update does not need to be known immediately.
+# * *{Concurrent::Atom}:* Shared, mutable variable providing independent,
+#   uncoordinated, *synchronous* change of individual values. Best used when
+#   the value will undergo frequent reads but only occasional, though complex,
+#   updates. Suitable when the result of an update must be known immediately.
+# * *{Concurrent::AtomicReference}:* A simple object reference that can be updated
+#   atomically. Updates are synchronous but fast. Best used when updates a
+#   simple set operations. Not suitable when updates are complex.
+#   {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar
+#   but optimized for the given data type.
+# * *{Concurrent::Exchanger}:* Shared, stateless synchronization point. Used
+#   when two or more threads need to exchange data. The threads will pair then
+#   block on each other until the exchange is complete.
+# * *{Concurrent::MVar}:* Shared synchronization point. Used when one thread
+#   must give a value to another, which must take the value. The threads will
+#   block on each other until the exchange is complete.
+# * *{Concurrent::ThreadLocalVar}:* Shared, mutable, isolated variable which
+#   holds a different value for each thread which has access. Often used as
+#   an instance variable in objects which must maintain different state
+#   for different threads.
+# * *{Concurrent::TVar}:* Shared, mutable variables which provide
+#   *coordinated*, *synchronous*, change of *many* stated. Used when multiple
+#   value must change together, in an all-or-nothing transaction.
+# Performance:
+#
+# ```
+# Testing with ruby 2.1.2
+# Testing with Concurrent::MutexAtomicFixnum...
+#   3.130000   0.000000   3.130000 (  3.136505)
+# Testing with Concurrent::CAtomicFixnum...
+#   0.790000   0.000000   0.790000 (  0.785550)
+#
+# Testing with jruby 1.9.3
+# Testing with Concurrent::MutexAtomicFixnum...
+#   5.460000   2.460000   7.920000 (  3.715000)
+# Testing with Concurrent::JavaAtomicFixnum...
+#   4.520000   0.030000   4.550000 (  1.187000)
+# ```
+#
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicLong.html java.util.concurrent.atomic.AtomicLong
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb#9
+class Concurrent::MutexAtomicFixnum
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # Creates a new `AtomicFixnum` with the given initial value.
+  #
+  # @param initial [Fixnum] the initial value
+  # @raise [ArgumentError] if the initial value is not a `Fixnum`
+  # @return [MutexAtomicFixnum] a new instance of MutexAtomicFixnum
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb#13
+  def initialize(initial = T.unsafe(nil)); end
+
+  # Atomically sets the value to the given updated value if the current
+  # value == the expected value.
+  #
+  # @param expect [Fixnum] the expected value
+  # @param update [Fixnum] the new value
+  # @return [Boolean] true if the value was updated else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb#44
+  def compare_and_set(expect, update); end
+
+  # Decreases the current value by the given amount (defaults to 1).
+  #
+  # @param delta [Fixnum] the amount by which to decrease the current value
+  # @return [Fixnum] the current value after decrementation
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb#37
+  def decrement(delta = T.unsafe(nil)); end
+
+  # Decreases the current value by the given amount (defaults to 1).
+  #
+  # @param delta [Fixnum] the amount by which to decrease the current value
+  # @return [Fixnum] the current value after decrementation
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb#37
+  def down(delta = T.unsafe(nil)); end
+
+  # Increases the current value by the given amount (defaults to 1).
+  #
+  # @param delta [Fixnum] the amount by which to increase the current value
+  # @return [Fixnum] the current value after incrementation
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb#30
+  def increment(delta = T.unsafe(nil)); end
+
+  # Increases the current value by the given amount (defaults to 1).
+  #
+  # @param delta [Fixnum] the amount by which to increase the current value
+  # @return [Fixnum] the current value after incrementation
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb#30
+  def up(delta = T.unsafe(nil)); end
+
+  # Pass the current value to the given block, replacing it
+  # with the block's result. May retry if the value changes
+  # during the block's execution.
+  #
+  # @return [Object] the new value
+  # @yield [Object] Calculate a new value for the atomic reference using
+  #   given (old) value
+  # @yieldparam old_value [Object] the starting value of the atomic reference
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb#56
+  def update; end
+
+  # Retrieves the current `Fixnum` value.
+  #
+  # @return [Fixnum] the current value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb#20
+  def value; end
+
+  # Explicitly sets the value.
+  #
+  # @param value [Fixnum] the new value to be set
+  # @raise [ArgumentError] if the new value is not a `Fixnum`
+  # @return [Fixnum] the current value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb#25
+  def value=(value); end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb#65
+  def synchronize; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb#76
+  def ns_set(value); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb#9
+class Concurrent::MutexAtomicReference
+  include ::Concurrent::AtomicDirectUpdate
+  include ::Concurrent::AtomicNumericCompareAndSetWrapper
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # @param value [Object] The initial value.
+  # @return [MutexAtomicReference] a new instance of MutexAtomicReference
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb#16
+  def initialize(value = T.unsafe(nil)); end
+
+  # Atomically sets the value to the given updated value if
+  # the current value == the expected value.
+  #
+  # that the actual value was not equal to the expected value.
+  #
+  # @param old_value [Object] the expected value
+  # @param new_value [Object] the new value
+  # @return [Boolean] `true` if successful. A `false` return indicates
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb#45
+  def _compare_and_set(old_value, new_value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/numeric_cas_wrapper.rb#10
+  def compare_and_swap(old_value, new_value); end
+
+  # Gets the current value.
+  #
+  # @return [Object] the current value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb#23
+  def get; end
+
+  # Atomically sets to the given value and returns the old value.
+  #
+  # @param new_value [Object] the new value
+  # @return [Object] the old value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb#35
+  def get_and_set(new_value); end
+
+  # Sets to the given value.
+  #
+  # @param new_value [Object] the new value
+  # @return [Object] the new value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb#29
+  def set(new_value); end
+
+  # Atomically sets to the given value and returns the old value.
+  #
+  # @param new_value [Object] the new value
+  # @return [Object] the old value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb#35
+  def swap(new_value); end
+
+  # Gets the current value.
+  #
+  # @return [Object] the current value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb#23
+  def value; end
+
+  # Sets to the given value.
+  #
+  # @param new_value [Object] the new value
+  # @return [Object] the new value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb#29
+  def value=(new_value); end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb#59
+  def synchronize; end
+end
+
+# A synchronization object that allows one thread to wait on multiple other threads.
+# The thread that will wait creates a `CountDownLatch` and sets the initial value
+# (normally equal to the number of other threads). The initiating thread passes the
+# latch to the other threads then waits for the other threads by calling the `#wait`
+# method. Each of the other threads calls `#count_down` when done with its work.
+# When the latch counter reaches zero the waiting thread is unblocked and continues
+# with its work. A `CountDownLatch` can be used only once. Its value cannot be reset.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb#9
+class Concurrent::MutexCountDownLatch < ::Concurrent::Synchronization::LockableObject
+  # Create a new `CountDownLatch` with the initial `count`.
+  #
+  # @param count [new] the initial count
+  # @raise [ArgumentError] if `count` is not an integer or is less than zero
+  # @return [MutexCountDownLatch] a new instance of MutexCountDownLatch
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb#12
+  def initialize(count = T.unsafe(nil)); end
+
+  # The current value of the counter.
+  #
+  # @return [Fixnum] the current value of the counter
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb#34
+  def count; end
+
+  # Signal the latch to decrement the counter. Will signal all blocked threads when
+  # the `count` reaches zero.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb#26
+  def count_down; end
+
+  # Block on the latch until the counter reaches zero or until `timeout` is reached.
+  #
+  # @param timeout [Fixnum] the number of seconds to wait for the counter or `nil`
+  #   to block indefinitely
+  # @return [Boolean] `true` if the `count` reaches zero else false on `timeout`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb#21
+  def wait(timeout = T.unsafe(nil)); end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb#40
+  def ns_initialize(count); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb#9
+class Concurrent::MutexSemaphore < ::Concurrent::Synchronization::LockableObject
+  # @return [MutexSemaphore] a new instance of MutexSemaphore
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb#12
+  def initialize(count); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb#20
+  def acquire(permits = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb#38
+  def available_permits; end
+
+  # Acquires and returns all permits that are immediately available.
+  #
+  # @return [Integer]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb#47
+  def drain_permits; end
+
+  # Shrinks the number of available permits by the indicated reduction.
+  #
+  # @param reduction [Fixnum] Number of permits to remove.
+  # @raise [ArgumentError] if `reduction` is not an integer or is negative
+  # @raise [ArgumentError] if `@free` - `@reduction` is less than zero
+  # @return [nil]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb#99
+  def reduce_permits(reduction); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb#77
+  def release(permits = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb#54
+  def try_acquire(permits = T.unsafe(nil), timeout = T.unsafe(nil)); end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb#110
+  def ns_initialize(count); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb#117
+  def try_acquire_now(permits); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb#127
+  def try_acquire_timed(permits, timeout); end
+end
+
+# Various classes within allows for +nil+ values to be stored,
+# so a special +NULL+ token is required to indicate the "nil-ness".
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/constants.rb#6
+Concurrent::NULL = T.let(T.unsafe(nil), Object)
+
+# Suppresses all output when used for logging.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#103
+Concurrent::NULL_LOGGER = T.let(T.unsafe(nil), Proc)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/options.rb#6
+module Concurrent::Options
+  class << self
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/options.rb#27
+    def executor(executor_identifier); end
+
+    # Get the requested `Executor` based on the values set in the options hash.
+    #
+    # @option opts
+    # @param opts [Hash] the options defining the requested executor
+    # @return [Executor, nil] the requested thread pool, or nil when no option specified
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/options.rb#19
+    def executor_from_options(opts = T.unsafe(nil)); end
+  end
+end
+
+# Promises are inspired by the JavaScript [Promises/A](http://wiki.commonjs.org/wiki/Promises/A)
+# and [Promises/A+](http://promises-aplus.github.io/promises-spec/) specifications.
+#
+# > A promise represents the eventual value returned from the single
+# > completion of an operation.
+#
+# Promises are similar to futures and share many of the same behaviours.
+# Promises are far more robust, however. Promises can be chained in a tree
+# structure where each promise may have zero or more children. Promises are
+# chained using the `then` method. The result of a call to `then` is always
+# another promise. Promises are resolved asynchronously (with respect to the
+# main thread) but in a strict order: parents are guaranteed to be resolved
+# before their children, children before their younger siblings. The `then`
+# method takes two parameters: an optional block to be executed upon parent
+# resolution and an optional callable to be executed upon parent failure. The
+# result of each promise is passed to each of its children upon resolution.
+# When a promise is rejected all its children will be summarily rejected and
+# will receive the reason.
+#
+# Promises have several possible states: *:unscheduled*, *:pending*,
+# *:processing*, *:rejected*, or *:fulfilled*. These are also aggregated as
+# `#incomplete?` and `#complete?`. When a Promise is created it is set to
+# *:unscheduled*. Once the `#execute` method is called the state becomes
+# *:pending*. Once a job is pulled from the thread pool's queue and is given
+# to a thread for processing (often immediately upon `#post`) the state
+# becomes *:processing*. The future will remain in this state until processing
+# is complete. A future that is in the *:unscheduled*, *:pending*, or
+# *:processing* is considered `#incomplete?`. A `#complete?` Promise is either
+# *:rejected*, indicating that an exception was thrown during processing, or
+# *:fulfilled*, indicating success. If a Promise is *:fulfilled* its `#value`
+# will be updated to reflect the result of the operation. If *:rejected* the
+# `reason` will be updated with a reference to the thrown exception. The
+# predicate methods `#unscheduled?`, `#pending?`, `#rejected?`, and
+# `#fulfilled?` can be called at any time to obtain the state of the Promise,
+# as can the `#state` method, which returns a symbol.
+#
+# Retrieving the value of a promise is done through the `value` (alias:
+# `deref`) method. Obtaining the value of a promise is a potentially blocking
+# operation. When a promise is *rejected* a call to `value` will return `nil`
+# immediately. When a promise is *fulfilled* a call to `value` will
+# immediately return the current value. When a promise is *pending* a call to
+# `value` will block until the promise is either *rejected* or *fulfilled*. A
+# *timeout* value can be passed to `value` to limit how long the call will
+# block. If `nil` the call will block indefinitely. If `0` the call will not
+# block. Any other integer or float value will indicate the maximum number of
+# seconds to block.
+#
+# Promises run on the global thread pool.
+#
+# ### Examples
+#
+# Start by requiring promises
+#
+# ```ruby
+# require 'concurrent/promise'
+# ```
+#
+# Then create one
+#
+# ```ruby
+# p = Concurrent::Promise.execute do
+#       # do something
+#       42
+#     end
+# ```
+#
+# Promises can be chained using the `then` method. The `then` method accepts a
+# block and an executor, to be executed on fulfillment, and a callable argument to be executed
+# on rejection. The result of the each promise is passed as the block argument
+# to chained promises.
+#
+# ```ruby
+# p = Concurrent::Promise.new{10}.then{|x| x * 2}.then{|result| result - 10 }.execute
+# ```
+#
+# And so on, and so on, and so on...
+#
+# ```ruby
+# p = Concurrent::Promise.fulfill(20).
+#     then{|result| result - 10 }.
+#     then{|result| result * 3 }.
+#     then(executor: different_executor){|result| result % 5 }.execute
+# ```
+#
+# The initial state of a newly created Promise depends on the state of its parent:
+# - if parent is *unscheduled* the child will be *unscheduled*
+# - if parent is *pending* the child will be *pending*
+# - if parent is *fulfilled* the child will be *pending*
+# - if parent is *rejected* the child will be *pending* (but will ultimately be *rejected*)
+#
+# Promises are executed asynchronously from the main thread. By the time a
+# child Promise finishes intialization it may be in a different state than its
+# parent (by the time a child is created its parent may have completed
+# execution and changed state). Despite being asynchronous, however, the order
+# of execution of Promise objects in a chain (or tree) is strictly defined.
+#
+# There are multiple ways to create and execute a new `Promise`. Both ways
+# provide identical behavior:
+#
+# ```ruby
+# # create, operate, then execute
+# p1 = Concurrent::Promise.new{ "Hello World!" }
+# p1.state #=> :unscheduled
+# p1.execute
+#
+# # create and immediately execute
+# p2 = Concurrent::Promise.new{ "Hello World!" }.execute
+#
+# # execute during creation
+# p3 = Concurrent::Promise.execute{ "Hello World!" }
+# ```
+#
+# Once the `execute` method is called a `Promise` becomes `pending`:
+#
+# ```ruby
+# p = Concurrent::Promise.execute{ "Hello, world!" }
+# p.state    #=> :pending
+# p.pending? #=> true
+# ```
+#
+# Wait a little bit, and the promise will resolve and provide a value:
+#
+# ```ruby
+# p = Concurrent::Promise.execute{ "Hello, world!" }
+# sleep(0.1)
+#
+# p.state      #=> :fulfilled
+# p.fulfilled? #=> true
+# p.value      #=> "Hello, world!"
+# ```
+#
+# If an exception occurs, the promise will be rejected and will provide
+# a reason for the rejection:
+#
+# ```ruby
+# p = Concurrent::Promise.execute{ raise StandardError.new("Here comes the Boom!") }
+# sleep(0.1)
+#
+# p.state     #=> :rejected
+# p.rejected? #=> true
+# p.reason    #=> "#<StandardError: Here comes the Boom!>"
+# ```
+#
+# #### Rejection
+#
+# When a promise is rejected all its children will be rejected and will
+# receive the rejection `reason` as the rejection callable parameter:
+#
+# ```ruby
+# p = Concurrent::Promise.execute { Thread.pass; raise StandardError }
+#
+# c1 = p.then(-> reason { 42 })
+# c2 = p.then(-> reason { raise 'Boom!' })
+#
+# c1.wait.state  #=> :fulfilled
+# c1.value       #=> 45
+# c2.wait.state  #=> :rejected
+# c2.reason      #=> #<RuntimeError: Boom!>
+# ```
+#
+# Once a promise is rejected it will continue to accept children that will
+# receive immediately rejection (they will be executed asynchronously).
+#
+# #### Aliases
+#
+# The `then` method is the most generic alias: it accepts a block to be
+# executed upon parent fulfillment and a callable to be executed upon parent
+# rejection. At least one of them should be passed. The default block is `{
+# |result| result }` that fulfills the child with the parent value. The
+# default callable is `{ |reason| raise reason }` that rejects the child with
+# the parent reason.
+#
+# - `on_success { |result| ... }` is the same as `then {|result| ... }`
+# - `rescue { |reason| ... }` is the same as `then(Proc.new { |reason| ... } )`
+# - `rescue` is aliased by `catch` and `on_error`
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#190
+class Concurrent::Promise < ::Concurrent::IVar
+  # Initialize a new Promise with the provided options.
+  #
+  # @option opts
+  # @option opts
+  # @option opts
+  # @option opts
+  # @param opts [Hash] a customizable set of options
+  # @raise [ArgumentError] if no block is given
+  # @return [Promise] a new instance of Promise
+  # @see http://wiki.commonjs.org/wiki/Promises/A
+  # @see http://promises-aplus.github.io/promises-spec/
+  # @yield The block operation to be performed asynchronously.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#210
+  def initialize(opts = T.unsafe(nil), &block); end
+
+  # Chain onto this promise an action to be undertaken on failure
+  # (rejection).
+  #
+  # @return [Promise] self
+  # @yield The block to execute
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#360
+  def catch(&block); end
+
+  # Execute an `:unscheduled` `Promise`. Immediately sets the state to `:pending` and
+  # passes the block to a new thread/thread pool for eventual execution.
+  # Does nothing if the `Promise` is in any state other than `:unscheduled`.
+  #
+  # @return [Promise] a reference to `self`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#246
+  def execute; end
+
+  # Set the `IVar` to failed due to some error and wake or notify all threads waiting on it.
+  #
+  # @param reason [Object] for the failure
+  # @raise [Concurrent::MultipleAssignmentError] if the `IVar` has already
+  #   been set or otherwise completed
+  # @raise [Concurrent::PromiseExecutionError] if not the root promise
+  # @return [IVar] self
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#278
+  def fail(reason = T.unsafe(nil)); end
+
+  # Yield the successful result to the block that returns a promise. If that
+  # promise is also successful the result is the result of the yielded promise.
+  # If either part fails the whole also fails.
+  #
+  # @example
+  #   Promise.execute { 1 }.flat_map { |v| Promise.execute { v + 2 } }.value! #=> 3
+  # @return [Promise]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#375
+  def flat_map(&block); end
+
+  # Chain onto this promise an action to be undertaken on failure
+  # (rejection).
+  #
+  # @return [Promise] self
+  # @yield The block to execute
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#360
+  def on_error(&block); end
+
+  # Chain onto this promise an action to be undertaken on success
+  # (fulfillment).
+  #
+  # @raise [ArgumentError]
+  # @return [Promise] self
+  # @yield The block to execute
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#349
+  def on_success(&block); end
+
+  # Chain onto this promise an action to be undertaken on failure
+  # (rejection).
+  #
+  # @return [Promise] self
+  # @yield The block to execute
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#360
+  def rescue(&block); end
+
+  # Set the `IVar` to a value and wake or notify all threads waiting on it.
+  #
+  # @param value [Object] the value to store in the `IVar`
+  # @raise [ArgumentError] if both a value and a block are given
+  # @raise [Concurrent::MultipleAssignmentError] if the `IVar` has already
+  #   been set or otherwise completed
+  # @raise [Concurrent::PromiseExecutionError] if not the root promise
+  # @return [IVar] self
+  # @yield A block operation to use for setting the value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#262
+  def set(value = T.unsafe(nil), &block); end
+
+  # Chain a new promise off the current promise.
+  #
+  # @overload then
+  # @overload then
+  # @raise [ArgumentError]
+  # @return [Promise] the new promise
+  # @yield The block operation to be performed asynchronously.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#314
+  def then(*args, &block); end
+
+  # Builds a promise that produces the result of self and others in an Array
+  # and fails if any of them fails.
+  #
+  # @overload zip
+  # @overload zip
+  # @return [Promise<Array>]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#440
+  def zip(*others); end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#551
+  def complete(success, value, reason); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#545
+  def notify_child(child); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#481
+  def ns_initialize(value, opts); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#533
+  def on_fulfill(result); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#539
+  def on_reject(reason); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#562
+  def realize(task); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#528
+  def root?; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#520
+  def set_pending; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#570
+  def set_state!(success, value, reason); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#576
+  def synchronized_set_state!(success, value, reason); end
+
+  class << self
+    # Aggregate a collection of zero or more promises under a composite promise,
+    # execute the aggregated promises and collect them into a standard Ruby array,
+    # call the given Ruby `Ennnumerable` predicate (such as `any?`, `all?`, `none?`,
+    # or `one?`) on the collection checking for the success or failure of each,
+    # then executing the composite's `#then` handlers if the predicate returns
+    # `true` or executing the composite's `#rescue` handlers if the predicate
+    # returns false.
+    #
+    #
+    # The returned promise will not yet have been executed. Additional `#then`
+    # and `#rescue` handlers may still be provided. Once the returned promise
+    # is execute the aggregate promises will be also be executed (if they have
+    # not been executed already). The results of the aggregate promises will
+    # be checked upon completion. The necessary `#then` and `#rescue` blocks
+    # on the aggregating promise will then be executed as appropriate. If the
+    # `#rescue` handlers are executed the raises exception will be
+    # `Concurrent::PromiseExecutionError`.
+    #
+    # @param promises [Array] Zero or more promises to aggregate
+    # @return [Promise] an unscheduled (not executed) promise that aggregates
+    #   the promises given as arguments
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#505
+    def aggregate(method, *promises); end
+
+    # Aggregates a collection of promises and executes the `then` condition
+    # if all aggregated promises succeed. Executes the `rescue` handler with
+    # a `Concurrent::PromiseExecutionError` if any of the aggregated promises
+    # fail. Upon execution will execute any of the aggregate promises that
+    # were not already executed.
+    #
+    # @return [Boolean]
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#464
+    def all?(*promises); end
+
+    # Aggregates a collection of promises and executes the `then` condition
+    # if any aggregated promises succeed. Executes the `rescue` handler with
+    # a `Concurrent::PromiseExecutionError` if any of the aggregated promises
+    # fail. Upon execution will execute any of the aggregate promises that
+    # were not already executed.
+    #
+    #
+    # The returned promise will not yet have been executed. Additional `#then`
+    # and `#rescue` handlers may still be provided. Once the returned promise
+    # is execute the aggregate promises will be also be executed (if they have
+    # not been executed already). The results of the aggregate promises will
+    # be checked upon completion. The necessary `#then` and `#rescue` blocks
+    # on the aggregating promise will then be executed as appropriate. If the
+    # `#rescue` handlers are executed the raises exception will be
+    # `Concurrent::PromiseExecutionError`.
+    #
+    # @param promises [Array] Zero or more promises to aggregate
+    # @return [Promise] an unscheduled (not executed) promise that aggregates
+    #   the promises given as arguments
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#475
+    def any?(*promises); end
+
+    # Create a new `Promise` object with the given block, execute it, and return the
+    # `:pending` object.
+    #
+    # @example
+    #   promise = Concurrent::Promise.execute{ sleep(1); 42 }
+    #   promise.state #=> :pending
+    # @option opts
+    # @option opts
+    # @option opts
+    # @option opts
+    # @param opts [Hash] a customizable set of options
+    # @raise [ArgumentError] if no block is given
+    # @return [Promise] the newly created `Promise` in the `:pending` state
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#296
+    def execute(opts = T.unsafe(nil), &block); end
+
+    # Create a new `Promise` and fulfill it immediately.
+    #
+    # @option opts
+    # @option opts
+    # @option opts
+    # @option opts
+    # @param opts [Hash] a customizable set of options
+    # @raise [ArgumentError] if no block is given
+    # @return [Promise] the newly created `Promise`
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#224
+    def fulfill(value, opts = T.unsafe(nil)); end
+
+    # Create a new `Promise` and reject it immediately.
+    #
+    # @option opts
+    # @option opts
+    # @option opts
+    # @option opts
+    # @param opts [Hash] a customizable set of options
+    # @raise [ArgumentError] if no block is given
+    # @return [Promise] the newly created `Promise`
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#237
+    def reject(reason, opts = T.unsafe(nil)); end
+
+    # Builds a promise that produces the result of promises in an Array
+    # and fails if any of them fails.
+    #
+    # @overload zip
+    # @overload zip
+    # @return [Promise<Array>]
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#409
+    def zip(*promises); end
+  end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promise.rb#11
+class Concurrent::PromiseExecutionError < ::StandardError; end
+
+# {include:file:docs-source/promises-main.md}
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#13
+module Concurrent::Promises
+  extend ::Concurrent::Promises::FactoryMethods::Configuration
+  extend ::Concurrent::Promises::FactoryMethods
+end
+
+# @abstract
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2047
+class Concurrent::Promises::AbstractAnyPromise < ::Concurrent::Promises::BlockedPromise; end
+
+# Common ancestor of {Event} and {Future} classes, many shared methods are defined here.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#513
+class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization::Object
+  include ::Concurrent::Promises::InternalStates
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # @return [AbstractEventFuture] a new instance of AbstractEventFuture
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#522
+  def initialize(promise, default_executor); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#137
+  def __initialize_atomic_fields__; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#738
+  def add_callback_clear_delayed_node(node); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#733
+  def add_callback_notify_blocked(promise, index); end
+
+  # For inspection.
+  #
+  # @return [Array<AbstractPromise>]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#702
+  def blocks; end
+
+  # For inspection.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#710
+  def callbacks; end
+
+  # Shortcut of {#chain_on} with default `:io` executor supplied.
+  #
+  # @return [Future]
+  # @see #chain_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#596
+  def chain(*args, &task); end
+
+  # Chains the task to be executed asynchronously on executor after it is resolved.
+  #
+  # @overload an_event.chain_on
+  # @overload a_future.chain_on
+  # @param executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. The task is executed on it, default executor remains unchanged.
+  # @param args [Object] arguments which are passed to the task when it's executed.
+  #   (It might be prepended with other arguments, see the @yield section).
+  # @return [Future]
+  # @yieldreturn will become result of the returned Future.
+  #   Its returned value becomes {Future#value} fulfilling it,
+  #   raised exception becomes {Future#reason} rejecting it.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#614
+  def chain_on(executor, *args, &task); end
+
+  # Resolves the resolvable when receiver is resolved.
+  #
+  # @param resolvable [Resolvable]
+  # @return [self]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#629
+  def chain_resolvable(resolvable); end
+
+  # Returns default executor.
+  #
+  # @return [Executor] default executor
+  # @see #with_default_executor
+  # @see FactoryMethods#future_on
+  # @see FactoryMethods#resolvable_future
+  # @see FactoryMethods#any_fulfilled_future_on
+  # @see similar
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#590
+  def default_executor; end
+
+  # @return [String] Short string representation.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#619
+  def inspect; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#93
+  def internal_state; end
+
+  # Shortcut of {#on_resolution_using} with default `:io` executor supplied.
+  #
+  # @return [self]
+  # @see #on_resolution_using
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#637
+  def on_resolution(*args, &callback); end
+
+  # Stores the callback to be executed synchronously on resolving thread after it is
+  # resolved.
+  #
+  # @overload an_event.on_resolution!
+  # @overload a_future.on_resolution!
+  # @param args [Object] arguments which are passed to the task when it's executed.
+  #   (It might be prepended with other arguments, see the @yield section).
+  # @return [self]
+  # @yieldreturn is forgotten.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#655
+  def on_resolution!(*args, &callback); end
+
+  # Stores the callback to be executed asynchronously on executor after it is resolved.
+  #
+  # @overload an_event.on_resolution_using
+  # @overload a_future.on_resolution_using
+  # @param executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. The task is executed on it, default executor remains unchanged.
+  # @param args [Object] arguments which are passed to the task when it's executed.
+  #   (It might be prepended with other arguments, see the @yield section).
+  # @return [self]
+  # @yieldreturn is forgotten.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#673
+  def on_resolution_using(executor, *args, &callback); end
+
+  # Is it in pending state?
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#549
+  def pending?; end
+
+  # For inspection.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#716
+  def promise; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#688
+  def resolve_with(state, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
+
+  # Is it in resolved state?
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#555
+  def resolved?; end
+
+  # Returns its state.
+  #
+  # @overload an_event.state
+  # @overload a_future.state
+  # @return [Symbol]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#543
+  def state; end
+
+  # Resolves the resolvable when receiver is resolved.
+  #
+  # @param resolvable [Resolvable]
+  # @return [self]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#629
+  def tangle(resolvable); end
+
+  # @return [String] Short string representation.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#619
+  def to_s; end
+
+  # Propagates touch. Requests all the delayed futures, which it depends on, to be
+  # executed. This method is called by any other method requiring resolved state, like {#wait}.
+  #
+  # @return [self]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#562
+  def touch; end
+
+  # For inspection.
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#722
+  def touched?; end
+
+  # Wait (block the Thread) until receiver is {#resolved?}.
+  # Calls {Concurrent::AbstractEventFuture#touch}.
+  #
+  # @note This function potentially blocks current thread until the Future is resolved.
+  #   Be careful it can deadlock. Try to chain instead.
+  # @param timeout [Numeric] the maximum time in second to wait.
+  # @return [self, true, false] self implies timeout was not used, true implies timeout was used
+  #   and it was resolved, false implies it was not resolved within timeout.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#578
+  def wait(timeout = T.unsafe(nil)); end
+
+  # For inspection.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#728
+  def waiting_threads; end
+
+  # Crates new object with same class with the executor set as its new default executor.
+  # Any futures depending on it will use the new default executor.
+  #
+  # @abstract
+  # @raise [NotImplementedError]
+  # @return [AbstractEventFuture]
+  # @see Event#with_default_executor
+  # @see Future#with_default_executor
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#683
+  def with_default_executor(executor); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#743
+  def with_hidden_resolvable; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#750
+  def add_callback(method, *args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#812
+  def async_callback_on_resolution(state, executor, args, callback); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#796
+  def call_callback(method, state, args); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#800
+  def call_callbacks(state); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#763
+  def callback_clear_delayed_node(state, node); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#818
+  def callback_notify_blocked(state, promise, index); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#105
+  def compare_and_set_internal_state(expected, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#97
+  def internal_state=(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#101
+  def swap_internal_state(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#109
+  def update_internal_state(&block); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#768
+  def wait_until_resolved(timeout); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#808
+  def with_async(executor, *args, &block); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1796
+class Concurrent::Promises::AbstractFlatPromise < ::Concurrent::Promises::BlockedPromise
+  # @return [AbstractFlatPromise] a new instance of AbstractFlatPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1798
+  def initialize(delayed_because, blockers_count, event_or_future); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1808
+  def touch; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1828
+  def add_delayed_of(future); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1820
+  def on_resolvable(resolved_future, index); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1824
+  def resolvable?(countdown, future, index); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1816
+  def touched?; end
+end
+
+# @abstract
+# @private
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1549
+class Concurrent::Promises::AbstractPromise < ::Concurrent::Synchronization::Object
+  include ::Concurrent::Promises::InternalStates
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # @return [AbstractPromise] a new instance of AbstractPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1553
+  def initialize(future); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1564
+  def default_executor; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1581
+  def delayed_because; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1558
+  def event; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1558
+  def future; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1575
+  def inspect; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1568
+  def state; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1575
+  def to_s; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1572
+  def touch; end
+
+  private
+
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1592
+  def evaluate_to(*args, block); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1587
+  def resolve_with(new_state, raise_on_reassign = T.unsafe(nil)); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2084
+class Concurrent::Promises::AnyFulfilledFuturePromise < ::Concurrent::Promises::AnyResolvedFuturePromise
+  private
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2088
+  def resolvable?(countdown, event_or_future, index); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2050
+class Concurrent::Promises::AnyResolvedEventPromise < ::Concurrent::Promises::AbstractAnyPromise
+  # @return [AnyResolvedEventPromise] a new instance of AnyResolvedEventPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2054
+  def initialize(delayed, blockers_count, default_executor); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2062
+  def on_resolvable(resolved_future, index); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2058
+  def resolvable?(countdown, future, index); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2067
+class Concurrent::Promises::AnyResolvedFuturePromise < ::Concurrent::Promises::AbstractAnyPromise
+  # @return [AnyResolvedFuturePromise] a new instance of AnyResolvedFuturePromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2071
+  def initialize(delayed, blockers_count, default_executor); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2079
+  def on_resolvable(resolved_future, index); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2075
+  def resolvable?(countdown, future, index); end
+end
+
+# @abstract
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1619
+class Concurrent::Promises::BlockedPromise < ::Concurrent::Promises::InnerPromise
+  # @return [BlockedPromise] a new instance of BlockedPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1661
+  def initialize(delayed, blockers_count, future); end
+
+  # for inspection only
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1683
+  def blocked_by; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1674
+  def delayed_because; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1667
+  def on_blocker_resolution(future, index); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1678
+  def touch; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1691
+  def clear_and_propagate_touch(stack_or_element = T.unsafe(nil)); end
+
+  # @raise [NotImplementedError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1710
+  def on_resolvable(resolved_future, index); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1706
+  def process_on_blocker_resolution(future, index); end
+
+  # @return [true, false] if resolvable
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1702
+  def resolvable?(countdown, future, index); end
+
+  class << self
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1652
+    def add_delayed(delayed1, delayed2); end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1645
+    def new_blocked_by(blockers, *args, &block); end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1623
+    def new_blocked_by1(blocker, *args, &block); end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1630
+    def new_blocked_by2(blocker1, blocker2, *args, &block); end
+
+    private
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/safe_initialization.rb#29
+    def new(*args, &block); end
+  end
+end
+
+# @abstract
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1716
+class Concurrent::Promises::BlockedTaskPromise < ::Concurrent::Promises::BlockedPromise
+  # @raise [ArgumentError]
+  # @return [BlockedTaskPromise] a new instance of BlockedTaskPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1717
+  def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1725
+  def executor; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1766
+class Concurrent::Promises::ChainPromise < ::Concurrent::Promises::BlockedTaskPromise
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1769
+  def on_resolvable(resolved_future, index); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2095
+class Concurrent::Promises::DelayPromise < ::Concurrent::Promises::InnerPromise
+  # @return [DelayPromise] a new instance of DelayPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2097
+  def initialize(default_executor); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2108
+  def delayed_because; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2104
+  def touch; end
+end
+
+# Represents an event which will happen in future (will be resolved). The event is either
+# pending or resolved. It should be always resolved. Use {Future} to communicate rejections and
+# cancellation.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#826
+class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture
+  # Creates a new event or a future which will be resolved when receiver and other are.
+  # Returns an event if receiver and other are events, otherwise returns a future.
+  # If just one of the parties is Future then the result
+  # of the returned future is equal to the result of the supplied future. If both are futures
+  # then the result is as described in {FactoryMethods#zip_futures_on}.
+  #
+  # @return [Future, Event]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#839
+  def &(other); end
+
+  # Creates a new event which will be resolved when the first of receiver, `event_or_future`
+  # resolves.
+  #
+  # @return [Event]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#853
+  def any(event_or_future); end
+
+  # Creates new event dependent on receiver which will not evaluate until touched, see {#touch}.
+  # In other words, it inserts delay into the chain of Futures making rest of it lazy evaluated.
+  #
+  # @return [Event]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#863
+  def delay; end
+
+  # Creates new event dependent on receiver scheduled to execute on/in intended_time.
+  # In time is interpreted from the moment the receiver is resolved, therefore it inserts
+  # delay into the chain.
+  #
+  # @param intended_time [Numeric, Time] `Numeric` means to run in `intended_time` seconds.
+  #   `Time` means to run on `intended_time`.
+  # @return [Event]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#875
+  def schedule(intended_time); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#596
+  def then(*args, &task); end
+
+  # Returns self, since this is event
+  #
+  # @return [Event]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#893
+  def to_event; end
+
+  # Converts event to a future. The future is fulfilled when the event is resolved, the future may never fail.
+  #
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#885
+  def to_future; end
+
+  # Crates new object with same class with the executor set as its new default executor.
+  # Any futures depending on it will use the new default executor.
+  #
+  # @return [Event]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#899
+  def with_default_executor(executor); end
+
+  # Creates a new event or a future which will be resolved when receiver and other are.
+  # Returns an event if receiver and other are events, otherwise returns a future.
+  # If just one of the parties is Future then the result
+  # of the returned future is equal to the result of the supplied future. If both are futures
+  # then the result is as described in {FactoryMethods#zip_futures_on}.
+  #
+  # @return [Future, Event]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#839
+  def zip(other); end
+
+  # Creates a new event which will be resolved when the first of receiver, `event_or_future`
+  # resolves.
+  #
+  # @return [Event]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#853
+  def |(event_or_future); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#910
+  def callback_on_resolution(state, args, callback); end
+
+  # @raise [Concurrent::MultipleAssignmentError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#905
+  def rejected_resolution(raise_on_reassign, state); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1972
+class Concurrent::Promises::EventWrapperPromise < ::Concurrent::Promises::BlockedPromise
+  # @return [EventWrapperPromise] a new instance of EventWrapperPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1973
+  def initialize(delayed, blockers_count, default_executor); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1979
+  def on_resolvable(resolved_future, index); end
+end
+
+# Container of all {Future}, {Event} factory methods. They are never constructed directly with
+# new.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#46
+module Concurrent::Promises::FactoryMethods
+  include ::Concurrent::Promises::FactoryMethods::Configuration
+  extend ::Concurrent::ReInclude
+  extend ::Concurrent::Promises::FactoryMethods::Configuration
+  extend ::Concurrent::Promises::FactoryMethods
+
+  # Shortcut of {#any_resolved_future_on} with default `:io` executor supplied.
+  #
+  # @return [Future]
+  # @see #any_resolved_future_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#278
+  def any(*futures_and_or_events); end
+
+  # Shortcut of {#any_event_on} with default `:io` executor supplied.
+  #
+  # @return [Event]
+  # @see #any_event_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#319
+  def any_event(*futures_and_or_events); end
+
+  # Creates a new event which becomes resolved after the first futures_and_or_events resolves.
+  # If resolved it does not propagate {Concurrent::AbstractEventFuture#touch}, leaving delayed
+  # futures un-executed if they are not required any more.
+  #
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  # @param futures_and_or_events [AbstractEventFuture]
+  # @return [Event]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#329
+  def any_event_on(default_executor, *futures_and_or_events); end
+
+  # Shortcut of {#any_fulfilled_future_on} with default `:io` executor supplied.
+  #
+  # @return [Future]
+  # @see #any_fulfilled_future_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#300
+  def any_fulfilled_future(*futures_and_or_events); end
+
+  # Creates a new future which is resolved after the first futures_and_or_events is fulfilled.
+  # Its result equals the result of the first resolved future or if all futures_and_or_events reject,
+  # it has reason of the last rejected future.
+  # If resolved it does not propagate {Concurrent::AbstractEventFuture#touch}, leaving delayed
+  # futures un-executed if they are not required any more.
+  # If event is supplied, which does not have value and can be only resolved, it's
+  # represented as `:fulfilled` with value `nil`.
+  #
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  # @param futures_and_or_events [AbstractEventFuture]
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#313
+  def any_fulfilled_future_on(default_executor, *futures_and_or_events); end
+
+  # Shortcut of {#any_resolved_future_on} with default `:io` executor supplied.
+  #
+  # @return [Future]
+  # @see #any_resolved_future_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#278
+  def any_resolved_future(*futures_and_or_events); end
+
+  # Creates a new future which is resolved after the first futures_and_or_events is resolved.
+  # Its result equals the result of the first resolved future.
+  # If resolved it does not propagate {Concurrent::AbstractEventFuture#touch}, leaving delayed
+  # futures un-executed if they are not required any more.
+  # If event is supplied, which does not have value and can be only resolved, it's
+  # represented as `:fulfilled` with value `nil`.
+  #
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  # @param futures_and_or_events [AbstractEventFuture]
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#294
+  def any_resolved_future_on(default_executor, *futures_and_or_events); end
+
+  # Shortcut of {#delay_on} with default `:io` executor supplied.
+  #
+  # @return [Future, Event]
+  # @see #delay_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#190
+  def delay(*args, &task); end
+
+  # Creates a new event or future which is resolved only after it is touched,
+  # see {Concurrent::AbstractEventFuture#touch}.
+  #
+  # @overload delay_on
+  # @overload delay_on
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#207
+  def delay_on(default_executor, *args, &task); end
+
+  # Creates a resolved future which will be fulfilled with the given value.
+  #
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  # @param value [Object]
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#127
+  def fulfilled_future(value, default_executor = T.unsafe(nil)); end
+
+  # Shortcut of {#future_on} with default `:io` executor supplied.
+  #
+  # @return [Future]
+  # @see #future_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#94
+  def future(*args, &task); end
+
+  # Constructs a new Future which will be resolved after block is evaluated on default executor.
+  # Evaluation begins immediately.
+  #
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  # @param args [Object] arguments which are passed to the task when it's executed.
+  #   (It might be prepended with other arguments, see the @yield section).
+  # @return [Future]
+  # @yield [*args] to the task.
+  # @yieldreturn will become result of the returned Future.
+  #   Its returned value becomes {Future#value} fulfilling it,
+  #   raised exception becomes {Future#reason} rejecting it.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#106
+  def future_on(default_executor, *args, &task); end
+
+  # General constructor. Behaves differently based on the argument's type. It's provided for convenience
+  # but it's better to be explicit.
+  #
+  # @overload make_future
+  # @overload make_future
+  # @overload make_future
+  # @overload make_future
+  # @overload make_future
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  # @return [Event, Future]
+  # @see rejected_future, resolved_event, fulfilled_future
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#174
+  def make_future(argument = T.unsafe(nil), default_executor = T.unsafe(nil)); end
+
+  # Creates a resolved future which will be rejected with the given reason.
+  #
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  # @param reason [Object]
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#136
+  def rejected_future(reason, default_executor = T.unsafe(nil)); end
+
+  # Shortcut of {#resolvable_event_on} with default `:io` executor supplied.
+  #
+  # @return [ResolvableEvent]
+  # @see #resolvable_event_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#63
+  def resolvable_event; end
+
+  # Creates a resolvable event, user is responsible for resolving the event once
+  # by calling {Promises::ResolvableEvent#resolve}.
+  #
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  # @return [ResolvableEvent]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#72
+  def resolvable_event_on(default_executor = T.unsafe(nil)); end
+
+  # Shortcut of {#resolvable_future_on} with default `:io` executor supplied.
+  #
+  # @return [ResolvableFuture]
+  # @see #resolvable_future_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#78
+  def resolvable_future; end
+
+  # Creates resolvable future, user is responsible for resolving the future once by
+  # {Promises::ResolvableFuture#resolve}, {Promises::ResolvableFuture#fulfill},
+  # or {Promises::ResolvableFuture#reject}
+  #
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  # @return [ResolvableFuture]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#88
+  def resolvable_future_on(default_executor = T.unsafe(nil)); end
+
+  # Creates resolved event.
+  #
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  # @return [Event]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#144
+  def resolved_event(default_executor = T.unsafe(nil)); end
+
+  # Creates a resolved future with will be either fulfilled with the given value or rejected with
+  # the given reason.
+  #
+  # @param fulfilled [true, false]
+  # @param value [Object]
+  # @param reason [Object]
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#118
+  def resolved_future(fulfilled, value, reason, default_executor = T.unsafe(nil)); end
+
+  # Shortcut of {#schedule_on} with default `:io` executor supplied.
+  #
+  # @return [Future, Event]
+  # @see #schedule_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#214
+  def schedule(intended_time, *args, &task); end
+
+  # Creates a new event or future which is resolved in intended_time.
+  #
+  # @overload schedule_on
+  # @overload schedule_on
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  # @param intended_time [Numeric, Time] `Numeric` means to run in `intended_time` seconds.
+  #   `Time` means to run on `intended_time`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#233
+  def schedule_on(default_executor, intended_time, *args, &task); end
+
+  # Shortcut of {#zip_futures_on} with default `:io` executor supplied.
+  #
+  # @return [Future]
+  # @see #zip_futures_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#240
+  def zip(*futures_and_or_events); end
+
+  # Shortcut of {#zip_events_on} with default `:io` executor supplied.
+  #
+  # @return [Event]
+  # @see #zip_events_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#262
+  def zip_events(*futures_and_or_events); end
+
+  # Creates a new event which is resolved after all futures_and_or_events are resolved.
+  # (Future is resolved when fulfilled or rejected.)
+  #
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  # @param futures_and_or_events [AbstractEventFuture]
+  # @return [Event]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#272
+  def zip_events_on(default_executor, *futures_and_or_events); end
+
+  # Shortcut of {#zip_futures_on} with default `:io` executor supplied.
+  #
+  # @return [Future]
+  # @see #zip_futures_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#240
+  def zip_futures(*futures_and_or_events); end
+
+  # Creates a new future which is resolved after all futures_and_or_events are resolved.
+  # Its value is an array of zipped future values. Its reason is an array of reasons for rejection.
+  # If there is an error it rejects.
+  # If event is supplied, which does not have value and can be only resolved, it's
+  # represented as `:fulfilled` with value `nil`.
+  #
+  # @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. Default executor propagates to chained futures unless overridden with
+  #   executor parameter or changed with {AbstractEventFuture#with_default_executor}.
+  # @param futures_and_or_events [AbstractEventFuture]
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#254
+  def zip_futures_on(default_executor, *futures_and_or_events); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#50
+module Concurrent::Promises::FactoryMethods::Configuration
+  # @return [Executor, :io, :fast] the executor which is used when none is supplied
+  #   to a factory method. The method can be overridden in the receivers of
+  #   `include FactoryMethod`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#54
+  def default_executor; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1840
+class Concurrent::Promises::FlatEventPromise < ::Concurrent::Promises::AbstractFlatPromise
+  # @return [FlatEventPromise] a new instance of FlatEventPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1844
+  def initialize(delayed, blockers_count, default_executor); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1848
+  def process_on_blocker_resolution(future, index); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1873
+class Concurrent::Promises::FlatFuturePromise < ::Concurrent::Promises::AbstractFlatPromise
+  # @raise [ArgumentError]
+  # @return [FlatFuturePromise] a new instance of FlatFuturePromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1877
+  def initialize(delayed, blockers_count, levels, default_executor); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1884
+  def process_on_blocker_resolution(future, index); end
+end
+
+# Represents a value which will become available in future. May reject with a reason instead,
+# e.g. when the tasks raises an exception.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#917
+class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
+  # Creates a new event or a future which will be resolved when receiver and other are.
+  # Returns an event if receiver and other are events, otherwise returns a future.
+  # If just one of the parties is Future then the result
+  # of the returned future is equal to the result of the supplied future. If both are futures
+  # then the result is as described in {FactoryMethods#zip_futures_on}.
+  #
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1070
+  def &(other); end
+
+  # Creates a new event which will be resolved when the first of receiver, `event_or_future`
+  # resolves. Returning future will have value nil if event_or_future is event and resolves
+  # first.
+  #
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1085
+  def any(event_or_future); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1215
+  def apply(args, block); end
+
+  # Creates new future dependent on receiver which will not evaluate until touched, see {#touch}.
+  # In other words, it inserts delay into the chain of Futures making rest of it lazy evaluated.
+  #
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1095
+  def delay; end
+
+  # Allows rejected Future to be risen with `raise` method.
+  # If the reason is not an exception `Runtime.new(reason)` is returned.
+  #
+  # @example
+  #   raise Promises.rejected_future(StandardError.new("boom"))
+  #   raise Promises.rejected_future("or just boom")
+  # @raise [Concurrent::Error] when raising not rejected future
+  # @return [Exception]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1013
+  def exception(*args); end
+
+  # Creates new future which will have result of the future returned by receiver. If receiver
+  # rejects it will have its rejection.
+  #
+  # @param level [Integer] how many levels of futures should flatten
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1120
+  def flat(level = T.unsafe(nil)); end
+
+  # Creates new event which will be resolved when the returned event by receiver is.
+  # Be careful if the receiver rejects it will just resolve since Event does not hold reason.
+  #
+  # @return [Event]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1130
+  def flat_event; end
+
+  # Creates new future which will have result of the future returned by receiver. If receiver
+  # rejects it will have its rejection.
+  #
+  # @param level [Integer] how many levels of futures should flatten
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1120
+  def flat_future(level = T.unsafe(nil)); end
+
+  # Is it in fulfilled state?
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#921
+  def fulfilled?; end
+
+  # @return [String] Short string representation.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1235
+  def inspect; end
+
+  # Shortcut of {#on_fulfillment_using} with default `:io` executor supplied.
+  #
+  # @return [self]
+  # @see #on_fulfillment_using
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1136
+  def on_fulfillment(*args, &callback); end
+
+  # Stores the callback to be executed synchronously on resolving thread after it is
+  # fulfilled. Does nothing on rejection.
+  #
+  # @param args [Object] arguments which are passed to the task when it's executed.
+  #   (It might be prepended with other arguments, see the @yield section).
+  # @return [self]
+  # @yield [value, *args] to the callback.
+  # @yieldreturn is forgotten.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1147
+  def on_fulfillment!(*args, &callback); end
+
+  # Stores the callback to be executed asynchronously on executor after it is
+  # fulfilled. Does nothing on rejection.
+  #
+  # @param executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. The task is executed on it, default executor remains unchanged.
+  # @param args [Object] arguments which are passed to the task when it's executed.
+  #   (It might be prepended with other arguments, see the @yield section).
+  # @return [self]
+  # @yield [value, *args] to the callback.
+  # @yieldreturn is forgotten.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1159
+  def on_fulfillment_using(executor, *args, &callback); end
+
+  # Shortcut of {#on_rejection_using} with default `:io` executor supplied.
+  #
+  # @return [self]
+  # @see #on_rejection_using
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1165
+  def on_rejection(*args, &callback); end
+
+  # Stores the callback to be executed synchronously on resolving thread after it is
+  # rejected. Does nothing on fulfillment.
+  #
+  # @param args [Object] arguments which are passed to the task when it's executed.
+  #   (It might be prepended with other arguments, see the @yield section).
+  # @return [self]
+  # @yield [reason, *args] to the callback.
+  # @yieldreturn is forgotten.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1176
+  def on_rejection!(*args, &callback); end
+
+  # Stores the callback to be executed asynchronously on executor after it is
+  # rejected. Does nothing on fulfillment.
+  #
+  # @param executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. The task is executed on it, default executor remains unchanged.
+  # @param args [Object] arguments which are passed to the task when it's executed.
+  #   (It might be prepended with other arguments, see the @yield section).
+  # @return [self]
+  # @yield [reason, *args] to the callback.
+  # @yieldreturn is forgotten.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1188
+  def on_rejection_using(executor, *args, &callback); end
+
+  # Returns reason of future's rejection.
+  # Calls {Concurrent::AbstractEventFuture#touch}.
+  #
+  # @note This function potentially blocks current thread until the Future is resolved.
+  #   Be careful it can deadlock. Try to chain instead.
+  # @note Make sure returned `nil` is not confused with timeout, no value when rejected,
+  #   no reason when fulfilled, etc.
+  #   Use more exact methods if needed, like {#wait}, {#value!}, {#result}, etc.
+  # @param timeout [Numeric] the maximum time in second to wait.
+  # @param timeout_value [Object] a value returned by the method when it times out
+  # @return [Object, timeout_value] the reason, or timeout_value on timeout, or nil on fulfillment.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#966
+  def reason(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
+
+  # Is it in rejected state?
+  #
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#928
+  def rejected?; end
+
+  # Shortcut of {#rescue_on} with default `:io` executor supplied.
+  #
+  # @return [Future]
+  # @see #rescue_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1052
+  def rescue(*args, &task); end
+
+  # Chains the task to be executed asynchronously on executor after it rejects. Does not run
+  # the task if it fulfills. It will resolve though, triggering any dependent futures.
+  #
+  # @param executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. The task is executed on it, default executor remains unchanged.
+  # @param args [Object] arguments which are passed to the task when it's executed.
+  #   (It might be prepended with other arguments, see the @yield section).
+  # @return [Future]
+  # @yield [reason, *args] to the task.
+  # @yieldreturn will become result of the returned Future.
+  #   Its returned value becomes {Future#value} fulfilling it,
+  #   raised exception becomes {Future#reason} rejecting it.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1064
+  def rescue_on(executor, *args, &task); end
+
+  # Returns triplet fulfilled?, value, reason.
+  # Calls {Concurrent::AbstractEventFuture#touch}.
+  #
+  # @note This function potentially blocks current thread until the Future is resolved.
+  #   Be careful it can deadlock. Try to chain instead.
+  # @param timeout [Numeric] the maximum time in second to wait.
+  # @return [Array(Boolean, Object, Object), nil] triplet of fulfilled?, value, reason, or nil
+  #   on timeout.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#981
+  def result(timeout = T.unsafe(nil)); end
+
+  # Allows to use futures as green threads. The receiver has to evaluate to a future which
+  # represents what should be done next. It basically flattens indefinitely until non Future
+  # values is returned which becomes result of the returned future. Any encountered exception
+  # will become reason of the returned future.
+  #
+  # @example
+  #   body = lambda do |v|
+  #   v += 1
+  #   v < 5 ? Promises.future(v, &body) : v
+  #   end
+  #   Promises.future(0, &body).run.value! # => 5
+  # @param run_test [#call(value)] an object which when called returns either Future to keep running with
+  #   or nil, then the run completes with the value.
+  #   The run_test can be used to extract the Future from deeper structure,
+  #   or to distinguish Future which is a resulting value from a future
+  #   which is suppose to continue running.
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1210
+  def run(run_test = T.unsafe(nil)); end
+
+  # Creates new event dependent on receiver scheduled to execute on/in intended_time.
+  # In time is interpreted from the moment the receiver is resolved, therefore it inserts
+  # delay into the chain.
+  #
+  # @param intended_time [Numeric, Time] `Numeric` means to run in `intended_time` seconds.
+  #   `Time` means to run on `intended_time`.
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1102
+  def schedule(intended_time); end
+
+  # Shortcut of {#then_on} with default `:io` executor supplied.
+  #
+  # @return [Future]
+  # @see #then_on
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1034
+  def then(*args, &task); end
+
+  # Chains the task to be executed asynchronously on executor after it fulfills. Does not run
+  # the task if it rejects. It will resolve though, triggering any dependent futures.
+  #
+  # @param executor [Executor, :io, :fast] Instance of an executor or a name of the
+  #   global executor. The task is executed on it, default executor remains unchanged.
+  # @param args [Object] arguments which are passed to the task when it's executed.
+  #   (It might be prepended with other arguments, see the @yield section).
+  # @return [Future]
+  # @yield [value, *args] to the task.
+  # @yieldreturn will become result of the returned Future.
+  #   Its returned value becomes {Future#value} fulfilling it,
+  #   raised exception becomes {Future#reason} rejecting it.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1046
+  def then_on(executor, *args, &task); end
+
+  # Converts future to event which is resolved when future is resolved by fulfillment or rejection.
+  #
+  # @return [Event]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1222
+  def to_event; end
+
+  # Returns self, since this is a future
+  #
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1230
+  def to_future; end
+
+  # @return [String] Short string representation.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1235
+  def to_s; end
+
+  # Return value of the future.
+  # Calls {Concurrent::AbstractEventFuture#touch}.
+  #
+  # @note This function potentially blocks current thread until the Future is resolved.
+  #   Be careful it can deadlock. Try to chain instead.
+  # @note Make sure returned `nil` is not confused with timeout, no value when rejected,
+  #   no reason when fulfilled, etc.
+  #   Use more exact methods if needed, like {#wait}, {#value!}, {#result}, etc.
+  # @param timeout [Numeric] the maximum time in second to wait.
+  # @param timeout_value [Object] a value returned by the method when it times out
+  # @return [Object, nil, timeout_value] the value of the Future when fulfilled,
+  #   timeout_value on timeout,
+  #   nil on rejection.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#950
+  def value(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
+
+  # Return value of the future.
+  # Calls {Concurrent::AbstractEventFuture#touch}.
+  #
+  # @note This function potentially blocks current thread until the Future is resolved.
+  #   Be careful it can deadlock. Try to chain instead.
+  # @note Make sure returned `nil` is not confused with timeout, no value when rejected,
+  #   no reason when fulfilled, etc.
+  #   Use more exact methods if needed, like {#wait}, {#value!}, {#result}, etc.
+  # @param timeout [Numeric] the maximum time in second to wait.
+  # @param timeout_value [Object] a value returned by the method when it times out
+  # @raise [Exception] {#reason} on rejection
+  # @return [Object, nil, timeout_value] the value of the Future when fulfilled,
+  #   or nil on rejection,
+  #   or timeout_value on timeout.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#997
+  def value!(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
+
+  # Wait (block the Thread) until receiver is {#resolved?}.
+  # Calls {Concurrent::AbstractEventFuture#touch}.
+  #
+  # @note This function potentially blocks current thread until the Future is resolved.
+  #   Be careful it can deadlock. Try to chain instead.
+  # @param timeout [Numeric] the maximum time in second to wait.
+  # @raise [Exception] {#reason} on rejection
+  # @return [self, true, false] self implies timeout was not used, true implies timeout was used
+  #   and it was resolved, false implies it was not resolved within timeout.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#987
+  def wait!(timeout = T.unsafe(nil)); end
+
+  # Crates new object with same class with the executor set as its new default executor.
+  # Any futures depending on it will use the new default executor.
+  #
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1111
+  def with_default_executor(executor); end
+
+  # Creates a new event or a future which will be resolved when receiver and other are.
+  # Returns an event if receiver and other are events, otherwise returns a future.
+  # If just one of the parties is Future then the result
+  # of the returned future is equal to the result of the supplied future. If both are futures
+  # then the result is as described in {FactoryMethods#zip_futures_on}.
+  #
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1070
+  def zip(other); end
+
+  # Creates a new event which will be resolved when the first of receiver, `event_or_future`
+  # resolves. Returning future will have value nil if event_or_future is event and resolves
+  # first.
+  #
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1085
+  def |(event_or_future); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1272
+  def async_callback_on_fulfillment(state, executor, args, callback); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1278
+  def async_callback_on_rejection(state, executor, args, callback); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1284
+  def callback_on_fulfillment(state, args, callback); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1288
+  def callback_on_rejection(state, args, callback); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1292
+  def callback_on_resolution(state, args, callback); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1251
+  def rejected_resolution(raise_on_reassign, state); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1247
+  def run_test(v); end
+
+  # @raise [self]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1266
+  def wait_until_resolved!(timeout = T.unsafe(nil)); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1984
+class Concurrent::Promises::FutureWrapperPromise < ::Concurrent::Promises::BlockedPromise
+  # @return [FutureWrapperPromise] a new instance of FutureWrapperPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1985
+  def initialize(delayed, blockers_count, default_executor); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1991
+  def on_resolvable(resolved_future, index); end
+end
+
+# will be immediately resolved
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1783
+class Concurrent::Promises::ImmediateEventPromise < ::Concurrent::Promises::InnerPromise
+  # @return [ImmediateEventPromise] a new instance of ImmediateEventPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1784
+  def initialize(default_executor); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1789
+class Concurrent::Promises::ImmediateFuturePromise < ::Concurrent::Promises::InnerPromise
+  # @return [ImmediateFuturePromise] a new instance of ImmediateFuturePromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1790
+  def initialize(default_executor, fulfilled, value, reason); end
+end
+
+# @abstract
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1615
+class Concurrent::Promises::InnerPromise < ::Concurrent::Promises::AbstractPromise; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#338
+module Concurrent::Promises::InternalStates; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#397
+class Concurrent::Promises::InternalStates::Fulfilled < ::Concurrent::Promises::InternalStates::ResolvedWithResult
+  # @return [Fulfilled] a new instance of Fulfilled
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#399
+  def initialize(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#407
+  def apply(args, block); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#403
+  def fulfilled?; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#415
+  def reason; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#419
+  def to_sym; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#411
+  def value; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#425
+class Concurrent::Promises::InternalStates::FulfilledArray < ::Concurrent::Promises::InternalStates::Fulfilled
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#426
+  def apply(args, block); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#488
+Concurrent::Promises::InternalStates::PENDING = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Pending)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#459
+class Concurrent::Promises::InternalStates::PartiallyRejected < ::Concurrent::Promises::InternalStates::ResolvedWithResult
+  # @return [PartiallyRejected] a new instance of PartiallyRejected
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#460
+  def initialize(value, reason); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#482
+  def apply(args, block); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#466
+  def fulfilled?; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#478
+  def reason; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#470
+  def to_sym; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#474
+  def value; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#351
+class Concurrent::Promises::InternalStates::Pending < ::Concurrent::Promises::InternalStates::State
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#352
+  def resolved?; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#356
+  def to_sym; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#490
+Concurrent::Promises::InternalStates::RESERVED = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Reserved)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#492
+Concurrent::Promises::InternalStates::RESOLVED = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Fulfilled)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#432
+class Concurrent::Promises::InternalStates::Rejected < ::Concurrent::Promises::InternalStates::ResolvedWithResult
+  # @return [Rejected] a new instance of Rejected
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#433
+  def initialize(reason); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#453
+  def apply(args, block); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#437
+  def fulfilled?; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#445
+  def reason; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#449
+  def to_sym; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#441
+  def value; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#362
+class Concurrent::Promises::InternalStates::Reserved < ::Concurrent::Promises::InternalStates::Pending; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#366
+class Concurrent::Promises::InternalStates::ResolvedWithResult < ::Concurrent::Promises::InternalStates::State
+  # @raise [NotImplementedError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#391
+  def apply; end
+
+  # @raise [NotImplementedError]
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#379
+  def fulfilled?; end
+
+  # @raise [NotImplementedError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#387
+  def reason; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#367
+  def resolved?; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#375
+  def result; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#371
+  def to_sym; end
+
+  # @raise [NotImplementedError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#383
+  def value; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#340
+class Concurrent::Promises::InternalStates::State
+  # @raise [NotImplementedError]
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#341
+  def resolved?; end
+
+  # @raise [NotImplementedError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#345
+  def to_sym; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1748
+class Concurrent::Promises::RescuePromise < ::Concurrent::Promises::BlockedTaskPromise
+  # @return [RescuePromise] a new instance of RescuePromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1751
+  def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1755
+  def on_resolvable(resolved_future, index); end
+end
+
+# Marker module of Future, Event resolved manually.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1299
+module Concurrent::Promises::Resolvable
+  include ::Concurrent::Promises::InternalStates
+end
+
+# A Event which can be resolved by user.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1304
+class Concurrent::Promises::ResolvableEvent < ::Concurrent::Promises::Event
+  include ::Concurrent::Promises::Resolvable
+
+  # Makes the event resolved, which triggers all dependent futures.
+  #
+  # @param raise_on_reassign [Boolean] should method raise exception if already resolved
+  # @param reserved [true, false] Set to true if the resolvable is {#reserve}d by you,
+  #   marks resolution of reserved resolvable events and futures explicitly.
+  #   Advanced feature, ignore unless you use {Resolvable#reserve} from edge.
+  # @return [self, false] false is returned when raise_on_reassign is false and the receiver
+  #   is already resolved.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1324
+  def resolve(raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
+
+  # Behaves as {AbstractEventFuture#wait} but has one additional optional argument
+  # resolve_on_timeout.
+  #
+  # @param resolve_on_timeout [true, false] If it times out and the argument is true it will also resolve the event.
+  # @return [self, true, false]
+  # @see AbstractEventFuture#wait
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1342
+  def wait(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
+
+  # Creates new event wrapping receiver, effectively hiding the resolve method.
+  #
+  # @return [Event]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1331
+  def with_hidden_resolvable; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1600
+class Concurrent::Promises::ResolvableEventPromise < ::Concurrent::Promises::AbstractPromise
+  # @return [ResolvableEventPromise] a new instance of ResolvableEventPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1601
+  def initialize(default_executor); end
+end
+
+# A Future which can be resolved by user.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1354
+class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
+  include ::Concurrent::Promises::Resolvable
+
+  # Evaluates the block and sets its result as future's value fulfilling, if the block raises
+  # an exception the future rejects with it.
+  #
+  # @return [self]
+  # @yield [*args] to the block.
+  # @yieldreturn [Object] value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1395
+  def evaluate_to(*args, &block); end
+
+  # Evaluates the block and sets its result as future's value fulfilling, if the block raises
+  # an exception the future rejects with it.
+  #
+  # @raise [Exception] also raise reason on rejection.
+  # @return [self]
+  # @yield [*args] to the block.
+  # @yieldreturn [Object] value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1406
+  def evaluate_to!(*args, &block); end
+
+  # Makes the future fulfilled with `value`,
+  # which triggers all dependent futures.
+  #
+  # @param value [Object]
+  # @param raise_on_reassign [Boolean] should method raise exception if already resolved
+  # @param reserved [true, false] Set to true if the resolvable is {#reserve}d by you,
+  #   marks resolution of reserved resolvable events and futures explicitly.
+  #   Advanced feature, ignore unless you use {Resolvable#reserve} from edge.
+  # @return [self, false] false is returned when raise_on_reassign is false and the receiver
+  #   is already resolved.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1375
+  def fulfill(value, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
+
+  # Behaves as {Future#reason} but has one additional optional argument
+  # resolve_on_timeout.
+  #
+  # @param resolve_on_timeout [::Array(true, Object, nil), ::Array(false, nil, Exception), nil] If it times out and the argument is not nil it will also resolve the future
+  #   to the provided resolution.
+  # @return [Exception, timeout_value, nil]
+  # @see Future#reason
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1503
+  def reason(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
+
+  # Makes the future rejected with `reason`,
+  # which triggers all dependent futures.
+  #
+  # @param reason [Object]
+  # @param raise_on_reassign [Boolean] should method raise exception if already resolved
+  # @param reserved [true, false] Set to true if the resolvable is {#reserve}d by you,
+  #   marks resolution of reserved resolvable events and futures explicitly.
+  #   Advanced feature, ignore unless you use {Resolvable#reserve} from edge.
+  # @return [self, false] false is returned when raise_on_reassign is false and the receiver
+  #   is already resolved.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1385
+  def reject(reason, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
+
+  # Makes the future resolved with result of triplet `fulfilled?`, `value`, `reason`,
+  # which triggers all dependent futures.
+  #
+  # @param fulfilled [true, false]
+  # @param value [Object]
+  # @param reason [Object]
+  # @param raise_on_reassign [Boolean] should method raise exception if already resolved
+  # @param reserved [true, false] Set to true if the resolvable is {#reserve}d by you,
+  #   marks resolution of reserved resolvable events and futures explicitly.
+  #   Advanced feature, ignore unless you use {Resolvable#reserve} from edge.
+  # @return [self, false] false is returned when raise_on_reassign is false and the receiver
+  #   is already resolved.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1365
+  def resolve(fulfilled = T.unsafe(nil), value = T.unsafe(nil), reason = T.unsafe(nil), raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
+
+  # Behaves as {Future#result} but has one additional optional argument
+  # resolve_on_timeout.
+  #
+  # @param resolve_on_timeout [::Array(true, Object, nil), ::Array(false, nil, Exception), nil] If it times out and the argument is not nil it will also resolve the future
+  #   to the provided resolution.
+  # @return [::Array(Boolean, Object, Exception), nil]
+  # @see Future#result
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1524
+  def result(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
+
+  # Behaves as {Future#value} but has one additional optional argument
+  # resolve_on_timeout.
+  #
+  # @param resolve_on_timeout [::Array(true, Object, nil), ::Array(false, nil, Exception), nil] If it times out and the argument is not nil it will also resolve the future
+  #   to the provided resolution.
+  # @return [Object, timeout_value, nil]
+  # @see Future#value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1459
+  def value(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
+
+  # Behaves as {Future#value!} but has one additional optional argument
+  # resolve_on_timeout.
+  #
+  # @param resolve_on_timeout [::Array(true, Object, nil), ::Array(false, nil, Exception), nil] If it times out and the argument is not nil it will also resolve the future
+  #   to the provided resolution.
+  # @raise [Exception] {#reason} on rejection
+  # @return [Object, timeout_value, nil]
+  # @see Future#value!
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1481
+  def value!(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
+
+  # Behaves as {AbstractEventFuture#wait} but has one additional optional argument
+  # resolve_on_timeout.
+  #
+  # @param resolve_on_timeout [::Array(true, Object, nil), ::Array(false, nil, Exception), nil] If it times out and the argument is not nil it will also resolve the future
+  #   to the provided resolution.
+  # @return [self, true, false]
+  # @see AbstractEventFuture#wait
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1421
+  def wait(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
+
+  # Behaves as {Future#wait!} but has one additional optional argument
+  # resolve_on_timeout.
+  #
+  # @param resolve_on_timeout [::Array(true, Object, nil), ::Array(false, nil, Exception), nil] If it times out and the argument is not nil it will also resolve the future
+  #   to the provided resolution.
+  # @raise [Exception] {#reason} on rejection
+  # @return [self, true, false]
+  # @see Future#wait!
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1438
+  def wait!(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
+
+  # Creates new future wrapping receiver, effectively hiding the resolve method and similar.
+  #
+  # @return [Future]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1542
+  def with_hidden_resolvable; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1606
+class Concurrent::Promises::ResolvableFuturePromise < ::Concurrent::Promises::AbstractPromise
+  # @return [ResolvableFuturePromise] a new instance of ResolvableFuturePromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1607
+  def initialize(default_executor); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1592
+  def evaluate_to(*args, block); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1909
+class Concurrent::Promises::RunFuturePromise < ::Concurrent::Promises::AbstractFlatPromise
+  # @return [RunFuturePromise] a new instance of RunFuturePromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1913
+  def initialize(delayed, blockers_count, default_executor, run_test); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1918
+  def process_on_blocker_resolution(future, index); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2114
+class Concurrent::Promises::ScheduledPromise < ::Concurrent::Promises::InnerPromise
+  # @return [ScheduledPromise] a new instance of ScheduledPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2125
+  def initialize(default_executor, intended_time); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2119
+  def inspect; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2115
+  def intended_time; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1730
+class Concurrent::Promises::ThenPromise < ::Concurrent::Promises::BlockedTaskPromise
+  # @return [ThenPromise] a new instance of ThenPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1733
+  def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1737
+  def on_resolvable(resolved_future, index); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1940
+class Concurrent::Promises::ZipEventEventPromise < ::Concurrent::Promises::BlockedPromise
+  # @return [ZipEventEventPromise] a new instance of ZipEventEventPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1941
+  def initialize(delayed, blockers_count, default_executor); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1947
+  def on_resolvable(resolved_future, index); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2031
+class Concurrent::Promises::ZipEventsPromise < ::Concurrent::Promises::BlockedPromise
+  # @return [ZipEventsPromise] a new instance of ZipEventsPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2035
+  def initialize(delayed, blockers_count, default_executor); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2041
+  def on_resolvable(resolved_future, index); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1952
+class Concurrent::Promises::ZipFutureEventPromise < ::Concurrent::Promises::BlockedPromise
+  # @return [ZipFutureEventPromise] a new instance of ZipFutureEventPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1953
+  def initialize(delayed, blockers_count, default_executor); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1967
+  def on_resolvable(resolved_future, index); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1960
+  def process_on_blocker_resolution(future, index); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1996
+class Concurrent::Promises::ZipFuturesPromise < ::Concurrent::Promises::BlockedPromise
+  # @return [ZipFuturesPromise] a new instance of ZipFuturesPromise
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2000
+  def initialize(delayed, blockers_count, default_executor); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2013
+  def on_resolvable(resolved_future, index); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2007
+  def process_on_blocker_resolution(future, index); end
+end
+
+# Methods form module A included to a module B, which is already included into class C,
+# will not be visible in the C class. If this module is extended to B then A's methods
+# are correctly made visible to C.
+#
+# @example
+#   module A
+#   def a
+#   :a
+#   end
+#   end
+#
+#   module B1
+#   end
+#
+#   class C1
+#   include B1
+#   end
+#
+#   module B2
+#   extend Concurrent::ReInclude
+#   end
+#
+#   class C2
+#   include B2
+#   end
+#
+#   B1.send :include, A
+#   B2.send :include, A
+#
+#   C1.new.respond_to? :a # => false
+#   C2.new.respond_to? :a # => true
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/re_include.rb#36
+module Concurrent::ReInclude
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/re_include.rb#44
+  def extended(base); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/re_include.rb#50
+  def include(*modules); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/re_include.rb#38
+  def included(base); end
+end
+
+# Ruby read-write lock implementation
+#
+# Allows any number of concurrent readers, but only one concurrent writer
+# (And if the "write" lock is taken, any readers who come along will have to wait)
+#
+# If readers are already active when a writer comes along, the writer will wait for
+# all the readers to finish before going ahead.
+# Any additional readers that come when the writer is already waiting, will also
+# wait (so writers are not starved).
+#
+# This implementation is based on `java.util.concurrent.ReentrantReadWriteLock`.
+#
+# @example
+#   lock = Concurrent::ReadWriteLock.new
+#   lock.with_read_lock  { data.retrieve }
+#   lock.with_write_lock { data.modify! }
+# @note Do **not** try to acquire the write lock while already holding a read lock
+#   **or** try to acquire the write lock while you already have it.
+#   This will lead to deadlock
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/ReentrantReadWriteLock.html java.util.concurrent.ReentrantReadWriteLock
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#31
+class Concurrent::ReadWriteLock < ::Concurrent::Synchronization::Object
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # Create a new `ReadWriteLock` in the unlocked state.
+  #
+  # @return [ReadWriteLock] a new instance of ReadWriteLock
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#59
+  def initialize; end
+
+  # Acquire a read lock. If a write lock has been acquired will block until
+  # it is released. Will not block if other read locks have been acquired.
+  #
+  # @raise [Concurrent::ResourceLimitError] if the maximum number of readers
+  #   is exceeded.
+  # @return [Boolean] true if the lock is successfully acquired
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#111
+  def acquire_read_lock; end
+
+  # Acquire a write lock. Will block and wait for all active readers and writers.
+  #
+  # @raise [Concurrent::ResourceLimitError] if the maximum number of writers
+  #   is exceeded.
+  # @return [Boolean] true if the lock is successfully acquired
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#160
+  def acquire_write_lock; end
+
+  # Queries whether any threads are waiting to acquire the read or write lock.
+  #
+  # @return [Boolean] true if any threads are waiting for a lock else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#214
+  def has_waiters?; end
+
+  # Release a previously acquired read lock.
+  #
+  # @return [Boolean] true if the lock is successfully released
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#140
+  def release_read_lock; end
+
+  # Release a previously acquired write lock.
+  #
+  # @return [Boolean] true if the lock is successfully released
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#196
+  def release_write_lock; end
+
+  # Execute a block operation within a read lock.
+  #
+  # @raise [ArgumentError] when no block is given.
+  # @raise [Concurrent::ResourceLimitError] if the maximum number of readers
+  #   is exceeded.
+  # @return [Object] the result of the block operation.
+  # @yield the task to be performed within the lock.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#75
+  def with_read_lock; end
+
+  # Execute a block operation within a write lock.
+  #
+  # @raise [ArgumentError] when no block is given.
+  # @raise [Concurrent::ResourceLimitError] if the maximum number of readers
+  #   is exceeded.
+  # @return [Object] the result of the block operation.
+  # @yield the task to be performed within the lock.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#94
+  def with_write_lock; end
+
+  # Queries if the write lock is held by any thread.
+  #
+  # @return [Boolean] true if the write lock is held else false`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#207
+  def write_locked?; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#246
+  def max_readers?(c = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#251
+  def max_writers?(c = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#221
+  def running_readers(c = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#226
+  def running_readers?(c = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#231
+  def running_writer?(c = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#241
+  def waiting_writer?(c = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#236
+  def waiting_writers(c = T.unsafe(nil)); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#40
+Concurrent::ReadWriteLock::MAX_READERS = T.let(T.unsafe(nil), Integer)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#43
+Concurrent::ReadWriteLock::MAX_WRITERS = T.let(T.unsafe(nil), Integer)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#37
+Concurrent::ReadWriteLock::RUNNING_WRITER = T.let(T.unsafe(nil), Integer)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb#34
+Concurrent::ReadWriteLock::WAITING_WRITER = T.let(T.unsafe(nil), Integer)
+
+# Re-entrant read-write lock implementation
+#
+# Allows any number of concurrent readers, but only one concurrent writer
+# (And while the "write" lock is taken, no read locks can be obtained either.
+# Hence, the write lock can also be called an "exclusive" lock.)
+#
+# If another thread has taken a read lock, any thread which wants a write lock
+# will block until all the readers release their locks. However, once a thread
+# starts waiting to obtain a write lock, any additional readers that come along
+# will also wait (so writers are not starved).
+#
+# A thread can acquire both a read and write lock at the same time. A thread can
+# also acquire a read lock OR a write lock more than once. Only when the read (or
+# write) lock is released as many times as it was acquired, will the thread
+# actually let it go, allowing other threads which might have been waiting
+# to proceed. Therefore the lock can be upgraded by first acquiring
+# read lock and then write lock and that the lock can be downgraded by first
+# having both read and write lock a releasing just the write lock.
+#
+# If both read and write locks are acquired by the same thread, it is not strictly
+# necessary to release them in the same order they were acquired. In other words,
+# the following code is legal:
+#
+# This implementation was inspired by `java.util.concurrent.ReentrantReadWriteLock`.
+#
+# @example
+#   lock = Concurrent::ReentrantReadWriteLock.new
+#   lock.acquire_write_lock
+#   lock.acquire_read_lock
+#   lock.release_write_lock
+#   # At this point, the current thread is holding only a read lock, not a write
+#   # lock. So other threads can take read locks, but not a write lock.
+#   lock.release_read_lock
+#   # Now the current thread is not holding either a read or write lock, so
+#   # another thread could potentially acquire a write lock.
+# @example
+#   lock = Concurrent::ReentrantReadWriteLock.new
+#   lock.with_read_lock  { data.retrieve }
+#   lock.with_write_lock { data.modify! }
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/ReentrantReadWriteLock.html java.util.concurrent.ReentrantReadWriteLock
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#53
+class Concurrent::ReentrantReadWriteLock < ::Concurrent::Synchronization::Object
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # Create a new `ReentrantReadWriteLock` in the unlocked state.
+  #
+  # @return [ReentrantReadWriteLock] a new instance of ReentrantReadWriteLock
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#109
+  def initialize; end
+
+  # Acquire a read lock. If a write lock is held by another thread, will block
+  # until it is released.
+  #
+  # @raise [Concurrent::ResourceLimitError] if the maximum number of readers
+  #   is exceeded.
+  # @return [Boolean] true if the lock is successfully acquired
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#162
+  def acquire_read_lock; end
+
+  # Acquire a write lock. Will block and wait for all active readers and writers.
+  #
+  # @raise [Concurrent::ResourceLimitError] if the maximum number of writers
+  #   is exceeded.
+  # @return [Boolean] true if the lock is successfully acquired
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#257
+  def acquire_write_lock; end
+
+  # Release a previously acquired read lock.
+  #
+  # @return [Boolean] true if the lock is successfully released
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#236
+  def release_read_lock; end
+
+  # Release a previously acquired write lock.
+  #
+  # @return [Boolean] true if the lock is successfully released
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#329
+  def release_write_lock; end
+
+  # Try to acquire a read lock and return true if we succeed. If it cannot be
+  # acquired immediately, return false.
+  #
+  # @return [Boolean] true if the lock is successfully acquired
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#215
+  def try_read_lock; end
+
+  # Try to acquire a write lock and return true if we succeed. If it cannot be
+  # acquired immediately, return false.
+  #
+  # @return [Boolean] true if the lock is successfully acquired
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#310
+  def try_write_lock; end
+
+  # Execute a block operation within a read lock.
+  #
+  # @raise [ArgumentError] when no block is given.
+  # @raise [Concurrent::ResourceLimitError] if the maximum number of readers
+  #   is exceeded.
+  # @return [Object] the result of the block operation.
+  # @yield the task to be performed within the lock.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#126
+  def with_read_lock; end
+
+  # Execute a block operation within a write lock.
+  #
+  # @raise [ArgumentError] when no block is given.
+  # @raise [Concurrent::ResourceLimitError] if the maximum number of readers
+  #   is exceeded.
+  # @return [Object] the result of the block operation.
+  # @yield the task to be performed within the lock.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#145
+  def with_write_lock; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#370
+  def max_readers?(c = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#375
+  def max_writers?(c = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#345
+  def running_readers(c = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#350
+  def running_readers?(c = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#355
+  def running_writer?(c = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#365
+  def waiting_or_running_writer?(c = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#360
+  def waiting_writers(c = T.unsafe(nil)); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#94
+Concurrent::ReentrantReadWriteLock::MAX_READERS = T.let(T.unsafe(nil), Integer)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#96
+Concurrent::ReentrantReadWriteLock::MAX_WRITERS = T.let(T.unsafe(nil), Integer)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#84
+Concurrent::ReentrantReadWriteLock::READER_BITS = T.let(T.unsafe(nil), Integer)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#102
+Concurrent::ReentrantReadWriteLock::READ_LOCK_MASK = T.let(T.unsafe(nil), Integer)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#92
+Concurrent::ReentrantReadWriteLock::RUNNING_WRITER = T.let(T.unsafe(nil), Integer)
+
+# Used with @Counter:
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#90
+Concurrent::ReentrantReadWriteLock::WAITING_WRITER = T.let(T.unsafe(nil), Integer)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#86
+Concurrent::ReentrantReadWriteLock::WRITER_BITS = T.let(T.unsafe(nil), Integer)
+
+# Used with @HeldCount:
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#100
+Concurrent::ReentrantReadWriteLock::WRITE_LOCK_HELD = T.let(T.unsafe(nil), Integer)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb#104
+Concurrent::ReentrantReadWriteLock::WRITE_LOCK_MASK = T.let(T.unsafe(nil), Integer)
+
+# Raised by an `Executor` when it is unable to process a given task,
+# possibly because of a reject policy or other internal error.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#48
+class Concurrent::RejectedExecutionError < ::Concurrent::Error; end
+
+# Raised when any finite resource, such as a lock counter, exceeds its
+# maximum limit/threshold.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#52
+class Concurrent::ResourceLimitError < ::Concurrent::Error; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#129
+class Concurrent::RubyExchanger < ::Concurrent::AbstractExchanger
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # @return [RubyExchanger] a new instance of RubyExchanger
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#159
+  def initialize; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#137
+  def __initialize_atomic_fields__; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#105
+  def compare_and_set_slot(expected, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#93
+  def slot; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#97
+  def slot=(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#101
+  def swap_slot(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#109
+  def update_slot(&block); end
+
+  private
+
+  # Waits for another thread to arrive at this exchange point (unless the
+  # current thread is interrupted), and then transfers the given object to
+  # it, receiving its object in return. The timeout value indicates the
+  # approximate number of seconds the method should block while waiting
+  # for the exchange. When the timeout value is `nil` the method will
+  # block indefinitely.
+  #
+  # @param value [Object] the value to exchange with another thread
+  # @param timeout [Numeric, nil] in seconds, `nil` blocks indefinitely
+  # @return [Object, CANCEL] the value exchanged by the other thread; {CANCEL} on timeout
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#170
+  def do_exchange(value, timeout); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#138
+class Concurrent::RubyExchanger::Node < ::Concurrent::Synchronization::Object
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # @return [Node] a new instance of Node
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#142
+  def initialize(item); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#137
+  def __initialize_atomic_fields__; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#105
+  def compare_and_set_value(expected, value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#153
+  def item; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#149
+  def latch; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#101
+  def swap_value(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#109
+  def update_value(&block); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#93
+  def value; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#97
+  def value=(value); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb#8
+class Concurrent::RubyExecutorService < ::Concurrent::AbstractExecutorService
+  # @return [RubyExecutorService] a new instance of RubyExecutorService
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb#11
+  def initialize(*args, &block); end
+
+  # Begin an immediate shutdown. In-progress tasks will be allowed to
+  # complete but enqueued tasks will be dismissed and no new tasks
+  # will be accepted. Has no additional effect if the thread pool is
+  # not running.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb#42
+  def kill; end
+
+  # Submit a task to the executor for asynchronous processing.
+  #
+  # @param args [Array] zero or more arguments to be passed to the task
+  # @raise [ArgumentError] if no task is given
+  # @return [Boolean] `true` if the task is queued, `false` if the executor
+  #   is not running
+  # @yield the asynchronous task to perform
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb#17
+  def post(*args, &task); end
+
+  # Begin an orderly shutdown. Tasks already in the queue will be executed,
+  # but no new tasks will be accepted. Has no additional effect if the
+  # thread pool is not running.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb#33
+  def shutdown; end
+
+  # Block until executor shutdown is complete or until `timeout` seconds have
+  # passed.
+  #
+  # @note Does not initiate shutdown or termination. Either `shutdown` or `kill`
+  #   must be called before this method (or on another thread).
+  # @param timeout [Integer] the maximum number of seconds to wait for shutdown to complete
+  # @return [Boolean] `true` if shutdown complete or false on `timeout`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb#52
+  def wait_for_termination(timeout = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb#70
+  def ns_running?; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb#78
+  def ns_shutdown?; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb#66
+  def ns_shutdown_execution; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb#74
+  def ns_shuttingdown?; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb#58
+  def stop_event; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb#62
+  def stopped_event; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_single_thread_executor.rb#8
+class Concurrent::RubySingleThreadExecutor < ::Concurrent::RubyThreadPoolExecutor
+  # @return [RubySingleThreadExecutor] a new instance of RubySingleThreadExecutor
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_single_thread_executor.rb#11
+  def initialize(opts = T.unsafe(nil)); end
+end
+
+# **Thread Pool Options**
+#
+# Thread pools support several configuration options:
+#
+# * `idletime`: The number of seconds that a thread may be idle before being reclaimed.
+# * `name`: The name of the executor (optional). Printed in the executor's `#to_s` output and
+#   a `<name>-worker-<id>` name is given to its threads if supported by used Ruby
+#   implementation. `<id>` is uniq for each thread.
+# * `max_queue`: The maximum number of tasks that may be waiting in the work queue at
+#   any one time. When the queue size reaches `max_queue` and no new threads can be created,
+#   subsequent tasks will be rejected in accordance with the configured `fallback_policy`.
+# * `auto_terminate`: When true (default), the threads started will be marked as daemon.
+# * `fallback_policy`: The policy defining how rejected tasks are handled.
+#
+# Three fallback policies are supported:
+#
+# * `:abort`: Raise a `RejectedExecutionError` exception and discard the task.
+# * `:discard`: Discard the task and return false.
+# * `:caller_runs`: Execute the task on the calling thread.
+#
+# **Shutting Down Thread Pools**
+#
+# Killing a thread pool while tasks are still being processed, either by calling
+# the `#kill` method or at application exit, will have unpredictable results. There
+# is no way for the thread pool to know what resources are being used by the
+# in-progress tasks. When those tasks are killed the impact on those resources
+# cannot be predicted. The *best* practice is to explicitly shutdown all thread
+# pools using the provided methods:
+#
+# * Call `#shutdown` to initiate an orderly termination of all in-progress tasks
+# * Call `#wait_for_termination` with an appropriate timeout interval an allow
+#   the orderly shutdown to complete
+# * Call `#kill` *only when* the thread pool fails to shutdown in the allotted time
+#
+# On some runtime platforms (most notably the JVM) the application will not
+# exit until all thread pools have been shutdown. To prevent applications from
+# "hanging" on exit, all threads can be marked as daemon according to the
+# `:auto_terminate` option.
+#
+# ```ruby
+# pool1 = Concurrent::FixedThreadPool.new(5) # threads will be marked as daemon
+# pool2 = Concurrent::FixedThreadPool.new(5, auto_terminate: false) # mark threads as non-daemon
+# ```
+#
+# @note Failure to properly shutdown a thread pool can lead to unpredictable results.
+#   Please read *Shutting Down Thread Pools* for more information.
+# @see http://docs.oracle.com/javase/tutorial/essential/concurrency/pools.html Java Tutorials: Thread Pools
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executors.html Java Executors class
+# @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html Java ExecutorService interface
+# @see https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html#setDaemon-boolean-
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#12
+class Concurrent::RubyThreadPoolExecutor < ::Concurrent::RubyExecutorService
+  # @return [RubyThreadPoolExecutor] a new instance of RubyThreadPoolExecutor
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#45
+  def initialize(opts = T.unsafe(nil)); end
+
+  # The number of threads that are actively executing tasks.
+  #
+  # @return [Integer] The number of threads that are actively executing tasks.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#65
+  def active_count; end
+
+  # Does the task queue have a maximum size?
+  #
+  # @return [Boolean] True if the task queue has a maximum size else false.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#72
+  def can_overflow?; end
+
+  # The number of tasks that have been completed by the pool since construction.
+  #
+  # @return [Integer] The number of tasks that have been completed by the pool since construction.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#60
+  def completed_task_count; end
+
+  # The number of seconds that a thread may be idle before being reclaimed.
+  #
+  # @return [Integer] The number of seconds that a thread may be idle before being reclaimed.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#36
+  def idletime; end
+
+  # The largest number of threads that have been created in the pool since construction.
+  #
+  # @return [Integer] The largest number of threads that have been created in the pool since construction.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#50
+  def largest_length; end
+
+  # The number of threads currently in the pool.
+  #
+  # @return [Integer] The number of threads currently in the pool.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#77
+  def length; end
+
+  # The maximum number of threads that may be created in the pool.
+  #
+  # @return [Integer] The maximum number of threads that may be created in the pool.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#30
+  def max_length; end
+
+  # The maximum number of tasks that may be waiting in the work queue at any one time.
+  # When the queue size reaches `max_queue` subsequent tasks will be rejected in
+  # accordance with the configured `fallback_policy`.
+  #
+  # @return [Integer] The maximum number of tasks that may be waiting in the work queue at any one time.
+  #   When the queue size reaches `max_queue` subsequent tasks will be rejected in
+  #   accordance with the configured `fallback_policy`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#39
+  def max_queue; end
+
+  # The minimum number of threads that may be retained in the pool.
+  #
+  # @return [Integer] The minimum number of threads that may be retained in the pool.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#33
+  def min_length; end
+
+  # Prune the thread pool of unneeded threads
+  #
+  # What is being pruned is controlled by the min_threads and idletime
+  # parameters passed at pool creation time
+  #
+  # This is a no-op on some pool implementation (e.g. the Java one).  The Ruby
+  # pool will auto-prune each time a new job is posted. You will need to call
+  # this method explicitely in case your application post jobs in bursts (a
+  # lot of jobs and then nothing for long periods)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#118
+  def prune_pool; end
+
+  # The number of tasks in the queue awaiting execution.
+  #
+  # @return [Integer] The number of tasks in the queue awaiting execution.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#82
+  def queue_length; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#103
+  def ready_worker(worker, last_message); end
+
+  # Number of tasks that may be enqueued before reaching `max_queue` and rejecting
+  # new tasks. A value of -1 indicates that the queue may grow without bound.
+  #
+  # @return [Integer] Number of tasks that may be enqueued before reaching `max_queue` and rejecting
+  #   new tasks. A value of -1 indicates that the queue may grow without bound.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#87
+  def remaining_capacity; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#98
+  def remove_busy_worker(worker); end
+
+  # The number of tasks that have been scheduled for execution on the pool since construction.
+  #
+  # @return [Integer] The number of tasks that have been scheduled for execution on the pool since construction.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#55
+  def scheduled_task_count; end
+
+  # Whether or not a value of 0 for :max_queue option means the queue must perform direct hand-off or rather unbounded queue.
+  #
+  # @return [true, false]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#42
+  def synchronous; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#108
+  def worker_died(worker); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#113
+  def worker_task_completed; end
+
+  private
+
+  # creates new worker which has to receive work to do after it's added
+  #
+  # @return [nil, Worker] nil of max capacity is reached
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#241
+  def ns_add_busy_worker; end
+
+  # tries to assign task to a worker, tries to get one from @ready or to create new one
+  #
+  # @return [true, false] if task is assigned to a worker
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#201
+  def ns_assign_worker(*args, &task); end
+
+  # tries to enqueue task
+  #
+  # @return [true, false] if enqueued
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#219
+  def ns_enqueue(*args, &task); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#160
+  def ns_execute(*args, &task); end
+
+  # @raise [ArgumentError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#125
+  def ns_initialize(opts); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#189
+  def ns_kill_execution; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#155
+  def ns_limited_queue?; end
+
+  # try oldest worker if it is idle for enough time, it's returned back at the start
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#280
+  def ns_prune_pool; end
+
+  # handle ready worker, giving it new job or assigning back to @ready
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#253
+  def ns_ready_worker(worker, last_message, success = T.unsafe(nil)); end
+
+  # removes a worker which is not in not tracked in @ready
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#271
+  def ns_remove_busy_worker(worker); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#296
+  def ns_reset_if_forked; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#174
+  def ns_shutdown_execution; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#231
+  def ns_worker_died(worker); end
+end
+
+# Default maximum number of threads that will be created in the pool.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#15
+Concurrent::RubyThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE = T.let(T.unsafe(nil), Integer)
+
+# Default maximum number of tasks that may be added to the task queue.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#21
+Concurrent::RubyThreadPoolExecutor::DEFAULT_MAX_QUEUE_SIZE = T.let(T.unsafe(nil), Integer)
+
+# Default minimum number of threads that will be retained in the pool.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#18
+Concurrent::RubyThreadPoolExecutor::DEFAULT_MIN_POOL_SIZE = T.let(T.unsafe(nil), Integer)
+
+# Default value of the :synchronous option.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#27
+Concurrent::RubyThreadPoolExecutor::DEFAULT_SYNCHRONOUS = T.let(T.unsafe(nil), FalseClass)
+
+# Default maximum number of seconds a thread in the pool may remain idle
+# before being reclaimed.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#24
+Concurrent::RubyThreadPoolExecutor::DEFAULT_THREAD_IDLETIMEOUT = T.let(T.unsafe(nil), Integer)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#310
+class Concurrent::RubyThreadPoolExecutor::Worker
+  include ::Logger::Severity
+  include ::Concurrent::Concern::Logging
+
+  # @return [Worker] a new instance of Worker
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#313
+  def initialize(pool, id); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#324
+  def <<(message); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#332
+  def kill; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#328
+  def stop; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#338
+  def create_worker(queue, pool, idletime); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#358
+  def run_task(pool, task, args); end
+end
+
+# A simple utility class that executes a callable and returns and array of three elements:
+# success - indicating if the callable has been executed without errors
+# value - filled by the callable result if it has been executed without errors, nil otherwise
+# reason - the error risen by the callable if it has been executed with errors, nil otherwise
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/safe_task_executor.rb#9
+class Concurrent::SafeTaskExecutor < ::Concurrent::Synchronization::LockableObject
+  # @return [SafeTaskExecutor] a new instance of SafeTaskExecutor
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/safe_task_executor.rb#11
+  def initialize(task, opts = T.unsafe(nil)); end
+
+  # @return [Array]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/safe_task_executor.rb#18
+  def execute(*args); end
+end
+
+# `ScheduledTask` is a close relative of `Concurrent::Future` but with one
+# important difference: A `Future` is set to execute as soon as possible
+# whereas a `ScheduledTask` is set to execute after a specified delay. This
+# implementation is loosely based on Java's
+# [ScheduledExecutorService](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ScheduledExecutorService.html).
+# It is a more feature-rich variant of {Concurrent.timer}.
+#
+# The *intended* schedule time of task execution is set on object construction
+# with the `delay` argument. The delay is a numeric (floating point or integer)
+# representing a number of seconds in the future. Any other value or a numeric
+# equal to or less than zero will result in an exception. The *actual* schedule
+# time of task execution is set when the `execute` method is called.
+#
+# The constructor can also be given zero or more processing options. Currently
+# the only supported options are those recognized by the
+# [Dereferenceable](Dereferenceable) module.
+#
+# The final constructor argument is a block representing the task to be performed.
+# If no block is given an `ArgumentError` will be raised.
+#
+# **States**
+#
+# `ScheduledTask` mixes in the  [Obligation](Obligation) module thus giving it
+# "future" behavior. This includes the expected lifecycle states. `ScheduledTask`
+# has one additional state, however. While the task (block) is being executed the
+# state of the object will be `:processing`. This additional state is necessary
+# because it has implications for task cancellation.
+#
+# **Cancellation**
+#
+# A `:pending` task can be cancelled using the `#cancel` method. A task in any
+# other state, including `:processing`, cannot be cancelled. The `#cancel`
+# method returns a boolean indicating the success of the cancellation attempt.
+# A cancelled `ScheduledTask` cannot be restarted. It is immutable.
+#
+# **Obligation and Observation**
+#
+# The result of a `ScheduledTask` can be obtained either synchronously or
+# asynchronously. `ScheduledTask` mixes in both the [Obligation](Obligation)
+# module and the
+# [Observable](http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html)
+# module from the Ruby standard library. With one exception `ScheduledTask`
+# behaves identically to [Future](Observable) with regard to these modules.
+#
+# @example Basic usage
+#
+#   require 'concurrent/scheduled_task'
+#   require 'csv'
+#   require 'open-uri'
+#
+#   class Ticker
+#   def get_year_end_closing(symbol, year, api_key)
+#   uri = "https://www.alphavantage.co/query?function=TIME_SERIES_MONTHLY&symbol=#{symbol}&apikey=#{api_key}&datatype=csv"
+#   data = []
+#   csv = URI.parse(uri).read
+#   if csv.include?('call frequency')
+#   return :rate_limit_exceeded
+#   end
+#   CSV.parse(csv, headers: true) do |row|
+#   data << row['close'].to_f if row['timestamp'].include?(year.to_s)
+#   end
+#   year_end = data.first
+#   year_end
+#   rescue => e
+#   p e
+#   end
+#   end
+#
+#   api_key = ENV['ALPHAVANTAGE_KEY']
+#   abort(error_message) unless api_key
+#
+#   # Future
+#   price = Concurrent::Future.execute{ Ticker.new.get_year_end_closing('TWTR', 2013, api_key) }
+#   price.state #=> :pending
+#   price.pending? #=> true
+#   price.value(0) #=> nil (does not block)
+#
+#   sleep(1)    # do other stuff
+#
+#   price.value #=> 63.65 (after blocking if necessary)
+#   price.state #=> :fulfilled
+#   price.fulfilled? #=> true
+#   price.value #=> 63.65
+# @example Successful task execution
+#
+#   task = Concurrent::ScheduledTask.new(2){ 'What does the fox say?' }
+#   task.state         #=> :unscheduled
+#   task.execute
+#   task.state         #=> pending
+#
+#   # wait for it...
+#   sleep(3)
+#
+#   task.unscheduled? #=> false
+#   task.pending?     #=> false
+#   task.fulfilled?   #=> true
+#   task.rejected?    #=> false
+#   task.value        #=> 'What does the fox say?'
+# @example One line creation and execution
+#
+#   task = Concurrent::ScheduledTask.new(2){ 'What does the fox say?' }.execute
+#   task.state         #=> pending
+#
+#   task = Concurrent::ScheduledTask.execute(2){ 'What do you get when you multiply 6 by 9?' }
+#   task.state         #=> pending
+# @example Failed task execution
+#
+#   task = Concurrent::ScheduledTask.execute(2){ raise StandardError.new('Call me maybe?') }
+#   task.pending?      #=> true
+#
+#   # wait for it...
+#   sleep(3)
+#
+#   task.unscheduled? #=> false
+#   task.pending?     #=> false
+#   task.fulfilled?   #=> false
+#   task.rejected?    #=> true
+#   task.value        #=> nil
+#   task.reason       #=> #<StandardError: Call me maybe?>
+# @example Task execution with observation
+#
+#   observer = Class.new{
+#   def update(time, value, reason)
+#   puts "The task completed at #{time} with value '#{value}'"
+#   end
+#   }.new
+#
+#   task = Concurrent::ScheduledTask.new(2){ 'What does the fox say?' }
+#   task.add_observer(observer)
+#   task.execute
+#   task.pending?      #=> true
+#
+#   # wait for it...
+#   sleep(3)
+#
+#   #>> The task completed at 2013-11-07 12:26:09 -0500 with value 'What does the fox say?'
+# @see Concurrent.timer
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#158
+class Concurrent::ScheduledTask < ::Concurrent::IVar
+  include ::Comparable
+
+  # Schedule a task for execution at a specified future time.
+  #
+  # @option opts
+  # @param delay [Float] the number of seconds to wait for before executing the task
+  # @param opts [Hash] a customizable set of options
+  # @raise [ArgumentError] When no block is given
+  # @raise [ArgumentError] When given a time that is in the past
+  # @return [ScheduledTask] a new instance of ScheduledTask
+  # @yield the task to be performed
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#178
+  def initialize(delay, opts = T.unsafe(nil), &task); end
+
+  # Comparator which orders by schedule time.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#213
+  def <=>(other); end
+
+  # Cancel this task and prevent it from executing. A task can only be
+  # cancelled if it is pending or unscheduled.
+  #
+  # @return [Boolean] true if successfully cancelled else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#235
+  def cancel; end
+
+  # Has the task been cancelled?
+  #
+  # @return [Boolean] true if the task is in the given state else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#220
+  def cancelled?; end
+
+  # Execute an `:unscheduled` `ScheduledTask`. Immediately sets the state to `:pending`
+  # and starts counting down toward execution. Does nothing if the `ScheduledTask` is
+  # in any state other than `:unscheduled`.
+  #
+  # @return [ScheduledTask] a reference to `self`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#273
+  def execute; end
+
+  # The executor on which to execute the task.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#163
+  def executor; end
+
+  # The `delay` value given at instanciation.
+  #
+  # @return [Float] the initial delay.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#199
+  def initial_delay; end
+
+  # Execute the task.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#297
+  def process_task; end
+
+  # In the task execution in progress?
+  #
+  # @return [Boolean] true if the task is in the given state else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#227
+  def processing?; end
+
+  # Reschedule the task using the given delay and the current time.
+  # A task can only be reset while it is `:pending`.
+  #
+  # @param delay [Float] the number of seconds to wait for before executing the task
+  # @raise [ArgumentError] When given a time that is in the past
+  # @return [Boolean] true if successfully rescheduled else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#262
+  def reschedule(delay); end
+
+  # Reschedule the task using the original delay and the current time.
+  # A task can only be reset while it is `:pending`.
+  #
+  # @return [Boolean] true if successfully rescheduled else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#250
+  def reset; end
+
+  # The monotonic time at which the the task is scheduled to be executed.
+  #
+  # @return [Float] the schedule time or nil if `unscheduled`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#206
+  def schedule_time; end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#135
+  def fail(reason = T.unsafe(nil)); end
+
+  # Reschedule the task using the given delay and the current time.
+  # A task can only be reset while it is `:pending`.
+  #
+  # @param delay [Float] the number of seconds to wait for before executing the task
+  # @return [Boolean] true if successfully rescheduled else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#326
+  def ns_reschedule(delay); end
+
+  # Schedule the task using the given delay and the current time.
+  #
+  # @param delay [Float] the number of seconds to wait for before executing the task
+  # @return [Boolean] true if successfully rescheduled else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#312
+  def ns_schedule(delay); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#113
+  def set(value = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/ivar.rb#145
+  def try_set(value = T.unsafe(nil), &block); end
+
+  class << self
+    # Create a new `ScheduledTask` object with the given block, execute it, and return the
+    # `:pending` object.
+    #
+    # @param delay [Float] the number of seconds to wait for before executing the task
+    # @raise [ArgumentError] if no block is given
+    # @return [ScheduledTask] the newly created `ScheduledTask` in the `:pending` state
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/scheduled_task.rb#290
+    def execute(delay, opts = T.unsafe(nil), &task); end
+  end
+end
+
+# A counting semaphore. Conceptually, a semaphore maintains a set of
+# permits. Each {#acquire} blocks if necessary until a permit is
+# available, and then takes it. Each {#release} adds a permit, potentially
+# releasing a blocking acquirer.
+# However, no actual permit objects are used; the Semaphore just keeps a
+# count of the number available and acts accordingly.
+# Alternatively, permits may be acquired within a block, and automatically
+# released after the block finishes executing.
+#
+# @example
+#   semaphore = Concurrent::Semaphore.new(2)
+#
+#   t1 = Thread.new do
+#   semaphore.acquire
+#   puts "Thread 1 acquired semaphore"
+#   end
+#
+#   t2 = Thread.new do
+#   semaphore.acquire
+#   puts "Thread 2 acquired semaphore"
+#   end
+#
+#   t3 = Thread.new do
+#   semaphore.acquire
+#   puts "Thread 3 acquired semaphore"
+#   end
+#
+#   t4 = Thread.new do
+#   sleep(2)
+#   puts "Thread 4 releasing semaphore"
+#   semaphore.release
+#   end
+#
+#   [t1, t2, t3, t4].each(&:join)
+#
+#   # prints:
+#   # Thread 3 acquired semaphore
+#   # Thread 2 acquired semaphore
+#   # Thread 4 releasing semaphore
+#   # Thread 1 acquired semaphore
+# @example
+#   semaphore = Concurrent::Semaphore.new(1)
+#
+#   puts semaphore.available_permits
+#   semaphore.acquire do
+#   puts semaphore.available_permits
+#   end
+#   puts semaphore.available_permits
+#
+#   # prints:
+#   # 1
+#   # 0
+#   # 1
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/semaphore.rb#161
+class Concurrent::Semaphore < ::Concurrent::MutexSemaphore; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/semaphore.rb#96
+Concurrent::SemaphoreImplementation = Concurrent::MutexSemaphore
+
+# Indicates that the including `ExecutorService` guarantees
+# that all operations will occur in the order they are post and that no
+# two operations may occur simultaneously. This module provides no
+# functionality and provides no guarantees. That is the responsibility
+# of the including class. This module exists solely to allow the including
+# object to be interrogated for its serialization status.
+#
+# @example
+#   class Foo
+#   include Concurrent::SerialExecutor
+#   end
+#
+#   foo = Foo.new
+#
+#   foo.is_a? Concurrent::ExecutorService #=> true
+#   foo.is_a? Concurrent::SerialExecutor  #=> true
+#   foo.serialized?                       #=> true
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/serial_executor_service.rb#24
+module Concurrent::SerialExecutorService
+  include ::Logger::Severity
+  include ::Concurrent::Concern::Logging
+  include ::Concurrent::ExecutorService
+
+  # Does this executor guarantee serialization of its operations?
+  #
+  # @note Always returns `true`
+  # @return [Boolean] True if the executor guarantees that all operations
+  #   will be post in the order they are received and no two operations may
+  #   occur simultaneously. Else false.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/serial_executor_service.rb#30
+  def serialized?; end
+end
+
+# Ensures passed jobs in a serialized order never running at the same time.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/serialized_execution.rb#8
+class Concurrent::SerializedExecution < ::Concurrent::Synchronization::LockableObject
+  include ::Logger::Severity
+  include ::Concurrent::Concern::Logging
+
+  # @return [SerializedExecution] a new instance of SerializedExecution
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/serialized_execution.rb#11
+  def initialize; end
+
+  # Submit a task to the executor for asynchronous processing.
+  #
+  # @param executor [Executor] to be used for this job
+  # @param args [Array] zero or more arguments to be passed to the task
+  # @raise [ArgumentError] if no task is given
+  # @return [Boolean] `true` if the task is queued, `false` if the executor
+  #   is not running
+  # @yield the asynchronous task to perform
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/serialized_execution.rb#34
+  def post(executor, *args, &task); end
+
+  # As {#post} but allows to submit multiple tasks at once, it's guaranteed that they will not
+  # be interleaved by other tasks.
+  #
+  # @param posts [Array<Array(ExecutorService, Array<Object>, Proc)>] array of triplets where
+  #   first is a {ExecutorService}, second is array of args for task, third is a task (Proc)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/serialized_execution.rb#44
+  def posts(posts); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/serialized_execution.rb#75
+  def call_job(job); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/serialized_execution.rb#70
+  def ns_initialize; end
+
+  # ensures next job is executed if any is stashed
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/serialized_execution.rb#95
+  def work(job); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/serialized_execution.rb#16
+class Concurrent::SerializedExecution::Job < ::Struct
+  # Returns the value of attribute args
+  #
+  # @return [Object] the current value of args
+  def args; end
+
+  # Sets the attribute args
+  #
+  # @param value [Object] the value to set the attribute args to.
+  # @return [Object] the newly set value
+  def args=(_); end
+
+  # Returns the value of attribute block
+  #
+  # @return [Object] the current value of block
+  def block; end
+
+  # Sets the attribute block
+  #
+  # @param value [Object] the value to set the attribute block to.
+  # @return [Object] the newly set value
+  def block=(_); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/serialized_execution.rb#17
+  def call; end
+
+  # Returns the value of attribute executor
+  #
+  # @return [Object] the current value of executor
+  def executor; end
+
+  # Sets the attribute executor
+  #
+  # @param value [Object] the value to set the attribute executor to.
+  # @return [Object] the newly set value
+  def executor=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# A wrapper/delegator for any `ExecutorService` that
+# guarantees serialized execution of tasks.
+#
+# @see [SimpleDelegator](http://www.ruby-doc.org/stdlib-2.1.2/libdoc/delegate/rdoc/SimpleDelegator.html)
+# @see Concurrent::SerializedExecution
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/serialized_execution_delegator.rb#12
+class Concurrent::SerializedExecutionDelegator < ::SimpleDelegator
+  include ::Logger::Severity
+  include ::Concurrent::Concern::Logging
+  include ::Concurrent::ExecutorService
+  include ::Concurrent::SerialExecutorService
+
+  # @return [SerializedExecutionDelegator] a new instance of SerializedExecutionDelegator
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/serialized_execution_delegator.rb#15
+  def initialize(executor); end
+
+  # Submit a task to the executor for asynchronous processing.
+  #
+  # @param args [Array] zero or more arguments to be passed to the task
+  # @raise [ArgumentError] if no task is given
+  # @return [Boolean] `true` if the task is queued, `false` if the executor
+  #   is not running
+  # @yield the asynchronous task to perform
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/serialized_execution_delegator.rb#22
+  def post(*args, &task); end
+end
+
+# A thread-safe subclass of Set. This version locks against the object
+# itself for every method call, ensuring only one thread can be reading
+# or writing at a time. This includes iteration methods like `#each`.
+#
+# @note `a += b` is **not** a **thread-safe** operation on
+#   `Concurrent::Set`. It reads Set `a`, then it creates new `Concurrent::Set`
+#   which is union of `a` and `b`, then it writes the union to `a`.
+#   The read and write are independent operations they do not form a single atomic
+#   operation therefore when two `+=` operations are executed concurrently updates
+#   may be lost. Use `#merge` instead.
+# @see http://ruby-doc.org/stdlib-2.4.0/libdoc/set/rdoc/Set.html Ruby standard library `Set`
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/set.rb#61
+class Concurrent::Set < ::Concurrent::CRubySet; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/set.rb#23
+Concurrent::SetImplementation = Concurrent::CRubySet
+
+# An thread-safe, write-once variation of Ruby's standard `Struct`.
+# Each member can have its value set at most once, either at construction
+# or any time thereafter. Attempting to assign a value to a member
+# that has already been set will result in a `Concurrent::ImmutabilityError`.
+#
+# @see http://ruby-doc.org/core/Struct.html Ruby standard library `Struct`
+# @see http://en.wikipedia.org/wiki/Final_(Java) Java `final` keyword
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#14
+module Concurrent::SettableStruct
+  include ::Concurrent::Synchronization::AbstractStruct
+
+  # Equality
+  #
+  # @return [Boolean] true if other has the same struct subclass and has
+  #   equal member values (according to `Object#==`)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#50
+  def ==(other); end
+
+  # Attribute Reference
+  #
+  # @param member [Symbol, String, Integer] the string or symbol name of the member
+  #   for which to obtain the value or the member's index
+  # @raise [NameError] if the member does not exist
+  # @raise [IndexError] if the index is out of range.
+  # @return [Object] the value of the given struct member or the member at the given index.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#45
+  def [](member); end
+
+  # Attribute Assignment
+  #
+  # Sets the value of the given struct member or the member at the given index.
+  #
+  # @param member [Symbol, String, Integer] the string or symbol name of the member
+  #   for which to obtain the value or the member's index
+  # @raise [NameError] if the name does not exist
+  # @raise [IndexError] if the index is out of range.
+  # @raise [Concurrent::ImmutabilityError] if the given member has already been set
+  # @return [Object] the value of the given struct member or the member at the given index.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#75
+  def []=(member, value); end
+
+  # Yields the value of each struct member in order. If no block is given
+  # an enumerator is returned.
+  #
+  # @yield the operation to be performed on each struct member
+  # @yieldparam value [Object] each struct value (in order)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#55
+  def each(&block); end
+
+  # Yields the name and value of each struct member in order. If no block is
+  # given an enumerator is returned.
+  #
+  # @yield the operation to be performed on each struct member/value pair
+  # @yieldparam member [Object] each struct member (in order)
+  # @yieldparam value [Object] each struct value (in order)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#61
+  def each_pair(&block); end
+
+  # Describe the contents of this struct in a string.
+  #
+  # @return [String] the contents of this struct in a string
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#29
+  def inspect; end
+
+  # Returns a new struct containing the contents of `other` and the contents
+  # of `self`. If no block is specified, the value for entries with duplicate
+  # keys will be that of `other`. Otherwise the value for each duplicate key
+  # is determined by calling the block with the key, its value in `self` and
+  # its value in `other`.
+  #
+  # @param other [Hash] the hash from which to set the new values
+  # @raise [ArgumentError] of given a member that is not defined in the struct
+  # @return [Synchronization::AbstractStruct] a new struct with the new values
+  # @yield an options block for resolving duplicate keys
+  # @yieldparam member [String, Symbol] the name of the member which is duplicated
+  # @yieldparam selfvalue [Object] the value of the member in `self`
+  # @yieldparam othervalue [Object] the value of the member in `other`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#35
+  def merge(other, &block); end
+
+  # Yields each member value from the struct to the block and returns an Array
+  # containing the member values from the struct for which the given block
+  # returns a true value (equivalent to `Enumerable#select`).
+  #
+  # @return [Array] an array containing each value for which the block returns true
+  # @yield the operation to be performed on each struct member
+  # @yieldparam value [Object] each struct value (in order)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#67
+  def select(&block); end
+
+  # Returns the values for this struct as an Array.
+  #
+  # @return [Array] the values for this struct
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#18
+  def to_a; end
+
+  # Returns a hash containing the names and values for the struct’s members.
+  #
+  # @return [Hash] the names and values for the struct’s members
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#40
+  def to_h; end
+
+  # Describe the contents of this struct in a string.
+  #
+  # @return [String] the contents of this struct in a string
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#29
+  def to_s; end
+
+  # Returns the values for this struct as an Array.
+  #
+  # @return [Array] the values for this struct
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#18
+  def values; end
+
+  # Returns the struct member values for each selector as an Array.
+  #
+  # A selector may be either an Integer offset or a Range of offsets (as in `Array#values_at`).
+  #
+  # @param indexes [Fixnum, Range] the index(es) from which to obatin the values (in order)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#24
+  def values_at(*indexes); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#97
+  def initialize_copy(original); end
+
+  class << self
+    # Factory for creating new struct classes.
+    #
+    # ```
+    # new([class_name] [, member_name]+>) -> StructClass click to toggle source
+    # new([class_name] [, member_name]+>) {|StructClass| block } -> StructClass
+    # new(value, ...) -> obj
+    # StructClass[value, ...] -> obj
+    # ```
+    #
+    # The first two forms are used to create a new struct subclass `class_name`
+    # that can contain a value for each   member_name . This subclass can be
+    # used to create instances of the structure like any other  Class .
+    #
+    # If the `class_name` is omitted an anonymous struct class will be created.
+    # Otherwise, the name of this struct will appear as a constant in the struct class,
+    # so it must be unique for all structs under this base class and must start with a
+    # capital letter. Assigning a struct class to a constant also gives the class
+    # the name of the constant.
+    #
+    # If a block is given it will be evaluated in the context of `StructClass`, passing
+    # the created class as a parameter. This is the recommended way to customize a struct.
+    # Subclassing an anonymous struct creates an extra anonymous class that will never be used.
+    #
+    # The last two forms create a new instance of a struct subclass. The number of value
+    # parameters must be less than or equal to the number of attributes defined for the
+    # struct. Unset parameters default to nil. Passing more parameters than number of attributes
+    # will raise an `ArgumentError`.
+    #
+    # @see http://ruby-doc.org/core/Struct.html#method-c-new Ruby standard library `Struct#new`
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#105
+    def new(*args, &block); end
+  end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/settable_struct.rb#115
+Concurrent::SettableStruct::FACTORY = T.let(T.unsafe(nil), T.untyped)
+
+# An executor service in which every operation spawns a new,
+# independently operating thread.
+#
+# This is perhaps the most inefficient executor service in this
+# library. It exists mainly for testing an debugging. Thread creation
+# and management is expensive in Ruby and this executor performs no
+# resource pooling. This can be very beneficial during testing and
+# debugging because it decouples the using code from the underlying
+# executor implementation. In production this executor will likely
+# lead to suboptimal performance.
+#
+# @note Intended for use primarily in testing and debugging.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb#21
+class Concurrent::SimpleExecutorService < ::Concurrent::RubyExecutorService
+  # Submit a task to the executor for asynchronous processing.
+  #
+  # @param task [Proc] the asynchronous task to perform
+  # @return [self] returns itself
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb#56
+  def <<(task); end
+
+  # Begin an immediate shutdown. In-progress tasks will be allowed to
+  # complete but enqueued tasks will be dismissed and no new tasks
+  # will be accepted. Has no additional effect if the thread pool is
+  # not running.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb#84
+  def kill; end
+
+  # Submit a task to the executor for asynchronous processing.
+  #
+  # @param args [Array] zero or more arguments to be passed to the task
+  # @raise [ArgumentError] if no task is given
+  # @return [Boolean] `true` if the task is queued, `false` if the executor
+  #   is not running
+  # @yield the asynchronous task to perform
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb#40
+  def post(*args, &task); end
+
+  # Is the executor running?
+  #
+  # @return [Boolean] `true` when running, `false` when shutting down or shutdown
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb#62
+  def running?; end
+
+  # Begin an orderly shutdown. Tasks already in the queue will be executed,
+  # but no new tasks will be accepted. Has no additional effect if the
+  # thread pool is not running.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb#77
+  def shutdown; end
+
+  # Is the executor shutdown?
+  #
+  # @return [Boolean] `true` when shutdown, `false` when shutting down or running
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb#72
+  def shutdown?; end
+
+  # Is the executor shuttingdown?
+  #
+  # @return [Boolean] `true` when not running and not shutdown, else `false`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb#67
+  def shuttingdown?; end
+
+  # Block until executor shutdown is complete or until `timeout` seconds have
+  # passed.
+  #
+  # @note Does not initiate shutdown or termination. Either `shutdown` or `kill`
+  #   must be called before this method (or on another thread).
+  # @param timeout [Integer] the maximum number of seconds to wait for shutdown to complete
+  # @return [Boolean] `true` if shutdown complete or false on `timeout`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb#91
+  def wait_for_termination(timeout = T.unsafe(nil)); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb#97
+  def ns_initialize(*args); end
+
+  class << self
+    # Submit a task to the executor for asynchronous processing.
+    #
+    # @param task [Proc] the asynchronous task to perform
+    # @return [self] returns itself
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb#34
+    def <<(task); end
+
+    # Submit a task to the executor for asynchronous processing.
+    #
+    # @param args [Array] zero or more arguments to be passed to the task
+    # @raise [ArgumentError] if no task is given
+    # @return [Boolean] `true` if the task is queued, `false` if the executor
+    #   is not running
+    # @yield the asynchronous task to perform
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb#24
+    def post(*args); end
+  end
+end
+
+# A thread pool with a single thread an unlimited queue. Should the thread
+# die for any reason it will be removed and replaced, thus ensuring that
+# the executor will always remain viable and available to process jobs.
+#
+# A common pattern for background processing is to create a single thread
+# on which an infinite loop is run. The thread's loop blocks on an input
+# source (perhaps blocking I/O or a queue) and processes each input as it
+# is received. This pattern has several issues. The thread itself is highly
+# susceptible to errors during processing. Also, the thread itself must be
+# constantly monitored and restarted should it die. `SingleThreadExecutor`
+# encapsulates all these bahaviors. The task processor is highly resilient
+# to errors from within tasks. Also, should the thread die it will
+# automatically be restarted.
+#
+# The API and behavior of this class are based on Java's `SingleThreadExecutor`.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/single_thread_executor.rb#37
+class Concurrent::SingleThreadExecutor < ::Concurrent::RubySingleThreadExecutor; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/single_thread_executor.rb#10
+Concurrent::SingleThreadExecutorImplementation = Concurrent::RubySingleThreadExecutor
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_object.rb#2
+module Concurrent::Synchronization
+  class << self
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/full_memory_barrier.rb#7
+    def full_memory_barrier; end
+  end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_lockable_object.rb#9
+class Concurrent::Synchronization::AbstractLockableObject < ::Concurrent::Synchronization::Object
+  protected
+
+  # Broadcast to all waiting threads.
+  #
+  # @note only to be used inside synchronized block
+  # @note to provide direct access to this method in a descendant add method
+  #   ```
+  #   def broadcast
+  #   synchronize { ns_broadcast }
+  #   end
+  #   ```
+  # @raise [NotImplementedError]
+  # @return [self]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_lockable_object.rb#96
+  def ns_broadcast; end
+
+  # Signal one waiting thread.
+  #
+  # @note only to be used inside synchronized block
+  # @note to provide direct access to this method in a descendant add method
+  #   ```
+  #   def signal
+  #   synchronize { ns_signal }
+  #   end
+  #   ```
+  # @raise [NotImplementedError]
+  # @return [self]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_lockable_object.rb#81
+  def ns_signal; end
+
+  # Wait until another thread calls #signal or #broadcast,
+  # spurious wake-ups can happen.
+  #
+  # @note only to be used inside synchronized block
+  # @note to provide direct access to this method in a descendant add method
+  #   ```
+  #   def wait(timeout = nil)
+  #   synchronize { ns_wait(timeout) }
+  #   end
+  #   ```
+  # @param timeout [Numeric, nil] in seconds, `nil` means no timeout
+  # @raise [NotImplementedError]
+  # @return [self]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_lockable_object.rb#66
+  def ns_wait(timeout = T.unsafe(nil)); end
+
+  # Wait until condition is met or timeout passes,
+  # protects against spurious wake-ups.
+  #
+  # @note only to be used inside synchronized block
+  # @note to provide direct access to this method in a descendant add method
+  #   ```
+  #   def wait_until(timeout = nil, &condition)
+  #   synchronize { ns_wait_until(timeout, &condition) }
+  #   end
+  #   ```
+  # @param timeout [Numeric, nil] in seconds, `nil` means no timeout
+  # @return [true, false] if condition met
+  # @yield condition to be met
+  # @yieldreturn [true, false]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_lockable_object.rb#37
+  def ns_wait_until(timeout = T.unsafe(nil), &condition); end
+
+  # @note can by made public in descendants if required by `public :synchronize`
+  # @raise [NotImplementedError]
+  # @yield runs the block synchronized against this object,
+  #   equivalent of java's `synchronize(this) {}`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_lockable_object.rb#18
+  def synchronize; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_object.rb#6
+class Concurrent::Synchronization::AbstractObject
+  # @return [AbstractObject] a new instance of AbstractObject
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_object.rb#7
+  def initialize; end
+
+  # @abstract
+  # @raise [NotImplementedError]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_object.rb#13
+  def full_memory_barrier; end
+
+  class << self
+    # @raise [NotImplementedError]
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_object.rb#17
+    def attr_volatile(*names); end
+  end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#6
+module Concurrent::Synchronization::AbstractStruct
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#9
+  def initialize(*values); end
+
+  # Returns the number of struct members.
+  #
+  # @return [Fixnum] the number of struct members
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#19
+  def length; end
+
+  # Returns the struct members as an array of symbols.
+  #
+  # @return [Array] the struct members as an array of symbols
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#29
+  def members; end
+
+  # Returns the number of struct members.
+  #
+  # @return [Fixnum] the number of struct members
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#19
+  def size; end
+
+  protected
+
+  # Yields the value of each struct member in order. If no block is given
+  # an enumerator is returned.
+  #
+  # @yield the operation to be performed on each struct member
+  # @yieldparam value [Object] each struct value (in order)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#82
+  def ns_each; end
+
+  # Yields the name and value of each struct member in order. If no block is
+  # given an enumerator is returned.
+  #
+  # @yield the operation to be performed on each struct member/value pair
+  # @yieldparam member [Object] each struct member (in order)
+  # @yieldparam value [Object] each struct value (in order)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#89
+  def ns_each_pair; end
+
+  # Equality
+  #
+  # @return [Boolean] true if other has the same struct subclass and has
+  #   equal member values (according to `Object#==`)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#75
+  def ns_equality(other); end
+
+  # Attribute Reference
+  #
+  # @param member [Symbol, String, Integer] the string or symbol name of the member
+  #   for which to obtain the value or the member's index
+  # @raise [NameError] if the member does not exist
+  # @raise [IndexError] if the index is out of range.
+  # @return [Object] the value of the given struct member or the member at the given index.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#59
+  def ns_get(member); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#119
+  def ns_initialize_copy; end
+
+  # Describe the contents of this struct in a string.
+  #
+  # @return [String] the contents of this struct in a string
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#105
+  def ns_inspect; end
+
+  # Returns a new struct containing the contents of `other` and the contents
+  # of `self`. If no block is specified, the value for entries with duplicate
+  # keys will be that of `other`. Otherwise the value for each duplicate key
+  # is determined by calling the block with the key, its value in `self` and
+  # its value in `other`.
+  #
+  # @param other [Hash] the hash from which to set the new values
+  # @raise [ArgumentError] of given a member that is not defined in the struct
+  # @return [Synchronization::AbstractStruct] a new struct with the new values
+  # @yield an options block for resolving duplicate keys
+  # @yieldparam member [String, Symbol] the name of the member which is duplicated
+  # @yieldparam selfvalue [Object] the value of the member in `self`
+  # @yieldparam othervalue [Object] the value of the member in `other`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#114
+  def ns_merge(other, &block); end
+
+  # Yields each member value from the struct to the block and returns an Array
+  # containing the member values from the struct for which the given block
+  # returns a true value (equivalent to `Enumerable#select`).
+  #
+  # @return [Array] an array containing each value for which the block returns true
+  # @yield the operation to be performed on each struct member
+  # @yieldparam value [Object] each struct value (in order)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#98
+  def ns_select; end
+
+  # Returns a hash containing the names and values for the struct’s members.
+  #
+  # @return [Hash] the names and values for the struct’s members
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#52
+  def ns_to_h; end
+
+  # Returns the values for this struct as an Array.
+  #
+  # @return [Array] the values for this struct
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#38
+  def ns_values; end
+
+  # Returns the struct member values for each selector as an Array.
+  #
+  # A selector may be either an Integer offset or a Range of offsets (as in `Array#values_at`).
+  #
+  # @param indexes [Fixnum, Range] the index(es) from which to obatin the values (in order)
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#45
+  def ns_values_at(indexes); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#130
+  def pr_underscore(clazz); end
+
+  class << self
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb#141
+    def define_struct_class(parent, base, name, members, &block); end
+  end
+end
+
+# TODO (pitr-ch 04-Dec-2016): should be in edge
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/condition.rb#8
+class Concurrent::Synchronization::Condition < ::Concurrent::Synchronization::LockableObject
+  # @return [Condition] a new instance of Condition
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/condition.rb#18
+  def initialize(lock); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/condition.rb#47
+  def broadcast; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/condition.rb#51
+  def ns_broadcast; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/condition.rb#43
+  def ns_signal; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/condition.rb#27
+  def ns_wait(timeout = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/condition.rb#35
+  def ns_wait_until(timeout = T.unsafe(nil), &condition); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/condition.rb#39
+  def signal; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/condition.rb#23
+  def wait(timeout = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/condition.rb#31
+  def wait_until(timeout = T.unsafe(nil), &condition); end
+
+  class << self
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/safe_initialization.rb#29
+    def private_new(*args, &block); end
+
+    private
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/safe_initialization.rb#29
+    def new(*args, &block); end
+  end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#8
+module Concurrent::Synchronization::ConditionSignalling
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#16
+  def ns_broadcast; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#11
+  def ns_signal; end
+end
+
+# TODO (pitr-ch 04-Dec-2016): should be in edge
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/lock.rb#8
+class Concurrent::Synchronization::Lock < ::Concurrent::Synchronization::LockableObject
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/lock.rb#31
+  def broadcast; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#16
+  def ns_broadcast; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#11
+  def ns_signal; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#52
+  def ns_wait(timeout = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/abstract_lockable_object.rb#37
+  def ns_wait_until(timeout = T.unsafe(nil), &condition); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/lock.rb#25
+  def signal; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#44
+  def synchronize; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/lock.rb#13
+  def wait(timeout = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/lock.rb#19
+  def wait_until(timeout = T.unsafe(nil), &condition); end
+end
+
+# Safe synchronization under any Ruby implementation.
+#   It provides methods like {#synchronize}, {#wait}, {#signal} and {#broadcast}.
+#   Provides a single layer which can improve its implementation over time without changes needed to
+#   the classes using it. Use {Synchronization::Object} not this abstract class.
+#
+#   @note this object does not support usage together with
+#     [`Thread#wakeup`](http://ruby-doc.org/core/Thread.html#method-i-wakeup)
+#     and [`Thread#raise`](http://ruby-doc.org/core/Thread.html#method-i-raise).
+#     `Thread#sleep` and `Thread#wakeup` will work as expected but mixing `Synchronization::Object#wait` and
+#     `Thread#wakeup` will not work on all platforms.
+#
+#   @see Event implementation as an example of this class use
+#
+#   @example simple
+#     class AnClass < Synchronization::Object
+#       def initialize
+#         super
+#         synchronize { @value = 'asd' }
+#       end
+#
+#       def value
+#         synchronize { @value }
+#       end
+#     end
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/lockable_object.rb#50
+class Concurrent::Synchronization::LockableObject < ::Concurrent::Synchronization::MutexLockableObject
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/condition.rb#57
+  def new_condition; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/lockable_object.rb#11
+Concurrent::Synchronization::LockableObjectImplementation = Concurrent::Synchronization::MutexLockableObject
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#60
+class Concurrent::Synchronization::MonitorLockableObject < ::Concurrent::Synchronization::AbstractLockableObject
+  include ::Concurrent::Synchronization::ConditionSignalling
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # @return [MonitorLockableObject] a new instance of MonitorLockableObject
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#65
+  def initialize; end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#83
+  def ns_wait(timeout = T.unsafe(nil)); end
+
+  # TODO may be a problem with lock.synchronize { lock.wait }
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#79
+  def synchronize; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#71
+  def initialize_copy(other); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#25
+class Concurrent::Synchronization::MutexLockableObject < ::Concurrent::Synchronization::AbstractLockableObject
+  include ::Concurrent::Synchronization::ConditionSignalling
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # @return [MutexLockableObject] a new instance of MutexLockableObject
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#30
+  def initialize; end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#52
+  def ns_wait(timeout = T.unsafe(nil)); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#44
+  def synchronize; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb#36
+  def initialize_copy(other); end
+end
+
+# Abstract object providing final, volatile, ans CAS extensions to build other concurrent abstractions.
+# - final instance variables see {Object.safe_initialization!}
+# - volatile instance variables see {Object.attr_volatile}
+# - volatile instance variables see {Object.attr_atomic}
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#15
+class Concurrent::Synchronization::Object < ::Concurrent::Synchronization::AbstractObject
+  include ::Concurrent::Synchronization::Volatile
+  extend ::Concurrent::Synchronization::Volatile::ClassMethods
+
+  # Has to be called by children.
+  #
+  # @return [Object] a new instance of Object
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#28
+  def initialize; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#146
+  def __initialize_atomic_fields__; end
+
+  class << self
+    # @return [true, false] is the attribute with name atomic?
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#125
+    def atomic_attribute?(name); end
+
+    # @param inherited [true, false] should inherited volatile with CAS fields be returned?
+    # @return [::Array<Symbol>] Returns defined volatile with CAS fields on this class.
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#119
+    def atomic_attributes(inherited = T.unsafe(nil)); end
+
+    # Creates methods for reading and writing to a instance variable with
+    # volatile (Java) semantic as {.attr_volatile} does.
+    # The instance variable should be accessed oly through generated methods.
+    # This method generates following methods: `value`, `value=(new_value) #=> new_value`,
+    # `swap_value(new_value) #=> old_value`,
+    # `compare_and_set_value(expected, value) #=> true || false`, `update_value(&block)`.
+    #
+    # @param names [::Array<Symbol>] of the instance variables to be volatile with CAS.
+    # @return [::Array<Symbol>] names of defined method names.
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#84
+    def attr_atomic(*names); end
+
+    # For testing purposes, quite slow. Injects assert code to new method which will raise if class instance contains
+    # any instance variables with CamelCase names and isn't {.safe_initialization?}.
+    #
+    # @raise when offend found
+    # @return [true]
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#45
+    def ensure_safe_initialization_when_final_fields_are_present; end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#33
+    def safe_initialization!; end
+
+    # @return [Boolean]
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#37
+    def safe_initialization?; end
+
+    private
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#131
+    def define_initialize_atomic_fields; end
+  end
+end
+
+# By extending this module, a class and all its children are marked to be constructed safely. Meaning that
+# all writes (ivar initializations) are made visible to all readers of newly constructed object. It ensures
+# same behaviour as Java's final fields.
+#
+# Due to using Kernel#extend, the module is not included again if already present in the ancestors,
+# which avoids extra overhead.
+#
+# @example
+#   class AClass < Concurrent::Synchronization::Object
+#   extend Concurrent::Synchronization::SafeInitialization
+#
+#   def initialize
+#   @AFinalValue = 'value' # published safely, #foo will never return nil
+#   end
+#
+#   def foo
+#   @AFinalValue
+#   end
+#   end
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/safe_initialization.rb#28
+module Concurrent::Synchronization::SafeInitialization
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/safe_initialization.rb#29
+  def new(*args, &block); end
+end
+
+# Volatile adds the attr_volatile class method when included.
+#
+#  foo = Foo.new
+#  foo.bar
+#  => 1
+#  foo.bar = 2
+#  => 2
+#
+# @example
+#   class Foo
+#   include Concurrent::Synchronization::Volatile
+#
+#   attr_volatile :bar
+#
+#   def initialize
+#   self.bar = 1
+#   end
+#   end
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/volatile.rb#28
+module Concurrent::Synchronization::Volatile
+  mixes_in_class_methods ::Concurrent::Synchronization::Volatile::ClassMethods
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/volatile.rb#33
+  def full_memory_barrier; end
+
+  class << self
+    # @private
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/volatile.rb#29
+    def included(base); end
+  end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/volatile.rb#37
+module Concurrent::Synchronization::Volatile::ClassMethods
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/volatile.rb#39
+  def attr_volatile(*names); end
+end
+
+# This class provides a trivial way to synchronize all calls to a given object
+# by wrapping it with a `Delegator` that performs `Monitor#enter/exit` calls
+# around the delegated `#send`. Example:
+#
+#   array = [] # not thread-safe on many impls
+#   array = SynchronizedDelegator.new([]) # thread-safe
+#
+# A simple `Monitor` provides a very coarse-grained way to synchronize a given
+# object, in that it will cause synchronization for methods that have no need
+# for it, but this is a trivial way to get thread-safety where none may exist
+# currently on some implementations.
+#
+# This class is currently being considered for inclusion into stdlib, via
+# https://bugs.ruby-lang.org/issues/8556
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb#21
+class Concurrent::SynchronizedDelegator < ::SimpleDelegator
+  # @return [SynchronizedDelegator] a new instance of SynchronizedDelegator
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb#31
+  def initialize(obj); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb#36
+  def method_missing(method, *args, &block); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb#22
+  def setup; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb#27
+  def teardown; end
+end
+
+# A `TVar` is a transactional variable - a single-element container that
+# is used as part of a transaction - see `Concurrent::atomically`.
+#
+#
+# ## Thread-safe Variable Classes
+#
+# Each of the thread-safe variable classes is designed to solve a different
+# problem. In general:
+#
+# * *{Concurrent::Agent}:* Shared, mutable variable providing independent,
+#   uncoordinated, *asynchronous* change of individual values. Best used when
+#   the value will undergo frequent, complex updates. Suitable when the result
+#   of an update does not need to be known immediately.
+# * *{Concurrent::Atom}:* Shared, mutable variable providing independent,
+#   uncoordinated, *synchronous* change of individual values. Best used when
+#   the value will undergo frequent reads but only occasional, though complex,
+#   updates. Suitable when the result of an update must be known immediately.
+# * *{Concurrent::AtomicReference}:* A simple object reference that can be updated
+#   atomically. Updates are synchronous but fast. Best used when updates a
+#   simple set operations. Not suitable when updates are complex.
+#   {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar
+#   but optimized for the given data type.
+# * *{Concurrent::Exchanger}:* Shared, stateless synchronization point. Used
+#   when two or more threads need to exchange data. The threads will pair then
+#   block on each other until the exchange is complete.
+# * *{Concurrent::MVar}:* Shared synchronization point. Used when one thread
+#   must give a value to another, which must take the value. The threads will
+#   block on each other until the exchange is complete.
+# * *{Concurrent::ThreadLocalVar}:* Shared, mutable, isolated variable which
+#   holds a different value for each thread which has access. Often used as
+#   an instance variable in objects which must maintain different state
+#   for different threads.
+# * *{Concurrent::TVar}:* Shared, mutable variables which provide
+#   *coordinated*, *synchronous*, change of *many* stated. Used when multiple
+#   value must change together, in an all-or-nothing transaction.
+# {include:file:docs-source/tvar.md}
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#12
+class Concurrent::TVar < ::Concurrent::Synchronization::Object
+  extend ::Concurrent::Synchronization::SafeInitialization
+
+  # Create a new `TVar` with an initial value.
+  #
+  # @return [TVar] a new instance of TVar
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#16
+  def initialize(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#46
+  def unsafe_lock; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#36
+  def unsafe_value; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#41
+  def unsafe_value=(value); end
+
+  # Get the value of a `TVar`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#22
+  def value; end
+
+  # Set the value of a `TVar`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#29
+  def value=(value); end
+end
+
+# A `ThreadLocalVar` is a variable where the value is different for each thread.
+# Each variable may have a default value, but when you modify the variable only
+# the current thread will ever see that change.
+#
+# This is similar to Ruby's built-in thread-local variables (`Thread#thread_variable_get`),
+# but with these major advantages:
+# * `ThreadLocalVar` has its own identity, it doesn't need a Symbol.
+# * Each Ruby's built-in thread-local variable leaks some memory forever (it's a Symbol held forever on the thread),
+#   so it's only OK to create a small amount of them.
+#   `ThreadLocalVar` has no such issue and it is fine to create many of them.
+# * Ruby's built-in thread-local variables leak forever the value set on each thread (unless set to nil explicitly).
+#   `ThreadLocalVar` automatically removes the mapping for each thread once the `ThreadLocalVar` instance is GC'd.
+#
+#
+# ## Thread-safe Variable Classes
+#
+# Each of the thread-safe variable classes is designed to solve a different
+# problem. In general:
+#
+# * *{Concurrent::Agent}:* Shared, mutable variable providing independent,
+#   uncoordinated, *asynchronous* change of individual values. Best used when
+#   the value will undergo frequent, complex updates. Suitable when the result
+#   of an update does not need to be known immediately.
+# * *{Concurrent::Atom}:* Shared, mutable variable providing independent,
+#   uncoordinated, *synchronous* change of individual values. Best used when
+#   the value will undergo frequent reads but only occasional, though complex,
+#   updates. Suitable when the result of an update must be known immediately.
+# * *{Concurrent::AtomicReference}:* A simple object reference that can be updated
+#   atomically. Updates are synchronous but fast. Best used when updates a
+#   simple set operations. Not suitable when updates are complex.
+#   {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar
+#   but optimized for the given data type.
+# * *{Concurrent::Exchanger}:* Shared, stateless synchronization point. Used
+#   when two or more threads need to exchange data. The threads will pair then
+#   block on each other until the exchange is complete.
+# * *{Concurrent::MVar}:* Shared synchronization point. Used when one thread
+#   must give a value to another, which must take the value. The threads will
+#   block on each other until the exchange is complete.
+# * *{Concurrent::ThreadLocalVar}:* Shared, mutable, isolated variable which
+#   holds a different value for each thread which has access. Often used as
+#   an instance variable in objects which must maintain different state
+#   for different threads.
+# * *{Concurrent::TVar}:* Shared, mutable variables which provide
+#   *coordinated*, *synchronous*, change of *many* stated. Used when multiple
+#   value must change together, in an all-or-nothing transaction.
+#
+# @example
+#   v = ThreadLocalVar.new(14)
+#   v.value #=> 14
+#   v.value = 2
+#   v.value #=> 2
+# @example
+#   v = ThreadLocalVar.new(14)
+#
+#   t1 = Thread.new do
+#   v.value #=> 14
+#   v.value = 1
+#   v.value #=> 1
+#   end
+#
+#   t2 = Thread.new do
+#   v.value #=> 14
+#   v.value = 2
+#   v.value #=> 2
+#   end
+#
+#   v.value #=> 14
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb#43
+class Concurrent::ThreadLocalVar
+  # Creates a thread local variable.
+  #
+  # @param default [Object] the default value when otherwise unset
+  # @param default_block [Proc] Optional block that gets called to obtain the
+  #   default value for each thread
+  # @return [ThreadLocalVar] a new instance of ThreadLocalVar
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb#51
+  def initialize(default = T.unsafe(nil), &default_block); end
+
+  # Bind the given value to thread local storage during
+  # execution of the given block.
+  #
+  # @param value [Object] the value to bind
+  # @return [Object] the value
+  # @yield the operation to be performed with the bound variable
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb#88
+  def bind(value); end
+
+  # Returns the value in the current thread's copy of this thread-local variable.
+  #
+  # @return [Object] the current value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb#70
+  def value; end
+
+  # Sets the current thread's copy of this thread-local variable to the specified value.
+  #
+  # @param value [Object] the value to set
+  # @return [Object] the new value
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb#78
+  def value=(value); end
+
+  protected
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb#103
+  def default; end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb#44
+Concurrent::ThreadLocalVar::LOCALS = T.let(T.unsafe(nil), Concurrent::ThreadLocals)
+
+# An array-backed storage of indexed variables per thread.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#141
+class Concurrent::ThreadLocals < ::Concurrent::AbstractLocals
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#142
+  def locals; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#146
+  def locals!; end
+end
+
+# An abstraction composed of one or more threads and a task queue. Tasks
+# (blocks or `proc` objects) are submitted to the pool and added to the queue.
+# The threads in the pool remove the tasks and execute them in the order
+# they were received.
+#
+# A `ThreadPoolExecutor` will automatically adjust the pool size according
+# to the bounds set by `min-threads` and `max-threads`. When a new task is
+# submitted and fewer than `min-threads` threads are running, a new thread
+# is created to handle the request, even if other worker threads are idle.
+# If there are more than `min-threads` but less than `max-threads` threads
+# running, a new thread will be created only if the queue is full.
+#
+# Threads that are idle for too long will be garbage collected, down to the
+# configured minimum options. Should a thread crash it, too, will be garbage collected.
+#
+# `ThreadPoolExecutor` is based on the Java class of the same name. From
+# the official Java documentation;
+#
+# > Thread pools address two different problems: they usually provide
+# > improved performance when executing large numbers of asynchronous tasks,
+# > due to reduced per-task invocation overhead, and they provide a means
+# > of bounding and managing the resources, including threads, consumed
+# > when executing a collection of tasks. Each ThreadPoolExecutor also
+# > maintains some basic statistics, such as the number of completed tasks.
+# >
+# > To be useful across a wide range of contexts, this class provides many
+# > adjustable parameters and extensibility hooks. However, programmers are
+# > urged to use the more convenient Executors factory methods
+# > [CachedThreadPool] (unbounded thread pool, with automatic thread reclamation),
+# > [FixedThreadPool] (fixed size thread pool) and [SingleThreadExecutor] (single
+# > background thread), that preconfigure settings for the most common usage
+# > scenarios.
+#
+# **Thread Pool Options**
+#
+# Thread pools support several configuration options:
+#
+# * `idletime`: The number of seconds that a thread may be idle before being reclaimed.
+# * `name`: The name of the executor (optional). Printed in the executor's `#to_s` output and
+#   a `<name>-worker-<id>` name is given to its threads if supported by used Ruby
+#   implementation. `<id>` is uniq for each thread.
+# * `max_queue`: The maximum number of tasks that may be waiting in the work queue at
+#   any one time. When the queue size reaches `max_queue` and no new threads can be created,
+#   subsequent tasks will be rejected in accordance with the configured `fallback_policy`.
+# * `auto_terminate`: When true (default), the threads started will be marked as daemon.
+# * `fallback_policy`: The policy defining how rejected tasks are handled.
+#
+# Three fallback policies are supported:
+#
+# * `:abort`: Raise a `RejectedExecutionError` exception and discard the task.
+# * `:discard`: Discard the task and return false.
+# * `:caller_runs`: Execute the task on the calling thread.
+#
+# **Shutting Down Thread Pools**
+#
+# Killing a thread pool while tasks are still being processed, either by calling
+# the `#kill` method or at application exit, will have unpredictable results. There
+# is no way for the thread pool to know what resources are being used by the
+# in-progress tasks. When those tasks are killed the impact on those resources
+# cannot be predicted. The *best* practice is to explicitly shutdown all thread
+# pools using the provided methods:
+#
+# * Call `#shutdown` to initiate an orderly termination of all in-progress tasks
+# * Call `#wait_for_termination` with an appropriate timeout interval an allow
+#   the orderly shutdown to complete
+# * Call `#kill` *only when* the thread pool fails to shutdown in the allotted time
+#
+# On some runtime platforms (most notably the JVM) the application will not
+# exit until all thread pools have been shutdown. To prevent applications from
+# "hanging" on exit, all threads can be marked as daemon according to the
+# `:auto_terminate` option.
+#
+# ```ruby
+# pool1 = Concurrent::FixedThreadPool.new(5) # threads will be marked as daemon
+# pool2 = Concurrent::FixedThreadPool.new(5, auto_terminate: false) # mark threads as non-daemon
+# ```
+#
+# @note Failure to properly shutdown a thread pool can lead to unpredictable results.
+#   Please read *Shutting Down Thread Pools* for more information.
+# @see http://docs.oracle.com/javase/tutorial/essential/concurrency/pools.html Java Tutorials: Thread Pools
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executors.html Java Executors class
+# @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html Java ExecutorService interface
+# @see https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html#setDaemon-boolean-
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/thread_pool_executor.rb#56
+class Concurrent::ThreadPoolExecutor < ::Concurrent::RubyThreadPoolExecutor; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/thread_pool_executor.rb#10
+Concurrent::ThreadPoolExecutorImplementation = Concurrent::RubyThreadPoolExecutor
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util.rb#4
+module Concurrent::ThreadSafe; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util.rb#7
+module Concurrent::ThreadSafe::Util
+  class << self
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#16
+    def make_synchronized_on_cruby(klass); end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb#41
+    def make_synchronized_on_truffleruby(klass); end
+  end
+end
+
+# TODO (pitr-ch 15-Oct-2016): migrate to Utility::ProcessorCounter
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util.rb#13
+Concurrent::ThreadSafe::Util::CPU_COUNT = T.let(T.unsafe(nil), Integer)
+
+# TODO (pitr-ch 15-Oct-2016): migrate to Utility::NativeInteger
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util.rb#10
+Concurrent::ThreadSafe::Util::FIXNUM_BIT_SIZE = T.let(T.unsafe(nil), Integer)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/thread_safe/util.rb#11
+Concurrent::ThreadSafe::Util::MAX_INT = T.let(T.unsafe(nil), Integer)
+
+# Raised when an operation times out.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/errors.rb#55
+class Concurrent::TimeoutError < ::Concurrent::Error; end
+
+# Executes a collection of tasks, each after a given delay. A master task
+# monitors the set and schedules each task for execution at the appropriate
+# time. Tasks are run on the global thread pool or on the supplied executor.
+# Each task is represented as a `ScheduledTask`.
+#
+# @see Concurrent::ScheduledTask
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/timer_set.rb#19
+class Concurrent::TimerSet < ::Concurrent::RubyExecutorService
+  # Create a new set of timed tasks.
+  #
+  # @option opts
+  # @param opts [Hash] the options used to specify the executor on which to perform actions
+  # @return [TimerSet] a new instance of TimerSet
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/timer_set.rb#30
+  def initialize(opts = T.unsafe(nil)); end
+
+  # Begin an immediate shutdown. In-progress tasks will be allowed to
+  # complete but enqueued tasks will be dismissed and no new tasks
+  # will be accepted. Has no additional effect if the thread pool is
+  # not running.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/timer_set.rb#62
+  def kill; end
+
+  # Post a task to be execute run after a given delay (in seconds). If the
+  # delay is less than 1/100th of a second the task will be immediately post
+  # to the executor.
+  #
+  # @param delay [Float] the number of seconds to wait for before executing the task.
+  # @param args [Array<Object>] the arguments passed to the task on execution.
+  # @raise [ArgumentError] if the intended execution time is not in the future.
+  # @raise [ArgumentError] if no block is given.
+  # @return [Concurrent::ScheduledTask, false] IVar representing the task if the post
+  #   is successful; false after shutdown.
+  # @yield the task to be performed.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/timer_set.rb#48
+  def post(delay, *args, &task); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/executor_service.rb#166
+  def <<(task); end
+
+  # Initialize the object.
+  #
+  # @param opts [Hash] the options to create the object with.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/timer_set.rb#74
+  def ns_initialize(opts); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/timer_set.rb#94
+  def ns_post_task(task); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/timer_set.rb#129
+  def ns_reset_if_forked; end
+
+  # `ExecutorService` callback called during shutdown.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/timer_set.rb#122
+  def ns_shutdown_execution; end
+
+  # Post the task to the internal queue.
+  #
+  # @note This is intended as a callback method from ScheduledTask
+  #   only. It is not intended to be used directly. Post a task
+  #   by using the `SchedulesTask#execute` method.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/timer_set.rb#89
+  def post_task(task); end
+
+  # Run a loop and execute tasks in the scheduled order and at the approximate
+  # scheduled time. If no tasks remain the thread will exit gracefully so that
+  # garbage collection can occur. If there are no ready tasks it will sleep
+  # for up to 60 seconds waiting for the next scheduled task.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/timer_set.rb#143
+  def process_tasks; end
+
+  # Remove the given task from the queue.
+  #
+  # @note This is intended as a callback method from `ScheduledTask`
+  #   only. It is not intended to be used directly. Cancel a task
+  #   by using the `ScheduledTask#cancel` method.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/timer_set.rb#115
+  def remove_task(task); end
+end
+
+# A very common concurrency pattern is to run a thread that performs a task at
+# regular intervals. The thread that performs the task sleeps for the given
+# interval then wakes up and performs the task. Lather, rinse, repeat... This
+# pattern causes two problems. First, it is difficult to test the business
+# logic of the task because the task itself is tightly coupled with the
+# concurrency logic. Second, an exception raised while performing the task can
+# cause the entire thread to abend. In a long-running application where the
+# task thread is intended to run for days/weeks/years a crashed task thread
+# can pose a significant problem. `TimerTask` alleviates both problems.
+#
+# When a `TimerTask` is launched it starts a thread for monitoring the
+# execution interval. The `TimerTask` thread does not perform the task,
+# however. Instead, the TimerTask launches the task on a separate thread.
+# Should the task experience an unrecoverable crash only the task thread will
+# crash. This makes the `TimerTask` very fault tolerant. Additionally, the
+# `TimerTask` thread can respond to the success or failure of the task,
+# performing logging or ancillary operations.
+#
+# One other advantage of `TimerTask` is that it forces the business logic to
+# be completely decoupled from the concurrency logic. The business logic can
+# be tested separately then passed to the `TimerTask` for scheduling and
+# running.
+#
+# A `TimerTask` supports two different types of interval calculations.
+# A fixed delay will always wait the same amount of time between the
+# completion of one task and the start of the next. A fixed rate will
+# attempt to maintain a constant rate of execution regardless of the
+# duration of the task. For example, if a fixed rate task is scheduled
+# to run every 60 seconds but the task itself takes 10 seconds to
+# complete, the next task will be scheduled to run 50 seconds after
+# the start of the previous task. If the task takes 70 seconds to
+# complete, the next task will be start immediately after the previous
+# task completes. Tasks will not be executed concurrently.
+#
+# In some cases it may be necessary for a `TimerTask` to affect its own
+# execution cycle. To facilitate this, a reference to the TimerTask instance
+# is passed as an argument to the provided block every time the task is
+# executed.
+#
+# The `TimerTask` class includes the `Dereferenceable` mixin module so the
+# result of the last execution is always available via the `#value` method.
+# Dereferencing options can be passed to the `TimerTask` during construction or
+# at any later time using the `#set_deref_options` method.
+#
+# `TimerTask` supports notification through the Ruby standard library
+# {http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html
+# Observable} module. On execution the `TimerTask` will notify the observers
+# with three arguments: time of execution, the result of the block (or nil on
+# failure), and any raised exceptions (or nil on success).
+#
+# @example Basic usage
+#   task = Concurrent::TimerTask.new{ puts 'Boom!' }
+#   task.execute
+#
+#   task.execution_interval #=> 60 (default)
+#
+#   # wait 60 seconds...
+#   #=> 'Boom!'
+#
+#   task.shutdown #=> true
+# @example Configuring `:execution_interval`
+#   task = Concurrent::TimerTask.new(execution_interval: 5) do
+#   puts 'Boom!'
+#   end
+#
+#   task.execution_interval #=> 5
+# @example Immediate execution with `:run_now`
+#   task = Concurrent::TimerTask.new(run_now: true){ puts 'Boom!' }
+#   task.execute
+#
+#   #=> 'Boom!'
+# @example Configuring `:interval_type` with either :fixed_delay or :fixed_rate, default is :fixed_delay
+#   task = Concurrent::TimerTask.new(execution_interval: 5, interval_type: :fixed_rate) do
+#   puts 'Boom!'
+#   end
+#   task.interval_type #=> :fixed_rate
+# @example Last `#value` and `Dereferenceable` mixin
+#   task = Concurrent::TimerTask.new(
+#   dup_on_deref: true,
+#   execution_interval: 5
+#   ){ Time.now }
+#
+#   task.execute
+#   Time.now   #=> 2013-11-07 18:06:50 -0500
+#   sleep(10)
+#   task.value #=> 2013-11-07 18:06:55 -0500
+# @example Controlling execution from within the block
+#   timer_task = Concurrent::TimerTask.new(execution_interval: 1) do |task|
+#   task.execution_interval.to_i.times{ print 'Boom! ' }
+#   print "\n"
+#   task.execution_interval += 1
+#   if task.execution_interval > 5
+#   puts 'Stopping...'
+#   task.shutdown
+#   end
+#   end
+#
+#   timer_task.execute
+#   #=> Boom!
+#   #=> Boom! Boom!
+#   #=> Boom! Boom! Boom!
+#   #=> Boom! Boom! Boom! Boom!
+#   #=> Boom! Boom! Boom! Boom! Boom!
+#   #=> Stopping...
+# @example Observation
+#   class TaskObserver
+#   def update(time, result, ex)
+#   if result
+#   print "(#{time}) Execution successfully returned #{result}\n"
+#   else
+#   print "(#{time}) Execution failed with error #{ex}\n"
+#   end
+#   end
+#   end
+#
+#   task = Concurrent::TimerTask.new(execution_interval: 1){ 42 }
+#   task.add_observer(TaskObserver.new)
+#   task.execute
+#   sleep 4
+#
+#   #=> (2013-10-13 19:08:58 -0400) Execution successfully returned 42
+#   #=> (2013-10-13 19:08:59 -0400) Execution successfully returned 42
+#   #=> (2013-10-13 19:09:00 -0400) Execution successfully returned 42
+#   task.shutdown
+#
+#   task = Concurrent::TimerTask.new(execution_interval: 1){ sleep }
+#   task.add_observer(TaskObserver.new)
+#   task.execute
+#
+#   #=> (2013-10-13 19:07:25 -0400) Execution timed out
+#   #=> (2013-10-13 19:07:27 -0400) Execution timed out
+#   #=> (2013-10-13 19:07:29 -0400) Execution timed out
+#   task.shutdown
+#
+#   task = Concurrent::TimerTask.new(execution_interval: 1){ raise StandardError }
+#   task.add_observer(TaskObserver.new)
+#   task.execute
+#
+#   #=> (2013-10-13 19:09:37 -0400) Execution failed with error StandardError
+#   #=> (2013-10-13 19:09:38 -0400) Execution failed with error StandardError
+#   #=> (2013-10-13 19:09:39 -0400) Execution failed with error StandardError
+#   task.shutdown
+# @see http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html
+# @see http://docs.oracle.com/javase/7/docs/api/java/util/TimerTask.html
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#165
+class Concurrent::TimerTask < ::Concurrent::RubyExecutorService
+  include ::Concurrent::Concern::Dereferenceable
+  include ::Concurrent::Concern::Observable
+
+  # Create a new TimerTask with the given task and configuration.
+  #
+  # @option opts
+  # @option opts
+  # @option opts
+  # @param opts [Hash] the options defining task execution.
+  # @raise ArgumentError when no block is given.
+  # @return [TimerTask] the new `TimerTask`
+  # @yield to the block after :execution_interval seconds have passed since
+  #   the last yield
+  # @yieldparam task a reference to the `TimerTask` instance so that the
+  #   block can control its own lifecycle. Necessary since `self` will
+  #   refer to the execution context of the block rather than the running
+  #   `TimerTask`.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#209
+  def initialize(opts = T.unsafe(nil), &task); end
+
+  # Execute a previously created `TimerTask`.
+  #
+  # @example Instance and execute in separate steps
+  #   task = Concurrent::TimerTask.new(execution_interval: 10){ print "Hello World\n" }
+  #   task.running? #=> false
+  #   task.execute
+  #   task.running? #=> true
+  # @example Instance and execute in one line
+  #   task = Concurrent::TimerTask.new(execution_interval: 10){ print "Hello World\n" }.execute
+  #   task.running? #=> true
+  # @return [TimerTask] a reference to `self`
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#235
+  def execute; end
+
+  # @return [Fixnum] Number of seconds after the task completes before the
+  #   task is performed again.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#259
+  def execution_interval; end
+
+  # @return [Fixnum] Number of seconds after the task completes before the
+  #   task is performed again.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#266
+  def execution_interval=(value); end
+
+  # @return [Symbol] method to calculate the interval between executions
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#276
+  def interval_type; end
+
+  # Is the executor running?
+  #
+  # @return [Boolean] `true` when running, `false` when shutting down or shutdown
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#218
+  def running?; end
+
+  # @return [Fixnum] Number of seconds the task can run before it is
+  #   considered to have failed.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#281
+  def timeout_interval; end
+
+  # @return [Fixnum] Number of seconds the task can run before it is
+  #   considered to have failed.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#288
+  def timeout_interval=(value); end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/executor_service.rb#166
+  def <<(task); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#352
+  def calculate_next_interval(start_time); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#336
+  def execute_task(completion); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#296
+  def ns_initialize(opts, &task); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#324
+  def ns_kill_execution; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#318
+  def ns_shutdown_execution; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb#17
+  def post(*args, &task); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#330
+  def schedule_next_task(interval = T.unsafe(nil)); end
+
+  class << self
+    # Create and execute a new `TimerTask`.
+    #
+    # @example
+    #   task = Concurrent::TimerTask.execute(execution_interval: 10){ print "Hello World\n" }
+    #   task.running? #=> true
+    # @option opts
+    # @option opts
+    # @option opts
+    # @param opts [Hash] the options defining task execution.
+    # @raise ArgumentError when no block is given.
+    # @return [TimerTask] the new `TimerTask`
+    # @yield to the block after :execution_interval seconds have passed since
+    #   the last yield
+    # @yieldparam task a reference to the `TimerTask` instance so that the
+    #   block can control its own lifecycle. Necessary since `self` will
+    #   refer to the execution context of the block rather than the running
+    #   `TimerTask`.
+    #
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#252
+    def execute(opts = T.unsafe(nil), &task); end
+  end
+end
+
+# Default `:interval_type`
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#181
+Concurrent::TimerTask::DEFAULT_INTERVAL_TYPE = T.let(T.unsafe(nil), Symbol)
+
+# Default `:execution_interval` in seconds.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#170
+Concurrent::TimerTask::EXECUTION_INTERVAL = T.let(T.unsafe(nil), Integer)
+
+# Maintain the interval between the end of one execution and the start of the next execution.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#173
+Concurrent::TimerTask::FIXED_DELAY = T.let(T.unsafe(nil), Symbol)
+
+# Maintain the interval between the start of one execution and the start of the next.
+# If execution time exceeds the interval, the next execution will start immediately
+# after the previous execution finishes. Executions will not run concurrently.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#178
+Concurrent::TimerTask::FIXED_RATE = T.let(T.unsafe(nil), Symbol)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#153
+class Concurrent::Transaction
+  # @return [Transaction] a new instance of Transaction
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#162
+  def initialize; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#192
+  def abort; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#196
+  def commit; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#177
+  def open(tvar); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#166
+  def read(tvar); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#206
+  def unlock; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#171
+  def write(tvar, value); end
+
+  class << self
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#212
+    def current; end
+
+    # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#216
+    def current=(transaction); end
+  end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#155
+Concurrent::Transaction::ABORTED = T.let(T.unsafe(nil), Object)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#159
+class Concurrent::Transaction::AbortError < ::StandardError; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#160
+class Concurrent::Transaction::LeaveError < ::StandardError; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#157
+class Concurrent::Transaction::OpenEntry < ::Struct
+  # Returns the value of attribute modified
+  #
+  # @return [Object] the current value of modified
+  def modified; end
+
+  # Sets the attribute modified
+  #
+  # @param value [Object] the value to set the attribute modified to.
+  # @return [Object] the newly set value
+  def modified=(_); end
+
+  # Returns the value of attribute value
+  #
+  # @return [Object] the current value of value
+  def value; end
+
+  # Sets the attribute value
+  #
+  # @param value [Object] the value to set the attribute value to.
+  # @return [Object] the newly set value
+  def value=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# A fixed size array with volatile (synchronized, thread safe) getters/setters.
+# Mixes in Ruby's `Enumerable` module for enhanced search, sort, and traversal.
+#
+# @example
+#   tuple = Concurrent::Tuple.new(16)
+#
+#   tuple.set(0, :foo)                   #=> :foo  | volatile write
+#   tuple.get(0)                         #=> :foo  | volatile read
+#   tuple.compare_and_set(0, :foo, :bar) #=> true  | strong CAS
+#   tuple.cas(0, :foo, :baz)             #=> false | strong CAS
+#   tuple.get(0)                         #=> :bar  | volatile read
+# @see https://en.wikipedia.org/wiki/Tuple Tuple entry at Wikipedia
+# @see http://www.erlang.org/doc/reference_manual/data_types.html#id70396 Erlang Tuple
+# @see http://ruby-doc.org/core-2.2.2/Enumerable.html Enumerable
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/tuple.rb#20
+class Concurrent::Tuple
+  include ::Enumerable
+
+  # Create a new tuple of the given size.
+  #
+  # @param size [Integer] the number of elements in the tuple
+  # @return [Tuple] a new instance of Tuple
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tuple.rb#29
+  def initialize(size); end
+
+  # Set the value at the given index to the new value if and only if the current
+  # value matches the given old value.
+  #
+  # @param i [Integer] the index for the element to set
+  # @param old_value [Object] the value to compare against the current value
+  # @param new_value [Object] the value to set at the given index
+  # @return [Boolean] true if the value at the given element was set else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tuple.rb#69
+  def cas(i, old_value, new_value); end
+
+  # Set the value at the given index to the new value if and only if the current
+  # value matches the given old value.
+  #
+  # @param i [Integer] the index for the element to set
+  # @param old_value [Object] the value to compare against the current value
+  # @param new_value [Object] the value to set at the given index
+  # @return [Boolean] true if the value at the given element was set else false
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tuple.rb#69
+  def compare_and_set(i, old_value, new_value); end
+
+  # Calls the given block once for each element in self, passing that element as a parameter.
+  #
+  # @yieldparam ref [Object] the `Concurrent::AtomicReference` object at the current index
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tuple.rb#78
+  def each; end
+
+  # Get the value of the element at the given index.
+  #
+  # @param i [Integer] the index from which to retrieve the value
+  # @return [Object] the value at the given index or nil if the index is out of bounds
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tuple.rb#43
+  def get(i); end
+
+  # Set the element at the given index to the given value
+  #
+  # @param i [Integer] the index for the element to set
+  # @param value [Object] the value to set at the given index
+  # @return [Object] the new value of the element at the given index or nil if the index is out of bounds
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tuple.rb#55
+  def set(i, value); end
+
+  # The (fixed) size of the tuple.
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tuple.rb#24
+  def size; end
+
+  # Get the value of the element at the given index.
+  #
+  # @param i [Integer] the index from which to retrieve the value
+  # @return [Object] the value at the given index or nil if the index is out of bounds
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tuple.rb#43
+  def volatile_get(i); end
+
+  # Set the element at the given index to the given value
+  #
+  # @param i [Integer] the index for the element to set
+  # @param value [Object] the value to set at the given index
+  # @return [Object] the new value of the element at the given index or nil if the index is out of bounds
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tuple.rb#55
+  def volatile_set(i, value); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/engine.rb#3
+module Concurrent::Utility; end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/engine.rb#6
+module Concurrent::Utility::EngineDetector
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/engine.rb#7
+  def on_cruby?; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/engine.rb#11
+  def on_jruby?; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/engine.rb#27
+  def on_linux?; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/engine.rb#23
+  def on_osx?; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/engine.rb#15
+  def on_truffleruby?; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/engine.rb#19
+  def on_windows?; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/engine.rb#31
+  def ruby_version(version = T.unsafe(nil), comparison, major, minor, patch); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb#9
+module Concurrent::Utility::NativeExtensionLoader
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb#11
+  def allow_c_extensions?; end
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb#15
+  def c_extensions_loaded?; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb#19
+  def load_native_extensions; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb#50
+  def java_extensions_loaded?; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb#38
+  def load_error_path(error); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb#46
+  def set_c_extensions_loaded; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb#54
+  def set_java_extensions_loaded; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb#58
+  def try_load_c_extension(path); end
+end
+
+# @private
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_integer.rb#5
+module Concurrent::Utility::NativeInteger
+  extend ::Concurrent::Utility::NativeInteger
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_integer.rb#24
+  def ensure_integer(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_integer.rb#31
+  def ensure_integer_and_bounds(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_integer.rb#17
+  def ensure_lower_bound(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_integer.rb#37
+  def ensure_positive(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_integer.rb#44
+  def ensure_positive_and_no_zero(value); end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_integer.rb#10
+  def ensure_upper_bound(value); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_integer.rb#8
+Concurrent::Utility::NativeInteger::MAX_VALUE = T.let(T.unsafe(nil), Integer)
+
+# http://stackoverflow.com/questions/535721/ruby-max-integer
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/native_integer.rb#7
+Concurrent::Utility::NativeInteger::MIN_VALUE = T.let(T.unsafe(nil), Integer)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#10
+class Concurrent::Utility::ProcessorCounter
+  # @return [ProcessorCounter] a new instance of ProcessorCounter
+  #
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#11
+  def initialize; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#26
+  def available_processor_count; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#41
+  def cpu_quota; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#45
+  def cpu_shares; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#22
+  def physical_processor_count; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#18
+  def processor_count; end
+
+  private
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#104
+  def compute_cpu_quota; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#124
+  def compute_cpu_shares; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#59
+  def compute_physical_processor_count; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#51
+  def compute_processor_count; end
+
+  # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#99
+  def run(command); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/version.rb#2
+Concurrent::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.5.rbi b/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.5.rbi
deleted file mode 100644
index 05e842256de63..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.5.rbi
+++ /dev/null
@@ -1,64 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `connection_pool` gem.
-# Please instead update this file by running `bin/tapioca gem connection_pool`.
-
-class ConnectionPool
-  def initialize(options = T.unsafe(nil), &block); end
-
-  def available; end
-  def checkin; end
-  def checkout(options = T.unsafe(nil)); end
-  def reload(&block); end
-  def shutdown(&block); end
-  def size; end
-  def then(options = T.unsafe(nil)); end
-  def with(options = T.unsafe(nil)); end
-
-  class << self
-    def wrap(options, &block); end
-  end
-end
-
-ConnectionPool::DEFAULTS = T.let(T.unsafe(nil), Hash)
-class ConnectionPool::Error < ::RuntimeError; end
-class ConnectionPool::PoolShuttingDownError < ::ConnectionPool::Error; end
-
-class ConnectionPool::TimedStack
-  def initialize(size = T.unsafe(nil), &block); end
-
-  def <<(obj, options = T.unsafe(nil)); end
-  def empty?; end
-  def length; end
-  def max; end
-  def pop(timeout = T.unsafe(nil), options = T.unsafe(nil)); end
-  def push(obj, options = T.unsafe(nil)); end
-  def shutdown(reload: T.unsafe(nil), &block); end
-
-  private
-
-  def connection_stored?(options = T.unsafe(nil)); end
-  def current_time; end
-  def fetch_connection(options = T.unsafe(nil)); end
-  def shutdown_connections(options = T.unsafe(nil)); end
-  def store_connection(obj, options = T.unsafe(nil)); end
-  def try_create(options = T.unsafe(nil)); end
-end
-
-class ConnectionPool::TimeoutError < ::Timeout::Error; end
-ConnectionPool::VERSION = T.let(T.unsafe(nil), String)
-
-class ConnectionPool::Wrapper < ::BasicObject
-  def initialize(options = T.unsafe(nil), &block); end
-
-  def method_missing(name, *args, &block); end
-  def pool_available; end
-  def pool_shutdown(&block); end
-  def pool_size; end
-  def respond_to?(id, *args); end
-  def with(&block); end
-  def wrapped_pool; end
-end
-
-ConnectionPool::Wrapper::METHODS = T.let(T.unsafe(nil), Array)
diff --git a/Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.5.0.rbi b/Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.5.0.rbi
deleted file mode 100644
index 5b73ae7fe9a9d..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.5.0.rbi
+++ /dev/null
@@ -1,185 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `diff-lcs` gem.
-# Please instead update this file by running `bin/tapioca gem diff-lcs`.
-
-module Diff; end
-
-module Diff::LCS
-  def diff(other, callbacks = T.unsafe(nil), &block); end
-  def lcs(other, &block); end
-  def patch(patchset); end
-  def patch!(patchset); end
-  def patch_me(patchset); end
-  def sdiff(other, callbacks = T.unsafe(nil), &block); end
-  def traverse_balanced(other, callbacks = T.unsafe(nil), &block); end
-  def traverse_sequences(other, callbacks = T.unsafe(nil), &block); end
-  def unpatch(patchset); end
-  def unpatch!(patchset); end
-  def unpatch_me(patchset); end
-
-  class << self
-    def LCS(seq1, seq2, &block); end
-    def callbacks_for(callbacks); end
-    def diff(seq1, seq2, callbacks = T.unsafe(nil), &block); end
-    def lcs(seq1, seq2, &block); end
-    def patch(src, patchset, direction = T.unsafe(nil)); end
-    def patch!(src, patchset); end
-    def sdiff(seq1, seq2, callbacks = T.unsafe(nil), &block); end
-    def traverse_balanced(seq1, seq2, callbacks = T.unsafe(nil)); end
-    def traverse_sequences(seq1, seq2, callbacks = T.unsafe(nil)); end
-    def unpatch!(src, patchset); end
-
-    private
-
-    def diff_traversal(method, seq1, seq2, callbacks, &block); end
-  end
-end
-
-Diff::LCS::BalancedCallbacks = Diff::LCS::DefaultCallbacks
-
-class Diff::LCS::Block
-  def initialize(chunk); end
-
-  def changes; end
-  def diff_size; end
-  def insert; end
-  def op; end
-  def remove; end
-end
-
-class Diff::LCS::Change
-  include ::Comparable
-
-  def initialize(*args); end
-
-  def <=>(other); end
-  def ==(other); end
-  def action; end
-  def adding?; end
-  def changed?; end
-  def deleting?; end
-  def element; end
-  def finished_a?; end
-  def finished_b?; end
-  def inspect(*_args); end
-  def position; end
-  def to_a; end
-  def to_ary; end
-  def unchanged?; end
-
-  class << self
-    def from_a(arr); end
-    def valid_action?(action); end
-  end
-end
-
-Diff::LCS::Change::IntClass = Integer
-Diff::LCS::Change::VALID_ACTIONS = T.let(T.unsafe(nil), Array)
-
-class Diff::LCS::ContextChange < ::Diff::LCS::Change
-  def initialize(*args); end
-
-  def <=>(other); end
-  def ==(other); end
-  def new_element; end
-  def new_position; end
-  def old_element; end
-  def old_position; end
-  def to_a; end
-  def to_ary; end
-
-  class << self
-    def from_a(arr); end
-    def simplify(event); end
-  end
-end
-
-class Diff::LCS::ContextDiffCallbacks < ::Diff::LCS::DiffCallbacks
-  def change(event); end
-  def discard_a(event); end
-  def discard_b(event); end
-end
-
-class Diff::LCS::DefaultCallbacks
-  class << self
-    def change(event); end
-    def discard_a(event); end
-    def discard_b(event); end
-    def match(event); end
-  end
-end
-
-class Diff::LCS::DiffCallbacks
-  def initialize; end
-
-  def diffs; end
-  def discard_a(event); end
-  def discard_b(event); end
-  def finish; end
-  def match(_event); end
-
-  private
-
-  def finish_hunk; end
-end
-
-class Diff::LCS::Hunk
-  def initialize(data_old, data_new, piece, flag_context, file_length_difference); end
-
-  def blocks; end
-  def diff(format, last = T.unsafe(nil)); end
-  def end_new; end
-  def end_old; end
-  def file_length_difference; end
-  def flag_context; end
-  def flag_context=(context); end
-  def merge(hunk); end
-  def missing_last_newline?(data); end
-  def overlaps?(hunk); end
-  def start_new; end
-  def start_old; end
-  def unshift(hunk); end
-
-  private
-
-  def context_diff(last = T.unsafe(nil)); end
-  def context_range(mode, op, last = T.unsafe(nil)); end
-  def ed_diff(format, _last = T.unsafe(nil)); end
-  def encode(literal, target_encoding = T.unsafe(nil)); end
-  def encode_as(string, *args); end
-  def old_diff(_last = T.unsafe(nil)); end
-  def unified_diff(last = T.unsafe(nil)); end
-  def unified_range(mode, last); end
-end
-
-Diff::LCS::Hunk::ED_DIFF_OP_ACTION = T.let(T.unsafe(nil), Hash)
-Diff::LCS::Hunk::OLD_DIFF_OP_ACTION = T.let(T.unsafe(nil), Hash)
-
-module Diff::LCS::Internals
-  class << self
-    def analyze_patchset(patchset, depth = T.unsafe(nil)); end
-    def intuit_diff_direction(src, patchset, limit = T.unsafe(nil)); end
-    def lcs(a, b); end
-
-    private
-
-    def inverse_vector(a, vector); end
-    def position_hash(enum, interval); end
-    def replace_next_larger(enum, value, last_index = T.unsafe(nil)); end
-  end
-end
-
-class Diff::LCS::SDiffCallbacks
-  def initialize; end
-
-  def change(event); end
-  def diffs; end
-  def discard_a(event); end
-  def discard_b(event); end
-  def match(event); end
-end
-
-Diff::LCS::SequenceCallbacks = Diff::LCS::DefaultCallbacks
-Diff::LCS::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/docile@1.4.0.rbi b/Library/Homebrew/sorbet/rbi/gems/docile@1.4.0.rbi
deleted file mode 100644
index d8a14c572165c..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/docile@1.4.0.rbi
+++ /dev/null
@@ -1,54 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `docile` gem.
-# Please instead update this file by running `bin/tapioca gem docile`.
-
-module Docile
-  extend ::Docile::Execution
-
-  private
-
-  def dsl_eval(dsl, *args, &block); end
-  def dsl_eval_immutable(dsl, *args, &block); end
-  def dsl_eval_with_block_return(dsl, *args, &block); end
-
-  class << self
-    def dsl_eval(dsl, *args, &block); end
-    def dsl_eval_immutable(dsl, *args, &block); end
-    def dsl_eval_with_block_return(dsl, *args, &block); end
-  end
-end
-
-module Docile::BacktraceFilter
-  def backtrace; end
-  def backtrace_locations; end
-end
-
-Docile::BacktraceFilter::FILTER_PATTERN = T.let(T.unsafe(nil), Regexp)
-
-class Docile::ChainingFallbackContextProxy < ::Docile::FallbackContextProxy
-  def method_missing(method, *args, &block); end
-end
-
-module Docile::Execution
-  private
-
-  def exec_in_proxy_context(dsl, proxy_type, *args, &block); end
-
-  class << self
-    def exec_in_proxy_context(dsl, proxy_type, *args, &block); end
-  end
-end
-
-class Docile::FallbackContextProxy
-  def initialize(receiver, fallback); end
-
-  def instance_variables; end
-  def method_missing(method, *args, &block); end
-end
-
-Docile::FallbackContextProxy::NON_FALLBACK_METHODS = T.let(T.unsafe(nil), Set)
-Docile::FallbackContextProxy::NON_PROXIED_INSTANCE_VARIABLES = T.let(T.unsafe(nil), Set)
-Docile::FallbackContextProxy::NON_PROXIED_METHODS = T.let(T.unsafe(nil), Set)
-Docile::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi b/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi
deleted file mode 100644
index 7e96cdabf2772..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi
+++ /dev/null
@@ -1,71 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `domain_name` gem.
-# Please instead update this file by running `bin/tapioca gem domain_name`.
-
-class DomainName
-  def initialize(hostname); end
-
-  def <(other); end
-  def <=(other); end
-  def <=>(other); end
-  def ==(other); end
-  def >(other); end
-  def >=(other); end
-  def canonical?; end
-  def canonical_tld?; end
-  def cookie_domain?(domain, host_only = T.unsafe(nil)); end
-  def domain; end
-  def domain_idn; end
-  def hostname; end
-  def hostname_idn; end
-  def idn; end
-  def inspect; end
-  def ipaddr; end
-  def ipaddr?; end
-  def superdomain; end
-  def tld; end
-  def tld_idn; end
-  def to_s; end
-  def to_str; end
-  def uri_host; end
-
-  class << self
-    def etld_data; end
-    def normalize(domain); end
-  end
-end
-
-DomainName::DOT = T.let(T.unsafe(nil), String)
-DomainName::ETLD_DATA = T.let(T.unsafe(nil), Hash)
-DomainName::ETLD_DATA_DATE = T.let(T.unsafe(nil), String)
-
-module DomainName::Punycode
-  class << self
-    def decode(string); end
-    def decode_hostname(hostname); end
-    def encode(string); end
-    def encode_hostname(hostname); end
-  end
-end
-
-class DomainName::Punycode::ArgumentError < ::ArgumentError; end
-DomainName::Punycode::BASE = T.let(T.unsafe(nil), Integer)
-class DomainName::Punycode::BufferOverflowError < ::DomainName::Punycode::ArgumentError; end
-DomainName::Punycode::CUTOFF = T.let(T.unsafe(nil), Integer)
-DomainName::Punycode::DAMP = T.let(T.unsafe(nil), Integer)
-DomainName::Punycode::DECODE_DIGIT = T.let(T.unsafe(nil), Hash)
-DomainName::Punycode::DELIMITER = T.let(T.unsafe(nil), String)
-DomainName::Punycode::DOT = T.let(T.unsafe(nil), String)
-DomainName::Punycode::ENCODE_DIGIT = T.let(T.unsafe(nil), Proc)
-DomainName::Punycode::INITIAL_BIAS = T.let(T.unsafe(nil), Integer)
-DomainName::Punycode::INITIAL_N = T.let(T.unsafe(nil), Integer)
-DomainName::Punycode::LOBASE = T.let(T.unsafe(nil), Integer)
-DomainName::Punycode::MAXINT = T.let(T.unsafe(nil), Integer)
-DomainName::Punycode::PREFIX = T.let(T.unsafe(nil), String)
-DomainName::Punycode::RE_NONBASIC = T.let(T.unsafe(nil), Regexp)
-DomainName::Punycode::SKEW = T.let(T.unsafe(nil), Integer)
-DomainName::Punycode::TMAX = T.let(T.unsafe(nil), Integer)
-DomainName::Punycode::TMIN = T.let(T.unsafe(nil), Integer)
-DomainName::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/ecma-re-validator@0.4.0.rbi b/Library/Homebrew/sorbet/rbi/gems/ecma-re-validator@0.4.0.rbi
deleted file mode 100644
index 205518febaaa5..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/ecma-re-validator@0.4.0.rbi
+++ /dev/null
@@ -1,15 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `ecma-re-validator` gem.
-# Please instead update this file by running `bin/tapioca gem ecma-re-validator`.
-
-module EcmaReValidator
-  class << self
-    def valid?(input); end
-  end
-end
-
-EcmaReValidator::INVALID_REGEXP = T.let(T.unsafe(nil), Array)
-EcmaReValidator::INVALID_TOKENS = T.let(T.unsafe(nil), Array)
-EcmaReValidator::UNICODE_CHARACTERS = T.let(T.unsafe(nil), Array)
diff --git a/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.3.rbi
deleted file mode 100644
index 18eca679b81e2..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.3.rbi
+++ /dev/null
@@ -1,566 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `elftools` gem.
-# Please instead update this file by running `bin/tapioca gem elftools`.
-
-module ELFTools; end
-
-module ELFTools::Constants
-  include ::ELFTools::Constants::DF
-  include ::ELFTools::Constants::DT
-  include ::ELFTools::Constants::EM
-  include ::ELFTools::Constants::ET
-  include ::ELFTools::Constants::PF
-  include ::ELFTools::Constants::PT
-  include ::ELFTools::Constants::SHN
-  include ::ELFTools::Constants::SHT
-  include ::ELFTools::Constants::STB
-  include ::ELFTools::Constants::STT
-end
-
-module ELFTools::Constants::DF; end
-ELFTools::Constants::DF::DF_1_CONFALT = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_DIRECT = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_DISPRELDNE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_DISPRELPND = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_EDITED = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_ENDFILTEE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_GLOBAL = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_GLOBAUDIT = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_GROUP = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_IGNMULDEF = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_INITFIRST = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_INTERPOSE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_LOADFLTR = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_NODEFLIB = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_NODELETE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_NODIRECT = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_NODUMP = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_NOHDR = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_NOKSYMS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_NOOPEN = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_NORELOC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_NOW = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_ORIGIN = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_SINGLETON = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_SYMINTPOSE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_1_TRANS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_BIND_NOW = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_ORIGIN = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_STATIC_TLS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_SYMBOLIC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DF::DF_TEXTREL = T.let(T.unsafe(nil), Integer)
-module ELFTools::Constants::DT; end
-ELFTools::Constants::DT::DT_ADDRRNGHI = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_ADDRRNGLO = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_BIND_NOW = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_DEBUG = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_ENCODING = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_FINI = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_FINI_ARRAY = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_FINI_ARRAYSZ = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_FLAGS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_FLAGS_1 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_GNU_HASH = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_HASH = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_HIOS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_HIPROC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_INIT = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_INIT_ARRAY = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_INIT_ARRAYSZ = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_JMPREL = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_LOOS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_LOPROC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_NEEDED = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_NULL = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_PLTGOT = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_PLTREL = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_PLTRELSZ = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_REL = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_RELA = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_RELACOUNT = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_RELAENT = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_RELASZ = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_RELCOUNT = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_RELENT = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_RELSZ = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_RPATH = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_RUNPATH = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_SONAME = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_STRSZ = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_STRTAB = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_SYMBOLIC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_SYMENT = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_SYMTAB = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_TEXTREL = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_VALRNGHI = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_VALRNGLO = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_VERDEF = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_VERDEFNUM = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_VERNEED = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_VERNEEDNUM = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::DT::DT_VERSYM = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::ELFMAG = T.let(T.unsafe(nil), String)
-
-module ELFTools::Constants::EM
-  class << self
-    def mapping(val); end
-  end
-end
-
-ELFTools::Constants::EM::EM_386 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_486 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_68K = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_860 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_88K = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_AARCH64 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_ALPHA = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_ALTERA_NIOS2 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_ARM = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_AVR32 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_BLACKFIN = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_BPF = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_CRIS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_CYGNUS_M32R = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_CYGNUS_MN10300 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_FRV = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_H8_300 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_IA_64 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_M32 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_M32R = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_MICROBLAZE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_MIPS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_MIPS_RS3_LE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_MIPS_RS4_BE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_MN10300 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_NONE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_OPENRISC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_PARISC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_PPC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_PPC64 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_S390 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_S390_OLD = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_SH = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_SPARC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_SPARC32PLUS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_SPARCV9 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_SPU = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_TILEGX = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_TILEPRO = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_TI_C6000 = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::EM::EM_X86_64 = T.let(T.unsafe(nil), Integer)
-
-module ELFTools::Constants::ET
-  class << self
-    def mapping(type); end
-  end
-end
-
-ELFTools::Constants::ET::ET_CORE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::ET::ET_DYN = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::ET::ET_EXEC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::ET::ET_NONE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::ET::ET_REL = T.let(T.unsafe(nil), Integer)
-module ELFTools::Constants::PF; end
-ELFTools::Constants::PF::PF_R = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PF::PF_W = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PF::PF_X = T.let(T.unsafe(nil), Integer)
-module ELFTools::Constants::PT; end
-ELFTools::Constants::PT::PT_DYNAMIC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PT::PT_GNU_EH_FRAME = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PT::PT_GNU_RELRO = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PT::PT_GNU_STACK = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PT::PT_HIOS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PT::PT_HIPROC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PT::PT_INTERP = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PT::PT_LOAD = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PT::PT_LOOS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PT::PT_LOPROC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PT::PT_NOTE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PT::PT_NULL = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PT::PT_PHDR = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PT::PT_SHLIB = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::PT::PT_TLS = T.let(T.unsafe(nil), Integer)
-module ELFTools::Constants::SHN; end
-ELFTools::Constants::SHN::SHN_LORESERVE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHN::SHN_UNDEF = T.let(T.unsafe(nil), Integer)
-module ELFTools::Constants::SHT; end
-ELFTools::Constants::SHT::SHT_DYNAMIC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_DYNSYM = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_HASH = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_HIPROC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_HIUSER = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_LOPROC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_LOUSER = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_NOBITS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_NOTE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_NULL = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_PROGBITS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_REL = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_RELA = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_SHLIB = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_STRTAB = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::SHT::SHT_SYMTAB = T.let(T.unsafe(nil), Integer)
-module ELFTools::Constants::STB; end
-ELFTools::Constants::STB::STB_GLOBAL = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STB::STB_GNU_UNIQUE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STB::STB_HIOS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STB::STB_HIPROC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STB::STB_LOCAL = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STB::STB_LOOS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STB::STB_LOPROC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STB::STB_NUM = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STB::STB_WEAK = T.let(T.unsafe(nil), Integer)
-module ELFTools::Constants::STT; end
-ELFTools::Constants::STT::STT_ARM_TFUNC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STT::STT_COMMON = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STT::STT_FILE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STT::STT_FUNC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STT::STT_GNU_IFUNC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STT::STT_HIOS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STT::STT_HIPROC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STT::STT_LOOS = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STT::STT_LOPROC = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STT::STT_NOTYPE = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STT::STT_NUM = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STT::STT_OBJECT = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STT::STT_SECTION = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STT::STT_SPARC_REGISTER = T.let(T.unsafe(nil), Integer)
-ELFTools::Constants::STT::STT_TLS = T.let(T.unsafe(nil), Integer)
-
-module ELFTools::Dynamic
-  def each_tags(&block); end
-  def tag_at(n); end
-  def tag_by_type(type); end
-  def tags; end
-  def tags_by_type(type); end
-
-  private
-
-  def endian; end
-  def str_offset; end
-end
-
-class ELFTools::Dynamic::Tag
-  def initialize(header, stream, str_offset); end
-
-  def header; end
-  def name; end
-  def name?; end
-  def stream; end
-  def value; end
-end
-
-ELFTools::Dynamic::Tag::TYPE_WITH_NAME = T.let(T.unsafe(nil), Array)
-class ELFTools::ELFClassError < ::ELFTools::ELFError; end
-class ELFTools::ELFDataError < ::ELFTools::ELFError; end
-class ELFTools::ELFError < ::StandardError; end
-
-class ELFTools::ELFFile
-  def initialize(stream); end
-
-  def build_id; end
-  def each_sections(&block); end
-  def each_segments(&block); end
-  def elf_class; end
-  def elf_type; end
-  def endian; end
-  def header; end
-  def machine; end
-  def num_sections; end
-  def num_segments; end
-  def offset_from_vma(vma, size = T.unsafe(nil)); end
-  def patches; end
-  def save(filename); end
-  def section_at(n); end
-  def section_by_name(name); end
-  def sections; end
-  def sections_by_type(type, &block); end
-  def segment_at(n); end
-  def segment_by_type(type); end
-  def segments; end
-  def segments_by_type(type, &block); end
-  def stream; end
-  def strtab_section; end
-
-  private
-
-  def create_section(n); end
-  def create_segment(n); end
-  def identify; end
-  def loaded_headers; end
-end
-
-class ELFTools::ELFMagicError < ::ELFTools::ELFError; end
-
-class ELFTools::LazyArray
-  def initialize(size, &block); end
-
-  def [](i); end
-end
-
-module ELFTools::Note
-  def each_notes; end
-  def notes; end
-
-  private
-
-  def create_note(cur); end
-  def endian; end
-end
-
-class ELFTools::Note::Note
-  def initialize(header, stream, offset); end
-
-  def desc; end
-  def description; end
-  def header; end
-  def name; end
-  def offset; end
-  def stream; end
-end
-
-ELFTools::Note::SIZE_OF_NHDR = T.let(T.unsafe(nil), Integer)
-
-class ELFTools::Relocation
-  def initialize(header, stream); end
-
-  def header; end
-  def r_info_sym; end
-  def r_info_type; end
-  def stream; end
-  def symbol_index; end
-  def type; end
-
-  private
-
-  def mask_bit; end
-end
-
-module ELFTools::Sections; end
-
-class ELFTools::Sections::DynamicSection < ::ELFTools::Sections::Section
-  include ::ELFTools::Dynamic
-
-  def tag_start; end
-end
-
-class ELFTools::Sections::NoteSection < ::ELFTools::Sections::Section
-  include ::ELFTools::Note
-
-  def note_start; end
-  def note_total_size; end
-end
-
-class ELFTools::Sections::NullSection < ::ELFTools::Sections::Section
-  def null?; end
-end
-
-class ELFTools::Sections::RelocationSection < ::ELFTools::Sections::Section
-  def each_relocations(&block); end
-  def num_relocations; end
-  def rela?; end
-  def relocation_at(n); end
-  def relocations; end
-
-  private
-
-  def create_relocation(n); end
-end
-
-class ELFTools::Sections::Section
-  def initialize(header, stream, offset_from_vma: T.unsafe(nil), strtab: T.unsafe(nil), **_kwargs); end
-
-  def data; end
-  def header; end
-  def name; end
-  def null?; end
-  def stream; end
-  def type; end
-
-  class << self
-    def create(header, stream, *args, **kwargs); end
-  end
-end
-
-class ELFTools::Sections::StrTabSection < ::ELFTools::Sections::Section
-  def name_at(offset); end
-end
-
-class ELFTools::Sections::SymTabSection < ::ELFTools::Sections::Section
-  def initialize(header, stream, section_at: T.unsafe(nil), **_kwargs); end
-
-  def each_symbols(&block); end
-  def num_symbols; end
-  def symbol_at(n); end
-  def symbol_by_name(name); end
-  def symbols; end
-  def symstr; end
-
-  private
-
-  def create_symbol(n); end
-end
-
-class ELFTools::Sections::Symbol
-  def initialize(header, stream, symstr: T.unsafe(nil)); end
-
-  def header; end
-  def name; end
-  def stream; end
-end
-
-module ELFTools::Segments; end
-
-class ELFTools::Segments::DynamicSegment < ::ELFTools::Segments::Segment
-  include ::ELFTools::Dynamic
-
-  def tag_start; end
-end
-
-class ELFTools::Segments::InterpSegment < ::ELFTools::Segments::Segment
-  def interp_name; end
-end
-
-class ELFTools::Segments::LoadSegment < ::ELFTools::Segments::Segment
-  def file_head; end
-  def file_tail; end
-  def mem_head; end
-  def mem_size; end
-  def mem_tail; end
-  def offset_in?(offset, size = T.unsafe(nil)); end
-  def offset_to_vma(offset); end
-  def size; end
-  def vma_in?(vma, size = T.unsafe(nil)); end
-  def vma_to_offset(vma); end
-end
-
-class ELFTools::Segments::NoteSegment < ::ELFTools::Segments::Segment
-  include ::ELFTools::Note
-
-  def note_start; end
-  def note_total_size; end
-end
-
-class ELFTools::Segments::Segment
-  def initialize(header, stream, offset_from_vma: T.unsafe(nil)); end
-
-  def data; end
-  def executable?; end
-  def header; end
-  def readable?; end
-  def stream; end
-  def type; end
-  def writable?; end
-
-  class << self
-    def create(header, stream, *args, **kwargs); end
-  end
-end
-
-module ELFTools::Structs; end
-
-class ELFTools::Structs::ELF32_Phdr < ::ELFTools::Structs::ELFStruct
-  class << self
-    def inherited(subclass); end
-    def new(*args); end
-  end
-end
-
-class ELFTools::Structs::ELF32_sym < ::ELFTools::Structs::ELFStruct
-  class << self
-    def inherited(subclass); end
-    def new(*args); end
-  end
-end
-
-class ELFTools::Structs::ELF64_Phdr < ::ELFTools::Structs::ELFStruct
-  class << self
-    def inherited(subclass); end
-    def new(*args); end
-  end
-end
-
-class ELFTools::Structs::ELF64_sym < ::ELFTools::Structs::ELFStruct
-  class << self
-    def inherited(subclass); end
-    def new(*args); end
-  end
-end
-
-class ELFTools::Structs::ELFStruct < ::BinData::Record
-  def elf_class; end
-  def elf_class=(_arg0); end
-  def offset; end
-  def offset=(_arg0); end
-  def patches; end
-
-  class << self
-    def inherited(subclass); end
-    def new(*args); end
-    def pack(val, bytes); end
-    def self_endian; end
-  end
-end
-
-ELFTools::Structs::ELFStruct::CHOICE_SIZE_T = T.let(T.unsafe(nil), Hash)
-
-class ELFTools::Structs::ELF_Dyn < ::ELFTools::Structs::ELFStruct
-  class << self
-    def inherited(subclass); end
-    def new(*args); end
-  end
-end
-
-class ELFTools::Structs::ELF_Ehdr < ::ELFTools::Structs::ELFStruct
-  class << self
-    def inherited(subclass); end
-    def new(*args); end
-  end
-end
-
-class ELFTools::Structs::ELF_Nhdr < ::ELFTools::Structs::ELFStruct
-  class << self
-    def inherited(subclass); end
-    def new(*args); end
-  end
-end
-
-ELFTools::Structs::ELF_Phdr = T.let(T.unsafe(nil), Hash)
-
-class ELFTools::Structs::ELF_Rel < ::ELFTools::Structs::ELFStruct
-  class << self
-    def inherited(subclass); end
-    def new(*args); end
-  end
-end
-
-class ELFTools::Structs::ELF_Rela < ::ELFTools::Structs::ELFStruct
-  class << self
-    def inherited(subclass); end
-    def new(*args); end
-  end
-end
-
-class ELFTools::Structs::ELF_Shdr < ::ELFTools::Structs::ELFStruct
-  class << self
-    def inherited(subclass); end
-    def new(*args); end
-  end
-end
-
-ELFTools::Structs::ELF_sym = T.let(T.unsafe(nil), Hash)
-
-module ELFTools::Util
-  extend ::ELFTools::Util::ClassMethods
-end
-
-module ELFTools::Util::ClassMethods
-  def align(num, bit); end
-  def cstring(stream, offset); end
-  def select_by_type(enum, type); end
-  def to_constant(mod, val); end
-end
-
-ELFTools::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/elftools@1.3.1.rbi b/Library/Homebrew/sorbet/rbi/gems/elftools@1.3.1.rbi
new file mode 100644
index 0000000000000..392194dfd0028
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/elftools@1.3.1.rbi
@@ -0,0 +1,4288 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `elftools` gem.
+# Please instead update this file by running `bin/tapioca gem elftools`.
+
+# The ELF parsing tools!
+# Main entry point is {ELFTools::ELFFile}, see it
+# for more information.
+#
+# source://elftools//lib/elftools/constants.rb#3
+module ELFTools; end
+
+# Define constants from elf.h.
+# Mostly refer from https://github.com/torvalds/linux/blob/master/include/uapi/linux/elf.h
+# and binutils/elfcpp/elfcpp.h.
+#
+# source://elftools//lib/elftools/constants.rb#7
+module ELFTools::Constants
+  include ::ELFTools::Constants::DF
+  include ::ELFTools::Constants::DT
+  include ::ELFTools::Constants::EM
+  include ::ELFTools::Constants::ET
+  include ::ELFTools::Constants::PF
+  include ::ELFTools::Constants::PT
+  include ::ELFTools::Constants::SHN
+  include ::ELFTools::Constants::SHF
+  include ::ELFTools::Constants::SHT
+  include ::ELFTools::Constants::STB
+  include ::ELFTools::Constants::STT
+end
+
+# Values of `d_un.d_val' in the DT_FLAGS and DT_FLAGS_1 entry.
+#
+# source://elftools//lib/elftools/constants.rb#12
+module ELFTools::Constants::DF; end
+
+# Configuration alternative created.
+#
+# source://elftools//lib/elftools/constants.rb#32
+ELFTools::Constants::DF::DF_1_CONFALT = T.let(T.unsafe(nil), Integer)
+
+# Direct binding enabled.
+#
+# source://elftools//lib/elftools/constants.rb#27
+ELFTools::Constants::DF::DF_1_DIRECT = T.let(T.unsafe(nil), Integer)
+
+# Disp reloc applied at build time.
+#
+# source://elftools//lib/elftools/constants.rb#34
+ELFTools::Constants::DF::DF_1_DISPRELDNE = T.let(T.unsafe(nil), Integer)
+
+# Disp reloc applied at run-time.
+#
+# source://elftools//lib/elftools/constants.rb#35
+ELFTools::Constants::DF::DF_1_DISPRELPND = T.let(T.unsafe(nil), Integer)
+
+# Object is modified after built.
+#
+# source://elftools//lib/elftools/constants.rb#40
+ELFTools::Constants::DF::DF_1_EDITED = T.let(T.unsafe(nil), Integer)
+
+# Filtee terminates filters search.
+#
+# source://elftools//lib/elftools/constants.rb#33
+ELFTools::Constants::DF::DF_1_ENDFILTEE = T.let(T.unsafe(nil), Integer)
+
+# Set RTLD_GLOBAL for this object.
+#
+# source://elftools//lib/elftools/constants.rb#20
+ELFTools::Constants::DF::DF_1_GLOBAL = T.let(T.unsafe(nil), Integer)
+
+# Global auditing required.
+#
+# source://elftools//lib/elftools/constants.rb#43
+ELFTools::Constants::DF::DF_1_GLOBAUDIT = T.let(T.unsafe(nil), Integer)
+
+# Set RTLD_GROUP for this object.
+#
+# source://elftools//lib/elftools/constants.rb#21
+ELFTools::Constants::DF::DF_1_GROUP = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#37
+ELFTools::Constants::DF::DF_1_IGNMULDEF = T.let(T.unsafe(nil), Integer)
+
+# Set RTLD_INITFIRST for this object
+#
+# source://elftools//lib/elftools/constants.rb#24
+ELFTools::Constants::DF::DF_1_INITFIRST = T.let(T.unsafe(nil), Integer)
+
+# Object is used to interpose.
+#
+# source://elftools//lib/elftools/constants.rb#29
+ELFTools::Constants::DF::DF_1_INTERPOSE = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#47
+ELFTools::Constants::DF::DF_1_KMOD = T.let(T.unsafe(nil), Integer)
+
+# Trigger filtee loading at runtime.
+#
+# source://elftools//lib/elftools/constants.rb#23
+ELFTools::Constants::DF::DF_1_LOADFLTR = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#49
+ELFTools::Constants::DF::DF_1_NOCOMMON = T.let(T.unsafe(nil), Integer)
+
+# Ignore default lib search path.
+#
+# source://elftools//lib/elftools/constants.rb#30
+ELFTools::Constants::DF::DF_1_NODEFLIB = T.let(T.unsafe(nil), Integer)
+
+# Set RTLD_NODELETE for this object.
+#
+# source://elftools//lib/elftools/constants.rb#22
+ELFTools::Constants::DF::DF_1_NODELETE = T.let(T.unsafe(nil), Integer)
+
+# Object has no-direct binding.
+#
+# source://elftools//lib/elftools/constants.rb#36
+ELFTools::Constants::DF::DF_1_NODIRECT = T.let(T.unsafe(nil), Integer)
+
+# Object can't be dldump'ed.
+#
+# source://elftools//lib/elftools/constants.rb#31
+ELFTools::Constants::DF::DF_1_NODUMP = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#39
+ELFTools::Constants::DF::DF_1_NOHDR = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#38
+ELFTools::Constants::DF::DF_1_NOKSYMS = T.let(T.unsafe(nil), Integer)
+
+# Set RTLD_NOOPEN for this object.
+#
+# source://elftools//lib/elftools/constants.rb#25
+ELFTools::Constants::DF::DF_1_NOOPEN = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#41
+ELFTools::Constants::DF::DF_1_NORELOC = T.let(T.unsafe(nil), Integer)
+
+# Set RTLD_NOW for this object.
+#
+# source://elftools//lib/elftools/constants.rb#19
+ELFTools::Constants::DF::DF_1_NOW = T.let(T.unsafe(nil), Integer)
+
+# $ORIGIN must be handled.
+#
+# source://elftools//lib/elftools/constants.rb#26
+ELFTools::Constants::DF::DF_1_ORIGIN = T.let(T.unsafe(nil), Integer)
+
+# Object is a position-independent executable.
+#
+# source://elftools//lib/elftools/constants.rb#46
+ELFTools::Constants::DF::DF_1_PIE = T.let(T.unsafe(nil), Integer)
+
+# Singleton symbols are used.
+#
+# source://elftools//lib/elftools/constants.rb#44
+ELFTools::Constants::DF::DF_1_SINGLETON = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#45
+ELFTools::Constants::DF::DF_1_STUB = T.let(T.unsafe(nil), Integer)
+
+# Object has individual interposers.
+#
+# source://elftools//lib/elftools/constants.rb#42
+ELFTools::Constants::DF::DF_1_SYMINTPOSE = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#28
+ELFTools::Constants::DF::DF_1_TRANS = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#48
+ELFTools::Constants::DF::DF_1_WEAKFILTER = T.let(T.unsafe(nil), Integer)
+
+# No lazy binding for this object
+#
+# source://elftools//lib/elftools/constants.rb#16
+ELFTools::Constants::DF::DF_BIND_NOW = T.let(T.unsafe(nil), Integer)
+
+# Object may use DF_ORIGIN
+#
+# source://elftools//lib/elftools/constants.rb#13
+ELFTools::Constants::DF::DF_ORIGIN = T.let(T.unsafe(nil), Integer)
+
+# Module uses the static TLS model
+#
+# source://elftools//lib/elftools/constants.rb#17
+ELFTools::Constants::DF::DF_STATIC_TLS = T.let(T.unsafe(nil), Integer)
+
+# Symbol resolutions starts here
+#
+# source://elftools//lib/elftools/constants.rb#14
+ELFTools::Constants::DF::DF_SYMBOLIC = T.let(T.unsafe(nil), Integer)
+
+# Object contains text relocations
+#
+# source://elftools//lib/elftools/constants.rb#15
+ELFTools::Constants::DF::DF_TEXTREL = T.let(T.unsafe(nil), Integer)
+
+# Dynamic table types, records in +d_tag+.
+#
+# source://elftools//lib/elftools/constants.rb#54
+module ELFTools::Constants::DT; end
+
+# see {DT_ADDRRNGLO}
+#
+# source://elftools//lib/elftools/constants.rb#115
+ELFTools::Constants::DT::DT_ADDRRNGHI = T.let(T.unsafe(nil), Integer)
+
+# Values between {DT_ADDRRNGLO} and {DT_ADDRRNGHI} use the +d_un.d_ptr+ field of the dynamic structure.
+#
+# source://elftools//lib/elftools/constants.rb#103
+ELFTools::Constants::DT::DT_ADDRRNGLO = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#111
+ELFTools::Constants::DT::DT_AUDIT = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#187
+ELFTools::Constants::DT::DT_AUXILIARY = T.let(T.unsafe(nil), Integer)
+
+# if the loader needs to do relocate now, superseded by the DF_BIND_NOW flag
+#
+# source://elftools//lib/elftools/constants.rb#79
+ELFTools::Constants::DT::DT_BIND_NOW = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#109
+ELFTools::Constants::DT::DT_CONFIG = T.let(T.unsafe(nil), Integer)
+
+# for debugging
+#
+# source://elftools//lib/elftools/constants.rb#76
+ELFTools::Constants::DT::DT_DEBUG = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#110
+ELFTools::Constants::DT::DT_DEPAUDIT = T.let(T.unsafe(nil), Integer)
+
+# just a lower bound
+#
+# source://elftools//lib/elftools/constants.rb#86
+ELFTools::Constants::DT::DT_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#189
+ELFTools::Constants::DT::DT_FILTER = T.let(T.unsafe(nil), Integer)
+
+# where the termination function is
+#
+# source://elftools//lib/elftools/constants.rb#68
+ELFTools::Constants::DT::DT_FINI = T.let(T.unsafe(nil), Integer)
+
+# address of fini array
+#
+# source://elftools//lib/elftools/constants.rb#81
+ELFTools::Constants::DT::DT_FINI_ARRAY = T.let(T.unsafe(nil), Integer)
+
+# total size of fini array
+#
+# source://elftools//lib/elftools/constants.rb#83
+ELFTools::Constants::DT::DT_FINI_ARRAYSZ = T.let(T.unsafe(nil), Integer)
+
+# flags
+#
+# source://elftools//lib/elftools/constants.rb#85
+ELFTools::Constants::DT::DT_FLAGS = T.let(T.unsafe(nil), Integer)
+
+# flags
+#
+# source://elftools//lib/elftools/constants.rb#120
+ELFTools::Constants::DT::DT_FLAGS_1 = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#107
+ELFTools::Constants::DT::DT_GNU_CONFLICT = T.let(T.unsafe(nil), Integer)
+
+# the gnu hash
+#
+# source://elftools//lib/elftools/constants.rb#104
+ELFTools::Constants::DT::DT_GNU_HASH = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#108
+ELFTools::Constants::DT::DT_GNU_LIBLIST = T.let(T.unsafe(nil), Integer)
+
+# address of symbol hash table
+#
+# source://elftools//lib/elftools/constants.rb#59
+ELFTools::Constants::DT::DT_HASH = T.let(T.unsafe(nil), Integer)
+
+# see {DT_LOOS}
+#
+# source://elftools//lib/elftools/constants.rb#96
+ELFTools::Constants::DT::DT_HIOS = T.let(T.unsafe(nil), Integer)
+
+# see {DT_LOPROC}
+#
+# source://elftools//lib/elftools/constants.rb#191
+ELFTools::Constants::DT::DT_HIPROC = T.let(T.unsafe(nil), Integer)
+
+# where the initialization function is
+#
+# source://elftools//lib/elftools/constants.rb#67
+ELFTools::Constants::DT::DT_INIT = T.let(T.unsafe(nil), Integer)
+
+# address init array
+#
+# source://elftools//lib/elftools/constants.rb#80
+ELFTools::Constants::DT::DT_INIT_ARRAY = T.let(T.unsafe(nil), Integer)
+
+# total size of init array
+#
+# source://elftools//lib/elftools/constants.rb#82
+ELFTools::Constants::DT::DT_INIT_ARRAYSZ = T.let(T.unsafe(nil), Integer)
+
+# address of relocation entries associated solely with procedure linkage table
+#
+# source://elftools//lib/elftools/constants.rb#78
+ELFTools::Constants::DT::DT_JMPREL = T.let(T.unsafe(nil), Integer)
+
+# Values between {DT_LOOS} and {DT_HIOS} are reserved for operating system-specific semantics.
+#
+# source://elftools//lib/elftools/constants.rb#95
+ELFTools::Constants::DT::DT_LOOS = T.let(T.unsafe(nil), Integer)
+
+# Values between {DT_LOPROC} and {DT_HIPROC} are reserved for processor-specific semantics.
+#
+# source://elftools//lib/elftools/constants.rb#127
+ELFTools::Constants::DT::DT_LOPROC = T.let(T.unsafe(nil), Integer)
+
+# address of auxiliary +.dynamic+
+#
+# source://elftools//lib/elftools/constants.rb#181
+ELFTools::Constants::DT::DT_MIPS_AUX_DYNAMIC = T.let(T.unsafe(nil), Integer)
+
+# base address of the segment
+#
+# source://elftools//lib/elftools/constants.rb#144
+ELFTools::Constants::DT::DT_MIPS_BASE_ADDRESS = T.let(T.unsafe(nil), Integer)
+
+# size of compact relocation section (O32)
+#
+# source://elftools//lib/elftools/constants.rb#179
+ELFTools::Constants::DT::DT_MIPS_COMPACT_SIZE = T.let(T.unsafe(nil), Integer)
+
+# address of +.conflict+ section
+#
+# source://elftools//lib/elftools/constants.rb#146
+ELFTools::Constants::DT::DT_MIPS_CONFLICT = T.let(T.unsafe(nil), Integer)
+
+# number of entries in the +.conflict+ section
+#
+# source://elftools//lib/elftools/constants.rb#149
+ELFTools::Constants::DT::DT_MIPS_CONFLICTNO = T.let(T.unsafe(nil), Integer)
+
+# flags indicating information about C++ flavor
+#
+# source://elftools//lib/elftools/constants.rb#166
+ELFTools::Constants::DT::DT_MIPS_CXX_FLAGS = T.let(T.unsafe(nil), Integer)
+
+# delta C++ class definition
+#
+# source://elftools//lib/elftools/constants.rb#156
+ELFTools::Constants::DT::DT_MIPS_DELTA_CLASS = T.let(T.unsafe(nil), Integer)
+
+# delta symbols that hold class declarations
+#
+# source://elftools//lib/elftools/constants.rb#164
+ELFTools::Constants::DT::DT_MIPS_DELTA_CLASSSYM = T.let(T.unsafe(nil), Integer)
+
+# number of entries in {DT_MIPS_DELTA_CLASSSYM}
+#
+# source://elftools//lib/elftools/constants.rb#165
+ELFTools::Constants::DT::DT_MIPS_DELTA_CLASSSYM_NO = T.let(T.unsafe(nil), Integer)
+
+# number of entries in {DT_MIPS_DELTA_CLASS}
+#
+# source://elftools//lib/elftools/constants.rb#157
+ELFTools::Constants::DT::DT_MIPS_DELTA_CLASS_NO = T.let(T.unsafe(nil), Integer)
+
+# delta C++ class instances
+#
+# source://elftools//lib/elftools/constants.rb#158
+ELFTools::Constants::DT::DT_MIPS_DELTA_INSTANCE = T.let(T.unsafe(nil), Integer)
+
+# number of entries in {DT_MIPS_DELTA_INSTANCE}
+#
+# source://elftools//lib/elftools/constants.rb#159
+ELFTools::Constants::DT::DT_MIPS_DELTA_INSTANCE_NO = T.let(T.unsafe(nil), Integer)
+
+# delta relocations
+#
+# source://elftools//lib/elftools/constants.rb#160
+ELFTools::Constants::DT::DT_MIPS_DELTA_RELOC = T.let(T.unsafe(nil), Integer)
+
+# number of entries in {DT_MIPS_DELTA_RELOC}
+#
+# source://elftools//lib/elftools/constants.rb#161
+ELFTools::Constants::DT::DT_MIPS_DELTA_RELOC_NO = T.let(T.unsafe(nil), Integer)
+
+# delta symbols that Delta relocations refer to
+#
+# source://elftools//lib/elftools/constants.rb#162
+ELFTools::Constants::DT::DT_MIPS_DELTA_SYM = T.let(T.unsafe(nil), Integer)
+
+# number of entries in {DT_MIPS_DELTA_SYM}
+#
+# source://elftools//lib/elftools/constants.rb#163
+ELFTools::Constants::DT::DT_MIPS_DELTA_SYM_NO = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#175
+ELFTools::Constants::DT::DT_MIPS_DYNSTR_ALIGN = T.let(T.unsafe(nil), Integer)
+
+# 32 bits of flags
+#
+# source://elftools//lib/elftools/constants.rb#143
+ELFTools::Constants::DT::DT_MIPS_FLAGS = T.let(T.unsafe(nil), Integer)
+
+# index of first dynamic symbol in global offset table
+#
+# source://elftools//lib/elftools/constants.rb#153
+ELFTools::Constants::DT::DT_MIPS_GOTSYM = T.let(T.unsafe(nil), Integer)
+
+# GP value for auxiliary GOTs
+#
+# source://elftools//lib/elftools/constants.rb#180
+ELFTools::Constants::DT::DT_MIPS_GP_VALUE = T.let(T.unsafe(nil), Integer)
+
+# GOT index of the first PTE for a hidden symbol
+#
+# source://elftools//lib/elftools/constants.rb#171
+ELFTools::Constants::DT::DT_MIPS_HIDDEN_GOTIDX = T.let(T.unsafe(nil), Integer)
+
+# number of page table entries in global offset table
+#
+# source://elftools//lib/elftools/constants.rb#154
+ELFTools::Constants::DT::DT_MIPS_HIPAGENO = T.let(T.unsafe(nil), Integer)
+
+# checksum of external strings and common sizes
+#
+# source://elftools//lib/elftools/constants.rb#141
+ELFTools::Constants::DT::DT_MIPS_ICHECKSUM = T.let(T.unsafe(nil), Integer)
+
+# address of +.interface+
+#
+# source://elftools//lib/elftools/constants.rb#174
+ELFTools::Constants::DT::DT_MIPS_INTERFACE = T.let(T.unsafe(nil), Integer)
+
+# size of the +.interface+ section
+#
+# source://elftools//lib/elftools/constants.rb#176
+ELFTools::Constants::DT::DT_MIPS_INTERFACE_SIZE = T.let(T.unsafe(nil), Integer)
+
+# index of version string in string table
+#
+# source://elftools//lib/elftools/constants.rb#142
+ELFTools::Constants::DT::DT_MIPS_IVERSION = T.let(T.unsafe(nil), Integer)
+
+# address of +.liblist+ section
+#
+# source://elftools//lib/elftools/constants.rb#147
+ELFTools::Constants::DT::DT_MIPS_LIBLIST = T.let(T.unsafe(nil), Integer)
+
+# number of entries in the +.liblist+ section
+#
+# source://elftools//lib/elftools/constants.rb#150
+ELFTools::Constants::DT::DT_MIPS_LIBLISTNO = T.let(T.unsafe(nil), Integer)
+
+# GOT index of the first PTE for a segment
+#
+# source://elftools//lib/elftools/constants.rb#169
+ELFTools::Constants::DT::DT_MIPS_LOCALPAGE_GOTIDX = T.let(T.unsafe(nil), Integer)
+
+# GOT index of the first PTE for a local symbol
+#
+# source://elftools//lib/elftools/constants.rb#170
+ELFTools::Constants::DT::DT_MIPS_LOCAL_GOTIDX = T.let(T.unsafe(nil), Integer)
+
+# number of local global offset table entries
+#
+# source://elftools//lib/elftools/constants.rb#148
+ELFTools::Constants::DT::DT_MIPS_LOCAL_GOTNO = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#145
+ELFTools::Constants::DT::DT_MIPS_MSYM = T.let(T.unsafe(nil), Integer)
+
+# address of +.MIPS.options+
+#
+# source://elftools//lib/elftools/constants.rb#173
+ELFTools::Constants::DT::DT_MIPS_OPTIONS = T.let(T.unsafe(nil), Integer)
+
+# default suffix of DSO to be added by rld on +dlopen()+ calls
+#
+# source://elftools//lib/elftools/constants.rb#178
+ELFTools::Constants::DT::DT_MIPS_PERF_SUFFIX = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#167
+ELFTools::Constants::DT::DT_MIPS_PIXIE_INIT = T.let(T.unsafe(nil), Integer)
+
+# address of the base of the PLTGOT
+#
+# source://elftools//lib/elftools/constants.rb#182
+ELFTools::Constants::DT::DT_MIPS_PLTGOT = T.let(T.unsafe(nil), Integer)
+
+# GOT index of the first PTE for a protected symbol
+#
+# source://elftools//lib/elftools/constants.rb#172
+ELFTools::Constants::DT::DT_MIPS_PROTECTED_GOTIDX = T.let(T.unsafe(nil), Integer)
+
+# address of run time loader map, used for debugging
+#
+# source://elftools//lib/elftools/constants.rb#155
+ELFTools::Constants::DT::DT_MIPS_RLD_MAP = T.let(T.unsafe(nil), Integer)
+
+# relative offset of run time loader map
+#
+# source://elftools//lib/elftools/constants.rb#184
+ELFTools::Constants::DT::DT_MIPS_RLD_MAP_REL = T.let(T.unsafe(nil), Integer)
+
+# size of +rld_text_resolve+ function stored in the GOT
+#
+# source://elftools//lib/elftools/constants.rb#177
+ELFTools::Constants::DT::DT_MIPS_RLD_TEXT_RESOLVE_ADDR = T.let(T.unsafe(nil), Integer)
+
+# 32 bit version number for runtime linker interface
+#
+# source://elftools//lib/elftools/constants.rb#139
+ELFTools::Constants::DT::DT_MIPS_RLD_VERSION = T.let(T.unsafe(nil), Integer)
+
+# base of a writable PLT
+#
+# source://elftools//lib/elftools/constants.rb#183
+ELFTools::Constants::DT::DT_MIPS_RWPLT = T.let(T.unsafe(nil), Integer)
+
+# address of +.MIPS.symlib+
+#
+# source://elftools//lib/elftools/constants.rb#168
+ELFTools::Constants::DT::DT_MIPS_SYMBOL_LIB = T.let(T.unsafe(nil), Integer)
+
+# number of entries in the +.dynsym+ section
+#
+# source://elftools//lib/elftools/constants.rb#151
+ELFTools::Constants::DT::DT_MIPS_SYMTABNO = T.let(T.unsafe(nil), Integer)
+
+# time stamp
+#
+# source://elftools//lib/elftools/constants.rb#140
+ELFTools::Constants::DT::DT_MIPS_TIME_STAMP = T.let(T.unsafe(nil), Integer)
+
+# index of first external dynamic symbol not referenced locally
+#
+# source://elftools//lib/elftools/constants.rb#152
+ELFTools::Constants::DT::DT_MIPS_UNREFEXTNO = T.let(T.unsafe(nil), Integer)
+
+# GNU-style hash table with xlat
+#
+# source://elftools//lib/elftools/constants.rb#185
+ELFTools::Constants::DT::DT_MIPS_XHASH = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#113
+ELFTools::Constants::DT::DT_MOVETAB = T.let(T.unsafe(nil), Integer)
+
+# libraries need to be linked by loader
+#
+# source://elftools//lib/elftools/constants.rb#56
+ELFTools::Constants::DT::DT_NEEDED = T.let(T.unsafe(nil), Integer)
+
+# marks the end of the _DYNAMIC array
+#
+# source://elftools//lib/elftools/constants.rb#55
+ELFTools::Constants::DT::DT_NULL = T.let(T.unsafe(nil), Integer)
+
+# address of procedure linkage table or global offset table
+#
+# source://elftools//lib/elftools/constants.rb#58
+ELFTools::Constants::DT::DT_PLTGOT = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#112
+ELFTools::Constants::DT::DT_PLTPAD = T.let(T.unsafe(nil), Integer)
+
+# type of relocation entry, either {DT_REL} or {DT_RELA}
+#
+# source://elftools//lib/elftools/constants.rb#75
+ELFTools::Constants::DT::DT_PLTREL = T.let(T.unsafe(nil), Integer)
+
+# total size of relocation entries
+#
+# source://elftools//lib/elftools/constants.rb#57
+ELFTools::Constants::DT::DT_PLTRELSZ = T.let(T.unsafe(nil), Integer)
+
+# start of the .glink section
+#
+# source://elftools//lib/elftools/constants.rb#132
+ELFTools::Constants::DT::DT_PPC64_GLINK = T.let(T.unsafe(nil), Integer)
+
+# start of the .opd section
+#
+# source://elftools//lib/elftools/constants.rb#133
+ELFTools::Constants::DT::DT_PPC64_OPD = T.let(T.unsafe(nil), Integer)
+
+# size of the .opd section
+#
+# source://elftools//lib/elftools/constants.rb#134
+ELFTools::Constants::DT::DT_PPC64_OPDSZ = T.let(T.unsafe(nil), Integer)
+
+# whether various optimisations are possible
+#
+# source://elftools//lib/elftools/constants.rb#135
+ELFTools::Constants::DT::DT_PPC64_OPT = T.let(T.unsafe(nil), Integer)
+
+# global offset table
+#
+# source://elftools//lib/elftools/constants.rb#129
+ELFTools::Constants::DT::DT_PPC_GOT = T.let(T.unsafe(nil), Integer)
+
+# whether various optimisations are possible
+#
+# source://elftools//lib/elftools/constants.rb#130
+ELFTools::Constants::DT::DT_PPC_OPT = T.let(T.unsafe(nil), Integer)
+
+# pre-initialization functions array
+#
+# source://elftools//lib/elftools/constants.rb#87
+ELFTools::Constants::DT::DT_PREINIT_ARRAY = T.let(T.unsafe(nil), Integer)
+
+# pre-initialization functions array size (bytes)
+#
+# source://elftools//lib/elftools/constants.rb#88
+ELFTools::Constants::DT::DT_PREINIT_ARRAYSZ = T.let(T.unsafe(nil), Integer)
+
+# similar to {DT_RELA}
+#
+# source://elftools//lib/elftools/constants.rb#72
+ELFTools::Constants::DT::DT_REL = T.let(T.unsafe(nil), Integer)
+
+# address of a relocation table
+#
+# source://elftools//lib/elftools/constants.rb#62
+ELFTools::Constants::DT::DT_RELA = T.let(T.unsafe(nil), Integer)
+
+# relative relocation count
+#
+# source://elftools//lib/elftools/constants.rb#118
+ELFTools::Constants::DT::DT_RELACOUNT = T.let(T.unsafe(nil), Integer)
+
+# size of each entry in the {DT_RELA} table
+#
+# source://elftools//lib/elftools/constants.rb#64
+ELFTools::Constants::DT::DT_RELAENT = T.let(T.unsafe(nil), Integer)
+
+# total size of the {DT_RELA} table
+#
+# source://elftools//lib/elftools/constants.rb#63
+ELFTools::Constants::DT::DT_RELASZ = T.let(T.unsafe(nil), Integer)
+
+# relative relocation count
+#
+# source://elftools//lib/elftools/constants.rb#119
+ELFTools::Constants::DT::DT_RELCOUNT = T.let(T.unsafe(nil), Integer)
+
+# size of each entry in the {DT_REL} table
+#
+# source://elftools//lib/elftools/constants.rb#74
+ELFTools::Constants::DT::DT_RELENT = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#91
+ELFTools::Constants::DT::DT_RELR = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#92
+ELFTools::Constants::DT::DT_RELRENT = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#90
+ELFTools::Constants::DT::DT_RELRSZ = T.let(T.unsafe(nil), Integer)
+
+# total size of the {DT_REL} table
+#
+# source://elftools//lib/elftools/constants.rb#73
+ELFTools::Constants::DT::DT_RELSZ = T.let(T.unsafe(nil), Integer)
+
+# has been superseded by {DT_RUNPATH}
+#
+# source://elftools//lib/elftools/constants.rb#70
+ELFTools::Constants::DT::DT_RPATH = T.let(T.unsafe(nil), Integer)
+
+# path of libraries for searching
+#
+# source://elftools//lib/elftools/constants.rb#84
+ELFTools::Constants::DT::DT_RUNPATH = T.let(T.unsafe(nil), Integer)
+
+# the shared object name
+#
+# source://elftools//lib/elftools/constants.rb#69
+ELFTools::Constants::DT::DT_SONAME = T.let(T.unsafe(nil), Integer)
+
+# index of an +STT_SPARC_REGISTER+ symbol within the {DT_SYMTAB} table
+#
+# source://elftools//lib/elftools/constants.rb#137
+ELFTools::Constants::DT::DT_SPARC_REGISTER = T.let(T.unsafe(nil), Integer)
+
+# total size of {DT_STRTAB}
+#
+# source://elftools//lib/elftools/constants.rb#65
+ELFTools::Constants::DT::DT_STRSZ = T.let(T.unsafe(nil), Integer)
+
+# address of string table
+#
+# source://elftools//lib/elftools/constants.rb#60
+ELFTools::Constants::DT::DT_STRTAB = T.let(T.unsafe(nil), Integer)
+
+# has been superseded by the DF_SYMBOLIC flag
+#
+# source://elftools//lib/elftools/constants.rb#71
+ELFTools::Constants::DT::DT_SYMBOLIC = T.let(T.unsafe(nil), Integer)
+
+# size of each entry in {DT_SYMTAB}
+#
+# source://elftools//lib/elftools/constants.rb#66
+ELFTools::Constants::DT::DT_SYMENT = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#114
+ELFTools::Constants::DT::DT_SYMINFO = T.let(T.unsafe(nil), Integer)
+
+# address of symbol table
+#
+# source://elftools//lib/elftools/constants.rb#61
+ELFTools::Constants::DT::DT_SYMTAB = T.let(T.unsafe(nil), Integer)
+
+# address of the +SHT_SYMTAB_SHNDX+ section associated with {DT_SYMTAB} table
+#
+# source://elftools//lib/elftools/constants.rb#89
+ELFTools::Constants::DT::DT_SYMTAB_SHNDX = T.let(T.unsafe(nil), Integer)
+
+# has been superseded by the DF_TEXTREL flag
+#
+# source://elftools//lib/elftools/constants.rb#77
+ELFTools::Constants::DT::DT_TEXTREL = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#106
+ELFTools::Constants::DT::DT_TLSDESC_GOT = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#105
+ELFTools::Constants::DT::DT_TLSDESC_PLT = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#188
+ELFTools::Constants::DT::DT_USED = T.let(T.unsafe(nil), Integer)
+
+# see {DT_VALRNGLO}
+#
+# source://elftools//lib/elftools/constants.rb#100
+ELFTools::Constants::DT::DT_VALRNGHI = T.let(T.unsafe(nil), Integer)
+
+# Values between {DT_VALRNGLO} and {DT_VALRNGHI} use the +d_un.d_val+ field of the dynamic structure.
+#
+# source://elftools//lib/elftools/constants.rb#99
+ELFTools::Constants::DT::DT_VALRNGLO = T.let(T.unsafe(nil), Integer)
+
+# address of version definition table
+#
+# source://elftools//lib/elftools/constants.rb#121
+ELFTools::Constants::DT::DT_VERDEF = T.let(T.unsafe(nil), Integer)
+
+# number of entries in {DT_VERDEF}
+#
+# source://elftools//lib/elftools/constants.rb#122
+ELFTools::Constants::DT::DT_VERDEFNUM = T.let(T.unsafe(nil), Integer)
+
+# address of version dependency table
+#
+# source://elftools//lib/elftools/constants.rb#123
+ELFTools::Constants::DT::DT_VERNEED = T.let(T.unsafe(nil), Integer)
+
+# number of entries in {DT_VERNEED}
+#
+# source://elftools//lib/elftools/constants.rb#124
+ELFTools::Constants::DT::DT_VERNEEDNUM = T.let(T.unsafe(nil), Integer)
+
+# section address of .gnu.version
+#
+# source://elftools//lib/elftools/constants.rb#117
+ELFTools::Constants::DT::DT_VERSYM = T.let(T.unsafe(nil), Integer)
+
+# ELF magic header
+#
+# source://elftools//lib/elftools/constants.rb#9
+ELFTools::Constants::ELFMAG = T.let(T.unsafe(nil), String)
+
+# These constants define the various ELF target machines.
+#
+# source://elftools//lib/elftools/constants.rb#196
+module ELFTools::Constants::EM
+  class << self
+    # Return the architecture name according to +val+.
+    # Used by {ELFTools::ELFFile#machine}.
+    #
+    # Only supports famous archs.
+    #
+    # @example
+    #   mapping(3)
+    #   #=> 'Intel 80386'
+    #   mapping(6)
+    #   #=> 'Intel 80386'
+    #   mapping(62)
+    #   #=> 'Advanced Micro Devices X86-64'
+    #   mapping(1337)
+    #   #=> '<unknown>: 0x539'
+    # @param val [Integer] Value of +e_machine+.
+    # @return [String] Name of architecture.
+    #
+    # source://elftools//lib/elftools/constants.rb#427
+    def mapping(val); end
+  end
+end
+
+# Intel 80386
+#
+# source://elftools//lib/elftools/constants.rb#200
+ELFTools::Constants::EM::EM_386 = T.let(T.unsafe(nil), Integer)
+
+# Intel 80486
+#
+# source://elftools//lib/elftools/constants.rb#203
+ELFTools::Constants::EM::EM_486 = T.let(T.unsafe(nil), Integer)
+
+# Tachyum
+#
+# source://elftools//lib/elftools/constants.rb#397
+ELFTools::Constants::EM::EM_56800EF = T.let(T.unsafe(nil), Integer)
+
+# Renesas 78K0R
+#
+# source://elftools//lib/elftools/constants.rb#358
+ELFTools::Constants::EM::EM_56800EX = T.let(T.unsafe(nil), Integer)
+
+# Kalray VLIW core of the MPPA processor family
+#
+# source://elftools//lib/elftools/constants.rb#392
+ELFTools::Constants::EM::EM_65816 = T.let(T.unsafe(nil), Integer)
+
+# Motorola MC68HC08 Microcontroller
+#
+# source://elftools//lib/elftools/constants.rb#256
+ELFTools::Constants::EM::EM_68HC05 = T.let(T.unsafe(nil), Integer)
+
+# Motorola MC68HC11 Microcontroller
+#
+# source://elftools//lib/elftools/constants.rb#255
+ELFTools::Constants::EM::EM_68HC08 = T.let(T.unsafe(nil), Integer)
+
+# Motorola MC68HC16 Microcontroller
+#
+# source://elftools//lib/elftools/constants.rb#254
+ELFTools::Constants::EM::EM_68HC11 = T.let(T.unsafe(nil), Integer)
+
+# Motorola Coldfire
+#
+# source://elftools//lib/elftools/constants.rb#237
+ELFTools::Constants::EM::EM_68HC12 = T.let(T.unsafe(nil), Integer)
+
+# STMicroelectronics ST7 8-bit microcontroller
+#
+# source://elftools//lib/elftools/constants.rb#253
+ELFTools::Constants::EM::EM_68HC16 = T.let(T.unsafe(nil), Integer)
+
+# Motorola 68000
+#
+# source://elftools//lib/elftools/constants.rb#201
+ELFTools::Constants::EM::EM_68K = T.let(T.unsafe(nil), Integer)
+
+# Broadcom VideoCore V processor
+#
+# source://elftools//lib/elftools/constants.rb#357
+ELFTools::Constants::EM::EM_78K0R = T.let(T.unsafe(nil), Integer)
+
+# QUALCOMM DSP6 Processor
+#
+# source://elftools//lib/elftools/constants.rb#324
+ELFTools::Constants::EM::EM_8051 = T.let(T.unsafe(nil), Integer)
+
+# Intel 80860
+#
+# source://elftools//lib/elftools/constants.rb#204
+ELFTools::Constants::EM::EM_860 = T.let(T.unsafe(nil), Integer)
+
+# Motorola 88000
+#
+# source://elftools//lib/elftools/constants.rb#202
+ELFTools::Constants::EM::EM_88K = T.let(T.unsafe(nil), Integer)
+
+# Sun's "v8plus"
+#
+# source://elftools//lib/elftools/constants.rb#216
+ELFTools::Constants::EM::EM_960 = T.let(T.unsafe(nil), Integer)
+
+# Intel K1OM
+#
+# source://elftools//lib/elftools/constants.rb#342
+ELFTools::Constants::EM::EM_AARCH64 = T.let(T.unsafe(nil), Integer)
+
+# This is an interim value that we will use until the committee comes up with a final number.
+#
+# source://elftools//lib/elftools/constants.rb#402
+ELFTools::Constants::EM::EM_ALPHA = T.let(T.unsafe(nil), Integer)
+
+# Icera Semiconductor Inc. Deep Execution Processor
+#
+# source://elftools//lib/elftools/constants.rb#297
+ELFTools::Constants::EM::EM_ALTERA_NIOS2 = T.let(T.unsafe(nil), Integer)
+
+# Moxie processor family
+#
+# source://elftools//lib/elftools/constants.rb#378
+ELFTools::Constants::EM::EM_AMDGPU = T.let(T.unsafe(nil), Integer)
+
+# Siemens Tricore embedded processor
+#
+# source://elftools//lib/elftools/constants.rb#229
+ELFTools::Constants::EM::EM_ARC = T.let(T.unsafe(nil), Integer)
+
+# Sharp embedded microprocessor
+#
+# source://elftools//lib/elftools/constants.rb#293
+ELFTools::Constants::EM::EM_ARCA = T.let(T.unsafe(nil), Integer)
+
+# OpenRISC 32-bit embedded processor
+#
+# source://elftools//lib/elftools/constants.rb#277
+ELFTools::Constants::EM::EM_ARC_COMPACT = T.let(T.unsafe(nil), Integer)
+
+# KIPO-KAIST Core-A 2nd generation processor family
+#
+# source://elftools//lib/elftools/constants.rb#353
+ELFTools::Constants::EM::EM_ARC_COMPACT2 = T.let(T.unsafe(nil), Integer)
+
+# MOS Technology MCS 6502 processor
+#
+# source://elftools//lib/elftools/constants.rb#390
+ELFTools::Constants::EM::EM_ARC_COMPACT3 = T.let(T.unsafe(nil), Integer)
+
+# C-SKY processor family
+#
+# source://elftools//lib/elftools/constants.rb#388
+ELFTools::Constants::EM::EM_ARC_COMPACT3_64 = T.let(T.unsafe(nil), Integer)
+
+# Motorola M*Core
+#
+# source://elftools//lib/elftools/constants.rb#225
+ELFTools::Constants::EM::EM_ARM = T.let(T.unsafe(nil), Integer)
+
+# SiTera Prism
+#
+# source://elftools//lib/elftools/constants.rb#267
+ELFTools::Constants::EM::EM_AVR = T.let(T.unsafe(nil), Integer)
+
+# ARM 64 bit
+#
+# source://elftools//lib/elftools/constants.rb#343
+ELFTools::Constants::EM::EM_AVR32 = T.let(T.unsafe(nil), Integer)
+
+# Freescale 56800EX Digital Signal Controller (DSC)
+#
+# source://elftools//lib/elftools/constants.rb#359
+ELFTools::Constants::EM::EM_BA1 = T.let(T.unsafe(nil), Integer)
+
+# Beyond BA1 CPU architecture
+#
+# source://elftools//lib/elftools/constants.rb#360
+ELFTools::Constants::EM::EM_BA2 = T.let(T.unsafe(nil), Integer)
+
+# TI msp430 micro controller
+#
+# source://elftools//lib/elftools/constants.rb#290
+ELFTools::Constants::EM::EM_BLACKFIN = T.let(T.unsafe(nil), Integer)
+
+# CEVA X2 Processor Family
+#
+# source://elftools//lib/elftools/constants.rb#382
+ELFTools::Constants::EM::EM_BPF = T.let(T.unsafe(nil), Integer)
+
+# Motorola XGATE embedded processor
+#
+# source://elftools//lib/elftools/constants.rb#300
+ELFTools::Constants::EM::EM_C116 = T.let(T.unsafe(nil), Integer)
+
+# KM211 KVARC processor
+#
+# source://elftools//lib/elftools/constants.rb#369
+ELFTools::Constants::EM::EM_CDP = T.let(T.unsafe(nil), Integer)
+
+# Microchip Technology dsPIC30F Digital Signal Controller
+#
+# source://elftools//lib/elftools/constants.rb#303
+ELFTools::Constants::EM::EM_CE = T.let(T.unsafe(nil), Integer)
+
+# Lanai 32-bit processor
+#
+# source://elftools//lib/elftools/constants.rb#380
+ELFTools::Constants::EM::EM_CEVA = T.let(T.unsafe(nil), Integer)
+
+# CEVA Processor Architecture Family
+#
+# source://elftools//lib/elftools/constants.rb#381
+ELFTools::Constants::EM::EM_CEVA_X2 = T.let(T.unsafe(nil), Integer)
+
+# Tilera TILE-Gx
+#
+# source://elftools//lib/elftools/constants.rb#350
+ELFTools::Constants::EM::EM_CLOUDSHIELD = T.let(T.unsafe(nil), Integer)
+
+# Paneve CDP architecture family
+#
+# source://elftools//lib/elftools/constants.rb#370
+ELFTools::Constants::EM::EM_COGE = T.let(T.unsafe(nil), Integer)
+
+# Stanford MIPS-X
+#
+# source://elftools//lib/elftools/constants.rb#236
+ELFTools::Constants::EM::EM_COLDFIRE = T.let(T.unsafe(nil), Integer)
+
+# Cognitive Smart Memory Processor
+#
+# source://elftools//lib/elftools/constants.rb#371
+ELFTools::Constants::EM::EM_COOL = T.let(T.unsafe(nil), Integer)
+
+# CloudShield architecture family
+#
+# source://elftools//lib/elftools/constants.rb#351
+ELFTools::Constants::EM::EM_COREA_1ST = T.let(T.unsafe(nil), Integer)
+
+# KIPO-KAIST Core-A 1st generation processor family
+#
+# source://elftools//lib/elftools/constants.rb#352
+ELFTools::Constants::EM::EM_COREA_2ND = T.let(T.unsafe(nil), Integer)
+
+# MAX Processor
+#
+# source://elftools//lib/elftools/constants.rb#287
+ELFTools::Constants::EM::EM_CR = T.let(T.unsafe(nil), Integer)
+
+# Cyan Technology eCOG16 family
+#
+# source://elftools//lib/elftools/constants.rb#337
+ELFTools::Constants::EM::EM_CR16 = T.let(T.unsafe(nil), Integer)
+
+# M2000 Reconfigurable RISC Microprocessor
+#
+# source://elftools//lib/elftools/constants.rb#332
+ELFTools::Constants::EM::EM_CRAYNV2 = T.let(T.unsafe(nil), Integer)
+
+# Digital VAX
+#
+# source://elftools//lib/elftools/constants.rb#260
+ELFTools::Constants::EM::EM_CRIS = T.let(T.unsafe(nil), Integer)
+
+# Altera Nios II soft-core processor
+#
+# source://elftools//lib/elftools/constants.rb#298
+ELFTools::Constants::EM::EM_CRX = T.let(T.unsafe(nil), Integer)
+
+# NEC Vector Engine
+#
+# source://elftools//lib/elftools/constants.rb#387
+ELFTools::Constants::EM::EM_CSKY = T.let(T.unsafe(nil), Integer)
+
+# Nanoradio Optimized RISC
+#
+# source://elftools//lib/elftools/constants.rb#373
+ELFTools::Constants::EM::EM_CSR_KALIMBA = T.let(T.unsafe(nil), Integer)
+
+# Xilinx MicroBlaze
+#
+# source://elftools//lib/elftools/constants.rb#348
+ELFTools::Constants::EM::EM_CUDA = T.let(T.unsafe(nil), Integer)
+
+# Bogus old m32r magic number, used by old tools.
+#
+# source://elftools//lib/elftools/constants.rb#405
+ELFTools::Constants::EM::EM_CYGNUS_M32R = T.let(T.unsafe(nil), Integer)
+
+# Also Panasonic/MEI MN10300, AM33
+#
+# source://elftools//lib/elftools/constants.rb#409
+ELFTools::Constants::EM::EM_CYGNUS_MN10300 = T.let(T.unsafe(nil), Integer)
+
+# STMicroelectronics 64bit VLIW Data Signal Processor
+#
+# source://elftools//lib/elftools/constants.rb#320
+ELFTools::Constants::EM::EM_CYPRESS_M8C = T.let(T.unsafe(nil), Integer)
+
+# Fujitsu FR30
+#
+# source://elftools//lib/elftools/constants.rb#269
+ELFTools::Constants::EM::EM_D10V = T.let(T.unsafe(nil), Integer)
+
+# Mitsubishi D10V
+#
+# source://elftools//lib/elftools/constants.rb#270
+ELFTools::Constants::EM::EM_D30V = T.let(T.unsafe(nil), Integer)
+
+# Sunplus S+core7 RISC processor
+#
+# source://elftools//lib/elftools/constants.rb#310
+ELFTools::Constants::EM::EM_DSP24 = T.let(T.unsafe(nil), Integer)
+
+# Renesas M16C series microprocessors
+#
+# source://elftools//lib/elftools/constants.rb#302
+ELFTools::Constants::EM::EM_DSPIC30F = T.let(T.unsafe(nil), Integer)
+
+# eXcess: 16/32/64-bit configurable embedded CPU
+#
+# source://elftools//lib/elftools/constants.rb#296
+ELFTools::Constants::EM::EM_DXP = T.let(T.unsafe(nil), Integer)
+
+# Andes Technology compact code size embedded RISC processor family
+#
+# source://elftools//lib/elftools/constants.rb#327
+ELFTools::Constants::EM::EM_ECOG1 = T.let(T.unsafe(nil), Integer)
+
+# MCST Elbrus general purpose hardware architecture
+#
+# source://elftools//lib/elftools/constants.rb#336
+ELFTools::Constants::EM::EM_ECOG16 = T.let(T.unsafe(nil), Integer)
+
+# Cyan Technology eCOG1X family
+#
+# source://elftools//lib/elftools/constants.rb#328
+ELFTools::Constants::EM::EM_ECOG1X = T.let(T.unsafe(nil), Integer)
+
+# Analog Devices SHARC family of 32-bit DSP processors
+#
+# source://elftools//lib/elftools/constants.rb#308
+ELFTools::Constants::EM::EM_ECOG2 = T.let(T.unsafe(nil), Integer)
+
+# National Semiconductor CompactRISC 16-bit processor
+#
+# source://elftools//lib/elftools/constants.rb#338
+ELFTools::Constants::EM::EM_ETPU = T.let(T.unsafe(nil), Integer)
+
+# Microprocessor series from PKU-Unity Ltd. and MPRC of Peking University
+#
+# source://elftools//lib/elftools/constants.rb#295
+ELFTools::Constants::EM::EM_EXCESS = T.let(T.unsafe(nil), Integer)
+
+# National Semiconductor CompactRISC
+#
+# source://elftools//lib/elftools/constants.rb#288
+ELFTools::Constants::EM::EM_F2MC16 = T.let(T.unsafe(nil), Integer)
+
+# Infineon Technologies 32-bit embedded cpu
+#
+# source://elftools//lib/elftools/constants.rb#262
+ELFTools::Constants::EM::EM_FIREPATH = T.let(T.unsafe(nil), Integer)
+
+# NEC V800 series
+#
+# source://elftools//lib/elftools/constants.rb#222
+ELFTools::Constants::EM::EM_FR20 = T.let(T.unsafe(nil), Integer)
+
+# Atmel AVR 8-bit microcontroller
+#
+# source://elftools//lib/elftools/constants.rb#268
+ELFTools::Constants::EM::EM_FR30 = T.let(T.unsafe(nil), Integer)
+
+# NXP 56800EF Digital Signal Controller (DSC)
+#
+# source://elftools//lib/elftools/constants.rb#399
+ELFTools::Constants::EM::EM_FRV = T.let(T.unsafe(nil), Integer)
+
+# Controls and Data Services VISIUMcore processor
+#
+# source://elftools//lib/elftools/constants.rb#376
+ELFTools::Constants::EM::EM_FT32 = T.let(T.unsafe(nil), Integer)
+
+# Digital Equipment Corp. PDP-11
+#
+# source://elftools//lib/elftools/constants.rb#250
+ELFTools::Constants::EM::EM_FX66 = T.let(T.unsafe(nil), Integer)
+
+# Linux BPF - in-kernel virtual machine
+#
+# source://elftools//lib/elftools/constants.rb#383
+ELFTools::Constants::EM::EM_GRAPHCORE_IPU = T.let(T.unsafe(nil), Integer)
+
+# Renesas H8/300H
+#
+# source://elftools//lib/elftools/constants.rb#232
+ELFTools::Constants::EM::EM_H8S = T.let(T.unsafe(nil), Integer)
+
+# ARC Cores
+#
+# source://elftools//lib/elftools/constants.rb#230
+ELFTools::Constants::EM::EM_H8_300 = T.let(T.unsafe(nil), Integer)
+
+# Renesas H8/300
+#
+# source://elftools//lib/elftools/constants.rb#231
+ELFTools::Constants::EM::EM_H8_300H = T.let(T.unsafe(nil), Integer)
+
+# Renesas H8S
+#
+# source://elftools//lib/elftools/constants.rb#233
+ELFTools::Constants::EM::EM_H8_500 = T.let(T.unsafe(nil), Integer)
+
+# Donald Knuth's educational 64-bit processor
+#
+# source://elftools//lib/elftools/constants.rb#265
+ELFTools::Constants::EM::EM_HUANY = T.let(T.unsafe(nil), Integer)
+
+# Renesas H8/500H
+#
+# source://elftools//lib/elftools/constants.rb#234
+ELFTools::Constants::EM::EM_IA_64 = T.let(T.unsafe(nil), Integer)
+
+# Graphcore Intelligent Processing Unit
+#
+# source://elftools//lib/elftools/constants.rb#384
+ELFTools::Constants::EM::EM_IMG1 = T.let(T.unsafe(nil), Integer)
+
+# Microchip 8-bit PIC(r) family
+#
+# source://elftools//lib/elftools/constants.rb#363
+ELFTools::Constants::EM::EM_INTELGT = T.let(T.unsafe(nil), Integer)
+
+# STMicroelectronics ST200 microcontroller
+#
+# source://elftools//lib/elftools/constants.rb#285
+ELFTools::Constants::EM::EM_IP2K = T.let(T.unsafe(nil), Integer)
+
+# Axis Communications 32-bit embedded processor
+#
+# source://elftools//lib/elftools/constants.rb#261
+ELFTools::Constants::EM::EM_JAVELIN = T.let(T.unsafe(nil), Integer)
+
+# Intel L1OM
+#
+# source://elftools//lib/elftools/constants.rb#341
+ELFTools::Constants::EM::EM_K1OM = T.let(T.unsafe(nil), Integer)
+
+# LoongArch
+#
+# source://elftools//lib/elftools/constants.rb#394
+ELFTools::Constants::EM::EM_KF32 = T.let(T.unsafe(nil), Integer)
+
+# Intel Graphics Technology
+#
+# source://elftools//lib/elftools/constants.rb#364
+ELFTools::Constants::EM::EM_KM32 = T.let(T.unsafe(nil), Integer)
+
+# KM211 KMX32 32-bit processor
+#
+# source://elftools//lib/elftools/constants.rb#366
+ELFTools::Constants::EM::EM_KMX16 = T.let(T.unsafe(nil), Integer)
+
+# KM211 KM32 32-bit processor
+#
+# source://elftools//lib/elftools/constants.rb#365
+ELFTools::Constants::EM::EM_KMX32 = T.let(T.unsafe(nil), Integer)
+
+# KM211 KMX16 16-bit processor
+#
+# source://elftools//lib/elftools/constants.rb#367
+ELFTools::Constants::EM::EM_KMX8 = T.let(T.unsafe(nil), Integer)
+
+# KM211 KMX8 8-bit processor
+#
+# source://elftools//lib/elftools/constants.rb#368
+ELFTools::Constants::EM::EM_KVARC = T.let(T.unsafe(nil), Integer)
+
+# Synopsys ARCv2.3 32-bit
+#
+# source://elftools//lib/elftools/constants.rb#391
+ELFTools::Constants::EM::EM_KVX = T.let(T.unsafe(nil), Integer)
+
+# Infineon Technologies SLE9X core
+#
+# source://elftools//lib/elftools/constants.rb#340
+ELFTools::Constants::EM::EM_L1OM = T.let(T.unsafe(nil), Integer)
+
+# AMD GPU architecture
+#
+# source://elftools//lib/elftools/constants.rb#379
+ELFTools::Constants::EM::EM_LANAI = T.let(T.unsafe(nil), Integer)
+
+# Broadcom VideoCore III processor
+#
+# source://elftools//lib/elftools/constants.rb#312
+ELFTools::Constants::EM::EM_LATTICEMICO32 = T.let(T.unsafe(nil), Integer)
+
+# WDC 65816/65C816
+#
+# source://elftools//lib/elftools/constants.rb#393
+ELFTools::Constants::EM::EM_LOONGARCH = T.let(T.unsafe(nil), Integer)
+
+# Infineon C16x/XC16x processor
+#
+# source://elftools//lib/elftools/constants.rb#301
+ELFTools::Constants::EM::EM_M16C = T.let(T.unsafe(nil), Integer)
+
+# AT&T WE 32100
+#
+# source://elftools//lib/elftools/constants.rb#198
+ELFTools::Constants::EM::EM_M32 = T.let(T.unsafe(nil), Integer)
+
+# Freescale Communication Engine RISC core
+#
+# source://elftools//lib/elftools/constants.rb#304
+ELFTools::Constants::EM::EM_M32C = T.let(T.unsafe(nil), Integer)
+
+# Renesas V850
+#
+# source://elftools//lib/elftools/constants.rb#272
+ELFTools::Constants::EM::EM_M32R = T.let(T.unsafe(nil), Integer)
+
+# New Japan Radio (NJR) 16-bit DSP Processor
+#
+# source://elftools//lib/elftools/constants.rb#331
+ELFTools::Constants::EM::EM_MANIK = T.let(T.unsafe(nil), Integer)
+
+# Ubicom IP2022 micro controller
+#
+# source://elftools//lib/elftools/constants.rb#286
+ELFTools::Constants::EM::EM_MAX = T.let(T.unsafe(nil), Integer)
+
+# Cyan Technology eCOG1X family
+#
+# source://elftools//lib/elftools/constants.rb#329
+ELFTools::Constants::EM::EM_MAXQ30 = T.let(T.unsafe(nil), Integer)
+
+# XMOS xCORE processor family
+#
+# source://elftools//lib/elftools/constants.rb#362
+ELFTools::Constants::EM::EM_MCHP_PIC = T.let(T.unsafe(nil), Integer)
+
+# Synopsys ARCv2.3 64-bit
+#
+# source://elftools//lib/elftools/constants.rb#389
+ELFTools::Constants::EM::EM_MCS6502 = T.let(T.unsafe(nil), Integer)
+
+# Imagination Technologies Meta processor architecture
+#
+# source://elftools//lib/elftools/constants.rb#335
+ELFTools::Constants::EM::EM_MCST_ELBRUS = T.let(T.unsafe(nil), Integer)
+
+# Motorola Star*Core processor
+#
+# source://elftools//lib/elftools/constants.rb#243
+ELFTools::Constants::EM::EM_ME16 = T.let(T.unsafe(nil), Integer)
+
+# Renesas RX family
+#
+# source://elftools//lib/elftools/constants.rb#334
+ELFTools::Constants::EM::EM_METAG = T.let(T.unsafe(nil), Integer)
+
+# Tilera TILEPro
+#
+# source://elftools//lib/elftools/constants.rb#347
+ELFTools::Constants::EM::EM_MICROBLAZE = T.let(T.unsafe(nil), Integer)
+
+# MIPS R3000 (officially, big-endian only)
+#
+# source://elftools//lib/elftools/constants.rb#205
+ELFTools::Constants::EM::EM_MIPS = T.let(T.unsafe(nil), Integer)
+
+# Next two are historical and binaries and
+# modules of these types will be rejected by Linux.
+#
+# source://elftools//lib/elftools/constants.rb#210
+ELFTools::Constants::EM::EM_MIPS_RS3_LE = T.let(T.unsafe(nil), Integer)
+
+# MIPS R3000 little-endian
+#
+# source://elftools//lib/elftools/constants.rb#211
+ELFTools::Constants::EM::EM_MIPS_RS4_BE = T.let(T.unsafe(nil), Integer)
+
+# HP/Intel IA-64
+#
+# source://elftools//lib/elftools/constants.rb#235
+ELFTools::Constants::EM::EM_MIPS_X = T.let(T.unsafe(nil), Integer)
+
+# Motorola M68HC12
+#
+# source://elftools//lib/elftools/constants.rb#238
+ELFTools::Constants::EM::EM_MMA = T.let(T.unsafe(nil), Integer)
+
+# Texas Instruments Programmable Realtime Unit
+#
+# source://elftools//lib/elftools/constants.rb#319
+ELFTools::Constants::EM::EM_MMDSP_PLUS = T.let(T.unsafe(nil), Integer)
+
+# LSI Logic's 16-bit DSP processor
+#
+# source://elftools//lib/elftools/constants.rb#264
+ELFTools::Constants::EM::EM_MMIX = T.let(T.unsafe(nil), Integer)
+
+# Matsushita MN10300
+#
+# source://elftools//lib/elftools/constants.rb#274
+ELFTools::Constants::EM::EM_MN10200 = T.let(T.unsafe(nil), Integer)
+
+# Renesas M32R
+#
+# source://elftools//lib/elftools/constants.rb#273
+ELFTools::Constants::EM::EM_MN10300 = T.let(T.unsafe(nil), Integer)
+
+# FTDI Chip FT32 high performance 32-bit RISC architecture
+#
+# source://elftools//lib/elftools/constants.rb#377
+ELFTools::Constants::EM::EM_MOXIE = T.let(T.unsafe(nil), Integer)
+
+# Fujitsu F2MC16
+#
+# source://elftools//lib/elftools/constants.rb#289
+ELFTools::Constants::EM::EM_MSP430 = T.let(T.unsafe(nil), Integer)
+
+# Siemens PCP
+#
+# source://elftools//lib/elftools/constants.rb#240
+ELFTools::Constants::EM::EM_NCPU = T.let(T.unsafe(nil), Integer)
+
+# Sony nCPU embedded RISC processor
+#
+# source://elftools//lib/elftools/constants.rb#241
+ELFTools::Constants::EM::EM_NDR1 = T.let(T.unsafe(nil), Integer)
+
+# STMicroelectronics STxP7x family
+#
+# source://elftools//lib/elftools/constants.rb#326
+ELFTools::Constants::EM::EM_NDS32 = T.let(T.unsafe(nil), Integer)
+
+# Imagination Technologies
+#
+# source://elftools//lib/elftools/constants.rb#385
+ELFTools::Constants::EM::EM_NFP = T.let(T.unsafe(nil), Integer)
+
+# none
+#
+# source://elftools//lib/elftools/constants.rb#197
+ELFTools::Constants::EM::EM_NONE = T.let(T.unsafe(nil), Integer)
+
+# Bluechip Systems CoolEngine
+#
+# source://elftools//lib/elftools/constants.rb#372
+ELFTools::Constants::EM::EM_NORC = T.let(T.unsafe(nil), Integer)
+
+# Thompson Multimedia General Purpose Processor
+#
+# source://elftools//lib/elftools/constants.rb#281
+ELFTools::Constants::EM::EM_NS32K = T.let(T.unsafe(nil), Integer)
+
+# Synopsys ARCompact V2
+#
+# source://elftools//lib/elftools/constants.rb#354
+ELFTools::Constants::EM::EM_OPEN8 = T.let(T.unsafe(nil), Integer)
+
+# picoJava
+#
+# source://elftools//lib/elftools/constants.rb#276
+ELFTools::Constants::EM::EM_OPENRISC = T.let(T.unsafe(nil), Integer)
+
+# MIPS R4000 big-endian
+#
+# source://elftools//lib/elftools/constants.rb#213
+ELFTools::Constants::EM::EM_PARISC = T.let(T.unsafe(nil), Integer)
+
+# Fujitsu Multimedia Accelerator
+#
+# source://elftools//lib/elftools/constants.rb#239
+ELFTools::Constants::EM::EM_PCP = T.let(T.unsafe(nil), Integer)
+
+# Sony DSP Processor
+#
+# source://elftools//lib/elftools/constants.rb#248
+ELFTools::Constants::EM::EM_PDP10 = T.let(T.unsafe(nil), Integer)
+
+# Digital Equipment Corp. PDP-10
+#
+# source://elftools//lib/elftools/constants.rb#249
+ELFTools::Constants::EM::EM_PDP11 = T.let(T.unsafe(nil), Integer)
+
+# AMD x86-64
+#
+# source://elftools//lib/elftools/constants.rb#247
+ELFTools::Constants::EM::EM_PDSP = T.let(T.unsafe(nil), Integer)
+
+# Matsushita MN10200
+#
+# source://elftools//lib/elftools/constants.rb#275
+ELFTools::Constants::EM::EM_PJ = T.let(T.unsafe(nil), Integer)
+
+# Intel 80960
+#
+# source://elftools//lib/elftools/constants.rb#217
+ELFTools::Constants::EM::EM_PPC = T.let(T.unsafe(nil), Integer)
+
+# PowerPC
+#
+# source://elftools//lib/elftools/constants.rb#218
+ELFTools::Constants::EM::EM_PPC64 = T.let(T.unsafe(nil), Integer)
+
+# Harvard's machine-independent format
+#
+# source://elftools//lib/elftools/constants.rb#266
+ELFTools::Constants::EM::EM_PRISM = T.let(T.unsafe(nil), Integer)
+
+# NXP Semiconductors TriMedia architecture family
+#
+# source://elftools//lib/elftools/constants.rb#323
+ELFTools::Constants::EM::EM_QDSP6 = T.let(T.unsafe(nil), Integer)
+
+# Cypress M8C microprocessor
+#
+# source://elftools//lib/elftools/constants.rb#321
+ELFTools::Constants::EM::EM_R32C = T.let(T.unsafe(nil), Integer)
+
+# TRW RH32
+#
+# source://elftools//lib/elftools/constants.rb#224
+ELFTools::Constants::EM::EM_RCE = T.let(T.unsafe(nil), Integer)
+
+# Fujitsu FR20
+#
+# source://elftools//lib/elftools/constants.rb#223
+ELFTools::Constants::EM::EM_RH32 = T.let(T.unsafe(nil), Integer)
+
+# Open8 8-bit RISC soft processor core
+#
+# source://elftools//lib/elftools/constants.rb#355
+ELFTools::Constants::EM::EM_RL78 = T.let(T.unsafe(nil), Integer)
+
+# Altium TSK3000 core
+#
+# source://elftools//lib/elftools/constants.rb#306
+ELFTools::Constants::EM::EM_RS08 = T.let(T.unsafe(nil), Integer)
+
+# Cray Inc. NV2 vector architecture
+#
+# source://elftools//lib/elftools/constants.rb#333
+ELFTools::Constants::EM::EM_RX = T.let(T.unsafe(nil), Integer)
+
+# IBM System/370
+#
+# source://elftools//lib/elftools/constants.rb#206
+ELFTools::Constants::EM::EM_S370 = T.let(T.unsafe(nil), Integer)
+
+# PowerPC64
+#
+# source://elftools//lib/elftools/constants.rb#219
+ELFTools::Constants::EM::EM_S390 = T.let(T.unsafe(nil), Integer)
+
+# This is the old interim value for S/390 architecture
+#
+# source://elftools//lib/elftools/constants.rb#407
+ELFTools::Constants::EM::EM_S390_OLD = T.let(T.unsafe(nil), Integer)
+
+# Cyan Technology eCOG2 microprocessor
+#
+# source://elftools//lib/elftools/constants.rb#309
+ELFTools::Constants::EM::EM_SCORE7 = T.let(T.unsafe(nil), Integer)
+
+# S1C33 Family of Seiko Epson processors
+#
+# source://elftools//lib/elftools/constants.rb#292
+ELFTools::Constants::EM::EM_SEP = T.let(T.unsafe(nil), Integer)
+
+# RISC processor for Lattice FPGA architecture
+#
+# source://elftools//lib/elftools/constants.rb#313
+ELFTools::Constants::EM::EM_SE_C17 = T.let(T.unsafe(nil), Integer)
+
+# ADI Blackfin Processor
+#
+# source://elftools//lib/elftools/constants.rb#291
+ELFTools::Constants::EM::EM_SE_C33 = T.let(T.unsafe(nil), Integer)
+
+# ARM 32 bit
+#
+# source://elftools//lib/elftools/constants.rb#226
+ELFTools::Constants::EM::EM_SH = T.let(T.unsafe(nil), Integer)
+
+# Freescale RS08 embedded processor
+#
+# source://elftools//lib/elftools/constants.rb#307
+ELFTools::Constants::EM::EM_SHARC = T.let(T.unsafe(nil), Integer)
+
+# Freescale Extended Time Processing Unit
+#
+# source://elftools//lib/elftools/constants.rb#339
+ELFTools::Constants::EM::EM_SLE9X = T.let(T.unsafe(nil), Integer)
+
+# Tenor Network TPC processor
+#
+# source://elftools//lib/elftools/constants.rb#283
+ELFTools::Constants::EM::EM_SNP1K = T.let(T.unsafe(nil), Integer)
+
+# SPARC
+#
+# source://elftools//lib/elftools/constants.rb#199
+ELFTools::Constants::EM::EM_SPARC = T.let(T.unsafe(nil), Integer)
+
+# Fujitsu VPP500 (also some older versions of PowerPC)
+#
+# source://elftools//lib/elftools/constants.rb#215
+ELFTools::Constants::EM::EM_SPARC32PLUS = T.let(T.unsafe(nil), Integer)
+
+# SuperH
+#
+# source://elftools//lib/elftools/constants.rb#227
+ELFTools::Constants::EM::EM_SPARCV9 = T.let(T.unsafe(nil), Integer)
+
+# IBM S/390
+#
+# source://elftools//lib/elftools/constants.rb#220
+ELFTools::Constants::EM::EM_SPU = T.let(T.unsafe(nil), Integer)
+
+# Toyota ME16 processor
+#
+# source://elftools//lib/elftools/constants.rb#244
+ELFTools::Constants::EM::EM_ST100 = T.let(T.unsafe(nil), Integer)
+
+# Silicon Graphics SVx
+#
+# source://elftools//lib/elftools/constants.rb#258
+ELFTools::Constants::EM::EM_ST19 = T.let(T.unsafe(nil), Integer)
+
+# Trebia SNP 1000 processor
+#
+# source://elftools//lib/elftools/constants.rb#284
+ELFTools::Constants::EM::EM_ST200 = T.let(T.unsafe(nil), Integer)
+
+# STMicroelectronics ST9+ 8/16 bit microcontroller
+#
+# source://elftools//lib/elftools/constants.rb#252
+ELFTools::Constants::EM::EM_ST7 = T.let(T.unsafe(nil), Integer)
+
+# Siemens FX66 microcontroller
+#
+# source://elftools//lib/elftools/constants.rb#251
+ELFTools::Constants::EM::EM_ST9PLUS = T.let(T.unsafe(nil), Integer)
+
+# Denso NDR1 microprocessor
+#
+# source://elftools//lib/elftools/constants.rb#242
+ELFTools::Constants::EM::EM_STARCORE = T.let(T.unsafe(nil), Integer)
+
+# Atmel Corporation 32-bit microprocessor family
+#
+# source://elftools//lib/elftools/constants.rb#344
+ELFTools::Constants::EM::EM_STM8 = T.let(T.unsafe(nil), Integer)
+
+# Intel 8051 and variants
+#
+# source://elftools//lib/elftools/constants.rb#325
+ELFTools::Constants::EM::EM_STXP7X = T.let(T.unsafe(nil), Integer)
+
+# Motorola MC68HC05 Microcontroller
+#
+# source://elftools//lib/elftools/constants.rb#257
+ELFTools::Constants::EM::EM_SVX = T.let(T.unsafe(nil), Integer)
+
+# LAPIS nX-U16/U8
+#
+# source://elftools//lib/elftools/constants.rb#396
+ELFTools::Constants::EM::EM_TACHYUM = T.let(T.unsafe(nil), Integer)
+
+# STMicroeletronics STM8 8-bit microcontroller
+#
+# source://elftools//lib/elftools/constants.rb#345
+ELFTools::Constants::EM::EM_TILE64 = T.let(T.unsafe(nil), Integer)
+
+# NVIDIA CUDA architecture
+#
+# source://elftools//lib/elftools/constants.rb#349
+ELFTools::Constants::EM::EM_TILEGX = T.let(T.unsafe(nil), Integer)
+
+# Tilera TILE64 multicore architecture family
+#
+# source://elftools//lib/elftools/constants.rb#346
+ELFTools::Constants::EM::EM_TILEPRO = T.let(T.unsafe(nil), Integer)
+
+# STMicroelectronics ST100 processor
+#
+# source://elftools//lib/elftools/constants.rb#245
+ELFTools::Constants::EM::EM_TINYJ = T.let(T.unsafe(nil), Integer)
+
+# The Texas Instruments TMS320C55x DSP family
+#
+# source://elftools//lib/elftools/constants.rb#317
+ELFTools::Constants::EM::EM_TI_ARP32 = T.let(T.unsafe(nil), Integer)
+
+# The Texas Instruments TMS320C6000 DSP family
+#
+# source://elftools//lib/elftools/constants.rb#315
+ELFTools::Constants::EM::EM_TI_C2000 = T.let(T.unsafe(nil), Integer)
+
+# The Texas Instruments TMS320C2000 DSP family
+#
+# source://elftools//lib/elftools/constants.rb#316
+ELFTools::Constants::EM::EM_TI_C5500 = T.let(T.unsafe(nil), Integer)
+
+# Seiko Epson C17 family
+#
+# source://elftools//lib/elftools/constants.rb#314
+ELFTools::Constants::EM::EM_TI_C6000 = T.let(T.unsafe(nil), Integer)
+
+# Texas Instruments Application Specific RISC Processor, 32bit fetch
+#
+# source://elftools//lib/elftools/constants.rb#318
+ELFTools::Constants::EM::EM_TI_PRU = T.let(T.unsafe(nil), Integer)
+
+# Alphamosaic VideoCore processor
+#
+# source://elftools//lib/elftools/constants.rb#280
+ELFTools::Constants::EM::EM_TMM_GPP = T.let(T.unsafe(nil), Integer)
+
+# National Semiconductor 32000 series
+#
+# source://elftools//lib/elftools/constants.rb#282
+ELFTools::Constants::EM::EM_TPC = T.let(T.unsafe(nil), Integer)
+
+# SPARC v9 64-bit
+#
+# source://elftools//lib/elftools/constants.rb#228
+ELFTools::Constants::EM::EM_TRICORE = T.let(T.unsafe(nil), Integer)
+
+# Renesas R32C series microprocessors
+#
+# source://elftools//lib/elftools/constants.rb#322
+ELFTools::Constants::EM::EM_TRIMEDIA = T.let(T.unsafe(nil), Integer)
+
+# Freescale Communication Engine RISC core
+#
+# source://elftools//lib/elftools/constants.rb#305
+ELFTools::Constants::EM::EM_TSK3000 = T.let(T.unsafe(nil), Integer)
+
+# ChipON KungFu32
+#
+# source://elftools//lib/elftools/constants.rb#395
+ELFTools::Constants::EM::EM_U16_U8CORE = T.let(T.unsafe(nil), Integer)
+
+# Arca RISC Microprocessor
+#
+# source://elftools//lib/elftools/constants.rb#294
+ELFTools::Constants::EM::EM_UNICORE = T.let(T.unsafe(nil), Integer)
+
+# Cell BE SPU
+#
+# source://elftools//lib/elftools/constants.rb#221
+ELFTools::Constants::EM::EM_V800 = T.let(T.unsafe(nil), Integer)
+
+# Mitsubishi D30V
+#
+# source://elftools//lib/elftools/constants.rb#271
+ELFTools::Constants::EM::EM_V850 = T.let(T.unsafe(nil), Integer)
+
+# STMicroelectronics ST19 8-bit cpu
+#
+# source://elftools//lib/elftools/constants.rb#259
+ELFTools::Constants::EM::EM_VAX = T.let(T.unsafe(nil), Integer)
+
+# Netronome Flow Processor (NFP)
+#
+# source://elftools//lib/elftools/constants.rb#386
+ELFTools::Constants::EM::EM_VE = T.let(T.unsafe(nil), Integer)
+
+# Tensilica Xtensa Architecture
+#
+# source://elftools//lib/elftools/constants.rb#279
+ELFTools::Constants::EM::EM_VIDEOCORE = T.let(T.unsafe(nil), Integer)
+
+# New Japan Radio (NJR) 24-bit DSP Processor
+#
+# source://elftools//lib/elftools/constants.rb#311
+ELFTools::Constants::EM::EM_VIDEOCORE3 = T.let(T.unsafe(nil), Integer)
+
+# Renesas RL78 family
+#
+# source://elftools//lib/elftools/constants.rb#356
+ELFTools::Constants::EM::EM_VIDEOCORE5 = T.let(T.unsafe(nil), Integer)
+
+# Zilog Z80
+#
+# source://elftools//lib/elftools/constants.rb#375
+ELFTools::Constants::EM::EM_VISIUM = T.let(T.unsafe(nil), Integer)
+
+# HPPA
+#
+# source://elftools//lib/elftools/constants.rb#214
+ELFTools::Constants::EM::EM_VPP500 = T.let(T.unsafe(nil), Integer)
+
+# Advanced Logic Corp. TinyJ embedded processor
+#
+# source://elftools//lib/elftools/constants.rb#246
+ELFTools::Constants::EM::EM_X86_64 = T.let(T.unsafe(nil), Integer)
+
+# Beyond BA2 CPU architecture
+#
+# source://elftools//lib/elftools/constants.rb#361
+ELFTools::Constants::EM::EM_XCORE = T.let(T.unsafe(nil), Integer)
+
+# National Semiconductor CRX
+#
+# source://elftools//lib/elftools/constants.rb#299
+ELFTools::Constants::EM::EM_XGATE = T.let(T.unsafe(nil), Integer)
+
+# Dallas Semiconductor MAXQ30 Core Micro-controllers
+#
+# source://elftools//lib/elftools/constants.rb#330
+ELFTools::Constants::EM::EM_XIMO16 = T.let(T.unsafe(nil), Integer)
+
+# ARC International ARCompact processor
+#
+# source://elftools//lib/elftools/constants.rb#278
+ELFTools::Constants::EM::EM_XTENSA = T.let(T.unsafe(nil), Integer)
+
+# CSR Kalimba architecture family
+#
+# source://elftools//lib/elftools/constants.rb#374
+ELFTools::Constants::EM::EM_Z80 = T.let(T.unsafe(nil), Integer)
+
+# Element 14 64-bit DSP processor
+#
+# source://elftools//lib/elftools/constants.rb#263
+ELFTools::Constants::EM::EM_ZSP = T.let(T.unsafe(nil), Integer)
+
+# This module defines ELF file types.
+#
+# source://elftools//lib/elftools/constants.rb#446
+module ELFTools::Constants::ET
+  class << self
+    # Return the type name according to +e_type+ in ELF file header.
+    #
+    # @return [String] Type in string format.
+    #
+    # source://elftools//lib/elftools/constants.rb#454
+    def mapping(type); end
+  end
+end
+
+# core file
+#
+# source://elftools//lib/elftools/constants.rb#451
+ELFTools::Constants::ET::ET_CORE = T.let(T.unsafe(nil), Integer)
+
+# shared object
+#
+# source://elftools//lib/elftools/constants.rb#450
+ELFTools::Constants::ET::ET_DYN = T.let(T.unsafe(nil), Integer)
+
+# executable file
+#
+# source://elftools//lib/elftools/constants.rb#449
+ELFTools::Constants::ET::ET_EXEC = T.let(T.unsafe(nil), Integer)
+
+# no file type
+#
+# source://elftools//lib/elftools/constants.rb#447
+ELFTools::Constants::ET::ET_NONE = T.let(T.unsafe(nil), Integer)
+
+# relocatable file
+#
+# source://elftools//lib/elftools/constants.rb#448
+ELFTools::Constants::ET::ET_REL = T.let(T.unsafe(nil), Integer)
+
+# Program header permission flags, records bitwise OR value in +p_flags+.
+#
+# source://elftools//lib/elftools/constants.rb#468
+module ELFTools::Constants::PF; end
+
+# readable
+#
+# source://elftools//lib/elftools/constants.rb#471
+ELFTools::Constants::PF::PF_R = T.let(T.unsafe(nil), Integer)
+
+# writable
+#
+# source://elftools//lib/elftools/constants.rb#470
+ELFTools::Constants::PF::PF_W = T.let(T.unsafe(nil), Integer)
+
+# executable
+#
+# source://elftools//lib/elftools/constants.rb#469
+ELFTools::Constants::PF::PF_X = T.let(T.unsafe(nil), Integer)
+
+# Program header types, records in +p_type+.
+#
+# source://elftools//lib/elftools/constants.rb#476
+module ELFTools::Constants::PT; end
+
+# platform architecture compatibility information
+#
+# source://elftools//lib/elftools/constants.rb#509
+ELFTools::Constants::PT::PT_AARCH64_ARCHEXT = T.let(T.unsafe(nil), Integer)
+
+# exception unwind tables
+#
+# source://elftools//lib/elftools/constants.rb#510
+ELFTools::Constants::PT::PT_AARCH64_UNWIND = T.let(T.unsafe(nil), Integer)
+
+# platform architecture compatibility information
+#
+# source://elftools//lib/elftools/constants.rb#501
+ELFTools::Constants::PT::PT_ARM_ARCHEXT = T.let(T.unsafe(nil), Integer)
+
+# exception unwind tables
+#
+# source://elftools//lib/elftools/constants.rb#502
+ELFTools::Constants::PT::PT_ARM_EXIDX = T.let(T.unsafe(nil), Integer)
+
+# dynamic tags
+#
+# source://elftools//lib/elftools/constants.rb#479
+ELFTools::Constants::PT::PT_DYNAMIC = T.let(T.unsafe(nil), Integer)
+
+# for exception handler
+#
+# source://elftools//lib/elftools/constants.rb#487
+ELFTools::Constants::PT::PT_GNU_EH_FRAME = T.let(T.unsafe(nil), Integer)
+
+# Mbind segments (upper bound)
+#
+# source://elftools//lib/elftools/constants.rb#491
+ELFTools::Constants::PT::PT_GNU_MBIND_HI = T.let(T.unsafe(nil), Integer)
+
+# Mbind segments (lower bound)
+#
+# source://elftools//lib/elftools/constants.rb#492
+ELFTools::Constants::PT::PT_GNU_MBIND_LO = T.let(T.unsafe(nil), Integer)
+
+# GNU property
+#
+# source://elftools//lib/elftools/constants.rb#490
+ELFTools::Constants::PT::PT_GNU_PROPERTY = T.let(T.unsafe(nil), Integer)
+
+# read only after relocation
+#
+# source://elftools//lib/elftools/constants.rb#489
+ELFTools::Constants::PT::PT_GNU_RELRO = T.let(T.unsafe(nil), Integer)
+
+# permission of stack
+#
+# source://elftools//lib/elftools/constants.rb#488
+ELFTools::Constants::PT::PT_GNU_STACK = T.let(T.unsafe(nil), Integer)
+
+# OS-specific
+#
+# source://elftools//lib/elftools/constants.rb#496
+ELFTools::Constants::PT::PT_HIOS = T.let(T.unsafe(nil), Integer)
+
+# see {PT_LOPROC}
+#
+# source://elftools//lib/elftools/constants.rb#514
+ELFTools::Constants::PT::PT_HIPROC = T.let(T.unsafe(nil), Integer)
+
+# interpreter, same as .interp section
+#
+# source://elftools//lib/elftools/constants.rb#480
+ELFTools::Constants::PT::PT_INTERP = T.let(T.unsafe(nil), Integer)
+
+# segment to be load
+#
+# source://elftools//lib/elftools/constants.rb#478
+ELFTools::Constants::PT::PT_LOAD = T.let(T.unsafe(nil), Integer)
+
+# OS-specific
+#
+# source://elftools//lib/elftools/constants.rb#486
+ELFTools::Constants::PT::PT_LOOS = T.let(T.unsafe(nil), Integer)
+
+# Values between {PT_LOPROC} and {PT_HIPROC} are reserved for processor-specific semantics.
+#
+# source://elftools//lib/elftools/constants.rb#499
+ELFTools::Constants::PT::PT_LOPROC = T.let(T.unsafe(nil), Integer)
+
+# +.MIPS.abiflags+ section
+#
+# source://elftools//lib/elftools/constants.rb#507
+ELFTools::Constants::PT::PT_MIPS_ABIFLAGS = T.let(T.unsafe(nil), Integer)
+
+# +.MIPS.options+ section
+#
+# source://elftools//lib/elftools/constants.rb#506
+ELFTools::Constants::PT::PT_MIPS_OPTIONS = T.let(T.unsafe(nil), Integer)
+
+# register usage information
+#
+# source://elftools//lib/elftools/constants.rb#504
+ELFTools::Constants::PT::PT_MIPS_REGINFO = T.let(T.unsafe(nil), Integer)
+
+# runtime procedure table
+#
+# source://elftools//lib/elftools/constants.rb#505
+ELFTools::Constants::PT::PT_MIPS_RTPROC = T.let(T.unsafe(nil), Integer)
+
+# same as .note* section
+#
+# source://elftools//lib/elftools/constants.rb#481
+ELFTools::Constants::PT::PT_NOTE = T.let(T.unsafe(nil), Integer)
+
+# null segment
+#
+# source://elftools//lib/elftools/constants.rb#477
+ELFTools::Constants::PT::PT_NULL = T.let(T.unsafe(nil), Integer)
+
+# Section for boot arguments
+#
+# source://elftools//lib/elftools/constants.rb#495
+ELFTools::Constants::PT::PT_OPENBSD_BOOTDATA = T.let(T.unsafe(nil), Integer)
+
+# Fill with random data
+#
+# source://elftools//lib/elftools/constants.rb#493
+ELFTools::Constants::PT::PT_OPENBSD_RANDOMIZE = T.let(T.unsafe(nil), Integer)
+
+# Program does W^X violations
+#
+# source://elftools//lib/elftools/constants.rb#494
+ELFTools::Constants::PT::PT_OPENBSD_WXNEEDED = T.let(T.unsafe(nil), Integer)
+
+# where program header starts
+#
+# source://elftools//lib/elftools/constants.rb#483
+ELFTools::Constants::PT::PT_PHDR = T.let(T.unsafe(nil), Integer)
+
+# 4k page table size
+#
+# source://elftools//lib/elftools/constants.rb#512
+ELFTools::Constants::PT::PT_S390_PGSTE = T.let(T.unsafe(nil), Integer)
+
+# reserved
+#
+# source://elftools//lib/elftools/constants.rb#482
+ELFTools::Constants::PT::PT_SHLIB = T.let(T.unsafe(nil), Integer)
+
+# thread local storage segment
+#
+# source://elftools//lib/elftools/constants.rb#484
+ELFTools::Constants::PT::PT_TLS = T.let(T.unsafe(nil), Integer)
+
+# Section flag mask types, records in +sh_flag+.
+#
+# source://elftools//lib/elftools/constants.rb#548
+module ELFTools::Constants::SHF; end
+
+# Occupies memory during execution
+#
+# source://elftools//lib/elftools/constants.rb#550
+ELFTools::Constants::SHF::SHF_ALLOC = T.let(T.unsafe(nil), Integer)
+
+# Section with compressed data.
+#
+# source://elftools//lib/elftools/constants.rb#559
+ELFTools::Constants::SHF::SHF_COMPRESSED = T.let(T.unsafe(nil), Integer)
+
+# Section is excluded unless referenced or allocated (Solaris).
+#
+# source://elftools//lib/elftools/constants.rb#565
+ELFTools::Constants::SHF::SHF_EXCLUDE = T.let(T.unsafe(nil), Integer)
+
+# Executable
+#
+# source://elftools//lib/elftools/constants.rb#551
+ELFTools::Constants::SHF::SHF_EXECINSTR = T.let(T.unsafe(nil), Integer)
+
+# Mbind section
+#
+# source://elftools//lib/elftools/constants.rb#563
+ELFTools::Constants::SHF::SHF_GNU_MBIND = T.let(T.unsafe(nil), Integer)
+
+# Not to be GCed by linker.
+#
+# source://elftools//lib/elftools/constants.rb#562
+ELFTools::Constants::SHF::SHF_GNU_RETAIN = T.let(T.unsafe(nil), Integer)
+
+# Section is member of a group.
+#
+# source://elftools//lib/elftools/constants.rb#557
+ELFTools::Constants::SHF::SHF_GROUP = T.let(T.unsafe(nil), Integer)
+
+# `sh_info' contains SHT index
+#
+# source://elftools//lib/elftools/constants.rb#554
+ELFTools::Constants::SHF::SHF_INFO_LINK = T.let(T.unsafe(nil), Integer)
+
+# Preserve order after combining
+#
+# source://elftools//lib/elftools/constants.rb#555
+ELFTools::Constants::SHF::SHF_LINK_ORDER = T.let(T.unsafe(nil), Integer)
+
+# OS-specific.
+#
+# source://elftools//lib/elftools/constants.rb#560
+ELFTools::Constants::SHF::SHF_MASKOS = T.let(T.unsafe(nil), Integer)
+
+# Processor-specific
+#
+# source://elftools//lib/elftools/constants.rb#561
+ELFTools::Constants::SHF::SHF_MASKPROC = T.let(T.unsafe(nil), Integer)
+
+# Might be merged
+#
+# source://elftools//lib/elftools/constants.rb#552
+ELFTools::Constants::SHF::SHF_MERGE = T.let(T.unsafe(nil), Integer)
+
+# Special ordering requirement
+#
+# source://elftools//lib/elftools/constants.rb#564
+ELFTools::Constants::SHF::SHF_ORDERED = T.let(T.unsafe(nil), Integer)
+
+# Non-standard OS specific handling required
+#
+# source://elftools//lib/elftools/constants.rb#556
+ELFTools::Constants::SHF::SHF_OS_NONCONFORMING = T.let(T.unsafe(nil), Integer)
+
+# Contains nul-terminated strings
+#
+# source://elftools//lib/elftools/constants.rb#553
+ELFTools::Constants::SHF::SHF_STRINGS = T.let(T.unsafe(nil), Integer)
+
+# Section hold thread-local data.
+#
+# source://elftools//lib/elftools/constants.rb#558
+ELFTools::Constants::SHF::SHF_TLS = T.let(T.unsafe(nil), Integer)
+
+# Writable
+#
+# source://elftools//lib/elftools/constants.rb#549
+ELFTools::Constants::SHF::SHF_WRITE = T.let(T.unsafe(nil), Integer)
+
+# Special indices to section. These are used when there is no valid index to section header.
+# The meaning of these values is left upto the embedding header.
+#
+# source://elftools//lib/elftools/constants.rb#520
+module ELFTools::Constants::SHN; end
+
+# specifies absolute values for the corresponding reference
+#
+# source://elftools//lib/elftools/constants.rb#540
+ELFTools::Constants::SHN::SHN_ABS = T.let(T.unsafe(nil), Integer)
+
+# symbols defined relative to this section are common symbols
+#
+# source://elftools//lib/elftools/constants.rb#541
+ELFTools::Constants::SHN::SHN_COMMON = T.let(T.unsafe(nil), Integer)
+
+# see {SHN_LOOS}
+#
+# source://elftools//lib/elftools/constants.rb#539
+ELFTools::Constants::SHN::SHN_HIOS = T.let(T.unsafe(nil), Integer)
+
+# see {SHN_LOPROC}
+#
+# source://elftools//lib/elftools/constants.rb#535
+ELFTools::Constants::SHN::SHN_HIPROC = T.let(T.unsafe(nil), Integer)
+
+# end of reserved indices
+#
+# source://elftools//lib/elftools/constants.rb#543
+ELFTools::Constants::SHN::SHN_HIRESERVE = T.let(T.unsafe(nil), Integer)
+
+# Values between {SHN_LOOS} and {SHN_HIOS} are reserved for operating system-specific semantics.
+#
+# source://elftools//lib/elftools/constants.rb#538
+ELFTools::Constants::SHN::SHN_LOOS = T.let(T.unsafe(nil), Integer)
+
+# Values between {SHN_LOPROC} and {SHN_HIPROC} are reserved for processor-specific semantics.
+#
+# source://elftools//lib/elftools/constants.rb#525
+ELFTools::Constants::SHN::SHN_LOPROC = T.let(T.unsafe(nil), Integer)
+
+# start of reserved indices
+#
+# source://elftools//lib/elftools/constants.rb#522
+ELFTools::Constants::SHN::SHN_LORESERVE = T.let(T.unsafe(nil), Integer)
+
+# defined and allocated common symbol
+#
+# source://elftools//lib/elftools/constants.rb#527
+ELFTools::Constants::SHN::SHN_MIPS_ACOMMON = T.let(T.unsafe(nil), Integer)
+
+# defined and allocated data symbol
+#
+# source://elftools//lib/elftools/constants.rb#529
+ELFTools::Constants::SHN::SHN_MIPS_DATA = T.let(T.unsafe(nil), Integer)
+
+# small common symbol
+#
+# source://elftools//lib/elftools/constants.rb#530
+ELFTools::Constants::SHN::SHN_MIPS_SCOMMON = T.let(T.unsafe(nil), Integer)
+
+# small undefined symbol
+#
+# source://elftools//lib/elftools/constants.rb#531
+ELFTools::Constants::SHN::SHN_MIPS_SUNDEFINED = T.let(T.unsafe(nil), Integer)
+
+# defined and allocated text symbol
+#
+# source://elftools//lib/elftools/constants.rb#528
+ELFTools::Constants::SHN::SHN_MIPS_TEXT = T.let(T.unsafe(nil), Integer)
+
+# undefined section
+#
+# source://elftools//lib/elftools/constants.rb#521
+ELFTools::Constants::SHN::SHN_UNDEF = T.let(T.unsafe(nil), Integer)
+
+# large common symbol
+#
+# source://elftools//lib/elftools/constants.rb#533
+ELFTools::Constants::SHN::SHN_X86_64_LCOMMON = T.let(T.unsafe(nil), Integer)
+
+# escape value indicating that the actual section header index is too large to fit
+#
+# source://elftools//lib/elftools/constants.rb#542
+ELFTools::Constants::SHN::SHN_XINDEX = T.let(T.unsafe(nil), Integer)
+
+# Section header types, records in +sh_type+.
+#
+# source://elftools//lib/elftools/constants.rb#570
+module ELFTools::Constants::SHT; end
+
+# source://elftools//lib/elftools/constants.rb#661
+ELFTools::Constants::SHT::SHT_AARCH64_ATTRIBUTES = T.let(T.unsafe(nil), Integer)
+
+# object file compatibility attributes
+#
+# source://elftools//lib/elftools/constants.rb#614
+ELFTools::Constants::SHT::SHT_ARM_ATTRIBUTES = T.let(T.unsafe(nil), Integer)
+
+# support for debugging overlaid programs
+#
+# source://elftools//lib/elftools/constants.rb#615
+ELFTools::Constants::SHT::SHT_ARM_DEBUGOVERLAY = T.let(T.unsafe(nil), Integer)
+
+# exception index table
+#
+# source://elftools//lib/elftools/constants.rb#612
+ELFTools::Constants::SHT::SHT_ARM_EXIDX = T.let(T.unsafe(nil), Integer)
+
+# support for debugging overlaid programs
+#
+# source://elftools//lib/elftools/constants.rb#616
+ELFTools::Constants::SHT::SHT_ARM_OVERLAYSECTION = T.let(T.unsafe(nil), Integer)
+
+# BPABI DLL dynamic linking pre-emption map
+#
+# source://elftools//lib/elftools/constants.rb#613
+ELFTools::Constants::SHT::SHT_ARM_PREEMPTMAP = T.let(T.unsafe(nil), Integer)
+
+# object file compatibility attributes
+#
+# source://elftools//lib/elftools/constants.rb#663
+ELFTools::Constants::SHT::SHT_CSKY_ATTRIBUTES = T.let(T.unsafe(nil), Integer)
+
+# information of dynamic linking
+#
+# source://elftools//lib/elftools/constants.rb#577
+ELFTools::Constants::SHT::SHT_DYNAMIC = T.let(T.unsafe(nil), Integer)
+
+# symbols for dynamic
+#
+# source://elftools//lib/elftools/constants.rb#582
+ELFTools::Constants::SHT::SHT_DYNSYM = T.let(T.unsafe(nil), Integer)
+
+# array of termination functions
+#
+# source://elftools//lib/elftools/constants.rb#584
+ELFTools::Constants::SHT::SHT_FINI_ARRAY = T.let(T.unsafe(nil), Integer)
+
+# object attributes
+#
+# source://elftools//lib/elftools/constants.rb#596
+ELFTools::Constants::SHT::SHT_GNU_ATTRIBUTES = T.let(T.unsafe(nil), Integer)
+
+# GNU style symbol hash table
+#
+# source://elftools//lib/elftools/constants.rb#597
+ELFTools::Constants::SHT::SHT_GNU_HASH = T.let(T.unsafe(nil), Integer)
+
+# incremental build data
+#
+# source://elftools//lib/elftools/constants.rb#595
+ELFTools::Constants::SHT::SHT_GNU_INCREMENTAL_GOT_PLT = T.let(T.unsafe(nil), Integer)
+
+# incremental build data
+#
+# source://elftools//lib/elftools/constants.rb#592
+ELFTools::Constants::SHT::SHT_GNU_INCREMENTAL_INPUTS = T.let(T.unsafe(nil), Integer)
+
+# incremental build data
+#
+# source://elftools//lib/elftools/constants.rb#594
+ELFTools::Constants::SHT::SHT_GNU_INCREMENTAL_RELOCS = T.let(T.unsafe(nil), Integer)
+
+# incremental build data
+#
+# source://elftools//lib/elftools/constants.rb#593
+ELFTools::Constants::SHT::SHT_GNU_INCREMENTAL_SYMTAB = T.let(T.unsafe(nil), Integer)
+
+# list of prelink dependencies
+#
+# source://elftools//lib/elftools/constants.rb#598
+ELFTools::Constants::SHT::SHT_GNU_LIBLIST = T.let(T.unsafe(nil), Integer)
+
+# versions defined by file
+#
+# source://elftools//lib/elftools/constants.rb#600
+ELFTools::Constants::SHT::SHT_GNU_verdef = T.let(T.unsafe(nil), Integer)
+
+# versions needed by file
+#
+# source://elftools//lib/elftools/constants.rb#602
+ELFTools::Constants::SHT::SHT_GNU_verneed = T.let(T.unsafe(nil), Integer)
+
+# symbol versions
+#
+# source://elftools//lib/elftools/constants.rb#604
+ELFTools::Constants::SHT::SHT_GNU_versym = T.let(T.unsafe(nil), Integer)
+
+# section group
+#
+# source://elftools//lib/elftools/constants.rb#586
+ELFTools::Constants::SHT::SHT_GROUP = T.let(T.unsafe(nil), Integer)
+
+# symbol hash table
+#
+# source://elftools//lib/elftools/constants.rb#576
+ELFTools::Constants::SHT::SHT_HASH = T.let(T.unsafe(nil), Integer)
+
+# see {SHT_LOOS}
+#
+# source://elftools//lib/elftools/constants.rb#605
+ELFTools::Constants::SHT::SHT_HIOS = T.let(T.unsafe(nil), Integer)
+
+# see {SHT_LOPROC}
+#
+# source://elftools//lib/elftools/constants.rb#667
+ELFTools::Constants::SHT::SHT_HIPROC = T.let(T.unsafe(nil), Integer)
+
+# see {SHT_LOUSER}
+#
+# source://elftools//lib/elftools/constants.rb#671
+ELFTools::Constants::SHT::SHT_HIUSER = T.let(T.unsafe(nil), Integer)
+
+# array of initialization functions
+#
+# source://elftools//lib/elftools/constants.rb#583
+ELFTools::Constants::SHT::SHT_INIT_ARRAY = T.let(T.unsafe(nil), Integer)
+
+# Values between {SHT_LOOS} and {SHT_HIOS} are reserved for operating system-specific semantics.
+#
+# source://elftools//lib/elftools/constants.rb#591
+ELFTools::Constants::SHT::SHT_LOOS = T.let(T.unsafe(nil), Integer)
+
+# Values between {SHT_LOPROC} and {SHT_HIPROC} are reserved for processor-specific semantics.
+#
+# source://elftools//lib/elftools/constants.rb#608
+ELFTools::Constants::SHT::SHT_LOPROC = T.let(T.unsafe(nil), Integer)
+
+# Values between {SHT_LOUSER} and {SHT_HIUSER} are reserved for application programs.
+#
+# source://elftools//lib/elftools/constants.rb#670
+ELFTools::Constants::SHT::SHT_LOUSER = T.let(T.unsafe(nil), Integer)
+
+# ABI related flags
+#
+# source://elftools//lib/elftools/constants.rb#658
+ELFTools::Constants::SHT::SHT_MIPS_ABIFLAGS = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#639
+ELFTools::Constants::SHT::SHT_MIPS_AUXSYM = T.let(T.unsafe(nil), Integer)
+
+# list of symbols whose definitions conflict with shared objects
+#
+# source://elftools//lib/elftools/constants.rb#622
+ELFTools::Constants::SHT::SHT_MIPS_CONFLICT = T.let(T.unsafe(nil), Integer)
+
+# description of contents of another section
+#
+# source://elftools//lib/elftools/constants.rb#631
+ELFTools::Constants::SHT::SHT_MIPS_CONTENT = T.let(T.unsafe(nil), Integer)
+
+# register usage information
+#
+# source://elftools//lib/elftools/constants.rb#625
+ELFTools::Constants::SHT::SHT_MIPS_DEBUG = T.let(T.unsafe(nil), Integer)
+
+# delta C++ class table
+#
+# source://elftools//lib/elftools/constants.rb#646
+ELFTools::Constants::SHT::SHT_MIPS_DELTACLASS = T.let(T.unsafe(nil), Integer)
+
+# delta C++ declarations
+#
+# source://elftools//lib/elftools/constants.rb#648
+ELFTools::Constants::SHT::SHT_MIPS_DELTADECL = T.let(T.unsafe(nil), Integer)
+
+# delta C++ instance table
+#
+# source://elftools//lib/elftools/constants.rb#645
+ELFTools::Constants::SHT::SHT_MIPS_DELTAINST = T.let(T.unsafe(nil), Integer)
+
+# delta C++ symbol table
+#
+# source://elftools//lib/elftools/constants.rb#644
+ELFTools::Constants::SHT::SHT_MIPS_DELTASYM = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#636
+ELFTools::Constants::SHT::SHT_MIPS_DENSE = T.let(T.unsafe(nil), Integer)
+
+# DWARF debugging section
+#
+# source://elftools//lib/elftools/constants.rb#647
+ELFTools::Constants::SHT::SHT_MIPS_DWARF = T.let(T.unsafe(nil), Integer)
+
+# C++ exception handling region info
+#
+# source://elftools//lib/elftools/constants.rb#656
+ELFTools::Constants::SHT::SHT_MIPS_EH_REGION = T.let(T.unsafe(nil), Integer)
+
+# events section
+#
+# source://elftools//lib/elftools/constants.rb#650
+ELFTools::Constants::SHT::SHT_MIPS_EVENTS = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#635
+ELFTools::Constants::SHT::SHT_MIPS_EXTSYM = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#634
+ELFTools::Constants::SHT::SHT_MIPS_FDESC = T.let(T.unsafe(nil), Integer)
+
+# global pointer table
+#
+# source://elftools//lib/elftools/constants.rb#623
+ELFTools::Constants::SHT::SHT_MIPS_GPTAB = T.let(T.unsafe(nil), Integer)
+
+# interface information
+#
+# source://elftools//lib/elftools/constants.rb#630
+ELFTools::Constants::SHT::SHT_MIPS_IFACE = T.let(T.unsafe(nil), Integer)
+
+# set of dynamic shared objects
+#
+# source://elftools//lib/elftools/constants.rb#620
+ELFTools::Constants::SHT::SHT_MIPS_LIBLIST = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#642
+ELFTools::Constants::SHT::SHT_MIPS_LINE = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#641
+ELFTools::Constants::SHT::SHT_MIPS_LOCSTR = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#638
+ELFTools::Constants::SHT::SHT_MIPS_LOCSYM = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#621
+ELFTools::Constants::SHT::SHT_MIPS_MSYM = T.let(T.unsafe(nil), Integer)
+
+# miscellaneous options
+#
+# source://elftools//lib/elftools/constants.rb#632
+ELFTools::Constants::SHT::SHT_MIPS_OPTIONS = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#640
+ELFTools::Constants::SHT::SHT_MIPS_OPTSYM = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#627
+ELFTools::Constants::SHT::SHT_MIPS_PACKAGE = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#628
+ELFTools::Constants::SHT::SHT_MIPS_PACKSYM = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#637
+ELFTools::Constants::SHT::SHT_MIPS_PDESC = T.let(T.unsafe(nil), Integer)
+
+# runtime procedure descriptor table exception information
+#
+# source://elftools//lib/elftools/constants.rb#657
+ELFTools::Constants::SHT::SHT_MIPS_PDR_EXCEPTION = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#652
+ELFTools::Constants::SHT::SHT_MIPS_PIXIE = T.let(T.unsafe(nil), Integer)
+
+# section contains register usage information
+#
+# source://elftools//lib/elftools/constants.rb#626
+ELFTools::Constants::SHT::SHT_MIPS_REGINFO = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#629
+ELFTools::Constants::SHT::SHT_MIPS_RELD = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#643
+ELFTools::Constants::SHT::SHT_MIPS_RFDESC = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#633
+ELFTools::Constants::SHT::SHT_MIPS_SHDR = T.let(T.unsafe(nil), Integer)
+
+# list of libraries the binary depends on
+#
+# source://elftools//lib/elftools/constants.rb#649
+ELFTools::Constants::SHT::SHT_MIPS_SYMBOL_LIB = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#651
+ELFTools::Constants::SHT::SHT_MIPS_TRANSLATE = T.let(T.unsafe(nil), Integer)
+
+# microcode information
+#
+# source://elftools//lib/elftools/constants.rb#624
+ELFTools::Constants::SHT::SHT_MIPS_UCODE = T.let(T.unsafe(nil), Integer)
+
+# intermediate code
+#
+# source://elftools//lib/elftools/constants.rb#655
+ELFTools::Constants::SHT::SHT_MIPS_WHIRL = T.let(T.unsafe(nil), Integer)
+
+# GNU style symbol hash table with xlat
+#
+# source://elftools//lib/elftools/constants.rb#659
+ELFTools::Constants::SHT::SHT_MIPS_XHASH = T.let(T.unsafe(nil), Integer)
+
+# address translation table
+#
+# source://elftools//lib/elftools/constants.rb#653
+ELFTools::Constants::SHT::SHT_MIPS_XLATE = T.let(T.unsafe(nil), Integer)
+
+# SGI internal address translation table
+#
+# source://elftools//lib/elftools/constants.rb#654
+ELFTools::Constants::SHT::SHT_MIPS_XLATE_DEBUG = T.let(T.unsafe(nil), Integer)
+
+# section occupies no space
+#
+# source://elftools//lib/elftools/constants.rb#579
+ELFTools::Constants::SHT::SHT_NOBITS = T.let(T.unsafe(nil), Integer)
+
+# section for notes
+#
+# source://elftools//lib/elftools/constants.rb#578
+ELFTools::Constants::SHT::SHT_NOTE = T.let(T.unsafe(nil), Integer)
+
+# null section
+#
+# source://elftools//lib/elftools/constants.rb#571
+ELFTools::Constants::SHT::SHT_NULL = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#665
+ELFTools::Constants::SHT::SHT_ORDERED = T.let(T.unsafe(nil), Integer)
+
+# array of functions that are invoked before all other initialization functions
+#
+# source://elftools//lib/elftools/constants.rb#585
+ELFTools::Constants::SHT::SHT_PREINIT_ARRAY = T.let(T.unsafe(nil), Integer)
+
+# information defined by program itself
+#
+# source://elftools//lib/elftools/constants.rb#572
+ELFTools::Constants::SHT::SHT_PROGBITS = T.let(T.unsafe(nil), Integer)
+
+# relocation
+#
+# source://elftools//lib/elftools/constants.rb#580
+ELFTools::Constants::SHT::SHT_REL = T.let(T.unsafe(nil), Integer)
+
+# relocation with addends
+#
+# source://elftools//lib/elftools/constants.rb#575
+ELFTools::Constants::SHT::SHT_RELA = T.let(T.unsafe(nil), Integer)
+
+# RELR relative relocations
+#
+# source://elftools//lib/elftools/constants.rb#588
+ELFTools::Constants::SHT::SHT_RELR = T.let(T.unsafe(nil), Integer)
+
+# reserved
+#
+# source://elftools//lib/elftools/constants.rb#581
+ELFTools::Constants::SHT::SHT_SHLIB = T.let(T.unsafe(nil), Integer)
+
+# source://elftools//lib/elftools/constants.rb#610
+ELFTools::Constants::SHT::SHT_SPARC_GOTDATA = T.let(T.unsafe(nil), Integer)
+
+# string table section
+#
+# source://elftools//lib/elftools/constants.rb#574
+ELFTools::Constants::SHT::SHT_STRTAB = T.let(T.unsafe(nil), Integer)
+
+# versions defined by file
+#
+# source://elftools//lib/elftools/constants.rb#599
+ELFTools::Constants::SHT::SHT_SUNW_verdef = T.let(T.unsafe(nil), Integer)
+
+# versions needed by file
+#
+# source://elftools//lib/elftools/constants.rb#601
+ELFTools::Constants::SHT::SHT_SUNW_verneed = T.let(T.unsafe(nil), Integer)
+
+# symbol versions
+#
+# source://elftools//lib/elftools/constants.rb#603
+ELFTools::Constants::SHT::SHT_SUNW_versym = T.let(T.unsafe(nil), Integer)
+
+# symbol table section
+#
+# source://elftools//lib/elftools/constants.rb#573
+ELFTools::Constants::SHT::SHT_SYMTAB = T.let(T.unsafe(nil), Integer)
+
+# indices for SHN_XINDEX entries
+#
+# source://elftools//lib/elftools/constants.rb#587
+ELFTools::Constants::SHT::SHT_SYMTAB_SHNDX = T.let(T.unsafe(nil), Integer)
+
+# x86_64 unwind information
+#
+# source://elftools//lib/elftools/constants.rb#618
+ELFTools::Constants::SHT::SHT_X86_64_UNWIND = T.let(T.unsafe(nil), Integer)
+
+# Symbol binding from Sym st_info field.
+#
+# source://elftools//lib/elftools/constants.rb#676
+module ELFTools::Constants::STB; end
+
+# Global symbol
+#
+# source://elftools//lib/elftools/constants.rb#678
+ELFTools::Constants::STB::STB_GLOBAL = T.let(T.unsafe(nil), Integer)
+
+# Unique symbol.
+#
+# source://elftools//lib/elftools/constants.rb#682
+ELFTools::Constants::STB::STB_GNU_UNIQUE = T.let(T.unsafe(nil), Integer)
+
+# End of OS-specific
+#
+# source://elftools//lib/elftools/constants.rb#683
+ELFTools::Constants::STB::STB_HIOS = T.let(T.unsafe(nil), Integer)
+
+# End of processor-specific
+#
+# source://elftools//lib/elftools/constants.rb#685
+ELFTools::Constants::STB::STB_HIPROC = T.let(T.unsafe(nil), Integer)
+
+# Local symbol
+#
+# source://elftools//lib/elftools/constants.rb#677
+ELFTools::Constants::STB::STB_LOCAL = T.let(T.unsafe(nil), Integer)
+
+# Start of OS-specific
+#
+# source://elftools//lib/elftools/constants.rb#681
+ELFTools::Constants::STB::STB_LOOS = T.let(T.unsafe(nil), Integer)
+
+# Start of processor-specific
+#
+# source://elftools//lib/elftools/constants.rb#684
+ELFTools::Constants::STB::STB_LOPROC = T.let(T.unsafe(nil), Integer)
+
+# Number of defined types.
+#
+# source://elftools//lib/elftools/constants.rb#680
+ELFTools::Constants::STB::STB_NUM = T.let(T.unsafe(nil), Integer)
+
+# Weak symbol
+#
+# source://elftools//lib/elftools/constants.rb#679
+ELFTools::Constants::STB::STB_WEAK = T.let(T.unsafe(nil), Integer)
+
+# Symbol types from Sym st_info field.
+#
+# source://elftools//lib/elftools/constants.rb#690
+module ELFTools::Constants::STT; end
+
+# ARM: a THUMB label.
+#
+# source://elftools//lib/elftools/constants.rb#718
+ELFTools::Constants::STT::STT_ARM_16BIT = T.let(T.unsafe(nil), Integer)
+
+# ARM: a THUMB function. This is not defined in ARM ELF Specification but
+# used by the GNU tool-chain.
+#
+# source://elftools//lib/elftools/constants.rb#717
+ELFTools::Constants::STT::STT_ARM_TFUNC = T.let(T.unsafe(nil), Integer)
+
+# Symbol is a common data object
+#
+# source://elftools//lib/elftools/constants.rb#696
+ELFTools::Constants::STT::STT_COMMON = T.let(T.unsafe(nil), Integer)
+
+# Symbol's name is file name
+#
+# source://elftools//lib/elftools/constants.rb#695
+ELFTools::Constants::STT::STT_FILE = T.let(T.unsafe(nil), Integer)
+
+# Symbol is a code object
+#
+# source://elftools//lib/elftools/constants.rb#693
+ELFTools::Constants::STT::STT_FUNC = T.let(T.unsafe(nil), Integer)
+
+# GNU extension: symbol value points to a function which is called
+# at runtime to determine the final value of the symbol.
+#
+# source://elftools//lib/elftools/constants.rb#704
+ELFTools::Constants::STT::STT_GNU_IFUNC = T.let(T.unsafe(nil), Integer)
+
+# End of OS-specific
+#
+# source://elftools//lib/elftools/constants.rb#707
+ELFTools::Constants::STT::STT_HIOS = T.let(T.unsafe(nil), Integer)
+
+# End of processor-specific
+#
+# source://elftools//lib/elftools/constants.rb#709
+ELFTools::Constants::STT::STT_HIPROC = T.let(T.unsafe(nil), Integer)
+
+# Start of OS-specific
+#
+# source://elftools//lib/elftools/constants.rb#706
+ELFTools::Constants::STT::STT_LOOS = T.let(T.unsafe(nil), Integer)
+
+# Start of processor-specific
+#
+# source://elftools//lib/elftools/constants.rb#708
+ELFTools::Constants::STT::STT_LOPROC = T.let(T.unsafe(nil), Integer)
+
+# Symbol type is unspecified
+#
+# source://elftools//lib/elftools/constants.rb#691
+ELFTools::Constants::STT::STT_NOTYPE = T.let(T.unsafe(nil), Integer)
+
+# Deprecated.
+#
+# source://elftools//lib/elftools/constants.rb#698
+ELFTools::Constants::STT::STT_NUM = T.let(T.unsafe(nil), Integer)
+
+# Symbol is a data object
+#
+# source://elftools//lib/elftools/constants.rb#692
+ELFTools::Constants::STT::STT_OBJECT = T.let(T.unsafe(nil), Integer)
+
+# Complex relocation expression
+#
+# source://elftools//lib/elftools/constants.rb#699
+ELFTools::Constants::STT::STT_RELC = T.let(T.unsafe(nil), Integer)
+
+# Symbol associated with a section
+#
+# source://elftools//lib/elftools/constants.rb#694
+ELFTools::Constants::STT::STT_SECTION = T.let(T.unsafe(nil), Integer)
+
+# The section type that must be used for register symbols on
+# Sparc. These symbols initialize a global register.
+#
+# source://elftools//lib/elftools/constants.rb#713
+ELFTools::Constants::STT::STT_SPARC_REGISTER = T.let(T.unsafe(nil), Integer)
+
+# Signed Complex relocation expression
+#
+# source://elftools//lib/elftools/constants.rb#700
+ELFTools::Constants::STT::STT_SRELC = T.let(T.unsafe(nil), Integer)
+
+# Symbol is thread-local data object
+#
+# source://elftools//lib/elftools/constants.rb#697
+ELFTools::Constants::STT::STT_TLS = T.let(T.unsafe(nil), Integer)
+
+# Define common methods for dynamic sections and dynamic segments.
+#
+# @note This module can only be included by {ELFTools::Sections::DynamicSection}
+#   and {ELFTools::Segments::DynamicSegment} because methods here assume some
+#   attributes exist.
+#
+# source://elftools//lib/elftools/dynamic.rb#10
+module ELFTools::Dynamic
+  # Iterate all tags.
+  #
+  # @note This method assume the following methods already exist:
+  #   header
+  #   tag_start
+  # @return [Enumerator<ELFTools::Dynamic::Tag>, Array<ELFTools::Dynamic::Tag>] If block is not given, an enumerator will be returned.
+  #   Otherwise, return array of tags.
+  # @yieldparam tag [ELFTools::Dynamic::Tag]
+  #
+  # source://elftools//lib/elftools/dynamic.rb#21
+  def each_tags(&block); end
+
+  # Get the +n+-th tag.
+  #
+  # Tags are lazy loaded.
+  #
+  # @note This method assume the following methods already exist:
+  #   header
+  #   tag_start
+  # @note We cannot do bound checking of +n+ here since the only way to get size
+  #   of tags is calling +tags.size+.
+  # @param n [Integer] The index.
+  # @return [ELFTools::Dynamic::Tag] The desired tag.
+  #
+  # source://elftools//lib/elftools/dynamic.rb#93
+  def tag_at(n); end
+
+  # Get a tag of specific type.
+  #
+  # @example
+  #   dynamic = elf.segment_by_type(:dynamic)
+  #   # type as integer
+  #   dynamic.tag_by_type(0) # the null tag
+  #   #=>  #<ELFTools::Dynamic::Tag:0x0055b5a5ecad28 @header={:d_tag=>0, :d_val=>0}>
+  #   dynamic.tag_by_type(ELFTools::Constants::DT_NULL)
+  #   #=>  #<ELFTools::Dynamic::Tag:0x0055b5a5ecad28 @header={:d_tag=>0, :d_val=>0}>
+  #
+  #   # symbol
+  #   dynamic.tag_by_type(:null)
+  #   #=>  #<ELFTools::Dynamic::Tag:0x0055b5a5ecad28 @header={:d_tag=>0, :d_val=>0}>
+  #   dynamic.tag_by_type(:pltgot)
+  #   #=> #<ELFTools::Dynamic::Tag:0x0055d3d2d91b28 @header={:d_tag=>3, :d_val=>6295552}>
+  #
+  #   # string
+  #   dynamic.tag_by_type('null')
+  #   #=>  #<ELFTools::Dynamic::Tag:0x0055b5a5ecad28 @header={:d_tag=>0, :d_val=>0}>
+  #   dynamic.tag_by_type('DT_PLTGOT')
+  #   #=> #<ELFTools::Dynamic::Tag:0x0055d3d2d91b28 @header={:d_tag=>3, :d_val=>6295552}>
+  # @param type [Integer, Symbol, String] Constant value, symbol, or string of type
+  #   is acceptable. See examples for more information.
+  # @return [ELFTools::Dynamic::Tag] The desired tag.
+  #
+  # source://elftools//lib/elftools/dynamic.rb#64
+  def tag_by_type(type); end
+
+  # Use {#tags} to get all tags.
+  #
+  # @return [Array<ELFTools::Dynamic::Tag>] Array of tags.
+  #
+  # source://elftools//lib/elftools/dynamic.rb#36
+  def tags; end
+
+  # Get tags of specific type.
+  #
+  # @param type [Integer, Symbol, String] Constant value, symbol, or string of type
+  #   is acceptable. See examples for more information.
+  # @return [Array<ELFTools::Dynamic::Tag>] The desired tags.
+  # @see #tag_by_type
+  #
+  # source://elftools//lib/elftools/dynamic.rb#76
+  def tags_by_type(type); end
+
+  private
+
+  # source://elftools//lib/elftools/dynamic.rb#108
+  def endian; end
+
+  # Get the DT_STRTAB's +d_val+ offset related to file.
+  #
+  # source://elftools//lib/elftools/dynamic.rb#113
+  def str_offset; end
+end
+
+# A tag class.
+#
+# source://elftools//lib/elftools/dynamic.rb#119
+class ELFTools::Dynamic::Tag
+  # Instantiate a {ELFTools::Dynamic::Tag} object.
+  #
+  # @param header [ELF_Dyn] The dynamic tag header.
+  # @param stream [#pos=, #read] Streaming object.
+  # @param str_offset [Method] Call this method to get the string offset related
+  #   to file.
+  # @return [Tag] a new instance of Tag
+  #
+  # source://elftools//lib/elftools/dynamic.rb#129
+  def initialize(header, stream, str_offset); end
+
+  # @return [ELFTools::Structs::ELF_Dyn] The dynamic tag header.
+  #
+  # source://elftools//lib/elftools/dynamic.rb#120
+  def header; end
+
+  # Return the name of this tag.
+  #
+  # Only tags with name would return a name.
+  # Others would return +nil+.
+  #
+  # @return [String, nil] The name.
+  #
+  # source://elftools//lib/elftools/dynamic.rb#171
+  def name; end
+
+  # Is this tag has a name?
+  #
+  # The criteria here is if this tag's type is in {TYPE_WITH_NAME}.
+  #
+  # @return [Boolean] Is this tag has a name.
+  #
+  # source://elftools//lib/elftools/dynamic.rb#162
+  def name?; end
+
+  # @return [#pos=, #read] Streaming object.
+  #
+  # source://elftools//lib/elftools/dynamic.rb#121
+  def stream; end
+
+  # Return the content of this tag records.
+  #
+  # For normal tags, this method just return
+  # +header.d_val+. For tags with +header.d_val+
+  # in meaning of string offset (e.g. DT_NEEDED), this method would
+  # return the string it specified.
+  # Tags with type in {TYPE_WITH_NAME} are those tags with name.
+  #
+  # @example
+  #   dynamic = elf.segment_by_type(:dynamic)
+  #   dynamic.tag_by_type(:init).value
+  #   #=> 4195600 # 0x400510
+  #   dynamic.tag_by_type(:needed).value
+  #   #=> 'libc.so.6'
+  # @return [Integer, String] The content this tag records.
+  #
+  # source://elftools//lib/elftools/dynamic.rb#154
+  def value; end
+end
+
+# Some dynamic have name.
+#
+# source://elftools//lib/elftools/dynamic.rb#136
+ELFTools::Dynamic::Tag::TYPE_WITH_NAME = T.let(T.unsafe(nil), Array)
+
+# Raised on invalid ELF class (EI_CLASS).
+#
+# source://elftools//lib/elftools/exceptions.rb#11
+class ELFTools::ELFClassError < ::ELFTools::ELFError; end
+
+# Raised on invalid ELF data encoding (EI_DATA).
+#
+# source://elftools//lib/elftools/exceptions.rb#14
+class ELFTools::ELFDataError < ::ELFTools::ELFError; end
+
+# Being raised when parsing error.
+#
+# source://elftools//lib/elftools/exceptions.rb#5
+class ELFTools::ELFError < ::StandardError; end
+
+# The main class for using elftools.
+#
+# source://elftools//lib/elftools/elf_file.rb#12
+class ELFTools::ELFFile
+  # Instantiate an {ELFFile} object.
+  #
+  # @example
+  #   ELFFile.new(File.open('/bin/cat'))
+  #   #=> #<ELFTools::ELFFile:0x00564b106c32a0 @elf_class=64, @endian=:little, @stream=#<File:/bin/cat>>
+  # @param stream [#pos=, #read] The +File+ object to be fetch information from.
+  # @return [ELFFile] a new instance of ELFFile
+  #
+  # source://elftools//lib/elftools/elf_file.rb#24
+  def initialize(stream); end
+
+  # Return the BuildID of ELF.
+  #
+  # @example
+  #   elf.build_id
+  #   #=> '73ab62cb7bc9959ce053c2b711322158708cdc07'
+  # @return [String, nil] BuildID in hex form will be returned.
+  #   +nil+ is returned if the .note.gnu.build-id section
+  #   is not found.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#52
+  def build_id; end
+
+  # Iterate all sections.
+  #
+  # All sections are lazy loading, the section
+  # only be created whenever accessing it.
+  # This method is useful for {#section_by_name}
+  # since not all sections need to be created.
+  #
+  # @return [Enumerator<ELFTools::Sections::Section>, Array<ELFTools::Sections::Section>] As +Array#each+, if block is not given, a enumerator will be returned,
+  #   otherwise, the whole sections will be returned.
+  # @yieldparam section [ELFTools::Sections::Section] A section.
+  # @yieldreturn [void]
+  #
+  # source://elftools//lib/elftools/elf_file.rb#122
+  def each_sections(&block); end
+
+  # Iterate all segments.
+  #
+  # All segments are lazy loading, the segment
+  # only be created whenever accessing it.
+  # This method is useful for {#segment_by_type}
+  # since not all segments need to be created.
+  #
+  # @return [Array<ELFTools::Segments::Segment>] Whole segments will be returned.
+  # @yieldparam segment [ELFTools::Segments::Segment] A segment.
+  # @yieldreturn [void]
+  #
+  # source://elftools//lib/elftools/elf_file.rb#195
+  def each_segments(&block); end
+
+  # @return [Integer] 32 or 64.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#14
+  def elf_class; end
+
+  # Return the ELF type according to +e_type+.
+  #
+  # @example
+  #   ELFFile.new(File.open('spec/files/libc.so.6')).elf_type
+  #   #=> 'DYN'
+  #   ELFFile.new(File.open('spec/files/amd64.elf')).elf_type
+  #   #=> 'EXEC'
+  # @return [String] Type in string format.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#82
+  def elf_type; end
+
+  # @return [Symbol] +:little+ or +:big+.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#15
+  def endian; end
+
+  # Return the file header.
+  #
+  # Lazy loading.
+  #
+  # @return [ELFTools::Structs::ELF_Ehdr] The header.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#35
+  def header; end
+
+  # Get machine architecture.
+  #
+  # Mappings of architecture can be found
+  # in {ELFTools::Constants::EM.mapping}.
+  #
+  # @example
+  #   elf.machine
+  #   #=> 'Advanced Micro Devices X86-64'
+  # @return [String] Name of architecture.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#71
+  def machine; end
+
+  # Number of sections in this file.
+  #
+  # @example
+  #   elf.num_sections
+  #   #=> 29
+  # @return [Integer] The desired number.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#93
+  def num_sections; end
+
+  # Number of segments in this file.
+  #
+  # @return [Integer] The desited number.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#181
+  def num_segments; end
+
+  # Get the offset related to file, given virtual memory address.
+  #
+  # This method should work no matter ELF is a PIE or not.
+  # This method refers from (actually equals to) binutils/readelf.c#offset_from_vma.
+  #
+  # @example
+  #   elf = ELFTools::ELFFile.new(File.open('/bin/cat'))
+  #   elf.offset_from_vma(0x401337)
+  #   #=> 4919 # 0x1337
+  # @param vma [Integer] The virtual address to be queried.
+  # @return [Integer] Related file offset.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#293
+  def offset_from_vma(vma, size = T.unsafe(nil)); end
+
+  # The patch status.
+  #
+  # @return [Hash{Integer => String}]
+  #
+  # source://elftools//lib/elftools/elf_file.rb#301
+  def patches; end
+
+  # Apply patches and save as +filename+.
+  #
+  # @param filename [String]
+  # @return [void]
+  #
+  # source://elftools//lib/elftools/elf_file.rb#315
+  def save(filename); end
+
+  # Acquire the +n+-th section, 0-based.
+  #
+  # Sections are lazy loaded.
+  #
+  # @param n [Integer] The index.
+  # @return [ELFTools::Sections::Section, nil] The target section.
+  #   If +n+ is out of bound, +nil+ is returned.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#144
+  def section_at(n); end
+
+  # Acquire the section named as +name+.
+  #
+  # @example
+  #   elf.section_by_name('.note.gnu.build-id')
+  #   #=> #<ELFTools::Sections::Section:0x005647b1282428>
+  #   elf.section_by_name('')
+  #   #=> #<ELFTools::Sections::NullSection:0x005647b11da110>
+  #   elf.section_by_name('no such section')
+  #   #=> nil
+  # @param name [String] The desired section name.
+  # @return [ELFTools::Sections::Section, nil] The target section.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#107
+  def section_by_name(name); end
+
+  # Simply use {#sections} to get all sections.
+  #
+  # @return [Array<ELFTools::Sections::Section>] Whole sections.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#133
+  def sections; end
+
+  # Fetch all sections with specific type.
+  #
+  # The available types are listed in {ELFTools::Constants::PT}.
+  # This method accept giving block.
+  #
+  # @example
+  #   elf = ELFTools::ELFFile.new(File.open('spec/files/amd64.elf'))
+  #   elf.sections_by_type(:rela)
+  #   #=> [#<ELFTools::Sections::RelocationSection:0x00563cd3219970>,
+  #   #    #<ELFTools::Sections::RelocationSection:0x00563cd3b89d70>]
+  # @param type [Integer, Symbol, String] The type needed, similar format as {#segment_by_type}.
+  # @return [Array<ELFTools::Sections::section>] The target sections.
+  # @yieldparam section [ELFTools::Sections::Section] A section in specific type.
+  # @yieldreturn [void]
+  #
+  # source://elftools//lib/elftools/elf_file.rb#163
+  def sections_by_type(type, &block); end
+
+  # Acquire the +n+-th segment, 0-based.
+  #
+  # Segments are lazy loaded.
+  #
+  # @param n [Integer] The index.
+  # @return [ELFTools::Segments::Segment, nil] The target segment.
+  #   If +n+ is out of bound, +nil+ is returned.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#278
+  def segment_at(n); end
+
+  # Get the first segment with +p_type=type+.
+  # The available types are listed in {ELFTools::Constants::PT}.
+  #
+  # @example
+  #   # type as an integer
+  #   elf.segment_by_type(ELFTools::Constants::PT_NOTE)
+  #   #=>  #<ELFTools::Segments::NoteSegment:0x005629dda1e4f8>
+  #
+  #   elf.segment_by_type(4) # PT_NOTE
+  #   #=>  #<ELFTools::Segments::NoteSegment:0x005629dda1e4f8>
+  #
+  #   # type as a symbol
+  #   elf.segment_by_type(:PT_NOTE)
+  #   #=>  #<ELFTools::Segments::NoteSegment:0x005629dda1e4f8>
+  #
+  #   # you can do this
+  #   elf.segment_by_type(:note) # will be transformed into `PT_NOTE`
+  #   #=>  #<ELFTools::Segments::NoteSegment:0x005629dda1e4f8>
+  #
+  #   # type as a string
+  #   elf.segment_by_type('PT_NOTE')
+  #   #=>  #<ELFTools::Segments::NoteSegment:0x005629dda1e4f8>
+  #
+  #   # this is ok
+  #   elf.segment_by_type('note') # will be transformed into `PT_NOTE`
+  #   #=>  #<ELFTools::Segments::NoteSegment:0x005629dda1e4f8>
+  # @example
+  #   elf.segment_by_type(1337)
+  #   # ArgumentError: No constants in Constants::PT is 1337
+  #
+  #   elf.segment_by_type('oao')
+  #   # ArgumentError: No constants in Constants::PT named "PT_OAO"
+  # @example
+  #   elf.segment_by_type(0)
+  #   #=> nil # no such segment exists
+  # @note This method will return the first segment found,
+  #   to found all segments with specific type you can use {#segments_by_type}.
+  # @param type [Integer, Symbol, String] See examples for clear usage.
+  # @return [ELFTools::Segments::Segment] The target segment.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#251
+  def segment_by_type(type); end
+
+  # Simply use {#segments} to get all segments.
+  #
+  # @return [Array<ELFTools::Segments::Segment>] Whole segments.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#206
+  def segments; end
+
+  # Fetch all segments with specific type.
+  #
+  # If you want to find only one segment,
+  # use {#segment_by_type} instead.
+  # This method accept giving block.
+  #
+  # @param type [Integer, Symbol, String] The type needed, same format as {#segment_by_type}.
+  # @return [Array<ELFTools::Segments::Segment>] The target segments.
+  # @yieldparam segment [ELFTools::Segments::Segment] A segment in specific type.
+  # @yieldreturn [void]
+  #
+  # source://elftools//lib/elftools/elf_file.rb#266
+  def segments_by_type(type, &block); end
+
+  # @return [#pos=, #read] The +File+ object.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#13
+  def stream; end
+
+  # Get the string table section.
+  #
+  # This section is acquired by using the +e_shstrndx+
+  # in ELF header.
+  #
+  # @return [ELFTools::Sections::StrTabSection] The desired section.
+  #
+  # source://elftools//lib/elftools/elf_file.rb#173
+  def strtab_section; end
+
+  private
+
+  # source://elftools//lib/elftools/elf_file.rb#359
+  def create_section(n); end
+
+  # source://elftools//lib/elftools/elf_file.rb#370
+  def create_segment(n); end
+
+  # @raise [ELFMagicError]
+  #
+  # source://elftools//lib/elftools/elf_file.rb#339
+  def identify; end
+
+  # bad idea..
+  #
+  # source://elftools//lib/elftools/elf_file.rb#327
+  def loaded_headers; end
+end
+
+# Raised on invalid ELF magic.
+#
+# source://elftools//lib/elftools/exceptions.rb#8
+class ELFTools::ELFMagicError < ::ELFTools::ELFError; end
+
+# A helper class for {ELFTools} easy to implement
+# 'lazy loading' objects.
+# Mainly used when loading sections, segments, and
+# symbols.
+#
+# source://elftools//lib/elftools/lazy_array.rb#29
+class ELFTools::LazyArray < ::SimpleDelegator
+  # Instantiate a {LazyArray} object.
+  #
+  # @example
+  #   arr = LazyArray.new(10) { |i| p "calc #{i}"; i * i }
+  #   p arr[2]
+  #   # "calc 2"
+  #   # 4
+  #
+  #   p arr[3]
+  #   # "calc 3"
+  #   # 9
+  #
+  #   p arr[3]
+  #   # 9
+  # @param size [Integer] The size of array.
+  # @return [LazyArray] a new instance of LazyArray
+  # @yieldparam i [Integer] Needs the +i+-th element.
+  # @yieldreturn [Object] Value of the +i+-th element.
+  #
+  # source://elftools//lib/elftools/lazy_array.rb#30
+  def initialize(size, &block); end
+
+  # To access elements like a normal array.
+  #
+  # Elements are lazy loaded at the first time
+  # access it.
+  #
+  # @return [Object] The element, returned type is the
+  #   return type of block given in {#initialize}.
+  #
+  # source://elftools//lib/elftools/lazy_array.rb#42
+  def [](i); end
+end
+
+# Since both note sections and note segments refer to notes, this module
+# defines common methods for {ELFTools::Sections::NoteSection} and
+# {ELFTools::Segments::NoteSegment}.
+#
+# @note This module can only be included in {ELFTools::Sections::NoteSection} and
+#   {ELFTools::Segments::NoteSegment} since some methods here assume some
+#   attributes already exist.
+#
+# source://elftools//lib/elftools/note.rb#15
+module ELFTools::Note
+  # Iterate all notes in a note section or segment.
+  #
+  # Structure of notes are:
+  #   +---------------+
+  #   | Note 1 header |
+  #   +---------------+
+  #   |  Note 1 name  |
+  #   +---------------+
+  #   |  Note 1 desc  |
+  #   +---------------+
+  #   | Note 2 header |
+  #   +---------------+
+  #   |      ...      |
+  #   +---------------+
+  #
+  # @note This method assume following methods exist:
+  #   stream
+  #   note_start
+  #   note_total_size
+  # @return [Enumerator<ELFTools::Note::Note>, Array<ELFTools::Note::Note>] If block is not given, an enumerator will be returned.
+  #   Otherwise, return the array of notes.
+  #
+  # source://elftools//lib/elftools/note.rb#44
+  def each_notes; end
+
+  # Simply +#notes+ to get all notes.
+  #
+  # @return [Array<ELFTools::Note::Note>] Whole notes.
+  #
+  # source://elftools//lib/elftools/note.rb#67
+  def notes; end
+
+  private
+
+  # source://elftools//lib/elftools/note.rb#81
+  def create_note(cur); end
+
+  # Get the endian.
+  #
+  # @note This method assume method +header+ exists.
+  # @return [Symbol] +:little+ or +:big+.
+  #
+  # source://elftools//lib/elftools/note.rb#77
+  def endian; end
+end
+
+# Class of a note.
+#
+# source://elftools//lib/elftools/note.rb#87
+class ELFTools::Note::Note
+  # Instantiate a {ELFTools::Note::Note} object.
+  #
+  # @param header [ELF_Nhdr] The note header.
+  # @param stream [#pos=, #read] Streaming object.
+  # @param offset [Integer] Start address of this note, includes the header.
+  # @return [Note] a new instance of Note
+  #
+  # source://elftools//lib/elftools/note.rb#97
+  def initialize(header, stream, offset); end
+
+  # Description of this note.
+  #
+  # @return [String] The description.
+  #
+  # source://elftools//lib/elftools/note.rb#114
+  def desc; end
+
+  # Description of this note.
+  # If someone likes to use full name.
+  #
+  # @return [String] The description.
+  #
+  # source://elftools//lib/elftools/note.rb#114
+  def description; end
+
+  # @return [ELFTools::Structs::ELF_Nhdr] Note header.
+  #
+  # source://elftools//lib/elftools/note.rb#88
+  def header; end
+
+  # Name of this note.
+  #
+  # @return [String] The name.
+  #
+  # source://elftools//lib/elftools/note.rb#105
+  def name; end
+
+  # @return [Integer] Address of this note start, includes note header.
+  #
+  # source://elftools//lib/elftools/note.rb#90
+  def offset; end
+
+  # @return [#pos=, #read] Streaming object.
+  #
+  # source://elftools//lib/elftools/note.rb#89
+  def stream; end
+end
+
+# Since size of {ELFTools::Structs::ELF_Nhdr} will not change no matter in
+# what endian and what arch, we can do this here. This value should equal
+# to 12.
+#
+# source://elftools//lib/elftools/note.rb#19
+ELFTools::Note::SIZE_OF_NHDR = T.let(T.unsafe(nil), Integer)
+
+# A relocation entry.
+#
+# Can be either a REL or RELA relocation.
+# XXX: move this to an independent file?
+#
+# source://elftools//lib/elftools/sections/relocation_section.rb#77
+class ELFTools::Relocation
+  # Instantiate a {Relocation} object.
+  #
+  # @return [Relocation] a new instance of Relocation
+  #
+  # source://elftools//lib/elftools/sections/relocation_section.rb#82
+  def initialize(header, stream); end
+
+  # @return [ELFTools::Structs::ELF_Rel, ELFTools::Structs::ELF_Rela] Rel(a) header.
+  #
+  # source://elftools//lib/elftools/sections/relocation_section.rb#78
+  def header; end
+
+  # +r_info+ contains sym and type, use two methods
+  # to access them easier.
+  #
+  # @return [Integer] sym infor.
+  #
+  # source://elftools//lib/elftools/sections/relocation_section.rb#90
+  def r_info_sym; end
+
+  # +r_info+ contains sym and type, use two methods
+  # to access them easier.
+  #
+  # @return [Integer] type infor.
+  #
+  # source://elftools//lib/elftools/sections/relocation_section.rb#98
+  def r_info_type; end
+
+  # @return [#pos=, #read] Streaming object.
+  #
+  # source://elftools//lib/elftools/sections/relocation_section.rb#79
+  def stream; end
+
+  # +r_info+ contains sym and type, use two methods
+  # to access them easier.
+  #
+  # @return [Integer] sym infor.
+  #
+  # source://elftools//lib/elftools/sections/relocation_section.rb#90
+  def symbol_index; end
+
+  # +r_info+ contains sym and type, use two methods
+  # to access them easier.
+  #
+  # @return [Integer] type infor.
+  #
+  # source://elftools//lib/elftools/sections/relocation_section.rb#98
+  def type; end
+
+  private
+
+  # source://elftools//lib/elftools/sections/relocation_section.rb#105
+  def mask_bit; end
+end
+
+# Defines different types of sections in this module.
+#
+# source://elftools//lib/elftools/sections/section.rb#5
+module ELFTools::Sections; end
+
+# Class for dynamic table section.
+#
+# This section should always be named .dynamic.
+# This class knows how to get the list of dynamic tags.
+#
+# source://elftools//lib/elftools/sections/dynamic_section.rb#12
+class ELFTools::Sections::DynamicSection < ::ELFTools::Sections::Section
+  include ::ELFTools::Dynamic
+
+  # Get the start address of tags.
+  #
+  # @return [Integer] Start address of tags.
+  #
+  # source://elftools//lib/elftools/sections/dynamic_section.rb#17
+  def tag_start; end
+end
+
+# Class of note section.
+# Note section records notes
+#
+# source://elftools//lib/elftools/sections/note_section.rb#11
+class ELFTools::Sections::NoteSection < ::ELFTools::Sections::Section
+  include ::ELFTools::Note
+
+  # Address offset of notes start.
+  #
+  # @return [Integer] The offset.
+  #
+  # source://elftools//lib/elftools/sections/note_section.rb#16
+  def note_start; end
+
+  # The total size of notes in this section.
+  #
+  # @return [Integer] The size.
+  #
+  # source://elftools//lib/elftools/sections/note_section.rb#22
+  def note_total_size; end
+end
+
+# Class of null section.
+# Null section is for specific the end
+# of linked list (+sh_link+) between sections.
+#
+# source://elftools//lib/elftools/sections/null_section.rb#12
+class ELFTools::Sections::NullSection < ::ELFTools::Sections::Section
+  # Is this a null section?
+  #
+  # @return [Boolean] Yes it is.
+  #
+  # source://elftools//lib/elftools/sections/null_section.rb#13
+  def null?; end
+end
+
+# Class of note section.
+# Note section records notes
+#
+# source://elftools//lib/elftools/sections/relocation_section.rb#13
+class ELFTools::Sections::RelocationSection < ::ELFTools::Sections::Section
+  # Iterate all relocations.
+  #
+  # All relocations are lazy loading, the relocation
+  # only be created whenever accessing it.
+  #
+  # @return [Enumerator<ELFTools::Relocation>, Array<ELFTools::Relocation>] If block is not given, an enumerator will be returned.
+  #   Otherwise, the whole relocations will be returned.
+  # @yieldparam rel [ELFTools::Relocation] A relocation object.
+  # @yieldreturn [void]
+  #
+  # source://elftools//lib/elftools/sections/relocation_section.rb#45
+  def each_relocations(&block); end
+
+  # Number of relocations in this section.
+  #
+  # @return [Integer] The number.
+  #
+  # source://elftools//lib/elftools/sections/relocation_section.rb#20
+  def num_relocations; end
+
+  # Is this relocation a RELA or REL type.
+  #
+  # @return [Boolean] If is RELA.
+  #
+  # source://elftools//lib/elftools/sections/relocation_section.rb#14
+  def rela?; end
+
+  # Acquire the +n+-th relocation, 0-based.
+  #
+  # relocations are lazy loaded.
+  #
+  # @param n [Integer] The index.
+  # @return [ELFTools::Relocation, nil] The target relocation.
+  #   If +n+ is out of bound, +nil+ is returned.
+  #
+  # source://elftools//lib/elftools/sections/relocation_section.rb#31
+  def relocation_at(n); end
+
+  # Simply use {#relocations} to get all relocations.
+  #
+  # @return [Array<ELFTools::Relocation>] Whole relocations.
+  #
+  # source://elftools//lib/elftools/sections/relocation_section.rb#56
+  def relocations; end
+
+  private
+
+  # source://elftools//lib/elftools/sections/relocation_section.rb#62
+  def create_relocation(n); end
+end
+
+# Base class of sections.
+#
+# source://elftools//lib/elftools/sections/section.rb#7
+class ELFTools::Sections::Section
+  # Instantiate a {Section} object.
+  #
+  # @param header [ELFTools::Structs::ELF_Shdr] The section header object.
+  # @param stream [#pos=, #read] The streaming object for further dump.
+  # @param strtab [ELFTools::Sections::StrTabSection, Proc] The string table object. For fetching section names.
+  #   If +Proc+ if given, it will call at the first
+  #   time access +#name+.
+  # @param offset_from_vma [Method] The method to get offset of file, given virtual memory address.
+  # @return [Section] a new instance of Section
+  #
+  # source://elftools//lib/elftools/sections/section.rb#22
+  def initialize(header, stream, offset_from_vma: T.unsafe(nil), strtab: T.unsafe(nil), **_kwargs); end
+
+  # Fetch data of this section.
+  #
+  # @return [String] Data.
+  #
+  # source://elftools//lib/elftools/sections/section.rb#44
+  def data; end
+
+  # @return [ELFTools::Structs::ELF_Shdr] Section header.
+  #
+  # source://elftools//lib/elftools/sections/section.rb#8
+  def header; end
+
+  # Get name of this section.
+  #
+  # @return [String] The name.
+  #
+  # source://elftools//lib/elftools/sections/section.rb#38
+  def name; end
+
+  # Is this a null section?
+  #
+  # @return [Boolean] No it's not.
+  #
+  # source://elftools//lib/elftools/sections/section.rb#51
+  def null?; end
+
+  # @return [#pos=, #read] Streaming object.
+  #
+  # source://elftools//lib/elftools/sections/section.rb#9
+  def stream; end
+
+  # Return +header.sh_type+ in a simpler way.
+  #
+  # @return [Integer] The type, meaning of types are defined in {Constants::SHT}.
+  #
+  # source://elftools//lib/elftools/sections/section.rb#32
+  def type; end
+
+  class << self
+    # Use different class according to +header.sh_type+.
+    #
+    # @param header [ELFTools::Structs::ELF_Shdr] Section header.
+    # @param stream [#pos=, #read] Streaming object.
+    # @return [ELFTools::Sections::Section] Return object dependes on +header.sh_type+.
+    #
+    # source://elftools//lib/elftools/sections/sections.rb#24
+    def create(header, stream, *args, **kwargs); end
+  end
+end
+
+# Class of string table section.
+# Usually for section .strtab and .dynstr,
+# which record names.
+#
+# source://elftools//lib/elftools/sections/str_tab_section.rb#15
+class ELFTools::Sections::StrTabSection < ::ELFTools::Sections::Section
+  # Return the section or symbol name.
+  #
+  # @param offset [Integer] Usually from +shdr.sh_name+ or +sym.st_name+.
+  # @return [String] The name without null bytes.
+  #
+  # source://elftools//lib/elftools/sections/str_tab_section.rb#16
+  def name_at(offset); end
+end
+
+# Class of symbol table section.
+# Usually for section .symtab and .dynsym,
+# which will refer to symbols in ELF file.
+#
+# source://elftools//lib/elftools/sections/sym_tab_section.rb#20
+class ELFTools::Sections::SymTabSection < ::ELFTools::Sections::Section
+  # Instantiate a {SymTabSection} object.
+  # There's a +section_at+ lambda for {SymTabSection}
+  # to easily fetch other sections.
+  #
+  # @param header [ELFTools::Structs::ELF_Shdr] See {Section#initialize} for more information.
+  # @param stream [#pos=, #read] See {Section#initialize} for more information.
+  # @param section_at [Proc] The method for fetching other sections by index.
+  #   This lambda should be {ELFTools::ELFFile#section_at}.
+  # @return [SymTabSection] a new instance of SymTabSection
+  #
+  # source://elftools//lib/elftools/sections/sym_tab_section.rb#21
+  def initialize(header, stream, section_at: T.unsafe(nil), **_kwargs); end
+
+  # Iterate all symbols.
+  #
+  # All symbols are lazy loading, the symbol
+  # only be created whenever accessing it.
+  # This method is useful for {#symbol_by_name}
+  # since not all symbols need to be created.
+  #
+  # @return [Enumerator<ELFTools::Sections::Symbol>, Array<ELFTools::Sections::Symbol>] If block is not given, an enumerator will be returned.
+  #   Otherwise return array of symbols.
+  # @yieldparam sym [ELFTools::Sections::Symbol] A symbol object.
+  # @yieldreturn [void]
+  #
+  # source://elftools//lib/elftools/sections/sym_tab_section.rb#59
+  def each_symbols(&block); end
+
+  # Number of symbols.
+  #
+  # @example
+  #   symtab.num_symbols
+  #   #=> 75
+  # @return [Integer] The number.
+  #
+  # source://elftools//lib/elftools/sections/sym_tab_section.rb#32
+  def num_symbols; end
+
+  # Acquire the +n+-th symbol, 0-based.
+  #
+  # Symbols are lazy loaded.
+  #
+  # @param n [Integer] The index.
+  # @return [ELFTools::Sections::Symbol, nil] The target symbol.
+  #   If +n+ is out of bound, +nil+ is returned.
+  #
+  # source://elftools//lib/elftools/sections/sym_tab_section.rb#43
+  def symbol_at(n); end
+
+  # Get symbol by its name.
+  #
+  # @param name [String] The name of symbol.
+  # @return [ELFTools::Sections::Symbol] Desired symbol.
+  #
+  # source://elftools//lib/elftools/sections/sym_tab_section.rb#78
+  def symbol_by_name(name); end
+
+  # Simply use {#symbols} to get all symbols.
+  #
+  # @return [Array<ELFTools::Sections::Symbol>] The whole symbols.
+  #
+  # source://elftools//lib/elftools/sections/sym_tab_section.rb#70
+  def symbols; end
+
+  # Return the symbol string section.
+  # Lazy loaded.
+  #
+  # @return [ELFTools::Sections::StrTabSection] The string table section.
+  #
+  # source://elftools//lib/elftools/sections/sym_tab_section.rb#85
+  def symstr; end
+
+  private
+
+  # source://elftools//lib/elftools/sections/sym_tab_section.rb#91
+  def create_symbol(n); end
+end
+
+# Class of symbol.
+#
+# XXX: Should this class be defined in an independent file?
+#
+# source://elftools//lib/elftools/sections/sym_tab_section.rb#102
+class ELFTools::Sections::Symbol
+  # Instantiate a {ELFTools::Sections::Symbol} object.
+  #
+  # @param header [ELFTools::Structs::ELF32_sym, ELFTools::Structs::ELF64_sym] The symbol header.
+  # @param stream [#pos=, #read] The streaming object.
+  # @param symstr [ELFTools::Sections::StrTabSection, Proc] The symbol string section.
+  #   If +Proc+ is given, it will be called at the first time
+  #   access {Symbol#name}.
+  # @return [Symbol] a new instance of Symbol
+  #
+  # source://elftools//lib/elftools/sections/sym_tab_section.rb#114
+  def initialize(header, stream, symstr: T.unsafe(nil)); end
+
+  # @return [ELFTools::Structs::ELF32_sym, ELFTools::Structs::ELF64_sym] Section header.
+  #
+  # source://elftools//lib/elftools/sections/sym_tab_section.rb#103
+  def header; end
+
+  # Return the symbol name.
+  #
+  # @return [String] The name.
+  #
+  # source://elftools//lib/elftools/sections/sym_tab_section.rb#122
+  def name; end
+
+  # @return [#pos=, #read] Streaming object.
+  #
+  # source://elftools//lib/elftools/sections/sym_tab_section.rb#104
+  def stream; end
+end
+
+# Module for defining different types of segments.
+#
+# source://elftools//lib/elftools/segments/segment.rb#4
+module ELFTools::Segments; end
+
+# Class for dynamic table segment.
+#
+# This class knows how to get the list of dynamic tags.
+#
+# source://elftools//lib/elftools/segments/dynamic_segment.rb#11
+class ELFTools::Segments::DynamicSegment < ::ELFTools::Segments::Segment
+  include ::ELFTools::Dynamic
+
+  # Get the start address of tags.
+  #
+  # @return [Integer] Start address of tags.
+  #
+  # source://elftools//lib/elftools/segments/dynamic_segment.rb#15
+  def tag_start; end
+end
+
+# For DT_INTERP segment, knows how to get path of
+# ELF interpreter.
+#
+# source://elftools//lib/elftools/segments/interp_segment.rb#14
+class ELFTools::Segments::InterpSegment < ::ELFTools::Segments::Segment
+  # Get the path of interpreter.
+  #
+  # @example
+  #   interp_segment.interp_name
+  #   #=> '/lib64/ld-linux-x86-64.so.2'
+  # @return [String] Path to the interpreter.
+  #
+  # source://elftools//lib/elftools/segments/interp_segment.rb#15
+  def interp_name; end
+end
+
+# For DT_LOAD segment.
+# Able to query between file offset and virtual memory address.
+#
+# source://elftools//lib/elftools/segments/load_segment.rb#12
+class ELFTools::Segments::LoadSegment < ::ELFTools::Segments::Segment
+  # Returns the start of this segment.
+  #
+  # @return [Integer] The file offset.
+  #
+  # source://elftools//lib/elftools/segments/load_segment.rb#13
+  def file_head; end
+
+  # Returns the end of this segment.
+  #
+  # @return [Integer] The file offset.
+  #
+  # source://elftools//lib/elftools/segments/load_segment.rb#27
+  def file_tail; end
+
+  # Returns the start virtual address of this segment.
+  #
+  # @return [Integer] The vma.
+  #
+  # source://elftools//lib/elftools/segments/load_segment.rb#34
+  def mem_head; end
+
+  # Returns size in memory.
+  #
+  # @return [Integer] The size.
+  #
+  # source://elftools//lib/elftools/segments/load_segment.rb#41
+  def mem_size; end
+
+  # Returns the end virtual address of this segment.
+  #
+  # @return [Integer] The vma.
+  #
+  # source://elftools//lib/elftools/segments/load_segment.rb#48
+  def mem_tail; end
+
+  # Query if the given file offset located in this segment.
+  #
+  # @param offset [Integer] File offset.
+  # @param size [Integer] Size.
+  # @return [Boolean]
+  #
+  # source://elftools//lib/elftools/segments/load_segment.rb#58
+  def offset_in?(offset, size = T.unsafe(nil)); end
+
+  # Convert file offset into virtual memory address.
+  #
+  # @param offset [Integer] File offset.
+  # @return [Integer]
+  #
+  # source://elftools//lib/elftools/segments/load_segment.rb#66
+  def offset_to_vma(offset); end
+
+  # Returns size in file.
+  #
+  # @return [Integer] The size.
+  #
+  # source://elftools//lib/elftools/segments/load_segment.rb#20
+  def size; end
+
+  # Query if the given virtual memory address located in this segment.
+  #
+  # @param vma [Integer] Virtual memory address.
+  # @param size [Integer] Size.
+  # @return [Boolean]
+  #
+  # source://elftools//lib/elftools/segments/load_segment.rb#77
+  def vma_in?(vma, size = T.unsafe(nil)); end
+
+  # Convert virtual memory address into file offset.
+  #
+  # @param vma [Integer] Virtual memory address.
+  # @return [Integer]
+  #
+  # source://elftools//lib/elftools/segments/load_segment.rb#86
+  def vma_to_offset(vma); end
+end
+
+# Class of note segment.
+#
+# source://elftools//lib/elftools/segments/note_segment.rb#10
+class ELFTools::Segments::NoteSegment < ::ELFTools::Segments::Segment
+  include ::ELFTools::Note
+
+  # Address offset of notes start.
+  #
+  # @return [Integer] The offset.
+  #
+  # source://elftools//lib/elftools/segments/note_segment.rb#15
+  def note_start; end
+
+  # The total size of notes in this segment.
+  #
+  # @return [Integer] The size.
+  #
+  # source://elftools//lib/elftools/segments/note_segment.rb#21
+  def note_total_size; end
+end
+
+# Base class of segments.
+#
+# source://elftools//lib/elftools/segments/segment.rb#6
+class ELFTools::Segments::Segment
+  # Instantiate a {Segment} object.
+  #
+  # @param header [ELFTools::Structs::ELF32_Phdr, ELFTools::Structs::ELF64_Phdr] Program header.
+  # @param stream [#pos=, #read] Streaming object.
+  # @param offset_from_vma [Method] The method to get offset of file, given virtual memory address.
+  # @return [Segment] a new instance of Segment
+  #
+  # source://elftools//lib/elftools/segments/segment.rb#17
+  def initialize(header, stream, offset_from_vma: T.unsafe(nil)); end
+
+  # The content in this segment.
+  #
+  # @return [String] The content.
+  #
+  # source://elftools//lib/elftools/segments/segment.rb#32
+  def data; end
+
+  # Is this segment executable?
+  #
+  # @return [Boolean] True or false.
+  #
+  # source://elftools//lib/elftools/segments/segment.rb#51
+  def executable?; end
+
+  # @return [ELFTools::Structs::ELF32_Phdr, ELFTools::Structs::ELF64_Phdr] Program header.
+  #
+  # source://elftools//lib/elftools/segments/segment.rb#7
+  def header; end
+
+  # Is this segment readable?
+  #
+  # @return [Boolean] True or false.
+  #
+  # source://elftools//lib/elftools/segments/segment.rb#39
+  def readable?; end
+
+  # @return [#pos=, #read] Streaming object.
+  #
+  # source://elftools//lib/elftools/segments/segment.rb#8
+  def stream; end
+
+  # Return +header.p_type+ in a simpler way.
+  #
+  # @return [Integer] The type, meaning of types are defined in {Constants::PT}.
+  #
+  # source://elftools//lib/elftools/segments/segment.rb#26
+  def type; end
+
+  # Is this segment writable?
+  #
+  # @return [Boolean] True or false.
+  #
+  # source://elftools//lib/elftools/segments/segment.rb#45
+  def writable?; end
+
+  class << self
+    # Use different class according to +header.p_type+.
+    #
+    # @param header [ELFTools::Structs::ELF32_Phdr, ELFTools::Structs::ELF64_Phdr] Program header of a segment.
+    # @param stream [#pos=, #read] Streaming object.
+    # @return [ELFTools::Segments::Segment] Return object dependes on +header.p_type+.
+    #
+    # source://elftools//lib/elftools/segments/segments.rb#22
+    def create(header, stream, *args, **kwargs); end
+  end
+end
+
+# Define ELF related structures in this module.
+#
+# Structures are fetched from https://github.com/torvalds/linux/blob/master/include/uapi/linux/elf.h.
+# Use gem +bindata+ to have these structures support 32/64 bits and little/big endian simultaneously.
+#
+# source://elftools//lib/elftools/structs.rb#10
+module ELFTools::Structs; end
+
+# Program header structure for 32-bit.
+#
+# source://elftools//lib/elftools/structs.rb#123
+class ELFTools::Structs::ELF32_Phdr < ::ELFTools::Structs::ELFStruct
+  class << self
+    # source://bindata/2.5.0/lib/bindata/base.rb#53
+    def inherited(subclass); end
+
+    # source://bindata/2.5.0/lib/bindata/dsl.rb#280
+    def new(*args); end
+  end
+end
+
+# Symbol structure for 32-bit.
+#
+# source://elftools//lib/elftools/structs.rb#155
+class ELFTools::Structs::ELF32_sym < ::ELFTools::Structs::ELFStruct
+  class << self
+    # source://bindata/2.5.0/lib/bindata/base.rb#53
+    def inherited(subclass); end
+
+    # source://bindata/2.5.0/lib/bindata/dsl.rb#280
+    def new(*args); end
+  end
+end
+
+# Program header structure for 64-bit.
+#
+# source://elftools//lib/elftools/structs.rb#136
+class ELFTools::Structs::ELF64_Phdr < ::ELFTools::Structs::ELFStruct
+  class << self
+    # source://bindata/2.5.0/lib/bindata/base.rb#53
+    def inherited(subclass); end
+
+    # source://bindata/2.5.0/lib/bindata/dsl.rb#280
+    def new(*args); end
+  end
+end
+
+# Symbol structure for 64-bit.
+#
+# source://elftools//lib/elftools/structs.rb#166
+class ELFTools::Structs::ELF64_sym < ::ELFTools::Structs::ELFStruct
+  class << self
+    # source://bindata/2.5.0/lib/bindata/base.rb#53
+    def inherited(subclass); end
+
+    # source://bindata/2.5.0/lib/bindata/dsl.rb#280
+    def new(*args); end
+  end
+end
+
+# The base structure to define common methods.
+#
+# source://elftools//lib/elftools/structs.rb#13
+class ELFTools::Structs::ELFStruct < ::BinData::Record
+  # @return [Integer] 32 or 64.
+  #
+  # source://elftools//lib/elftools/structs.rb#18
+  def elf_class; end
+
+  # @return [Integer] 32 or 64.
+  #
+  # source://elftools//lib/elftools/structs.rb#18
+  def elf_class=(_arg0); end
+
+  # @return [Integer] The file offset of this header.
+  #
+  # source://elftools//lib/elftools/structs.rb#19
+  def offset; end
+
+  # @return [Integer] The file offset of this header.
+  #
+  # source://elftools//lib/elftools/structs.rb#19
+  def offset=(_arg0); end
+
+  # Records which fields have been patched.
+  #
+  # @return [Hash{Integer => Integer}] Patches.
+  #
+  # source://elftools//lib/elftools/structs.rb#23
+  def patches; end
+
+  # BinData hash(Snapshot) that behaves like HashWithIndifferentAccess
+  #
+  # source://bindata/2.5.0/lib/bindata/struct.rb#107
+  def to_h; end
+
+  class << self
+    # source://bindata/2.5.0/lib/bindata/base.rb#53
+    def inherited(subclass); end
+
+    # Hooks the constructor.
+    #
+    # +BinData::Record+ doesn't allow us to override +#initialize+, so we hack +new+ here.
+    #
+    # source://elftools//lib/elftools/structs.rb#34
+    def new(*args); end
+
+    # Packs an integer to string.
+    #
+    # @param val [Integer]
+    # @param bytes [Integer]
+    # @raise [ArgumentError]
+    # @return [String]
+    #
+    # source://elftools//lib/elftools/structs.rb#64
+    def pack(val, bytes); end
+
+    # Gets the endianness of current class.
+    #
+    # @return [:little, :big] The endianness.
+    #
+    # source://elftools//lib/elftools/structs.rb#56
+    def self_endian; end
+  end
+end
+
+# DRY. Many fields have different type in different arch.
+#
+# source://elftools//lib/elftools/structs.rb#14
+ELFTools::Structs::ELFStruct::CHOICE_SIZE_T = T.let(T.unsafe(nil), Proc)
+
+# Dynamic tag header.
+#
+# source://elftools//lib/elftools/structs.rb#191
+class ELFTools::Structs::ELF_Dyn < ::ELFTools::Structs::ELFStruct
+  class << self
+    # source://bindata/2.5.0/lib/bindata/base.rb#53
+    def inherited(subclass); end
+
+    # source://bindata/2.5.0/lib/bindata/dsl.rb#280
+    def new(*args); end
+  end
+end
+
+# ELF header structure.
+#
+# source://elftools//lib/elftools/structs.rb#80
+class ELFTools::Structs::ELF_Ehdr < ::ELFTools::Structs::ELFStruct
+  class << self
+    # source://bindata/2.5.0/lib/bindata/base.rb#53
+    def inherited(subclass); end
+
+    # source://bindata/2.5.0/lib/bindata/dsl.rb#280
+    def new(*args); end
+  end
+end
+
+# Note header.
+#
+# source://elftools//lib/elftools/structs.rb#183
+class ELFTools::Structs::ELF_Nhdr < ::ELFTools::Structs::ELFStruct
+  class << self
+    # source://bindata/2.5.0/lib/bindata/base.rb#53
+    def inherited(subclass); end
+
+    # source://bindata/2.5.0/lib/bindata/dsl.rb#280
+    def new(*args); end
+  end
+end
+
+# Gets the class of program header according to bits.
+#
+# source://elftools//lib/elftools/structs.rb#149
+ELFTools::Structs::ELF_Phdr = T.let(T.unsafe(nil), Hash)
+
+# Rel header in .rel section.
+#
+# source://elftools//lib/elftools/structs.rb#200
+class ELFTools::Structs::ELF_Rel < ::ELFTools::Structs::ELFStruct
+  # Compatibility with ELF_Rela, both can be used interchangeably
+  #
+  # source://elftools//lib/elftools/structs.rb#206
+  def r_addend; end
+
+  class << self
+    # source://bindata/2.5.0/lib/bindata/base.rb#53
+    def inherited(subclass); end
+
+    # source://bindata/2.5.0/lib/bindata/dsl.rb#280
+    def new(*args); end
+  end
+end
+
+# Rela header in .rela section.
+#
+# source://elftools//lib/elftools/structs.rb#212
+class ELFTools::Structs::ELF_Rela < ::ELFTools::Structs::ELFStruct
+  class << self
+    # source://bindata/2.5.0/lib/bindata/base.rb#53
+    def inherited(subclass); end
+
+    # source://bindata/2.5.0/lib/bindata/dsl.rb#280
+    def new(*args); end
+  end
+end
+
+# Section header structure.
+#
+# source://elftools//lib/elftools/structs.rb#108
+class ELFTools::Structs::ELF_Shdr < ::ELFTools::Structs::ELFStruct
+  class << self
+    # source://bindata/2.5.0/lib/bindata/base.rb#53
+    def inherited(subclass); end
+
+    # source://bindata/2.5.0/lib/bindata/dsl.rb#280
+    def new(*args); end
+  end
+end
+
+# Get symbol header class according to bits.
+#
+# source://elftools//lib/elftools/structs.rb#177
+ELFTools::Structs::ELF_sym = T.let(T.unsafe(nil), Hash)
+
+# Define some util methods.
+#
+# source://elftools//lib/elftools/util.rb#5
+module ELFTools::Util
+  extend ::ELFTools::Util::ClassMethods
+end
+
+# Class methods.
+#
+# source://elftools//lib/elftools/util.rb#7
+module ELFTools::Util::ClassMethods
+  # Round up the number to be multiple of
+  # +2**bit+.
+  #
+  # @example
+  #   align(10, 1) #=> 10
+  #   align(10, 2) #=> 12
+  #   align(10, 3) #=> 16
+  #   align(10, 4) #=> 16
+  #   align(10, 5) #=> 32
+  # @param num [Integer] Number to be rounded-up.
+  # @param bit [Integer] How many bit to be aligned.
+  # @return [Integer] See examples.
+  #
+  # source://elftools//lib/elftools/util.rb#19
+  def align(num, bit); end
+
+  # Read from stream until reach a null-byte.
+  #
+  # @example
+  #   Util.cstring(File.open('/bin/cat'), 0)
+  #   #=> "\x7FELF\x02\x01\x01"
+  # @param stream [#pos=, #read] Streaming object
+  # @param offset [Integer] Start from here.
+  # @return [String] Result string will never contain null byte.
+  #
+  # source://elftools//lib/elftools/util.rb#61
+  def cstring(stream, offset); end
+
+  # Select objects from enumerator with +.type+ property
+  # equals to +type+.
+  #
+  # Different from naive +Array#select+ is this method
+  # will yield block whenever find a desired object.
+  #
+  # This method is used to simplify the same logic in methods
+  # {ELFFile#sections_by_type}, {ELFFile#segments_by_type}, etc.
+  #
+  # @param enum [Enumerator] An enumerator for further select.
+  # @param type [Object] The type you want.
+  # @return [Array<Object>] The return value will be objects in +enum+ with attribute
+  #   +.type+ equals to +type+.
+  #
+  # source://elftools//lib/elftools/util.rb#88
+  def select_by_type(enum, type); end
+
+  # Fetch the correct value from module +mod+.
+  #
+  # See {ELFTools::ELFFile#segment_by_type} for how to
+  # use this method.
+  #
+  # @param mod [Module] The module defined constant numbers.
+  # @param val [Integer, Symbol, String] Desired value.
+  # @raise [ArgumentError]
+  # @return [Integer] Currently this method always return a value
+  #   from {ELFTools::Constants}.
+  #
+  # source://elftools//lib/elftools/util.rb#36
+  def to_constant(mod, val); end
+end
+
+# Current gem version
+#
+# source://elftools//lib/elftools/version.rb#5
+ELFTools::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/erubi@1.13.0.rbi b/Library/Homebrew/sorbet/rbi/gems/erubi@1.13.0.rbi
new file mode 100644
index 0000000000000..16d45faf0e6eb
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/erubi@1.13.0.rbi
@@ -0,0 +1,150 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `erubi` gem.
+# Please instead update this file by running `bin/tapioca gem erubi`.
+
+
+# source://erubi//lib/erubi.rb#3
+module Erubi
+  private
+
+  def h(_arg0); end
+
+  class << self
+    def h(_arg0); end
+  end
+end
+
+# source://erubi//lib/erubi.rb#51
+class Erubi::Engine
+  # Initialize a new Erubi::Engine.  Options:
+  # +:bufval+ :: The value to use for the buffer variable, as a string (default <tt>'::String.new'</tt>).
+  # +:bufvar+ :: The variable name to use for the buffer variable, as a string.
+  # +:chain_appends+ :: Whether to chain <tt><<</t> calls to the buffer variable. Offers better
+  #                     performance, but can cause issues when the buffer variable is reassigned during
+  #                     template rendering (default +false+).
+  # +:ensure+ :: Wrap the template in a begin/ensure block restoring the previous value of bufvar.
+  # +:escapefunc+ :: The function to use for escaping, as a string (default: <tt>'::Erubi.h'</tt>).
+  # +:escape+ :: Whether to make <tt><%=</tt> escape by default, and <tt><%==</tt> not escape by default.
+  # +:escape_html+ :: Same as +:escape+, with lower priority.
+  # +:filename+ :: The filename for the template.
+  #              the resulting source code.  Note this may cause problems if you are wrapping the resulting
+  #              source code in other code, because the magic comment only has an effect at the beginning of
+  #              the file, and having the magic comment later in the file can trigger warnings.
+  # +:freeze_template_literals+ :: Whether to suffix all literal strings for template code with <tt>.freeze</tt>
+  #                                (default: +true+ on Ruby 2.1+, +false+ on Ruby 2.0 and older).
+  #                                Can be set to +false+ on Ruby 2.3+ when frozen string literals are enabled
+  #                                in order to improve performance.
+  # +:literal_prefix+ :: The prefix to output when using escaped tag delimiters (default <tt>'<%'</tt>).
+  # +:literal_postfix+ :: The postfix to output when using escaped tag delimiters (default <tt>'%>'</tt>).
+  # +:outvar+ :: Same as +:bufvar+, with lower priority.
+  # +:postamble+ :: The postamble for the template, by default returns the resulting source code.
+  # +:preamble+ :: The preamble for the template, by default initializes the buffer variable.
+  # +:regexp+ :: The regexp to use for scanning.
+  # +:src+ :: The initial value to use for the source code, an empty string by default.
+  # +:trim+ :: Whether to trim leading and trailing whitespace, true by default.
+  #
+  # @return [Engine] a new instance of Engine
+  #
+  # source://erubi//lib/erubi.rb#91
+  def initialize(input, properties = T.unsafe(nil)); end
+
+  # The variable name used for the buffer variable.
+  #
+  # source://erubi//lib/erubi.rb#62
+  def bufvar; end
+
+  # The filename of the template, if one was given.
+  #
+  # source://erubi//lib/erubi.rb#59
+  def filename; end
+
+  # The frozen ruby source code generated from the template, which can be evaled.
+  #
+  # source://erubi//lib/erubi.rb#56
+  def src; end
+
+  private
+
+  # Add ruby code to the template
+  #
+  # source://erubi//lib/erubi.rb#223
+  def add_code(code); end
+
+  # Add the given ruby expression result to the template,
+  # escaping it based on the indicator given and escape flag.
+  #
+  # source://erubi//lib/erubi.rb#232
+  def add_expression(indicator, code); end
+
+  # Add the result of Ruby expression to the template
+  #
+  # source://erubi//lib/erubi.rb#241
+  def add_expression_result(code); end
+
+  # Add the escaped result of Ruby expression to the template
+  #
+  # source://erubi//lib/erubi.rb#246
+  def add_expression_result_escaped(code); end
+
+  # Add the given postamble to the src.  Can be overridden in subclasses
+  # to make additional changes to src that depend on the current state.
+  #
+  # source://erubi//lib/erubi.rb#252
+  def add_postamble(postamble); end
+
+  # Add raw text to the template.  Modifies argument if argument is mutable as a memory optimization.
+  # Must be called with a string, cannot be called with nil (Rails's subclass depends on it).
+  #
+  # source://erubi//lib/erubi.rb#210
+  def add_text(text); end
+
+  # Raise an exception, as the base engine class does not support handling other indicators.
+  #
+  # @raise [ArgumentError]
+  #
+  # source://erubi//lib/erubi.rb#258
+  def handle(indicator, code, tailch, rspace, lspace); end
+
+  # Make sure that any current expression has been terminated.
+  # The default is to terminate all expressions, but when
+  # the chain_appends option is used, expressions may not be
+  # terminated.
+  #
+  # source://erubi//lib/erubi.rb#286
+  def terminate_expression; end
+
+  # Make sure the buffer variable is the target of the next append
+  # before yielding to the block. Mark that the buffer is the target
+  # of the next append after the block executes.
+  #
+  # This method should only be called if the block will result in
+  # code where << will append to the bufvar.
+  #
+  # source://erubi//lib/erubi.rb#268
+  def with_buffer; end
+end
+
+# The default regular expression used for scanning.
+#
+# source://erubi//lib/erubi.rb#53
+Erubi::Engine::DEFAULT_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://erubi//lib/erubi.rb#17
+Erubi::FREEZE_TEMPLATE_LITERALS = T.let(T.unsafe(nil), TrueClass)
+
+# source://erubi//lib/erubi.rb#15
+Erubi::MATCH_METHOD = T.let(T.unsafe(nil), Symbol)
+
+# source://erubi//lib/erubi.rb#8
+Erubi::RANGE_FIRST = T.let(T.unsafe(nil), Integer)
+
+# source://erubi//lib/erubi.rb#9
+Erubi::RANGE_LAST = T.let(T.unsafe(nil), Integer)
+
+# source://erubi//lib/erubi.rb#16
+Erubi::SKIP_DEFINED_FOR_INSTANCE_VARIABLE = T.let(T.unsafe(nil), TrueClass)
+
+# source://erubi//lib/erubi.rb#4
+Erubi::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/hana@1.3.7.rbi b/Library/Homebrew/sorbet/rbi/gems/hana@1.3.7.rbi
deleted file mode 100644
index 042aa1baf1a3f..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/hana@1.3.7.rbi
+++ /dev/null
@@ -1,66 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `hana` gem.
-# Please instead update this file by running `bin/tapioca gem hana`.
-
-module Hana; end
-
-class Hana::Patch
-  def initialize(is); end
-
-  def apply(doc); end
-
-  private
-
-  def add(ins, doc); end
-  def add_op(dest, key, obj); end
-  def check_index(obj, key); end
-  def copy(ins, doc); end
-  def get_path(ins); end
-  def move(ins, doc); end
-  def remove(ins, doc); end
-  def replace(ins, doc); end
-  def rm_op(obj, key); end
-  def test(ins, doc); end
-end
-
-class Hana::Patch::Exception < ::StandardError; end
-Hana::Patch::FROM = T.let(T.unsafe(nil), String)
-
-class Hana::Patch::FailedTestException < ::Hana::Patch::Exception
-  def initialize(path, value); end
-
-  def path; end
-  def path=(_arg0); end
-  def value; end
-  def value=(_arg0); end
-end
-
-class Hana::Patch::IndexError < ::Hana::Patch::Exception; end
-class Hana::Patch::InvalidObjectOperationException < ::Hana::Patch::Exception; end
-class Hana::Patch::InvalidPath < ::Hana::Patch::Exception; end
-class Hana::Patch::MissingTargetException < ::Hana::Patch::Exception; end
-class Hana::Patch::ObjectOperationOnArrayException < ::Hana::Patch::Exception; end
-class Hana::Patch::OutOfBoundsException < ::Hana::Patch::Exception; end
-Hana::Patch::VALID = T.let(T.unsafe(nil), Hash)
-Hana::Patch::VALUE = T.let(T.unsafe(nil), String)
-
-class Hana::Pointer
-  include ::Enumerable
-
-  def initialize(path); end
-
-  def each(&block); end
-  def eval(object); end
-
-  class << self
-    def eval(list, object); end
-    def parse(path); end
-  end
-end
-
-Hana::Pointer::ESC = T.let(T.unsafe(nil), Hash)
-class Hana::Pointer::Exception < ::StandardError; end
-class Hana::Pointer::FormatError < ::Hana::Pointer::Exception; end
-Hana::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi b/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi
deleted file mode 100644
index 87172a89cc86e..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi
+++ /dev/null
@@ -1,853 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `highline` gem.
-# Please instead update this file by running `bin/tapioca gem highline`.
-
-::RUBY19 = T.let(T.unsafe(nil), TrueClass)
-
-class HighLine
-  include ::HighLine::BuiltinStyles
-  include ::HighLine::CustomErrors
-  extend ::HighLine::BuiltinStyles::ClassMethods
-  extend ::SingleForwardable
-
-  def initialize(input = T.unsafe(nil), output = T.unsafe(nil), wrap_at = T.unsafe(nil), page_at = T.unsafe(nil), indent_size = T.unsafe(nil), indent_level = T.unsafe(nil)); end
-
-  def agree(yes_or_no_question, character = T.unsafe(nil)); end
-  def ask(template_or_question, answer_type = T.unsafe(nil), &details); end
-  def choose(*items, &details); end
-  def color(string, *colors); end
-  def color_code(*colors); end
-  def get_response_character_mode(question); end
-  def get_response_getc_mode(question); end
-  def get_response_line_mode(question); end
-  def indent(increase = T.unsafe(nil), statement = T.unsafe(nil), multiline = T.unsafe(nil)); end
-  def indent_level; end
-  def indent_level=(_arg0); end
-  def indent_size; end
-  def indent_size=(_arg0); end
-  def indentation; end
-  def input; end
-  def key; end
-  def key=(_arg0); end
-  def list(items, mode = T.unsafe(nil), option = T.unsafe(nil)); end
-  def multi_indent; end
-  def multi_indent=(_arg0); end
-  def new_scope; end
-  def newline; end
-  def output; end
-  def output_cols; end
-  def output_rows; end
-  def page_at; end
-  def page_at=(setting); end
-  def puts(*args); end
-  def render_statement(statement); end
-  def reset_use_color; end
-  def say(statement); end
-  def shell_style_lambda(menu); end
-  def terminal; end
-  def track_eof; end
-  def track_eof=(_arg0); end
-  def track_eof?; end
-  def uncolor(string); end
-  def use_color; end
-  def use_color=(_arg0); end
-  def use_color?; end
-  def wrap_at; end
-  def wrap_at=(setting); end
-
-  private
-
-  def actual_length(text); end
-  def confirm(question); end
-  def default_use_color; end
-  def erase_current_line; end
-  def get_line(question); end
-  def get_line_raw_no_echo_mode(question); end
-  def ignore_arrow_key; end
-  def last_answer(answers); end
-  def line_overflow_for_question?(line, question); end
-  def output_erase_char; end
-  def say_last_char_or_echo_char(line, question); end
-  def say_new_line_or_overwrite(question); end
-  def unique_answers(list); end
-
-  class << self
-    def String(s); end
-    def Style(*args); end
-    def agree(*args, &block); end
-    def ask(*args, &block); end
-    def choose(*args, &block); end
-    def color(*args, &block); end
-    def color_code(*args, &block); end
-    def color_scheme; end
-    def color_scheme=(_arg0); end
-    def colorize_strings; end
-    def default_instance; end
-    def default_instance=(_arg0); end
-    def find_or_create_style(arg); end
-    def find_or_create_style_list(*args); end
-    def reset; end
-    def reset_color_scheme; end
-    def reset_use_color(*args, &block); end
-    def say(*args, &block); end
-    def supports_rgb_color?; end
-    def track_eof=(*args, &block); end
-    def track_eof?(*args, &block); end
-    def uncolor(*args, &block); end
-    def use_color=(*args, &block); end
-    def use_color?(*args, &block); end
-    def using_color_scheme?; end
-  end
-end
-
-module HighLine::BuiltinStyles
-  mixes_in_class_methods ::HighLine::BuiltinStyles::ClassMethods
-
-  class << self
-    def included(base); end
-  end
-end
-
-HighLine::BuiltinStyles::BASIC_COLORS = T.let(T.unsafe(nil), Array)
-HighLine::BuiltinStyles::BLACK = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BLACK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::BLINK = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BLINK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::BLUE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BLUE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::BOLD = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BOLD_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::BRIGHT_BLACK = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BRIGHT_BLACK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::BRIGHT_BLUE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BRIGHT_BLUE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::BRIGHT_CYAN = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BRIGHT_CYAN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::BRIGHT_GRAY = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BRIGHT_GRAY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::BRIGHT_GREEN = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BRIGHT_GREEN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::BRIGHT_GREY = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BRIGHT_GREY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::BRIGHT_MAGENTA = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BRIGHT_MAGENTA_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::BRIGHT_NONE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BRIGHT_NONE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::BRIGHT_RED = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BRIGHT_RED_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::BRIGHT_WHITE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BRIGHT_WHITE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::BRIGHT_YELLOW = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::BRIGHT_YELLOW_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::CLEAR = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::CLEAR_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::COLORS = T.let(T.unsafe(nil), Array)
-HighLine::BuiltinStyles::COLOR_LIST = T.let(T.unsafe(nil), Hash)
-HighLine::BuiltinStyles::CONCEALED = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::CONCEALED_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::CYAN = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::CYAN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-
-module HighLine::BuiltinStyles::ClassMethods
-  def const_missing(name); end
-end
-
-HighLine::BuiltinStyles::ClassMethods::RGB_COLOR_PATTERN = T.let(T.unsafe(nil), Regexp)
-HighLine::BuiltinStyles::DARK = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::DARK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ERASE_CHAR = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ERASE_CHAR_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ERASE_LINE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ERASE_LINE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::GRAY = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::GRAY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::GREEN = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::GREEN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::GREY = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::GREY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::LIGHT_BLACK = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::LIGHT_BLACK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::LIGHT_BLUE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::LIGHT_BLUE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::LIGHT_CYAN = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::LIGHT_CYAN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::LIGHT_GRAY = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::LIGHT_GRAY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::LIGHT_GREEN = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::LIGHT_GREEN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::LIGHT_GREY = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::LIGHT_GREY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::LIGHT_MAGENTA = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::LIGHT_MAGENTA_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::LIGHT_NONE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::LIGHT_NONE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::LIGHT_RED = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::LIGHT_RED_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::LIGHT_WHITE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::LIGHT_WHITE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::LIGHT_YELLOW = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::LIGHT_YELLOW_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::MAGENTA = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::MAGENTA_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::NONE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::NONE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_BLACK = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_BLACK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_BLUE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_BLUE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_BRIGHT_BLACK = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_BRIGHT_BLACK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_BRIGHT_BLUE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_BRIGHT_BLUE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_BRIGHT_CYAN = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_BRIGHT_CYAN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_BRIGHT_GRAY = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_BRIGHT_GRAY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_BRIGHT_GREEN = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_BRIGHT_GREEN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_BRIGHT_GREY = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_BRIGHT_GREY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_BRIGHT_MAGENTA = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_BRIGHT_MAGENTA_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_BRIGHT_NONE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_BRIGHT_NONE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_BRIGHT_RED = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_BRIGHT_RED_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_BRIGHT_WHITE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_BRIGHT_WHITE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_BRIGHT_YELLOW = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_BRIGHT_YELLOW_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_CYAN = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_CYAN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_GRAY = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_GRAY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_GREEN = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_GREEN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_GREY = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_GREY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_LIGHT_BLACK = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_LIGHT_BLACK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_LIGHT_BLUE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_LIGHT_BLUE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_LIGHT_CYAN = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_LIGHT_CYAN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_LIGHT_GRAY = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_LIGHT_GRAY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_LIGHT_GREEN = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_LIGHT_GREEN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_LIGHT_GREY = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_LIGHT_GREY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_LIGHT_MAGENTA = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_LIGHT_MAGENTA_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_LIGHT_NONE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_LIGHT_NONE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_LIGHT_RED = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_LIGHT_RED_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_LIGHT_WHITE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_LIGHT_WHITE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_LIGHT_YELLOW = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_LIGHT_YELLOW_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_MAGENTA = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_MAGENTA_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_NONE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_NONE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_RED = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_RED_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_WHITE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_WHITE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::ON_YELLOW = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::ON_YELLOW_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::RED = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::RED_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::RESET = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::RESET_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::REVERSE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::REVERSE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::STYLES = T.let(T.unsafe(nil), Array)
-HighLine::BuiltinStyles::STYLE_LIST = T.let(T.unsafe(nil), Hash)
-HighLine::BuiltinStyles::UNDERLINE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::UNDERLINE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::UNDERSCORE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::UNDERSCORE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::WHITE = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::WHITE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-HighLine::BuiltinStyles::YELLOW = T.let(T.unsafe(nil), String)
-HighLine::BuiltinStyles::YELLOW_STYLE = T.let(T.unsafe(nil), HighLine::Style)
-
-class HighLine::ColorScheme
-  def initialize(h = T.unsafe(nil)); end
-
-  def [](color_tag); end
-  def []=(color_tag, constants); end
-  def definition(color_tag); end
-  def include?(color_tag); end
-  def keys; end
-  def load_from_hash(h); end
-  def to_hash; end
-
-  private
-
-  def to_constant(v); end
-  def to_symbol(t); end
-end
-
-module HighLine::CustomErrors; end
-
-class HighLine::CustomErrors::ExplainableError < ::StandardError
-  def explanation_key; end
-end
-
-class HighLine::CustomErrors::NoAutoCompleteMatch < ::HighLine::CustomErrors::ExplainableError
-  def explanation_key; end
-end
-
-class HighLine::CustomErrors::NoConfirmationQuestionError < ::HighLine::CustomErrors::ExplainableError
-  def explanation_key; end
-end
-
-class HighLine::CustomErrors::NotInRangeQuestionError < ::HighLine::CustomErrors::ExplainableError
-  def explanation_key; end
-end
-
-class HighLine::CustomErrors::NotValidQuestionError < ::HighLine::CustomErrors::ExplainableError
-  def explanation_key; end
-end
-
-class HighLine::CustomErrors::QuestionError < ::HighLine::CustomErrors::ExplainableError
-  def explanation_key; end
-end
-
-class HighLine::List
-  def initialize(items, options = T.unsafe(nil)); end
-
-  def col_down; end
-  def col_down_mode; end
-  def cols; end
-  def cols=(cols); end
-  def items; end
-  def list; end
-  def row_join_str_size; end
-  def row_join_string; end
-  def row_join_string=(_arg0); end
-  def slice_by_cols; end
-  def slice_by_rows; end
-  def to_a; end
-  def to_s; end
-  def transpose; end
-  def transpose_mode; end
-
-  private
-
-  def build; end
-  def items_sliced_by_cols; end
-  def items_sliced_by_rows; end
-  def row_count; end
-  def stringfy(row); end
-end
-
-class HighLine::ListRenderer
-  def initialize(items, mode = T.unsafe(nil), option = T.unsafe(nil), highline); end
-
-  def highline; end
-  def items; end
-  def mode; end
-  def option; end
-  def render; end
-
-  private
-
-  def actual_length(text); end
-  def actual_lengths_for(line); end
-  def col_count; end
-  def col_count_calculate; end
-  def get_col_widths(lines); end
-  def get_row_widths(lines); end
-  def get_segment_widths(lines); end
-  def inside_line_size_limit?(widths); end
-  def items_max_length; end
-  def line_size_limit; end
-  def list_columns_across_mode; end
-  def list_columns_down_mode; end
-  def list_default_mode; end
-  def list_inline_mode; end
-  def list_uneven_columns_down_mode; end
-  def list_uneven_columns_mode(list = T.unsafe(nil)); end
-  def max_length(items); end
-  def pad_char; end
-  def pad_uneven_rows(list, widths); end
-  def render_list_items(items); end
-  def right_pad_field(field, width); end
-  def right_pad_row(row, widths); end
-  def right_padded_items; end
-  def row_count; end
-  def row_join_str_size; end
-  def row_join_string; end
-  def row_join_string=(_arg0); end
-  def row_to_s(row); end
-  def stringfy_list(list); end
-  def transpose(lines); end
-end
-
-class HighLine::Menu < ::HighLine::Question
-  def initialize; end
-
-  def add_item(item); end
-  def all_items; end
-  def build_item(*args); end
-  def choice(name, help = T.unsafe(nil), text = T.unsafe(nil), &action); end
-  def choices(*names, &action); end
-  def decorate_index(index); end
-  def decorate_item(text, ix); end
-  def find_item_from_selection(items, selection); end
-  def flow; end
-  def flow=(_arg0); end
-  def gather_selected(highline_context, selections, details = T.unsafe(nil)); end
-  def get_item_by_letter(items, selection); end
-  def get_item_by_number(items, selection); end
-  def header; end
-  def header=(_arg0); end
-  def help(topic, help); end
-  def hidden(name, help = T.unsafe(nil), &action); end
-  def index; end
-  def index=(style); end
-  def index_color; end
-  def index_color=(_arg0); end
-  def index_suffix; end
-  def index_suffix=(_arg0); end
-  def init_help; end
-  def layout; end
-  def layout=(new_layout); end
-  def list_option; end
-  def list_option=(_arg0); end
-  def map_items_by_index; end
-  def map_items_by_name; end
-  def mark_for_decoration(text, ix); end
-  def nil_on_handled; end
-  def nil_on_handled=(_arg0); end
-  def options; end
-  def parse_list; end
-  def prompt; end
-  def prompt=(_arg0); end
-  def select(highline_context, selection, details = T.unsafe(nil)); end
-  def select_by; end
-  def select_by=(_arg0); end
-  def shell; end
-  def shell=(_arg0); end
-  def show_default_if_any; end
-  def to_ary; end
-  def to_s; end
-  def update_responses; end
-  def value_for_array_selections(items, selections, details); end
-  def value_for_hash_selections(items, selections, details); end
-  def value_for_selected_item(item, details); end
-
-  class << self
-    def index_color; end
-    def index_color=(_arg0); end
-  end
-end
-
-class HighLine::Menu::Item
-  def initialize(name, attributes); end
-
-  def action; end
-  def help; end
-  def item_help; end
-  def name; end
-  def text; end
-end
-
-class HighLine::Paginator
-  def initialize(highline); end
-
-  def continue_paging?; end
-  def highline; end
-  def page_print(text); end
-end
-
-class HighLine::Question
-  include ::HighLine::CustomErrors
-
-  def initialize(template, answer_type); end
-
-  def above; end
-  def above=(_arg0); end
-  def answer; end
-  def answer=(_arg0); end
-  def answer_or_default(answer_string); end
-  def answer_type; end
-  def answer_type=(_arg0); end
-  def ask_on_error_msg; end
-  def below; end
-  def below=(_arg0); end
-  def build_responses(message_source = T.unsafe(nil)); end
-  def build_responses_new_hash(message_source); end
-  def case; end
-  def case=(_arg0); end
-  def change_case(answer_string); end
-  def character; end
-  def character=(_arg0); end
-  def check_range; end
-  def choices_complete(answer_string); end
-  def completion; end
-  def completion=(_arg0); end
-  def confirm; end
-  def confirm=(_arg0); end
-  def confirm_question(highline); end
-  def convert; end
-  def default; end
-  def default=(_arg0); end
-  def default_responses_hash; end
-  def directory; end
-  def directory=(_arg0); end
-  def echo; end
-  def echo=(_arg0); end
-  def expected_range; end
-  def final_response(error); end
-  def final_responses; end
-  def first_answer; end
-  def first_answer=(_arg0); end
-  def first_answer?; end
-  def format_answer(answer_string); end
-  def gather; end
-  def gather=(_arg0); end
-  def get_echo_for_response(response); end
-  def get_response(highline); end
-  def get_response_or_default(highline); end
-  def glob; end
-  def glob=(_arg0); end
-  def in; end
-  def in=(_arg0); end
-  def in_range?; end
-  def limit; end
-  def limit=(_arg0); end
-  def overwrite; end
-  def overwrite=(_arg0); end
-  def readline; end
-  def readline=(_arg0); end
-  def remove_whitespace(answer_string); end
-  def responses; end
-  def selection; end
-  def show_question(highline); end
-  def template; end
-  def template=(_arg0); end
-  def to_s; end
-  def valid_answer?; end
-  def validate; end
-  def validate=(_arg0); end
-  def verify_match; end
-  def verify_match=(_arg0); end
-  def whitespace; end
-  def whitespace=(_arg0); end
-
-  private
-
-  def append_default; end
-  def choice_error_str(message_source); end
-
-  class << self
-    def build(template_or_question, answer_type = T.unsafe(nil), &details); end
-  end
-end
-
-class HighLine::Question::AnswerConverter
-  extend ::Forwardable
-
-  def initialize(question); end
-
-  def answer(*args, &block); end
-  def answer=(*args, &block); end
-  def answer_type(*args, &block); end
-  def check_range(*args, &block); end
-  def choices_complete(*args, &block); end
-  def convert; end
-  def directory(*args, &block); end
-  def to_array; end
-  def to_file; end
-  def to_float; end
-  def to_integer; end
-  def to_pathname; end
-  def to_proc; end
-  def to_regexp; end
-  def to_string; end
-  def to_symbol; end
-
-  private
-
-  def convert_by_answer_type; end
-end
-
-class HighLine::QuestionAsker
-  include ::HighLine::CustomErrors
-
-  def initialize(question, highline); end
-
-  def ask_once; end
-  def gather_answers; end
-  def gather_hash; end
-  def gather_integer; end
-  def gather_regexp; end
-  def question; end
-
-  private
-
-  def answer_matches_regex(answer); end
-  def explain_error(explanation_key); end
-  def gather_answers_based_on_type; end
-  def gather_with_array; end
-end
-
-class HighLine::SampleColorScheme < ::HighLine::ColorScheme
-  def initialize(_h = T.unsafe(nil)); end
-end
-
-HighLine::SampleColorScheme::SAMPLE_SCHEME = T.let(T.unsafe(nil), Hash)
-
-class HighLine::Statement
-  def initialize(source, highline); end
-
-  def highline; end
-  def source; end
-  def statement; end
-  def template_string; end
-  def to_s; end
-
-  private
-
-  def format_statement; end
-  def render_template; end
-  def stringfy(template_string); end
-  def template; end
-
-  class << self
-    def const_missing(constant); end
-  end
-end
-
-class HighLine::String < ::String
-  include ::HighLine::StringExtensions
-
-  def black; end
-  def blink; end
-  def blue; end
-  def bold; end
-  def bright_black; end
-  def bright_blue; end
-  def bright_cyan; end
-  def bright_gray; end
-  def bright_green; end
-  def bright_grey; end
-  def bright_magenta; end
-  def bright_none; end
-  def bright_red; end
-  def bright_white; end
-  def bright_yellow; end
-  def clear; end
-  def color(*args); end
-  def concealed; end
-  def cyan; end
-  def dark; end
-  def foreground(*args); end
-  def gray; end
-  def green; end
-  def grey; end
-  def light_black; end
-  def light_blue; end
-  def light_cyan; end
-  def light_gray; end
-  def light_green; end
-  def light_grey; end
-  def light_magenta; end
-  def light_none; end
-  def light_red; end
-  def light_white; end
-  def light_yellow; end
-  def magenta; end
-  def method_missing(method, *_args); end
-  def none; end
-  def on(arg); end
-  def on_black; end
-  def on_blue; end
-  def on_bright_black; end
-  def on_bright_blue; end
-  def on_bright_cyan; end
-  def on_bright_gray; end
-  def on_bright_green; end
-  def on_bright_grey; end
-  def on_bright_magenta; end
-  def on_bright_none; end
-  def on_bright_red; end
-  def on_bright_white; end
-  def on_bright_yellow; end
-  def on_cyan; end
-  def on_gray; end
-  def on_green; end
-  def on_grey; end
-  def on_light_black; end
-  def on_light_blue; end
-  def on_light_cyan; end
-  def on_light_gray; end
-  def on_light_green; end
-  def on_light_grey; end
-  def on_light_magenta; end
-  def on_light_none; end
-  def on_light_red; end
-  def on_light_white; end
-  def on_light_yellow; end
-  def on_magenta; end
-  def on_none; end
-  def on_red; end
-  def on_rgb(*colors); end
-  def on_white; end
-  def on_yellow; end
-  def red; end
-  def reset; end
-  def reverse; end
-  def rgb(*colors); end
-  def uncolor; end
-  def underline; end
-  def underscore; end
-  def white; end
-  def yellow; end
-
-  private
-
-  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
-  def setup_color_code(*colors); end
-end
-
-module HighLine::StringExtensions
-  class << self
-    def define_builtin_style_methods(base); end
-    def define_style_support_methods(base); end
-    def included(base); end
-  end
-end
-
-HighLine::StringExtensions::STYLE_METHOD_NAME_PATTERN = T.let(T.unsafe(nil), Regexp)
-
-class HighLine::Style
-  def initialize(defn = T.unsafe(nil)); end
-
-  def blue; end
-  def bright; end
-  def builtin; end
-  def builtin=(_arg0); end
-  def code; end
-  def color(string); end
-  def dup; end
-  def green; end
-  def light; end
-  def list; end
-  def name; end
-  def on; end
-  def red; end
-  def rgb; end
-  def rgb=(_arg0); end
-  def to_hash; end
-  def variant(new_name, options = T.unsafe(nil)); end
-
-  private
-
-  def create_bright_variant(variant_name); end
-  def find_style(name); end
-
-  class << self
-    def ansi_rgb_to_hex(ansi_number); end
-    def clear_index; end
-    def code_index; end
-    def index(style); end
-    def list; end
-    def rgb(*colors); end
-    def rgb_hex(*colors); end
-    def rgb_number(*parts); end
-    def rgb_parts(hex); end
-    def uncolor(string); end
-  end
-end
-
-class HighLine::TemplateRenderer
-  extend ::Forwardable
-
-  def initialize(template, source, highline); end
-
-  def answer(*args, &block); end
-  def answer_type(*args, &block); end
-  def color(*args, &block); end
-  def header(*args, &block); end
-  def highline; end
-  def key(*args, &block); end
-  def list(*args, &block); end
-  def menu; end
-  def method_missing(method, *args); end
-  def prompt(*args, &block); end
-  def render; end
-  def source; end
-  def template; end
-
-  class << self
-    def const_missing(name); end
-  end
-end
-
-class HighLine::Terminal
-  def initialize(input, output); end
-
-  def character_mode; end
-  def get_character; end
-  def get_line(question, highline); end
-  def get_line_default(highline); end
-  def get_line_with_readline(question, highline); end
-  def initialize_system_extensions; end
-  def input; end
-  def jruby?; end
-  def output; end
-  def raw_no_echo_mode; end
-  def raw_no_echo_mode_exec; end
-  def readline_read(question); end
-  def restore_mode; end
-  def rubinius?; end
-  def terminal_size; end
-  def windows?; end
-
-  private
-
-  def restore_stty; end
-  def run_preserving_stty; end
-  def save_stty; end
-
-  class << self
-    def get_terminal(input, output); end
-  end
-end
-
-class HighLine::Terminal::IOConsole < ::HighLine::Terminal
-  def get_character; end
-  def raw_no_echo_mode; end
-  def restore_mode; end
-  def terminal_size; end
-end
-
-HighLine::VERSION = T.let(T.unsafe(nil), String)
-
-module HighLine::Wrapper
-  class << self
-    def actual_length(string_with_escapes); end
-    def wrap(text, wrap_at); end
-  end
-end
-
-class Object < ::BasicObject
-  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
-  include ::ActiveSupport::ForkTracker::CoreExt
-  include ::ActiveSupport::ForkTracker::CoreExtPrivate
-  include ::Kernel
-  include ::JSON::Ext::Generator::GeneratorMethods::Object
-  include ::PP::ObjectMixin
-  include ::ActiveSupport::Dependencies::Loadable
-  include ::ActiveSupport::Tryable
-
-  def or_ask(*args, &details); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi b/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi
deleted file mode 100644
index c07ed11de18cb..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi
+++ /dev/null
@@ -1,649 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `hpricot` gem.
-# Please instead update this file by running `bin/tapioca gem hpricot`.
-
-::RUBY19 = T.let(T.unsafe(nil), TrueClass)
-
-module Hpricot
-  class << self
-    def XML(input = T.unsafe(nil), opts = T.unsafe(nil), &blk); end
-    def buffer_size; end
-    def buffer_size=(_arg0); end
-    def build(ele = T.unsafe(nil), assigns = T.unsafe(nil), &blk); end
-    def css(_arg0, _arg1, _arg2); end
-    def make(input = T.unsafe(nil), opts = T.unsafe(nil), &blk); end
-    def parse(input = T.unsafe(nil), opts = T.unsafe(nil), &blk); end
-    def scan(*_arg0); end
-    def uxs(str); end
-  end
-end
-
-Hpricot::AttrCore = T.let(T.unsafe(nil), Array)
-Hpricot::AttrEvents = T.let(T.unsafe(nil), Array)
-Hpricot::AttrFocus = T.let(T.unsafe(nil), Array)
-Hpricot::AttrHAlign = T.let(T.unsafe(nil), Array)
-Hpricot::AttrI18n = T.let(T.unsafe(nil), Array)
-Hpricot::AttrVAlign = T.let(T.unsafe(nil), Array)
-
-class Hpricot::Attributes
-  def initialize(e); end
-
-  def [](k); end
-  def []=(k, v); end
-  def element; end
-  def element=(_arg0); end
-  def inspect; end
-  def to_hash; end
-  def to_s; end
-end
-
-Hpricot::Attrs = T.let(T.unsafe(nil), Array)
-
-class Hpricot::BlankSlate
-  class << self
-    def hide(name); end
-  end
-end
-
-class Hpricot::BogusETag
-  include ::Hpricot
-  include ::Hpricot::Node
-  include ::Hpricot::Leaf
-  include ::Hpricot::Traverse
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::BogusETag::Trav
-
-  def initialize(name); end
-
-  def clear_raw; end
-  def output(out, opts = T.unsafe(nil)); end
-  def pretty_print(q); end
-  def raw_string; end
-end
-
-module Hpricot::BogusETag::Trav
-  include ::Hpricot::Traverse
-  include ::Hpricot::Leaf::Trav
-end
-
-module Hpricot::Builder
-  def <<(string); end
-  def a(*args, &block); end
-  def abbr(*args, &block); end
-  def acronym(*args, &block); end
-  def add_child(ele); end
-  def address(*args, &block); end
-  def applet(*args, &block); end
-  def area(*args, &block); end
-  def b(*args, &block); end
-  def base(*args, &block); end
-  def basefont(*args, &block); end
-  def bdo(*args, &block); end
-  def big(*args, &block); end
-  def blockquote(*args, &block); end
-  def body(*args, &block); end
-  def br(*args, &block); end
-  def build(*a, &b); end
-  def button(*args, &block); end
-  def caption(*args, &block); end
-  def center(*args, &block); end
-  def cite(*args, &block); end
-  def code(*args, &block); end
-  def col(*args, &block); end
-  def colgroup(*args, &block); end
-  def concat(string); end
-  def dd(*args, &block); end
-  def del(*args, &block); end
-  def dfn(*args, &block); end
-  def dir(*args, &block); end
-  def div(*args, &block); end
-  def dl(*args, &block); end
-  def doctype(target, pub, sys); end
-  def dt(*args, &block); end
-  def em(*args, &block); end
-  def fieldset(*args, &block); end
-  def font(*args, &block); end
-  def form(*args, &block); end
-  def h1(*args, &block); end
-  def h2(*args, &block); end
-  def h3(*args, &block); end
-  def h4(*args, &block); end
-  def h5(*args, &block); end
-  def h6(*args, &block); end
-  def head(*args, &block); end
-  def hr(*args, &block); end
-  def html(*args, &block); end
-  def html_tag(sym, *args, &block); end
-  def i(*args, &block); end
-  def iframe(*args, &block); end
-  def img(*args, &block); end
-  def input(*args, &block); end
-  def ins(*args, &block); end
-  def isindex(*args, &block); end
-  def kbd(*args, &block); end
-  def label(*args, &block); end
-  def legend(*args, &block); end
-  def li(*args, &block); end
-  def link(*args, &block); end
-  def map(*args, &block); end
-  def menu(*args, &block); end
-  def meta(*args, &block); end
-  def noframes(*args, &block); end
-  def noscript(*args, &block); end
-  def object(*args, &block); end
-  def ol(*args, &block); end
-  def optgroup(*args, &block); end
-  def option(*args, &block); end
-  def p(*args, &block); end
-  def param(*args, &block); end
-  def pre(*args, &block); end
-  def q(*args, &block); end
-  def s(*args, &block); end
-  def samp(*args, &block); end
-  def script(*args, &block); end
-  def select(*args, &block); end
-  def small(*args, &block); end
-  def span(*args, &block); end
-  def strike(*args, &block); end
-  def strong(*args, &block); end
-  def style(*args, &block); end
-  def sub(*args, &block); end
-  def sup(*args, &block); end
-  def table(*args, &block); end
-  def tag!(tag, *args, &block); end
-  def tbody(*args, &block); end
-  def td(*args, &block); end
-  def text(string); end
-  def text!(string); end
-  def textarea(*args, &block); end
-  def tfoot(*args, &block); end
-  def th(*args, &block); end
-  def thead(*args, &block); end
-  def title(*args, &block); end
-  def tr(*args, &block); end
-  def tt(*args, &block); end
-  def u(*args, &block); end
-  def ul(*args, &block); end
-  def var(*args, &block); end
-  def xhtml_strict(attrs = T.unsafe(nil), &block); end
-  def xhtml_transitional(attrs = T.unsafe(nil), &block); end
-
-  private
-
-  def xhtml_html(attrs = T.unsafe(nil), &block); end
-
-  class << self
-    def set(option, value); end
-  end
-end
-
-class Hpricot::CData
-  include ::Hpricot
-  include ::Hpricot::Node
-  include ::Hpricot::Leaf
-  include ::Hpricot::Traverse
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::CData::Trav
-
-  def initialize(content); end
-
-  def content; end
-  def content=(_arg0); end
-  def inner_text; end
-  def output(out, opts = T.unsafe(nil)); end
-  def raw_string; end
-  def to_plain_text; end
-  def to_s; end
-end
-
-module Hpricot::CData::Trav
-  include ::Hpricot::Traverse
-  include ::Hpricot::Leaf::Trav
-end
-
-class Hpricot::Comment
-  include ::Hpricot
-  include ::Hpricot::Node
-  include ::Hpricot::Leaf
-  include ::Hpricot::Traverse
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Comment::Trav
-
-  def content; end
-  def content=(_arg0); end
-  def output(out, opts = T.unsafe(nil)); end
-  def pathname; end
-  def raw_string; end
-end
-
-module Hpricot::Comment::Trav
-  include ::Hpricot::Traverse
-  include ::Hpricot::Leaf::Trav
-end
-
-module Hpricot::Container
-  include ::Hpricot
-  include ::Hpricot::Node
-end
-
-module Hpricot::Container::Trav
-  include ::Hpricot::Traverse
-
-  def classes; end
-  def containers; end
-  def each_child(&block); end
-  def each_child_with_index(&block); end
-  def each_hyperlink; end
-  def each_hyperlink_uri(base_uri = T.unsafe(nil)); end
-  def each_uri(base_uri = T.unsafe(nil)); end
-  def filter(&block); end
-  def find_element(*names); end
-  def following_siblings; end
-  def get_element_by_id(id); end
-  def get_elements_by_tag_name(*a); end
-  def insert_after(nodes, ele); end
-  def insert_before(nodes, ele); end
-  def next_sibling; end
-  def preceding_siblings; end
-  def previous_sibling; end
-  def replace_child(old, new); end
-  def siblings_at(*pos); end
-  def traverse_text_internal(&block); end
-
-  private
-
-  def each_hyperlink_attribute; end
-end
-
-class Hpricot::Context
-  include ::Hpricot
-end
-
-class Hpricot::CssProxy < ::Hpricot::BlankSlate
-  def initialize(builder, sym); end
-
-  def method_missing(id_or_class, *args, &block); end
-end
-
-class Hpricot::Doc
-  include ::Hpricot
-  include ::Hpricot::Node
-  include ::Hpricot::Container
-  include ::Hpricot::Traverse
-  include ::Hpricot::Container::Trav
-  include ::Hpricot::Doc::Trav
-
-  def altered!; end
-  def inspect; end
-  def inspect_tree; end
-  def make(input = T.unsafe(nil), &blk); end
-  def output(out, opts = T.unsafe(nil)); end
-  def pretty_print(q); end
-end
-
-module Hpricot::Doc::Trav
-  include ::Hpricot::Traverse
-  include ::Hpricot::Container::Trav
-
-  def author; end
-  def css_path; end
-  def root; end
-  def title; end
-  def traverse_all_element(&block); end
-  def traverse_some_element(name_set, &block); end
-  def xpath; end
-end
-
-class Hpricot::DocType
-  include ::Hpricot
-  include ::Hpricot::Node
-  include ::Hpricot::Leaf
-  include ::Hpricot::Traverse
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::DocType::Trav
-
-  def initialize(target, pub, sys); end
-
-  def clear_raw; end
-  def output(out, opts = T.unsafe(nil)); end
-  def pathname; end
-  def public_id; end
-  def public_id=(_arg0); end
-  def raw_string; end
-  def system_id; end
-  def system_id=(_arg0); end
-  def target; end
-  def target=(_arg0); end
-end
-
-module Hpricot::DocType::Trav
-  include ::Hpricot::Traverse
-  include ::Hpricot::Leaf::Trav
-end
-
-class Hpricot::ETag < ::Hpricot::BogusETag
-  include ::Hpricot::Tag
-
-  def inspect; end
-  def output(out, opts = T.unsafe(nil)); end
-  def pretty_print(q); end
-end
-
-class Hpricot::Elem
-  include ::Hpricot
-  include ::Hpricot::Node
-  include ::Hpricot::Container
-  include ::Hpricot::Traverse
-  include ::Hpricot::Container::Trav
-  include ::Hpricot::Elem::Trav
-
-  def initialize(tag, attrs = T.unsafe(nil), children = T.unsafe(nil), etag = T.unsafe(nil)); end
-
-  def attributes; end
-  def attributes_as_html; end
-  def clear_raw; end
-  def empty?; end
-  def inspect; end
-  def inspect_tree(depth = T.unsafe(nil)); end
-  def output(out, opts = T.unsafe(nil)); end
-  def pathname; end
-  def pretty_print(q); end
-  def pretty_print_stag(q); end
-  def to_plain_text; end
-end
-
-module Hpricot::Elem::Trav
-  include ::Hpricot::Traverse
-  include ::Hpricot::Container::Trav
-
-  def [](name); end
-  def []=(name, val); end
-  def get_attribute(name); end
-  def has_attribute?(name); end
-  def remove_attribute(name); end
-  def set_attribute(name, val); end
-  def traverse_all_element(&block); end
-  def traverse_some_element(name_set, &block); end
-end
-
-Hpricot::ElementContent = T.let(T.unsafe(nil), Hash)
-Hpricot::ElementExclusions = T.let(T.unsafe(nil), Hash)
-Hpricot::ElementInclusions = T.let(T.unsafe(nil), Hash)
-
-class Hpricot::Elements < ::Array
-  def %(expr, &blk); end
-  def /(*expr, &blk); end
-  def add_class(class_name); end
-  def after(str = T.unsafe(nil), &blk); end
-  def append(str = T.unsafe(nil), &blk); end
-  def at(expr, &blk); end
-  def attr(key, value = T.unsafe(nil), &blk); end
-  def before(str = T.unsafe(nil), &blk); end
-  def empty; end
-  def filter(expr); end
-  def html(*string); end
-  def html=(string); end
-  def innerHTML(*string); end
-  def innerHTML=(string); end
-  def inner_html(*string); end
-  def inner_html=(string); end
-  def inner_text; end
-  def inspect; end
-  def not(expr); end
-  def prepend(str = T.unsafe(nil), &blk); end
-  def pretty_print(q); end
-  def remove; end
-  def remove_attr(name); end
-  def remove_class(name = T.unsafe(nil)); end
-  def search(*expr, &blk); end
-  def set(key, value = T.unsafe(nil), &blk); end
-  def text; end
-  def to_html; end
-  def to_s; end
-  def wrap(str = T.unsafe(nil), &blk); end
-
-  private
-
-  def copy_node(node, l); end
-
-  class << self
-    def expand(ele1, ele2, excl = T.unsafe(nil)); end
-    def filter(nodes, expr, truth = T.unsafe(nil)); end
-  end
-end
-
-Hpricot::Elements::ATTR_RE = T.let(T.unsafe(nil), Regexp)
-Hpricot::Elements::BRACK_RE = T.let(T.unsafe(nil), Regexp)
-Hpricot::Elements::CATCH_RE = T.let(T.unsafe(nil), Regexp)
-Hpricot::Elements::CUST_RE = T.let(T.unsafe(nil), Regexp)
-Hpricot::Elements::FUNC_RE = T.let(T.unsafe(nil), Regexp)
-class Hpricot::EncodingError < ::StandardError; end
-class Hpricot::Error < ::StandardError; end
-Hpricot::FORM_TAGS = T.let(T.unsafe(nil), Array)
-
-module Hpricot::Leaf
-  include ::Hpricot
-  include ::Hpricot::Node
-
-  def inspect; end
-  def pretty_print(q); end
-end
-
-module Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-
-  def traverse_all_element; end
-  def traverse_some_element(name_set); end
-  def traverse_text_internal; end
-end
-
-class Hpricot::Name
-  include ::Hpricot
-end
-
-Hpricot::NamedCharacters = T.let(T.unsafe(nil), Hash)
-Hpricot::NamedCharactersPattern = T.let(T.unsafe(nil), Regexp)
-
-module Hpricot::Node
-  include ::Hpricot
-
-  def altered!; end
-  def clear_raw; end
-  def html_quote(str); end
-  def if_output(opts); end
-  def inspect_tree(depth = T.unsafe(nil)); end
-  def pathname; end
-end
-
-Hpricot::OmittedAttrName = T.let(T.unsafe(nil), Hash)
-class Hpricot::ParseError < ::StandardError; end
-
-class Hpricot::ProcIns
-  include ::Hpricot
-  include ::Hpricot::Node
-  include ::Hpricot::Leaf
-  include ::Hpricot::Traverse
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::ProcIns::Trav
-
-  def content; end
-  def content=(_arg0); end
-  def output(out, opts = T.unsafe(nil)); end
-  def pathname; end
-  def raw_string; end
-  def target; end
-  def target=(_arg0); end
-end
-
-module Hpricot::ProcIns::Trav
-  include ::Hpricot::Traverse
-  include ::Hpricot::Leaf::Trav
-end
-
-Hpricot::ProcInsParse = T.let(T.unsafe(nil), Regexp)
-Hpricot::SELF_CLOSING_TAGS = T.let(T.unsafe(nil), Array)
-
-module Hpricot::Tag
-  include ::Hpricot
-end
-
-class Hpricot::Text
-  include ::Hpricot
-  include ::Hpricot::Node
-  include ::Hpricot::Leaf
-  include ::Hpricot::Traverse
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Text::Trav
-
-  def initialize(content); end
-
-  def <<(str); end
-  def clear_raw; end
-  def content; end
-  def content=(_arg0); end
-  def inner_text; end
-  def output(out, opts = T.unsafe(nil)); end
-  def pathname; end
-  def pretty_print(q); end
-  def raw_string; end
-  def to_plain_text; end
-  def to_s; end
-end
-
-module Hpricot::Text::Trav
-  include ::Hpricot::Traverse
-  include ::Hpricot::Leaf::Trav
-
-  def traverse_text_internal; end
-end
-
-module Hpricot::Traverse
-  def %(expr); end
-  def /(expr, &blk); end
-  def after(html = T.unsafe(nil), &blk); end
-  def at(expr); end
-  def before(html = T.unsafe(nil), &blk); end
-  def bogusetag?; end
-  def children_of_type(tag_name); end
-  def clean_path(path); end
-  def comment?; end
-  def css_path; end
-  def doc?; end
-  def doctype?; end
-  def elem?; end
-  def following; end
-  def get_subnode(*indexes); end
-  def html(inner = T.unsafe(nil), &blk); end
-  def index(name); end
-  def innerHTML(inner = T.unsafe(nil), &blk); end
-  def innerHTML=(inner); end
-  def innerText; end
-  def inner_html(inner = T.unsafe(nil), &blk); end
-  def inner_html=(inner); end
-  def inner_text; end
-  def make(input = T.unsafe(nil), &blk); end
-  def next; end
-  def next_node; end
-  def node_position; end
-  def nodes_at(*pos); end
-  def position; end
-  def preceding; end
-  def previous; end
-  def previous_node; end
-  def procins?; end
-  def search(expr, &blk); end
-  def swap(html = T.unsafe(nil), &blk); end
-  def text?; end
-  def to_html; end
-  def to_original_html; end
-  def to_plain_text; end
-  def to_s; end
-  def traverse_element(*names, &block); end
-  def traverse_text(&block); end
-  def xmldecl?; end
-  def xpath; end
-
-  private
-
-  def reparent(nodes); end
-
-  class << self
-    def filter(tok, &blk); end
-  end
-end
-
-class Hpricot::XHTMLStrict
-  class << self
-    def doctype; end
-    def doctype=(_arg0); end
-    def forms; end
-    def forms=(_arg0); end
-    def self_closing; end
-    def self_closing=(_arg0); end
-    def tags; end
-    def tags=(_arg0); end
-    def tagset; end
-    def tagset=(_arg0); end
-  end
-end
-
-class Hpricot::XHTMLTransitional
-  class << self
-    def doctype; end
-    def doctype=(_arg0); end
-    def forms; end
-    def forms=(_arg0); end
-    def self_closing; end
-    def self_closing=(_arg0); end
-    def tags; end
-    def tags=(_arg0); end
-    def tagset; end
-    def tagset=(_arg0); end
-  end
-end
-
-class Hpricot::XMLDecl
-  include ::Hpricot
-  include ::Hpricot::Node
-  include ::Hpricot::Leaf
-  include ::Hpricot::Traverse
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::XMLDecl::Trav
-
-  def clear_raw; end
-  def encoding; end
-  def encoding=(_arg0); end
-  def output(out, opts = T.unsafe(nil)); end
-  def pathname; end
-  def raw_string; end
-  def standalone; end
-  def standalone=(_arg0); end
-  def version; end
-  def version=(_arg0); end
-end
-
-module Hpricot::XMLDecl::Trav
-  include ::Hpricot::Traverse
-  include ::Hpricot::Leaf::Trav
-end
-
-class Object < ::BasicObject
-  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
-  include ::ActiveSupport::ForkTracker::CoreExt
-  include ::ActiveSupport::ForkTracker::CoreExtPrivate
-  include ::Kernel
-  include ::JSON::Ext::Generator::GeneratorMethods::Object
-  include ::PP::ObjectMixin
-  include ::ActiveSupport::Dependencies::Loadable
-  include ::ActiveSupport::Tryable
-
-  private
-
-  def Hpricot(input = T.unsafe(nil), opts = T.unsafe(nil), &blk); end
-
-  class << self
-    def method_added(name); end
-  end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.5.rbi b/Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.5.rbi
deleted file mode 100644
index e55f34138a483..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.5.rbi
+++ /dev/null
@@ -1,216 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `http-cookie` gem.
-# Please instead update this file by running `bin/tapioca gem http-cookie`.
-
-module HTTP; end
-
-class HTTP::Cookie
-  include ::Mechanize::CookieDeprecated
-  include ::Mechanize::CookieIMethods
-  include ::Comparable
-  extend ::Mechanize::CookieDeprecated
-  extend ::Mechanize::CookieCMethods
-
-  def initialize(*args); end
-
-  def <=>(other); end
-  def acceptable?; end
-  def acceptable_from_uri?(uri); end
-  def accessed_at; end
-  def accessed_at=(_arg0); end
-  def cookie_value; end
-  def created_at; end
-  def created_at=(_arg0); end
-  def domain; end
-  def domain=(domain); end
-  def domain_name; end
-  def dot_domain; end
-  def encode_with(coder); end
-  def expire!; end
-  def expired?(time = T.unsafe(nil)); end
-  def expires; end
-  def expires=(t); end
-  def expires_at; end
-  def expires_at=(t); end
-  def for_domain; end
-  def for_domain=(_arg0); end
-  def for_domain?; end
-  def httponly; end
-  def httponly=(_arg0); end
-  def httponly?; end
-  def init_with(coder); end
-  def inspect; end
-  def max_age; end
-  def max_age=(sec); end
-  def name; end
-  def name=(name); end
-  def origin; end
-  def origin=(origin); end
-  def path; end
-  def path=(path); end
-  def secure; end
-  def secure=(_arg0); end
-  def secure?; end
-  def session; end
-  def session?; end
-  def set_cookie_value; end
-  def to_s; end
-  def to_yaml_properties; end
-  def valid_for_uri?(uri); end
-  def value; end
-  def value=(value); end
-  def yaml_initialize(tag, map); end
-
-  class << self
-    def cookie_value(cookies); end
-    def cookie_value_to_hash(cookie_value); end
-    def path_match?(base_path, target_path); end
-  end
-end
-
-HTTP::Cookie::MAX_COOKIES_PER_DOMAIN = T.let(T.unsafe(nil), Integer)
-HTTP::Cookie::MAX_COOKIES_TOTAL = T.let(T.unsafe(nil), Integer)
-HTTP::Cookie::MAX_LENGTH = T.let(T.unsafe(nil), Integer)
-HTTP::Cookie::PERSISTENT_PROPERTIES = T.let(T.unsafe(nil), Array)
-
-class HTTP::Cookie::Scanner < ::StringScanner
-  def initialize(string, logger = T.unsafe(nil)); end
-
-  def parse_cookie_date(s); end
-  def scan_cookie; end
-  def scan_dquoted; end
-  def scan_name; end
-  def scan_name_value(comma_as_separator = T.unsafe(nil)); end
-  def scan_set_cookie; end
-  def scan_value(comma_as_separator = T.unsafe(nil)); end
-  def skip_wsp; end
-
-  private
-
-  def tuple_to_time(day_of_month, month, year, time); end
-
-  class << self
-    def quote(s); end
-  end
-end
-
-HTTP::Cookie::Scanner::RE_BAD_CHAR = T.let(T.unsafe(nil), Regexp)
-HTTP::Cookie::Scanner::RE_COOKIE_COMMA = T.let(T.unsafe(nil), Regexp)
-HTTP::Cookie::Scanner::RE_NAME = T.let(T.unsafe(nil), Regexp)
-HTTP::Cookie::Scanner::RE_WSP = T.let(T.unsafe(nil), Regexp)
-HTTP::Cookie::UNIX_EPOCH = T.let(T.unsafe(nil), Time)
-HTTP::Cookie::VERSION = T.let(T.unsafe(nil), String)
-
-class HTTP::CookieJar
-  include ::Mechanize::CookieDeprecated
-  include ::Mechanize::CookieJarIMethods
-  include ::Enumerable
-
-  def initialize(options = T.unsafe(nil)); end
-
-  def <<(cookie); end
-  def cleanup(session = T.unsafe(nil)); end
-  def clear; end
-  def cookies(url = T.unsafe(nil)); end
-  def delete(cookie); end
-  def each(uri = T.unsafe(nil), &block); end
-  def empty?(url = T.unsafe(nil)); end
-  def load(readable, *options); end
-  def parse(set_cookie, origin, options = T.unsafe(nil)); end
-  def save(writable, *options); end
-  def store; end
-
-  private
-
-  def get_impl(base, value, *args); end
-  def initialize_copy(other); end
-
-  class << self
-    def const_missing(name); end
-  end
-end
-
-class HTTP::CookieJar::AbstractSaver
-  def initialize(options = T.unsafe(nil)); end
-
-  def load(io, jar); end
-  def save(io, jar); end
-
-  private
-
-  def default_options; end
-
-  class << self
-    def class_to_symbol(klass); end
-    def implementation(symbol); end
-    def inherited(subclass); end
-  end
-end
-
-class HTTP::CookieJar::AbstractStore
-  include ::MonitorMixin
-  include ::Enumerable
-
-  def initialize(options = T.unsafe(nil)); end
-
-  def add(cookie); end
-  def cleanup(session = T.unsafe(nil)); end
-  def clear; end
-  def delete(cookie); end
-  def each(uri = T.unsafe(nil), &block); end
-  def empty?; end
-
-  private
-
-  def default_options; end
-  def initialize_copy(other); end
-
-  class << self
-    def class_to_symbol(klass); end
-    def implementation(symbol); end
-    def inherited(subclass); end
-  end
-end
-
-class HTTP::CookieJar::CookiestxtSaver < ::HTTP::CookieJar::AbstractSaver
-  def load(io, jar); end
-  def save(io, jar); end
-
-  private
-
-  def cookie_to_record(cookie); end
-  def default_options; end
-  def parse_record(line); end
-end
-
-HTTP::CookieJar::CookiestxtSaver::False = T.let(T.unsafe(nil), String)
-HTTP::CookieJar::CookiestxtSaver::HTTPONLY_PREFIX = T.let(T.unsafe(nil), String)
-HTTP::CookieJar::CookiestxtSaver::RE_HTTPONLY_PREFIX = T.let(T.unsafe(nil), Regexp)
-HTTP::CookieJar::CookiestxtSaver::True = T.let(T.unsafe(nil), String)
-
-class HTTP::CookieJar::HashStore < ::HTTP::CookieJar::AbstractStore
-  def initialize(options = T.unsafe(nil)); end
-
-  def add(cookie); end
-  def cleanup(session = T.unsafe(nil)); end
-  def clear; end
-  def default_options; end
-  def delete(cookie); end
-  def each(uri = T.unsafe(nil)); end
-
-  private
-
-  def initialize_copy(other); end
-end
-
-class HTTP::CookieJar::YAMLSaver < ::HTTP::CookieJar::AbstractSaver
-  def load(io, jar); end
-  def save(io, jar); end
-
-  private
-
-  def default_options; end
-  def load_yaml(yaml); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/i18n@1.12.0.rbi b/Library/Homebrew/sorbet/rbi/gems/i18n@1.12.0.rbi
deleted file mode 100644
index 001d53cafad6a..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/i18n@1.12.0.rbi
+++ /dev/null
@@ -1,718 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `i18n` gem.
-# Please instead update this file by running `bin/tapioca gem i18n`.
-
-module GetText; end
-
-class GetText::PoParser < ::Racc::Parser
-  def _(x); end
-  def _reduce_10(val, _values, result); end
-  def _reduce_12(val, _values, result); end
-  def _reduce_13(val, _values, result); end
-  def _reduce_14(val, _values, result); end
-  def _reduce_15(val, _values, result); end
-  def _reduce_5(val, _values, result); end
-  def _reduce_8(val, _values, result); end
-  def _reduce_9(val, _values, result); end
-  def _reduce_none(val, _values, result); end
-  def next_token; end
-  def on_comment(comment); end
-  def on_message(msgid, msgstr); end
-  def parse(str, data, ignore_fuzzy = T.unsafe(nil)); end
-  def unescape(orig); end
-end
-
-GetText::PoParser::Racc_arg = T.let(T.unsafe(nil), Array)
-GetText::PoParser::Racc_debug_parser = T.let(T.unsafe(nil), TrueClass)
-GetText::PoParser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
-
-module I18n
-  extend ::I18n::Base
-
-  class << self
-    def cache_key_digest; end
-    def cache_key_digest=(key_digest); end
-    def cache_namespace; end
-    def cache_namespace=(namespace); end
-    def cache_store; end
-    def cache_store=(store); end
-    def fallbacks; end
-    def fallbacks=(fallbacks); end
-    def interpolate(string, values); end
-    def interpolate_hash(string, values); end
-    def new_double_nested_cache; end
-    def perform_caching?; end
-    def reserve_key(key); end
-    def reserved_keys_pattern; end
-  end
-end
-
-class I18n::ArgumentError < ::ArgumentError; end
-module I18n::Backend; end
-
-module I18n::Backend::Base
-  include ::I18n::Backend::Transliterator
-
-  def available_locales; end
-  def eager_load!; end
-  def exists?(locale, key, options = T.unsafe(nil)); end
-  def load_translations(*filenames); end
-  def localize(locale, object, format = T.unsafe(nil), options = T.unsafe(nil)); end
-  def reload!; end
-  def store_translations(locale, data, options = T.unsafe(nil)); end
-  def translate(locale, key, options = T.unsafe(nil)); end
-
-  protected
-
-  def deep_interpolate(locale, data, values = T.unsafe(nil)); end
-  def default(locale, object, subject, options = T.unsafe(nil)); end
-  def eager_loaded?; end
-  def interpolate(locale, subject, values = T.unsafe(nil)); end
-  def load_file(filename); end
-  def load_json(filename); end
-  def load_rb(filename); end
-  def load_yaml(filename); end
-  def load_yml(filename); end
-  def lookup(locale, key, scope = T.unsafe(nil), options = T.unsafe(nil)); end
-  def pluralization_key(entry, count); end
-  def pluralize(locale, entry, count); end
-  def resolve(locale, object, subject, options = T.unsafe(nil)); end
-  def resolve_entry(locale, object, subject, options = T.unsafe(nil)); end
-  def subtrees?; end
-  def translate_localization_format(locale, object, format, options); end
-end
-
-module I18n::Backend::Cache
-  def translate(locale, key, options = T.unsafe(nil)); end
-
-  protected
-
-  def _fetch(cache_key, &block); end
-  def cache_key(locale, key, options); end
-  def fetch(cache_key, &block); end
-
-  private
-
-  def digest_item(key); end
-end
-
-module I18n::Backend::CacheFile
-  def path_roots; end
-  def path_roots=(_arg0); end
-
-  protected
-
-  def load_file(filename); end
-  def normalized_path(file); end
-end
-
-module I18n::Backend::Cascade
-  def lookup(locale, key, scope = T.unsafe(nil), options = T.unsafe(nil)); end
-end
-
-class I18n::Backend::Chain
-  include ::I18n::Backend::Transliterator
-  include ::I18n::Backend::Base
-  include ::I18n::Backend::Chain::Implementation
-end
-
-module I18n::Backend::Chain::Implementation
-  include ::I18n::Backend::Transliterator
-  include ::I18n::Backend::Base
-
-  def initialize(*backends); end
-
-  def available_locales; end
-  def backends; end
-  def backends=(_arg0); end
-  def eager_load!; end
-  def exists?(locale, key, options = T.unsafe(nil)); end
-  def initialized?; end
-  def localize(locale, object, format = T.unsafe(nil), options = T.unsafe(nil)); end
-  def reload!; end
-  def store_translations(locale, data, options = T.unsafe(nil)); end
-  def translate(locale, key, default_options = T.unsafe(nil)); end
-
-  protected
-
-  def init_translations; end
-  def namespace_lookup?(result, options); end
-  def translations; end
-
-  private
-
-  def _deep_merge(hash, other_hash); end
-end
-
-module I18n::Backend::Fallbacks
-  def exists?(locale, key, options = T.unsafe(nil)); end
-  def extract_non_symbol_default!(options); end
-  def resolve_entry(locale, object, subject, options = T.unsafe(nil)); end
-  def translate(locale, key, options = T.unsafe(nil)); end
-
-  private
-
-  def on_fallback(_original_locale, _fallback_locale, _key, _options); end
-end
-
-module I18n::Backend::Flatten
-  def flatten_keys(hash, escape, prev_key = T.unsafe(nil), &block); end
-  def flatten_translations(locale, data, escape, subtree); end
-  def links; end
-  def normalize_flat_keys(locale, key, scope, separator); end
-
-  protected
-
-  def escape_default_separator(key); end
-  def find_link(locale, key); end
-  def resolve_link(locale, key); end
-  def store_link(locale, key, link); end
-
-  class << self
-    def escape_default_separator(key); end
-    def normalize_flat_keys(locale, key, scope, separator); end
-  end
-end
-
-I18n::Backend::Flatten::FLATTEN_SEPARATOR = T.let(T.unsafe(nil), String)
-I18n::Backend::Flatten::SEPARATOR_ESCAPE_CHAR = T.let(T.unsafe(nil), String)
-
-module I18n::Backend::Gettext
-  protected
-
-  def load_po(filename); end
-  def normalize(locale, data); end
-  def normalize_pluralization(locale, key, value); end
-  def parse(filename); end
-end
-
-class I18n::Backend::Gettext::PoData < ::Hash
-  def set_comment(msgid_or_sym, comment); end
-end
-
-module I18n::Backend::InterpolationCompiler
-  def interpolate(locale, string, values); end
-  def store_translations(locale, data, options = T.unsafe(nil)); end
-
-  protected
-
-  def compile_all_strings_in(data); end
-end
-
-module I18n::Backend::InterpolationCompiler::Compiler
-  extend ::I18n::Backend::InterpolationCompiler::Compiler
-
-  def compile_if_an_interpolation(string); end
-  def interpolated_str?(str); end
-
-  protected
-
-  def compile_interpolation_token(key); end
-  def compiled_interpolation_body(str); end
-  def direct_key(key); end
-  def escape_key_sym(key); end
-  def escape_plain_str(str); end
-  def handle_interpolation_token(interpolation, matchdata); end
-  def interpolate_key(key); end
-  def interpolate_or_raise_missing(key); end
-  def missing_key(key); end
-  def nil_key(key); end
-  def reserved_key(key); end
-  def tokenize(str); end
-end
-
-I18n::Backend::InterpolationCompiler::Compiler::INTERPOLATION_SYNTAX_PATTERN = T.let(T.unsafe(nil), Regexp)
-I18n::Backend::InterpolationCompiler::Compiler::TOKENIZER = T.let(T.unsafe(nil), Regexp)
-
-class I18n::Backend::KeyValue
-  include ::I18n::Backend::Flatten
-  include ::I18n::Backend::Transliterator
-  include ::I18n::Backend::Base
-  include ::I18n::Backend::KeyValue::Implementation
-end
-
-module I18n::Backend::KeyValue::Implementation
-  include ::I18n::Backend::Flatten
-  include ::I18n::Backend::Transliterator
-  include ::I18n::Backend::Base
-
-  def initialize(store, subtrees = T.unsafe(nil)); end
-
-  def available_locales; end
-  def initialized?; end
-  def store; end
-  def store=(_arg0); end
-  def store_translations(locale, data, options = T.unsafe(nil)); end
-
-  protected
-
-  def init_translations; end
-  def lookup(locale, key, scope = T.unsafe(nil), options = T.unsafe(nil)); end
-  def pluralize(locale, entry, count); end
-  def subtrees?; end
-  def translations; end
-end
-
-class I18n::Backend::KeyValue::SubtreeProxy
-  def initialize(master_key, store); end
-
-  def [](key); end
-  def has_key?(key); end
-  def inspect; end
-  def instance_of?(klass); end
-  def is_a?(klass); end
-  def kind_of?(klass); end
-  def nil?; end
-end
-
-class I18n::Backend::LazyLoadable < ::I18n::Backend::Simple
-  def initialize(lazy_load: T.unsafe(nil)); end
-
-  def available_locales; end
-  def eager_load!; end
-  def initialized?; end
-  def lookup(locale, key, scope = T.unsafe(nil), options = T.unsafe(nil)); end
-  def reload!; end
-
-  protected
-
-  def init_translations; end
-  def initialized_locales; end
-
-  private
-
-  def assert_file_named_correctly!(file, translations); end
-  def filenames_for_current_locale; end
-  def lazy_load?; end
-  def load_translations_and_collect_file_errors(files); end
-end
-
-class I18n::Backend::LazyLoadable::FilenameIncorrect < ::StandardError
-  def initialize(file, expected_locale, unexpected_locales); end
-end
-
-class I18n::Backend::LocaleExtractor
-  class << self
-    def locale_from_path(path); end
-  end
-end
-
-module I18n::Backend::Memoize
-  def available_locales; end
-  def eager_load!; end
-  def reload!; end
-  def store_translations(locale, data, options = T.unsafe(nil)); end
-
-  protected
-
-  def lookup(locale, key, scope = T.unsafe(nil), options = T.unsafe(nil)); end
-  def memoized_lookup; end
-  def reset_memoizations!(locale = T.unsafe(nil)); end
-end
-
-module I18n::Backend::Metadata
-  def interpolate(locale, entry, values = T.unsafe(nil)); end
-  def pluralize(locale, entry, count); end
-  def translate(locale, key, options = T.unsafe(nil)); end
-
-  protected
-
-  def with_metadata(metadata, &block); end
-
-  class << self
-    def included(base); end
-  end
-end
-
-module I18n::Backend::Pluralization
-  def pluralize(locale, entry, count); end
-
-  protected
-
-  def pluralizer(locale); end
-  def pluralizers; end
-end
-
-class I18n::Backend::Simple
-  include ::I18n::Backend::Transliterator
-  include ::I18n::Backend::Base
-  include ::I18n::Backend::Simple::Implementation
-end
-
-module I18n::Backend::Simple::Implementation
-  include ::I18n::Backend::Transliterator
-  include ::I18n::Backend::Base
-
-  def available_locales; end
-  def eager_load!; end
-  def initialized?; end
-  def reload!; end
-  def store_translations(locale, data, options = T.unsafe(nil)); end
-  def translations(do_init: T.unsafe(nil)); end
-
-  protected
-
-  def init_translations; end
-  def lookup(locale, key, scope = T.unsafe(nil), options = T.unsafe(nil)); end
-end
-
-module I18n::Backend::Transliterator
-  def transliterate(locale, string, replacement = T.unsafe(nil)); end
-
-  class << self
-    def get(rule = T.unsafe(nil)); end
-  end
-end
-
-I18n::Backend::Transliterator::DEFAULT_REPLACEMENT_CHAR = T.let(T.unsafe(nil), String)
-
-class I18n::Backend::Transliterator::HashTransliterator
-  def initialize(rule = T.unsafe(nil)); end
-
-  def transliterate(string, replacement = T.unsafe(nil)); end
-
-  private
-
-  def add(hash); end
-  def add_default_approximations; end
-  def approximations; end
-end
-
-I18n::Backend::Transliterator::HashTransliterator::DEFAULT_APPROXIMATIONS = T.let(T.unsafe(nil), Hash)
-
-class I18n::Backend::Transliterator::ProcTransliterator
-  def initialize(rule); end
-
-  def transliterate(string, replacement = T.unsafe(nil)); end
-end
-
-module I18n::Base
-  def available_locales; end
-  def available_locales=(value); end
-  def available_locales_initialized?; end
-  def backend; end
-  def backend=(value); end
-  def config; end
-  def config=(value); end
-  def default_locale; end
-  def default_locale=(value); end
-  def default_separator; end
-  def default_separator=(value); end
-  def eager_load!; end
-  def enforce_available_locales; end
-  def enforce_available_locales!(locale); end
-  def enforce_available_locales=(value); end
-  def exception_handler; end
-  def exception_handler=(value); end
-  def exists?(key, _locale = T.unsafe(nil), locale: T.unsafe(nil), **options); end
-  def l(object, locale: T.unsafe(nil), format: T.unsafe(nil), **options); end
-  def load_path; end
-  def load_path=(value); end
-  def locale; end
-  def locale=(value); end
-  def locale_available?(locale); end
-  def localize(object, locale: T.unsafe(nil), format: T.unsafe(nil), **options); end
-  def normalize_keys(locale, key, scope, separator = T.unsafe(nil)); end
-  def reload!; end
-  def t(key = T.unsafe(nil), throw: T.unsafe(nil), raise: T.unsafe(nil), locale: T.unsafe(nil), **options); end
-  def t!(key, **options); end
-  def translate(key = T.unsafe(nil), throw: T.unsafe(nil), raise: T.unsafe(nil), locale: T.unsafe(nil), **options); end
-  def translate!(key, **options); end
-  def transliterate(key, throw: T.unsafe(nil), raise: T.unsafe(nil), locale: T.unsafe(nil), replacement: T.unsafe(nil), **options); end
-  def with_locale(tmp_locale = T.unsafe(nil)); end
-
-  private
-
-  def handle_exception(handling, exception, locale, key, options); end
-  def normalize_key(key, separator); end
-  def translate_key(key, throw, raise, locale, backend, options); end
-end
-
-class I18n::Config
-  def available_locales; end
-  def available_locales=(locales); end
-  def available_locales_initialized?; end
-  def available_locales_set; end
-  def backend; end
-  def backend=(backend); end
-  def clear_available_locales_set; end
-  def default_locale; end
-  def default_locale=(locale); end
-  def default_separator; end
-  def default_separator=(separator); end
-  def enforce_available_locales; end
-  def enforce_available_locales=(enforce_available_locales); end
-  def exception_handler; end
-  def exception_handler=(exception_handler); end
-  def interpolation_patterns; end
-  def interpolation_patterns=(interpolation_patterns); end
-  def load_path; end
-  def load_path=(load_path); end
-  def locale; end
-  def locale=(locale); end
-  def missing_interpolation_argument_handler; end
-  def missing_interpolation_argument_handler=(exception_handler); end
-end
-
-I18n::DEFAULT_INTERPOLATION_PATTERNS = T.let(T.unsafe(nil), Array)
-
-class I18n::Disabled < ::I18n::ArgumentError
-  def initialize(method); end
-end
-
-I18n::EMPTY_HASH = T.let(T.unsafe(nil), Hash)
-
-class I18n::ExceptionHandler
-  def call(exception, _locale, _key, _options); end
-end
-
-module I18n::Gettext
-  class << self
-    def extract_scope(msgid, separator); end
-    def plural_keys(*args); end
-  end
-end
-
-I18n::Gettext::CONTEXT_SEPARATOR = T.let(T.unsafe(nil), String)
-
-module I18n::Gettext::Helpers
-  def N_(msgsid); end
-  def _(msgid, options = T.unsafe(nil)); end
-  def gettext(msgid, options = T.unsafe(nil)); end
-  def n_(msgid, msgid_plural, n = T.unsafe(nil)); end
-  def ngettext(msgid, msgid_plural, n = T.unsafe(nil)); end
-  def np_(msgctxt, msgid, msgid_plural, n = T.unsafe(nil)); end
-  def npgettext(msgctxt, msgid, msgid_plural, n = T.unsafe(nil)); end
-  def ns_(msgid, msgid_plural, n = T.unsafe(nil), separator = T.unsafe(nil)); end
-  def nsgettext(msgid, msgid_plural, n = T.unsafe(nil), separator = T.unsafe(nil)); end
-  def p_(msgctxt, msgid); end
-  def pgettext(msgctxt, msgid); end
-  def s_(msgid, separator = T.unsafe(nil)); end
-  def sgettext(msgid, separator = T.unsafe(nil)); end
-end
-
-I18n::Gettext::PLURAL_SEPARATOR = T.let(T.unsafe(nil), String)
-I18n::INTERPOLATION_PATTERN = T.let(T.unsafe(nil), Regexp)
-
-class I18n::InvalidFilenames < ::I18n::ArgumentError
-  def initialize(file_errors); end
-end
-
-I18n::InvalidFilenames::NUMBER_OF_ERRORS_SHOWN = T.let(T.unsafe(nil), Integer)
-
-class I18n::InvalidLocale < ::I18n::ArgumentError
-  def initialize(locale); end
-
-  def locale; end
-end
-
-class I18n::InvalidLocaleData < ::I18n::ArgumentError
-  def initialize(filename, exception_message); end
-
-  def filename; end
-end
-
-class I18n::InvalidPluralizationData < ::I18n::ArgumentError
-  def initialize(entry, count, key); end
-
-  def count; end
-  def entry; end
-  def key; end
-end
-
-I18n::JSON = ActiveSupport::JSON
-module I18n::Locale; end
-
-class I18n::Locale::Fallbacks < ::Hash
-  def initialize(*mappings); end
-
-  def [](locale); end
-  def defaults; end
-  def defaults=(defaults); end
-  def map(*args, &block); end
-
-  protected
-
-  def compute(tags, include_defaults = T.unsafe(nil), exclude = T.unsafe(nil)); end
-end
-
-module I18n::Locale::Tag
-  class << self
-    def implementation; end
-    def implementation=(implementation); end
-    def tag(tag); end
-  end
-end
-
-module I18n::Locale::Tag::Parents
-  def parent; end
-  def parents; end
-  def self_and_parents; end
-end
-
-I18n::Locale::Tag::RFC4646_FORMATS = T.let(T.unsafe(nil), Hash)
-I18n::Locale::Tag::RFC4646_SUBTAGS = T.let(T.unsafe(nil), Array)
-
-class I18n::Locale::Tag::Rfc4646 < ::Struct
-  include ::I18n::Locale::Tag::Parents
-
-  def language; end
-  def region; end
-  def script; end
-  def to_a; end
-  def to_s; end
-  def to_sym; end
-  def variant; end
-
-  class << self
-    def parser; end
-    def parser=(parser); end
-    def tag(tag); end
-  end
-end
-
-module I18n::Locale::Tag::Rfc4646::Parser
-  class << self
-    def match(tag); end
-  end
-end
-
-I18n::Locale::Tag::Rfc4646::Parser::PATTERN = T.let(T.unsafe(nil), Regexp)
-
-class I18n::Locale::Tag::Simple
-  include ::I18n::Locale::Tag::Parents
-
-  def initialize(*tag); end
-
-  def subtags; end
-  def tag; end
-  def to_a; end
-  def to_s; end
-  def to_sym; end
-
-  class << self
-    def tag(tag); end
-  end
-end
-
-class I18n::Middleware
-  def initialize(app); end
-
-  def call(env); end
-end
-
-class I18n::MissingInterpolationArgument < ::I18n::ArgumentError
-  def initialize(key, values, string); end
-
-  def key; end
-  def string; end
-  def values; end
-end
-
-class I18n::MissingTranslation < ::I18n::ArgumentError
-  include ::I18n::MissingTranslation::Base
-end
-
-module I18n::MissingTranslation::Base
-  def initialize(locale, key, options = T.unsafe(nil)); end
-
-  def key; end
-  def keys; end
-  def locale; end
-  def message; end
-  def options; end
-  def to_exception; end
-  def to_s; end
-end
-
-I18n::MissingTranslation::Base::PERMITTED_KEYS = T.let(T.unsafe(nil), Array)
-
-class I18n::MissingTranslationData < ::I18n::ArgumentError
-  include ::I18n::MissingTranslation::Base
-end
-
-I18n::RESERVED_KEYS = T.let(T.unsafe(nil), Array)
-
-class I18n::ReservedInterpolationKey < ::I18n::ArgumentError
-  def initialize(key, string); end
-
-  def key; end
-  def string; end
-end
-
-module I18n::Tests; end
-
-module I18n::Tests::Basics
-  def teardown; end
-end
-
-module I18n::Tests::Defaults
-  def setup; end
-end
-
-module I18n::Tests::Interpolation; end
-module I18n::Tests::Link; end
-
-module I18n::Tests::Localization
-  include ::I18n::Tests::Localization::Date
-  include ::I18n::Tests::Localization::DateTime
-  include ::I18n::Tests::Localization::Procs
-  include ::I18n::Tests::Localization::Time
-
-  class << self
-    def included(base); end
-  end
-end
-
-module I18n::Tests::Localization::Date
-  def setup; end
-end
-
-module I18n::Tests::Localization::DateTime
-  def setup; end
-end
-
-module I18n::Tests::Localization::Procs; end
-
-module I18n::Tests::Localization::Time
-  def setup; end
-end
-
-module I18n::Tests::Lookup
-  def setup; end
-end
-
-module I18n::Tests::Pluralization; end
-module I18n::Tests::Procs; end
-
-class I18n::UnknownFileType < ::I18n::ArgumentError
-  def initialize(type, filename); end
-
-  def filename; end
-  def type; end
-end
-
-class I18n::UnsupportedMethod < ::I18n::ArgumentError
-  def initialize(method, backend_klass, msg); end
-
-  def backend_klass; end
-  def method; end
-  def msg; end
-end
-
-module I18n::Utils
-  class << self
-    def deep_merge(hash, other_hash, &block); end
-    def deep_merge!(hash, other_hash, &block); end
-    def deep_symbolize_keys(hash); end
-    def except(hash, *keys); end
-
-    private
-
-    def deep_symbolize_keys_in_object(value); end
-  end
-end
-
-I18n::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/json@2.6.2.rbi b/Library/Homebrew/sorbet/rbi/gems/json@2.6.2.rbi
deleted file mode 100644
index 169cf4b68ca13..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/json@2.6.2.rbi
+++ /dev/null
@@ -1,101 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `json` gem.
-# Please instead update this file by running `bin/tapioca gem json`.
-
-class Class < ::Module
-  def json_creatable?; end
-end
-
-module JSON
-  private
-
-  def dump(obj, anIO = T.unsafe(nil), limit = T.unsafe(nil)); end
-  def fast_generate(obj, opts = T.unsafe(nil)); end
-  def fast_unparse(obj, opts = T.unsafe(nil)); end
-  def generate(obj, opts = T.unsafe(nil)); end
-  def load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end
-  def load_file(filespec, opts = T.unsafe(nil)); end
-  def load_file!(filespec, opts = T.unsafe(nil)); end
-  def parse(source, opts = T.unsafe(nil)); end
-  def parse!(source, opts = T.unsafe(nil)); end
-  def pretty_generate(obj, opts = T.unsafe(nil)); end
-  def pretty_unparse(obj, opts = T.unsafe(nil)); end
-  def recurse_proc(result, &proc); end
-  def restore(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end
-  def unparse(obj, opts = T.unsafe(nil)); end
-
-  class << self
-    def [](object, opts = T.unsafe(nil)); end
-    def create_fast_state; end
-    def create_id; end
-    def create_id=(new_value); end
-    def create_pretty_state; end
-    def deep_const_get(path); end
-    def dump(obj, anIO = T.unsafe(nil), limit = T.unsafe(nil)); end
-    def dump_default_options; end
-    def dump_default_options=(_arg0); end
-    def fast_generate(obj, opts = T.unsafe(nil)); end
-    def fast_unparse(obj, opts = T.unsafe(nil)); end
-    def generate(obj, opts = T.unsafe(nil)); end
-    def generator; end
-    def generator=(generator); end
-    def iconv(to, from, string); end
-    def load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end
-    def load_default_options; end
-    def load_default_options=(_arg0); end
-    def load_file(filespec, opts = T.unsafe(nil)); end
-    def load_file!(filespec, opts = T.unsafe(nil)); end
-    def parse(source, opts = T.unsafe(nil)); end
-    def parse!(source, opts = T.unsafe(nil)); end
-    def parser; end
-    def parser=(parser); end
-    def pretty_generate(obj, opts = T.unsafe(nil)); end
-    def pretty_unparse(obj, opts = T.unsafe(nil)); end
-    def recurse_proc(result, &proc); end
-    def restore(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end
-    def state; end
-    def state=(_arg0); end
-    def unparse(obj, opts = T.unsafe(nil)); end
-  end
-end
-
-JSON::CREATE_ID_TLS_KEY = T.let(T.unsafe(nil), String)
-JSON::DEFAULT_CREATE_ID = T.let(T.unsafe(nil), String)
-
-class JSON::GenericObject < ::OpenStruct
-  def as_json(*_arg0); end
-  def to_hash; end
-  def to_json(*a); end
-  def |(other); end
-
-  class << self
-    def dump(obj, *args); end
-    def from_hash(object); end
-    def json_creatable=(_arg0); end
-    def json_creatable?; end
-    def json_create(data); end
-    def load(source, proc = T.unsafe(nil), opts = T.unsafe(nil)); end
-  end
-end
-
-class JSON::JSONError < ::StandardError
-  class << self
-    def wrap(exception); end
-  end
-end
-
-JSON::Parser = JSON::Ext::Parser
-JSON::State = JSON::Ext::Generator::State
-JSON::UnparserError = JSON::GeneratorError
-
-module Kernel
-  extend ::Forwardable
-
-  private
-
-  def JSON(object, *args); end
-  def j(*objs); end
-  def jj(*objs); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/json_schemer@0.2.21.rbi b/Library/Homebrew/sorbet/rbi/gems/json_schemer@0.2.21.rbi
deleted file mode 100644
index 955adb20f1552..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/json_schemer@0.2.21.rbi
+++ /dev/null
@@ -1,173 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `json_schemer` gem.
-# Please instead update this file by running `bin/tapioca gem json_schemer`.
-
-module JSONSchemer
-  class << self
-    def schema(schema, **options); end
-
-    private
-
-    def draft_class(schema); end
-  end
-end
-
-class JSONSchemer::CachedRefResolver
-  def initialize(&ref_resolver); end
-
-  def call(uri); end
-end
-
-JSONSchemer::DEFAULT_META_SCHEMA = T.let(T.unsafe(nil), String)
-JSONSchemer::DRAFT_CLASS_BY_META_SCHEMA = T.let(T.unsafe(nil), Hash)
-
-module JSONSchemer::Errors
-  class << self
-    def pretty(error); end
-  end
-end
-
-JSONSchemer::FILE_URI_REF_RESOLVER = T.let(T.unsafe(nil), Proc)
-
-module JSONSchemer::Format
-  def iri_escape(data); end
-  def parse_uri_scheme(data); end
-  def valid_date_time?(data); end
-  def valid_email?(data); end
-  def valid_hostname?(data); end
-  def valid_ip?(data, type); end
-  def valid_json?(data); end
-  def valid_json_pointer?(data); end
-  def valid_relative_json_pointer?(data); end
-  def valid_spec_format?(data, format); end
-  def valid_uri?(data); end
-  def valid_uri_reference?(data); end
-  def valid_uri_template?(data); end
-end
-
-JSONSchemer::Format::DATE_TIME_OFFSET_REGEX = T.let(T.unsafe(nil), Regexp)
-JSONSchemer::Format::EMAIL_REGEX = T.let(T.unsafe(nil), Regexp)
-JSONSchemer::Format::HOSTNAME_REGEX = T.let(T.unsafe(nil), Regexp)
-JSONSchemer::Format::INVALID_QUERY_REGEX = T.let(T.unsafe(nil), Regexp)
-JSONSchemer::Format::JSON_POINTER_REGEX = T.let(T.unsafe(nil), Regexp)
-JSONSchemer::Format::JSON_POINTER_REGEX_STRING = T.let(T.unsafe(nil), String)
-JSONSchemer::Format::LABEL_REGEX_STRING = T.let(T.unsafe(nil), String)
-JSONSchemer::Format::RELATIVE_JSON_POINTER_REGEX = T.let(T.unsafe(nil), Regexp)
-class JSONSchemer::InvalidFileURI < ::StandardError; end
-class JSONSchemer::InvalidRefResolution < ::StandardError; end
-class JSONSchemer::InvalidSymbolKey < ::StandardError; end
-module JSONSchemer::Schema; end
-
-class JSONSchemer::Schema::Base
-  include ::JSONSchemer::Format
-
-  def initialize(schema, format: T.unsafe(nil), insert_property_defaults: T.unsafe(nil), before_property_validation: T.unsafe(nil), after_property_validation: T.unsafe(nil), formats: T.unsafe(nil), keywords: T.unsafe(nil), ref_resolver: T.unsafe(nil)); end
-
-  def valid?(data); end
-  def validate(data); end
-
-  protected
-
-  def ids; end
-  def valid_instance?(instance); end
-  def validate_instance(instance, &block); end
-
-  private
-
-  def child(schema); end
-  def custom_format?(format); end
-  def ecma_262_regex(pattern); end
-  def error(instance, type, details = T.unsafe(nil)); end
-  def format?; end
-  def formats; end
-  def id_keyword; end
-  def join_uri(a, b); end
-  def keywords; end
-  def pointer_uri(schema, pointer); end
-  def ref_resolver; end
-  def resolve_ids(schema, ids = T.unsafe(nil), parent_uri = T.unsafe(nil), pointer = T.unsafe(nil)); end
-  def resolve_ref(uri); end
-  def root; end
-  def safe_strict_decode64(data); end
-  def spec_format?(format); end
-  def validate_array(instance, &block); end
-  def validate_class(instance, &block); end
-  def validate_custom_format(instance, custom_format); end
-  def validate_exclusive_maximum(instance, exclusive_maximum, maximum); end
-  def validate_exclusive_minimum(instance, exclusive_minimum, minimum); end
-  def validate_integer(instance, &block); end
-  def validate_number(instance, &block); end
-  def validate_numeric(instance, &block); end
-  def validate_object(instance, &block); end
-  def validate_ref(instance, ref, &block); end
-  def validate_string(instance, &block); end
-  def validate_type(instance, type, &block); end
-end
-
-JSONSchemer::Schema::Base::BOOLEANS = T.let(T.unsafe(nil), Set)
-JSONSchemer::Schema::Base::DEFAULT_REF_RESOLVER = T.let(T.unsafe(nil), Proc)
-JSONSchemer::Schema::Base::ID_KEYWORD = T.let(T.unsafe(nil), String)
-JSONSchemer::Schema::Base::INSERT_DEFAULT_PROPERTY = T.let(T.unsafe(nil), Proc)
-
-class JSONSchemer::Schema::Base::Instance < ::Struct
-  def after_property_validation; end
-  def after_property_validation=(_); end
-  def before_property_validation; end
-  def before_property_validation=(_); end
-  def data; end
-  def data=(_); end
-  def data_pointer; end
-  def data_pointer=(_); end
-  def merge(data: T.unsafe(nil), data_pointer: T.unsafe(nil), schema: T.unsafe(nil), schema_pointer: T.unsafe(nil), parent_uri: T.unsafe(nil), before_property_validation: T.unsafe(nil), after_property_validation: T.unsafe(nil)); end
-  def parent_uri; end
-  def parent_uri=(_); end
-  def schema; end
-  def schema=(_); end
-  def schema_pointer; end
-  def schema_pointer=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-JSONSchemer::Schema::Base::NET_HTTP_REF_RESOLVER = T.let(T.unsafe(nil), Proc)
-JSONSchemer::Schema::Base::RUBY_REGEX_ANCHORS_TO_ECMA_262 = T.let(T.unsafe(nil), Hash)
-
-class JSONSchemer::Schema::Draft4 < ::JSONSchemer::Schema::Base
-  private
-
-  def id_keyword; end
-  def supported_format?(format); end
-  def validate_exclusive_maximum(instance, exclusive_maximum, maximum); end
-  def validate_exclusive_minimum(instance, exclusive_minimum, minimum); end
-  def validate_integer(instance, &block); end
-end
-
-JSONSchemer::Schema::Draft4::ID_KEYWORD = T.let(T.unsafe(nil), String)
-JSONSchemer::Schema::Draft4::SUPPORTED_FORMATS = T.let(T.unsafe(nil), Set)
-
-class JSONSchemer::Schema::Draft6 < ::JSONSchemer::Schema::Base
-  private
-
-  def supported_format?(format); end
-end
-
-JSONSchemer::Schema::Draft6::SUPPORTED_FORMATS = T.let(T.unsafe(nil), Set)
-
-class JSONSchemer::Schema::Draft7 < ::JSONSchemer::Schema::Base
-  private
-
-  def supported_format?(format); end
-end
-
-JSONSchemer::Schema::Draft7::SUPPORTED_FORMATS = T.let(T.unsafe(nil), Set)
-class JSONSchemer::UnknownRef < ::StandardError; end
-class JSONSchemer::UnsupportedMetaSchema < ::StandardError; end
-JSONSchemer::VERSION = T.let(T.unsafe(nil), String)
-JSONSchemer::WINDOWS_URI_PATH_REGEX = T.let(T.unsafe(nil), Regexp)
diff --git a/Library/Homebrew/sorbet/rbi/gems/json_schemer@2.3.0.rbi b/Library/Homebrew/sorbet/rbi/gems/json_schemer@2.3.0.rbi
new file mode 100644
index 0000000000000..c41fc70800f04
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/json_schemer@2.3.0.rbi
@@ -0,0 +1,2685 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `json_schemer` gem.
+# Please instead update this file by running `bin/tapioca gem json_schemer`.
+
+
+# Based on code from @robacarp found in issue 48:
+# https://github.com/davishmcclurg/json_schemer/issues/48
+#
+# source://json_schemer//lib/json_schemer/version.rb#2
+module JSONSchemer
+  class << self
+    # source://json_schemer//lib/json_schemer.rb#234
+    def configuration; end
+
+    # @yield [configuration]
+    #
+    # source://json_schemer//lib/json_schemer.rb#238
+    def configure; end
+
+    # source://json_schemer//lib/json_schemer.rb#142
+    def draft201909; end
+
+    # source://json_schemer//lib/json_schemer.rb#130
+    def draft202012; end
+
+    # source://json_schemer//lib/json_schemer.rb#178
+    def draft4; end
+
+    # source://json_schemer//lib/json_schemer.rb#166
+    def draft6; end
+
+    # source://json_schemer//lib/json_schemer.rb#154
+    def draft7; end
+
+    # source://json_schemer//lib/json_schemer.rb#230
+    def openapi(document, **options); end
+
+    # source://json_schemer//lib/json_schemer.rb#200
+    def openapi30; end
+
+    # source://json_schemer//lib/json_schemer.rb#222
+    def openapi30_document; end
+
+    # source://json_schemer//lib/json_schemer.rb#190
+    def openapi31; end
+
+    # source://json_schemer//lib/json_schemer.rb#214
+    def openapi31_document; end
+
+    # source://json_schemer//lib/json_schemer.rb#115
+    def schema(schema, **options); end
+
+    # @return [Boolean]
+    #
+    # source://json_schemer//lib/json_schemer.rb#120
+    def valid_schema?(schema, **options); end
+
+    # source://json_schemer//lib/json_schemer.rb#125
+    def validate_schema(schema, **options); end
+
+    private
+
+    # source://json_schemer//lib/json_schemer.rb#263
+    def meta_schema(schema, options); end
+
+    # source://json_schemer//lib/json_schemer.rb#244
+    def resolve(schema, options); end
+  end
+end
+
+# source://json_schemer//lib/json_schemer/result.rb#3
+JSONSchemer::CATCHALL = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/result.rb#8
+JSONSchemer::CLASSIC_ERROR_TYPES = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/cached_resolver.rb#15
+class JSONSchemer::CachedRefResolver < ::JSONSchemer::CachedResolver; end
+
+# source://json_schemer//lib/json_schemer/cached_resolver.rb#3
+class JSONSchemer::CachedResolver
+  # @return [CachedResolver] a new instance of CachedResolver
+  #
+  # source://json_schemer//lib/json_schemer/cached_resolver.rb#4
+  def initialize(&resolver); end
+
+  # source://json_schemer//lib/json_schemer/cached_resolver.rb#9
+  def call(*args); end
+end
+
+# source://json_schemer//lib/json_schemer/configuration.rb#3
+class JSONSchemer::Configuration < ::Struct
+  # @return [Configuration] a new instance of Configuration
+  #
+  # source://json_schemer//lib/json_schemer/configuration.rb#9
+  def initialize(base_uri: T.unsafe(nil), meta_schema: T.unsafe(nil), vocabulary: T.unsafe(nil), format: T.unsafe(nil), formats: T.unsafe(nil), content_encodings: T.unsafe(nil), content_media_types: T.unsafe(nil), keywords: T.unsafe(nil), before_property_validation: T.unsafe(nil), after_property_validation: T.unsafe(nil), insert_property_defaults: T.unsafe(nil), property_default_resolver: T.unsafe(nil), ref_resolver: T.unsafe(nil), regexp_resolver: T.unsafe(nil), output_format: T.unsafe(nil), resolve_enumerators: T.unsafe(nil), access_mode: T.unsafe(nil)); end
+
+  # Returns the value of attribute access_mode
+  #
+  # @return [Object] the current value of access_mode
+  def access_mode; end
+
+  # Sets the attribute access_mode
+  #
+  # @param value [Object] the value to set the attribute access_mode to.
+  # @return [Object] the newly set value
+  def access_mode=(_); end
+
+  # Returns the value of attribute after_property_validation
+  #
+  # @return [Object] the current value of after_property_validation
+  def after_property_validation; end
+
+  # Sets the attribute after_property_validation
+  #
+  # @param value [Object] the value to set the attribute after_property_validation to.
+  # @return [Object] the newly set value
+  def after_property_validation=(_); end
+
+  # Returns the value of attribute base_uri
+  #
+  # @return [Object] the current value of base_uri
+  def base_uri; end
+
+  # Sets the attribute base_uri
+  #
+  # @param value [Object] the value to set the attribute base_uri to.
+  # @return [Object] the newly set value
+  def base_uri=(_); end
+
+  # Returns the value of attribute before_property_validation
+  #
+  # @return [Object] the current value of before_property_validation
+  def before_property_validation; end
+
+  # Sets the attribute before_property_validation
+  #
+  # @param value [Object] the value to set the attribute before_property_validation to.
+  # @return [Object] the newly set value
+  def before_property_validation=(_); end
+
+  # Returns the value of attribute content_encodings
+  #
+  # @return [Object] the current value of content_encodings
+  def content_encodings; end
+
+  # Sets the attribute content_encodings
+  #
+  # @param value [Object] the value to set the attribute content_encodings to.
+  # @return [Object] the newly set value
+  def content_encodings=(_); end
+
+  # Returns the value of attribute content_media_types
+  #
+  # @return [Object] the current value of content_media_types
+  def content_media_types; end
+
+  # Sets the attribute content_media_types
+  #
+  # @param value [Object] the value to set the attribute content_media_types to.
+  # @return [Object] the newly set value
+  def content_media_types=(_); end
+
+  # Returns the value of attribute format
+  #
+  # @return [Object] the current value of format
+  def format; end
+
+  # Sets the attribute format
+  #
+  # @param value [Object] the value to set the attribute format to.
+  # @return [Object] the newly set value
+  def format=(_); end
+
+  # Returns the value of attribute formats
+  #
+  # @return [Object] the current value of formats
+  def formats; end
+
+  # Sets the attribute formats
+  #
+  # @param value [Object] the value to set the attribute formats to.
+  # @return [Object] the newly set value
+  def formats=(_); end
+
+  # Returns the value of attribute insert_property_defaults
+  #
+  # @return [Object] the current value of insert_property_defaults
+  def insert_property_defaults; end
+
+  # Sets the attribute insert_property_defaults
+  #
+  # @param value [Object] the value to set the attribute insert_property_defaults to.
+  # @return [Object] the newly set value
+  def insert_property_defaults=(_); end
+
+  # Returns the value of attribute keywords
+  #
+  # @return [Object] the current value of keywords
+  def keywords; end
+
+  # Sets the attribute keywords
+  #
+  # @param value [Object] the value to set the attribute keywords to.
+  # @return [Object] the newly set value
+  def keywords=(_); end
+
+  # Returns the value of attribute meta_schema
+  #
+  # @return [Object] the current value of meta_schema
+  def meta_schema; end
+
+  # Sets the attribute meta_schema
+  #
+  # @param value [Object] the value to set the attribute meta_schema to.
+  # @return [Object] the newly set value
+  def meta_schema=(_); end
+
+  # Returns the value of attribute output_format
+  #
+  # @return [Object] the current value of output_format
+  def output_format; end
+
+  # Sets the attribute output_format
+  #
+  # @param value [Object] the value to set the attribute output_format to.
+  # @return [Object] the newly set value
+  def output_format=(_); end
+
+  # Returns the value of attribute property_default_resolver
+  #
+  # @return [Object] the current value of property_default_resolver
+  def property_default_resolver; end
+
+  # Sets the attribute property_default_resolver
+  #
+  # @param value [Object] the value to set the attribute property_default_resolver to.
+  # @return [Object] the newly set value
+  def property_default_resolver=(_); end
+
+  # Returns the value of attribute ref_resolver
+  #
+  # @return [Object] the current value of ref_resolver
+  def ref_resolver; end
+
+  # Sets the attribute ref_resolver
+  #
+  # @param value [Object] the value to set the attribute ref_resolver to.
+  # @return [Object] the newly set value
+  def ref_resolver=(_); end
+
+  # Returns the value of attribute regexp_resolver
+  #
+  # @return [Object] the current value of regexp_resolver
+  def regexp_resolver; end
+
+  # Sets the attribute regexp_resolver
+  #
+  # @param value [Object] the value to set the attribute regexp_resolver to.
+  # @return [Object] the newly set value
+  def regexp_resolver=(_); end
+
+  # Returns the value of attribute resolve_enumerators
+  #
+  # @return [Object] the current value of resolve_enumerators
+  def resolve_enumerators; end
+
+  # Sets the attribute resolve_enumerators
+  #
+  # @param value [Object] the value to set the attribute resolve_enumerators to.
+  # @return [Object] the newly set value
+  def resolve_enumerators=(_); end
+
+  # Returns the value of attribute vocabulary
+  #
+  # @return [Object] the current value of vocabulary
+  def vocabulary; end
+
+  # Sets the attribute vocabulary
+  #
+  # @param value [Object] the value to set the attribute vocabulary to.
+  # @return [Object] the newly set value
+  def vocabulary=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://json_schemer//lib/json_schemer/content.rb#3
+module JSONSchemer::ContentEncoding; end
+
+# source://json_schemer//lib/json_schemer/content.rb#4
+JSONSchemer::ContentEncoding::BASE64 = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/content.rb#11
+module JSONSchemer::ContentMediaType; end
+
+# source://json_schemer//lib/json_schemer/content.rb#12
+JSONSchemer::ContentMediaType::JSON = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/draft201909/meta.rb#3
+module JSONSchemer::Draft201909; end
+
+# source://json_schemer//lib/json_schemer/draft201909/meta.rb#4
+JSONSchemer::Draft201909::BASE_URI = T.let(T.unsafe(nil), URI::HTTPS)
+
+# source://json_schemer//lib/json_schemer/draft201909/meta.rb#6
+JSONSchemer::Draft201909::CONTENT_ENCODINGS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/meta.rb#7
+JSONSchemer::Draft201909::CONTENT_MEDIA_TYPES = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/meta.rb#5
+JSONSchemer::Draft201909::FORMATS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/meta.rb#50
+module JSONSchemer::Draft201909::Meta; end
+
+# source://json_schemer//lib/json_schemer/draft201909/meta.rb#105
+JSONSchemer::Draft201909::Meta::APPLICATOR = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/meta.rb#297
+JSONSchemer::Draft201909::Meta::CONTENT = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/meta.rb#51
+JSONSchemer::Draft201909::Meta::CORE = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/meta.rb#286
+JSONSchemer::Draft201909::Meta::FORMAT = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/meta.rb#253
+JSONSchemer::Draft201909::Meta::META_DATA = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/meta.rb#310
+JSONSchemer::Draft201909::Meta::SCHEMAS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/meta.rb#158
+JSONSchemer::Draft201909::Meta::VALIDATION = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/meta.rb#8
+JSONSchemer::Draft201909::SCHEMA = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/vocab/core.rb#4
+module JSONSchemer::Draft201909::Vocab; end
+
+# source://json_schemer//lib/json_schemer/draft201909/vocab.rb#14
+JSONSchemer::Draft201909::Vocab::APPLICATOR = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/vocab/applicator.rb#5
+module JSONSchemer::Draft201909::Vocab::Applicator; end
+
+# source://json_schemer//lib/json_schemer/draft201909/vocab/applicator.rb#38
+class JSONSchemer::Draft201909::Vocab::Applicator::AdditionalItems < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/applicator.rb#39
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/applicator.rb#43
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/applicator.rb#47
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft201909/vocab/applicator.rb#6
+class JSONSchemer::Draft201909::Vocab::Applicator::Items < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/applicator.rb#7
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/applicator.rb#11
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/applicator.rb#21
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft201909/vocab/applicator.rb#61
+class JSONSchemer::Draft201909::Vocab::Applicator::UnevaluatedItems < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/applicator.rb#62
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/applicator.rb#66
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/applicator.rb#70
+  def validate(instance, instance_location, keyword_location, context); end
+
+  private
+
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/applicator.rb#88
+  def collect_unevaluated_items(result, instance_location, unevaluated_items); end
+end
+
+# source://json_schemer//lib/json_schemer/draft201909/vocab.rb#27
+JSONSchemer::Draft201909::Vocab::CONTENT = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/vocab.rb#5
+JSONSchemer::Draft201909::Vocab::CORE = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/vocab/core.rb#5
+module JSONSchemer::Draft201909::Vocab::Core; end
+
+# source://json_schemer//lib/json_schemer/draft201909/vocab/core.rb#6
+class JSONSchemer::Draft201909::Vocab::Core::RecursiveAnchor < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/core.rb#7
+  def parse; end
+end
+
+# source://json_schemer//lib/json_schemer/draft201909/vocab/core.rb#13
+class JSONSchemer::Draft201909::Vocab::Core::RecursiveRef < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/core.rb#22
+  def recursive_anchor; end
+
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/core.rb#18
+  def ref_schema; end
+
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/core.rb#14
+  def ref_uri; end
+
+  # source://json_schemer//lib/json_schemer/draft201909/vocab/core.rb#27
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft201909/vocab.rb#26
+JSONSchemer::Draft201909::Vocab::FORMAT = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/vocab.rb#28
+JSONSchemer::Draft201909::Vocab::META_DATA = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft201909/vocab.rb#25
+JSONSchemer::Draft201909::Vocab::VALIDATION = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#3
+module JSONSchemer::Draft202012; end
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#4
+JSONSchemer::Draft202012::BASE_URI = T.let(T.unsafe(nil), URI::HTTPS)
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#26
+JSONSchemer::Draft202012::CONTENT_ENCODINGS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#29
+JSONSchemer::Draft202012::CONTENT_MEDIA_TYPES = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#5
+JSONSchemer::Draft202012::FORMATS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#90
+module JSONSchemer::Draft202012::Meta; end
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#138
+JSONSchemer::Draft202012::Meta::APPLICATOR = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#339
+JSONSchemer::Draft202012::Meta::CONTENT = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#91
+JSONSchemer::Draft202012::Meta::CORE = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#319
+JSONSchemer::Draft202012::Meta::FORMAT_ANNOTATION = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#329
+JSONSchemer::Draft202012::Meta::FORMAT_ASSERTION = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#287
+JSONSchemer::Draft202012::Meta::META_DATA = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#352
+JSONSchemer::Draft202012::Meta::SCHEMAS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#182
+JSONSchemer::Draft202012::Meta::UNEVALUATED = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#193
+JSONSchemer::Draft202012::Meta::VALIDATION = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/meta.rb#32
+JSONSchemer::Draft202012::SCHEMA = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#4
+module JSONSchemer::Draft202012::Vocab; end
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-01#section-10
+#
+# source://json_schemer//lib/json_schemer/draft202012/vocab.rb#24
+JSONSchemer::Draft202012::Vocab::APPLICATOR = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#5
+module JSONSchemer::Draft202012::Vocab::Applicator; end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#297
+class JSONSchemer::Draft202012::Vocab::Applicator::AdditionalProperties < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#298
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#302
+  def false_schema_error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#306
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#310
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#6
+class JSONSchemer::Draft202012::Vocab::Applicator::AllOf < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#7
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#11
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#17
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#25
+class JSONSchemer::Draft202012::Vocab::Applicator::AnyOf < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#26
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#30
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#36
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#191
+class JSONSchemer::Draft202012::Vocab::Applicator::Contains < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#192
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#196
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#200
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#349
+class JSONSchemer::Draft202012::Vocab::Applicator::Dependencies < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#350
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#354
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#360
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#122
+class JSONSchemer::Draft202012::Vocab::Applicator::DependentSchemas < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#123
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#127
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#133
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#106
+class JSONSchemer::Draft202012::Vocab::Applicator::Else < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#107
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#111
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#115
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#79
+class JSONSchemer::Draft202012::Vocab::Applicator::If < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#80
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#84
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#168
+class JSONSchemer::Draft202012::Vocab::Applicator::Items < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#169
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#173
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#177
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#64
+class JSONSchemer::Draft202012::Vocab::Applicator::Not < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#65
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#69
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#73
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#44
+class JSONSchemer::Draft202012::Vocab::Applicator::OneOf < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#45
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#49
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#55
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#266
+class JSONSchemer::Draft202012::Vocab::Applicator::PatternProperties < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#267
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#271
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#277
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#146
+class JSONSchemer::Draft202012::Vocab::Applicator::PrefixItems < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#147
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#151
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#157
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#218
+class JSONSchemer::Draft202012::Vocab::Applicator::Properties < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#219
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#223
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#229
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#329
+class JSONSchemer::Draft202012::Vocab::Applicator::PropertyNames < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#330
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#334
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#338
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#90
+class JSONSchemer::Draft202012::Vocab::Applicator::Then < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#91
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#95
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/applicator.rb#99
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-8
+#
+# source://json_schemer//lib/json_schemer/draft202012/vocab.rb#88
+JSONSchemer::Draft202012::Vocab::CONTENT = T.let(T.unsafe(nil), Hash)
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-01#section-8
+#
+# source://json_schemer//lib/json_schemer/draft202012/vocab.rb#6
+JSONSchemer::Draft202012::Vocab::CORE = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/content.rb#5
+module JSONSchemer::Draft202012::Vocab::Content; end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/content.rb#6
+class JSONSchemer::Draft202012::Vocab::Content::ContentEncoding < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/content.rb#7
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/content.rb#11
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/content.rb#20
+class JSONSchemer::Draft202012::Vocab::Content::ContentMediaType < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/content.rb#21
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/content.rb#25
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/content.rb#35
+class JSONSchemer::Draft202012::Vocab::Content::ContentSchema < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/content.rb#36
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/content.rb#40
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#5
+module JSONSchemer::Draft202012::Vocab::Core; end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#45
+class JSONSchemer::Draft202012::Vocab::Core::Anchor < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#46
+  def parse; end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#120
+class JSONSchemer::Draft202012::Vocab::Core::Comment < ::JSONSchemer::Keyword; end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#112
+class JSONSchemer::Draft202012::Vocab::Core::Defs < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#113
+  def parse; end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#71
+class JSONSchemer::Draft202012::Vocab::Core::DynamicAnchor < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#72
+  def parse; end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#80
+class JSONSchemer::Draft202012::Vocab::Core::DynamicRef < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#89
+  def dynamic_anchor; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#85
+  def ref_schema; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#81
+  def ref_uri; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#95
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#36
+class JSONSchemer::Draft202012::Vocab::Core::Id < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#37
+  def parse; end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#53
+class JSONSchemer::Draft202012::Vocab::Core::Ref < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#62
+  def ref_schema; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#58
+  def ref_uri; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#66
+  def validate(instance, instance_location, keyword_location, context); end
+
+  class << self
+    # @return [Boolean]
+    #
+    # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#54
+    def exclusive?; end
+  end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#6
+class JSONSchemer::Draft202012::Vocab::Core::Schema < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#7
+  def parse; end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#128
+class JSONSchemer::Draft202012::Vocab::Core::UnknownKeyword < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#139
+  def fetch(token); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#129
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#149
+  def parsed_schema; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#153
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#17
+class JSONSchemer::Draft202012::Vocab::Core::Vocabulary < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#18
+  def parse; end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#122
+class JSONSchemer::Draft202012::Vocab::Core::XError < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/core.rb#123
+  def message(error_key); end
+end
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.2.1
+#
+# source://json_schemer//lib/json_schemer/draft202012/vocab.rb#80
+JSONSchemer::Draft202012::Vocab::FORMAT_ANNOTATION = T.let(T.unsafe(nil), Hash)
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.2.2
+#
+# source://json_schemer//lib/json_schemer/draft202012/vocab.rb#84
+JSONSchemer::Draft202012::Vocab::FORMAT_ASSERTION = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/format_annotation.rb#5
+module JSONSchemer::Draft202012::Vocab::FormatAnnotation; end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/format_annotation.rb#6
+class JSONSchemer::Draft202012::Vocab::FormatAnnotation::Format < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/format_annotation.rb#7
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/format_annotation.rb#11
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/format_annotation.rb#15
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/format_assertion.rb#5
+module JSONSchemer::Draft202012::Vocab::FormatAssertion; end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/format_assertion.rb#6
+class JSONSchemer::Draft202012::Vocab::FormatAssertion::Format < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/format_assertion.rb#7
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/format_assertion.rb#11
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/format_assertion.rb#15
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-9
+#
+# source://json_schemer//lib/json_schemer/draft202012/vocab.rb#94
+JSONSchemer::Draft202012::Vocab::META_DATA = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/meta_data.rb#5
+module JSONSchemer::Draft202012::Vocab::MetaData; end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/meta_data.rb#6
+class JSONSchemer::Draft202012::Vocab::MetaData::ReadOnly < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/meta_data.rb#7
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/meta_data.rb#11
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/meta_data.rb#17
+class JSONSchemer::Draft202012::Vocab::MetaData::WriteOnly < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/meta_data.rb#18
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/meta_data.rb#22
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-01#section-11
+#
+# source://json_schemer//lib/json_schemer/draft202012/vocab.rb#47
+JSONSchemer::Draft202012::Vocab::UNEVALUATED = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/unevaluated.rb#5
+module JSONSchemer::Draft202012::Vocab::Unevaluated; end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/unevaluated.rb#6
+class JSONSchemer::Draft202012::Vocab::Unevaluated::UnevaluatedItems < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/unevaluated.rb#7
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/unevaluated.rb#11
+  def false_schema_error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/unevaluated.rb#15
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/unevaluated.rb#19
+  def validate(instance, instance_location, keyword_location, context); end
+
+  private
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/unevaluated.rb#37
+  def collect_unevaluated_items(result, unevaluated_items); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/unevaluated.rb#54
+class JSONSchemer::Draft202012::Vocab::Unevaluated::UnevaluatedProperties < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/unevaluated.rb#55
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/unevaluated.rb#59
+  def false_schema_error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/unevaluated.rb#63
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/unevaluated.rb#67
+  def validate(instance, instance_location, keyword_location, context); end
+
+  private
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/unevaluated.rb#89
+  def collect_evaluated_keys(result, evaluated_keys); end
+end
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-6
+#
+# source://json_schemer//lib/json_schemer/draft202012/vocab.rb#52
+JSONSchemer::Draft202012::Vocab::VALIDATION = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#5
+module JSONSchemer::Draft202012::Vocab::Validation; end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#71
+class JSONSchemer::Draft202012::Vocab::Validation::Const < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#72
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#76
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#264
+class JSONSchemer::Draft202012::Vocab::Validation::DependentRequired < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#265
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#269
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#61
+class JSONSchemer::Draft202012::Vocab::Validation::Enum < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#62
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#66
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#101
+class JSONSchemer::Draft202012::Vocab::Validation::ExclusiveMaximum < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#102
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#106
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#121
+class JSONSchemer::Draft202012::Vocab::Validation::ExclusiveMinimum < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#122
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#126
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#195
+class JSONSchemer::Draft202012::Vocab::Validation::MaxContains < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#196
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#200
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#165
+class JSONSchemer::Draft202012::Vocab::Validation::MaxItems < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#166
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#170
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#131
+class JSONSchemer::Draft202012::Vocab::Validation::MaxLength < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#132
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#136
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#219
+class JSONSchemer::Draft202012::Vocab::Validation::MaxProperties < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#220
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#224
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#91
+class JSONSchemer::Draft202012::Vocab::Validation::Maximum < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#92
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#96
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#207
+class JSONSchemer::Draft202012::Vocab::Validation::MinContains < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#208
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#212
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#175
+class JSONSchemer::Draft202012::Vocab::Validation::MinItems < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#176
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#180
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#141
+class JSONSchemer::Draft202012::Vocab::Validation::MinLength < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#142
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#146
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#229
+class JSONSchemer::Draft202012::Vocab::Validation::MinProperties < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#230
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#234
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#111
+class JSONSchemer::Draft202012::Vocab::Validation::Minimum < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#112
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#116
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#81
+class JSONSchemer::Draft202012::Vocab::Validation::MultipleOf < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#82
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#86
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#151
+class JSONSchemer::Draft202012::Vocab::Validation::Pattern < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#152
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#156
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#160
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#239
+class JSONSchemer::Draft202012::Vocab::Validation::Required < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#240
+  def error(formatted_instance_location:, details:, **_arg2); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#244
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#6
+class JSONSchemer::Draft202012::Vocab::Validation::Type < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#7
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#28
+  def validate(instance, instance_location, keyword_location, _context); end
+
+  private
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#39
+  def valid_type(type, instance); end
+end
+
+# source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#185
+class JSONSchemer::Draft202012::Vocab::Validation::UniqueItems < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#186
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft202012/vocab/validation.rb#190
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft4/meta.rb#3
+module JSONSchemer::Draft4; end
+
+# source://json_schemer//lib/json_schemer/draft4/meta.rb#4
+JSONSchemer::Draft4::BASE_URI = T.let(T.unsafe(nil), URI::HTTP)
+
+# source://json_schemer//lib/json_schemer/draft4/meta.rb#9
+JSONSchemer::Draft4::CONTENT_ENCODINGS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft4/meta.rb#10
+JSONSchemer::Draft4::CONTENT_MEDIA_TYPES = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft4/meta.rb#5
+JSONSchemer::Draft4::FORMATS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft4/meta.rb#11
+JSONSchemer::Draft4::SCHEMA = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft4/vocab/validation.rb#4
+module JSONSchemer::Draft4::Vocab; end
+
+# source://json_schemer//lib/json_schemer/draft4/vocab.rb#5
+JSONSchemer::Draft4::Vocab::ALL = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft4/vocab/validation.rb#5
+module JSONSchemer::Draft4::Vocab::Validation; end
+
+# source://json_schemer//lib/json_schemer/draft4/vocab/validation.rb#13
+class JSONSchemer::Draft4::Vocab::Validation::ExclusiveMaximum < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft4/vocab/validation.rb#14
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft4/vocab/validation.rb#18
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft4/vocab/validation.rb#25
+class JSONSchemer::Draft4::Vocab::Validation::ExclusiveMinimum < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft4/vocab/validation.rb#26
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft4/vocab/validation.rb#30
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft4/vocab/validation.rb#6
+class JSONSchemer::Draft4::Vocab::Validation::Type < ::JSONSchemer::Draft202012::Vocab::Validation::Type
+  private
+
+  # source://json_schemer//lib/json_schemer/draft4/vocab/validation.rb#8
+  def valid_type(type, instance); end
+end
+
+# source://json_schemer//lib/json_schemer/draft6/meta.rb#3
+module JSONSchemer::Draft6; end
+
+# source://json_schemer//lib/json_schemer/draft6/meta.rb#4
+JSONSchemer::Draft6::BASE_URI = T.let(T.unsafe(nil), URI::HTTP)
+
+# source://json_schemer//lib/json_schemer/draft6/meta.rb#14
+JSONSchemer::Draft6::CONTENT_ENCODINGS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft6/meta.rb#15
+JSONSchemer::Draft6::CONTENT_MEDIA_TYPES = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft6/meta.rb#5
+JSONSchemer::Draft6::FORMATS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft6/meta.rb#16
+JSONSchemer::Draft6::SCHEMA = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft6/vocab.rb#4
+module JSONSchemer::Draft6::Vocab; end
+
+# source://json_schemer//lib/json_schemer/draft6/vocab.rb#5
+JSONSchemer::Draft6::Vocab::ALL = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft7/meta.rb#3
+module JSONSchemer::Draft7; end
+
+# source://json_schemer//lib/json_schemer/draft7/meta.rb#4
+JSONSchemer::Draft7::BASE_URI = T.let(T.unsafe(nil), URI::HTTP)
+
+# source://json_schemer//lib/json_schemer/draft7/meta.rb#8
+JSONSchemer::Draft7::CONTENT_ENCODINGS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft7/meta.rb#9
+JSONSchemer::Draft7::CONTENT_MEDIA_TYPES = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft7/meta.rb#5
+JSONSchemer::Draft7::FORMATS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft7/meta.rb#10
+JSONSchemer::Draft7::SCHEMA = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft7/vocab/validation.rb#4
+module JSONSchemer::Draft7::Vocab; end
+
+# source://json_schemer//lib/json_schemer/draft7/vocab.rb#5
+JSONSchemer::Draft7::Vocab::ALL = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/draft7/vocab/validation.rb#5
+module JSONSchemer::Draft7::Vocab::Validation; end
+
+# source://json_schemer//lib/json_schemer/draft7/vocab/validation.rb#12
+class JSONSchemer::Draft7::Vocab::Validation::AdditionalItems < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/draft7/vocab/validation.rb#13
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft7/vocab/validation.rb#17
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/draft7/vocab/validation.rb#21
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft7/vocab/validation.rb#38
+class JSONSchemer::Draft7::Vocab::Validation::ContentEncoding < ::JSONSchemer::Draft202012::Vocab::Content::ContentEncoding
+  # source://json_schemer//lib/json_schemer/draft7/vocab/validation.rb#39
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft7/vocab/validation.rb#43
+  def validate(instance, instance_location, keyword_location, _context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft7/vocab/validation.rb#52
+class JSONSchemer::Draft7::Vocab::Validation::ContentMediaType < ::JSONSchemer::Draft202012::Vocab::Content::ContentMediaType
+  # source://json_schemer//lib/json_schemer/draft7/vocab/validation.rb#53
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/draft7/vocab/validation.rb#57
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/draft7/vocab/validation.rb#6
+class JSONSchemer::Draft7::Vocab::Validation::Ref < ::JSONSchemer::Draft202012::Vocab::Core::Ref
+  class << self
+    # @return [Boolean]
+    #
+    # source://json_schemer//lib/json_schemer/draft7/vocab/validation.rb#7
+    def exclusive?; end
+  end
+end
+
+# source://json_schemer//lib/json_schemer/ecma_regexp.rb#3
+class JSONSchemer::EcmaRegexp
+  class << self
+    # source://json_schemer//lib/json_schemer/ecma_regexp.rb#39
+    def ruby_equivalent(pattern); end
+  end
+end
+
+# source://json_schemer//lib/json_schemer/ecma_regexp.rb#27
+JSONSchemer::EcmaRegexp::RUBY_EQUIVALENTS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/ecma_regexp.rb#4
+class JSONSchemer::EcmaRegexp::Syntax < ::Regexp::Syntax::Base; end
+
+# regexp_parser >= 2.3.0 uses syntax classes directly instead of instances
+# :nocov:
+#
+# source://json_schemer//lib/json_schemer/ecma_regexp.rb#7
+JSONSchemer::EcmaRegexp::Syntax::SYNTAX = JSONSchemer::EcmaRegexp::Syntax
+
+# source://json_schemer//lib/json_schemer/errors.rb#6
+module JSONSchemer::Errors
+  class << self
+    # source://json_schemer//lib/json_schemer/errors.rb#8
+    def pretty(error); end
+  end
+end
+
+# source://json_schemer//lib/json_schemer.rb#106
+JSONSchemer::FILE_URI_REF_RESOLVER = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format/duration.rb#3
+module JSONSchemer::Format
+  extend ::JSONSchemer::Format::Duration
+  extend ::JSONSchemer::Format::Email
+  extend ::JSONSchemer::Format::Hostname
+  extend ::JSONSchemer::Format::JSONPointer
+  extend ::JSONSchemer::Format::URITemplate
+
+  class << self
+    # source://json_schemer//lib/json_schemer/format.rb#132
+    def iri_escape(data); end
+
+    # @raise [::URI::InvalidURIError]
+    #
+    # source://json_schemer//lib/json_schemer/format.rb#112
+    def parse_uri_scheme(data); end
+
+    # source://json_schemer//lib/json_schemer/format.rb#90
+    def percent_encode(data, regexp); end
+
+    # @return [Boolean]
+    #
+    # source://json_schemer//lib/json_schemer/format.rb#96
+    def valid_date_time?(data); end
+
+    # @return [Boolean]
+    #
+    # source://json_schemer//lib/json_schemer/format.rb#105
+    def valid_ip?(data, family); end
+
+    # @return [Boolean]
+    #
+    # source://json_schemer//lib/json_schemer/format.rb#136
+    def valid_regex?(data); end
+
+    # @return [Boolean]
+    #
+    # source://json_schemer//lib/json_schemer/format.rb#119
+    def valid_uri?(data); end
+
+    # @return [Boolean]
+    #
+    # source://json_schemer//lib/json_schemer/format.rb#125
+    def valid_uri_reference?(data); end
+
+    # @return [Boolean]
+    #
+    # source://json_schemer//lib/json_schemer/format.rb#142
+    def valid_uuid?(data); end
+  end
+end
+
+# source://json_schemer//lib/json_schemer/format.rb#79
+JSONSchemer::Format::BINARY_TO_PERCENT_ENCODED = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/format.rb#8
+JSONSchemer::Format::DATE = T.let(T.unsafe(nil), Proc)
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3
+#
+# source://json_schemer//lib/json_schemer/format.rb#5
+JSONSchemer::Format::DATE_TIME = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format.rb#70
+JSONSchemer::Format::DATE_TIME_OFFSET_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer/format.rb#71
+JSONSchemer::Format::DATE_TIME_SEPARATOR_CHARACTER_CLASS = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format.rb#14
+JSONSchemer::Format::DURATION = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format/duration.rb#4
+module JSONSchemer::Format::Duration
+  # @return [Boolean]
+  #
+  # source://json_schemer//lib/json_schemer/format/duration.rb#18
+  def valid_duration?(data); end
+end
+
+# duration          = "P" (dur-date / dur-time / dur-week)
+#
+# source://json_schemer//lib/json_schemer/format/duration.rb#15
+JSONSchemer::Format::Duration::DURATION = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format/duration.rb#16
+JSONSchemer::Format::Duration::DURATION_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# dur-date          = (dur-day / dur-month / dur-year) [dur-time]
+#
+# source://json_schemer//lib/json_schemer/format/duration.rb#14
+JSONSchemer::Format::Duration::DUR_DATE = T.let(T.unsafe(nil), String)
+
+# dur-day           = 1*DIGIT "D"
+#
+# source://json_schemer//lib/json_schemer/format/duration.rb#10
+JSONSchemer::Format::Duration::DUR_DAY = T.let(T.unsafe(nil), String)
+
+# dur-hour          = 1*DIGIT "H" [dur-minute]
+#
+# source://json_schemer//lib/json_schemer/format/duration.rb#8
+JSONSchemer::Format::Duration::DUR_HOUR = T.let(T.unsafe(nil), String)
+
+# dur-second        = 1*DIGIT "S"
+#
+# source://json_schemer//lib/json_schemer/format/duration.rb#7
+JSONSchemer::Format::Duration::DUR_MINUTE = T.let(T.unsafe(nil), String)
+
+# dur-month         = 1*DIGIT "M" [dur-day]
+#
+# source://json_schemer//lib/json_schemer/format/duration.rb#12
+JSONSchemer::Format::Duration::DUR_MONTH = T.let(T.unsafe(nil), String)
+
+# https://datatracker.ietf.org/doc/html/rfc3339#appendix-A
+#
+# source://json_schemer//lib/json_schemer/format/duration.rb#6
+JSONSchemer::Format::Duration::DUR_SECOND = T.let(T.unsafe(nil), String)
+
+# dur-time          = "T" (dur-hour / dur-minute / dur-second)
+#
+# source://json_schemer//lib/json_schemer/format/duration.rb#9
+JSONSchemer::Format::Duration::DUR_TIME = T.let(T.unsafe(nil), String)
+
+# dur-week          = 1*DIGIT "W"
+#
+# source://json_schemer//lib/json_schemer/format/duration.rb#11
+JSONSchemer::Format::Duration::DUR_WEEK = T.let(T.unsafe(nil), String)
+
+# dur-year          = 1*DIGIT "Y" [dur-month]
+#
+# source://json_schemer//lib/json_schemer/format/duration.rb#13
+JSONSchemer::Format::Duration::DUR_YEAR = T.let(T.unsafe(nil), String)
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3.2
+#
+# source://json_schemer//lib/json_schemer/format.rb#18
+JSONSchemer::Format::EMAIL = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format/email.rb#4
+module JSONSchemer::Format::Email
+  # @return [Boolean]
+  #
+  # source://json_schemer//lib/json_schemer/format/email.rb#44
+  def valid_email?(data); end
+end
+
+# using `valid_id?` to check ip addresses because it's complicated.     # IPv6-address-literal  = "IPv6:" IPv6-addr
+#
+# source://json_schemer//lib/json_schemer/format/email.rb#36
+JSONSchemer::Format::Email::ADDRESS_LITERAL = T.let(T.unsafe(nil), String)
+
+# Atom            = 1*atext
+#
+# source://json_schemer//lib/json_schemer/format/email.rb#30
+JSONSchemer::Format::Email::ATOM = T.let(T.unsafe(nil), String)
+
+# https://datatracker.ietf.org/doc/html/rfc5321#section-4.1.2
+#
+# source://json_schemer//lib/json_schemer/format/email.rb#9
+JSONSchemer::Format::Email::A_TEXT = T.let(T.unsafe(nil), String)
+
+# Dot-string      = Atom *("."  Atom)
+#
+# source://json_schemer//lib/json_schemer/format/email.rb#31
+JSONSchemer::Format::Email::DOT_STRING = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format/email.rb#42
+JSONSchemer::Format::Email::EMAIL_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer/format/email.rb#32
+JSONSchemer::Format::Email::LOCAL_PART = T.let(T.unsafe(nil), String)
+
+# using `valid_hostname?` to check domain because it's complicated
+#
+# source://json_schemer//lib/json_schemer/format/email.rb#41
+JSONSchemer::Format::Email::MAILBOX = T.let(T.unsafe(nil), String)
+
+# qtextSMTP       = %d32-33 / %d35-91 / %d93-126
+#                 ; i.e., within a quoted string, any
+#                 ; ASCII graphic or space is permitted
+#                 ; without blackslash-quoting except
+#                 ; double-quote and the backslash itself.
+#
+# source://json_schemer//lib/json_schemer/format/email.rb#25
+JSONSchemer::Format::Email::QUOTED_PAIR_SMTP = T.let(T.unsafe(nil), String)
+
+# Quoted-string   = DQUOTE *QcontentSMTP DQUOTE
+#
+# source://json_schemer//lib/json_schemer/format/email.rb#29
+JSONSchemer::Format::Email::QUOTED_STRING = T.let(T.unsafe(nil), String)
+
+# quoted-pairSMTP = %d92 %d32-126
+#                 ; i.e., backslash followed by any ASCII
+#                 ; graphic (including itself) or SPace
+#
+# source://json_schemer//lib/json_schemer/format/email.rb#28
+JSONSchemer::Format::Email::Q_CONTENT_SMTP = T.let(T.unsafe(nil), String)
+
+# atext           = ALPHA / DIGIT /    ; Printable US-ASCII
+#                   "!" / "#" /        ;  characters not including
+#                   "$" / "%" /        ;  specials.  Used for atoms.
+#                   "&" / "'" /
+#                   "*" / "+" /
+#                   "-" / "/" /
+#                   "=" / "?" /
+#                   "^" / "_" /
+#                   "`" / "{" /
+#                   "|" / "}" /
+#                   "~"
+#
+# source://json_schemer//lib/json_schemer/format/email.rb#20
+JSONSchemer::Format::Email::Q_TEXT_SMTP = T.let(T.unsafe(nil), String)
+
+# https://datatracker.ietf.org/doc/html/rfc6531#section-3.3
+# I think this is the same as "UTF8-non-ascii"? (https://datatracker.ietf.org/doc/html/rfc6532#section-3.1)
+#
+# source://json_schemer//lib/json_schemer/format/email.rb#7
+JSONSchemer::Format::Email::UTF8_NON_ASCII = T.let(T.unsafe(nil), String)
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3.3
+#
+# source://json_schemer//lib/json_schemer/format.rb#25
+JSONSchemer::Format::HOSTNAME = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format.rb#72
+JSONSchemer::Format::HOUR_24_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer/format/hostname.rb#4
+module JSONSchemer::Format::Hostname
+  # @return [Boolean]
+  #
+  # source://json_schemer//lib/json_schemer/format/hostname.rb#42
+  def valid_hostname?(data); end
+end
+
+# source://json_schemer//lib/json_schemer/format/hostname.rb#40
+JSONSchemer::Format::Hostname::ARABIC_EXTENDED_DIGITS_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# https://datatracker.ietf.org/doc/html/rfc5892#appendix-A.8
+# https://datatracker.ietf.org/doc/html/rfc5892#appendix-A.9
+#
+# source://json_schemer//lib/json_schemer/format/hostname.rb#39
+JSONSchemer::Format::Hostname::ARABIC_INDIC_DIGITS_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer/format/hostname.rb#33
+JSONSchemer::Format::Hostname::CONTEXT_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# \u{00DF}\u{03C2} covered by \p{Ll}
+#
+# source://json_schemer//lib/json_schemer/format/hostname.rb#10
+JSONSchemer::Format::Hostname::EXCEPTIONS_DISALLOWED = T.let(T.unsafe(nil), String)
+
+# https://datatracker.ietf.org/doc/html/rfc5892#section-2.6
+#
+# source://json_schemer//lib/json_schemer/format/hostname.rb#9
+JSONSchemer::Format::Hostname::EXCEPTIONS_PVALID = T.let(T.unsafe(nil), String)
+
+# https://datatracker.ietf.org/doc/html/rfc5892#appendix-A.4
+#
+# source://json_schemer//lib/json_schemer/format/hostname.rb#29
+JSONSchemer::Format::Hostname::GREEK_LOWER_NUMERAL_SIGN = T.let(T.unsafe(nil), String)
+
+# https://datatracker.ietf.org/doc/html/rfc5892#appendix-A.5
+# https://datatracker.ietf.org/doc/html/rfc5892#appendix-A.6
+#
+# source://json_schemer//lib/json_schemer/format/hostname.rb#32
+JSONSchemer::Format::Hostname::HEBREW_PUNCTUATION = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format/hostname.rb#15
+JSONSchemer::Format::Hostname::HOSTNAME_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer/format/hostname.rb#19
+JSONSchemer::Format::Hostname::JOINING_TYPE_D_CHARACTER_CLASS = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format/hostname.rb#18
+JSONSchemer::Format::Hostname::JOINING_TYPE_L_CHARACTER_CLASS = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format/hostname.rb#21
+JSONSchemer::Format::Hostname::JOINING_TYPE_R_CHARACTER_CLASS = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format/hostname.rb#20
+JSONSchemer::Format::Hostname::JOINING_TYPE_T_CHARACTER_CLASS = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format/hostname.rb#36
+JSONSchemer::Format::Hostname::KATAKANA_MIDDLE_DOT_CONTEXT_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# https://datatracker.ietf.org/doc/html/rfc5892#appendix-A.7
+#
+# source://json_schemer//lib/json_schemer/format/hostname.rb#35
+JSONSchemer::Format::Hostname::KATAKANA_MIDDLE_DOT_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer/format/hostname.rb#11
+JSONSchemer::Format::Hostname::LABEL_CHARACTER_CLASS = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format/hostname.rb#14
+JSONSchemer::Format::Hostname::LABEL_REGEX_STRING = T.let(T.unsafe(nil), String)
+
+# https://datatracker.ietf.org/doc/html/rfc5891#section-4.2.3.2
+#
+# source://json_schemer//lib/json_schemer/format/hostname.rb#13
+JSONSchemer::Format::Hostname::LEADING_CHARACTER_CLASS = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format/hostname.rb#7
+JSONSchemer::Format::Hostname::LETTER_DIGITS = T.let(T.unsafe(nil), String)
+
+# https://datatracker.ietf.org/doc/html/rfc5892#section-2.1
+#
+# source://json_schemer//lib/json_schemer/format/hostname.rb#6
+JSONSchemer::Format::Hostname::MARKS = T.let(T.unsafe(nil), String)
+
+# https://datatracker.ietf.org/doc/html/rfc5892#appendix-A.3
+#
+# source://json_schemer//lib/json_schemer/format/hostname.rb#27
+JSONSchemer::Format::Hostname::MIDDLE_DOT = T.let(T.unsafe(nil), String)
+
+# bin/hostname_character_classes
+#
+# source://json_schemer//lib/json_schemer/format/hostname.rb#17
+JSONSchemer::Format::Hostname::VIRAMA_CHARACTER_CLASS = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format/hostname.rb#25
+JSONSchemer::Format::Hostname::ZERO_WIDTH_NON_JOINER_JOINING_TYPE = T.let(T.unsafe(nil), String)
+
+# https://datatracker.ietf.org/doc/html/rfc5892#appendix-A.1
+# https://datatracker.ietf.org/doc/html/rfc5892#appendix-A.2
+#
+# source://json_schemer//lib/json_schemer/format/hostname.rb#24
+JSONSchemer::Format::Hostname::ZERO_WIDTH_VIRAMA = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format.rb#21
+JSONSchemer::Format::IDN_EMAIL = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format.rb#28
+JSONSchemer::Format::IDN_HOSTNAME = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format.rb#75
+JSONSchemer::Format::INVALID_QUERY_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3.4
+#
+# source://json_schemer//lib/json_schemer/format.rb#32
+JSONSchemer::Format::IPV4 = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format.rb#35
+JSONSchemer::Format::IPV6 = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format.rb#74
+JSONSchemer::Format::IP_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer/format.rb#45
+JSONSchemer::Format::IRI = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format.rb#76
+JSONSchemer::Format::IRI_ESCAPE_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer/format.rb#48
+JSONSchemer::Format::IRI_REFERENCE = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format/json_pointer.rb#4
+module JSONSchemer::Format::JSONPointer
+  # @return [Boolean]
+  #
+  # source://json_schemer//lib/json_schemer/format/json_pointer.rb#9
+  def valid_json_pointer?(data); end
+
+  # @return [Boolean]
+  #
+  # source://json_schemer//lib/json_schemer/format/json_pointer.rb#13
+  def valid_relative_json_pointer?(data); end
+end
+
+# source://json_schemer//lib/json_schemer/format/json_pointer.rb#6
+JSONSchemer::Format::JSONPointer::JSON_POINTER_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer/format/json_pointer.rb#5
+JSONSchemer::Format::JSONPointer::JSON_POINTER_REGEX_STRING = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format/json_pointer.rb#7
+JSONSchemer::Format::JSONPointer::RELATIVE_JSON_POINTER_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3.7
+#
+# source://json_schemer//lib/json_schemer/format.rb#59
+JSONSchemer::Format::JSON_POINTER = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format.rb#73
+JSONSchemer::Format::LEAP_SECOND_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer/format.rb#78
+JSONSchemer::Format::NIL_UUID = T.let(T.unsafe(nil), String)
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3.8
+#
+# source://json_schemer//lib/json_schemer/format.rb#66
+JSONSchemer::Format::REGEX = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format.rb#62
+JSONSchemer::Format::RELATIVE_JSON_POINTER = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format.rb#11
+JSONSchemer::Format::TIME = T.let(T.unsafe(nil), Proc)
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3.5
+#
+# source://json_schemer//lib/json_schemer/format.rb#39
+JSONSchemer::Format::URI = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#4
+module JSONSchemer::Format::URITemplate
+  # @return [Boolean]
+  #
+  # source://json_schemer//lib/json_schemer/format/uri_template.rb#29
+  def valid_uri_template?(data); end
+end
+
+# pct-encoded     =  "%" HEXDIG HEXDIG
+#
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#7
+JSONSchemer::Format::URITemplate::EXPLODE = T.let(T.unsafe(nil), String)
+
+# operator        =  op-level2 / op-level3 / op-reserve
+# op-level2       =  "+" / "#"
+# op-level3       =  "." / "/" / ";" / "?" / "&"
+# op-reserve      =  "=" / "," / "!" / "@" / "|"
+#
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#19
+JSONSchemer::Format::URITemplate::EXPRESSION = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#20
+JSONSchemer::Format::URITemplate::LITERALS = T.let(T.unsafe(nil), String)
+
+# explode         =  "*"
+#
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#8
+JSONSchemer::Format::URITemplate::MAX_LENGTH = T.let(T.unsafe(nil), String)
+
+# modifier-level4 =  prefix / explode
+#
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#10
+JSONSchemer::Format::URITemplate::MODIFIER_LEVEL4 = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#15
+JSONSchemer::Format::URITemplate::OPERATOR = T.let(T.unsafe(nil), String)
+
+# https://datatracker.ietf.org/doc/html/rfc6570
+#
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#6
+JSONSchemer::Format::URITemplate::PCT_ENCODED = T.let(T.unsafe(nil), String)
+
+# max-length      =  %x31-39 0*3DIGIT   ; positive integer < 10000
+#
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#9
+JSONSchemer::Format::URITemplate::PREFIX = T.let(T.unsafe(nil), String)
+
+# literals        =  %x21 / %x23-24 / %x26 / %x28-3B / %x3D / %x3F-5B
+#                 /  %x5D / %x5F / %x61-7A / %x7E / ucschar / iprivate
+#                 /  pct-encoded
+#                      ; any Unicode character except: CTL, SP,
+#                      ;  DQUOTE, "'", "%" (aside from pct-encoded),
+#                      ;  "<", ">", "\", "^", "`", "{", "|", "}"
+#
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#26
+JSONSchemer::Format::URITemplate::URI_TEMPLATE = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#27
+JSONSchemer::Format::URITemplate::URI_TEMPLATE_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# varchar         =  ALPHA / DIGIT / "_" / pct-encoded
+#
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#11
+JSONSchemer::Format::URITemplate::VARCHAR = T.let(T.unsafe(nil), String)
+
+# variable-list   =  varspec *( "," varspec )
+#
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#14
+JSONSchemer::Format::URITemplate::VARIABLE_LIST = T.let(T.unsafe(nil), String)
+
+# varname         =  varchar *( ["."] varchar )
+#
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#12
+JSONSchemer::Format::URITemplate::VARNAME = T.let(T.unsafe(nil), String)
+
+# varspec         =  varname [ modifier-level4 ]
+#
+# source://json_schemer//lib/json_schemer/format/uri_template.rb#13
+JSONSchemer::Format::URITemplate::VARSPEC = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/format.rb#42
+JSONSchemer::Format::URI_REFERENCE = T.let(T.unsafe(nil), Proc)
+
+# https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-01#section-7.3.6
+#
+# source://json_schemer//lib/json_schemer/format.rb#55
+JSONSchemer::Format::URI_TEMPLATE = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format.rb#51
+JSONSchemer::Format::UUID = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/format.rb#77
+JSONSchemer::Format::UUID_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer/result.rb#6
+JSONSchemer::I18N_ERRORS_SCOPE = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer/result.rb#5
+JSONSchemer::I18N_SCOPE = T.let(T.unsafe(nil), String)
+
+# unit separator
+#
+# source://json_schemer//lib/json_schemer/result.rb#4
+JSONSchemer::I18N_SEPARATOR = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer.rb#76
+class JSONSchemer::InvalidEcmaRegexp < ::StandardError; end
+
+# source://json_schemer//lib/json_schemer.rb#75
+class JSONSchemer::InvalidFileURI < ::StandardError; end
+
+# source://json_schemer//lib/json_schemer.rb#73
+class JSONSchemer::InvalidRefPointer < ::StandardError; end
+
+# source://json_schemer//lib/json_schemer.rb#72
+class JSONSchemer::InvalidRefResolution < ::StandardError; end
+
+# source://json_schemer//lib/json_schemer.rb#74
+class JSONSchemer::InvalidRegexpResolution < ::StandardError; end
+
+# source://json_schemer//lib/json_schemer/keyword.rb#3
+class JSONSchemer::Keyword
+  include ::JSONSchemer::Output
+
+  # @return [Keyword] a new instance of Keyword
+  #
+  # source://json_schemer//lib/json_schemer/keyword.rb#8
+  def initialize(value, parent, keyword, schema = T.unsafe(nil)); end
+
+  # source://json_schemer//lib/json_schemer/keyword.rb#21
+  def absolute_keyword_location; end
+
+  # source://json_schemer//lib/json_schemer/keyword.rb#29
+  def error_key; end
+
+  # source://json_schemer//lib/json_schemer/keyword.rb#33
+  def fetch(key); end
+
+  # Returns the value of attribute parent.
+  #
+  # source://json_schemer//lib/json_schemer/keyword.rb#6
+  def parent; end
+
+  # Returns the value of attribute parsed.
+  #
+  # source://json_schemer//lib/json_schemer/keyword.rb#6
+  def parsed; end
+
+  # source://json_schemer//lib/json_schemer/keyword.rb#37
+  def parsed_schema; end
+
+  # Returns the value of attribute root.
+  #
+  # source://json_schemer//lib/json_schemer/keyword.rb#6
+  def root; end
+
+  # source://json_schemer//lib/json_schemer/keyword.rb#25
+  def schema_pointer; end
+
+  # source://json_schemer//lib/json_schemer/keyword.rb#17
+  def validate(_instance, _instance_location, _keyword_location, _context); end
+
+  # Returns the value of attribute value.
+  #
+  # source://json_schemer//lib/json_schemer/keyword.rb#6
+  def value; end
+
+  private
+
+  # source://json_schemer//lib/json_schemer/keyword.rb#43
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/keyword.rb#47
+  def subschema(value, keyword = T.unsafe(nil), **options); end
+end
+
+# source://json_schemer//lib/json_schemer/location.rb#3
+module JSONSchemer::Location
+  class << self
+    # source://json_schemer//lib/json_schemer/location.rb#20
+    def escape_json_pointer_token(token); end
+
+    # source://json_schemer//lib/json_schemer/location.rb#12
+    def join(location, name); end
+
+    # source://json_schemer//lib/json_schemer/location.rb#16
+    def resolve(location); end
+
+    # source://json_schemer//lib/json_schemer/location.rb#8
+    def root; end
+  end
+end
+
+# source://json_schemer//lib/json_schemer/location.rb#4
+JSONSchemer::Location::JSON_POINTER_TOKEN_ESCAPE_CHARS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/location.rb#5
+JSONSchemer::Location::JSON_POINTER_TOKEN_ESCAPE_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer.rb#285
+JSONSchemer::META_SCHEMAS_BY_BASE_URI_STR = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer.rb#273
+JSONSchemer::META_SCHEMA_CALLABLES_BY_BASE_URI_STR = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/openapi.rb#3
+class JSONSchemer::OpenAPI
+  # @return [OpenAPI] a new instance of OpenAPI
+  #
+  # source://json_schemer//lib/json_schemer/openapi.rb#4
+  def initialize(document, **options); end
+
+  # source://json_schemer//lib/json_schemer/openapi.rb#30
+  def ref(value); end
+
+  # source://json_schemer//lib/json_schemer/openapi.rb#34
+  def schema(name); end
+
+  # @return [Boolean]
+  #
+  # source://json_schemer//lib/json_schemer/openapi.rb#22
+  def valid?; end
+
+  # source://json_schemer//lib/json_schemer/openapi.rb#26
+  def validate(**options); end
+end
+
+# source://json_schemer//lib/json_schemer/openapi30/document.rb#3
+module JSONSchemer::OpenAPI30; end
+
+# source://json_schemer//lib/json_schemer/openapi30/meta.rb#4
+JSONSchemer::OpenAPI30::BASE_URI = T.let(T.unsafe(nil), URI::Generic)
+
+# source://json_schemer//lib/json_schemer/openapi30/document.rb#4
+module JSONSchemer::OpenAPI30::Document; end
+
+# source://json_schemer//lib/json_schemer/openapi30/document.rb#5
+JSONSchemer::OpenAPI30::Document::SCHEMA = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/openapi30/document.rb#1667
+JSONSchemer::OpenAPI30::Document::SCHEMAS = T.let(T.unsafe(nil), Hash)
+
+# https://spec.openapis.org/oas/v3.0.3#data-types
+#
+# source://json_schemer//lib/json_schemer/openapi30/meta.rb#6
+JSONSchemer::OpenAPI30::FORMATS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/openapi30/meta.rb#25
+module JSONSchemer::OpenAPI30::Meta; end
+
+# source://json_schemer//lib/json_schemer/openapi30/meta.rb#26
+JSONSchemer::OpenAPI30::Meta::SCHEMAS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/openapi30/meta.rb#11
+JSONSchemer::OpenAPI30::SCHEMA = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/openapi30/vocab/base.rb#4
+module JSONSchemer::OpenAPI30::Vocab; end
+
+# https://spec.openapis.org/oas/v3.0.3#schema-object
+#
+# source://json_schemer//lib/json_schemer/openapi30/vocab.rb#6
+JSONSchemer::OpenAPI30::Vocab::BASE = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/openapi30/vocab/base.rb#5
+module JSONSchemer::OpenAPI30::Vocab::Base; end
+
+# source://json_schemer//lib/json_schemer/openapi30/vocab/base.rb#6
+class JSONSchemer::OpenAPI30::Vocab::Base::Type < ::JSONSchemer::Draft4::Vocab::Validation::Type
+  # source://json_schemer//lib/json_schemer/openapi30/vocab/base.rb#7
+  def parse; end
+end
+
+# source://json_schemer//lib/json_schemer/openapi31/meta.rb#3
+module JSONSchemer::OpenAPI31; end
+
+# source://json_schemer//lib/json_schemer/openapi31/meta.rb#4
+JSONSchemer::OpenAPI31::BASE_URI = T.let(T.unsafe(nil), URI::HTTPS)
+
+# source://json_schemer//lib/json_schemer/openapi31/document.rb#4
+module JSONSchemer::OpenAPI31::Document
+  class << self
+    # source://json_schemer//lib/json_schemer/openapi31/document.rb#16
+    def dialect_schema(dialect); end
+  end
+end
+
+# source://json_schemer//lib/json_schemer/openapi31/document.rb#14
+JSONSchemer::OpenAPI31::Document::DEFAULT_DIALECT = T.let(T.unsafe(nil), String)
+
+# http://json-schema.org/blog/posts/validating-openapi-and-json-schema
+#
+# source://json_schemer//lib/json_schemer/openapi31/document.rb#6
+JSONSchemer::OpenAPI31::Document::DIALECTS = T.let(T.unsafe(nil), Array)
+
+# source://json_schemer//lib/json_schemer/openapi31/document.rb#14
+JSONSchemer::OpenAPI31::Document::OTHER_DIALECTS = T.let(T.unsafe(nil), Array)
+
+# source://json_schemer//lib/json_schemer/openapi31/document.rb#104
+JSONSchemer::OpenAPI31::Document::SCHEMA = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/openapi31/document.rb#1543
+JSONSchemer::OpenAPI31::Document::SCHEMAS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/openapi31/document.rb#63
+JSONSchemer::OpenAPI31::Document::SCHEMA_BASE = T.let(T.unsafe(nil), Hash)
+
+# https://spec.openapis.org/oas/v3.1.0#data-types
+#
+# source://json_schemer//lib/json_schemer/openapi31/meta.rb#6
+JSONSchemer::OpenAPI31::FORMATS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/openapi31/meta.rb#40
+module JSONSchemer::OpenAPI31::Meta; end
+
+# source://json_schemer//lib/json_schemer/openapi31/meta.rb#41
+JSONSchemer::OpenAPI31::Meta::BASE = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/openapi31/meta.rb#130
+JSONSchemer::OpenAPI31::Meta::SCHEMAS = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/openapi31/meta.rb#13
+JSONSchemer::OpenAPI31::SCHEMA = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#4
+module JSONSchemer::OpenAPI31::Vocab; end
+
+# https://spec.openapis.org/oas/latest.html#schema-object
+#
+# source://json_schemer//lib/json_schemer/openapi31/vocab.rb#6
+JSONSchemer::OpenAPI31::Vocab::BASE = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#5
+module JSONSchemer::OpenAPI31::Vocab::Base; end
+
+# source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#6
+class JSONSchemer::OpenAPI31::Vocab::Base::AllOf < ::JSONSchemer::Draft202012::Vocab::Applicator::AllOf
+  # Returns the value of attribute skip_ref_once.
+  #
+  # source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#7
+  def skip_ref_once; end
+
+  # Sets the attribute skip_ref_once
+  #
+  # @param value the value to set the attribute skip_ref_once to.
+  #
+  # source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#7
+  def skip_ref_once=(_arg0); end
+
+  # source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#9
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#24
+class JSONSchemer::OpenAPI31::Vocab::Base::AnyOf < ::JSONSchemer::Draft202012::Vocab::Applicator::AnyOf
+  # source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#25
+  def validate(*_arg0); end
+end
+
+# source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#36
+class JSONSchemer::OpenAPI31::Vocab::Base::Discriminator < ::JSONSchemer::Keyword
+  # source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#42
+  def error(formatted_instance_location:, **_arg1); end
+
+  # source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#46
+  def mapping; end
+
+  # Returns the value of attribute skip_ref_once.
+  #
+  # source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#40
+  def skip_ref_once; end
+
+  # Sets the attribute skip_ref_once
+  #
+  # @param value the value to set the attribute skip_ref_once to.
+  #
+  # source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#40
+  def skip_ref_once=(_arg0); end
+
+  # source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#50
+  def subschemas_by_property_value; end
+
+  # source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#102
+  def validate(instance, instance_location, keyword_location, context); end
+end
+
+# https://spec.openapis.org/oas/v3.1.0#components-object
+#
+# source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#38
+JSONSchemer::OpenAPI31::Vocab::Base::Discriminator::FIXED_FIELD_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#30
+class JSONSchemer::OpenAPI31::Vocab::Base::OneOf < ::JSONSchemer::Draft202012::Vocab::Applicator::OneOf
+  # source://json_schemer//lib/json_schemer/openapi31/vocab/base.rb#31
+  def validate(*_arg0); end
+end
+
+# source://json_schemer//lib/json_schemer/output.rb#3
+module JSONSchemer::Output
+  # Returns the value of attribute keyword.
+  #
+  # source://json_schemer//lib/json_schemer/output.rb#6
+  def keyword; end
+
+  # Returns the value of attribute schema.
+  #
+  # source://json_schemer//lib/json_schemer/output.rb#6
+  def schema; end
+
+  # source://json_schemer//lib/json_schemer/output.rb#8
+  def x_error; end
+
+  private
+
+  # :nocov:
+  #
+  # source://json_schemer//lib/json_schemer/output.rb#43
+  def deep_stringify_keys(obj); end
+
+  # source://json_schemer//lib/json_schemer/output.rb#19
+  def escaped_keyword; end
+
+  # source://json_schemer//lib/json_schemer/output.rb#27
+  def fragment_encode(location); end
+
+  # source://json_schemer//lib/json_schemer/output.rb#23
+  def join_location(location, keyword); end
+
+  # source://json_schemer//lib/json_schemer/output.rb#15
+  def result(instance, instance_location, keyword_location, valid, nested = T.unsafe(nil), type: T.unsafe(nil), annotation: T.unsafe(nil), details: T.unsafe(nil), ignore_nested: T.unsafe(nil)); end
+
+  # source://json_schemer//lib/json_schemer/output.rb#33
+  def stringify(key); end
+end
+
+# source://json_schemer//lib/json_schemer/output.rb#4
+JSONSchemer::Output::FRAGMENT_ENCODE_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer/result.rb#12
+class JSONSchemer::Result < ::Struct
+  # Returns the value of attribute annotation
+  #
+  # @return [Object] the current value of annotation
+  def annotation; end
+
+  # Sets the attribute annotation
+  #
+  # @param value [Object] the value to set the attribute annotation to.
+  # @return [Object] the newly set value
+  def annotation=(_); end
+
+  # source://json_schemer//lib/json_schemer/result.rb#126
+  def basic; end
+
+  # source://json_schemer//lib/json_schemer/result.rb#173
+  def classic; end
+
+  # source://json_schemer//lib/json_schemer/result.rb#147
+  def detailed; end
+
+  # Returns the value of attribute details
+  #
+  # @return [Object] the current value of details
+  def details; end
+
+  # Sets the attribute details
+  #
+  # @param value [Object] the value to set the attribute details to.
+  # @return [Object] the newly set value
+  def details=(_); end
+
+  # source://json_schemer//lib/json_schemer/result.rb#30
+  def error; end
+
+  # source://json_schemer//lib/json_schemer/result.rb#122
+  def flag; end
+
+  # source://json_schemer//lib/json_schemer/result.rb#62
+  def i18n!; end
+
+  # @return [Boolean]
+  #
+  # source://json_schemer//lib/json_schemer/result.rb#57
+  def i18n?; end
+
+  # Returns the value of attribute ignore_nested
+  #
+  # @return [Object] the current value of ignore_nested
+  def ignore_nested; end
+
+  # Sets the attribute ignore_nested
+  #
+  # @param value [Object] the value to set the attribute ignore_nested to.
+  # @return [Object] the newly set value
+  def ignore_nested=(_); end
+
+  # source://json_schemer//lib/json_schemer/result.rb#192
+  def insert_property_defaults(context); end
+
+  # Returns the value of attribute instance
+  #
+  # @return [Object] the current value of instance
+  def instance; end
+
+  # Sets the attribute instance
+  #
+  # @param value [Object] the value to set the attribute instance to.
+  # @return [Object] the newly set value
+  def instance=(_); end
+
+  # Returns the value of attribute instance_location
+  #
+  # @return [Object] the current value of instance_location
+  def instance_location; end
+
+  # Sets the attribute instance_location
+  #
+  # @param value [Object] the value to set the attribute instance_location to.
+  # @return [Object] the newly set value
+  def instance_location=(_); end
+
+  # Returns the value of attribute keyword_location
+  #
+  # @return [Object] the current value of keyword_location
+  def keyword_location; end
+
+  # Sets the attribute keyword_location
+  #
+  # @param value [Object] the value to set the attribute keyword_location to.
+  # @return [Object] the newly set value
+  def keyword_location=(_); end
+
+  # Returns the value of attribute nested
+  #
+  # @return [Object] the current value of nested
+  def nested; end
+
+  # Sets the attribute nested
+  #
+  # @param value [Object] the value to set the attribute nested to.
+  # @return [Object] the newly set value
+  def nested=(_); end
+
+  # Returns the value of attribute nested_key
+  #
+  # @return [Object] the current value of nested_key
+  def nested_key; end
+
+  # Sets the attribute nested_key
+  #
+  # @param value [Object] the value to set the attribute nested_key to.
+  # @return [Object] the newly set value
+  def nested_key=(_); end
+
+  # source://json_schemer//lib/json_schemer/result.rb#13
+  def output(output_format); end
+
+  # Returns the value of attribute source
+  #
+  # @return [Object] the current value of source
+  def source; end
+
+  # Sets the attribute source
+  #
+  # @param value [Object] the value to set the attribute source to.
+  # @return [Object] the newly set value
+  def source=(_); end
+
+  # source://json_schemer//lib/json_schemer/result.rb#105
+  def to_classic; end
+
+  # source://json_schemer//lib/json_schemer/result.rb#88
+  def to_output_unit; end
+
+  # Returns the value of attribute type
+  #
+  # @return [Object] the current value of type
+  def type; end
+
+  # Sets the attribute type
+  #
+  # @param value [Object] the value to set the attribute type to.
+  # @return [Object] the newly set value
+  def type=(_); end
+
+  # Returns the value of attribute valid
+  #
+  # @return [Object] the current value of valid
+  def valid; end
+
+  # Sets the attribute valid
+  #
+  # @param value [Object] the value to set the attribute valid to.
+  # @return [Object] the newly set value
+  def valid=(_); end
+
+  # source://json_schemer//lib/json_schemer/result.rb#163
+  def verbose; end
+
+  private
+
+  # source://json_schemer//lib/json_schemer/result.rb#232
+  def default_keyword_instance(schema); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://json_schemer//lib/json_schemer/schema.rb#3
+class JSONSchemer::Schema
+  include ::JSONSchemer::Output
+
+  # @return [Schema] a new instance of Schema
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#49
+  def initialize(value, parent = T.unsafe(nil), root = T.unsafe(nil), keyword = T.unsafe(nil), configuration: T.unsafe(nil), base_uri: T.unsafe(nil), meta_schema: T.unsafe(nil), vocabulary: T.unsafe(nil), format: T.unsafe(nil), formats: T.unsafe(nil), content_encodings: T.unsafe(nil), content_media_types: T.unsafe(nil), keywords: T.unsafe(nil), before_property_validation: T.unsafe(nil), after_property_validation: T.unsafe(nil), insert_property_defaults: T.unsafe(nil), property_default_resolver: T.unsafe(nil), ref_resolver: T.unsafe(nil), regexp_resolver: T.unsafe(nil), output_format: T.unsafe(nil), resolve_enumerators: T.unsafe(nil), access_mode: T.unsafe(nil)); end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#267
+  def absolute_keyword_location; end
+
+  # Returns the value of attribute after_property_validation.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#47
+  def after_property_validation; end
+
+  # Returns the value of attribute base_uri.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#45
+  def base_uri; end
+
+  # Sets the attribute base_uri
+  #
+  # @param value the value to set the attribute base_uri to.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#45
+  def base_uri=(_arg0); end
+
+  # Returns the value of attribute before_property_validation.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#47
+  def before_property_validation; end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#218
+  def bundle; end
+
+  # Returns the value of attribute configuration.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#46
+  def configuration; end
+
+  # Returns the value of attribute content_encodings.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#47
+  def content_encodings; end
+
+  # Returns the value of attribute content_media_types.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#47
+  def content_media_types; end
+
+  # Returns the value of attribute custom_keywords.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#47
+  def custom_keywords; end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#326
+  def defs_keyword; end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#334
+  def error(formatted_instance_location:, **options); end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#290
+  def error_key; end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#294
+  def fetch(key); end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#306
+  def fetch_content_encoding(content_encoding, *args, &block); end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#314
+  def fetch_content_media_type(content_media_type, *args, &block); end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#298
+  def fetch_format(format, *args, &block); end
+
+  # Returns the value of attribute format.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#47
+  def format; end
+
+  # Returns the value of attribute formats.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#47
+  def formats; end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#322
+  def id_keyword; end
+
+  # Returns the value of attribute insert_property_defaults.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#47
+  def insert_property_defaults; end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#357
+  def inspect; end
+
+  # Returns the value of attribute keyword_order.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#45
+  def keyword_order; end
+
+  # Sets the attribute keyword_order
+  #
+  # @param value the value to set the attribute keyword_order to.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#45
+  def keyword_order=(_arg0); end
+
+  # Returns the value of attribute keywords.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#45
+  def keywords; end
+
+  # Sets the attribute keywords
+  #
+  # @param value the value to set the attribute keywords to.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#45
+  def keywords=(_arg0); end
+
+  # Returns the value of attribute meta_schema.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#45
+  def meta_schema; end
+
+  # Sets the attribute meta_schema
+  #
+  # @param value the value to set the attribute meta_schema to.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#45
+  def meta_schema=(_arg0); end
+
+  # Returns the value of attribute parent.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#46
+  def parent; end
+
+  # Returns the value of attribute parsed.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#46
+  def parsed; end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#123
+  def ref(value); end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#342
+  def ref_resolver; end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#346
+  def regexp_resolver; end
+
+  # @raise [InvalidRefPointer]
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#170
+  def resolve_ref(uri); end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#214
+  def resolve_regexp(pattern); end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#330
+  def resources; end
+
+  # Returns the value of attribute root.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#46
+  def root; end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#280
+  def schema_pointer; end
+
+  # @return [Boolean]
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#99
+  def valid?(instance, **options); end
+
+  # @return [Boolean]
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#115
+  def valid_schema?(**options); end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#103
+  def validate(instance, output_format: T.unsafe(nil), resolve_enumerators: T.unsafe(nil), access_mode: T.unsafe(nil)); end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#127
+  def validate_instance(instance, instance_location, keyword_location, context); end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#119
+  def validate_schema(**options); end
+
+  # Returns the value of attribute value.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#46
+  def value; end
+
+  # Returns the value of attribute vocabulary.
+  #
+  # source://json_schemer//lib/json_schemer/schema.rb#47
+  def vocabulary; end
+
+  private
+
+  # source://json_schemer//lib/json_schemer/schema.rb#363
+  def parse; end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#409
+  def property_default_resolver; end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#413
+  def resolve_enumerators!(output); end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#405
+  def root_keyword_location; end
+end
+
+# source://json_schemer//lib/json_schemer/schema.rb#4
+class JSONSchemer::Schema::Context < ::Struct
+  # Returns the value of attribute access_mode
+  #
+  # @return [Object] the current value of access_mode
+  def access_mode; end
+
+  # Sets the attribute access_mode
+  #
+  # @param value [Object] the value to set the attribute access_mode to.
+  # @return [Object] the newly set value
+  def access_mode=(_); end
+
+  # Returns the value of attribute adjacent_results
+  #
+  # @return [Object] the current value of adjacent_results
+  def adjacent_results; end
+
+  # Sets the attribute adjacent_results
+  #
+  # @param value [Object] the value to set the attribute adjacent_results to.
+  # @return [Object] the newly set value
+  def adjacent_results=(_); end
+
+  # Returns the value of attribute dynamic_scope
+  #
+  # @return [Object] the current value of dynamic_scope
+  def dynamic_scope; end
+
+  # Sets the attribute dynamic_scope
+  #
+  # @param value [Object] the value to set the attribute dynamic_scope to.
+  # @return [Object] the newly set value
+  def dynamic_scope=(_); end
+
+  # Returns the value of attribute instance
+  #
+  # @return [Object] the current value of instance
+  def instance; end
+
+  # Sets the attribute instance
+  #
+  # @param value [Object] the value to set the attribute instance to.
+  # @return [Object] the newly set value
+  def instance=(_); end
+
+  # source://json_schemer//lib/json_schemer/schema.rb#5
+  def original_instance(instance_location); end
+
+  # Returns the value of attribute short_circuit
+  #
+  # @return [Object] the current value of short_circuit
+  def short_circuit; end
+
+  # Sets the attribute short_circuit
+  #
+  # @param value [Object] the value to set the attribute short_circuit to.
+  # @return [Object] the newly set value
+  def short_circuit=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://json_schemer//lib/json_schemer/schema.rb#31
+JSONSchemer::Schema::DEFAULT_PROPERTY_DEFAULT_RESOLVER = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/schema.rb#29
+JSONSchemer::Schema::ECMA_REGEXP_RESOLVER = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/schema.rb#22
+JSONSchemer::Schema::ID_KEYWORD_CLASS = JSONSchemer::Draft202012::Vocab::Core::Id
+
+# source://json_schemer//lib/json_schemer/schema.rb#27
+JSONSchemer::Schema::NET_HTTP_REF_RESOLVER = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/schema.rb#24
+JSONSchemer::Schema::NOT_KEYWORD_CLASS = JSONSchemer::Draft202012::Vocab::Applicator::Not
+
+# source://json_schemer//lib/json_schemer/schema.rb#25
+JSONSchemer::Schema::PROPERTIES_KEYWORD_CLASS = JSONSchemer::Draft202012::Vocab::Applicator::Properties
+
+# source://json_schemer//lib/json_schemer/schema.rb#28
+JSONSchemer::Schema::RUBY_REGEXP_RESOLVER = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/schema.rb#20
+JSONSchemer::Schema::SCHEMA_KEYWORD_CLASS = JSONSchemer::Draft202012::Vocab::Core::Schema
+
+# source://json_schemer//lib/json_schemer/schema.rb#41
+JSONSchemer::Schema::SYMBOL_PROPERTY_DEFAULT_RESOLVER = T.let(T.unsafe(nil), Proc)
+
+# source://json_schemer//lib/json_schemer/schema.rb#23
+JSONSchemer::Schema::UNKNOWN_KEYWORD_CLASS = JSONSchemer::Draft202012::Vocab::Core::UnknownKeyword
+
+# source://json_schemer//lib/json_schemer/schema.rb#21
+JSONSchemer::Schema::VOCABULARY_KEYWORD_CLASS = JSONSchemer::Draft202012::Vocab::Core::Vocabulary
+
+# source://json_schemer//lib/json_schemer.rb#69
+class JSONSchemer::UnknownContentEncoding < ::StandardError; end
+
+# source://json_schemer//lib/json_schemer.rb#70
+class JSONSchemer::UnknownContentMediaType < ::StandardError; end
+
+# source://json_schemer//lib/json_schemer.rb#67
+class JSONSchemer::UnknownFormat < ::StandardError; end
+
+# source://json_schemer//lib/json_schemer.rb#71
+class JSONSchemer::UnknownOutputFormat < ::StandardError; end
+
+# source://json_schemer//lib/json_schemer.rb#66
+class JSONSchemer::UnknownRef < ::StandardError; end
+
+# source://json_schemer//lib/json_schemer.rb#68
+class JSONSchemer::UnknownVocabulary < ::StandardError; end
+
+# source://json_schemer//lib/json_schemer.rb#65
+class JSONSchemer::UnsupportedOpenAPIVersion < ::StandardError; end
+
+# source://json_schemer//lib/json_schemer/version.rb#3
+JSONSchemer::VERSION = T.let(T.unsafe(nil), String)
+
+# source://json_schemer//lib/json_schemer.rb#78
+JSONSchemer::VOCABULARIES = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer.rb#102
+JSONSchemer::VOCABULARY_ORDER = T.let(T.unsafe(nil), Hash)
+
+# source://json_schemer//lib/json_schemer.rb#104
+JSONSchemer::WINDOWS_URI_PATH_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://json_schemer//lib/json_schemer/result.rb#7
+JSONSchemer::X_ERROR_REGEX = T.let(T.unsafe(nil), Regexp)
diff --git a/Library/Homebrew/sorbet/rbi/gems/kramdown@2.4.0.rbi b/Library/Homebrew/sorbet/rbi/gems/kramdown@2.4.0.rbi
new file mode 100644
index 0000000000000..9b2edd5252cb9
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/kramdown@2.4.0.rbi
@@ -0,0 +1,3271 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `kramdown` gem.
+# Please instead update this file by running `bin/tapioca gem kramdown`.
+
+# source://kramdown//lib/kramdown/version.rb#10
+module Kramdown
+  class << self
+    # Return the data directory for kramdown.
+    #
+    # source://kramdown//lib/kramdown/document.rb#49
+    def data_dir; end
+  end
+end
+
+# This module contains all available converters, i.e. classes that take a root Element and convert
+# it to a specific output format. The result is normally a string. For example, the
+# Converter::Html module converts an element tree into valid HTML.
+#
+# Converters use the Base class for common functionality (like applying a template to the output)
+# \- see its API documentation for how to create a custom converter class.
+#
+# source://kramdown//lib/kramdown/converter.rb#20
+module Kramdown::Converter
+  extend ::Kramdown::Utils::Configurable
+
+  class << self
+    # source://kramdown//lib/kramdown/utils/configurable.rb#37
+    def add_math_engine(data, *args, &block); end
+
+    # source://kramdown//lib/kramdown/utils/configurable.rb#37
+    def add_syntax_highlighter(data, *args, &block); end
+
+    # source://kramdown//lib/kramdown/utils/configurable.rb#30
+    def configurables; end
+
+    # source://kramdown//lib/kramdown/utils/configurable.rb#34
+    def math_engine(data); end
+
+    # source://kramdown//lib/kramdown/utils/configurable.rb#34
+    def syntax_highlighter(data); end
+  end
+end
+
+# == \Base class for converters
+#
+# This class serves as base class for all converters. It provides methods that can/should be
+# used by all converters (like #generate_id) as well as common functionality that is
+# automatically applied to the result (for example, embedding the output into a template).
+#
+# A converter object is used as a throw-away object, i.e. it is only used for storing the needed
+# state information during conversion. Therefore one can't instantiate a converter object
+# directly but only use the Base::convert method.
+#
+# == Implementing a converter
+#
+# Implementing a new converter is rather easy: just derive a new class from this class and put
+# it in the Kramdown::Converter module (the latter is only needed if auto-detection should work
+# properly). Then you need to implement the #convert method which has to contain the conversion
+# code for converting an element and has to return the conversion result.
+#
+# The actual transformation of the document tree can be done in any way. However, writing one
+# method per element type is a straight forward way to do it - this is how the Html and Latex
+# converters do the transformation.
+#
+# Have a look at the Base::convert method for additional information!
+#
+# source://kramdown//lib/kramdown/converter/base.rb#40
+class Kramdown::Converter::Base
+  # Initialize the converter with the given +root+ element and +options+ hash.
+  #
+  # @return [Base] a new instance of Base
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#55
+  def initialize(root, options); end
+
+  # Returns whether the template should be applied after the conversion of the tree.
+  #
+  # Defaults to true.
+  #
+  # @return [Boolean]
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#73
+  def apply_template_after?; end
+
+  # Returns whether the template should be applied before the conversion of the tree.
+  #
+  # Defaults to false.
+  #
+  # @return [Boolean]
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#66
+  def apply_template_before?; end
+
+  # The basic version of the ID generator, without any special provisions for empty or unique
+  # IDs.
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#237
+  def basic_generate_id(str); end
+
+  # Convert the element +el+ and return the resulting object.
+  #
+  # This is the only method that has to be implemented by sub-classes!
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#122
+  def convert(_el); end
+
+  # Can be used by a converter for storing arbitrary information during the conversion process.
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#43
+  def data; end
+
+  # Extract the code block/span language from the attributes.
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#174
+  def extract_code_language(attr); end
+
+  # See #extract_code_language
+  #
+  # *Warning*: This version will modify the given attributes if a language is present.
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#183
+  def extract_code_language!(attr); end
+
+  # Format the given math element with the math engine configured through the option
+  # 'math_engine'.
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#206
+  def format_math(el, opts = T.unsafe(nil)); end
+
+  # Generate an unique alpha-numeric ID from the the string +str+ for use as a header ID.
+  #
+  # Uses the option +auto_id_prefix+: the value of this option is prepended to every generated
+  # ID.
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#222
+  def generate_id(str); end
+
+  # Highlight the given +text+ in the language +lang+ with the syntax highlighter configured
+  # through the option 'syntax_highlighter'.
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#192
+  def highlight_code(text, lang, type, opts = T.unsafe(nil)); end
+
+  # Return +true+ if the header element +el+ should be used for the table of contents (as
+  # specified by the +toc_levels+ option).
+  #
+  # @return [Boolean]
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#162
+  def in_toc?(el); end
+
+  # The hash with the conversion options.
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#46
+  def options; end
+
+  # Return the output header level given a level.
+  #
+  # Uses the +header_offset+ option for adjusting the header level.
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#169
+  def output_header_level(level); end
+
+  # The root element that is converted.
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#49
+  def root; end
+
+  # Return the entity that represents the given smart_quote element.
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#248
+  def smart_quote_entity(el); end
+
+  # Add the given warning +text+ to the warning array.
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#156
+  def warning(text); end
+
+  # The warnings array.
+  #
+  # source://kramdown//lib/kramdown/converter/base.rb#52
+  def warnings; end
+
+  class << self
+    # Apply the +template+ using +body+ as the body string.
+    #
+    # The template is evaluated using ERB and the body is available in the @body instance variable
+    # and the converter object in the @converter instance variable.
+    #
+    # source://kramdown//lib/kramdown/converter/base.rb#130
+    def apply_template(converter, body); end
+
+    # Convert the element tree +tree+ and return the resulting conversion object (normally a
+    # string) and an array with warning messages. The parameter +options+ specifies the conversion
+    # options that should be used.
+    #
+    # Initializes a new instance of the calling class and then calls the #convert method with
+    # +tree+ as parameter.
+    #
+    # If the +template+ option is specified and non-empty, the template is evaluate with ERB
+    # before and/or after the tree conversion depending on the result of #apply_template_before?
+    # and #apply_template_after?. If the template is evaluated before, an empty string is used for
+    # the body; if evaluated after, the result is used as body. See ::apply_template.
+    #
+    # The template resolution is done in the following way (for the converter ConverterName):
+    #
+    # 1. Look in the current working directory for the template.
+    #
+    # 2. Append +.converter_name+ (e.g. +.html+) to the template name and look for the resulting
+    #    file in the current working directory (the form +.convertername+ is deprecated).
+    #
+    # 3. Append +.converter_name+ to the template name and look for it in the kramdown data
+    #    directory (the form +.convertername+ is deprecated).
+    #
+    # 4. Check if the template name starts with 'string://' and if so, strip this prefix away and
+    #    use the rest as template.
+    #
+    # source://kramdown//lib/kramdown/converter/base.rb#101
+    def convert(tree, options = T.unsafe(nil)); end
+
+    # Return the template specified by +template+.
+    #
+    # source://kramdown//lib/kramdown/converter/base.rb#139
+    def get_template(template); end
+
+    private
+
+    def allocate; end
+    def new(*_arg0); end
+  end
+end
+
+# source://kramdown//lib/kramdown/converter/base.rb#245
+Kramdown::Converter::Base::SMART_QUOTE_INDICES = T.let(T.unsafe(nil), Hash)
+
+# Converts a Kramdown::Document to a nested hash for further processing or debug output.
+#
+# source://kramdown//lib/kramdown/converter/hash_ast.rb#19
+class Kramdown::Converter::HashAST < ::Kramdown::Converter::Base
+  # source://kramdown//lib/kramdown/converter/hash_ast.rb#21
+  def convert(el); end
+end
+
+# source://kramdown//lib/kramdown/converter/hash_ast.rb#35
+Kramdown::Converter::HashAst = Kramdown::Converter::HashAST
+
+# Converts a Kramdown::Document to HTML.
+#
+# You can customize the HTML converter by sub-classing it and overriding the +convert_NAME+
+# methods. Each such method takes the following parameters:
+#
+# [+el+] The element of type +NAME+ to be converted.
+#
+# [+indent+] A number representing the current amount of spaces for indent (only used for
+#            block-level elements).
+#
+# The return value of such a method has to be a string containing the element +el+ formatted as
+# HTML element.
+#
+# source://kramdown//lib/kramdown/converter/html.rb#30
+class Kramdown::Converter::Html < ::Kramdown::Converter::Base
+  include ::Kramdown::Utils::Html
+  include ::Kramdown::Parser::Html::Constants
+
+  # Initialize the HTML converter with the given Kramdown document +doc+.
+  #
+  # @return [Html] a new instance of Html
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#39
+  def initialize(root, options); end
+
+  # Add the syntax highlighter name to the 'class' attribute of the given attribute hash. And
+  # overwrites or add a "language-LANG" part using the +lang+ parameter if +lang+ is not nil.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#409
+  def add_syntax_highlighter_to_class_attr(attr, lang = T.unsafe(nil)); end
+
+  # Dispatch the conversion of the element +el+ to a +convert_TYPE+ method using the +type+ of
+  # the element.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#57
+  def convert(el, indent = T.unsafe(nil)); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#272
+  def convert_a(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#365
+  def convert_abbreviation(el, _indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#77
+  def convert_blank(_el, _indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#141
+  def convert_blockquote(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#268
+  def convert_br(_el, _indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#111
+  def convert_codeblock(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#280
+  def convert_codespan(el, _indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#260
+  def convert_comment(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#178
+  def convert_dd(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#174
+  def convert_dl(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#190
+  def convert_dt(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#319
+  def convert_em(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#324
+  def convert_entity(el, _indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#294
+  def convert_footnote(el, _indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#145
+  def convert_header(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#155
+  def convert_hr(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#201
+  def convert_html_element(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#276
+  def convert_img(el, _indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#178
+  def convert_li(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#351
+  def convert_math(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#162
+  def convert_ol(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#86
+  def convert_p(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#311
+  def convert_raw(el, _indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#372
+  def convert_root(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#347
+  def convert_smart_quote(el, _indent); end
+
+  # Helper method used by +convert_p+ to convert a paragraph that only contains a single :img
+  # element.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#99
+  def convert_standalone_image(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#319
+  def convert_strong(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#238
+  def convert_table(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#238
+  def convert_tbody(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#248
+  def convert_td(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#81
+  def convert_text(el, _indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#238
+  def convert_tfoot(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#238
+  def convert_thead(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#238
+  def convert_tr(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#339
+  def convert_typographic_sym(el, _indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#162
+  def convert_ul(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#228
+  def convert_xml_comment(el, indent); end
+
+  # source://kramdown//lib/kramdown/converter/html.rb#228
+  def convert_xml_pi(el, indent); end
+
+  # Fixes the elements for use in a TOC entry.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#453
+  def fix_for_toc_entry(elements); end
+
+  # Return an HTML ordered list with the footnote content for the used footnotes.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#488
+  def footnote_content; end
+
+  # Format the given element as block HTML.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#397
+  def format_as_block_html(name, attr, body, indent); end
+
+  # Format the given element as block HTML with a newline after the start tag and indentation
+  # before the end tag.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#403
+  def format_as_indented_block_html(name, attr, body, indent); end
+
+  # Format the given element as span HTML.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#392
+  def format_as_span_html(name, attr, body); end
+
+  # Generate and return an element tree for the table of contents.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#415
+  def generate_toc_tree(toc, type, attr); end
+
+  # The amount of indentation used when nesting HTML tags.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#36
+  def indent; end
+
+  # The amount of indentation used when nesting HTML tags.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#36
+  def indent=(_arg0); end
+
+  # Return the converted content of the children of +el+ as a string. The parameter +indent+ has
+  # to be the amount of indentation used for the element +el+.
+  #
+  # Pushes +el+ onto the @stack before converting the child elements and pops it from the stack
+  # afterwards.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#66
+  def inner(el, indent); end
+
+  # Obfuscate the +text+ by using HTML entities.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#476
+  def obfuscate(text); end
+
+  # Remove all footnotes from the given elements.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#468
+  def remove_footnotes(elements); end
+
+  # Remove all link elements by unwrapping them.
+  #
+  # source://kramdown//lib/kramdown/converter/html.rb#460
+  def unwrap_links(elements); end
+end
+
+# source://kramdown//lib/kramdown/converter/html.rb#246
+Kramdown::Converter::Html::ENTITY_NBSP = T.let(T.unsafe(nil), Kramdown::Utils::Entities::Entity)
+
+# source://kramdown//lib/kramdown/converter/html.rb#485
+Kramdown::Converter::Html::FOOTNOTE_BACKLINK_FMT = T.let(T.unsafe(nil), String)
+
+# source://kramdown//lib/kramdown/converter/html.rb#328
+Kramdown::Converter::Html::TYPOGRAPHIC_SYMS = T.let(T.unsafe(nil), Hash)
+
+# source://kramdown//lib/kramdown/converter/html.rb#159
+Kramdown::Converter::Html::ZERO_TO_ONETWENTYEIGHT = T.let(T.unsafe(nil), Array)
+
+# Converts an element tree to the kramdown format.
+#
+# source://kramdown//lib/kramdown/converter/kramdown.rb#18
+class Kramdown::Converter::Kramdown < ::Kramdown::Converter::Base
+  include ::Kramdown::Utils::Html
+
+  # @return [Kramdown] a new instance of Kramdown
+  #
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#24
+  def initialize(root, options); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#34
+  def convert(el, opts = T.unsafe(nil)); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#291
+  def convert_a(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#377
+  def convert_abbreviation(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#70
+  def convert_blank(_el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#107
+  def convert_blockquote(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#287
+  def convert_br(_el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#103
+  def convert_codeblock(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#324
+  def convert_codespan(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#279
+  def convert_comment(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#158
+  def convert_dd(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#124
+  def convert_dl(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#182
+  def convert_dt(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#346
+  def convert_em(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#356
+  def convert_entity(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#329
+  def convert_footnote(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#112
+  def convert_header(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#120
+  def convert_hr(_el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#195
+  def convert_html_element(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#308
+  def convert_img(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#130
+  def convert_li(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#373
+  def convert_math(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#124
+  def convert_ol(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#88
+  def convert_p(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#334
+  def convert_raw(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#381
+  def convert_root(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#369
+  def convert_smart_quote(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#351
+  def convert_strong(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#239
+  def convert_table(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#260
+  def convert_tbody(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#275
+  def convert_td(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#76
+  def convert_text(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#267
+  def convert_tfoot(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#244
+  def convert_thead(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#271
+  def convert_tr(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#365
+  def convert_typographic_sym(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#124
+  def convert_ul(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#229
+  def convert_xml_comment(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#229
+  def convert_xml_pi(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#408
+  def create_abbrev_defs; end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#399
+  def create_footnote_defs; end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#389
+  def create_link_defs; end
+
+  # Return the IAL containing the attributes of the element +el+.
+  #
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#419
+  def ial_for_element(el); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#54
+  def inner(el, opts = T.unsafe(nil)); end
+
+  # source://kramdown//lib/kramdown/converter/kramdown.rb#444
+  def parse_title(attr); end
+end
+
+# source://kramdown//lib/kramdown/converter/kramdown.rb#74
+Kramdown::Converter::Kramdown::ESCAPED_CHAR_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/converter/kramdown.rb#192
+Kramdown::Converter::Kramdown::HTML_ELEMENT_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/converter/kramdown.rb#190
+Kramdown::Converter::Kramdown::HTML_TAGS_WITH_BODY = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/converter/kramdown.rb#360
+Kramdown::Converter::Kramdown::TYPOGRAPHIC_SYMS = T.let(T.unsafe(nil), Hash)
+
+# Converts an element tree to LaTeX.
+#
+# This converter uses ideas from other Markdown-to-LaTeX converters like Pandoc and Maruku.
+#
+# You can customize this converter by sub-classing it and overriding the +convert_NAME+ methods.
+# Each such method takes the following parameters:
+#
+# [+el+] The element of type +NAME+ to be converted.
+#
+# [+opts+] A hash containing processing options that are passed down from parent elements. The
+#          key :parent is always set and contains the parent element as value.
+#
+# The return value of such a method has to be a string containing the element +el+ formatted
+# correctly as LaTeX markup.
+#
+# source://kramdown//lib/kramdown/converter/latex.rb#31
+class Kramdown::Converter::Latex < ::Kramdown::Converter::Base
+  # Initialize the LaTeX converter with the +root+ element and the conversion +options+.
+  #
+  # @return [Latex] a new instance of Latex
+  #
+  # source://kramdown//lib/kramdown/converter/latex.rb#34
+  def initialize(root, options); end
+
+  # Return a LaTeX comment containing all attributes as 'key="value"' pairs.
+  #
+  # source://kramdown//lib/kramdown/converter/latex.rb#599
+  def attribute_list(el); end
+
+  # Dispatch the conversion of the element +el+ to a +convert_TYPE+ method using the +type+ of
+  # the element.
+  #
+  # source://kramdown//lib/kramdown/converter/latex.rb#41
+  def convert(el, opts = T.unsafe(nil)); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#216
+  def convert_a(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#569
+  def convert_abbreviation(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#61
+  def convert_blank(_el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#110
+  def convert_blockquote(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#209
+  def convert_br(_el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#87
+  def convert_codeblock(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#239
+  def convert_codespan(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#205
+  def convert_comment(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#151
+  def convert_dd(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#139
+  def convert_dl(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#147
+  def convert_dt(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#263
+  def convert_em(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#533
+  def convert_entity(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#250
+  def convert_footnote(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#114
+  def convert_header(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#124
+  def convert_hr(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#155
+  def convert_html_element(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#225
+  def convert_img(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#143
+  def convert_li(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#556
+  def convert_math(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#129
+  def convert_ol(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#69
+  def convert_p(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#255
+  def convert_raw(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#57
+  def convert_root(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#550
+  def convert_smart_quote(el, opts); end
+
+  # Helper method used by +convert_p+ to convert a paragraph that only contains a single :img
+  # element.
+  #
+  # source://kramdown//lib/kramdown/converter/latex.rb#80
+  def convert_standalone_image(el, _opts, img); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#267
+  def convert_strong(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#177
+  def convert_table(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#189
+  def convert_tbody(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#201
+  def convert_td(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#65
+  def convert_text(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#193
+  def convert_tfoot(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#185
+  def convert_thead(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#197
+  def convert_tr(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#542
+  def convert_typographic_sym(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#129
+  def convert_ul(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#166
+  def convert_xml_comment(el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#170
+  def convert_xml_pi(_el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/latex.rb#522
+  def entity_to_latex(entity); end
+
+  # Escape the special LaTeX characters in the string +str+.
+  #
+  # source://kramdown//lib/kramdown/converter/latex.rb#618
+  def escape(str); end
+
+  # Return the converted content of the children of +el+ as a string.
+  #
+  # source://kramdown//lib/kramdown/converter/latex.rb#46
+  def inner(el, opts); end
+
+  # Wrap the +text+ inside a LaTeX environment of type +type+. The element +el+ is passed on to
+  # the method #attribute_list -- the resulting string is appended to both the \\begin and the
+  # \\end lines of the LaTeX environment for easier post-processing of LaTeX environments.
+  #
+  # source://kramdown//lib/kramdown/converter/latex.rb#582
+  def latex_environment(type, el, text); end
+
+  # Return a string containing a valid \hypertarget command if the element has an ID defined, or
+  # +nil+ otherwise. If the parameter +add_label+ is +true+, a \label command will also be used
+  # additionally to the \hypertarget command.
+  #
+  # source://kramdown//lib/kramdown/converter/latex.rb#590
+  def latex_link_target(el, add_label = T.unsafe(nil)); end
+
+  # Normalize the abbreviation key so that it only contains allowed ASCII character
+  #
+  # source://kramdown//lib/kramdown/converter/latex.rb#575
+  def normalize_abbreviation_key(key); end
+end
+
+# Inspired by Maruku: entity conversion table based on the one from htmltolatex
+# (http://sourceforge.net/projects/htmltolatex/), with some small adjustments/additions
+#
+# source://kramdown//lib/kramdown/converter/latex.rb#273
+Kramdown::Converter::Latex::ENTITY_CONV_TABLE = T.let(T.unsafe(nil), Hash)
+
+# source://kramdown//lib/kramdown/converter/latex.rb#605
+Kramdown::Converter::Latex::ESCAPE_MAP = T.let(T.unsafe(nil), Hash)
+
+# source://kramdown//lib/kramdown/converter/latex.rb#615
+Kramdown::Converter::Latex::ESCAPE_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/converter/latex.rb#175
+Kramdown::Converter::Latex::TABLE_ALIGNMENT_CHAR = T.let(T.unsafe(nil), Hash)
+
+# source://kramdown//lib/kramdown/converter/latex.rb#537
+Kramdown::Converter::Latex::TYPOGRAPHIC_SYMS = T.let(T.unsafe(nil), Hash)
+
+# Converts a Kramdown::Document to a manpage in groff format. See man(7), groff_man(7) and
+# man-pages(7) for information regarding the output.
+#
+# source://kramdown//lib/kramdown/converter/man.rb#18
+class Kramdown::Converter::Man < ::Kramdown::Converter::Base
+  # source://kramdown//lib/kramdown/converter/man.rb#20
+  def convert(el, opts = T.unsafe(nil)); end
+
+  private
+
+  # source://kramdown//lib/kramdown/converter/man.rb#191
+  def convert_a(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#229
+  def convert_abbreviation(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#47
+  def convert_blank(*_arg0); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#95
+  def convert_blockquote(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#225
+  def convert_br(_el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#89
+  def convert_codeblock(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#221
+  def convert_codespan(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#186
+  def convert_comment(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#127
+  def convert_dd(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#101
+  def convert_dl(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#121
+  def convert_dt(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#209
+  def convert_em(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#255
+  def convert_entity(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#241
+  def convert_footnote(*_arg0); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#61
+  def convert_header(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#47
+  def convert_hr(*_arg0); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#182
+  def convert_html_element(*_arg0); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#205
+  def convert_img(_el, _opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#110
+  def convert_li(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#233
+  def convert_math(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#101
+  def convert_ol(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#52
+  def convert_p(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#245
+  def convert_raw(*_arg0); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#40
+  def convert_root(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#259
+  def convert_smart_quote(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#215
+  def convert_strong(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#139
+  def convert_table(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#154
+  def convert_tbody(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#170
+  def convert_td(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#249
+  def convert_text(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#161
+  def convert_tfoot(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#148
+  def convert_thead(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#165
+  def convert_tr(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#268
+  def convert_typographic_sym(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#101
+  def convert_ul(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#186
+  def convert_xml_comment(el, opts); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#47
+  def convert_xml_pi(*_arg0); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#285
+  def escape(text, preserve_whitespace = T.unsafe(nil)); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#26
+  def inner(el, opts, use = T.unsafe(nil)); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#272
+  def macro(name, *args); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#276
+  def newline(text); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#281
+  def quote(text); end
+
+  # source://kramdown//lib/kramdown/converter/man.rb#293
+  def unicode_char(codepoint); end
+end
+
+# source://kramdown//lib/kramdown/converter/man.rb#137
+Kramdown::Converter::Man::TABLE_CELL_ALIGNMENT = T.let(T.unsafe(nil), Hash)
+
+# source://kramdown//lib/kramdown/converter/man.rb#263
+Kramdown::Converter::Man::TYPOGRAPHIC_SYMS_MAP = T.let(T.unsafe(nil), Hash)
+
+# Removes all block (and optionally span) level HTML tags from the element tree.
+#
+# This converter can be used on parsed HTML documents to get an element tree that will only
+# contain native kramdown elements.
+#
+# *Note* that the returned element tree may not be fully conformant (i.e. the content models of
+# *some elements may be violated)!
+#
+# This converter modifies the given tree in-place and returns it.
+#
+# source://kramdown//lib/kramdown/converter/remove_html_tags.rb#25
+class Kramdown::Converter::RemoveHtmlTags < ::Kramdown::Converter::Base
+  # @return [RemoveHtmlTags] a new instance of RemoveHtmlTags
+  #
+  # source://kramdown//lib/kramdown/converter/remove_html_tags.rb#27
+  def initialize(root, options); end
+
+  # source://kramdown//lib/kramdown/converter/remove_html_tags.rb#32
+  def convert(el); end
+end
+
+# Converts a Kramdown::Document to an element tree that represents the table of contents.
+#
+# The returned tree consists of Element objects of type :toc where the root element is just used
+# as container object. Each :toc element contains as value the wrapped :header element and under
+# the attribute key :id the header ID that should be used (note that this ID may not exist in
+# the wrapped element).
+#
+# Since the TOC tree consists of special :toc elements, one cannot directly feed this tree to
+# other converters!
+#
+# source://kramdown//lib/kramdown/converter/toc.rb#25
+class Kramdown::Converter::Toc < ::Kramdown::Converter::Base
+  # @return [Toc] a new instance of Toc
+  #
+  # source://kramdown//lib/kramdown/converter/toc.rb#27
+  def initialize(root, options); end
+
+  # source://kramdown//lib/kramdown/converter/toc.rb#34
+  def convert(el); end
+
+  private
+
+  # source://kramdown//lib/kramdown/converter/toc.rb#47
+  def add_to_toc(el, id); end
+end
+
+# The main interface to kramdown.
+#
+# This class provides a one-stop-shop for using kramdown to convert text into various output
+# formats. Use it like this:
+#
+#   require 'kramdown'
+#   doc = Kramdown::Document.new('This *is* some kramdown text')
+#   puts doc.to_html
+#
+# The #to_html method is a shortcut for using the Converter::Html class. See #method_missing for
+# more information.
+#
+# The second argument to the ::new method is an options hash for customizing the behaviour of the
+# used parser and the converter. See ::new for more information!
+#
+# source://kramdown//lib/kramdown/document.rb#73
+class Kramdown::Document
+  # Create a new Kramdown document from the string +source+ and use the provided +options+. The
+  # options that can be used are defined in the Options module.
+  #
+  # The special options key :input can be used to select the parser that should parse the
+  # +source+. It has to be the name of a class in the Kramdown::Parser module. For example, to
+  # select the kramdown parser, one would set the :input key to +Kramdown+. If this key is not
+  # set, it defaults to +Kramdown+.
+  #
+  # The +source+ is immediately parsed by the selected parser so that the root element is
+  # immediately available and the output can be generated.
+  #
+  # @return [Document] a new instance of Document
+  #
+  # source://kramdown//lib/kramdown/document.rb#96
+  def initialize(source, options = T.unsafe(nil)); end
+
+  # source://kramdown//lib/kramdown/document.rb#124
+  def inspect; end
+
+  # Check if a method is invoked that begins with +to_+ and if so, try to instantiate a converter
+  # class (i.e. a class in the Kramdown::Converter module) and use it for converting the document.
+  #
+  # For example, +to_html+ would instantiate the Kramdown::Converter::Html class.
+  #
+  # source://kramdown//lib/kramdown/document.rb#113
+  def method_missing(id, *attr, &block); end
+
+  # The options hash which holds the options for parsing/converting the Kramdown document.
+  #
+  # source://kramdown//lib/kramdown/document.rb#80
+  def options; end
+
+  # The root Element of the element tree. It is immediately available after the ::new method has
+  # been called.
+  #
+  # source://kramdown//lib/kramdown/document.rb#77
+  def root; end
+
+  # The root Element of the element tree. It is immediately available after the ::new method has
+  # been called.
+  #
+  # source://kramdown//lib/kramdown/document.rb#77
+  def root=(_arg0); end
+
+  # An array of warning messages. It is filled with warnings during the parsing phase (i.e. in
+  # ::new) and the conversion phase.
+  #
+  # source://kramdown//lib/kramdown/document.rb#84
+  def warnings; end
+
+  protected
+
+  # Try requiring a parser or converter class and don't raise an error if the file is not found.
+  #
+  # source://kramdown//lib/kramdown/document.rb#129
+  def try_require(type, name); end
+end
+
+# Represents all elements in the element tree.
+#
+# kramdown only uses this one class for representing all available elements in an element tree
+# (paragraphs, headers, emphasis, ...). The type of element can be set via the #type accessor.
+#
+# The root of a kramdown element tree has to be an element of type :root. It needs to have certain
+# option keys set so that conversions work correctly. If only a part of a tree should be
+# converted, duplicate the root node and assign the #children appropriately, e.g:
+#
+#   root = doc.root
+#   new_root = root.dup
+#   new_root.children = [root.children[0]]  # assign new array with elements to convert
+#
+# Following is a description of all supported element types.
+#
+# Note that the option :location may contain the start line number of an element in the source
+# document.
+#
+# == Structural Elements
+#
+# === :root
+#
+# [Category] None
+# [Usage context] As the root element of a document
+# [Content model] Block-level elements
+#
+# Represents the root of a kramdown document.
+#
+# The root element contains the following option keys:
+#
+#             parts of the kramdown document.
+#
+# :abbrev_defs:: This key may be used to store the mapping of abbreviation to abbreviation
+#                definition.
+#
+# :abbrev_attr:: This key may be used to store the mapping of abbreviation to abbreviation
+#                attributes.
+#
+# :options:: This key may be used to store options that were set during parsing of the document.
+#
+# :footnote_count:: This key stores the number of actually referenced footnotes of the document.
+#
+# === :blank
+#
+# [Category] Block-level element
+# [Usage context] Where block-level elements are expected
+# [Content model] Empty
+#
+# Represents one or more blank lines. It is not allowed to have two or more consecutive blank
+# elements.
+#
+# The +value+ field may contain the original content of the blank lines.
+#
+#
+# === :p
+#
+# [Category] Block-level element
+# [Usage context] Where block-level elements are expected
+# [Content model] Span-level elements
+#
+# Represents a paragraph.
+#
+# If the option :transparent is +true+, this element just represents a block of text. I.e. this
+# element just functions as a container for span-level elements.
+#
+#
+# === :header
+#
+# [Category] Block-level element
+# [Usage context] Where block-level elements are expected
+# [Content model] Span-level elements
+#
+# Represents a header.
+#
+# The option :level specifies the header level and has to contain a number between 1 and \6. The
+# option :raw_text has to contain the raw header text.
+#
+#
+# === :blockquote
+#
+# [Category] Block-level element
+# [Usage context] Where block-level elements are expected
+# [Content model] Block-level elements
+#
+# Represents a blockquote.
+#
+#
+# === :codeblock
+#
+# [Category] Block-level element
+# [Usage context] Where block-level elements are expected
+# [Content model] Empty
+#
+# Represents a code block, i.e. a block of text that should be used as-is.
+#
+# The +value+ field has to contain the content of the code block.
+#
+# The option :lang specifies a highlighting language with possible HTML style options (e.g.
+# php?start_inline=1) and should be used instead of a possibly also available language embedded in
+# a class name of the form 'language-LANG'.
+#
+#
+# === :ul
+#
+# [Category] Block-level element
+# [Usage context] Where block-level elements are expected
+# [Content model] One or more :li elements
+#
+# Represents an unordered list.
+#
+#
+# === :ol
+#
+# [Category] Block-level element
+# [Usage context] Where block-level elements are expected
+# [Content model] One or more :li elements
+#
+# Represents an ordered list.
+#
+#
+# === :li
+#
+# [Category] Block-level element
+# [Usage context] Inside :ol and :ul elements
+# [Content model] Block-level elements
+#
+# Represents a list item of an ordered or unordered list.
+#
+# Note that the first child of a list item must not be a :blank element!
+#
+#
+# === :dl
+#
+# [Category] Block-level element
+# [Usage context] Where block-level elements are expected
+# [Content model] One or more groups each consisting of one or more :dt elements followed by one
+#                 or more :dd elements.
+#
+# Represents a definition list which contains groups consisting of terms and definitions for them.
+#
+#
+# === :dt
+#
+# [Category] Block-level element
+# [Usage context] Before :dt or :dd elements inside a :dl elment
+# [Content model] Span-level elements
+#
+# Represents the term part of a term-definition group in a definition list.
+#
+#
+# === :dd
+#
+# [Category] Block-level element
+# [Usage context] After :dt or :dd elements inside a :dl elment
+# [Content model] Block-level elements
+#
+# Represents the definition part of a term-definition group in a definition list.
+#
+#
+# === :hr
+#
+# [Category] Block-level element
+# [Usage context] Where block-level elements are expected
+# [Content model] None
+#
+# Represents a horizontal line.
+#
+#
+# === :table
+#
+# [Category] Block-level element
+# [Usage context] Where block-level elements are expected
+# [Content model] Zero or one :thead elements, one or more :tbody elements, zero or one :tfoot
+#                 elements
+#
+# Represents a table. Each table row (i.e. :tr element) of the table has to contain the same
+# number of :td elements.
+#
+# The option :alignment has to be an array containing the alignment values, exactly one for each
+# column of the table. The possible alignment values are :left, :center, :right and :default.
+#
+#
+# === :thead
+#
+# [Category] None
+# [Usage context] As first element inside a :table element
+# [Content model] One or more :tr elements
+#
+# Represents the table header.
+#
+#
+# === :tbody
+#
+# [Category] None
+# [Usage context] After a :thead element but before a :tfoot element inside a :table element
+# [Content model] One or more :tr elements
+#
+# Represents a table body.
+#
+#
+# === :tfoot
+#
+# [Category] None
+# [Usage context] As last element inside a :table element
+# [Content model] One or more :tr elements
+#
+# Represents the table footer.
+#
+#
+# === :tr
+#
+# [Category] None
+# [Usage context] Inside :thead, :tbody and :tfoot elements
+# [Content model] One or more :td elements
+#
+# Represents a table row.
+#
+#
+# === :td
+#
+# [Category] Block-level element
+# [Usage context] Inside :tr elements
+# [Content model] As child of :thead/:tr span-level elements, as child of :tbody/:tr and
+#                 :tfoot/:tr block-level elements
+#
+# Represents a table cell.
+#
+#
+# === :math
+#
+# [Category] Block/span-level element
+# [Usage context] Where block/span-level elements are expected
+# [Content model] None
+#
+# Represents mathematical text that is written in LaTeX.
+#
+# The +value+ field has to contain the actual mathematical text.
+#
+# The option :category has to be set to either :span or :block depending on the context where the
+# element is used.
+#
+#
+# == Text Markup Elements
+#
+# === :text
+#
+# [Category] Span-level element
+# [Usage context] Where span-level elements are expected
+# [Content model] None
+#
+# Represents text.
+#
+# The +value+ field has to contain the text itself.
+#
+#
+# === :br
+#
+# [Category] Span-level element
+# [Usage context] Where span-level elements are expected
+# [Content model] None
+#
+# Represents a hard line break.
+#
+#
+# === :a
+#
+# [Category] Span-level element
+# [Usage context] Where span-level elements are expected
+# [Content model] Span-level elements
+#
+# Represents a link to an URL.
+#
+# The attribute +href+ has to be set to the URL to which the link points. The attribute +title+
+# optionally contains the title of the link.
+#
+#
+# === :img
+#
+# [Category] Span-level element
+# [Usage context] Where span-level elements are expected
+# [Content model] None
+#
+# Represents an image.
+#
+# The attribute +src+ has to be set to the URL of the image. The attribute +alt+ has to contain a
+# text description of the image. The attribute +title+ optionally contains the title of the image.
+#
+#
+# === :codespan
+#
+# [Category] Span-level element
+# [Usage context] Where span-level elements are expected
+# [Content model] None
+#
+# Represents verbatim text.
+#
+# The +value+ field has to contain the content of the code span.
+#
+#
+# === :footnote
+#
+# [Category] Span-level element
+# [Usage context] Where span-level elements are expected
+# [Content model] None
+#
+# Represents a footnote marker.
+#
+# The +value+ field has to contain an element whose children are the content of the footnote. The
+# option :name has to contain a valid and unique footnote name. A valid footnote name consists of
+# a word character or a digit and then optionally followed by other word characters, digits or
+# dashes.
+#
+#
+# === :em
+#
+# [Category] Span-level element
+# [Usage context] Where span-level elements are expected
+# [Content model] Span-level elements
+#
+# Represents emphasis of its contents.
+#
+#
+# === :strong
+#
+# [Category] Span-level element
+# [Usage context] Where span-level elements are expected
+# [Content model] Span-level elements
+#
+# Represents strong importance for its contents.
+#
+#
+# === :entity
+#
+# [Category] Span-level element
+# [Usage context] Where span-level elements are expected
+# [Content model] None
+#
+# Represents an HTML entity.
+#
+# The +value+ field has to contain an instance of Kramdown::Utils::Entities::Entity. The option
+# :original can be used to store the original representation of the entity.
+#
+#
+# === :typographic_sym
+#
+# [Category] Span-level element
+# [Usage context] Where span-level elements are expected
+# [Content model] None
+#
+# Represents a typographic symbol.
+#
+# The +value+ field needs to contain a Symbol representing the specific typographic symbol from
+# the following list:
+#
+# :mdash:: An mdash character (---)
+# :ndash:: An ndash character (--)
+# :hellip:: An ellipsis (...)
+# :laquo:: A left guillemet (<<)
+# :raquo:: A right guillemet (>>)
+# :laquo_space:: A left guillemet with a space (<< )
+# :raquo_space:: A right guillemet with a space ( >>)
+#
+#
+# === :smart_quote
+#
+# [Category] Span-level element
+# [Usage context] Where span-level elements are expected
+# [Content model] None
+#
+# Represents a quotation character.
+#
+# The +value+ field needs to contain a Symbol representing the specific quotation character:
+#
+# :lsquo:: Left single quote
+# :rsquo:: Right single quote
+# :ldquo:: Left double quote
+# :rdquo:: Right double quote
+#
+#
+# === :abbreviation
+#
+# [Category] Span-level element
+# [Usage context] Where span-level elements are expected
+# [Content model] None
+#
+# Represents a text part that is an abbreviation.
+#
+# The +value+ field has to contain the text part that is the abbreviation. The definition of the
+# abbreviation is stored in the :root element of the document.
+#
+#
+# == Other Elements
+#
+# === :html_element
+#
+# [Category] Block/span-level element
+# [Usage context] Where block/span-level elements or raw HTML elements are expected
+# [Content model] Depends on the element
+#
+# Represents an HTML element.
+#
+# The +value+ field has to contain the name of the HTML element the element is representing.
+#
+# The option :category has to be set to either :span or :block depending on the whether the
+# element is a block-level or a span-level element. The option :content_model has to be set to the
+# content model for the element (either :block if it contains block-level elements, :span if it
+# contains span-level elements or :raw if it contains raw content).
+#
+#
+# === :xml_comment
+#
+# [Category] Block/span-level element
+# [Usage context] Where block/span-level elements are expected or in raw HTML elements
+# [Content model] None
+#
+# Represents an XML/HTML comment.
+#
+# The +value+ field has to contain the whole XML/HTML comment including the delimiters.
+#
+# The option :category has to be set to either :span or :block depending on the context where the
+# element is used.
+#
+#
+# === :xml_pi
+#
+# [Category] Block/span-level element
+# [Usage context] Where block/span-level elements are expected or in raw HTML elements
+# [Content model] None
+#
+# Represents an XML/HTML processing instruction.
+#
+# The +value+ field has to contain the whole XML/HTML processing instruction including the
+# delimiters.
+#
+# The option :category has to be set to either :span or :block depending on the context where the
+# element is used.
+#
+#
+# === :comment
+#
+# [Category] Block/span-level element
+# [Usage context] Where block/span-level elements are expected
+# [Content model] None
+#
+# Represents a comment.
+#
+# The +value+ field has to contain the comment.
+#
+# The option :category has to be set to either :span or :block depending on the context where the
+# element is used. If it is set to :span, then no blank lines are allowed in the comment.
+#
+#
+# === :raw
+#
+# [Category] Block/span-level element
+# [Usage context] Where block/span-level elements are expected
+# [Content model] None
+#
+# Represents a raw string that should not be modified. For example, the element could contain some
+# HTML code that should be output as-is without modification and escaping.
+#
+# The +value+ field has to contain the actual raw text.
+#
+# The option :category has to be set to either :span or :block depending on the context where the
+# element is used. If it is set to :span, then no blank lines are allowed in the raw text.
+#
+# The option :type can be set to an array of strings to define for which converters the raw string
+# is valid.
+#
+# source://kramdown//lib/kramdown/element.rb#482
+class Kramdown::Element
+  # Create a new Element object of type +type+. The optional parameters +value+, +attr+ and
+  # +options+ can also be set in this constructor for convenience.
+  #
+  # @return [Element] a new instance of Element
+  #
+  # source://kramdown//lib/kramdown/element.rb#496
+  def initialize(type, value = T.unsafe(nil), attr = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  # The attributes of the element.
+  #
+  # source://kramdown//lib/kramdown/element.rb#502
+  def attr; end
+
+  # syntactic sugar to simplify calls such as +Kramdown::Element.category(el) == :block+ with
+  # +el.block?+.
+  #
+  # Returns boolean true or false.
+  #
+  # @return [Boolean]
+  #
+  # source://kramdown//lib/kramdown/element.rb#537
+  def block?; end
+
+  # The child elements of this element.
+  #
+  # source://kramdown//lib/kramdown/element.rb#492
+  def children; end
+
+  # The child elements of this element.
+  #
+  # source://kramdown//lib/kramdown/element.rb#492
+  def children=(_arg0); end
+
+  # source://kramdown//lib/kramdown/element.rb#511
+  def inspect; end
+
+  # The options hash for the element. It is used for storing arbitray options.
+  #
+  # source://kramdown//lib/kramdown/element.rb#507
+  def options; end
+
+  # syntactic sugar to simplify calls such as +Kramdown::Element.category(el) == :span+ with
+  # +el.span?+.
+  #
+  # Returns boolean true or false.
+  #
+  # @return [Boolean]
+  #
+  # source://kramdown//lib/kramdown/element.rb#545
+  def span?; end
+
+  # A symbol representing the element type. For example, :p or :blockquote.
+  #
+  # source://kramdown//lib/kramdown/element.rb#485
+  def type; end
+
+  # A symbol representing the element type. For example, :p or :blockquote.
+  #
+  # source://kramdown//lib/kramdown/element.rb#485
+  def type=(_arg0); end
+
+  # The value of the element. The interpretation of this field depends on the type of the element.
+  # Many elements don't use this field.
+  #
+  # source://kramdown//lib/kramdown/element.rb#489
+  def value; end
+
+  # The value of the element. The interpretation of this field depends on the type of the element.
+  # Many elements don't use this field.
+  #
+  # source://kramdown//lib/kramdown/element.rb#489
+  def value=(_arg0); end
+
+  class << self
+    # Return the category of +el+ which can be :block, :span or +nil+.
+    #
+    # Most elements have a fixed category, however, some elements can either appear in a block-level
+    # or a span-level context. These elements need to have the option :category correctly set.
+    #
+    # source://kramdown//lib/kramdown/element.rb#529
+    def category(el); end
+  end
+end
+
+# source://kramdown//lib/kramdown/element.rb#519
+Kramdown::Element::CATEGORY = T.let(T.unsafe(nil), Hash)
+
+# This error is raised when an error condition is encountered.
+#
+# *Note* that this error is only raised by the support framework for the parsers and converters.
+#
+# source://kramdown//lib/kramdown/error.rb#15
+class Kramdown::Error < ::RuntimeError; end
+
+# This module defines all options that are used by parsers and/or converters as well as providing
+# methods to deal with the options.
+#
+# source://kramdown//lib/kramdown/options.rb#16
+module Kramdown::Options
+  class << self
+    # Return a Hash with the default values for all options.
+    #
+    # source://kramdown//lib/kramdown/options.rb#72
+    def defaults; end
+
+    # Define a new option called +name+ (a Symbol) with the given +type+ (String, Integer, Float,
+    # Symbol, Boolean, Object), default value +default+ and the description +desc+. If a block is
+    # specified, it should validate the value and either raise an error or return a valid value.
+    #
+    # The type 'Object' should only be used for complex types for which none of the other types
+    # suffices. A block needs to be specified when using type 'Object' and it has to cope with
+    # a value given as string and as the opaque type.
+    #
+    # @raise [ArgumentError]
+    #
+    # source://kramdown//lib/kramdown/options.rb#51
+    def define(name, type, default, desc, &block); end
+
+    # Return +true+ if an option called +name+ is defined.
+    #
+    # @return [Boolean]
+    #
+    # source://kramdown//lib/kramdown/options.rb#67
+    def defined?(name); end
+
+    # Return all option definitions.
+    #
+    # source://kramdown//lib/kramdown/options.rb#62
+    def definitions; end
+
+    # Merge the #defaults Hash with the *parsed* options from the given Hash, i.e. only valid option
+    # names are considered and their value is run through the #parse method.
+    #
+    # source://kramdown//lib/kramdown/options.rb#82
+    def merge(hash); end
+
+    # Parse the given value +data+ as if it was a value for the option +name+ and return the parsed
+    # value with the correct type.
+    #
+    # If +data+ already has the correct type, it is just returned. Otherwise it is converted to a
+    # String and then to the correct type.
+    #
+    # @raise [ArgumentError]
+    #
+    # source://kramdown//lib/kramdown/options.rb#96
+    def parse(name, data); end
+
+    # Ensures that the option value +val+ for the option called +name+ is a valid array. The
+    # parameter +val+ can be
+    #
+    # - a comma separated string which is split into an array of values
+    # - or an array.
+    #
+    # Optionally, the array is checked for the correct size.
+    #
+    # source://kramdown//lib/kramdown/options.rb#141
+    def simple_array_validator(val, name, size = T.unsafe(nil)); end
+
+    # Ensures that the option value +val+ for the option called +name+ is a valid hash. The
+    # parameter +val+ can be
+    #
+    # - a hash in YAML format
+    # - or a Ruby Hash object.
+    #
+    # @raise [Kramdown::Error]
+    #
+    # source://kramdown//lib/kramdown/options.rb#158
+    def simple_hash_validator(val, name); end
+
+    # Converts the given String +data+ into a Symbol or +nil+ with the
+    # following provisions:
+    #
+    # - A leading colon is stripped from the string.
+    # - An empty value or a value equal to "nil" results in +nil+.
+    #
+    # source://kramdown//lib/kramdown/options.rb#122
+    def str_to_sym(data); end
+  end
+end
+
+# Allowed option types.
+#
+# source://kramdown//lib/kramdown/options.rb#39
+Kramdown::Options::ALLOWED_TYPES = T.let(T.unsafe(nil), Array)
+
+# Helper class introducing a boolean type for specifying boolean values (+true+ and +false+) as
+# option types.
+#
+# source://kramdown//lib/kramdown/options.rb#20
+class Kramdown::Options::Boolean
+  class << self
+    # Return +true+ if +other+ is either +true+ or +false+
+    #
+    # source://kramdown//lib/kramdown/options.rb#23
+    def ===(other); end
+  end
+end
+
+# Struct class for storing the definition of an option.
+#
+# source://kramdown//lib/kramdown/options.rb#36
+class Kramdown::Options::Definition < ::Struct
+  # Returns the value of attribute default
+  #
+  # @return [Object] the current value of default
+  def default; end
+
+  # Sets the attribute default
+  #
+  # @param value [Object] the value to set the attribute default to.
+  # @return [Object] the newly set value
+  def default=(_); end
+
+  # Returns the value of attribute desc
+  #
+  # @return [Object] the current value of desc
+  def desc; end
+
+  # Sets the attribute desc
+  #
+  # @param value [Object] the value to set the attribute desc to.
+  # @return [Object] the newly set value
+  def desc=(_); end
+
+  # Returns the value of attribute name
+  #
+  # @return [Object] the current value of name
+  def name; end
+
+  # Sets the attribute name
+  #
+  # @param value [Object] the value to set the attribute name to.
+  # @return [Object] the newly set value
+  def name=(_); end
+
+  # Returns the value of attribute type
+  #
+  # @return [Object] the current value of type
+  def type; end
+
+  # Sets the attribute type
+  #
+  # @param value [Object] the value to set the attribute type to.
+  # @return [Object] the newly set value
+  def type=(_); end
+
+  # Returns the value of attribute validator
+  #
+  # @return [Object] the current value of validator
+  def validator; end
+
+  # Sets the attribute validator
+  #
+  # @param value [Object] the value to set the attribute validator to.
+  # @return [Object] the newly set value
+  def validator=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://kramdown//lib/kramdown/options.rb#396
+Kramdown::Options::SMART_QUOTES_ENTITIES = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/options.rb#397
+Kramdown::Options::SMART_QUOTES_STR = T.let(T.unsafe(nil), String)
+
+# source://kramdown//lib/kramdown/options.rb#336
+Kramdown::Options::TOC_LEVELS_ARRAY = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/options.rb#335
+Kramdown::Options::TOC_LEVELS_RANGE = T.let(T.unsafe(nil), Range)
+
+# This module contains all available parsers. A parser takes an input string and converts the
+# string to an element tree.
+#
+# New parsers should be derived from the Base class which provides common functionality - see its
+# API documentation for how to create a custom converter class.
+#
+# source://kramdown//lib/kramdown/parser.rb#17
+module Kramdown::Parser; end
+
+# == \Base class for parsers
+#
+# This class serves as base class for parsers. It provides common methods that can/should be
+# used by all parsers, especially by those using StringScanner(Kramdown) for parsing.
+#
+# A parser object is used as a throw-away object, i.e. it is only used for storing the needed
+# state information during parsing. Therefore one can't instantiate a parser object directly but
+# only use the Base::parse method.
+#
+# == Implementing a parser
+#
+# Implementing a new parser is rather easy: just derive a new class from this class and put it
+# in the Kramdown::Parser module -- the latter is needed so that the auto-detection of the new
+# parser works correctly. Then you need to implement the +#parse+ method which has to contain
+# the parsing code.
+#
+# Have a look at the Base::parse, Base::new and Base#parse methods for additional information!
+#
+# source://kramdown//lib/kramdown/parser/base.rb#34
+class Kramdown::Parser::Base
+  # Initialize the parser object with the +source+ string and the parsing +options+.
+  #
+  # The @root element, the @warnings array and @text_type (specifies the default type for newly
+  # created text nodes) are automatically initialized.
+  #
+  # @return [Base] a new instance of Base
+  #
+  # source://kramdown//lib/kramdown/parser/base.rb#52
+  def initialize(source, options); end
+
+  # Modify the string +source+ to be usable by the parser (unifies line ending characters to
+  # +\n+ and makes sure +source+ ends with a new line character).
+  #
+  # source://kramdown//lib/kramdown/parser/base.rb#91
+  def adapt_source(source); end
+
+  # This helper method adds the given +text+ either to the last element in the +tree+ if it is a
+  # +type+ element or creates a new text element with the given +type+.
+  #
+  # source://kramdown//lib/kramdown/parser/base.rb#103
+  def add_text(text, tree = T.unsafe(nil), type = T.unsafe(nil)); end
+
+  # Extract the part of the StringScanner +strscan+ backed string specified by the +range+. This
+  # method works correctly under Ruby 1.8 and Ruby 1.9.
+  #
+  # source://kramdown//lib/kramdown/parser/base.rb#115
+  def extract_string(range, strscan); end
+
+  # The hash with the parsing options.
+  #
+  # source://kramdown//lib/kramdown/parser/base.rb#37
+  def options; end
+
+  # Parse the source string into an element tree.
+  #
+  # The parsing code should parse the source provided in @source and build an element tree the
+  # root of which should be @root.
+  #
+  # This is the only method that has to be implemented by sub-classes!
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://kramdown//lib/kramdown/parser/base.rb#79
+  def parse; end
+
+  # The root element of element tree that is created from the source string.
+  #
+  # source://kramdown//lib/kramdown/parser/base.rb#46
+  def root; end
+
+  # The original source string.
+  #
+  # source://kramdown//lib/kramdown/parser/base.rb#43
+  def source; end
+
+  # Add the given warning +text+ to the warning array.
+  #
+  # source://kramdown//lib/kramdown/parser/base.rb#84
+  def warning(text); end
+
+  # The array with the parser warnings.
+  #
+  # source://kramdown//lib/kramdown/parser/base.rb#40
+  def warnings; end
+
+  class << self
+    # Parse the +source+ string into an element tree, possibly using the parsing +options+, and
+    # return the root element of the element tree and an array with warning messages.
+    #
+    # Initializes a new instance of the calling class and then calls the +#parse+ method that must
+    # be implemented by each subclass.
+    #
+    # source://kramdown//lib/kramdown/parser/base.rb#67
+    def parse(source, options = T.unsafe(nil)); end
+
+    private
+
+    def allocate; end
+    def new(*_arg0); end
+  end
+end
+
+# Used for parsing an HTML document.
+#
+# The parsing code is in the Parser module that can also be used by other parsers.
+#
+# source://kramdown//lib/kramdown/parser/html.rb#22
+class Kramdown::Parser::Html < ::Kramdown::Parser::Base
+  include ::Kramdown::Parser::Html::Constants
+  include ::Kramdown::Parser::Html::Parser
+
+  # Parse the source string provided on initialization as HTML document.
+  #
+  # source://kramdown//lib/kramdown/parser/html.rb#586
+  def parse; end
+end
+
+# Contains all constants that are used when parsing.
+#
+# source://kramdown//lib/kramdown/parser/html.rb#25
+module Kramdown::Parser::Html::Constants; end
+
+# source://kramdown//lib/kramdown/parser/html.rb#32
+Kramdown::Parser::Html::Constants::HTML_ATTRIBUTE_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/html.rb#59
+Kramdown::Parser::Html::Constants::HTML_BLOCK_ELEMENTS = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/parser/html.rb#30
+Kramdown::Parser::Html::Constants::HTML_COMMENT_RE = T.let(T.unsafe(nil), Regexp)
+
+# The following elements are also parsed as raw since they need child elements that cannot
+# be expressed using kramdown syntax: colgroup table tbody thead tfoot tr ul ol
+#
+# source://kramdown//lib/kramdown/parser/html.rb#48
+Kramdown::Parser::Html::Constants::HTML_CONTENT_MODEL = T.let(T.unsafe(nil), Hash)
+
+# source://kramdown//lib/kramdown/parser/html.rb#37
+Kramdown::Parser::Html::Constants::HTML_CONTENT_MODEL_BLOCK = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/parser/html.rb#44
+Kramdown::Parser::Html::Constants::HTML_CONTENT_MODEL_RAW = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/parser/html.rb#41
+Kramdown::Parser::Html::Constants::HTML_CONTENT_MODEL_SPAN = T.let(T.unsafe(nil), Array)
+
+# :stopdoc:
+# The following regexps are based on the ones used by REXML, with some slight modifications.
+#
+# source://kramdown//lib/kramdown/parser/html.rb#29
+Kramdown::Parser::Html::Constants::HTML_DOCTYPE_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/html.rb#66
+Kramdown::Parser::Html::Constants::HTML_ELEMENT = T.let(T.unsafe(nil), Hash)
+
+# source://kramdown//lib/kramdown/parser/html.rb#63
+Kramdown::Parser::Html::Constants::HTML_ELEMENTS_WITHOUT_BODY = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/parser/html.rb#35
+Kramdown::Parser::Html::Constants::HTML_ENTITY_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/html.rb#31
+Kramdown::Parser::Html::Constants::HTML_INSTRUCTION_RE = T.let(T.unsafe(nil), Regexp)
+
+# Some HTML elements like script belong to both categories (i.e. are valid in block and
+# span HTML) and don't appear therefore!
+# script, textarea
+#
+# source://kramdown//lib/kramdown/parser/html.rb#56
+Kramdown::Parser::Html::Constants::HTML_SPAN_ELEMENTS = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/parser/html.rb#34
+Kramdown::Parser::Html::Constants::HTML_TAG_CLOSE_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/html.rb#33
+Kramdown::Parser::Html::Constants::HTML_TAG_RE = T.let(T.unsafe(nil), Regexp)
+
+# Converts HTML elements to native elements if possible.
+#
+# source://kramdown//lib/kramdown/parser/html.rb#197
+class Kramdown::Parser::Html::ElementConverter
+  include ::Kramdown::Parser::Html::Constants
+  include ::Kramdown::Utils::Entities
+
+  # @return [ElementConverter] a new instance of ElementConverter
+  #
+  # source://kramdown//lib/kramdown/parser/html.rb#216
+  def initialize(root); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#384
+  def convert_a(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#394
+  def convert_b(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#417
+  def convert_code(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#394
+  def convert_em(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#408
+  def convert_h1(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#408
+  def convert_h2(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#408
+  def convert_h3(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#408
+  def convert_h4(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#408
+  def convert_h5(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#408
+  def convert_h6(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#394
+  def convert_i(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#417
+  def convert_pre(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#563
+  def convert_script(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#394
+  def convert_strong(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#460
+  def convert_table(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#380
+  def convert_textarea(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#375
+  def extract_text(el, raw); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#575
+  def handle_math_tag(el); end
+
+  # @return [Boolean]
+  #
+  # source://kramdown//lib/kramdown/parser/html.rb#571
+  def is_math_tag?(el); end
+
+  # @return [Boolean]
+  #
+  # source://kramdown//lib/kramdown/parser/html.rb#503
+  def is_simple_table?(el); end
+
+  # Convert the element +el+ and its children.
+  #
+  # source://kramdown//lib/kramdown/parser/html.rb#225
+  def process(el, do_conversion = T.unsafe(nil), preserve_text = T.unsafe(nil), parent = T.unsafe(nil)); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#278
+  def process_children(el, do_conversion = T.unsafe(nil), preserve_text = T.unsafe(nil)); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#320
+  def process_html_element(el, do_conversion = T.unsafe(nil), preserve_text = T.unsafe(nil)); end
+
+  # Process the HTML text +raw+: compress whitespace (if +preserve+ is +false+) and convert
+  # entities in entity elements.
+  #
+  # source://kramdown//lib/kramdown/parser/html.rb#291
+  def process_text(raw, preserve = T.unsafe(nil)); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#326
+  def remove_text_children(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#359
+  def remove_whitespace_children(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#369
+  def set_basics(el, type, opts = T.unsafe(nil)); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#349
+  def strip_whitespace(el); end
+
+  # source://kramdown//lib/kramdown/parser/html.rb#330
+  def wrap_text_children(el); end
+
+  class << self
+    # source://kramdown//lib/kramdown/parser/html.rb#220
+    def convert(root, el = T.unsafe(nil)); end
+  end
+end
+
+# source://kramdown//lib/kramdown/parser/html.rb#393
+Kramdown::Parser::Html::ElementConverter::EMPHASIS_TYPE_MAP = T.let(T.unsafe(nil), Hash)
+
+# source://kramdown//lib/kramdown/parser/html.rb#204
+Kramdown::Parser::Html::ElementConverter::REMOVE_TEXT_CHILDREN = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/parser/html.rb#208
+Kramdown::Parser::Html::ElementConverter::REMOVE_WHITESPACE_CHILDREN = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/parser/html.rb#213
+Kramdown::Parser::Html::ElementConverter::SIMPLE_ELEMENTS = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/parser/html.rb#210
+Kramdown::Parser::Html::ElementConverter::STRIP_WHITESPACE = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/parser/html.rb#206
+Kramdown::Parser::Html::ElementConverter::WRAP_TEXT_CHILDREN = T.let(T.unsafe(nil), Array)
+
+# Contains the parsing methods. This module can be mixed into any parser to get HTML parsing
+# functionality. The only thing that must be provided by the class are instance variable
+# parsing.
+#
+# source://kramdown//lib/kramdown/parser/html.rb#77
+module Kramdown::Parser::Html::Parser
+  include ::Kramdown::Parser::Html::Constants
+
+  # Process the HTML start tag that has already be scanned/checked via @src.
+  #
+  # Does the common processing steps and then yields to the caller for further processing
+  # (first parameter is the created element; the second parameter is +true+ if the HTML
+  # element is already closed, ie. contains no body; the third parameter specifies whether the
+  # body - and the end tag - need to be handled in case closed=false).
+  #
+  # source://kramdown//lib/kramdown/parser/html.rb#87
+  def handle_html_start_tag(line = T.unsafe(nil)); end
+
+  # Handle the raw HTML tag at the current position.
+  #
+  # source://kramdown//lib/kramdown/parser/html.rb#127
+  def handle_raw_html_tag(name); end
+
+  # Parses the given string for HTML attributes and returns the resulting hash.
+  #
+  # If the optional +line+ parameter is supplied, it is used in warning messages.
+  #
+  # If the optional +in_html_tag+ parameter is set to +false+, attributes are not modified to
+  # contain only lowercase letters.
+  #
+  # source://kramdown//lib/kramdown/parser/html.rb#114
+  def parse_html_attributes(str, line = T.unsafe(nil), in_html_tag = T.unsafe(nil)); end
+
+  # Parse raw HTML from the current source position, storing the found elements in +el+.
+  # Parsing continues until one of the following criteria are fulfilled:
+  #
+  # - The end of the document is reached.
+  # - The matching end tag for the element +el+ is found (only used if +el+ is an HTML
+  #   element).
+  #
+  # When an HTML start tag is found, processing is deferred to #handle_html_start_tag,
+  # providing the block given to this method.
+  #
+  # source://kramdown//lib/kramdown/parser/html.rb#150
+  def parse_raw_html(el, &block); end
+end
+
+# source://kramdown//lib/kramdown/parser/html.rb#139
+Kramdown::Parser::Html::Parser::HTML_RAW_START = T.let(T.unsafe(nil), Regexp)
+
+# Used for parsing a document in kramdown format.
+#
+# If you want to extend the functionality of the parser, you need to do the following:
+#
+# * Create a new subclass
+# * add the needed parser methods
+# * modify the @block_parsers and @span_parsers variables and add the names of your parser
+#   methods
+#
+# Here is a small example for an extended parser class that parses ERB style tags as raw text if
+# they are used as span-level elements (an equivalent block-level parser should probably also be
+# made to handle the block case):
+#
+#   require 'kramdown/parser/kramdown'
+#
+#   class Kramdown::Parser::ERBKramdown < Kramdown::Parser::Kramdown
+#
+#      def initialize(source, options)
+#        super
+#        @span_parsers.unshift(:erb_tags)
+#      end
+#
+#      ERB_TAGS_START = /<%.*?%>/
+#
+#      def parse_erb_tags
+#        @src.pos += @src.matched_size
+#        @tree.children << Element.new(:raw, @src.matched)
+#      end
+#      define_parser(:erb_tags, ERB_TAGS_START, '<%')
+#
+#   end
+#
+# The new parser can be used like this:
+#
+#   require 'kramdown/document'
+#   # require the file with the above parser class
+#
+#   Kramdown::Document.new(input_text, :input => 'ERBKramdown').to_html
+#
+# source://kramdown//lib/kramdown/parser/kramdown.rb#60
+class Kramdown::Parser::Kramdown < ::Kramdown::Parser::Base
+  include ::Kramdown
+  include ::Kramdown::Parser::Html::Constants
+  include ::Kramdown::Parser::Html::Parser
+
+  # Create a new Kramdown parser object with the given +options+.
+  #
+  # @return [Kramdown] a new instance of Kramdown
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#65
+  def initialize(source, options); end
+
+  # This helper methods adds the approriate attributes to the element +el+ of type +a+ or +img+
+  # and the element itself to the @tree.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/link.rb#39
+  def add_link(el, href, title, alt_text = T.unsafe(nil), ial = T.unsafe(nil)); end
+
+  # Return +true+ if we are after a block boundary.
+  #
+  # @return [Boolean]
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/block_boundary.rb#21
+  def after_block_boundary?; end
+
+  # Return +true+ if we are before a block boundary.
+  #
+  # @return [Boolean]
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/block_boundary.rb#28
+  def before_block_boundary?; end
+
+  # Correct abbreviation attributes.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/abbreviation.rb#34
+  def correct_abbreviations_attributes; end
+
+  # source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#96
+  def handle_extension(name, opts, body, type, line_no = T.unsafe(nil)); end
+
+  # source://kramdown//lib/kramdown/parser/kramdown/html.rb#25
+  def handle_kramdown_html_tag(el, closed, handle_body); end
+
+  # Normalize the link identifier.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/link.rb#17
+  def normalize_link_id(id); end
+
+  # source://kramdown//lib/kramdown/parser/kramdown/paragraph.rb#56
+  def paragraph_end; end
+
+  # The source string provided on initialization is parsed into the @root element.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#88
+  def parse; end
+
+  # Parse the link definition at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/abbreviation.rb#17
+  def parse_abbrev_definition; end
+
+  # Parse the string +str+ and extract all attributes and add all found attributes to the hash
+  # +opts+.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#18
+  def parse_attribute_list(str, opts); end
+
+  # Parse the Atx header at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/header.rb#32
+  def parse_atx_header; end
+
+  # Parse the autolink at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/autolink.rb#19
+  def parse_autolink; end
+
+  # Parse the blank line at the current postition.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/blank_line.rb#17
+  def parse_blank_line; end
+
+  # Parse one of the block extensions (ALD, block IAL or generic extension) at the current
+  # location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#164
+  def parse_block_extensions; end
+
+  # Parse the HTML at the current position as block-level HTML.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/html.rb#71
+  def parse_block_html; end
+
+  # Parse the math block at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/math.rb#19
+  def parse_block_math; end
+
+  # Parse the blockquote at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/blockquote.rb#21
+  def parse_blockquote; end
+
+  # Parse the indented codeblock at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/codeblock.rb#23
+  def parse_codeblock; end
+
+  # Parse the fenced codeblock at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/codeblock.rb#37
+  def parse_codeblock_fenced; end
+
+  # Parse the codespan at the current scanner location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/codespan.rb#17
+  def parse_codespan; end
+
+  # Parse the ordered or unordered list at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/list.rb#153
+  def parse_definition_list; end
+
+  # Parse the emphasis at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/emphasis.rb#17
+  def parse_emphasis; end
+
+  # Parse the EOB marker at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/eob.rb#17
+  def parse_eob_marker; end
+
+  # Parse the backslash-escaped character at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/escaped_chars.rb#17
+  def parse_escaped_chars; end
+
+  # Parse the generic extension at the current point. The parameter +type+ can either be :block
+  # or :span depending whether we parse a block or span extension tag.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#54
+  def parse_extension_start_tag(type); end
+
+  # Used for parsing the first line of a list item or a definition, i.e. the line with list item
+  # marker or the definition marker.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/list.rb#32
+  def parse_first_list_line(indentation, content); end
+
+  # Parse the foot note definition at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/footnote.rb#21
+  def parse_footnote_definition; end
+
+  # Parse the footnote marker at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/footnote.rb#40
+  def parse_footnote_marker; end
+
+  # Parse the horizontal rule at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/horizontal_rule.rb#17
+  def parse_horizontal_rule; end
+
+  # Parse the HTML entity at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/html_entity.rb#17
+  def parse_html_entity; end
+
+  # Parse the inline math at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/math.rb#44
+  def parse_inline_math; end
+
+  # Parse the line break at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/line_break.rb#17
+  def parse_line_break; end
+
+  # Parse the link at the current scanner position. This method is used to parse normal links as
+  # well as image links.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/link.rb#61
+  def parse_link; end
+
+  # Parse the link definition at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/link.rb#24
+  def parse_link_definition; end
+
+  # Parse the ordered or unordered list at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/list.rb#54
+  def parse_list; end
+
+  # Parse the paragraph at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/paragraph.rb#31
+  def parse_paragraph; end
+
+  # Parse the Setext header at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/header.rb#20
+  def parse_setext_header; end
+
+  # Parse the smart quotes at current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/smart_quotes.rb#158
+  def parse_smart_quotes; end
+
+  # Parse the extension span at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#192
+  def parse_span_extensions; end
+
+  # Parse the HTML at the current position as span-level HTML.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/html.rb#102
+  def parse_span_html; end
+
+  # Parse the table at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/table.rb#25
+  def parse_table; end
+
+  # Parse the typographic symbols at the current location.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/typographic_symbol.rb#22
+  def parse_typographic_syms; end
+
+  # Replace the abbreviation text with elements.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/abbreviation.rb#41
+  def replace_abbreviations(el, regexps = T.unsafe(nil)); end
+
+  # Update the +ial+ with the information from the inline attribute list +opts+.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#41
+  def update_ial_with_ial(ial, opts); end
+
+  protected
+
+  # source://kramdown//lib/kramdown/parser/kramdown/header.rb#59
+  def add_header(level, text, id); end
+
+  # Adapt the object to allow parsing like specified in the options.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#121
+  def configure_parser; end
+
+  # Create a new block-level element, taking care of applying a preceding block IAL if it
+  # exists. This method should always be used for creating a block-level element!
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#305
+  def new_block_el(*args); end
+
+  # Parse all block-level elements in +text+ into the element +el+.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#140
+  def parse_blocks(el, text = T.unsafe(nil)); end
+
+  # Returns header text and optional ID.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/header.rb#47
+  def parse_header_contents; end
+
+  # Parse all span-level elements in the source string of @src into +el+.
+  #
+  # If the parameter +stop_re+ (a regexp) is used, parsing is immediately stopped if the regexp
+  # matches and if no block is given or if a block is given and it returns +true+.
+  #
+  # The parameter +parsers+ can be used to specify the (span-level) parsing methods that should
+  # be used for parsing.
+  #
+  # The parameter +text_type+ specifies the type which should be used for created text nodes.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#214
+  def parse_spans(el, stop_re = T.unsafe(nil), parsers = T.unsafe(nil), text_type = T.unsafe(nil)); end
+
+  # Reset the current parsing environment. The parameter +env+ can be used to set initial
+  # values for one or more environment variables.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#253
+  def reset_env(opts = T.unsafe(nil)); end
+
+  # Restore the current parsing environment.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#268
+  def restore_env(env); end
+
+  # Return the current parsing environment.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#263
+  def save_env; end
+
+  # Create the needed span parser regexps.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#134
+  def span_parser_regexps(parsers = T.unsafe(nil)); end
+
+  # Update the given attributes hash +attr+ with the information from the inline attribute list
+  # +ial+ and all referenced ALDs.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#274
+  def update_attr_with_ial(attr, ial); end
+
+  #
+  # Update the parser specific link definitions with the data from +link_defs+ (the value of the
+  # :link_defs option).
+  #
+  # The parameter +link_defs+ is a hash where the keys are possibly unnormalized link IDs and
+  # the values are two element arrays consisting of the link target and a title (can be +nil+).
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#116
+  def update_link_definitions(link_defs); end
+
+  # Update the raw text for automatic ID generation.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#288
+  def update_raw_text(item); end
+
+  # Update the tree by parsing all :+raw_text+ elements with the span-level parser (resets the
+  # environment) and by updating the attributes from the IALs.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#166
+  def update_tree(element); end
+
+  private
+
+  # precomputed patterns for indentations 1..4 and fallback expression
+  # to compute pattern when indentation is outside the 1..4 range.
+  #
+  # source://kramdown//lib/kramdown/parser/kramdown/list.rb#258
+  def fetch_pattern(type, indentation); end
+
+  # source://kramdown//lib/kramdown/parser/kramdown.rb#200
+  def span_pattern_cache(stop_re, span_start); end
+
+  class << self
+    # Add a parser method
+    #
+    # * with the given +name+,
+    # * using +start_re+ as start regexp
+    # * and, for span parsers, +span_start+ as a String that can be used in a regexp and
+    #   which identifies the starting character(s)
+    #
+    # to the registry. The method name is automatically derived from the +name+ or can explicitly
+    # be set by using the +meth_name+ parameter.
+    #
+    # source://kramdown//lib/kramdown/parser/kramdown.rb#328
+    def define_parser(name, start_re, span_start = T.unsafe(nil), meth_name = T.unsafe(nil)); end
+
+    # Return +true+ if there is a parser called +name+.
+    #
+    # @return [Boolean]
+    #
+    # source://kramdown//lib/kramdown/parser/kramdown.rb#339
+    def has_parser?(name); end
+
+    # Return the Data structure for the parser +name+.
+    #
+    # source://kramdown//lib/kramdown/parser/kramdown.rb#334
+    def parser(name = T.unsafe(nil)); end
+  end
+end
+
+# source://kramdown//lib/kramdown/parser/kramdown/abbreviation.rb#14
+Kramdown::Parser::Kramdown::ABBREV_DEFINITION_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/autolink.rb#14
+Kramdown::Parser::Kramdown::ACHARS = T.let(T.unsafe(nil), String)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#140
+Kramdown::Parser::Kramdown::ALD_ANY_CHARS = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#142
+Kramdown::Parser::Kramdown::ALD_CLASS_NAME = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#139
+Kramdown::Parser::Kramdown::ALD_ID_CHARS = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#141
+Kramdown::Parser::Kramdown::ALD_ID_NAME = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#150
+Kramdown::Parser::Kramdown::ALD_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#149
+Kramdown::Parser::Kramdown::ALD_TYPE_ANY = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#144
+Kramdown::Parser::Kramdown::ALD_TYPE_CLASS_NAME = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#145
+Kramdown::Parser::Kramdown::ALD_TYPE_ID_NAME = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#146
+Kramdown::Parser::Kramdown::ALD_TYPE_ID_OR_CLASS = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#147
+Kramdown::Parser::Kramdown::ALD_TYPE_ID_OR_CLASS_MULTI = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#143
+Kramdown::Parser::Kramdown::ALD_TYPE_KEY_VALUE_PAIR = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#148
+Kramdown::Parser::Kramdown::ALD_TYPE_REF = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/header.rb#29
+Kramdown::Parser::Kramdown::ATX_HEADER_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/autolink.rb#16
+Kramdown::Parser::Kramdown::AUTOLINK_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/autolink.rb#15
+Kramdown::Parser::Kramdown::AUTOLINK_START_STR = T.let(T.unsafe(nil), String)
+
+# source://kramdown//lib/kramdown/parser/kramdown/blank_line.rb#14
+Kramdown::Parser::Kramdown::BLANK_LINE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/blockquote.rb#18
+Kramdown::Parser::Kramdown::BLOCKQUOTE_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/block_boundary.rb#18
+Kramdown::Parser::Kramdown::BLOCK_BOUNDARY = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#160
+Kramdown::Parser::Kramdown::BLOCK_EXTENSIONS_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/math.rb#16
+Kramdown::Parser::Kramdown::BLOCK_MATH_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/codeblock.rb#20
+Kramdown::Parser::Kramdown::CODEBLOCK_MATCH = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/codeblock.rb#19
+Kramdown::Parser::Kramdown::CODEBLOCK_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/codespan.rb#14
+Kramdown::Parser::Kramdown::CODESPAN_DELIMITER = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/list.rb#150
+Kramdown::Parser::Kramdown::DEFINITION_LIST_START = T.let(T.unsafe(nil), Regexp)
+
+# Struct class holding all the needed data for one block/span-level parser method.
+#
+# source://kramdown//lib/kramdown/parser/kramdown.rb#317
+class Kramdown::Parser::Kramdown::Data < ::Struct
+  # Returns the value of attribute method
+  #
+  # @return [Object] the current value of method
+  def method; end
+
+  # Sets the attribute method
+  #
+  # @param value [Object] the value to set the attribute method to.
+  # @return [Object] the newly set value
+  def method=(_); end
+
+  # Returns the value of attribute name
+  #
+  # @return [Object] the current value of name
+  def name; end
+
+  # Sets the attribute name
+  #
+  # @param value [Object] the value to set the attribute name to.
+  # @return [Object] the newly set value
+  def name=(_); end
+
+  # Returns the value of attribute span_start
+  #
+  # @return [Object] the current value of span_start
+  def span_start; end
+
+  # Sets the attribute span_start
+  #
+  # @param value [Object] the value to set the attribute span_start to.
+  # @return [Object] the newly set value
+  def span_start=(_); end
+
+  # Returns the value of attribute start_re
+  #
+  # @return [Object] the current value of start_re
+  def start_re; end
+
+  # Sets the attribute start_re
+  #
+  # @param value [Object] the value to set the attribute start_re to.
+  # @return [Object] the newly set value
+  def start_re=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://kramdown//lib/kramdown/parser/kramdown/emphasis.rb#14
+Kramdown::Parser::Kramdown::EMPHASIS_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/eob.rb#14
+Kramdown::Parser::Kramdown::EOB_MARKER = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/escaped_chars.rb#14
+Kramdown::Parser::Kramdown::ESCAPED_CHARS = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#154
+Kramdown::Parser::Kramdown::EXT_BLOCK_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#155
+Kramdown::Parser::Kramdown::EXT_BLOCK_STOP_STR = T.let(T.unsafe(nil), String)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#187
+Kramdown::Parser::Kramdown::EXT_SPAN_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#153
+Kramdown::Parser::Kramdown::EXT_START_STR = T.let(T.unsafe(nil), String)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#152
+Kramdown::Parser::Kramdown::EXT_STOP_STR = T.let(T.unsafe(nil), String)
+
+# source://kramdown//lib/kramdown/parser/kramdown/codeblock.rb#34
+Kramdown::Parser::Kramdown::FENCED_CODEBLOCK_MATCH = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/codeblock.rb#33
+Kramdown::Parser::Kramdown::FENCED_CODEBLOCK_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/footnote.rb#18
+Kramdown::Parser::Kramdown::FOOTNOTE_DEFINITION_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/footnote.rb#37
+Kramdown::Parser::Kramdown::FOOTNOTE_MARKER_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/header.rb#44
+Kramdown::Parser::Kramdown::HEADER_ID = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/horizontal_rule.rb#14
+Kramdown::Parser::Kramdown::HR_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/html.rb#68
+Kramdown::Parser::Kramdown::HTML_BLOCK_START = T.let(T.unsafe(nil), Regexp)
+
+# Mapping of markdown attribute value to content model. I.e. :raw when "0", :default when "1"
+# (use default content model for the HTML element), :span when "span", :block when block and
+# for everything else +nil+ is returned.
+#
+# source://kramdown//lib/kramdown/parser/kramdown/html.rb#21
+Kramdown::Parser::Kramdown::HTML_MARKDOWN_ATTR_MAP = T.let(T.unsafe(nil), Hash)
+
+# source://kramdown//lib/kramdown/parser/kramdown/html.rb#99
+Kramdown::Parser::Kramdown::HTML_SPAN_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#157
+Kramdown::Parser::Kramdown::IAL_BLOCK = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#158
+Kramdown::Parser::Kramdown::IAL_BLOCK_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#14
+Kramdown::Parser::Kramdown::IAL_CLASS_ATTR = T.let(T.unsafe(nil), String)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#188
+Kramdown::Parser::Kramdown::IAL_SPAN_START = T.let(T.unsafe(nil), Regexp)
+
+# Regexp for matching indentation (one tab or four spaces)
+#
+# source://kramdown//lib/kramdown/parser/kramdown.rb#344
+Kramdown::Parser::Kramdown::INDENT = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/math.rb#41
+Kramdown::Parser::Kramdown::INLINE_MATH_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/paragraph.rb#24
+Kramdown::Parser::Kramdown::LAZY_END = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/paragraph.rb#20
+Kramdown::Parser::Kramdown::LAZY_END_HTML_SPAN_ELEMENTS = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/parser/kramdown/paragraph.rb#21
+Kramdown::Parser::Kramdown::LAZY_END_HTML_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/paragraph.rb#22
+Kramdown::Parser::Kramdown::LAZY_END_HTML_STOP = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/line_break.rb#14
+Kramdown::Parser::Kramdown::LINE_BREAK = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/link.rb#53
+Kramdown::Parser::Kramdown::LINK_BRACKET_STOP_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/link.rb#21
+Kramdown::Parser::Kramdown::LINK_DEFINITION_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/link.rb#55
+Kramdown::Parser::Kramdown::LINK_INLINE_ID_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/link.rb#56
+Kramdown::Parser::Kramdown::LINK_INLINE_TITLE_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/link.rb#54
+Kramdown::Parser::Kramdown::LINK_PAREN_STOP_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/link.rb#57
+Kramdown::Parser::Kramdown::LINK_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/list.rb#19
+Kramdown::Parser::Kramdown::LIST_ITEM_IAL = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/list.rb#20
+Kramdown::Parser::Kramdown::LIST_ITEM_IAL_CHECK = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/list.rb#51
+Kramdown::Parser::Kramdown::LIST_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/list.rb#50
+Kramdown::Parser::Kramdown::LIST_START_OL = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/list.rb#49
+Kramdown::Parser::Kramdown::LIST_START_UL = T.let(T.unsafe(nil), Regexp)
+
+# Regexp for matching the optional space (zero or up to three spaces)
+#
+# source://kramdown//lib/kramdown/parser/kramdown.rb#346
+Kramdown::Parser::Kramdown::OPT_SPACE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/paragraph.rb#28
+Kramdown::Parser::Kramdown::PARAGRAPH_END = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/paragraph.rb#27
+Kramdown::Parser::Kramdown::PARAGRAPH_MATCH = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/paragraph.rb#26
+Kramdown::Parser::Kramdown::PARAGRAPH_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/list.rb#22
+Kramdown::Parser::Kramdown::PARSE_FIRST_LIST_LINE_REGEXP_CACHE = T.let(T.unsafe(nil), Hash)
+
+# source://kramdown//lib/kramdown/parser/kramdown/list.rb#47
+Kramdown::Parser::Kramdown::PATTERN_TAIL = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/header.rb#17
+Kramdown::Parser::Kramdown::SETEXT_HEADER_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/smart_quotes.rb#155
+Kramdown::Parser::Kramdown::SMART_QUOTES_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/extensions.rb#189
+Kramdown::Parser::Kramdown::SPAN_EXTENSIONS_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/smart_quotes.rb#122
+Kramdown::Parser::Kramdown::SQ_CLOSE = T.let(T.unsafe(nil), String)
+
+# source://kramdown//lib/kramdown/parser/kramdown/smart_quotes.rb#121
+Kramdown::Parser::Kramdown::SQ_PUNCT = T.let(T.unsafe(nil), String)
+
+# source://kramdown//lib/kramdown/parser/kramdown/smart_quotes.rb#124
+Kramdown::Parser::Kramdown::SQ_RULES = T.let(T.unsafe(nil), Array)
+
+# '"
+#
+# source://kramdown//lib/kramdown/parser/kramdown/smart_quotes.rb#145
+Kramdown::Parser::Kramdown::SQ_SUBSTS = T.let(T.unsafe(nil), Hash)
+
+# source://kramdown//lib/kramdown/parser/kramdown/table.rb#18
+Kramdown::Parser::Kramdown::TABLE_FSEP_LINE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/table.rb#17
+Kramdown::Parser::Kramdown::TABLE_HSEP_ALIGN = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/table.rb#21
+Kramdown::Parser::Kramdown::TABLE_LINE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/table.rb#20
+Kramdown::Parser::Kramdown::TABLE_PIPE_CHECK = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/table.rb#19
+Kramdown::Parser::Kramdown::TABLE_ROW_LINE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/table.rb#16
+Kramdown::Parser::Kramdown::TABLE_SEP_LINE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/table.rb#22
+Kramdown::Parser::Kramdown::TABLE_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/html.rb#23
+Kramdown::Parser::Kramdown::TRAILING_WHITESPACE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/typographic_symbol.rb#14
+Kramdown::Parser::Kramdown::TYPOGRAPHIC_SYMS = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/parser/kramdown/typographic_symbol.rb#19
+Kramdown::Parser::Kramdown::TYPOGRAPHIC_SYMS_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/kramdown/typographic_symbol.rb#18
+Kramdown::Parser::Kramdown::TYPOGRAPHIC_SYMS_SUBST = T.let(T.unsafe(nil), Hash)
+
+# Used for parsing a document in Markdown format.
+#
+# This parser is based on the kramdown parser and removes the parser methods for the additional
+# non-Markdown features. However, since some things are handled differently by the kramdown
+# parser methods (like deciding when a list item contains just text), this parser differs from
+# real Markdown parsers in some respects.
+#
+# Note, though, that the parser basically fails just one of the Markdown test cases (some others
+# also fail but those failures are negligible).
+#
+# source://kramdown//lib/kramdown/parser/markdown.rb#25
+class Kramdown::Parser::Markdown < ::Kramdown::Parser::Kramdown
+  # @return [Markdown] a new instance of Markdown
+  #
+  # source://kramdown//lib/kramdown/parser/markdown.rb#32
+  def initialize(source, options); end
+end
+
+# :stopdoc:
+#
+# source://kramdown//lib/kramdown/parser/markdown.rb#40
+Kramdown::Parser::Markdown::BLOCK_BOUNDARY = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/markdown.rb#43
+Kramdown::Parser::Markdown::CODEBLOCK_MATCH = T.let(T.unsafe(nil), Regexp)
+
+# Array with all the parsing methods that should be removed from the standard kramdown parser.
+#
+# source://kramdown//lib/kramdown/parser/markdown.rb#28
+Kramdown::Parser::Markdown::EXTENDED = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/parser/markdown.rb#46
+Kramdown::Parser::Markdown::IAL_RAND_CHARS = T.let(T.unsafe(nil), Array)
+
+# source://kramdown//lib/kramdown/parser/markdown.rb#47
+Kramdown::Parser::Markdown::IAL_RAND_STRING = T.let(T.unsafe(nil), String)
+
+# source://kramdown//lib/kramdown/parser/markdown.rb#49
+Kramdown::Parser::Markdown::IAL_SPAN_START = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/markdown.rb#41
+Kramdown::Parser::Markdown::LAZY_END = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/markdown.rb#48
+Kramdown::Parser::Markdown::LIST_ITEM_IAL = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/parser/markdown.rb#44
+Kramdown::Parser::Markdown::PARAGRAPH_END = T.let(T.unsafe(nil), Regexp)
+
+# == \Utils Module
+#
+# This module contains utility class/modules/methods that can be used by both parsers and
+# converters.
+#
+# source://kramdown//lib/kramdown/utils.rb#16
+module Kramdown::Utils
+  class << self
+    # Treat +name+ as if it were snake cased (e.g. snake_case) and camelize it (e.g. SnakeCase).
+    #
+    # source://kramdown//lib/kramdown/utils.rb#26
+    def camelize(name); end
+
+    # source://kramdown//lib/kramdown/utils.rb#39
+    def deep_const_get(str); end
+
+    # Treat +name+ as if it were camelized (e.g. CamelizedName) and snake-case it (e.g. camelized_name).
+    #
+    # source://kramdown//lib/kramdown/utils.rb#31
+    def snake_case(name); end
+  end
+end
+
+# Methods for registering configurable extensions.
+#
+# source://kramdown//lib/kramdown/utils/configurable.rb#14
+module Kramdown::Utils::Configurable
+  # Create a new configurable extension called +name+.
+  #
+  # Three methods will be defined on the calling object which allow to use this configurable
+  # extension:
+  #
+  # configurables:: Returns a hash of hashes that is used to store all configurables of the
+  #                 object.
+  #
+  # <name>(ext_name):: Return the configured extension +ext_name+.
+  #
+  # add_<name>(ext_name, data=nil, &block):: Define an extension +ext_name+ by specifying either
+  #                                          the data as argument or by using a block.
+  #
+  # source://kramdown//lib/kramdown/utils/configurable.rb#28
+  def configurable(name); end
+end
+
+# Provides convenience methods for handling named and numeric entities.
+#
+# source://kramdown//lib/kramdown/utils/entities.rb#15
+module Kramdown::Utils::Entities
+  private
+
+  # Return the entity for the given code point or name +point_or_name+.
+  #
+  # source://kramdown//lib/kramdown/utils/entities.rb#334
+  def entity(point_or_name); end
+
+  class << self
+    # Return the entity for the given code point or name +point_or_name+.
+    #
+    # source://kramdown//lib/kramdown/utils/entities.rb#334
+    def entity(point_or_name); end
+  end
+end
+
+# Contains the mapping of code point (or name) to the actual Entity object.
+#
+# source://kramdown//lib/kramdown/utils/entities.rb#317
+Kramdown::Utils::Entities::ENTITY_MAP = T.let(T.unsafe(nil), Hash)
+
+# Array of arrays. Each sub-array specifies a code point and the associated name.
+#
+# This table is not used directly -- Entity objects are automatically created from it and put
+# into a Hash map when this file is loaded.
+#
+# source://kramdown//lib/kramdown/utils/entities.rb#29
+Kramdown::Utils::Entities::ENTITY_TABLE = T.let(T.unsafe(nil), Array)
+
+# Represents an entity that has a +code_point+ and +name+.
+#
+# source://kramdown//lib/kramdown/utils/entities.rb#18
+class Kramdown::Utils::Entities::Entity < ::Struct
+  # Return the UTF8 representation of the entity.
+  #
+  # source://kramdown//lib/kramdown/utils/entities.rb#20
+  def char; end
+
+  # Returns the value of attribute code_point
+  #
+  # @return [Object] the current value of code_point
+  def code_point; end
+
+  # Sets the attribute code_point
+  #
+  # @param value [Object] the value to set the attribute code_point to.
+  # @return [Object] the newly set value
+  def code_point=(_); end
+
+  # Returns the value of attribute name
+  #
+  # @return [Object] the current value of name
+  def name; end
+
+  # Sets the attribute name
+  #
+  # @param value [Object] the value to set the attribute name to.
+  # @return [Object] the newly set value
+  def name=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# Provides convenience methods for HTML related tasks.
+#
+# *Note* that this module has to be mixed into a class that has a @root (containing an element
+# of type :root) and an @options (containing an options hash) instance variable so that some of
+# the methods can work correctly.
+#
+# source://kramdown//lib/kramdown/utils/html.rb#21
+module Kramdown::Utils::Html
+  # Convert the entity +e+ to a string. The optional parameter +original+ may contain the
+  # original representation of the entity.
+  #
+  # This method uses the option +entity_output+ to determine the output form for the entity.
+  #
+  # source://kramdown//lib/kramdown/utils/html.rb#27
+  def entity_to_str(e, original = T.unsafe(nil)); end
+
+  # Escape the special HTML characters in the string +str+. The parameter +type+ specifies what
+  # is escaped: :all - all special HTML characters except the quotation mark as well as
+  # entities, :text - all special HTML characters except the quotation mark but no entities and
+  # :attribute - all special HTML characters including the quotation mark but no entities.
+  #
+  # source://kramdown//lib/kramdown/utils/html.rb#69
+  def escape_html(str, type = T.unsafe(nil)); end
+
+  # source://kramdown//lib/kramdown/utils/html.rb#74
+  def fix_cjk_line_break(str); end
+
+  # Return the HTML representation of the attributes +attr+.
+  #
+  # source://kramdown//lib/kramdown/utils/html.rb#44
+  def html_attributes(attr); end
+end
+
+# source://kramdown//lib/kramdown/utils/html.rb#59
+Kramdown::Utils::Html::ESCAPE_ALL_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/utils/html.rb#61
+Kramdown::Utils::Html::ESCAPE_ATTRIBUTE_RE = T.let(T.unsafe(nil), Regexp)
+
+# :stopdoc:
+#
+# source://kramdown//lib/kramdown/utils/html.rb#53
+Kramdown::Utils::Html::ESCAPE_MAP = T.let(T.unsafe(nil), Hash)
+
+# source://kramdown//lib/kramdown/utils/html.rb#62
+Kramdown::Utils::Html::ESCAPE_RE_FROM_TYPE = T.let(T.unsafe(nil), Hash)
+
+# source://kramdown//lib/kramdown/utils/html.rb#60
+Kramdown::Utils::Html::ESCAPE_TEXT_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://kramdown//lib/kramdown/utils/html.rb#73
+Kramdown::Utils::Html::REDUNDANT_LINE_BREAK_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# A simple least recently used (LRU) cache.
+#
+# The cache relies on the fact that Ruby's Hash class maintains insertion order. So deleting
+# and re-inserting a key-value pair on access moves the key to the last position. When an
+# entry is added and the cache is full, the first entry is removed.
+#
+# source://kramdown//lib/kramdown/utils/lru_cache.rb#18
+class Kramdown::Utils::LRUCache
+  # Creates a new LRUCache that can hold +size+ entries.
+  #
+  # @return [LRUCache] a new instance of LRUCache
+  #
+  # source://kramdown//lib/kramdown/utils/lru_cache.rb#21
+  def initialize(size); end
+
+  # Returns the stored value for +key+ or +nil+ if no value was stored under the key.
+  #
+  # source://kramdown//lib/kramdown/utils/lru_cache.rb#27
+  def [](key); end
+
+  # Stores the +value+ under the +key+.
+  #
+  # source://kramdown//lib/kramdown/utils/lru_cache.rb#32
+  def []=(key, value); end
+end
+
+# This patched StringScanner adds line number information for current scan position and a
+# start_line_number override for nested StringScanners.
+#
+# source://kramdown//lib/kramdown/utils/string_scanner.rb#17
+class Kramdown::Utils::StringScanner < ::StringScanner
+  # Takes the start line number as optional second argument.
+  #
+  # Note: The original second argument is no longer used so this should be safe.
+  #
+  # @return [StringScanner] a new instance of StringScanner
+  #
+  # source://kramdown//lib/kramdown/utils/string_scanner.rb#26
+  def initialize(string, start_line_number = T.unsafe(nil)); end
+
+  # Returns the line number for current charpos.
+  #
+  # NOTE: Requires that all line endings are normalized to '\n'
+  #
+  # NOTE: Normally we'd have to add one to the count of newlines to get the correct line number.
+  # However we add the one indirectly by using a one-based start_line_number.
+  #
+  # source://kramdown//lib/kramdown/utils/string_scanner.rb#67
+  def current_line_number; end
+
+  # Sets the byte position of the scan pointer.
+  #
+  # Note: This also resets some internal variables, so always use pos= when setting the position
+  # and don't use any other method for that!
+  #
+  # source://kramdown//lib/kramdown/utils/string_scanner.rb#37
+  def pos=(pos); end
+
+  # Revert the position to one saved by #save_pos.
+  #
+  # source://kramdown//lib/kramdown/utils/string_scanner.rb#56
+  def revert_pos(data); end
+
+  # Return information needed to revert the byte position of the string scanner in a performant
+  # way.
+  #
+  # The returned data can be fed to #revert_pos to revert the position to the saved one.
+  #
+  # Note: Just saving #pos won't be enough.
+  #
+  # source://kramdown//lib/kramdown/utils/string_scanner.rb#51
+  def save_pos; end
+
+  # The start line number. Used for nested StringScanners that scan a sub-string of the source
+  # document. The kramdown parser uses this, e.g., for span level parsers.
+  #
+  # source://kramdown//lib/kramdown/utils/string_scanner.rb#21
+  def start_line_number; end
+end
+
+# The kramdown version.
+#
+# source://kramdown//lib/kramdown/version.rb#13
+Kramdown::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/logger@1.6.1.rbi b/Library/Homebrew/sorbet/rbi/gems/logger@1.6.1.rbi
new file mode 100644
index 0000000000000..4e9ceacc7e68d
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/logger@1.6.1.rbi
@@ -0,0 +1,920 @@
+# typed: false
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `logger` gem.
+# Please instead update this file by running `bin/tapioca gem logger`.
+
+
+# \Class \Logger provides a simple but sophisticated logging utility that
+# you can use to create one or more
+# {event logs}[https://en.wikipedia.org/wiki/Logging_(software)#Event_logs]
+# for your program.
+# Each such log contains a chronological sequence of entries
+# that provides a record of the program's activities.
+#
+# == About the Examples
+#
+# All examples on this page assume that \Logger has been required:
+#
+#   require 'logger'
+#
+# == Synopsis
+#
+# Create a log with Logger.new:
+#
+#   # Single log file.
+#   logger = Logger.new('t.log')
+#   # Size-based rotated logging: 3 10-megabyte files.
+#   logger = Logger.new('t.log', 3, 10485760)
+#   # Period-based rotated logging: daily (also allowed: 'weekly', 'monthly').
+#   logger = Logger.new('t.log', 'daily')
+#   # Log to an IO stream.
+#   logger = Logger.new($stdout)
+#
+# Add entries (level, message) with Logger#add:
+#
+#   logger.add(Logger::DEBUG, 'Maximal debugging info')
+#   logger.add(Logger::INFO, 'Non-error information')
+#   logger.add(Logger::WARN, 'Non-error warning')
+#   logger.add(Logger::ERROR, 'Non-fatal error')
+#   logger.add(Logger::FATAL, 'Fatal error')
+#   logger.add(Logger::UNKNOWN, 'Most severe')
+#
+# Close the log with Logger#close:
+#
+#   logger.close
+#
+# == Entries
+#
+# You can add entries with method Logger#add:
+#
+#   logger.add(Logger::DEBUG, 'Maximal debugging info')
+#   logger.add(Logger::INFO, 'Non-error information')
+#   logger.add(Logger::WARN, 'Non-error warning')
+#   logger.add(Logger::ERROR, 'Non-fatal error')
+#   logger.add(Logger::FATAL, 'Fatal error')
+#   logger.add(Logger::UNKNOWN, 'Most severe')
+#
+# These shorthand methods also add entries:
+#
+#   logger.debug('Maximal debugging info')
+#   logger.info('Non-error information')
+#   logger.warn('Non-error warning')
+#   logger.error('Non-fatal error')
+#   logger.fatal('Fatal error')
+#   logger.unknown('Most severe')
+#
+# When you call any of these methods,
+# the entry may or may not be written to the log,
+# depending on the entry's severity and on the log level;
+# see {Log Level}[rdoc-ref:Logger@Log+Level]
+#
+# An entry always has:
+#
+# - A severity (the required argument to #add).
+# - An automatically created timestamp.
+#
+# And may also have:
+#
+# - A message.
+# - A program name.
+#
+# Example:
+#
+#   logger = Logger.new($stdout)
+#   logger.add(Logger::INFO, 'My message.', 'mung')
+#   # => I, [2022-05-07T17:21:46.536234 #20536]  INFO -- mung: My message.
+#
+# The default format for an entry is:
+#
+#   "%s, [%s #%d] %5s -- %s: %s\n"
+#
+# where the values to be formatted are:
+#
+# - \Severity (one letter).
+# - Timestamp.
+# - Process id.
+# - \Severity (word).
+# - Program name.
+# - Message.
+#
+# You can use a different entry format by:
+#
+# - Setting a custom format proc (affects following entries);
+#   see {formatter=}[Logger.html#attribute-i-formatter].
+# - Calling any of the methods above with a block
+#   (affects only the one entry).
+#   Doing so can have two benefits:
+#
+#   - Context: the block can evaluate the entire program context
+#     and create a context-dependent message.
+#   - Performance: the block is not evaluated unless the log level
+#     permits the entry actually to be written:
+#
+#       logger.error { my_slow_message_generator }
+#
+#     Contrast this with the string form, where the string is
+#     always evaluated, regardless of the log level:
+#
+#       logger.error("#{my_slow_message_generator}")
+#
+# === \Severity
+#
+# The severity of a log entry has two effects:
+#
+# - Determines whether the entry is selected for inclusion in the log;
+#   see {Log Level}[rdoc-ref:Logger@Log+Level].
+# - Indicates to any log reader (whether a person or a program)
+#   the relative importance of the entry.
+#
+# === Timestamp
+#
+# The timestamp for a log entry is generated automatically
+# when the entry is created.
+#
+# The logged timestamp is formatted by method
+# {Time#strftime}[https://docs.ruby-lang.org/en/master/Time.html#method-i-strftime]
+# using this format string:
+#
+#   '%Y-%m-%dT%H:%M:%S.%6N'
+#
+# Example:
+#
+#   logger = Logger.new($stdout)
+#   logger.add(Logger::INFO)
+#   # => I, [2022-05-07T17:04:32.318331 #20536]  INFO -- : nil
+#
+# You can set a different format using method #datetime_format=.
+#
+# === Message
+#
+# The message is an optional argument to an entry method:
+#
+#   logger = Logger.new($stdout)
+#   logger.add(Logger::INFO, 'My message')
+#   # => I, [2022-05-07T18:15:37.647581 #20536]  INFO -- : My message
+#
+# For the default entry formatter, <tt>Logger::Formatter</tt>,
+# the message object may be:
+#
+# - A string: used as-is.
+# - An Exception: <tt>message.message</tt> is used.
+# - Anything else: <tt>message.inspect</tt> is used.
+#
+# *Note*: Logger::Formatter does not escape or sanitize
+# the message passed to it.
+# Developers should be aware that malicious data (user input)
+# may be in the message, and should explicitly escape untrusted data.
+#
+# You can use a custom formatter to escape message data;
+# see the example at {formatter=}[Logger.html#attribute-i-formatter].
+#
+# === Program Name
+#
+# The program name is an optional argument to an entry method:
+#
+#   logger = Logger.new($stdout)
+#   logger.add(Logger::INFO, 'My message', 'mung')
+#   # => I, [2022-05-07T18:17:38.084716 #20536]  INFO -- mung: My message
+#
+# The default program name for a new logger may be set in the call to
+# Logger.new via optional keyword argument +progname+:
+#
+#   logger = Logger.new('t.log', progname: 'mung')
+#
+# The default program name for an existing logger may be set
+# by a call to method #progname=:
+#
+#   logger.progname = 'mung'
+#
+# The current program name may be retrieved with method
+# {progname}[Logger.html#attribute-i-progname]:
+#
+#   logger.progname # => "mung"
+#
+# == Log Level
+#
+# The log level setting determines whether an entry is actually
+# written to the log, based on the entry's severity.
+#
+# These are the defined severities (least severe to most severe):
+#
+#   logger = Logger.new($stdout)
+#   logger.add(Logger::DEBUG, 'Maximal debugging info')
+#   # => D, [2022-05-07T17:57:41.776220 #20536] DEBUG -- : Maximal debugging info
+#   logger.add(Logger::INFO, 'Non-error information')
+#   # => I, [2022-05-07T17:59:14.349167 #20536]  INFO -- : Non-error information
+#   logger.add(Logger::WARN, 'Non-error warning')
+#   # => W, [2022-05-07T18:00:45.337538 #20536]  WARN -- : Non-error warning
+#   logger.add(Logger::ERROR, 'Non-fatal error')
+#   # => E, [2022-05-07T18:02:41.592912 #20536] ERROR -- : Non-fatal error
+#   logger.add(Logger::FATAL, 'Fatal error')
+#   # => F, [2022-05-07T18:05:24.703931 #20536] FATAL -- : Fatal error
+#   logger.add(Logger::UNKNOWN, 'Most severe')
+#   # => A, [2022-05-07T18:07:54.657491 #20536]   ANY -- : Most severe
+#
+# The default initial level setting is Logger::DEBUG, the lowest level,
+# which means that all entries are to be written, regardless of severity:
+#
+#   logger = Logger.new($stdout)
+#   logger.level # => 0
+#   logger.add(0, "My message")
+#   # => D, [2022-05-11T15:10:59.773668 #20536] DEBUG -- : My message
+#
+# You can specify a different setting in a new logger
+# using keyword argument +level+ with an appropriate value:
+#
+#   logger = Logger.new($stdout, level: Logger::ERROR)
+#   logger = Logger.new($stdout, level: 'error')
+#   logger = Logger.new($stdout, level: :error)
+#   logger.level # => 3
+#
+# With this level, entries with severity Logger::ERROR and higher
+# are written, while those with lower severities are not written:
+#
+#   logger = Logger.new($stdout, level: Logger::ERROR)
+#   logger.add(3)
+#   # => E, [2022-05-11T15:17:20.933362 #20536] ERROR -- : nil
+#   logger.add(2) # Silent.
+#
+# You can set the log level for an existing logger
+# with method #level=:
+#
+#   logger.level = Logger::ERROR
+#
+# These shorthand methods also set the level:
+#
+#   logger.debug! # => 0
+#   logger.info!  # => 1
+#   logger.warn!  # => 2
+#   logger.error! # => 3
+#   logger.fatal! # => 4
+#
+# You can retrieve the log level with method #level.
+#
+#   logger.level = Logger::ERROR
+#   logger.level # => 3
+#
+# These methods return whether a given
+# level is to be written:
+#
+#   logger.level = Logger::ERROR
+#   logger.debug? # => false
+#   logger.info?  # => false
+#   logger.warn?  # => false
+#   logger.error? # => true
+#   logger.fatal? # => true
+#
+# == Log File Rotation
+#
+# By default, a log file is a single file that grows indefinitely
+# (until explicitly closed); there is no file rotation.
+#
+# To keep log files to a manageable size,
+# you can use _log_ _file_ _rotation_, which uses multiple log files:
+#
+# - Each log file has entries for a non-overlapping
+#   time interval.
+# - Only the most recent log file is open and active;
+#   the others are closed and inactive.
+#
+# === Size-Based Rotation
+#
+# For size-based log file rotation, call Logger.new with:
+#
+# - Argument +logdev+ as a file path.
+# - Argument +shift_age+ with a positive integer:
+#   the number of log files to be in the rotation.
+# - Argument +shift_size+ as a positive integer:
+#   the maximum size (in bytes) of each log file;
+#   defaults to 1048576 (1 megabyte).
+#
+# Examples:
+#
+#   logger = Logger.new('t.log', 3)           # Three 1-megabyte files.
+#   logger = Logger.new('t.log', 5, 10485760) # Five 10-megabyte files.
+#
+# For these examples, suppose:
+#
+#   logger = Logger.new('t.log', 3)
+#
+# Logging begins in the new log file, +t.log+;
+# the log file is "full" and ready for rotation
+# when a new entry would cause its size to exceed +shift_size+.
+#
+# The first time +t.log+ is full:
+#
+# - +t.log+ is closed and renamed to +t.log.0+.
+# - A new file +t.log+ is opened.
+#
+# The second time +t.log+ is full:
+#
+# - +t.log.0 is renamed as +t.log.1+.
+# - +t.log+ is closed and renamed to +t.log.0+.
+# - A new file +t.log+ is opened.
+#
+# Each subsequent time that +t.log+ is full,
+# the log files are rotated:
+#
+# - +t.log.1+ is removed.
+# - +t.log.0 is renamed as +t.log.1+.
+# - +t.log+ is closed and renamed to +t.log.0+.
+# - A new file +t.log+ is opened.
+#
+# === Periodic Rotation
+#
+# For periodic rotation, call Logger.new with:
+#
+# - Argument +logdev+ as a file path.
+# - Argument +shift_age+ as a string period indicator.
+#
+# Examples:
+#
+#   logger = Logger.new('t.log', 'daily')   # Rotate log files daily.
+#   logger = Logger.new('t.log', 'weekly')  # Rotate log files weekly.
+#   logger = Logger.new('t.log', 'monthly') # Rotate log files monthly.
+#
+# Example:
+#
+#   logger = Logger.new('t.log', 'daily')
+#
+# When the given period expires:
+#
+# - The base log file, +t.log+ is closed and renamed
+#   with a date-based suffix such as +t.log.20220509+.
+# - A new log file +t.log+ is opened.
+# - Nothing is removed.
+#
+# The default format for the suffix is <tt>'%Y%m%d'</tt>,
+# which produces a suffix similar to the one above.
+# You can set a different format using create-time option
+# +shift_period_suffix+;
+# see details and suggestions at
+# {Time#strftime}[https://docs.ruby-lang.org/en/master/Time.html#method-i-strftime].
+#
+# source://logger//lib/logger/version.rb#3
+class Logger
+  include ::Logger::Severity
+
+  # :call-seq:
+  #    Logger.new(logdev, shift_age = 0, shift_size = 1048576, **options)
+  #
+  # With the single argument +logdev+,
+  # returns a new logger with all default options:
+  #
+  #   Logger.new('t.log') # => #<Logger:0x000001e685dc6ac8>
+  #
+  # Argument +logdev+ must be one of:
+  #
+  # - A string filepath: entries are to be written
+  #   to the file at that path; if the file at that path exists,
+  #   new entries are appended.
+  # - An IO stream (typically +$stdout+, +$stderr+. or an open file):
+  #   entries are to be written to the given stream.
+  # - +nil+ or +File::NULL+: no entries are to be written.
+  #
+  # Examples:
+  #
+  #   Logger.new('t.log')
+  #   Logger.new($stdout)
+  #
+  # The keyword options are:
+  #
+  # - +level+: sets the log level; default value is Logger::DEBUG.
+  #   See {Log Level}[rdoc-ref:Logger@Log+Level]:
+  #
+  #     Logger.new('t.log', level: Logger::ERROR)
+  #
+  # - +progname+: sets the default program name; default is +nil+.
+  #   See {Program Name}[rdoc-ref:Logger@Program+Name]:
+  #
+  #     Logger.new('t.log', progname: 'mung')
+  #
+  # - +formatter+: sets the entry formatter; default is +nil+.
+  #   See {formatter=}[Logger.html#attribute-i-formatter].
+  # - +datetime_format+: sets the format for entry timestamp;
+  #   default is +nil+.
+  #   See #datetime_format=.
+  # - +binmode+: sets whether the logger writes in binary mode;
+  #   default is +false+.
+  # - +shift_period_suffix+: sets the format for the filename suffix
+  #   for periodic log file rotation; default is <tt>'%Y%m%d'</tt>.
+  #   See {Periodic Rotation}[rdoc-ref:Logger@Periodic+Rotation].
+  # - +reraise_write_errors+: An array of exception classes, which will
+  #   be reraised if there is an error when writing to the log device.
+  #   The default is to swallow all exceptions raised.
+  #
+  # @return [Logger] a new instance of Logger
+  #
+  # source://logger//lib/logger.rb#581
+  def initialize(logdev, shift_age = T.unsafe(nil), shift_size = T.unsafe(nil), level: T.unsafe(nil), progname: T.unsafe(nil), formatter: T.unsafe(nil), datetime_format: T.unsafe(nil), binmode: T.unsafe(nil), shift_period_suffix: T.unsafe(nil), reraise_write_errors: T.unsafe(nil)); end
+
+  # Writes the given +msg+ to the log with no formatting;
+  # returns the number of characters written,
+  # or +nil+ if no log device exists:
+  #
+  #   logger = Logger.new($stdout)
+  #   logger << 'My message.' # => 10
+  #
+  # Output:
+  #
+  #   My message.
+  #
+  # source://logger//lib/logger.rb#689
+  def <<(msg); end
+
+  # Creates a log entry, which may or may not be written to the log,
+  # depending on the entry's severity and on the log level.
+  # See {Log Level}[rdoc-ref:Logger@Log+Level]
+  # and {Entries}[rdoc-ref:Logger@Entries] for details.
+  #
+  # Examples:
+  #
+  #   logger = Logger.new($stdout, progname: 'mung')
+  #   logger.add(Logger::INFO)
+  #   logger.add(Logger::ERROR, 'No good')
+  #   logger.add(Logger::ERROR, 'No good', 'gnum')
+  #
+  # Output:
+  #
+  #   I, [2022-05-12T16:25:31.469726 #36328]  INFO -- mung: mung
+  #   E, [2022-05-12T16:25:55.349414 #36328] ERROR -- mung: No good
+  #   E, [2022-05-12T16:26:35.841134 #36328] ERROR -- gnum: No good
+  #
+  # These convenience methods have implicit severity:
+  #
+  # - #debug.
+  # - #info.
+  # - #warn.
+  # - #error.
+  # - #fatal.
+  # - #unknown.
+  #
+  # source://logger//lib/logger.rb#656
+  def add(severity, message = T.unsafe(nil), progname = T.unsafe(nil)); end
+
+  # Closes the logger; returns +nil+:
+  #
+  #   logger = Logger.new('t.log')
+  #   logger.close       # => nil
+  #   logger.info('foo') # Prints "log writing failed. closed stream"
+  #
+  # Related: Logger#reopen.
+  #
+  # source://logger//lib/logger.rb#736
+  def close; end
+
+  # Returns the date-time format; see #datetime_format=.
+  #
+  # source://logger//lib/logger.rb#438
+  def datetime_format; end
+
+  # Sets the date-time format.
+  #
+  # Argument +datetime_format+ should be either of these:
+  #
+  # - A string suitable for use as a format for method
+  #   {Time#strftime}[https://docs.ruby-lang.org/en/master/Time.html#method-i-strftime].
+  # - +nil+: the logger uses <tt>'%Y-%m-%dT%H:%M:%S.%6N'</tt>.
+  #
+  # source://logger//lib/logger.rb#432
+  def datetime_format=(datetime_format); end
+
+  # Equivalent to calling #add with severity <tt>Logger::DEBUG</tt>.
+  #
+  # source://logger//lib/logger.rb#695
+  def debug(progname = T.unsafe(nil), &block); end
+
+  # Sets the log level to Logger::DEBUG.
+  # See {Log Level}[rdoc-ref:Logger@Log+Level].
+  #
+  # source://logger//lib/logger.rb#487
+  def debug!; end
+
+  # Returns +true+ if the log level allows entries with severity
+  # Logger::DEBUG to be written, +false+ otherwise.
+  # See {Log Level}[rdoc-ref:Logger@Log+Level].
+  #
+  # @return [Boolean]
+  #
+  # source://logger//lib/logger.rb#482
+  def debug?; end
+
+  # Equivalent to calling #add with severity <tt>Logger::ERROR</tt>.
+  #
+  # source://logger//lib/logger.rb#713
+  def error(progname = T.unsafe(nil), &block); end
+
+  # Sets the log level to Logger::ERROR.
+  # See {Log Level}[rdoc-ref:Logger@Log+Level].
+  #
+  # source://logger//lib/logger.rb#520
+  def error!; end
+
+  # Returns +true+ if the log level allows entries with severity
+  # Logger::ERROR to be written, +false+ otherwise.
+  # See {Log Level}[rdoc-ref:Logger@Log+Level].
+  #
+  # @return [Boolean]
+  #
+  # source://logger//lib/logger.rb#515
+  def error?; end
+
+  # Equivalent to calling #add with severity <tt>Logger::FATAL</tt>.
+  #
+  # source://logger//lib/logger.rb#719
+  def fatal(progname = T.unsafe(nil), &block); end
+
+  # Sets the log level to Logger::FATAL.
+  # See {Log Level}[rdoc-ref:Logger@Log+Level].
+  #
+  # source://logger//lib/logger.rb#531
+  def fatal!; end
+
+  # Returns +true+ if the log level allows entries with severity
+  # Logger::FATAL to be written, +false+ otherwise.
+  # See {Log Level}[rdoc-ref:Logger@Log+Level].
+  #
+  # @return [Boolean]
+  #
+  # source://logger//lib/logger.rb#526
+  def fatal?; end
+
+  # Sets or retrieves the logger entry formatter proc.
+  #
+  # When +formatter+ is +nil+, the logger uses Logger::Formatter.
+  #
+  # When +formatter+ is a proc, a new entry is formatted by the proc,
+  # which is called with four arguments:
+  #
+  # - +severity+: The severity of the entry.
+  # - +time+: A Time object representing the entry's timestamp.
+  # - +progname+: The program name for the entry.
+  # - +msg+: The message for the entry (string or string-convertible object).
+  #
+  # The proc should return a string containing the formatted entry.
+  #
+  # This custom formatter uses
+  # {String#dump}[https://docs.ruby-lang.org/en/master/String.html#method-i-dump]
+  # to escape the message string:
+  #
+  #   logger = Logger.new($stdout, progname: 'mung')
+  #   original_formatter = logger.formatter || Logger::Formatter.new
+  #   logger.formatter = proc { |severity, time, progname, msg|
+  #     original_formatter.call(severity, time, progname, msg.dump)
+  #   }
+  #   logger.add(Logger::INFO, "hello \n ''")
+  #   logger.add(Logger::INFO, "\f\x00\xff\\\"")
+  #
+  # Output:
+  #
+  #   I, [2022-05-13T13:16:29.637488 #8492]  INFO -- mung: "hello \n ''"
+  #   I, [2022-05-13T13:16:29.637610 #8492]  INFO -- mung: "\f\x00\xFF\\\""
+  #
+  # source://logger//lib/logger.rb#473
+  def formatter; end
+
+  # Sets or retrieves the logger entry formatter proc.
+  #
+  # When +formatter+ is +nil+, the logger uses Logger::Formatter.
+  #
+  # When +formatter+ is a proc, a new entry is formatted by the proc,
+  # which is called with four arguments:
+  #
+  # - +severity+: The severity of the entry.
+  # - +time+: A Time object representing the entry's timestamp.
+  # - +progname+: The program name for the entry.
+  # - +msg+: The message for the entry (string or string-convertible object).
+  #
+  # The proc should return a string containing the formatted entry.
+  #
+  # This custom formatter uses
+  # {String#dump}[https://docs.ruby-lang.org/en/master/String.html#method-i-dump]
+  # to escape the message string:
+  #
+  #   logger = Logger.new($stdout, progname: 'mung')
+  #   original_formatter = logger.formatter || Logger::Formatter.new
+  #   logger.formatter = proc { |severity, time, progname, msg|
+  #     original_formatter.call(severity, time, progname, msg.dump)
+  #   }
+  #   logger.add(Logger::INFO, "hello \n ''")
+  #   logger.add(Logger::INFO, "\f\x00\xff\\\"")
+  #
+  # Output:
+  #
+  #   I, [2022-05-13T13:16:29.637488 #8492]  INFO -- mung: "hello \n ''"
+  #   I, [2022-05-13T13:16:29.637610 #8492]  INFO -- mung: "\f\x00\xFF\\\""
+  #
+  # source://logger//lib/logger.rb#473
+  def formatter=(_arg0); end
+
+  # Equivalent to calling #add with severity <tt>Logger::INFO</tt>.
+  #
+  # source://logger//lib/logger.rb#701
+  def info(progname = T.unsafe(nil), &block); end
+
+  # Sets the log level to Logger::INFO.
+  # See {Log Level}[rdoc-ref:Logger@Log+Level].
+  #
+  # source://logger//lib/logger.rb#498
+  def info!; end
+
+  # Returns +true+ if the log level allows entries with severity
+  # Logger::INFO to be written, +false+ otherwise.
+  # See {Log Level}[rdoc-ref:Logger@Log+Level].
+  #
+  # @return [Boolean]
+  #
+  # source://logger//lib/logger.rb#493
+  def info?; end
+
+  # Logging severity threshold (e.g. <tt>Logger::INFO</tt>).
+  #
+  # source://logger//lib/logger.rb#383
+  def level; end
+
+  # Sets the log level; returns +severity+.
+  # See {Log Level}[rdoc-ref:Logger@Log+Level].
+  #
+  # Argument +severity+ may be an integer, a string, or a symbol:
+  #
+  #   logger.level = Logger::ERROR # => 3
+  #   logger.level = 3             # => 3
+  #   logger.level = 'error'       # => "error"
+  #   logger.level = :error        # => :error
+  #
+  # Logger#sev_threshold= is an alias for Logger#level=.
+  #
+  # source://logger//lib/logger.rb#399
+  def level=(severity); end
+
+  # Creates a log entry, which may or may not be written to the log,
+  # depending on the entry's severity and on the log level.
+  # See {Log Level}[rdoc-ref:Logger@Log+Level]
+  # and {Entries}[rdoc-ref:Logger@Entries] for details.
+  #
+  # Examples:
+  #
+  #   logger = Logger.new($stdout, progname: 'mung')
+  #   logger.add(Logger::INFO)
+  #   logger.add(Logger::ERROR, 'No good')
+  #   logger.add(Logger::ERROR, 'No good', 'gnum')
+  #
+  # Output:
+  #
+  #   I, [2022-05-12T16:25:31.469726 #36328]  INFO -- mung: mung
+  #   E, [2022-05-12T16:25:55.349414 #36328] ERROR -- mung: No good
+  #   E, [2022-05-12T16:26:35.841134 #36328] ERROR -- gnum: No good
+  #
+  # These convenience methods have implicit severity:
+  #
+  # - #debug.
+  # - #info.
+  # - #warn.
+  # - #error.
+  # - #fatal.
+  # - #unknown.
+  #
+  # source://logger//lib/logger.rb#656
+  def log(severity, message = T.unsafe(nil), progname = T.unsafe(nil)); end
+
+  # Program name to include in log messages.
+  #
+  # source://logger//lib/logger.rb#422
+  def progname; end
+
+  # Program name to include in log messages.
+  #
+  # source://logger//lib/logger.rb#422
+  def progname=(_arg0); end
+
+  # Sets the logger's output stream:
+  #
+  # - If +logdev+ is +nil+, reopens the current output stream.
+  # - If +logdev+ is a filepath, opens the indicated file for append.
+  # - If +logdev+ is an IO stream
+  #   (usually <tt>$stdout</tt>, <tt>$stderr</tt>, or an open File object),
+  #   opens the stream for append.
+  #
+  # Example:
+  #
+  #   logger = Logger.new('t.log')
+  #   logger.add(Logger::ERROR, 'one')
+  #   logger.close
+  #   logger.add(Logger::ERROR, 'two') # Prints 'log writing failed. closed stream'
+  #   logger.reopen
+  #   logger.add(Logger::ERROR, 'three')
+  #   logger.close
+  #   File.readlines('t.log')
+  #   # =>
+  #   # ["# Logfile created on 2022-05-12 14:21:19 -0500 by logger.rb/v1.5.0\n",
+  #   #  "E, [2022-05-12T14:21:27.596726 #22428] ERROR -- : one\n",
+  #   #  "E, [2022-05-12T14:23:05.847241 #22428] ERROR -- : three\n"]
+  #
+  # source://logger//lib/logger.rb#624
+  def reopen(logdev = T.unsafe(nil)); end
+
+  # Logging severity threshold (e.g. <tt>Logger::INFO</tt>).
+  #
+  # source://logger//lib/logger.rb#383
+  def sev_threshold; end
+
+  # Sets the log level; returns +severity+.
+  # See {Log Level}[rdoc-ref:Logger@Log+Level].
+  #
+  # Argument +severity+ may be an integer, a string, or a symbol:
+  #
+  #   logger.level = Logger::ERROR # => 3
+  #   logger.level = 3             # => 3
+  #   logger.level = 'error'       # => "error"
+  #   logger.level = :error        # => :error
+  #
+  # Logger#sev_threshold= is an alias for Logger#level=.
+  #
+  # source://logger//lib/logger.rb#399
+  def sev_threshold=(severity); end
+
+  # Equivalent to calling #add with severity <tt>Logger::UNKNOWN</tt>.
+  #
+  # source://logger//lib/logger.rb#725
+  def unknown(progname = T.unsafe(nil), &block); end
+
+  # Equivalent to calling #add with severity <tt>Logger::WARN</tt>.
+  #
+  # source://logger//lib/logger.rb#707
+  def warn(progname = T.unsafe(nil), &block); end
+
+  # Sets the log level to Logger::WARN.
+  # See {Log Level}[rdoc-ref:Logger@Log+Level].
+  #
+  # source://logger//lib/logger.rb#509
+  def warn!; end
+
+  # Returns +true+ if the log level allows entries with severity
+  # Logger::WARN to be written, +false+ otherwise.
+  # See {Log Level}[rdoc-ref:Logger@Log+Level].
+  #
+  # @return [Boolean]
+  #
+  # source://logger//lib/logger.rb#504
+  def warn?; end
+
+  # Adjust the log level during the block execution for the current Fiber only
+  #
+  #   logger.with_level(:debug) do
+  #     logger.debug { "Hello" }
+  #   end
+  #
+  # source://logger//lib/logger.rb#408
+  def with_level(severity); end
+
+  private
+
+  # source://logger//lib/logger.rb#754
+  def format_message(severity, datetime, progname, msg); end
+
+  # source://logger//lib/logger.rb#745
+  def format_severity(severity); end
+
+  # Guarantee the existence of this ivar even when subclasses don't call the superclass constructor.
+  #
+  # source://logger//lib/logger.rb#750
+  def level_override; end
+end
+
+# Default formatter for log messages.
+#
+# source://logger//lib/logger/formatter.rb#5
+class Logger::Formatter
+  # @return [Formatter] a new instance of Formatter
+  #
+  # source://logger//lib/logger/formatter.rb#11
+  def initialize; end
+
+  # source://logger//lib/logger/formatter.rb#15
+  def call(severity, time, progname, msg); end
+
+  # Returns the value of attribute datetime_format.
+  #
+  # source://logger//lib/logger/formatter.rb#9
+  def datetime_format; end
+
+  # Sets the attribute datetime_format
+  #
+  # @param value the value to set the attribute datetime_format to.
+  #
+  # source://logger//lib/logger/formatter.rb#9
+  def datetime_format=(_arg0); end
+
+  private
+
+  # source://logger//lib/logger/formatter.rb#21
+  def format_datetime(time); end
+
+  # source://logger//lib/logger/formatter.rb#25
+  def msg2str(msg); end
+end
+
+# source://logger//lib/logger/formatter.rb#7
+Logger::Formatter::DatetimeFormat = T.let(T.unsafe(nil), String)
+
+# source://logger//lib/logger/formatter.rb#6
+Logger::Formatter::Format = T.let(T.unsafe(nil), String)
+
+# Device used for logging messages.
+#
+# source://logger//lib/logger/log_device.rb#7
+class Logger::LogDevice
+  include ::Logger::Period
+  include ::MonitorMixin
+
+  # @return [LogDevice] a new instance of LogDevice
+  #
+  # source://logger//lib/logger/log_device.rb#14
+  def initialize(log = T.unsafe(nil), shift_age: T.unsafe(nil), shift_size: T.unsafe(nil), shift_period_suffix: T.unsafe(nil), binmode: T.unsafe(nil), reraise_write_errors: T.unsafe(nil)); end
+
+  # source://logger//lib/logger/log_device.rb#59
+  def close; end
+
+  # Returns the value of attribute dev.
+  #
+  # source://logger//lib/logger/log_device.rb#10
+  def dev; end
+
+  # Returns the value of attribute filename.
+  #
+  # source://logger//lib/logger/log_device.rb#11
+  def filename; end
+
+  # source://logger//lib/logger/log_device.rb#69
+  def reopen(log = T.unsafe(nil)); end
+
+  # source://logger//lib/logger/log_device.rb#32
+  def write(message); end
+
+  private
+
+  # source://logger//lib/logger/log_device.rb#126
+  def add_log_header(file); end
+
+  # source://logger//lib/logger/log_device.rb#132
+  def check_shift_log; end
+
+  # source://logger//lib/logger/log_device.rb#110
+  def create_logfile(filename); end
+
+  # source://logger//lib/logger/log_device.rb#152
+  def lock_shift_log; end
+
+  # source://logger//lib/logger/log_device.rb#102
+  def open_logfile(filename); end
+
+  # source://logger//lib/logger/log_device.rb#86
+  def set_dev(log); end
+
+  # source://logger//lib/logger/log_device.rb#183
+  def shift_log_age; end
+
+  # source://logger//lib/logger/log_device.rb#195
+  def shift_log_period(period_end); end
+end
+
+# source://logger//lib/logger/period.rb#4
+module Logger::Period
+  private
+
+  # source://logger//lib/logger/period.rb#9
+  def next_rotate_time(now, shift_age); end
+
+  # source://logger//lib/logger/period.rb#31
+  def previous_period_end(now, shift_age); end
+
+  class << self
+    # source://logger//lib/logger/period.rb#9
+    def next_rotate_time(now, shift_age); end
+
+    # source://logger//lib/logger/period.rb#31
+    def previous_period_end(now, shift_age); end
+  end
+end
+
+# source://logger//lib/logger/period.rb#7
+Logger::Period::SiD = T.let(T.unsafe(nil), Integer)
+
+# \Severity label for logging (max 5 chars).
+#
+# source://logger//lib/logger.rb#743
+Logger::SEV_LABEL = T.let(T.unsafe(nil), Array)
+
+# Logging severity.
+#
+# source://logger//lib/logger/severity.rb#5
+module Logger::Severity
+  class << self
+    # source://logger//lib/logger/severity.rb#29
+    def coerce(severity); end
+  end
+end
+
+# source://logger//lib/logger/severity.rb#19
+Logger::Severity::LEVELS = T.let(T.unsafe(nil), Hash)
diff --git a/Library/Homebrew/sorbet/rbi/gems/mechanize@2.8.5.rbi b/Library/Homebrew/sorbet/rbi/gems/mechanize@2.8.5.rbi
deleted file mode 100644
index fd2e6eff7afae..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/mechanize@2.8.5.rbi
+++ /dev/null
@@ -1,1134 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `mechanize` gem.
-# Please instead update this file by running `bin/tapioca gem mechanize`.
-
-class HTTP::CookieJar
-  include ::Mechanize::CookieDeprecated
-  include ::Mechanize::CookieJarIMethods
-  include ::Enumerable
-
-  def initialize(options = T.unsafe(nil)); end
-
-  def <<(cookie); end
-  def cleanup(session = T.unsafe(nil)); end
-  def clear; end
-  def cookies(url = T.unsafe(nil)); end
-  def delete(cookie); end
-  def each(uri = T.unsafe(nil), &block); end
-  def empty?(url = T.unsafe(nil)); end
-  def load(readable, *options); end
-  def parse(set_cookie, origin, options = T.unsafe(nil)); end
-  def save(writable, *options); end
-  def store; end
-
-  private
-
-  def get_impl(base, value, *args); end
-  def initialize_copy(other); end
-
-  class << self
-    def const_missing(name); end
-  end
-end
-
-class Mechanize
-  def initialize(connection_name = T.unsafe(nil)); end
-
-  def add_auth(uri, user, password, realm = T.unsafe(nil), domain = T.unsafe(nil)); end
-  def agent; end
-  def auth(user, password, domain = T.unsafe(nil)); end
-  def back; end
-  def basic_auth(user, password, domain = T.unsafe(nil)); end
-  def ca_file; end
-  def ca_file=(ca_file); end
-  def cert; end
-  def cert=(cert); end
-  def cert_store; end
-  def cert_store=(cert_store); end
-  def certificate; end
-  def click(link); end
-  def conditional_requests; end
-  def conditional_requests=(enabled); end
-  def content_encoding_hooks; end
-  def cookie_jar; end
-  def cookie_jar=(cookie_jar); end
-  def cookies; end
-  def current_page; end
-  def default_encoding; end
-  def default_encoding=(_arg0); end
-  def delete(uri, query_params = T.unsafe(nil), headers = T.unsafe(nil)); end
-  def download(uri, io_or_filename, parameters = T.unsafe(nil), referer = T.unsafe(nil), headers = T.unsafe(nil)); end
-  def follow_meta_refresh; end
-  def follow_meta_refresh=(follow); end
-  def follow_meta_refresh_self; end
-  def follow_meta_refresh_self=(follow); end
-  def follow_redirect=(follow); end
-  def follow_redirect?; end
-  def force_default_encoding; end
-  def force_default_encoding=(_arg0); end
-  def get(uri, parameters = T.unsafe(nil), referer = T.unsafe(nil), headers = T.unsafe(nil)); end
-  def get_file(url); end
-  def gzip_enabled; end
-  def gzip_enabled=(enabled); end
-  def head(uri, query_params = T.unsafe(nil), headers = T.unsafe(nil)); end
-  def history; end
-  def history_added; end
-  def history_added=(_arg0); end
-  def html_parser; end
-  def html_parser=(_arg0); end
-  def idle_timeout; end
-  def idle_timeout=(idle_timeout); end
-  def ignore_bad_chunking; end
-  def ignore_bad_chunking=(ignore_bad_chunking); end
-  def keep_alive; end
-  def keep_alive=(enable); end
-  def keep_alive_time; end
-  def keep_alive_time=(_arg0); end
-  def key; end
-  def key=(key); end
-  def log; end
-  def log=(logger); end
-  def max_file_buffer; end
-  def max_file_buffer=(bytes); end
-  def max_history; end
-  def max_history=(length); end
-  def open_timeout; end
-  def open_timeout=(open_timeout); end
-  def page; end
-  def parse(uri, response, body); end
-  def pass; end
-  def pass=(pass); end
-  def pluggable_parser; end
-  def post(uri, query = T.unsafe(nil), headers = T.unsafe(nil)); end
-  def post_connect_hooks; end
-  def pre_connect_hooks; end
-  def pretty_print(q); end
-  def proxy_addr; end
-  def proxy_pass; end
-  def proxy_port; end
-  def proxy_user; end
-  def put(uri, entity, headers = T.unsafe(nil)); end
-  def read_timeout; end
-  def read_timeout=(read_timeout); end
-  def redirect_ok; end
-  def redirect_ok=(follow); end
-  def redirection_limit; end
-  def redirection_limit=(limit); end
-  def request_headers; end
-  def request_headers=(request_headers); end
-  def request_with_entity(verb, uri, entity, headers = T.unsafe(nil)); end
-  def reset; end
-  def resolve(link); end
-  def retry_change_requests; end
-  def retry_change_requests=(retry_change_requests); end
-  def robots; end
-  def robots=(enabled); end
-  def scheme_handlers; end
-  def scheme_handlers=(scheme_handlers); end
-  def set_proxy(address, port, user = T.unsafe(nil), password = T.unsafe(nil)); end
-  def shutdown; end
-  def ssl_version; end
-  def ssl_version=(ssl_version); end
-  def submit(form, button = T.unsafe(nil), headers = T.unsafe(nil)); end
-  def transact; end
-  def user_agent; end
-  def user_agent=(user_agent); end
-  def user_agent_alias=(name); end
-  def verify_callback; end
-  def verify_callback=(verify_callback); end
-  def verify_mode; end
-  def verify_mode=(verify_mode); end
-  def visited?(url); end
-  def visited_page(url); end
-  def watch_for_set; end
-  def watch_for_set=(_arg0); end
-
-  private
-
-  def add_to_history(page); end
-  def post_form(uri, form, headers = T.unsafe(nil)); end
-
-  class << self
-    def html_parser; end
-    def html_parser=(_arg0); end
-    def inherited(child); end
-    def log; end
-    def log=(_arg0); end
-    def start; end
-  end
-end
-
-Mechanize::AGENT_ALIASES = T.let(T.unsafe(nil), Hash)
-class Mechanize::ChunkedTerminationError < ::Mechanize::ResponseReadError; end
-
-class Mechanize::ContentTypeError < ::Mechanize::Error
-  def initialize(content_type); end
-
-  def content_type; end
-end
-
-Mechanize::Cookie = HTTP::Cookie
-
-module Mechanize::CookieCMethods
-  include ::Mechanize::CookieDeprecated
-
-  def parse(arg1, arg2, arg3 = T.unsafe(nil), &block); end
-end
-
-module Mechanize::CookieDeprecated
-  private
-
-  def __deprecated__(to = T.unsafe(nil)); end
-end
-
-module Mechanize::CookieIMethods
-  include ::Mechanize::CookieDeprecated
-
-  def set_domain(domain); end
-end
-
-class Mechanize::CookieJar < ::HTTP::CookieJar
-  def load(input, *options); end
-  def save(output, *options); end
-
-  private
-
-  def load_yaml(yaml); end
-end
-
-module Mechanize::CookieJarIMethods
-  include ::Mechanize::CookieDeprecated
-
-  def add(arg1, arg2 = T.unsafe(nil)); end
-  def add!(cookie); end
-  def clear!; end
-  def dump_cookiestxt(io); end
-  def jar; end
-  def load_cookiestxt(io); end
-  def save_as(filename, *options); end
-end
-
-class Mechanize::DirectorySaver < ::Mechanize::Download
-  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body_io = T.unsafe(nil), code = T.unsafe(nil)); end
-
-  class << self
-    def decode_filename?; end
-    def directory; end
-    def overwrite?; end
-    def save_to(directory, options = T.unsafe(nil)); end
-  end
-end
-
-class Mechanize::Download
-  include ::Mechanize::Parser
-
-  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body_io = T.unsafe(nil), code = T.unsafe(nil)); end
-
-  def body; end
-  def body_io; end
-  def content; end
-  def filename; end
-  def filename=(_arg0); end
-  def save(filename = T.unsafe(nil)); end
-  def save!(filename = T.unsafe(nil)); end
-  def save_as(filename = T.unsafe(nil)); end
-end
-
-module Mechanize::ElementMatcher
-  def elements_with(singular, plural = T.unsafe(nil)); end
-end
-
-class Mechanize::ElementNotFoundError < ::Mechanize::Error
-  def initialize(source, element, conditions); end
-
-  def conditions; end
-  def element; end
-  def source; end
-end
-
-class Mechanize::Error < ::RuntimeError; end
-
-class Mechanize::File
-  include ::Mechanize::Parser
-
-  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body = T.unsafe(nil), code = T.unsafe(nil)); end
-
-  def body; end
-  def body=(_arg0); end
-  def content; end
-  def filename; end
-  def filename=(_arg0); end
-  def save(filename = T.unsafe(nil)); end
-  def save!(filename = T.unsafe(nil)); end
-  def save_as(filename = T.unsafe(nil)); end
-end
-
-class Mechanize::FileConnection
-  def request(uri, request); end
-
-  class << self
-    def new(*a); end
-  end
-end
-
-class Mechanize::FileRequest
-  def initialize(uri); end
-
-  def []=(*a); end
-  def add_field(*a); end
-  def each_header; end
-  def path; end
-  def response_body_permitted?; end
-  def uri; end
-  def uri=(_arg0); end
-end
-
-class Mechanize::FileResponse
-  def initialize(file_path); end
-
-  def [](key); end
-  def code; end
-  def content_length; end
-  def each; end
-  def each_header; end
-  def file_path; end
-  def get_fields(key); end
-  def http_version; end
-  def message; end
-  def read_body; end
-  def uri; end
-
-  private
-
-  def dir_body; end
-  def directory?; end
-end
-
-class Mechanize::FileSaver < ::Mechanize::Download
-  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body_io = T.unsafe(nil), code = T.unsafe(nil)); end
-
-  def filename; end
-  def save_as(filename = T.unsafe(nil)); end
-end
-
-class Mechanize::Form
-  extend ::Forwardable
-  extend ::Mechanize::ElementMatcher
-
-  def initialize(node, mech = T.unsafe(nil), page = T.unsafe(nil)); end
-
-  def [](field_name); end
-  def []=(field_name, value); end
-  def action; end
-  def action=(_arg0); end
-  def add_button_to_query(button); end
-  def add_field!(field_name, value = T.unsafe(nil)); end
-  def at(*args, &block); end
-  def at_css(*args, &block); end
-  def at_xpath(*args, &block); end
-  def build_query(buttons = T.unsafe(nil)); end
-  def button(criteria = T.unsafe(nil)); end
-  def button_with(criteria = T.unsafe(nil)); end
-  def button_with!(criteria = T.unsafe(nil)); end
-  def buttons; end
-  def buttons_with(criteria = T.unsafe(nil)); end
-  def checkbox(criteria = T.unsafe(nil)); end
-  def checkbox_with(criteria = T.unsafe(nil)); end
-  def checkbox_with!(criteria = T.unsafe(nil)); end
-  def checkboxes; end
-  def checkboxes_with(criteria = T.unsafe(nil)); end
-  def click_button(button = T.unsafe(nil)); end
-  def css(*args, &block); end
-  def delete_field!(field_name); end
-  def dom_class; end
-  def dom_id; end
-  def elements; end
-  def encoding; end
-  def encoding=(_arg0); end
-  def enctype; end
-  def enctype=(_arg0); end
-  def field(criteria = T.unsafe(nil)); end
-  def field_with(criteria = T.unsafe(nil)); end
-  def field_with!(criteria = T.unsafe(nil)); end
-  def fields; end
-  def fields_with(criteria = T.unsafe(nil)); end
-  def file_upload(criteria = T.unsafe(nil)); end
-  def file_upload_with(criteria = T.unsafe(nil)); end
-  def file_upload_with!(criteria = T.unsafe(nil)); end
-  def file_uploads; end
-  def file_uploads_with(criteria = T.unsafe(nil)); end
-  def form_node; end
-  def has_field?(field_name); end
-  def has_key?(field_name); end
-  def has_value?(value); end
-  def hidden_field?(field_name); end
-  def hiddens; end
-  def ignore_encoding_error; end
-  def ignore_encoding_error=(_arg0); end
-  def inspect; end
-  def keygens; end
-  def keys; end
-  def method; end
-  def method=(_arg0); end
-  def method_missing(meth, *args); end
-  def name; end
-  def name=(_arg0); end
-  def node; end
-  def page; end
-  def pretty_print(q); end
-  def radiobutton(criteria = T.unsafe(nil)); end
-  def radiobutton_with(criteria = T.unsafe(nil)); end
-  def radiobutton_with!(criteria = T.unsafe(nil)); end
-  def radiobuttons; end
-  def radiobuttons_with(criteria = T.unsafe(nil)); end
-  def request_data; end
-  def reset; end
-  def reset_button?(button_name); end
-  def resets; end
-  def save_hash_field_order; end
-  def search(*args, &block); end
-  def select_buttons(selector, method = T.unsafe(nil)); end
-  def select_checkboxes(selector, method = T.unsafe(nil)); end
-  def select_fields(selector, method = T.unsafe(nil)); end
-  def select_file_uploads(selector, method = T.unsafe(nil)); end
-  def select_radiobuttons(selector, method = T.unsafe(nil)); end
-  def set_fields(fields = T.unsafe(nil)); end
-  def submit(button = T.unsafe(nil), headers = T.unsafe(nil)); end
-  def submit_button?(button_name); end
-  def submits; end
-  def text_field?(field_name); end
-  def textarea_field?(field_name); end
-  def textareas; end
-  def texts; end
-  def values; end
-  def xpath(*args, &block); end
-
-  private
-
-  def file_to_multipart(file, buf = T.unsafe(nil)); end
-  def from_native_charset(str); end
-  def mime_value_quote(str); end
-  def param_to_multipart(name, value, buf = T.unsafe(nil)); end
-  def parse; end
-  def proc_query(field); end
-  def rand_string(len = T.unsafe(nil)); end
-end
-
-class Mechanize::Form::Button < ::Mechanize::Form::Field; end
-Mechanize::Form::CRLF = T.let(T.unsafe(nil), String)
-
-class Mechanize::Form::CheckBox < ::Mechanize::Form::RadioButton
-  def inspect; end
-  def query_value; end
-end
-
-class Mechanize::Form::Field
-  extend ::Forwardable
-
-  def initialize(node, value = T.unsafe(nil)); end
-
-  def <=>(other); end
-  def at(*args, &block); end
-  def at_css(*args, &block); end
-  def at_xpath(*args, &block); end
-  def css(*args, &block); end
-  def dom_class; end
-  def dom_id; end
-  def index; end
-  def index=(_arg0); end
-  def inspect; end
-  def name; end
-  def name=(_arg0); end
-  def node; end
-  def node=(_arg0); end
-  def query_value; end
-  def raw_value; end
-  def search(*args, &block); end
-  def type; end
-  def type=(_arg0); end
-  def value; end
-  def value=(_arg0); end
-  def xpath(*args, &block); end
-end
-
-class Mechanize::Form::FileUpload < ::Mechanize::Form::Field
-  def initialize(node, file_name); end
-
-  def file_data; end
-  def file_data=(_arg0); end
-  def file_name; end
-  def file_name=(_arg0); end
-  def mime_type; end
-  def mime_type=(_arg0); end
-end
-
-class Mechanize::Form::Hidden < ::Mechanize::Form::Field; end
-
-class Mechanize::Form::ImageButton < ::Mechanize::Form::Button
-  def initialize(*args); end
-
-  def query_value; end
-  def x; end
-  def x=(_arg0); end
-  def y; end
-  def y=(_arg0); end
-end
-
-class Mechanize::Form::Keygen < ::Mechanize::Form::Field
-  def initialize(node, value = T.unsafe(nil)); end
-
-  def challenge; end
-  def generate_key(key_size = T.unsafe(nil)); end
-  def key; end
-end
-
-class Mechanize::Form::MultiSelectList < ::Mechanize::Form::Field
-  extend ::Mechanize::ElementMatcher
-
-  def initialize(node); end
-
-  def option(criteria = T.unsafe(nil)); end
-  def option_with(criteria = T.unsafe(nil)); end
-  def option_with!(criteria = T.unsafe(nil)); end
-  def options; end
-  def options=(_arg0); end
-  def options_with(criteria = T.unsafe(nil)); end
-  def query_value; end
-  def select_all; end
-  def select_none; end
-  def select_options(selector, method = T.unsafe(nil)); end
-  def selected_options; end
-  def value; end
-  def value=(values); end
-end
-
-class Mechanize::Form::Option
-  def initialize(node, select_list); end
-
-  def click; end
-  def node; end
-  def select; end
-  def select_list; end
-  def selected; end
-  def selected?; end
-  def text; end
-  def tick; end
-  def to_s; end
-  def unselect; end
-  def untick; end
-  def value; end
-
-  private
-
-  def unselect_peers; end
-end
-
-class Mechanize::Form::RadioButton < ::Mechanize::Form::Field
-  def initialize(node, form); end
-
-  def ==(other); end
-  def [](key); end
-  def check; end
-  def checked; end
-  def checked=(_arg0); end
-  def checked?; end
-  def click; end
-  def eql?(other); end
-  def form; end
-  def hash; end
-  def label; end
-  def pretty_print_instance_variables; end
-  def text; end
-  def uncheck; end
-
-  private
-
-  def uncheck_peers; end
-end
-
-class Mechanize::Form::Reset < ::Mechanize::Form::Button; end
-
-class Mechanize::Form::SelectList < ::Mechanize::Form::MultiSelectList
-  def initialize(node); end
-
-  def query_value; end
-  def value; end
-  def value=(new_value); end
-end
-
-class Mechanize::Form::Submit < ::Mechanize::Form::Button; end
-class Mechanize::Form::Text < ::Mechanize::Form::Field; end
-class Mechanize::Form::Textarea < ::Mechanize::Form::Field; end
-class Mechanize::HTTP; end
-
-class Mechanize::HTTP::Agent
-  def initialize(connection_name = T.unsafe(nil)); end
-
-  def add_auth(uri, user, password, realm = T.unsafe(nil), domain = T.unsafe(nil)); end
-  def add_default_auth(user, password, domain = T.unsafe(nil)); end
-  def allowed_error_codes; end
-  def allowed_error_codes=(_arg0); end
-  def auth_store; end
-  def authenticate_methods; end
-  def auto_io(name, read_size, input_io); end
-  def back; end
-  def ca_file; end
-  def ca_file=(ca_file); end
-  def cert_store; end
-  def cert_store=(cert_store); end
-  def certificate; end
-  def certificate=(certificate); end
-  def conditional_requests; end
-  def conditional_requests=(_arg0); end
-  def connection_for(uri); end
-  def content_encoding_gunzip(body_io); end
-  def content_encoding_hooks; end
-  def content_encoding_inflate(body_io); end
-  def context; end
-  def context=(_arg0); end
-  def cookie_jar; end
-  def cookie_jar=(_arg0); end
-  def current_page; end
-  def digest_challenges; end
-  def disable_keep_alive(request); end
-  def enable_gzip(request); end
-  def fetch(uri, method = T.unsafe(nil), headers = T.unsafe(nil), params = T.unsafe(nil), referer = T.unsafe(nil), redirects = T.unsafe(nil)); end
-  def follow_meta_refresh; end
-  def follow_meta_refresh=(_arg0); end
-  def follow_meta_refresh_self; end
-  def follow_meta_refresh_self=(_arg0); end
-  def get_meta_refresh(response, uri, page); end
-  def get_robots(uri); end
-  def gzip_enabled; end
-  def gzip_enabled=(_arg0); end
-  def history; end
-  def history=(_arg0); end
-  def hook_content_encoding(response, uri, response_body_io); end
-  def http; end
-  def http_request(uri, method, params = T.unsafe(nil)); end
-  def idle_timeout; end
-  def idle_timeout=(timeout); end
-  def ignore_bad_chunking; end
-  def ignore_bad_chunking=(_arg0); end
-  def inflate(compressed, window_bits = T.unsafe(nil)); end
-  def keep_alive; end
-  def keep_alive=(_arg0); end
-  def log; end
-  def make_tempfile(name); end
-  def max_file_buffer; end
-  def max_file_buffer=(_arg0); end
-  def max_history; end
-  def max_history=(length); end
-  def open_timeout; end
-  def open_timeout=(_arg0); end
-  def pass; end
-  def pass=(_arg0); end
-  def post_connect(uri, response, body_io); end
-  def post_connect_hooks; end
-  def pre_connect(request); end
-  def pre_connect_hooks; end
-  def private_key; end
-  def private_key=(private_key); end
-  def proxy_uri; end
-  def read_timeout; end
-  def read_timeout=(_arg0); end
-  def redirect_ok; end
-  def redirect_ok=(_arg0); end
-  def redirection_limit; end
-  def redirection_limit=(_arg0); end
-  def request_add_headers(request, headers = T.unsafe(nil)); end
-  def request_auth(request, uri); end
-  def request_auth_digest(request, uri, realm, base_uri, iis); end
-  def request_cookies(request, uri); end
-  def request_headers; end
-  def request_headers=(_arg0); end
-  def request_host(request, uri); end
-  def request_language_charset(request); end
-  def request_log(request); end
-  def request_referer(request, uri, referer); end
-  def request_user_agent(request); end
-  def reset; end
-  def resolve(uri, referer = T.unsafe(nil)); end
-  def resolve_parameters(uri, method, parameters); end
-  def response_authenticate(response, page, uri, request, headers, params, referer); end
-  def response_content_encoding(response, body_io); end
-  def response_cookies(response, uri, page); end
-  def response_follow_meta_refresh(response, uri, page, redirects); end
-  def response_log(response); end
-  def response_parse(response, body_io, uri); end
-  def response_read(response, request, uri); end
-  def response_redirect(response, method, page, redirects, headers, referer = T.unsafe(nil)); end
-  def retry_change_requests; end
-  def retry_change_requests=(retri); end
-  def robots; end
-  def robots=(value); end
-  def robots_allowed?(uri); end
-  def robots_disallowed?(url); end
-  def robots_error(url); end
-  def robots_error!(url); end
-  def robots_mutex; end
-  def robots_reset(url); end
-  def save_cookies(uri, set_cookie); end
-  def scheme_handlers; end
-  def scheme_handlers=(_arg0); end
-  def secure_resolve!(uri, referer = T.unsafe(nil)); end
-  def set_proxy(addr, port = T.unsafe(nil), user = T.unsafe(nil), pass = T.unsafe(nil)); end
-  def shutdown; end
-  def ssl_version; end
-  def ssl_version=(ssl_version); end
-  def use_tempfile?(size); end
-  def user_agent; end
-  def user_agent=(user_agent); end
-  def verify_callback; end
-  def verify_callback=(verify_callback); end
-  def verify_mode; end
-  def verify_mode=(verify_mode); end
-  def visited_page(url); end
-  def webrobots; end
-end
-
-Mechanize::HTTP::Agent::COOKIE_HEADERS = T.let(T.unsafe(nil), Array)
-Mechanize::HTTP::Agent::CREDENTIAL_HEADERS = T.let(T.unsafe(nil), Array)
-Mechanize::HTTP::Agent::POST_HEADERS = T.let(T.unsafe(nil), Array)
-Mechanize::HTTP::Agent::RobotsKey = T.let(T.unsafe(nil), Symbol)
-
-class Mechanize::HTTP::AuthChallenge < ::Struct
-  def [](param); end
-  def params; end
-  def params=(_); end
-  def raw; end
-  def raw=(_); end
-  def realm(uri); end
-  def realm_name; end
-  def scheme; end
-  def scheme=(_); end
-  def to_s; end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class Mechanize::HTTP::AuthRealm
-  def initialize(scheme, uri, realm); end
-
-  def ==(other); end
-  def eql?(other); end
-  def hash; end
-  def inspect; end
-  def realm; end
-  def scheme; end
-  def uri; end
-end
-
-class Mechanize::HTTP::AuthStore
-  def initialize; end
-
-  def add_auth(uri, user, pass, realm = T.unsafe(nil), domain = T.unsafe(nil)); end
-  def add_default_auth(user, pass, domain = T.unsafe(nil)); end
-  def auth_accounts; end
-  def credentials?(uri, challenges); end
-  def credentials_for(uri, realm); end
-  def default_auth; end
-  def remove_auth(uri, realm = T.unsafe(nil)); end
-end
-
-class Mechanize::HTTP::ContentDisposition < ::Struct
-  def creation_date; end
-  def creation_date=(_); end
-  def filename; end
-  def filename=(_); end
-  def modification_date; end
-  def modification_date=(_); end
-  def parameters; end
-  def parameters=(_); end
-  def read_date; end
-  def read_date=(_); end
-  def size; end
-  def size=(_); end
-  def type; end
-  def type=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class Mechanize::HTTP::ContentDispositionParser
-  def initialize; end
-
-  def parse(content_disposition, header = T.unsafe(nil)); end
-  def parse_parameters; end
-  def rfc_2045_quoted_string; end
-  def rfc_2045_token; end
-  def rfc_2045_value; end
-  def scanner; end
-  def scanner=(_arg0); end
-  def spaces; end
-
-  class << self
-    def parse(content_disposition); end
-  end
-end
-
-class Mechanize::HTTP::WWWAuthenticateParser
-  def initialize; end
-
-  def auth_param; end
-  def auth_scheme; end
-  def parse(www_authenticate); end
-  def quoted_string; end
-  def scan_comma_spaces; end
-  def scanner; end
-  def scanner=(_arg0); end
-  def spaces; end
-  def token; end
-end
-
-class Mechanize::Headers < ::Hash
-  def [](key); end
-  def []=(key, value); end
-  def canonical_each; end
-  def key?(key); end
-end
-
-class Mechanize::History < ::Array
-  def initialize(max_size = T.unsafe(nil)); end
-
-  def <<(page, uri = T.unsafe(nil)); end
-  def clear; end
-  def inspect; end
-  def max_size; end
-  def max_size=(_arg0); end
-  def pop; end
-  def push(page, uri = T.unsafe(nil)); end
-  def shift; end
-  def visited?(uri); end
-  def visited_page(uri); end
-
-  private
-
-  def initialize_copy(orig); end
-  def remove_from_index(page); end
-end
-
-class Mechanize::Image < ::Mechanize::Download; end
-
-class Mechanize::Page < ::Mechanize::File
-  extend ::Forwardable
-  extend ::Mechanize::ElementMatcher
-
-  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body = T.unsafe(nil), code = T.unsafe(nil), mech = T.unsafe(nil)); end
-
-  def %(*args, &block); end
-  def /(*args, &block); end
-  def at(*args, &block); end
-  def at_css(*args, &block); end
-  def at_xpath(*args, &block); end
-  def base(criteria = T.unsafe(nil)); end
-  def base_with(criteria = T.unsafe(nil)); end
-  def base_with!(criteria = T.unsafe(nil)); end
-  def bases; end
-  def bases_with(criteria = T.unsafe(nil)); end
-  def canonical_uri; end
-  def content_type; end
-  def css(*args, &block); end
-  def detected_encoding; end
-  def encoding; end
-  def encoding=(encoding); end
-  def encoding_error?(parser = T.unsafe(nil)); end
-  def encodings; end
-  def form(criteria = T.unsafe(nil)); end
-  def form_with(criteria = T.unsafe(nil)); end
-  def form_with!(criteria = T.unsafe(nil)); end
-  def forms; end
-  def forms_with(criteria = T.unsafe(nil)); end
-  def frame(criteria = T.unsafe(nil)); end
-  def frame_with(criteria = T.unsafe(nil)); end
-  def frame_with!(criteria = T.unsafe(nil)); end
-  def frames; end
-  def frames_with(criteria = T.unsafe(nil)); end
-  def iframe(criteria = T.unsafe(nil)); end
-  def iframe_with(criteria = T.unsafe(nil)); end
-  def iframe_with!(criteria = T.unsafe(nil)); end
-  def iframes; end
-  def iframes_with(criteria = T.unsafe(nil)); end
-  def image(criteria = T.unsafe(nil)); end
-  def image_urls; end
-  def image_with(criteria = T.unsafe(nil)); end
-  def image_with!(criteria = T.unsafe(nil)); end
-  def images; end
-  def images_with(criteria = T.unsafe(nil)); end
-  def inspect; end
-  def labels; end
-  def labels_hash; end
-  def link(criteria = T.unsafe(nil)); end
-  def link_with(criteria = T.unsafe(nil)); end
-  def link_with!(criteria = T.unsafe(nil)); end
-  def links; end
-  def links_with(criteria = T.unsafe(nil)); end
-  def mech; end
-  def mech=(_arg0); end
-  def meta_charset; end
-  def meta_refresh; end
-  def parser; end
-  def pretty_print(q); end
-  def reset; end
-  def response_header_charset; end
-  def root; end
-  def search(*args, &block); end
-  def select_bases(selector, method = T.unsafe(nil)); end
-  def select_forms(selector, method = T.unsafe(nil)); end
-  def select_frames(selector, method = T.unsafe(nil)); end
-  def select_iframes(selector, method = T.unsafe(nil)); end
-  def select_images(selector, method = T.unsafe(nil)); end
-  def select_links(selector, method = T.unsafe(nil)); end
-  def title; end
-  def xpath(*args, &block); end
-
-  private
-
-  def html_body; end
-
-  class << self
-    def charset(content_type); end
-    def charset_from_content_type(content_type); end
-    def meta_charset(body); end
-    def meta_content_type(body); end
-    def response_header_charset(response); end
-  end
-end
-
-class Mechanize::Page::Base < ::Mechanize::Page::Link; end
-Mechanize::Page::DEFAULT_RESPONSE = T.let(T.unsafe(nil), Hash)
-
-class Mechanize::Page::Frame < ::Mechanize::Page::Link
-  def initialize(node, mech, referer); end
-
-  def content; end
-  def name; end
-  def node; end
-  def src; end
-  def text; end
-end
-
-class Mechanize::Page::Image
-  def initialize(node, page); end
-
-  def alt; end
-  def caption; end
-  def dom_class; end
-  def dom_id; end
-  def extname; end
-  def fetch(parameters = T.unsafe(nil), referer = T.unsafe(nil), headers = T.unsafe(nil)); end
-  def height; end
-  def image_referer; end
-  def inspect; end
-  def mech; end
-  def mech=(_arg0); end
-  def mime_type; end
-  def node; end
-  def page; end
-  def page=(_arg0); end
-  def pretty_print(q); end
-  def relative?; end
-  def src; end
-  def text; end
-  def title; end
-  def to_s; end
-  def uri; end
-  def url; end
-  def width; end
-end
-
-class Mechanize::Page::Label
-  def initialize(node, page); end
-
-  def for; end
-  def node; end
-  def page; end
-  def text; end
-  def to_s; end
-end
-
-class Mechanize::Page::Link
-  def initialize(node, mech, page); end
-
-  def attributes; end
-  def click; end
-  def dom_class; end
-  def dom_id; end
-  def href; end
-  def inspect; end
-  def node; end
-  def noreferrer?; end
-  def page; end
-  def pretty_print(q); end
-  def referer; end
-  def rel; end
-  def rel?(kind); end
-  def resolved_uri; end
-  def text; end
-  def to_s; end
-  def uri; end
-end
-
-class Mechanize::Page::MetaRefresh < ::Mechanize::Page::Link
-  def initialize(node, page, delay, href, link_self = T.unsafe(nil)); end
-
-  def delay; end
-  def link_self; end
-  def noreferrer?; end
-
-  class << self
-    def from_node(node, page, uri = T.unsafe(nil)); end
-    def parse(content, base_uri = T.unsafe(nil)); end
-  end
-end
-
-Mechanize::Page::MetaRefresh::CONTENT_REGEXP = T.let(T.unsafe(nil), Regexp)
-Mechanize::Page::MetaRefresh::UNSAFE = T.let(T.unsafe(nil), Regexp)
-
-module Mechanize::Parser
-  extend ::Forwardable
-
-  def [](*args, &block); end
-  def []=(*args, &block); end
-  def canonical_each(*args, &block); end
-  def code; end
-  def code=(_arg0); end
-  def each(*args, &block); end
-  def extract_filename(full_path = T.unsafe(nil)); end
-  def fill_header(response); end
-  def find_free_name(filename); end
-  def header; end
-  def key?(*args, &block); end
-  def response; end
-  def response=(_arg0); end
-  def uri; end
-  def uri=(_arg0); end
-end
-
-Mechanize::Parser::SPECIAL_FILENAMES = T.let(T.unsafe(nil), Regexp)
-
-class Mechanize::PluggableParser
-  def initialize; end
-
-  def [](content_type); end
-  def []=(content_type, klass); end
-  def csv=(klass); end
-  def default; end
-  def default=(_arg0); end
-  def html=(klass); end
-  def parser(content_type); end
-  def pdf=(klass); end
-  def register_parser(content_type, klass); end
-  def xhtml=(klass); end
-  def xml=(klass); end
-end
-
-Mechanize::PluggableParser::CONTENT_TYPES = T.let(T.unsafe(nil), Hash)
-Mechanize::PluggableParser::InvalidContentTypeError = MIME::Type::InvalidContentType
-
-class Mechanize::RedirectLimitReachedError < ::Mechanize::Error
-  def initialize(page, redirects); end
-
-  def page; end
-  def redirects; end
-  def response_code; end
-end
-
-class Mechanize::RedirectNotGetOrHeadError < ::Mechanize::Error
-  def initialize(page, verb); end
-
-  def inspect; end
-  def page; end
-  def response_code; end
-  def to_s; end
-  def uri; end
-  def verb; end
-end
-
-class Mechanize::ResponseCodeError < ::Mechanize::Error
-  def initialize(page, message = T.unsafe(nil)); end
-
-  def inspect; end
-  def page; end
-  def response_code; end
-  def to_s; end
-end
-
-class Mechanize::ResponseReadError < ::Mechanize::Error
-  def initialize(error, response, body_io, uri, mechanize); end
-
-  def body_io; end
-  def error; end
-  def force_parse; end
-  def mechanize; end
-  def message; end
-  def response; end
-  def uri; end
-end
-
-class Mechanize::RobotsDisallowedError < ::Mechanize::Error
-  def initialize(url); end
-
-  def inspect; end
-  def to_s; end
-  def uri; end
-  def url; end
-end
-
-class Mechanize::UnauthorizedError < ::Mechanize::ResponseCodeError
-  def initialize(page, challenges, message); end
-
-  def challenges; end
-  def to_s; end
-end
-
-class Mechanize::UnsupportedSchemeError < ::Mechanize::Error
-  def initialize(scheme, uri); end
-
-  def scheme; end
-  def scheme=(_arg0); end
-  def uri; end
-  def uri=(_arg0); end
-end
-
-class Mechanize::Util
-  class << self
-    def build_query_string(parameters, enc = T.unsafe(nil)); end
-    def detect_charset(src); end
-    def each_parameter(parameters, &block); end
-    def from_native_charset(s, code, ignore_encoding_error = T.unsafe(nil), log = T.unsafe(nil)); end
-    def guess_encoding(src); end
-    def html_unescape(s); end
-    def uri_escape(str, unsafe = T.unsafe(nil)); end
-    def uri_unescape(str); end
-
-    private
-
-    def each_parameter_1(key, value, &block); end
-  end
-end
-
-Mechanize::Util::DefaultMimeTypes = T.let(T.unsafe(nil), Hash)
-Mechanize::VERSION = T.let(T.unsafe(nil), String)
-
-class Mechanize::XmlFile < ::Mechanize::File
-  extend ::Forwardable
-
-  def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body = T.unsafe(nil), code = T.unsafe(nil)); end
-
-  def at(*args, &block); end
-  def search(*args, &block); end
-  def xml; end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi
deleted file mode 100644
index b7ecbb694710c..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi
+++ /dev/null
@@ -1,72 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `method_source` gem.
-# Please instead update this file by running `bin/tapioca gem method_source`.
-
-module MethodSource
-  extend ::MethodSource::CodeHelpers
-
-  class << self
-    def comment_helper(source_location, name = T.unsafe(nil)); end
-    def extract_code(source_location); end
-    def lines_for(file_name, name = T.unsafe(nil)); end
-    def source_helper(source_location, name = T.unsafe(nil)); end
-    def valid_expression?(str); end
-  end
-end
-
-module MethodSource::CodeHelpers
-  def comment_describing(file, line_number); end
-  def complete_expression?(str); end
-  def expression_at(file, line_number, options = T.unsafe(nil)); end
-
-  private
-
-  def extract_first_expression(lines, consume = T.unsafe(nil), &block); end
-  def extract_last_comment(lines); end
-end
-
-module MethodSource::CodeHelpers::IncompleteExpression
-  class << self
-    def ===(ex); end
-    def rbx?; end
-  end
-end
-
-MethodSource::CodeHelpers::IncompleteExpression::GENERIC_REGEXPS = T.let(T.unsafe(nil), Array)
-MethodSource::CodeHelpers::IncompleteExpression::RBX_ONLY_REGEXPS = T.let(T.unsafe(nil), Array)
-
-module MethodSource::MethodExtensions
-  def comment; end
-  def source; end
-
-  class << self
-    def included(klass); end
-  end
-end
-
-module MethodSource::ReeSourceLocation
-  def source_location; end
-end
-
-module MethodSource::SourceLocation; end
-
-module MethodSource::SourceLocation::MethodExtensions
-  def source_location; end
-
-  private
-
-  def trace_func(event, file, line, id, binding, classname); end
-end
-
-module MethodSource::SourceLocation::ProcExtensions
-  def source_location; end
-end
-
-module MethodSource::SourceLocation::UnboundMethodExtensions
-  def source_location; end
-end
-
-class MethodSource::SourceNotFoundError < ::StandardError; end
-MethodSource::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/method_source@1.1.0.rbi b/Library/Homebrew/sorbet/rbi/gems/method_source@1.1.0.rbi
new file mode 100644
index 0000000000000..4e40c9a7ec3f9
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/method_source@1.1.0.rbi
@@ -0,0 +1,303 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `method_source` gem.
+# Please instead update this file by running `bin/tapioca gem method_source`.
+
+# source://method_source//lib/method_source.rb#163
+class Method
+  include ::MethodSource::SourceLocation::MethodExtensions
+  include ::MethodSource::MethodExtensions
+end
+
+# source://method_source//lib/method_source/version.rb#1
+module MethodSource
+  extend ::MethodSource::CodeHelpers
+
+  class << self
+    # Clear cache.
+    #
+    # source://method_source//lib/method_source.rb#59
+    def clear_cache; end
+
+    # Helper method responsible for opening source file and buffering up
+    # the comments for a specified method. Defined here to avoid polluting
+    # `Method` class.
+    #
+    # @param source_location [Array] The array returned by Method#source_location
+    # @param method_name [String]
+    # @raise [SourceNotFoundError]
+    # @return [String] The comments up to the point of the method.
+    #
+    # source://method_source//lib/method_source.rb#38
+    def comment_helper(source_location, name = T.unsafe(nil)); end
+
+    # @deprecated — use MethodSource::CodeHelpers#expression_at
+    #
+    # source://method_source//lib/method_source.rb#71
+    def extract_code(source_location); end
+
+    # Load a memoized copy of the lines in a file.
+    #
+    # @param file_name [String]
+    # @param method_name [String]
+    # @raise [SourceNotFoundError]
+    # @return [Array<String>] the contents of the file
+    #
+    # source://method_source//lib/method_source.rb#51
+    def lines_for(file_name, name = T.unsafe(nil)); end
+
+    # Helper method responsible for extracting method body.
+    # Defined here to avoid polluting `Method` class.
+    #
+    # @param source_location [Array] The array returned by Method#source_location
+    # @param method_name [String]
+    # @return [String] The method body
+    #
+    # source://method_source//lib/method_source.rb#23
+    def source_helper(source_location, name = T.unsafe(nil)); end
+
+    # @deprecated — use MethodSource::CodeHelpers#complete_expression?
+    # @return [Boolean]
+    #
+    # source://method_source//lib/method_source.rb#64
+    def valid_expression?(str); end
+  end
+end
+
+# source://method_source//lib/method_source/code_helpers.rb#3
+module MethodSource::CodeHelpers
+  # Retrieve the comment describing the expression on the given line of the given file.
+  #
+  # This is useful to get module or method documentation.
+  #
+  # @param file [Array<String>, File, String] The file to parse, either as a File or as
+  #   a String or an Array of lines.
+  # @param line_number [Integer] The line number at which to look.
+  #   NOTE: The first line in a file is line 1!
+  # @return [String] The comment
+  #
+  # source://method_source//lib/method_source/code_helpers.rb#52
+  def comment_describing(file, line_number); end
+
+  # Determine if a string of code is a complete Ruby expression.
+  #
+  # @example
+  #   complete_expression?("class Hello") #=> false
+  #   complete_expression?("class Hello; end") #=> true
+  #   complete_expression?("class 123") #=> SyntaxError: unexpected tINTEGER
+  # @param code [String] The code to validate.
+  # @raise [SyntaxError] Any SyntaxError that does not represent incompleteness.
+  # @return [Boolean] Whether or not the code is a complete Ruby expression.
+  #
+  # source://method_source//lib/method_source/code_helpers.rb#66
+  def complete_expression?(str); end
+
+  # Retrieve the first expression starting on the given line of the given file.
+  #
+  # This is useful to get module or method source code.
+  #
+  #                           line 1!
+  #
+  # @option options
+  # @option options
+  # @param file [Array<String>, File, String] The file to parse, either as a File or as
+  # @param line_number [Integer] The line number at which to look.
+  #   NOTE: The first line in a file is
+  # @param options [Hash] The optional configuration parameters.
+  # @raise [SyntaxError] If the first complete expression can't be identified
+  # @return [String] The first complete expression
+  #
+  # source://method_source//lib/method_source/code_helpers.rb#20
+  def expression_at(file, line_number, options = T.unsafe(nil)); end
+
+  private
+
+  # Get the first expression from the input.
+  #
+  # @param lines [Array<String>]
+  # @param consume [Integer] A number of lines to automatically
+  #   consume (add to the expression buffer) without checking for validity.
+  # @raise [SyntaxError]
+  # @return [String] a valid ruby expression
+  # @yield a clean-up function to run before checking for complete_expression
+  #
+  # source://method_source//lib/method_source/code_helpers.rb#92
+  def extract_first_expression(lines, consume = T.unsafe(nil), &block); end
+
+  # Get the last comment from the input.
+  #
+  # @param lines [Array<String>]
+  # @return [String]
+  #
+  # source://method_source//lib/method_source/code_helpers.rb#106
+  def extract_last_comment(lines); end
+end
+
+# An exception matcher that matches only subsets of SyntaxErrors that can be
+# fixed by adding more input to the buffer.
+#
+# source://method_source//lib/method_source/code_helpers.rb#124
+module MethodSource::CodeHelpers::IncompleteExpression
+  class << self
+    # source://method_source//lib/method_source/code_helpers.rb#137
+    def ===(ex); end
+
+    # @return [Boolean]
+    #
+    # source://method_source//lib/method_source/code_helpers.rb#149
+    def rbx?; end
+  end
+end
+
+# source://method_source//lib/method_source/code_helpers.rb#125
+MethodSource::CodeHelpers::IncompleteExpression::GENERIC_REGEXPS = T.let(T.unsafe(nil), Array)
+
+# source://method_source//lib/method_source/code_helpers.rb#133
+MethodSource::CodeHelpers::IncompleteExpression::RBX_ONLY_REGEXPS = T.let(T.unsafe(nil), Array)
+
+# This module is to be included by `Method` and `UnboundMethod` and
+# provides the `#source` functionality
+#
+# source://method_source//lib/method_source.rb#77
+module MethodSource::MethodExtensions
+  # Return the comments associated with the method class/module.
+  #
+  # @example
+  #   MethodSource::MethodExtensions.method(:included).module_comment
+  #   =>
+  #   # This module is to be included by `Method` and `UnboundMethod` and
+  #   # provides the `#source` functionality
+  # @raise SourceNotFoundException
+  # @return [String] The method's comments as a string
+  #
+  # source://method_source//lib/method_source.rb#139
+  def class_comment; end
+
+  # Return the comments associated with the method as a string.
+  #
+  # @example
+  #   Set.instance_method(:clear).comment.display
+  #   =>
+  #   # Removes all elements and returns self.
+  # @raise SourceNotFoundException
+  # @return [String] The method's comments as a string
+  #
+  # source://method_source//lib/method_source.rb#126
+  def comment; end
+
+  # Return the comments associated with the method class/module.
+  #
+  # @example
+  #   MethodSource::MethodExtensions.method(:included).module_comment
+  #   =>
+  #   # This module is to be included by `Method` and `UnboundMethod` and
+  #   # provides the `#source` functionality
+  # @raise SourceNotFoundException
+  # @return [String] The method's comments as a string
+  #
+  # source://method_source//lib/method_source.rb#139
+  def module_comment; end
+
+  # Return the sourcecode for the method as a string
+  #
+  # @example
+  #   Set.instance_method(:clear).source.display
+  #   =>
+  #   def clear
+  #   @hash.clear
+  #   self
+  #   end
+  # @raise SourceNotFoundException
+  # @return [String] The method sourcecode as a string
+  #
+  # source://method_source//lib/method_source.rb#114
+  def source; end
+
+  class << self
+    # We use the included hook to patch Method#source on rubinius.
+    # We need to use the included hook as Rubinius defines a `source`
+    # on Method so including a module will have no effect (as it's
+    # higher up the MRO).
+    #
+    # @param klass [Class] The class that includes the module.
+    #
+    # source://method_source//lib/method_source.rb#84
+    def included(klass); end
+  end
+end
+
+# source://method_source//lib/method_source/source_location.rb#2
+module MethodSource::ReeSourceLocation
+  # Ruby enterprise edition provides all the information that's
+  # needed, in a slightly different way.
+  #
+  # source://method_source//lib/method_source/source_location.rb#5
+  def source_location; end
+end
+
+# source://method_source//lib/method_source/source_location.rb#10
+module MethodSource::SourceLocation; end
+
+# source://method_source//lib/method_source/source_location.rb#11
+module MethodSource::SourceLocation::MethodExtensions
+  # Return the source location of a method for Ruby 1.8.
+  #
+  # @return [Array] A two element array. First element is the
+  #   file, second element is the line in the file where the
+  #   method definition is found.
+  #
+  # source://method_source//lib/method_source/source_location.rb#40
+  def source_location; end
+
+  private
+
+  # source://method_source//lib/method_source/source_location.rb#26
+  def trace_func(event, file, line, id, binding, classname); end
+end
+
+# source://method_source//lib/method_source/source_location.rb#54
+module MethodSource::SourceLocation::ProcExtensions
+  # Return the source location for a Proc (in implementations
+  # without Proc#source_location)
+  #
+  # @return [Array] A two element array. First element is the
+  #   file, second element is the line in the file where the
+  #   proc definition is found.
+  #
+  # source://method_source//lib/method_source/source_location.rb#74
+  def source_location; end
+end
+
+# source://method_source//lib/method_source/source_location.rb#81
+module MethodSource::SourceLocation::UnboundMethodExtensions
+  # Return the source location of an instance method for Ruby 1.8.
+  #
+  # @return [Array] A two element array. First element is the
+  #   file, second element is the line in the file where the
+  #   method definition is found.
+  #
+  # source://method_source//lib/method_source/source_location.rb#101
+  def source_location; end
+end
+
+# An Exception to mark errors that were raised trying to find the source from
+# a given source_location.
+#
+# source://method_source//lib/method_source.rb#16
+class MethodSource::SourceNotFoundError < ::StandardError; end
+
+# source://method_source//lib/method_source/version.rb#2
+MethodSource::VERSION = T.let(T.unsafe(nil), String)
+
+# source://method_source//lib/method_source.rb#173
+class Proc
+  include ::MethodSource::SourceLocation::ProcExtensions
+  include ::MethodSource::MethodExtensions
+end
+
+# source://method_source//lib/method_source.rb#168
+class UnboundMethod
+  include ::MethodSource::SourceLocation::UnboundMethodExtensions
+  include ::MethodSource::MethodExtensions
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/mime-types-data@3.2022.0105.rbi b/Library/Homebrew/sorbet/rbi/gems/mime-types-data@3.2022.0105.rbi
deleted file mode 100644
index 453b40447ef3a..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/mime-types-data@3.2022.0105.rbi
+++ /dev/null
@@ -1,73 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `mime-types-data` gem.
-# Please instead update this file by running `bin/tapioca gem mime-types-data`.
-
-module MIME; end
-
-class MIME::Types
-  include ::Enumerable
-  extend ::Enumerable
-
-  def initialize; end
-
-  def [](type_id, complete: T.unsafe(nil), registered: T.unsafe(nil)); end
-  def add(*types); end
-  def add_type(type, quiet = T.unsafe(nil)); end
-  def count; end
-  def each; end
-  def inspect; end
-  def of(filename); end
-  def type_for(filename); end
-
-  private
-
-  def add_type_variant!(mime_type); end
-  def index_extensions!(mime_type); end
-  def match(pattern); end
-  def prune_matches(matches, complete, registered); end
-  def reindex_extensions!(mime_type); end
-
-  class << self
-    def [](type_id, complete: T.unsafe(nil), registered: T.unsafe(nil)); end
-    def add(*types); end
-    def count; end
-    def each; end
-    def logger; end
-    def logger=(_arg0); end
-    def new(*_arg0); end
-    def of(filename); end
-    def type_for(filename); end
-
-    private
-
-    def __instances__; end
-    def __types__; end
-    def lazy_load?; end
-    def load_default_mime_types(mode = T.unsafe(nil)); end
-    def load_mode; end
-    def reindex_extensions(type); end
-  end
-end
-
-class MIME::Types::Cache < ::Struct
-  def data; end
-  def data=(_); end
-  def version; end
-  def version=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def load(cache_file = T.unsafe(nil)); end
-    def members; end
-    def new(*_arg0); end
-    def save(types = T.unsafe(nil), cache_file = T.unsafe(nil)); end
-  end
-end
-
-module MIME::Types::Data; end
-MIME::Types::Data::PATH = T.let(T.unsafe(nil), String)
-MIME::Types::Data::VERSION = T.let(T.unsafe(nil), String)
-MIME::Types::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/mime-types@3.4.1.rbi b/Library/Homebrew/sorbet/rbi/gems/mime-types@3.4.1.rbi
deleted file mode 100644
index af47e4a82d671..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/mime-types@3.4.1.rbi
+++ /dev/null
@@ -1,295 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `mime-types` gem.
-# Please instead update this file by running `bin/tapioca gem mime-types`.
-
-module MIME; end
-
-class MIME::Type
-  include ::Comparable
-
-  def initialize(content_type); end
-
-  def <=>(other); end
-  def add_extensions(*extensions); end
-  def ascii?; end
-  def binary?; end
-  def complete?; end
-  def content_type; end
-  def default_encoding; end
-  def docs; end
-  def docs=(_arg0); end
-  def encode_with(coder); end
-  def encoding; end
-  def encoding=(enc); end
-  def eql?(other); end
-  def extensions; end
-  def extensions=(value); end
-  def friendly(lang = T.unsafe(nil)); end
-  def i18n_key; end
-  def init_with(coder); end
-  def inspect; end
-  def like?(other); end
-  def media_type; end
-  def obsolete; end
-  def obsolete=(_arg0); end
-  def obsolete?; end
-  def preferred_extension; end
-  def preferred_extension=(value); end
-  def priority_compare(other); end
-  def provisional; end
-  def provisional=(_arg0); end
-  def provisional?; end
-  def raw_media_type; end
-  def raw_sub_type; end
-  def registered; end
-  def registered=(_arg0); end
-  def registered?; end
-  def signature; end
-  def signature=(_arg0); end
-  def signature?; end
-  def simplified; end
-  def sub_type; end
-  def to_h; end
-  def to_json(*args); end
-  def to_s; end
-  def to_str; end
-  def use_instead; end
-  def use_instead=(_arg0); end
-  def xref_urls; end
-  def xrefs; end
-  def xrefs=(xrefs); end
-
-  private
-
-  def content_type=(type_string); end
-  def intern_string(string); end
-  def xref_map(values, helper); end
-  def xref_url_for_draft(value); end
-  def xref_url_for_person(value); end
-  def xref_url_for_rfc(value); end
-  def xref_url_for_rfc_errata(value); end
-  def xref_url_for_template(value); end
-
-  class << self
-    def i18n_key(content_type); end
-    def match(content_type); end
-    def simplified(content_type, remove_x_prefix: T.unsafe(nil)); end
-
-    private
-
-    def simplify_matchdata(matchdata, remove_x = T.unsafe(nil), joiner: T.unsafe(nil)); end
-  end
-end
-
-MIME::Type::ASCII_ENCODINGS = T.let(T.unsafe(nil), Array)
-MIME::Type::BINARY_ENCODINGS = T.let(T.unsafe(nil), Array)
-
-class MIME::Type::Columnar < ::MIME::Type
-  def initialize(container, content_type, extensions); end
-
-  def docs(*args); end
-  def docs=(*args); end
-  def encode_with(coder); end
-  def encoding(*args); end
-  def encoding=(*args); end
-  def friendly(*args); end
-  def obsolete(*args); end
-  def obsolete=(*args); end
-  def obsolete?(*args); end
-  def preferred_extension(*args); end
-  def preferred_extension=(*args); end
-  def provisional(*args); end
-  def provisional=(*args); end
-  def provisional?(*args); end
-  def registered(*args); end
-  def registered=(*args); end
-  def registered?(*args); end
-  def signature(*args); end
-  def signature=(*args); end
-  def signature?(*args); end
-  def use_instead(*args); end
-  def use_instead=(*args); end
-  def xref_urls(*args); end
-  def xrefs(*args); end
-  def xrefs=(*args); end
-end
-
-MIME::Type::I18N_RE = T.let(T.unsafe(nil), Regexp)
-
-class MIME::Type::InvalidContentType < ::ArgumentError
-  def initialize(type_string); end
-
-  def to_s; end
-end
-
-class MIME::Type::InvalidEncoding < ::ArgumentError
-  def initialize(encoding); end
-
-  def to_s; end
-end
-
-MIME::Type::MEDIA_TYPE_RE = T.let(T.unsafe(nil), Regexp)
-MIME::Type::VERSION = T.let(T.unsafe(nil), String)
-
-class MIME::Types
-  include ::Enumerable
-  extend ::Enumerable
-
-  def initialize; end
-
-  def [](type_id, complete: T.unsafe(nil), registered: T.unsafe(nil)); end
-  def add(*types); end
-  def add_type(type, quiet = T.unsafe(nil)); end
-  def count; end
-  def each; end
-  def inspect; end
-  def of(filename); end
-  def type_for(filename); end
-
-  private
-
-  def add_type_variant!(mime_type); end
-  def index_extensions!(mime_type); end
-  def match(pattern); end
-  def prune_matches(matches, complete, registered); end
-  def reindex_extensions!(mime_type); end
-
-  class << self
-    def [](type_id, complete: T.unsafe(nil), registered: T.unsafe(nil)); end
-    def add(*types); end
-    def count; end
-    def each; end
-    def logger; end
-    def logger=(_arg0); end
-    def new(*_arg0); end
-    def of(filename); end
-    def type_for(filename); end
-
-    private
-
-    def __instances__; end
-    def __types__; end
-    def lazy_load?; end
-    def load_default_mime_types(mode = T.unsafe(nil)); end
-    def load_mode; end
-    def reindex_extensions(type); end
-  end
-end
-
-class MIME::Types::Cache < ::Struct
-  def data; end
-  def data=(_); end
-  def version; end
-  def version=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def load(cache_file = T.unsafe(nil)); end
-    def members; end
-    def new(*_arg0); end
-    def save(types = T.unsafe(nil), cache_file = T.unsafe(nil)); end
-  end
-end
-
-module MIME::Types::Columnar
-  def load_base_data(path); end
-
-  private
-
-  def arr(line); end
-  def dict(line, array: T.unsafe(nil)); end
-  def each_file_line(name, lookup = T.unsafe(nil)); end
-  def flag(line); end
-  def load_docs; end
-  def load_encoding; end
-  def load_flags; end
-  def load_friendly; end
-  def load_preferred_extension; end
-  def load_use_instead; end
-  def load_xrefs; end
-  def opt(line); end
-
-  class << self
-    def extended(obj); end
-  end
-end
-
-MIME::Types::Columnar::LOAD_MUTEX = T.let(T.unsafe(nil), Thread::Mutex)
-
-class MIME::Types::Container
-  extend ::Forwardable
-
-  def initialize(hash = T.unsafe(nil)); end
-
-  def ==(*args, &block); end
-  def [](key); end
-  def []=(key, value); end
-  def add(key, value); end
-  def count(*args, &block); end
-  def each(*args, &block); end
-  def each_value(*args, &block); end
-  def empty?(*args, &block); end
-  def encode_with(coder); end
-  def flat_map(*args, &block); end
-  def init_with(coder); end
-  def keys(*args, &block); end
-  def marshal_dump; end
-  def marshal_load(hash); end
-  def merge(other); end
-  def merge!(other); end
-  def select(*args, &block); end
-  def to_hash; end
-  def values(*args, &block); end
-
-  protected
-
-  def container; end
-  def container=(_arg0); end
-  def normalize; end
-end
-
-MIME::Types::Container::EMPTY_SET = T.let(T.unsafe(nil), Set)
-
-class MIME::Types::Loader
-  def initialize(path = T.unsafe(nil), container = T.unsafe(nil)); end
-
-  def container; end
-  def load(options = T.unsafe(nil)); end
-  def load_columnar; end
-  def load_json; end
-  def load_yaml; end
-  def path; end
-
-  private
-
-  def columnar_path; end
-  def json_path; end
-  def yaml_path; end
-
-  class << self
-    def load(options = T.unsafe(nil)); end
-    def load_from_json(filename); end
-    def load_from_yaml(filename); end
-
-    private
-
-    def old_yaml?; end
-    def read_file(filename); end
-  end
-end
-
-MIME::Types::VERSION = T.let(T.unsafe(nil), String)
-
-class MIME::Types::WarnLogger < ::Logger
-  def initialize(_one, _two = T.unsafe(nil), _three = T.unsafe(nil)); end
-end
-
-class MIME::Types::WarnLogger::WarnLogDevice < ::Logger::LogDevice
-  def initialize(*_arg0); end
-
-  def close; end
-  def write(m); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.8.0.rbi b/Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.8.0.rbi
deleted file mode 100644
index 851964f779f98..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.8.0.rbi
+++ /dev/null
@@ -1,101 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `mini_portile2` gem.
-# Please instead update this file by running `bin/tapioca gem mini_portile2`.
-
-class MiniPortile
-  def initialize(name, version, **kwargs); end
-
-  def activate; end
-  def apply_patch(patch_file); end
-  def compile; end
-  def configure; end
-  def configure_options; end
-  def configure_options=(_arg0); end
-  def configured?; end
-  def cook; end
-  def download; end
-  def downloaded?; end
-  def extract; end
-  def files; end
-  def files=(_arg0); end
-  def gcc_cmd; end
-  def host; end
-  def host=(_arg0); end
-  def install; end
-  def installed?; end
-  def logger; end
-  def logger=(_arg0); end
-  def make_cmd; end
-  def name; end
-  def original_host; end
-  def patch; end
-  def patch_files; end
-  def patch_files=(_arg0); end
-  def path; end
-  def prepare_build_directory; end
-  def source_directory; end
-  def source_directory=(path); end
-  def target; end
-  def target=(_arg0); end
-  def version; end
-
-  private
-
-  def archives_path; end
-  def computed_options; end
-  def configure_defaults; end
-  def configure_prefix; end
-  def detect_host; end
-  def download_file(url, full_path, count = T.unsafe(nil)); end
-  def download_file_file(uri, full_path); end
-  def download_file_ftp(uri, full_path); end
-  def download_file_http(url, full_path, count = T.unsafe(nil)); end
-  def execute(action, command, command_opts = T.unsafe(nil)); end
-  def extract_file(file, target); end
-  def files_hashs; end
-  def log_file(action); end
-  def message(text); end
-  def newer?(target, checkpoint); end
-  def output(text = T.unsafe(nil)); end
-  def port_path; end
-  def tar_compression_switch(filename); end
-  def tar_exe; end
-  def tmp_path; end
-  def verify_file(file); end
-  def which(cmd); end
-  def with_tempfile(filename, full_path); end
-  def work_path; end
-
-  class << self
-    def mingw?; end
-    def mswin?; end
-    def windows?; end
-  end
-end
-
-MiniPortile::DEFAULT_TIMEOUT = T.let(T.unsafe(nil), Integer)
-MiniPortile::KEYRING_NAME = T.let(T.unsafe(nil), String)
-MiniPortile::TAR_EXECUTABLES = T.let(T.unsafe(nil), Array)
-MiniPortile::VERSION = T.let(T.unsafe(nil), String)
-
-class MiniPortileCMake < ::MiniPortile
-  def initialize(name, version, **kwargs); end
-
-  def cmake_cmd; end
-  def configure; end
-  def configure_defaults; end
-  def configure_prefix; end
-  def configured?; end
-  def make_cmd; end
-end
-
-class Net::HTTP < ::Net::Protocol
-  private
-
-  def edit_path(path); end
-end
-
-Net::HTTP::ENVIRONMENT_VARIABLE_IS_MULTIUSER_SAFE = T.let(T.unsafe(nil), TrueClass)
-Net::HTTP::ProxyMod = Net::HTTP::ProxyDelta
diff --git a/Library/Homebrew/sorbet/rbi/gems/minitest@5.16.2.rbi b/Library/Homebrew/sorbet/rbi/gems/minitest@5.16.2.rbi
deleted file mode 100644
index 8a4ceb611ee4f..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/minitest@5.16.2.rbi
+++ /dev/null
@@ -1,348 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `minitest` gem.
-# Please instead update this file by running `bin/tapioca gem minitest`.
-
-module Minitest
-  class << self
-    def __run(reporter, options); end
-    def after_run(&block); end
-    def autorun; end
-    def backtrace_filter; end
-    def backtrace_filter=(_arg0); end
-    def cattr_accessor(name); end
-    def clock_time; end
-    def extensions; end
-    def extensions=(_arg0); end
-    def filter_backtrace(bt); end
-    def info_signal; end
-    def info_signal=(_arg0); end
-    def init_plugins(options); end
-    def load_plugins; end
-    def parallel_executor; end
-    def parallel_executor=(_arg0); end
-    def process_args(args = T.unsafe(nil)); end
-    def reporter; end
-    def reporter=(_arg0); end
-    def run(args = T.unsafe(nil)); end
-    def run_one_method(klass, method_name); end
-    def seed; end
-    def seed=(_arg0); end
-  end
-end
-
-class Minitest::AbstractReporter
-  include ::Mutex_m
-
-  def lock; end
-  def locked?; end
-  def passed?; end
-  def prerecord(klass, name); end
-  def record(result); end
-  def report; end
-  def start; end
-  def synchronize(&block); end
-  def try_lock; end
-  def unlock; end
-end
-
-class Minitest::Assertion < ::Exception
-  def error; end
-  def location; end
-  def result_code; end
-  def result_label; end
-end
-
-module Minitest::Assertions
-  def _synchronize; end
-  def assert(test, msg = T.unsafe(nil)); end
-  def assert_empty(obj, msg = T.unsafe(nil)); end
-  def assert_equal(exp, act, msg = T.unsafe(nil)); end
-  def assert_in_delta(exp, act, delta = T.unsafe(nil), msg = T.unsafe(nil)); end
-  def assert_in_epsilon(exp, act, epsilon = T.unsafe(nil), msg = T.unsafe(nil)); end
-  def assert_includes(collection, obj, msg = T.unsafe(nil)); end
-  def assert_instance_of(cls, obj, msg = T.unsafe(nil)); end
-  def assert_kind_of(cls, obj, msg = T.unsafe(nil)); end
-  def assert_match(matcher, obj, msg = T.unsafe(nil)); end
-  def assert_nil(obj, msg = T.unsafe(nil)); end
-  def assert_operator(o1, op, o2 = T.unsafe(nil), msg = T.unsafe(nil)); end
-  def assert_output(stdout = T.unsafe(nil), stderr = T.unsafe(nil)); end
-  def assert_path_exists(path, msg = T.unsafe(nil)); end
-  def assert_predicate(o1, op, msg = T.unsafe(nil)); end
-  def assert_raises(*exp); end
-  def assert_respond_to(obj, meth, msg = T.unsafe(nil)); end
-  def assert_same(exp, act, msg = T.unsafe(nil)); end
-  def assert_send(send_ary, m = T.unsafe(nil)); end
-  def assert_silent; end
-  def assert_throws(sym, msg = T.unsafe(nil)); end
-  def capture_io; end
-  def capture_subprocess_io; end
-  def diff(exp, act); end
-  def exception_details(e, msg); end
-  def fail_after(y, m, d, msg); end
-  def flunk(msg = T.unsafe(nil)); end
-  def message(msg = T.unsafe(nil), ending = T.unsafe(nil), &default); end
-  def mu_pp(obj); end
-  def mu_pp_for_diff(obj); end
-  def pass(_msg = T.unsafe(nil)); end
-  def refute(test, msg = T.unsafe(nil)); end
-  def refute_empty(obj, msg = T.unsafe(nil)); end
-  def refute_equal(exp, act, msg = T.unsafe(nil)); end
-  def refute_in_delta(exp, act, delta = T.unsafe(nil), msg = T.unsafe(nil)); end
-  def refute_in_epsilon(a, b, epsilon = T.unsafe(nil), msg = T.unsafe(nil)); end
-  def refute_includes(collection, obj, msg = T.unsafe(nil)); end
-  def refute_instance_of(cls, obj, msg = T.unsafe(nil)); end
-  def refute_kind_of(cls, obj, msg = T.unsafe(nil)); end
-  def refute_match(matcher, obj, msg = T.unsafe(nil)); end
-  def refute_nil(obj, msg = T.unsafe(nil)); end
-  def refute_operator(o1, op, o2 = T.unsafe(nil), msg = T.unsafe(nil)); end
-  def refute_path_exists(path, msg = T.unsafe(nil)); end
-  def refute_predicate(o1, op, msg = T.unsafe(nil)); end
-  def refute_respond_to(obj, meth, msg = T.unsafe(nil)); end
-  def refute_same(exp, act, msg = T.unsafe(nil)); end
-  def skip(msg = T.unsafe(nil), bt = T.unsafe(nil)); end
-  def skip_until(y, m, d, msg); end
-  def skipped?; end
-  def things_to_diff(exp, act); end
-
-  class << self
-    def diff; end
-    def diff=(o); end
-  end
-end
-
-Minitest::Assertions::E = T.let(T.unsafe(nil), String)
-Minitest::Assertions::UNDEFINED = T.let(T.unsafe(nil), Object)
-
-class Minitest::BacktraceFilter
-  def filter(bt); end
-end
-
-Minitest::BacktraceFilter::MT_RE = T.let(T.unsafe(nil), Regexp)
-
-class Minitest::CompositeReporter < ::Minitest::AbstractReporter
-  def initialize(*reporters); end
-
-  def <<(reporter); end
-  def io; end
-  def passed?; end
-  def prerecord(klass, name); end
-  def record(result); end
-  def report; end
-  def reporters; end
-  def reporters=(_arg0); end
-  def start; end
-end
-
-module Minitest::Guard
-  def jruby?(platform = T.unsafe(nil)); end
-  def maglev?(platform = T.unsafe(nil)); end
-  def mri?(platform = T.unsafe(nil)); end
-  def osx?(platform = T.unsafe(nil)); end
-  def rubinius?(platform = T.unsafe(nil)); end
-  def windows?(platform = T.unsafe(nil)); end
-end
-
-module Minitest::Parallel; end
-
-class Minitest::Parallel::Executor
-  def initialize(size); end
-
-  def <<(work); end
-  def shutdown; end
-  def size; end
-  def start; end
-end
-
-module Minitest::Parallel::Test
-  def _synchronize; end
-end
-
-module Minitest::Parallel::Test::ClassMethods
-  def run_one_method(klass, method_name, reporter); end
-  def test_order; end
-end
-
-class Minitest::ProgressReporter < ::Minitest::Reporter
-  def prerecord(klass, name); end
-  def record(result); end
-end
-
-module Minitest::Reportable
-  def class_name; end
-  def error?; end
-  def location; end
-  def passed?; end
-  def result_code; end
-  def skipped?; end
-end
-
-class Minitest::Reporter < ::Minitest::AbstractReporter
-  def initialize(io = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def io; end
-  def io=(_arg0); end
-  def options; end
-  def options=(_arg0); end
-end
-
-class Minitest::Result < ::Minitest::Runnable
-  include ::Minitest::Reportable
-
-  def class_name; end
-  def klass; end
-  def klass=(_arg0); end
-  def source_location; end
-  def source_location=(_arg0); end
-  def to_s; end
-
-  class << self
-    def from(runnable); end
-  end
-end
-
-class Minitest::Runnable
-  def initialize(name); end
-
-  def assertions; end
-  def assertions=(_arg0); end
-  def failure; end
-  def failures; end
-  def failures=(_arg0); end
-  def marshal_dump; end
-  def marshal_load(ary); end
-  def name; end
-  def name=(o); end
-  def passed?; end
-  def result_code; end
-  def run; end
-  def skipped?; end
-  def time; end
-  def time=(_arg0); end
-  def time_it; end
-
-  class << self
-    def inherited(klass); end
-    def methods_matching(re); end
-    def on_signal(name, action); end
-    def reset; end
-    def run(reporter, options = T.unsafe(nil)); end
-    def run_one_method(klass, method_name, reporter); end
-    def runnable_methods; end
-    def runnables; end
-    def with_info_handler(reporter, &block); end
-  end
-end
-
-Minitest::Runnable::SIGNALS = T.let(T.unsafe(nil), Hash)
-
-class Minitest::Skip < ::Minitest::Assertion
-  def result_label; end
-end
-
-class Minitest::StatisticsReporter < ::Minitest::Reporter
-  def initialize(io = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def assertions; end
-  def assertions=(_arg0); end
-  def count; end
-  def count=(_arg0); end
-  def errors; end
-  def errors=(_arg0); end
-  def failures; end
-  def failures=(_arg0); end
-  def passed?; end
-  def record(result); end
-  def report; end
-  def results; end
-  def results=(_arg0); end
-  def skips; end
-  def skips=(_arg0); end
-  def start; end
-  def start_time; end
-  def start_time=(_arg0); end
-  def total_time; end
-  def total_time=(_arg0); end
-end
-
-class Minitest::SummaryReporter < ::Minitest::StatisticsReporter
-  def aggregated_results(io); end
-  def old_sync; end
-  def old_sync=(_arg0); end
-  def report; end
-  def start; end
-  def statistics; end
-  def summary; end
-  def sync; end
-  def sync=(_arg0); end
-  def to_s; end
-
-  private
-
-  def binary_string; end
-end
-
-class Minitest::Test < ::Minitest::Runnable
-  include ::Minitest::Assertions
-  include ::Minitest::Reportable
-  include ::Minitest::Test::LifecycleHooks
-  include ::Minitest::Guard
-  extend ::Minitest::Guard
-
-  def capture_exceptions; end
-  def class_name; end
-  def neuter_exception(e); end
-  def new_exception(klass, msg, bt, kill = T.unsafe(nil)); end
-  def run; end
-  def sanitize_exception(e); end
-  def with_info_handler(&block); end
-
-  class << self
-    def i_suck_and_my_tests_are_order_dependent!; end
-    def io_lock; end
-    def io_lock=(_arg0); end
-    def make_my_diffs_pretty!; end
-    def parallelize_me!; end
-    def runnable_methods; end
-    def test_order; end
-  end
-end
-
-module Minitest::Test::LifecycleHooks
-  def after_setup; end
-  def after_teardown; end
-  def before_setup; end
-  def before_teardown; end
-  def setup; end
-  def teardown; end
-end
-
-Minitest::Test::PASSTHROUGH_EXCEPTIONS = T.let(T.unsafe(nil), Array)
-Minitest::Test::TEARDOWN_METHODS = T.let(T.unsafe(nil), Array)
-
-class Minitest::UnexpectedError < ::Minitest::Assertion
-  def initialize(error); end
-
-  def backtrace; end
-  def error; end
-  def error=(_arg0); end
-  def message; end
-  def result_label; end
-end
-
-class Minitest::Unit
-  class << self
-    def after_tests(&b); end
-    def autorun; end
-  end
-end
-
-class Minitest::Unit::TestCase < ::Minitest::Test
-  class << self
-    def inherited(klass); end
-  end
-end
-
-Minitest::Unit::VERSION = T.let(T.unsafe(nil), String)
-Minitest::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/minitest@5.25.1.rbi b/Library/Homebrew/sorbet/rbi/gems/minitest@5.25.1.rbi
new file mode 100644
index 0000000000000..bc0cba202971d
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/minitest@5.25.1.rbi
@@ -0,0 +1,1546 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `minitest` gem.
+# Please instead update this file by running `bin/tapioca gem minitest`.
+
+
+# :include: README.rdoc
+#
+# source://minitest//lib/minitest/parallel.rb#1
+module Minitest
+  class << self
+    # Internal run method. Responsible for telling all Runnable
+    # sub-classes to run.
+    #
+    # source://minitest//lib/minitest.rb#322
+    def __run(reporter, options); end
+
+    # A simple hook allowing you to run a block of code after everything
+    # is done running. Eg:
+    #
+    #   Minitest.after_run { p $debugging_info }
+    #
+    # source://minitest//lib/minitest.rb#96
+    def after_run(&block); end
+
+    # source://minitest//lib/minitest.rb#19
+    def allow_fork; end
+
+    # source://minitest//lib/minitest.rb#19
+    def allow_fork=(_arg0); end
+
+    # Registers Minitest to run at process exit
+    #
+    # source://minitest//lib/minitest.rb#69
+    def autorun; end
+
+    # source://minitest//lib/minitest.rb#19
+    def backtrace_filter; end
+
+    # source://minitest//lib/minitest.rb#19
+    def backtrace_filter=(_arg0); end
+
+    # source://minitest//lib/minitest.rb#18
+    def cattr_accessor(name); end
+
+    # source://minitest//lib/minitest.rb#1215
+    def clock_time; end
+
+    # source://minitest//lib/minitest.rb#302
+    def empty_run!(options); end
+
+    # source://minitest//lib/minitest.rb#19
+    def extensions; end
+
+    # source://minitest//lib/minitest.rb#19
+    def extensions=(_arg0); end
+
+    # source://minitest//lib/minitest.rb#335
+    def filter_backtrace(bt); end
+
+    # source://minitest//lib/minitest.rb#19
+    def info_signal; end
+
+    # source://minitest//lib/minitest.rb#19
+    def info_signal=(_arg0); end
+
+    # source://minitest//lib/minitest.rb#124
+    def init_plugins(options); end
+
+    # source://minitest//lib/minitest.rb#108
+    def load_plugins; end
+
+    # source://minitest//lib/minitest.rb#19
+    def parallel_executor; end
+
+    # source://minitest//lib/minitest.rb#19
+    def parallel_executor=(_arg0); end
+
+    # source://minitest//lib/minitest.rb#142
+    def process_args(args = T.unsafe(nil)); end
+
+    # Register a plugin to be used. Does NOT require / load it.
+    #
+    # source://minitest//lib/minitest.rb#103
+    def register_plugin(name_or_mod); end
+
+    # source://minitest//lib/minitest.rb#19
+    def reporter; end
+
+    # source://minitest//lib/minitest.rb#19
+    def reporter=(_arg0); end
+
+    # This is the top-level run method. Everything starts from here. It
+    # tells each Runnable sub-class to run, and each of those are
+    # responsible for doing whatever they do.
+    #
+    # The overall structure of a run looks like this:
+    #
+    #   Minitest.autorun
+    #     Minitest.run(args)
+    #       Minitest.load_plugins
+    #       Minitest.process_args
+    #       Minitest.init_plugins
+    #       Minitest.__run(reporter, options)
+    #         Runnable.runnables.each
+    #           runnable_klass.run(reporter, options)
+    #             self.runnable_methods.each
+    #               self.run_one_method(self, runnable_method, reporter)
+    #                 Minitest.run_one_method(klass, runnable_method)
+    #                   klass.new(runnable_method).run
+    #
+    # source://minitest//lib/minitest.rb#268
+    def run(args = T.unsafe(nil)); end
+
+    # source://minitest//lib/minitest.rb#1206
+    def run_one_method(klass, method_name); end
+
+    # source://minitest//lib/minitest.rb#19
+    def seed; end
+
+    # source://minitest//lib/minitest.rb#19
+    def seed=(_arg0); end
+  end
+end
+
+# Defines the API for Reporters. Subclass this and override whatever
+# you want. Go nuts.
+#
+# source://minitest//lib/minitest.rb#686
+class Minitest::AbstractReporter
+  # @return [AbstractReporter] a new instance of AbstractReporter
+  #
+  # source://minitest//lib/minitest.rb#688
+  def initialize; end
+
+  # Did this run pass?
+  #
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#723
+  def passed?; end
+
+  # About to start running a test. This allows a reporter to show
+  # that it is starting or that we are in the middle of a test run.
+  #
+  # source://minitest//lib/minitest.rb#702
+  def prerecord(klass, name); end
+
+  # Output and record the result of the test. Call
+  # {result#result_code}[rdoc-ref:Runnable#result_code] to get the
+  # result character string. Stores the result of the run if the run
+  # did not pass.
+  #
+  # source://minitest//lib/minitest.rb#711
+  def record(result); end
+
+  # Outputs the summary of the run.
+  #
+  # source://minitest//lib/minitest.rb#717
+  def report; end
+
+  # Starts reporting on the run.
+  #
+  # source://minitest//lib/minitest.rb#695
+  def start; end
+
+  # source://minitest//lib/minitest.rb#727
+  def synchronize(&block); end
+end
+
+# Represents run failures.
+#
+# source://minitest//lib/minitest.rb#1019
+class Minitest::Assertion < ::Exception
+  # source://minitest//lib/minitest.rb#1022
+  def error; end
+
+  # Where was this run before an assertion was raised?
+  #
+  # source://minitest//lib/minitest.rb#1029
+  def location; end
+
+  # source://minitest//lib/minitest.rb#1037
+  def result_code; end
+
+  # source://minitest//lib/minitest.rb#1041
+  def result_label; end
+end
+
+# source://minitest//lib/minitest.rb#1020
+Minitest::Assertion::RE = T.let(T.unsafe(nil), Regexp)
+
+# Minitest Assertions.  All assertion methods accept a +msg+ which is
+# printed if the assertion fails.
+#
+# Protocol: Nearly everything here boils up to +assert+, which
+# expects to be able to increment an instance accessor named
+# +assertions+. This is not provided by Assertions and must be
+# provided by the thing including Assertions. See Minitest::Runnable
+# for an example.
+#
+# source://minitest//lib/minitest/assertions.rb#16
+module Minitest::Assertions
+  # source://minitest//lib/minitest/assertions.rb#181
+  def _synchronize; end
+
+  # source://minitest//lib/minitest/assertions.rb#194
+  def _where; end
+
+  # Fails unless +test+ is truthy.
+  #
+  # source://minitest//lib/minitest/assertions.rb#171
+  def assert(test, msg = T.unsafe(nil)); end
+
+  # Fails unless +obj+ is empty.
+  #
+  # source://minitest//lib/minitest/assertions.rb#188
+  def assert_empty(obj, msg = T.unsafe(nil)); end
+
+  # Fails unless <tt>exp == act</tt> printing the difference between
+  # the two, if possible.
+  #
+  # If there is no visible difference but the assertion fails, you
+  # should suspect that your #== is buggy, or your inspect output is
+  # missing crucial details.  For nicer structural diffing, set
+  # Minitest::Test.make_my_diffs_pretty!
+  #
+  # For floats use assert_in_delta.
+  #
+  # See also: Minitest::Assertions.diff
+  #
+  # source://minitest//lib/minitest/assertions.rb#214
+  def assert_equal(exp, act, msg = T.unsafe(nil)); end
+
+  # For comparing Floats.  Fails unless +exp+ and +act+ are within +delta+
+  # of each other.
+  #
+  #   assert_in_delta Math::PI, (22.0 / 7.0), 0.01
+  #
+  # source://minitest//lib/minitest/assertions.rb#235
+  def assert_in_delta(exp, act, delta = T.unsafe(nil), msg = T.unsafe(nil)); end
+
+  # For comparing Floats.  Fails unless +exp+ and +act+ have a relative
+  # error less than +epsilon+.
+  #
+  # source://minitest//lib/minitest/assertions.rb#247
+  def assert_in_epsilon(exp, act, epsilon = T.unsafe(nil), msg = T.unsafe(nil)); end
+
+  # Fails unless +collection+ includes +obj+.
+  #
+  # source://minitest//lib/minitest/assertions.rb#254
+  def assert_includes(collection, obj, msg = T.unsafe(nil)); end
+
+  # Fails unless +obj+ is an instance of +cls+.
+  #
+  # source://minitest//lib/minitest/assertions.rb#265
+  def assert_instance_of(cls, obj, msg = T.unsafe(nil)); end
+
+  # Fails unless +obj+ is a kind of +cls+.
+  #
+  # source://minitest//lib/minitest/assertions.rb#276
+  def assert_kind_of(cls, obj, msg = T.unsafe(nil)); end
+
+  # Fails unless +matcher+ <tt>=~</tt> +obj+.
+  #
+  # source://minitest//lib/minitest/assertions.rb#287
+  def assert_match(matcher, obj, msg = T.unsafe(nil)); end
+
+  # Fails unless +obj+ is nil
+  #
+  # source://minitest//lib/minitest/assertions.rb#299
+  def assert_nil(obj, msg = T.unsafe(nil)); end
+
+  # For testing with binary operators. Eg:
+  #
+  #   assert_operator 5, :<=, 4
+  #
+  # source://minitest//lib/minitest/assertions.rb#309
+  def assert_operator(o1, op, o2 = T.unsafe(nil), msg = T.unsafe(nil)); end
+
+  # Fails if stdout or stderr do not output the expected results.
+  # Pass in nil if you don't care about that streams output. Pass in
+  # "" if you require it to be silent. Pass in a regexp if you want
+  # to pattern match.
+  #
+  #   assert_output(/hey/) { method_with_output }
+  #
+  # NOTE: this uses #capture_io, not #capture_subprocess_io.
+  #
+  # See also: #assert_silent
+  #
+  # source://minitest//lib/minitest/assertions.rb#327
+  def assert_output(stdout = T.unsafe(nil), stderr = T.unsafe(nil)); end
+
+  # Fails unless +path+ exists.
+  #
+  # source://minitest//lib/minitest/assertions.rb#351
+  def assert_path_exists(path, msg = T.unsafe(nil)); end
+
+  # For testing with pattern matching (only supported with Ruby 3.0 and later)
+  #
+  #   # pass
+  #   assert_pattern { [1,2,3] => [Integer, Integer, Integer] }
+  #
+  #   # fail "length mismatch (given 3, expected 1)"
+  #   assert_pattern { [1,2,3] => [Integer] }
+  #
+  # The bare <tt>=></tt> pattern will raise a NoMatchingPatternError on failure, which would
+  # normally be counted as a test error. This assertion rescues NoMatchingPatternError and
+  # generates a test failure. Any other exception will be raised as normal and generate a test
+  # error.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://minitest//lib/minitest/assertions.rb#370
+  def assert_pattern; end
+
+  # For testing with predicates. Eg:
+  #
+  #   assert_predicate str, :empty?
+  #
+  # This is really meant for specs and is front-ended by assert_operator:
+  #
+  #   str.must_be :empty?
+  #
+  # source://minitest//lib/minitest/assertions.rb#391
+  def assert_predicate(o1, op, msg = T.unsafe(nil)); end
+
+  # Fails unless the block raises one of +exp+. Returns the
+  # exception matched so you can check the message, attributes, etc.
+  #
+  # +exp+ takes an optional message on the end to help explain
+  # failures and defaults to StandardError if no exception class is
+  # passed. Eg:
+  #
+  #   assert_raises(CustomError) { method_with_custom_error }
+  #
+  # With custom error message:
+  #
+  #   assert_raises(CustomError, 'This should have raised CustomError') { method_with_custom_error }
+  #
+  # Using the returned object:
+  #
+  #   error = assert_raises(CustomError) do
+  #     raise CustomError, 'This is really bad'
+  #   end
+  #
+  #   assert_equal 'This is really bad', error.message
+  #
+  # source://minitest//lib/minitest/assertions.rb#418
+  def assert_raises(*exp); end
+
+  # Fails unless +obj+ responds to +meth+.
+  # include_all defaults to false to match Object#respond_to?
+  #
+  # source://minitest//lib/minitest/assertions.rb#450
+  def assert_respond_to(obj, meth, msg = T.unsafe(nil), include_all: T.unsafe(nil)); end
+
+  # Fails unless +exp+ and +act+ are #equal?
+  #
+  # source://minitest//lib/minitest/assertions.rb#460
+  def assert_same(exp, act, msg = T.unsafe(nil)); end
+
+  # +send_ary+ is a receiver, message and arguments.
+  #
+  # Fails unless the call returns a true value
+  #
+  # source://minitest//lib/minitest/assertions.rb#473
+  def assert_send(send_ary, m = T.unsafe(nil)); end
+
+  # Fails if the block outputs anything to stderr or stdout.
+  #
+  # See also: #assert_output
+  #
+  # source://minitest//lib/minitest/assertions.rb#488
+  def assert_silent; end
+
+  # Fails unless the block throws +sym+
+  #
+  # source://minitest//lib/minitest/assertions.rb#497
+  def assert_throws(sym, msg = T.unsafe(nil)); end
+
+  # Captures $stdout and $stderr into strings:
+  #
+  #   out, err = capture_io do
+  #     puts "Some info"
+  #     warn "You did a bad thing"
+  #   end
+  #
+  #   assert_match %r%info%, out
+  #   assert_match %r%bad%, err
+  #
+  # NOTE: For efficiency, this method uses StringIO and does not
+  # capture IO for subprocesses. Use #capture_subprocess_io for
+  # that.
+  #
+  # source://minitest//lib/minitest/assertions.rb#538
+  def capture_io; end
+
+  # Captures $stdout and $stderr into strings, using Tempfile to
+  # ensure that subprocess IO is captured as well.
+  #
+  #   out, err = capture_subprocess_io do
+  #     system "echo Some info"
+  #     system "echo You did a bad thing 1>&2"
+  #   end
+  #
+  #   assert_match %r%info%, out
+  #   assert_match %r%bad%, err
+  #
+  # NOTE: This method is approximately 10x slower than #capture_io so
+  # only use it when you need to test the output of a subprocess.
+  #
+  # source://minitest//lib/minitest/assertions.rb#571
+  def capture_subprocess_io; end
+
+  # Returns a diff between +exp+ and +act+. If there is no known
+  # diff command or if it doesn't make sense to diff the output
+  # (single line, short output), then it simply returns a basic
+  # comparison between the two.
+  #
+  # See +things_to_diff+ for more info.
+  #
+  # source://minitest//lib/minitest/assertions.rb#57
+  def diff(exp, act); end
+
+  # Returns details for exception +e+
+  #
+  # source://minitest//lib/minitest/assertions.rb#603
+  def exception_details(e, msg); end
+
+  # Fails after a given date (in the local time zone). This allows
+  # you to put time-bombs in your tests if you need to keep
+  # something around until a later date lest you forget about it.
+  #
+  # source://minitest//lib/minitest/assertions.rb#619
+  def fail_after(y, m, d, msg); end
+
+  # Fails with +msg+.
+  #
+  # source://minitest//lib/minitest/assertions.rb#626
+  def flunk(msg = T.unsafe(nil)); end
+
+  # Returns a proc that will output +msg+ along with the default message.
+  #
+  # source://minitest//lib/minitest/assertions.rb#634
+  def message(msg = T.unsafe(nil), ending = T.unsafe(nil), &default); end
+
+  # This returns a human-readable version of +obj+. By default
+  # #inspect is called. You can override this to use #pretty_inspect
+  # if you want.
+  #
+  # See Minitest::Test.make_my_diffs_pretty!
+  #
+  # source://minitest//lib/minitest/assertions.rb#127
+  def mu_pp(obj); end
+
+  # This returns a diff-able more human-readable version of +obj+.
+  # This differs from the regular mu_pp because it expands escaped
+  # newlines and makes hex-values (like object_ids) generic. This
+  # uses mu_pp to do the first pass and then cleans it up.
+  #
+  # source://minitest//lib/minitest/assertions.rb#145
+  def mu_pp_for_diff(obj); end
+
+  # used for counting assertions
+  #
+  # source://minitest//lib/minitest/assertions.rb#645
+  def pass(_msg = T.unsafe(nil)); end
+
+  # Fails if +test+ is truthy.
+  #
+  # source://minitest//lib/minitest/assertions.rb#652
+  def refute(test, msg = T.unsafe(nil)); end
+
+  # Fails if +obj+ is empty.
+  #
+  # source://minitest//lib/minitest/assertions.rb#660
+  def refute_empty(obj, msg = T.unsafe(nil)); end
+
+  # Fails if <tt>exp == act</tt>.
+  #
+  # For floats use refute_in_delta.
+  #
+  # source://minitest//lib/minitest/assertions.rb#671
+  def refute_equal(exp, act, msg = T.unsafe(nil)); end
+
+  # For comparing Floats.  Fails if +exp+ is within +delta+ of +act+.
+  #
+  #   refute_in_delta Math::PI, (22.0 / 7.0)
+  #
+  # source://minitest//lib/minitest/assertions.rb#683
+  def refute_in_delta(exp, act, delta = T.unsafe(nil), msg = T.unsafe(nil)); end
+
+  # For comparing Floats.  Fails if +exp+ and +act+ have a relative error
+  # less than +epsilon+.
+  #
+  # source://minitest//lib/minitest/assertions.rb#695
+  def refute_in_epsilon(a, b, epsilon = T.unsafe(nil), msg = T.unsafe(nil)); end
+
+  # Fails if +collection+ includes +obj+.
+  #
+  # source://minitest//lib/minitest/assertions.rb#702
+  def refute_includes(collection, obj, msg = T.unsafe(nil)); end
+
+  # Fails if +obj+ is an instance of +cls+.
+  #
+  # source://minitest//lib/minitest/assertions.rb#713
+  def refute_instance_of(cls, obj, msg = T.unsafe(nil)); end
+
+  # Fails if +obj+ is a kind of +cls+.
+  #
+  # source://minitest//lib/minitest/assertions.rb#723
+  def refute_kind_of(cls, obj, msg = T.unsafe(nil)); end
+
+  # Fails if +matcher+ <tt>=~</tt> +obj+.
+  #
+  # source://minitest//lib/minitest/assertions.rb#731
+  def refute_match(matcher, obj, msg = T.unsafe(nil)); end
+
+  # Fails if +obj+ is nil.
+  #
+  # source://minitest//lib/minitest/assertions.rb#741
+  def refute_nil(obj, msg = T.unsafe(nil)); end
+
+  # Fails if +o1+ is not +op+ +o2+. Eg:
+  #
+  #   refute_operator 1, :>, 2 #=> pass
+  #   refute_operator 1, :<, 2 #=> fail
+  #
+  # source://minitest//lib/minitest/assertions.rb#776
+  def refute_operator(o1, op, o2 = T.unsafe(nil), msg = T.unsafe(nil)); end
+
+  # Fails if +path+ exists.
+  #
+  # source://minitest//lib/minitest/assertions.rb#785
+  def refute_path_exists(path, msg = T.unsafe(nil)); end
+
+  # For testing with pattern matching (only supported with Ruby 3.0 and later)
+  #
+  #   # pass
+  #   refute_pattern { [1,2,3] => [String] }
+  #
+  #   # fail "NoMatchingPatternError expected, but nothing was raised."
+  #   refute_pattern { [1,2,3] => [Integer, Integer, Integer] }
+  #
+  # This assertion expects a NoMatchingPatternError exception, and will fail if none is raised. Any
+  # other exceptions will be raised as normal and generate a test error.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://minitest//lib/minitest/assertions.rb#758
+  def refute_pattern; end
+
+  # For testing with predicates.
+  #
+  #   refute_predicate str, :empty?
+  #
+  # This is really meant for specs and is front-ended by refute_operator:
+  #
+  #   str.wont_be :empty?
+  #
+  # source://minitest//lib/minitest/assertions.rb#799
+  def refute_predicate(o1, op, msg = T.unsafe(nil)); end
+
+  # Fails if +obj+ responds to the message +meth+.
+  # include_all defaults to false to match Object#respond_to?
+  #
+  # source://minitest//lib/minitest/assertions.rb#808
+  def refute_respond_to(obj, meth, msg = T.unsafe(nil), include_all: T.unsafe(nil)); end
+
+  # Fails if +exp+ is the same (by object identity) as +act+.
+  #
+  # source://minitest//lib/minitest/assertions.rb#817
+  def refute_same(exp, act, msg = T.unsafe(nil)); end
+
+  # Skips the current run. If run in verbose-mode, the skipped run
+  # gets listed at the end of the run but doesn't cause a failure
+  # exit code.
+  #
+  # @raise [Minitest::Skip]
+  #
+  # source://minitest//lib/minitest/assertions.rb#830
+  def skip(msg = T.unsafe(nil), _ignored = T.unsafe(nil)); end
+
+  # Skips the current run until a given date (in the local time
+  # zone). This allows you to put some fixes on hold until a later
+  # date, but still holds you accountable and prevents you from
+  # forgetting it.
+  #
+  # source://minitest//lib/minitest/assertions.rb#842
+  def skip_until(y, m, d, msg); end
+
+  # Was this testcase skipped? Meant for #teardown.
+  #
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest/assertions.rb#851
+  def skipped?; end
+
+  # Returns things to diff [expect, butwas], or [nil, nil] if nothing to diff.
+  #
+  # Criterion:
+  #
+  # 1. Strings include newlines or escaped newlines, but not both.
+  # 2. or:  String lengths are > 30 characters.
+  # 3. or:  Strings are equal to each other (but maybe different encodings?).
+  # 4. and: we found a diff executable.
+  #
+  # source://minitest//lib/minitest/assertions.rb#102
+  def things_to_diff(exp, act); end
+
+  class << self
+    # Returns the diff command to use in #diff. Tries to intelligently
+    # figure out what diff to use.
+    #
+    # source://minitest//lib/minitest/assertions.rb#27
+    def diff; end
+
+    # Set the diff command to use in #diff.
+    #
+    # source://minitest//lib/minitest/assertions.rb#45
+    def diff=(o); end
+  end
+end
+
+# source://minitest//lib/minitest/assertions.rb#199
+Minitest::Assertions::E = T.let(T.unsafe(nil), String)
+
+# source://minitest//lib/minitest/assertions.rb#17
+Minitest::Assertions::UNDEFINED = T.let(T.unsafe(nil), Object)
+
+# The standard backtrace filter for minitest.
+#
+# See Minitest.backtrace_filter=.
+#
+# source://minitest//lib/minitest.rb#1174
+class Minitest::BacktraceFilter
+  # @return [BacktraceFilter] a new instance of BacktraceFilter
+  #
+  # source://minitest//lib/minitest.rb#1183
+  def initialize(regexp = T.unsafe(nil)); end
+
+  # Filter +bt+ to something useful. Returns the whole thing if
+  # $DEBUG (ruby) or $MT_DEBUG (env).
+  #
+  # source://minitest//lib/minitest.rb#1191
+  def filter(bt); end
+
+  # The regular expression to use to filter backtraces. Defaults to +MT_RE+.
+  #
+  # source://minitest//lib/minitest.rb#1181
+  def regexp; end
+
+  # The regular expression to use to filter backtraces. Defaults to +MT_RE+.
+  #
+  # source://minitest//lib/minitest.rb#1181
+  def regexp=(_arg0); end
+end
+
+# source://minitest//lib/minitest.rb#1176
+Minitest::BacktraceFilter::MT_RE = T.let(T.unsafe(nil), Regexp)
+
+# Dispatch to multiple reporters as one.
+#
+# source://minitest//lib/minitest.rb#968
+class Minitest::CompositeReporter < ::Minitest::AbstractReporter
+  # @return [CompositeReporter] a new instance of CompositeReporter
+  #
+  # source://minitest//lib/minitest.rb#974
+  def initialize(*reporters); end
+
+  # Add another reporter to the mix.
+  #
+  # source://minitest//lib/minitest.rb#986
+  def <<(reporter); end
+
+  # source://minitest//lib/minitest.rb#979
+  def io; end
+
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#990
+  def passed?; end
+
+  # source://minitest//lib/minitest.rb#998
+  def prerecord(klass, name); end
+
+  # source://minitest//lib/minitest.rb#1005
+  def record(result); end
+
+  # source://minitest//lib/minitest.rb#1011
+  def report; end
+
+  # The list of reporters to dispatch to.
+  #
+  # source://minitest//lib/minitest.rb#972
+  def reporters; end
+
+  # The list of reporters to dispatch to.
+  #
+  # source://minitest//lib/minitest.rb#972
+  def reporters=(_arg0); end
+
+  # source://minitest//lib/minitest.rb#994
+  def start; end
+end
+
+# Compresses backtraces.
+#
+# source://minitest//lib/minitest/compress.rb#5
+module Minitest::Compress
+  # Takes a backtrace (array of strings) and compresses repeating
+  # cycles in it to make it more readable.
+  #
+  # source://minitest//lib/minitest/compress.rb#11
+  def compress(orig); end
+end
+
+# Provides a simple set of guards that you can use in your tests
+# to skip execution if it is not applicable. These methods are
+# mixed into Test as both instance and class methods so you
+# can use them inside or outside of the test methods.
+#
+#   def test_something_for_mri
+#     skip "bug 1234"  if jruby?
+#     # ...
+#   end
+#
+#   if windows? then
+#     # ... lots of test methods ...
+#   end
+#
+# source://minitest//lib/minitest.rb#1118
+module Minitest::Guard
+  # Is this running on jruby?
+  #
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#1123
+  def jruby?(platform = T.unsafe(nil)); end
+
+  # Is this running on maglev?
+  #
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#1130
+  def maglev?(platform = T.unsafe(nil)); end
+
+  # Is this running on mri?
+  #
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#1140
+  def mri?(platform = T.unsafe(nil)); end
+
+  # Is this running on macOS?
+  #
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#1147
+  def osx?(platform = T.unsafe(nil)); end
+
+  # Is this running on rubinius?
+  #
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#1154
+  def rubinius?(platform = T.unsafe(nil)); end
+
+  # Is this running on windows?
+  #
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#1164
+  def windows?(platform = T.unsafe(nil)); end
+end
+
+# source://minitest//lib/minitest/parallel.rb#2
+module Minitest::Parallel; end
+
+# The engine used to run multiple tests in parallel.
+#
+# source://minitest//lib/minitest/parallel.rb#7
+class Minitest::Parallel::Executor
+  # Create a parallel test executor of with +size+ workers.
+  #
+  # @return [Executor] a new instance of Executor
+  #
+  # source://minitest//lib/minitest/parallel.rb#17
+  def initialize(size); end
+
+  # Add a job to the queue
+  #
+  # source://minitest//lib/minitest/parallel.rb#43
+  def <<(work); end
+
+  # Shuts down the pool of workers by signalling them to quit and
+  # waiting for them all to finish what they're currently working
+  # on.
+  #
+  # source://minitest//lib/minitest/parallel.rb#50
+  def shutdown; end
+
+  # The size of the pool of workers.
+  #
+  # source://minitest//lib/minitest/parallel.rb#12
+  def size; end
+
+  # Start the executor
+  #
+  # source://minitest//lib/minitest/parallel.rb#26
+  def start; end
+end
+
+# source://minitest//lib/minitest/parallel.rb#56
+module Minitest::Parallel::Test
+  # source://minitest//lib/minitest/parallel.rb#57
+  def _synchronize; end
+end
+
+# source://minitest//lib/minitest/parallel.rb#59
+module Minitest::Parallel::Test::ClassMethods
+  # source://minitest//lib/minitest/parallel.rb#60
+  def run_one_method(klass, method_name, reporter); end
+
+  # source://minitest//lib/minitest/parallel.rb#64
+  def test_order; end
+end
+
+# A very simple reporter that prints the "dots" during the run.
+#
+# This is added to the top-level CompositeReporter at the start of
+# the run. If you want to change the output of minitest via a
+# plugin, pull this out of the composite and replace it with your
+# own.
+#
+# source://minitest//lib/minitest.rb#758
+class Minitest::ProgressReporter < ::Minitest::Reporter
+  # source://minitest//lib/minitest.rb#759
+  def prerecord(klass, name); end
+
+  # source://minitest//lib/minitest.rb#766
+  def record(result); end
+end
+
+# Shared code for anything that can get passed to a Reporter. See
+# Minitest::Test & Minitest::Result.
+#
+# source://minitest//lib/minitest.rb#580
+module Minitest::Reportable
+  # @raise [NotImplementedError]
+  #
+  # source://minitest//lib/minitest.rb#602
+  def class_name; end
+
+  # Did this run error?
+  #
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#623
+  def error?; end
+
+  # The location identifier of this test. Depends on a method
+  # existing called class_name.
+  #
+  # source://minitest//lib/minitest.rb#597
+  def location; end
+
+  # Did this run pass?
+  #
+  # Note: skipped runs are not considered passing, but they don't
+  # cause the process to exit non-zero.
+  #
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#587
+  def passed?; end
+
+  # Returns ".", "F", or "E" based on the result of the run.
+  #
+  # source://minitest//lib/minitest.rb#609
+  def result_code; end
+
+  # Was this run skipped?
+  #
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#616
+  def skipped?; end
+end
+
+# source://minitest//lib/minitest.rb#591
+Minitest::Reportable::BASE_DIR = T.let(T.unsafe(nil), String)
+
+# source://minitest//lib/minitest.rb#734
+class Minitest::Reporter < ::Minitest::AbstractReporter
+  # @return [Reporter] a new instance of Reporter
+  #
+  # source://minitest//lib/minitest.rb#743
+  def initialize(io = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  # The IO used to report.
+  #
+  # source://minitest//lib/minitest.rb#736
+  def io; end
+
+  # The IO used to report.
+  #
+  # source://minitest//lib/minitest.rb#736
+  def io=(_arg0); end
+
+  # Command-line options for this run.
+  #
+  # source://minitest//lib/minitest.rb#741
+  def options; end
+
+  # Command-line options for this run.
+  #
+  # source://minitest//lib/minitest.rb#741
+  def options=(_arg0); end
+end
+
+# This represents a test result in a clean way that can be
+# marshalled over a wire. Tests can do anything they want to the
+# test instance and can create conditions that cause Marshal.dump to
+# blow up. By using Result.from(a_test) you can be reasonably sure
+# that the test result can be marshalled.
+#
+# source://minitest//lib/minitest.rb#635
+class Minitest::Result < ::Minitest::Runnable
+  include ::Minitest::Reportable
+
+  # source://minitest//lib/minitest.rb#669
+  def class_name; end
+
+  # The class name of the test result.
+  #
+  # source://minitest//lib/minitest.rb#644
+  def klass; end
+
+  # The class name of the test result.
+  #
+  # source://minitest//lib/minitest.rb#644
+  def klass=(_arg0); end
+
+  # The location of the test method.
+  #
+  # source://minitest//lib/minitest.rb#649
+  def source_location; end
+
+  # The location of the test method.
+  #
+  # source://minitest//lib/minitest.rb#649
+  def source_location=(_arg0); end
+
+  # source://minitest//lib/minitest.rb#673
+  def to_s; end
+
+  class << self
+    # Create a new test result from a Runnable instance.
+    #
+    # source://minitest//lib/minitest.rb#654
+    def from(runnable); end
+  end
+end
+
+# re-open
+#
+# source://minitest//lib/minitest.rb#348
+class Minitest::Runnable
+  # @return [Runnable] a new instance of Runnable
+  #
+  # source://minitest//lib/minitest.rb#511
+  def initialize(name); end
+
+  # Number of assertions executed in this run.
+  #
+  # source://minitest//lib/minitest.rb#352
+  def assertions; end
+
+  # Number of assertions executed in this run.
+  #
+  # source://minitest//lib/minitest.rb#352
+  def assertions=(_arg0); end
+
+  # source://minitest//lib/minitest.rb#507
+  def failure; end
+
+  # An assertion raised during the run, if any.
+  #
+  # source://minitest//lib/minitest.rb#357
+  def failures; end
+
+  # An assertion raised during the run, if any.
+  #
+  # source://minitest//lib/minitest.rb#357
+  def failures=(_arg0); end
+
+  # source://minitest//lib/minitest.rb#493
+  def marshal_dump; end
+
+  # source://minitest//lib/minitest.rb#503
+  def marshal_load(ary); end
+
+  # Metadata you attach to the test results that get sent to the reporter.
+  #
+  # Lazily initializes to a hash, to keep memory down.
+  #
+  # NOTE: this data *must* be plain (read: marshal-able) data!
+  # Hashes! Arrays! Strings!
+  #
+  # source://minitest//lib/minitest.rb#526
+  def metadata; end
+
+  # Sets metadata, mainly used for +Result.from+.
+  #
+  # source://minitest//lib/minitest.rb#533
+  def metadata=(_arg0); end
+
+  # Returns true if metadata exists.
+  #
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#538
+  def metadata?; end
+
+  # Name of the run.
+  #
+  # source://minitest//lib/minitest.rb#375
+  def name; end
+
+  # Set the name of the run.
+  #
+  # source://minitest//lib/minitest.rb#382
+  def name=(o); end
+
+  # Did this run pass?
+  #
+  # Note: skipped runs are not considered passing, but they don't
+  # cause the process to exit non-zero.
+  #
+  # @raise [NotImplementedError]
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#555
+  def passed?; end
+
+  # Returns a single character string to print based on the result
+  # of the run. One of <tt>"."</tt>, <tt>"F"</tt>,
+  # <tt>"E"</tt> or <tt>"S"</tt>.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://minitest//lib/minitest.rb#564
+  def result_code; end
+
+  # Runs a single method. Needs to return self.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://minitest//lib/minitest.rb#545
+  def run; end
+
+  # Was this run skipped? See #passed? for more information.
+  #
+  # @raise [NotImplementedError]
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#571
+  def skipped?; end
+
+  # The time it took to run.
+  #
+  # source://minitest//lib/minitest.rb#362
+  def time; end
+
+  # The time it took to run.
+  #
+  # source://minitest//lib/minitest.rb#362
+  def time=(_arg0); end
+
+  # source://minitest//lib/minitest.rb#364
+  def time_it; end
+
+  class << self
+    # source://minitest//lib/minitest.rb#1225
+    def inherited(klass); end
+
+    # Returns all instance methods matching the pattern +re+.
+    #
+    # source://minitest//lib/minitest.rb#389
+    def methods_matching(re); end
+
+    # source://minitest//lib/minitest.rb#463
+    def on_signal(name, action); end
+
+    # source://minitest//lib/minitest.rb#393
+    def reset; end
+
+    # Responsible for running all runnable methods in a given class,
+    # each in its own instance. Each instance is passed to the
+    # reporter to record.
+    #
+    # source://minitest//lib/minitest.rb#404
+    def run(reporter, options = T.unsafe(nil)); end
+
+    # Runs a single method and has the reporter record the result.
+    # This was considered internal API but is factored out of run so
+    # that subclasses can specialize the running of an individual
+    # test. See Minitest::ParallelTest::ClassMethods for an example.
+    #
+    # source://minitest//lib/minitest.rb#444
+    def run_one_method(klass, method_name, reporter); end
+
+    # Each subclass of Runnable is responsible for overriding this
+    # method to return all runnable methods. See #methods_matching.
+    #
+    # @raise [NotImplementedError]
+    #
+    # source://minitest//lib/minitest.rb#480
+    def runnable_methods; end
+
+    # Returns all subclasses of Runnable.
+    #
+    # source://minitest//lib/minitest.rb#487
+    def runnables; end
+
+    # Defines the order to run tests (:random by default). Override
+    # this or use a convenience method to change it for your tests.
+    #
+    # source://minitest//lib/minitest.rb#453
+    def test_order; end
+
+    # source://minitest//lib/minitest.rb#457
+    def with_info_handler(reporter, &block); end
+  end
+end
+
+# source://minitest//lib/minitest.rb#461
+Minitest::Runnable::SIGNALS = T.let(T.unsafe(nil), Hash)
+
+# Assertion raised when skipping a run.
+#
+# source://minitest//lib/minitest.rb#1049
+class Minitest::Skip < ::Minitest::Assertion
+  # source://minitest//lib/minitest.rb#1050
+  def result_label; end
+end
+
+# A reporter that gathers statistics about a test run. Does not do
+# any IO because meant to be used as a parent class for a reporter
+# that does.
+#
+# If you want to create an entirely different type of output (eg,
+# CI, HTML, etc), this is the place to start.
+#
+# Example:
+#
+#   class JenkinsCIReporter < StatisticsReporter
+#     def report
+#       super  # Needed to calculate some statistics
+#
+#       print "<testsuite "
+#       print "tests='#{count}' "
+#       print "failures='#{failures}' "
+#       # Remaining XML...
+#     end
+#   end
+#
+# source://minitest//lib/minitest.rb#794
+class Minitest::StatisticsReporter < ::Minitest::Reporter
+  # @return [StatisticsReporter] a new instance of StatisticsReporter
+  #
+  # source://minitest//lib/minitest.rb#843
+  def initialize(io = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  # Total number of assertions.
+  #
+  # source://minitest//lib/minitest.rb#798
+  def assertions; end
+
+  # Total number of assertions.
+  #
+  # source://minitest//lib/minitest.rb#798
+  def assertions=(_arg0); end
+
+  # Total number of test cases.
+  #
+  # source://minitest//lib/minitest.rb#803
+  def count; end
+
+  # Total number of test cases.
+  #
+  # source://minitest//lib/minitest.rb#803
+  def count=(_arg0); end
+
+  # Total number of tests that erred.
+  #
+  # source://minitest//lib/minitest.rb#831
+  def errors; end
+
+  # Total number of tests that erred.
+  #
+  # source://minitest//lib/minitest.rb#831
+  def errors=(_arg0); end
+
+  # Total number of tests that failed.
+  #
+  # source://minitest//lib/minitest.rb#826
+  def failures; end
+
+  # Total number of tests that failed.
+  #
+  # source://minitest//lib/minitest.rb#826
+  def failures=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://minitest//lib/minitest.rb#857
+  def passed?; end
+
+  # source://minitest//lib/minitest.rb#865
+  def record(result); end
+
+  # Report on the tracked statistics.
+  #
+  # source://minitest//lib/minitest.rb#875
+  def report; end
+
+  # An +Array+ of test cases that failed or were skipped.
+  #
+  # source://minitest//lib/minitest.rb#808
+  def results; end
+
+  # An +Array+ of test cases that failed or were skipped.
+  #
+  # source://minitest//lib/minitest.rb#808
+  def results=(_arg0); end
+
+  # Total number of tests that where skipped.
+  #
+  # source://minitest//lib/minitest.rb#841
+  def skips; end
+
+  # Total number of tests that where skipped.
+  #
+  # source://minitest//lib/minitest.rb#841
+  def skips=(_arg0); end
+
+  # source://minitest//lib/minitest.rb#861
+  def start; end
+
+  # Time the test run started. If available, the monotonic clock is
+  # used and this is a +Float+, otherwise it's an instance of
+  # +Time+.
+  #
+  # source://minitest//lib/minitest.rb#815
+  def start_time; end
+
+  # Time the test run started. If available, the monotonic clock is
+  # used and this is a +Float+, otherwise it's an instance of
+  # +Time+.
+  #
+  # source://minitest//lib/minitest.rb#815
+  def start_time=(_arg0); end
+
+  # Test run time. If available, the monotonic clock is used and
+  # this is a +Float+, otherwise it's an instance of +Time+.
+  #
+  # source://minitest//lib/minitest.rb#821
+  def total_time; end
+
+  # Test run time. If available, the monotonic clock is used and
+  # this is a +Float+, otherwise it's an instance of +Time+.
+  #
+  # source://minitest//lib/minitest.rb#821
+  def total_time=(_arg0); end
+
+  # Total number of tests that warned.
+  #
+  # source://minitest//lib/minitest.rb#836
+  def warnings; end
+
+  # Total number of tests that warned.
+  #
+  # source://minitest//lib/minitest.rb#836
+  def warnings=(_arg0); end
+end
+
+# A reporter that prints the header, summary, and failure details at
+# the end of the run.
+#
+# This is added to the top-level CompositeReporter at the start of
+# the run. If you want to change the output of minitest via a
+# plugin, pull this out of the composite and replace it with your
+# own.
+#
+# source://minitest//lib/minitest.rb#896
+class Minitest::SummaryReporter < ::Minitest::StatisticsReporter
+  # source://minitest//lib/minitest.rb#929
+  def aggregated_results(io); end
+
+  # source://minitest//lib/minitest.rb#898
+  def old_sync; end
+
+  # source://minitest//lib/minitest.rb#898
+  def old_sync=(_arg0); end
+
+  # source://minitest//lib/minitest.rb#912
+  def report; end
+
+  # source://minitest//lib/minitest.rb#900
+  def start; end
+
+  # source://minitest//lib/minitest.rb#924
+  def statistics; end
+
+  # source://minitest//lib/minitest.rb#949
+  def summary; end
+
+  # source://minitest//lib/minitest.rb#897
+  def sync; end
+
+  # source://minitest//lib/minitest.rb#897
+  def sync=(_arg0); end
+
+  # source://minitest//lib/minitest.rb#945
+  def to_s; end
+end
+
+# Subclass Test to create your own tests. Typically you'll want a
+# Test subclass per implementation class.
+#
+# See Minitest::Assertions
+#
+# source://minitest//lib/minitest/test.rb#10
+class Minitest::Test < ::Minitest::Runnable
+  include ::Minitest::Assertions
+  include ::Minitest::Reportable
+  include ::Minitest::Test::LifecycleHooks
+  include ::Minitest::Guard
+  extend ::Minitest::Guard
+
+  # LifecycleHooks
+  #
+  # source://minitest//lib/minitest/test.rb#189
+  def capture_exceptions; end
+
+  # source://minitest//lib/minitest/test.rb#15
+  def class_name; end
+
+  # source://minitest//lib/minitest/test.rb#206
+  def neuter_exception(e); end
+
+  # source://minitest//lib/minitest/test.rb#217
+  def new_exception(klass, msg, bt, kill = T.unsafe(nil)); end
+
+  # Runs a single test with setup/teardown hooks.
+  #
+  # source://minitest//lib/minitest/test.rb#87
+  def run; end
+
+  # source://minitest//lib/minitest/test.rb#199
+  def sanitize_exception(e); end
+
+  class << self
+    # Call this at the top of your tests when you absolutely
+    # positively need to have ordered tests. In doing so, you're
+    # admitting that you suck and your tests are weak.
+    #
+    # source://minitest//lib/minitest/test.rb#35
+    def i_suck_and_my_tests_are_order_dependent!; end
+
+    # Returns the value of attribute io_lock.
+    #
+    # source://minitest//lib/minitest/test.rb#26
+    def io_lock; end
+
+    # Sets the attribute io_lock
+    #
+    # @param value the value to set the attribute io_lock to.
+    #
+    # source://minitest//lib/minitest/test.rb#26
+    def io_lock=(_arg0); end
+
+    # Make diffs for this Test use #pretty_inspect so that diff
+    # in assert_equal can have more details. NOTE: this is much slower
+    # than the regular inspect but much more usable for complex
+    # objects.
+    #
+    # source://minitest//lib/minitest/test.rb#48
+    def make_my_diffs_pretty!; end
+
+    # Call this at the top of your tests (inside the +Minitest::Test+
+    # subclass or +describe+ block) when you want to run your tests in
+    # parallel. In doing so, you're admitting that you rule and your
+    # tests are awesome.
+    #
+    # source://minitest//lib/minitest/test.rb#60
+    def parallelize_me!; end
+
+    # Returns all instance methods starting with "test_". Based on
+    # #test_order, the methods are either sorted, randomized
+    # (default), or run in parallel.
+    #
+    # source://minitest//lib/minitest/test.rb#70
+    def runnable_methods; end
+  end
+end
+
+# Provides before/after hooks for setup and teardown. These are
+# meant for library writers, NOT for regular test authors. See
+# #before_setup for an example.
+#
+# source://minitest//lib/minitest/test.rb#112
+module Minitest::Test::LifecycleHooks
+  # Runs before every test, after setup. This hook is meant for
+  # libraries to extend minitest. It is not meant to be used by
+  # test developers.
+  #
+  # See #before_setup for an example.
+  #
+  # source://minitest//lib/minitest/test.rb#162
+  def after_setup; end
+
+  # Runs after every test, after teardown. This hook is meant for
+  # libraries to extend minitest. It is not meant to be used by
+  # test developers.
+  #
+  # See #before_setup for an example.
+  #
+  # source://minitest//lib/minitest/test.rb#186
+  def after_teardown; end
+
+  # Runs before every test, before setup. This hook is meant for
+  # libraries to extend minitest. It is not meant to be used by
+  # test developers.
+  #
+  # As a simplistic example:
+  #
+  #   module MyMinitestPlugin
+  #     def before_setup
+  #       super
+  #       # ... stuff to do before setup is run
+  #     end
+  #
+  #     def after_setup
+  #       # ... stuff to do after setup is run
+  #       super
+  #     end
+  #
+  #     def before_teardown
+  #       super
+  #       # ... stuff to do before teardown is run
+  #     end
+  #
+  #     def after_teardown
+  #       # ... stuff to do after teardown is run
+  #       super
+  #     end
+  #   end
+  #
+  #   class Minitest::Test
+  #     include MyMinitestPlugin
+  #   end
+  #
+  # source://minitest//lib/minitest/test.rb#147
+  def before_setup; end
+
+  # Runs after every test, before teardown. This hook is meant for
+  # libraries to extend minitest. It is not meant to be used by
+  # test developers.
+  #
+  # See #before_setup for an example.
+  #
+  # source://minitest//lib/minitest/test.rb#171
+  def before_teardown; end
+
+  # Runs before every test. Use this to set up before each test
+  # run.
+  #
+  # source://minitest//lib/minitest/test.rb#153
+  def setup; end
+
+  # Runs after every test. Use this to clean up after each test
+  # run.
+  #
+  # source://minitest//lib/minitest/test.rb#177
+  def teardown; end
+end
+
+# source://minitest//lib/minitest/test.rb#19
+Minitest::Test::PASSTHROUGH_EXCEPTIONS = T.let(T.unsafe(nil), Array)
+
+# source://minitest//lib/minitest/test.rb#21
+Minitest::Test::SETUP_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://minitest//lib/minitest/test.rb#23
+Minitest::Test::TEARDOWN_METHODS = T.let(T.unsafe(nil), Array)
+
+# Assertion wrapping an unexpected error that was raised during a run.
+#
+# source://minitest//lib/minitest.rb#1058
+class Minitest::UnexpectedError < ::Minitest::Assertion
+  include ::Minitest::Compress
+
+  # @return [UnexpectedError] a new instance of UnexpectedError
+  #
+  # source://minitest//lib/minitest.rb#1064
+  def initialize(error); end
+
+  # source://minitest//lib/minitest.rb#1077
+  def backtrace; end
+
+  # TODO: figure out how to use `cause` instead
+  #
+  # source://minitest//lib/minitest.rb#1062
+  def error; end
+
+  # TODO: figure out how to use `cause` instead
+  #
+  # source://minitest//lib/minitest.rb#1062
+  def error=(_arg0); end
+
+  # source://minitest//lib/minitest.rb#1083
+  def message; end
+
+  # source://minitest//lib/minitest.rb#1089
+  def result_label; end
+end
+
+# source://minitest//lib/minitest.rb#1081
+Minitest::UnexpectedError::BASE_RE = T.let(T.unsafe(nil), Regexp)
+
+# Assertion raised on warning when running in -Werror mode.
+#
+# source://minitest//lib/minitest.rb#1097
+class Minitest::UnexpectedWarning < ::Minitest::Assertion
+  # source://minitest//lib/minitest.rb#1098
+  def result_label; end
+end
+
+# source://minitest//lib/minitest.rb#12
+Minitest::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/msgpack@1.5.3.rbi b/Library/Homebrew/sorbet/rbi/gems/msgpack@1.5.3.rbi
deleted file mode 100644
index 3e13ad3ab3794..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/msgpack@1.5.3.rbi
+++ /dev/null
@@ -1,205 +0,0 @@
-# typed: false
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `msgpack` gem.
-# Please instead update this file by running `bin/tapioca gem msgpack`.
-
-class Array
-  include ::Enumerable
-  include ::JSON::Ext::Generator::GeneratorMethods::Array
-  include ::Plist::Emit
-  include ::MessagePack::CoreExt
-
-  private
-
-  def to_msgpack_with_packer(packer); end
-end
-
-Bignum = Integer
-
-class FalseClass
-  include ::JSON::Ext::Generator::GeneratorMethods::FalseClass
-  include ::MessagePack::CoreExt
-
-  private
-
-  def to_msgpack_with_packer(packer); end
-end
-
-class Float < ::Numeric
-  include ::JSON::Ext::Generator::GeneratorMethods::Float
-  include ::MessagePack::CoreExt
-
-  private
-
-  def to_msgpack_with_packer(packer); end
-end
-
-class Hash
-  include ::Enumerable
-  include ::JSON::Ext::Generator::GeneratorMethods::Hash
-  include ::Plist::Emit
-  include ::MessagePack::CoreExt
-
-  private
-
-  def to_msgpack_with_packer(packer); end
-end
-
-class Integer < ::Numeric
-  include ::JSON::Ext::Generator::GeneratorMethods::Integer
-  include ::MessagePack::CoreExt
-
-  private
-
-  def to_msgpack_with_packer(packer); end
-end
-
-module MessagePack
-  private
-
-  def dump(v, io = T.unsafe(nil), options = T.unsafe(nil)); end
-  def load(src, param = T.unsafe(nil)); end
-  def pack(v, io = T.unsafe(nil), options = T.unsafe(nil)); end
-  def unpack(src, param = T.unsafe(nil)); end
-
-  class << self
-    def dump(v, io = T.unsafe(nil), options = T.unsafe(nil)); end
-    def load(src, param = T.unsafe(nil)); end
-    def pack(v, io = T.unsafe(nil), options = T.unsafe(nil)); end
-    def unpack(src, param = T.unsafe(nil)); end
-  end
-end
-
-module MessagePack::CoreExt
-  def to_msgpack(packer_or_io = T.unsafe(nil)); end
-end
-
-class MessagePack::ExtensionValue < ::Struct
-  include ::MessagePack::CoreExt
-
-  def payload=(_); end
-  def type=(_); end
-
-  private
-
-  def to_msgpack_with_packer(packer); end
-end
-
-class MessagePack::Factory
-  def dump(v, *rest); end
-  def load(src, param = T.unsafe(nil)); end
-  def pack(v, *rest); end
-  def pool(size = T.unsafe(nil), **options); end
-  def registered_types(selector = T.unsafe(nil)); end
-  def type_registered?(klass_or_type, selector = T.unsafe(nil)); end
-  def unpack(src, param = T.unsafe(nil)); end
-end
-
-class MessagePack::Factory::Pool
-  def initialize(factory, size, options = T.unsafe(nil)); end
-
-  def dump(object); end
-  def load(data); end
-end
-
-class MessagePack::Factory::Pool::AbstractPool
-  def initialize(size, &block); end
-
-  def checkin(member); end
-  def checkout; end
-end
-
-class MessagePack::Factory::Pool::PackerPool < ::MessagePack::Factory::Pool::AbstractPool
-  private
-
-  def reset(packer); end
-end
-
-class MessagePack::Factory::Pool::UnpackerPool < ::MessagePack::Factory::Pool::AbstractPool
-  private
-
-  def reset(unpacker); end
-end
-
-class MessagePack::Packer
-  def registered_types; end
-  def type_registered?(klass_or_type); end
-end
-
-module MessagePack::Time; end
-MessagePack::Time::Packer = T.let(T.unsafe(nil), Proc)
-MessagePack::Time::TIME_AT_3_AVAILABLE = T.let(T.unsafe(nil), TrueClass)
-MessagePack::Time::Unpacker = T.let(T.unsafe(nil), Proc)
-
-class MessagePack::Timestamp
-  def initialize(sec, nsec); end
-
-  def ==(other); end
-  def nsec; end
-  def sec; end
-  def to_msgpack_ext; end
-
-  class << self
-    def from_msgpack_ext(data); end
-    def to_msgpack_ext(sec, nsec); end
-  end
-end
-
-MessagePack::Timestamp::TIMESTAMP32_MAX_SEC = T.let(T.unsafe(nil), Integer)
-MessagePack::Timestamp::TIMESTAMP64_MAX_SEC = T.let(T.unsafe(nil), Integer)
-MessagePack::Timestamp::TYPE = T.let(T.unsafe(nil), Integer)
-
-class MessagePack::UnexpectedTypeError < ::MessagePack::UnpackError
-  include ::MessagePack::TypeError
-end
-
-class MessagePack::Unpacker
-  def registered_types; end
-  def type_registered?(klass_or_type); end
-end
-
-class NilClass
-  include ::JSON::Ext::Generator::GeneratorMethods::NilClass
-  include ::MessagePack::CoreExt
-
-  private
-
-  def to_msgpack_with_packer(packer); end
-end
-
-class String
-  include ::Comparable
-  include ::JSON::Ext::Generator::GeneratorMethods::String
-  include ::MessagePack::CoreExt
-  extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
-
-  private
-
-  def to_msgpack_with_packer(packer); end
-end
-
-String::BLANK_RE = T.let(T.unsafe(nil), Regexp)
-String::ENCODED_BLANKS = T.let(T.unsafe(nil), Concurrent::Map)
-
-class Symbol
-  include ::Comparable
-  include ::MessagePack::CoreExt
-
-  private
-
-  def to_msgpack_with_packer(packer); end
-
-  class << self
-    def from_msgpack_ext(data); end
-  end
-end
-
-class TrueClass
-  include ::JSON::Ext::Generator::GeneratorMethods::TrueClass
-  include ::MessagePack::CoreExt
-
-  private
-
-  def to_msgpack_with_packer(packer); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi b/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi
deleted file mode 100644
index 175edbe2b85f6..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi
+++ /dev/null
@@ -1,189 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `mustache` gem.
-# Please instead update this file by running `bin/tapioca gem mustache`.
-
-class Mustache
-  def initialize(options = T.unsafe(nil)); end
-
-  def [](key); end
-  def []=(key, value); end
-  def compiled?; end
-  def context; end
-  def escape(value); end
-  def escapeHTML(str); end
-  def initialize_settings; end
-  def partial(name); end
-  def path; end
-  def raise_on_context_miss=(boolean); end
-  def raise_on_context_miss?; end
-  def render(data = T.unsafe(nil), ctx = T.unsafe(nil)); end
-  def render_file(name, context = T.unsafe(nil)); end
-  def template; end
-  def template=(template); end
-  def template_extension; end
-  def template_extension=(template_extension); end
-  def template_file; end
-  def template_file=(template_file); end
-  def template_name; end
-  def template_name=(template_name); end
-  def template_path; end
-  def template_path=(path); end
-
-  private
-
-  def templateify(obj); end
-
-  class << self
-    def classify(underscored); end
-    def compiled?; end
-    def const_from_file(name); end
-    def inheritable_config_for(attr_name, default); end
-    def inherited(subclass); end
-    def initialize_settings; end
-    def partial(name); end
-    def path; end
-    def path=(path); end
-    def raise_on_context_miss=(boolean); end
-    def raise_on_context_miss?; end
-    def render(*args); end
-    def render_file(name, context = T.unsafe(nil)); end
-    def rescued_const_get(name); end
-    def template; end
-    def template=(template); end
-    def template_extension; end
-    def template_extension=(template_extension); end
-    def template_file; end
-    def template_file=(template_file); end
-    def template_name; end
-    def template_name=(template_name); end
-    def template_path; end
-    def template_path=(path); end
-    def templateify(obj, options = T.unsafe(nil)); end
-    def underscore(classified = T.unsafe(nil)); end
-    def view_class(name); end
-    def view_namespace; end
-    def view_namespace=(namespace); end
-    def view_path; end
-    def view_path=(path); end
-  end
-end
-
-class Mustache::Context
-  def initialize(mustache); end
-
-  def [](name); end
-  def []=(name, value); end
-  def current; end
-  def escape(value); end
-  def fetch(name, default = T.unsafe(nil)); end
-  def find(obj, key, default = T.unsafe(nil)); end
-  def has_key?(key); end
-  def mustache_in_stack; end
-  def partial(name, indentation = T.unsafe(nil)); end
-  def pop; end
-  def push(new_obj); end
-  def template_for_partial(partial); end
-
-  private
-
-  def find_in_hash(obj, key, default); end
-end
-
-class Mustache::ContextMiss < ::RuntimeError; end
-module Mustache::Enumerable; end
-
-class Mustache::Generator
-  def initialize(options = T.unsafe(nil)); end
-
-  def compile(exp); end
-
-  private
-
-  def compile!(exp); end
-  def ev(s); end
-  def on_etag(name, offset); end
-  def on_fetch(names); end
-  def on_inverted_section(name, offset, content, raw, delims); end
-  def on_partial(name, offset, indentation); end
-  def on_section(name, offset, content, raw, delims); end
-  def on_utag(name, offset); end
-  def str(s); end
-end
-
-class Mustache::Parser
-  def initialize(options = T.unsafe(nil)); end
-
-  def compile(template); end
-  def ctag; end
-  def ctag=(value); end
-  def otag; end
-  def otag=(value); end
-
-  private
-
-  def content_tags(type, current_ctag_regex); end
-  def dispatch_based_on_type(type, content, fetch, padding, pre_match_position); end
-  def error(message, pos = T.unsafe(nil)); end
-  def find_closing_tag(scanner, current_ctag_regex); end
-  def offset; end
-  def position; end
-  def regexp(thing); end
-  def scan_tag_(content, fetch, padding, pre_match_position); end
-  def scan_tag_!(content, fetch, padding, pre_match_position); end
-  def scan_tag_=(content, fetch, padding, pre_match_position); end
-  def scan_tag_block(content, fetch, padding, pre_match_position); end
-  def scan_tag_close(content, fetch, padding, pre_match_position); end
-  def scan_tag_comment(content, fetch, padding, pre_match_position); end
-  def scan_tag_delimiter(content, fetch, padding, pre_match_position); end
-  def scan_tag_inverted(content, fetch, padding, pre_match_position); end
-  def scan_tag_open_partial(content, fetch, padding, pre_match_position); end
-  def scan_tag_unescaped(content, fetch, padding, pre_match_position); end
-  def scan_tags; end
-  def scan_text; end
-  def scan_until_exclusive(regexp); end
-
-  class << self
-    def add_type(*types, &block); end
-    def valid_types; end
-  end
-end
-
-Mustache::Parser::ALLOWED_CONTENT = T.let(T.unsafe(nil), Regexp)
-Mustache::Parser::ANY_CONTENT = T.let(T.unsafe(nil), Array)
-Mustache::Parser::SKIP_WHITESPACE = T.let(T.unsafe(nil), Array)
-
-class Mustache::Parser::SyntaxError < ::StandardError
-  def initialize(message, position); end
-
-  def to_s; end
-end
-
-Mustache::Parser::VALID_TYPES = T.let(T.unsafe(nil), Array)
-
-class Mustache::Template
-  def initialize(source, options = T.unsafe(nil)); end
-
-  def compile(src = T.unsafe(nil)); end
-  def partials; end
-  def render(context); end
-  def sections; end
-  def source; end
-  def tags; end
-  def to_s(src = T.unsafe(nil)); end
-  def tokens(src = T.unsafe(nil)); end
-
-  class << self
-    def recursor(toks, section, &block); end
-  end
-end
-
-module Mustache::Utils; end
-
-class Mustache::Utils::String
-  def initialize(string); end
-
-  def classify; end
-  def underscore(view_namespace); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi b/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi
deleted file mode 100644
index 8b0051b417b92..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi
+++ /dev/null
@@ -1,8 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `net-http-digest_auth` gem.
-# Please instead update this file by running `bin/tapioca gem net-http-digest_auth`.
-
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.1.rbi b/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.1.rbi
deleted file mode 100644
index 81e139b7e6318..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.1.rbi
+++ /dev/null
@@ -1,144 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `net-http-persistent` gem.
-# Please instead update this file by running `bin/tapioca gem net-http-persistent`.
-
-class Net::HTTP::Persistent
-  def initialize(name: T.unsafe(nil), proxy: T.unsafe(nil), pool_size: T.unsafe(nil)); end
-
-  def ca_file; end
-  def ca_file=(file); end
-  def ca_path; end
-  def ca_path=(path); end
-  def cert; end
-  def cert=(certificate); end
-  def cert_store; end
-  def cert_store=(store); end
-  def certificate; end
-  def certificate=(certificate); end
-  def ciphers; end
-  def ciphers=(ciphers); end
-  def connection_for(uri); end
-  def debug_output; end
-  def debug_output=(_arg0); end
-  def escape(str); end
-  def expired?(connection); end
-  def finish(connection); end
-  def generation; end
-  def headers; end
-  def http_version(uri); end
-  def http_versions; end
-  def idle_timeout; end
-  def idle_timeout=(_arg0); end
-  def keep_alive; end
-  def keep_alive=(_arg0); end
-  def key; end
-  def key=(key); end
-  def max_requests; end
-  def max_requests=(_arg0); end
-  def max_retries; end
-  def max_retries=(retries); end
-  def max_version; end
-  def max_version=(max_version); end
-  def min_version; end
-  def min_version=(min_version); end
-  def name; end
-  def no_proxy; end
-  def normalize_uri(uri); end
-  def open_timeout; end
-  def open_timeout=(_arg0); end
-  def override_headers; end
-  def pipeline(uri, requests, &block); end
-  def pool; end
-  def private_key; end
-  def private_key=(key); end
-  def proxy=(proxy); end
-  def proxy_bypass?(host, port); end
-  def proxy_from_env; end
-  def proxy_uri; end
-  def read_timeout; end
-  def read_timeout=(_arg0); end
-  def reconnect; end
-  def reconnect_ssl; end
-  def request(uri, req = T.unsafe(nil), &block); end
-  def request_setup(req_or_uri); end
-  def reset(connection); end
-  def reuse_ssl_sessions; end
-  def reuse_ssl_sessions=(_arg0); end
-  def shutdown; end
-  def socket_options; end
-  def ssl(connection); end
-  def ssl_generation; end
-  def ssl_timeout; end
-  def ssl_timeout=(ssl_timeout); end
-  def ssl_version; end
-  def ssl_version=(ssl_version); end
-  def start(http); end
-  def timeout_key; end
-  def unescape(str); end
-  def verify_callback; end
-  def verify_callback=(callback); end
-  def verify_depth; end
-  def verify_depth=(verify_depth); end
-  def verify_mode; end
-  def verify_mode=(verify_mode); end
-  def write_timeout; end
-  def write_timeout=(_arg0); end
-
-  class << self
-    def detect_idle_timeout(uri, max = T.unsafe(nil)); end
-  end
-end
-
-class Net::HTTP::Persistent::Connection
-  def initialize(http_class, http_args, ssl_generation); end
-
-  def finish; end
-  def http; end
-  def http=(_arg0); end
-  def last_use; end
-  def last_use=(_arg0); end
-  def requests; end
-  def requests=(_arg0); end
-  def reset; end
-  def ressl(ssl_generation); end
-  def ssl_generation; end
-  def ssl_generation=(_arg0); end
-end
-
-Net::HTTP::Persistent::DEFAULT_POOL_SIZE = T.let(T.unsafe(nil), Integer)
-Net::HTTP::Persistent::EPOCH = T.let(T.unsafe(nil), Time)
-class Net::HTTP::Persistent::Error < ::StandardError; end
-
-class Net::HTTP::Persistent::Pool < ::ConnectionPool
-  def initialize(options = T.unsafe(nil), &block); end
-
-  def available; end
-  def checkin(net_http_args); end
-  def checkout(net_http_args); end
-  def key; end
-  def shutdown; end
-end
-
-class Net::HTTP::Persistent::TimedStackMulti < ::ConnectionPool::TimedStack
-  def initialize(size = T.unsafe(nil), &block); end
-
-  def empty?; end
-  def length; end
-
-  private
-
-  def connection_stored?(options = T.unsafe(nil)); end
-  def fetch_connection(options = T.unsafe(nil)); end
-  def lru_update(connection_args); end
-  def shutdown_connections; end
-  def store_connection(obj, options = T.unsafe(nil)); end
-  def try_create(options = T.unsafe(nil)); end
-
-  class << self
-    def hash_of_arrays; end
-  end
-end
-
-Net::HTTP::Persistent::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/nokogiri@1.13.7.rbi b/Library/Homebrew/sorbet/rbi/gems/nokogiri@1.13.7.rbi
deleted file mode 100644
index ef2021b0959ed..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/nokogiri@1.13.7.rbi
+++ /dev/null
@@ -1,1544 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `nokogiri` gem.
-# Please instead update this file by running `bin/tapioca gem nokogiri`.
-
-module Nokogiri
-  class << self
-    def HTML(input, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
-    def HTML4(input, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
-    def HTML5(input, url = T.unsafe(nil), encoding = T.unsafe(nil), **options, &block); end
-    def Slop(*args, &block); end
-    def XML(thing, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
-    def XSLT(stylesheet, modules = T.unsafe(nil)); end
-    def install_default_aliases; end
-    def jruby?; end
-    def libxml2_patches; end
-    def make(input = T.unsafe(nil), opts = T.unsafe(nil), &blk); end
-    def parse(string, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
-    def uses_gumbo?; end
-    def uses_libxml?(requirement = T.unsafe(nil)); end
-  end
-end
-
-module Nokogiri::CSS
-  class << self
-    def parse(selector); end
-    def xpath_for(selector, options = T.unsafe(nil)); end
-  end
-end
-
-class Nokogiri::CSS::Node
-  def initialize(type, value); end
-
-  def accept(visitor); end
-  def find_by_type(types); end
-  def to_a; end
-  def to_type; end
-  def to_xpath(prefix, visitor); end
-  def type; end
-  def type=(_arg0); end
-  def value; end
-  def value=(_arg0); end
-end
-
-Nokogiri::CSS::Node::ALLOW_COMBINATOR_ON_SELF = T.let(T.unsafe(nil), Array)
-
-class Nokogiri::CSS::Parser < ::Racc::Parser
-  def initialize(namespaces = T.unsafe(nil)); end
-
-  def _reduce_1(val, _values, result); end
-  def _reduce_10(val, _values, result); end
-  def _reduce_11(val, _values, result); end
-  def _reduce_13(val, _values, result); end
-  def _reduce_14(val, _values, result); end
-  def _reduce_15(val, _values, result); end
-  def _reduce_17(val, _values, result); end
-  def _reduce_18(val, _values, result); end
-  def _reduce_19(val, _values, result); end
-  def _reduce_2(val, _values, result); end
-  def _reduce_21(val, _values, result); end
-  def _reduce_23(val, _values, result); end
-  def _reduce_24(val, _values, result); end
-  def _reduce_25(val, _values, result); end
-  def _reduce_26(val, _values, result); end
-  def _reduce_28(val, _values, result); end
-  def _reduce_29(val, _values, result); end
-  def _reduce_3(val, _values, result); end
-  def _reduce_30(val, _values, result); end
-  def _reduce_31(val, _values, result); end
-  def _reduce_32(val, _values, result); end
-  def _reduce_34(val, _values, result); end
-  def _reduce_35(val, _values, result); end
-  def _reduce_36(val, _values, result); end
-  def _reduce_37(val, _values, result); end
-  def _reduce_38(val, _values, result); end
-  def _reduce_39(val, _values, result); end
-  def _reduce_4(val, _values, result); end
-  def _reduce_40(val, _values, result); end
-  def _reduce_41(val, _values, result); end
-  def _reduce_42(val, _values, result); end
-  def _reduce_45(val, _values, result); end
-  def _reduce_47(val, _values, result); end
-  def _reduce_48(val, _values, result); end
-  def _reduce_49(val, _values, result); end
-  def _reduce_5(val, _values, result); end
-  def _reduce_50(val, _values, result); end
-  def _reduce_51(val, _values, result); end
-  def _reduce_54(val, _values, result); end
-  def _reduce_55(val, _values, result); end
-  def _reduce_56(val, _values, result); end
-  def _reduce_57(val, _values, result); end
-  def _reduce_58(val, _values, result); end
-  def _reduce_6(val, _values, result); end
-  def _reduce_64(val, _values, result); end
-  def _reduce_65(val, _values, result); end
-  def _reduce_66(val, _values, result); end
-  def _reduce_67(val, _values, result); end
-  def _reduce_69(val, _values, result); end
-  def _reduce_7(val, _values, result); end
-  def _reduce_70(val, _values, result); end
-  def _reduce_71(val, _values, result); end
-  def _reduce_72(val, _values, result); end
-  def _reduce_73(val, _values, result); end
-  def _reduce_74(val, _values, result); end
-  def _reduce_75(val, _values, result); end
-  def _reduce_76(val, _values, result); end
-  def _reduce_8(val, _values, result); end
-  def _reduce_9(val, _values, result); end
-  def _reduce_none(val, _values, result); end
-  def cache_key(query, prefix, visitor); end
-  def next_token; end
-  def on_error(error_token_id, error_value, value_stack); end
-  def parse(string); end
-  def unescape_css_identifier(identifier); end
-  def unescape_css_string(str); end
-  def xpath_for(string, prefix, visitor); end
-
-  class << self
-    def [](string); end
-    def []=(string, value); end
-    def cache_on?; end
-    def clear_cache(create_new_object = T.unsafe(nil)); end
-    def set_cache(value); end
-    def without_cache(&block); end
-  end
-end
-
-Nokogiri::CSS::Parser::CACHE_SWITCH_NAME = T.let(T.unsafe(nil), Symbol)
-Nokogiri::CSS::Parser::Racc_arg = T.let(T.unsafe(nil), Array)
-Nokogiri::CSS::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
-class Nokogiri::CSS::SyntaxError < ::Nokogiri::SyntaxError; end
-
-class Nokogiri::CSS::Tokenizer
-  def _next_token; end
-  def action; end
-  def filename; end
-  def lineno; end
-  def load_file(filename); end
-  def next_token; end
-  def scan(str); end
-  def scan_file(filename); end
-  def scan_setup(str); end
-  def scan_str(str); end
-  def state; end
-  def state=(_arg0); end
-end
-
-class Nokogiri::CSS::Tokenizer::ScanError < ::StandardError; end
-
-class Nokogiri::CSS::XPathVisitor
-  def initialize(builtins: T.unsafe(nil), doctype: T.unsafe(nil)); end
-
-  def accept(node); end
-  def config; end
-  def visit_attrib_name(node); end
-  def visit_attribute_condition(node); end
-  def visit_child_selector(node); end
-  def visit_class_condition(node); end
-  def visit_combinator(node); end
-  def visit_conditional_selector(node); end
-  def visit_descendant_selector(node); end
-  def visit_direct_adjacent_selector(node); end
-  def visit_element_name(node); end
-  def visit_following_selector(node); end
-  def visit_function(node); end
-  def visit_id(node); end
-  def visit_not(node); end
-  def visit_pseudo_class(node); end
-
-  private
-
-  def css_class(hay, needle); end
-  def html5_element_name_needs_namespace_handling(node); end
-  def is_of_type_pseudo_class?(node); end
-  def nth(node, options = T.unsafe(nil)); end
-  def read_a_and_positive_b(values); end
-end
-
-module Nokogiri::CSS::XPathVisitor::BuiltinsConfig; end
-Nokogiri::CSS::XPathVisitor::BuiltinsConfig::ALWAYS = T.let(T.unsafe(nil), Symbol)
-Nokogiri::CSS::XPathVisitor::BuiltinsConfig::NEVER = T.let(T.unsafe(nil), Symbol)
-Nokogiri::CSS::XPathVisitor::BuiltinsConfig::OPTIMAL = T.let(T.unsafe(nil), Symbol)
-Nokogiri::CSS::XPathVisitor::BuiltinsConfig::VALUES = T.let(T.unsafe(nil), Array)
-module Nokogiri::CSS::XPathVisitor::DoctypeConfig; end
-Nokogiri::CSS::XPathVisitor::DoctypeConfig::HTML4 = T.let(T.unsafe(nil), Symbol)
-Nokogiri::CSS::XPathVisitor::DoctypeConfig::HTML5 = T.let(T.unsafe(nil), Symbol)
-Nokogiri::CSS::XPathVisitor::DoctypeConfig::VALUES = T.let(T.unsafe(nil), Array)
-Nokogiri::CSS::XPathVisitor::DoctypeConfig::XML = T.let(T.unsafe(nil), Symbol)
-Nokogiri::CSS::XPathVisitor::WILDCARD_NAMESPACES = T.let(T.unsafe(nil), TrueClass)
-
-module Nokogiri::CSS::XPathVisitorAlwaysUseBuiltins
-  class << self
-    def new; end
-  end
-end
-
-module Nokogiri::CSS::XPathVisitorOptimallyUseBuiltins
-  class << self
-    def new; end
-  end
-end
-
-module Nokogiri::ClassResolver
-  def related_class(class_name); end
-end
-
-Nokogiri::ClassResolver::VALID_NAMESPACES = T.let(T.unsafe(nil), Set)
-module Nokogiri::Decorators; end
-
-module Nokogiri::Decorators::Slop
-  def method_missing(name, *args, &block); end
-
-  private
-
-  def respond_to_missing?(name, include_private = T.unsafe(nil)); end
-end
-
-Nokogiri::Decorators::Slop::XPATH_PREFIX = T.let(T.unsafe(nil), String)
-
-class Nokogiri::EncodingHandler
-  def name; end
-
-  class << self
-    def [](_arg0); end
-    def alias(_arg0, _arg1); end
-    def clear_aliases!; end
-    def delete(_arg0); end
-  end
-end
-
-module Nokogiri::Gumbo
-  class << self
-    def fragment(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5); end
-    def parse(_arg0, _arg1, _arg2, _arg3, _arg4); end
-  end
-end
-
-Nokogiri::Gumbo::DEFAULT_MAX_ATTRIBUTES = T.let(T.unsafe(nil), Integer)
-Nokogiri::Gumbo::DEFAULT_MAX_ERRORS = T.let(T.unsafe(nil), Integer)
-Nokogiri::Gumbo::DEFAULT_MAX_TREE_DEPTH = T.let(T.unsafe(nil), Integer)
-Nokogiri::HTML = Nokogiri::HTML4
-
-module Nokogiri::HTML4
-  class << self
-    def fragment(string, encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
-    def parse(input, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
-  end
-end
-
-class Nokogiri::HTML4::Builder < ::Nokogiri::XML::Builder
-  def to_html; end
-end
-
-class Nokogiri::HTML4::Document < ::Nokogiri::XML::Document
-  def fragment(tags = T.unsafe(nil)); end
-  def meta_encoding; end
-  def meta_encoding=(encoding); end
-  def meta_robots(custom_name = T.unsafe(nil)); end
-  def nofollow?(custom_name = T.unsafe(nil)); end
-  def noindex?(custom_name = T.unsafe(nil)); end
-  def serialize(options = T.unsafe(nil)); end
-  def title; end
-  def title=(text); end
-  def type; end
-  def xpath_doctype; end
-
-  private
-
-  def meta_content_type; end
-  def parse_meta_robots(custom_name); end
-  def set_metadata_element(element); end
-
-  class << self
-    def new(*_arg0); end
-    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
-    def read_io(_arg0, _arg1, _arg2, _arg3); end
-    def read_memory(_arg0, _arg1, _arg2, _arg3); end
-  end
-end
-
-class Nokogiri::HTML4::Document::EncodingFound < ::StandardError
-  def initialize(encoding); end
-
-  def found_encoding; end
-end
-
-class Nokogiri::HTML4::Document::EncodingReader
-  def initialize(io); end
-
-  def encoding_found; end
-  def read(len); end
-
-  class << self
-    def detect_encoding(chunk); end
-  end
-end
-
-class Nokogiri::HTML4::Document::EncodingReader::JumpSAXHandler < ::Nokogiri::HTML4::Document::EncodingReader::SAXHandler
-  def initialize(jumptag); end
-
-  def start_element(name, attrs = T.unsafe(nil)); end
-end
-
-class Nokogiri::HTML4::Document::EncodingReader::SAXHandler < ::Nokogiri::XML::SAX::Document
-  def initialize; end
-
-  def encoding; end
-  def start_element(name, attrs = T.unsafe(nil)); end
-end
-
-class Nokogiri::HTML4::DocumentFragment < ::Nokogiri::XML::DocumentFragment
-  def initialize(document, tags = T.unsafe(nil), ctx = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  class << self
-    def parse(tags, encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
-  end
-end
-
-class Nokogiri::HTML4::ElementDescription
-  def block?; end
-  def default_sub_element; end
-  def deprecated?; end
-  def deprecated_attributes; end
-  def description; end
-  def empty?; end
-  def implied_end_tag?; end
-  def implied_start_tag?; end
-  def inline?; end
-  def inspect; end
-  def name; end
-  def optional_attributes; end
-  def required_attributes; end
-  def save_end_tag?; end
-  def sub_elements; end
-  def to_s; end
-
-  private
-
-  def default_desc; end
-
-  class << self
-    def [](_arg0); end
-  end
-end
-
-Nokogiri::HTML4::ElementDescription::ACTION_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::ALIGN_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::ALT_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::APPLET_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::AREA_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::A_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::BASEFONT_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::BGCOLOR_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::BLOCK = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::BLOCKLI_ELT = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::BODY_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::BODY_CONTENTS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::BODY_DEPR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::BUTTON_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::CELLHALIGN = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::CELLVALIGN = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::CLEAR_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::COL_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::COL_ELT = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::COMPACT_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::COMPACT_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::CONTENT_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::COREATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::CORE_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::CORE_I18N_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::DIR_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::DL_CONTENTS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::DefaultDescriptions = T.let(T.unsafe(nil), Hash)
-Nokogiri::HTML4::ElementDescription::Desc = Struct
-Nokogiri::HTML4::ElementDescription::EDIT_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::EMBED_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::EMPTY = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::EVENTS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::FIELDSET_CONTENTS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::FLOW = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::FLOW_PARAM = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::FONTSTYLE = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::FONT_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::FORMCTRL = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::FORM_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::FORM_CONTENTS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::FRAMESET_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::FRAMESET_CONTENTS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::FRAME_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::HEADING = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::HEAD_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::HEAD_CONTENTS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::HREF_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::HR_DEPR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::HTML_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::HTML_CDATA = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::HTML_CONTENT = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::HTML_FLOW = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::HTML_INLINE = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::HTML_PCDATA = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::I18N = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::I18N_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::IFRAME_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::IMG_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::INLINE = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::INLINE_P = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::INPUT_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::LABEL_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::LABEL_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::LANGUAGE_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::LEGEND_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::LINK_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::LIST = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::LI_ELT = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::MAP_CONTENTS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::META_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::MODIFIER = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::NAME_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::NOFRAMES_CONTENT = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::OBJECT_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::OBJECT_CONTENTS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::OBJECT_DEPR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::OL_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::OPTGROUP_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::OPTION_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::OPTION_ELT = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::PARAM_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::PCDATA = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::PHRASE = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::PRE_CONTENT = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::PROMPT_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::QUOTE_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::ROWS_COLS_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::SCRIPT_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::SELECT_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::SELECT_CONTENT = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::SPECIAL = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::SRC_ALT_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::STYLE_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::TABLE_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::TABLE_CONTENTS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::TABLE_DEPR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::TALIGN_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::TARGET_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::TEXTAREA_ATTRS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::TH_TD_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::TH_TD_DEPR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::TR_CONTENTS = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::TR_ELT = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::TYPE_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::UL_DEPR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::VERSION_ATTR = T.let(T.unsafe(nil), Array)
-Nokogiri::HTML4::ElementDescription::WIDTH_ATTR = T.let(T.unsafe(nil), Array)
-class Nokogiri::HTML4::EntityDescription < ::Struct; end
-
-class Nokogiri::HTML4::EntityLookup
-  def [](name); end
-  def get(_arg0); end
-end
-
-Nokogiri::HTML4::NamedCharacters = T.let(T.unsafe(nil), Nokogiri::HTML4::EntityLookup)
-module Nokogiri::HTML4::SAX; end
-
-class Nokogiri::HTML4::SAX::Parser < ::Nokogiri::XML::SAX::Parser
-  def parse_file(filename, encoding = T.unsafe(nil)); end
-  def parse_io(io, encoding = T.unsafe(nil)); end
-  def parse_memory(data, encoding = T.unsafe(nil)); end
-end
-
-class Nokogiri::HTML4::SAX::ParserContext < ::Nokogiri::XML::SAX::ParserContext
-  def parse_with(_arg0); end
-
-  class << self
-    def file(_arg0, _arg1); end
-    def memory(_arg0, _arg1); end
-    def new(thing, encoding = T.unsafe(nil)); end
-  end
-end
-
-class Nokogiri::HTML4::SAX::PushParser < ::Nokogiri::XML::SAX::PushParser
-  def initialize(doc = T.unsafe(nil), file_name = T.unsafe(nil), encoding = T.unsafe(nil)); end
-
-  def <<(chunk, last_chunk = T.unsafe(nil)); end
-  def document; end
-  def document=(_arg0); end
-  def finish; end
-  def write(chunk, last_chunk = T.unsafe(nil)); end
-
-  private
-
-  def initialize_native(_arg0, _arg1, _arg2); end
-  def native_write(_arg0, _arg1); end
-end
-
-module Nokogiri::HTML5
-  class << self
-    def escape_text(text, encoding, attribute_mode); end
-    def fragment(string, encoding = T.unsafe(nil), **options); end
-    def get(uri, options = T.unsafe(nil)); end
-    def get_impl(uri, options = T.unsafe(nil)); end
-    def parse(string, url = T.unsafe(nil), encoding = T.unsafe(nil), **options, &block); end
-    def prepend_newline?(node); end
-    def read_and_encode(string, encoding); end
-    def reencode(body, content_type = T.unsafe(nil)); end
-    def serialize_node_internal(current_node, io, encoding, options); end
-  end
-end
-
-class Nokogiri::HTML5::Document < ::Nokogiri::HTML4::Document
-  def fragment(tags = T.unsafe(nil)); end
-  def to_xml(options = T.unsafe(nil), &block); end
-  def xpath_doctype; end
-
-  class << self
-    def do_parse(string_or_io, url, encoding, options); end
-    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), **options, &block); end
-    def read_io(io, url = T.unsafe(nil), encoding = T.unsafe(nil), **options); end
-    def read_memory(string, url = T.unsafe(nil), encoding = T.unsafe(nil), **options); end
-  end
-end
-
-class Nokogiri::HTML5::DocumentFragment < ::Nokogiri::HTML4::DocumentFragment
-  def initialize(doc, tags = T.unsafe(nil), ctx = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def document; end
-  def document=(_arg0); end
-  def errors; end
-  def errors=(_arg0); end
-  def extract_params(params); end
-  def serialize(options = T.unsafe(nil), &block); end
-
-  class << self
-    def parse(tags, encoding = T.unsafe(nil), options = T.unsafe(nil)); end
-  end
-end
-
-Nokogiri::HTML5::HTML_NAMESPACE = T.let(T.unsafe(nil), String)
-Nokogiri::HTML5::MATHML_NAMESPACE = T.let(T.unsafe(nil), String)
-
-module Nokogiri::HTML5::Node
-  def fragment(tags); end
-  def inner_html(options = T.unsafe(nil)); end
-  def write_to(io, *options); end
-
-  private
-
-  def add_child_node_and_reparent_attrs(node); end
-end
-
-Nokogiri::HTML5::SVG_NAMESPACE = T.let(T.unsafe(nil), String)
-Nokogiri::HTML5::XLINK_NAMESPACE = T.let(T.unsafe(nil), String)
-Nokogiri::HTML5::XMLNS_NAMESPACE = T.let(T.unsafe(nil), String)
-Nokogiri::HTML5::XML_NAMESPACE = T.let(T.unsafe(nil), String)
-Nokogiri::LIBXML2_PATCHES = T.let(T.unsafe(nil), Array)
-Nokogiri::LIBXML_COMPILED_VERSION = T.let(T.unsafe(nil), String)
-Nokogiri::LIBXML_ICONV_ENABLED = T.let(T.unsafe(nil), TrueClass)
-Nokogiri::LIBXML_LOADED_VERSION = T.let(T.unsafe(nil), String)
-Nokogiri::LIBXML_MEMORY_MANAGEMENT = T.let(T.unsafe(nil), String)
-Nokogiri::LIBXSLT_COMPILED_VERSION = T.let(T.unsafe(nil), String)
-Nokogiri::LIBXSLT_DATETIME_ENABLED = T.let(T.unsafe(nil), TrueClass)
-Nokogiri::LIBXSLT_LOADED_VERSION = T.let(T.unsafe(nil), String)
-Nokogiri::LIBXSLT_PATCHES = T.let(T.unsafe(nil), Array)
-Nokogiri::OTHER_LIBRARY_VERSIONS = T.let(T.unsafe(nil), String)
-Nokogiri::PACKAGED_LIBRARIES = T.let(T.unsafe(nil), TrueClass)
-Nokogiri::PRECOMPILED_LIBRARIES = T.let(T.unsafe(nil), TrueClass)
-class Nokogiri::SyntaxError < ::StandardError; end
-
-module Nokogiri::Test
-  class << self
-    def __foreign_error_handler; end
-  end
-end
-
-Nokogiri::VERSION = T.let(T.unsafe(nil), String)
-Nokogiri::VERSION_INFO = T.let(T.unsafe(nil), Hash)
-
-class Nokogiri::VersionInfo
-  include ::Singleton
-  extend ::Singleton::SingletonClassMethods
-
-  def compiled_libxml_version; end
-  def compiled_libxslt_version; end
-  def engine; end
-  def jruby?; end
-  def libxml2?; end
-  def libxml2_has_iconv?; end
-  def libxml2_precompiled?; end
-  def libxml2_using_packaged?; end
-  def libxml2_using_system?; end
-  def libxslt_has_datetime?; end
-  def loaded_libxml_version; end
-  def loaded_libxslt_version; end
-  def ruby_minor; end
-  def to_hash; end
-  def to_markdown; end
-  def warnings; end
-  def windows?; end
-
-  class << self
-    def instance; end
-  end
-end
-
-module Nokogiri::XML
-  class << self
-    def Reader(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
-    def RelaxNG(string_or_io, options = T.unsafe(nil)); end
-    def Schema(string_or_io, options = T.unsafe(nil)); end
-    def fragment(string, options = T.unsafe(nil), &block); end
-    def parse(thing, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil), &block); end
-  end
-end
-
-class Nokogiri::XML::Attr < ::Nokogiri::XML::Node
-  def content=(_arg0); end
-  def to_s; end
-  def value; end
-  def value=(_arg0); end
-
-  private
-
-  def inspect_attributes; end
-
-  class << self
-    def new(*_arg0); end
-  end
-end
-
-class Nokogiri::XML::AttributeDecl < ::Nokogiri::XML::Node
-  def attribute_type; end
-  def default; end
-  def enumeration; end
-  def inspect; end
-end
-
-class Nokogiri::XML::Builder
-  include ::Nokogiri::ClassResolver
-
-  def initialize(options = T.unsafe(nil), root = T.unsafe(nil), &block); end
-
-  def <<(string); end
-  def [](ns); end
-  def arity; end
-  def arity=(_arg0); end
-  def cdata(string); end
-  def comment(string); end
-  def context; end
-  def context=(_arg0); end
-  def doc; end
-  def doc=(_arg0); end
-  def method_missing(method, *args, &block); end
-  def parent; end
-  def parent=(_arg0); end
-  def text(string); end
-  def to_xml(*args); end
-
-  private
-
-  def insert(node, &block); end
-
-  class << self
-    def with(root, &block); end
-  end
-end
-
-Nokogiri::XML::Builder::DEFAULT_DOCUMENT_OPTIONS = T.let(T.unsafe(nil), Hash)
-
-class Nokogiri::XML::Builder::NodeBuilder
-  def initialize(node, doc_builder); end
-
-  def [](k); end
-  def []=(k, v); end
-  def method_missing(method, *args, &block); end
-end
-
-class Nokogiri::XML::CDATA < ::Nokogiri::XML::Text
-  def name; end
-
-  class << self
-    def new(*_arg0); end
-  end
-end
-
-class Nokogiri::XML::CharacterData < ::Nokogiri::XML::Node
-  include ::Nokogiri::XML::PP::CharacterData
-end
-
-class Nokogiri::XML::Comment < ::Nokogiri::XML::CharacterData
-  class << self
-    def new(*_arg0); end
-  end
-end
-
-class Nokogiri::XML::DTD < ::Nokogiri::XML::Node
-  def attributes; end
-  def each; end
-  def elements; end
-  def entities; end
-  def external_id; end
-  def html5_dtd?; end
-  def html_dtd?; end
-  def keys; end
-  def notations; end
-  def system_id; end
-  def validate(_arg0); end
-end
-
-class Nokogiri::XML::Document < ::Nokogiri::XML::Node
-  def initialize(*args); end
-
-  def <<(node_or_tags); end
-  def add_child(node_or_tags); end
-  def canonicalize(*_arg0); end
-  def clone(*_arg0); end
-  def collect_namespaces; end
-  def create_cdata(string, &block); end
-  def create_comment(string, &block); end
-  def create_element(name, *contents_or_attrs, &block); end
-  def create_entity(*_arg0); end
-  def create_text_node(string, &block); end
-  def decorate(node); end
-  def decorators(key); end
-  def document; end
-  def dup(*_arg0); end
-  def encoding; end
-  def encoding=(_arg0); end
-  def errors; end
-  def errors=(_arg0); end
-  def fragment(tags = T.unsafe(nil)); end
-  def name; end
-  def namespace_inheritance; end
-  def namespace_inheritance=(_arg0); end
-  def namespaces; end
-  def remove_namespaces!; end
-  def root; end
-  def root=(_arg0); end
-  def slop!; end
-  def to_xml(*args, &block); end
-  def url; end
-  def validate; end
-  def version; end
-  def xpath_doctype; end
-
-  private
-
-  def inspect_attributes; end
-
-  class << self
-    def empty_doc?(string_or_io); end
-    def new(*_arg0); end
-    def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
-    def read_io(_arg0, _arg1, _arg2, _arg3); end
-    def read_memory(_arg0, _arg1, _arg2, _arg3); end
-  end
-end
-
-Nokogiri::XML::Document::IMPLIED_XPATH_CONTEXTS = T.let(T.unsafe(nil), Array)
-Nokogiri::XML::Document::NCNAME_CHAR = T.let(T.unsafe(nil), String)
-Nokogiri::XML::Document::NCNAME_RE = T.let(T.unsafe(nil), Regexp)
-Nokogiri::XML::Document::NCNAME_START_CHAR = T.let(T.unsafe(nil), String)
-
-class Nokogiri::XML::DocumentFragment < ::Nokogiri::XML::Node
-  def initialize(document, tags = T.unsafe(nil), ctx = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def css(*args); end
-  def dup; end
-  def errors; end
-  def errors=(things); end
-  def fragment(data); end
-  def name; end
-  def search(*rules); end
-  def serialize; end
-  def to_html(*args); end
-  def to_s; end
-  def to_xhtml(*args); end
-  def to_xml(*args); end
-
-  private
-
-  def namespace_declarations(ctx); end
-
-  class << self
-    def new(*_arg0); end
-    def parse(tags, options = T.unsafe(nil), &block); end
-  end
-end
-
-class Nokogiri::XML::Element < ::Nokogiri::XML::Node; end
-
-class Nokogiri::XML::ElementContent
-  def children; end
-  def document; end
-  def name; end
-  def occur; end
-  def prefix; end
-  def type; end
-
-  private
-
-  def c1; end
-  def c2; end
-end
-
-Nokogiri::XML::ElementContent::ELEMENT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ElementContent::MULT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ElementContent::ONCE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ElementContent::OPT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ElementContent::OR = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ElementContent::PCDATA = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ElementContent::PLUS = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ElementContent::SEQ = T.let(T.unsafe(nil), Integer)
-
-class Nokogiri::XML::ElementDecl < ::Nokogiri::XML::Node
-  def content; end
-  def element_type; end
-  def inspect; end
-  def prefix; end
-end
-
-class Nokogiri::XML::EntityDecl < ::Nokogiri::XML::Node
-  def content; end
-  def entity_type; end
-  def external_id; end
-  def inspect; end
-  def original_content; end
-  def system_id; end
-
-  class << self
-    def new(name, doc, *args); end
-  end
-end
-
-Nokogiri::XML::EntityDecl::EXTERNAL_GENERAL_PARSED = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::EntityDecl::EXTERNAL_GENERAL_UNPARSED = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::EntityDecl::EXTERNAL_PARAMETER = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::EntityDecl::INTERNAL_GENERAL = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::EntityDecl::INTERNAL_PARAMETER = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::EntityDecl::INTERNAL_PREDEFINED = T.let(T.unsafe(nil), Integer)
-
-class Nokogiri::XML::EntityReference < ::Nokogiri::XML::Node
-  def children; end
-  def inspect_attributes; end
-
-  class << self
-    def new(*_arg0); end
-  end
-end
-
-class Nokogiri::XML::Namespace
-  include ::Nokogiri::XML::PP::Node
-
-  def document; end
-  def href; end
-  def prefix; end
-
-  private
-
-  def inspect_attributes; end
-end
-
-class Nokogiri::XML::Node
-  include ::Nokogiri::HTML5::Node
-  include ::Nokogiri::XML::PP::Node
-  include ::Nokogiri::XML::Searchable
-  include ::Nokogiri::ClassResolver
-  include ::Enumerable
-
-  def initialize(name, document); end
-
-  def <<(node_or_tags); end
-  def <=>(other); end
-  def ==(other); end
-  def [](name); end
-  def []=(name, value); end
-  def accept(visitor); end
-  def add_child(node_or_tags); end
-  def add_class(names); end
-  def add_namespace(_arg0, _arg1); end
-  def add_namespace_definition(_arg0, _arg1); end
-  def add_next_sibling(node_or_tags); end
-  def add_previous_sibling(node_or_tags); end
-  def after(node_or_tags); end
-  def ancestors(selector = T.unsafe(nil)); end
-  def append_class(names); end
-  def attr(name); end
-  def attribute(_arg0); end
-  def attribute_nodes; end
-  def attribute_with_ns(_arg0, _arg1); end
-  def attributes; end
-  def before(node_or_tags); end
-  def blank?; end
-  def canonicalize(mode = T.unsafe(nil), inclusive_namespaces = T.unsafe(nil), with_comments = T.unsafe(nil)); end
-  def cdata?; end
-  def child; end
-  def children; end
-  def children=(node_or_tags); end
-  def classes; end
-  def clone(*_arg0); end
-  def comment?; end
-  def content; end
-  def content=(string); end
-  def create_external_subset(_arg0, _arg1, _arg2); end
-  def create_internal_subset(_arg0, _arg1, _arg2); end
-  def css_path; end
-  def decorate!; end
-  def default_namespace=(url); end
-  def delete(name); end
-  def description; end
-  def do_xinclude(options = T.unsafe(nil)); end
-  def document; end
-  def document?; end
-  def dup(*_arg0); end
-  def each; end
-  def elem?; end
-  def element?; end
-  def element_children; end
-  def elements; end
-  def encode_special_chars(_arg0); end
-  def external_subset; end
-  def first_element_child; end
-  def fragment?; end
-  def get_attribute(name); end
-  def has_attribute?(_arg0); end
-  def html?; end
-  def inner_html=(node_or_tags); end
-  def inner_text; end
-  def internal_subset; end
-  def key?(_arg0); end
-  def keys; end
-  def kwattr_add(attribute_name, keywords); end
-  def kwattr_append(attribute_name, keywords); end
-  def kwattr_remove(attribute_name, keywords); end
-  def kwattr_values(attribute_name); end
-  def lang; end
-  def lang=(_arg0); end
-  def last_element_child; end
-  def line; end
-  def line=(_arg0); end
-  def matches?(selector); end
-  def name; end
-  def name=(_arg0); end
-  def namespace; end
-  def namespace=(ns); end
-  def namespace_definitions; end
-  def namespace_scopes; end
-  def namespaced_key?(_arg0, _arg1); end
-  def namespaces; end
-  def native_content=(_arg0); end
-  def next; end
-  def next=(node_or_tags); end
-  def next_element; end
-  def next_sibling; end
-  def node_name; end
-  def node_name=(_arg0); end
-  def node_type; end
-  def parent; end
-  def parent=(parent_node); end
-  def parse(string_or_io, options = T.unsafe(nil)); end
-  def path; end
-  def pointer_id; end
-  def prepend_child(node_or_tags); end
-  def previous; end
-  def previous=(node_or_tags); end
-  def previous_element; end
-  def previous_sibling; end
-  def processing_instruction?; end
-  def read_only?; end
-  def remove; end
-  def remove_attribute(name); end
-  def remove_class(names = T.unsafe(nil)); end
-  def replace(node_or_tags); end
-  def serialize(*args, &block); end
-  def set_attribute(name, value); end
-  def swap(node_or_tags); end
-  def text; end
-  def text?; end
-  def to_html(options = T.unsafe(nil)); end
-  def to_s; end
-  def to_str; end
-  def to_xhtml(options = T.unsafe(nil)); end
-  def to_xml(options = T.unsafe(nil)); end
-  def traverse(&block); end
-  def type; end
-  def unlink; end
-  def value?(value); end
-  def values; end
-  def wrap(html); end
-  def write_html_to(io, options = T.unsafe(nil)); end
-  def write_xhtml_to(io, options = T.unsafe(nil)); end
-  def write_xml_to(io, options = T.unsafe(nil)); end
-  def xml?; end
-
-  protected
-
-  def coerce(data); end
-
-  private
-
-  def add_child_node(_arg0); end
-  def add_next_sibling_node(_arg0); end
-  def add_previous_sibling_node(_arg0); end
-  def add_sibling(next_or_previous, node_or_tags); end
-  def compare(_arg0); end
-  def dump_html; end
-  def get(_arg0); end
-  def in_context(_arg0, _arg1); end
-  def inspect_attributes; end
-  def keywordify(keywords); end
-  def native_write_to(_arg0, _arg1, _arg2, _arg3); end
-  def process_xincludes(_arg0); end
-  def replace_node(_arg0); end
-  def set(_arg0, _arg1); end
-  def set_namespace(_arg0); end
-  def to_format(save_option, options); end
-  def write_format_to(save_option, io, options); end
-
-  class << self
-    def new(*_arg0); end
-  end
-end
-
-Nokogiri::XML::Node::ATTRIBUTE_DECL = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::ATTRIBUTE_NODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::CDATA_SECTION_NODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::COMMENT_NODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::DOCB_DOCUMENT_NODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::DOCUMENT_FRAG_NODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::DOCUMENT_NODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::DOCUMENT_TYPE_NODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::DTD_NODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::ELEMENT_DECL = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::ELEMENT_NODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::ENTITY_DECL = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::ENTITY_NODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::ENTITY_REF_NODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::HTML_DOCUMENT_NODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::IMPLIED_XPATH_CONTEXTS = T.let(T.unsafe(nil), Array)
-Nokogiri::XML::Node::NAMESPACE_DECL = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::NOTATION_NODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::PI_NODE = T.let(T.unsafe(nil), Integer)
-
-class Nokogiri::XML::Node::SaveOptions
-  def initialize(options = T.unsafe(nil)); end
-
-  def as_html; end
-  def as_html?; end
-  def as_xhtml; end
-  def as_xhtml?; end
-  def as_xml; end
-  def as_xml?; end
-  def default_html; end
-  def default_html?; end
-  def default_xhtml; end
-  def default_xhtml?; end
-  def default_xml; end
-  def default_xml?; end
-  def format; end
-  def format?; end
-  def no_declaration; end
-  def no_declaration?; end
-  def no_empty_tags; end
-  def no_empty_tags?; end
-  def no_xhtml; end
-  def no_xhtml?; end
-  def options; end
-  def to_i; end
-end
-
-Nokogiri::XML::Node::SaveOptions::AS_HTML = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::SaveOptions::AS_XHTML = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::SaveOptions::AS_XML = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::SaveOptions::DEFAULT_HTML = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::SaveOptions::DEFAULT_XHTML = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::SaveOptions::DEFAULT_XML = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::SaveOptions::FORMAT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::SaveOptions::NO_DECLARATION = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::SaveOptions::NO_XHTML = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::TEXT_NODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::XINCLUDE_END = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Node::XINCLUDE_START = T.let(T.unsafe(nil), Integer)
-
-class Nokogiri::XML::NodeSet
-  include ::Nokogiri::XML::Searchable
-  include ::Enumerable
-
-  def initialize(document, list = T.unsafe(nil)); end
-
-  def %(*args); end
-  def &(_arg0); end
-  def +(_arg0); end
-  def -(_arg0); end
-  def <<(_arg0); end
-  def ==(other); end
-  def [](*_arg0); end
-  def add_class(name); end
-  def after(datum); end
-  def append_class(name); end
-  def at(*args); end
-  def attr(key, value = T.unsafe(nil), &block); end
-  def attribute(key, value = T.unsafe(nil), &block); end
-  def before(datum); end
-  def children; end
-  def clone; end
-  def css(*args); end
-  def delete(_arg0); end
-  def document; end
-  def document=(_arg0); end
-  def dup; end
-  def each; end
-  def empty?; end
-  def filter(expr); end
-  def first(n = T.unsafe(nil)); end
-  def include?(_arg0); end
-  def index(node = T.unsafe(nil)); end
-  def inner_html(*args); end
-  def inner_text; end
-  def inspect; end
-  def last; end
-  def length; end
-  def pop; end
-  def push(_arg0); end
-  def remove; end
-  def remove_attr(name); end
-  def remove_attribute(name); end
-  def remove_class(name = T.unsafe(nil)); end
-  def reverse; end
-  def set(key, value = T.unsafe(nil), &block); end
-  def shift; end
-  def size; end
-  def slice(*_arg0); end
-  def text; end
-  def to_a; end
-  def to_ary; end
-  def to_html(*args); end
-  def to_s; end
-  def to_xhtml(*args); end
-  def to_xml(*args); end
-  def unlink; end
-  def wrap(html); end
-  def xpath(*args); end
-  def |(_arg0); end
-end
-
-Nokogiri::XML::NodeSet::IMPLIED_XPATH_CONTEXTS = T.let(T.unsafe(nil), Array)
-class Nokogiri::XML::Notation < ::Struct; end
-module Nokogiri::XML::PP; end
-
-module Nokogiri::XML::PP::CharacterData
-  def inspect; end
-  def pretty_print(pp); end
-end
-
-module Nokogiri::XML::PP::Node
-  def inspect; end
-  def pretty_print(pp); end
-end
-
-class Nokogiri::XML::ParseOptions
-  def initialize(options = T.unsafe(nil)); end
-
-  def ==(other); end
-  def big_lines; end
-  def big_lines?; end
-  def compact; end
-  def compact?; end
-  def default_html; end
-  def default_html?; end
-  def default_schema; end
-  def default_schema?; end
-  def default_xml; end
-  def default_xml?; end
-  def default_xslt; end
-  def default_xslt?; end
-  def dtdattr; end
-  def dtdattr?; end
-  def dtdload; end
-  def dtdload?; end
-  def dtdvalid; end
-  def dtdvalid?; end
-  def huge; end
-  def huge?; end
-  def inspect; end
-  def nobasefix; end
-  def nobasefix?; end
-  def nobig_lines; end
-  def noblanks; end
-  def noblanks?; end
-  def nocdata; end
-  def nocdata?; end
-  def nocompact; end
-  def nodefault_html; end
-  def nodefault_schema; end
-  def nodefault_xml; end
-  def nodefault_xslt; end
-  def nodict; end
-  def nodict?; end
-  def nodtdattr; end
-  def nodtdload; end
-  def nodtdvalid; end
-  def noent; end
-  def noent?; end
-  def noerror; end
-  def noerror?; end
-  def nohuge; end
-  def nonet; end
-  def nonet?; end
-  def nonobasefix; end
-  def nonoblanks; end
-  def nonocdata; end
-  def nonodict; end
-  def nonoent; end
-  def nonoerror; end
-  def nononet; end
-  def nonowarning; end
-  def nonoxincnode; end
-  def nonsclean; end
-  def noold10; end
-  def nopedantic; end
-  def norecover; end
-  def nosax1; end
-  def nowarning; end
-  def nowarning?; end
-  def noxinclude; end
-  def noxincnode; end
-  def noxincnode?; end
-  def nsclean; end
-  def nsclean?; end
-  def old10; end
-  def old10?; end
-  def options; end
-  def options=(_arg0); end
-  def pedantic; end
-  def pedantic?; end
-  def recover; end
-  def recover?; end
-  def sax1; end
-  def sax1?; end
-  def strict; end
-  def strict?; end
-  def to_i; end
-  def xinclude; end
-  def xinclude?; end
-end
-
-Nokogiri::XML::ParseOptions::BIG_LINES = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::COMPACT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::DEFAULT_HTML = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::DEFAULT_SCHEMA = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::DEFAULT_XML = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::DEFAULT_XSLT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::DTDATTR = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::DTDLOAD = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::DTDVALID = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::HUGE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::NOBASEFIX = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::NOBLANKS = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::NOCDATA = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::NODICT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::NOENT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::NOERROR = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::NONET = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::NOWARNING = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::NOXINCNODE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::NSCLEAN = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::OLD10 = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::PEDANTIC = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::RECOVER = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::SAX1 = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::STRICT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::ParseOptions::XINCLUDE = T.let(T.unsafe(nil), Integer)
-
-class Nokogiri::XML::ProcessingInstruction < ::Nokogiri::XML::Node
-  def initialize(document, name, content); end
-
-  class << self
-    def new(*_arg0); end
-  end
-end
-
-class Nokogiri::XML::Reader
-  include ::Enumerable
-
-  def initialize(source, url = T.unsafe(nil), encoding = T.unsafe(nil)); end
-
-  def attribute(_arg0); end
-  def attribute_at(_arg0); end
-  def attribute_count; end
-  def attribute_nodes; end
-  def attributes; end
-  def attributes?; end
-  def base_uri; end
-  def default?; end
-  def depth; end
-  def each; end
-  def empty_element?; end
-  def encoding; end
-  def errors; end
-  def errors=(_arg0); end
-  def inner_xml; end
-  def lang; end
-  def local_name; end
-  def name; end
-  def namespace_uri; end
-  def namespaces; end
-  def node_type; end
-  def outer_xml; end
-  def prefix; end
-  def read; end
-  def self_closing?; end
-  def source; end
-  def state; end
-  def value; end
-  def value?; end
-  def xml_version; end
-
-  class << self
-    def from_io(*_arg0); end
-    def from_memory(*_arg0); end
-  end
-end
-
-Nokogiri::XML::Reader::TYPE_ATTRIBUTE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_CDATA = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_COMMENT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_DOCUMENT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_DOCUMENT_FRAGMENT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_DOCUMENT_TYPE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_ELEMENT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_END_ELEMENT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_END_ENTITY = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_ENTITY = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_ENTITY_REFERENCE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_NONE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_NOTATION = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_PROCESSING_INSTRUCTION = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_TEXT = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_WHITESPACE = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::Reader::TYPE_XML_DECLARATION = T.let(T.unsafe(nil), Integer)
-
-class Nokogiri::XML::RelaxNG < ::Nokogiri::XML::Schema
-  private
-
-  def validate_document(_arg0); end
-
-  class << self
-    def from_document(*_arg0); end
-    def read_memory(*_arg0); end
-  end
-end
-
-module Nokogiri::XML::SAX; end
-
-class Nokogiri::XML::SAX::Document
-  def cdata_block(string); end
-  def characters(string); end
-  def comment(string); end
-  def end_document; end
-  def end_element(name); end
-  def end_element_namespace(name, prefix = T.unsafe(nil), uri = T.unsafe(nil)); end
-  def error(string); end
-  def processing_instruction(name, content); end
-  def start_document; end
-  def start_element(name, attrs = T.unsafe(nil)); end
-  def start_element_namespace(name, attrs = T.unsafe(nil), prefix = T.unsafe(nil), uri = T.unsafe(nil), ns = T.unsafe(nil)); end
-  def warning(string); end
-  def xmldecl(version, encoding, standalone); end
-end
-
-class Nokogiri::XML::SAX::Parser
-  def initialize(doc = T.unsafe(nil), encoding = T.unsafe(nil)); end
-
-  def document; end
-  def document=(_arg0); end
-  def encoding; end
-  def encoding=(_arg0); end
-  def parse(thing, &block); end
-  def parse_file(filename); end
-  def parse_io(io, encoding = T.unsafe(nil)); end
-  def parse_memory(data); end
-
-  private
-
-  def check_encoding(encoding); end
-end
-
-class Nokogiri::XML::SAX::Parser::Attribute < ::Struct; end
-Nokogiri::XML::SAX::Parser::ENCODINGS = T.let(T.unsafe(nil), Hash)
-
-class Nokogiri::XML::SAX::ParserContext
-  def column; end
-  def line; end
-  def parse_with(_arg0); end
-  def recovery; end
-  def recovery=(_arg0); end
-  def replace_entities; end
-  def replace_entities=(_arg0); end
-
-  class << self
-    def file(_arg0); end
-    def io(_arg0, _arg1); end
-    def memory(_arg0); end
-    def new(thing, encoding = T.unsafe(nil)); end
-  end
-end
-
-class Nokogiri::XML::SAX::PushParser
-  def initialize(doc = T.unsafe(nil), file_name = T.unsafe(nil), encoding = T.unsafe(nil)); end
-
-  def <<(chunk, last_chunk = T.unsafe(nil)); end
-  def document; end
-  def document=(_arg0); end
-  def finish; end
-  def options; end
-  def options=(_arg0); end
-  def replace_entities; end
-  def replace_entities=(_arg0); end
-  def write(chunk, last_chunk = T.unsafe(nil)); end
-
-  private
-
-  def initialize_native(_arg0, _arg1); end
-  def native_write(_arg0, _arg1); end
-end
-
-class Nokogiri::XML::Schema
-  def errors; end
-  def errors=(_arg0); end
-  def parse_options; end
-  def parse_options=(_arg0); end
-  def valid?(thing); end
-  def validate(thing); end
-
-  private
-
-  def validate_document(_arg0); end
-  def validate_file(_arg0); end
-
-  class << self
-    def from_document(*_arg0); end
-    def new(string_or_io, options = T.unsafe(nil)); end
-    def read_memory(*_arg0); end
-  end
-end
-
-module Nokogiri::XML::Searchable
-  def %(*args); end
-  def /(*args); end
-  def >(selector); end
-  def at(*args); end
-  def at_css(*args); end
-  def at_xpath(*args); end
-  def css(*args); end
-  def search(*args); end
-  def xpath(*args); end
-
-  private
-
-  def css_internal(node, rules, handler, ns); end
-  def css_rules_to_xpath(rules, ns); end
-  def extract_params(params); end
-  def xpath_impl(node, path, handler, ns, binds); end
-  def xpath_internal(node, paths, handler, ns, binds); end
-  def xpath_query_from_css_rule(rule, ns); end
-end
-
-Nokogiri::XML::Searchable::LOOKS_LIKE_XPATH = T.let(T.unsafe(nil), Regexp)
-
-class Nokogiri::XML::SyntaxError < ::Nokogiri::SyntaxError
-  def code; end
-  def column; end
-  def domain; end
-  def error?; end
-  def fatal?; end
-  def file; end
-  def int1; end
-  def level; end
-  def line; end
-  def none?; end
-  def str1; end
-  def str2; end
-  def str3; end
-  def to_s; end
-  def warning?; end
-
-  private
-
-  def level_to_s; end
-  def location_to_s; end
-  def nil_or_zero?(attribute); end
-end
-
-class Nokogiri::XML::Text < ::Nokogiri::XML::CharacterData
-  def content=(string); end
-
-  class << self
-    def new(*_arg0); end
-  end
-end
-
-Nokogiri::XML::XML_C14N_1_0 = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::XML_C14N_1_1 = T.let(T.unsafe(nil), Integer)
-Nokogiri::XML::XML_C14N_EXCLUSIVE_1_0 = T.let(T.unsafe(nil), Integer)
-module Nokogiri::XML::XPath; end
-Nokogiri::XML::XPath::CURRENT_SEARCH_PREFIX = T.let(T.unsafe(nil), String)
-Nokogiri::XML::XPath::GLOBAL_SEARCH_PREFIX = T.let(T.unsafe(nil), String)
-Nokogiri::XML::XPath::ROOT_SEARCH_PREFIX = T.let(T.unsafe(nil), String)
-Nokogiri::XML::XPath::SUBTREE_SEARCH_PREFIX = T.let(T.unsafe(nil), String)
-
-class Nokogiri::XML::XPath::SyntaxError < ::Nokogiri::XML::SyntaxError
-  def to_s; end
-end
-
-class Nokogiri::XML::XPathContext
-  def evaluate(*_arg0); end
-  def register_namespaces(namespaces); end
-  def register_ns(_arg0, _arg1); end
-  def register_variable(_arg0, _arg1); end
-
-  class << self
-    def new(_arg0); end
-  end
-end
-
-module Nokogiri::XSLT
-  class << self
-    def parse(string, modules = T.unsafe(nil)); end
-    def quote_params(params); end
-    def register(_arg0, _arg1); end
-  end
-end
-
-class Nokogiri::XSLT::Stylesheet
-  def apply_to(document, params = T.unsafe(nil)); end
-  def serialize(_arg0); end
-  def transform(*_arg0); end
-
-  class << self
-    def parse_stylesheet_doc(_arg0); end
-  end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/parallel@1.22.1.rbi b/Library/Homebrew/sorbet/rbi/gems/parallel@1.22.1.rbi
deleted file mode 100644
index 5b00e8261a6b9..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/parallel@1.22.1.rbi
+++ /dev/null
@@ -1,116 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `parallel` gem.
-# Please instead update this file by running `bin/tapioca gem parallel`.
-
-module Parallel
-  extend ::Parallel::ProcessorCount
-
-  class << self
-    def all?(*args, &block); end
-    def any?(*args, &block); end
-    def each(array, options = T.unsafe(nil), &block); end
-    def each_with_index(array, options = T.unsafe(nil), &block); end
-    def flat_map(*args, &block); end
-    def in_processes(options = T.unsafe(nil), &block); end
-    def in_threads(options = T.unsafe(nil)); end
-    def map(source, options = T.unsafe(nil), &block); end
-    def map_with_index(array, options = T.unsafe(nil), &block); end
-    def worker_number; end
-    def worker_number=(worker_num); end
-
-    private
-
-    def add_progress_bar!(job_factory, options); end
-    def call_with_index(item, index, options, &block); end
-    def create_workers(job_factory, options, &block); end
-    def extract_count_from_options(options); end
-    def instrument_finish(item, index, result, options); end
-    def instrument_start(item, index, options); end
-    def process_incoming_jobs(read, write, job_factory, options, &block); end
-    def replace_worker(job_factory, workers, index, options, blk); end
-    def with_instrumentation(item, index, options); end
-    def work_direct(job_factory, options, &block); end
-    def work_in_processes(job_factory, options, &blk); end
-    def work_in_ractors(job_factory, options); end
-    def work_in_threads(job_factory, options, &block); end
-    def worker(job_factory, options, &block); end
-  end
-end
-
-class Parallel::Break < ::StandardError
-  def initialize(value = T.unsafe(nil)); end
-
-  def value; end
-end
-
-class Parallel::DeadWorker < ::StandardError; end
-
-class Parallel::ExceptionWrapper
-  def initialize(exception); end
-
-  def exception; end
-end
-
-class Parallel::JobFactory
-  def initialize(source, mutex); end
-
-  def next; end
-  def pack(item, index); end
-  def size; end
-  def unpack(data); end
-
-  private
-
-  def producer?; end
-  def queue_wrapper(array); end
-end
-
-class Parallel::Kill < ::Parallel::Break; end
-
-module Parallel::ProcessorCount
-  def physical_processor_count; end
-  def processor_count; end
-end
-
-Parallel::Stop = T.let(T.unsafe(nil), Object)
-
-class Parallel::UndumpableException < ::StandardError
-  def initialize(original); end
-
-  def backtrace; end
-end
-
-class Parallel::UserInterruptHandler
-  class << self
-    def kill(thing); end
-    def kill_on_ctrl_c(pids, options); end
-
-    private
-
-    def restore_interrupt(old, signal); end
-    def trap_interrupt(signal); end
-  end
-end
-
-Parallel::UserInterruptHandler::INTERRUPT_SIGNAL = T.let(T.unsafe(nil), Symbol)
-Parallel::VERSION = T.let(T.unsafe(nil), String)
-Parallel::Version = T.let(T.unsafe(nil), String)
-
-class Parallel::Worker
-  def initialize(read, write, pid); end
-
-  def close_pipes; end
-  def pid; end
-  def read; end
-  def stop; end
-  def thread; end
-  def thread=(_arg0); end
-  def work(data); end
-  def write; end
-
-  private
-
-  def wait; end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.11.1.rbi b/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.11.1.rbi
deleted file mode 100644
index a84e6edc6be4e..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.11.1.rbi
+++ /dev/null
@@ -1,95 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `parallel_tests` gem.
-# Please instead update this file by running `bin/tapioca gem parallel_tests`.
-
-module ParallelTests
-  class << self
-    def bundler_enabled?; end
-    def delta; end
-    def determine_number_of_processes(count); end
-    def first_process?; end
-    def last_process?; end
-    def now; end
-    def number_of_running_processes; end
-    def pid_file_path; end
-    def pids; end
-    def stop_all_processes; end
-    def wait_for_other_processes_to_finish; end
-    def with_pid_file; end
-    def with_ruby_binary(command); end
-  end
-end
-
-class ParallelTests::CLI
-  def run(argv); end
-
-  private
-
-  def any_test_failed?(test_results); end
-  def append_test_options(options, argv); end
-  def detailed_duration(seconds); end
-  def execute_command_in_parallel(command, num_processes, options); end
-  def execute_in_parallel(items, num_processes, options); end
-  def extract_file_paths(argv); end
-  def extract_test_options(argv); end
-  def final_fail_message; end
-  def first_is_1?; end
-  def handle_interrupt; end
-  def load_runner(type); end
-  def lock(lockfile); end
-  def parse_options!(argv); end
-  def pluralize(n, singular); end
-  def report_failure_rerun_commmand(test_results, options); end
-  def report_number_of_tests(groups); end
-  def report_results(test_results, options); end
-  def report_time_taken(&block); end
-  def reprint_output(result, lockfile); end
-  def run_tests(group, process_number, num_processes, options); end
-  def run_tests_in_parallel(num_processes, options); end
-  def simulate_output_for_ci(simulate); end
-  def use_colors?; end
-end
-
-class ParallelTests::Grouper
-  class << self
-    def by_scenarios(tests, num_groups, options = T.unsafe(nil)); end
-    def by_steps(tests, num_groups, options); end
-    def in_even_groups_by_size(items, num_groups, options = T.unsafe(nil)); end
-
-    private
-
-    def add_to_group(group, item, size); end
-    def group_by_features_with_steps(tests, options); end
-    def group_by_scenarios(tests, options = T.unsafe(nil)); end
-    def group_features_by_size(items, groups_to_fill); end
-    def isolate_count(options); end
-    def items_to_group(items); end
-    def largest_first(files); end
-    def smallest_group(groups); end
-    def specify_groups(items, num_groups, options, groups); end
-  end
-end
-
-class ParallelTests::Pids
-  def initialize(file_path); end
-
-  def add(pid); end
-  def all; end
-  def count; end
-  def delete(pid); end
-  def file_path; end
-  def mutex; end
-
-  private
-
-  def clear; end
-  def pids; end
-  def read; end
-  def save; end
-  def sync(&block); end
-end
-
-ParallelTests::RUBY_BINARY = T.let(T.unsafe(nil), String)
-ParallelTests::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/parallel_tests@4.7.2.rbi b/Library/Homebrew/sorbet/rbi/gems/parallel_tests@4.7.2.rbi
new file mode 100644
index 0000000000000..b2c5015ac41b7
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/parallel_tests@4.7.2.rbi
@@ -0,0 +1,246 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `parallel_tests` gem.
+# Please instead update this file by running `bin/tapioca gem parallel_tests`.
+
+
+# rake tasks for Rails 3+
+#
+# source://parallel_tests//lib/parallel_tests.rb#6
+module ParallelTests
+  class << self
+    # copied from http://github.com/carlhuda/bundler Bundler::SharedHelpers#find_gemfile
+    #
+    # @return [Boolean]
+    #
+    # source://parallel_tests//lib/parallel_tests.rb#52
+    def bundler_enabled?; end
+
+    # source://parallel_tests//lib/parallel_tests.rb#97
+    def delta; end
+
+    # source://parallel_tests//lib/parallel_tests.rb#16
+    def determine_number_of_processes(count); end
+
+    # @return [Boolean]
+    #
+    # source://parallel_tests//lib/parallel_tests.rb#68
+    def first_process?; end
+
+    # @return [Boolean]
+    #
+    # source://parallel_tests//lib/parallel_tests.rb#72
+    def last_process?; end
+
+    # source://parallel_tests//lib/parallel_tests.rb#93
+    def now; end
+
+    # source://parallel_tests//lib/parallel_tests.rb#89
+    def number_of_running_processes; end
+
+    # source://parallel_tests//lib/parallel_tests.rb#41
+    def pid_file_path; end
+
+    # source://parallel_tests//lib/parallel_tests.rb#37
+    def pids; end
+
+    # source://parallel_tests//lib/parallel_tests.rb#45
+    def stop_all_processes; end
+
+    # source://parallel_tests//lib/parallel_tests.rb#84
+    def wait_for_other_processes_to_finish; end
+
+    # source://parallel_tests//lib/parallel_tests.rb#24
+    def with_pid_file; end
+
+    # source://parallel_tests//lib/parallel_tests.rb#80
+    def with_ruby_binary(command); end
+  end
+end
+
+# source://parallel_tests//lib/parallel_tests/cli.rb#9
+class ParallelTests::CLI
+  # source://parallel_tests//lib/parallel_tests/cli.rb#10
+  def run(argv); end
+
+  private
+
+  # exit with correct status code so rake parallel:test && echo 123 works
+  #
+  # @return [Boolean]
+  #
+  # source://parallel_tests//lib/parallel_tests/cli.rb#178
+  def any_test_failed?(test_results); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#362
+  def append_test_options(options, argv); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#403
+  def detailed_duration(seconds); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#377
+  def execute_command_in_parallel(command, num_processes, options); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#56
+  def execute_in_parallel(items, num_processes, options); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#351
+  def extract_file_paths(argv); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#357
+  def extract_test_options(argv); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#410
+  def final_fail_message; end
+
+  # @return [Boolean]
+  #
+  # source://parallel_tests//lib/parallel_tests/cli.rb#420
+  def first_is_1?; end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#31
+  def handle_interrupt; end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#370
+  def load_runner(type); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#127
+  def lock(lockfile); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#182
+  def parse_options!(argv); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#167
+  def pluralize(n, singular); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#145
+  def report_failure_rerun_commmand(test_results, options); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#159
+  def report_number_of_tests(groups); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#137
+  def report_results(test_results, options); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#398
+  def report_time_taken(&block); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#119
+  def reprint_output(result, lockfile); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#111
+  def run_tests(group, process_number, num_processes, options); end
+
+  # source://parallel_tests//lib/parallel_tests/cli.rb#71
+  def run_tests_in_parallel(num_processes, options); end
+
+  # CI systems often fail when there is no output for a long time, so simulate some output
+  #
+  # source://parallel_tests//lib/parallel_tests/cli.rb#426
+  def simulate_output_for_ci(simulate); end
+
+  # @return [Boolean]
+  #
+  # source://parallel_tests//lib/parallel_tests/cli.rb#416
+  def use_colors?; end
+end
+
+# source://parallel_tests//lib/parallel_tests/grouper.rb#3
+class ParallelTests::Grouper
+  class << self
+    # source://parallel_tests//lib/parallel_tests/grouper.rb#10
+    def by_scenarios(tests, num_groups, options = T.unsafe(nil)); end
+
+    # source://parallel_tests//lib/parallel_tests/grouper.rb#5
+    def by_steps(tests, num_groups, options); end
+
+    # source://parallel_tests//lib/parallel_tests/grouper.rb#15
+    def in_even_groups_by_size(items, num_groups, options = T.unsafe(nil)); end
+
+    private
+
+    # source://parallel_tests//lib/parallel_tests/grouper.rb#113
+    def add_to_group(group, item, size); end
+
+    # source://parallel_tests//lib/parallel_tests/grouper.rb#118
+    def group_by_features_with_steps(tests, options); end
+
+    # source://parallel_tests//lib/parallel_tests/grouper.rb#123
+    def group_by_scenarios(tests, options = T.unsafe(nil)); end
+
+    # source://parallel_tests//lib/parallel_tests/grouper.rb#128
+    def group_features_by_size(items, groups_to_fill); end
+
+    # source://parallel_tests//lib/parallel_tests/grouper.rb#95
+    def isolate_count(options); end
+
+    # source://parallel_tests//lib/parallel_tests/grouper.rb#136
+    def items_to_group(items); end
+
+    # source://parallel_tests//lib/parallel_tests/grouper.rb#105
+    def largest_first(files); end
+
+    # source://parallel_tests//lib/parallel_tests/grouper.rb#109
+    def smallest_group(groups); end
+
+    # source://parallel_tests//lib/parallel_tests/grouper.rb#51
+    def specify_groups(items, num_groups, options, groups); end
+  end
+end
+
+# source://parallel_tests//lib/parallel_tests/pids.rb#5
+class ParallelTests::Pids
+  # @return [Pids] a new instance of Pids
+  #
+  # source://parallel_tests//lib/parallel_tests/pids.rb#8
+  def initialize(file_path); end
+
+  # source://parallel_tests//lib/parallel_tests/pids.rb#13
+  def add(pid); end
+
+  # source://parallel_tests//lib/parallel_tests/pids.rb#28
+  def all; end
+
+  # source://parallel_tests//lib/parallel_tests/pids.rb#23
+  def count; end
+
+  # source://parallel_tests//lib/parallel_tests/pids.rb#18
+  def delete(pid); end
+
+  # Returns the value of attribute file_path.
+  #
+  # source://parallel_tests//lib/parallel_tests/pids.rb#6
+  def file_path; end
+
+  # Returns the value of attribute mutex.
+  #
+  # source://parallel_tests//lib/parallel_tests/pids.rb#6
+  def mutex; end
+
+  private
+
+  # source://parallel_tests//lib/parallel_tests/pids.rb#39
+  def clear; end
+
+  # source://parallel_tests//lib/parallel_tests/pids.rb#35
+  def pids; end
+
+  # source://parallel_tests//lib/parallel_tests/pids.rb#44
+  def read; end
+
+  # source://parallel_tests//lib/parallel_tests/pids.rb#52
+  def save; end
+
+  # source://parallel_tests//lib/parallel_tests/pids.rb#56
+  def sync(&block); end
+end
+
+# source://parallel_tests//lib/parallel_tests.rb#8
+ParallelTests::RUBY_BINARY = T.let(T.unsafe(nil), String)
+
+# source://parallel_tests//lib/parallel_tests/version.rb#3
+ParallelTests::VERSION = T.let(T.unsafe(nil), String)
+
+# source://parallel_tests//lib/parallel_tests.rb#7
+ParallelTests::WINDOWS = T.let(T.unsafe(nil), T.untyped)
diff --git a/Library/Homebrew/sorbet/rbi/gems/parlour@8.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/parlour@8.0.0.rbi
deleted file mode 100644
index ee80f20bc3782..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/parlour@8.0.0.rbi
+++ /dev/null
@@ -1,2154 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `parlour` gem.
-# Please instead update this file by running `bin/tapioca gem parlour`.
-
-module Kernel
-  extend ::Forwardable
-end
-
-module Parlour; end
-
-class Parlour::ConflictResolver
-  def initialize; end
-
-  sig do
-    params(
-      namespace: Parlour::RbiGenerator::Namespace,
-      resolver: T.proc.params(desc: ::String, choices: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T.nilable(::Parlour::RbiGenerator::RbiObject))
-    ).void
-  end
-  def resolve_conflicts(namespace, &resolver); end
-
-  private
-
-  sig { params(arr: T::Array[T.untyped]).returns(T::Boolean) }
-  def all_eql?(arr); end
-
-  sig { params(namespace: Parlour::RbiGenerator::Namespace, name: T.nilable(::String)).void }
-  def deduplicate_mixins_of_name(namespace, name); end
-
-  sig { params(arr: T::Array[T.untyped]).returns(T.nilable(::Symbol)) }
-  def merge_strategy(arr); end
-end
-
-module Parlour::Conversion; end
-
-class Parlour::Conversion::Converter
-  abstract!
-
-  def initialize; end
-
-  sig { params(msg: ::String, node: ::Parlour::RbiGenerator::RbiObject).void }
-  def add_warning(msg, node); end
-
-  sig { returns(T::Array[[::String, ::Parlour::TypedObject]]) }
-  def warnings; end
-end
-
-class Parlour::Conversion::RbiToRbs < ::Parlour::Conversion::Converter
-  sig { params(rbs_gen: ::Parlour::RbsGenerator).void }
-  def initialize(rbs_gen); end
-
-  sig { params(from: Parlour::RbiGenerator::Namespace, to: Parlour::RbsGenerator::Namespace).void }
-  def convert_all(from, to); end
-
-  sig { params(node: ::Parlour::RbiGenerator::RbiObject, new_parent: Parlour::RbsGenerator::Namespace).void }
-  def convert_object(node, new_parent); end
-
-  sig { returns(::Parlour::RbsGenerator) }
-  def rbs_gen; end
-end
-
-module Parlour::Debugging
-  class << self
-    sig { params(value: T::Boolean).returns(T::Boolean) }
-    def debug_mode=(value); end
-
-    sig { returns(T::Boolean) }
-    def debug_mode?; end
-
-    sig { params(object: T.untyped, message: ::String).void }
-    def debug_puts(object, message); end
-
-    sig { params(object: T.untyped).returns(::String) }
-    def name_for_debug_caller(object); end
-  end
-end
-
-class Parlour::Debugging::Tree
-  sig { params(colour: T::Boolean).void }
-  def initialize(colour: T.unsafe(nil)); end
-
-  sig { params(message: ::String).returns(::String) }
-  def begin(message); end
-
-  sig { returns(T::Boolean) }
-  def colour; end
-
-  sig { params(message: ::String).returns(::String) }
-  def end(message); end
-
-  sig { params(message: ::String).returns(::String) }
-  def here(message); end
-
-  def indent!(offset); end
-  def line_prefix; end
-  def text_prefix; end
-end
-
-Parlour::Debugging::Tree::INDENT_SPACES = T.let(T.unsafe(nil), Integer)
-
-class Parlour::DetachedRbiGenerator < ::Parlour::RbiGenerator
-  sig { override.returns(T.nilable(::Parlour::Plugin)) }
-  def current_plugin; end
-
-  sig { returns(T.untyped) }
-  def detached!; end
-
-  sig { override.returns(::Parlour::Options) }
-  def options; end
-
-  sig { override.params(strictness: ::String).returns(::String) }
-  def rbi(strictness = T.unsafe(nil)); end
-end
-
-class Parlour::DetachedRbsGenerator < ::Parlour::RbsGenerator
-  sig { override.returns(T.nilable(::Parlour::Plugin)) }
-  def current_plugin; end
-
-  sig { returns(T.untyped) }
-  def detached!; end
-
-  sig { override.returns(::Parlour::Options) }
-  def options; end
-
-  sig { override.returns(::String) }
-  def rbs; end
-end
-
-class Parlour::Generator
-  sig { params(break_params: ::Integer, tab_size: ::Integer, sort_namespaces: T::Boolean).void }
-  def initialize(break_params: T.unsafe(nil), tab_size: T.unsafe(nil), sort_namespaces: T.unsafe(nil)); end
-
-  sig { overridable.returns(T.nilable(::Parlour::Plugin)) }
-  def current_plugin; end
-
-  def current_plugin=(_arg0); end
-
-  sig { overridable.returns(::Parlour::Options) }
-  def options; end
-end
-
-module Parlour::Mixin; end
-
-module Parlour::Mixin::Searchable
-  extend T::Generic
-
-  abstract!
-
-  Child = type_member { { upper: Parlour::TypedObject } }
-
-  sig { abstract.returns(T::Array[Child]) }
-  def children; end
-
-  sig { params(name: T.nilable(::String), type: T.nilable(::Class)).returns(Child) }
-  def find(name: T.unsafe(nil), type: T.unsafe(nil)); end
-
-  sig { params(name: T.nilable(::String), type: T.nilable(::Class)).returns(T::Array[Child]) }
-  def find_all(name: T.unsafe(nil), type: T.unsafe(nil)); end
-
-  private
-
-  sig { params(child: Child, name: T.nilable(::String), type: T.nilable(::Class)).returns(T::Boolean) }
-  def searchable_child_matches(child, name, type); end
-end
-
-class Parlour::Options
-  sig { params(break_params: ::Integer, tab_size: ::Integer, sort_namespaces: T::Boolean).void }
-  def initialize(break_params:, tab_size:, sort_namespaces:); end
-
-  sig { returns(::Integer) }
-  def break_params; end
-
-  sig { params(level: ::Integer, str: ::String).returns(::String) }
-  def indented(level, str); end
-
-  sig { returns(T::Boolean) }
-  def sort_namespaces; end
-
-  sig { returns(::Integer) }
-  def tab_size; end
-end
-
-class Parlour::ParseError < ::StandardError
-  def initialize(buffer, range); end
-
-  sig { returns(::Parser::Source::Buffer) }
-  def buffer; end
-
-  sig { returns(::Parser::Source::Range) }
-  def range; end
-end
-
-class Parlour::Plugin
-  abstract!
-
-  sig { params(options: T::Hash[T.untyped, T.untyped]).void }
-  def initialize(options); end
-
-  sig { abstract.params(root: Parlour::RbiGenerator::Namespace).void }
-  def generate(root); end
-
-  sig { returns(T.nilable(::String)) }
-  def strictness; end
-
-  def strictness=(_arg0); end
-
-  class << self
-    sig { params(new_plugin: T.class_of(Parlour::Plugin)).void }
-    def inherited(new_plugin); end
-
-    sig { returns(T::Hash[::String, T.class_of(Parlour::Plugin)]) }
-    def registered_plugins; end
-
-    sig do
-      params(
-        plugins: T::Array[::Parlour::Plugin],
-        generator: ::Parlour::RbiGenerator,
-        allow_failure: T::Boolean
-      ).void
-    end
-    def run_plugins(plugins, generator, allow_failure: T.unsafe(nil)); end
-  end
-end
-
-class Parlour::RbiGenerator < ::Parlour::Generator
-  def initialize(**hash); end
-
-  sig { overridable.params(strictness: ::String).returns(::String) }
-  def rbi(strictness = T.unsafe(nil)); end
-
-  sig { overridable.returns(Parlour::RbiGenerator::Namespace) }
-  def root; end
-end
-
-class Parlour::RbiGenerator::Arbitrary < ::Parlour::RbiGenerator::RbiObject
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      code: ::String,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Arbitrary).void)
-    ).void
-  end
-  def initialize(generator, code: T.unsafe(nil), &block); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(::String) }
-  def code; end
-
-  def code=(_arg0); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Attribute < ::Parlour::RbiGenerator::Method
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      kind: ::Symbol,
-      type: T.any(::Parlour::Types::Type, ::String),
-      class_attribute: T::Boolean,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void)
-    ).void
-  end
-  def initialize(generator, name, kind, type, class_attribute: T.unsafe(nil), &block); end
-
-  sig { override.params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(T::Boolean) }
-  def class_attribute; end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { returns(::Symbol) }
-  def kind; end
-
-  sig { returns(T.any(::Parlour::Types::Type, ::String)) }
-  def type; end
-
-  private
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_definition(indent_level, options); end
-end
-
-class Parlour::RbiGenerator::ClassNamespace < ::Parlour::RbiGenerator::Namespace
-  extend T::Generic
-
-  Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } }
-
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      final: T::Boolean,
-      sealed: T::Boolean,
-      superclass: T.nilable(::String),
-      abstract: T::Boolean,
-      block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)
-    ).void
-  end
-  def initialize(generator, name, final, sealed, superclass, abstract, &block); end
-
-  sig { returns(T::Boolean) }
-  def abstract; end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T.nilable(::String)) }
-  def superclass; end
-end
-
-class Parlour::RbiGenerator::Constant < ::Parlour::RbiGenerator::RbiObject
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      value: T.any(::Parlour::Types::Type, ::String),
-      eigen_constant: T::Boolean,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Constant).void)
-    ).void
-  end
-  def initialize(generator, name: T.unsafe(nil), value: T.unsafe(nil), eigen_constant: T.unsafe(nil), &block); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  def eigen_constant; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T.any(::Parlour::Types::Type, ::String)) }
-  def value; end
-end
-
-class Parlour::RbiGenerator::EnumClassNamespace < ::Parlour::RbiGenerator::ClassNamespace
-  extend T::Generic
-
-  Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } }
-
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      final: T::Boolean,
-      sealed: T::Boolean,
-      enums: T::Array[T.any(::String, [::String, ::String])],
-      abstract: T::Boolean,
-      block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void)
-    ).void
-  end
-  def initialize(generator, name, final, sealed, enums, abstract, &block); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { returns(T::Array[T.any(::String, [::String, ::String])]) }
-  def enums; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_body(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Extend < ::Parlour::RbiGenerator::RbiObject
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Extend).void)
-    ).void
-  end
-  def initialize(generator, name: T.unsafe(nil), &block); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Include < ::Parlour::RbiGenerator::RbiObject
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Include).void)
-    ).void
-  end
-  def initialize(generator, name: T.unsafe(nil), &block); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Method < ::Parlour::RbiGenerator::RbiObject
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      parameters: T::Array[::Parlour::RbiGenerator::Parameter],
-      return_type: T.nilable(T.any(::Parlour::Types::Type, ::String)),
-      abstract: T::Boolean,
-      implementation: T::Boolean,
-      override: T::Boolean,
-      overridable: T::Boolean,
-      class_method: T::Boolean,
-      final: T::Boolean,
-      type_parameters: T.nilable(T::Array[::Symbol]),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Method).void)
-    ).void
-  end
-  def initialize(generator, name, parameters, return_type = T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end
-
-  sig { overridable.params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(T::Boolean) }
-  def abstract; end
-
-  sig { returns(T::Boolean) }
-  def class_method; end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { returns(T::Boolean) }
-  def final; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { returns(T::Boolean) }
-  def implementation; end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T::Boolean) }
-  def overridable; end
-
-  sig { returns(T::Boolean) }
-  def override; end
-
-  sig { returns(T::Array[::Parlour::RbiGenerator::Parameter]) }
-  def parameters; end
-
-  sig { returns(T.nilable(T.any(::Parlour::Types::Type, ::String))) }
-  def return_type; end
-
-  sig { returns(T::Array[::Symbol]) }
-  def type_parameters; end
-
-  private
-
-  sig { overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_definition(indent_level, options); end
-
-  sig { returns(::String) }
-  def qualifiers; end
-end
-
-class Parlour::RbiGenerator::ModuleNamespace < ::Parlour::RbiGenerator::Namespace
-  extend T::Generic
-
-  Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } }
-
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      final: T::Boolean,
-      sealed: T::Boolean,
-      interface: T::Boolean,
-      abstract: T::Boolean,
-      block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)
-    ).void
-  end
-  def initialize(generator, name, final, sealed, interface, abstract, &block); end
-
-  sig { returns(T::Boolean) }
-  def abstract; end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { returns(T::Boolean) }
-  def interface; end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Namespace < ::Parlour::RbiGenerator::RbiObject
-  extend T::Generic
-  include ::Parlour::Mixin::Searchable
-
-  Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } }
-
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: T.nilable(::String),
-      final: T::Boolean,
-      sealed: T::Boolean,
-      block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Namespace).void)
-    ).void
-  end
-  def initialize(generator, name = T.unsafe(nil), final = T.unsafe(nil), sealed = T.unsafe(nil), &block); end
-
-  sig { params(comment: T.any(::String, T::Array[::String])).void }
-  def add_comment_to_next_child(comment); end
-
-  sig { returns(T::Array[::Parlour::RbiGenerator::TypeAlias]) }
-  def aliases; end
-
-  sig { override.returns(T::Array[::Parlour::RbiGenerator::RbiObject]) }
-  def children; end
-
-  sig { returns(T::Array[::Parlour::RbiGenerator::Constant]) }
-  def constants; end
-
-  def create_arbitrary(code:, &block); end
-  def create_attr(*args, &blk); end
-
-  sig do
-    params(
-      name: ::String,
-      type: T.any(::Parlour::Types::Type, ::String),
-      class_attribute: T::Boolean,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void)
-    ).returns(::Parlour::RbiGenerator::Attribute)
-  end
-  def create_attr_accessor(name, type:, class_attribute: T.unsafe(nil), &block); end
-
-  sig do
-    params(
-      name: ::String,
-      type: T.any(::Parlour::Types::Type, ::String),
-      class_attribute: T::Boolean,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void)
-    ).returns(::Parlour::RbiGenerator::Attribute)
-  end
-  def create_attr_reader(name, type:, class_attribute: T.unsafe(nil), &block); end
-
-  sig do
-    params(
-      name: ::String,
-      type: T.any(::Parlour::Types::Type, ::String),
-      class_attribute: T::Boolean,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void)
-    ).returns(::Parlour::RbiGenerator::Attribute)
-  end
-  def create_attr_writer(name, type:, class_attribute: T.unsafe(nil), &block); end
-
-  sig do
-    params(
-      name: ::String,
-      kind: ::Symbol,
-      type: T.any(::Parlour::Types::Type, ::String),
-      class_attribute: T::Boolean,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void)
-    ).returns(::Parlour::RbiGenerator::Attribute)
-  end
-  def create_attribute(name, kind:, type:, class_attribute: T.unsafe(nil), &block); end
-
-  sig do
-    params(
-      name: ::String,
-      final: T::Boolean,
-      sealed: T::Boolean,
-      superclass: T.nilable(::String),
-      abstract: T::Boolean,
-      block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)
-    ).returns(Parlour::RbiGenerator::ClassNamespace)
-  end
-  def create_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), superclass: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
-
-  sig do
-    params(
-      name: ::String,
-      value: ::String,
-      eigen_constant: T::Boolean,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Constant).void)
-    ).returns(::Parlour::RbiGenerator::Constant)
-  end
-  def create_constant(name, value:, eigen_constant: T.unsafe(nil), &block); end
-
-  sig do
-    params(
-      name: ::String,
-      final: T::Boolean,
-      sealed: T::Boolean,
-      enums: T.nilable(T::Array[T.any(::String, [::String, ::String])]),
-      abstract: T::Boolean,
-      block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void)
-    ).returns(Parlour::RbiGenerator::EnumClassNamespace)
-  end
-  def create_enum_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), enums: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
-
-  sig do
-    params(
-      name: ::String,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Extend).void)
-    ).returns(::Parlour::RbiGenerator::Extend)
-  end
-  def create_extend(name, &block); end
-
-  sig { params(extendables: T::Array[::String]).returns(T::Array[::Parlour::RbiGenerator::Extend]) }
-  def create_extends(extendables); end
-
-  sig do
-    params(
-      name: ::String,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Include).void)
-    ).returns(::Parlour::RbiGenerator::Include)
-  end
-  def create_include(name, &block); end
-
-  sig { params(includables: T::Array[::String]).returns(T::Array[::Parlour::RbiGenerator::Include]) }
-  def create_includes(includables); end
-
-  sig do
-    params(
-      name: ::String,
-      parameters: T.nilable(T::Array[::Parlour::RbiGenerator::Parameter]),
-      return_type: T.nilable(T.any(::Parlour::Types::Type, ::String)),
-      returns: T.nilable(T.any(::Parlour::Types::Type, ::String)),
-      abstract: T::Boolean,
-      implementation: T::Boolean,
-      override: T::Boolean,
-      overridable: T::Boolean,
-      class_method: T::Boolean,
-      final: T::Boolean,
-      type_parameters: T.nilable(T::Array[::Symbol]),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Method).void)
-    ).returns(::Parlour::RbiGenerator::Method)
-  end
-  def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), returns: T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end
-
-  sig do
-    params(
-      name: ::String,
-      final: T::Boolean,
-      sealed: T::Boolean,
-      interface: T::Boolean,
-      abstract: T::Boolean,
-      block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)
-    ).returns(Parlour::RbiGenerator::ModuleNamespace)
-  end
-  def create_module(name, final: T.unsafe(nil), sealed: T.unsafe(nil), interface: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
-
-  sig do
-    params(
-      name: ::String,
-      final: T::Boolean,
-      sealed: T::Boolean,
-      props: T.nilable(T::Array[::Parlour::RbiGenerator::StructProp]),
-      abstract: T::Boolean,
-      block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void)
-    ).returns(Parlour::RbiGenerator::StructClassNamespace)
-  end
-  def create_struct_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), props: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
-
-  sig do
-    params(
-      name: ::String,
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::TypeAlias).void)
-    ).returns(::Parlour::RbiGenerator::TypeAlias)
-  end
-  def create_type_alias(name, type:, &block); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { returns(T::Array[::Parlour::RbiGenerator::Extend]) }
-  def extends; end
-
-  sig { returns(T::Boolean) }
-  def final; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { returns(T::Array[::Parlour::RbiGenerator::Include]) }
-  def includes; end
-
-  sig { override.overridable.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.overridable.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { params(constant: ::Module, block: T.proc.params(x: Parlour::RbiGenerator::Namespace).void).void }
-  def path(constant, &block); end
-
-  sig { returns(T::Boolean) }
-  def sealed; end
-
-  def type_aliases(*args, &blk); end
-
-  private
-
-  sig { overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_body(indent_level, options); end
-
-  sig { params(object: ::Parlour::RbiGenerator::RbiObject).void }
-  def move_next_comments(object); end
-end
-
-Parlour::RbiGenerator::Options = Parlour::Options
-
-class Parlour::RbiGenerator::Parameter
-  sig do
-    params(
-      name: ::String,
-      type: T.nilable(T.any(::Parlour::Types::Type, ::String)),
-      default: T.nilable(::String)
-    ).void
-  end
-  def initialize(name, type: T.unsafe(nil), default: T.unsafe(nil)); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(T.nilable(::String)) }
-  def default; end
-
-  sig { returns(::String) }
-  def describe_in_method; end
-
-  sig { void }
-  def generalize_from_rbi!; end
-
-  sig { returns(::Symbol) }
-  def kind; end
-
-  sig { returns(::String) }
-  def name; end
-
-  sig { returns(::String) }
-  def name_without_kind; end
-
-  sig { returns(::String) }
-  def to_def_param; end
-
-  sig { returns(::String) }
-  def to_sig_param; end
-
-  sig { returns(T.any(::Parlour::Types::Type, ::String)) }
-  def type; end
-end
-
-Parlour::RbiGenerator::Parameter::PREFIXES = T.let(T.unsafe(nil), Hash)
-
-class Parlour::RbiGenerator::RbiObject < ::Parlour::TypedObject
-  abstract!
-
-  sig { params(generator: ::Parlour::Generator, name: ::String).void }
-  def initialize(generator, name); end
-
-  sig { abstract.void }
-  def generalize_from_rbi!; end
-
-  sig { abstract.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { returns(::Parlour::Generator) }
-  def generator; end
-
-  sig { abstract.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { abstract.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::StructClassNamespace < ::Parlour::RbiGenerator::ClassNamespace
-  extend T::Generic
-
-  Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } }
-
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      final: T::Boolean,
-      sealed: T::Boolean,
-      props: T::Array[::Parlour::RbiGenerator::StructProp],
-      abstract: T::Boolean,
-      block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void)
-    ).void
-  end
-  def initialize(generator, name, final, sealed, props, abstract, &block); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_body(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T::Array[::Parlour::RbiGenerator::StructProp]) }
-  def props; end
-end
-
-class Parlour::RbiGenerator::StructProp
-  sig do
-    params(
-      name: ::String,
-      type: T.any(::Parlour::Types::Type, ::String),
-      optional: T.nilable(T.any(::Symbol, T::Boolean)),
-      enum: T.nilable(::String),
-      dont_store: T.nilable(T::Boolean),
-      foreign: T.nilable(::String),
-      default: T.nilable(::String),
-      factory: T.nilable(::String),
-      immutable: T.nilable(T::Boolean),
-      array: T.nilable(::String),
-      override: T.nilable(T::Boolean),
-      redaction: T.nilable(::String)
-    ).void
-  end
-  def initialize(name, type, optional: T.unsafe(nil), enum: T.unsafe(nil), dont_store: T.unsafe(nil), foreign: T.unsafe(nil), default: T.unsafe(nil), factory: T.unsafe(nil), immutable: T.unsafe(nil), array: T.unsafe(nil), override: T.unsafe(nil), redaction: T.unsafe(nil)); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(T.nilable(::String)) }
-  def array; end
-
-  sig { returns(T.nilable(::String)) }
-  def default; end
-
-  sig { returns(T.nilable(T::Boolean)) }
-  def dont_store; end
-
-  sig { returns(T.nilable(::String)) }
-  def enum; end
-
-  sig { returns(T.nilable(::String)) }
-  def factory; end
-
-  sig { returns(T.nilable(::String)) }
-  def foreign; end
-
-  sig { void }
-  def generalize_from_rbi!; end
-
-  sig { returns(T.nilable(T::Boolean)) }
-  def immutable; end
-
-  sig { returns(::String) }
-  def name; end
-
-  sig { returns(T.nilable(T.any(::Symbol, T::Boolean))) }
-  def optional; end
-
-  sig { returns(T.nilable(T::Boolean)) }
-  def override; end
-
-  sig { returns(T.nilable(::String)) }
-  def redaction; end
-
-  sig { returns(::String) }
-  def to_prop_call; end
-
-  sig { returns(T.any(::Parlour::Types::Type, ::String)) }
-  def type; end
-end
-
-Parlour::RbiGenerator::StructProp::EXTRA_PROPERTIES = T.let(T.unsafe(nil), Array)
-
-class Parlour::RbiGenerator::TypeAlias < ::Parlour::RbiGenerator::RbiObject
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::TypeAlias).void)
-    ).void
-  end
-  def initialize(generator, name:, type:, &block); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T.any(::Parlour::Types::Type, ::String)) }
-  def type; end
-end
-
-class Parlour::RbsGenerator < ::Parlour::Generator
-  def initialize(**hash); end
-
-  sig { overridable.returns(::String) }
-  def rbs; end
-
-  sig { overridable.returns(Parlour::RbsGenerator::Namespace) }
-  def root; end
-end
-
-class Parlour::RbsGenerator::Arbitrary < ::Parlour::RbsGenerator::RbsObject
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      code: ::String,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Arbitrary).void)
-    ).void
-  end
-  def initialize(generator, code: T.unsafe(nil), &block); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(::String) }
-  def code; end
-
-  def code=(_arg0); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbs(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-end
-
-class Parlour::RbsGenerator::Attribute < ::Parlour::RbsGenerator::Method
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      kind: ::Symbol,
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void)
-    ).void
-  end
-  def initialize(generator, name, kind, type, &block); end
-
-  sig { override.params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbs(indent_level, options); end
-
-  sig { returns(::Symbol) }
-  def kind; end
-
-  sig { returns(T.any(::Parlour::Types::Type, ::String)) }
-  def type; end
-end
-
-class Parlour::RbsGenerator::Block
-  sig { params(type: ::Parlour::Types::Proc, required: T::Boolean).void }
-  def initialize(type, required); end
-
-  sig { overridable.params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { params(options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbs(options); end
-
-  sig { returns(T::Boolean) }
-  def required; end
-
-  sig { returns(::Parlour::Types::Proc) }
-  def type; end
-end
-
-class Parlour::RbsGenerator::ClassNamespace < ::Parlour::RbsGenerator::Namespace
-  extend T::Generic
-
-  Child = type_member { { fixed: Parlour::RbsGenerator::RbsObject } }
-
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      superclass: T.nilable(T.any(::Parlour::Types::Type, ::String)),
-      block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::ClassNamespace).void)
-    ).void
-  end
-  def initialize(generator, name, superclass, &block); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbs(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T.nilable(T.any(::Parlour::Types::Type, ::String))) }
-  def superclass; end
-end
-
-class Parlour::RbsGenerator::Constant < ::Parlour::RbsGenerator::RbsObject
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Constant).void)
-    ).void
-  end
-  def initialize(generator, name, type:, &block); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbs(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T.any(::Parlour::Types::Type, ::String)) }
-  def type; end
-end
-
-class Parlour::RbsGenerator::Extend < ::Parlour::RbsGenerator::RbsObject
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Extend).void)
-    ).void
-  end
-  def initialize(generator, type:, &block); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbs(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T.any(::Parlour::Types::Type, ::String)) }
-  def type; end
-end
-
-class Parlour::RbsGenerator::Include < ::Parlour::RbsGenerator::RbsObject
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Include).void)
-    ).void
-  end
-  def initialize(generator, type:, &block); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbs(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T.any(::Parlour::Types::Type, ::String)) }
-  def type; end
-end
-
-class Parlour::RbsGenerator::InterfaceNamespace < ::Parlour::RbsGenerator::Namespace
-  extend T::Generic
-
-  Child = type_member { { fixed: Parlour::RbsGenerator::RbsObject } }
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbs(indent_level, options); end
-end
-
-class Parlour::RbsGenerator::Method < ::Parlour::RbsGenerator::RbsObject
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      signatures: T::Array[::Parlour::RbsGenerator::MethodSignature],
-      class_method: T::Boolean,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Method).void)
-    ).void
-  end
-  def initialize(generator, name, signatures, class_method: T.unsafe(nil), &block); end
-
-  sig { overridable.params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(T::Boolean) }
-  def class_method; end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbs(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T::Array[::Parlour::RbsGenerator::MethodSignature]) }
-  def signatures; end
-end
-
-class Parlour::RbsGenerator::MethodSignature
-  sig do
-    params(
-      parameters: T::Array[::Parlour::RbsGenerator::Parameter],
-      return_type: T.nilable(T.any(::Parlour::Types::Type, ::String)),
-      block: T.nilable(::Parlour::RbsGenerator::Block),
-      type_parameters: T.nilable(T::Array[::Symbol])
-    ).void
-  end
-  def initialize(parameters, return_type = T.unsafe(nil), block: T.unsafe(nil), type_parameters: T.unsafe(nil)); end
-
-  sig { overridable.params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(T.nilable(::Parlour::RbsGenerator::Block)) }
-  def block; end
-
-  sig { returns(::String) }
-  def describe_in_method; end
-
-  sig { params(options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbs(options); end
-
-  sig { returns(T::Array[::Parlour::RbsGenerator::Parameter]) }
-  def parameters; end
-
-  sig { returns(T.nilable(T.any(::Parlour::Types::Type, ::String))) }
-  def return_type; end
-
-  sig { returns(T::Array[::Symbol]) }
-  def type_parameters; end
-end
-
-class Parlour::RbsGenerator::ModuleNamespace < ::Parlour::RbsGenerator::Namespace
-  extend T::Generic
-
-  Child = type_member { { fixed: Parlour::RbsGenerator::RbsObject } }
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbs(indent_level, options); end
-end
-
-class Parlour::RbsGenerator::Namespace < ::Parlour::RbsGenerator::RbsObject
-  extend T::Generic
-  include ::Parlour::Mixin::Searchable
-
-  Child = type_member { { fixed: Parlour::RbsGenerator::RbsObject } }
-
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: T.nilable(::String),
-      block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void)
-    ).void
-  end
-  def initialize(generator, name = T.unsafe(nil), &block); end
-
-  sig { params(comment: T.any(::String, T::Array[::String])).void }
-  def add_comment_to_next_child(comment); end
-
-  sig { returns(T::Array[::Parlour::RbsGenerator::TypeAlias]) }
-  def aliases; end
-
-  sig { override.returns(T::Array[::Parlour::RbsGenerator::RbsObject]) }
-  def children; end
-
-  sig { returns(T::Array[::Parlour::RbsGenerator::Constant]) }
-  def constants; end
-
-  def create_arbitrary(code:, &block); end
-  def create_attr(*args, &blk); end
-
-  sig do
-    params(
-      name: ::String,
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void)
-    ).returns(::Parlour::RbsGenerator::Attribute)
-  end
-  def create_attr_accessor(name, type:, &block); end
-
-  sig do
-    params(
-      name: ::String,
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void)
-    ).returns(::Parlour::RbsGenerator::Attribute)
-  end
-  def create_attr_reader(name, type:, &block); end
-
-  sig do
-    params(
-      name: ::String,
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void)
-    ).returns(::Parlour::RbsGenerator::Attribute)
-  end
-  def create_attr_writer(name, type:, &block); end
-
-  sig do
-    params(
-      name: ::String,
-      kind: ::Symbol,
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void)
-    ).returns(::Parlour::RbsGenerator::Attribute)
-  end
-  def create_attribute(name, kind:, type:, &block); end
-
-  sig do
-    params(
-      name: ::String,
-      superclass: T.nilable(T.any(::Parlour::Types::Type, ::String)),
-      block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::ClassNamespace).void)
-    ).returns(Parlour::RbsGenerator::ClassNamespace)
-  end
-  def create_class(name, superclass: T.unsafe(nil), &block); end
-
-  sig do
-    params(
-      name: ::String,
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Constant).void)
-    ).returns(::Parlour::RbsGenerator::Constant)
-  end
-  def create_constant(name, type:, &block); end
-
-  sig do
-    params(
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Extend).void)
-    ).returns(::Parlour::RbsGenerator::Extend)
-  end
-  def create_extend(type, &block); end
-
-  sig do
-    params(
-      extendables: T::Array[T.any(::Parlour::Types::Type, ::String)]
-    ).returns(T::Array[::Parlour::RbsGenerator::Extend])
-  end
-  def create_extends(extendables); end
-
-  sig do
-    params(
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Include).void)
-    ).returns(::Parlour::RbsGenerator::Include)
-  end
-  def create_include(type, &block); end
-
-  sig do
-    params(
-      includables: T::Array[T.any(::Parlour::Types::Type, ::String)]
-    ).returns(T::Array[::Parlour::RbsGenerator::Include])
-  end
-  def create_includes(includables); end
-
-  sig do
-    params(
-      name: ::String,
-      block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void)
-    ).returns(Parlour::RbsGenerator::InterfaceNamespace)
-  end
-  def create_interface(name, &block); end
-
-  sig do
-    params(
-      name: ::String,
-      signatures: T.nilable(T::Array[::Parlour::RbsGenerator::MethodSignature]),
-      class_method: T::Boolean,
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Method).void)
-    ).returns(::Parlour::RbsGenerator::Method)
-  end
-  def create_method(name, signatures = T.unsafe(nil), class_method: T.unsafe(nil), &block); end
-
-  sig do
-    params(
-      name: ::String,
-      block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void)
-    ).returns(Parlour::RbsGenerator::ModuleNamespace)
-  end
-  def create_module(name, &block); end
-
-  sig do
-    params(
-      name: ::String,
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::TypeAlias).void)
-    ).returns(::Parlour::RbsGenerator::TypeAlias)
-  end
-  def create_type_alias(name, type:, &block); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { returns(T::Array[::Parlour::RbsGenerator::Extend]) }
-  def extends; end
-
-  sig { override.overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbs(indent_level, options); end
-
-  sig { returns(T::Array[::Parlour::RbsGenerator::Include]) }
-  def includes; end
-
-  sig { override.overridable.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.overridable.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { params(object: T.untyped, block: T.proc.params(x: Parlour::RbsGenerator::Namespace).void).void }
-  def path(object, &block); end
-
-  def type_aliases(*args, &blk); end
-
-  private
-
-  sig { overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_body(indent_level, options); end
-
-  sig { params(object: ::Parlour::RbsGenerator::RbsObject).void }
-  def move_next_comments(object); end
-end
-
-class Parlour::RbsGenerator::Parameter
-  sig { params(name: ::String, type: T.nilable(T.any(::Parlour::Types::Type, ::String)), required: T::Boolean).void }
-  def initialize(name, type: T.unsafe(nil), required: T.unsafe(nil)); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(::Symbol) }
-  def kind; end
-
-  sig { returns(::String) }
-  def name; end
-
-  sig { returns(::String) }
-  def name_without_kind; end
-
-  sig { returns(T::Boolean) }
-  def required; end
-
-  sig { returns(::String) }
-  def to_rbs_param; end
-
-  sig { returns(T.any(::Parlour::Types::Type, ::String)) }
-  def type; end
-end
-
-Parlour::RbsGenerator::Parameter::PREFIXES = T.let(T.unsafe(nil), Hash)
-Parlour::RbsGenerator::Parameter::RBS_KEYWORDS = T.let(T.unsafe(nil), Array)
-
-class Parlour::RbsGenerator::RbsObject < ::Parlour::TypedObject
-  abstract!
-
-  sig { params(generator: ::Parlour::Generator, name: ::String).void }
-  def initialize(generator, name); end
-
-  sig { abstract.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbs(indent_level, options); end
-
-  sig { returns(::Parlour::Generator) }
-  def generator; end
-
-  sig { abstract.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
-  def merge_into_self(others); end
-
-  sig { abstract.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-end
-
-class Parlour::RbsGenerator::TypeAlias < ::Parlour::RbsGenerator::RbsObject
-  sig do
-    params(
-      generator: ::Parlour::Generator,
-      name: ::String,
-      type: T.any(::Parlour::Types::Type, ::String),
-      block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::TypeAlias).void)
-    ).void
-  end
-  def initialize(generator, name:, type:, &block); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_rbs(indent_level, options); end
-
-  sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T.any(::Parlour::Types::Type, ::String)) }
-  def type; end
-end
-
-module Parlour::TypeLoader
-  class << self
-    sig do
-      params(
-        filename: ::String,
-        generator: T.nilable(::Parlour::RbiGenerator)
-      ).returns(Parlour::RbiGenerator::Namespace)
-    end
-    def load_file(filename, generator: T.unsafe(nil)); end
-
-    sig do
-      params(
-        root: ::String,
-        inclusions: T::Array[::String],
-        exclusions: T::Array[::String],
-        generator: T.nilable(::Parlour::RbiGenerator)
-      ).returns(Parlour::RbiGenerator::Namespace)
-    end
-    def load_project(root, inclusions: T.unsafe(nil), exclusions: T.unsafe(nil), generator: T.unsafe(nil)); end
-
-    sig do
-      params(
-        source: ::String,
-        filename: T.nilable(::String),
-        generator: T.nilable(::Parlour::RbiGenerator)
-      ).returns(Parlour::RbiGenerator::Namespace)
-    end
-    def load_source(source, filename = T.unsafe(nil), generator: T.unsafe(nil)); end
-  end
-end
-
-class Parlour::TypeParser
-  sig do
-    params(
-      ast: ::Parser::AST::Node,
-      unknown_node_errors: T::Boolean,
-      generator: T.nilable(::Parlour::RbiGenerator)
-    ).void
-  end
-  def initialize(ast, unknown_node_errors: T.unsafe(nil), generator: T.unsafe(nil)); end
-
-  sig { returns(::Parser::AST::Node) }
-  def ast; end
-
-  def ast=(_arg0); end
-
-  sig { returns(::Parlour::RbiGenerator) }
-  def generator; end
-
-  def generator=(_arg0); end
-
-  sig { returns(Parlour::RbiGenerator::Namespace) }
-  def parse_all; end
-
-  sig do
-    params(
-      path: ::Parlour::TypeParser::NodePath,
-      is_within_eigenclass: T::Boolean
-    ).returns(T::Array[::Parlour::RbiGenerator::Method])
-  end
-  def parse_method_into_methods(path, is_within_eigenclass: T.unsafe(nil)); end
-
-  sig { params(node: ::Parser::AST::Node).returns(::Parlour::Types::Type) }
-  def parse_node_to_type(node); end
-
-  sig do
-    params(
-      path: ::Parlour::TypeParser::NodePath,
-      is_within_eigenclass: T::Boolean
-    ).returns(T::Array[::Parlour::RbiGenerator::RbiObject])
-  end
-  def parse_path_to_object(path, is_within_eigenclass: T.unsafe(nil)); end
-
-  sig do
-    params(
-      path: ::Parlour::TypeParser::NodePath,
-      is_within_eigenclass: T::Boolean
-    ).returns(T::Array[::Parlour::RbiGenerator::Method])
-  end
-  def parse_sig_into_methods(path, is_within_eigenclass: T.unsafe(nil)); end
-
-  sig { params(path: ::Parlour::TypeParser::NodePath).returns(::Parlour::TypeParser::IntermediateSig) }
-  def parse_sig_into_sig(path); end
-
-  sig { returns(T::Boolean) }
-  def unknown_node_errors; end
-
-  protected
-
-  sig { params(node: T.nilable(::Parser::AST::Node), modifier: ::Symbol).returns(T::Boolean) }
-  def body_has_modifier?(node, modifier); end
-
-  sig { params(node: ::Parser::AST::Node).returns([T::Array[::String], T::Array[::String]]) }
-  def body_includes_and_extends(node); end
-
-  sig { params(node: T.nilable(::Parser::AST::Node)).returns(T::Array[::Symbol]) }
-  def constant_names(node); end
-
-  sig { params(node: T.nilable(::Parser::AST::Node)).returns(T.nilable(::String)) }
-  def node_to_s(node); end
-
-  sig { params(desc: ::String, node: T.any(::Parlour::TypeParser::NodePath, ::Parser::AST::Node)).returns(T.noreturn) }
-  def parse_err(desc, node); end
-
-  sig { params(path: ::Parlour::TypeParser::NodePath).returns(T::Boolean) }
-  def previous_sibling_sig_node?(path); end
-
-  sig { params(node: ::Parser::AST::Node).returns(T::Boolean) }
-  def sig_node?(node); end
-
-  sig { params(msg: ::String, node: ::Parser::AST::Node).void }
-  def warning(msg, node); end
-
-  sig do
-    type_parameters(:A, :B)
-      .params(
-        a: T::Array[T.type_parameter(:A)],
-        fa: T.proc.params(item: T.type_parameter(:A)).returns(T.untyped),
-        b: T::Array[T.type_parameter(:B)],
-        fb: T.proc.params(item: T.type_parameter(:B)).returns(T.untyped)
-      ).returns(T::Array[[T.type_parameter(:A), T.type_parameter(:B)]])
-  end
-  def zip_by(a, fa, b, fb); end
-
-  class << self
-    sig do
-      params(
-        filename: ::String,
-        source: ::String,
-        generator: T.nilable(::Parlour::RbiGenerator)
-      ).returns(::Parlour::TypeParser)
-    end
-    def from_source(filename, source, generator: T.unsafe(nil)); end
-
-    sig { params(str: ::String).returns(::Parlour::Types::Type) }
-    def parse_single_type(str); end
-  end
-end
-
-class Parlour::TypeParser::IntermediateSig < ::T::Struct
-  prop :abstract, T::Boolean
-  prop :final, T::Boolean
-  prop :overridable, T::Boolean
-  prop :override, T::Boolean
-  prop :params, T.nilable(T::Array[::Parser::AST::Node])
-  prop :return_type, T.nilable(::String)
-  prop :type_parameters, T.nilable(T::Array[::Symbol])
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-class Parlour::TypeParser::NodePath
-  sig { params(indices: T::Array[::Integer]).void }
-  def initialize(indices); end
-
-  sig { params(index: ::Integer).returns(::Parlour::TypeParser::NodePath) }
-  def child(index); end
-
-  sig { returns(T::Array[::Integer]) }
-  def indices; end
-
-  sig { returns(::Parlour::TypeParser::NodePath) }
-  def parent; end
-
-  sig { params(offset: ::Integer).returns(::Parlour::TypeParser::NodePath) }
-  def sibling(offset); end
-
-  sig { params(start: ::Parser::AST::Node).returns(::Parser::AST::Node) }
-  def traverse(start); end
-end
-
-class Parlour::TypedObject
-  abstract!
-
-  sig { params(name: ::String).void }
-  def initialize(name); end
-
-  sig { params(comment: T.any(::String, T::Array[::String])).void }
-  def add_comment(comment); end
-
-  def add_comments(*args, &blk); end
-
-  sig { returns(T::Array[::String]) }
-  def comments; end
-
-  sig { returns(::String) }
-  def describe; end
-
-  sig { params(tree: T.nilable(::Parlour::Debugging::Tree)).returns(::String) }
-  def describe_tree(tree: T.unsafe(nil)); end
-
-  sig { returns(T.nilable(::Parlour::Plugin)) }
-  def generated_by; end
-
-  def inspect(*args, &blk); end
-
-  sig { returns(::String) }
-  def name; end
-
-  def to_s(*args, &blk); end
-
-  protected
-
-  sig { abstract.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
-  def describe_attrs; end
-
-  sig { params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
-  def generate_comments(indent_level, options); end
-end
-
-module Parlour::Types; end
-
-class Parlour::Types::Array < ::Parlour::Types::SingleElementCollection
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def collection_name; end
-end
-
-class Parlour::Types::Boolean < ::Parlour::Types::Type
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def describe; end
-
-  sig { override.returns(::String) }
-  def generate_rbi; end
-
-  sig { override.returns(::String) }
-  def generate_rbs; end
-end
-
-class Parlour::Types::Class < ::Parlour::Types::Type
-  sig { params(type: T.any(::Parlour::Types::Type, ::String)).void }
-  def initialize(type); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def describe; end
-
-  sig { override.returns(::String) }
-  def generate_rbi; end
-
-  sig { override.returns(::String) }
-  def generate_rbs; end
-
-  sig { returns(::Parlour::Types::Type) }
-  def type; end
-end
-
-class Parlour::Types::Enumerable < ::Parlour::Types::SingleElementCollection
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def collection_name; end
-end
-
-class Parlour::Types::Enumerator < ::Parlour::Types::SingleElementCollection
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def collection_name; end
-end
-
-class Parlour::Types::Generic < ::Parlour::Types::Type
-  sig do
-    params(
-      type: T.any(::Parlour::Types::Type, ::String),
-      type_params: T::Array[T.any(::Parlour::Types::Type, ::String)]
-    ).void
-  end
-  def initialize(type, type_params); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def describe; end
-
-  sig { override.returns(::String) }
-  def generate_rbi; end
-
-  sig { override.returns(::String) }
-  def generate_rbs; end
-
-  sig { returns(::Parlour::Types::Type) }
-  def type; end
-
-  sig { returns(T::Array[::Parlour::Types::Type]) }
-  def type_params; end
-end
-
-class Parlour::Types::Hash < ::Parlour::Types::Type
-  sig { params(key: T.any(::Parlour::Types::Type, ::String), value: T.any(::Parlour::Types::Type, ::String)).void }
-  def initialize(key, value); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def describe; end
-
-  sig { override.returns(::String) }
-  def generate_rbi; end
-
-  sig { override.returns(::String) }
-  def generate_rbs; end
-
-  sig { returns(::Parlour::Types::Type) }
-  def key; end
-
-  sig { returns(::Parlour::Types::Type) }
-  def value; end
-end
-
-class Parlour::Types::Intersection < ::Parlour::Types::Type
-  sig { params(types: T::Array[T.any(::Parlour::Types::Type, ::String)]).void }
-  def initialize(types); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def describe; end
-
-  sig { override.returns(::String) }
-  def generate_rbi; end
-
-  sig { override.returns(::String) }
-  def generate_rbs; end
-
-  sig { returns(T::Array[::Parlour::Types::Type]) }
-  def types; end
-end
-
-class Parlour::Types::Nilable < ::Parlour::Types::Type
-  sig { params(type: T.any(::Parlour::Types::Type, ::String)).void }
-  def initialize(type); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def describe; end
-
-  sig { override.returns(::String) }
-  def generate_rbi; end
-
-  sig { override.returns(::String) }
-  def generate_rbs; end
-
-  sig { returns(::Parlour::Types::Type) }
-  def type; end
-end
-
-class Parlour::Types::Proc < ::Parlour::Types::Type
-  sig do
-    params(
-      parameters: T::Array[::Parlour::Types::Proc::Parameter],
-      return_type: T.nilable(T.any(::Parlour::Types::Type, ::String))
-    ).void
-  end
-  def initialize(parameters, return_type); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def describe; end
-
-  sig { override.returns(::String) }
-  def generate_rbi; end
-
-  sig { override.returns(::String) }
-  def generate_rbs; end
-
-  sig { returns(T::Array[::Parlour::Types::Proc::Parameter]) }
-  def parameters; end
-
-  sig { returns(T.nilable(::Parlour::Types::Type)) }
-  def return_type; end
-end
-
-class Parlour::Types::Proc::Parameter
-  sig { params(name: ::String, type: T.any(::Parlour::Types::Type, ::String), default: T.nilable(::String)).void }
-  def initialize(name, type, default = T.unsafe(nil)); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(T.nilable(::String)) }
-  def default; end
-
-  sig { returns(::String) }
-  def name; end
-
-  sig { returns(::Parlour::Types::Type) }
-  def type; end
-end
-
-class Parlour::Types::Range < ::Parlour::Types::SingleElementCollection
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def collection_name; end
-end
-
-class Parlour::Types::Raw < ::Parlour::Types::Type
-  sig { params(str: ::String).void }
-  def initialize(str); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def describe; end
-
-  sig { override.returns(::String) }
-  def generate_rbi; end
-
-  sig { override.returns(::String) }
-  def generate_rbs; end
-
-  sig { returns(::String) }
-  def str; end
-end
-
-class Parlour::Types::Record < ::Parlour::Types::Type
-  sig { params(keys_to_types: T::Hash[::Symbol, T.any(::Parlour::Types::Type, ::String)]).void }
-  def initialize(keys_to_types); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def describe; end
-
-  sig { override.returns(::String) }
-  def generate_rbi; end
-
-  sig { override.returns(::String) }
-  def generate_rbs; end
-
-  sig { returns(T::Hash[::Symbol, ::Parlour::Types::Type]) }
-  def keys_to_types; end
-end
-
-class Parlour::Types::Self < ::Parlour::Types::Type
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def describe; end
-
-  sig { override.returns(::String) }
-  def generate_rbi; end
-
-  sig { override.returns(::String) }
-  def generate_rbs; end
-end
-
-class Parlour::Types::Set < ::Parlour::Types::SingleElementCollection
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def collection_name; end
-end
-
-class Parlour::Types::SingleElementCollection < ::Parlour::Types::Type
-  abstract!
-
-  sig { params(element: T.any(::Parlour::Types::Type, ::String)).void }
-  def initialize(element); end
-
-  sig { abstract.returns(::String) }
-  def collection_name; end
-
-  sig { override.returns(::String) }
-  def describe; end
-
-  sig { returns(::Parlour::Types::Type) }
-  def element; end
-
-  sig { override.returns(::String) }
-  def generate_rbi; end
-
-  sig { override.returns(::String) }
-  def generate_rbs; end
-end
-
-class Parlour::Types::Tuple < ::Parlour::Types::Type
-  sig { params(types: T::Array[T.any(::Parlour::Types::Type, ::String)]).void }
-  def initialize(types); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def describe; end
-
-  sig { override.returns(::String) }
-  def generate_rbi; end
-
-  sig { override.returns(::String) }
-  def generate_rbs; end
-
-  sig { returns(T::Array[::Parlour::Types::Type]) }
-  def types; end
-end
-
-class Parlour::Types::Type
-  abstract!
-
-  def initialize(*args, &blk); end
-
-  sig { abstract.returns(::String) }
-  def describe; end
-
-  sig { abstract.returns(::String) }
-  def generate_rbi; end
-
-  sig { abstract.returns(::String) }
-  def generate_rbs; end
-
-  def hash; end
-
-  sig { params(type_like: T.any(::Parlour::Types::Type, ::String)).returns(::Parlour::Types::Type) }
-  def to_type(type_like); end
-
-  class << self
-    sig { params(type_like: T.any(::Parlour::Types::Type, ::String)).returns(::Parlour::Types::Type) }
-    def to_type(type_like); end
-  end
-end
-
-Parlour::Types::TypeLike = T.type_alias { T.any(::Parlour::Types::Type, ::String) }
-
-class Parlour::Types::Union < ::Parlour::Types::Type
-  sig { params(types: T::Array[T.any(::Parlour::Types::Type, ::String)]).void }
-  def initialize(types); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def describe; end
-
-  sig { override.returns(::String) }
-  def generate_rbi; end
-
-  sig { override.returns(::String) }
-  def generate_rbs; end
-
-  sig { returns(T::Array[::Parlour::Types::Type]) }
-  def types; end
-end
-
-class Parlour::Types::Untyped < ::Parlour::Types::Type
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(::String) }
-  def describe; end
-
-  sig { override.returns(::String) }
-  def generate_rbi; end
-
-  sig { override.returns(::String) }
-  def generate_rbs; end
-end
-
-Parlour::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/parser@3.1.2.0.rbi b/Library/Homebrew/sorbet/rbi/gems/parser@3.1.2.0.rbi
deleted file mode 100644
index 975e204c51324..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/parser@3.1.2.0.rbi
+++ /dev/null
@@ -1,1653 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `parser` gem.
-# Please instead update this file by running `bin/tapioca gem parser`.
-
-module Parser
-  class << self
-    private
-
-    def warn_syntax_deviation(feature, version); end
-  end
-end
-
-module Parser::AST; end
-
-class Parser::AST::Node < ::AST::Node
-  def assign_properties(properties); end
-  def loc; end
-  def location; end
-end
-
-class Parser::AST::Processor < ::AST::Processor
-  def on_alias(node); end
-  def on_and(node); end
-  def on_and_asgn(node); end
-  def on_arg(node); end
-  def on_arg_expr(node); end
-  def on_args(node); end
-  def on_argument(node); end
-  def on_array(node); end
-  def on_array_pattern(node); end
-  def on_array_pattern_with_tail(node); end
-  def on_back_ref(node); end
-  def on_begin(node); end
-  def on_block(node); end
-  def on_block_pass(node); end
-  def on_blockarg(node); end
-  def on_blockarg_expr(node); end
-  def on_break(node); end
-  def on_case(node); end
-  def on_case_match(node); end
-  def on_casgn(node); end
-  def on_class(node); end
-  def on_const(node); end
-  def on_const_pattern(node); end
-  def on_csend(node); end
-  def on_cvar(node); end
-  def on_cvasgn(node); end
-  def on_def(node); end
-  def on_defined?(node); end
-  def on_defs(node); end
-  def on_dstr(node); end
-  def on_dsym(node); end
-  def on_eflipflop(node); end
-  def on_empty_else(node); end
-  def on_ensure(node); end
-  def on_erange(node); end
-  def on_find_pattern(node); end
-  def on_for(node); end
-  def on_forward_arg(node); end
-  def on_gvar(node); end
-  def on_gvasgn(node); end
-  def on_hash(node); end
-  def on_hash_pattern(node); end
-  def on_if(node); end
-  def on_if_guard(node); end
-  def on_iflipflop(node); end
-  def on_in_match(node); end
-  def on_in_pattern(node); end
-  def on_index(node); end
-  def on_indexasgn(node); end
-  def on_irange(node); end
-  def on_ivar(node); end
-  def on_ivasgn(node); end
-  def on_kwarg(node); end
-  def on_kwargs(node); end
-  def on_kwbegin(node); end
-  def on_kwoptarg(node); end
-  def on_kwrestarg(node); end
-  def on_kwsplat(node); end
-  def on_lambda(node); end
-  def on_lvar(node); end
-  def on_lvasgn(node); end
-  def on_masgn(node); end
-  def on_match_alt(node); end
-  def on_match_as(node); end
-  def on_match_current_line(node); end
-  def on_match_pattern(node); end
-  def on_match_pattern_p(node); end
-  def on_match_rest(node); end
-  def on_match_var(node); end
-  def on_match_with_lvasgn(node); end
-  def on_mlhs(node); end
-  def on_module(node); end
-  def on_next(node); end
-  def on_not(node); end
-  def on_nth_ref(node); end
-  def on_numblock(node); end
-  def on_op_asgn(node); end
-  def on_optarg(node); end
-  def on_or(node); end
-  def on_or_asgn(node); end
-  def on_pair(node); end
-  def on_pin(node); end
-  def on_postexe(node); end
-  def on_preexe(node); end
-  def on_procarg0(node); end
-  def on_redo(node); end
-  def on_regexp(node); end
-  def on_resbody(node); end
-  def on_rescue(node); end
-  def on_restarg(node); end
-  def on_restarg_expr(node); end
-  def on_retry(node); end
-  def on_return(node); end
-  def on_sclass(node); end
-  def on_send(node); end
-  def on_shadowarg(node); end
-  def on_splat(node); end
-  def on_super(node); end
-  def on_undef(node); end
-  def on_unless_guard(node); end
-  def on_until(node); end
-  def on_until_post(node); end
-  def on_var(node); end
-  def on_vasgn(node); end
-  def on_when(node); end
-  def on_while(node); end
-  def on_while_post(node); end
-  def on_xstr(node); end
-  def on_yield(node); end
-  def process_argument_node(node); end
-  def process_regular_node(node); end
-  def process_var_asgn_node(node); end
-  def process_variable_node(node); end
-end
-
-class Parser::Base < ::Racc::Parser
-  def initialize(builder = T.unsafe(nil)); end
-
-  def builder; end
-  def context; end
-  def current_arg_stack; end
-  def diagnostics; end
-  def lexer; end
-  def max_numparam_stack; end
-  def parse(source_buffer); end
-  def parse_with_comments(source_buffer); end
-  def pattern_hash_keys; end
-  def pattern_variables; end
-  def reset; end
-  def source_buffer; end
-  def static_env; end
-  def tokenize(source_buffer, recover = T.unsafe(nil)); end
-
-  private
-
-  def check_kwarg_name(name_t); end
-  def diagnostic(level, reason, arguments, location_t, highlights_ts = T.unsafe(nil)); end
-  def next_token; end
-  def on_error(error_token_id, error_value, value_stack); end
-
-  class << self
-    def default_parser; end
-    def parse(string, file = T.unsafe(nil), line = T.unsafe(nil)); end
-    def parse_file(filename); end
-    def parse_file_with_comments(filename); end
-    def parse_with_comments(string, file = T.unsafe(nil), line = T.unsafe(nil)); end
-
-    private
-
-    def setup_source_buffer(file, line, string, encoding); end
-  end
-end
-
-module Parser::Builders; end
-
-class Parser::Builders::Default
-  def initialize; end
-
-  def __ENCODING__(__ENCODING__t); end
-  def __FILE__(__FILE__t); end
-  def __LINE__(__LINE__t); end
-  def accessible(node); end
-  def alias(alias_t, to, from); end
-  def arg(name_t); end
-  def arg_expr(expr); end
-  def args(begin_t, args, end_t, check_args = T.unsafe(nil)); end
-  def array(begin_t, elements, end_t); end
-  def array_pattern(lbrack_t, elements, rbrack_t); end
-  def assign(lhs, eql_t, rhs); end
-  def assignable(node); end
-  def associate(begin_t, pairs, end_t); end
-  def attr_asgn(receiver, dot_t, selector_t); end
-  def back_ref(token); end
-  def begin(begin_t, body, end_t); end
-  def begin_body(compound_stmt, rescue_bodies = T.unsafe(nil), else_t = T.unsafe(nil), else_ = T.unsafe(nil), ensure_t = T.unsafe(nil), ensure_ = T.unsafe(nil)); end
-  def begin_keyword(begin_t, body, end_t); end
-  def binary_op(receiver, operator_t, arg); end
-  def block(method_call, begin_t, args, body, end_t); end
-  def block_pass(amper_t, arg); end
-  def blockarg(amper_t, name_t); end
-  def blockarg_expr(amper_t, expr); end
-  def call_lambda(lambda_t); end
-  def call_method(receiver, dot_t, selector_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
-  def call_type_for_dot(dot_t); end
-  def case(case_t, expr, when_bodies, else_t, else_body, end_t); end
-  def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end
-  def character(char_t); end
-  def complex(complex_t); end
-  def compstmt(statements); end
-  def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end
-  def condition_mod(if_true, if_false, cond_t, cond); end
-  def const(name_t); end
-  def const_fetch(scope, t_colon2, name_t); end
-  def const_global(t_colon3, name_t); end
-  def const_op_assignable(node); end
-  def const_pattern(const, ldelim_t, pattern, rdelim_t); end
-  def cvar(token); end
-  def dedent_string(node, dedent_level); end
-  def def_class(class_t, name, lt_t, superclass, body, end_t); end
-  def def_endless_method(def_t, name_t, args, assignment_t, body); end
-  def def_endless_singleton(def_t, definee, dot_t, name_t, args, assignment_t, body); end
-  def def_method(def_t, name_t, args, body, end_t); end
-  def def_module(module_t, name, body, end_t); end
-  def def_sclass(class_t, lshft_t, expr, body, end_t); end
-  def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end
-  def emit_file_line_as_literals; end
-  def emit_file_line_as_literals=(_arg0); end
-  def false(false_t); end
-  def find_pattern(lbrack_t, elements, rbrack_t); end
-  def float(float_t); end
-  def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end
-  def forward_arg(dots_t); end
-  def forward_only_args(begin_t, dots_t, end_t); end
-  def forwarded_args(dots_t); end
-  def gvar(token); end
-  def hash_pattern(lbrace_t, kwargs, rbrace_t); end
-  def ident(token); end
-  def if_guard(if_t, if_body); end
-  def in_match(lhs, in_t, rhs); end
-  def in_pattern(in_t, pattern, guard, then_t, body); end
-  def index(receiver, lbrack_t, indexes, rbrack_t); end
-  def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end
-  def integer(integer_t); end
-  def ivar(token); end
-  def keyword_cmd(type, keyword_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
-  def kwarg(name_t); end
-  def kwnilarg(dstar_t, nil_t); end
-  def kwoptarg(name_t, value); end
-  def kwrestarg(dstar_t, name_t = T.unsafe(nil)); end
-  def kwsplat(dstar_t, arg); end
-  def logical_op(type, lhs, op_t, rhs); end
-  def loop(type, keyword_t, cond, do_t, body, end_t); end
-  def loop_mod(type, body, keyword_t, cond); end
-  def match_alt(left, pipe_t, right); end
-  def match_as(value, assoc_t, as); end
-  def match_hash_var(name_t); end
-  def match_hash_var_from_str(begin_t, strings, end_t); end
-  def match_label(label_type, label); end
-  def match_nil_pattern(dstar_t, nil_t); end
-  def match_op(receiver, match_t, arg); end
-  def match_pair(label_type, label, value); end
-  def match_pattern(lhs, match_t, rhs); end
-  def match_pattern_p(lhs, match_t, rhs); end
-  def match_rest(star_t, name_t = T.unsafe(nil)); end
-  def match_var(name_t); end
-  def match_with_trailing_comma(match, comma_t); end
-  def multi_assign(lhs, eql_t, rhs); end
-  def multi_lhs(begin_t, items, end_t); end
-  def nil(nil_t); end
-  def not_op(not_t, begin_t = T.unsafe(nil), receiver = T.unsafe(nil), end_t = T.unsafe(nil)); end
-  def nth_ref(token); end
-  def numargs(max_numparam); end
-  def objc_kwarg(kwname_t, assoc_t, name_t); end
-  def objc_restarg(star_t, name = T.unsafe(nil)); end
-  def objc_varargs(pair, rest_of_varargs); end
-  def op_assign(lhs, op_t, rhs); end
-  def optarg(name_t, eql_t, value); end
-  def pair(key, assoc_t, value); end
-  def pair_keyword(key_t, value); end
-  def pair_label(key_t); end
-  def pair_list_18(list); end
-  def pair_quoted(begin_t, parts, end_t, value); end
-  def parser; end
-  def parser=(_arg0); end
-  def pin(pin_t, var); end
-  def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end
-  def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end
-  def procarg0(arg); end
-  def range_exclusive(lhs, dot3_t, rhs); end
-  def range_inclusive(lhs, dot2_t, rhs); end
-  def rational(rational_t); end
-  def regexp_compose(begin_t, parts, end_t, options); end
-  def regexp_options(regopt_t); end
-  def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end
-  def restarg(star_t, name_t = T.unsafe(nil)); end
-  def restarg_expr(star_t, expr = T.unsafe(nil)); end
-  def self(token); end
-  def shadowarg(name_t); end
-  def splat(star_t, arg = T.unsafe(nil)); end
-  def string(string_t); end
-  def string_compose(begin_t, parts, end_t); end
-  def string_internal(string_t); end
-  def symbol(symbol_t); end
-  def symbol_compose(begin_t, parts, end_t); end
-  def symbol_internal(symbol_t); end
-  def symbols_compose(begin_t, parts, end_t); end
-  def ternary(cond, question_t, if_true, colon_t, if_false); end
-  def true(true_t); end
-  def unary_num(unary_t, numeric); end
-  def unary_op(op_t, receiver); end
-  def undef_method(undef_t, names); end
-  def unless_guard(unless_t, unless_body); end
-  def when(when_t, patterns, then_t, body); end
-  def word(parts); end
-  def words_compose(begin_t, parts, end_t); end
-  def xstring_compose(begin_t, parts, end_t); end
-
-  private
-
-  def arg_name_collides?(this_name, that_name); end
-  def arg_prefix_map(op_t, name_t = T.unsafe(nil)); end
-  def binary_op_map(left_e, op_t, right_e); end
-  def block_map(receiver_l, begin_t, end_t); end
-  def check_assignment_to_numparam(name, loc); end
-  def check_condition(cond); end
-  def check_duplicate_arg(this_arg, map = T.unsafe(nil)); end
-  def check_duplicate_args(args, map = T.unsafe(nil)); end
-  def check_duplicate_pattern_key(name, loc); end
-  def check_duplicate_pattern_variable(name, loc); end
-  def check_lvar_name(name, loc); end
-  def check_reserved_for_numparam(name, loc); end
-  def collapse_string_parts?(parts); end
-  def collection_map(begin_t, parts, end_t); end
-  def condition_map(keyword_t, cond_e, begin_t, body_e, else_t, else_e, end_t); end
-  def constant_map(scope, colon2_t, name_t); end
-  def definition_map(keyword_t, operator_t, name_t, end_t); end
-  def delimited_string_map(string_t); end
-  def diagnostic(type, reason, arguments, location, highlights = T.unsafe(nil)); end
-  def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end
-  def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e); end
-  def expr_map(loc); end
-  def for_map(keyword_t, in_t, begin_t, end_t); end
-  def guard_map(keyword_t, guard_body_e); end
-  def index_map(receiver_e, lbrack_t, rbrack_t); end
-  def join_exprs(left_expr, right_expr); end
-  def keyword_map(keyword_t, begin_t, args, end_t); end
-  def keyword_mod_map(pre_e, keyword_t, post_e); end
-  def kwarg_map(name_t, value_e = T.unsafe(nil)); end
-  def kwargs?(node); end
-  def loc(token); end
-  def module_definition_map(keyword_t, name_e, operator_t, end_t); end
-  def n(type, children, source_map); end
-  def n0(type, source_map); end
-  def numeric(kind, token); end
-  def pair_keyword_map(key_t, value_e); end
-  def pair_quoted_map(begin_t, end_t, value_e); end
-  def prefix_string_map(symbol); end
-  def range_map(start_e, op_t, end_e); end
-  def regexp_map(begin_t, end_t, options_e); end
-  def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end
-  def rewrite_hash_args_to_kwargs(args); end
-  def send_binary_op_map(lhs_e, selector_t, rhs_e); end
-  def send_index_map(receiver_e, lbrack_t, rbrack_t); end
-  def send_map(receiver_e, dot_t, selector_t, begin_t = T.unsafe(nil), args = T.unsafe(nil), end_t = T.unsafe(nil)); end
-  def send_unary_op_map(selector_t, arg_e); end
-  def static_regexp(parts, options); end
-  def static_regexp_node(node); end
-  def static_string(nodes); end
-  def string_map(begin_t, parts, end_t); end
-  def string_value(token); end
-  def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end
-  def token_map(token); end
-  def unary_op_map(op_t, arg_e = T.unsafe(nil)); end
-  def unquoted_map(token); end
-  def validate_definee(definee); end
-  def validate_no_forward_arg_after_restarg(args); end
-  def value(token); end
-  def var_send_map(variable_e); end
-  def variable_map(name_t); end
-
-  class << self
-    def emit_arg_inside_procarg0; end
-    def emit_arg_inside_procarg0=(_arg0); end
-    def emit_encoding; end
-    def emit_encoding=(_arg0); end
-    def emit_forward_arg; end
-    def emit_forward_arg=(_arg0); end
-    def emit_index; end
-    def emit_index=(_arg0); end
-    def emit_kwargs; end
-    def emit_kwargs=(_arg0); end
-    def emit_lambda; end
-    def emit_lambda=(_arg0); end
-    def emit_match_pattern; end
-    def emit_match_pattern=(_arg0); end
-    def emit_procarg0; end
-    def emit_procarg0=(_arg0); end
-    def modernize; end
-  end
-end
-
-class Parser::ClobberingError < ::RuntimeError; end
-
-class Parser::Context
-  def initialize; end
-
-  def in_argdef; end
-  def in_argdef=(_arg0); end
-  def in_block; end
-  def in_block=(_arg0); end
-  def in_class; end
-  def in_class=(_arg0); end
-  def in_def; end
-  def in_def=(_arg0); end
-  def in_defined; end
-  def in_defined=(_arg0); end
-  def in_dynamic_block?; end
-  def in_kwarg; end
-  def in_kwarg=(_arg0); end
-  def in_lambda; end
-  def in_lambda=(_arg0); end
-  def reset; end
-end
-
-Parser::Context::FLAGS = T.let(T.unsafe(nil), Array)
-
-class Parser::CurrentArgStack
-  def initialize; end
-
-  def empty?; end
-  def pop; end
-  def push(value); end
-  def reset; end
-  def set(value); end
-  def stack; end
-  def top; end
-end
-
-Parser::CurrentRuby = Parser::Ruby26
-
-module Parser::Deprecation
-  def warn_of_deprecation; end
-  def warned_of_deprecation=(_arg0); end
-end
-
-class Parser::Diagnostic
-  def initialize(level, reason, arguments, location, highlights = T.unsafe(nil)); end
-
-  def arguments; end
-  def highlights; end
-  def level; end
-  def location; end
-  def message; end
-  def reason; end
-  def render; end
-
-  private
-
-  def first_line_only(range); end
-  def last_line_only(range); end
-  def render_line(range, ellipsis = T.unsafe(nil), range_end = T.unsafe(nil)); end
-end
-
-class Parser::Diagnostic::Engine
-  def initialize(consumer = T.unsafe(nil)); end
-
-  def all_errors_are_fatal; end
-  def all_errors_are_fatal=(_arg0); end
-  def consumer; end
-  def consumer=(_arg0); end
-  def ignore_warnings; end
-  def ignore_warnings=(_arg0); end
-  def process(diagnostic); end
-
-  protected
-
-  def ignore?(diagnostic); end
-  def raise?(diagnostic); end
-end
-
-Parser::Diagnostic::LEVELS = T.let(T.unsafe(nil), Array)
-
-class Parser::Lexer
-  def initialize(version); end
-
-  def advance; end
-  def cmdarg; end
-  def cmdarg=(_arg0); end
-  def cmdarg_stack; end
-  def command_start; end
-  def command_start=(_arg0); end
-  def comments; end
-  def comments=(_arg0); end
-  def cond; end
-  def cond=(_arg0); end
-  def cond_stack; end
-  def context; end
-  def context=(_arg0); end
-  def dedent_level; end
-  def diagnostics; end
-  def diagnostics=(_arg0); end
-  def encoding; end
-  def force_utf32; end
-  def force_utf32=(_arg0); end
-  def lambda_stack; end
-  def paren_nest; end
-  def pop_cmdarg; end
-  def pop_cond; end
-  def push_cmdarg; end
-  def push_cond; end
-  def reset(reset_state = T.unsafe(nil)); end
-  def source_buffer; end
-  def source_buffer=(source_buffer); end
-  def state; end
-  def state=(state); end
-  def static_env; end
-  def static_env=(_arg0); end
-  def tokens; end
-  def tokens=(_arg0); end
-
-  protected
-
-  def arg_or_cmdarg(cmd_state); end
-  def diagnostic(type, reason, arguments = T.unsafe(nil), location = T.unsafe(nil), highlights = T.unsafe(nil)); end
-  def emit(type, value = T.unsafe(nil), s = T.unsafe(nil), e = T.unsafe(nil)); end
-  def emit_comment(s = T.unsafe(nil), e = T.unsafe(nil)); end
-  def emit_do(do_block = T.unsafe(nil)); end
-  def emit_table(table, s = T.unsafe(nil), e = T.unsafe(nil)); end
-  def encode_escape(ord); end
-  def eof_codepoint?(point); end
-  def literal; end
-  def next_state_for_literal(literal); end
-  def pop_literal; end
-  def push_literal(*args); end
-  def range(s = T.unsafe(nil), e = T.unsafe(nil)); end
-  def stack_pop; end
-  def tok(s = T.unsafe(nil), e = T.unsafe(nil)); end
-  def version?(*versions); end
-
-  class << self
-    def lex_en_expr_arg; end
-    def lex_en_expr_arg=(_arg0); end
-    def lex_en_expr_beg; end
-    def lex_en_expr_beg=(_arg0); end
-    def lex_en_expr_cmdarg; end
-    def lex_en_expr_cmdarg=(_arg0); end
-    def lex_en_expr_dot; end
-    def lex_en_expr_dot=(_arg0); end
-    def lex_en_expr_end; end
-    def lex_en_expr_end=(_arg0); end
-    def lex_en_expr_endarg; end
-    def lex_en_expr_endarg=(_arg0); end
-    def lex_en_expr_endfn; end
-    def lex_en_expr_endfn=(_arg0); end
-    def lex_en_expr_fname; end
-    def lex_en_expr_fname=(_arg0); end
-    def lex_en_expr_labelarg; end
-    def lex_en_expr_labelarg=(_arg0); end
-    def lex_en_expr_mid; end
-    def lex_en_expr_mid=(_arg0); end
-    def lex_en_expr_value; end
-    def lex_en_expr_value=(_arg0); end
-    def lex_en_expr_variable; end
-    def lex_en_expr_variable=(_arg0); end
-    def lex_en_interp_backslash_delimited; end
-    def lex_en_interp_backslash_delimited=(_arg0); end
-    def lex_en_interp_backslash_delimited_words; end
-    def lex_en_interp_backslash_delimited_words=(_arg0); end
-    def lex_en_interp_string; end
-    def lex_en_interp_string=(_arg0); end
-    def lex_en_interp_words; end
-    def lex_en_interp_words=(_arg0); end
-    def lex_en_leading_dot; end
-    def lex_en_leading_dot=(_arg0); end
-    def lex_en_line_begin; end
-    def lex_en_line_begin=(_arg0); end
-    def lex_en_line_comment; end
-    def lex_en_line_comment=(_arg0); end
-    def lex_en_plain_backslash_delimited; end
-    def lex_en_plain_backslash_delimited=(_arg0); end
-    def lex_en_plain_backslash_delimited_words; end
-    def lex_en_plain_backslash_delimited_words=(_arg0); end
-    def lex_en_plain_string; end
-    def lex_en_plain_string=(_arg0); end
-    def lex_en_plain_words; end
-    def lex_en_plain_words=(_arg0); end
-    def lex_en_regexp_modifiers; end
-    def lex_en_regexp_modifiers=(_arg0); end
-    def lex_error; end
-    def lex_error=(_arg0); end
-    def lex_start; end
-    def lex_start=(_arg0); end
-
-    private
-
-    def _lex_eof_trans; end
-    def _lex_eof_trans=(_arg0); end
-    def _lex_from_state_actions; end
-    def _lex_from_state_actions=(_arg0); end
-    def _lex_index_offsets; end
-    def _lex_index_offsets=(_arg0); end
-    def _lex_indicies; end
-    def _lex_indicies=(_arg0); end
-    def _lex_key_spans; end
-    def _lex_key_spans=(_arg0); end
-    def _lex_to_state_actions; end
-    def _lex_to_state_actions=(_arg0); end
-    def _lex_trans_actions; end
-    def _lex_trans_actions=(_arg0); end
-    def _lex_trans_keys; end
-    def _lex_trans_keys=(_arg0); end
-    def _lex_trans_targs; end
-    def _lex_trans_targs=(_arg0); end
-  end
-end
-
-class Parser::Lexer::Dedenter
-  def initialize(dedent_level); end
-
-  def dedent(string); end
-  def interrupt; end
-end
-
-Parser::Lexer::Dedenter::TAB_WIDTH = T.let(T.unsafe(nil), Integer)
-Parser::Lexer::ESCAPES = T.let(T.unsafe(nil), Hash)
-Parser::Lexer::KEYWORDS = T.let(T.unsafe(nil), Hash)
-Parser::Lexer::KEYWORDS_BEGIN = T.let(T.unsafe(nil), Hash)
-Parser::Lexer::LEX_STATES = T.let(T.unsafe(nil), Hash)
-
-class Parser::Lexer::Literal
-  def initialize(lexer, str_type, delimiter, str_s, heredoc_e = T.unsafe(nil), indent = T.unsafe(nil), dedent_body = T.unsafe(nil), label_allowed = T.unsafe(nil)); end
-
-  def backslash_delimited?; end
-  def dedent_level; end
-  def end_interp_brace_and_try_closing; end
-  def extend_content; end
-  def extend_space(ts, te); end
-  def extend_string(string, ts, te); end
-  def flush_string; end
-  def heredoc?; end
-  def heredoc_e; end
-  def infer_indent_level(line); end
-  def interpolate?; end
-  def munge_escape?(character); end
-  def nest_and_try_closing(delimiter, ts, te, lookahead = T.unsafe(nil)); end
-  def plain_heredoc?; end
-  def regexp?; end
-  def saved_herebody_s; end
-  def saved_herebody_s=(_arg0); end
-  def squiggly_heredoc?; end
-  def start_interp_brace; end
-  def str_s; end
-  def supports_line_continuation_via_slash?; end
-  def type; end
-  def words?; end
-
-  protected
-
-  def clear_buffer; end
-  def coerce_encoding(string); end
-  def delimiter?(delimiter); end
-  def emit(token, type, s, e); end
-  def emit_start_tok; end
-end
-
-Parser::Lexer::Literal::DELIMITERS = T.let(T.unsafe(nil), Hash)
-Parser::Lexer::Literal::TYPES = T.let(T.unsafe(nil), Hash)
-Parser::Lexer::PUNCTUATION = T.let(T.unsafe(nil), Hash)
-Parser::Lexer::PUNCTUATION_BEGIN = T.let(T.unsafe(nil), Hash)
-Parser::Lexer::REGEXP_META_CHARACTERS = T.let(T.unsafe(nil), Regexp)
-
-class Parser::Lexer::StackState
-  def initialize(name); end
-
-  def active?; end
-  def clear; end
-  def empty?; end
-  def inspect; end
-  def lexpop; end
-  def pop; end
-  def push(bit); end
-  def to_s; end
-end
-
-Parser::MESSAGES = T.let(T.unsafe(nil), Hash)
-
-class Parser::MaxNumparamStack
-  def initialize; end
-
-  def empty?; end
-  def has_numparams?; end
-  def has_ordinary_params!; end
-  def has_ordinary_params?; end
-  def pop; end
-  def push(static:); end
-  def register(numparam); end
-  def stack; end
-  def top; end
-
-  private
-
-  def set(value); end
-end
-
-Parser::MaxNumparamStack::ORDINARY_PARAMS = T.let(T.unsafe(nil), Integer)
-
-module Parser::Messages
-  class << self
-    def compile(reason, arguments); end
-  end
-end
-
-module Parser::Meta; end
-Parser::Meta::NODE_TYPES = T.let(T.unsafe(nil), Set)
-
-class Parser::Rewriter < ::Parser::AST::Processor
-  extend ::Parser::Deprecation
-
-  def initialize(*_arg0); end
-
-  def assignment?(node); end
-  def insert_after(range, content); end
-  def insert_before(range, content); end
-  def remove(range); end
-  def replace(range, content); end
-  def rewrite(source_buffer, ast); end
-  def wrap(range, before, after); end
-end
-
-Parser::Rewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
-
-class Parser::Ruby26 < ::Parser::Base
-  def _reduce_10(val, _values, result); end
-  def _reduce_100(val, _values, result); end
-  def _reduce_101(val, _values, result); end
-  def _reduce_102(val, _values, result); end
-  def _reduce_103(val, _values, result); end
-  def _reduce_104(val, _values, result); end
-  def _reduce_105(val, _values, result); end
-  def _reduce_106(val, _values, result); end
-  def _reduce_107(val, _values, result); end
-  def _reduce_108(val, _values, result); end
-  def _reduce_109(val, _values, result); end
-  def _reduce_11(val, _values, result); end
-  def _reduce_110(val, _values, result); end
-  def _reduce_111(val, _values, result); end
-  def _reduce_113(val, _values, result); end
-  def _reduce_114(val, _values, result); end
-  def _reduce_115(val, _values, result); end
-  def _reduce_12(val, _values, result); end
-  def _reduce_121(val, _values, result); end
-  def _reduce_125(val, _values, result); end
-  def _reduce_126(val, _values, result); end
-  def _reduce_127(val, _values, result); end
-  def _reduce_13(val, _values, result); end
-  def _reduce_14(val, _values, result); end
-  def _reduce_15(val, _values, result); end
-  def _reduce_17(val, _values, result); end
-  def _reduce_18(val, _values, result); end
-  def _reduce_19(val, _values, result); end
-  def _reduce_199(val, _values, result); end
-  def _reduce_2(val, _values, result); end
-  def _reduce_20(val, _values, result); end
-  def _reduce_200(val, _values, result); end
-  def _reduce_201(val, _values, result); end
-  def _reduce_202(val, _values, result); end
-  def _reduce_203(val, _values, result); end
-  def _reduce_204(val, _values, result); end
-  def _reduce_205(val, _values, result); end
-  def _reduce_206(val, _values, result); end
-  def _reduce_207(val, _values, result); end
-  def _reduce_208(val, _values, result); end
-  def _reduce_209(val, _values, result); end
-  def _reduce_21(val, _values, result); end
-  def _reduce_210(val, _values, result); end
-  def _reduce_211(val, _values, result); end
-  def _reduce_212(val, _values, result); end
-  def _reduce_213(val, _values, result); end
-  def _reduce_214(val, _values, result); end
-  def _reduce_215(val, _values, result); end
-  def _reduce_216(val, _values, result); end
-  def _reduce_217(val, _values, result); end
-  def _reduce_218(val, _values, result); end
-  def _reduce_219(val, _values, result); end
-  def _reduce_22(val, _values, result); end
-  def _reduce_220(val, _values, result); end
-  def _reduce_221(val, _values, result); end
-  def _reduce_222(val, _values, result); end
-  def _reduce_223(val, _values, result); end
-  def _reduce_224(val, _values, result); end
-  def _reduce_226(val, _values, result); end
-  def _reduce_227(val, _values, result); end
-  def _reduce_228(val, _values, result); end
-  def _reduce_229(val, _values, result); end
-  def _reduce_23(val, _values, result); end
-  def _reduce_230(val, _values, result); end
-  def _reduce_231(val, _values, result); end
-  def _reduce_232(val, _values, result); end
-  def _reduce_233(val, _values, result); end
-  def _reduce_234(val, _values, result); end
-  def _reduce_235(val, _values, result); end
-  def _reduce_236(val, _values, result); end
-  def _reduce_237(val, _values, result); end
-  def _reduce_238(val, _values, result); end
-  def _reduce_24(val, _values, result); end
-  def _reduce_244(val, _values, result); end
-  def _reduce_245(val, _values, result); end
-  def _reduce_249(val, _values, result); end
-  def _reduce_25(val, _values, result); end
-  def _reduce_250(val, _values, result); end
-  def _reduce_252(val, _values, result); end
-  def _reduce_253(val, _values, result); end
-  def _reduce_254(val, _values, result); end
-  def _reduce_256(val, _values, result); end
-  def _reduce_259(val, _values, result); end
-  def _reduce_26(val, _values, result); end
-  def _reduce_260(val, _values, result); end
-  def _reduce_261(val, _values, result); end
-  def _reduce_262(val, _values, result); end
-  def _reduce_263(val, _values, result); end
-  def _reduce_264(val, _values, result); end
-  def _reduce_265(val, _values, result); end
-  def _reduce_266(val, _values, result); end
-  def _reduce_267(val, _values, result); end
-  def _reduce_268(val, _values, result); end
-  def _reduce_269(val, _values, result); end
-  def _reduce_27(val, _values, result); end
-  def _reduce_270(val, _values, result); end
-  def _reduce_271(val, _values, result); end
-  def _reduce_272(val, _values, result); end
-  def _reduce_273(val, _values, result); end
-  def _reduce_274(val, _values, result); end
-  def _reduce_275(val, _values, result); end
-  def _reduce_277(val, _values, result); end
-  def _reduce_278(val, _values, result); end
-  def _reduce_279(val, _values, result); end
-  def _reduce_28(val, _values, result); end
-  def _reduce_29(val, _values, result); end
-  def _reduce_290(val, _values, result); end
-  def _reduce_291(val, _values, result); end
-  def _reduce_292(val, _values, result); end
-  def _reduce_293(val, _values, result); end
-  def _reduce_294(val, _values, result); end
-  def _reduce_295(val, _values, result); end
-  def _reduce_296(val, _values, result); end
-  def _reduce_297(val, _values, result); end
-  def _reduce_298(val, _values, result); end
-  def _reduce_299(val, _values, result); end
-  def _reduce_3(val, _values, result); end
-  def _reduce_300(val, _values, result); end
-  def _reduce_301(val, _values, result); end
-  def _reduce_302(val, _values, result); end
-  def _reduce_303(val, _values, result); end
-  def _reduce_304(val, _values, result); end
-  def _reduce_305(val, _values, result); end
-  def _reduce_306(val, _values, result); end
-  def _reduce_307(val, _values, result); end
-  def _reduce_308(val, _values, result); end
-  def _reduce_309(val, _values, result); end
-  def _reduce_31(val, _values, result); end
-  def _reduce_311(val, _values, result); end
-  def _reduce_312(val, _values, result); end
-  def _reduce_313(val, _values, result); end
-  def _reduce_314(val, _values, result); end
-  def _reduce_315(val, _values, result); end
-  def _reduce_316(val, _values, result); end
-  def _reduce_317(val, _values, result); end
-  def _reduce_318(val, _values, result); end
-  def _reduce_319(val, _values, result); end
-  def _reduce_32(val, _values, result); end
-  def _reduce_320(val, _values, result); end
-  def _reduce_321(val, _values, result); end
-  def _reduce_322(val, _values, result); end
-  def _reduce_323(val, _values, result); end
-  def _reduce_324(val, _values, result); end
-  def _reduce_325(val, _values, result); end
-  def _reduce_326(val, _values, result); end
-  def _reduce_327(val, _values, result); end
-  def _reduce_328(val, _values, result); end
-  def _reduce_329(val, _values, result); end
-  def _reduce_33(val, _values, result); end
-  def _reduce_330(val, _values, result); end
-  def _reduce_331(val, _values, result); end
-  def _reduce_332(val, _values, result); end
-  def _reduce_333(val, _values, result); end
-  def _reduce_334(val, _values, result); end
-  def _reduce_335(val, _values, result); end
-  def _reduce_337(val, _values, result); end
-  def _reduce_338(val, _values, result); end
-  def _reduce_339(val, _values, result); end
-  def _reduce_340(val, _values, result); end
-  def _reduce_343(val, _values, result); end
-  def _reduce_347(val, _values, result); end
-  def _reduce_349(val, _values, result); end
-  def _reduce_35(val, _values, result); end
-  def _reduce_352(val, _values, result); end
-  def _reduce_353(val, _values, result); end
-  def _reduce_354(val, _values, result); end
-  def _reduce_355(val, _values, result); end
-  def _reduce_357(val, _values, result); end
-  def _reduce_358(val, _values, result); end
-  def _reduce_359(val, _values, result); end
-  def _reduce_36(val, _values, result); end
-  def _reduce_360(val, _values, result); end
-  def _reduce_361(val, _values, result); end
-  def _reduce_362(val, _values, result); end
-  def _reduce_363(val, _values, result); end
-  def _reduce_364(val, _values, result); end
-  def _reduce_365(val, _values, result); end
-  def _reduce_366(val, _values, result); end
-  def _reduce_367(val, _values, result); end
-  def _reduce_368(val, _values, result); end
-  def _reduce_369(val, _values, result); end
-  def _reduce_37(val, _values, result); end
-  def _reduce_370(val, _values, result); end
-  def _reduce_371(val, _values, result); end
-  def _reduce_372(val, _values, result); end
-  def _reduce_373(val, _values, result); end
-  def _reduce_374(val, _values, result); end
-  def _reduce_375(val, _values, result); end
-  def _reduce_377(val, _values, result); end
-  def _reduce_378(val, _values, result); end
-  def _reduce_379(val, _values, result); end
-  def _reduce_38(val, _values, result); end
-  def _reduce_380(val, _values, result); end
-  def _reduce_381(val, _values, result); end
-  def _reduce_382(val, _values, result); end
-  def _reduce_383(val, _values, result); end
-  def _reduce_384(val, _values, result); end
-  def _reduce_386(val, _values, result); end
-  def _reduce_387(val, _values, result); end
-  def _reduce_388(val, _values, result); end
-  def _reduce_389(val, _values, result); end
-  def _reduce_39(val, _values, result); end
-  def _reduce_390(val, _values, result); end
-  def _reduce_391(val, _values, result); end
-  def _reduce_392(val, _values, result); end
-  def _reduce_393(val, _values, result); end
-  def _reduce_394(val, _values, result); end
-  def _reduce_395(val, _values, result); end
-  def _reduce_397(val, _values, result); end
-  def _reduce_398(val, _values, result); end
-  def _reduce_399(val, _values, result); end
-  def _reduce_4(val, _values, result); end
-  def _reduce_40(val, _values, result); end
-  def _reduce_400(val, _values, result); end
-  def _reduce_401(val, _values, result); end
-  def _reduce_402(val, _values, result); end
-  def _reduce_403(val, _values, result); end
-  def _reduce_404(val, _values, result); end
-  def _reduce_405(val, _values, result); end
-  def _reduce_406(val, _values, result); end
-  def _reduce_407(val, _values, result); end
-  def _reduce_408(val, _values, result); end
-  def _reduce_409(val, _values, result); end
-  def _reduce_41(val, _values, result); end
-  def _reduce_410(val, _values, result); end
-  def _reduce_411(val, _values, result); end
-  def _reduce_412(val, _values, result); end
-  def _reduce_413(val, _values, result); end
-  def _reduce_414(val, _values, result); end
-  def _reduce_415(val, _values, result); end
-  def _reduce_416(val, _values, result); end
-  def _reduce_417(val, _values, result); end
-  def _reduce_418(val, _values, result); end
-  def _reduce_419(val, _values, result); end
-  def _reduce_42(val, _values, result); end
-  def _reduce_420(val, _values, result); end
-  def _reduce_421(val, _values, result); end
-  def _reduce_422(val, _values, result); end
-  def _reduce_423(val, _values, result); end
-  def _reduce_424(val, _values, result); end
-  def _reduce_425(val, _values, result); end
-  def _reduce_426(val, _values, result); end
-  def _reduce_427(val, _values, result); end
-  def _reduce_428(val, _values, result); end
-  def _reduce_429(val, _values, result); end
-  def _reduce_430(val, _values, result); end
-  def _reduce_431(val, _values, result); end
-  def _reduce_433(val, _values, result); end
-  def _reduce_434(val, _values, result); end
-  def _reduce_435(val, _values, result); end
-  def _reduce_438(val, _values, result); end
-  def _reduce_44(val, _values, result); end
-  def _reduce_440(val, _values, result); end
-  def _reduce_445(val, _values, result); end
-  def _reduce_446(val, _values, result); end
-  def _reduce_447(val, _values, result); end
-  def _reduce_448(val, _values, result); end
-  def _reduce_449(val, _values, result); end
-  def _reduce_450(val, _values, result); end
-  def _reduce_451(val, _values, result); end
-  def _reduce_452(val, _values, result); end
-  def _reduce_453(val, _values, result); end
-  def _reduce_454(val, _values, result); end
-  def _reduce_455(val, _values, result); end
-  def _reduce_456(val, _values, result); end
-  def _reduce_457(val, _values, result); end
-  def _reduce_458(val, _values, result); end
-  def _reduce_459(val, _values, result); end
-  def _reduce_460(val, _values, result); end
-  def _reduce_461(val, _values, result); end
-  def _reduce_462(val, _values, result); end
-  def _reduce_463(val, _values, result); end
-  def _reduce_464(val, _values, result); end
-  def _reduce_465(val, _values, result); end
-  def _reduce_466(val, _values, result); end
-  def _reduce_467(val, _values, result); end
-  def _reduce_468(val, _values, result); end
-  def _reduce_469(val, _values, result); end
-  def _reduce_47(val, _values, result); end
-  def _reduce_470(val, _values, result); end
-  def _reduce_471(val, _values, result); end
-  def _reduce_472(val, _values, result); end
-  def _reduce_473(val, _values, result); end
-  def _reduce_474(val, _values, result); end
-  def _reduce_475(val, _values, result); end
-  def _reduce_476(val, _values, result); end
-  def _reduce_477(val, _values, result); end
-  def _reduce_478(val, _values, result); end
-  def _reduce_479(val, _values, result); end
-  def _reduce_48(val, _values, result); end
-  def _reduce_481(val, _values, result); end
-  def _reduce_482(val, _values, result); end
-  def _reduce_483(val, _values, result); end
-  def _reduce_484(val, _values, result); end
-  def _reduce_485(val, _values, result); end
-  def _reduce_486(val, _values, result); end
-  def _reduce_487(val, _values, result); end
-  def _reduce_488(val, _values, result); end
-  def _reduce_489(val, _values, result); end
-  def _reduce_49(val, _values, result); end
-  def _reduce_490(val, _values, result); end
-  def _reduce_491(val, _values, result); end
-  def _reduce_492(val, _values, result); end
-  def _reduce_493(val, _values, result); end
-  def _reduce_494(val, _values, result); end
-  def _reduce_495(val, _values, result); end
-  def _reduce_496(val, _values, result); end
-  def _reduce_497(val, _values, result); end
-  def _reduce_498(val, _values, result); end
-  def _reduce_499(val, _values, result); end
-  def _reduce_5(val, _values, result); end
-  def _reduce_50(val, _values, result); end
-  def _reduce_500(val, _values, result); end
-  def _reduce_501(val, _values, result); end
-  def _reduce_502(val, _values, result); end
-  def _reduce_503(val, _values, result); end
-  def _reduce_504(val, _values, result); end
-  def _reduce_505(val, _values, result); end
-  def _reduce_506(val, _values, result); end
-  def _reduce_507(val, _values, result); end
-  def _reduce_508(val, _values, result); end
-  def _reduce_509(val, _values, result); end
-  def _reduce_510(val, _values, result); end
-  def _reduce_511(val, _values, result); end
-  def _reduce_512(val, _values, result); end
-  def _reduce_513(val, _values, result); end
-  def _reduce_514(val, _values, result); end
-  def _reduce_515(val, _values, result); end
-  def _reduce_516(val, _values, result); end
-  def _reduce_517(val, _values, result); end
-  def _reduce_518(val, _values, result); end
-  def _reduce_519(val, _values, result); end
-  def _reduce_520(val, _values, result); end
-  def _reduce_521(val, _values, result); end
-  def _reduce_522(val, _values, result); end
-  def _reduce_523(val, _values, result); end
-  def _reduce_524(val, _values, result); end
-  def _reduce_525(val, _values, result); end
-  def _reduce_526(val, _values, result); end
-  def _reduce_527(val, _values, result); end
-  def _reduce_528(val, _values, result); end
-  def _reduce_529(val, _values, result); end
-  def _reduce_53(val, _values, result); end
-  def _reduce_530(val, _values, result); end
-  def _reduce_531(val, _values, result); end
-  def _reduce_532(val, _values, result); end
-  def _reduce_533(val, _values, result); end
-  def _reduce_534(val, _values, result); end
-  def _reduce_535(val, _values, result); end
-  def _reduce_536(val, _values, result); end
-  def _reduce_537(val, _values, result); end
-  def _reduce_539(val, _values, result); end
-  def _reduce_54(val, _values, result); end
-  def _reduce_540(val, _values, result); end
-  def _reduce_541(val, _values, result); end
-  def _reduce_542(val, _values, result); end
-  def _reduce_543(val, _values, result); end
-  def _reduce_544(val, _values, result); end
-  def _reduce_545(val, _values, result); end
-  def _reduce_546(val, _values, result); end
-  def _reduce_547(val, _values, result); end
-  def _reduce_548(val, _values, result); end
-  def _reduce_549(val, _values, result); end
-  def _reduce_550(val, _values, result); end
-  def _reduce_551(val, _values, result); end
-  def _reduce_552(val, _values, result); end
-  def _reduce_553(val, _values, result); end
-  def _reduce_556(val, _values, result); end
-  def _reduce_557(val, _values, result); end
-  def _reduce_558(val, _values, result); end
-  def _reduce_559(val, _values, result); end
-  def _reduce_560(val, _values, result); end
-  def _reduce_561(val, _values, result); end
-  def _reduce_562(val, _values, result); end
-  def _reduce_563(val, _values, result); end
-  def _reduce_566(val, _values, result); end
-  def _reduce_567(val, _values, result); end
-  def _reduce_570(val, _values, result); end
-  def _reduce_571(val, _values, result); end
-  def _reduce_572(val, _values, result); end
-  def _reduce_574(val, _values, result); end
-  def _reduce_575(val, _values, result); end
-  def _reduce_577(val, _values, result); end
-  def _reduce_578(val, _values, result); end
-  def _reduce_579(val, _values, result); end
-  def _reduce_58(val, _values, result); end
-  def _reduce_580(val, _values, result); end
-  def _reduce_581(val, _values, result); end
-  def _reduce_582(val, _values, result); end
-  def _reduce_59(val, _values, result); end
-  def _reduce_595(val, _values, result); end
-  def _reduce_596(val, _values, result); end
-  def _reduce_6(val, _values, result); end
-  def _reduce_60(val, _values, result); end
-  def _reduce_601(val, _values, result); end
-  def _reduce_602(val, _values, result); end
-  def _reduce_606(val, _values, result); end
-  def _reduce_610(val, _values, result); end
-  def _reduce_62(val, _values, result); end
-  def _reduce_63(val, _values, result); end
-  def _reduce_64(val, _values, result); end
-  def _reduce_65(val, _values, result); end
-  def _reduce_66(val, _values, result); end
-  def _reduce_67(val, _values, result); end
-  def _reduce_68(val, _values, result); end
-  def _reduce_69(val, _values, result); end
-  def _reduce_70(val, _values, result); end
-  def _reduce_71(val, _values, result); end
-  def _reduce_72(val, _values, result); end
-  def _reduce_73(val, _values, result); end
-  def _reduce_74(val, _values, result); end
-  def _reduce_75(val, _values, result); end
-  def _reduce_76(val, _values, result); end
-  def _reduce_78(val, _values, result); end
-  def _reduce_79(val, _values, result); end
-  def _reduce_8(val, _values, result); end
-  def _reduce_80(val, _values, result); end
-  def _reduce_81(val, _values, result); end
-  def _reduce_82(val, _values, result); end
-  def _reduce_83(val, _values, result); end
-  def _reduce_84(val, _values, result); end
-  def _reduce_85(val, _values, result); end
-  def _reduce_86(val, _values, result); end
-  def _reduce_88(val, _values, result); end
-  def _reduce_89(val, _values, result); end
-  def _reduce_9(val, _values, result); end
-  def _reduce_90(val, _values, result); end
-  def _reduce_91(val, _values, result); end
-  def _reduce_92(val, _values, result); end
-  def _reduce_93(val, _values, result); end
-  def _reduce_94(val, _values, result); end
-  def _reduce_95(val, _values, result); end
-  def _reduce_96(val, _values, result); end
-  def _reduce_97(val, _values, result); end
-  def _reduce_98(val, _values, result); end
-  def _reduce_99(val, _values, result); end
-  def _reduce_none(val, _values, result); end
-  def default_encoding; end
-  def local_pop; end
-  def local_push; end
-  def version; end
-end
-
-Parser::Ruby26::Racc_arg = T.let(T.unsafe(nil), Array)
-Parser::Ruby26::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
-module Parser::Source; end
-
-class Parser::Source::Buffer
-  def initialize(name, first_line = T.unsafe(nil), source: T.unsafe(nil)); end
-
-  def column_for_position(position); end
-  def decompose_position(position); end
-  def first_line; end
-  def freeze; end
-  def inspect; end
-  def last_line; end
-  def line_for_position(position); end
-  def line_range(lineno); end
-  def name; end
-  def raw_source=(input); end
-  def read; end
-  def slice(range); end
-  def source; end
-  def source=(input); end
-  def source_line(lineno); end
-  def source_lines; end
-  def source_range; end
-
-  private
-
-  def bsearch(line_begins, position); end
-  def line_begins; end
-  def line_index_for_position(position); end
-
-  class << self
-    def recognize_encoding(string); end
-    def reencode_string(input); end
-  end
-end
-
-Parser::Source::Buffer::ENCODING_RE = T.let(T.unsafe(nil), Regexp)
-
-class Parser::Source::Comment
-  def initialize(range); end
-
-  def ==(other); end
-  def document?; end
-  def inline?; end
-  def inspect; end
-  def loc; end
-  def location; end
-  def text; end
-  def type; end
-
-  class << self
-    def associate(ast, comments); end
-    def associate_by_identity(ast, comments); end
-    def associate_locations(ast, comments); end
-  end
-end
-
-class Parser::Source::Comment::Associator
-  def initialize(ast, comments); end
-
-  def associate; end
-  def associate_by_identity; end
-  def associate_locations; end
-  def skip_directives; end
-  def skip_directives=(_arg0); end
-
-  private
-
-  def advance_comment; end
-  def advance_through_directives; end
-  def associate_and_advance_comment(node); end
-  def children_in_source_order(node); end
-  def current_comment_before?(node); end
-  def current_comment_before_end?(node); end
-  def current_comment_decorates?(node); end
-  def do_associate; end
-  def process_leading_comments(node); end
-  def process_trailing_comments(node); end
-  def visit(node); end
-end
-
-Parser::Source::Comment::Associator::MAGIC_COMMENT_RE = T.let(T.unsafe(nil), Regexp)
-Parser::Source::Comment::Associator::POSTFIX_TYPES = T.let(T.unsafe(nil), Set)
-
-class Parser::Source::Map
-  def initialize(expression); end
-
-  def ==(other); end
-  def column; end
-  def expression; end
-  def first_line; end
-  def last_column; end
-  def last_line; end
-  def line; end
-  def node; end
-  def node=(node); end
-  def to_hash; end
-  def with_expression(expression_l); end
-
-  protected
-
-  def update_expression(expression_l); end
-  def with(&block); end
-
-  private
-
-  def initialize_copy(other); end
-end
-
-class Parser::Source::Map::Collection < ::Parser::Source::Map
-  def initialize(begin_l, end_l, expression_l); end
-
-  def begin; end
-  def end; end
-end
-
-class Parser::Source::Map::Condition < ::Parser::Source::Map
-  def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end
-
-  def begin; end
-  def else; end
-  def end; end
-  def keyword; end
-end
-
-class Parser::Source::Map::Constant < ::Parser::Source::Map
-  def initialize(double_colon, name, expression); end
-
-  def double_colon; end
-  def name; end
-  def operator; end
-  def with_operator(operator_l); end
-
-  protected
-
-  def update_operator(operator_l); end
-end
-
-class Parser::Source::Map::Definition < ::Parser::Source::Map
-  def initialize(keyword_l, operator_l, name_l, end_l); end
-
-  def end; end
-  def keyword; end
-  def name; end
-  def operator; end
-end
-
-class Parser::Source::Map::For < ::Parser::Source::Map
-  def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end
-
-  def begin; end
-  def end; end
-  def in; end
-  def keyword; end
-end
-
-class Parser::Source::Map::Heredoc < ::Parser::Source::Map
-  def initialize(begin_l, body_l, end_l); end
-
-  def heredoc_body; end
-  def heredoc_end; end
-end
-
-class Parser::Source::Map::Index < ::Parser::Source::Map
-  def initialize(begin_l, end_l, expression_l); end
-
-  def begin; end
-  def end; end
-  def operator; end
-  def with_operator(operator_l); end
-
-  protected
-
-  def update_operator(operator_l); end
-end
-
-class Parser::Source::Map::Keyword < ::Parser::Source::Map
-  def initialize(keyword_l, begin_l, end_l, expression_l); end
-
-  def begin; end
-  def end; end
-  def keyword; end
-end
-
-class Parser::Source::Map::MethodDefinition < ::Parser::Source::Map
-  def initialize(keyword_l, operator_l, name_l, end_l, assignment_l, body_l); end
-
-  def assignment; end
-  def end; end
-  def keyword; end
-  def name; end
-  def operator; end
-end
-
-class Parser::Source::Map::ObjcKwarg < ::Parser::Source::Map
-  def initialize(keyword_l, operator_l, argument_l, expression_l); end
-
-  def argument; end
-  def keyword; end
-  def operator; end
-end
-
-class Parser::Source::Map::Operator < ::Parser::Source::Map
-  def initialize(operator, expression); end
-
-  def operator; end
-end
-
-class Parser::Source::Map::RescueBody < ::Parser::Source::Map
-  def initialize(keyword_l, assoc_l, begin_l, expression_l); end
-
-  def assoc; end
-  def begin; end
-  def keyword; end
-end
-
-class Parser::Source::Map::Send < ::Parser::Source::Map
-  def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end
-
-  def begin; end
-  def dot; end
-  def end; end
-  def operator; end
-  def selector; end
-  def with_operator(operator_l); end
-
-  protected
-
-  def update_operator(operator_l); end
-end
-
-class Parser::Source::Map::Ternary < ::Parser::Source::Map
-  def initialize(question_l, colon_l, expression_l); end
-
-  def colon; end
-  def question; end
-end
-
-class Parser::Source::Map::Variable < ::Parser::Source::Map
-  def initialize(name_l, expression_l = T.unsafe(nil)); end
-
-  def name; end
-  def operator; end
-  def with_operator(operator_l); end
-
-  protected
-
-  def update_operator(operator_l); end
-end
-
-class Parser::Source::Range
-  include ::Comparable
-  include ::RuboCop::AST::Ext::Range
-
-  def initialize(source_buffer, begin_pos, end_pos); end
-
-  def <=>(other); end
-  def adjust(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
-  def begin; end
-  def begin_pos; end
-  def column; end
-  def column_range; end
-  def contained?(other); end
-  def contains?(other); end
-  def crossing?(other); end
-  def disjoint?(other); end
-  def empty?; end
-  def end; end
-  def end_pos; end
-  def eql?(_arg0); end
-  def first_line; end
-  def hash; end
-  def inspect; end
-  def intersect(other); end
-  def is?(*what); end
-  def join(other); end
-  def last_column; end
-  def last_line; end
-  def length; end
-  def line; end
-  def overlaps?(other); end
-  def resize(new_size); end
-  def size; end
-  def source; end
-  def source_buffer; end
-  def source_line; end
-  def to_a; end
-  def to_range; end
-  def to_s; end
-  def with(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
-end
-
-class Parser::Source::Rewriter
-  extend ::Parser::Deprecation
-
-  def initialize(source_buffer); end
-
-  def diagnostics; end
-  def insert_after(range, content); end
-  def insert_after_multi(range, content); end
-  def insert_before(range, content); end
-  def insert_before_multi(range, content); end
-  def process; end
-  def remove(range); end
-  def replace(range, content); end
-  def source_buffer; end
-  def transaction; end
-  def wrap(range, before, after); end
-
-  private
-
-  def active_clobber; end
-  def active_clobber=(value); end
-  def active_insertions; end
-  def active_insertions=(value); end
-  def active_queue; end
-  def adjacent?(range1, range2); end
-  def adjacent_insertion_mask(range); end
-  def adjacent_insertions?(range); end
-  def adjacent_position_mask(range); end
-  def adjacent_updates?(range); end
-  def append(action); end
-  def can_merge?(action, existing); end
-  def clobbered_insertion?(insertion); end
-  def clobbered_position_mask(range); end
-  def in_transaction?; end
-  def merge_actions(action, existing); end
-  def merge_actions!(action, existing); end
-  def merge_replacements(actions); end
-  def raise_clobber_error(action, existing); end
-  def record_insertion(range); end
-  def record_replace(range); end
-  def replace_actions(old, updated); end
-  def replace_compatible_with_insertion?(replace, insertion); end
-end
-
-class Parser::Source::Rewriter::Action
-  include ::Comparable
-
-  def initialize(range, replacement = T.unsafe(nil), allow_multiple_insertions = T.unsafe(nil), order = T.unsafe(nil)); end
-
-  def <=>(other); end
-  def allow_multiple_insertions; end
-  def allow_multiple_insertions?; end
-  def order; end
-  def range; end
-  def replacement; end
-  def to_s; end
-end
-
-Parser::Source::Rewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
-
-class Parser::Source::TreeRewriter
-  extend ::Parser::Deprecation
-
-  def initialize(source_buffer, crossing_deletions: T.unsafe(nil), different_replacements: T.unsafe(nil), swallowed_insertions: T.unsafe(nil)); end
-
-  def as_nested_actions; end
-  def as_replacements; end
-  def diagnostics; end
-  def empty?; end
-  def import!(foreign_rewriter, offset: T.unsafe(nil)); end
-  def in_transaction?; end
-  def insert_after(range, content); end
-  def insert_after_multi(range, text); end
-  def insert_before(range, content); end
-  def insert_before_multi(range, text); end
-  def inspect; end
-  def merge(with); end
-  def merge!(with); end
-  def process; end
-  def remove(range); end
-  def replace(range, content); end
-  def source_buffer; end
-  def transaction; end
-  def wrap(range, insert_before, insert_after); end
-
-  protected
-
-  def action_root; end
-
-  private
-
-  def action_summary; end
-  def check_policy_validity; end
-  def check_range_validity(range); end
-  def combine(range, attributes); end
-  def enforce_policy(event); end
-  def trigger_policy(event, range: T.unsafe(nil), conflict: T.unsafe(nil), **arguments); end
-end
-
-Parser::Source::TreeRewriter::ACTIONS = T.let(T.unsafe(nil), Array)
-
-class Parser::Source::TreeRewriter::Action
-  def initialize(range, enforcer, insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil), children: T.unsafe(nil)); end
-
-  def combine(action); end
-  def contract; end
-  def empty?; end
-  def insert_after; end
-  def insert_before; end
-  def insertion?; end
-  def moved(source_buffer, offset); end
-  def nested_actions; end
-  def ordered_replacements; end
-  def range; end
-  def replacement; end
-
-  protected
-
-  def analyse_hierarchy(action); end
-  def bsearch_child_index(from = T.unsafe(nil)); end
-  def call_enforcer_for_merge(action); end
-  def check_fusible(action, *fusible); end
-  def children; end
-  def combine_children(more_children); end
-  def do_combine(action); end
-  def fuse_deletions(action, fusible, other_sibblings); end
-  def merge(action); end
-  def place_in_hierarchy(action); end
-  def swallow(children); end
-  def with(range: T.unsafe(nil), enforcer: T.unsafe(nil), children: T.unsafe(nil), insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil)); end
-end
-
-Parser::Source::TreeRewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
-Parser::Source::TreeRewriter::POLICY_TO_LEVEL = T.let(T.unsafe(nil), Hash)
-
-class Parser::StaticEnvironment
-  def initialize; end
-
-  def declare(name); end
-  def declare_anonymous_blockarg; end
-  def declare_forward_args; end
-  def declared?(name); end
-  def declared_anonymous_blockarg?; end
-  def declared_forward_args?; end
-  def empty?; end
-  def extend_dynamic; end
-  def extend_static; end
-  def reset; end
-  def unextend; end
-end
-
-Parser::StaticEnvironment::ANONYMOUS_BLOCKARG = T.let(T.unsafe(nil), Symbol)
-Parser::StaticEnvironment::FORWARD_ARGS = T.let(T.unsafe(nil), Symbol)
-
-class Parser::SyntaxError < ::StandardError
-  def initialize(diagnostic); end
-
-  def diagnostic; end
-end
-
-class Parser::TreeRewriter < ::Parser::AST::Processor
-  def assignment?(node); end
-  def insert_after(range, content); end
-  def insert_before(range, content); end
-  def remove(range); end
-  def replace(range, content); end
-  def rewrite(source_buffer, ast, **policy); end
-  def wrap(range, before, after); end
-end
-
-Parser::VERSION = T.let(T.unsafe(nil), String)
-
-class Parser::VariablesStack
-  def initialize; end
-
-  def declare(name); end
-  def declared?(name); end
-  def empty?; end
-  def pop; end
-  def push; end
-  def reset; end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/parser@3.3.5.1.rbi b/Library/Homebrew/sorbet/rbi/gems/parser@3.3.5.1.rbi
new file mode 100644
index 0000000000000..5c8811c7128cd
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/parser@3.3.5.1.rbi
@@ -0,0 +1,7316 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `parser` gem.
+# Please instead update this file by running `bin/tapioca gem parser`.
+
+
+# @api public
+#
+# source://parser//lib/parser.rb#19
+module Parser
+  class << self
+    private
+
+    # source://parser//lib/parser/current.rb#5
+    def warn_syntax_deviation(feature, version); end
+  end
+end
+
+# @api public
+#
+# source://parser//lib/parser.rb#24
+module Parser::AST; end
+
+# {Parser::AST::Node} contains information about a single AST node and its
+# child nodes. It extends the basic [AST::Node](https://www.rubydoc.info/gems/ast/AST/Node)
+# class provided by gem [ast](https://www.rubydoc.info/gems/ast).
+#
+# @api public
+#
+# source://parser//lib/parser/ast/node.rb#17
+class Parser::AST::Node < ::AST::Node
+  # Assigns various properties to this AST node. Currently only the
+  # location can be set.
+  #
+  # @api public
+  # @option properties
+  # @param properties [Hash]
+  #
+  # source://parser//lib/parser/ast/node.rb#30
+  def assign_properties(properties); end
+
+  # Source map for this Node.
+  #
+  # @api public
+  # @return [Parser::Source::Map]
+  #
+  # source://parser//lib/parser/ast/node.rb#18
+  def loc; end
+
+  # Source map for this Node.
+  #
+  # @api public
+  # @return [Parser::Source::Map]
+  #
+  # source://parser//lib/parser/ast/node.rb#18
+  def location; end
+end
+
+# @api public
+#
+# source://parser//lib/parser/ast/processor.rb#9
+class Parser::AST::Processor
+  include ::AST::Processor::Mixin
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_alias(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_and(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_and_asgn(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#118
+  def on_arg(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_arg_expr(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_args(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#105
+  def on_argument(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_array(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_array_pattern(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_array_pattern_with_tail(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#34
+  def on_back_ref(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_begin(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_block(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_block_pass(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#118
+  def on_blockarg(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_blockarg_expr(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_break(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_case(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_case_match(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#89
+  def on_casgn(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_class(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#81
+  def on_const(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_const_pattern(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#181
+  def on_csend(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#34
+  def on_cvar(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#58
+  def on_cvasgn(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#160
+  def on_def(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_defined?(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#169
+  def on_defs(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_dstr(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_dsym(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_eflipflop(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#288
+  def on_empty_else(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_ensure(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_erange(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_find_pattern(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_for(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#118
+  def on_forward_arg(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_forwarded_kwrestarg(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_forwarded_restarg(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#34
+  def on_gvar(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#58
+  def on_gvasgn(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_hash(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_hash_pattern(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_if(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_if_guard(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_iflipflop(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_in_match(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_in_pattern(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_index(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_indexasgn(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_irange(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#34
+  def on_ivar(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#58
+  def on_ivasgn(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#118
+  def on_kwarg(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_kwargs(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_kwbegin(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#118
+  def on_kwoptarg(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#118
+  def on_kwrestarg(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_kwsplat(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_lambda(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#34
+  def on_lvar(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#58
+  def on_lvasgn(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_masgn(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_match_alt(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_match_as(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_match_current_line(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_match_pattern(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_match_pattern_p(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_match_rest(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#34
+  def on_match_var(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_match_with_lvasgn(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_mlhs(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_module(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_next(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_not(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#34
+  def on_nth_ref(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#198
+  def on_numblock(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#70
+  def on_op_asgn(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#118
+  def on_optarg(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_or(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_or_asgn(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_pair(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_pin(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_postexe(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_preexe(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#132
+  def on_procarg0(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_redo(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_regexp(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_resbody(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_rescue(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#118
+  def on_restarg(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_restarg_expr(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_retry(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_return(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_sclass(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#181
+  def on_send(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#118
+  def on_shadowarg(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_splat(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_super(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_undef(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_unless_guard(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_until(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_until_post(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#29
+  def on_var(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#45
+  def on_vasgn(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_when(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_while(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_while_post(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_xstr(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def on_yield(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#281
+  def process_argument_node(node); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/ast/processor.rb#12
+  def process_regular_node(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#273
+  def process_var_asgn_node(node); end
+
+  # @api public
+  # @private
+  #
+  # source://parser//lib/parser/ast/processor.rb#265
+  def process_variable_node(node); end
+end
+
+# Base class for version-specific parsers.
+#
+# @api public
+#
+# source://parser//lib/parser/base.rb#16
+class Parser::Base < ::Racc::Parser
+  # @api public
+  # @param builder [Parser::Builders::Default] The AST builder to use.
+  # @return [Base] a new instance of Base
+  #
+  # source://parser//lib/parser/base.rb#126
+  def initialize(builder = T.unsafe(nil)); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/base.rb#114
+  def builder; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/base.rb#117
+  def context; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/base.rb#119
+  def current_arg_stack; end
+
+  # @api public
+  # @return [Parser::Diagnostic::Engine]
+  #
+  # source://parser//lib/parser/base.rb#113
+  def diagnostics; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/base.rb#112
+  def lexer; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/base.rb#118
+  def max_numparam_stack; end
+
+  # Parses a source buffer and returns the AST, or `nil` in case of a non fatal error.
+  #
+  # @api public
+  # @param source_buffer [Parser::Source::Buffer] The source buffer to parse.
+  # @return [Parser::AST::Node, nil]
+  #
+  # source://parser//lib/parser/base.rb#186
+  def parse(source_buffer); end
+
+  # Parses a source buffer and returns the AST and the source code comments.
+  #
+  # @api public
+  # @return [Array]
+  # @see #parse
+  # @see Parser::Source::Comment#associate
+  #
+  # source://parser//lib/parser/base.rb#204
+  def parse_with_comments(source_buffer); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/base.rb#121
+  def pattern_hash_keys; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/base.rb#120
+  def pattern_variables; end
+
+  # Resets the state of the parser.
+  #
+  # @api public
+  #
+  # source://parser//lib/parser/base.rb#167
+  def reset; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/base.rb#116
+  def source_buffer; end
+
+  # @api public
+  # @return [Parser::StaticEnvironment]
+  #
+  # source://parser//lib/parser/base.rb#115
+  def static_env; end
+
+  # Parses a source buffer and returns the AST, the source code comments,
+  # and the tokens emitted by the lexer. In case of a fatal error, a {SyntaxError}
+  # is raised, unless `recover` is true. In case of an error
+  # (non-fatal or recovered), `nil` is returned instead of the AST, and
+  # comments as well as tokens are only returned up to the location of
+  # the error.
+  #
+  # Currently, token stream format returned by #tokenize is not documented,
+  # but is considered part of a public API and only changed according
+  # to Semantic Versioning.
+  #
+  # However, note that the exact token composition of various constructs
+  # might vary. For example, a string `"foo"` is represented equally well
+  # by `:tSTRING_BEG " :tSTRING_CONTENT foo :tSTRING_END "` and
+  # `:tSTRING "foo"`; such details must not be relied upon.
+  #
+  # @api public
+  # @param source_buffer [Parser::Source::Buffer]
+  # @param recover [Boolean] If true, recover from syntax errors. False by default.
+  # @return [Array]
+  #
+  # source://parser//lib/parser/base.rb#233
+  def tokenize(source_buffer, recover = T.unsafe(nil)); end
+
+  private
+
+  # @api public
+  #
+  # source://parser//lib/parser/base.rb#257
+  def check_kwarg_name(name_t); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/base.rb#266
+  def diagnostic(level, reason, arguments, location_t, highlights_ts = T.unsafe(nil)); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/base.rb#251
+  def next_token; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/base.rb#282
+  def on_error(error_token_id, error_value, value_stack); end
+
+  class << self
+    # @api public
+    # @return [Parser::Base] parser with the default options set.
+    #
+    # source://parser//lib/parser/base.rb#84
+    def default_parser; end
+
+    # Parses a string of Ruby code and returns the AST. If the source
+    # cannot be parsed, {SyntaxError} is raised and a diagnostic is
+    # printed to `stderr`.
+    #
+    # @api public
+    # @example
+    #   Parser::Base.parse('puts "hello"')
+    # @param string [String] The block of code to parse.
+    # @param file [String] The name of the file the code originated from.
+    # @param line [Numeric] The initial line number.
+    # @return [Parser::AST::Node]
+    #
+    # source://parser//lib/parser/base.rb#30
+    def parse(string, file = T.unsafe(nil), line = T.unsafe(nil)); end
+
+    # Parses Ruby source code by reading it from a file. If the source
+    # cannot be parsed, {SyntaxError} is raised and a diagnostic is
+    # printed to `stderr`.
+    #
+    # @api public
+    # @param filename [String] Path to the file to parse.
+    # @return [Parser::AST::Node]
+    # @see #parse
+    #
+    # source://parser//lib/parser/base.rb#64
+    def parse_file(filename); end
+
+    # Parses Ruby source code by reading it from a file and returns the AST and
+    # comments. If the source cannot be parsed, {SyntaxError} is raised and a
+    # diagnostic is printed to `stderr`.
+    #
+    # @api public
+    # @param filename [String] Path to the file to parse.
+    # @return [Array]
+    # @see #parse
+    #
+    # source://parser//lib/parser/base.rb#77
+    def parse_file_with_comments(filename); end
+
+    # Parses a string of Ruby code and returns the AST and comments. If the
+    # source cannot be parsed, {SyntaxError} is raised and a diagnostic is
+    # printed to `stderr`.
+    #
+    # @api public
+    # @example
+    #   Parser::Base.parse_with_comments('puts "hello"')
+    # @param string [String] The block of code to parse.
+    # @param file [String] The name of the file the code originated from.
+    # @param line [Numeric] The initial line number.
+    # @return [Array]
+    #
+    # source://parser//lib/parser/base.rb#49
+    def parse_with_comments(string, file = T.unsafe(nil), line = T.unsafe(nil)); end
+
+    private
+
+    # @api public
+    #
+    # source://parser//lib/parser/base.rb#97
+    def setup_source_buffer(file, line, string, encoding); end
+  end
+end
+
+# @api public
+#
+# source://parser//lib/parser.rb#78
+module Parser::Builders; end
+
+# source://parser//lib/parser/builders/default.rb#8
+class Parser::Builders::Default
+  # source://parser//lib/parser/builders/default.rb#243
+  def initialize; end
+
+  # source://parser//lib/parser/builders/default.rb#703
+  def __ENCODING__(__ENCODING__t); end
+
+  # source://parser//lib/parser/builders/default.rb#348
+  def __FILE__(__FILE__t); end
+
+  # source://parser//lib/parser/builders/default.rb#312
+  def __LINE__(__LINE__t); end
+
+  # source://parser//lib/parser/builders/default.rb#622
+  def accessible(node); end
+
+  # source://parser//lib/parser/builders/default.rb#878
+  def alias(alias_t, to, from); end
+
+  # source://parser//lib/parser/builders/default.rb#917
+  def arg(name_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1007
+  def arg_expr(expr); end
+
+  # source://parser//lib/parser/builders/default.rb#887
+  def args(begin_t, args, end_t, check_args = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#440
+  def array(begin_t, elements, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1590
+  def array_pattern(lbrack_t, elements, rbrack_t); end
+
+  # source://parser//lib/parser/builders/default.rb#767
+  def assign(lhs, eql_t, rhs); end
+
+  # source://parser//lib/parser/builders/default.rb#712
+  def assignable(node); end
+
+  # source://parser//lib/parser/builders/default.rb#540
+  def associate(begin_t, pairs, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1171
+  def attr_asgn(receiver, dot_t, selector_t); end
+
+  # source://parser//lib/parser/builders/default.rb#612
+  def back_ref(token); end
+
+  # source://parser//lib/parser/builders/default.rb#1435
+  def begin(begin_t, body, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1377
+  def begin_body(compound_stmt, rescue_bodies = T.unsafe(nil), else_t = T.unsafe(nil), else_ = T.unsafe(nil), ensure_t = T.unsafe(nil), ensure_ = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#1453
+  def begin_keyword(begin_t, body, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1205
+  def binary_op(receiver, operator_t, arg); end
+
+  # source://parser//lib/parser/builders/default.rb#1122
+  def block(method_call, begin_t, args, body, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1157
+  def block_pass(amper_t, arg); end
+
+  # source://parser//lib/parser/builders/default.rb#982
+  def blockarg(amper_t, name_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1027
+  def blockarg_expr(amper_t, expr); end
+
+  # source://parser//lib/parser/builders/default.rb#1113
+  def call_lambda(lambda_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1096
+  def call_method(receiver, dot_t, selector_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#1068
+  def call_type_for_dot(dot_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1310
+  def case(case_t, expr, when_bodies, else_t, else_body, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1473
+  def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#343
+  def character(char_t); end
+
+  # source://parser//lib/parser/builders/default.rb#284
+  def complex(complex_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1423
+  def compstmt(statements); end
+
+  # source://parser//lib/parser/builders/default.rb#1286
+  def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1292
+  def condition_mod(if_true, if_false, cond_t, cond); end
+
+  # source://parser//lib/parser/builders/default.rb#686
+  def const(name_t); end
+
+  # source://parser//lib/parser/builders/default.rb#698
+  def const_fetch(scope, t_colon2, name_t); end
+
+  # source://parser//lib/parser/builders/default.rb#691
+  def const_global(t_colon3, name_t); end
+
+  # source://parser//lib/parser/builders/default.rb#763
+  def const_op_assignable(node); end
+
+  # source://parser//lib/parser/builders/default.rb#1620
+  def const_pattern(const, ldelim_t, pattern, rdelim_t); end
+
+  # source://parser//lib/parser/builders/default.rb#607
+  def cvar(token); end
+
+  # source://parser//lib/parser/builders/default.rb#388
+  def dedent_string(node, dedent_level); end
+
+  # source://parser//lib/parser/builders/default.rb#814
+  def def_class(class_t, name, lt_t, superclass, body, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#845
+  def def_endless_method(def_t, name_t, args, assignment_t, body); end
+
+  # source://parser//lib/parser/builders/default.rb#863
+  def def_endless_singleton(def_t, definee, dot_t, name_t, args, assignment_t, body); end
+
+  # source://parser//lib/parser/builders/default.rb#837
+  def def_method(def_t, name_t, args, body, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#827
+  def def_module(module_t, name, body, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#821
+  def def_sclass(class_t, lshft_t, expr, body, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#853
+  def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#237
+  def emit_file_line_as_literals; end
+
+  # source://parser//lib/parser/builders/default.rb#237
+  def emit_file_line_as_literals=(_arg0); end
+
+  # source://parser//lib/parser/builders/default.rb#265
+  def false(false_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1611
+  def find_pattern(lbrack_t, elements, rbrack_t); end
+
+  # source://parser//lib/parser/builders/default.rb#276
+  def float(float_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1331
+  def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#913
+  def forward_arg(dots_t); end
+
+  # source://parser//lib/parser/builders/default.rb#903
+  def forward_only_args(begin_t, dots_t, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1084
+  def forwarded_args(dots_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1092
+  def forwarded_kwrestarg(dstar_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1088
+  def forwarded_restarg(star_t); end
+
+  # source://parser//lib/parser/builders/default.rb#596
+  def gvar(token); end
+
+  # source://parser//lib/parser/builders/default.rb#1584
+  def hash_pattern(lbrace_t, kwargs, rbrace_t); end
+
+  # source://parser//lib/parser/builders/default.rb#586
+  def ident(token); end
+
+  # source://parser//lib/parser/builders/default.rb#1500
+  def if_guard(if_t, if_body); end
+
+  # source://parser//lib/parser/builders/default.rb#1479
+  def in_match(lhs, in_t, rhs); end
+
+  # source://parser//lib/parser/builders/default.rb#1494
+  def in_pattern(in_t, pattern, guard, then_t, body); end
+
+  # source://parser//lib/parser/builders/default.rb#1180
+  def index(receiver, lbrack_t, indexes, rbrack_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1194
+  def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end
+
+  # source://parser//lib/parser/builders/default.rb#272
+  def integer(integer_t); end
+
+  # source://parser//lib/parser/builders/default.rb#591
+  def ivar(token); end
+
+  # source://parser//lib/parser/builders/default.rb#1339
+  def keyword_cmd(type, keyword_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#944
+  def kwarg(name_t); end
+
+  # source://parser//lib/parser/builders/default.rb#970
+  def kwnilarg(dstar_t, nil_t); end
+
+  # source://parser//lib/parser/builders/default.rb#951
+  def kwoptarg(name_t, value); end
+
+  # source://parser//lib/parser/builders/default.rb#958
+  def kwrestarg(dstar_t, name_t = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#535
+  def kwsplat(dstar_t, arg); end
+
+  # source://parser//lib/parser/builders/default.rb#1279
+  def logical_op(type, lhs, op_t, rhs); end
+
+  # source://parser//lib/parser/builders/default.rb#1317
+  def loop(type, keyword_t, cond, do_t, body, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1322
+  def loop_mod(type, body, keyword_t, cond); end
+
+  # source://parser//lib/parser/builders/default.rb#1634
+  def match_alt(left, pipe_t, right); end
+
+  # source://parser//lib/parser/builders/default.rb#1641
+  def match_as(value, assoc_t, as); end
+
+  # source://parser//lib/parser/builders/default.rb#1520
+  def match_hash_var(name_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1534
+  def match_hash_var_from_str(begin_t, strings, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1672
+  def match_label(label_type, label); end
+
+  # source://parser//lib/parser/builders/default.rb#1648
+  def match_nil_pattern(dstar_t, nil_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1227
+  def match_op(receiver, match_t, arg); end
+
+  # source://parser//lib/parser/builders/default.rb#1653
+  def match_pair(label_type, label, value); end
+
+  # source://parser//lib/parser/builders/default.rb#1484
+  def match_pattern(lhs, match_t, rhs); end
+
+  # source://parser//lib/parser/builders/default.rb#1489
+  def match_pattern_p(lhs, match_t, rhs); end
+
+  # source://parser//lib/parser/builders/default.rb#1573
+  def match_rest(star_t, name_t = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#1508
+  def match_var(name_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1616
+  def match_with_trailing_comma(match, comma_t); end
+
+  # source://parser//lib/parser/builders/default.rb#805
+  def multi_assign(lhs, eql_t, rhs); end
+
+  # source://parser//lib/parser/builders/default.rb#800
+  def multi_lhs(begin_t, items, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#255
+  def nil(nil_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1255
+  def not_op(not_t, begin_t = T.unsafe(nil), receiver = T.unsafe(nil), end_t = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#617
+  def nth_ref(token); end
+
+  # source://parser//lib/parser/builders/default.rb#899
+  def numargs(max_numparam); end
+
+  # source://parser//lib/parser/builders/default.rb#1038
+  def objc_kwarg(kwname_t, assoc_t, name_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1052
+  def objc_restarg(star_t, name = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#1162
+  def objc_varargs(pair, rest_of_varargs); end
+
+  # source://parser//lib/parser/builders/default.rb#774
+  def op_assign(lhs, op_t, rhs); end
+
+  # source://parser//lib/parser/builders/default.rb#924
+  def optarg(name_t, eql_t, value); end
+
+  # source://parser//lib/parser/builders/default.rb#488
+  def pair(key, assoc_t, value); end
+
+  # source://parser//lib/parser/builders/default.rb#505
+  def pair_keyword(key_t, value); end
+
+  # source://parser//lib/parser/builders/default.rb#521
+  def pair_label(key_t); end
+
+  # source://parser//lib/parser/builders/default.rb#493
+  def pair_list_18(list); end
+
+  # source://parser//lib/parser/builders/default.rb#513
+  def pair_quoted(begin_t, parts, end_t, value); end
+
+  # source://parser//lib/parser/builders/default.rb#225
+  def parser; end
+
+  # source://parser//lib/parser/builders/default.rb#225
+  def parser=(_arg0); end
+
+  # source://parser//lib/parser/builders/default.rb#1629
+  def pin(pin_t, var); end
+
+  # source://parser//lib/parser/builders/default.rb#1362
+  def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1357
+  def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end
+
+  # source://parser//lib/parser/builders/default.rb#992
+  def procarg0(arg); end
+
+  # source://parser//lib/parser/builders/default.rb#572
+  def range_exclusive(lhs, dot3_t, rhs); end
+
+  # source://parser//lib/parser/builders/default.rb#567
+  def range_inclusive(lhs, dot2_t, rhs); end
+
+  # source://parser//lib/parser/builders/default.rb#280
+  def rational(rational_t); end
+
+  # source://parser//lib/parser/builders/default.rb#426
+  def regexp_compose(begin_t, parts, end_t, options); end
+
+  # source://parser//lib/parser/builders/default.rb#417
+  def regexp_options(regopt_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1369
+  def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end
+
+  # source://parser//lib/parser/builders/default.rb#933
+  def restarg(star_t, name_t = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#1016
+  def restarg_expr(star_t, expr = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#581
+  def self(token); end
+
+  # source://parser//lib/parser/builders/default.rb#975
+  def shadowarg(name_t); end
+
+  # source://parser//lib/parser/builders/default.rb#445
+  def splat(star_t, arg = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#319
+  def string(string_t); end
+
+  # source://parser//lib/parser/builders/default.rb#329
+  def string_compose(begin_t, parts, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#324
+  def string_internal(string_t); end
+
+  # source://parser//lib/parser/builders/default.rb#355
+  def symbol(symbol_t); end
+
+  # source://parser//lib/parser/builders/default.rb#365
+  def symbol_compose(begin_t, parts, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#360
+  def symbol_internal(symbol_t); end
+
+  # source://parser//lib/parser/builders/default.rb#469
+  def symbols_compose(begin_t, parts, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1297
+  def ternary(cond, question_t, if_true, colon_t, if_false); end
+
+  # source://parser//lib/parser/builders/default.rb#260
+  def true(true_t); end
+
+  # source://parser//lib/parser/builders/default.rb#294
+  def unary_num(unary_t, numeric); end
+
+  # source://parser//lib/parser/builders/default.rb#1243
+  def unary_op(op_t, receiver); end
+
+  # source://parser//lib/parser/builders/default.rb#873
+  def undef_method(undef_t, names); end
+
+  # source://parser//lib/parser/builders/default.rb#1504
+  def unless_guard(unless_t, unless_body); end
+
+  # source://parser//lib/parser/builders/default.rb#1304
+  def when(when_t, patterns, then_t, body); end
+
+  # source://parser//lib/parser/builders/default.rb#455
+  def word(parts); end
+
+  # source://parser//lib/parser/builders/default.rb#464
+  def words_compose(begin_t, parts, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#381
+  def xstring_compose(begin_t, parts, end_t); end
+
+  private
+
+  # source://parser//lib/parser/builders/default.rb#1821
+  def arg_name_collides?(this_name, that_name); end
+
+  # source://parser//lib/parser/builders/default.rb#2017
+  def arg_prefix_map(op_t, name_t = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#1991
+  def binary_op_map(left_e, op_t, right_e); end
+
+  # source://parser//lib/parser/builders/default.rb#2119
+  def block_map(receiver_l, begin_t, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1796
+  def check_assignment_to_numparam(name, loc); end
+
+  # source://parser//lib/parser/builders/default.rb#1688
+  def check_condition(cond); end
+
+  # source://parser//lib/parser/builders/default.rb#1767
+  def check_duplicate_arg(this_arg, map = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#1742
+  def check_duplicate_args(args, map = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#1854
+  def check_duplicate_pattern_key(name, loc); end
+
+  # source://parser//lib/parser/builders/default.rb#1844
+  def check_duplicate_pattern_variable(name, loc); end
+
+  # source://parser//lib/parser/builders/default.rb#1836
+  def check_lvar_name(name, loc); end
+
+  # source://parser//lib/parser/builders/default.rb#1811
+  def check_reserved_for_numparam(name, loc); end
+
+  # source://parser//lib/parser/builders/default.rb#2280
+  def collapse_string_parts?(parts); end
+
+  # source://parser//lib/parser/builders/default.rb#1942
+  def collection_map(begin_t, parts, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#2146
+  def condition_map(keyword_t, cond_e, begin_t, body_e, else_t, else_e, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1977
+  def constant_map(scope, colon2_t, name_t); end
+
+  # source://parser//lib/parser/builders/default.rb#2050
+  def definition_map(keyword_t, operator_t, name_t, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1883
+  def delimited_string_map(string_t); end
+
+  # source://parser//lib/parser/builders/default.rb#2302
+  def diagnostic(type, reason, arguments, location, highlights = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#2190
+  def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end
+
+  # source://parser//lib/parser/builders/default.rb#2056
+  def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e); end
+
+  # source://parser//lib/parser/builders/default.rb#1938
+  def expr_map(loc); end
+
+  # source://parser//lib/parser/builders/default.rb#2171
+  def for_map(keyword_t, in_t, begin_t, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#2218
+  def guard_map(keyword_t, guard_body_e); end
+
+  # source://parser//lib/parser/builders/default.rb#2108
+  def index_map(receiver_e, lbrack_t, rbrack_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1874
+  def join_exprs(left_expr, right_expr); end
+
+  # source://parser//lib/parser/builders/default.rb#2124
+  def keyword_map(keyword_t, begin_t, args, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#2141
+  def keyword_mod_map(pre_e, keyword_t, post_e); end
+
+  # source://parser//lib/parser/builders/default.rb#2027
+  def kwarg_map(name_t, value_e = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#2333
+  def kwargs?(node); end
+
+  # source://parser//lib/parser/builders/default.rb#2297
+  def loc(token); end
+
+  # source://parser//lib/parser/builders/default.rb#2040
+  def module_definition_map(keyword_t, name_e, operator_t, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#1866
+  def n(type, children, source_map); end
+
+  # source://parser//lib/parser/builders/default.rb#1870
+  def n0(type, source_map); end
+
+  # source://parser//lib/parser/builders/default.rb#288
+  def numeric(kind, token); end
+
+  # source://parser//lib/parser/builders/default.rb#1908
+  def pair_keyword_map(key_t, value_e); end
+
+  # source://parser//lib/parser/builders/default.rb#1923
+  def pair_quoted_map(begin_t, end_t, value_e); end
+
+  # source://parser//lib/parser/builders/default.rb#1894
+  def prefix_string_map(symbol); end
+
+  # source://parser//lib/parser/builders/default.rb#2005
+  def range_map(start_e, op_t, end_e); end
+
+  # source://parser//lib/parser/builders/default.rb#1972
+  def regexp_map(begin_t, end_t, options_e); end
+
+  # source://parser//lib/parser/builders/default.rb#2177
+  def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end
+
+  # source://parser//lib/parser/builders/default.rb#2323
+  def rewrite_hash_args_to_kwargs(args); end
+
+  # source://parser//lib/parser/builders/default.rb#2090
+  def send_binary_op_map(lhs_e, selector_t, rhs_e); end
+
+  # source://parser//lib/parser/builders/default.rb#2113
+  def send_index_map(receiver_e, lbrack_t, rbrack_t); end
+
+  # source://parser//lib/parser/builders/default.rb#2064
+  def send_map(receiver_e, dot_t, selector_t, begin_t = T.unsafe(nil), args = T.unsafe(nil), end_t = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#2096
+  def send_unary_op_map(selector_t, arg_e); end
+
+  # source://parser//lib/parser/builders/default.rb#2249
+  def static_regexp(parts, options); end
+
+  # source://parser//lib/parser/builders/default.rb#2269
+  def static_regexp_node(node); end
+
+  # source://parser//lib/parser/builders/default.rb#2232
+  def static_string(nodes); end
+
+  # source://parser//lib/parser/builders/default.rb#1958
+  def string_map(begin_t, parts, end_t); end
+
+  # source://parser//lib/parser/builders/default.rb#2289
+  def string_value(token); end
+
+  # source://parser//lib/parser/builders/default.rb#2166
+  def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end
+
+  # source://parser//lib/parser/builders/default.rb#1879
+  def token_map(token); end
+
+  # source://parser//lib/parser/builders/default.rb#1995
+  def unary_op_map(op_t, arg_e = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/builders/default.rb#1903
+  def unquoted_map(token); end
+
+  # source://parser//lib/parser/builders/default.rb#2311
+  def validate_definee(definee); end
+
+  # source://parser//lib/parser/builders/default.rb#1781
+  def validate_no_forward_arg_after_restarg(args); end
+
+  # source://parser//lib/parser/builders/default.rb#2285
+  def value(token); end
+
+  # source://parser//lib/parser/builders/default.rb#2084
+  def var_send_map(variable_e); end
+
+  # source://parser//lib/parser/builders/default.rb#1987
+  def variable_map(name_t); end
+
+  class << self
+    # source://parser//lib/parser/builders/default.rb#97
+    def emit_arg_inside_procarg0; end
+
+    # source://parser//lib/parser/builders/default.rb#97
+    def emit_arg_inside_procarg0=(_arg0); end
+
+    # source://parser//lib/parser/builders/default.rb#58
+    def emit_encoding; end
+
+    # source://parser//lib/parser/builders/default.rb#58
+    def emit_encoding=(_arg0); end
+
+    # source://parser//lib/parser/builders/default.rb#126
+    def emit_forward_arg; end
+
+    # source://parser//lib/parser/builders/default.rb#126
+    def emit_forward_arg=(_arg0); end
+
+    # source://parser//lib/parser/builders/default.rb#80
+    def emit_index; end
+
+    # source://parser//lib/parser/builders/default.rb#80
+    def emit_index=(_arg0); end
+
+    # source://parser//lib/parser/builders/default.rb#174
+    def emit_kwargs; end
+
+    # source://parser//lib/parser/builders/default.rb#174
+    def emit_kwargs=(_arg0); end
+
+    # source://parser//lib/parser/builders/default.rb#22
+    def emit_lambda; end
+
+    # source://parser//lib/parser/builders/default.rb#22
+    def emit_lambda=(_arg0); end
+
+    # source://parser//lib/parser/builders/default.rb#203
+    def emit_match_pattern; end
+
+    # source://parser//lib/parser/builders/default.rb#203
+    def emit_match_pattern=(_arg0); end
+
+    # source://parser//lib/parser/builders/default.rb#40
+    def emit_procarg0; end
+
+    # source://parser//lib/parser/builders/default.rb#40
+    def emit_procarg0=(_arg0); end
+
+    # source://parser//lib/parser/builders/default.rb#211
+    def modernize; end
+  end
+end
+
+# {Parser::ClobberingError} is raised when {Parser::Source::Rewriter}
+# detects a clobbering rewrite action. This class inherits {RuntimeError}
+# rather than {StandardError} for backward compatibility.
+#
+# @api public
+#
+# source://parser//lib/parser/clobbering_error.rb#11
+class Parser::ClobberingError < ::RuntimeError; end
+
+# Context of parsing that is represented by a stack of scopes.
+#
+# Supported states:
+# + :class - in the class body (class A; end)
+# + :module - in the module body (module M; end)
+# + :sclass - in the singleton class body (class << obj; end)
+# + :def - in the method body (def m; end)
+# + :defs - in the singleton method body (def self.m; end)
+# + :def_open_args - in the arglist of the method definition
+#                    keep in mind that it's set **only** after reducing the first argument,
+#                    if you need to handle the first argument check `lex_state == expr_fname`
+# + :block - in the block body (tap {})
+# + :lambda - in the lambda body (-> {})
+#
+# source://parser//lib/parser/context.rb#18
+class Parser::Context
+  # @return [Context] a new instance of Context
+  #
+  # source://parser//lib/parser/context.rb#29
+  def initialize; end
+
+  # source://parser//lib/parser/context.rb#43
+  def in_argdef; end
+
+  # source://parser//lib/parser/context.rb#43
+  def in_argdef=(_arg0); end
+
+  # source://parser//lib/parser/context.rb#43
+  def in_block; end
+
+  # source://parser//lib/parser/context.rb#43
+  def in_block=(_arg0); end
+
+  # source://parser//lib/parser/context.rb#43
+  def in_class; end
+
+  # source://parser//lib/parser/context.rb#43
+  def in_class=(_arg0); end
+
+  # source://parser//lib/parser/context.rb#43
+  def in_def; end
+
+  # source://parser//lib/parser/context.rb#43
+  def in_def=(_arg0); end
+
+  # source://parser//lib/parser/context.rb#43
+  def in_defined; end
+
+  # source://parser//lib/parser/context.rb#43
+  def in_defined=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/context.rb#45
+  def in_dynamic_block?; end
+
+  # source://parser//lib/parser/context.rb#43
+  def in_kwarg; end
+
+  # source://parser//lib/parser/context.rb#43
+  def in_kwarg=(_arg0); end
+
+  # source://parser//lib/parser/context.rb#43
+  def in_lambda; end
+
+  # source://parser//lib/parser/context.rb#43
+  def in_lambda=(_arg0); end
+
+  # source://parser//lib/parser/context.rb#33
+  def reset; end
+end
+
+# source://parser//lib/parser/context.rb#19
+Parser::Context::FLAGS = T.let(T.unsafe(nil), Array)
+
+# Stack that holds names of current arguments,
+# i.e. while parsing
+#   def m1(a = (def m2(b = def m3(c = 1); end); end)); end
+#                                   ^
+# stack is [:a, :b, :c]
+#
+# Emulates `p->cur_arg` in MRI's parse.y
+#
+# @api private
+#
+# source://parser//lib/parser/current_arg_stack.rb#14
+class Parser::CurrentArgStack
+  # @api private
+  # @return [CurrentArgStack] a new instance of CurrentArgStack
+  #
+  # source://parser//lib/parser/current_arg_stack.rb#17
+  def initialize; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/current_arg_stack.rb#22
+  def empty?; end
+
+  # @api private
+  #
+  # source://parser//lib/parser/current_arg_stack.rb#34
+  def pop; end
+
+  # @api private
+  #
+  # source://parser//lib/parser/current_arg_stack.rb#26
+  def push(value); end
+
+  # @api private
+  #
+  # source://parser//lib/parser/current_arg_stack.rb#38
+  def reset; end
+
+  # @api private
+  #
+  # source://parser//lib/parser/current_arg_stack.rb#30
+  def set(value); end
+
+  # @api private
+  #
+  # source://parser//lib/parser/current_arg_stack.rb#15
+  def stack; end
+
+  # @api private
+  #
+  # source://parser//lib/parser/current_arg_stack.rb#42
+  def top; end
+end
+
+# source://parser//lib/parser/current.rb#120
+Parser::CurrentRuby = Parser::Ruby33
+
+# @api private
+#
+# source://parser//lib/parser/deprecation.rb#7
+module Parser::Deprecation
+  # @api private
+  #
+  # source://parser//lib/parser/deprecation.rb#9
+  def warn_of_deprecation; end
+
+  # @api private
+  #
+  # source://parser//lib/parser/deprecation.rb#8
+  def warned_of_deprecation=(_arg0); end
+end
+
+# @api public
+#
+# source://parser//lib/parser/diagnostic.rb#31
+class Parser::Diagnostic
+  # @api public
+  # @param level [Symbol]
+  # @param reason [Symbol]
+  # @param arguments [Hash]
+  # @param location [Parser::Source::Range]
+  # @param highlights [Array<Parser::Source::Range>]
+  # @return [Diagnostic] a new instance of Diagnostic
+  #
+  # source://parser//lib/parser/diagnostic.rb#49
+  def initialize(level, reason, arguments, location, highlights = T.unsafe(nil)); end
+
+  # @api public
+  # @return [Symbol] extended arguments that describe the error
+  # @see Parser::MESSAGES
+  #
+  # source://parser//lib/parser/diagnostic.rb#39
+  def arguments; end
+
+  # Supplementary error-related source ranges.
+  #
+  # @api public
+  # @return [Array<Parser::Source::Range>]
+  #
+  # source://parser//lib/parser/diagnostic.rb#40
+  def highlights; end
+
+  # @api public
+  # @return [Symbol] diagnostic level
+  # @see LEVELS
+  #
+  # source://parser//lib/parser/diagnostic.rb#39
+  def level; end
+
+  # Main error-related source range.
+  #
+  # @api public
+  # @return [Parser::Source::Range]
+  #
+  # source://parser//lib/parser/diagnostic.rb#40
+  def location; end
+
+  # @api public
+  # @return [String] the rendered message.
+  #
+  # source://parser//lib/parser/diagnostic.rb#69
+  def message; end
+
+  # @api public
+  # @return [Symbol] reason for error
+  # @see Parser::MESSAGES
+  #
+  # source://parser//lib/parser/diagnostic.rb#39
+  def reason; end
+
+  # Renders the diagnostic message as a clang-like diagnostic.
+  #
+  # @api public
+  # @example
+  #   diagnostic.render # =>
+  #   # [
+  #   #   "(fragment:0):1:5: error: unexpected token $end",
+  #   #   "foo +",
+  #   #   "    ^"
+  #   # ]
+  # @return [Array<String>]
+  #
+  # source://parser//lib/parser/diagnostic.rb#86
+  def render; end
+
+  private
+
+  # If necessary, shrink a `Range` so as to include only the first line.
+  #
+  # @api public
+  # @return [Parser::Source::Range]
+  #
+  # source://parser//lib/parser/diagnostic.rb#142
+  def first_line_only(range); end
+
+  # If necessary, shrink a `Range` so as to include only the last line.
+  #
+  # @api public
+  # @return [Parser::Source::Range]
+  #
+  # source://parser//lib/parser/diagnostic.rb#155
+  def last_line_only(range); end
+
+  # Renders one source line in clang diagnostic style, with highlights.
+  #
+  # @api public
+  # @return [Array<String>]
+  #
+  # source://parser//lib/parser/diagnostic.rb#110
+  def render_line(range, ellipsis = T.unsafe(nil), range_end = T.unsafe(nil)); end
+end
+
+# source://parser//lib/parser/diagnostic/engine.rb#36
+class Parser::Diagnostic::Engine
+  # source://parser//lib/parser/diagnostic/engine.rb#45
+  def initialize(consumer = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/diagnostic/engine.rb#39
+  def all_errors_are_fatal; end
+
+  # source://parser//lib/parser/diagnostic/engine.rb#39
+  def all_errors_are_fatal=(_arg0); end
+
+  # source://parser//lib/parser/diagnostic/engine.rb#37
+  def consumer; end
+
+  # source://parser//lib/parser/diagnostic/engine.rb#37
+  def consumer=(_arg0); end
+
+  # source://parser//lib/parser/diagnostic/engine.rb#40
+  def ignore_warnings; end
+
+  # source://parser//lib/parser/diagnostic/engine.rb#40
+  def ignore_warnings=(_arg0); end
+
+  # source://parser//lib/parser/diagnostic/engine.rb#64
+  def process(diagnostic); end
+
+  protected
+
+  # source://parser//lib/parser/diagnostic/engine.rb#86
+  def ignore?(diagnostic); end
+
+  # source://parser//lib/parser/diagnostic/engine.rb#97
+  def raise?(diagnostic); end
+end
+
+# Collection of the available diagnostic levels.
+#
+# @api public
+# @return [Array]
+#
+# source://parser//lib/parser/diagnostic.rb#37
+Parser::Diagnostic::LEVELS = T.let(T.unsafe(nil), Array)
+
+# line 3 "lib/parser/lexer.rl"
+#
+# === BEFORE YOU START ===
+#
+# Read the Ruby Hacking Guide chapter 11, available in English at
+# http://whitequark.org/blog/2013/04/01/ruby-hacking-guide-ch-11-finite-state-lexer/
+#
+# Remember two things about Ragel scanners:
+#
+#   1) Longest match wins.
+#
+#   2) If two matches have the same length, the first
+#      in source code wins.
+#
+# General rules of making Ragel and Bison happy:
+#
+#  * `p` (position) and `@te` contain the index of the character
+#    they're pointing to ("current"), plus one. `@ts` contains the index
+#    of the corresponding character. The code for extracting matched token is:
+#
+#       @source_buffer.slice(@ts...@te)
+#
+#  * If your input is `foooooooobar` and the rule is:
+#
+#       'f' 'o'+
+#
+#    the result will be:
+#
+#       foooooooobar
+#       ^ ts=0   ^ p=te=9
+#
+#  * A Ragel lexer action should not emit more than one token, unless
+#    you know what you are doing.
+#
+#  * All Ragel commands (fnext, fgoto, ...) end with a semicolon.
+#
+#  * If an action emits the token and transitions to another state, use
+#    these Ragel commands:
+#
+#       emit($whatever)
+#       fnext $next_state; fbreak;
+#
+#    If you perform `fgoto` in an action which does not emit a token nor
+#    rewinds the stream pointer, the parser's side-effectful,
+#    context-sensitive lookahead actions will break in a hard to detect
+#    and debug way.
+#
+#  * If an action does not emit a token:
+#
+#       fgoto $next_state;
+#
+#  * If an action features lookbehind, i.e. matches characters with the
+#    intent of passing them to another action:
+#
+#       p = @ts - 1
+#       fgoto $next_state;
+#
+#    or, if the lookbehind consists of a single character:
+#
+#       fhold; fgoto $next_state;
+#
+#  * Ragel merges actions. So, if you have `e_lparen = '(' %act` and
+#    `c_lparen = '('` and a lexer action `e_lparen | c_lparen`, the result
+#    _will_ invoke the action `act`.
+#
+#    e_something stands for "something with **e**mbedded action".
+#
+#  * EOF is explicit and is matched by `c_eof`. If you want to introspect
+#    the state of the lexer, add this rule to the state:
+#
+#       c_eof => do_eof;
+#
+#  * If you proceed past EOF, the lexer will complain:
+#
+#       NoMethodError: undefined method `ord' for nil:NilClass
+#
+# source://parser//lib/parser/lexer-F1.rb#82
+class Parser::Lexer
+  # @return [Lexer] a new instance of Lexer
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8250
+  def initialize(version); end
+
+  # Return next token: [type, value].
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8410
+  def advance; end
+
+  # Returns the value of attribute cmdarg.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8244
+  def cmdarg; end
+
+  # Sets the attribute cmdarg
+  #
+  # @param value the value to set the attribute cmdarg to.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8244
+  def cmdarg=(_arg0); end
+
+  # Returns the value of attribute cmdarg_stack.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8248
+  def cmdarg_stack; end
+
+  # Returns the value of attribute command_start.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8244
+  def command_start; end
+
+  # Sets the attribute command_start
+  #
+  # @param value the value to set the attribute command_start to.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8244
+  def command_start=(_arg0); end
+
+  # Returns the value of attribute comments.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8246
+  def comments; end
+
+  # Sets the attribute comments
+  #
+  # @param value the value to set the attribute comments to.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8246
+  def comments=(_arg0); end
+
+  # Returns the value of attribute cond.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8244
+  def cond; end
+
+  # Sets the attribute cond
+  #
+  # @param value the value to set the attribute cond to.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8244
+  def cond=(_arg0); end
+
+  # Returns the value of attribute cond_stack.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8248
+  def cond_stack; end
+
+  # Returns the value of attribute context.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8244
+  def context; end
+
+  # Sets the attribute context
+  #
+  # @param value the value to set the attribute context to.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8244
+  def context=(_arg0); end
+
+  # source://parser//lib/parser/lexer-F1.rb#8405
+  def dedent_level; end
+
+  # Returns the value of attribute diagnostics.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8240
+  def diagnostics; end
+
+  # Sets the attribute diagnostics
+  #
+  # @param value the value to set the attribute diagnostics to.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8240
+  def diagnostics=(_arg0); end
+
+  # source://parser//lib/parser/lexer-F1.rb#8358
+  def encoding; end
+
+  # Returns the value of attribute force_utf32.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8242
+  def force_utf32; end
+
+  # Sets the attribute force_utf32
+  #
+  # @param value the value to set the attribute force_utf32 to.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8242
+  def force_utf32=(_arg0); end
+
+  # Returns the value of attribute lambda_stack.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8248
+  def lambda_stack; end
+
+  # Returns the value of attribute paren_nest.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8248
+  def paren_nest; end
+
+  # source://parser//lib/parser/lexer-F1.rb#8392
+  def pop_cmdarg; end
+
+  # source://parser//lib/parser/lexer-F1.rb#8401
+  def pop_cond; end
+
+  # source://parser//lib/parser/lexer-F1.rb#8387
+  def push_cmdarg; end
+
+  # source://parser//lib/parser/lexer-F1.rb#8396
+  def push_cond; end
+
+  # source://parser//lib/parser/lexer-F1.rb#8281
+  def reset(reset_state = T.unsafe(nil)); end
+
+  # %
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8238
+  def source_buffer; end
+
+  # source://parser//lib/parser/lexer-F1.rb#8334
+  def source_buffer=(source_buffer); end
+
+  # source://parser//lib/parser/lexer-F1.rb#8379
+  def state; end
+
+  # source://parser//lib/parser/lexer-F1.rb#8383
+  def state=(state); end
+
+  # Returns the value of attribute static_env.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8241
+  def static_env; end
+
+  # Sets the attribute static_env
+  #
+  # @param value the value to set the attribute static_env to.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8241
+  def static_env=(_arg0); end
+
+  # Returns the value of attribute tokens.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8246
+  def tokens; end
+
+  # Sets the attribute tokens
+  #
+  # @param value the value to set the attribute tokens to.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8246
+  def tokens=(_arg0); end
+
+  # Returns the value of attribute version.
+  #
+  # source://parser//lib/parser/lexer-F1.rb#8248
+  def version; end
+
+  protected
+
+  # source://parser//lib/parser/lexer-F1.rb#14692
+  def arg_or_cmdarg(cmd_state); end
+
+  # source://parser//lib/parser/lexer-F1.rb#14754
+  def check_ambiguous_slash(tm); end
+
+  # source://parser//lib/parser/lexer-F1.rb#14716
+  def diagnostic(type, reason, arguments = T.unsafe(nil), location = T.unsafe(nil), highlights = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer-F1.rb#14722
+  def e_lbrace; end
+
+  # source://parser//lib/parser/lexer-F1.rb#14666
+  def emit(type, value = T.unsafe(nil), s = T.unsafe(nil), e = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer-F1.rb#14775
+  def emit_class_var(ts = T.unsafe(nil), te = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer-F1.rb#14803
+  def emit_colon_with_digits(p, tm, diag_msg); end
+
+  # source://parser//lib/parser/lexer-F1.rb#14700
+  def emit_comment(s = T.unsafe(nil), e = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer-F1.rb#14712
+  def emit_comment_from_range(p, pe); end
+
+  # source://parser//lib/parser/lexer-F1.rb#14682
+  def emit_do(do_block = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer-F1.rb#14765
+  def emit_global_var(ts = T.unsafe(nil), te = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer-F1.rb#14783
+  def emit_instance_var(ts = T.unsafe(nil), te = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer-F1.rb#14791
+  def emit_rbrace_rparen_rbrack; end
+
+  # source://parser//lib/parser/lexer-F1.rb#14813
+  def emit_singleton_class; end
+
+  # source://parser//lib/parser/lexer-F1.rb#14676
+  def emit_table(table, s = T.unsafe(nil), e = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer-F1.rb#14731
+  def numeric_literal_int; end
+
+  # source://parser//lib/parser/lexer-F1.rb#14750
+  def on_newline(p); end
+
+  # source://parser//lib/parser/lexer-F1.rb#14662
+  def range(s = T.unsafe(nil), e = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer-F1.rb#14653
+  def stack_pop; end
+
+  # source://parser//lib/parser/lexer-F1.rb#14658
+  def tok(s = T.unsafe(nil), e = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/lexer-F1.rb#14649
+  def version?(*versions); end
+
+  class << self
+    # Returns the value of attribute lex_en_expr_arg.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8186
+    def lex_en_expr_arg; end
+
+    # Sets the attribute lex_en_expr_arg
+    #
+    # @param value the value to set the attribute lex_en_expr_arg to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8186
+    def lex_en_expr_arg=(_arg0); end
+
+    # Returns the value of attribute lex_en_expr_beg.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8202
+    def lex_en_expr_beg; end
+
+    # Sets the attribute lex_en_expr_beg
+    #
+    # @param value the value to set the attribute lex_en_expr_beg to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8202
+    def lex_en_expr_beg=(_arg0); end
+
+    # Returns the value of attribute lex_en_expr_cmdarg.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8190
+    def lex_en_expr_cmdarg; end
+
+    # Sets the attribute lex_en_expr_cmdarg
+    #
+    # @param value the value to set the attribute lex_en_expr_cmdarg to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8190
+    def lex_en_expr_cmdarg=(_arg0); end
+
+    # Returns the value of attribute lex_en_expr_dot.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8182
+    def lex_en_expr_dot; end
+
+    # Sets the attribute lex_en_expr_dot
+    #
+    # @param value the value to set the attribute lex_en_expr_dot to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8182
+    def lex_en_expr_dot=(_arg0); end
+
+    # Returns the value of attribute lex_en_expr_end.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8214
+    def lex_en_expr_end; end
+
+    # Sets the attribute lex_en_expr_end
+    #
+    # @param value the value to set the attribute lex_en_expr_end to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8214
+    def lex_en_expr_end=(_arg0); end
+
+    # Returns the value of attribute lex_en_expr_endarg.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8194
+    def lex_en_expr_endarg; end
+
+    # Sets the attribute lex_en_expr_endarg
+    #
+    # @param value the value to set the attribute lex_en_expr_endarg to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8194
+    def lex_en_expr_endarg=(_arg0); end
+
+    # Returns the value of attribute lex_en_expr_endfn.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8178
+    def lex_en_expr_endfn; end
+
+    # Sets the attribute lex_en_expr_endfn
+    #
+    # @param value the value to set the attribute lex_en_expr_endfn to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8178
+    def lex_en_expr_endfn=(_arg0); end
+
+    # Returns the value of attribute lex_en_expr_fname.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8174
+    def lex_en_expr_fname; end
+
+    # Sets the attribute lex_en_expr_fname
+    #
+    # @param value the value to set the attribute lex_en_expr_fname to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8174
+    def lex_en_expr_fname=(_arg0); end
+
+    # Returns the value of attribute lex_en_expr_labelarg.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8206
+    def lex_en_expr_labelarg; end
+
+    # Sets the attribute lex_en_expr_labelarg
+    #
+    # @param value the value to set the attribute lex_en_expr_labelarg to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8206
+    def lex_en_expr_labelarg=(_arg0); end
+
+    # Returns the value of attribute lex_en_expr_mid.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8198
+    def lex_en_expr_mid; end
+
+    # Sets the attribute lex_en_expr_mid
+    #
+    # @param value the value to set the attribute lex_en_expr_mid to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8198
+    def lex_en_expr_mid=(_arg0); end
+
+    # Returns the value of attribute lex_en_expr_value.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8210
+    def lex_en_expr_value; end
+
+    # Sets the attribute lex_en_expr_value
+    #
+    # @param value the value to set the attribute lex_en_expr_value to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8210
+    def lex_en_expr_value=(_arg0); end
+
+    # Returns the value of attribute lex_en_expr_variable.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8170
+    def lex_en_expr_variable; end
+
+    # Sets the attribute lex_en_expr_variable
+    #
+    # @param value the value to set the attribute lex_en_expr_variable to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8170
+    def lex_en_expr_variable=(_arg0); end
+
+    # Returns the value of attribute lex_en_inside_string.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8230
+    def lex_en_inside_string; end
+
+    # Sets the attribute lex_en_inside_string
+    #
+    # @param value the value to set the attribute lex_en_inside_string to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8230
+    def lex_en_inside_string=(_arg0); end
+
+    # Returns the value of attribute lex_en_leading_dot.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8218
+    def lex_en_leading_dot; end
+
+    # Sets the attribute lex_en_leading_dot
+    #
+    # @param value the value to set the attribute lex_en_leading_dot to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8218
+    def lex_en_leading_dot=(_arg0); end
+
+    # Returns the value of attribute lex_en_line_begin.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8226
+    def lex_en_line_begin; end
+
+    # Sets the attribute lex_en_line_begin
+    #
+    # @param value the value to set the attribute lex_en_line_begin to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8226
+    def lex_en_line_begin=(_arg0); end
+
+    # Returns the value of attribute lex_en_line_comment.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8222
+    def lex_en_line_comment; end
+
+    # Sets the attribute lex_en_line_comment
+    #
+    # @param value the value to set the attribute lex_en_line_comment to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8222
+    def lex_en_line_comment=(_arg0); end
+
+    # Returns the value of attribute lex_error.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8165
+    def lex_error; end
+
+    # Sets the attribute lex_error
+    #
+    # @param value the value to set the attribute lex_error to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8165
+    def lex_error=(_arg0); end
+
+    # Returns the value of attribute lex_start.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8161
+    def lex_start; end
+
+    # Sets the attribute lex_start
+    #
+    # @param value the value to set the attribute lex_start to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8161
+    def lex_start=(_arg0); end
+
+    private
+
+    # Returns the value of attribute _lex_eof_trans.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8064
+    def _lex_eof_trans; end
+
+    # Sets the attribute _lex_eof_trans
+    #
+    # @param value the value to set the attribute _lex_eof_trans to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#8064
+    def _lex_eof_trans=(_arg0); end
+
+    # Returns the value of attribute _lex_from_state_actions.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#7967
+    def _lex_from_state_actions; end
+
+    # Sets the attribute _lex_from_state_actions
+    #
+    # @param value the value to set the attribute _lex_from_state_actions to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#7967
+    def _lex_from_state_actions=(_arg0); end
+
+    # Returns the value of attribute _lex_index_offsets.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#461
+    def _lex_index_offsets; end
+
+    # Sets the attribute _lex_index_offsets
+    #
+    # @param value the value to set the attribute _lex_index_offsets to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#461
+    def _lex_index_offsets=(_arg0); end
+
+    # Returns the value of attribute _lex_indicies.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#558
+    def _lex_indicies; end
+
+    # Sets the attribute _lex_indicies
+    #
+    # @param value the value to set the attribute _lex_indicies to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#558
+    def _lex_indicies=(_arg0); end
+
+    # Returns the value of attribute _lex_key_spans.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#364
+    def _lex_key_spans; end
+
+    # Sets the attribute _lex_key_spans
+    #
+    # @param value the value to set the attribute _lex_key_spans to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#364
+    def _lex_key_spans=(_arg0); end
+
+    # Returns the value of attribute _lex_to_state_actions.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#7870
+    def _lex_to_state_actions; end
+
+    # Sets the attribute _lex_to_state_actions
+    #
+    # @param value the value to set the attribute _lex_to_state_actions to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#7870
+    def _lex_to_state_actions=(_arg0); end
+
+    # Returns the value of attribute _lex_trans_actions.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#7722
+    def _lex_trans_actions; end
+
+    # Sets the attribute _lex_trans_actions
+    #
+    # @param value the value to set the attribute _lex_trans_actions to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#7722
+    def _lex_trans_actions=(_arg0); end
+
+    # Returns the value of attribute _lex_trans_keys.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#87
+    def _lex_trans_keys; end
+
+    # Sets the attribute _lex_trans_keys
+    #
+    # @param value the value to set the attribute _lex_trans_keys to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#87
+    def _lex_trans_keys=(_arg0); end
+
+    # Returns the value of attribute _lex_trans_targs.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#7574
+    def _lex_trans_targs; end
+
+    # Sets the attribute _lex_trans_targs
+    #
+    # @param value the value to set the attribute _lex_trans_targs to.
+    #
+    # source://parser//lib/parser/lexer-F1.rb#7574
+    def _lex_trans_targs=(_arg0); end
+  end
+end
+
+# source://parser//lib/parser/lexer/dedenter.rb#5
+class Parser::Lexer::Dedenter
+  # source://parser//lib/parser/lexer/dedenter.rb#9
+  def initialize(dedent_level); end
+
+  # source://parser//lib/parser/lexer/dedenter.rb#36
+  def dedent(string); end
+
+  # source://parser//lib/parser/lexer/dedenter.rb#83
+  def interrupt; end
+end
+
+# source://parser//lib/parser/lexer/dedenter.rb#7
+Parser::Lexer::Dedenter::TAB_WIDTH = T.let(T.unsafe(nil), Integer)
+
+# source://parser//lib/parser/lexer-F1.rb#14860
+Parser::Lexer::ESCAPE_WHITESPACE = T.let(T.unsafe(nil), Hash)
+
+# source://parser//lib/parser/lexer-F1.rb#14846
+Parser::Lexer::KEYWORDS = T.let(T.unsafe(nil), Hash)
+
+# source://parser//lib/parser/lexer-F1.rb#14853
+Parser::Lexer::KEYWORDS_BEGIN = T.let(T.unsafe(nil), Hash)
+
+# source://parser//lib/parser/lexer-F1.rb#8362
+Parser::Lexer::LEX_STATES = T.let(T.unsafe(nil), Hash)
+
+# source://parser//lib/parser/lexer/literal.rb#6
+class Parser::Lexer::Literal
+  # source://parser//lib/parser/lexer/literal.rb#42
+  def initialize(lexer, str_type, delimiter, str_s, heredoc_e = T.unsafe(nil), indent = T.unsafe(nil), dedent_body = T.unsafe(nil), label_allowed = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer/literal.rb#116
+  def backslash_delimited?; end
+
+  # source://parser//lib/parser/lexer/literal.rb#39
+  def dedent_level; end
+
+  # source://parser//lib/parser/lexer/literal.rb#191
+  def end_interp_brace_and_try_closing; end
+
+  # source://parser//lib/parser/lexer/literal.rb#218
+  def extend_content; end
+
+  # source://parser//lib/parser/lexer/literal.rb#222
+  def extend_space(ts, te); end
+
+  # source://parser//lib/parser/lexer/literal.rb#197
+  def extend_string(string, ts, te); end
+
+  # source://parser//lib/parser/lexer/literal.rb#204
+  def flush_string; end
+
+  # source://parser//lib/parser/lexer/literal.rb#104
+  def heredoc?; end
+
+  # source://parser//lib/parser/lexer/literal.rb#39
+  def heredoc_e; end
+
+  # source://parser//lib/parser/lexer/literal.rb#168
+  def infer_indent_level(line); end
+
+  # source://parser//lib/parser/lexer/literal.rb#91
+  def interpolate?; end
+
+  # source://parser//lib/parser/lexer/literal.rb#124
+  def munge_escape?(character); end
+
+  # source://parser//lib/parser/lexer/literal.rb#134
+  def nest_and_try_closing(delimiter, ts, te, lookahead = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer/literal.rb#108
+  def plain_heredoc?; end
+
+  # source://parser//lib/parser/lexer/literal.rb#100
+  def regexp?; end
+
+  # source://parser//lib/parser/lexer/literal.rb#40
+  def saved_herebody_s; end
+
+  # source://parser//lib/parser/lexer/literal.rb#40
+  def saved_herebody_s=(_arg0); end
+
+  # source://parser//lib/parser/lexer/literal.rb#112
+  def squiggly_heredoc?; end
+
+  # source://parser//lib/parser/lexer/literal.rb#187
+  def start_interp_brace; end
+
+  # source://parser//lib/parser/lexer/literal.rb#39
+  def str_s; end
+
+  # source://parser//lib/parser/lexer/literal.rb#232
+  def supports_line_continuation_via_slash?; end
+
+  # source://parser//lib/parser/lexer/literal.rb#120
+  def type; end
+
+  # source://parser//lib/parser/lexer/literal.rb#95
+  def words?; end
+
+  protected
+
+  # source://parser//lib/parser/lexer/literal.rb#263
+  def clear_buffer; end
+
+  # source://parser//lib/parser/lexer/literal.rb#259
+  def coerce_encoding(string); end
+
+  # source://parser//lib/parser/lexer/literal.rb#238
+  def delimiter?(delimiter); end
+
+  # source://parser//lib/parser/lexer/literal.rb#279
+  def emit(token, type, s, e); end
+
+  # source://parser//lib/parser/lexer/literal.rb#274
+  def emit_start_tok; end
+end
+
+# source://parser//lib/parser/lexer/literal.rb#7
+Parser::Lexer::Literal::DELIMITERS = T.let(T.unsafe(nil), Hash)
+
+# source://parser//lib/parser/lexer/literal.rb#8
+Parser::Lexer::Literal::SPACE = T.let(T.unsafe(nil), Integer)
+
+# source://parser//lib/parser/lexer/literal.rb#9
+Parser::Lexer::Literal::TAB = T.let(T.unsafe(nil), Integer)
+
+# source://parser//lib/parser/lexer/literal.rb#11
+Parser::Lexer::Literal::TYPES = T.let(T.unsafe(nil), Hash)
+
+# Mapping of strings to parser tokens.
+#
+# source://parser//lib/parser/lexer-F1.rb#14820
+Parser::Lexer::PUNCTUATION = T.let(T.unsafe(nil), Hash)
+
+# source://parser//lib/parser/lexer-F1.rb#14840
+Parser::Lexer::PUNCTUATION_BEGIN = T.let(T.unsafe(nil), Hash)
+
+# source://parser//lib/parser/lexer/stack_state.rb#5
+class Parser::Lexer::StackState
+  # source://parser//lib/parser/lexer/stack_state.rb#6
+  def initialize(name); end
+
+  # source://parser//lib/parser/lexer/stack_state.rb#34
+  def active?; end
+
+  # source://parser//lib/parser/lexer/stack_state.rb#11
+  def clear; end
+
+  # source://parser//lib/parser/lexer/stack_state.rb#38
+  def empty?; end
+
+  # source://parser//lib/parser/lexer/stack_state.rb#42
+  def inspect; end
+
+  # source://parser//lib/parser/lexer/stack_state.rb#29
+  def lexpop; end
+
+  # source://parser//lib/parser/lexer/stack_state.rb#22
+  def pop; end
+
+  # source://parser//lib/parser/lexer/stack_state.rb#15
+  def push(bit); end
+
+  # source://parser//lib/parser/lexer/stack_state.rb#42
+  def to_s; end
+end
+
+# line 3 "lib/parser/lexer-strings.rl"
+#
+# source://parser//lib/parser/lexer-strings.rb#6
+class Parser::LexerStrings
+  # @return [LexerStrings] a new instance of LexerStrings
+  #
+  # source://parser//lib/parser/lexer-strings.rb#3300
+  def initialize(lexer, version); end
+
+  # source://parser//lib/parser/lexer-strings.rb#3339
+  def advance(p); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5069
+  def close_interp_on_current_literal(p); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5043
+  def continue_lexing(current_literal); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5092
+  def dedent_level; end
+
+  # Returns the value of attribute herebody_s.
+  #
+  # source://parser//lib/parser/lexer-strings.rb#3295
+  def herebody_s; end
+
+  # Sets the attribute herebody_s
+  #
+  # @param value the value to set the attribute herebody_s to.
+  #
+  # source://parser//lib/parser/lexer-strings.rb#3295
+  def herebody_s=(_arg0); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5047
+  def literal; end
+
+  # source://parser//lib/parser/lexer-strings.rb#5015
+  def next_state_for_literal(literal); end
+
+  # This hook is triggered by "main" lexer on every newline character
+  #
+  # source://parser//lib/parser/lexer-strings.rb#5100
+  def on_newline(p); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5051
+  def pop_literal; end
+
+  # === LITERAL STACK ===
+  #
+  # source://parser//lib/parser/lexer-strings.rb#5009
+  def push_literal(*args); end
+
+  # source://parser//lib/parser/lexer-strings.rb#4999
+  def read_character_constant(p); end
+
+  # source://parser//lib/parser/lexer-strings.rb#3314
+  def reset; end
+
+  # Set by "main" lexer
+  #
+  # source://parser//lib/parser/lexer-strings.rb#3298
+  def source_buffer; end
+
+  # Set by "main" lexer
+  #
+  # source://parser//lib/parser/lexer-strings.rb#3298
+  def source_buffer=(_arg0); end
+
+  # Set by "main" lexer
+  #
+  # source://parser//lib/parser/lexer-strings.rb#3298
+  def source_pts; end
+
+  # Set by "main" lexer
+  #
+  # source://parser//lib/parser/lexer-strings.rb#3298
+  def source_pts=(_arg0); end
+
+  protected
+
+  # source://parser//lib/parser/lexer-strings.rb#5397
+  def check_ambiguous_slash(tm); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5408
+  def check_invalid_escapes(p); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5136
+  def cond; end
+
+  # source://parser//lib/parser/lexer-strings.rb#5132
+  def diagnostic(type, reason, arguments = T.unsafe(nil), location = T.unsafe(nil), highlights = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5128
+  def emit(type, value = T.unsafe(nil), s = T.unsafe(nil), e = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5387
+  def emit_character_constant; end
+
+  # source://parser//lib/parser/lexer-strings.rb#5364
+  def emit_interp_var(interp_var_kind); end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/lexer-strings.rb#5140
+  def emit_invalid_escapes?; end
+
+  # source://parser//lib/parser/lexer-strings.rb#5291
+  def encode_escape(ord); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5375
+  def encode_escaped_char(p); end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/lexer-strings.rb#5112
+  def eof_codepoint?(point); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5210
+  def extend_interp_code(current_literal); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5225
+  def extend_interp_digit_var; end
+
+  # source://parser//lib/parser/lexer-strings.rb#5355
+  def extend_interp_var(current_literal); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5234
+  def extend_string_eol_check_eof(current_literal, pe); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5251
+  def extend_string_eol_heredoc_intertwined(p); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5241
+  def extend_string_eol_heredoc_line; end
+
+  # source://parser//lib/parser/lexer-strings.rb#5267
+  def extend_string_eol_words(current_literal, p); end
+
+  # String escaping
+  #
+  # source://parser//lib/parser/lexer-strings.rb#5154
+  def extend_string_escaped; end
+
+  # source://parser//lib/parser/lexer-strings.rb#5287
+  def extend_string_for_token_range(current_literal, string); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5279
+  def extend_string_slice_end(lookahead); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5124
+  def range(s = T.unsafe(nil), e = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5347
+  def read_post_meta_or_ctrl_char(p); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5379
+  def slash_c_char; end
+
+  # source://parser//lib/parser/lexer-strings.rb#5383
+  def slash_m_char; end
+
+  # source://parser//lib/parser/lexer-strings.rb#5120
+  def tok(s = T.unsafe(nil), e = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5295
+  def unescape_char(p); end
+
+  # source://parser//lib/parser/lexer-strings.rb#5307
+  def unicode_points(p); end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/lexer-strings.rb#5116
+  def version?(*versions); end
+
+  class << self
+    # Returns the value of attribute lex_en_character.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3275
+    def lex_en_character; end
+
+    # Sets the attribute lex_en_character
+    #
+    # @param value the value to set the attribute lex_en_character to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3275
+    def lex_en_character=(_arg0); end
+
+    # Returns the value of attribute lex_en_interp_backslash_delimited.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3255
+    def lex_en_interp_backslash_delimited; end
+
+    # Sets the attribute lex_en_interp_backslash_delimited
+    #
+    # @param value the value to set the attribute lex_en_interp_backslash_delimited to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3255
+    def lex_en_interp_backslash_delimited=(_arg0); end
+
+    # Returns the value of attribute lex_en_interp_backslash_delimited_words.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3263
+    def lex_en_interp_backslash_delimited_words; end
+
+    # Sets the attribute lex_en_interp_backslash_delimited_words
+    #
+    # @param value the value to set the attribute lex_en_interp_backslash_delimited_words to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3263
+    def lex_en_interp_backslash_delimited_words=(_arg0); end
+
+    # Returns the value of attribute lex_en_interp_string.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3243
+    def lex_en_interp_string; end
+
+    # Sets the attribute lex_en_interp_string
+    #
+    # @param value the value to set the attribute lex_en_interp_string to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3243
+    def lex_en_interp_string=(_arg0); end
+
+    # Returns the value of attribute lex_en_interp_words.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3239
+    def lex_en_interp_words; end
+
+    # Sets the attribute lex_en_interp_words
+    #
+    # @param value the value to set the attribute lex_en_interp_words to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3239
+    def lex_en_interp_words=(_arg0); end
+
+    # Returns the value of attribute lex_en_plain_backslash_delimited.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3259
+    def lex_en_plain_backslash_delimited; end
+
+    # Sets the attribute lex_en_plain_backslash_delimited
+    #
+    # @param value the value to set the attribute lex_en_plain_backslash_delimited to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3259
+    def lex_en_plain_backslash_delimited=(_arg0); end
+
+    # Returns the value of attribute lex_en_plain_backslash_delimited_words.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3267
+    def lex_en_plain_backslash_delimited_words; end
+
+    # Sets the attribute lex_en_plain_backslash_delimited_words
+    #
+    # @param value the value to set the attribute lex_en_plain_backslash_delimited_words to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3267
+    def lex_en_plain_backslash_delimited_words=(_arg0); end
+
+    # Returns the value of attribute lex_en_plain_string.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3251
+    def lex_en_plain_string; end
+
+    # Sets the attribute lex_en_plain_string
+    #
+    # @param value the value to set the attribute lex_en_plain_string to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3251
+    def lex_en_plain_string=(_arg0); end
+
+    # Returns the value of attribute lex_en_plain_words.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3247
+    def lex_en_plain_words; end
+
+    # Sets the attribute lex_en_plain_words
+    #
+    # @param value the value to set the attribute lex_en_plain_words to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3247
+    def lex_en_plain_words=(_arg0); end
+
+    # Returns the value of attribute lex_en_regexp_modifiers.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3271
+    def lex_en_regexp_modifiers; end
+
+    # Sets the attribute lex_en_regexp_modifiers
+    #
+    # @param value the value to set the attribute lex_en_regexp_modifiers to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3271
+    def lex_en_regexp_modifiers=(_arg0); end
+
+    # Returns the value of attribute lex_en_unknown.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3279
+    def lex_en_unknown; end
+
+    # Sets the attribute lex_en_unknown
+    #
+    # @param value the value to set the attribute lex_en_unknown to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3279
+    def lex_en_unknown=(_arg0); end
+
+    # Returns the value of attribute lex_error.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3234
+    def lex_error; end
+
+    # Sets the attribute lex_error
+    #
+    # @param value the value to set the attribute lex_error to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3234
+    def lex_error=(_arg0); end
+
+    # Returns the value of attribute lex_start.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3230
+    def lex_start; end
+
+    # Sets the attribute lex_start
+    #
+    # @param value the value to set the attribute lex_start to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3230
+    def lex_start=(_arg0); end
+
+    private
+
+    # Returns the value of attribute _lex_actions.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#11
+    def _lex_actions; end
+
+    # Sets the attribute _lex_actions
+    #
+    # @param value the value to set the attribute _lex_actions to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#11
+    def _lex_actions=(_arg0); end
+
+    # Returns the value of attribute _lex_eof_trans.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3184
+    def _lex_eof_trans; end
+
+    # Sets the attribute _lex_eof_trans
+    #
+    # @param value the value to set the attribute _lex_eof_trans to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3184
+    def _lex_eof_trans=(_arg0); end
+
+    # Returns the value of attribute _lex_from_state_actions.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3138
+    def _lex_from_state_actions; end
+
+    # Sets the attribute _lex_from_state_actions
+    #
+    # @param value the value to set the attribute _lex_from_state_actions to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3138
+    def _lex_from_state_actions=(_arg0); end
+
+    # Returns the value of attribute _lex_index_offsets.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#244
+    def _lex_index_offsets; end
+
+    # Sets the attribute _lex_index_offsets
+    #
+    # @param value the value to set the attribute _lex_index_offsets to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#244
+    def _lex_index_offsets=(_arg0); end
+
+    # Returns the value of attribute _lex_indicies.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#290
+    def _lex_indicies; end
+
+    # Sets the attribute _lex_indicies
+    #
+    # @param value the value to set the attribute _lex_indicies to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#290
+    def _lex_indicies=(_arg0); end
+
+    # Returns the value of attribute _lex_key_spans.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#198
+    def _lex_key_spans; end
+
+    # Sets the attribute _lex_key_spans
+    #
+    # @param value the value to set the attribute _lex_key_spans to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#198
+    def _lex_key_spans=(_arg0); end
+
+    # Returns the value of attribute _lex_to_state_actions.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3092
+    def _lex_to_state_actions; end
+
+    # Sets the attribute _lex_to_state_actions
+    #
+    # @param value the value to set the attribute _lex_to_state_actions to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3092
+    def _lex_to_state_actions=(_arg0); end
+
+    # Returns the value of attribute _lex_trans_actions.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3029
+    def _lex_trans_actions; end
+
+    # Sets the attribute _lex_trans_actions
+    #
+    # @param value the value to set the attribute _lex_trans_actions to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#3029
+    def _lex_trans_actions=(_arg0); end
+
+    # Returns the value of attribute _lex_trans_keys.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#76
+    def _lex_trans_keys; end
+
+    # Sets the attribute _lex_trans_keys
+    #
+    # @param value the value to set the attribute _lex_trans_keys to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#76
+    def _lex_trans_keys=(_arg0); end
+
+    # Returns the value of attribute _lex_trans_targs.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#2966
+    def _lex_trans_targs; end
+
+    # Sets the attribute _lex_trans_targs
+    #
+    # @param value the value to set the attribute _lex_trans_targs to.
+    #
+    # source://parser//lib/parser/lexer-strings.rb#2966
+    def _lex_trans_targs=(_arg0); end
+  end
+end
+
+# %
+#
+# source://parser//lib/parser/lexer-strings.rb#3287
+Parser::LexerStrings::ESCAPES = T.let(T.unsafe(nil), Hash)
+
+# source://parser//lib/parser/lexer-strings.rb#5414
+Parser::LexerStrings::ESCAPE_WHITESPACE = T.let(T.unsafe(nil), Hash)
+
+# source://parser//lib/parser/lexer-strings.rb#3332
+Parser::LexerStrings::LEX_STATES = T.let(T.unsafe(nil), Hash)
+
+# source://parser//lib/parser/lexer-strings.rb#3293
+Parser::LexerStrings::REGEXP_META_CHARACTERS = T.let(T.unsafe(nil), Regexp)
+
+# Diagnostic messages (errors, warnings and notices) that can be generated.
+#
+# @api public
+# @see Diagnostic
+#
+# source://parser//lib/parser/messages.rb#11
+Parser::MESSAGES = T.let(T.unsafe(nil), Hash)
+
+# Holds p->max_numparam from parse.y
+#
+# @api private
+#
+# source://parser//lib/parser/max_numparam_stack.rb#8
+class Parser::MaxNumparamStack
+  # @api private
+  # @return [MaxNumparamStack] a new instance of MaxNumparamStack
+  #
+  # source://parser//lib/parser/max_numparam_stack.rb#13
+  def initialize; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/max_numparam_stack.rb#17
+  def empty?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/max_numparam_stack.rb#29
+  def has_numparams?; end
+
+  # @api private
+  #
+  # source://parser//lib/parser/max_numparam_stack.rb#21
+  def has_ordinary_params!; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/max_numparam_stack.rb#25
+  def has_ordinary_params?; end
+
+  # @api private
+  #
+  # source://parser//lib/parser/max_numparam_stack.rb#45
+  def pop; end
+
+  # @api private
+  #
+  # source://parser//lib/parser/max_numparam_stack.rb#41
+  def push(static:); end
+
+  # @api private
+  #
+  # source://parser//lib/parser/max_numparam_stack.rb#33
+  def register(numparam); end
+
+  # @api private
+  #
+  # source://parser//lib/parser/max_numparam_stack.rb#9
+  def stack; end
+
+  # @api private
+  #
+  # source://parser//lib/parser/max_numparam_stack.rb#37
+  def top; end
+
+  private
+
+  # @api private
+  #
+  # source://parser//lib/parser/max_numparam_stack.rb#51
+  def set(value); end
+end
+
+# @api private
+#
+# source://parser//lib/parser/max_numparam_stack.rb#11
+Parser::MaxNumparamStack::ORDINARY_PARAMS = T.let(T.unsafe(nil), Integer)
+
+# @api private
+#
+# source://parser//lib/parser/messages.rb#112
+module Parser::Messages
+  class << self
+    # Formats the message, returns a raw template if there's nothing to interpolate
+    #
+    # Code like `format("", {})` gives a warning, and so this method tries interpolating
+    # only if `arguments` hash is not empty.
+    #
+    # @api private
+    #
+    # source://parser//lib/parser/messages.rb#119
+    def compile(reason, arguments); end
+  end
+end
+
+# Parser metadata
+#
+# source://parser//lib/parser/meta.rb#5
+module Parser::Meta; end
+
+# All node types that parser can produce. Not all parser versions
+# will be able to produce every possible node.
+#
+# source://parser//lib/parser/meta.rb#9
+Parser::Meta::NODE_TYPES = T.let(T.unsafe(nil), Set)
+
+# {Parser::Rewriter} is deprecated. Use {Parser::TreeRewriter} instead.
+# It has a backwards compatible API and uses {Parser::Source::TreeRewriter}
+# instead of {Parser::Source::Rewriter}.
+# Please check the documentation for {Parser::Source::Rewriter} for details.
+#
+# @api public
+# @deprecated Use {Parser::TreeRewriter}
+#
+# source://parser//lib/parser/rewriter.rb#14
+class Parser::Rewriter < ::Parser::AST::Processor
+  extend ::Parser::Deprecation
+
+  # @api public
+  # @return [Rewriter] a new instance of Rewriter
+  #
+  # source://parser//lib/parser/rewriter.rb#98
+  def initialize(*_arg0); end
+
+  # Returns `true` if the specified node is an assignment node, returns false
+  # otherwise.
+  #
+  # @api public
+  # @param node [Parser::AST::Node]
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/rewriter.rb#38
+  def assignment?(node); end
+
+  # Inserts new code after the given source range.
+  #
+  # @api public
+  # @param range [Parser::Source::Range]
+  # @param content [String]
+  #
+  # source://parser//lib/parser/rewriter.rb#77
+  def insert_after(range, content); end
+
+  # Inserts new code before the given source range.
+  #
+  # @api public
+  # @param range [Parser::Source::Range]
+  # @param content [String]
+  #
+  # source://parser//lib/parser/rewriter.rb#67
+  def insert_before(range, content); end
+
+  # Removes the source range.
+  #
+  # @api public
+  # @param range [Parser::Source::Range]
+  #
+  # source://parser//lib/parser/rewriter.rb#47
+  def remove(range); end
+
+  # Replaces the code of the source range `range` with `content`.
+  #
+  # @api public
+  # @param range [Parser::Source::Range]
+  # @param content [String]
+  #
+  # source://parser//lib/parser/rewriter.rb#87
+  def replace(range, content); end
+
+  # Rewrites the AST/source buffer and returns a String containing the new
+  # version.
+  #
+  # @api public
+  # @param source_buffer [Parser::Source::Buffer]
+  # @param ast [Parser::AST::Node]
+  # @return [String]
+  #
+  # source://parser//lib/parser/rewriter.rb#23
+  def rewrite(source_buffer, ast); end
+
+  # Wraps the given source range with the given values.
+  #
+  # @api public
+  # @param range [Parser::Source::Range]
+  # @param content [String]
+  #
+  # source://parser//lib/parser/rewriter.rb#57
+  def wrap(range, before, after); end
+end
+
+# @api public
+#
+# source://parser//lib/parser/rewriter.rb#91
+Parser::Rewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
+
+# source://parser//lib/parser/ruby33.rb#14
+class Parser::Ruby33 < ::Parser::Base
+  # reduce 0 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#8371
+  def _reduce_1(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8425
+  def _reduce_10(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9024
+  def _reduce_100(val, _values, result); end
+
+  # reduce 101 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#9033
+  def _reduce_102(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9039
+  def _reduce_103(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9045
+  def _reduce_104(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9051
+  def _reduce_105(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9057
+  def _reduce_106(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9063
+  def _reduce_107(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9069
+  def _reduce_108(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9075
+  def _reduce_109(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8431
+  def _reduce_11(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9081
+  def _reduce_110(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9091
+  def _reduce_111(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9097
+  def _reduce_112(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9107
+  def _reduce_113(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9114
+  def _reduce_114(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9121
+  def _reduce_115(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9127
+  def _reduce_116(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9133
+  def _reduce_117(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9139
+  def _reduce_118(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9145
+  def _reduce_119(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8448
+  def _reduce_12(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9151
+  def _reduce_120(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9157
+  def _reduce_121(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9163
+  def _reduce_122(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9170
+  def _reduce_123(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9177
+  def _reduce_124(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9183
+  def _reduce_125(val, _values, result); end
+
+  # reduce 126 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#9191
+  def _reduce_127(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9197
+  def _reduce_128(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9203
+  def _reduce_129(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8454
+  def _reduce_13(val, _values, result); end
+
+  # reduce 134 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#9219
+  def _reduce_135(val, _values, result); end
+
+  # reduce 136 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#9227
+  def _reduce_137(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9233
+  def _reduce_138(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9239
+  def _reduce_139(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8460
+  def _reduce_14(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8466
+  def _reduce_15(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8472
+  def _reduce_16(val, _values, result); end
+
+  # reduce 17 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#8480
+  def _reduce_18(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8486
+  def _reduce_19(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8378
+  def _reduce_2(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8492
+  def _reduce_20(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8498
+  def _reduce_21(val, _values, result); end
+
+  # reduce 210 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#9387
+  def _reduce_211(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9393
+  def _reduce_212(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9399
+  def _reduce_213(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9408
+  def _reduce_214(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9417
+  def _reduce_215(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9426
+  def _reduce_216(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9435
+  def _reduce_217(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9443
+  def _reduce_218(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9451
+  def _reduce_219(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8506
+  def _reduce_22(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9457
+  def _reduce_220(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9463
+  def _reduce_221(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9469
+  def _reduce_222(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9475
+  def _reduce_223(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9481
+  def _reduce_224(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9487
+  def _reduce_225(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9493
+  def _reduce_226(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9499
+  def _reduce_227(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9505
+  def _reduce_228(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9511
+  def _reduce_229(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8514
+  def _reduce_23(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9517
+  def _reduce_230(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9523
+  def _reduce_231(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9529
+  def _reduce_232(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9537
+  def _reduce_233(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9543
+  def _reduce_234(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9549
+  def _reduce_235(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9555
+  def _reduce_236(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9561
+  def _reduce_237(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9567
+  def _reduce_238(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8520
+  def _reduce_24(val, _values, result); end
+
+  # reduce 239 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#9575
+  def _reduce_240(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9581
+  def _reduce_241(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9587
+  def _reduce_242(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9593
+  def _reduce_243(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9599
+  def _reduce_244(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9605
+  def _reduce_245(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9611
+  def _reduce_246(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9617
+  def _reduce_247(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9623
+  def _reduce_248(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9629
+  def _reduce_249(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8526
+  def _reduce_25(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9635
+  def _reduce_250(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9641
+  def _reduce_251(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9648
+  def _reduce_252(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9655
+  def _reduce_253(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9669
+  def _reduce_254(val, _values, result); end
+
+  # reduce 256 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#9687
+  def _reduce_257(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9697
+  def _reduce_258(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8533
+  def _reduce_26(val, _values, result); end
+
+  # reduce 262 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#9711
+  def _reduce_263(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9717
+  def _reduce_264(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9723
+  def _reduce_265(val, _values, result); end
+
+  # reduce 268 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#9735
+  def _reduce_269(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8540
+  def _reduce_27(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9741
+  def _reduce_270(val, _values, result); end
+
+  # reduce 271 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#9749
+  def _reduce_272(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9759
+  def _reduce_273(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9765
+  def _reduce_274(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9775
+  def _reduce_275(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9785
+  def _reduce_276(val, _values, result); end
+
+  # reduce 277 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#9793
+  def _reduce_278(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8546
+  def _reduce_28(val, _values, result); end
+
+  # reduce 280 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#9803
+  def _reduce_281(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9809
+  def _reduce_282(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9815
+  def _reduce_283(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9821
+  def _reduce_284(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9827
+  def _reduce_285(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9834
+  def _reduce_286(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9842
+  def _reduce_287(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9848
+  def _reduce_288(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9875
+  def _reduce_289(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8552
+  def _reduce_29(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9896
+  def _reduce_290(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9902
+  def _reduce_291(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9917
+  def _reduce_292(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9923
+  def _reduce_293(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9929
+  def _reduce_294(val, _values, result); end
+
+  # reduce 295 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#9937
+  def _reduce_296(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9943
+  def _reduce_297(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9949
+  def _reduce_298(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9955
+  def _reduce_299(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8387
+  def _reduce_3(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8562
+  def _reduce_30(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9970
+  def _reduce_300(val, _values, result); end
+
+  # reduce 301 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#9978
+  def _reduce_302(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9984
+  def _reduce_303(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9990
+  def _reduce_304(val, _values, result); end
+
+  # reduce 314 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10016
+  def _reduce_315(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10022
+  def _reduce_316(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10028
+  def _reduce_317(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10036
+  def _reduce_318(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10042
+  def _reduce_319(val, _values, result); end
+
+  # reduce 31 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#8570
+  def _reduce_32(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10048
+  def _reduce_320(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10054
+  def _reduce_321(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10060
+  def _reduce_322(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10066
+  def _reduce_323(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10072
+  def _reduce_324(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10078
+  def _reduce_325(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10084
+  def _reduce_326(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10090
+  def _reduce_327(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10096
+  def _reduce_328(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10102
+  def _reduce_329(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8576
+  def _reduce_33(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10110
+  def _reduce_330(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10116
+  def _reduce_331(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10122
+  def _reduce_332(val, _values, result); end
+
+  # reduce 333 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10134
+  def _reduce_334(val, _values, result); end
+
+  # reduce 335 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10144
+  def _reduce_336(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10153
+  def _reduce_337(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10162
+  def _reduce_338(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10168
+  def _reduce_339(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8583
+  def _reduce_34(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10174
+  def _reduce_340(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10184
+  def _reduce_341(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10194
+  def _reduce_342(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10204
+  def _reduce_343(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10210
+  def _reduce_344(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10217
+  def _reduce_345(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10233
+  def _reduce_346(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10241
+  def _reduce_347(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10253
+  def _reduce_348(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10260
+  def _reduce_349(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8594
+  def _reduce_35(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10274
+  def _reduce_350(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10286
+  def _reduce_351(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10298
+  def _reduce_352(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10304
+  def _reduce_353(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10310
+  def _reduce_354(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10316
+  def _reduce_355(val, _values, result); end
+
+  # reduce 356 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10324
+  def _reduce_357(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10330
+  def _reduce_358(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10336
+  def _reduce_359(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10343
+  def _reduce_360(val, _values, result); end
+
+  # reduce 362 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10355
+  def _reduce_363(val, _values, result); end
+
+  # reduce 366 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10367
+  def _reduce_367(val, _values, result); end
+
+  # reduce 368 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10380
+  def _reduce_369(val, _values, result); end
+
+  # reduce 36 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#8602
+  def _reduce_37(val, _values, result); end
+
+  # reduce 371 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10390
+  def _reduce_372(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10396
+  def _reduce_373(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10402
+  def _reduce_374(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10408
+  def _reduce_375(val, _values, result); end
+
+  # reduce 376 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10416
+  def _reduce_377(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10423
+  def _reduce_378(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10431
+  def _reduce_379(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8608
+  def _reduce_38(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10437
+  def _reduce_380(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10443
+  def _reduce_381(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10449
+  def _reduce_382(val, _values, result); end
+
+  # reduce 384 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10459
+  def _reduce_385(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10465
+  def _reduce_386(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10471
+  def _reduce_387(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10477
+  def _reduce_388(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10483
+  def _reduce_389(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8614
+  def _reduce_39(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10489
+  def _reduce_390(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10495
+  def _reduce_391(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10501
+  def _reduce_392(val, _values, result); end
+
+  # reduce 393 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10509
+  def _reduce_394(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10518
+  def _reduce_395(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10528
+  def _reduce_396(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10536
+  def _reduce_397(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10545
+  def _reduce_398(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8393
+  def _reduce_4(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8623
+  def _reduce_40(val, _values, result); end
+
+  # reduce 399 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10555
+  def _reduce_400(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10564
+  def _reduce_401(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10574
+  def _reduce_402(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10582
+  def _reduce_403(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10591
+  def _reduce_404(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10598
+  def _reduce_405(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10606
+  def _reduce_406(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10613
+  def _reduce_407(val, _values, result); end
+
+  # reduce 408 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10623
+  def _reduce_409(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8632
+  def _reduce_41(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10629
+  def _reduce_410(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10635
+  def _reduce_411(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10644
+  def _reduce_412(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10653
+  def _reduce_413(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10659
+  def _reduce_414(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10665
+  def _reduce_415(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10671
+  def _reduce_416(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10677
+  def _reduce_417(val, _values, result); end
+
+  # reduce 418 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10686
+  def _reduce_419(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8641
+  def _reduce_42(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10695
+  def _reduce_420(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10701
+  def _reduce_421(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10717
+  def _reduce_422(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10725
+  def _reduce_423(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10735
+  def _reduce_424(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10742
+  def _reduce_425(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10749
+  def _reduce_426(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10756
+  def _reduce_427(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10763
+  def _reduce_428(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10770
+  def _reduce_429(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8649
+  def _reduce_43(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10777
+  def _reduce_430(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10785
+  def _reduce_431(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10793
+  def _reduce_432(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10805
+  def _reduce_433(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10816
+  def _reduce_434(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10824
+  def _reduce_435(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10832
+  def _reduce_436(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10840
+  def _reduce_437(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10846
+  def _reduce_438(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10854
+  def _reduce_439(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8658
+  def _reduce_44(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10862
+  def _reduce_440(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10870
+  def _reduce_441(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10876
+  def _reduce_442(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10882
+  def _reduce_443(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10889
+  def _reduce_444(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10896
+  def _reduce_445(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10903
+  def _reduce_446(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10910
+  def _reduce_447(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10917
+  def _reduce_448(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10927
+  def _reduce_449(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8672
+  def _reduce_45(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10934
+  def _reduce_450(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10940
+  def _reduce_451(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10951
+  def _reduce_452(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10958
+  def _reduce_453(val, _values, result); end
+
+  # reduce 454 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#10966
+  def _reduce_455(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10972
+  def _reduce_456(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10978
+  def _reduce_457(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10988
+  def _reduce_458(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#10996
+  def _reduce_459(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8686
+  def _reduce_46(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11003
+  def _reduce_460(val, _values, result); end
+
+  # reduce 461 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11011
+  def _reduce_462(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11017
+  def _reduce_463(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11023
+  def _reduce_464(val, _values, result); end
+
+  # reduce 465 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11031
+  def _reduce_466(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11041
+  def _reduce_467(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11047
+  def _reduce_468(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11053
+  def _reduce_469(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11059
+  def _reduce_470(val, _values, result); end
+
+  # reduce 471 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11067
+  def _reduce_472(val, _values, result); end
+
+  # reduce 473 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11075
+  def _reduce_474(val, _values, result); end
+
+  # reduce 475 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11083
+  def _reduce_476(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11090
+  def _reduce_477(val, _values, result); end
+
+  # reduce 47 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#8694
+  def _reduce_48(val, _values, result); end
+
+  # reduce 479 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11101
+  def _reduce_480(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11109
+  def _reduce_481(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11117
+  def _reduce_482(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11125
+  def _reduce_483(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11132
+  def _reduce_484(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11140
+  def _reduce_485(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11148
+  def _reduce_486(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11156
+  def _reduce_487(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11163
+  def _reduce_488(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11169
+  def _reduce_489(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8704
+  def _reduce_49(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11175
+  def _reduce_490(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11181
+  def _reduce_491(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11189
+  def _reduce_492(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11197
+  def _reduce_493(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11203
+  def _reduce_494(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11209
+  def _reduce_495(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11216
+  def _reduce_496(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11222
+  def _reduce_497(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11228
+  def _reduce_498(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11234
+  def _reduce_499(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8399
+  def _reduce_5(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11240
+  def _reduce_500(val, _values, result); end
+
+  # reduce 501 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11248
+  def _reduce_502(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11258
+  def _reduce_503(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11268
+  def _reduce_504(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11274
+  def _reduce_505(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11280
+  def _reduce_506(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11286
+  def _reduce_507(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11292
+  def _reduce_508(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11298
+  def _reduce_509(val, _values, result); end
+
+  # reduce 50 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#8712
+  def _reduce_51(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11304
+  def _reduce_510(val, _values, result); end
+
+  # reduce 511 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11312
+  def _reduce_512(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11318
+  def _reduce_513(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11324
+  def _reduce_514(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11330
+  def _reduce_515(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11336
+  def _reduce_516(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11342
+  def _reduce_517(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11348
+  def _reduce_518(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11354
+  def _reduce_519(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11360
+  def _reduce_520(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11366
+  def _reduce_521(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11372
+  def _reduce_522(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11378
+  def _reduce_523(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11384
+  def _reduce_524(val, _values, result); end
+
+  # reduce 525 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11392
+  def _reduce_526(val, _values, result); end
+
+  # reduce 527 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11400
+  def _reduce_528(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11406
+  def _reduce_529(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11412
+  def _reduce_530(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11418
+  def _reduce_531(val, _values, result); end
+
+  # reduce 534 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11430
+  def _reduce_535(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11436
+  def _reduce_536(val, _values, result); end
+
+  # reduce 53 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#8726
+  def _reduce_54(val, _values, result); end
+
+  # reduce 544 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11458
+  def _reduce_545(val, _values, result); end
+
+  # reduce 546 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11466
+  def _reduce_547(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11472
+  def _reduce_548(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11484
+  def _reduce_549(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8732
+  def _reduce_55(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11491
+  def _reduce_550(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11498
+  def _reduce_551(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11504
+  def _reduce_552(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11510
+  def _reduce_553(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11516
+  def _reduce_554(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11531
+  def _reduce_555(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11537
+  def _reduce_556(val, _values, result); end
+
+  # reduce 558 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11547
+  def _reduce_559(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8738
+  def _reduce_56(val, _values, result); end
+
+  # reduce 560 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11555
+  def _reduce_561(val, _values, result); end
+
+  # reduce 564 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11567
+  def _reduce_565(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11573
+  def _reduce_566(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11579
+  def _reduce_567(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11585
+  def _reduce_568(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11592
+  def _reduce_569(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8744
+  def _reduce_57(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11599
+  def _reduce_570(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11605
+  def _reduce_571(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11612
+  def _reduce_572(val, _values, result); end
+
+  # reduce 574 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11623
+  def _reduce_575(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11629
+  def _reduce_576(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11635
+  def _reduce_577(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11641
+  def _reduce_578(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11647
+  def _reduce_579(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8750
+  def _reduce_58(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11653
+  def _reduce_580(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11659
+  def _reduce_581(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11665
+  def _reduce_582(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11671
+  def _reduce_583(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11677
+  def _reduce_584(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11683
+  def _reduce_585(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11689
+  def _reduce_586(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11695
+  def _reduce_587(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11701
+  def _reduce_588(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11707
+  def _reduce_589(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8759
+  def _reduce_59(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11713
+  def _reduce_590(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11719
+  def _reduce_591(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11725
+  def _reduce_592(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11731
+  def _reduce_593(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11737
+  def _reduce_594(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11743
+  def _reduce_595(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11749
+  def _reduce_596(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11755
+  def _reduce_597(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11762
+  def _reduce_598(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8405
+  def _reduce_6(val, _values, result); end
+
+  # reduce 599 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11773
+  def _reduce_600(val, _values, result); end
+
+  # reduce 603 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11785
+  def _reduce_604(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11792
+  def _reduce_605(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11799
+  def _reduce_606(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11805
+  def _reduce_607(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11816
+  def _reduce_608(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11823
+  def _reduce_609(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11830
+  def _reduce_610(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11837
+  def _reduce_611(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11844
+  def _reduce_612(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11850
+  def _reduce_613(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11856
+  def _reduce_614(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11862
+  def _reduce_615(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11868
+  def _reduce_616(val, _values, result); end
+
+  # reduce 617 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11876
+  def _reduce_618(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11882
+  def _reduce_619(val, _values, result); end
+
+  # reduce 61 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#8772
+  def _reduce_62(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11888
+  def _reduce_620(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11894
+  def _reduce_621(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11900
+  def _reduce_622(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11906
+  def _reduce_623(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11912
+  def _reduce_624(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11918
+  def _reduce_625(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11924
+  def _reduce_626(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11930
+  def _reduce_627(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11936
+  def _reduce_628(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11942
+  def _reduce_629(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8778
+  def _reduce_63(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11948
+  def _reduce_630(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11954
+  def _reduce_631(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11960
+  def _reduce_632(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11966
+  def _reduce_633(val, _values, result); end
+
+  # reduce 634 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11974
+  def _reduce_635(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#11981
+  def _reduce_636(val, _values, result); end
+
+  # reduce 637 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#11992
+  def _reduce_638(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12000
+  def _reduce_639(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8785
+  def _reduce_64(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12008
+  def _reduce_640(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12014
+  def _reduce_641(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12020
+  def _reduce_642(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12026
+  def _reduce_643(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12032
+  def _reduce_644(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12039
+  def _reduce_645(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12045
+  def _reduce_646(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12051
+  def _reduce_647(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12060
+  def _reduce_648(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12070
+  def _reduce_649(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8795
+  def _reduce_65(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12078
+  def _reduce_650(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12087
+  def _reduce_651(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12095
+  def _reduce_652(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12104
+  def _reduce_653(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12111
+  def _reduce_654(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12119
+  def _reduce_655(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12128
+  def _reduce_656(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12135
+  def _reduce_657(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12143
+  def _reduce_658(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12150
+  def _reduce_659(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8801
+  def _reduce_66(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12158
+  def _reduce_660(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12164
+  def _reduce_661(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12170
+  def _reduce_662(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12176
+  def _reduce_663(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12182
+  def _reduce_664(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12188
+  def _reduce_665(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12194
+  def _reduce_666(val, _values, result); end
+
+  # reduce 667 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#12202
+  def _reduce_668(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12212
+  def _reduce_669(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8808
+  def _reduce_67(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12219
+  def _reduce_670(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12226
+  def _reduce_671(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12232
+  def _reduce_672(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12238
+  def _reduce_673(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12244
+  def _reduce_674(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12259
+  def _reduce_675(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12267
+  def _reduce_676(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12275
+  def _reduce_677(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12282
+  def _reduce_678(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12289
+  def _reduce_679(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12295
+  def _reduce_680(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12301
+  def _reduce_681(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12307
+  def _reduce_682(val, _values, result); end
+
+  # reduce 684 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#12317
+  def _reduce_685(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12323
+  def _reduce_686(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12331
+  def _reduce_687(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12339
+  def _reduce_688(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12347
+  def _reduce_689(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12355
+  def _reduce_690(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12361
+  def _reduce_691(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12367
+  def _reduce_692(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12373
+  def _reduce_693(val, _values, result); end
+
+  # reduce 695 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#12383
+  def _reduce_696(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12391
+  def _reduce_697(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8411
+  def _reduce_7(val, _values, result); end
+
+  # reduce 699 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#12403
+  def _reduce_700(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12411
+  def _reduce_701(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12419
+  def _reduce_702(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12425
+  def _reduce_703(val, _values, result); end
+
+  # reduce 704 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#12433
+  def _reduce_705(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12439
+  def _reduce_706(val, _values, result); end
+
+  # reduce 707 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#12447
+  def _reduce_708(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12453
+  def _reduce_709(val, _values, result); end
+
+  # reduce 70 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#8820
+  def _reduce_71(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12459
+  def _reduce_710(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12465
+  def _reduce_711(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12471
+  def _reduce_712(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12477
+  def _reduce_713(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12483
+  def _reduce_714(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12489
+  def _reduce_715(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8827
+  def _reduce_72(val, _values, result); end
+
+  # reduce 725 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#12524
+  def _reduce_726(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12530
+  def _reduce_727(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8834
+  def _reduce_73(val, _values, result); end
+
+  # reduce 731 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#12544
+  def _reduce_732(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12550
+  def _reduce_733(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12556
+  def _reduce_734(val, _values, result); end
+
+  # reduce 736 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#12566
+  def _reduce_737(val, _values, result); end
+
+  # reduce 740 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#12578
+  def _reduce_741(val, _values, result); end
+
+  # reduce 74 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#8843
+  def _reduce_75(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8850
+  def _reduce_76(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8861
+  def _reduce_77(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8868
+  def _reduce_78(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8879
+  def _reduce_79(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8886
+  def _reduce_80(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8897
+  def _reduce_81(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8907
+  def _reduce_82(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8914
+  def _reduce_83(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8921
+  def _reduce_84(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8928
+  def _reduce_85(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8935
+  def _reduce_86(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8942
+  def _reduce_87(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8948
+  def _reduce_88(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8954
+  def _reduce_89(val, _values, result); end
+
+  # reduce 8 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#8419
+  def _reduce_9(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8960
+  def _reduce_90(val, _values, result); end
+
+  # reduce 91 omitted
+  #
+  # source://parser//lib/parser/ruby33.rb#8968
+  def _reduce_92(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8975
+  def _reduce_93(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8982
+  def _reduce_94(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8990
+  def _reduce_95(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#8997
+  def _reduce_96(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9005
+  def _reduce_97(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9011
+  def _reduce_98(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#9018
+  def _reduce_99(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#12584
+  def _reduce_none(val, _values, result); end
+
+  # source://parser//lib/parser/ruby33.rb#21
+  def default_encoding; end
+
+  # source://parser//lib/parser/ruby33.rb#25
+  def endless_method_name(name_t); end
+
+  # source://parser//lib/parser/ruby33.rb#38
+  def local_pop; end
+
+  # source://parser//lib/parser/ruby33.rb#31
+  def local_push; end
+
+  # source://parser//lib/parser/ruby33.rb#45
+  def try_declare_numparam(node); end
+
+  # source://parser//lib/parser/ruby33.rb#17
+  def version; end
+end
+
+# source://parser//lib/parser/ruby33.rb#7955
+Parser::Ruby33::Racc_arg = T.let(T.unsafe(nil), Array)
+
+# source://parser//lib/parser/ruby33.rb#8365
+Parser::Ruby33::Racc_debug_parser = T.let(T.unsafe(nil), FalseClass)
+
+# source://parser//lib/parser/ruby33.rb#7972
+Parser::Ruby33::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
+
+# @api public
+#
+# source://parser//lib/parser.rb#30
+module Parser::Source; end
+
+# A buffer with source code. {Buffer} contains the source code itself,
+# associated location information (name and first line), and takes care
+# of encoding.
+#
+# A source buffer is immutable once populated.
+#
+# @api public
+#
+# source://parser//lib/parser/source/buffer.rb#25
+class Parser::Source::Buffer
+  # @api public
+  # @return [Buffer] a new instance of Buffer
+  #
+  # source://parser//lib/parser/source/buffer.rb#110
+  def initialize(name, first_line = T.unsafe(nil), source: T.unsafe(nil)); end
+
+  # Convert a character index into the source to a column number.
+  #
+  # @api private
+  # @param position [Integer]
+  # @return [Integer] column
+  #
+  # source://parser//lib/parser/source/buffer.rb#247
+  def column_for_position(position); end
+
+  # Convert a character index into the source to a `[line, column]` tuple.
+  #
+  # @api public
+  # @param position [Integer]
+  # @return [[Integer, Integer]] `[line, column]`
+  #
+  # source://parser//lib/parser/source/buffer.rb#222
+  def decompose_position(position); end
+
+  # First line of the buffer, 1 by default.
+  #
+  # @api public
+  # @return [Integer] first line
+  #
+  # source://parser//lib/parser/source/buffer.rb#26
+  def first_line; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/buffer.rb#317
+  def freeze; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/buffer.rb#323
+  def inspect; end
+
+  # Number of last line in the buffer
+  #
+  # @api public
+  # @return [Integer]
+  #
+  # source://parser//lib/parser/source/buffer.rb#312
+  def last_line; end
+
+  # Convert a character index into the source to a line number.
+  #
+  # @api private
+  # @param position [Integer]
+  # @return [Integer] line
+  #
+  # source://parser//lib/parser/source/buffer.rb#236
+  def line_for_position(position); end
+
+  # Extract line `lineno` as a new `Range`, taking `first_line` into account.
+  #
+  # @api public
+  # @param lineno [Integer]
+  # @raise [IndexError] if `lineno` is out of bounds
+  # @return [Range]
+  #
+  # source://parser//lib/parser/source/buffer.rb#289
+  def line_range(lineno); end
+
+  # Buffer name. If the buffer was created from a file, the name corresponds
+  # to relative path to the file.
+  #
+  # @api public
+  # @return [String] buffer name
+  #
+  # source://parser//lib/parser/source/buffer.rb#26
+  def name; end
+
+  # Populate this buffer from a string without encoding autodetection.
+  #
+  # @api public
+  # @param input [String]
+  # @raise [ArgumentError] if already populated
+  # @return [String]
+  #
+  # source://parser//lib/parser/source/buffer.rb#185
+  def raw_source=(input); end
+
+  # Populate this buffer from correspondingly named file.
+  #
+  # @api public
+  # @example
+  #   Parser::Source::Buffer.new('foo/bar.rb').read
+  # @raise [ArgumentError] if already populated
+  # @return [Buffer] self
+  #
+  # source://parser//lib/parser/source/buffer.rb#136
+  def read; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/buffer.rb#199
+  def slice(start, length = T.unsafe(nil)); end
+
+  # Source code contained in this buffer.
+  #
+  # @api public
+  # @raise [RuntimeError] if buffer is not populated yet
+  # @return [String] source code
+  #
+  # source://parser//lib/parser/source/buffer.rb#150
+  def source; end
+
+  # Populate this buffer from a string with encoding autodetection.
+  # `input` is mutated if not frozen.
+  #
+  # @api public
+  # @param input [String]
+  # @raise [ArgumentError] if already populated
+  # @raise [EncodingError] if `input` includes invalid byte sequence for the encoding
+  # @return [String]
+  #
+  # source://parser//lib/parser/source/buffer.rb#167
+  def source=(input); end
+
+  # Extract line `lineno` from source, taking `first_line` into account.
+  #
+  # @api public
+  # @param lineno [Integer]
+  # @raise [IndexError] if `lineno` is out of bounds
+  # @return [String]
+  #
+  # source://parser//lib/parser/source/buffer.rb#278
+  def source_line(lineno); end
+
+  # Return an `Array` of source code lines.
+  #
+  # @api public
+  # @return [Array<String>]
+  #
+  # source://parser//lib/parser/source/buffer.rb#257
+  def source_lines; end
+
+  # @api public
+  # @return [Range] A range covering the whole source
+  #
+  # source://parser//lib/parser/source/buffer.rb#303
+  def source_range; end
+
+  private
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/buffer.rb#353
+  def bsearch(line_begins, position); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/buffer.rb#330
+  def line_begins; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/buffer.rb#344
+  def line_index_for_position(position); end
+
+  class << self
+    # Try to recognize encoding of `string` as Ruby would, i.e. by looking for
+    # magic encoding comment or UTF-8 BOM. `string` can be in any encoding.
+    #
+    # @api public
+    # @param string [String]
+    # @raise [Parser::UnknownEncodingInMagicComment] if the encoding is not recognized
+    # @return [String, nil] encoding name, if recognized
+    #
+    # source://parser//lib/parser/source/buffer.rb#52
+    def recognize_encoding(string); end
+
+    # Recognize encoding of `input` and process it so it could be lexed.
+    #
+    #  * If `input` does not contain BOM or magic encoding comment, it is
+    #    kept in the original encoding.
+    #  * If the detected encoding is binary, `input` is kept in binary.
+    #  * Otherwise, `input` is re-encoded into UTF-8 and returned as a
+    #    new string.
+    #
+    # This method mutates the encoding of `input`, but not its content.
+    #
+    # @api public
+    # @param input [String]
+    # @raise [EncodingError]
+    # @return [String]
+    #
+    # source://parser//lib/parser/source/buffer.rb#95
+    def reencode_string(input); end
+  end
+end
+
+# @api private
+#
+# source://parser//lib/parser/source/buffer.rb#31
+Parser::Source::Buffer::ENCODING_RE = T.let(T.unsafe(nil), Regexp)
+
+# A comment in the source code.
+#
+# @api public
+#
+# source://parser//lib/parser/source/comment.rb#17
+class Parser::Source::Comment
+  # @api public
+  # @param range [Parser::Source::Range]
+  # @return [Comment] a new instance of Comment
+  #
+  # source://parser//lib/parser/source/comment.rb#67
+  def initialize(range); end
+
+  # Compares comments. Two comments are equal if they
+  # correspond to the same source range.
+  #
+  # @api public
+  # @param other [Object]
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/comment.rb#120
+  def ==(other); end
+
+  # @api public
+  # @return [Boolean] true if this is a block comment.
+  # @see #type
+  #
+  # source://parser//lib/parser/source/comment.rb#109
+  def document?; end
+
+  # @api public
+  # @return [Boolean] true if this is an inline comment.
+  # @see #type
+  #
+  # source://parser//lib/parser/source/comment.rb#101
+  def inline?; end
+
+  # @api public
+  # @return [String] a human-readable representation of this comment
+  #
+  # source://parser//lib/parser/source/comment.rb#128
+  def inspect; end
+
+  # @api public
+  # @return [Parser::Source::Range]
+  #
+  # source://parser//lib/parser/source/comment.rb#20
+  def loc; end
+
+  # @api public
+  # @return [Parser::Source::Range]
+  #
+  # source://parser//lib/parser/source/comment.rb#20
+  def location; end
+
+  # @api public
+  # @return [String]
+  #
+  # source://parser//lib/parser/source/comment.rb#18
+  def text; end
+
+  # Type of this comment.
+  #
+  #   * Inline comments correspond to `:inline`:
+  #
+  #         # whatever
+  #
+  #   * Block comments correspond to `:document`:
+  #
+  #         =begin
+  #         hi i am a document
+  #         =end
+  #
+  # @api public
+  # @return [Symbol]
+  #
+  # source://parser//lib/parser/source/comment.rb#89
+  def type; end
+
+  class << self
+    # Associate `comments` with `ast` nodes by their corresponding node.
+    #
+    # @api public
+    # @deprecated Use {associate_locations}.
+    # @param ast [Parser::AST::Node]
+    # @param comments [Array<Comment>]
+    # @return [Hash<Parser::AST::Node, Array<Comment>>]
+    # @see Parser::Source::Comment::Associator#associate
+    #
+    # source://parser//lib/parser/source/comment.rb#32
+    def associate(ast, comments); end
+
+    # Associate `comments` with `ast` nodes using identity.
+    #
+    # @api public
+    # @param ast [Parser::AST::Node]
+    # @param comments [Array<Comment>]
+    # @return [Hash<Parser::Source::Node, Array<Comment>>]
+    # @see Parser::Source::Comment::Associator#associate_by_identity
+    #
+    # source://parser//lib/parser/source/comment.rb#59
+    def associate_by_identity(ast, comments); end
+
+    # Associate `comments` with `ast` nodes by their location in the
+    # source.
+    #
+    # @api public
+    # @param ast [Parser::AST::Node]
+    # @param comments [Array<Comment>]
+    # @return [Hash<Parser::Source::Map, Array<Comment>>]
+    # @see Parser::Source::Comment::Associator#associate_locations
+    #
+    # source://parser//lib/parser/source/comment.rb#46
+    def associate_locations(ast, comments); end
+  end
+end
+
+# source://parser//lib/parser/source/comment/associator.rb#45
+class Parser::Source::Comment::Associator
+  # source://parser//lib/parser/source/comment/associator.rb#51
+  def initialize(ast, comments); end
+
+  # source://parser//lib/parser/source/comment/associator.rb#92
+  def associate; end
+
+  # source://parser//lib/parser/source/comment/associator.rb#115
+  def associate_by_identity; end
+
+  # source://parser//lib/parser/source/comment/associator.rb#104
+  def associate_locations; end
+
+  # source://parser//lib/parser/source/comment/associator.rb#46
+  def skip_directives; end
+
+  # source://parser//lib/parser/source/comment/associator.rb#46
+  def skip_directives=(_arg0); end
+
+  private
+
+  # source://parser//lib/parser/source/comment/associator.rb#182
+  def advance_comment; end
+
+  # source://parser//lib/parser/source/comment/associator.rb#214
+  def advance_through_directives; end
+
+  # source://parser//lib/parser/source/comment/associator.rb#206
+  def associate_and_advance_comment(node); end
+
+  # source://parser//lib/parser/source/comment/associator.rb#123
+  def children_in_source_order(node); end
+
+  # source://parser//lib/parser/source/comment/associator.rb#187
+  def current_comment_before?(node); end
+
+  # source://parser//lib/parser/source/comment/associator.rb#194
+  def current_comment_before_end?(node); end
+
+  # source://parser//lib/parser/source/comment/associator.rb#201
+  def current_comment_decorates?(node); end
+
+  # source://parser//lib/parser/source/comment/associator.rb#135
+  def do_associate; end
+
+  # source://parser//lib/parser/source/comment/associator.rb#166
+  def process_leading_comments(node); end
+
+  # source://parser//lib/parser/source/comment/associator.rb#173
+  def process_trailing_comments(node); end
+
+  # source://parser//lib/parser/source/comment/associator.rb#148
+  def visit(node); end
+end
+
+# source://parser//lib/parser/source/comment/associator.rb#212
+Parser::Source::Comment::Associator::MAGIC_COMMENT_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://parser//lib/parser/source/comment/associator.rb#122
+Parser::Source::Comment::Associator::POSTFIX_TYPES = T.let(T.unsafe(nil), Set)
+
+# {Map} relates AST nodes to the source code they were parsed from.
+# More specifically, a {Map} or its subclass contains a set of ranges:
+#
+#  * `expression`: smallest range which includes all source corresponding
+#    to the node and all `expression` ranges of its children.
+#  * other ranges (`begin`, `end`, `operator`, ...): node-specific ranges
+#    pointing to various interesting tokens corresponding to the node.
+#
+# Note that the {Map::Heredoc} map is the only one whose `expression` does
+# not include other ranges. It only covers the heredoc marker (`<<HERE`),
+# not the here document itself.
+#
+# All ranges except `expression` are defined by {Map} subclasses.
+#
+# Ranges (except `expression`) can be `nil` if the corresponding token is
+# not present in source. For example, a hash may not have opening/closing
+# braces, and so would its source map.
+#
+#     p Parser::CurrentRuby.parse('[1 => 2]').children[0].loc
+#     # => <Parser::Source::Map::Collection:0x007f5492b547d8
+#     #  @end=nil, @begin=nil,
+#     #  @expression=#<Source::Range (string) 1...7>>
+#
+# The {file:doc/AST_FORMAT.md} document describes how ranges associated to source
+# code tokens. For example, the entry
+#
+#     (array (int 1) (int 2))
+#
+#     "[1, 2]"
+#      ^ begin
+#           ^ end
+#      ~~~~~~ expression
+#
+# means that if `node` is an {Parser::AST::Node} `(array (int 1) (int 2))`,
+# then `node.loc` responds to `begin`, `end` and `expression`, and
+# `node.loc.begin` returns a range pointing at the opening bracket, and so on.
+#
+# If you want to write code polymorphic by the source map (i.e. accepting
+# several subclasses of {Map}), use `respond_to?` instead of `is_a?` to
+# check whether the map features the range you need. Concrete {Map}
+# subclasses may not be preserved between versions, but their interfaces
+# will be kept compatible.
+#
+# You can visualize the source maps with `ruby-parse -E` command-line tool.
+#
+# @api public
+# @example
+#   require 'parser/current'
+#
+#   p Parser::CurrentRuby.parse('[1, 2]').loc
+#   # => #<Parser::Source::Map::Collection:0x007f14b80eccd8
+#   #  @end=#<Source::Range (string) 5...6>,
+#   #  @begin=#<Source::Range (string) 0...1>,
+#   #  @expression=#<Source::Range (string) 0...6>>
+#
+# source://parser//lib/parser/source/map.rb#70
+class Parser::Source::Map
+  # @api public
+  # @param expression [Range]
+  # @return [Map] a new instance of Map
+  #
+  # source://parser//lib/parser/source/map.rb#76
+  def initialize(expression); end
+
+  # Compares source maps.
+  #
+  # @api public
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/map.rb#140
+  def ==(other); end
+
+  # A shortcut for `self.expression.column`.
+  #
+  # @api public
+  # @return [Integer]
+  #
+  # source://parser//lib/parser/source/map.rb#109
+  def column; end
+
+  # @api public
+  # @return [Range]
+  #
+  # source://parser//lib/parser/source/map.rb#72
+  def expression; end
+
+  # A shortcut for `self.expression.line`.
+  #
+  # @api public
+  # @return [Integer]
+  #
+  # source://parser//lib/parser/source/map.rb#99
+  def first_line; end
+
+  # A shortcut for `self.expression.last_column`.
+  #
+  # @api public
+  # @return [Integer]
+  #
+  # source://parser//lib/parser/source/map.rb#125
+  def last_column; end
+
+  # A shortcut for `self.expression.last_line`.
+  #
+  # @api public
+  # @return [Integer]
+  #
+  # source://parser//lib/parser/source/map.rb#117
+  def last_line; end
+
+  # A shortcut for `self.expression.line`.
+  #
+  # @api public
+  # @return [Integer]
+  #
+  # source://parser//lib/parser/source/map.rb#99
+  def line; end
+
+  # The node that is described by this map. Nodes and maps have 1:1 correspondence.
+  #
+  # @api public
+  # @return [Parser::AST::Node]
+  #
+  # source://parser//lib/parser/source/map.rb#71
+  def node; end
+
+  # @api private
+  #
+  # source://parser//lib/parser/source/map.rb#89
+  def node=(node); end
+
+  # Converts this source map to a hash with keys corresponding to
+  # ranges. For example, if called on an instance of {Collection},
+  # which adds the `begin` and `end` ranges, the resulting hash
+  # will contain keys `:expression`, `:begin` and `:end`.
+  #
+  # @api public
+  # @example
+  #   require 'parser/current'
+  #
+  #   p Parser::CurrentRuby.parse('[1, 2]').loc.to_hash
+  #   # => {
+  #   #   :begin => #<Source::Range (string) 0...1>,
+  #   #   :end => #<Source::Range (string) 5...6>,
+  #   #   :expression => #<Source::Range (string) 0...6>
+  #   # }
+  # @return [Hash<Symbol, Parser::Source::Range>]
+  #
+  # source://parser//lib/parser/source/map.rb#166
+  def to_hash; end
+
+  # @api private
+  #
+  # source://parser//lib/parser/source/map.rb#132
+  def with_expression(expression_l); end
+
+  protected
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/map.rb#180
+  def update_expression(expression_l); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/map.rb#176
+  def with(&block); end
+
+  private
+
+  # @api private
+  #
+  # source://parser//lib/parser/source/map.rb#82
+  def initialize_copy(other); end
+end
+
+# source://parser//lib/parser/source/map/collection.rb#6
+class Parser::Source::Map::Collection < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/collection.rb#10
+  def initialize(begin_l, end_l, expression_l); end
+
+  # source://parser//lib/parser/source/map/collection.rb#7
+  def begin; end
+
+  # source://parser//lib/parser/source/map/collection.rb#8
+  def end; end
+end
+
+# source://parser//lib/parser/source/map/condition.rb#6
+class Parser::Source::Map::Condition < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/condition.rb#12
+  def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end
+
+  # source://parser//lib/parser/source/map/condition.rb#8
+  def begin; end
+
+  # source://parser//lib/parser/source/map/condition.rb#9
+  def else; end
+
+  # source://parser//lib/parser/source/map/condition.rb#10
+  def end; end
+
+  # source://parser//lib/parser/source/map/condition.rb#7
+  def keyword; end
+end
+
+# source://parser//lib/parser/source/map/constant.rb#6
+class Parser::Source::Map::Constant < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/constant.rb#11
+  def initialize(double_colon, name, expression); end
+
+  # source://parser//lib/parser/source/map/constant.rb#7
+  def double_colon; end
+
+  # source://parser//lib/parser/source/map/constant.rb#8
+  def name; end
+
+  # source://parser//lib/parser/source/map/constant.rb#9
+  def operator; end
+
+  # source://parser//lib/parser/source/map/constant.rb#20
+  def with_operator(operator_l); end
+
+  protected
+
+  # source://parser//lib/parser/source/map/constant.rb#26
+  def update_operator(operator_l); end
+end
+
+# source://parser//lib/parser/source/map/definition.rb#6
+class Parser::Source::Map::Definition < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/definition.rb#12
+  def initialize(keyword_l, operator_l, name_l, end_l); end
+
+  # source://parser//lib/parser/source/map/definition.rb#10
+  def end; end
+
+  # source://parser//lib/parser/source/map/definition.rb#7
+  def keyword; end
+
+  # source://parser//lib/parser/source/map/definition.rb#9
+  def name; end
+
+  # source://parser//lib/parser/source/map/definition.rb#8
+  def operator; end
+end
+
+# source://parser//lib/parser/source/map/for.rb#6
+class Parser::Source::Map::For < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/for.rb#10
+  def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end
+
+  # source://parser//lib/parser/source/map/for.rb#8
+  def begin; end
+
+  # source://parser//lib/parser/source/map/for.rb#8
+  def end; end
+
+  # source://parser//lib/parser/source/map/for.rb#7
+  def in; end
+
+  # source://parser//lib/parser/source/map/for.rb#7
+  def keyword; end
+end
+
+# source://parser//lib/parser/source/map/heredoc.rb#6
+class Parser::Source::Map::Heredoc < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/heredoc.rb#10
+  def initialize(begin_l, body_l, end_l); end
+
+  # source://parser//lib/parser/source/map/heredoc.rb#7
+  def heredoc_body; end
+
+  # source://parser//lib/parser/source/map/heredoc.rb#8
+  def heredoc_end; end
+end
+
+# source://parser//lib/parser/source/map/index.rb#6
+class Parser::Source::Map::Index < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/index.rb#11
+  def initialize(begin_l, end_l, expression_l); end
+
+  # source://parser//lib/parser/source/map/index.rb#7
+  def begin; end
+
+  # source://parser//lib/parser/source/map/index.rb#8
+  def end; end
+
+  # source://parser//lib/parser/source/map/index.rb#9
+  def operator; end
+
+  # source://parser//lib/parser/source/map/index.rb#21
+  def with_operator(operator_l); end
+
+  protected
+
+  # source://parser//lib/parser/source/map/index.rb#27
+  def update_operator(operator_l); end
+end
+
+# source://parser//lib/parser/source/map/keyword.rb#6
+class Parser::Source::Map::Keyword < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/keyword.rb#11
+  def initialize(keyword_l, begin_l, end_l, expression_l); end
+
+  # source://parser//lib/parser/source/map/keyword.rb#8
+  def begin; end
+
+  # source://parser//lib/parser/source/map/keyword.rb#9
+  def end; end
+
+  # source://parser//lib/parser/source/map/keyword.rb#7
+  def keyword; end
+end
+
+# source://parser//lib/parser/source/map/method_definition.rb#6
+class Parser::Source::Map::MethodDefinition < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/method_definition.rb#13
+  def initialize(keyword_l, operator_l, name_l, end_l, assignment_l, body_l); end
+
+  # source://parser//lib/parser/source/map/method_definition.rb#11
+  def assignment; end
+
+  # source://parser//lib/parser/source/map/method_definition.rb#10
+  def end; end
+
+  # source://parser//lib/parser/source/map/method_definition.rb#7
+  def keyword; end
+
+  # source://parser//lib/parser/source/map/method_definition.rb#9
+  def name; end
+
+  # source://parser//lib/parser/source/map/method_definition.rb#8
+  def operator; end
+end
+
+# source://parser//lib/parser/source/map/objc_kwarg.rb#6
+class Parser::Source::Map::ObjcKwarg < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/objc_kwarg.rb#11
+  def initialize(keyword_l, operator_l, argument_l, expression_l); end
+
+  # source://parser//lib/parser/source/map/objc_kwarg.rb#9
+  def argument; end
+
+  # source://parser//lib/parser/source/map/objc_kwarg.rb#7
+  def keyword; end
+
+  # source://parser//lib/parser/source/map/objc_kwarg.rb#8
+  def operator; end
+end
+
+# source://parser//lib/parser/source/map/operator.rb#6
+class Parser::Source::Map::Operator < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/operator.rb#9
+  def initialize(operator, expression); end
+
+  # source://parser//lib/parser/source/map/operator.rb#7
+  def operator; end
+end
+
+# source://parser//lib/parser/source/map/rescue_body.rb#6
+class Parser::Source::Map::RescueBody < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/rescue_body.rb#11
+  def initialize(keyword_l, assoc_l, begin_l, expression_l); end
+
+  # source://parser//lib/parser/source/map/rescue_body.rb#8
+  def assoc; end
+
+  # source://parser//lib/parser/source/map/rescue_body.rb#9
+  def begin; end
+
+  # source://parser//lib/parser/source/map/rescue_body.rb#7
+  def keyword; end
+end
+
+# source://parser//lib/parser/source/map/send.rb#6
+class Parser::Source::Map::Send < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/send.rb#13
+  def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end
+
+  # source://parser//lib/parser/source/map/send.rb#10
+  def begin; end
+
+  # source://parser//lib/parser/source/map/send.rb#7
+  def dot; end
+
+  # source://parser//lib/parser/source/map/send.rb#11
+  def end; end
+
+  # source://parser//lib/parser/source/map/send.rb#9
+  def operator; end
+
+  # source://parser//lib/parser/source/map/send.rb#8
+  def selector; end
+
+  # source://parser//lib/parser/source/map/send.rb#24
+  def with_operator(operator_l); end
+
+  protected
+
+  # source://parser//lib/parser/source/map/send.rb#30
+  def update_operator(operator_l); end
+end
+
+# source://parser//lib/parser/source/map/ternary.rb#6
+class Parser::Source::Map::Ternary < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/ternary.rb#10
+  def initialize(question_l, colon_l, expression_l); end
+
+  # source://parser//lib/parser/source/map/ternary.rb#8
+  def colon; end
+
+  # source://parser//lib/parser/source/map/ternary.rb#7
+  def question; end
+end
+
+# source://parser//lib/parser/source/map/variable.rb#6
+class Parser::Source::Map::Variable < ::Parser::Source::Map
+  # source://parser//lib/parser/source/map/variable.rb#10
+  def initialize(name_l, expression_l = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/source/map/variable.rb#7
+  def name; end
+
+  # source://parser//lib/parser/source/map/variable.rb#8
+  def operator; end
+
+  # source://parser//lib/parser/source/map/variable.rb#19
+  def with_operator(operator_l); end
+
+  protected
+
+  # source://parser//lib/parser/source/map/variable.rb#25
+  def update_operator(operator_l); end
+end
+
+# A range of characters in a particular source buffer.
+#
+# The range is always exclusive, i.e. a range with `begin_pos` of 3 and
+# `end_pos` of 5 will contain the following characters:
+#
+#     example
+#        ^^
+#
+# @api public
+#
+# source://parser//lib/parser/source/range.rb#26
+class Parser::Source::Range
+  include ::Comparable
+
+  # @api public
+  # @param source_buffer [Buffer]
+  # @param begin_pos [Integer]
+  # @param end_pos [Integer]
+  # @return [Range] a new instance of Range
+  #
+  # source://parser//lib/parser/source/range.rb#37
+  def initialize(source_buffer, begin_pos, end_pos); end
+
+  # Compare ranges, first by begin_pos, then by end_pos.
+  #
+  # @api public
+  #
+  # source://parser//lib/parser/source/range.rb#301
+  def <=>(other); end
+
+  # by the given amount(s)
+  #
+  # @api public
+  # @param Endpoint(s) [Hash] to change, any combination of :begin_pos or :end_pos
+  # @return [Range] the same range as this range but with the given end point(s) adjusted
+  #
+  # source://parser//lib/parser/source/range.rb#193
+  def adjust(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
+
+  # @api public
+  # @return [Range] a zero-length range located just before the beginning
+  #   of this range.
+  #
+  # source://parser//lib/parser/source/range.rb#55
+  def begin; end
+
+  # @api public
+  # @return [Integer] index of the first character in the range
+  #
+  # source://parser//lib/parser/source/range.rb#30
+  def begin_pos; end
+
+  # @api public
+  # @return [Integer] zero-based column number of the beginning of this range.
+  #
+  # source://parser//lib/parser/source/range.rb#92
+  def column; end
+
+  # @api public
+  # @raise RangeError
+  # @return [::Range] a range of columns spanned by this range.
+  #
+  # source://parser//lib/parser/source/range.rb#114
+  def column_range; end
+
+  # Return `other.contains?(self)`
+  #
+  # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
+  #
+  # @api public
+  # @param other [Range]
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/range.rb#274
+  def contained?(other); end
+
+  # Returns true iff this range contains (strictly) `other`.
+  #
+  # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
+  #
+  # @api public
+  # @param other [Range]
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/range.rb#262
+  def contains?(other); end
+
+  # Returns true iff both ranges intersect and also have different elements from one another.
+  #
+  # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
+  #
+  # @api public
+  # @param other [Range]
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/range.rb#286
+  def crossing?(other); end
+
+  # Return `true` iff this range and `other` are disjoint.
+  #
+  # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
+  #
+  # @api public
+  # @param other [Range]
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/range.rb#236
+  def disjoint?(other); end
+
+  # Checks if a range is empty; if it contains no characters
+  #
+  # @api public
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/range.rb#294
+  def empty?; end
+
+  # @api public
+  # @return [Range] a zero-length range located just after the end
+  #   of this range.
+  #
+  # source://parser//lib/parser/source/range.rb#63
+  def end; end
+
+  # @api public
+  # @return [Integer] index of the character after the last character in the range
+  #
+  # source://parser//lib/parser/source/range.rb#30
+  def end_pos; end
+
+  # @api public
+  def eql?(_arg0); end
+
+  # Line number of the beginning of this range. By default, the first line
+  # of a buffer is 1; as such, line numbers are most commonly one-based.
+  #
+  # @api public
+  # @return [Integer] line number of the beginning of this range.
+  # @see Buffer
+  #
+  # source://parser//lib/parser/source/range.rb#83
+  def first_line; end
+
+  # Support for Ranges be used in as Hash indices and in Sets.
+  #
+  # @api public
+  #
+  # source://parser//lib/parser/source/range.rb#313
+  def hash; end
+
+  # @api public
+  # @return [String] a human-readable representation of this range.
+  #
+  # source://parser//lib/parser/source/range.rb#320
+  def inspect; end
+
+  # @api public
+  # @param other [Range]
+  # @return [Range] overlapping region of this range and `other`, or `nil`
+  #   if they do not overlap
+  #
+  # source://parser//lib/parser/source/range.rb#220
+  def intersect(other); end
+
+  # `is?` provides a concise way to compare the source corresponding to this range.
+  # For example, `r.source == '(' || r.source == 'begin'` is equivalent to
+  # `r.is?('(', 'begin')`.
+  #
+  # @api public
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/range.rb#141
+  def is?(*what); end
+
+  # @api public
+  # @param other [Range]
+  # @return [Range] smallest possible range spanning both this range and `other`.
+  #
+  # source://parser//lib/parser/source/range.rb#209
+  def join(other); end
+
+  # @api public
+  # @return [Integer] zero-based column number of the end of this range.
+  #
+  # source://parser//lib/parser/source/range.rb#106
+  def last_column; end
+
+  # @api public
+  # @return [Integer] line number of the end of this range.
+  #
+  # source://parser//lib/parser/source/range.rb#99
+  def last_line; end
+
+  # @api public
+  # @return [Integer] amount of characters included in this range.
+  #
+  # source://parser//lib/parser/source/range.rb#70
+  def length; end
+
+  # Line number of the beginning of this range. By default, the first line
+  # of a buffer is 1; as such, line numbers are most commonly one-based.
+  #
+  # @api public
+  # @return [Integer] line number of the beginning of this range.
+  # @see Buffer
+  #
+  # source://parser//lib/parser/source/range.rb#83
+  def line; end
+
+  # Return `true` iff this range is not disjoint from `other`.
+  #
+  # @api public
+  # @param other [Range]
+  # @return [Boolean] `true` if this range and `other` overlap
+  #
+  # source://parser//lib/parser/source/range.rb#250
+  def overlaps?(other); end
+
+  # @api public
+  # @param new_size [Integer]
+  # @return [Range] a range beginning at the same point as this range and length `new_size`.
+  #
+  # source://parser//lib/parser/source/range.rb#201
+  def resize(new_size); end
+
+  # @api public
+  # @return [Integer] amount of characters included in this range.
+  #
+  # source://parser//lib/parser/source/range.rb#70
+  def size; end
+
+  # @api public
+  # @return [String] all source code covered by this range.
+  #
+  # source://parser//lib/parser/source/range.rb#132
+  def source; end
+
+  # @api public
+  # @return [Parser::Source::Buffer]
+  #
+  # source://parser//lib/parser/source/range.rb#29
+  def source_buffer; end
+
+  # @api public
+  # @return [String] a line of source code containing the beginning of this range.
+  #
+  # source://parser//lib/parser/source/range.rb#125
+  def source_line; end
+
+  # @api public
+  # @return [Array<Integer>] a set of character indexes contained in this range.
+  #
+  # source://parser//lib/parser/source/range.rb#148
+  def to_a; end
+
+  # @api public
+  # @return [Range] a Ruby range with the same `begin_pos` and `end_pos`
+  #
+  # source://parser//lib/parser/source/range.rb#155
+  def to_range; end
+
+  # Composes a GNU/Clang-style string representation of the beginning of this
+  # range.
+  #
+  # For example, for the following range in file `foo.rb`,
+  #
+  #     def foo
+  #         ^^^
+  #
+  # `to_s` will return `foo.rb:1:5`.
+  # Note that the column index is one-based.
+  #
+  # @api public
+  # @return [String]
+  #
+  # source://parser//lib/parser/source/range.rb#173
+  def to_s; end
+
+  # to the given value(s).
+  #
+  # @api public
+  # @param Endpoint(s) [Hash] to change, any combination of :begin_pos or :end_pos
+  # @return [Range] the same range as this range but with the given end point(s) changed
+  #
+  # source://parser//lib/parser/source/range.rb#184
+  def with(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
+end
+
+# {Rewriter} is deprecated. Use {TreeRewriter} instead.
+#
+# TreeRewriter has simplified semantics, and customizable policies
+# with regards to clobbering. Please read the documentation.
+#
+# Keep in mind:
+# - Rewriter was discarding the `end_pos` of the given range for `insert_before`,
+#   and the `begin_pos` for `insert_after`. These are meaningful in TreeRewriter.
+# - TreeRewriter's wrap/insert_before/insert_after are multiple by default, while
+#   Rewriter would raise clobbering errors if the non '_multi' version was called.
+# - The TreeRewriter policy closest to Rewriter's behavior is:
+#       different_replacements: :raise,
+#       swallowed_insertions: :raise,
+#       crossing_deletions: :accept
+#
+# @api public
+# @deprecated Use {TreeRewriter}
+#
+# source://parser//lib/parser/source/rewriter.rb#31
+class Parser::Source::Rewriter
+  extend ::Parser::Deprecation
+
+  # @api public
+  # @deprecated Use {TreeRewriter}
+  # @param source_buffer [Source::Buffer]
+  # @return [Rewriter] a new instance of Rewriter
+  #
+  # source://parser//lib/parser/source/rewriter.rb#39
+  def initialize(source_buffer); end
+
+  # @api public
+  # @return [Diagnostic::Engine]
+  #
+  # source://parser//lib/parser/source/rewriter.rb#33
+  def diagnostics; end
+
+  # Inserts new code after the given source range.
+  #
+  # @api public
+  # @deprecated Use {TreeRewriter#insert_after}
+  # @param range [Range]
+  # @param content [String]
+  # @raise [ClobberingError] when clobbering is detected
+  # @return [Rewriter] self
+  #
+  # source://parser//lib/parser/source/rewriter.rb#131
+  def insert_after(range, content); end
+
+  # Inserts new code after the given source range by allowing other
+  # insertions at the same position.
+  # Note that an insertion with latter invocation comes _after_ earlier
+  # insertion at the same position in the rewritten source.
+  #
+  # @api public
+  # @deprecated Use {TreeRewriter#insert_after}
+  # @example Inserting ')]'
+  #   rewriter.
+  #   insert_after_multi(range, ')').
+  #   insert_after_multi(range, ']').
+  #   process
+  # @param range [Range]
+  # @param content [String]
+  # @raise [ClobberingError] when clobbering is detected
+  # @return [Rewriter] self
+  #
+  # source://parser//lib/parser/source/rewriter.rb#153
+  def insert_after_multi(range, content); end
+
+  # Inserts new code before the given source range.
+  #
+  # @api public
+  # @deprecated Use {TreeRewriter#insert_before}
+  # @param range [Range]
+  # @param content [String]
+  # @raise [ClobberingError] when clobbering is detected
+  # @return [Rewriter] self
+  #
+  # source://parser//lib/parser/source/rewriter.rb#80
+  def insert_before(range, content); end
+
+  # Inserts new code before the given source range by allowing other
+  # insertions at the same position.
+  # Note that an insertion with latter invocation comes _before_ earlier
+  # insertion at the same position in the rewritten source.
+  #
+  # @api public
+  # @deprecated Use {TreeRewriter#insert_before}
+  # @example Inserting '[('
+  #   rewriter.
+  #   insert_before_multi(range, '(').
+  #   insert_before_multi(range, '[').
+  #   process
+  # @param range [Range]
+  # @param content [String]
+  # @raise [ClobberingError] when clobbering is detected
+  # @return [Rewriter] self
+  #
+  # source://parser//lib/parser/source/rewriter.rb#117
+  def insert_before_multi(range, content); end
+
+  # Applies all scheduled changes to the `source_buffer` and returns
+  # modified source as a new string.
+  #
+  # @api public
+  # @deprecated Use {TreeRewriter#process}
+  # @return [String]
+  #
+  # source://parser//lib/parser/source/rewriter.rb#178
+  def process; end
+
+  # Removes the source range.
+  #
+  # @api public
+  # @deprecated Use {TreeRewriter#remove}
+  # @param range [Range]
+  # @raise [ClobberingError] when clobbering is detected
+  # @return [Rewriter] self
+  #
+  # source://parser//lib/parser/source/rewriter.rb#67
+  def remove(range); end
+
+  # Replaces the code of the source range `range` with `content`.
+  #
+  # @api public
+  # @deprecated Use {TreeRewriter#replace}
+  # @param range [Range]
+  # @param content [String]
+  # @raise [ClobberingError] when clobbering is detected
+  # @return [Rewriter] self
+  #
+  # source://parser//lib/parser/source/rewriter.rb#167
+  def replace(range, content); end
+
+  # @api public
+  # @return [Source::Buffer]
+  #
+  # source://parser//lib/parser/source/rewriter.rb#32
+  def source_buffer; end
+
+  # Provides a protected block where a sequence of multiple rewrite actions
+  # are handled atomically. If any of the actions failed by clobbering,
+  # all the actions are rolled back.
+  #
+  # @api public
+  # @deprecated Use {TreeRewriter#transaction}
+  # @example
+  #   begin
+  #   rewriter.transaction do
+  #   rewriter.insert_before(range_of_something, '(')
+  #   rewriter.insert_after(range_of_something, ')')
+  #   end
+  #   rescue Parser::ClobberingError
+  #   end
+  # @raise [RuntimeError] when no block is passed
+  # @raise [RuntimeError] when already in a transaction
+  #
+  # source://parser//lib/parser/source/rewriter.rb#216
+  def transaction; end
+
+  # Inserts new code before and after the given source range.
+  #
+  # @api public
+  # @deprecated Use {TreeRewriter#wrap}
+  # @param range [Range]
+  # @param before [String]
+  # @param after [String]
+  # @raise [ClobberingError] when clobbering is detected
+  # @return [Rewriter] self
+  #
+  # source://parser//lib/parser/source/rewriter.rb#94
+  def wrap(range, before, after); end
+
+  private
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#476
+  def active_clobber; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#484
+  def active_clobber=(value); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#480
+  def active_insertions; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#492
+  def active_insertions=(value); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#472
+  def active_queue; end
+
+  # @api public
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/rewriter.rb#500
+  def adjacent?(range1, range2); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#351
+  def adjacent_insertion_mask(range); end
+
+  # @api public
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/rewriter.rb#366
+  def adjacent_insertions?(range); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#347
+  def adjacent_position_mask(range); end
+
+  # @api public
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/rewriter.rb#377
+  def adjacent_updates?(range); end
+
+  # Schedule a code update. If it overlaps with another update, check
+  # whether they conflict, and raise a clobbering error if they do.
+  # (As a special case, zero-length ranges at the same position are
+  # considered to "overlap".) Otherwise, merge them.
+  #
+  # Updates which are adjacent to each other, but do not overlap, are also
+  # merged.
+  #
+  # RULES:
+  #
+  # - Insertion ("replacing" a zero-length range):
+  #   - Two insertions at the same point conflict. This is true even
+  #     if the earlier insertion has already been merged with an adjacent
+  #     update, and even if they are both inserting the same text.
+  #   - An insertion never conflicts with a replace or remove operation
+  #     on its right or left side, which does not overlap it (in other
+  #     words, which does not update BOTH its right and left sides).
+  #   - An insertion always conflicts with a remove operation which spans
+  #     both its sides.
+  #   - An insertion conflicts with a replace operation which spans both its
+  #     sides, unless the replacement text is longer than the replaced text
+  #     by the size of the insertion (or more), and the portion of
+  #     replacement text immediately after the insertion position is
+  #     identical to the inserted text.
+  #
+  # - Removal operations never conflict with each other.
+  #
+  # - Replacement operations:
+  #   - Take the portion of each replacement text which falls within:
+  #     - The other operation's replaced region
+  #     - The other operation's replacement text, if it extends past the
+  #       end of its own replaced region (in other words, if the replacement
+  #       text is longer than the text it replaces)
+  #   - If and only if the taken texts are identical for both operations,
+  #     they do not conflict.
+  #
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#280
+  def append(action); end
+
+  # @api public
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/rewriter.rb#389
+  def can_merge?(action, existing); end
+
+  # @api public
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/rewriter.rb#355
+  def clobbered_insertion?(insertion); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#343
+  def clobbered_position_mask(range); end
+
+  # @api public
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/rewriter.rb#468
+  def in_transaction?; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#410
+  def merge_actions(action, existing); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#419
+  def merge_actions!(action, existing); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#425
+  def merge_replacements(actions); end
+
+  # @api public
+  # @raise [ClobberingError]
+  #
+  # source://parser//lib/parser/source/rewriter.rb#450
+  def raise_clobber_error(action, existing); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#335
+  def record_insertion(range); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#339
+  def record_replace(range); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/rewriter.rb#445
+  def replace_actions(old, updated); end
+
+  # @api public
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/rewriter.rb#383
+  def replace_compatible_with_insertion?(replace, insertion); end
+end
+
+# source://parser//lib/parser/source/rewriter/action.rb#9
+class Parser::Source::Rewriter::Action
+  include ::Comparable
+
+  # source://parser//lib/parser/source/rewriter/action.rb#15
+  def initialize(range, replacement = T.unsafe(nil), allow_multiple_insertions = T.unsafe(nil), order = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/source/rewriter/action.rb#24
+  def <=>(other); end
+
+  # source://parser//lib/parser/source/rewriter/action.rb#12
+  def allow_multiple_insertions; end
+
+  # source://parser//lib/parser/source/rewriter/action.rb#12
+  def allow_multiple_insertions?; end
+
+  # source://parser//lib/parser/source/rewriter/action.rb#12
+  def order; end
+
+  # source://parser//lib/parser/source/rewriter/action.rb#12
+  def range; end
+
+  # source://parser//lib/parser/source/rewriter/action.rb#12
+  def replacement; end
+
+  # source://parser//lib/parser/source/rewriter/action.rb#30
+  def to_s; end
+end
+
+# @api public
+#
+# source://parser//lib/parser/source/rewriter.rb#504
+Parser::Source::Rewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
+
+# {TreeRewriter} performs the heavy lifting in the source rewriting process.
+# It schedules code updates to be performed in the correct order.
+#
+# For simple cases, the resulting source will be obvious.
+#
+# Examples for more complex cases follow. Assume these examples are acting on
+# the source `'puts(:hello, :world)`. The methods #wrap, #remove, etc.
+# receive a Range as first argument; for clarity, examples below use english
+# sentences and a string of raw code instead.
+#
+# ## Overlapping ranges:
+#
+# Any two rewriting actions on overlapping ranges will fail and raise
+# a `ClobberingError`, unless they are both deletions (covered next).
+#
+# * wrap ':hello, ' with '(' and ')'
+# * wrap ', :world' with '(' and ')'
+#  => CloberringError
+#
+# ## Overlapping deletions:
+#
+# * remove ':hello, '
+# * remove ', :world'
+#
+# The overlapping ranges are merged and `':hello, :world'` will be removed.
+# This policy can be changed. `:crossing_deletions` defaults to `:accept`
+# but can be set to `:warn` or `:raise`.
+#
+# ## Multiple actions at the same end points:
+#
+# Results will always be independent on the order they were given.
+# Exception: rewriting actions done on exactly the same range (covered next).
+#
+# Example:
+# * replace ', ' by ' => '
+# * wrap ':hello, :world' with '{' and '}'
+# * replace ':world' with ':everybody'
+# * wrap ':world' with '[', ']'
+#
+# The resulting string will be `'puts({:hello => [:everybody]})'`
+# and this result is independent on the order the instructions were given in.
+#
+# Note that if the two "replace" were given as a single replacement of ', :world'
+# for ' => :everybody', the result would be a `ClobberingError` because of the wrap
+# in square brackets.
+#
+# ## Multiple wraps on same range:
+# * wrap ':hello' with '(' and ')'
+# * wrap ':hello' with '[' and ']'
+#
+# The wraps are combined in order given and results would be `'puts([(:hello)], :world)'`.
+#
+# ## Multiple replacements on same range:
+# * replace ':hello' by ':hi', then
+# * replace ':hello' by ':hey'
+#
+# The replacements are made in the order given, so the latter replacement
+# supersedes the former and ':hello' will be replaced by ':hey'.
+#
+# This policy can be changed. `:different_replacements` defaults to `:accept`
+# but can be set to `:warn` or `:raise`.
+#
+# ## Swallowed insertions:
+# wrap 'world' by '__', '__'
+# replace ':hello, :world' with ':hi'
+#
+# A containing replacement will swallow the contained rewriting actions
+# and `':hello, :world'` will be replaced by `':hi'`.
+#
+# This policy can be changed for swallowed insertions. `:swallowed_insertions`
+# defaults to `:accept` but can be set to `:warn` or `:raise`
+#
+# ## Implementation
+# The updates are organized in a tree, according to the ranges they act on
+# (where children are strictly contained by their parent), hence the name.
+#
+# @api public
+#
+# source://parser//lib/parser/source/tree_rewriter.rb#91
+class Parser::Source::TreeRewriter
+  extend ::Parser::Deprecation
+
+  # @api public
+  # @param source_buffer [Source::Buffer]
+  # @return [TreeRewriter] a new instance of TreeRewriter
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#98
+  def initialize(source_buffer, crossing_deletions: T.unsafe(nil), different_replacements: T.unsafe(nil), swallowed_insertions: T.unsafe(nil)); end
+
+  # Returns a representation of the rewriter as nested insertions (:wrap) and replacements.
+  #
+  #     rewriter.as_actions # =>[ [:wrap, 1...10, '(', ')'],
+  #                               [:wrap, 2...6, '', '!'],  # aka "insert_after"
+  #                               [:replace, 2...4, 'foo'],
+  #                               [:replace, 5...6, ''],  # aka "removal"
+  #                             ],
+  #
+  # Contrary to `as_replacements`, this representation is sufficient to recreate exactly
+  # the rewriter.
+  #
+  # @api public
+  # @return [Array<(Symbol, Range, String{, String})>]
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#299
+  def as_nested_actions; end
+
+  # Returns a representation of the rewriter as an ordered list of replacements.
+  #
+  #     rewriter.as_replacements # => [ [1...1, '('],
+  #                                     [2...4, 'foo'],
+  #                                     [5...6, ''],
+  #                                     [6...6, '!'],
+  #                                     [10...10, ')'],
+  #                                   ]
+  #
+  # This representation is sufficient to recreate the result of `process` but it is
+  # not sufficient to recreate completely the rewriter for further merging/actions.
+  # See `as_nested_actions`
+  #
+  # @api public
+  # @return [Array<Range, String>] an ordered list of pairs of range & replacement
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#281
+  def as_replacements; end
+
+  # @api public
+  # @return [Diagnostic::Engine]
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#93
+  def diagnostics; end
+
+  # Returns true iff no (non trivial) update has been recorded
+  #
+  # @api public
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#125
+  def empty?; end
+
+  # For special cases where one needs to merge a rewriter attached to a different source_buffer
+  # or that needs to be offset. Policies of the receiver are used.
+  #
+  # @api public
+  # @param rewriter [TreeRewriter] from different source_buffer
+  # @param offset [Integer]
+  # @raise [IndexError] if action ranges (once offset) don't fit the current buffer
+  # @return [Rewriter] self
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#168
+  def import!(foreign_rewriter, offset: T.unsafe(nil)); end
+
+  # @api public
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#329
+  def in_transaction?; end
+
+  # Shortcut for `wrap(range, nil, content)`
+  #
+  # @api public
+  # @param range [Range]
+  # @param content [String]
+  # @raise [ClobberingError] when clobbering is detected
+  # @return [Rewriter] self
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#242
+  def insert_after(range, content); end
+
+  # @api private
+  # @deprecated Use insert_after or wrap
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#351
+  def insert_after_multi(range, text); end
+
+  # Shortcut for `wrap(range, content, nil)`
+  #
+  # @api public
+  # @param range [Range]
+  # @param content [String]
+  # @raise [ClobberingError] when clobbering is detected
+  # @return [Rewriter] self
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#230
+  def insert_before(range, content); end
+
+  # @api private
+  # @deprecated Use insert_after or wrap
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#342
+  def insert_before_multi(range, text); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#334
+  def inspect; end
+
+  # Returns a new rewriter that consists of the updates of the received
+  # and the given argument. Policies of the receiver are used.
+  #
+  # @api public
+  # @param with [Rewriter]
+  # @raise [ClobberingError] when clobbering is detected
+  # @return [Rewriter] merge of receiver and argument
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#155
+  def merge(with); end
+
+  # Merges the updates of argument with the receiver.
+  # Policies of the receiver are used.
+  # This action is atomic in that it won't change the receiver
+  # unless it succeeds.
+  #
+  # @api public
+  # @param with [Rewriter]
+  # @raise [ClobberingError] when clobbering is detected
+  # @return [Rewriter] self
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#139
+  def merge!(with); end
+
+  # Applies all scheduled changes to the `source_buffer` and returns
+  # modified source as a new string.
+  #
+  # @api public
+  # @return [String]
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#252
+  def process; end
+
+  # Shortcut for `replace(range, '')`
+  #
+  # @api public
+  # @param range [Range]
+  # @raise [ClobberingError] when clobbering is detected
+  # @return [Rewriter] self
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#217
+  def remove(range); end
+
+  # Replaces the code of the source range `range` with `content`.
+  #
+  # @api public
+  # @param range [Range]
+  # @param content [String]
+  # @raise [ClobberingError] when clobbering is detected
+  # @return [Rewriter] self
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#193
+  def replace(range, content); end
+
+  # @api public
+  # @return [Source::Buffer]
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#92
+  def source_buffer; end
+
+  # Provides a protected block where a sequence of multiple rewrite actions
+  # are handled atomically. If any of the actions failed by clobbering,
+  # all the actions are rolled back. Transactions can be nested.
+  #
+  # @api public
+  # @raise [RuntimeError] when no block is passed
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#310
+  def transaction; end
+
+  # Inserts the given strings before and after the given range.
+  #
+  # @api public
+  # @param range [Range]
+  # @param insert_before [String, nil]
+  # @param insert_after [String, nil]
+  # @raise [ClobberingError] when clobbering is detected
+  # @return [Rewriter] self
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#206
+  def wrap(range, insert_before, insert_after); end
+
+  protected
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#365
+  def action_root; end
+
+  private
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#369
+  def action_summary; end
+
+  # @api public
+  # @raise [ArgumentError]
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#392
+  def check_policy_validity; end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#404
+  def check_range_validity(range); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#397
+  def combine(range, attributes); end
+
+  # @api public
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#411
+  def enforce_policy(event); end
+
+  # @api public
+  # @raise [Parser::ClobberingError]
+  #
+  # source://parser//lib/parser/source/tree_rewriter.rb#418
+  def trigger_policy(event, range: T.unsafe(nil), conflict: T.unsafe(nil), **arguments); end
+end
+
+# @api public
+#
+# source://parser//lib/parser/source/tree_rewriter.rb#391
+Parser::Source::TreeRewriter::ACTIONS = T.let(T.unsafe(nil), Array)
+
+# source://parser//lib/parser/source/tree_rewriter/action.rb#14
+class Parser::Source::TreeRewriter::Action
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#17
+  def initialize(range, enforcer, insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil), children: T.unsafe(nil)); end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#29
+  def combine(action); end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#68
+  def contract; end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#34
+  def empty?; end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#15
+  def insert_after; end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#15
+  def insert_before; end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#58
+  def insertion?; end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#81
+  def moved(source_buffer, offset); end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#50
+  def nested_actions; end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#41
+  def ordered_replacements; end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#15
+  def range; end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#15
+  def replacement; end
+
+  protected
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#159
+  def analyse_hierarchy(action); end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#146
+  def bsearch_child_index(from = T.unsafe(nil)); end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#225
+  def call_enforcer_for_merge(action); end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#205
+  def check_fusible(action, *fusible); end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#95
+  def children; end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#130
+  def combine_children(more_children); end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#103
+  def do_combine(action); end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#136
+  def fuse_deletions(action, fusible, other_sibblings); end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#216
+  def merge(action); end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#111
+  def place_in_hierarchy(action); end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#233
+  def swallow(children); end
+
+  # source://parser//lib/parser/source/tree_rewriter/action.rb#97
+  def with(range: T.unsafe(nil), enforcer: T.unsafe(nil), children: T.unsafe(nil), insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil)); end
+end
+
+# @api public
+#
+# source://parser//lib/parser/source/tree_rewriter.rb#356
+Parser::Source::TreeRewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
+
+# @api public
+#
+# source://parser//lib/parser/source/tree_rewriter.rb#417
+Parser::Source::TreeRewriter::POLICY_TO_LEVEL = T.let(T.unsafe(nil), Hash)
+
+# source://parser//lib/parser/static_environment.rb#5
+class Parser::StaticEnvironment
+  # @return [StaticEnvironment] a new instance of StaticEnvironment
+  #
+  # source://parser//lib/parser/static_environment.rb#17
+  def initialize; end
+
+  # source://parser//lib/parser/static_environment.rb#55
+  def declare(name); end
+
+  # Anonymous blockarg
+  #
+  # source://parser//lib/parser/static_environment.rb#77
+  def declare_anonymous_blockarg; end
+
+  # Anonymous kwresarg
+  #
+  # source://parser//lib/parser/static_environment.rb#113
+  def declare_anonymous_kwrestarg; end
+
+  # Anonymous restarg
+  #
+  # source://parser//lib/parser/static_environment.rb#95
+  def declare_anonymous_restarg; end
+
+  # Forward args
+  #
+  # source://parser//lib/parser/static_environment.rb#67
+  def declare_forward_args; end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/static_environment.rb#61
+  def declared?(name); end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/static_environment.rb#81
+  def declared_anonymous_blockarg?; end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/static_environment.rb#85
+  def declared_anonymous_blockarg_in_current_scpe?; end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/static_environment.rb#117
+  def declared_anonymous_kwrestarg?; end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/static_environment.rb#121
+  def declared_anonymous_kwrestarg_in_current_scope?; end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/static_environment.rb#99
+  def declared_anonymous_restarg?; end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/static_environment.rb#103
+  def declared_anonymous_restarg_in_current_scope?; end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/static_environment.rb#71
+  def declared_forward_args?; end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/static_environment.rb#129
+  def empty?; end
+
+  # source://parser//lib/parser/static_environment.rb#33
+  def extend_dynamic; end
+
+  # source://parser//lib/parser/static_environment.rb#26
+  def extend_static; end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/static_environment.rb#89
+  def parent_has_anonymous_blockarg?; end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/static_environment.rb#125
+  def parent_has_anonymous_kwrestarg?; end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/static_environment.rb#107
+  def parent_has_anonymous_restarg?; end
+
+  # source://parser//lib/parser/static_environment.rb#21
+  def reset; end
+
+  # source://parser//lib/parser/static_environment.rb#49
+  def unextend; end
+end
+
+# source://parser//lib/parser/static_environment.rb#15
+Parser::StaticEnvironment::ANONYMOUS_BLOCKARG_INHERITED = T.let(T.unsafe(nil), Symbol)
+
+# source://parser//lib/parser/static_environment.rb#14
+Parser::StaticEnvironment::ANONYMOUS_BLOCKARG_IN_CURRENT_SCOPE = T.let(T.unsafe(nil), Symbol)
+
+# source://parser//lib/parser/static_environment.rb#12
+Parser::StaticEnvironment::ANONYMOUS_KWRESTARG_INHERITED = T.let(T.unsafe(nil), Symbol)
+
+# source://parser//lib/parser/static_environment.rb#11
+Parser::StaticEnvironment::ANONYMOUS_KWRESTARG_IN_CURRENT_SCOPE = T.let(T.unsafe(nil), Symbol)
+
+# source://parser//lib/parser/static_environment.rb#9
+Parser::StaticEnvironment::ANONYMOUS_RESTARG_INHERITED = T.let(T.unsafe(nil), Symbol)
+
+# source://parser//lib/parser/static_environment.rb#8
+Parser::StaticEnvironment::ANONYMOUS_RESTARG_IN_CURRENT_SCOPE = T.let(T.unsafe(nil), Symbol)
+
+# source://parser//lib/parser/static_environment.rb#6
+Parser::StaticEnvironment::FORWARD_ARGS = T.let(T.unsafe(nil), Symbol)
+
+# {Parser::SyntaxError} is raised whenever parser detects a syntax error,
+# similar to the standard SyntaxError class.
+#
+# @api public
+#
+# source://parser//lib/parser/syntax_error.rb#13
+class Parser::SyntaxError < ::StandardError
+  # @api public
+  # @return [SyntaxError] a new instance of SyntaxError
+  #
+  # source://parser//lib/parser/syntax_error.rb#16
+  def initialize(diagnostic); end
+
+  # @api public
+  # @return [Parser::Diagnostic]
+  #
+  # source://parser//lib/parser/syntax_error.rb#14
+  def diagnostic; end
+end
+
+# {Parser::TreeRewriter} offers a basic API that makes it easy to rewrite
+# existing ASTs. It's built on top of {Parser::AST::Processor} and
+# {Parser::Source::TreeRewriter}
+#
+# For example, assume you want to remove `do` tokens from a while statement.
+# You can do this as following:
+#
+#     require 'parser/current'
+#
+#     class RemoveDo < Parser::TreeRewriter
+#       def on_while(node)
+#         # Check if the statement starts with "do"
+#         if node.location.begin.is?('do')
+#           remove(node.location.begin)
+#         end
+#       end
+#     end
+#
+#     code = <<-EOF
+#     while true do
+#       puts 'hello'
+#     end
+#     EOF
+#
+#     ast           = Parser::CurrentRuby.parse code
+#     buffer        = Parser::Source::Buffer.new('(example)', source: code)
+#     rewriter      = RemoveDo.new
+#
+#     # Rewrite the AST, returns a String with the new form.
+#     puts rewriter.rewrite(buffer, ast)
+#
+# This would result in the following Ruby code:
+#
+#     while true
+#       puts 'hello'
+#     end
+#
+# Keep in mind that {Parser::TreeRewriter} does not take care of indentation when
+# inserting/replacing code so you'll have to do this yourself.
+#
+# See also [a blog entry](http://whitequark.org/blog/2013/04/26/lets-play-with-ruby-code/)
+# describing rewriters in greater detail.
+#
+# @api public
+#
+# source://parser//lib/parser/tree_rewriter.rb#51
+class Parser::TreeRewriter < ::Parser::AST::Processor
+  # Returns `true` if the specified node is an assignment node, returns false
+  # otherwise.
+  #
+  # @api public
+  # @param node [Parser::AST::Node]
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/tree_rewriter.rb#79
+  def assignment?(node); end
+
+  # Inserts new code after the given source range.
+  #
+  # @api public
+  # @param range [Parser::Source::Range]
+  # @param content [String]
+  #
+  # source://parser//lib/parser/tree_rewriter.rb#118
+  def insert_after(range, content); end
+
+  # Inserts new code before the given source range.
+  #
+  # @api public
+  # @param range [Parser::Source::Range]
+  # @param content [String]
+  #
+  # source://parser//lib/parser/tree_rewriter.rb#108
+  def insert_before(range, content); end
+
+  # Removes the source range.
+  #
+  # @api public
+  # @param range [Parser::Source::Range]
+  #
+  # source://parser//lib/parser/tree_rewriter.rb#88
+  def remove(range); end
+
+  # Replaces the code of the source range `range` with `content`.
+  #
+  # @api public
+  # @param range [Parser::Source::Range]
+  # @param content [String]
+  #
+  # source://parser//lib/parser/tree_rewriter.rb#128
+  def replace(range, content); end
+
+  # Rewrites the AST/source buffer and returns a String containing the new
+  # version.
+  #
+  # @api public
+  # @param source_buffer [Parser::Source::Buffer]
+  # @param ast [Parser::AST::Node]
+  # @param crossing_deletions:, [Symbol] different_replacements:, swallowed_insertions:
+  #   policy arguments for TreeRewriter (optional)
+  # @return [String]
+  #
+  # source://parser//lib/parser/tree_rewriter.rb#62
+  def rewrite(source_buffer, ast, **policy); end
+
+  # Wraps the given source range with the given values.
+  #
+  # @api public
+  # @param range [Parser::Source::Range]
+  # @param content [String]
+  #
+  # source://parser//lib/parser/tree_rewriter.rb#98
+  def wrap(range, before, after); end
+end
+
+# {Parser::UnknownEncodingInMagicComment} is raised when a magic encoding
+# comment is encountered that the currently running Ruby version doesn't
+# recognize. It inherits from {ArgumentError} since that is the exception
+# Ruby itself raises when trying to execute a file with an unknown encoding.
+# As such, it is also not a {Parser::SyntaxError}.
+#
+# @api public
+#
+# source://parser//lib/parser/unknown_encoding_in_magic_comment_error.rb#13
+class Parser::UnknownEncodingInMagicComment < ::ArgumentError; end
+
+# source://parser//lib/parser/version.rb#4
+Parser::VERSION = T.let(T.unsafe(nil), String)
+
+# source://parser//lib/parser/variables_stack.rb#5
+class Parser::VariablesStack
+  # @return [VariablesStack] a new instance of VariablesStack
+  #
+  # source://parser//lib/parser/variables_stack.rb#6
+  def initialize; end
+
+  # source://parser//lib/parser/variables_stack.rb#27
+  def declare(name); end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/variables_stack.rb#31
+  def declared?(name); end
+
+  # @return [Boolean]
+  #
+  # source://parser//lib/parser/variables_stack.rb#11
+  def empty?; end
+
+  # source://parser//lib/parser/variables_stack.rb#19
+  def pop; end
+
+  # source://parser//lib/parser/variables_stack.rb#15
+  def push; end
+
+  # source://parser//lib/parser/variables_stack.rb#23
+  def reset; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/patchelf@1.3.0.rbi b/Library/Homebrew/sorbet/rbi/gems/patchelf@1.3.0.rbi
deleted file mode 100644
index be5c04a6ec010..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/patchelf@1.3.0.rbi
+++ /dev/null
@@ -1,133 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `patchelf` gem.
-# Please instead update this file by running `bin/tapioca gem patchelf`.
-
-module PatchELF; end
-
-module PatchELF::Helper
-  private
-
-  def aligndown(val, align = T.unsafe(nil)); end
-  def alignup(val, align = T.unsafe(nil)); end
-  def color_enabled?; end
-  def colorize(str, type); end
-
-  class << self
-    def aligndown(val, align = T.unsafe(nil)); end
-    def alignup(val, align = T.unsafe(nil)); end
-    def color_enabled?; end
-    def colorize(str, type); end
-  end
-end
-
-PatchELF::Helper::COLOR_CODE = T.let(T.unsafe(nil), Hash)
-PatchELF::Helper::PAGE_SIZE = T.let(T.unsafe(nil), Integer)
-
-module PatchELF::Logger
-  private
-
-  def debug(msg); end
-  def error(msg); end
-  def info(msg); end
-  def level=(msg); end
-  def warn(msg); end
-
-  class << self
-    def debug(msg); end
-    def error(msg); end
-    def info(msg); end
-    def level=(msg); end
-    def warn(msg); end
-  end
-end
-
-class PatchELF::MM
-  def initialize(elf); end
-
-  def dispatch!; end
-  def extend_size; end
-  def extended?; end
-  def extended_offset(off); end
-  def malloc(size, &block); end
-  def threshold; end
-
-  private
-
-  def abnormal_elf(msg); end
-  def extend_backward(seg, size = T.unsafe(nil)); end
-  def extend_forward(seg, size = T.unsafe(nil)); end
-  def fgap_method; end
-  def find_gap(check_sz: T.unsafe(nil)); end
-  def invoke_callbacks(seg, start); end
-  def load_segments; end
-  def mgap_method; end
-  def new_load_method; end
-  def shift_attributes; end
-  def writable?(seg); end
-end
-
-class PatchELF::MissingSegmentError < ::PatchELF::PatchError; end
-class PatchELF::MissingTagError < ::PatchELF::PatchError; end
-class PatchELF::PatchError < ::ELFTools::ELFError; end
-
-class PatchELF::Patcher
-  def initialize(filename, on_error: T.unsafe(nil), logging: T.unsafe(nil)); end
-
-  def add_needed(need); end
-  def elf; end
-  def interpreter; end
-  def interpreter=(interp); end
-  def needed; end
-  def needed=(needs); end
-  def remove_needed(need); end
-  def replace_needed(src, tar); end
-  def rpath; end
-  def rpath=(rpath); end
-  def runpath; end
-  def runpath=(runpath); end
-  def save(out_file = T.unsafe(nil), patchelf_compatible: T.unsafe(nil)); end
-  def soname; end
-  def soname=(name); end
-  def use_rpath!; end
-
-  private
-
-  def dirty?; end
-  def dynamic_or_log; end
-  def interpreter_; end
-  def log_or_raise(msg, exception = T.unsafe(nil)); end
-  def needed_; end
-  def runpath_(rpath_sym = T.unsafe(nil)); end
-  def soname_; end
-  def tag_name_or_log(type, log_msg); end
-end
-
-class PatchELF::Saver
-  def initialize(in_file, out_file, set); end
-
-  def in_file; end
-  def out_file; end
-  def save!; end
-
-  private
-
-  def dynamic; end
-  def expand_dynamic!; end
-  def inline_patch(off, str); end
-  def lazy_dyn(sym); end
-  def malloc_strtab!; end
-  def patch_dynamic; end
-  def patch_interpreter; end
-  def patch_needed; end
-  def patch_out(out_file); end
-  def patch_runpath(sym = T.unsafe(nil)); end
-  def patch_soname; end
-  def reg_str_table(str, &block); end
-  def section_header(name); end
-  def strtab_string; end
-end
-
-PatchELF::Saver::IGNORE = T.let(T.unsafe(nil), Integer)
-PatchELF::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/patchelf@1.5.1.rbi b/Library/Homebrew/sorbet/rbi/gems/patchelf@1.5.1.rbi
new file mode 100644
index 0000000000000..d829c17a48a78
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/patchelf@1.5.1.rbi
@@ -0,0 +1,589 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `patchelf` gem.
+# Please instead update this file by running `bin/tapioca gem patchelf`.
+
+# Main module of patchelf.
+#
+# @author david942j
+#
+# source://patchelf//lib/patchelf.rb#6
+module PatchELF; end
+
+# Helper methods for internal usage.
+#
+# source://patchelf//lib/patchelf/helper.rb#5
+module PatchELF::Helper
+  private
+
+  # @example
+  #   aligndown(0x1234)
+  #   #=> 4096
+  #   aligndown(0x33, 0x20)
+  #   #=> 32
+  #   aligndown(0x10, 0x8)
+  #   #=> 16
+  # @param val [Integer]
+  # @param align [Integer]
+  # @return [Integer] Aligned result.
+  #
+  # source://patchelf//lib/patchelf/helper.rb#65
+  def aligndown(val, align = T.unsafe(nil)); end
+
+  # @example
+  #   alignup(0x1234)
+  #   #=> 8192
+  #   alignup(0x33, 0x20)
+  #   #=> 64
+  #   alignup(0x10, 0x8)
+  #   #=> 16
+  # @param val [Integer]
+  # @param align [Integer]
+  # @return [Integer] Aligned result.
+  #
+  # source://patchelf//lib/patchelf/helper.rb#80
+  def alignup(val, align = T.unsafe(nil)); end
+
+  # For {#colorize} to decide if need add color codes.
+  #
+  # @return [Boolean]
+  #
+  # source://patchelf//lib/patchelf/helper.rb#50
+  def color_enabled?; end
+
+  # For wrapping string with color codes for prettier inspect.
+  #
+  # @param str [String] Content to colorize.
+  # @param type [Symbol] Specify which kind of color to use, valid symbols are defined in {.COLOR_CODE}.
+  # @return [String] String that wrapped with color codes.
+  #
+  # source://patchelf//lib/patchelf/helper.rb#40
+  def colorize(str, type); end
+
+  # The size of one page.
+  #
+  # source://patchelf//lib/patchelf/helper.rb#17
+  def page_size(e_machine = T.unsafe(nil)); end
+
+  class << self
+    # @example
+    #   aligndown(0x1234)
+    #   #=> 4096
+    #   aligndown(0x33, 0x20)
+    #   #=> 32
+    #   aligndown(0x10, 0x8)
+    #   #=> 16
+    # @param val [Integer]
+    # @param align [Integer]
+    # @return [Integer] Aligned result.
+    #
+    # source://patchelf//lib/patchelf/helper.rb#65
+    def aligndown(val, align = T.unsafe(nil)); end
+
+    # @example
+    #   alignup(0x1234)
+    #   #=> 8192
+    #   alignup(0x33, 0x20)
+    #   #=> 64
+    #   alignup(0x10, 0x8)
+    #   #=> 16
+    # @param val [Integer]
+    # @param align [Integer]
+    # @return [Integer] Aligned result.
+    #
+    # source://patchelf//lib/patchelf/helper.rb#80
+    def alignup(val, align = T.unsafe(nil)); end
+
+    # For {#colorize} to decide if need add color codes.
+    #
+    # @return [Boolean]
+    #
+    # source://patchelf//lib/patchelf/helper.rb#50
+    def color_enabled?; end
+
+    # For wrapping string with color codes for prettier inspect.
+    #
+    # @param str [String] Content to colorize.
+    # @param type [Symbol] Specify which kind of color to use, valid symbols are defined in {.COLOR_CODE}.
+    # @return [String] String that wrapped with color codes.
+    #
+    # source://patchelf//lib/patchelf/helper.rb#40
+    def colorize(str, type); end
+
+    # The size of one page.
+    #
+    # source://patchelf//lib/patchelf/helper.rb#17
+    def page_size(e_machine = T.unsafe(nil)); end
+  end
+end
+
+# Color codes for pretty print.
+#
+# source://patchelf//lib/patchelf/helper.rb#9
+PatchELF::Helper::COLOR_CODE = T.let(T.unsafe(nil), Hash)
+
+# A logger for internal usage.
+#
+# source://patchelf//lib/patchelf/logger.rb#9
+module PatchELF::Logger
+  private
+
+  # source://patchelf//lib/patchelf/logger.rb#19
+  def debug(msg); end
+
+  # source://patchelf//lib/patchelf/logger.rb#19
+  def error(msg); end
+
+  # source://patchelf//lib/patchelf/logger.rb#19
+  def info(msg); end
+
+  # source://patchelf//lib/patchelf/logger.rb#19
+  def level=(msg); end
+
+  # source://patchelf//lib/patchelf/logger.rb#19
+  def warn(msg); end
+
+  class << self
+    # source://patchelf//lib/patchelf/logger.rb#19
+    def debug(msg); end
+
+    # source://patchelf//lib/patchelf/logger.rb#19
+    def error(msg); end
+
+    # source://patchelf//lib/patchelf/logger.rb#19
+    def info(msg); end
+
+    # source://patchelf//lib/patchelf/logger.rb#19
+    def level=(msg); end
+
+    # source://patchelf//lib/patchelf/logger.rb#19
+    def warn(msg); end
+  end
+end
+
+# Memory management, provides malloc/free to allocate LOAD segments.
+#
+# @private
+#
+# source://patchelf//lib/patchelf/mm.rb#8
+class PatchELF::MM
+  # Instantiate a {MM} object.
+  #
+  # @param elf [ELFTools::ELFFile]
+  # @return [MM] a new instance of MM
+  #
+  # source://patchelf//lib/patchelf/mm.rb#14
+  def initialize(elf); end
+
+  # Let the malloc / free requests be effective.
+  #
+  # @return [void]
+  #
+  # source://patchelf//lib/patchelf/mm.rb#35
+  def dispatch!; end
+
+  # @return [Integer] The size extended.
+  #
+  # source://patchelf//lib/patchelf/mm.rb#9
+  def extend_size; end
+
+  # Query if extended.
+  #
+  # @return [Boolean]
+  #
+  # source://patchelf//lib/patchelf/mm.rb#57
+  def extended?; end
+
+  # Get correct offset after the extension.
+  #
+  # @param off [Integer]
+  # @return [Integer] Shifted offset.
+  #
+  # source://patchelf//lib/patchelf/mm.rb#66
+  def extended_offset(off); end
+
+  # @param size [Integer]
+  # @raise [ArgumentError]
+  # @return [void]
+  # @yieldparam off [Integer]
+  # @yieldparam vaddr [Integer]
+  # @yieldreturn [void] One can only do the following things in the block:
+  #   1. Set ELF headers' attributes (with ELFTools)
+  #   2. Invoke {Saver#inline_patch}
+  #
+  # source://patchelf//lib/patchelf/mm.rb#27
+  def malloc(size, &block); end
+
+  # @return [Integer] Where the file start to be extended.
+  #
+  # source://patchelf//lib/patchelf/mm.rb#10
+  def threshold; end
+
+  private
+
+  # @raise [ArgumentError]
+  #
+  # source://patchelf//lib/patchelf/mm.rb#182
+  def abnormal_elf(msg); end
+
+  # source://patchelf//lib/patchelf/mm.rb#86
+  def extend_backward(seg, size = T.unsafe(nil)); end
+
+  # source://patchelf//lib/patchelf/mm.rb#93
+  def extend_forward(seg, size = T.unsafe(nil)); end
+
+  # source://patchelf//lib/patchelf/mm.rb#75
+  def fgap_method; end
+
+  # source://patchelf//lib/patchelf/mm.rb#122
+  def find_gap(check_sz: T.unsafe(nil)); end
+
+  # source://patchelf//lib/patchelf/mm.rb#174
+  def invoke_callbacks(seg, start); end
+
+  # source://patchelf//lib/patchelf/mm.rb#170
+  def load_segments; end
+
+  # source://patchelf//lib/patchelf/mm.rb#102
+  def mgap_method; end
+
+  # TODO
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://patchelf//lib/patchelf/mm.rb#138
+  def new_load_method; end
+
+  # For all attributes >= threshold, += offset
+  #
+  # source://patchelf//lib/patchelf/mm.rb#147
+  def shift_attributes; end
+
+  # @return [Boolean]
+  #
+  # source://patchelf//lib/patchelf/mm.rb#142
+  def writable?(seg); end
+end
+
+# Raised on missing Program Header(segment)
+#
+# source://patchelf//lib/patchelf/exceptions.rb#14
+class PatchELF::MissingSegmentError < ::PatchELF::PatchError; end
+
+# Raised when Dynamic Tag is missing
+#
+# source://patchelf//lib/patchelf/exceptions.rb#11
+class PatchELF::MissingTagError < ::PatchELF::PatchError; end
+
+# Raised on an error during ELF modification.
+#
+# source://patchelf//lib/patchelf/exceptions.rb#8
+class PatchELF::PatchError < ::ELFTools::ELFError; end
+
+# Class to handle all patching things.
+#
+# source://patchelf//lib/patchelf/patcher.rb#12
+class PatchELF::Patcher
+  # Instantiate a {Patcher} object.
+  #
+  # @param filename [String] Filename of input ELF.
+  # @param logging [Boolean] *deprecated*: use +on_error+ instead
+  # @param on_error [:log, :silent, :exception] action when the desired segment/tag field isn't present
+  #   :log = logs to stderr
+  #   :exception = raise exception related to the error
+  #   :silent = ignore the errors
+  # @raise [ArgumentError]
+  # @return [Patcher] a new instance of Patcher
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#28
+  def initialize(filename, on_error: T.unsafe(nil), logging: T.unsafe(nil)); end
+
+  # Add the needed library.
+  #
+  # @note This setting will be saved after {#save} being invoked.
+  # @param need [String]
+  # @return [void]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#81
+  def add_needed(need); end
+
+  # @note This setting will be saved after {#save} being invoked.
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#16
+  def elf; end
+
+  # @example
+  #   PatchELF::Patcher.new('/bin/ls').interpreter
+  #   #=> "/lib64/ld-linux-x86-64.so.2"
+  # @return [String?] Get interpreter's name.
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#44
+  def interpreter; end
+
+  # Set interpreter's name.
+  #
+  # If the input ELF has no existent interpreter,
+  # this method will show a warning and has no effect.
+  #
+  # @note This setting will be saved after {#save} being invoked.
+  # @param interp [String]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#54
+  def interpreter=(interp); end
+
+  # Get needed libraries.
+  #
+  # @example
+  #   patcher = PatchELF::Patcher.new('/bin/ls')
+  #   patcher.needed
+  #   #=> ["libselinux.so.1", "libc.so.6"]
+  # @return [Array<String>]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#66
+  def needed; end
+
+  # Set needed libraries.
+  #
+  # @note This setting will be saved after {#save} being invoked.
+  # @param needs [Array<String>]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#73
+  def needed=(needs); end
+
+  # Remove the needed library.
+  #
+  # @note This setting will be saved after {#save} being invoked.
+  # @param need [String]
+  # @return [void]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#90
+  def remove_needed(need); end
+
+  # Replace needed library +src+ with +tar+.
+  #
+  # @note This setting will be saved after {#save} being invoked.
+  # @param src [String] Library to be replaced.
+  # @param tar [String] Library replace with.
+  # @return [void]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#103
+  def replace_needed(src, tar); end
+
+  # Get rpath
+  # return [String?]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#142
+  def rpath; end
+
+  # Set rpath
+  #
+  # Modify / set DT_RPATH of the given ELF.
+  # similar to runpath= except DT_RPATH is modifed/created in DYNAMIC segment.
+  #
+  # @note This setting will be saved after {#save} being invoked.
+  # @param rpath [String]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#152
+  def rpath=(rpath); end
+
+  # Get runpath.
+  #
+  # @return [String?]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#136
+  def runpath; end
+
+  # Set runpath.
+  #
+  # If DT_RUNPATH is not presented in the input ELF,
+  # a new DT_RUNPATH attribute will be inserted into the DYNAMIC segment.
+  #
+  # @note This setting will be saved after {#save} being invoked.
+  # @param runpath [String]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#162
+  def runpath=(runpath); end
+
+  # Save the patched ELF as +out_file+.
+  #
+  # @param out_file [String?] If +out_file+ is +nil+, the original input file will be modified.
+  # @param patchelf_compatible [Boolean] When +patchelf_compatible+ is true, tries to produce same ELF as the one produced by NixOS/patchelf.
+  # @return [void]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#179
+  def save(out_file = T.unsafe(nil), patchelf_compatible: T.unsafe(nil)); end
+
+  # Get the soname of a shared library.
+  #
+  # @example
+  #   patcher = PatchELF::Patcher.new('/bin/ls')
+  #   patcher.soname
+  #   # [WARN] Entry DT_SONAME not found, not a shared library?
+  #   #=> nil
+  # @example
+  #   PatchELF::Patcher.new('/lib/x86_64-linux-gnu/libc.so.6').soname
+  #   #=> "libc.so.6"
+  # @return [String?] The name.
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#118
+  def soname; end
+
+  # Set soname.
+  #
+  # If the input ELF is not a shared library with a soname,
+  # this method will show a warning and has no effect.
+  #
+  # @note This setting will be saved after {#save} being invoked.
+  # @param name [String]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#128
+  def soname=(name); end
+
+  # Set all operations related to DT_RUNPATH to use DT_RPATH.
+  #
+  # @return [self]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#168
+  def use_rpath!; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#228
+  def dirty?; end
+
+  # source://patchelf//lib/patchelf/patcher.rb#242
+  def dynamic_or_log; end
+
+  # source://patchelf//lib/patchelf/patcher.rb#202
+  def interpreter_; end
+
+  # @raise [exception]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#196
+  def log_or_raise(msg, exception = T.unsafe(nil)); end
+
+  # @return [Array<String>]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#210
+  def needed_; end
+
+  # @return [String?]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#218
+  def runpath_(rpath_sym = T.unsafe(nil)); end
+
+  # @return [String?]
+  #
+  # source://patchelf//lib/patchelf/patcher.rb#223
+  def soname_; end
+
+  # source://patchelf//lib/patchelf/patcher.rb#232
+  def tag_name_or_log(type, log_msg); end
+end
+
+# Internal use only.
+#
+# For {Patcher} to do patching things and save to file.
+#
+# @private
+#
+# source://patchelf//lib/patchelf/saver.rb#16
+class PatchELF::Saver
+  # Instantiate a {Saver} object.
+  #
+  # @param in_file [String]
+  # @param out_file [String]
+  # @param set [{Symbol => String, Array}]
+  # @return [Saver] a new instance of Saver
+  #
+  # source://patchelf//lib/patchelf/saver.rb#24
+  def initialize(in_file, out_file, set); end
+
+  # @return [String] Input filename.
+  #
+  # source://patchelf//lib/patchelf/saver.rb#17
+  def in_file; end
+
+  # @return [String] Output filename.
+  #
+  # source://patchelf//lib/patchelf/saver.rb#18
+  def out_file; end
+
+  # @return [void]
+  #
+  # source://patchelf//lib/patchelf/saver.rb#37
+  def save!; end
+
+  private
+
+  # source://patchelf//lib/patchelf/saver.rb#278
+  def dynamic; end
+
+  # source://patchelf//lib/patchelf/saver.rb#158
+  def expand_dynamic!; end
+
+  # This can only be used for patching interpreter's name
+  # or set strings in a malloc-ed area.
+  # i.e. NEVER intend to change the string defined in strtab
+  #
+  # source://patchelf//lib/patchelf/saver.rb#238
+  def inline_patch(off, str); end
+
+  # Create a temp tag header.
+  #
+  # @return [ELFTools::Structs::ELF_Dyn]
+  #
+  # source://patchelf//lib/patchelf/saver.rb#150
+  def lazy_dyn(sym); end
+
+  # source://patchelf//lib/patchelf/saver.rb#179
+  def malloc_strtab!; end
+
+  # source://patchelf//lib/patchelf/saver.rb#88
+  def patch_dynamic; end
+
+  # source://patchelf//lib/patchelf/saver.rb#53
+  def patch_interpreter; end
+
+  # source://patchelf//lib/patchelf/saver.rb#121
+  def patch_needed; end
+
+  # Modify the out_file according to registered patches.
+  #
+  # source://patchelf//lib/patchelf/saver.rb#243
+  def patch_out(out_file); end
+
+  # source://patchelf//lib/patchelf/saver.rb#111
+  def patch_runpath(sym = T.unsafe(nil)); end
+
+  # source://patchelf//lib/patchelf/saver.rb#103
+  def patch_soname; end
+
+  # @param str [String]
+  # @yieldparam idx [Integer]
+  # @yieldreturn [void]
+  #
+  # source://patchelf//lib/patchelf/saver.rb#208
+  def reg_str_table(str, &block); end
+
+  # @return [ELFTools::Sections::Section?]
+  #
+  # source://patchelf//lib/patchelf/saver.rb#271
+  def section_header(name); end
+
+  # source://patchelf//lib/patchelf/saver.rb#217
+  def strtab_string; end
+end
+
+# To mark a not-using tag
+#
+# source://patchelf//lib/patchelf/saver.rb#120
+PatchELF::Saver::IGNORE = T.let(T.unsafe(nil), Integer)
+
+# Current gem version.
+#
+# source://patchelf//lib/patchelf/version.rb#5
+PatchELF::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/plist@3.6.0.rbi b/Library/Homebrew/sorbet/rbi/gems/plist@3.6.0.rbi
deleted file mode 100644
index 4e521bb855d55..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/plist@3.6.0.rbi
+++ /dev/null
@@ -1,129 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `plist` gem.
-# Please instead update this file by running `bin/tapioca gem plist`.
-
-module Plist
-  class << self
-    def parse_xml(filename_or_xml); end
-  end
-end
-
-module Plist::Emit
-  def save_plist(filename, options = T.unsafe(nil)); end
-  def to_plist(envelope = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  class << self
-    def dump(obj, envelope = T.unsafe(nil), options = T.unsafe(nil)); end
-    def save_plist(obj, filename, options = T.unsafe(nil)); end
-    def wrap(contents); end
-  end
-end
-
-Plist::Emit::DEFAULT_INDENT = T.let(T.unsafe(nil), String)
-
-class Plist::Emit::PlistBuilder
-  def initialize(indent_str); end
-
-  def build(element, level = T.unsafe(nil)); end
-
-  private
-
-  def comment_tag(content); end
-  def data_tag(data, level); end
-  def element_type(item); end
-  def indent(str, level); end
-  def tag(type, contents, level, &block); end
-end
-
-class Plist::Listener
-  def initialize; end
-
-  def open; end
-  def open=(_arg0); end
-  def result; end
-  def result=(_arg0); end
-  def tag_end(name); end
-  def tag_start(name, attributes); end
-  def text(contents); end
-end
-
-class Plist::PArray < ::Plist::PTag
-  def to_ruby; end
-end
-
-class Plist::PData < ::Plist::PTag
-  def to_ruby; end
-end
-
-class Plist::PDate < ::Plist::PTag
-  def to_ruby; end
-end
-
-class Plist::PDict < ::Plist::PTag
-  def to_ruby; end
-end
-
-class Plist::PFalse < ::Plist::PTag
-  def to_ruby; end
-end
-
-class Plist::PInteger < ::Plist::PTag
-  def to_ruby; end
-end
-
-class Plist::PKey < ::Plist::PTag
-  def to_ruby; end
-end
-
-class Plist::PList < ::Plist::PTag
-  def to_ruby; end
-end
-
-class Plist::PReal < ::Plist::PTag
-  def to_ruby; end
-end
-
-class Plist::PString < ::Plist::PTag
-  def to_ruby; end
-end
-
-class Plist::PTag
-  def initialize; end
-
-  def children; end
-  def children=(_arg0); end
-  def text; end
-  def text=(_arg0); end
-  def to_ruby; end
-
-  class << self
-    def inherited(sub_class); end
-    def mappings; end
-  end
-end
-
-class Plist::PTrue < ::Plist::PTag
-  def to_ruby; end
-end
-
-class Plist::StreamParser
-  def initialize(plist_data_or_file, listener); end
-
-  def parse; end
-
-  private
-
-  def parse_encoding_from_xml_declaration(xml_declaration); end
-end
-
-Plist::StreamParser::CDATA = T.let(T.unsafe(nil), Regexp)
-Plist::StreamParser::COMMENT_END = T.let(T.unsafe(nil), Regexp)
-Plist::StreamParser::COMMENT_START = T.let(T.unsafe(nil), Regexp)
-Plist::StreamParser::DOCTYPE_PATTERN = T.let(T.unsafe(nil), Regexp)
-Plist::StreamParser::TEXT = T.let(T.unsafe(nil), Regexp)
-Plist::StreamParser::UNIMPLEMENTED_ERROR = T.let(T.unsafe(nil), String)
-Plist::StreamParser::XMLDECL_PATTERN = T.let(T.unsafe(nil), Regexp)
-class Plist::UnimplementedElementError < ::RuntimeError; end
-Plist::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/plist@3.7.1.rbi b/Library/Homebrew/sorbet/rbi/gems/plist@3.7.1.rbi
new file mode 100644
index 0000000000000..bff5bc5f900f5
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/plist@3.7.1.rbi
@@ -0,0 +1,334 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `plist` gem.
+# Please instead update this file by running `bin/tapioca gem plist`.
+
+# source://plist//lib/plist/generator.rb#172
+class Array
+  include ::Enumerable
+  include ::Plist::Emit
+end
+
+# source://plist//lib/plist/generator.rb#176
+class Hash
+  include ::Enumerable
+  include ::Plist::Emit
+end
+
+# Plist parses Mac OS X xml property list files into ruby data structures.
+#
+# === Load a plist file
+# This is the main point of the library:
+#
+#   r = Plist.parse_xml(filename_or_xml)
+#
+# source://plist//lib/plist/generator.rb#9
+module Plist
+  class << self
+    # Note that I don't use these two elements much:
+    #
+    #  + Date elements are returned as DateTime objects.
+    #  + Data elements are implemented as Tempfiles
+    #
+    # Plist.parse_xml will blow up if it encounters a Date element.
+    # If you encounter such an error, or if you have a Date element which
+    # can't be parsed into a Time object, please create an issue
+    # attaching your plist file at https://github.com/patsplat/plist/issues
+    # so folks can implement the proper support.
+    #
+    # By default, <data> will be assumed to be a marshaled Ruby object and
+    # interpreted with <tt>Marshal.load</tt>. Pass <tt>marshal: false</tt>
+    # to disable this behavior and return the raw binary data as an IO
+    # object instead.
+    #
+    # source://plist//lib/plist/parser.rb#34
+    def parse_xml(filename_or_xml, options = T.unsafe(nil)); end
+  end
+end
+
+# === Create a plist
+# You can dump an object to a plist in one of two ways:
+#
+# * <tt>Plist::Emit.dump(obj)</tt>
+# * <tt>obj.to_plist</tt>
+#   * This requires that you mixin the <tt>Plist::Emit</tt> module, which is already done for +Array+ and +Hash+.
+#
+# The following Ruby classes are converted into native plist types:
+#   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time, true, false
+# * +Array+ and +Hash+ are both recursive; their elements will be converted into plist nodes inside the <array> and <dict> containers (respectively).
+# * +IO+ (and its descendants) and +StringIO+ objects are read from and their contents placed in a <data> element.
+# * User classes may implement +to_plist_node+ to dictate how they should be serialized; otherwise the object will be passed to <tt>Marshal.dump</tt> and the result placed in a <data> element.
+#
+# For detailed usage instructions, refer to USAGE[link:files/docs/USAGE.html] and the methods documented below.
+#
+# source://plist//lib/plist/generator.rb#24
+module Plist::Emit
+  # Helper method for injecting into classes.  Calls <tt>Plist::Emit.save_plist</tt> with +self+.
+  #
+  # source://plist//lib/plist/generator.rb#33
+  def save_plist(filename, options = T.unsafe(nil)); end
+
+  # Helper method for injecting into classes.  Calls <tt>Plist::Emit.dump</tt> with +self+.
+  #
+  # source://plist//lib/plist/generator.rb#28
+  def to_plist(envelope = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  class << self
+    # The following Ruby classes are converted into native plist types:
+    #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time
+    #
+    # Write us (via RubyForge) if you think another class can be coerced safely into one of the expected plist classes.
+    #
+    # +IO+ and +StringIO+ objects are encoded and placed in <data> elements; other objects are <tt>Marshal.dump</tt>'ed unless they implement +to_plist_node+.
+    #
+    # The +envelope+ parameters dictates whether or not the resultant plist fragment is wrapped in the normal XML/plist header and footer.  Set it to false if you only want the fragment.
+    #
+    # source://plist//lib/plist/generator.rb#45
+    def dump(obj, envelope = T.unsafe(nil), options = T.unsafe(nil)); end
+
+    # Writes the serialized object's plist to the specified filename.
+    #
+    # source://plist//lib/plist/generator.rb#55
+    def save_plist(obj, filename, options = T.unsafe(nil)); end
+
+    # source://plist//lib/plist/generator.rb#160
+    def wrap(contents); end
+  end
+end
+
+# source://plist//lib/plist/generator.rb#25
+Plist::Emit::DEFAULT_INDENT = T.let(T.unsafe(nil), String)
+
+# source://plist//lib/plist/generator.rb#63
+class Plist::Emit::PlistBuilder
+  # @return [PlistBuilder] a new instance of PlistBuilder
+  #
+  # source://plist//lib/plist/generator.rb#64
+  def initialize(indent_str); end
+
+  # source://plist//lib/plist/generator.rb#68
+  def build(element, level = T.unsafe(nil)); end
+
+  private
+
+  # source://plist//lib/plist/generator.rb#155
+  def comment_tag(content); end
+
+  # source://plist//lib/plist/generator.rb#125
+  def data_tag(data, level); end
+
+  # source://plist//lib/plist/generator.rb#142
+  def element_type(item); end
+
+  # source://plist//lib/plist/generator.rb#138
+  def indent(str, level); end
+
+  # source://plist//lib/plist/generator.rb#113
+  def tag(type, contents, level, &block); end
+end
+
+# source://plist//lib/plist/parser.rb#42
+class Plist::Listener
+  # @return [Listener] a new instance of Listener
+  #
+  # source://plist//lib/plist/parser.rb#47
+  def initialize(options = T.unsafe(nil)); end
+
+  # include REXML::StreamListener
+  #
+  # source://plist//lib/plist/parser.rb#45
+  def open; end
+
+  # include REXML::StreamListener
+  #
+  # source://plist//lib/plist/parser.rb#45
+  def open=(_arg0); end
+
+  # include REXML::StreamListener
+  #
+  # source://plist//lib/plist/parser.rb#45
+  def result; end
+
+  # include REXML::StreamListener
+  #
+  # source://plist//lib/plist/parser.rb#45
+  def result=(_arg0); end
+
+  # source://plist//lib/plist/parser.rb#64
+  def tag_end(name); end
+
+  # source://plist//lib/plist/parser.rb#53
+  def tag_start(name, attributes); end
+
+  # source://plist//lib/plist/parser.rb#57
+  def text(contents); end
+end
+
+# source://plist//lib/plist/parser.rb#210
+class Plist::PArray < ::Plist::PTag
+  # source://plist//lib/plist/parser.rb#211
+  def to_ruby; end
+end
+
+# source://plist//lib/plist/parser.rb#249
+class Plist::PData < ::Plist::PTag
+  # source://plist//lib/plist/parser.rb#250
+  def to_ruby; end
+end
+
+# source://plist//lib/plist/parser.rb#243
+class Plist::PDate < ::Plist::PTag
+  # source://plist//lib/plist/parser.rb#244
+  def to_ruby; end
+end
+
+# source://plist//lib/plist/parser.rb#180
+class Plist::PDict < ::Plist::PTag
+  # source://plist//lib/plist/parser.rb#181
+  def to_ruby; end
+end
+
+# source://plist//lib/plist/parser.rb#230
+class Plist::PFalse < ::Plist::PTag
+  # source://plist//lib/plist/parser.rb#231
+  def to_ruby; end
+end
+
+# source://plist//lib/plist/parser.rb#218
+class Plist::PInteger < ::Plist::PTag
+  # source://plist//lib/plist/parser.rb#219
+  def to_ruby; end
+end
+
+# source://plist//lib/plist/parser.rb#198
+class Plist::PKey < ::Plist::PTag
+  # source://plist//lib/plist/parser.rb#199
+  def to_ruby; end
+end
+
+# source://plist//lib/plist/parser.rb#174
+class Plist::PList < ::Plist::PTag
+  # source://plist//lib/plist/parser.rb#175
+  def to_ruby; end
+end
+
+# source://plist//lib/plist/parser.rb#236
+class Plist::PReal < ::Plist::PTag
+  # source://plist//lib/plist/parser.rb#237
+  def to_ruby; end
+end
+
+# source://plist//lib/plist/parser.rb#204
+class Plist::PString < ::Plist::PTag
+  # source://plist//lib/plist/parser.rb#205
+  def to_ruby; end
+end
+
+# source://plist//lib/plist/parser.rb#150
+class Plist::PTag
+  # @return [PTag] a new instance of PTag
+  #
+  # source://plist//lib/plist/parser.rb#164
+  def initialize(options); end
+
+  # Returns the value of attribute children.
+  #
+  # source://plist//lib/plist/parser.rb#163
+  def children; end
+
+  # Sets the attribute children
+  #
+  # @param value the value to set the attribute children to.
+  #
+  # source://plist//lib/plist/parser.rb#163
+  def children=(_arg0); end
+
+  # Returns the value of attribute options.
+  #
+  # source://plist//lib/plist/parser.rb#163
+  def options; end
+
+  # Sets the attribute options
+  #
+  # @param value the value to set the attribute options to.
+  #
+  # source://plist//lib/plist/parser.rb#163
+  def options=(_arg0); end
+
+  # Returns the value of attribute text.
+  #
+  # source://plist//lib/plist/parser.rb#163
+  def text; end
+
+  # Sets the attribute text
+  #
+  # @param value the value to set the attribute text to.
+  #
+  # source://plist//lib/plist/parser.rb#163
+  def text=(_arg0); end
+
+  # source://plist//lib/plist/parser.rb#169
+  def to_ruby; end
+
+  class << self
+    # @private
+    #
+    # source://plist//lib/plist/parser.rb#155
+    def inherited(sub_class); end
+
+    # source://plist//lib/plist/parser.rb#151
+    def mappings; end
+  end
+end
+
+# source://plist//lib/plist/parser.rb#224
+class Plist::PTrue < ::Plist::PTag
+  # source://plist//lib/plist/parser.rb#225
+  def to_ruby; end
+end
+
+# source://plist//lib/plist/parser.rb#74
+class Plist::StreamParser
+  # @return [StreamParser] a new instance of StreamParser
+  #
+  # source://plist//lib/plist/parser.rb#75
+  def initialize(plist_data_or_file, listener); end
+
+  # source://plist//lib/plist/parser.rb#96
+  def parse; end
+
+  private
+
+  # source://plist//lib/plist/parser.rb#135
+  def parse_encoding_from_xml_declaration(xml_declaration); end
+end
+
+# source://plist//lib/plist/parser.rb#88
+Plist::StreamParser::CDATA = T.let(T.unsafe(nil), Regexp)
+
+# source://plist//lib/plist/parser.rb#92
+Plist::StreamParser::COMMENT_END = T.let(T.unsafe(nil), Regexp)
+
+# source://plist//lib/plist/parser.rb#91
+Plist::StreamParser::COMMENT_START = T.let(T.unsafe(nil), Regexp)
+
+# source://plist//lib/plist/parser.rb#90
+Plist::StreamParser::DOCTYPE_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# source://plist//lib/plist/parser.rb#87
+Plist::StreamParser::TEXT = T.let(T.unsafe(nil), Regexp)
+
+# source://plist//lib/plist/parser.rb#93
+Plist::StreamParser::UNIMPLEMENTED_ERROR = T.let(T.unsafe(nil), String)
+
+# source://plist//lib/plist/parser.rb#89
+Plist::StreamParser::XMLDECL_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# Raised when an element is not implemented
+#
+# source://plist//lib/plist/parser.rb#17
+class Plist::UnimplementedElementError < ::RuntimeError; end
+
+# source://plist//lib/plist/version.rb#4
+Plist::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/prism@1.2.0.rbi b/Library/Homebrew/sorbet/rbi/gems/prism@1.2.0.rbi
new file mode 100644
index 0000000000000..c6c606d9dab62
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/prism@1.2.0.rbi
@@ -0,0 +1,39085 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `prism` gem.
+# Please instead update this file by running `bin/tapioca gem prism`.
+
+
+# typed: strict
+
+# =begin
+# This file is generated by the templates/template.rb script and should not be
+# modified manually. See templates/rbi/prism/dsl.rbi.erb
+# if you are looking to modify the template
+# =end
+# =begin
+# This file is generated by the templates/template.rb script and should not be
+# modified manually. See templates/rbi/prism/node.rbi.erb
+# if you are looking to modify the template
+# =end
+# =begin
+# This file is generated by the templates/template.rb script and should not be
+# modified manually. See templates/rbi/prism/visitor.rbi.erb
+# if you are looking to modify the template
+# =end
+
+# We keep these shims in here because our client libraries might not have parser
+# in their bundle.
+module Parser; end
+
+class Parser::Base; end
+
+# The Prism Ruby parser.
+#
+# "Parsing Ruby is suddenly manageable!"
+#   - You, hopefully
+#
+# source://prism//lib/prism.rb#8
+module Prism
+  class << self
+    # Mirror the Prism.dump API by using the serialization API.
+    def dump(*_arg0); end
+
+    # Mirror the Prism.dump_file API by using the serialization API.
+    def dump_file(*_arg0); end
+
+    # Mirror the Prism.lex API by using the serialization API.
+    def lex(*_arg0); end
+
+    # :call-seq:
+    #   Prism::lex_compat(source, **options) -> LexCompat::Result
+    #
+    # Returns a parse result whose value is an array of tokens that closely
+    # resembles the return value of Ripper::lex. The main difference is that the
+    # `:on_sp` token is not emitted.
+    #
+    # For supported options, see Prism::parse.
+    #
+    # source://prism//lib/prism.rb#45
+    sig { params(source: String, options: T::Hash[Symbol, T.untyped]).returns(Prism::LexCompat::Result) }
+    def lex_compat(source, **options); end
+
+    # Mirror the Prism.lex_file API by using the serialization API.
+    def lex_file(*_arg0); end
+
+    # :call-seq:
+    #   Prism::lex_ripper(source) -> Array
+    #
+    # This lexes with the Ripper lex. It drops any space events but otherwise
+    # returns the same tokens. Raises SyntaxError if the syntax in source is
+    # invalid.
+    #
+    # source://prism//lib/prism.rb#55
+    sig { params(source: String).returns(T::Array[T.untyped]) }
+    def lex_ripper(source); end
+
+    # :call-seq:
+    #   Prism::load(source, serialized) -> ParseResult
+    #
+    # Load the serialized AST using the source as a reference into a tree.
+    #
+    # source://prism//lib/prism.rb#63
+    sig { params(source: String, serialized: String).returns(Prism::ParseResult) }
+    def load(source, serialized); end
+
+    # Mirror the Prism.parse API by using the serialization API.
+    def parse(*_arg0); end
+
+    # Mirror the Prism.parse_comments API by using the serialization API.
+    def parse_comments(*_arg0); end
+
+    # Mirror the Prism.parse_failure? API by using the serialization API.
+    #
+    # @return [Boolean]
+    def parse_failure?(*_arg0); end
+
+    # Mirror the Prism.parse_file API by using the serialization API. This uses
+    # native strings instead of Ruby strings because it allows us to use mmap
+    # when it is available.
+    def parse_file(*_arg0); end
+
+    # Mirror the Prism.parse_file_comments API by using the serialization
+    # API. This uses native strings instead of Ruby strings because it allows us
+    # to use mmap when it is available.
+    def parse_file_comments(*_arg0); end
+
+    # Mirror the Prism.parse_file_failure? API by using the serialization API.
+    #
+    # @return [Boolean]
+    def parse_file_failure?(*_arg0); end
+
+    # Mirror the Prism.parse_file_success? API by using the serialization API.
+    #
+    # @return [Boolean]
+    def parse_file_success?(*_arg0); end
+
+    # Mirror the Prism.parse_lex API by using the serialization API.
+    def parse_lex(*_arg0); end
+
+    # Mirror the Prism.parse_lex_file API by using the serialization API.
+    def parse_lex_file(*_arg0); end
+
+    # Mirror the Prism.parse_stream API by using the serialization API.
+    def parse_stream(*_arg0); end
+
+    # Mirror the Prism.parse_success? API by using the serialization API.
+    #
+    # @return [Boolean]
+    def parse_success?(*_arg0); end
+
+    # Mirror the Prism.profile API by using the serialization API.
+    def profile(*_arg0); end
+
+    # Mirror the Prism.profile_file API by using the serialization API.
+    def profile_file(*_arg0); end
+  end
+end
+
+# Specialized version of Prism::Source for source code that includes ASCII
+# characters only. This class is used to apply performance optimizations that
+# cannot be applied to sources that include multibyte characters.
+#
+# In the extremely rare case that a source includes multi-byte characters but
+# is marked as binary because of a magic encoding comment and it cannot be
+# eagerly converted to UTF-8, this class will be used as well. This is because
+# at that point we will treat everything as single-byte characters.
+#
+# source://prism//lib/prism/parse_result.rb#236
+class Prism::ASCIISource < ::Prism::Source
+  # Return the column number in characters for the given byte offset.
+  #
+  # source://prism//lib/prism/parse_result.rb#243
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def character_column(byte_offset); end
+
+  # Return the character offset for the given byte offset.
+  #
+  # source://prism//lib/prism/parse_result.rb#238
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def character_offset(byte_offset); end
+
+  # Returns a cache that is the identity function in order to maintain the
+  # same interface. We can do this because code units are always equivalent to
+  # byte offsets for ASCII-only sources.
+  #
+  # source://prism//lib/prism/parse_result.rb#260
+  sig do
+    params(
+      encoding: Encoding
+    ).returns(T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer)))
+  end
+  def code_units_cache(encoding); end
+
+  # Specialized version of `code_units_column` that does not depend on
+  # `code_units_offset`, which is a more expensive operation. This is
+  # essentially the same as `Prism::Source#column`.
+  #
+  # source://prism//lib/prism/parse_result.rb#267
+  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
+  def code_units_column(byte_offset, encoding); end
+
+  # Returns the offset from the start of the file for the given byte offset
+  # counting in code units for the given encoding.
+  #
+  # This method is tested with UTF-8, UTF-16, and UTF-32. If there is the
+  # concept of code units that differs from the number of characters in other
+  # encodings, it is not captured here.
+  #
+  # source://prism//lib/prism/parse_result.rb#253
+  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
+  def code_units_offset(byte_offset, encoding); end
+end
+
+# Represents the use of the `alias` keyword to alias a global variable.
+#
+#     alias $foo $bar
+#     ^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#227
+class Prism::AliasGlobalVariableNode < ::Prism::Node
+  # Initialize a new AliasGlobalVariableNode node.
+  #
+  # @return [AliasGlobalVariableNode] a new instance of AliasGlobalVariableNode
+  #
+  # source://prism//lib/prism/node.rb#229
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      new_name: T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode),
+      old_name: T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::SymbolNode, Prism::MissingNode),
+      keyword_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, new_name, old_name, keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#316
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#240
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#245
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#255
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#250
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?new_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode, ?old_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode, ?keyword_loc: Location) -> AliasGlobalVariableNode
+  #
+  # source://prism//lib/prism/node.rb#260
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      new_name: T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode),
+      old_name: T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::SymbolNode, Prism::MissingNode),
+      keyword_loc: Prism::Location
+    ).returns(Prism::AliasGlobalVariableNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#245
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, new_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode, old_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode, keyword_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#268
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#300
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#295
+  sig { returns(String) }
+  def keyword; end
+
+  # The location of the `alias` keyword.
+  #
+  #     alias $foo $bar
+  #     ^^^^^
+  #
+  # source://prism//lib/prism/node.rb#288
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # Represents the new name of the global variable that can be used after aliasing.
+  #
+  #     alias $foo $bar
+  #           ^^^^
+  #
+  # source://prism//lib/prism/node.rb#276
+  sig { returns(T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)) }
+  def new_name; end
+
+  # Represents the old name of the global variable that can be used before aliasing.
+  #
+  #     alias $foo $bar
+  #                ^^^^
+  #
+  # source://prism//lib/prism/node.rb#282
+  sig do
+    returns(T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::SymbolNode, Prism::MissingNode))
+  end
+  def old_name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#305
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#310
+    def type; end
+  end
+end
+
+# Represents the use of the `alias` keyword to alias a method.
+#
+#     alias foo bar
+#     ^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#328
+class Prism::AliasMethodNode < ::Prism::Node
+  # Initialize a new AliasMethodNode node.
+  #
+  # @return [AliasMethodNode] a new instance of AliasMethodNode
+  #
+  # source://prism//lib/prism/node.rb#330
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      new_name: T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode),
+      old_name: T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode, Prism::GlobalVariableReadNode, Prism::MissingNode),
+      keyword_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, new_name, old_name, keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#426
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#341
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#346
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#356
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#351
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?new_name: SymbolNode | InterpolatedSymbolNode, ?old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode, ?keyword_loc: Location) -> AliasMethodNode
+  #
+  # source://prism//lib/prism/node.rb#361
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      new_name: T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode),
+      old_name: T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode, Prism::GlobalVariableReadNode, Prism::MissingNode),
+      keyword_loc: Prism::Location
+    ).returns(Prism::AliasMethodNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#346
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, new_name: SymbolNode | InterpolatedSymbolNode, old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode, keyword_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#369
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#410
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#405
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#398
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # Represents the new name of the method that will be aliased.
+  #
+  #     alias foo bar
+  #           ^^^
+  #
+  #     alias :foo :bar
+  #           ^^^^
+  #
+  #     alias :"#{foo}" :"#{bar}"
+  #           ^^^^^^^^^
+  #
+  # source://prism//lib/prism/node.rb#383
+  sig { returns(T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)) }
+  def new_name; end
+
+  # Represents the old name of the method that will be aliased.
+  #
+  #     alias foo bar
+  #               ^^^
+  #
+  #     alias :foo :bar
+  #                ^^^^
+  #
+  #     alias :"#{foo}" :"#{bar}"
+  #                     ^^^^^^^^^
+  #
+  # source://prism//lib/prism/node.rb#395
+  sig do
+    returns(T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode, Prism::GlobalVariableReadNode, Prism::MissingNode))
+  end
+  def old_name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#415
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#420
+    def type; end
+  end
+end
+
+# Represents an alternation pattern in pattern matching.
+#
+#     foo => bar | baz
+#            ^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#438
+class Prism::AlternationPatternNode < ::Prism::Node
+  # Initialize a new AlternationPatternNode node.
+  #
+  # @return [AlternationPatternNode] a new instance of AlternationPatternNode
+  #
+  # source://prism//lib/prism/node.rb#440
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: Prism::Node,
+      right: Prism::Node,
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, left, right, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#527
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#451
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#456
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#466
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#461
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> AlternationPatternNode
+  #
+  # source://prism//lib/prism/node.rb#471
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: Prism::Node,
+      right: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::AlternationPatternNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#456
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#479
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#511
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Represents the left side of the expression.
+  #
+  #     foo => bar | baz
+  #            ^^^
+  #
+  # source://prism//lib/prism/node.rb#487
+  sig { returns(Prism::Node) }
+  def left; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#506
+  sig { returns(String) }
+  def operator; end
+
+  # Represents the alternation operator location.
+  #
+  #     foo => bar | baz
+  #                ^
+  #
+  # source://prism//lib/prism/node.rb#499
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Represents the right side of the expression.
+  #
+  #     foo => bar | baz
+  #                  ^^^
+  #
+  # source://prism//lib/prism/node.rb#493
+  sig { returns(Prism::Node) }
+  def right; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#516
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#521
+    def type; end
+  end
+end
+
+# Represents the use of the `&&` operator or the `and` keyword.
+#
+#     left and right
+#     ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#539
+class Prism::AndNode < ::Prism::Node
+  # Initialize a new AndNode node.
+  #
+  # @return [AndNode] a new instance of AndNode
+  #
+  # source://prism//lib/prism/node.rb#541
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: Prism::Node,
+      right: Prism::Node,
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, left, right, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#634
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#552
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#557
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#567
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#562
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> AndNode
+  #
+  # source://prism//lib/prism/node.rb#572
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: Prism::Node,
+      right: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::AndNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#557
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#580
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#618
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     left and right
+  #     ^^^^
+  #
+  #     1 && 2
+  #     ^
+  #
+  # source://prism//lib/prism/node.rb#591
+  sig { returns(Prism::Node) }
+  def left; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#613
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `and` keyword or the `&&` operator.
+  #
+  #     left and right
+  #          ^^^
+  #
+  # source://prism//lib/prism/node.rb#606
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Represents the right side of the expression.
+  #
+  #     left && right
+  #             ^^^^^
+  #
+  #     1 and 2
+  #           ^
+  #
+  # source://prism//lib/prism/node.rb#600
+  sig { returns(Prism::Node) }
+  def right; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#623
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#628
+    def type; end
+  end
+end
+
+# Represents a set of arguments to a method or a keyword.
+#
+#     return foo, bar, baz
+#            ^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#646
+class Prism::ArgumentsNode < ::Prism::Node
+  # Initialize a new ArgumentsNode node.
+  #
+  # @return [ArgumentsNode] a new instance of ArgumentsNode
+  #
+  # source://prism//lib/prism/node.rb#648
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      arguments: T::Array[Prism::Node]
+    ).void
+  end
+  def initialize(source, node_id, location, flags, arguments); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#734
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#657
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: Array[Prism::node]
+  #
+  # source://prism//lib/prism/node.rb#715
+  sig { returns(T::Array[Prism::Node]) }
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#662
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#672
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#667
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def contains_forwarding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#690
+  sig { returns(T::Boolean) }
+  def contains_forwarding?; end
+
+  # def contains_keyword_splat?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#700
+  sig { returns(T::Boolean) }
+  def contains_keyword_splat?; end
+
+  # def contains_keywords?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#695
+  sig { returns(T::Boolean) }
+  def contains_keywords?; end
+
+  # def contains_multiple_splats?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#710
+  sig { returns(T::Boolean) }
+  def contains_multiple_splats?; end
+
+  # def contains_splat?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#705
+  sig { returns(T::Boolean) }
+  def contains_splat?; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: Array[Prism::node]) -> ArgumentsNode
+  #
+  # source://prism//lib/prism/node.rb#677
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      arguments: T::Array[Prism::Node]
+    ).returns(Prism::ArgumentsNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#662
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: Array[Prism::node] }
+  #
+  # source://prism//lib/prism/node.rb#685
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#718
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#723
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#728
+    def type; end
+  end
+end
+
+# Flags for arguments nodes.
+#
+# source://prism//lib/prism/node.rb#16684
+module Prism::ArgumentsNodeFlags; end
+
+# if the arguments contain forwarding
+#
+# source://prism//lib/prism/node.rb#16686
+Prism::ArgumentsNodeFlags::CONTAINS_FORWARDING = T.let(T.unsafe(nil), Integer)
+
+# if the arguments contain keywords
+#
+# source://prism//lib/prism/node.rb#16689
+Prism::ArgumentsNodeFlags::CONTAINS_KEYWORDS = T.let(T.unsafe(nil), Integer)
+
+# if the arguments contain a keyword splat
+#
+# source://prism//lib/prism/node.rb#16692
+Prism::ArgumentsNodeFlags::CONTAINS_KEYWORD_SPLAT = T.let(T.unsafe(nil), Integer)
+
+# if the arguments contain multiple splats
+#
+# source://prism//lib/prism/node.rb#16698
+Prism::ArgumentsNodeFlags::CONTAINS_MULTIPLE_SPLATS = T.let(T.unsafe(nil), Integer)
+
+# if the arguments contain a splat
+#
+# source://prism//lib/prism/node.rb#16695
+Prism::ArgumentsNodeFlags::CONTAINS_SPLAT = T.let(T.unsafe(nil), Integer)
+
+# Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.
+#
+#     [1, 2, 3]
+#     ^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#746
+class Prism::ArrayNode < ::Prism::Node
+  # Initialize a new ArrayNode node.
+  #
+  # @return [ArrayNode] a new instance of ArrayNode
+  #
+  # source://prism//lib/prism/node.rb#748
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      elements: T::Array[Prism::Node],
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, elements, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#862
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#759
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#764
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#841
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # Represents the optional source location for the closing token.
+  #
+  #     [1,2,3]                 # "]"
+  #     %w[foo bar baz]         # "]"
+  #     %I(apple orange banana) # ")"
+  #     foo = 1, 2, 3           # nil
+  #
+  # source://prism//lib/prism/node.rb#823
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#774
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#769
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def contains_splat?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#792
+  sig { returns(T::Boolean) }
+  def contains_splat?; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?elements: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayNode
+  #
+  # source://prism//lib/prism/node.rb#779
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      elements: T::Array[Prism::Node],
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::ArrayNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), elements: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#764
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, elements: Array[Prism::node], opening_loc: Location?, closing_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#787
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # Represent the list of zero or more [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression) within the array.
+  #
+  # source://prism//lib/prism/node.rb#797
+  sig { returns(T::Array[Prism::Node]) }
+  def elements; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#846
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#836
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # Represents the optional source location for the opening token.
+  #
+  #     [1,2,3]                 # "["
+  #     %w[foo bar baz]         # "%w["
+  #     %I(apple orange banana) # "%I("
+  #     foo = 1, 2, 3           # nil
+  #
+  # source://prism//lib/prism/node.rb#805
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#851
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#856
+    def type; end
+  end
+end
+
+# Flags for array nodes.
+#
+# source://prism//lib/prism/node.rb#16702
+module Prism::ArrayNodeFlags; end
+
+# if array contains splat nodes
+#
+# source://prism//lib/prism/node.rb#16704
+Prism::ArrayNodeFlags::CONTAINS_SPLAT = T.let(T.unsafe(nil), Integer)
+
+# Represents an array pattern in pattern matching.
+#
+#     foo in 1, 2
+#     ^^^^^^^^^^^
+#
+#     foo in [1, 2]
+#     ^^^^^^^^^^^^^
+#
+#     foo in *1
+#     ^^^^^^^^^
+#
+#     foo in Bar[]
+#     ^^^^^^^^^^^^
+#
+#     foo in Bar[1, 2, 3]
+#     ^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#888
+class Prism::ArrayPatternNode < ::Prism::Node
+  # Initialize a new ArrayPatternNode node.
+  #
+  # @return [ArrayPatternNode] a new instance of ArrayPatternNode
+  #
+  # source://prism//lib/prism/node.rb#890
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      constant: T.nilable(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode)),
+      requireds: T::Array[Prism::Node],
+      rest: T.nilable(Prism::Node),
+      posts: T::Array[Prism::Node],
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, constant, requireds, rest, posts, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#1006
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#904
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#909
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#985
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#967
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#924
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#914
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # attr_reader constant: ConstantReadNode | ConstantPathNode | nil
+  #
+  # source://prism//lib/prism/node.rb#942
+  sig { returns(T.nilable(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode))) }
+  def constant; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantReadNode | ConstantPathNode | nil, ?requireds: Array[Prism::node], ?rest: Prism::node?, ?posts: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayPatternNode
+  #
+  # source://prism//lib/prism/node.rb#929
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      constant: T.nilable(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode)),
+      requireds: T::Array[Prism::Node],
+      rest: T.nilable(Prism::Node),
+      posts: T::Array[Prism::Node],
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::ArrayPatternNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), requireds: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#909
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantReadNode | ConstantPathNode | nil, requireds: Array[Prism::node], rest: Prism::node?, posts: Array[Prism::node], opening_loc: Location?, closing_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#937
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#990
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#980
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#954
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # attr_reader posts: Array[Prism::node]
+  #
+  # source://prism//lib/prism/node.rb#951
+  sig { returns(T::Array[Prism::Node]) }
+  def posts; end
+
+  # attr_reader requireds: Array[Prism::node]
+  #
+  # source://prism//lib/prism/node.rb#945
+  sig { returns(T::Array[Prism::Node]) }
+  def requireds; end
+
+  # attr_reader rest: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#948
+  sig { returns(T.nilable(Prism::Node)) }
+  def rest; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#995
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#1000
+    def type; end
+  end
+end
+
+# Represents a hash key/value pair.
+#
+#     { a => b }
+#       ^^^^^^
+#
+# source://prism//lib/prism/node.rb#1023
+class Prism::AssocNode < ::Prism::Node
+  # Initialize a new AssocNode node.
+  #
+  # @return [AssocNode] a new instance of AssocNode
+  #
+  # source://prism//lib/prism/node.rb#1025
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      key: Prism::Node,
+      value: Prism::Node,
+      operator_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, key, value, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#1127
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#1036
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1041
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#1051
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#1046
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?key: Prism::node, ?value: Prism::node, ?operator_loc: Location?) -> AssocNode
+  #
+  # source://prism//lib/prism/node.rb#1056
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      key: Prism::Node,
+      value: Prism::Node,
+      operator_loc: T.nilable(Prism::Location)
+    ).returns(Prism::AssocNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), key: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1041
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, key: Prism::node, value: Prism::node, operator_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#1064
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#1111
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The key of the association. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     { a: b }
+  #       ^
+  #
+  #     { foo => bar }
+  #       ^^^
+  #
+  #     { def a; end => 1 }
+  #       ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/node.rb#1078
+  sig { returns(Prism::Node) }
+  def key; end
+
+  # def operator: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#1106
+  sig { returns(T.nilable(String)) }
+  def operator; end
+
+  # The location of the `=>` operator, if present.
+  #
+  #     { foo => bar }
+  #           ^^
+  #
+  # source://prism//lib/prism/node.rb#1093
+  sig { returns(T.nilable(Prism::Location)) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#1116
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value of the association, if present. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     { foo => bar }
+  #              ^^^
+  #
+  #     { x: 1 }
+  #          ^
+  #
+  # source://prism//lib/prism/node.rb#1087
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#1121
+    def type; end
+  end
+end
+
+# Represents a splat in a hash literal.
+#
+#     { **foo }
+#       ^^^^^
+#
+# source://prism//lib/prism/node.rb#1139
+class Prism::AssocSplatNode < ::Prism::Node
+  # Initialize a new AssocSplatNode node.
+  #
+  # @return [AssocSplatNode] a new instance of AssocSplatNode
+  #
+  # source://prism//lib/prism/node.rb#1141
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, value, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#1223
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#1151
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1156
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#1168
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#1161
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node?, ?operator_loc: Location) -> AssocSplatNode
+  #
+  # source://prism//lib/prism/node.rb#1173
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).returns(Prism::AssocSplatNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1156
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node?, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#1181
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#1207
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#1202
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `**` operator.
+  #
+  #     { **x }
+  #       ^^
+  #
+  # source://prism//lib/prism/node.rb#1195
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#1212
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to be splatted, if present. Will be missing when keyword rest argument forwarding is used.
+  #
+  #     { **foo }
+  #         ^^^
+  #
+  # source://prism//lib/prism/node.rb#1189
+  sig { returns(T.nilable(Prism::Node)) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#1217
+    def type; end
+  end
+end
+
+# The FFI backend is used on other Ruby implementations.
+#
+# source://prism//lib/prism.rb#81
+Prism::BACKEND = T.let(T.unsafe(nil), Symbol)
+
+# Represents reading a reference to a field in the previous match.
+#
+#     $'
+#     ^^
+#
+# source://prism//lib/prism/node.rb#1234
+class Prism::BackReferenceReadNode < ::Prism::Node
+  # Initialize a new BackReferenceReadNode node.
+  #
+  # @return [BackReferenceReadNode] a new instance of BackReferenceReadNode
+  #
+  # source://prism//lib/prism/node.rb#1236
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#1301
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#1245
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1250
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#1260
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#1255
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> BackReferenceReadNode
+  #
+  # source://prism//lib/prism/node.rb#1265
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::BackReferenceReadNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1250
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#1273
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#1285
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the back-reference variable, including the leading `$`.
+  #
+  #     $& # name `:$&`
+  #
+  #     $+ # name `:$+`
+  #
+  # source://prism//lib/prism/node.rb#1282
+  sig { returns(Symbol) }
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#1290
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#1295
+    def type; end
+  end
+end
+
+# A class that knows how to walk down the tree. None of the individual visit
+# methods are implemented on this visitor, so it forces the consumer to
+# implement each one that they need. For a default implementation that
+# continues walking the tree, see the Visitor class.
+#
+# source://prism//lib/prism/visitor.rb#14
+class Prism::BasicVisitor
+  # Calls `accept` on the given node if it is not `nil`, which in turn should
+  # call back into this visitor by calling the appropriate `visit_*` method.
+  #
+  # source://prism//lib/prism/visitor.rb#17
+  sig { params(node: T.nilable(Prism::Node)).void }
+  def visit(node); end
+
+  # Visits each node in `nodes` by calling `accept` on each one.
+  #
+  # source://prism//lib/prism/visitor.rb#23
+  sig { params(nodes: T::Array[T.nilable(Prism::Node)]).void }
+  def visit_all(nodes); end
+
+  # Visits the child nodes of `node` by calling `accept` on each one.
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::Node).void }
+  def visit_child_nodes(node); end
+end
+
+# Represents a begin statement.
+#
+#     begin
+#       foo
+#     end
+#     ^^^^^
+#
+# source://prism//lib/prism/node.rb#1313
+class Prism::BeginNode < ::Prism::Node
+  # Initialize a new BeginNode node.
+  #
+  # @return [BeginNode] a new instance of BeginNode
+  #
+  # source://prism//lib/prism/node.rb#1315
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      begin_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode),
+      rescue_clause: T.nilable(Prism::RescueNode),
+      else_clause: T.nilable(Prism::ElseNode),
+      ensure_clause: T.nilable(Prism::EnsureNode),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#1431
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#1329
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def begin_keyword: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#1405
+  sig { returns(T.nilable(String)) }
+  def begin_keyword; end
+
+  # attr_reader begin_keyword_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#1367
+  sig { returns(T.nilable(Prism::Location)) }
+  def begin_keyword_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1334
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#1349
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#1339
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?begin_keyword_loc: Location?, ?statements: StatementsNode?, ?rescue_clause: RescueNode?, ?else_clause: ElseNode?, ?ensure_clause: EnsureNode?, ?end_keyword_loc: Location?) -> BeginNode
+  #
+  # source://prism//lib/prism/node.rb#1354
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      begin_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode),
+      rescue_clause: T.nilable(Prism::RescueNode),
+      else_clause: T.nilable(Prism::ElseNode),
+      ensure_clause: T.nilable(Prism::EnsureNode),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::BeginNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), begin_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), rescue_clause: T.unsafe(nil), else_clause: T.unsafe(nil), ensure_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1334
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#1362
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader else_clause: ElseNode?
+  #
+  # source://prism//lib/prism/node.rb#1386
+  sig { returns(T.nilable(Prism::ElseNode)) }
+  def else_clause; end
+
+  # def end_keyword: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#1410
+  sig { returns(T.nilable(String)) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#1392
+  sig { returns(T.nilable(Prism::Location)) }
+  def end_keyword_loc; end
+
+  # attr_reader ensure_clause: EnsureNode?
+  #
+  # source://prism//lib/prism/node.rb#1389
+  sig { returns(T.nilable(Prism::EnsureNode)) }
+  def ensure_clause; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#1415
+  sig { override.returns(String) }
+  def inspect; end
+
+  # source://prism//lib/prism/parse_result/newlines.rb#79
+  def newline_flag!(lines); end
+
+  # attr_reader rescue_clause: RescueNode?
+  #
+  # source://prism//lib/prism/node.rb#1383
+  sig { returns(T.nilable(Prism::RescueNode)) }
+  def rescue_clause; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism//lib/prism/node.rb#1380
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#1420
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#1425
+    def type; end
+  end
+end
+
+# Represents a block argument using `&`.
+#
+#     bar(&args)
+#     ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#1446
+class Prism::BlockArgumentNode < ::Prism::Node
+  # Initialize a new BlockArgumentNode node.
+  #
+  # @return [BlockArgumentNode] a new instance of BlockArgumentNode
+  #
+  # source://prism//lib/prism/node.rb#1448
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      expression: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, expression, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#1524
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#1458
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1463
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#1475
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#1468
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node?, ?operator_loc: Location) -> BlockArgumentNode
+  #
+  # source://prism//lib/prism/node.rb#1480
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      expression: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).returns(Prism::BlockArgumentNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1463
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node?, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#1488
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader expression: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#1493
+  sig { returns(T.nilable(Prism::Node)) }
+  def expression; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#1508
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#1503
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#1496
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#1513
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#1518
+    def type; end
+  end
+end
+
+# Represents a block local variable.
+#
+#     a { |; b| }
+#            ^
+#
+# source://prism//lib/prism/node.rb#1535
+class Prism::BlockLocalVariableNode < ::Prism::Node
+  # Initialize a new BlockLocalVariableNode node.
+  #
+  # @return [BlockLocalVariableNode] a new instance of BlockLocalVariableNode
+  #
+  # source://prism//lib/prism/node.rb#1537
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#1603
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#1546
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1551
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#1561
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#1556
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> BlockLocalVariableNode
+  #
+  # source://prism//lib/prism/node.rb#1566
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::BlockLocalVariableNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1551
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#1574
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#1587
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#1584
+  sig { returns(Symbol) }
+  def name; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#1579
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#1592
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#1597
+    def type; end
+  end
+end
+
+# Represents a block of ruby code.
+#
+#     [1, 2, 3].each { |i| puts x }
+#                    ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#1614
+class Prism::BlockNode < ::Prism::Node
+  # Initialize a new BlockNode node.
+  #
+  # @return [BlockNode] a new instance of BlockNode
+  #
+  # source://prism//lib/prism/node.rb#1616
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      parameters: T.nilable(T.any(Prism::BlockParametersNode, Prism::NumberedParametersNode, Prism::ItParametersNode)),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, locals, parameters, body, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#1714
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#1629
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader body: StatementsNode | BeginNode | nil
+  #
+  # source://prism//lib/prism/node.rb#1671
+  sig { returns(T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1634
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#1693
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#1681
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#1647
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#1639
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, ?body: StatementsNode | BeginNode | nil, ?opening_loc: Location, ?closing_loc: Location) -> BlockNode
+  #
+  # source://prism//lib/prism/node.rb#1652
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      parameters: T.nilable(T.any(Prism::BlockParametersNode, Prism::NumberedParametersNode, Prism::ItParametersNode)),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).returns(Prism::BlockNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1634
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, body: StatementsNode | BeginNode | nil, opening_loc: Location, closing_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#1660
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#1698
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[Symbol]
+  #
+  # source://prism//lib/prism/node.rb#1665
+  sig { returns(T::Array[Symbol]) }
+  def locals; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#1688
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#1674
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil
+  #
+  # source://prism//lib/prism/node.rb#1668
+  sig { returns(T.nilable(T.any(Prism::BlockParametersNode, Prism::NumberedParametersNode, Prism::ItParametersNode))) }
+  def parameters; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#1703
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#1708
+    def type; end
+  end
+end
+
+# Represents a block parameter of a method, block, or lambda definition.
+#
+#     def a(&b)
+#           ^^
+#     end
+#
+# source://prism//lib/prism/node.rb#1730
+class Prism::BlockParameterNode < ::Prism::Node
+  # Initialize a new BlockParameterNode node.
+  #
+  # @return [BlockParameterNode] a new instance of BlockParameterNode
+  #
+  # source://prism//lib/prism/node.rb#1732
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#1825
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#1743
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1748
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#1758
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#1753
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> BlockParameterNode
+  #
+  # source://prism//lib/prism/node.rb#1763
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).returns(Prism::BlockParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1748
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#1771
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#1809
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol?
+  #
+  # source://prism//lib/prism/node.rb#1781
+  sig { returns(T.nilable(Symbol)) }
+  def name; end
+
+  # attr_reader name_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#1784
+  sig { returns(T.nilable(Prism::Location)) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#1804
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#1797
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#1776
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#1814
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#1819
+    def type; end
+  end
+end
+
+# Represents a block's parameters declaration.
+#
+#     -> (a, b = 1; local) { }
+#        ^^^^^^^^^^^^^^^^^
+#
+#     foo do |a, b = 1; local|
+#            ^^^^^^^^^^^^^^^^^
+#     end
+#
+# source://prism//lib/prism/node.rb#1842
+class Prism::BlockParametersNode < ::Prism::Node
+  # Initialize a new BlockParametersNode node.
+  #
+  # @return [BlockParametersNode] a new instance of BlockParametersNode
+  #
+  # source://prism//lib/prism/node.rb#1844
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      parameters: T.nilable(Prism::ParametersNode),
+      locals: T::Array[Prism::BlockLocalVariableNode],
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, parameters, locals, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#1950
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#1856
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1861
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#1929
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#1911
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#1874
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#1866
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parameters: ParametersNode?, ?locals: Array[BlockLocalVariableNode], ?opening_loc: Location?, ?closing_loc: Location?) -> BlockParametersNode
+  #
+  # source://prism//lib/prism/node.rb#1879
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      parameters: T.nilable(Prism::ParametersNode),
+      locals: T::Array[Prism::BlockLocalVariableNode],
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::BlockParametersNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parameters: T.unsafe(nil), locals: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1861
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parameters: ParametersNode?, locals: Array[BlockLocalVariableNode], opening_loc: Location?, closing_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#1887
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#1934
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[BlockLocalVariableNode]
+  #
+  # source://prism//lib/prism/node.rb#1895
+  sig { returns(T::Array[Prism::BlockLocalVariableNode]) }
+  def locals; end
+
+  # def opening: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#1924
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#1898
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # attr_reader parameters: ParametersNode?
+  #
+  # source://prism//lib/prism/node.rb#1892
+  sig { returns(T.nilable(Prism::ParametersNode)) }
+  def parameters; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#1939
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#1944
+    def type; end
+  end
+end
+
+# Represents the use of the `break` keyword.
+#
+#     break foo
+#     ^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#1964
+class Prism::BreakNode < ::Prism::Node
+  # Initialize a new BreakNode node.
+  #
+  # @return [BreakNode] a new instance of BreakNode
+  #
+  # source://prism//lib/prism/node.rb#1966
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      keyword_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, arguments, keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#2048
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#1976
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # The arguments to the break statement, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     break foo
+  #           ^^^
+  #
+  # source://prism//lib/prism/node.rb#2014
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1981
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#1993
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#1986
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: ArgumentsNode?, ?keyword_loc: Location) -> BreakNode
+  #
+  # source://prism//lib/prism/node.rb#1998
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      keyword_loc: Prism::Location
+    ).returns(Prism::BreakNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#1981
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: ArgumentsNode?, keyword_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#2006
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#2032
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#2027
+  sig { returns(String) }
+  def keyword; end
+
+  # The location of the `break` keyword.
+  #
+  #     break foo
+  #     ^^^^^
+  #
+  # source://prism//lib/prism/node.rb#2020
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#2037
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#2042
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator on a call.
+#
+#     foo.bar &&= value
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#2059
+class Prism::CallAndWriteNode < ::Prism::Node
+  # Initialize a new CallAndWriteNode node.
+  #
+  # @return [CallAndWriteNode] a new instance of CallAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#2061
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#2208
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#2076
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2122
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # def call_operator: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#2177
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#2135
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#2081
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#2094
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#2086
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node) -> CallAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#2099
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::CallAndWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#2081
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#2107
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2127
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#2192
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def message: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#2182
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  # attr_reader message_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#2148
+  sig { returns(T.nilable(Prism::Location)) }
+  def message_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#2187
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#2167
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader read_name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#2161
+  sig { returns(Symbol) }
+  def read_name; end
+
+  # attr_reader receiver: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#2132
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2112
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#2197
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#2174
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2117
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  # attr_reader write_name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#2164
+  sig { returns(Symbol) }
+  def write_name; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#2202
+    def type; end
+  end
+end
+
+# Represents a method call, in all of the various forms that can take.
+#
+#     foo
+#     ^^^
+#
+#     foo()
+#     ^^^^^
+#
+#     +foo
+#     ^^^^
+#
+#     foo + bar
+#     ^^^^^^^^^
+#
+#     foo.bar
+#     ^^^^^^^
+#
+#     foo&.bar
+#     ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#2240
+class Prism::CallNode < ::Prism::Node
+  # Initialize a new CallNode node.
+  #
+  # @return [CallNode] a new instance of CallNode
+  #
+  # source://prism//lib/prism/node.rb#2242
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      name: Symbol,
+      message_loc: T.nilable(Prism::Location),
+      opening_loc: T.nilable(Prism::Location),
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: T.nilable(Prism::Location),
+      block: T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#2424
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#2258
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism//lib/prism/node.rb#2369
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2305
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader block: BlockNode | BlockArgumentNode | nil
+  #
+  # source://prism//lib/prism/node.rb#2385
+  sig { returns(T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))) }
+  def block; end
+
+  # def call_operator: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#2388
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#2327
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#2263
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#2403
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#2372
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#2277
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#2268
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> CallNode
+  #
+  # source://prism//lib/prism/node.rb#2282
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      name: Symbol,
+      message_loc: T.nilable(Prism::Location),
+      opening_loc: T.nilable(Prism::Location),
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: T.nilable(Prism::Location),
+      block: T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))
+    ).returns(Prism::CallNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#2263
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: BlockNode | BlockArgumentNode | nil }
+  #
+  # source://prism//lib/prism/node.rb#2290
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # When a call node has the attribute_write flag set, it means that the call
+  # is using the attribute write syntax. This is either a method call to []=
+  # or a method call to a method that ends with =. Either way, the = sign is
+  # present in the source.
+  #
+  # Prism returns the message_loc _without_ the = sign attached, because there
+  # can be any amount of space between the message and the = sign. However,
+  # sometimes you want the location of the full message including the inner
+  # space and the = sign. This method provides that.
+  #
+  # source://prism//lib/prism/node_ext.rb#331
+  sig { returns(T.nilable(Prism::Location)) }
+  def full_message_loc; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2310
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#2408
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def message: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#2393
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  # attr_reader message_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#2343
+  sig { returns(T.nilable(Prism::Location)) }
+  def message_loc; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#2340
+  sig { returns(Symbol) }
+  def name; end
+
+  # def opening: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#2398
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#2356
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     foo.bar
+  #     ^^^
+  #
+  #     +foo
+  #      ^^^
+  #
+  #     foo + bar
+  #     ^^^
+  #
+  # source://prism//lib/prism/node.rb#2324
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2295
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#2413
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2300
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#2418
+    def type; end
+  end
+end
+
+# Flags for call nodes.
+#
+# source://prism//lib/prism/node.rb#16708
+module Prism::CallNodeFlags; end
+
+# a call that is an attribute write, so the value being written should be returned
+#
+# source://prism//lib/prism/node.rb#16716
+Prism::CallNodeFlags::ATTRIBUTE_WRITE = T.let(T.unsafe(nil), Integer)
+
+# a call that ignores method visibility
+#
+# source://prism//lib/prism/node.rb#16719
+Prism::CallNodeFlags::IGNORE_VISIBILITY = T.let(T.unsafe(nil), Integer)
+
+# &. operator
+#
+# source://prism//lib/prism/node.rb#16710
+Prism::CallNodeFlags::SAFE_NAVIGATION = T.let(T.unsafe(nil), Integer)
+
+# a call that could have been a local variable
+#
+# source://prism//lib/prism/node.rb#16713
+Prism::CallNodeFlags::VARIABLE_CALL = T.let(T.unsafe(nil), Integer)
+
+# Represents the use of an assignment operator on a call.
+#
+#     foo.bar += baz
+#     ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#2442
+class Prism::CallOperatorWriteNode < ::Prism::Node
+  # Initialize a new CallOperatorWriteNode node.
+  #
+  # @return [CallOperatorWriteNode] a new instance of CallOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#2444
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      binary_operator: Symbol,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#2590
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#2460
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2506
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader binary_operator: Symbol
+  #
+  # source://prism//lib/prism/node.rb#2551
+  sig { returns(Symbol) }
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#2554
+  sig { returns(Prism::Location) }
+  def binary_operator_loc; end
+
+  # def call_operator: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#2564
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#2519
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#2465
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#2478
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#2470
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node) -> CallOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#2483
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      binary_operator: Symbol,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::CallOperatorWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#2465
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#2491
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2511
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#2574
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def message: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#2569
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  # attr_reader message_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#2532
+  sig { returns(T.nilable(Prism::Location)) }
+  def message_loc; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  #
+  # source://prism//lib/prism/node_ext.rb#339
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  #
+  # source://prism//lib/prism/node_ext.rb#346
+  def operator_loc; end
+
+  # attr_reader read_name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#2545
+  sig { returns(Symbol) }
+  def read_name; end
+
+  # attr_reader receiver: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#2516
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2496
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#2579
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#2561
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2501
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  # attr_reader write_name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#2548
+  sig { returns(Symbol) }
+  def write_name; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#2584
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator on a call.
+#
+#     foo.bar ||= value
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#2608
+class Prism::CallOrWriteNode < ::Prism::Node
+  # Initialize a new CallOrWriteNode node.
+  #
+  # @return [CallOrWriteNode] a new instance of CallOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#2610
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#2757
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#2625
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2671
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # def call_operator: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#2726
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#2684
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#2630
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#2643
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#2635
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node) -> CallOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#2648
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::CallOrWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#2630
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#2656
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2676
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#2741
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def message: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#2731
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  # attr_reader message_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#2697
+  sig { returns(T.nilable(Prism::Location)) }
+  def message_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#2736
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#2716
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader read_name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#2710
+  sig { returns(Symbol) }
+  def read_name; end
+
+  # attr_reader receiver: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#2681
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2661
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#2746
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#2723
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2666
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  # attr_reader write_name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#2713
+  sig { returns(Symbol) }
+  def write_name; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#2751
+    def type; end
+  end
+end
+
+# Represents assigning to a method call.
+#
+#     foo.bar, = 1
+#     ^^^^^^^
+#
+#     begin
+#     rescue => foo.bar
+#               ^^^^^^^
+#     end
+#
+#     for foo.bar in baz do end
+#         ^^^^^^^
+#
+# source://prism//lib/prism/node.rb#2782
+class Prism::CallTargetNode < ::Prism::Node
+  # Initialize a new CallTargetNode node.
+  #
+  # @return [CallTargetNode] a new instance of CallTargetNode
+  #
+  # source://prism//lib/prism/node.rb#2784
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: Prism::Node,
+      call_operator_loc: Prism::Location,
+      name: Symbol,
+      message_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#2895
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#2796
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2839
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # def call_operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#2869
+  sig { returns(String) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#2852
+  sig { returns(Prism::Location) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#2801
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#2811
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#2806
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node, ?call_operator_loc: Location, ?name: Symbol, ?message_loc: Location) -> CallTargetNode
+  #
+  # source://prism//lib/prism/node.rb#2816
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: Prism::Node,
+      call_operator_loc: Prism::Location,
+      name: Symbol,
+      message_loc: Prism::Location
+    ).returns(Prism::CallTargetNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#2801
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, call_operator_loc: Location, name: Symbol, message_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#2824
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2844
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#2879
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def message: () -> String
+  #
+  # source://prism//lib/prism/node.rb#2874
+  sig { returns(String) }
+  def message; end
+
+  # attr_reader message_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#2862
+  sig { returns(Prism::Location) }
+  def message_loc; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#2859
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader receiver: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#2849
+  sig { returns(Prism::Node) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2829
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#2884
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#2834
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#2889
+    def type; end
+  end
+end
+
+# Represents assigning to a local variable in pattern matching.
+#
+#     foo => [bar => baz]
+#            ^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#2909
+class Prism::CapturePatternNode < ::Prism::Node
+  # Initialize a new CapturePatternNode node.
+  #
+  # @return [CapturePatternNode] a new instance of CapturePatternNode
+  #
+  # source://prism//lib/prism/node.rb#2911
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Prism::Node,
+      target: Prism::LocalVariableTargetNode,
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, value, target, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#2989
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#2922
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#2927
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#2937
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#2932
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?target: LocalVariableTargetNode, ?operator_loc: Location) -> CapturePatternNode
+  #
+  # source://prism//lib/prism/node.rb#2942
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Prism::Node,
+      target: Prism::LocalVariableTargetNode,
+      operator_loc: Prism::Location
+    ).returns(Prism::CapturePatternNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#2927
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, target: LocalVariableTargetNode, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#2950
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#2973
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#2968
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#2961
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader target: LocalVariableTargetNode
+  #
+  # source://prism//lib/prism/node.rb#2958
+  sig { returns(Prism::LocalVariableTargetNode) }
+  def target; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#2978
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#2955
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#2983
+    def type; end
+  end
+end
+
+# Represents the use of a case statement for pattern matching.
+#
+#     case true
+#     in false
+#     end
+#     ^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#3003
+class Prism::CaseMatchNode < ::Prism::Node
+  # Initialize a new CaseMatchNode node.
+  #
+  # @return [CaseMatchNode] a new instance of CaseMatchNode
+  #
+  # source://prism//lib/prism/node.rb#3005
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      predicate: T.nilable(Prism::Node),
+      conditions: T::Array[Prism::InNode],
+      else_clause: T.nilable(Prism::ElseNode),
+      case_keyword_loc: Prism::Location,
+      end_keyword_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#3104
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#3018
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def case_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#3078
+  sig { returns(String) }
+  def case_keyword; end
+
+  # attr_reader case_keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#3064
+  sig { returns(Prism::Location) }
+  def case_keyword_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3023
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#3037
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#3028
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # attr_reader conditions: Array[InNode]
+  #
+  # source://prism//lib/prism/node.rb#3058
+  sig { returns(T::Array[Prism::InNode]) }
+  def conditions; end
+
+  # Returns the else clause of the case match node. This method is deprecated
+  # in favor of #else_clause.
+  #
+  # source://prism//lib/prism/node_ext.rb#467
+  def consequent; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[InNode], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseMatchNode
+  #
+  # source://prism//lib/prism/node.rb#3042
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      predicate: T.nilable(Prism::Node),
+      conditions: T::Array[Prism::InNode],
+      else_clause: T.nilable(Prism::ElseNode),
+      case_keyword_loc: Prism::Location,
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::CaseMatchNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), predicate: T.unsafe(nil), conditions: T.unsafe(nil), else_clause: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3023
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[InNode], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#3050
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader else_clause: ElseNode?
+  #
+  # source://prism//lib/prism/node.rb#3061
+  sig { returns(T.nilable(Prism::ElseNode)) }
+  def else_clause; end
+
+  # def end_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#3083
+  sig { returns(String) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#3071
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#3088
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader predicate: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#3055
+  sig { returns(T.nilable(Prism::Node)) }
+  def predicate; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#3093
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#3098
+    def type; end
+  end
+end
+
+# Represents the use of a case statement.
+#
+#     case true
+#     when false
+#     end
+#     ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#3121
+class Prism::CaseNode < ::Prism::Node
+  # Initialize a new CaseNode node.
+  #
+  # @return [CaseNode] a new instance of CaseNode
+  #
+  # source://prism//lib/prism/node.rb#3123
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      predicate: T.nilable(Prism::Node),
+      conditions: T::Array[Prism::WhenNode],
+      else_clause: T.nilable(Prism::ElseNode),
+      case_keyword_loc: Prism::Location,
+      end_keyword_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#3222
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#3136
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def case_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#3196
+  sig { returns(String) }
+  def case_keyword; end
+
+  # attr_reader case_keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#3182
+  sig { returns(Prism::Location) }
+  def case_keyword_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3141
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#3155
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#3146
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # attr_reader conditions: Array[WhenNode]
+  #
+  # source://prism//lib/prism/node.rb#3176
+  sig { returns(T::Array[Prism::WhenNode]) }
+  def conditions; end
+
+  # Returns the else clause of the case node. This method is deprecated in
+  # favor of #else_clause.
+  #
+  # source://prism//lib/prism/node_ext.rb#476
+  def consequent; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[WhenNode], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseNode
+  #
+  # source://prism//lib/prism/node.rb#3160
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      predicate: T.nilable(Prism::Node),
+      conditions: T::Array[Prism::WhenNode],
+      else_clause: T.nilable(Prism::ElseNode),
+      case_keyword_loc: Prism::Location,
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::CaseNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), predicate: T.unsafe(nil), conditions: T.unsafe(nil), else_clause: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3141
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[WhenNode], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#3168
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader else_clause: ElseNode?
+  #
+  # source://prism//lib/prism/node.rb#3179
+  sig { returns(T.nilable(Prism::ElseNode)) }
+  def else_clause; end
+
+  # def end_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#3201
+  sig { returns(String) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#3189
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#3206
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader predicate: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#3173
+  sig { returns(T.nilable(Prism::Node)) }
+  def predicate; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#3211
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#3216
+    def type; end
+  end
+end
+
+# Represents a class declaration involving the `class` keyword.
+#
+#     class Foo end
+#     ^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#3237
+class Prism::ClassNode < ::Prism::Node
+  # Initialize a new ClassNode node.
+  #
+  # @return [ClassNode] a new instance of ClassNode
+  #
+  # source://prism//lib/prism/node.rb#3239
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      class_keyword_loc: Prism::Location,
+      constant_path: T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::CallNode),
+      inheritance_operator_loc: T.nilable(Prism::Location),
+      superclass: T.nilable(Prism::Node),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      end_keyword_loc: Prism::Location,
+      name: Symbol
+    ).void
+  end
+  def initialize(source, node_id, location, flags, locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#3365
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#3255
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader body: StatementsNode | BeginNode | nil
+  #
+  # source://prism//lib/prism/node.rb#3321
+  sig { returns(T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3260
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def class_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#3334
+  sig { returns(String) }
+  def class_keyword; end
+
+  # attr_reader class_keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#3295
+  sig { returns(Prism::Location) }
+  def class_keyword_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#3274
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#3265
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # attr_reader constant_path: ConstantReadNode | ConstantPathNode | CallNode
+  #
+  # source://prism//lib/prism/node.rb#3302
+  sig { returns(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::CallNode)) }
+  def constant_path; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?constant_path: ConstantReadNode | ConstantPathNode | CallNode, ?inheritance_operator_loc: Location?, ?superclass: Prism::node?, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location, ?name: Symbol) -> ClassNode
+  #
+  # source://prism//lib/prism/node.rb#3279
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      class_keyword_loc: Prism::Location,
+      constant_path: T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::CallNode),
+      inheritance_operator_loc: T.nilable(Prism::Location),
+      superclass: T.nilable(Prism::Node),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      end_keyword_loc: Prism::Location,
+      name: Symbol
+    ).returns(Prism::ClassNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), inheritance_operator_loc: T.unsafe(nil), superclass: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3260
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, constant_path: ConstantReadNode | ConstantPathNode | CallNode, inheritance_operator_loc: Location?, superclass: Prism::node?, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location, name: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#3287
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#3344
+  sig { returns(String) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#3324
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inheritance_operator: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#3339
+  sig { returns(T.nilable(String)) }
+  def inheritance_operator; end
+
+  # attr_reader inheritance_operator_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#3305
+  sig { returns(T.nilable(Prism::Location)) }
+  def inheritance_operator_loc; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#3349
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[Symbol]
+  #
+  # source://prism//lib/prism/node.rb#3292
+  sig { returns(T::Array[Symbol]) }
+  def locals; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#3331
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader superclass: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#3318
+  sig { returns(T.nilable(Prism::Node)) }
+  def superclass; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#3354
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#3359
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator for assignment to a class variable.
+#
+#     @@target &&= value
+#     ^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#3383
+class Prism::ClassVariableAndWriteNode < ::Prism::Node
+  # Initialize a new ClassVariableAndWriteNode node.
+  #
+  # @return [ClassVariableAndWriteNode] a new instance of ClassVariableAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#3385
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#3471
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#3397
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3402
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#3412
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#3407
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ClassVariableAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#3417
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ClassVariableAndWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3402
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#3425
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # source://prism//lib/prism/desugar_compiler.rb#164
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#3455
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#3430
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#3433
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#3450
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#3440
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#3460
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#3447
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#3465
+    def type; end
+  end
+end
+
+# Represents assigning to a class variable using an operator that isn't `=`.
+#
+#     @@target += value
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#3484
+class Prism::ClassVariableOperatorWriteNode < ::Prism::Node
+  # Initialize a new ClassVariableOperatorWriteNode node.
+  #
+  # @return [ClassVariableOperatorWriteNode] a new instance of ClassVariableOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#3486
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#3571
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#3499
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader binary_operator: Symbol
+  #
+  # source://prism//lib/prism/node.rb#3552
+  sig { returns(Symbol) }
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#3542
+  sig { returns(Prism::Location) }
+  def binary_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3504
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#3514
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#3509
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ClassVariableOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#3519
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::ClassVariableOperatorWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3504
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#3527
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # source://prism//lib/prism/desugar_compiler.rb#176
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#3555
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#3532
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#3535
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  #
+  # source://prism//lib/prism/node_ext.rb#355
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  #
+  # source://prism//lib/prism/node_ext.rb#362
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#3560
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#3549
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#3565
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a class variable.
+#
+#     @@target ||= value
+#     ^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#3585
+class Prism::ClassVariableOrWriteNode < ::Prism::Node
+  # Initialize a new ClassVariableOrWriteNode node.
+  #
+  # @return [ClassVariableOrWriteNode] a new instance of ClassVariableOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#3587
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#3673
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#3599
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3604
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#3614
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#3609
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ClassVariableOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#3619
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ClassVariableOrWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3604
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#3627
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # source://prism//lib/prism/desugar_compiler.rb#170
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#3657
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#3632
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#3635
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#3652
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#3642
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#3662
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#3649
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#3667
+    def type; end
+  end
+end
+
+# Represents referencing a class variable.
+#
+#     @@foo
+#     ^^^^^
+#
+# source://prism//lib/prism/node.rb#3686
+class Prism::ClassVariableReadNode < ::Prism::Node
+  # Initialize a new ClassVariableReadNode node.
+  #
+  # @return [ClassVariableReadNode] a new instance of ClassVariableReadNode
+  #
+  # source://prism//lib/prism/node.rb#3688
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#3753
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#3697
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3702
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#3712
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#3707
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ClassVariableReadNode
+  #
+  # source://prism//lib/prism/node.rb#3717
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::ClassVariableReadNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3702
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#3725
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#3737
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+  #
+  #     @@abc   # name `:@@abc`
+  #
+  #     @@_test # name `:@@_test`
+  #
+  # source://prism//lib/prism/node.rb#3734
+  sig { returns(Symbol) }
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#3742
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#3747
+    def type; end
+  end
+end
+
+# Represents writing to a class variable in a context that doesn't have an explicit value.
+#
+#     @@foo, @@bar = baz
+#     ^^^^^  ^^^^^
+#
+# source://prism//lib/prism/node.rb#3763
+class Prism::ClassVariableTargetNode < ::Prism::Node
+  # Initialize a new ClassVariableTargetNode node.
+  #
+  # @return [ClassVariableTargetNode] a new instance of ClassVariableTargetNode
+  #
+  # source://prism//lib/prism/node.rb#3765
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#3826
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#3774
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3779
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#3789
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#3784
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ClassVariableTargetNode
+  #
+  # source://prism//lib/prism/node.rb#3794
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::ClassVariableTargetNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3779
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#3802
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#3810
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#3807
+  sig { returns(Symbol) }
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#3815
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#3820
+    def type; end
+  end
+end
+
+# Represents writing to a class variable.
+#
+#     @@foo = 1
+#     ^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#3836
+class Prism::ClassVariableWriteNode < ::Prism::Node
+  # Initialize a new ClassVariableWriteNode node.
+  #
+  # @return [ClassVariableWriteNode] a new instance of ClassVariableWriteNode
+  #
+  # source://prism//lib/prism/node.rb#3838
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#3940
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#3850
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3855
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#3865
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#3860
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> ClassVariableWriteNode
+  #
+  # source://prism//lib/prism/node.rb#3870
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::ClassVariableWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3855
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#3878
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#3924
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+  #
+  #     @@abc = 123     # name `@@abc`
+  #
+  #     @@_test = :test # name `@@_test`
+  #
+  # source://prism//lib/prism/node.rb#3887
+  sig { returns(Symbol) }
+  def name; end
+
+  # The location of the variable name.
+  #
+  #     @@foo = :bar
+  #     ^^^^^
+  #
+  # source://prism//lib/prism/node.rb#3893
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#3919
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `=` operator.
+  #
+  #     @@foo = :bar
+  #           ^
+  #
+  # source://prism//lib/prism/node.rb#3912
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#3929
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to write to the class variable. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     @@foo = :bar
+  #             ^^^^
+  #
+  #     @@_xyz = 123
+  #              ^^^
+  #
+  # source://prism//lib/prism/node.rb#3906
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#3934
+    def type; end
+  end
+end
+
+# A cache that can be used to quickly compute code unit offsets from byte
+# offsets. It purposefully provides only a single #[] method to access the
+# cache in order to minimize surface area.
+#
+# Note that there are some known issues here that may or may not be addressed
+# in the future:
+#
+# * The first is that there are issues when the cache computes values that are
+#   not on character boundaries. This can result in subsequent computations
+#   being off by one or more code units.
+# * The second is that this cache is currently unbounded. In theory we could
+#   introduce some kind of LRU cache to limit the number of entries, but this
+#   has not yet been implemented.
+#
+# source://prism//lib/prism/parse_result.rb#172
+class Prism::CodeUnitsCache
+  # Initialize a new cache with the given source and encoding.
+  #
+  # @return [CodeUnitsCache] a new instance of CodeUnitsCache
+  #
+  # source://prism//lib/prism/parse_result.rb#198
+  sig { params(source: String, encoding: Encoding).void }
+  def initialize(source, encoding); end
+
+  # Retrieve the code units offset from the given byte offset.
+  #
+  # source://prism//lib/prism/parse_result.rb#212
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def [](byte_offset); end
+end
+
+# source://prism//lib/prism/parse_result.rb#184
+class Prism::CodeUnitsCache::LengthCounter
+  # @return [LengthCounter] a new instance of LengthCounter
+  #
+  # source://prism//lib/prism/parse_result.rb#185
+  def initialize(source, encoding); end
+
+  # source://prism//lib/prism/parse_result.rb#190
+  def count(byte_offset, byte_length); end
+end
+
+# source://prism//lib/prism/parse_result.rb#173
+class Prism::CodeUnitsCache::UTF16Counter
+  # @return [UTF16Counter] a new instance of UTF16Counter
+  #
+  # source://prism//lib/prism/parse_result.rb#174
+  def initialize(source, encoding); end
+
+  # source://prism//lib/prism/parse_result.rb#179
+  def count(byte_offset, byte_length); end
+end
+
+# This represents a comment that was encountered during parsing. It is the
+# base class for all comment types.
+#
+# source://prism//lib/prism/parse_result.rb#507
+class Prism::Comment
+  abstract!
+
+  # Create a new comment object with the given location.
+  #
+  # @return [Comment] a new instance of Comment
+  #
+  # source://prism//lib/prism/parse_result.rb#512
+  sig { params(location: Prism::Location).void }
+  def initialize(location); end
+
+  # Implement the hash pattern matching interface for Comment.
+  #
+  # source://prism//lib/prism/parse_result.rb#517
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # The location of this comment in the source.
+  #
+  # source://prism//lib/prism/parse_result.rb#509
+  sig { returns(Prism::Location) }
+  def location; end
+
+  # Returns the content of the comment by slicing it from the source code.
+  #
+  # source://prism//lib/prism/parse_result.rb#522
+  sig { returns(String) }
+  def slice; end
+
+  sig { abstract.returns(T::Boolean) }
+  def trailing?; end
+end
+
+# A compiler is a visitor that returns the value of each node as it visits.
+# This is as opposed to a visitor which will only walk the tree. This can be
+# useful when you are trying to compile a tree into a different format.
+#
+# For example, to build a representation of the tree as s-expressions, you
+# could write:
+#
+#     class SExpressions < Prism::Compiler
+#       def visit_arguments_node(node) = [:arguments, super]
+#       def visit_call_node(node) = [:call, super]
+#       def visit_integer_node(node) = [:integer]
+#       def visit_program_node(node) = [:program, super]
+#     end
+#
+#     Prism.parse("1 + 2").value.accept(SExpressions.new)
+#     # => [:program, [[[:call, [[:integer], [:arguments, [[:integer]]]]]]]]
+#
+# source://prism//lib/prism/compiler.rb#27
+class Prism::Compiler < ::Prism::Visitor
+  # Visit an individual node.
+  #
+  # source://prism//lib/prism/compiler.rb#29
+  sig { params(node: T.nilable(Prism::Node)).returns(T.untyped) }
+  def visit(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AliasGlobalVariableNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_alias_global_variable_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AliasMethodNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_alias_method_node(node); end
+
+  # Visit a list of nodes.
+  #
+  # source://prism//lib/prism/compiler.rb#34
+  sig { params(nodes: T::Array[T.nilable(Prism::Node)]).returns(T::Array[T.untyped]) }
+  def visit_all(nodes); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AlternationPatternNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_alternation_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AndNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_and_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ArgumentsNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_arguments_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ArrayNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_array_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ArrayPatternNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_array_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AssocNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_assoc_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AssocSplatNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_assoc_splat_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BackReferenceReadNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_back_reference_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BeginNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_begin_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockArgumentNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_block_argument_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockLocalVariableNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_block_local_variable_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_block_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockParameterNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_block_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockParametersNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_block_parameters_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BreakNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_break_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallAndWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_call_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_call_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallOperatorWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_call_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallOrWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_call_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallTargetNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_call_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CapturePatternNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_capture_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CaseMatchNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_case_match_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CaseNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_case_node(node); end
+
+  # Visit the child nodes of the given node.
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  sig { params(node: Prism::Node).returns(T::Array[T.untyped]) }
+  def visit_child_nodes(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_class_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableAndWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_class_variable_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableOperatorWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_class_variable_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableOrWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_class_variable_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableReadNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_class_variable_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableTargetNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_class_variable_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_class_variable_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantAndWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_constant_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantOperatorWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_constant_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantOrWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_constant_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathAndWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_constant_path_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_constant_path_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathOperatorWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_constant_path_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathOrWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_constant_path_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathTargetNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_constant_path_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_constant_path_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantReadNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_constant_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantTargetNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_constant_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_constant_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a DefNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_def_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a DefinedNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_defined_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ElseNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_else_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a EmbeddedStatementsNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_embedded_statements_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a EmbeddedVariableNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_embedded_variable_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a EnsureNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_ensure_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a FalseNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_false_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a FindPatternNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_find_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a FlipFlopNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_flip_flop_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a FloatNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_float_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ForNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_for_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ForwardingArgumentsNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_forwarding_arguments_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ForwardingParameterNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_forwarding_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ForwardingSuperNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_forwarding_super_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableAndWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_global_variable_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableOperatorWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_global_variable_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableOrWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_global_variable_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableReadNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_global_variable_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableTargetNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_global_variable_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_global_variable_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a HashNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_hash_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a HashPatternNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_hash_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IfNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_if_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ImaginaryNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_imaginary_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ImplicitNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_implicit_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ImplicitRestNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_implicit_rest_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_in_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IndexAndWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_index_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IndexOperatorWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_index_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IndexOrWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_index_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IndexTargetNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_index_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableAndWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_instance_variable_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableOperatorWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableOrWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_instance_variable_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableReadNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_instance_variable_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableTargetNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_instance_variable_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_instance_variable_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IntegerNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_integer_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedMatchLastLineNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedRegularExpressionNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedStringNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_interpolated_string_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedSymbolNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_interpolated_symbol_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedXStringNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_interpolated_x_string_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ItLocalVariableReadNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_it_local_variable_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ItParametersNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_it_parameters_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a KeywordHashNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_keyword_hash_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a KeywordRestParameterNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LambdaNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_lambda_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableAndWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_local_variable_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableOperatorWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_local_variable_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableOrWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_local_variable_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableReadNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_local_variable_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableTargetNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_local_variable_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_local_variable_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MatchLastLineNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_match_last_line_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MatchPredicateNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_match_predicate_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MatchRequiredNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_match_required_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MatchWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_match_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MissingNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_missing_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ModuleNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_module_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MultiTargetNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_multi_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MultiWriteNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_multi_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NextNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_next_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NilNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_nil_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NoKeywordsParameterNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_no_keywords_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NumberedParametersNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_numbered_parameters_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NumberedReferenceReadNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_numbered_reference_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a OptionalKeywordParameterNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a OptionalParameterNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_optional_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a OrNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_or_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ParametersNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_parameters_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ParenthesesNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_parentheses_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a PinnedExpressionNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_pinned_expression_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a PinnedVariableNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_pinned_variable_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a PostExecutionNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_post_execution_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a PreExecutionNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_pre_execution_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ProgramNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_program_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RangeNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_range_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RationalNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_rational_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RedoNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_redo_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RegularExpressionNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_regular_expression_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RequiredKeywordParameterNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_required_keyword_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RequiredParameterNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_required_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RescueModifierNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_rescue_modifier_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RescueNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_rescue_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RestParameterNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_rest_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RetryNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_retry_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ReturnNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_return_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SelfNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_self_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ShareableConstantNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_shareable_constant_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SingletonClassNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_singleton_class_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SourceEncodingNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_source_encoding_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SourceFileNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_source_file_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SourceLineNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_source_line_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SplatNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_splat_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a StatementsNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_statements_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a StringNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_string_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SuperNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_super_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SymbolNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_symbol_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a TrueNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_true_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a UndefNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_undef_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a UnlessNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_unless_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a UntilNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_until_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a WhenNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_when_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a WhileNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_while_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a XStringNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_x_string_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a YieldNode node
+  #
+  # source://prism//lib/prism/compiler.rb#39
+  def visit_yield_node(node); end
+end
+
+# Represents the use of the `&&=` operator for assignment to a constant.
+#
+#     Target &&= value
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#3953
+class Prism::ConstantAndWriteNode < ::Prism::Node
+  # Initialize a new ConstantAndWriteNode node.
+  #
+  # @return [ConstantAndWriteNode] a new instance of ConstantAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#3955
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#4041
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#3967
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3972
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#3982
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#3977
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ConstantAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#3987
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantAndWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#3972
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#3995
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # source://prism//lib/prism/desugar_compiler.rb#182
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#4025
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#4000
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#4003
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#4020
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#4010
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#4030
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#4017
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#4035
+    def type; end
+  end
+end
+
+# Represents assigning to a constant using an operator that isn't `=`.
+#
+#     Target += value
+#     ^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#4054
+class Prism::ConstantOperatorWriteNode < ::Prism::Node
+  # Initialize a new ConstantOperatorWriteNode node.
+  #
+  # @return [ConstantOperatorWriteNode] a new instance of ConstantOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#4056
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#4141
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#4069
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader binary_operator: Symbol
+  #
+  # source://prism//lib/prism/node.rb#4122
+  sig { returns(Symbol) }
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#4112
+  sig { returns(Prism::Location) }
+  def binary_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4074
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#4084
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#4079
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ConstantOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#4089
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::ConstantOperatorWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4074
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#4097
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # source://prism//lib/prism/desugar_compiler.rb#194
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#4125
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#4102
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#4105
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  #
+  # source://prism//lib/prism/node_ext.rb#371
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  #
+  # source://prism//lib/prism/node_ext.rb#378
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#4130
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#4119
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#4135
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a constant.
+#
+#     Target ||= value
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#4155
+class Prism::ConstantOrWriteNode < ::Prism::Node
+  # Initialize a new ConstantOrWriteNode node.
+  #
+  # @return [ConstantOrWriteNode] a new instance of ConstantOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#4157
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#4243
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#4169
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4174
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#4184
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#4179
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ConstantOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#4189
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantOrWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4174
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#4197
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # source://prism//lib/prism/desugar_compiler.rb#188
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#4227
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#4202
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#4205
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#4222
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#4212
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#4232
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#4219
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#4237
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator for assignment to a constant path.
+#
+#     Parent::Child &&= value
+#     ^^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#4256
+class Prism::ConstantPathAndWriteNode < ::Prism::Node
+  # Initialize a new ConstantPathAndWriteNode node.
+  #
+  # @return [ConstantPathAndWriteNode] a new instance of ConstantPathAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#4258
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, target, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#4336
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#4269
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4274
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#4284
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#4279
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#4289
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantPathAndWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4274
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#4297
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#4320
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#4315
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#4305
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader target: ConstantPathNode
+  #
+  # source://prism//lib/prism/node.rb#4302
+  sig { returns(Prism::ConstantPathNode) }
+  def target; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#4325
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#4312
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#4330
+    def type; end
+  end
+end
+
+# Represents accessing a constant through a path of `::` operators.
+#
+#     Foo::Bar
+#     ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#4348
+class Prism::ConstantPathNode < ::Prism::Node
+  # Initialize a new ConstantPathNode node.
+  #
+  # @return [ConstantPathNode] a new instance of ConstantPathNode
+  #
+  # source://prism//lib/prism/node.rb#4350
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      parent: T.nilable(Prism::Node),
+      name: T.nilable(Symbol),
+      delimiter_loc: Prism::Location,
+      name_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, parent, name, delimiter_loc, name_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#4459
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#4362
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # Previously, we had a child node on this class that contained either a
+  # constant read or a missing node. To not cause a breaking change, we
+  # continue to supply that API.
+  #
+  # source://prism//lib/prism/node_ext.rb#202
+  def child; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4367
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#4379
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#4372
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location) -> ConstantPathNode
+  #
+  # source://prism//lib/prism/node.rb#4384
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      parent: T.nilable(Prism::Node),
+      name: T.nilable(Symbol),
+      delimiter_loc: Prism::Location,
+      name_loc: Prism::Location
+    ).returns(Prism::ConstantPathNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4367
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#4392
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def delimiter: () -> String
+  #
+  # source://prism//lib/prism/node.rb#4438
+  sig { returns(String) }
+  def delimiter; end
+
+  # The location of the `::` delimiter.
+  #
+  #     ::Foo
+  #     ^^
+  #
+  #     One::Two
+  #        ^^
+  #
+  # source://prism//lib/prism/node.rb#4418
+  sig { returns(Prism::Location) }
+  def delimiter_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # Returns the full name of this constant path. For example: "Foo::Bar"
+  #
+  # source://prism//lib/prism/node_ext.rb#195
+  sig { returns(String) }
+  def full_name; end
+
+  # Returns the list of parts for the full name of this constant path.
+  # For example: [:Foo, :Bar]
+  #
+  # source://prism//lib/prism/node_ext.rb#173
+  sig { returns(T::Array[Symbol]) }
+  def full_name_parts; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#4443
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the constant being accessed. This could be `nil` in the event of a syntax error.
+  #
+  # source://prism//lib/prism/node.rb#4409
+  sig { returns(T.nilable(Symbol)) }
+  def name; end
+
+  # The location of the name of the constant.
+  #
+  #     ::Foo
+  #       ^^^
+  #
+  #     One::Two
+  #          ^^^
+  #
+  # source://prism//lib/prism/node.rb#4431
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # The left-hand node of the path, if present. It can be `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). It will be `nil` when the constant lookup is at the root of the module tree.
+  #
+  #     Foo::Bar
+  #     ^^^
+  #
+  #     self::Test
+  #     ^^^^
+  #
+  #     a.b::C
+  #     ^^^
+  #
+  # source://prism//lib/prism/node.rb#4406
+  sig { returns(T.nilable(Prism::Node)) }
+  def parent; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#4448
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#4453
+    def type; end
+  end
+end
+
+# An error class raised when dynamic parts are found while computing a
+# constant path's full name. For example:
+# Foo::Bar::Baz -> does not raise because all parts of the constant path are
+# simple constants
+# var::Bar::Baz -> raises because the first part of the constant path is a
+# local variable
+#
+# source://prism//lib/prism/node_ext.rb#164
+class Prism::ConstantPathNode::DynamicPartsInConstantPathError < ::StandardError; end
+
+# An error class raised when missing nodes are found while computing a
+# constant path's full name. For example:
+# Foo:: -> raises because the constant path is missing the last part
+#
+# source://prism//lib/prism/node_ext.rb#169
+class Prism::ConstantPathNode::MissingNodesInConstantPathError < ::StandardError; end
+
+# Represents assigning to a constant path using an operator that isn't `=`.
+#
+#     Parent::Child += value
+#     ^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#4472
+class Prism::ConstantPathOperatorWriteNode < ::Prism::Node
+  # Initialize a new ConstantPathOperatorWriteNode node.
+  #
+  # @return [ConstantPathOperatorWriteNode] a new instance of ConstantPathOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#4474
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).void
+  end
+  def initialize(source, node_id, location, flags, target, binary_operator_loc, value, binary_operator); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#4551
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#4486
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader binary_operator: Symbol
+  #
+  # source://prism//lib/prism/node.rb#4532
+  sig { returns(Symbol) }
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#4522
+  sig { returns(Prism::Location) }
+  def binary_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4491
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#4501
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#4496
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ConstantPathOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#4506
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::ConstantPathOperatorWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4491
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#4514
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#4535
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  #
+  # source://prism//lib/prism/node_ext.rb#387
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  #
+  # source://prism//lib/prism/node_ext.rb#394
+  def operator_loc; end
+
+  # attr_reader target: ConstantPathNode
+  #
+  # source://prism//lib/prism/node.rb#4519
+  sig { returns(Prism::ConstantPathNode) }
+  def target; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#4540
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#4529
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#4545
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a constant path.
+#
+#     Parent::Child ||= value
+#     ^^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#4564
+class Prism::ConstantPathOrWriteNode < ::Prism::Node
+  # Initialize a new ConstantPathOrWriteNode node.
+  #
+  # @return [ConstantPathOrWriteNode] a new instance of ConstantPathOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#4566
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, target, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#4644
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#4577
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4582
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#4592
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#4587
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#4597
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantPathOrWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4582
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#4605
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#4628
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#4623
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#4613
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader target: ConstantPathNode
+  #
+  # source://prism//lib/prism/node.rb#4610
+  sig { returns(Prism::ConstantPathNode) }
+  def target; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#4633
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#4620
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#4638
+    def type; end
+  end
+end
+
+# Represents writing to a constant path in a context that doesn't have an explicit value.
+#
+#     Foo::Foo, Bar::Bar = baz
+#     ^^^^^^^^  ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#4656
+class Prism::ConstantPathTargetNode < ::Prism::Node
+  # Initialize a new ConstantPathTargetNode node.
+  #
+  # @return [ConstantPathTargetNode] a new instance of ConstantPathTargetNode
+  #
+  # source://prism//lib/prism/node.rb#4658
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      parent: T.nilable(Prism::Node),
+      name: T.nilable(Symbol),
+      delimiter_loc: Prism::Location,
+      name_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, parent, name, delimiter_loc, name_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#4746
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#4670
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # Previously, we had a child node on this class that contained either a
+  # constant read or a missing node. To not cause a breaking change, we
+  # continue to supply that API.
+  #
+  # source://prism//lib/prism/node_ext.rb#243
+  def child; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4675
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#4687
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#4680
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location) -> ConstantPathTargetNode
+  #
+  # source://prism//lib/prism/node.rb#4692
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      parent: T.nilable(Prism::Node),
+      name: T.nilable(Symbol),
+      delimiter_loc: Prism::Location,
+      name_loc: Prism::Location
+    ).returns(Prism::ConstantPathTargetNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4675
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#4700
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def delimiter: () -> String
+  #
+  # source://prism//lib/prism/node.rb#4725
+  sig { returns(String) }
+  def delimiter; end
+
+  # attr_reader delimiter_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#4711
+  sig { returns(Prism::Location) }
+  def delimiter_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # Returns the full name of this constant path. For example: "Foo::Bar"
+  #
+  # source://prism//lib/prism/node_ext.rb#236
+  sig { returns(String) }
+  def full_name; end
+
+  # Returns the list of parts for the full name of this constant path.
+  # For example: [:Foo, :Bar]
+  #
+  # source://prism//lib/prism/node_ext.rb#216
+  sig { returns(T::Array[Symbol]) }
+  def full_name_parts; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#4730
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol?
+  #
+  # source://prism//lib/prism/node.rb#4708
+  sig { returns(T.nilable(Symbol)) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#4718
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # attr_reader parent: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#4705
+  sig { returns(T.nilable(Prism::Node)) }
+  def parent; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#4735
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#4740
+    def type; end
+  end
+end
+
+# Represents writing to a constant path.
+#
+#     ::Foo = 1
+#     ^^^^^^^^^
+#
+#     Foo::Bar = 1
+#     ^^^^^^^^^^^^
+#
+#     ::Foo::Bar = 1
+#     ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#4765
+class Prism::ConstantPathWriteNode < ::Prism::Node
+  # Initialize a new ConstantPathWriteNode node.
+  #
+  # @return [ConstantPathWriteNode] a new instance of ConstantPathWriteNode
+  #
+  # source://prism//lib/prism/node.rb#4767
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, target, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#4857
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#4778
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4783
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#4793
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#4788
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathWriteNode
+  #
+  # source://prism//lib/prism/node.rb#4798
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantPathWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4783
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#4806
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#4841
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#4836
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `=` operator.
+  #
+  #     ::ABC = 123
+  #           ^
+  #
+  # source://prism//lib/prism/node.rb#4823
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # A node representing the constant path being written to.
+  #
+  #     Foo::Bar = 1
+  #     ^^^^^^^^
+  #
+  #     ::Foo = :abc
+  #     ^^^^^
+  #
+  # source://prism//lib/prism/node.rb#4817
+  sig { returns(Prism::ConstantPathNode) }
+  def target; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#4846
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to write to the constant path. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     FOO::BAR = :abc
+  #                ^^^^
+  #
+  # source://prism//lib/prism/node.rb#4833
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#4851
+    def type; end
+  end
+end
+
+# Represents referencing a constant.
+#
+#     Foo
+#     ^^^
+#
+# source://prism//lib/prism/node.rb#4869
+class Prism::ConstantReadNode < ::Prism::Node
+  # Initialize a new ConstantReadNode node.
+  #
+  # @return [ConstantReadNode] a new instance of ConstantReadNode
+  #
+  # source://prism//lib/prism/node.rb#4871
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#4936
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#4880
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4885
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#4895
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#4890
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ConstantReadNode
+  #
+  # source://prism//lib/prism/node.rb#4900
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::ConstantReadNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4885
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#4908
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # Returns the full name of this constant. For example: "Foo"
+  #
+  # source://prism//lib/prism/node_ext.rb#139
+  sig { returns(String) }
+  def full_name; end
+
+  # Returns the list of parts for the full name of this constant.
+  # For example: [:Foo]
+  #
+  # source://prism//lib/prism/node_ext.rb#134
+  sig { returns(T::Array[Symbol]) }
+  def full_name_parts; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#4920
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
+  #
+  #     X              # name `:X`
+  #
+  #     SOME_CONSTANT  # name `:SOME_CONSTANT`
+  #
+  # source://prism//lib/prism/node.rb#4917
+  sig { returns(Symbol) }
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#4925
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#4930
+    def type; end
+  end
+end
+
+# Represents writing to a constant in a context that doesn't have an explicit value.
+#
+#     Foo, Bar = baz
+#     ^^^  ^^^
+#
+# source://prism//lib/prism/node.rb#4946
+class Prism::ConstantTargetNode < ::Prism::Node
+  # Initialize a new ConstantTargetNode node.
+  #
+  # @return [ConstantTargetNode] a new instance of ConstantTargetNode
+  #
+  # source://prism//lib/prism/node.rb#4948
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#5009
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#4957
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4962
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#4972
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#4967
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ConstantTargetNode
+  #
+  # source://prism//lib/prism/node.rb#4977
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::ConstantTargetNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#4962
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#4985
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # Returns the full name of this constant. For example: "Foo"
+  #
+  # source://prism//lib/prism/node_ext.rb#262
+  sig { returns(String) }
+  def full_name; end
+
+  # Returns the list of parts for the full name of this constant.
+  # For example: [:Foo]
+  #
+  # source://prism//lib/prism/node_ext.rb#257
+  sig { returns(T::Array[Symbol]) }
+  def full_name_parts; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#4993
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#4990
+  sig { returns(Symbol) }
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#4998
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#5003
+    def type; end
+  end
+end
+
+# Represents writing to a constant.
+#
+#     Foo = 1
+#     ^^^^^^^
+#
+# source://prism//lib/prism/node.rb#5019
+class Prism::ConstantWriteNode < ::Prism::Node
+  # Initialize a new ConstantWriteNode node.
+  #
+  # @return [ConstantWriteNode] a new instance of ConstantWriteNode
+  #
+  # source://prism//lib/prism/node.rb#5021
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#5123
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#5033
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5038
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#5048
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#5043
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> ConstantWriteNode
+  #
+  # source://prism//lib/prism/node.rb#5053
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::ConstantWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5038
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#5061
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # Returns the full name of this constant. For example: "Foo"
+  #
+  # source://prism//lib/prism/node_ext.rb#152
+  sig { returns(String) }
+  def full_name; end
+
+  # Returns the list of parts for the full name of this constant.
+  # For example: [:Foo]
+  #
+  # source://prism//lib/prism/node_ext.rb#147
+  sig { returns(T::Array[Symbol]) }
+  def full_name_parts; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#5107
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
+  #
+  #     Foo = :bar # name `:Foo`
+  #
+  #     XYZ = 1    # name `:XYZ`
+  #
+  # source://prism//lib/prism/node.rb#5070
+  sig { returns(Symbol) }
+  def name; end
+
+  # The location of the constant name.
+  #
+  #     FOO = 1
+  #     ^^^
+  #
+  # source://prism//lib/prism/node.rb#5076
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#5102
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `=` operator.
+  #
+  #     FOO = :bar
+  #         ^
+  #
+  # source://prism//lib/prism/node.rb#5095
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#5112
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to write to the constant. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     FOO = :bar
+  #           ^^^^
+  #
+  #     MyClass = Class.new
+  #               ^^^^^^^^^
+  #
+  # source://prism//lib/prism/node.rb#5089
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#5117
+    def type; end
+  end
+end
+
+# The DSL module provides a set of methods that can be used to create prism
+# nodes in a more concise manner. For example, instead of writing:
+#
+#     source = Prism::Source.for("[1]")
+#
+#     Prism::ArrayNode.new(
+#       source,
+#       0,
+#       Prism::Location.new(source, 0, 3),
+#       0,
+#       [
+#         Prism::IntegerNode.new(
+#           source,
+#           0,
+#           Prism::Location.new(source, 1, 1),
+#           Prism::IntegerBaseFlags::DECIMAL,
+#           1
+#         )
+#       ],
+#       Prism::Location.new(source, 0, 1),
+#       Prism::Location.new(source, 2, 1)
+#     )
+#
+# you could instead write:
+#
+#     class Builder
+#       include Prism::DSL
+#
+#       attr_reader :default_source
+#
+#       def initialize
+#         @default_source = source("[1]")
+#       end
+#
+#       def build
+#         array_node(
+#           location: location(start_offset: 0, length: 3),
+#           elements: [
+#             integer_node(
+#               location: location(start_offset: 1, length: 1),
+#               flags: integer_base_flag(:decimal),
+#               value: 1
+#             )
+#           ],
+#           opening_loc: location(start_offset: 0, length: 1),
+#           closing_loc: location(start_offset: 2, length: 1)
+#         )
+#       end
+#     end
+#
+# This is mostly helpful in the context of generating trees programmatically.
+#
+# source://prism//lib/prism/dsl.rb#61
+module Prism::DSL
+  extend ::Prism::DSL
+
+  # Create a new AliasGlobalVariableNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#77
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      new_name: T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode),
+      old_name: T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::SymbolNode, Prism::MissingNode),
+      keyword_loc: Prism::Location
+    ).returns(Prism::AliasGlobalVariableNode)
+  end
+  def alias_global_variable_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # Create a new AliasMethodNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#82
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      new_name: T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode),
+      old_name: T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode, Prism::GlobalVariableReadNode, Prism::MissingNode),
+      keyword_loc: Prism::Location
+    ).returns(Prism::AliasMethodNode)
+  end
+  def alias_method_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # Create a new AlternationPatternNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#87
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: Prism::Node,
+      right: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::AlternationPatternNode)
+  end
+  def alternation_pattern_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new AndNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#92
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: Prism::Node,
+      right: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::AndNode)
+  end
+  def and_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new ArgumentsNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#97
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      arguments: T::Array[Prism::Node]
+    ).returns(Prism::ArgumentsNode)
+  end
+  def arguments_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the ArgumentsNodeFlags flags.
+  #
+  # source://prism//lib/prism/dsl.rb#832
+  sig { params(name: Symbol).returns(Integer) }
+  def arguments_node_flag(name); end
+
+  # Create a new ArrayNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#102
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      elements: T::Array[Prism::Node],
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::ArrayNode)
+  end
+  def array_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), elements: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the ArrayNodeFlags flags.
+  #
+  # source://prism//lib/prism/dsl.rb#844
+  sig { params(name: Symbol).returns(Integer) }
+  def array_node_flag(name); end
+
+  # Create a new ArrayPatternNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#107
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      constant: T.nilable(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode)),
+      requireds: T::Array[Prism::Node],
+      rest: T.nilable(Prism::Node),
+      posts: T::Array[Prism::Node],
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::ArrayPatternNode)
+  end
+  def array_pattern_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), requireds: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new AssocNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#112
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      key: Prism::Node,
+      value: Prism::Node,
+      operator_loc: T.nilable(Prism::Location)
+    ).returns(Prism::AssocNode)
+  end
+  def assoc_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), key: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new AssocSplatNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#117
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).returns(Prism::AssocSplatNode)
+  end
+  def assoc_splat_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new BackReferenceReadNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#122
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::BackReferenceReadNode)
+  end
+  def back_reference_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new BeginNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#127
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      begin_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode),
+      rescue_clause: T.nilable(Prism::RescueNode),
+      else_clause: T.nilable(Prism::ElseNode),
+      ensure_clause: T.nilable(Prism::EnsureNode),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::BeginNode)
+  end
+  def begin_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), begin_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), rescue_clause: T.unsafe(nil), else_clause: T.unsafe(nil), ensure_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new BlockArgumentNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#132
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      expression: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).returns(Prism::BlockArgumentNode)
+  end
+  def block_argument_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new BlockLocalVariableNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#137
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::BlockLocalVariableNode)
+  end
+  def block_local_variable_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new BlockNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#142
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      parameters: T.nilable(T.any(Prism::BlockParametersNode, Prism::NumberedParametersNode, Prism::ItParametersNode)),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).returns(Prism::BlockNode)
+  end
+  def block_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new BlockParameterNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#147
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).returns(Prism::BlockParameterNode)
+  end
+  def block_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new BlockParametersNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#152
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      parameters: T.nilable(Prism::ParametersNode),
+      locals: T::Array[Prism::BlockLocalVariableNode],
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::BlockParametersNode)
+  end
+  def block_parameters_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parameters: T.unsafe(nil), locals: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new BreakNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#157
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      keyword_loc: Prism::Location
+    ).returns(Prism::BreakNode)
+  end
+  def break_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # Create a new CallAndWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#162
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::CallAndWriteNode)
+  end
+  def call_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new CallNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#167
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      name: Symbol,
+      message_loc: T.nilable(Prism::Location),
+      opening_loc: T.nilable(Prism::Location),
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: T.nilable(Prism::Location),
+      block: T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))
+    ).returns(Prism::CallNode)
+  end
+  def call_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the CallNodeFlags flags.
+  #
+  # source://prism//lib/prism/dsl.rb#852
+  sig { params(name: Symbol).returns(Integer) }
+  def call_node_flag(name); end
+
+  # Create a new CallOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#172
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      binary_operator: Symbol,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::CallOperatorWriteNode)
+  end
+  def call_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new CallOrWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#177
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::CallOrWriteNode)
+  end
+  def call_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new CallTargetNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#182
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: Prism::Node,
+      call_operator_loc: Prism::Location,
+      name: Symbol,
+      message_loc: Prism::Location
+    ).returns(Prism::CallTargetNode)
+  end
+  def call_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil)); end
+
+  # Create a new CapturePatternNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#187
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Prism::Node,
+      target: Prism::LocalVariableTargetNode,
+      operator_loc: Prism::Location
+    ).returns(Prism::CapturePatternNode)
+  end
+  def capture_pattern_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new CaseMatchNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#192
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      predicate: T.nilable(Prism::Node),
+      conditions: T::Array[Prism::InNode],
+      else_clause: T.nilable(Prism::ElseNode),
+      case_keyword_loc: Prism::Location,
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::CaseMatchNode)
+  end
+  def case_match_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), predicate: T.unsafe(nil), conditions: T.unsafe(nil), else_clause: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new CaseNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#197
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      predicate: T.nilable(Prism::Node),
+      conditions: T::Array[Prism::WhenNode],
+      else_clause: T.nilable(Prism::ElseNode),
+      case_keyword_loc: Prism::Location,
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::CaseNode)
+  end
+  def case_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), predicate: T.unsafe(nil), conditions: T.unsafe(nil), else_clause: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new ClassNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#202
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      class_keyword_loc: Prism::Location,
+      constant_path: T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::CallNode),
+      inheritance_operator_loc: T.nilable(Prism::Location),
+      superclass: T.nilable(Prism::Node),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      end_keyword_loc: Prism::Location,
+      name: Symbol
+    ).returns(Prism::ClassNode)
+  end
+  def class_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), inheritance_operator_loc: T.unsafe(nil), superclass: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new ClassVariableAndWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#207
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ClassVariableAndWriteNode)
+  end
+  def class_variable_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ClassVariableOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#212
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::ClassVariableOperatorWriteNode)
+  end
+  def class_variable_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # Create a new ClassVariableOrWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#217
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ClassVariableOrWriteNode)
+  end
+  def class_variable_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ClassVariableReadNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#222
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::ClassVariableReadNode)
+  end
+  def class_variable_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new ClassVariableTargetNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#227
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::ClassVariableTargetNode)
+  end
+  def class_variable_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new ClassVariableWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#232
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::ClassVariableWriteNode)
+  end
+  def class_variable_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new ConstantAndWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#237
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantAndWriteNode)
+  end
+  def constant_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ConstantOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#242
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::ConstantOperatorWriteNode)
+  end
+  def constant_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # Create a new ConstantOrWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#247
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantOrWriteNode)
+  end
+  def constant_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ConstantPathAndWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#252
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantPathAndWriteNode)
+  end
+  def constant_path_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ConstantPathNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#257
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      parent: T.nilable(Prism::Node),
+      name: T.nilable(Symbol),
+      delimiter_loc: Prism::Location,
+      name_loc: Prism::Location
+    ).returns(Prism::ConstantPathNode)
+  end
+  def constant_path_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil)); end
+
+  # Create a new ConstantPathOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#262
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::ConstantPathOperatorWriteNode)
+  end
+  def constant_path_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # Create a new ConstantPathOrWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#267
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantPathOrWriteNode)
+  end
+  def constant_path_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ConstantPathTargetNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#272
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      parent: T.nilable(Prism::Node),
+      name: T.nilable(Symbol),
+      delimiter_loc: Prism::Location,
+      name_loc: Prism::Location
+    ).returns(Prism::ConstantPathTargetNode)
+  end
+  def constant_path_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil)); end
+
+  # Create a new ConstantPathWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#277
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantPathWriteNode)
+  end
+  def constant_path_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ConstantReadNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#282
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::ConstantReadNode)
+  end
+  def constant_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new ConstantTargetNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#287
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::ConstantTargetNode)
+  end
+  def constant_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new ConstantWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#292
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::ConstantWriteNode)
+  end
+  def constant_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new DefNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#297
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      receiver: T.nilable(Prism::Node),
+      parameters: T.nilable(Prism::ParametersNode),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      locals: T::Array[Symbol],
+      def_keyword_loc: Prism::Location,
+      operator_loc: T.nilable(Prism::Location),
+      lparen_loc: T.nilable(Prism::Location),
+      rparen_loc: T.nilable(Prism::Location),
+      equal_loc: T.nilable(Prism::Location),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::DefNode)
+  end
+  def def_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), receiver: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), locals: T.unsafe(nil), def_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), equal_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new DefinedNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#302
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      lparen_loc: T.nilable(Prism::Location),
+      value: Prism::Node,
+      rparen_loc: T.nilable(Prism::Location),
+      keyword_loc: Prism::Location
+    ).returns(Prism::DefinedNode)
+  end
+  def defined_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lparen_loc: T.unsafe(nil), value: T.unsafe(nil), rparen_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # Create a new ElseNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#307
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      else_keyword_loc: Prism::Location,
+      statements: T.nilable(Prism::StatementsNode),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::ElseNode)
+  end
+  def else_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), else_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new EmbeddedStatementsNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#312
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      statements: T.nilable(Prism::StatementsNode),
+      closing_loc: Prism::Location
+    ).returns(Prism::EmbeddedStatementsNode)
+  end
+  def embedded_statements_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), statements: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new EmbeddedVariableNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#317
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      operator_loc: Prism::Location,
+      variable: T.any(Prism::InstanceVariableReadNode, Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)
+    ).returns(Prism::EmbeddedVariableNode)
+  end
+  def embedded_variable_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), variable: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the EncodingFlags flags.
+  #
+  # source://prism//lib/prism/dsl.rb#863
+  sig { params(name: Symbol).returns(Integer) }
+  def encoding_flag(name); end
+
+  # Create a new EnsureNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#322
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      ensure_keyword_loc: Prism::Location,
+      statements: T.nilable(Prism::StatementsNode),
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::EnsureNode)
+  end
+  def ensure_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), ensure_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new FalseNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#327
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::FalseNode)
+  end
+  def false_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new FindPatternNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#332
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      constant: T.nilable(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode)),
+      left: Prism::SplatNode,
+      requireds: T::Array[Prism::Node],
+      right: T.any(Prism::SplatNode, Prism::MissingNode),
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::FindPatternNode)
+  end
+  def find_pattern_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), left: T.unsafe(nil), requireds: T.unsafe(nil), right: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new FlipFlopNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#337
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: T.nilable(Prism::Node),
+      right: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).returns(Prism::FlipFlopNode)
+  end
+  def flip_flop_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new FloatNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#342
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Float
+    ).returns(Prism::FloatNode)
+  end
+  def float_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ForNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#347
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      index: T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::MissingNode),
+      collection: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode),
+      for_keyword_loc: Prism::Location,
+      in_keyword_loc: Prism::Location,
+      do_keyword_loc: T.nilable(Prism::Location),
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::ForNode)
+  end
+  def for_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), index: T.unsafe(nil), collection: T.unsafe(nil), statements: T.unsafe(nil), for_keyword_loc: T.unsafe(nil), in_keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new ForwardingArgumentsNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#352
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::ForwardingArgumentsNode)
+  end
+  def forwarding_arguments_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new ForwardingParameterNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#357
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::ForwardingParameterNode)
+  end
+  def forwarding_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new ForwardingSuperNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#362
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      block: T.nilable(Prism::BlockNode)
+    ).returns(Prism::ForwardingSuperNode)
+  end
+  def forwarding_super_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # Create a new GlobalVariableAndWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#367
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::GlobalVariableAndWriteNode)
+  end
+  def global_variable_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new GlobalVariableOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#372
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::GlobalVariableOperatorWriteNode)
+  end
+  def global_variable_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # Create a new GlobalVariableOrWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#377
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::GlobalVariableOrWriteNode)
+  end
+  def global_variable_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new GlobalVariableReadNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#382
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::GlobalVariableReadNode)
+  end
+  def global_variable_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new GlobalVariableTargetNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#387
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::GlobalVariableTargetNode)
+  end
+  def global_variable_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new GlobalVariableWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#392
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::GlobalVariableWriteNode)
+  end
+  def global_variable_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new HashNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#397
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)],
+      closing_loc: Prism::Location
+    ).returns(Prism::HashNode)
+  end
+  def hash_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), elements: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new HashPatternNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#402
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      constant: T.nilable(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode)),
+      elements: T::Array[Prism::AssocNode],
+      rest: T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode)),
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::HashPatternNode)
+  end
+  def hash_pattern_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), elements: T.unsafe(nil), rest: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new IfNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#407
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      if_keyword_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      then_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode),
+      subsequent: T.nilable(T.any(Prism::ElseNode, Prism::IfNode)),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::IfNode)
+  end
+  def if_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), if_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), subsequent: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new ImaginaryNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#412
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      numeric: T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode)
+    ).returns(Prism::ImaginaryNode)
+  end
+  def imaginary_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), numeric: T.unsafe(nil)); end
+
+  # Create a new ImplicitNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#417
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: T.any(Prism::LocalVariableReadNode, Prism::CallNode, Prism::ConstantReadNode, Prism::LocalVariableTargetNode)
+    ).returns(Prism::ImplicitNode)
+  end
+  def implicit_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ImplicitRestNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#422
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::ImplicitRestNode)
+  end
+  def implicit_rest_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new InNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#427
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      pattern: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode),
+      in_loc: Prism::Location,
+      then_loc: T.nilable(Prism::Location)
+    ).returns(Prism::InNode)
+  end
+  def in_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), pattern: T.unsafe(nil), statements: T.unsafe(nil), in_loc: T.unsafe(nil), then_loc: T.unsafe(nil)); end
+
+  # Create a new IndexAndWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#432
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::BlockArgumentNode),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::IndexAndWriteNode)
+  end
+  def index_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new IndexOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#437
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::BlockArgumentNode),
+      binary_operator: Symbol,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::IndexOperatorWriteNode)
+  end
+  def index_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new IndexOrWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#442
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::BlockArgumentNode),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::IndexOrWriteNode)
+  end
+  def index_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new IndexTargetNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#447
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: Prism::Node,
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::BlockArgumentNode)
+    ).returns(Prism::IndexTargetNode)
+  end
+  def index_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # Create a new InstanceVariableAndWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#452
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::InstanceVariableAndWriteNode)
+  end
+  def instance_variable_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new InstanceVariableOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#457
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::InstanceVariableOperatorWriteNode)
+  end
+  def instance_variable_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # Create a new InstanceVariableOrWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#462
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::InstanceVariableOrWriteNode)
+  end
+  def instance_variable_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new InstanceVariableReadNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#467
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::InstanceVariableReadNode)
+  end
+  def instance_variable_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new InstanceVariableTargetNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#472
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::InstanceVariableTargetNode)
+  end
+  def instance_variable_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new InstanceVariableWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#477
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::InstanceVariableWriteNode)
+  end
+  def instance_variable_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the IntegerBaseFlags flags.
+  #
+  # source://prism//lib/prism/dsl.rb#872
+  sig { params(name: Symbol).returns(Integer) }
+  def integer_base_flag(name); end
+
+  # Create a new IntegerNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#482
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Integer
+    ).returns(Prism::IntegerNode)
+  end
+  def integer_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new InterpolatedMatchLastLineNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#487
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).returns(Prism::InterpolatedMatchLastLineNode)
+  end
+  def interpolated_match_last_line_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new InterpolatedRegularExpressionNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#492
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).returns(Prism::InterpolatedRegularExpressionNode)
+  end
+  def interpolated_regular_expression_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new InterpolatedStringNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#497
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)],
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::InterpolatedStringNode)
+  end
+  def interpolated_string_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the InterpolatedStringNodeFlags flags.
+  #
+  # source://prism//lib/prism/dsl.rb#883
+  sig { params(name: Symbol).returns(Integer) }
+  def interpolated_string_node_flag(name); end
+
+  # Create a new InterpolatedSymbolNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#502
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::InterpolatedSymbolNode)
+  end
+  def interpolated_symbol_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new InterpolatedXStringNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#507
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).returns(Prism::InterpolatedXStringNode)
+  end
+  def interpolated_x_string_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new ItLocalVariableReadNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#512
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::ItLocalVariableReadNode)
+  end
+  def it_local_variable_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new ItParametersNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#517
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::ItParametersNode)
+  end
+  def it_parameters_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new KeywordHashNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#522
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]
+    ).returns(Prism::KeywordHashNode)
+  end
+  def keyword_hash_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), elements: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the KeywordHashNodeFlags flags.
+  #
+  # source://prism//lib/prism/dsl.rb#892
+  sig { params(name: Symbol).returns(Integer) }
+  def keyword_hash_node_flag(name); end
+
+  # Create a new KeywordRestParameterNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#527
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).returns(Prism::KeywordRestParameterNode)
+  end
+  def keyword_rest_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new LambdaNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#532
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      operator_loc: Prism::Location,
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      parameters: T.nilable(T.any(Prism::BlockParametersNode, Prism::NumberedParametersNode, Prism::ItParametersNode)),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))
+    ).returns(Prism::LambdaNode)
+  end
+  def lambda_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil)); end
+
+  # Create a new LocalVariableAndWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#537
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node,
+      name: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableAndWriteNode)
+  end
+  def local_variable_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # Create a new LocalVariableOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#542
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      name: Symbol,
+      binary_operator: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableOperatorWriteNode)
+  end
+  def local_variable_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), binary_operator: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # Create a new LocalVariableOrWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#547
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node,
+      name: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableOrWriteNode)
+  end
+  def local_variable_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # Create a new LocalVariableReadNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#552
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableReadNode)
+  end
+  def local_variable_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # Create a new LocalVariableTargetNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#557
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableTargetNode)
+  end
+  def local_variable_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # Create a new LocalVariableWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#562
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      depth: Integer,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::LocalVariableWriteNode)
+  end
+  def local_variable_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new Location object.
+  #
+  # source://prism//lib/prism/dsl.rb#72
+  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).returns(Prism::Location) }
+  def location(source: T.unsafe(nil), start_offset: T.unsafe(nil), length: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the LoopFlags flags.
+  #
+  # source://prism//lib/prism/dsl.rb#900
+  sig { params(name: Symbol).returns(Integer) }
+  def loop_flag(name); end
+
+  # Create a new MatchLastLineNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#567
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).returns(Prism::MatchLastLineNode)
+  end
+  def match_last_line_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # Create a new MatchPredicateNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#572
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Prism::Node,
+      pattern: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::MatchPredicateNode)
+  end
+  def match_predicate_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new MatchRequiredNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#577
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Prism::Node,
+      pattern: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::MatchRequiredNode)
+  end
+  def match_required_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new MatchWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#582
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      call: Prism::CallNode,
+      targets: T::Array[Prism::LocalVariableTargetNode]
+    ).returns(Prism::MatchWriteNode)
+  end
+  def match_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), call: T.unsafe(nil), targets: T.unsafe(nil)); end
+
+  # Create a new MissingNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#587
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::MissingNode)
+  end
+  def missing_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new ModuleNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#592
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      module_keyword_loc: Prism::Location,
+      constant_path: T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::MissingNode),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      end_keyword_loc: Prism::Location,
+      name: Symbol
+    ).returns(Prism::ModuleNode)
+  end
+  def module_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), module_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new MultiTargetNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#597
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
+      rest: T.nilable(T.any(Prism::ImplicitRestNode, Prism::SplatNode)),
+      rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
+      lparen_loc: T.nilable(Prism::Location),
+      rparen_loc: T.nilable(Prism::Location)
+    ).returns(Prism::MultiTargetNode)
+  end
+  def multi_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end
+
+  # Create a new MultiWriteNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#602
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
+      rest: T.nilable(T.any(Prism::ImplicitRestNode, Prism::SplatNode)),
+      rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
+      lparen_loc: T.nilable(Prism::Location),
+      rparen_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::MultiWriteNode)
+  end
+  def multi_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new NextNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#607
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      keyword_loc: Prism::Location
+    ).returns(Prism::NextNode)
+  end
+  def next_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # Create a new NilNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#612
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::NilNode)
+  end
+  def nil_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new NoKeywordsParameterNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#617
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      operator_loc: Prism::Location,
+      keyword_loc: Prism::Location
+    ).returns(Prism::NoKeywordsParameterNode)
+  end
+  def no_keywords_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # Create a new NumberedParametersNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#622
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      maximum: Integer
+    ).returns(Prism::NumberedParametersNode)
+  end
+  def numbered_parameters_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), maximum: T.unsafe(nil)); end
+
+  # Create a new NumberedReferenceReadNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#627
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      number: Integer
+    ).returns(Prism::NumberedReferenceReadNode)
+  end
+  def numbered_reference_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), number: T.unsafe(nil)); end
+
+  # Create a new OptionalKeywordParameterNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#632
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::OptionalKeywordParameterNode)
+  end
+  def optional_keyword_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new OptionalParameterNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#637
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::OptionalParameterNode)
+  end
+  def optional_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new OrNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#642
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: Prism::Node,
+      right: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::OrNode)
+  end
+  def or_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the ParameterFlags flags.
+  #
+  # source://prism//lib/prism/dsl.rb#908
+  sig { params(name: Symbol).returns(Integer) }
+  def parameter_flag(name); end
+
+  # Create a new ParametersNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#647
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      requireds: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)],
+      optionals: T::Array[Prism::OptionalParameterNode],
+      rest: T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode)),
+      posts: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)],
+      keywords: T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)],
+      keyword_rest: T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)),
+      block: T.nilable(Prism::BlockParameterNode)
+    ).returns(Prism::ParametersNode)
+  end
+  def parameters_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), requireds: T.unsafe(nil), optionals: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), keywords: T.unsafe(nil), keyword_rest: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # Create a new ParenthesesNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#652
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      body: T.nilable(Prism::Node),
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).returns(Prism::ParenthesesNode)
+  end
+  def parentheses_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new PinnedExpressionNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#657
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      expression: Prism::Node,
+      operator_loc: Prism::Location,
+      lparen_loc: Prism::Location,
+      rparen_loc: Prism::Location
+    ).returns(Prism::PinnedExpressionNode)
+  end
+  def pinned_expression_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end
+
+  # Create a new PinnedVariableNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#662
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      variable: T.any(Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode, Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::ItLocalVariableReadNode, Prism::MissingNode),
+      operator_loc: Prism::Location
+    ).returns(Prism::PinnedVariableNode)
+  end
+  def pinned_variable_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), variable: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new PostExecutionNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#667
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      statements: T.nilable(Prism::StatementsNode),
+      keyword_loc: Prism::Location,
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).returns(Prism::PostExecutionNode)
+  end
+  def post_execution_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new PreExecutionNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#672
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      statements: T.nilable(Prism::StatementsNode),
+      keyword_loc: Prism::Location,
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).returns(Prism::PreExecutionNode)
+  end
+  def pre_execution_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new ProgramNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#677
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      statements: Prism::StatementsNode
+    ).returns(Prism::ProgramNode)
+  end
+  def program_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the RangeFlags flags.
+  #
+  # source://prism//lib/prism/dsl.rb#916
+  sig { params(name: Symbol).returns(Integer) }
+  def range_flag(name); end
+
+  # Create a new RangeNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#682
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: T.nilable(Prism::Node),
+      right: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).returns(Prism::RangeNode)
+  end
+  def range_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new RationalNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#687
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      numerator: Integer,
+      denominator: Integer
+    ).returns(Prism::RationalNode)
+  end
+  def rational_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), numerator: T.unsafe(nil), denominator: T.unsafe(nil)); end
+
+  # Create a new RedoNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#692
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::RedoNode)
+  end
+  def redo_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the RegularExpressionFlags flags.
+  #
+  # source://prism//lib/prism/dsl.rb#924
+  sig { params(name: Symbol).returns(Integer) }
+  def regular_expression_flag(name); end
+
+  # Create a new RegularExpressionNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#697
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).returns(Prism::RegularExpressionNode)
+  end
+  def regular_expression_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # Create a new RequiredKeywordParameterNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#702
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location
+    ).returns(Prism::RequiredKeywordParameterNode)
+  end
+  def required_keyword_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil)); end
+
+  # Create a new RequiredParameterNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#707
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::RequiredParameterNode)
+  end
+  def required_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new RescueModifierNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#712
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      expression: Prism::Node,
+      keyword_loc: Prism::Location,
+      rescue_expression: Prism::Node
+    ).returns(Prism::RescueModifierNode)
+  end
+  def rescue_modifier_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), keyword_loc: T.unsafe(nil), rescue_expression: T.unsafe(nil)); end
+
+  # Create a new RescueNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#717
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      exceptions: T::Array[Prism::Node],
+      operator_loc: T.nilable(Prism::Location),
+      reference: T.nilable(T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::MissingNode)),
+      statements: T.nilable(Prism::StatementsNode),
+      subsequent: T.nilable(Prism::RescueNode)
+    ).returns(Prism::RescueNode)
+  end
+  def rescue_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), exceptions: T.unsafe(nil), operator_loc: T.unsafe(nil), reference: T.unsafe(nil), statements: T.unsafe(nil), subsequent: T.unsafe(nil)); end
+
+  # Create a new RestParameterNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#722
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).returns(Prism::RestParameterNode)
+  end
+  def rest_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new RetryNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#727
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::RetryNode)
+  end
+  def retry_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new ReturnNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#732
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode)
+    ).returns(Prism::ReturnNode)
+  end
+  def return_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), arguments: T.unsafe(nil)); end
+
+  # Create a new SelfNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#737
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::SelfNode)
+  end
+  def self_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new ShareableConstantNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#742
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      write: T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode)
+    ).returns(Prism::ShareableConstantNode)
+  end
+  def shareable_constant_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), write: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the ShareableConstantNodeFlags flags.
+  #
+  # source://prism//lib/prism/dsl.rb#942
+  sig { params(name: Symbol).returns(Integer) }
+  def shareable_constant_node_flag(name); end
+
+  # Create a new SingletonClassNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#747
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      class_keyword_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      expression: Prism::Node,
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::SingletonClassNode)
+  end
+  def singleton_class_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new Source object.
+  #
+  # source://prism//lib/prism/dsl.rb#67
+  sig { params(string: String).returns(Prism::Source) }
+  def source(string); end
+
+  # Create a new SourceEncodingNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#752
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::SourceEncodingNode)
+  end
+  def source_encoding_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new SourceFileNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#757
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      filepath: String
+    ).returns(Prism::SourceFileNode)
+  end
+  def source_file_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), filepath: T.unsafe(nil)); end
+
+  # Create a new SourceLineNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#762
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::SourceLineNode)
+  end
+  def source_line_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new SplatNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#767
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      operator_loc: Prism::Location,
+      expression: T.nilable(Prism::Node)
+    ).returns(Prism::SplatNode)
+  end
+  def splat_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil)); end
+
+  # Create a new StatementsNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#772
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      body: T::Array[Prism::Node]
+    ).returns(Prism::StatementsNode)
+  end
+  def statements_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), body: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the StringFlags flags.
+  #
+  # source://prism//lib/prism/dsl.rb#952
+  sig { params(name: Symbol).returns(Integer) }
+  def string_flag(name); end
+
+  # Create a new StringNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#777
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      content_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      unescaped: String
+    ).returns(Prism::StringNode)
+  end
+  def string_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # Create a new SuperNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#782
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      lparen_loc: T.nilable(Prism::Location),
+      arguments: T.nilable(Prism::ArgumentsNode),
+      rparen_loc: T.nilable(Prism::Location),
+      block: T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))
+    ).returns(Prism::SuperNode)
+  end
+  def super_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the SymbolFlags flags.
+  #
+  # source://prism//lib/prism/dsl.rb#963
+  sig { params(name: Symbol).returns(Integer) }
+  def symbol_flag(name); end
+
+  # Create a new SymbolNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#787
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      value_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location),
+      unescaped: String
+    ).returns(Prism::SymbolNode)
+  end
+  def symbol_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), value_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # Create a new TrueNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#792
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::TrueNode)
+  end
+  def true_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new UndefNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#797
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      names: T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)],
+      keyword_loc: Prism::Location
+    ).returns(Prism::UndefNode)
+  end
+  def undef_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), names: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # Create a new UnlessNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#802
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      predicate: Prism::Node,
+      then_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode),
+      else_clause: T.nilable(Prism::ElseNode),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::UnlessNode)
+  end
+  def unless_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), else_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new UntilNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#807
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode)
+    ).returns(Prism::UntilNode)
+  end
+  def until_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # Create a new WhenNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#812
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      conditions: T::Array[Prism::Node],
+      then_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode)
+    ).returns(Prism::WhenNode)
+  end
+  def when_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), conditions: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # Create a new WhileNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#817
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode)
+    ).returns(Prism::WhileNode)
+  end
+  def while_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # Create a new XStringNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#822
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).returns(Prism::XStringNode)
+  end
+  def x_string_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # Create a new YieldNode node.
+  #
+  # source://prism//lib/prism/dsl.rb#827
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      lparen_loc: T.nilable(Prism::Location),
+      arguments: T.nilable(Prism::ArgumentsNode),
+      rparen_loc: T.nilable(Prism::Location)
+    ).returns(Prism::YieldNode)
+  end
+  def yield_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end
+
+  private
+
+  # The default location object that gets attached to nodes if no location is
+  # specified, which uses the given source.
+  #
+  # source://prism//lib/prism/dsl.rb#982
+  sig { returns(Prism::Location) }
+  def default_location; end
+
+  # The default node that gets attached to nodes if no node is specified for a
+  # required node field.
+  #
+  # source://prism//lib/prism/dsl.rb#988
+  sig { params(source: Prism::Source, location: Prism::Location).returns(Prism::Node) }
+  def default_node(source, location); end
+
+  # The default source object that gets attached to nodes and locations if no
+  # source is specified.
+  #
+  # source://prism//lib/prism/dsl.rb#976
+  sig { returns(Prism::Source) }
+  def default_source; end
+end
+
+# Represents a method definition.
+#
+#     def method
+#     end
+#     ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#5137
+class Prism::DefNode < ::Prism::Node
+  # Initialize a new DefNode node.
+  #
+  # @return [DefNode] a new instance of DefNode
+  #
+  # source://prism//lib/prism/node.rb#5139
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      receiver: T.nilable(Prism::Node),
+      parameters: T.nilable(Prism::ParametersNode),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      locals: T::Array[Symbol],
+      def_keyword_loc: Prism::Location,
+      operator_loc: T.nilable(Prism::Location),
+      lparen_loc: T.nilable(Prism::Location),
+      rparen_loc: T.nilable(Prism::Location),
+      equal_loc: T.nilable(Prism::Location),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#5336
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#5159
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader body: StatementsNode | BeginNode | nil
+  #
+  # source://prism//lib/prism/node.rb#5212
+  sig { returns(T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5164
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#5178
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#5169
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?receiver: Prism::node?, ?parameters: ParametersNode?, ?body: StatementsNode | BeginNode | nil, ?locals: Array[Symbol], ?def_keyword_loc: Location, ?operator_loc: Location?, ?lparen_loc: Location?, ?rparen_loc: Location?, ?equal_loc: Location?, ?end_keyword_loc: Location?) -> DefNode
+  #
+  # source://prism//lib/prism/node.rb#5183
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      receiver: T.nilable(Prism::Node),
+      parameters: T.nilable(Prism::ParametersNode),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      locals: T::Array[Symbol],
+      def_keyword_loc: Prism::Location,
+      operator_loc: T.nilable(Prism::Location),
+      lparen_loc: T.nilable(Prism::Location),
+      rparen_loc: T.nilable(Prism::Location),
+      equal_loc: T.nilable(Prism::Location),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::DefNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), receiver: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), locals: T.unsafe(nil), def_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), equal_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5164
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, receiver: Prism::node?, parameters: ParametersNode?, body: StatementsNode | BeginNode | nil, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#5191
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def def_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#5290
+  sig { returns(String) }
+  def def_keyword; end
+
+  # attr_reader def_keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#5218
+  sig { returns(Prism::Location) }
+  def def_keyword_loc; end
+
+  # def end_keyword: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#5315
+  sig { returns(T.nilable(String)) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#5277
+  sig { returns(T.nilable(Prism::Location)) }
+  def end_keyword_loc; end
+
+  # def equal: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#5310
+  sig { returns(T.nilable(String)) }
+  def equal; end
+
+  # attr_reader equal_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#5264
+  sig { returns(T.nilable(Prism::Location)) }
+  def equal_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#5320
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[Symbol]
+  #
+  # source://prism//lib/prism/node.rb#5215
+  sig { returns(T::Array[Symbol]) }
+  def locals; end
+
+  # def lparen: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#5300
+  sig { returns(T.nilable(String)) }
+  def lparen; end
+
+  # attr_reader lparen_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#5238
+  sig { returns(T.nilable(Prism::Location)) }
+  def lparen_loc; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#5196
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#5199
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#5295
+  sig { returns(T.nilable(String)) }
+  def operator; end
+
+  # attr_reader operator_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#5225
+  sig { returns(T.nilable(Prism::Location)) }
+  def operator_loc; end
+
+  # attr_reader parameters: ParametersNode?
+  #
+  # source://prism//lib/prism/node.rb#5209
+  sig { returns(T.nilable(Prism::ParametersNode)) }
+  def parameters; end
+
+  # attr_reader receiver: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#5206
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def rparen: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#5305
+  sig { returns(T.nilable(String)) }
+  def rparen; end
+
+  # attr_reader rparen_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#5251
+  sig { returns(T.nilable(Prism::Location)) }
+  def rparen_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#5325
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#5330
+    def type; end
+  end
+end
+
+# Represents the use of the `defined?` keyword.
+#
+#     defined?(a)
+#     ^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#5358
+class Prism::DefinedNode < ::Prism::Node
+  # Initialize a new DefinedNode node.
+  #
+  # @return [DefinedNode] a new instance of DefinedNode
+  #
+  # source://prism//lib/prism/node.rb#5360
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      lparen_loc: T.nilable(Prism::Location),
+      value: Prism::Node,
+      rparen_loc: T.nilable(Prism::Location),
+      keyword_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, lparen_loc, value, rparen_loc, keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#5472
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#5372
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5377
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#5387
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#5382
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lparen_loc: Location?, ?value: Prism::node, ?rparen_loc: Location?, ?keyword_loc: Location) -> DefinedNode
+  #
+  # source://prism//lib/prism/node.rb#5392
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      lparen_loc: T.nilable(Prism::Location),
+      value: Prism::Node,
+      rparen_loc: T.nilable(Prism::Location),
+      keyword_loc: Prism::Location
+    ).returns(Prism::DefinedNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lparen_loc: T.unsafe(nil), value: T.unsafe(nil), rparen_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5377
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lparen_loc: Location?, value: Prism::node, rparen_loc: Location?, keyword_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#5400
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#5456
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#5451
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#5434
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # def lparen: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#5441
+  sig { returns(T.nilable(String)) }
+  def lparen; end
+
+  # attr_reader lparen_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#5405
+  sig { returns(T.nilable(Prism::Location)) }
+  def lparen_loc; end
+
+  # def rparen: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#5446
+  sig { returns(T.nilable(String)) }
+  def rparen; end
+
+  # attr_reader rparen_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#5421
+  sig { returns(T.nilable(Prism::Location)) }
+  def rparen_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#5461
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#5418
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#5466
+    def type; end
+  end
+end
+
+# source://prism//lib/prism/desugar_compiler.rb#4
+class Prism::DesugarAndWriteNode
+  include ::Prism::DSL
+
+  # @return [DesugarAndWriteNode] a new instance of DesugarAndWriteNode
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#9
+  def initialize(node, default_source, read_class, write_class, **arguments); end
+
+  # Returns the value of attribute arguments.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#7
+  def arguments; end
+
+  # Desugar `x &&= y` to `x && x = y`
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#18
+  def compile; end
+
+  # Returns the value of attribute default_source.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#7
+  def default_source; end
+
+  # Returns the value of attribute node.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#7
+  def node; end
+
+  # Returns the value of attribute read_class.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#7
+  def read_class; end
+
+  # Returns the value of attribute write_class.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#7
+  def write_class; end
+end
+
+# DesugarCompiler is a compiler that desugars Ruby code into a more primitive
+# form. This is useful for consumers that want to deal with fewer node types.
+#
+# source://prism//lib/prism/desugar_compiler.rb#255
+class Prism::DesugarCompiler < ::Prism::MutationCompiler
+  # @@foo &&= bar
+  #
+  # becomes
+  #
+  # @@foo && @@foo = bar
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#261
+  def visit_class_variable_and_write_node(node); end
+
+  # @@foo += bar
+  #
+  # becomes
+  #
+  # @@foo = @@foo + bar
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#279
+  def visit_class_variable_operator_write_node(node); end
+
+  # @@foo ||= bar
+  #
+  # becomes
+  #
+  # defined?(@@foo) ? @@foo : @@foo = bar
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#270
+  def visit_class_variable_or_write_node(node); end
+
+  # Foo &&= bar
+  #
+  # becomes
+  #
+  # Foo && Foo = bar
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#288
+  def visit_constant_and_write_node(node); end
+
+  # Foo += bar
+  #
+  # becomes
+  #
+  # Foo = Foo + bar
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#306
+  def visit_constant_operator_write_node(node); end
+
+  # Foo ||= bar
+  #
+  # becomes
+  #
+  # defined?(Foo) ? Foo : Foo = bar
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#297
+  def visit_constant_or_write_node(node); end
+
+  # $foo &&= bar
+  #
+  # becomes
+  #
+  # $foo && $foo = bar
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#315
+  def visit_global_variable_and_write_node(node); end
+
+  # $foo += bar
+  #
+  # becomes
+  #
+  # $foo = $foo + bar
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#333
+  def visit_global_variable_operator_write_node(node); end
+
+  # $foo ||= bar
+  #
+  # becomes
+  #
+  # defined?($foo) ? $foo : $foo = bar
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#324
+  def visit_global_variable_or_write_node(node); end
+
+  # becomes
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#342
+  def visit_instance_variable_and_write_node(node); end
+
+  # becomes
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#360
+  def visit_instance_variable_operator_write_node(node); end
+
+  # becomes
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#351
+  def visit_instance_variable_or_write_node(node); end
+
+  # foo &&= bar
+  #
+  # becomes
+  #
+  # foo && foo = bar
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#369
+  def visit_local_variable_and_write_node(node); end
+
+  # foo += bar
+  #
+  # becomes
+  #
+  # foo = foo + bar
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#387
+  def visit_local_variable_operator_write_node(node); end
+
+  # foo ||= bar
+  #
+  # becomes
+  #
+  # foo || foo = bar
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#378
+  def visit_local_variable_or_write_node(node); end
+end
+
+# source://prism//lib/prism/desugar_compiler.rb#86
+class Prism::DesugarOperatorWriteNode
+  include ::Prism::DSL
+
+  # @return [DesugarOperatorWriteNode] a new instance of DesugarOperatorWriteNode
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#91
+  def initialize(node, default_source, read_class, write_class, **arguments); end
+
+  # Returns the value of attribute arguments.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#89
+  def arguments; end
+
+  # Desugar `x += y` to `x = x + y`
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#100
+  def compile; end
+
+  # Returns the value of attribute default_source.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#89
+  def default_source; end
+
+  # Returns the value of attribute node.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#89
+  def node; end
+
+  # Returns the value of attribute read_class.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#89
+  def read_class; end
+
+  # Returns the value of attribute write_class.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#89
+  def write_class; end
+end
+
+# source://prism//lib/prism/desugar_compiler.rb#35
+class Prism::DesugarOrWriteDefinedNode
+  include ::Prism::DSL
+
+  # @return [DesugarOrWriteDefinedNode] a new instance of DesugarOrWriteDefinedNode
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#40
+  def initialize(node, default_source, read_class, write_class, **arguments); end
+
+  # Returns the value of attribute arguments.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#38
+  def arguments; end
+
+  # Desugar `x ||= y` to `defined?(x) ? x : x = y`
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#49
+  def compile; end
+
+  # Returns the value of attribute default_source.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#38
+  def default_source; end
+
+  # Returns the value of attribute node.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#38
+  def node; end
+
+  # Returns the value of attribute read_class.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#38
+  def read_class; end
+
+  # Returns the value of attribute write_class.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#38
+  def write_class; end
+end
+
+# source://prism//lib/prism/desugar_compiler.rb#130
+class Prism::DesugarOrWriteNode
+  include ::Prism::DSL
+
+  # @return [DesugarOrWriteNode] a new instance of DesugarOrWriteNode
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#135
+  def initialize(node, default_source, read_class, write_class, **arguments); end
+
+  # Returns the value of attribute arguments.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#133
+  def arguments; end
+
+  # Desugar `x ||= y` to `x || x = y`
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#144
+  def compile; end
+
+  # Returns the value of attribute default_source.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#133
+  def default_source; end
+
+  # Returns the value of attribute node.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#133
+  def node; end
+
+  # Returns the value of attribute read_class.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#133
+  def read_class; end
+
+  # Returns the value of attribute write_class.
+  #
+  # source://prism//lib/prism/desugar_compiler.rb#133
+  def write_class; end
+end
+
+# The dispatcher class fires events for nodes that are found while walking an
+# AST to all registered listeners. It's useful for performing different types
+# of analysis on the AST while only having to walk the tree once.
+#
+# To use the dispatcher, you would first instantiate it and register listeners
+# for the events you're interested in:
+#
+#     class OctalListener
+#       def on_integer_node_enter(node)
+#         if node.octal? && !node.slice.start_with?("0o")
+#           warn("Octal integers should be written with the 0o prefix")
+#         end
+#       end
+#     end
+#
+#     listener = OctalListener.new
+#     dispatcher = Prism::Dispatcher.new
+#     dispatcher.register(listener, :on_integer_node_enter)
+#
+# Then, you can walk any number of trees and dispatch events to the listeners:
+#
+#     result = Prism.parse("001 + 002 + 003")
+#     dispatcher.dispatch(result.value)
+#
+# Optionally, you can also use `#dispatch_once` to dispatch enter and leave
+# events for a single node without recursing further down the tree. This can
+# be useful in circumstances where you want to reuse the listeners you already
+# have registers but want to stop walking the tree at a certain point.
+#
+#     integer = result.value.statements.body.first.receiver.receiver
+#     dispatcher.dispatch_once(integer)
+#
+# source://prism//lib/prism/dispatcher.rb#42
+class Prism::Dispatcher < ::Prism::Visitor
+  # Initialize a new dispatcher.
+  #
+  # @return [Dispatcher] a new instance of Dispatcher
+  #
+  # source://prism//lib/prism/dispatcher.rb#47
+  def initialize; end
+
+  # Walks `root` dispatching events to all registered listeners.
+  #
+  # def dispatch: (Node) -> void
+  #
+  # source://prism//lib/prism/visitor.rb#17
+  def dispatch(node); end
+
+  # Dispatches a single event for `node` to all registered listeners.
+  #
+  # def dispatch_once: (Node) -> void
+  #
+  # source://prism//lib/prism/dispatcher.rb#66
+  def dispatch_once(node); end
+
+  # attr_reader listeners: Hash[Symbol, Array[Listener]]
+  #
+  # source://prism//lib/prism/dispatcher.rb#44
+  def listeners; end
+
+  # Register a listener for one or more events.
+  #
+  # def register: (Listener, *Symbol) -> void
+  #
+  # source://prism//lib/prism/dispatcher.rb#54
+  def register(listener, *events); end
+
+  # Dispatch enter and leave events for AliasGlobalVariableNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#72
+  def visit_alias_global_variable_node(node); end
+
+  # Dispatch enter and leave events for AliasMethodNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#80
+  def visit_alias_method_node(node); end
+
+  # Dispatch enter and leave events for AlternationPatternNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#88
+  def visit_alternation_pattern_node(node); end
+
+  # Dispatch enter and leave events for AndNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#96
+  def visit_and_node(node); end
+
+  # Dispatch enter and leave events for ArgumentsNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#104
+  def visit_arguments_node(node); end
+
+  # Dispatch enter and leave events for ArrayNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#112
+  def visit_array_node(node); end
+
+  # Dispatch enter and leave events for ArrayPatternNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#120
+  def visit_array_pattern_node(node); end
+
+  # Dispatch enter and leave events for AssocNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#128
+  def visit_assoc_node(node); end
+
+  # Dispatch enter and leave events for AssocSplatNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#136
+  def visit_assoc_splat_node(node); end
+
+  # Dispatch enter and leave events for BackReferenceReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#144
+  def visit_back_reference_read_node(node); end
+
+  # Dispatch enter and leave events for BeginNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#152
+  def visit_begin_node(node); end
+
+  # Dispatch enter and leave events for BlockArgumentNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#160
+  def visit_block_argument_node(node); end
+
+  # Dispatch enter and leave events for BlockLocalVariableNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#168
+  def visit_block_local_variable_node(node); end
+
+  # Dispatch enter and leave events for BlockNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#176
+  def visit_block_node(node); end
+
+  # Dispatch enter and leave events for BlockParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#184
+  def visit_block_parameter_node(node); end
+
+  # Dispatch enter and leave events for BlockParametersNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#192
+  def visit_block_parameters_node(node); end
+
+  # Dispatch enter and leave events for BreakNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#200
+  def visit_break_node(node); end
+
+  # Dispatch enter and leave events for CallAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#208
+  def visit_call_and_write_node(node); end
+
+  # Dispatch enter and leave events for CallNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#216
+  def visit_call_node(node); end
+
+  # Dispatch enter and leave events for CallOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#224
+  def visit_call_operator_write_node(node); end
+
+  # Dispatch enter and leave events for CallOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#232
+  def visit_call_or_write_node(node); end
+
+  # Dispatch enter and leave events for CallTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#240
+  def visit_call_target_node(node); end
+
+  # Dispatch enter and leave events for CapturePatternNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#248
+  def visit_capture_pattern_node(node); end
+
+  # Dispatch enter and leave events for CaseMatchNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#256
+  def visit_case_match_node(node); end
+
+  # Dispatch enter and leave events for CaseNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#264
+  def visit_case_node(node); end
+
+  # Dispatch enter and leave events for ClassNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#272
+  def visit_class_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#280
+  def visit_class_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#288
+  def visit_class_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#296
+  def visit_class_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#304
+  def visit_class_variable_read_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#312
+  def visit_class_variable_target_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#320
+  def visit_class_variable_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#328
+  def visit_constant_and_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#336
+  def visit_constant_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#344
+  def visit_constant_or_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#352
+  def visit_constant_path_and_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#360
+  def visit_constant_path_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#368
+  def visit_constant_path_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#376
+  def visit_constant_path_or_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#384
+  def visit_constant_path_target_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#392
+  def visit_constant_path_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#400
+  def visit_constant_read_node(node); end
+
+  # Dispatch enter and leave events for ConstantTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#408
+  def visit_constant_target_node(node); end
+
+  # Dispatch enter and leave events for ConstantWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#416
+  def visit_constant_write_node(node); end
+
+  # Dispatch enter and leave events for DefNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#424
+  def visit_def_node(node); end
+
+  # Dispatch enter and leave events for DefinedNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#432
+  def visit_defined_node(node); end
+
+  # Dispatch enter and leave events for ElseNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#440
+  def visit_else_node(node); end
+
+  # Dispatch enter and leave events for EmbeddedStatementsNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#448
+  def visit_embedded_statements_node(node); end
+
+  # Dispatch enter and leave events for EmbeddedVariableNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#456
+  def visit_embedded_variable_node(node); end
+
+  # Dispatch enter and leave events for EnsureNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#464
+  def visit_ensure_node(node); end
+
+  # Dispatch enter and leave events for FalseNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#472
+  def visit_false_node(node); end
+
+  # Dispatch enter and leave events for FindPatternNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#480
+  def visit_find_pattern_node(node); end
+
+  # Dispatch enter and leave events for FlipFlopNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#488
+  def visit_flip_flop_node(node); end
+
+  # Dispatch enter and leave events for FloatNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#496
+  def visit_float_node(node); end
+
+  # Dispatch enter and leave events for ForNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#504
+  def visit_for_node(node); end
+
+  # Dispatch enter and leave events for ForwardingArgumentsNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#512
+  def visit_forwarding_arguments_node(node); end
+
+  # Dispatch enter and leave events for ForwardingParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#520
+  def visit_forwarding_parameter_node(node); end
+
+  # Dispatch enter and leave events for ForwardingSuperNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#528
+  def visit_forwarding_super_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#536
+  def visit_global_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#544
+  def visit_global_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#552
+  def visit_global_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#560
+  def visit_global_variable_read_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#568
+  def visit_global_variable_target_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#576
+  def visit_global_variable_write_node(node); end
+
+  # Dispatch enter and leave events for HashNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#584
+  def visit_hash_node(node); end
+
+  # Dispatch enter and leave events for HashPatternNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#592
+  def visit_hash_pattern_node(node); end
+
+  # Dispatch enter and leave events for IfNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#600
+  def visit_if_node(node); end
+
+  # Dispatch enter and leave events for ImaginaryNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#608
+  def visit_imaginary_node(node); end
+
+  # Dispatch enter and leave events for ImplicitNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#616
+  def visit_implicit_node(node); end
+
+  # Dispatch enter and leave events for ImplicitRestNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#624
+  def visit_implicit_rest_node(node); end
+
+  # Dispatch enter and leave events for InNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#632
+  def visit_in_node(node); end
+
+  # Dispatch enter and leave events for IndexAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#640
+  def visit_index_and_write_node(node); end
+
+  # Dispatch enter and leave events for IndexOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#648
+  def visit_index_operator_write_node(node); end
+
+  # Dispatch enter and leave events for IndexOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#656
+  def visit_index_or_write_node(node); end
+
+  # Dispatch enter and leave events for IndexTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#664
+  def visit_index_target_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#672
+  def visit_instance_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#680
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#688
+  def visit_instance_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#696
+  def visit_instance_variable_read_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#704
+  def visit_instance_variable_target_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#712
+  def visit_instance_variable_write_node(node); end
+
+  # Dispatch enter and leave events for IntegerNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#720
+  def visit_integer_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedMatchLastLineNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#728
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedRegularExpressionNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#736
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedStringNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#744
+  def visit_interpolated_string_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedSymbolNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#752
+  def visit_interpolated_symbol_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedXStringNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#760
+  def visit_interpolated_x_string_node(node); end
+
+  # Dispatch enter and leave events for ItLocalVariableReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#768
+  def visit_it_local_variable_read_node(node); end
+
+  # Dispatch enter and leave events for ItParametersNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#776
+  def visit_it_parameters_node(node); end
+
+  # Dispatch enter and leave events for KeywordHashNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#784
+  def visit_keyword_hash_node(node); end
+
+  # Dispatch enter and leave events for KeywordRestParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#792
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Dispatch enter and leave events for LambdaNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#800
+  def visit_lambda_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#808
+  def visit_local_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#816
+  def visit_local_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#824
+  def visit_local_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#832
+  def visit_local_variable_read_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#840
+  def visit_local_variable_target_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#848
+  def visit_local_variable_write_node(node); end
+
+  # Dispatch enter and leave events for MatchLastLineNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#856
+  def visit_match_last_line_node(node); end
+
+  # Dispatch enter and leave events for MatchPredicateNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#864
+  def visit_match_predicate_node(node); end
+
+  # Dispatch enter and leave events for MatchRequiredNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#872
+  def visit_match_required_node(node); end
+
+  # Dispatch enter and leave events for MatchWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#880
+  def visit_match_write_node(node); end
+
+  # Dispatch enter and leave events for MissingNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#888
+  def visit_missing_node(node); end
+
+  # Dispatch enter and leave events for ModuleNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#896
+  def visit_module_node(node); end
+
+  # Dispatch enter and leave events for MultiTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#904
+  def visit_multi_target_node(node); end
+
+  # Dispatch enter and leave events for MultiWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#912
+  def visit_multi_write_node(node); end
+
+  # Dispatch enter and leave events for NextNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#920
+  def visit_next_node(node); end
+
+  # Dispatch enter and leave events for NilNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#928
+  def visit_nil_node(node); end
+
+  # Dispatch enter and leave events for NoKeywordsParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#936
+  def visit_no_keywords_parameter_node(node); end
+
+  # Dispatch enter and leave events for NumberedParametersNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#944
+  def visit_numbered_parameters_node(node); end
+
+  # Dispatch enter and leave events for NumberedReferenceReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#952
+  def visit_numbered_reference_read_node(node); end
+
+  # Dispatch enter and leave events for OptionalKeywordParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#960
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Dispatch enter and leave events for OptionalParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#968
+  def visit_optional_parameter_node(node); end
+
+  # Dispatch enter and leave events for OrNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#976
+  def visit_or_node(node); end
+
+  # Dispatch enter and leave events for ParametersNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#984
+  def visit_parameters_node(node); end
+
+  # Dispatch enter and leave events for ParenthesesNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#992
+  def visit_parentheses_node(node); end
+
+  # Dispatch enter and leave events for PinnedExpressionNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1000
+  def visit_pinned_expression_node(node); end
+
+  # Dispatch enter and leave events for PinnedVariableNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1008
+  def visit_pinned_variable_node(node); end
+
+  # Dispatch enter and leave events for PostExecutionNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1016
+  def visit_post_execution_node(node); end
+
+  # Dispatch enter and leave events for PreExecutionNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1024
+  def visit_pre_execution_node(node); end
+
+  # Dispatch enter and leave events for ProgramNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1032
+  def visit_program_node(node); end
+
+  # Dispatch enter and leave events for RangeNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1040
+  def visit_range_node(node); end
+
+  # Dispatch enter and leave events for RationalNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1048
+  def visit_rational_node(node); end
+
+  # Dispatch enter and leave events for RedoNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1056
+  def visit_redo_node(node); end
+
+  # Dispatch enter and leave events for RegularExpressionNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1064
+  def visit_regular_expression_node(node); end
+
+  # Dispatch enter and leave events for RequiredKeywordParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1072
+  def visit_required_keyword_parameter_node(node); end
+
+  # Dispatch enter and leave events for RequiredParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1080
+  def visit_required_parameter_node(node); end
+
+  # Dispatch enter and leave events for RescueModifierNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1088
+  def visit_rescue_modifier_node(node); end
+
+  # Dispatch enter and leave events for RescueNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1096
+  def visit_rescue_node(node); end
+
+  # Dispatch enter and leave events for RestParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1104
+  def visit_rest_parameter_node(node); end
+
+  # Dispatch enter and leave events for RetryNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1112
+  def visit_retry_node(node); end
+
+  # Dispatch enter and leave events for ReturnNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1120
+  def visit_return_node(node); end
+
+  # Dispatch enter and leave events for SelfNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1128
+  def visit_self_node(node); end
+
+  # Dispatch enter and leave events for ShareableConstantNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1136
+  def visit_shareable_constant_node(node); end
+
+  # Dispatch enter and leave events for SingletonClassNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1144
+  def visit_singleton_class_node(node); end
+
+  # Dispatch enter and leave events for SourceEncodingNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1152
+  def visit_source_encoding_node(node); end
+
+  # Dispatch enter and leave events for SourceFileNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1160
+  def visit_source_file_node(node); end
+
+  # Dispatch enter and leave events for SourceLineNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1168
+  def visit_source_line_node(node); end
+
+  # Dispatch enter and leave events for SplatNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1176
+  def visit_splat_node(node); end
+
+  # Dispatch enter and leave events for StatementsNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1184
+  def visit_statements_node(node); end
+
+  # Dispatch enter and leave events for StringNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1192
+  def visit_string_node(node); end
+
+  # Dispatch enter and leave events for SuperNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1200
+  def visit_super_node(node); end
+
+  # Dispatch enter and leave events for SymbolNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1208
+  def visit_symbol_node(node); end
+
+  # Dispatch enter and leave events for TrueNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1216
+  def visit_true_node(node); end
+
+  # Dispatch enter and leave events for UndefNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1224
+  def visit_undef_node(node); end
+
+  # Dispatch enter and leave events for UnlessNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1232
+  def visit_unless_node(node); end
+
+  # Dispatch enter and leave events for UntilNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1240
+  def visit_until_node(node); end
+
+  # Dispatch enter and leave events for WhenNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1248
+  def visit_when_node(node); end
+
+  # Dispatch enter and leave events for WhileNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1256
+  def visit_while_node(node); end
+
+  # Dispatch enter and leave events for XStringNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1264
+  def visit_x_string_node(node); end
+
+  # Dispatch enter and leave events for YieldNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1272
+  def visit_yield_node(node); end
+end
+
+# source://prism//lib/prism/dispatcher.rb#1278
+class Prism::Dispatcher::DispatchOnce < ::Prism::Visitor
+  # @return [DispatchOnce] a new instance of DispatchOnce
+  #
+  # source://prism//lib/prism/dispatcher.rb#1281
+  def initialize(listeners); end
+
+  # Returns the value of attribute listeners.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1279
+  def listeners; end
+
+  # Dispatch enter and leave events for AliasGlobalVariableNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1286
+  def visit_alias_global_variable_node(node); end
+
+  # Dispatch enter and leave events for AliasMethodNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1292
+  def visit_alias_method_node(node); end
+
+  # Dispatch enter and leave events for AlternationPatternNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1298
+  def visit_alternation_pattern_node(node); end
+
+  # Dispatch enter and leave events for AndNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1304
+  def visit_and_node(node); end
+
+  # Dispatch enter and leave events for ArgumentsNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1310
+  def visit_arguments_node(node); end
+
+  # Dispatch enter and leave events for ArrayNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1316
+  def visit_array_node(node); end
+
+  # Dispatch enter and leave events for ArrayPatternNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1322
+  def visit_array_pattern_node(node); end
+
+  # Dispatch enter and leave events for AssocNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1328
+  def visit_assoc_node(node); end
+
+  # Dispatch enter and leave events for AssocSplatNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1334
+  def visit_assoc_splat_node(node); end
+
+  # Dispatch enter and leave events for BackReferenceReadNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1340
+  def visit_back_reference_read_node(node); end
+
+  # Dispatch enter and leave events for BeginNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1346
+  def visit_begin_node(node); end
+
+  # Dispatch enter and leave events for BlockArgumentNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1352
+  def visit_block_argument_node(node); end
+
+  # Dispatch enter and leave events for BlockLocalVariableNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1358
+  def visit_block_local_variable_node(node); end
+
+  # Dispatch enter and leave events for BlockNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1364
+  def visit_block_node(node); end
+
+  # Dispatch enter and leave events for BlockParameterNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1370
+  def visit_block_parameter_node(node); end
+
+  # Dispatch enter and leave events for BlockParametersNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1376
+  def visit_block_parameters_node(node); end
+
+  # Dispatch enter and leave events for BreakNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1382
+  def visit_break_node(node); end
+
+  # Dispatch enter and leave events for CallAndWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1388
+  def visit_call_and_write_node(node); end
+
+  # Dispatch enter and leave events for CallNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1394
+  def visit_call_node(node); end
+
+  # Dispatch enter and leave events for CallOperatorWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1400
+  def visit_call_operator_write_node(node); end
+
+  # Dispatch enter and leave events for CallOrWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1406
+  def visit_call_or_write_node(node); end
+
+  # Dispatch enter and leave events for CallTargetNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1412
+  def visit_call_target_node(node); end
+
+  # Dispatch enter and leave events for CapturePatternNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1418
+  def visit_capture_pattern_node(node); end
+
+  # Dispatch enter and leave events for CaseMatchNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1424
+  def visit_case_match_node(node); end
+
+  # Dispatch enter and leave events for CaseNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1430
+  def visit_case_node(node); end
+
+  # Dispatch enter and leave events for ClassNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1436
+  def visit_class_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableAndWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1442
+  def visit_class_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableOperatorWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1448
+  def visit_class_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableOrWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1454
+  def visit_class_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableReadNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1460
+  def visit_class_variable_read_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableTargetNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1466
+  def visit_class_variable_target_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1472
+  def visit_class_variable_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantAndWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1478
+  def visit_constant_and_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantOperatorWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1484
+  def visit_constant_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantOrWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1490
+  def visit_constant_or_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathAndWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1496
+  def visit_constant_path_and_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1502
+  def visit_constant_path_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathOperatorWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1508
+  def visit_constant_path_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathOrWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1514
+  def visit_constant_path_or_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathTargetNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1520
+  def visit_constant_path_target_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1526
+  def visit_constant_path_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantReadNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1532
+  def visit_constant_read_node(node); end
+
+  # Dispatch enter and leave events for ConstantTargetNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1538
+  def visit_constant_target_node(node); end
+
+  # Dispatch enter and leave events for ConstantWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1544
+  def visit_constant_write_node(node); end
+
+  # Dispatch enter and leave events for DefNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1550
+  def visit_def_node(node); end
+
+  # Dispatch enter and leave events for DefinedNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1556
+  def visit_defined_node(node); end
+
+  # Dispatch enter and leave events for ElseNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1562
+  def visit_else_node(node); end
+
+  # Dispatch enter and leave events for EmbeddedStatementsNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1568
+  def visit_embedded_statements_node(node); end
+
+  # Dispatch enter and leave events for EmbeddedVariableNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1574
+  def visit_embedded_variable_node(node); end
+
+  # Dispatch enter and leave events for EnsureNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1580
+  def visit_ensure_node(node); end
+
+  # Dispatch enter and leave events for FalseNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1586
+  def visit_false_node(node); end
+
+  # Dispatch enter and leave events for FindPatternNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1592
+  def visit_find_pattern_node(node); end
+
+  # Dispatch enter and leave events for FlipFlopNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1598
+  def visit_flip_flop_node(node); end
+
+  # Dispatch enter and leave events for FloatNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1604
+  def visit_float_node(node); end
+
+  # Dispatch enter and leave events for ForNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1610
+  def visit_for_node(node); end
+
+  # Dispatch enter and leave events for ForwardingArgumentsNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1616
+  def visit_forwarding_arguments_node(node); end
+
+  # Dispatch enter and leave events for ForwardingParameterNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1622
+  def visit_forwarding_parameter_node(node); end
+
+  # Dispatch enter and leave events for ForwardingSuperNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1628
+  def visit_forwarding_super_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableAndWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1634
+  def visit_global_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableOperatorWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1640
+  def visit_global_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableOrWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1646
+  def visit_global_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableReadNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1652
+  def visit_global_variable_read_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableTargetNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1658
+  def visit_global_variable_target_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1664
+  def visit_global_variable_write_node(node); end
+
+  # Dispatch enter and leave events for HashNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1670
+  def visit_hash_node(node); end
+
+  # Dispatch enter and leave events for HashPatternNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1676
+  def visit_hash_pattern_node(node); end
+
+  # Dispatch enter and leave events for IfNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1682
+  def visit_if_node(node); end
+
+  # Dispatch enter and leave events for ImaginaryNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1688
+  def visit_imaginary_node(node); end
+
+  # Dispatch enter and leave events for ImplicitNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1694
+  def visit_implicit_node(node); end
+
+  # Dispatch enter and leave events for ImplicitRestNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1700
+  def visit_implicit_rest_node(node); end
+
+  # Dispatch enter and leave events for InNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1706
+  def visit_in_node(node); end
+
+  # Dispatch enter and leave events for IndexAndWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1712
+  def visit_index_and_write_node(node); end
+
+  # Dispatch enter and leave events for IndexOperatorWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1718
+  def visit_index_operator_write_node(node); end
+
+  # Dispatch enter and leave events for IndexOrWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1724
+  def visit_index_or_write_node(node); end
+
+  # Dispatch enter and leave events for IndexTargetNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1730
+  def visit_index_target_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableAndWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1736
+  def visit_instance_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableOperatorWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1742
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableOrWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1748
+  def visit_instance_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableReadNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1754
+  def visit_instance_variable_read_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableTargetNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1760
+  def visit_instance_variable_target_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1766
+  def visit_instance_variable_write_node(node); end
+
+  # Dispatch enter and leave events for IntegerNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1772
+  def visit_integer_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedMatchLastLineNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1778
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedRegularExpressionNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1784
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedStringNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1790
+  def visit_interpolated_string_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedSymbolNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1796
+  def visit_interpolated_symbol_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedXStringNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1802
+  def visit_interpolated_x_string_node(node); end
+
+  # Dispatch enter and leave events for ItLocalVariableReadNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1808
+  def visit_it_local_variable_read_node(node); end
+
+  # Dispatch enter and leave events for ItParametersNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1814
+  def visit_it_parameters_node(node); end
+
+  # Dispatch enter and leave events for KeywordHashNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1820
+  def visit_keyword_hash_node(node); end
+
+  # Dispatch enter and leave events for KeywordRestParameterNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1826
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Dispatch enter and leave events for LambdaNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1832
+  def visit_lambda_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableAndWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1838
+  def visit_local_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableOperatorWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1844
+  def visit_local_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableOrWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1850
+  def visit_local_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableReadNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1856
+  def visit_local_variable_read_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableTargetNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1862
+  def visit_local_variable_target_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1868
+  def visit_local_variable_write_node(node); end
+
+  # Dispatch enter and leave events for MatchLastLineNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1874
+  def visit_match_last_line_node(node); end
+
+  # Dispatch enter and leave events for MatchPredicateNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1880
+  def visit_match_predicate_node(node); end
+
+  # Dispatch enter and leave events for MatchRequiredNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1886
+  def visit_match_required_node(node); end
+
+  # Dispatch enter and leave events for MatchWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1892
+  def visit_match_write_node(node); end
+
+  # Dispatch enter and leave events for MissingNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1898
+  def visit_missing_node(node); end
+
+  # Dispatch enter and leave events for ModuleNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1904
+  def visit_module_node(node); end
+
+  # Dispatch enter and leave events for MultiTargetNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1910
+  def visit_multi_target_node(node); end
+
+  # Dispatch enter and leave events for MultiWriteNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1916
+  def visit_multi_write_node(node); end
+
+  # Dispatch enter and leave events for NextNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1922
+  def visit_next_node(node); end
+
+  # Dispatch enter and leave events for NilNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1928
+  def visit_nil_node(node); end
+
+  # Dispatch enter and leave events for NoKeywordsParameterNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1934
+  def visit_no_keywords_parameter_node(node); end
+
+  # Dispatch enter and leave events for NumberedParametersNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1940
+  def visit_numbered_parameters_node(node); end
+
+  # Dispatch enter and leave events for NumberedReferenceReadNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1946
+  def visit_numbered_reference_read_node(node); end
+
+  # Dispatch enter and leave events for OptionalKeywordParameterNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1952
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Dispatch enter and leave events for OptionalParameterNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1958
+  def visit_optional_parameter_node(node); end
+
+  # Dispatch enter and leave events for OrNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1964
+  def visit_or_node(node); end
+
+  # Dispatch enter and leave events for ParametersNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1970
+  def visit_parameters_node(node); end
+
+  # Dispatch enter and leave events for ParenthesesNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1976
+  def visit_parentheses_node(node); end
+
+  # Dispatch enter and leave events for PinnedExpressionNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1982
+  def visit_pinned_expression_node(node); end
+
+  # Dispatch enter and leave events for PinnedVariableNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1988
+  def visit_pinned_variable_node(node); end
+
+  # Dispatch enter and leave events for PostExecutionNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#1994
+  def visit_post_execution_node(node); end
+
+  # Dispatch enter and leave events for PreExecutionNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2000
+  def visit_pre_execution_node(node); end
+
+  # Dispatch enter and leave events for ProgramNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2006
+  def visit_program_node(node); end
+
+  # Dispatch enter and leave events for RangeNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2012
+  def visit_range_node(node); end
+
+  # Dispatch enter and leave events for RationalNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2018
+  def visit_rational_node(node); end
+
+  # Dispatch enter and leave events for RedoNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2024
+  def visit_redo_node(node); end
+
+  # Dispatch enter and leave events for RegularExpressionNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2030
+  def visit_regular_expression_node(node); end
+
+  # Dispatch enter and leave events for RequiredKeywordParameterNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2036
+  def visit_required_keyword_parameter_node(node); end
+
+  # Dispatch enter and leave events for RequiredParameterNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2042
+  def visit_required_parameter_node(node); end
+
+  # Dispatch enter and leave events for RescueModifierNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2048
+  def visit_rescue_modifier_node(node); end
+
+  # Dispatch enter and leave events for RescueNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2054
+  def visit_rescue_node(node); end
+
+  # Dispatch enter and leave events for RestParameterNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2060
+  def visit_rest_parameter_node(node); end
+
+  # Dispatch enter and leave events for RetryNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2066
+  def visit_retry_node(node); end
+
+  # Dispatch enter and leave events for ReturnNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2072
+  def visit_return_node(node); end
+
+  # Dispatch enter and leave events for SelfNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2078
+  def visit_self_node(node); end
+
+  # Dispatch enter and leave events for ShareableConstantNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2084
+  def visit_shareable_constant_node(node); end
+
+  # Dispatch enter and leave events for SingletonClassNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2090
+  def visit_singleton_class_node(node); end
+
+  # Dispatch enter and leave events for SourceEncodingNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2096
+  def visit_source_encoding_node(node); end
+
+  # Dispatch enter and leave events for SourceFileNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2102
+  def visit_source_file_node(node); end
+
+  # Dispatch enter and leave events for SourceLineNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2108
+  def visit_source_line_node(node); end
+
+  # Dispatch enter and leave events for SplatNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2114
+  def visit_splat_node(node); end
+
+  # Dispatch enter and leave events for StatementsNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2120
+  def visit_statements_node(node); end
+
+  # Dispatch enter and leave events for StringNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2126
+  def visit_string_node(node); end
+
+  # Dispatch enter and leave events for SuperNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2132
+  def visit_super_node(node); end
+
+  # Dispatch enter and leave events for SymbolNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2138
+  def visit_symbol_node(node); end
+
+  # Dispatch enter and leave events for TrueNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2144
+  def visit_true_node(node); end
+
+  # Dispatch enter and leave events for UndefNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2150
+  def visit_undef_node(node); end
+
+  # Dispatch enter and leave events for UnlessNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2156
+  def visit_unless_node(node); end
+
+  # Dispatch enter and leave events for UntilNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2162
+  def visit_until_node(node); end
+
+  # Dispatch enter and leave events for WhenNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2168
+  def visit_when_node(node); end
+
+  # Dispatch enter and leave events for WhileNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2174
+  def visit_while_node(node); end
+
+  # Dispatch enter and leave events for XStringNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2180
+  def visit_x_string_node(node); end
+
+  # Dispatch enter and leave events for YieldNode nodes.
+  #
+  # source://prism//lib/prism/dispatcher.rb#2186
+  def visit_yield_node(node); end
+end
+
+# This visitor provides the ability to call Node#to_dot, which converts a
+# subtree into a graphviz dot graph.
+#
+# source://prism//lib/prism/dot_visitor.rb#14
+class Prism::DotVisitor < ::Prism::Visitor
+  # Initialize a new dot visitor.
+  #
+  # @return [DotVisitor] a new instance of DotVisitor
+  #
+  # source://prism//lib/prism/dot_visitor.rb#106
+  def initialize; end
+
+  # The digraph that is being built.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#103
+  def digraph; end
+
+  # Convert this visitor into a graphviz dot graph string.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#111
+  def to_dot; end
+
+  # Visit a AliasGlobalVariableNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#116
+  def visit_alias_global_variable_node(node); end
+
+  # Visit a AliasMethodNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#141
+  def visit_alias_method_node(node); end
+
+  # Visit a AlternationPatternNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#166
+  def visit_alternation_pattern_node(node); end
+
+  # Visit a AndNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#191
+  def visit_and_node(node); end
+
+  # Visit a ArgumentsNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#216
+  def visit_arguments_node(node); end
+
+  # Visit a ArrayNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#246
+  def visit_array_node(node); end
+
+  # Visit a ArrayPatternNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#286
+  def visit_array_pattern_node(node); end
+
+  # Visit a AssocNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#348
+  def visit_assoc_node(node); end
+
+  # Visit a AssocSplatNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#375
+  def visit_assoc_splat_node(node); end
+
+  # Visit a BackReferenceReadNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#398
+  def visit_back_reference_read_node(node); end
+
+  # Visit a BeginNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#415
+  def visit_begin_node(node); end
+
+  # Visit a BlockArgumentNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#463
+  def visit_block_argument_node(node); end
+
+  # Visit a BlockLocalVariableNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#486
+  def visit_block_local_variable_node(node); end
+
+  # Visit a BlockNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#506
+  def visit_block_node(node); end
+
+  # Visit a BlockParameterNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#541
+  def visit_block_parameter_node(node); end
+
+  # Visit a BlockParametersNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#569
+  def visit_block_parameters_node(node); end
+
+  # Visit a BreakNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#612
+  def visit_break_node(node); end
+
+  # Visit a CallAndWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#635
+  def visit_call_and_write_node(node); end
+
+  # Visit a CallNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#681
+  def visit_call_node(node); end
+
+  # Visit a CallOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#739
+  def visit_call_operator_write_node(node); end
+
+  # Visit a CallOrWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#788
+  def visit_call_or_write_node(node); end
+
+  # Visit a CallTargetNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#834
+  def visit_call_target_node(node); end
+
+  # Visit a CapturePatternNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#864
+  def visit_capture_pattern_node(node); end
+
+  # Visit a CaseMatchNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#889
+  def visit_case_match_node(node); end
+
+  # Visit a CaseNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#934
+  def visit_case_node(node); end
+
+  # Visit a ClassNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#979
+  def visit_class_node(node); end
+
+  # Visit a ClassVariableAndWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1026
+  def visit_class_variable_and_write_node(node); end
+
+  # Visit a ClassVariableOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1053
+  def visit_class_variable_operator_write_node(node); end
+
+  # Visit a ClassVariableOrWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1083
+  def visit_class_variable_or_write_node(node); end
+
+  # Visit a ClassVariableReadNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1110
+  def visit_class_variable_read_node(node); end
+
+  # Visit a ClassVariableTargetNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1127
+  def visit_class_variable_target_node(node); end
+
+  # Visit a ClassVariableWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1144
+  def visit_class_variable_write_node(node); end
+
+  # Visit a ConstantAndWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1171
+  def visit_constant_and_write_node(node); end
+
+  # Visit a ConstantOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1198
+  def visit_constant_operator_write_node(node); end
+
+  # Visit a ConstantOrWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1228
+  def visit_constant_or_write_node(node); end
+
+  # Visit a ConstantPathAndWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1255
+  def visit_constant_path_and_write_node(node); end
+
+  # Visit a ConstantPathNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1280
+  def visit_constant_path_node(node); end
+
+  # Visit a ConstantPathOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1309
+  def visit_constant_path_operator_write_node(node); end
+
+  # Visit a ConstantPathOrWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1337
+  def visit_constant_path_or_write_node(node); end
+
+  # Visit a ConstantPathTargetNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1362
+  def visit_constant_path_target_node(node); end
+
+  # Visit a ConstantPathWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1391
+  def visit_constant_path_write_node(node); end
+
+  # Visit a ConstantReadNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1416
+  def visit_constant_read_node(node); end
+
+  # Visit a ConstantTargetNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1433
+  def visit_constant_target_node(node); end
+
+  # Visit a ConstantWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1450
+  def visit_constant_write_node(node); end
+
+  # Visit a DefNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1477
+  def visit_def_node(node); end
+
+  # Visit a DefinedNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1546
+  def visit_defined_node(node); end
+
+  # Visit a ElseNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1577
+  def visit_else_node(node); end
+
+  # Visit a EmbeddedStatementsNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1605
+  def visit_embedded_statements_node(node); end
+
+  # Visit a EmbeddedVariableNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1631
+  def visit_embedded_variable_node(node); end
+
+  # Visit a EnsureNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1652
+  def visit_ensure_node(node); end
+
+  # Visit a FalseNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1678
+  def visit_false_node(node); end
+
+  # Visit a FindPatternNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1692
+  def visit_find_pattern_node(node); end
+
+  # Visit a FlipFlopNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1743
+  def visit_flip_flop_node(node); end
+
+  # Visit a FloatNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1775
+  def visit_float_node(node); end
+
+  # Visit a ForNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1792
+  def visit_for_node(node); end
+
+  # Visit a ForwardingArgumentsNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1834
+  def visit_forwarding_arguments_node(node); end
+
+  # Visit a ForwardingParameterNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1848
+  def visit_forwarding_parameter_node(node); end
+
+  # Visit a ForwardingSuperNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1862
+  def visit_forwarding_super_node(node); end
+
+  # Visit a GlobalVariableAndWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1882
+  def visit_global_variable_and_write_node(node); end
+
+  # Visit a GlobalVariableOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1909
+  def visit_global_variable_operator_write_node(node); end
+
+  # Visit a GlobalVariableOrWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1939
+  def visit_global_variable_or_write_node(node); end
+
+  # Visit a GlobalVariableReadNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1966
+  def visit_global_variable_read_node(node); end
+
+  # Visit a GlobalVariableTargetNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#1983
+  def visit_global_variable_target_node(node); end
+
+  # Visit a GlobalVariableWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2000
+  def visit_global_variable_write_node(node); end
+
+  # Visit a HashNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2027
+  def visit_hash_node(node); end
+
+  # Visit a HashPatternNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2060
+  def visit_hash_pattern_node(node); end
+
+  # Visit a IfNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2109
+  def visit_if_node(node); end
+
+  # Visit a ImaginaryNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2154
+  def visit_imaginary_node(node); end
+
+  # Visit a ImplicitNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2172
+  def visit_implicit_node(node); end
+
+  # Visit a ImplicitRestNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2190
+  def visit_implicit_rest_node(node); end
+
+  # Visit a InNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2204
+  def visit_in_node(node); end
+
+  # Visit a IndexAndWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2236
+  def visit_index_and_write_node(node); end
+
+  # Visit a IndexOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2289
+  def visit_index_operator_write_node(node); end
+
+  # Visit a IndexOrWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2345
+  def visit_index_or_write_node(node); end
+
+  # Visit a IndexTargetNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2398
+  def visit_index_target_node(node); end
+
+  # Visit a InstanceVariableAndWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2437
+  def visit_instance_variable_and_write_node(node); end
+
+  # Visit a InstanceVariableOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2464
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Visit a InstanceVariableOrWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2494
+  def visit_instance_variable_or_write_node(node); end
+
+  # Visit a InstanceVariableReadNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2521
+  def visit_instance_variable_read_node(node); end
+
+  # Visit a InstanceVariableTargetNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2538
+  def visit_instance_variable_target_node(node); end
+
+  # Visit a InstanceVariableWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2555
+  def visit_instance_variable_write_node(node); end
+
+  # Visit a IntegerNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2582
+  def visit_integer_node(node); end
+
+  # Visit a InterpolatedMatchLastLineNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2602
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Visit a InterpolatedRegularExpressionNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2638
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Visit a InterpolatedStringNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2674
+  def visit_interpolated_string_node(node); end
+
+  # Visit a InterpolatedSymbolNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2714
+  def visit_interpolated_symbol_node(node); end
+
+  # Visit a InterpolatedXStringNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2751
+  def visit_interpolated_x_string_node(node); end
+
+  # Visit a ItLocalVariableReadNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2784
+  def visit_it_local_variable_read_node(node); end
+
+  # Visit a ItParametersNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2798
+  def visit_it_parameters_node(node); end
+
+  # Visit a KeywordHashNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2812
+  def visit_keyword_hash_node(node); end
+
+  # Visit a KeywordRestParameterNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2842
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Visit a LambdaNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2870
+  def visit_lambda_node(node); end
+
+  # Visit a LocalVariableAndWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2908
+  def visit_local_variable_and_write_node(node); end
+
+  # Visit a LocalVariableOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2938
+  def visit_local_variable_operator_write_node(node); end
+
+  # Visit a LocalVariableOrWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#2971
+  def visit_local_variable_or_write_node(node); end
+
+  # Visit a LocalVariableReadNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3001
+  def visit_local_variable_read_node(node); end
+
+  # Visit a LocalVariableTargetNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3021
+  def visit_local_variable_target_node(node); end
+
+  # Visit a LocalVariableWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3041
+  def visit_local_variable_write_node(node); end
+
+  # Visit a MatchLastLineNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3071
+  def visit_match_last_line_node(node); end
+
+  # Visit a MatchPredicateNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3100
+  def visit_match_predicate_node(node); end
+
+  # Visit a MatchRequiredNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3125
+  def visit_match_required_node(node); end
+
+  # Visit a MatchWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3150
+  def visit_match_write_node(node); end
+
+  # Visit a MissingNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3181
+  def visit_missing_node(node); end
+
+  # Visit a ModuleNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3195
+  def visit_module_node(node); end
+
+  # Visit a MultiTargetNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3231
+  def visit_multi_target_node(node); end
+
+  # Visit a MultiWriteNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3287
+  def visit_multi_write_node(node); end
+
+  # Visit a NextNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3350
+  def visit_next_node(node); end
+
+  # Visit a NilNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3373
+  def visit_nil_node(node); end
+
+  # Visit a NoKeywordsParameterNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3387
+  def visit_no_keywords_parameter_node(node); end
+
+  # Visit a NumberedParametersNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3407
+  def visit_numbered_parameters_node(node); end
+
+  # Visit a NumberedReferenceReadNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3424
+  def visit_numbered_reference_read_node(node); end
+
+  # Visit a OptionalKeywordParameterNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3441
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Visit a OptionalParameterNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3468
+  def visit_optional_parameter_node(node); end
+
+  # Visit a OrNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3498
+  def visit_or_node(node); end
+
+  # Visit a ParametersNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3523
+  def visit_parameters_node(node); end
+
+  # Visit a ParenthesesNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3607
+  def visit_parentheses_node(node); end
+
+  # Visit a PinnedExpressionNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3633
+  def visit_pinned_expression_node(node); end
+
+  # Visit a PinnedVariableNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3660
+  def visit_pinned_variable_node(node); end
+
+  # Visit a PostExecutionNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3681
+  def visit_post_execution_node(node); end
+
+  # Visit a PreExecutionNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3710
+  def visit_pre_execution_node(node); end
+
+  # Visit a ProgramNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3739
+  def visit_program_node(node); end
+
+  # Visit a RangeNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3760
+  def visit_range_node(node); end
+
+  # Visit a RationalNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3792
+  def visit_rational_node(node); end
+
+  # Visit a RedoNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3815
+  def visit_redo_node(node); end
+
+  # Visit a RegularExpressionNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3829
+  def visit_regular_expression_node(node); end
+
+  # Visit a RequiredKeywordParameterNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3858
+  def visit_required_keyword_parameter_node(node); end
+
+  # Visit a RequiredParameterNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3881
+  def visit_required_parameter_node(node); end
+
+  # Visit a RescueModifierNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3901
+  def visit_rescue_modifier_node(node); end
+
+  # Visit a RescueNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3926
+  def visit_rescue_node(node); end
+
+  # Visit a RestParameterNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#3979
+  def visit_rest_parameter_node(node); end
+
+  # Visit a RetryNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4007
+  def visit_retry_node(node); end
+
+  # Visit a ReturnNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4021
+  def visit_return_node(node); end
+
+  # Visit a SelfNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4044
+  def visit_self_node(node); end
+
+  # Visit a ShareableConstantNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4058
+  def visit_shareable_constant_node(node); end
+
+  # Visit a SingletonClassNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4079
+  def visit_singleton_class_node(node); end
+
+  # Visit a SourceEncodingNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4115
+  def visit_source_encoding_node(node); end
+
+  # Visit a SourceFileNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4129
+  def visit_source_file_node(node); end
+
+  # Visit a SourceLineNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4149
+  def visit_source_line_node(node); end
+
+  # Visit a SplatNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4163
+  def visit_splat_node(node); end
+
+  # Visit a StatementsNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4186
+  def visit_statements_node(node); end
+
+  # Visit a StringNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4213
+  def visit_string_node(node); end
+
+  # Visit a SuperNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4246
+  def visit_super_node(node); end
+
+  # Visit a SymbolNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4285
+  def visit_symbol_node(node); end
+
+  # Visit a TrueNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4320
+  def visit_true_node(node); end
+
+  # Visit a UndefNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4334
+  def visit_undef_node(node); end
+
+  # Visit a UnlessNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4364
+  def visit_unless_node(node); end
+
+  # Visit a UntilNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4407
+  def visit_until_node(node); end
+
+  # Visit a WhenNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4442
+  def visit_when_node(node); end
+
+  # Visit a WhileNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4483
+  def visit_while_node(node); end
+
+  # Visit a XStringNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4518
+  def visit_x_string_node(node); end
+
+  # Visit a YieldNode node.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4547
+  def visit_yield_node(node); end
+
+  private
+
+  # Inspect a node that has arguments_node_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4593
+  def arguments_node_flags_inspect(node); end
+
+  # Inspect a node that has array_node_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4605
+  def array_node_flags_inspect(node); end
+
+  # Inspect a node that has call_node_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4613
+  def call_node_flags_inspect(node); end
+
+  # Inspect a node that has encoding_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4624
+  def encoding_flags_inspect(node); end
+
+  # Inspect a node that has integer_base_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4633
+  def integer_base_flags_inspect(node); end
+
+  # Inspect a node that has interpolated_string_node_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4644
+  def interpolated_string_node_flags_inspect(node); end
+
+  # Inspect a node that has keyword_hash_node_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4653
+  def keyword_hash_node_flags_inspect(node); end
+
+  # Inspect a location to display the start and end line and column numbers.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4587
+  def location_inspect(location); end
+
+  # Inspect a node that has loop_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4661
+  def loop_flags_inspect(node); end
+
+  # Generate a unique node ID for a node throughout the digraph.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4582
+  def node_id(node); end
+
+  # Inspect a node that has parameter_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4669
+  def parameter_flags_inspect(node); end
+
+  # Inspect a node that has range_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4677
+  def range_flags_inspect(node); end
+
+  # Inspect a node that has regular_expression_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4685
+  def regular_expression_flags_inspect(node); end
+
+  # Inspect a node that has shareable_constant_node_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4703
+  def shareable_constant_node_flags_inspect(node); end
+
+  # Inspect a node that has string_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4713
+  def string_flags_inspect(node); end
+
+  # Inspect a node that has symbol_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#4724
+  def symbol_flags_inspect(node); end
+end
+
+# source://prism//lib/prism/dot_visitor.rb#59
+class Prism::DotVisitor::Digraph
+  # @return [Digraph] a new instance of Digraph
+  #
+  # source://prism//lib/prism/dot_visitor.rb#62
+  def initialize; end
+
+  # source://prism//lib/prism/dot_visitor.rb#76
+  def edge(value); end
+
+  # Returns the value of attribute edges.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#60
+  def edges; end
+
+  # source://prism//lib/prism/dot_visitor.rb#68
+  def node(value); end
+
+  # Returns the value of attribute nodes.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#60
+  def nodes; end
+
+  # source://prism//lib/prism/dot_visitor.rb#80
+  def to_dot; end
+
+  # source://prism//lib/prism/dot_visitor.rb#72
+  def waypoint(value); end
+
+  # Returns the value of attribute waypoints.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#60
+  def waypoints; end
+end
+
+# source://prism//lib/prism/dot_visitor.rb#15
+class Prism::DotVisitor::Field
+  # @return [Field] a new instance of Field
+  #
+  # source://prism//lib/prism/dot_visitor.rb#18
+  def initialize(name, value, port); end
+
+  # Returns the value of attribute name.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#16
+  def name; end
+
+  # Returns the value of attribute port.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#16
+  def port; end
+
+  # source://prism//lib/prism/dot_visitor.rb#24
+  def to_dot; end
+
+  # Returns the value of attribute value.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#16
+  def value; end
+end
+
+# source://prism//lib/prism/dot_visitor.rb#33
+class Prism::DotVisitor::Table
+  # @return [Table] a new instance of Table
+  #
+  # source://prism//lib/prism/dot_visitor.rb#36
+  def initialize(name); end
+
+  # source://prism//lib/prism/dot_visitor.rb#41
+  def field(name, value = T.unsafe(nil), port: T.unsafe(nil)); end
+
+  # Returns the value of attribute fields.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#34
+  def fields; end
+
+  # Returns the value of attribute name.
+  #
+  # source://prism//lib/prism/dot_visitor.rb#34
+  def name; end
+
+  # source://prism//lib/prism/dot_visitor.rb#45
+  def to_dot; end
+end
+
+# Represents an `else` clause in a `case`, `if`, or `unless` statement.
+#
+#     if a then b else c end
+#                 ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#5485
+class Prism::ElseNode < ::Prism::Node
+  # Initialize a new ElseNode node.
+  #
+  # @return [ElseNode] a new instance of ElseNode
+  #
+  # source://prism//lib/prism/node.rb#5487
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      else_keyword_loc: Prism::Location,
+      statements: T.nilable(Prism::StatementsNode),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, else_keyword_loc, statements, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#5582
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#5498
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5503
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#5515
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#5508
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?else_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location?) -> ElseNode
+  #
+  # source://prism//lib/prism/node.rb#5520
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      else_keyword_loc: Prism::Location,
+      statements: T.nilable(Prism::StatementsNode),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::ElseNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), else_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5503
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#5528
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def else_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#5556
+  sig { returns(String) }
+  def else_keyword; end
+
+  # attr_reader else_keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#5533
+  sig { returns(Prism::Location) }
+  def else_keyword_loc; end
+
+  # def end_keyword: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#5561
+  sig { returns(T.nilable(String)) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#5543
+  sig { returns(T.nilable(Prism::Location)) }
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#5566
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism//lib/prism/node.rb#5540
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#5571
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#5576
+    def type; end
+  end
+end
+
+# EmbDocComment objects correspond to comments that are surrounded by =begin
+# and =end.
+#
+# source://prism//lib/prism/parse_result.rb#544
+class Prism::EmbDocComment < ::Prism::Comment
+  # Returns a string representation of this comment.
+  #
+  # source://prism//lib/prism/parse_result.rb#551
+  sig { returns(String) }
+  def inspect; end
+
+  # This can only be true for inline comments.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/parse_result.rb#546
+  sig { override.returns(T::Boolean) }
+  def trailing?; end
+end
+
+# Represents an interpolated set of statements.
+#
+#     "foo #{bar}"
+#          ^^^^^^
+#
+# source://prism//lib/prism/node.rb#5594
+class Prism::EmbeddedStatementsNode < ::Prism::Node
+  # Initialize a new EmbeddedStatementsNode node.
+  #
+  # @return [EmbeddedStatementsNode] a new instance of EmbeddedStatementsNode
+  #
+  # source://prism//lib/prism/node.rb#5596
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      statements: T.nilable(Prism::StatementsNode),
+      closing_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, statements, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#5685
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#5607
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5612
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#5664
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#5652
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#5624
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#5617
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?statements: StatementsNode?, ?closing_loc: Location) -> EmbeddedStatementsNode
+  #
+  # source://prism//lib/prism/node.rb#5629
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      statements: T.nilable(Prism::StatementsNode),
+      closing_loc: Prism::Location
+    ).returns(Prism::EmbeddedStatementsNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), statements: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5612
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, statements: StatementsNode?, closing_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#5637
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#5669
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#5659
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#5642
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism//lib/prism/node.rb#5649
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#5674
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#5679
+    def type; end
+  end
+end
+
+# Represents an interpolated variable.
+#
+#     "foo #@bar"
+#          ^^^^^
+#
+# source://prism//lib/prism/node.rb#5697
+class Prism::EmbeddedVariableNode < ::Prism::Node
+  # Initialize a new EmbeddedVariableNode node.
+  #
+  # @return [EmbeddedVariableNode] a new instance of EmbeddedVariableNode
+  #
+  # source://prism//lib/prism/node.rb#5699
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      operator_loc: Prism::Location,
+      variable: T.any(Prism::InstanceVariableReadNode, Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, operator_loc, variable); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#5773
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#5709
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5714
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#5724
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#5719
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode) -> EmbeddedVariableNode
+  #
+  # source://prism//lib/prism/node.rb#5729
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      operator_loc: Prism::Location,
+      variable: T.any(Prism::InstanceVariableReadNode, Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)
+    ).returns(Prism::EmbeddedVariableNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), variable: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5714
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode }
+  #
+  # source://prism//lib/prism/node.rb#5737
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#5757
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#5752
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#5742
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#5762
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode
+  #
+  # source://prism//lib/prism/node.rb#5749
+  sig do
+    returns(T.any(Prism::InstanceVariableReadNode, Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode))
+  end
+  def variable; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#5767
+    def type; end
+  end
+end
+
+# Flags for nodes that have unescaped content.
+#
+# source://prism//lib/prism/node.rb#16723
+module Prism::EncodingFlags; end
+
+# internal bytes forced the encoding to binary
+#
+# source://prism//lib/prism/node.rb#16728
+Prism::EncodingFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to UTF-8
+#
+# source://prism//lib/prism/node.rb#16725
+Prism::EncodingFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# Represents an `ensure` clause in a `begin` statement.
+#
+#     begin
+#       foo
+#     ensure
+#     ^^^^^^
+#       bar
+#     end
+#
+# source://prism//lib/prism/node.rb#5788
+class Prism::EnsureNode < ::Prism::Node
+  # Initialize a new EnsureNode node.
+  #
+  # @return [EnsureNode] a new instance of EnsureNode
+  #
+  # source://prism//lib/prism/node.rb#5790
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      ensure_keyword_loc: Prism::Location,
+      statements: T.nilable(Prism::StatementsNode),
+      end_keyword_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, ensure_keyword_loc, statements, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#5879
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#5801
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5806
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#5818
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#5811
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?ensure_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location) -> EnsureNode
+  #
+  # source://prism//lib/prism/node.rb#5823
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      ensure_keyword_loc: Prism::Location,
+      statements: T.nilable(Prism::StatementsNode),
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::EnsureNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), ensure_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5806
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#5831
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#5858
+  sig { returns(String) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#5846
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  # def ensure_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#5853
+  sig { returns(String) }
+  def ensure_keyword; end
+
+  # attr_reader ensure_keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#5836
+  sig { returns(Prism::Location) }
+  def ensure_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#5863
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism//lib/prism/node.rb#5843
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#5868
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#5873
+    def type; end
+  end
+end
+
+# Represents the use of the literal `false` keyword.
+#
+#     false
+#     ^^^^^
+#
+# source://prism//lib/prism/node.rb#5891
+class Prism::FalseNode < ::Prism::Node
+  # Initialize a new FalseNode node.
+  #
+  # @return [FalseNode] a new instance of FalseNode
+  #
+  # source://prism//lib/prism/node.rb#5893
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void }
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#5950
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#5901
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5906
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#5916
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#5911
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> FalseNode
+  #
+  # source://prism//lib/prism/node.rb#5921
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::FalseNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5906
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  #
+  # source://prism//lib/prism/node.rb#5929
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#5934
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#5939
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#5944
+    def type; end
+  end
+end
+
+# Represents a find pattern in pattern matching.
+#
+#     foo in *bar, baz, *qux
+#            ^^^^^^^^^^^^^^^
+#
+#     foo in [*bar, baz, *qux]
+#            ^^^^^^^^^^^^^^^^^
+#
+#     foo in Foo(*bar, baz, *qux)
+#            ^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#5965
+class Prism::FindPatternNode < ::Prism::Node
+  # Initialize a new FindPatternNode node.
+  #
+  # @return [FindPatternNode] a new instance of FindPatternNode
+  #
+  # source://prism//lib/prism/node.rb#5967
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      constant: T.nilable(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode)),
+      left: Prism::SplatNode,
+      requireds: T::Array[Prism::Node],
+      right: T.any(Prism::SplatNode, Prism::MissingNode),
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, constant, left, requireds, right, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#6083
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#5981
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5986
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#6062
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#6044
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#6001
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#5991
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # attr_reader constant: ConstantReadNode | ConstantPathNode | nil
+  #
+  # source://prism//lib/prism/node.rb#6019
+  sig { returns(T.nilable(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode))) }
+  def constant; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantReadNode | ConstantPathNode | nil, ?left: SplatNode, ?requireds: Array[Prism::node], ?right: SplatNode | MissingNode, ?opening_loc: Location?, ?closing_loc: Location?) -> FindPatternNode
+  #
+  # source://prism//lib/prism/node.rb#6006
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      constant: T.nilable(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode)),
+      left: Prism::SplatNode,
+      requireds: T::Array[Prism::Node],
+      right: T.any(Prism::SplatNode, Prism::MissingNode),
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::FindPatternNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), left: T.unsafe(nil), requireds: T.unsafe(nil), right: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#5986
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantReadNode | ConstantPathNode | nil, left: SplatNode, requireds: Array[Prism::node], right: SplatNode | MissingNode, opening_loc: Location?, closing_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#6014
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#6067
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader left: SplatNode
+  #
+  # source://prism//lib/prism/node.rb#6022
+  sig { returns(Prism::SplatNode) }
+  def left; end
+
+  # def opening: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#6057
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#6031
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # attr_reader requireds: Array[Prism::node]
+  #
+  # source://prism//lib/prism/node.rb#6025
+  sig { returns(T::Array[Prism::Node]) }
+  def requireds; end
+
+  # attr_reader right: SplatNode | MissingNode
+  #
+  # source://prism//lib/prism/node.rb#6028
+  sig { returns(T.any(Prism::SplatNode, Prism::MissingNode)) }
+  def right; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#6072
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#6077
+    def type; end
+  end
+end
+
+# Represents the use of the `..` or `...` operators to create flip flops.
+#
+#     baz if foo .. bar
+#            ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#6099
+class Prism::FlipFlopNode < ::Prism::Node
+  # Initialize a new FlipFlopNode node.
+  #
+  # @return [FlipFlopNode] a new instance of FlipFlopNode
+  #
+  # source://prism//lib/prism/node.rb#6101
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: T.nilable(Prism::Node),
+      right: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, left, right, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#6187
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#6112
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6117
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#6130
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#6122
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location) -> FlipFlopNode
+  #
+  # source://prism//lib/prism/node.rb#6135
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: T.nilable(Prism::Node),
+      right: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).returns(Prism::FlipFlopNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6117
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node?, right: Prism::node?, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#6143
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def exclude_end?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#6148
+  sig { returns(T::Boolean) }
+  def exclude_end?; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#6171
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader left: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#6153
+  sig { returns(T.nilable(Prism::Node)) }
+  def left; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#6166
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#6159
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader right: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#6156
+  sig { returns(T.nilable(Prism::Node)) }
+  def right; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#6176
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#6181
+    def type; end
+  end
+end
+
+# Represents a floating point number literal.
+#
+#     1.0
+#     ^^^
+#
+# source://prism//lib/prism/node.rb#6200
+class Prism::FloatNode < ::Prism::Node
+  # Initialize a new FloatNode node.
+  #
+  # @return [FloatNode] a new instance of FloatNode
+  #
+  # source://prism//lib/prism/node.rb#6202
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, value: Float).void }
+  def initialize(source, node_id, location, flags, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#6263
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#6211
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6216
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#6226
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#6221
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Float) -> FloatNode
+  #
+  # source://prism//lib/prism/node.rb#6231
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer, value: Float).returns(Prism::FloatNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6216
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Float }
+  #
+  # source://prism//lib/prism/node.rb#6239
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#6247
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#6252
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value of the floating point number as a Float.
+  #
+  # source://prism//lib/prism/node.rb#6244
+  sig { returns(Float) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#6257
+    def type; end
+  end
+end
+
+# Represents the use of the `for` keyword.
+#
+#     for i in a end
+#     ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#6273
+class Prism::ForNode < ::Prism::Node
+  # Initialize a new ForNode node.
+  #
+  # @return [ForNode] a new instance of ForNode
+  #
+  # source://prism//lib/prism/node.rb#6275
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      index: T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::MissingNode),
+      collection: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode),
+      for_keyword_loc: Prism::Location,
+      in_keyword_loc: Prism::Location,
+      do_keyword_loc: T.nilable(Prism::Location),
+      end_keyword_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#6429
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#6290
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6295
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # The collection to iterate over.
+  #
+  #     for i in a end
+  #              ^
+  #
+  # source://prism//lib/prism/node.rb#6336
+  sig { returns(Prism::Node) }
+  def collection; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#6309
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#6300
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode, ?collection: Prism::node, ?statements: StatementsNode?, ?for_keyword_loc: Location, ?in_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location) -> ForNode
+  #
+  # source://prism//lib/prism/node.rb#6314
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      index: T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::MissingNode),
+      collection: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode),
+      for_keyword_loc: Prism::Location,
+      in_keyword_loc: Prism::Location,
+      do_keyword_loc: T.nilable(Prism::Location),
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::ForNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), index: T.unsafe(nil), collection: T.unsafe(nil), statements: T.unsafe(nil), for_keyword_loc: T.unsafe(nil), in_keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6295
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode, collection: Prism::node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#6322
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def do_keyword: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#6403
+  sig { returns(T.nilable(String)) }
+  def do_keyword; end
+
+  # The location of the `do` keyword, if present.
+  #
+  #     for i in a do end
+  #                ^^
+  #
+  # source://prism//lib/prism/node.rb#6370
+  sig { returns(T.nilable(Prism::Location)) }
+  def do_keyword_loc; end
+
+  # def end_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#6408
+  sig { returns(String) }
+  def end_keyword; end
+
+  # The location of the `end` keyword.
+  #
+  #     for i in a end
+  #                ^^^
+  #
+  # source://prism//lib/prism/node.rb#6386
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def for_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#6393
+  sig { returns(String) }
+  def for_keyword; end
+
+  # The location of the `for` keyword.
+  #
+  #     for i in a end
+  #     ^^^
+  #
+  # source://prism//lib/prism/node.rb#6350
+  sig { returns(Prism::Location) }
+  def for_keyword_loc; end
+
+  # def in_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#6398
+  sig { returns(String) }
+  def in_keyword; end
+
+  # The location of the `in` keyword.
+  #
+  #     for i in a end
+  #           ^^
+  #
+  # source://prism//lib/prism/node.rb#6360
+  sig { returns(Prism::Location) }
+  def in_keyword_loc; end
+
+  # The index expression for `for` loops.
+  #
+  #     for i in a end
+  #         ^
+  #
+  # source://prism//lib/prism/node.rb#6330
+  sig do
+    returns(T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::MissingNode))
+  end
+  def index; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#6413
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Represents the body of statements to execute for each iteration of the loop.
+  #
+  #     for i in a
+  #       foo(i)
+  #       ^^^^^^
+  #     end
+  #
+  # source://prism//lib/prism/node.rb#6344
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#6418
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#6423
+    def type; end
+  end
+end
+
+# Represents forwarding all arguments to this method to another method.
+#
+#     def foo(...)
+#       bar(...)
+#           ^^^
+#     end
+#
+# source://prism//lib/prism/node.rb#6447
+class Prism::ForwardingArgumentsNode < ::Prism::Node
+  # Initialize a new ForwardingArgumentsNode node.
+  #
+  # @return [ForwardingArgumentsNode] a new instance of ForwardingArgumentsNode
+  #
+  # source://prism//lib/prism/node.rb#6449
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void }
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#6506
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#6457
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6462
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#6472
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#6467
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ForwardingArgumentsNode
+  #
+  # source://prism//lib/prism/node.rb#6477
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::ForwardingArgumentsNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6462
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  #
+  # source://prism//lib/prism/node.rb#6485
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#6490
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#6495
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#6500
+    def type; end
+  end
+end
+
+# Represents the use of the forwarding parameter in a method, block, or lambda declaration.
+#
+#     def foo(...)
+#             ^^^
+#     end
+#
+# source://prism//lib/prism/node.rb#6516
+class Prism::ForwardingParameterNode < ::Prism::Node
+  # Initialize a new ForwardingParameterNode node.
+  #
+  # @return [ForwardingParameterNode] a new instance of ForwardingParameterNode
+  #
+  # source://prism//lib/prism/node.rb#6518
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void }
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#6575
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#6526
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6531
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#6541
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#6536
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ForwardingParameterNode
+  #
+  # source://prism//lib/prism/node.rb#6546
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::ForwardingParameterNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6531
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  #
+  # source://prism//lib/prism/node.rb#6554
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#6559
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#6564
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#6569
+    def type; end
+  end
+end
+
+# Represents the use of the `super` keyword without parentheses or arguments.
+#
+#     super
+#     ^^^^^
+#
+# source://prism//lib/prism/node.rb#6584
+class Prism::ForwardingSuperNode < ::Prism::Node
+  # Initialize a new ForwardingSuperNode node.
+  #
+  # @return [ForwardingSuperNode] a new instance of ForwardingSuperNode
+  #
+  # source://prism//lib/prism/node.rb#6586
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      block: T.nilable(Prism::BlockNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, block); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#6649
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#6595
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader block: BlockNode?
+  #
+  # source://prism//lib/prism/node.rb#6630
+  sig { returns(T.nilable(Prism::BlockNode)) }
+  def block; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6600
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#6612
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#6605
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?block: BlockNode?) -> ForwardingSuperNode
+  #
+  # source://prism//lib/prism/node.rb#6617
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      block: T.nilable(Prism::BlockNode)
+    ).returns(Prism::ForwardingSuperNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6600
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, block: BlockNode? }
+  #
+  # source://prism//lib/prism/node.rb#6625
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#6633
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#6638
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#6643
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator for assignment to a global variable.
+#
+#     $target &&= value
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#6659
+class Prism::GlobalVariableAndWriteNode < ::Prism::Node
+  # Initialize a new GlobalVariableAndWriteNode node.
+  #
+  # @return [GlobalVariableAndWriteNode] a new instance of GlobalVariableAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#6661
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#6747
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#6673
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6678
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#6688
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#6683
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> GlobalVariableAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#6693
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::GlobalVariableAndWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6678
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#6701
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # source://prism//lib/prism/desugar_compiler.rb#200
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#6731
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#6706
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#6709
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#6726
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#6716
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#6736
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#6723
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#6741
+    def type; end
+  end
+end
+
+# Represents assigning to a global variable using an operator that isn't `=`.
+#
+#     $target += value
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#6760
+class Prism::GlobalVariableOperatorWriteNode < ::Prism::Node
+  # Initialize a new GlobalVariableOperatorWriteNode node.
+  #
+  # @return [GlobalVariableOperatorWriteNode] a new instance of GlobalVariableOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#6762
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#6847
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#6775
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader binary_operator: Symbol
+  #
+  # source://prism//lib/prism/node.rb#6828
+  sig { returns(Symbol) }
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#6818
+  sig { returns(Prism::Location) }
+  def binary_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6780
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#6790
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#6785
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> GlobalVariableOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#6795
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::GlobalVariableOperatorWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6780
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#6803
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # source://prism//lib/prism/desugar_compiler.rb#212
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#6831
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#6808
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#6811
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  #
+  # source://prism//lib/prism/node_ext.rb#403
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  #
+  # source://prism//lib/prism/node_ext.rb#410
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#6836
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#6825
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#6841
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a global variable.
+#
+#     $target ||= value
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#6861
+class Prism::GlobalVariableOrWriteNode < ::Prism::Node
+  # Initialize a new GlobalVariableOrWriteNode node.
+  #
+  # @return [GlobalVariableOrWriteNode] a new instance of GlobalVariableOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#6863
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#6949
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#6875
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6880
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#6890
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#6885
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> GlobalVariableOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#6895
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::GlobalVariableOrWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6880
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#6903
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # source://prism//lib/prism/desugar_compiler.rb#206
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#6933
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#6908
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#6911
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#6928
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#6918
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#6938
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#6925
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#6943
+    def type; end
+  end
+end
+
+# Represents referencing a global variable.
+#
+#     $foo
+#     ^^^^
+#
+# source://prism//lib/prism/node.rb#6962
+class Prism::GlobalVariableReadNode < ::Prism::Node
+  # Initialize a new GlobalVariableReadNode node.
+  #
+  # @return [GlobalVariableReadNode] a new instance of GlobalVariableReadNode
+  #
+  # source://prism//lib/prism/node.rb#6964
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#7029
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#6973
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6978
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#6988
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#6983
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> GlobalVariableReadNode
+  #
+  # source://prism//lib/prism/node.rb#6993
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::GlobalVariableReadNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#6978
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#7001
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#7013
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
+  #
+  #     $foo   # name `:$foo`
+  #
+  #     $_Test # name `:$_Test`
+  #
+  # source://prism//lib/prism/node.rb#7010
+  sig { returns(Symbol) }
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#7018
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#7023
+    def type; end
+  end
+end
+
+# Represents writing to a global variable in a context that doesn't have an explicit value.
+#
+#     $foo, $bar = baz
+#     ^^^^  ^^^^
+#
+# source://prism//lib/prism/node.rb#7039
+class Prism::GlobalVariableTargetNode < ::Prism::Node
+  # Initialize a new GlobalVariableTargetNode node.
+  #
+  # @return [GlobalVariableTargetNode] a new instance of GlobalVariableTargetNode
+  #
+  # source://prism//lib/prism/node.rb#7041
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#7102
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#7050
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7055
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#7065
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#7060
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> GlobalVariableTargetNode
+  #
+  # source://prism//lib/prism/node.rb#7070
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::GlobalVariableTargetNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7055
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#7078
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#7086
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#7083
+  sig { returns(Symbol) }
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#7091
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#7096
+    def type; end
+  end
+end
+
+# Represents writing to a global variable.
+#
+#     $foo = 1
+#     ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#7112
+class Prism::GlobalVariableWriteNode < ::Prism::Node
+  # Initialize a new GlobalVariableWriteNode node.
+  #
+  # @return [GlobalVariableWriteNode] a new instance of GlobalVariableWriteNode
+  #
+  # source://prism//lib/prism/node.rb#7114
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#7216
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#7126
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7131
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#7141
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#7136
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> GlobalVariableWriteNode
+  #
+  # source://prism//lib/prism/node.rb#7146
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::GlobalVariableWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7131
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#7154
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#7200
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
+  #
+  #     $foo = :bar  # name `:$foo`
+  #
+  #     $_Test = 123 # name `:$_Test`
+  #
+  # source://prism//lib/prism/node.rb#7163
+  sig { returns(Symbol) }
+  def name; end
+
+  # The location of the global variable's name.
+  #
+  #     $foo = :bar
+  #     ^^^^
+  #
+  # source://prism//lib/prism/node.rb#7169
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#7195
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `=` operator.
+  #
+  #     $foo = :bar
+  #          ^
+  #
+  # source://prism//lib/prism/node.rb#7188
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#7205
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to write to the global variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     $foo = :bar
+  #            ^^^^
+  #
+  #     $-xyz = 123
+  #             ^^^
+  #
+  # source://prism//lib/prism/node.rb#7182
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#7210
+    def type; end
+  end
+end
+
+# Represents a hash literal.
+#
+#     { a => b }
+#     ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#7229
+class Prism::HashNode < ::Prism::Node
+  # Initialize a new HashNode node.
+  #
+  # @return [HashNode] a new instance of HashNode
+  #
+  # source://prism//lib/prism/node.rb#7231
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)],
+      closing_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, elements, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#7330
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#7242
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7247
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#7309
+  sig { returns(String) }
+  def closing; end
+
+  # The location of the closing brace.
+  #
+  #     { a => b }
+  #              ^
+  #
+  # source://prism//lib/prism/node.rb#7297
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#7257
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#7252
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?elements: Array[AssocNode | AssocSplatNode], ?closing_loc: Location) -> HashNode
+  #
+  # source://prism//lib/prism/node.rb#7262
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)],
+      closing_loc: Prism::Location
+    ).returns(Prism::HashNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), elements: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7247
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, elements: Array[AssocNode | AssocSplatNode], closing_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#7270
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s.
+  #
+  #     { a: b }
+  #       ^^^^
+  #
+  #     { **foo }
+  #       ^^^^^
+  #
+  # source://prism//lib/prism/node.rb#7291
+  sig { returns(T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]) }
+  def elements; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#7314
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#7304
+  sig { returns(String) }
+  def opening; end
+
+  # The location of the opening brace.
+  #
+  #     { a => b }
+  #     ^
+  #
+  # source://prism//lib/prism/node.rb#7278
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#7319
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#7324
+    def type; end
+  end
+end
+
+# Represents a hash pattern in pattern matching.
+#
+#     foo => { a: 1, b: 2 }
+#            ^^^^^^^^^^^^^^
+#
+#     foo => { a: 1, b: 2, **c }
+#            ^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#7346
+class Prism::HashPatternNode < ::Prism::Node
+  # Initialize a new HashPatternNode node.
+  #
+  # @return [HashPatternNode] a new instance of HashPatternNode
+  #
+  # source://prism//lib/prism/node.rb#7348
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      constant: T.nilable(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode)),
+      elements: T::Array[Prism::AssocNode],
+      rest: T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode)),
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, constant, elements, rest, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#7459
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#7361
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7366
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#7438
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#7420
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#7380
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#7371
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # attr_reader constant: ConstantReadNode | ConstantPathNode | nil
+  #
+  # source://prism//lib/prism/node.rb#7398
+  sig { returns(T.nilable(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode))) }
+  def constant; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantReadNode | ConstantPathNode | nil, ?elements: Array[AssocNode], ?rest: AssocSplatNode | NoKeywordsParameterNode | nil, ?opening_loc: Location?, ?closing_loc: Location?) -> HashPatternNode
+  #
+  # source://prism//lib/prism/node.rb#7385
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      constant: T.nilable(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode)),
+      elements: T::Array[Prism::AssocNode],
+      rest: T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode)),
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::HashPatternNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), elements: T.unsafe(nil), rest: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7366
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantReadNode | ConstantPathNode | nil, elements: Array[AssocNode], rest: AssocSplatNode | NoKeywordsParameterNode | nil, opening_loc: Location?, closing_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#7393
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader elements: Array[AssocNode]
+  #
+  # source://prism//lib/prism/node.rb#7401
+  sig { returns(T::Array[Prism::AssocNode]) }
+  def elements; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#7443
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#7433
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#7407
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # attr_reader rest: AssocSplatNode | NoKeywordsParameterNode | nil
+  #
+  # source://prism//lib/prism/node.rb#7404
+  sig { returns(T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode))) }
+  def rest; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#7448
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#7453
+    def type; end
+  end
+end
+
+# source://prism//lib/prism/node_ext.rb#52
+module Prism::HeredocQuery
+  # Returns true if this node was represented as a heredoc in the source code.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node_ext.rb#54
+  def heredoc?; end
+end
+
+# Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
+#
+#     bar if foo
+#     ^^^^^^^^^^
+#
+#     if foo then bar end
+#     ^^^^^^^^^^^^^^^^^^^
+#
+#     foo ? bar : baz
+#     ^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#7480
+class Prism::IfNode < ::Prism::Node
+  # Initialize a new IfNode node.
+  #
+  # @return [IfNode] a new instance of IfNode
+  #
+  # source://prism//lib/prism/node.rb#7482
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      if_keyword_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      then_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode),
+      subsequent: T.nilable(T.any(Prism::ElseNode, Prism::IfNode)),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, if_keyword_loc, predicate, then_keyword_loc, statements, subsequent, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#7658
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#7496
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7501
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#7515
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#7506
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # Returns the subsequent if/elsif/else clause of the if node. This method is
+  # deprecated in favor of #subsequent.
+  #
+  # source://prism//lib/prism/node_ext.rb#485
+  def consequent; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?if_keyword_loc: Location?, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?subsequent: ElseNode | IfNode | nil, ?end_keyword_loc: Location?) -> IfNode
+  #
+  # source://prism//lib/prism/node.rb#7520
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      if_keyword_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      then_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode),
+      subsequent: T.nilable(T.any(Prism::ElseNode, Prism::IfNode)),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::IfNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), if_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), subsequent: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7501
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, if_keyword_loc: Location?, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, subsequent: ElseNode | IfNode | nil, end_keyword_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#7528
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#7637
+  sig { returns(T.nilable(String)) }
+  def end_keyword; end
+
+  # The location of the `end` keyword if present, `nil` otherwise.
+  #
+  #     if foo
+  #       bar
+  #     end
+  #     ^^^
+  #
+  # source://prism//lib/prism/node.rb#7614
+  sig { returns(T.nilable(Prism::Location)) }
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def if_keyword: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#7627
+  sig { returns(T.nilable(String)) }
+  def if_keyword; end
+
+  # The location of the `if` keyword if present.
+  #
+  #     bar if foo
+  #         ^^
+  #
+  # The `if_keyword_loc` field will be `nil` when the `IfNode` represents a ternary expression.
+  #
+  # source://prism//lib/prism/node.rb#7538
+  sig { returns(T.nilable(Prism::Location)) }
+  def if_keyword_loc; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#7642
+  sig { override.returns(String) }
+  def inspect; end
+
+  # source://prism//lib/prism/parse_result/newlines.rb#91
+  def newline_flag!(lines); end
+
+  # The node for the condition the `IfNode` is testing.
+  #
+  #     if foo
+  #        ^^^
+  #       bar
+  #     end
+  #
+  #     bar if foo
+  #            ^^^
+  #
+  #     foo ? bar : baz
+  #     ^^^
+  #
+  # source://prism//lib/prism/node.rb#7562
+  sig { returns(Prism::Node) }
+  def predicate; end
+
+  # Represents the body of statements that will be executed when the predicate is evaluated as truthy. Will be `nil` when no body is provided.
+  #
+  #     if foo
+  #       bar
+  #       ^^^
+  #       baz
+  #       ^^^
+  #     end
+  #
+  # source://prism//lib/prism/node.rb#7591
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # Represents an `ElseNode` or an `IfNode` when there is an `else` or an `elsif` in the `if` statement.
+  #
+  #     if foo
+  #       bar
+  #     elsif baz
+  #     ^^^^^^^^^
+  #       qux
+  #       ^^^
+  #     end
+  #     ^^^
+  #
+  #     if foo then bar else baz end
+  #                     ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/node.rb#7606
+  sig { returns(T.nilable(T.any(Prism::ElseNode, Prism::IfNode))) }
+  def subsequent; end
+
+  # def then_keyword: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#7632
+  sig { returns(T.nilable(String)) }
+  def then_keyword; end
+
+  # The location of the `then` keyword (if present) or the `?` in a ternary expression, `nil` otherwise.
+  #
+  #     if foo then bar end
+  #            ^^^^
+  #
+  #     a ? b : c
+  #       ^
+  #
+  # source://prism//lib/prism/node.rb#7571
+  sig { returns(T.nilable(Prism::Location)) }
+  def then_keyword_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#7647
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#7652
+    def type; end
+  end
+end
+
+# Represents an imaginary number literal.
+#
+#     1.0i
+#     ^^^^
+#
+# source://prism//lib/prism/node.rb#7673
+class Prism::ImaginaryNode < ::Prism::Node
+  # Initialize a new ImaginaryNode node.
+  #
+  # @return [ImaginaryNode] a new instance of ImaginaryNode
+  #
+  # source://prism//lib/prism/node.rb#7675
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      numeric: T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, numeric); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#7736
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#7684
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7689
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#7699
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#7694
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?numeric: FloatNode | IntegerNode | RationalNode) -> ImaginaryNode
+  #
+  # source://prism//lib/prism/node.rb#7704
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      numeric: T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode)
+    ).returns(Prism::ImaginaryNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), numeric: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7689
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, numeric: FloatNode | IntegerNode | RationalNode }
+  #
+  # source://prism//lib/prism/node.rb#7712
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#7720
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader numeric: FloatNode | IntegerNode | RationalNode
+  #
+  # source://prism//lib/prism/node.rb#7717
+  sig { returns(T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode)) }
+  def numeric; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#7725
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # Returns the value of the node as a Ruby Complex.
+  #
+  # source://prism//lib/prism/node_ext.rb#107
+  sig { returns(Complex) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#7730
+    def type; end
+  end
+end
+
+# Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source.
+#
+#     { foo: }
+#       ^^^^
+#
+#     { Foo: }
+#       ^^^^
+#
+#     foo in { bar: }
+#              ^^^^
+#
+# source://prism//lib/prism/node.rb#7752
+class Prism::ImplicitNode < ::Prism::Node
+  # Initialize a new ImplicitNode node.
+  #
+  # @return [ImplicitNode] a new instance of ImplicitNode
+  #
+  # source://prism//lib/prism/node.rb#7754
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: T.any(Prism::LocalVariableReadNode, Prism::CallNode, Prism::ConstantReadNode, Prism::LocalVariableTargetNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#7815
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#7763
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7768
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#7778
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#7773
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode) -> ImplicitNode
+  #
+  # source://prism//lib/prism/node.rb#7783
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: T.any(Prism::LocalVariableReadNode, Prism::CallNode, Prism::ConstantReadNode, Prism::LocalVariableTargetNode)
+    ).returns(Prism::ImplicitNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7768
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode }
+  #
+  # source://prism//lib/prism/node.rb#7791
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#7799
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#7804
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode
+  #
+  # source://prism//lib/prism/node.rb#7796
+  sig do
+    returns(T.any(Prism::LocalVariableReadNode, Prism::CallNode, Prism::ConstantReadNode, Prism::LocalVariableTargetNode))
+  end
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#7809
+    def type; end
+  end
+end
+
+# Represents using a trailing comma to indicate an implicit rest parameter.
+#
+#     foo { |bar,| }
+#               ^
+#
+#     foo in [bar,]
+#                ^
+#
+#     for foo, in bar do end
+#            ^
+#
+#     foo, = bar
+#        ^
+#
+# source://prism//lib/prism/node.rb#7834
+class Prism::ImplicitRestNode < ::Prism::Node
+  # Initialize a new ImplicitRestNode node.
+  #
+  # @return [ImplicitRestNode] a new instance of ImplicitRestNode
+  #
+  # source://prism//lib/prism/node.rb#7836
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void }
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#7893
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#7844
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7849
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#7859
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#7854
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ImplicitRestNode
+  #
+  # source://prism//lib/prism/node.rb#7864
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::ImplicitRestNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7849
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  #
+  # source://prism//lib/prism/node.rb#7872
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#7877
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#7882
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#7887
+    def type; end
+  end
+end
+
+# Represents the use of the `in` keyword in a case statement.
+#
+#     case a; in b then c end
+#             ^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#7902
+class Prism::InNode < ::Prism::Node
+  # Initialize a new InNode node.
+  #
+  # @return [InNode] a new instance of InNode
+  #
+  # source://prism//lib/prism/node.rb#7904
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      pattern: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode),
+      in_loc: Prism::Location,
+      then_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, pattern, statements, in_loc, then_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#8004
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#7916
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7921
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#7934
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#7926
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?pattern: Prism::node, ?statements: StatementsNode?, ?in_loc: Location, ?then_loc: Location?) -> InNode
+  #
+  # source://prism//lib/prism/node.rb#7939
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      pattern: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode),
+      in_loc: Prism::Location,
+      then_loc: T.nilable(Prism::Location)
+    ).returns(Prism::InNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), pattern: T.unsafe(nil), statements: T.unsafe(nil), in_loc: T.unsafe(nil), then_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#7921
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, pattern: Prism::node, statements: StatementsNode?, in_loc: Location, then_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#7947
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def in: () -> String
+  #
+  # source://prism//lib/prism/node.rb#7978
+  sig { returns(String) }
+  def in; end
+
+  # attr_reader in_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#7958
+  sig { returns(Prism::Location) }
+  def in_loc; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#7988
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader pattern: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#7952
+  sig { returns(Prism::Node) }
+  def pattern; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism//lib/prism/node.rb#7955
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # def then: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#7983
+  sig { returns(T.nilable(String)) }
+  def then; end
+
+  # attr_reader then_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#7965
+  sig { returns(T.nilable(Prism::Location)) }
+  def then_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#7993
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#7998
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator on a call to the `[]` method.
+#
+#     foo.bar[baz] &&= value
+#     ^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#8017
+class Prism::IndexAndWriteNode < ::Prism::Node
+  # Initialize a new IndexAndWriteNode node.
+  #
+  # @return [IndexAndWriteNode] a new instance of IndexAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#8019
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::BlockArgumentNode),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#8175
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#8035
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism//lib/prism/node.rb#8116
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8083
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader block: BlockArgumentNode?
+  #
+  # source://prism//lib/prism/node.rb#8126
+  sig { returns(T.nilable(Prism::BlockArgumentNode)) }
+  def block; end
+
+  # def call_operator: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#8139
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#8096
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#8040
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#8149
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8119
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#8055
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#8045
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?operator_loc: Location, ?value: Prism::node) -> IndexAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#8060
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::BlockArgumentNode),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::IndexAndWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#8040
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#8068
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8088
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#8159
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#8144
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8109
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#8154
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8129
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader receiver: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#8093
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8073
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#8164
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#8136
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8078
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#8169
+    def type; end
+  end
+end
+
+# Represents the use of an assignment operator on a call to `[]`.
+#
+#     foo.bar[baz] += value
+#     ^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#8193
+class Prism::IndexOperatorWriteNode < ::Prism::Node
+  # Initialize a new IndexOperatorWriteNode node.
+  #
+  # @return [IndexOperatorWriteNode] a new instance of IndexOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#8195
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::BlockArgumentNode),
+      binary_operator: Symbol,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#8350
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#8212
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism//lib/prism/node.rb#8293
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8260
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader binary_operator: Symbol
+  #
+  # source://prism//lib/prism/node.rb#8306
+  sig { returns(Symbol) }
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8309
+  sig { returns(Prism::Location) }
+  def binary_operator_loc; end
+
+  # attr_reader block: BlockArgumentNode?
+  #
+  # source://prism//lib/prism/node.rb#8303
+  sig { returns(T.nilable(Prism::BlockArgumentNode)) }
+  def block; end
+
+  # def call_operator: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#8319
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#8273
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#8217
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#8329
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8296
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#8232
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#8222
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node) -> IndexOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#8237
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::BlockArgumentNode),
+      binary_operator: Symbol,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::IndexOperatorWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#8217
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#8245
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8265
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#8334
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#8324
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8286
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  #
+  # source://prism//lib/prism/node_ext.rb#419
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  #
+  # source://prism//lib/prism/node_ext.rb#426
+  def operator_loc; end
+
+  # attr_reader receiver: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#8270
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8250
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#8339
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#8316
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8255
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#8344
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator on a call to `[]`.
+#
+#     foo.bar[baz] ||= value
+#     ^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#8369
+class Prism::IndexOrWriteNode < ::Prism::Node
+  # Initialize a new IndexOrWriteNode node.
+  #
+  # @return [IndexOrWriteNode] a new instance of IndexOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#8371
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::BlockArgumentNode),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#8527
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#8387
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism//lib/prism/node.rb#8468
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8435
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader block: BlockArgumentNode?
+  #
+  # source://prism//lib/prism/node.rb#8478
+  sig { returns(T.nilable(Prism::BlockArgumentNode)) }
+  def block; end
+
+  # def call_operator: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#8491
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#8448
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#8392
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#8501
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8471
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#8407
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#8397
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?operator_loc: Location, ?value: Prism::node) -> IndexOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#8412
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::BlockArgumentNode),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::IndexOrWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#8392
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#8420
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8440
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#8511
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#8496
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8461
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#8506
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8481
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader receiver: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#8445
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8425
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#8516
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#8488
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8430
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#8521
+    def type; end
+  end
+end
+
+# Represents assigning to an index.
+#
+#     foo[bar], = 1
+#     ^^^^^^^^
+#
+#     begin
+#     rescue => foo[bar]
+#               ^^^^^^^^
+#     end
+#
+#     for foo[bar] in baz do end
+#         ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#8553
+class Prism::IndexTargetNode < ::Prism::Node
+  # Initialize a new IndexTargetNode node.
+  #
+  # @return [IndexTargetNode] a new instance of IndexTargetNode
+  #
+  # source://prism//lib/prism/node.rb#8555
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: Prism::Node,
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::BlockArgumentNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, opening_loc, arguments, closing_loc, block); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#8674
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#8568
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism//lib/prism/node.rb#8635
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8615
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader block: BlockArgumentNode?
+  #
+  # source://prism//lib/prism/node.rb#8645
+  sig { returns(T.nilable(Prism::BlockArgumentNode)) }
+  def block; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#8573
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#8653
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8638
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#8587
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#8578
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?) -> IndexTargetNode
+  #
+  # source://prism//lib/prism/node.rb#8592
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: Prism::Node,
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::BlockArgumentNode)
+    ).returns(Prism::IndexTargetNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#8573
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode? }
+  #
+  # source://prism//lib/prism/node.rb#8600
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8620
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#8658
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#8648
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8628
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader receiver: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#8625
+  sig { returns(Prism::Node) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8605
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#8663
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#8610
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#8668
+    def type; end
+  end
+end
+
+# InlineComment objects are the most common. They correspond to comments in
+# the source file like this one that start with #.
+#
+# source://prism//lib/prism/parse_result.rb#529
+class Prism::InlineComment < ::Prism::Comment
+  # Returns a string representation of this comment.
+  #
+  # source://prism//lib/prism/parse_result.rb#537
+  sig { returns(String) }
+  def inspect; end
+
+  # Returns true if this comment happens on the same line as other code and
+  # false if the comment is by itself.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/parse_result.rb#532
+  sig { override.returns(T::Boolean) }
+  def trailing?; end
+end
+
+# This visitor is responsible for composing the strings that get returned by
+# the various #inspect methods defined on each of the nodes.
+#
+# source://prism//lib/prism/inspect_visitor.rb#12
+class Prism::InspectVisitor < ::Prism::Visitor
+  # Initializes a new instance of the InspectVisitor.
+  #
+  # @return [InspectVisitor] a new instance of InspectVisitor
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#35
+  sig { params(indent: String).void }
+  def initialize(indent = T.unsafe(nil)); end
+
+  # The list of commands that we need to execute in order to compose the
+  # final string.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#32
+  def commands; end
+
+  # Compose the final string.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#48
+  sig { returns(String) }
+  def compose; end
+
+  # The current prefix string.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#28
+  def indent; end
+
+  # Inspect a AliasGlobalVariableNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#77
+  def visit_alias_global_variable_node(node); end
+
+  # Inspect a AliasMethodNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#89
+  def visit_alias_method_node(node); end
+
+  # Inspect a AlternationPatternNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#101
+  def visit_alternation_pattern_node(node); end
+
+  # Inspect a AndNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#113
+  def visit_and_node(node); end
+
+  # Inspect a ArgumentsNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#125
+  def visit_arguments_node(node); end
+
+  # Inspect a ArrayNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#141
+  def visit_array_node(node); end
+
+  # Inspect a ArrayPatternNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#159
+  def visit_array_pattern_node(node); end
+
+  # Inspect a AssocNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#198
+  def visit_assoc_node(node); end
+
+  # Inspect a AssocSplatNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#210
+  def visit_assoc_splat_node(node); end
+
+  # Inspect a BackReferenceReadNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#224
+  def visit_back_reference_read_node(node); end
+
+  # Inspect a BeginNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#232
+  def visit_begin_node(node); end
+
+  # Inspect a BlockArgumentNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#265
+  def visit_block_argument_node(node); end
+
+  # Inspect a BlockLocalVariableNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#279
+  def visit_block_local_variable_node(node); end
+
+  # Inspect a BlockNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#287
+  def visit_block_node(node); end
+
+  # Inspect a BlockParameterNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#309
+  def visit_block_parameter_node(node); end
+
+  # Inspect a BlockParametersNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#323
+  def visit_block_parameters_node(node); end
+
+  # Inspect a BreakNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#347
+  def visit_break_node(node); end
+
+  # Inspect a CallAndWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#361
+  def visit_call_and_write_node(node); end
+
+  # Inspect a CallNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#381
+  def visit_call_node(node); end
+
+  # Inspect a CallOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#411
+  def visit_call_operator_write_node(node); end
+
+  # Inspect a CallOrWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#432
+  def visit_call_or_write_node(node); end
+
+  # Inspect a CallTargetNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#452
+  def visit_call_target_node(node); end
+
+  # Inspect a CapturePatternNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#464
+  def visit_capture_pattern_node(node); end
+
+  # Inspect a CaseMatchNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#476
+  def visit_case_match_node(node); end
+
+  # Inspect a CaseNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#506
+  def visit_case_node(node); end
+
+  # Inspect a ClassNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#536
+  def visit_class_node(node); end
+
+  # Inspect a ClassVariableAndWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#562
+  def visit_class_variable_and_write_node(node); end
+
+  # Inspect a ClassVariableOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#574
+  def visit_class_variable_operator_write_node(node); end
+
+  # Inspect a ClassVariableOrWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#587
+  def visit_class_variable_or_write_node(node); end
+
+  # Inspect a ClassVariableReadNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#599
+  def visit_class_variable_read_node(node); end
+
+  # Inspect a ClassVariableTargetNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#607
+  def visit_class_variable_target_node(node); end
+
+  # Inspect a ClassVariableWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#615
+  def visit_class_variable_write_node(node); end
+
+  # Inspect a ConstantAndWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#627
+  def visit_constant_and_write_node(node); end
+
+  # Inspect a ConstantOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#639
+  def visit_constant_operator_write_node(node); end
+
+  # Inspect a ConstantOrWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#652
+  def visit_constant_or_write_node(node); end
+
+  # Inspect a ConstantPathAndWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#664
+  def visit_constant_path_and_write_node(node); end
+
+  # Inspect a ConstantPathNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#676
+  def visit_constant_path_node(node); end
+
+  # Inspect a ConstantPathOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#696
+  def visit_constant_path_operator_write_node(node); end
+
+  # Inspect a ConstantPathOrWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#709
+  def visit_constant_path_or_write_node(node); end
+
+  # Inspect a ConstantPathTargetNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#721
+  def visit_constant_path_target_node(node); end
+
+  # Inspect a ConstantPathWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#741
+  def visit_constant_path_write_node(node); end
+
+  # Inspect a ConstantReadNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#753
+  def visit_constant_read_node(node); end
+
+  # Inspect a ConstantTargetNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#761
+  def visit_constant_target_node(node); end
+
+  # Inspect a ConstantWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#769
+  def visit_constant_write_node(node); end
+
+  # Inspect a DefNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#781
+  def visit_def_node(node); end
+
+  # Inspect a DefinedNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#815
+  def visit_defined_node(node); end
+
+  # Inspect a ElseNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#827
+  def visit_else_node(node); end
+
+  # Inspect a EmbeddedStatementsNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#842
+  def visit_embedded_statements_node(node); end
+
+  # Inspect a EmbeddedVariableNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#857
+  def visit_embedded_variable_node(node); end
+
+  # Inspect a EnsureNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#867
+  def visit_ensure_node(node); end
+
+  # Inspect a FalseNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#882
+  def visit_false_node(node); end
+
+  # Inspect a FindPatternNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#889
+  def visit_find_pattern_node(node); end
+
+  # Inspect a FlipFlopNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#917
+  def visit_flip_flop_node(node); end
+
+  # Inspect a FloatNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#937
+  def visit_float_node(node); end
+
+  # Inspect a ForNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#945
+  def visit_for_node(node); end
+
+  # Inspect a ForwardingArgumentsNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#966
+  def visit_forwarding_arguments_node(node); end
+
+  # Inspect a ForwardingParameterNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#973
+  def visit_forwarding_parameter_node(node); end
+
+  # Inspect a ForwardingSuperNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#980
+  def visit_forwarding_super_node(node); end
+
+  # Inspect a GlobalVariableAndWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#993
+  def visit_global_variable_and_write_node(node); end
+
+  # Inspect a GlobalVariableOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1005
+  def visit_global_variable_operator_write_node(node); end
+
+  # Inspect a GlobalVariableOrWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1018
+  def visit_global_variable_or_write_node(node); end
+
+  # Inspect a GlobalVariableReadNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1030
+  def visit_global_variable_read_node(node); end
+
+  # Inspect a GlobalVariableTargetNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1038
+  def visit_global_variable_target_node(node); end
+
+  # Inspect a GlobalVariableWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1046
+  def visit_global_variable_write_node(node); end
+
+  # Inspect a HashNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1058
+  def visit_hash_node(node); end
+
+  # Inspect a HashPatternNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1076
+  def visit_hash_pattern_node(node); end
+
+  # Inspect a IfNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1106
+  def visit_if_node(node); end
+
+  # Inspect a ImaginaryNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1130
+  def visit_imaginary_node(node); end
+
+  # Inspect a ImplicitNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1139
+  def visit_implicit_node(node); end
+
+  # Inspect a ImplicitRestNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1148
+  def visit_implicit_rest_node(node); end
+
+  # Inspect a InNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1155
+  def visit_in_node(node); end
+
+  # Inspect a IndexAndWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1172
+  def visit_index_and_write_node(node); end
+
+  # Inspect a IndexOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1203
+  def visit_index_operator_write_node(node); end
+
+  # Inspect a IndexOrWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1235
+  def visit_index_or_write_node(node); end
+
+  # Inspect a IndexTargetNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1266
+  def visit_index_target_node(node); end
+
+  # Inspect a InstanceVariableAndWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1289
+  def visit_instance_variable_and_write_node(node); end
+
+  # Inspect a InstanceVariableOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1301
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Inspect a InstanceVariableOrWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1314
+  def visit_instance_variable_or_write_node(node); end
+
+  # Inspect a InstanceVariableReadNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1326
+  def visit_instance_variable_read_node(node); end
+
+  # Inspect a InstanceVariableTargetNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1334
+  def visit_instance_variable_target_node(node); end
+
+  # Inspect a InstanceVariableWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1342
+  def visit_instance_variable_write_node(node); end
+
+  # Inspect a IntegerNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1354
+  def visit_integer_node(node); end
+
+  # Inspect a InterpolatedMatchLastLineNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1362
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Inspect a InterpolatedRegularExpressionNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1380
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Inspect a InterpolatedStringNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1398
+  def visit_interpolated_string_node(node); end
+
+  # Inspect a InterpolatedSymbolNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1416
+  def visit_interpolated_symbol_node(node); end
+
+  # Inspect a InterpolatedXStringNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1434
+  def visit_interpolated_x_string_node(node); end
+
+  # Inspect a ItLocalVariableReadNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1452
+  def visit_it_local_variable_read_node(node); end
+
+  # Inspect a ItParametersNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1459
+  def visit_it_parameters_node(node); end
+
+  # Inspect a KeywordHashNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1466
+  def visit_keyword_hash_node(node); end
+
+  # Inspect a KeywordRestParameterNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1482
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Inspect a LambdaNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1496
+  def visit_lambda_node(node); end
+
+  # Inspect a LocalVariableAndWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1519
+  def visit_local_variable_and_write_node(node); end
+
+  # Inspect a LocalVariableOperatorWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1532
+  def visit_local_variable_operator_write_node(node); end
+
+  # Inspect a LocalVariableOrWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1546
+  def visit_local_variable_or_write_node(node); end
+
+  # Inspect a LocalVariableReadNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1559
+  def visit_local_variable_read_node(node); end
+
+  # Inspect a LocalVariableTargetNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1568
+  def visit_local_variable_target_node(node); end
+
+  # Inspect a LocalVariableWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1577
+  def visit_local_variable_write_node(node); end
+
+  # Inspect a MatchLastLineNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1590
+  def visit_match_last_line_node(node); end
+
+  # Inspect a MatchPredicateNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1601
+  def visit_match_predicate_node(node); end
+
+  # Inspect a MatchRequiredNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1613
+  def visit_match_required_node(node); end
+
+  # Inspect a MatchWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1625
+  def visit_match_write_node(node); end
+
+  # Inspect a MissingNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1643
+  def visit_missing_node(node); end
+
+  # Inspect a ModuleNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1650
+  def visit_module_node(node); end
+
+  # Inspect a MultiTargetNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1669
+  def visit_multi_target_node(node); end
+
+  # Inspect a MultiWriteNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1702
+  def visit_multi_write_node(node); end
+
+  # Inspect a NextNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1738
+  def visit_next_node(node); end
+
+  # Inspect a NilNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1752
+  def visit_nil_node(node); end
+
+  # Inspect a NoKeywordsParameterNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1759
+  def visit_no_keywords_parameter_node(node); end
+
+  # Inspect a NumberedParametersNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1768
+  def visit_numbered_parameters_node(node); end
+
+  # Inspect a NumberedReferenceReadNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1776
+  def visit_numbered_reference_read_node(node); end
+
+  # Inspect a OptionalKeywordParameterNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1784
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Inspect a OptionalParameterNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1795
+  def visit_optional_parameter_node(node); end
+
+  # Inspect a OrNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1807
+  def visit_or_node(node); end
+
+  # Inspect a ParametersNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1819
+  def visit_parameters_node(node); end
+
+  # Inspect a ParenthesesNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1880
+  def visit_parentheses_node(node); end
+
+  # Inspect a PinnedExpressionNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1895
+  def visit_pinned_expression_node(node); end
+
+  # Inspect a PinnedVariableNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1907
+  def visit_pinned_variable_node(node); end
+
+  # Inspect a PostExecutionNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1917
+  def visit_post_execution_node(node); end
+
+  # Inspect a PreExecutionNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1933
+  def visit_pre_execution_node(node); end
+
+  # Inspect a ProgramNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1949
+  def visit_program_node(node); end
+
+  # Inspect a RangeNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1959
+  def visit_range_node(node); end
+
+  # Inspect a RationalNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1979
+  def visit_rational_node(node); end
+
+  # Inspect a RedoNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1988
+  def visit_redo_node(node); end
+
+  # Inspect a RegularExpressionNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#1995
+  def visit_regular_expression_node(node); end
+
+  # Inspect a RequiredKeywordParameterNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2006
+  def visit_required_keyword_parameter_node(node); end
+
+  # Inspect a RequiredParameterNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2015
+  def visit_required_parameter_node(node); end
+
+  # Inspect a RescueModifierNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2023
+  def visit_rescue_modifier_node(node); end
+
+  # Inspect a RescueNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2035
+  def visit_rescue_node(node); end
+
+  # Inspect a RestParameterNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2071
+  def visit_rest_parameter_node(node); end
+
+  # Inspect a RetryNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2085
+  def visit_retry_node(node); end
+
+  # Inspect a ReturnNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2092
+  def visit_return_node(node); end
+
+  # Inspect a SelfNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2106
+  def visit_self_node(node); end
+
+  # Inspect a ShareableConstantNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2113
+  def visit_shareable_constant_node(node); end
+
+  # Inspect a SingletonClassNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2122
+  def visit_singleton_class_node(node); end
+
+  # Inspect a SourceEncodingNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2141
+  def visit_source_encoding_node(node); end
+
+  # Inspect a SourceFileNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2148
+  def visit_source_file_node(node); end
+
+  # Inspect a SourceLineNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2156
+  def visit_source_line_node(node); end
+
+  # Inspect a SplatNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2163
+  def visit_splat_node(node); end
+
+  # Inspect a StatementsNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2177
+  def visit_statements_node(node); end
+
+  # Inspect a StringNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2193
+  def visit_string_node(node); end
+
+  # Inspect a SuperNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2204
+  def visit_super_node(node); end
+
+  # Inspect a SymbolNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2226
+  def visit_symbol_node(node); end
+
+  # Inspect a TrueNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2237
+  def visit_true_node(node); end
+
+  # Inspect a UndefNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2244
+  def visit_undef_node(node); end
+
+  # Inspect a UnlessNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2261
+  def visit_unless_node(node); end
+
+  # Inspect a UntilNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2285
+  def visit_until_node(node); end
+
+  # Inspect a WhenNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2302
+  def visit_when_node(node); end
+
+  # Inspect a WhileNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2326
+  def visit_while_node(node); end
+
+  # Inspect a XStringNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2343
+  def visit_x_string_node(node); end
+
+  # Inspect a YieldNode node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2354
+  def visit_yield_node(node); end
+
+  private
+
+  # Compose a string representing the given inner location field.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2378
+  def inspect_location(location); end
+
+  # Compose a header for the given node.
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#2372
+  def inspect_node(name, node); end
+
+  class << self
+    # Compose an inspect string for the given node.
+    #
+    # source://prism//lib/prism/inspect_visitor.rb#41
+    sig { params(node: Prism::Node).returns(String) }
+    def compose(node); end
+  end
+end
+
+# Most of the time, we can simply pass down the indent to the next node.
+# However, when we are inside a list we want some extra special formatting
+# when we hit an element in that list. In this case, we have a special
+# command that replaces the subsequent indent with the given value.
+#
+# source://prism//lib/prism/inspect_visitor.rb#17
+class Prism::InspectVisitor::Replace
+  # @return [Replace] a new instance of Replace
+  #
+  # source://prism//lib/prism/inspect_visitor.rb#20
+  def initialize(value); end
+
+  # source://prism//lib/prism/inspect_visitor.rb#18
+  def value; end
+end
+
+# Represents the use of the `&&=` operator for assignment to an instance variable.
+#
+#     @target &&= value
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#8689
+class Prism::InstanceVariableAndWriteNode < ::Prism::Node
+  # Initialize a new InstanceVariableAndWriteNode node.
+  #
+  # @return [InstanceVariableAndWriteNode] a new instance of InstanceVariableAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#8691
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#8777
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#8703
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#8708
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#8718
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#8713
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> InstanceVariableAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#8723
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::InstanceVariableAndWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#8708
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#8731
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # source://prism//lib/prism/desugar_compiler.rb#218
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#8761
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#8736
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8739
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#8756
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8746
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#8766
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#8753
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#8771
+    def type; end
+  end
+end
+
+# Represents assigning to an instance variable using an operator that isn't `=`.
+#
+#     @target += value
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#8790
+class Prism::InstanceVariableOperatorWriteNode < ::Prism::Node
+  # Initialize a new InstanceVariableOperatorWriteNode node.
+  #
+  # @return [InstanceVariableOperatorWriteNode] a new instance of InstanceVariableOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#8792
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#8877
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#8805
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader binary_operator: Symbol
+  #
+  # source://prism//lib/prism/node.rb#8858
+  sig { returns(Symbol) }
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8848
+  sig { returns(Prism::Location) }
+  def binary_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#8810
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#8820
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#8815
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> InstanceVariableOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#8825
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::InstanceVariableOperatorWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#8810
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#8833
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # source://prism//lib/prism/desugar_compiler.rb#230
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#8861
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#8838
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8841
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  #
+  # source://prism//lib/prism/node_ext.rb#435
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  #
+  # source://prism//lib/prism/node_ext.rb#442
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#8866
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#8855
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#8871
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to an instance variable.
+#
+#     @target ||= value
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#8891
+class Prism::InstanceVariableOrWriteNode < ::Prism::Node
+  # Initialize a new InstanceVariableOrWriteNode node.
+  #
+  # @return [InstanceVariableOrWriteNode] a new instance of InstanceVariableOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#8893
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#8979
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#8905
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#8910
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#8920
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#8915
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> InstanceVariableOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#8925
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::InstanceVariableOrWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#8910
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#8933
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # source://prism//lib/prism/desugar_compiler.rb#224
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#8963
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#8938
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8941
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#8958
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#8948
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#8968
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#8955
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#8973
+    def type; end
+  end
+end
+
+# Represents referencing an instance variable.
+#
+#     @foo
+#     ^^^^
+#
+# source://prism//lib/prism/node.rb#8992
+class Prism::InstanceVariableReadNode < ::Prism::Node
+  # Initialize a new InstanceVariableReadNode node.
+  #
+  # @return [InstanceVariableReadNode] a new instance of InstanceVariableReadNode
+  #
+  # source://prism//lib/prism/node.rb#8994
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#9059
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#9003
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9008
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#9018
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#9013
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> InstanceVariableReadNode
+  #
+  # source://prism//lib/prism/node.rb#9023
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::InstanceVariableReadNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9008
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#9031
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#9043
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+  #
+  #     @x     # name `:@x`
+  #
+  #     @_test # name `:@_test`
+  #
+  # source://prism//lib/prism/node.rb#9040
+  sig { returns(Symbol) }
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#9048
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#9053
+    def type; end
+  end
+end
+
+# Represents writing to an instance variable in a context that doesn't have an explicit value.
+#
+#     @foo, @bar = baz
+#     ^^^^  ^^^^
+#
+# source://prism//lib/prism/node.rb#9069
+class Prism::InstanceVariableTargetNode < ::Prism::Node
+  # Initialize a new InstanceVariableTargetNode node.
+  #
+  # @return [InstanceVariableTargetNode] a new instance of InstanceVariableTargetNode
+  #
+  # source://prism//lib/prism/node.rb#9071
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#9132
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#9080
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9085
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#9095
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#9090
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> InstanceVariableTargetNode
+  #
+  # source://prism//lib/prism/node.rb#9100
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::InstanceVariableTargetNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9085
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#9108
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#9116
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#9113
+  sig { returns(Symbol) }
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#9121
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#9126
+    def type; end
+  end
+end
+
+# Represents writing to an instance variable.
+#
+#     @foo = 1
+#     ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#9142
+class Prism::InstanceVariableWriteNode < ::Prism::Node
+  # Initialize a new InstanceVariableWriteNode node.
+  #
+  # @return [InstanceVariableWriteNode] a new instance of InstanceVariableWriteNode
+  #
+  # source://prism//lib/prism/node.rb#9144
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#9246
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#9156
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9161
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#9171
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#9166
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> InstanceVariableWriteNode
+  #
+  # source://prism//lib/prism/node.rb#9176
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::InstanceVariableWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9161
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#9184
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#9230
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+  #
+  #     @x = :y       # name `:@x`
+  #
+  #     @_foo = "bar" # name `@_foo`
+  #
+  # source://prism//lib/prism/node.rb#9193
+  sig { returns(Symbol) }
+  def name; end
+
+  # The location of the variable name.
+  #
+  #     @_x = 1
+  #     ^^^
+  #
+  # source://prism//lib/prism/node.rb#9199
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#9225
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `=` operator.
+  #
+  #     @x = y
+  #        ^
+  #
+  # source://prism//lib/prism/node.rb#9218
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#9235
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to write to the instance variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     @foo = :bar
+  #            ^^^^
+  #
+  #     @_x = 1234
+  #           ^^^^
+  #
+  # source://prism//lib/prism/node.rb#9212
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#9240
+    def type; end
+  end
+end
+
+# Flags for integer nodes that correspond to the base of the integer.
+#
+# source://prism//lib/prism/node.rb#16732
+module Prism::IntegerBaseFlags; end
+
+# 0b prefix
+#
+# source://prism//lib/prism/node.rb#16734
+Prism::IntegerBaseFlags::BINARY = T.let(T.unsafe(nil), Integer)
+
+# 0d or no prefix
+#
+# source://prism//lib/prism/node.rb#16737
+Prism::IntegerBaseFlags::DECIMAL = T.let(T.unsafe(nil), Integer)
+
+# 0x prefix
+#
+# source://prism//lib/prism/node.rb#16743
+Prism::IntegerBaseFlags::HEXADECIMAL = T.let(T.unsafe(nil), Integer)
+
+# 0o or 0 prefix
+#
+# source://prism//lib/prism/node.rb#16740
+Prism::IntegerBaseFlags::OCTAL = T.let(T.unsafe(nil), Integer)
+
+# Represents an integer number literal.
+#
+#     1
+#     ^
+#
+# source://prism//lib/prism/node.rb#9259
+class Prism::IntegerNode < ::Prism::Node
+  # Initialize a new IntegerNode node.
+  #
+  # @return [IntegerNode] a new instance of IntegerNode
+  #
+  # source://prism//lib/prism/node.rb#9261
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Integer
+    ).void
+  end
+  def initialize(source, node_id, location, flags, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#9342
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#9270
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def binary?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9303
+  sig { returns(T::Boolean) }
+  def binary?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9275
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#9285
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#9280
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Integer) -> IntegerNode
+  #
+  # source://prism//lib/prism/node.rb#9290
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Integer
+    ).returns(Prism::IntegerNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def decimal?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9308
+  sig { returns(T::Boolean) }
+  def decimal?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9275
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Integer }
+  #
+  # source://prism//lib/prism/node.rb#9298
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def hexadecimal?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9318
+  sig { returns(T::Boolean) }
+  def hexadecimal?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#9326
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def octal?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9313
+  sig { returns(T::Boolean) }
+  def octal?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#9331
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value of the integer literal as a number.
+  #
+  # source://prism//lib/prism/node.rb#9323
+  sig { returns(Integer) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#9336
+    def type; end
+  end
+end
+
+# Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object.
+#
+#     if /foo #{bar} baz/ then end
+#        ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#9353
+class Prism::InterpolatedMatchLastLineNode < ::Prism::Node
+  include ::Prism::RegularExpressionOptions
+
+  # Initialize a new InterpolatedMatchLastLineNode node.
+  #
+  # @return [InterpolatedMatchLastLineNode] a new instance of InterpolatedMatchLastLineNode
+  #
+  # source://prism//lib/prism/node.rb#9355
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#9497
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#9366
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def ascii_8bit?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9424
+  sig { returns(T::Boolean) }
+  def ascii_8bit?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9371
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#9476
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#9464
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#9381
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#9376
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedMatchLastLineNode
+  #
+  # source://prism//lib/prism/node.rb#9386
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).returns(Prism::InterpolatedMatchLastLineNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9371
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#9394
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def euc_jp?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9419
+  sig { returns(T::Boolean) }
+  def euc_jp?; end
+
+  # def extended?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9404
+  sig { returns(T::Boolean) }
+  def extended?; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9444
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9449
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9439
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def ignore_case?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9399
+  sig { returns(T::Boolean) }
+  def ignore_case?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#9481
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def multi_line?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9409
+  sig { returns(T::Boolean) }
+  def multi_line?; end
+
+  # source://prism//lib/prism/parse_result/newlines.rb#121
+  def newline_flag!(lines); end
+
+  # def once?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9414
+  sig { returns(T::Boolean) }
+  def once?; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#9471
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#9454
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  sig { returns(Integer) }
+  def options; end
+
+  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
+  #
+  # source://prism//lib/prism/node.rb#9461
+  sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) }
+  def parts; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#9486
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # def utf_8?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9434
+  sig { returns(T::Boolean) }
+  def utf_8?; end
+
+  # def windows_31j?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9429
+  sig { returns(T::Boolean) }
+  def windows_31j?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#9491
+    def type; end
+  end
+end
+
+# Represents a regular expression literal that contains interpolation.
+#
+#     /foo #{bar} baz/
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#9511
+class Prism::InterpolatedRegularExpressionNode < ::Prism::Node
+  include ::Prism::RegularExpressionOptions
+
+  # Initialize a new InterpolatedRegularExpressionNode node.
+  #
+  # @return [InterpolatedRegularExpressionNode] a new instance of InterpolatedRegularExpressionNode
+  #
+  # source://prism//lib/prism/node.rb#9513
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#9655
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#9524
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def ascii_8bit?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9582
+  sig { returns(T::Boolean) }
+  def ascii_8bit?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9529
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#9634
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#9622
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#9539
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#9534
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedRegularExpressionNode
+  #
+  # source://prism//lib/prism/node.rb#9544
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).returns(Prism::InterpolatedRegularExpressionNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9529
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#9552
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def euc_jp?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9577
+  sig { returns(T::Boolean) }
+  def euc_jp?; end
+
+  # def extended?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9562
+  sig { returns(T::Boolean) }
+  def extended?; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9602
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9607
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9597
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def ignore_case?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9557
+  sig { returns(T::Boolean) }
+  def ignore_case?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#9639
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def multi_line?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9567
+  sig { returns(T::Boolean) }
+  def multi_line?; end
+
+  # source://prism//lib/prism/parse_result/newlines.rb#128
+  def newline_flag!(lines); end
+
+  # def once?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9572
+  sig { returns(T::Boolean) }
+  def once?; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#9629
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#9612
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  sig { returns(Integer) }
+  def options; end
+
+  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
+  #
+  # source://prism//lib/prism/node.rb#9619
+  sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) }
+  def parts; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#9644
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # def utf_8?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9592
+  sig { returns(T::Boolean) }
+  def utf_8?; end
+
+  # def windows_31j?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9587
+  sig { returns(T::Boolean) }
+  def windows_31j?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#9649
+    def type; end
+  end
+end
+
+# Represents a string literal that contains interpolation.
+#
+#     "foo #{bar} baz"
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#9669
+class Prism::InterpolatedStringNode < ::Prism::Node
+  include ::Prism::HeredocQuery
+
+  # Initialize a new InterpolatedStringNode node.
+  #
+  # @return [InterpolatedStringNode] a new instance of InterpolatedStringNode
+  #
+  # source://prism//lib/prism/node.rb#9671
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)],
+      closing_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#9780
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#9682
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9687
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#9759
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#9741
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#9697
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#9692
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode], ?closing_loc: Location?) -> InterpolatedStringNode
+  #
+  # source://prism//lib/prism/node.rb#9702
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)],
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::InterpolatedStringNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9687
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode], closing_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#9710
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def frozen?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9715
+  sig { returns(T::Boolean) }
+  def frozen?; end
+
+  sig { returns(T::Boolean) }
+  def heredoc?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#9764
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def mutable?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#9720
+  sig { returns(T::Boolean) }
+  def mutable?; end
+
+  # source://prism//lib/prism/parse_result/newlines.rb#135
+  def newline_flag!(lines); end
+
+  # def opening: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#9754
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#9725
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode]
+  #
+  # source://prism//lib/prism/node.rb#9738
+  sig do
+    returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)])
+  end
+  def parts; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#9769
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#9774
+    def type; end
+  end
+end
+
+# Flags for interpolated string nodes that indicated mutability if they are also marked as literals.
+#
+# source://prism//lib/prism/node.rb#16747
+module Prism::InterpolatedStringNodeFlags; end
+
+# source://prism//lib/prism/node.rb#16749
+Prism::InterpolatedStringNodeFlags::FROZEN = T.let(T.unsafe(nil), Integer)
+
+# source://prism//lib/prism/node.rb#16752
+Prism::InterpolatedStringNodeFlags::MUTABLE = T.let(T.unsafe(nil), Integer)
+
+# Represents a symbol literal that contains interpolation.
+#
+#     :"foo #{bar} baz"
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#9794
+class Prism::InterpolatedSymbolNode < ::Prism::Node
+  # Initialize a new InterpolatedSymbolNode node.
+  #
+  # @return [InterpolatedSymbolNode] a new instance of InterpolatedSymbolNode
+  #
+  # source://prism//lib/prism/node.rb#9796
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#9895
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#9807
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9812
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#9874
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#9856
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#9822
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#9817
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location?) -> InterpolatedSymbolNode
+  #
+  # source://prism//lib/prism/node.rb#9827
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::InterpolatedSymbolNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9812
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#9835
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#9879
+  sig { override.returns(String) }
+  def inspect; end
+
+  # source://prism//lib/prism/parse_result/newlines.rb#142
+  def newline_flag!(lines); end
+
+  # def opening: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#9869
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#9840
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
+  #
+  # source://prism//lib/prism/node.rb#9853
+  sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) }
+  def parts; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#9884
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#9889
+    def type; end
+  end
+end
+
+# Represents an xstring literal that contains interpolation.
+#
+#     `foo #{bar} baz`
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#9908
+class Prism::InterpolatedXStringNode < ::Prism::Node
+  include ::Prism::HeredocQuery
+
+  # Initialize a new InterpolatedXStringNode node.
+  #
+  # @return [InterpolatedXStringNode] a new instance of InterpolatedXStringNode
+  #
+  # source://prism//lib/prism/node.rb#9910
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#9997
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#9921
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9926
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#9976
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#9964
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#9936
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#9931
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedXStringNode
+  #
+  # source://prism//lib/prism/node.rb#9941
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).returns(Prism::InterpolatedXStringNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#9926
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#9949
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  sig { returns(T::Boolean) }
+  def heredoc?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#9981
+  sig { override.returns(String) }
+  def inspect; end
+
+  # source://prism//lib/prism/parse_result/newlines.rb#149
+  def newline_flag!(lines); end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#9971
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#9954
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
+  #
+  # source://prism//lib/prism/node.rb#9961
+  sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) }
+  def parts; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#9986
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#9991
+    def type; end
+  end
+end
+
+# Represents reading from the implicit `it` local variable.
+#
+#     -> { it }
+#          ^^
+#
+# source://prism//lib/prism/node.rb#10010
+class Prism::ItLocalVariableReadNode < ::Prism::Node
+  # Initialize a new ItLocalVariableReadNode node.
+  #
+  # @return [ItLocalVariableReadNode] a new instance of ItLocalVariableReadNode
+  #
+  # source://prism//lib/prism/node.rb#10012
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void }
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#10069
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#10020
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10025
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#10035
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#10030
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ItLocalVariableReadNode
+  #
+  # source://prism//lib/prism/node.rb#10040
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::ItLocalVariableReadNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10025
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  #
+  # source://prism//lib/prism/node.rb#10048
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#10053
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#10058
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#10063
+    def type; end
+  end
+end
+
+# Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
+#
+#     -> { it + it }
+#     ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#10078
+class Prism::ItParametersNode < ::Prism::Node
+  # Initialize a new ItParametersNode node.
+  #
+  # @return [ItParametersNode] a new instance of ItParametersNode
+  #
+  # source://prism//lib/prism/node.rb#10080
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void }
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#10137
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#10088
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10093
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#10103
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#10098
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ItParametersNode
+  #
+  # source://prism//lib/prism/node.rb#10108
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::ItParametersNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10093
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  #
+  # source://prism//lib/prism/node.rb#10116
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#10121
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#10126
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#10131
+    def type; end
+  end
+end
+
+# Represents a hash literal without opening and closing braces.
+#
+#     foo(a: b)
+#         ^^^^
+#
+# source://prism//lib/prism/node.rb#10146
+class Prism::KeywordHashNode < ::Prism::Node
+  # Initialize a new KeywordHashNode node.
+  #
+  # @return [KeywordHashNode] a new instance of KeywordHashNode
+  #
+  # source://prism//lib/prism/node.rb#10148
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]
+    ).void
+  end
+  def initialize(source, node_id, location, flags, elements); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#10214
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#10157
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10162
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#10172
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#10167
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?elements: Array[AssocNode | AssocSplatNode]) -> KeywordHashNode
+  #
+  # source://prism//lib/prism/node.rb#10177
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]
+    ).returns(Prism::KeywordHashNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), elements: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10162
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, elements: Array[AssocNode | AssocSplatNode] }
+  #
+  # source://prism//lib/prism/node.rb#10185
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader elements: Array[AssocNode | AssocSplatNode]
+  #
+  # source://prism//lib/prism/node.rb#10195
+  sig { returns(T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]) }
+  def elements; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#10198
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def symbol_keys?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#10190
+  sig { returns(T::Boolean) }
+  def symbol_keys?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#10203
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#10208
+    def type; end
+  end
+end
+
+# Flags for keyword hash nodes.
+#
+# source://prism//lib/prism/node.rb#16756
+module Prism::KeywordHashNodeFlags; end
+
+# a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments
+#
+# source://prism//lib/prism/node.rb#16758
+Prism::KeywordHashNodeFlags::SYMBOL_KEYS = T.let(T.unsafe(nil), Integer)
+
+# Represents a keyword rest parameter to a method, block, or lambda definition.
+#
+#     def a(**b)
+#           ^^^
+#     end
+#
+# source://prism//lib/prism/node.rb#10227
+class Prism::KeywordRestParameterNode < ::Prism::Node
+  # Initialize a new KeywordRestParameterNode node.
+  #
+  # @return [KeywordRestParameterNode] a new instance of KeywordRestParameterNode
+  #
+  # source://prism//lib/prism/node.rb#10229
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#10322
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#10240
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10245
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#10255
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#10250
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> KeywordRestParameterNode
+  #
+  # source://prism//lib/prism/node.rb#10260
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).returns(Prism::KeywordRestParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10245
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#10268
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#10306
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol?
+  #
+  # source://prism//lib/prism/node.rb#10278
+  sig { returns(T.nilable(Symbol)) }
+  def name; end
+
+  # attr_reader name_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#10281
+  sig { returns(T.nilable(Prism::Location)) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#10301
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#10294
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#10273
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#10311
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#10316
+    def type; end
+  end
+end
+
+# Represents using a lambda literal (not the lambda method call).
+#
+#     ->(value) { value * 2 }
+#     ^^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#10335
+class Prism::LambdaNode < ::Prism::Node
+  # Initialize a new LambdaNode node.
+  #
+  # @return [LambdaNode] a new instance of LambdaNode
+  #
+  # source://prism//lib/prism/node.rb#10337
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      operator_loc: Prism::Location,
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      parameters: T.nilable(T.any(Prism::BlockParametersNode, Prism::NumberedParametersNode, Prism::ItParametersNode)),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))
+    ).void
+  end
+  def initialize(source, node_id, location, flags, locals, operator_loc, opening_loc, closing_loc, parameters, body); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#10448
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#10351
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader body: StatementsNode | BeginNode | nil
+  #
+  # source://prism//lib/prism/node.rb#10414
+  sig { returns(T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10356
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#10427
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#10404
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#10369
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#10361
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?operator_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, ?body: StatementsNode | BeginNode | nil) -> LambdaNode
+  #
+  # source://prism//lib/prism/node.rb#10374
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      operator_loc: Prism::Location,
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      parameters: T.nilable(T.any(Prism::BlockParametersNode, Prism::NumberedParametersNode, Prism::ItParametersNode)),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))
+    ).returns(Prism::LambdaNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10356
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, body: StatementsNode | BeginNode | nil }
+  #
+  # source://prism//lib/prism/node.rb#10382
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#10432
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[Symbol]
+  #
+  # source://prism//lib/prism/node.rb#10387
+  sig { returns(T::Array[Symbol]) }
+  def locals; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#10422
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#10397
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#10417
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#10390
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil
+  #
+  # source://prism//lib/prism/node.rb#10411
+  sig { returns(T.nilable(T.any(Prism::BlockParametersNode, Prism::NumberedParametersNode, Prism::ItParametersNode))) }
+  def parameters; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#10437
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#10442
+    def type; end
+  end
+end
+
+# This class is responsible for lexing the source using prism and then
+# converting those tokens to be compatible with Ripper. In the vast majority
+# of cases, this is a one-to-one mapping of the token type. Everything else
+# generally lines up. However, there are a few cases that require special
+# handling.
+#
+# source://prism//lib/prism/lex_compat.rb#12
+class Prism::LexCompat
+  # @return [LexCompat] a new instance of LexCompat
+  #
+  # source://prism//lib/prism/lex_compat.rb#619
+  def initialize(source, **options); end
+
+  # Returns the value of attribute options.
+  #
+  # source://prism//lib/prism/lex_compat.rb#617
+  def options; end
+
+  # source://prism//lib/prism/lex_compat.rb#624
+  def result; end
+
+  # Returns the value of attribute source.
+  #
+  # source://prism//lib/prism/lex_compat.rb#617
+  def source; end
+end
+
+# Ripper doesn't include the rest of the token in the event, so we need to
+# trim it down to just the content on the first line when comparing.
+#
+# source://prism//lib/prism/lex_compat.rb#230
+class Prism::LexCompat::EndContentToken < ::Prism::LexCompat::Token
+  # source://prism//lib/prism/lex_compat.rb#231
+  def ==(other); end
+end
+
+# A heredoc in this case is a list of tokens that belong to the body of the
+# heredoc that should be appended onto the list of tokens when the heredoc
+# closes.
+#
+# source://prism//lib/prism/lex_compat.rb#291
+module Prism::LexCompat::Heredoc
+  class << self
+    # Here we will split between the two types of heredocs and return the
+    # object that will store their tokens.
+    #
+    # source://prism//lib/prism/lex_compat.rb#603
+    def build(opening); end
+  end
+end
+
+# Dash heredocs are a little more complicated. They are a list of tokens
+# that need to be split on "\\\n" to mimic Ripper's behavior. We also need
+# to keep track of the state that the heredoc was opened in.
+#
+# source://prism//lib/prism/lex_compat.rb#315
+class Prism::LexCompat::Heredoc::DashHeredoc
+  # @return [DashHeredoc] a new instance of DashHeredoc
+  #
+  # source://prism//lib/prism/lex_compat.rb#318
+  def initialize(split); end
+
+  # source://prism//lib/prism/lex_compat.rb#323
+  def <<(token); end
+
+  # source://prism//lib/prism/lex_compat.rb#316
+  def split; end
+
+  # source://prism//lib/prism/lex_compat.rb#327
+  def to_a; end
+
+  # source://prism//lib/prism/lex_compat.rb#316
+  def tokens; end
+end
+
+# Heredocs that are dedenting heredocs are a little more complicated.
+# Ripper outputs on_ignored_sp tokens for the whitespace that is being
+# removed from the output. prism only modifies the node itself and keeps
+# the token the same. This simplifies prism, but makes comparing against
+# Ripper much harder because there is a length mismatch.
+#
+# Fortunately, we already have to pull out the heredoc tokens in order to
+# insert them into the stream in the correct order. As such, we can do
+# some extra manipulation on the tokens to make them match Ripper's
+# output by mirroring the dedent logic that Ripper uses.
+#
+# source://prism//lib/prism/lex_compat.rb#374
+class Prism::LexCompat::Heredoc::DedentingHeredoc
+  # @return [DedentingHeredoc] a new instance of DedentingHeredoc
+  #
+  # source://prism//lib/prism/lex_compat.rb#379
+  def initialize; end
+
+  # As tokens are coming in, we track the minimum amount of common leading
+  # whitespace on plain string content tokens. This allows us to later
+  # remove that amount of whitespace from the beginning of each line.
+  #
+  # source://prism//lib/prism/lex_compat.rb#390
+  def <<(token); end
+
+  # Returns the value of attribute dedent.
+  #
+  # source://prism//lib/prism/lex_compat.rb#377
+  def dedent; end
+
+  # Returns the value of attribute dedent_next.
+  #
+  # source://prism//lib/prism/lex_compat.rb#377
+  def dedent_next; end
+
+  # Returns the value of attribute embexpr_balance.
+  #
+  # source://prism//lib/prism/lex_compat.rb#377
+  def embexpr_balance; end
+
+  # source://prism//lib/prism/lex_compat.rb#427
+  def to_a; end
+
+  # Returns the value of attribute tokens.
+  #
+  # source://prism//lib/prism/lex_compat.rb#377
+  def tokens; end
+end
+
+# source://prism//lib/prism/lex_compat.rb#375
+Prism::LexCompat::Heredoc::DedentingHeredoc::TAB_WIDTH = T.let(T.unsafe(nil), Integer)
+
+# Heredocs that are no dash or tilde heredocs are just a list of tokens.
+# We need to keep them around so that we can insert them in the correct
+# order back into the token stream and set the state of the last token to
+# the state that the heredoc was opened in.
+#
+# source://prism//lib/prism/lex_compat.rb#296
+class Prism::LexCompat::Heredoc::PlainHeredoc
+  # @return [PlainHeredoc] a new instance of PlainHeredoc
+  #
+  # source://prism//lib/prism/lex_compat.rb#299
+  def initialize; end
+
+  # source://prism//lib/prism/lex_compat.rb#303
+  def <<(token); end
+
+  # source://prism//lib/prism/lex_compat.rb#307
+  def to_a; end
+
+  # source://prism//lib/prism/lex_compat.rb#297
+  def tokens; end
+end
+
+# Ident tokens for the most part are exactly the same, except sometimes we
+# know an ident is a local when ripper doesn't (when they are introduced
+# through named captures in regular expressions). In that case we don't
+# compare the state.
+#
+# source://prism//lib/prism/lex_compat.rb#248
+class Prism::LexCompat::IdentToken < ::Prism::LexCompat::Token
+  # source://prism//lib/prism/lex_compat.rb#249
+  def ==(other); end
+end
+
+# Tokens where state should be ignored
+# used for :on_comment, :on_heredoc_end, :on_embexpr_end
+#
+# source://prism//lib/prism/lex_compat.rb#238
+class Prism::LexCompat::IgnoreStateToken < ::Prism::LexCompat::Token
+  # source://prism//lib/prism/lex_compat.rb#239
+  def ==(other); end
+end
+
+# Ignored newlines can occasionally have a LABEL state attached to them, so
+# we compare the state differently here.
+#
+# source://prism//lib/prism/lex_compat.rb#259
+class Prism::LexCompat::IgnoredNewlineToken < ::Prism::LexCompat::Token
+  # source://prism//lib/prism/lex_compat.rb#260
+  def ==(other); end
+end
+
+# If we have an identifier that follows a method name like:
+#
+#     def foo bar
+#
+# then Ripper will mark bar as END|LABEL if there is a local in a parent
+# scope named bar because it hasn't pushed the local table yet. We do this
+# more accurately, so we need to allow comparing against both END and
+# END|LABEL.
+#
+# source://prism//lib/prism/lex_compat.rb#279
+class Prism::LexCompat::ParamToken < ::Prism::LexCompat::Token
+  # source://prism//lib/prism/lex_compat.rb#280
+  def ==(other); end
+end
+
+# This is a mapping of prism token types to Ripper token types. This is a
+# many-to-one mapping because we split up our token types, whereas Ripper
+# tends to group them.
+#
+# source://prism//lib/prism/lex_compat.rb#33
+Prism::LexCompat::RIPPER = T.let(T.unsafe(nil), Hash)
+
+# A result class specialized for holding tokens produced by the lexer.
+#
+# source://prism//lib/prism/lex_compat.rb#14
+class Prism::LexCompat::Result < ::Prism::Result
+  # Create a new lex compat result object with the given values.
+  #
+  # @return [Result] a new instance of Result
+  #
+  # source://prism//lib/prism/lex_compat.rb#19
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  # Implement the hash pattern matching interface for Result.
+  #
+  # source://prism//lib/prism/lex_compat.rb#25
+  def deconstruct_keys(keys); end
+
+  # The list of tokens that were produced by the lexer.
+  #
+  # source://prism//lib/prism/lex_compat.rb#16
+  def value; end
+end
+
+# When we produce tokens, we produce the same arrays that Ripper does.
+# However, we add a couple of convenience methods onto them to make them a
+# little easier to work with. We delegate all other methods to the array.
+#
+# source://prism//lib/prism/lex_compat.rb#204
+class Prism::LexCompat::Token < ::SimpleDelegator
+  # The type of the token.
+  #
+  # source://prism//lib/prism/lex_compat.rb#213
+  def event; end
+
+  # The location of the token in the source.
+  #
+  # source://prism//lib/prism/lex_compat.rb#208
+  def location; end
+
+  # The state of the lexer when this token was produced.
+  #
+  # source://prism//lib/prism/lex_compat.rb#223
+  def state; end
+
+  # The slice of the source that this token represents.
+  #
+  # source://prism//lib/prism/lex_compat.rb#218
+  def value; end
+end
+
+# This is a result specific to the `lex` and `lex_file` methods.
+#
+# source://prism//lib/prism/parse_result.rb#764
+class Prism::LexResult < ::Prism::Result
+  # Create a new lex result object with the given values.
+  #
+  # @return [LexResult] a new instance of LexResult
+  #
+  # source://prism//lib/prism/parse_result.rb#769
+  sig do
+    params(
+      value: T::Array[T.untyped],
+      comments: T::Array[Prism::Comment],
+      magic_comments: T::Array[Prism::MagicComment],
+      data_loc: T.nilable(Prism::Location),
+      errors: T::Array[Prism::ParseError],
+      warnings: T::Array[Prism::ParseWarning],
+      source: Prism::Source
+    ).void
+  end
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  # Implement the hash pattern matching interface for LexResult.
+  #
+  # source://prism//lib/prism/parse_result.rb#775
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # The list of tokens that were parsed from the source code.
+  #
+  # source://prism//lib/prism/parse_result.rb#766
+  sig { returns(T::Array[T.untyped]) }
+  def value; end
+end
+
+# This is a class that wraps the Ripper lexer to produce almost exactly the
+# same tokens.
+#
+# source://prism//lib/prism/lex_compat.rb#872
+class Prism::LexRipper
+  # @return [LexRipper] a new instance of LexRipper
+  #
+  # source://prism//lib/prism/lex_compat.rb#875
+  def initialize(source); end
+
+  # source://prism//lib/prism/lex_compat.rb#879
+  def result; end
+
+  # source://prism//lib/prism/lex_compat.rb#873
+  def source; end
+
+  private
+
+  # source://prism//lib/prism/lex_compat.rb#913
+  def lex(source); end
+end
+
+# Represents the use of the `&&=` operator for assignment to a local variable.
+#
+#     target &&= value
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#10464
+class Prism::LocalVariableAndWriteNode < ::Prism::Node
+  # Initialize a new LocalVariableAndWriteNode node.
+  #
+  # @return [LocalVariableAndWriteNode] a new instance of LocalVariableAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#10466
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node,
+      name: Symbol,
+      depth: Integer
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name_loc, operator_loc, value, name, depth); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#10556
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#10479
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10484
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#10494
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#10489
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer) -> LocalVariableAndWriteNode
+  #
+  # source://prism//lib/prism/node.rb#10499
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node,
+      name: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableAndWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10484
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer }
+  #
+  # source://prism//lib/prism/node.rb#10507
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader depth: Integer
+  #
+  # source://prism//lib/prism/node.rb#10532
+  sig { returns(Integer) }
+  def depth; end
+
+  # source://prism//lib/prism/desugar_compiler.rb#236
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#10540
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#10529
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#10512
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#10535
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#10519
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#10545
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#10526
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#10550
+    def type; end
+  end
+end
+
+# Represents assigning to a local variable using an operator that isn't `=`.
+#
+#     target += value
+#     ^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#10570
+class Prism::LocalVariableOperatorWriteNode < ::Prism::Node
+  # Initialize a new LocalVariableOperatorWriteNode node.
+  #
+  # @return [LocalVariableOperatorWriteNode] a new instance of LocalVariableOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#10572
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      name: Symbol,
+      binary_operator: Symbol,
+      depth: Integer
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name_loc, binary_operator_loc, value, name, binary_operator, depth); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#10661
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#10586
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader binary_operator: Symbol
+  #
+  # source://prism//lib/prism/node.rb#10639
+  sig { returns(Symbol) }
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#10626
+  sig { returns(Prism::Location) }
+  def binary_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10591
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#10601
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#10596
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?binary_operator: Symbol, ?depth: Integer) -> LocalVariableOperatorWriteNode
+  #
+  # source://prism//lib/prism/node.rb#10606
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      name: Symbol,
+      binary_operator: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableOperatorWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), binary_operator: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10591
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, binary_operator_loc: Location, value: Prism::node, name: Symbol, binary_operator: Symbol, depth: Integer }
+  #
+  # source://prism//lib/prism/node.rb#10614
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader depth: Integer
+  #
+  # source://prism//lib/prism/node.rb#10642
+  sig { returns(Integer) }
+  def depth; end
+
+  # source://prism//lib/prism/desugar_compiler.rb#248
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#10645
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#10636
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#10619
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  #
+  # source://prism//lib/prism/node_ext.rb#451
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  #
+  # source://prism//lib/prism/node_ext.rb#458
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#10650
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#10633
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#10655
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a local variable.
+#
+#     target ||= value
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#10676
+class Prism::LocalVariableOrWriteNode < ::Prism::Node
+  # Initialize a new LocalVariableOrWriteNode node.
+  #
+  # @return [LocalVariableOrWriteNode] a new instance of LocalVariableOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#10678
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node,
+      name: Symbol,
+      depth: Integer
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name_loc, operator_loc, value, name, depth); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#10768
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#10691
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10696
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#10706
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#10701
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer) -> LocalVariableOrWriteNode
+  #
+  # source://prism//lib/prism/node.rb#10711
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node,
+      name: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableOrWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10696
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer }
+  #
+  # source://prism//lib/prism/node.rb#10719
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader depth: Integer
+  #
+  # source://prism//lib/prism/node.rb#10744
+  sig { returns(Integer) }
+  def depth; end
+
+  # source://prism//lib/prism/desugar_compiler.rb#242
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#10752
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#10741
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#10724
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#10747
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#10731
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#10757
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#10738
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#10762
+    def type; end
+  end
+end
+
+# Represents reading a local variable. Note that this requires that a local variable of the same name has already been written to in the same scope, otherwise it is parsed as a method call.
+#
+#     foo
+#     ^^^
+#
+# source://prism//lib/prism/node.rb#10782
+class Prism::LocalVariableReadNode < ::Prism::Node
+  # Initialize a new LocalVariableReadNode node.
+  #
+  # @return [LocalVariableReadNode] a new instance of LocalVariableReadNode
+  #
+  # source://prism//lib/prism/node.rb#10784
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      depth: Integer
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, depth); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#10863
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#10794
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10799
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#10809
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#10804
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer) -> LocalVariableReadNode
+  #
+  # source://prism//lib/prism/node.rb#10814
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableReadNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10799
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer }
+  #
+  # source://prism//lib/prism/node.rb#10822
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # The number of visible scopes that should be searched to find the origin of this local variable.
+  #
+  #     foo = 1; foo # depth 0
+  #
+  #     bar = 2; tap { bar } # depth 1
+  #
+  # The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
+  #
+  # source://prism//lib/prism/node.rb#10844
+  sig { returns(Integer) }
+  def depth; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#10847
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+  #
+  #     x      # name `:x`
+  #
+  #     _Test  # name `:_Test`
+  #
+  # Note that this can also be an underscore followed by a number for the default block parameters.
+  #
+  #     _1     # name `:_1`
+  #
+  # source://prism//lib/prism/node.rb#10835
+  sig { returns(Symbol) }
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#10852
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#10857
+    def type; end
+  end
+end
+
+# Represents writing to a local variable in a context that doesn't have an explicit value.
+#
+#     foo, bar = baz
+#     ^^^  ^^^
+#
+# source://prism//lib/prism/node.rb#10874
+class Prism::LocalVariableTargetNode < ::Prism::Node
+  # Initialize a new LocalVariableTargetNode node.
+  #
+  # @return [LocalVariableTargetNode] a new instance of LocalVariableTargetNode
+  #
+  # source://prism//lib/prism/node.rb#10876
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      depth: Integer
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, depth); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#10941
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#10886
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10891
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#10901
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#10896
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer) -> LocalVariableTargetNode
+  #
+  # source://prism//lib/prism/node.rb#10906
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableTargetNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10891
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer }
+  #
+  # source://prism//lib/prism/node.rb#10914
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader depth: Integer
+  #
+  # source://prism//lib/prism/node.rb#10922
+  sig { returns(Integer) }
+  def depth; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#10925
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#10919
+  sig { returns(Symbol) }
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#10930
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#10935
+    def type; end
+  end
+end
+
+# Represents writing to a local variable.
+#
+#     foo = 1
+#     ^^^^^^^
+#
+# source://prism//lib/prism/node.rb#10952
+class Prism::LocalVariableWriteNode < ::Prism::Node
+  # Initialize a new LocalVariableWriteNode node.
+  #
+  # @return [LocalVariableWriteNode] a new instance of LocalVariableWriteNode
+  #
+  # source://prism//lib/prism/node.rb#10954
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      depth: Integer,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, depth, name_loc, value, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#11070
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#10967
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10972
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#10982
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#10977
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> LocalVariableWriteNode
+  #
+  # source://prism//lib/prism/node.rb#10987
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      depth: Integer,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::LocalVariableWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#10972
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer, name_loc: Location, value: Prism::node, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#10995
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # The number of semantic scopes we have to traverse to find the declaration of this variable.
+  #
+  #     foo = 1         # depth 0
+  #
+  #     tap { foo = 1 } # depth 1
+  #
+  # The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
+  #
+  # source://prism//lib/prism/node.rb#11013
+  sig { returns(Integer) }
+  def depth; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#11054
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+  #
+  #     foo = :bar # name `:foo`
+  #
+  #     abc = 123  # name `:abc`
+  #
+  # source://prism//lib/prism/node.rb#11004
+  sig { returns(Symbol) }
+  def name; end
+
+  # The location of the variable name.
+  #
+  #     foo = :bar
+  #     ^^^
+  #
+  # source://prism//lib/prism/node.rb#11019
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#11049
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `=` operator.
+  #
+  #     x = :y
+  #       ^
+  #
+  # source://prism//lib/prism/node.rb#11042
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#11059
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to write to the local variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     foo = :bar
+  #           ^^^^
+  #
+  #     abc = 1234
+  #           ^^^^
+  #
+  # Note that since the name of a local variable is known before the value is parsed, it is valid for a local variable to appear within the value of its own write.
+  #
+  #     foo = foo
+  #
+  # source://prism//lib/prism/node.rb#11036
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#11064
+    def type; end
+  end
+end
+
+# This represents a location in the source.
+#
+# source://prism//lib/prism/parse_result.rb#273
+class Prism::Location
+  # Create a new location object with the given source, start byte offset, and
+  # byte length.
+  #
+  # @return [Location] a new instance of Location
+  #
+  # source://prism//lib/prism/parse_result.rb#288
+  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void }
+  def initialize(source, start_offset, length); end
+
+  # Returns true if the given other location is equal to this location.
+  #
+  # source://prism//lib/prism/parse_result.rb#476
+  sig { params(other: T.untyped).returns(T::Boolean) }
+  def ==(other); end
+
+  # Join this location with the first occurrence of the string in the source
+  # that occurs after this location on the same line, and return the new
+  # location. This will raise an error if the string does not exist.
+  #
+  # source://prism//lib/prism/parse_result.rb#495
+  sig { params(string: String).returns(Prism::Location) }
+  def adjoin(string); end
+
+  # The end column in code units using the given cache to fetch or calculate
+  # the value.
+  #
+  # source://prism//lib/prism/parse_result.rb#461
+  sig do
+    params(
+      cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))
+    ).returns(Integer)
+  end
+  def cached_end_code_units_column(cache); end
+
+  # The end offset from the start of the file in code units using the given
+  # cache to fetch or calculate the value.
+  #
+  # source://prism//lib/prism/parse_result.rb#397
+  sig do
+    params(
+      cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))
+    ).returns(Integer)
+  end
+  def cached_end_code_units_offset(cache); end
+
+  # The start column in code units using the given cache to fetch or calculate
+  # the value.
+  #
+  # source://prism//lib/prism/parse_result.rb#437
+  sig do
+    params(
+      cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))
+    ).returns(Integer)
+  end
+  def cached_start_code_units_column(cache); end
+
+  # The start offset from the start of the file in code units using the given
+  # cache to fetch or calculate the value.
+  #
+  # source://prism//lib/prism/parse_result.rb#375
+  sig do
+    params(
+      cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer))
+    ).returns(Integer)
+  end
+  def cached_start_code_units_offset(cache); end
+
+  # Returns a new location that is the result of chopping off the last byte.
+  #
+  # source://prism//lib/prism/parse_result.rb#334
+  sig { returns(Prism::Location) }
+  def chop; end
+
+  # Returns all comments that are associated with this location (both leading
+  # and trailing comments).
+  #
+  # source://prism//lib/prism/parse_result.rb#324
+  sig { returns(T::Array[Prism::Comment]) }
+  def comments; end
+
+  # Create a new location object with the given options.
+  #
+  # source://prism//lib/prism/parse_result.rb#329
+  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).returns(Prism::Location) }
+  def copy(source: T.unsafe(nil), start_offset: T.unsafe(nil), length: T.unsafe(nil)); end
+
+  # Implement the hash pattern matching interface for Location.
+  #
+  # source://prism//lib/prism/parse_result.rb#466
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # The column number in characters where this location ends from the start of
+  # the line.
+  #
+  # source://prism//lib/prism/parse_result.rb#449
+  sig { returns(Integer) }
+  def end_character_column; end
+
+  # The character offset from the beginning of the source where this location
+  # ends.
+  #
+  # source://prism//lib/prism/parse_result.rb#386
+  sig { returns(Integer) }
+  def end_character_offset; end
+
+  # The column number in code units of the given encoding where this location
+  # ends from the start of the line.
+  #
+  # source://prism//lib/prism/parse_result.rb#455
+  sig { params(encoding: Encoding).returns(Integer) }
+  def end_code_units_column(encoding = T.unsafe(nil)); end
+
+  # The offset from the start of the file in code units of the given encoding.
+  #
+  # source://prism//lib/prism/parse_result.rb#391
+  sig { params(encoding: Encoding).returns(Integer) }
+  def end_code_units_offset(encoding = T.unsafe(nil)); end
+
+  # The column number in bytes where this location ends from the start of the
+  # line.
+  #
+  # source://prism//lib/prism/parse_result.rb#443
+  sig { returns(Integer) }
+  def end_column; end
+
+  # The line number where this location ends.
+  #
+  # source://prism//lib/prism/parse_result.rb#413
+  sig { returns(Integer) }
+  def end_line; end
+
+  # The byte offset from the beginning of the source where this location ends.
+  #
+  # source://prism//lib/prism/parse_result.rb#380
+  sig { returns(Integer) }
+  def end_offset; end
+
+  # Returns a string representation of this location.
+  #
+  # source://prism//lib/prism/parse_result.rb#339
+  sig { returns(String) }
+  def inspect; end
+
+  # Returns a new location that stretches from this location to the given
+  # other location. Raises an error if this location is not before the other
+  # location or if they don't share the same source.
+  #
+  # source://prism//lib/prism/parse_result.rb#485
+  sig { params(other: Prism::Location).returns(Prism::Location) }
+  def join(other); end
+
+  # Attach a comment to the leading comments of this location.
+  #
+  # source://prism//lib/prism/parse_result.rb#307
+  sig { params(comment: Prism::Comment).void }
+  def leading_comment(comment); end
+
+  # These are the comments that are associated with this location that exist
+  # before the start of this location.
+  #
+  # source://prism//lib/prism/parse_result.rb#302
+  sig { returns(T::Array[Prism::Comment]) }
+  def leading_comments; end
+
+  # The length of this location in bytes.
+  #
+  # source://prism//lib/prism/parse_result.rb#284
+  sig { returns(Integer) }
+  def length; end
+
+  # Implement the pretty print interface for Location.
+  #
+  # source://prism//lib/prism/parse_result.rb#471
+  sig { params(q: T.untyped).void }
+  def pretty_print(q); end
+
+  # The source code that this location represents.
+  #
+  # source://prism//lib/prism/parse_result.rb#349
+  sig { returns(String) }
+  def slice; end
+
+  # The source code that this location represents starting from the beginning
+  # of the line that this location starts on to the end of the line that this
+  # location ends on.
+  #
+  # source://prism//lib/prism/parse_result.rb#356
+  def slice_lines; end
+
+  # Returns all of the lines of the source code associated with this location.
+  #
+  # source://prism//lib/prism/parse_result.rb#344
+  sig { returns(T::Array[String]) }
+  def source_lines; end
+
+  # The column number in characters where this location ends from the start of
+  # the line.
+  #
+  # source://prism//lib/prism/parse_result.rb#425
+  sig { returns(Integer) }
+  def start_character_column; end
+
+  # The character offset from the beginning of the source where this location
+  # starts.
+  #
+  # source://prism//lib/prism/parse_result.rb#364
+  sig { returns(Integer) }
+  def start_character_offset; end
+
+  # The column number in code units of the given encoding where this location
+  # starts from the start of the line.
+  #
+  # source://prism//lib/prism/parse_result.rb#431
+  sig { params(encoding: Encoding).returns(Integer) }
+  def start_code_units_column(encoding = T.unsafe(nil)); end
+
+  # The offset from the start of the file in code units of the given encoding.
+  #
+  # source://prism//lib/prism/parse_result.rb#369
+  sig { params(encoding: Encoding).returns(Integer) }
+  def start_code_units_offset(encoding = T.unsafe(nil)); end
+
+  # The column number in bytes where this location starts from the start of
+  # the line.
+  #
+  # source://prism//lib/prism/parse_result.rb#419
+  sig { returns(Integer) }
+  def start_column; end
+
+  # The line number where this location starts.
+  #
+  # source://prism//lib/prism/parse_result.rb#402
+  sig { returns(Integer) }
+  def start_line; end
+
+  # The content of the line where this location starts before this location.
+  #
+  # source://prism//lib/prism/parse_result.rb#407
+  sig { returns(String) }
+  def start_line_slice; end
+
+  # The byte offset from the beginning of the source where this location
+  # starts.
+  #
+  # source://prism//lib/prism/parse_result.rb#281
+  sig { returns(Integer) }
+  def start_offset; end
+
+  # Attach a comment to the trailing comments of this location.
+  #
+  # source://prism//lib/prism/parse_result.rb#318
+  sig { params(comment: Prism::Comment).void }
+  def trailing_comment(comment); end
+
+  # These are the comments that are associated with this location that exist
+  # after the end of this location.
+  #
+  # source://prism//lib/prism/parse_result.rb#313
+  sig { returns(T::Array[Prism::Comment]) }
+  def trailing_comments; end
+
+  protected
+
+  # A Source object that is used to determine more information from the given
+  # offset and length.
+  #
+  # source://prism//lib/prism/parse_result.rb#276
+  sig { returns(Prism::Source) }
+  def source; end
+end
+
+# Flags for while and until loop nodes.
+#
+# source://prism//lib/prism/node.rb#16762
+module Prism::LoopFlags; end
+
+# a loop after a begin statement, so the body is executed first before the condition
+#
+# source://prism//lib/prism/node.rb#16764
+Prism::LoopFlags::BEGIN_MODIFIER = T.let(T.unsafe(nil), Integer)
+
+# This represents a magic comment that was encountered during parsing.
+#
+# source://prism//lib/prism/parse_result.rb#557
+class Prism::MagicComment
+  # Create a new magic comment object with the given key and value locations.
+  #
+  # @return [MagicComment] a new instance of MagicComment
+  #
+  # source://prism//lib/prism/parse_result.rb#565
+  sig { params(key_loc: Prism::Location, value_loc: Prism::Location).void }
+  def initialize(key_loc, value_loc); end
+
+  # Implement the hash pattern matching interface for MagicComment.
+  #
+  # source://prism//lib/prism/parse_result.rb#581
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # Returns a string representation of this magic comment.
+  #
+  # source://prism//lib/prism/parse_result.rb#586
+  sig { returns(String) }
+  def inspect; end
+
+  # Returns the key of the magic comment by slicing it from the source code.
+  #
+  # source://prism//lib/prism/parse_result.rb#571
+  sig { returns(String) }
+  def key; end
+
+  # A Location object representing the location of the key in the source.
+  #
+  # source://prism//lib/prism/parse_result.rb#559
+  sig { returns(Prism::Location) }
+  def key_loc; end
+
+  # Returns the value of the magic comment by slicing it from the source code.
+  #
+  # source://prism//lib/prism/parse_result.rb#576
+  sig { returns(String) }
+  def value; end
+
+  # A Location object representing the location of the value in the source.
+  #
+  # source://prism//lib/prism/parse_result.rb#562
+  sig { returns(Prism::Location) }
+  def value_loc; end
+end
+
+# Represents a regular expression literal used in the predicate of a conditional to implicitly match against the last line read by an IO object.
+#
+#     if /foo/i then end
+#        ^^^^^^
+#
+# source://prism//lib/prism/node.rb#11084
+class Prism::MatchLastLineNode < ::Prism::Node
+  include ::Prism::RegularExpressionOptions
+
+  # Initialize a new MatchLastLineNode node.
+  #
+  # @return [MatchLastLineNode] a new instance of MatchLastLineNode
+  #
+  # source://prism//lib/prism/node.rb#11086
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#11241
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#11098
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def ascii_8bit?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#11156
+  sig { returns(T::Boolean) }
+  def ascii_8bit?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11103
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#11220
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#11200
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#11113
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#11108
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def content: () -> String
+  #
+  # source://prism//lib/prism/node.rb#11215
+  sig { returns(String) }
+  def content; end
+
+  # attr_reader content_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#11193
+  sig { returns(Prism::Location) }
+  def content_loc; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> MatchLastLineNode
+  #
+  # source://prism//lib/prism/node.rb#11118
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).returns(Prism::MatchLastLineNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11103
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String }
+  #
+  # source://prism//lib/prism/node.rb#11126
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def euc_jp?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#11151
+  sig { returns(T::Boolean) }
+  def euc_jp?; end
+
+  # def extended?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#11136
+  sig { returns(T::Boolean) }
+  def extended?; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#11176
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#11181
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#11171
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def ignore_case?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#11131
+  sig { returns(T::Boolean) }
+  def ignore_case?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#11225
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def multi_line?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#11141
+  sig { returns(T::Boolean) }
+  def multi_line?; end
+
+  # def once?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#11146
+  sig { returns(T::Boolean) }
+  def once?; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#11210
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#11186
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  sig { returns(Integer) }
+  def options; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#11230
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader unescaped: String
+  #
+  # source://prism//lib/prism/node.rb#11207
+  sig { returns(String) }
+  def unescaped; end
+
+  # def utf_8?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#11166
+  sig { returns(T::Boolean) }
+  def utf_8?; end
+
+  # def windows_31j?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#11161
+  sig { returns(T::Boolean) }
+  def windows_31j?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#11235
+    def type; end
+  end
+end
+
+# Represents the use of the modifier `in` operator.
+#
+#     foo in bar
+#     ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#11255
+class Prism::MatchPredicateNode < ::Prism::Node
+  # Initialize a new MatchPredicateNode node.
+  #
+  # @return [MatchPredicateNode] a new instance of MatchPredicateNode
+  #
+  # source://prism//lib/prism/node.rb#11257
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Prism::Node,
+      pattern: Prism::Node,
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, value, pattern, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#11335
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#11268
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11273
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#11283
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#11278
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location) -> MatchPredicateNode
+  #
+  # source://prism//lib/prism/node.rb#11288
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Prism::Node,
+      pattern: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::MatchPredicateNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11273
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, pattern: Prism::node, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#11296
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#11319
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#11314
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#11307
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader pattern: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#11304
+  sig { returns(Prism::Node) }
+  def pattern; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#11324
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#11301
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#11329
+    def type; end
+  end
+end
+
+# Represents the use of the `=>` operator.
+#
+#     foo => bar
+#     ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#11347
+class Prism::MatchRequiredNode < ::Prism::Node
+  # Initialize a new MatchRequiredNode node.
+  #
+  # @return [MatchRequiredNode] a new instance of MatchRequiredNode
+  #
+  # source://prism//lib/prism/node.rb#11349
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Prism::Node,
+      pattern: Prism::Node,
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, value, pattern, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#11427
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#11360
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11365
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#11375
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#11370
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location) -> MatchRequiredNode
+  #
+  # source://prism//lib/prism/node.rb#11380
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Prism::Node,
+      pattern: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::MatchRequiredNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11365
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, pattern: Prism::node, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#11388
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#11411
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#11406
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#11399
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader pattern: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#11396
+  sig { returns(Prism::Node) }
+  def pattern; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#11416
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#11393
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#11421
+    def type; end
+  end
+end
+
+# Represents writing local variables using a regular expression match with named capture groups.
+#
+#     /(?<foo>bar)/ =~ baz
+#     ^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#11439
+class Prism::MatchWriteNode < ::Prism::Node
+  # Initialize a new MatchWriteNode node.
+  #
+  # @return [MatchWriteNode] a new instance of MatchWriteNode
+  #
+  # source://prism//lib/prism/node.rb#11441
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      call: Prism::CallNode,
+      targets: T::Array[Prism::LocalVariableTargetNode]
+    ).void
+  end
+  def initialize(source, node_id, location, flags, call, targets); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#11506
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#11451
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader call: CallNode
+  #
+  # source://prism//lib/prism/node.rb#11484
+  sig { returns(Prism::CallNode) }
+  def call; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11456
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#11466
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#11461
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?call: CallNode, ?targets: Array[LocalVariableTargetNode]) -> MatchWriteNode
+  #
+  # source://prism//lib/prism/node.rb#11471
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      call: Prism::CallNode,
+      targets: T::Array[Prism::LocalVariableTargetNode]
+    ).returns(Prism::MatchWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), call: T.unsafe(nil), targets: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11456
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, call: CallNode, targets: Array[LocalVariableTargetNode] }
+  #
+  # source://prism//lib/prism/node.rb#11479
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#11490
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader targets: Array[LocalVariableTargetNode]
+  #
+  # source://prism//lib/prism/node.rb#11487
+  sig { returns(T::Array[Prism::LocalVariableTargetNode]) }
+  def targets; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#11495
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#11500
+    def type; end
+  end
+end
+
+# Represents a node that is missing from the source and results in a syntax error.
+#
+# source://prism//lib/prism/node.rb#11515
+class Prism::MissingNode < ::Prism::Node
+  # Initialize a new MissingNode node.
+  #
+  # @return [MissingNode] a new instance of MissingNode
+  #
+  # source://prism//lib/prism/node.rb#11517
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void }
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#11574
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#11525
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11530
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#11540
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#11535
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> MissingNode
+  #
+  # source://prism//lib/prism/node.rb#11545
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::MissingNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11530
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  #
+  # source://prism//lib/prism/node.rb#11553
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#11558
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#11563
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#11568
+    def type; end
+  end
+end
+
+# Represents a module declaration involving the `module` keyword.
+#
+#     module Foo end
+#     ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#11583
+class Prism::ModuleNode < ::Prism::Node
+  # Initialize a new ModuleNode node.
+  #
+  # @return [ModuleNode] a new instance of ModuleNode
+  #
+  # source://prism//lib/prism/node.rb#11585
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      module_keyword_loc: Prism::Location,
+      constant_path: T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::MissingNode),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      end_keyword_loc: Prism::Location,
+      name: Symbol
+    ).void
+  end
+  def initialize(source, node_id, location, flags, locals, module_keyword_loc, constant_path, body, end_keyword_loc, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#11687
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#11599
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader body: StatementsNode | BeginNode | nil
+  #
+  # source://prism//lib/prism/node.rb#11648
+  sig { returns(T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11604
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#11617
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#11609
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # attr_reader constant_path: ConstantReadNode | ConstantPathNode | MissingNode
+  #
+  # source://prism//lib/prism/node.rb#11645
+  sig { returns(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::MissingNode)) }
+  def constant_path; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?module_keyword_loc: Location, ?constant_path: ConstantReadNode | ConstantPathNode | MissingNode, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location, ?name: Symbol) -> ModuleNode
+  #
+  # source://prism//lib/prism/node.rb#11622
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      module_keyword_loc: Prism::Location,
+      constant_path: T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::MissingNode),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      end_keyword_loc: Prism::Location,
+      name: Symbol
+    ).returns(Prism::ModuleNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), module_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11604
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], module_keyword_loc: Location, constant_path: ConstantReadNode | ConstantPathNode | MissingNode, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location, name: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#11630
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#11666
+  sig { returns(String) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#11651
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#11671
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[Symbol]
+  #
+  # source://prism//lib/prism/node.rb#11635
+  sig { returns(T::Array[Symbol]) }
+  def locals; end
+
+  # def module_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#11661
+  sig { returns(String) }
+  def module_keyword; end
+
+  # attr_reader module_keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#11638
+  sig { returns(Prism::Location) }
+  def module_keyword_loc; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#11658
+  sig { returns(Symbol) }
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#11676
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#11681
+    def type; end
+  end
+end
+
+# Represents a multi-target expression.
+#
+#     a, (b, c) = 1, 2, 3
+#        ^^^^^^
+#
+# This can be a part of `MultiWriteNode` as above, or the target of a `for` loop
+#
+#     for a, b in [[1, 2], [3, 4]]
+#         ^^^^
+#
+# source://prism//lib/prism/node.rb#11708
+class Prism::MultiTargetNode < ::Prism::Node
+  # Initialize a new MultiTargetNode node.
+  #
+  # @return [MultiTargetNode] a new instance of MultiTargetNode
+  #
+  # source://prism//lib/prism/node.rb#11710
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
+      rest: T.nilable(T.any(Prism::ImplicitRestNode, Prism::SplatNode)),
+      rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
+      lparen_loc: T.nilable(Prism::Location),
+      rparen_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, lefts, rest, rights, lparen_loc, rparen_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#11851
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#11723
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11728
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#11742
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#11733
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: ImplicitRestNode | SplatNode | nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?) -> MultiTargetNode
+  #
+  # source://prism//lib/prism/node.rb#11747
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
+      rest: T.nilable(T.any(Prism::ImplicitRestNode, Prism::SplatNode)),
+      rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
+      lparen_loc: T.nilable(Prism::Location),
+      rparen_loc: T.nilable(Prism::Location)
+    ).returns(Prism::MultiTargetNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11728
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], lparen_loc: Location?, rparen_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#11755
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#11835
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Represents the targets expressions before a splat node.
+  #
+  #     a, (b, c, *) = 1, 2, 3, 4, 5
+  #         ^^^^
+  #
+  # The splat node can be absent, in that case all target expressions are in the left field.
+  #
+  #     a, (b, c) = 1, 2, 3, 4, 5
+  #         ^^^^
+  #
+  # source://prism//lib/prism/node.rb#11768
+  sig do
+    returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)])
+  end
+  def lefts; end
+
+  # def lparen: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#11825
+  sig { returns(T.nilable(String)) }
+  def lparen; end
+
+  # The location of the opening parenthesis.
+  #
+  #     a, (b, c) = 1, 2, 3
+  #        ^
+  #
+  # source://prism//lib/prism/node.rb#11796
+  sig { returns(T.nilable(Prism::Location)) }
+  def lparen_loc; end
+
+  # Represents a splat node in the target expression.
+  #
+  #     a, (b, *c) = 1, 2, 3, 4
+  #            ^^
+  #
+  # The variable can be empty, this results in a `SplatNode` with a `nil` expression field.
+  #
+  #     a, (b, *) = 1, 2, 3, 4
+  #            ^
+  #
+  # If the `*` is omitted, this field will contain an `ImplicitRestNode`
+  #
+  #     a, (b,) = 1, 2, 3, 4
+  #          ^
+  #
+  # source://prism//lib/prism/node.rb#11784
+  sig { returns(T.nilable(T.any(Prism::ImplicitRestNode, Prism::SplatNode))) }
+  def rest; end
+
+  # Represents the targets expressions after a splat node.
+  #
+  #     a, (*, b, c) = 1, 2, 3, 4, 5
+  #            ^^^^
+  #
+  # source://prism//lib/prism/node.rb#11790
+  sig do
+    returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)])
+  end
+  def rights; end
+
+  # def rparen: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#11830
+  sig { returns(T.nilable(String)) }
+  def rparen; end
+
+  # The location of the closing parenthesis.
+  #
+  #     a, (b, c) = 1, 2, 3
+  #             ^
+  #
+  # source://prism//lib/prism/node.rb#11812
+  sig { returns(T.nilable(Prism::Location)) }
+  def rparen_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#11840
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#11845
+    def type; end
+  end
+end
+
+# Represents a write to a multi-target expression.
+#
+#     a, b, c = 1, 2, 3
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#11867
+class Prism::MultiWriteNode < ::Prism::Node
+  # Initialize a new MultiWriteNode node.
+  #
+  # @return [MultiWriteNode] a new instance of MultiWriteNode
+  #
+  # source://prism//lib/prism/node.rb#11869
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
+      rest: T.nilable(T.any(Prism::ImplicitRestNode, Prism::SplatNode)),
+      rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
+      lparen_loc: T.nilable(Prism::Location),
+      rparen_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#12034
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#11884
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11889
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#11904
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#11894
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: ImplicitRestNode | SplatNode | nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?, ?operator_loc: Location, ?value: Prism::node) -> MultiWriteNode
+  #
+  # source://prism//lib/prism/node.rb#11909
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
+      rest: T.nilable(T.any(Prism::ImplicitRestNode, Prism::SplatNode)),
+      rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
+      lparen_loc: T.nilable(Prism::Location),
+      rparen_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::MultiWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#11889
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#11917
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#12018
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Represents the targets expressions before a splat node.
+  #
+  #     a, b, * = 1, 2, 3, 4, 5
+  #     ^^^^
+  #
+  # The splat node can be absent, in that case all target expressions are in the left field.
+  #
+  #     a, b, c = 1, 2, 3, 4, 5
+  #     ^^^^^^^
+  #
+  # source://prism//lib/prism/node.rb#11930
+  sig do
+    returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)])
+  end
+  def lefts; end
+
+  # def lparen: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#12003
+  sig { returns(T.nilable(String)) }
+  def lparen; end
+
+  # The location of the opening parenthesis.
+  #
+  #     (a, b, c) = 1, 2, 3
+  #     ^
+  #
+  # source://prism//lib/prism/node.rb#11958
+  sig { returns(T.nilable(Prism::Location)) }
+  def lparen_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#12013
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the operator.
+  #
+  #     a, b, c = 1, 2, 3
+  #             ^
+  #
+  # source://prism//lib/prism/node.rb#11990
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Represents a splat node in the target expression.
+  #
+  #     a, b, *c = 1, 2, 3, 4
+  #           ^^
+  #
+  # The variable can be empty, this results in a `SplatNode` with a `nil` expression field.
+  #
+  #     a, b, * = 1, 2, 3, 4
+  #           ^
+  #
+  # If the `*` is omitted, this field will contain an `ImplicitRestNode`
+  #
+  #     a, b, = 1, 2, 3, 4
+  #         ^
+  #
+  # source://prism//lib/prism/node.rb#11946
+  sig { returns(T.nilable(T.any(Prism::ImplicitRestNode, Prism::SplatNode))) }
+  def rest; end
+
+  # Represents the targets expressions after a splat node.
+  #
+  #     a, *, b, c = 1, 2, 3, 4, 5
+  #           ^^^^
+  #
+  # source://prism//lib/prism/node.rb#11952
+  sig do
+    returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)])
+  end
+  def rights; end
+
+  # def rparen: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#12008
+  sig { returns(T.nilable(String)) }
+  def rparen; end
+
+  # The location of the closing parenthesis.
+  #
+  #     (a, b, c) = 1, 2, 3
+  #             ^
+  #
+  # source://prism//lib/prism/node.rb#11974
+  sig { returns(T.nilable(Prism::Location)) }
+  def rparen_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#12023
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to write to the targets. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     a, b, c = 1, 2, 3
+  #               ^^^^^^^
+  #
+  # source://prism//lib/prism/node.rb#12000
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#12028
+    def type; end
+  end
+end
+
+# This visitor walks through the tree and copies each node as it is being
+# visited. This is useful for consumers that want to mutate the tree, as you
+# can change subtrees in place without effecting the rest of the tree.
+#
+# source://prism//lib/prism/mutation_compiler.rb#13
+class Prism::MutationCompiler < ::Prism::Compiler
+  # Copy a AliasGlobalVariableNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#15
+  def visit_alias_global_variable_node(node); end
+
+  # Copy a AliasMethodNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#20
+  def visit_alias_method_node(node); end
+
+  # Copy a AlternationPatternNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#25
+  def visit_alternation_pattern_node(node); end
+
+  # Copy a AndNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#30
+  def visit_and_node(node); end
+
+  # Copy a ArgumentsNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#35
+  def visit_arguments_node(node); end
+
+  # Copy a ArrayNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#40
+  def visit_array_node(node); end
+
+  # Copy a ArrayPatternNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#45
+  def visit_array_pattern_node(node); end
+
+  # Copy a AssocNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#50
+  def visit_assoc_node(node); end
+
+  # Copy a AssocSplatNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#55
+  def visit_assoc_splat_node(node); end
+
+  # Copy a BackReferenceReadNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#60
+  def visit_back_reference_read_node(node); end
+
+  # Copy a BeginNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#65
+  def visit_begin_node(node); end
+
+  # Copy a BlockArgumentNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#70
+  def visit_block_argument_node(node); end
+
+  # Copy a BlockLocalVariableNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#75
+  def visit_block_local_variable_node(node); end
+
+  # Copy a BlockNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#80
+  def visit_block_node(node); end
+
+  # Copy a BlockParameterNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#85
+  def visit_block_parameter_node(node); end
+
+  # Copy a BlockParametersNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#90
+  def visit_block_parameters_node(node); end
+
+  # Copy a BreakNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#95
+  def visit_break_node(node); end
+
+  # Copy a CallAndWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#100
+  def visit_call_and_write_node(node); end
+
+  # Copy a CallNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#105
+  def visit_call_node(node); end
+
+  # Copy a CallOperatorWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#110
+  def visit_call_operator_write_node(node); end
+
+  # Copy a CallOrWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#115
+  def visit_call_or_write_node(node); end
+
+  # Copy a CallTargetNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#120
+  def visit_call_target_node(node); end
+
+  # Copy a CapturePatternNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#125
+  def visit_capture_pattern_node(node); end
+
+  # Copy a CaseMatchNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#130
+  def visit_case_match_node(node); end
+
+  # Copy a CaseNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#135
+  def visit_case_node(node); end
+
+  # Copy a ClassNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#140
+  def visit_class_node(node); end
+
+  # Copy a ClassVariableAndWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#145
+  def visit_class_variable_and_write_node(node); end
+
+  # Copy a ClassVariableOperatorWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#150
+  def visit_class_variable_operator_write_node(node); end
+
+  # Copy a ClassVariableOrWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#155
+  def visit_class_variable_or_write_node(node); end
+
+  # Copy a ClassVariableReadNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#160
+  def visit_class_variable_read_node(node); end
+
+  # Copy a ClassVariableTargetNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#165
+  def visit_class_variable_target_node(node); end
+
+  # Copy a ClassVariableWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#170
+  def visit_class_variable_write_node(node); end
+
+  # Copy a ConstantAndWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#175
+  def visit_constant_and_write_node(node); end
+
+  # Copy a ConstantOperatorWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#180
+  def visit_constant_operator_write_node(node); end
+
+  # Copy a ConstantOrWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#185
+  def visit_constant_or_write_node(node); end
+
+  # Copy a ConstantPathAndWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#190
+  def visit_constant_path_and_write_node(node); end
+
+  # Copy a ConstantPathNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#195
+  def visit_constant_path_node(node); end
+
+  # Copy a ConstantPathOperatorWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#200
+  def visit_constant_path_operator_write_node(node); end
+
+  # Copy a ConstantPathOrWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#205
+  def visit_constant_path_or_write_node(node); end
+
+  # Copy a ConstantPathTargetNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#210
+  def visit_constant_path_target_node(node); end
+
+  # Copy a ConstantPathWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#215
+  def visit_constant_path_write_node(node); end
+
+  # Copy a ConstantReadNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#220
+  def visit_constant_read_node(node); end
+
+  # Copy a ConstantTargetNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#225
+  def visit_constant_target_node(node); end
+
+  # Copy a ConstantWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#230
+  def visit_constant_write_node(node); end
+
+  # Copy a DefNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#235
+  def visit_def_node(node); end
+
+  # Copy a DefinedNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#240
+  def visit_defined_node(node); end
+
+  # Copy a ElseNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#245
+  def visit_else_node(node); end
+
+  # Copy a EmbeddedStatementsNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#250
+  def visit_embedded_statements_node(node); end
+
+  # Copy a EmbeddedVariableNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#255
+  def visit_embedded_variable_node(node); end
+
+  # Copy a EnsureNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#260
+  def visit_ensure_node(node); end
+
+  # Copy a FalseNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#265
+  def visit_false_node(node); end
+
+  # Copy a FindPatternNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#270
+  def visit_find_pattern_node(node); end
+
+  # Copy a FlipFlopNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#275
+  def visit_flip_flop_node(node); end
+
+  # Copy a FloatNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#280
+  def visit_float_node(node); end
+
+  # Copy a ForNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#285
+  def visit_for_node(node); end
+
+  # Copy a ForwardingArgumentsNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#290
+  def visit_forwarding_arguments_node(node); end
+
+  # Copy a ForwardingParameterNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#295
+  def visit_forwarding_parameter_node(node); end
+
+  # Copy a ForwardingSuperNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#300
+  def visit_forwarding_super_node(node); end
+
+  # Copy a GlobalVariableAndWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#305
+  def visit_global_variable_and_write_node(node); end
+
+  # Copy a GlobalVariableOperatorWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#310
+  def visit_global_variable_operator_write_node(node); end
+
+  # Copy a GlobalVariableOrWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#315
+  def visit_global_variable_or_write_node(node); end
+
+  # Copy a GlobalVariableReadNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#320
+  def visit_global_variable_read_node(node); end
+
+  # Copy a GlobalVariableTargetNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#325
+  def visit_global_variable_target_node(node); end
+
+  # Copy a GlobalVariableWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#330
+  def visit_global_variable_write_node(node); end
+
+  # Copy a HashNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#335
+  def visit_hash_node(node); end
+
+  # Copy a HashPatternNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#340
+  def visit_hash_pattern_node(node); end
+
+  # Copy a IfNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#345
+  def visit_if_node(node); end
+
+  # Copy a ImaginaryNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#350
+  def visit_imaginary_node(node); end
+
+  # Copy a ImplicitNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#355
+  def visit_implicit_node(node); end
+
+  # Copy a ImplicitRestNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#360
+  def visit_implicit_rest_node(node); end
+
+  # Copy a InNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#365
+  def visit_in_node(node); end
+
+  # Copy a IndexAndWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#370
+  def visit_index_and_write_node(node); end
+
+  # Copy a IndexOperatorWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#375
+  def visit_index_operator_write_node(node); end
+
+  # Copy a IndexOrWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#380
+  def visit_index_or_write_node(node); end
+
+  # Copy a IndexTargetNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#385
+  def visit_index_target_node(node); end
+
+  # Copy a InstanceVariableAndWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#390
+  def visit_instance_variable_and_write_node(node); end
+
+  # Copy a InstanceVariableOperatorWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#395
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Copy a InstanceVariableOrWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#400
+  def visit_instance_variable_or_write_node(node); end
+
+  # Copy a InstanceVariableReadNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#405
+  def visit_instance_variable_read_node(node); end
+
+  # Copy a InstanceVariableTargetNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#410
+  def visit_instance_variable_target_node(node); end
+
+  # Copy a InstanceVariableWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#415
+  def visit_instance_variable_write_node(node); end
+
+  # Copy a IntegerNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#420
+  def visit_integer_node(node); end
+
+  # Copy a InterpolatedMatchLastLineNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#425
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Copy a InterpolatedRegularExpressionNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#430
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Copy a InterpolatedStringNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#435
+  def visit_interpolated_string_node(node); end
+
+  # Copy a InterpolatedSymbolNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#440
+  def visit_interpolated_symbol_node(node); end
+
+  # Copy a InterpolatedXStringNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#445
+  def visit_interpolated_x_string_node(node); end
+
+  # Copy a ItLocalVariableReadNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#450
+  def visit_it_local_variable_read_node(node); end
+
+  # Copy a ItParametersNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#455
+  def visit_it_parameters_node(node); end
+
+  # Copy a KeywordHashNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#460
+  def visit_keyword_hash_node(node); end
+
+  # Copy a KeywordRestParameterNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#465
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Copy a LambdaNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#470
+  def visit_lambda_node(node); end
+
+  # Copy a LocalVariableAndWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#475
+  def visit_local_variable_and_write_node(node); end
+
+  # Copy a LocalVariableOperatorWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#480
+  def visit_local_variable_operator_write_node(node); end
+
+  # Copy a LocalVariableOrWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#485
+  def visit_local_variable_or_write_node(node); end
+
+  # Copy a LocalVariableReadNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#490
+  def visit_local_variable_read_node(node); end
+
+  # Copy a LocalVariableTargetNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#495
+  def visit_local_variable_target_node(node); end
+
+  # Copy a LocalVariableWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#500
+  def visit_local_variable_write_node(node); end
+
+  # Copy a MatchLastLineNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#505
+  def visit_match_last_line_node(node); end
+
+  # Copy a MatchPredicateNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#510
+  def visit_match_predicate_node(node); end
+
+  # Copy a MatchRequiredNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#515
+  def visit_match_required_node(node); end
+
+  # Copy a MatchWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#520
+  def visit_match_write_node(node); end
+
+  # Copy a MissingNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#525
+  def visit_missing_node(node); end
+
+  # Copy a ModuleNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#530
+  def visit_module_node(node); end
+
+  # Copy a MultiTargetNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#535
+  def visit_multi_target_node(node); end
+
+  # Copy a MultiWriteNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#540
+  def visit_multi_write_node(node); end
+
+  # Copy a NextNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#545
+  def visit_next_node(node); end
+
+  # Copy a NilNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#550
+  def visit_nil_node(node); end
+
+  # Copy a NoKeywordsParameterNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#555
+  def visit_no_keywords_parameter_node(node); end
+
+  # Copy a NumberedParametersNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#560
+  def visit_numbered_parameters_node(node); end
+
+  # Copy a NumberedReferenceReadNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#565
+  def visit_numbered_reference_read_node(node); end
+
+  # Copy a OptionalKeywordParameterNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#570
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Copy a OptionalParameterNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#575
+  def visit_optional_parameter_node(node); end
+
+  # Copy a OrNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#580
+  def visit_or_node(node); end
+
+  # Copy a ParametersNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#585
+  def visit_parameters_node(node); end
+
+  # Copy a ParenthesesNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#590
+  def visit_parentheses_node(node); end
+
+  # Copy a PinnedExpressionNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#595
+  def visit_pinned_expression_node(node); end
+
+  # Copy a PinnedVariableNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#600
+  def visit_pinned_variable_node(node); end
+
+  # Copy a PostExecutionNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#605
+  def visit_post_execution_node(node); end
+
+  # Copy a PreExecutionNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#610
+  def visit_pre_execution_node(node); end
+
+  # Copy a ProgramNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#615
+  def visit_program_node(node); end
+
+  # Copy a RangeNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#620
+  def visit_range_node(node); end
+
+  # Copy a RationalNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#625
+  def visit_rational_node(node); end
+
+  # Copy a RedoNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#630
+  def visit_redo_node(node); end
+
+  # Copy a RegularExpressionNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#635
+  def visit_regular_expression_node(node); end
+
+  # Copy a RequiredKeywordParameterNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#640
+  def visit_required_keyword_parameter_node(node); end
+
+  # Copy a RequiredParameterNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#645
+  def visit_required_parameter_node(node); end
+
+  # Copy a RescueModifierNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#650
+  def visit_rescue_modifier_node(node); end
+
+  # Copy a RescueNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#655
+  def visit_rescue_node(node); end
+
+  # Copy a RestParameterNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#660
+  def visit_rest_parameter_node(node); end
+
+  # Copy a RetryNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#665
+  def visit_retry_node(node); end
+
+  # Copy a ReturnNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#670
+  def visit_return_node(node); end
+
+  # Copy a SelfNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#675
+  def visit_self_node(node); end
+
+  # Copy a ShareableConstantNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#680
+  def visit_shareable_constant_node(node); end
+
+  # Copy a SingletonClassNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#685
+  def visit_singleton_class_node(node); end
+
+  # Copy a SourceEncodingNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#690
+  def visit_source_encoding_node(node); end
+
+  # Copy a SourceFileNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#695
+  def visit_source_file_node(node); end
+
+  # Copy a SourceLineNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#700
+  def visit_source_line_node(node); end
+
+  # Copy a SplatNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#705
+  def visit_splat_node(node); end
+
+  # Copy a StatementsNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#710
+  def visit_statements_node(node); end
+
+  # Copy a StringNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#715
+  def visit_string_node(node); end
+
+  # Copy a SuperNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#720
+  def visit_super_node(node); end
+
+  # Copy a SymbolNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#725
+  def visit_symbol_node(node); end
+
+  # Copy a TrueNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#730
+  def visit_true_node(node); end
+
+  # Copy a UndefNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#735
+  def visit_undef_node(node); end
+
+  # Copy a UnlessNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#740
+  def visit_unless_node(node); end
+
+  # Copy a UntilNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#745
+  def visit_until_node(node); end
+
+  # Copy a WhenNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#750
+  def visit_when_node(node); end
+
+  # Copy a WhileNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#755
+  def visit_while_node(node); end
+
+  # Copy a XStringNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#760
+  def visit_x_string_node(node); end
+
+  # Copy a YieldNode node
+  #
+  # source://prism//lib/prism/mutation_compiler.rb#765
+  def visit_yield_node(node); end
+end
+
+# Represents the use of the `next` keyword.
+#
+#     next 1
+#     ^^^^^^
+#
+# source://prism//lib/prism/node.rb#12052
+class Prism::NextNode < ::Prism::Node
+  # Initialize a new NextNode node.
+  #
+  # @return [NextNode] a new instance of NextNode
+  #
+  # source://prism//lib/prism/node.rb#12054
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      keyword_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, arguments, keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#12130
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#12064
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism//lib/prism/node.rb#12099
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12069
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#12081
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#12074
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: ArgumentsNode?, ?keyword_loc: Location) -> NextNode
+  #
+  # source://prism//lib/prism/node.rb#12086
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      keyword_loc: Prism::Location
+    ).returns(Prism::NextNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12069
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: ArgumentsNode?, keyword_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#12094
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#12114
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#12109
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#12102
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#12119
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#12124
+    def type; end
+  end
+end
+
+# Represents the use of the `nil` keyword.
+#
+#     nil
+#     ^^^
+#
+# source://prism//lib/prism/node.rb#12141
+class Prism::NilNode < ::Prism::Node
+  # Initialize a new NilNode node.
+  #
+  # @return [NilNode] a new instance of NilNode
+  #
+  # source://prism//lib/prism/node.rb#12143
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void }
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#12200
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#12151
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12156
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#12166
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#12161
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> NilNode
+  #
+  # source://prism//lib/prism/node.rb#12171
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::NilNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12156
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  #
+  # source://prism//lib/prism/node.rb#12179
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#12184
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#12189
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#12194
+    def type; end
+  end
+end
+
+# Represents the use of `**nil` inside method arguments.
+#
+#     def a(**nil)
+#           ^^^^^
+#     end
+#
+# source://prism//lib/prism/node.rb#12210
+class Prism::NoKeywordsParameterNode < ::Prism::Node
+  # Initialize a new NoKeywordsParameterNode node.
+  #
+  # @return [NoKeywordsParameterNode] a new instance of NoKeywordsParameterNode
+  #
+  # source://prism//lib/prism/node.rb#12212
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      operator_loc: Prism::Location,
+      keyword_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, operator_loc, keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#12295
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#12222
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12227
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#12237
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#12232
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?keyword_loc: Location) -> NoKeywordsParameterNode
+  #
+  # source://prism//lib/prism/node.rb#12242
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      operator_loc: Prism::Location,
+      keyword_loc: Prism::Location
+    ).returns(Prism::NoKeywordsParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12227
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, keyword_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#12250
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#12279
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#12274
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#12262
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#12269
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#12255
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#12284
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#12289
+    def type; end
+  end
+end
+
+# This represents a node in the tree. It is the parent class of all of the
+# various node types.
+#
+# source://prism//lib/prism/node.rb#12
+class Prism::Node
+  abstract!
+
+  # Accepts a visitor and calls back into the specialized visit function.
+  #
+  # @raise [NoMethodError]
+  #
+  # source://prism//lib/prism/node.rb#169
+  sig { abstract.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # Returns the first node that matches the given block when visited in a
+  # depth-first search. This is useful for finding a node that matches a
+  # particular condition.
+  #
+  #     node.breadth_first_search { |node| node.node_id == node_id }
+  #
+  # source://prism//lib/prism/node.rb#139
+  sig { params(block: T.proc.params(node: Prism::Node).returns(T::Boolean)).returns(T.nilable(Prism::Node)) }
+  def breadth_first_search(&block); end
+
+  # Returns an array of child nodes, including `nil`s in the place of optional
+  # nodes that were not present.
+  #
+  # @raise [NoMethodError]
+  #
+  # source://prism//lib/prism/node.rb#175
+  sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # Returns an array of child nodes and locations that could potentially have
+  # comments attached to them.
+  #
+  # @raise [NoMethodError]
+  #
+  # source://prism//lib/prism/node.rb#189
+  sig { abstract.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # Returns an array of child nodes, excluding any `nil`s in the place of
+  # optional nodes that were not present.
+  #
+  # @raise [NoMethodError]
+  #
+  # source://prism//lib/prism/node.rb#183
+  sig { abstract.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # Returns an array of child nodes, including `nil`s in the place of optional
+  # nodes that were not present.
+  #
+  # @raise [NoMethodError]
+  #
+  # source://prism//lib/prism/node.rb#175
+  sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # source://prism//lib/prism/node_ext.rb#7
+  def deprecated(*replacements); end
+
+  # The end offset of the node in the source. This method is effectively a
+  # delegate method to the location object.
+  #
+  # source://prism//lib/prism/node.rb#40
+  sig { returns(Integer) }
+  def end_offset; end
+
+  sig { abstract.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # Returns a string representation of the node.
+  #
+  # @raise [NoMethodError]
+  #
+  # source://prism//lib/prism/node.rb#194
+  sig { abstract.returns(String) }
+  def inspect; end
+
+  # A Location instance that represents the location of this node in the
+  # source.
+  #
+  # source://prism//lib/prism/node.rb#25
+  sig { returns(Prism::Location) }
+  def location; end
+
+  # Returns true if the node has the newline flag set.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#72
+  sig { returns(T::Boolean) }
+  def newline?; end
+
+  # source://prism//lib/prism/parse_result/newlines.rb#69
+  def newline_flag!(lines); end
+
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/parse_result/newlines.rb#65
+  def newline_flag?; end
+
+  # A unique identifier for this node. This is used in a very specific
+  # use case where you want to keep around a reference to a node without
+  # having to keep around the syntax tree in memory. This unique identifier
+  # will be consistent across multiple parses of the same source code.
+  #
+  # source://prism//lib/prism/node.rb#21
+  sig { returns(Integer) }
+  def node_id; end
+
+  # Similar to inspect, but respects the current level of indentation given by
+  # the pretty print object.
+  #
+  # source://prism//lib/prism/node.rb#83
+  sig { params(q: T.untyped).void }
+  def pretty_print(q); end
+
+  # Returns all of the lines of the source code associated with this node.
+  # An alias for source_lines, used to mimic the API from
+  # RubyVM::AbstractSyntaxTree to make it easier to migrate.
+  #
+  # source://prism//lib/prism/node.rb#46
+  sig { returns(T::Array[String]) }
+  def script_lines; end
+
+  # Slice the location of the node from the source.
+  #
+  # source://prism//lib/prism/node.rb#55
+  sig { returns(String) }
+  def slice; end
+
+  # Slice the location of the node from the source, starting at the beginning
+  # of the line that the location starts on, ending at the end of the line
+  # that the location ends on.
+  #
+  # source://prism//lib/prism/node.rb#62
+  sig { returns(String) }
+  def slice_lines; end
+
+  # Returns all of the lines of the source code associated with this node.
+  #
+  # source://prism//lib/prism/node.rb#46
+  sig { returns(T::Array[String]) }
+  def source_lines; end
+
+  # The start offset of the node in the source. This method is effectively a
+  # delegate method to the location object.
+  #
+  # source://prism//lib/prism/node.rb#33
+  sig { returns(Integer) }
+  def start_offset; end
+
+  # Returns true if the node has the static literal flag set.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#77
+  sig { returns(T::Boolean) }
+  def static_literal?; end
+
+  # Convert this node into a graphviz dot graph string.
+  #
+  # source://prism//lib/prism/node.rb#91
+  sig { returns(String) }
+  def to_dot; end
+
+  # Returns a list of nodes that are descendants of this node that contain the
+  # given line and column. This is useful for locating a node that is selected
+  # based on the line and column of the source code.
+  #
+  # Important to note is that the column given to this method should be in
+  # bytes, as opposed to characters or code units.
+  #
+  # source://prism//lib/prism/node.rb#102
+  sig { params(line: Integer, column: Integer).returns(T::Array[Prism::Node]) }
+  def tunnel(line, column); end
+
+  # Sometimes you want to check an instance of a node against a list of
+  # classes to see what kind of behavior to perform. Usually this is done by
+  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+  # case statement and doing `case node; when cls1; when cls2; end`. Both of
+  # these approaches are relatively slow because of the constant lookups,
+  # method calls, and/or array allocations.
+  #
+  # Instead, you can call #type, which will return to you a symbol that you
+  # can use for comparison. This is faster than the other approaches because
+  # it uses a single integer comparison, but also because if you're on CRuby
+  # you can take advantage of the fact that case statements with all symbol
+  # keys will use a jump table.
+  #
+  # @raise [NoMethodError]
+  #
+  # source://prism//lib/prism/node.rb#210
+  sig { abstract.returns(Symbol) }
+  def type; end
+
+  protected
+
+  # An bitset of flags for this node. There are certain flags that are common
+  # for all nodes, and then some nodes have specific flags.
+  #
+  # source://prism//lib/prism/node.rb#68
+  sig { returns(Integer) }
+  def flags; end
+
+  private
+
+  # A pointer to the source that this node was created from.
+  #
+  # source://prism//lib/prism/node.rb#14
+  sig { returns(Prism::Source) }
+  def source; end
+
+  class << self
+    # Returns a list of the fields that exist for this node class. Fields
+    # describe the structure of the node. This kind of reflection is useful for
+    # things like recursively visiting each node _and_ field in the tree.
+    #
+    # @raise [NoMethodError]
+    #
+    # source://prism//lib/prism/node.rb#153
+    def fields; end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # @raise [NoMethodError]
+    #
+    # source://prism//lib/prism/node.rb#218
+    def type; end
+  end
+end
+
+# The flags that are common to all nodes.
+#
+# source://prism//lib/prism/node.rb#16855
+module Prism::NodeFlags; end
+
+# A flag to indicate that the node is a candidate to emit a :line event
+# through tracepoint when compiled.
+#
+# source://prism//lib/prism/node.rb#16858
+Prism::NodeFlags::NEWLINE = T.let(T.unsafe(nil), Integer)
+
+# A flag to indicate that the value that the node represents is a value that
+# can be determined at parse-time.
+#
+# source://prism//lib/prism/node.rb#16862
+Prism::NodeFlags::STATIC_LITERAL = T.let(T.unsafe(nil), Integer)
+
+# Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
+#
+#     -> { _1 + _2 }
+#     ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#12306
+class Prism::NumberedParametersNode < ::Prism::Node
+  # Initialize a new NumberedParametersNode node.
+  #
+  # @return [NumberedParametersNode] a new instance of NumberedParametersNode
+  #
+  # source://prism//lib/prism/node.rb#12308
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      maximum: Integer
+    ).void
+  end
+  def initialize(source, node_id, location, flags, maximum); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#12369
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#12317
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12322
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#12332
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#12327
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?maximum: Integer) -> NumberedParametersNode
+  #
+  # source://prism//lib/prism/node.rb#12337
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      maximum: Integer
+    ).returns(Prism::NumberedParametersNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), maximum: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12322
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, maximum: Integer }
+  #
+  # source://prism//lib/prism/node.rb#12345
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#12353
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader maximum: Integer
+  #
+  # source://prism//lib/prism/node.rb#12350
+  sig { returns(Integer) }
+  def maximum; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#12358
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#12363
+    def type; end
+  end
+end
+
+# Represents reading a numbered reference to a capture in the previous match.
+#
+#     $1
+#     ^^
+#
+# source://prism//lib/prism/node.rb#12379
+class Prism::NumberedReferenceReadNode < ::Prism::Node
+  # Initialize a new NumberedReferenceReadNode node.
+  #
+  # @return [NumberedReferenceReadNode] a new instance of NumberedReferenceReadNode
+  #
+  # source://prism//lib/prism/node.rb#12381
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      number: Integer
+    ).void
+  end
+  def initialize(source, node_id, location, flags, number); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#12448
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#12390
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12395
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#12405
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#12400
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?number: Integer) -> NumberedReferenceReadNode
+  #
+  # source://prism//lib/prism/node.rb#12410
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      number: Integer
+    ).returns(Prism::NumberedReferenceReadNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), number: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12395
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, number: Integer }
+  #
+  # source://prism//lib/prism/node.rb#12418
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#12432
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The (1-indexed, from the left) number of the capture group. Numbered references that are too large result in this value being `0`.
+  #
+  #     $1          # number `1`
+  #
+  #     $5432       # number `5432`
+  #
+  #     $4294967296 # number `0`
+  #
+  # source://prism//lib/prism/node.rb#12429
+  sig { returns(Integer) }
+  def number; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#12437
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#12442
+    def type; end
+  end
+end
+
+# Represents an optional keyword parameter to a method, block, or lambda definition.
+#
+#     def a(b: 1)
+#           ^^^^
+#     end
+#
+# source://prism//lib/prism/node.rb#12459
+class Prism::OptionalKeywordParameterNode < ::Prism::Node
+  # Initialize a new OptionalKeywordParameterNode node.
+  #
+  # @return [OptionalKeywordParameterNode] a new instance of OptionalKeywordParameterNode
+  #
+  # source://prism//lib/prism/node.rb#12461
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#12539
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#12472
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12477
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#12487
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#12482
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node) -> OptionalKeywordParameterNode
+  #
+  # source://prism//lib/prism/node.rb#12492
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::OptionalKeywordParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12477
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#12500
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#12523
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#12510
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#12513
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#12505
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#12528
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#12520
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#12533
+    def type; end
+  end
+end
+
+# Represents an optional parameter to a method, block, or lambda definition.
+#
+#     def a(b = 1)
+#           ^^^^^
+#     end
+#
+# source://prism//lib/prism/node.rb#12553
+class Prism::OptionalParameterNode < ::Prism::Node
+  # Initialize a new OptionalParameterNode node.
+  #
+  # @return [OptionalParameterNode] a new instance of OptionalParameterNode
+  #
+  # source://prism//lib/prism/node.rb#12555
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#12646
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#12567
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12572
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#12582
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#12577
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> OptionalParameterNode
+  #
+  # source://prism//lib/prism/node.rb#12587
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::OptionalParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12572
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#12595
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#12630
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#12605
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#12608
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#12625
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#12615
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#12600
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#12635
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#12622
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#12640
+    def type; end
+  end
+end
+
+# Represents the use of the `||` operator or the `or` keyword.
+#
+#     left or right
+#     ^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#12660
+class Prism::OrNode < ::Prism::Node
+  # Initialize a new OrNode node.
+  #
+  # @return [OrNode] a new instance of OrNode
+  #
+  # source://prism//lib/prism/node.rb#12662
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: Prism::Node,
+      right: Prism::Node,
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, left, right, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#12755
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#12673
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12678
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#12688
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#12683
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> OrNode
+  #
+  # source://prism//lib/prism/node.rb#12693
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: Prism::Node,
+      right: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::OrNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12678
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#12701
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#12739
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     left or right
+  #     ^^^^
+  #
+  #     1 || 2
+  #     ^
+  #
+  # source://prism//lib/prism/node.rb#12712
+  sig { returns(Prism::Node) }
+  def left; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#12734
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `or` keyword or the `||` operator.
+  #
+  #     left or right
+  #          ^^
+  #
+  # source://prism//lib/prism/node.rb#12727
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Represents the right side of the expression.
+  #
+  #     left || right
+  #             ^^^^^
+  #
+  #     1 or 2
+  #          ^
+  #
+  # source://prism//lib/prism/node.rb#12721
+  sig { returns(Prism::Node) }
+  def right; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#12744
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#12749
+    def type; end
+  end
+end
+
+# A parser for the pack template language.
+#
+# source://prism//lib/prism/pack.rb#6
+module Prism::Pack
+  class << self
+    def parse(_arg0, _arg1, _arg2); end
+  end
+end
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::AGNOSTIC_ENDIAN = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::BACK = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::BER = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::BIG_ENDIAN = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::COMMENT = T.let(T.unsafe(nil), Symbol)
+
+# A directive in the pack template language.
+#
+# source://prism//lib/prism/pack.rb#60
+class Prism::Pack::Directive
+  # Initialize a new directive with the given values.
+  #
+  # @return [Directive] a new instance of Directive
+  #
+  # source://prism//lib/prism/pack.rb#89
+  def initialize(version, variant, source, type, signed, endian, size, length_type, length); end
+
+  # Provide a human-readable description of the directive.
+  #
+  # source://prism//lib/prism/pack.rb#131
+  def describe; end
+
+  # The type of endianness of the directive.
+  #
+  # source://prism//lib/prism/pack.rb#77
+  def endian; end
+
+  # The length of this directive (used for integers).
+  #
+  # source://prism//lib/prism/pack.rb#86
+  def length; end
+
+  # The length type of this directive (used for integers).
+  #
+  # source://prism//lib/prism/pack.rb#83
+  def length_type; end
+
+  # The type of signedness of the directive.
+  #
+  # source://prism//lib/prism/pack.rb#74
+  def signed; end
+
+  # The size of the directive.
+  #
+  # source://prism//lib/prism/pack.rb#80
+  def size; end
+
+  # A byteslice of the source string that this directive represents.
+  #
+  # source://prism//lib/prism/pack.rb#68
+  def source; end
+
+  # The type of the directive.
+  #
+  # source://prism//lib/prism/pack.rb#71
+  def type; end
+
+  # A symbol representing whether or not we are packing or unpacking.
+  #
+  # source://prism//lib/prism/pack.rb#65
+  def variant; end
+
+  # A symbol representing the version of Ruby.
+  #
+  # source://prism//lib/prism/pack.rb#62
+  def version; end
+end
+
+# The descriptions of the various types of endianness.
+#
+# source://prism//lib/prism/pack.rb#102
+Prism::Pack::Directive::ENDIAN_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
+
+# The descriptions of the various types of signedness.
+#
+# source://prism//lib/prism/pack.rb#111
+Prism::Pack::Directive::SIGNED_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
+
+# The descriptions of the various types of sizes.
+#
+# source://prism//lib/prism/pack.rb#118
+Prism::Pack::Directive::SIZE_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::ENDIAN_NA = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::FLOAT = T.let(T.unsafe(nil), Symbol)
+
+# The result of parsing a pack template.
+#
+# source://prism//lib/prism/pack.rb#198
+class Prism::Pack::Format
+  # Create a new Format with the given directives and encoding.
+  #
+  # @return [Format] a new instance of Format
+  #
+  # source://prism//lib/prism/pack.rb#206
+  def initialize(directives, encoding); end
+
+  # Provide a human-readable description of the format.
+  #
+  # source://prism//lib/prism/pack.rb#212
+  def describe; end
+
+  # A list of the directives in the template.
+  #
+  # source://prism//lib/prism/pack.rb#200
+  def directives; end
+
+  # The encoding of the template.
+  #
+  # source://prism//lib/prism/pack.rb#203
+  def encoding; end
+end
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::INTEGER = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::LENGTH_FIXED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::LENGTH_MAX = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::LENGTH_NA = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::LENGTH_RELATIVE = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::LITTLE_ENDIAN = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::MOVE = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::NATIVE_ENDIAN = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::NULL = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::SIGNED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::SIGNED_NA = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::SIZE_16 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::SIZE_32 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::SIZE_64 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::SIZE_8 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::SIZE_INT = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::SIZE_LONG = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::SIZE_LONG_LONG = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::SIZE_NA = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::SIZE_P = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::SIZE_SHORT = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::SPACE = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::STRING_BASE64 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::STRING_FIXED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::STRING_HEX_HIGH = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::STRING_HEX_LOW = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::STRING_LSB = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::STRING_MIME = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::STRING_MSB = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::STRING_NULL_PADDED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::STRING_NULL_TERMINATED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::STRING_POINTER = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::STRING_SPACE_PADDED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::STRING_UU = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::UNSIGNED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#56
+Prism::Pack::UTF8 = T.let(T.unsafe(nil), Symbol)
+
+# Flags for parameter nodes.
+#
+# source://prism//lib/prism/node.rb#16768
+module Prism::ParameterFlags; end
+
+# a parameter name that has been repeated in the method signature
+#
+# source://prism//lib/prism/node.rb#16770
+Prism::ParameterFlags::REPEATED_PARAMETER = T.let(T.unsafe(nil), Integer)
+
+# Represents the list of parameters on a method, block, or lambda definition.
+#
+#     def a(b, c, d)
+#           ^^^^^^^
+#     end
+#
+# source://prism//lib/prism/node.rb#12768
+class Prism::ParametersNode < ::Prism::Node
+  # Initialize a new ParametersNode node.
+  #
+  # @return [ParametersNode] a new instance of ParametersNode
+  #
+  # source://prism//lib/prism/node.rb#12770
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      requireds: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)],
+      optionals: T::Array[Prism::OptionalParameterNode],
+      rest: T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode)),
+      posts: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)],
+      keywords: T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)],
+      keyword_rest: T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)),
+      block: T.nilable(Prism::BlockParameterNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, requireds, optionals, rest, posts, keywords, keyword_rest, block); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#12863
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#12785
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader block: BlockParameterNode?
+  #
+  # source://prism//lib/prism/node.rb#12844
+  sig { returns(T.nilable(Prism::BlockParameterNode)) }
+  def block; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12790
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#12808
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#12795
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?requireds: Array[RequiredParameterNode | MultiTargetNode], ?optionals: Array[OptionalParameterNode], ?rest: RestParameterNode | ImplicitRestNode | nil, ?posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], ?keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], ?keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, ?block: BlockParameterNode?) -> ParametersNode
+  #
+  # source://prism//lib/prism/node.rb#12813
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      requireds: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)],
+      optionals: T::Array[Prism::OptionalParameterNode],
+      rest: T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode)),
+      posts: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)],
+      keywords: T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)],
+      keyword_rest: T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)),
+      block: T.nilable(Prism::BlockParameterNode)
+    ).returns(Prism::ParametersNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), requireds: T.unsafe(nil), optionals: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), keywords: T.unsafe(nil), keyword_rest: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12790
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, requireds: Array[RequiredParameterNode | MultiTargetNode], optionals: Array[OptionalParameterNode], rest: RestParameterNode | ImplicitRestNode | nil, posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, block: BlockParameterNode? }
+  #
+  # source://prism//lib/prism/node.rb#12821
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#12847
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil
+  #
+  # source://prism//lib/prism/node.rb#12841
+  sig do
+    returns(T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)))
+  end
+  def keyword_rest; end
+
+  # attr_reader keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode]
+  #
+  # source://prism//lib/prism/node.rb#12838
+  sig { returns(T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)]) }
+  def keywords; end
+
+  # attr_reader optionals: Array[OptionalParameterNode]
+  #
+  # source://prism//lib/prism/node.rb#12829
+  sig { returns(T::Array[Prism::OptionalParameterNode]) }
+  def optionals; end
+
+  # attr_reader posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode]
+  #
+  # source://prism//lib/prism/node.rb#12835
+  sig do
+    returns(T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)])
+  end
+  def posts; end
+
+  # attr_reader requireds: Array[RequiredParameterNode | MultiTargetNode]
+  #
+  # source://prism//lib/prism/node.rb#12826
+  sig { returns(T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)]) }
+  def requireds; end
+
+  # attr_reader rest: RestParameterNode | ImplicitRestNode | nil
+  #
+  # source://prism//lib/prism/node.rb#12832
+  sig { returns(T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode))) }
+  def rest; end
+
+  # Mirrors the Method#parameters method.
+  #
+  # source://prism//lib/prism/node_ext.rb#269
+  sig { returns(T::Array[T.any([Symbol, Symbol], [Symbol])]) }
+  def signature; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#12852
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#12857
+    def type; end
+  end
+end
+
+# Represents a parenthesized expression
+#
+#     (10 + 34)
+#     ^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#12883
+class Prism::ParenthesesNode < ::Prism::Node
+  # Initialize a new ParenthesesNode node.
+  #
+  # @return [ParenthesesNode] a new instance of ParenthesesNode
+  #
+  # source://prism//lib/prism/node.rb#12885
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      body: T.nilable(Prism::Node),
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, body, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#12974
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#12896
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader body: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#12931
+  sig { returns(T.nilable(Prism::Node)) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12901
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#12953
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#12941
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#12913
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#12906
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?body: Prism::node?, ?opening_loc: Location, ?closing_loc: Location) -> ParenthesesNode
+  #
+  # source://prism//lib/prism/node.rb#12918
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      body: T.nilable(Prism::Node),
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).returns(Prism::ParenthesesNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#12901
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, body: Prism::node?, opening_loc: Location, closing_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#12926
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#12958
+  sig { override.returns(String) }
+  def inspect; end
+
+  # source://prism//lib/prism/parse_result/newlines.rb#85
+  def newline_flag!(lines); end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#12948
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#12934
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#12963
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#12968
+    def type; end
+  end
+end
+
+# This represents an error that was encountered during parsing.
+#
+# source://prism//lib/prism/parse_result.rb#592
+class Prism::ParseError
+  # Create a new error object with the given message and location.
+  #
+  # @return [ParseError] a new instance of ParseError
+  #
+  # source://prism//lib/prism/parse_result.rb#607
+  sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
+  def initialize(type, message, location, level); end
+
+  # Implement the hash pattern matching interface for ParseError.
+  #
+  # source://prism//lib/prism/parse_result.rb#615
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # Returns a string representation of this error.
+  #
+  # source://prism//lib/prism/parse_result.rb#620
+  sig { returns(String) }
+  def inspect; end
+
+  # The level of this error.
+  #
+  # source://prism//lib/prism/parse_result.rb#604
+  sig { returns(Symbol) }
+  def level; end
+
+  # A Location object representing the location of this error in the source.
+  #
+  # source://prism//lib/prism/parse_result.rb#601
+  sig { returns(Prism::Location) }
+  def location; end
+
+  # The message associated with this error.
+  #
+  # source://prism//lib/prism/parse_result.rb#598
+  sig { returns(String) }
+  def message; end
+
+  # The type of error. This is an _internal_ symbol that is used for
+  # communicating with translation layers. It is not meant to be public API.
+  #
+  # source://prism//lib/prism/parse_result.rb#595
+  sig { returns(Symbol) }
+  def type; end
+end
+
+# This is a result specific to the `parse_lex` and `parse_lex_file` methods.
+#
+# source://prism//lib/prism/parse_result.rb#781
+class Prism::ParseLexResult < ::Prism::Result
+  # Create a new parse lex result object with the given values.
+  #
+  # @return [ParseLexResult] a new instance of ParseLexResult
+  #
+  # source://prism//lib/prism/parse_result.rb#787
+  sig do
+    params(
+      value: [Prism::ProgramNode, T::Array[T.untyped]],
+      comments: T::Array[Prism::Comment],
+      magic_comments: T::Array[Prism::MagicComment],
+      data_loc: T.nilable(Prism::Location),
+      errors: T::Array[Prism::ParseError],
+      warnings: T::Array[Prism::ParseWarning],
+      source: Prism::Source
+    ).void
+  end
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  # Implement the hash pattern matching interface for ParseLexResult.
+  #
+  # source://prism//lib/prism/parse_result.rb#793
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # A tuple of the syntax tree and the list of tokens that were parsed from
+  # the source code.
+  #
+  # source://prism//lib/prism/parse_result.rb#784
+  sig { returns([Prism::ProgramNode, T::Array[T.untyped]]) }
+  def value; end
+end
+
+# This is a result specific to the `parse` and `parse_file` methods.
+#
+# source://prism//lib/prism/parse_result.rb#722
+class Prism::ParseResult < ::Prism::Result
+  # Create a new parse result object with the given values.
+  #
+  # @return [ParseResult] a new instance of ParseResult
+  #
+  # source://prism//lib/prism/parse_result.rb#735
+  sig do
+    params(
+      value: Prism::ProgramNode,
+      comments: T::Array[Prism::Comment],
+      magic_comments: T::Array[Prism::MagicComment],
+      data_loc: T.nilable(Prism::Location),
+      errors: T::Array[Prism::ParseError],
+      warnings: T::Array[Prism::ParseWarning],
+      source: Prism::Source
+    ).void
+  end
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  # Attach the list of comments to their respective locations in the tree.
+  #
+  # source://prism//lib/prism/parse_result.rb#746
+  def attach_comments!; end
+
+  # Implement the hash pattern matching interface for ParseResult.
+  #
+  # source://prism//lib/prism/parse_result.rb#741
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # Returns a string representation of the syntax tree with the errors
+  # displayed inline.
+  #
+  # source://prism//lib/prism/parse_result.rb#758
+  def errors_format; end
+
+  # Walk the tree and mark nodes that are on a new line, loosely emulating
+  # the behavior of CRuby's `:line` tracepoint event.
+  #
+  # source://prism//lib/prism/parse_result.rb#752
+  def mark_newlines!; end
+
+  # The syntax tree that was parsed from the source code.
+  #
+  # source://prism//lib/prism/parse_result.rb#732
+  sig { returns(Prism::ProgramNode) }
+  def value; end
+end
+
+# When we've parsed the source, we have both the syntax tree and the list of
+# comments that we found in the source. This class is responsible for
+# walking the tree and finding the nearest location to attach each comment.
+#
+# It does this by first finding the nearest locations to each comment.
+# Locations can either come from nodes directly or from location fields on
+# nodes. For example, a `ClassNode` has an overall location encompassing the
+# entire class, but it also has a location for the `class` keyword.
+#
+# Once the nearest locations are found, it determines which one to attach
+# to. If it's a trailing comment (a comment on the same line as other source
+# code), it will favor attaching to the nearest location that occurs before
+# the comment. Otherwise it will favor attaching to the nearest location
+# that is after the comment.
+#
+# source://prism//lib/prism/parse_result/comments.rb#19
+class Prism::ParseResult::Comments
+  # Create a new Comments object that will attach comments to the given
+  # parse result.
+  #
+  # @return [Comments] a new instance of Comments
+  #
+  # source://prism//lib/prism/parse_result/comments.rb#86
+  def initialize(parse_result); end
+
+  # Attach the comments to their respective locations in the tree by
+  # mutating the parse result.
+  #
+  # source://prism//lib/prism/parse_result/comments.rb#92
+  def attach!; end
+
+  # The parse result that we are attaching comments to.
+  #
+  # source://prism//lib/prism/parse_result/comments.rb#82
+  def parse_result; end
+
+  private
+
+  # Responsible for finding the nearest targets to the given comment within
+  # the context of the given encapsulating node.
+  #
+  # source://prism//lib/prism/parse_result/comments.rb#119
+  def nearest_targets(node, comment); end
+end
+
+# A target for attaching comments that is based on a location field on a
+# node. For example, the `end` token of a ClassNode.
+#
+# source://prism//lib/prism/parse_result/comments.rb#53
+class Prism::ParseResult::Comments::LocationTarget
+  # @return [LocationTarget] a new instance of LocationTarget
+  #
+  # source://prism//lib/prism/parse_result/comments.rb#56
+  def initialize(location); end
+
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/parse_result/comments.rb#68
+  def encloses?(comment); end
+
+  # source://prism//lib/prism/parse_result/comments.rb#64
+  def end_offset; end
+
+  # source://prism//lib/prism/parse_result/comments.rb#72
+  def leading_comment(comment); end
+
+  # source://prism//lib/prism/parse_result/comments.rb#54
+  def location; end
+
+  # source://prism//lib/prism/parse_result/comments.rb#60
+  def start_offset; end
+
+  # source://prism//lib/prism/parse_result/comments.rb#76
+  def trailing_comment(comment); end
+end
+
+# A target for attaching comments that is based on a specific node's
+# location.
+#
+# source://prism//lib/prism/parse_result/comments.rb#22
+class Prism::ParseResult::Comments::NodeTarget
+  # @return [NodeTarget] a new instance of NodeTarget
+  #
+  # source://prism//lib/prism/parse_result/comments.rb#25
+  def initialize(node); end
+
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/parse_result/comments.rb#37
+  def encloses?(comment); end
+
+  # source://prism//lib/prism/parse_result/comments.rb#33
+  def end_offset; end
+
+  # source://prism//lib/prism/parse_result/comments.rb#42
+  def leading_comment(comment); end
+
+  # source://prism//lib/prism/parse_result/comments.rb#23
+  def node; end
+
+  # source://prism//lib/prism/parse_result/comments.rb#29
+  def start_offset; end
+
+  # source://prism//lib/prism/parse_result/comments.rb#46
+  def trailing_comment(comment); end
+end
+
+# An object to represent the set of errors on a parse result. This object
+# can be used to format the errors in a human-readable way.
+#
+# source://prism//lib/prism/parse_result/errors.rb#9
+class Prism::ParseResult::Errors
+  # Initialize a new set of errors from the given parse result.
+  #
+  # @return [Errors] a new instance of Errors
+  #
+  # source://prism//lib/prism/parse_result/errors.rb#14
+  def initialize(parse_result); end
+
+  # Formats the errors in a human-readable way and return them as a string.
+  #
+  # source://prism//lib/prism/parse_result/errors.rb#19
+  def format; end
+
+  # The parse result that contains the errors.
+  #
+  # source://prism//lib/prism/parse_result/errors.rb#11
+  def parse_result; end
+end
+
+# The :line tracepoint event gets fired whenever the Ruby VM encounters an
+# expression on a new line. The types of expressions that can trigger this
+# event are:
+#
+# * if statements
+# * unless statements
+# * nodes that are children of statements lists
+#
+# In order to keep track of the newlines, we have a list of offsets that
+# come back from the parser. We assign these offsets to the first nodes that
+# we find in the tree that are on those lines.
+#
+# Note that the logic in this file should be kept in sync with the Java
+# MarkNewlinesVisitor, since that visitor is responsible for marking the
+# newlines for JRuby/TruffleRuby.
+#
+# This file is autoloaded only when `mark_newlines!` is called, so the
+# re-opening of the various nodes in this file will only be performed in
+# that case. We do that to avoid storing the extra `@newline` instance
+# variable on every node if we don't need it.
+#
+# source://prism//lib/prism/parse_result/newlines.rb#25
+class Prism::ParseResult::Newlines < ::Prism::Visitor
+  # Create a new Newlines visitor with the given newline offsets.
+  #
+  # @return [Newlines] a new instance of Newlines
+  #
+  # source://prism//lib/prism/parse_result/newlines.rb#27
+  def initialize(lines); end
+
+  # Permit block/lambda nodes to mark newlines within themselves.
+  #
+  # source://prism//lib/prism/parse_result/newlines.rb#33
+  def visit_block_node(node); end
+
+  # Mark if/unless nodes as newlines.
+  #
+  # source://prism//lib/prism/parse_result/newlines.rb#47
+  def visit_if_node(node); end
+
+  # Permit block/lambda nodes to mark newlines within themselves.
+  #
+  # source://prism//lib/prism/parse_result/newlines.rb#33
+  def visit_lambda_node(node); end
+
+  # Permit statements lists to mark newlines within themselves.
+  #
+  # source://prism//lib/prism/parse_result/newlines.rb#55
+  def visit_statements_node(node); end
+
+  # Mark if/unless nodes as newlines.
+  #
+  # source://prism//lib/prism/parse_result/newlines.rb#47
+  def visit_unless_node(node); end
+end
+
+# This represents a warning that was encountered during parsing.
+#
+# source://prism//lib/prism/parse_result.rb#626
+class Prism::ParseWarning
+  # Create a new warning object with the given message and location.
+  #
+  # @return [ParseWarning] a new instance of ParseWarning
+  #
+  # source://prism//lib/prism/parse_result.rb#641
+  sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
+  def initialize(type, message, location, level); end
+
+  # Implement the hash pattern matching interface for ParseWarning.
+  #
+  # source://prism//lib/prism/parse_result.rb#649
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # Returns a string representation of this warning.
+  #
+  # source://prism//lib/prism/parse_result.rb#654
+  sig { returns(String) }
+  def inspect; end
+
+  # The level of this warning.
+  #
+  # source://prism//lib/prism/parse_result.rb#638
+  sig { returns(Symbol) }
+  def level; end
+
+  # A Location object representing the location of this warning in the source.
+  #
+  # source://prism//lib/prism/parse_result.rb#635
+  sig { returns(Prism::Location) }
+  def location; end
+
+  # The message associated with this warning.
+  #
+  # source://prism//lib/prism/parse_result.rb#632
+  sig { returns(String) }
+  def message; end
+
+  # The type of warning. This is an _internal_ symbol that is used for
+  # communicating with translation layers. It is not meant to be public API.
+  #
+  # source://prism//lib/prism/parse_result.rb#629
+  sig { returns(Symbol) }
+  def type; end
+end
+
+# A pattern is an object that wraps a Ruby pattern matching expression. The
+# expression would normally be passed to an `in` clause within a `case`
+# expression or a rightward assignment expression. For example, in the
+# following snippet:
+#
+#     case node
+#     in ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]
+#     end
+#
+# the pattern is the <tt>ConstantPathNode[...]</tt> expression.
+#
+# The pattern gets compiled into an object that responds to #call by running
+# the #compile method. This method itself will run back through Prism to
+# parse the expression into a tree, then walk the tree to generate the
+# necessary callable objects. For example, if you wanted to compile the
+# expression above into a callable, you would:
+#
+#     callable = Prism::Pattern.new("ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]").compile
+#     callable.call(node)
+#
+# The callable object returned by #compile is guaranteed to respond to #call
+# with a single argument, which is the node to match against. It also is
+# guaranteed to respond to #===, which means it itself can be used in a `case`
+# expression, as in:
+#
+#     case node
+#     when callable
+#     end
+#
+# If the query given to the initializer cannot be compiled into a valid
+# matcher (either because of a syntax error or because it is using syntax we
+# do not yet support) then a Prism::Pattern::CompilationError will be
+# raised.
+#
+# source://prism//lib/prism/pattern.rb#37
+class Prism::Pattern
+  # Create a new pattern with the given query. The query should be a string
+  # containing a Ruby pattern matching expression.
+  #
+  # @return [Pattern] a new instance of Pattern
+  #
+  # source://prism//lib/prism/pattern.rb#63
+  def initialize(query); end
+
+  # Compile the query into a callable object that can be used to match against
+  # nodes.
+  #
+  # @raise [CompilationError]
+  #
+  # source://prism//lib/prism/pattern.rb#70
+  def compile; end
+
+  # The query that this pattern was initialized with.
+  #
+  # source://prism//lib/prism/pattern.rb#59
+  def query; end
+
+  # Scan the given node and all of its children for nodes that match the
+  # pattern. If a block is given, it will be called with each node that
+  # matches the pattern. If no block is given, an enumerator will be returned
+  # that will yield each node that matches the pattern.
+  #
+  # source://prism//lib/prism/pattern.rb#86
+  def scan(root); end
+
+  private
+
+  # Shortcut for combining two procs into one that returns true if both return
+  # true.
+  #
+  # source://prism//lib/prism/pattern.rb#102
+  def combine_and(left, right); end
+
+  # Shortcut for combining two procs into one that returns true if either
+  # returns true.
+  #
+  # source://prism//lib/prism/pattern.rb#108
+  def combine_or(left, right); end
+
+  # in foo | bar
+  #
+  # source://prism//lib/prism/pattern.rb#143
+  def compile_alternation_pattern_node(node); end
+
+  # in [foo, bar, baz]
+  #
+  # source://prism//lib/prism/pattern.rb#118
+  def compile_array_pattern_node(node); end
+
+  # Compile a name associated with a constant.
+  #
+  # source://prism//lib/prism/pattern.rb#168
+  def compile_constant_name(node, name); end
+
+  # in Prism::ConstantReadNode
+  #
+  # source://prism//lib/prism/pattern.rb#148
+  def compile_constant_path_node(node); end
+
+  # in ConstantReadNode
+  # in String
+  #
+  # source://prism//lib/prism/pattern.rb#163
+  def compile_constant_read_node(node); end
+
+  # Raise an error because the given node is not supported.
+  #
+  # @raise [CompilationError]
+  #
+  # source://prism//lib/prism/pattern.rb#113
+  def compile_error(node); end
+
+  # in InstanceVariableReadNode[name: Symbol]
+  # in { name: Symbol }
+  #
+  # source://prism//lib/prism/pattern.rb#184
+  def compile_hash_pattern_node(node); end
+
+  # in nil
+  #
+  # source://prism//lib/prism/pattern.rb#214
+  def compile_nil_node(node); end
+
+  # Compile any kind of node. Dispatch out to the individual compilation
+  # methods based on the type of node.
+  #
+  # source://prism//lib/prism/pattern.rb#243
+  def compile_node(node); end
+
+  # in /foo/
+  #
+  # source://prism//lib/prism/pattern.rb#219
+  def compile_regular_expression_node(node); end
+
+  # in ""
+  # in "foo"
+  #
+  # source://prism//lib/prism/pattern.rb#227
+  def compile_string_node(node); end
+
+  # in :+
+  # in :foo
+  #
+  # source://prism//lib/prism/pattern.rb#235
+  def compile_symbol_node(node); end
+end
+
+# Raised when the query given to a pattern is either invalid Ruby syntax or
+# is using syntax that we don't yet support.
+#
+# source://prism//lib/prism/pattern.rb#40
+class Prism::Pattern::CompilationError < ::StandardError
+  # Create a new CompilationError with the given representation of the node
+  # that caused the error.
+  #
+  # @return [CompilationError] a new instance of CompilationError
+  #
+  # source://prism//lib/prism/pattern.rb#43
+  def initialize(repr); end
+end
+
+# Represents the use of the `^` operator for pinning an expression in a pattern matching expression.
+#
+#     foo in ^(bar)
+#            ^^^^^^
+#
+# source://prism//lib/prism/node.rb#12986
+class Prism::PinnedExpressionNode < ::Prism::Node
+  # Initialize a new PinnedExpressionNode node.
+  #
+  # @return [PinnedExpressionNode] a new instance of PinnedExpressionNode
+  #
+  # source://prism//lib/prism/node.rb#12988
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      expression: Prism::Node,
+      operator_loc: Prism::Location,
+      lparen_loc: Prism::Location,
+      rparen_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, expression, operator_loc, lparen_loc, rparen_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#13088
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#13000
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13005
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#13015
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#13010
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node, ?operator_loc: Location, ?lparen_loc: Location, ?rparen_loc: Location) -> PinnedExpressionNode
+  #
+  # source://prism//lib/prism/node.rb#13020
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      expression: Prism::Node,
+      operator_loc: Prism::Location,
+      lparen_loc: Prism::Location,
+      rparen_loc: Prism::Location
+    ).returns(Prism::PinnedExpressionNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13005
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#13028
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader expression: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#13033
+  sig { returns(Prism::Node) }
+  def expression; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#13072
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def lparen: () -> String
+  #
+  # source://prism//lib/prism/node.rb#13062
+  sig { returns(String) }
+  def lparen; end
+
+  # attr_reader lparen_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#13043
+  sig { returns(Prism::Location) }
+  def lparen_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#13057
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#13036
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # def rparen: () -> String
+  #
+  # source://prism//lib/prism/node.rb#13067
+  sig { returns(String) }
+  def rparen; end
+
+  # attr_reader rparen_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#13050
+  sig { returns(Prism::Location) }
+  def rparen_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#13077
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#13082
+    def type; end
+  end
+end
+
+# Represents the use of the `^` operator for pinning a variable in a pattern matching expression.
+#
+#     foo in ^bar
+#            ^^^^
+#
+# source://prism//lib/prism/node.rb#13101
+class Prism::PinnedVariableNode < ::Prism::Node
+  # Initialize a new PinnedVariableNode node.
+  #
+  # @return [PinnedVariableNode] a new instance of PinnedVariableNode
+  #
+  # source://prism//lib/prism/node.rb#13103
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      variable: T.any(Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode, Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::ItLocalVariableReadNode, Prism::MissingNode),
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, variable, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#13177
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#13113
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13118
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#13128
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#13123
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode, ?operator_loc: Location) -> PinnedVariableNode
+  #
+  # source://prism//lib/prism/node.rb#13133
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      variable: T.any(Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode, Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::ItLocalVariableReadNode, Prism::MissingNode),
+      operator_loc: Prism::Location
+    ).returns(Prism::PinnedVariableNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), variable: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13118
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#13141
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#13161
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#13156
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#13149
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#13166
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode
+  #
+  # source://prism//lib/prism/node.rb#13146
+  sig do
+    returns(T.any(Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode, Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::ItLocalVariableReadNode, Prism::MissingNode))
+  end
+  def variable; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#13171
+    def type; end
+  end
+end
+
+# Represents the use of the `END` keyword.
+#
+#     END { foo }
+#     ^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#13188
+class Prism::PostExecutionNode < ::Prism::Node
+  # Initialize a new PostExecutionNode node.
+  #
+  # @return [PostExecutionNode] a new instance of PostExecutionNode
+  #
+  # source://prism//lib/prism/node.rb#13190
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      statements: T.nilable(Prism::StatementsNode),
+      keyword_loc: Prism::Location,
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, statements, keyword_loc, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#13292
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#13202
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13207
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#13271
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#13254
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#13219
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#13212
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location) -> PostExecutionNode
+  #
+  # source://prism//lib/prism/node.rb#13224
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      statements: T.nilable(Prism::StatementsNode),
+      keyword_loc: Prism::Location,
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).returns(Prism::PostExecutionNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13207
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#13232
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#13276
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#13261
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#13240
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#13266
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#13247
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism//lib/prism/node.rb#13237
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#13281
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#13286
+    def type; end
+  end
+end
+
+# Represents the use of the `BEGIN` keyword.
+#
+#     BEGIN { foo }
+#     ^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#13305
+class Prism::PreExecutionNode < ::Prism::Node
+  # Initialize a new PreExecutionNode node.
+  #
+  # @return [PreExecutionNode] a new instance of PreExecutionNode
+  #
+  # source://prism//lib/prism/node.rb#13307
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      statements: T.nilable(Prism::StatementsNode),
+      keyword_loc: Prism::Location,
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, statements, keyword_loc, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#13409
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#13319
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13324
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#13388
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#13371
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#13336
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#13329
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location) -> PreExecutionNode
+  #
+  # source://prism//lib/prism/node.rb#13341
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      statements: T.nilable(Prism::StatementsNode),
+      keyword_loc: Prism::Location,
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).returns(Prism::PreExecutionNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13324
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#13349
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#13393
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#13378
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#13357
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#13383
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#13364
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism//lib/prism/node.rb#13354
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#13398
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#13403
+    def type; end
+  end
+end
+
+# The top level node of any parse tree.
+#
+# source://prism//lib/prism/node.rb#13419
+class Prism::ProgramNode < ::Prism::Node
+  # Initialize a new ProgramNode node.
+  #
+  # @return [ProgramNode] a new instance of ProgramNode
+  #
+  # source://prism//lib/prism/node.rb#13421
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      statements: Prism::StatementsNode
+    ).void
+  end
+  def initialize(source, node_id, location, flags, locals, statements); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#13486
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#13431
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13436
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#13446
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#13441
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?statements: StatementsNode) -> ProgramNode
+  #
+  # source://prism//lib/prism/node.rb#13451
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      statements: Prism::StatementsNode
+    ).returns(Prism::ProgramNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13436
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], statements: StatementsNode }
+  #
+  # source://prism//lib/prism/node.rb#13459
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#13470
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[Symbol]
+  #
+  # source://prism//lib/prism/node.rb#13464
+  sig { returns(T::Array[Symbol]) }
+  def locals; end
+
+  # attr_reader statements: StatementsNode
+  #
+  # source://prism//lib/prism/node.rb#13467
+  sig { returns(Prism::StatementsNode) }
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#13475
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#13480
+    def type; end
+  end
+end
+
+# Flags for range and flip-flop nodes.
+#
+# source://prism//lib/prism/node.rb#16774
+module Prism::RangeFlags; end
+
+# ... operator
+#
+# source://prism//lib/prism/node.rb#16776
+Prism::RangeFlags::EXCLUDE_END = T.let(T.unsafe(nil), Integer)
+
+# Represents the use of the `..` or `...` operators.
+#
+#     1..2
+#     ^^^^
+#
+#     c if a =~ /left/ ... b =~ /right/
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#13501
+class Prism::RangeNode < ::Prism::Node
+  # Initialize a new RangeNode node.
+  #
+  # @return [RangeNode] a new instance of RangeNode
+  #
+  # source://prism//lib/prism/node.rb#13503
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: T.nilable(Prism::Node),
+      right: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, left, right, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#13602
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#13514
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13519
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#13532
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#13524
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location) -> RangeNode
+  #
+  # source://prism//lib/prism/node.rb#13537
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: T.nilable(Prism::Node),
+      right: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).returns(Prism::RangeNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13519
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node?, right: Prism::node?, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#13545
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def exclude_end?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13550
+  sig { returns(T::Boolean) }
+  def exclude_end?; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#13586
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The left-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     1...
+  #     ^
+  #
+  #     hello...goodbye
+  #     ^^^^^
+  #
+  # source://prism//lib/prism/node.rb#13561
+  sig { returns(T.nilable(Prism::Node)) }
+  def left; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#13581
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `..` or `...` operator.
+  #
+  # source://prism//lib/prism/node.rb#13574
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # The right-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     ..5
+  #       ^
+  #
+  #     1...foo
+  #         ^^^
+  # If neither right-hand or left-hand side was included, this will be a MissingNode.
+  #
+  # source://prism//lib/prism/node.rb#13571
+  sig { returns(T.nilable(Prism::Node)) }
+  def right; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#13591
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#13596
+    def type; end
+  end
+end
+
+# Represents a rational number literal.
+#
+#     1.0r
+#     ^^^^
+#
+# source://prism//lib/prism/node.rb#13615
+class Prism::RationalNode < ::Prism::Node
+  # Initialize a new RationalNode node.
+  #
+  # @return [RationalNode] a new instance of RationalNode
+  #
+  # source://prism//lib/prism/node.rb#13617
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      numerator: Integer,
+      denominator: Integer
+    ).void
+  end
+  def initialize(source, node_id, location, flags, numerator, denominator); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#13706
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#13627
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def binary?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13660
+  sig { returns(T::Boolean) }
+  def binary?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13632
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#13642
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#13637
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?numerator: Integer, ?denominator: Integer) -> RationalNode
+  #
+  # source://prism//lib/prism/node.rb#13647
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      numerator: Integer,
+      denominator: Integer
+    ).returns(Prism::RationalNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), numerator: T.unsafe(nil), denominator: T.unsafe(nil)); end
+
+  # def decimal?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13665
+  sig { returns(T::Boolean) }
+  def decimal?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13632
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, numerator: Integer, denominator: Integer }
+  #
+  # source://prism//lib/prism/node.rb#13655
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # The denominator of the rational number.
+  #
+  #     1.5r # denominator 2
+  #
+  # source://prism//lib/prism/node.rb#13687
+  sig { returns(Integer) }
+  def denominator; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def hexadecimal?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13675
+  sig { returns(T::Boolean) }
+  def hexadecimal?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#13690
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The numerator of the rational number.
+  #
+  #     1.5r # numerator 3
+  #
+  # source://prism//lib/prism/node.rb#13682
+  sig { returns(Integer) }
+  def numerator; end
+
+  # Returns the value of the node as an IntegerNode or a FloatNode. This
+  # method is deprecated in favor of #value or #numerator/#denominator.
+  #
+  # source://prism//lib/prism/node_ext.rb#120
+  def numeric; end
+
+  # def octal?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13670
+  sig { returns(T::Boolean) }
+  def octal?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#13695
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # Returns the value of the node as a Ruby Rational.
+  #
+  # source://prism//lib/prism/node_ext.rb#114
+  sig { returns(Rational) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#13700
+    def type; end
+  end
+end
+
+# Represents the use of the `redo` keyword.
+#
+#     redo
+#     ^^^^
+#
+# source://prism//lib/prism/node.rb#13718
+class Prism::RedoNode < ::Prism::Node
+  # Initialize a new RedoNode node.
+  #
+  # @return [RedoNode] a new instance of RedoNode
+  #
+  # source://prism//lib/prism/node.rb#13720
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void }
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#13777
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#13728
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13733
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#13743
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#13738
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> RedoNode
+  #
+  # source://prism//lib/prism/node.rb#13748
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::RedoNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13733
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  #
+  # source://prism//lib/prism/node.rb#13756
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#13761
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#13766
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#13771
+    def type; end
+  end
+end
+
+# The Reflection module provides the ability to reflect on the structure of
+# the syntax tree itself, as opposed to looking at a single syntax tree. This
+# is useful in metaprogramming contexts.
+#
+# source://prism//lib/prism/reflection.rb#13
+module Prism::Reflection
+  class << self
+    # Returns the fields for the given node.
+    #
+    # source://prism//lib/prism/reflection.rb#104
+    sig { params(node: T.class_of(Prism::Node)).returns(T::Array[Prism::Reflection::Field]) }
+    def fields_for(node); end
+  end
+end
+
+# A constant field represents a constant value on a node. Effectively, it
+# represents an identifier found within the source. It resolves to a symbol
+# in Ruby.
+#
+# source://prism//lib/prism/reflection.rb#45
+class Prism::Reflection::ConstantField < ::Prism::Reflection::Field; end
+
+# A constant list field represents a list of constant values on a node. It
+# resolves to an array of symbols in Ruby.
+#
+# source://prism//lib/prism/reflection.rb#55
+class Prism::Reflection::ConstantListField < ::Prism::Reflection::Field; end
+
+# A field represents a single piece of data on a node. It is the base class
+# for all other field types.
+#
+# source://prism//lib/prism/reflection.rb#16
+class Prism::Reflection::Field
+  # Initializes the field with the given name.
+  #
+  # @return [Field] a new instance of Field
+  #
+  # source://prism//lib/prism/reflection.rb#21
+  sig { params(name: Symbol).void }
+  def initialize(name); end
+
+  # The name of the field.
+  #
+  # source://prism//lib/prism/reflection.rb#18
+  sig { returns(Symbol) }
+  def name; end
+end
+
+# A flags field represents a bitset of flags on a node. It resolves to an
+# integer in Ruby. Note that the flags cannot be accessed directly on the
+# node because the integer is kept private. Instead, the various flags in
+# the bitset should be accessed through their query methods.
+#
+# source://prism//lib/prism/reflection.rb#92
+class Prism::Reflection::FlagsField < ::Prism::Reflection::Field
+  # Initializes the flags field with the given name and flags.
+  #
+  # @return [FlagsField] a new instance of FlagsField
+  #
+  # source://prism//lib/prism/reflection.rb#97
+  sig { params(name: Symbol, flags: T::Array[Symbol]).void }
+  def initialize(name, flags); end
+
+  # The names of the flags in the bitset.
+  #
+  # source://prism//lib/prism/reflection.rb#94
+  sig { returns(T::Array[Symbol]) }
+  def flags; end
+end
+
+# A float field represents a double-precision floating point value. It is
+# used exclusively to represent the value of a floating point literal. It
+# resolves to a Float in Ruby.
+#
+# source://prism//lib/prism/reflection.rb#85
+class Prism::Reflection::FloatField < ::Prism::Reflection::Field; end
+
+# An integer field represents an integer value. It is used to represent the
+# value of an integer literal, the depth of local variables, and the number
+# of a numbered reference. It resolves to an Integer in Ruby.
+#
+# source://prism//lib/prism/reflection.rb#79
+class Prism::Reflection::IntegerField < ::Prism::Reflection::Field; end
+
+# A location field represents the location of some part of the node in the
+# source code. For example, the location of a keyword or an operator. It
+# resolves to a Prism::Location in Ruby.
+#
+# source://prism//lib/prism/reflection.rb#67
+class Prism::Reflection::LocationField < ::Prism::Reflection::Field; end
+
+# A node field represents a single child node in the syntax tree. It
+# resolves to a Prism::Node in Ruby.
+#
+# source://prism//lib/prism/reflection.rb#28
+class Prism::Reflection::NodeField < ::Prism::Reflection::Field; end
+
+# A node list field represents a list of child nodes in the syntax tree. It
+# resolves to an array of Prism::Node instances in Ruby.
+#
+# source://prism//lib/prism/reflection.rb#39
+class Prism::Reflection::NodeListField < ::Prism::Reflection::Field; end
+
+# An optional constant field represents a constant value on a node that may
+# or may not be present. It resolves to either a symbol or nil in Ruby.
+#
+# source://prism//lib/prism/reflection.rb#50
+class Prism::Reflection::OptionalConstantField < ::Prism::Reflection::Field; end
+
+# An optional location field represents the location of some part of the
+# node in the source code that may or may not be present. It resolves to
+# either a Prism::Location or nil in Ruby.
+#
+# source://prism//lib/prism/reflection.rb#73
+class Prism::Reflection::OptionalLocationField < ::Prism::Reflection::Field; end
+
+# An optional node field represents a single child node in the syntax tree
+# that may or may not be present. It resolves to either a Prism::Node or nil
+# in Ruby.
+#
+# source://prism//lib/prism/reflection.rb#34
+class Prism::Reflection::OptionalNodeField < ::Prism::Reflection::Field; end
+
+# A string field represents a string value on a node. It almost always
+# represents the unescaped value of a string-like literal. It resolves to a
+# string in Ruby.
+#
+# source://prism//lib/prism/reflection.rb#61
+class Prism::Reflection::StringField < ::Prism::Reflection::Field; end
+
+# Flags for regular expression and match last line nodes.
+#
+# source://prism//lib/prism/node.rb#16780
+module Prism::RegularExpressionFlags; end
+
+# n - forces the ASCII-8BIT encoding
+#
+# source://prism//lib/prism/node.rb#16797
+Prism::RegularExpressionFlags::ASCII_8BIT = T.let(T.unsafe(nil), Integer)
+
+# e - forces the EUC-JP encoding
+#
+# source://prism//lib/prism/node.rb#16794
+Prism::RegularExpressionFlags::EUC_JP = T.let(T.unsafe(nil), Integer)
+
+# x - ignores whitespace and allows comments in regular expressions
+#
+# source://prism//lib/prism/node.rb#16785
+Prism::RegularExpressionFlags::EXTENDED = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to binary
+#
+# source://prism//lib/prism/node.rb#16809
+Prism::RegularExpressionFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to US-ASCII
+#
+# source://prism//lib/prism/node.rb#16812
+Prism::RegularExpressionFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to UTF-8
+#
+# source://prism//lib/prism/node.rb#16806
+Prism::RegularExpressionFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# i - ignores the case of characters when matching
+#
+# source://prism//lib/prism/node.rb#16782
+Prism::RegularExpressionFlags::IGNORE_CASE = T.let(T.unsafe(nil), Integer)
+
+# m - allows $ to match the end of lines within strings
+#
+# source://prism//lib/prism/node.rb#16788
+Prism::RegularExpressionFlags::MULTI_LINE = T.let(T.unsafe(nil), Integer)
+
+# o - only interpolates values into the regular expression once
+#
+# source://prism//lib/prism/node.rb#16791
+Prism::RegularExpressionFlags::ONCE = T.let(T.unsafe(nil), Integer)
+
+# u - forces the UTF-8 encoding
+#
+# source://prism//lib/prism/node.rb#16803
+Prism::RegularExpressionFlags::UTF_8 = T.let(T.unsafe(nil), Integer)
+
+# s - forces the Windows-31J encoding
+#
+# source://prism//lib/prism/node.rb#16800
+Prism::RegularExpressionFlags::WINDOWS_31J = T.let(T.unsafe(nil), Integer)
+
+# Represents a regular expression literal with no interpolation.
+#
+#     /foo/i
+#     ^^^^^^
+#
+# source://prism//lib/prism/node.rb#13786
+class Prism::RegularExpressionNode < ::Prism::Node
+  include ::Prism::RegularExpressionOptions
+
+  # Initialize a new RegularExpressionNode node.
+  #
+  # @return [RegularExpressionNode] a new instance of RegularExpressionNode
+  #
+  # source://prism//lib/prism/node.rb#13788
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#13943
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#13800
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def ascii_8bit?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13858
+  sig { returns(T::Boolean) }
+  def ascii_8bit?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13805
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#13922
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#13902
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#13815
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#13810
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def content: () -> String
+  #
+  # source://prism//lib/prism/node.rb#13917
+  sig { returns(String) }
+  def content; end
+
+  # attr_reader content_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#13895
+  sig { returns(Prism::Location) }
+  def content_loc; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> RegularExpressionNode
+  #
+  # source://prism//lib/prism/node.rb#13820
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).returns(Prism::RegularExpressionNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13805
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String }
+  #
+  # source://prism//lib/prism/node.rb#13828
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def euc_jp?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13853
+  sig { returns(T::Boolean) }
+  def euc_jp?; end
+
+  # def extended?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13838
+  sig { returns(T::Boolean) }
+  def extended?; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13878
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13883
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13873
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def ignore_case?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13833
+  sig { returns(T::Boolean) }
+  def ignore_case?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#13927
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def multi_line?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13843
+  sig { returns(T::Boolean) }
+  def multi_line?; end
+
+  # def once?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13848
+  sig { returns(T::Boolean) }
+  def once?; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#13912
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#13888
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  sig { returns(Integer) }
+  def options; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#13932
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader unescaped: String
+  #
+  # source://prism//lib/prism/node.rb#13909
+  sig { returns(String) }
+  def unescaped; end
+
+  # def utf_8?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13868
+  sig { returns(T::Boolean) }
+  def utf_8?; end
+
+  # def windows_31j?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#13863
+  sig { returns(T::Boolean) }
+  def windows_31j?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#13937
+    def type; end
+  end
+end
+
+# source://prism//lib/prism/node_ext.rb#20
+module Prism::RegularExpressionOptions
+  # Returns a numeric value that represents the flags that were used to create
+  # the regular expression.
+  #
+  # source://prism//lib/prism/node_ext.rb#23
+  def options; end
+end
+
+# Represents a required keyword parameter to a method, block, or lambda definition.
+#
+#     def a(b: )
+#           ^^
+#     end
+#
+# source://prism//lib/prism/node.rb#13958
+class Prism::RequiredKeywordParameterNode < ::Prism::Node
+  # Initialize a new RequiredKeywordParameterNode node.
+  #
+  # @return [RequiredKeywordParameterNode] a new instance of RequiredKeywordParameterNode
+  #
+  # source://prism//lib/prism/node.rb#13960
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#14034
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#13970
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13975
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#13985
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#13980
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location) -> RequiredKeywordParameterNode
+  #
+  # source://prism//lib/prism/node.rb#13990
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location
+    ).returns(Prism::RequiredKeywordParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#13975
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#13998
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#14018
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#14008
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#14011
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#14003
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#14023
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#14028
+    def type; end
+  end
+end
+
+# Represents a required parameter to a method, block, or lambda definition.
+#
+#     def a(b)
+#           ^
+#     end
+#
+# source://prism//lib/prism/node.rb#14047
+class Prism::RequiredParameterNode < ::Prism::Node
+  # Initialize a new RequiredParameterNode node.
+  #
+  # @return [RequiredParameterNode] a new instance of RequiredParameterNode
+  #
+  # source://prism//lib/prism/node.rb#14049
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#14115
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#14058
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14063
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#14073
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#14068
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> RequiredParameterNode
+  #
+  # source://prism//lib/prism/node.rb#14078
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::RequiredParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14063
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  #
+  # source://prism//lib/prism/node.rb#14086
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#14099
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism//lib/prism/node.rb#14096
+  sig { returns(Symbol) }
+  def name; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#14091
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#14104
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#14109
+    def type; end
+  end
+end
+
+# Represents an expression modified with a rescue.
+#
+#     foo rescue nil
+#     ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#14126
+class Prism::RescueModifierNode < ::Prism::Node
+  # Initialize a new RescueModifierNode node.
+  #
+  # @return [RescueModifierNode] a new instance of RescueModifierNode
+  #
+  # source://prism//lib/prism/node.rb#14128
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      expression: Prism::Node,
+      keyword_loc: Prism::Location,
+      rescue_expression: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, expression, keyword_loc, rescue_expression); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#14206
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#14139
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14144
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#14154
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#14149
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node, ?keyword_loc: Location, ?rescue_expression: Prism::node) -> RescueModifierNode
+  #
+  # source://prism//lib/prism/node.rb#14159
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      expression: Prism::Node,
+      keyword_loc: Prism::Location,
+      rescue_expression: Prism::Node
+    ).returns(Prism::RescueModifierNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), keyword_loc: T.unsafe(nil), rescue_expression: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14144
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node, keyword_loc: Location, rescue_expression: Prism::node }
+  #
+  # source://prism//lib/prism/node.rb#14167
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader expression: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#14172
+  sig { returns(Prism::Node) }
+  def expression; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#14190
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#14185
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#14175
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # source://prism//lib/prism/parse_result/newlines.rb#115
+  def newline_flag!(lines); end
+
+  # attr_reader rescue_expression: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#14182
+  sig { returns(Prism::Node) }
+  def rescue_expression; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#14195
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#14200
+    def type; end
+  end
+end
+
+# Represents a rescue statement.
+#
+#     begin
+#     rescue Foo, *splat, Bar => ex
+#       foo
+#     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#     end
+#
+# `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `reference` field.
+#
+# source://prism//lib/prism/node.rb#14223
+class Prism::RescueNode < ::Prism::Node
+  # Initialize a new RescueNode node.
+  #
+  # @return [RescueNode] a new instance of RescueNode
+  #
+  # source://prism//lib/prism/node.rb#14225
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      exceptions: T::Array[Prism::Node],
+      operator_loc: T.nilable(Prism::Location),
+      reference: T.nilable(T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::MissingNode)),
+      statements: T.nilable(Prism::StatementsNode),
+      subsequent: T.nilable(Prism::RescueNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, keyword_loc, exceptions, operator_loc, reference, statements, subsequent); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#14335
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#14239
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14244
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#14259
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#14249
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # Returns the subsequent rescue clause of the rescue node. This method is
+  # deprecated in favor of #subsequent.
+  #
+  # source://prism//lib/prism/node_ext.rb#494
+  def consequent; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?exceptions: Array[Prism::node], ?operator_loc: Location?, ?reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil, ?statements: StatementsNode?, ?subsequent: RescueNode?) -> RescueNode
+  #
+  # source://prism//lib/prism/node.rb#14264
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      exceptions: T::Array[Prism::Node],
+      operator_loc: T.nilable(Prism::Location),
+      reference: T.nilable(T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::MissingNode)),
+      statements: T.nilable(Prism::StatementsNode),
+      subsequent: T.nilable(Prism::RescueNode)
+    ).returns(Prism::RescueNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), exceptions: T.unsafe(nil), operator_loc: T.unsafe(nil), reference: T.unsafe(nil), statements: T.unsafe(nil), subsequent: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14244
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, exceptions: Array[Prism::node], operator_loc: Location?, reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil, statements: StatementsNode?, subsequent: RescueNode? }
+  #
+  # source://prism//lib/prism/node.rb#14272
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader exceptions: Array[Prism::node]
+  #
+  # source://prism//lib/prism/node.rb#14284
+  sig { returns(T::Array[Prism::Node]) }
+  def exceptions; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#14319
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#14309
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#14277
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # def operator: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#14314
+  sig { returns(T.nilable(String)) }
+  def operator; end
+
+  # attr_reader operator_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#14287
+  sig { returns(T.nilable(Prism::Location)) }
+  def operator_loc; end
+
+  # attr_reader reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil
+  #
+  # source://prism//lib/prism/node.rb#14300
+  sig do
+    returns(T.nilable(T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::MissingNode)))
+  end
+  def reference; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism//lib/prism/node.rb#14303
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # attr_reader subsequent: RescueNode?
+  #
+  # source://prism//lib/prism/node.rb#14306
+  sig { returns(T.nilable(Prism::RescueNode)) }
+  def subsequent; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#14324
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#14329
+    def type; end
+  end
+end
+
+# Represents a rest parameter to a method, block, or lambda definition.
+#
+#     def a(*b)
+#           ^^
+#     end
+#
+# source://prism//lib/prism/node.rb#14352
+class Prism::RestParameterNode < ::Prism::Node
+  # Initialize a new RestParameterNode node.
+  #
+  # @return [RestParameterNode] a new instance of RestParameterNode
+  #
+  # source://prism//lib/prism/node.rb#14354
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#14447
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#14365
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14370
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#14380
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#14375
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> RestParameterNode
+  #
+  # source://prism//lib/prism/node.rb#14385
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).returns(Prism::RestParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14370
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#14393
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#14431
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol?
+  #
+  # source://prism//lib/prism/node.rb#14403
+  sig { returns(T.nilable(Symbol)) }
+  def name; end
+
+  # attr_reader name_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#14406
+  sig { returns(T.nilable(Prism::Location)) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#14426
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#14419
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#14398
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#14436
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#14441
+    def type; end
+  end
+end
+
+# This represents the result of a call to ::parse or ::parse_file. It contains
+# the requested structure, any comments that were encounters, and any errors
+# that were encountered.
+#
+# source://prism//lib/prism/parse_result.rb#662
+class Prism::Result
+  # Create a new result object with the given values.
+  #
+  # @return [Result] a new instance of Result
+  #
+  # source://prism//lib/prism/parse_result.rb#684
+  sig do
+    params(
+      comments: T::Array[Prism::Comment],
+      magic_comments: T::Array[Prism::MagicComment],
+      data_loc: T.nilable(Prism::Location),
+      errors: T::Array[Prism::ParseError],
+      warnings: T::Array[Prism::ParseWarning],
+      source: Prism::Source
+    ).void
+  end
+  def initialize(comments, magic_comments, data_loc, errors, warnings, source); end
+
+  # Create a code units cache for the given encoding.
+  #
+  # source://prism//lib/prism/parse_result.rb#716
+  sig do
+    params(
+      encoding: Encoding
+    ).returns(T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer)))
+  end
+  def code_units_cache(encoding); end
+
+  # The list of comments that were encountered during parsing.
+  #
+  # source://prism//lib/prism/parse_result.rb#664
+  sig { returns(T::Array[Prism::Comment]) }
+  def comments; end
+
+  # An optional location that represents the location of the __END__ marker
+  # and the rest of the content of the file. This content is loaded into the
+  # DATA constant when the file being parsed is the main file being executed.
+  #
+  # source://prism//lib/prism/parse_result.rb#672
+  sig { returns(T.nilable(Prism::Location)) }
+  def data_loc; end
+
+  # Implement the hash pattern matching interface for Result.
+  #
+  # source://prism//lib/prism/parse_result.rb#694
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # Returns the encoding of the source code that was parsed.
+  #
+  # source://prism//lib/prism/parse_result.rb#699
+  sig { returns(Encoding) }
+  def encoding; end
+
+  # The list of errors that were generated during parsing.
+  #
+  # source://prism//lib/prism/parse_result.rb#675
+  sig { returns(T::Array[Prism::ParseError]) }
+  def errors; end
+
+  # Returns true if there were errors during parsing and false if there were
+  # not.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/parse_result.rb#711
+  sig { returns(T::Boolean) }
+  def failure?; end
+
+  # The list of magic comments that were encountered during parsing.
+  #
+  # source://prism//lib/prism/parse_result.rb#667
+  sig { returns(T::Array[Prism::MagicComment]) }
+  def magic_comments; end
+
+  # A Source instance that represents the source code that was parsed.
+  #
+  # source://prism//lib/prism/parse_result.rb#681
+  sig { returns(Prism::Source) }
+  def source; end
+
+  # Returns true if there were no errors during parsing and false if there
+  # were.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/parse_result.rb#705
+  sig { returns(T::Boolean) }
+  def success?; end
+
+  # The list of warnings that were generated during parsing.
+  #
+  # source://prism//lib/prism/parse_result.rb#678
+  sig { returns(T::Array[Prism::ParseWarning]) }
+  def warnings; end
+end
+
+# Represents the use of the `retry` keyword.
+#
+#     retry
+#     ^^^^^
+#
+# source://prism//lib/prism/node.rb#14460
+class Prism::RetryNode < ::Prism::Node
+  # Initialize a new RetryNode node.
+  #
+  # @return [RetryNode] a new instance of RetryNode
+  #
+  # source://prism//lib/prism/node.rb#14462
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void }
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#14519
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#14470
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14475
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#14485
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#14480
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> RetryNode
+  #
+  # source://prism//lib/prism/node.rb#14490
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::RetryNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14475
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  #
+  # source://prism//lib/prism/node.rb#14498
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#14503
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#14508
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#14513
+    def type; end
+  end
+end
+
+# Represents the use of the `return` keyword.
+#
+#     return 1
+#     ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#14528
+class Prism::ReturnNode < ::Prism::Node
+  # Initialize a new ReturnNode node.
+  #
+  # @return [ReturnNode] a new instance of ReturnNode
+  #
+  # source://prism//lib/prism/node.rb#14530
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, keyword_loc, arguments); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#14606
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#14540
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism//lib/prism/node.rb#14582
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14545
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#14557
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#14550
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?arguments: ArgumentsNode?) -> ReturnNode
+  #
+  # source://prism//lib/prism/node.rb#14562
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode)
+    ).returns(Prism::ReturnNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), arguments: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14545
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, arguments: ArgumentsNode? }
+  #
+  # source://prism//lib/prism/node.rb#14570
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#14590
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#14585
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#14575
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#14595
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#14600
+    def type; end
+  end
+end
+
+# Represents the `self` keyword.
+#
+#     self
+#     ^^^^
+#
+# source://prism//lib/prism/node.rb#14617
+class Prism::SelfNode < ::Prism::Node
+  # Initialize a new SelfNode node.
+  #
+  # @return [SelfNode] a new instance of SelfNode
+  #
+  # source://prism//lib/prism/node.rb#14619
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void }
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#14676
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#14627
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14632
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#14642
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#14637
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SelfNode
+  #
+  # source://prism//lib/prism/node.rb#14647
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::SelfNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14632
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  #
+  # source://prism//lib/prism/node.rb#14655
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#14660
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#14665
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#14670
+    def type; end
+  end
+end
+
+# A module responsible for deserializing parse results.
+#
+# source://prism//lib/prism/serialize.rb#14
+module Prism::Serialize
+  class << self
+    # Deserialize the AST represented by the given string into a parse result.
+    #
+    # source://prism//lib/prism/serialize.rb#28
+    def load(input, serialized); end
+
+    # Deserialize the tokens represented by the given string into a parse
+    # result.
+    #
+    # source://prism//lib/prism/serialize.rb#51
+    def load_tokens(source, serialized); end
+  end
+end
+
+# source://prism//lib/prism/serialize.rb#55
+class Prism::Serialize::Loader
+  # @return [Loader] a new instance of Loader
+  #
+  # source://prism//lib/prism/serialize.rb#91
+  def initialize(source, serialized); end
+
+  # Returns the value of attribute constant_pool.
+  #
+  # source://prism//lib/prism/serialize.rb#88
+  def constant_pool; end
+
+  # Returns the value of attribute constant_pool_offset.
+  #
+  # source://prism//lib/prism/serialize.rb#88
+  def constant_pool_offset; end
+
+  # Returns the value of attribute encoding.
+  #
+  # source://prism//lib/prism/serialize.rb#87
+  def encoding; end
+
+  # Returns the value of attribute input.
+  #
+  # source://prism//lib/prism/serialize.rb#87
+  def input; end
+
+  # Returns the value of attribute io.
+  #
+  # source://prism//lib/prism/serialize.rb#87
+  def io; end
+
+  # source://prism//lib/prism/serialize.rb#129
+  def load_comments; end
+
+  # source://prism//lib/prism/serialize.rb#115
+  def load_encoding; end
+
+  # source://prism//lib/prism/serialize.rb#106
+  def load_header; end
+
+  # source://prism//lib/prism/serialize.rb#125
+  def load_line_offsets; end
+
+  # source://prism//lib/prism/serialize.rb#462
+  def load_metadata; end
+
+  # source://prism//lib/prism/serialize.rb#496
+  def load_nodes; end
+
+  # source://prism//lib/prism/serialize.rb#510
+  def load_result; end
+
+  # source://prism//lib/prism/serialize.rb#121
+  def load_start_line; end
+
+  # source://prism//lib/prism/serialize.rb#471
+  def load_tokens; end
+
+  # source://prism//lib/prism/serialize.rb#484
+  def load_tokens_result; end
+
+  # Returns the value of attribute serialized.
+  #
+  # source://prism//lib/prism/serialize.rb#87
+  def serialized; end
+
+  # Returns the value of attribute source.
+  #
+  # source://prism//lib/prism/serialize.rb#88
+  def source; end
+
+  # Returns the value of attribute start_line.
+  #
+  # source://prism//lib/prism/serialize.rb#89
+  def start_line; end
+
+  private
+
+  # source://prism//lib/prism/serialize.rb#596
+  def load_constant(index); end
+
+  # source://prism//lib/prism/serialize.rb#549
+  def load_double; end
+
+  # source://prism//lib/prism/serialize.rb#564
+  def load_embedded_string; end
+
+  # source://prism//lib/prism/serialize.rb#626
+  def load_error_level; end
+
+  # source://prism//lib/prism/serialize.rb#538
+  def load_integer; end
+
+  # source://prism//lib/prism/serialize.rb#580
+  def load_location; end
+
+  # source://prism//lib/prism/serialize.rb#584
+  def load_location_object; end
+
+  # source://prism//lib/prism/serialize.rb#655
+  def load_node; end
+
+  # source://prism//lib/prism/serialize.rb#621
+  def load_optional_constant; end
+
+  # source://prism//lib/prism/serialize.rb#588
+  def load_optional_location; end
+
+  # source://prism//lib/prism/serialize.rb#592
+  def load_optional_location_object; end
+
+  # source://prism//lib/prism/serialize.rb#557
+  def load_optional_node; end
+
+  # source://prism//lib/prism/serialize.rb#617
+  def load_required_constant; end
+
+  # source://prism//lib/prism/serialize.rb#568
+  def load_string; end
+
+  # source://prism//lib/prism/serialize.rb#553
+  def load_uint32; end
+
+  # source://prism//lib/prism/serialize.rb#533
+  def load_varsint; end
+
+  # variable-length integer using https://en.wikipedia.org/wiki/LEB128
+  # This is also what protobuf uses: https://protobuf.dev/programming-guides/encoding/#varints
+  #
+  # source://prism//lib/prism/serialize.rb#519
+  def load_varuint; end
+
+  # source://prism//lib/prism/serialize.rb#641
+  def load_warning_level; end
+end
+
+# source://prism//lib/prism/serialize.rb#138
+Prism::Serialize::Loader::DIAGNOSTIC_TYPES = T.let(T.unsafe(nil), Array)
+
+# StringIO is synchronized and that adds a high overhead on TruffleRuby.
+#
+# source://prism//lib/prism/serialize.rb#83
+Prism::Serialize::Loader::FastStringIO = StringIO
+
+# The major version of prism that we are expecting to find in the serialized
+# strings.
+#
+# source://prism//lib/prism/serialize.rb#17
+Prism::Serialize::MAJOR_VERSION = T.let(T.unsafe(nil), Integer)
+
+# The minor version of prism that we are expecting to find in the serialized
+# strings.
+#
+# source://prism//lib/prism/serialize.rb#21
+Prism::Serialize::MINOR_VERSION = T.let(T.unsafe(nil), Integer)
+
+# The patch version of prism that we are expecting to find in the serialized
+# strings.
+#
+# source://prism//lib/prism/serialize.rb#25
+Prism::Serialize::PATCH_VERSION = T.let(T.unsafe(nil), Integer)
+
+# The token types that can be indexed by their enum values.
+#
+# source://prism//lib/prism/serialize.rb#1737
+Prism::Serialize::TOKEN_TYPES = T.let(T.unsafe(nil), Array)
+
+# This node wraps a constant write to indicate that when the value is written, it should have its shareability state modified.
+#
+#     C = { a: 1 }
+#     ^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#14686
+class Prism::ShareableConstantNode < ::Prism::Node
+  # Initialize a new ShareableConstantNode node.
+  #
+  # @return [ShareableConstantNode] a new instance of ShareableConstantNode
+  #
+  # source://prism//lib/prism/node.rb#14688
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      write: T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, write); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#14764
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#14697
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14702
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#14712
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#14707
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode) -> ShareableConstantNode
+  #
+  # source://prism//lib/prism/node.rb#14717
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      write: T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode)
+    ).returns(Prism::ShareableConstantNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), write: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14702
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode }
+  #
+  # source://prism//lib/prism/node.rb#14725
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def experimental_copy?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#14740
+  sig { returns(T::Boolean) }
+  def experimental_copy?; end
+
+  # def experimental_everything?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#14735
+  sig { returns(T::Boolean) }
+  def experimental_everything?; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#14748
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def literal?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#14730
+  sig { returns(T::Boolean) }
+  def literal?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#14753
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The constant write that should be modified with the shareability state.
+  #
+  # source://prism//lib/prism/node.rb#14745
+  sig do
+    returns(T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode))
+  end
+  def write; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#14758
+    def type; end
+  end
+end
+
+# Flags for shareable constant nodes.
+#
+# source://prism//lib/prism/node.rb#16816
+module Prism::ShareableConstantNodeFlags; end
+
+# constant writes that should be modified with shareable constant value experimental copy
+#
+# source://prism//lib/prism/node.rb#16824
+Prism::ShareableConstantNodeFlags::EXPERIMENTAL_COPY = T.let(T.unsafe(nil), Integer)
+
+# constant writes that should be modified with shareable constant value experimental everything
+#
+# source://prism//lib/prism/node.rb#16821
+Prism::ShareableConstantNodeFlags::EXPERIMENTAL_EVERYTHING = T.let(T.unsafe(nil), Integer)
+
+# constant writes that should be modified with shareable constant value literal
+#
+# source://prism//lib/prism/node.rb#16818
+Prism::ShareableConstantNodeFlags::LITERAL = T.let(T.unsafe(nil), Integer)
+
+# Represents a singleton class declaration involving the `class` keyword.
+#
+#     class << self end
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#14775
+class Prism::SingletonClassNode < ::Prism::Node
+  # Initialize a new SingletonClassNode node.
+  #
+  # @return [SingletonClassNode] a new instance of SingletonClassNode
+  #
+  # source://prism//lib/prism/node.rb#14777
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      class_keyword_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      expression: Prism::Node,
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      end_keyword_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#14888
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#14791
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader body: StatementsNode | BeginNode | nil
+  #
+  # source://prism//lib/prism/node.rb#14847
+  sig { returns(T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14796
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def class_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#14857
+  sig { returns(String) }
+  def class_keyword; end
+
+  # attr_reader class_keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#14830
+  sig { returns(Prism::Location) }
+  def class_keyword_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#14809
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#14801
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?operator_loc: Location, ?expression: Prism::node, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location) -> SingletonClassNode
+  #
+  # source://prism//lib/prism/node.rb#14814
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      class_keyword_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      expression: Prism::Node,
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::SingletonClassNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14796
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Prism::node, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#14822
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#14867
+  sig { returns(String) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#14850
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  # attr_reader expression: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#14844
+  sig { returns(Prism::Node) }
+  def expression; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#14872
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[Symbol]
+  #
+  # source://prism//lib/prism/node.rb#14827
+  sig { returns(T::Array[Symbol]) }
+  def locals; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#14862
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#14837
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#14877
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#14882
+    def type; end
+  end
+end
+
+# This represents a source of Ruby code that has been parsed. It is used in
+# conjunction with locations to allow them to resolve line numbers and source
+# ranges.
+#
+# source://prism//lib/prism/parse_result.rb#7
+class Prism::Source
+  # Create a new source object with the given source code.
+  #
+  # @return [Source] a new instance of Source
+  #
+  # source://prism//lib/prism/parse_result.rb#45
+  sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
+  def initialize(source, start_line = T.unsafe(nil), offsets = T.unsafe(nil)); end
+
+  # Return the column number in characters for the given byte offset.
+  #
+  # source://prism//lib/prism/parse_result.rb#97
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def character_column(byte_offset); end
+
+  # Return the character offset for the given byte offset.
+  #
+  # source://prism//lib/prism/parse_result.rb#92
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def character_offset(byte_offset); end
+
+  # Generate a cache that targets a specific encoding for calculating code
+  # unit offsets.
+  #
+  # source://prism//lib/prism/parse_result.rb#125
+  sig do
+    params(
+      encoding: Encoding
+    ).returns(T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer)))
+  end
+  def code_units_cache(encoding); end
+
+  # Returns the column number in code units for the given encoding for the
+  # given byte offset.
+  #
+  # source://prism//lib/prism/parse_result.rb#131
+  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
+  def code_units_column(byte_offset, encoding); end
+
+  # Returns the offset from the start of the file for the given byte offset
+  # counting in code units for the given encoding.
+  #
+  # This method is tested with UTF-8, UTF-16, and UTF-32. If there is the
+  # concept of code units that differs from the number of characters in other
+  # encodings, it is not captured here.
+  #
+  # We purposefully replace invalid and undefined characters with replacement
+  # characters in this conversion. This happens for two reasons. First, it's
+  # possible that the given byte offset will not occur on a character
+  # boundary. Second, it's possible that the source code will contain a
+  # character that has no equivalent in the given encoding.
+  #
+  # source://prism//lib/prism/parse_result.rb#113
+  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
+  def code_units_offset(byte_offset, encoding); end
+
+  # Return the column number for the given byte offset.
+  #
+  # source://prism//lib/prism/parse_result.rb#87
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def column(byte_offset); end
+
+  # Returns the encoding of the source code, which is set by parameters to the
+  # parser or by the encoding magic comment.
+  #
+  # source://prism//lib/prism/parse_result.rb#53
+  sig { returns(Encoding) }
+  def encoding; end
+
+  # Binary search through the offsets to find the line number for the given
+  # byte offset.
+  #
+  # source://prism//lib/prism/parse_result.rb#70
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def line(byte_offset); end
+
+  # Returns the byte offset of the end of the line corresponding to the given
+  # byte offset.
+  #
+  # source://prism//lib/prism/parse_result.rb#82
+  def line_end(byte_offset); end
+
+  # Return the byte offset of the start of the line corresponding to the given
+  # byte offset.
+  #
+  # source://prism//lib/prism/parse_result.rb#76
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def line_start(byte_offset); end
+
+  # Returns the lines of the source code as an array of strings.
+  #
+  # source://prism//lib/prism/parse_result.rb#58
+  sig { returns(T::Array[String]) }
+  def lines; end
+
+  # The list of newline byte offsets in the source code.
+  #
+  # source://prism//lib/prism/parse_result.rb#42
+  sig { returns(T::Array[Integer]) }
+  def offsets; end
+
+  # Perform a byteslice on the source code using the given byte offset and
+  # byte length.
+  #
+  # source://prism//lib/prism/parse_result.rb#64
+  sig { params(byte_offset: Integer, length: Integer).returns(String) }
+  def slice(byte_offset, length); end
+
+  # The source code that this source object represents.
+  #
+  # source://prism//lib/prism/parse_result.rb#36
+  sig { returns(String) }
+  def source; end
+
+  # The line number where this source starts.
+  #
+  # source://prism//lib/prism/parse_result.rb#39
+  sig { returns(Integer) }
+  def start_line; end
+
+  private
+
+  # Binary search through the offsets to find the line number for the given
+  # byte offset.
+  #
+  # source://prism//lib/prism/parse_result.rb#139
+  def find_line(byte_offset); end
+
+  class << self
+    # Create a new source object with the given source code. This method should
+    # be used instead of `new` and it will return either a `Source` or a
+    # specialized and more performant `ASCIISource` if no multibyte characters
+    # are present in the source code.
+    #
+    # source://prism//lib/prism/parse_result.rb#12
+    def for(source, start_line = T.unsafe(nil), offsets = T.unsafe(nil)); end
+  end
+end
+
+# Represents the use of the `__ENCODING__` keyword.
+#
+#     __ENCODING__
+#     ^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#14904
+class Prism::SourceEncodingNode < ::Prism::Node
+  # Initialize a new SourceEncodingNode node.
+  #
+  # @return [SourceEncodingNode] a new instance of SourceEncodingNode
+  #
+  # source://prism//lib/prism/node.rb#14906
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void }
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#14963
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#14914
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14919
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#14929
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#14924
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SourceEncodingNode
+  #
+  # source://prism//lib/prism/node.rb#14934
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::SourceEncodingNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14919
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  #
+  # source://prism//lib/prism/node.rb#14942
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#14947
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#14952
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#14957
+    def type; end
+  end
+end
+
+# Represents the use of the `__FILE__` keyword.
+#
+#     __FILE__
+#     ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#14972
+class Prism::SourceFileNode < ::Prism::Node
+  # Initialize a new SourceFileNode node.
+  #
+  # @return [SourceFileNode] a new instance of SourceFileNode
+  #
+  # source://prism//lib/prism/node.rb#14974
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      filepath: String
+    ).void
+  end
+  def initialize(source, node_id, location, flags, filepath); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#15055
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#14983
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14988
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#14998
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#14993
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?filepath: String) -> SourceFileNode
+  #
+  # source://prism//lib/prism/node.rb#15003
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      filepath: String
+    ).returns(Prism::SourceFileNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), filepath: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#14988
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, filepath: String }
+  #
+  # source://prism//lib/prism/node.rb#15011
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # Represents the file path being parsed. This corresponds directly to the `filepath` option given to the various `Prism::parse*` APIs.
+  #
+  # source://prism//lib/prism/node.rb#15036
+  sig { returns(String) }
+  def filepath; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#15021
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#15016
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def frozen?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#15026
+  sig { returns(T::Boolean) }
+  def frozen?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#15039
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def mutable?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#15031
+  sig { returns(T::Boolean) }
+  def mutable?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#15044
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#15049
+    def type; end
+  end
+end
+
+# Represents the use of the `__LINE__` keyword.
+#
+#     __LINE__
+#     ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#15066
+class Prism::SourceLineNode < ::Prism::Node
+  # Initialize a new SourceLineNode node.
+  #
+  # @return [SourceLineNode] a new instance of SourceLineNode
+  #
+  # source://prism//lib/prism/node.rb#15068
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void }
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#15125
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#15076
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15081
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#15091
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#15086
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SourceLineNode
+  #
+  # source://prism//lib/prism/node.rb#15096
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::SourceLineNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15081
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  #
+  # source://prism//lib/prism/node.rb#15104
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#15109
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#15114
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#15119
+    def type; end
+  end
+end
+
+# Represents the use of the splat operator.
+#
+#     [*a]
+#      ^^
+#
+# source://prism//lib/prism/node.rb#15134
+class Prism::SplatNode < ::Prism::Node
+  # Initialize a new SplatNode node.
+  #
+  # @return [SplatNode] a new instance of SplatNode
+  #
+  # source://prism//lib/prism/node.rb#15136
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      operator_loc: Prism::Location,
+      expression: T.nilable(Prism::Node)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, operator_loc, expression); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#15212
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#15146
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15151
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#15163
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#15156
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?expression: Prism::node?) -> SplatNode
+  #
+  # source://prism//lib/prism/node.rb#15168
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      operator_loc: Prism::Location,
+      expression: T.nilable(Prism::Node)
+    ).returns(Prism::SplatNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15151
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, expression: Prism::node? }
+  #
+  # source://prism//lib/prism/node.rb#15176
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader expression: Prism::node?
+  #
+  # source://prism//lib/prism/node.rb#15188
+  sig { returns(T.nilable(Prism::Node)) }
+  def expression; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#15196
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  #
+  # source://prism//lib/prism/node.rb#15191
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#15181
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#15201
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#15206
+    def type; end
+  end
+end
+
+# Represents a set of statements contained within some scope.
+#
+#     foo; bar; baz
+#     ^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#15223
+class Prism::StatementsNode < ::Prism::Node
+  # Initialize a new StatementsNode node.
+  #
+  # @return [StatementsNode] a new instance of StatementsNode
+  #
+  # source://prism//lib/prism/node.rb#15225
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      body: T::Array[Prism::Node]
+    ).void
+  end
+  def initialize(source, node_id, location, flags, body); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#15286
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#15234
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader body: Array[Prism::node]
+  #
+  # source://prism//lib/prism/node.rb#15267
+  sig { returns(T::Array[Prism::Node]) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15239
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#15249
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#15244
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?body: Array[Prism::node]) -> StatementsNode
+  #
+  # source://prism//lib/prism/node.rb#15254
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      body: T::Array[Prism::Node]
+    ).returns(Prism::StatementsNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), body: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15239
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, body: Array[Prism::node] }
+  #
+  # source://prism//lib/prism/node.rb#15262
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#15270
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#15275
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#15280
+    def type; end
+  end
+end
+
+# Flags for string nodes.
+#
+# source://prism//lib/prism/node.rb#16828
+module Prism::StringFlags; end
+
+# internal bytes forced the encoding to binary
+#
+# source://prism//lib/prism/node.rb#16833
+Prism::StringFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to UTF-8
+#
+# source://prism//lib/prism/node.rb#16830
+Prism::StringFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# source://prism//lib/prism/node.rb#16836
+Prism::StringFlags::FROZEN = T.let(T.unsafe(nil), Integer)
+
+# source://prism//lib/prism/node.rb#16839
+Prism::StringFlags::MUTABLE = T.let(T.unsafe(nil), Integer)
+
+# Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string.
+#
+#     "foo"
+#     ^^^^^
+#
+#     %w[foo]
+#        ^^^
+#
+#     "foo #{bar} baz"
+#      ^^^^      ^^^^
+#
+# source://prism//lib/prism/node.rb#15303
+class Prism::StringNode < ::Prism::Node
+  include ::Prism::HeredocQuery
+
+  # Initialize a new StringNode node.
+  #
+  # @return [StringNode] a new instance of StringNode
+  #
+  # source://prism//lib/prism/node.rb#15305
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      content_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      unescaped: String
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#15437
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#15317
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15322
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#15416
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#15390
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#15332
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#15327
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def content: () -> String
+  #
+  # source://prism//lib/prism/node.rb#15411
+  sig { returns(String) }
+  def content; end
+
+  # attr_reader content_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#15383
+  sig { returns(Prism::Location) }
+  def content_loc; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?content_loc: Location, ?closing_loc: Location?, ?unescaped: String) -> StringNode
+  #
+  # source://prism//lib/prism/node.rb#15337
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      content_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      unescaped: String
+    ).returns(Prism::StringNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15322
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String }
+  #
+  # source://prism//lib/prism/node.rb#15345
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#15355
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#15350
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def frozen?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#15360
+  sig { returns(T::Boolean) }
+  def frozen?; end
+
+  sig { returns(T::Boolean) }
+  def heredoc?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#15421
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def mutable?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#15365
+  sig { returns(T::Boolean) }
+  def mutable?; end
+
+  # def opening: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#15406
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#15370
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # Occasionally it's helpful to treat a string as if it were interpolated so
+  # that there's a consistent interface for working with strings.
+  #
+  # source://prism//lib/prism/node_ext.rb#72
+  sig { returns(Prism::InterpolatedStringNode) }
+  def to_interpolated; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#15426
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader unescaped: String
+  #
+  # source://prism//lib/prism/node.rb#15403
+  sig { returns(String) }
+  def unescaped; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#15431
+    def type; end
+  end
+end
+
+# Represents the use of the `super` keyword with parentheses or arguments.
+#
+#     super()
+#     ^^^^^^^
+#
+#     super foo, bar
+#     ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#15454
+class Prism::SuperNode < ::Prism::Node
+  # Initialize a new SuperNode node.
+  #
+  # @return [SuperNode] a new instance of SuperNode
+  #
+  # source://prism//lib/prism/node.rb#15456
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      lparen_loc: T.nilable(Prism::Location),
+      arguments: T.nilable(Prism::ArgumentsNode),
+      rparen_loc: T.nilable(Prism::Location),
+      block: T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))
+    ).void
+  end
+  def initialize(source, node_id, location, flags, keyword_loc, lparen_loc, arguments, rparen_loc, block); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#15575
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#15469
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism//lib/prism/node.rb#15525
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # attr_reader block: BlockNode | BlockArgumentNode | nil
+  #
+  # source://prism//lib/prism/node.rb#15541
+  sig { returns(T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))) }
+  def block; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15474
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#15487
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#15479
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> SuperNode
+  #
+  # source://prism//lib/prism/node.rb#15492
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      lparen_loc: T.nilable(Prism::Location),
+      arguments: T.nilable(Prism::ArgumentsNode),
+      rparen_loc: T.nilable(Prism::Location),
+      block: T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))
+    ).returns(Prism::SuperNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15474
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: BlockNode | BlockArgumentNode | nil }
+  #
+  # source://prism//lib/prism/node.rb#15500
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#15559
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#15544
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#15505
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # def lparen: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#15549
+  sig { returns(T.nilable(String)) }
+  def lparen; end
+
+  # attr_reader lparen_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#15512
+  sig { returns(T.nilable(Prism::Location)) }
+  def lparen_loc; end
+
+  # def rparen: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#15554
+  sig { returns(T.nilable(String)) }
+  def rparen; end
+
+  # attr_reader rparen_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#15528
+  sig { returns(T.nilable(Prism::Location)) }
+  def rparen_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#15564
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#15569
+    def type; end
+  end
+end
+
+# Flags for symbol nodes.
+#
+# source://prism//lib/prism/node.rb#16843
+module Prism::SymbolFlags; end
+
+# internal bytes forced the encoding to binary
+#
+# source://prism//lib/prism/node.rb#16848
+Prism::SymbolFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to US-ASCII
+#
+# source://prism//lib/prism/node.rb#16851
+Prism::SymbolFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to UTF-8
+#
+# source://prism//lib/prism/node.rb#16845
+Prism::SymbolFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# Represents a symbol literal or a symbol contained within a `%i` list.
+#
+#     :foo
+#     ^^^^
+#
+#     %i[foo]
+#        ^^^
+#
+# source://prism//lib/prism/node.rb#15592
+class Prism::SymbolNode < ::Prism::Node
+  # Initialize a new SymbolNode node.
+  #
+  # @return [SymbolNode] a new instance of SymbolNode
+  #
+  # source://prism//lib/prism/node.rb#15594
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      value_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location),
+      unescaped: String
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, value_loc, closing_loc, unescaped); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#15727
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#15606
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15611
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#15706
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#15680
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#15621
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#15616
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?value_loc: Location?, ?closing_loc: Location?, ?unescaped: String) -> SymbolNode
+  #
+  # source://prism//lib/prism/node.rb#15626
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      value_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location),
+      unescaped: String
+    ).returns(Prism::SymbolNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), value_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15611
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String }
+  #
+  # source://prism//lib/prism/node.rb#15634
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#15644
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#15649
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#15639
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#15711
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#15696
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#15654
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#15716
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader unescaped: String
+  #
+  # source://prism//lib/prism/node.rb#15693
+  sig { returns(String) }
+  def unescaped; end
+
+  # def value: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#15701
+  sig { returns(T.nilable(String)) }
+  def value; end
+
+  # attr_reader value_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#15667
+  sig { returns(T.nilable(Prism::Location)) }
+  def value_loc; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#15721
+    def type; end
+  end
+end
+
+# This represents a token from the Ruby source.
+#
+# source://prism//lib/prism/parse_result.rb#799
+class Prism::Token
+  # Create a new token object with the given type, value, and location.
+  #
+  # @return [Token] a new instance of Token
+  #
+  # source://prism//lib/prism/parse_result.rb#811
+  sig { params(source: Prism::Source, type: Symbol, value: String, location: T.any(Integer, Prism::Location)).void }
+  def initialize(source, type, value, location); end
+
+  # Returns true if the given other token is equal to this token.
+  #
+  # source://prism//lib/prism/parse_result.rb#846
+  sig { params(other: T.untyped).returns(T::Boolean) }
+  def ==(other); end
+
+  # Implement the hash pattern matching interface for Token.
+  #
+  # source://prism//lib/prism/parse_result.rb#819
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # Returns a string representation of this token.
+  #
+  # source://prism//lib/prism/parse_result.rb#853
+  def inspect; end
+
+  # A Location object representing the location of this token in the source.
+  #
+  # source://prism//lib/prism/parse_result.rb#824
+  sig { returns(Prism::Location) }
+  def location; end
+
+  # Implement the pretty print interface for Token.
+  #
+  # source://prism//lib/prism/parse_result.rb#831
+  sig { params(q: T.untyped).void }
+  def pretty_print(q); end
+
+  # The type of token that this token is.
+  #
+  # source://prism//lib/prism/parse_result.rb#805
+  sig { returns(Symbol) }
+  def type; end
+
+  # A byteslice of the source that this token represents.
+  #
+  # source://prism//lib/prism/parse_result.rb#808
+  sig { returns(String) }
+  def value; end
+
+  private
+
+  # The Source object that represents the source this token came from.
+  #
+  # source://prism//lib/prism/parse_result.rb#801
+  sig { returns(Prism::Source) }
+  def source; end
+end
+
+# This module is responsible for converting the prism syntax tree into other
+# syntax trees.
+#
+# source://prism//lib/prism/translation.rb#6
+module Prism::Translation; end
+
+# This class is the entry-point for converting a prism syntax tree into the
+# whitequark/parser gem's syntax tree. It inherits from the base parser for
+# the parser gem, and overrides the parse* methods to parse with prism and
+# then translate.
+#
+# source://prism//lib/prism/translation/parser.rb#16
+class Prism::Translation::Parser < ::Parser::Base
+  # The default encoding for Ruby files is UTF-8.
+  #
+  # source://prism//lib/prism/translation/parser.rb#41
+  def default_encoding; end
+
+  # Parses a source buffer and returns the AST.
+  #
+  # source://prism//lib/prism/translation/parser.rb#49
+  def parse(source_buffer); end
+
+  # Parses a source buffer and returns the AST and the source code comments.
+  #
+  # source://prism//lib/prism/translation/parser.rb#62
+  def parse_with_comments(source_buffer); end
+
+  # Parses a source buffer and returns the AST, the source code comments,
+  # and the tokens emitted by the lexer.
+  #
+  # source://prism//lib/prism/translation/parser.rb#79
+  def tokenize(source_buffer, recover = T.unsafe(nil)); end
+
+  # Since prism resolves num params for us, we don't need to support this
+  # kind of logic here.
+  #
+  # source://prism//lib/prism/translation/parser.rb#105
+  def try_declare_numparam(node); end
+
+  # source://prism//lib/prism/translation/parser.rb#36
+  sig { overridable.returns(Integer) }
+  def version; end
+
+  # source://prism//lib/prism/translation/parser.rb#45
+  def yyerror; end
+
+  private
+
+  # Build the parser gem AST from the prism AST.
+  #
+  # source://prism//lib/prism/translation/parser.rb#263
+  def build_ast(program, offset_cache); end
+
+  # Build the parser gem comments from the prism comments.
+  #
+  # source://prism//lib/prism/translation/parser.rb#268
+  def build_comments(comments, offset_cache); end
+
+  # Prism deals with offsets in bytes, while the parser gem deals with
+  # offsets in characters. We need to handle this conversion in order to
+  # build the parser gem AST.
+  #
+  # If the bytesize of the source is the same as the length, then we can
+  # just use the offset directly. Otherwise, we build an array where the
+  # index is the byte offset and the value is the character offset.
+  #
+  # source://prism//lib/prism/translation/parser.rb#246
+  def build_offset_cache(source); end
+
+  # Build a range from a prism location.
+  #
+  # source://prism//lib/prism/translation/parser.rb#280
+  def build_range(location, offset_cache); end
+
+  # Build the parser gem tokens from the prism tokens.
+  #
+  # source://prism//lib/prism/translation/parser.rb#275
+  def build_tokens(tokens, offset_cache); end
+
+  # Converts the version format handled by Parser to the format handled by Prism.
+  #
+  # source://prism//lib/prism/translation/parser.rb#289
+  def convert_for_prism(version); end
+
+  # Build a diagnostic from the given prism parse error.
+  #
+  # source://prism//lib/prism/translation/parser.rb#124
+  def error_diagnostic(error, offset_cache); end
+
+  # If there was a error generated during the parse, then raise an
+  # appropriate syntax error. Otherwise return the result.
+  #
+  # source://prism//lib/prism/translation/parser.rb#224
+  def unwrap(result, offset_cache); end
+
+  # This is a hook to allow consumers to disable some errors if they don't
+  # want them to block creating the syntax tree.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/translation/parser.rb#113
+  def valid_error?(error); end
+
+  # This is a hook to allow consumers to disable some warnings if they don't
+  # want them to block creating the syntax tree.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/translation/parser.rb#119
+  def valid_warning?(warning); end
+
+  # Build a diagnostic from the given prism parse warning.
+  #
+  # source://prism//lib/prism/translation/parser.rb#197
+  def warning_diagnostic(warning, offset_cache); end
+end
+
+# This class is the entry-point for Ruby 3.3 of `Prism::Translation::Parser`.
+#
+# source://prism//lib/prism/translation/parser33.rb#6
+class Prism::Translation::Parser33 < ::Prism::Translation::Parser
+  # source://prism//lib/prism/translation/parser33.rb#7
+  sig { override.returns(Integer) }
+  def version; end
+end
+
+# This class is the entry-point for Ruby 3.4 of `Prism::Translation::Parser`.
+#
+# source://prism//lib/prism/translation/parser34.rb#6
+class Prism::Translation::Parser34 < ::Prism::Translation::Parser
+  # source://prism//lib/prism/translation/parser34.rb#7
+  sig { override.returns(Integer) }
+  def version; end
+end
+
+# A visitor that knows how to convert a prism syntax tree into the
+# whitequark/parser gem's syntax tree.
+#
+# source://prism//lib/prism/translation/parser/compiler.rb#8
+class Prism::Translation::Parser::Compiler < ::Prism::Compiler
+  # Initialize a new compiler with the given parser, offset cache, and
+  # options.
+  #
+  # @return [Compiler] a new instance of Compiler
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#39
+  def initialize(parser, offset_cache, forwarding: T.unsafe(nil), in_destructure: T.unsafe(nil), in_pattern: T.unsafe(nil)); end
+
+  # The Parser::Builders::Default instance that is being used to build the
+  # AST.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#18
+  def builder; end
+
+  # The types of values that can be forwarded in the current scope.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#29
+  def forwarding; end
+
+  # Whether or not the current node is in a destructure.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#32
+  def in_destructure; end
+
+  # Whether or not the current node is in a pattern.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#35
+  def in_pattern; end
+
+  # The offset cache that is used to map between byte and character
+  # offsets in the file.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#26
+  def offset_cache; end
+
+  # The Parser::Base instance that is being used to build the AST.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#14
+  def parser; end
+
+  # The Parser::Source::Buffer instance that is holding a reference to the
+  # source code.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#22
+  def source_buffer; end
+
+  # alias $foo $bar
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#58
+  def visit_alias_global_variable_node(node); end
+
+  # alias foo bar
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#52
+  def visit_alias_method_node(node); end
+
+  # foo => bar | baz
+  #        ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#64
+  def visit_alternation_pattern_node(node); end
+
+  # a and b
+  # ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#70
+  def visit_and_node(node); end
+
+  # foo(bar)
+  #     ^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#105
+  def visit_arguments_node(node); end
+
+  # []
+  # ^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#76
+  def visit_array_node(node); end
+
+  # foo => [bar]
+  #        ^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#82
+  def visit_array_pattern_node(node); end
+
+  # { a: 1 }
+  #   ^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#111
+  def visit_assoc_node(node); end
+
+  # def foo(**); bar(**); end
+  #                  ^^
+  #
+  # { **foo }
+  #   ^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#160
+  def visit_assoc_splat_node(node); end
+
+  # $+
+  # ^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#172
+  def visit_back_reference_read_node(node); end
+
+  # begin end
+  # ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#178
+  def visit_begin_node(node); end
+
+  # foo(&bar)
+  #     ^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#216
+  def visit_block_argument_node(node); end
+
+  # foo { |; bar| }
+  #          ^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#222
+  def visit_block_local_variable_node(node); end
+
+  # A block on a keyword or method call.
+  #
+  # @raise [CompilationError]
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#227
+  def visit_block_node(node); end
+
+  # def foo(&bar); end
+  #         ^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#233
+  def visit_block_parameter_node(node); end
+
+  # A block's parameters.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#238
+  def visit_block_parameters_node(node); end
+
+  # break
+  # ^^^^^
+  #
+  # break foo
+  # ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#247
+  def visit_break_node(node); end
+
+  # foo.bar &&= baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#352
+  def visit_call_and_write_node(node); end
+
+  # foo
+  # ^^^
+  #
+  # foo.bar
+  # ^^^^^^^
+  #
+  # foo.bar() {}
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#259
+  def visit_call_node(node); end
+
+  # foo.bar += baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#333
+  def visit_call_operator_write_node(node); end
+
+  # foo.bar ||= baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#371
+  def visit_call_or_write_node(node); end
+
+  # foo.bar, = 1
+  # ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#390
+  def visit_call_target_node(node); end
+
+  # foo => bar => baz
+  #        ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#402
+  def visit_capture_pattern_node(node); end
+
+  # case foo; in bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#421
+  def visit_case_match_node(node); end
+
+  # case foo; when bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#408
+  def visit_case_node(node); end
+
+  # class Foo; end
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#434
+  def visit_class_node(node); end
+
+  # @@foo &&= bar
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#473
+  def visit_class_variable_and_write_node(node); end
+
+  # @@foo += bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#463
+  def visit_class_variable_operator_write_node(node); end
+
+  # @@foo ||= bar
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#483
+  def visit_class_variable_or_write_node(node); end
+
+  # @@foo
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#447
+  def visit_class_variable_read_node(node); end
+
+  # @@foo, = bar
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#493
+  def visit_class_variable_target_node(node); end
+
+  # @@foo = 1
+  # ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#453
+  def visit_class_variable_write_node(node); end
+
+  # Foo &&= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#524
+  def visit_constant_and_write_node(node); end
+
+  # Foo += bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#514
+  def visit_constant_operator_write_node(node); end
+
+  # Foo ||= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#534
+  def visit_constant_or_write_node(node); end
+
+  # Foo::Bar &&= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#590
+  def visit_constant_path_and_write_node(node); end
+
+  # Foo::Bar
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#550
+  def visit_constant_path_node(node); end
+
+  # Foo::Bar += baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#580
+  def visit_constant_path_operator_write_node(node); end
+
+  # Foo::Bar ||= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#600
+  def visit_constant_path_or_write_node(node); end
+
+  # Foo::Bar, = baz
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#610
+  def visit_constant_path_target_node(node); end
+
+  # Foo::Bar = 1
+  # ^^^^^^^^^^^^
+  #
+  # Foo::Foo, Bar::Bar = 1
+  # ^^^^^^^^  ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#570
+  def visit_constant_path_write_node(node); end
+
+  # Foo
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#499
+  def visit_constant_read_node(node); end
+
+  # Foo, = bar
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#544
+  def visit_constant_target_node(node); end
+
+  # Foo = 1
+  # ^^^^^^^
+  #
+  # Foo, Bar = 1
+  # ^^^  ^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#508
+  def visit_constant_write_node(node); end
+
+  # def foo; end
+  # ^^^^^^^^^^^^
+  #
+  # def self.foo; end
+  # ^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#619
+  def visit_def_node(node); end
+
+  # defined? a
+  # ^^^^^^^^^^
+  #
+  # defined?(a)
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#666
+  def visit_defined_node(node); end
+
+  # if foo then bar else baz end
+  #                 ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#678
+  def visit_else_node(node); end
+
+  # "foo #{bar}"
+  #      ^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#684
+  def visit_embedded_statements_node(node); end
+
+  # "foo #@bar"
+  #      ^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#694
+  def visit_embedded_variable_node(node); end
+
+  # begin; foo; ensure; bar; end
+  #             ^^^^^^^^^^^^
+  #
+  # @raise [CompilationError]
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#700
+  def visit_ensure_node(node); end
+
+  # false
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#706
+  def visit_false_node(node); end
+
+  # foo => [*, bar, *]
+  #        ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#712
+  def visit_find_pattern_node(node); end
+
+  # 0..5
+  # ^^^^
+  # if foo .. bar; end
+  #    ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1475
+  def visit_flip_flop_node(node); end
+
+  # 1.0
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#724
+  def visit_float_node(node); end
+
+  # for foo in bar do end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#730
+  def visit_for_node(node); end
+
+  # def foo(...); bar(...); end
+  #                   ^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#748
+  def visit_forwarding_arguments_node(node); end
+
+  # def foo(...); end
+  #         ^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#754
+  def visit_forwarding_parameter_node(node); end
+
+  # super
+  # ^^^^^
+  #
+  # super {}
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#763
+  def visit_forwarding_super_node(node); end
+
+  # $foo &&= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#801
+  def visit_global_variable_and_write_node(node); end
+
+  # $foo += bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#791
+  def visit_global_variable_operator_write_node(node); end
+
+  # $foo ||= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#811
+  def visit_global_variable_or_write_node(node); end
+
+  # $foo
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#775
+  def visit_global_variable_read_node(node); end
+
+  # $foo, = bar
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#821
+  def visit_global_variable_target_node(node); end
+
+  # $foo = 1
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#781
+  def visit_global_variable_write_node(node); end
+
+  # {}
+  # ^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#827
+  def visit_hash_node(node); end
+
+  # foo => {}
+  #        ^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#837
+  def visit_hash_pattern_node(node); end
+
+  # if foo then bar end
+  # ^^^^^^^^^^^^^^^^^^^
+  #
+  # bar if foo
+  # ^^^^^^^^^^
+  #
+  # foo ? bar : baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#855
+  def visit_if_node(node); end
+
+  # 1i
+  # ^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#897
+  def visit_imaginary_node(node); end
+
+  # { foo: }
+  #   ^^^^
+  #
+  # @raise [CompilationError]
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#903
+  def visit_implicit_node(node); end
+
+  # foo { |bar,| }
+  #           ^
+  #
+  # @raise [CompilationError]
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#909
+  def visit_implicit_rest_node(node); end
+
+  # case foo; in bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#915
+  def visit_in_node(node); end
+
+  # foo[bar] &&= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#959
+  def visit_index_and_write_node(node); end
+
+  # foo[bar] += baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#941
+  def visit_index_operator_write_node(node); end
+
+  # foo[bar] ||= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#977
+  def visit_index_or_write_node(node); end
+
+  # foo[bar], = 1
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#995
+  def visit_index_target_node(node); end
+
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1032
+  def visit_instance_variable_and_write_node(node); end
+
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1022
+  def visit_instance_variable_operator_write_node(node); end
+
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1042
+  def visit_instance_variable_or_write_node(node); end
+
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1006
+  def visit_instance_variable_read_node(node); end
+
+  # @foo, = bar
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1052
+  def visit_instance_variable_target_node(node); end
+
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1012
+  def visit_instance_variable_write_node(node); end
+
+  # 1
+  # ^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1058
+  def visit_integer_node(node); end
+
+  # /foo #{bar}/
+  # ^^^^^^^^^^^^
+  # if /foo #{bar}/ then end
+  #    ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1064
+  def visit_interpolated_match_last_line_node(node); end
+
+  # /foo #{bar}/
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1064
+  def visit_interpolated_regular_expression_node(node); end
+
+  # "foo #{bar}"
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1079
+  def visit_interpolated_string_node(node); end
+
+  # :"foo #{bar}"
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1113
+  def visit_interpolated_symbol_node(node); end
+
+  # `foo #{bar}`
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1123
+  def visit_interpolated_x_string_node(node); end
+
+  # -> { it }
+  #      ^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1137
+  def visit_it_local_variable_read_node(node); end
+
+  # -> { it }
+  # ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1143
+  def visit_it_parameters_node(node); end
+
+  # foo(bar: baz)
+  #     ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1149
+  def visit_keyword_hash_node(node); end
+
+  # def foo(**bar); end
+  #         ^^^^^
+  #
+  # def foo(**); end
+  #         ^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1158
+  def visit_keyword_rest_parameter_node(node); end
+
+  # -> {}
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1167
+  def visit_lambda_node(node); end
+
+  # foo &&= bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1219
+  def visit_local_variable_and_write_node(node); end
+
+  # foo += bar
+  # ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1209
+  def visit_local_variable_operator_write_node(node); end
+
+  # foo ||= bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1229
+  def visit_local_variable_or_write_node(node); end
+
+  # foo
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1193
+  def visit_local_variable_read_node(node); end
+
+  # foo, = bar
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1239
+  def visit_local_variable_target_node(node); end
+
+  # foo = 1
+  # ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1199
+  def visit_local_variable_write_node(node); end
+
+  # /foo/
+  # ^^^^^
+  # if /foo/ then end
+  #    ^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1509
+  def visit_match_last_line_node(node); end
+
+  # foo in bar
+  # ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1249
+  def visit_match_predicate_node(node); end
+
+  # foo => bar
+  # ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1259
+  def visit_match_required_node(node); end
+
+  # /(?<foo>foo)/ =~ bar
+  # ^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1269
+  def visit_match_write_node(node); end
+
+  # A node that is missing from the syntax tree. This is only used in the
+  # case of a syntax error. The parser gem doesn't have such a concept, so
+  # we invent our own here.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1280
+  def visit_missing_node(node); end
+
+  # module Foo; end
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1286
+  def visit_module_node(node); end
+
+  # foo, bar = baz
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1297
+  def visit_multi_target_node(node); end
+
+  # foo, bar = baz
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1307
+  def visit_multi_write_node(node); end
+
+  # next
+  # ^^^^
+  #
+  # next foo
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1330
+  def visit_next_node(node); end
+
+  # nil
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1342
+  def visit_nil_node(node); end
+
+  # def foo(**nil); end
+  #         ^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1348
+  def visit_no_keywords_parameter_node(node); end
+
+  # -> { _1 + _2 }
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1358
+  def visit_numbered_parameters_node(node); end
+
+  # $1
+  # ^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1364
+  def visit_numbered_reference_read_node(node); end
+
+  # def foo(bar: baz); end
+  #         ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1370
+  def visit_optional_keyword_parameter_node(node); end
+
+  # def foo(bar = 1); end
+  #         ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1376
+  def visit_optional_parameter_node(node); end
+
+  # a or b
+  # ^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1382
+  def visit_or_node(node); end
+
+  # def foo(bar, *baz); end
+  #         ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1388
+  def visit_parameters_node(node); end
+
+  # ()
+  # ^^
+  #
+  # (1)
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1427
+  def visit_parentheses_node(node); end
+
+  # foo => ^(bar)
+  #        ^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1437
+  def visit_pinned_expression_node(node); end
+
+  # foo = 1 and bar => ^foo
+  #                    ^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1444
+  def visit_pinned_variable_node(node); end
+
+  # END {}
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1449
+  def visit_post_execution_node(node); end
+
+  # BEGIN {}
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1459
+  def visit_pre_execution_node(node); end
+
+  # The top-level program node.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1469
+  def visit_program_node(node); end
+
+  # 0..5
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1475
+  def visit_range_node(node); end
+
+  # 1r
+  # ^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1497
+  def visit_rational_node(node); end
+
+  # redo
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1503
+  def visit_redo_node(node); end
+
+  # /foo/
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1509
+  def visit_regular_expression_node(node); end
+
+  # def foo(bar:); end
+  #         ^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1535
+  def visit_required_keyword_parameter_node(node); end
+
+  # def foo(bar); end
+  #         ^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1541
+  def visit_required_parameter_node(node); end
+
+  # foo rescue bar
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1547
+  def visit_rescue_modifier_node(node); end
+
+  # begin; rescue; end
+  #        ^^^^^^^
+  #
+  # @raise [CompilationError]
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1565
+  def visit_rescue_node(node); end
+
+  # def foo(*bar); end
+  #         ^^^^
+  #
+  # def foo(*); end
+  #         ^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1574
+  def visit_rest_parameter_node(node); end
+
+  # retry
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1580
+  def visit_retry_node(node); end
+
+  # return
+  # ^^^^^^
+  #
+  # return 1
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1589
+  def visit_return_node(node); end
+
+  # self
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1601
+  def visit_self_node(node); end
+
+  # A shareable constant.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1606
+  def visit_shareable_constant_node(node); end
+
+  # class << self; end
+  # ^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1612
+  def visit_singleton_class_node(node); end
+
+  # __ENCODING__
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1624
+  def visit_source_encoding_node(node); end
+
+  # __FILE__
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1630
+  def visit_source_file_node(node); end
+
+  # __LINE__
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1636
+  def visit_source_line_node(node); end
+
+  # foo(*bar)
+  #     ^^^^
+  #
+  # def foo((bar, *baz)); end
+  #               ^^^^
+  #
+  # def foo(*); bar(*); end
+  #                 ^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1648
+  def visit_splat_node(node); end
+
+  # A list of statements.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1661
+  def visit_statements_node(node); end
+
+  # "foo"
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1667
+  def visit_string_node(node); end
+
+  # super(foo)
+  # ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1709
+  def visit_super_node(node); end
+
+  # :foo
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1732
+  def visit_symbol_node(node); end
+
+  # true
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1764
+  def visit_true_node(node); end
+
+  # undef foo
+  # ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1770
+  def visit_undef_node(node); end
+
+  # unless foo; bar end
+  # ^^^^^^^^^^^^^^^^^^^
+  #
+  # bar unless foo
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1779
+  def visit_unless_node(node); end
+
+  # until foo; bar end
+  # ^^^^^^^^^^^^^^^^^^
+  #
+  # bar until foo
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1809
+  def visit_until_node(node); end
+
+  # case foo; when bar; end
+  #           ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1831
+  def visit_when_node(node); end
+
+  # while foo; bar end
+  # ^^^^^^^^^^^^^^^^^^
+  #
+  # bar while foo
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1849
+  def visit_while_node(node); end
+
+  # `foo`
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1871
+  def visit_x_string_node(node); end
+
+  # yield
+  # ^^^^^
+  #
+  # yield 1
+  # ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1902
+  def visit_yield_node(node); end
+
+  private
+
+  # The parser gem automatically converts \r\n to \n, meaning our offsets
+  # need to be adjusted to always subtract 1 from the length.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#2045
+  def chomped_bytesize(line); end
+
+  # Initialize a new compiler with the given option overrides, used to
+  # visit a subtree with the given options.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1916
+  def copy_compiler(forwarding: T.unsafe(nil), in_destructure: T.unsafe(nil), in_pattern: T.unsafe(nil)); end
+
+  # When *, **, &, or ... are used as an argument in a method call, we
+  # check if they were allowed by the current context. To determine that
+  # we build this lookup table.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1923
+  def find_forwarding(node); end
+
+  # Returns the set of targets for a MultiTargetNode or a MultiWriteNode.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1936
+  def multi_target_elements(node); end
+
+  # Negate the value of a numeric node. This is a special case where you
+  # have a negative sign on one line and then a number on the next line.
+  # In normal Ruby, this will always be a method call. The parser gem,
+  # however, marks this as a numeric literal. We have to massage the tree
+  # here to get it into the correct form.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1948
+  def numeric_negate(message_loc, receiver); end
+
+  # Blocks can have a special set of parameters that automatically expand
+  # when given arrays if they have a single required parameter and no
+  # other parameters.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1962
+  def procarg0?(parameters); end
+
+  # Constructs a new source range from the given start and end offsets.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1979
+  def srange(location); end
+
+  # Constructs a new source range by finding the given tokens between the
+  # given start offset and end offset. If the needle is not found, it
+  # returns nil. Importantly it does not search past newlines or comments.
+  #
+  # Note that end_offset is allowed to be nil, in which case this will
+  # search until the end of the string.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1994
+  def srange_find(start_offset, end_offset, tokens); end
+
+  # Constructs a new source range from the given start and end offsets.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#1984
+  def srange_offsets(start_offset, end_offset); end
+
+  # Transform a location into a token that the parser gem expects.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#2004
+  def token(location); end
+
+  # Visit a block node on a call.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#2009
+  def visit_block(call, block); end
+
+  # Visit a heredoc that can be either a string or an xstring.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#2051
+  def visit_heredoc(node); end
+
+  # Visit a numeric node and account for the optional sign.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#2123
+  def visit_numeric(node, value); end
+
+  # Within the given block, track that we're within a pattern.
+  #
+  # source://prism//lib/prism/translation/parser/compiler.rb#2135
+  def within_pattern; end
+end
+
+# Raised when the tree is malformed or there is a bug in the compiler.
+#
+# source://prism//lib/prism/translation/parser/compiler.rb#10
+class Prism::Translation::Parser::Compiler::CompilationError < ::StandardError; end
+
+# Locations in the parser gem AST are generated using this class. We
+# store a reference to its constant to make it slightly faster to look
+# up.
+#
+# source://prism//lib/prism/translation/parser/compiler.rb#1976
+Prism::Translation::Parser::Compiler::Range = Parser::Source::Range
+
+# source://prism//lib/prism/translation/parser.rb#17
+Prism::Translation::Parser::Diagnostic = Parser::Diagnostic
+
+# Accepts a list of prism tokens and converts them into the expected
+# format for the parser gem.
+#
+# source://prism//lib/prism/translation/parser/lexer.rb#8
+class Prism::Translation::Parser::Lexer
+  # Initialize the lexer with the given source buffer, prism tokens, and
+  # offset cache.
+  #
+  # @return [Lexer] a new instance of Lexer
+  #
+  # source://prism//lib/prism/translation/parser/lexer.rb#217
+  def initialize(source_buffer, lexed, offset_cache); end
+
+  # An array of tuples that contain prism tokens and their associated lex
+  # state when they were lexed.
+  #
+  # source://prism//lib/prism/translation/parser/lexer.rb#210
+  def lexed; end
+
+  # A hash that maps offsets in bytes to offsets in characters.
+  #
+  # source://prism//lib/prism/translation/parser/lexer.rb#213
+  def offset_cache; end
+
+  # The Parser::Source::Buffer that the tokens were lexed from.
+  #
+  # source://prism//lib/prism/translation/parser/lexer.rb#206
+  def source_buffer; end
+
+  # Convert the prism tokens into the expected format for the parser gem.
+  #
+  # source://prism//lib/prism/translation/parser/lexer.rb#227
+  def to_a; end
+
+  private
+
+  # Parse a complex from the string representation.
+  #
+  # source://prism//lib/prism/translation/parser/lexer.rb#409
+  def parse_complex(value); end
+
+  # Parse a float from the string representation.
+  #
+  # source://prism//lib/prism/translation/parser/lexer.rb#402
+  def parse_float(value); end
+
+  # Parse an integer from the string representation.
+  #
+  # source://prism//lib/prism/translation/parser/lexer.rb#395
+  def parse_integer(value); end
+
+  # Parse a rational from the string representation.
+  #
+  # source://prism//lib/prism/translation/parser/lexer.rb#424
+  def parse_rational(value); end
+end
+
+# These constants represent flags in our lex state. We really, really
+# don't want to be using them and we really, really don't want to be
+# exposing them as part of our public API. Unfortunately, we don't have
+# another way of matching the exact tokens that the parser gem expects
+# without them. We should find another way to do this, but in the
+# meantime we'll hide them from the documentation and mark them as
+# private constants.
+#
+# source://prism//lib/prism/translation/parser/lexer.rb#187
+Prism::Translation::Parser::Lexer::EXPR_BEG = T.let(T.unsafe(nil), Integer)
+
+# source://prism//lib/prism/translation/parser/lexer.rb#188
+Prism::Translation::Parser::Lexer::EXPR_LABEL = T.let(T.unsafe(nil), Integer)
+
+# It is used to determine whether `do` is of the token type `kDO` or `kDO_LAMBDA`.
+#
+# NOTE: In edge cases like `-> (foo = -> (bar) {}) do end`, please note that `kDO` is still returned
+# instead of `kDO_LAMBDA`, which is expected: https://github.com/ruby/prism/pull/3046
+#
+# source://prism//lib/prism/translation/parser/lexer.rb#194
+Prism::Translation::Parser::Lexer::LAMBDA_TOKEN_TYPES = T.let(T.unsafe(nil), Array)
+
+# The `PARENTHESIS_LEFT` token in Prism is classified as either `tLPAREN` or `tLPAREN2` in the Parser gem.
+# The following token types are listed as those classified as `tLPAREN`.
+#
+# source://prism//lib/prism/translation/parser/lexer.rb#198
+Prism::Translation::Parser::Lexer::LPAREN_CONVERSION_TOKEN_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://prism//lib/prism/translation/parser/lexer.rb#223
+Prism::Translation::Parser::Lexer::Range = Parser::Source::Range
+
+# The direct translating of types between the two lexers.
+#
+# source://prism//lib/prism/translation/parser/lexer.rb#10
+Prism::Translation::Parser::Lexer::TYPES = T.let(T.unsafe(nil), Hash)
+
+# The parser gem has a list of diagnostics with a hard-coded set of error
+# messages. We create our own diagnostic class in order to set our own
+# error messages.
+#
+# source://prism//lib/prism/translation/parser.rb#23
+class Prism::Translation::Parser::PrismDiagnostic < ::Parser::Diagnostic
+  # Initialize a new diagnostic with the given message and location.
+  #
+  # @return [PrismDiagnostic] a new instance of PrismDiagnostic
+  #
+  # source://prism//lib/prism/translation/parser.rb#28
+  def initialize(message, level, reason, location); end
+
+  # This is the cached message coming from prism.
+  #
+  # source://prism//lib/prism/translation/parser.rb#25
+  def message; end
+end
+
+# source://prism//lib/prism/translation/parser.rb#34
+Prism::Translation::Parser::Racc_debug_parser = T.let(T.unsafe(nil), FalseClass)
+
+# This class provides a compatibility layer between prism and Ripper. It
+# functions by parsing the entire tree first and then walking it and
+# executing each of the Ripper callbacks as it goes. To use this class, you
+# treat `Prism::Translation::Ripper` effectively as you would treat the
+# `Ripper` class.
+#
+# Note that this class will serve the most common use cases, but Ripper's
+# API is extensive and undocumented. It relies on reporting the state of the
+# parser at any given time. We do our best to replicate that here, but
+# because it is a different architecture it is not possible to perfectly
+# replicate the behavior of Ripper.
+#
+# The main known difference is that we may omit dispatching some events in
+# some cases. This impacts the following events:
+#
+# - on_assign_error
+# - on_comma
+# - on_ignored_nl
+# - on_ignored_sp
+# - on_kw
+# - on_label_end
+# - on_lbrace
+# - on_lbracket
+# - on_lparen
+# - on_nl
+# - on_op
+# - on_operator_ambiguous
+# - on_rbrace
+# - on_rbracket
+# - on_rparen
+# - on_semicolon
+# - on_sp
+# - on_symbeg
+# - on_tstring_beg
+# - on_tstring_end
+#
+# source://prism//lib/prism/translation/ripper.rb#43
+class Prism::Translation::Ripper < ::Prism::Compiler
+  # Create a new Translation::Ripper object with the given source.
+  #
+  # @return [Ripper] a new instance of Ripper
+  #
+  # source://prism//lib/prism/translation/ripper.rb#444
+  def initialize(source, filename = T.unsafe(nil), lineno = T.unsafe(nil)); end
+
+  # The current column number of the parser.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#441
+  def column; end
+
+  # True if the parser encountered an error during parsing.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/translation/ripper.rb#457
+  sig { returns(T::Boolean) }
+  def error?; end
+
+  # The filename of the source being parsed.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#435
+  def filename; end
+
+  # The current line number of the parser.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#438
+  def lineno; end
+
+  # Parse the source and return the result.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#462
+  sig { returns(T.untyped) }
+  def parse; end
+
+  # The source that is being parsed.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#432
+  def source; end
+
+  # alias $foo $bar
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#561
+  def visit_alias_global_variable_node(node); end
+
+  # alias foo bar
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#551
+  def visit_alias_method_node(node); end
+
+  # foo => bar | baz
+  #        ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#585
+  def visit_alternation_pattern_node(node); end
+
+  # a and b
+  # ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#605
+  def visit_and_node(node); end
+
+  # foo(bar)
+  #     ^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#796
+  def visit_arguments_node(node); end
+
+  # []
+  # ^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#615
+  def visit_array_node(node); end
+
+  # foo => [bar]
+  #        ^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#775
+  def visit_array_pattern_node(node); end
+
+  # { a: 1 }
+  #   ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#803
+  def visit_assoc_node(node); end
+
+  # def foo(**); bar(**); end
+  #                  ^^
+  #
+  # { **foo }
+  #   ^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#816
+  def visit_assoc_splat_node(node); end
+
+  # $+
+  # ^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#825
+  def visit_back_reference_read_node(node); end
+
+  # begin end
+  # ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#832
+  def visit_begin_node(node); end
+
+  # foo(&bar)
+  #     ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#896
+  def visit_block_argument_node(node); end
+
+  # foo { |; bar| }
+  #          ^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#902
+  def visit_block_local_variable_node(node); end
+
+  # Visit a BlockNode.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#908
+  def visit_block_node(node); end
+
+  # def foo(&bar); end
+  #         ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#944
+  def visit_block_parameter_node(node); end
+
+  # A block's parameters.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#958
+  def visit_block_parameters_node(node); end
+
+  # break
+  # ^^^^^
+  #
+  # break foo
+  # ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#982
+  def visit_break_node(node); end
+
+  # foo.bar &&= baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1194
+  def visit_call_and_write_node(node); end
+
+  # foo
+  # ^^^
+  #
+  # foo.bar
+  # ^^^^^^^
+  #
+  # foo.bar() {}
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1002
+  def visit_call_node(node); end
+
+  # foo.bar += baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1172
+  def visit_call_operator_write_node(node); end
+
+  # foo.bar ||= baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1216
+  def visit_call_or_write_node(node); end
+
+  # foo.bar, = 1
+  # ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1238
+  def visit_call_target_node(node); end
+
+  # foo => bar => baz
+  #        ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1263
+  def visit_capture_pattern_node(node); end
+
+  # case foo; in bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1286
+  def visit_case_match_node(node); end
+
+  # case foo; when bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1273
+  def visit_case_node(node); end
+
+  # class Foo; end
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1299
+  def visit_class_node(node); end
+
+  # @@foo &&= bar
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1352
+  def visit_class_variable_and_write_node(node); end
+
+  # @@foo += bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1338
+  def visit_class_variable_operator_write_node(node); end
+
+  # @@foo ||= bar
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1366
+  def visit_class_variable_or_write_node(node); end
+
+  # @@foo
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1317
+  def visit_class_variable_read_node(node); end
+
+  # @@foo, = bar
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1380
+  def visit_class_variable_target_node(node); end
+
+  # @@foo = 1
+  # ^^^^^^^^^
+  #
+  # @@foo, @@bar = 1
+  # ^^^^^  ^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1327
+  def visit_class_variable_write_node(node); end
+
+  # Foo &&= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1422
+  def visit_constant_and_write_node(node); end
+
+  # Foo += bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1408
+  def visit_constant_operator_write_node(node); end
+
+  # Foo ||= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1436
+  def visit_constant_or_write_node(node); end
+
+  # Foo::Bar &&= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1523
+  def visit_constant_path_and_write_node(node); end
+
+  # Foo::Bar
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1457
+  def visit_constant_path_node(node); end
+
+  # Foo::Bar += baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1509
+  def visit_constant_path_operator_write_node(node); end
+
+  # Foo::Bar ||= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1537
+  def visit_constant_path_or_write_node(node); end
+
+  # Foo::Bar, = baz
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1551
+  def visit_constant_path_target_node(node); end
+
+  # Foo::Bar = 1
+  # ^^^^^^^^^^^^
+  #
+  # Foo::Foo, Bar::Bar = 1
+  # ^^^^^^^^  ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1480
+  def visit_constant_path_write_node(node); end
+
+  # Foo
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1387
+  def visit_constant_read_node(node); end
+
+  # Foo, = bar
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1450
+  def visit_constant_target_node(node); end
+
+  # Foo = 1
+  # ^^^^^^^
+  #
+  # Foo, Bar = 1
+  # ^^^  ^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1397
+  def visit_constant_write_node(node); end
+
+  # def foo; end
+  # ^^^^^^^^^^^^
+  #
+  # def self.foo; end
+  # ^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1560
+  def visit_def_node(node); end
+
+  # defined? a
+  # ^^^^^^^^^^
+  #
+  # defined?(a)
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1607
+  def visit_defined_node(node); end
+
+  # if foo then bar else baz end
+  #                 ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1614
+  def visit_else_node(node); end
+
+  # "foo #{bar}"
+  #      ^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1630
+  def visit_embedded_statements_node(node); end
+
+  # "foo #@bar"
+  #      ^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1651
+  def visit_embedded_variable_node(node); end
+
+  # Visit an EnsureNode node.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1662
+  def visit_ensure_node(node); end
+
+  # false
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1680
+  def visit_false_node(node); end
+
+  # foo => [*, bar, *]
+  #        ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1687
+  def visit_find_pattern_node(node); end
+
+  # if foo .. bar; end
+  #    ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1712
+  def visit_flip_flop_node(node); end
+
+  # 1.0
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1726
+  def visit_float_node(node); end
+
+  # for foo in bar do end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1732
+  def visit_for_node(node); end
+
+  # def foo(...); bar(...); end
+  #                   ^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1749
+  def visit_forwarding_arguments_node(node); end
+
+  # def foo(...); end
+  #         ^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1756
+  def visit_forwarding_parameter_node(node); end
+
+  # super
+  # ^^^^^
+  #
+  # super {}
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1766
+  def visit_forwarding_super_node(node); end
+
+  # $foo &&= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1815
+  def visit_global_variable_and_write_node(node); end
+
+  # $foo += bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1801
+  def visit_global_variable_operator_write_node(node); end
+
+  # $foo ||= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1829
+  def visit_global_variable_or_write_node(node); end
+
+  # $foo
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1780
+  def visit_global_variable_read_node(node); end
+
+  # $foo, = bar
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1843
+  def visit_global_variable_target_node(node); end
+
+  # $foo = 1
+  # ^^^^^^^^
+  #
+  # $foo, $bar = 1
+  # ^^^^  ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1790
+  def visit_global_variable_write_node(node); end
+
+  # {}
+  # ^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1850
+  def visit_hash_node(node); end
+
+  # foo => {}
+  #        ^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1865
+  def visit_hash_pattern_node(node); end
+
+  # if foo then bar end
+  # ^^^^^^^^^^^^^^^^^^^
+  #
+  # bar if foo
+  # ^^^^^^^^^^
+  #
+  # foo ? bar : baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1907
+  def visit_if_node(node); end
+
+  # 1i
+  # ^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1943
+  def visit_imaginary_node(node); end
+
+  # { foo: }
+  #   ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1949
+  def visit_implicit_node(node); end
+
+  # foo { |bar,| }
+  #           ^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1954
+  def visit_implicit_rest_node(node); end
+
+  # case foo; in bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1961
+  def visit_in_node(node); end
+
+  # foo[bar] &&= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1996
+  def visit_index_and_write_node(node); end
+
+  # foo[bar] += baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1979
+  def visit_index_operator_write_node(node); end
+
+  # foo[bar] ||= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2013
+  def visit_index_or_write_node(node); end
+
+  # foo[bar], = 1
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2030
+  def visit_index_target_node(node); end
+
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2072
+  def visit_instance_variable_and_write_node(node); end
+
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2058
+  def visit_instance_variable_operator_write_node(node); end
+
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2086
+  def visit_instance_variable_or_write_node(node); end
+
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2040
+  def visit_instance_variable_read_node(node); end
+
+  # @foo, = bar
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2100
+  def visit_instance_variable_target_node(node); end
+
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2047
+  def visit_instance_variable_write_node(node); end
+
+  # 1
+  # ^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2107
+  def visit_integer_node(node); end
+
+  # if /foo #{bar}/ then end
+  #    ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2113
+  def visit_interpolated_match_last_line_node(node); end
+
+  # /foo #{bar}/
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2132
+  def visit_interpolated_regular_expression_node(node); end
+
+  # "foo #{bar}"
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2151
+  def visit_interpolated_string_node(node); end
+
+  # :"foo #{bar}"
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2179
+  def visit_interpolated_symbol_node(node); end
+
+  # `foo #{bar}`
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2192
+  def visit_interpolated_x_string_node(node); end
+
+  # -> { it }
+  #      ^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2222
+  def visit_it_local_variable_read_node(node); end
+
+  # -> { it }
+  # ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2229
+  def visit_it_parameters_node(node); end
+
+  # foo(bar: baz)
+  #     ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2234
+  def visit_keyword_hash_node(node); end
+
+  # def foo(**bar); end
+  #         ^^^^^
+  #
+  # def foo(**); end
+  #         ^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2246
+  def visit_keyword_rest_parameter_node(node); end
+
+  # -> {}
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2260
+  def visit_lambda_node(node); end
+
+  # foo &&= bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2352
+  def visit_local_variable_and_write_node(node); end
+
+  # foo += bar
+  # ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2338
+  def visit_local_variable_operator_write_node(node); end
+
+  # foo ||= bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2366
+  def visit_local_variable_or_write_node(node); end
+
+  # foo
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2320
+  def visit_local_variable_read_node(node); end
+
+  # foo, = bar
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2380
+  def visit_local_variable_target_node(node); end
+
+  # foo = 1
+  # ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2327
+  def visit_local_variable_write_node(node); end
+
+  # if /foo/ then end
+  #    ^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2387
+  def visit_match_last_line_node(node); end
+
+  # foo in bar
+  # ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2402
+  def visit_match_predicate_node(node); end
+
+  # foo => bar
+  # ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2411
+  def visit_match_required_node(node); end
+
+  # /(?<foo>foo)/ =~ bar
+  # ^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2420
+  def visit_match_write_node(node); end
+
+  # A node that is missing from the syntax tree. This is only used in the
+  # case of a syntax error.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2426
+  def visit_missing_node(node); end
+
+  # module Foo; end
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2432
+  def visit_module_node(node); end
+
+  # (foo, bar), bar = qux
+  # ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2449
+  def visit_multi_target_node(node); end
+
+  # foo, bar = baz
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2503
+  def visit_multi_write_node(node); end
+
+  # next
+  # ^^^^
+  #
+  # next foo
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2523
+  def visit_next_node(node); end
+
+  # nil
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2537
+  def visit_nil_node(node); end
+
+  # def foo(**nil); end
+  #         ^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2544
+  def visit_no_keywords_parameter_node(node); end
+
+  # -> { _1 + _2 }
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2553
+  def visit_numbered_parameters_node(node); end
+
+  # $1
+  # ^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2558
+  def visit_numbered_reference_read_node(node); end
+
+  # def foo(bar: baz); end
+  #         ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2565
+  def visit_optional_keyword_parameter_node(node); end
+
+  # def foo(bar = 1); end
+  #         ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2575
+  def visit_optional_parameter_node(node); end
+
+  # a or b
+  # ^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2585
+  def visit_or_node(node); end
+
+  # def foo(bar, *baz); end
+  #         ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2595
+  def visit_parameters_node(node); end
+
+  # ()
+  # ^^
+  #
+  # (1)
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2622
+  def visit_parentheses_node(node); end
+
+  # foo => ^(bar)
+  #        ^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2636
+  def visit_pinned_expression_node(node); end
+
+  # foo = 1 and bar => ^foo
+  #                    ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2645
+  def visit_pinned_variable_node(node); end
+
+  # END {}
+  # ^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2651
+  def visit_post_execution_node(node); end
+
+  # BEGIN {}
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2666
+  def visit_pre_execution_node(node); end
+
+  # The top-level program node.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2680
+  def visit_program_node(node); end
+
+  # 0..5
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2691
+  def visit_range_node(node); end
+
+  # 1r
+  # ^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2705
+  def visit_rational_node(node); end
+
+  # redo
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2711
+  def visit_redo_node(node); end
+
+  # /foo/
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2718
+  def visit_regular_expression_node(node); end
+
+  # def foo(bar:); end
+  #         ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2740
+  def visit_required_keyword_parameter_node(node); end
+
+  # def foo(bar); end
+  #         ^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2747
+  def visit_required_parameter_node(node); end
+
+  # foo rescue bar
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2754
+  def visit_rescue_modifier_node(node); end
+
+  # begin; rescue; end
+  #        ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2764
+  def visit_rescue_node(node); end
+
+  # def foo(*bar); end
+  #         ^^^^
+  #
+  # def foo(*); end
+  #         ^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2822
+  def visit_rest_parameter_node(node); end
+
+  # retry
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2834
+  def visit_retry_node(node); end
+
+  # return
+  # ^^^^^^
+  #
+  # return 1
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2844
+  def visit_return_node(node); end
+
+  # self
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2858
+  def visit_self_node(node); end
+
+  # A shareable constant.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2864
+  def visit_shareable_constant_node(node); end
+
+  # class << self; end
+  # ^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2870
+  def visit_singleton_class_node(node); end
+
+  # __ENCODING__
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2880
+  def visit_source_encoding_node(node); end
+
+  # __FILE__
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2887
+  def visit_source_file_node(node); end
+
+  # __LINE__
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2894
+  def visit_source_line_node(node); end
+
+  # foo(*bar)
+  #     ^^^^
+  #
+  # def foo((bar, *baz)); end
+  #               ^^^^
+  #
+  # def foo(*); bar(*); end
+  #                 ^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2907
+  def visit_splat_node(node); end
+
+  # A list of statements.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2912
+  def visit_statements_node(node); end
+
+  # "foo"
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2929
+  def visit_string_node(node); end
+
+  # super(foo)
+  # ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3061
+  def visit_super_node(node); end
+
+  # :foo
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3082
+  def visit_symbol_node(node); end
+
+  # true
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3106
+  def visit_true_node(node); end
+
+  # undef foo
+  # ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3113
+  def visit_undef_node(node); end
+
+  # unless foo; bar end
+  # ^^^^^^^^^^^^^^^^^^^
+  #
+  # bar unless foo
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3125
+  def visit_unless_node(node); end
+
+  # until foo; bar end
+  # ^^^^^^^^^^^^^^^^^
+  #
+  # bar until foo
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3153
+  def visit_until_node(node); end
+
+  # case foo; when bar; end
+  #           ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3177
+  def visit_when_node(node); end
+
+  # while foo; bar end
+  # ^^^^^^^^^^^^^^^^^^
+  #
+  # bar while foo
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3198
+  def visit_while_node(node); end
+
+  # `foo`
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3222
+  def visit_x_string_node(node); end
+
+  # yield
+  # ^^^^^
+  #
+  # yield 1
+  # ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3245
+  def visit_yield_node(node); end
+
+  private
+
+  # :stopdoc:
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def _dispatch_0; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def _dispatch_1(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def _dispatch_2(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def _dispatch_3(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3389
+  def _dispatch_4(_, _, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3390
+  def _dispatch_5(_, _, _, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3391
+  def _dispatch_7(_, _, _, _, _, _, _); end
+
+  # This method is responsible for updating lineno and column information
+  # to reflect the current node.
+  #
+  # This method could be drastically improved with some caching on the start
+  # of every line, but for now it's good enough.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3375
+  def bounds(location); end
+
+  # Returns true if the given node is a command node.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1163
+  def command?(node); end
+
+  # This method is called when the parser found syntax error.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3413
+  def compile_error(msg); end
+
+  # This method is provided by the Ripper C extension. It is called when a
+  # string needs to be dedented because of a tilde heredoc. It is expected
+  # that it will modify the string in place and return the number of bytes
+  # that were removed.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3428
+  def dedent_string(string, width); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_BEGIN(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_CHAR(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_END(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on___end__(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_alias(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_alias_error(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_aref(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_aref_field(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_arg_ambiguous(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_arg_paren(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_args_add(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_args_add_block(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_args_add_star(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_args_forward; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_args_new; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_array(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3389
+  def on_aryptn(_, _, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_assign(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_assign_error(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_assoc_new(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_assoc_splat(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_assoclist_from_args(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_backref(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_backtick(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_bare_assoc_hash(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_begin(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def on_binary(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_block_var(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_blockarg(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3389
+  def on_bodystmt(_, _, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_brace_block(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_break(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def on_call(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_case(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def on_class(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_class_name_error(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_comma(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_command(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3389
+  def on_command_call(_, _, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_comment(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_const(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_const_path_field(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_const_path_ref(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_const_ref(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_cvar(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def on_def(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_defined(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3390
+  def on_defs(_, _, _, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_do_block(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_dot2(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_dot3(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_dyna_symbol(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_else(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def on_elsif(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_embdoc(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_embdoc_beg(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_embdoc_end(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_embexpr_beg(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_embexpr_end(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_embvar(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_ensure(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_excessed_comma; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_fcall(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def on_field(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_float(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3389
+  def on_fndptn(_, _, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def on_for(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_gvar(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_hash(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_heredoc_beg(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_heredoc_dedent(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_heredoc_end(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def on_hshptn(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_ident(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def on_if(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_if_mod(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def on_ifop(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_ignored_nl(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_ignored_sp(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_imaginary(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def on_in(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_int(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_ivar(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_kw(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_kwrest_param(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_label(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_label_end(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_lambda(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_lbrace(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_lbracket(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_lparen(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_magic_comment(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_massign(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_method_add_arg(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_method_add_block(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_mlhs_add(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_mlhs_add_post(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_mlhs_add_star(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_mlhs_new; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_mlhs_paren(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_module(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_mrhs_add(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_mrhs_add_star(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_mrhs_new; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_mrhs_new_from_args(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_next(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_nl(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_nokw_param(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_op(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def on_opassign(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_operator_ambiguous(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_param_error(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3391
+  def on_params(_, _, _, _, _, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_paren(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_parse_error(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_period(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_program(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_qsymbols_add(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_qsymbols_beg(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_qsymbols_new; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_qwords_add(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_qwords_beg(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_qwords_new; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_rational(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_rbrace(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_rbracket(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_redo; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_regexp_add(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_regexp_beg(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_regexp_end(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_regexp_literal(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_regexp_new; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3389
+  def on_rescue(_, _, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_rescue_mod(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_rest_param(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_retry; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_return(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_return0; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_rparen(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_sclass(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_semicolon(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_sp(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_stmts_add(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_stmts_new; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_string_add(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_string_concat(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_string_content; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_string_dvar(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_string_embexpr(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_string_literal(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_super(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_symbeg(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_symbol(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_symbol_literal(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_symbols_add(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_symbols_beg(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_symbols_new; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_tlambda(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_tlambeg(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_top_const_field(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_top_const_ref(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_tstring_beg(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_tstring_content(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_tstring_end(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_unary(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_undef(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def on_unless(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_unless_mod(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_until(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_until_mod(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_var_alias(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_var_field(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_var_ref(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_vcall(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_void_stmt; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3388
+  def on_when(_, _, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_while(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_while_mod(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_word_add(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_word_new; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_words_add(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_words_beg(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_words_new; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_words_sep(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3387
+  def on_xstring_add(_, _); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_xstring_literal(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_xstring_new; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3386
+  def on_yield(_); end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_yield0; end
+
+  # source://prism//lib/prism/translation/ripper.rb#3385
+  def on_zsuper; end
+
+  # Lazily initialize the parse result.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3271
+  def result; end
+
+  # Returns true if there is a comma between the two locations.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3280
+  def trailing_comma?(left, right); end
+
+  # Visit one side of an alias global variable node.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#570
+  def visit_alias_global_variable_node_value(node); end
+
+  # Visit a list of elements, like the elements of an array or arguments.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#756
+  def visit_arguments(elements); end
+
+  # Visit the clauses of a begin node to form an on_bodystmt call.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#840
+  def visit_begin_node_clauses(location, node, allow_newline); end
+
+  # Visit the body of a structure that can have either a set of statements
+  # or statements wrapped in rescue/else/ensure.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#875
+  def visit_body_node(location, node, allow_newline = T.unsafe(nil)); end
+
+  # Visit the arguments and block of a call node and return the arguments
+  # and block as they should be used.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1136
+  def visit_call_node_arguments(arguments_node, block_node, trailing_comma); end
+
+  # Visit a constant path that is part of a write node.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#1489
+  def visit_constant_path_write_node_target(node); end
+
+  # Visit a destructured positional parameter node.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2609
+  def visit_destructured_parameter_node(node); end
+
+  # Visit a string that is expressed using a <<~ heredoc.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2980
+  def visit_heredoc_node(parts, base); end
+
+  # Ripper gives back the escaped string content but strips out the common
+  # leading whitespace. Prism gives back the unescaped string content and
+  # a location for the escaped string content. Unfortunately these don't
+  # work well together, so here we need to re-derive the common leading
+  # whitespace.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2955
+  def visit_heredoc_node_whitespace(parts); end
+
+  # Visit a heredoc node that is representing a string.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3026
+  def visit_heredoc_string_node(node); end
+
+  # Visit a heredoc node that is representing an xstring.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3043
+  def visit_heredoc_x_string_node(node); end
+
+  # Visit the targets of a multi-target node.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2462
+  def visit_multi_target_node_targets(lefts, rest, rights, skippable); end
+
+  # Visit a node that represents a number. We need to explicitly handle the
+  # unary - operator.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3319
+  def visit_number_node(node); end
+
+  # Visit a pattern within a pattern match. This is used to bypass the
+  # parenthesis node that can be used to wrap patterns.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#595
+  def visit_pattern_node(node); end
+
+  # Visit the list of statements of a statements node. We support nil
+  # statements in the list. This would normally not be allowed by the
+  # structure of the prism parse tree, but we manually add them here so that
+  # we can mirror Ripper's void stmt.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2921
+  def visit_statements_node_body(body); end
+
+  # Visit an individual part of a string-like node.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#2211
+  def visit_string_content(part); end
+
+  # Visit the string content of a particular node. This method is used to
+  # split into the various token types.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3292
+  def visit_token(token, allow_keywords = T.unsafe(nil)); end
+
+  # Dispatch a words_sep event that contains the space between the elements
+  # of list literals.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#745
+  def visit_words_sep(opening_loc, previous, current); end
+
+  # Visit a node that represents a write value. This is used to handle the
+  # special case of an implicit array that is generated without brackets.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3337
+  def visit_write_value(node); end
+
+  # Returns true if there is a semicolon between the two locations.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3285
+  def void_stmt?(left, right, allow_newline); end
+
+  # This method is called when weak warning is produced by the parser.
+  # +fmt+ and +args+ is printf style.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3404
+  def warn(fmt, *args); end
+
+  # This method is called when strong warning is produced by the parser.
+  # +fmt+ and +args+ is printf style.
+  #
+  # source://prism//lib/prism/translation/ripper.rb#3409
+  def warning(fmt, *args); end
+
+  class << self
+    # Tokenizes the Ruby program and returns an array of an array,
+    # which is formatted like
+    # <code>[[lineno, column], type, token, state]</code>.
+    # The +filename+ argument is mostly ignored.
+    # By default, this method does not handle syntax errors in +src+,
+    # use the +raise_errors+ keyword to raise a SyntaxError for an error in +src+.
+    #
+    #     require "ripper"
+    #     require "pp"
+    #
+    #     pp Ripper.lex("def m(a) nil end")
+    #     #=> [[[1,  0], :on_kw,     "def", FNAME    ],
+    #          [[1,  3], :on_sp,     " ",   FNAME    ],
+    #          [[1,  4], :on_ident,  "m",   ENDFN    ],
+    #          [[1,  5], :on_lparen, "(",   BEG|LABEL],
+    #          [[1,  6], :on_ident,  "a",   ARG      ],
+    #          [[1,  7], :on_rparen, ")",   ENDFN    ],
+    #          [[1,  8], :on_sp,     " ",   BEG      ],
+    #          [[1,  9], :on_kw,     "nil", END      ],
+    #          [[1, 12], :on_sp,     " ",   END      ],
+    #          [[1, 13], :on_kw,     "end", END      ]]
+    #
+    # source://prism//lib/prism/translation/ripper.rb#72
+    def lex(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end
+
+    # Parses the given Ruby program read from +src+.
+    # +src+ must be a String or an IO or a object with a #gets method.
+    #
+    # source://prism//lib/prism/translation/ripper.rb#46
+    def parse(src, filename = T.unsafe(nil), lineno = T.unsafe(nil)); end
+
+    # Parses +src+ and create S-exp tree.
+    # Returns more readable tree rather than Ripper.sexp_raw.
+    # This method is mainly for developer use.
+    # The +filename+ argument is mostly ignored.
+    # By default, this method does not handle syntax errors in +src+,
+    # returning +nil+ in such cases. Use the +raise_errors+ keyword
+    # to raise a SyntaxError for an error in +src+.
+    #
+    #     require "ripper"
+    #     require "pp"
+    #
+    #     pp Ripper.sexp("def m(a) nil end")
+    #       #=> [:program,
+    #            [[:def,
+    #             [:@ident, "m", [1, 4]],
+    #             [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil, nil, nil, nil]],
+    #             [:bodystmt, [[:var_ref, [:@kw, "nil", [1, 9]]]], nil, nil, nil]]]]
+    #
+    # source://prism//lib/prism/translation/ripper.rb#381
+    def sexp(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end
+
+    # Parses +src+ and create S-exp tree.
+    # This method is mainly for developer use.
+    # The +filename+ argument is mostly ignored.
+    # By default, this method does not handle syntax errors in +src+,
+    # returning +nil+ in such cases. Use the +raise_errors+ keyword
+    # to raise a SyntaxError for an error in +src+.
+    #
+    #     require "ripper"
+    #     require "pp"
+    #
+    #     pp Ripper.sexp_raw("def m(a) nil end")
+    #       #=> [:program,
+    #            [:stmts_add,
+    #             [:stmts_new],
+    #             [:def,
+    #              [:@ident, "m", [1, 4]],
+    #              [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil]],
+    #              [:bodystmt,
+    #               [:stmts_add, [:stmts_new], [:var_ref, [:@kw, "nil", [1, 9]]]],
+    #               nil,
+    #               nil,
+    #               nil]]]]
+    #
+    # source://prism//lib/prism/translation/ripper.rb#416
+    def sexp_raw(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end
+  end
+end
+
+# A list of all of the Ruby binary operators.
+#
+# source://prism//lib/prism/translation/ripper.rb#337
+Prism::Translation::Ripper::BINARY_OPERATORS = T.let(T.unsafe(nil), Array)
+
+# This array contains name of all ripper events.
+#
+# source://prism//lib/prism/translation/ripper.rb#289
+Prism::Translation::Ripper::EVENTS = T.let(T.unsafe(nil), Array)
+
+# A list of all of the Ruby keywords.
+#
+# source://prism//lib/prism/translation/ripper.rb#292
+Prism::Translation::Ripper::KEYWORDS = T.let(T.unsafe(nil), Array)
+
+# This array contains name of parser events.
+#
+# source://prism//lib/prism/translation/ripper.rb#283
+Prism::Translation::Ripper::PARSER_EVENTS = T.let(T.unsafe(nil), Array)
+
+# This contains a table of all of the parser events and their
+# corresponding arity.
+#
+# source://prism//lib/prism/translation/ripper.rb#84
+Prism::Translation::Ripper::PARSER_EVENT_TABLE = T.let(T.unsafe(nil), Hash)
+
+# This array contains name of scanner events.
+#
+# source://prism//lib/prism/translation/ripper.rb#286
+Prism::Translation::Ripper::SCANNER_EVENTS = T.let(T.unsafe(nil), Array)
+
+# This contains a table of all of the scanner events and their
+# corresponding arity.
+#
+# source://prism//lib/prism/translation/ripper.rb#227
+Prism::Translation::Ripper::SCANNER_EVENT_TABLE = T.let(T.unsafe(nil), Hash)
+
+# This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that
+# returns the arrays of [type, *children].
+#
+# source://prism//lib/prism/translation/ripper/sexp.rb#10
+class Prism::Translation::Ripper::SexpBuilder < ::Prism::Translation::Ripper
+  # :stopdoc:
+  #
+  # source://prism//lib/prism/translation/ripper/sexp.rb#13
+  def error; end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_BEGIN(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_CHAR(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_END(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on___end__(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_alias(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_alias_error(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_aref(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_aref_field(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_arg_ambiguous(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_arg_paren(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_args_add(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_args_add_block(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_args_add_star(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_args_forward(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_args_new(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_array(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_aryptn(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_assign(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_assign_error(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_assoc_new(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_assoc_splat(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_assoclist_from_args(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_backref(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_backtick(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_bare_assoc_hash(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_begin(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_binary(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_block_var(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_blockarg(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_bodystmt(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_brace_block(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_break(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_call(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_case(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_class(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_class_name_error(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_comma(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_command(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_command_call(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_comment(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_const(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_const_path_field(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_const_path_ref(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_const_ref(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_cvar(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_def(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_defined(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_defs(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_do_block(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_dot2(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_dot3(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_dyna_symbol(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_else(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_elsif(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_embdoc(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_embdoc_beg(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_embdoc_end(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_embexpr_beg(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_embexpr_end(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_embvar(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_ensure(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_excessed_comma(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_fcall(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_field(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_float(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_fndptn(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_for(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_gvar(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_hash(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_heredoc_beg(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_heredoc_end(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_hshptn(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_ident(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_if(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_if_mod(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_ifop(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_ignored_nl(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_ignored_sp(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_imaginary(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_in(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_int(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_ivar(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_kw(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_kwrest_param(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_label(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_label_end(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_lambda(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_lbrace(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_lbracket(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_lparen(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_magic_comment(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_massign(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_method_add_arg(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_method_add_block(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_mlhs_add(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_mlhs_add_post(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_mlhs_add_star(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_mlhs_new(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_mlhs_paren(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_module(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_mrhs_add(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_mrhs_add_star(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_mrhs_new(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_mrhs_new_from_args(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_next(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_nl(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_nokw_param(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_op(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_opassign(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_operator_ambiguous(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_param_error(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_params(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_paren(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_period(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_program(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_qsymbols_add(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_qsymbols_beg(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_qsymbols_new(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_qwords_add(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_qwords_beg(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_qwords_new(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_rational(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_rbrace(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_rbracket(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_redo(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_regexp_add(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_regexp_beg(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_regexp_end(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_regexp_literal(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_regexp_new(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_rescue(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_rescue_mod(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_rest_param(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_retry(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_return(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_return0(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_rparen(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_sclass(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_semicolon(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_sp(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_stmts_add(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_stmts_new(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_string_add(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_string_concat(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_string_content(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_string_dvar(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_string_embexpr(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_string_literal(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_super(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_symbeg(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_symbol(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_symbol_literal(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_symbols_add(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_symbols_beg(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_symbols_new(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_tlambda(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_tlambeg(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_top_const_field(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_top_const_ref(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_tstring_beg(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_tstring_content(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_tstring_end(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_unary(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_undef(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_unless(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_unless_mod(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_until(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_until_mod(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_var_alias(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_var_field(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_var_ref(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_vcall(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_void_stmt(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_when(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_while(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_while_mod(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_word_add(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_word_new(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_words_add(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_words_beg(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_words_new(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#55
+  def on_words_sep(tok); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_xstring_add(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_xstring_literal(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_xstring_new(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_yield(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_yield0(*args); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#47
+  def on_zsuper(*args); end
+
+  private
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#61
+  def compile_error(mesg); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#17
+  def dedent_element(e, width); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#61
+  def on_error(mesg); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#24
+  def on_heredoc_dedent(val, width); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#61
+  def on_parse_error(mesg); end
+end
+
+# This class mirrors the ::Ripper::SexpBuilderPP subclass of ::Ripper that
+# returns the same values as ::Ripper::SexpBuilder except with a couple of
+# niceties that flatten linked lists into arrays.
+#
+# source://prism//lib/prism/translation/ripper/sexp.rb#74
+class Prism::Translation::Ripper::SexpBuilderPP < ::Prism::Translation::Ripper::SexpBuilder
+  private
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#92
+  def _dispatch_event_new; end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#96
+  def _dispatch_event_push(list, item); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#96
+  def on_args_add(list, item); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#92
+  def on_args_new; end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#79
+  def on_heredoc_dedent(val, width); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#96
+  def on_mlhs_add(list, item); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#109
+  def on_mlhs_add_post(list, post); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#105
+  def on_mlhs_add_star(list, star); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#92
+  def on_mlhs_new; end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#101
+  def on_mlhs_paren(list); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#96
+  def on_mrhs_add(list, item); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#92
+  def on_mrhs_new; end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#96
+  def on_qsymbols_add(list, item); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#92
+  def on_qsymbols_new; end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#96
+  def on_qwords_add(list, item); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#92
+  def on_qwords_new; end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#96
+  def on_regexp_add(list, item); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#92
+  def on_regexp_new; end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#96
+  def on_stmts_add(list, item); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#92
+  def on_stmts_new; end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#96
+  def on_string_add(list, item); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#96
+  def on_symbols_add(list, item); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#92
+  def on_symbols_new; end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#96
+  def on_word_add(list, item); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#92
+  def on_word_new; end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#96
+  def on_words_add(list, item); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#92
+  def on_words_new; end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#96
+  def on_xstring_add(list, item); end
+
+  # source://prism//lib/prism/translation/ripper/sexp.rb#92
+  def on_xstring_new; end
+end
+
+# This module is the entry-point for converting a prism syntax tree into the
+# seattlerb/ruby_parser gem's syntax tree.
+#
+# source://prism//lib/prism/translation/ruby_parser.rb#14
+class Prism::Translation::RubyParser
+  # Parse the given source and translate it into the seattlerb/ruby_parser
+  # gem's Sexp format.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1598
+  def parse(source, filepath = T.unsafe(nil)); end
+
+  # Parse the given file and translate it into the seattlerb/ruby_parser
+  # gem's Sexp format.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1604
+  def parse_file(filepath); end
+
+  private
+
+  # Translate the given parse result and filepath into the
+  # seattlerb/ruby_parser gem's Sexp format.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1626
+  def translate(result, filepath); end
+
+  class << self
+    # Parse the given source and translate it into the seattlerb/ruby_parser
+    # gem's Sexp format.
+    #
+    # source://prism//lib/prism/translation/ruby_parser.rb#1611
+    def parse(source, filepath = T.unsafe(nil)); end
+
+    # Parse the given file and translate it into the seattlerb/ruby_parser
+    # gem's Sexp format.
+    #
+    # source://prism//lib/prism/translation/ruby_parser.rb#1617
+    def parse_file(filepath); end
+  end
+end
+
+# A prism visitor that builds Sexp objects.
+#
+# source://prism//lib/prism/translation/ruby_parser.rb#16
+class Prism::Translation::RubyParser::Compiler < ::Prism::Compiler
+  # Initialize a new compiler with the given file name.
+  #
+  # @return [Compiler] a new instance of Compiler
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#31
+  def initialize(file, in_def: T.unsafe(nil), in_pattern: T.unsafe(nil)); end
+
+  # This is the name of the file that we are compiling. We set it on every
+  # Sexp object that is generated, and also use it to compile __FILE__
+  # nodes.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#20
+  def file; end
+
+  # Class variables will change their type based on if they are inside of
+  # a method definition or not, so we need to track that state.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#24
+  def in_def; end
+
+  # Some nodes will change their representation if they are inside of a
+  # pattern, so we need to track that state.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#28
+  def in_pattern; end
+
+  # alias $foo $bar
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#45
+  def visit_alias_global_variable_node(node); end
+
+  # alias foo bar
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#39
+  def visit_alias_method_node(node); end
+
+  # foo => bar | baz
+  #        ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#51
+  def visit_alternation_pattern_node(node); end
+
+  # a and b
+  # ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#57
+  def visit_and_node(node); end
+
+  # foo(bar)
+  #     ^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#108
+  def visit_arguments_node(node); end
+
+  # []
+  # ^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#75
+  def visit_array_node(node); end
+
+  # foo => [bar]
+  #        ^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#85
+  def visit_array_pattern_node(node); end
+
+  # { a: 1 }
+  #   ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#114
+  def visit_assoc_node(node); end
+
+  # def foo(**); bar(**); end
+  #                  ^^
+  #
+  # { **foo }
+  #   ^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#123
+  def visit_assoc_splat_node(node); end
+
+  # $+
+  # ^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#133
+  def visit_back_reference_read_node(node); end
+
+  # begin end
+  # ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#139
+  def visit_begin_node(node); end
+
+  # foo(&bar)
+  #     ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#172
+  def visit_block_argument_node(node); end
+
+  # foo { |; bar| }
+  #          ^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#180
+  def visit_block_local_variable_node(node); end
+
+  # A block on a keyword or method call.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#185
+  def visit_block_node(node); end
+
+  # def foo(&bar); end
+  #         ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#191
+  def visit_block_parameter_node(node); end
+
+  # A block's parameters.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#196
+  def visit_block_parameters_node(node); end
+
+  # break
+  # ^^^^^
+  #
+  # break foo
+  # ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#236
+  def visit_break_node(node); end
+
+  # foo.bar &&= baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#304
+  def visit_call_and_write_node(node); end
+
+  # foo
+  # ^^^
+  #
+  # foo.bar
+  # ^^^^^^^
+  #
+  # foo.bar() {}
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#254
+  def visit_call_node(node); end
+
+  # foo.bar += baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#294
+  def visit_call_operator_write_node(node); end
+
+  # foo.bar ||= baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#314
+  def visit_call_or_write_node(node); end
+
+  # foo.bar, = 1
+  # ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#337
+  def visit_call_target_node(node); end
+
+  # foo => bar => baz
+  #        ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#343
+  def visit_capture_pattern_node(node); end
+
+  # case foo; in bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#355
+  def visit_case_match_node(node); end
+
+  # case foo; when bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#349
+  def visit_case_node(node); end
+
+  # class Foo; end
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#361
+  def visit_class_node(node); end
+
+  # @@foo &&= bar
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#402
+  def visit_class_variable_and_write_node(node); end
+
+  # @@foo += bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#396
+  def visit_class_variable_operator_write_node(node); end
+
+  # @@foo ||= bar
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#408
+  def visit_class_variable_or_write_node(node); end
+
+  # @@foo
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#381
+  def visit_class_variable_read_node(node); end
+
+  # @@foo, = bar
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#414
+  def visit_class_variable_target_node(node); end
+
+  # @@foo = 1
+  # ^^^^^^^^^
+  #
+  # @@foo, @@bar = 1
+  # ^^^^^  ^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#390
+  def visit_class_variable_write_node(node); end
+
+  # Foo &&= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#447
+  def visit_constant_and_write_node(node); end
+
+  # Foo += bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#441
+  def visit_constant_operator_write_node(node); end
+
+  # Foo ||= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#453
+  def visit_constant_or_write_node(node); end
+
+  # Foo::Bar &&= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#490
+  def visit_constant_path_and_write_node(node); end
+
+  # Foo::Bar
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#465
+  def visit_constant_path_node(node); end
+
+  # Foo::Bar += baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#484
+  def visit_constant_path_operator_write_node(node); end
+
+  # Foo::Bar ||= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#496
+  def visit_constant_path_or_write_node(node); end
+
+  # Foo::Bar, = baz
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#502
+  def visit_constant_path_target_node(node); end
+
+  # Foo::Bar = 1
+  # ^^^^^^^^^^^^
+  #
+  # Foo::Foo, Bar::Bar = 1
+  # ^^^^^^^^  ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#478
+  def visit_constant_path_write_node(node); end
+
+  # Foo
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#426
+  def visit_constant_read_node(node); end
+
+  # Foo, = bar
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#459
+  def visit_constant_target_node(node); end
+
+  # Foo = 1
+  # ^^^^^^^
+  #
+  # Foo, Bar = 1
+  # ^^^  ^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#435
+  def visit_constant_write_node(node); end
+
+  # def foo; end
+  # ^^^^^^^^^^^^
+  #
+  # def self.foo; end
+  # ^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#518
+  def visit_def_node(node); end
+
+  # defined? a
+  # ^^^^^^^^^^
+  #
+  # defined?(a)
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#549
+  def visit_defined_node(node); end
+
+  # if foo then bar else baz end
+  #                 ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#555
+  def visit_else_node(node); end
+
+  # "foo #{bar}"
+  #      ^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#561
+  def visit_embedded_statements_node(node); end
+
+  # "foo #@bar"
+  #      ^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#569
+  def visit_embedded_variable_node(node); end
+
+  # begin; foo; ensure; bar; end
+  #             ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#575
+  def visit_ensure_node(node); end
+
+  # false
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#581
+  def visit_false_node(node); end
+
+  # foo => [*, bar, *]
+  #        ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#587
+  def visit_find_pattern_node(node); end
+
+  # if foo .. bar; end
+  #    ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#593
+  def visit_flip_flop_node(node); end
+
+  # 1.0
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#603
+  def visit_float_node(node); end
+
+  # for foo in bar do end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#609
+  def visit_for_node(node); end
+
+  # def foo(...); bar(...); end
+  #                   ^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#615
+  def visit_forwarding_arguments_node(node); end
+
+  # def foo(...); end
+  #         ^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#621
+  def visit_forwarding_parameter_node(node); end
+
+  # super
+  # ^^^^^
+  #
+  # super {}
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#630
+  def visit_forwarding_super_node(node); end
+
+  # $foo &&= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#657
+  def visit_global_variable_and_write_node(node); end
+
+  # $foo += bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#651
+  def visit_global_variable_operator_write_node(node); end
+
+  # $foo ||= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#663
+  def visit_global_variable_or_write_node(node); end
+
+  # $foo
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#636
+  def visit_global_variable_read_node(node); end
+
+  # $foo, = bar
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#669
+  def visit_global_variable_target_node(node); end
+
+  # $foo = 1
+  # ^^^^^^^^
+  #
+  # $foo, $bar = 1
+  # ^^^^  ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#645
+  def visit_global_variable_write_node(node); end
+
+  # {}
+  # ^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#675
+  def visit_hash_node(node); end
+
+  # foo => {}
+  #        ^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#681
+  def visit_hash_pattern_node(node); end
+
+  # if foo then bar end
+  # ^^^^^^^^^^^^^^^^^^^
+  #
+  # bar if foo
+  # ^^^^^^^^^^
+  #
+  # foo ? bar : baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#702
+  def visit_if_node(node); end
+
+  # 1i
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#707
+  def visit_imaginary_node(node); end
+
+  # { foo: }
+  #   ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#713
+  def visit_implicit_node(node); end
+
+  # foo { |bar,| }
+  #           ^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#718
+  def visit_implicit_rest_node(node); end
+
+  # case foo; in bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#723
+  def visit_in_node(node); end
+
+  # foo[bar] &&= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#749
+  def visit_index_and_write_node(node); end
+
+  # foo[bar] += baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#736
+  def visit_index_operator_write_node(node); end
+
+  # foo[bar] ||= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#762
+  def visit_index_or_write_node(node); end
+
+  # foo[bar], = 1
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#775
+  def visit_index_target_node(node); end
+
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#805
+  def visit_instance_variable_and_write_node(node); end
+
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#799
+  def visit_instance_variable_operator_write_node(node); end
+
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#811
+  def visit_instance_variable_or_write_node(node); end
+
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#784
+  def visit_instance_variable_read_node(node); end
+
+  # @foo, = bar
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#817
+  def visit_instance_variable_target_node(node); end
+
+  # ^^^^^^^^
+  #
+  # @foo, @bar = 1
+  # ^^^^  ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#793
+  def visit_instance_variable_write_node(node); end
+
+  # 1
+  # ^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#823
+  def visit_integer_node(node); end
+
+  # if /foo #{bar}/ then end
+  #    ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#829
+  def visit_interpolated_match_last_line_node(node); end
+
+  # /foo #{bar}/
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#846
+  def visit_interpolated_regular_expression_node(node); end
+
+  # "foo #{bar}"
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#861
+  def visit_interpolated_string_node(node); end
+
+  # :"foo #{bar}"
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#868
+  def visit_interpolated_symbol_node(node); end
+
+  # `foo #{bar}`
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#875
+  def visit_interpolated_x_string_node(node); end
+
+  # -> { it }
+  #      ^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#947
+  def visit_it_local_variable_read_node(node); end
+
+  # foo(bar: baz)
+  #     ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#953
+  def visit_keyword_hash_node(node); end
+
+  # def foo(**bar); end
+  #         ^^^^^
+  #
+  # def foo(**); end
+  #         ^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#962
+  def visit_keyword_rest_parameter_node(node); end
+
+  # -> {}
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#967
+  def visit_lambda_node(node); end
+
+  # foo &&= bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1010
+  def visit_local_variable_and_write_node(node); end
+
+  # foo += bar
+  # ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1004
+  def visit_local_variable_operator_write_node(node); end
+
+  # foo ||= bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1016
+  def visit_local_variable_or_write_node(node); end
+
+  # foo
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#985
+  def visit_local_variable_read_node(node); end
+
+  # foo, = bar
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1022
+  def visit_local_variable_target_node(node); end
+
+  # foo = 1
+  # ^^^^^^^
+  #
+  # foo, bar = 1
+  # ^^^  ^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#998
+  def visit_local_variable_write_node(node); end
+
+  # if /foo/ then end
+  #    ^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1028
+  def visit_match_last_line_node(node); end
+
+  # foo in bar
+  # ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1034
+  def visit_match_predicate_node(node); end
+
+  # foo => bar
+  # ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1040
+  def visit_match_required_node(node); end
+
+  # /(?<foo>foo)/ =~ bar
+  # ^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1046
+  def visit_match_write_node(node); end
+
+  # A node that is missing from the syntax tree. This is only used in the
+  # case of a syntax error. The parser gem doesn't have such a concept, so
+  # we invent our own here.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1053
+  def visit_missing_node(node); end
+
+  # module Foo; end
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1059
+  def visit_module_node(node); end
+
+  # foo, bar = baz
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1079
+  def visit_multi_target_node(node); end
+
+  # foo, bar = baz
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1089
+  def visit_multi_write_node(node); end
+
+  # next
+  # ^^^^
+  #
+  # next foo
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1113
+  def visit_next_node(node); end
+
+  # nil
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1126
+  def visit_nil_node(node); end
+
+  # def foo(**nil); end
+  #         ^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1132
+  def visit_no_keywords_parameter_node(node); end
+
+  # -> { _1 + _2 }
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1138
+  def visit_numbered_parameters_node(node); end
+
+  # $1
+  # ^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1144
+  def visit_numbered_reference_read_node(node); end
+
+  # def foo(bar: baz); end
+  #         ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1150
+  def visit_optional_keyword_parameter_node(node); end
+
+  # def foo(bar = 1); end
+  #         ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1156
+  def visit_optional_parameter_node(node); end
+
+  # a or b
+  # ^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1162
+  def visit_or_node(node); end
+
+  # def foo(bar, *baz); end
+  #         ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1180
+  def visit_parameters_node(node); end
+
+  # ()
+  # ^^
+  #
+  # (1)
+  # ^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1218
+  def visit_parentheses_node(node); end
+
+  # foo => ^(bar)
+  #        ^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1228
+  def visit_pinned_expression_node(node); end
+
+  # foo = 1 and bar => ^foo
+  #                    ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1234
+  def visit_pinned_variable_node(node); end
+
+  # END {}
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1243
+  def visit_post_execution_node(node); end
+
+  # BEGIN {}
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1248
+  def visit_pre_execution_node(node); end
+
+  # The top-level program node.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1253
+  def visit_program_node(node); end
+
+  # 0..5
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1259
+  def visit_range_node(node); end
+
+  # 1r
+  # ^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1281
+  def visit_rational_node(node); end
+
+  # redo
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1287
+  def visit_redo_node(node); end
+
+  # /foo/
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1293
+  def visit_regular_expression_node(node); end
+
+  # def foo(bar:); end
+  #         ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1299
+  def visit_required_keyword_parameter_node(node); end
+
+  # def foo(bar); end
+  #         ^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1305
+  def visit_required_parameter_node(node); end
+
+  # foo rescue bar
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1311
+  def visit_rescue_modifier_node(node); end
+
+  # begin; rescue; end
+  #        ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1317
+  def visit_rescue_node(node); end
+
+  # def foo(*bar); end
+  #         ^^^^
+  #
+  # def foo(*); end
+  #         ^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1337
+  def visit_rest_parameter_node(node); end
+
+  # retry
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1343
+  def visit_retry_node(node); end
+
+  # return
+  # ^^^^^^
+  #
+  # return 1
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1352
+  def visit_return_node(node); end
+
+  # self
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1365
+  def visit_self_node(node); end
+
+  # A shareable constant.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1370
+  def visit_shareable_constant_node(node); end
+
+  # class << self; end
+  # ^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1376
+  def visit_singleton_class_node(node); end
+
+  # __ENCODING__
+  # ^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1384
+  def visit_source_encoding_node(node); end
+
+  # __FILE__
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1391
+  def visit_source_file_node(node); end
+
+  # __LINE__
+  # ^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1397
+  def visit_source_line_node(node); end
+
+  # foo(*bar)
+  #     ^^^^
+  #
+  # def foo((bar, *baz)); end
+  #               ^^^^
+  #
+  # def foo(*); bar(*); end
+  #                 ^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1409
+  def visit_splat_node(node); end
+
+  # A list of statements.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1418
+  def visit_statements_node(node); end
+
+  # "foo"
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1430
+  def visit_string_node(node); end
+
+  # super(foo)
+  # ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1442
+  def visit_super_node(node); end
+
+  # :foo
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1456
+  def visit_symbol_node(node); end
+
+  # true
+  # ^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1462
+  def visit_true_node(node); end
+
+  # undef foo
+  # ^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1468
+  def visit_undef_node(node); end
+
+  # unless foo; bar end
+  # ^^^^^^^^^^^^^^^^^^^
+  #
+  # bar unless foo
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1478
+  def visit_unless_node(node); end
+
+  # until foo; bar end
+  # ^^^^^^^^^^^^^^^^^
+  #
+  # bar until foo
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1487
+  def visit_until_node(node); end
+
+  # case foo; when bar; end
+  #           ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1493
+  def visit_when_node(node); end
+
+  # while foo; bar end
+  # ^^^^^^^^^^^^^^^^^^
+  #
+  # bar while foo
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1502
+  def visit_while_node(node); end
+
+  # `foo`
+  # ^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1508
+  def visit_x_string_node(node); end
+
+  # yield
+  # ^^^^^
+  #
+  # yield 1
+  # ^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1524
+  def visit_yield_node(node); end
+
+  private
+
+  # If a class variable is written within a method definition, it has a
+  # different type than everywhere else.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#420
+  def class_variable_write_type; end
+
+  # Create a new compiler with the given options.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1531
+  def copy_compiler(in_def: T.unsafe(nil), in_pattern: T.unsafe(nil)); end
+
+  # Call nodes with operators following them will either be op_asgn or
+  # op_asgn2 nodes. That is determined by their call operator and their
+  # right-hand side.
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#325
+  def op_asgn?(node); end
+
+  # Call nodes with operators following them can use &. as an operator,
+  # which changes their type by prefixing "safe_".
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#331
+  def op_asgn_type(node, type); end
+
+  # Create a new Sexp object from the given prism node and arguments.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1536
+  def s(node, *arguments); end
+
+  # Visit a block node, which will modify the AST by wrapping the given
+  # visited node in an iter node.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1546
+  def visit_block(node, sexp, block); end
+
+  # def foo((bar, baz)); end
+  #         ^^^^^^^^^^
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1195
+  def visit_destructured_parameter(node); end
+
+  # Visit the interpolated content of the string-like node.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#882
+  def visit_interpolated_parts(parts); end
+
+  # Pattern constants get wrapped in another layer of :const.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1567
+  def visit_pattern_constant(node); end
+
+  # If the bounds of a range node are empty parentheses, then they do not
+  # get replaced by their usual s(:nil), but instead are s(:begin).
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1271
+  def visit_range_bounds_node(node); end
+
+  # Visit the value of a write, which will be on the right-hand side of
+  # a write operator. Because implicit arrays can have splats, those could
+  # potentially be wrapped in an svalue node.
+  #
+  # source://prism//lib/prism/translation/ruby_parser.rb#1581
+  def visit_write_value(node); end
+end
+
+# Represents the use of the literal `true` keyword.
+#
+#     true
+#     ^^^^
+#
+# source://prism//lib/prism/node.rb#15741
+class Prism::TrueNode < ::Prism::Node
+  # Initialize a new TrueNode node.
+  #
+  # @return [TrueNode] a new instance of TrueNode
+  #
+  # source://prism//lib/prism/node.rb#15743
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void }
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#15800
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#15751
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15756
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#15766
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#15761
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> TrueNode
+  #
+  # source://prism//lib/prism/node.rb#15771
+  sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::TrueNode) }
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15756
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  #
+  # source://prism//lib/prism/node.rb#15779
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#15784
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#15789
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#15794
+    def type; end
+  end
+end
+
+# Represents the use of the `undef` keyword.
+#
+#     undef :foo, :bar, :baz
+#     ^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#15809
+class Prism::UndefNode < ::Prism::Node
+  # Initialize a new UndefNode node.
+  #
+  # @return [UndefNode] a new instance of UndefNode
+  #
+  # source://prism//lib/prism/node.rb#15811
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      names: T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)],
+      keyword_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, names, keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#15885
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#15821
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15826
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#15836
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#15831
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?names: Array[SymbolNode | InterpolatedSymbolNode], ?keyword_loc: Location) -> UndefNode
+  #
+  # source://prism//lib/prism/node.rb#15841
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      names: T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)],
+      keyword_loc: Prism::Location
+    ).returns(Prism::UndefNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), names: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15826
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, names: Array[SymbolNode | InterpolatedSymbolNode], keyword_loc: Location }
+  #
+  # source://prism//lib/prism/node.rb#15849
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#15869
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#15864
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#15857
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # attr_reader names: Array[SymbolNode | InterpolatedSymbolNode]
+  #
+  # source://prism//lib/prism/node.rb#15854
+  sig { returns(T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)]) }
+  def names; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#15874
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#15879
+    def type; end
+  end
+end
+
+# Represents the use of the `unless` keyword, either in the block form or the modifier form.
+#
+#     bar unless foo
+#     ^^^^^^^^^^^^^^
+#
+#     unless foo then bar end
+#     ^^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#15900
+class Prism::UnlessNode < ::Prism::Node
+  # Initialize a new UnlessNode node.
+  #
+  # @return [UnlessNode] a new instance of UnlessNode
+  #
+  # source://prism//lib/prism/node.rb#15902
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      predicate: Prism::Node,
+      then_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode),
+      else_clause: T.nilable(Prism::ElseNode),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, keyword_loc, predicate, then_keyword_loc, statements, else_clause, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#16051
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#15916
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15921
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#15935
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#15926
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # Returns the else clause of the unless node. This method is deprecated in
+  # favor of #else_clause.
+  #
+  # source://prism//lib/prism/node_ext.rb#503
+  def consequent; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?else_clause: ElseNode?, ?end_keyword_loc: Location?) -> UnlessNode
+  #
+  # source://prism//lib/prism/node.rb#15940
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      predicate: Prism::Node,
+      then_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode),
+      else_clause: T.nilable(Prism::ElseNode),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::UnlessNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), else_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#15921
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, else_clause: ElseNode?, end_keyword_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#15948
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # The else clause of the unless expression, if present.
+  #
+  #     unless cond then bar else baz end
+  #                          ^^^^^^^^
+  #
+  # source://prism//lib/prism/node.rb#16001
+  sig { returns(T.nilable(Prism::ElseNode)) }
+  def else_clause; end
+
+  # def end_keyword: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#16030
+  sig { returns(T.nilable(String)) }
+  def end_keyword; end
+
+  # The location of the `end` keyword, if present.
+  #
+  #     unless cond then bar end
+  #                          ^^^
+  #
+  # source://prism//lib/prism/node.rb#16007
+  sig { returns(T.nilable(Prism::Location)) }
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#16035
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#16020
+  sig { returns(String) }
+  def keyword; end
+
+  # The location of the `unless` keyword.
+  #
+  #     unless cond then bar end
+  #     ^^^^^^
+  #
+  #     bar unless cond
+  #         ^^^^^^
+  #
+  # source://prism//lib/prism/node.rb#15959
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # source://prism//lib/prism/parse_result/newlines.rb#97
+  def newline_flag!(lines); end
+
+  # The condition to be evaluated for the unless expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     unless cond then bar end
+  #            ^^^^
+  #
+  #     bar unless cond
+  #                ^^^^
+  #
+  # source://prism//lib/prism/node.rb#15972
+  sig { returns(Prism::Node) }
+  def predicate; end
+
+  # The body of statements that will executed if the unless condition is
+  # falsey. Will be `nil` if no body is provided.
+  #
+  #     unless cond then bar end
+  #                      ^^^
+  #
+  # source://prism//lib/prism/node.rb#15995
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # def then_keyword: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#16025
+  sig { returns(T.nilable(String)) }
+  def then_keyword; end
+
+  # The location of the `then` keyword, if present.
+  #
+  #     unless cond then bar end
+  #                 ^^^^
+  #
+  # source://prism//lib/prism/node.rb#15978
+  sig { returns(T.nilable(Prism::Location)) }
+  def then_keyword_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#16040
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#16045
+    def type; end
+  end
+end
+
+# Represents the use of the `until` keyword, either in the block form or the modifier form.
+#
+#     bar until foo
+#     ^^^^^^^^^^^^^
+#
+#     until foo do bar end
+#     ^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#16069
+class Prism::UntilNode < ::Prism::Node
+  # Initialize a new UntilNode node.
+  #
+  # @return [UntilNode] a new instance of UntilNode
+  #
+  # source://prism//lib/prism/node.rb#16071
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, keyword_loc, closing_loc, predicate, statements); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#16176
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#16083
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def begin_modifier?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#16119
+  sig { returns(T::Boolean) }
+  def begin_modifier?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#16088
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#16155
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#16131
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#16101
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#16093
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode
+  #
+  # source://prism//lib/prism/node.rb#16106
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode)
+    ).returns(Prism::UntilNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#16088
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? }
+  #
+  # source://prism//lib/prism/node.rb#16114
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#16160
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#16150
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#16124
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # source://prism//lib/prism/parse_result/newlines.rb#103
+  def newline_flag!(lines); end
+
+  # attr_reader predicate: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#16144
+  sig { returns(Prism::Node) }
+  def predicate; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism//lib/prism/node.rb#16147
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#16165
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#16170
+    def type; end
+  end
+end
+
+# The version constant is set by reading the result of calling pm_version.
+Prism::VERSION = T.let(T.unsafe(nil), String)
+
+# A visitor is a class that provides a default implementation for every accept
+# method defined on the nodes. This means it can walk a tree without the
+# caller needing to define any special handling. This allows you to handle a
+# subset of the tree, while still walking the whole tree.
+#
+# For example, to find all of the method calls that call the `foo` method, you
+# could write:
+#
+#     class FooCalls < Prism::Visitor
+#       def visit_call_node(node)
+#         if node.name == "foo"
+#           # Do something with the node
+#         end
+#
+#         # Call super so that the visitor continues walking the tree
+#         super
+#       end
+#     end
+#
+# source://prism//lib/prism/visitor.rb#54
+class Prism::Visitor < ::Prism::BasicVisitor
+  # Visit a AliasGlobalVariableNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::AliasGlobalVariableNode).void }
+  def visit_alias_global_variable_node(node); end
+
+  # Visit a AliasMethodNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::AliasMethodNode).void }
+  def visit_alias_method_node(node); end
+
+  # Visit a AlternationPatternNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::AlternationPatternNode).void }
+  def visit_alternation_pattern_node(node); end
+
+  # Visit a AndNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::AndNode).void }
+  def visit_and_node(node); end
+
+  # Visit a ArgumentsNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ArgumentsNode).void }
+  def visit_arguments_node(node); end
+
+  # Visit a ArrayNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ArrayNode).void }
+  def visit_array_node(node); end
+
+  # Visit a ArrayPatternNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ArrayPatternNode).void }
+  def visit_array_pattern_node(node); end
+
+  # Visit a AssocNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::AssocNode).void }
+  def visit_assoc_node(node); end
+
+  # Visit a AssocSplatNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::AssocSplatNode).void }
+  def visit_assoc_splat_node(node); end
+
+  # Visit a BackReferenceReadNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::BackReferenceReadNode).void }
+  def visit_back_reference_read_node(node); end
+
+  # Visit a BeginNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::BeginNode).void }
+  def visit_begin_node(node); end
+
+  # Visit a BlockArgumentNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::BlockArgumentNode).void }
+  def visit_block_argument_node(node); end
+
+  # Visit a BlockLocalVariableNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::BlockLocalVariableNode).void }
+  def visit_block_local_variable_node(node); end
+
+  # Visit a BlockNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::BlockNode).void }
+  def visit_block_node(node); end
+
+  # Visit a BlockParameterNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::BlockParameterNode).void }
+  def visit_block_parameter_node(node); end
+
+  # Visit a BlockParametersNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::BlockParametersNode).void }
+  def visit_block_parameters_node(node); end
+
+  # Visit a BreakNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::BreakNode).void }
+  def visit_break_node(node); end
+
+  # Visit a CallAndWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::CallAndWriteNode).void }
+  def visit_call_and_write_node(node); end
+
+  # Visit a CallNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  # Visit a CallOperatorWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::CallOperatorWriteNode).void }
+  def visit_call_operator_write_node(node); end
+
+  # Visit a CallOrWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::CallOrWriteNode).void }
+  def visit_call_or_write_node(node); end
+
+  # Visit a CallTargetNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::CallTargetNode).void }
+  def visit_call_target_node(node); end
+
+  # Visit a CapturePatternNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::CapturePatternNode).void }
+  def visit_capture_pattern_node(node); end
+
+  # Visit a CaseMatchNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::CaseMatchNode).void }
+  def visit_case_match_node(node); end
+
+  # Visit a CaseNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::CaseNode).void }
+  def visit_case_node(node); end
+
+  # Visit a ClassNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  # Visit a ClassVariableAndWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ClassVariableAndWriteNode).void }
+  def visit_class_variable_and_write_node(node); end
+
+  # Visit a ClassVariableOperatorWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ClassVariableOperatorWriteNode).void }
+  def visit_class_variable_operator_write_node(node); end
+
+  # Visit a ClassVariableOrWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ClassVariableOrWriteNode).void }
+  def visit_class_variable_or_write_node(node); end
+
+  # Visit a ClassVariableReadNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ClassVariableReadNode).void }
+  def visit_class_variable_read_node(node); end
+
+  # Visit a ClassVariableTargetNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ClassVariableTargetNode).void }
+  def visit_class_variable_target_node(node); end
+
+  # Visit a ClassVariableWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ClassVariableWriteNode).void }
+  def visit_class_variable_write_node(node); end
+
+  # Visit a ConstantAndWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ConstantAndWriteNode).void }
+  def visit_constant_and_write_node(node); end
+
+  # Visit a ConstantOperatorWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ConstantOperatorWriteNode).void }
+  def visit_constant_operator_write_node(node); end
+
+  # Visit a ConstantOrWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ConstantOrWriteNode).void }
+  def visit_constant_or_write_node(node); end
+
+  # Visit a ConstantPathAndWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ConstantPathAndWriteNode).void }
+  def visit_constant_path_and_write_node(node); end
+
+  # Visit a ConstantPathNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ConstantPathNode).void }
+  def visit_constant_path_node(node); end
+
+  # Visit a ConstantPathOperatorWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
+  def visit_constant_path_operator_write_node(node); end
+
+  # Visit a ConstantPathOrWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ConstantPathOrWriteNode).void }
+  def visit_constant_path_or_write_node(node); end
+
+  # Visit a ConstantPathTargetNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ConstantPathTargetNode).void }
+  def visit_constant_path_target_node(node); end
+
+  # Visit a ConstantPathWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ConstantPathWriteNode).void }
+  def visit_constant_path_write_node(node); end
+
+  # Visit a ConstantReadNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ConstantReadNode).void }
+  def visit_constant_read_node(node); end
+
+  # Visit a ConstantTargetNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ConstantTargetNode).void }
+  def visit_constant_target_node(node); end
+
+  # Visit a ConstantWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ConstantWriteNode).void }
+  def visit_constant_write_node(node); end
+
+  # Visit a DefNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::DefNode).void }
+  def visit_def_node(node); end
+
+  # Visit a DefinedNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::DefinedNode).void }
+  def visit_defined_node(node); end
+
+  # Visit a ElseNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ElseNode).void }
+  def visit_else_node(node); end
+
+  # Visit a EmbeddedStatementsNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::EmbeddedStatementsNode).void }
+  def visit_embedded_statements_node(node); end
+
+  # Visit a EmbeddedVariableNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::EmbeddedVariableNode).void }
+  def visit_embedded_variable_node(node); end
+
+  # Visit a EnsureNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::EnsureNode).void }
+  def visit_ensure_node(node); end
+
+  # Visit a FalseNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::FalseNode).void }
+  def visit_false_node(node); end
+
+  # Visit a FindPatternNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::FindPatternNode).void }
+  def visit_find_pattern_node(node); end
+
+  # Visit a FlipFlopNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::FlipFlopNode).void }
+  def visit_flip_flop_node(node); end
+
+  # Visit a FloatNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::FloatNode).void }
+  def visit_float_node(node); end
+
+  # Visit a ForNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ForNode).void }
+  def visit_for_node(node); end
+
+  # Visit a ForwardingArgumentsNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ForwardingArgumentsNode).void }
+  def visit_forwarding_arguments_node(node); end
+
+  # Visit a ForwardingParameterNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ForwardingParameterNode).void }
+  def visit_forwarding_parameter_node(node); end
+
+  # Visit a ForwardingSuperNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ForwardingSuperNode).void }
+  def visit_forwarding_super_node(node); end
+
+  # Visit a GlobalVariableAndWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::GlobalVariableAndWriteNode).void }
+  def visit_global_variable_and_write_node(node); end
+
+  # Visit a GlobalVariableOperatorWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::GlobalVariableOperatorWriteNode).void }
+  def visit_global_variable_operator_write_node(node); end
+
+  # Visit a GlobalVariableOrWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::GlobalVariableOrWriteNode).void }
+  def visit_global_variable_or_write_node(node); end
+
+  # Visit a GlobalVariableReadNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::GlobalVariableReadNode).void }
+  def visit_global_variable_read_node(node); end
+
+  # Visit a GlobalVariableTargetNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::GlobalVariableTargetNode).void }
+  def visit_global_variable_target_node(node); end
+
+  # Visit a GlobalVariableWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::GlobalVariableWriteNode).void }
+  def visit_global_variable_write_node(node); end
+
+  # Visit a HashNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::HashNode).void }
+  def visit_hash_node(node); end
+
+  # Visit a HashPatternNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::HashPatternNode).void }
+  def visit_hash_pattern_node(node); end
+
+  # Visit a IfNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::IfNode).void }
+  def visit_if_node(node); end
+
+  # Visit a ImaginaryNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ImaginaryNode).void }
+  def visit_imaginary_node(node); end
+
+  # Visit a ImplicitNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ImplicitNode).void }
+  def visit_implicit_node(node); end
+
+  # Visit a ImplicitRestNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ImplicitRestNode).void }
+  def visit_implicit_rest_node(node); end
+
+  # Visit a InNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::InNode).void }
+  def visit_in_node(node); end
+
+  # Visit a IndexAndWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::IndexAndWriteNode).void }
+  def visit_index_and_write_node(node); end
+
+  # Visit a IndexOperatorWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::IndexOperatorWriteNode).void }
+  def visit_index_operator_write_node(node); end
+
+  # Visit a IndexOrWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::IndexOrWriteNode).void }
+  def visit_index_or_write_node(node); end
+
+  # Visit a IndexTargetNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::IndexTargetNode).void }
+  def visit_index_target_node(node); end
+
+  # Visit a InstanceVariableAndWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::InstanceVariableAndWriteNode).void }
+  def visit_instance_variable_and_write_node(node); end
+
+  # Visit a InstanceVariableOperatorWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Visit a InstanceVariableOrWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::InstanceVariableOrWriteNode).void }
+  def visit_instance_variable_or_write_node(node); end
+
+  # Visit a InstanceVariableReadNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::InstanceVariableReadNode).void }
+  def visit_instance_variable_read_node(node); end
+
+  # Visit a InstanceVariableTargetNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::InstanceVariableTargetNode).void }
+  def visit_instance_variable_target_node(node); end
+
+  # Visit a InstanceVariableWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::InstanceVariableWriteNode).void }
+  def visit_instance_variable_write_node(node); end
+
+  # Visit a IntegerNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::IntegerNode).void }
+  def visit_integer_node(node); end
+
+  # Visit a InterpolatedMatchLastLineNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::InterpolatedMatchLastLineNode).void }
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Visit a InterpolatedRegularExpressionNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::InterpolatedRegularExpressionNode).void }
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Visit a InterpolatedStringNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::InterpolatedStringNode).void }
+  def visit_interpolated_string_node(node); end
+
+  # Visit a InterpolatedSymbolNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::InterpolatedSymbolNode).void }
+  def visit_interpolated_symbol_node(node); end
+
+  # Visit a InterpolatedXStringNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::InterpolatedXStringNode).void }
+  def visit_interpolated_x_string_node(node); end
+
+  # Visit a ItLocalVariableReadNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ItLocalVariableReadNode).void }
+  def visit_it_local_variable_read_node(node); end
+
+  # Visit a ItParametersNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ItParametersNode).void }
+  def visit_it_parameters_node(node); end
+
+  # Visit a KeywordHashNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::KeywordHashNode).void }
+  def visit_keyword_hash_node(node); end
+
+  # Visit a KeywordRestParameterNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::KeywordRestParameterNode).void }
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Visit a LambdaNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::LambdaNode).void }
+  def visit_lambda_node(node); end
+
+  # Visit a LocalVariableAndWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::LocalVariableAndWriteNode).void }
+  def visit_local_variable_and_write_node(node); end
+
+  # Visit a LocalVariableOperatorWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::LocalVariableOperatorWriteNode).void }
+  def visit_local_variable_operator_write_node(node); end
+
+  # Visit a LocalVariableOrWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::LocalVariableOrWriteNode).void }
+  def visit_local_variable_or_write_node(node); end
+
+  # Visit a LocalVariableReadNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::LocalVariableReadNode).void }
+  def visit_local_variable_read_node(node); end
+
+  # Visit a LocalVariableTargetNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::LocalVariableTargetNode).void }
+  def visit_local_variable_target_node(node); end
+
+  # Visit a LocalVariableWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::LocalVariableWriteNode).void }
+  def visit_local_variable_write_node(node); end
+
+  # Visit a MatchLastLineNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::MatchLastLineNode).void }
+  def visit_match_last_line_node(node); end
+
+  # Visit a MatchPredicateNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::MatchPredicateNode).void }
+  def visit_match_predicate_node(node); end
+
+  # Visit a MatchRequiredNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::MatchRequiredNode).void }
+  def visit_match_required_node(node); end
+
+  # Visit a MatchWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::MatchWriteNode).void }
+  def visit_match_write_node(node); end
+
+  # Visit a MissingNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::MissingNode).void }
+  def visit_missing_node(node); end
+
+  # Visit a ModuleNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  # Visit a MultiTargetNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::MultiTargetNode).void }
+  def visit_multi_target_node(node); end
+
+  # Visit a MultiWriteNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::MultiWriteNode).void }
+  def visit_multi_write_node(node); end
+
+  # Visit a NextNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::NextNode).void }
+  def visit_next_node(node); end
+
+  # Visit a NilNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::NilNode).void }
+  def visit_nil_node(node); end
+
+  # Visit a NoKeywordsParameterNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::NoKeywordsParameterNode).void }
+  def visit_no_keywords_parameter_node(node); end
+
+  # Visit a NumberedParametersNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::NumberedParametersNode).void }
+  def visit_numbered_parameters_node(node); end
+
+  # Visit a NumberedReferenceReadNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::NumberedReferenceReadNode).void }
+  def visit_numbered_reference_read_node(node); end
+
+  # Visit a OptionalKeywordParameterNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::OptionalKeywordParameterNode).void }
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Visit a OptionalParameterNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::OptionalParameterNode).void }
+  def visit_optional_parameter_node(node); end
+
+  # Visit a OrNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::OrNode).void }
+  def visit_or_node(node); end
+
+  # Visit a ParametersNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ParametersNode).void }
+  def visit_parameters_node(node); end
+
+  # Visit a ParenthesesNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ParenthesesNode).void }
+  def visit_parentheses_node(node); end
+
+  # Visit a PinnedExpressionNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::PinnedExpressionNode).void }
+  def visit_pinned_expression_node(node); end
+
+  # Visit a PinnedVariableNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::PinnedVariableNode).void }
+  def visit_pinned_variable_node(node); end
+
+  # Visit a PostExecutionNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::PostExecutionNode).void }
+  def visit_post_execution_node(node); end
+
+  # Visit a PreExecutionNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::PreExecutionNode).void }
+  def visit_pre_execution_node(node); end
+
+  # Visit a ProgramNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ProgramNode).void }
+  def visit_program_node(node); end
+
+  # Visit a RangeNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::RangeNode).void }
+  def visit_range_node(node); end
+
+  # Visit a RationalNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::RationalNode).void }
+  def visit_rational_node(node); end
+
+  # Visit a RedoNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::RedoNode).void }
+  def visit_redo_node(node); end
+
+  # Visit a RegularExpressionNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::RegularExpressionNode).void }
+  def visit_regular_expression_node(node); end
+
+  # Visit a RequiredKeywordParameterNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::RequiredKeywordParameterNode).void }
+  def visit_required_keyword_parameter_node(node); end
+
+  # Visit a RequiredParameterNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::RequiredParameterNode).void }
+  def visit_required_parameter_node(node); end
+
+  # Visit a RescueModifierNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::RescueModifierNode).void }
+  def visit_rescue_modifier_node(node); end
+
+  # Visit a RescueNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::RescueNode).void }
+  def visit_rescue_node(node); end
+
+  # Visit a RestParameterNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::RestParameterNode).void }
+  def visit_rest_parameter_node(node); end
+
+  # Visit a RetryNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::RetryNode).void }
+  def visit_retry_node(node); end
+
+  # Visit a ReturnNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ReturnNode).void }
+  def visit_return_node(node); end
+
+  # Visit a SelfNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::SelfNode).void }
+  def visit_self_node(node); end
+
+  # Visit a ShareableConstantNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::ShareableConstantNode).void }
+  def visit_shareable_constant_node(node); end
+
+  # Visit a SingletonClassNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  # Visit a SourceEncodingNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::SourceEncodingNode).void }
+  def visit_source_encoding_node(node); end
+
+  # Visit a SourceFileNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::SourceFileNode).void }
+  def visit_source_file_node(node); end
+
+  # Visit a SourceLineNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::SourceLineNode).void }
+  def visit_source_line_node(node); end
+
+  # Visit a SplatNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::SplatNode).void }
+  def visit_splat_node(node); end
+
+  # Visit a StatementsNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::StatementsNode).void }
+  def visit_statements_node(node); end
+
+  # Visit a StringNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::StringNode).void }
+  def visit_string_node(node); end
+
+  # Visit a SuperNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::SuperNode).void }
+  def visit_super_node(node); end
+
+  # Visit a SymbolNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::SymbolNode).void }
+  def visit_symbol_node(node); end
+
+  # Visit a TrueNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::TrueNode).void }
+  def visit_true_node(node); end
+
+  # Visit a UndefNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::UndefNode).void }
+  def visit_undef_node(node); end
+
+  # Visit a UnlessNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::UnlessNode).void }
+  def visit_unless_node(node); end
+
+  # Visit a UntilNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::UntilNode).void }
+  def visit_until_node(node); end
+
+  # Visit a WhenNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::WhenNode).void }
+  def visit_when_node(node); end
+
+  # Visit a WhileNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::WhileNode).void }
+  def visit_while_node(node); end
+
+  # Visit a XStringNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::XStringNode).void }
+  def visit_x_string_node(node); end
+
+  # Visit a YieldNode node
+  #
+  # source://prism//lib/prism/visitor.rb#29
+  sig { params(node: Prism::YieldNode).void }
+  def visit_yield_node(node); end
+end
+
+# Represents the use of the `when` keyword within a case statement.
+#
+#     case true
+#     when true
+#     ^^^^^^^^^
+#     end
+#
+# source://prism//lib/prism/node.rb#16192
+class Prism::WhenNode < ::Prism::Node
+  # Initialize a new WhenNode node.
+  #
+  # @return [WhenNode] a new instance of WhenNode
+  #
+  # source://prism//lib/prism/node.rb#16194
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      conditions: T::Array[Prism::Node],
+      then_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, keyword_loc, conditions, then_keyword_loc, statements); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#16294
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#16206
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#16211
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#16224
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#16216
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # attr_reader conditions: Array[Prism::node]
+  #
+  # source://prism//lib/prism/node.rb#16249
+  sig { returns(T::Array[Prism::Node]) }
+  def conditions; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?) -> WhenNode
+  #
+  # source://prism//lib/prism/node.rb#16229
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      conditions: T::Array[Prism::Node],
+      then_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode)
+    ).returns(Prism::WhenNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), conditions: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#16211
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, conditions: Array[Prism::node], then_keyword_loc: Location?, statements: StatementsNode? }
+  #
+  # source://prism//lib/prism/node.rb#16237
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#16278
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#16268
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#16242
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism//lib/prism/node.rb#16265
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # def then_keyword: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#16273
+  sig { returns(T.nilable(String)) }
+  def then_keyword; end
+
+  # attr_reader then_keyword_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#16252
+  sig { returns(T.nilable(Prism::Location)) }
+  def then_keyword_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#16283
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#16288
+    def type; end
+  end
+end
+
+# Represents the use of the `while` keyword, either in the block form or the modifier form.
+#
+#     bar while foo
+#     ^^^^^^^^^^^^^
+#
+#     while foo do bar end
+#     ^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#16311
+class Prism::WhileNode < ::Prism::Node
+  # Initialize a new WhileNode node.
+  #
+  # @return [WhileNode] a new instance of WhileNode
+  #
+  # source://prism//lib/prism/node.rb#16313
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, keyword_loc, closing_loc, predicate, statements); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#16418
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#16325
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def begin_modifier?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#16361
+  sig { returns(T::Boolean) }
+  def begin_modifier?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#16330
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#16397
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#16373
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#16343
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#16335
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode
+  #
+  # source://prism//lib/prism/node.rb#16348
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode)
+    ).returns(Prism::WhileNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#16330
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? }
+  #
+  # source://prism//lib/prism/node.rb#16356
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#16402
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#16392
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#16366
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # source://prism//lib/prism/parse_result/newlines.rb#109
+  def newline_flag!(lines); end
+
+  # attr_reader predicate: Prism::node
+  #
+  # source://prism//lib/prism/node.rb#16386
+  sig { returns(Prism::Node) }
+  def predicate; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism//lib/prism/node.rb#16389
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#16407
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#16412
+    def type; end
+  end
+end
+
+# Represents an xstring literal with no interpolation.
+#
+#     `foo`
+#     ^^^^^
+#
+# source://prism//lib/prism/node.rb#16432
+class Prism::XStringNode < ::Prism::Node
+  include ::Prism::HeredocQuery
+
+  # Initialize a new XStringNode node.
+  #
+  # @return [XStringNode] a new instance of XStringNode
+  #
+  # source://prism//lib/prism/node.rb#16434
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#16544
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#16446
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#16451
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism//lib/prism/node.rb#16523
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#16503
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#16461
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#16456
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def content: () -> String
+  #
+  # source://prism//lib/prism/node.rb#16518
+  sig { returns(String) }
+  def content; end
+
+  # attr_reader content_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#16496
+  sig { returns(Prism::Location) }
+  def content_loc; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> XStringNode
+  #
+  # source://prism//lib/prism/node.rb#16466
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).returns(Prism::XStringNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#16451
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String }
+  #
+  # source://prism//lib/prism/node.rb#16474
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#16484
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism//lib/prism/node.rb#16479
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  sig { returns(T::Boolean) }
+  def heredoc?; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#16528
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String
+  #
+  # source://prism//lib/prism/node.rb#16513
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#16489
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # Occasionally it's helpful to treat a string as if it were interpolated so
+  # that there's a consistent interface for working with strings.
+  #
+  # source://prism//lib/prism/node_ext.rb#90
+  sig { returns(Prism::InterpolatedXStringNode) }
+  def to_interpolated; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#16533
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader unescaped: String
+  #
+  # source://prism//lib/prism/node.rb#16510
+  sig { returns(String) }
+  def unescaped; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#16538
+    def type; end
+  end
+end
+
+# Represents the use of the `yield` keyword.
+#
+#     yield 1
+#     ^^^^^^^
+#
+# source://prism//lib/prism/node.rb#16558
+class Prism::YieldNode < ::Prism::Node
+  # Initialize a new YieldNode node.
+  #
+  # @return [YieldNode] a new instance of YieldNode
+  #
+  # source://prism//lib/prism/node.rb#16560
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      lparen_loc: T.nilable(Prism::Location),
+      arguments: T.nilable(Prism::ArgumentsNode),
+      rparen_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, keyword_loc, lparen_loc, arguments, rparen_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  #
+  # source://prism//lib/prism/node.rb#16674
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism//lib/prism/node.rb#16572
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism//lib/prism/node.rb#16627
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#16577
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism//lib/prism/node.rb#16589
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism//lib/prism/node.rb#16582
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?) -> YieldNode
+  #
+  # source://prism//lib/prism/node.rb#16594
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      lparen_loc: T.nilable(Prism::Location),
+      arguments: T.nilable(Prism::ArgumentsNode),
+      rparen_loc: T.nilable(Prism::Location)
+    ).returns(Prism::YieldNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism//lib/prism/node.rb#16577
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location? }
+  #
+  # source://prism//lib/prism/node.rb#16602
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  #
+  # source://prism//lib/prism/node.rb#16658
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  #
+  # source://prism//lib/prism/node.rb#16643
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism//lib/prism/node.rb#16607
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # def lparen: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#16648
+  sig { returns(T.nilable(String)) }
+  def lparen; end
+
+  # attr_reader lparen_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#16614
+  sig { returns(T.nilable(Prism::Location)) }
+  def lparen_loc; end
+
+  # def rparen: () -> String?
+  #
+  # source://prism//lib/prism/node.rb#16653
+  sig { returns(T.nilable(String)) }
+  def rparen; end
+
+  # attr_reader rparen_loc: Location?
+  #
+  # source://prism//lib/prism/node.rb#16630
+  sig { returns(T.nilable(Prism::Location)) }
+  def rparen_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  #
+  # source://prism//lib/prism/node.rb#16663
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    #
+    # source://prism//lib/prism/node.rb#16668
+    def type; end
+  end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/pry@0.14.1.rbi b/Library/Homebrew/sorbet/rbi/gems/pry@0.14.1.rbi
deleted file mode 100644
index 8f04fe9c6fa39..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/pry@0.14.1.rbi
+++ /dev/null
@@ -1,2493 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `pry` gem.
-# Please instead update this file by running `bin/tapioca gem pry`.
-
-::RUBY19 = T.let(T.unsafe(nil), TrueClass)
-
-class BasicObject
-  def __binding__; end
-end
-
-class Object < ::BasicObject
-  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
-  include ::ActiveSupport::ForkTracker::CoreExt
-  include ::ActiveSupport::ForkTracker::CoreExtPrivate
-  include ::Kernel
-  include ::JSON::Ext::Generator::GeneratorMethods::Object
-  include ::PP::ObjectMixin
-  include ::ActiveSupport::Dependencies::Loadable
-  include ::ActiveSupport::Tryable
-
-  def __binding__; end
-  def pry(object = T.unsafe(nil), hash = T.unsafe(nil)); end
-end
-
-class Pry
-  extend ::Forwardable
-  extend ::Pry::Forwardable
-
-  def initialize(options = T.unsafe(nil)); end
-
-  def add_sticky_local(name, &block); end
-  def backtrace; end
-  def backtrace=(_arg0); end
-  def binding_stack; end
-  def binding_stack=(_arg0); end
-  def color(*args, &block); end
-  def color=(*args, &block); end
-  def commands(*args, &block); end
-  def commands=(*args, &block); end
-  def complete(str); end
-  def config; end
-  def current_binding; end
-  def current_context; end
-  def custom_completions; end
-  def custom_completions=(_arg0); end
-  def editor(*args, &block); end
-  def editor=(*args, &block); end
-  def eval(line, options = T.unsafe(nil)); end
-  def eval_string; end
-  def eval_string=(_arg0); end
-  def evaluate_ruby(code); end
-  def exception_handler(*args, &block); end
-  def exception_handler=(*args, &block); end
-  def exec_hook(name, *args, &block); end
-  def exit_value; end
-  def extra_sticky_locals(*args, &block); end
-  def extra_sticky_locals=(*args, &block); end
-  def hooks(*args, &block); end
-  def hooks=(*args, &block); end
-  def inject_local(name, value, binding); end
-  def inject_sticky_locals!; end
-  def input(*args, &block); end
-  def input=(*args, &block); end
-  def input_ring; end
-  def last_dir; end
-  def last_dir=(_arg0); end
-  def last_exception; end
-  def last_exception=(exception); end
-  def last_file; end
-  def last_file=(_arg0); end
-  def last_result; end
-  def last_result=(_arg0); end
-  def last_result_is_exception?; end
-  def memory_size; end
-  def memory_size=(size); end
-  def output; end
-  def output=(*args, &block); end
-  def output_ring; end
-  def pager; end
-  def pager=(*args, &block); end
-  def pop_prompt; end
-  def print(*args, &block); end
-  def print=(*args, &block); end
-  def process_command(val); end
-  def process_command_safely(val); end
-  def prompt; end
-  def prompt=(new_prompt); end
-  def push_binding(object); end
-  def push_initial_binding(target = T.unsafe(nil)); end
-  def push_prompt(new_prompt); end
-  def quiet?; end
-  def raise_up(*args); end
-  def raise_up!(*args); end
-  def raise_up_common(force, *args); end
-  def repl(target = T.unsafe(nil)); end
-  def reset_eval_string; end
-  def run_command(val); end
-  def select_prompt; end
-  def set_last_result(result, code = T.unsafe(nil)); end
-  def should_print?; end
-  def show_result(result); end
-  def sticky_locals; end
-  def suppress_output; end
-  def suppress_output=(_arg0); end
-  def update_input_history(code); end
-
-  private
-
-  def ensure_correct_encoding!(val); end
-  def generate_prompt(prompt_proc, conf); end
-  def handle_line(line, options); end
-  def prompt_stack; end
-
-  class << self
-    def Code(obj); end
-    def Method(obj); end
-    def WrappedModule(obj); end
-    def auto_resize!; end
-    def binding_for(target); end
-    def cli; end
-    def cli=(_arg0); end
-    def color(*args, &block); end
-    def color=(*args, &block); end
-    def commands(*args, &block); end
-    def commands=(*args, &block); end
-    def config; end
-    def config=(_arg0); end
-    def configure; end
-    def critical_section; end
-    def current; end
-    def current_line; end
-    def current_line=(_arg0); end
-    def custom_completions; end
-    def custom_completions=(_arg0); end
-    def editor(*args, &block); end
-    def editor=(*args, &block); end
-    def eval_path; end
-    def eval_path=(_arg0); end
-    def exception_handler(*args, &block); end
-    def exception_handler=(*args, &block); end
-    def extra_sticky_locals(*args, &block); end
-    def extra_sticky_locals=(*args, &block); end
-    def final_session_setup; end
-    def history(*args, &block); end
-    def history=(*args, &block); end
-    def hooks(*args, &block); end
-    def hooks=(*args, &block); end
-    def in_critical_section?; end
-    def init; end
-    def initial_session?; end
-    def initial_session_setup; end
-    def input(*args, &block); end
-    def input=(*args, &block); end
-    def last_internal_error; end
-    def last_internal_error=(_arg0); end
-    def line_buffer; end
-    def line_buffer=(_arg0); end
-    def load_file_at_toplevel(file); end
-    def load_file_through_repl(file_name); end
-    def load_history; end
-    def load_rc_files; end
-    def load_requires; end
-    def load_traps; end
-    def load_win32console; end
-    def main; end
-    def memory_size(*args, &block); end
-    def memory_size=(*args, &block); end
-    def output(*args, &block); end
-    def output=(*args, &block); end
-    def pager(*args, &block); end
-    def pager=(*args, &block); end
-    def print(*args, &block); end
-    def print=(*args, &block); end
-    def prompt(*args, &block); end
-    def prompt=(*args, &block); end
-    def quiet; end
-    def quiet=(_arg0); end
-    def rc_files_to_load; end
-    def real_path_to(file); end
-    def reset_defaults; end
-    def run_command(command_string, options = T.unsafe(nil)); end
-    def start(target = T.unsafe(nil), options = T.unsafe(nil)); end
-    def toplevel_binding; end
-    def toplevel_binding=(_arg0); end
-    def view_clip(obj, options = T.unsafe(nil)); end
-  end
-end
-
-Pry::BINDING_METHOD_IMPL = T.let(T.unsafe(nil), Array)
-
-class Pry::BasicObject < ::BasicObject
-  include ::Kernel
-end
-
-Pry::BasicObject::Dir = Dir
-Pry::BasicObject::ENV = T.let(T.unsafe(nil), Object)
-Pry::BasicObject::File = File
-Pry::BasicObject::Kernel = Kernel
-Pry::BasicObject::LoadError = LoadError
-Pry::BasicObject::Pry = Pry
-
-class Pry::BlockCommand < ::Pry::Command
-  def call(*args); end
-  def help; end
-end
-
-class Pry::CLI
-  class << self
-    def add_option_processor(&block); end
-    def add_options(&block); end
-    def input_args; end
-    def input_args=(_arg0); end
-    def option_processors; end
-    def option_processors=(_arg0); end
-    def options; end
-    def options=(_arg0); end
-    def parse_options(args = T.unsafe(nil)); end
-    def reset; end
-    def start(opts); end
-  end
-end
-
-class Pry::CLI::NoOptionsError < ::StandardError; end
-
-class Pry::ClassCommand < ::Pry::Command
-  def args; end
-  def args=(_arg0); end
-  def call(*args); end
-  def complete(search); end
-  def help; end
-  def options(opt); end
-  def opts; end
-  def opts=(_arg0); end
-  def process; end
-  def setup; end
-  def slop; end
-  def subcommands(cmd); end
-
-  class << self
-    def doc; end
-    def file; end
-    def inherited(klass); end
-    def line; end
-    def source; end
-    def source_file; end
-    def source_line; end
-    def source_location; end
-
-    private
-
-    def source_object; end
-  end
-end
-
-class Pry::Code
-  extend ::MethodSource::CodeHelpers
-
-  def initialize(lines = T.unsafe(nil), start_line = T.unsafe(nil), code_type = T.unsafe(nil)); end
-
-  def <<(line); end
-  def ==(other); end
-  def after(lineno, lines = T.unsafe(nil)); end
-  def around(lineno, lines = T.unsafe(nil)); end
-  def before(lineno, lines = T.unsafe(nil)); end
-  def between(start_line, end_line = T.unsafe(nil)); end
-  def code_type; end
-  def code_type=(_arg0); end
-  def comment_describing(line_number); end
-  def expression_at(line_number, consume = T.unsafe(nil)); end
-  def grep(pattern); end
-  def highlighted; end
-  def length; end
-  def max_lineno_width; end
-  def method_missing(method_name, *args, &block); end
-  def nesting_at(line_number); end
-  def print_to_output(output, color = T.unsafe(nil)); end
-  def push(line); end
-  def raw; end
-  def reject(&block); end
-  def select(&block); end
-  def take_lines(start_line, num_lines); end
-  def to_s; end
-  def with_indentation(spaces = T.unsafe(nil)); end
-  def with_line_numbers(y_n = T.unsafe(nil)); end
-  def with_marker(lineno = T.unsafe(nil)); end
-
-  protected
-
-  def alter(&block); end
-
-  private
-
-  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
-
-  class << self
-    def from_file(filename, code_type = T.unsafe(nil)); end
-    def from_method(meth, start_line = T.unsafe(nil)); end
-    def from_module(mod, candidate_rank = T.unsafe(nil), start_line = T.unsafe(nil)); end
-  end
-end
-
-class Pry::Code::CodeRange
-  def initialize(start_line, end_line = T.unsafe(nil)); end
-
-  def indices_range(lines); end
-
-  private
-
-  def end_line; end
-  def find_end_index(lines); end
-  def find_start_index(lines); end
-  def force_set_end_line; end
-  def indices(lines); end
-  def set_end_line_from_range; end
-  def start_line; end
-end
-
-class Pry::Code::LOC
-  def initialize(line, lineno); end
-
-  def ==(other); end
-  def add_line_number(max_width = T.unsafe(nil), color = T.unsafe(nil)); end
-  def add_marker(marker_lineno); end
-  def colorize(code_type); end
-  def dup; end
-  def handle_multiline_entries_from_edit_command(line, max_width); end
-  def indent(distance); end
-  def line; end
-  def lineno; end
-  def tuple; end
-end
-
-class Pry::CodeFile
-  def initialize(filename, code_type = T.unsafe(nil)); end
-
-  def code; end
-  def code_type; end
-
-  private
-
-  def abs_path; end
-  def code_path; end
-  def from_load_path; end
-  def from_pry_init_pwd; end
-  def from_pwd; end
-  def readable?(path); end
-  def type_from_filename(filename, default = T.unsafe(nil)); end
-end
-
-Pry::CodeFile::DEFAULT_EXT = T.let(T.unsafe(nil), String)
-Pry::CodeFile::EXTENSIONS = T.let(T.unsafe(nil), Hash)
-Pry::CodeFile::FILES = T.let(T.unsafe(nil), Hash)
-Pry::CodeFile::INITIAL_PWD = T.let(T.unsafe(nil), String)
-
-class Pry::CodeObject
-  include ::Pry::Helpers::OptionsHelpers
-  include ::Pry::Helpers::CommandHelpers
-
-  def initialize(str, pry_instance, options = T.unsafe(nil)); end
-
-  def command_lookup; end
-  def default_lookup; end
-  def empty_lookup; end
-  def method_or_class_lookup; end
-  def pry_instance; end
-  def pry_instance=(_arg0); end
-  def str; end
-  def str=(_arg0); end
-  def super_level; end
-  def super_level=(_arg0); end
-  def target; end
-  def target=(_arg0); end
-
-  private
-
-  def looks_like_an_instance_method?(str); end
-  def lookup_super(obj, super_level); end
-  def safe_to_evaluate?(str); end
-  def sourcable_object?(obj); end
-  def target_self; end
-
-  class << self
-    def lookup(str, pry_instance, options = T.unsafe(nil)); end
-  end
-end
-
-module Pry::CodeObject::Helpers
-  def c_method?; end
-  def c_module?; end
-  def command?; end
-  def module_with_yard_docs?; end
-  def real_method_object?; end
-end
-
-class Pry::ColorPrinter < ::PP
-  def pp(object); end
-  def text(str, max_width = T.unsafe(nil)); end
-
-  private
-
-  def highlight_object_literal(object_literal); end
-  def inspect_object(object); end
-
-  class << self
-    def default(_output, value, pry_instance); end
-    def pp(obj, output = T.unsafe(nil), max_width = T.unsafe(nil)); end
-  end
-end
-
-class Pry::Command
-  include ::Pry::Helpers::BaseHelpers
-  include ::Pry::Helpers::OptionsHelpers
-  include ::Pry::Helpers::CommandHelpers
-  include ::Pry::Helpers::Text
-  extend ::Pry::Helpers::DocumentationHelpers
-  extend ::Pry::CodeObject::Helpers
-
-  def initialize(context = T.unsafe(nil)); end
-
-  def _pry_; end
-  def _pry_=(_arg0); end
-  def arg_string; end
-  def arg_string=(_arg0); end
-  def block; end
-  def captures; end
-  def captures=(_arg0); end
-  def check_for_command_collision(command_match, arg_string); end
-  def command_block; end
-  def command_block=(_arg0); end
-  def command_name; end
-  def command_options; end
-  def command_set; end
-  def command_set=(_arg0); end
-  def commands; end
-  def complete(_search); end
-  def context; end
-  def context=(_arg0); end
-  def description; end
-  def eval_string; end
-  def eval_string=(_arg0); end
-  def hooks; end
-  def hooks=(_arg0); end
-  def interpolate_string(str); end
-  def match; end
-  def name; end
-  def output; end
-  def output=(_arg0); end
-  def process_line(line); end
-  def pry_instance; end
-  def pry_instance=(_arg0); end
-  def run(command_string, *args); end
-  def source; end
-  def state; end
-  def target; end
-  def target=(_arg0); end
-  def target_self; end
-  def tokenize(val); end
-  def void; end
-
-  private
-
-  def after_hooks; end
-  def before_hooks; end
-  def call_safely(*args); end
-  def call_with_hooks(*args); end
-  def find_hooks(event); end
-  def normalize_method_args(method, args); end
-  def pass_block(arg_string); end
-  def use_unpatched_symbol; end
-
-  class << self
-    def banner(arg = T.unsafe(nil)); end
-    def block; end
-    def block=(_arg0); end
-    def command_name; end
-    def command_options(arg = T.unsafe(nil)); end
-    def command_options=(_arg0); end
-    def command_regex; end
-    def convert_to_regex(obj); end
-    def default_options(match); end
-    def description(arg = T.unsafe(nil)); end
-    def description=(_arg0); end
-    def doc; end
-    def file; end
-    def group(name = T.unsafe(nil)); end
-    def inspect; end
-    def line; end
-    def match(arg = T.unsafe(nil)); end
-    def match=(_arg0); end
-    def match_score(val); end
-    def matches?(val); end
-    def name; end
-    def options(arg = T.unsafe(nil)); end
-    def options=(_arg0); end
-    def source; end
-    def source_file; end
-    def source_line; end
-    def state; end
-    def subclass(match, description, options, helpers, &block); end
-  end
-end
-
-class Pry::Command::AmendLine < ::Pry::ClassCommand
-  def process; end
-
-  private
-
-  def amend_input; end
-  def delete_from_array(array, range); end
-  def insert_into_array(array, range); end
-  def line_count; end
-  def line_range; end
-  def replace_in_array(array, range); end
-  def start_and_end_line_number; end
-  def zero_indexed_range_from_one_indexed_numbers(start_line_number, end_line_number); end
-end
-
-class Pry::Command::Bang < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::BangPry < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::Cat < ::Pry::ClassCommand
-  def complete(search); end
-  def load_path_completions; end
-  def options(opt); end
-  def process; end
-end
-
-class Pry::Command::Cat::AbstractFormatter
-  include ::Pry::Helpers::OptionsHelpers
-  include ::Pry::Helpers::CommandHelpers
-  include ::Pry::Helpers::BaseHelpers
-
-  private
-
-  def between_lines; end
-  def code_type; end
-  def decorate(content); end
-  def use_line_numbers?; end
-end
-
-class Pry::Command::Cat::ExceptionFormatter < ::Pry::Command::Cat::AbstractFormatter
-  include ::Pry::Helpers::Text
-
-  def initialize(exception, pry_instance, opts); end
-
-  def ex; end
-  def format; end
-  def opts; end
-  def pry_instance; end
-
-  private
-
-  def backtrace_file; end
-  def backtrace_level; end
-  def backtrace_line; end
-  def check_for_errors; end
-  def code_window_size; end
-  def header; end
-  def increment_backtrace_level; end
-  def start_and_end_line_for_code_window; end
-end
-
-class Pry::Command::Cat::FileFormatter < ::Pry::Command::Cat::AbstractFormatter
-  def initialize(file_with_embedded_line, pry_instance, opts); end
-
-  def file_and_line; end
-  def file_with_embedded_line; end
-  def format; end
-  def opts; end
-  def pry_instance; end
-
-  private
-
-  def code_type; end
-  def code_window_size; end
-  def decorate(content); end
-  def detect_code_type_from_file(file_name); end
-  def file_name; end
-  def line_number; end
-end
-
-class Pry::Command::Cat::InputExpressionFormatter < ::Pry::Command::Cat::AbstractFormatter
-  def initialize(input_expressions, opts); end
-
-  def format; end
-  def input_expressions; end
-  def input_expressions=(_arg0); end
-  def opts; end
-  def opts=(_arg0); end
-
-  private
-
-  def normalized_expression_range; end
-  def numbered_input_items; end
-  def selected_input_items; end
-end
-
-class Pry::Command::Cd < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::ChangeInspector < ::Pry::ClassCommand
-  def process(inspector); end
-
-  private
-
-  def inspector_map; end
-end
-
-class Pry::Command::ChangePrompt < ::Pry::ClassCommand
-  def options(opt); end
-  def process(prompt); end
-
-  private
-
-  def change_prompt(prompt); end
-  def list_prompts; end
-end
-
-class Pry::Command::ClearScreen < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::CodeCollector
-  include ::Pry::Helpers::OptionsHelpers
-  include ::Pry::Helpers::CommandHelpers
-
-  def initialize(args, opts, pry_instance); end
-
-  def args; end
-  def code_object; end
-  def content; end
-  def file; end
-  def file=(_arg0); end
-  def line_range; end
-  def obj_name; end
-  def opts; end
-  def pry_input_content; end
-  def pry_instance; end
-  def pry_output_content; end
-  def restrict_to_lines(content, range); end
-
-  private
-
-  def bad_option_combination?; end
-  def code_object_doc; end
-  def code_object_source_or_file; end
-  def convert_to_range(range); end
-  def could_not_locate(name); end
-  def file_content; end
-  def pry_array_content_as_string(array, ranges); end
-
-  class << self
-    def inject_options(opt); end
-    def input_expression_ranges; end
-    def input_expression_ranges=(_arg0); end
-    def output_result_ranges; end
-    def output_result_ranges=(_arg0); end
-  end
-end
-
-class Pry::Command::DisablePry < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::Edit < ::Pry::ClassCommand
-  def apply_runtime_patch; end
-  def bad_option_combination?; end
-  def code_object; end
-  def ensure_file_name_is_valid(file_name); end
-  def file_and_line; end
-  def file_and_line_for_current_exception; end
-  def file_based_exception?; end
-  def file_edit; end
-  def filename_argument; end
-  def initial_temp_file_content; end
-  def input_expression; end
-  def never_reload?; end
-  def options(opt); end
-  def patch_exception?; end
-  def previously_patched?(code_object); end
-  def probably_a_file?(str); end
-  def process; end
-  def pry_method?(code_object); end
-  def reload?(file_name = T.unsafe(nil)); end
-  def reloadable?; end
-  def repl_edit; end
-  def repl_edit?; end
-  def runtime_patch?; end
-end
-
-class Pry::Command::Edit::ExceptionPatcher
-  def initialize(pry_instance, state, exception_file_and_line); end
-
-  def file_and_line; end
-  def file_and_line=(_arg0); end
-  def perform_patch; end
-  def pry_instance; end
-  def pry_instance=(_arg0); end
-  def state; end
-  def state=(_arg0); end
-end
-
-module Pry::Command::Edit::FileAndLineLocator
-  class << self
-    def from_binding(target); end
-    def from_code_object(code_object, filename_argument); end
-    def from_exception(exception, backtrace_level); end
-    def from_filename_argument(filename_argument); end
-  end
-end
-
-class Pry::Command::Exit < ::Pry::ClassCommand
-  def process; end
-  def process_pop_and_return; end
-end
-
-class Pry::Command::ExitAll < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::ExitProgram < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::FindMethod < ::Pry::ClassCommand
-  extend ::Pry::Helpers::BaseHelpers
-
-  def options(opt); end
-  def process; end
-
-  private
-
-  def additional_info(header, method); end
-  def content_search(namespace); end
-  def matched_method_lines(header, method); end
-  def name_search(namespace); end
-  def pattern; end
-  def print_matches(matches); end
-  def print_matches_for_class(klass, grouped); end
-  def recurse_namespace(klass, done = T.unsafe(nil), &block); end
-  def search_all_methods(namespace); end
-  def search_class; end
-  def show_search_results(matches); end
-end
-
-class Pry::Command::FixIndent < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::Help < ::Pry::ClassCommand
-  def command_groups; end
-  def display_command(command); end
-  def display_filtered_commands(search); end
-  def display_filtered_search_results(search); end
-  def display_index(groups); end
-  def display_search(search); end
-  def group_sort_key(group_name); end
-  def help_text_for_commands(name, commands); end
-  def normalize(key); end
-  def process; end
-  def search_hash(search, hash); end
-  def sorted_commands(commands); end
-  def sorted_group_names(groups); end
-  def visible_commands; end
-end
-
-class Pry::Command::Hist < ::Pry::ClassCommand
-  def options(opt); end
-  def process; end
-
-  private
-
-  def check_for_juxtaposed_replay(replay_sequence); end
-  def find_history; end
-  def process_clear; end
-  def process_display; end
-  def process_replay; end
-  def process_save; end
-end
-
-class Pry::Command::ImportSet < ::Pry::ClassCommand
-  def process(_command_set_name); end
-end
-
-class Pry::Command::JumpTo < ::Pry::ClassCommand
-  def process(break_level); end
-end
-
-class Pry::Command::ListInspectors < ::Pry::ClassCommand
-  def process; end
-
-  private
-
-  def inspector_map; end
-  def selected_inspector?(inspector); end
-  def selected_text; end
-end
-
-class Pry::Command::Ls < ::Pry::ClassCommand
-  def no_user_opts?; end
-  def options(opt); end
-  def process; end
-
-  private
-
-  def error_list; end
-  def raise_errors_if_arguments_are_weird; end
-end
-
-class Pry::Command::Ls::Constants < ::Pry::Command::Ls::Formatter
-  include ::Pry::Command::Ls::Interrogatable
-
-  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
-
-  def correct_opts?; end
-  def output_self; end
-
-  private
-
-  def format(mod, constants); end
-  def show_deprecated_constants?; end
-end
-
-Pry::Command::Ls::Constants::DEPRECATED_CONSTANTS = T.let(T.unsafe(nil), Array)
-Pry::Command::Ls::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-
-class Pry::Command::Ls::Formatter
-  def initialize(pry_instance); end
-
-  def grep=(_arg0); end
-  def pry_instance; end
-  def write_out; end
-
-  private
-
-  def color(type, str); end
-  def correct_opts?; end
-  def format_value(value); end
-  def grep; end
-  def output_section(heading, body); end
-  def output_self; end
-end
-
-class Pry::Command::Ls::Globals < ::Pry::Command::Ls::Formatter
-  def initialize(opts, pry_instance); end
-
-  def output_self; end
-
-  private
-
-  def format(globals); end
-end
-
-Pry::Command::Ls::Globals::BUILTIN_GLOBALS = T.let(T.unsafe(nil), Array)
-Pry::Command::Ls::Globals::PSEUDO_GLOBALS = T.let(T.unsafe(nil), Array)
-
-class Pry::Command::Ls::Grep
-  def initialize(grep_regexp); end
-
-  def regexp; end
-end
-
-class Pry::Command::Ls::InstanceVars < ::Pry::Command::Ls::Formatter
-  include ::Pry::Command::Ls::Interrogatable
-
-  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
-
-  def correct_opts?; end
-  def output_self; end
-
-  private
-
-  def format(type, vars); end
-end
-
-module Pry::Command::Ls::Interrogatable
-  private
-
-  def interrogatee_mod; end
-  def interrogating_a_module?; end
-end
-
-module Pry::Command::Ls::JRubyHacks
-  private
-
-  def rubbishness(name); end
-  def trim_jruby_aliases(methods); end
-end
-
-class Pry::Command::Ls::LocalNames < ::Pry::Command::Ls::Formatter
-  def initialize(no_user_opts, args, pry_instance); end
-
-  def correct_opts?; end
-  def output_self; end
-
-  private
-
-  def format(locals); end
-end
-
-class Pry::Command::Ls::LocalVars < ::Pry::Command::Ls::Formatter
-  def initialize(opts, pry_instance); end
-
-  def output_self; end
-
-  private
-
-  def colorized_assignment_style(lhs, rhs, desired_width = T.unsafe(nil)); end
-  def format(name_value_pairs); end
-end
-
-class Pry::Command::Ls::LsEntity
-  def initialize(opts); end
-
-  def entities_table; end
-  def pry_instance; end
-
-  private
-
-  def constants; end
-  def entities; end
-  def globals; end
-  def grep(entity); end
-  def instance_vars; end
-  def local_names; end
-  def local_vars; end
-  def methods; end
-  def self_methods; end
-end
-
-class Pry::Command::Ls::Methods < ::Pry::Command::Ls::Formatter
-  include ::Pry::Command::Ls::Interrogatable
-  include ::Pry::Command::Ls::JRubyHacks
-  include ::Pry::Command::Ls::MethodsHelper
-
-  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
-
-  def output_self; end
-
-  private
-
-  def below_ceiling; end
-  def correct_opts?; end
-end
-
-module Pry::Command::Ls::MethodsHelper
-  include ::Pry::Command::Ls::JRubyHacks
-
-  private
-
-  def all_methods(instance_methods = T.unsafe(nil)); end
-  def format(methods); end
-  def resolution_order; end
-end
-
-class Pry::Command::Ls::SelfMethods < ::Pry::Command::Ls::Formatter
-  include ::Pry::Command::Ls::Interrogatable
-  include ::Pry::Command::Ls::JRubyHacks
-  include ::Pry::Command::Ls::MethodsHelper
-
-  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
-
-  def output_self; end
-
-  private
-
-  def correct_opts?; end
-end
-
-class Pry::Command::Nesting < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::Play < ::Pry::ClassCommand
-  def code_object; end
-  def content; end
-  def content_after_options; end
-  def content_at_expression; end
-  def default_file; end
-  def file_content; end
-  def options(opt); end
-  def perform_play; end
-  def process; end
-  def should_use_default_file?; end
-  def show_input; end
-end
-
-class Pry::Command::PryBacktrace < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::RaiseUp < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::ReloadCode < ::Pry::ClassCommand
-  def process; end
-
-  private
-
-  def check_for_reloadability(code_object, identifier); end
-  def current_file; end
-  def reload_current_file; end
-  def reload_object(identifier); end
-end
-
-class Pry::Command::Reset < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::Ri < ::Pry::ClassCommand
-  def process(spec); end
-end
-
-class Pry::Command::SaveFile < ::Pry::ClassCommand
-  def display_content; end
-  def file_name; end
-  def mode; end
-  def options(opt); end
-  def process; end
-  def save_file; end
-end
-
-class Pry::Command::ShellCommand < ::Pry::ClassCommand
-  def process(cmd); end
-
-  private
-
-  def cd_path_env; end
-  def cd_path_exists?; end
-  def parse_destination(dest); end
-  def path_from_cd_path(dest); end
-  def process_cd(dest); end
-  def special_case_path?(dest); end
-end
-
-class Pry::Command::ShellMode < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::ShowDoc < ::Pry::Command::ShowInfo
-  include ::Pry::Helpers::DocumentationHelpers
-
-  def content_for(code_object); end
-  def docs_for(code_object); end
-  def header_options; end
-  def process; end
-  def render_doc_markup_for(code_object); end
-  def start_line_for(code_object); end
-end
-
-class Pry::Command::ShowInfo < ::Pry::ClassCommand
-  extend ::Pry::Helpers::BaseHelpers
-
-  def initialize(*_arg0); end
-
-  def code_object_header(code_object, line_num); end
-  def code_object_with_accessible_source(code_object); end
-  def complete(input); end
-  def content_and_header_for_code_object(code_object); end
-  def content_and_headers_for_all_module_candidates(mod); end
-  def file_and_line_for(code_object); end
-  def header(code_object); end
-  def header_options; end
-  def method_header(code_object, line_num); end
-  def method_sections(code_object); end
-  def module_header(code_object, line_num); end
-  def no_definition_message; end
-  def obj_name; end
-  def options(opt); end
-  def process; end
-  def show_all_modules?(code_object); end
-  def start_line_for(code_object); end
-  def use_line_numbers?; end
-  def valid_superclass?(code_object); end
-end
-
-class Pry::Command::ShowInput < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::ShowSource < ::Pry::Command::ShowInfo
-  include ::Pry::Helpers::DocumentationHelpers
-
-  def content_for(code_object); end
-  def docs_for(code_object); end
-  def header_options; end
-  def options(opt); end
-  def process; end
-  def render_doc_markup_for(code_object); end
-  def start_line_for(code_object); end
-end
-
-class Pry::Command::Stat < ::Pry::ClassCommand
-  def options(opt); end
-  def process; end
-end
-
-class Pry::Command::SwitchTo < ::Pry::ClassCommand
-  def process(selection); end
-end
-
-class Pry::Command::ToggleColor < ::Pry::ClassCommand
-  def color_toggle; end
-  def process; end
-end
-
-Pry::Command::VOID_VALUE = T.let(T.unsafe(nil), Object)
-
-class Pry::Command::Version < ::Pry::ClassCommand
-  def process; end
-end
-
-class Pry::Command::WatchExpression < ::Pry::ClassCommand
-  def options(opt); end
-  def process; end
-
-  private
-
-  def add_expression(_arguments); end
-  def add_hook; end
-  def delete(index); end
-  def eval_and_print_changed(output); end
-  def expressions; end
-  def list; end
-end
-
-class Pry::Command::WatchExpression::Expression
-  def initialize(pry_instance, target, source); end
-
-  def changed?; end
-  def eval!; end
-  def previous_value; end
-  def pry_instance; end
-  def source; end
-  def target; end
-  def to_s; end
-  def value; end
-
-  private
-
-  def target_eval(target, source); end
-end
-
-class Pry::Command::Whereami < ::Pry::ClassCommand
-  def initialize(*_arg0); end
-
-  def bad_option_combination?; end
-  def code; end
-  def code?; end
-  def location; end
-  def options(opt); end
-  def process; end
-  def setup; end
-
-  private
-
-  def class_code; end
-  def code_window; end
-  def default_code; end
-  def expand_path(filename); end
-  def handle_internal_binding; end
-  def marker; end
-  def method_code; end
-  def nothing_to_do?; end
-  def small_method?; end
-  def target_class; end
-  def top_level?; end
-  def use_line_numbers?; end
-  def valid_method?; end
-  def window_size; end
-
-  class << self
-    def method_size_cutoff; end
-    def method_size_cutoff=(_arg0); end
-  end
-end
-
-class Pry::Command::Wtf < ::Pry::ClassCommand
-  def options(opt); end
-  def process; end
-
-  private
-
-  def format_backtrace(backtrace); end
-  def format_header(title, exception); end
-  def read_line(file, line); end
-  def trim_backtrace(backtrace); end
-  def unwind_exceptions; end
-end
-
-Pry::Command::Wtf::RUBY_FRAME_PATTERN = T.let(T.unsafe(nil), Regexp)
-class Pry::CommandError < ::StandardError; end
-
-class Pry::CommandSet
-  include ::Enumerable
-  include ::Pry::Helpers::BaseHelpers
-
-  def initialize(*imported_sets, &block); end
-
-  def [](pattern); end
-  def []=(pattern, command); end
-  def add_command(command); end
-  def alias_command(match, action, options = T.unsafe(nil)); end
-  def block_command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
-  def command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
-  def complete(search, context = T.unsafe(nil)); end
-  def create_command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
-  def delete(*searches); end
-  def desc(search, description = T.unsafe(nil)); end
-  def each(&block); end
-  def find_command(pattern); end
-  def find_command_by_match_or_listing(match_or_listing); end
-  def find_command_for_help(search); end
-  def helper_module; end
-  def import(*sets); end
-  def import_from(set, *matches); end
-  def keys; end
-  def list_commands; end
-  def process_line(val, context = T.unsafe(nil)); end
-  def rename_command(new_match, search, options = T.unsafe(nil)); end
-  def to_h; end
-  def to_hash; end
-  def valid_command?(val); end
-
-  private
-
-  def helpers(&block); end
-end
-
-class Pry::CommandState
-  def initialize; end
-
-  def reset(command_name); end
-  def state_for(command_name); end
-
-  class << self
-    def default; end
-  end
-end
-
-Pry::Commands = T.let(T.unsafe(nil), Pry::CommandSet)
-
-class Pry::Config
-  extend ::Pry::Config::Attributable
-
-  def initialize; end
-
-  def [](attr); end
-  def []=(attr, value); end
-  def auto_indent; end
-  def auto_indent=(_arg0); end
-  def collision_warning; end
-  def collision_warning=(_arg0); end
-  def color; end
-  def color=(_arg0); end
-  def command_completions; end
-  def command_completions=(_arg0); end
-  def command_prefix; end
-  def command_prefix=(_arg0); end
-  def commands; end
-  def commands=(_arg0); end
-  def completer; end
-  def completer=(_arg0); end
-  def control_d_handler; end
-  def control_d_handler=(value); end
-  def correct_indent; end
-  def correct_indent=(_arg0); end
-  def default_window_size; end
-  def default_window_size=(_arg0); end
-  def disable_auto_reload; end
-  def disable_auto_reload=(_arg0); end
-  def editor; end
-  def editor=(_arg0); end
-  def exception_handler; end
-  def exception_handler=(_arg0); end
-  def exception_whitelist; end
-  def exception_whitelist=(_arg0); end
-  def exec_string; end
-  def exec_string=(_arg0); end
-  def extra_sticky_locals; end
-  def extra_sticky_locals=(_arg0); end
-  def file_completions; end
-  def file_completions=(_arg0); end
-  def history; end
-  def history=(_arg0); end
-  def history_file; end
-  def history_file=(_arg0); end
-  def history_ignorelist; end
-  def history_ignorelist=(_arg0); end
-  def history_load; end
-  def history_load=(_arg0); end
-  def history_save; end
-  def history_save=(_arg0); end
-  def hooks; end
-  def hooks=(_arg0); end
-  def input; end
-  def input=(_arg0); end
-  def ls; end
-  def ls=(_arg0); end
-  def memory_size; end
-  def memory_size=(_arg0); end
-  def merge(config_hash); end
-  def merge!(config_hash); end
-  def method_missing(method_name, *args, &_block); end
-  def output; end
-  def output=(_arg0); end
-  def output_prefix; end
-  def output_prefix=(_arg0); end
-  def pager; end
-  def pager=(_arg0); end
-  def print; end
-  def print=(_arg0); end
-  def prompt; end
-  def prompt=(_arg0); end
-  def prompt_name; end
-  def prompt_name=(_arg0); end
-  def prompt_safe_contexts; end
-  def prompt_safe_contexts=(_arg0); end
-  def quiet; end
-  def quiet=(_arg0); end
-  def rc_file; end
-  def rc_file=(_arg0); end
-  def requires; end
-  def requires=(_arg0); end
-  def should_load_local_rc; end
-  def should_load_local_rc=(_arg0); end
-  def should_load_rc; end
-  def should_load_rc=(_arg0); end
-  def should_load_requires; end
-  def should_load_requires=(_arg0); end
-  def should_trap_interrupts; end
-  def should_trap_interrupts=(_arg0); end
-  def system; end
-  def system=(_arg0); end
-  def unrescued_exceptions; end
-  def unrescued_exceptions=(_arg0); end
-  def windows_console_warning; end
-  def windows_console_warning=(_arg0); end
-
-  private
-
-  def default_rc_file; end
-  def initialize_dup(other); end
-  def lazy_readline; end
-  def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end
-end
-
-module Pry::Config::Attributable
-  def attribute(attr_name); end
-end
-
-class Pry::Config::LazyValue
-  def initialize(&block); end
-
-  def call; end
-end
-
-class Pry::Config::MemoizedValue
-  def initialize(&block); end
-
-  def call; end
-end
-
-class Pry::Config::Value
-  def initialize(value); end
-
-  def call; end
-end
-
-module Pry::ControlDHandler
-  class << self
-    def default(pry_instance); end
-  end
-end
-
-Pry::EMPTY_COMPLETIONS = T.let(T.unsafe(nil), Array)
-
-class Pry::Editor
-  include ::Pry::Helpers::OptionsHelpers
-  include ::Pry::Helpers::CommandHelpers
-
-  def initialize(pry_instance); end
-
-  def build_editor_invocation_string(file, line, blocking); end
-  def edit_tempfile_with_content(initial_content, line = T.unsafe(nil)); end
-  def invoke_editor(file, line, blocking = T.unsafe(nil)); end
-  def pry_instance; end
-
-  private
-
-  def blocking_flag_for_editor(blocking); end
-  def editor_name; end
-  def open_editor(editor_invocation); end
-  def open_editor_on_jruby(editor_invocation); end
-  def start_line_syntax_for_editor(file_name, line_number); end
-
-  class << self
-    def default; end
-  end
-end
-
-module Pry::Env
-  class << self
-    def [](key); end
-  end
-end
-
-module Pry::ExceptionHandler
-  class << self
-    def handle_exception(output, exception, _pry_instance); end
-
-    private
-
-    def cause_text(cause); end
-    def exception_text(exception); end
-    def standard_error_text_for(exception); end
-  end
-end
-
-module Pry::Forwardable
-  include ::Forwardable
-
-  def def_private_delegators(target, *private_delegates); end
-end
-
-module Pry::FrozenObjectException
-  class << self
-    def ===(exception); end
-  end
-end
-
-Pry::HAS_SAFE_LEVEL = T.let(T.unsafe(nil), TrueClass)
-
-module Pry::Helpers
-  class << self
-    def tablify(things, line_length, pry_instance = T.unsafe(nil)); end
-    def tablify_or_one_line(heading, things, pry_instance = T.unsafe(nil)); end
-    def tablify_to_screen_width(things, options, pry_instance = T.unsafe(nil)); end
-  end
-end
-
-module Pry::Helpers::BaseHelpers
-  extend ::Pry::Helpers::BaseHelpers
-
-  def colorize_code(code); end
-  def find_command(name, set = T.unsafe(nil)); end
-  def heading(text); end
-  def highlight(string, regexp, highlight_color = T.unsafe(nil)); end
-  def not_a_real_file?(file); end
-  def safe_send(obj, method, *args, &block); end
-  def silence_warnings; end
-  def stagger_output(text, _out = T.unsafe(nil)); end
-  def use_ansi_codes?; end
-end
-
-module Pry::Helpers::CommandHelpers
-  include ::Pry::Helpers::OptionsHelpers
-  extend ::Pry::Helpers::OptionsHelpers
-  extend ::Pry::Helpers::CommandHelpers
-
-  def absolute_index_number(line_number, array_length); end
-  def absolute_index_range(range_or_number, array_length); end
-  def get_method_or_raise(method_name, context, opts = T.unsafe(nil)); end
-  def internal_binding?(context); end
-  def one_index_number(line_number); end
-  def one_index_range(range); end
-  def one_index_range_or_number(range_or_number); end
-  def restrict_to_lines(content, lines); end
-  def set_file_and_dir_locals(file_name, pry = T.unsafe(nil), ctx = T.unsafe(nil)); end
-  def temp_file(ext = T.unsafe(nil)); end
-  def unindent(dirty_text, left_padding = T.unsafe(nil)); end
-end
-
-module Pry::Helpers::DocumentationHelpers
-  private
-
-  def get_comment_content(comment); end
-  def process_comment_markup(comment); end
-  def process_rdoc(comment); end
-  def process_yardoc(comment); end
-  def process_yardoc_tag(comment, tag); end
-  def strip_comments_from_c_code(code); end
-  def strip_leading_whitespace(text); end
-
-  class << self
-    def get_comment_content(comment); end
-    def process_comment_markup(comment); end
-    def process_rdoc(comment); end
-    def process_yardoc(comment); end
-    def process_yardoc_tag(comment, tag); end
-    def strip_comments_from_c_code(code); end
-    def strip_leading_whitespace(text); end
-  end
-end
-
-Pry::Helpers::DocumentationHelpers::YARD_TAGS = T.let(T.unsafe(nil), Array)
-
-module Pry::Helpers::OptionsHelpers
-  private
-
-  def method_object; end
-  def method_options(opt); end
-
-  class << self
-    def method_object; end
-    def method_options(opt); end
-  end
-end
-
-module Pry::Helpers::Platform
-  class << self
-    def jruby?; end
-    def jruby_19?; end
-    def linux?; end
-    def mac_osx?; end
-    def mri?; end
-    def mri_19?; end
-    def mri_2?; end
-    def windows?; end
-    def windows_ansi?; end
-  end
-end
-
-class Pry::Helpers::Table
-  def initialize(items, args, pry_instance = T.unsafe(nil)); end
-
-  def ==(other); end
-  def column_count; end
-  def column_count=(count); end
-  def columns; end
-  def fits_on_line?(line_length); end
-  def items; end
-  def items=(items); end
-  def rows_to_s(style = T.unsafe(nil)); end
-  def to_a; end
-  def to_s; end
-
-  private
-
-  def _max_width(things); end
-  def _rebuild_colorless_cache; end
-  def _recall_color_for(thing); end
-  def _recolumn; end
-end
-
-module Pry::Helpers::Text
-  extend ::Pry::Helpers::Text
-
-  def black(text); end
-  def black_on_black(text); end
-  def black_on_blue(text); end
-  def black_on_cyan(text); end
-  def black_on_green(text); end
-  def black_on_magenta(text); end
-  def black_on_purple(text); end
-  def black_on_red(text); end
-  def black_on_white(text); end
-  def black_on_yellow(text); end
-  def blue(text); end
-  def blue_on_black(text); end
-  def blue_on_blue(text); end
-  def blue_on_cyan(text); end
-  def blue_on_green(text); end
-  def blue_on_magenta(text); end
-  def blue_on_purple(text); end
-  def blue_on_red(text); end
-  def blue_on_white(text); end
-  def blue_on_yellow(text); end
-  def bold(text); end
-  def bright_black(text); end
-  def bright_black_on_black(text); end
-  def bright_black_on_blue(text); end
-  def bright_black_on_cyan(text); end
-  def bright_black_on_green(text); end
-  def bright_black_on_magenta(text); end
-  def bright_black_on_purple(text); end
-  def bright_black_on_red(text); end
-  def bright_black_on_white(text); end
-  def bright_black_on_yellow(text); end
-  def bright_blue(text); end
-  def bright_blue_on_black(text); end
-  def bright_blue_on_blue(text); end
-  def bright_blue_on_cyan(text); end
-  def bright_blue_on_green(text); end
-  def bright_blue_on_magenta(text); end
-  def bright_blue_on_purple(text); end
-  def bright_blue_on_red(text); end
-  def bright_blue_on_white(text); end
-  def bright_blue_on_yellow(text); end
-  def bright_cyan(text); end
-  def bright_cyan_on_black(text); end
-  def bright_cyan_on_blue(text); end
-  def bright_cyan_on_cyan(text); end
-  def bright_cyan_on_green(text); end
-  def bright_cyan_on_magenta(text); end
-  def bright_cyan_on_purple(text); end
-  def bright_cyan_on_red(text); end
-  def bright_cyan_on_white(text); end
-  def bright_cyan_on_yellow(text); end
-  def bright_green(text); end
-  def bright_green_on_black(text); end
-  def bright_green_on_blue(text); end
-  def bright_green_on_cyan(text); end
-  def bright_green_on_green(text); end
-  def bright_green_on_magenta(text); end
-  def bright_green_on_purple(text); end
-  def bright_green_on_red(text); end
-  def bright_green_on_white(text); end
-  def bright_green_on_yellow(text); end
-  def bright_magenta(text); end
-  def bright_magenta_on_black(text); end
-  def bright_magenta_on_blue(text); end
-  def bright_magenta_on_cyan(text); end
-  def bright_magenta_on_green(text); end
-  def bright_magenta_on_magenta(text); end
-  def bright_magenta_on_purple(text); end
-  def bright_magenta_on_red(text); end
-  def bright_magenta_on_white(text); end
-  def bright_magenta_on_yellow(text); end
-  def bright_purple(text); end
-  def bright_purple_on_black(text); end
-  def bright_purple_on_blue(text); end
-  def bright_purple_on_cyan(text); end
-  def bright_purple_on_green(text); end
-  def bright_purple_on_magenta(text); end
-  def bright_purple_on_purple(text); end
-  def bright_purple_on_red(text); end
-  def bright_purple_on_white(text); end
-  def bright_purple_on_yellow(text); end
-  def bright_red(text); end
-  def bright_red_on_black(text); end
-  def bright_red_on_blue(text); end
-  def bright_red_on_cyan(text); end
-  def bright_red_on_green(text); end
-  def bright_red_on_magenta(text); end
-  def bright_red_on_purple(text); end
-  def bright_red_on_red(text); end
-  def bright_red_on_white(text); end
-  def bright_red_on_yellow(text); end
-  def bright_white(text); end
-  def bright_white_on_black(text); end
-  def bright_white_on_blue(text); end
-  def bright_white_on_cyan(text); end
-  def bright_white_on_green(text); end
-  def bright_white_on_magenta(text); end
-  def bright_white_on_purple(text); end
-  def bright_white_on_red(text); end
-  def bright_white_on_white(text); end
-  def bright_white_on_yellow(text); end
-  def bright_yellow(text); end
-  def bright_yellow_on_black(text); end
-  def bright_yellow_on_blue(text); end
-  def bright_yellow_on_cyan(text); end
-  def bright_yellow_on_green(text); end
-  def bright_yellow_on_magenta(text); end
-  def bright_yellow_on_purple(text); end
-  def bright_yellow_on_red(text); end
-  def bright_yellow_on_white(text); end
-  def bright_yellow_on_yellow(text); end
-  def cyan(text); end
-  def cyan_on_black(text); end
-  def cyan_on_blue(text); end
-  def cyan_on_cyan(text); end
-  def cyan_on_green(text); end
-  def cyan_on_magenta(text); end
-  def cyan_on_purple(text); end
-  def cyan_on_red(text); end
-  def cyan_on_white(text); end
-  def cyan_on_yellow(text); end
-  def default(text); end
-  def green(text); end
-  def green_on_black(text); end
-  def green_on_blue(text); end
-  def green_on_cyan(text); end
-  def green_on_green(text); end
-  def green_on_magenta(text); end
-  def green_on_purple(text); end
-  def green_on_red(text); end
-  def green_on_white(text); end
-  def green_on_yellow(text); end
-  def indent(text, chars); end
-  def magenta(text); end
-  def magenta_on_black(text); end
-  def magenta_on_blue(text); end
-  def magenta_on_cyan(text); end
-  def magenta_on_green(text); end
-  def magenta_on_magenta(text); end
-  def magenta_on_purple(text); end
-  def magenta_on_red(text); end
-  def magenta_on_white(text); end
-  def magenta_on_yellow(text); end
-  def no_color; end
-  def no_pager; end
-  def purple(text); end
-  def purple_on_black(text); end
-  def purple_on_blue(text); end
-  def purple_on_cyan(text); end
-  def purple_on_green(text); end
-  def purple_on_magenta(text); end
-  def purple_on_purple(text); end
-  def purple_on_red(text); end
-  def purple_on_white(text); end
-  def purple_on_yellow(text); end
-  def red(text); end
-  def red_on_black(text); end
-  def red_on_blue(text); end
-  def red_on_cyan(text); end
-  def red_on_green(text); end
-  def red_on_magenta(text); end
-  def red_on_purple(text); end
-  def red_on_red(text); end
-  def red_on_white(text); end
-  def red_on_yellow(text); end
-  def strip_color(text); end
-  def white(text); end
-  def white_on_black(text); end
-  def white_on_blue(text); end
-  def white_on_cyan(text); end
-  def white_on_green(text); end
-  def white_on_magenta(text); end
-  def white_on_purple(text); end
-  def white_on_red(text); end
-  def white_on_white(text); end
-  def white_on_yellow(text); end
-  def with_line_numbers(text, offset, color = T.unsafe(nil)); end
-  def yellow(text); end
-  def yellow_on_black(text); end
-  def yellow_on_blue(text); end
-  def yellow_on_cyan(text); end
-  def yellow_on_green(text); end
-  def yellow_on_magenta(text); end
-  def yellow_on_purple(text); end
-  def yellow_on_red(text); end
-  def yellow_on_white(text); end
-  def yellow_on_yellow(text); end
-end
-
-Pry::Helpers::Text::COLORS = T.let(T.unsafe(nil), Hash)
-
-class Pry::History
-  def initialize(options = T.unsafe(nil)); end
-
-  def <<(line); end
-  def clear; end
-  def filter(history); end
-  def history_line_count; end
-  def load; end
-  def loader; end
-  def loader=(_arg0); end
-  def original_lines; end
-  def push(line); end
-  def saver; end
-  def saver=(_arg0); end
-  def session_line_count; end
-  def to_a; end
-
-  private
-
-  def history_file; end
-  def history_file_path; end
-  def invalid_readline_line?(line); end
-  def read_from_file; end
-  def save_to_file(line); end
-  def should_ignore?(line); end
-
-  class << self
-    def default_file; end
-  end
-end
-
-class Pry::Hooks
-  def initialize; end
-
-  def add_hook(event_name, hook_name, callable = T.unsafe(nil), &block); end
-  def clear_event_hooks(event_name); end
-  def delete_hook(event_name, hook_name); end
-  def errors; end
-  def exec_hook(event_name, *args, &block); end
-  def get_hook(event_name, hook_name); end
-  def get_hooks(event_name); end
-  def hook_count(event_name); end
-  def hook_exists?(event_name, hook_name); end
-  def merge(other); end
-  def merge!(other); end
-
-  protected
-
-  def hooks; end
-
-  private
-
-  def initialize_copy(_orig); end
-
-  class << self
-    def default; end
-  end
-end
-
-class Pry::Indent
-  include ::Pry::Helpers::BaseHelpers
-
-  def initialize(pry_instance = T.unsafe(nil)); end
-
-  def correct_indentation(prompt, code, overhang = T.unsafe(nil)); end
-  def current_prefix; end
-  def end_of_statement?(last_token, last_kind); end
-  def in_string?; end
-  def indent(input); end
-  def indent_level; end
-  def indentation_delta(tokens); end
-  def module_nesting; end
-  def open_delimiters; end
-  def open_delimiters_line; end
-  def reset; end
-  def stack; end
-  def tokenize(string); end
-  def track_delimiter(token); end
-  def track_module_nesting(token, kind); end
-  def track_module_nesting_end(token, kind = T.unsafe(nil)); end
-
-  class << self
-    def indent(str); end
-    def nesting_at(str, line_number); end
-  end
-end
-
-Pry::Indent::IGNORE_TOKENS = T.let(T.unsafe(nil), Array)
-Pry::Indent::MIDWAY_TOKENS = T.let(T.unsafe(nil), Array)
-Pry::Indent::OPEN_TOKENS = T.let(T.unsafe(nil), Hash)
-Pry::Indent::OPTIONAL_DO_TOKENS = T.let(T.unsafe(nil), Array)
-Pry::Indent::SINGLELINE_TOKENS = T.let(T.unsafe(nil), Array)
-Pry::Indent::SPACES = T.let(T.unsafe(nil), String)
-Pry::Indent::STATEMENT_END_TOKENS = T.let(T.unsafe(nil), Array)
-class Pry::Indent::UnparseableNestingError < ::StandardError; end
-
-class Pry::InputCompleter
-  def initialize(input, pry = T.unsafe(nil)); end
-
-  def build_path(input); end
-  def call(str, options = T.unsafe(nil)); end
-  def ignored_modules; end
-  def select_message(path, receiver, message, candidates); end
-end
-
-Pry::InputCompleter::ARRAY_REGEXP = T.let(T.unsafe(nil), Regexp)
-Pry::InputCompleter::CONSTANT_OR_METHOD_REGEXP = T.let(T.unsafe(nil), Regexp)
-Pry::InputCompleter::CONSTANT_REGEXP = T.let(T.unsafe(nil), Regexp)
-Pry::InputCompleter::GLOBALVARIABLE_REGEXP = T.let(T.unsafe(nil), Regexp)
-Pry::InputCompleter::HEX_REGEXP = T.let(T.unsafe(nil), Regexp)
-Pry::InputCompleter::NUMERIC_REGEXP = T.let(T.unsafe(nil), Regexp)
-Pry::InputCompleter::PROC_OR_HASH_REGEXP = T.let(T.unsafe(nil), Regexp)
-Pry::InputCompleter::REGEX_REGEXP = T.let(T.unsafe(nil), Regexp)
-Pry::InputCompleter::RESERVED_WORDS = T.let(T.unsafe(nil), Array)
-Pry::InputCompleter::SYMBOL_METHOD_CALL_REGEXP = T.let(T.unsafe(nil), Regexp)
-Pry::InputCompleter::SYMBOL_REGEXP = T.let(T.unsafe(nil), Regexp)
-Pry::InputCompleter::TOPLEVEL_LOOKUP_REGEXP = T.let(T.unsafe(nil), Regexp)
-Pry::InputCompleter::VARIABLE_REGEXP = T.let(T.unsafe(nil), Regexp)
-Pry::InputCompleter::WORD_ESCAPE_STR = T.let(T.unsafe(nil), String)
-
-class Pry::InputLock
-  def initialize; end
-
-  def __with_ownership; end
-  def enter_interruptible_region; end
-  def interruptible_region; end
-  def leave_interruptible_region; end
-  def with_ownership(&block); end
-
-  class << self
-    def for(input); end
-    def global_lock; end
-    def global_lock=(_arg0); end
-    def input_locks; end
-    def input_locks=(_arg0); end
-  end
-end
-
-class Pry::InputLock::Interrupt < ::Exception; end
-class Pry::Inspector; end
-Pry::Inspector::MAP = T.let(T.unsafe(nil), Hash)
-Pry::LOCAL_RC_FILE = T.let(T.unsafe(nil), String)
-
-class Pry::LastException < ::BasicObject
-  def initialize(exception); end
-
-  def bt_index; end
-  def bt_index=(_arg0); end
-  def bt_source_location_for(index); end
-  def file; end
-  def inc_bt_index; end
-  def line; end
-  def method_missing(name, *args, &block); end
-  def wrapped_exception; end
-
-  private
-
-  def respond_to_missing?(name, include_all = T.unsafe(nil)); end
-end
-
-class Pry::Method
-  include ::Pry::Helpers::BaseHelpers
-  include ::Pry::Helpers::DocumentationHelpers
-  include ::Pry::CodeObject::Helpers
-  extend ::Pry::Helpers::BaseHelpers
-  extend ::Forwardable
-  extend ::Pry::Forwardable
-
-  def initialize(method, known_info = T.unsafe(nil)); end
-
-  def ==(other); end
-  def alias?; end
-  def aliases; end
-  def bound_method?; end
-  def comment; end
-  def doc; end
-  def dynamically_defined?; end
-  def is_a?(klass); end
-  def kind_of?(klass); end
-  def method_missing(method_name, *args, &block); end
-  def name; end
-  def name_with_owner; end
-  def original_name; end
-  def owner(*args, &block); end
-  def parameters(*args, &block); end
-  def pry_method?; end
-  def receiver(*args, &block); end
-  def redefine(source); end
-  def respond_to?(method_name, include_all = T.unsafe(nil)); end
-  def signature; end
-  def singleton_method?; end
-  def source; end
-  def source?; end
-  def source_file; end
-  def source_line; end
-  def source_range; end
-  def source_type; end
-  def super(times = T.unsafe(nil)); end
-  def unbound_method?; end
-  def undefined?; end
-  def visibility; end
-  def wrapped; end
-  def wrapped_owner; end
-
-  private
-
-  def c_source; end
-  def method_name_from_first_line(first_ln); end
-  def pry_doc_info; end
-  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
-  def ruby_source; end
-  def super_using_ancestors(ancestors, times = T.unsafe(nil)); end
-
-  class << self
-    def all_from_class(klass, include_super = T.unsafe(nil)); end
-    def all_from_obj(obj, include_super = T.unsafe(nil)); end
-    def from_binding(binding); end
-    def from_class(klass, name, target = T.unsafe(nil)); end
-    def from_module(klass, name, target = T.unsafe(nil)); end
-    def from_obj(obj, name, target = T.unsafe(nil)); end
-    def from_str(name, target = T.unsafe(nil), options = T.unsafe(nil)); end
-    def instance_method_definition?(name, definition_line); end
-    def instance_resolution_order(klass); end
-    def lookup_method_via_binding(obj, method_name, method_type, target = T.unsafe(nil)); end
-    def method_definition?(name, definition_line); end
-    def resolution_order(obj); end
-    def singleton_class_of(obj); end
-    def singleton_class_resolution_order(klass); end
-    def singleton_method_definition?(name, definition_line); end
-  end
-end
-
-class Pry::Method::Disowned < ::Pry::Method
-  def initialize(receiver, method_name); end
-
-  def method_missing(method_name, *args, &block); end
-  def name; end
-  def owner; end
-  def receiver; end
-  def source?; end
-  def undefined?; end
-
-  private
-
-  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
-end
-
-class Pry::Method::Patcher
-  def initialize(method); end
-
-  def method; end
-  def method=(_arg0); end
-  def patch_in_ram(source); end
-
-  private
-
-  def cache_key; end
-  def definition_for_owner(line); end
-  def redefine(source); end
-  def with_method_transaction; end
-  def wrap(source); end
-  def wrap_for_nesting(source); end
-  def wrap_for_owner(source); end
-
-  class << self
-    def code_for(filename); end
-  end
-end
-
-class Pry::Method::WeirdMethodLocator
-  def initialize(method, target); end
-
-  def find_method; end
-  def lost_method?; end
-  def method; end
-  def method=(_arg0); end
-  def target; end
-  def target=(_arg0); end
-
-  private
-
-  def all_methods_for(obj); end
-  def expanded_source_location(source_location); end
-  def find_method_in_superclass; end
-  def find_renamed_method; end
-  def index_to_line_number(index); end
-  def lines_for_file(file); end
-  def normal_method?(method); end
-  def pry_file?; end
-  def renamed_method_source_location; end
-  def skip_superclass_search?; end
-  def target_file; end
-  def target_line; end
-  def target_self; end
-  def valid_file?(file); end
-
-  class << self
-    def normal_method?(method, binding); end
-    def weird_method?(method, binding); end
-  end
-end
-
-class Pry::MethodNotFound < ::Pry::CommandError; end
-
-class Pry::NoCommandError < ::StandardError
-  def initialize(match, owner); end
-end
-
-class Pry::ObjectPath
-  def initialize(path_string, current_stack); end
-
-  def resolve; end
-
-  private
-
-  def complete?(segment); end
-  def handle_failure(context, err); end
-end
-
-Pry::ObjectPath::SPECIAL_TERMS = T.let(T.unsafe(nil), Array)
-class Pry::ObsoleteError < ::StandardError; end
-
-class Pry::Output
-  def initialize(pry_instance); end
-
-  def <<(*objs); end
-  def decolorize_maybe(str); end
-  def height; end
-  def method_missing(method_name, *args, &block); end
-  def print(*objs); end
-  def pry_instance; end
-  def puts(*objs); end
-  def size; end
-  def tty?; end
-  def width; end
-  def write(*objs); end
-
-  private
-
-  def actual_screen_size; end
-  def ansicon_env_size; end
-  def env_size; end
-  def io_console_size; end
-  def nonzero_column?(size); end
-  def readline_size; end
-  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
-end
-
-Pry::Output::DEFAULT_SIZE = T.let(T.unsafe(nil), Array)
-
-class Pry::Pager
-  def initialize(pry_instance); end
-
-  def open; end
-  def page(text); end
-  def pry_instance; end
-
-  private
-
-  def best_available; end
-  def enabled?; end
-  def output; end
-end
-
-class Pry::Pager::NullPager
-  def initialize(out); end
-
-  def <<(str); end
-  def close; end
-  def print(str); end
-  def puts(str); end
-  def write(str); end
-
-  private
-
-  def height; end
-  def width; end
-end
-
-class Pry::Pager::PageTracker
-  def initialize(rows, cols); end
-
-  def page?; end
-  def record(str); end
-  def reset; end
-
-  private
-
-  def line_length(line); end
-end
-
-class Pry::Pager::SimplePager < ::Pry::Pager::NullPager
-  def initialize(*_arg0); end
-
-  def write(str); end
-end
-
-class Pry::Pager::StopPaging < ::StandardError; end
-
-class Pry::Pager::SystemPager < ::Pry::Pager::NullPager
-  def initialize(*_arg0); end
-
-  def close; end
-  def write(str); end
-
-  private
-
-  def invoked_pager?; end
-  def pager; end
-  def write_to_pager(text); end
-
-  class << self
-    def available?; end
-    def default_pager; end
-  end
-end
-
-class Pry::Prompt
-  def initialize(name, description, prompt_procs); end
-
-  def [](key); end
-  def description; end
-  def incomplete_proc; end
-  def name; end
-  def prompt_procs; end
-  def wait_proc; end
-
-  class << self
-    def [](name); end
-    def add(name, description = T.unsafe(nil), separators = T.unsafe(nil)); end
-    def all; end
-  end
-end
-
-class Pry::REPL
-  extend ::Forwardable
-  extend ::Pry::Forwardable
-
-  def initialize(pry, options = T.unsafe(nil)); end
-
-  def input(*args, &block); end
-  def output(*args, &block); end
-  def pry; end
-  def pry=(_arg0); end
-  def start; end
-
-  private
-
-  def calculate_overhang(current_prompt, original_val, indented_val); end
-  def coolline_available?; end
-  def epilogue; end
-  def handle_read_errors; end
-  def input_readline(*args); end
-  def piping?; end
-  def prologue; end
-  def read; end
-  def read_line(current_prompt); end
-  def readline_available?; end
-  def repl; end
-  def set_readline_output; end
-
-  class << self
-    def start(options); end
-  end
-end
-
-class Pry::REPLFileLoader
-  def initialize(file_name); end
-
-  def define_additional_commands; end
-  def interactive_mode(pry_instance); end
-  def load; end
-  def non_interactive_mode(pry_instance, content); end
-end
-
-module Pry::RescuableException
-  class << self
-    def ===(exception); end
-  end
-end
-
-class Pry::Result
-  def initialize(is_command, retval = T.unsafe(nil)); end
-
-  def command?; end
-  def retval; end
-  def void_command?; end
-end
-
-class Pry::Ring
-  def initialize(max_size); end
-
-  def <<(value); end
-  def [](index); end
-  def clear; end
-  def count; end
-  def max_size; end
-  def size; end
-  def to_a; end
-
-  private
-
-  def transpose_buffer_tail; end
-end
-
-class Pry::Slop
-  include ::Enumerable
-
-  def initialize(config = T.unsafe(nil), &block); end
-
-  def [](key); end
-  def add_callback(label, &block); end
-  def banner(banner = T.unsafe(nil)); end
-  def banner=(banner); end
-  def command(command, options = T.unsafe(nil), &block); end
-  def config; end
-  def description(desc = T.unsafe(nil)); end
-  def description=(desc); end
-  def each(&block); end
-  def fetch_command(command); end
-  def fetch_option(key); end
-  def get(key); end
-  def help; end
-  def missing; end
-  def on(*objects, &block); end
-  def opt(*objects, &block); end
-  def option(*objects, &block); end
-  def options; end
-  def parse(items = T.unsafe(nil), &block); end
-  def parse!(items = T.unsafe(nil), &block); end
-  def present?(*keys); end
-  def run(callable = T.unsafe(nil), &block); end
-  def separator(text); end
-  def strict?; end
-  def to_h(include_commands = T.unsafe(nil)); end
-  def to_hash(include_commands = T.unsafe(nil)); end
-  def to_s; end
-
-  private
-
-  def autocreate(items, index); end
-  def build_option(objects, &block); end
-  def clean(object); end
-  def commands_to_help; end
-  def execute_multiple_switches(option, argument, index); end
-  def execute_option(option, argument, index, item = T.unsafe(nil)); end
-  def extract_long_flag(objects, config); end
-  def extract_option(flag); end
-  def extract_short_flag(objects, config); end
-  def method_missing(method, *args, &block); end
-  def process_item(items, index, &block); end
-  def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end
-
-  class << self
-    def optspec(string, config = T.unsafe(nil)); end
-    def parse(items = T.unsafe(nil), config = T.unsafe(nil), &block); end
-    def parse!(items = T.unsafe(nil), config = T.unsafe(nil), &block); end
-  end
-end
-
-class Pry::Slop::Commands
-  include ::Enumerable
-
-  def initialize(config = T.unsafe(nil), &block); end
-
-  def [](key); end
-  def arguments; end
-  def banner(banner = T.unsafe(nil)); end
-  def banner=(_arg0); end
-  def commands; end
-  def config; end
-  def default(config = T.unsafe(nil), &block); end
-  def each(&block); end
-  def get(key); end
-  def global(config = T.unsafe(nil), &block); end
-  def help; end
-  def inspect; end
-  def on(command, config = T.unsafe(nil), &block); end
-  def parse(items = T.unsafe(nil)); end
-  def parse!(items = T.unsafe(nil)); end
-  def present?(key); end
-  def to_hash; end
-  def to_s; end
-
-  private
-
-  def execute_arguments!(items); end
-  def execute_global_opts!(items); end
-end
-
-Pry::Slop::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-class Pry::Slop::Error < ::StandardError; end
-class Pry::Slop::InvalidArgumentError < ::Pry::Slop::Error; end
-class Pry::Slop::InvalidCommandError < ::Pry::Slop::Error; end
-class Pry::Slop::InvalidOptionError < ::Pry::Slop::Error; end
-class Pry::Slop::MissingArgumentError < ::Pry::Slop::Error; end
-class Pry::Slop::MissingOptionError < ::Pry::Slop::Error; end
-
-class Pry::Slop::Option
-  def initialize(slop, short, long, description, config = T.unsafe(nil), &block); end
-
-  def accepts_optional_argument?; end
-  def argument_in_value; end
-  def argument_in_value=(_arg0); end
-  def call(*objects); end
-  def config; end
-  def count; end
-  def count=(_arg0); end
-  def description; end
-  def expects_argument?; end
-  def help; end
-  def inspect; end
-  def key; end
-  def long; end
-  def short; end
-  def to_s; end
-  def types; end
-  def value; end
-  def value=(new_value); end
-
-  private
-
-  def value_to_float(value); end
-  def value_to_integer(value); end
-  def value_to_range(value); end
-end
-
-Pry::Slop::Option::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-Pry::Slop::VERSION = T.let(T.unsafe(nil), String)
-
-class Pry::SyntaxHighlighter
-  class << self
-    def highlight(code, language = T.unsafe(nil)); end
-    def keyword_token_color; end
-    def overwrite_coderay_comment_token!; end
-    def tokenize(code, language = T.unsafe(nil)); end
-  end
-end
-
-module Pry::SystemCommandHandler
-  class << self
-    def default(output, command, _pry_instance); end
-  end
-end
-
-module Pry::TooSafeException
-  class << self
-    def ===(exception); end
-  end
-end
-
-module Pry::UserError; end
-Pry::VERSION = T.let(T.unsafe(nil), String)
-
-module Pry::Warning
-  class << self
-    def warn(message); end
-  end
-end
-
-class Pry::WrappedModule
-  include ::Pry::Helpers::BaseHelpers
-  include ::Pry::CodeObject::Helpers
-
-  def initialize(mod); end
-
-  def candidate(rank); end
-  def candidates; end
-  def class?; end
-  def constants(inherit = T.unsafe(nil)); end
-  def doc; end
-  def file; end
-  def line; end
-  def method_missing(method_name, *args, &block); end
-  def method_prefix; end
-  def module?; end
-  def nonblank_name; end
-  def number_of_candidates; end
-  def singleton_class?; end
-  def singleton_instance; end
-  def source; end
-  def source_file; end
-  def source_line; end
-  def source_location; end
-  def super(times = T.unsafe(nil)); end
-  def wrapped; end
-  def yard_doc; end
-  def yard_docs?; end
-  def yard_file; end
-  def yard_line; end
-
-  private
-
-  def all_methods_for(mod); end
-  def all_relevant_methods_for(mod); end
-  def all_source_locations_by_popularity; end
-  def lines_for_file(file); end
-  def method_candidates; end
-  def method_defined_by_forwardable_module?(method); end
-  def nested_module?(parent, name); end
-  def primary_candidate; end
-  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
-
-  class << self
-    def from_str(mod_name, target = T.unsafe(nil)); end
-
-    private
-
-    def safe_to_evaluate?(str, target); end
-  end
-end
-
-class Pry::WrappedModule::Candidate
-  include ::Pry::Helpers::DocumentationHelpers
-  include ::Pry::CodeObject::Helpers
-  extend ::Forwardable
-  extend ::Pry::Forwardable
-
-  def initialize(wrapper, rank); end
-
-  def class?(*args, &block); end
-  def doc; end
-  def file; end
-  def line; end
-  def module?(*args, &block); end
-  def nonblank_name(*args, &block); end
-  def number_of_candidates(*args, &block); end
-  def source; end
-  def source_file; end
-  def source_line; end
-  def source_location; end
-  def wrapped(*args, &block); end
-
-  private
-
-  def class_regexes; end
-  def first_line_of_module_definition(file, line); end
-  def first_method_source_location; end
-  def last_method_source_location; end
-  def lines_for_file(*a, &b); end
-  def method_candidates(*a, &b); end
-  def name(*a, &b); end
-  def number_of_lines_in_first_chunk; end
-  def yard_docs?(*a, &b); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/pry@0.14.2.rbi b/Library/Homebrew/sorbet/rbi/gems/pry@0.14.2.rbi
new file mode 100644
index 0000000000000..10ea8f68ea505
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/pry@0.14.2.rbi
@@ -0,0 +1,10069 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `pry` gem.
+# Please instead update this file by running `bin/tapioca gem pry`.
+
+# source://pry//lib/pry/core_extensions.rb#115
+class BasicObject
+  # Return a binding object for the receiver.
+  #
+  # The `self` of the binding is set to the current object, and it contains no
+  # local variables.
+  #
+  # The default definee (http://yugui.jp/articles/846) is set such that new
+  # methods defined will be added to the singleton class of the BasicObject.
+  #
+  # @return [Binding]
+  #
+  # source://pry//lib/pry/core_extensions.rb#125
+  def __binding__; end
+end
+
+# source://pry//lib/pry/core_extensions.rb#24
+class Object < ::BasicObject
+  include ::Kernel
+  include ::PP::ObjectMixin
+
+  # Return a binding object for the receiver.
+  #
+  # The `self` of the binding is set to the current object, and it contains no
+  # local variables.
+  #
+  # The default definee (http://yugui.jp/articles/846) is set such that:
+  #
+  # * If `self` is a class or module, then new methods created in the binding
+  #   will be defined in that class or module (as in `class Foo; end`).
+  # * If `self` is a normal object, then new methods created in the binding will
+  #   be defined on its singleton class (as in `class << self; end`).
+  # * If `self` doesn't have a  real singleton class (i.e. it is a Fixnum, Float,
+  #   Symbol, nil, true, or false), then new methods will be created on the
+  #   object's class (as in `self.class.class_eval{ }`)
+  #
+  # Newly created constants, including classes and modules, will also be added
+  # to the default definee.
+  #
+  # @return [Binding]
+  #
+  # source://pry//lib/pry/core_extensions.rb#70
+  def __binding__; end
+
+  # Start a Pry REPL on self.
+  #
+  # If `self` is a Binding then that will be used to evaluate expressions;
+  # otherwise a new binding will be created.
+  #
+  # @example With a binding
+  #   binding.pry
+  # @example On any object
+  #   "dummy".pry
+  # @example With options
+  #   def my_method
+  #   binding.pry :quiet => true
+  #   end
+  #   my_method()
+  # @param object [Object] the object or binding to pry
+  #   (__deprecated__, use `object.pry`)
+  # @param hash [Hash] the options hash
+  # @see Pry.start
+  #
+  # source://pry//lib/pry/core_extensions.rb#43
+  def pry(object = T.unsafe(nil), hash = T.unsafe(nil)); end
+end
+
+# source://pry//lib/pry/version.rb#3
+class Pry
+  extend ::Forwardable
+  extend ::Pry::Forwardable
+
+  # Create a new {Pry} instance.
+  #
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @param options [Hash]
+  # @return [Pry] a new instance of Pry
+  #
+  # source://pry//lib/pry/pry_instance.rb#81
+  def initialize(options = T.unsafe(nil)); end
+
+  # Add a sticky local to this Pry instance.
+  # A sticky local is a local that persists between all bindings in a session.
+  #
+  # @param name [Symbol] The name of the sticky local.
+  # @yield The block that defines the content of the local. The local
+  #   will be refreshed at each tick of the repl loop.
+  #
+  # source://pry//lib/pry/pry_instance.rb#212
+  def add_sticky_local(name, &block); end
+
+  # Returns the value of attribute backtrace.
+  #
+  # source://pry//lib/pry/pry_instance.rb#35
+  def backtrace; end
+
+  # Sets the attribute backtrace
+  #
+  # @param value the value to set the attribute backtrace to.
+  #
+  # source://pry//lib/pry/pry_instance.rb#35
+  def backtrace=(_arg0); end
+
+  # Returns the value of attribute binding_stack.
+  #
+  # source://pry//lib/pry/pry_instance.rb#32
+  def binding_stack; end
+
+  # Sets the attribute binding_stack
+  #
+  # @param value the value to set the attribute binding_stack to.
+  #
+  # source://pry//lib/pry/pry_instance.rb#32
+  def binding_stack=(_arg0); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def color(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def color=(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def commands(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def commands=(*args, **_arg1, &block); end
+
+  # Generate completions.
+  #
+  # @param str [String] What the user has typed so far
+  # @return [Array<String>] Possible completions
+  #
+  # source://pry//lib/pry/pry_instance.rb#145
+  def complete(str); end
+
+  # Returns the value of attribute config.
+  #
+  # source://pry//lib/pry/pry_instance.rb#50
+  def config; end
+
+  # The currently active `Binding`.
+  #
+  # @return [Binding] The currently active `Binding` for the session.
+  #
+  # source://pry//lib/pry/pry_instance.rb#124
+  def current_binding; end
+
+  # The currently active `Binding`.
+  # support previous API
+  #
+  # @return [Binding] The currently active `Binding` for the session.
+  #
+  # source://pry//lib/pry/pry_instance.rb#124
+  def current_context; end
+
+  # Returns the value of attribute custom_completions.
+  #
+  # source://pry//lib/pry/pry_instance.rb#33
+  def custom_completions; end
+
+  # Sets the attribute custom_completions
+  #
+  # @param value the value to set the attribute custom_completions to.
+  #
+  # source://pry//lib/pry/pry_instance.rb#33
+  def custom_completions=(_arg0); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def editor(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def editor=(*args, **_arg1, &block); end
+
+  # Pass a line of input to Pry.
+  #
+  # This is the equivalent of `Binding#eval` but with extra Pry!
+  #
+  # In particular:
+  # 1. Pry commands will be executed immediately if the line matches.
+  # 2. Partial lines of input will be queued up until a complete expression has
+  #    been accepted.
+  # 3. Output is written to `#output` in pretty colours, not returned.
+  #
+  # Once this method has raised an exception or returned false, this instance
+  # is no longer usable. {#exit_value} will return the session's breakout
+  # value if applicable.
+  #
+  # @option options
+  # @param line [String?] The line of input; `nil` if the user types `<Ctrl-D>`
+  # @param options [Hash] a customizable set of options
+  # @raise [Exception] If the user uses the `raise-up` command, this method
+  #   will raise that exception.
+  # @return [Boolean] Is Pry ready to accept more input?
+  #
+  # source://pry//lib/pry/pry_instance.rb#255
+  def eval(line, options = T.unsafe(nil)); end
+
+  # Returns the value of attribute eval_string.
+  #
+  # source://pry//lib/pry/pry_instance.rb#34
+  def eval_string; end
+
+  # Sets the attribute eval_string
+  #
+  # @param value the value to set the attribute eval_string to.
+  #
+  # source://pry//lib/pry/pry_instance.rb#34
+  def eval_string=(_arg0); end
+
+  # source://pry//lib/pry/pry_instance.rb#286
+  def evaluate_ruby(code); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def exception_handler(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def exception_handler=(*args, **_arg1, &block); end
+
+  # Execute the specified hook.
+  # If executing a hook raises an exception, we log that and then continue sucessfully.
+  # To debug such errors, use the global variable $pry_hook_error, which is set as a
+  # result.
+  #
+  # @param name [Symbol] The hook name to execute
+  # @param args [*Object] The arguments to pass to the hook
+  # @return [Object, Exception] The return value of the hook or the exception raised
+  #
+  # source://pry//lib/pry/pry_instance.rb#394
+  def exec_hook(name, *args, &block); end
+
+  # Returns the value of attribute exit_value.
+  #
+  # source://pry//lib/pry/pry_instance.rb#42
+  def exit_value; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def extra_sticky_locals(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def extra_sticky_locals=(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def hooks(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def hooks=(*args, **_arg1, &block); end
+
+  # Injects a local variable into the provided binding.
+  #
+  # @param name [String] The name of the local to inject.
+  # @param value [Object] The value to set the local to.
+  # @param binding [Binding] The binding to set the local on.
+  # @return [Object] The value the local was set to.
+  #
+  # source://pry//lib/pry/pry_instance.rb#173
+  def inject_local(name, value, binding); end
+
+  # Inject all the sticky locals into the current binding.
+  #
+  # source://pry//lib/pry/pry_instance.rb#201
+  def inject_sticky_locals!; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def input(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def input=(*args, **_arg1, &block); end
+
+  # @since v0.12.0
+  #
+  # source://pry//lib/pry/pry_instance.rb#45
+  def input_ring; end
+
+  # Returns the value of attribute last_dir.
+  #
+  # source://pry//lib/pry/pry_instance.rb#39
+  def last_dir; end
+
+  # Sets the attribute last_dir
+  #
+  # @param value the value to set the attribute last_dir to.
+  #
+  # source://pry//lib/pry/pry_instance.rb#39
+  def last_dir=(_arg0); end
+
+  # Returns the value of attribute last_exception.
+  #
+  # source://pry//lib/pry/pry_instance.rb#41
+  def last_exception; end
+
+  # Set the last exception for a session.
+  #
+  # @param exception [Exception] The last exception.
+  #
+  # source://pry//lib/pry/pry_instance.rb#418
+  def last_exception=(exception); end
+
+  # Returns the value of attribute last_file.
+  #
+  # source://pry//lib/pry/pry_instance.rb#38
+  def last_file; end
+
+  # Sets the attribute last_file
+  #
+  # @param value the value to set the attribute last_file to.
+  #
+  # source://pry//lib/pry/pry_instance.rb#38
+  def last_file=(_arg0); end
+
+  # Returns the value of attribute last_result.
+  #
+  # source://pry//lib/pry/pry_instance.rb#37
+  def last_result; end
+
+  # Sets the attribute last_result
+  #
+  # @param value the value to set the attribute last_result to.
+  #
+  # source://pry//lib/pry/pry_instance.rb#37
+  def last_result=(_arg0); end
+
+  # @return [Boolean] True if the last result is an exception that was raised,
+  #   as opposed to simply an instance of Exception (like the result of
+  #   Exception.new)
+  #
+  # source://pry//lib/pry/pry_instance.rb#440
+  def last_result_is_exception?; end
+
+  # @return [Integer] The maximum amount of objects remembered by the inp and
+  #   out arrays. Defaults to 100.
+  #
+  # source://pry//lib/pry/pry_instance.rb#190
+  def memory_size; end
+
+  # source://pry//lib/pry/pry_instance.rb#195
+  def memory_size=(size); end
+
+  # Returns an output device
+  #
+  # @example
+  #   pry_instance.output.puts "ohai!"
+  #
+  # source://pry//lib/pry/pry_instance.rb#538
+  def output; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def output=(*args, **_arg1, &block); end
+
+  # @since v0.12.0
+  #
+  # source://pry//lib/pry/pry_instance.rb#48
+  def output_ring; end
+
+  # Returns the currently configured pager
+  #
+  # @example
+  #   pry_instance.pager.page text
+  #
+  # source://pry//lib/pry/pry_instance.rb#530
+  def pager; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def pager=(*args, **_arg1, &block); end
+
+  # Pops the current prompt off of the prompt stack. If the prompt you are
+  # popping is the last prompt, it will not be popped. Use this to restore the
+  # previous prompt.
+  #
+  # @example
+  #   pry = Pry.new(prompt: Pry::Prompt[:my_prompt1])
+  #   pry.push_prompt(Pry::Prompt[:my_prompt2])
+  #   pry.pop_prompt # => prompt2
+  #   pry.pop_prompt # => prompt1
+  #   pry.pop_prompt # => prompt1
+  # @return [Pry::Prompt] the prompt being popped
+  #
+  # source://pry//lib/pry/pry_instance.rb#522
+  def pop_prompt; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def print(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def print=(*args, **_arg1, &block); end
+
+  # If the given line is a valid command, process it in the context of the
+  # current `eval_string` and binding.
+  #
+  # @param val [String] The line to process.
+  # @return [Boolean] `true` if `val` is a command, `false` otherwise
+  #
+  # source://pry//lib/pry/pry_instance.rb#325
+  def process_command(val); end
+
+  # Same as process_command, but outputs exceptions to `#output` instead of
+  # raising.
+  #
+  # @param val [String] The line to process.
+  # @return [Boolean] `true` if `val` is a command, `false` otherwise
+  #
+  # source://pry//lib/pry/pry_instance.rb#360
+  def process_command_safely(val); end
+
+  # This is the prompt at the top of the prompt stack.
+  #
+  # @return [Pry::Prompt] the current prompt
+  #
+  # source://pry//lib/pry/pry_instance.rb#101
+  def prompt; end
+
+  # Sets the Pry prompt.
+  #
+  # @param new_prompt [Pry::Prompt]
+  # @return [void]
+  #
+  # source://pry//lib/pry/pry_instance.rb#108
+  def prompt=(new_prompt); end
+
+  # Push a binding for the given object onto the stack. If this instance is
+  # currently stopped, mark it as usable again.
+  #
+  # source://pry//lib/pry/pry_instance.rb#131
+  def push_binding(object); end
+
+  # Initialize this instance by pushing its initial context into the binding
+  # stack. If no target is given, start at the top level.
+  #
+  # source://pry//lib/pry/pry_instance.rb#118
+  def push_initial_binding(target = T.unsafe(nil)); end
+
+  # Pushes the current prompt onto a stack that it can be restored from later.
+  # Use this if you wish to temporarily change the prompt.
+  #
+  # @example
+  #   push_prompt(Pry::Prompt[:my_prompt])
+  # @param new_prompt [Pry::Prompt]
+  # @return [Pry::Prompt] new_prompt
+  #
+  # source://pry//lib/pry/pry_instance.rb#506
+  def push_prompt(new_prompt); end
+
+  # Convenience accessor for the `quiet` config key.
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/pry_instance.rb#592
+  def quiet?; end
+
+  # source://pry//lib/pry/pry_instance.rb#582
+  def raise_up(*args); end
+
+  # source://pry//lib/pry/pry_instance.rb#586
+  def raise_up!(*args); end
+
+  # Raise an exception out of Pry.
+  #
+  # See Kernel#raise for documentation of parameters.
+  # See rb_make_exception for the inbuilt implementation.
+  #
+  # This is necessary so that the raise-up command can tell the
+  # difference between an exception the user has decided to raise,
+  # and a mistake in specifying that exception.
+  #
+  # (i.e. raise-up RunThymeError.new should not be the same as
+  #  raise-up NameError, "unititialized constant RunThymeError")
+  #
+  # @raise [TypeError]
+  #
+  # source://pry//lib/pry/pry_instance.rb#554
+  def raise_up_common(force, *args); end
+
+  # Potentially deprecated. Use `Pry::REPL.new(pry, :target => target).start`
+  # (If nested sessions are going to exist, this method is fine, but a goal is
+  # to come up with an alternative to nested sessions altogether.)
+  #
+  # source://pry//lib/pry/pry_instance.rb#282
+  def repl(target = T.unsafe(nil)); end
+
+  # Reset the current eval string. If the user has entered part of a multiline
+  # expression, this discards that input.
+  #
+  # source://pry//lib/pry/pry_instance.rb#231
+  def reset_eval_string; end
+
+  # Run the specified command.
+  #
+  # @example
+  #   pry_instance.run_command("ls -m")
+  # @param val [String] The command (and its params) to execute.
+  # @return [Pry::Command::VOID_VALUE]
+  #
+  # source://pry//lib/pry/pry_instance.rb#375
+  def run_command(val); end
+
+  # Returns the appropriate prompt to use.
+  #
+  # @return [String] The prompt.
+  #
+  # source://pry//lib/pry/pry_instance.rb#453
+  def select_prompt; end
+
+  # Set the last result of an eval.
+  # This method should not need to be invoked directly.
+  #
+  # @param result [Object] The result.
+  # @param code [String] The code that was run.
+  #
+  # source://pry//lib/pry/pry_instance.rb#409
+  def set_last_result(result, code = T.unsafe(nil)); end
+
+  # Whether the print proc should be invoked.
+  # Currently only invoked if the output is not suppressed.
+  #
+  # @return [Boolean] Whether the print proc should be invoked.
+  #
+  # source://pry//lib/pry/pry_instance.rb#447
+  def should_print?; end
+
+  # Output the result or pass to an exception handler (if result is an exception).
+  #
+  # source://pry//lib/pry/pry_instance.rb#298
+  def show_result(result); end
+
+  # source://pry//lib/pry/pry_instance.rb#216
+  def sticky_locals; end
+
+  # Returns the value of attribute suppress_output.
+  #
+  # source://pry//lib/pry/pry_instance.rb#36
+  def suppress_output; end
+
+  # Sets the attribute suppress_output
+  #
+  # @param value the value to set the attribute suppress_output to.
+  #
+  # source://pry//lib/pry/pry_instance.rb#36
+  def suppress_output=(_arg0); end
+
+  # Update Pry's internal state after evalling code.
+  # This method should not need to be invoked directly.
+  #
+  # @param code [String] The code we just eval'd
+  #
+  # source://pry//lib/pry/pry_instance.rb#428
+  def update_input_history(code); end
+
+  private
+
+  # Force `eval_string` into the encoding of `val`. [Issue #284]
+  #
+  # source://pry//lib/pry/pry_instance.rb#680
+  def ensure_correct_encoding!(val); end
+
+  # source://pry//lib/pry/pry_instance.rb#688
+  def generate_prompt(prompt_proc, conf); end
+
+  # source://pry//lib/pry/pry_instance.rb#598
+  def handle_line(line, options); end
+
+  # the array that the prompt stack is stored in
+  #
+  # source://pry//lib/pry/pry_instance.rb#697
+  def prompt_stack; end
+
+  class << self
+    # Convert the given object into an instance of `Pry::Code`, if it isn't
+    # already one.
+    #
+    # @param obj [Code, Method, UnboundMethod, Proc, Pry::Method, String, Array, IO]
+    #
+    # source://pry//lib/pry/code.rb#12
+    def Code(obj); end
+
+    # If the given object is a `Pry::Method`, return it unaltered. If it's
+    # anything else, return it wrapped in a `Pry::Method` instance.
+    #
+    # source://pry//lib/pry/method.rb#9
+    def Method(obj); end
+
+    # If the given object is a `Pry::WrappedModule`, return it unaltered. If it's
+    # anything else, return it wrapped in a `Pry::WrappedModule` instance.
+    #
+    # source://pry//lib/pry/wrapped_module.rb#7
+    def WrappedModule(obj); end
+
+    # source://pry//lib/pry/pry_class.rb#294
+    def auto_resize!; end
+
+    # Return a `Binding` object for `target` or return `target` if it is
+    # already a `Binding`.
+    # In the case where `target` is top-level then return `TOPLEVEL_BINDING`
+    #
+    # @param target [Object] The object to get a `Binding` object for.
+    # @return [Binding] The `Binding` object.
+    #
+    # source://pry//lib/pry/pry_class.rb#347
+    def binding_for(target); end
+
+    # Returns the value of attribute cli.
+    #
+    # source://pry//lib/pry/pry_class.rb#22
+    def cli; end
+
+    # Sets the attribute cli
+    #
+    # @param value the value to set the attribute cli to.
+    #
+    # source://pry//lib/pry/pry_class.rb#22
+    def cli=(_arg0); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def color(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def color=(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def commands(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def commands=(*args, **_arg1, &block); end
+
+    # Returns the value of attribute config.
+    #
+    # source://pry//lib/pry/pry_class.rb#25
+    def config; end
+
+    # Sets the attribute config
+    #
+    # @param value the value to set the attribute config to.
+    #
+    # source://pry//lib/pry/pry_class.rb#25
+    def config=(_arg0); end
+
+    # @example
+    #   Pry.configure do |config|
+    #   config.eager_load! # optional
+    #   config.input =     # ..
+    #   config.foo = 2
+    #   end
+    # @yield [config] Yields a block with {Pry.config} as its argument.
+    #
+    # source://pry//lib/pry/pry_class.rb#46
+    def configure; end
+
+    # source://pry//lib/pry/pry_class.rb#380
+    def critical_section; end
+
+    # @return [Pry::Config] Returns a value store for an instance of Pry running on the current thread.
+    #
+    # source://pry//lib/pry/pry_class.rb#63
+    def current; end
+
+    # Returns the value of attribute current_line.
+    #
+    # source://pry//lib/pry/pry_class.rb#19
+    def current_line; end
+
+    # Sets the attribute current_line
+    #
+    # @param value the value to set the attribute current_line to.
+    #
+    # source://pry//lib/pry/pry_class.rb#19
+    def current_line=(_arg0); end
+
+    # Returns the value of attribute custom_completions.
+    #
+    # source://pry//lib/pry/pry_class.rb#18
+    def custom_completions; end
+
+    # Sets the attribute custom_completions
+    #
+    # @param value the value to set the attribute custom_completions to.
+    #
+    # source://pry//lib/pry/pry_class.rb#18
+    def custom_completions=(_arg0); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def editor(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def editor=(*args, **_arg1, &block); end
+
+    # Returns the value of attribute eval_path.
+    #
+    # source://pry//lib/pry/pry_class.rb#21
+    def eval_path; end
+
+    # Sets the attribute eval_path
+    #
+    # @param value the value to set the attribute eval_path to.
+    #
+    # source://pry//lib/pry/pry_class.rb#21
+    def eval_path=(_arg0); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def exception_handler(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def exception_handler=(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def extra_sticky_locals(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def extra_sticky_locals=(*args, **_arg1, &block); end
+
+    # source://pry//lib/pry/pry_class.rb#139
+    def final_session_setup; end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def history(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def history=(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def hooks(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def hooks=(*args, **_arg1, &block); end
+
+    # @return [Boolean]
+    #
+    # source://pry//lib/pry/pry_class.rb#375
+    def in_critical_section?; end
+
+    # Basic initialization.
+    #
+    # source://pry//lib/pry/pry_class.rb#338
+    def init; end
+
+    # @return [Boolean] Whether this is the first time a Pry session has
+    #   been started since loading the Pry class.
+    #
+    # source://pry//lib/pry/pry_class.rb#257
+    def initial_session?; end
+
+    # Do basic setup for initial session including: loading pryrc, plugins,
+    # requires, and history.
+    #
+    # source://pry//lib/pry/pry_class.rb#129
+    def initial_session_setup; end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def input(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def input=(*args, **_arg1, &block); end
+
+    # Returns the value of attribute last_internal_error.
+    #
+    # source://pry//lib/pry/pry_class.rb#24
+    def last_internal_error; end
+
+    # Sets the attribute last_internal_error
+    #
+    # @param value the value to set the attribute last_internal_error to.
+    #
+    # source://pry//lib/pry/pry_class.rb#24
+    def last_internal_error=(_arg0); end
+
+    # Returns the value of attribute line_buffer.
+    #
+    # source://pry//lib/pry/pry_class.rb#20
+    def line_buffer; end
+
+    # Sets the attribute line_buffer
+    #
+    # @param value the value to set the attribute line_buffer to.
+    #
+    # source://pry//lib/pry/pry_class.rb#20
+    def line_buffer=(_arg0); end
+
+    # Load the given file in the context of `Pry.toplevel_binding`
+    #
+    # @param file [String] The unexpanded file path.
+    #
+    # source://pry//lib/pry/pry_class.rb#69
+    def load_file_at_toplevel(file); end
+
+    # Execute the file through the REPL loop, non-interactively.
+    #
+    # @param file_name [String] File name to load through the REPL.
+    #
+    # source://pry//lib/pry/pry_class.rb#202
+    def load_file_through_repl(file_name); end
+
+    # Load Readline history if required.
+    #
+    # source://pry//lib/pry/pry_class.rb#251
+    def load_history; end
+
+    # Load RC files if appropriate This method can also be used to reload the
+    # files if they have changed.
+    #
+    # source://pry//lib/pry/pry_class.rb#77
+    def load_rc_files; end
+
+    # Load any Ruby files specified with the -r flag on the command line.
+    #
+    # source://pry//lib/pry/pry_class.rb#101
+    def load_requires; end
+
+    # Trap interrupts on jruby, and make them behave like MRI so we can
+    # catch them.
+    #
+    # source://pry//lib/pry/pry_class.rb#109
+    def load_traps; end
+
+    # source://pry//lib/pry/pry_class.rb#113
+    def load_win32console; end
+
+    # @return [main] returns the special instance of Object, "main".
+    #
+    # source://pry//lib/pry/pry_class.rb#55
+    def main; end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def memory_size(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def memory_size=(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def output(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def output=(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def pager(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def pager=(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def print(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def print=(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def prompt(*args, **_arg1, &block); end
+
+    # source://forwardable/1.3.2/forwardable.rb#229
+    def prompt=(*args, **_arg1, &block); end
+
+    # Returns the value of attribute quiet.
+    #
+    # source://pry//lib/pry/pry_class.rb#23
+    def quiet; end
+
+    # Sets the attribute quiet
+    #
+    # @param value the value to set the attribute quiet to.
+    #
+    # source://pry//lib/pry/pry_class.rb#23
+    def quiet=(_arg0); end
+
+    # Load the local RC file (./.pryrc)
+    #
+    # source://pry//lib/pry/pry_class.rb#86
+    def rc_files_to_load; end
+
+    # Expand a file to its canonical name (following symlinks as appropriate)
+    #
+    # source://pry//lib/pry/pry_class.rb#94
+    def real_path_to(file); end
+
+    # Set all the configurable options back to their default values
+    #
+    # source://pry//lib/pry/pry_class.rb#326
+    def reset_defaults; end
+
+    # Run a Pry command from outside a session. The commands available are
+    # those referenced by `Pry.config.commands` (the default command set).
+    #
+    # @example Run under Pry class, returning only public methods.
+    #   Pry.run_command "ls -m", :target => Pry
+    # @example Run at top-level with no output.
+    #   Pry.run_command "ls"
+    # @example Display command output.
+    #   Pry.run_command "ls -av", :show_output => true
+    # @option options
+    # @option options
+    # @param command_string [String] The Pry command (including arguments,
+    #   if any).
+    # @param options [Hash] Optional named parameters.
+    # @return [nil]
+    #
+    # source://pry//lib/pry/pry_class.rb#277
+    def run_command(command_string, options = T.unsafe(nil)); end
+
+    # Start a Pry REPL.
+    # This method also loads `pryrc` as necessary the first time it is invoked.
+    #
+    # @example
+    #   Pry.start(Object.new, :input => MyInput.new)
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @option options
+    # @param target [Object, Binding] The receiver of the Pry session
+    # @param options [Hash]
+    #
+    # source://pry//lib/pry/pry_class.rb#156
+    def start(target = T.unsafe(nil), options = T.unsafe(nil)); end
+
+    # source://pry//lib/pry/pry_class.rb#354
+    def toplevel_binding; end
+
+    # Sets the attribute toplevel_binding
+    #
+    # @param value the value to set the attribute toplevel_binding to.
+    #
+    # source://pry//lib/pry/pry_class.rb#372
+    def toplevel_binding=(_arg0); end
+
+    # An inspector that clips the output to `max_length` chars.
+    # In case of > `max_length` chars the `#<Object...> notation is used.
+    #
+    # @option options
+    # @option options
+    # @param obj [Object] The object to view.
+    # @param options [Hash]
+    # @return [String] The string representation of `obj`.
+    #
+    # source://pry//lib/pry/pry_class.rb#225
+    def view_clip(obj, options = T.unsafe(nil)); end
+
+    private
+
+    # @return [Boolean]
+    #
+    # source://pry//lib/pry/pry_class.rb#388
+    def mutex_available?; end
+  end
+end
+
+# @return [Array] Code of the method used when implementing Pry's
+#   __binding__, along with line indication to be used with instance_eval (and
+#   friends).
+# @see Object#__binding__
+#
+# source://pry//lib/pry/core_extensions.rb#9
+Pry::BINDING_METHOD_IMPL = T.let(T.unsafe(nil), Array)
+
+# source://pry//lib/pry/basic_object.rb#4
+class Pry::BasicObject < ::BasicObject
+  include ::Kernel
+end
+
+# source://pry//lib/pry/basic_object.rb#6
+Pry::BasicObject::Dir = Dir
+
+# source://pry//lib/pry/basic_object.rb#6
+Pry::BasicObject::ENV = T.let(T.unsafe(nil), Object)
+
+# source://pry//lib/pry/basic_object.rb#6
+Pry::BasicObject::File = File
+
+# source://pry//lib/pry/basic_object.rb#6
+Pry::BasicObject::Kernel = Kernel
+
+# source://pry//lib/pry/basic_object.rb#6
+Pry::BasicObject::LoadError = LoadError
+
+# source://pry//lib/pry/basic_object.rb#6
+Pry::BasicObject::Pry = Pry
+
+# A super-class for Commands that are created with a single block.
+#
+# This class ensures that the block is called with the correct number of
+# arguments and the right context.
+#
+# Create subclasses using {Pry::CommandSet#command}.
+#
+# source://pry//lib/pry/block_command.rb#13
+class Pry::BlockCommand < ::Pry::Command
+  # Call the block that was registered with this command.
+  #
+  # @param args [Array<String>] The arguments passed
+  # @return [Object] The return value of the block
+  #
+  # source://pry//lib/pry/block_command.rb#14
+  def call(*args); end
+
+  # source://pry//lib/pry/block_command.rb#18
+  def help; end
+end
+
+# Manage the processing of command line options
+#
+# source://pry//lib/pry/cli.rb#7
+class Pry::CLI
+  class << self
+    # Add a block responsible for processing parsed options.
+    #
+    # source://pry//lib/pry/cli.rb#39
+    def add_option_processor(&block); end
+
+    # Add another set of CLI options (a Pry::Slop block)
+    #
+    # source://pry//lib/pry/cli.rb#24
+    def add_options(&block); end
+
+    # @return [Array<String>] The input array of strings to process
+    #   as CLI options.
+    #
+    # source://pry//lib/pry/cli.rb#21
+    def input_args; end
+
+    # @return [Array<String>] The input array of strings to process
+    #   as CLI options.
+    #
+    # source://pry//lib/pry/cli.rb#21
+    def input_args=(_arg0); end
+
+    # @return [Array] The Procs that process the parsed options. Plugins can
+    #   utilize this facility in order to add and process their own Pry
+    #   options.
+    #
+    # source://pry//lib/pry/cli.rb#17
+    def option_processors; end
+
+    # @return [Array] The Procs that process the parsed options. Plugins can
+    #   utilize this facility in order to add and process their own Pry
+    #   options.
+    #
+    # source://pry//lib/pry/cli.rb#17
+    def option_processors=(_arg0); end
+
+    # @return [Proc] The Proc defining the valid command line options.
+    #
+    # source://pry//lib/pry/cli.rb#12
+    def options; end
+
+    # @return [Proc] The Proc defining the valid command line options.
+    #
+    # source://pry//lib/pry/cli.rb#12
+    def options=(_arg0); end
+
+    # source://pry//lib/pry/cli.rb#52
+    def parse_options(args = T.unsafe(nil)); end
+
+    # Clear `options` and `option_processors`
+    #
+    # source://pry//lib/pry/cli.rb#47
+    def reset; end
+
+    # source://pry//lib/pry/cli.rb#90
+    def start(opts); end
+  end
+end
+
+# source://pry//lib/pry/cli.rb#8
+class Pry::CLI::NoOptionsError < ::StandardError; end
+
+# A super-class of Commands with structure.
+#
+# This class implements the bare-minimum functionality that a command should
+# have, namely a --help switch, and then delegates actual processing to its
+# subclasses.
+#
+# Create subclasses using {Pry::CommandSet#create_command}, and override the
+# `options(opt)` method to set up an instance of Pry::Slop, and the `process`
+# method to actually run the command. If necessary, you can also override
+# `setup` which will be called before `options`, for example to require any
+# gems your command needs to run, or to set up state.
+#
+# source://pry//lib/pry/class_command.rb#15
+class Pry::ClassCommand < ::Pry::Command
+  # Returns the value of attribute args.
+  #
+  # source://pry//lib/pry/class_command.rb#64
+  def args; end
+
+  # Sets the attribute args
+  #
+  # @param value the value to set the attribute args to.
+  #
+  # source://pry//lib/pry/class_command.rb#64
+  def args=(_arg0); end
+
+  # Set up `opts` and `args`, and then call `process`.
+  #
+  # This method will display help if necessary.
+  #
+  # @param args [Array<String>] The arguments passed
+  # @return [Object] The return value of `process` or VOID_VALUE
+  #
+  # source://pry//lib/pry/class_command.rb#72
+  def call(*args); end
+
+  # Generate shell completions
+  #
+  # @param search [String] The line typed so far
+  # @return [Array<String>] the words to complete
+  #
+  # source://pry//lib/pry/class_command.rb#105
+  def complete(search); end
+
+  # Return the help generated by Pry::Slop for this command.
+  #
+  # source://pry//lib/pry/class_command.rb#87
+  def help; end
+
+  # A method to setup Pry::Slop so it can parse the options your command expects.
+  #
+  # method, as it may be called by Pry at any time for introspection reasons.
+  # If you need to set up default values, use `setup` instead.
+  #
+  # @example
+  #   def options(opt)
+  #   opt.banner "Gists methods or classes"
+  #   opt.on(:c, :class, "gist a class") do
+  #   @action = :class
+  #   end
+  #   end
+  # @note Please don't do anything side-effecty in the main part of this
+  #
+  # source://pry//lib/pry/class_command.rb#171
+  def options(opt); end
+
+  # Returns the value of attribute opts.
+  #
+  # source://pry//lib/pry/class_command.rb#63
+  def opts; end
+
+  # Sets the attribute opts
+  #
+  # @param value the value to set the attribute opts to.
+  #
+  # source://pry//lib/pry/class_command.rb#63
+  def opts=(_arg0); end
+
+  # The actual body of your command should go here.
+  #
+  # The `opts` mehod can be called to get the options that Pry::Slop has passed,
+  # and `args` gives the remaining, unparsed arguments.
+  #
+  # The return value of this method is discarded unless the command was
+  # created with `:keep_retval => true`, in which case it is returned to the
+  # repl.
+  #
+  # @example
+  #   def process
+  #   if opts.present?(:class)
+  #   gist_class
+  #   else
+  #   gist_method
+  #   end
+  #   end
+  # @raise [CommandError]
+  #
+  # source://pry//lib/pry/class_command.rb#190
+  def process; end
+
+  # A method called just before `options(opt)` as part of `call`.
+  #
+  # This method can be used to set up any context your command needs to run,
+  # for example requiring gems, or setting default values for options.
+  #
+  # @example
+  #   def setup
+  #   require 'gist'
+  #   @action = :method
+  #   end
+  #
+  # source://pry//lib/pry/class_command.rb#121
+  def setup; end
+
+  # Return an instance of Pry::Slop that can parse either subcommands or the
+  # options that this command accepts.
+  #
+  # source://pry//lib/pry/class_command.rb#93
+  def slop; end
+
+  # A method to setup Pry::Slop commands so it can parse the subcommands your
+  # command expects. If you need to set up default values, use `setup`
+  # instead.
+  #
+  # @example A minimal example
+  #   def subcommands(cmd)
+  #   cmd.command :download do |opt|
+  #   description 'Downloads a content from a server'
+  #
+  #   opt.on :verbose, 'Use verbose output'
+  #
+  #   run do |options, arguments|
+  #   ContentDownloader.download(options, arguments)
+  #   end
+  #   end
+  #   end
+  # @example Define the invokation block anywhere you want
+  #   def subcommands(cmd)
+  #   cmd.command :download do |opt|
+  #   description 'Downloads a content from a server'
+  #
+  #   opt.on :verbose, 'Use verbose output'
+  #   end
+  #   end
+  #
+  #   def process
+  #   # Perform calculations...
+  #   opts.fetch_command(:download).run do |options, arguments|
+  #   ContentDownloader.download(options, arguments)
+  #   end
+  #   # More calculations...
+  #   end
+  #
+  # source://pry//lib/pry/class_command.rb#156
+  def subcommands(cmd); end
+
+  class << self
+    # source://pry//lib/pry/class_command.rb#29
+    def doc; end
+
+    # source://pry//lib/pry/class_command.rb#37
+    def file; end
+
+    # Ensure that subclasses inherit the options, description and
+    # match from a ClassCommand super class.
+    #
+    # source://pry//lib/pry/class_command.rb#19
+    def inherited(klass); end
+
+    # source://pry//lib/pry/class_command.rb#42
+    def line; end
+
+    # source://pry//lib/pry/class_command.rb#25
+    def source; end
+
+    # source://pry//lib/pry/class_command.rb#37
+    def source_file; end
+
+    # source://pry//lib/pry/class_command.rb#42
+    def source_line; end
+
+    # source://pry//lib/pry/class_command.rb#33
+    def source_location; end
+
+    private
+
+    # The object used to extract the source for the command.
+    #
+    # This should be a `Pry::Method(block)` for a command made with `create_command`
+    # and a `Pry::WrappedModule(self)` for a command that's a standard class.
+    #
+    # @return [Pry::WrappedModule, Pry::Method]
+    #
+    # source://pry//lib/pry/class_command.rb#54
+    def source_object; end
+  end
+end
+
+# `Pry::Code` is a class that encapsulates lines of source code and their
+# line numbers and formats them for terminal output. It can read from a file
+# or method definition or be instantiated with a `String` or an `Array`.
+#
+# In general, the formatting methods in `Code` return a new `Code` object
+# which will format the text as specified when `#to_s` is called. This allows
+# arbitrary chaining of formatting methods without mutating the original
+# object.
+#
+# source://pry//lib/pry/code.rb#32
+class Pry::Code
+  extend ::MethodSource::CodeHelpers
+
+  # Instantiate a `Code` object containing code from the given `Array`,
+  # `String`, or `IO`. The first line will be line 1 unless specified
+  # otherwise. If you need non-contiguous line numbers, you can create an
+  # empty `Code` object and then use `#push` to insert the lines.
+  #
+  # @param lines [Array<String>, String, IO]
+  # @param start_line [Integer?]
+  # @param code_type [Symbol?]
+  # @return [Code] a new instance of Code
+  #
+  # source://pry//lib/pry/code.rb#87
+  def initialize(lines = T.unsafe(nil), start_line = T.unsafe(nil), code_type = T.unsafe(nil)); end
+
+  # Append the given line. +lineno+ is one more than the last existing
+  # line, unless specified otherwise.
+  #
+  # @param line [String]
+  # @return [void]
+  #
+  # source://pry//lib/pry/code.rb#102
+  def <<(line); end
+
+  # Two `Code` objects are equal if they contain the same lines with the same
+  # numbers. Otherwise, call `to_s` and `chomp` and compare as Strings.
+  #
+  # @param other [Code, Object]
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/code.rb#325
+  def ==(other); end
+
+  # Remove all lines except for the +lines+ after and excluding +lineno+.
+  #
+  # @param lineno [Integer]
+  # @param lines [Integer]
+  # @return [Code]
+  #
+  # source://pry//lib/pry/code.rb#195
+  def after(lineno, lines = T.unsafe(nil)); end
+
+  # Remove all lines except for the +lines+ on either side of and including
+  # +lineno+.
+  #
+  # @param lineno [Integer]
+  # @param lines [Integer]
+  # @return [Code]
+  #
+  # source://pry//lib/pry/code.rb#182
+  def around(lineno, lines = T.unsafe(nil)); end
+
+  # Remove all lines except for the +lines+ up to and excluding +lineno+.
+  #
+  # @param lineno [Integer]
+  # @param lines [Integer]
+  # @return [Code]
+  #
+  # source://pry//lib/pry/code.rb#168
+  def before(lineno, lines = T.unsafe(nil)); end
+
+  # Remove all lines that aren't in the given range, expressed either as a
+  # `Range` object or a first and last line number (inclusive). Negative
+  # indices count from the end of the array of lines.
+  #
+  # @param start_line [Range, Integer]
+  # @param end_line [Integer?]
+  # @return [Code]
+  #
+  # source://pry//lib/pry/code.rb#135
+  def between(start_line, end_line = T.unsafe(nil)); end
+
+  # @return [Symbol] The type of code stored in this wrapper.
+  #
+  # source://pry//lib/pry/code.rb#77
+  def code_type; end
+
+  # @return [Symbol] The type of code stored in this wrapper.
+  #
+  # source://pry//lib/pry/code.rb#77
+  def code_type=(_arg0); end
+
+  # Get the comment that describes the expression on the given line number.
+  #
+  # @param line_number [Integer] (1-based)
+  # @return [String] the code.
+  #
+  # source://pry//lib/pry/code.rb#286
+  def comment_describing(line_number); end
+
+  # Get the multiline expression that starts on the given line number.
+  #
+  # @param line_number [Integer] (1-based)
+  # @return [String] the code.
+  #
+  # source://pry//lib/pry/code.rb#294
+  def expression_at(line_number, consume = T.unsafe(nil)); end
+
+  # Remove all lines that don't match the given `pattern`.
+  #
+  # @param pattern [Regexp]
+  # @return [Code]
+  #
+  # source://pry//lib/pry/code.rb#207
+  def grep(pattern); end
+
+  # @return [String] a (possibly highlighted) copy of the source code.
+  #
+  # source://pry//lib/pry/code.rb#263
+  def highlighted; end
+
+  # Return the number of lines stored.
+  #
+  # @return [Integer]
+  #
+  # source://pry//lib/pry/code.rb#316
+  def length; end
+
+  # @return [Integer] the number of digits in the last line.
+  #
+  # source://pry//lib/pry/code.rb#252
+  def max_lineno_width; end
+
+  # Forward any missing methods to the output of `#to_s`.
+  #
+  # source://pry//lib/pry/code.rb#335
+  def method_missing(method_name, *args, &block); end
+
+  # Get the (approximate) Module.nesting at the give line number.
+  #
+  # @param line_number [Integer] line number starting from 1
+  # @return [Array<Module>] a list of open modules.
+  #
+  # source://pry//lib/pry/code.rb#302
+  def nesting_at(line_number); end
+
+  # Writes a formatted representation (based on the configuration of the
+  # object) to the given output, which must respond to `#<<`.
+  #
+  # source://pry//lib/pry/code.rb#269
+  def print_to_output(output, color = T.unsafe(nil)); end
+
+  # Append the given line. +lineno+ is one more than the last existing
+  # line, unless specified otherwise.
+  #
+  # @param line [String]
+  # @return [void]
+  #
+  # source://pry//lib/pry/code.rb#102
+  def push(line); end
+
+  # Return an unformatted String of the code.
+  #
+  # @return [String]
+  #
+  # source://pry//lib/pry/code.rb#309
+  def raw; end
+
+  # Filter the lines using the given block.
+  #
+  # @return [Code]
+  # @yield [LOC]
+  #
+  # source://pry//lib/pry/code.rb#122
+  def reject(&block); end
+
+  # Filter the lines using the given block.
+  #
+  # @return [Code]
+  # @yield [LOC]
+  #
+  # source://pry//lib/pry/code.rb#112
+  def select(&block); end
+
+  # Take `num_lines` from `start_line`, forward or backwards.
+  #
+  # @param start_line [Integer]
+  # @param num_lines [Integer]
+  # @return [Code]
+  #
+  # source://pry//lib/pry/code.rb#150
+  def take_lines(start_line, num_lines); end
+
+  # @return [String] a formatted representation (based on the configuration of
+  #   the object).
+  #
+  # source://pry//lib/pry/code.rb#258
+  def to_s; end
+
+  # Format output with the specified number of spaces in front of every line,
+  # unless `spaces` is falsy.
+  #
+  # @param spaces [Integer?]
+  # @return [Code]
+  #
+  # source://pry//lib/pry/code.rb#244
+  def with_indentation(spaces = T.unsafe(nil)); end
+
+  # Format output with line numbers next to it, unless `y_n` is falsy.
+  #
+  # @param y_n [Boolean?]
+  # @return [Code]
+  #
+  # source://pry//lib/pry/code.rb#221
+  def with_line_numbers(y_n = T.unsafe(nil)); end
+
+  # Format output with a marker next to the given +lineno+, unless +lineno+ is
+  # falsy.
+  #
+  # @param lineno [Integer?]
+  # @return [Code]
+  #
+  # source://pry//lib/pry/code.rb#232
+  def with_marker(lineno = T.unsafe(nil)); end
+
+  protected
+
+  # An abstraction of the `dup.instance_eval` pattern used throughout this
+  # class.
+  #
+  # source://pry//lib/pry/code.rb#353
+  def alter(&block); end
+
+  private
+
+  # Check whether String responds to missing methods.
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/code.rb#345
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+
+  class << self
+    # Instantiate a `Code` object containing code loaded from a file or
+    # Pry's line buffer.
+    #
+    # @param filename [String] The name of a file, or "(pry)".
+    # @param code_type [Symbol] The type of code the file contains.
+    # @return [Code]
+    #
+    # source://pry//lib/pry/code.rb#42
+    def from_file(filename, code_type = T.unsafe(nil)); end
+
+    # Instantiate a `Code` object containing code extracted from a
+    # `::Method`, `UnboundMethod`, `Proc`, or `Pry::Method` object.
+    #
+    # @param meth [::Method, UnboundMethod, Proc, Pry::Method] The method
+    #   object.
+    # @param start_line [Integer, nil] The line number to start on, or nil to
+    #   use the method's original line numbers.
+    # @return [Code]
+    #
+    # source://pry//lib/pry/code.rb#55
+    def from_method(meth, start_line = T.unsafe(nil)); end
+
+    # Attempt to extract the source code for module (or class) `mod`.
+    #
+    # @param mod [Module, Class] The module (or class) of interest.
+    # @param candidate_rank [Integer] The module candidate (by rank)
+    #   to use (see `Pry::WrappedModule::Candidate` for more information).
+    # @param start_line [Integer, nil] The line number to start on, or nil to
+    #   use the method's original line numbers.
+    # @return [Code]
+    #
+    # source://pry//lib/pry/code.rb#69
+    def from_module(mod, candidate_rank = T.unsafe(nil), start_line = T.unsafe(nil)); end
+  end
+end
+
+# Represents a range of lines in a code listing.
+#
+# @api private
+#
+# source://pry//lib/pry/code/code_range.rb#8
+class Pry::Code::CodeRange
+  # @api private
+  # @param start_line [Integer]
+  # @param end_line [Integer?]
+  # @return [CodeRange] a new instance of CodeRange
+  #
+  # source://pry//lib/pry/code/code_range.rb#11
+  def initialize(start_line, end_line = T.unsafe(nil)); end
+
+  # @api private
+  # @param lines [Array<LOC>]
+  # @return [Range]
+  #
+  # source://pry//lib/pry/code/code_range.rb#19
+  def indices_range(lines); end
+
+  private
+
+  # @api private
+  #
+  # source://pry//lib/pry/code/code_range.rb#27
+  def end_line; end
+
+  # @api private
+  # @return [Integer]
+  #
+  # source://pry//lib/pry/code/code_range.rb#57
+  def find_end_index(lines); end
+
+  # @api private
+  # @return [Integer]
+  #
+  # source://pry//lib/pry/code/code_range.rb#50
+  def find_start_index(lines); end
+
+  # If `end_line` is equal to `nil`, then calculate it from the first
+  # parameter, `start_line`. Otherwise, leave it as it is.
+  #
+  # @api private
+  # @return [void]
+  #
+  # source://pry//lib/pry/code/code_range.rb#32
+  def force_set_end_line; end
+
+  # Finds indices of `start_line` and `end_line` in the given Array of
+  # +lines+.
+  #
+  # @api private
+  # @param lines [Array<LOC>]
+  # @return [Array<Integer>]
+  #
+  # source://pry//lib/pry/code/code_range.rb#45
+  def indices(lines); end
+
+  # For example, if the range is 4..10, then `start_line` would be equal to
+  # 4 and `end_line` to 10.
+  #
+  # @api private
+  # @return [void]
+  #
+  # source://pry//lib/pry/code/code_range.rb#66
+  def set_end_line_from_range; end
+
+  # @api private
+  #
+  # source://pry//lib/pry/code/code_range.rb#25
+  def start_line; end
+end
+
+# Represents a line of code (which may, in fact, contain multiple lines if
+# the entirety was eval'd as a single unit following the `edit` command).
+#
+# A line of code is a tuple, which consists of a line and a line number. A
+# `LOC` object's state (namely, the line parameter) can be changed via
+# instance methods.  `Pry::Code` heavily uses this class.
+#
+# @api private
+# @example
+#   loc = LOC.new("def example\n  :example\nend", 1)
+#   puts loc.line
+#   def example
+#   :example
+#   end
+#   #=> nil
+#
+#   loc.indent(3)
+#   loc.line #=> "   def example\n  :example\nend"
+#
+# source://pry//lib/pry/code/loc.rb#23
+class Pry::Code::LOC
+  # @api private
+  # @param line [String] The line of code.
+  # @param lineno [Integer] The position of the +line+.
+  # @return [LOC] a new instance of LOC
+  #
+  # source://pry//lib/pry/code/loc.rb#29
+  def initialize(line, lineno); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/code/loc.rb#34
+  def ==(other); end
+
+  # Prepends the line number `lineno` to the `line`.
+  #
+  # @api private
+  # @param max_width [Integer]
+  # @return [void]
+  #
+  # source://pry//lib/pry/code/loc.rb#64
+  def add_line_number(max_width = T.unsafe(nil), color = T.unsafe(nil)); end
+
+  # Prepends a marker "=>" or an empty marker to the +line+.
+  #
+  # @api private
+  # @param marker_lineno [Integer] If it is equal to the `lineno`, then
+  #   prepend a hashrocket. Otherwise, an empty marker.
+  # @return [void]
+  #
+  # source://pry//lib/pry/code/loc.rb#81
+  def add_marker(marker_lineno); end
+
+  # Paints the `line` of code.
+  #
+  # @api private
+  # @param code_type [Symbol]
+  # @return [void]
+  #
+  # source://pry//lib/pry/code/loc.rb#56
+  def colorize(code_type); end
+
+  # @api private
+  #
+  # source://pry//lib/pry/code/loc.rb#38
+  def dup; end
+
+  # @api private
+  #
+  # source://pry//lib/pry/code/loc.rb#98
+  def handle_multiline_entries_from_edit_command(line, max_width); end
+
+  # Indents the `line` with +distance+ spaces.
+  #
+  # @api private
+  # @param distance [Integer]
+  # @return [void]
+  #
+  # source://pry//lib/pry/code/loc.rb#94
+  def indent(distance); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://pry//lib/pry/code/loc.rb#43
+  def line; end
+
+  # @api private
+  # @return [Integer]
+  #
+  # source://pry//lib/pry/code/loc.rb#48
+  def lineno; end
+
+  # @api private
+  # @return [Array<String, Integer>]
+  #
+  # source://pry//lib/pry/code/loc.rb#25
+  def tuple; end
+end
+
+# source://pry//lib/pry/code/code_file.rb#6
+class Pry::CodeFile
+  # @param filename [String] The name of a file with code to be detected
+  # @param code_type [Symbol] The type of code the `filename` contains
+  # @return [CodeFile] a new instance of CodeFile
+  #
+  # source://pry//lib/pry/code/code_file.rb#41
+  def initialize(filename, code_type = T.unsafe(nil)); end
+
+  # @return [String] The code contained in the current `@filename`.
+  #
+  # source://pry//lib/pry/code/code_file.rb#47
+  def code; end
+
+  # @return [Symbol] The type of code stored in this wrapper.
+  #
+  # source://pry//lib/pry/code/code_file.rb#37
+  def code_type; end
+
+  private
+
+  # @raise [MethodSource::SourceNotFoundError] if the `filename` is not
+  #   readable for some reason.
+  # @return [String] absolute path for the given `filename`.
+  #
+  # source://pry//lib/pry/code/code_file.rb#64
+  def abs_path; end
+
+  # @return [Array] All the paths that contain code that Pry can use for its
+  #   API's. Skips directories.
+  #
+  # source://pry//lib/pry/code/code_file.rb#80
+  def code_path; end
+
+  # @return [String]
+  #
+  # source://pry//lib/pry/code/code_file.rb#110
+  def from_load_path; end
+
+  # @return [String]
+  #
+  # source://pry//lib/pry/code/code_file.rb#105
+  def from_pry_init_pwd; end
+
+  # @return [String]
+  #
+  # source://pry//lib/pry/code/code_file.rb#100
+  def from_pwd; end
+
+  # @param path [String]
+  # @return [Boolean] if the path, with or without the default ext,
+  #   is a readable file then `true`, otherwise `false`.
+  #
+  # source://pry//lib/pry/code/code_file.rb#73
+  def readable?(path); end
+
+  # @param filename [String]
+  # @param default [Symbol] (:unknown) the file type to assume if none could be
+  #   detected.
+  # @return [Symbol, nil] The SyntaxHighlighter type of a file from its
+  #   extension, or `nil` if `:unknown`.
+  #
+  # source://pry//lib/pry/code/code_file.rb#89
+  def type_from_filename(filename, default = T.unsafe(nil)); end
+end
+
+# source://pry//lib/pry/code/code_file.rb#7
+Pry::CodeFile::DEFAULT_EXT = T.let(T.unsafe(nil), String)
+
+# List of all supported languages.
+#
+# @return [Hash]
+#
+# source://pry//lib/pry/code/code_file.rb#11
+Pry::CodeFile::EXTENSIONS = T.let(T.unsafe(nil), Hash)
+
+# source://pry//lib/pry/code/code_file.rb#28
+Pry::CodeFile::FILES = T.let(T.unsafe(nil), Hash)
+
+# Store the current working directory. This allows show-source etc. to work if
+# your process has changed directory since boot. [Issue #675]
+#
+# source://pry//lib/pry/code/code_file.rb#34
+Pry::CodeFile::INITIAL_PWD = T.let(T.unsafe(nil), String)
+
+# This class is responsible for taking a string (identifying a
+# command/class/method/etc) and returning the relevant type of object.
+# For example, if the user looks up "show-source" then  a
+# `Pry::Command` will be returned. Alternatively, if the user passes in "Pry#repl" then
+# a `Pry::Method` object will be returned.
+#
+# The `CodeObject.lookup` method is responsible for 1. figuring out what kind of
+# object the user wants (applying precedence rules in doing so -- i.e methods
+# get precedence over commands with the same name) and 2. Returning
+# the appropriate object. If the user fails to provide a string
+# identifer for the object (i.e they pass in `nil` or "") then the
+# object looked up will be the 'current method' or 'current class'
+# associated with the Binding.
+#
+# TODO: This class is a clusterfuck. We need a much more robust
+# concept of what a "Code Object" really is. Currently
+# commands/classes/candidates/methods and so on just share a very
+# ill-defined interface.
+#
+# source://pry//lib/pry/code_object.rb#22
+class Pry::CodeObject
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+
+  # @return [CodeObject] a new instance of CodeObject
+  #
+  # source://pry//lib/pry/code_object.rb#82
+  def initialize(str, pry_instance, options = T.unsafe(nil)); end
+
+  # TODO: just make it so find_command_by_match_or_listing doesn't raise?
+  #
+  # source://pry//lib/pry/code_object.rb#94
+  def command_lookup; end
+
+  # lookup variables and constants and `self` that are not modules
+  #
+  # source://pry//lib/pry/code_object.rb#118
+  def default_lookup; end
+
+  # when no paramter is given (i.e CodeObject.lookup(nil)), then we
+  # lookup the 'current object' from the binding.
+  #
+  # source://pry//lib/pry/code_object.rb#102
+  def empty_lookup; end
+
+  # source://pry//lib/pry/code_object.rb#136
+  def method_or_class_lookup; end
+
+  # Returns the value of attribute pry_instance.
+  #
+  # source://pry//lib/pry/code_object.rb#79
+  def pry_instance; end
+
+  # Sets the attribute pry_instance
+  #
+  # @param value the value to set the attribute pry_instance to.
+  #
+  # source://pry//lib/pry/code_object.rb#79
+  def pry_instance=(_arg0); end
+
+  # Returns the value of attribute str.
+  #
+  # source://pry//lib/pry/code_object.rb#77
+  def str; end
+
+  # Sets the attribute str
+  #
+  # @param value the value to set the attribute str to.
+  #
+  # source://pry//lib/pry/code_object.rb#77
+  def str=(_arg0); end
+
+  # Returns the value of attribute super_level.
+  #
+  # source://pry//lib/pry/code_object.rb#80
+  def super_level; end
+
+  # Sets the attribute super_level
+  #
+  # @param value the value to set the attribute super_level to.
+  #
+  # source://pry//lib/pry/code_object.rb#80
+  def super_level=(_arg0); end
+
+  # Returns the value of attribute target.
+  #
+  # source://pry//lib/pry/code_object.rb#78
+  def target; end
+
+  # Sets the attribute target
+  #
+  # @param value the value to set the attribute target to.
+  #
+  # source://pry//lib/pry/code_object.rb#78
+  def target=(_arg0); end
+
+  private
+
+  # Returns true if `str` looks like a method, i.e Klass#method
+  # We need to consider this case because method lookups should fall
+  # through to the `method_or_class_lookup()` method but a
+  # defined?() on a "Klass#method` string will see the `#` as a
+  # comment and only evaluate the `Klass` part.
+  #
+  # @param str [String]
+  # @return [Boolean] Whether the string looks like an instance method.
+  #
+  # source://pry//lib/pry/code_object.rb#163
+  def looks_like_an_instance_method?(str); end
+
+  # grab the nth (`super_level`) super of `obj
+  #
+  # @param obj [Object]
+  # @param super_level [Fixnum] How far up the super chain to ascend.
+  # @raise [Pry::CommandError]
+  #
+  # source://pry//lib/pry/code_object.rb#188
+  def lookup_super(obj, super_level); end
+
+  # We use this method to decide whether code is safe to eval. Method's are
+  # generally not, but everything else is.
+  # TODO: is just checking != "method" enough??
+  # TODO: see duplication of this method in Pry::WrappedModule
+  #
+  # @param str [String] The string to lookup
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/code_object.rb#173
+  def safe_to_evaluate?(str); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/code_object.rb#152
+  def sourcable_object?(obj); end
+
+  # source://pry//lib/pry/code_object.rb#181
+  def target_self; end
+
+  class << self
+    # source://pry//lib/pry/code_object.rb#69
+    def lookup(str, pry_instance, options = T.unsafe(nil)); end
+  end
+end
+
+# source://pry//lib/pry/code_object.rb#23
+module Pry::CodeObject::Helpers
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/code_object.rb#30
+  def c_method?; end
+
+  # @note If a module defined by C was extended with a lot of methods written
+  #   in Ruby, this method would fail.
+  # @return [Boolean] `true` if this module was defined by means of the C API,
+  #   `false` if it's a Ruby module.
+  #
+  # source://pry//lib/pry/code_object.rb#46
+  def c_module?; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/code_object.rb#38
+  def command?; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/code_object.rb#34
+  def module_with_yard_docs?; end
+
+  # we need this helper as some Pry::Method objects can wrap Procs
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/code_object.rb#26
+  def real_method_object?; end
+end
+
+# PP subclass for streaming inspect output in color.
+#
+# source://pry//lib/pry/color_printer.rb#8
+class Pry::ColorPrinter < ::PP
+  # source://pry//lib/pry/color_printer.rb#25
+  def pp(object); end
+
+  # source://pry//lib/pry/color_printer.rb#37
+  def text(str, max_width = T.unsafe(nil)); end
+
+  private
+
+  # source://pry//lib/pry/color_printer.rb#49
+  def highlight_object_literal(object_literal); end
+
+  # source://pry//lib/pry/color_printer.rb#55
+  def inspect_object(object); end
+
+  class << self
+    # source://pry//lib/pry/color_printer.rb#11
+    def default(_output, value, pry_instance); end
+
+    # source://pry//lib/pry/color_printer.rb#18
+    def pp(obj, output = T.unsafe(nil), max_width = T.unsafe(nil)); end
+  end
+end
+
+# N.B. using a regular expresion here so that "raise-up 'foo'" does the right thing.
+#
+# source://pry//lib/pry/command.rb#11
+class Pry::Command
+  include ::Pry::Helpers::BaseHelpers
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+  include ::Pry::Helpers::Text
+  extend ::Pry::Helpers::DocumentationHelpers
+  extend ::Pry::CodeObject::Helpers
+
+  # Instantiate a command, in preparation for calling it.
+  #
+  # @param context [Hash] The runtime context to use with this command.
+  # @return [Command] a new instance of Command
+  #
+  # source://pry//lib/pry/command.rb#230
+  def initialize(context = T.unsafe(nil)); end
+
+  # source://pry//lib/pry/command.rb#292
+  def _pry_; end
+
+  # Sets the attribute pry_instance
+  #
+  # @param value the value to set the attribute pry_instance to.
+  #
+  # source://pry//lib/pry/command.rb#217
+  def _pry_=(_arg0); end
+
+  # Returns the value of attribute arg_string.
+  #
+  # source://pry//lib/pry/command.rb#213
+  def arg_string; end
+
+  # Sets the attribute arg_string
+  #
+  # @param value the value to set the attribute arg_string to.
+  #
+  # source://pry//lib/pry/command.rb#213
+  def arg_string=(_arg0); end
+
+  # source://pry//lib/pry/command.rb#253
+  def block; end
+
+  # Returns the value of attribute captures.
+  #
+  # source://pry//lib/pry/command.rb#211
+  def captures; end
+
+  # Sets the attribute captures
+  #
+  # @param value the value to set the attribute captures to.
+  #
+  # source://pry//lib/pry/command.rb#211
+  def captures=(_arg0); end
+
+  # Display a warning if a command collides with a local/method in
+  # the current scope.
+  #
+  # source://pry//lib/pry/command.rb#329
+  def check_for_command_collision(command_match, arg_string); end
+
+  # The block we pass *into* a command so long as `:takes_block` is
+  # not equal to `false`
+  #
+  # @example
+  #   my-command | do
+  #   puts "block content"
+  #   end
+  #
+  # source://pry//lib/pry/command.rb#226
+  def command_block; end
+
+  # The block we pass *into* a command so long as `:takes_block` is
+  # not equal to `false`
+  #
+  # @example
+  #   my-command | do
+  #   puts "block content"
+  #   end
+  #
+  # source://pry//lib/pry/command.rb#226
+  def command_block=(_arg0); end
+
+  # source://pry//lib/pry/command.rb#261
+  def command_name; end
+
+  # source://pry//lib/pry/command.rb#257
+  def command_options; end
+
+  # Returns the value of attribute command_set.
+  #
+  # source://pry//lib/pry/command.rb#215
+  def command_set; end
+
+  # Sets the attribute command_set
+  #
+  # @param value the value to set the attribute command_set to.
+  #
+  # source://pry//lib/pry/command.rb#215
+  def command_set=(_arg0); end
+
+  # source://pry//lib/pry/command.rb#284
+  def commands; end
+
+  # Generate completions for this command
+  #
+  # @param _search [String] The line typed so far
+  # @return [Array<String>] Completion words
+  #
+  # source://pry//lib/pry/command.rb#411
+  def complete(_search); end
+
+  # Returns the value of attribute context.
+  #
+  # source://pry//lib/pry/command.rb#214
+  def context; end
+
+  # Sets the attribute context
+  #
+  # @param value the value to set the attribute context to.
+  #
+  # source://pry//lib/pry/command.rb#214
+  def context=(_arg0); end
+
+  # source://pry//lib/pry/command.rb#249
+  def description; end
+
+  # Returns the value of attribute eval_string.
+  #
+  # source://pry//lib/pry/command.rb#212
+  def eval_string; end
+
+  # Sets the attribute eval_string
+  #
+  # @param value the value to set the attribute eval_string to.
+  #
+  # source://pry//lib/pry/command.rb#212
+  def eval_string=(_arg0); end
+
+  # Returns the value of attribute hooks.
+  #
+  # source://pry//lib/pry/command.rb#216
+  def hooks; end
+
+  # Sets the attribute hooks
+  #
+  # @param value the value to set the attribute hooks to.
+  #
+  # source://pry//lib/pry/command.rb#216
+  def hooks=(_arg0); end
+
+  # Revaluate the string (str) and perform interpolation.
+  #
+  # @param str [String] The string to reevaluate with interpolation.
+  # @return [String] The reevaluated string with interpolations
+  #   applied (if any).
+  #
+  # source://pry//lib/pry/command.rb#318
+  def interpolate_string(str); end
+
+  # source://pry//lib/pry/command.rb#245
+  def match; end
+
+  # Make those properties accessible to instances
+  #
+  # source://pry//lib/pry/command.rb#241
+  def name; end
+
+  # Properties of one execution of a command (passed by {Pry#run_command} as a hash of
+  # context and expanded in `#initialize`
+  #
+  # source://pry//lib/pry/command.rb#209
+  def output; end
+
+  # Properties of one execution of a command (passed by {Pry#run_command} as a hash of
+  # context and expanded in `#initialize`
+  #
+  # source://pry//lib/pry/command.rb#209
+  def output=(_arg0); end
+
+  # Process a line that Command.matches? this command.
+  #
+  # @param line [String] The line to process
+  # @return [Object, Command::VOID_VALUE]
+  #
+  # source://pry//lib/pry/command.rb#394
+  def process_line(line); end
+
+  # Returns the value of attribute pry_instance.
+  #
+  # source://pry//lib/pry/command.rb#217
+  def pry_instance; end
+
+  # Sets the attribute pry_instance
+  #
+  # @param value the value to set the attribute pry_instance to.
+  #
+  # source://pry//lib/pry/command.rb#217
+  def pry_instance=(_arg0); end
+
+  # Run a command from another command.
+  #
+  # @example
+  #   run "show-input"
+  # @example
+  #   run ".ls"
+  # @example
+  #   run "amend-line",  "5", 'puts "hello world"'
+  # @param command_string [String] The string that invokes the command
+  # @param args [Array] Further arguments to pass to the command
+  #
+  # source://pry//lib/pry/command.rb#278
+  def run(command_string, *args); end
+
+  # source://pry//lib/pry/command.rb#265
+  def source; end
+
+  # @example
+  #   state.my_state = "my state"  # this will not conflict with any
+  #   # `state.my_state` used in another command.
+  # @return [Hash] Pry commands can store arbitrary state
+  #   here. This state persists between subsequent command invocations.
+  #   All state saved here is unique to the command, it does not
+  #   need to be namespaced.
+  #
+  # source://pry//lib/pry/command.rb#309
+  def state; end
+
+  # Returns the value of attribute target.
+  #
+  # source://pry//lib/pry/command.rb#210
+  def target; end
+
+  # Sets the attribute target
+  #
+  # @param value the value to set the attribute target to.
+  #
+  # source://pry//lib/pry/command.rb#210
+  def target=(_arg0); end
+
+  # @return [Object] The value of `self` inside the `target` binding.
+  #
+  # source://pry//lib/pry/command.rb#298
+  def target_self; end
+
+  # Extract necessary information from a line that Command.matches? this
+  # command.
+  #
+  # Returns an array of four elements:
+  #
+  # ```
+  #  [String] the portion of the line that matched with the Command match
+  #  [String] a string of all the arguments (i.e. everything but the match)
+  #  [Array]  the captures caught by the command_regex
+  #  [Array]  the arguments obtained by splitting the arg_string
+  # ```
+  #
+  # @param val [String] The line of input
+  # @return [Array]
+  #
+  # source://pry//lib/pry/command.rb#356
+  def tokenize(val); end
+
+  # source://pry//lib/pry/command.rb#288
+  def void; end
+
+  private
+
+  # source://pry//lib/pry/command.rb#485
+  def after_hooks; end
+
+  # source://pry//lib/pry/command.rb#481
+  def before_hooks; end
+
+  # Run the command with the given `args`.
+  #
+  # This is a public wrapper around `#call` which ensures all preconditions
+  # are met.
+  #
+  # @param args [Array<String>] The arguments to pass to this command.
+  # @return [Object] The return value of the `#call` method, or
+  #   {Command::VOID_VALUE}.
+  #
+  # source://pry//lib/pry/command.rb#425
+  def call_safely(*args); end
+
+  # Run the `#call` method and all the registered hooks.
+  #
+  # @param args [Array<String>] The arguments to `#call`
+  # @return [Object] The return value from `#call`
+  #
+  # source://pry//lib/pry/command.rb#492
+  def call_with_hooks(*args); end
+
+  # source://pry//lib/pry/command.rb#476
+  def find_hooks(event); end
+
+  # Normalize method arguments according to its arity.
+  #
+  # @param method [Integer]
+  # @param args [Array]
+  # @return [Array] a (possibly shorter) array of the arguments to pass
+  #
+  # source://pry//lib/pry/command.rb#509
+  def normalize_method_args(method, args); end
+
+  # Pass a block argument to a command.
+  #
+  # @param arg_string [String] The arguments (as a string) passed to the command.
+  #   We inspect these for a '| do' or a '| {' and if we find it we use it
+  #   to start a block input sequence. Once we have a complete
+  #   block, we save it to an accessor that can be retrieved from the command context.
+  #   Note that if we find the '| do' or '| {' we delete this and the
+  #   elements following it from `arg_string`.
+  #
+  # source://pry//lib/pry/command.rb#451
+  def pass_block(arg_string); end
+
+  # source://pry//lib/pry/command.rb#436
+  def use_unpatched_symbol; end
+
+  class << self
+    # Define or get the command's banner
+    #
+    # source://pry//lib/pry/command.rb#61
+    def banner(arg = T.unsafe(nil)); end
+
+    # source://pry//lib/pry/command.rb#66
+    def block; end
+
+    # Sets the attribute block
+    #
+    # @param value the value to set the attribute block to.
+    #
+    # source://pry//lib/pry/command.rb#30
+    def block=(_arg0); end
+
+    # source://pry//lib/pry/command.rb#109
+    def command_name; end
+
+    # Define or get the command's options
+    #
+    # source://pry//lib/pry/command.rb#51
+    def command_options(arg = T.unsafe(nil)); end
+
+    # Sets the attribute command_options
+    #
+    # @param value the value to set the attribute command_options to.
+    #
+    # source://pry//lib/pry/command.rb#32
+    def command_options=(_arg0); end
+
+    # source://pry//lib/pry/command.rb#165
+    def command_regex; end
+
+    # source://pry//lib/pry/command.rb#172
+    def convert_to_regex(obj); end
+
+    # source://pry//lib/pry/command.rb#89
+    def default_options(match); end
+
+    # Define or get the command's description
+    #
+    # source://pry//lib/pry/command.rb#45
+    def description(arg = T.unsafe(nil)); end
+
+    # Sets the attribute description
+    #
+    # @param value the value to set the attribute description to.
+    #
+    # source://pry//lib/pry/command.rb#31
+    def description=(_arg0); end
+
+    # source://pry//lib/pry/command.rb#75
+    def doc; end
+
+    # source://pry//lib/pry/command.rb#79
+    def file; end
+
+    # The group in which the command should be displayed in "help" output.
+    # This is usually auto-generated from directory naming, but it can be
+    # manually overridden if necessary.
+    # Group should not be changed once it is initialized.
+    #
+    # source://pry//lib/pry/command.rb#185
+    def group(name = T.unsafe(nil)); end
+
+    # source://pry//lib/pry/command.rb#105
+    def inspect; end
+
+    # source://pry//lib/pry/command.rb#84
+    def line; end
+
+    # source://pry//lib/pry/command.rb#35
+    def match(arg = T.unsafe(nil)); end
+
+    # Sets the attribute match
+    #
+    # @param value the value to set the attribute match to.
+    #
+    # source://pry//lib/pry/command.rb#33
+    def match=(_arg0); end
+
+    # How well does this command match the given line?
+    #
+    # Higher scores are better because they imply that this command matches
+    # the line more closely.
+    #
+    # The score is calculated by taking the number of characters at the start
+    # of the string that are used only to identify the command, not as part of
+    # the arguments.
+    #
+    # @example
+    #   /\.(.*)/.match_score(".foo") #=> 1
+    #   /\.*(.*)/.match_score("...foo") #=> 3
+    #   'hi'.match_score("hi there") #=> 2
+    # @param val [String] A line input at the REPL
+    # @return [Fixnum]
+    #
+    # source://pry//lib/pry/command.rb#153
+    def match_score(val); end
+
+    # Should this command be called for the given line?
+    #
+    # @param val [String] A line input at the REPL
+    # @return [Boolean]
+    #
+    # source://pry//lib/pry/command.rb#133
+    def matches?(val); end
+
+    # source://pry//lib/pry/command.rb#101
+    def name; end
+
+    # Define or get the command's options
+    # backward compatibility
+    #
+    # source://pry//lib/pry/command.rb#51
+    def options(arg = T.unsafe(nil)); end
+
+    # Sets the attribute command_options
+    #
+    # @param value the value to set the attribute command_options to.
+    #
+    # source://pry//lib/pry/command.rb#32
+    def options=(_arg0); end
+
+    # source://pry//lib/pry/command.rb#70
+    def source; end
+
+    # source://pry//lib/pry/command.rb#79
+    def source_file; end
+
+    # source://pry//lib/pry/command.rb#84
+    def source_line; end
+
+    # source://pry//lib/pry/command.rb#202
+    def state; end
+
+    # Create a new command with the given properties.
+    #
+    # @param match [String, Regex] The thing that triggers this command
+    # @param description [String] The description to appear in `help`
+    # @param options [Hash] Behavioral options (see {Pry::CommandSet#command})
+    # @param helpers [Module] A module of helper functions to be included.
+    # @return [Class] (a subclass of {Pry::Command})
+    # @yield optional, used for BlockCommands
+    #
+    # source://pry//lib/pry/command.rb#120
+    def subclass(match, description, options, helpers, &block); end
+  end
+end
+
+# source://pry//lib/pry/commands/amend_line.rb#5
+class Pry::Command::AmendLine < ::Pry::ClassCommand
+  # @raise [CommandError]
+  #
+  # source://pry//lib/pry/commands/amend_line.rb#22
+  def process; end
+
+  private
+
+  # @return [String] A new string with the amendments applied to it.
+  #
+  # source://pry//lib/pry/commands/amend_line.rb#33
+  def amend_input; end
+
+  # source://pry//lib/pry/commands/amend_line.rb#47
+  def delete_from_array(array, range); end
+
+  # source://pry//lib/pry/commands/amend_line.rb#51
+  def insert_into_array(array, range); end
+
+  # @return [Fixnum] The number of lines currently in `eval_string` (the
+  #   input buffer)
+  #
+  # source://pry//lib/pry/commands/amend_line.rb#62
+  def line_count; end
+
+  # The lines (or line) that will be modified by the `amend-line`.
+  #
+  # @return [Range, Fixnum] The lines or line.
+  #
+  # source://pry//lib/pry/commands/amend_line.rb#90
+  def line_range; end
+
+  # source://pry//lib/pry/commands/amend_line.rb#56
+  def replace_in_array(array, range); end
+
+  # Returns the (one-indexed) start and end lines given by the user.
+  # The lines in this range will be affected by the `amend-line`.
+  # Returns `nil` if no lines were specified by the user.
+  #
+  # @return [Array<Fixnum>, nil]
+  #
+  # source://pry//lib/pry/commands/amend_line.rb#70
+  def start_and_end_line_number; end
+
+  # Takes two numbers that are 1-indexed, and returns a range (or
+  # number) that is 0-indexed. 1-indexed means the first element is
+  # indentified by 1 rather than by 0 (as is the case for Ruby arrays).
+  #
+  # @param start_line_number [Fixnum] One-indexed number.
+  # @param end_line_number [Fixnum] One-indexed number.
+  # @return [Range] The zero-indexed range.
+  #
+  # source://pry//lib/pry/commands/amend_line.rb#83
+  def zero_indexed_range_from_one_indexed_numbers(start_line_number, end_line_number); end
+end
+
+# source://pry//lib/pry/commands/bang.rb#5
+class Pry::Command::Bang < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/bang.rb#16
+  def process; end
+end
+
+# source://pry//lib/pry/commands/bang_pry.rb#5
+class Pry::Command::BangPry < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/bang_pry.rb#14
+  def process; end
+end
+
+# source://pry//lib/pry/commands/cat.rb#5
+class Pry::Command::Cat < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/cat.rb#53
+  def complete(search); end
+
+  # source://pry//lib/pry/commands/cat.rb#57
+  def load_path_completions; end
+
+  # source://pry//lib/pry/commands/cat.rb#23
+  def options(opt); end
+
+  # source://pry//lib/pry/commands/cat.rb#38
+  def process; end
+end
+
+# source://pry//lib/pry/commands/cat/abstract_formatter.rb#6
+class Pry::Command::Cat::AbstractFormatter
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+  include ::Pry::Helpers::BaseHelpers
+
+  private
+
+  # source://pry//lib/pry/commands/cat/abstract_formatter.rb#26
+  def between_lines; end
+
+  # source://pry//lib/pry/commands/cat/abstract_formatter.rb#18
+  def code_type; end
+
+  # source://pry//lib/pry/commands/cat/abstract_formatter.rb#12
+  def decorate(content); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/cat/abstract_formatter.rb#22
+  def use_line_numbers?; end
+end
+
+# source://pry//lib/pry/commands/cat/exception_formatter.rb#6
+class Pry::Command::Cat::ExceptionFormatter < ::Pry::Command::Cat::AbstractFormatter
+  include ::Pry::Helpers::Text
+
+  # @return [ExceptionFormatter] a new instance of ExceptionFormatter
+  #
+  # source://pry//lib/pry/commands/cat/exception_formatter.rb#12
+  def initialize(exception, pry_instance, opts); end
+
+  # Returns the value of attribute ex.
+  #
+  # source://pry//lib/pry/commands/cat/exception_formatter.rb#7
+  def ex; end
+
+  # source://pry//lib/pry/commands/cat/exception_formatter.rb#18
+  def format; end
+
+  # Returns the value of attribute opts.
+  #
+  # source://pry//lib/pry/commands/cat/exception_formatter.rb#8
+  def opts; end
+
+  # Returns the value of attribute pry_instance.
+  #
+  # source://pry//lib/pry/commands/cat/exception_formatter.rb#9
+  def pry_instance; end
+
+  private
+
+  # source://pry//lib/pry/commands/cat/exception_formatter.rb#56
+  def backtrace_file; end
+
+  # source://pry//lib/pry/commands/cat/exception_formatter.rb#37
+  def backtrace_level; end
+
+  # source://pry//lib/pry/commands/cat/exception_formatter.rb#60
+  def backtrace_line; end
+
+  # @raise [CommandError]
+  #
+  # source://pry//lib/pry/commands/cat/exception_formatter.rb#64
+  def check_for_errors; end
+
+  # source://pry//lib/pry/commands/cat/exception_formatter.rb#33
+  def code_window_size; end
+
+  # source://pry//lib/pry/commands/cat/exception_formatter.rb#78
+  def header; end
+
+  # source://pry//lib/pry/commands/cat/exception_formatter.rb#52
+  def increment_backtrace_level; end
+
+  # source://pry//lib/pry/commands/cat/exception_formatter.rb#71
+  def start_and_end_line_for_code_window; end
+end
+
+# source://pry//lib/pry/commands/cat/file_formatter.rb#6
+class Pry::Command::Cat::FileFormatter < ::Pry::Command::Cat::AbstractFormatter
+  # @return [FileFormatter] a new instance of FileFormatter
+  #
+  # source://pry//lib/pry/commands/cat/file_formatter.rb#11
+  def initialize(file_with_embedded_line, pry_instance, opts); end
+
+  # source://pry//lib/pry/commands/cat/file_formatter.rb#27
+  def file_and_line; end
+
+  # Returns the value of attribute file_with_embedded_line.
+  #
+  # source://pry//lib/pry/commands/cat/file_formatter.rb#7
+  def file_with_embedded_line; end
+
+  # source://pry//lib/pry/commands/cat/file_formatter.rb#22
+  def format; end
+
+  # Returns the value of attribute opts.
+  #
+  # source://pry//lib/pry/commands/cat/file_formatter.rb#8
+  def opts; end
+
+  # Returns the value of attribute pry_instance.
+  #
+  # source://pry//lib/pry/commands/cat/file_formatter.rb#9
+  def pry_instance; end
+
+  private
+
+  # source://pry//lib/pry/commands/cat/file_formatter.rb#55
+  def code_type; end
+
+  # source://pry//lib/pry/commands/cat/file_formatter.rb#43
+  def code_window_size; end
+
+  # source://pry//lib/pry/commands/cat/file_formatter.rb#47
+  def decorate(content); end
+
+  # source://pry//lib/pry/commands/cat/file_formatter.rb#59
+  def detect_code_type_from_file(file_name); end
+
+  # source://pry//lib/pry/commands/cat/file_formatter.rb#35
+  def file_name; end
+
+  # source://pry//lib/pry/commands/cat/file_formatter.rb#39
+  def line_number; end
+end
+
+# source://pry//lib/pry/commands/cat/input_expression_formatter.rb#6
+class Pry::Command::Cat::InputExpressionFormatter < ::Pry::Command::Cat::AbstractFormatter
+  # @return [InputExpressionFormatter] a new instance of InputExpressionFormatter
+  #
+  # source://pry//lib/pry/commands/cat/input_expression_formatter.rb#10
+  def initialize(input_expressions, opts); end
+
+  # @raise [CommandError]
+  #
+  # source://pry//lib/pry/commands/cat/input_expression_formatter.rb#15
+  def format; end
+
+  # Returns the value of attribute input_expressions.
+  #
+  # source://pry//lib/pry/commands/cat/input_expression_formatter.rb#7
+  def input_expressions; end
+
+  # Sets the attribute input_expressions
+  #
+  # @param value the value to set the attribute input_expressions to.
+  #
+  # source://pry//lib/pry/commands/cat/input_expression_formatter.rb#7
+  def input_expressions=(_arg0); end
+
+  # Returns the value of attribute opts.
+  #
+  # source://pry//lib/pry/commands/cat/input_expression_formatter.rb#8
+  def opts; end
+
+  # Sets the attribute opts
+  #
+  # @param value the value to set the attribute opts to.
+  #
+  # source://pry//lib/pry/commands/cat/input_expression_formatter.rb#8
+  def opts=(_arg0); end
+
+  private
+
+  # source://pry//lib/pry/commands/cat/input_expression_formatter.rb#42
+  def normalized_expression_range; end
+
+  # source://pry//lib/pry/commands/cat/input_expression_formatter.rb#37
+  def numbered_input_items; end
+
+  # source://pry//lib/pry/commands/cat/input_expression_formatter.rb#33
+  def selected_input_items; end
+end
+
+# source://pry//lib/pry/commands/cd.rb#5
+class Pry::Command::Cd < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/cd.rb#25
+  def process; end
+end
+
+# source://pry//lib/pry/commands/change_inspector.rb#5
+class Pry::Command::ChangeInspector < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/change_inspector.rb#17
+  def process(inspector); end
+
+  private
+
+  # source://pry//lib/pry/commands/change_inspector.rb#28
+  def inspector_map; end
+end
+
+# source://pry//lib/pry/commands/change_prompt.rb#5
+class Pry::Command::ChangePrompt < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/change_prompt.rb#16
+  def options(opt); end
+
+  # source://pry//lib/pry/commands/change_prompt.rb#20
+  def process(prompt); end
+
+  private
+
+  # source://pry//lib/pry/commands/change_prompt.rb#38
+  def change_prompt(prompt); end
+
+  # source://pry//lib/pry/commands/change_prompt.rb#30
+  def list_prompts; end
+end
+
+# source://pry//lib/pry/commands/clear_screen.rb#5
+class Pry::Command::ClearScreen < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/clear_screen.rb#10
+  def process; end
+end
+
+# source://pry//lib/pry/commands/code_collector.rb#5
+class Pry::Command::CodeCollector
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+
+  # @return [CodeCollector] a new instance of CodeCollector
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#23
+  def initialize(args, opts, pry_instance); end
+
+  # Returns the value of attribute args.
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#8
+  def args; end
+
+  # The code object
+  #
+  # @return [Pry::WrappedModule, Pry::Method, Pry::Command]
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#86
+  def code_object; end
+
+  # The content (i.e code/docs) for the selected object.
+  # If the user provided a bare code object, it returns the source.
+  # If the user provided the `-i` or `-o` switches, it returns the
+  # selected input/output lines joined as a string. If the user used
+  # `-d CODE_OBJECT` it returns the docs for that code object.
+  #
+  # @return [String]
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#60
+  def content; end
+
+  # The name of the explicitly given file (if any).
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#13
+  def file; end
+
+  # The name of the explicitly given file (if any).
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#13
+  def file=(_arg0); end
+
+  # The line range passed to `--lines`, converted to a 0-indexed range.
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#123
+  def line_range; end
+
+  # Name of the object argument
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#128
+  def obj_name; end
+
+  # Returns the value of attribute opts.
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#9
+  def opts; end
+
+  # The selected `pry_instance.input_ring` as a string, as specified by
+  # the `-i` switch.
+  #
+  # @return [String]
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#116
+  def pry_input_content; end
+
+  # Returns the value of attribute pry_instance.
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#10
+  def pry_instance; end
+
+  # The selected `pry_instance.output_ring` as a string, as specified by
+  # the `-o` switch.
+  #
+  # @return [String]
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#104
+  def pry_output_content; end
+
+  # Given a string and a range, return the `range` lines of that
+  # string.
+  #
+  # @param content [String]
+  # @param range [Range, Fixnum]
+  # @return [String] The string restricted to the given range
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#96
+  def restrict_to_lines(content, range); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#134
+  def bad_option_combination?; end
+
+  # source://pry//lib/pry/commands/code_collector.rb#153
+  def code_object_doc; end
+
+  # source://pry//lib/pry/commands/code_collector.rb#157
+  def code_object_source_or_file; end
+
+  # source://pry//lib/pry/commands/code_collector.rb#175
+  def convert_to_range(range); end
+
+  # @raise [CommandError]
+  #
+  # source://pry//lib/pry/commands/code_collector.rb#171
+  def could_not_locate(name); end
+
+  # source://pry//lib/pry/commands/code_collector.rb#161
+  def file_content; end
+
+  # source://pry//lib/pry/commands/code_collector.rb#139
+  def pry_array_content_as_string(array, ranges); end
+
+  class << self
+    # Add the `--lines`, `-o`, `-i`, `-s`, `-d` options.
+    #
+    # source://pry//lib/pry/commands/code_collector.rb#30
+    def inject_options(opt); end
+
+    # Returns the value of attribute input_expression_ranges.
+    #
+    # source://pry//lib/pry/commands/code_collector.rb#16
+    def input_expression_ranges; end
+
+    # Sets the attribute input_expression_ranges
+    #
+    # @param value the value to set the attribute input_expression_ranges to.
+    #
+    # source://pry//lib/pry/commands/code_collector.rb#16
+    def input_expression_ranges=(_arg0); end
+
+    # Returns the value of attribute output_result_ranges.
+    #
+    # source://pry//lib/pry/commands/code_collector.rb#17
+    def output_result_ranges; end
+
+    # Sets the attribute output_result_ranges
+    #
+    # @param value the value to set the attribute output_result_ranges to.
+    #
+    # source://pry//lib/pry/commands/code_collector.rb#17
+    def output_result_ranges=(_arg0); end
+  end
+end
+
+# source://pry//lib/pry/commands/disable_pry.rb#5
+class Pry::Command::DisablePry < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/disable_pry.rb#23
+  def process; end
+end
+
+# source://pry//lib/pry/commands/edit.rb#5
+class Pry::Command::Edit < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/edit.rb#89
+  def apply_runtime_patch; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/edit.rb#172
+  def bad_option_combination?; end
+
+  # source://pry//lib/pry/commands/edit.rb#152
+  def code_object; end
+
+  # @raise [CommandError]
+  #
+  # source://pry//lib/pry/commands/edit.rb#105
+  def ensure_file_name_is_valid(file_name); end
+
+  # source://pry//lib/pry/commands/edit.rb#119
+  def file_and_line; end
+
+  # source://pry//lib/pry/commands/edit.rb#115
+  def file_and_line_for_current_exception; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/edit.rb#78
+  def file_based_exception?; end
+
+  # source://pry//lib/pry/commands/edit.rb#135
+  def file_edit; end
+
+  # source://pry//lib/pry/commands/edit.rb#148
+  def filename_argument; end
+
+  # source://pry//lib/pry/commands/edit.rb#203
+  def initial_temp_file_content; end
+
+  # source://pry//lib/pry/commands/edit.rb#180
+  def input_expression; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/edit.rb#195
+  def never_reload?; end
+
+  # source://pry//lib/pry/commands/edit.rb#25
+  def options(opt); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/edit.rb#168
+  def patch_exception?; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/edit.rb#163
+  def previously_patched?(code_object); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/edit.rb#215
+  def probably_a_file?(str); end
+
+  # source://pry//lib/pry/commands/edit.rb#46
+  def process; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/edit.rb#158
+  def pry_method?(code_object); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/edit.rb#199
+  def reload?(file_name = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/edit.rb#191
+  def reloadable?; end
+
+  # source://pry//lib/pry/commands/edit.rb#69
+  def repl_edit; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/edit.rb#64
+  def repl_edit?; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/edit.rb#82
+  def runtime_patch?; end
+end
+
+# source://pry//lib/pry/commands/edit/exception_patcher.rb#6
+class Pry::Command::Edit::ExceptionPatcher
+  # @return [ExceptionPatcher] a new instance of ExceptionPatcher
+  #
+  # source://pry//lib/pry/commands/edit/exception_patcher.rb#11
+  def initialize(pry_instance, state, exception_file_and_line); end
+
+  # Returns the value of attribute file_and_line.
+  #
+  # source://pry//lib/pry/commands/edit/exception_patcher.rb#9
+  def file_and_line; end
+
+  # Sets the attribute file_and_line
+  #
+  # @param value the value to set the attribute file_and_line to.
+  #
+  # source://pry//lib/pry/commands/edit/exception_patcher.rb#9
+  def file_and_line=(_arg0); end
+
+  # perform the patch
+  #
+  # source://pry//lib/pry/commands/edit/exception_patcher.rb#18
+  def perform_patch; end
+
+  # Returns the value of attribute pry_instance.
+  #
+  # source://pry//lib/pry/commands/edit/exception_patcher.rb#7
+  def pry_instance; end
+
+  # Sets the attribute pry_instance
+  #
+  # @param value the value to set the attribute pry_instance to.
+  #
+  # source://pry//lib/pry/commands/edit/exception_patcher.rb#7
+  def pry_instance=(_arg0); end
+
+  # Returns the value of attribute state.
+  #
+  # source://pry//lib/pry/commands/edit/exception_patcher.rb#8
+  def state; end
+
+  # Sets the attribute state
+  #
+  # @param value the value to set the attribute state to.
+  #
+  # source://pry//lib/pry/commands/edit/exception_patcher.rb#8
+  def state=(_arg0); end
+end
+
+# source://pry//lib/pry/commands/edit/file_and_line_locator.rb#6
+module Pry::Command::Edit::FileAndLineLocator
+  class << self
+    # source://pry//lib/pry/commands/edit/file_and_line_locator.rb#8
+    def from_binding(target); end
+
+    # source://pry//lib/pry/commands/edit/file_and_line_locator.rb#16
+    def from_code_object(code_object, filename_argument); end
+
+    # @raise [CommandError]
+    #
+    # source://pry//lib/pry/commands/edit/file_and_line_locator.rb#24
+    def from_exception(exception, backtrace_level); end
+
+    # when file and line are passed as a single arg, e.g my_file.rb:30
+    #
+    # source://pry//lib/pry/commands/edit/file_and_line_locator.rb#38
+    def from_filename_argument(filename_argument); end
+  end
+end
+
+# source://pry//lib/pry/commands/exit.rb#5
+class Pry::Command::Exit < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/exit.rb#25
+  def process; end
+
+  # source://pry//lib/pry/commands/exit.rb#34
+  def process_pop_and_return; end
+end
+
+# source://pry//lib/pry/commands/exit_all.rb#5
+class Pry::Command::ExitAll < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/exit_all.rb#18
+  def process; end
+end
+
+# source://pry//lib/pry/commands/exit_program.rb#5
+class Pry::Command::ExitProgram < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/exit_program.rb#18
+  def process; end
+end
+
+# source://pry//lib/pry/commands/find_method.rb#5
+class Pry::Command::FindMethod < ::Pry::ClassCommand
+  extend ::Pry::Helpers::BaseHelpers
+
+  # source://pry//lib/pry/commands/find_method.rb#31
+  def options(opt); end
+
+  # source://pry//lib/pry/commands/find_method.rb#36
+  def process; end
+
+  private
+
+  # Return the matched lines of method source if `-c` is given or ""
+  # if `-c` was not given
+  #
+  # source://pry//lib/pry/commands/find_method.rb#100
+  def additional_info(header, method); end
+
+  # Search for all methods who's implementation matches the given regex
+  # within a namespace.
+  #
+  # @param namespace [Module] The namespace to search
+  # @return [Array<Method>]
+  #
+  # source://pry//lib/pry/commands/find_method.rb#186
+  def content_search(namespace); end
+
+  # source://pry//lib/pry/commands/find_method.rb#108
+  def matched_method_lines(header, method); end
+
+  # Search for all methods with a name that matches the given regex
+  # within a namespace.
+  #
+  # @param namespace [Module] The namespace to search
+  # @return [Array<Method>]
+  #
+  # source://pry//lib/pry/commands/find_method.rb#174
+  def name_search(namespace); end
+
+  # @return [Regexp] The pattern to search for.
+  #
+  # source://pry//lib/pry/commands/find_method.rb#48
+  def pattern; end
+
+  # pretty-print a list of matching methods.
+  #
+  # @param matches [Array<Method>]
+  #
+  # source://pry//lib/pry/commands/find_method.rb#80
+  def print_matches(matches); end
+
+  # Print matched methods for a class
+  #
+  # source://pry//lib/pry/commands/find_method.rb#90
+  def print_matches_for_class(klass, grouped); end
+
+  # Run the given block against every constant in the provided namespace.
+  #
+  # @param klass [Module] The namespace in which to start the search.
+  # @param done [Hash<Module,Boolean>] The namespaces we've already visited (private)
+  # @yieldparam klass Each class/module in the namespace.
+  #
+  # source://pry//lib/pry/commands/find_method.rb#120
+  def recurse_namespace(klass, done = T.unsafe(nil), &block); end
+
+  # Gather all the methods in a namespace that pass the given block.
+  #
+  # @param namespace [Module] The namespace in which to search.
+  # @return [Array<Method>]
+  # @yieldparam method [Method] The method to test
+  # @yieldreturn [Boolean]
+  #
+  # source://pry//lib/pry/commands/find_method.rb#150
+  def search_all_methods(namespace); end
+
+  # The class to search for methods.
+  # We only search classes, so if the search object is an
+  # instance, return its class. If no search object is given
+  # search `target_self`.
+  #
+  # source://pry//lib/pry/commands/find_method.rb#67
+  def search_class; end
+
+  # Output the result of the search.
+  #
+  # @param matches [Array]
+  #
+  # source://pry//lib/pry/commands/find_method.rb#55
+  def show_search_results(matches); end
+end
+
+# source://pry//lib/pry/commands/fix_indent.rb#5
+class Pry::Command::FixIndent < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/fix_indent.rb#15
+  def process; end
+end
+
+# source://pry//lib/pry/commands/help.rb#5
+class Pry::Command::Help < ::Pry::ClassCommand
+  # Get a hash of available commands grouped by the "group" name.
+  #
+  # source://pry//lib/pry/commands/help.rb#29
+  def command_groups; end
+
+  # Display help for an individual command.
+  #
+  # @param command [Pry::Command]
+  #
+  # source://pry//lib/pry/commands/help.rb#125
+  def display_command(command); end
+
+  # Display help for a searched item, filtered by group
+  #
+  # @param search [String] The string to search for.
+  # @raise [CommandError]
+  #
+  # source://pry//lib/pry/commands/help.rb#111
+  def display_filtered_commands(search); end
+
+  # Display help for a searched item, filtered first by group
+  # and if that fails, filtered by command name.
+  #
+  # @param search [String] The string to search for.
+  #
+  # source://pry//lib/pry/commands/help.rb#98
+  def display_filtered_search_results(search); end
+
+  # Display the index view, with headings and short descriptions per command.
+  #
+  # @param groups [Hash<String, Array<Commands>>]
+  #
+  # source://pry//lib/pry/commands/help.rb#44
+  def display_index(groups); end
+
+  # Display help for an individual command or group.
+  #
+  # @param search [String] The string to search for.
+  #
+  # source://pry//lib/pry/commands/help.rb#86
+  def display_search(search); end
+
+  # source://pry//lib/pry/commands/help.rb#159
+  def group_sort_key(group_name); end
+
+  # Given a group name and an array of commands,
+  # return the help string for those commands.
+  #
+  # @param name [String] The group name.
+  # @param commands [Array<Pry::Command>]
+  # @return [String] The generated help string.
+  #
+  # source://pry//lib/pry/commands/help.rb#62
+  def help_text_for_commands(name, commands); end
+
+  # Clean search terms to make it easier to search group names
+  #
+  # @param key [String]
+  # @return [String]
+  #
+  # source://pry//lib/pry/commands/help.rb#155
+  def normalize(key); end
+
+  # source://pry//lib/pry/commands/help.rb#33
+  def process; end
+
+  # Find a subset of a hash that matches the user's search term.
+  #
+  # If there's an exact match a Hash of one element will be returned,
+  # otherwise a sub-Hash with every key that matches the search will
+  # be returned.
+  #
+  # @param search [String] the search term
+  # @param hash [Hash] the hash to search
+  #
+  # source://pry//lib/pry/commands/help.rb#137
+  def search_hash(search, hash); end
+
+  # Sort an array of commands by their `listing` name.
+  #
+  # @param commands [Array<Pry::Command>] The commands to sort
+  # @return [Array<Pry::Command>] commands sorted by listing name.
+  #
+  # source://pry//lib/pry/commands/help.rb#79
+  def sorted_commands(commands); end
+
+  # @param groups [Hash]
+  # @return [Array<String>] An array of sorted group names.
+  #
+  # source://pry//lib/pry/commands/help.rb#71
+  def sorted_group_names(groups); end
+
+  # We only want to show commands that have descriptions, so that the
+  # easter eggs don't show up.
+  #
+  # source://pry//lib/pry/commands/help.rb#20
+  def visible_commands; end
+end
+
+# source://pry//lib/pry/commands/hist.rb#5
+class Pry::Command::Hist < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/hist.rb#25
+  def options(opt); end
+
+  # source://pry//lib/pry/commands/hist.rb#43
+  def process; end
+
+  private
+
+  # Checks +replay_sequence+ for the presence of neighboring replay calls.
+  #
+  # @example
+  #   [1] pry(main)> hist --show 46894
+  #   46894: hist --replay 46675..46677
+  #   [2] pry(main)> hist --show 46675..46677
+  #   46675: 1+1
+  #   46676: a = 100
+  #   46677: hist --tail
+  #   [3] pry(main)> hist --replay 46894
+  #   Error: Replay index 46894 points out to another replay call:
+  #   `hist -r 46675..46677`
+  #   [4] pry(main)>
+  # @param replay_sequence [String] The sequence of commands to be replayed
+  #   (per saltum)
+  # @raise [Pry::CommandError] If +replay_sequence+ contains another
+  #   "hist --replay" call
+  # @return [Boolean] `false` if +replay_sequence+ does not contain another
+  #   "hist --replay" call
+  #
+  # source://pry//lib/pry/commands/hist.rb#143
+  def check_for_juxtaposed_replay(replay_sequence); end
+
+  # Finds history depending on the given switch.
+  #
+  # @return [Pry::Code] if it finds `--all` (or `-a`) switch, returns all
+  #   entries in history. Without the switch returns only the entries from the
+  #   current Pry session.
+  #
+  # source://pry//lib/pry/commands/hist.rb#168
+  def find_history; end
+
+  # source://pry//lib/pry/commands/hist.rb#105
+  def process_clear; end
+
+  # source://pry//lib/pry/commands/hist.rb#78
+  def process_display; end
+
+  # source://pry//lib/pry/commands/hist.rb#110
+  def process_replay; end
+
+  # source://pry//lib/pry/commands/hist.rb#86
+  def process_save; end
+end
+
+# source://pry//lib/pry/commands/import_set.rb#5
+class Pry::Command::ImportSet < ::Pry::ClassCommand
+  # TODO: resolve unused parameter.
+  #
+  # @raise [CommandError]
+  #
+  # source://pry//lib/pry/commands/import_set.rb#17
+  def process(_command_set_name); end
+end
+
+# source://pry//lib/pry/commands/jump_to.rb#5
+class Pry::Command::JumpTo < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/jump_to.rb#14
+  def process(break_level); end
+end
+
+# source://pry//lib/pry/commands/list_inspectors.rb#5
+class Pry::Command::ListInspectors < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/list_inspectors.rb#16
+  def process; end
+
+  private
+
+  # source://pry//lib/pry/commands/list_inspectors.rb#28
+  def inspector_map; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/list_inspectors.rb#36
+  def selected_inspector?(inspector); end
+
+  # source://pry//lib/pry/commands/list_inspectors.rb#32
+  def selected_text; end
+end
+
+# source://pry//lib/pry/commands/ls/jruby_hacks.rb#5
+class Pry::Command::Ls < ::Pry::ClassCommand
+  # Exclude -q, -v and --grep because they,
+  # don't specify what the user wants to see.
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/ls.rb#85
+  def no_user_opts?; end
+
+  # source://pry//lib/pry/commands/ls.rb#52
+  def options(opt); end
+
+  # source://pry//lib/pry/commands/ls.rb#90
+  def process; end
+
+  private
+
+  # source://pry//lib/pry/commands/ls.rb#106
+  def error_list; end
+
+  # source://pry//lib/pry/commands/ls.rb#126
+  def raise_errors_if_arguments_are_weird; end
+end
+
+# source://pry//lib/pry/commands/ls/constants.rb#6
+class Pry::Command::Ls::Constants < ::Pry::Command::Ls::Formatter
+  include ::Pry::Command::Ls::Interrogatable
+
+  # @return [Constants] a new instance of Constants
+  #
+  # source://pry//lib/pry/commands/ls/constants.rb#14
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/ls/constants.rb#23
+  def correct_opts?; end
+
+  # source://pry//lib/pry/commands/ls/constants.rb#27
+  def output_self; end
+
+  private
+
+  # source://pry//lib/pry/commands/ls/constants.rb#39
+  def format(mod, constants); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/ls/constants.rb#35
+  def show_deprecated_constants?; end
+end
+
+# source://pry//lib/pry/commands/ls/constants.rb#7
+Pry::Command::Ls::Constants::DEPRECATED_CONSTANTS = T.let(T.unsafe(nil), Array)
+
+# source://pry//lib/pry/commands/ls.rb#6
+Pry::Command::Ls::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+# source://pry//lib/pry/commands/ls/formatter.rb#6
+class Pry::Command::Ls::Formatter
+  # @return [Formatter] a new instance of Formatter
+  #
+  # source://pry//lib/pry/commands/ls/formatter.rb#10
+  def initialize(pry_instance); end
+
+  # Sets the attribute grep
+  #
+  # @param value the value to set the attribute grep to.
+  #
+  # source://pry//lib/pry/commands/ls/formatter.rb#7
+  def grep=(_arg0); end
+
+  # Returns the value of attribute pry_instance.
+  #
+  # source://pry//lib/pry/commands/ls/formatter.rb#8
+  def pry_instance; end
+
+  # source://pry//lib/pry/commands/ls/formatter.rb#16
+  def write_out; end
+
+  private
+
+  # source://pry//lib/pry/commands/ls/formatter.rb#24
+  def color(type, str); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/ls/formatter.rb#41
+  def correct_opts?; end
+
+  # source://pry//lib/pry/commands/ls/formatter.rb#37
+  def format_value(value); end
+
+  # source://pry//lib/pry/commands/ls/formatter.rb#49
+  def grep; end
+
+  # Add a new section to the output.
+  # Outputs nothing if the section would be empty.
+  #
+  # source://pry//lib/pry/commands/ls/formatter.rb#30
+  def output_section(heading, body); end
+
+  # @raise [NotImplementedError]
+  #
+  # source://pry//lib/pry/commands/ls/formatter.rb#45
+  def output_self; end
+end
+
+# source://pry//lib/pry/commands/ls/globals.rb#7
+class Pry::Command::Ls::Globals < ::Pry::Command::Ls::Formatter
+  # @return [Globals] a new instance of Globals
+  #
+  # source://pry//lib/pry/commands/ls/globals.rb#24
+  def initialize(opts, pry_instance); end
+
+  # source://pry//lib/pry/commands/ls/globals.rb#29
+  def output_self; end
+
+  private
+
+  # source://pry//lib/pry/commands/ls/globals.rb#36
+  def format(globals); end
+end
+
+# Taken from "puts global_variables.inspect".
+#
+# source://pry//lib/pry/commands/ls/globals.rb#8
+Pry::Command::Ls::Globals::BUILTIN_GLOBALS = T.let(T.unsafe(nil), Array)
+
+# `$SAFE` and `$?` are thread-local, the exception stuff only works in a
+# rescue clause, everything else is basically a local variable with a `$`
+# in its name.
+#
+# source://pry//lib/pry/commands/ls/globals.rb#19
+Pry::Command::Ls::Globals::PSEUDO_GLOBALS = T.let(T.unsafe(nil), Array)
+
+# source://pry//lib/pry/commands/ls/grep.rb#6
+class Pry::Command::Ls::Grep
+  # @return [Grep] a new instance of Grep
+  #
+  # source://pry//lib/pry/commands/ls/grep.rb#7
+  def initialize(grep_regexp); end
+
+  # source://pry//lib/pry/commands/ls/grep.rb#11
+  def regexp; end
+end
+
+# source://pry//lib/pry/commands/ls/instance_vars.rb#6
+class Pry::Command::Ls::InstanceVars < ::Pry::Command::Ls::Formatter
+  include ::Pry::Command::Ls::Interrogatable
+
+  # @return [InstanceVars] a new instance of InstanceVars
+  #
+  # source://pry//lib/pry/commands/ls/instance_vars.rb#9
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/ls/instance_vars.rb#16
+  def correct_opts?; end
+
+  # source://pry//lib/pry/commands/ls/instance_vars.rb#20
+  def output_self; end
+
+  private
+
+  # source://pry//lib/pry/commands/ls/instance_vars.rb#34
+  def format(type, vars); end
+end
+
+# source://pry//lib/pry/commands/ls/interrogatable.rb#6
+module Pry::Command::Ls::Interrogatable
+  private
+
+  # source://pry//lib/pry/commands/ls/interrogatable.rb#13
+  def interrogatee_mod; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/ls/interrogatable.rb#9
+  def interrogating_a_module?; end
+end
+
+# source://pry//lib/pry/commands/ls/jruby_hacks.rb#6
+module Pry::Command::Ls::JRubyHacks
+  private
+
+  # When removing jruby aliases, we want to keep the alias that is
+  # "least rubbish" according to this metric.
+  #
+  # source://pry//lib/pry/commands/ls/jruby_hacks.rb#40
+  def rubbishness(name); end
+
+  # JRuby creates lots of aliases for methods imported from java in an attempt
+  # to make life easier for ruby programmers.  (e.g. getFooBar becomes
+  # get_foo_bar and foo_bar, and maybe foo_bar? if it returns a Boolean). The
+  # full transformations are in the assignAliases method of:
+  # https://github.com/jruby/jruby/blob/master/src/org/jruby/javasupport/JavaClass.java
+  #
+  # This has the unfortunate side-effect of making the output of ls even more
+  # incredibly verbose than it normally would be for these objects; and so we
+  # filter out all but the nicest of these aliases here.
+  #
+  # TODO: This is a little bit vague, better heuristics could be used.
+  #       JRuby also has a lot of scala-specific logic, which we don't copy.
+  #
+  # source://pry//lib/pry/commands/ls/jruby_hacks.rb#21
+  def trim_jruby_aliases(methods); end
+end
+
+# source://pry//lib/pry/commands/ls/local_names.rb#6
+class Pry::Command::Ls::LocalNames < ::Pry::Command::Ls::Formatter
+  # @return [LocalNames] a new instance of LocalNames
+  #
+  # source://pry//lib/pry/commands/ls/local_names.rb#7
+  def initialize(no_user_opts, args, pry_instance); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/ls/local_names.rb#14
+  def correct_opts?; end
+
+  # source://pry//lib/pry/commands/ls/local_names.rb#18
+  def output_self; end
+
+  private
+
+  # source://pry//lib/pry/commands/ls/local_names.rb#25
+  def format(locals); end
+end
+
+# source://pry//lib/pry/commands/ls/local_vars.rb#6
+class Pry::Command::Ls::LocalVars < ::Pry::Command::Ls::Formatter
+  # @return [LocalVars] a new instance of LocalVars
+  #
+  # source://pry//lib/pry/commands/ls/local_vars.rb#7
+  def initialize(opts, pry_instance); end
+
+  # source://pry//lib/pry/commands/ls/local_vars.rb#13
+  def output_self; end
+
+  private
+
+  # source://pry//lib/pry/commands/ls/local_vars.rb#34
+  def colorized_assignment_style(lhs, rhs, desired_width = T.unsafe(nil)); end
+
+  # source://pry//lib/pry/commands/ls/local_vars.rb#25
+  def format(name_value_pairs); end
+end
+
+# source://pry//lib/pry/commands/ls/ls_entity.rb#6
+class Pry::Command::Ls::LsEntity
+  # @return [LsEntity] a new instance of LsEntity
+  #
+  # source://pry//lib/pry/commands/ls/ls_entity.rb#9
+  def initialize(opts); end
+
+  # source://pry//lib/pry/commands/ls/ls_entity.rb#18
+  def entities_table; end
+
+  # Returns the value of attribute pry_instance.
+  #
+  # source://pry//lib/pry/commands/ls/ls_entity.rb#7
+  def pry_instance; end
+
+  private
+
+  # source://pry//lib/pry/commands/ls/ls_entity.rb#32
+  def constants; end
+
+  # source://pry//lib/pry/commands/ls/ls_entity.rb#56
+  def entities; end
+
+  # source://pry//lib/pry/commands/ls/ls_entity.rb#28
+  def globals; end
+
+  # source://pry//lib/pry/commands/ls/ls_entity.rb#24
+  def grep(entity); end
+
+  # source://pry//lib/pry/commands/ls/ls_entity.rb#44
+  def instance_vars; end
+
+  # source://pry//lib/pry/commands/ls/ls_entity.rb#48
+  def local_names; end
+
+  # source://pry//lib/pry/commands/ls/ls_entity.rb#52
+  def local_vars; end
+
+  # source://pry//lib/pry/commands/ls/ls_entity.rb#36
+  def methods; end
+
+  # source://pry//lib/pry/commands/ls/ls_entity.rb#40
+  def self_methods; end
+end
+
+# source://pry//lib/pry/commands/ls/methods.rb#6
+class Pry::Command::Ls::Methods < ::Pry::Command::Ls::Formatter
+  include ::Pry::Command::Ls::Interrogatable
+  include ::Pry::Command::Ls::JRubyHacks
+  include ::Pry::Command::Ls::MethodsHelper
+
+  # @return [Methods] a new instance of Methods
+  #
+  # source://pry//lib/pry/commands/ls/methods.rb#10
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+
+  # source://pry//lib/pry/commands/ls/methods.rb#22
+  def output_self; end
+
+  private
+
+  # Get a lambda that can be used with `take_while` to prevent over-eager
+  # traversal of the Object's ancestry graph.
+  #
+  # source://pry//lib/pry/commands/ls/methods.rb#41
+  def below_ceiling; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/ls/methods.rb#35
+  def correct_opts?; end
+end
+
+# source://pry//lib/pry/commands/ls/methods_helper.rb#6
+module Pry::Command::Ls::MethodsHelper
+  include ::Pry::Command::Ls::JRubyHacks
+
+  private
+
+  # Get all the methods that we'll want to output.
+  #
+  # source://pry//lib/pry/commands/ls/methods_helper.rb#12
+  def all_methods(instance_methods = T.unsafe(nil)); end
+
+  # source://pry//lib/pry/commands/ls/methods_helper.rb#34
+  def format(methods); end
+
+  # source://pry//lib/pry/commands/ls/methods_helper.rb#26
+  def resolution_order; end
+end
+
+# source://pry//lib/pry/commands/ls/self_methods.rb#6
+class Pry::Command::Ls::SelfMethods < ::Pry::Command::Ls::Formatter
+  include ::Pry::Command::Ls::Interrogatable
+  include ::Pry::Command::Ls::JRubyHacks
+  include ::Pry::Command::Ls::MethodsHelper
+
+  # @return [SelfMethods] a new instance of SelfMethods
+  #
+  # source://pry//lib/pry/commands/ls/self_methods.rb#10
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+
+  # source://pry//lib/pry/commands/ls/self_methods.rb#18
+  def output_self; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/ls/self_methods.rb#28
+  def correct_opts?; end
+end
+
+# source://pry//lib/pry/commands/nesting.rb#5
+class Pry::Command::Nesting < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/nesting.rb#14
+  def process; end
+end
+
+# source://pry//lib/pry/commands/play.rb#5
+class Pry::Command::Play < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/play.rb#74
+  def code_object; end
+
+  # source://pry//lib/pry/commands/play.rb#82
+  def content; end
+
+  # source://pry//lib/pry/commands/play.rb#60
+  def content_after_options; end
+
+  # source://pry//lib/pry/commands/play.rb#70
+  def content_at_expression; end
+
+  # The file to play from when no code object is specified.
+  # e.g `play --lines 4..10`
+  #
+  # source://pry//lib/pry/commands/play.rb#92
+  def default_file; end
+
+  # source://pry//lib/pry/commands/play.rb#102
+  def file_content; end
+
+  # source://pry//lib/pry/commands/play.rb#29
+  def options(opt); end
+
+  # source://pry//lib/pry/commands/play.rb#48
+  def perform_play; end
+
+  # source://pry//lib/pry/commands/play.rb#41
+  def process; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/play.rb#78
+  def should_use_default_file?; end
+
+  # source://pry//lib/pry/commands/play.rb#53
+  def show_input; end
+end
+
+# source://pry//lib/pry/commands/pry_backtrace.rb#5
+class Pry::Command::PryBacktrace < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/pry_backtrace.rb#22
+  def process; end
+end
+
+# source://pry//lib/pry/commands/raise_up.rb#6
+class Pry::Command::RaiseUp < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/raise_up.rb#27
+  def process; end
+end
+
+# source://pry//lib/pry/commands/reload_code.rb#5
+class Pry::Command::ReloadCode < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/reload_code.rb#20
+  def process; end
+
+  private
+
+  # @raise [CommandError]
+  #
+  # source://pry//lib/pry/commands/reload_code.rb#58
+  def check_for_reloadability(code_object, identifier); end
+
+  # source://pry//lib/pry/commands/reload_code.rb#32
+  def current_file; end
+
+  # source://pry//lib/pry/commands/reload_code.rb#42
+  def reload_current_file; end
+
+  # source://pry//lib/pry/commands/reload_code.rb#51
+  def reload_object(identifier); end
+end
+
+# source://pry//lib/pry/commands/reset.rb#5
+class Pry::Command::Reset < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/reset.rb#14
+  def process; end
+end
+
+# source://pry//lib/pry/commands/ri.rb#7
+class Pry::Command::Ri < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/ri.rb#21
+  def process(spec); end
+end
+
+# source://pry//lib/pry/commands/save_file.rb#5
+class Pry::Command::SaveFile < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/save_file.rb#50
+  def display_content; end
+
+  # source://pry//lib/pry/commands/save_file.rb#39
+  def file_name; end
+
+  # source://pry//lib/pry/commands/save_file.rb#56
+  def mode; end
+
+  # source://pry//lib/pry/commands/save_file.rb#21
+  def options(opt); end
+
+  # @raise [CommandError]
+  #
+  # source://pry//lib/pry/commands/save_file.rb#28
+  def process; end
+
+  # source://pry//lib/pry/commands/save_file.rb#43
+  def save_file; end
+end
+
+# source://pry//lib/pry/commands/shell_command.rb#5
+class Pry::Command::ShellCommand < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/shell_command.rb#21
+  def process(cmd); end
+
+  private
+
+  # source://pry//lib/pry/commands/shell_command.rb#50
+  def cd_path_env; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/shell_command.rb#54
+  def cd_path_exists?; end
+
+  # source://pry//lib/pry/commands/shell_command.rb#36
+  def parse_destination(dest); end
+
+  # source://pry//lib/pry/commands/shell_command.rb#58
+  def path_from_cd_path(dest); end
+
+  # source://pry//lib/pry/commands/shell_command.rb#43
+  def process_cd(dest); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/shell_command.rb#68
+  def special_case_path?(dest); end
+end
+
+# source://pry//lib/pry/commands/shell_mode.rb#5
+class Pry::Command::ShellMode < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/shell_mode.rb#14
+  def process; end
+end
+
+# source://pry//lib/pry/commands/show_doc.rb#5
+class Pry::Command::ShowDoc < ::Pry::Command::ShowInfo
+  include ::Pry::Helpers::DocumentationHelpers
+
+  # The docs for code_object prepared for display.
+  #
+  # source://pry//lib/pry/commands/show_doc.rb#35
+  def content_for(code_object); end
+
+  # Return docs for the code_object, adjusting for whether the code_object
+  # has yard docs available, in which case it returns those.
+  # (note we only have to check yard docs for modules since they can
+  # have multiple docs, but methods can only be doc'd once so we
+  # dont need to check them)
+  #
+  # source://pry//lib/pry/commands/show_doc.rb#64
+  def docs_for(code_object); end
+
+  # Which sections to include in the 'header', can toggle: :owner,
+  # :signature and visibility.
+  #
+  # source://pry//lib/pry/commands/show_doc.rb#76
+  def header_options; end
+
+  # source://pry//lib/pry/commands/show_doc.rb#24
+  def process; end
+
+  # process the markup (if necessary) and apply colors
+  #
+  # source://pry//lib/pry/commands/show_doc.rb#44
+  def render_doc_markup_for(code_object); end
+
+  # figure out start line of docs by back-calculating based on
+  # number of lines in the comment and the start line of the code_object
+  #
+  # @return [Fixnum] start line of docs
+  #
+  # source://pry//lib/pry/commands/show_doc.rb#83
+  def start_line_for(code_object); end
+end
+
+# source://pry//lib/pry/commands/show_info.rb#5
+class Pry::Command::ShowInfo < ::Pry::ClassCommand
+  extend ::Pry::Helpers::BaseHelpers
+
+  # @return [ShowInfo] a new instance of ShowInfo
+  #
+  # source://pry//lib/pry/commands/show_info.rb#10
+  def initialize(*_arg0); end
+
+  # source://pry//lib/pry/commands/show_info.rb#127
+  def code_object_header(code_object, line_num); end
+
+  # This method checks whether the `code_object` is a WrappedModule, if it
+  # is, then it returns the first candidate (monkeypatch) with accessible
+  # source (or docs). If `code_object` is not a WrappedModule (i.e a method
+  # or a command) then the `code_object` itself is just returned.
+  #
+  # @raise [CommandError]
+  # @return [Pry::WrappedModule, Pry::Method, Pry::Command]
+  #
+  # source://pry//lib/pry/commands/show_info.rb#61
+  def code_object_with_accessible_source(code_object); end
+
+  # source://pry//lib/pry/commands/show_info.rb#213
+  def complete(input); end
+
+  # source://pry//lib/pry/commands/show_info.rb#77
+  def content_and_header_for_code_object(code_object); end
+
+  # source://pry//lib/pry/commands/show_info.rb#81
+  def content_and_headers_for_all_module_candidates(mod); end
+
+  # takes into account possible yard docs, and returns yard_file / yard_line
+  # Also adjusts for start line of comments (using start_line_for), which it
+  # has to infer by subtracting number of lines of comment from start line
+  # of code_object
+  #
+  # source://pry//lib/pry/commands/show_info.rb#205
+  def file_and_line_for(code_object); end
+
+  # Generate a header (meta-data information) for all the code
+  # object types: methods, modules, commands, procs...
+  #
+  # source://pry//lib/pry/commands/show_info.rb#106
+  def header(code_object); end
+
+  # source://pry//lib/pry/commands/show_info.rb#173
+  def header_options; end
+
+  # source://pry//lib/pry/commands/show_info.rb#142
+  def method_header(code_object, line_num); end
+
+  # source://pry//lib/pry/commands/show_info.rb#165
+  def method_sections(code_object); end
+
+  # source://pry//lib/pry/commands/show_info.rb#151
+  def module_header(code_object, line_num); end
+
+  # source://pry//lib/pry/commands/show_info.rb#100
+  def no_definition_message; end
+
+  # source://pry//lib/pry/commands/show_info.rb#185
+  def obj_name; end
+
+  # source://pry//lib/pry/commands/show_info.rb#16
+  def options(opt); end
+
+  # @raise [CommandError]
+  #
+  # source://pry//lib/pry/commands/show_info.rb#26
+  def process; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/show_info.rb#181
+  def show_all_modules?(code_object); end
+
+  # source://pry//lib/pry/commands/show_info.rb#193
+  def start_line_for(code_object); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/show_info.rb#189
+  def use_line_numbers?; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/show_info.rb#73
+  def valid_superclass?(code_object); end
+end
+
+# source://pry//lib/pry/commands/show_input.rb#5
+class Pry::Command::ShowInput < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/show_input.rb#15
+  def process; end
+end
+
+# source://pry//lib/pry/commands/show_source.rb#5
+class Pry::Command::ShowSource < ::Pry::Command::ShowInfo
+  include ::Pry::Helpers::DocumentationHelpers
+
+  # The source for code_object prepared for display.
+  #
+  # source://pry//lib/pry/commands/show_source.rb#48
+  def content_for(code_object); end
+
+  # Return docs for the code_object, adjusting for whether the code_object
+  # has yard docs available, in which case it returns those.
+  # (note we only have to check yard docs for modules since they can
+  # have multiple docs, but methods can only be doc'd once so we
+  # dont need to check them)
+  #
+  # source://pry//lib/pry/commands/show_source.rb#86
+  def docs_for(code_object); end
+
+  # Which sections to include in the 'header', can toggle: :owner,
+  # :signature and visibility.
+  #
+  # source://pry//lib/pry/commands/show_source.rb#98
+  def header_options; end
+
+  # source://pry//lib/pry/commands/show_source.rb#31
+  def options(opt); end
+
+  # source://pry//lib/pry/commands/show_source.rb#38
+  def process; end
+
+  # process the markup (if necessary) and apply colors
+  #
+  # source://pry//lib/pry/commands/show_source.rb#66
+  def render_doc_markup_for(code_object); end
+
+  # figure out start line of docs by back-calculating based on
+  # number of lines in the comment and the start line of the code_object
+  #
+  # @return [Fixnum] start line of docs
+  #
+  # source://pry//lib/pry/commands/show_source.rb#105
+  def start_line_for(code_object); end
+end
+
+# source://pry//lib/pry/commands/stat.rb#5
+class Pry::Command::Stat < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/stat.rb#19
+  def options(opt); end
+
+  # source://pry//lib/pry/commands/stat.rb#23
+  def process; end
+end
+
+# source://pry//lib/pry/commands/switch_to.rb#5
+class Pry::Command::SwitchTo < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/switch_to.rb#14
+  def process(selection); end
+end
+
+# source://pry//lib/pry/commands/toggle_color.rb#5
+class Pry::Command::ToggleColor < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/toggle_color.rb#21
+  def color_toggle; end
+
+  # source://pry//lib/pry/commands/toggle_color.rb#16
+  def process; end
+end
+
+# represents a void return value for a command
+#
+# source://pry//lib/pry/command.rb#20
+Pry::Command::VOID_VALUE = T.let(T.unsafe(nil), Object)
+
+# source://pry//lib/pry/commands/pry_version.rb#5
+class Pry::Command::Version < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/pry_version.rb#14
+  def process; end
+end
+
+# source://pry//lib/pry/commands/watch_expression.rb#5
+class Pry::Command::WatchExpression < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/watch_expression.rb#31
+  def options(opt); end
+
+  # source://pry//lib/pry/commands/watch_expression.rb#42
+  def process; end
+
+  private
+
+  # TODO: fix arguments.
+  # https://github.com/pry/pry/commit/b031df2f2f5850ee6e9018f33d35f3485a9b0423
+  #
+  # source://pry//lib/pry/commands/watch_expression.rb#93
+  def add_expression(_arguments); end
+
+  # source://pry//lib/pry/commands/watch_expression.rb#98
+  def add_hook; end
+
+  # source://pry//lib/pry/commands/watch_expression.rb#59
+  def delete(index); end
+
+  # source://pry//lib/pry/commands/watch_expression.rb#84
+  def eval_and_print_changed(output); end
+
+  # source://pry//lib/pry/commands/watch_expression.rb#55
+  def expressions; end
+
+  # source://pry//lib/pry/commands/watch_expression.rb#69
+  def list; end
+end
+
+# source://pry//lib/pry/commands/watch_expression/expression.rb#6
+class Pry::Command::WatchExpression::Expression
+  # @return [Expression] a new instance of Expression
+  #
+  # source://pry//lib/pry/commands/watch_expression/expression.rb#9
+  def initialize(pry_instance, target, source); end
+
+  # Has the value of the expression changed?
+  #
+  # We use the pretty-printed string represenation to detect differences
+  # as this avoids problems with dup (causes too many differences) and ==
+  # (causes too few)
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/watch_expression/expression.rb#29
+  def changed?; end
+
+  # source://pry//lib/pry/commands/watch_expression/expression.rb#15
+  def eval!; end
+
+  # Returns the value of attribute previous_value.
+  #
+  # source://pry//lib/pry/commands/watch_expression/expression.rb#7
+  def previous_value; end
+
+  # Returns the value of attribute pry_instance.
+  #
+  # source://pry//lib/pry/commands/watch_expression/expression.rb#7
+  def pry_instance; end
+
+  # Returns the value of attribute source.
+  #
+  # source://pry//lib/pry/commands/watch_expression/expression.rb#7
+  def source; end
+
+  # Returns the value of attribute target.
+  #
+  # source://pry//lib/pry/commands/watch_expression/expression.rb#7
+  def target; end
+
+  # source://pry//lib/pry/commands/watch_expression/expression.rb#20
+  def to_s; end
+
+  # Returns the value of attribute value.
+  #
+  # source://pry//lib/pry/commands/watch_expression/expression.rb#7
+  def value; end
+
+  private
+
+  # source://pry//lib/pry/commands/watch_expression/expression.rb#35
+  def target_eval(target, source); end
+end
+
+# source://pry//lib/pry/commands/whereami.rb#7
+class Pry::Command::Whereami < ::Pry::ClassCommand
+  # @return [Whereami] a new instance of Whereami
+  #
+  # source://pry//lib/pry/commands/whereami.rb#8
+  def initialize(*_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/whereami.rb#83
+  def bad_option_combination?; end
+
+  # source://pry//lib/pry/commands/whereami.rb#63
+  def code; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/whereami.rb#77
+  def code?; end
+
+  # source://pry//lib/pry/commands/whereami.rb#88
+  def location; end
+
+  # source://pry//lib/pry/commands/whereami.rb#55
+  def options(opt); end
+
+  # source://pry//lib/pry/commands/whereami.rb#92
+  def process; end
+
+  # source://pry//lib/pry/commands/whereami.rb#44
+  def setup; end
+
+  private
+
+  # source://pry//lib/pry/commands/whereami.rb#171
+  def class_code; end
+
+  # source://pry//lib/pry/commands/whereami.rb#152
+  def code_window; end
+
+  # source://pry//lib/pry/commands/whereami.rb#144
+  def default_code; end
+
+  # source://pry//lib/pry/commands/whereami.rb#185
+  def expand_path(filename); end
+
+  # source://pry//lib/pry/commands/whereami.rb#132
+  def handle_internal_binding; end
+
+  # source://pry//lib/pry/commands/whereami.rb#124
+  def marker; end
+
+  # source://pry//lib/pry/commands/whereami.rb#156
+  def method_code; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/whereami.rb#116
+  def nothing_to_do?; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/whereami.rb#140
+  def small_method?; end
+
+  # This either returns the `target_self`
+  # or it returns the class of `target_self` if `target_self` is not a class.
+  #
+  # @return [Pry::WrappedModule]
+  #
+  # source://pry//lib/pry/commands/whereami.rb#165
+  def target_class; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/whereami.rb#128
+  def top_level?; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/whereami.rb#120
+  def use_line_numbers?; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/commands/whereami.rb#180
+  def valid_method?; end
+
+  # source://pry//lib/pry/commands/whereami.rb#192
+  def window_size; end
+
+  class << self
+    # Returns the value of attribute method_size_cutoff.
+    #
+    # source://pry//lib/pry/commands/whereami.rb#15
+    def method_size_cutoff; end
+
+    # Sets the attribute method_size_cutoff
+    #
+    # @param value the value to set the attribute method_size_cutoff to.
+    #
+    # source://pry//lib/pry/commands/whereami.rb#15
+    def method_size_cutoff=(_arg0); end
+  end
+end
+
+# source://pry//lib/pry/commands/wtf.rb#5
+class Pry::Command::Wtf < ::Pry::ClassCommand
+  # source://pry//lib/pry/commands/wtf.rb#27
+  def options(opt); end
+
+  # source://pry//lib/pry/commands/wtf.rb#32
+  def process; end
+
+  private
+
+  # source://pry//lib/pry/commands/wtf.rb#64
+  def format_backtrace(backtrace); end
+
+  # source://pry//lib/pry/commands/wtf.rb#60
+  def format_header(title, exception); end
+
+  # source://pry//lib/pry/commands/wtf.rb#83
+  def read_line(file, line); end
+
+  # source://pry//lib/pry/commands/wtf.rb#76
+  def trim_backtrace(backtrace); end
+
+  # source://pry//lib/pry/commands/wtf.rb#48
+  def unwind_exceptions; end
+end
+
+# source://pry//lib/pry/commands/wtf.rb#25
+Pry::Command::Wtf::RUBY_FRAME_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# CommandErrors are caught by the REPL loop and displayed to the user. They
+# indicate an exceptional condition that's fatal to the current command.
+#
+# source://pry//lib/pry/exceptions.rb#68
+class Pry::CommandError < ::StandardError; end
+
+# This class is used to create sets of commands. Commands can be imported from
+# different sets, aliased, removed, etc.
+#
+# source://pry//lib/pry/command_set.rb#12
+class Pry::CommandSet
+  include ::Enumerable
+  include ::Pry::Helpers::BaseHelpers
+
+  # @param imported_sets [Array<Commandset>] Sets which will be imported automatically
+  # @return [CommandSet] a new instance of CommandSet
+  # @yield Optional block run to define commands
+  #
+  # source://pry//lib/pry/command_set.rb#20
+  def initialize(*imported_sets, &block); end
+
+  # Find a command that matches the given line
+  #
+  # @param pattern [String] The line that might be a command invocation
+  # @return [Pry::Command, nil]
+  #
+  # source://pry//lib/pry/command_set.rb#275
+  def [](pattern); end
+
+  # Re-assign the command found at _pattern_ with _command_.
+  #
+  # @example
+  #   Pry.config.commands["help"] = MyHelpCommand
+  # @param pattern [Regexp, String] The command to add or replace(found at _pattern_).
+  # @param command [Pry::Command] The command to add.
+  # @return [Pry::Command] Returns the new command (matched with "pattern".)
+  #
+  # source://pry//lib/pry/command_set.rb#298
+  def []=(pattern, command); end
+
+  # Add a command to set.
+  #
+  # @param command [Command] a subclass of Pry::Command.
+  #
+  # source://pry//lib/pry/command_set.rb#324
+  def add_command(command); end
+
+  # Aliases a command
+  #
+  # @example Creating an alias for `ls -M`
+  #   Pry.config.commands.alias_command "lM", "ls -M"
+  # @example Pass explicit description (overriding default).
+  #   Pry.config.commands.alias_command "lM", "ls -M", :desc => "cutiepie"
+  # @param match [String, Regex] The match of the alias (can be a regex).
+  # @param action [String] The action to be performed (typically
+  #   another command).
+  # @param options [Hash] The optional configuration parameters,
+  #   accepts the same as the `command` method, but also allows the
+  #   command description to be passed this way too as `:desc`
+  #
+  # source://pry//lib/pry/command_set.rb#190
+  def alias_command(match, action, options = T.unsafe(nil)); end
+
+  # Defines a new Pry command.
+  #
+  # @example
+  #   MyCommands = Pry::CommandSet.new do
+  #   command "greet", "Greet somebody" do |name|
+  #   puts "Good afternoon #{name.capitalize}!"
+  #   end
+  #   end
+  #
+  #   # From pry:
+  #   # pry(main)> pry_instance.commands = MyCommands
+  #   # pry(main)> greet john
+  #   # Good afternoon John!
+  #   # pry(main)> help greet
+  #   # Greet somebody
+  # @example Regexp command
+  #   MyCommands = Pry::CommandSet.new do
+  #   command(
+  #   /number-(\d+)/, "number-N regex command", :listing => "number"
+  #   ) do |num, name|
+  #   puts "hello #{name}, nice number: #{num}"
+  #   end
+  #   end
+  #
+  #   # From pry:
+  #   # pry(main)> pry_instance.commands = MyCommands
+  #   # pry(main)> number-10 john
+  #   # hello john, nice number: 10
+  #   # pry(main)> help number
+  #   # number-N regex command
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @param match [String, Regexp] The start of invocations of this command.
+  # @param description [String] A description of the command.
+  # @param options [Hash] The optional configuration parameters.
+  # @yield The action to perform. The parameters in the block
+  #   determines the parameters the command will receive. All
+  #   parameters passed into the block will be strings. Successive
+  #   command parameters are separated by whitespace at the Pry prompt.
+  #
+  # source://pry//lib/pry/command_set.rb#78
+  def block_command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
+
+  # Defines a new Pry command.
+  #
+  # @example
+  #   MyCommands = Pry::CommandSet.new do
+  #   command "greet", "Greet somebody" do |name|
+  #   puts "Good afternoon #{name.capitalize}!"
+  #   end
+  #   end
+  #
+  #   # From pry:
+  #   # pry(main)> pry_instance.commands = MyCommands
+  #   # pry(main)> greet john
+  #   # Good afternoon John!
+  #   # pry(main)> help greet
+  #   # Greet somebody
+  # @example Regexp command
+  #   MyCommands = Pry::CommandSet.new do
+  #   command(
+  #   /number-(\d+)/, "number-N regex command", :listing => "number"
+  #   ) do |num, name|
+  #   puts "hello #{name}, nice number: #{num}"
+  #   end
+  #   end
+  #
+  #   # From pry:
+  #   # pry(main)> pry_instance.commands = MyCommands
+  #   # pry(main)> number-10 john
+  #   # hello john, nice number: 10
+  #   # pry(main)> help number
+  #   # number-N regex command
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @param match [String, Regexp] The start of invocations of this command.
+  # @param description [String] A description of the command.
+  # @param options [Hash] The optional configuration parameters.
+  # @yield The action to perform. The parameters in the block
+  #   determines the parameters the command will receive. All
+  #   parameters passed into the block will be strings. Successive
+  #   command parameters are separated by whitespace at the Pry prompt.
+  #
+  # source://pry//lib/pry/command_set.rb#78
+  def command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
+
+  # Generate completions for the user's search.
+  #
+  # @param search [String] The line to search for
+  # @param context [Hash] The context to create the command with
+  # @return [Array<String>]
+  #
+  # source://pry//lib/pry/command_set.rb#365
+  def complete(search, context = T.unsafe(nil)); end
+
+  # Defines a new Pry command class.
+  #
+  # @example
+  #   Pry::Commands.create_command "echo", "echo's the input", :shellwords => false do
+  #   def options(opt)
+  #   opt.banner "Usage: echo [-u | -d] <string to echo>"
+  #   opt.on :u, :upcase, "ensure the output is all upper-case"
+  #   opt.on :d, :downcase, "ensure the output is all lower-case"
+  #   end
+  #
+  #   def process
+  #   if opts.present?(:u) && opts.present?(:d)
+  #   raise Pry::CommandError, "-u and -d makes no sense"
+  #   end
+  #   result = args.join(" ")
+  #   result.downcase! if opts.present?(:downcase)
+  #   result.upcase! if opts.present?(:upcase)
+  #   output.puts result
+  #   end
+  #   end
+  # @param match [String, Regexp] The start of invocations of this command.
+  # @param description [String] A description of the command.
+  # @param options [Hash] The optional configuration parameters, see {#command}
+  # @yield The class body's definition.
+  #
+  # source://pry//lib/pry/command_set.rb#117
+  def create_command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
+
+  # Removes some commands from the set
+  #
+  # @param searches [Array<String>] the matches or listings of the commands
+  #   to remove
+  #
+  # source://pry//lib/pry/command_set.rb#138
+  def delete(*searches); end
+
+  # Sets or gets the description for a command (replacing the old
+  # description). Returns current description if no description
+  # parameter provided.
+  #
+  # @example Setting
+  #   MyCommands = Pry::CommandSet.new do
+  #   desc "help", "help description"
+  #   end
+  # @example Getting
+  #   Pry.config.commands.desc "amend-line"
+  # @param search [String, Regexp] The command match.
+  # @param description [String?] (nil) The command description.
+  #
+  # source://pry//lib/pry/command_set.rb#253
+  def desc(search, description = T.unsafe(nil)); end
+
+  # source://pry//lib/pry/command_set.rb#131
+  def each(&block); end
+
+  # Find a command that matches the given line
+  #
+  # @param pattern [String] The line that might be a command invocation
+  # @return [Pry::Command, nil]
+  #
+  # source://pry//lib/pry/command_set.rb#275
+  def find_command(pattern); end
+
+  # @param match_or_listing [String, Regexp] The match or listing of a command.
+  #   of the command to retrieve.
+  # @return [Command] The command object matched.
+  #
+  # source://pry//lib/pry/command_set.rb#173
+  def find_command_by_match_or_listing(match_or_listing); end
+
+  # Find the command that the user might be trying to refer to.
+  #
+  # @param search [String] The user's search.
+  # @return [Pry::Command?]
+  #
+  # source://pry//lib/pry/command_set.rb#331
+  def find_command_for_help(search); end
+
+  # Returns the value of attribute helper_module.
+  #
+  # source://pry//lib/pry/command_set.rb#15
+  def helper_module; end
+
+  # Imports all the commands from one or more sets.
+  #
+  # @param sets [Array<CommandSet>] Command sets, all of the commands of which
+  #   will be imported.
+  # @return [Pry::CommandSet] Returns the reciever (a command set).
+  #
+  # source://pry//lib/pry/command_set.rb#149
+  def import(*sets); end
+
+  # Imports some commands from a set
+  #
+  # @param set [CommandSet] Set to import commands from
+  # @param matches [Array<String>] Commands to import
+  # @return [Pry::CommandSet] Returns the reciever (a command set).
+  #
+  # source://pry//lib/pry/command_set.rb#161
+  def import_from(set, *matches); end
+
+  # @return [Array] The list of commands provided by the command set.
+  #
+  # source://pry//lib/pry/command_set.rb#262
+  def keys; end
+
+  # @return [Array] The list of commands provided by the command set.
+  #
+  # source://pry//lib/pry/command_set.rb#262
+  def list_commands; end
+
+  # Process the given line to see whether it needs executing as a command.
+  #
+  # @param val [String] The line to execute
+  # @param context [Hash] The context to execute the commands with
+  # @return [CommandSet::Result]
+  #
+  # source://pry//lib/pry/command_set.rb#351
+  def process_line(val, context = T.unsafe(nil)); end
+
+  # Rename a command. Accepts either match or listing for the search.
+  #
+  # @example Renaming the `ls` command and changing its description.
+  #   Pry.config.commands.rename "dir", "ls", :description => "DOS friendly ls"
+  # @param new_match [String, Regexp] The new match for the command.
+  # @param search [String, Regexp] The command's current match or listing.
+  # @param options [Hash] The optional configuration parameters,
+  #   accepts the same as the `command` method, but also allows the
+  #   command description to be passed this way too.
+  #
+  # source://pry//lib/pry/command_set.rb#227
+  def rename_command(new_match, search, options = T.unsafe(nil)); end
+
+  # source://pry//lib/pry/command_set.rb#267
+  def to_h; end
+
+  # source://pry//lib/pry/command_set.rb#267
+  def to_hash; end
+
+  # Is the given line a command invocation?
+  #
+  # @param val [String]
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/command_set.rb#343
+  def valid_command?(val); end
+
+  private
+
+  # Defines helpers methods for this command sets.
+  # Those helpers are only defined in this command set.
+  #
+  # @example
+  #   helpers do
+  #   def hello
+  #   puts "Hello!"
+  #   end
+  #
+  #   include OtherModule
+  #   end
+  # @yield A block defining helper methods
+  #
+  # source://pry//lib/pry/command_set.rb#390
+  def helpers(&block); end
+end
+
+# CommandState is a data structure to hold per-command state.
+#
+# Pry commands can store arbitrary state here. This state persists between
+# subsequent command invocations. All state saved here is unique to the
+# command.
+#
+# @api private
+# @since v0.13.0
+#
+# source://pry//lib/pry/command_state.rb#14
+class Pry::CommandState
+  # @api private
+  # @return [CommandState] a new instance of CommandState
+  # @since v0.13.0
+  #
+  # source://pry//lib/pry/command_state.rb#19
+  def initialize; end
+
+  # @api private
+  # @since v0.13.0
+  #
+  # source://pry//lib/pry/command_state.rb#27
+  def reset(command_name); end
+
+  # @api private
+  # @since v0.13.0
+  #
+  # source://pry//lib/pry/command_state.rb#23
+  def state_for(command_name); end
+
+  class << self
+    # @api private
+    # @since v0.13.0
+    #
+    # source://pry//lib/pry/command_state.rb#15
+    def default; end
+  end
+end
+
+# source://pry//lib/pry.rb#35
+Pry::Commands = T.let(T.unsafe(nil), Pry::CommandSet)
+
+# @api private
+#
+# source://pry//lib/pry/config/attributable.rb#4
+class Pry::Config
+  extend ::Pry::Config::Attributable
+
+  # @api private
+  # @return [Config] a new instance of Config
+  #
+  # source://pry//lib/pry/config.rb#154
+  def initialize; end
+
+  # @api private
+  #
+  # source://pry//lib/pry/config.rb#234
+  def [](attr); end
+
+  # @api private
+  #
+  # source://pry//lib/pry/config.rb#230
+  def []=(attr, value); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def auto_indent; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def auto_indent=(_arg0); end
+
+  # @api private
+  # @return [Boolean] whether or not display a warning when a command name
+  #   collides with a method/local in the current context.
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def collision_warning; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def collision_warning=(_arg0); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def color; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def color=(_arg0); end
+
+  # @api private
+  # @return [Proc]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def command_completions; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def command_completions=(_arg0); end
+
+  # A string that must precede all commands. For example, if is is
+  # set to "%", the "cd" command must be invoked as "%cd").
+  #
+  # @api private
+  # @return [String]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def command_prefix; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def command_prefix=(_arg0); end
+
+  # @api private
+  # @return [Pry::CommandSet]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def commands; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def commands=(_arg0); end
+
+  # @api private
+  # @return [#build_completion_proc] a completer to use
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def completer; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def completer=(_arg0); end
+
+  # @api private
+  #
+  # source://pry//lib/pry/config.rb#259
+  def control_d_handler; end
+
+  # @api private
+  #
+  # source://pry//lib/pry/config.rb#260
+  def control_d_handler=(value); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def correct_indent; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def correct_indent=(_arg0); end
+
+  # @api private
+  # @return [Integer] The number of lines of context to show before and after
+  #   exceptions
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def default_window_size; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def default_window_size=(_arg0); end
+
+  # @api private
+  # @return [Boolean] whether to disable edit-method's auto-reloading behavior
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def disable_auto_reload; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def disable_auto_reload=(_arg0); end
+
+  # If it is a String, then that String is used as the shell
+  # command to invoke the editor.
+  #
+  # If it responds to #call is callable then `file`, `line`, and `reloading`
+  # are passed to it. `reloading` indicates whether Pry will be reloading code
+  # after the shell command returns. All parameters are optional.
+  #
+  # @api private
+  # @return [String, #call]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def editor; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def editor=(_arg0); end
+
+  # @api private
+  # @return [Proc] the printer for exceptions
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def exception_handler; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def exception_handler=(_arg0); end
+
+  # @api private
+  # @deprecated
+  # @return [Array] Exception that Pry shouldn't rescue
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def exception_whitelist; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def exception_whitelist=(_arg0); end
+
+  # @api private
+  # @return [String] a line of code to execute in context before the session
+  #   starts
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def exec_string; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def exec_string=(_arg0); end
+
+  # @api private
+  # @return [Hash{Symbol=>Proc}]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def extra_sticky_locals; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def extra_sticky_locals=(_arg0); end
+
+  # @api private
+  # @return [Proc]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def file_completions; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def file_completions=(_arg0); end
+
+  # @api private
+  # @return [Pry::History]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def history; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def history=(_arg0); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def history_file; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def history_file=(_arg0); end
+
+  # @api private
+  # @return [Array<String,Regexp>]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def history_ignorelist; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def history_ignorelist=(_arg0); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def history_load; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def history_load=(_arg0); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def history_save; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def history_save=(_arg0); end
+
+  # @api private
+  # @return [Pry::Hooks]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def hooks; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def hooks=(_arg0); end
+
+  # @api private
+  # @return [IO, #readline] he object from which Pry retrieves its lines of
+  #   input
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def input; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def input=(_arg0); end
+
+  # @api private
+  # @return [Hash]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def ls; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def ls=(_arg0); end
+
+  # @api private
+  # @return [Integer] how many input/output lines to keep in memory
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def memory_size; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def memory_size=(_arg0); end
+
+  # @api private
+  #
+  # source://pry//lib/pry/config.rb#226
+  def merge(config_hash); end
+
+  # @api private
+  #
+  # source://pry//lib/pry/config.rb#221
+  def merge!(config_hash); end
+
+  # @api private
+  #
+  # source://pry//lib/pry/config.rb#239
+  def method_missing(method_name, *args, &_block); end
+
+  # @api private
+  # @return [IO, #puts] where Pry should output results provided by {input}
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def output; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def output=(_arg0); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def output_prefix; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def output_prefix=(_arg0); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def pager; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def pager=(_arg0); end
+
+  # @api private
+  # @return [Proc] the printer for Ruby expressions (not commands)
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def print; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def print=(_arg0); end
+
+  # @api private
+  # @return [Pry::Prompt]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def prompt; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def prompt=(_arg0); end
+
+  # @api private
+  # @return [String] The display name that is part of the prompt
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def prompt_name; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def prompt_name=(_arg0); end
+
+  # @api private
+  # @return [Array<Object>] the list of objects that are known to have a
+  #   1-line #inspect output suitable for prompt
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def prompt_safe_contexts; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def prompt_safe_contexts=(_arg0); end
+
+  # @api private
+  # @return [Boolean] suppresses whereami output on `binding.pry`
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def quiet; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def quiet=(_arg0); end
+
+  # @api private
+  # @return [String]
+  # @since v0.13.0
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def rc_file; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def rc_file=(_arg0); end
+
+  # @api private
+  # @return [Array<String>] Ruby files to be required
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def requires; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def requires=(_arg0); end
+
+  # @api private
+  # @return [Boolean] whether the local ./.pryrc should be loaded
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def should_load_local_rc; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def should_load_local_rc=(_arg0); end
+
+  # @api private
+  # @return [Boolean] whether the global ~/.pryrc should be loaded
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def should_load_rc; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def should_load_rc=(_arg0); end
+
+  # @api private
+  # @return [Boolean] whether to load files specified with the -r flag
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def should_load_requires; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def should_load_requires=(_arg0); end
+
+  # Whether Pry should trap SIGINT and cause it to raise an Interrupt
+  # exception. This is only useful on JRuby, MRI does this for us.
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def should_trap_interrupts; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def should_trap_interrupts=(_arg0); end
+
+  # @api private
+  # @return [Proc] The proc that runs system commands
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def system; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def system=(_arg0); end
+
+  # @api private
+  # @return [Array] Exception that Pry shouldn't rescue
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def unrescued_exceptions; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def unrescued_exceptions=(_arg0); end
+
+  # @api private
+  # @return [Boolean] displays a warning about experience improvement on
+  #   Windows
+  #
+  # source://pry//lib/pry/config/attributable.rb#13
+  def windows_console_warning; end
+
+  # source://pry//lib/pry/config/attributable.rb#18
+  def windows_console_warning=(_arg0); end
+
+  private
+
+  # @api private
+  #
+  # source://pry//lib/pry/config.rb#303
+  def default_rc_file; end
+
+  # @api private
+  #
+  # source://pry//lib/pry/config.rb#254
+  def initialize_dup(other); end
+
+  # @api private
+  #
+  # source://pry//lib/pry/config.rb#289
+  def lazy_readline; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/config.rb#250
+  def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end
+end
+
+# Attributable provides the ability to create "attribute"
+# accessors. Attribute accessors create a standard "attr_writer" and a
+# customised "attr_reader". This reader is Proc-aware (lazy).
+#
+# @api private
+# @since v0.13.0
+#
+# source://pry//lib/pry/config/attributable.rb#11
+module Pry::Config::Attributable
+  # @api private
+  # @since v0.13.0
+  #
+  # source://pry//lib/pry/config/attributable.rb#12
+  def attribute(attr_name); end
+end
+
+# LazyValue is a Proc (block) wrapper. It is meant to be used as a
+# configuration value. Subsequent `#call` calls always evaluate the given
+# block.
+#
+# @api private
+# @example
+#   num = 19
+#   value = Pry::Config::LazyValue.new { num += 1 }
+#   value.foo # => 20
+#   value.foo # => 21
+#   value.foo # => 22
+# @see Pry::Config::MemoizedValue
+# @since v0.13.0
+#
+# source://pry//lib/pry/config/lazy_value.rb#19
+class Pry::Config::LazyValue
+  # @api private
+  # @return [LazyValue] a new instance of LazyValue
+  # @since v0.13.0
+  #
+  # source://pry//lib/pry/config/lazy_value.rb#20
+  def initialize(&block); end
+
+  # @api private
+  # @since v0.13.0
+  #
+  # source://pry//lib/pry/config/lazy_value.rb#24
+  def call; end
+end
+
+# MemoizedValue is a Proc (block) wrapper. It is meant to be used as a
+# configuration value. Subsequent `#call` calls return the same memoized
+# result.
+#
+# @api private
+# @example
+#   num = 19
+#   value = Pry::Config::MemoizedValue.new { num += 1 }
+#   value.call # => 20
+#   value.call # => 20
+#   value.call # => 20
+# @see Pry::Config::LazyValue
+# @since v0.13.0
+#
+# source://pry//lib/pry/config/memoized_value.rb#19
+class Pry::Config::MemoizedValue
+  # @api private
+  # @return [MemoizedValue] a new instance of MemoizedValue
+  # @since v0.13.0
+  #
+  # source://pry//lib/pry/config/memoized_value.rb#20
+  def initialize(&block); end
+
+  # @api private
+  # @since v0.13.0
+  #
+  # source://pry//lib/pry/config/memoized_value.rb#26
+  def call; end
+end
+
+# Value holds a value for the given attribute and decides how it should
+# be read. Procs get called, other values are returned as is.
+#
+# @api private
+# @since v0.13.0
+#
+# source://pry//lib/pry/config/value.rb#10
+class Pry::Config::Value
+  # @api private
+  # @return [Value] a new instance of Value
+  # @since v0.13.0
+  #
+  # source://pry//lib/pry/config/value.rb#11
+  def initialize(value); end
+
+  # @api private
+  # @since v0.13.0
+  #
+  # source://pry//lib/pry/config/value.rb#15
+  def call; end
+end
+
+# @api private
+# @since v0.13.0
+#
+# source://pry//lib/pry/control_d_handler.rb#6
+module Pry::ControlDHandler
+  class << self
+    # Deal with the ^D key being pressed. Different behaviour in different
+    # cases:
+    #   1. In an expression behave like `!` command.
+    #   2. At top-level session behave like `exit` command.
+    #   3. In a nested session behave like `cd ..`.
+    #
+    # @api private
+    # @since v0.13.0
+    #
+    # source://pry//lib/pry/control_d_handler.rb#12
+    def default(pry_instance); end
+  end
+end
+
+# source://pry//lib/pry/pry_instance.rb#59
+Pry::EMPTY_COMPLETIONS = T.let(T.unsafe(nil), Array)
+
+# source://pry//lib/pry/editor.rb#6
+class Pry::Editor
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+
+  # @return [Editor] a new instance of Editor
+  #
+  # source://pry//lib/pry/editor.rb#27
+  def initialize(pry_instance); end
+
+  # Generate the string that's used to start the editor. This includes
+  # all the flags we want as well as the file and line number we
+  # want to open at.
+  #
+  # source://pry//lib/pry/editor.rb#60
+  def build_editor_invocation_string(file, line, blocking); end
+
+  # source://pry//lib/pry/editor.rb#31
+  def edit_tempfile_with_content(initial_content, line = T.unsafe(nil)); end
+
+  # source://pry//lib/pry/editor.rb#41
+  def invoke_editor(file, line, blocking = T.unsafe(nil)); end
+
+  # Returns the value of attribute pry_instance.
+  #
+  # source://pry//lib/pry/editor.rb#25
+  def pry_instance; end
+
+  private
+
+  # Some editors that run outside the terminal allow you to control whether or
+  # not to block the process from which they were launched (in this case, Pry).
+  # For those editors, return the flag that produces the desired behavior.
+  #
+  # source://pry//lib/pry/editor.rb#100
+  def blocking_flag_for_editor(blocking); end
+
+  # Get the name of the binary that Pry.config.editor points to.
+  #
+  # This is useful for deciding which flags we pass to the editor as
+  # we can just use the program's name and ignore any absolute paths.
+  #
+  # @example
+  #   Pry.config.editor="/home/conrad/bin/textmate -w"
+  #   editor_name
+  #   # => textmate
+  #
+  # source://pry//lib/pry/editor.rb#153
+  def editor_name; end
+
+  # Start the editor running, using the calculated invocation string
+  #
+  # source://pry//lib/pry/editor.rb#76
+  def open_editor(editor_invocation); end
+
+  # We need JRuby specific code here cos just shelling out using
+  # system() appears to be pretty broken :/
+  #
+  # source://pry//lib/pry/editor.rb#89
+  def open_editor_on_jruby(editor_invocation); end
+
+  # Return the syntax for a given editor for starting the editor
+  # and moving to a particular line within that file
+  #
+  # source://pry//lib/pry/editor.rb#115
+  def start_line_syntax_for_editor(file_name, line_number); end
+
+  class << self
+    # source://pry//lib/pry/editor.rb#7
+    def default; end
+  end
+end
+
+# Env is a helper module to work with environment variables.
+#
+# @api private
+# @since v0.13.0
+#
+# source://pry//lib/pry/env.rb#8
+module Pry::Env
+  class << self
+    # @api private
+    # @since v0.13.0
+    #
+    # source://pry//lib/pry/env.rb#9
+    def [](key); end
+  end
+end
+
+# @api private
+# @since v0.13.0
+#
+# source://pry//lib/pry/exception_handler.rb#6
+module Pry::ExceptionHandler
+  class << self
+    # Will only show the first line of the backtrace.
+    #
+    # @api private
+    # @since v0.13.0
+    #
+    # source://pry//lib/pry/exception_handler.rb#9
+    def handle_exception(output, exception, _pry_instance); end
+
+    private
+
+    # @api private
+    # @since v0.13.0
+    #
+    # source://pry//lib/pry/exception_handler.rb#37
+    def cause_text(cause); end
+
+    # @api private
+    # @since v0.13.0
+    #
+    # source://pry//lib/pry/exception_handler.rb#32
+    def exception_text(exception); end
+
+    # @api private
+    # @since v0.13.0
+    #
+    # source://pry//lib/pry/exception_handler.rb#19
+    def standard_error_text_for(exception); end
+  end
+end
+
+# source://pry//lib/pry/forwardable.rb#4
+module Pry::Forwardable
+  include ::Forwardable
+
+  # Since Ruby 2.4, Forwardable will print a warning when
+  # calling a method that is private on a delegate, and
+  # in the future it could be an error: https://bugs.ruby-lang.org/issues/12782#note-3
+  #
+  # That's why we revert to a custom implementation for delegating one
+  # private method to another.
+  #
+  # source://pry//lib/pry/forwardable.rb#16
+  def def_private_delegators(target, *private_delegates); end
+end
+
+# When we try to get a binding for an object, we try to define a method on
+# that Object's singleton class. This doesn't work for "frozen" Object's, and
+# the exception is just a vanilla RuntimeError.
+#
+# source://pry//lib/pry/exceptions.rb#56
+module Pry::FrozenObjectException
+  class << self
+    # source://pry//lib/pry/exceptions.rb#57
+    def ===(exception); end
+  end
+end
+
+# @return [Boolean] true if this Ruby supports safe levels and tainting,
+#   to guard against using deprecated or unsupported features
+#
+# source://pry//lib/pry/pry_class.rb#11
+Pry::HAS_SAFE_LEVEL = T.let(T.unsafe(nil), FalseClass)
+
+# source://pry//lib/pry/helpers/base_helpers.rb#4
+module Pry::Helpers
+  class << self
+    # source://pry//lib/pry/helpers/table.rb#27
+    def tablify(things, line_length, pry_instance = T.unsafe(nil)); end
+
+    # source://pry//lib/pry/helpers/table.rb#5
+    def tablify_or_one_line(heading, things, pry_instance = T.unsafe(nil)); end
+
+    # source://pry//lib/pry/helpers/table.rb#16
+    def tablify_to_screen_width(things, options, pry_instance = T.unsafe(nil)); end
+  end
+end
+
+# source://pry//lib/pry/helpers/base_helpers.rb#5
+module Pry::Helpers::BaseHelpers
+  extend ::Pry::Helpers::BaseHelpers
+
+  # source://pry//lib/pry/helpers/base_helpers.rb#43
+  def colorize_code(code); end
+
+  # source://pry//lib/pry/helpers/base_helpers.rb#27
+  def find_command(name, set = T.unsafe(nil)); end
+
+  # formatting
+  #
+  # source://pry//lib/pry/helpers/base_helpers.rb#54
+  def heading(text); end
+
+  # source://pry//lib/pry/helpers/base_helpers.rb#47
+  def highlight(string, regexp, highlight_color = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/helpers/base_helpers.rb#34
+  def not_a_real_file?(file); end
+
+  # Acts like send but ignores any methods defined below Object or Class in the
+  # inheritance hierarchy.
+  # This is required to introspect methods on objects like Net::HTTP::Get that
+  # have overridden the `method` method.
+  #
+  # source://pry//lib/pry/helpers/base_helpers.rb#22
+  def safe_send(obj, method, *args, &block); end
+
+  # source://pry//lib/pry/helpers/base_helpers.rb#8
+  def silence_warnings; end
+
+  # Send the given text through the best available pager (if Pry.config.pager is
+  # enabled). Infers where to send the output if used as a mixin.
+  # DEPRECATED.
+  #
+  # source://pry//lib/pry/helpers/base_helpers.rb#62
+  def stagger_output(text, _out = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/helpers/base_helpers.rb#38
+  def use_ansi_codes?; end
+end
+
+# source://pry//lib/pry/helpers/command_helpers.rb#7
+module Pry::Helpers::CommandHelpers
+  include ::Pry::Helpers::OptionsHelpers
+  extend ::Pry::Helpers::OptionsHelpers
+  extend ::Pry::Helpers::CommandHelpers
+
+  # source://pry//lib/pry/helpers/command_helpers.rb#115
+  def absolute_index_number(line_number, array_length); end
+
+  # source://pry//lib/pry/helpers/command_helpers.rb#123
+  def absolute_index_range(range_or_number, array_length); end
+
+  # source://pry//lib/pry/helpers/command_helpers.rb#31
+  def get_method_or_raise(method_name, context, opts = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/helpers/command_helpers.rb#21
+  def internal_binding?(context); end
+
+  # source://pry//lib/pry/helpers/command_helpers.rb#97
+  def one_index_number(line_number); end
+
+  # convert a 1-index range to a 0-indexed one
+  #
+  # source://pry//lib/pry/helpers/command_helpers.rb#102
+  def one_index_range(range); end
+
+  # source://pry//lib/pry/helpers/command_helpers.rb#106
+  def one_index_range_or_number(range_or_number); end
+
+  # Restrict a string to the given range of lines (1-indexed)
+  #
+  # @param content [String] The string.
+  # @param lines [Range, Integer] The line(s) to restrict it to.
+  # @return [String] The resulting string.
+  #
+  # source://pry//lib/pry/helpers/command_helpers.rb#92
+  def restrict_to_lines(content, lines); end
+
+  # source://pry//lib/pry/helpers/command_helpers.rb#135
+  def set_file_and_dir_locals(file_name, pry = T.unsafe(nil), ctx = T.unsafe(nil)); end
+
+  # Open a temp file and yield it to the block, closing it after
+  #
+  # @return [String] The path of the temp file
+  #
+  # source://pry//lib/pry/helpers/command_helpers.rb#14
+  def temp_file(ext = T.unsafe(nil)); end
+
+  # Remove any common leading whitespace from every line in `text`. This
+  # can be used to make a HEREDOC line up with the left margin, without
+  # sacrificing the indentation level of the source code.
+  #
+  # @example
+  #   opt.banner(unindent(<<-USAGE))
+  #   Lorem ipsum dolor sit amet, consectetur adipisicing elit,
+  #   sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+  #   "Ut enim ad minim veniam."
+  #   USAGE
+  # @param dirty_text [String] The text from which to remove indentation
+  # @return [String] the text with indentation stripped
+  #
+  # source://pry//lib/pry/helpers/command_helpers.rb#68
+  def unindent(dirty_text, left_padding = T.unsafe(nil)); end
+end
+
+# This class contains methods useful for extracting
+# documentation from methods and classes.
+#
+# source://pry//lib/pry/helpers/documentation_helpers.rb#7
+module Pry::Helpers::DocumentationHelpers
+  private
+
+  # Given a string that makes up a comment in a source-code file parse out the content
+  # that the user is intended to read. (i.e. without leading indentation, #-characters
+  # or shebangs)
+  #
+  # @param comment [String]
+  # @return [String]
+  #
+  # source://pry//lib/pry/helpers/documentation_helpers.rb#67
+  def get_comment_content(comment); end
+
+  # source://pry//lib/pry/helpers/documentation_helpers.rb#51
+  def process_comment_markup(comment); end
+
+  # source://pry//lib/pry/helpers/documentation_helpers.rb#15
+  def process_rdoc(comment); end
+
+  # source://pry//lib/pry/helpers/documentation_helpers.rb#45
+  def process_yardoc(comment); end
+
+  # source://pry//lib/pry/helpers/documentation_helpers.rb#30
+  def process_yardoc_tag(comment, tag); end
+
+  # @param code [String]
+  # @return [String]
+  #
+  # source://pry//lib/pry/helpers/documentation_helpers.rb#57
+  def strip_comments_from_c_code(code); end
+
+  # @param text [String]
+  # @return [String]
+  #
+  # source://pry//lib/pry/helpers/documentation_helpers.rb#79
+  def strip_leading_whitespace(text); end
+
+  class << self
+    # Given a string that makes up a comment in a source-code file parse out the content
+    # that the user is intended to read. (i.e. without leading indentation, #-characters
+    # or shebangs)
+    #
+    # @param comment [String]
+    # @return [String]
+    #
+    # source://pry//lib/pry/helpers/documentation_helpers.rb#67
+    def get_comment_content(comment); end
+
+    # source://pry//lib/pry/helpers/documentation_helpers.rb#51
+    def process_comment_markup(comment); end
+
+    # source://pry//lib/pry/helpers/documentation_helpers.rb#15
+    def process_rdoc(comment); end
+
+    # source://pry//lib/pry/helpers/documentation_helpers.rb#45
+    def process_yardoc(comment); end
+
+    # source://pry//lib/pry/helpers/documentation_helpers.rb#30
+    def process_yardoc_tag(comment, tag); end
+
+    # @param code [String]
+    # @return [String]
+    #
+    # source://pry//lib/pry/helpers/documentation_helpers.rb#57
+    def strip_comments_from_c_code(code); end
+
+    # @param text [String]
+    # @return [String]
+    #
+    # source://pry//lib/pry/helpers/documentation_helpers.rb#79
+    def strip_leading_whitespace(text); end
+  end
+end
+
+# source://pry//lib/pry/helpers/documentation_helpers.rb#8
+Pry::Helpers::DocumentationHelpers::YARD_TAGS = T.let(T.unsafe(nil), Array)
+
+# source://pry//lib/pry/helpers/options_helpers.rb#5
+module Pry::Helpers::OptionsHelpers
+  private
+
+  # Get the method object parsed by the slop instance
+  #
+  # source://pry//lib/pry/helpers/options_helpers.rb#23
+  def method_object; end
+
+  # Add method options to the Pry::Slop instance
+  #
+  # source://pry//lib/pry/helpers/options_helpers.rb#9
+  def method_options(opt); end
+
+  class << self
+    # Get the method object parsed by the slop instance
+    #
+    # source://pry//lib/pry/helpers/options_helpers.rb#23
+    def method_object; end
+
+    # Add method options to the Pry::Slop instance
+    #
+    # source://pry//lib/pry/helpers/options_helpers.rb#9
+    def method_options(opt); end
+  end
+end
+
+# Contains methods for querying the platform that Pry is running on
+#
+# @api public
+# @since v0.12.0
+#
+# source://pry//lib/pry/helpers/platform.rb#10
+module Pry::Helpers::Platform
+  class << self
+    # @api public
+    # @return [Boolean]
+    # @since v0.12.0
+    #
+    # source://pry//lib/pry/helpers/platform.rb#35
+    def jruby?; end
+
+    # @api public
+    # @return [Boolean]
+    # @since v0.12.0
+    #
+    # source://pry//lib/pry/helpers/platform.rb#40
+    def jruby_19?; end
+
+    # @api public
+    # @return [Boolean]
+    # @since v0.12.0
+    #
+    # source://pry//lib/pry/helpers/platform.rb#17
+    def linux?; end
+
+    # @api public
+    # @return [Boolean]
+    # @since v0.12.0
+    #
+    # source://pry//lib/pry/helpers/platform.rb#12
+    def mac_osx?; end
+
+    # @api public
+    # @return [Boolean]
+    # @since v0.12.0
+    #
+    # source://pry//lib/pry/helpers/platform.rb#45
+    def mri?; end
+
+    # @api public
+    # @return [Boolean]
+    # @since v0.12.0
+    #
+    # source://pry//lib/pry/helpers/platform.rb#50
+    def mri_2?; end
+
+    # @api public
+    # @return [Boolean] true when Pry is running on Windows with ANSI support,
+    #   false otherwise
+    # @since v0.12.0
+    #
+    # source://pry//lib/pry/helpers/platform.rb#23
+    def windows?; end
+
+    # @api public
+    # @return [Boolean]
+    # @since v0.12.0
+    #
+    # source://pry//lib/pry/helpers/platform.rb#28
+    def windows_ansi?; end
+  end
+end
+
+# source://pry//lib/pry/helpers/table.rb#35
+class Pry::Helpers::Table
+  # @return [Table] a new instance of Table
+  #
+  # source://pry//lib/pry/helpers/table.rb#37
+  def initialize(items, args, pry_instance = T.unsafe(nil)); end
+
+  # source://pry//lib/pry/helpers/table.rb#81
+  def ==(other); end
+
+  # Returns the value of attribute column_count.
+  #
+  # source://pry//lib/pry/helpers/table.rb#36
+  def column_count; end
+
+  # source://pry//lib/pry/helpers/table.rb#68
+  def column_count=(count); end
+
+  # source://pry//lib/pry/helpers/table.rb#77
+  def columns; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/helpers/table.rb#73
+  def fits_on_line?(line_length); end
+
+  # Returns the value of attribute items.
+  #
+  # source://pry//lib/pry/helpers/table.rb#36
+  def items; end
+
+  # source://pry//lib/pry/helpers/table.rb#62
+  def items=(items); end
+
+  # source://pry//lib/pry/helpers/table.rb#47
+  def rows_to_s(style = T.unsafe(nil)); end
+
+  # source://pry//lib/pry/helpers/table.rb#85
+  def to_a; end
+
+  # source://pry//lib/pry/helpers/table.rb#43
+  def to_s; end
+
+  private
+
+  # source://pry//lib/pry/helpers/table.rb#91
+  def _max_width(things); end
+
+  # source://pry//lib/pry/helpers/table.rb#95
+  def _rebuild_colorless_cache; end
+
+  # source://pry//lib/pry/helpers/table.rb#116
+  def _recall_color_for(thing); end
+
+  # source://pry//lib/pry/helpers/table.rb#105
+  def _recolumn; end
+end
+
+# The methods defined on {Text} are available to custom commands via
+# {Pry::Command#text}.
+#
+# source://pry//lib/pry/helpers/text.rb#7
+module Pry::Helpers::Text
+  extend ::Pry::Helpers::Text
+
+  # source://pry//lib/pry/helpers/text.rb#23
+  def black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def black_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def black_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def black_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def black_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def black_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def black_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def black_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def black_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def black_on_yellow(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#23
+  def blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def blue_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def blue_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def blue_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def blue_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def blue_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def blue_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def blue_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def blue_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def blue_on_yellow(text); end
+
+  # Returns _text_ as bold text for use on a terminal.
+  #
+  # @param text [String, #to_s]
+  # @return [String] _text_
+  #
+  # source://pry//lib/pry/helpers/text.rb#54
+  def bold(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#27
+  def bright_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_black_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_black_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_black_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_black_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_black_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_black_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_black_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_black_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_black_on_yellow(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#27
+  def bright_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_blue_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_blue_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_blue_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_blue_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_blue_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_blue_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_blue_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_blue_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_blue_on_yellow(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#27
+  def bright_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_cyan_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_cyan_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_cyan_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_cyan_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_cyan_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_cyan_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_cyan_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_cyan_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_cyan_on_yellow(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#27
+  def bright_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_green_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_green_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_green_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_green_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_green_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_green_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_green_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_green_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_green_on_yellow(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#27
+  def bright_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_magenta_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_magenta_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_magenta_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_magenta_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_magenta_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_magenta_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_magenta_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_magenta_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_magenta_on_yellow(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#27
+  def bright_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_purple_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_purple_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_purple_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_purple_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_purple_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_purple_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_purple_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_purple_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_purple_on_yellow(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#27
+  def bright_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_red_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_red_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_red_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_red_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_red_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_red_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_red_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_red_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_red_on_yellow(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#27
+  def bright_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_white_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_white_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_white_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_white_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_white_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_white_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_white_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_white_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_white_on_yellow(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#27
+  def bright_yellow(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_yellow_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_yellow_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_yellow_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_yellow_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_yellow_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_yellow_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_yellow_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_yellow_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#36
+  def bright_yellow_on_yellow(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#23
+  def cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def cyan_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def cyan_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def cyan_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def cyan_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def cyan_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def cyan_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def cyan_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def cyan_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def cyan_on_yellow(text); end
+
+  # Returns `text` in the default foreground colour.
+  # Use this instead of "black" or "white" when you mean absence of colour.
+  #
+  # @param text [String, #to_s]
+  # @return [String]
+  #
+  # source://pry//lib/pry/helpers/text.rb#63
+  def default(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#23
+  def green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def green_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def green_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def green_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def green_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def green_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def green_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def green_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def green_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def green_on_yellow(text); end
+
+  # Returns _text_ indented by _chars_ spaces.
+  #
+  # @param text [String]
+  # @param chars [Fixnum]
+  #
+  # source://pry//lib/pry/helpers/text.rb#113
+  def indent(text, chars); end
+
+  # source://pry//lib/pry/helpers/text.rb#23
+  def magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def magenta_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def magenta_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def magenta_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def magenta_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def magenta_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def magenta_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def magenta_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def magenta_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def magenta_on_yellow(text); end
+
+  # @return [void]
+  # @yield Yields a block with color turned off.
+  #
+  # source://pry//lib/pry/helpers/text.rb#73
+  def no_color; end
+
+  # @return [void]
+  # @yield Yields a block with paging turned off.
+  #
+  # source://pry//lib/pry/helpers/text.rb#87
+  def no_pager; end
+
+  # source://pry//lib/pry/helpers/text.rb#23
+  def purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def purple_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def purple_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def purple_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def purple_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def purple_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def purple_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def purple_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def purple_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def purple_on_yellow(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#23
+  def red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def red_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def red_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def red_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def red_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def red_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def red_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def red_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def red_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def red_on_yellow(text); end
+
+  # Remove any color codes from _text_.
+  #
+  # @param text [String, #to_s]
+  # @return [String] _text_ stripped of any color codes.
+  #
+  # source://pry//lib/pry/helpers/text.rb#46
+  def strip_color(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#23
+  def white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def white_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def white_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def white_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def white_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def white_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def white_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def white_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def white_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def white_on_yellow(text); end
+
+  # Returns _text_ in a numbered list, beginning at _offset_.
+  #
+  # @param text [#each_line]
+  # @param offset [Fixnum]
+  # @return [String]
+  #
+  # source://pry//lib/pry/helpers/text.rb#100
+  def with_line_numbers(text, offset, color = T.unsafe(nil)); end
+
+  # source://pry//lib/pry/helpers/text.rb#23
+  def yellow(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def yellow_on_black(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def yellow_on_blue(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def yellow_on_cyan(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def yellow_on_green(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def yellow_on_magenta(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def yellow_on_purple(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def yellow_on_red(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def yellow_on_white(text); end
+
+  # source://pry//lib/pry/helpers/text.rb#32
+  def yellow_on_yellow(text); end
+end
+
+# source://pry//lib/pry/helpers/text.rb#10
+Pry::Helpers::Text::COLORS = T.let(T.unsafe(nil), Hash)
+
+# The History class is responsible for maintaining the user's input history,
+# both internally and within Readline.
+#
+# source://pry//lib/pry/history.rb#6
+class Pry::History
+  # @return [History] a new instance of History
+  #
+  # source://pry//lib/pry/history.rb#29
+  def initialize(options = T.unsafe(nil)); end
+
+  # Add a line to the input history, ignoring blank and duplicate lines.
+  #
+  # @param line [String]
+  # @return [String] The same line that was passed in
+  #
+  # source://pry//lib/pry/history.rb#53
+  def <<(line); end
+
+  # Clear this session's history. This won't affect the contents of the
+  # history file.
+  #
+  # source://pry//lib/pry/history.rb#74
+  def clear; end
+
+  # Filter the history with the histignore options
+  #
+  # @return [Array<String>] An array containing all the lines that are not
+  #   included in the histignore.
+  #
+  # source://pry//lib/pry/history.rb#95
+  def filter(history); end
+
+  # @return [Integer] total number of lines, including original lines
+  #
+  # source://pry//lib/pry/history.rb#27
+  def history_line_count; end
+
+  # Load the input history using `History.loader`.
+  #
+  # @return [Integer] The number of lines loaded
+  #
+  # source://pry//lib/pry/history.rb#40
+  def load; end
+
+  # Returns the value of attribute loader.
+  #
+  # source://pry//lib/pry/history.rb#21
+  def loader; end
+
+  # Sets the attribute loader
+  #
+  # @param value the value to set the attribute loader to.
+  #
+  # source://pry//lib/pry/history.rb#21
+  def loader=(_arg0); end
+
+  # @return [Fixnum] Number of lines in history when Pry first loaded.
+  #
+  # source://pry//lib/pry/history.rb#24
+  def original_lines; end
+
+  # Add a line to the input history, ignoring blank and duplicate lines.
+  #
+  # @param line [String]
+  # @return [String] The same line that was passed in
+  #
+  # source://pry//lib/pry/history.rb#53
+  def push(line); end
+
+  # Returns the value of attribute saver.
+  #
+  # source://pry//lib/pry/history.rb#21
+  def saver; end
+
+  # Sets the attribute saver
+  #
+  # @param value the value to set the attribute saver to.
+  #
+  # source://pry//lib/pry/history.rb#21
+  def saver=(_arg0); end
+
+  # @return [Fixnum] The number of lines in history from just this session.
+  #
+  # source://pry//lib/pry/history.rb#81
+  def session_line_count; end
+
+  # Return an Array containing all stored history.
+  #
+  # @return [Array<String>] An Array containing all lines of history loaded
+  #   or entered by the user in the current session.
+  #
+  # source://pry//lib/pry/history.rb#88
+  def to_a; end
+
+  private
+
+  # The history file, opened for appending.
+  #
+  # source://pry//lib/pry/history.rb#127
+  def history_file; end
+
+  # source://pry//lib/pry/history.rb#143
+  def history_file_path; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/history.rb#147
+  def invalid_readline_line?(line); end
+
+  # The default loader. Yields lines from `Pry.config.history_file`.
+  #
+  # source://pry//lib/pry/history.rb#113
+  def read_from_file; end
+
+  # The default saver. Appends the given line to `Pry.config.history_file`.
+  #
+  # source://pry//lib/pry/history.rb#122
+  def save_to_file(line); end
+
+  # Check if the line match any option in the histignore
+  # [Pry.config.history_ignorelist]
+  #
+  # @return [Boolean] a boolean that notifies if the line was found in the
+  #   histignore array.
+  #
+  # source://pry//lib/pry/history.rb#105
+  def should_ignore?(line); end
+
+  class << self
+    # source://pry//lib/pry/history.rb#7
+    def default_file; end
+  end
+end
+
+# Implements a hooks system for Pry. A hook is a callable that is associated
+# with an event. A number of events are currently provided by Pry, these
+# include: `:when_started`, `:before_session`, `:after_session`.  A hook must
+# have a name, and is connected with an event by the `Pry::Hooks#add_hook`
+# method.
+#
+# @example Adding a hook for the `:before_session` event.
+#   Pry.config.hooks.add_hook(:before_session, :say_hi) do
+#   puts "hello"
+#   end
+#
+# source://pry//lib/pry/hooks.rb#14
+class Pry::Hooks
+  # @return [Hooks] a new instance of Hooks
+  #
+  # source://pry//lib/pry/hooks.rb#25
+  def initialize; end
+
+  # Add a new hook to be executed for the `event_name` event.
+  #
+  # @param event_name [Symbol] The name of the event.
+  # @param hook_name [Symbol] The name of the hook.
+  # @param callable [#call] The callable.
+  # @raise [ArgumentError]
+  # @return [Pry:Hooks] The receiver.
+  # @yield The block to use as the callable (if no `callable` provided).
+  #
+  # source://pry//lib/pry/hooks.rb#81
+  def add_hook(event_name, hook_name, callable = T.unsafe(nil), &block); end
+
+  # Clear all hooks functions for a given event.
+  #
+  # @param event_name [String] The name of the event.
+  # @return [void]
+  #
+  # source://pry//lib/pry/hooks.rb#165
+  def clear_event_hooks(event_name); end
+
+  # @param event_name [Symbol] The name of the event.
+  # @param hook_name [Symbol] The name of the hook.
+  #   to delete.
+  # @return [#call] The deleted hook.
+  #
+  # source://pry//lib/pry/hooks.rb#147
+  def delete_hook(event_name, hook_name); end
+
+  # source://pry//lib/pry/hooks.rb#39
+  def errors; end
+
+  # Execute the list of hooks for the `event_name` event.
+  #
+  # @param event_name [Symbol] The name of the event.
+  # @param args [Array] The arguments to pass to each hook function.
+  # @return [Object] The return value of the last executed hook.
+  #
+  # source://pry//lib/pry/hooks.rb#108
+  def exec_hook(event_name, *args, &block); end
+
+  # @param event_name [Symbol] The name of the event.
+  # @param hook_name [Symbol] The name of the hook
+  # @return [#call] a specific hook for a given event.
+  #
+  # source://pry//lib/pry/hooks.rb#128
+  def get_hook(event_name, hook_name); end
+
+  # `add_hook`/`delete_hook` for that.
+  #
+  # @note Modifying the returned hash does not alter the hooks, use
+  # @param event_name [Symbol] The name of the event.
+  # @return [Hash] The hash of hook names / hook functions.
+  #
+  # source://pry//lib/pry/hooks.rb#139
+  def get_hooks(event_name); end
+
+  # @param event_name [Symbol] The name of the event.
+  # @return [Fixnum] The number of hook functions for `event_name`.
+  #
+  # source://pry//lib/pry/hooks.rb#121
+  def hook_count(event_name); end
+
+  # @param event_name [Symbol] Name of the event.
+  # @param hook_name [Symbol] Name of the hook.
+  # @return [Boolean] Whether the hook by the name `hook_name`.
+  #
+  # source://pry//lib/pry/hooks.rb#172
+  def hook_exists?(event_name, hook_name); end
+
+  # @example
+  #   hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
+  #   Pry::Hooks.new.merge(hooks)
+  # @param other [Pry::Hooks] The `Pry::Hooks` instance to merge
+  # @return [Pry::Hooks] a new `Pry::Hooks` instance containing a merge of the
+  #   contents of two `Pry:Hooks` instances.
+  #
+  # source://pry//lib/pry/hooks.rb#69
+  def merge(other); end
+
+  # Destructively merge the contents of two `Pry:Hooks` instances.
+  #
+  # @param other [Pry::Hooks] The `Pry::Hooks` instance to merge
+  # @return [Pry:Hooks] The receiver.
+  # @see #merge
+  #
+  # source://pry//lib/pry/hooks.rb#48
+  def merge!(other); end
+
+  protected
+
+  # Returns the value of attribute hooks.
+  #
+  # source://pry//lib/pry/hooks.rb#178
+  def hooks; end
+
+  private
+
+  # Ensure that duplicates have their @hooks object.
+  #
+  # source://pry//lib/pry/hooks.rb#30
+  def initialize_copy(_orig); end
+
+  class << self
+    # source://pry//lib/pry/hooks.rb#15
+    def default; end
+  end
+end
+
+# Pry::Indent is a class that can be used to indent a number of lines
+# containing Ruby code similar as to how IRB does it (but better). The class
+# works by tokenizing a string using CodeRay and then looping over those
+# tokens. Based on the tokens in a line of code that line (or the next one)
+# will be indented or un-indented by correctly.
+#
+# source://pry//lib/pry/indent.rb#11
+class Pry::Indent
+  include ::Pry::Helpers::BaseHelpers
+
+  # @return [Indent] a new instance of Indent
+  #
+  # source://pry//lib/pry/indent.rb#104
+  def initialize(pry_instance = T.unsafe(nil)); end
+
+  # Return a string which, when printed, will rewrite the previous line with
+  # the correct indentation. Mostly useful for fixing 'end'.
+  #
+  # @param prompt [String] The user's prompt
+  # @param code [String] The code the user just typed in
+  # @param overhang [Integer] The number of characters to erase afterwards (the
+  #   the difference in length between the old line and the new one)
+  # @return [String] correctly indented line
+  #
+  # source://pry//lib/pry/indent.rb#393
+  def correct_indentation(prompt, code, overhang = T.unsafe(nil)); end
+
+  # Get the indentation for the start of the next line.
+  #
+  # This is what's used between the prompt and the cursor in pry.
+  #
+  # @return String  The correct number of spaces
+  #
+  # source://pry//lib/pry/indent.rb#181
+  def current_prefix; end
+
+  # If the code just before an "if" or "while" token on a line looks like the
+  # end of a statement, then we want to treat that "if" as a singleline, not
+  # multiline statement.
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/indent.rb#264
+  def end_of_statement?(last_token, last_kind); end
+
+  # Are we currently in the middle of a string literal.
+  #
+  # This is used to determine whether to re-indent a given line, we mustn't
+  # re-indent within string literals because to do so would actually change
+  # the value of the String!
+  #
+  # @return [Boolean] Boolean
+  #
+  # source://pry//lib/pry/indent.rb#275
+  def in_string?; end
+
+  # Indents a string and returns it. This string can either be a single line
+  # or multiple ones.
+  #
+  # @example
+  #   str = <<TXT
+  #   class User
+  #   attr_accessor :name
+  #   end
+  #   TXT
+  #
+  #   # This would result in the following being displayed:
+  #   #
+  #   # class User
+  #   #   attr_accessor :name
+  #   # end
+  #   #
+  #   puts Pry::Indent.new.indent(str)
+  # @param input [String] The input string to indent.
+  # @return [String] The indented version of +input+.
+  #
+  # source://pry//lib/pry/indent.rb#142
+  def indent(input); end
+
+  # @return [String] String containing the spaces to be inserted before the next line.
+  #
+  # source://pry//lib/pry/indent.rb#18
+  def indent_level; end
+
+  # Get the change in indentation indicated by the line.
+  #
+  # By convention, you remove indent from the line containing end tokens,
+  # but add indent to the line *after* that which contains the start tokens.
+  #
+  # This method returns a pair, where the first number is the number of closings
+  # on this line (i.e. the number of indents to remove before the line) and the
+  # second is the number of openings (i.e. the number of indents to add after
+  # this line)
+  #
+  # @param tokens [Array] A list of tokens to scan.
+  # @return [Array[Integer]]
+  #
+  # source://pry//lib/pry/indent.rb#198
+  def indentation_delta(tokens); end
+
+  # Return a list of strings which can be used to re-construct the Module.nesting at
+  # the current point in the file.
+  #
+  # Returns nil if the syntax of the file was not recognizable.
+  #
+  # @return [Array<String>]
+  #
+  # source://pry//lib/pry/indent.rb#376
+  def module_nesting; end
+
+  # All the open delimiters, in the order that they first appeared.
+  #
+  # @return [String]
+  #
+  # source://pry//lib/pry/indent.rb#312
+  def open_delimiters; end
+
+  # Return a string which restores the CodeRay string status to the correct value by
+  # opening HEREDOCs and strings.
+  #
+  # @return String
+  #
+  # source://pry//lib/pry/indent.rb#320
+  def open_delimiters_line; end
+
+  # reset internal state
+  #
+  # source://pry//lib/pry/indent.rb#110
+  def reset; end
+
+  # @return [Array<String>] The stack of open tokens.
+  #
+  # source://pry//lib/pry/indent.rb#21
+  def stack; end
+
+  # Given a string of Ruby code, use CodeRay to export the tokens.
+  #
+  # @param string [String] The Ruby to lex
+  # @return [Array] An Array of pairs of [token_value, token_type]
+  #
+  # source://pry//lib/pry/indent.rb#283
+  def tokenize(string); end
+
+  # Update the internal state about what kind of strings are open.
+  #
+  # Most of the complication here comes from the fact that HEREDOCs can be
+  # nested. For normal strings (which can't be nested) we assume that CodeRay
+  # correctly pairs open-and-close delimiters so we don't bother checking what
+  # they are.
+  #
+  # @param token [String] The token (of type :delimiter)
+  #
+  # source://pry//lib/pry/indent.rb#297
+  def track_delimiter(token); end
+
+  # Update the internal state relating to module nesting.
+  #
+  # It's responsible for adding to the @module_nesting array, which looks
+  # something like:
+  #
+  # [ ["class", "Foo"], ["module", "Bar::Baz"], ["class <<", "self"] ]
+  #
+  # A nil value in the @module_nesting array happens in two places: either
+  # when @awaiting_class is true and we're still waiting for the string to
+  # fill that space, or when a parse was rejected.
+  #
+  # At the moment this function is quite restricted about what formats it will
+  # parse, for example we disallow expressions after the class keyword. This
+  # could maybe be improved in the future.
+  #
+  # @param token [String] a token from Coderay
+  # @param kind [Symbol] the kind of that token
+  #
+  # source://pry//lib/pry/indent.rb#341
+  def track_module_nesting(token, kind); end
+
+  # Update the internal state relating to module nesting on 'end'.
+  #
+  # If the current 'end' pairs up with a class or a module then we should
+  # pop an array off of @module_nesting
+  #
+  # @param token [String] a token from Coderay
+  # @param kind [Symbol] the kind of that token
+  #
+  # source://pry//lib/pry/indent.rb#366
+  def track_module_nesting_end(token, kind = T.unsafe(nil)); end
+
+  class << self
+    # Clean the indentation of a fragment of ruby.
+    #
+    # @param str [String]
+    # @return [String]
+    #
+    # source://pry//lib/pry/indent.rb#82
+    def indent(str); end
+
+    # Get the module nesting at the given point in the given string.
+    #
+    # NOTE If the line specified contains a method definition, then the nesting
+    # at the start of the method definition is used. Otherwise the nesting from
+    # the end of the line is used.
+    #
+    # @param str [String] The ruby code to analyze
+    # @param line_number [Fixnum] The line number (starting from 1)
+    # @return [Array<String>]
+    #
+    # source://pry//lib/pry/indent.rb#95
+    def nesting_at(str, line_number); end
+  end
+end
+
+# Collection of token types that should be ignored. Without this list
+# keywords such as "class" inside strings would cause the code to be
+# indented incorrectly.
+#
+# :pre_constant and :preserved_constant are the CodeRay 0.9.8 and 1.0.0
+# classifications of "true", "false", and "nil".
+#
+# source://pry//lib/pry/indent.rb#60
+Pry::Indent::IGNORE_TOKENS = T.let(T.unsafe(nil), Array)
+
+# Collection of tokens that should appear dedented even though they
+# don't affect the surrounding code.
+#
+# source://pry//lib/pry/indent.rb#76
+Pry::Indent::MIDWAY_TOKENS = T.let(T.unsafe(nil), Array)
+
+# Hash containing all the tokens that should increase the indentation
+# level. The keys of this hash are open tokens, the values the matching
+# tokens that should prevent a line from being indented if they appear on
+# the same line.
+#
+# source://pry//lib/pry/indent.rb#30
+Pry::Indent::OPEN_TOKENS = T.let(T.unsafe(nil), Hash)
+
+# Which tokens can be followed by an optional "do" keyword.
+#
+# source://pry//lib/pry/indent.rb#52
+Pry::Indent::OPTIONAL_DO_TOKENS = T.let(T.unsafe(nil), Array)
+
+# Which tokens can either be open tokens, or appear as modifiers on
+# a single-line.
+#
+# source://pry//lib/pry/indent.rb#49
+Pry::Indent::SINGLELINE_TOKENS = T.let(T.unsafe(nil), Array)
+
+# The amount of spaces to insert for each indent level.
+#
+# source://pry//lib/pry/indent.rb#24
+Pry::Indent::SPACES = T.let(T.unsafe(nil), String)
+
+# Tokens that indicate the end of a statement (i.e. that, if they appear
+# directly before an "if" indicates that that if applies to the same line,
+# not the next line)
+#
+# :reserved and :keywords are the CodeRay 0.9.8 and 1.0.0 respectively
+# classifications of "super", "next", "return", etc.
+#
+# source://pry//lib/pry/indent.rb#69
+Pry::Indent::STATEMENT_END_TOKENS = T.let(T.unsafe(nil), Array)
+
+# Raised if {#module_nesting} would not work.
+#
+# source://pry//lib/pry/indent.rb#15
+class Pry::Indent::UnparseableNestingError < ::StandardError; end
+
+# source://pry//lib/pry/input_completer.rb#6
+class Pry::InputCompleter
+  # @return [InputCompleter] a new instance of InputCompleter
+  #
+  # source://pry//lib/pry/input_completer.rb#42
+  def initialize(input, pry = T.unsafe(nil)); end
+
+  # build_path seperates the input into two parts: path and input.
+  # input is the partial string that should be completed
+  # path is a proc that takes an input and builds a full path.
+  #
+  # source://pry//lib/pry/input_completer.rb#240
+  def build_path(input); end
+
+  # Return a new completion proc for use by Readline.
+  #
+  # source://pry//lib/pry/input_completer.rb#56
+  def call(str, options = T.unsafe(nil)); end
+
+  # source://pry//lib/pry/input_completer.rb#255
+  def ignored_modules; end
+
+  # source://pry//lib/pry/input_completer.rb#229
+  def select_message(path, receiver, message, candidates); end
+end
+
+# source://pry//lib/pry/input_completer.rb#8
+Pry::InputCompleter::ARRAY_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://pry//lib/pry/input_completer.rb#15
+Pry::InputCompleter::CONSTANT_OR_METHOD_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://pry//lib/pry/input_completer.rb#14
+Pry::InputCompleter::CONSTANT_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://pry//lib/pry/input_completer.rb#17
+Pry::InputCompleter::GLOBALVARIABLE_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://pry//lib/pry/input_completer.rb#16
+Pry::InputCompleter::HEX_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://pry//lib/pry/input_completer.rb#7
+Pry::InputCompleter::NUMERIC_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://pry//lib/pry/input_completer.rb#12
+Pry::InputCompleter::PROC_OR_HASH_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://pry//lib/pry/input_completer.rb#11
+Pry::InputCompleter::REGEX_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://pry//lib/pry/input_completer.rb#20
+Pry::InputCompleter::RESERVED_WORDS = T.let(T.unsafe(nil), Array)
+
+# source://pry//lib/pry/input_completer.rb#10
+Pry::InputCompleter::SYMBOL_METHOD_CALL_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://pry//lib/pry/input_completer.rb#9
+Pry::InputCompleter::SYMBOL_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://pry//lib/pry/input_completer.rb#13
+Pry::InputCompleter::TOPLEVEL_LOOKUP_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://pry//lib/pry/input_completer.rb#18
+Pry::InputCompleter::VARIABLE_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://pry//lib/pry/input_completer.rb#40
+Pry::InputCompleter::WORD_ESCAPE_STR = T.let(T.unsafe(nil), String)
+
+# There is one InputLock per input (such as STDIN) as two REPLs on the same
+# input makes things delirious. InputLock serializes accesses to the input so
+# that threads to not conflict with each other. The latest thread to request
+# ownership of the input wins.
+#
+# source://pry//lib/pry/input_lock.rb#8
+class Pry::InputLock
+  # @return [InputLock] a new instance of InputLock
+  #
+  # source://pry//lib/pry/input_lock.rb#29
+  def initialize; end
+
+  # Adds ourselves to the ownership list. The last one in the list may access
+  # the input through interruptible_region().
+  #
+  # source://pry//lib/pry/input_lock.rb#38
+  def __with_ownership; end
+
+  # source://pry//lib/pry/input_lock.rb#81
+  def enter_interruptible_region; end
+
+  # source://pry//lib/pry/input_lock.rb#108
+  def interruptible_region; end
+
+  # source://pry//lib/pry/input_lock.rb#95
+  def leave_interruptible_region; end
+
+  # source://pry//lib/pry/input_lock.rb#75
+  def with_ownership(&block); end
+
+  class << self
+    # source://pry//lib/pry/input_lock.rb#19
+    def for(input); end
+
+    # Returns the value of attribute global_lock.
+    #
+    # source://pry//lib/pry/input_lock.rb#13
+    def global_lock; end
+
+    # Sets the attribute global_lock
+    #
+    # @param value the value to set the attribute global_lock to.
+    #
+    # source://pry//lib/pry/input_lock.rb#13
+    def global_lock=(_arg0); end
+
+    # Returns the value of attribute input_locks.
+    #
+    # source://pry//lib/pry/input_lock.rb#12
+    def input_locks; end
+
+    # Sets the attribute input_locks
+    #
+    # @param value the value to set the attribute input_locks to.
+    #
+    # source://pry//lib/pry/input_lock.rb#12
+    def input_locks=(_arg0); end
+  end
+end
+
+# source://pry//lib/pry/input_lock.rb#9
+class Pry::InputLock::Interrupt < ::Exception; end
+
+# source://pry//lib/pry/inspector.rb#4
+class Pry::Inspector; end
+
+# source://pry//lib/pry/inspector.rb#5
+Pry::Inspector::MAP = T.let(T.unsafe(nil), Hash)
+
+# source://pry//lib/pry/pry_class.rb#7
+Pry::LOCAL_RC_FILE = T.let(T.unsafe(nil), String)
+
+# source://pry//lib/pry/last_exception.rb#12
+class Pry::LastException < ::BasicObject
+  # @return [LastException] a new instance of LastException
+  #
+  # source://pry//lib/pry/last_exception.rb#15
+  def initialize(exception); end
+
+  # Returns the value of attribute bt_index.
+  #
+  # source://pry//lib/pry/last_exception.rb#13
+  def bt_index; end
+
+  # Sets the attribute bt_index
+  #
+  # @param value the value to set the attribute bt_index to.
+  #
+  # source://pry//lib/pry/last_exception.rb#13
+  def bt_index=(_arg0); end
+
+  # source://pry//lib/pry/last_exception.rb#52
+  def bt_source_location_for(index); end
+
+  # @return [String] returns the path to a file for the current backtrace. see {#bt_index}.
+  #
+  # source://pry//lib/pry/last_exception.rb#37
+  def file; end
+
+  # source://pry//lib/pry/last_exception.rb#57
+  def inc_bt_index; end
+
+  # @return [Fixnum] returns the line for the current backtrace. see {#bt_index}.
+  #
+  # source://pry//lib/pry/last_exception.rb#43
+  def line; end
+
+  # source://pry//lib/pry/last_exception.rb#21
+  def method_missing(name, *args, &block); end
+
+  # @return [Exception] returns the wrapped exception
+  #
+  # source://pry//lib/pry/last_exception.rb#48
+  def wrapped_exception; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/last_exception.rb#29
+  def respond_to_missing?(name, include_all = T.unsafe(nil)); end
+end
+
+# This class wraps the normal `Method` and `UnboundMethod` classes
+# to provide extra functionality useful to Pry.
+#
+# source://pry//lib/pry/method.rb#20
+class Pry::Method
+  include ::Pry::Helpers::BaseHelpers
+  include ::Pry::Helpers::DocumentationHelpers
+  include ::Pry::CodeObject::Helpers
+  extend ::Pry::Helpers::BaseHelpers
+  extend ::Forwardable
+  extend ::Pry::Forwardable
+
+  # A new instance of `Pry::Method` wrapping the given `::Method`,
+  # `UnboundMethod`, or `Proc`.
+  #
+  # @param method [::Method, UnboundMethod, Proc]
+  # @param known_info [Hash] Can be used to pre-cache expensive to compute stuff.
+  # @return [Pry::Method]
+  #
+  # source://pry//lib/pry/method.rb#263
+  def initialize(method, known_info = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/method.rb#483
+  def ==(other); end
+
+  # @return [Boolean] Is the method definitely an alias?
+  #
+  # source://pry//lib/pry/method.rb#478
+  def alias?; end
+
+  # @return [Array<String>] All known aliases for the method.
+  #
+  # source://pry//lib/pry/method.rb#461
+  def aliases; end
+
+  # @return [Boolean] Whether the method is bound.
+  #
+  # source://pry//lib/pry/method.rb#446
+  def bound_method?; end
+
+  # source://pry//lib/pry/method.rb#515
+  def comment; end
+
+  # @return [String, nil] The documentation for the method, or `nil` if it's
+  #   unavailable.
+  #
+  # source://pry//lib/pry/method.rb#329
+  def doc; end
+
+  # @return [Boolean] Was the method defined outside a source file?
+  #
+  # source://pry//lib/pry/method.rb#436
+  def dynamically_defined?; end
+
+  # @param klass [Class]
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/method.rb#491
+  def is_a?(klass); end
+
+  # @param klass [Class]
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/method.rb#491
+  def kind_of?(klass); end
+
+  # Delegate any unknown calls to the wrapped method.
+  #
+  # source://pry//lib/pry/method.rb#503
+  def method_missing(method_name, *args, &block); end
+
+  # Get the name of the method as a String, regardless of the underlying
+  # Method#name type.
+  #
+  # @return [String]
+  #
+  # source://pry//lib/pry/method.rb#272
+  def name; end
+
+  # Get the name of the method including the class on which it was defined.
+  #
+  # @example
+  #   method(:puts).method_name
+  #   => "Kernel.puts"
+  # @return [String]
+  #
+  # source://pry//lib/pry/method.rb#299
+  def name_with_owner; end
+
+  # @return [String, nil] The original name the method was defined under,
+  #   before any aliasing, or `nil` if it can't be determined.
+  #
+  # source://pry//lib/pry/method.rb#429
+  def original_name; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def owner(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def parameters(*args, **_arg1, &block); end
+
+  # @return [Boolean] Was the method defined within the Pry REPL?
+  #
+  # source://pry//lib/pry/method.rb#456
+  def pry_method?; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def receiver(*args, **_arg1, &block); end
+
+  # Update the live copy of the method's source.
+  #
+  # source://pry//lib/pry/method.rb#314
+  def redefine(source); end
+
+  # @param method_name [String, Symbol]
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/method.rb#498
+  def respond_to?(method_name, include_all = T.unsafe(nil)); end
+
+  # @return [String] A representation of the method's signature, including its
+  #   name and parameters. Optional and "rest" parameters are marked with `*`
+  #   and block parameters with `&`. Keyword arguments are shown with `:`
+  #   If the parameter names are unavailable, they're given numbered names instead.
+  #   Paraphrased from `awesome_print` gem.
+  #
+  # source://pry//lib/pry/method.rb#391
+  def signature; end
+
+  # @return [Boolean] Whether the method is a singleton method.
+  #
+  # source://pry//lib/pry/method.rb#451
+  def singleton_method?; end
+
+  # @return [String, nil] The source code of the method, or `nil` if it's unavailable.
+  #
+  # source://pry//lib/pry/method.rb#304
+  def source; end
+
+  # Can we get the source code for this method?
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/method.rb#321
+  def source?; end
+
+  # @return [String, nil] The name of the file the method is defined in, or
+  #   `nil` if the filename is unavailable.
+  #
+  # source://pry//lib/pry/method.rb#348
+  def source_file; end
+
+  # @return [Fixnum, nil] The line of code in `source_file` which begins
+  #   the method's definition, or `nil` if that information is unavailable.
+  #
+  # source://pry//lib/pry/method.rb#361
+  def source_line; end
+
+  # @return [Range, nil] The range of lines in `source_file` which contain
+  #   the method's definition, or `nil` if that information is unavailable.
+  #
+  # source://pry//lib/pry/method.rb#367
+  def source_range; end
+
+  # @return [Symbol] The source type of the method. The options are
+  #   `:ruby` for Ruby methods or `:c` for methods written in C.
+  #
+  # source://pry//lib/pry/method.rb#342
+  def source_type; end
+
+  # @return [Pry::Method, nil] The wrapped method that is called when you
+  #   use "super" in the body of this method.
+  #
+  # source://pry//lib/pry/method.rb#417
+  def super(times = T.unsafe(nil)); end
+
+  # @return [Boolean] Whether the method is unbound.
+  #
+  # source://pry//lib/pry/method.rb#441
+  def unbound_method?; end
+
+  # Is the method undefined? (aka `Disowned`)
+  #
+  # @return [Boolean] false
+  #
+  # source://pry//lib/pry/method.rb#290
+  def undefined?; end
+
+  # @return [Symbol] The visibility of the method. May be `:public`,
+  #   `:protected`, or `:private`.
+  #
+  # source://pry//lib/pry/method.rb#373
+  def visibility; end
+
+  # Get underlying object wrapped by this Pry::Method instance
+  #
+  # @return [Method, UnboundMethod, Proc]
+  #
+  # source://pry//lib/pry/method.rb#284
+  def wrapped; end
+
+  # Get the owner of the method as a Pry::Module
+  #
+  # @return [Pry::Module]
+  #
+  # source://pry//lib/pry/method.rb#278
+  def wrapped_owner; end
+
+  private
+
+  # source://pry//lib/pry/method.rb#578
+  def c_source; end
+
+  # @param first_ln [String] The first line of a method definition.
+  # @return [String, nil]
+  #
+  # source://pry//lib/pry/method.rb#564
+  def method_name_from_first_line(first_ln); end
+
+  # @raise [CommandError] when the method can't be found or `pry-doc` isn't installed.
+  # @return [YARD::CodeObjects::MethodObject]
+  #
+  # source://pry//lib/pry/method.rb#523
+  def pry_doc_info; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/method.rb#511
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+
+  # source://pry//lib/pry/method.rb#583
+  def ruby_source; end
+
+  # @param ancestors [Class, Module] The ancestors to investigate
+  # @return [Method] The unwrapped super-method
+  #
+  # source://pry//lib/pry/method.rb#543
+  def super_using_ancestors(ancestors, times = T.unsafe(nil)); end
+
+  class << self
+    # Get all of the instance methods of a `Class` or `Module`
+    #
+    # @param klass [Class, Module]
+    # @param include_super [Boolean] Whether to include methods from ancestors.
+    # @return [Array[Pry::Method]]
+    #
+    # source://pry//lib/pry/method.rb#161
+    def all_from_class(klass, include_super = T.unsafe(nil)); end
+
+    # Get all of the methods on an `Object`
+    #
+    # @param obj [Object]
+    # @param include_super [Boolean] indicates whether or not to include methods from ancestors.
+    # @return [Array[Pry::Method]]
+    #
+    # source://pry//lib/pry/method.rb#184
+    def all_from_obj(obj, include_super = T.unsafe(nil)); end
+
+    # Given a `Binding`, try to extract the `::Method` it originated from and
+    # use it to instantiate a `Pry::Method`. Return `nil` if this isn't
+    # possible.
+    #
+    # @param binding [Binding]
+    # @return [Pry::Method, nil]
+    #
+    # source://pry//lib/pry/method.rb#77
+    def from_binding(binding); end
+
+    # Given a `Class` or `Module` and the name of a method, try to
+    # instantiate a `Pry::Method` containing the instance method of
+    # that name. Return `nil` if no such method exists.
+    #
+    # @param klass [Class, Module]
+    # @param name [String]
+    # @param target [Binding] The binding where the method is looked up.
+    # @return [Pry::Method, nil]
+    #
+    # source://pry//lib/pry/method.rb#136
+    def from_class(klass, name, target = T.unsafe(nil)); end
+
+    # Given a `Class` or `Module` and the name of a method, try to
+    # instantiate a `Pry::Method` containing the instance method of
+    # that name. Return `nil` if no such method exists.
+    #
+    # @param klass [Class, Module]
+    # @param name [String]
+    # @param target [Binding] The binding where the method is looked up.
+    # @return [Pry::Method, nil]
+    #
+    # source://pry//lib/pry/method.rb#136
+    def from_module(klass, name, target = T.unsafe(nil)); end
+
+    # Given an object and the name of a method, try to instantiate
+    # a `Pry::Method` containing the method of that name bound to
+    # that object. Return `nil` if no such method exists.
+    #
+    # @param obj [Object]
+    # @param name [String]
+    # @param target [Binding] The binding where the method is looked up.
+    # @return [Pry::Method, nil]
+    #
+    # source://pry//lib/pry/method.rb#151
+    def from_obj(obj, name, target = T.unsafe(nil)); end
+
+    # Given a string representing a method name and optionally a binding to
+    # search in, find and return the requested method wrapped in a
+    # `Pry::Method` instance.
+    #
+    # @option options
+    # @option options
+    # @param name [String] The name of the method to retrieve.
+    # @param target [Binding] The context in which to search for the method.
+    # @param options [Hash]
+    # @return [Pry::Method, nil] A `Pry::Method` instance containing the
+    #   requested method, or `nil` if name is `nil` or no method could be
+    #   located matching the parameters.
+    #
+    # source://pry//lib/pry/method.rb#43
+    def from_str(name, target = T.unsafe(nil), options = T.unsafe(nil)); end
+
+    # @return [Boolean]
+    #
+    # source://pry//lib/pry/method.rb#227
+    def instance_method_definition?(name, definition_line); end
+
+    # Get every `Class` and `Module`, in order, that will be checked when looking
+    # for methods on instances of the given `Class` or `Module`.
+    # This does not treat singleton classes of classes specially.
+    #
+    # @param klass [Class, Module]
+    # @return [Array[Class, Module]]
+    #
+    # source://pry//lib/pry/method.rb#210
+    def instance_resolution_order(klass); end
+
+    # In order to support 2.0 Refinements we need to look up methods
+    # inside the relevant Binding.
+    #
+    # @param obj [Object] The owner/receiver of the method.
+    # @param method_name [Symbol] The name of the method.
+    # @param method_type [Symbol] The type of method: :method or :instance_method
+    # @param target [Binding] The binding where the method is looked up.
+    # @return [Method, UnboundMethod] The 'refined' method object.
+    #
+    # source://pry//lib/pry/method.rb#114
+    def lookup_method_via_binding(obj, method_name, method_type, target = T.unsafe(nil)); end
+
+    # @return [Boolean]
+    #
+    # source://pry//lib/pry/method.rb#215
+    def method_definition?(name, definition_line); end
+
+    # Get every `Class` and `Module`, in order, that will be checked when looking
+    # for an instance method to call on this object.
+    #
+    # @param obj [Object]
+    # @return [Array[Class, Module]]
+    #
+    # source://pry//lib/pry/method.rb#192
+    def resolution_order(obj); end
+
+    # source://pry//lib/pry/method.rb#247
+    def singleton_class_of(obj); end
+
+    # Get the singleton classes of superclasses that could define methods on
+    # the given class object, and any modules they include.
+    # If a module is included at multiple points in the ancestry, only
+    # the lowest copy will be returned.
+    #
+    # source://pry//lib/pry/method.rb#238
+    def singleton_class_resolution_order(klass); end
+
+    # @return [Boolean]
+    #
+    # source://pry//lib/pry/method.rb#220
+    def singleton_method_definition?(name, definition_line); end
+  end
+end
+
+# A Disowned Method is one that's been removed from the class on which it was defined.
+#
+# e.g.
+# class C
+#   def foo
+#     C.send(:undefine_method, :foo)
+#     Pry::Method.from_binding(binding)
+#   end
+# end
+#
+# In this case we assume that the "owner" is the singleton class of the receiver.
+#
+# This occurs mainly in Sinatra applications.
+#
+# source://pry//lib/pry/method/disowned.rb#18
+class Pry::Method::Disowned < ::Pry::Method
+  # Create a new Disowned method.
+  #
+  # @param receiver [Object]
+  # @param method_name [String]
+  # @return [Disowned] a new instance of Disowned
+  #
+  # source://pry//lib/pry/method/disowned.rb#25
+  def initialize(receiver, method_name); end
+
+  # Raise a more useful error message instead of trying to forward to nil.
+  #
+  # source://pry//lib/pry/method/disowned.rb#52
+  def method_missing(method_name, *args, &block); end
+
+  # Returns the value of attribute name.
+  #
+  # source://pry//lib/pry/method/disowned.rb#19
+  def name; end
+
+  # Get the hypothesized owner of the method.
+  #
+  # @return [Object]
+  #
+  # source://pry//lib/pry/method/disowned.rb#46
+  def owner; end
+
+  # Returns the value of attribute receiver.
+  #
+  # source://pry//lib/pry/method/disowned.rb#19
+  def receiver; end
+
+  # Can we get the source for this method?
+  #
+  # @return [Boolean] false
+  #
+  # source://pry//lib/pry/method/disowned.rb#39
+  def source?; end
+
+  # Is the method undefined? (aka `Disowned`)
+  #
+  # @return [Boolean] true
+  #
+  # source://pry//lib/pry/method/disowned.rb#33
+  def undefined?; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/method/disowned.rb#62
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+end
+
+# source://pry//lib/pry/method/patcher.rb#5
+class Pry::Method::Patcher
+  # @return [Patcher] a new instance of Patcher
+  #
+  # source://pry//lib/pry/method/patcher.rb#12
+  def initialize(method); end
+
+  # Returns the value of attribute method.
+  #
+  # source://pry//lib/pry/method/patcher.rb#6
+  def method; end
+
+  # Sets the attribute method
+  #
+  # @param value the value to set the attribute method to.
+  #
+  # source://pry//lib/pry/method/patcher.rb#6
+  def method=(_arg0); end
+
+  # perform the patch
+  #
+  # source://pry//lib/pry/method/patcher.rb#21
+  def patch_in_ram(source); end
+
+  private
+
+  # source://pry//lib/pry/method/patcher.rb#38
+  def cache_key; end
+
+  # Update the definition line so that it can be eval'd directly on the Method's
+  # owner instead of from the original context.
+  #
+  # In particular this takes `def self.foo` and turns it into `def foo` so that we
+  # don't end up creating the method on the singleton class of the singleton class
+  # by accident.
+  #
+  # This is necessarily done by String manipulation because we can't find out what
+  # syntax is needed for the argument list by ruby-level introspection.
+  #
+  # @param line [String] The original definition line. e.g. def self.foo(bar, baz=1)
+  # @return [String] The new definition line. e.g. def foo(bar, baz=1)
+  #
+  # source://pry//lib/pry/method/patcher.rb#78
+  def definition_for_owner(line); end
+
+  # source://pry//lib/pry/method/patcher.rb#33
+  def redefine(source); end
+
+  # Run some code ensuring that at the end target#meth_name will not have changed.
+  #
+  # When we're redefining aliased methods we will overwrite the method at the
+  # unaliased name (so that super continues to work). By wrapping that code in a
+  # transation we make that not happen, which means that alias_method_chains, etc.
+  # continue to work.
+  #
+  # source://pry//lib/pry/method/patcher.rb#49
+  def with_method_transaction; end
+
+  # Apply wrap_for_owner and wrap_for_nesting successively to `source`
+  #
+  # @param source [String]
+  # @return [String] The wrapped source.
+  #
+  # source://pry//lib/pry/method/patcher.rb#91
+  def wrap(source); end
+
+  # Update the new source code to have the correct Module.nesting.
+  #
+  # This method uses syntactic analysis of the original source file to determine
+  # the new nesting, so that we can tell the difference between:
+  #
+  #   class A; def self.b; end; end
+  #   class << A; def b; end; end
+  #
+  # The resulting code should be evaluated in the TOPLEVEL_BINDING.
+  #
+  # @param source [String] The source to wrap.
+  # @return [String]
+  #
+  # source://pry//lib/pry/method/patcher.rb#122
+  def wrap_for_nesting(source); end
+
+  # Update the source code so that when it has the right owner when eval'd.
+  #
+  # This (combined with definition_for_owner) is backup for the case that
+  # wrap_for_nesting fails, to ensure that the method will stil be defined in
+  # the correct place.
+  #
+  # @param source [String] The source to wrap
+  # @return [String]
+  #
+  # source://pry//lib/pry/method/patcher.rb#103
+  def wrap_for_owner(source); end
+
+  class << self
+    # source://pry//lib/pry/method/patcher.rb#16
+    def code_for(filename); end
+  end
+end
+
+# This class is responsible for locating the *real* `Pry::Method`
+# object captured by a binding.
+#
+# Given a `Binding` from inside a method and a 'seed' Pry::Method object,
+# there are primarily two situations where the seed method doesn't match
+# the Binding:
+# 1. The Pry::Method is from a subclass
+# 2. The Pry::Method represents a method of the same name while the original
+# was renamed to something else. For 1. we search vertically up the
+# inheritance chain, and for 2. we search laterally along the object's
+# method table.
+#
+# When we locate the method that matches the Binding we wrap it in
+# Pry::Method and return it, or return nil if we fail.
+#
+# source://pry//lib/pry/method/weird_method_locator.rb#19
+class Pry::Method::WeirdMethodLocator
+  # @param method [Pry::Method] The seed method.
+  # @param target [Binding] The Binding that captures the method
+  #   we want to locate.
+  # @return [WeirdMethodLocator] a new instance of WeirdMethodLocator
+  #
+  # source://pry//lib/pry/method/weird_method_locator.rb#55
+  def initialize(method, target); end
+
+  # @return [Pry::Method, nil] The Pry::Method that matches the
+  #   given binding.
+  #
+  # source://pry//lib/pry/method/weird_method_locator.rb#62
+  def find_method; end
+
+  # @return [Boolean] Whether the Pry::Method is unrecoverable
+  #   This usually happens when the method captured by the Binding
+  #   has been subsequently deleted.
+  #
+  # source://pry//lib/pry/method/weird_method_locator.rb#69
+  def lost_method?; end
+
+  # Returns the value of attribute method.
+  #
+  # source://pry//lib/pry/method/weird_method_locator.rb#49
+  def method; end
+
+  # Sets the attribute method
+  #
+  # @param value the value to set the attribute method to.
+  #
+  # source://pry//lib/pry/method/weird_method_locator.rb#49
+  def method=(_arg0); end
+
+  # Returns the value of attribute target.
+  #
+  # source://pry//lib/pry/method/weird_method_locator.rb#50
+  def target; end
+
+  # Sets the attribute target
+  #
+  # @param value the value to set the attribute target to.
+  #
+  # source://pry//lib/pry/method/weird_method_locator.rb#50
+  def target=(_arg0); end
+
+  private
+
+  # source://pry//lib/pry/method/weird_method_locator.rb#215
+  def all_methods_for(obj); end
+
+  # source://pry//lib/pry/method/weird_method_locator.rb#167
+  def expanded_source_location(source_location); end
+
+  # it's possible in some cases that the method we find by this approach is
+  # a sub-method of the one we're currently in, consider:
+  #
+  # class A; def b; binding.pry; end; end
+  # class B < A; def b; super; end; end
+  #
+  # Given that we can normally find the source_range of methods, and that we
+  # know which __FILE__ and __LINE__ the binding is at, we can hope to
+  # disambiguate these cases.
+  #
+  # This obviously won't work if the source is unavaiable for some reason,
+  # or if both methods have the same __FILE__ and __LINE__.
+  #
+  # @return [Pry::Method, nil] The Pry::Method representing the
+  #   superclass method.
+  #
+  # source://pry//lib/pry/method/weird_method_locator.rb#131
+  def find_method_in_superclass; end
+
+  # This is the case where the name of a method has changed
+  # (via alias_method) so we locate the Method object for the
+  # renamed method.
+  #
+  # @return [Pry::Method, nil] The Pry::Method representing the
+  #   renamed method
+  #
+  # source://pry//lib/pry/method/weird_method_locator.rb#156
+  def find_renamed_method; end
+
+  # source://pry//lib/pry/method/weird_method_locator.rb#197
+  def index_to_line_number(index); end
+
+  # source://pry//lib/pry/method/weird_method_locator.rb#206
+  def lines_for_file(file); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/method/weird_method_locator.rb#80
+  def normal_method?(method); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/method/weird_method_locator.rb#106
+  def pry_file?; end
+
+  # Use static analysis to locate the start of the method definition.
+  # We have the `__FILE__` and `__LINE__` from the binding and the
+  # original name of the method so we search up until we find a
+  # def/define_method, etc defining a method of the appropriate name.
+  #
+  # @return [Array<String, Fixnum>] The `source_location` of the
+  #   renamed method
+  #
+  # source://pry//lib/pry/method/weird_method_locator.rb#184
+  def renamed_method_source_location; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/method/weird_method_locator.rb#75
+  def skip_superclass_search?; end
+
+  # source://pry//lib/pry/method/weird_method_locator.rb#88
+  def target_file; end
+
+  # source://pry//lib/pry/method/weird_method_locator.rb#98
+  def target_line; end
+
+  # source://pry//lib/pry/method/weird_method_locator.rb#84
+  def target_self; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/method/weird_method_locator.rb#202
+  def valid_file?(file); end
+
+  class << self
+    # Whether the given method object matches the associated binding.
+    # If the method object does not match the binding, then it's
+    # most likely not the method captured by the binding, and we
+    # must commence a search.
+    #
+    # @param method [Pry::Method]
+    # @param binding [Binding]
+    # @return [Boolean]
+    #
+    # source://pry//lib/pry/method/weird_method_locator.rb#29
+    def normal_method?(method, binding); end
+
+    # @return [Boolean]
+    #
+    # source://pry//lib/pry/method/weird_method_locator.rb#44
+    def weird_method?(method, binding); end
+  end
+end
+
+# source://pry//lib/pry/exceptions.rb#69
+class Pry::MethodNotFound < ::Pry::CommandError; end
+
+# source://pry//lib/pry/command_set.rb#4
+class Pry::NoCommandError < ::StandardError
+  # @return [NoCommandError] a new instance of NoCommandError
+  #
+  # source://pry//lib/pry/command_set.rb#5
+  def initialize(match, owner); end
+end
+
+# `ObjectPath` implements the resolution of "object paths", which are strings
+# that are similar to filesystem paths but meant for traversing Ruby objects.
+# Examples of valid object paths include:
+#
+#     x
+#     @foo/@bar
+#     "string"/upcase
+#     Pry/Method
+#
+# Object paths are mostly relevant in the context of the `cd` command.
+#
+# @see https://github.com/pry/pry/wiki/State-navigation
+#
+# source://pry//lib/pry/object_path.rb#17
+class Pry::ObjectPath
+  # @param path_string [String] The object path expressed as a string.
+  # @param current_stack [Array<Binding>] The current state of the binding
+  #   stack.
+  # @return [ObjectPath] a new instance of ObjectPath
+  #
+  # source://pry//lib/pry/object_path.rb#23
+  def initialize(path_string, current_stack); end
+
+  # @return [Array<Binding>] a new stack resulting from applying the given
+  #   path to the current stack.
+  #
+  # source://pry//lib/pry/object_path.rb#30
+  def resolve; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/object_path.rb#74
+  def complete?(segment); end
+
+  # source://pry//lib/pry/object_path.rb#78
+  def handle_failure(context, err); end
+end
+
+# source://pry//lib/pry/object_path.rb#18
+Pry::ObjectPath::SPECIAL_TERMS = T.let(T.unsafe(nil), Array)
+
+# indicates obsolete API
+#
+# source://pry//lib/pry/exceptions.rb#72
+class Pry::ObsoleteError < ::StandardError; end
+
+# source://pry//lib/pry/output.rb#4
+class Pry::Output
+  # @return [Output] a new instance of Output
+  #
+  # source://pry//lib/pry/output.rb#10
+  def initialize(pry_instance); end
+
+  # source://pry//lib/pry/output.rb#28
+  def <<(*objs); end
+
+  # source://pry//lib/pry/output.rb#53
+  def decolorize_maybe(str); end
+
+  # Return a screen height or the default if that fails.
+  #
+  # source://pry//lib/pry/output.rb#74
+  def height; end
+
+  # source://pry//lib/pry/output.rb#41
+  def method_missing(method_name, *args, &block); end
+
+  # source://pry//lib/pry/output.rb#28
+  def print(*objs); end
+
+  # Returns the value of attribute pry_instance.
+  #
+  # source://pry//lib/pry/output.rb#8
+  def pry_instance; end
+
+  # source://pry//lib/pry/output.rb#15
+  def puts(*objs); end
+
+  # @return [Array<Integer>] a pair of [rows, columns] which gives the size of
+  #   the window. If the window size cannot be determined, the default value.
+  #
+  # source://pry//lib/pry/output.rb#61
+  def size; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/output.rb#37
+  def tty?; end
+
+  # Return a screen width or the default if that fails.
+  #
+  # source://pry//lib/pry/output.rb#69
+  def width; end
+
+  # source://pry//lib/pry/output.rb#28
+  def write(*objs); end
+
+  private
+
+  # source://pry//lib/pry/output.rb#80
+  def actual_screen_size; end
+
+  # source://pry//lib/pry/output.rb#125
+  def ansicon_env_size; end
+
+  # source://pry//lib/pry/output.rb#109
+  def env_size; end
+
+  # source://pry//lib/pry/output.rb#92
+  def io_console_size; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/output.rb#132
+  def nonzero_column?(size); end
+
+  # source://pry//lib/pry/output.rb#114
+  def readline_size; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/output.rb#49
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+end
+
+# @return [Array<Integer>] default terminal screen size [rows, cols]
+#
+# source://pry//lib/pry/output.rb#6
+Pry::Output::DEFAULT_SIZE = T.let(T.unsafe(nil), Array)
+
+# source://pry//lib/pry/pager.rb#7
+class Pry::Pager
+  # @return [Pager] a new instance of Pager
+  #
+  # source://pry//lib/pry/pager.rb#13
+  def initialize(pry_instance); end
+
+  # Yields a pager object (`NullPager`, `SimplePager`, or `SystemPager`).
+  # All pagers accept output with `#puts`, `#print`, `#write`, and `#<<`.
+  #
+  # source://pry//lib/pry/pager.rb#33
+  def open; end
+
+  # Send the given text through the best available pager (if
+  # `Pry.config.pager` is enabled). If you want to send text through in
+  # chunks as you generate it, use `open` to get a writable object
+  # instead.
+  #
+  # @param text [String] Text to run through a pager.
+  #
+  # source://pry//lib/pry/pager.rb#25
+  def page(text); end
+
+  # Returns the value of attribute pry_instance.
+  #
+  # source://pry//lib/pry/pager.rb#11
+  def pry_instance; end
+
+  private
+
+  # Return an instance of the "best" available pager class --
+  # `SystemPager` if possible, `SimplePager` if `SystemPager` isn't
+  # available, and `NullPager` if the user has disabled paging. All
+  # pagers accept output with `#puts`, `#print`, `#write`, and `#<<`. You
+  # must call `#close` when you're done writing output to a pager, and
+  # you must rescue `Pry::Pager::StopPaging`. These requirements can be
+  # avoided by using `.open` instead.
+  #
+  # source://pry//lib/pry/pager.rb#56
+  def best_available; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/pager.rb#43
+  def enabled?; end
+
+  # Returns the value of attribute output.
+  #
+  # source://pry//lib/pry/pager.rb#47
+  def output; end
+end
+
+# `NullPager` is a "pager" that actually just prints all output as it
+# comes in. Used when `Pry.config.pager` is false.
+#
+# source://pry//lib/pry/pager.rb#68
+class Pry::Pager::NullPager
+  # @return [NullPager] a new instance of NullPager
+  #
+  # source://pry//lib/pry/pager.rb#69
+  def initialize(out); end
+
+  # source://pry//lib/pry/pager.rb#77
+  def <<(str); end
+
+  # source://pry//lib/pry/pager.rb#86
+  def close; end
+
+  # source://pry//lib/pry/pager.rb#77
+  def print(str); end
+
+  # source://pry//lib/pry/pager.rb#73
+  def puts(str); end
+
+  # source://pry//lib/pry/pager.rb#82
+  def write(str); end
+
+  private
+
+  # source://pry//lib/pry/pager.rb#90
+  def height; end
+
+  # source://pry//lib/pry/pager.rb#94
+  def width; end
+end
+
+# `PageTracker` tracks output to determine whether it's likely to take
+# up a whole page. This doesn't need to be super precise, but we can
+# use it for `SimplePager` and to avoid invoking the system pager
+# unnecessarily.
+#
+# One simplifying assumption is that we don't need `#page?` to return
+# `true` on the basis of an incomplete line. Long lines should be
+# counted as multiple lines, but we don't have to transition from
+# `false` to `true` until we see a newline.
+#
+# source://pry//lib/pry/pager.rb#213
+class Pry::Pager::PageTracker
+  # @return [PageTracker] a new instance of PageTracker
+  #
+  # source://pry//lib/pry/pager.rb#214
+  def initialize(rows, cols); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/pager.rb#231
+  def page?; end
+
+  # source://pry//lib/pry/pager.rb#220
+  def record(str); end
+
+  # source://pry//lib/pry/pager.rb#235
+  def reset; end
+
+  private
+
+  # Approximation of the printable length of a given line, without the
+  # newline and without ANSI color codes.
+  #
+  # source://pry//lib/pry/pager.rb#244
+  def line_length(line); end
+end
+
+# `SimplePager` is a straightforward pure-Ruby pager. We use it on
+# JRuby and when we can't find a usable external pager.
+#
+# source://pry//lib/pry/pager.rb#101
+class Pry::Pager::SimplePager < ::Pry::Pager::NullPager
+  # @return [SimplePager] a new instance of SimplePager
+  #
+  # source://pry//lib/pry/pager.rb#102
+  def initialize(*_arg0); end
+
+  # source://pry//lib/pry/pager.rb#107
+  def write(str); end
+end
+
+# source://pry//lib/pry/pager.rb#8
+class Pry::Pager::StopPaging < ::StandardError; end
+
+# `SystemPager` buffers output until we're pretty sure it's at least a
+# page long, then invokes an external pager and starts streaming output
+# to it. If `#close` is called before then, it just prints out the
+# buffered content.
+#
+# source://pry//lib/pry/pager.rb#129
+class Pry::Pager::SystemPager < ::Pry::Pager::NullPager
+  # @return [SystemPager] a new instance of SystemPager
+  #
+  # source://pry//lib/pry/pager.rb#161
+  def initialize(*_arg0); end
+
+  # source://pry//lib/pry/pager.rb#181
+  def close; end
+
+  # source://pry//lib/pry/pager.rb#168
+  def write(str); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/pager.rb#195
+  def invoked_pager?; end
+
+  # source://pry//lib/pry/pager.rb#199
+  def pager; end
+
+  # source://pry//lib/pry/pager.rb#191
+  def write_to_pager(text); end
+
+  class << self
+    # @return [Boolean]
+    #
+    # source://pry//lib/pry/pager.rb#142
+    def available?; end
+
+    # source://pry//lib/pry/pager.rb#130
+    def default_pager; end
+  end
+end
+
+# Prompt represents the Pry prompt, which can be used with Readline-like
+# libraries. It defines a few default prompts (default prompt, simple prompt,
+# etc) and also provides an API for adding and implementing custom prompts.
+#
+# @api public
+# @example Registering a new Pry prompt
+#   Pry::Prompt.add(
+#   :ipython,
+#   'IPython-like prompt', [':', '...:']
+#   ) do |_context, _nesting, pry_instance, sep|
+#   sep == ':' ? "In [#{pry_instance.input_ring.count}]: " : '   ...: '
+#   end
+#
+#   # Produces:
+#   # In [3]: def foo
+#   #    ...:   puts 'foo'
+#   #    ...: end
+#   # => :foo
+#   # In [4]:
+# @example Manually instantiating the Prompt class
+#   prompt_procs = [
+#   proc { '#{rand(1)}>" },
+#   proc { "#{('a'..'z').to_a.sample}*" }
+#   ]
+#   prompt = Pry::Prompt.new(
+#   :random,
+#   'Random number or letter prompt.',
+#   prompt_procs
+#   )
+#   prompt.wait_proc.call(...) #=>
+#   prompt.incomplete_proc.call(...)
+# @since v0.11.0
+#
+# source://pry//lib/pry/prompt.rb#38
+class Pry::Prompt
+  # @api public
+  # @param name [String]
+  # @param description [String]
+  # @param prompt_procs [Array<Proc>]
+  # @return [Prompt] a new instance of Prompt
+  # @since v0.11.0
+  #
+  # source://pry//lib/pry/prompt.rb#117
+  def initialize(name, description, prompt_procs); end
+
+  # @api public
+  # @deprecated Use a `Pry::Prompt` instance directly
+  # @since v0.11.0
+  #
+  # source://pry//lib/pry/prompt.rb#135
+  def [](key); end
+
+  # @api public
+  # @return [String]
+  # @since v0.11.0
+  #
+  # source://pry//lib/pry/prompt.rb#108
+  def description; end
+
+  # @api public
+  # @return [Proc] the proc which builds the prompt when in the middle of an
+  #   expression such as open method, etc. (`*`)
+  # @since v0.11.0
+  #
+  # source://pry//lib/pry/prompt.rb#130
+  def incomplete_proc; end
+
+  # @api public
+  # @return [String]
+  # @since v0.11.0
+  #
+  # source://pry//lib/pry/prompt.rb#105
+  def name; end
+
+  # @api public
+  # @return [Array<Proc>] the array of procs that hold
+  #   `[wait_proc, incomplete_proc]`
+  # @since v0.11.0
+  #
+  # source://pry//lib/pry/prompt.rb#112
+  def prompt_procs; end
+
+  # @api public
+  # @return [Proc] the proc which builds the wait prompt (`>`)
+  # @since v0.11.0
+  #
+  # source://pry//lib/pry/prompt.rb#124
+  def wait_proc; end
+
+  class << self
+    # Retrieves a prompt.
+    #
+    # @api public
+    # @example
+    #   Prompt[:my_prompt]
+    # @param name [Symbol] The name of the prompt you want to access
+    # @return [Hash{Symbol=>Object}]
+    # @since v0.12.0
+    #
+    # source://pry//lib/pry/prompt.rb#52
+    def [](name); end
+
+    # Adds a new prompt to the prompt hash.
+    #
+    # @api public
+    # @param name [Symbol]
+    # @param description [String]
+    # @param separators [Array<String>] The separators to differentiate
+    #   between prompt modes (default mode and class/method definition mode).
+    #   The Array *must* have a size of 2.
+    # @raise [ArgumentError] if the size of `separators` is not 2
+    # @raise [ArgumentError] if `prompt_name` is already occupied
+    # @return [nil]
+    # @since v0.12.0
+    # @yield [context, nesting, pry_instance, sep]
+    # @yieldparam context [Object] the context where Pry is currently in
+    # @yieldparam nesting [Integer] whether the context is nested
+    # @yieldparam pry_instance [Pry] the Pry instance
+    # @yieldparam separator [String] separator string
+    #
+    # source://pry//lib/pry/prompt.rb#79
+    def add(name, description = T.unsafe(nil), separators = T.unsafe(nil)); end
+
+    # @api public
+    # @note Use this for read-only operations
+    # @return [Hash{Symbol=>Hash}] the duplicate of the internal prompts hash
+    # @since v0.12.0
+    #
+    # source://pry//lib/pry/prompt.rb#59
+    def all; end
+  end
+end
+
+# source://pry//lib/pry/repl.rb#4
+class Pry::REPL
+  extend ::Forwardable
+  extend ::Pry::Forwardable
+
+  # Create an instance of {REPL} wrapping the given {Pry}.
+  #
+  # @option options
+  # @param pry [Pry] The instance of {Pry} that this {REPL} will control.
+  # @param options [Hash] Options for this {REPL} instance.
+  # @return [REPL] a new instance of REPL
+  #
+  # source://pry//lib/pry/repl.rb#22
+  def initialize(pry, options = T.unsafe(nil)); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def input(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def output(*args, **_arg1, &block); end
+
+  # @return [Pry] The instance of {Pry} that the user is controlling.
+  #
+  # source://pry//lib/pry/repl.rb#9
+  def pry; end
+
+  # @return [Pry] The instance of {Pry} that the user is controlling.
+  #
+  # source://pry//lib/pry/repl.rb#9
+  def pry=(_arg0); end
+
+  # Start the read-eval-print loop.
+  #
+  # @raise [Exception] If the session throws `:raise_up`, raise the exception
+  #   thrown with it.
+  # @return [Object?] If the session throws `:breakout`, return the value
+  #   thrown with it.
+  #
+  # source://pry//lib/pry/repl.rb#36
+  def start; end
+
+  private
+
+  # Calculates correct overhang for current line. Supports vi Readline
+  # mode and its indicators such as "(ins)" or "(cmd)".
+  #
+  # @note This doesn't calculate overhang for Readline's emacs mode with an
+  #   indicator because emacs is the default mode and it doesn't use
+  #   indicators in 99% of cases.
+  # @return [Integer]
+  #
+  # source://pry//lib/pry/repl.rb#237
+  def calculate_overhang(current_prompt, original_val, indented_val); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/repl.rb#205
+  def coolline_available?; end
+
+  # Clean up after the repl session.
+  #
+  # @return [void]
+  #
+  # source://pry//lib/pry/repl.rb#84
+  def epilogue; end
+
+  # Manage switching of input objects on encountering `EOFError`s.
+  #
+  # @return [Object] Whatever the given block returns.
+  # @return [:no_more_input] Indicates that no more input can be read.
+  #
+  # source://pry//lib/pry/repl.rb#127
+  def handle_read_errors; end
+
+  # source://pry//lib/pry/repl.rb#195
+  def input_readline(*args); end
+
+  # If `$stdout` is not a tty, it's probably a pipe.
+  #
+  # @example
+  #   # `piping?` returns `false`
+  #   % pry
+  #   [1] pry(main)
+  #
+  #   # `piping?` returns `true`
+  #   % pry | tee log
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/repl.rb#217
+  def piping?; end
+
+  # Set up the repl session.
+  #
+  # @return [void]
+  #
+  # source://pry//lib/pry/repl.rb#47
+  def prologue; end
+
+  # Read a line of input from the user.
+  #
+  # @return [String] The line entered by the user.
+  # @return [nil] On `<Ctrl-D>`.
+  # @return [:control_c] On `<Ctrl+C>`.
+  # @return [:no_more_input] On EOF.
+  #
+  # source://pry//lib/pry/repl.rb#93
+  def read; end
+
+  # Returns the next line of input to be sent to the {Pry} instance.
+  #
+  # @param current_prompt [String] The prompt to use for input.
+  # @return [String?] The next line of input, or `nil` on <Ctrl-D>.
+  #
+  # source://pry//lib/pry/repl.rb#169
+  def read_line(current_prompt); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/repl.rb#201
+  def readline_available?; end
+
+  # The actual read-eval-print loop.
+  #
+  # The {REPL} instance is responsible for reading and looping, whereas the
+  # {Pry} instance is responsible for evaluating user input and printing
+  # return values and command output.
+  #
+  # @raise [Exception] If the session throws `:raise_up`, raise the exception
+  #   thrown with it.
+  # @return [Object?] If the session throws `:breakout`, return the value
+  #   thrown with it.
+  #
+  # source://pry//lib/pry/repl.rb#66
+  def repl; end
+
+  # @return [void]
+  #
+  # source://pry//lib/pry/repl.rb#224
+  def set_readline_output; end
+
+  class << self
+    # Instantiate a new {Pry} instance with the given options, then start a
+    # {REPL} instance wrapping it.
+    #
+    # @option options
+    # @param options [Hash] a customizable set of options
+    #
+    # source://pry//lib/pry/repl.rb#14
+    def start(options); end
+  end
+end
+
+# A class to manage the loading of files through the REPL loop.
+# This is an interesting trick as it processes your file as if it
+# was user input in an interactive session. As a result, all Pry
+# commands are available, and they are executed non-interactively. Furthermore
+# the session becomes interactive when the repl loop processes a
+# 'make-interactive' command in the file. The session also becomes
+# interactive when an exception is encountered, enabling you to fix
+# the error before returning to non-interactive processing with the
+# 'make-non-interactive' command.
+#
+# source://pry//lib/pry/repl_file_loader.rb#14
+class Pry::REPLFileLoader
+  # @return [REPLFileLoader] a new instance of REPLFileLoader
+  #
+  # source://pry//lib/pry/repl_file_loader.rb#15
+  def initialize(file_name); end
+
+  # Define a few extra commands useful for flipping back & forth
+  # between interactive/non-interactive modes
+  #
+  # source://pry//lib/pry/repl_file_loader.rb#59
+  def define_additional_commands; end
+
+  # Switch to interactive mode, i.e take input from the user
+  # and use the regular print and exception handlers.
+  #
+  # @param pry_instance [Pry] the Pry instance to make interactive.
+  #
+  # source://pry//lib/pry/repl_file_loader.rb#26
+  def interactive_mode(pry_instance); end
+
+  # Actually load the file through the REPL by setting file content
+  # as the REPL input stream.
+  #
+  # source://pry//lib/pry/repl_file_loader.rb#75
+  def load; end
+
+  # Switch to non-interactive mode. Essentially
+  # this means there is no result output
+  # and that the session becomes interactive when an exception is encountered.
+  #
+  # @param pry_instance [Pry] the Pry instance to make non-interactive.
+  #
+  # source://pry//lib/pry/repl_file_loader.rb#37
+  def non_interactive_mode(pry_instance, content); end
+end
+
+# As a REPL, we often want to catch any unexpected exceptions that may have
+# been raised; however we don't want to go overboard and prevent the user
+# from exiting Pry when they want to.
+#
+# source://pry//lib/pry/exceptions.rb#7
+module Pry::RescuableException
+  class << self
+    # source://pry//lib/pry/exceptions.rb#8
+    def ===(exception); end
+  end
+end
+
+# Wraps the return result of process_commands, indicates if the
+# result IS a command and what kind of command (e.g void)
+#
+# source://pry//lib/pry/command_set.rb#397
+class Pry::Result
+  # @return [Result] a new instance of Result
+  #
+  # source://pry//lib/pry/command_set.rb#400
+  def initialize(is_command, retval = T.unsafe(nil)); end
+
+  # Is the result a command?
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/command_set.rb#407
+  def command?; end
+
+  # Returns the value of attribute retval.
+  #
+  # source://pry//lib/pry/command_set.rb#398
+  def retval; end
+
+  # Is the result a command and if it is, is it a void command?
+  # (one that does not return a value)
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/command_set.rb#414
+  def void_command?; end
+end
+
+# A ring is a thread-safe fixed-capacity array to which you can only add
+# elements. Older entries are overwritten as you add new elements, so that the
+# ring can never contain more than `max_size` elemens.
+#
+# @api public
+# @example
+#   ring = Pry::Ring.new(3)
+#   ring << 1 << 2 << 3
+#   ring.to_a #=> [1, 2, 3]
+#   ring << 4
+#   ring.to_a #=> [2, 3, 4]
+#
+#   ring[0] #=> 2
+#   ring[-1] #=> 4
+#   ring.clear
+#   ring[0] #=> nil
+# @since v0.12.0
+#
+# source://pry//lib/pry/ring.rb#22
+class Pry::Ring
+  # @api public
+  # @param max_size [Integer] Maximum buffer size. The buffer will start
+  #   overwriting elements once its reaches its maximum capacity
+  # @return [Ring] a new instance of Ring
+  # @since v0.12.0
+  #
+  # source://pry//lib/pry/ring.rb#33
+  def initialize(max_size); end
+
+  # Push `value` to the current index.
+  #
+  # @api public
+  # @param value [Object]
+  # @return [self]
+  # @since v0.12.0
+  #
+  # source://pry//lib/pry/ring.rb#43
+  def <<(value); end
+
+  # Read the value stored at `index`.
+  #
+  # @api public
+  # @param index [Integer, Range] The element (if Integer) or elements
+  #   (if Range) associated with `index`
+  # @return [Object, Array<Object>, nil] element(s) at `index`, `nil` if none
+  #   exist
+  # @since v0.12.0
+  #
+  # source://pry//lib/pry/ring.rb#57
+  def [](index); end
+
+  # Clear the buffer and reset count.
+  #
+  # @api public
+  # @return [void]
+  # @since v0.12.0
+  #
+  # source://pry//lib/pry/ring.rb#75
+  def clear; end
+
+  # @api public
+  # @return [Integer] how many objects were added during the lifetime of the
+  #   ring
+  # @since v0.12.0
+  #
+  # source://pry//lib/pry/ring.rb#28
+  def count; end
+
+  # @api public
+  # @return [Integer] maximum buffer size
+  # @since v0.12.0
+  #
+  # source://pry//lib/pry/ring.rb#24
+  def max_size; end
+
+  # @api public
+  # @return [Integer] how many objects were added during the lifetime of the
+  #   ring
+  # @since v0.12.0
+  #
+  # source://pry//lib/pry/ring.rb#28
+  def size; end
+
+  # @api public
+  # @return [Array<Object>] the buffer as unwinded array
+  # @since v0.12.0
+  #
+  # source://pry//lib/pry/ring.rb#67
+  def to_a; end
+
+  private
+
+  # @api public
+  # @since v0.12.0
+  #
+  # source://pry//lib/pry/ring.rb#84
+  def transpose_buffer_tail; end
+end
+
+# source://pry//lib/pry/slop.rb#5
+class Pry::Slop
+  include ::Enumerable
+
+  # Create a new instance of Slop and optionally build options via a block.
+  #
+  # config - A Hash of configuration options.
+  # block  - An optional block used to specify options.
+  #
+  # @return [Slop] a new instance of Slop
+  #
+  # source://pry//lib/pry/slop.rb#127
+  def initialize(config = T.unsafe(nil), &block); end
+
+  # Fetch an options argument value.
+  #
+  # key - The Symbol or String option short or long flag.
+  #
+  # Returns the Object value for this option, or nil.
+  #
+  # source://pry//lib/pry/slop.rb#278
+  def [](key); end
+
+  # Add a callback.
+  #
+  # label - The Symbol identifier to attach this callback.
+  #
+  # Returns nothing.
+  #
+  # source://pry//lib/pry/slop.rb#398
+  def add_callback(label, &block); end
+
+  # Get or set the banner.
+  #
+  # banner - The String to set the banner.
+  #
+  # Returns the banner String.
+  #
+  # source://pry//lib/pry/slop.rb#168
+  def banner(banner = T.unsafe(nil)); end
+
+  # Set the banner.
+  #
+  # banner - The String to set the banner.
+  #
+  # source://pry//lib/pry/slop.rb#159
+  def banner=(banner); end
+
+  # Add a new command.
+  #
+  # command - The Symbol or String used to identify this command.
+  # options - A Hash of configuration options (see Slop::new)
+  #
+  # Returns a new instance of Slop mapped to this command.
+  #
+  # source://pry//lib/pry/slop.rb#196
+  def command(command, options = T.unsafe(nil), &block); end
+
+  # The Hash of configuration options for this Slop instance.
+  #
+  # source://pry//lib/pry/slop.rb#118
+  def config; end
+
+  # Get or set the description (used for commands).
+  #
+  # desc - The String to set the description.
+  #
+  # Returns the description String.
+  #
+  # source://pry//lib/pry/slop.rb#185
+  def description(desc = T.unsafe(nil)); end
+
+  # Set the description (used for commands).
+  #
+  # desc - The String to set the description.
+  #
+  # source://pry//lib/pry/slop.rb#176
+  def description=(desc); end
+
+  # Enumerable interface. Yields each Slop::Option.
+  #
+  # source://pry//lib/pry/slop.rb#297
+  def each(&block); end
+
+  # Fetch a Slop object associated with this command.
+  #
+  # command - The String or Symbol name of the command.
+  #
+  # Examples:
+  #
+  #   opts.command :foo do
+  #     on :v, :verbose, 'Enable verbose mode'
+  #   end
+  #
+  #   # ruby run.rb foo -v
+  #   opts.fetch_command(:foo).verbose? #=> true
+  #
+  # source://pry//lib/pry/slop.rb#389
+  def fetch_command(command); end
+
+  # Fetch a Slop::Option object.
+  #
+  # key - The Symbol or String option key.
+  #
+  # Examples:
+  #
+  #   opts.on(:foo, 'Something fooey', :argument => :optional)
+  #   opt = opts.fetch_option(:foo)
+  #   opt.class #=> Slop::Option
+  #   opt.accepts_optional_argument? #=> true
+  #
+  # Returns an Option or nil if none were found.
+  #
+  # source://pry//lib/pry/slop.rb#373
+  def fetch_option(key); end
+
+  # Fetch an options argument value.
+  #
+  # key - The Symbol or String option short or long flag.
+  #
+  # Returns the Object value for this option, or nil.
+  #
+  # source://pry//lib/pry/slop.rb#278
+  def get(key); end
+
+  # Print a handy Slop help string.
+  #
+  # Returns the banner followed by available option help strings.
+  #
+  # source://pry//lib/pry/slop.rb#416
+  def help; end
+
+  # Fetch a list of options which were missing from the parsed list.
+  #
+  # Examples:
+  #
+  #   opts = Slop.new do
+  #     on :n, :name=
+  #     on :p, :password=
+  #   end
+  #
+  #   opts.parse %w[ --name Lee ]
+  #   opts.missing #=> ['password']
+  #
+  # Returns an Array of Strings representing missing options.
+  #
+  # source://pry//lib/pry/slop.rb#357
+  def missing; end
+
+  # Add an Option.
+  #
+  # objects - An Array with an optional Hash as the last element.
+  #
+  # Examples:
+  #
+  #   on '-u', '--username=', 'Your username'
+  #   on :v, :verbose, 'Enable verbose mode'
+  #
+  # Returns the created instance of Slop::Option.
+  #
+  # source://pry//lib/pry/slop.rb#265
+  def on(*objects, &block); end
+
+  # Add an Option.
+  #
+  # objects - An Array with an optional Hash as the last element.
+  #
+  # Examples:
+  #
+  #   on '-u', '--username=', 'Your username'
+  #   on :v, :verbose, 'Enable verbose mode'
+  #
+  # Returns the created instance of Slop::Option.
+  #
+  # source://pry//lib/pry/slop.rb#265
+  def opt(*objects, &block); end
+
+  # Add an Option.
+  #
+  # objects - An Array with an optional Hash as the last element.
+  #
+  # Examples:
+  #
+  #   on '-u', '--username=', 'Your username'
+  #   on :v, :verbose, 'Enable verbose mode'
+  #
+  # Returns the created instance of Slop::Option.
+  #
+  # source://pry//lib/pry/slop.rb#265
+  def option(*objects, &block); end
+
+  # The Array of Slop::Option objects tied to this Slop instance.
+  #
+  # source://pry//lib/pry/slop.rb#121
+  def options; end
+
+  # Parse a list of items, executing and gathering options along the way.
+  #
+  # items - The Array of items to extract options from (default: ARGV).
+  # block - An optional block which when used will yield non options.
+  #
+  # Returns an Array of original items.
+  #
+  # source://pry//lib/pry/slop.rb#206
+  def parse(items = T.unsafe(nil), &block); end
+
+  # Parse a list of items, executing and gathering options along the way.
+  # unlike parse() this method will remove any options and option arguments
+  # from the original Array.
+  #
+  # items - The Array of items to extract options from (default: ARGV).
+  # block - An optional block which when used will yield non options.
+  #
+  # Returns an Array of original items with options removed.
+  #
+  # source://pry//lib/pry/slop.rb#219
+  def parse!(items = T.unsafe(nil), &block); end
+
+  # Check for an options presence.
+  #
+  # Examples:
+  #
+  #   opts.parse %w( --foo )
+  #   opts.present?(:foo) #=> true
+  #   opts.present?(:bar) #=> false
+  #
+  # Returns true if all of the keys are present in the parsed arguments.
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/slop.rb#333
+  def present?(*keys); end
+
+  # Specify code to be executed when these options are parsed.
+  #
+  # callable - An object responding to a call method.
+  #
+  # yields - The instance of Slop parsing these options
+  #          An Array of unparsed arguments
+  #
+  # Example:
+  #
+  #   Slop.parse do
+  #     on :v, :verbose
+  #
+  #     run do |opts, args|
+  #       puts "Arguments: #{args.inspect}" if opts.verbose?
+  #     end
+  #   end
+  #
+  # @raise [ArgumentError]
+  #
+  # source://pry//lib/pry/slop.rb#317
+  def run(callable = T.unsafe(nil), &block); end
+
+  # Add string separators between options.
+  #
+  # text - The String text to print.
+  #
+  # source://pry//lib/pry/slop.rb#405
+  def separator(text); end
+
+  # Is strict mode enabled?
+  #
+  # Returns true if strict mode is enabled, false otherwise.
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/slop.rb#152
+  def strict?; end
+
+  # Returns a new Hash with option flags as keys and option values as values.
+  #
+  # include_commands - If true, merge options from all sub-commands.
+  #
+  # source://pry//lib/pry/slop.rb#287
+  def to_h(include_commands = T.unsafe(nil)); end
+
+  # Returns a new Hash with option flags as keys and option values as values.
+  #
+  # include_commands - If true, merge options from all sub-commands.
+  #
+  # source://pry//lib/pry/slop.rb#287
+  def to_hash(include_commands = T.unsafe(nil)); end
+
+  # Print a handy Slop help string.
+  #
+  # Returns the banner followed by available option help strings.
+  #
+  # source://pry//lib/pry/slop.rb#416
+  def to_s; end
+
+  private
+
+  # Autocreate an option on the fly. See the :autocreate Slop config option.
+  #
+  # items - The Array of items we're parsing.
+  # index - The current Integer index for the item we're processing.
+  #
+  # Returns nothing.
+  #
+  # source://pry//lib/pry/slop.rb#590
+  def autocreate(items, index); end
+
+  # Build an option from a list of objects.
+  #
+  # objects - An Array of objects used to build this option.
+  #
+  # Returns a new instance of Slop::Option.
+  #
+  # source://pry//lib/pry/slop.rb#606
+  def build_option(objects, &block); end
+
+  # Remove any leading -- characters from a string.
+  #
+  # object - The Object we want to cast to a String and clean.
+  #
+  # Returns the newly cleaned String with leading -- characters removed.
+  #
+  # source://pry//lib/pry/slop.rb#659
+  def clean(object); end
+
+  # source://pry//lib/pry/slop.rb#663
+  def commands_to_help; end
+
+  # Execute a `-abc` type option where a, b and c are all options. This
+  # method is only executed if the multiple_switches argument is true.
+  #
+  # option   - The first Option object.
+  # argument - The argument to this option. (Split into multiple Options).
+  # index    - The index of the current item being processed.
+  #
+  # Returns nothing.
+  #
+  # source://pry//lib/pry/slop.rb#552
+  def execute_multiple_switches(option, argument, index); end
+
+  # Execute an option, firing off callbacks and assigning arguments.
+  #
+  # option   - The Slop::Option object found by #process_item.
+  # argument - The argument Object to assign to this option.
+  # index    - The current Integer index of the object we're processing.
+  # item     - The optional String item we're processing.
+  #
+  # Returns nothing.
+  #
+  # source://pry//lib/pry/slop.rb#519
+  def execute_option(option, argument, index, item = T.unsafe(nil)); end
+
+  # Extract the long flag from an item.
+  #
+  # objects - The Array of objects passed from #build_option.
+  # config  - The Hash of configuration options built in #build_option.
+  #
+  # source://pry//lib/pry/slop.rb#644
+  def extract_long_flag(objects, config); end
+
+  # Extract an option from a flag.
+  #
+  # flag - The flag key used to extract an option.
+  #
+  # Returns an Array of [option, argument].
+  #
+  # source://pry//lib/pry/slop.rb#567
+  def extract_option(flag); end
+
+  # Extract the short flag from an item.
+  #
+  # objects - The Array of objects passed from #build_option.
+  # config  - The Hash of configuration options built in #build_option.
+  #
+  # source://pry//lib/pry/slop.rb#626
+  def extract_short_flag(objects, config); end
+
+  # Convenience method for present?(:option).
+  #
+  # Examples:
+  #
+  #   opts.parse %( --verbose )
+  #   opts.verbose? #=> true
+  #   opts.other?   #=> false
+  #
+  # Returns true if this option is present. If this method does not end
+  # with a ? character it will instead call super().
+  #
+  # source://pry//lib/pry/slop.rb#454
+  def method_missing(method, *args, &block); end
+
+  # Process a list item, figure out if it's an option, execute any
+  # callbacks, assign any option arguments, and do some sanity checks.
+  #
+  # items - The Array of items to process.
+  # index - The current Integer index of the item we want to process.
+  # block - An optional block which when passed will yield non options.
+  #
+  # Returns nothing.
+  #
+  # source://pry//lib/pry/slop.rb#472
+  def process_item(items, index, &block); end
+
+  # Override this method so we can check if an option? method exists.
+  #
+  # Returns true if this option key exists in our list of options.
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/slop.rb#340
+  def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end
+
+  class << self
+    # Build a Slop object from a option specification.
+    #
+    # This allows you to design your options via a simple String rather
+    # than programatically. Do note though that with this method, you're
+    # unable to pass any advanced options to the on() method when creating
+    # options.
+    #
+    # string - The optspec String
+    # config - A Hash of configuration options to pass to Slop.new
+    #
+    # Examples:
+    #
+    #   opts = Slop.optspec(<<-SPEC)
+    #   ruby foo.rb [options]
+    #   ---
+    #   n,name=     Your name
+    #   a,age=      Your age
+    #   A,auth      Sign in with auth
+    #   p,passcode= Your secret pass code
+    #   SPEC
+    #
+    #   opts.fetch_option(:name).description #=> "Your name"
+    #
+    # Returns a new instance of Slop.
+    #
+    # source://pry//lib/pry/slop.rb#97
+    def optspec(string, config = T.unsafe(nil)); end
+
+    # items  - The Array of items to extract options from (default: ARGV).
+    # config - The Hash of configuration options to send to Slop.new().
+    # block  - An optional block used to add options.
+    #
+    # Examples:
+    #
+    #   Slop.parse(ARGV, :help => true) do
+    #     on '-n', '--name', 'Your username', :argument => true
+    #   end
+    #
+    # Returns a new instance of Slop.
+    #
+    # source://pry//lib/pry/slop.rb#54
+    def parse(items = T.unsafe(nil), config = T.unsafe(nil), &block); end
+
+    # items  - The Array of items to extract options from (default: ARGV).
+    # config - The Hash of configuration options to send to Slop.new().
+    # block  - An optional block used to add options.
+    #
+    # Returns a new instance of Slop.
+    #
+    # source://pry//lib/pry/slop.rb#63
+    def parse!(items = T.unsafe(nil), config = T.unsafe(nil), &block); end
+  end
+end
+
+# source://pry//lib/pry/slop/commands.rb#5
+class Pry::Slop::Commands
+  include ::Enumerable
+
+  # Create a new instance of Slop::Commands and optionally build
+  # Slop instances via a block. Any configuration options used in
+  # this method will be the default configuration options sent to
+  # each Slop object created.
+  #
+  # config - An optional configuration Hash.
+  # block  - Optional block used to define commands.
+  #
+  # Examples:
+  #
+  #   commands = Slop::Commands.new do
+  #     on :new do
+  #       on '-o', '--outdir=', 'The output directory'
+  #       on '-v', '--verbose', 'Enable verbose mode'
+  #     end
+  #
+  #     on :generate do
+  #       on '--assets', 'Generate assets', :default => true
+  #     end
+  #
+  #     global do
+  #       on '-D', '--debug', 'Enable debug mode', :default => false
+  #     end
+  #   end
+  #
+  #   commands[:new].class #=> Slop
+  #   commands.parse
+  #
+  # @return [Commands] a new instance of Commands
+  #
+  # source://pry//lib/pry/slop/commands.rb#39
+  def initialize(config = T.unsafe(nil), &block); end
+
+  # Fetch the instance of Slop tied to a command.
+  #
+  # key - The String or Symbol key used to locate this command.
+  #
+  # Returns the Slop instance if this key is found, nil otherwise.
+  #
+  # source://pry//lib/pry/slop/commands.rb#100
+  def [](key); end
+
+  # Returns the value of attribute arguments.
+  #
+  # source://pry//lib/pry/slop/commands.rb#8
+  def arguments; end
+
+  # Optionally set the banner for this command help output.
+  #
+  # banner - The String text to set the banner.
+  #
+  # Returns the String banner if one is set.
+  #
+  # source://pry//lib/pry/slop/commands.rb#59
+  def banner(banner = T.unsafe(nil)); end
+
+  # Sets the attribute banner
+  #
+  # @param value the value to set the attribute banner to.
+  #
+  # source://pry//lib/pry/slop/commands.rb#9
+  def banner=(_arg0); end
+
+  # Returns the value of attribute commands.
+  #
+  # source://pry//lib/pry/slop/commands.rb#8
+  def commands; end
+
+  # Returns the value of attribute config.
+  #
+  # source://pry//lib/pry/slop/commands.rb#8
+  def config; end
+
+  # Add a Slop instance used when no other commands exist.
+  #
+  # config - A Hash of configuration options to pass to Slop.
+  # block  - An optional block used to pass options to Slop.
+  #
+  # Returns the newly created Slop instance mapped to default.
+  #
+  # source://pry//lib/pry/slop/commands.rb#81
+  def default(config = T.unsafe(nil), &block); end
+
+  # Enumerable interface.
+  #
+  # source://pry//lib/pry/slop/commands.rb#119
+  def each(&block); end
+
+  # Fetch the instance of Slop tied to a command.
+  #
+  # key - The String or Symbol key used to locate this command.
+  #
+  # Returns the Slop instance if this key is found, nil otherwise.
+  #
+  # source://pry//lib/pry/slop/commands.rb#100
+  def get(key); end
+
+  # Add a global Slop instance.
+  #
+  # config - A Hash of configuration options to pass to Slop.
+  # block  - An optional block used to pass options to Slop.
+  #
+  # Returns the newly created Slop instance mapped to global.
+  #
+  # source://pry//lib/pry/slop/commands.rb#91
+  def global(config = T.unsafe(nil), &block); end
+
+  # Returns the help String.
+  #
+  # source://pry//lib/pry/slop/commands.rb#158
+  def help; end
+
+  # Returns the inspection String.
+  #
+  # source://pry//lib/pry/slop/commands.rb#170
+  def inspect; end
+
+  # Add a Slop instance for a specific command.
+  #
+  # command - A String or Symbol key used to identify this command.
+  # config  - A Hash of configuration options to pass to Slop.
+  # block   - An optional block used to pass options to Slop.
+  #
+  # Returns the newly created Slop instance mapped to command.
+  #
+  # source://pry//lib/pry/slop/commands.rb#71
+  def on(command, config = T.unsafe(nil), &block); end
+
+  # Parse a list of items.
+  #
+  # items - The Array of items to parse.
+  #
+  # Returns the original Array of items.
+  #
+  # source://pry//lib/pry/slop/commands.rb#128
+  def parse(items = T.unsafe(nil)); end
+
+  # Parse a list of items, removing any options or option arguments found.
+  #
+  # items - The Array of items to parse.
+  #
+  # Returns the original Array of items with options removed.
+  #
+  # source://pry//lib/pry/slop/commands.rb#138
+  def parse!(items = T.unsafe(nil)); end
+
+  # Check for a command presence.
+  #
+  # Examples:
+  #
+  #   cmds.parse %w( foo )
+  #   cmds.present?(:foo) #=> true
+  #   cmds.present?(:bar) #=> false
+  #
+  # Returns true if the given key is present in the parsed arguments.
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/slop/commands.rb#114
+  def present?(key); end
+
+  # Returns a nested Hash with Slop options and values. See Slop#to_hash.
+  #
+  # source://pry//lib/pry/slop/commands.rb#153
+  def to_hash; end
+
+  # Returns the help String.
+  #
+  # source://pry//lib/pry/slop/commands.rb#158
+  def to_s; end
+
+  private
+
+  # Returns nothing.
+  #
+  # source://pry//lib/pry/slop/commands.rb#177
+  def execute_arguments!(items); end
+
+  # Returns nothing.
+  #
+  # source://pry//lib/pry/slop/commands.rb#183
+  def execute_global_opts!(items); end
+end
+
+# Returns a default Hash of configuration options this Slop instance uses.
+#
+# source://pry//lib/pry/slop.rb#30
+Pry::Slop::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+# The main Error class, all Exception classes inherit from this class.
+#
+# source://pry//lib/pry/slop.rb#12
+class Pry::Slop::Error < ::StandardError; end
+
+# Raised when an argument does not match its intended match constraint.
+#
+# source://pry//lib/pry/slop.rb#21
+class Pry::Slop::InvalidArgumentError < ::Pry::Slop::Error; end
+
+# Raised when an invalid command is found and the strict flag is enabled.
+#
+# source://pry//lib/pry/slop.rb#27
+class Pry::Slop::InvalidCommandError < ::Pry::Slop::Error; end
+
+# Raised when an invalid option is found and the strict flag is enabled.
+#
+# source://pry//lib/pry/slop.rb#24
+class Pry::Slop::InvalidOptionError < ::Pry::Slop::Error; end
+
+# Raised when an option argument is expected but none are given.
+#
+# source://pry//lib/pry/slop.rb#15
+class Pry::Slop::MissingArgumentError < ::Pry::Slop::Error; end
+
+# Raised when an option is expected/required but not present.
+#
+# source://pry//lib/pry/slop.rb#18
+class Pry::Slop::MissingOptionError < ::Pry::Slop::Error; end
+
+# source://pry//lib/pry/slop/option.rb#5
+class Pry::Slop::Option
+  # Incapsulate internal option information, mainly used to store
+  # option specific configuration data, most of the meat of this
+  # class is found in the #value method.
+  #
+  # slop        - The instance of Slop tied to this Option.
+  # short       - The String or Symbol short flag.
+  # long        - The String or Symbol long flag.
+  # description - The String description text.
+  # config      - A Hash of configuration options.
+  # block       - An optional block used as a callback.
+  #
+  # @return [Option] a new instance of Option
+  #
+  # source://pry//lib/pry/slop/option.rb#35
+  def initialize(slop, short, long, description, config = T.unsafe(nil), &block); end
+
+  # Returns true if this option accepts an optional argument.
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/slop/option.rb#72
+  def accepts_optional_argument?; end
+
+  # Returns the value of attribute argument_in_value.
+  #
+  # source://pry//lib/pry/slop/option.rb#23
+  def argument_in_value; end
+
+  # Sets the attribute argument_in_value
+  #
+  # @param value the value to set the attribute argument_in_value to.
+  #
+  # source://pry//lib/pry/slop/option.rb#23
+  def argument_in_value=(_arg0); end
+
+  # Call this options callback if one exists, and it responds to call().
+  #
+  # Returns nothing.
+  #
+  # source://pry//lib/pry/slop/option.rb#84
+  def call(*objects); end
+
+  # Returns the value of attribute config.
+  #
+  # source://pry//lib/pry/slop/option.rb#22
+  def config; end
+
+  # Returns the value of attribute count.
+  #
+  # source://pry//lib/pry/slop/option.rb#23
+  def count; end
+
+  # Sets the attribute count
+  #
+  # @param value the value to set the attribute count to.
+  #
+  # source://pry//lib/pry/slop/option.rb#23
+  def count=(_arg0); end
+
+  # Returns the value of attribute description.
+  #
+  # source://pry//lib/pry/slop/option.rb#22
+  def description; end
+
+  # Returns true if this option expects an argument.
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/slop/option.rb#67
+  def expects_argument?; end
+
+  # Returns the help String for this option.
+  #
+  # source://pry//lib/pry/slop/option.rb#124
+  def help; end
+
+  # Returns the String inspection text.
+  #
+  # source://pry//lib/pry/slop/option.rb#143
+  def inspect; end
+
+  # Returns the String flag of this option. Preferring the long flag.
+  #
+  # source://pry//lib/pry/slop/option.rb#77
+  def key; end
+
+  # Returns the value of attribute long.
+  #
+  # source://pry//lib/pry/slop/option.rb#22
+  def long; end
+
+  # Returns the value of attribute short.
+  #
+  # source://pry//lib/pry/slop/option.rb#22
+  def short; end
+
+  # Returns the help String for this option.
+  #
+  # source://pry//lib/pry/slop/option.rb#124
+  def to_s; end
+
+  # Returns the value of attribute types.
+  #
+  # source://pry//lib/pry/slop/option.rb#22
+  def types; end
+
+  # Fetch the argument value for this option.
+  #
+  # Returns the Object once any type conversions have taken place.
+  #
+  # source://pry//lib/pry/slop/option.rb#108
+  def value; end
+
+  # Set the new argument value for this option.
+  #
+  # We use this setter method to handle concatenating lists. That is,
+  # when an array type is specified and used more than once, values from
+  # both options will be grouped together and flattened into a single array.
+  #
+  # source://pry//lib/pry/slop/option.rb#93
+  def value=(new_value); end
+
+  private
+
+  # Convert an object to a Float if possible.
+  #
+  # value - The Object we want to convert to a float.
+  #
+  # Returns the Float value if possible to convert, else a zero.
+  #
+  # source://pry//lib/pry/slop/option.rb#173
+  def value_to_float(value); end
+
+  # Convert an object to an Integer if possible.
+  #
+  # value - The Object we want to convert to an integer.
+  #
+  # Returns the Integer value if possible to convert, else a zero.
+  #
+  # source://pry//lib/pry/slop/option.rb#156
+  def value_to_integer(value); end
+
+  # Convert an object to a Range if possible.
+  #
+  # value - The Object we want to convert to a range.
+  #
+  # Returns the Range value if one could be found, else the original object.
+  #
+  # source://pry//lib/pry/slop/option.rb#190
+  def value_to_range(value); end
+end
+
+# The default Hash of configuration options this class uses.
+#
+# source://pry//lib/pry/slop/option.rb#7
+Pry::Slop::Option::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+# source://pry//lib/pry/slop.rb#9
+Pry::Slop::VERSION = T.let(T.unsafe(nil), String)
+
+# @api private
+# @since v0.13.0
+#
+# source://pry//lib/pry/syntax_highlighter.rb#8
+class Pry::SyntaxHighlighter
+  class << self
+    # @api private
+    # @since v0.13.0
+    #
+    # source://pry//lib/pry/syntax_highlighter.rb#9
+    def highlight(code, language = T.unsafe(nil)); end
+
+    # @api private
+    # @since v0.13.0
+    #
+    # source://pry//lib/pry/syntax_highlighter.rb#17
+    def keyword_token_color; end
+
+    # Sets comment token to blue (black by default), so it's more legible.
+    #
+    # @api private
+    # @since v0.13.0
+    #
+    # source://pry//lib/pry/syntax_highlighter.rb#22
+    def overwrite_coderay_comment_token!; end
+
+    # @api private
+    # @since v0.13.0
+    #
+    # source://pry//lib/pry/syntax_highlighter.rb#13
+    def tokenize(code, language = T.unsafe(nil)); end
+  end
+end
+
+# @api private
+# @since v0.13.0
+#
+# source://pry//lib/pry/system_command_handler.rb#6
+module Pry::SystemCommandHandler
+  class << self
+    # @api private
+    # @since v0.13.0
+    #
+    # source://pry//lib/pry/system_command_handler.rb#8
+    def default(output, command, _pry_instance); end
+  end
+end
+
+# Catches SecurityErrors if $SAFE is set
+#
+# source://pry//lib/pry/exceptions.rb#28
+module Pry::TooSafeException
+  class << self
+    # source://pry//lib/pry/exceptions.rb#29
+    def ===(exception); end
+  end
+end
+
+# An Exception Tag (cf. Exceptional Ruby) that instructs Pry to show the error
+# in a more user-friendly manner. This should be used when the exception
+# happens within Pry itself as a direct consequence of the user typing
+# something wrong.
+#
+# This allows us to distinguish between the user typing:
+#
+# pry(main)> def )
+# SyntaxError: unexpected )
+#
+# pry(main)> method_that_evals("def )")
+# SyntaxError: (eval):1: syntax error, unexpected ')'
+# from ./a.rb:2 in `eval'
+#
+# source://pry//lib/pry/exceptions.rb#51
+module Pry::UserError; end
+
+# source://pry//lib/pry/version.rb#4
+Pry::VERSION = T.let(T.unsafe(nil), String)
+
+# @api private
+# @since v0.13.0
+#
+# source://pry//lib/pry/warning.rb#6
+module Pry::Warning
+  class << self
+    # Prints a warning message with exact file and line location, similar to how
+    # Ruby's -W prints warnings.
+    #
+    # @api private
+    # @param message [String]
+    # @return [void]
+    # @since v0.13.0
+    #
+    # source://pry//lib/pry/warning.rb#12
+    def warn(message); end
+  end
+end
+
+# source://pry//lib/pry/wrapped_module.rb#16
+class Pry::WrappedModule
+  include ::Pry::Helpers::BaseHelpers
+  include ::Pry::CodeObject::Helpers
+
+  # @param mod [Module]
+  # @raise [ArgumentError] if the argument is not a `Module`
+  # @return [WrappedModule] a new instance of WrappedModule
+  #
+  # source://pry//lib/pry/wrapped_module.rb#56
+  def initialize(mod); end
+
+  # Return a candidate for this module of specified rank. A `rank`
+  # of 0 is equivalent to the 'primary candidate', which is the
+  # module definition with the highest number of methods. A `rank`
+  # of 1 is the module definition with the second highest number of
+  # methods, and so on. Module candidates are necessary as modules
+  # can be reopened multiple times and in multiple places in Ruby,
+  # the candidate API gives you access to the module definition
+  # representing each of those reopenings.
+  #
+  # @param rank [Fixnum]
+  # @raise [Pry::CommandError] If the `rank` is out of range. That
+  #   is greater than `number_of_candidates - 1`.
+  # @return [Pry::WrappedModule::Candidate]
+  #
+  # source://pry//lib/pry/wrapped_module.rb#239
+  def candidate(rank); end
+
+  # @return [Array]
+  #
+  # source://pry//lib/pry/wrapped_module.rb#250
+  def candidates; end
+
+  # Is this strictly a class?
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/wrapped_module.rb#126
+  def class?; end
+
+  # Returns an array of the names of the constants accessible in the wrapped
+  # module. This avoids the problem of accidentally calling the singleton
+  # method `Module.constants`.
+  #
+  # @param inherit [Boolean] Include the names of constants from included
+  #   modules?
+  #
+  # source://pry//lib/pry/wrapped_module.rb#76
+  def constants(inherit = T.unsafe(nil)); end
+
+  # Returns documentation for the module.
+  # This documentation is for the primary candidate, if
+  # you would like documentation for other candidates use
+  # `WrappedModule#candidate` to select the candidate you're
+  # interested in.
+  #
+  # @raise [Pry::CommandError] If documentation cannot be found.
+  # @return [String] The documentation for the module.
+  #
+  # source://pry//lib/pry/wrapped_module.rb#195
+  def doc; end
+
+  # @return [String, nil] The associated file for the module (i.e
+  #   the primary candidate: highest ranked monkeypatch).
+  #
+  # source://pry//lib/pry/wrapped_module.rb#176
+  def file; end
+
+  # @return [Fixnum, nil] The associated line for the module (i.e
+  #   the primary candidate: highest ranked monkeypatch).
+  #
+  # source://pry//lib/pry/wrapped_module.rb#183
+  def line; end
+
+  # Forward method invocations to the wrapped module
+  #
+  # source://pry//lib/pry/wrapped_module.rb#150
+  def method_missing(method_name, *args, &block); end
+
+  # The prefix that would appear before methods defined on this class.
+  #
+  # i.e. the "String." or "String#" in String.new and String#initialize.
+  #
+  # @return String
+  #
+  # source://pry//lib/pry/wrapped_module.rb#85
+  def method_prefix; end
+
+  # Is this strictly a module? (does not match classes)
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/wrapped_module.rb#120
+  def module?; end
+
+  # The name of the Module if it has one, otherwise #<Class:0xf00>.
+  #
+  # @return [String]
+  #
+  # source://pry//lib/pry/wrapped_module.rb#100
+  def nonblank_name; end
+
+  # @return [Fixnum] The number of candidate definitions for the
+  #   current module.
+  #
+  # source://pry//lib/pry/wrapped_module.rb#245
+  def number_of_candidates; end
+
+  # Is this a singleton class?
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/wrapped_module.rb#110
+  def singleton_class?; end
+
+  # Get the instance associated with this singleton class.
+  #
+  # @raise ArgumentError: tried to get instance of non singleton class
+  # @return [Object]
+  #
+  # source://pry//lib/pry/wrapped_module.rb#135
+  def singleton_instance; end
+
+  # Returns the source for the module.
+  # This source is for the primary candidate, if
+  # you would like source for other candidates use
+  # `WrappedModule#candidate` to select the candidate you're
+  # interested in.
+  #
+  # @raise [Pry::CommandError] If source cannot be found.
+  # @return [String] The source for the module.
+  #
+  # source://pry//lib/pry/wrapped_module.rb#206
+  def source; end
+
+  # @return [String, nil] The associated file for the module (i.e
+  #   the primary candidate: highest ranked monkeypatch).
+  #
+  # source://pry//lib/pry/wrapped_module.rb#176
+  def source_file; end
+
+  # @return [Fixnum, nil] The associated line for the module (i.e
+  #   the primary candidate: highest ranked monkeypatch).
+  #
+  # source://pry//lib/pry/wrapped_module.rb#183
+  def source_line; end
+
+  # Retrieve the source location of a module. Return value is in same
+  # format as Method#source_location. If the source location
+  # cannot be found this method returns `nil`.
+  #
+  # @return [Array<String, Fixnum>, nil] The source location of the
+  #   module (or class), or `nil` if no source location found.
+  #
+  # source://pry//lib/pry/wrapped_module.rb#168
+  def source_location; end
+
+  # @param times [Fixnum] How far to travel up the ancestor chain.
+  # @return [Pry::WrappedModule, nil] The wrapped module that is the
+  #   superclass.
+  #   When `self` is a `Module` then return the
+  #   nth ancestor, otherwise (in the case of classes) return the
+  #   nth ancestor that is a class.
+  #
+  # source://pry//lib/pry/wrapped_module.rb#270
+  def super(times = T.unsafe(nil)); end
+
+  # Returns the value of attribute wrapped.
+  #
+  # source://pry//lib/pry/wrapped_module.rb#20
+  def wrapped; end
+
+  # @return [String] Return the YARD docs for this module.
+  #
+  # source://pry//lib/pry/wrapped_module.rb#223
+  def yard_doc; end
+
+  # @return [Boolean] Whether YARD docs are available for this module.
+  #
+  # source://pry//lib/pry/wrapped_module.rb#260
+  def yard_docs?; end
+
+  # @return [String] Return the associated file for the
+  #   module from YARD, if one exists.
+  #
+  # source://pry//lib/pry/wrapped_module.rb#212
+  def yard_file; end
+
+  # @return [Fixnum] Return the associated line for the
+  #   module from YARD, if one exists.
+  #
+  # source://pry//lib/pry/wrapped_module.rb#218
+  def yard_line; end
+
+  private
+
+  # Return all methods (instance methods and class methods) for a
+  # given module.
+  #
+  # @return [Array<Pry::Method>]
+  #
+  # source://pry//lib/pry/wrapped_module.rb#347
+  def all_methods_for(mod); end
+
+  # We only want methods that have a non-nil `source_location`. We also
+  # skip some spooky internal methods.
+  #
+  # @return [Array<Pry::Method>]
+  #
+  # source://pry//lib/pry/wrapped_module.rb#329
+  def all_relevant_methods_for(mod); end
+
+  # A helper method.
+  #
+  # source://pry//lib/pry/wrapped_module.rb#310
+  def all_source_locations_by_popularity; end
+
+  # memoized lines for file
+  #
+  # source://pry//lib/pry/wrapped_module.rb#371
+  def lines_for_file(file); end
+
+  # @return [Array<Array<Pry::Method>>] The array of `Pry::Method` objects,
+  #   there are two associated with each candidate. The first is the 'base
+  #   method' for a candidate and it serves as the start point for
+  #   the search in  uncovering the module definition. The second is
+  #   the last method defined for that candidate and it is used to
+  #   speed up source code extraction.
+  #
+  # source://pry//lib/pry/wrapped_module.rb#302
+  def method_candidates; end
+
+  # Detect methods that are defined with `def_delegator` from the Forwardable
+  # module. We want to reject these methods as they screw up module
+  # extraction since the `source_location` for such methods points at forwardable.rb
+  # TODO: make this more robust as valid user-defined files called
+  # forwardable.rb are also skipped.
+  #
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/wrapped_module.rb#366
+  def method_defined_by_forwardable_module?(method); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/wrapped_module.rb#351
+  def nested_module?(parent, name); end
+
+  # @return [Pry::WrappedModule::Candidate] The candidate with the
+  #   highest rank, that is the 'monkey patch' of this module with the
+  #   highest number of methods, which contains a source code line that
+  #   defines the module. It is considered the 'canonical' definition
+  #   for the module. In the absense of a suitable candidate, the
+  #   candidate of rank 0 will be returned, or a CommandError raised if
+  #   there are no candidates at all.
+  #
+  # source://pry//lib/pry/wrapped_module.rb#292
+  def primary_candidate; end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/wrapped_module.rb#158
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+
+  class << self
+    # Convert a string to a module.
+    #
+    # @example
+    #   Pry::WrappedModule.from_str("Pry::Code")
+    # @param mod_name [String]
+    # @param target [Binding] The binding where the lookup takes place.
+    # @return [Module, nil] The module or `nil` (if conversion failed).
+    #
+    # source://pry//lib/pry/wrapped_module.rb#29
+    def from_str(mod_name, target = T.unsafe(nil)); end
+
+    private
+
+    # We use this method to decide whether code is safe to eval. Method's are
+    # generally not, but everything else is.
+    # TODO: is just checking != "method" enough??
+    # TODO: see duplication of this method in Pry::CodeObject
+    #
+    # @param str [String] The string to lookup.
+    # @param target [Binding] Where the lookup takes place.
+    # @return [Boolean]
+    #
+    # source://pry//lib/pry/wrapped_module.rb#45
+    def safe_to_evaluate?(str, target); end
+  end
+end
+
+# This class represents a single candidate for a module/class definition.
+# It provides access to the source, documentation, line and file
+# for a monkeypatch (reopening) of a class/module.
+#
+# source://pry//lib/pry/wrapped_module/candidate.rb#8
+class Pry::WrappedModule::Candidate
+  include ::Pry::Helpers::DocumentationHelpers
+  include ::Pry::CodeObject::Helpers
+  extend ::Forwardable
+  extend ::Pry::Forwardable
+
+  # @param wrapper [Pry::WrappedModule] The associated
+  #   `Pry::WrappedModule` instance that owns the candidates.
+  # @param rank [Fixnum] The rank of the candidate to
+  #   retrieve. Passing 0 returns 'primary candidate' (the candidate with largest
+  #   number of methods), passing 1 retrieves candidate with
+  #   second largest number of methods, and so on, up to
+  #   `Pry::WrappedModule#number_of_candidates() - 1`
+  # @raise [Pry::CommandError] If `rank` is out of bounds.
+  # @return [Candidate] a new instance of Candidate
+  #
+  # source://pry//lib/pry/wrapped_module/candidate.rb#38
+  def initialize(wrapper, rank); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def class?(*args, **_arg1, &block); end
+
+  # @raise [Pry::CommandError] If documentation cannot be found.
+  # @return [String] The documentation for the candidate.
+  #
+  # source://pry//lib/pry/wrapped_module/candidate.rb#70
+  def doc; end
+
+  # @return [String] The file where the module definition is located.
+  #
+  # source://pry//lib/pry/wrapped_module/candidate.rb#14
+  def file; end
+
+  # @return [Fixnum] The line where the module definition is located.
+  #
+  # source://pry//lib/pry/wrapped_module/candidate.rb#18
+  def line; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def module?(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def nonblank_name(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def number_of_candidates(*args, **_arg1, &block); end
+
+  # @raise [Pry::CommandError] If source code cannot be found.
+  # @return [String] The source for the candidate, i.e the
+  #   complete module/class definition.
+  #
+  # source://pry//lib/pry/wrapped_module/candidate.rb#59
+  def source; end
+
+  # @return [String] The file where the module definition is located.
+  #
+  # source://pry//lib/pry/wrapped_module/candidate.rb#14
+  def source_file; end
+
+  # @return [Fixnum] The line where the module definition is located.
+  #
+  # source://pry//lib/pry/wrapped_module/candidate.rb#18
+  def source_line; end
+
+  # @return [Array, nil] A `[String, Fixnum]` pair representing the
+  #   source location (file and line) for the candidate or `nil`
+  #   if no source location found.
+  #
+  # source://pry//lib/pry/wrapped_module/candidate.rb#79
+  def source_location; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def wrapped(*args, **_arg1, &block); end
+
+  private
+
+  # Locate the first line of the module definition.
+  #
+  # @param file [String] The file that contains the module
+  #   definition (somewhere).
+  # @param line [Fixnum] The module definition should appear
+  #   before this line (if it exists).
+  # @return [Fixnum] The line where the module is defined. This
+  #   line number is one-indexed.
+  #
+  # source://pry//lib/pry/wrapped_module/candidate.rb#99
+  def first_line_of_module_definition(file, line); end
+
+  # This method is used by `Candidate#source_location` as a
+  # starting point for the search for the candidate's definition.
+  #
+  # @return [Array] The source location of the base method used to
+  #   calculate the source location of the candidate.
+  #
+  # source://pry//lib/pry/wrapped_module/candidate.rb#116
+  def first_method_source_location; end
+
+  # @return [Array] The source location of the last method in this
+  #   candidate's module definition.
+  #
+  # source://pry//lib/pry/wrapped_module/candidate.rb#122
+  def last_method_source_location; end
+
+  # source://pry//lib/pry/forwardable.rb#18
+  def lines_for_file(*a, &b); end
+
+  # source://pry//lib/pry/forwardable.rb#18
+  def method_candidates(*a, &b); end
+
+  # @return [Boolean]
+  #
+  # source://pry//lib/pry/wrapped_module/candidate.rb#104
+  def module_definition_first_line?(line); end
+
+  # source://pry//lib/pry/forwardable.rb#18
+  def name(*a, &b); end
+
+  # Return the number of lines between the start of the class definition and
+  # the start of the last method. We use this value so we can quickly grab
+  # these lines from the file (without having to check each intervening line
+  # for validity, which is expensive) speeding up source extraction.
+  #
+  # @return [Integer] number of lines.
+  #
+  # source://pry//lib/pry/wrapped_module/candidate.rb#132
+  def number_of_lines_in_first_chunk; end
+
+  # source://pry//lib/pry/forwardable.rb#18
+  def yard_docs?(*a, &b); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/public_suffix@4.0.7.rbi b/Library/Homebrew/sorbet/rbi/gems/public_suffix@4.0.7.rbi
deleted file mode 100644
index 6973c1b0c08e5..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/public_suffix@4.0.7.rbi
+++ /dev/null
@@ -1,145 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `public_suffix` gem.
-# Please instead update this file by running `bin/tapioca gem public_suffix`.
-
-module PublicSuffix
-  class << self
-    def decompose(name, rule); end
-    def domain(name, **options); end
-    def normalize(name); end
-    def parse(name, list: T.unsafe(nil), default_rule: T.unsafe(nil), ignore_private: T.unsafe(nil)); end
-    def valid?(name, list: T.unsafe(nil), default_rule: T.unsafe(nil), ignore_private: T.unsafe(nil)); end
-  end
-end
-
-PublicSuffix::BANG = T.let(T.unsafe(nil), String)
-PublicSuffix::DOT = T.let(T.unsafe(nil), String)
-
-class PublicSuffix::Domain
-  def initialize(*args); end
-
-  def domain; end
-  def domain?; end
-  def name; end
-  def sld; end
-  def subdomain; end
-  def subdomain?; end
-  def tld; end
-  def to_a; end
-  def to_s; end
-  def trd; end
-
-  class << self
-    def name_to_labels(name); end
-  end
-end
-
-class PublicSuffix::DomainInvalid < ::PublicSuffix::Error; end
-class PublicSuffix::DomainNotAllowed < ::PublicSuffix::DomainInvalid; end
-class PublicSuffix::Error < ::StandardError; end
-
-class PublicSuffix::List
-  def initialize; end
-
-  def <<(rule); end
-  def ==(other); end
-  def add(rule); end
-  def clear; end
-  def default_rule; end
-  def each(&block); end
-  def empty?; end
-  def eql?(other); end
-  def find(name, default: T.unsafe(nil), **options); end
-  def size; end
-
-  protected
-
-  def rules; end
-
-  private
-
-  def entry_to_rule(entry, value); end
-  def rule_to_entry(rule); end
-  def select(name, ignore_private: T.unsafe(nil)); end
-
-  class << self
-    def default(**options); end
-    def default=(value); end
-    def parse(input, private_domains: T.unsafe(nil)); end
-  end
-end
-
-PublicSuffix::List::DEFAULT_LIST_PATH = T.let(T.unsafe(nil), String)
-
-module PublicSuffix::Rule
-  class << self
-    def default; end
-    def factory(content, private: T.unsafe(nil)); end
-  end
-end
-
-class PublicSuffix::Rule::Base
-  def initialize(value:, length: T.unsafe(nil), private: T.unsafe(nil)); end
-
-  def ==(other); end
-  def decompose(*_arg0); end
-  def eql?(other); end
-  def length; end
-  def match?(name); end
-  def parts; end
-  def private; end
-  def value; end
-
-  class << self
-    def build(content, private: T.unsafe(nil)); end
-  end
-end
-
-class PublicSuffix::Rule::Entry < ::Struct
-  def length; end
-  def length=(_); end
-  def private; end
-  def private=(_); end
-  def type; end
-  def type=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class PublicSuffix::Rule::Exception < ::PublicSuffix::Rule::Base
-  def decompose(domain); end
-  def parts; end
-  def rule; end
-
-  class << self
-    def build(content, private: T.unsafe(nil)); end
-  end
-end
-
-class PublicSuffix::Rule::Normal < ::PublicSuffix::Rule::Base
-  def decompose(domain); end
-  def parts; end
-  def rule; end
-end
-
-class PublicSuffix::Rule::Wildcard < ::PublicSuffix::Rule::Base
-  def initialize(value:, length: T.unsafe(nil), private: T.unsafe(nil)); end
-
-  def decompose(domain); end
-  def parts; end
-  def rule; end
-
-  class << self
-    def build(content, private: T.unsafe(nil)); end
-  end
-end
-
-PublicSuffix::STAR = T.let(T.unsafe(nil), String)
-PublicSuffix::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/racc@1.6.0.rbi b/Library/Homebrew/sorbet/rbi/gems/racc@1.6.0.rbi
deleted file mode 100644
index 93e67bf5e012a..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/racc@1.6.0.rbi
+++ /dev/null
@@ -1,639 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `racc` gem.
-# Please instead update this file by running `bin/tapioca gem racc`.
-
-::RUBY19 = T.let(T.unsafe(nil), TrueClass)
-
-class Object < ::BasicObject
-  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
-  include ::ActiveSupport::ForkTracker::CoreExt
-  include ::ActiveSupport::ForkTracker::CoreExtPrivate
-  include ::Kernel
-  include ::JSON::Ext::Generator::GeneratorMethods::Object
-  include ::PP::ObjectMixin
-  include ::ActiveSupport::Dependencies::Loadable
-  include ::ActiveSupport::Tryable
-end
-
-ParseError = Racc::ParseError
-
-class Racc::Accept
-  def inspect; end
-end
-
-class Racc::ActionTable
-  def initialize(rt, st); end
-
-  def accept; end
-  def each_reduce(&block); end
-  def each_shift(&block); end
-  def error; end
-  def init; end
-  def reduce(i); end
-  def reduce_n; end
-  def shift(i); end
-  def shift_n; end
-end
-
-class Racc::CompileError < ::Racc::Error; end
-Racc::Copyright = T.let(T.unsafe(nil), String)
-
-class Racc::DebugFlags
-  def initialize(parse = T.unsafe(nil), rule = T.unsafe(nil), token = T.unsafe(nil), state = T.unsafe(nil), la = T.unsafe(nil), prec = T.unsafe(nil), conf = T.unsafe(nil)); end
-
-  def any?; end
-  def la; end
-  def parse; end
-  def prec; end
-  def rule; end
-  def state; end
-  def status_logging; end
-  def token; end
-
-  class << self
-    def parse_option_string(s); end
-  end
-end
-
-class Racc::Error < ::StandardError
-  def inspect; end
-end
-
-class Racc::Goto
-  def initialize(ident, sym, from, to); end
-
-  def from_state; end
-  def ident; end
-  def inspect; end
-  def symbol; end
-  def to_state; end
-end
-
-class Racc::Grammar
-  extend ::Forwardable
-
-  def initialize(debug_flags = T.unsafe(nil)); end
-
-  def [](x); end
-  def add(rule); end
-  def added?(sym); end
-  def declare_precedence(assoc, syms); end
-  def dfa; end
-  def each(&block); end
-  def each_index(&block); end
-  def each_nonterminal(*args, &block); end
-  def each_rule(&block); end
-  def each_symbol(*args, &block); end
-  def each_terminal(*args, &block); end
-  def each_useless_nonterminal; end
-  def each_useless_rule; end
-  def each_with_index(&block); end
-  def end_precedence_declaration(reverse); end
-  def init; end
-  def intern(value, dummy = T.unsafe(nil)); end
-  def n_expected_srconflicts; end
-  def n_expected_srconflicts=(_arg0); end
-  def n_useless_nonterminals; end
-  def n_useless_rules; end
-  def nfa; end
-  def nonterminal_base; end
-  def parser_class; end
-  def size; end
-  def start; end
-  def start_symbol=(s); end
-  def state_transition_table; end
-  def states; end
-  def symbols; end
-  def symboltable; end
-  def to_s; end
-  def useless_nonterminal_exist?; end
-  def useless_rule_exist?; end
-  def write_log(path); end
-
-  private
-
-  def _compute_expand(t, set, lock); end
-  def add_start_rule; end
-  def check_rules_nullable(rules); end
-  def check_rules_useless(rules); end
-  def check_symbols_nullable(symbols); end
-  def check_symbols_useless(s); end
-  def compute_expand(t); end
-  def compute_hash; end
-  def compute_heads; end
-  def compute_locate; end
-  def compute_nullable; end
-  def compute_nullable_0; end
-  def compute_useless; end
-  def determine_terminals; end
-  def fix_ident; end
-
-  class << self
-    def define(&block); end
-  end
-end
-
-class Racc::Grammar::DefinitionEnv
-  def initialize; end
-
-  def _(&block); end
-  def _add(target, x); end
-  def _added?(sym); end
-  def _delayed_add(rule); end
-  def _intern(x); end
-  def action(&block); end
-  def flush_delayed; end
-  def grammar; end
-  def many(sym, &block); end
-  def many1(sym, &block); end
-  def method_missing(mid, *args, &block); end
-  def null(&block); end
-  def option(sym, default = T.unsafe(nil), &block); end
-  def precedence_table(&block); end
-  def separated_by(sep, sym, &block); end
-  def separated_by1(sep, sym, &block); end
-  def seq(*list, &block); end
-
-  private
-
-  def _defmetasyntax(type, id, action, &block); end
-  def _regist(target_name); end
-  def _wrap(target_name, sym, block); end
-end
-
-class Racc::Grammar::PrecedenceDefinitionEnv
-  def initialize(g); end
-
-  def higher; end
-  def left(*syms); end
-  def lower; end
-  def nonassoc(*syms); end
-  def reverse; end
-  def right(*syms); end
-end
-
-class Racc::ISet
-  def initialize(a = T.unsafe(nil)); end
-
-  def [](key); end
-  def []=(key, val); end
-  def add(i); end
-  def clear; end
-  def delete(key); end
-  def dup; end
-  def each(&block); end
-  def empty?; end
-  def include?(key); end
-  def inspect; end
-  def key?(key); end
-  def set; end
-  def size; end
-  def to_a; end
-  def to_s; end
-  def update(other); end
-  def update_a(a); end
-end
-
-class Racc::Item
-  def initialize(rule, la); end
-
-  def each_la(tbl); end
-  def la; end
-  def rule; end
-end
-
-class Racc::LocationPointer
-  def initialize(rule, i, sym); end
-
-  def ==(ot); end
-  def before(len); end
-  def dereference; end
-  def eql?(ot); end
-  def hash; end
-  def head?; end
-  def ident; end
-  def increment; end
-  def index; end
-  def inspect; end
-  def next; end
-  def reduce; end
-  def reduce?; end
-  def rule; end
-  def symbol; end
-  def to_s; end
-
-  private
-
-  def ptr_bug!; end
-end
-
-class Racc::LogFileGenerator
-  def initialize(states, debug_flags = T.unsafe(nil)); end
-
-  def action_out(f, state); end
-  def outact(f, t, act); end
-  def output(out); end
-  def output_conflict(out); end
-  def output_rule(out); end
-  def output_state(out); end
-  def output_token(out); end
-  def output_useless(out); end
-  def outrrconf(f, confs); end
-  def outsrconf(f, confs); end
-  def pointer_out(out, ptr); end
-  def symbol_locations(locs); end
-end
-
-class Racc::OrMark
-  def initialize(lineno); end
-
-  def inspect; end
-  def lineno; end
-  def name; end
-end
-
-class Racc::Parser
-  def _racc_do_parse_rb(arg, in_debug); end
-  def _racc_do_reduce(arg, act); end
-  def _racc_evalact(act, arg); end
-  def _racc_init_sysvars; end
-  def _racc_setup; end
-  def _racc_yyparse_rb(recv, mid, arg, c_debug); end
-  def next_token; end
-  def on_error(t, val, vstack); end
-  def racc_accept; end
-  def racc_e_pop(state, tstack, vstack); end
-  def racc_next_state(curstate, state); end
-  def racc_print_stacks(t, v); end
-  def racc_print_states(s); end
-  def racc_read_token(t, tok, val); end
-  def racc_reduce(toks, sim, tstack, vstack); end
-  def racc_shift(tok, tstack, vstack); end
-  def racc_token2str(tok); end
-  def token_to_str(t); end
-  def yyaccept; end
-  def yyerrok; end
-  def yyerror; end
-
-  class << self
-    def racc_runtime_type; end
-  end
-end
-
-Racc::Parser::Racc_Main_Parsing_Routine = T.let(T.unsafe(nil), Symbol)
-Racc::Parser::Racc_Runtime_Core_Id_C = T.let(T.unsafe(nil), String)
-Racc::Parser::Racc_Runtime_Core_Version = T.let(T.unsafe(nil), String)
-Racc::Parser::Racc_Runtime_Core_Version_C = T.let(T.unsafe(nil), String)
-Racc::Parser::Racc_Runtime_Core_Version_R = T.let(T.unsafe(nil), String)
-Racc::Parser::Racc_Runtime_Type = T.let(T.unsafe(nil), String)
-Racc::Parser::Racc_Runtime_Version = T.let(T.unsafe(nil), String)
-Racc::Parser::Racc_YY_Parse_Method = T.let(T.unsafe(nil), Symbol)
-
-class Racc::ParserClassGenerator
-  def initialize(states); end
-
-  def generate; end
-
-  private
-
-  def define_actions(c); end
-end
-
-class Racc::Prec
-  def initialize(symbol, lineno); end
-
-  def inspect; end
-  def lineno; end
-  def name; end
-  def symbol; end
-end
-
-class Racc::RRconflict
-  def initialize(sid, high, low, tok); end
-
-  def high_prec; end
-  def low_prec; end
-  def stateid; end
-  def to_s; end
-  def token; end
-end
-
-class Racc::Reduce
-  def initialize(rule); end
-
-  def decref; end
-  def incref; end
-  def inspect; end
-  def refn; end
-  def rule; end
-  def ruleid; end
-end
-
-class Racc::Rule
-  def initialize(target, syms, act); end
-
-  def ==(other); end
-  def [](idx); end
-  def accept?; end
-  def action; end
-  def each(&block); end
-  def each_rule(&block); end
-  def empty?; end
-  def hash; end
-  def hash=(n); end
-  def ident; end
-  def ident=(_arg0); end
-  def inspect; end
-  def null=(n); end
-  def nullable?; end
-  def prec(sym, &block); end
-  def precedence; end
-  def precedence=(sym); end
-  def ptrs; end
-  def replace(src, dest); end
-  def rule; end
-  def size; end
-  def specified_prec; end
-  def specified_prec=(_arg0); end
-  def symbols; end
-  def target; end
-  def target=(_arg0); end
-  def to_s; end
-  def useless=(u); end
-  def useless?; end
-  def |(x); end
-end
-
-class Racc::SRconflict
-  def initialize(sid, shift, reduce); end
-
-  def reduce; end
-  def shift; end
-  def stateid; end
-  def to_s; end
-end
-
-class Racc::Shift
-  def initialize(goto); end
-
-  def goto_id; end
-  def goto_state; end
-  def inspect; end
-end
-
-class Racc::SourceText
-  def initialize(text, filename, lineno); end
-
-  def filename; end
-  def lineno; end
-  def location; end
-  def text; end
-  def to_s; end
-end
-
-class Racc::State
-  def initialize(ident, core); end
-
-  def ==(oth); end
-  def action; end
-  def check_la(la_rules); end
-  def closure; end
-  def conflict?; end
-  def core; end
-  def defact; end
-  def defact=(_arg0); end
-  def eql?(oth); end
-  def goto_table; end
-  def gotos; end
-  def hash; end
-  def ident; end
-  def inspect; end
-  def la=(la); end
-  def make_closure(core); end
-  def n_rrconflicts; end
-  def n_srconflicts; end
-  def ritems; end
-  def rr_conflict(high, low, ctok); end
-  def rrconf; end
-  def rruleid(rule); end
-  def rrules; end
-  def sr_conflict(shift, reduce); end
-  def srconf; end
-  def stateid; end
-  def stokens; end
-  def to_s; end
-end
-
-class Racc::StateTransitionTable < ::Struct
-  def initialize(states); end
-
-  def action_check; end
-  def action_check=(_); end
-  def action_default; end
-  def action_default=(_); end
-  def action_pointer; end
-  def action_pointer=(_); end
-  def action_table; end
-  def action_table=(_); end
-  def debug_parser; end
-  def debug_parser=(_); end
-  def goto_check; end
-  def goto_check=(_); end
-  def goto_default; end
-  def goto_default=(_); end
-  def goto_pointer; end
-  def goto_pointer=(_); end
-  def goto_table; end
-  def goto_table=(_); end
-  def grammar; end
-  def nt_base; end
-  def nt_base=(_); end
-  def parser_class; end
-  def reduce_n; end
-  def reduce_n=(_); end
-  def reduce_table; end
-  def reduce_table=(_); end
-  def shift_n; end
-  def shift_n=(_); end
-  def states; end
-  def token_table; end
-  def token_table=(_); end
-  def token_to_s_table; end
-  def token_to_s_table=(_); end
-  def token_value_table; end
-  def use_result_var; end
-  def use_result_var=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def generate(states); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class Racc::StateTransitionTableGenerator
-  def initialize(states); end
-
-  def act2actid(act); end
-  def addent(all, arr, chkval, ptr); end
-  def gen_action_tables(t, states); end
-  def gen_goto_tables(t, grammar); end
-  def generate; end
-  def mkmapexp(arr); end
-  def reduce_table(grammar); end
-  def set_table(entries, dummy, tbl, chk, ptr); end
-  def token_table(grammar); end
-end
-
-Racc::StateTransitionTableGenerator::RE_DUP_MAX = T.let(T.unsafe(nil), Integer)
-
-class Racc::States
-  include ::Enumerable
-  extend ::Forwardable
-
-  def initialize(grammar, debug_flags = T.unsafe(nil)); end
-
-  def [](i); end
-  def actions; end
-  def dfa; end
-  def each(&block); end
-  def each_index(&block); end
-  def each_state(&block); end
-  def grammar; end
-  def inspect; end
-  def n_rrconflicts; end
-  def n_srconflicts; end
-  def nfa; end
-  def nt_base(*args, &block); end
-  def reduce_n(*args, &block); end
-  def rrconflict_exist?; end
-  def shift_n(*args, &block); end
-  def should_report_srconflict?; end
-  def size; end
-  def srconflict_exist?; end
-  def state_transition_table; end
-  def to_s; end
-
-  private
-
-  def addrel(tbl, i, item); end
-  def addsym(table, sym, ptr); end
-  def check_useless; end
-  def compute_dfa; end
-  def compute_nfa; end
-  def core_to_state(core); end
-  def create_tmap(size); end
-  def digraph(map, relation); end
-  def do_resolve_sr(stok, rtok); end
-  def each_t(tbl, set); end
-  def fingerprint(arr); end
-  def generate_states(state); end
-  def lookahead; end
-  def pack(state); end
-  def print_atab(idx, tab); end
-  def print_tab(idx, rel, tab); end
-  def print_tab_i(idx, rel, tab, i); end
-  def printb(i); end
-  def record_path(begst, rule); end
-  def resolve(state); end
-  def resolve_rr(state, r); end
-  def resolve_sr(state, s); end
-  def set_accept; end
-  def transpose(rel); end
-  def traverse(i, index, vertices, map, relation); end
-end
-
-Racc::States::ASSOC = T.let(T.unsafe(nil), Hash)
-
-class Racc::Sym
-  def initialize(value, dummyp); end
-
-  def assoc; end
-  def assoc=(_arg0); end
-  def dummy?; end
-  def expand; end
-  def expand=(v); end
-  def hash; end
-  def heads; end
-  def ident; end
-  def ident=(v); end
-  def inspect; end
-  def locate; end
-  def nonterminal?; end
-  def null=(n); end
-  def nullable?; end
-  def precedence; end
-  def precedence=(_arg0); end
-  def rule; end
-  def self_null?; end
-  def serialize; end
-  def serialized=(_arg0); end
-  def should_terminal; end
-  def should_terminal?; end
-  def snull=(v); end
-  def string_symbol?; end
-  def term=(t); end
-  def terminal?; end
-  def to_s; end
-  def useless=(f); end
-  def useless?; end
-  def value; end
-  def |(x); end
-
-  class << self
-    def once_writer(nm); end
-  end
-end
-
-class Racc::SymbolTable
-  include ::Enumerable
-
-  def initialize; end
-
-  def [](id); end
-  def anchor; end
-  def delete(sym); end
-  def dummy; end
-  def each(&block); end
-  def each_nonterminal(&block); end
-  def each_terminal(&block); end
-  def error; end
-  def fix; end
-  def intern(val, dummy = T.unsafe(nil)); end
-  def nonterminals; end
-  def nt_base; end
-  def nt_max; end
-  def symbols; end
-  def terminals(&block); end
-  def to_a; end
-
-  private
-
-  def check_terminals; end
-  def fix_ident; end
-end
-
-class Racc::UserAction
-  def initialize(src, proc); end
-
-  def empty?; end
-  def inspect; end
-  def name; end
-  def proc; end
-  def proc?; end
-  def source; end
-  def source?; end
-
-  class << self
-    def empty; end
-    def proc(pr = T.unsafe(nil), &block); end
-    def source_text(src); end
-  end
-end
-
-Racc::VERSION = T.let(T.unsafe(nil), String)
-Racc::Version = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rack@2.2.4.rbi b/Library/Homebrew/sorbet/rbi/gems/rack@2.2.4.rbi
deleted file mode 100644
index bcd16f3d6d490..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rack@2.2.4.rbi
+++ /dev/null
@@ -1,1624 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rack` gem.
-# Please instead update this file by running `bin/tapioca gem rack`.
-
-module Rack
-  class << self
-    def release; end
-    def version; end
-  end
-end
-
-module Rack::Auth; end
-
-class Rack::Auth::AbstractHandler
-  def initialize(app, realm = T.unsafe(nil), &authenticator); end
-
-  def realm; end
-  def realm=(_arg0); end
-
-  private
-
-  def bad_request; end
-  def unauthorized(www_authenticate = T.unsafe(nil)); end
-end
-
-class Rack::Auth::AbstractRequest
-  def initialize(env); end
-
-  def params; end
-  def parts; end
-  def provided?; end
-  def request; end
-  def scheme; end
-  def valid?; end
-
-  private
-
-  def authorization_key; end
-end
-
-Rack::Auth::AbstractRequest::AUTHORIZATION_KEYS = T.let(T.unsafe(nil), Array)
-
-class Rack::Auth::Basic < ::Rack::Auth::AbstractHandler
-  def call(env); end
-
-  private
-
-  def challenge; end
-  def valid?(auth); end
-end
-
-class Rack::Auth::Basic::Request < ::Rack::Auth::AbstractRequest
-  def basic?; end
-  def credentials; end
-  def username; end
-end
-
-module Rack::Auth::Digest; end
-
-class Rack::Auth::Digest::MD5 < ::Rack::Auth::AbstractHandler
-  def initialize(app, realm = T.unsafe(nil), opaque = T.unsafe(nil), &authenticator); end
-
-  def call(env); end
-  def opaque; end
-  def opaque=(_arg0); end
-  def passwords_hashed=(_arg0); end
-  def passwords_hashed?; end
-
-  private
-
-  def A1(auth, password); end
-  def A2(auth); end
-  def H(data); end
-  def KD(secret, data); end
-  def challenge(hash = T.unsafe(nil)); end
-  def digest(auth, password); end
-  def md5(data); end
-  def params(hash = T.unsafe(nil)); end
-  def valid?(auth); end
-  def valid_digest?(auth); end
-  def valid_nonce?(auth); end
-  def valid_opaque?(auth); end
-  def valid_qop?(auth); end
-end
-
-Rack::Auth::Digest::MD5::QOP = T.let(T.unsafe(nil), String)
-
-class Rack::Auth::Digest::Nonce
-  def initialize(timestamp = T.unsafe(nil), given_digest = T.unsafe(nil)); end
-
-  def digest; end
-  def fresh?; end
-  def stale?; end
-  def to_s; end
-  def valid?; end
-
-  class << self
-    def parse(string); end
-    def private_key; end
-    def private_key=(_arg0); end
-    def time_limit; end
-    def time_limit=(_arg0); end
-  end
-end
-
-class Rack::Auth::Digest::Params < ::Hash
-  def initialize; end
-
-  def [](k); end
-  def []=(k, v); end
-  def quote(str); end
-  def to_s; end
-
-  class << self
-    def dequote(str); end
-    def parse(str); end
-    def split_header_value(str); end
-  end
-end
-
-Rack::Auth::Digest::Params::UNQUOTED = T.let(T.unsafe(nil), Array)
-
-class Rack::Auth::Digest::Request < ::Rack::Auth::AbstractRequest
-  def correct_uri?; end
-  def digest?; end
-  def method; end
-  def method_missing(sym, *args); end
-  def nonce; end
-  def params; end
-  def respond_to?(sym, *_arg1); end
-end
-
-class Rack::BodyProxy
-  def initialize(body, &block); end
-
-  def close; end
-  def closed?; end
-  def method_missing(method_name, *args, &block); end
-
-  private
-
-  def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end
-end
-
-class Rack::Builder
-  def initialize(default_app = T.unsafe(nil), &block); end
-
-  def call(env); end
-  def freeze_app; end
-  def map(path, &block); end
-  def run(app); end
-  def to_app; end
-  def use(middleware, *args, &block); end
-  def warmup(prc = T.unsafe(nil), &block); end
-
-  private
-
-  def generate_map(default_app, mapping); end
-
-  class << self
-    def app(default_app = T.unsafe(nil), &block); end
-    def load_file(path, opts = T.unsafe(nil)); end
-    def new_from_string(builder_script, file = T.unsafe(nil)); end
-    def parse_file(config, opts = T.unsafe(nil)); end
-  end
-end
-
-Rack::Builder::UTF_8_BOM = T.let(T.unsafe(nil), String)
-Rack::CACHE_CONTROL = T.let(T.unsafe(nil), String)
-Rack::CONTENT_LENGTH = T.let(T.unsafe(nil), String)
-Rack::CONTENT_TYPE = T.let(T.unsafe(nil), String)
-
-class Rack::Cascade
-  def initialize(apps, cascade_for = T.unsafe(nil)); end
-
-  def <<(app); end
-  def add(app); end
-  def apps; end
-  def call(env); end
-  def include?(app); end
-end
-
-Rack::Cascade::NotFound = T.let(T.unsafe(nil), Array)
-
-class Rack::Chunked
-  include ::Rack::Utils
-
-  def initialize(app); end
-
-  def call(env); end
-  def chunkable_version?(ver); end
-end
-
-class Rack::Chunked::Body
-  def initialize(body); end
-
-  def close; end
-  def each(&block); end
-
-  private
-
-  def yield_trailers; end
-end
-
-Rack::Chunked::Body::TAIL = T.let(T.unsafe(nil), String)
-Rack::Chunked::Body::TERM = T.let(T.unsafe(nil), String)
-
-class Rack::Chunked::TrailerBody < ::Rack::Chunked::Body
-  private
-
-  def yield_trailers; end
-end
-
-class Rack::CommonLogger
-  def initialize(app, logger = T.unsafe(nil)); end
-
-  def call(env); end
-
-  private
-
-  def extract_content_length(headers); end
-  def log(env, status, header, began_at); end
-end
-
-Rack::CommonLogger::FORMAT = T.let(T.unsafe(nil), String)
-
-class Rack::ConditionalGet
-  def initialize(app); end
-
-  def call(env); end
-
-  private
-
-  def etag_matches?(none_match, headers); end
-  def fresh?(env, headers); end
-  def modified_since?(modified_since, headers); end
-  def to_rfc2822(since); end
-end
-
-class Rack::Config
-  def initialize(app, &block); end
-
-  def call(env); end
-end
-
-class Rack::ContentLength
-  include ::Rack::Utils
-
-  def initialize(app); end
-
-  def call(env); end
-end
-
-class Rack::ContentType
-  include ::Rack::Utils
-
-  def initialize(app, content_type = T.unsafe(nil)); end
-
-  def call(env); end
-end
-
-Rack::DELETE = T.let(T.unsafe(nil), String)
-
-class Rack::Deflater
-  def initialize(app, options = T.unsafe(nil)); end
-
-  def call(env); end
-
-  private
-
-  def should_deflate?(env, status, headers, body); end
-end
-
-class Rack::Deflater::GzipStream
-  def initialize(body, mtime, sync); end
-
-  def close; end
-  def each(&block); end
-  def write(data); end
-end
-
-class Rack::Directory
-  def initialize(root, app = T.unsafe(nil)); end
-
-  def call(env); end
-  def check_bad_request(path_info); end
-  def check_forbidden(path_info); end
-  def entity_not_found(path_info); end
-  def filesize_format(int); end
-  def get(env); end
-  def list_directory(path_info, path, script_name); end
-  def list_path(env, path, path_info, script_name); end
-  def root; end
-  def stat(path); end
-end
-
-Rack::Directory::DIR_FILE = T.let(T.unsafe(nil), String)
-Rack::Directory::DIR_PAGE_FOOTER = T.let(T.unsafe(nil), String)
-Rack::Directory::DIR_PAGE_HEADER = T.let(T.unsafe(nil), String)
-
-class Rack::Directory::DirectoryBody < ::Struct
-  def each; end
-
-  private
-
-  def DIR_FILE_escape(htmls); end
-end
-
-Rack::Directory::FILESIZE_FORMAT = T.let(T.unsafe(nil), Array)
-Rack::ETAG = T.let(T.unsafe(nil), String)
-
-class Rack::ETag
-  def initialize(app, no_cache_control = T.unsafe(nil), cache_control = T.unsafe(nil)); end
-
-  def call(env); end
-
-  private
-
-  def digest_body(body); end
-  def etag_body?(body); end
-  def etag_status?(status); end
-  def skip_caching?(headers); end
-end
-
-Rack::ETag::DEFAULT_CACHE_CONTROL = T.let(T.unsafe(nil), String)
-Rack::ETag::ETAG_STRING = T.let(T.unsafe(nil), String)
-Rack::EXPIRES = T.let(T.unsafe(nil), String)
-
-class Rack::Events
-  def initialize(app, handlers); end
-
-  def call(env); end
-
-  private
-
-  def make_request(env); end
-  def make_response(status, headers, body); end
-  def on_commit(request, response); end
-  def on_error(request, response, e); end
-  def on_finish(request, response); end
-  def on_start(request, response); end
-end
-
-module Rack::Events::Abstract
-  def on_commit(req, res); end
-  def on_error(req, res, e); end
-  def on_finish(req, res); end
-  def on_send(req, res); end
-  def on_start(req, res); end
-end
-
-class Rack::Events::BufferedResponse < ::Rack::Response::Raw
-  def initialize(status, headers, body); end
-
-  def body; end
-  def to_a; end
-end
-
-class Rack::Events::EventedBodyProxy < ::Rack::BodyProxy
-  def initialize(body, request, response, handlers, &block); end
-
-  def each; end
-  def request; end
-  def response; end
-end
-
-Rack::File = Rack::Files
-
-class Rack::Files
-  def initialize(root, headers = T.unsafe(nil), default_mime = T.unsafe(nil)); end
-
-  def call(env); end
-  def get(env); end
-  def root; end
-  def serving(request, path); end
-
-  private
-
-  def fail(status, body, headers = T.unsafe(nil)); end
-  def filesize(path); end
-  def mime_type(path, default_mime); end
-
-  class << self
-    def method_added(name); end
-  end
-end
-
-Rack::Files::ALLOWED_VERBS = T.let(T.unsafe(nil), Array)
-Rack::Files::ALLOW_HEADER = T.let(T.unsafe(nil), String)
-
-class Rack::Files::BaseIterator
-  def initialize(path, ranges, options); end
-
-  def bytesize; end
-  def close; end
-  def each; end
-  def options; end
-  def path; end
-  def ranges; end
-
-  private
-
-  def each_range_part(file, range); end
-  def multipart?; end
-  def multipart_heading(range); end
-end
-
-class Rack::Files::Iterator < ::Rack::Files::BaseIterator
-  def to_path; end
-end
-
-Rack::Files::MULTIPART_BOUNDARY = T.let(T.unsafe(nil), String)
-
-class Rack::ForwardRequest < ::Exception
-  def initialize(url, env = T.unsafe(nil)); end
-
-  def env; end
-  def url; end
-end
-
-Rack::GET = T.let(T.unsafe(nil), String)
-Rack::HEAD = T.let(T.unsafe(nil), String)
-Rack::HTTPS = T.let(T.unsafe(nil), String)
-Rack::HTTP_COOKIE = T.let(T.unsafe(nil), String)
-Rack::HTTP_HOST = T.let(T.unsafe(nil), String)
-Rack::HTTP_PORT = T.let(T.unsafe(nil), String)
-Rack::HTTP_VERSION = T.let(T.unsafe(nil), String)
-
-module Rack::Handler
-  class << self
-    def default; end
-    def get(server); end
-    def pick(server_names); end
-    def register(server, klass); end
-    def try_require(prefix, const_name); end
-  end
-end
-
-class Rack::Handler::CGI
-  class << self
-    def run(app, **options); end
-    def send_body(body); end
-    def send_headers(status, headers); end
-    def serve(app); end
-  end
-end
-
-Rack::Handler::SERVER_NAMES = T.let(T.unsafe(nil), Array)
-
-class Rack::Handler::WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
-  def initialize(server, app); end
-
-  def service(req, res); end
-
-  class << self
-    def run(app, **options); end
-    def shutdown; end
-    def valid_options; end
-  end
-end
-
-class Rack::Head
-  def initialize(app); end
-
-  def call(env); end
-end
-
-Rack::LINK = T.let(T.unsafe(nil), String)
-
-class Rack::Lint
-  include ::Rack::Lint::Assertion
-
-  def initialize(app); end
-
-  def _call(env); end
-  def call(env = T.unsafe(nil)); end
-  def check_content_length(status, headers); end
-  def check_content_type(status, headers); end
-  def check_env(env); end
-  def check_error(error); end
-  def check_headers(header); end
-  def check_hijack(env); end
-  def check_hijack_response(headers, env); end
-  def check_input(input); end
-  def check_status(status); end
-  def close; end
-  def each; end
-  def verify_content_length(bytes); end
-end
-
-module Rack::Lint::Assertion
-  def assert(message); end
-end
-
-class Rack::Lint::ErrorWrapper
-  include ::Rack::Lint::Assertion
-
-  def initialize(error); end
-
-  def close(*args); end
-  def flush; end
-  def puts(str); end
-  def write(str); end
-end
-
-class Rack::Lint::HijackWrapper
-  include ::Rack::Lint::Assertion
-  extend ::Forwardable
-
-  def initialize(io); end
-
-  def close(*args, &block); end
-  def close_read(*args, &block); end
-  def close_write(*args, &block); end
-  def closed?(*args, &block); end
-  def flush(*args, &block); end
-  def read(*args, &block); end
-  def read_nonblock(*args, &block); end
-  def write(*args, &block); end
-  def write_nonblock(*args, &block); end
-end
-
-Rack::Lint::HijackWrapper::REQUIRED_METHODS = T.let(T.unsafe(nil), Array)
-
-class Rack::Lint::InputWrapper
-  include ::Rack::Lint::Assertion
-
-  def initialize(input); end
-
-  def close(*args); end
-  def each(*args); end
-  def gets(*args); end
-  def read(*args); end
-  def rewind(*args); end
-end
-
-class Rack::Lint::LintError < ::RuntimeError; end
-
-class Rack::Lock
-  def initialize(app, mutex = T.unsafe(nil)); end
-
-  def call(env); end
-
-  private
-
-  def unlock; end
-end
-
-class Rack::Logger
-  def initialize(app, level = T.unsafe(nil)); end
-
-  def call(env); end
-end
-
-class Rack::MediaType
-  class << self
-    def params(content_type); end
-    def type(content_type); end
-
-    private
-
-    def strip_doublequotes(str); end
-  end
-end
-
-Rack::MediaType::SPLIT_PATTERN = T.let(T.unsafe(nil), Regexp)
-
-class Rack::MethodOverride
-  def initialize(app); end
-
-  def call(env); end
-  def method_override(env); end
-
-  private
-
-  def allowed_methods; end
-  def method_override_param(req); end
-end
-
-Rack::MethodOverride::ALLOWED_METHODS = T.let(T.unsafe(nil), Array)
-Rack::MethodOverride::HTTP_METHODS = T.let(T.unsafe(nil), Array)
-Rack::MethodOverride::HTTP_METHOD_OVERRIDE_HEADER = T.let(T.unsafe(nil), String)
-Rack::MethodOverride::METHOD_OVERRIDE_PARAM_KEY = T.let(T.unsafe(nil), String)
-
-module Rack::Mime
-  private
-
-  def match?(value, matcher); end
-  def mime_type(ext, fallback = T.unsafe(nil)); end
-
-  class << self
-    def match?(value, matcher); end
-    def mime_type(ext, fallback = T.unsafe(nil)); end
-  end
-end
-
-Rack::Mime::MIME_TYPES = T.let(T.unsafe(nil), Hash)
-
-class Rack::MockRequest
-  def initialize(app); end
-
-  def delete(uri, opts = T.unsafe(nil)); end
-  def get(uri, opts = T.unsafe(nil)); end
-  def head(uri, opts = T.unsafe(nil)); end
-  def options(uri, opts = T.unsafe(nil)); end
-  def patch(uri, opts = T.unsafe(nil)); end
-  def post(uri, opts = T.unsafe(nil)); end
-  def put(uri, opts = T.unsafe(nil)); end
-  def request(method = T.unsafe(nil), uri = T.unsafe(nil), opts = T.unsafe(nil)); end
-
-  class << self
-    def env_for(uri = T.unsafe(nil), opts = T.unsafe(nil)); end
-    def parse_uri_rfc2396(uri); end
-  end
-end
-
-Rack::MockRequest::DEFAULT_ENV = T.let(T.unsafe(nil), Hash)
-
-class Rack::MockRequest::FatalWarner
-  def flush; end
-  def puts(warning); end
-  def string; end
-  def write(warning); end
-end
-
-class Rack::MockRequest::FatalWarning < ::RuntimeError; end
-
-class Rack::MockResponse < ::Rack::Response
-  def initialize(status, headers, body, errors = T.unsafe(nil)); end
-
-  def =~(other); end
-  def body; end
-  def cookie(name); end
-  def cookies; end
-  def empty?; end
-  def errors; end
-  def errors=(_arg0); end
-  def match(other); end
-  def original_headers; end
-
-  private
-
-  def identify_cookie_attributes(cookie_filling); end
-  def parse_cookies_from_header; end
-
-  class << self
-    def [](*_arg0); end
-  end
-end
-
-module Rack::Multipart
-  class << self
-    def build_multipart(params, first = T.unsafe(nil)); end
-    def extract_multipart(req, params = T.unsafe(nil)); end
-    def parse_multipart(env, params = T.unsafe(nil)); end
-  end
-end
-
-Rack::Multipart::ATTRIBUTE = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::ATTRIBUTE_CHAR = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::BROKEN = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::CONDISP = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::DISPPARM = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::EOL = T.let(T.unsafe(nil), String)
-Rack::Multipart::EXTENDED_INITIAL_NAME = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::EXTENDED_INITIAL_PARAMETER = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::EXTENDED_INITIAL_VALUE = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::EXTENDED_OTHER_NAME = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::EXTENDED_OTHER_PARAMETER = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::EXTENDED_OTHER_VALUE = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::EXTENDED_PARAMETER = T.let(T.unsafe(nil), Regexp)
-
-class Rack::Multipart::Generator
-  def initialize(params, first = T.unsafe(nil)); end
-
-  def dump; end
-
-  private
-
-  def content_for_other(file, name); end
-  def content_for_tempfile(io, file, name); end
-  def flattened_params; end
-  def multipart?; end
-end
-
-Rack::Multipart::MULTIPART = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::MULTIPART_BOUNDARY = T.let(T.unsafe(nil), String)
-Rack::Multipart::MULTIPART_CONTENT_DISPOSITION = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::MULTIPART_CONTENT_ID = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::MULTIPART_CONTENT_TYPE = T.let(T.unsafe(nil), Regexp)
-class Rack::Multipart::MultipartPartLimitError < ::Errno::EMFILE; end
-
-class Rack::Multipart::Parser
-  def initialize(boundary, tempfile, bufsize, query_parser); end
-
-  def on_read(content); end
-  def result; end
-  def state; end
-
-  private
-
-  def consume_boundary; end
-  def full_boundary; end
-  def get_filename(head); end
-  def handle_consume_token; end
-  def handle_empty_content!(content); end
-  def handle_fast_forward; end
-  def handle_mime_body; end
-  def handle_mime_head; end
-  def run_parser; end
-  def tag_multipart_encoding(filename, content_type, name, body); end
-
-  class << self
-    def parse(io, content_length, content_type, tmpfile, bufsize, qp); end
-    def parse_boundary(content_type); end
-  end
-end
-
-Rack::Multipart::Parser::BOUNDARY_REGEX = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::Parser::BUFSIZE = T.let(T.unsafe(nil), Integer)
-
-class Rack::Multipart::Parser::BoundedIO
-  def initialize(io, content_length); end
-
-  def read(size, outbuf = T.unsafe(nil)); end
-  def rewind; end
-end
-
-Rack::Multipart::Parser::CHARSET = T.let(T.unsafe(nil), String)
-
-class Rack::Multipart::Parser::Collector
-  include ::Enumerable
-
-  def initialize(tempfile); end
-
-  def each; end
-  def on_mime_body(mime_index, content); end
-  def on_mime_finish(mime_index); end
-  def on_mime_head(mime_index, head, filename, content_type, name); end
-
-  private
-
-  def check_open_files; end
-end
-
-class Rack::Multipart::Parser::Collector::BufferPart < ::Rack::Multipart::Parser::Collector::MimePart
-  def close; end
-  def file?; end
-end
-
-class Rack::Multipart::Parser::Collector::MimePart < ::Struct
-  def get_data; end
-end
-
-class Rack::Multipart::Parser::Collector::TempfilePart < ::Rack::Multipart::Parser::Collector::MimePart
-  def close; end
-  def file?; end
-end
-
-Rack::Multipart::Parser::EMPTY = T.let(T.unsafe(nil), Rack::Multipart::Parser::MultipartInfo)
-
-class Rack::Multipart::Parser::MultipartInfo < ::Struct
-  def params; end
-  def params=(_); end
-  def tmp_files; end
-  def tmp_files=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-Rack::Multipart::Parser::TEMPFILE_FACTORY = T.let(T.unsafe(nil), Proc)
-Rack::Multipart::Parser::TEXT_PLAIN = T.let(T.unsafe(nil), String)
-Rack::Multipart::REGULAR_PARAMETER = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::REGULAR_PARAMETER_NAME = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::RFC2183 = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::SECTION = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::TOKEN = T.let(T.unsafe(nil), Regexp)
-
-class Rack::Multipart::UploadedFile
-  def initialize(filepath = T.unsafe(nil), ct = T.unsafe(nil), bin = T.unsafe(nil), path: T.unsafe(nil), content_type: T.unsafe(nil), binary: T.unsafe(nil), filename: T.unsafe(nil), io: T.unsafe(nil)); end
-
-  def content_type; end
-  def content_type=(_arg0); end
-  def local_path; end
-  def method_missing(method_name, *args, &block); end
-  def original_filename; end
-  def path; end
-  def respond_to?(*args); end
-end
-
-Rack::Multipart::VALUE = T.let(T.unsafe(nil), Regexp)
-
-class Rack::NullLogger
-  def initialize(app); end
-
-  def <<(msg); end
-  def add(severity, message = T.unsafe(nil), progname = T.unsafe(nil), &block); end
-  def call(env); end
-  def close; end
-  def datetime_format; end
-  def datetime_format=(datetime_format); end
-  def debug(progname = T.unsafe(nil), &block); end
-  def debug?; end
-  def error(progname = T.unsafe(nil), &block); end
-  def error?; end
-  def fatal(progname = T.unsafe(nil), &block); end
-  def fatal?; end
-  def formatter; end
-  def formatter=(formatter); end
-  def info(progname = T.unsafe(nil), &block); end
-  def info?; end
-  def level; end
-  def level=(level); end
-  def progname; end
-  def progname=(progname); end
-  def sev_threshold; end
-  def sev_threshold=(sev_threshold); end
-  def unknown(progname = T.unsafe(nil), &block); end
-  def warn(progname = T.unsafe(nil), &block); end
-  def warn?; end
-end
-
-Rack::OPTIONS = T.let(T.unsafe(nil), String)
-Rack::PATCH = T.let(T.unsafe(nil), String)
-Rack::PATH_INFO = T.let(T.unsafe(nil), String)
-Rack::POST = T.let(T.unsafe(nil), String)
-Rack::PUT = T.let(T.unsafe(nil), String)
-Rack::QUERY_STRING = T.let(T.unsafe(nil), String)
-
-class Rack::QueryParser
-  def initialize(params_class, key_space_limit, param_depth_limit); end
-
-  def key_space_limit; end
-  def make_params; end
-  def new_depth_limit(param_depth_limit); end
-  def new_space_limit(key_space_limit); end
-  def normalize_params(params, name, v, depth); end
-  def param_depth_limit; end
-  def parse_nested_query(qs, d = T.unsafe(nil)); end
-  def parse_query(qs, d = T.unsafe(nil), &unescaper); end
-
-  private
-
-  def params_hash_has_key?(hash, key); end
-  def params_hash_type?(obj); end
-  def unescape(s); end
-
-  class << self
-    def make_default(key_space_limit, param_depth_limit); end
-  end
-end
-
-Rack::QueryParser::COMMON_SEP = T.let(T.unsafe(nil), Hash)
-Rack::QueryParser::DEFAULT_SEP = T.let(T.unsafe(nil), Regexp)
-class Rack::QueryParser::InvalidParameterError < ::ArgumentError; end
-class Rack::QueryParser::ParameterTypeError < ::TypeError; end
-
-class Rack::QueryParser::Params
-  def initialize(limit); end
-
-  def [](key); end
-  def []=(key, value); end
-  def key?(key); end
-  def to_h; end
-  def to_params_hash; end
-end
-
-class Rack::QueryParser::ParamsTooDeepError < ::RangeError; end
-Rack::RACK_ERRORS = T.let(T.unsafe(nil), String)
-Rack::RACK_HIJACK = T.let(T.unsafe(nil), String)
-Rack::RACK_HIJACK_IO = T.let(T.unsafe(nil), String)
-Rack::RACK_INPUT = T.let(T.unsafe(nil), String)
-Rack::RACK_IS_HIJACK = T.let(T.unsafe(nil), String)
-Rack::RACK_LOGGER = T.let(T.unsafe(nil), String)
-Rack::RACK_METHODOVERRIDE_ORIGINAL_METHOD = T.let(T.unsafe(nil), String)
-Rack::RACK_MULTIPART_BUFFER_SIZE = T.let(T.unsafe(nil), String)
-Rack::RACK_MULTIPART_TEMPFILE_FACTORY = T.let(T.unsafe(nil), String)
-Rack::RACK_MULTIPROCESS = T.let(T.unsafe(nil), String)
-Rack::RACK_MULTITHREAD = T.let(T.unsafe(nil), String)
-Rack::RACK_RECURSIVE_INCLUDE = T.let(T.unsafe(nil), String)
-Rack::RACK_REQUEST_COOKIE_HASH = T.let(T.unsafe(nil), String)
-Rack::RACK_REQUEST_COOKIE_STRING = T.let(T.unsafe(nil), String)
-Rack::RACK_REQUEST_FORM_HASH = T.let(T.unsafe(nil), String)
-Rack::RACK_REQUEST_FORM_INPUT = T.let(T.unsafe(nil), String)
-Rack::RACK_REQUEST_FORM_VARS = T.let(T.unsafe(nil), String)
-Rack::RACK_REQUEST_QUERY_HASH = T.let(T.unsafe(nil), String)
-Rack::RACK_REQUEST_QUERY_STRING = T.let(T.unsafe(nil), String)
-Rack::RACK_RUNONCE = T.let(T.unsafe(nil), String)
-Rack::RACK_SESSION = T.let(T.unsafe(nil), String)
-Rack::RACK_SESSION_OPTIONS = T.let(T.unsafe(nil), String)
-Rack::RACK_SESSION_UNPACKED_COOKIE_DATA = T.let(T.unsafe(nil), String)
-Rack::RACK_SHOWSTATUS_DETAIL = T.let(T.unsafe(nil), String)
-Rack::RACK_TEMPFILES = T.let(T.unsafe(nil), String)
-Rack::RACK_URL_SCHEME = T.let(T.unsafe(nil), String)
-Rack::RACK_VERSION = T.let(T.unsafe(nil), String)
-Rack::RELEASE = T.let(T.unsafe(nil), String)
-Rack::REQUEST_METHOD = T.let(T.unsafe(nil), String)
-Rack::REQUEST_PATH = T.let(T.unsafe(nil), String)
-
-class Rack::Recursive
-  def initialize(app); end
-
-  def _call(env); end
-  def call(env); end
-  def include(env, path); end
-end
-
-class Rack::Reloader
-  def initialize(app, cooldown = T.unsafe(nil), backend = T.unsafe(nil)); end
-
-  def call(env); end
-  def reload!(stderr = T.unsafe(nil)); end
-  def safe_load(file, mtime, stderr = T.unsafe(nil)); end
-end
-
-module Rack::Reloader::Stat
-  def figure_path(file, paths); end
-  def rotation; end
-  def safe_stat(file); end
-end
-
-class Rack::Request
-  include ::Rack::Request::Env
-  include ::Rack::Request::Helpers
-
-  def initialize(env); end
-
-  def delete_param(k); end
-  def params; end
-  def query; end
-  def update_param(k, v); end
-  def version_supplied; end
-  def version_supplied=(_arg0); end
-  def xhr?; end
-
-  class << self
-    def ip_filter; end
-    def ip_filter=(_arg0); end
-  end
-end
-
-Rack::Request::ALLOWED_SCHEMES = T.let(T.unsafe(nil), Array)
-
-module Rack::Request::Env
-  def initialize(env); end
-
-  def add_header(key, v); end
-  def delete_header(name); end
-  def each_header(&block); end
-  def env; end
-  def fetch_header(name, &block); end
-  def get_header(name); end
-  def has_header?(name); end
-  def set_header(name, v); end
-
-  private
-
-  def initialize_copy(other); end
-end
-
-module Rack::Request::Helpers
-  def GET; end
-  def POST; end
-  def [](key); end
-  def []=(key, value); end
-  def accept_encoding; end
-  def accept_language; end
-  def authority; end
-  def base_url; end
-  def body; end
-  def content_charset; end
-  def content_length; end
-  def content_type; end
-  def cookies; end
-  def delete?; end
-  def delete_param(k); end
-  def form_data?; end
-  def forwarded_authority; end
-  def forwarded_for; end
-  def forwarded_port; end
-  def fullpath; end
-  def get?; end
-  def head?; end
-  def host; end
-  def host_authority; end
-  def host_with_port(authority = T.unsafe(nil)); end
-  def hostname; end
-  def ip; end
-  def link?; end
-  def logger; end
-  def media_type; end
-  def media_type_params; end
-  def multithread?; end
-  def options?; end
-  def params; end
-  def parseable_data?; end
-  def patch?; end
-  def path; end
-  def path_info; end
-  def path_info=(s); end
-  def port; end
-  def post?; end
-  def put?; end
-  def query_string; end
-  def referer; end
-  def referrer; end
-  def request_method; end
-  def scheme; end
-  def script_name; end
-  def script_name=(s); end
-  def server_authority; end
-  def server_name; end
-  def server_port; end
-  def session; end
-  def session_options; end
-  def ssl?; end
-  def trace?; end
-  def trusted_proxy?(ip); end
-  def unlink?; end
-  def update_param(k, v); end
-  def url; end
-  def user_agent; end
-  def values_at(*keys); end
-  def xhr?; end
-
-  private
-
-  def allowed_scheme(header); end
-  def default_session; end
-  def extract_proto_header(header); end
-  def forwarded_scheme; end
-  def parse_http_accept_header(header); end
-  def parse_multipart; end
-  def parse_query(qs, d = T.unsafe(nil)); end
-  def query_parser; end
-  def reject_trusted_ip_addresses(ip_addresses); end
-  def split_authority(authority); end
-  def split_header(value); end
-  def wrap_ipv6(host); end
-end
-
-Rack::Request::Helpers::AUTHORITY = T.let(T.unsafe(nil), Regexp)
-Rack::Request::Helpers::DEFAULT_PORTS = T.let(T.unsafe(nil), Hash)
-Rack::Request::Helpers::FORM_DATA_MEDIA_TYPES = T.let(T.unsafe(nil), Array)
-Rack::Request::Helpers::HTTP_X_FORWARDED_FOR = T.let(T.unsafe(nil), String)
-Rack::Request::Helpers::HTTP_X_FORWARDED_HOST = T.let(T.unsafe(nil), String)
-Rack::Request::Helpers::HTTP_X_FORWARDED_PORT = T.let(T.unsafe(nil), String)
-Rack::Request::Helpers::HTTP_X_FORWARDED_PROTO = T.let(T.unsafe(nil), String)
-Rack::Request::Helpers::HTTP_X_FORWARDED_SCHEME = T.let(T.unsafe(nil), String)
-Rack::Request::Helpers::HTTP_X_FORWARDED_SSL = T.let(T.unsafe(nil), String)
-Rack::Request::Helpers::PARSEABLE_DATA_MEDIA_TYPES = T.let(T.unsafe(nil), Array)
-Rack::Request::SCHEME_WHITELIST = T.let(T.unsafe(nil), Array)
-
-class Rack::Response
-  include ::Rack::Response::Helpers
-
-  def initialize(body = T.unsafe(nil), status = T.unsafe(nil), headers = T.unsafe(nil)); end
-
-  def [](key); end
-  def []=(key, v); end
-  def body; end
-  def body=(_arg0); end
-  def chunked?; end
-  def close; end
-  def delete_header(key); end
-  def each(&callback); end
-  def empty?; end
-  def finish(&block); end
-  def get_header(key); end
-  def has_header?(key); end
-  def header; end
-  def headers; end
-  def length; end
-  def length=(_arg0); end
-  def redirect(target, status = T.unsafe(nil)); end
-  def set_header(key, v); end
-  def status; end
-  def status=(_arg0); end
-  def to_a(&block); end
-  def write(chunk); end
-
-  class << self
-    def [](status, headers, body); end
-  end
-end
-
-Rack::Response::CHUNKED = T.let(T.unsafe(nil), String)
-
-module Rack::Response::Helpers
-  def accepted?; end
-  def add_header(key, v); end
-  def bad_request?; end
-  def cache!(duration = T.unsafe(nil), directive: T.unsafe(nil)); end
-  def cache_control; end
-  def cache_control=(v); end
-  def client_error?; end
-  def content_length; end
-  def content_type; end
-  def content_type=(content_type); end
-  def created?; end
-  def delete_cookie(key, value = T.unsafe(nil)); end
-  def do_not_cache!; end
-  def etag; end
-  def etag=(v); end
-  def forbidden?; end
-  def include?(header); end
-  def informational?; end
-  def invalid?; end
-  def location; end
-  def location=(location); end
-  def media_type; end
-  def media_type_params; end
-  def method_not_allowed?; end
-  def moved_permanently?; end
-  def no_content?; end
-  def not_found?; end
-  def ok?; end
-  def precondition_failed?; end
-  def redirect?; end
-  def redirection?; end
-  def server_error?; end
-  def set_cookie(key, value); end
-  def set_cookie_header; end
-  def set_cookie_header=(v); end
-  def successful?; end
-  def unauthorized?; end
-  def unprocessable?; end
-
-  protected
-
-  def append(chunk); end
-  def buffered_body!; end
-end
-
-class Rack::Response::Raw
-  include ::Rack::Response::Helpers
-
-  def initialize(status, headers); end
-
-  def delete_header(key); end
-  def get_header(key); end
-  def has_header?(key); end
-  def headers; end
-  def set_header(key, v); end
-  def status; end
-  def status=(_arg0); end
-end
-
-Rack::Response::STATUS_WITH_NO_ENTITY_BODY = T.let(T.unsafe(nil), Hash)
-
-class Rack::RewindableInput
-  def initialize(io); end
-
-  def close; end
-  def each(&block); end
-  def gets; end
-  def read(*args); end
-  def rewind; end
-
-  private
-
-  def filesystem_has_posix_semantics?; end
-  def make_rewindable; end
-end
-
-class Rack::Runtime
-  def initialize(app, name = T.unsafe(nil)); end
-
-  def call(env); end
-end
-
-Rack::Runtime::FORMAT_STRING = T.let(T.unsafe(nil), String)
-Rack::Runtime::HEADER_NAME = T.let(T.unsafe(nil), String)
-Rack::SCRIPT_NAME = T.let(T.unsafe(nil), String)
-Rack::SERVER_NAME = T.let(T.unsafe(nil), String)
-Rack::SERVER_PORT = T.let(T.unsafe(nil), String)
-Rack::SERVER_PROTOCOL = T.let(T.unsafe(nil), String)
-Rack::SET_COOKIE = T.let(T.unsafe(nil), String)
-
-class Rack::Sendfile
-  def initialize(app, variation = T.unsafe(nil), mappings = T.unsafe(nil)); end
-
-  def call(env); end
-
-  private
-
-  def map_accel_path(env, path); end
-  def variation(env); end
-end
-
-class Rack::Server
-  def initialize(options = T.unsafe(nil)); end
-
-  def app; end
-  def default_options; end
-  def middleware; end
-  def options; end
-  def options=(_arg0); end
-  def server; end
-  def start(&block); end
-
-  private
-
-  def build_app(app); end
-  def build_app_and_options_from_config; end
-  def build_app_from_string; end
-  def check_pid!; end
-  def daemonize_app; end
-  def handle_profiling(heapfile, profile_mode, filename); end
-  def make_profile_name(filename); end
-  def opt_parser; end
-  def parse_options(args); end
-  def pidfile_process_status; end
-  def wrapped_app; end
-  def write_pid; end
-
-  class << self
-    def default_middleware_by_environment; end
-    def logging_middleware; end
-    def middleware; end
-    def start(options = T.unsafe(nil)); end
-  end
-end
-
-class Rack::Server::Options
-  def handler_opts(options); end
-  def parse!(args); end
-end
-
-module Rack::Session; end
-module Rack::Session::Abstract; end
-
-class Rack::Session::Abstract::ID < ::Rack::Session::Abstract::Persisted
-  def delete_session(req, sid, options); end
-  def find_session(req, sid); end
-  def write_session(req, sid, session, options); end
-
-  class << self
-    def inherited(klass); end
-  end
-end
-
-class Rack::Session::Abstract::Persisted
-  def initialize(app, options = T.unsafe(nil)); end
-
-  def call(env); end
-  def commit_session(req, res); end
-  def context(env, app = T.unsafe(nil)); end
-  def default_options; end
-  def key; end
-  def sid_secure; end
-
-  private
-
-  def commit_session?(req, session, options); end
-  def cookie_value(data); end
-  def current_session_id(req); end
-  def delete_session(req, sid, options); end
-  def extract_session_id(request); end
-  def find_session(env, sid); end
-  def force_options?(options); end
-  def forced_session_update?(session, options); end
-  def generate_sid(secure = T.unsafe(nil)); end
-  def initialize_sid; end
-  def load_session(req); end
-  def loaded_session?(session); end
-  def make_request(env); end
-  def prepare_session(req); end
-  def security_matches?(request, options); end
-  def session_class; end
-  def session_exists?(req); end
-  def set_cookie(request, res, cookie); end
-  def write_session(req, sid, session, options); end
-end
-
-Rack::Session::Abstract::Persisted::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-
-class Rack::Session::Abstract::PersistedSecure < ::Rack::Session::Abstract::Persisted
-  def extract_session_id(*_arg0); end
-  def generate_sid(*_arg0); end
-
-  private
-
-  def cookie_value(data); end
-  def session_class; end
-end
-
-class Rack::Session::Abstract::PersistedSecure::SecureSessionHash < ::Rack::Session::Abstract::SessionHash
-  def [](key); end
-end
-
-class Rack::Session::Abstract::SessionHash
-  include ::Enumerable
-
-  def initialize(store, req); end
-
-  def [](key); end
-  def []=(key, value); end
-  def clear; end
-  def delete(key); end
-  def destroy; end
-  def dig(key, *keys); end
-  def each(&block); end
-  def empty?; end
-  def exists?; end
-  def fetch(key, default = T.unsafe(nil), &block); end
-  def has_key?(key); end
-  def id; end
-  def id=(_arg0); end
-  def include?(key); end
-  def inspect; end
-  def key?(key); end
-  def keys; end
-  def loaded?; end
-  def merge!(hash); end
-  def options; end
-  def replace(hash); end
-  def store(key, value); end
-  def to_hash; end
-  def update(hash); end
-  def values; end
-
-  private
-
-  def load!; end
-  def load_for_read!; end
-  def load_for_write!; end
-  def stringify_keys(other); end
-
-  class << self
-    def find(req); end
-    def set(req, session); end
-    def set_options(req, options); end
-  end
-end
-
-Rack::Session::Abstract::SessionHash::Unspecified = T.let(T.unsafe(nil), Object)
-
-class Rack::Session::Cookie < ::Rack::Session::Abstract::PersistedSecure
-  def initialize(app, options = T.unsafe(nil)); end
-
-  def coder; end
-
-  private
-
-  def delete_session(req, session_id, options); end
-  def digest_match?(data, digest); end
-  def extract_session_id(request); end
-  def find_session(req, sid); end
-  def generate_hmac(data, secret); end
-  def persistent_session_id!(data, sid = T.unsafe(nil)); end
-  def secure?(options); end
-  def unpacked_cookie_data(request); end
-  def write_session(req, session_id, session, options); end
-end
-
-class Rack::Session::Cookie::Base64
-  def decode(str); end
-  def encode(str); end
-end
-
-class Rack::Session::Cookie::Base64::JSON < ::Rack::Session::Cookie::Base64
-  def decode(str); end
-  def encode(obj); end
-end
-
-class Rack::Session::Cookie::Base64::Marshal < ::Rack::Session::Cookie::Base64
-  def decode(str); end
-  def encode(str); end
-end
-
-class Rack::Session::Cookie::Base64::ZipJSON < ::Rack::Session::Cookie::Base64
-  def decode(str); end
-  def encode(obj); end
-end
-
-class Rack::Session::Cookie::Identity
-  def decode(str); end
-  def encode(str); end
-end
-
-class Rack::Session::Cookie::SessionId
-  def initialize(session_id, cookie_value); end
-
-  def cookie_value; end
-end
-
-class Rack::Session::Pool < ::Rack::Session::Abstract::PersistedSecure
-  def initialize(app, options = T.unsafe(nil)); end
-
-  def delete_session(req, session_id, options); end
-  def find_session(req, sid); end
-  def generate_sid; end
-  def mutex; end
-  def pool; end
-  def with_lock(req); end
-  def write_session(req, session_id, new_session, options); end
-
-  private
-
-  def get_session_with_fallback(sid); end
-end
-
-Rack::Session::Pool::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-
-class Rack::Session::SessionId
-  def initialize(public_id); end
-
-  def cookie_value; end
-  def empty?; end
-  def inspect; end
-  def private_id; end
-  def public_id; end
-  def to_s; end
-
-  private
-
-  def hash_sid(sid); end
-end
-
-Rack::Session::SessionId::ID_VERSION = T.let(T.unsafe(nil), Integer)
-
-class Rack::ShowExceptions
-  def initialize(app); end
-
-  def call(env); end
-  def dump_exception(exception); end
-  def h(obj); end
-  def prefers_plaintext?(env); end
-  def pretty(env, exception); end
-  def template; end
-
-  private
-
-  def accepts_html?(env); end
-end
-
-Rack::ShowExceptions::CONTEXT = T.let(T.unsafe(nil), Integer)
-Rack::ShowExceptions::TEMPLATE = T.let(T.unsafe(nil), ERB)
-
-class Rack::ShowStatus
-  def initialize(app); end
-
-  def call(env); end
-  def h(obj); end
-end
-
-Rack::ShowStatus::TEMPLATE = T.let(T.unsafe(nil), String)
-
-class Rack::Static
-  def initialize(app, options = T.unsafe(nil)); end
-
-  def add_index_root?(path); end
-  def applicable_rules(path); end
-  def call(env); end
-  def can_serve(path); end
-  def overwrite_file_path(path); end
-  def route_file(path); end
-end
-
-Rack::TRACE = T.let(T.unsafe(nil), String)
-Rack::TRANSFER_ENCODING = T.let(T.unsafe(nil), String)
-
-class Rack::TempfileReaper
-  def initialize(app); end
-
-  def call(env); end
-end
-
-Rack::UNLINK = T.let(T.unsafe(nil), String)
-
-class Rack::URLMap
-  def initialize(map = T.unsafe(nil)); end
-
-  def call(env); end
-  def remap(map); end
-
-  private
-
-  def casecmp?(v1, v2); end
-end
-
-module Rack::Utils
-  private
-
-  def add_cookie_to_header(header, key, value); end
-  def add_remove_cookie_to_header(header, key, value = T.unsafe(nil)); end
-  def best_q_match(q_value_header, available_mimes); end
-  def build_nested_query(value, prefix = T.unsafe(nil)); end
-  def build_query(params); end
-  def byte_ranges(env, size); end
-  def clean_path_info(path_info); end
-  def clock_time; end
-  def delete_cookie_header!(header, key, value = T.unsafe(nil)); end
-  def escape(s); end
-  def escape_html(string); end
-  def escape_path(s); end
-  def get_byte_ranges(http_range, size); end
-  def make_delete_cookie_header(header, key, value); end
-  def parse_cookies(env); end
-  def parse_cookies_header(header); end
-  def parse_nested_query(qs, d = T.unsafe(nil)); end
-  def parse_query(qs, d = T.unsafe(nil), &unescaper); end
-  def q_values(q_value_header); end
-  def rfc2109(time); end
-  def rfc2822(time); end
-  def secure_compare(a, b); end
-  def select_best_encoding(available_encodings, accept_encoding); end
-  def set_cookie_header!(header, key, value); end
-  def status_code(status); end
-  def unescape(s, encoding = T.unsafe(nil)); end
-  def unescape_path(s); end
-  def valid_path?(path); end
-
-  class << self
-    def add_cookie_to_header(header, key, value); end
-    def add_remove_cookie_to_header(header, key, value = T.unsafe(nil)); end
-    def best_q_match(q_value_header, available_mimes); end
-    def build_nested_query(value, prefix = T.unsafe(nil)); end
-    def build_query(params); end
-    def byte_ranges(env, size); end
-    def clean_path_info(path_info); end
-    def clock_time; end
-    def default_query_parser; end
-    def default_query_parser=(_arg0); end
-    def delete_cookie_header!(header, key, value = T.unsafe(nil)); end
-    def escape(s); end
-    def escape_html(string); end
-    def escape_path(s); end
-    def get_byte_ranges(http_range, size); end
-    def key_space_limit; end
-    def key_space_limit=(v); end
-    def make_delete_cookie_header(header, key, value); end
-    def multipart_part_limit; end
-    def multipart_part_limit=(_arg0); end
-    def param_depth_limit; end
-    def param_depth_limit=(v); end
-    def parse_cookies(env); end
-    def parse_cookies_header(header); end
-    def parse_nested_query(qs, d = T.unsafe(nil)); end
-    def parse_query(qs, d = T.unsafe(nil), &unescaper); end
-    def q_values(q_value_header); end
-    def rfc2109(time); end
-    def rfc2822(time); end
-    def secure_compare(a, b); end
-    def select_best_encoding(available_encodings, accept_encoding); end
-    def set_cookie_header!(header, key, value); end
-    def status_code(status); end
-    def unescape(s, encoding = T.unsafe(nil)); end
-    def unescape_path(s); end
-    def valid_path?(path); end
-  end
-end
-
-Rack::Utils::COMMON_SEP = T.let(T.unsafe(nil), Hash)
-
-class Rack::Utils::Context
-  def initialize(app_f, app_r); end
-
-  def app; end
-  def call(env); end
-  def context(env, app = T.unsafe(nil)); end
-  def for; end
-  def recontext(app); end
-end
-
-Rack::Utils::DEFAULT_SEP = T.let(T.unsafe(nil), Regexp)
-Rack::Utils::ESCAPE_HTML = T.let(T.unsafe(nil), Hash)
-Rack::Utils::ESCAPE_HTML_PATTERN = T.let(T.unsafe(nil), Regexp)
-Rack::Utils::HTTP_STATUS_CODES = T.let(T.unsafe(nil), Hash)
-
-class Rack::Utils::HeaderHash < ::Hash
-  def initialize(hash = T.unsafe(nil)); end
-
-  def [](k); end
-  def []=(k, v); end
-  def clear; end
-  def delete(k); end
-  def each; end
-  def has_key?(k); end
-  def include?(k); end
-  def key?(k); end
-  def member?(k); end
-  def merge(other); end
-  def merge!(other); end
-  def replace(other); end
-  def to_hash; end
-
-  protected
-
-  def names; end
-
-  private
-
-  def initialize_copy(other); end
-
-  class << self
-    def [](headers); end
-  end
-end
-
-Rack::Utils::InvalidParameterError = Rack::QueryParser::InvalidParameterError
-Rack::Utils::KeySpaceConstrainedParams = Rack::QueryParser::Params
-Rack::Utils::NULL_BYTE = T.let(T.unsafe(nil), String)
-Rack::Utils::PATH_SEPS = T.let(T.unsafe(nil), Regexp)
-Rack::Utils::ParameterTypeError = Rack::QueryParser::ParameterTypeError
-Rack::Utils::RFC2822_DAY_NAME = T.let(T.unsafe(nil), Array)
-Rack::Utils::RFC2822_MONTH_NAME = T.let(T.unsafe(nil), Array)
-Rack::Utils::STATUS_WITH_NO_ENTITY_BODY = T.let(T.unsafe(nil), Hash)
-Rack::Utils::SYMBOL_TO_STATUS_CODE = T.let(T.unsafe(nil), Hash)
-Rack::VERSION = T.let(T.unsafe(nil), Array)
-
-class WEBrick::HTTPResponse
-  def rack; end
-  def rack=(_arg0); end
-  def setup_header; end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rainbow@3.1.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rainbow@3.1.1.rbi
index e704587b974be..87f4c33ef20fb 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rainbow@3.1.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rainbow@3.1.1.rbi
@@ -4,154 +4,399 @@
 # This is an autogenerated file for types exported from the `rainbow` gem.
 # Please instead update this file by running `bin/tapioca gem rainbow`.
 
+class Object < ::BasicObject
+  include ::Kernel
+  include ::PP::ObjectMixin
+
+  private
+
+  # source://rainbow//lib/rainbow/global.rb#23
+  def Rainbow(string); end
+end
+
+# source://rainbow//lib/rainbow/string_utils.rb#3
 module Rainbow
   class << self
+    # source://rainbow//lib/rainbow/global.rb#10
     def enabled; end
+
+    # source://rainbow//lib/rainbow/global.rb#14
     def enabled=(value); end
+
+    # source://rainbow//lib/rainbow/global.rb#6
     def global; end
+
+    # source://rainbow//lib/rainbow.rb#6
     def new; end
+
+    # source://rainbow//lib/rainbow/global.rb#18
     def uncolor(string); end
   end
 end
 
+# source://rainbow//lib/rainbow/color.rb#4
 class Rainbow::Color
+  # Returns the value of attribute ground.
+  #
+  # source://rainbow//lib/rainbow/color.rb#5
   def ground; end
 
   class << self
+    # source://rainbow//lib/rainbow/color.rb#7
     def build(ground, values); end
+
+    # source://rainbow//lib/rainbow/color.rb#40
     def parse_hex_color(hex); end
   end
 end
 
+# source://rainbow//lib/rainbow/color.rb#54
 class Rainbow::Color::Indexed < ::Rainbow::Color
+  # @return [Indexed] a new instance of Indexed
+  #
+  # source://rainbow//lib/rainbow/color.rb#57
   def initialize(ground, num); end
 
+  # source://rainbow//lib/rainbow/color.rb#62
   def codes; end
+
+  # Returns the value of attribute num.
+  #
+  # source://rainbow//lib/rainbow/color.rb#55
   def num; end
 end
 
+# source://rainbow//lib/rainbow/color.rb#69
 class Rainbow::Color::Named < ::Rainbow::Color::Indexed
+  # @return [Named] a new instance of Named
+  #
+  # source://rainbow//lib/rainbow/color.rb#90
   def initialize(ground, name); end
 
   class << self
+    # source://rainbow//lib/rainbow/color.rb#82
     def color_names; end
+
+    # source://rainbow//lib/rainbow/color.rb#86
     def valid_names; end
   end
 end
 
+# source://rainbow//lib/rainbow/color.rb#70
 Rainbow::Color::Named::NAMES = T.let(T.unsafe(nil), Hash)
 
+# source://rainbow//lib/rainbow/color.rb#100
 class Rainbow::Color::RGB < ::Rainbow::Color::Indexed
+  # @return [RGB] a new instance of RGB
+  #
+  # source://rainbow//lib/rainbow/color.rb#107
   def initialize(ground, *values); end
 
+  # Returns the value of attribute b.
+  #
+  # source://rainbow//lib/rainbow/color.rb#101
   def b; end
+
+  # source://rainbow//lib/rainbow/color.rb#116
   def codes; end
+
+  # Returns the value of attribute g.
+  #
+  # source://rainbow//lib/rainbow/color.rb#101
   def g; end
+
+  # Returns the value of attribute r.
+  #
+  # source://rainbow//lib/rainbow/color.rb#101
   def r; end
 
   private
 
+  # source://rainbow//lib/rainbow/color.rb#122
   def code_from_rgb; end
 
   class << self
+    # source://rainbow//lib/rainbow/color.rb#103
     def to_ansi_domain(value); end
   end
 end
 
+# source://rainbow//lib/rainbow/color.rb#129
 class Rainbow::Color::X11Named < ::Rainbow::Color::RGB
   include ::Rainbow::X11ColorNames
 
+  # @return [X11Named] a new instance of X11Named
+  #
+  # source://rainbow//lib/rainbow/color.rb#140
   def initialize(ground, name); end
 
   class << self
+    # source://rainbow//lib/rainbow/color.rb#132
     def color_names; end
+
+    # source://rainbow//lib/rainbow/color.rb#136
     def valid_names; end
   end
 end
 
+# source://rainbow//lib/rainbow/null_presenter.rb#4
 class Rainbow::NullPresenter < ::String
+  # source://rainbow//lib/rainbow/null_presenter.rb#9
   def background(*_values); end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#9
   def bg(*_values); end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#49
   def black; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#33
   def blink; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#65
   def blue; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#17
   def bold; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#17
   def bright; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#5
   def color(*_values); end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#45
   def cross_out; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#73
   def cyan; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#21
   def dark; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#21
   def faint; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#5
   def fg(*_values); end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#5
   def foreground(*_values); end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#57
   def green; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#41
   def hide; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#37
   def inverse; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#25
   def italic; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#69
   def magenta; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#81
   def method_missing(method_name, *args); end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#53
   def red; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#13
   def reset; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#45
   def strike; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#29
   def underline; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#77
   def white; end
+
+  # source://rainbow//lib/rainbow/null_presenter.rb#61
   def yellow; end
 
   private
 
+  # @return [Boolean]
+  #
+  # source://rainbow//lib/rainbow/null_presenter.rb#89
   def respond_to_missing?(method_name, *args); end
 end
 
+# source://rainbow//lib/rainbow/presenter.rb#8
 class Rainbow::Presenter < ::String
+  # Sets background color of this text.
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#30
   def background(*values); end
+
+  # Sets background color of this text.
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#30
   def bg(*values); end
+
+  # source://rainbow//lib/rainbow/presenter.rb#92
   def black; end
+
+  # Turns on blinking attribute for this text (not well supported by terminal
+  # emulators).
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#72
   def blink; end
+
+  # source://rainbow//lib/rainbow/presenter.rb#108
   def blue; end
+
+  # Turns on bright/bold for this text.
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#45
   def bold; end
+
+  # Turns on bright/bold for this text.
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#45
   def bright; end
+
+  # Sets color of this text.
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#22
   def color(*values); end
+
+  # source://rainbow//lib/rainbow/presenter.rb#86
   def cross_out; end
+
+  # source://rainbow//lib/rainbow/presenter.rb#116
   def cyan; end
+
+  # Turns on faint/dark for this text (not well supported by terminal
+  # emulators).
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#53
   def dark; end
+
+  # Turns on faint/dark for this text (not well supported by terminal
+  # emulators).
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#53
   def faint; end
+
+  # Sets color of this text.
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#22
   def fg(*values); end
+
+  # Sets color of this text.
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#22
   def foreground(*values); end
+
+  # source://rainbow//lib/rainbow/presenter.rb#100
   def green; end
+
+  # Hides this text (set its color to the same as background).
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#82
   def hide; end
+
+  # Inverses current foreground/background colors.
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#77
   def inverse; end
+
+  # Turns on italic style for this text (not well supported by terminal
+  # emulators).
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#61
   def italic; end
+
+  # source://rainbow//lib/rainbow/presenter.rb#112
   def magenta; end
+
+  # We take care of X11 color method call here.
+  # Such as #aqua, #ghostwhite.
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#126
   def method_missing(method_name, *args); end
+
+  # source://rainbow//lib/rainbow/presenter.rb#96
   def red; end
+
+  # Resets terminal to default colors/backgrounds.
+  #
+  # It shouldn't be needed to use this method because all methods
+  # append terminal reset code to end of string.
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#40
   def reset; end
+
+  # source://rainbow//lib/rainbow/presenter.rb#86
   def strike; end
+
+  # Turns on underline decoration for this text.
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#66
   def underline; end
+
+  # source://rainbow//lib/rainbow/presenter.rb#120
   def white; end
+
+  # source://rainbow//lib/rainbow/presenter.rb#104
   def yellow; end
 
   private
 
+  # @return [Boolean]
+  #
+  # source://rainbow//lib/rainbow/presenter.rb#134
   def respond_to_missing?(method_name, *args); end
+
+  # source://rainbow//lib/rainbow/presenter.rb#140
   def wrap_with_sgr(codes); end
 end
 
+# source://rainbow//lib/rainbow/presenter.rb#9
 Rainbow::Presenter::TERM_EFFECTS = T.let(T.unsafe(nil), Hash)
 
+# source://rainbow//lib/rainbow/string_utils.rb#4
 class Rainbow::StringUtils
   class << self
+    # source://rainbow//lib/rainbow/string_utils.rb#17
     def uncolor(string); end
+
+    # source://rainbow//lib/rainbow/string_utils.rb#5
     def wrap_with_sgr(string, codes); end
   end
 end
 
+# source://rainbow//lib/rainbow/wrapper.rb#7
 class Rainbow::Wrapper
+  # @return [Wrapper] a new instance of Wrapper
+  #
+  # source://rainbow//lib/rainbow/wrapper.rb#10
   def initialize(enabled = T.unsafe(nil)); end
 
+  # Returns the value of attribute enabled.
+  #
+  # source://rainbow//lib/rainbow/wrapper.rb#8
   def enabled; end
+
+  # Sets the attribute enabled
+  #
+  # @param value the value to set the attribute enabled to.
+  #
+  # source://rainbow//lib/rainbow/wrapper.rb#8
   def enabled=(_arg0); end
+
+  # source://rainbow//lib/rainbow/wrapper.rb#14
   def wrap(string); end
 end
 
+# source://rainbow//lib/rainbow/x11_color_names.rb#4
 module Rainbow::X11ColorNames; end
+
+# source://rainbow//lib/rainbow/x11_color_names.rb#5
 Rainbow::X11ColorNames::NAMES = T.let(T.unsafe(nil), Hash)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rbi@0.0.14.rbi b/Library/Homebrew/sorbet/rbi/gems/rbi@0.0.14.rbi
deleted file mode 100644
index c11faca967cd9..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rbi@0.0.14.rbi
+++ /dev/null
@@ -1,2082 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rbi` gem.
-# Please instead update this file by running `bin/tapioca gem rbi`.
-
-module RBI; end
-
-class RBI::ASTVisitor
-  abstract!
-
-  def initialize(*args, &blk); end
-
-  sig { abstract.params(node: T.nilable(::AST::Node)).void }
-  def visit(node); end
-
-  sig { params(nodes: T::Array[::AST::Node]).void }
-  def visit_all(nodes); end
-
-  private
-
-  sig { params(node: ::AST::Node).returns(::String) }
-  def parse_expr(node); end
-
-  sig { params(node: ::AST::Node).returns(::String) }
-  def parse_name(node); end
-end
-
-class RBI::Arg < ::RBI::Node
-  sig { params(value: ::String, loc: T.nilable(::RBI::Loc)).void }
-  def initialize(value, loc: T.unsafe(nil)); end
-
-  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(::String) }
-  def to_s; end
-
-  sig { returns(::String) }
-  def value; end
-end
-
-class RBI::Attr < ::RBI::NodeWithComments
-  include ::RBI::Indexable
-
-  abstract!
-
-  sig do
-    params(
-      name: ::Symbol,
-      names: T::Array[::Symbol],
-      visibility: ::RBI::Visibility,
-      sigs: T::Array[::RBI::Sig],
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment]
-    ).void
-  end
-  def initialize(name, names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil)); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { abstract.returns(T::Array[::String]) }
-  def fully_qualified_names; end
-
-  sig { override.returns(T::Array[::String]) }
-  def index_ids; end
-
-  sig { override.params(other: ::RBI::Node).void }
-  def merge_with(other); end
-
-  sig { returns(T::Array[::Symbol]) }
-  def names; end
-
-  def names=(_arg0); end
-
-  sig { override.returns(T::Boolean) }
-  def oneline?; end
-
-  sig { returns(T::Array[::RBI::Sig]) }
-  def sigs; end
-
-  sig { returns(::RBI::Visibility) }
-  def visibility; end
-
-  def visibility=(_arg0); end
-end
-
-class RBI::AttrAccessor < ::RBI::Attr
-  sig do
-    params(
-      name: ::Symbol,
-      names: ::Symbol,
-      visibility: ::RBI::Visibility,
-      sigs: T::Array[::RBI::Sig],
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::AttrAccessor).void)
-    ).void
-  end
-  def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { override.returns(T::Array[::String]) }
-  def fully_qualified_names; end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::AttrReader < ::RBI::Attr
-  sig do
-    params(
-      name: ::Symbol,
-      names: ::Symbol,
-      visibility: ::RBI::Visibility,
-      sigs: T::Array[::RBI::Sig],
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::AttrReader).void)
-    ).void
-  end
-  def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { override.returns(T::Array[::String]) }
-  def fully_qualified_names; end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::AttrWriter < ::RBI::Attr
-  sig do
-    params(
-      name: ::Symbol,
-      names: ::Symbol,
-      visibility: ::RBI::Visibility,
-      sigs: T::Array[::RBI::Sig],
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::AttrWriter).void)
-    ).void
-  end
-  def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { override.returns(T::Array[::String]) }
-  def fully_qualified_names; end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::BlankLine < ::RBI::Comment
-  sig { params(loc: T.nilable(::RBI::Loc)).void }
-  def initialize(loc: T.unsafe(nil)); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-end
-
-class RBI::BlockParam < ::RBI::Param
-  sig do
-    params(
-      name: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::BlockParam).void)
-    ).void
-  end
-  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { override.params(v: ::RBI::Printer, last: T::Boolean).void }
-  def print_comment_leading_space(v, last:); end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::Class < ::RBI::Scope
-  sig do
-    params(
-      name: ::String,
-      superclass_name: T.nilable(::String),
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Class).void)
-    ).void
-  end
-  def initialize(name, superclass_name: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { override.returns(::String) }
-  def fully_qualified_name; end
-
-  sig { returns(::String) }
-  def name; end
-
-  def name=(_arg0); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def print_header(v); end
-
-  sig { returns(T.nilable(::String)) }
-  def superclass_name; end
-
-  def superclass_name=(_arg0); end
-end
-
-class RBI::Comment < ::RBI::Node
-  sig { params(text: ::String, loc: T.nilable(::RBI::Loc)).void }
-  def initialize(text, loc: T.unsafe(nil)); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(::String) }
-  def text; end
-
-  def text=(_arg0); end
-end
-
-class RBI::ConflictTree < ::RBI::Tree
-  sig { params(left_name: ::String, right_name: ::String).void }
-  def initialize(left_name: T.unsafe(nil), right_name: T.unsafe(nil)); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(::RBI::Tree) }
-  def left; end
-
-  def right; end
-end
-
-class RBI::Const < ::RBI::NodeWithComments
-  include ::RBI::Indexable
-
-  sig do
-    params(
-      name: ::String,
-      value: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Const).void)
-    ).void
-  end
-  def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { returns(::String) }
-  def fully_qualified_name; end
-
-  sig { override.returns(T::Array[::String]) }
-  def index_ids; end
-
-  sig { returns(::String) }
-  def name; end
-
-  sig { override.returns(::String) }
-  def to_s; end
-
-  def value; end
-end
-
-class RBI::ConstBuilder < ::RBI::ASTVisitor
-  sig { void }
-  def initialize; end
-
-  sig { returns(T::Array[::String]) }
-  def names; end
-
-  def names=(_arg0); end
-
-  sig { override.params(node: T.nilable(::AST::Node)).void }
-  def visit(node); end
-
-  class << self
-    sig { params(node: T.nilable(::AST::Node)).returns(T.nilable(::String)) }
-    def visit(node); end
-  end
-end
-
-class RBI::Error < ::StandardError; end
-
-class RBI::Extend < ::RBI::Mixin
-  include ::RBI::Indexable
-
-  sig do
-    params(
-      name: ::String,
-      names: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Extend).void)
-    ).void
-  end
-  def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { override.returns(T::Array[::String]) }
-  def index_ids; end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::File
-  sig do
-    params(
-      strictness: T.nilable(::String),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(file: ::RBI::File).void)
-    ).void
-  end
-  def initialize(strictness: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(node: ::RBI::Node).void }
-  def <<(node); end
-
-  sig { params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(T::Array[::RBI::Comment]) }
-  def comments; end
-
-  def comments=(_arg0); end
-
-  sig { returns(T::Boolean) }
-  def empty?; end
-
-  sig do
-    params(
-      out: T.any(::IO, ::StringIO),
-      indent: ::Integer,
-      print_locs: T::Boolean,
-      max_line_length: T.nilable(::Integer)
-    ).void
-  end
-  def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
-
-  sig { returns(::RBI::Tree) }
-  def root; end
-
-  def root=(_arg0); end
-
-  sig { returns(T.nilable(::String)) }
-  def strictness; end
-
-  def strictness=(_arg0); end
-
-  sig { params(indent: ::Integer, print_locs: T::Boolean, max_line_length: T.nilable(::Integer)).returns(::String) }
-  def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
-end
-
-class RBI::Formatter
-  sig do
-    params(
-      add_sig_templates: T::Boolean,
-      group_nodes: T::Boolean,
-      max_line_length: T.nilable(::Integer),
-      nest_singleton_methods: T::Boolean,
-      nest_non_public_methods: T::Boolean,
-      sort_nodes: T::Boolean
-    ).void
-  end
-  def initialize(add_sig_templates: T.unsafe(nil), group_nodes: T.unsafe(nil), max_line_length: T.unsafe(nil), nest_singleton_methods: T.unsafe(nil), nest_non_public_methods: T.unsafe(nil), sort_nodes: T.unsafe(nil)); end
-
-  sig { returns(T::Boolean) }
-  def add_sig_templates; end
-
-  def add_sig_templates=(_arg0); end
-
-  sig { params(file: ::RBI::File).void }
-  def format_file(file); end
-
-  sig { params(tree: ::RBI::Tree).void }
-  def format_tree(tree); end
-
-  def group_nodes; end
-  def group_nodes=(_arg0); end
-
-  sig { returns(T.nilable(::Integer)) }
-  def max_line_length; end
-
-  def max_line_length=(_arg0); end
-  def nest_non_public_methods; end
-  def nest_non_public_methods=(_arg0); end
-  def nest_singleton_methods; end
-  def nest_singleton_methods=(_arg0); end
-
-  sig { params(file: ::RBI::File).returns(::String) }
-  def print_file(file); end
-
-  sig { params(tree: ::RBI::Tree).returns(::String) }
-  def print_tree(tree); end
-
-  def sort_nodes; end
-  def sort_nodes=(_arg0); end
-end
-
-class RBI::Group < ::RBI::Tree
-  sig { params(kind: ::RBI::Group::Kind).void }
-  def initialize(kind); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(::RBI::Group::Kind) }
-  def kind; end
-end
-
-class RBI::Group::Kind < ::T::Enum
-  enums do
-    Mixins = new
-    RequiredAncestors = new
-    Helpers = new
-    TypeMembers = new
-    MixesInClassMethods = new
-    Sends = new
-    Attrs = new
-    TStructFields = new
-    TEnums = new
-    Inits = new
-    Methods = new
-    SingletonClasses = new
-    Consts = new
-  end
-end
-
-class RBI::Helper < ::RBI::NodeWithComments
-  include ::RBI::Indexable
-
-  sig do
-    params(
-      name: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Helper).void)
-    ).void
-  end
-  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { override.returns(T::Array[::String]) }
-  def index_ids; end
-
-  sig { returns(::String) }
-  def name; end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::Include < ::RBI::Mixin
-  include ::RBI::Indexable
-
-  sig do
-    params(
-      name: ::String,
-      names: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Include).void)
-    ).void
-  end
-  def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { override.returns(T::Array[::String]) }
-  def index_ids; end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::Index < ::RBI::Visitor
-  sig { void }
-  def initialize; end
-
-  sig { params(id: ::String).returns(T::Array[::RBI::Node]) }
-  def [](id); end
-
-  sig { params(nodes: ::RBI::Node).void }
-  def index(*nodes); end
-
-  sig { returns(T::Array[::String]) }
-  def keys; end
-
-  sig { override.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
-
-  private
-
-  sig { params(node: T.all(::RBI::Indexable, ::RBI::Node)).void }
-  def index_node(node); end
-
-  class << self
-    sig { params(node: ::RBI::Node).returns(::RBI::Index) }
-    def index(*node); end
-  end
-end
-
-module RBI::Indexable
-  interface!
-
-  sig { abstract.returns(T::Array[::String]) }
-  def index_ids; end
-end
-
-class RBI::KwArg < ::RBI::Arg
-  sig { params(keyword: ::String, value: ::String, loc: T.nilable(::RBI::Loc)).void }
-  def initialize(keyword, value, loc: T.unsafe(nil)); end
-
-  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(::String) }
-  def keyword; end
-
-  sig { returns(::String) }
-  def to_s; end
-end
-
-class RBI::KwOptParam < ::RBI::Param
-  sig do
-    params(
-      name: ::String,
-      value: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::KwOptParam).void)
-    ).void
-  end
-  def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { override.params(v: ::RBI::Printer, last: T::Boolean).void }
-  def print_comment_leading_space(v, last:); end
-
-  sig { override.returns(::String) }
-  def to_s; end
-
-  sig { returns(::String) }
-  def value; end
-end
-
-class RBI::KwParam < ::RBI::Param
-  sig do
-    params(
-      name: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::KwParam).void)
-    ).void
-  end
-  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { override.params(v: ::RBI::Printer, last: T::Boolean).void }
-  def print_comment_leading_space(v, last:); end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::KwRestParam < ::RBI::Param
-  sig do
-    params(
-      name: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::KwRestParam).void)
-    ).void
-  end
-  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { override.params(v: ::RBI::Printer, last: T::Boolean).void }
-  def print_comment_leading_space(v, last:); end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::Loc
-  sig do
-    params(
-      file: T.nilable(::String),
-      begin_line: T.nilable(::Integer),
-      end_line: T.nilable(::Integer),
-      begin_column: T.nilable(::Integer),
-      end_column: T.nilable(::Integer)
-    ).void
-  end
-  def initialize(file: T.unsafe(nil), begin_line: T.unsafe(nil), end_line: T.unsafe(nil), begin_column: T.unsafe(nil), end_column: T.unsafe(nil)); end
-
-  def begin_column; end
-
-  sig { returns(T.nilable(::Integer)) }
-  def begin_line; end
-
-  def end_column; end
-  def end_line; end
-
-  sig { returns(T.nilable(::String)) }
-  def file; end
-
-  sig { returns(T.nilable(::String)) }
-  def source; end
-
-  sig { returns(::String) }
-  def to_s; end
-
-  class << self
-    sig { params(file: ::String, ast_loc: T.any(::Parser::Source::Map, ::Parser::Source::Range)).returns(::RBI::Loc) }
-    def from_ast_loc(file, ast_loc); end
-  end
-end
-
-class RBI::MergeTree < ::RBI::Tree
-  sig do
-    params(
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      conflicts: T::Array[::RBI::Rewriters::Merge::Conflict],
-      block: T.nilable(T.proc.params(node: ::RBI::Tree).void)
-    ).void
-  end
-  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), conflicts: T.unsafe(nil), &block); end
-
-  sig { returns(T::Array[::RBI::Rewriters::Merge::Conflict]) }
-  def conflicts; end
-end
-
-class RBI::Method < ::RBI::NodeWithComments
-  include ::RBI::Indexable
-
-  sig do
-    params(
-      name: ::String,
-      params: T::Array[::RBI::Param],
-      is_singleton: T::Boolean,
-      visibility: ::RBI::Visibility,
-      sigs: T::Array[::RBI::Sig],
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Method).void)
-    ).void
-  end
-  def initialize(name, params: T.unsafe(nil), is_singleton: T.unsafe(nil), visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(param: ::RBI::Param).void }
-  def <<(param); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { returns(::String) }
-  def fully_qualified_name; end
-
-  sig { override.returns(T::Array[::String]) }
-  def index_ids; end
-
-  sig { returns(T::Boolean) }
-  def inline_params?; end
-
-  sig { returns(T::Boolean) }
-  def is_singleton; end
-
-  def is_singleton=(_arg0); end
-
-  sig { override.params(other: ::RBI::Node).void }
-  def merge_with(other); end
-
-  sig { returns(::String) }
-  def name; end
-
-  def name=(_arg0); end
-
-  sig { override.returns(T::Boolean) }
-  def oneline?; end
-
-  sig { returns(T::Array[::RBI::Param]) }
-  def params; end
-
-  sig { returns(T::Array[::RBI::Sig]) }
-  def sigs; end
-
-  def sigs=(_arg0); end
-
-  sig { override.returns(::String) }
-  def to_s; end
-
-  sig { returns(::RBI::Visibility) }
-  def visibility; end
-
-  def visibility=(_arg0); end
-end
-
-class RBI::MixesInClassMethods < ::RBI::Mixin
-  include ::RBI::Indexable
-
-  sig do
-    params(
-      name: ::String,
-      names: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::MixesInClassMethods).void)
-    ).void
-  end
-  def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { override.returns(T::Array[::String]) }
-  def index_ids; end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::Mixin < ::RBI::NodeWithComments
-  abstract!
-
-  sig do
-    params(
-      name: ::String,
-      names: T::Array[::String],
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment]
-    ).void
-  end
-  def initialize(name, names, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { returns(T::Array[::String]) }
-  def names; end
-
-  def names=(_arg0); end
-end
-
-class RBI::Module < ::RBI::Scope
-  sig do
-    params(
-      name: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Module).void)
-    ).void
-  end
-  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { override.returns(::String) }
-  def fully_qualified_name; end
-
-  sig { returns(::String) }
-  def name; end
-
-  def name=(_arg0); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def print_header(v); end
-end
-
-class RBI::Node
-  abstract!
-
-  sig { params(loc: T.nilable(::RBI::Loc)).void }
-  def initialize(loc: T.unsafe(nil)); end
-
-  sig { abstract.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { params(_other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(_other); end
-
-  sig { void }
-  def detach; end
-
-  sig { returns(::RBI::Group::Kind) }
-  def group_kind; end
-
-  sig { returns(T.nilable(::RBI::Loc)) }
-  def loc; end
-
-  def loc=(_arg0); end
-
-  sig { params(other: ::RBI::Node).void }
-  def merge_with(other); end
-
-  sig { returns(T::Boolean) }
-  def oneline?; end
-
-  sig { returns(T.nilable(::RBI::ConflictTree)) }
-  def parent_conflict_tree; end
-
-  sig { returns(T.nilable(::RBI::Scope)) }
-  def parent_scope; end
-
-  sig { returns(T.nilable(::RBI::Tree)) }
-  def parent_tree; end
-
-  def parent_tree=(_arg0); end
-
-  sig do
-    params(
-      out: T.any(::IO, ::StringIO),
-      indent: ::Integer,
-      print_locs: T::Boolean,
-      max_line_length: T.nilable(::Integer)
-    ).void
-  end
-  def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
-
-  sig { params(v: ::RBI::Printer).void }
-  def print_blank_line_before(v); end
-
-  sig { params(node: ::RBI::Node).void }
-  def replace(node); end
-
-  sig { params(indent: ::Integer, print_locs: T::Boolean, max_line_length: T.nilable(::Integer)).returns(::String) }
-  def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
-end
-
-class RBI::NodeWithComments < ::RBI::Node
-  abstract!
-
-  sig { params(loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
-  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil)); end
-
-  sig { returns(T::Array[::String]) }
-  def annotations; end
-
-  sig { returns(T::Array[::RBI::Comment]) }
-  def comments; end
-
-  def comments=(_arg0); end
-
-  sig { override.params(other: ::RBI::Node).void }
-  def merge_with(other); end
-
-  sig { override.returns(T::Boolean) }
-  def oneline?; end
-end
-
-class RBI::OptParam < ::RBI::Param
-  sig do
-    params(
-      name: ::String,
-      value: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::OptParam).void)
-    ).void
-  end
-  def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { override.params(v: ::RBI::Printer, last: T::Boolean).void }
-  def print_comment_leading_space(v, last:); end
-
-  sig { returns(::String) }
-  def value; end
-end
-
-class RBI::Param < ::RBI::NodeWithComments
-  abstract!
-
-  sig { params(name: ::String, loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
-  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(T::Array[::String]) }
-  def comments_lines; end
-
-  sig { returns(::String) }
-  def name; end
-
-  sig { params(v: ::RBI::Printer, last: T::Boolean).void }
-  def print_comment_leading_space(v, last:); end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::ParseError < ::StandardError
-  sig { params(message: ::String, location: ::RBI::Loc).void }
-  def initialize(message, location); end
-
-  sig { returns(::RBI::Loc) }
-  def location; end
-end
-
-class RBI::Parser
-  sig { void }
-  def initialize; end
-
-  sig { params(path: ::String).returns(::RBI::Tree) }
-  def parse_file(path); end
-
-  sig { params(string: ::String).returns(::RBI::Tree) }
-  def parse_string(string); end
-
-  private
-
-  sig { params(content: ::String, file: ::String).returns(::RBI::Tree) }
-  def parse(content, file:); end
-
-  class << self
-    sig { params(path: ::String).returns(::RBI::Tree) }
-    def parse_file(path); end
-
-    sig { params(paths: T::Array[::String]).returns(T::Array[::RBI::Tree]) }
-    def parse_files(paths); end
-
-    sig { params(string: ::String).returns(::RBI::Tree) }
-    def parse_string(string); end
-
-    sig { params(strings: T::Array[::String]).returns(T::Array[::RBI::Tree]) }
-    def parse_strings(strings); end
-  end
-end
-
-class RBI::Printer < ::RBI::Visitor
-  sig do
-    params(
-      out: T.any(::IO, ::StringIO),
-      indent: ::Integer,
-      print_locs: T::Boolean,
-      max_line_length: T.nilable(::Integer)
-    ).void
-  end
-  def initialize(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
-
-  sig { returns(::Integer) }
-  def current_indent; end
-
-  sig { void }
-  def dedent; end
-
-  def in_visibility_group; end
-  def in_visibility_group=(_arg0); end
-
-  sig { void }
-  def indent; end
-
-  sig { returns(T.nilable(::Integer)) }
-  def max_line_length; end
-
-  sig { returns(T.nilable(::RBI::Node)) }
-  def previous_node; end
-
-  sig { params(string: ::String).void }
-  def print(string); end
-
-  sig { returns(T::Boolean) }
-  def print_locs; end
-
-  def print_locs=(_arg0); end
-
-  sig { params(string: ::String).void }
-  def printl(string); end
-
-  sig { params(string: T.nilable(::String)).void }
-  def printn(string = T.unsafe(nil)); end
-
-  sig { params(string: T.nilable(::String)).void }
-  def printt(string = T.unsafe(nil)); end
-
-  sig { override.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
-
-  sig { override.params(nodes: T::Array[::RBI::Node]).void }
-  def visit_all(nodes); end
-
-  sig { params(file: ::RBI::File).void }
-  def visit_file(file); end
-end
-
-class RBI::Private < ::RBI::Visibility
-  sig do
-    params(
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Private).void)
-    ).void
-  end
-  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-end
-
-class RBI::Protected < ::RBI::Visibility
-  sig do
-    params(
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Protected).void)
-    ).void
-  end
-  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-end
-
-class RBI::Public < ::RBI::Visibility
-  sig do
-    params(
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Public).void)
-    ).void
-  end
-  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-end
-
-class RBI::ReqParam < ::RBI::Param
-  sig do
-    params(
-      name: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::ReqParam).void)
-    ).void
-  end
-  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
-  def ==(other); end
-end
-
-class RBI::RequiresAncestor < ::RBI::NodeWithComments
-  include ::RBI::Indexable
-
-  sig { params(name: ::String, loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
-  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { override.returns(T::Array[::String]) }
-  def index_ids; end
-
-  sig { returns(::String) }
-  def name; end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::RestParam < ::RBI::Param
-  sig do
-    params(
-      name: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::RestParam).void)
-    ).void
-  end
-  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { override.params(v: ::RBI::Printer, last: T::Boolean).void }
-  def print_comment_leading_space(v, last:); end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-module RBI::Rewriters; end
-
-class RBI::Rewriters::AddSigTemplates < ::RBI::Visitor
-  sig { params(with_todo_comment: T::Boolean).void }
-  def initialize(with_todo_comment: T.unsafe(nil)); end
-
-  sig { override.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
-
-  private
-
-  sig { params(attr: ::RBI::Attr).void }
-  def add_attr_sig(attr); end
-
-  sig { params(method: ::RBI::Method).void }
-  def add_method_sig(method); end
-
-  sig { params(node: ::RBI::NodeWithComments).void }
-  def add_todo_comment(node); end
-end
-
-class RBI::Rewriters::Annotate < ::RBI::Visitor
-  sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
-  def initialize(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end
-
-  sig { override.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
-
-  private
-
-  sig { params(node: ::RBI::NodeWithComments).void }
-  def annotate_node(node); end
-
-  sig { params(node: ::RBI::Node).returns(T::Boolean) }
-  def root?(node); end
-end
-
-class RBI::Rewriters::Deannotate < ::RBI::Visitor
-  sig { params(annotation: ::String).void }
-  def initialize(annotation); end
-
-  sig { override.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
-
-  private
-
-  sig { params(node: ::RBI::NodeWithComments).void }
-  def deannotate_node(node); end
-end
-
-class RBI::Rewriters::GroupNodes < ::RBI::Visitor
-  sig { override.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
-end
-
-class RBI::Rewriters::Merge
-  sig { params(left_name: ::String, right_name: ::String, keep: ::RBI::Rewriters::Merge::Keep).void }
-  def initialize(left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
-
-  sig { params(tree: ::RBI::Tree).void }
-  def merge(tree); end
-
-  sig { returns(::RBI::MergeTree) }
-  def tree; end
-
-  class << self
-    sig do
-      params(
-        left: ::RBI::Tree,
-        right: ::RBI::Tree,
-        left_name: ::String,
-        right_name: ::String,
-        keep: ::RBI::Rewriters::Merge::Keep
-      ).returns(::RBI::MergeTree)
-    end
-    def merge_trees(left, right, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
-  end
-end
-
-class RBI::Rewriters::Merge::Conflict < ::T::Struct
-  const :left, ::RBI::Node
-  const :left_name, ::String
-  const :right, ::RBI::Node
-  const :right_name, ::String
-
-  sig { returns(::String) }
-  def to_s; end
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-class RBI::Rewriters::Merge::ConflictTreeMerger < ::RBI::Visitor
-  sig { override.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
-
-  sig { override.params(nodes: T::Array[::RBI::Node]).void }
-  def visit_all(nodes); end
-
-  private
-
-  sig { params(left: ::RBI::Tree, right: ::RBI::Tree).void }
-  def merge_conflict_trees(left, right); end
-end
-
-class RBI::Rewriters::Merge::Keep < ::T::Enum
-  enums do
-    NONE = new
-    LEFT = new
-    RIGHT = new
-  end
-end
-
-class RBI::Rewriters::Merge::TreeMerger < ::RBI::Visitor
-  sig do
-    params(
-      output: ::RBI::Tree,
-      left_name: ::String,
-      right_name: ::String,
-      keep: ::RBI::Rewriters::Merge::Keep
-    ).void
-  end
-  def initialize(output, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
-
-  sig { returns(T::Array[::RBI::Rewriters::Merge::Conflict]) }
-  def conflicts; end
-
-  sig { override.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
-
-  private
-
-  sig { returns(::RBI::Tree) }
-  def current_scope; end
-
-  sig { params(left: ::RBI::Scope, right: ::RBI::Scope).void }
-  def make_conflict_scope(left, right); end
-
-  sig { params(left: ::RBI::Node, right: ::RBI::Node).void }
-  def make_conflict_tree(left, right); end
-
-  sig { params(node: ::RBI::Node).returns(T.nilable(::RBI::Node)) }
-  def previous_definition(node); end
-
-  sig { params(left: ::RBI::Scope, right: ::RBI::Scope).returns(::RBI::Scope) }
-  def replace_scope_header(left, right); end
-end
-
-class RBI::Rewriters::NestNonPublicMethods < ::RBI::Visitor
-  sig { override.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
-end
-
-class RBI::Rewriters::NestSingletonMethods < ::RBI::Visitor
-  sig { override.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
-end
-
-class RBI::Rewriters::RemoveKnownDefinitions < ::RBI::Visitor
-  sig { params(index: ::RBI::Index).void }
-  def initialize(index); end
-
-  sig { returns(T::Array[::RBI::Rewriters::RemoveKnownDefinitions::Operation]) }
-  def operations; end
-
-  sig { override.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
-
-  sig { params(nodes: T::Array[::RBI::Node]).void }
-  def visit_all(nodes); end
-
-  private
-
-  sig { params(node: ::RBI::Node, previous: ::RBI::Node).returns(T::Boolean) }
-  def can_delete_node?(node, previous); end
-
-  sig { params(node: ::RBI::Node, previous: ::RBI::Node).void }
-  def delete_node(node, previous); end
-
-  sig { params(node: ::RBI::Indexable).returns(T.nilable(::RBI::Node)) }
-  def previous_definition_for(node); end
-
-  class << self
-    sig do
-      params(
-        tree: ::RBI::Tree,
-        index: ::RBI::Index
-      ).returns([::RBI::Tree, T::Array[::RBI::Rewriters::RemoveKnownDefinitions::Operation]])
-    end
-    def remove(tree, index); end
-  end
-end
-
-class RBI::Rewriters::RemoveKnownDefinitions::Operation < ::T::Struct
-  const :deleted_node, ::RBI::Node
-  const :duplicate_of, ::RBI::Node
-
-  sig { returns(::String) }
-  def to_s; end
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-class RBI::Rewriters::SortNodes < ::RBI::Visitor
-  sig { override.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
-
-  private
-
-  sig { params(kind: ::RBI::Group::Kind).returns(::Integer) }
-  def group_rank(kind); end
-
-  sig { params(node: ::RBI::Node).returns(T.nilable(::String)) }
-  def node_name(node); end
-
-  sig { params(node: ::RBI::Node).returns(::Integer) }
-  def node_rank(node); end
-
-  sig { params(node: ::RBI::Node).void }
-  def sort_node_names!(node); end
-end
-
-class RBI::Scope < ::RBI::Tree
-  include ::RBI::Indexable
-
-  abstract!
-
-  def initialize(*args, &blk); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(T.self_type) }
-  def dup_empty; end
-
-  sig { abstract.returns(::String) }
-  def fully_qualified_name; end
-
-  sig { override.returns(T::Array[::String]) }
-  def index_ids; end
-
-  sig { params(v: ::RBI::Printer).void }
-  def print_body(v); end
-
-  sig { abstract.params(v: ::RBI::Printer).void }
-  def print_header(v); end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::ScopeConflict < ::RBI::Tree
-  sig { params(left: ::RBI::Scope, right: ::RBI::Scope, left_name: ::String, right_name: ::String).void }
-  def initialize(left:, right:, left_name: T.unsafe(nil), right_name: T.unsafe(nil)); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(::RBI::Scope) }
-  def left; end
-
-  sig { override.returns(T::Boolean) }
-  def oneline?; end
-
-  def right; end
-end
-
-class RBI::Send < ::RBI::NodeWithComments
-  include ::RBI::Indexable
-
-  sig do
-    params(
-      method: ::String,
-      args: T::Array[::RBI::Arg],
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Send).void)
-    ).void
-  end
-  def initialize(method, args = T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(arg: ::RBI::Arg).void }
-  def <<(arg); end
-
-  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(T::Array[::RBI::Arg]) }
-  def args; end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { override.returns(T::Array[::String]) }
-  def index_ids; end
-
-  sig { returns(::String) }
-  def method; end
-
-  sig { returns(::String) }
-  def to_s; end
-end
-
-class RBI::Sig < ::RBI::Node
-  sig do
-    params(
-      params: T::Array[::RBI::SigParam],
-      return_type: T.nilable(::String),
-      is_abstract: T::Boolean,
-      is_override: T::Boolean,
-      is_overridable: T::Boolean,
-      is_final: T::Boolean,
-      type_params: T::Array[::String],
-      checked: T.nilable(::Symbol),
-      loc: T.nilable(::RBI::Loc),
-      block: T.nilable(T.proc.params(node: ::RBI::Sig).void)
-    ).void
-  end
-  def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), loc: T.unsafe(nil), &block); end
-
-  sig { params(param: ::RBI::SigParam).void }
-  def <<(param); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(T.nilable(::Symbol)) }
-  def checked; end
-
-  def checked=(_arg0); end
-
-  sig { returns(T::Boolean) }
-  def inline_params?; end
-
-  sig { returns(T::Boolean) }
-  def is_abstract; end
-
-  def is_abstract=(_arg0); end
-  def is_final; end
-  def is_final=(_arg0); end
-  def is_overridable; end
-  def is_overridable=(_arg0); end
-  def is_override; end
-  def is_override=(_arg0); end
-
-  sig { override.returns(T::Boolean) }
-  def oneline?; end
-
-  sig { returns(T::Array[::RBI::SigParam]) }
-  def params; end
-
-  sig { returns(T.nilable(::String)) }
-  def return_type; end
-
-  def return_type=(_arg0); end
-
-  sig { returns(T::Array[::String]) }
-  def type_params; end
-
-  private
-
-  sig { params(v: ::RBI::Printer).void }
-  def print_as_block(v); end
-
-  sig { params(v: ::RBI::Printer).void }
-  def print_as_line(v); end
-
-  sig { returns(T::Array[::String]) }
-  def sig_modifiers; end
-end
-
-class RBI::SigBuilder < ::RBI::ASTVisitor
-  sig { void }
-  def initialize; end
-
-  sig { returns(::RBI::Sig) }
-  def current; end
-
-  def current=(_arg0); end
-
-  sig { override.params(node: T.nilable(::AST::Node)).void }
-  def visit(node); end
-
-  sig { params(node: ::AST::Node).void }
-  def visit_send(node); end
-
-  class << self
-    sig { params(node: ::AST::Node).returns(::RBI::Sig) }
-    def build(node); end
-  end
-end
-
-class RBI::SigParam < ::RBI::NodeWithComments
-  sig do
-    params(
-      name: ::String,
-      type: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::SigParam).void)
-    ).void
-  end
-  def initialize(name, type, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(other: ::Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(T::Array[::String]) }
-  def comments_lines; end
-
-  sig { returns(::String) }
-  def name; end
-
-  sig { params(v: ::RBI::Printer, last: T::Boolean).void }
-  def print_comment_leading_space(v, last:); end
-
-  def type; end
-end
-
-class RBI::SingletonClass < ::RBI::Scope
-  sig do
-    params(
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::SingletonClass).void)
-    ).void
-  end
-  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.returns(::String) }
-  def fully_qualified_name; end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def print_header(v); end
-end
-
-class RBI::Struct < ::RBI::Scope
-  sig do
-    params(
-      name: ::String,
-      members: T::Array[::Symbol],
-      keyword_init: T::Boolean,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(struct: ::RBI::Struct).void)
-    ).void
-  end
-  def initialize(name, members: T.unsafe(nil), keyword_init: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { override.returns(::String) }
-  def fully_qualified_name; end
-
-  sig { returns(T::Boolean) }
-  def keyword_init; end
-
-  def keyword_init=(_arg0); end
-
-  sig { returns(T::Array[::Symbol]) }
-  def members; end
-
-  def members=(_arg0); end
-
-  sig { returns(::String) }
-  def name; end
-
-  def name=(_arg0); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def print_header(v); end
-end
-
-class RBI::TEnum < ::RBI::Class
-  sig do
-    params(
-      name: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(klass: ::RBI::TEnum).void)
-    ).void
-  end
-  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-end
-
-class RBI::TEnumBlock < ::RBI::NodeWithComments
-  include ::RBI::Indexable
-
-  sig do
-    params(
-      names: T::Array[::String],
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::TEnumBlock).void)
-    ).void
-  end
-  def initialize(names = T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(name: ::String).void }
-  def <<(name); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(T::Boolean) }
-  def empty?; end
-
-  sig { override.returns(T::Array[::String]) }
-  def index_ids; end
-
-  sig { override.params(other: ::RBI::Node).void }
-  def merge_with(other); end
-
-  sig { returns(T::Array[::String]) }
-  def names; end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::TStruct < ::RBI::Class
-  sig do
-    params(
-      name: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(klass: ::RBI::TStruct).void)
-    ).void
-  end
-  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-end
-
-class RBI::TStructConst < ::RBI::TStructField
-  include ::RBI::Indexable
-
-  sig do
-    params(
-      name: ::String,
-      type: ::String,
-      default: T.nilable(::String),
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::TStructConst).void)
-    ).void
-  end
-  def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { override.returns(T::Array[::String]) }
-  def fully_qualified_names; end
-
-  sig { override.returns(T::Array[::String]) }
-  def index_ids; end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::TStructField < ::RBI::NodeWithComments
-  abstract!
-
-  sig do
-    params(
-      name: ::String,
-      type: ::String,
-      default: T.nilable(::String),
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment]
-    ).void
-  end
-  def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil)); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { returns(T.nilable(::String)) }
-  def default; end
-
-  def default=(_arg0); end
-
-  sig { abstract.returns(T::Array[::String]) }
-  def fully_qualified_names; end
-
-  sig { returns(::String) }
-  def name; end
-
-  def name=(_arg0); end
-  def type; end
-  def type=(_arg0); end
-end
-
-class RBI::TStructProp < ::RBI::TStructField
-  include ::RBI::Indexable
-
-  sig do
-    params(
-      name: ::String,
-      type: ::String,
-      default: T.nilable(::String),
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::TStructProp).void)
-    ).void
-  end
-  def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
-  def compatible_with?(other); end
-
-  sig { override.returns(T::Array[::String]) }
-  def fully_qualified_names; end
-
-  sig { override.returns(T::Array[::String]) }
-  def index_ids; end
-
-  sig { override.returns(::String) }
-  def to_s; end
-end
-
-class RBI::Tree < ::RBI::NodeWithComments
-  sig do
-    params(
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Tree).void)
-    ).void
-  end
-  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(node: ::RBI::Node).void }
-  def <<(node); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { params(with_todo_comment: T::Boolean).void }
-  def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end
-
-  sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
-  def annotate!(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end
-
-  sig do
-    params(
-      name: ::String,
-      superclass_name: T.nilable(::String),
-      block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)
-    ).returns(::RBI::Scope)
-  end
-  def create_class(name, superclass_name: T.unsafe(nil), &block); end
-
-  sig { params(name: ::String, value: ::String).void }
-  def create_constant(name, value:); end
-
-  sig { params(name: ::String).void }
-  def create_extend(name); end
-
-  sig { params(name: ::String).void }
-  def create_include(name); end
-
-  sig do
-    params(
-      name: ::String,
-      parameters: T::Array[::RBI::TypedParam],
-      return_type: ::String,
-      class_method: T::Boolean,
-      visibility: ::RBI::Visibility
-    ).void
-  end
-  def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil), visibility: T.unsafe(nil)); end
-
-  sig { params(name: ::String).void }
-  def create_mixes_in_class_methods(name); end
-
-  sig { params(name: ::String, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
-  def create_module(name, &block); end
-
-  sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).void }
-  def create_path(constant, &block); end
-
-  sig do
-    params(
-      name: ::String,
-      type: ::String,
-      variance: ::Symbol,
-      fixed: T.nilable(::String),
-      upper: T.nilable(::String),
-      lower: T.nilable(::String)
-    ).void
-  end
-  def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end
-
-  sig { params(annotation: ::String).void }
-  def deannotate!(annotation); end
-
-  sig { returns(T::Boolean) }
-  def empty?; end
-
-  sig { void }
-  def group_nodes!; end
-
-  sig { returns(::RBI::Index) }
-  def index; end
-
-  sig do
-    params(
-      other: ::RBI::Tree,
-      left_name: ::String,
-      right_name: ::String,
-      keep: ::RBI::Rewriters::Merge::Keep
-    ).returns(::RBI::MergeTree)
-  end
-  def merge(other, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
-
-  sig { void }
-  def nest_non_public_methods!; end
-
-  sig { void }
-  def nest_singleton_methods!; end
-
-  sig { returns(T::Array[::RBI::Node]) }
-  def nodes; end
-
-  sig { override.returns(T::Boolean) }
-  def oneline?; end
-
-  sig { void }
-  def sort_nodes!; end
-
-  private
-
-  sig { params(node: ::RBI::Node).returns(::RBI::Node) }
-  def create_node(node); end
-
-  sig { returns(T::Hash[::String, ::RBI::Node]) }
-  def nodes_cache; end
-
-  sig { params(name: ::String).returns(T::Boolean) }
-  def valid_method_name?(name); end
-end
-
-RBI::Tree::SPECIAL_METHOD_NAMES = T.let(T.unsafe(nil), Array)
-
-class RBI::TreeBuilder < ::RBI::ASTVisitor
-  sig do
-    params(
-      file: ::String,
-      comments: T::Array[::Parser::Source::Comment],
-      nodes_comments_assoc: T::Hash[::Parser::Source::Map, T::Array[::Parser::Source::Comment]]
-    ).void
-  end
-  def initialize(file:, comments: T.unsafe(nil), nodes_comments_assoc: T.unsafe(nil)); end
-
-  sig { returns(T.nilable(::AST::Node)) }
-  def last_node; end
-
-  sig { void }
-  def post_process; end
-
-  sig { returns(::RBI::Tree) }
-  def tree; end
-
-  sig { override.params(node: T.nilable(::Object)).void }
-  def visit(node); end
-
-  private
-
-  sig { void }
-  def assoc_dangling_comments; end
-
-  sig { returns(::RBI::Tree) }
-  def current_scope; end
-
-  sig { returns(T::Array[::RBI::Sig]) }
-  def current_sigs; end
-
-  sig { params(node: ::AST::Node).returns(T::Array[::RBI::Comment]) }
-  def node_comments(node); end
-
-  sig { params(node: ::AST::Node).returns(::RBI::Loc) }
-  def node_loc(node); end
-
-  sig { params(node: ::AST::Node).returns(T.nilable(::RBI::Node)) }
-  def parse_block(node); end
-
-  sig { params(node: ::AST::Node).returns(::RBI::Node) }
-  def parse_const_assign(node); end
-
-  sig { params(node: ::AST::Node).returns(::RBI::Method) }
-  def parse_def(node); end
-
-  sig { params(node: ::AST::Node).returns(::RBI::TEnumBlock) }
-  def parse_enum(node); end
-
-  sig { params(node: ::AST::Node).returns(::RBI::Param) }
-  def parse_param(node); end
-
-  sig { params(node: ::AST::Node).returns(::RBI::RequiresAncestor) }
-  def parse_requires_ancestor(node); end
-
-  sig { params(node: ::AST::Node).returns(::RBI::Scope) }
-  def parse_scope(node); end
-
-  sig { params(node: ::AST::Node).returns(T.nilable(::RBI::Node)) }
-  def parse_send(node); end
-
-  sig { params(node: ::AST::Node).returns(T::Array[::RBI::Arg]) }
-  def parse_send_args(node); end
-
-  sig { params(node: ::AST::Node).returns(::RBI::Sig) }
-  def parse_sig(node); end
-
-  sig { params(node: ::AST::Node).returns(::RBI::Struct) }
-  def parse_struct(node); end
-
-  sig { params(node: ::AST::Node).returns([::String, ::String, T.nilable(::String)]) }
-  def parse_tstruct_prop(node); end
-
-  sig { void }
-  def separate_header_comments; end
-
-  sig { void }
-  def set_root_tree_loc; end
-
-  sig { params(node: ::AST::Node).returns(T::Boolean) }
-  def struct_definition?(node); end
-end
-
-class RBI::TypeMember < ::RBI::NodeWithComments
-  sig do
-    params(
-      name: ::String,
-      value: ::String,
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::TypeMember).void)
-    ).void
-  end
-  def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(::String) }
-  def fully_qualified_name; end
-
-  sig { returns(::String) }
-  def name; end
-
-  sig { override.returns(::String) }
-  def to_s; end
-
-  def value; end
-end
-
-class RBI::UnexpectedParserError < ::StandardError
-  sig { params(parent_exception: ::Exception, last_location: ::RBI::Loc).void }
-  def initialize(parent_exception, last_location); end
-
-  sig { returns(::RBI::Loc) }
-  def last_location; end
-
-  sig { params(io: T.any(::IO, ::StringIO)).void }
-  def print_debug(io: T.unsafe(nil)); end
-end
-
-RBI::VERSION = T.let(T.unsafe(nil), String)
-
-class RBI::Visibility < ::RBI::NodeWithComments
-  abstract!
-
-  sig { params(visibility: ::Symbol, loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
-  def initialize(visibility, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
-
-  sig { params(other: ::RBI::Visibility).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { returns(T::Boolean) }
-  def private?; end
-
-  sig { returns(T::Boolean) }
-  def protected?; end
-
-  sig { returns(T::Boolean) }
-  def public?; end
-
-  sig { returns(::Symbol) }
-  def visibility; end
-end
-
-class RBI::VisibilityGroup < ::RBI::Tree
-  sig { params(visibility: ::RBI::Visibility).void }
-  def initialize(visibility); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { override.returns(T::Boolean) }
-  def oneline?; end
-
-  sig { returns(::RBI::Visibility) }
-  def visibility; end
-end
-
-class RBI::Visitor
-  abstract!
-
-  def initialize(*args, &blk); end
-
-  sig { abstract.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
-
-  sig { params(nodes: T::Array[::RBI::Node]).void }
-  def visit_all(nodes); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rbi@0.2.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rbi@0.2.1.rbi
new file mode 100644
index 0000000000000..d2b7262bc350b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/rbi@0.2.1.rbi
@@ -0,0 +1,4535 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rbi` gem.
+# Please instead update this file by running `bin/tapioca gem rbi`.
+
+
+# source://rbi//lib/rbi.rb#7
+module RBI; end
+
+# source://rbi//lib/rbi/model.rb#1045
+class RBI::Arg < ::RBI::Node
+  # source://rbi//lib/rbi/model.rb#1057
+  sig { params(value: ::String, loc: T.nilable(::RBI::Loc)).void }
+  def initialize(value, loc: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/model.rb#1063
+  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/model.rb#1068
+  sig { returns(::String) }
+  def to_s; end
+
+  # source://rbi//lib/rbi/model.rb#1049
+  sig { returns(::String) }
+  def value; end
+end
+
+# Attributes
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/model.rb#351
+class RBI::Attr < ::RBI::NodeWithComments
+  include ::RBI::Indexable
+
+  abstract!
+
+  # source://rbi//lib/rbi/model.rb#376
+  sig do
+    params(
+      name: ::Symbol,
+      names: T::Array[::Symbol],
+      visibility: ::RBI::Visibility,
+      sigs: T::Array[::RBI::Sig],
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment]
+    ).void
+  end
+  def initialize(name, names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#420
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # @abstract
+  #
+  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#61
+  sig { abstract.returns(T::Array[::RBI::Method]) }
+  def convert_to_methods; end
+
+  # @abstract
+  #
+  # source://rbi//lib/rbi/model.rb#384
+  sig { abstract.returns(T::Array[::String]) }
+  def fully_qualified_names; end
+
+  # source://rbi//lib/rbi/index.rb#113
+  sig { override.returns(T::Array[::String]) }
+  def index_ids; end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#428
+  sig { override.params(other: ::RBI::Node).void }
+  def merge_with(other); end
+
+  # source://rbi//lib/rbi/model.rb#358
+  sig { returns(T::Array[::Symbol]) }
+  def names; end
+
+  # source://rbi//lib/rbi/model.rb#364
+  sig { returns(T::Array[::RBI::Sig]) }
+  def sigs; end
+
+  # source://rbi//lib/rbi/model.rb#361
+  sig { returns(::RBI::Visibility) }
+  def visibility; end
+
+  # @return [Visibility]
+  #
+  # source://rbi//lib/rbi/model.rb#361
+  def visibility=(_arg0); end
+
+  private
+
+  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#89
+  sig do
+    params(
+      name: ::String,
+      sig: T.nilable(::RBI::Sig),
+      visibility: ::RBI::Visibility,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment]
+    ).returns(::RBI::Method)
+  end
+  def create_getter_method(name, sig, visibility, loc, comments); end
+
+  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#110
+  sig do
+    params(
+      name: ::String,
+      sig: T.nilable(::RBI::Sig),
+      attribute_type: T.nilable(T.any(::RBI::Type, ::String)),
+      visibility: ::RBI::Visibility,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment]
+    ).returns(::RBI::Method)
+  end
+  def create_setter_method(name, sig, attribute_type, visibility, loc, comments); end
+
+  # @raise [UnexpectedMultipleSigsError]
+  #
+  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#66
+  sig(:final) { returns([T.nilable(::RBI::Sig), T.nilable(T.any(::RBI::Type, ::String))]) }
+  def parse_sig; end
+end
+
+# source://rbi//lib/rbi/model.rb#387
+class RBI::AttrAccessor < ::RBI::Attr
+  # source://rbi//lib/rbi/model.rb#401
+  sig do
+    params(
+      name: ::Symbol,
+      names: ::Symbol,
+      visibility: ::RBI::Visibility,
+      sigs: T::Array[::RBI::Sig],
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::AttrAccessor).void)
+    ).void
+  end
+  def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#460
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#140
+  sig { override.returns(T::Array[::RBI::Method]) }
+  def convert_to_methods; end
+
+  # source://rbi//lib/rbi/model.rb#407
+  sig { override.returns(T::Array[::String]) }
+  def fully_qualified_names; end
+
+  # source://rbi//lib/rbi/model.rb#413
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#419
+class RBI::AttrReader < ::RBI::Attr
+  # source://rbi//lib/rbi/model.rb#433
+  sig do
+    params(
+      name: ::Symbol,
+      names: ::Symbol,
+      visibility: ::RBI::Visibility,
+      sigs: T::Array[::RBI::Sig],
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::AttrReader).void)
+    ).void
+  end
+  def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#442
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#154
+  sig { override.returns(T::Array[::RBI::Method]) }
+  def convert_to_methods; end
+
+  # source://rbi//lib/rbi/model.rb#439
+  sig { override.returns(T::Array[::String]) }
+  def fully_qualified_names; end
+
+  # source://rbi//lib/rbi/model.rb#445
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#451
+class RBI::AttrWriter < ::RBI::Attr
+  # source://rbi//lib/rbi/model.rb#465
+  sig do
+    params(
+      name: ::Symbol,
+      names: ::Symbol,
+      visibility: ::RBI::Visibility,
+      sigs: T::Array[::RBI::Sig],
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::AttrWriter).void)
+    ).void
+  end
+  def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#451
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#163
+  sig { override.returns(T::Array[::RBI::Method]) }
+  def convert_to_methods; end
+
+  # source://rbi//lib/rbi/model.rb#471
+  sig { override.returns(T::Array[::String]) }
+  def fully_qualified_names; end
+
+  # source://rbi//lib/rbi/model.rb#477
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# An arbitrary blank line that can be added both in trees and comments
+#
+# source://rbi//lib/rbi/model.rb#76
+class RBI::BlankLine < ::RBI::Comment
+  # source://rbi//lib/rbi/model.rb#80
+  sig { params(loc: T.nilable(::RBI::Loc)).void }
+  def initialize(loc: T.unsafe(nil)); end
+end
+
+# source://rbi//lib/rbi/model.rb#816
+class RBI::BlockParam < ::RBI::Param
+  # source://rbi//lib/rbi/model.rb#827
+  sig do
+    params(
+      name: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::BlockParam).void)
+    ).void
+  end
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#838
+  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/model.rb#833
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#220
+class RBI::Class < ::RBI::Scope
+  # source://rbi//lib/rbi/model.rb#238
+  sig do
+    params(
+      name: ::String,
+      superclass_name: T.nilable(::String),
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Class).void)
+    ).void
+  end
+  def initialize(name, superclass_name: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#384
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/model.rb#246
+  sig { override.returns(::String) }
+  def fully_qualified_name; end
+
+  # source://rbi//lib/rbi/model.rb#224
+  sig { returns(::String) }
+  def name; end
+
+  # @return [String]
+  #
+  # source://rbi//lib/rbi/model.rb#224
+  def name=(_arg0); end
+
+  # source://rbi//lib/rbi/model.rb#227
+  sig { returns(T.nilable(::String)) }
+  def superclass_name; end
+
+  # @return [String, nil]
+  #
+  # source://rbi//lib/rbi/model.rb#227
+  def superclass_name=(_arg0); end
+end
+
+# source://rbi//lib/rbi/model.rb#55
+class RBI::Comment < ::RBI::Node
+  # source://rbi//lib/rbi/model.rb#62
+  sig { params(text: ::String, loc: T.nilable(::RBI::Loc)).void }
+  def initialize(text, loc: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/model.rb#68
+  sig { params(other: ::Object).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/model.rb#59
+  sig { returns(::String) }
+  def text; end
+
+  # @return [String]
+  #
+  # source://rbi//lib/rbi/model.rb#59
+  def text=(_arg0); end
+end
+
+# A tree showing incompatibles nodes
+#
+# Is rendered as a merge conflict between `left` and` right`:
+# ~~~rb
+# class Foo
+#   <<<<<<< left
+#   def m1; end
+#   def m2(a); end
+#   =======
+#   def m1(a); end
+#   def m2; end
+#   >>>>>>> right
+# end
+# ~~~
+#
+# source://rbi//lib/rbi/rewriters/merge_trees.rb#583
+class RBI::ConflictTree < ::RBI::Tree
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#593
+  sig { params(left_name: ::String, right_name: ::String).void }
+  def initialize(left_name: T.unsafe(nil), right_name: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#587
+  sig { returns(::RBI::Tree) }
+  def left; end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#590
+  sig { returns(::String) }
+  def left_name; end
+
+  # @return [Tree]
+  #
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#587
+  def right; end
+
+  # @return [String]
+  #
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#590
+  def right_name; end
+end
+
+# Consts
+#
+# source://rbi//lib/rbi/model.rb#314
+class RBI::Const < ::RBI::NodeWithComments
+  include ::RBI::Indexable
+
+  # source://rbi//lib/rbi/model.rb#329
+  sig do
+    params(
+      name: ::String,
+      value: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Const).void)
+    ).void
+  end
+  def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#411
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/model.rb#337
+  sig { returns(::String) }
+  def fully_qualified_name; end
+
+  # source://rbi//lib/rbi/index.rb#103
+  sig { override.returns(T::Array[::String]) }
+  def index_ids; end
+
+  # source://rbi//lib/rbi/model.rb#318
+  sig { returns(::String) }
+  def name; end
+
+  # source://rbi//lib/rbi/model.rb#344
+  sig { override.returns(::String) }
+  def to_s; end
+
+  # @return [String]
+  #
+  # source://rbi//lib/rbi/model.rb#318
+  def value; end
+end
+
+# source://rbi//lib/rbi/rewriters/merge_trees.rb#351
+class RBI::DuplicateNodeError < ::RBI::Error; end
+
+# source://rbi//lib/rbi.rb#8
+class RBI::Error < ::StandardError; end
+
+# source://rbi//lib/rbi/model.rb#891
+class RBI::Extend < ::RBI::Mixin
+  include ::RBI::Indexable
+
+  # source://rbi//lib/rbi/model.rb#903
+  sig do
+    params(
+      name: ::String,
+      names: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Extend).void)
+    ).void
+  end
+  def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#510
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/index.rb#143
+  sig { override.returns(T::Array[::String]) }
+  def index_ids; end
+
+  # source://rbi//lib/rbi/model.rb#909
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#139
+class RBI::File
+  # source://rbi//lib/rbi/model.rb#158
+  sig do
+    params(
+      strictness: T.nilable(::String),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(file: ::RBI::File).void)
+    ).void
+  end
+  def initialize(strictness: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#166
+  sig { params(node: ::RBI::Node).void }
+  def <<(node); end
+
+  # source://rbi//lib/rbi/model.rb#149
+  sig { returns(T::Array[::RBI::Comment]) }
+  def comments; end
+
+  # @return [Array<Comment>]
+  #
+  # source://rbi//lib/rbi/model.rb#149
+  def comments=(_arg0); end
+
+  # source://rbi//lib/rbi/model.rb#171
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  # source://rbi//lib/rbi/printer.rb#743
+  sig do
+    params(
+      out: T.any(::IO, ::StringIO),
+      indent: ::Integer,
+      print_locs: T::Boolean,
+      max_line_length: T.nilable(::Integer)
+    ).void
+  end
+  def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#996
+  sig { params(out: T.any(::IO, ::StringIO), indent: ::Integer, print_locs: T::Boolean).void }
+  def rbs_print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#1002
+  sig { params(indent: ::Integer, print_locs: T::Boolean).returns(::String) }
+  def rbs_string(indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/model.rb#143
+  sig { returns(::RBI::Tree) }
+  def root; end
+
+  # @return [Tree]
+  #
+  # source://rbi//lib/rbi/model.rb#143
+  def root=(_arg0); end
+
+  # source://rbi//lib/rbi/model.rb#146
+  sig { returns(T.nilable(::String)) }
+  def strictness; end
+
+  # @return [String, nil]
+  #
+  # source://rbi//lib/rbi/model.rb#146
+  def strictness=(_arg0); end
+
+  # source://rbi//lib/rbi/printer.rb#749
+  sig { params(indent: ::Integer, print_locs: T::Boolean, max_line_length: T.nilable(::Integer)).returns(::String) }
+  def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
+end
+
+# source://rbi//lib/rbi/formatter.rb#5
+class RBI::Formatter
+  # source://rbi//lib/rbi/formatter.rb#24
+  sig do
+    params(
+      add_sig_templates: T::Boolean,
+      group_nodes: T::Boolean,
+      max_line_length: T.nilable(::Integer),
+      nest_singleton_methods: T::Boolean,
+      nest_non_public_members: T::Boolean,
+      sort_nodes: T::Boolean
+    ).void
+  end
+  def initialize(add_sig_templates: T.unsafe(nil), group_nodes: T.unsafe(nil), max_line_length: T.unsafe(nil), nest_singleton_methods: T.unsafe(nil), nest_non_public_members: T.unsafe(nil), sort_nodes: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/formatter.rb#47
+  sig { params(file: ::RBI::File).void }
+  def format_file(file); end
+
+  # source://rbi//lib/rbi/formatter.rb#52
+  sig { params(tree: ::RBI::Tree).void }
+  def format_tree(tree); end
+
+  # source://rbi//lib/rbi/formatter.rb#12
+  sig { returns(T.nilable(::Integer)) }
+  def max_line_length; end
+
+  # @return [Integer, nil]
+  #
+  # source://rbi//lib/rbi/formatter.rb#12
+  def max_line_length=(_arg0); end
+
+  # source://rbi//lib/rbi/formatter.rb#41
+  sig { params(file: ::RBI::File).returns(::String) }
+  def print_file(file); end
+
+  # source://rbi//lib/rbi/formatter.rb#9
+  sig { params(sort_nodes: T::Boolean).returns(T::Boolean) }
+  def sort_nodes=(sort_nodes); end
+end
+
+# source://rbi//lib/rbi/rewriters/group_nodes.rb#87
+class RBI::Group < ::RBI::Tree
+  # source://rbi//lib/rbi/rewriters/group_nodes.rb#94
+  sig { params(kind: ::RBI::Group::Kind).void }
+  def initialize(kind); end
+
+  # source://rbi//lib/rbi/rewriters/group_nodes.rb#91
+  sig { returns(::RBI::Group::Kind) }
+  def kind; end
+end
+
+# source://rbi//lib/rbi/rewriters/group_nodes.rb#99
+class RBI::Group::Kind < ::T::Enum
+  enums do
+    Attrs = new
+    Consts = new
+    Helpers = new
+    Inits = new
+    Methods = new
+    MixesInClassMethods = new
+    Mixins = new
+    RequiredAncestors = new
+    Sends = new
+    SingletonClasses = new
+    TEnums = new
+    TStructFields = new
+    TypeMembers = new
+  end
+end
+
+# source://rbi//lib/rbi/rewriters/group_nodes.rb#5
+class RBI::GroupNodesError < ::RBI::Error; end
+
+# Sorbet's misc.
+#
+# source://rbi//lib/rbi/model.rb#1374
+class RBI::Helper < ::RBI::NodeWithComments
+  include ::RBI::Indexable
+
+  # source://rbi//lib/rbi/model.rb#1388
+  sig do
+    params(
+      name: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Helper).void)
+    ).void
+  end
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#528
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/index.rb#173
+  sig { override.returns(T::Array[::String]) }
+  def index_ids; end
+
+  # source://rbi//lib/rbi/model.rb#1378
+  sig { returns(::String) }
+  def name; end
+
+  # source://rbi//lib/rbi/model.rb#1395
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#868
+class RBI::Include < ::RBI::Mixin
+  include ::RBI::Indexable
+
+  # source://rbi//lib/rbi/model.rb#880
+  sig do
+    params(
+      name: ::String,
+      names: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Include).void)
+    ).void
+  end
+  def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#501
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/index.rb#133
+  sig { override.returns(T::Array[::String]) }
+  def index_ids; end
+
+  # source://rbi//lib/rbi/model.rb#886
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# source://rbi//lib/rbi/index.rb#5
+class RBI::Index < ::RBI::Visitor
+  # source://rbi//lib/rbi/index.rb#21
+  sig { void }
+  def initialize; end
+
+  # source://rbi//lib/rbi/index.rb#32
+  sig { params(id: ::String).returns(T::Array[::RBI::Node]) }
+  def [](id); end
+
+  # source://rbi//lib/rbi/index.rb#37
+  sig { params(nodes: ::RBI::Node).void }
+  def index(*nodes); end
+
+  # source://rbi//lib/rbi/index.rb#27
+  sig { returns(T::Array[::String]) }
+  def keys; end
+
+  # source://rbi//lib/rbi/index.rb#42
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+
+  private
+
+  # source://rbi//lib/rbi/index.rb#59
+  sig { params(node: T.all(::RBI::Indexable, ::RBI::Node)).void }
+  def index_node(node); end
+
+  class << self
+    # source://rbi//lib/rbi/index.rb#13
+    sig { params(node: ::RBI::Node).returns(::RBI::Index) }
+    def index(*node); end
+  end
+end
+
+# A Node that can be referred to by a unique ID inside an index
+#
+# @abstract Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/index.rb#74
+module RBI::Indexable
+  interface!
+
+  # Unique IDs that refer to this node.
+  #
+  # Some nodes can have multiple ids, for example an attribute accessor matches the ID of the
+  # getter and the setter.
+  #
+  # @abstract
+  #
+  # source://rbi//lib/rbi/index.rb#85
+  sig { abstract.returns(T::Array[::String]) }
+  def index_ids; end
+end
+
+# source://rbi//lib/rbi/model.rb#1073
+class RBI::KwArg < ::RBI::Arg
+  # source://rbi//lib/rbi/model.rb#1086
+  sig { params(keyword: ::String, value: ::String, loc: T.nilable(::RBI::Loc)).void }
+  def initialize(keyword, value, loc: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/model.rb#1092
+  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/model.rb#1077
+  sig { returns(::String) }
+  def keyword; end
+
+  # source://rbi//lib/rbi/model.rb#1097
+  sig { returns(::String) }
+  def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#757
+class RBI::KwOptParam < ::RBI::Param
+  # source://rbi//lib/rbi/model.rb#772
+  sig do
+    params(
+      name: ::String,
+      value: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::KwOptParam).void)
+    ).void
+  end
+  def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#784
+  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/model.rb#779
+  sig { override.returns(::String) }
+  def to_s; end
+
+  # source://rbi//lib/rbi/model.rb#761
+  sig { returns(::String) }
+  def value; end
+end
+
+# source://rbi//lib/rbi/model.rb#730
+class RBI::KwParam < ::RBI::Param
+  # source://rbi//lib/rbi/model.rb#741
+  sig do
+    params(
+      name: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::KwParam).void)
+    ).void
+  end
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#752
+  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/model.rb#747
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#789
+class RBI::KwRestParam < ::RBI::Param
+  # source://rbi//lib/rbi/model.rb#800
+  sig do
+    params(
+      name: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::KwRestParam).void)
+    ).void
+  end
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#811
+  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/model.rb#806
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# source://rbi//lib/rbi/loc.rb#5
+class RBI::Loc
+  # source://rbi//lib/rbi/loc.rb#38
+  sig do
+    params(
+      file: T.nilable(::String),
+      begin_line: T.nilable(::Integer),
+      end_line: T.nilable(::Integer),
+      begin_column: T.nilable(::Integer),
+      end_column: T.nilable(::Integer)
+    ).void
+  end
+  def initialize(file: T.unsafe(nil), begin_line: T.unsafe(nil), end_line: T.unsafe(nil), begin_column: T.unsafe(nil), end_column: T.unsafe(nil)); end
+
+  # @return [Integer, nil]
+  #
+  # source://rbi//lib/rbi/loc.rb#27
+  def begin_column; end
+
+  # source://rbi//lib/rbi/loc.rb#27
+  sig { returns(T.nilable(::Integer)) }
+  def begin_line; end
+
+  # @return [Integer, nil]
+  #
+  # source://rbi//lib/rbi/loc.rb#27
+  def end_column; end
+
+  # @return [Integer, nil]
+  #
+  # source://rbi//lib/rbi/loc.rb#27
+  def end_line; end
+
+  # source://rbi//lib/rbi/loc.rb#24
+  sig { returns(T.nilable(::String)) }
+  def file; end
+
+  # source://rbi//lib/rbi/loc.rb#56
+  sig { returns(T.nilable(::String)) }
+  def source; end
+
+  # source://rbi//lib/rbi/loc.rb#47
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    # source://rbi//lib/rbi/loc.rb#12
+    sig { params(file: ::String, prism_location: ::Prism::Location).returns(::RBI::Loc) }
+    def from_prism(file, prism_location); end
+  end
+end
+
+# A tree that _might_ contain conflicts
+#
+# source://rbi//lib/rbi/rewriters/merge_trees.rb#330
+class RBI::MergeTree < ::RBI::Tree
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#344
+  sig do
+    params(
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      conflicts: T::Array[::RBI::Rewriters::Merge::Conflict],
+      block: T.nilable(T.proc.params(node: ::RBI::Tree).void)
+    ).void
+  end
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), conflicts: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#334
+  sig { returns(T::Array[::RBI::Rewriters::Merge::Conflict]) }
+  def conflicts; end
+end
+
+# Methods and args
+#
+# source://rbi//lib/rbi/model.rb#485
+class RBI::Method < ::RBI::NodeWithComments
+  include ::RBI::Indexable
+
+  # source://rbi//lib/rbi/model.rb#515
+  sig do
+    params(
+      name: ::String,
+      params: T::Array[::RBI::Param],
+      is_singleton: T::Boolean,
+      visibility: ::RBI::Visibility,
+      sigs: T::Array[::RBI::Sig],
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Method).void)
+    ).void
+  end
+  def initialize(name, params: T.unsafe(nil), is_singleton: T.unsafe(nil), visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#535
+  sig { params(param: ::RBI::Param).void }
+  def <<(param); end
+
+  # source://rbi//lib/rbi/model.rb#570
+  sig { params(name: ::String).void }
+  def add_block_param(name); end
+
+  # source://rbi//lib/rbi/model.rb#560
+  sig { params(name: ::String, default_value: ::String).void }
+  def add_kw_opt_param(name, default_value); end
+
+  # source://rbi//lib/rbi/model.rb#555
+  sig { params(name: ::String).void }
+  def add_kw_param(name); end
+
+  # source://rbi//lib/rbi/model.rb#565
+  sig { params(name: ::String).void }
+  def add_kw_rest_param(name); end
+
+  # source://rbi//lib/rbi/model.rb#545
+  sig { params(name: ::String, default_value: ::String).void }
+  def add_opt_param(name, default_value); end
+
+  # source://rbi//lib/rbi/model.rb#540
+  sig { params(name: ::String).void }
+  def add_param(name); end
+
+  # source://rbi//lib/rbi/model.rb#550
+  sig { params(name: ::String).void }
+  def add_rest_param(name); end
+
+  # source://rbi//lib/rbi/model.rb#587
+  sig do
+    params(
+      params: T::Array[::RBI::SigParam],
+      return_type: T.any(::RBI::Type, ::String),
+      is_abstract: T::Boolean,
+      is_override: T::Boolean,
+      is_overridable: T::Boolean,
+      is_final: T::Boolean,
+      type_params: T::Array[::String],
+      checked: T.nilable(::Symbol),
+      block: T.proc.params(node: ::RBI::Sig).void
+    ).void
+  end
+  def add_sig(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#469
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/model.rb#613
+  sig { returns(::String) }
+  def fully_qualified_name; end
+
+  # source://rbi//lib/rbi/index.rb#123
+  sig { override.returns(T::Array[::String]) }
+  def index_ids; end
+
+  # source://rbi//lib/rbi/model.rb#495
+  sig { returns(T::Boolean) }
+  def is_singleton; end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/model.rb#495
+  def is_singleton=(_arg0); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#478
+  sig { override.params(other: ::RBI::Node).void }
+  def merge_with(other); end
+
+  # source://rbi//lib/rbi/model.rb#489
+  sig { returns(::String) }
+  def name; end
+
+  # @return [String]
+  #
+  # source://rbi//lib/rbi/model.rb#489
+  def name=(_arg0); end
+
+  # source://rbi//lib/rbi/model.rb#492
+  sig { returns(T::Array[::RBI::Param]) }
+  def params; end
+
+  # source://rbi//lib/rbi/model.rb#501
+  sig { returns(T::Array[::RBI::Sig]) }
+  def sigs; end
+
+  # @return [Array<Sig>]
+  #
+  # source://rbi//lib/rbi/model.rb#501
+  def sigs=(_arg0); end
+
+  # source://rbi//lib/rbi/model.rb#622
+  sig { override.returns(::String) }
+  def to_s; end
+
+  # source://rbi//lib/rbi/model.rb#498
+  sig { returns(::RBI::Visibility) }
+  def visibility; end
+
+  # @return [Visibility]
+  #
+  # source://rbi//lib/rbi/model.rb#498
+  def visibility=(_arg0); end
+end
+
+# source://rbi//lib/rbi/model.rb#1435
+class RBI::MixesInClassMethods < ::RBI::Mixin
+  include ::RBI::Indexable
+
+  # source://rbi//lib/rbi/model.rb#1447
+  sig do
+    params(
+      name: ::String,
+      names: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::MixesInClassMethods).void)
+    ).void
+  end
+  def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#519
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/index.rb#153
+  sig { override.returns(T::Array[::String]) }
+  def index_ids; end
+
+  # source://rbi//lib/rbi/model.rb#1453
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# Mixins
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/model.rb#845
+class RBI::Mixin < ::RBI::NodeWithComments
+  abstract!
+
+  # source://rbi//lib/rbi/model.rb#862
+  sig do
+    params(
+      name: ::String,
+      names: T::Array[::String],
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment]
+    ).void
+  end
+  def initialize(name, names, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#492
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/model.rb#852
+  sig { returns(T::Array[::String]) }
+  def names; end
+end
+
+# source://rbi//lib/rbi/model.rb#192
+class RBI::Module < ::RBI::Scope
+  # source://rbi//lib/rbi/model.rb#206
+  sig do
+    params(
+      name: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Module).void)
+    ).void
+  end
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#393
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/model.rb#213
+  sig { override.returns(::String) }
+  def fully_qualified_name; end
+
+  # source://rbi//lib/rbi/model.rb#196
+  sig { returns(::String) }
+  def name; end
+
+  # @return [String]
+  #
+  # source://rbi//lib/rbi/model.rb#196
+  def name=(_arg0); end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/model.rb#7
+class RBI::Node
+  abstract!
+
+  # source://rbi//lib/rbi/model.rb#20
+  sig { params(loc: T.nilable(::RBI::Loc)).void }
+  def initialize(loc: T.unsafe(nil)); end
+
+  # Can `self` and `_other` be merged into a single definition?
+  #
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#287
+  sig { params(_other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(_other); end
+
+  # source://rbi//lib/rbi/model.rb#26
+  sig { void }
+  def detach; end
+
+  # source://rbi//lib/rbi/model.rb#17
+  sig { returns(T.nilable(::RBI::Loc)) }
+  def loc; end
+
+  # @return [Loc, nil]
+  #
+  # source://rbi//lib/rbi/model.rb#17
+  def loc=(_arg0); end
+
+  # Merge `self` and `other` into a single definition
+  #
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#293
+  sig { params(other: ::RBI::Node).void }
+  def merge_with(other); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#296
+  sig { returns(T.nilable(::RBI::ConflictTree)) }
+  def parent_conflict_tree; end
+
+  # source://rbi//lib/rbi/model.rb#48
+  sig { returns(T.nilable(::RBI::Scope)) }
+  def parent_scope; end
+
+  # source://rbi//lib/rbi/model.rb#14
+  sig { returns(T.nilable(::RBI::Tree)) }
+  def parent_tree; end
+
+  # @return [Tree, nil]
+  #
+  # source://rbi//lib/rbi/model.rb#14
+  def parent_tree=(_arg0); end
+
+  # source://rbi//lib/rbi/printer.rb#767
+  sig do
+    params(
+      out: T.any(::IO, ::StringIO),
+      indent: ::Integer,
+      print_locs: T::Boolean,
+      max_line_length: T.nilable(::Integer)
+    ).void
+  end
+  def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#1013
+  sig { params(out: T.any(::IO, ::StringIO), indent: ::Integer, print_locs: T::Boolean).void }
+  def rbs_print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#1019
+  sig { params(indent: ::Integer, print_locs: T::Boolean).returns(::String) }
+  def rbs_string(indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
+
+  # @raise [ReplaceNodeError]
+  #
+  # source://rbi//lib/rbi/model.rb#35
+  sig { params(node: ::RBI::Node).void }
+  def replace(node); end
+
+  # source://rbi//lib/rbi/rewriters/filter_versions.rb#94
+  sig { params(version: ::Gem::Version).returns(T::Boolean) }
+  def satisfies_version?(version); end
+
+  # source://rbi//lib/rbi/printer.rb#773
+  sig { params(indent: ::Integer, print_locs: T::Boolean, max_line_length: T.nilable(::Integer)).returns(::String) }
+  def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/model.rb#85
+class RBI::NodeWithComments < ::RBI::Node
+  abstract!
+
+  # source://rbi//lib/rbi/model.rb#95
+  sig { params(loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/model.rb#101
+  sig { returns(T::Array[::String]) }
+  def annotations; end
+
+  # source://rbi//lib/rbi/model.rb#92
+  sig { returns(T::Array[::RBI::Comment]) }
+  def comments; end
+
+  # @return [Array<Comment>]
+  #
+  # source://rbi//lib/rbi/model.rb#92
+  def comments=(_arg0); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#311
+  sig { override.params(other: ::RBI::Node).void }
+  def merge_with(other); end
+
+  # source://rbi//lib/rbi/rewriters/filter_versions.rb#104
+  sig { returns(T::Array[::Gem::Requirement]) }
+  def version_requirements; end
+end
+
+# source://rbi//lib/rbi/model.rb#676
+class RBI::OptParam < ::RBI::Param
+  # source://rbi//lib/rbi/model.rb#691
+  sig do
+    params(
+      name: ::String,
+      value: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::OptParam).void)
+    ).void
+  end
+  def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#698
+  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/model.rb#680
+  sig { returns(::String) }
+  def value; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/model.rb#627
+class RBI::Param < ::RBI::NodeWithComments
+  abstract!
+
+  # source://rbi//lib/rbi/model.rb#643
+  sig { params(name: ::String, loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/model.rb#634
+  sig { returns(::String) }
+  def name; end
+
+  # source://rbi//lib/rbi/model.rb#649
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# source://rbi//lib/rbi/parser.rb#7
+class RBI::ParseError < ::RBI::Error
+  # source://rbi//lib/rbi/parser.rb#14
+  sig { params(message: ::String, location: ::RBI::Loc).void }
+  def initialize(message, location); end
+
+  # source://rbi//lib/rbi/parser.rb#11
+  sig { returns(::RBI::Loc) }
+  def location; end
+end
+
+# source://rbi//lib/rbi/parser.rb#53
+class RBI::Parser
+  # source://rbi//lib/rbi/parser.rb#88
+  sig { params(path: ::String).returns(::RBI::Tree) }
+  def parse_file(path); end
+
+  # source://rbi//lib/rbi/parser.rb#83
+  sig { params(string: ::String).returns(::RBI::Tree) }
+  def parse_string(string); end
+
+  private
+
+  # source://rbi//lib/rbi/parser.rb#95
+  sig { params(source: ::String, file: ::String).returns(::RBI::Tree) }
+  def parse(source, file:); end
+
+  class << self
+    # source://rbi//lib/rbi/parser.rb#65
+    sig { params(path: ::String).returns(::RBI::Tree) }
+    def parse_file(path); end
+
+    # source://rbi//lib/rbi/parser.rb#70
+    sig { params(paths: T::Array[::String]).returns(T::Array[::RBI::Tree]) }
+    def parse_files(paths); end
+
+    # source://rbi//lib/rbi/parser.rb#60
+    sig { params(string: ::String).returns(::RBI::Tree) }
+    def parse_string(string); end
+
+    # source://rbi//lib/rbi/parser.rb#76
+    sig { params(strings: T::Array[::String]).returns(T::Array[::RBI::Tree]) }
+    def parse_strings(strings); end
+  end
+end
+
+# source://rbi//lib/rbi/parser.rb#828
+class RBI::Parser::SigBuilder < ::RBI::Parser::Visitor
+  # source://rbi//lib/rbi/parser.rb#835
+  sig { params(content: ::String, file: ::String).void }
+  def initialize(content, file:); end
+
+  # source://rbi//lib/rbi/parser.rb#832
+  sig { returns(::RBI::Sig) }
+  def current; end
+
+  # source://rbi//lib/rbi/parser.rb#887
+  sig { override.params(node: ::Prism::AssocNode).void }
+  def visit_assoc_node(node); end
+
+  # source://rbi//lib/rbi/parser.rb#842
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+end
+
+# source://rbi//lib/rbi/parser.rb#153
+class RBI::Parser::TreeBuilder < ::RBI::Parser::Visitor
+  # source://rbi//lib/rbi/parser.rb#163
+  sig { params(source: ::String, comments: T::Array[::Prism::Comment], file: ::String).void }
+  def initialize(source, comments:, file:); end
+
+  # source://rbi//lib/rbi/parser.rb#160
+  sig { returns(T.nilable(::Prism::Node)) }
+  def last_node; end
+
+  # source://rbi//lib/rbi/parser.rb#157
+  sig { returns(::RBI::Tree) }
+  def tree; end
+
+  # source://rbi//lib/rbi/parser.rb#324
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  # source://rbi//lib/rbi/parser.rb#175
+  sig { override.params(node: ::Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  # source://rbi//lib/rbi/parser.rb#224
+  sig { params(node: T.any(::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode)).void }
+  def visit_constant_assign(node); end
+
+  # source://rbi//lib/rbi/parser.rb#217
+  sig { override.params(node: ::Prism::ConstantPathWriteNode).void }
+  def visit_constant_path_write_node(node); end
+
+  # source://rbi//lib/rbi/parser.rb#210
+  sig { override.params(node: ::Prism::ConstantWriteNode).void }
+  def visit_constant_write_node(node); end
+
+  # source://rbi//lib/rbi/parser.rb#257
+  sig { override.params(node: ::Prism::DefNode).void }
+  def visit_def_node(node); end
+
+  # source://rbi//lib/rbi/parser.rb#278
+  sig { override.params(node: ::Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  # source://rbi//lib/rbi/parser.rb#296
+  sig { override.params(node: ::Prism::ProgramNode).void }
+  def visit_program_node(node); end
+
+  # source://rbi//lib/rbi/parser.rb#307
+  sig { override.params(node: ::Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  private
+
+  # Collect all the remaining comments within a node
+  #
+  # source://rbi//lib/rbi/parser.rb#503
+  sig { params(node: ::Prism::Node).void }
+  def collect_dangling_comments(node); end
+
+  # Collect all the remaining comments after visiting the tree
+  #
+  # source://rbi//lib/rbi/parser.rb#521
+  sig { void }
+  def collect_orphan_comments; end
+
+  # source://rbi//lib/rbi/parser.rb#544
+  sig { returns(::RBI::Tree) }
+  def current_scope; end
+
+  # source://rbi//lib/rbi/parser.rb#549
+  sig { returns(T::Array[::RBI::Sig]) }
+  def current_sigs; end
+
+  # source://rbi//lib/rbi/parser.rb#556
+  sig { params(sigs: T::Array[::RBI::Sig]).returns(T::Array[::RBI::Comment]) }
+  def detach_comments_from_sigs(sigs); end
+
+  # source://rbi//lib/rbi/parser.rb#568
+  sig { params(node: ::Prism::Node).returns(T::Array[::RBI::Comment]) }
+  def node_comments(node); end
+
+  # source://rbi//lib/rbi/parser.rb#586
+  sig { params(node: ::Prism::Comment).returns(::RBI::Comment) }
+  def parse_comment(node); end
+
+  # source://rbi//lib/rbi/parser.rb#615
+  sig { params(node: T.nilable(::Prism::Node)).returns(T::Array[::RBI::Param]) }
+  def parse_params(node); end
+
+  # source://rbi//lib/rbi/parser.rb#591
+  sig { params(node: T.nilable(::Prism::Node)).returns(T::Array[::RBI::Arg]) }
+  def parse_send_args(node); end
+
+  # source://rbi//lib/rbi/parser.rb#689
+  sig { params(node: ::Prism::CallNode).returns(::RBI::Sig) }
+  def parse_sig(node); end
+
+  # source://rbi//lib/rbi/parser.rb#698
+  sig do
+    params(
+      node: T.any(::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode)
+    ).returns(T.nilable(::RBI::Struct))
+  end
+  def parse_struct(node); end
+
+  # source://rbi//lib/rbi/parser.rb#748
+  sig { params(send: ::Prism::CallNode).void }
+  def parse_tstruct_field(send); end
+
+  # source://rbi//lib/rbi/parser.rb#785
+  sig { params(name: ::String, node: ::Prism::Node).returns(::RBI::Visibility) }
+  def parse_visibility(name, node); end
+
+  # source://rbi//lib/rbi/parser.rb#799
+  sig { void }
+  def separate_header_comments; end
+
+  # source://rbi//lib/rbi/parser.rb#809
+  sig { void }
+  def set_root_tree_loc; end
+
+  # source://rbi//lib/rbi/parser.rb#823
+  sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+  def type_variable_definition?(node); end
+end
+
+# source://rbi//lib/rbi/parser.rb#122
+class RBI::Parser::Visitor < ::Prism::Visitor
+  # source://rbi//lib/rbi/parser.rb#126
+  sig { params(source: ::String, file: ::String).void }
+  def initialize(source, file:); end
+
+  private
+
+  # source://rbi//lib/rbi/parser.rb#136
+  sig { params(node: ::Prism::Node).returns(::RBI::Loc) }
+  def node_loc(node); end
+
+  # source://rbi//lib/rbi/parser.rb#141
+  sig { params(node: T.nilable(::Prism::Node)).returns(T.nilable(::String)) }
+  def node_string(node); end
+
+  # source://rbi//lib/rbi/parser.rb#148
+  sig { params(node: ::Prism::Node).returns(::String) }
+  def node_string!(node); end
+end
+
+# source://rbi//lib/rbi/printer.rb#7
+class RBI::Printer < ::RBI::Visitor
+  # source://rbi//lib/rbi/printer.rb#30
+  sig do
+    params(
+      out: T.any(::IO, ::StringIO),
+      indent: ::Integer,
+      print_locs: T::Boolean,
+      max_line_length: T.nilable(::Integer)
+    ).void
+  end
+  def initialize(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/printer.rb#17
+  sig { returns(::Integer) }
+  def current_indent; end
+
+  # source://rbi//lib/rbi/printer.rb#48
+  sig { void }
+  def dedent; end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/printer.rb#11
+  def in_visibility_group; end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/printer.rb#11
+  def in_visibility_group=(_arg0); end
+
+  # Printing
+  #
+  # source://rbi//lib/rbi/printer.rb#43
+  sig { void }
+  def indent; end
+
+  # source://rbi//lib/rbi/printer.rb#20
+  sig { returns(T.nilable(::Integer)) }
+  def max_line_length; end
+
+  # source://rbi//lib/rbi/printer.rb#14
+  sig { returns(T.nilable(::RBI::Node)) }
+  def previous_node; end
+
+  # Print a string without indentation nor `\n` at the end.
+  #
+  # source://rbi//lib/rbi/printer.rb#54
+  sig { params(string: ::String).void }
+  def print(string); end
+
+  # source://rbi//lib/rbi/printer.rb#11
+  sig { returns(T::Boolean) }
+  def print_locs; end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/printer.rb#11
+  def print_locs=(_arg0); end
+
+  # Print a string with indentation and `\n` at the end.
+  #
+  # source://rbi//lib/rbi/printer.rb#74
+  sig { params(string: ::String).void }
+  def printl(string); end
+
+  # Print a string without indentation but with a `\n` at the end.
+  #
+  # source://rbi//lib/rbi/printer.rb#60
+  sig { params(string: T.nilable(::String)).void }
+  def printn(string = T.unsafe(nil)); end
+
+  # Print a string with indentation but without a `\n` at the end.
+  #
+  # source://rbi//lib/rbi/printer.rb#67
+  sig { params(string: T.nilable(::String)).void }
+  def printt(string = T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/printer.rb#80
+  sig { override.params(nodes: T::Array[::RBI::Node]).void }
+  def visit_all(nodes); end
+
+  # source://rbi//lib/rbi/printer.rb#91
+  sig { override.params(file: ::RBI::File).void }
+  def visit_file(file); end
+
+  private
+
+  # source://rbi//lib/rbi/printer.rb#618
+  sig { params(node: ::RBI::Node).returns(T::Boolean) }
+  def oneline?(node); end
+
+  # source://rbi//lib/rbi/printer.rb#576
+  sig { params(node: ::RBI::Node).void }
+  def print_blank_line_before(node); end
+
+  # source://rbi//lib/rbi/printer.rb#586
+  sig { params(node: ::RBI::Node).void }
+  def print_loc(node); end
+
+  # source://rbi//lib/rbi/printer.rb#592
+  sig { params(node: ::RBI::Param, last: T::Boolean).void }
+  def print_param_comment_leading_space(node, last:); end
+
+  # source://rbi//lib/rbi/printer.rb#665
+  sig { params(node: ::RBI::Sig).void }
+  def print_sig_as_block(node); end
+
+  # source://rbi//lib/rbi/printer.rb#640
+  sig { params(node: ::RBI::Sig).void }
+  def print_sig_as_line(node); end
+
+  # source://rbi//lib/rbi/printer.rb#610
+  sig { params(node: ::RBI::SigParam, last: T::Boolean).void }
+  def print_sig_param_comment_leading_space(node, last:); end
+
+  # source://rbi//lib/rbi/printer.rb#721
+  sig { params(node: ::RBI::Sig).returns(T::Array[::String]) }
+  def sig_modifiers(node); end
+
+  # source://rbi//lib/rbi/printer.rb#417
+  sig { override.params(node: ::RBI::Arg).void }
+  def visit_arg(node); end
+
+  # source://rbi//lib/rbi/printer.rb#237
+  sig { params(node: ::RBI::Attr).void }
+  def visit_attr(node); end
+
+  # source://rbi//lib/rbi/printer.rb#222
+  sig { override.params(node: ::RBI::AttrAccessor).void }
+  def visit_attr_accessor(node); end
+
+  # source://rbi//lib/rbi/printer.rb#227
+  sig { override.params(node: ::RBI::AttrReader).void }
+  def visit_attr_reader(node); end
+
+  # source://rbi//lib/rbi/printer.rb#232
+  sig { override.params(node: ::RBI::AttrWriter).void }
+  def visit_attr_writer(node); end
+
+  # source://rbi//lib/rbi/printer.rb#126
+  sig { override.params(node: ::RBI::BlankLine).void }
+  def visit_blank_line(node); end
+
+  # source://rbi//lib/rbi/printer.rb#344
+  sig { override.params(node: ::RBI::BlockParam).void }
+  def visit_block_param(node); end
+
+  # source://rbi//lib/rbi/printer.rb#143
+  sig { override.params(node: ::RBI::Class).void }
+  def visit_class(node); end
+
+  # source://rbi//lib/rbi/printer.rb#110
+  sig { override.params(node: ::RBI::Comment).void }
+  def visit_comment(node); end
+
+  # source://rbi//lib/rbi/printer.rb#553
+  sig { override.params(node: ::RBI::ConflictTree).void }
+  def visit_conflict_tree(node); end
+
+  # source://rbi//lib/rbi/printer.rb#213
+  sig { override.params(node: ::RBI::Const).void }
+  def visit_const(node); end
+
+  # source://rbi//lib/rbi/printer.rb#354
+  sig { override.params(node: ::RBI::Extend).void }
+  def visit_extend(node); end
+
+  # source://rbi//lib/rbi/printer.rb#525
+  sig { override.params(node: ::RBI::Group).void }
+  def visit_group(node); end
+
+  # source://rbi//lib/rbi/printer.rb#511
+  sig { override.params(node: ::RBI::Helper).void }
+  def visit_helper(node); end
+
+  # source://rbi//lib/rbi/printer.rb#349
+  sig { override.params(node: ::RBI::Include).void }
+  def visit_include(node); end
+
+  # source://rbi//lib/rbi/printer.rb#422
+  sig { override.params(node: ::RBI::KwArg).void }
+  def visit_kw_arg(node); end
+
+  # source://rbi//lib/rbi/printer.rb#334
+  sig { override.params(node: ::RBI::KwOptParam).void }
+  def visit_kw_opt_param(node); end
+
+  # source://rbi//lib/rbi/printer.rb#329
+  sig { override.params(node: ::RBI::KwParam).void }
+  def visit_kw_param(node); end
+
+  # source://rbi//lib/rbi/printer.rb#339
+  sig { override.params(node: ::RBI::KwRestParam).void }
+  def visit_kw_rest_param(node); end
+
+  # source://rbi//lib/rbi/printer.rb#265
+  sig { override.params(node: ::RBI::Method).void }
+  def visit_method(node); end
+
+  # source://rbi//lib/rbi/printer.rb#520
+  sig { override.params(node: ::RBI::MixesInClassMethods).void }
+  def visit_mixes_in_class_methods(node); end
+
+  # source://rbi//lib/rbi/printer.rb#359
+  sig { params(node: ::RBI::Mixin).void }
+  def visit_mixin(node); end
+
+  # source://rbi//lib/rbi/printer.rb#138
+  sig { override.params(node: ::RBI::Module).void }
+  def visit_module(node); end
+
+  # source://rbi//lib/rbi/printer.rb#319
+  sig { override.params(node: ::RBI::OptParam).void }
+  def visit_opt_param(node); end
+
+  # source://rbi//lib/rbi/printer.rb#386
+  sig { override.params(node: ::RBI::Private).void }
+  def visit_private(node); end
+
+  # source://rbi//lib/rbi/printer.rb#381
+  sig { override.params(node: ::RBI::Protected).void }
+  def visit_protected(node); end
+
+  # source://rbi//lib/rbi/printer.rb#376
+  sig { override.params(node: ::RBI::Public).void }
+  def visit_public(node); end
+
+  # source://rbi//lib/rbi/printer.rb#314
+  sig { override.params(node: ::RBI::ReqParam).void }
+  def visit_req_param(node); end
+
+  # source://rbi//lib/rbi/printer.rb#544
+  sig { override.params(node: ::RBI::RequiresAncestor).void }
+  def visit_requires_ancestor(node); end
+
+  # source://rbi//lib/rbi/printer.rb#324
+  sig { override.params(node: ::RBI::RestParam).void }
+  def visit_rest_param(node); end
+
+  # source://rbi//lib/rbi/printer.rb#158
+  sig { params(node: ::RBI::Scope).void }
+  def visit_scope(node); end
+
+  # source://rbi//lib/rbi/printer.rb#203
+  sig { params(node: ::RBI::Scope).void }
+  def visit_scope_body(node); end
+
+  # source://rbi//lib/rbi/printer.rb#562
+  sig { override.params(node: ::RBI::ScopeConflict).void }
+  def visit_scope_conflict(node); end
+
+  # source://rbi//lib/rbi/printer.rb#168
+  sig { params(node: ::RBI::Scope).void }
+  def visit_scope_header(node); end
+
+  # source://rbi//lib/rbi/printer.rb#400
+  sig { override.params(node: ::RBI::Send).void }
+  def visit_send(node); end
+
+  # source://rbi//lib/rbi/printer.rb#427
+  sig { override.params(node: ::RBI::Sig).void }
+  def visit_sig(node); end
+
+  # source://rbi//lib/rbi/printer.rb#447
+  sig { override.params(node: ::RBI::SigParam).void }
+  def visit_sig_param(node); end
+
+  # source://rbi//lib/rbi/printer.rb#153
+  sig { override.params(node: ::RBI::SingletonClass).void }
+  def visit_singleton_class(node); end
+
+  # source://rbi//lib/rbi/printer.rb#148
+  sig { override.params(node: ::RBI::Struct).void }
+  def visit_struct(node); end
+
+  # source://rbi//lib/rbi/printer.rb#467
+  sig { params(node: ::RBI::TStructField).void }
+  def visit_t_struct_field(node); end
+
+  # source://rbi//lib/rbi/printer.rb#485
+  sig { override.params(node: ::RBI::TEnum).void }
+  def visit_tenum(node); end
+
+  # source://rbi//lib/rbi/printer.rb#490
+  sig { override.params(node: ::RBI::TEnumBlock).void }
+  def visit_tenum_block(node); end
+
+  # source://rbi//lib/rbi/printer.rb#131
+  sig { override.params(node: ::RBI::Tree).void }
+  def visit_tree(node); end
+
+  # source://rbi//lib/rbi/printer.rb#452
+  sig { override.params(node: ::RBI::TStruct).void }
+  def visit_tstruct(node); end
+
+  # source://rbi//lib/rbi/printer.rb#457
+  sig { override.params(node: ::RBI::TStructConst).void }
+  def visit_tstruct_const(node); end
+
+  # source://rbi//lib/rbi/printer.rb#462
+  sig { override.params(node: ::RBI::TStructProp).void }
+  def visit_tstruct_prop(node); end
+
+  # source://rbi//lib/rbi/printer.rb#502
+  sig { override.params(node: ::RBI::TypeMember).void }
+  def visit_type_member(node); end
+
+  # source://rbi//lib/rbi/printer.rb#391
+  sig { params(node: ::RBI::Visibility).void }
+  def visit_visibility(node); end
+
+  # source://rbi//lib/rbi/printer.rb#531
+  sig { override.params(node: ::RBI::VisibilityGroup).void }
+  def visit_visibility_group(node); end
+end
+
+# source://rbi//lib/rbi/printer.rb#5
+class RBI::PrinterError < ::RBI::Error; end
+
+# source://rbi//lib/rbi/model.rb#986
+class RBI::Private < ::RBI::Visibility
+  # source://rbi//lib/rbi/model.rb#996
+  sig do
+    params(
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Private).void)
+    ).void
+  end
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+# source://rbi//lib/rbi/model.rb#970
+class RBI::Protected < ::RBI::Visibility
+  # source://rbi//lib/rbi/model.rb#980
+  sig do
+    params(
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Protected).void)
+    ).void
+  end
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+# source://rbi//lib/rbi/model.rb#954
+class RBI::Public < ::RBI::Visibility
+  # source://rbi//lib/rbi/model.rb#964
+  sig do
+    params(
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Public).void)
+    ).void
+  end
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+# source://rbi//lib/rbi/rbs_printer.rb#5
+class RBI::RBSPrinter < ::RBI::Visitor
+  # source://rbi//lib/rbi/rbs_printer.rb#18
+  sig { params(out: T.any(::IO, ::StringIO), indent: ::Integer, print_locs: T::Boolean).void }
+  def initialize(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#15
+  sig { returns(::Integer) }
+  def current_indent; end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#35
+  sig { void }
+  def dedent; end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/rbs_printer.rb#9
+  def in_visibility_group; end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/rbs_printer.rb#9
+  def in_visibility_group=(_arg0); end
+
+  # Printing
+  #
+  # source://rbi//lib/rbi/rbs_printer.rb#30
+  sig { void }
+  def indent; end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#12
+  sig { returns(T.nilable(::RBI::Node)) }
+  def previous_node; end
+
+  # Print a string without indentation nor `\n` at the end.
+  #
+  # source://rbi//lib/rbi/rbs_printer.rb#41
+  sig { params(string: ::String).void }
+  def print(string); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#275
+  sig { params(node: ::RBI::Attr, sig: ::RBI::Sig).void }
+  def print_attr_sig(node, sig); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#9
+  sig { returns(T::Boolean) }
+  def print_locs; end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/rbs_printer.rb#9
+  def print_locs=(_arg0); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#350
+  sig { params(node: ::RBI::Method, sig: ::RBI::Sig).void }
+  def print_method_sig(node, sig); end
+
+  # Print a string with indentation and `\n` at the end.
+  #
+  # source://rbi//lib/rbi/rbs_printer.rb#61
+  sig { params(string: ::String).void }
+  def printl(string); end
+
+  # Print a string without indentation but with a `\n` at the end.
+  #
+  # source://rbi//lib/rbi/rbs_printer.rb#47
+  sig { params(string: T.nilable(::String)).void }
+  def printn(string = T.unsafe(nil)); end
+
+  # Print a string with indentation but without a `\n` at the end.
+  #
+  # source://rbi//lib/rbi/rbs_printer.rb#54
+  sig { params(string: T.nilable(::String)).void }
+  def printt(string = T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#67
+  sig { override.params(nodes: T::Array[::RBI::Node]).void }
+  def visit_all(nodes); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#505
+  sig { override.params(node: ::RBI::Arg).void }
+  def visit_arg(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#243
+  sig { params(node: ::RBI::Attr).void }
+  def visit_attr(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#228
+  sig { override.params(node: ::RBI::AttrAccessor).void }
+  def visit_attr_accessor(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#233
+  sig { override.params(node: ::RBI::AttrReader).void }
+  def visit_attr_reader(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#238
+  sig { override.params(node: ::RBI::AttrWriter).void }
+  def visit_attr_writer(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#106
+  sig { override.params(node: ::RBI::BlankLine).void }
+  def visit_blank_line(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#444
+  sig { override.params(node: ::RBI::BlockParam).void }
+  def visit_block_param(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#123
+  sig { override.params(node: ::RBI::Class).void }
+  def visit_class(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#90
+  sig { override.params(node: ::RBI::Comment).void }
+  def visit_comment(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#625
+  sig { override.params(node: ::RBI::ConflictTree).void }
+  def visit_conflict_tree(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#213
+  sig { override.params(node: ::RBI::Const).void }
+  def visit_const(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#454
+  sig { override.params(node: ::RBI::Extend).void }
+  def visit_extend(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#78
+  sig { override.params(file: ::RBI::File).void }
+  def visit_file(file); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#601
+  sig { override.params(node: ::RBI::Group).void }
+  def visit_group(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#591
+  sig { override.params(node: ::RBI::Helper).void }
+  def visit_helper(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#449
+  sig { override.params(node: ::RBI::Include).void }
+  def visit_include(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#510
+  sig { override.params(node: ::RBI::KwArg).void }
+  def visit_kw_arg(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#434
+  sig { override.params(node: ::RBI::KwOptParam).void }
+  def visit_kw_opt_param(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#429
+  sig { override.params(node: ::RBI::KwParam).void }
+  def visit_kw_param(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#439
+  sig { override.params(node: ::RBI::KwRestParam).void }
+  def visit_kw_rest_param(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#292
+  sig { override.params(node: ::RBI::Method).void }
+  def visit_method(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#596
+  sig { override.params(node: ::RBI::MixesInClassMethods).void }
+  def visit_mixes_in_class_methods(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#459
+  sig { params(node: ::RBI::Mixin).void }
+  def visit_mixin(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#118
+  sig { override.params(node: ::RBI::Module).void }
+  def visit_module(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#419
+  sig { override.params(node: ::RBI::OptParam).void }
+  def visit_opt_param(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#486
+  sig { override.params(node: ::RBI::Private).void }
+  def visit_private(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#481
+  sig { override.params(node: ::RBI::Protected).void }
+  def visit_protected(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#476
+  sig { override.params(node: ::RBI::Public).void }
+  def visit_public(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#414
+  sig { override.params(node: ::RBI::ReqParam).void }
+  def visit_req_param(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#620
+  sig { override.params(node: ::RBI::RequiresAncestor).void }
+  def visit_requires_ancestor(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#424
+  sig { override.params(node: ::RBI::RestParam).void }
+  def visit_rest_param(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#138
+  sig { params(node: ::RBI::Scope).void }
+  def visit_scope(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#201
+  sig { params(node: ::RBI::Scope).void }
+  def visit_scope_body(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#634
+  sig { override.params(node: ::RBI::ScopeConflict).void }
+  def visit_scope_conflict(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#148
+  sig { params(node: ::RBI::Scope).void }
+  def visit_scope_header(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#500
+  sig { override.params(node: ::RBI::Send).void }
+  def visit_send(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#133
+  sig { override.params(node: ::RBI::SingletonClass).void }
+  def visit_singleton_class(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#128
+  sig { override.params(node: ::RBI::Struct).void }
+  def visit_struct(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#563
+  sig { override.params(node: ::RBI::TEnum).void }
+  def visit_tenum(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#568
+  sig { override.params(node: ::RBI::TEnumBlock).void }
+  def visit_tenum_block(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#111
+  sig { override.params(node: ::RBI::Tree).void }
+  def visit_tree(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#515
+  sig { override.params(node: ::RBI::TStruct).void }
+  def visit_tstruct(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#549
+  sig { override.params(node: ::RBI::TStructConst).void }
+  def visit_tstruct_const(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#556
+  sig { override.params(node: ::RBI::TStructProp).void }
+  def visit_tstruct_prop(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#586
+  sig { override.params(node: ::RBI::TypeMember).void }
+  def visit_type_member(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#491
+  sig { params(node: ::RBI::Visibility).void }
+  def visit_visibility(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#607
+  sig { override.params(node: ::RBI::VisibilityGroup).void }
+  def visit_visibility_group(node); end
+
+  private
+
+  # source://rbi//lib/rbi/rbs_printer.rb#782
+  sig { params(node: ::RBI::Type).returns(T::Boolean) }
+  def bare_nilable_proc?(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#777
+  sig { params(node: ::RBI::Type).returns(T::Boolean) }
+  def bare_proc?(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#725
+  sig { params(node: ::RBI::Node).returns(T::Boolean) }
+  def oneline?(node); end
+
+  # Parse a string containing a `T.let(x, X)` and extract the type
+  #
+  # Returns `nil` is the string is not a `T.let`.
+  #
+  # source://rbi//lib/rbi/rbs_printer.rb#759
+  sig { params(code: T.nilable(::String)).returns(T.nilable(::String)) }
+  def parse_t_let(code); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#747
+  sig { params(type: T.any(::RBI::Type, ::String)).returns(::RBI::Type) }
+  def parse_type(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#650
+  sig { params(node: ::RBI::Node).void }
+  def print_blank_line_before(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#669
+  sig { params(node: ::RBI::Node).void }
+  def print_loc(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#699
+  sig { params(node: ::RBI::Param, last: T::Boolean).void }
+  def print_param_comment_leading_space(node, last:); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#675
+  sig { params(node: ::RBI::Method, param: ::RBI::SigParam).void }
+  def print_sig_param(node, param); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#717
+  sig { params(node: ::RBI::SigParam, last: T::Boolean).void }
+  def print_sig_param_comment_leading_space(node, last:); end
+end
+
+# source://rbi//lib/rbi/rbs_printer.rb#6
+class RBI::RBSPrinter::Error < ::RBI::Error; end
+
+# source://rbi//lib/rbi/model.rb#5
+class RBI::ReplaceNodeError < ::RBI::Error; end
+
+# source://rbi//lib/rbi/model.rb#654
+class RBI::ReqParam < ::RBI::Param
+  # source://rbi//lib/rbi/model.rb#665
+  sig do
+    params(
+      name: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::ReqParam).void)
+    ).void
+  end
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#671
+  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+  def ==(other); end
+end
+
+# source://rbi//lib/rbi/model.rb#1458
+class RBI::RequiresAncestor < ::RBI::NodeWithComments
+  include ::RBI::Indexable
+
+  # source://rbi//lib/rbi/model.rb#1471
+  sig { params(name: ::String, loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/index.rb#163
+  sig { override.returns(T::Array[::String]) }
+  def index_ids; end
+
+  # source://rbi//lib/rbi/model.rb#1462
+  sig { returns(::String) }
+  def name; end
+
+  # source://rbi//lib/rbi/model.rb#1477
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#703
+class RBI::RestParam < ::RBI::Param
+  # source://rbi//lib/rbi/model.rb#714
+  sig do
+    params(
+      name: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::RestParam).void)
+    ).void
+  end
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#725
+  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/model.rb#720
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# source://rbi//lib/rbi/rewriters/add_sig_templates.rb#5
+module RBI::Rewriters; end
+
+# source://rbi//lib/rbi/rewriters/add_sig_templates.rb#6
+class RBI::Rewriters::AddSigTemplates < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/add_sig_templates.rb#10
+  sig { params(with_todo_comment: T::Boolean).void }
+  def initialize(with_todo_comment: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rewriters/add_sig_templates.rb#16
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+
+  private
+
+  # source://rbi//lib/rbi/rewriters/add_sig_templates.rb#30
+  sig { params(attr: ::RBI::Attr).void }
+  def add_attr_sig(attr); end
+
+  # source://rbi//lib/rbi/rewriters/add_sig_templates.rb#45
+  sig { params(method: ::RBI::Method).void }
+  def add_method_sig(method); end
+
+  # source://rbi//lib/rbi/rewriters/add_sig_templates.rb#56
+  sig { params(node: ::RBI::NodeWithComments).void }
+  def add_todo_comment(node); end
+end
+
+# source://rbi//lib/rbi/rewriters/annotate.rb#6
+class RBI::Rewriters::Annotate < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/annotate.rb#10
+  sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
+  def initialize(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rewriters/annotate.rb#18
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+
+  private
+
+  # source://rbi//lib/rbi/rewriters/annotate.rb#31
+  sig { params(node: ::RBI::NodeWithComments).void }
+  def annotate_node(node); end
+
+  # source://rbi//lib/rbi/rewriters/annotate.rb#38
+  sig { params(node: ::RBI::Node).returns(T::Boolean) }
+  def root?(node); end
+end
+
+# source://rbi//lib/rbi/rewriters/attr_to_methods.rb#22
+class RBI::Rewriters::AttrToMethods < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#26
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+
+  private
+
+  # @raise [ReplaceNodeError]
+  #
+  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#39
+  sig { params(node: ::RBI::Node, with: T::Array[::RBI::Node]).void }
+  def replace(node, with:); end
+end
+
+# source://rbi//lib/rbi/rewriters/deannotate.rb#6
+class RBI::Rewriters::Deannotate < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/deannotate.rb#10
+  sig { params(annotation: ::String).void }
+  def initialize(annotation); end
+
+  # source://rbi//lib/rbi/rewriters/deannotate.rb#16
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+
+  private
+
+  # source://rbi//lib/rbi/rewriters/deannotate.rb#27
+  sig { params(node: ::RBI::NodeWithComments).void }
+  def deannotate_node(node); end
+end
+
+# Take a gem version and filter out all RBI that is not relevant to that version based on @version annotations
+# in comments. As an example:
+#
+# ~~~rb
+# tree = Parser.parse_string(<<~RBI)
+#   class Foo
+#     # @version > 0.3.0
+#     def bar
+#     end
+#
+#     # @version <= 0.3.0
+#     def bar(arg1)
+#     end
+#   end
+# RBI
+#
+# Rewriters::FilterVersions.filter(tree, Gem::Version.new("0.3.1"))
+#
+# assert_equal(<<~RBI, tree.string)
+#   class Foo
+#     # @version > 0.3.0
+#     def bar
+#     end
+#   end
+# RBI
+# ~~~
+#
+# Supported operators:
+# - equals `=`
+# - not equals `!=`
+# - greater than `>`
+# - greater than or equal to `>=`
+# - less than `<`
+# - less than or equal to `<=`
+# - pessimistic or twiddle-wakka`~>`
+#
+# And/or logic:
+# - "And" logic: put multiple versions on the same line
+#   - e.g. `@version > 0.3.0, <1.0.0` means version must be greater than 0.3.0 AND less than 1.0.0
+# - "Or" logic: put multiple versions on subsequent lines
+#   - e.g. the following means version must be less than 0.3.0 OR greater than 1.0.0
+#       ```
+#       # @version < 0.3.0
+#       # @version > 1.0.0
+#       ```
+# Prerelease versions:
+# - Prerelease versions are considered less than their non-prerelease counterparts
+#   - e.g. `0.4.0-prerelease` is less than `0.4.0`
+#
+# RBI with no versions:
+# - RBI with no version annotations are automatically counted towards ALL versions
+#
+# source://rbi//lib/rbi/rewriters/filter_versions.rb#57
+class RBI::Rewriters::FilterVersions < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/filter_versions.rb#73
+  sig { params(version: ::Gem::Version).void }
+  def initialize(version); end
+
+  # source://rbi//lib/rbi/rewriters/filter_versions.rb#79
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+
+  class << self
+    # source://rbi//lib/rbi/rewriters/filter_versions.rb#66
+    sig { params(tree: ::RBI::Tree, version: ::Gem::Version).void }
+    def filter(tree, version); end
+  end
+end
+
+# source://rbi//lib/rbi/rewriters/filter_versions.rb#60
+RBI::Rewriters::FilterVersions::VERSION_PREFIX = T.let(T.unsafe(nil), String)
+
+# Rewrite non-singleton methods inside singleton classes to singleton methods
+#
+# Example:
+# ~~~rb
+# class << self
+#  def m1; end
+#  def self.m2; end
+#
+#  class << self
+#    def m3; end
+#  end
+# end
+# ~~~
+#
+# will be rewritten to:
+#
+# ~~~rb
+# def self.m1; end
+#
+# class << self
+#   def self.m2; end
+#   def self.m3; end
+# end
+# ~~~
+#
+# source://rbi//lib/rbi/rewriters/flatten_singleton_methods.rb#30
+class RBI::Rewriters::FlattenSingletonMethods < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/flatten_singleton_methods.rb#34
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+end
+
+# Flattens visibility nodes into method nodes
+#
+# Example:
+# ~~~rb
+# class A
+#   def m1; end
+#   private
+#   def m2; end
+#   def m3; end
+# end
+# ~~~
+#
+# will be transformed into:
+#
+# ~~~rb
+# class A
+#   def m1; end
+#   private def m2; end
+#   private def m3; end
+# end
+# ~~~
+#
+# source://rbi//lib/rbi/rewriters/flatten_visibilities.rb#27
+class RBI::Rewriters::FlattenVisibilities < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/flatten_visibilities.rb#31
+  sig { void }
+  def initialize; end
+
+  # source://rbi//lib/rbi/rewriters/flatten_visibilities.rb#38
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+end
+
+# source://rbi//lib/rbi/rewriters/group_nodes.rb#8
+class RBI::Rewriters::GroupNodes < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/group_nodes.rb#12
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+
+  private
+
+  # source://rbi//lib/rbi/rewriters/group_nodes.rb#36
+  sig { params(node: ::RBI::Node).returns(::RBI::Group::Kind) }
+  def group_kind(node); end
+end
+
+# Merge two RBI trees together
+#
+# Be this `Tree`:
+# ~~~rb
+# class Foo
+#   attr_accessor :a
+#   def m; end
+#   C = 10
+# end
+# ~~~
+#
+# Merged with this one:
+# ~~~rb
+# class Foo
+#   attr_reader :a
+#   def m(x); end
+#   C = 10
+# end
+# ~~~
+#
+# Compatible definitions are merged together while incompatible definitions are moved into a `ConflictTree`:
+# ~~~rb
+# class Foo
+#   <<<<<<< left
+#   attr_accessor :a
+#   def m; end
+#   =======
+#   attr_reader :a
+#   def m(x); end
+#   >>>>>>> right
+#   C = 10
+# end
+# ~~~
+#
+# source://rbi//lib/rbi/rewriters/merge_trees.rb#39
+class RBI::Rewriters::Merge
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#70
+  sig { params(left_name: ::String, right_name: ::String, keep: ::RBI::Rewriters::Merge::Keep).void }
+  def initialize(left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#79
+  sig { params(tree: ::RBI::Tree).void }
+  def merge(tree); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#67
+  sig { returns(::RBI::MergeTree) }
+  def tree; end
+
+  class << self
+    # source://rbi//lib/rbi/rewriters/merge_trees.rb#54
+    sig do
+      params(
+        left: ::RBI::Tree,
+        right: ::RBI::Tree,
+        left_name: ::String,
+        right_name: ::String,
+        keep: ::RBI::Rewriters::Merge::Keep
+      ).returns(::RBI::MergeTree)
+    end
+    def merge_trees(left, right, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
+  end
+end
+
+# Used for logging / error displaying purpose
+#
+# source://rbi//lib/rbi/rewriters/merge_trees.rb#86
+class RBI::Rewriters::Merge::Conflict < ::T::Struct
+  const :left, ::RBI::Node
+  const :right, ::RBI::Node
+  const :left_name, ::String
+  const :right_name, ::String
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#95
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    # source://sorbet-runtime/0.5.11592/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# Merge adjacent conflict trees
+#
+# Transform this:
+# ~~~rb
+# class Foo
+#   <<<<<<< left
+#   def m1; end
+#   =======
+#   def m1(a); end
+#   >>>>>>> right
+#   <<<<<<< left
+#   def m2(a); end
+#   =======
+#   def m2; end
+#   >>>>>>> right
+# end
+# ~~~
+#
+# Into this:
+# ~~~rb
+# class Foo
+#   <<<<<<< left
+#   def m1; end
+#   def m2(a); end
+#   =======
+#   def m1(a); end
+#   def m2; end
+#   >>>>>>> right
+# end
+# ~~~
+#
+# source://rbi//lib/rbi/rewriters/merge_trees.rb#245
+class RBI::Rewriters::Merge::ConflictTreeMerger < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#247
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#252
+  sig { override.params(nodes: T::Array[::RBI::Node]).void }
+  def visit_all(nodes); end
+
+  private
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#273
+  sig { params(left: ::RBI::Tree, right: ::RBI::Tree).void }
+  def merge_conflict_trees(left, right); end
+end
+
+# source://rbi//lib/rbi/rewriters/merge_trees.rb#42
+class RBI::Rewriters::Merge::Keep < ::T::Enum
+  enums do
+    LEFT = new
+    NONE = new
+    RIGHT = new
+  end
+end
+
+# source://rbi//lib/rbi/rewriters/merge_trees.rb#100
+class RBI::Rewriters::Merge::TreeMerger < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#107
+  sig do
+    params(
+      output: ::RBI::Tree,
+      left_name: ::String,
+      right_name: ::String,
+      keep: ::RBI::Rewriters::Merge::Keep
+    ).void
+  end
+  def initialize(output, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#104
+  sig { returns(T::Array[::RBI::Rewriters::Merge::Conflict]) }
+  def conflicts; end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#119
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+
+  private
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#168
+  sig { returns(::RBI::Tree) }
+  def current_scope; end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#185
+  sig { params(left: ::RBI::Scope, right: ::RBI::Scope).void }
+  def make_conflict_scope(left, right); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#192
+  sig { params(left: ::RBI::Node, right: ::RBI::Node).void }
+  def make_conflict_tree(left, right); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#173
+  sig { params(node: ::RBI::Node).returns(T.nilable(::RBI::Node)) }
+  def previous_definition(node); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#204
+  sig { params(left: ::RBI::Scope, right: ::RBI::Scope).returns(::RBI::Scope) }
+  def replace_scope_header(left, right); end
+end
+
+# source://rbi//lib/rbi/rewriters/nest_non_public_members.rb#6
+class RBI::Rewriters::NestNonPublicMembers < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/nest_non_public_members.rb#10
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+end
+
+# source://rbi//lib/rbi/rewriters/nest_singleton_methods.rb#6
+class RBI::Rewriters::NestSingletonMethods < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/nest_singleton_methods.rb#10
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+end
+
+# This rewriter moves top-level members into a top-level Object class
+#
+# Example:
+# ~~~rb
+# def foo; end
+# attr_reader :bar
+# ~~~
+#
+# will be rewritten to:
+#
+# ~~~rb
+# class Object
+#  def foo; end
+#  attr_reader :bar
+# end
+# ~~~
+#
+# source://rbi//lib/rbi/rewriters/nest_top_level_members.rb#22
+class RBI::Rewriters::NestTopLevelMembers < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/nest_top_level_members.rb#26
+  sig { void }
+  def initialize; end
+
+  # source://rbi//lib/rbi/rewriters/nest_top_level_members.rb#33
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+end
+
+# Remove all definitions existing in the index from the current tree
+#
+# Let's create an `Index` from two different `Tree`s:
+# ~~~rb
+# tree1 = Parse.parse_string(<<~RBI)
+#   class Foo
+#     def foo; end
+#   end
+# RBI
+#
+# tree2 = Parse.parse_string(<<~RBI)
+#   FOO = 10
+# RBI
+#
+# index = Index.index(tree1, tree2)
+# ~~~
+#
+# We can use `RemoveKnownDefinitions` to remove the definitions found in the `index` from the `Tree` to clean:
+# ~~~rb
+# tree_to_clean = Parser.parse_string(<<~RBI)
+#   class Foo
+#     def foo; end
+#     def bar; end
+#   end
+#   FOO = 10
+#   BAR = 42
+# RBI
+#
+# cleaned_tree, operations = RemoveKnownDefinitions.remove(tree_to_clean, index)
+#
+# assert_equal(<<~RBI, cleaned_tree)
+#   class Foo
+#     def bar; end
+#   end
+#   BAR = 42
+# RBI
+#
+# assert_equal(<<~OPERATIONS, operations.join("\n"))
+#   Deleted ::Foo#foo at -:2:2-2-16 (duplicate from -:2:2-2:16)
+#   Deleted ::FOO at -:5:0-5:8 (duplicate from -:1:0-1:8)
+# OPERATIONS
+# ~~~
+#
+# source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#48
+class RBI::Rewriters::RemoveKnownDefinitions < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#55
+  sig { params(index: ::RBI::Index).void }
+  def initialize(index); end
+
+  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#52
+  sig { returns(T::Array[::RBI::Rewriters::RemoveKnownDefinitions::Operation]) }
+  def operations; end
+
+  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#83
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+
+  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#78
+  sig { params(nodes: T::Array[::RBI::Node]).void }
+  def visit_all(nodes); end
+
+  private
+
+  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#111
+  sig { params(node: ::RBI::Node, previous: ::RBI::Node).returns(T::Boolean) }
+  def can_delete_node?(node, previous); end
+
+  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#129
+  sig { params(node: ::RBI::Node, previous: ::RBI::Node).void }
+  def delete_node(node, previous); end
+
+  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#102
+  sig { params(node: ::RBI::Indexable).returns(T.nilable(::RBI::Node)) }
+  def previous_definition_for(node); end
+
+  class << self
+    # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#70
+    sig do
+      params(
+        tree: ::RBI::Tree,
+        index: ::RBI::Index
+      ).returns([::RBI::Tree, T::Array[::RBI::Rewriters::RemoveKnownDefinitions::Operation]])
+    end
+    def remove(tree, index); end
+  end
+end
+
+# source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#134
+class RBI::Rewriters::RemoveKnownDefinitions::Operation < ::T::Struct
+  const :deleted_node, ::RBI::Node
+  const :duplicate_of, ::RBI::Node
+
+  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#141
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    # source://sorbet-runtime/0.5.11592/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# source://rbi//lib/rbi/rewriters/sort_nodes.rb#6
+class RBI::Rewriters::SortNodes < ::RBI::Visitor
+  # source://rbi//lib/rbi/rewriters/sort_nodes.rb#10
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+
+  private
+
+  # source://rbi//lib/rbi/rewriters/sort_nodes.rb#73
+  sig { params(kind: ::RBI::Group::Kind).returns(::Integer) }
+  def group_rank(kind); end
+
+  # source://rbi//lib/rbi/rewriters/sort_nodes.rb#94
+  sig { params(node: ::RBI::Node).returns(T.nilable(::String)) }
+  def node_name(node); end
+
+  # source://rbi//lib/rbi/rewriters/sort_nodes.rb#45
+  sig { params(node: ::RBI::Node).returns(::Integer) }
+  def node_rank(node); end
+
+  # source://rbi//lib/rbi/rewriters/sort_nodes.rb#106
+  sig { params(node: ::RBI::Node).void }
+  def sort_node_names!(node); end
+end
+
+# Scopes
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/model.rb#178
+class RBI::Scope < ::RBI::Tree
+  include ::RBI::Indexable
+
+  abstract!
+
+  # Duplicate `self` scope without its body
+  #
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#358
+  sig { returns(T.self_type) }
+  def dup_empty; end
+
+  # @abstract
+  #
+  # source://rbi//lib/rbi/model.rb#184
+  sig { abstract.returns(::String) }
+  def fully_qualified_name; end
+
+  # source://rbi//lib/rbi/index.rb#93
+  sig { override.returns(T::Array[::String]) }
+  def index_ids; end
+
+  # source://rbi//lib/rbi/model.rb#187
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# A conflict between two scope headers
+#
+# Is rendered as a merge conflict between `left` and` right` for scope definitions:
+# ~~~rb
+# <<<<<<< left
+# class Foo
+# =======
+# module Foo
+# >>>>>>> right
+#   def m1; end
+# end
+# ~~~
+#
+# source://rbi//lib/rbi/rewriters/merge_trees.rb#616
+class RBI::ScopeConflict < ::RBI::Tree
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#633
+  sig { params(left: ::RBI::Scope, right: ::RBI::Scope, left_name: ::String, right_name: ::String).void }
+  def initialize(left:, right:, left_name: T.unsafe(nil), right_name: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#620
+  sig { returns(::RBI::Scope) }
+  def left; end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#623
+  sig { returns(::String) }
+  def left_name; end
+
+  # @return [Scope]
+  #
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#620
+  def right; end
+
+  # @return [String]
+  #
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#623
+  def right_name; end
+end
+
+# Sends
+#
+# source://rbi//lib/rbi/model.rb#1004
+class RBI::Send < ::RBI::NodeWithComments
+  include ::RBI::Indexable
+
+  # source://rbi//lib/rbi/model.rb#1022
+  sig do
+    params(
+      method: ::String,
+      args: T::Array[::RBI::Arg],
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Send).void)
+    ).void
+  end
+  def initialize(method, args = T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#1030
+  sig { params(arg: ::RBI::Arg).void }
+  def <<(arg); end
+
+  # source://rbi//lib/rbi/model.rb#1035
+  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/model.rb#1011
+  sig { returns(T::Array[::RBI::Arg]) }
+  def args; end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#537
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/index.rb#193
+  sig { override.returns(T::Array[::String]) }
+  def index_ids; end
+
+  # source://rbi//lib/rbi/model.rb#1008
+  sig { returns(::String) }
+  def method; end
+
+  # source://rbi//lib/rbi/model.rb#1040
+  sig { returns(::String) }
+  def to_s; end
+end
+
+# Sorbet's sigs
+#
+# source://rbi//lib/rbi/model.rb#1104
+class RBI::Sig < ::RBI::NodeWithComments
+  # source://rbi//lib/rbi/model.rb#1137
+  sig do
+    params(
+      params: T::Array[::RBI::SigParam],
+      return_type: T.any(::RBI::Type, ::String),
+      is_abstract: T::Boolean,
+      is_override: T::Boolean,
+      is_overridable: T::Boolean,
+      is_final: T::Boolean,
+      type_params: T::Array[::String],
+      checked: T.nilable(::Symbol),
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Sig).void)
+    ).void
+  end
+  def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#1163
+  sig { params(param: ::RBI::SigParam).void }
+  def <<(param); end
+
+  # source://rbi//lib/rbi/model.rb#1173
+  sig { params(other: ::Object).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/model.rb#1168
+  sig { params(name: ::String, type: T.any(::RBI::Type, ::String)).void }
+  def add_param(name, type); end
+
+  # source://rbi//lib/rbi/model.rb#1120
+  sig { returns(T.nilable(::Symbol)) }
+  def checked; end
+
+  # @return [Symbol, nil]
+  #
+  # source://rbi//lib/rbi/model.rb#1120
+  def checked=(_arg0); end
+
+  # source://rbi//lib/rbi/model.rb#1114
+  sig { returns(T::Boolean) }
+  def is_abstract; end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/model.rb#1114
+  def is_abstract=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/model.rb#1114
+  def is_final; end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/model.rb#1114
+  def is_final=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/model.rb#1114
+  def is_overridable; end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/model.rb#1114
+  def is_overridable=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/model.rb#1114
+  def is_override; end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/model.rb#1114
+  def is_override=(_arg0); end
+
+  # source://rbi//lib/rbi/model.rb#1108
+  sig { returns(T::Array[::RBI::SigParam]) }
+  def params; end
+
+  # source://rbi//lib/rbi/model.rb#1111
+  sig { returns(T.any(::RBI::Type, ::String)) }
+  def return_type; end
+
+  # @return [Type, String]
+  #
+  # source://rbi//lib/rbi/model.rb#1111
+  def return_type=(_arg0); end
+
+  # source://rbi//lib/rbi/model.rb#1117
+  sig { returns(T::Array[::String]) }
+  def type_params; end
+end
+
+# source://rbi//lib/rbi/model.rb#1182
+class RBI::SigParam < ::RBI::NodeWithComments
+  # source://rbi//lib/rbi/model.rb#1200
+  sig do
+    params(
+      name: ::String,
+      type: T.any(::RBI::Type, ::String),
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::SigParam).void)
+    ).void
+  end
+  def initialize(name, type, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#1208
+  sig { params(other: ::Object).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/model.rb#1186
+  sig { returns(::String) }
+  def name; end
+
+  # source://rbi//lib/rbi/model.rb#1189
+  sig { returns(T.any(::RBI::Type, ::String)) }
+  def type; end
+end
+
+# source://rbi//lib/rbi/model.rb#253
+class RBI::SingletonClass < ::RBI::Scope
+  # source://rbi//lib/rbi/model.rb#263
+  sig do
+    params(
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::SingletonClass).void)
+    ).void
+  end
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#269
+  sig { override.returns(::String) }
+  def fully_qualified_name; end
+end
+
+# source://rbi//lib/rbi/model.rb#274
+class RBI::Struct < ::RBI::Scope
+  # source://rbi//lib/rbi/model.rb#296
+  sig do
+    params(
+      name: ::String,
+      members: T::Array[::Symbol],
+      keyword_init: T::Boolean,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(struct: ::RBI::Struct).void)
+    ).void
+  end
+  def initialize(name, members: T.unsafe(nil), keyword_init: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#402
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/model.rb#305
+  sig { override.returns(::String) }
+  def fully_qualified_name; end
+
+  # source://rbi//lib/rbi/model.rb#284
+  sig { returns(T::Boolean) }
+  def keyword_init; end
+
+  # @return [Boolean]
+  #
+  # source://rbi//lib/rbi/model.rb#284
+  def keyword_init=(_arg0); end
+
+  # source://rbi//lib/rbi/model.rb#281
+  sig { returns(T::Array[::Symbol]) }
+  def members; end
+
+  # @return [Array<Symbol>]
+  #
+  # source://rbi//lib/rbi/model.rb#281
+  def members=(_arg0); end
+
+  # source://rbi//lib/rbi/model.rb#278
+  sig { returns(::String) }
+  def name; end
+
+  # @return [String]
+  #
+  # source://rbi//lib/rbi/model.rb#278
+  def name=(_arg0); end
+end
+
+# Sorbet's T::Enum
+#
+# source://rbi//lib/rbi/model.rb#1329
+class RBI::TEnum < ::RBI::Class
+  # source://rbi//lib/rbi/model.rb#1340
+  sig do
+    params(
+      name: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(klass: ::RBI::TEnum).void)
+    ).void
+  end
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+# source://rbi//lib/rbi/model.rb#1346
+class RBI::TEnumBlock < ::RBI::Scope
+  # source://rbi//lib/rbi/model.rb#1356
+  sig do
+    params(
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::TEnumBlock).void)
+    ).void
+  end
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#1362
+  sig { override.returns(::String) }
+  def fully_qualified_name; end
+
+  # source://rbi//lib/rbi/index.rb#223
+  sig { override.returns(T::Array[::String]) }
+  def index_ids; end
+
+  # source://rbi//lib/rbi/model.rb#1367
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# Sorbet's T::Struct
+#
+# source://rbi//lib/rbi/model.rb#1215
+class RBI::TStruct < ::RBI::Class
+  # source://rbi//lib/rbi/model.rb#1226
+  sig do
+    params(
+      name: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(klass: ::RBI::TStruct).void)
+    ).void
+  end
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+# source://rbi//lib/rbi/model.rb#1267
+class RBI::TStructConst < ::RBI::TStructField
+  include ::RBI::Indexable
+
+  # source://rbi//lib/rbi/model.rb#1280
+  sig do
+    params(
+      name: ::String,
+      type: T.any(::RBI::Type, ::String),
+      default: T.nilable(::String),
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::TStructConst).void)
+    ).void
+  end
+  def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#555
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/model.rb#1286
+  sig { override.returns(T::Array[::String]) }
+  def fully_qualified_names; end
+
+  # source://rbi//lib/rbi/index.rb#203
+  sig { override.returns(T::Array[::String]) }
+  def index_ids; end
+
+  # source://rbi//lib/rbi/model.rb#1292
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/model.rb#1232
+class RBI::TStructField < ::RBI::NodeWithComments
+  abstract!
+
+  # source://rbi//lib/rbi/model.rb#1256
+  sig do
+    params(
+      name: ::String,
+      type: T.any(::RBI::Type, ::String),
+      default: T.nilable(::String),
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment]
+    ).void
+  end
+  def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#546
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/model.rb#1245
+  sig { returns(T.nilable(::String)) }
+  def default; end
+
+  # @return [String, nil]
+  #
+  # source://rbi//lib/rbi/model.rb#1245
+  def default=(_arg0); end
+
+  # @abstract
+  #
+  # source://rbi//lib/rbi/model.rb#1264
+  sig { abstract.returns(T::Array[::String]) }
+  def fully_qualified_names; end
+
+  # source://rbi//lib/rbi/model.rb#1239
+  sig { returns(::String) }
+  def name; end
+
+  # @return [String]
+  #
+  # source://rbi//lib/rbi/model.rb#1239
+  def name=(_arg0); end
+
+  # source://rbi//lib/rbi/model.rb#1242
+  sig { returns(T.any(::RBI::Type, ::String)) }
+  def type; end
+
+  # @return [Type, String]
+  #
+  # source://rbi//lib/rbi/model.rb#1242
+  def type=(_arg0); end
+end
+
+# source://rbi//lib/rbi/model.rb#1297
+class RBI::TStructProp < ::RBI::TStructField
+  include ::RBI::Indexable
+
+  # source://rbi//lib/rbi/model.rb#1310
+  sig do
+    params(
+      name: ::String,
+      type: T.any(::RBI::Type, ::String),
+      default: T.nilable(::String),
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::TStructProp).void)
+    ).void
+  end
+  def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#564
+  sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  # source://rbi//lib/rbi/model.rb#1316
+  sig { override.returns(T::Array[::String]) }
+  def fully_qualified_names; end
+
+  # source://rbi//lib/rbi/index.rb#213
+  sig { override.returns(T::Array[::String]) }
+  def index_ids; end
+
+  # source://rbi//lib/rbi/model.rb#1322
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#108
+class RBI::Tree < ::RBI::NodeWithComments
+  # source://rbi//lib/rbi/model.rb#121
+  sig do
+    params(
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Tree).void)
+    ).void
+  end
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#128
+  sig { params(node: ::RBI::Node).void }
+  def <<(node); end
+
+  # source://rbi//lib/rbi/rewriters/add_sig_templates.rb#66
+  sig { params(with_todo_comment: T::Boolean).void }
+  def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rewriters/annotate.rb#49
+  sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
+  def annotate!(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end
+
+  # source://tapioca/0.16.3/lib/tapioca/rbi_ext/model.rb#38
+  sig do
+    params(
+      name: ::String,
+      superclass_name: T.nilable(::String),
+      block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)
+    ).returns(::RBI::Scope)
+  end
+  def create_class(name, superclass_name: T.unsafe(nil), &block); end
+
+  # source://tapioca/0.16.3/lib/tapioca/rbi_ext/model.rb#45
+  sig { params(name: ::String, value: ::String).void }
+  def create_constant(name, value:); end
+
+  # source://tapioca/0.16.3/lib/tapioca/rbi_ext/model.rb#55
+  sig { params(name: ::String).void }
+  def create_extend(name); end
+
+  # source://tapioca/0.16.3/lib/tapioca/rbi_ext/model.rb#50
+  sig { params(name: ::String).void }
+  def create_include(name); end
+
+  # source://tapioca/0.16.3/lib/tapioca/rbi_ext/model.rb#90
+  sig do
+    params(
+      name: ::String,
+      parameters: T::Array[::RBI::TypedParam],
+      return_type: T.nilable(::String),
+      class_method: T::Boolean,
+      visibility: ::RBI::Visibility,
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Method).void)
+    ).void
+  end
+  def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil), visibility: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://tapioca/0.16.3/lib/tapioca/rbi_ext/model.rb#60
+  sig { params(name: ::String).void }
+  def create_mixes_in_class_methods(name); end
+
+  # source://tapioca/0.16.3/lib/tapioca/rbi_ext/model.rb#25
+  sig { params(name: ::String, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
+  def create_module(name, &block); end
+
+  # source://tapioca/0.16.3/lib/tapioca/rbi_ext/model.rb#9
+  sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
+  def create_path(constant, &block); end
+
+  # source://tapioca/0.16.3/lib/tapioca/rbi_ext/model.rb#74
+  sig do
+    params(
+      name: ::String,
+      type: ::String,
+      variance: ::Symbol,
+      fixed: T.nilable(::String),
+      upper: T.nilable(::String),
+      lower: T.nilable(::String)
+    ).void
+  end
+  def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rewriters/deannotate.rb#41
+  sig { params(annotation: ::String).void }
+  def deannotate!(annotation); end
+
+  # source://rbi//lib/rbi/model.rb#134
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  # source://rbi//lib/rbi/rewriters/filter_versions.rb#118
+  sig { params(version: ::Gem::Version).void }
+  def filter_versions!(version); end
+
+  # source://rbi//lib/rbi/rewriters/flatten_singleton_methods.rb#60
+  sig { void }
+  def flatten_singleton_methods!; end
+
+  # source://rbi//lib/rbi/rewriters/flatten_visibilities.rb#60
+  sig { void }
+  def flatten_visibilities!; end
+
+  # source://rbi//lib/rbi/rewriters/group_nodes.rb#81
+  sig { void }
+  def group_nodes!; end
+
+  # source://rbi//lib/rbi/index.rb#68
+  sig { returns(::RBI::Index) }
+  def index; end
+
+  # source://rbi//lib/rbi/rewriters/merge_trees.rb#324
+  sig do
+    params(
+      other: ::RBI::Tree,
+      left_name: ::String,
+      right_name: ::String,
+      keep: ::RBI::Rewriters::Merge::Keep
+    ).returns(::RBI::MergeTree)
+  end
+  def merge(other, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/rewriters/nest_non_public_members.rb#46
+  sig { void }
+  def nest_non_public_members!; end
+
+  # source://rbi//lib/rbi/rewriters/nest_singleton_methods.rb#36
+  sig { void }
+  def nest_singleton_methods!; end
+
+  # source://rbi//lib/rbi/rewriters/nest_top_level_members.rb#63
+  sig { void }
+  def nest_top_level_members!; end
+
+  # source://rbi//lib/rbi/model.rb#112
+  sig { returns(T::Array[::RBI::Node]) }
+  def nodes; end
+
+  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#53
+  sig { void }
+  def replace_attributes_with_methods!; end
+
+  # source://rbi//lib/rbi/rewriters/sort_nodes.rb#119
+  sig { void }
+  def sort_nodes!; end
+
+  private
+
+  # source://tapioca/0.16.3/lib/tapioca/rbi_ext/model.rb#123
+  sig { params(node: ::RBI::Node).returns(::RBI::Node) }
+  def create_node(node); end
+
+  # source://tapioca/0.16.3/lib/tapioca/rbi_ext/model.rb#118
+  sig { returns(T::Hash[::String, ::RBI::Node]) }
+  def nodes_cache; end
+end
+
+# The base class for all RBI types.
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/type.rb#6
+class RBI::Type
+  abstract!
+
+  # source://rbi//lib/rbi/type.rb#699
+  sig { void }
+  def initialize; end
+
+  # @abstract
+  #
+  # source://rbi//lib/rbi/type.rb#745
+  sig { abstract.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#748
+  sig { params(other: ::BasicObject).returns(T::Boolean) }
+  def eql?(other); end
+
+  # source://rbi//lib/rbi/type.rb#753
+  sig { override.returns(::Integer) }
+  def hash; end
+
+  # Returns a new type that is `nilable` if it is not already.
+  #
+  # If the type is already nilable, it returns itself.
+  # ```ruby
+  # type = RBI::Type.simple("String")
+  # type.to_rbi # => "String"
+  # type.nilable.to_rbi # => "T.nilable(String)"
+  # type.nilable.nilable.to_rbi # => "T.nilable(String)"
+  # ```
+  #
+  # source://rbi//lib/rbi/type.rb#713
+  sig { returns(::RBI::Type) }
+  def nilable; end
+
+  # Returns whether the type is nilable.
+  #
+  # source://rbi//lib/rbi/type.rb#740
+  sig { returns(T::Boolean) }
+  def nilable?; end
+
+  # Returns the non-nilable version of the type.
+  # If the type is already non-nilable, it returns itself.
+  # If the type is nilable, it returns the inner type.
+  #
+  # ```ruby
+  # type = RBI::Type.nilable(RBI::Type.simple("String"))
+  # type.to_rbi # => "T.nilable(String)"
+  # type.non_nilable.to_rbi # => "String"
+  # type.non_nilable.non_nilable.to_rbi # => "String"
+  # ```
+  #
+  # source://rbi//lib/rbi/type.rb#728
+  sig { returns(::RBI::Type) }
+  def non_nilable; end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#1030
+  sig { returns(::String) }
+  def rbs_string; end
+
+  # @abstract
+  #
+  # source://rbi//lib/rbi/type.rb#758
+  sig { abstract.returns(::String) }
+  def to_rbi; end
+
+  # source://rbi//lib/rbi/type.rb#761
+  sig { override.returns(::String) }
+  def to_s; end
+
+  class << self
+    # Builds a type that represents an intersection of multiple types like `T.all(String, Integer)`.
+    #
+    # Note that this method transforms types such as `T.all(String, String)` into `String`, so
+    # it may return something other than a `All`.
+    #
+    # source://rbi//lib/rbi/type.rb#563
+    sig { params(type1: ::RBI::Type, type2: ::RBI::Type, types: ::RBI::Type).returns(::RBI::Type) }
+    def all(type1, type2, *types); end
+
+    # Builds a type that represents a union of multiple types like `T.any(String, Integer)`.
+    #
+    # Note that this method transforms types such as `T.any(String, NilClass)` into `T.nilable(String)`, so
+    # it may return something other than a `Any`.
+    #
+    # source://rbi//lib/rbi/type.rb#590
+    sig { params(type1: ::RBI::Type, type2: ::RBI::Type, types: ::RBI::Type).returns(::RBI::Type) }
+    def any(type1, type2, *types); end
+
+    # Builds a type that represents `T.anything`.
+    #
+    # source://rbi//lib/rbi/type.rb#488
+    sig { returns(::RBI::Type::Anything) }
+    def anything; end
+
+    # Builds a type that represents `T.attached_class`.
+    #
+    # source://rbi//lib/rbi/type.rb#494
+    sig { returns(::RBI::Type::AttachedClass) }
+    def attached_class; end
+
+    # Builds a type that represents `T::Boolean`.
+    #
+    # source://rbi//lib/rbi/type.rb#500
+    sig { returns(::RBI::Type::Boolean) }
+    def boolean; end
+
+    # Builds a type that represents the singleton class of another type like `T.class_of(Foo)`.
+    #
+    # source://rbi//lib/rbi/type.rb#538
+    sig { params(type: ::RBI::Type::Simple, type_parameter: T.nilable(::RBI::Type)).returns(::RBI::Type::ClassOf) }
+    def class_of(type, type_parameter = T.unsafe(nil)); end
+
+    # Builds a type that represents a generic type like `T::Array[String]` or `T::Hash[Symbol, Integer]`.
+    #
+    # source://rbi//lib/rbi/type.rb#655
+    sig { params(name: ::String, params: T.any(::RBI::Type, T::Array[::RBI::Type])).returns(::RBI::Type::Generic) }
+    def generic(name, *params); end
+
+    # Builds a type that represents a nilable of another type like `T.nilable(String)`.
+    #
+    # Note that this method transforms types such as `T.nilable(T.untyped)` into `T.untyped`, so
+    # it may return something other than a `RBI::Type::Nilable`.
+    #
+    # source://rbi//lib/rbi/type.rb#547
+    sig { params(type: ::RBI::Type).returns(::RBI::Type) }
+    def nilable(type); end
+
+    # Builds a type that represents `T.noreturn`.
+    #
+    # source://rbi//lib/rbi/type.rb#506
+    sig { returns(::RBI::Type::NoReturn) }
+    def noreturn; end
+
+    # source://rbi//lib/rbi/type_parser.rb#26
+    sig { params(node: ::Prism::Node).returns(::RBI::Type) }
+    def parse_node(node); end
+
+    # @raise [Error]
+    #
+    # source://rbi//lib/rbi/type_parser.rb#10
+    sig { params(string: ::String).returns(::RBI::Type) }
+    def parse_string(string); end
+
+    # Builds a type that represents a proc type like `T.proc.void`.
+    #
+    # source://rbi//lib/rbi/type.rb#683
+    sig { returns(::RBI::Type::Proc) }
+    def proc; end
+
+    # Builds a type that represents `T.self_type`.
+    #
+    # source://rbi//lib/rbi/type.rb#512
+    sig { returns(::RBI::Type::SelfType) }
+    def self_type; end
+
+    # Builds a type that represents a shape type like `{name: String, age: Integer}`.
+    #
+    # source://rbi//lib/rbi/type.rb#675
+    sig { params(types: T::Hash[T.any(::String, ::Symbol), ::RBI::Type]).returns(::RBI::Type::Shape) }
+    def shape(types = T.unsafe(nil)); end
+
+    # Builds a simple type like `String` or `::Foo::Bar`.
+    #
+    # It raises a `NameError` if the name is not a valid Ruby class identifier.
+    #
+    # @raise [NameError]
+    #
+    # source://rbi//lib/rbi/type.rb#477
+    sig { params(name: ::String).returns(::RBI::Type::Simple) }
+    def simple(name); end
+
+    # Builds a type that represents the class of another type like `T::Class[Foo]`.
+    #
+    # source://rbi//lib/rbi/type.rb#532
+    sig { params(type: ::RBI::Type).returns(::RBI::Type::Class) }
+    def t_class(type); end
+
+    # Builds a type that represents a tuple type like `[String, Integer]`.
+    #
+    # source://rbi//lib/rbi/type.rb#669
+    sig { params(types: T.any(::RBI::Type, T::Array[::RBI::Type])).returns(::RBI::Type::Tuple) }
+    def tuple(*types); end
+
+    # Builds a type that represents a type parameter like `T.type_parameter(:U)`.
+    #
+    # source://rbi//lib/rbi/type.rb#661
+    sig { params(name: ::Symbol).returns(::RBI::Type::TypeParameter) }
+    def type_parameter(name); end
+
+    # Builds a type that represents `T.untyped`.
+    #
+    # source://rbi//lib/rbi/type.rb#518
+    sig { returns(::RBI::Type::Untyped) }
+    def untyped; end
+
+    # Builds a type that represents `void`.
+    #
+    # source://rbi//lib/rbi/type.rb#524
+    sig { returns(::RBI::Type::Void) }
+    def void; end
+
+    private
+
+    # source://rbi//lib/rbi/type_parser.rb#263
+    sig { params(node: ::Prism::CallNode).returns(T::Array[::Prism::Node]) }
+    def call_chain(node); end
+
+    # source://rbi//lib/rbi/type_parser.rb#250
+    sig { params(node: ::Prism::CallNode, count: ::Integer).returns(T::Array[::Prism::Node]) }
+    def check_arguments_at_least!(node, count); end
+
+    # source://rbi//lib/rbi/type_parser.rb#235
+    sig { params(node: ::Prism::CallNode, count: ::Integer).returns(T::Array[::Prism::Node]) }
+    def check_arguments_exactly!(node, count); end
+
+    # @raise [Error]
+    #
+    # source://rbi//lib/rbi/type_parser.rb#69
+    sig { params(node: ::Prism::CallNode).returns(::RBI::Type) }
+    def parse_call(node); end
+
+    # source://rbi//lib/rbi/type_parser.rb#52
+    sig { params(node: T.any(::Prism::ConstantPathNode, ::Prism::ConstantReadNode)).returns(::RBI::Type) }
+    def parse_constant(node); end
+
+    # @raise [Error]
+    #
+    # source://rbi//lib/rbi/type_parser.rb#195
+    sig { params(node: ::Prism::CallNode).returns(::RBI::Type) }
+    def parse_proc(node); end
+
+    # source://rbi//lib/rbi/type_parser.rb#176
+    sig { params(node: T.any(::Prism::HashNode, ::Prism::KeywordHashNode)).returns(::RBI::Type) }
+    def parse_shape(node); end
+
+    # source://rbi//lib/rbi/type_parser.rb#171
+    sig { params(node: ::Prism::ArrayNode).returns(::RBI::Type) }
+    def parse_tuple(node); end
+
+    # source://rbi//lib/rbi/type_parser.rb#276
+    sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+    def t?(node); end
+
+    # source://rbi//lib/rbi/type_parser.rb#288
+    sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+    def t_boolean?(node); end
+
+    # source://rbi//lib/rbi/type_parser.rb#295
+    sig { params(node: ::Prism::ConstantPathNode).returns(T::Boolean) }
+    def t_class?(node); end
+
+    # source://rbi//lib/rbi/type_parser.rb#300
+    sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+    def t_class_of?(node); end
+
+    # source://rbi//lib/rbi/type_parser.rb#307
+    sig { params(node: ::Prism::CallNode).returns(T::Boolean) }
+    def t_proc?(node); end
+
+    # source://rbi//lib/rbi/type.rb#693
+    sig { params(name: ::String).returns(T::Boolean) }
+    def valid_identifier?(name); end
+  end
+end
+
+# A type that is intersection of multiple types like `T.all(String, Integer)`.
+#
+# source://rbi//lib/rbi/type.rb#252
+class RBI::Type::All < ::RBI::Type::Composite
+  # source://rbi//lib/rbi/type.rb#256
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# A type that is union of multiple types like `T.any(String, Integer)`.
+#
+# source://rbi//lib/rbi/type.rb#262
+class RBI::Type::Any < ::RBI::Type::Composite
+  # source://rbi//lib/rbi/type.rb#271
+  sig { returns(T::Boolean) }
+  def nilable?; end
+
+  # source://rbi//lib/rbi/type.rb#266
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# `T.anything`.
+#
+# source://rbi//lib/rbi/type.rb#43
+class RBI::Type::Anything < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#47
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#52
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# `T.attached_class`.
+#
+# source://rbi//lib/rbi/type.rb#58
+class RBI::Type::AttachedClass < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#62
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#67
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# `T::Boolean`.
+#
+# source://rbi//lib/rbi/type.rb#73
+class RBI::Type::Boolean < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#77
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#82
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# The class of another type like `T::Class[Foo]`.
+#
+# source://rbi//lib/rbi/type.rb#150
+class RBI::Type::Class < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#157
+  sig { params(type: ::RBI::Type).void }
+  def initialize(type); end
+
+  # source://rbi//lib/rbi/type.rb#163
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#168
+  sig { override.returns(::String) }
+  def to_rbi; end
+
+  # source://rbi//lib/rbi/type.rb#154
+  sig { returns(::RBI::Type) }
+  def type; end
+end
+
+# The singleton class of another type like `T.class_of(Foo)`.
+#
+# source://rbi//lib/rbi/type.rb#174
+class RBI::Type::ClassOf < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#184
+  sig { params(type: ::RBI::Type::Simple, type_parameter: T.nilable(::RBI::Type)).void }
+  def initialize(type, type_parameter = T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/type.rb#191
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#196
+  sig { override.returns(::String) }
+  def to_rbi; end
+
+  # source://rbi//lib/rbi/type.rb#178
+  sig { returns(::RBI::Type::Simple) }
+  def type; end
+
+  # source://rbi//lib/rbi/type.rb#181
+  sig { returns(T.nilable(::RBI::Type)) }
+  def type_parameter; end
+end
+
+# A type that is composed of multiple types like `T.all(String, Integer)`.
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/type.rb#230
+class RBI::Type::Composite < ::RBI::Type
+  abstract!
+
+  # source://rbi//lib/rbi/type.rb#240
+  sig { params(types: T::Array[::RBI::Type]).void }
+  def initialize(types); end
+
+  # source://rbi//lib/rbi/type.rb#246
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#237
+  sig { returns(T::Array[::RBI::Type]) }
+  def types; end
+end
+
+# source://rbi//lib/rbi/type_parser.rb#6
+class RBI::Type::Error < ::RBI::Error; end
+
+# A generic type like `T::Array[String]` or `T::Hash[Symbol, Integer]`.
+#
+# source://rbi//lib/rbi/type.rb#279
+class RBI::Type::Generic < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#289
+  sig { params(name: ::String, params: ::RBI::Type).void }
+  def initialize(name, *params); end
+
+  # source://rbi//lib/rbi/type.rb#296
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#283
+  sig { returns(::String) }
+  def name; end
+
+  # source://rbi//lib/rbi/type.rb#286
+  sig { returns(T::Array[::RBI::Type]) }
+  def params; end
+
+  # source://rbi//lib/rbi/type.rb#301
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# A type that can be `nil` like `T.nilable(String)`.
+#
+# source://rbi//lib/rbi/type.rb#206
+class RBI::Type::Nilable < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#213
+  sig { params(type: ::RBI::Type).void }
+  def initialize(type); end
+
+  # source://rbi//lib/rbi/type.rb#219
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#224
+  sig { override.returns(::String) }
+  def to_rbi; end
+
+  # source://rbi//lib/rbi/type.rb#210
+  sig { returns(::RBI::Type) }
+  def type; end
+end
+
+# `T.noreturn`.
+#
+# source://rbi//lib/rbi/type.rb#88
+class RBI::Type::NoReturn < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#92
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#97
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# A proc type like `T.proc.void`.
+#
+# source://rbi//lib/rbi/type.rb#387
+class RBI::Type::Proc < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#400
+  sig { void }
+  def initialize; end
+
+  # source://rbi//lib/rbi/type.rb#408
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#436
+  sig { params(type: T.untyped).returns(T.self_type) }
+  def bind(type); end
+
+  # source://rbi//lib/rbi/type.rb#418
+  sig { params(params: ::RBI::Type).returns(T.self_type) }
+  def params(**params); end
+
+  # source://rbi//lib/rbi/type.rb#397
+  sig { returns(T.nilable(::RBI::Type)) }
+  def proc_bind; end
+
+  # source://rbi//lib/rbi/type.rb#391
+  sig { returns(T::Hash[::Symbol, ::RBI::Type]) }
+  def proc_params; end
+
+  # source://rbi//lib/rbi/type.rb#394
+  sig { returns(::RBI::Type) }
+  def proc_returns; end
+
+  # source://rbi//lib/rbi/type.rb#424
+  sig { params(type: T.untyped).returns(T.self_type) }
+  def returns(type); end
+
+  # source://rbi//lib/rbi/type.rb#442
+  sig { override.returns(::String) }
+  def to_rbi; end
+
+  # source://rbi//lib/rbi/type.rb#430
+  sig { returns(T.self_type) }
+  def void; end
+end
+
+# `T.self_type`.
+#
+# source://rbi//lib/rbi/type.rb#103
+class RBI::Type::SelfType < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#107
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#112
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# A shape type like `{name: String, age: Integer}`.
+#
+# source://rbi//lib/rbi/type.rb#357
+class RBI::Type::Shape < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#364
+  sig { params(types: T::Hash[T.any(::String, ::Symbol), ::RBI::Type]).void }
+  def initialize(types); end
+
+  # source://rbi//lib/rbi/type.rb#370
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#375
+  sig { override.returns(::String) }
+  def to_rbi; end
+
+  # source://rbi//lib/rbi/type.rb#361
+  sig { returns(T::Hash[T.any(::String, ::Symbol), ::RBI::Type]) }
+  def types; end
+end
+
+# A type that represents a simple class name like `String` or `Foo`.
+#
+# It can also be a qualified name like `::Foo` or `Foo::Bar`.
+#
+# source://rbi//lib/rbi/type.rb#17
+class RBI::Type::Simple < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#24
+  sig { params(name: ::String).void }
+  def initialize(name); end
+
+  # source://rbi//lib/rbi/type.rb#30
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#21
+  sig { returns(::String) }
+  def name; end
+
+  # source://rbi//lib/rbi/type.rb#35
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# A tuple type like `[String, Integer]`.
+#
+# source://rbi//lib/rbi/type.rb#333
+class RBI::Type::Tuple < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#340
+  sig { params(types: T::Array[::RBI::Type]).void }
+  def initialize(types); end
+
+  # source://rbi//lib/rbi/type.rb#346
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#351
+  sig { override.returns(::String) }
+  def to_rbi; end
+
+  # source://rbi//lib/rbi/type.rb#337
+  sig { returns(T::Array[::RBI::Type]) }
+  def types; end
+end
+
+# A type parameter like `T.type_parameter(:U)`.
+#
+# source://rbi//lib/rbi/type.rb#307
+class RBI::Type::TypeParameter < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#314
+  sig { params(name: ::Symbol).void }
+  def initialize(name); end
+
+  # source://rbi//lib/rbi/type.rb#320
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#311
+  sig { returns(::Symbol) }
+  def name; end
+
+  # source://rbi//lib/rbi/type.rb#325
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# `T.untyped`.
+#
+# source://rbi//lib/rbi/type.rb#118
+class RBI::Type::Untyped < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#122
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#127
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# source://rbi//lib/rbi/type_visitor.rb#6
+class RBI::Type::Visitor
+  # source://rbi//lib/rbi/type_visitor.rb#12
+  sig { params(node: ::RBI::Type).void }
+  def visit(node); end
+
+  private
+
+  # source://rbi//lib/rbi/type_visitor.rb#58
+  sig { params(type: ::RBI::Type::All).void }
+  def visit_all(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#61
+  sig { params(type: ::RBI::Type::Any).void }
+  def visit_any(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#64
+  sig { params(type: ::RBI::Type::Anything).void }
+  def visit_anything(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#67
+  sig { params(type: ::RBI::Type::AttachedClass).void }
+  def visit_attached_class(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#70
+  sig { params(type: ::RBI::Type::Boolean).void }
+  def visit_boolean(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#73
+  sig { params(type: ::RBI::Type::Class).void }
+  def visit_class(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#76
+  sig { params(type: ::RBI::Type::ClassOf).void }
+  def visit_class_of(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#79
+  sig { params(type: ::RBI::Type::Generic).void }
+  def visit_generic(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#82
+  sig { params(type: ::RBI::Type::Nilable).void }
+  def visit_nilable(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#88
+  sig { params(type: ::RBI::Type::NoReturn).void }
+  def visit_no_return(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#91
+  sig { params(type: ::RBI::Type::Proc).void }
+  def visit_proc(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#94
+  sig { params(type: ::RBI::Type::SelfType).void }
+  def visit_self_type(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#100
+  sig { params(type: ::RBI::Type::Shape).void }
+  def visit_shape(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#85
+  sig { params(type: ::RBI::Type::Simple).void }
+  def visit_simple(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#103
+  sig { params(type: ::RBI::Type::Tuple).void }
+  def visit_tuple(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#106
+  sig { params(type: ::RBI::Type::TypeParameter).void }
+  def visit_type_parameter(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#109
+  sig { params(type: ::RBI::Type::Untyped).void }
+  def visit_untyped(type); end
+
+  # source://rbi//lib/rbi/type_visitor.rb#97
+  sig { params(type: ::RBI::Type::Void).void }
+  def visit_void(type); end
+end
+
+# source://rbi//lib/rbi/type_visitor.rb#9
+class RBI::Type::Visitor::Error < ::RBI::Error; end
+
+# `void`.
+#
+# source://rbi//lib/rbi/type.rb#133
+class RBI::Type::Void < ::RBI::Type
+  # source://rbi//lib/rbi/type.rb#137
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/type.rb#142
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# source://rbi//lib/rbi/model.rb#1400
+class RBI::TypeMember < ::RBI::NodeWithComments
+  include ::RBI::Indexable
+
+  # source://rbi//lib/rbi/model.rb#1415
+  sig do
+    params(
+      name: ::String,
+      value: ::String,
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::TypeMember).void)
+    ).void
+  end
+  def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi//lib/rbi/model.rb#1423
+  sig { returns(::String) }
+  def fully_qualified_name; end
+
+  # source://rbi//lib/rbi/index.rb#183
+  sig { override.returns(T::Array[::String]) }
+  def index_ids; end
+
+  # source://rbi//lib/rbi/model.rb#1404
+  sig { returns(::String) }
+  def name; end
+
+  # source://rbi//lib/rbi/model.rb#1430
+  sig { override.returns(::String) }
+  def to_s; end
+
+  # @return [String]
+  #
+  # source://rbi//lib/rbi/model.rb#1404
+  def value; end
+end
+
+# source://rbi//lib/rbi/rbs_printer.rb#787
+class RBI::TypePrinter
+  # source://rbi//lib/rbi/rbs_printer.rb#794
+  sig { void }
+  def initialize; end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#791
+  sig { returns(::String) }
+  def string; end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#799
+  sig { params(node: ::RBI::Type).void }
+  def visit(node); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#907
+  sig { params(type: ::RBI::Type::All).void }
+  def visit_all(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#917
+  sig { params(type: ::RBI::Type::Any).void }
+  def visit_any(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#864
+  sig { params(type: ::RBI::Type::Anything).void }
+  def visit_anything(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#889
+  sig { params(type: ::RBI::Type::AttachedClass).void }
+  def visit_attached_class(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#848
+  sig { params(type: ::RBI::Type::Boolean).void }
+  def visit_boolean(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#969
+  sig { params(type: ::RBI::Type::Class).void }
+  def visit_class(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#900
+  sig { params(type: ::RBI::Type::ClassOf).void }
+  def visit_class_of(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#853
+  sig { params(type: ::RBI::Type::Generic).void }
+  def visit_generic(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#894
+  sig { params(type: ::RBI::Type::Nilable).void }
+  def visit_nilable(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#874
+  sig { params(type: ::RBI::Type::NoReturn).void }
+  def visit_no_return(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#948
+  sig { params(type: ::RBI::Type::Proc).void }
+  def visit_proc(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#884
+  sig { params(type: ::RBI::Type::SelfType).void }
+  def visit_self_type(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#937
+  sig { params(type: ::RBI::Type::Shape).void }
+  def visit_shape(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#843
+  sig { params(type: ::RBI::Type::Simple).void }
+  def visit_simple(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#927
+  sig { params(type: ::RBI::Type::Tuple).void }
+  def visit_tuple(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#964
+  sig { params(type: ::RBI::Type::TypeParameter).void }
+  def visit_type_parameter(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#879
+  sig { params(type: ::RBI::Type::Untyped).void }
+  def visit_untyped(type); end
+
+  # source://rbi//lib/rbi/rbs_printer.rb#869
+  sig { params(type: ::RBI::Type::Void).void }
+  def visit_void(type); end
+
+  private
+
+  # source://rbi//lib/rbi/rbs_printer.rb#978
+  sig { params(type_name: ::String).returns(::String) }
+  def translate_t_type(type_name); end
+end
+
+# source://rbi//lib/rbi/rewriters/attr_to_methods.rb#5
+class RBI::UnexpectedMultipleSigsError < ::RBI::Error
+  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#10
+  sig { params(node: ::RBI::Node).void }
+  def initialize(node); end
+
+  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#7
+  sig { returns(::RBI::Node) }
+  def node; end
+end
+
+# source://rbi//lib/rbi/parser.rb#20
+class RBI::UnexpectedParserError < ::RBI::Error
+  # source://rbi//lib/rbi/parser.rb#27
+  sig { params(parent_exception: ::Exception, last_location: ::RBI::Loc).void }
+  def initialize(parent_exception, last_location); end
+
+  # source://rbi//lib/rbi/parser.rb#24
+  sig { returns(::RBI::Loc) }
+  def last_location; end
+
+  # source://rbi//lib/rbi/parser.rb#34
+  sig { params(io: T.any(::IO, ::StringIO)).void }
+  def print_debug(io: T.unsafe(nil)); end
+end
+
+# source://rbi//lib/rbi/version.rb#5
+RBI::VERSION = T.let(T.unsafe(nil), String)
+
+# Visibility
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/model.rb#916
+class RBI::Visibility < ::RBI::NodeWithComments
+  abstract!
+
+  # source://rbi//lib/rbi/model.rb#926
+  sig { params(visibility: ::Symbol, loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
+  def initialize(visibility, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  # source://rbi//lib/rbi/model.rb#932
+  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://rbi//lib/rbi/model.rb#949
+  sig { returns(T::Boolean) }
+  def private?; end
+
+  # source://rbi//lib/rbi/model.rb#944
+  sig { returns(T::Boolean) }
+  def protected?; end
+
+  # source://rbi//lib/rbi/model.rb#939
+  sig { returns(T::Boolean) }
+  def public?; end
+
+  # source://rbi//lib/rbi/model.rb#923
+  sig { returns(::Symbol) }
+  def visibility; end
+end
+
+# source://rbi//lib/rbi/rewriters/nest_non_public_members.rb#52
+class RBI::VisibilityGroup < ::RBI::Tree
+  # source://rbi//lib/rbi/rewriters/nest_non_public_members.rb#59
+  sig { params(visibility: ::RBI::Visibility).void }
+  def initialize(visibility); end
+
+  # source://rbi//lib/rbi/rewriters/nest_non_public_members.rb#56
+  sig { returns(::RBI::Visibility) }
+  def visibility; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/visitor.rb#7
+class RBI::Visitor
+  abstract!
+
+  # source://rbi//lib/rbi/visitor.rb#14
+  sig { params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#108
+  sig { params(nodes: T::Array[::RBI::Node]).void }
+  def visit_all(nodes); end
+
+  # source://rbi//lib/rbi/visitor.rb#113
+  sig { params(file: ::RBI::File).void }
+  def visit_file(file); end
+
+  private
+
+  # source://rbi//lib/rbi/visitor.rb#195
+  sig { params(node: ::RBI::Arg).void }
+  def visit_arg(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#144
+  sig { params(node: ::RBI::AttrAccessor).void }
+  def visit_attr_accessor(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#147
+  sig { params(node: ::RBI::AttrReader).void }
+  def visit_attr_reader(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#150
+  sig { params(node: ::RBI::AttrWriter).void }
+  def visit_attr_writer(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#123
+  sig { params(node: ::RBI::BlankLine).void }
+  def visit_blank_line(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#174
+  sig { params(node: ::RBI::BlockParam).void }
+  def visit_block_param(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#129
+  sig { params(node: ::RBI::Class).void }
+  def visit_class(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#120
+  sig { params(node: ::RBI::Comment).void }
+  def visit_comment(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#240
+  sig { params(node: ::RBI::ConflictTree).void }
+  def visit_conflict_tree(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#141
+  sig { params(node: ::RBI::Const).void }
+  def visit_const(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#180
+  sig { params(node: ::RBI::Extend).void }
+  def visit_extend(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#234
+  sig { params(node: ::RBI::Group).void }
+  def visit_group(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#222
+  sig { params(node: ::RBI::Helper).void }
+  def visit_helper(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#177
+  sig { params(node: ::RBI::Include).void }
+  def visit_include(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#198
+  sig { params(node: ::RBI::KwArg).void }
+  def visit_kw_arg(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#168
+  sig { params(node: ::RBI::KwOptParam).void }
+  def visit_kw_opt_param(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#165
+  sig { params(node: ::RBI::KwParam).void }
+  def visit_kw_param(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#171
+  sig { params(node: ::RBI::KwRestParam).void }
+  def visit_kw_rest_param(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#153
+  sig { params(node: ::RBI::Method).void }
+  def visit_method(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#228
+  sig { params(node: ::RBI::MixesInClassMethods).void }
+  def visit_mixes_in_class_methods(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#126
+  sig { params(node: ::RBI::Module).void }
+  def visit_module(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#159
+  sig { params(node: ::RBI::OptParam).void }
+  def visit_opt_param(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#189
+  sig { params(node: ::RBI::Private).void }
+  def visit_private(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#186
+  sig { params(node: ::RBI::Protected).void }
+  def visit_protected(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#183
+  sig { params(node: ::RBI::Public).void }
+  def visit_public(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#156
+  sig { params(node: ::RBI::ReqParam).void }
+  def visit_req_param(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#231
+  sig { params(node: ::RBI::RequiresAncestor).void }
+  def visit_requires_ancestor(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#162
+  sig { params(node: ::RBI::RestParam).void }
+  def visit_rest_param(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#243
+  sig { params(node: ::RBI::ScopeConflict).void }
+  def visit_scope_conflict(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#192
+  sig { params(node: ::RBI::Send).void }
+  def visit_send(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#201
+  sig { params(node: ::RBI::Sig).void }
+  def visit_sig(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#204
+  sig { params(node: ::RBI::SigParam).void }
+  def visit_sig_param(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#132
+  sig { params(node: ::RBI::SingletonClass).void }
+  def visit_singleton_class(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#135
+  sig { params(node: ::RBI::Struct).void }
+  def visit_struct(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#216
+  sig { params(node: ::RBI::TEnum).void }
+  def visit_tenum(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#219
+  sig { params(node: ::RBI::TEnumBlock).void }
+  def visit_tenum_block(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#138
+  sig { params(node: ::RBI::Tree).void }
+  def visit_tree(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#207
+  sig { params(node: ::RBI::TStruct).void }
+  def visit_tstruct(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#210
+  sig { params(node: ::RBI::TStructConst).void }
+  def visit_tstruct_const(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#213
+  sig { params(node: ::RBI::TStructProp).void }
+  def visit_tstruct_prop(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#225
+  sig { params(node: ::RBI::TypeMember).void }
+  def visit_type_member(node); end
+
+  # source://rbi//lib/rbi/visitor.rb#237
+  sig { params(node: ::RBI::VisibilityGroup).void }
+  def visit_visibility_group(node); end
+end
+
+# source://rbi//lib/rbi/visitor.rb#5
+class RBI::VisitorError < ::RBI::Error; end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rbs@3.6.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rbs@3.6.1.rbi
new file mode 100644
index 0000000000000..9a63519c9d8e5
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/rbs@3.6.1.rbi
@@ -0,0 +1,6857 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rbs` gem.
+# Please instead update this file by running `bin/tapioca gem rbs`.
+
+
+# source://rbs//lib/rbs/namespace.rb#120
+module Kernel
+  # source://rbs//lib/rbs/namespace.rb#121
+  def Namespace(name); end
+
+  # source://rbs//lib/rbs/type_name.rb#93
+  def TypeName(string); end
+end
+
+# source://rbs//lib/rbs/version.rb#3
+module RBS
+  class << self
+    # source://rbs//lib/rbs.rb#68
+    def logger; end
+
+    # Returns the value of attribute logger_level.
+    #
+    # source://rbs//lib/rbs.rb#65
+    def logger_level; end
+
+    # source://rbs//lib/rbs.rb#77
+    def logger_level=(level); end
+
+    # Returns the value of attribute logger_output.
+    #
+    # source://rbs//lib/rbs.rb#66
+    def logger_output; end
+
+    # source://rbs//lib/rbs.rb#72
+    def logger_output=(val); end
+
+    # source://rbs//lib/rbs.rb#82
+    def print_warning; end
+  end
+end
+
+# source://rbs//lib/rbs/ast/type_param.rb#4
+module RBS::AST; end
+
+# source://rbs//lib/rbs/ast/annotation.rb#5
+class RBS::AST::Annotation
+  # @return [Annotation] a new instance of Annotation
+  #
+  # source://rbs//lib/rbs/ast/annotation.rb#9
+  def initialize(string:, location:); end
+
+  # source://rbs//lib/rbs/ast/annotation.rb#14
+  def ==(other); end
+
+  # source://rbs//lib/rbs/ast/annotation.rb#14
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/annotation.rb#20
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/annotation.rb#7
+  def location; end
+
+  # Returns the value of attribute string.
+  #
+  # source://rbs//lib/rbs/ast/annotation.rb#6
+  def string; end
+
+  # source://rbs//lib/rbs/ast/annotation.rb#24
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/comment.rb#5
+class RBS::AST::Comment
+  # @return [Comment] a new instance of Comment
+  #
+  # source://rbs//lib/rbs/ast/comment.rb#9
+  def initialize(string:, location:); end
+
+  # source://rbs//lib/rbs/ast/comment.rb#14
+  def ==(other); end
+
+  # source://rbs//lib/rbs/ast/comment.rb#14
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/comment.rb#20
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/comment.rb#7
+  def location; end
+
+  # Returns the value of attribute string.
+  #
+  # source://rbs//lib/rbs/ast/comment.rb#6
+  def string; end
+
+  # source://rbs//lib/rbs/ast/comment.rb#24
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/declarations.rb#5
+module RBS::AST::Declarations; end
+
+# source://rbs//lib/rbs/ast/declarations.rb#419
+class RBS::AST::Declarations::AliasDecl < ::RBS::AST::Declarations::Base
+  # @return [AliasDecl] a new instance of AliasDecl
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#422
+  def initialize(new_name:, old_name:, location:, comment:); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#429
+  def ==(other); end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#420
+  def comment; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#429
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#437
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#420
+  def location; end
+
+  # Returns the value of attribute new_name.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#420
+  def new_name; end
+
+  # Returns the value of attribute old_name.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#420
+  def old_name; end
+end
+
+# source://rbs//lib/rbs/ast/declarations.rb#6
+class RBS::AST::Declarations::Base; end
+
+# source://rbs//lib/rbs/ast/declarations.rb#55
+class RBS::AST::Declarations::Class < ::RBS::AST::Declarations::Base
+  include ::RBS::AST::Declarations::NestedDeclarationHelper
+  include ::RBS::AST::Declarations::MixinHelper
+
+  # @return [Class] a new instance of Class
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#97
+  def initialize(name:, type_params:, super_class:, members:, annotations:, location:, comment:); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#119
+  def ==(other); end
+
+  # Returns the value of attribute annotations.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#93
+  def annotations; end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#95
+  def comment; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#119
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#129
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#94
+  def location; end
+
+  # Returns the value of attribute members.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#91
+  def members; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#89
+  def name; end
+
+  # Returns the value of attribute super_class.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#92
+  def super_class; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#133
+  def to_json(state = T.unsafe(nil)); end
+
+  # Returns the value of attribute type_params.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#90
+  def type_params; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#107
+  def update(name: T.unsafe(nil), type_params: T.unsafe(nil), super_class: T.unsafe(nil), members: T.unsafe(nil), annotations: T.unsafe(nil), location: T.unsafe(nil), comment: T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/declarations.rb#56
+class RBS::AST::Declarations::Class::Super
+  # @return [Super] a new instance of Super
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#61
+  def initialize(name:, args:, location:); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#67
+  def ==(other); end
+
+  # Returns the value of attribute args.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#58
+  def args; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#67
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#73
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#59
+  def location; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#57
+  def name; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#77
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/declarations.rb#442
+class RBS::AST::Declarations::ClassAlias < ::RBS::AST::Declarations::AliasDecl
+  # source://rbs//lib/rbs/ast/declarations.rb#443
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/declarations.rb#347
+class RBS::AST::Declarations::Constant < ::RBS::AST::Declarations::Base
+  # @return [Constant] a new instance of Constant
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#353
+  def initialize(name:, type:, location:, comment:); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#360
+  def ==(other); end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#351
+  def comment; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#360
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#368
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#350
+  def location; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#348
+  def name; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#372
+  def to_json(state = T.unsafe(nil)); end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#349
+  def type; end
+end
+
+# source://rbs//lib/rbs/ast/declarations.rb#383
+class RBS::AST::Declarations::Global < ::RBS::AST::Declarations::Base
+  # @return [Global] a new instance of Global
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#389
+  def initialize(name:, type:, location:, comment:); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#396
+  def ==(other); end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#387
+  def comment; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#396
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#404
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#386
+  def location; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#384
+  def name; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#408
+  def to_json(state = T.unsafe(nil)); end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#385
+  def type; end
+end
+
+# source://rbs//lib/rbs/ast/declarations.rb#248
+class RBS::AST::Declarations::Interface < ::RBS::AST::Declarations::Base
+  include ::RBS::AST::Declarations::MixinHelper
+
+  # @return [Interface] a new instance of Interface
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#258
+  def initialize(name:, type_params:, members:, annotations:, location:, comment:); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#278
+  def ==(other); end
+
+  # Returns the value of attribute annotations.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#252
+  def annotations; end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#254
+  def comment; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#278
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#287
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#253
+  def location; end
+
+  # Returns the value of attribute members.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#251
+  def members; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#249
+  def name; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#291
+  def to_json(state = T.unsafe(nil)); end
+
+  # Returns the value of attribute type_params.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#250
+  def type_params; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#267
+  def update(name: T.unsafe(nil), type_params: T.unsafe(nil), members: T.unsafe(nil), annotations: T.unsafe(nil), location: T.unsafe(nil), comment: T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/declarations.rb#35
+module RBS::AST::Declarations::MixinHelper
+  # source://rbs//lib/rbs/ast/declarations.rb#36
+  def each_mixin(&block); end
+end
+
+# source://rbs//lib/rbs/ast/declarations.rb#147
+class RBS::AST::Declarations::Module < ::RBS::AST::Declarations::Base
+  include ::RBS::AST::Declarations::NestedDeclarationHelper
+  include ::RBS::AST::Declarations::MixinHelper
+
+  # @return [Module] a new instance of Module
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#197
+  def initialize(name:, type_params:, members:, self_types:, annotations:, location:, comment:); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#220
+  def ==(other); end
+
+  # Returns the value of attribute annotations.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#193
+  def annotations; end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#195
+  def comment; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#220
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#230
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#192
+  def location; end
+
+  # Returns the value of attribute members.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#191
+  def members; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#189
+  def name; end
+
+  # Returns the value of attribute self_types.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#194
+  def self_types; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#234
+  def to_json(state = T.unsafe(nil)); end
+
+  # Returns the value of attribute type_params.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#190
+  def type_params; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#207
+  def update(name: T.unsafe(nil), type_params: T.unsafe(nil), members: T.unsafe(nil), self_types: T.unsafe(nil), annotations: T.unsafe(nil), location: T.unsafe(nil), comment: T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/declarations.rb#148
+class RBS::AST::Declarations::Module::Self
+  # @return [Self] a new instance of Self
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#153
+  def initialize(name:, args:, location:); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#159
+  def ==(other); end
+
+  # Returns the value of attribute args.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#150
+  def args; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#159
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#165
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#151
+  def location; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#149
+  def name; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#169
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#177
+  def to_s; end
+end
+
+# source://rbs//lib/rbs/ast/declarations.rb#454
+class RBS::AST::Declarations::ModuleAlias < ::RBS::AST::Declarations::AliasDecl
+  # source://rbs//lib/rbs/ast/declarations.rb#455
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/declarations.rb#9
+module RBS::AST::Declarations::NestedDeclarationHelper
+  # source://rbs//lib/rbs/ast/declarations.rb#22
+  def each_decl; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#10
+  def each_member; end
+end
+
+# source://rbs//lib/rbs/ast/declarations.rb#304
+class RBS::AST::Declarations::TypeAlias < ::RBS::AST::Declarations::Base
+  # @return [TypeAlias] a new instance of TypeAlias
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#312
+  def initialize(name:, type_params:, type:, annotations:, location:, comment:); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#321
+  def ==(other); end
+
+  # Returns the value of attribute annotations.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#308
+  def annotations; end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#310
+  def comment; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#321
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#330
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#309
+  def location; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#305
+  def name; end
+
+  # source://rbs//lib/rbs/ast/declarations.rb#334
+  def to_json(state = T.unsafe(nil)); end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#307
+  def type; end
+
+  # Returns the value of attribute type_params.
+  #
+  # source://rbs//lib/rbs/ast/declarations.rb#306
+  def type_params; end
+end
+
+# source://rbs//lib/rbs/ast/directives.rb#5
+module RBS::AST::Directives; end
+
+# source://rbs//lib/rbs/ast/directives.rb#6
+class RBS::AST::Directives::Base; end
+
+# source://rbs//lib/rbs/ast/directives.rb#9
+class RBS::AST::Directives::Use < ::RBS::AST::Directives::Base
+  # @return [Use] a new instance of Use
+  #
+  # source://rbs//lib/rbs/ast/directives.rb#31
+  def initialize(clauses:, location:); end
+
+  # Returns the value of attribute clauses.
+  #
+  # source://rbs//lib/rbs/ast/directives.rb#29
+  def clauses; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/directives.rb#29
+  def location; end
+end
+
+# source://rbs//lib/rbs/ast/directives.rb#10
+class RBS::AST::Directives::Use::SingleClause
+  # @return [SingleClause] a new instance of SingleClause
+  #
+  # source://rbs//lib/rbs/ast/directives.rb#13
+  def initialize(type_name:, new_name:, location:); end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/directives.rb#11
+  def location; end
+
+  # Returns the value of attribute new_name.
+  #
+  # source://rbs//lib/rbs/ast/directives.rb#11
+  def new_name; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/ast/directives.rb#11
+  def type_name; end
+end
+
+# source://rbs//lib/rbs/ast/directives.rb#20
+class RBS::AST::Directives::Use::WildcardClause
+  # @return [WildcardClause] a new instance of WildcardClause
+  #
+  # source://rbs//lib/rbs/ast/directives.rb#23
+  def initialize(namespace:, location:); end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/directives.rb#21
+  def location; end
+
+  # Returns the value of attribute namespace.
+  #
+  # source://rbs//lib/rbs/ast/directives.rb#21
+  def namespace; end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#5
+module RBS::AST::Members; end
+
+# source://rbs//lib/rbs/ast/members.rb#397
+class RBS::AST::Members::Alias < ::RBS::AST::Members::Base
+  # @return [Alias] a new instance of Alias
+  #
+  # source://rbs//lib/rbs/ast/members.rb#405
+  def initialize(new_name:, old_name:, kind:, annotations:, location:, comment:); end
+
+  # source://rbs//lib/rbs/ast/members.rb#414
+  def ==(other); end
+
+  # Returns the value of attribute annotations.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#401
+  def annotations; end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#403
+  def comment; end
+
+  # source://rbs//lib/rbs/ast/members.rb#414
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/members.rb#423
+  def hash; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/ast/members.rb#439
+  def instance?; end
+
+  # Returns the value of attribute kind.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#400
+  def kind; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#402
+  def location; end
+
+  # Returns the value of attribute new_name.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#398
+  def new_name; end
+
+  # Returns the value of attribute old_name.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#399
+  def old_name; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/ast/members.rb#443
+  def singleton?; end
+
+  # source://rbs//lib/rbs/ast/members.rb#427
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#327
+class RBS::AST::Members::AttrAccessor < ::RBS::AST::Members::Base
+  include ::RBS::AST::Members::Attribute
+
+  # source://rbs//lib/rbs/ast/members.rb#330
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#309
+class RBS::AST::Members::AttrReader < ::RBS::AST::Members::Base
+  include ::RBS::AST::Members::Attribute
+
+  # source://rbs//lib/rbs/ast/members.rb#312
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#345
+class RBS::AST::Members::AttrWriter < ::RBS::AST::Members::Base
+  include ::RBS::AST::Members::Attribute
+
+  # source://rbs//lib/rbs/ast/members.rb#348
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#258
+module RBS::AST::Members::Attribute
+  # source://rbs//lib/rbs/ast/members.rb#268
+  def initialize(name:, type:, ivar_name:, kind:, annotations:, location:, comment:, visibility: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/ast/members.rb#279
+  def ==(other); end
+
+  # Returns the value of attribute annotations.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#263
+  def annotations; end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#265
+  def comment; end
+
+  # source://rbs//lib/rbs/ast/members.rb#279
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/members.rb#290
+  def hash; end
+
+  # Returns the value of attribute ivar_name.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#262
+  def ivar_name; end
+
+  # Returns the value of attribute kind.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#261
+  def kind; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#264
+  def location; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#259
+  def name; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#260
+  def type; end
+
+  # source://rbs//lib/rbs/ast/members.rb#294
+  def update(name: T.unsafe(nil), type: T.unsafe(nil), ivar_name: T.unsafe(nil), kind: T.unsafe(nil), annotations: T.unsafe(nil), location: T.unsafe(nil), comment: T.unsafe(nil), visibility: T.unsafe(nil)); end
+
+  # Returns the value of attribute visibility.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#266
+  def visibility; end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#6
+class RBS::AST::Members::Base; end
+
+# source://rbs//lib/rbs/ast/members.rb#157
+class RBS::AST::Members::ClassInstanceVariable < ::RBS::AST::Members::Base
+  include ::RBS::AST::Members::Var
+
+  # source://rbs//lib/rbs/ast/members.rb#160
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#171
+class RBS::AST::Members::ClassVariable < ::RBS::AST::Members::Base
+  include ::RBS::AST::Members::Var
+
+  # source://rbs//lib/rbs/ast/members.rb#174
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#228
+class RBS::AST::Members::Extend < ::RBS::AST::Members::Base
+  include ::RBS::AST::Members::Mixin
+
+  # source://rbs//lib/rbs/ast/members.rb#231
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#213
+class RBS::AST::Members::Include < ::RBS::AST::Members::Base
+  include ::RBS::AST::Members::Mixin
+
+  # source://rbs//lib/rbs/ast/members.rb#216
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#143
+class RBS::AST::Members::InstanceVariable < ::RBS::AST::Members::Base
+  include ::RBS::AST::Members::Var
+
+  # source://rbs//lib/rbs/ast/members.rb#146
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#363
+module RBS::AST::Members::LocationOnly
+  # source://rbs//lib/rbs/ast/members.rb#366
+  def initialize(location:); end
+
+  # source://rbs//lib/rbs/ast/members.rb#370
+  def ==(other); end
+
+  # source://rbs//lib/rbs/ast/members.rb#370
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/members.rb#376
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#364
+  def location; end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#9
+class RBS::AST::Members::MethodDefinition < ::RBS::AST::Members::Base
+  # @return [MethodDefinition] a new instance of MethodDefinition
+  #
+  # source://rbs//lib/rbs/ast/members.rb#53
+  def initialize(name:, kind:, overloads:, annotations:, location:, comment:, overloading:, visibility:); end
+
+  # source://rbs//lib/rbs/ast/members.rb#64
+  def ==(other); end
+
+  # Returns the value of attribute annotations.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#47
+  def annotations; end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#49
+  def comment; end
+
+  # source://rbs//lib/rbs/ast/members.rb#64
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/members.rb#75
+  def hash; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/ast/members.rb#79
+  def instance?; end
+
+  # Returns the value of attribute kind.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#45
+  def kind; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#48
+  def location; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#44
+  def name; end
+
+  # Returns the value of attribute overloading.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#50
+  def overloading; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/ast/members.rb#87
+  def overloading?; end
+
+  # Returns the value of attribute overloads.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#46
+  def overloads; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/ast/members.rb#83
+  def singleton?; end
+
+  # source://rbs//lib/rbs/ast/members.rb#104
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/ast/members.rb#91
+  def update(name: T.unsafe(nil), kind: T.unsafe(nil), overloads: T.unsafe(nil), annotations: T.unsafe(nil), location: T.unsafe(nil), comment: T.unsafe(nil), overloading: T.unsafe(nil), visibility: T.unsafe(nil)); end
+
+  # Returns the value of attribute visibility.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#51
+  def visibility; end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#10
+class RBS::AST::Members::MethodDefinition::Overload
+  # @return [Overload] a new instance of Overload
+  #
+  # source://rbs//lib/rbs/ast/members.rb#13
+  def initialize(method_type:, annotations:); end
+
+  # source://rbs//lib/rbs/ast/members.rb#18
+  def ==(other); end
+
+  # Returns the value of attribute annotations.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#11
+  def annotations; end
+
+  # source://rbs//lib/rbs/ast/members.rb#18
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/members.rb#22
+  def hash; end
+
+  # Returns the value of attribute method_type.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#11
+  def method_type; end
+
+  # source://rbs//lib/rbs/ast/members.rb#32
+  def sub(subst); end
+
+  # source://rbs//lib/rbs/ast/members.rb#36
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/ast/members.rb#28
+  def update(annotations: T.unsafe(nil), method_type: T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#185
+module RBS::AST::Members::Mixin
+  # source://rbs//lib/rbs/ast/members.rb#192
+  def initialize(name:, args:, annotations:, location:, comment:); end
+
+  # source://rbs//lib/rbs/ast/members.rb#200
+  def ==(other); end
+
+  # Returns the value of attribute annotations.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#188
+  def annotations; end
+
+  # Returns the value of attribute args.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#187
+  def args; end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#190
+  def comment; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/ast/members.rb#204
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/members.rb#208
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#189
+  def location; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#186
+  def name; end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#243
+class RBS::AST::Members::Prepend < ::RBS::AST::Members::Base
+  include ::RBS::AST::Members::Mixin
+
+  # source://rbs//lib/rbs/ast/members.rb#246
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#389
+class RBS::AST::Members::Private < ::RBS::AST::Members::Base
+  include ::RBS::AST::Members::LocationOnly
+
+  # source://rbs//lib/rbs/ast/members.rb#392
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#381
+class RBS::AST::Members::Public < ::RBS::AST::Members::Base
+  include ::RBS::AST::Members::LocationOnly
+
+  # source://rbs//lib/rbs/ast/members.rb#384
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/ast/members.rb#119
+module RBS::AST::Members::Var
+  # source://rbs//lib/rbs/ast/members.rb#125
+  def initialize(name:, type:, location:, comment:); end
+
+  # source://rbs//lib/rbs/ast/members.rb#132
+  def ==(other); end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#123
+  def comment; end
+
+  # source://rbs//lib/rbs/ast/members.rb#132
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/members.rb#138
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#122
+  def location; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#120
+  def name; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/ast/members.rb#121
+  def type; end
+end
+
+# source://rbs//lib/rbs/ast/type_param.rb#5
+class RBS::AST::TypeParam
+  # @return [TypeParam] a new instance of TypeParam
+  #
+  # source://rbs//lib/rbs/ast/type_param.rb#8
+  def initialize(name:, variance:, upper_bound:, location:, default_type: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/ast/type_param.rb#33
+  def ==(other); end
+
+  # Returns the value of attribute default_type.
+  #
+  # source://rbs//lib/rbs/ast/type_param.rb#6
+  def default_type; end
+
+  # source://rbs//lib/rbs/ast/type_param.rb#33
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/ast/type_param.rb#44
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/ast/type_param.rb#6
+  def location; end
+
+  # source://rbs//lib/rbs/ast/type_param.rb#69
+  def map_type(&block); end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/ast/type_param.rb#6
+  def name; end
+
+  # source://rbs//lib/rbs/ast/type_param.rb#59
+  def rename(name); end
+
+  # source://rbs//lib/rbs/ast/type_param.rb#48
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/ast/type_param.rb#127
+  def to_s; end
+
+  # source://rbs//lib/rbs/ast/type_param.rb#24
+  def unchecked!(value = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/ast/type_param.rb#29
+  def unchecked?; end
+
+  # source://rbs//lib/rbs/ast/type_param.rb#17
+  def upper_bound; end
+
+  # Returns the value of attribute upper_bound_type.
+  #
+  # source://rbs//lib/rbs/ast/type_param.rb#6
+  def upper_bound_type; end
+
+  # Returns the value of attribute variance.
+  #
+  # source://rbs//lib/rbs/ast/type_param.rb#6
+  def variance; end
+
+  class << self
+    # source://rbs//lib/rbs/ast/type_param.rb#156
+    def application(params, args); end
+
+    # source://rbs//lib/rbs/ast/type_param.rb#188
+    def normalize_args(params, args); end
+
+    # source://rbs//lib/rbs/ast/type_param.rb#109
+    def rename(params, new_names:); end
+
+    # source://rbs//lib/rbs/ast/type_param.rb#87
+    def resolve_variables(params); end
+
+    # source://rbs//lib/rbs/ast/type_param.rb#97
+    def subst_var(vars, type); end
+
+    # source://rbs//lib/rbs/ast/type_param.rb#209
+    def validate(type_params); end
+  end
+end
+
+# The Visitor class implements the Visitor pattern for traversing the RBS Abstract Syntax Tree (AST).
+#
+# It provides methods to visit each type of node in the AST, allowing for custom processing of each node type.
+#
+# This class is designed to be subclassed, with specific visit methods overridden to implement custom behavior for
+# different node types.
+#
+# Example usage:
+#
+# ~~~rb
+# class MyVisitor < RBS::AST::Visitor
+#   def visit_declaration_class(node)
+#     puts "Visiting class: #{node.name}"
+#
+#     super # call `super` to run the default visiting behavior
+#   end
+# end
+#
+# visitor = MyVisitor.new
+# visitor.visit(ast_node)
+# ~~~
+#
+# source://rbs//lib/rbs/ast/visitor.rb#26
+class RBS::AST::Visitor
+  # source://rbs//lib/rbs/ast/visitor.rb#27
+  def visit(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#70
+  def visit_all(nodes); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#79
+  def visit_declaration_class(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#87
+  def visit_declaration_constant(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#76
+  def visit_declaration_global(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#93
+  def visit_declaration_interface(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#83
+  def visit_declaration_module(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#90
+  def visit_declaration_type_alias(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#97
+  def visit_member_alias(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#124
+  def visit_member_attr_accessor(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#118
+  def visit_member_attr_reader(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#121
+  def visit_member_attr_writer(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#100
+  def visit_member_class_instance_variable(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#103
+  def visit_member_class_variable(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#133
+  def visit_member_extend(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#127
+  def visit_member_include(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#106
+  def visit_member_instance_variable(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#115
+  def visit_member_method_definition(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#130
+  def visit_member_prepend(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#109
+  def visit_member_private(node); end
+
+  # source://rbs//lib/rbs/ast/visitor.rb#112
+  def visit_member_public(node); end
+end
+
+# source://rbs//lib/rbs/ancestor_graph.rb#4
+class RBS::AncestorGraph
+  # @return [AncestorGraph] a new instance of AncestorGraph
+  #
+  # source://rbs//lib/rbs/ancestor_graph.rb#13
+  def initialize(env:, ancestor_builder: T.unsafe(nil)); end
+
+  # Returns the value of attribute ancestor_builder.
+  #
+  # source://rbs//lib/rbs/ancestor_graph.rb#9
+  def ancestor_builder; end
+
+  # source://rbs//lib/rbs/ancestor_graph.rb#19
+  def build; end
+
+  # source://rbs//lib/rbs/ancestor_graph.rb#32
+  def build_ancestors(node, ancestors); end
+
+  # Returns the value of attribute children.
+  #
+  # source://rbs//lib/rbs/ancestor_graph.rb#11
+  def children; end
+
+  # source://rbs//lib/rbs/ancestor_graph.rb#64
+  def each_ancestor(node, yielded: T.unsafe(nil), &block); end
+
+  # source://rbs//lib/rbs/ancestor_graph.rb#56
+  def each_child(node, &block); end
+
+  # source://rbs//lib/rbs/ancestor_graph.rb#78
+  def each_descendant(node, yielded: T.unsafe(nil), &block); end
+
+  # source://rbs//lib/rbs/ancestor_graph.rb#48
+  def each_parent(node, &block); end
+
+  # Returns the value of attribute env.
+  #
+  # source://rbs//lib/rbs/ancestor_graph.rb#8
+  def env; end
+
+  # Returns the value of attribute parents.
+  #
+  # source://rbs//lib/rbs/ancestor_graph.rb#10
+  def parents; end
+
+  # source://rbs//lib/rbs/ancestor_graph.rb#43
+  def register(parent:, child:); end
+end
+
+# source://rbs//lib/rbs/ancestor_graph.rb#5
+class RBS::AncestorGraph::InstanceNode < ::Struct
+  def type_name; end
+  def type_name=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rbs//lib/rbs/ancestor_graph.rb#6
+class RBS::AncestorGraph::SingletonNode < ::Struct
+  def type_name; end
+  def type_name=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rbs//lib/rbs/errors.rb#19
+class RBS::BaseError < ::StandardError; end
+
+# source://rbs//lib/rbs/buffer.rb#4
+class RBS::Buffer
+  # @return [Buffer] a new instance of Buffer
+  #
+  # source://rbs//lib/rbs/buffer.rb#8
+  def initialize(name:, content:); end
+
+  # Returns the value of attribute content.
+  #
+  # source://rbs//lib/rbs/buffer.rb#6
+  def content; end
+
+  # source://rbs//lib/rbs/buffer.rb#63
+  def inspect; end
+
+  # source://rbs//lib/rbs/buffer.rb#59
+  def last_position; end
+
+  # source://rbs//lib/rbs/buffer.rb#13
+  def lines; end
+
+  # source://rbs//lib/rbs/buffer.rb#49
+  def loc_to_pos(loc); end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/buffer.rb#5
+  def name; end
+
+  # source://rbs//lib/rbs/buffer.rb#37
+  def pos_to_loc(pos); end
+
+  # source://rbs//lib/rbs/buffer.rb#17
+  def ranges; end
+end
+
+# source://rbs//lib/rbs/builtin_names.rb#4
+module RBS::BuiltinNames; end
+
+# source://rbs//lib/rbs/builtin_names.rb#45
+RBS::BuiltinNames::Array = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#37
+RBS::BuiltinNames::BasicObject = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#43
+RBS::BuiltinNames::Class = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#41
+RBS::BuiltinNames::Comparable = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#42
+RBS::BuiltinNames::Enumerable = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#48
+RBS::BuiltinNames::Enumerator = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#55
+RBS::BuiltinNames::FalseClass = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#52
+RBS::BuiltinNames::Float = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#46
+RBS::BuiltinNames::Hash = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#51
+RBS::BuiltinNames::Integer = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#39
+RBS::BuiltinNames::Kernel = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#44
+RBS::BuiltinNames::Module = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#5
+class RBS::BuiltinNames::Name
+  # @return [Name] a new instance of Name
+  #
+  # source://rbs//lib/rbs/builtin_names.rb#8
+  def initialize(name:); end
+
+  # source://rbs//lib/rbs/builtin_names.rb#16
+  def instance_type(*args); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/builtin_names.rb#20
+  def instance_type?(type); end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/builtin_names.rb#6
+  def name; end
+
+  # source://rbs//lib/rbs/builtin_names.rb#24
+  def singleton_type; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/builtin_names.rb#28
+  def singleton_type?(type); end
+
+  # source://rbs//lib/rbs/builtin_names.rb#12
+  def to_s; end
+
+  class << self
+    # source://rbs//lib/rbs/builtin_names.rb#32
+    def define(name, namespace: T.unsafe(nil)); end
+  end
+end
+
+# source://rbs//lib/rbs/builtin_names.rb#56
+RBS::BuiltinNames::Numeric = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#38
+RBS::BuiltinNames::Object = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#47
+RBS::BuiltinNames::Range = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#53
+RBS::BuiltinNames::Regexp = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#49
+RBS::BuiltinNames::Set = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#40
+RBS::BuiltinNames::String = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#50
+RBS::BuiltinNames::Symbol = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/builtin_names.rb#54
+RBS::BuiltinNames::TrueClass = T.let(T.unsafe(nil), RBS::BuiltinNames::Name)
+
+# source://rbs//lib/rbs/cli/colored_io.rb#4
+class RBS::CLI; end
+
+# source://rbs//lib/rbs/cli/colored_io.rb#5
+class RBS::CLI::ColoredIO
+  # @return [ColoredIO] a new instance of ColoredIO
+  #
+  # source://rbs//lib/rbs/cli/colored_io.rb#8
+  def initialize(stdout:); end
+
+  # source://rbs//lib/rbs/cli/colored_io.rb#28
+  def puts(*_arg0, **_arg1, &_arg2); end
+
+  # source://rbs//lib/rbs/cli/colored_io.rb#20
+  def puts_green(string); end
+
+  # source://rbs//lib/rbs/cli/colored_io.rb#12
+  def puts_red(string); end
+
+  # Returns the value of attribute stdout.
+  #
+  # source://rbs//lib/rbs/cli/colored_io.rb#6
+  def stdout; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/cli/colored_io.rb#43
+  def are_colors_disabled?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/cli/colored_io.rb#39
+  def are_colors_supported?; end
+
+  # https://github.com/rubygems/rubygems/blob/ed65279100234a17d65d71fe26de5083984ac5b8/bundler/lib/bundler/vendor/thor/lib/thor/shell/color.rb#L99-L109
+  #
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/cli/colored_io.rb#35
+  def can_display_colors?; end
+end
+
+# source://rbs//lib/rbs/collection/sources/base.rb#4
+module RBS::Collection; end
+
+# source://rbs//lib/rbs/collection/cleaner.rb#5
+class RBS::Collection::Cleaner
+  # @return [Cleaner] a new instance of Cleaner
+  #
+  # source://rbs//lib/rbs/collection/cleaner.rb#8
+  def initialize(lockfile_path:); end
+
+  # source://rbs//lib/rbs/collection/cleaner.rb#12
+  def clean; end
+
+  # Returns the value of attribute lock.
+  #
+  # source://rbs//lib/rbs/collection/cleaner.rb#6
+  def lock; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/collection/cleaner.rb#30
+  def needed?(gem_name, version); end
+end
+
+# This class represent the configuration file.
+#
+# source://rbs//lib/rbs/collection/config.rb#7
+class RBS::Collection::Config
+  # @return [Config] a new instance of Config
+  #
+  # source://rbs//lib/rbs/collection/config.rb#49
+  def initialize(data, config_path:); end
+
+  # Returns the value of attribute config_path.
+  #
+  # source://rbs//lib/rbs/collection/config.rb#19
+  def config_path; end
+
+  # Returns the value of attribute data.
+  #
+  # source://rbs//lib/rbs/collection/config.rb#19
+  def data; end
+
+  # source://rbs//lib/rbs/collection/config.rb#54
+  def gem(gem_name); end
+
+  # source://rbs//lib/rbs/collection/config.rb#74
+  def gems; end
+
+  # source://rbs//lib/rbs/collection/config.rb#58
+  def repo_path; end
+
+  # source://rbs//lib/rbs/collection/config.rb#62
+  def repo_path_data; end
+
+  # source://rbs//lib/rbs/collection/config.rb#66
+  def sources; end
+
+  class << self
+    # source://rbs//lib/rbs/collection/config.rb#21
+    def find_config_path; end
+
+    # source://rbs//lib/rbs/collection/config.rb#41
+    def from_path(path); end
+
+    # Generate a rbs lockfile from Gemfile.lock to `config_path`.
+    # If `with_lockfile` is true, it respects existing rbs lockfile.
+    #
+    # source://rbs//lib/rbs/collection/config.rb#34
+    def generate_lockfile(config_path:, definition:, with_lockfile: T.unsafe(nil)); end
+
+    # source://rbs//lib/rbs/collection/config.rb#45
+    def to_lockfile_path(config_path); end
+  end
+end
+
+# source://rbs//lib/rbs/collection/config.rb#8
+class RBS::Collection::Config::CollectionNotAvailable < ::StandardError
+  # @return [CollectionNotAvailable] a new instance of CollectionNotAvailable
+  #
+  # source://rbs//lib/rbs/collection/config.rb#9
+  def initialize; end
+end
+
+# source://rbs//lib/rbs/collection/config/lockfile.rb#6
+class RBS::Collection::Config::Lockfile
+  # @return [Lockfile] a new instance of Lockfile
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile.rb#9
+  def initialize(lockfile_path:, path:, gemfile_lock_path:); end
+
+  # @raise [CollectionNotAvailable]
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile.rb#73
+  def check_rbs_availability!; end
+
+  # source://rbs//lib/rbs/collection/config/lockfile.rb#18
+  def fullpath; end
+
+  # source://rbs//lib/rbs/collection/config/lockfile.rb#22
+  def gemfile_lock_fullpath; end
+
+  # Returns the value of attribute gemfile_lock_path.
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile.rb#7
+  def gemfile_lock_path; end
+
+  # Returns the value of attribute gems.
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile.rb#7
+  def gems; end
+
+  # source://rbs//lib/rbs/collection/config/lockfile.rb#65
+  def library_data(lib); end
+
+  # Returns the value of attribute lockfile_dir.
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile.rb#7
+  def lockfile_dir; end
+
+  # Returns the value of attribute lockfile_path.
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile.rb#7
+  def lockfile_path; end
+
+  # Returns the value of attribute path.
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile.rb#7
+  def path; end
+
+  # Returns the value of attribute sources.
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile.rb#7
+  def sources; end
+
+  # source://rbs//lib/rbs/collection/config/lockfile.rb#28
+  def to_lockfile; end
+
+  class << self
+    # source://rbs//lib/rbs/collection/config/lockfile.rb#42
+    def from_lockfile(lockfile_path:, data:); end
+  end
+end
+
+# source://rbs//lib/rbs/collection/config/lockfile_generator.rb#6
+class RBS::Collection::Config::LockfileGenerator
+  # @return [LockfileGenerator] a new instance of LockfileGenerator
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#31
+  def initialize(config:, definition:, with_lockfile:); end
+
+  # Returns the value of attribute config.
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#23
+  def config; end
+
+  # Returns the value of attribute definition.
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#23
+  def definition; end
+
+  # Returns the value of attribute existing_lockfile.
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#23
+  def existing_lockfile; end
+
+  # Returns the value of attribute gem_entries.
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#23
+  def gem_entries; end
+
+  # Returns the value of attribute gem_hash.
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#23
+  def gem_hash; end
+
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#59
+  def generate; end
+
+  # Returns the value of attribute lockfile.
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#23
+  def lockfile; end
+
+  private
+
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#91
+  def assign_gem(name:, version:, skip: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#152
+  def assign_stdlib(name:, from_gem:); end
+
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#184
+  def find_best_version(version:, versions:); end
+
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#178
+  def find_source(name:); end
+
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#83
+  def validate_gemfile_lock_path!(lock:, gemfile_lock_path:); end
+
+  class << self
+    # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#25
+    def generate(config:, definition:, with_lockfile: T.unsafe(nil)); end
+  end
+end
+
+# source://rbs//lib/rbs/collection/config/lockfile_generator.rb#7
+class RBS::Collection::Config::LockfileGenerator::GemfileLockMismatchError < ::StandardError
+  # @return [GemfileLockMismatchError] a new instance of GemfileLockMismatchError
+  #
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#8
+  def initialize(expected:, actual:); end
+
+  # source://rbs//lib/rbs/collection/config/lockfile_generator.rb#13
+  def message; end
+end
+
+# source://rbs//lib/rbs/collection/config.rb#17
+RBS::Collection::Config::PATH = T.let(T.unsafe(nil), Pathname)
+
+# source://rbs//lib/rbs/collection/installer.rb#5
+class RBS::Collection::Installer
+  # @return [Installer] a new instance of Installer
+  #
+  # source://rbs//lib/rbs/collection/installer.rb#9
+  def initialize(lockfile_path:, stdout: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/collection/installer.rb#14
+  def install_from_lockfile; end
+
+  # Returns the value of attribute lockfile.
+  #
+  # source://rbs//lib/rbs/collection/installer.rb#6
+  def lockfile; end
+
+  # Returns the value of attribute stdout.
+  #
+  # source://rbs//lib/rbs/collection/installer.rb#7
+  def stdout; end
+end
+
+# source://rbs//lib/rbs/collection/sources/base.rb#5
+module RBS::Collection::Sources
+  class << self
+    # source://rbs//lib/rbs/collection/sources.rb#12
+    def from_config_entry(source_entry, base_directory:); end
+  end
+end
+
+# source://rbs//lib/rbs/collection/sources/base.rb#6
+module RBS::Collection::Sources::Base
+  # source://rbs//lib/rbs/collection/sources/base.rb#7
+  def dependencies_of(name, version); end
+end
+
+# source://rbs//lib/rbs/collection/sources/git.rb#10
+class RBS::Collection::Sources::Git
+  include ::RBS::Collection::Sources::Base
+
+  # @return [Git] a new instance of Git
+  #
+  # source://rbs//lib/rbs/collection/sources/git.rb#18
+  def initialize(name:, revision:, remote:, repo_dir:); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/collection/sources/git.rb#26
+  def has?(name, version); end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#43
+  def install(dest:, name:, version:, stdout:); end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#223
+  def load_metadata(dir:); end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#73
+  def manifest_of(name, version); end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#207
+  def metadata_content(name:, version:); end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/collection/sources/git.rb#16
+  def name; end
+
+  # Returns the value of attribute remote.
+  #
+  # source://rbs//lib/rbs/collection/sources/git.rb#16
+  def remote; end
+
+  # Returns the value of attribute repo_dir.
+  #
+  # source://rbs//lib/rbs/collection/sources/git.rb#16
+  def repo_dir; end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#172
+  def resolved_revision; end
+
+  # Returns the value of attribute revision.
+  #
+  # source://rbs//lib/rbs/collection/sources/git.rb#16
+  def revision; end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#113
+  def to_lockfile; end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#36
+  def versions(name); end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#215
+  def write_metadata(dir:, name:, version:); end
+
+  private
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#87
+  def _install(dest:, name:, version:); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/collection/sources/git.rb#183
+  def commit_hash?; end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#99
+  def cp_r(src, dest); end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#123
+  def format_config_entry(name, version); end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#168
+  def gem_repo_dir; end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#229
+  def gems_versions; end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#187
+  def git(*cmd, **opt); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/collection/sources/git.rb#191
+  def git?(*cmd, **opt); end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#158
+  def git_dir; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/collection/sources/git.rb#152
+  def need_to_fetch?(revision); end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#130
+  def setup!; end
+
+  # source://rbs//lib/rbs/collection/sources/git.rb#197
+  def sh!(*cmd, **opt); end
+end
+
+# source://rbs//lib/rbs/collection/sources/git.rb#14
+class RBS::Collection::Sources::Git::CommandError < ::StandardError; end
+
+# source://rbs//lib/rbs/collection/sources/git.rb#12
+RBS::Collection::Sources::Git::METADATA_FILENAME = T.let(T.unsafe(nil), String)
+
+# source://rbs//lib/rbs/collection/sources/local.rb#6
+class RBS::Collection::Sources::Local
+  include ::RBS::Collection::Sources::Base
+
+  # @return [Local] a new instance of Local
+  #
+  # source://rbs//lib/rbs/collection/sources/local.rb#11
+  def initialize(path:, base_directory:); end
+
+  # Returns the value of attribute full_path.
+  #
+  # source://rbs//lib/rbs/collection/sources/local.rb#9
+  def full_path; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/collection/sources/local.rb#17
+  def has?(name, version); end
+
+  # Create a symlink instead of copying file to refer files in @path.
+  # By avoiding copying RBS files, the users do not need re-run `rbs collection install`
+  # when the RBS files are updated.
+  #
+  # source://rbs//lib/rbs/collection/sources/local.rb#32
+  def install(dest:, name:, version:, stdout:); end
+
+  # source://rbs//lib/rbs/collection/sources/local.rb#64
+  def manifest_of(name, version); end
+
+  # Returns the value of attribute path.
+  #
+  # source://rbs//lib/rbs/collection/sources/local.rb#9
+  def path; end
+
+  # source://rbs//lib/rbs/collection/sources/local.rb#72
+  def to_lockfile; end
+
+  # source://rbs//lib/rbs/collection/sources/local.rb#25
+  def versions(name); end
+
+  private
+
+  # source://rbs//lib/rbs/collection/sources/local.rb#59
+  def _install(src, dst); end
+end
+
+# Signatures that are inclduded in gem package as sig/ directory.
+#
+# source://rbs//lib/rbs/collection/sources/rubygems.rb#9
+class RBS::Collection::Sources::Rubygems
+  include ::RBS::Collection::Sources::Base
+  include ::Singleton
+  extend ::Singleton::SingletonClassMethods
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/collection/sources/rubygems.rb#13
+  def has?(name, version); end
+
+  # source://rbs//lib/rbs/collection/sources/rubygems.rb#23
+  def install(dest:, name:, version:, stdout:); end
+
+  # source://rbs//lib/rbs/collection/sources/rubygems.rb#29
+  def manifest_of(name, version); end
+
+  # source://rbs//lib/rbs/collection/sources/rubygems.rb#36
+  def to_lockfile; end
+
+  # source://rbs//lib/rbs/collection/sources/rubygems.rb#17
+  def versions(name); end
+
+  private
+
+  # source://rbs//lib/rbs/collection/sources/rubygems.rb#42
+  def gem_sig_path(name, version); end
+
+  class << self
+    private
+
+    def allocate; end
+    def new(*_arg0); end
+  end
+end
+
+# signatures that are bundled in rbs gem under the stdlib/ directory
+#
+# source://rbs//lib/rbs/collection/sources/stdlib.rb#9
+class RBS::Collection::Sources::Stdlib
+  include ::RBS::Collection::Sources::Base
+  include ::Singleton
+  extend ::Singleton::SingletonClassMethods
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/collection/sources/stdlib.rb#15
+  def has?(name, version); end
+
+  # source://rbs//lib/rbs/collection/sources/stdlib.rb#23
+  def install(dest:, name:, version:, stdout:); end
+
+  # source://rbs//lib/rbs/collection/sources/stdlib.rb#29
+  def manifest_of(name, version); end
+
+  # source://rbs//lib/rbs/collection/sources/stdlib.rb#38
+  def to_lockfile; end
+
+  # source://rbs//lib/rbs/collection/sources/stdlib.rb#19
+  def versions(name); end
+
+  private
+
+  # source://rbs//lib/rbs/collection/sources/stdlib.rb#44
+  def lookup(name, version); end
+
+  class << self
+    private
+
+    def allocate; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rbs//lib/rbs/collection/sources/stdlib.rb#13
+RBS::Collection::Sources::Stdlib::REPO = T.let(T.unsafe(nil), RBS::Repository)
+
+# source://rbs//lib/rbs/constant.rb#4
+class RBS::Constant
+  # @return [Constant] a new instance of Constant
+  #
+  # source://rbs//lib/rbs/constant.rb#9
+  def initialize(name:, type:, entry:); end
+
+  # source://rbs//lib/rbs/constant.rb#15
+  def ==(other); end
+
+  # Returns the value of attribute entry.
+  #
+  # source://rbs//lib/rbs/constant.rb#7
+  def entry; end
+
+  # source://rbs//lib/rbs/constant.rb#15
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/constant.rb#24
+  def hash; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/constant.rb#5
+  def name; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/constant.rb#6
+  def type; end
+end
+
+# source://rbs//lib/rbs/errors.rb#553
+class RBS::CyclicClassAliasDefinitionError < ::RBS::BaseError
+  include ::RBS::DetailedMessageable
+
+  # @return [CyclicClassAliasDefinitionError] a new instance of CyclicClassAliasDefinitionError
+  #
+  # source://rbs//lib/rbs/errors.rb#558
+  def initialize(entry); end
+
+  # Returns the value of attribute alias_entry.
+  #
+  # source://rbs//lib/rbs/errors.rb#556
+  def alias_entry; end
+
+  # source://rbs//lib/rbs/errors.rb#564
+  def location; end
+end
+
+# source://rbs//lib/rbs/errors.rb#514
+class RBS::CyclicTypeParameterBound < ::RBS::BaseError
+  include ::RBS::DetailedMessageable
+
+  # @return [CyclicTypeParameterBound] a new instance of CyclicTypeParameterBound
+  #
+  # source://rbs//lib/rbs/errors.rb#519
+  def initialize(type_name:, method_name:, params:, location:); end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/errors.rb#517
+  def location; end
+
+  # Returns the value of attribute method_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#517
+  def method_name; end
+
+  # Returns the value of attribute params.
+  #
+  # source://rbs//lib/rbs/errors.rb#517
+  def params; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#517
+  def type_name; end
+end
+
+# source://rbs//lib/rbs/definition.rb#4
+class RBS::Definition
+  # @return [Definition] a new instance of Definition
+  #
+  # source://rbs//lib/rbs/definition.rb#282
+  def initialize(type_name:, entry:, self_type:, ancestors:); end
+
+  # Returns the value of attribute ancestors.
+  #
+  # source://rbs//lib/rbs/definition.rb#276
+  def ancestors; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/definition.rb#305
+  def class?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/definition.rb#322
+  def class_type?; end
+
+  # Returns the value of attribute class_variables.
+  #
+  # source://rbs//lib/rbs/definition.rb#280
+  def class_variables; end
+
+  # source://rbs//lib/rbs/definition.rb#367
+  def each_type(&block); end
+
+  # Returns the value of attribute entry.
+  #
+  # source://rbs//lib/rbs/definition.rb#275
+  def entry; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/definition.rb#326
+  def instance_type?; end
+
+  # Returns the value of attribute instance_variables.
+  #
+  # source://rbs//lib/rbs/definition.rb#279
+  def instance_variables; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/definition.rb#313
+  def interface?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/definition.rb#330
+  def interface_type?; end
+
+  # source://rbs//lib/rbs/definition.rb#357
+  def map_method_type(&block); end
+
+  # Returns the value of attribute methods.
+  #
+  # source://rbs//lib/rbs/definition.rb#278
+  def methods; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/definition.rb#309
+  def module?; end
+
+  # Returns the value of attribute self_type.
+  #
+  # source://rbs//lib/rbs/definition.rb#277
+  def self_type; end
+
+  # source://rbs//lib/rbs/definition.rb#347
+  def sub(s); end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/definition.rb#274
+  def type_name; end
+
+  # source://rbs//lib/rbs/definition.rb#334
+  def type_params; end
+
+  # source://rbs//lib/rbs/definition.rb#338
+  def type_params_decl; end
+end
+
+# source://rbs//lib/rbs/definition.rb#189
+module RBS::Definition::Ancestor; end
+
+# source://rbs//lib/rbs/definition.rb#190
+class RBS::Definition::Ancestor::Instance
+  # @return [Instance] a new instance of Instance
+  #
+  # source://rbs//lib/rbs/definition.rb#193
+  def initialize(name:, args:, source:); end
+
+  # source://rbs//lib/rbs/definition.rb#199
+  def ==(other); end
+
+  # Returns the value of attribute args.
+  #
+  # source://rbs//lib/rbs/definition.rb#191
+  def args; end
+
+  # source://rbs//lib/rbs/definition.rb#199
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/definition.rb#205
+  def hash; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/definition.rb#191
+  def name; end
+
+  # Returns the value of attribute source.
+  #
+  # source://rbs//lib/rbs/definition.rb#191
+  def source; end
+end
+
+# source://rbs//lib/rbs/definition.rb#210
+class RBS::Definition::Ancestor::Singleton
+  # @return [Singleton] a new instance of Singleton
+  #
+  # source://rbs//lib/rbs/definition.rb#213
+  def initialize(name:); end
+
+  # source://rbs//lib/rbs/definition.rb#217
+  def ==(other); end
+
+  # source://rbs//lib/rbs/definition.rb#217
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/definition.rb#223
+  def hash; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/definition.rb#211
+  def name; end
+end
+
+# source://rbs//lib/rbs/definition.rb#229
+class RBS::Definition::InstanceAncestors
+  # @return [InstanceAncestors] a new instance of InstanceAncestors
+  #
+  # source://rbs//lib/rbs/definition.rb#234
+  def initialize(type_name:, params:, ancestors:); end
+
+  # Returns the value of attribute ancestors.
+  #
+  # source://rbs//lib/rbs/definition.rb#232
+  def ancestors; end
+
+  # source://rbs//lib/rbs/definition.rb#240
+  def apply(args, env:, location:); end
+
+  # Returns the value of attribute params.
+  #
+  # source://rbs//lib/rbs/definition.rb#231
+  def params; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/definition.rb#230
+  def type_name; end
+end
+
+# source://rbs//lib/rbs/definition.rb#25
+class RBS::Definition::Method
+  # @return [Method] a new instance of Method
+  #
+  # source://rbs//lib/rbs/definition.rb#81
+  def initialize(super_method:, defs:, accessibility:, alias_of:, annotations: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/definition.rb#89
+  def ==(other); end
+
+  # Returns the value of attribute accessibility.
+  #
+  # source://rbs//lib/rbs/definition.rb#77
+  def accessibility; end
+
+  # Returns the value of attribute alias_of.
+  #
+  # source://rbs//lib/rbs/definition.rb#79
+  def alias_of; end
+
+  # source://rbs//lib/rbs/definition.rb#126
+  def annotations; end
+
+  # source://rbs//lib/rbs/definition.rb#122
+  def comments; end
+
+  # source://rbs//lib/rbs/definition.rb#104
+  def defined_in; end
+
+  # Returns the value of attribute defs.
+  #
+  # source://rbs//lib/rbs/definition.rb#76
+  def defs; end
+
+  # source://rbs//lib/rbs/definition.rb#89
+  def eql?(other); end
+
+  # Returns the value of attribute extra_annotations.
+  #
+  # source://rbs//lib/rbs/definition.rb#78
+  def extra_annotations; end
+
+  # source://rbs//lib/rbs/definition.rb#100
+  def hash; end
+
+  # source://rbs//lib/rbs/definition.rb#111
+  def implemented_in; end
+
+  # source://rbs//lib/rbs/definition.rb#169
+  def map_method_type(&block); end
+
+  # source://rbs//lib/rbs/definition.rb#151
+  def map_type(&block); end
+
+  # source://rbs//lib/rbs/definition.rb#160
+  def map_type_bound(&block); end
+
+  # source://rbs//lib/rbs/definition.rb#130
+  def members; end
+
+  # source://rbs//lib/rbs/definition.rb#118
+  def method_types; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/definition.rb#138
+  def private?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/definition.rb#134
+  def public?; end
+
+  # source://rbs//lib/rbs/definition.rb#142
+  def sub(s); end
+
+  # Returns the value of attribute super_method.
+  #
+  # source://rbs//lib/rbs/definition.rb#75
+  def super_method; end
+
+  # source://rbs//lib/rbs/definition.rb#178
+  def update(super_method: T.unsafe(nil), defs: T.unsafe(nil), accessibility: T.unsafe(nil), alias_of: T.unsafe(nil), annotations: T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/definition.rb#26
+class RBS::Definition::Method::TypeDef
+  # @return [TypeDef] a new instance of TypeDef
+  #
+  # source://rbs//lib/rbs/definition.rb#32
+  def initialize(type:, member:, defined_in:, implemented_in:); end
+
+  # source://rbs//lib/rbs/definition.rb#39
+  def ==(other); end
+
+  # source://rbs//lib/rbs/definition.rb#57
+  def annotations; end
+
+  # source://rbs//lib/rbs/definition.rb#53
+  def comment; end
+
+  # Returns the value of attribute defined_in.
+  #
+  # source://rbs//lib/rbs/definition.rb#29
+  def defined_in; end
+
+  # source://rbs//lib/rbs/definition.rb#39
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/definition.rb#49
+  def hash; end
+
+  # Returns the value of attribute implemented_in.
+  #
+  # source://rbs//lib/rbs/definition.rb#30
+  def implemented_in; end
+
+  # Returns the value of attribute member.
+  #
+  # source://rbs//lib/rbs/definition.rb#28
+  def member; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/definition.rb#65
+  def overload?; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/definition.rb#27
+  def type; end
+
+  # source://rbs//lib/rbs/definition.rb#61
+  def update(type: T.unsafe(nil), member: T.unsafe(nil), defined_in: T.unsafe(nil), implemented_in: T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/definition.rb#264
+class RBS::Definition::SingletonAncestors
+  # @return [SingletonAncestors] a new instance of SingletonAncestors
+  #
+  # source://rbs//lib/rbs/definition.rb#268
+  def initialize(type_name:, ancestors:); end
+
+  # Returns the value of attribute ancestors.
+  #
+  # source://rbs//lib/rbs/definition.rb#266
+  def ancestors; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/definition.rb#265
+  def type_name; end
+end
+
+# source://rbs//lib/rbs/definition.rb#5
+class RBS::Definition::Variable
+  # @return [Variable] a new instance of Variable
+  #
+  # source://rbs//lib/rbs/definition.rb#10
+  def initialize(parent_variable:, type:, declared_in:); end
+
+  # Returns the value of attribute declared_in.
+  #
+  # source://rbs//lib/rbs/definition.rb#8
+  def declared_in; end
+
+  # Returns the value of attribute parent_variable.
+  #
+  # source://rbs//lib/rbs/definition.rb#6
+  def parent_variable; end
+
+  # source://rbs//lib/rbs/definition.rb#16
+  def sub(s); end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/definition.rb#7
+  def type; end
+end
+
+# source://rbs//lib/rbs/definition_builder.rb#4
+class RBS::DefinitionBuilder
+  # @return [DefinitionBuilder] a new instance of DefinitionBuilder
+  #
+  # source://rbs//lib/rbs/definition_builder.rb#14
+  def initialize(env:, ancestor_builder: T.unsafe(nil), method_builder: T.unsafe(nil)); end
+
+  # Returns the value of attribute ancestor_builder.
+  #
+  # source://rbs//lib/rbs/definition_builder.rb#6
+  def ancestor_builder; end
+
+  # source://rbs//lib/rbs/definition_builder.rb#168
+  def build_instance(type_name); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#43
+  def build_interface(type_name); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#301
+  def build_singleton(type_name); end
+
+  # Builds a definition for singleton without .new method.
+  #
+  # source://rbs//lib/rbs/definition_builder.rb#230
+  def build_singleton0(type_name); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#85
+  def define_instance(definition, type_name, subst); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#33
+  def define_interface(definition, type_name, subst); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#606
+  def define_method(methods, definition, method, subst, self_type_methods, defined_in:, implemented_in: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#25
+  def ensure_namespace!(namespace, location:); end
+
+  # Returns the value of attribute env.
+  #
+  # source://rbs//lib/rbs/definition_builder.rb#5
+  def env; end
+
+  # source://rbs//lib/rbs/definition_builder.rb#767
+  def expand_alias(type_name); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#771
+  def expand_alias1(type_name); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#778
+  def expand_alias2(type_name, args); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#545
+  def import_methods(definition, module_name, module_methods, interfaces_methods, subst, self_type_methods); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#537
+  def insert_variable(type_name, variables, name:, type:); end
+
+  # Returns the value of attribute instance_cache.
+  #
+  # source://rbs//lib/rbs/definition_builder.rb#9
+  def instance_cache; end
+
+  # Returns the value of attribute interface_cache.
+  #
+  # source://rbs//lib/rbs/definition_builder.rb#12
+  def interface_cache; end
+
+  # source://rbs//lib/rbs/definition_builder.rb#411
+  def interface_methods(interface_ancestors); end
+
+  # Returns the value of attribute method_builder.
+  #
+  # source://rbs//lib/rbs/definition_builder.rb#7
+  def method_builder; end
+
+  # Returns the value of attribute singleton0_cache.
+  #
+  # source://rbs//lib/rbs/definition_builder.rb#11
+  def singleton0_cache; end
+
+  # Returns the value of attribute singleton_cache.
+  #
+  # source://rbs//lib/rbs/definition_builder.rb#10
+  def singleton_cache; end
+
+  # source://rbs//lib/rbs/definition_builder.rb#441
+  def source_location(source, decl); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#66
+  def tapp_subst(name, args); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#763
+  def try_cache(type_name, cache:); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#802
+  def update(env:, except:, ancestor_builder:); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#431
+  def validate_params_with(type_params, result:); end
+
+  # @raise [NoTypeFoundError]
+  #
+  # source://rbs//lib/rbs/definition_builder.rb#831
+  def validate_type_name(name, location); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#455
+  def validate_type_params(definition, ancestors:, methods:); end
+
+  # source://rbs//lib/rbs/definition_builder.rb#820
+  def validate_type_presence(type); end
+end
+
+# source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#5
+class RBS::DefinitionBuilder::AncestorBuilder
+  # @return [AncestorBuilder] a new instance of AncestorBuilder
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#162
+  def initialize(env:); end
+
+  # Returns the value of attribute env.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#151
+  def env; end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#606
+  def fill_ancestor_source(ancestor, name:, source:, &block); end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#434
+  def instance_ancestors(type_name, building_ancestors: T.unsafe(nil)); end
+
+  # Returns the value of attribute instance_ancestors_cache.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#154
+  def instance_ancestors_cache; end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#570
+  def interface_ancestors(type_name, building_ancestors: T.unsafe(nil)); end
+
+  # Returns the value of attribute interface_ancestors_cache.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#160
+  def interface_ancestors_cache; end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#414
+  def mixin_ancestors(entry, type_name, included_modules:, included_interfaces:, extended_modules:, prepended_modules:, extended_interfaces:); end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#348
+  def mixin_ancestors0(decl, type_name, align_params:, included_modules:, included_interfaces:, extended_modules:, prepended_modules:, extended_interfaces:); end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#192
+  def one_instance_ancestors(type_name); end
+
+  # Returns the value of attribute one_instance_ancestors_cache.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#153
+  def one_instance_ancestors_cache; end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#329
+  def one_interface_ancestors(type_name); end
+
+  # Returns the value of attribute one_interface_ancestors_cache.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#159
+  def one_interface_ancestors_cache; end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#275
+  def one_singleton_ancestors(type_name); end
+
+  # Returns the value of attribute one_singleton_ancestors_cache.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#156
+  def one_singleton_ancestors_cache; end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#515
+  def singleton_ancestors(type_name, building_ancestors: T.unsafe(nil)); end
+
+  # Returns the value of attribute singleton_ancestors_cache.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#157
+  def singleton_ancestors_cache; end
+
+  # @raise [SuperclassMismatchError]
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#175
+  def validate_super_class!(type_name, entry); end
+end
+
+# source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#6
+class RBS::DefinitionBuilder::AncestorBuilder::OneAncestors
+  # @return [OneAncestors] a new instance of OneAncestors
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#17
+  def initialize(type_name:, params:, super_class:, self_types:, included_modules:, included_interfaces:, prepended_modules:, extended_modules:, extended_interfaces:); end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#29
+  def each_ancestor(&block); end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#86
+  def each_extended_interface(&block); end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#78
+  def each_extended_module(&block); end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#62
+  def each_included_interface(&block); end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#54
+  def each_included_module(&block); end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#70
+  def each_prepended_module(&block); end
+
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#46
+  def each_self_type(&block); end
+
+  # Returns the value of attribute extended_interfaces.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#15
+  def extended_interfaces; end
+
+  # Returns the value of attribute extended_modules.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#14
+  def extended_modules; end
+
+  # Returns the value of attribute included_interfaces.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#12
+  def included_interfaces; end
+
+  # Returns the value of attribute included_modules.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#11
+  def included_modules; end
+
+  # Returns the value of attribute params.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#8
+  def params; end
+
+  # Returns the value of attribute prepended_modules.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#13
+  def prepended_modules; end
+
+  # Returns the value of attribute self_types.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#10
+  def self_types; end
+
+  # Returns the value of attribute super_class.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#9
+  def super_class; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#7
+  def type_name; end
+
+  class << self
+    # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#94
+    def class_instance(type_name:, params:, super_class:); end
+
+    # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#136
+    def interface(type_name:, params:); end
+
+    # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#122
+    def module_instance(type_name:, params:); end
+
+    # source://rbs//lib/rbs/definition_builder/ancestor_builder.rb#108
+    def singleton(type_name:, super_class:); end
+  end
+end
+
+# source://rbs//lib/rbs/definition_builder/method_builder.rb#5
+class RBS::DefinitionBuilder::MethodBuilder
+  # @return [MethodBuilder] a new instance of MethodBuilder
+  #
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#91
+  def initialize(env:); end
+
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#194
+  def build_alias(methods, type, member:); end
+
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#199
+  def build_attribute(methods, type, member:, accessibility:); end
+
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#99
+  def build_instance(type_name); end
+
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#174
+  def build_interface(type_name); end
+
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#215
+  def build_method(methods, type, member:, accessibility:); end
+
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#145
+  def build_singleton(type_name); end
+
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#226
+  def each_member_with_accessibility(members, accessibility: T.unsafe(nil)); end
+
+  # Returns the value of attribute env.
+  #
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#86
+  def env; end
+
+  # Returns the value of attribute instance_methods.
+  #
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#87
+  def instance_methods; end
+
+  # Returns the value of attribute interface_methods.
+  #
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#89
+  def interface_methods; end
+
+  # Returns the value of attribute singleton_methods.
+  #
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#88
+  def singleton_methods; end
+
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#239
+  def update(env:, except:); end
+end
+
+# source://rbs//lib/rbs/definition_builder/method_builder.rb#6
+class RBS::DefinitionBuilder::MethodBuilder::Methods
+  # @return [Methods] a new instance of Methods
+  #
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#30
+  def initialize(type:); end
+
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#49
+  def each; end
+
+  # Returns the value of attribute methods.
+  #
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#28
+  def methods; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#27
+  def type; end
+
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#35
+  def validate!; end
+end
+
+# source://rbs//lib/rbs/definition_builder/method_builder.rb#7
+class RBS::DefinitionBuilder::MethodBuilder::Methods::Definition < ::Struct
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#14
+  def accessibility; end
+
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#10
+  def original; end
+
+  class << self
+    # source://rbs//lib/rbs/definition_builder/method_builder.rb#22
+    def empty(name:, type:); end
+  end
+end
+
+# source://rbs//lib/rbs/definition_builder/method_builder.rb#63
+class RBS::DefinitionBuilder::MethodBuilder::Methods::Sorter
+  include ::TSort
+
+  # @return [Sorter] a new instance of Sorter
+  #
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#68
+  def initialize(methods); end
+
+  # Returns the value of attribute methods.
+  #
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#66
+  def methods; end
+
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#76
+  def tsort_each_child(defn); end
+
+  # source://rbs//lib/rbs/definition_builder/method_builder.rb#72
+  def tsort_each_node(&block); end
+end
+
+# source://rbs//lib/rbs/errors.rb#21
+class RBS::DefinitionError < ::RBS::BaseError; end
+
+# source://rbs//lib/rbs/errors.rb#23
+module RBS::DetailedMessageable
+  # source://rbs//lib/rbs/errors.rb#24
+  def detailed_message(highlight: T.unsafe(nil), **_arg1); end
+end
+
+# source://rbs//lib/rbs/diff.rb#4
+class RBS::Diff
+  # @return [Diff] a new instance of Diff
+  #
+  # source://rbs//lib/rbs/diff.rb#5
+  def initialize(type_name:, library_options:, after_path: T.unsafe(nil), before_path: T.unsafe(nil), detail: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/diff.rb#13
+  def each_diff(&block); end
+
+  private
+
+  # source://rbs//lib/rbs/diff.rb#96
+  def build_builder(env); end
+
+  # source://rbs//lib/rbs/diff.rb#77
+  def build_env(path); end
+
+  # source://rbs//lib/rbs/diff.rb#49
+  def build_methods(path); end
+
+  # source://rbs//lib/rbs/diff.rb#116
+  def constant_to_s(constant); end
+
+  # source://rbs//lib/rbs/diff.rb#100
+  def definition_method_to_s(key, kind, definition_method); end
+
+  # source://rbs//lib/rbs/diff.rb#38
+  def each_diff_constants(before_constant_children, after_constant_children); end
+
+  # source://rbs//lib/rbs/diff.rb#27
+  def each_diff_methods(kind, before_methods, after_methods); end
+end
+
+# source://rbs//lib/rbs/errors.rb#394
+class RBS::DuplicatedDeclarationError < ::RBS::LoadingError
+  # @return [DuplicatedDeclarationError] a new instance of DuplicatedDeclarationError
+  #
+  # source://rbs//lib/rbs/errors.rb#398
+  def initialize(name, *decls); end
+
+  # Returns the value of attribute decls.
+  #
+  # source://rbs//lib/rbs/errors.rb#396
+  def decls; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/errors.rb#395
+  def name; end
+end
+
+# source://rbs//lib/rbs/errors.rb#292
+class RBS::DuplicatedInterfaceMethodDefinitionError < ::RBS::DefinitionError
+  include ::RBS::DetailedMessageable
+
+  # @return [DuplicatedInterfaceMethodDefinitionError] a new instance of DuplicatedInterfaceMethodDefinitionError
+  #
+  # source://rbs//lib/rbs/errors.rb#299
+  def initialize(type:, method_name:, member:); end
+
+  # source://rbs//lib/rbs/errors.rb#307
+  def location; end
+
+  # Returns the value of attribute member.
+  #
+  # source://rbs//lib/rbs/errors.rb#297
+  def member; end
+
+  # Returns the value of attribute method_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#296
+  def method_name; end
+
+  # source://rbs//lib/rbs/errors.rb#311
+  def qualified_method_name; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/errors.rb#295
+  def type; end
+
+  # source://rbs//lib/rbs/errors.rb#320
+  def type_name; end
+end
+
+# source://rbs//lib/rbs/errors.rb#251
+class RBS::DuplicatedMethodDefinitionError < ::RBS::DefinitionError
+  include ::RBS::DetailedMessageable
+
+  # @return [DuplicatedMethodDefinitionError] a new instance of DuplicatedMethodDefinitionError
+  #
+  # source://rbs//lib/rbs/errors.rb#258
+  def initialize(type:, method_name:, members:); end
+
+  # source://rbs//lib/rbs/errors.rb#283
+  def location; end
+
+  # Returns the value of attribute members.
+  #
+  # source://rbs//lib/rbs/errors.rb#256
+  def members; end
+
+  # Returns the value of attribute method_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#255
+  def method_name; end
+
+  # source://rbs//lib/rbs/errors.rb#287
+  def other_locations; end
+
+  # source://rbs//lib/rbs/errors.rb#270
+  def qualified_method_name; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/errors.rb#254
+  def type; end
+
+  # source://rbs//lib/rbs/errors.rb#279
+  def type_name; end
+end
+
+# source://rbs//lib/rbs/environment.rb#4
+class RBS::Environment
+  # @return [Environment] a new instance of Environment
+  #
+  # source://rbs//lib/rbs/environment.rb#145
+  def initialize; end
+
+  # source://rbs//lib/rbs/environment.rb#470
+  def <<(decl); end
+
+  # source://rbs//lib/rbs/environment.rb#792
+  def absolute_type(resolver, map, type, context:); end
+
+  # source://rbs//lib/rbs/environment.rb#787
+  def absolute_type_name(resolver, map, type_name, context:); end
+
+  # source://rbs//lib/rbs/environment.rb#476
+  def add_signature(buffer:, directives:, decls:); end
+
+  # source://rbs//lib/rbs/environment.rb#528
+  def append_context(context, decl); end
+
+  # source://rbs//lib/rbs/environment.rb#803
+  def buffers; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment.rb#218
+  def class_alias?(name); end
+
+  # Returns the value of attribute class_alias_decls.
+  #
+  # source://rbs//lib/rbs/environment.rb#12
+  def class_alias_decls; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment.rb#202
+  def class_decl?(name); end
+
+  # Returns the value of attribute class_decls.
+  #
+  # source://rbs//lib/rbs/environment.rb#7
+  def class_decls; end
+
+  # source://rbs//lib/rbs/environment.rb#226
+  def class_entry(type_name); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment.rb#198
+  def constant_decl?(name); end
+
+  # Returns the value of attribute constant_decls.
+  #
+  # source://rbs//lib/rbs/environment.rb#10
+  def constant_decls; end
+
+  # source://rbs//lib/rbs/environment.rb#274
+  def constant_entry(type_name); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment.rb#194
+  def constant_name?(name); end
+
+  # Returns the value of attribute declarations.
+  #
+  # source://rbs//lib/rbs/environment.rb#5
+  def declarations; end
+
+  # Returns the value of attribute global_decls.
+  #
+  # source://rbs//lib/rbs/environment.rb#11
+  def global_decls; end
+
+  # source://rbs//lib/rbs/environment.rb#373
+  def insert_decl(decl, outer:, namespace:); end
+
+  # source://rbs//lib/rbs/environment.rb#798
+  def inspect; end
+
+  # Returns the value of attribute interface_decls.
+  #
+  # source://rbs//lib/rbs/environment.rb#8
+  def interface_decls; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment.rb#176
+  def interface_name?(name); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment.rb#210
+  def module_alias?(name); end
+
+  # source://rbs//lib/rbs/environment.rb#266
+  def module_class_entry(type_name); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment.rb#206
+  def module_decl?(name); end
+
+  # source://rbs//lib/rbs/environment.rb#235
+  def module_entry(type_name); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment.rb#184
+  def module_name?(name); end
+
+  # source://rbs//lib/rbs/environment.rb#332
+  def normalize_module_name(name); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment.rb#336
+  def normalize_module_name?(name); end
+
+  # source://rbs//lib/rbs/environment.rb#328
+  def normalize_type_name(name); end
+
+  # source://rbs//lib/rbs/environment.rb#297
+  def normalize_type_name!(name); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment.rb#278
+  def normalize_type_name?(name); end
+
+  # source://rbs//lib/rbs/environment.rb#244
+  def normalized_class_entry(type_name); end
+
+  # source://rbs//lib/rbs/environment.rb#270
+  def normalized_module_class_entry(type_name); end
+
+  # source://rbs//lib/rbs/environment.rb#255
+  def normalized_module_entry(type_name); end
+
+  # source://rbs//lib/rbs/environment.rb#323
+  def normalized_type_name!(name); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment.rb#310
+  def normalized_type_name?(type_name); end
+
+  # source://rbs//lib/rbs/environment.rb#537
+  def resolve_declaration(resolver, map, decl, outer:, prefix:); end
+
+  # source://rbs//lib/rbs/environment.rb#673
+  def resolve_member(resolver, map, member, context:); end
+
+  # source://rbs//lib/rbs/environment.rb#773
+  def resolve_method_type(resolver, map, type, context:); end
+
+  # source://rbs//lib/rbs/environment.rb#489
+  def resolve_type_names(only: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/environment.rb#781
+  def resolve_type_params(resolver, map, params, context:); end
+
+  # source://rbs//lib/rbs/environment.rb#522
+  def resolver_context(*nesting); end
+
+  # Returns the value of attribute signatures.
+  #
+  # source://rbs//lib/rbs/environment.rb#14
+  def signatures; end
+
+  # Returns the value of attribute type_alias_decls.
+  #
+  # source://rbs//lib/rbs/environment.rb#9
+  def type_alias_decls; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment.rb#180
+  def type_alias_name?(name); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment.rb#188
+  def type_name?(name); end
+
+  # source://rbs//lib/rbs/environment.rb#807
+  def unload(buffers); end
+
+  # source://rbs//lib/rbs/environment.rb#483
+  def validate_type_params; end
+
+  private
+
+  # source://rbs//lib/rbs/environment.rb#158
+  def initialize_copy(other); end
+
+  class << self
+    # source://rbs//lib/rbs/environment.rb#170
+    def from_loader(loader); end
+  end
+end
+
+# source://rbs//lib/rbs/environment.rb#130
+class RBS::Environment::ClassAliasEntry < ::RBS::Environment::SingleEntry; end
+
+# source://rbs//lib/rbs/environment.rb#100
+class RBS::Environment::ClassEntry < ::RBS::Environment::MultiEntry
+  # source://rbs//lib/rbs/environment.rb#101
+  def primary; end
+end
+
+# source://rbs//lib/rbs/environment.rb#139
+class RBS::Environment::ConstantEntry < ::RBS::Environment::SingleEntry; end
+
+# source://rbs//lib/rbs/environment.rb#16
+module RBS::Environment::ContextUtil
+  # source://rbs//lib/rbs/environment.rb#17
+  def calculate_context(decls); end
+end
+
+# source://rbs//lib/rbs/environment.rb#142
+class RBS::Environment::GlobalEntry < ::RBS::Environment::SingleEntry; end
+
+# source://rbs//lib/rbs/environment.rb#133
+class RBS::Environment::InterfaceEntry < ::RBS::Environment::SingleEntry; end
+
+# source://rbs//lib/rbs/environment.rb#127
+class RBS::Environment::ModuleAliasEntry < ::RBS::Environment::SingleEntry; end
+
+# source://rbs//lib/rbs/environment.rb#85
+class RBS::Environment::ModuleEntry < ::RBS::Environment::MultiEntry
+  # source://rbs//lib/rbs/environment.rb#92
+  def primary; end
+
+  # source://rbs//lib/rbs/environment.rb#86
+  def self_types; end
+end
+
+# source://rbs//lib/rbs/environment.rb#29
+class RBS::Environment::MultiEntry
+  # @return [MultiEntry] a new instance of MultiEntry
+  #
+  # source://rbs//lib/rbs/environment.rb#43
+  def initialize(name:); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment.rb#70
+  def compatible_params?(ps1, ps2); end
+
+  # Returns the value of attribute decls.
+  #
+  # source://rbs//lib/rbs/environment.rb#41
+  def decls; end
+
+  # source://rbs//lib/rbs/environment.rb#48
+  def insert(decl:, outer:); end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/environment.rb#40
+  def name; end
+
+  # source://rbs//lib/rbs/environment.rb#80
+  def primary; end
+
+  # source://rbs//lib/rbs/environment.rb#76
+  def type_params; end
+
+  # source://rbs//lib/rbs/environment.rb#53
+  def validate_type_params; end
+end
+
+# source://rbs//lib/rbs/environment.rb#30
+class RBS::Environment::MultiEntry::D < ::Struct
+  include ::RBS::Environment::ContextUtil
+
+  # source://rbs//lib/rbs/environment.rb#35
+  def context; end
+
+  def decl; end
+  def decl=(_); end
+  def outer; end
+  def outer=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rbs//lib/rbs/environment.rb#109
+class RBS::Environment::SingleEntry
+  include ::RBS::Environment::ContextUtil
+
+  # @return [SingleEntry] a new instance of SingleEntry
+  #
+  # source://rbs//lib/rbs/environment.rb#114
+  def initialize(name:, decl:, outer:); end
+
+  # source://rbs//lib/rbs/environment.rb#122
+  def context; end
+
+  # Returns the value of attribute decl.
+  #
+  # source://rbs//lib/rbs/environment.rb#112
+  def decl; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/environment.rb#110
+  def name; end
+
+  # Returns the value of attribute outer.
+  #
+  # source://rbs//lib/rbs/environment.rb#111
+  def outer; end
+end
+
+# source://rbs//lib/rbs/environment.rb#136
+class RBS::Environment::TypeAliasEntry < ::RBS::Environment::SingleEntry; end
+
+# source://rbs//lib/rbs/environment/use_map.rb#5
+class RBS::Environment::UseMap
+  # @return [UseMap] a new instance of UseMap
+  #
+  # source://rbs//lib/rbs/environment/use_map.rb#30
+  def initialize(table:); end
+
+  # source://rbs//lib/rbs/environment/use_map.rb#36
+  def build_map(clause); end
+
+  # source://rbs//lib/rbs/environment/use_map.rb#72
+  def resolve(type_name); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment/use_map.rb#53
+  def resolve?(type_name); end
+
+  # Returns the value of attribute use_dirs.
+  #
+  # source://rbs//lib/rbs/environment/use_map.rb#28
+  def use_dirs; end
+end
+
+# source://rbs//lib/rbs/environment/use_map.rb#6
+class RBS::Environment::UseMap::Table
+  # @return [Table] a new instance of Table
+  #
+  # source://rbs//lib/rbs/environment/use_map.rb#9
+  def initialize; end
+
+  # Returns the value of attribute children.
+  #
+  # source://rbs//lib/rbs/environment/use_map.rb#7
+  def children; end
+
+  # source://rbs//lib/rbs/environment/use_map.rb#14
+  def compute_children; end
+
+  # Returns the value of attribute known_types.
+  #
+  # source://rbs//lib/rbs/environment/use_map.rb#7
+  def known_types; end
+end
+
+# source://rbs//lib/rbs/environment_loader.rb#4
+class RBS::EnvironmentLoader
+  include ::RBS::FileFinder
+
+  # @return [EnvironmentLoader] a new instance of EnvironmentLoader
+  #
+  # source://rbs//lib/rbs/environment_loader.rb#40
+  def initialize(core_root: T.unsafe(nil), repository: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/environment_loader.rb#48
+  def add(path: T.unsafe(nil), library: T.unsafe(nil), version: T.unsafe(nil), resolve_dependencies: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/environment_loader.rb#80
+  def add_collection(lockfile); end
+
+  # Returns the value of attribute core_root.
+  #
+  # source://rbs//lib/rbs/environment_loader.rb#20
+  def core_root; end
+
+  # Returns the value of attribute dirs.
+  #
+  # source://rbs//lib/rbs/environment_loader.rb#24
+  def dirs; end
+
+  # source://rbs//lib/rbs/environment_loader.rb#126
+  def each_dir; end
+
+  # source://rbs//lib/rbs/environment_loader.rb#149
+  def each_signature; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment_loader.rb#104
+  def has_library?(library:, version:); end
+
+  # Returns the value of attribute libs.
+  #
+  # source://rbs//lib/rbs/environment_loader.rb#23
+  def libs; end
+
+  # source://rbs//lib/rbs/environment_loader.rb#112
+  def load(env:); end
+
+  # Returns the value of attribute repository.
+  #
+  # source://rbs//lib/rbs/environment_loader.rb#21
+  def repository; end
+
+  # source://rbs//lib/rbs/environment_loader.rb#65
+  def resolve_dependencies(library:, version:); end
+
+  class << self
+    # source://rbs//lib/rbs/environment_loader.rb#28
+    def gem_sig_path(name, version); end
+  end
+end
+
+# source://rbs//lib/rbs/environment_loader.rb#26
+RBS::EnvironmentLoader::DEFAULT_CORE_ROOT = T.let(T.unsafe(nil), Pathname)
+
+# source://rbs//lib/rbs/environment_loader.rb#17
+class RBS::EnvironmentLoader::Library < ::Struct; end
+
+# source://rbs//lib/rbs/environment_loader.rb#5
+class RBS::EnvironmentLoader::UnknownLibraryError < ::StandardError
+  # @return [UnknownLibraryError] a new instance of UnknownLibraryError
+  #
+  # source://rbs//lib/rbs/environment_loader.rb#8
+  def initialize(lib:); end
+
+  # Returns the value of attribute library.
+  #
+  # source://rbs//lib/rbs/environment_loader.rb#6
+  def library; end
+end
+
+# source://rbs//lib/rbs/environment_walker.rb#4
+class RBS::EnvironmentWalker
+  include ::TSort
+
+  # @return [EnvironmentWalker] a new instance of EnvironmentWalker
+  #
+  # source://rbs//lib/rbs/environment_walker.rb#11
+  def initialize(env:); end
+
+  # source://rbs//lib/rbs/environment_walker.rb#16
+  def builder; end
+
+  # source://rbs//lib/rbs/environment_walker.rb#99
+  def each_type_name(type, &block); end
+
+  # source://rbs//lib/rbs/environment_walker.rb#105
+  def each_type_node(type, &block); end
+
+  # Returns the value of attribute env.
+  #
+  # source://rbs//lib/rbs/environment_walker.rb#9
+  def env; end
+
+  # source://rbs//lib/rbs/environment_walker.rb#20
+  def only_ancestors!(only = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/environment_walker.rb#25
+  def only_ancestors?; end
+
+  # source://rbs//lib/rbs/environment_walker.rb#44
+  def tsort_each_child(node, &block); end
+
+  # source://rbs//lib/rbs/environment_walker.rb#31
+  def tsort_each_node(&block); end
+end
+
+# source://rbs//lib/rbs/environment_walker.rb#5
+class RBS::EnvironmentWalker::InstanceNode < ::Struct
+  def type_name; end
+  def type_name=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rbs//lib/rbs/environment_walker.rb#6
+class RBS::EnvironmentWalker::SingletonNode < ::Struct
+  def type_name; end
+  def type_name=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rbs//lib/rbs/environment_walker.rb#7
+class RBS::EnvironmentWalker::TypeNameNode < ::Struct
+  def type_name; end
+  def type_name=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rbs//lib/rbs/factory.rb#4
+class RBS::Factory
+  # source://rbs//lib/rbs/factory.rb#5
+  def type_name(string); end
+end
+
+# source://rbs//lib/rbs/file_finder.rb#4
+module RBS::FileFinder
+  class << self
+    # source://rbs//lib/rbs/file_finder.rb#7
+    def each_file(path, skip_hidden:, immediate: T.unsafe(nil), &block); end
+  end
+end
+
+# source://rbs//lib/rbs/errors.rb#383
+class RBS::GenericParameterMismatchError < ::RBS::LoadingError
+  # @return [GenericParameterMismatchError] a new instance of GenericParameterMismatchError
+  #
+  # source://rbs//lib/rbs/errors.rb#387
+  def initialize(name:, decl:); end
+
+  # Returns the value of attribute decl.
+  #
+  # source://rbs//lib/rbs/errors.rb#385
+  def decl; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/errors.rb#384
+  def name; end
+end
+
+# source://rbs//lib/rbs/errors.rb#529
+class RBS::InconsistentClassModuleAliasError < ::RBS::BaseError
+  include ::RBS::DetailedMessageable
+
+  # @return [InconsistentClassModuleAliasError] a new instance of InconsistentClassModuleAliasError
+  #
+  # source://rbs//lib/rbs/errors.rb#534
+  def initialize(entry); end
+
+  # Returns the value of attribute alias_entry.
+  #
+  # source://rbs//lib/rbs/errors.rb#532
+  def alias_entry; end
+
+  # source://rbs//lib/rbs/errors.rb#548
+  def location; end
+end
+
+# source://rbs//lib/rbs/errors.rb#187
+class RBS::InheritModuleError < ::RBS::DefinitionError
+  include ::RBS::DetailedMessageable
+
+  # @return [InheritModuleError] a new instance of InheritModuleError
+  #
+  # source://rbs//lib/rbs/errors.rb#192
+  def initialize(super_decl); end
+
+  # source://rbs//lib/rbs/errors.rb#198
+  def location; end
+
+  # Returns the value of attribute super_decl.
+  #
+  # source://rbs//lib/rbs/errors.rb#190
+  def super_decl; end
+
+  class << self
+    # source://rbs//lib/rbs/errors.rb#202
+    def check!(super_decl, env:); end
+  end
+end
+
+# source://rbs//lib/rbs/errors.rb#354
+class RBS::InvalidOverloadMethodError < ::RBS::DefinitionError
+  include ::RBS::DetailedMessageable
+
+  # @return [InvalidOverloadMethodError] a new instance of InvalidOverloadMethodError
+  #
+  # source://rbs//lib/rbs/errors.rb#362
+  def initialize(type_name:, method_name:, kind:, members:); end
+
+  # Returns the value of attribute kind.
+  #
+  # source://rbs//lib/rbs/errors.rb#359
+  def kind; end
+
+  # source://rbs//lib/rbs/errors.rb#378
+  def location; end
+
+  # Returns the value of attribute members.
+  #
+  # source://rbs//lib/rbs/errors.rb#360
+  def members; end
+
+  # Returns the value of attribute method_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#358
+  def method_name; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#357
+  def type_name; end
+end
+
+# source://rbs//lib/rbs/errors.rb#67
+class RBS::InvalidTypeApplicationError < ::RBS::DefinitionError
+  # @return [InvalidTypeApplicationError] a new instance of InvalidTypeApplicationError
+  #
+  # source://rbs//lib/rbs/errors.rb#74
+  def initialize(type_name:, args:, params:, location:); end
+
+  # Returns the value of attribute args.
+  #
+  # source://rbs//lib/rbs/errors.rb#69
+  def args; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/errors.rb#72
+  def location; end
+
+  # Returns the value of attribute params.
+  #
+  # source://rbs//lib/rbs/errors.rb#70
+  def params; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#68
+  def type_name; end
+
+  # Returns the value of attribute type_params.
+  #
+  # source://rbs//lib/rbs/errors.rb#71
+  def type_params; end
+
+  class << self
+    # source://rbs//lib/rbs/errors.rb#83
+    def check!(type_name:, args:, params:, location:); end
+
+    # source://rbs//lib/rbs/errors.rb#92
+    def check2!(env:, type_name:, args:, location:); end
+  end
+end
+
+# source://rbs//lib/rbs/errors.rb#407
+class RBS::InvalidVarianceAnnotationError < ::RBS::DefinitionError
+  include ::RBS::DetailedMessageable
+
+  # @return [InvalidVarianceAnnotationError] a new instance of InvalidVarianceAnnotationError
+  #
+  # source://rbs//lib/rbs/errors.rb#414
+  def initialize(type_name:, param:, location:); end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/errors.rb#412
+  def location; end
+
+  # Returns the value of attribute param.
+  #
+  # source://rbs//lib/rbs/errors.rb#411
+  def param; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#410
+  def type_name; end
+end
+
+# source://rbs//lib/rbs/errors.rb#20
+class RBS::LoadingError < ::RBS::BaseError; end
+
+# source://rbs//lib/rbs/location_aux.rb#4
+class RBS::Location
+  def initialize(_arg0, _arg1, _arg2); end
+
+  # source://rbs//lib/rbs/location_aux.rb#71
+  def ==(other); end
+
+  def [](_arg0); end
+  def _add_optional_child(_arg0, _arg1, _arg2); end
+  def _add_optional_no_child(_arg0); end
+  def _add_required_child(_arg0, _arg1, _arg2); end
+  def _optional_keys; end
+  def _required_keys; end
+
+  # source://rbs//lib/rbs/location_aux.rb#102
+  def add_optional_child(name, range); end
+
+  # source://rbs//lib/rbs/location_aux.rb#98
+  def add_required_child(name, range); end
+
+  def aref(_arg0); end
+  def buffer; end
+
+  # source://rbs//lib/rbs/location_aux.rb#110
+  def each_optional_key(&block); end
+
+  # source://rbs//lib/rbs/location_aux.rb#118
+  def each_required_key(&block); end
+
+  # source://rbs//lib/rbs/location_aux.rb#47
+  def end_column; end
+
+  # source://rbs//lib/rbs/location_aux.rb#43
+  def end_line; end
+
+  # source://rbs//lib/rbs/location_aux.rb#55
+  def end_loc; end
+
+  def end_pos; end
+
+  # source://rbs//lib/rbs/location_aux.rb#5
+  def inspect; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/location_aux.rb#126
+  def key?(name); end
+
+  # source://rbs//lib/rbs/location_aux.rb#31
+  def name; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/location_aux.rb#130
+  def optional_key?(name); end
+
+  # source://rbs//lib/rbs/location_aux.rb#59
+  def range; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/location_aux.rb#134
+  def required_key?(name); end
+
+  # source://rbs//lib/rbs/location_aux.rb#63
+  def source; end
+
+  # source://rbs//lib/rbs/location_aux.rb#39
+  def start_column; end
+
+  # source://rbs//lib/rbs/location_aux.rb#35
+  def start_line; end
+
+  # source://rbs//lib/rbs/location_aux.rb#51
+  def start_loc; end
+
+  def start_pos; end
+
+  # source://rbs//lib/rbs/location_aux.rb#78
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/location_aux.rb#67
+  def to_s; end
+
+  private
+
+  def initialize_copy(_arg0); end
+
+  class << self
+    # source://rbs//lib/rbs/location_aux.rb#16
+    def new(buffer_ = T.unsafe(nil), start_pos_ = T.unsafe(nil), end_pos_ = T.unsafe(nil), buffer: T.unsafe(nil), start_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
+
+    # source://rbs//lib/rbs/location_aux.rb#94
+    def to_string(location, default: T.unsafe(nil)); end
+  end
+end
+
+# source://rbs//lib/rbs/location_aux.rb#29
+RBS::Location::WithChildren = RBS::Location
+
+# source://rbs//lib/rbs/locator.rb#4
+class RBS::Locator
+  # @return [Locator] a new instance of Locator
+  #
+  # source://rbs//lib/rbs/locator.rb#7
+  def initialize(buffer:, dirs:, decls:); end
+
+  # Returns the value of attribute buffer.
+  #
+  # source://rbs//lib/rbs/locator.rb#5
+  def buffer; end
+
+  # Returns the value of attribute decls.
+  #
+  # source://rbs//lib/rbs/locator.rb#5
+  def decls; end
+
+  # Returns the value of attribute dirs.
+  #
+  # source://rbs//lib/rbs/locator.rb#5
+  def dirs; end
+
+  # source://rbs//lib/rbs/locator.rb#13
+  def find(line:, column:); end
+
+  # source://rbs//lib/rbs/locator.rb#29
+  def find2(line:, column:); end
+
+  # source://rbs//lib/rbs/locator.rb#58
+  def find_in_decl(pos, decl:, array:); end
+
+  # source://rbs//lib/rbs/locator.rb#42
+  def find_in_directive(pos, dir, array); end
+
+  # source://rbs//lib/rbs/locator.rb#206
+  def find_in_loc(pos, location:, array:); end
+
+  # source://rbs//lib/rbs/locator.rb#129
+  def find_in_member(pos, member:, array:); end
+
+  # source://rbs//lib/rbs/locator.rb#152
+  def find_in_method_type(pos, method_type:, array:); end
+
+  # source://rbs//lib/rbs/locator.rb#190
+  def find_in_type(pos, type:, array:); end
+
+  # source://rbs//lib/rbs/locator.rb#170
+  def find_in_type_param(pos, type_param:, array:); end
+
+  # source://rbs//lib/rbs/locator.rb#233
+  def test_loc(pos, location:); end
+end
+
+# source://rbs//lib/rbs/errors.rb#4
+module RBS::MethodNameHelper
+  # source://rbs//lib/rbs/errors.rb#5
+  def method_name_string; end
+end
+
+# source://rbs//lib/rbs/method_type.rb#4
+class RBS::MethodType
+  # @return [MethodType] a new instance of MethodType
+  #
+  # source://rbs//lib/rbs/method_type.rb#10
+  def initialize(type_params:, type:, block:, location:); end
+
+  # source://rbs//lib/rbs/method_type.rb#17
+  def ==(other); end
+
+  # Returns the value of attribute block.
+  #
+  # source://rbs//lib/rbs/method_type.rb#7
+  def block; end
+
+  # source://rbs//lib/rbs/method_type.rb#84
+  def each_type(&block); end
+
+  # source://rbs//lib/rbs/method_type.rb#57
+  def free_variables(set = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/method_type.rb#125
+  def has_classish_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/method_type.rb#121
+  def has_self_type?; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/method_type.rb#8
+  def location; end
+
+  # source://rbs//lib/rbs/method_type.rb#63
+  def map_type(&block); end
+
+  # source://rbs//lib/rbs/method_type.rb#72
+  def map_type_bound(&block); end
+
+  # source://rbs//lib/rbs/method_type.rb#33
+  def sub(s); end
+
+  # source://rbs//lib/rbs/method_type.rb#24
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/method_type.rb#98
+  def to_s; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/method_type.rb#6
+  def type; end
+
+  # source://rbs//lib/rbs/method_type.rb#117
+  def type_param_names; end
+
+  # Returns the value of attribute type_params.
+  #
+  # source://rbs//lib/rbs/method_type.rb#5
+  def type_params; end
+
+  # source://rbs//lib/rbs/method_type.rb#48
+  def update(type_params: T.unsafe(nil), type: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/method_type.rb#129
+  def with_nonreturn_void?; end
+end
+
+# source://rbs//lib/rbs/errors.rb#443
+class RBS::MixinClassError < ::RBS::DefinitionError
+  include ::RBS::DetailedMessageable
+
+  # @return [MixinClassError] a new instance of MixinClassError
+  #
+  # source://rbs//lib/rbs/errors.rb#449
+  def initialize(type_name:, member:); end
+
+  # source://rbs//lib/rbs/errors.rb#456
+  def location; end
+
+  # Returns the value of attribute member.
+  #
+  # source://rbs//lib/rbs/errors.rb#447
+  def member; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#446
+  def type_name; end
+
+  private
+
+  # source://rbs//lib/rbs/errors.rb#468
+  def mixin_name; end
+
+  class << self
+    # source://rbs//lib/rbs/errors.rb#460
+    def check!(type_name:, env:, member:); end
+  end
+end
+
+# source://rbs//lib/rbs/namespace.rb#4
+class RBS::Namespace
+  # @return [Namespace] a new instance of Namespace
+  #
+  # source://rbs//lib/rbs/namespace.rb#7
+  def initialize(path:, absolute:); end
+
+  # source://rbs//lib/rbs/namespace.rb#20
+  def +(other); end
+
+  # source://rbs//lib/rbs/namespace.rb#59
+  def ==(other); end
+
+  # source://rbs//lib/rbs/namespace.rb#47
+  def absolute!; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/namespace.rb#39
+  def absolute?; end
+
+  # source://rbs//lib/rbs/namespace.rb#28
+  def append(component); end
+
+  # source://rbs//lib/rbs/namespace.rb#101
+  def ascend; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/namespace.rb#55
+  def empty?; end
+
+  # source://rbs//lib/rbs/namespace.rb#59
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/namespace.rb#65
+  def hash; end
+
+  # source://rbs//lib/rbs/namespace.rb#32
+  def parent; end
+
+  # Returns the value of attribute path.
+  #
+  # source://rbs//lib/rbs/namespace.rb#5
+  def path; end
+
+  # source://rbs//lib/rbs/namespace.rb#51
+  def relative!; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/namespace.rb#43
+  def relative?; end
+
+  # source://rbs//lib/rbs/namespace.rb#69
+  def split; end
+
+  # source://rbs//lib/rbs/namespace.rb#75
+  def to_s; end
+
+  # source://rbs//lib/rbs/namespace.rb#84
+  def to_type_name; end
+
+  class << self
+    # source://rbs//lib/rbs/namespace.rb#12
+    def empty; end
+
+    # source://rbs//lib/rbs/namespace.rb#93
+    def parse(string); end
+
+    # source://rbs//lib/rbs/namespace.rb#16
+    def root; end
+  end
+end
+
+# source://rbs//lib/rbs/errors.rb#229
+class RBS::NoMixinFoundError < ::RBS::DefinitionError
+  include ::RBS::DetailedMessageable
+
+  # @return [NoMixinFoundError] a new instance of NoMixinFoundError
+  #
+  # source://rbs//lib/rbs/errors.rb#235
+  def initialize(type_name:, member:); end
+
+  # source://rbs//lib/rbs/errors.rb#242
+  def location; end
+
+  # Returns the value of attribute member.
+  #
+  # source://rbs//lib/rbs/errors.rb#233
+  def member; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#232
+  def type_name; end
+
+  class << self
+    # source://rbs//lib/rbs/errors.rb#246
+    def check!(type_name, env:, member:); end
+  end
+end
+
+# source://rbs//lib/rbs/errors.rb#210
+class RBS::NoSelfTypeFoundError < ::RBS::DefinitionError
+  include ::RBS::DetailedMessageable
+
+  # @return [NoSelfTypeFoundError] a new instance of NoSelfTypeFoundError
+  #
+  # source://rbs//lib/rbs/errors.rb#216
+  def initialize(type_name:, location:); end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/errors.rb#214
+  def location; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#213
+  def type_name; end
+
+  class << self
+    # source://rbs//lib/rbs/errors.rb#223
+    def check!(self_type, env:); end
+  end
+end
+
+# source://rbs//lib/rbs/errors.rb#167
+class RBS::NoSuperclassFoundError < ::RBS::DefinitionError
+  # @return [NoSuperclassFoundError] a new instance of NoSuperclassFoundError
+  #
+  # source://rbs//lib/rbs/errors.rb#171
+  def initialize(type_name:, location:); end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/errors.rb#169
+  def location; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#168
+  def type_name; end
+
+  class << self
+    # source://rbs//lib/rbs/errors.rb#178
+    def check!(type_name, env:, location:); end
+  end
+end
+
+# source://rbs//lib/rbs/errors.rb#148
+class RBS::NoTypeFoundError < ::RBS::DefinitionError
+  include ::RBS::DetailedMessageable
+
+  # @return [NoTypeFoundError] a new instance of NoTypeFoundError
+  #
+  # source://rbs//lib/rbs/errors.rb#154
+  def initialize(type_name:, location:); end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/errors.rb#152
+  def location; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#151
+  def type_name; end
+
+  class << self
+    # source://rbs//lib/rbs/errors.rb#161
+    def check!(type_name, env:, location:); end
+  end
+end
+
+# source://rbs//lib/rbs/errors.rb#500
+class RBS::NonregularTypeAliasError < ::RBS::BaseError
+  include ::RBS::DetailedMessageable
+
+  # @return [NonregularTypeAliasError] a new instance of NonregularTypeAliasError
+  #
+  # source://rbs//lib/rbs/errors.rb#506
+  def initialize(diagnostic:, location:); end
+
+  # Returns the value of attribute diagnostic.
+  #
+  # source://rbs//lib/rbs/errors.rb#503
+  def diagnostic; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/errors.rb#504
+  def location; end
+end
+
+# source://rbs//lib/rbs/parser/lex_result.rb#4
+class RBS::Parser
+  class << self
+    def _lex(_arg0, _arg1); end
+    def _parse_method_type(_arg0, _arg1, _arg2, _arg3, _arg4); end
+    def _parse_signature(_arg0, _arg1); end
+    def _parse_type(_arg0, _arg1, _arg2, _arg3, _arg4); end
+
+    # source://rbs//lib/rbs/parser_aux.rb#34
+    def buffer(source); end
+
+    # source://rbs//lib/rbs/parser_aux.rb#25
+    def lex(source); end
+
+    # source://rbs//lib/rbs/parser_aux.rb#13
+    def parse_method_type(source, range: T.unsafe(nil), variables: T.unsafe(nil), require_eof: T.unsafe(nil)); end
+
+    # source://rbs//lib/rbs/parser_aux.rb#18
+    def parse_signature(source); end
+
+    # source://rbs//lib/rbs/parser_aux.rb#8
+    def parse_type(source, range: T.unsafe(nil), variables: T.unsafe(nil), require_eof: T.unsafe(nil)); end
+  end
+end
+
+# source://rbs//lib/rbs/parser_aux.rb#43
+RBS::Parser::KEYWORDS = T.let(T.unsafe(nil), Hash)
+
+# source://rbs//lib/rbs/parser/lex_result.rb#5
+class RBS::Parser::LexResult
+  # @return [LexResult] a new instance of LexResult
+  #
+  # source://rbs//lib/rbs/parser/lex_result.rb#9
+  def initialize(buffer:, value:); end
+
+  # Returns the value of attribute buffer.
+  #
+  # source://rbs//lib/rbs/parser/lex_result.rb#6
+  def buffer; end
+
+  # Returns the value of attribute value.
+  #
+  # source://rbs//lib/rbs/parser/lex_result.rb#7
+  def value; end
+end
+
+# source://rbs//lib/rbs/parser/token.rb#5
+class RBS::Parser::Token
+  # @return [Token] a new instance of Token
+  #
+  # source://rbs//lib/rbs/parser/token.rb#9
+  def initialize(type:, location:); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/parser/token.rb#18
+  def comment?; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/parser/token.rb#7
+  def location; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/parser/token.rb#6
+  def type; end
+
+  # source://rbs//lib/rbs/parser/token.rb#14
+  def value; end
+end
+
+# source://rbs//lib/rbs/errors.rb#51
+class RBS::ParsingError < ::RBS::BaseError
+  include ::RBS::DetailedMessageable
+
+  # @return [ParsingError] a new instance of ParsingError
+  #
+  # source://rbs//lib/rbs/errors.rb#58
+  def initialize(location, error_message, token_type); end
+
+  # Returns the value of attribute error_message.
+  #
+  # source://rbs//lib/rbs/errors.rb#55
+  def error_message; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/errors.rb#54
+  def location; end
+
+  # Returns the value of attribute token_type.
+  #
+  # source://rbs//lib/rbs/errors.rb#56
+  def token_type; end
+end
+
+# source://rbs//lib/rbs/prototype/helpers.rb#4
+module RBS::Prototype; end
+
+# source://rbs//lib/rbs/prototype/helpers.rb#5
+module RBS::Prototype::Helpers
+  private
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/prototype/helpers.rb#96
+  def any_node?(node, nodes: T.unsafe(nil), &block); end
+
+  # NOTE: args_node may be a nil by a bug
+  #       https://bugs.ruby-lang.org/issues/17495
+  #
+  # source://rbs//lib/rbs/prototype/helpers.rb#120
+  def args_from_node(args_node); end
+
+  # source://rbs//lib/rbs/prototype/helpers.rb#8
+  def block_from_body(node); end
+
+  # source://rbs//lib/rbs/prototype/helpers.rb#84
+  def each_child(node, &block); end
+
+  # source://rbs//lib/rbs/prototype/helpers.rb#88
+  def each_node(nodes); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/prototype/helpers.rb#108
+  def keyword_hash?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/prototype/helpers.rb#124
+  def symbol_literal_node?(node); end
+
+  # source://rbs//lib/rbs/prototype/helpers.rb#135
+  def untyped; end
+end
+
+# source://rbs//lib/rbs/prototype/node_usage.rb#5
+class RBS::Prototype::NodeUsage
+  include ::RBS::Prototype::Helpers
+
+  # @return [NodeUsage] a new instance of NodeUsage
+  #
+  # source://rbs//lib/rbs/prototype/node_usage.rb#10
+  def initialize(node); end
+
+  # source://rbs//lib/rbs/prototype/node_usage.rb#25
+  def calculate(node, conditional:); end
+
+  # Returns the value of attribute conditional_nodes.
+  #
+  # source://rbs//lib/rbs/prototype/node_usage.rb#8
+  def conditional_nodes; end
+
+  # source://rbs//lib/rbs/prototype/node_usage.rb#17
+  def each_conditional_node(&block); end
+end
+
+# source://rbs//lib/rbs/prototype/rb.rb#5
+class RBS::Prototype::RB
+  include ::RBS::Prototype::Helpers
+
+  # @return [RB] a new instance of RB
+  #
+  # source://rbs//lib/rbs/prototype/rb.rb#45
+  def initialize; end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#556
+  def block_type(node); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#536
+  def body_type(node); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#451
+  def const_to_name(node, context:); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#432
+  def const_to_name!(node); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#764
+  def current_accessibility(decls, index = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#49
+  def decls; end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#804
+  def find_def_index_by_name(decls, name); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#531
+  def function_return_type_from_body(node); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#473
+  def function_type_from_body(node, def_name); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#549
+  def if_unless_type(node); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/prototype/rb.rb#800
+  def is_accessibility?(decl); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#462
+  def literal_to_symbol(node); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#570
+  def literal_to_type(node); end
+
+  # backward compatible
+  #
+  # source://rbs//lib/rbs/prototype/rb.rb#711
+  def node_type(node, default: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#711
+  def param_type(node, default: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#75
+  def parse(string); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#756
+  def private; end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#107
+  def process(node, decls:, comments:, context:); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#426
+  def process_children(node, decls:, comments:, context:); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#760
+  def public; end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#691
+  def range_element_type(types); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#774
+  def remove_unnecessary_accessibility_methods!(decls); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#822
+  def sort_members!(decls); end
+
+  # Returns the value of attribute source_decls.
+  #
+  # source://rbs//lib/rbs/prototype/rb.rb#42
+  def source_decls; end
+
+  # Returns the value of attribute toplevel_members.
+  #
+  # source://rbs//lib/rbs/prototype/rb.rb#43
+  def toplevel_members; end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#680
+  def types_to_union_type(types); end
+end
+
+# source://rbs//lib/rbs/prototype/rb.rb#8
+class RBS::Prototype::RB::Context < ::Struct
+  # source://rbs//lib/rbs/prototype/rb.rb#25
+  def attribute_kind; end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#33
+  def enter_namespace(namespace); end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#15
+  def method_kind; end
+
+  # source://rbs//lib/rbs/prototype/rb.rb#37
+  def update(module_function: T.unsafe(nil), singleton: T.unsafe(nil), in_def: T.unsafe(nil)); end
+
+  class << self
+    # source://rbs//lib/rbs/prototype/rb.rb#11
+    def initial(namespace: T.unsafe(nil)); end
+  end
+end
+
+# source://rbs//lib/rbs/prototype/rbi.rb#5
+class RBS::Prototype::RBI
+  include ::RBS::Prototype::Helpers
+
+  # @return [RBI] a new instance of RBI
+  #
+  # source://rbs//lib/rbs/prototype/rbi.rb#12
+  def initialize; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/prototype/rbi.rb#557
+  def call_node?(node, name:, receiver: T.unsafe(nil), args: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#561
+  def const_to_name(node); end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#92
+  def current_module; end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#96
+  def current_module!; end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#48
+  def current_namespace; end
+
+  # Returns the value of attribute decls.
+  #
+  # source://rbs//lib/rbs/prototype/rbi.rb#8
+  def decls; end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#597
+  def each_arg(array, &block); end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#611
+  def each_child(node); end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#114
+  def join_comments(nodes, comments); end
+
+  # Returns the value of attribute last_sig.
+  #
+  # source://rbs//lib/rbs/prototype/rbi.rb#10
+  def last_sig; end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#281
+  def method_type(args_node, type_node, variables:, overloads:); end
+
+  # Returns the value of attribute modules.
+  #
+  # source://rbs//lib/rbs/prototype/rbi.rb#9
+  def modules; end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#44
+  def nested_name(name); end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#619
+  def node_to_hash(node); end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#18
+  def parse(string); end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#347
+  def parse_params(args_node, args, method_type, variables:, overloads:); end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#108
+  def pop_sig; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/prototype/rbi.rb#549
+  def proc_type?(type_node); end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#119
+  def process(node, comments:, outer: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#54
+  def push_class(name, super_class, comment:); end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#73
+  def push_module(name, comment:); end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#100
+  def push_sig(node); end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#472
+  def type_of(type_node, variables:); end
+
+  # source://rbs//lib/rbs/prototype/rbi.rb#485
+  def type_of0(type_node, variables:); end
+end
+
+# source://rbs//lib/rbs/prototype/runtime/helpers.rb#5
+class RBS::Prototype::Runtime
+  include ::RBS::Prototype::Helpers
+  include ::RBS::Prototype::Runtime::Helpers
+
+  # @return [Runtime] a new instance of Runtime
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#70
+  def initialize(patterns:, env:, merge:, todo: T.unsafe(nil), owners_included: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#650
+  def block_from_ast_of(method); end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#100
+  def builder; end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#108
+  def decls; end
+
+  # Generate/find outer module declarations
+  # This is broken down into another method to comply with `DRY`
+  # This generates/finds declarations in nested form & returns the last array of declarations
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#579
+  def ensure_outer_module_declarations(mod); end
+
+  # Returns the value of attribute env.
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#64
+  def env; end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#484
+  def generate_class(mod); end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#422
+  def generate_constants(mod, decls); end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#298
+  def generate_methods(mod, module_name, members); end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#561
+  def generate_mixin(mod, decl, type_name, type_name_absolute); end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#523
+  def generate_module(mod); end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#469
+  def generate_super_class(mod); end
+
+  # Returns the value of attribute merge.
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#65
+  def merge; end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#239
+  def merge_rbs(module_name, members, instance: T.unsafe(nil), singleton: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#170
+  def method_type(method); end
+
+  # Returns the value of attribute outline.
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#68
+  def outline; end
+
+  # Sets the attribute outline
+  #
+  # @param value the value to set the attribute outline to.
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#68
+  def outline=(_arg0); end
+
+  # Returns the value of attribute owners_included.
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#67
+  def owners_included; end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#104
+  def parse(file); end
+
+  # Returns the value of attribute patterns.
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#63
+  def patterns; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#83
+  def target?(const); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#285
+  def target_method?(mod, instance: T.unsafe(nil), singleton: T.unsafe(nil)); end
+
+  # Returns the value of attribute todo.
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#66
+  def todo; end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#96
+  def todo_object; end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#633
+  def type_args(type_name); end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#641
+  def type_params(mod); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#412
+  def can_alias?(mod, method); end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#128
+  def each_mixined_module(type_name, mod); end
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#137
+  def each_mixined_module_one(type_name, mod); end
+end
+
+# source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#211
+class RBS::Prototype::Runtime::DataGenerator < ::RBS::Prototype::Runtime::ValueObjectBase
+  private
+
+  # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#227
+  def add_decl_members(decl); end
+
+  # def self.new: (untyped foo, untyped bar) -> instance
+  #             | (foo: untyped, bar: untyped) -> instance
+  #
+  # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#235
+  def build_s_new; end
+
+  # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#223
+  def build_super_class; end
+
+  class << self
+    # @return [Boolean]
+    #
+    # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#212
+    def generatable?(target); end
+  end
+end
+
+# source://rbs//lib/rbs/prototype/runtime/helpers.rb#6
+module RBS::Prototype::Runtime::Helpers
+  private
+
+  # source://rbs//lib/rbs/prototype/runtime/helpers.rb#19
+  def const_name(const); end
+
+  # source://rbs//lib/rbs/prototype/runtime/helpers.rb#15
+  def const_name!(const); end
+
+  # Returns the exact name & not compactly declared name
+  #
+  # source://rbs//lib/rbs/prototype/runtime/helpers.rb#10
+  def only_name(mod); end
+
+  # source://rbs//lib/rbs/prototype/runtime/helpers.rb#37
+  def to_type_name(name, full_name: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/prototype/runtime/helpers.rb#53
+  def untyped; end
+end
+
+# source://rbs//lib/rbs/prototype/runtime/reflection.rb#6
+module RBS::Prototype::Runtime::Reflection
+  class << self
+    # source://rbs//lib/rbs/prototype/runtime/reflection.rb#12
+    def constants_of(mod, inherit = T.unsafe(nil)); end
+
+    # source://rbs//lib/rbs/prototype/runtime/reflection.rb#7
+    def object_class(value); end
+  end
+end
+
+# source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#89
+class RBS::Prototype::Runtime::StructGenerator < ::RBS::Prototype::Runtime::ValueObjectBase
+  private
+
+  # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#106
+  def add_decl_members(decl); end
+
+  # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#163
+  def build_overload_for_keyword_arguments; end
+
+  # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#149
+  def build_overload_for_positional_arguments; end
+
+  # def self.keyword_init?: () -> bool?
+  #
+  # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#178
+  def build_s_keyword_init_p; end
+
+  # def self.new: (?untyped foo, ?untyped bar) -> instance
+  #             | (?foo: untyped, ?bar: untyped) -> instance
+  #
+  # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#115
+  def build_s_new; end
+
+  # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#102
+  def build_super_class; end
+
+  class << self
+    # @return [Boolean]
+    #
+    # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#90
+    def generatable?(target); end
+  end
+end
+
+# source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#100
+RBS::Prototype::Runtime::StructGenerator::CAN_CALL_KEYWORD_INIT_P = T.let(T.unsafe(nil), TrueClass)
+
+# source://rbs//lib/rbs/prototype/runtime.rb#10
+class RBS::Prototype::Runtime::Todo
+  # @return [Todo] a new instance of Todo
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#11
+  def initialize(builder:); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#42
+  def skip_constant?(module_name:, name:); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#33
+  def skip_instance_method?(module_name:, method:, accessibility:); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#15
+  def skip_mixin?(type_name:, module_name:, mixin_class:); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/prototype/runtime.rb#24
+  def skip_singleton_method?(module_name:, method:, accessibility:); end
+
+  private
+
+  # source://rbs//lib/rbs/prototype/runtime.rb#49
+  def mixin_decls(type_name); end
+end
+
+# source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#8
+class RBS::Prototype::Runtime::ValueObjectBase
+  include ::RBS::Prototype::Runtime::Helpers
+
+  # @return [ValueObjectBase] a new instance of ValueObjectBase
+  #
+  # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#11
+  def initialize(target_class); end
+
+  # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#15
+  def build_decl; end
+
+  private
+
+  # attr_accessor foo: untyped
+  #
+  # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#74
+  def build_member_accessors(ast_members_class); end
+
+  # def self.members: () -> [ :foo, :bar ]
+  # def members: () -> [ :foo, :bar ]
+  #
+  # source://rbs//lib/rbs/prototype/runtime/value_object_generator.rb#35
+  def build_s_members; end
+end
+
+# source://rbs//lib/rdoc_plugin/parser.rb#6
+module RBS::RDocPlugin; end
+
+# source://rbs//lib/rdoc_plugin/parser.rb#7
+class RBS::RDocPlugin::Parser
+  # @return [Parser] a new instance of Parser
+  #
+  # source://rbs//lib/rdoc_plugin/parser.rb#11
+  def initialize(top_level, content); end
+
+  # Returns the value of attribute content.
+  #
+  # source://rbs//lib/rdoc_plugin/parser.rb#9
+  def content; end
+
+  # Sets the attribute content
+  #
+  # @param value the value to set the attribute content to.
+  #
+  # source://rbs//lib/rdoc_plugin/parser.rb#9
+  def content=(_arg0); end
+
+  # source://rbs//lib/rdoc_plugin/parser.rb#94
+  def parse_attr_decl(decl:, context:, outer_name: T.unsafe(nil)); end
+
+  # source://rbs//lib/rdoc_plugin/parser.rb#53
+  def parse_class_decl(decl:, context:, outer_name: T.unsafe(nil)); end
+
+  # source://rbs//lib/rdoc_plugin/parser.rb#67
+  def parse_constant_decl(decl:, context:, outer_name: T.unsafe(nil)); end
+
+  # source://rbs//lib/rdoc_plugin/parser.rb#125
+  def parse_extend_decl(decl:, context:, outer_name: T.unsafe(nil)); end
+
+  # source://rbs//lib/rdoc_plugin/parser.rb#109
+  def parse_include_decl(decl:, context:, outer_name: T.unsafe(nil)); end
+
+  # source://rbs//lib/rdoc_plugin/parser.rb#24
+  def parse_member(decl:, context:, outer_name: T.unsafe(nil)); end
+
+  # source://rbs//lib/rdoc_plugin/parser.rb#88
+  def parse_method_alias_decl(decl:, context:, outer_name: T.unsafe(nil)); end
+
+  # source://rbs//lib/rdoc_plugin/parser.rb#73
+  def parse_method_decl(decl:, context:, outer_name: T.unsafe(nil)); end
+
+  # source://rbs//lib/rdoc_plugin/parser.rb#60
+  def parse_module_decl(decl:, context:, outer_name: T.unsafe(nil)); end
+
+  # source://rbs//lib/rdoc_plugin/parser.rb#16
+  def scan; end
+
+  # Returns the value of attribute top_level.
+  #
+  # source://rbs//lib/rdoc_plugin/parser.rb#9
+  def top_level; end
+
+  # Sets the attribute top_level
+  #
+  # @param value the value to set the attribute top_level to.
+  #
+  # source://rbs//lib/rdoc_plugin/parser.rb#9
+  def top_level=(_arg0); end
+
+  private
+
+  # source://rbs//lib/rdoc_plugin/parser.rb#149
+  def comment_string(with_comment); end
+
+  # source://rbs//lib/rdoc_plugin/parser.rb#143
+  def construct_comment(context:, comment:); end
+
+  # source://rbs//lib/rdoc_plugin/parser.rb#154
+  def fully_qualified_name(outer_name:, decl:); end
+end
+
+# source://rbs//lib/rbs/errors.rb#423
+class RBS::RecursiveAliasDefinitionError < ::RBS::DefinitionError
+  include ::RBS::DetailedMessageable
+
+  # @return [RecursiveAliasDefinitionError] a new instance of RecursiveAliasDefinitionError
+  #
+  # source://rbs//lib/rbs/errors.rb#429
+  def initialize(type:, defs:); end
+
+  # Returns the value of attribute defs.
+  #
+  # source://rbs//lib/rbs/errors.rb#427
+  def defs; end
+
+  # source://rbs//lib/rbs/errors.rb#436
+  def location; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/errors.rb#426
+  def type; end
+end
+
+# source://rbs//lib/rbs/errors.rb#110
+class RBS::RecursiveAncestorError < ::RBS::DefinitionError
+  # @return [RecursiveAncestorError] a new instance of RecursiveAncestorError
+  #
+  # source://rbs//lib/rbs/errors.rb#114
+  def initialize(ancestors:, location:); end
+
+  # Returns the value of attribute ancestors.
+  #
+  # source://rbs//lib/rbs/errors.rb#111
+  def ancestors; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/errors.rb#112
+  def location; end
+
+  class << self
+    # source://rbs//lib/rbs/errors.rb#134
+    def check!(self_ancestor, ancestors:, location:); end
+  end
+end
+
+# source://rbs//lib/rbs/errors.rb#482
+class RBS::RecursiveTypeAliasError < ::RBS::BaseError
+  include ::RBS::DetailedMessageable
+
+  # @return [RecursiveTypeAliasError] a new instance of RecursiveTypeAliasError
+  #
+  # source://rbs//lib/rbs/errors.rb#488
+  def initialize(alias_names:, location:); end
+
+  # Returns the value of attribute alias_names.
+  #
+  # source://rbs//lib/rbs/errors.rb#485
+  def alias_names; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/errors.rb#486
+  def location; end
+
+  # source://rbs//lib/rbs/errors.rb#495
+  def name; end
+end
+
+# source://rbs//lib/rbs/repository.rb#4
+class RBS::Repository
+  # @return [Repository] a new instance of Repository
+  #
+  # source://rbs//lib/rbs/repository.rb#74
+  def initialize(no_stdlib: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/repository.rb#98
+  def add(dir); end
+
+  # Returns the value of attribute dirs.
+  #
+  # source://rbs//lib/rbs/repository.rb#71
+  def dirs; end
+
+  # Returns the value of attribute gems.
+  #
+  # source://rbs//lib/rbs/repository.rb#72
+  def gems; end
+
+  # source://rbs//lib/rbs/repository.rb#108
+  def lookup(gem, version); end
+
+  # source://rbs//lib/rbs/repository.rb#113
+  def lookup_path(gem, version); end
+
+  class << self
+    # source://rbs//lib/rbs/repository.rb#83
+    def default; end
+
+    # source://rbs//lib/rbs/repository.rb#87
+    def find_best_version(version, candidates); end
+  end
+end
+
+# source://rbs//lib/rbs/repository.rb#5
+RBS::Repository::DEFAULT_STDLIB_ROOT = T.let(T.unsafe(nil), Pathname)
+
+# source://rbs//lib/rbs/repository.rb#7
+class RBS::Repository::GemRBS
+  # @return [GemRBS] a new instance of GemRBS
+  #
+  # source://rbs//lib/rbs/repository.rb#11
+  def initialize(name:); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/repository.rb#64
+  def empty?; end
+
+  # source://rbs//lib/rbs/repository.rb#59
+  def find_best_version(version); end
+
+  # source://rbs//lib/rbs/repository.rb#54
+  def latest_version; end
+
+  # source://rbs//lib/rbs/repository.rb#22
+  def load!; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/repository.rb#8
+  def name; end
+
+  # source://rbs//lib/rbs/repository.rb#49
+  def oldest_version; end
+
+  # Returns the value of attribute paths.
+  #
+  # source://rbs//lib/rbs/repository.rb#9
+  def paths; end
+
+  # source://rbs//lib/rbs/repository.rb#45
+  def version_names; end
+
+  # source://rbs//lib/rbs/repository.rb#17
+  def versions; end
+end
+
+# source://rbs//lib/rbs/repository.rb#69
+class RBS::Repository::VersionPath < ::Struct
+  def gem; end
+  def gem=(_); end
+  def path; end
+  def path=(_); end
+  def version; end
+  def version=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rbs//lib/rbs/resolver/constant_resolver.rb#4
+module RBS::Resolver; end
+
+# source://rbs//lib/rbs/resolver/constant_resolver.rb#5
+class RBS::Resolver::ConstantResolver
+  # @return [ConstantResolver] a new instance of ConstantResolver
+  #
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#88
+  def initialize(builder:); end
+
+  # Returns the value of attribute builder.
+  #
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#85
+  def builder; end
+
+  # Returns the value of attribute child_constants_cache.
+  #
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#86
+  def child_constants_cache; end
+
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#112
+  def children(module_name); end
+
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#100
+  def constants(context); end
+
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#178
+  def constants_from_ancestors(module_name, constants:); end
+
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#163
+  def constants_from_context(context, constants:); end
+
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#201
+  def constants_itself(context, constants:); end
+
+  # Returns the value of attribute context_constants_cache.
+  #
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#86
+  def context_constants_cache; end
+
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#138
+  def load_child_constants(name); end
+
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#122
+  def load_context_constants(context); end
+
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#95
+  def resolve(name, context:); end
+
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#108
+  def resolve_child(module_name, name); end
+
+  # Returns the value of attribute table.
+  #
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#85
+  def table; end
+end
+
+# source://rbs//lib/rbs/resolver/constant_resolver.rb#6
+class RBS::Resolver::ConstantResolver::Table
+  # @return [Table] a new instance of Table
+  #
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#10
+  def initialize(environment); end
+
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#63
+  def children(name); end
+
+  # Returns the value of attribute children_table.
+  #
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#7
+  def children_table; end
+
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#67
+  def constant(name); end
+
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#80
+  def constant_of_constant(name, entry); end
+
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#71
+  def constant_of_module(name, entry); end
+
+  # Returns the value of attribute constants_table.
+  #
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#8
+  def constants_table; end
+
+  # Returns the value of attribute toplevel.
+  #
+  # source://rbs//lib/rbs/resolver/constant_resolver.rb#7
+  def toplevel; end
+end
+
+# source://rbs//lib/rbs/resolver/type_name_resolver.rb#5
+class RBS::Resolver::TypeNameResolver
+  # @return [TypeNameResolver] a new instance of TypeNameResolver
+  #
+  # source://rbs//lib/rbs/resolver/type_name_resolver.rb#10
+  def initialize(env); end
+
+  # Returns the value of attribute all_names.
+  #
+  # source://rbs//lib/rbs/resolver/type_name_resolver.rb#6
+  def all_names; end
+
+  # Returns the value of attribute cache.
+  #
+  # source://rbs//lib/rbs/resolver/type_name_resolver.rb#7
+  def cache; end
+
+  # Returns the value of attribute env.
+  #
+  # source://rbs//lib/rbs/resolver/type_name_resolver.rb#8
+  def env; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/resolver/type_name_resolver.rb#84
+  def has_name?(full_name); end
+
+  # source://rbs//lib/rbs/resolver/type_name_resolver.rb#51
+  def partition(type_name); end
+
+  # source://rbs//lib/rbs/resolver/type_name_resolver.rb#28
+  def resolve(type_name, context:); end
+
+  # source://rbs//lib/rbs/resolver/type_name_resolver.rb#69
+  def resolve_in(head, context); end
+
+  # source://rbs//lib/rbs/resolver/type_name_resolver.rb#21
+  def try_cache(query); end
+end
+
+# source://rbs//lib/rbs/substitution.rb#4
+class RBS::Substitution
+  # @return [Substitution] a new instance of Substitution
+  #
+  # source://rbs//lib/rbs/substitution.rb#12
+  def initialize; end
+
+  # source://rbs//lib/rbs/substitution.rb#66
+  def +(other); end
+
+  # source://rbs//lib/rbs/substitution.rb#37
+  def [](ty); end
+
+  # source://rbs//lib/rbs/substitution.rb#16
+  def add(from:, to:); end
+
+  # source://rbs//lib/rbs/substitution.rb#37
+  def apply(ty); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/substitution.rb#8
+  def empty?; end
+
+  # Returns the value of attribute instance_type.
+  #
+  # source://rbs//lib/rbs/substitution.rb#6
+  def instance_type; end
+
+  # Sets the attribute instance_type
+  #
+  # @param value the value to set the attribute instance_type to.
+  #
+  # source://rbs//lib/rbs/substitution.rb#6
+  def instance_type=(_arg0); end
+
+  # Returns the value of attribute mapping.
+  #
+  # source://rbs//lib/rbs/substitution.rb#5
+  def mapping; end
+
+  # source://rbs//lib/rbs/substitution.rb#55
+  def without(*vars); end
+
+  class << self
+    # source://rbs//lib/rbs/substitution.rb#20
+    def build(variables, types, instance_type: T.unsafe(nil), &block); end
+  end
+end
+
+# source://rbs//lib/rbs/subtractor.rb#4
+class RBS::Subtractor
+  # @return [Subtractor] a new instance of Subtractor
+  #
+  # source://rbs//lib/rbs/subtractor.rb#5
+  def initialize(minuend, subtrahend); end
+
+  # source://rbs//lib/rbs/subtractor.rb#10
+  def call(minuend = T.unsafe(nil), context: T.unsafe(nil)); end
+
+  private
+
+  # source://rbs//lib/rbs/subtractor.rb#177
+  def absolute_typename(name, context:); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/subtractor.rb#160
+  def access_modifier?(decl); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/subtractor.rb#118
+  def cvar_exist?(owner, name); end
+
+  # source://rbs//lib/rbs/subtractor.rb#127
+  def each_member(owner, &block); end
+
+  # source://rbs//lib/rbs/subtractor.rb#48
+  def filter_members(decl, context:); end
+
+  # source://rbs//lib/rbs/subtractor.rb#148
+  def filter_redundunt_access_modifiers(decls); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/subtractor.rb#106
+  def ivar_exist?(owner, name, kind); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/subtractor.rb#60
+  def member_exist?(owner, member, context:); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/subtractor.rb#89
+  def method_exist?(owner, method_name, kind); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/subtractor.rb#137
+  def mixin_exist?(owner, mixin, context:); end
+
+  # source://rbs//lib/rbs/subtractor.rb#186
+  def typename_candidates(name, context:); end
+
+  # source://rbs//lib/rbs/subtractor.rb#164
+  def update_decl(decl, members:); end
+end
+
+# source://rbs//lib/rbs/errors.rb#343
+class RBS::SuperclassMismatchError < ::RBS::DefinitionError
+  # @return [SuperclassMismatchError] a new instance of SuperclassMismatchError
+  #
+  # source://rbs//lib/rbs/errors.rb#347
+  def initialize(name:, entry:); end
+
+  # Returns the value of attribute entry.
+  #
+  # source://rbs//lib/rbs/errors.rb#345
+  def entry; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/errors.rb#344
+  def name; end
+end
+
+# source://rbs//lib/rbs/type_alias_dependency.rb#4
+class RBS::TypeAliasDependency
+  # @return [TypeAliasDependency] a new instance of TypeAliasDependency
+  #
+  # source://rbs//lib/rbs/type_alias_dependency.rb#14
+  def initialize(env:); end
+
+  # source://rbs//lib/rbs/type_alias_dependency.rb#27
+  def build_dependencies; end
+
+  # Check if an alias type definition is circular & prohibited
+  #
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/type_alias_dependency.rb#19
+  def circular_definition?(alias_name); end
+
+  # A hash which stores the transitive closure
+  # of the directed graph
+  #
+  # source://rbs//lib/rbs/type_alias_dependency.rb#12
+  def dependencies; end
+
+  # source://rbs//lib/rbs/type_alias_dependency.rb#57
+  def dependencies_of(name); end
+
+  # Direct dependencies corresponds to a directed graph
+  # with vertices as types and directions based on assignment of types
+  #
+  # source://rbs//lib/rbs/type_alias_dependency.rb#9
+  def direct_dependencies; end
+
+  # source://rbs//lib/rbs/type_alias_dependency.rb#52
+  def direct_dependencies_of(name); end
+
+  # Returns the value of attribute env.
+  #
+  # source://rbs//lib/rbs/type_alias_dependency.rb#5
+  def env; end
+
+  # source://rbs//lib/rbs/type_alias_dependency.rb#43
+  def transitive_closure; end
+
+  private
+
+  # Recursive function to construct transitive closure
+  #
+  # source://rbs//lib/rbs/type_alias_dependency.rb#81
+  def dependency(start, vertex, nested = T.unsafe(nil)); end
+
+  # Constructs directed graph recursively
+  #
+  # source://rbs//lib/rbs/type_alias_dependency.rb#65
+  def direct_dependency(type, result = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/type_alias_regularity.rb#4
+class RBS::TypeAliasRegularity
+  # @return [TypeAliasRegularity] a new instance of TypeAliasRegularity
+  #
+  # source://rbs//lib/rbs/type_alias_regularity.rb#16
+  def initialize(env:); end
+
+  # source://rbs//lib/rbs/type_alias_regularity.rb#61
+  def build_alias_type(name); end
+
+  # Returns the value of attribute builder.
+  #
+  # source://rbs//lib/rbs/type_alias_regularity.rb#14
+  def builder; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/type_alias_regularity.rb#69
+  def compatible_args?(args1, args2); end
+
+  # Returns the value of attribute diagnostics.
+  #
+  # source://rbs//lib/rbs/type_alias_regularity.rb#14
+  def diagnostics; end
+
+  # source://rbs//lib/rbs/type_alias_regularity.rb#110
+  def each_alias_type(type, &block); end
+
+  # source://rbs//lib/rbs/type_alias_regularity.rb#83
+  def each_mutual_alias_defs(&block); end
+
+  # Returns the value of attribute env.
+  #
+  # source://rbs//lib/rbs/type_alias_regularity.rb#14
+  def env; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/type_alias_regularity.rb#79
+  def nonregular?(type_name); end
+
+  # source://rbs//lib/rbs/type_alias_regularity.rb#22
+  def validate; end
+
+  # source://rbs//lib/rbs/type_alias_regularity.rb#39
+  def validate_alias_type(alias_type, names, types); end
+
+  class << self
+    # source://rbs//lib/rbs/type_alias_regularity.rb#120
+    def validate(env:); end
+  end
+end
+
+# source://rbs//lib/rbs/type_alias_regularity.rb#5
+class RBS::TypeAliasRegularity::Diagnostic
+  # @return [Diagnostic] a new instance of Diagnostic
+  #
+  # source://rbs//lib/rbs/type_alias_regularity.rb#8
+  def initialize(type_name:, nonregular_type:); end
+
+  # Returns the value of attribute nonregular_type.
+  #
+  # source://rbs//lib/rbs/type_alias_regularity.rb#6
+  def nonregular_type; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/type_alias_regularity.rb#6
+  def type_name; end
+end
+
+# source://rbs//lib/rbs/type_name.rb#4
+class RBS::TypeName
+  # @return [TypeName] a new instance of TypeName
+  #
+  # source://rbs//lib/rbs/type_name.rb#9
+  def initialize(namespace:, name:); end
+
+  # source://rbs//lib/rbs/type_name.rb#79
+  def +(other); end
+
+  # source://rbs//lib/rbs/type_name.rb#25
+  def ==(other); end
+
+  # source://rbs//lib/rbs/type_name.rb#55
+  def absolute!; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/type_name.rb#59
+  def absolute?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/type_name.rb#51
+  def alias?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/type_name.rb#47
+  def class?; end
+
+  # source://rbs//lib/rbs/type_name.rb#25
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/type_name.rb#31
+  def hash; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/type_name.rb#67
+  def interface?; end
+
+  # Returns the value of attribute kind.
+  #
+  # source://rbs//lib/rbs/type_name.rb#7
+  def kind; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/type_name.rb#6
+  def name; end
+
+  # Returns the value of attribute namespace.
+  #
+  # source://rbs//lib/rbs/type_name.rb#5
+  def namespace; end
+
+  # source://rbs//lib/rbs/type_name.rb#63
+  def relative!; end
+
+  # source://rbs//lib/rbs/type_name.rb#75
+  def split; end
+
+  # source://rbs//lib/rbs/type_name.rb#39
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/type_name.rb#43
+  def to_namespace; end
+
+  # source://rbs//lib/rbs/type_name.rb#35
+  def to_s; end
+
+  # source://rbs//lib/rbs/type_name.rb#71
+  def with_prefix(namespace); end
+end
+
+# source://rbs//lib/rbs/errors.rb#580
+class RBS::TypeParamDefaultReferenceError < ::RBS::DefinitionError
+  include ::RBS::DetailedMessageable
+
+  # @return [TypeParamDefaultReferenceError] a new instance of TypeParamDefaultReferenceError
+  #
+  # source://rbs//lib/rbs/errors.rb#586
+  def initialize(type_param, location:); end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/errors.rb#584
+  def location; end
+
+  # Returns the value of attribute type_param.
+  #
+  # source://rbs//lib/rbs/errors.rb#583
+  def type_param; end
+
+  class << self
+    # source://rbs//lib/rbs/errors.rb#592
+    def check!(type_params); end
+  end
+end
+
+# source://rbs//lib/rbs/types.rb#4
+module RBS::Types; end
+
+# source://rbs//lib/rbs/types.rb#394
+class RBS::Types::Alias
+  include ::RBS::Types::Application
+
+  # @return [Alias] a new instance of Alias
+  #
+  # source://rbs//lib/rbs/types.rb#399
+  def initialize(name:, args:, location:); end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/types.rb#395
+  def location; end
+
+  # source://rbs//lib/rbs/types.rb#421
+  def map_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#413
+  def map_type_name(&block); end
+
+  # source://rbs//lib/rbs/types.rb#409
+  def sub(s); end
+
+  # source://rbs//lib/rbs/types.rb#405
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/types.rb#252
+module RBS::Types::Application
+  # source://rbs//lib/rbs/types.rb#256
+  def ==(other); end
+
+  # Returns the value of attribute args.
+  #
+  # source://rbs//lib/rbs/types.rb#254
+  def args; end
+
+  # source://rbs//lib/rbs/types.rb#282
+  def each_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#256
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/types.rb#266
+  def free_variables(set = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#294
+  def has_classish_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#290
+  def has_self_type?; end
+
+  # source://rbs//lib/rbs/types.rb#262
+  def hash; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/types.rb#253
+  def name; end
+
+  # source://rbs//lib/rbs/types.rb#274
+  def to_s(level = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#298
+  def with_nonreturn_void?; end
+end
+
+# source://rbs//lib/rbs/types.rb#41
+module RBS::Types::Bases; end
+
+# source://rbs//lib/rbs/types.rb#109
+class RBS::Types::Bases::Any < ::RBS::Types::Bases::Base
+  # source://rbs//lib/rbs/types.rb#110
+  def to_s(level = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#114
+  def todo!; end
+end
+
+# source://rbs//lib/rbs/types.rb#42
+class RBS::Types::Bases::Base
+  include ::RBS::Types::NoFreeVariables
+  include ::RBS::Types::NoSubst
+  include ::RBS::Types::EmptyEachType
+  include ::RBS::Types::NoTypeName
+
+  # @return [Base] a new instance of Base
+  #
+  # source://rbs//lib/rbs/types.rb#45
+  def initialize(location:); end
+
+  # source://rbs//lib/rbs/types.rb#49
+  def ==(other); end
+
+  # source://rbs//lib/rbs/types.rb#49
+  def eql?(other); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#98
+  def has_classish_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#94
+  def has_self_type?; end
+
+  # source://rbs//lib/rbs/types.rb#53
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/types.rb#43
+  def location; end
+
+  # source://rbs//lib/rbs/types.rb#64
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#69
+  def to_s(level = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#102
+  def with_nonreturn_void?; end
+end
+
+# source://rbs//lib/rbs/types.rb#107
+class RBS::Types::Bases::Bool < ::RBS::Types::Bases::Base; end
+
+# source://rbs//lib/rbs/types.rb#121
+class RBS::Types::Bases::Bottom < ::RBS::Types::Bases::Base; end
+
+# source://rbs//lib/rbs/types.rb#128
+class RBS::Types::Bases::Class < ::RBS::Types::Bases::Base; end
+
+# source://rbs//lib/rbs/types.rb#123
+class RBS::Types::Bases::Instance < ::RBS::Types::Bases::Base
+  # source://rbs//lib/rbs/types.rb#124
+  def sub(s); end
+end
+
+# source://rbs//lib/rbs/types.rb#119
+class RBS::Types::Bases::Nil < ::RBS::Types::Bases::Base; end
+
+# source://rbs//lib/rbs/types.rb#122
+class RBS::Types::Bases::Self < ::RBS::Types::Bases::Base; end
+
+# source://rbs//lib/rbs/types.rb#120
+class RBS::Types::Bases::Top < ::RBS::Types::Bases::Base; end
+
+# source://rbs//lib/rbs/types.rb#108
+class RBS::Types::Bases::Void < ::RBS::Types::Bases::Base; end
+
+# source://rbs//lib/rbs/types.rb#1294
+class RBS::Types::Block
+  # @return [Block] a new instance of Block
+  #
+  # source://rbs//lib/rbs/types.rb#1299
+  def initialize(type:, required:, self_type: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#1305
+  def ==(other); end
+
+  # source://rbs//lib/rbs/types.rb#1328
+  def map_type(&block); end
+
+  # Returns the value of attribute required.
+  #
+  # source://rbs//lib/rbs/types.rb#1296
+  def required; end
+
+  # Returns the value of attribute self_type.
+  #
+  # source://rbs//lib/rbs/types.rb#1297
+  def self_type; end
+
+  # source://rbs//lib/rbs/types.rb#1320
+  def sub(s); end
+
+  # source://rbs//lib/rbs/types.rb#1312
+  def to_json(state = T.unsafe(nil)); end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/types.rb#1295
+  def type; end
+end
+
+# source://rbs//lib/rbs/types.rb#352
+class RBS::Types::ClassInstance
+  include ::RBS::Types::Application
+
+  # @return [ClassInstance] a new instance of ClassInstance
+  #
+  # source://rbs//lib/rbs/types.rb#357
+  def initialize(name:, args:, location:); end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/types.rb#353
+  def location; end
+
+  # source://rbs//lib/rbs/types.rb#381
+  def map_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#373
+  def map_type_name(&block); end
+
+  # source://rbs//lib/rbs/types.rb#367
+  def sub(s); end
+
+  # source://rbs//lib/rbs/types.rb#363
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/types.rb#200
+class RBS::Types::ClassSingleton
+  include ::RBS::Types::NoFreeVariables
+  include ::RBS::Types::NoSubst
+  include ::RBS::Types::EmptyEachType
+
+  # @return [ClassSingleton] a new instance of ClassSingleton
+  #
+  # source://rbs//lib/rbs/types.rb#204
+  def initialize(name:, location:); end
+
+  # source://rbs//lib/rbs/types.rb#209
+  def ==(other); end
+
+  # source://rbs//lib/rbs/types.rb#209
+  def eql?(other); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#243
+  def has_classish_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#239
+  def has_self_type?; end
+
+  # source://rbs//lib/rbs/types.rb#215
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/types.rb#202
+  def location; end
+
+  # source://rbs//lib/rbs/types.rb#232
+  def map_type_name; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/types.rb#201
+  def name; end
+
+  # source://rbs//lib/rbs/types.rb#222
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#226
+  def to_s(level = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#247
+  def with_nonreturn_void?; end
+end
+
+# source://rbs//lib/rbs/types.rb#23
+module RBS::Types::EmptyEachType
+  # source://rbs//lib/rbs/types.rb#24
+  def each_type; end
+
+  # source://rbs//lib/rbs/types.rb#32
+  def map_type(&block); end
+end
+
+# source://rbs//lib/rbs/types.rb#871
+class RBS::Types::Function
+  # @return [Function] a new instance of Function
+  #
+  # source://rbs//lib/rbs/types.rb#927
+  def initialize(required_positionals:, optional_positionals:, rest_positionals:, trailing_positionals:, required_keywords:, optional_keywords:, rest_keywords:, return_type:); end
+
+  # source://rbs//lib/rbs/types.rb#938
+  def ==(other); end
+
+  # source://rbs//lib/rbs/types.rb#1009
+  def amap(array, &block); end
+
+  # source://rbs//lib/rbs/types.rb#1146
+  def drop_head; end
+
+  # source://rbs//lib/rbs/types.rb#1163
+  def drop_tail; end
+
+  # source://rbs//lib/rbs/types.rb#1046
+  def each_param(&block); end
+
+  # source://rbs//lib/rbs/types.rb#1031
+  def each_type; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1117
+  def empty?; end
+
+  # source://rbs//lib/rbs/types.rb#938
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/types.rb#964
+  def free_variables(set = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1188
+  def has_classish_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1176
+  def has_keyword?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1184
+  def has_self_type?; end
+
+  # source://rbs//lib/rbs/types.rb#952
+  def hash; end
+
+  # source://rbs//lib/rbs/types.rb#1017
+  def hmapv(hash, &block); end
+
+  # source://rbs//lib/rbs/types.rb#992
+  def map_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#1025
+  def map_type_name(&block); end
+
+  # Returns the value of attribute optional_keywords.
+  #
+  # source://rbs//lib/rbs/types.rb#923
+  def optional_keywords; end
+
+  # Returns the value of attribute optional_positionals.
+  #
+  # source://rbs//lib/rbs/types.rb#919
+  def optional_positionals; end
+
+  # source://rbs//lib/rbs/types.rb#1127
+  def param_to_s; end
+
+  # Returns the value of attribute required_keywords.
+  #
+  # source://rbs//lib/rbs/types.rb#922
+  def required_keywords; end
+
+  # Returns the value of attribute required_positionals.
+  #
+  # source://rbs//lib/rbs/types.rb#918
+  def required_positionals; end
+
+  # Returns the value of attribute rest_keywords.
+  #
+  # source://rbs//lib/rbs/types.rb#924
+  def rest_keywords; end
+
+  # Returns the value of attribute rest_positionals.
+  #
+  # source://rbs//lib/rbs/types.rb#920
+  def rest_positionals; end
+
+  # source://rbs//lib/rbs/types.rb#1142
+  def return_to_s; end
+
+  # Returns the value of attribute return_type.
+  #
+  # source://rbs//lib/rbs/types.rb#925
+  def return_type; end
+
+  # source://rbs//lib/rbs/types.rb#1073
+  def sub(s); end
+
+  # source://rbs//lib/rbs/types.rb#1060
+  def to_json(state = T.unsafe(nil)); end
+
+  # Returns the value of attribute trailing_positionals.
+  #
+  # source://rbs//lib/rbs/types.rb#921
+  def trailing_positionals; end
+
+  # source://rbs//lib/rbs/types.rb#1103
+  def update(required_positionals: T.unsafe(nil), optional_positionals: T.unsafe(nil), rest_positionals: T.unsafe(nil), trailing_positionals: T.unsafe(nil), required_keywords: T.unsafe(nil), optional_keywords: T.unsafe(nil), rest_keywords: T.unsafe(nil), return_type: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1192
+  def with_nonreturn_void?; end
+
+  # source://rbs//lib/rbs/types.rb#1090
+  def with_return_type(type); end
+
+  class << self
+    # source://rbs//lib/rbs/types.rb#1077
+    def empty(return_type); end
+  end
+end
+
+# source://rbs//lib/rbs/types.rb#872
+class RBS::Types::Function::Param
+  # @return [Param] a new instance of Param
+  #
+  # source://rbs//lib/rbs/types.rb#877
+  def initialize(type:, name:, location: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#883
+  def ==(other); end
+
+  # source://rbs//lib/rbs/types.rb#883
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/types.rb#889
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/types.rb#875
+  def location; end
+
+  # source://rbs//lib/rbs/types.rb#893
+  def map_type(&block); end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/types.rb#874
+  def name; end
+
+  # source://rbs//lib/rbs/types.rb#901
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#905
+  def to_s; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/types.rb#873
+  def type; end
+end
+
+# source://rbs//lib/rbs/types.rb#310
+class RBS::Types::Interface
+  include ::RBS::Types::Application
+
+  # @return [Interface] a new instance of Interface
+  #
+  # source://rbs//lib/rbs/types.rb#315
+  def initialize(name:, args:, location:); end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/types.rb#311
+  def location; end
+
+  # source://rbs//lib/rbs/types.rb#339
+  def map_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#331
+  def map_type_name(&block); end
+
+  # source://rbs//lib/rbs/types.rb#325
+  def sub(s); end
+
+  # source://rbs//lib/rbs/types.rb#321
+  def to_json(state = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/types.rb#790
+class RBS::Types::Intersection
+  # @return [Intersection] a new instance of Intersection
+  #
+  # source://rbs//lib/rbs/types.rb#794
+  def initialize(types:, location:); end
+
+  # source://rbs//lib/rbs/types.rb#799
+  def ==(other); end
+
+  # source://rbs//lib/rbs/types.rb#835
+  def each_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#799
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/types.rb#809
+  def free_variables(set = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#862
+  def has_classish_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#858
+  def has_self_type?; end
+
+  # source://rbs//lib/rbs/types.rb#805
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/types.rb#792
+  def location; end
+
+  # source://rbs//lib/rbs/types.rb#843
+  def map_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#851
+  def map_type_name(&block); end
+
+  # source://rbs//lib/rbs/types.rb#821
+  def sub(s); end
+
+  # source://rbs//lib/rbs/types.rb#817
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#826
+  def to_s(level = T.unsafe(nil)); end
+
+  # Returns the value of attribute types.
+  #
+  # source://rbs//lib/rbs/types.rb#791
+  def types; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#866
+  def with_nonreturn_void?; end
+end
+
+# source://rbs//lib/rbs/types.rb#1469
+class RBS::Types::Literal
+  include ::RBS::Types::NoFreeVariables
+  include ::RBS::Types::NoSubst
+  include ::RBS::Types::EmptyEachType
+  include ::RBS::Types::NoTypeName
+
+  # @return [Literal] a new instance of Literal
+  #
+  # source://rbs//lib/rbs/types.rb#1473
+  def initialize(literal:, location:); end
+
+  # source://rbs//lib/rbs/types.rb#1478
+  def ==(other); end
+
+  # source://rbs//lib/rbs/types.rb#1478
+  def eql?(other); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1505
+  def has_classish_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1501
+  def has_self_type?; end
+
+  # source://rbs//lib/rbs/types.rb#1484
+  def hash; end
+
+  # Returns the value of attribute literal.
+  #
+  # source://rbs//lib/rbs/types.rb#1470
+  def literal; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/types.rb#1471
+  def location; end
+
+  # source://rbs//lib/rbs/types.rb#1493
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#1497
+  def to_s(level = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1509
+  def with_nonreturn_void?; end
+
+  class << self
+    # source://rbs//lib/rbs/types.rb#1529
+    def unescape_string(string, is_double_quote); end
+  end
+end
+
+# source://rbs//lib/rbs/types.rb#1513
+RBS::Types::Literal::TABLE = T.let(T.unsafe(nil), Hash)
+
+# source://rbs//lib/rbs/types.rb#5
+module RBS::Types::NoFreeVariables
+  # source://rbs//lib/rbs/types.rb#6
+  def free_variables(set = T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/types.rb#11
+module RBS::Types::NoSubst
+  # source://rbs//lib/rbs/types.rb#12
+  def sub(s); end
+end
+
+# source://rbs//lib/rbs/types.rb#17
+module RBS::Types::NoTypeName
+  # source://rbs//lib/rbs/types.rb#18
+  def map_type_name; end
+end
+
+# source://rbs//lib/rbs/types.rb#626
+class RBS::Types::Optional
+  # @return [Optional] a new instance of Optional
+  #
+  # source://rbs//lib/rbs/types.rb#630
+  def initialize(type:, location:); end
+
+  # source://rbs//lib/rbs/types.rb#635
+  def ==(other); end
+
+  # source://rbs//lib/rbs/types.rb#671
+  def each_type; end
+
+  # source://rbs//lib/rbs/types.rb#635
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/types.rb#645
+  def free_variables(set = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#701
+  def has_classish_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#697
+  def has_self_type?; end
+
+  # source://rbs//lib/rbs/types.rb#641
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/types.rb#628
+  def location; end
+
+  # source://rbs//lib/rbs/types.rb#686
+  def map_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#679
+  def map_type_name(&block); end
+
+  # source://rbs//lib/rbs/types.rb#653
+  def sub(s); end
+
+  # source://rbs//lib/rbs/types.rb#649
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#657
+  def to_s(level = T.unsafe(nil)); end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/types.rb#627
+  def type; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#705
+  def with_nonreturn_void?; end
+end
+
+# source://rbs//lib/rbs/types.rb#1349
+class RBS::Types::Proc
+  # @return [Proc] a new instance of Proc
+  #
+  # source://rbs//lib/rbs/types.rb#1355
+  def initialize(location:, type:, block:, self_type: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#1362
+  def ==(other); end
+
+  # Returns the value of attribute block.
+  #
+  # source://rbs//lib/rbs/types.rb#1351
+  def block; end
+
+  # source://rbs//lib/rbs/types.rb#1414
+  def each_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#1362
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/types.rb#1372
+  def free_variables(set = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1452
+  def has_classish_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1448
+  def has_self_type?; end
+
+  # source://rbs//lib/rbs/types.rb#1368
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/types.rb#1353
+  def location; end
+
+  # source://rbs//lib/rbs/types.rb#1435
+  def map_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#1426
+  def map_type_name(&block); end
+
+  # Returns the value of attribute self_type.
+  #
+  # source://rbs//lib/rbs/types.rb#1352
+  def self_type; end
+
+  # source://rbs//lib/rbs/types.rb#1389
+  def sub(s); end
+
+  # source://rbs//lib/rbs/types.rb#1379
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#1398
+  def to_s(level = T.unsafe(nil)); end
+
+  # Returns the value of attribute type.
+  #
+  # source://rbs//lib/rbs/types.rb#1350
+  def type; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1456
+  def with_nonreturn_void?; end
+end
+
+# source://rbs//lib/rbs/types.rb#517
+class RBS::Types::Record
+  # @return [Record] a new instance of Record
+  #
+  # source://rbs//lib/rbs/types.rb#521
+  def initialize(location:, all_fields: T.unsafe(nil), fields: T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#538
+  def ==(other); end
+
+  # Returns the value of attribute all_fields.
+  #
+  # source://rbs//lib/rbs/types.rb#518
+  def all_fields; end
+
+  # source://rbs//lib/rbs/types.rb#586
+  def each_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#538
+  def eql?(other); end
+
+  # Returns the value of attribute fields.
+  #
+  # source://rbs//lib/rbs/types.rb#518
+  def fields; end
+
+  # source://rbs//lib/rbs/types.rb#548
+  def free_variables(set = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#617
+  def has_classish_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#613
+  def has_self_type?; end
+
+  # source://rbs//lib/rbs/types.rb#544
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/types.rb#519
+  def location; end
+
+  # source://rbs//lib/rbs/types.rb#602
+  def map_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#595
+  def map_type_name(&block); end
+
+  # Returns the value of attribute optional_fields.
+  #
+  # source://rbs//lib/rbs/types.rb#518
+  def optional_fields; end
+
+  # source://rbs//lib/rbs/types.rb#563
+  def sub(s); end
+
+  # source://rbs//lib/rbs/types.rb#559
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#570
+  def to_s(level = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#621
+  def with_nonreturn_void?; end
+end
+
+# source://rbs//lib/rbs/types.rb#1337
+module RBS::Types::SelfTypeBindingHelper
+  private
+
+  # source://rbs//lib/rbs/types.rb#1340
+  def self_type_binding_to_s(t); end
+
+  class << self
+    # source://rbs//lib/rbs/types.rb#1340
+    def self_type_binding_to_s(t); end
+  end
+end
+
+# source://rbs//lib/rbs/types.rb#434
+class RBS::Types::Tuple
+  # @return [Tuple] a new instance of Tuple
+  #
+  # source://rbs//lib/rbs/types.rb#438
+  def initialize(types:, location:); end
+
+  # source://rbs//lib/rbs/types.rb#443
+  def ==(other); end
+
+  # source://rbs//lib/rbs/types.rb#478
+  def each_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#443
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/types.rb#453
+  def free_variables(set = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#508
+  def has_classish_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#504
+  def has_self_type?; end
+
+  # source://rbs//lib/rbs/types.rb#449
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/types.rb#436
+  def location; end
+
+  # source://rbs//lib/rbs/types.rb#493
+  def map_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#486
+  def map_type_name(&block); end
+
+  # source://rbs//lib/rbs/types.rb#465
+  def sub(s); end
+
+  # source://rbs//lib/rbs/types.rb#461
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#470
+  def to_s(level = T.unsafe(nil)); end
+
+  # Returns the value of attribute types.
+  #
+  # source://rbs//lib/rbs/types.rb#435
+  def types; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#512
+  def with_nonreturn_void?; end
+end
+
+# source://rbs//lib/rbs/types.rb#710
+class RBS::Types::Union
+  # @return [Union] a new instance of Union
+  #
+  # source://rbs//lib/rbs/types.rb#714
+  def initialize(types:, location:); end
+
+  # source://rbs//lib/rbs/types.rb#719
+  def ==(other); end
+
+  # source://rbs//lib/rbs/types.rb#754
+  def each_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#719
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/types.rb#729
+  def free_variables(set = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#781
+  def has_classish_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#777
+  def has_self_type?; end
+
+  # source://rbs//lib/rbs/types.rb#725
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/types.rb#712
+  def location; end
+
+  # source://rbs//lib/rbs/types.rb#762
+  def map_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#770
+  def map_type_name(&block); end
+
+  # source://rbs//lib/rbs/types.rb#741
+  def sub(s); end
+
+  # source://rbs//lib/rbs/types.rb#737
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#746
+  def to_s(level = T.unsafe(nil)); end
+
+  # Returns the value of attribute types.
+  #
+  # source://rbs//lib/rbs/types.rb#711
+  def types; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#785
+  def with_nonreturn_void?; end
+end
+
+# source://rbs//lib/rbs/types.rb#1205
+class RBS::Types::UntypedFunction
+  # @return [UntypedFunction] a new instance of UntypedFunction
+  #
+  # source://rbs//lib/rbs/types.rb#1208
+  def initialize(return_type:); end
+
+  # source://rbs//lib/rbs/types.rb#1282
+  def ==(other); end
+
+  # source://rbs//lib/rbs/types.rb#1232
+  def each_param(&block); end
+
+  # source://rbs//lib/rbs/types.rb#1224
+  def each_type(&block); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1258
+  def empty?; end
+
+  # source://rbs//lib/rbs/types.rb#1282
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/types.rb#1212
+  def free_variables(acc = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1266
+  def has_classish_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1262
+  def has_self_type?; end
+
+  # source://rbs//lib/rbs/types.rb#1288
+  def hash; end
+
+  # source://rbs//lib/rbs/types.rb#1216
+  def map_type(&block); end
+
+  # source://rbs//lib/rbs/types.rb#1274
+  def param_to_s; end
+
+  # source://rbs//lib/rbs/types.rb#1278
+  def return_to_s; end
+
+  # Returns the value of attribute return_type.
+  #
+  # source://rbs//lib/rbs/types.rb#1206
+  def return_type; end
+
+  # source://rbs//lib/rbs/types.rb#1246
+  def sub(subst); end
+
+  # source://rbs//lib/rbs/types.rb#1240
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#1254
+  def update(return_type: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#1270
+  def with_nonreturn_void?; end
+
+  # source://rbs//lib/rbs/types.rb#1250
+  def with_return_type(ty); end
+end
+
+# source://rbs//lib/rbs/types.rb#131
+class RBS::Types::Variable
+  include ::RBS::Types::NoTypeName
+  include ::RBS::Types::EmptyEachType
+
+  # @return [Variable] a new instance of Variable
+  #
+  # source://rbs//lib/rbs/types.rb#137
+  def initialize(name:, location:); end
+
+  # source://rbs//lib/rbs/types.rb#142
+  def ==(other); end
+
+  # source://rbs//lib/rbs/types.rb#142
+  def eql?(other); end
+
+  # source://rbs//lib/rbs/types.rb#152
+  def free_variables(set = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#191
+  def has_classish_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#187
+  def has_self_type?; end
+
+  # source://rbs//lib/rbs/types.rb#148
+  def hash; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/types.rb#133
+  def location; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rbs//lib/rbs/types.rb#132
+  def name; end
+
+  # source://rbs//lib/rbs/types.rb#162
+  def sub(s); end
+
+  # source://rbs//lib/rbs/types.rb#158
+  def to_json(state = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/types.rb#181
+  def to_s(level = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/types.rb#195
+  def with_nonreturn_void?; end
+
+  class << self
+    # source://rbs//lib/rbs/types.rb#166
+    def build(v); end
+
+    # source://rbs//lib/rbs/types.rb#176
+    def fresh(v = T.unsafe(nil)); end
+  end
+end
+
+# source://rbs//lib/rbs/errors.rb#325
+class RBS::UnknownMethodAliasError < ::RBS::DefinitionError
+  include ::RBS::DetailedMessageable
+
+  # @return [UnknownMethodAliasError] a new instance of UnknownMethodAliasError
+  #
+  # source://rbs//lib/rbs/errors.rb#333
+  def initialize(type_name:, original_name:, aliased_name:, location:); end
+
+  # Returns the value of attribute aliased_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#330
+  def aliased_name; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/errors.rb#331
+  def location; end
+
+  # Returns the value of attribute original_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#329
+  def original_name; end
+
+  # Returns the value of attribute type_name.
+  #
+  # source://rbs//lib/rbs/errors.rb#328
+  def type_name; end
+end
+
+# source://rbs//lib/rbs/version.rb#4
+RBS::VERSION = T.let(T.unsafe(nil), String)
+
+# source://rbs//lib/rbs/validator.rb#4
+class RBS::Validator
+  # @return [Validator] a new instance of Validator
+  #
+  # source://rbs//lib/rbs/validator.rb#9
+  def initialize(env:, resolver:); end
+
+  # source://rbs//lib/rbs/validator.rb#15
+  def absolute_type(type, context:, &block); end
+
+  # Returns the value of attribute definition_builder.
+  #
+  # source://rbs//lib/rbs/validator.rb#7
+  def definition_builder; end
+
+  # Returns the value of attribute env.
+  #
+  # source://rbs//lib/rbs/validator.rb#5
+  def env; end
+
+  # Returns the value of attribute resolver.
+  #
+  # source://rbs//lib/rbs/validator.rb#6
+  def resolver; end
+
+  # source://rbs//lib/rbs/validator.rb#172
+  def type_alias_dependency; end
+
+  # source://rbs//lib/rbs/validator.rb#176
+  def type_alias_regularity; end
+
+  # source://rbs//lib/rbs/validator.rb#152
+  def validate_class_alias(entry:); end
+
+  # source://rbs//lib/rbs/validator.rb#102
+  def validate_method_definition(method_def, type_name:); end
+
+  # Validates presence of the relative type, and application arity match.
+  #
+  # source://rbs//lib/rbs/validator.rb#22
+  def validate_type(type, context:); end
+
+  # source://rbs//lib/rbs/validator.rb#61
+  def validate_type_alias(entry:); end
+
+  # source://rbs//lib/rbs/validator.rb#118
+  def validate_type_params(params, type_name:, location:, method_name: T.unsafe(nil)); end
+end
+
+# source://rbs//lib/rbs/variance_calculator.rb#4
+class RBS::VarianceCalculator
+  # @return [VarianceCalculator] a new instance of VarianceCalculator
+  #
+  # source://rbs//lib/rbs/variance_calculator.rb#78
+  def initialize(builder:); end
+
+  # Returns the value of attribute builder.
+  #
+  # source://rbs//lib/rbs/variance_calculator.rb#76
+  def builder; end
+
+  # source://rbs//lib/rbs/variance_calculator.rb#82
+  def env; end
+
+  # source://rbs//lib/rbs/variance_calculator.rb#169
+  def function(type, result:, context:); end
+
+  # source://rbs//lib/rbs/variance_calculator.rb#98
+  def in_inherit(name:, args:, variables:); end
+
+  # source://rbs//lib/rbs/variance_calculator.rb#86
+  def in_method_type(method_type:, variables:); end
+
+  # source://rbs//lib/rbs/variance_calculator.rb#110
+  def in_type_alias(name:); end
+
+  # source://rbs//lib/rbs/variance_calculator.rb#176
+  def negate(variance); end
+
+  # source://rbs//lib/rbs/variance_calculator.rb#121
+  def type(type, result:, context:); end
+end
+
+# source://rbs//lib/rbs/variance_calculator.rb#5
+class RBS::VarianceCalculator::Result
+  # @return [Result] a new instance of Result
+  #
+  # source://rbs//lib/rbs/variance_calculator.rb#8
+  def initialize(variables:); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/variance_calculator.rb#45
+  def compatible?(var, with_annotation:); end
+
+  # source://rbs//lib/rbs/variance_calculator.rb#24
+  def contravariant(x); end
+
+  # source://rbs//lib/rbs/variance_calculator.rb#15
+  def covariant(x); end
+
+  # source://rbs//lib/rbs/variance_calculator.rb#37
+  def each(&block); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/variance_calculator.rb#41
+  def include?(name); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/variance_calculator.rb#60
+  def incompatible?(params); end
+
+  # source://rbs//lib/rbs/variance_calculator.rb#33
+  def invariant(x); end
+
+  # Returns the value of attribute result.
+  #
+  # source://rbs//lib/rbs/variance_calculator.rb#6
+  def result; end
+end
+
+# source://rbs//lib/rbs/vendorer.rb#4
+class RBS::Vendorer
+  # @return [Vendorer] a new instance of Vendorer
+  #
+  # source://rbs//lib/rbs/vendorer.rb#8
+  def initialize(vendor_dir:, loader:); end
+
+  # source://rbs//lib/rbs/vendorer.rb#21
+  def clean!; end
+
+  # source://rbs//lib/rbs/vendorer.rb#28
+  def copy!; end
+
+  # source://rbs//lib/rbs/vendorer.rb#13
+  def ensure_dir; end
+
+  # Returns the value of attribute loader.
+  #
+  # source://rbs//lib/rbs/vendorer.rb#6
+  def loader; end
+
+  # Returns the value of attribute vendor_dir.
+  #
+  # source://rbs//lib/rbs/vendorer.rb#5
+  def vendor_dir; end
+end
+
+# source://rbs//lib/rbs/errors.rb#569
+class RBS::WillSyntaxError < ::RBS::DefinitionError
+  include ::RBS::DetailedMessageable
+
+  # @return [WillSyntaxError] a new instance of WillSyntaxError
+  #
+  # source://rbs//lib/rbs/errors.rb#574
+  def initialize(message, location:); end
+
+  # Returns the value of attribute location.
+  #
+  # source://rbs//lib/rbs/errors.rb#572
+  def location; end
+end
+
+# source://rbs//lib/rbs/writer.rb#4
+class RBS::Writer
+  # @return [Writer] a new instance of Writer
+  #
+  # source://rbs//lib/rbs/writer.rb#8
+  def initialize(out:); end
+
+  # source://rbs//lib/rbs/writer.rb#361
+  def attribute(kind, attr); end
+
+  # source://rbs//lib/rbs/writer.rb#42
+  def format_annotation(annotation); end
+
+  # source://rbs//lib/rbs/writer.rb#23
+  def indent(size = T.unsafe(nil)); end
+
+  # Returns the value of attribute indentation.
+  #
+  # source://rbs//lib/rbs/writer.rb#6
+  def indentation; end
+
+  # source://rbs//lib/rbs/writer.rb#288
+  def method_name(name); end
+
+  # source://rbs//lib/rbs/writer.rb#214
+  def name_and_args(name, args); end
+
+  # source://rbs//lib/rbs/writer.rb#202
+  def name_and_params(name, params); end
+
+  # Returns the value of attribute out.
+  #
+  # source://rbs//lib/rbs/writer.rb#5
+  def out; end
+
+  # source://rbs//lib/rbs/writer.rb#30
+  def prefix; end
+
+  # source://rbs//lib/rbs/writer.rb#18
+  def preserve!(preserve: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rbs//lib/rbs/writer.rb#14
+  def preserve?; end
+
+  # source://rbs//lib/rbs/writer.rb#391
+  def preserve_empty_line(prev, decl); end
+
+  # source://rbs//lib/rbs/writer.rb#224
+  def put_lines(lines, leading_spaces:); end
+
+  # source://rbs//lib/rbs/writer.rb#34
+  def puts(string = T.unsafe(nil)); end
+
+  # source://rbs//lib/rbs/writer.rb#79
+  def write(contents); end
+
+  # source://rbs//lib/rbs/writer.rb#60
+  def write_annotation(annotations); end
+
+  # source://rbs//lib/rbs/writer.rb#66
+  def write_comment(comment); end
+
+  # source://rbs//lib/rbs/writer.rb#114
+  def write_decl(decl); end
+
+  # source://rbs//lib/rbs/writer.rb#309
+  def write_def(member); end
+
+  # source://rbs//lib/rbs/writer.rb#97
+  def write_directive(dir); end
+
+  # source://rbs//lib/rbs/writer.rb#301
+  def write_loc_source(located); end
+
+  # source://rbs//lib/rbs/writer.rb#234
+  def write_member(member); end
+end
+
+# source://rbs//lib/rdoc/discover.rb#8
+class RDoc::Parser::RBS < ::RDoc::Parser
+  # source://rbs//lib/rdoc/discover.rb#10
+  def scan; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.2.rbi
deleted file mode 100644
index 25b5f7e36c851..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.2.rbi
+++ /dev/null
@@ -1,47 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rdiscount` gem.
-# Please instead update this file by running `bin/tapioca gem rdiscount`.
-
-Markdown = RDiscount
-
-class RDiscount
-  def initialize(text, *extensions); end
-
-  def autolink; end
-  def autolink=(_arg0); end
-  def filter_html; end
-  def filter_html=(_arg0); end
-  def filter_styles; end
-  def filter_styles=(_arg0); end
-  def fold_lines; end
-  def fold_lines=(_arg0); end
-  def footnotes; end
-  def footnotes=(_arg0); end
-  def generate_toc; end
-  def generate_toc=(_arg0); end
-  def no_image; end
-  def no_image=(_arg0); end
-  def no_links; end
-  def no_links=(_arg0); end
-  def no_pseudo_protocols; end
-  def no_pseudo_protocols=(_arg0); end
-  def no_strikethrough; end
-  def no_strikethrough=(_arg0); end
-  def no_superscript; end
-  def no_superscript=(_arg0); end
-  def no_tables; end
-  def no_tables=(_arg0); end
-  def safelink; end
-  def safelink=(_arg0); end
-  def smart; end
-  def smart=(_arg0); end
-  def strict; end
-  def strict=(_arg0); end
-  def text; end
-  def to_html(*_arg0); end
-  def toc_content(*_arg0); end
-end
-
-RDiscount::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/redcarpet@3.6.0.rbi b/Library/Homebrew/sorbet/rbi/gems/redcarpet@3.6.0.rbi
new file mode 100644
index 0000000000000..705a9e63015e3
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/redcarpet@3.6.0.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `redcarpet` gem.
+# Please instead update this file by running `bin/tapioca gem redcarpet`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem
diff --git a/Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.5.0.rbi b/Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.5.0.rbi
deleted file mode 100644
index de92bf189b2b5..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.5.0.rbi
+++ /dev/null
@@ -1,1146 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `regexp_parser` gem.
-# Please instead update this file by running `bin/tapioca gem regexp_parser`.
-
-module Regexp::Expression; end
-
-class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
-  def alternatives; end
-  def match_length; end
-end
-
-Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative
-class Regexp::Expression::Alternative < ::Regexp::Expression::Sequence; end
-module Regexp::Expression::Anchor; end
-Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine
-Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString
-
-class Regexp::Expression::Anchor::Base < ::Regexp::Expression::Base
-  def match_length; end
-end
-
-class Regexp::Expression::Anchor::BeginningOfLine < ::Regexp::Expression::Anchor::Base; end
-class Regexp::Expression::Anchor::BeginningOfString < ::Regexp::Expression::Anchor::Base; end
-Regexp::Expression::Anchor::EOL = Regexp::Expression::Anchor::EndOfLine
-Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString
-Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine
-class Regexp::Expression::Anchor::EndOfLine < ::Regexp::Expression::Anchor::Base; end
-class Regexp::Expression::Anchor::EndOfString < ::Regexp::Expression::Anchor::Base; end
-class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < ::Regexp::Expression::Anchor::Base; end
-class Regexp::Expression::Anchor::MatchStart < ::Regexp::Expression::Anchor::Base; end
-class Regexp::Expression::Anchor::NonWordBoundary < ::Regexp::Expression::Anchor::Base; end
-class Regexp::Expression::Anchor::WordBoundary < ::Regexp::Expression::Anchor::Base; end
-module Regexp::Expression::Assertion; end
-
-class Regexp::Expression::Assertion::Base < ::Regexp::Expression::Group::Base
-  def match_length; end
-end
-
-class Regexp::Expression::Assertion::Lookahead < ::Regexp::Expression::Assertion::Base; end
-class Regexp::Expression::Assertion::Lookbehind < ::Regexp::Expression::Assertion::Base; end
-class Regexp::Expression::Assertion::NegativeLookahead < ::Regexp::Expression::Assertion::Base; end
-class Regexp::Expression::Assertion::NegativeLookbehind < ::Regexp::Expression::Assertion::Base; end
-module Regexp::Expression::Backreference; end
-
-class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
-  def match_length; end
-  def referenced_expression; end
-  def referenced_expression=(_arg0); end
-
-  private
-
-  def initialize_copy(orig); end
-end
-
-class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base
-  def initialize(token, options = T.unsafe(nil)); end
-
-  def name; end
-  def reference; end
-end
-
-class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name; end
-
-class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name
-  def initialize(token, options = T.unsafe(nil)); end
-
-  def recursion_level; end
-end
-
-class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base
-  def initialize(token, options = T.unsafe(nil)); end
-
-  def number; end
-  def reference; end
-end
-
-class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number; end
-class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative; end
-
-class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::Number
-  def initialize(token, options = T.unsafe(nil)); end
-
-  def recursion_level; end
-end
-
-class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::Backreference::Number
-  def effective_number; end
-  def effective_number=(_arg0); end
-  def reference; end
-end
-
-class Regexp::Expression::Base
-  include ::Regexp::Expression::Shared
-  include ::RuboCop::Ext::RegexpParser::Expression::Base
-  extend ::Regexp::Expression::Shared::ClassMethods
-
-  def initialize(token, options = T.unsafe(nil)); end
-
-  def =~(string, offset = T.unsafe(nil)); end
-  def a?; end
-  def ascii_classes?; end
-  def attributes; end
-  def case_insensitive?; end
-  def conditional_level; end
-  def conditional_level=(_arg0); end
-  def d?; end
-  def default_classes?; end
-  def extended?; end
-  def free_spacing?; end
-  def greedy?; end
-  def i?; end
-  def ignore_case?; end
-  def lazy?; end
-  def level; end
-  def level=(_arg0); end
-  def m?; end
-  def match(string, offset = T.unsafe(nil)); end
-  def match?(string); end
-  def matches?(string); end
-  def multiline?; end
-  def nesting_level; end
-  def options; end
-  def options=(_arg0); end
-  def possessive?; end
-  def quantifier; end
-  def quantifier=(_arg0); end
-  def quantify(*args); end
-  def quantity; end
-  def reluctant?; end
-  def repetitions; end
-  def set_level; end
-  def set_level=(_arg0); end
-  def strfre(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
-  def strfregexp(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
-  def te; end
-  def te=(_arg0); end
-  def text; end
-  def text=(_arg0); end
-  def to_h; end
-  def to_re(format = T.unsafe(nil)); end
-  def token; end
-  def token=(_arg0); end
-  def ts; end
-  def ts=(_arg0); end
-  def type; end
-  def type=(_arg0); end
-  def u?; end
-  def unicode_classes?; end
-  def unquantified_clone; end
-  def x?; end
-
-  private
-
-  def initialize_copy(orig); end
-end
-
-class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
-  include ::RuboCop::Ext::RegexpParser::Expression::CharacterSet
-
-  def initialize(token, options = T.unsafe(nil)); end
-
-  def close; end
-  def closed; end
-  def closed=(_arg0); end
-  def closed?; end
-  def match_length; end
-  def negate; end
-  def negated?; end
-  def negative; end
-  def negative=(_arg0); end
-  def negative?; end
-  def parts; end
-end
-
-class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expression::Sequence
-  def match_length; end
-end
-
-class Regexp::Expression::CharacterSet::Intersection < ::Regexp::Expression::SequenceOperation
-  def match_length; end
-end
-
-Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::CharacterSet::IntersectedSequence
-
-class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpression
-  def <<(exp); end
-  def complete?; end
-  def match_length; end
-  def parts; end
-  def starts_at; end
-  def ts; end
-end
-
-module Regexp::Expression::CharacterType; end
-class Regexp::Expression::CharacterType::Any < ::Regexp::Expression::CharacterType::Base; end
-
-class Regexp::Expression::CharacterType::Base < ::Regexp::Expression::Base
-  def match_length; end
-end
-
-class Regexp::Expression::CharacterType::Digit < ::Regexp::Expression::CharacterType::Base; end
-class Regexp::Expression::CharacterType::ExtendedGrapheme < ::Regexp::Expression::CharacterType::Base; end
-class Regexp::Expression::CharacterType::Hex < ::Regexp::Expression::CharacterType::Base; end
-class Regexp::Expression::CharacterType::Linebreak < ::Regexp::Expression::CharacterType::Base; end
-class Regexp::Expression::CharacterType::NonDigit < ::Regexp::Expression::CharacterType::Base; end
-class Regexp::Expression::CharacterType::NonHex < ::Regexp::Expression::CharacterType::Base; end
-class Regexp::Expression::CharacterType::NonSpace < ::Regexp::Expression::CharacterType::Base; end
-class Regexp::Expression::CharacterType::NonWord < ::Regexp::Expression::CharacterType::Base; end
-class Regexp::Expression::CharacterType::Space < ::Regexp::Expression::CharacterType::Base; end
-class Regexp::Expression::CharacterType::Word < ::Regexp::Expression::CharacterType::Base; end
-class Regexp::Expression::Comment < ::Regexp::Expression::FreeSpace; end
-module Regexp::Expression::Conditional; end
-class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence; end
-
-class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base
-  def match_length; end
-  def reference; end
-  def referenced_expression; end
-  def referenced_expression=(_arg0); end
-
-  private
-
-  def initialize_copy(orig); end
-end
-
-class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression
-  def <<(exp); end
-  def add_sequence(active_opts = T.unsafe(nil)); end
-  def branch(active_opts = T.unsafe(nil)); end
-  def branches; end
-  def condition; end
-  def condition=(exp); end
-  def match_length; end
-  def parts; end
-  def reference; end
-  def referenced_expression; end
-  def referenced_expression=(_arg0); end
-
-  private
-
-  def initialize_copy(orig); end
-end
-
-class Regexp::Expression::Conditional::TooManyBranches < ::Regexp::Parser::Error
-  def initialize; end
-end
-
-module Regexp::Expression::EscapeSequence; end
-
-class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp::Expression::EscapeSequence::Base
-  def char; end
-
-  private
-
-  def control_sequence_to_s(control_sequence); end
-  def meta_char_to_codepoint(meta_char); end
-end
-
-class Regexp::Expression::EscapeSequence::AsciiEscape < ::Regexp::Expression::EscapeSequence::Base; end
-class Regexp::Expression::EscapeSequence::Backspace < ::Regexp::Expression::EscapeSequence::Base; end
-
-class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base
-  def char; end
-  def codepoint; end
-  def match_length; end
-end
-
-class Regexp::Expression::EscapeSequence::Bell < ::Regexp::Expression::EscapeSequence::Base; end
-class Regexp::Expression::EscapeSequence::Codepoint < ::Regexp::Expression::EscapeSequence::Base; end
-
-class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::EscapeSequence::Base
-  def char; end
-  def chars; end
-  def codepoint; end
-  def codepoints; end
-  def match_length; end
-end
-
-class Regexp::Expression::EscapeSequence::Control < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
-  def codepoint; end
-end
-
-class Regexp::Expression::EscapeSequence::FormFeed < ::Regexp::Expression::EscapeSequence::Base; end
-class Regexp::Expression::EscapeSequence::Hex < ::Regexp::Expression::EscapeSequence::Base; end
-
-class Regexp::Expression::EscapeSequence::Literal < ::Regexp::Expression::EscapeSequence::Base
-  def char; end
-end
-
-class Regexp::Expression::EscapeSequence::Meta < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
-  def codepoint; end
-end
-
-class Regexp::Expression::EscapeSequence::MetaControl < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
-  def codepoint; end
-end
-
-class Regexp::Expression::EscapeSequence::Newline < ::Regexp::Expression::EscapeSequence::Base; end
-
-class Regexp::Expression::EscapeSequence::Octal < ::Regexp::Expression::EscapeSequence::Base
-  def char; end
-end
-
-class Regexp::Expression::EscapeSequence::Return < ::Regexp::Expression::EscapeSequence::Base; end
-class Regexp::Expression::EscapeSequence::Tab < ::Regexp::Expression::EscapeSequence::Base; end
-class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::EscapeSequence::Base; end
-
-class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
-  def match_length; end
-  def quantify(*_args); end
-end
-
-module Regexp::Expression::Group; end
-
-class Regexp::Expression::Group::Absence < ::Regexp::Expression::Group::Base
-  def match_length; end
-end
-
-class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base; end
-
-class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression
-  def capturing?; end
-  def comment?; end
-  def parts; end
-end
-
-class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base
-  def capturing?; end
-  def identifier; end
-  def number; end
-  def number=(_arg0); end
-  def number_at_level; end
-  def number_at_level=(_arg0); end
-end
-
-class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base
-  def comment?; end
-  def parts; end
-end
-
-class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture
-  def initialize(token, options = T.unsafe(nil)); end
-
-  def identifier; end
-  def name; end
-
-  private
-
-  def initialize_copy(orig); end
-end
-
-class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base
-  def option_changes; end
-  def option_changes=(_arg0); end
-
-  private
-
-  def initialize_copy(orig); end
-end
-
-class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base
-  def initialize(*_arg0); end
-
-  def implicit=(_arg0); end
-  def implicit?; end
-  def parts; end
-end
-
-module Regexp::Expression::Keep; end
-
-class Regexp::Expression::Keep::Mark < ::Regexp::Expression::Base
-  def match_length; end
-end
-
-class Regexp::Expression::Literal < ::Regexp::Expression::Base
-  def match_length; end
-end
-
-Regexp::Expression::MatchLength = Regexp::MatchLength
-
-class Regexp::Expression::PosixClass < ::Regexp::Expression::Base
-  def match_length; end
-  def name; end
-  def negative?; end
-end
-
-class Regexp::Expression::Quantifier
-  include ::Regexp::Expression::Shared
-  extend ::Regexp::Expression::Shared::ClassMethods
-
-  def initialize(*args); end
-
-  def conditional_level; end
-  def conditional_level=(_arg0); end
-  def greedy?; end
-  def lazy?; end
-  def level; end
-  def level=(_arg0); end
-  def max; end
-  def min; end
-  def mode; end
-  def nesting_level; end
-  def options; end
-  def options=(_arg0); end
-  def possessive?; end
-  def quantifier; end
-  def quantifier=(_arg0); end
-  def reluctant?; end
-  def set_level; end
-  def set_level=(_arg0); end
-  def te; end
-  def te=(_arg0); end
-  def text; end
-  def text=(_arg0); end
-  def to_h; end
-  def token; end
-  def token=(_arg0); end
-  def ts; end
-  def ts=(_arg0); end
-  def type; end
-  def type=(_arg0); end
-
-  private
-
-  def deprecated_old_init(token, text, min, max, mode = T.unsafe(nil)); end
-  def minmax; end
-end
-
-Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array)
-
-class Regexp::Expression::Root < ::Regexp::Expression::Subexpression
-  class << self
-    def build(options = T.unsafe(nil)); end
-  end
-end
-
-class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
-  def quantify(*args); end
-  def starts_at; end
-  def ts; end
-
-  class << self
-    def add_to(exp, params = T.unsafe(nil), active_opts = T.unsafe(nil)); end
-  end
-end
-
-class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpression
-  def <<(exp); end
-  def add_sequence(active_opts = T.unsafe(nil)); end
-  def operands; end
-  def operator; end
-  def parts; end
-  def sequences; end
-  def starts_at; end
-  def ts; end
-end
-
-module Regexp::Expression::Shared
-  mixes_in_class_methods ::Regexp::Expression::Shared::ClassMethods
-
-  def ==(other); end
-  def ===(other); end
-  def base_length; end
-  def coded_offset; end
-  def eql?(other); end
-  def full_length; end
-  def is?(test_token, test_type = T.unsafe(nil)); end
-  def nesting_level=(lvl); end
-  def offset; end
-  def one_of?(scope, top = T.unsafe(nil)); end
-  def parts; end
-  def quantified?; end
-  def quantifier_affix(expression_format); end
-  def starts_at; end
-  def terminal?; end
-  def to_s(format = T.unsafe(nil)); end
-  def to_str(format = T.unsafe(nil)); end
-  def token_class; end
-  def type?(test_type); end
-
-  private
-
-  def init_from_token_and_options(token, options = T.unsafe(nil)); end
-  def initialize_copy(orig); end
-
-  class << self
-    def included(mod); end
-  end
-end
-
-module Regexp::Expression::Shared::ClassMethods
-  def construct(params = T.unsafe(nil)); end
-  def construct_defaults; end
-  def token_class; end
-end
-
-class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
-  include ::Enumerable
-
-  def initialize(token, options = T.unsafe(nil)); end
-
-  def <<(exp); end
-  def [](*args, &block); end
-  def at(*args, &block); end
-  def dig(*indices); end
-  def each(*args, &block); end
-  def each_expression(include_self = T.unsafe(nil)); end
-  def empty?(*args, &block); end
-  def expressions; end
-  def expressions=(_arg0); end
-  def fetch(*args, &block); end
-  def flat_map(include_self = T.unsafe(nil)); end
-  def index(*args, &block); end
-  def inner_match_length; end
-  def join(*args, &block); end
-  def last(*args, &block); end
-  def length(*args, &block); end
-  def match_length; end
-  def parts; end
-  def strfre_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
-  def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
-  def te; end
-  def to_h; end
-  def traverse(include_self = T.unsafe(nil), &block); end
-  def values_at(*args, &block); end
-  def walk(include_self = T.unsafe(nil), &block); end
-
-  private
-
-  def initialize_copy(orig); end
-  def intersperse(expressions, separator); end
-end
-
-module Regexp::Expression::UnicodeProperty; end
-class Regexp::Expression::UnicodeProperty::Age < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Alnum < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Alpha < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Any < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Ascii < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::UnicodeProperty::Base; end
-
-class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base
-  def match_length; end
-  def name; end
-  def negative?; end
-  def shortcut; end
-end
-
-class Regexp::Expression::UnicodeProperty::Blank < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Block < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Cntrl < ::Regexp::Expression::UnicodeProperty::Base; end
-module Regexp::Expression::UnicodeProperty::Codepoint; end
-class Regexp::Expression::UnicodeProperty::Codepoint::Any < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
-class Regexp::Expression::UnicodeProperty::Codepoint::Base < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Codepoint::Control < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
-class Regexp::Expression::UnicodeProperty::Codepoint::Format < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
-class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
-class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
-class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
-class Regexp::Expression::UnicodeProperty::Derived < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Digit < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Emoji < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Graph < ::Regexp::Expression::UnicodeProperty::Base; end
-module Regexp::Expression::UnicodeProperty::Letter; end
-class Regexp::Expression::UnicodeProperty::Letter::Any < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
-class Regexp::Expression::UnicodeProperty::Letter::Base < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Letter::Cased < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
-class Regexp::Expression::UnicodeProperty::Letter::Lowercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
-class Regexp::Expression::UnicodeProperty::Letter::Modifier < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
-class Regexp::Expression::UnicodeProperty::Letter::Other < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
-class Regexp::Expression::UnicodeProperty::Letter::Titlecase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
-class Regexp::Expression::UnicodeProperty::Letter::Uppercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
-class Regexp::Expression::UnicodeProperty::Lower < ::Regexp::Expression::UnicodeProperty::Base; end
-module Regexp::Expression::UnicodeProperty::Mark; end
-class Regexp::Expression::UnicodeProperty::Mark::Any < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
-class Regexp::Expression::UnicodeProperty::Mark::Base < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Mark::Combining < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
-class Regexp::Expression::UnicodeProperty::Mark::Enclosing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
-class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
-class Regexp::Expression::UnicodeProperty::Mark::Spacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
-class Regexp::Expression::UnicodeProperty::Newline < ::Regexp::Expression::UnicodeProperty::Base; end
-module Regexp::Expression::UnicodeProperty::Number; end
-class Regexp::Expression::UnicodeProperty::Number::Any < ::Regexp::Expression::UnicodeProperty::Number::Base; end
-class Regexp::Expression::UnicodeProperty::Number::Base < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Number::Decimal < ::Regexp::Expression::UnicodeProperty::Number::Base; end
-class Regexp::Expression::UnicodeProperty::Number::Letter < ::Regexp::Expression::UnicodeProperty::Number::Base; end
-class Regexp::Expression::UnicodeProperty::Number::Other < ::Regexp::Expression::UnicodeProperty::Number::Base; end
-class Regexp::Expression::UnicodeProperty::Print < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Punct < ::Regexp::Expression::UnicodeProperty::Base; end
-module Regexp::Expression::UnicodeProperty::Punctuation; end
-class Regexp::Expression::UnicodeProperty::Punctuation::Any < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
-class Regexp::Expression::UnicodeProperty::Punctuation::Base < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Punctuation::Close < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
-class Regexp::Expression::UnicodeProperty::Punctuation::Connector < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
-class Regexp::Expression::UnicodeProperty::Punctuation::Dash < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
-class Regexp::Expression::UnicodeProperty::Punctuation::Final < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
-class Regexp::Expression::UnicodeProperty::Punctuation::Initial < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
-class Regexp::Expression::UnicodeProperty::Punctuation::Open < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
-class Regexp::Expression::UnicodeProperty::Punctuation::Other < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
-class Regexp::Expression::UnicodeProperty::Script < ::Regexp::Expression::UnicodeProperty::Base; end
-module Regexp::Expression::UnicodeProperty::Separator; end
-class Regexp::Expression::UnicodeProperty::Separator::Any < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
-class Regexp::Expression::UnicodeProperty::Separator::Base < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Separator::Line < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
-class Regexp::Expression::UnicodeProperty::Separator::Paragraph < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
-class Regexp::Expression::UnicodeProperty::Separator::Space < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
-class Regexp::Expression::UnicodeProperty::Space < ::Regexp::Expression::UnicodeProperty::Base; end
-module Regexp::Expression::UnicodeProperty::Symbol; end
-class Regexp::Expression::UnicodeProperty::Symbol::Any < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
-class Regexp::Expression::UnicodeProperty::Symbol::Base < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Symbol::Currency < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
-class Regexp::Expression::UnicodeProperty::Symbol::Math < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
-class Regexp::Expression::UnicodeProperty::Symbol::Modifier < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
-class Regexp::Expression::UnicodeProperty::Symbol::Other < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
-class Regexp::Expression::UnicodeProperty::Upper < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Word < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::XPosixPunct < ::Regexp::Expression::UnicodeProperty::Base; end
-class Regexp::Expression::UnicodeProperty::Xdigit < ::Regexp::Expression::UnicodeProperty::Base; end
-
-class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace
-  def merge(exp); end
-end
-
-class Regexp::Lexer
-  def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
-
-  private
-
-  def ascend(type, token); end
-  def break_codepoint_list(token); end
-  def break_literal(token); end
-  def conditional_nesting; end
-  def conditional_nesting=(_arg0); end
-  def descend(type, token); end
-  def merge_condition(current); end
-  def nesting; end
-  def nesting=(_arg0); end
-  def set_nesting; end
-  def set_nesting=(_arg0); end
-  def shift; end
-  def shift=(_arg0); end
-  def tokens; end
-  def tokens=(_arg0); end
-
-  class << self
-    def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
-    def scan(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
-  end
-end
-
-Regexp::Lexer::CLOSING_TOKENS = T.let(T.unsafe(nil), Array)
-Regexp::Lexer::CONDITION_TOKENS = T.let(T.unsafe(nil), Array)
-Regexp::Lexer::OPENING_TOKENS = T.let(T.unsafe(nil), Array)
-
-class Regexp::MatchLength
-  include ::Enumerable
-
-  def initialize(exp, opts = T.unsafe(nil)); end
-
-  def each(opts = T.unsafe(nil)); end
-  def endless_each; end
-  def fixed?; end
-  def include?(length); end
-  def inspect; end
-  def max; end
-  def min; end
-  def minmax; end
-  def to_re; end
-
-  private
-
-  def base_max; end
-  def base_max=(_arg0); end
-  def base_min; end
-  def base_min=(_arg0); end
-  def exp_class; end
-  def exp_class=(_arg0); end
-  def max_rep; end
-  def max_rep=(_arg0); end
-  def min_rep; end
-  def min_rep=(_arg0); end
-  def reify; end
-  def reify=(_arg0); end
-  def test_regexp; end
-
-  class << self
-    def of(obj); end
-  end
-end
-
-class Regexp::Parser
-  include ::Regexp::Expression
-  include ::Regexp::Expression::UnicodeProperty
-
-  def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
-
-  private
-
-  def active_opts; end
-  def anchor(token); end
-  def assign_effective_number(exp); end
-  def assign_referenced_expressions; end
-  def backref(token); end
-  def captured_group_count_at_level; end
-  def captured_group_counts; end
-  def captured_group_counts=(_arg0); end
-  def close_completed_character_set_range; end
-  def close_group; end
-  def close_set; end
-  def conditional(token); end
-  def conditional_nesting; end
-  def conditional_nesting=(_arg0); end
-  def count_captured_group; end
-  def decrease_nesting; end
-  def escape(token); end
-  def extract_options(input, options); end
-  def free_space(token); end
-  def group(token); end
-  def increase_group_level(exp); end
-  def intersection(token); end
-  def keep(token); end
-  def literal(token); end
-  def meta(token); end
-  def negate_set; end
-  def nest(exp); end
-  def nest_conditional(exp); end
-  def nesting; end
-  def nesting=(_arg0); end
-  def node; end
-  def node=(_arg0); end
-  def open_group(token); end
-  def open_set(token); end
-  def options_group(token); end
-  def options_stack; end
-  def options_stack=(_arg0); end
-  def parse_token(token); end
-  def posixclass(token); end
-  def property(token); end
-  def quantifier(token); end
-  def range(token); end
-  def root; end
-  def root=(_arg0); end
-  def sequence_operation(klass, token); end
-  def set(token); end
-  def switching_options; end
-  def switching_options=(_arg0); end
-  def total_captured_group_count; end
-  def type(token); end
-
-  class << self
-    def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
-  end
-end
-
-Regexp::Parser::ENC_FLAGS = T.let(T.unsafe(nil), Array)
-class Regexp::Parser::Error < ::StandardError; end
-Regexp::Parser::MOD_FLAGS = T.let(T.unsafe(nil), Array)
-class Regexp::Parser::ParserError < ::Regexp::Parser::Error; end
-Regexp::Parser::UPTokens = Regexp::Syntax::Token::UnicodeProperty
-
-class Regexp::Parser::UnknownTokenError < ::Regexp::Parser::ParserError
-  def initialize(type, token); end
-end
-
-class Regexp::Parser::UnknownTokenTypeError < ::Regexp::Parser::ParserError
-  def initialize(type, token); end
-end
-
-Regexp::Parser::VERSION = T.let(T.unsafe(nil), String)
-
-class Regexp::Scanner
-  def emit(type, token, text); end
-  def scan(input_object, options: T.unsafe(nil), &block); end
-
-  private
-
-  def append_literal(data, ts, te); end
-  def block; end
-  def block=(_arg0); end
-  def char_pos; end
-  def char_pos=(_arg0); end
-  def conditional_stack; end
-  def conditional_stack=(_arg0); end
-  def copy(data, ts, te); end
-  def emit_literal; end
-  def emit_meta_control_sequence(data, ts, te, token); end
-  def emit_options(text); end
-  def free_spacing; end
-  def free_spacing=(_arg0); end
-  def free_spacing?(input_object, options); end
-  def group_depth; end
-  def group_depth=(_arg0); end
-  def in_group?; end
-  def in_set?; end
-  def literal; end
-  def literal=(_arg0); end
-  def set_depth; end
-  def set_depth=(_arg0); end
-  def spacing_stack; end
-  def spacing_stack=(_arg0); end
-  def tokens; end
-  def tokens=(_arg0); end
-  def validation_error(type, what, reason = T.unsafe(nil)); end
-
-  class << self
-    def long_prop_map; end
-    def parse_prop_map(name); end
-    def posix_classes; end
-    def scan(input_object, options: T.unsafe(nil), &block); end
-    def short_prop_map; end
-  end
-end
-
-class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError
-  def initialize(what, reason); end
-end
-
-class Regexp::Scanner::InvalidGroupError < ::Regexp::Scanner::ValidationError
-  def initialize(what, reason); end
-end
-
-class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError
-  def initialize(option, text); end
-end
-
-class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError
-  def initialize(what = T.unsafe(nil), where = T.unsafe(nil)); end
-end
-
-class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError
-  def initialize(where = T.unsafe(nil)); end
-end
-
-class Regexp::Scanner::ScannerError < ::Regexp::Parser::Error; end
-
-class Regexp::Scanner::UnknownPosixClassError < ::Regexp::Scanner::ValidationError
-  def initialize(text); end
-end
-
-class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::ValidationError
-  def initialize(name); end
-end
-
-class Regexp::Scanner::ValidationError < ::Regexp::Parser::Error
-  def initialize(reason); end
-end
-
-module Regexp::Syntax
-  private
-
-  def comparable(name); end
-  def const_missing(const_name); end
-  def fallback_version_class(version); end
-  def for(name); end
-  def new(name); end
-  def specified_versions; end
-  def supported?(name); end
-  def version_class(version); end
-  def warn_if_future_version(const_name); end
-
-  class << self
-    def comparable(name); end
-    def const_missing(const_name); end
-    def fallback_version_class(version); end
-    def for(name); end
-    def new(name); end
-    def specified_versions; end
-    def supported?(name); end
-    def version_class(version); end
-    def warn_if_future_version(const_name); end
-  end
-end
-
-class Regexp::Syntax::Any < ::Regexp::Syntax::Base
-  class << self
-    def implements?(_type, _token); end
-  end
-end
-
-class Regexp::Syntax::Base
-  include ::Regexp::Syntax::Token
-
-  def initialize; end
-
-  def method_missing(name, *args); end
-
-  private
-
-  def respond_to_missing?(name, include_private = T.unsafe(nil)); end
-
-  class << self
-    def added_features; end
-    def check!(type, token); end
-    def check?(type, token); end
-    def excludes(type, tokens); end
-    def features; end
-    def features=(_arg0); end
-    def implementations(type); end
-    def implements(type, tokens); end
-    def implements!(type, token); end
-    def implements?(type, token); end
-    def inherited(subclass); end
-    def normalize(type, token); end
-    def normalize_backref(type, token); end
-    def normalize_group(type, token); end
-    def removed_features; end
-  end
-end
-
-class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError
-  def initialize(name); end
-end
-
-class Regexp::Syntax::NotImplementedError < ::Regexp::Syntax::SyntaxError
-  def initialize(syntax, type, token); end
-end
-
-class Regexp::Syntax::SyntaxError < ::Regexp::Parser::Error; end
-module Regexp::Syntax::Token; end
-Regexp::Syntax::Token::All = T.let(T.unsafe(nil), Array)
-module Regexp::Syntax::Token::Anchor; end
-Regexp::Syntax::Token::Anchor::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Anchor::Basic = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Anchor::Extended = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Anchor::MatchStart = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Anchor::String = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Anchor::Type = T.let(T.unsafe(nil), Symbol)
-module Regexp::Syntax::Token::Assertion; end
-Regexp::Syntax::Token::Assertion::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Assertion::Lookahead = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Assertion::Lookbehind = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Assertion::Type = T.let(T.unsafe(nil), Symbol)
-module Regexp::Syntax::Token::Backreference; end
-Regexp::Syntax::Token::Backreference::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Backreference::Name = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Backreference::Number = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Backreference::NumberRef = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Backreference::Plain = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Backreference::RecursionLevel = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Backreference::Type = T.let(T.unsafe(nil), Symbol)
-Regexp::Syntax::Token::Backreference::V1_8_6 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Backreference::V1_9_1 = T.let(T.unsafe(nil), Array)
-module Regexp::Syntax::Token::CharacterSet; end
-Regexp::Syntax::Token::CharacterSet::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::CharacterSet::Basic = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::CharacterSet::Extended = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::CharacterSet::Type = T.let(T.unsafe(nil), Symbol)
-module Regexp::Syntax::Token::CharacterType; end
-Regexp::Syntax::Token::CharacterType::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::CharacterType::Basic = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::CharacterType::Clustered = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::CharacterType::Extended = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::CharacterType::Hex = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::CharacterType::Type = T.let(T.unsafe(nil), Symbol)
-module Regexp::Syntax::Token::Conditional; end
-Regexp::Syntax::Token::Conditional::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Conditional::Condition = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Conditional::Delimiters = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Conditional::Separator = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Conditional::Type = T.let(T.unsafe(nil), Symbol)
-module Regexp::Syntax::Token::Escape; end
-Regexp::Syntax::Token::Escape::ASCII = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Escape::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Escape::Basic = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Escape::Control = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Escape::Hex = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Escape::Meta = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Escape::Octal = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Escape::Type = T.let(T.unsafe(nil), Symbol)
-Regexp::Syntax::Token::Escape::Unicode = T.let(T.unsafe(nil), Array)
-module Regexp::Syntax::Token::FreeSpace; end
-Regexp::Syntax::Token::FreeSpace::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::FreeSpace::Type = T.let(T.unsafe(nil), Symbol)
-module Regexp::Syntax::Token::Group; end
-Regexp::Syntax::Token::Group::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Group::Atomic = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Group::Basic = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Group::Comment = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Group::Extended = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Group::Named = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Group::Passive = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Group::Type = T.let(T.unsafe(nil), Symbol)
-Regexp::Syntax::Token::Group::V1_8_6 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Group::V2_4_1 = T.let(T.unsafe(nil), Array)
-module Regexp::Syntax::Token::Keep; end
-Regexp::Syntax::Token::Keep::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Keep::Mark = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Keep::Type = T.let(T.unsafe(nil), Symbol)
-module Regexp::Syntax::Token::Literal; end
-Regexp::Syntax::Token::Literal::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Literal::Type = T.let(T.unsafe(nil), Symbol)
-Regexp::Syntax::Token::Map = T.let(T.unsafe(nil), Hash)
-module Regexp::Syntax::Token::Meta; end
-Regexp::Syntax::Token::Meta::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Meta::Basic = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Meta::Extended = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Meta::Type = T.let(T.unsafe(nil), Symbol)
-module Regexp::Syntax::Token::PosixClass; end
-Regexp::Syntax::Token::PosixClass::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::PosixClass::Extensions = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::PosixClass::NonType = T.let(T.unsafe(nil), Symbol)
-Regexp::Syntax::Token::PosixClass::Standard = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::PosixClass::Type = T.let(T.unsafe(nil), Symbol)
-module Regexp::Syntax::Token::Quantifier; end
-Regexp::Syntax::Token::Quantifier::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Quantifier::Greedy = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Quantifier::Interval = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Quantifier::IntervalAll = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Quantifier::IntervalPossessive = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Quantifier::IntervalReluctant = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Quantifier::Possessive = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Quantifier::Reluctant = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Quantifier::Type = T.let(T.unsafe(nil), Symbol)
-Regexp::Syntax::Token::Quantifier::V1_8_6 = T.let(T.unsafe(nil), Array)
-module Regexp::Syntax::Token::SubexpressionCall; end
-Regexp::Syntax::Token::SubexpressionCall::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::SubexpressionCall::Name = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::SubexpressionCall::Number = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::Types = T.let(T.unsafe(nil), Array)
-module Regexp::Syntax::Token::UnicodeProperty; end
-Regexp::Syntax::Token::UnicodeProperty::Age = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Age_V1_9_3 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Age_V2_0_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Age_V2_2_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Age_V2_3_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Age_V2_4_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Age_V2_5_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_2 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_3 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Age_V3_1_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Age_V3_2_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::All = T.let(T.unsafe(nil), Array)
-module Regexp::Syntax::Token::UnicodeProperty::Category; end
-Regexp::Syntax::Token::UnicodeProperty::Category::All = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Category::Codepoint = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Category::Letter = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Category::Mark = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Category::Number = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Category::Punctuation = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Category::Separator = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Category::Symbol = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::CharType_V1_9_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::CharType_V2_5_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Derived = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Derived_V1_9_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Derived_V2_0_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Derived_V2_4_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Derived_V2_5_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Emoji = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_5_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::NonType = T.let(T.unsafe(nil), Symbol)
-Regexp::Syntax::Token::UnicodeProperty::POSIX = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Script = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_3 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Script_V2_0_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Script_V2_2_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Script_V2_3_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Script_V2_4_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Script_V2_5_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_2 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Script_V3_1_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Script_V3_2_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::Type = T.let(T.unsafe(nil), Symbol)
-Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V1_9_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_0_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_2_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_3_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_4_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_5_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_2 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_1_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_2_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::V1_9_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::V1_9_3 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::V2_0_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::V2_2_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::V2_3_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::V2_4_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::V2_5_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::V2_6_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::V2_6_2 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::V2_6_3 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::V3_1_0 = T.let(T.unsafe(nil), Array)
-Regexp::Syntax::Token::UnicodeProperty::V3_2_0 = T.let(T.unsafe(nil), Array)
-
-class Regexp::Syntax::UnknownSyntaxNameError < ::Regexp::Syntax::SyntaxError
-  def initialize(name); end
-end
-
-class Regexp::Syntax::V1_8_6 < ::Regexp::Syntax::Base; end
-class Regexp::Syntax::V1_9_1 < ::Regexp::Syntax::V1_8_6; end
-class Regexp::Syntax::V1_9_3 < ::Regexp::Syntax::V1_9_1; end
-class Regexp::Syntax::V2_0_0 < ::Regexp::Syntax::V1_9_3; end
-class Regexp::Syntax::V2_2_0 < ::Regexp::Syntax::V2_0_0; end
-class Regexp::Syntax::V2_3_0 < ::Regexp::Syntax::V2_2_0; end
-class Regexp::Syntax::V2_4_0 < ::Regexp::Syntax::V2_3_0; end
-class Regexp::Syntax::V2_4_1 < ::Regexp::Syntax::V2_4_0; end
-class Regexp::Syntax::V2_5_0 < ::Regexp::Syntax::V2_4_1; end
-class Regexp::Syntax::V2_6_0 < ::Regexp::Syntax::V2_5_0; end
-class Regexp::Syntax::V2_6_2 < ::Regexp::Syntax::V2_6_0; end
-class Regexp::Syntax::V2_6_3 < ::Regexp::Syntax::V2_6_2; end
-class Regexp::Syntax::V3_1_0 < ::Regexp::Syntax::V2_6_3; end
-class Regexp::Syntax::V3_2_0 < ::Regexp::Syntax::V3_1_0; end
-Regexp::Syntax::VERSION_CONST_REGEXP = T.let(T.unsafe(nil), Regexp)
-Regexp::Syntax::VERSION_FORMAT = T.let(T.unsafe(nil), String)
-Regexp::Syntax::VERSION_REGEXP = T.let(T.unsafe(nil), Regexp)
-Regexp::TOKEN_KEYS = T.let(T.unsafe(nil), Array)
-
-class Regexp::Token < ::Struct
-  def conditional_level; end
-  def conditional_level=(_); end
-  def length; end
-  def level; end
-  def level=(_); end
-  def next; end
-  def next=(_arg0); end
-  def offset; end
-  def previous; end
-  def previous=(_arg0); end
-  def set_level; end
-  def set_level=(_); end
-  def te; end
-  def te=(_); end
-  def text; end
-  def text=(_); end
-  def token; end
-  def token=(_); end
-  def ts; end
-  def ts=(_); end
-  def type; end
-  def type=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.9.2.rbi b/Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.9.2.rbi
new file mode 100644
index 0000000000000..eca8d5deb1c8b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.9.2.rbi
@@ -0,0 +1,3772 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `regexp_parser` gem.
+# Please instead update this file by running `bin/tapioca gem regexp_parser`.
+
+
+# source://regexp_parser//lib/regexp_parser/expression/shared.rb#1
+module Regexp::Expression; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#5
+class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
+  def alternatives; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#9
+  def human_name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#131
+  def match_length; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#6
+Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative
+
+# A sequence of expressions, used by Alternation as one of its alternatives.
+#
+# source://regexp_parser//lib/regexp_parser/expression/classes/alternation.rb#3
+class Regexp::Expression::Alternative < ::Regexp::Expression::Sequence
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#10
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#2
+module Regexp::Expression::Anchor; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#18
+Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#20
+Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#3
+class Regexp::Expression::Anchor::Base < ::Regexp::Expression::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
+  def match_length; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#5
+class Regexp::Expression::Anchor::BeginningOfLine < ::Regexp::Expression::Anchor::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#11
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#8
+class Regexp::Expression::Anchor::BeginningOfString < ::Regexp::Expression::Anchor::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#12
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#19
+Regexp::Expression::Anchor::EOL = Regexp::Expression::Anchor::EndOfLine
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#21
+Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#22
+Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#6
+class Regexp::Expression::Anchor::EndOfLine < ::Regexp::Expression::Anchor::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#13
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#9
+class Regexp::Expression::Anchor::EndOfString < ::Regexp::Expression::Anchor::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#14
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#11
+class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < ::Regexp::Expression::Anchor::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#15
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#16
+class Regexp::Expression::Anchor::MatchStart < ::Regexp::Expression::Anchor::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#16
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#14
+class Regexp::Expression::Anchor::NonWordBoundary < ::Regexp::Expression::Anchor::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#17
+  def human_name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#13
+  def negative?; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/anchor.rb#13
+class Regexp::Expression::Anchor::WordBoundary < ::Regexp::Expression::Anchor::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#18
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#64
+module Regexp::Expression::Assertion; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#65
+class Regexp::Expression::Assertion::Base < ::Regexp::Expression::Group::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
+  def match_length; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#67
+class Regexp::Expression::Assertion::Lookahead < ::Regexp::Expression::Assertion::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#19
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#70
+class Regexp::Expression::Assertion::Lookbehind < ::Regexp::Expression::Assertion::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#20
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#68
+class Regexp::Expression::Assertion::NegativeLookahead < ::Regexp::Expression::Assertion::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#21
+  def human_name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#14
+  def negative?; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#71
+class Regexp::Expression::Assertion::NegativeLookbehind < ::Regexp::Expression::Assertion::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#22
+  def human_name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#15
+  def negative?; end
+end
+
+# alias for symmetry between token symbol and Expression class name
+#
+# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#74
+Regexp::Expression::Backref = Regexp::Expression::Backreference
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#2
+module Regexp::Expression::Backreference; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#3
+class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#155
+  def match_length; end
+
+  # Returns the value of attribute referenced_expression.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#4
+  def referenced_expression; end
+
+  # Sets the attribute referenced_expression
+  #
+  # @param value the value to set the attribute referenced_expression to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#4
+  def referenced_expression=(_arg0); end
+
+  private
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#6
+  def initialize_copy(orig); end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#140
+    def referential?; end
+  end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#34
+class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base
+  # @return [Name] a new instance of Name
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#38
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#23
+  def human_name; end
+
+  # Returns the value of attribute name.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#35
+  def name; end
+
+  # Returns the value of attribute name.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#35
+  def reference; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#50
+class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#24
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#62
+class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name
+  # @return [NameRecursionLevel] a new instance of NameRecursionLevel
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#65
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # Returns the value of attribute recursion_level.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#63
+  def recursion_level; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#24
+class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base
+  # @return [Number] a new instance of Number
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#28
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#25
+  def human_name; end
+
+  # Returns the value of attribute number.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#25
+  def number; end
+
+  # Returns the value of attribute number.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#25
+  def reference; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#49
+class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#27
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#51
+class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#28
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#53
+class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::NumberRelative
+  # @return [NumberRecursionLevel] a new instance of NumberRecursionLevel
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#56
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # Returns the value of attribute recursion_level.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#54
+  def recursion_level; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#44
+class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::Backreference::Number
+  # Returns the value of attribute effective_number.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45
+  def effective_number; end
+
+  # Sets the attribute effective_number
+  #
+  # @param value the value to set the attribute effective_number to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45
+  def effective_number=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#26
+  def human_name; end
+
+  # Returns the value of attribute effective_number.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/backreference.rb#45
+  def reference; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/base.rb#2
+class Regexp::Expression::Base
+  include ::Regexp::Expression::Shared
+  extend ::Regexp::Expression::Shared::ClassMethods
+
+  # @return [Base] a new instance of Base
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/base.rb#5
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#8
+  def =~(string, offset = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#25
+  def a?; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#25
+  def ascii_classes?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/base.rb#60
+  def attributes; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#8
+  def case_insensitive?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def conditional_level; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def conditional_level=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def custom_to_s_handling; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def custom_to_s_handling=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#20
+  def d?; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#20
+  def default_classes?; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#14
+  def extended?; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#14
+  def free_spacing?; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/base.rb#47
+  def greedy?; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#8
+  def i?; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#8
+  def ignore_case?; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/base.rb#51
+  def lazy?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def level; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def level=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#3
+  def m?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#8
+  def match(string, offset = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#3
+  def match?(string); end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match.rb#3
+  def matches?(string); end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#3
+  def multiline?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14
+  def nesting_level; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def options; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def options=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def parent; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def parent=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/base.rb#56
+  def possessive?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def pre_quantifier_decorations; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def pre_quantifier_decorations=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14
+  def quantifier; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/base.rb#17
+  def quantify(*args); end
+
+  # Deprecated. Prefer `#repetitions` which has a more uniform interface.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/base.rb#26
+  def quantity; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/base.rb#51
+  def reluctant?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/base.rb#31
+  def repetitions; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def set_level; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def set_level=(_arg0); end
+
+  # %l  Level (depth) of the expression. Returns 'root' for the root
+  #       expression, returns zero or higher for all others.
+  #
+  #   %>  Indentation at expression's level.
+  #
+  #   %x  Index of the expression at its depth. Available when using
+  #       the sprintf_tree method only.
+  #
+  #   %s  Start offset within the whole expression.
+  #   %e  End offset within the whole expression.
+  #   %S  Length of expression.
+  #
+  #   %o  Coded offset and length, same as '@%s+%S'
+  #
+  #   %y  Type of expression.
+  #   %k  Token of expression.
+  #   %i  ID, same as '%y:%k'
+  #   %c  Class name
+  #
+  #   %q  Quantifier info, as {m[,M]}
+  #   %Q  Quantifier text
+  #
+  #   %z  Quantifier min
+  #   %Z  Quantifier max
+  #
+  #   %t  Base text of the expression (excludes quantifier, if any)
+  #   %~t Full text if the expression is terminal, otherwise %i
+  #   %T  Full text of the expression (includes quantifier, if any)
+  #
+  #   %b  Basic info, same as '%o %i'
+  #   %m  Most info, same as '%b %q'
+  #   %a  All info, same as '%m %t'
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#37
+  def strfre(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
+
+  # %l  Level (depth) of the expression. Returns 'root' for the root
+  #       expression, returns zero or higher for all others.
+  #
+  #   %>  Indentation at expression's level.
+  #
+  #   %x  Index of the expression at its depth. Available when using
+  #       the sprintf_tree method only.
+  #
+  #   %s  Start offset within the whole expression.
+  #   %e  End offset within the whole expression.
+  #   %S  Length of expression.
+  #
+  #   %o  Coded offset and length, same as '@%s+%S'
+  #
+  #   %y  Type of expression.
+  #   %k  Token of expression.
+  #   %i  ID, same as '%y:%k'
+  #   %c  Class name
+  #
+  #   %q  Quantifier info, as {m[,M]}
+  #   %Q  Quantifier text
+  #
+  #   %z  Quantifier min
+  #   %Z  Quantifier max
+  #
+  #   %t  Base text of the expression (excludes quantifier, if any)
+  #   %~t Full text if the expression is terminal, otherwise %i
+  #   %T  Full text of the expression (includes quantifier, if any)
+  #
+  #   %b  Basic info, same as '%o %i'
+  #   %m  Most info, same as '%b %q'
+  #   %a  All info, same as '%m %t'
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#37
+  def strfregexp(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def te; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def te=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def text; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def text=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/base.rb#60
+  def to_h; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/base.rb#9
+  def to_re(format = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def token; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def token=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def ts; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def ts=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def type; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def type=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#30
+  def u?; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#30
+  def unicode_classes?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/base.rb#21
+  def unquantified_clone; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/options.rb#14
+  def x?; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#2
+class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
+  # @return [CharacterSet] a new instance of CharacterSet
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#6
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#16
+  def close; end
+
+  # Returns the value of attribute closed.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
+  def closed; end
+
+  # Sets the attribute closed
+  #
+  # @param value the value to set the attribute closed to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
+  def closed=(_arg0); end
+
+  # Returns the value of attribute closed.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
+  def closed?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
+  def match_length; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#12
+  def negate; end
+
+  # Returns the value of attribute negative.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
+  def negative; end
+
+  # Sets the attribute negative
+  #
+  # @param value the value to set the attribute negative to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#3
+  def negative=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#16
+  def negative?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#15
+  def parts; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#3
+class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expression::Sequence
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#29
+  def human_name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
+  def match_length; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#5
+class Regexp::Expression::CharacterSet::Intersection < ::Regexp::Expression::SequenceOperation
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#30
+  def human_name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
+  def match_length; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_set/intersection.rb#6
+Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::CharacterSet::IntersectedSequence
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#3
+class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpression
+  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#8
+  def <<(exp); end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#14
+  def complete?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#31
+  def human_name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
+  def match_length; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#16
+  def parts; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/character_set/range.rb#4
+  def ts; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#2
+module Regexp::Expression::CharacterType; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#5
+class Regexp::Expression::CharacterType::Any < ::Regexp::Expression::CharacterType::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#32
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#3
+class Regexp::Expression::CharacterType::Base < ::Regexp::Expression::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
+  def match_length; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#17
+  def negative?; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#6
+class Regexp::Expression::CharacterType::Digit < ::Regexp::Expression::CharacterType::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#15
+class Regexp::Expression::CharacterType::ExtendedGrapheme < ::Regexp::Expression::CharacterType::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#8
+class Regexp::Expression::CharacterType::Hex < ::Regexp::Expression::CharacterType::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#14
+class Regexp::Expression::CharacterType::Linebreak < ::Regexp::Expression::CharacterType::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#7
+class Regexp::Expression::CharacterType::NonDigit < ::Regexp::Expression::CharacterType::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#9
+class Regexp::Expression::CharacterType::NonHex < ::Regexp::Expression::CharacterType::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#13
+class Regexp::Expression::CharacterType::NonSpace < ::Regexp::Expression::CharacterType::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#11
+class Regexp::Expression::CharacterType::NonWord < ::Regexp::Expression::CharacterType::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#12
+class Regexp::Expression::CharacterType::Space < ::Regexp::Expression::CharacterType::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_type.rb#10
+class Regexp::Expression::CharacterType::Word < ::Regexp::Expression::CharacterType::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#8
+class Regexp::Expression::Comment < ::Regexp::Expression::FreeSpace
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#33
+  def human_name; end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#130
+    def comment?; end
+  end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#2
+module Regexp::Expression::Conditional; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#25
+class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#34
+  def human_name; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#9
+class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#35
+  def human_name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
+  def match_length; end
+
+  # Name or number of the referenced capturing group that determines state.
+  # Returns a String if reference is by name, Integer if by number.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#14
+  def reference; end
+
+  # Returns the value of attribute referenced_expression.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#10
+  def referenced_expression; end
+
+  # Sets the attribute referenced_expression
+  #
+  # @param value the value to set the attribute referenced_expression to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#10
+  def referenced_expression=(_arg0); end
+
+  private
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#19
+  def initialize_copy(orig); end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#141
+    def referential?; end
+  end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#27
+class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#30
+  def <<(exp); end
+
+  # @raise [TooManyBranches]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34
+  def add_sequence(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end
+
+  # @raise [TooManyBranches]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#34
+  def branch(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#50
+  def branches; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#46
+  def condition; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#41
+  def condition=(exp); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#36
+  def human_name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#131
+  def match_length; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#17
+  def parts; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#54
+  def reference; end
+
+  # Returns the value of attribute referenced_expression.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#28
+  def referenced_expression; end
+
+  # Sets the attribute referenced_expression
+  #
+  # @param value the value to set the attribute referenced_expression to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#28
+  def referenced_expression=(_arg0); end
+
+  private
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#58
+  def initialize_copy(orig); end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#142
+    def referential?; end
+  end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#3
+class Regexp::Expression::Conditional::TooManyBranches < ::Regexp::Parser::Error
+  # @return [TooManyBranches] a new instance of TooManyBranches
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/conditional.rb#4
+  def initialize; end
+end
+
+# alias for symmetry between Token::* and Expression::*
+#
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#101
+Regexp::Expression::Escape = Regexp::Expression::EscapeSequence
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#2
+module Regexp::Expression::EscapeSequence; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#63
+class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp::Expression::EscapeSequence::Base
+  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#64
+  def char; end
+
+  private
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#70
+  def control_sequence_to_s(control_sequence); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#75
+  def meta_char_to_codepoint(meta_char); end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#27
+class Regexp::Expression::EscapeSequence::AsciiEscape < ::Regexp::Expression::EscapeSequence::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#28
+class Regexp::Expression::EscapeSequence::Backspace < ::Regexp::Expression::EscapeSequence::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#3
+class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base
+  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#9
+  def char; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#4
+  def codepoint; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
+  def match_length; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#29
+class Regexp::Expression::EscapeSequence::Bell < ::Regexp::Expression::EscapeSequence::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#37
+class Regexp::Expression::EscapeSequence::Codepoint < ::Regexp::Expression::EscapeSequence::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#39
+class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::EscapeSequence::Base
+  # @raise [NoMethodError]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#40
+  def char; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#48
+  def chars; end
+
+  # @raise [NoMethodError]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#44
+  def codepoint; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#52
+  def codepoints; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#164
+  def match_length; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#81
+class Regexp::Expression::EscapeSequence::Control < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
+  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#82
+  def codepoint; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#30
+class Regexp::Expression::EscapeSequence::FormFeed < ::Regexp::Expression::EscapeSequence::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#36
+class Regexp::Expression::EscapeSequence::Hex < ::Regexp::Expression::EscapeSequence::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#21
+class Regexp::Expression::EscapeSequence::Literal < ::Regexp::Expression::EscapeSequence::Base
+  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#22
+  def char; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#87
+class Regexp::Expression::EscapeSequence::Meta < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
+  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#88
+  def codepoint; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#93
+class Regexp::Expression::EscapeSequence::MetaControl < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence
+  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#94
+  def codepoint; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#31
+class Regexp::Expression::EscapeSequence::Newline < ::Regexp::Expression::EscapeSequence::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#57
+class Regexp::Expression::EscapeSequence::Octal < ::Regexp::Expression::EscapeSequence::Base
+  # source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#58
+  def char; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#32
+class Regexp::Expression::EscapeSequence::Return < ::Regexp::Expression::EscapeSequence::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#33
+class Regexp::Expression::EscapeSequence::Tab < ::Regexp::Expression::EscapeSequence::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/escape_sequence.rb#34
+class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::EscapeSequence::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#2
+class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
+  def match_length; end
+
+  # @raise [Regexp::Parser::Error]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#3
+  def quantify(*_args); end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#135
+    def decorative?; end
+  end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#2
+module Regexp::Expression::Group; end
+
+# Special case. Absence group can match 0.. chars, irrespective of content.
+# TODO: in theory, they *can* exclude match lengths with `.`: `(?~.{3})`
+#
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#19
+class Regexp::Expression::Group::Absence < ::Regexp::Expression::Group::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#172
+  def match_length; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#20
+class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#3
+class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression
+  # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#18
+  def parts; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#40
+class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#37
+  def human_name; end
+
+  # Returns the value of attribute number.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
+  def identifier; end
+
+  # Returns the value of attribute number.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
+  def number; end
+
+  # Sets the attribute number
+  #
+  # @param value the value to set the attribute number to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
+  def number=(_arg0); end
+
+  # Returns the value of attribute number_at_level.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
+  def number_at_level; end
+
+  # Sets the attribute number_at_level
+  #
+  # @param value the value to set the attribute number_at_level to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#41
+  def number_at_level=(_arg0); end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#126
+    def capturing?; end
+  end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#60
+class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#20
+  def parts; end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#131
+    def comment?; end
+
+    # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#136
+    def decorative?; end
+  end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#45
+class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture
+  # @return [Named] a new instance of Named
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#49
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#38
+  def human_name; end
+
+  # Returns the value of attribute name.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#46
+  def identifier; end
+
+  # Returns the value of attribute name.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#46
+  def name; end
+
+  private
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#54
+  def initialize_copy(orig); end
+end
+
+# TODO: should split off OptionsSwitch in v3.0.0. Maybe even make it no
+# longer inherit from Group because it is effectively a terminal expression.
+#
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#23
+class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base
+  # Returns the value of attribute option_changes.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#24
+  def option_changes; end
+
+  # Sets the attribute option_changes
+  #
+  # @param value the value to set the attribute option_changes to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#24
+  def option_changes=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#31
+  def quantify(*args); end
+
+  private
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#26
+  def initialize_copy(orig); end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#6
+class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base
+  # @return [Passive] a new instance of Passive
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#9
+  def initialize(*_arg0); end
+
+  # Sets the attribute implicit
+  #
+  # @param value the value to set the attribute implicit to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#7
+  def implicit=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/classes/group.rb#14
+  def implicit?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#19
+  def parts; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/keep.rb#2
+module Regexp::Expression::Keep; end
+
+# TODO: in regexp_parser v3.0.0 this should possibly be a Subexpression
+#       that contains all expressions to its left.
+#
+# source://regexp_parser//lib/regexp_parser/expression/classes/keep.rb#5
+class Regexp::Expression::Keep::Mark < ::Regexp::Expression::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#39
+  def human_name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#148
+  def match_length; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/literal.rb#2
+class Regexp::Expression::Literal < ::Regexp::Expression::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#40
+  def human_name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#105
+  def match_length; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#85
+Regexp::Expression::MatchLength = Regexp::MatchLength
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#10
+Regexp::Expression::Nonposixclass = Regexp::Expression::PosixClass
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#118
+Regexp::Expression::Nonproperty = Regexp::Expression::UnicodeProperty
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#2
+class Regexp::Expression::PosixClass < ::Regexp::Expression::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
+  def match_length; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#3
+  def name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#18
+  def negative?; end
+end
+
+# alias for symmetry between token symbol and Expression class name
+#
+# source://regexp_parser//lib/regexp_parser/expression/classes/posix_class.rb#9
+Regexp::Expression::Posixclass = Regexp::Expression::PosixClass
+
+# alias for symmetry between token symbol and Expression class name
+#
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#117
+Regexp::Expression::Property = Regexp::Expression::UnicodeProperty
+
+# TODO: in v3.0.0, maybe put Shared back into Base, and inherit from Base and
+# call super in #initialize, but raise in #quantifier= and #quantify,
+# or introduce an Expression::Quantifiable intermediate class.
+# Or actually allow chaining as a more concise but tricky solution than PR#69.
+#
+# source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#6
+class Regexp::Expression::Quantifier
+  include ::Regexp::Expression::Shared
+  extend ::Regexp::Expression::Shared::ClassMethods
+
+  # @return [Quantifier] a new instance of Quantifier
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#11
+  def initialize(*args); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def conditional_level; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def conditional_level=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def custom_to_s_handling; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def custom_to_s_handling=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31
+  def greedy?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31
+  def lazy?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def level; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def level=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#42
+  def max; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#38
+  def min; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#46
+  def mode; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14
+  def nesting_level; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def options; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def options=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def parent; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def parent=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31
+  def possessive?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def pre_quantifier_decorations; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def pre_quantifier_decorations=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#14
+  def quantifier; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#31
+  def reluctant?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def set_level; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def set_level=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def te; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def te=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def text; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def text=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#19
+  def to_h; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def token; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def token=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def ts; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def ts=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def type; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def type=(_arg0); end
+
+  private
+
+  # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#52
+  def deprecated_old_init(token, text, _min, _max, _mode = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#64
+  def derived_data; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/quantifier.rb#9
+Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/root.rb#2
+class Regexp::Expression::Root < ::Regexp::Expression::Subexpression
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#41
+  def human_name; end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/expression/classes/root.rb#3
+    def build(options = T.unsafe(nil)); end
+  end
+end
+
+# A sequence of expressions. Differs from a Subexpressions by how it handles
+# quantifiers, as it applies them to its last element instead of itself as
+# a whole subexpression.
+#
+# Used as the base class for the Alternation alternatives, Conditional
+# branches, and CharacterSet::Intersection intersected sequences.
+#
+# source://regexp_parser//lib/regexp_parser/expression/sequence.rb#8
+class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
+  # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#27
+  def quantify(token, *args); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#23
+  def ts; end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/expression/sequence.rb#10
+    def add_to(exp, params = T.unsafe(nil), active_opts = T.unsafe(nil)); end
+  end
+end
+
+# abstract class
+#
+# source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#3
+class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpression
+  # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#12
+  def <<(exp); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#16
+  def add_sequence(active_opts = T.unsafe(nil), params = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
+  def operands; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#9
+  def operator; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#22
+  def parts; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
+  def sequences; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/sequence_operation.rb#8
+  def ts; end
+end
+
+# alias for symmetry between token symbol and Expression class name
+#
+# source://regexp_parser//lib/regexp_parser/expression/classes/character_set.rb#22
+Regexp::Expression::Set = Regexp::Expression::CharacterSet
+
+# source://regexp_parser//lib/regexp_parser/expression/shared.rb#2
+module Regexp::Expression::Shared
+  mixes_in_class_methods ::Regexp::Expression::Shared::ClassMethods
+
+  # Deep-compare two expressions for equality.
+  #
+  # When changing the conditions, please make sure to update
+  # #pretty_print_instance_variables so that it includes all relevant values.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101
+  def ==(other); end
+
+  # Deep-compare two expressions for equality.
+  #
+  # When changing the conditions, please make sure to update
+  # #pretty_print_instance_variables so that it includes all relevant values.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101
+  def ===(other); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#51
+  def base_length; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#124
+  def capturing?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#96
+  def coded_offset; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#128
+  def comment?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#133
+  def decorative?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#47
+  def ends_at(include_quantifier = T.unsafe(nil)); end
+
+  # Deep-compare two expressions for equality.
+  #
+  # When changing the conditions, please make sure to update
+  # #pretty_print_instance_variables so that it includes all relevant values.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#101
+  def eql?(other); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#55
+  def full_length; end
+
+  # default implementation, e.g. "atomic group", "hex escape", "word type", ..
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#4
+  def human_name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#3
+  def inspect; end
+
+  # Test if this expression has the given test_token, and optionally a given
+  # test_type.
+  #
+  #   # Any expressions
+  #   exp.is? :*  # always returns true
+  #
+  #   # is it a :capture
+  #   exp.is? :capture
+  #
+  #   # is it a :character and a :set
+  #   exp.is? :character, :set
+  #
+  #   # is it a :meta :dot
+  #   exp.is? :dot, :meta
+  #
+  #   # is it a :meta or :escape :dot
+  #   exp.is? :dot, [:meta, :escape]
+  #
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#36
+  def is?(test_token, test_type = T.unsafe(nil)); end
+
+  # not an alias so as to respect overrides of #negative?
+  #
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#8
+  def negated?; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#3
+  def negative?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#100
+  def nesting_level=(lvl); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#92
+  def offset; end
+
+  # Test if this expression matches an entry in the given scope spec.
+  #
+  # A scope spec can be one of:
+  #
+  #   . An array: Interpreted as a set of tokens, tested for inclusion
+  #               of the expression's token.
+  #
+  #   . A hash:   Where the key is interpreted as the expression type
+  #               and the value is either a symbol or an array. In this
+  #               case, when the scope is a hash, one_of? calls itself to
+  #               evaluate the key's value.
+  #
+  #   . A symbol: matches the expression's token or type, depending on
+  #               the level of the call. If one_of? is called directly with
+  #               a symbol then it will always be checked against the
+  #               type of the expression. If it's being called for a value
+  #               from a hash, it will be checked against the token of the
+  #               expression.
+  #
+  #   # any expression
+  #   exp.one_of?(:*) # always true
+  #
+  #   # like exp.type?(:group)
+  #   exp.one_of?(:group)
+  #
+  #   # any expression of type meta
+  #   exp.one_of?(:meta => :*)
+  #
+  #   # meta dots and alternations
+  #   exp.one_of?(:meta => [:dot, :alternation])
+  #
+  #   # meta dots and any set tokens
+  #   exp.one_of?({meta: [:dot], set: :*})
+  #
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#75
+  def one_of?(scope, top = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#111
+  def optional?; end
+
+  # default implementation
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#4
+  def parts; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#84
+  def pre_quantifier_decoration(expression_format = T.unsafe(nil)); end
+
+  # Make pretty-print work despite #inspect implementation.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#12
+  def pretty_print(q); end
+
+  # Called by pretty_print (ruby/pp) and #inspect.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/printing.rb#17
+  def pretty_print_instance_variables; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#115
+  def quantified?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#106
+  def quantifier=(qtf); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#88
+  def quantifier_affix(expression_format = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#138
+  def referential?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#43
+  def starts_at; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#120
+  def terminal?; end
+
+  # #to_s reproduces the original source, as an unparser would.
+  #
+  # It takes an optional format argument.
+  #
+  # Example:
+  #
+  # lit = Regexp::Parser.parse(/a +/x)[0]
+  #
+  # lit.to_s            # => 'a+'  # default; with quantifier
+  # lit.to_s(:full)     # => 'a+'  # default; with quantifier
+  # lit.to_s(:base)     # => 'a'   # without quantifier
+  # lit.to_s(:original) # => 'a +' # with quantifier AND intermittent decorations
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#72
+  def to_s(format = T.unsafe(nil)); end
+
+  # #to_s reproduces the original source, as an unparser would.
+  #
+  # It takes an optional format argument.
+  #
+  # Example:
+  #
+  # lit = Regexp::Parser.parse(/a +/x)[0]
+  #
+  # lit.to_s            # => 'a+'  # default; with quantifier
+  # lit.to_s(:full)     # => 'a+'  # default; with quantifier
+  # lit.to_s(:base)     # => 'a'   # without quantifier
+  # lit.to_s(:original) # => 'a +' # with quantifier AND intermittent decorations
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#72
+  def to_str(format = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#37
+  def token_class; end
+
+  # Test if this expression has the given test_type, which can be either
+  # a symbol or an array of symbols to check against the expression's type.
+  #
+  #   # is it a :group expression
+  #   exp.type? :group
+  #
+  #   # is it a :set, or :meta
+  #   exp.type? [:set, :meta]
+  #
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#13
+  def type?(test_type); end
+
+  private
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#18
+  def init_from_token_and_options(token, options = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/shared.rb#32
+  def initialize_copy(orig); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#10
+  def intersperse(expressions, separator); end
+
+  class << self
+    # @private
+    #
+    # source://regexp_parser//lib/regexp_parser/expression/shared.rb#5
+    def included(mod); end
+  end
+end
+
+# filled in ./methods/*.rb
+#
+# source://regexp_parser//lib/regexp_parser/expression/shared.rb#3
+module Regexp::Expression::Shared::ClassMethods
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#125
+  def capturing?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#129
+  def comment?; end
+
+  # Convenience method to init a valid Expression without a Regexp::Token
+  #
+  # @raise [ArgumentError]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#5
+  def construct(params = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#15
+  def construct_defaults; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#134
+  def decorative?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#139
+  def referential?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#121
+  def terminal?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/construct.rb#25
+  def token_class; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#2
+class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
+  include ::Enumerable
+
+  # @return [Subexpression] a new instance of Subexpression
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#7
+  def initialize(token, options = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#20
+  def <<(exp); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
+  def [](*args, &block); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
+  def at(*args, &block); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#33
+  def dig(*indices); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
+  def each(*args, &block); end
+
+  # Traverses the expression, passing each recursive child to the
+  # given block.
+  # If the block takes two arguments, the indices of the children within
+  # their parents are also passed to it.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#8
+  def each_expression(include_self = T.unsafe(nil), &block); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
+  def empty?(*args, &block); end
+
+  # Returns the value of attribute expressions.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
+  def expressions; end
+
+  # Sets the attribute expressions
+  #
+  # @param value the value to set the attribute expressions to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#5
+  def expressions=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#50
+  def extract_quantifier_target(quantifier_description); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
+  def fetch(*args, &block); end
+
+  # Returns a new array with the results of calling the given block once
+  # for every expression. If a block is not given, returns an array with
+  # each expression and its level index as an array.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#56
+  def flat_map(include_self = T.unsafe(nil), &block); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
+  def index(*args, &block); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#118
+  def inner_match_length; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
+  def join(*args, &block); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
+  def last(*args, &block); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
+  def length(*args, &block); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#111
+  def match_length; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/parts.rb#21
+  def parts; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102
+  def strfre_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/strfregexp.rb#102
+  def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#39
+  def te; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#43
+  def to_h; end
+
+  # Traverses the subexpression (depth-first, pre-order) and calls the given
+  # block for each expression with three arguments; the traversal event,
+  # the expression, and the index of the expression within its parent.
+  #
+  # The event argument is passed as follows:
+  #
+  # - For subexpressions, :enter upon entering the subexpression, and
+  #   :exit upon exiting it.
+  #
+  # - For terminal expressions, :visit is called once.
+  #
+  # Returns self.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#32
+  def traverse(include_self = T.unsafe(nil), &block); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#27
+  def values_at(*args, &block); end
+
+  # Traverses the subexpression (depth-first, pre-order) and calls the given
+  # block for each expression with three arguments; the traversal event,
+  # the expression, and the index of the expression within its parent.
+  #
+  # The event argument is passed as follows:
+  #
+  # - For subexpressions, :enter upon entering the subexpression, and
+  #   :exit upon exiting it.
+  #
+  # - For terminal expressions, :visit is called once.
+  #
+  # Returns self.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#32
+  def walk(include_self = T.unsafe(nil), &block); end
+
+  protected
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#66
+  def each_expression_with_index(&block); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/traverse.rb#73
+  def each_expression_without_index(&block); end
+
+  private
+
+  # Override base method to clone the expressions as well.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/subexpression.rb#13
+  def initialize_copy(orig); end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/expression/methods/tests.rb#122
+    def terminal?; end
+  end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#2
+module Regexp::Expression::UnicodeProperty; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#108
+class Regexp::Expression::UnicodeProperty::Age < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#13
+class Regexp::Expression::UnicodeProperty::Alnum < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#14
+class Regexp::Expression::UnicodeProperty::Alpha < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#31
+class Regexp::Expression::UnicodeProperty::Any < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#15
+class Regexp::Expression::UnicodeProperty::Ascii < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#32
+class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#3
+class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#98
+  def match_length; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#4
+  def name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/negative.rb#19
+  def negative?; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#8
+  def shortcut; end
+end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#16
+class Regexp::Expression::UnicodeProperty::Blank < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#109
+class Regexp::Expression::UnicodeProperty::Block < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#17
+class Regexp::Expression::UnicodeProperty::Cntrl < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#97
+module Regexp::Expression::UnicodeProperty::Codepoint; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#100
+class Regexp::Expression::UnicodeProperty::Codepoint::Any < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#98
+class Regexp::Expression::UnicodeProperty::Codepoint::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#101
+class Regexp::Expression::UnicodeProperty::Codepoint::Control < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#102
+class Regexp::Expression::UnicodeProperty::Codepoint::Format < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#104
+class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#103
+class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#105
+class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#110
+class Regexp::Expression::UnicodeProperty::Derived < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#18
+class Regexp::Expression::UnicodeProperty::Digit < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#111
+class Regexp::Expression::UnicodeProperty::Emoji < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#112
+class Regexp::Expression::UnicodeProperty::Enumerated < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#19
+class Regexp::Expression::UnicodeProperty::Graph < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#34
+module Regexp::Expression::UnicodeProperty::Letter; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#37
+class Regexp::Expression::UnicodeProperty::Letter::Any < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#35
+class Regexp::Expression::UnicodeProperty::Letter::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#38
+class Regexp::Expression::UnicodeProperty::Letter::Cased < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#40
+class Regexp::Expression::UnicodeProperty::Letter::Lowercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#42
+class Regexp::Expression::UnicodeProperty::Letter::Modifier < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#43
+class Regexp::Expression::UnicodeProperty::Letter::Other < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#41
+class Regexp::Expression::UnicodeProperty::Letter::Titlecase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#39
+class Regexp::Expression::UnicodeProperty::Letter::Uppercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#20
+class Regexp::Expression::UnicodeProperty::Lower < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#46
+module Regexp::Expression::UnicodeProperty::Mark; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#49
+class Regexp::Expression::UnicodeProperty::Mark::Any < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#47
+class Regexp::Expression::UnicodeProperty::Mark::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#50
+class Regexp::Expression::UnicodeProperty::Mark::Combining < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#53
+class Regexp::Expression::UnicodeProperty::Mark::Enclosing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#51
+class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#52
+class Regexp::Expression::UnicodeProperty::Mark::Spacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#29
+class Regexp::Expression::UnicodeProperty::Newline < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#56
+module Regexp::Expression::UnicodeProperty::Number; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#59
+class Regexp::Expression::UnicodeProperty::Number::Any < ::Regexp::Expression::UnicodeProperty::Number::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#57
+class Regexp::Expression::UnicodeProperty::Number::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#60
+class Regexp::Expression::UnicodeProperty::Number::Decimal < ::Regexp::Expression::UnicodeProperty::Number::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#61
+class Regexp::Expression::UnicodeProperty::Number::Letter < ::Regexp::Expression::UnicodeProperty::Number::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#62
+class Regexp::Expression::UnicodeProperty::Number::Other < ::Regexp::Expression::UnicodeProperty::Number::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#21
+class Regexp::Expression::UnicodeProperty::Print < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#22
+class Regexp::Expression::UnicodeProperty::Punct < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#65
+module Regexp::Expression::UnicodeProperty::Punctuation; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#68
+class Regexp::Expression::UnicodeProperty::Punctuation::Any < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#66
+class Regexp::Expression::UnicodeProperty::Punctuation::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#72
+class Regexp::Expression::UnicodeProperty::Punctuation::Close < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#69
+class Regexp::Expression::UnicodeProperty::Punctuation::Connector < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#70
+class Regexp::Expression::UnicodeProperty::Punctuation::Dash < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#74
+class Regexp::Expression::UnicodeProperty::Punctuation::Final < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#73
+class Regexp::Expression::UnicodeProperty::Punctuation::Initial < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#71
+class Regexp::Expression::UnicodeProperty::Punctuation::Open < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#75
+class Regexp::Expression::UnicodeProperty::Punctuation::Other < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#113
+class Regexp::Expression::UnicodeProperty::Script < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#78
+module Regexp::Expression::UnicodeProperty::Separator; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#81
+class Regexp::Expression::UnicodeProperty::Separator::Any < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#79
+class Regexp::Expression::UnicodeProperty::Separator::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#83
+class Regexp::Expression::UnicodeProperty::Separator::Line < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#84
+class Regexp::Expression::UnicodeProperty::Separator::Paragraph < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#82
+class Regexp::Expression::UnicodeProperty::Separator::Space < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#23
+class Regexp::Expression::UnicodeProperty::Space < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#87
+module Regexp::Expression::UnicodeProperty::Symbol; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#90
+class Regexp::Expression::UnicodeProperty::Symbol::Any < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#88
+class Regexp::Expression::UnicodeProperty::Symbol::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#92
+class Regexp::Expression::UnicodeProperty::Symbol::Currency < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#91
+class Regexp::Expression::UnicodeProperty::Symbol::Math < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#93
+class Regexp::Expression::UnicodeProperty::Symbol::Modifier < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#94
+class Regexp::Expression::UnicodeProperty::Symbol::Other < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#24
+class Regexp::Expression::UnicodeProperty::Upper < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#25
+class Regexp::Expression::UnicodeProperty::Word < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#27
+class Regexp::Expression::UnicodeProperty::XPosixPunct < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/unicode_property.rb#26
+class Regexp::Expression::UnicodeProperty::Xdigit < ::Regexp::Expression::UnicodeProperty::Base; end
+
+# source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#11
+class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace
+  # source://regexp_parser//lib/regexp_parser/expression/methods/human_name.rb#42
+  def human_name; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/classes/free_space.rb#12
+  def merge(exp); end
+end
+
+# A very thin wrapper around the scanner that breaks quantified literal runs,
+# collects emitted tokens into an array, calculates their nesting depth, and
+# normalizes tokens for the parser, and checks if they are implemented by the
+# given syntax flavor.
+#
+# source://regexp_parser//lib/regexp_parser/lexer.rb#5
+class Regexp::Lexer
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#71
+  def emit(token); end
+
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#20
+  def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
+
+  private
+
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#91
+  def ascend(type, token); end
+
+  # Returns the value of attribute block.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def block; end
+
+  # Sets the attribute block
+  #
+  # @param value the value to set the attribute block to.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def block=(_arg0); end
+
+  # if a codepoint list is followed by a quantifier, that quantifier applies
+  # to the last codepoint, e.g. /\u{61 62 63}{3}/ =~ 'abccc'
+  # c.f. #break_literal.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#143
+  def break_codepoint_list(token); end
+
+  # called by scan to break a literal run that is longer than one character
+  # into two separate tokens when it is followed by a quantifier
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#123
+  def break_literal(token); end
+
+  # Returns the value of attribute collect_tokens.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def collect_tokens; end
+
+  # Sets the attribute collect_tokens
+  #
+  # @param value the value to set the attribute collect_tokens to.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def collect_tokens=(_arg0); end
+
+  # Returns the value of attribute conditional_nesting.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def conditional_nesting; end
+
+  # Sets the attribute conditional_nesting
+  #
+  # @param value the value to set the attribute conditional_nesting to.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def conditional_nesting=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#106
+  def descend(type, token); end
+
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#162
+  def merge_condition(current, last); end
+
+  # Returns the value of attribute nesting.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def nesting; end
+
+  # Sets the attribute nesting
+  #
+  # @param value the value to set the attribute nesting to.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def nesting=(_arg0); end
+
+  # Returns the value of attribute preprev_token.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def preprev_token; end
+
+  # Sets the attribute preprev_token
+  #
+  # @param value the value to set the attribute preprev_token to.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def preprev_token=(_arg0); end
+
+  # Returns the value of attribute prev_token.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def prev_token; end
+
+  # Sets the attribute prev_token
+  #
+  # @param value the value to set the attribute prev_token to.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def prev_token=(_arg0); end
+
+  # Returns the value of attribute set_nesting.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def set_nesting; end
+
+  # Sets the attribute set_nesting
+  #
+  # @param value the value to set the attribute set_nesting to.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def set_nesting=(_arg0); end
+
+  # Returns the value of attribute shift.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def shift; end
+
+  # Sets the attribute shift
+  #
+  # @param value the value to set the attribute shift to.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def shift=(_arg0); end
+
+  # Returns the value of attribute tokens.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def tokens; end
+
+  # Sets the attribute tokens
+  #
+  # @param value the value to set the attribute tokens to.
+  #
+  # source://regexp_parser//lib/regexp_parser/lexer.rb#87
+  def tokens=(_arg0); end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/lexer.rb#16
+    def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
+
+    # source://regexp_parser//lib/regexp_parser/lexer.rb#16
+    def scan(input, syntax = T.unsafe(nil), options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
+  end
+end
+
+# source://regexp_parser//lib/regexp_parser/lexer.rb#12
+Regexp::Lexer::CLOSING_TOKENS = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/lexer.rb#14
+Regexp::Lexer::CONDITION_TOKENS = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/lexer.rb#7
+Regexp::Lexer::OPENING_TOKENS = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#1
+class Regexp::MatchLength
+  include ::Enumerable
+
+  # @return [MatchLength] a new instance of MatchLength
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#9
+  def initialize(exp, opts = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#24
+  def each(opts = T.unsafe(nil)); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#35
+  def endless_each; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#44
+  def fixed?; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#40
+  def include?(length); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#60
+  def inspect; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#52
+  def max; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#48
+  def min; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#56
+  def minmax; end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#65
+  def to_re; end
+
+  private
+
+  # Returns the value of attribute base_max.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
+  def base_max; end
+
+  # Sets the attribute base_max
+  #
+  # @param value the value to set the attribute base_max to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
+  def base_max=(_arg0); end
+
+  # Returns the value of attribute base_min.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
+  def base_min; end
+
+  # Sets the attribute base_min
+  #
+  # @param value the value to set the attribute base_min to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
+  def base_min=(_arg0); end
+
+  # Returns the value of attribute exp_class.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
+  def exp_class; end
+
+  # Sets the attribute exp_class
+  #
+  # @param value the value to set the attribute exp_class to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
+  def exp_class=(_arg0); end
+
+  # Returns the value of attribute max_rep.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
+  def max_rep; end
+
+  # Sets the attribute max_rep
+  #
+  # @param value the value to set the attribute max_rep to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
+  def max_rep=(_arg0); end
+
+  # Returns the value of attribute min_rep.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
+  def min_rep; end
+
+  # Sets the attribute min_rep
+  #
+  # @param value the value to set the attribute min_rep to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
+  def min_rep=(_arg0); end
+
+  # Returns the value of attribute reify.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
+  def reify; end
+
+  # Sets the attribute reify
+  #
+  # @param value the value to set the attribute reify to.
+  #
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#71
+  def reify=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#74
+  def test_regexp; end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/expression/methods/match_length.rb#4
+    def of(obj); end
+  end
+end
+
+# source://regexp_parser//lib/regexp_parser/version.rb#2
+class Regexp::Parser
+  include ::Regexp::Expression
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#25
+  def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
+
+  private
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#574
+  def active_opts; end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#99
+  def anchor(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#262
+  def assign_effective_number(exp); end
+
+  # Assigns referenced expressions to referring expressions, e.g. if there is
+  # an instance of Backreference::Number, its #referenced_expression is set to
+  # the instance of Group::Capture that it refers to via its number.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#581
+  def assign_referenced_expressions; end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#227
+  def backref(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#202
+  def captured_group_count_at_level; end
+
+  # Returns the value of attribute captured_group_counts.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#56
+  def captured_group_counts; end
+
+  # Sets the attribute captured_group_counts
+  #
+  # @param value the value to set the attribute captured_group_counts to.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#56
+  def captured_group_counts=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#570
+  def close_completed_character_set_range; end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#210
+  def close_group; end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#538
+  def close_set; end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#269
+  def conditional(token); end
+
+  # Returns the value of attribute conditional_nesting.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#56
+  def conditional_nesting; end
+
+  # Sets the attribute conditional_nesting
+  #
+  # @param value the value to set the attribute conditional_nesting to.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#56
+  def conditional_nesting=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#206
+  def count_captured_group; end
+
+  # @yield [node]
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#216
+  def decrease_nesting; end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#305
+  def escape(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#60
+  def extract_options(input, options); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#349
+  def free_space(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#114
+  def group(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#509
+  def increase_group_level(exp); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#549
+  def intersection(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#360
+  def keep(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#364
+  def literal(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#368
+  def meta(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#534
+  def negate_set; end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#299
+  def nest(exp); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#294
+  def nest_conditional(exp); end
+
+  # Returns the value of attribute nesting.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#56
+  def nesting; end
+
+  # Sets the attribute nesting
+  #
+  # @param value the value to set the attribute nesting to.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#56
+  def nesting=(_arg0); end
+
+  # Returns the value of attribute node.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#56
+  def node; end
+
+  # Sets the attribute node
+  #
+  # @param value the value to set the attribute node to.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#56
+  def node=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#165
+  def open_group(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#527
+  def open_set(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#130
+  def options_group(token); end
+
+  # Returns the value of attribute options_stack.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#56
+  def options_stack; end
+
+  # Sets the attribute options_stack
+  #
+  # @param value the value to set the attribute options_stack to.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#56
+  def options_stack=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#76
+  def parse_token(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#390
+  def posixclass(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#397
+  def property(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#479
+  def quantifier(token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#542
+  def range(token); end
+
+  # Returns the value of attribute root.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#56
+  def root; end
+
+  # Sets the attribute root
+  #
+  # @param value the value to set the attribute root to.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#56
+  def root=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#379
+  def sequence_operation(klass, token); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#515
+  def set(token); end
+
+  # Returns the value of attribute switching_options.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#56
+  def switching_options; end
+
+  # Sets the attribute switching_options
+  #
+  # @param value the value to set the attribute switching_options to.
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#56
+  def switching_options=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#198
+  def total_captured_group_count; end
+
+  # source://regexp_parser//lib/regexp_parser/parser.rb#553
+  def type(token); end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/parser.rb#21
+    def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
+  end
+end
+
+# source://regexp_parser//lib/regexp_parser/parser.rb#128
+Regexp::Parser::ENC_FLAGS = T.let(T.unsafe(nil), Array)
+
+# base class for all gem-specific errors
+#
+# source://regexp_parser//lib/regexp_parser/error.rb#3
+class Regexp::Parser::Error < ::StandardError; end
+
+# source://regexp_parser//lib/regexp_parser/parser.rb#127
+Regexp::Parser::MOD_FLAGS = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/parser.rb#7
+class Regexp::Parser::ParserError < ::Regexp::Parser::Error; end
+
+# source://regexp_parser//lib/regexp_parser/parser.rb#394
+Regexp::Parser::UP = Regexp::Expression::UnicodeProperty
+
+# source://regexp_parser//lib/regexp_parser/parser.rb#395
+Regexp::Parser::UPTokens = Regexp::Syntax::Token::UnicodeProperty
+
+# source://regexp_parser//lib/regexp_parser/parser.rb#15
+class Regexp::Parser::UnknownTokenError < ::Regexp::Parser::ParserError
+  # @return [UnknownTokenError] a new instance of UnknownTokenError
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#16
+  def initialize(type, token); end
+end
+
+# source://regexp_parser//lib/regexp_parser/parser.rb#9
+class Regexp::Parser::UnknownTokenTypeError < ::Regexp::Parser::ParserError
+  # @return [UnknownTokenTypeError] a new instance of UnknownTokenTypeError
+  #
+  # source://regexp_parser//lib/regexp_parser/parser.rb#10
+  def initialize(type, token); end
+end
+
+# source://regexp_parser//lib/regexp_parser/version.rb#3
+Regexp::Parser::VERSION = T.let(T.unsafe(nil), String)
+
+# source://regexp_parser//lib/regexp_parser/scanner/errors/scanner_error.rb#3
+class Regexp::Scanner
+  # Emits an array with the details of the scanned pattern
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2406
+  def emit(type, token, text); end
+
+  # only public for #||= to work on ruby <= 2.5
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2431
+  def literal_run; end
+
+  # only public for #||= to work on ruby <= 2.5
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2431
+  def literal_run=(_arg0); end
+
+  # @raise [PrematureEndError]
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#24
+  def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
+
+  private
+
+  # Appends one or more characters to the literal buffer, to be emitted later
+  # by a call to emit_literal.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2468
+  def append_literal(data, ts, te); end
+
+  # Returns the value of attribute block.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def block; end
+
+  # Sets the attribute block
+  #
+  # @param value the value to set the attribute block to.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def block=(_arg0); end
+
+  # Returns the value of attribute char_pos.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def char_pos; end
+
+  # Sets the attribute char_pos
+  #
+  # @param value the value to set the attribute char_pos to.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def char_pos=(_arg0); end
+
+  # Returns the value of attribute collect_tokens.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def collect_tokens; end
+
+  # Sets the attribute collect_tokens
+  #
+  # @param value the value to set the attribute collect_tokens to.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def collect_tokens=(_arg0); end
+
+  # Returns the value of attribute conditional_stack.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def conditional_stack; end
+
+  # Sets the attribute conditional_stack
+  #
+  # @param value the value to set the attribute conditional_stack to.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def conditional_stack=(_arg0); end
+
+  # Copy from ts to te from data as text
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2462
+  def copy(data, ts, te); end
+
+  # Emits the literal run collected by calls to the append_literal method.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2473
+  def emit_literal; end
+
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2508
+  def emit_meta_control_sequence(data, ts, te, token); end
+
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2479
+  def emit_options(text); end
+
+  # Returns the value of attribute free_spacing.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def free_spacing; end
+
+  # Sets the attribute free_spacing
+  #
+  # @param value the value to set the attribute free_spacing to.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def free_spacing=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2441
+  def free_spacing?(input_object, options); end
+
+  # Returns the value of attribute group_depth.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def group_depth; end
+
+  # Sets the attribute group_depth
+  #
+  # @param value the value to set the attribute group_depth to.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def group_depth=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2453
+  def in_group?; end
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2457
+  def in_set?; end
+
+  # Returns the value of attribute prev_token.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def prev_token; end
+
+  # Sets the attribute prev_token
+  #
+  # @param value the value to set the attribute prev_token to.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def prev_token=(_arg0); end
+
+  # Returns the value of attribute set_depth.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def set_depth; end
+
+  # Sets the attribute set_depth
+  #
+  # @param value the value to set the attribute set_depth to.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def set_depth=(_arg0); end
+
+  # Returns the value of attribute spacing_stack.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def spacing_stack; end
+
+  # Sets the attribute spacing_stack
+  #
+  # @param value the value to set the attribute spacing_stack to.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def spacing_stack=(_arg0); end
+
+  # Returns the value of attribute tokens.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def tokens; end
+
+  # Sets the attribute tokens
+  #
+  # @param value the value to set the attribute tokens to.
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner.rb#2435
+  def tokens=(_arg0); end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/scanner.rb#2392
+    def long_prop_map; end
+
+    # source://regexp_parser//lib/regexp_parser/scanner.rb#2396
+    def parse_prop_map(name); end
+
+    # source://regexp_parser//lib/regexp_parser/scanner.rb#2400
+    def posix_classes; end
+
+    # Scans the given regular expression text, or Regexp object and collects the
+    # emitted token into an array that gets returned at the end. If a block is
+    # given, it gets called for each emitted token.
+    #
+    # This method may raise errors if a syntax error is encountered.
+    # --------------------------------------------------------------------------
+    #
+    # source://regexp_parser//lib/regexp_parser/scanner.rb#20
+    def scan(input_object, options: T.unsafe(nil), collect_tokens: T.unsafe(nil), &block); end
+
+    # lazy-load property maps when first needed
+    #
+    # source://regexp_parser//lib/regexp_parser/scanner.rb#2388
+    def short_prop_map; end
+  end
+end
+
+# Invalid back reference. Used for name a number refs/calls.
+#
+# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#44
+class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError
+  # @return [InvalidBackrefError] a new instance of InvalidBackrefError
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#45
+  def initialize(what, reason); end
+end
+
+# Invalid group. Used for named groups.
+#
+# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#29
+class Regexp::Scanner::InvalidGroupError < ::Regexp::Scanner::ValidationError
+  # @return [InvalidGroupError] a new instance of InvalidGroupError
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#30
+  def initialize(what, reason); end
+end
+
+# Invalid groupOption. Used for inline options.
+# TODO: should become InvalidGroupOptionError in v3.0.0 for consistency
+#
+# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#37
+class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError
+  # @return [InvalidGroupOption] a new instance of InvalidGroupOption
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#38
+  def initialize(option, text); end
+end
+
+# Invalid sequence format. Used for escape sequences, mainly.
+#
+# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#22
+class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError
+  # @return [InvalidSequenceError] a new instance of InvalidSequenceError
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#23
+  def initialize(what = T.unsafe(nil), where = T.unsafe(nil)); end
+end
+
+# Unexpected end of pattern
+#
+# source://regexp_parser//lib/regexp_parser/scanner/errors/premature_end_error.rb#3
+class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError
+  # @return [PrematureEndError] a new instance of PrematureEndError
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner/errors/premature_end_error.rb#4
+  def initialize(where = T.unsafe(nil)); end
+end
+
+# General scanner error (catch all)
+#
+# source://regexp_parser//lib/regexp_parser/scanner/errors/scanner_error.rb#5
+class Regexp::Scanner::ScannerError < ::Regexp::Parser::Error; end
+
+# The POSIX class name was not recognized by the scanner.
+#
+# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#58
+class Regexp::Scanner::UnknownPosixClassError < ::Regexp::Scanner::ValidationError
+  # @return [UnknownPosixClassError] a new instance of UnknownPosixClassError
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#59
+  def initialize(text, _); end
+end
+
+# The property name was not recognized by the scanner.
+#
+# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#51
+class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::ValidationError
+  # @return [UnknownUnicodePropertyError] a new instance of UnknownUnicodePropertyError
+  #
+  # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#52
+  def initialize(name, _); end
+end
+
+# Base for all scanner validation errors
+#
+# source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#4
+class Regexp::Scanner::ValidationError < ::Regexp::Scanner::ScannerError
+  class << self
+    # Centralizes and unifies the handling of validation related errors.
+    #
+    # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#5
+    def for(type, problem, reason = T.unsafe(nil)); end
+
+    # source://regexp_parser//lib/regexp_parser/scanner/errors/validation_error.rb#9
+    def types; end
+  end
+end
+
+# After loading all the tokens the map is full. Extract all tokens and types
+# into the All and Types constants.
+#
+# source://regexp_parser//lib/regexp_parser/syntax.rb#3
+module Regexp::Syntax
+  private
+
+  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#61
+  def comparable(name); end
+
+  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#44
+  def const_missing(const_name); end
+
+  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#51
+  def fallback_version_class(version); end
+
+  # Returns the syntax specification class for the given syntax
+  # version name. The special names 'any' and '*' return Syntax::Any.
+  #
+  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#22
+  def for(name); end
+
+  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#26
+  def new(name); end
+
+  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#57
+  def specified_versions; end
+
+  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#32
+  def supported?(name); end
+
+  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#36
+  def version_class(version); end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#61
+    def comparable(name); end
+
+    # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#44
+    def const_missing(const_name); end
+
+    # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#51
+    def fallback_version_class(version); end
+
+    # Returns the syntax specification class for the given syntax
+    # version name. The special names 'any' and '*' return Syntax::Any.
+    #
+    # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#22
+    def for(name); end
+
+    # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#26
+    def new(name); end
+
+    # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#57
+    def specified_versions; end
+
+    # @return [Boolean]
+    #
+    # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#32
+    def supported?(name); end
+
+    # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#36
+    def version_class(version); end
+  end
+end
+
+# A syntax that always returns true, passing all tokens as implemented. This
+# is useful during development, testing, and should be useful for some types
+# of transformations as well.
+#
+# source://regexp_parser//lib/regexp_parser/syntax/any.rb#5
+class Regexp::Syntax::Any < ::Regexp::Syntax::Base
+  class << self
+    # @return [Boolean]
+    #
+    # source://regexp_parser//lib/regexp_parser/syntax/any.rb#8
+    def implements?(_type, _token); end
+  end
+end
+
+# A lookup map of supported types and tokens in a given syntax
+#
+# source://regexp_parser//lib/regexp_parser/syntax/base.rb#9
+class Regexp::Syntax::Base
+  include ::Regexp::Syntax::Token
+
+  # TODO: drop this backwards compatibility code in v3.0.0, do `private :new`
+  #
+  # @return [Base] a new instance of Base
+  #
+  # source://regexp_parser//lib/regexp_parser/syntax/base.rb#99
+  def initialize; end
+
+  # source://regexp_parser//lib/regexp_parser/syntax/base.rb#104
+  def method_missing(name, *args); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://regexp_parser//lib/regexp_parser/syntax/base.rb#115
+  def respond_to_missing?(name, include_private = T.unsafe(nil)); end
+
+  class << self
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#46
+    def added_features; end
+
+    # @raise [NotImplementedError]
+    #
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#40
+    def check!(type, token); end
+
+    # @return [Boolean]
+    #
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#31
+    def check?(type, token); end
+
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#26
+    def excludes(type, tokens); end
+
+    # Returns the value of attribute features.
+    #
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#13
+    def features; end
+
+    # Sets the attribute features
+    #
+    # @param value the value to set the attribute features to.
+    #
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#13
+    def features=(_arg0); end
+
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#36
+    def implementations(type); end
+
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#21
+    def implements(type, tokens); end
+
+    # @raise [NotImplementedError]
+    #
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#40
+    def implements!(type, token); end
+
+    # @return [Boolean]
+    #
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#31
+    def implements?(type, token); end
+
+    # automatically inherit features through the syntax class hierarchy
+    #
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#16
+    def inherited(subclass); end
+
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#54
+    def normalize(type, token); end
+
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#74
+    def normalize_backref(type, token); end
+
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#65
+    def normalize_group(type, token); end
+
+    # source://regexp_parser//lib/regexp_parser/syntax/base.rb#50
+    def removed_features; end
+  end
+end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions.rb#8
+Regexp::Syntax::CURRENT = Regexp::Syntax::V3_1_0
+
+# source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#6
+class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError
+  # @return [InvalidVersionNameError] a new instance of InvalidVersionNameError
+  #
+  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#7
+  def initialize(name); end
+end
+
+# source://regexp_parser//lib/regexp_parser/syntax/base.rb#2
+class Regexp::Syntax::NotImplementedError < ::Regexp::Syntax::SyntaxError
+  # @return [NotImplementedError] a new instance of NotImplementedError
+  #
+  # source://regexp_parser//lib/regexp_parser/syntax/base.rb#3
+  def initialize(syntax, type, token); end
+end
+
+# source://regexp_parser//lib/regexp_parser/syntax.rb#4
+class Regexp::Syntax::SyntaxError < ::Regexp::Parser::Error; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token.rb#3
+module Regexp::Syntax::Token; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token.rb#42
+Regexp::Syntax::Token::All = T.let(T.unsafe(nil), Array)
+
+# alias for symmetry between Token::* and Expression::*
+#
+# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#15
+module Regexp::Syntax::Token::Alternation; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#16
+Regexp::Syntax::Token::Alternation::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#17
+Regexp::Syntax::Token::Alternation::Type = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#3
+module Regexp::Syntax::Token::Anchor; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#9
+Regexp::Syntax::Token::Anchor::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#4
+Regexp::Syntax::Token::Anchor::Basic = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#5
+Regexp::Syntax::Token::Anchor::Extended = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#7
+Regexp::Syntax::Token::Anchor::MatchStart = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#6
+Regexp::Syntax::Token::Anchor::String = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/anchor.rb#10
+Regexp::Syntax::Token::Anchor::Type = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#3
+module Regexp::Syntax::Token::Assertion; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#7
+Regexp::Syntax::Token::Assertion::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#4
+Regexp::Syntax::Token::Assertion::Lookahead = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#5
+Regexp::Syntax::Token::Assertion::Lookbehind = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/assertion.rb#8
+Regexp::Syntax::Token::Assertion::Type = T.let(T.unsafe(nil), Symbol)
+
+# alias for symmetry between token symbol and Expression class name
+#
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#31
+Regexp::Syntax::Token::Backref = Regexp::Syntax::Token::Backreference
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#3
+module Regexp::Syntax::Token::Backreference; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#15
+Regexp::Syntax::Token::Backreference::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#7
+Regexp::Syntax::Token::Backreference::Name = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#6
+Regexp::Syntax::Token::Backreference::Number = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#5
+Regexp::Syntax::Token::Backreference::NumberRef = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#4
+Regexp::Syntax::Token::Backreference::Plain = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#9
+Regexp::Syntax::Token::Backreference::RecursionLevel = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#16
+Regexp::Syntax::Token::Backreference::Type = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#11
+Regexp::Syntax::Token::Backreference::V1_8_6 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#13
+Regexp::Syntax::Token::Backreference::V1_9_1 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#3
+module Regexp::Syntax::Token::CharacterSet; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#7
+Regexp::Syntax::Token::CharacterSet::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#4
+Regexp::Syntax::Token::CharacterSet::Basic = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#5
+Regexp::Syntax::Token::CharacterSet::Extended = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#8
+Regexp::Syntax::Token::CharacterSet::Type = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#3
+module Regexp::Syntax::Token::CharacterType; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#10
+Regexp::Syntax::Token::CharacterType::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#4
+Regexp::Syntax::Token::CharacterType::Basic = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#8
+Regexp::Syntax::Token::CharacterType::Clustered = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#5
+Regexp::Syntax::Token::CharacterType::Extended = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#6
+Regexp::Syntax::Token::CharacterType::Hex = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/character_type.rb#11
+Regexp::Syntax::Token::CharacterType::Type = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#3
+module Regexp::Syntax::Token::Conditional; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#9
+Regexp::Syntax::Token::Conditional::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#6
+Regexp::Syntax::Token::Conditional::Condition = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#4
+Regexp::Syntax::Token::Conditional::Delimiters = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#7
+Regexp::Syntax::Token::Conditional::Separator = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/conditional.rb#11
+Regexp::Syntax::Token::Conditional::Type = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#3
+module Regexp::Syntax::Token::Escape; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#8
+Regexp::Syntax::Token::Escape::ASCII = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#24
+Regexp::Syntax::Token::Escape::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#4
+Regexp::Syntax::Token::Escape::Basic = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#6
+Regexp::Syntax::Token::Escape::Control = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#20
+Regexp::Syntax::Token::Escape::Hex = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#13
+Regexp::Syntax::Token::Escape::Meta = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#22
+Regexp::Syntax::Token::Escape::Octal = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#25
+Regexp::Syntax::Token::Escape::Type = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#11
+Regexp::Syntax::Token::Escape::Unicode = T.let(T.unsafe(nil), Array)
+
+# alias for symmetry between Token::* and Expression::*
+#
+# source://regexp_parser//lib/regexp_parser/syntax/token/escape.rb#31
+Regexp::Syntax::Token::EscapeSequence = Regexp::Syntax::Token::Escape
+
+# source://regexp_parser//lib/regexp_parser/syntax/token.rb#11
+module Regexp::Syntax::Token::FreeSpace; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token.rb#12
+Regexp::Syntax::Token::FreeSpace::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token.rb#13
+Regexp::Syntax::Token::FreeSpace::Type = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#3
+module Regexp::Syntax::Token::Group; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#17
+Regexp::Syntax::Token::Group::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#8
+Regexp::Syntax::Token::Group::Atomic = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#4
+Regexp::Syntax::Token::Group::Basic = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#10
+Regexp::Syntax::Token::Group::Comment = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#5
+Regexp::Syntax::Token::Group::Extended = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#7
+Regexp::Syntax::Token::Group::Named = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#9
+Regexp::Syntax::Token::Group::Passive = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#18
+Regexp::Syntax::Token::Group::Type = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#12
+Regexp::Syntax::Token::Group::V1_8_6 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/group.rb#15
+Regexp::Syntax::Token::Group::V2_4_1 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#3
+module Regexp::Syntax::Token::Keep; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#6
+Regexp::Syntax::Token::Keep::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#4
+Regexp::Syntax::Token::Keep::Mark = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/keep.rb#7
+Regexp::Syntax::Token::Keep::Type = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token.rb#6
+module Regexp::Syntax::Token::Literal; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token.rb#7
+Regexp::Syntax::Token::Literal::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token.rb#8
+Regexp::Syntax::Token::Literal::Type = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token.rb#4
+Regexp::Syntax::Token::Map = T.let(T.unsafe(nil), Hash)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#3
+module Regexp::Syntax::Token::Meta; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#8
+Regexp::Syntax::Token::Meta::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#5
+Regexp::Syntax::Token::Meta::Alternation = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#4
+Regexp::Syntax::Token::Meta::Basic = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#6
+Regexp::Syntax::Token::Meta::Extended = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/meta.rb#9
+Regexp::Syntax::Token::Meta::Type = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#3
+module Regexp::Syntax::Token::PosixClass; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#9
+Regexp::Syntax::Token::PosixClass::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#7
+Regexp::Syntax::Token::PosixClass::Extensions = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#11
+Regexp::Syntax::Token::PosixClass::NonType = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#4
+Regexp::Syntax::Token::PosixClass::Standard = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/posix_class.rb#10
+Regexp::Syntax::Token::PosixClass::Type = T.let(T.unsafe(nil), Symbol)
+
+# alias for symmetry between token symbol and Token module name
+#
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#749
+Regexp::Syntax::Token::Property = Regexp::Syntax::Token::UnicodeProperty
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#3
+module Regexp::Syntax::Token::Quantifier; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#29
+Regexp::Syntax::Token::Quantifier::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#4
+Regexp::Syntax::Token::Quantifier::Greedy = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#22
+Regexp::Syntax::Token::Quantifier::Interval = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#26
+Regexp::Syntax::Token::Quantifier::IntervalAll = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#24
+Regexp::Syntax::Token::Quantifier::IntervalPossessive = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#23
+Regexp::Syntax::Token::Quantifier::IntervalReluctant = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#16
+Regexp::Syntax::Token::Quantifier::Possessive = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#10
+Regexp::Syntax::Token::Quantifier::Reluctant = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#30
+Regexp::Syntax::Token::Quantifier::Type = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/quantifier.rb#28
+Regexp::Syntax::Token::Quantifier::V1_8_6 = T.let(T.unsafe(nil), Array)
+
+# alias for symmetry between token symbol and Token module name
+#
+# source://regexp_parser//lib/regexp_parser/syntax/token/character_set.rb#14
+Regexp::Syntax::Token::Set = Regexp::Syntax::Token::CharacterSet
+
+# Type is the same as Backreference so keeping it here, for now.
+#
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#20
+module Regexp::Syntax::Token::SubexpressionCall; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#24
+Regexp::Syntax::Token::SubexpressionCall::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#21
+Regexp::Syntax::Token::SubexpressionCall::Name = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/backreference.rb#22
+Regexp::Syntax::Token::SubexpressionCall::Number = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token.rb#43
+Regexp::Syntax::Token::Types = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#3
+module Regexp::Syntax::Token::UnicodeProperty; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#64
+Regexp::Syntax::Token::UnicodeProperty::Age = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#40
+Regexp::Syntax::Token::UnicodeProperty::Age_V1_9_3 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#44
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_0_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#46
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_2_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#48
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_3_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#50
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_4_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#52
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_5_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#54
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#56
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_2 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#58
+Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_3 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#60
+Regexp::Syntax::Token::UnicodeProperty::Age_V3_1_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#62
+Regexp::Syntax::Token::UnicodeProperty::Age_V3_2_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#739
+Regexp::Syntax::Token::UnicodeProperty::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#13
+module Regexp::Syntax::Token::UnicodeProperty::Category; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#36
+Regexp::Syntax::Token::UnicodeProperty::Category::All = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#33
+Regexp::Syntax::Token::UnicodeProperty::Category::Codepoint = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#14
+Regexp::Syntax::Token::UnicodeProperty::Category::Letter = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#17
+Regexp::Syntax::Token::UnicodeProperty::Category::Mark = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#20
+Regexp::Syntax::Token::UnicodeProperty::Category::Number = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#23
+Regexp::Syntax::Token::UnicodeProperty::Category::Punctuation = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#30
+Regexp::Syntax::Token::UnicodeProperty::Category::Separator = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#27
+Regexp::Syntax::Token::UnicodeProperty::Category::Symbol = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#6
+Regexp::Syntax::Token::UnicodeProperty::CharType_V1_9_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#9
+Regexp::Syntax::Token::UnicodeProperty::CharType_V2_5_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#133
+Regexp::Syntax::Token::UnicodeProperty::Derived = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#66
+Regexp::Syntax::Token::UnicodeProperty::Derived_V1_9_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#120
+Regexp::Syntax::Token::UnicodeProperty::Derived_V2_0_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#125
+Regexp::Syntax::Token::UnicodeProperty::Derived_V2_4_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#129
+Regexp::Syntax::Token::UnicodeProperty::Derived_V2_5_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#724
+Regexp::Syntax::Token::UnicodeProperty::Emoji = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#694
+Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_5_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#702
+Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_6_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#722
+Regexp::Syntax::Token::UnicodeProperty::Enumerated = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#706
+Regexp::Syntax::Token::UnicodeProperty::Enumerated_V2_4_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#742
+Regexp::Syntax::Token::UnicodeProperty::NonType = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#11
+Regexp::Syntax::Token::UnicodeProperty::POSIX = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#332
+Regexp::Syntax::Token::UnicodeProperty::Script = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#135
+Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#231
+Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_3 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#237
+Regexp::Syntax::Token::UnicodeProperty::Script_V2_0_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#247
+Regexp::Syntax::Token::UnicodeProperty::Script_V2_2_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#273
+Regexp::Syntax::Token::UnicodeProperty::Script_V2_3_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#282
+Regexp::Syntax::Token::UnicodeProperty::Script_V2_4_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#291
+Regexp::Syntax::Token::UnicodeProperty::Script_V2_5_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#298
+Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#308
+Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_2 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#315
+Regexp::Syntax::Token::UnicodeProperty::Script_V3_1_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#322
+Regexp::Syntax::Token::UnicodeProperty::Script_V3_2_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#741
+Regexp::Syntax::Token::UnicodeProperty::Type = T.let(T.unsafe(nil), Symbol)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#692
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#334
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V1_9_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#433
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_0_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#561
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_2_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#596
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_3_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#609
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_4_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#623
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_5_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#633
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#647
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_2 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#659
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_1_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#670
+Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_2_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#726
+Regexp::Syntax::Token::UnicodeProperty::V1_9_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#727
+Regexp::Syntax::Token::UnicodeProperty::V1_9_3 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#728
+Regexp::Syntax::Token::UnicodeProperty::V2_0_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#729
+Regexp::Syntax::Token::UnicodeProperty::V2_2_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#730
+Regexp::Syntax::Token::UnicodeProperty::V2_3_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#731
+Regexp::Syntax::Token::UnicodeProperty::V2_4_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#732
+Regexp::Syntax::Token::UnicodeProperty::V2_5_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#733
+Regexp::Syntax::Token::UnicodeProperty::V2_6_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#734
+Regexp::Syntax::Token::UnicodeProperty::V2_6_2 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#735
+Regexp::Syntax::Token::UnicodeProperty::V2_6_3 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#736
+Regexp::Syntax::Token::UnicodeProperty::V3_1_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/token/unicode_property.rb#737
+Regexp::Syntax::Token::UnicodeProperty::V3_2_0 = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#12
+class Regexp::Syntax::UnknownSyntaxNameError < ::Regexp::Syntax::SyntaxError
+  # @return [UnknownSyntaxNameError] a new instance of UnknownSyntaxNameError
+  #
+  # source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#13
+  def initialize(name); end
+end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions/1.8.6.rb#1
+class Regexp::Syntax::V1_8_6 < ::Regexp::Syntax::Base; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions/1.9.1.rb#1
+class Regexp::Syntax::V1_9_1 < ::Regexp::Syntax::V1_8_6; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions/1.9.3.rb#1
+class Regexp::Syntax::V1_9_3 < ::Regexp::Syntax::V1_9_1; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions/2.0.0.rb#1
+class Regexp::Syntax::V2_0_0 < ::Regexp::Syntax::V1_9_3; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions/2.2.0.rb#1
+class Regexp::Syntax::V2_2_0 < ::Regexp::Syntax::V2_0_0; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions/2.3.0.rb#1
+class Regexp::Syntax::V2_3_0 < ::Regexp::Syntax::V2_2_0; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions/2.4.0.rb#1
+class Regexp::Syntax::V2_4_0 < ::Regexp::Syntax::V2_3_0; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions/2.4.1.rb#1
+class Regexp::Syntax::V2_4_1 < ::Regexp::Syntax::V2_4_0; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions/2.5.0.rb#1
+class Regexp::Syntax::V2_5_0 < ::Regexp::Syntax::V2_4_1; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.0.rb#1
+class Regexp::Syntax::V2_6_0 < ::Regexp::Syntax::V2_5_0; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.2.rb#1
+class Regexp::Syntax::V2_6_2 < ::Regexp::Syntax::V2_6_0; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions/2.6.3.rb#1
+class Regexp::Syntax::V2_6_3 < ::Regexp::Syntax::V2_6_2; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions/3.1.0.rb#1
+class Regexp::Syntax::V3_1_0 < ::Regexp::Syntax::V2_6_3; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/versions/3.2.0.rb#1
+class Regexp::Syntax::V3_2_0 < ::Regexp::Syntax::V3_1_0; end
+
+# source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#4
+Regexp::Syntax::VERSION_CONST_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#2
+Regexp::Syntax::VERSION_FORMAT = T.let(T.unsafe(nil), String)
+
+# source://regexp_parser//lib/regexp_parser/syntax/version_lookup.rb#3
+Regexp::Syntax::VERSION_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://regexp_parser//lib/regexp_parser/token.rb#2
+Regexp::TOKEN_KEYS = T.let(T.unsafe(nil), Array)
+
+# source://regexp_parser//lib/regexp_parser/token.rb#13
+class Regexp::Token < ::Struct
+  def conditional_level; end
+  def conditional_level=(_); end
+
+  # source://regexp_parser//lib/regexp_parser/token.rb#20
+  def length; end
+
+  def level; end
+  def level=(_); end
+
+  # Returns the value of attribute next.
+  #
+  # source://regexp_parser//lib/regexp_parser/token.rb#14
+  def next; end
+
+  # Sets the attribute next
+  #
+  # @param value the value to set the attribute next to.
+  #
+  # source://regexp_parser//lib/regexp_parser/token.rb#14
+  def next=(_arg0); end
+
+  # source://regexp_parser//lib/regexp_parser/token.rb#16
+  def offset; end
+
+  # Returns the value of attribute previous.
+  #
+  # source://regexp_parser//lib/regexp_parser/token.rb#14
+  def previous; end
+
+  # Sets the attribute previous
+  #
+  # @param value the value to set the attribute previous to.
+  #
+  # source://regexp_parser//lib/regexp_parser/token.rb#14
+  def previous=(_arg0); end
+
+  def set_level; end
+  def set_level=(_); end
+  def te; end
+  def te=(_); end
+  def text; end
+  def text=(_); end
+  def token; end
+  def token=(_); end
+  def ts; end
+  def ts=(_); end
+  def type; end
+  def type=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.5.rbi b/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.5.rbi
deleted file mode 100644
index 493c0fc36fca1..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.5.rbi
+++ /dev/null
@@ -1,672 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rexml` gem.
-# Please instead update this file by running `bin/tapioca gem rexml`.
-
-class REXML::AttlistDecl < ::REXML::Child
-  include ::Enumerable
-
-  def initialize(source); end
-
-  def [](key); end
-  def each(&block); end
-  def element_name; end
-  def include?(key); end
-  def node_type; end
-  def write(out, indent = T.unsafe(nil)); end
-end
-
-class REXML::Attribute
-  include ::REXML::Node
-  include ::REXML::XMLTokens
-  include ::REXML::Namespace
-
-  def initialize(first, second = T.unsafe(nil), parent = T.unsafe(nil)); end
-
-  def ==(other); end
-  def clone; end
-  def doctype; end
-  def element; end
-  def element=(element); end
-  def hash; end
-  def inspect; end
-  def namespace(arg = T.unsafe(nil)); end
-  def node_type; end
-  def normalized=(_arg0); end
-  def prefix; end
-  def remove; end
-  def to_s; end
-  def to_string; end
-  def value; end
-  def write(output, indent = T.unsafe(nil)); end
-  def xpath; end
-end
-
-class REXML::Attributes < ::Hash
-  def initialize(element); end
-
-  def <<(attribute); end
-  def [](name); end
-  def []=(name, value); end
-  def add(attribute); end
-  def delete(attribute); end
-  def delete_all(name); end
-  def each; end
-  def each_attribute; end
-  def get_attribute(name); end
-  def get_attribute_ns(namespace, name); end
-  def length; end
-  def namespaces; end
-  def prefixes; end
-  def size; end
-  def to_a; end
-end
-
-class REXML::CData < ::REXML::Text
-  def initialize(first, whitespace = T.unsafe(nil), parent = T.unsafe(nil)); end
-
-  def clone; end
-  def to_s; end
-  def value; end
-  def write(output = T.unsafe(nil), indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
-end
-
-class REXML::Child
-  include ::REXML::Node
-
-  def initialize(parent = T.unsafe(nil)); end
-
-  def bytes; end
-  def document; end
-  def next_sibling; end
-  def next_sibling=(other); end
-  def parent; end
-  def parent=(other); end
-  def previous_sibling; end
-  def previous_sibling=(other); end
-  def remove; end
-  def replace_with(child); end
-end
-
-class REXML::Comment < ::REXML::Child
-  include ::Comparable
-
-  def initialize(first, second = T.unsafe(nil)); end
-
-  def <=>(other); end
-  def ==(other); end
-  def clone; end
-  def node_type; end
-  def string; end
-  def string=(_arg0); end
-  def to_s; end
-  def write(output, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
-end
-
-module REXML::DClonable; end
-
-class REXML::Declaration < ::REXML::Child
-  def initialize(src); end
-
-  def to_s; end
-  def write(output, indent); end
-end
-
-class REXML::DocType < ::REXML::Parent
-  include ::REXML::XMLTokens
-
-  def initialize(first, parent = T.unsafe(nil)); end
-
-  def add(child); end
-  def attribute_of(element, attribute); end
-  def attributes_of(element); end
-  def clone; end
-  def context; end
-  def entities; end
-  def entity(name); end
-  def external_id; end
-  def name; end
-  def namespaces; end
-  def node_type; end
-  def notation(name); end
-  def notations; end
-  def public; end
-  def system; end
-  def write(output, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
-end
-
-class REXML::Document < ::REXML::Element
-  def initialize(source = T.unsafe(nil), context = T.unsafe(nil)); end
-
-  def <<(child); end
-  def add(child); end
-  def add_element(arg = T.unsafe(nil), arg2 = T.unsafe(nil)); end
-  def clone; end
-  def doctype; end
-  def document; end
-  def encoding; end
-  def entity_expansion_count; end
-  def expanded_name; end
-  def name; end
-  def node_type; end
-  def record_entity_expansion; end
-  def root; end
-  def stand_alone?; end
-  def version; end
-  def write(*arguments); end
-  def xml_decl; end
-
-  private
-
-  def build(source); end
-
-  class << self
-    def entity_expansion_limit; end
-    def entity_expansion_limit=(val); end
-    def entity_expansion_text_limit; end
-    def entity_expansion_text_limit=(val); end
-    def parse_stream(source, listener); end
-  end
-end
-
-class REXML::Element < ::REXML::Parent
-  include ::REXML::XMLTokens
-  include ::REXML::Namespace
-
-  def initialize(arg = T.unsafe(nil), parent = T.unsafe(nil), context = T.unsafe(nil)); end
-
-  def [](name_or_index); end
-  def add_attribute(key, value = T.unsafe(nil)); end
-  def add_attributes(hash); end
-  def add_element(element, attrs = T.unsafe(nil)); end
-  def add_namespace(prefix, uri = T.unsafe(nil)); end
-  def add_text(text); end
-  def attribute(name, namespace = T.unsafe(nil)); end
-  def attributes; end
-  def cdatas; end
-  def clone; end
-  def comments; end
-  def context; end
-  def context=(_arg0); end
-  def delete_attribute(key); end
-  def delete_element(element); end
-  def delete_namespace(namespace = T.unsafe(nil)); end
-  def document; end
-  def each_element(xpath = T.unsafe(nil), &block); end
-  def each_element_with_attribute(key, value = T.unsafe(nil), max = T.unsafe(nil), name = T.unsafe(nil), &block); end
-  def each_element_with_text(text = T.unsafe(nil), max = T.unsafe(nil), name = T.unsafe(nil), &block); end
-  def elements; end
-  def get_elements(xpath); end
-  def get_text(path = T.unsafe(nil)); end
-  def has_attributes?; end
-  def has_elements?; end
-  def has_text?; end
-  def ignore_whitespace_nodes; end
-  def inspect; end
-  def instructions; end
-  def namespace(prefix = T.unsafe(nil)); end
-  def namespaces; end
-  def next_element; end
-  def node_type; end
-  def prefixes; end
-  def previous_element; end
-  def raw; end
-  def root; end
-  def root_node; end
-  def text(path = T.unsafe(nil)); end
-  def text=(text); end
-  def texts; end
-  def whitespace; end
-  def write(output = T.unsafe(nil), indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
-  def xpath; end
-
-  private
-
-  def __to_xpath_helper(node); end
-  def each_with_something(test, max = T.unsafe(nil), name = T.unsafe(nil)); end
-end
-
-class REXML::ElementDecl < ::REXML::Declaration
-  def initialize(src); end
-end
-
-class REXML::Elements
-  include ::Enumerable
-
-  def initialize(parent); end
-
-  def <<(element = T.unsafe(nil)); end
-  def [](index, name = T.unsafe(nil)); end
-  def []=(index, element); end
-  def add(element = T.unsafe(nil)); end
-  def collect(xpath = T.unsafe(nil)); end
-  def delete(element); end
-  def delete_all(xpath); end
-  def each(xpath = T.unsafe(nil)); end
-  def empty?; end
-  def index(element); end
-  def inject(xpath = T.unsafe(nil), initial = T.unsafe(nil)); end
-  def parent; end
-  def size; end
-  def to_a(xpath = T.unsafe(nil)); end
-
-  private
-
-  def literalize(name); end
-end
-
-module REXML::Encoding
-  def decode(string); end
-  def encode(string); end
-  def encoding; end
-  def encoding=(encoding); end
-
-  private
-
-  def find_encoding(name); end
-end
-
-class REXML::Entity < ::REXML::Child
-  include ::REXML::XMLTokens
-
-  def initialize(stream, value = T.unsafe(nil), parent = T.unsafe(nil), reference = T.unsafe(nil)); end
-
-  def external; end
-  def name; end
-  def ndata; end
-  def normalized; end
-  def pubid; end
-  def ref; end
-  def to_s; end
-  def unnormalized; end
-  def value; end
-  def write(out, indent = T.unsafe(nil)); end
-
-  class << self
-    def matches?(string); end
-  end
-end
-
-class REXML::ExternalEntity < ::REXML::Child
-  def initialize(src); end
-
-  def to_s; end
-  def write(output, indent); end
-end
-
-class REXML::Formatters::Default
-  def initialize(ie_hack = T.unsafe(nil)); end
-
-  def write(node, output); end
-
-  protected
-
-  def write_cdata(node, output); end
-  def write_comment(node, output); end
-  def write_document(node, output); end
-  def write_element(node, output); end
-  def write_instruction(node, output); end
-  def write_text(node, output); end
-end
-
-class REXML::Formatters::Pretty < ::REXML::Formatters::Default
-  def initialize(indentation = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
-
-  def compact; end
-  def compact=(_arg0); end
-  def width; end
-  def width=(_arg0); end
-
-  protected
-
-  def write_cdata(node, output); end
-  def write_comment(node, output); end
-  def write_document(node, output); end
-  def write_element(node, output); end
-  def write_text(node, output); end
-
-  private
-
-  def indent_text(string, level = T.unsafe(nil), style = T.unsafe(nil), indentfirstline = T.unsafe(nil)); end
-  def wrap(string, width); end
-end
-
-class REXML::IOSource < ::REXML::Source
-  def initialize(arg, block_size = T.unsafe(nil), encoding = T.unsafe(nil)); end
-
-  def consume(pattern); end
-  def current_line; end
-  def empty?; end
-  def match(pattern, cons = T.unsafe(nil)); end
-  def position; end
-  def read; end
-  def scan(pattern, cons = T.unsafe(nil)); end
-
-  private
-
-  def encoding_updated; end
-  def readline; end
-end
-
-class REXML::Instruction < ::REXML::Child
-  def initialize(target, content = T.unsafe(nil)); end
-
-  def ==(other); end
-  def clone; end
-  def content; end
-  def content=(_arg0); end
-  def inspect; end
-  def node_type; end
-  def target; end
-  def target=(_arg0); end
-  def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
-end
-
-class REXML::NotationDecl < ::REXML::Child
-  def initialize(name, middle, pub, sys); end
-
-  def name; end
-  def public; end
-  def public=(_arg0); end
-  def system; end
-  def system=(_arg0); end
-  def to_s; end
-  def write(output, indent = T.unsafe(nil)); end
-end
-
-class REXML::Output
-  include ::REXML::Encoding
-
-  def initialize(real_IO, encd = T.unsafe(nil)); end
-
-  def <<(content); end
-  def encoding; end
-  def to_s; end
-end
-
-class REXML::Parent < ::REXML::Child
-  include ::Enumerable
-
-  def initialize(parent = T.unsafe(nil)); end
-
-  def <<(object); end
-  def [](index); end
-  def []=(*args); end
-  def add(object); end
-  def children; end
-  def deep_clone; end
-  def delete(object); end
-  def delete_at(index); end
-  def delete_if(&block); end
-  def each(&block); end
-  def each_child(&block); end
-  def each_index(&block); end
-  def index(child); end
-  def insert_after(child1, child2); end
-  def insert_before(child1, child2); end
-  def length; end
-  def parent?; end
-  def push(object); end
-  def replace_child(to_replace, replacement); end
-  def size; end
-  def to_a; end
-  def unshift(object); end
-end
-
-class REXML::ParseException < ::RuntimeError
-  def initialize(message, source = T.unsafe(nil), parser = T.unsafe(nil), exception = T.unsafe(nil)); end
-
-  def context; end
-  def continued_exception; end
-  def continued_exception=(_arg0); end
-  def line; end
-  def parser; end
-  def parser=(_arg0); end
-  def position; end
-  def source; end
-  def source=(_arg0); end
-  def to_s; end
-end
-
-class REXML::Parsers::BaseParser
-  def initialize(source); end
-
-  def add_listener(listener); end
-  def empty?; end
-  def entity(reference, entities); end
-  def has_next?; end
-  def normalize(input, entities = T.unsafe(nil), entity_filter = T.unsafe(nil)); end
-  def peek(depth = T.unsafe(nil)); end
-  def position; end
-  def pull; end
-  def source; end
-  def stream=(source); end
-  def unnormalize(string, entities = T.unsafe(nil), filter = T.unsafe(nil)); end
-  def unshift(token); end
-
-  private
-
-  def need_source_encoding_update?(xml_declaration_encoding); end
-  def parse_attributes(prefixes, curr_ns); end
-  def parse_id(base_error_message, accept_external_id:, accept_public_id:); end
-  def parse_id_invalid_details(accept_external_id:, accept_public_id:); end
-  def parse_name(base_error_message); end
-  def process_instruction; end
-  def pull_event; end
-end
-
-REXML::Parsers::BaseParser::EXTERNAL_ID_PUBLIC = T.let(T.unsafe(nil), Regexp)
-REXML::Parsers::BaseParser::EXTERNAL_ID_SYSTEM = T.let(T.unsafe(nil), Regexp)
-REXML::Parsers::BaseParser::PUBLIC_ID = T.let(T.unsafe(nil), Regexp)
-REXML::Parsers::BaseParser::QNAME = T.let(T.unsafe(nil), Regexp)
-REXML::Parsers::BaseParser::QNAME_STR = T.let(T.unsafe(nil), String)
-
-class REXML::Parsers::StreamParser
-  def initialize(source, listener); end
-
-  def add_listener(listener); end
-  def parse; end
-end
-
-class REXML::Parsers::TreeParser
-  def initialize(source, build_context = T.unsafe(nil)); end
-
-  def add_listener(listener); end
-  def parse; end
-end
-
-class REXML::Parsers::XPathParser
-  include ::REXML::XMLTokens
-
-  def abbreviate(path); end
-  def expand(path); end
-  def namespaces=(namespaces); end
-  def parse(path); end
-  def predicate(path); end
-  def predicate_to_string(path, &block); end
-
-  private
-
-  def AdditiveExpr(path, parsed); end
-  def AndExpr(path, parsed); end
-  def EqualityExpr(path, parsed); end
-  def FilterExpr(path, parsed); end
-  def FunctionCall(rest, parsed); end
-  def LocationPath(path, parsed); end
-  def MultiplicativeExpr(path, parsed); end
-  def NodeTest(path, parsed); end
-  def OrExpr(path, parsed); end
-  def PathExpr(path, parsed); end
-  def Predicate(path, parsed); end
-  def PrimaryExpr(path, parsed); end
-  def RelationalExpr(path, parsed); end
-  def RelativeLocationPath(path, parsed); end
-  def UnaryExpr(path, parsed); end
-  def UnionExpr(path, parsed); end
-  def get_group(string); end
-  def parse_args(string); end
-end
-
-REXML::Parsers::XPathParser::LOCAL_NAME_WILDCARD = T.let(T.unsafe(nil), Regexp)
-REXML::Parsers::XPathParser::PREFIX_WILDCARD = T.let(T.unsafe(nil), Regexp)
-
-class REXML::ReferenceWriter
-  def initialize(id_type, public_id_literal, system_literal, context = T.unsafe(nil)); end
-
-  def write(output); end
-end
-
-class REXML::Source
-  include ::REXML::Encoding
-
-  def initialize(arg, encoding = T.unsafe(nil)); end
-
-  def buffer; end
-  def consume(pattern); end
-  def current_line; end
-  def empty?; end
-  def encoding; end
-  def encoding=(enc); end
-  def line; end
-  def match(pattern, cons = T.unsafe(nil)); end
-  def match_to(char, pattern); end
-  def match_to_consume(char, pattern); end
-  def position; end
-  def read; end
-  def scan(pattern, cons = T.unsafe(nil)); end
-
-  private
-
-  def detect_encoding; end
-  def encoding_updated; end
-end
-
-class REXML::Text < ::REXML::Child
-  include ::Comparable
-
-  def initialize(arg, respect_whitespace = T.unsafe(nil), parent = T.unsafe(nil), raw = T.unsafe(nil), entity_filter = T.unsafe(nil), illegal = T.unsafe(nil)); end
-
-  def <<(to_append); end
-  def <=>(other); end
-  def clone; end
-  def doctype; end
-  def empty?; end
-  def indent_text(string, level = T.unsafe(nil), style = T.unsafe(nil), indentfirstline = T.unsafe(nil)); end
-  def inspect; end
-  def node_type; end
-  def parent=(parent); end
-  def raw; end
-  def raw=(_arg0); end
-  def to_s; end
-  def value; end
-  def value=(val); end
-  def wrap(string, width, addnewline = T.unsafe(nil)); end
-  def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
-  def write_with_substitution(out, input); end
-  def xpath; end
-
-  private
-
-  def clear_cache; end
-
-  class << self
-    def check(string, pattern, doctype); end
-    def expand(ref, doctype, filter); end
-    def normalize(input, doctype = T.unsafe(nil), entity_filter = T.unsafe(nil)); end
-    def read_with_substitution(input, illegal = T.unsafe(nil)); end
-    def unnormalize(string, doctype = T.unsafe(nil), filter = T.unsafe(nil), illegal = T.unsafe(nil)); end
-  end
-end
-
-class REXML::UndefinedNamespaceException < ::REXML::ParseException
-  def initialize(prefix, source, parser); end
-end
-
-class REXML::Validation::ValidationException < ::RuntimeError
-  def initialize(msg); end
-end
-
-class REXML::XMLDecl < ::REXML::Child
-  include ::REXML::Encoding
-
-  def initialize(version = T.unsafe(nil), encoding = T.unsafe(nil), standalone = T.unsafe(nil)); end
-
-  def ==(other); end
-  def clone; end
-  def dowrite; end
-  def encoding=(enc); end
-  def inspect; end
-  def node_type; end
-  def nowrite; end
-  def old_enc=(encoding); end
-  def stand_alone?; end
-  def standalone; end
-  def standalone=(_arg0); end
-  def version; end
-  def version=(_arg0); end
-  def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
-  def writeencoding; end
-  def writethis; end
-  def xmldecl(version, encoding, standalone); end
-
-  private
-
-  def content(enc); end
-
-  class << self
-    def default; end
-  end
-end
-
-class REXML::XPathNode
-  def initialize(node, context = T.unsafe(nil)); end
-
-  def context; end
-  def position; end
-  def raw_node; end
-end
-
-class REXML::XPathParser
-  include ::REXML::XMLTokens
-
-  def initialize(strict: T.unsafe(nil)); end
-
-  def []=(variable_name, value); end
-  def first(path_stack, node); end
-  def get_first(path, nodeset); end
-  def match(path_stack, nodeset); end
-  def namespaces=(namespaces = T.unsafe(nil)); end
-  def parse(path, nodeset); end
-  def predicate(path, nodeset); end
-  def variables=(vars = T.unsafe(nil)); end
-
-  private
-
-  def child(nodeset); end
-  def compare(a, operator, b); end
-  def descendant(nodeset, include_self); end
-  def descendant_recursive(raw_node, new_nodeset, new_nodes, include_self); end
-  def each_unnode(nodeset); end
-  def enter(tag, *args); end
-  def equality_relational_compare(set1, op, set2); end
-  def evaluate_predicate(expression, nodesets); end
-  def expr(path_stack, nodeset, context = T.unsafe(nil)); end
-  def filter_nodeset(nodeset); end
-  def following(node); end
-  def following_node_of(node); end
-  def get_namespace(node, prefix); end
-  def leave(tag, *args); end
-  def next_sibling_node(node); end
-  def node_test(path_stack, nodesets, any_type: T.unsafe(nil)); end
-  def norm(b); end
-  def normalize_compare_values(a, operator, b); end
-  def preceding(node); end
-  def preceding_node_of(node); end
-  def sort(array_of_nodes, order); end
-  def step(path_stack, any_type: T.unsafe(nil), order: T.unsafe(nil)); end
-  def strict?; end
-  def trace(*args); end
-  def unnode(nodeset); end
-  def value_type(value); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi b/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi
deleted file mode 100644
index 0db9fe7be695e..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi
+++ /dev/null
@@ -1,194 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `ronn` gem.
-# Please instead update this file by running `bin/tapioca gem ronn`.
-
-module Ronn
-  class << self
-    def new(filename, attributes = T.unsafe(nil), &block); end
-    def release?; end
-    def revision; end
-    def version; end
-  end
-end
-
-class Ronn::Document
-  include ::Ronn::Utils
-
-  def initialize(path = T.unsafe(nil), attributes = T.unsafe(nil), &block); end
-
-  def basename(type = T.unsafe(nil)); end
-  def convert(format); end
-  def data; end
-  def date; end
-  def date=(_arg0); end
-  def html; end
-  def index; end
-  def index=(_arg0); end
-  def manual; end
-  def manual=(_arg0); end
-  def markdown; end
-  def name; end
-  def name=(_arg0); end
-  def name?; end
-  def organization; end
-  def organization=(_arg0); end
-  def path; end
-  def path_for(type = T.unsafe(nil)); end
-  def path_name; end
-  def path_section; end
-  def reference_name; end
-  def section; end
-  def section=(_arg0); end
-  def section?; end
-  def section_heads; end
-  def sniff; end
-  def styles; end
-  def styles=(styles); end
-  def tagline; end
-  def tagline=(_arg0); end
-  def title; end
-  def title?; end
-  def to_h; end
-  def to_html; end
-  def to_html_fragment(wrap_class = T.unsafe(nil)); end
-  def to_json; end
-  def to_markdown; end
-  def to_roff; end
-  def to_yaml; end
-  def toc; end
-
-  protected
-
-  def html_filter_angle_quotes; end
-  def html_filter_annotate_bare_links; end
-  def html_filter_definition_lists; end
-  def html_filter_heading_anchors; end
-  def html_filter_inject_name_section; end
-  def html_filter_manual_reference_links; end
-  def input_html; end
-  def markdown_filter_angle_quotes(markdown); end
-  def markdown_filter_heading_anchors(markdown); end
-  def markdown_filter_link_index(markdown); end
-  def preprocess!; end
-  def process_html!; end
-  def process_markdown!; end
-  def strip_heading(html); end
-end
-
-class Ronn::Index
-  include ::Enumerable
-
-  def initialize(path, &bk); end
-
-  def <<(path); end
-  def [](name); end
-  def add_manual(manual); end
-  def each(&bk); end
-  def empty?; end
-  def exist?; end
-  def first; end
-  def last; end
-  def manual(path); end
-  def manuals; end
-  def path; end
-  def read!(data); end
-  def reference(name, path); end
-  def references; end
-  def relative_to_index(path); end
-  def size; end
-  def to_a; end
-  def to_h; end
-  def to_text; end
-
-  class << self
-    def [](path); end
-    def index_path_for_file(file); end
-  end
-end
-
-Ronn::REV = T.let(T.unsafe(nil), String)
-
-class Ronn::Reference
-  def initialize(index, name, location); end
-
-  def location; end
-  def manual?; end
-  def name; end
-  def path; end
-  def relative?; end
-  def remote?; end
-  def ronn?; end
-  def url; end
-end
-
-class Ronn::RoffFilter
-  include ::Ronn::Utils
-
-  def initialize(html, name, section, tagline, manual = T.unsafe(nil), version = T.unsafe(nil), date = T.unsafe(nil)); end
-
-  def to_s; end
-
-  protected
-
-  def block_filter(node); end
-  def comment(text); end
-  def escape(text); end
-  def inline_filter(node); end
-  def macro(name, value = T.unsafe(nil)); end
-  def normalize_whitespace!(node); end
-  def previous(node); end
-  def quote(text); end
-  def remove_extraneous_elements!(doc); end
-  def title_heading(name, section, tagline, manual, version, date); end
-  def warn(text, *args); end
-  def write(text); end
-  def writeln(text); end
-end
-
-Ronn::RoffFilter::HTML_ROFF_ENTITIES = T.let(T.unsafe(nil), Hash)
-
-class Ronn::Template < ::Mustache
-  def initialize(document, style_path = T.unsafe(nil)); end
-
-  def custom_title?; end
-  def date; end
-  def generator; end
-  def inline_stylesheet(path, media = T.unsafe(nil)); end
-  def manual; end
-  def missing_styles; end
-  def name; end
-  def name_and_section?; end
-  def organization; end
-  def page_name; end
-  def remote_stylesheet(name, media = T.unsafe(nil)); end
-  def render(template = T.unsafe(nil)); end
-  def section; end
-  def section_heads; end
-  def style_files; end
-  def style_path; end
-  def style_path=(_arg0); end
-  def styles; end
-  def stylesheet(path, media = T.unsafe(nil)); end
-  def stylesheet_tags; end
-  def stylesheets; end
-  def tagline; end
-  def tagline?; end
-  def title; end
-  def wrap_class_name; end
-end
-
-module Ronn::Utils
-  def block_element?(name); end
-  def child_of?(node, tag); end
-  def empty_element?(name); end
-  def html_element?(name); end
-  def inline_element?(name); end
-end
-
-Ronn::Utils::HTML = T.let(T.unsafe(nil), Set)
-Ronn::Utils::HTML_BLOCK = T.let(T.unsafe(nil), Set)
-Ronn::Utils::HTML_EMPTY = T.let(T.unsafe(nil), Set)
-Ronn::Utils::HTML_INLINE = T.let(T.unsafe(nil), Set)
-Ronn::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.11.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.11.0.rbi
deleted file mode 100644
index 98d18e64e0cd0..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.11.0.rbi
+++ /dev/null
@@ -1,2520 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rspec-core` gem.
-# Please instead update this file by running `bin/tapioca gem rspec-core`.
-
-module RSpec
-  extend ::RSpec::Support::Warnings
-  extend ::RSpec::Core::Warnings
-
-  class << self
-    def clear_examples; end
-    def configuration; end
-    def configuration=(_arg0); end
-    def configure; end
-    def const_missing(name); end
-    def context(*args, &example_group_block); end
-    def current_example; end
-    def current_example=(example); end
-    def current_scope; end
-    def current_scope=(scope); end
-    def describe(*args, &example_group_block); end
-    def example_group(*args, &example_group_block); end
-    def fcontext(*args, &example_group_block); end
-    def fdescribe(*args, &example_group_block); end
-    def reset; end
-    def shared_context(name, *args, &block); end
-    def shared_examples(name, *args, &block); end
-    def shared_examples_for(name, *args, &block); end
-    def world; end
-    def world=(_arg0); end
-    def xcontext(*args, &example_group_block); end
-    def xdescribe(*args, &example_group_block); end
-  end
-end
-
-module RSpec::Core
-  class << self
-    def path_to_executable; end
-  end
-end
-
-class RSpec::Core::AnonymousExampleGroup < ::RSpec::Core::ExampleGroup
-  class << self
-    def metadata; end
-  end
-end
-
-class RSpec::Core::BacktraceFormatter
-  def initialize; end
-
-  def backtrace_line(line); end
-  def exclude?(line); end
-  def exclusion_patterns; end
-  def exclusion_patterns=(_arg0); end
-  def filter_gem(gem_name); end
-  def format_backtrace(backtrace, options = T.unsafe(nil)); end
-  def full_backtrace=(_arg0); end
-  def full_backtrace?; end
-  def inclusion_patterns; end
-  def inclusion_patterns=(_arg0); end
-
-  private
-
-  def matches?(patterns, line); end
-end
-
-module RSpec::Core::Bisect; end
-
-class RSpec::Core::Bisect::BisectFailedError < ::StandardError
-  class << self
-    def for_failed_spec_run(spec_output); end
-  end
-end
-
-class RSpec::Core::Bisect::Channel
-  def initialize; end
-
-  def close; end
-  def receive; end
-  def send(message); end
-end
-
-RSpec::Core::Bisect::Channel::MARSHAL_DUMP_ENCODING = T.let(T.unsafe(nil), Encoding)
-
-class RSpec::Core::Bisect::ExampleSetDescriptor < ::Struct
-  def all_example_ids; end
-  def all_example_ids=(_); end
-  def failed_example_ids; end
-  def failed_example_ids=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Core::Bisect::Notifier
-  def initialize(formatter); end
-
-  def publish(event, *args); end
-end
-
-class RSpec::Core::Configuration
-  include ::RSpec::Core::Hooks
-  include ::RSpec::Core::Configuration::Readers
-
-  def initialize; end
-
-  def add_formatter(formatter, output = T.unsafe(nil)); end
-  def add_setting(name, opts = T.unsafe(nil)); end
-  def after(scope = T.unsafe(nil), *meta, &block); end
-  def alias_example_group_to(new_name, *args); end
-  def alias_example_to(name, *args); end
-  def alias_it_behaves_like_to(new_name, report_label = T.unsafe(nil)); end
-  def alias_it_should_behave_like_to(new_name, report_label = T.unsafe(nil)); end
-  def append_after(scope = T.unsafe(nil), *meta, &block); end
-  def append_before(scope = T.unsafe(nil), *meta, &block); end
-  def apply_derived_metadata_to(metadata); end
-  def around(scope = T.unsafe(nil), *meta, &block); end
-  def backtrace_exclusion_patterns; end
-  def backtrace_exclusion_patterns=(patterns); end
-  def backtrace_formatter; end
-  def backtrace_inclusion_patterns; end
-  def backtrace_inclusion_patterns=(patterns); end
-  def before(scope = T.unsafe(nil), *meta, &block); end
-  def bisect_runner; end
-  def bisect_runner=(value); end
-  def bisect_runner_class; end
-  def color; end
-  def color=(_arg0); end
-  def color_enabled?(output = T.unsafe(nil)); end
-  def color_mode; end
-  def color_mode=(_arg0); end
-  def configure_example(example, example_hooks); end
-  def configure_expectation_framework; end
-  def configure_group(group); end
-  def configure_mock_framework; end
-  def default_color; end
-  def default_color=(_arg0); end
-  def default_color?; end
-  def default_formatter; end
-  def default_formatter=(value); end
-  def default_path; end
-  def default_path=(path); end
-  def default_path?; end
-  def define_derived_metadata(*filters, &block); end
-  def deprecation_stream; end
-  def deprecation_stream=(value); end
-  def detail_color; end
-  def detail_color=(_arg0); end
-  def detail_color?; end
-  def disable_monkey_patching; end
-  def disable_monkey_patching!; end
-  def disable_monkey_patching=(_arg0); end
-  def drb; end
-  def drb=(_arg0); end
-  def drb?; end
-  def drb_port; end
-  def drb_port=(_arg0); end
-  def drb_port?; end
-  def dry_run; end
-  def dry_run=(_arg0); end
-  def dry_run?; end
-  def error_exit_code; end
-  def error_exit_code=(_arg0); end
-  def error_exit_code?; end
-  def error_stream; end
-  def error_stream=(_arg0); end
-  def error_stream?; end
-  def example_status_persistence_file_path; end
-  def example_status_persistence_file_path=(value); end
-  def exclude_pattern; end
-  def exclude_pattern=(value); end
-  def exclusion_filter; end
-  def exclusion_filter=(filter); end
-  def expect_with(*frameworks); end
-  def expectation_framework=(framework); end
-  def expectation_frameworks; end
-  def expose_current_running_example_as(method_name); end
-  def expose_dsl_globally=(value); end
-  def expose_dsl_globally?; end
-  def extend(mod, *filters); end
-  def fail_fast; end
-  def fail_fast=(value); end
-  def fail_if_no_examples; end
-  def fail_if_no_examples=(_arg0); end
-  def fail_if_no_examples?; end
-  def failure_color; end
-  def failure_color=(_arg0); end
-  def failure_color?; end
-  def failure_exit_code; end
-  def failure_exit_code=(_arg0); end
-  def failure_exit_code?; end
-  def files_or_directories_to_run=(*files); end
-  def files_to_run; end
-  def files_to_run=(_arg0); end
-  def filter; end
-  def filter=(filter); end
-  def filter_gems_from_backtrace(*gem_names); end
-  def filter_manager; end
-  def filter_manager=(_arg0); end
-  def filter_run(*args); end
-  def filter_run_excluding(*args); end
-  def filter_run_including(*args); end
-  def filter_run_when_matching(*args); end
-  def fixed_color; end
-  def fixed_color=(_arg0); end
-  def fixed_color?; end
-  def force(hash); end
-  def format_docstrings(&block); end
-  def format_docstrings_block; end
-  def formatter=(formatter, output = T.unsafe(nil)); end
-  def formatter_loader; end
-  def formatters; end
-  def full_backtrace=(true_or_false); end
-  def full_backtrace?; end
-  def full_description; end
-  def full_description=(description); end
-  def hooks; end
-  def in_project_source_dir_regex; end
-  def include(mod, *filters); end
-  def include_context(shared_group_name, *filters); end
-  def inclusion_filter; end
-  def inclusion_filter=(filter); end
-  def last_run_statuses; end
-  def libs; end
-  def libs=(libs); end
-  def load_spec_files; end
-  def loaded_spec_files; end
-  def max_displayed_failure_line_count; end
-  def max_displayed_failure_line_count=(_arg0); end
-  def max_displayed_failure_line_count?; end
-  def mock_framework; end
-  def mock_framework=(framework); end
-  def mock_with(framework); end
-  def on_example_group_definition(&block); end
-  def on_example_group_definition_callbacks; end
-  def only_failures; end
-  def only_failures?; end
-  def only_failures_but_not_configured?; end
-  def order=(*args, &block); end
-  def ordering_manager; end
-  def ordering_registry(*args, &block); end
-  def output_stream; end
-  def output_stream=(value); end
-  def pattern; end
-  def pattern=(value); end
-  def pending_color; end
-  def pending_color=(_arg0); end
-  def pending_color?; end
-  def prepend(mod, *filters); end
-  def prepend_after(scope = T.unsafe(nil), *meta, &block); end
-  def prepend_before(scope = T.unsafe(nil), *meta, &block); end
-  def profile_examples; end
-  def profile_examples=(_arg0); end
-  def profile_examples?; end
-  def project_source_dirs; end
-  def project_source_dirs=(_arg0); end
-  def project_source_dirs?; end
-  def raise_errors_for_deprecations!; end
-  def raise_on_warning=(value); end
-  def register_ordering(*args, &block); end
-  def reporter; end
-  def requires; end
-  def requires=(paths); end
-  def reset; end
-  def reset_filters; end
-  def reset_reporter; end
-  def run_all_when_everything_filtered; end
-  def run_all_when_everything_filtered=(_arg0); end
-  def run_all_when_everything_filtered?; end
-  def seed(*args, &block); end
-  def seed=(*args, &block); end
-  def seed_used?(*args, &block); end
-  def shared_context_metadata_behavior; end
-  def shared_context_metadata_behavior=(value); end
-  def silence_filter_announcements; end
-  def silence_filter_announcements=(_arg0); end
-  def silence_filter_announcements?; end
-  def spec_files_with_failures; end
-  def start_time; end
-  def start_time=(_arg0); end
-  def start_time?; end
-  def static_config_filter_manager; end
-  def static_config_filter_manager=(_arg0); end
-  def success_color; end
-  def success_color=(_arg0); end
-  def success_color?; end
-  def threadsafe; end
-  def threadsafe=(_arg0); end
-  def threadsafe?; end
-  def treat_symbols_as_metadata_keys_with_true_values=(_value); end
-  def tty; end
-  def tty=(_arg0); end
-  def tty?; end
-  def warnings=(value); end
-  def warnings?; end
-  def when_first_matching_example_defined(*filters); end
-  def with_suite_hooks; end
-  def world; end
-  def world=(_arg0); end
-
-  private
-
-  def absolute_pattern?(pattern); end
-  def add_hook_to_existing_matching_groups(meta, scope, &block); end
-  def assert_no_example_groups_defined(config_option); end
-  def clear_values_derived_from_example_status_persistence_file_path; end
-  def command; end
-  def conditionally_disable_expectations_monkey_patching; end
-  def conditionally_disable_mocks_monkey_patching; end
-  def configure_group_with(group, module_list, application_method); end
-  def define_built_in_hooks; end
-  def define_mixed_in_module(mod, filters, mod_list, config_method, &block); end
-  def extract_location(path); end
-  def file_glob_from(path, pattern); end
-  def gather_directories(path); end
-  def get_files_to_run(paths); end
-  def get_matching_files(path, pattern); end
-  def handle_suite_hook(scope, meta); end
-  def load_file_handling_errors(method, file); end
-  def metadata_applies_to_group?(meta, group); end
-  def on_existing_matching_groups(meta); end
-  def output_to_tty?(output = T.unsafe(nil)); end
-  def output_wrapper; end
-  def paths_to_check(paths); end
-  def pattern_might_load_specs_from_vendored_dirs?; end
-  def rspec_expectations_loaded?; end
-  def rspec_mocks_loaded?; end
-  def run_suite_hooks(hook_description, hooks); end
-  def safe_extend(mod, host); end
-  def safe_include(mod, host); end
-  def safe_prepend(mod, host); end
-  def update_pattern_attr(name, value); end
-  def value_for(key); end
-
-  class << self
-    def add_read_only_setting(name, opts = T.unsafe(nil)); end
-    def add_setting(name, opts = T.unsafe(nil)); end
-    def define_alias(name, alias_name); end
-    def define_predicate(name); end
-    def define_reader(name); end
-    def delegate_to_ordering_manager(*methods); end
-  end
-end
-
-RSpec::Core::Configuration::DEFAULT_FORMATTER = T.let(T.unsafe(nil), Proc)
-
-class RSpec::Core::Configuration::DeprecationReporterBuffer
-  def initialize; end
-
-  def deprecation(*args); end
-  def play_onto(reporter); end
-end
-
-module RSpec::Core::Configuration::ExposeCurrentExample; end
-RSpec::Core::Configuration::FAILED_STATUS = T.let(T.unsafe(nil), String)
-RSpec::Core::Configuration::MOCKING_ADAPTERS = T.let(T.unsafe(nil), Hash)
-class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError < ::StandardError; end
-RSpec::Core::Configuration::PASSED_STATUS = T.let(T.unsafe(nil), String)
-RSpec::Core::Configuration::PENDING_STATUS = T.let(T.unsafe(nil), String)
-RSpec::Core::Configuration::RAISE_ERROR_WARNING_NOTIFIER = T.let(T.unsafe(nil), Proc)
-
-module RSpec::Core::Configuration::Readers
-  def clear_lets_on_failure; end
-  def default_color; end
-  def default_path; end
-  def default_retry_count; end
-  def default_sleep_interval; end
-  def deprecation_stream; end
-  def detail_color; end
-  def display_try_failure_messages; end
-  def drb; end
-  def drb_port; end
-  def dry_run; end
-  def error_exit_code; end
-  def error_stream; end
-  def example_status_persistence_file_path; end
-  def exceptions_to_hard_fail; end
-  def exceptions_to_retry; end
-  def exclude_pattern; end
-  def exponential_backoff; end
-  def fail_fast; end
-  def fail_if_no_examples; end
-  def failure_color; end
-  def failure_exit_code; end
-  def fixed_color; end
-  def libs; end
-  def max_displayed_failure_line_count; end
-  def only_failures; end
-  def output_stream; end
-  def pattern; end
-  def pending_color; end
-  def project_source_dirs; end
-  def requires; end
-  def retry_callback; end
-  def retry_count_condition; end
-  def run_all_when_everything_filtered; end
-  def shared_context_metadata_behavior; end
-  def silence_filter_announcements; end
-  def start_time; end
-  def success_color; end
-  def threadsafe; end
-  def tty; end
-  def verbose_retry; end
-  def wait_delay; end
-  def wait_timeout; end
-end
-
-RSpec::Core::Configuration::UNKNOWN_STATUS = T.let(T.unsafe(nil), String)
-RSpec::Core::Configuration::VALID_STATUSES = T.let(T.unsafe(nil), Array)
-
-class RSpec::Core::ConfigurationOptions
-  def initialize(args); end
-
-  def args; end
-  def configure(config); end
-  def configure_filter_manager(filter_manager); end
-  def options; end
-
-  private
-
-  def args_from_options_file(path); end
-  def command_line_options; end
-  def custom_options; end
-  def custom_options_file; end
-  def env_options; end
-  def file_options; end
-  def force?(key); end
-  def global_options; end
-  def global_options_file; end
-  def home_options_file_path; end
-  def load_formatters_into(config); end
-  def local_options; end
-  def local_options_file; end
-  def options_file_as_erb_string(path); end
-  def options_from(path); end
-  def order(keys); end
-  def organize_options; end
-  def parse_args_ignoring_files_or_dirs_to_run(args, source); end
-  def process_options_into(config); end
-  def project_options; end
-  def project_options_file; end
-  def resolve_xdg_config_home; end
-  def xdg_options_file_if_exists; end
-  def xdg_options_file_path; end
-end
-
-RSpec::Core::ConfigurationOptions::OPTIONS_ORDER = T.let(T.unsafe(nil), Array)
-RSpec::Core::ConfigurationOptions::UNFORCED_OPTIONS = T.let(T.unsafe(nil), RSpec::Core::Set)
-RSpec::Core::ConfigurationOptions::UNPROCESSABLE_OPTIONS = T.let(T.unsafe(nil), RSpec::Core::Set)
-
-module RSpec::Core::DSL
-  class << self
-    def change_global_dsl(&changes); end
-    def example_group_aliases; end
-    def expose_example_group_alias(name); end
-    def expose_example_group_alias_globally(method_name); end
-    def expose_globally!; end
-    def exposed_globally?; end
-    def remove_globally!; end
-    def top_level; end
-    def top_level=(_arg0); end
-  end
-end
-
-class RSpec::Core::DeprecationError < ::StandardError; end
-
-class RSpec::Core::DidYouMean
-  def initialize(relative_file_name); end
-
-  def call; end
-  def relative_file_name; end
-
-  private
-
-  def formats(probables); end
-  def red_font(mytext); end
-  def top_and_tail(rspec_format); end
-end
-
-class RSpec::Core::Example
-  def initialize(example_group_class, description, user_metadata, example_block = T.unsafe(nil)); end
-
-  def attempts; end
-  def attempts=(_arg0); end
-  def clear_exception; end
-  def clock; end
-  def clock=(_arg0); end
-  def description; end
-  def display_exception; end
-  def display_exception=(ex); end
-  def duplicate_with(metadata_overrides = T.unsafe(nil)); end
-  def example_group; end
-  def example_group_instance; end
-  def exception; end
-  def execution_result; end
-  def fail_with_exception(reporter, exception); end
-  def file_path; end
-  def full_description; end
-  def id; end
-  def inspect; end
-  def inspect_output; end
-  def instance_exec(*args, &block); end
-  def location; end
-  def location_rerun_argument; end
-  def metadata; end
-  def pending; end
-  def pending?; end
-  def reporter; end
-  def rerun_argument; end
-  def run(example_group_instance, reporter); end
-  def set_aggregate_failures_exception(exception); end
-  def set_exception(exception); end
-  def skip; end
-  def skip_with_exception(reporter, exception); end
-  def skipped?; end
-  def to_s; end
-  def update_inherited_metadata(updates); end
-
-  private
-
-  def assign_generated_description; end
-  def finish(reporter); end
-  def generate_description; end
-  def hooks; end
-  def location_description; end
-  def mocks_need_verification?; end
-  def record_finished(status, reporter); end
-  def run_after_example; end
-  def run_before_example; end
-  def start(reporter); end
-  def verify_mocks; end
-  def with_around_and_singleton_context_hooks; end
-  def with_around_example_hooks; end
-
-  class << self
-    def delegate_to_metadata(key); end
-    def parse_id(id); end
-  end
-end
-
-RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
-
-class RSpec::Core::Example::ExecutionResult
-  include ::RSpec::Core::HashImitatable
-  extend ::RSpec::Core::HashImitatable::ClassMethods
-
-  def ensure_timing_set(clock); end
-  def example_skipped?; end
-  def exception; end
-  def exception=(_arg0); end
-  def finished_at; end
-  def finished_at=(_arg0); end
-  def pending_exception; end
-  def pending_exception=(_arg0); end
-  def pending_fixed; end
-  def pending_fixed=(_arg0); end
-  def pending_fixed?; end
-  def pending_message; end
-  def pending_message=(_arg0); end
-  def record_finished(status, finished_at); end
-  def run_time; end
-  def run_time=(_arg0); end
-  def started_at; end
-  def started_at=(_arg0); end
-  def status; end
-  def status=(_arg0); end
-
-  private
-
-  def calculate_run_time(finished_at); end
-  def get_value(name); end
-  def hash_for_delegation; end
-  def issue_deprecation(_method_name, *_args); end
-  def set_value(name, value); end
-end
-
-class RSpec::Core::Example::Procsy
-  def initialize(example, &block); end
-
-  def <<(*a, &b); end
-  def ===(*a, &b); end
-  def >>(*a, &b); end
-  def [](*a, &b); end
-  def arity(*a, &b); end
-  def attempts; end
-  def binding(*a, &b); end
-  def call(*args, &block); end
-  def clock(*a, &b); end
-  def clock=(*a, &b); end
-  def clone(*a, &b); end
-  def curry(*a, &b); end
-  def description(*a, &b); end
-  def dup(*a, &b); end
-  def duplicate_with(*a, &b); end
-  def example; end
-  def example_group(*a, &b); end
-  def example_group_instance(*a, &b); end
-  def exception(*a, &b); end
-  def executed?; end
-  def execution_result(*a, &b); end
-  def file_path(*a, &b); end
-  def full_description(*a, &b); end
-  def hash(*a, &b); end
-  def id(*a, &b); end
-  def inspect; end
-  def inspect_output(*a, &b); end
-  def lambda?(*a, &b); end
-  def location(*a, &b); end
-  def location_rerun_argument(*a, &b); end
-  def metadata(*a, &b); end
-  def parameters(*a, &b); end
-  def pending(*a, &b); end
-  def pending?(*a, &b); end
-  def reporter(*a, &b); end
-  def rerun_argument(*a, &b); end
-  def run(*args, &block); end
-  def run_with_retry(opts = T.unsafe(nil)); end
-  def skip(*a, &b); end
-  def skipped?(*a, &b); end
-  def source_location(*a, &b); end
-  def to_proc; end
-  def update_inherited_metadata(*a, &b); end
-  def wrap(&block); end
-  def yield(*a, &b); end
-end
-
-class RSpec::Core::ExampleGroup
-  include ::RSpec::Core::MemoizedHelpers
-  include ::RSpec::Core::Pending
-  extend ::RSpec::Core::Hooks
-  extend ::RSpec::Core::MemoizedHelpers::ClassMethods
-  extend ::RSpec::Core::SharedExampleGroup
-
-  def initialize(inspect_output = T.unsafe(nil)); end
-
-  def clear_lets; end
-  def clear_memoized; end
-  def described_class; end
-  def inspect; end
-
-  private
-
-  def method_missing(name, *args); end
-
-  class << self
-    def add_example(example); end
-    def before_context_ivars; end
-    def children; end
-    def context(*args, &example_group_block); end
-    def currently_executing_a_context_hook?; end
-    def declaration_locations; end
-    def define_example_group_method(name, metadata = T.unsafe(nil)); end
-    def define_example_method(name, extra_options = T.unsafe(nil)); end
-    def define_nested_shared_group_method(new_name, report_label = T.unsafe(nil)); end
-    def delegate_to_metadata(*names); end
-    def descendant_filtered_examples; end
-    def descendants; end
-    def describe(*args, &example_group_block); end
-    def described_class; end
-    def description; end
-    def each_instance_variable_for_example(group); end
-    def ensure_example_groups_are_configured; end
-    def example(*all_args, &block); end
-    def example_group(*args, &example_group_block); end
-    def examples; end
-    def fcontext(*args, &example_group_block); end
-    def fdescribe(*args, &example_group_block); end
-    def fexample(*all_args, &block); end
-    def file_path; end
-    def filtered_examples; end
-    def find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end
-    def fit(*all_args, &block); end
-    def focus(*all_args, &block); end
-    def for_filtered_examples(reporter, &block); end
-    def fspecify(*all_args, &block); end
-    def id; end
-    def idempotently_define_singleton_method(name, &definition); end
-    def include_context(name, *args, &block); end
-    def include_examples(name, *args, &block); end
-    def it(*all_args, &block); end
-    def it_behaves_like(name, *args, &customization_block); end
-    def it_should_behave_like(name, *args, &customization_block); end
-    def location; end
-    def metadata; end
-    def next_runnable_index_for(file); end
-    def ordering_strategy; end
-    def parent_groups; end
-    def pending(*all_args, &block); end
-    def remove_example(example); end
-    def reset_memoized; end
-    def run(reporter = T.unsafe(nil)); end
-    def run_after_context_hooks(example_group_instance); end
-    def run_before_context_hooks(example_group_instance); end
-    def run_examples(reporter); end
-    def set_it_up(description, args, registration_collection, &example_group_block); end
-    def set_ivars(instance, ivars); end
-    def skip(*all_args, &block); end
-    def specify(*all_args, &block); end
-    def store_before_context_ivars(example_group_instance); end
-    def subclass(parent, description, args, registration_collection, &example_group_block); end
-    def superclass_before_context_ivars; end
-    def superclass_metadata; end
-    def top_level?; end
-    def top_level_description; end
-    def traverse_tree_until(&block); end
-    def update_inherited_metadata(updates); end
-    def with_replaced_metadata(meta); end
-    def xcontext(*args, &example_group_block); end
-    def xdescribe(*args, &example_group_block); end
-    def xexample(*all_args, &block); end
-    def xit(*all_args, &block); end
-    def xspecify(*all_args, &block); end
-
-    private
-
-    def method_missing(name, *args); end
-  end
-end
-
-RSpec::Core::ExampleGroup::INSTANCE_VARIABLE_TO_IGNORE = T.let(T.unsafe(nil), Symbol)
-class RSpec::Core::ExampleGroup::WrongScopeError < ::NoMethodError; end
-
-class RSpec::Core::ExampleStatusDumper
-  def initialize(examples); end
-
-  def dump; end
-
-  private
-
-  def column_widths; end
-  def formatted_header_rows; end
-  def formatted_row_from(row_values); end
-  def formatted_value_rows; end
-  def headers; end
-  def rows; end
-
-  class << self
-    def dump(examples); end
-  end
-end
-
-class RSpec::Core::ExampleStatusMerger
-  def initialize(this_run, from_previous_runs); end
-
-  def merge; end
-
-  private
-
-  def delete_previous_examples_that_no_longer_exist; end
-  def example_must_no_longer_exist?(ex_id); end
-  def hash_from(example_list); end
-  def loaded_spec_files; end
-  def sort_value_from(example); end
-  def spec_file_from(ex_id); end
-
-  class << self
-    def merge(this_run, from_previous_runs); end
-  end
-end
-
-class RSpec::Core::ExampleStatusParser
-  def initialize(string); end
-
-  def parse; end
-
-  private
-
-  def headers; end
-  def parse_row(line); end
-  def split_line(line); end
-
-  class << self
-    def parse(string); end
-  end
-end
-
-class RSpec::Core::ExampleStatusPersister
-  def initialize(examples, file_name); end
-
-  def persist; end
-
-  private
-
-  def dump_statuses(unparsed_previous_runs); end
-  def statuses_from_this_run; end
-
-  class << self
-    def load_from(file_name); end
-    def persist(examples, file_name); end
-  end
-end
-
-RSpec::Core::ExclusionRules = RSpec::Core::FilterRules
-
-class RSpec::Core::FilterManager
-  def initialize; end
-
-  def add_ids(rerun_path, scoped_ids); end
-  def add_location(file_path, line_numbers); end
-  def empty?; end
-  def exclude(*args); end
-  def exclude_only(*args); end
-  def exclude_with_low_priority(*args); end
-  def exclusions; end
-  def include(*args); end
-  def include_only(*args); end
-  def include_with_low_priority(*args); end
-  def inclusions; end
-  def prune(examples); end
-
-  private
-
-  def add_path_to_arrays_filter(filter_key, path, values); end
-  def file_scoped_include?(ex_metadata, ids, locations); end
-  def prune_conditionally_filtered_examples(examples); end
-end
-
-class RSpec::Core::FilterRules
-  def initialize(rules = T.unsafe(nil)); end
-
-  def [](key); end
-  def add(updated); end
-  def add_with_low_priority(updated); end
-  def clear; end
-  def delete(key); end
-  def description; end
-  def each_pair(&block); end
-  def empty?; end
-  def fetch(*args, &block); end
-  def include_example?(example); end
-  def opposite; end
-  def opposite=(_arg0); end
-  def rules; end
-  def use_only(updated); end
-
-  class << self
-    def build; end
-  end
-end
-
-RSpec::Core::FilterRules::PROC_HEX_NUMBER = T.let(T.unsafe(nil), Regexp)
-RSpec::Core::FilterRules::PROJECT_DIR = T.let(T.unsafe(nil), String)
-module RSpec::Core::FilterableItemRepository; end
-
-class RSpec::Core::FilterableItemRepository::QueryOptimized < ::RSpec::Core::FilterableItemRepository::UpdateOptimized
-  def initialize(applies_predicate); end
-
-  def append(item, metadata); end
-  def delete(item, metadata); end
-  def items_for(metadata); end
-  def prepend(item, metadata); end
-
-  private
-
-  def applicable_metadata_from(metadata); end
-  def find_items_for(request_meta); end
-  def handle_mutation(metadata); end
-  def proc_keys_from(metadata); end
-  def reconstruct_caches; end
-end
-
-class RSpec::Core::FilterableItemRepository::UpdateOptimized
-  def initialize(applies_predicate); end
-
-  def append(item, metadata); end
-  def delete(item, metadata); end
-  def items_and_filters; end
-  def items_for(request_meta); end
-  def prepend(item, metadata); end
-end
-
-module RSpec::Core::FlatMap
-  private
-
-  def flat_map(array, &block); end
-
-  class << self
-    def flat_map(array, &block); end
-  end
-end
-
-module RSpec::Core::Formatters
-  class << self
-    def register(formatter_class, *notifications); end
-  end
-end
-
-class RSpec::Core::Formatters::BaseBisectFormatter
-  def initialize(expected_failures); end
-
-  def example_failed(notification); end
-  def example_finished(notification); end
-  def start_dump(_notification); end
-
-  class << self
-    def inherited(formatter); end
-  end
-end
-
-class RSpec::Core::Formatters::BaseFormatter
-  def initialize(output); end
-
-  def close(_notification); end
-  def example_group; end
-  def example_group=(_arg0); end
-  def example_group_started(notification); end
-  def output; end
-  def start(notification); end
-
-  private
-
-  def output_supports_sync; end
-  def restore_sync_output; end
-  def start_sync_output; end
-end
-
-class RSpec::Core::Formatters::BaseTextFormatter < ::RSpec::Core::Formatters::BaseFormatter
-  def close(_notification); end
-  def dump_failures(notification); end
-  def dump_pending(notification); end
-  def dump_summary(summary); end
-  def message(notification); end
-  def seed(notification); end
-end
-
-class RSpec::Core::Formatters::BisectDRbFormatter < ::RSpec::Core::Formatters::BaseBisectFormatter
-  def initialize(_output); end
-
-  def notify_results(results); end
-end
-
-module RSpec::Core::Formatters::ConsoleCodes
-  private
-
-  def config_colors_to_methods; end
-  def console_code_for(code_or_symbol); end
-  def wrap(text, code_or_symbol); end
-
-  class << self
-    def config_colors_to_methods; end
-    def console_code_for(code_or_symbol); end
-    def wrap(text, code_or_symbol); end
-  end
-end
-
-RSpec::Core::Formatters::ConsoleCodes::VT100_CODES = T.let(T.unsafe(nil), Hash)
-RSpec::Core::Formatters::ConsoleCodes::VT100_CODE_VALUES = T.let(T.unsafe(nil), Hash)
-
-class RSpec::Core::Formatters::DeprecationFormatter
-  def initialize(deprecation_stream, summary_stream); end
-
-  def count; end
-  def deprecation(notification); end
-  def deprecation_message_for(data); end
-  def deprecation_stream; end
-  def deprecation_summary(_notification); end
-  def output; end
-  def printer; end
-  def summary_stream; end
-end
-
-RSpec::Core::Formatters::DeprecationFormatter::DEPRECATION_STREAM_NOTICE = T.let(T.unsafe(nil), String)
-
-class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter
-  def initialize(deprecation_stream, summary_stream, deprecation_formatter); end
-
-  def deprecation_formatter; end
-  def deprecation_stream; end
-  def deprecation_summary; end
-  def print_deferred_deprecation_warnings; end
-  def print_deprecation_message(data); end
-  def stash_deprecation_message(deprecation_message); end
-  def summary_stream; end
-end
-
-RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter::TOO_MANY_USES_LIMIT = T.let(T.unsafe(nil), Integer)
-
-class RSpec::Core::Formatters::DeprecationFormatter::FileStream
-  def initialize(file); end
-
-  def puts(*args); end
-  def summarize(summary_stream, deprecation_count); end
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage < ::Struct
-  def initialize(data); end
-
-  def to_s; end
-  def too_many_warnings_message; end
-  def type; end
-  def type=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter
-  def initialize(deprecation_stream, summary_stream, deprecation_formatter); end
-
-  def deprecation_formatter; end
-  def deprecation_stream; end
-  def deprecation_summary; end
-  def print_deprecation_message(data); end
-  def summary_stream; end
-end
-
-RSpec::Core::Formatters::DeprecationFormatter::RAISE_ERROR_CONFIG_NOTICE = T.let(T.unsafe(nil), String)
-
-class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream
-  def puts(message); end
-  def summarize(summary_stream, deprecation_count); end
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage < ::Struct
-  def initialize(data); end
-
-  def to_s; end
-  def too_many_warnings_message; end
-  def type; end
-  def type=(_); end
-
-  private
-
-  def deprecation_type_for(data); end
-  def output_formatted(str); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-RSpec::Core::Formatters::DeprecationFormatter::TOO_MANY_WARNINGS_NOTICE = T.let(T.unsafe(nil), String)
-
-class RSpec::Core::Formatters::DocumentationFormatter < ::RSpec::Core::Formatters::BaseTextFormatter
-  def initialize(output); end
-
-  def example_failed(failure); end
-  def example_group_finished(_notification); end
-  def example_group_started(notification); end
-  def example_passed(passed); end
-  def example_pending(pending); end
-  def example_started(_notification); end
-  def message(notification); end
-
-  private
-
-  def current_indentation(offset = T.unsafe(nil)); end
-  def failure_output(example); end
-  def flush_messages; end
-  def next_failure_index; end
-  def passed_output(example); end
-  def pending_output(example, message); end
-end
-
-class RSpec::Core::Formatters::ExceptionPresenter
-  def initialize(exception, example, options = T.unsafe(nil)); end
-
-  def colorized_formatted_backtrace(colorizer = T.unsafe(nil)); end
-  def colorized_message_lines(colorizer = T.unsafe(nil)); end
-  def description; end
-  def example; end
-  def exception; end
-  def formatted_backtrace(exception = T.unsafe(nil)); end
-  def formatted_cause(exception); end
-  def fully_formatted(failure_number, colorizer = T.unsafe(nil)); end
-  def fully_formatted_lines(failure_number, colorizer); end
-  def message_lines; end
-
-  private
-
-  def add_shared_group_lines(lines, colorizer); end
-  def backtrace_formatter; end
-  def detail_formatter; end
-  def encoded_description(description); end
-  def encoded_string(string); end
-  def encoding_of(string); end
-  def exception_backtrace; end
-  def exception_class_name(exception = T.unsafe(nil)); end
-  def exception_lines; end
-  def exception_message_string(exception); end
-  def extra_detail_formatter; end
-  def extra_failure_lines; end
-  def failure_lines; end
-  def failure_slash_error_lines; end
-  def final_exception(exception, previous = T.unsafe(nil)); end
-  def find_failed_line; end
-  def formatted_message_and_backtrace(colorizer); end
-  def indent_lines(lines, failure_number); end
-  def message_color; end
-  def read_failed_lines; end
-end
-
-class RSpec::Core::Formatters::ExceptionPresenter::Factory
-  def initialize(example); end
-
-  def build; end
-
-  private
-
-  def multiple_exception_summarizer(exception, prior_detail_formatter, color); end
-  def multiple_exceptions_error?(exception); end
-  def options; end
-  def pending_options; end
-  def sub_failure_list_formatter(exception, message_color); end
-  def with_multiple_error_options_as_needed(exception, options); end
-end
-
-class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater
-  def initialize(parent); end
-
-  def with_truncated_backtrace(child); end
-end
-
-module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter
-  class << self
-    def format_backtrace(*_arg0); end
-  end
-end
-
-RSpec::Core::Formatters::ExceptionPresenter::PENDING_DETAIL_FORMATTER = T.let(T.unsafe(nil), Proc)
-
-class RSpec::Core::Formatters::FailureListFormatter < ::RSpec::Core::Formatters::BaseFormatter
-  def dump_profile(_profile); end
-  def example_failed(failure); end
-  def message(_message); end
-end
-
-class RSpec::Core::Formatters::FallbackMessageFormatter
-  def initialize(output); end
-
-  def message(notification); end
-  def output; end
-end
-
-module RSpec::Core::Formatters::Helpers
-  class << self
-    def format_duration(duration); end
-    def format_seconds(float, precision = T.unsafe(nil)); end
-    def organize_ids(ids); end
-    def pluralize(count, string); end
-
-    private
-
-    def strip_trailing_zeroes(string); end
-  end
-end
-
-RSpec::Core::Formatters::Helpers::DEFAULT_PRECISION = T.let(T.unsafe(nil), Integer)
-RSpec::Core::Formatters::Helpers::SUB_SECOND_PRECISION = T.let(T.unsafe(nil), Integer)
-
-class RSpec::Core::Formatters::HtmlFormatter < ::RSpec::Core::Formatters::BaseFormatter
-  def initialize(output); end
-
-  def dump_summary(summary); end
-  def example_failed(failure); end
-  def example_group_started(notification); end
-  def example_passed(passed); end
-  def example_pending(pending); end
-  def example_started(_notification); end
-  def start(notification); end
-  def start_dump(_notification); end
-
-  private
-
-  def example_group_number; end
-  def example_number; end
-  def extra_failure_content(failure); end
-  def percent_done; end
-end
-
-class RSpec::Core::Formatters::HtmlPrinter
-  include ::ERB::Util
-
-  def initialize(output); end
-
-  def flush; end
-  def make_example_group_header_red(group_id); end
-  def make_example_group_header_yellow(group_id); end
-  def make_header_red; end
-  def make_header_yellow; end
-  def move_progress(percent_done); end
-  def print_example_failed(pending_fixed, description, run_time, failure_id, exception, extra_content); end
-  def print_example_group_end; end
-  def print_example_group_start(group_id, description, number_of_parents); end
-  def print_example_passed(description, run_time); end
-  def print_example_pending(description, pending_message); end
-  def print_html_start; end
-  def print_summary(duration, example_count, failure_count, pending_count); end
-
-  private
-
-  def indentation_style(number_of_parents); end
-end
-
-RSpec::Core::Formatters::HtmlPrinter::GLOBAL_SCRIPTS = T.let(T.unsafe(nil), String)
-RSpec::Core::Formatters::HtmlPrinter::GLOBAL_STYLES = T.let(T.unsafe(nil), String)
-RSpec::Core::Formatters::HtmlPrinter::HTML_HEADER = T.let(T.unsafe(nil), String)
-RSpec::Core::Formatters::HtmlPrinter::REPORT_HEADER = T.let(T.unsafe(nil), String)
-
-class RSpec::Core::Formatters::JsonFormatter < ::RSpec::Core::Formatters::BaseFormatter
-  def initialize(output); end
-
-  def close(_notification); end
-  def dump_profile(profile); end
-  def dump_profile_slowest_example_groups(profile); end
-  def dump_profile_slowest_examples(profile); end
-  def dump_summary(summary); end
-  def message(notification); end
-  def output_hash; end
-  def seed(notification); end
-  def stop(notification); end
-
-  private
-
-  def format_example(example); end
-end
-
-class RSpec::Core::Formatters::Loader
-  def initialize(reporter); end
-
-  def add(formatter_to_use, *paths); end
-  def default_formatter; end
-  def default_formatter=(_arg0); end
-  def formatters; end
-  def prepare_default(output_stream, deprecation_stream); end
-  def reporter; end
-  def setup_default(output_stream, deprecation_stream); end
-
-  private
-
-  def built_in_formatter(key); end
-  def custom_formatter(formatter_ref); end
-  def duplicate_formatter_exists?(new_formatter); end
-  def existing_formatter_implements?(notification); end
-  def find_formatter(formatter_to_use); end
-  def has_matching_output?(formatter, new_formatter); end
-  def notifications_for(formatter_class); end
-  def open_stream(path_or_wrapper); end
-  def path_for(const_ref); end
-  def register(formatter, notifications); end
-  def string_const?(str); end
-  def underscore(camel_cased_word); end
-  def underscore_with_fix_for_non_standard_rspec_naming(string); end
-
-  class << self
-    def formatters; end
-  end
-end
-
-class RSpec::Core::Formatters::ProfileFormatter
-  def initialize(output); end
-
-  def dump_profile(profile); end
-  def output; end
-
-  private
-
-  def bold(text); end
-  def dump_profile_slowest_example_groups(profile); end
-  def dump_profile_slowest_examples(profile); end
-  def format_caller(caller_info); end
-end
-
-class RSpec::Core::Formatters::ProgressFormatter < ::RSpec::Core::Formatters::BaseTextFormatter
-  def example_failed(_notification); end
-  def example_passed(_notification); end
-  def example_pending(_notification); end
-  def start_dump(_notification); end
-end
-
-class RSpec::Core::Formatters::SnippetExtractor
-  def initialize(source, beginning_line_number, max_line_count = T.unsafe(nil)); end
-
-  def beginning_line_number; end
-  def expression_lines; end
-  def max_line_count; end
-  def source; end
-
-  private
-
-  def expression_node; end
-  def expression_outmost_node?(node); end
-  def line_range_of_expression; end
-  def line_range_of_location_nodes_in_expression; end
-  def location_nodes_at_beginning_line; end
-  def unclosed_tokens_in_line_range(line_range); end
-
-  class << self
-    def extract_expression_lines_at(file_path, beginning_line_number, max_line_count = T.unsafe(nil)); end
-    def extract_line_at(file_path, line_number); end
-    def least_indentation_from(lines); end
-    def source_from_file(path); end
-  end
-end
-
-class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError < ::StandardError; end
-class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError < ::StandardError; end
-class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError < ::StandardError; end
-
-class RSpec::Core::Formatters::SyntaxHighlighter
-  def initialize(configuration); end
-
-  def highlight(lines); end
-
-  private
-
-  def color_enabled_implementation; end
-  def implementation; end
-
-  class << self
-    def attempt_to_add_rspec_terms_to_coderay_keywords; end
-  end
-end
-
-module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
-  class << self
-    def highlight_syntax(lines); end
-  end
-end
-
-RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation::RESET_CODE = T.let(T.unsafe(nil), String)
-
-module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
-  class << self
-    def highlight_syntax(lines); end
-  end
-end
-
-RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
-
-module RSpec::Core::HashImitatable
-  mixes_in_class_methods ::RSpec::Core::HashImitatable::ClassMethods
-
-  def <(*args, &block); end
-  def <=(*args, &block); end
-  def >(*args, &block); end
-  def >=(*args, &block); end
-  def [](key); end
-  def []=(key, value); end
-  def all?(*args, &block); end
-  def any?(*args, &block); end
-  def assoc(*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 collect(*args, &block); end
-  def collect_concat(*args, &block); end
-  def compact(*args, &block); end
-  def compact!(*args, &block); end
-  def compare_by_identity(*args, &block); end
-  def compare_by_identity?(*args, &block); end
-  def count(*args, &block); end
-  def cycle(*args, &block); end
-  def deep_merge(*args, &block); end
-  def deep_merge!(*args, &block); end
-  def default(*args, &block); end
-  def default=(*args, &block); end
-  def default_proc(*args, &block); end
-  def default_proc=(*args, &block); end
-  def delete(*args, &block); end
-  def delete_if(*args, &block); end
-  def detect(*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_key(*args, &block); end
-  def each_pair(*args, &block); end
-  def each_slice(*args, &block); end
-  def each_value(*args, &block); end
-  def each_with_index(*args, &block); end
-  def each_with_object(*args, &block); end
-  def empty?(*args, &block); end
-  def entries(*args, &block); end
-  def except(*args, &block); end
-  def except!(*args, &block); end
-  def extract!(*args, &block); end
-  def fetch(*args, &block); end
-  def fetch_values(*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 grep(*args, &block); end
-  def grep_v(*args, &block); end
-  def group_by(*args, &block); end
-  def has_key?(*args, &block); end
-  def has_value?(*args, &block); end
-  def include?(*args, &block); end
-  def index(*args, &block); end
-  def inject(*args, &block); end
-  def invert(*args, &block); end
-  def keep_if(*args, &block); end
-  def key(*args, &block); end
-  def key?(*args, &block); end
-  def keys(*args, &block); end
-  def lazy(*args, &block); end
-  def length(*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 merge(*args, &block); end
-  def merge!(*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 partition(*args, &block); end
-  def rassoc(*args, &block); end
-  def reduce(*args, &block); end
-  def rehash(*args, &block); end
-  def reject(*args, &block); end
-  def reject!(*args, &block); end
-  def replace(*args, &block); end
-  def reverse_each(*args, &block); end
-  def save_plist(*args, &block); end
-  def select(*args, &block); end
-  def select!(*args, &block); end
-  def shift(*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_by(*args, &block); end
-  def store(*args, &block); end
-  def sum(*args, &block); end
-  def take(*args, &block); end
-  def take_while(*args, &block); end
-  def to_a(*args, &block); end
-  def to_h; end
-  def to_hash(*args, &block); end
-  def to_msgpack(*args, &block); end
-  def to_plist(*args, &block); end
-  def to_proc(*args, &block); end
-  def to_set(*args, &block); end
-  def transform_keys(*args, &block); end
-  def transform_keys!(*args, &block); end
-  def transform_values(*args, &block); end
-  def transform_values!(*args, &block); end
-  def uniq(*args, &block); end
-  def update(*args, &block); end
-  def value?(*args, &block); end
-  def values(*args, &block); end
-  def values_at(*args, &block); end
-  def zip(*args, &block); end
-
-  private
-
-  def directly_supports_attribute?(name); end
-  def extra_hash_attributes; end
-  def get_value(name); end
-  def hash_for_delegation; end
-  def issue_deprecation(_method_name, *_args); end
-  def set_value(name, value); end
-
-  class << self
-    def included(klass); end
-  end
-end
-
-module RSpec::Core::HashImitatable::ClassMethods
-  def attr_accessor(*names); end
-  def hash_attribute_names; end
-end
-
-module RSpec::Core::Hooks
-  def after(*args, &block); end
-  def append_after(*args, &block); end
-  def append_before(*args, &block); end
-  def around(*args, &block); end
-  def before(*args, &block); end
-  def hooks; end
-  def prepend_after(*args, &block); end
-  def prepend_before(*args, &block); end
-end
-
-class RSpec::Core::Hooks::AfterContextHook < ::RSpec::Core::Hooks::Hook
-  def run(example); end
-end
-
-class RSpec::Core::Hooks::AfterHook < ::RSpec::Core::Hooks::Hook
-  def run(example); end
-end
-
-class RSpec::Core::Hooks::AroundHook < ::RSpec::Core::Hooks::Hook
-  def execute_with(example, procsy); end
-  def hook_description; end
-end
-
-class RSpec::Core::Hooks::BeforeHook < ::RSpec::Core::Hooks::Hook
-  def run(example); end
-end
-
-class RSpec::Core::Hooks::Hook < ::Struct
-  def block; end
-  def block=(_); end
-  def options; end
-  def options=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Core::Hooks::HookCollections
-  def initialize(owner, filterable_item_repo_class); end
-
-  def register(prepend_or_append, position, *args, &block); end
-  def register_global_singleton_context_hooks(example, globals); end
-  def register_globals(host, globals); end
-  def run(position, scope, example_or_group); end
-
-  protected
-
-  def all_hooks_for(position, scope); end
-  def matching_hooks_for(position, scope, example_or_group); end
-  def processable_hooks_for(position, scope, host); end
-  def run_owned_hooks_for(position, scope, example_or_group); end
-
-  private
-
-  def ensure_hooks_initialized_for(position, scope); end
-  def extract_scope_from(args); end
-  def hooks_for(position, scope); end
-  def known_scope?(scope); end
-  def normalized_scope_for(scope); end
-  def owner_parent_groups; end
-  def process(host, parent_groups, globals, position, scope); end
-  def run_around_example_hooks_for(example); end
-  def run_example_hooks_for(example, position, each_method); end
-  def scope_and_options_from(*args); end
-end
-
-RSpec::Core::Hooks::HookCollections::EMPTY_HOOK_ARRAY = T.let(T.unsafe(nil), Array)
-RSpec::Core::Hooks::HookCollections::HOOK_TYPES = T.let(T.unsafe(nil), Hash)
-RSpec::Core::Hooks::HookCollections::SCOPES = T.let(T.unsafe(nil), Array)
-RSpec::Core::Hooks::HookCollections::SCOPE_ALIASES = T.let(T.unsafe(nil), Hash)
-
-class RSpec::Core::InclusionRules < ::RSpec::Core::FilterRules
-  def add(*args); end
-  def add_with_low_priority(*args); end
-  def include_example?(example); end
-  def split_file_scoped_rules; end
-  def standalone?; end
-
-  private
-
-  def apply_standalone_filter(updated); end
-  def is_standalone_filter?(rules); end
-  def replace_filters(new_rules); end
-end
-
-module RSpec::Core::Invocations; end
-
-class RSpec::Core::Invocations::Bisect
-  def call(options, err, out); end
-
-  private
-
-  def bisect_formatter_klass_for(argument); end
-end
-
-class RSpec::Core::Invocations::DRbWithFallback
-  def call(options, err, out); end
-end
-
-class RSpec::Core::Invocations::InitializeProject
-  def call(*_args); end
-end
-
-class RSpec::Core::Invocations::PrintHelp < ::Struct
-  def call(_options, _err, out); end
-  def hidden_options; end
-  def hidden_options=(_); end
-  def parser; end
-  def parser=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Core::Invocations::PrintVersion
-  def call(_options, _err, out); end
-end
-
-class RSpec::Core::LegacyExampleGroupHash
-  include ::RSpec::Core::HashImitatable
-  extend ::RSpec::Core::HashImitatable::ClassMethods
-
-  def initialize(metadata); end
-
-  def to_h; end
-
-  private
-
-  def directly_supports_attribute?(name); end
-  def get_value(name); end
-  def set_value(name, value); end
-end
-
-module RSpec::Core::MemoizedHelpers
-  def initialize(*_arg0); end
-
-  def is_expected; end
-  def should(matcher = T.unsafe(nil), message = T.unsafe(nil)); end
-  def should_not(matcher = T.unsafe(nil), message = T.unsafe(nil)); end
-  def subject; end
-
-  private
-
-  def __init_memoized; end
-  def __memoized; end
-  def enforce_value_expectation(matcher, method_name); end
-  def matcher_supports_value_expectations?(matcher); end
-
-  class << self
-    def define_helpers_on(example_group); end
-    def get_constant_or_yield(example_group, name); end
-    def module_for(example_group); end
-  end
-end
-
-module RSpec::Core::MemoizedHelpers::ClassMethods
-  def let(name, &block); end
-  def let!(name, &block); end
-  def subject(name = T.unsafe(nil), &block); end
-  def subject!(name = T.unsafe(nil), &block); end
-end
-
-class RSpec::Core::MemoizedHelpers::ContextHookMemoized
-  class << self
-    def fetch_or_store(key, &_block); end
-    def isolate_for_context_hook(example_group_instance); end
-  end
-end
-
-class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After < ::RSpec::Core::MemoizedHelpers::ContextHookMemoized
-  class << self
-    def article; end
-    def hook_expression; end
-    def hook_intention; end
-  end
-end
-
-class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before < ::RSpec::Core::MemoizedHelpers::ContextHookMemoized
-  class << self
-    def article; end
-    def hook_expression; end
-    def hook_intention; end
-  end
-end
-
-class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized
-  def initialize; end
-
-  def fetch_or_store(key); end
-end
-
-class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized
-  def initialize; end
-
-  def fetch_or_store(key); end
-end
-
-module RSpec::Core::Metadata
-  class << self
-    def ascend(metadata); end
-    def ascending(metadata); end
-    def build_hash_from(args, warn_about_example_group_filtering = T.unsafe(nil)); end
-    def deep_hash_dup(object); end
-    def id_from(metadata); end
-    def location_tuple_from(metadata); end
-    def relative_path(line); end
-    def relative_path_regex; end
-  end
-end
-
-class RSpec::Core::Metadata::ExampleGroupHash < ::RSpec::Core::Metadata::HashPopulator
-  private
-
-  def described_class; end
-  def full_description; end
-
-  class << self
-    def backwards_compatibility_default_proc(&example_group_selector); end
-    def create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end
-    def hash_with_backwards_compatibility_default_proc; end
-  end
-end
-
-class RSpec::Core::Metadata::ExampleHash < ::RSpec::Core::Metadata::HashPopulator
-  private
-
-  def described_class; end
-  def full_description; end
-
-  class << self
-    def create(group_metadata, user_metadata, index_provider, description, block); end
-  end
-end
-
-class RSpec::Core::Metadata::HashPopulator
-  def initialize(metadata, user_metadata, index_provider, description_args, block); end
-
-  def block; end
-  def description_args; end
-  def metadata; end
-  def populate; end
-  def user_metadata; end
-
-  private
-
-  def build_description_from(parent_description = T.unsafe(nil), my_description = T.unsafe(nil)); end
-  def build_scoped_id_for(file_path); end
-  def description_separator(parent_part, child_part); end
-  def ensure_valid_user_keys; end
-  def file_path_and_line_number_from(backtrace); end
-  def populate_location_attributes; end
-end
-
-RSpec::Core::Metadata::RESERVED_KEYS = T.let(T.unsafe(nil), Array)
-
-module RSpec::Core::MetadataFilter
-  class << self
-    def apply?(predicate, filters, metadata); end
-    def filter_applies?(key, filter_value, metadata); end
-    def silence_metadata_example_group_deprecations; end
-
-    private
-
-    def filter_applies_to_any_value?(key, value, metadata); end
-    def filters_apply?(key, value, metadata); end
-    def id_filter_applies?(rerun_paths_to_scoped_ids, metadata); end
-    def location_filter_applies?(locations, metadata); end
-    def proc_filter_applies?(key, proc, metadata); end
-  end
-end
-
-class RSpec::Core::MultipleExceptionError < ::StandardError
-  include ::RSpec::Core::MultipleExceptionError::InterfaceTag
-
-  def initialize(*exceptions); end
-
-  def aggregation_block_label; end
-  def aggregation_metadata; end
-  def all_exceptions; end
-  def exception_count_description; end
-  def failures; end
-  def message; end
-  def other_errors; end
-  def summary; end
-end
-
-module RSpec::Core::MultipleExceptionError::InterfaceTag
-  def add(exception); end
-
-  class << self
-    def for(ex); end
-  end
-end
-
-module RSpec::Core::Notifications; end
-
-class RSpec::Core::Notifications::CustomNotification < ::Struct
-  class << self
-    def for(options = T.unsafe(nil)); end
-  end
-end
-
-class RSpec::Core::Notifications::DeprecationNotification < ::Struct
-  def call_site; end
-  def call_site=(_); end
-  def deprecated; end
-  def deprecated=(_); end
-  def message; end
-  def message=(_); end
-  def replacement; end
-  def replacement=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def from_hash(data); end
-    def inspect; end
-    def members; end
-
-    private
-
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Core::Notifications::ExampleNotification < ::Struct
-  def example; end
-  def example=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def for(example); end
-    def inspect; end
-    def members; end
-
-    private
-
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Core::Notifications::ExamplesNotification
-  def initialize(reporter); end
-
-  def examples; end
-  def failed_examples; end
-  def failure_notifications; end
-  def fully_formatted_failed_examples(colorizer = T.unsafe(nil)); end
-  def fully_formatted_pending_examples(colorizer = T.unsafe(nil)); end
-  def notifications; end
-  def pending_examples; end
-  def pending_notifications; end
-
-  private
-
-  def format_examples(examples); end
-end
-
-class RSpec::Core::Notifications::FailedExampleNotification < ::RSpec::Core::Notifications::ExampleNotification
-  def initialize(example, exception_presenter = T.unsafe(nil)); end
-
-  def colorized_formatted_backtrace(colorizer = T.unsafe(nil)); end
-  def colorized_message_lines(colorizer = T.unsafe(nil)); end
-  def description; end
-  def exception; end
-  def formatted_backtrace; end
-  def fully_formatted(failure_number, colorizer = T.unsafe(nil)); end
-  def fully_formatted_lines(failure_number, colorizer = T.unsafe(nil)); end
-  def message_lines; end
-end
-
-class RSpec::Core::Notifications::GroupNotification < ::Struct
-  def group; end
-  def group=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Core::Notifications::MessageNotification < ::Struct
-  def message; end
-  def message=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-module RSpec::Core::Notifications::NullColorizer
-  private
-
-  def wrap(line, _code_or_symbol); end
-
-  class << self
-    def wrap(line, _code_or_symbol); end
-  end
-end
-
-class RSpec::Core::Notifications::NullNotification; end
-class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification < ::RSpec::Core::Notifications::FailedExampleNotification; end
-class RSpec::Core::Notifications::PendingExampleFixedNotification < ::RSpec::Core::Notifications::FailedExampleNotification; end
-
-class RSpec::Core::Notifications::ProfileNotification
-  def initialize(duration, examples, number_of_examples, example_groups); end
-
-  def duration; end
-  def examples; end
-  def number_of_examples; end
-  def percentage; end
-  def slow_duration; end
-  def slowest_examples; end
-  def slowest_groups; end
-
-  private
-
-  def calculate_slowest_groups; end
-end
-
-class RSpec::Core::Notifications::SeedNotification < ::Struct
-  def fully_formatted; end
-  def seed; end
-  def seed=(_); end
-  def seed_used?; end
-  def used=(_); end
-
-  private
-
-  def used; end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Core::Notifications::SkippedExampleNotification < ::RSpec::Core::Notifications::ExampleNotification
-  def fully_formatted(pending_number, colorizer = T.unsafe(nil)); end
-end
-
-class RSpec::Core::Notifications::StartNotification < ::Struct
-  def count; end
-  def count=(_); end
-  def load_time; end
-  def load_time=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Core::Notifications::SummaryNotification < ::Struct
-  include ::RSpec::Core::ShellEscape
-
-  def colorized_rerun_commands(colorizer = T.unsafe(nil)); end
-  def colorized_totals_line(colorizer = T.unsafe(nil)); end
-  def duration; end
-  def duration=(_); end
-  def errors_outside_of_examples_count; end
-  def errors_outside_of_examples_count=(_); end
-  def example_count; end
-  def examples; end
-  def examples=(_); end
-  def failed_examples; end
-  def failed_examples=(_); end
-  def failure_count; end
-  def formatted_duration; end
-  def formatted_load_time; end
-  def fully_formatted(colorizer = T.unsafe(nil)); end
-  def load_time; end
-  def load_time=(_); end
-  def pending_count; end
-  def pending_examples; end
-  def pending_examples=(_); end
-  def totals_line; end
-
-  private
-
-  def duplicate_rerun_locations; end
-  def rerun_argument_for(example); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Core::NullReporter
-  class << self
-    private
-
-    def method_missing(*_arg0); end
-  end
-end
-
-module RSpec::Core::Ordering; end
-
-class RSpec::Core::Ordering::ConfigurationManager
-  def initialize; end
-
-  def force(hash); end
-  def order=(type); end
-  def ordering_registry; end
-  def register_ordering(name, strategy = T.unsafe(nil)); end
-  def seed; end
-  def seed=(seed); end
-  def seed_used?; end
-end
-
-class RSpec::Core::Ordering::Custom
-  def initialize(callable); end
-
-  def order(list); end
-end
-
-class RSpec::Core::Ordering::Identity
-  def order(items); end
-end
-
-class RSpec::Core::Ordering::Random
-  def initialize(configuration); end
-
-  def order(items); end
-  def used?; end
-
-  private
-
-  def jenkins_hash_digest(string); end
-end
-
-RSpec::Core::Ordering::Random::MAX_32_BIT = T.let(T.unsafe(nil), Integer)
-
-class RSpec::Core::Ordering::RecentlyModified
-  def order(list); end
-end
-
-class RSpec::Core::Ordering::Registry
-  def initialize(configuration); end
-
-  def fetch(name, &fallback); end
-  def register(sym, strategy); end
-  def used_random_seed?; end
-end
-
-class RSpec::Core::OutputWrapper
-  def initialize(output); end
-
-  def <<(*args, &block); end
-  def advise(*args, &block); end
-  def autoclose=(*args, &block); end
-  def autoclose?(*args, &block); end
-  def beep(*args, &block); end
-  def binmode(*args, &block); end
-  def binmode?(*args, &block); end
-  def bytes(*args, &block); end
-  def chars(*args, &block); end
-  def close(*args, &block); end
-  def close_on_exec=(*args, &block); end
-  def close_on_exec?(*args, &block); end
-  def close_read(*args, &block); end
-  def close_write(*args, &block); end
-  def closed?(*args, &block); end
-  def codepoints(*args, &block); end
-  def cooked(*args, &block); end
-  def cooked!(*args, &block); end
-  def cursor(*args, &block); end
-  def cursor=(*args, &block); end
-  def each(*args, &block); end
-  def each_byte(*args, &block); end
-  def each_char(*args, &block); end
-  def each_codepoint(*args, &block); end
-  def each_line(*args, &block); end
-  def echo=(*args, &block); end
-  def echo?(*args, &block); end
-  def eof(*args, &block); end
-  def eof?(*args, &block); end
-  def external_encoding(*args, &block); end
-  def fcntl(*args, &block); end
-  def fdatasync(*args, &block); end
-  def fileno(*args, &block); end
-  def flush(*args, &block); end
-  def fsync(*args, &block); end
-  def getbyte(*args, &block); end
-  def getc(*args, &block); end
-  def getch(*args, &block); end
-  def getpass(*args, &block); end
-  def gets(*args, &block); end
-  def goto(*args, &block); end
-  def iflush(*args, &block); end
-  def inspect(*args, &block); end
-  def internal_encoding(*args, &block); end
-  def ioctl(*args, &block); end
-  def ioflush(*args, &block); end
-  def isatty(*args, &block); end
-  def lineno(*args, &block); end
-  def lineno=(*args, &block); end
-  def lines(*args, &block); end
-  def method_missing(name, *args, &block); end
-  def noecho(*args, &block); end
-  def nonblock(*args, &block); end
-  def nonblock=(*args, &block); end
-  def nonblock?(*args, &block); end
-  def nread(*args, &block); end
-  def oflush(*args, &block); end
-  def output; end
-  def output=(_arg0); end
-  def pathconf(*args, &block); end
-  def pid(*args, &block); end
-  def pos(*args, &block); end
-  def pos=(*args, &block); end
-  def pread(*args, &block); end
-  def pressed?(*args, &block); end
-  def print(*args, &block); end
-  def printf(*args, &block); end
-  def putc(*args, &block); end
-  def puts(*args, &block); end
-  def pwrite(*args, &block); end
-  def raw(*args, &block); end
-  def raw!(*args, &block); end
-  def read(*args, &block); end
-  def read_nonblock(*args, &block); end
-  def readbyte(*args, &block); end
-  def readchar(*args, &block); end
-  def readline(*args, &block); end
-  def readlines(*args, &block); end
-  def readpartial(*args, &block); end
-  def ready?(*args, &block); end
-  def reopen(*args, &block); end
-  def respond_to?(name, priv = T.unsafe(nil)); end
-  def rewind(*args, &block); end
-  def seek(*args, &block); end
-  def set_encoding(*args, &block); end
-  def stat(*args, &block); end
-  def sync(*args, &block); end
-  def sync=(*args, &block); end
-  def sysread(*args, &block); end
-  def sysseek(*args, &block); end
-  def syswrite(*args, &block); end
-  def tell(*args, &block); end
-  def to_i(*args, &block); end
-  def to_io(*args, &block); end
-  def tty?(*args, &block); end
-  def ungetbyte(*args, &block); end
-  def ungetc(*args, &block); end
-  def wait(*args, &block); end
-  def wait_readable(*args, &block); end
-  def wait_writable(*args, &block); end
-  def winsize(*args, &block); end
-  def winsize=(*args, &block); end
-  def write(*args, &block); end
-  def write_nonblock(*args, &block); end
-end
-
-class RSpec::Core::Parser
-  def initialize(original_args); end
-
-  def original_args; end
-  def parse(source = T.unsafe(nil)); end
-
-  private
-
-  def add_tag_filter(options, filter_type, tag_name, value = T.unsafe(nil)); end
-  def configure_only_failures(options); end
-  def parser(options); end
-  def set_fail_fast(options, value); end
-
-  class << self
-    def parse(args, source = T.unsafe(nil)); end
-  end
-end
-
-module RSpec::Core::Pending
-  def pending(message = T.unsafe(nil)); end
-  def skip(message = T.unsafe(nil)); end
-
-  class << self
-    def mark_fixed!(example); end
-    def mark_pending!(example, message_or_bool); end
-    def mark_skipped!(example, message_or_bool); end
-  end
-end
-
-RSpec::Core::Pending::NOT_YET_IMPLEMENTED = T.let(T.unsafe(nil), String)
-RSpec::Core::Pending::NO_REASON_GIVEN = T.let(T.unsafe(nil), String)
-class RSpec::Core::Pending::PendingExampleFixedError < ::StandardError; end
-
-class RSpec::Core::Pending::SkipDeclaredInExample < ::StandardError
-  def initialize(argument); end
-
-  def argument; end
-end
-
-class RSpec::Core::Profiler
-  def initialize; end
-
-  def example_group_finished(notification); end
-  def example_group_started(notification); end
-  def example_groups; end
-  def example_started(notification); end
-end
-
-RSpec::Core::Profiler::NOTIFICATIONS = T.let(T.unsafe(nil), Array)
-
-class RSpec::Core::Reporter
-  def initialize(configuration); end
-
-  def abort_with(msg, exit_status); end
-  def close_after; end
-  def deprecation(hash); end
-  def example_failed(example); end
-  def example_finished(example); end
-  def example_group_finished(group); end
-  def example_group_started(group); end
-  def example_passed(example); end
-  def example_pending(example); end
-  def example_started(example); end
-  def examples; end
-  def exit_early(exit_code); end
-  def fail_fast_limit_met?; end
-  def failed_examples; end
-  def finish; end
-  def message(message); end
-  def notify(event, notification); end
-  def notify_non_example_exception(exception, context_description); end
-  def pending_examples; end
-  def prepare_default(loader, output_stream, deprecation_stream); end
-  def publish(event, options = T.unsafe(nil)); end
-  def register_listener(listener, *notifications); end
-  def registered_listeners(notification); end
-  def report(expected_example_count); end
-  def start(expected_example_count, time = T.unsafe(nil)); end
-  def stop; end
-
-  private
-
-  def close; end
-  def ensure_listeners_ready; end
-  def mute_profile_output?; end
-  def seed_used?; end
-end
-
-RSpec::Core::Reporter::RSPEC_NOTIFICATIONS = T.let(T.unsafe(nil), RSpec::Core::Set)
-
-module RSpec::Core::RubyProject
-  private
-
-  def add_dir_to_load_path(dir); end
-  def add_to_load_path(*dirs); end
-  def ascend_until; end
-  def determine_root; end
-  def find_first_parent_containing(dir); end
-  def root; end
-
-  class << self
-    def add_dir_to_load_path(dir); end
-    def add_to_load_path(*dirs); end
-    def ascend_until; end
-    def determine_root; end
-    def find_first_parent_containing(dir); end
-    def root; end
-  end
-end
-
-class RSpec::Core::Runner
-  def initialize(options, configuration = T.unsafe(nil), world = T.unsafe(nil)); end
-
-  def configuration; end
-  def configure(err, out); end
-  def exit_code(examples_passed = T.unsafe(nil)); end
-  def options; end
-  def run(err, out); end
-  def run_specs(example_groups); end
-  def setup(err, out); end
-  def world; end
-
-  private
-
-  def persist_example_statuses; end
-
-  class << self
-    def autorun; end
-    def autorun_disabled?; end
-    def disable_autorun!; end
-    def handle_interrupt; end
-    def installed_at_exit?; end
-    def invoke; end
-    def perform_at_exit; end
-    def run(args, err = T.unsafe(nil), out = T.unsafe(nil)); end
-    def running_in_drb?; end
-    def trap_interrupt; end
-  end
-end
-
-class RSpec::Core::Set
-  include ::Enumerable
-
-  def initialize(array = T.unsafe(nil)); end
-
-  def <<(key); end
-  def clear; end
-  def delete(key); end
-  def each(&block); end
-  def empty?; end
-  def include?(key); end
-  def merge(values); end
-end
-
-module RSpec::Core::SharedContext
-  include ::RSpec::Its
-
-  def __shared_context_recordings; end
-  def after(*args, &block); end
-  def append_after(*args, &block); end
-  def append_before(*args, &block); end
-  def around(*args, &block); end
-  def before(*args, &block); end
-  def context(*args, &block); end
-  def describe(*args, &block); end
-  def hooks(*args, &block); end
-  def included(group); end
-  def let(*args, &block); end
-  def let!(*args, &block); end
-  def prepend_after(*args, &block); end
-  def prepend_before(*args, &block); end
-  def subject(*args, &block); end
-  def subject!(*args, &block); end
-
-  class << self
-    def record(methods); end
-  end
-end
-
-class RSpec::Core::SharedContext::Recording < ::Struct
-  def args; end
-  def args=(_); end
-  def block; end
-  def block=(_); end
-  def method_name; end
-  def method_name=(_); end
-  def playback_onto(group); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-module RSpec::Core::SharedExampleGroup
-  def shared_context(name, *args, &block); end
-  def shared_examples(name, *args, &block); end
-  def shared_examples_for(name, *args, &block); end
-end
-
-class RSpec::Core::SharedExampleGroup::Registry
-  def add(context, name, *metadata_args, &block); end
-  def find(lookup_contexts, name); end
-
-  private
-
-  def ensure_block_has_source_location(_block); end
-  def formatted_location(block); end
-  def legacy_add(context, name, *metadata_args, &block); end
-  def shared_example_groups; end
-  def valid_name?(candidate); end
-  def warn_if_key_taken(context, key, new_block); end
-end
-
-module RSpec::Core::SharedExampleGroup::TopLevelDSL
-  class << self
-    def definitions; end
-    def expose_globally!; end
-    def exposed_globally?; end
-    def remove_globally!; end
-  end
-end
-
-class RSpec::Core::SharedExampleGroupInclusionStackFrame
-  def initialize(shared_group_name, inclusion_location); end
-
-  def description; end
-  def formatted_inclusion_location; end
-  def inclusion_location; end
-  def shared_group_name; end
-
-  class << self
-    def current_backtrace; end
-    def shared_example_group_inclusions; end
-    def with_frame(name, location); end
-  end
-end
-
-class RSpec::Core::SharedExampleGroupModule < ::Module
-  def initialize(description, definition, metadata); end
-
-  def definition; end
-  def include_in(klass, inclusion_line, args, customization_block); end
-  def included(klass); end
-  def inspect; end
-  def to_s; end
-end
-
-module RSpec::Core::ShellEscape
-  private
-
-  def conditionally_quote(id); end
-  def escape(shell_command); end
-  def quote(argument); end
-  def shell_allows_unquoted_ids?; end
-
-  class << self
-    def conditionally_quote(id); end
-    def escape(shell_command); end
-    def quote(argument); end
-    def shell_allows_unquoted_ids?; end
-  end
-end
-
-RSpec::Core::ShellEscape::SHELLS_ALLOWING_UNQUOTED_IDS = T.let(T.unsafe(nil), Array)
-
-class RSpec::Core::SuiteHookContext < ::RSpec::Core::Example
-  def initialize(hook_description, reporter); end
-
-  def set_exception(exception); end
-end
-
-class RSpec::Core::Time
-  class << self
-    def now; end
-  end
-end
-
-module RSpec::Core::Version; end
-RSpec::Core::Version::STRING = T.let(T.unsafe(nil), String)
-
-module RSpec::Core::Warnings
-  def deprecate(deprecated, data = T.unsafe(nil)); end
-  def warn_deprecation(message, opts = T.unsafe(nil)); end
-  def warn_with(message, options = T.unsafe(nil)); end
-end
-
-class RSpec::Core::World
-  def initialize(configuration = T.unsafe(nil)); end
-
-  def all_example_groups; end
-  def all_examples; end
-  def announce_exclusion_filter(announcements); end
-  def announce_filters; end
-  def announce_inclusion_filter(announcements); end
-  def everything_filtered_message; end
-  def example_count(groups = T.unsafe(nil)); end
-  def example_group_counts_by_spec_file; end
-  def example_groups; end
-  def exclusion_filter; end
-  def filter_manager; end
-  def filtered_examples; end
-  def inclusion_filter; end
-  def non_example_failure; end
-  def non_example_failure=(_arg0); end
-  def num_example_groups_defined_in(file); end
-  def ordered_example_groups; end
-  def preceding_declaration_line(absolute_file_name, filter_line); end
-  def prepare_example_filtering; end
-  def record(example_group); end
-  def registered_example_group_files; end
-  def report_filter_message(message); end
-  def reporter; end
-  def reset; end
-  def rspec_is_quitting; end
-  def rspec_is_quitting=(_arg0); end
-  def shared_example_group_registry; end
-  def source_from_file(path); end
-  def syntax_highlighter; end
-  def traverse_example_group_trees_until(&block); end
-  def wants_to_quit; end
-  def wants_to_quit=(_arg0); end
-
-  private
-
-  def descending_declaration_line_numbers_by_file; end
-  def fail_if_config_and_cli_options_invalid; end
-end
-
-module RSpec::Core::World::Null
-  class << self
-    def all_example_groups; end
-    def example_groups; end
-    def non_example_failure; end
-    def non_example_failure=(_); end
-    def registered_example_group_files; end
-    def traverse_example_group_trees_until; end
-  end
-end
-
-module RSpec::ExampleGroups
-  extend ::RSpec::Support::RecursiveConstMethods
-
-  class << self
-    def assign_const(group); end
-    def base_name_for(group); end
-    def constant_scope_for(group); end
-    def disambiguate(name, const_scope); end
-    def remove_all_constants; end
-  end
-end
-
-RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
-RSpec::SharedContext = RSpec::Core::SharedContext
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.13.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.13.2.rbi
new file mode 100644
index 0000000000000..9b68be7aa5389
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.13.2.rbi
@@ -0,0 +1,11040 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rspec-core` gem.
+# Please instead update this file by running `bin/tapioca gem rspec-core`.
+
+
+module ERB::Escape
+  private
+
+  def html_escape(_arg0); end
+
+  class << self
+    def html_escape(_arg0); end
+  end
+end
+
+# Namespace for all core RSpec code.
+#
+# source://rspec-core//lib/rspec/core/version.rb#1
+module RSpec
+  extend ::RSpec::Core::Warnings
+
+  class << self
+    # Used to ensure examples get reloaded between multiple runs in the same
+    # process and ensures user configuration is persisted.
+    #
+    # Users must invoke this if they want to clear all examples but preserve
+    # current configuration when they use the runner multiple times within the
+    # same process.
+    #
+    # source://rspec-core//lib/rspec/core.rb#70
+    def clear_examples; end
+
+    # Returns the global [Configuration](RSpec/Core/Configuration) object. While
+    # you _can_ use this method to access the configuration, the more common
+    # convention is to use [RSpec.configure](RSpec#configure-class_method).
+    #
+    # @example
+    #   RSpec.configuration.drb_port = 1234
+    # @see RSpec.configure
+    # @see Core::Configuration
+    #
+    # source://rspec-core//lib/rspec/core.rb#85
+    def configuration; end
+
+    # Setters for shared global objects
+    #
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core.rb#49
+    def configuration=(_arg0); end
+
+    # Yields the global configuration to a block.
+    #
+    # @example
+    #   RSpec.configure do |config|
+    #   config.add_formatter 'documentation'
+    #   end
+    # @see Core::Configuration
+    # @yield [Configuration] global configuration
+    #
+    # source://rspec-core//lib/rspec/core.rb#97
+    def configure; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core.rb#194
+    def const_missing(name); end
+
+    # source://rspec-core//lib/rspec/core/dsl.rb#42
+    def context(*args, &example_group_block); end
+
+    # The example being executed.
+    #
+    # The primary audience for this method is library authors who need access
+    # to the example currently being executed and also want to support all
+    # versions of RSpec 2 and 3.
+    #
+    # @example
+    #
+    #   RSpec.configure do |c|
+    #   # context.example is deprecated, but RSpec.current_example is not
+    #   # available until RSpec 3.0.
+    #   fetch_current_example = RSpec.respond_to?(:current_example) ?
+    #   proc { RSpec.current_example } : proc { |context| context.example }
+    #
+    #   c.before(:example) do
+    #   example = fetch_current_example.call(self)
+    #
+    #   # ...
+    #   end
+    #   end
+    #
+    # source://rspec-core//lib/rspec/core.rb#122
+    def current_example; end
+
+    # Set the current example being executed.
+    #
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core.rb#128
+    def current_example=(example); end
+
+    # Get the current RSpec execution scope
+    #
+    # Returns (in order of lifecycle):
+    #   * `:suite` as an initial value, this is outside of the test lifecycle.
+    #   * `:before_suite_hook` during `before(:suite)` hooks.
+    #   * `:before_context_hook` during `before(:context)` hooks.
+    #   * `:before_example_hook` during `before(:example)` hooks and `around(:example)` before `example.run`.
+    #   * `:example` within the example run.
+    #   * `:after_example_hook` during `after(:example)` hooks and `around(:example)` after `example.run`.
+    #   * `:after_context_hook` during `after(:context)` hooks.
+    #   * `:after_suite_hook` during `after(:suite)` hooks.
+    #   * `:suite` as a final value, again this is outside of the test lifecycle.
+    #
+    # Reminder, `:context` hooks have `:all` alias and `:example` hooks have `:each` alias.
+    #
+    # @return [Symbol]
+    #
+    # source://rspec-core//lib/rspec/core.rb#154
+    def current_scope; end
+
+    # Set the current scope rspec is executing in
+    #
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core.rb#134
+    def current_scope=(scope); end
+
+    # source://rspec-core//lib/rspec/core/dsl.rb#42
+    def describe(*args, &example_group_block); end
+
+    # source://rspec-core//lib/rspec/core/dsl.rb#42
+    def example_group(*args, &example_group_block); end
+
+    # source://rspec-core//lib/rspec/core/dsl.rb#42
+    def fcontext(*args, &example_group_block); end
+
+    # source://rspec-core//lib/rspec/core/dsl.rb#42
+    def fdescribe(*args, &example_group_block); end
+
+    # Used to ensure examples get reloaded and user configuration gets reset to
+    # defaults between multiple runs in the same process.
+    #
+    # Users must invoke this if they want to have the configuration reset when
+    # they use the runner multiple times within the same process. Users must deal
+    # themselves with re-configuration of RSpec before run.
+    #
+    # source://rspec-core//lib/rspec/core.rb#58
+    def reset; end
+
+    # source://rspec-core//lib/rspec/core/shared_example_group.rb#110
+    def shared_context(name, *args, &block); end
+
+    # source://rspec-core//lib/rspec/core/shared_example_group.rb#110
+    def shared_examples(name, *args, &block); end
+
+    # source://rspec-core//lib/rspec/core/shared_example_group.rb#110
+    def shared_examples_for(name, *args, &block); end
+
+    # Internal container for global non-configuration data.
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core.rb#160
+    def world; end
+
+    # Setters for shared global objects
+    #
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core.rb#49
+    def world=(_arg0); end
+
+    # source://rspec-core//lib/rspec/core/dsl.rb#42
+    def xcontext(*args, &example_group_block); end
+
+    # source://rspec-core//lib/rspec/core/dsl.rb#42
+    def xdescribe(*args, &example_group_block); end
+  end
+end
+
+# Namespace for the rspec-core code.
+#
+# source://rspec-core//lib/rspec/core/version.rb#2
+module RSpec::Core
+  class << self
+    # @private path to executable file.
+    #
+    # source://rspec-core//lib/rspec/core.rb#181
+    def path_to_executable; end
+  end
+end
+
+# Unnamed example group used by `SuiteHookContext`.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/example_group.rb#775
+class RSpec::Core::AnonymousExampleGroup < ::RSpec::Core::ExampleGroup
+  class << self
+    # source://rspec-core//lib/rspec/core/example_group.rb#776
+    def metadata; end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/backtrace_formatter.rb#4
+class RSpec::Core::BacktraceFormatter
+  # @return [BacktraceFormatter] a new instance of BacktraceFormatter
+  #
+  # source://rspec-core//lib/rspec/core/backtrace_formatter.rb#8
+  def initialize; end
+
+  # source://rspec-core//lib/rspec/core/backtrace_formatter.rb#49
+  def backtrace_line(line); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/backtrace_formatter.rb#53
+  def exclude?(line); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/backtrace_formatter.rb#6
+  def exclusion_patterns; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/backtrace_formatter.rb#6
+  def exclusion_patterns=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/backtrace_formatter.rb#28
+  def filter_gem(gem_name); end
+
+  # source://rspec-core//lib/rspec/core/backtrace_formatter.rb#33
+  def format_backtrace(backtrace, options = T.unsafe(nil)); end
+
+  # Sets the attribute full_backtrace
+  #
+  # @param value the value to set the attribute full_backtrace to.
+  #
+  # source://rspec-core//lib/rspec/core/backtrace_formatter.rb#22
+  def full_backtrace=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/backtrace_formatter.rb#24
+  def full_backtrace?; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/backtrace_formatter.rb#6
+  def inclusion_patterns; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/backtrace_formatter.rb#6
+  def inclusion_patterns=(_arg0); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/backtrace_formatter.rb#60
+  def matches?(patterns, line); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/bisect/utilities.rb#3
+module RSpec::Core::Bisect; end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/bisect/utilities.rb#8
+class RSpec::Core::Bisect::BisectFailedError < ::StandardError
+  class << self
+    # source://rspec-core//lib/rspec/core/bisect/utilities.rb#9
+    def for_failed_spec_run(spec_output); end
+  end
+end
+
+# Wraps a pipe to support sending objects between a child and
+# parent process. Where supported, encoding is explicitly
+# set to ensure binary data is able to pass from child to
+# parent.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/bisect/utilities.rb#36
+class RSpec::Core::Bisect::Channel
+  # @return [Channel] a new instance of Channel
+  #
+  # source://rspec-core//lib/rspec/core/bisect/utilities.rb#41
+  def initialize; end
+
+  # source://rspec-core//lib/rspec/core/bisect/utilities.rb#62
+  def close; end
+
+  # source://rspec-core//lib/rspec/core/bisect/utilities.rb#56
+  def receive; end
+
+  # source://rspec-core//lib/rspec/core/bisect/utilities.rb#50
+  def send(message); end
+end
+
+# source://rspec-core//lib/rspec/core/bisect/utilities.rb#38
+RSpec::Core::Bisect::Channel::MARSHAL_DUMP_ENCODING = T.let(T.unsafe(nil), Encoding)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/bisect/utilities.rb#5
+class RSpec::Core::Bisect::ExampleSetDescriptor < ::Struct
+  # Returns the value of attribute all_example_ids
+  #
+  # @return [Object] the current value of all_example_ids
+  def all_example_ids; end
+
+  # Sets the attribute all_example_ids
+  #
+  # @param value [Object] the value to set the attribute all_example_ids to.
+  # @return [Object] the newly set value
+  def all_example_ids=(_); end
+
+  # Returns the value of attribute failed_example_ids
+  #
+  # @return [Object] the current value of failed_example_ids
+  def failed_example_ids; end
+
+  # Sets the attribute failed_example_ids
+  #
+  # @param value [Object] the value to set the attribute failed_example_ids to.
+  # @return [Object] the newly set value
+  def failed_example_ids=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# Wraps a `formatter` providing a simple means to notify it in place
+# of an `RSpec::Core::Reporter`, without involving configuration in
+# any way.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/bisect/utilities.rb#19
+class RSpec::Core::Bisect::Notifier
+  # @return [Notifier] a new instance of Notifier
+  #
+  # source://rspec-core//lib/rspec/core/bisect/utilities.rb#20
+  def initialize(formatter); end
+
+  # source://rspec-core//lib/rspec/core/bisect/utilities.rb#24
+  def publish(event, *args); end
+end
+
+# Stores runtime configuration information.
+#
+# Configuration options are loaded from multiple files and joined together
+# with command-line switches and the `SPEC_OPTS` environment variable.
+#
+# Precedence order (where later entries overwrite earlier entries on
+# conflicts):
+#
+#   * Global (`$XDG_CONFIG_HOME/rspec/options`, or `~/.rspec` if it does
+#     not exist)
+#   * Project-specific (`./.rspec`)
+#   * Local (`./.rspec-local`)
+#   * Command-line options
+#   * `SPEC_OPTS`
+#
+# For example, an option set in the local file will override an option set
+# in your global file.
+#
+# The global, project-specific and local files can all be overridden with a
+# separate custom file using the --options command-line parameter.
+#
+# @example Standard settings
+#   RSpec.configure do |c|
+#   c.drb          = true
+#   c.drb_port     = 1234
+#   c.default_path = 'behavior'
+#   end
+# @example Hooks
+#   RSpec.configure do |c|
+#   c.before(:suite)   { establish_connection }
+#   c.before(:example) { log_in_as :authorized }
+#   c.around(:example) { |ex| Database.transaction(&ex) }
+#   end
+# @see RSpec.configure
+# @see Hooks
+#
+# source://rspec-core//lib/rspec/core/configuration.rb#47
+class RSpec::Core::Configuration
+  include ::RSpec::Core::Hooks
+  include ::RSpec::Core::Configuration::Readers
+
+  # Build an object to store runtime configuration options and set defaults
+  #
+  # @return [Configuration] a new instance of Configuration
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#528
+  def initialize; end
+
+  # Adds a formatter to the set RSpec will use for this run.
+  #
+  # @overload add_formatter
+  # @overload add_formatter
+  # @param formatter [Class, String, Object] formatter to use. Can be any of the
+  #   string values supported from the CLI (`p`/`progress`,
+  #   `d`/`doc`/`documentation`, `h`/`html`, or `j`/`json`), any
+  #   class that implements the formatter protocol and has registered
+  #   itself with RSpec as a formatter, or a formatter instance.
+  # @param output [String, IO] where the formatter will write its output.
+  #   Can be an IO object or a string path to a file. If not provided,
+  #   the configured `output_stream` (`$stdout`, by default) will be used.
+  # @see RSpec::Core::Formatters::Protocol
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#996
+  def add_formatter(formatter, output = T.unsafe(nil)); end
+
+  # Adds a custom setting to the RSpec.configuration object.
+  #
+  #     RSpec.configuration.add_setting :foo
+  #
+  # Used internally and by extension frameworks like rspec-rails, so they
+  # can add config settings that are domain specific. For example:
+  #
+  #     RSpec.configure do |c|
+  #       c.add_setting :use_transactional_fixtures,
+  #         :default => true,
+  #         :alias_with => :use_transactional_examples
+  #     end
+  #
+  # `add_setting` creates three methods on the configuration object, a
+  # setter, a getter, and a predicate:
+  #
+  #     RSpec.configuration.foo=(value)
+  #     RSpec.configuration.foo
+  #     RSpec.configuration.foo? # Returns true if foo returns anything but nil or false.
+  #
+  # @option opts
+  # @option opts
+  # @overload add_setting
+  # @overload add_setting
+  # @param opts [Hash] a customizable set of options
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#659
+  def add_setting(name, opts = T.unsafe(nil)); end
+
+  # Defines a `after` hook. See {Hooks#after} for full docs.
+  #
+  # This method differs from {Hooks#after} in only one way: it supports
+  # the `:suite` scope. Hooks with the `:suite` scope will be run once after
+  # the last example of the entire suite is executed. Conditions passed along
+  # with `:suite` are effectively ignored.
+  #
+  # @see #append_after
+  # @see #before
+  # @see #prepend_before
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2031
+  def after(scope = T.unsafe(nil), *meta, &block); end
+
+  # Creates a method that defines an example group with the provided
+  # metadata. Can be used to define example group/metadata shortcuts.
+  #
+  # @example
+  #   RSpec.configure do |config|
+  #   config.alias_example_group_to :describe_model, :type => :model
+  #   end
+  #
+  #   shared_context_for "model tests", :type => :model do
+  #   # define common model test helper methods, `let` declarations, etc
+  #   end
+  #
+  #   # This lets you do this:
+  #
+  #   RSpec.describe_model User do
+  #   end
+  #
+  #   # ... which is the equivalent of
+  #
+  #   RSpec.describe User, :type => :model do
+  #   end
+  # @note The defined aliased will also be added to the top level
+  #   (e.g. `main` and from within modules) if
+  #   `expose_dsl_globally` is set to true.
+  # @see #alias_example_to
+  # @see #expose_dsl_globally=
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1209
+  def alias_example_group_to(new_name, *args); end
+
+  # Creates a method that delegates to `example` including the submitted
+  # `args`. Used internally to add variants of `example` like `pending`:
+  #
+  # @example
+  #   RSpec.configure do |config|
+  #   config.alias_example_to :pending, :pending => true
+  #   end
+  #
+  #   # This lets you do this:
+  #
+  #   RSpec.describe Thing do
+  #   pending "does something" do
+  #   thing = Thing.new
+  #   end
+  #   end
+  #
+  #   # ... which is the equivalent of
+  #
+  #   RSpec.describe Thing do
+  #   it "does something", :pending => true do
+  #   thing = Thing.new
+  #   end
+  #   end
+  # @note The specific example alias below (`pending`) is already
+  #   defined for you.
+  # @note Use with caution. This extends the language used in your
+  #   specs, but does not add any additional documentation. We use this
+  #   in RSpec to define methods like `focus` and `xit`, but we also add
+  #   docs for those methods.
+  # @param name [String] example name alias
+  # @param args [Array<Symbol>, Hash] metadata for the generated example
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1177
+  def alias_example_to(name, *args); end
+
+  # Define an alias for it_should_behave_like that allows different
+  # language (like "it_has_behavior" or "it_behaves_like") to be
+  # employed when including shared examples.
+  #
+  # @example
+  #   RSpec.configure do |config|
+  #   config.alias_it_behaves_like_to(:it_has_behavior, 'has behavior:')
+  #   end
+  #
+  #   # allows the user to include a shared example group like:
+  #
+  #   RSpec.describe Entity do
+  #   it_has_behavior 'sortability' do
+  #   let(:sortable) { Entity.new }
+  #   end
+  #   end
+  #
+  #   # which is reported in the output as:
+  #   # Entity
+  #   #   has behavior: sortability
+  #   #     ...sortability examples here
+  # @note Use with caution. This extends the language used in your
+  #   specs, but does not add any additional documentation. We use this
+  #   in RSpec to define `it_should_behave_like` (for backward
+  #   compatibility), but we also add docs for that method.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1240
+  def alias_it_behaves_like_to(new_name, report_label = T.unsafe(nil)); end
+
+  # Define an alias for it_should_behave_like that allows different
+  # language (like "it_has_behavior" or "it_behaves_like") to be
+  # employed when including shared examples.
+  #
+  # @example
+  #   RSpec.configure do |config|
+  #   config.alias_it_behaves_like_to(:it_has_behavior, 'has behavior:')
+  #   end
+  #
+  #   # allows the user to include a shared example group like:
+  #
+  #   RSpec.describe Entity do
+  #   it_has_behavior 'sortability' do
+  #   let(:sortable) { Entity.new }
+  #   end
+  #   end
+  #
+  #   # which is reported in the output as:
+  #   # Entity
+  #   #   has behavior: sortability
+  #   #     ...sortability examples here
+  # @note Use with caution. This extends the language used in your
+  #   specs, but does not add any additional documentation. We use this
+  #   in RSpec to define `it_should_behave_like` (for backward
+  #   compatibility), but we also add docs for that method.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1240
+  def alias_it_should_behave_like_to(new_name, report_label = T.unsafe(nil)); end
+
+  # Adds `block` to the end of the list of `after` blocks in the same
+  # scope (`:example`, `:context`, or `:suite`), in contrast to {#after},
+  # which adds the hook to the start of the list.
+  #
+  # See {Hooks#after} for full `after` hook docs.
+  #
+  # This method differs from {Hooks#append_after} in only one way: it supports
+  # the `:suite` scope. Hooks with the `:suite` scope will be run once after
+  # the last example of the entire suite is executed. Conditions passed along
+  # with `:suite` are effectively ignored.
+  #
+  # @see #append_after
+  # @see #before
+  # @see #prepend_before
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2061
+  def append_after(scope = T.unsafe(nil), *meta, &block); end
+
+  # Defines a `before` hook. See {Hooks#before} for full docs.
+  #
+  # This method differs from {Hooks#before} in only one way: it supports
+  # the `:suite` scope. Hooks with the `:suite` scope will be run once before
+  # the first example of the entire suite is executed. Conditions passed along
+  # with `:suite` are effectively ignored.
+  #
+  # @see #prepend_before
+  # @see #after
+  # @see #append_after
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1976
+  def append_before(scope = T.unsafe(nil), *meta, &block); end
+
+  # @private
+  # @raise [SystemStackError]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1941
+  def apply_derived_metadata_to(metadata); end
+
+  # Registers `block` as an `around` hook.
+  #
+  # See {Hooks#around} for full `around` hook docs.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2079
+  def around(scope = T.unsafe(nil), *meta, &block); end
+
+  # Regexps used to exclude lines from backtraces.
+  #
+  # Excludes lines from ruby (and jruby) source, installed gems, anything
+  # in any "bin" directory, and any of the RSpec libs (outside gem
+  # installs) by default.
+  #
+  # You can modify the list via the getter, or replace it with the setter.
+  #
+  # To override this behaviour and display a full backtrace, use
+  # `--backtrace` on the command line, in a `.rspec` file, or in the
+  # `rspec_options` attribute of RSpec's rake task.
+  #
+  # @return [Array<Regexp>]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#697
+  def backtrace_exclusion_patterns; end
+
+  # Set regular expressions used to exclude lines in backtrace.
+  #
+  # @param patterns [Array<Regexp>] set backtrace_formatter exclusion_patterns
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#703
+  def backtrace_exclusion_patterns=(patterns); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#522
+  def backtrace_formatter; end
+
+  # Regexps used to include lines in backtraces.
+  #
+  # Defaults to [Regexp.new Dir.getwd].
+  #
+  # Lines that match an exclusion _and_ an inclusion pattern
+  # will be included.
+  #
+  # You can modify the list via the getter, or replace it with the setter.
+  #
+  # @return [Array<Regexp>]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#716
+  def backtrace_inclusion_patterns; end
+
+  # Set regular expressions used to include lines in backtrace.
+  #
+  # @attr patterns [Array<Regexp>] set backtrace_formatter inclusion_patterns
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#722
+  def backtrace_inclusion_patterns=(patterns); end
+
+  # Defines a `before` hook. See {Hooks#before} for full docs.
+  #
+  # This method differs from {Hooks#before} in only one way: it supports
+  # the `:suite` scope. Hooks with the `:suite` scope will be run once before
+  # the first example of the entire suite is executed. Conditions passed along
+  # with `:suite` are effectively ignored.
+  #
+  # @see #prepend_before
+  # @see #after
+  # @see #append_after
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1976
+  def before(scope = T.unsafe(nil), *meta, &block); end
+
+  # Determines which bisect runner implementation gets used to run subsets
+  # of the suite during a bisection. Your choices are:
+  #
+  #   - `:shell`: Performs a spec run by shelling out, booting RSpec and your
+  #     application environment each time. This runner is the most widely
+  #     compatible runner, but is not as fast. On platforms that do not
+  #     support forking, this is the default.
+  #   - `:fork`: Pre-boots RSpec and your application environment in a parent
+  #     process, and then forks a child process for each spec run. This runner
+  #     tends to be significantly faster than the `:shell` runner but cannot
+  #     be used in some situations. On platforms that support forking, this
+  #     is the default. If you use this runner, you should ensure that all
+  #     of your one-time setup logic goes in a `before(:suite)` hook instead
+  #     of getting run at the top-level of a file loaded by `--require`.
+  #
+  # @note This option will only be used by `--bisect` if you set it in a file
+  #   loaded via `--require`.
+  # @return [Symbol]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#499
+  def bisect_runner; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#500
+  def bisect_runner=(value); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2125
+  def bisect_runner_class; end
+
+  # Enables color output if the output is a TTY.  As of RSpec 3.6, this is
+  # the default behavior and this option is retained only for backwards
+  # compatibility.
+  #
+  # @deprecated No longer recommended because of complex behavior. Instead,
+  #   rely on the fact that TTYs will display color by default, or set
+  #   {#color_mode} to :on to display color on a non-TTY output.
+  # @return [Boolean]
+  # @see color_mode
+  # @see color_enabled?
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#922
+  def color; end
+
+  # Toggle output color.
+  #
+  # @deprecated No longer recommended because of complex behavior. Instead,
+  #   rely on the fact that TTYs will display color by default, or set
+  #   {:color_mode} to :on to display color on a non-TTY output.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#960
+  def color=(_arg0); end
+
+  # Check if color is enabled for a particular output.
+  #
+  # @param output [IO] an output stream to use, defaults to the current
+  #   `output_stream`
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#943
+  def color_enabled?(output = T.unsafe(nil)); end
+
+  # The mode for determining whether to display output in color. One of:
+  #
+  # - :automatic - the output will be in color if the output is a TTY (the
+  #   default)
+  # - :on - the output will be in color, whether or not the output is a TTY
+  # - :off - the output will not be in color
+  #
+  # @return [Boolean]
+  # @see color_enabled?
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#935
+  def color_mode; end
+
+  # Set the color mode.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#953
+  def color_mode=(_arg0); end
+
+  # Used internally to extend the singleton class of a single example's
+  # example group instance with modules using `include` and/or `extend`.
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1580
+  def configure_example(example, example_hooks); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1622
+  def configure_expectation_framework; end
+
+  # Used internally to extend a group with modules using `include`, `prepend` and/or
+  # `extend`.
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1568
+  def configure_group(group); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1616
+  def configure_mock_framework; end
+
+  # The default output color. Defaults to `:white` but can be set to one of
+  # the following: `[:black, :white, :red, :green, :yellow, :blue,
+  # :magenta, :cyan]`
+  #
+  # @return [Symbol]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def default_color; end
+
+  # The default output color. Defaults to `:white` but can be set to one of
+  # the following: `[:black, :white, :red, :green, :yellow, :blue,
+  # :magenta, :cyan]`
+  #
+  # @return [Symbol]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def default_color=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def default_color?; end
+
+  # The formatter that will be used if no formatter has been set.
+  # Defaults to 'progress'.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1003
+  def default_formatter; end
+
+  # Sets a fallback formatter to use if none other has been set.
+  #
+  # @example
+  #
+  #   RSpec.configure do |rspec|
+  #   rspec.default_formatter = 'doc'
+  #   end
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1014
+  def default_formatter=(value); end
+
+  # Path to use if no path is provided to the `rspec` command (default:
+  # `"spec"`). Allows you to just type `rspec` instead of `rspec spec` to
+  # run all the examples in the `spec` directory.
+  #
+  # @note Other scripts invoking `rspec` indirectly will ignore this
+  #   setting.
+  # @return [String]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def default_path; end
+
+  # Path to use if no path is provided to the `rspec` command (default:
+  # `"spec"`). Allows you to just type `rspec` instead of `rspec spec` to
+  # run all the examples in the `spec` directory.
+  #
+  # @note Other scripts invoking `rspec` indirectly will ignore this
+  #   setting.
+  # @return [String]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#121
+  def default_path=(path); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def default_path?; end
+
+  # Defines a callback that can assign derived metadata values.
+  #
+  # @example
+  #   RSpec.configure do |config|
+  #   # Tag all groups and examples in the spec/unit directory with
+  #   # :type => :unit
+  #   config.define_derived_metadata(:file_path => %r{/spec/unit/}) do |metadata|
+  #   metadata[:type] = :unit
+  #   end
+  #   end
+  # @param filters [Array<Symbol>, Hash] metadata filters that determine
+  #   which example or group metadata hashes the callback will be triggered
+  #   for. If none are given, the callback will be run against the metadata
+  #   hashes of all groups and examples.
+  # @yieldparam metadata [Hash] original metadata hash from an example or
+  #   group. Mutate this in your block as needed.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1900
+  def define_derived_metadata(*filters, &block); end
+
+  # Determines where deprecation warnings are printed.
+  # Defaults to `$stderr`.
+  #
+  # @return [IO, String] IO or filename to write to
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def deprecation_stream; end
+
+  # Determines where deprecation warnings are printed.
+  #
+  # @param value [IO, String] IO to write to or filename to write to
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#168
+  def deprecation_stream=(value); end
+
+  # Color used to print details.  Defaults to `:cyan` but can be set to one
+  # of the following: `[:black, :white, :red, :green, :yellow, :blue,
+  # :magenta, :cyan]`
+  #
+  # @return [Symbol]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def detail_color; end
+
+  # Color used to print details.  Defaults to `:cyan` but can be set to one
+  # of the following: `[:black, :white, :red, :green, :yellow, :blue,
+  # :magenta, :cyan]`
+  #
+  # @return [Symbol]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def detail_color=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def detail_color?; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1881
+  def disable_monkey_patching; end
+
+  # Enables zero monkey patching mode for RSpec. It removes monkey
+  # patching of the top-level DSL methods (`describe`,
+  # `shared_examples_for`, etc) onto `main` and `Module`, instead
+  # requiring you to prefix these methods with `RSpec.`. It enables
+  # expect-only syntax for rspec-mocks and rspec-expectations. It
+  # simply disables monkey patching on whatever pieces of RSpec
+  # the user is using.
+  #
+  # @example
+  #
+  #   # It disables all monkey patching.
+  #   RSpec.configure do |config|
+  #   config.disable_monkey_patching!
+  #   end
+  #
+  #   # Is an equivalent to
+  #   RSpec.configure do |config|
+  #   config.expose_dsl_globally = false
+  #
+  #   config.mock_with :rspec do |mocks|
+  #   mocks.syntax = :expect
+  #   mocks.patch_marshal_to_support_partial_doubles = false
+  #   end
+  #
+  #   config.expect_with :rspec do |expectations|
+  #   expectations.syntax = :expect
+  #   end
+  #   end
+  # @note It configures rspec-mocks and rspec-expectations only
+  #   if the user is using those (either explicitly or implicitly
+  #   by not setting `mock_with` or `expect_with` to anything else).
+  # @note If the user uses this options with `mock_with :mocha`
+  #   (or similar) they will still have monkey patching active
+  #   in their test environment from mocha.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1873
+  def disable_monkey_patching!; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1881
+  def disable_monkey_patching=(_arg0); end
+
+  # Run examples over DRb (default: `false`). RSpec doesn't supply the DRb
+  # server, but you can use tools like spork.
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def drb; end
+
+  # Run examples over DRb (default: `false`). RSpec doesn't supply the DRb
+  # server, but you can use tools like spork.
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def drb=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def drb?; end
+
+  # The drb_port (default: nil).
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def drb_port; end
+
+  # The drb_port (default: nil).
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def drb_port=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def drb_port?; end
+
+  # Prints the formatter output of your suite without running any
+  # examples or hooks.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def dry_run; end
+
+  # Prints the formatter output of your suite without running any
+  # examples or hooks.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def dry_run=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def dry_run?; end
+
+  # The exit code to return if there are any errors outside examples (default: failure_exit_code)
+  #
+  # @return [Integer]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def error_exit_code; end
+
+  # The exit code to return if there are any errors outside examples (default: failure_exit_code)
+  #
+  # @return [Integer]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def error_exit_code=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def error_exit_code?; end
+
+  # Default: `$stderr`.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def error_stream; end
+
+  # Default: `$stderr`.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def error_stream=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def error_stream?; end
+
+  # The file path to use for persisting example statuses. Necessary for the
+  # `--only-failures` and `--next-failure` CLI options.
+  #
+  # @overload example_status_persistence_file_path
+  # @overload example_status_persistence_file_path=
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def example_status_persistence_file_path; end
+
+  # Sets the file path to use for persisting example statuses. Necessary for the
+  # `--only-failures` and `--next-failure` CLI options.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#192
+  def example_status_persistence_file_path=(value); end
+
+  # Exclude files matching this pattern.
+  #
+  # @return [String]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def exclude_pattern; end
+
+  # Set pattern to match files to exclude.
+  #
+  # @attr value [String] the filename pattern to exclude spec files by
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#304
+  def exclude_pattern=(value); end
+
+  # Returns the `exclusion_filter`. If none has been set, returns an empty
+  # hash.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1369
+  def exclusion_filter; end
+
+  # Clears and reassigns the `exclusion_filter`. Set to `nil` if you don't
+  # want any exclusion filter at all.
+  #
+  # ### Warning
+  #
+  # This overrides any exclusion filters/tags set on the command line or in
+  # configuration files.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1362
+  def exclusion_filter=(filter); end
+
+  # Sets the expectation framework module(s) to be included in each example
+  # group.
+  #
+  # `frameworks` can be `:rspec`, `:test_unit`, `:minitest`, a custom
+  # module, or any combination thereof:
+  #
+  #     config.expect_with :rspec
+  #     config.expect_with :test_unit
+  #     config.expect_with :minitest
+  #     config.expect_with :rspec, :minitest
+  #     config.expect_with OtherExpectationFramework
+  #
+  # RSpec will translate `:rspec`, `:minitest`, and `:test_unit` into the
+  # appropriate modules.
+  #
+  # ## Configuration
+  #
+  # If the module responds to `configuration`, `expect_with` will
+  # yield the `configuration` object if given a block:
+  #
+  #     config.expect_with OtherExpectationFramework do |custom_config|
+  #       custom_config.custom_setting = true
+  #     end
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#858
+  def expect_with(*frameworks); end
+
+  # Delegates to expect_with(framework).
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#831
+  def expectation_framework=(framework); end
+
+  # Returns the configured expectation framework adapter module(s)
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#819
+  def expectation_frameworks; end
+
+  # Exposes the current running example via the named
+  # helper method. RSpec 2.x exposed this via `example`,
+  # but in RSpec 3.0, the example is instead exposed via
+  # an arg yielded to `it`, `before`, `let`, etc. However,
+  # some extension gems (such as Capybara) depend on the
+  # RSpec 2.x's `example` method, so this config option
+  # can be used to maintain compatibility.
+  #
+  # @example
+  #
+  #   RSpec.configure do |rspec|
+  #   rspec.expose_current_running_example_as :example
+  #   end
+  #
+  #   RSpec.describe MyClass do
+  #   before do
+  #   # `example` can be used here because of the above config.
+  #   do_something if example.metadata[:type] == "foo"
+  #   end
+  #   end
+  # @param method_name [Symbol] the name of the helper method
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1811
+  def expose_current_running_example_as(method_name); end
+
+  # Use this to expose the core RSpec DSL via `Module` and the `main`
+  # object. It will be set automatically but you can override it to
+  # remove the DSL.
+  # Default: true
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#151
+  def expose_dsl_globally=(value); end
+
+  # Indicates if the DSL has been exposed off of modules and `main`.
+  # Default: true
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#143
+  def expose_dsl_globally?; end
+
+  # Tells RSpec to extend example groups with `mod`. Methods defined in
+  # `mod` are exposed to example groups (not examples). Use `filters` to
+  # constrain the groups to extend.
+  #
+  # Similar to `include`, but behavior is added to example groups, which
+  # are classes, rather than the examples, which are instances of those
+  # classes.
+  #
+  # @example
+  #
+  #   module UiHelpers
+  #   def run_in_browser
+  #   # ...
+  #   end
+  #   end
+  #
+  #   module PermissionHelpers
+  #   def define_permissions
+  #   # ...
+  #   end
+  #   end
+  #
+  #   RSpec.configure do |config|
+  #   config.extend(UiHelpers, :type => :request)
+  #   config.extend(PermissionHelpers, :with_permissions, :type => :request)
+  #   end
+  #
+  #   describe "edit profile", :with_permissions, :type => :request do
+  #   run_in_browser
+  #   define_permissions
+  #
+  #   it "does stuff in the client" do
+  #   # ...
+  #   end
+  #   end
+  # @see #include
+  # @see #prepend
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1518
+  def extend(mod, *filters); end
+
+  # If specified, indicates the number of failures required before cleaning
+  # up and exit (default: `nil`). Can also be `true` to fail and exit on first
+  # failure
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def fail_fast; end
+
+  # @see fail_fast
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#214
+  def fail_fast=(value); end
+
+  # Whether or not to fail when there are no RSpec examples (default: false).
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def fail_if_no_examples; end
+
+  # Whether or not to fail when there are no RSpec examples (default: false).
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def fail_if_no_examples=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def fail_if_no_examples?; end
+
+  # Color to use to indicate failure.  Defaults to `:red` but can be set to
+  # one of the following: `[:black, :white, :red, :green, :yellow, :blue,
+  # :magenta, :cyan]`
+  #
+  # @return [Symbol]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def failure_color; end
+
+  # Color to use to indicate failure.  Defaults to `:red` but can be set to
+  # one of the following: `[:black, :white, :red, :green, :yellow, :blue,
+  # :magenta, :cyan]`
+  #
+  # @return [Symbol]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def failure_color=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def failure_color?; end
+
+  # The exit code to return if there are any failures (default: 1).
+  #
+  # @return [Integer]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def failure_exit_code; end
+
+  # The exit code to return if there are any failures (default: 1).
+  #
+  # @return [Integer]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def failure_exit_code=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def failure_exit_code?; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1083
+  def files_or_directories_to_run=(*files); end
+
+  # The spec files RSpec will run.
+  #
+  # @return [Array] specified files about to run
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1096
+  def files_to_run; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#516
+  def files_to_run=(_arg0); end
+
+  # Returns the `inclusion_filter`. If none has been set, returns an empty
+  # hash.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1313
+  def filter; end
+
+  # Clears and reassigns the `inclusion_filter`. Set to `nil` if you don't
+  # want any inclusion filter at all.
+  #
+  # ### Warning
+  #
+  # This overrides any inclusion filters/tags set on the command line or in
+  # configuration files.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1304
+  def filter=(filter); end
+
+  # Adds {#backtrace_exclusion_patterns} that will filter lines from
+  # the named gems from backtraces.
+  #
+  # @example
+  #   RSpec.configure do |config|
+  #   config.filter_gems_from_backtrace "rack", "rake"
+  #   end
+  # @note The patterns this adds will match the named gems in their common
+  #   locations (e.g. system gems, vendored with bundler, installed as a
+  #   :git dependency with bundler, etc) but is not guaranteed to work for
+  #   all possible gem locations. For example, if you have the gem source
+  #   in a directory with a completely unrelated name, and use bundler's
+  #   :path option, this will not filter it.
+  # @param gem_names [Array<String>] Names of the gems to filter
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#742
+  def filter_gems_from_backtrace(*gem_names); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#518
+  def filter_manager; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#518
+  def filter_manager=(_arg0); end
+
+  # Adds key/value pairs to the `inclusion_filter`. If `args`
+  # includes any symbols that are not part of the hash, each symbol
+  # is treated as a key in the hash with the value `true`.
+  #
+  # ### Note
+  #
+  # Filters set using this method can be overridden from the command line
+  # or config files (e.g. `.rspec`).
+  #
+  # @example
+  #   # Given this declaration.
+  #   describe "something", :foo => 'bar' do
+  #   # ...
+  #   end
+  #
+  #   # Any of the following will include that group.
+  #   config.filter_run_including :foo => 'bar'
+  #   config.filter_run_including :foo => /^ba/
+  #   config.filter_run_including :foo => lambda {|v| v == 'bar'}
+  #   config.filter_run_including :foo => lambda {|v,m| m[:foo] == 'bar'}
+  #
+  #   # Given a proc with an arity of 1, the lambda is passed the value
+  #   # related to the key, e.g.
+  #   config.filter_run_including :foo => lambda {|v| v == 'bar'}
+  #
+  #   # Given a proc with an arity of 2, the lambda is passed the value
+  #   # related to the key, and the metadata itself e.g.
+  #   config.filter_run_including :foo => lambda {|v,m| m[:foo] == 'bar'}
+  #
+  #   filter_run_including :foo # same as filter_run_including :foo => true
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1275
+  def filter_run(*args); end
+
+  # Adds key/value pairs to the `exclusion_filter`. If `args`
+  # includes any symbols that are not part of the hash, each symbol
+  # is treated as a key in the hash with the value `true`.
+  #
+  # ### Note
+  #
+  # Filters set using this method can be overridden from the command line
+  # or config files (e.g. `.rspec`).
+  #
+  # @example
+  #   # Given this declaration.
+  #   describe "something", :foo => 'bar' do
+  #   # ...
+  #   end
+  #
+  #   # Any of the following will exclude that group.
+  #   config.filter_run_excluding :foo => 'bar'
+  #   config.filter_run_excluding :foo => /^ba/
+  #   config.filter_run_excluding :foo => lambda {|v| v == 'bar'}
+  #   config.filter_run_excluding :foo => lambda {|v,m| m[:foo] == 'bar'}
+  #
+  #   # Given a proc with an arity of 1, the lambda is passed the value
+  #   # related to the key, e.g.
+  #   config.filter_run_excluding :foo => lambda {|v| v == 'bar'}
+  #
+  #   # Given a proc with an arity of 2, the lambda is passed the value
+  #   # related to the key, and the metadata itself e.g.
+  #   config.filter_run_excluding :foo => lambda {|v,m| m[:foo] == 'bar'}
+  #
+  #   filter_run_excluding :foo # same as filter_run_excluding :foo => true
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1349
+  def filter_run_excluding(*args); end
+
+  # Adds key/value pairs to the `inclusion_filter`. If `args`
+  # includes any symbols that are not part of the hash, each symbol
+  # is treated as a key in the hash with the value `true`.
+  #
+  # ### Note
+  #
+  # Filters set using this method can be overridden from the command line
+  # or config files (e.g. `.rspec`).
+  #
+  # @example
+  #   # Given this declaration.
+  #   describe "something", :foo => 'bar' do
+  #   # ...
+  #   end
+  #
+  #   # Any of the following will include that group.
+  #   config.filter_run_including :foo => 'bar'
+  #   config.filter_run_including :foo => /^ba/
+  #   config.filter_run_including :foo => lambda {|v| v == 'bar'}
+  #   config.filter_run_including :foo => lambda {|v,m| m[:foo] == 'bar'}
+  #
+  #   # Given a proc with an arity of 1, the lambda is passed the value
+  #   # related to the key, e.g.
+  #   config.filter_run_including :foo => lambda {|v| v == 'bar'}
+  #
+  #   # Given a proc with an arity of 2, the lambda is passed the value
+  #   # related to the key, and the metadata itself e.g.
+  #   config.filter_run_including :foo => lambda {|v,m| m[:foo] == 'bar'}
+  #
+  #   filter_run_including :foo # same as filter_run_including :foo => true
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1275
+  def filter_run_including(*args); end
+
+  # Applies the provided filter only if any of examples match, in constrast
+  # to {#filter_run}, which always applies even if no examples match, in
+  # which case no examples will be run. This allows you to leave configured
+  # filters in place that are intended only for temporary use. The most common
+  # example is focus filtering: `config.filter_run_when_matching :focus`.
+  # With that configured, you can temporarily focus an example or group
+  # by tagging it with `:focus` metadata, or prefixing it with an `f`
+  # (as in `fdescribe`, `fcontext` and `fit`) since those are aliases for
+  # `describe`/`context`/`it` with `:focus` metadata.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1291
+  def filter_run_when_matching(*args); end
+
+  # Color used when a pending example is fixed. Defaults to `:blue` but can
+  # be set to one of the following: `[:black, :white, :red, :green,
+  # :yellow, :blue, :magenta, :cyan]`
+  #
+  # @return [Symbol]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def fixed_color; end
+
+  # Color used when a pending example is fixed. Defaults to `:blue` but can
+  # be set to one of the following: `[:black, :white, :red, :green,
+  # :yellow, :blue, :magenta, :cyan]`
+  #
+  # @return [Symbol]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def fixed_color=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def fixed_color?; end
+
+  # Used to set higher priority option values from the command line.
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#592
+  def force(hash); end
+
+  # Formats the docstring output using the block provided.
+  #
+  # @example
+  #   # This will strip the descriptions of both examples and example
+  #   # groups.
+  #   RSpec.configure do |config|
+  #   config.format_docstrings { |s| s.strip }
+  #   end
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1661
+  def format_docstrings(&block); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1666
+  def format_docstrings_block; end
+
+  # Adds a formatter to the set RSpec will use for this run.
+  #
+  # @overload add_formatter
+  # @overload add_formatter
+  # @param formatter [Class, String, Object] formatter to use. Can be any of the
+  #   string values supported from the CLI (`p`/`progress`,
+  #   `d`/`doc`/`documentation`, `h`/`html`, or `j`/`json`), any
+  #   class that implements the formatter protocol and has registered
+  #   itself with RSpec as a formatter, or a formatter instance.
+  # @param output [String, IO] where the formatter will write its output.
+  #   Can be an IO object or a string path to a file. If not provided,
+  #   the configured `output_stream` (`$stdout`, by default) will be used.
+  # @see RSpec::Core::Formatters::Protocol
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#996
+  def formatter=(formatter, output = T.unsafe(nil)); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1029
+  def formatter_loader; end
+
+  # Returns a duplicate of the formatters currently loaded in
+  # the `FormatterLoader` for introspection.
+  #
+  # Note as this is a duplicate, any mutations will be disregarded.
+  #
+  # @return [Array] the formatters currently loaded
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1024
+  def formatters; end
+
+  # Toggle full backtrace.
+  #
+  # @attr true_or_false [Boolean] toggle full backtrace display
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#908
+  def full_backtrace=(true_or_false); end
+
+  # Check if full backtrace is enabled.
+  #
+  # @return [Boolean] is full backtrace enabled
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#902
+  def full_backtrace?; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def full_cause_backtrace; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def full_cause_backtrace=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def full_cause_backtrace?; end
+
+  # @return [Array] full description filter
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#977
+  def full_description; end
+
+  # Run examples matching on `description` in all files to run.
+  #
+  # @param description [String, Regexp] the pattern to filter on
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#972
+  def full_description=(description); end
+
+  # Holds the various registered hooks. Here we use a FilterableItemRepository
+  # implementation that is specifically optimized for the read/write patterns
+  # of the config object.
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2109
+  def hooks; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1607
+  def in_project_source_dir_regex; end
+
+  # Tells RSpec to include `mod` in example groups. Methods defined in
+  # `mod` are exposed to examples (not example groups). Use `filters` to
+  # constrain the groups or examples in which to include the module.
+  #
+  # @example
+  #
+  #   module AuthenticationHelpers
+  #   def login_as(user)
+  #   # ...
+  #   end
+  #   end
+  #
+  #   module PreferencesHelpers
+  #   def preferences(user, preferences = {})
+  #   # ...
+  #   end
+  #   end
+  #
+  #   module UserHelpers
+  #   def users(username)
+  #   # ...
+  #   end
+  #   end
+  #
+  #   RSpec.configure do |config|
+  #   config.include(UserHelpers) # included in all groups
+  #
+  #   # included in examples with `:preferences` metadata
+  #   config.include(PreferenceHelpers, :preferences)
+  #
+  #   # included in examples with `:type => :request` metadata
+  #   config.include(AuthenticationHelpers, :type => :request)
+  #
+  #   # included in examples where the `:type` metadata matches a proc condition
+  #   config.include(AuthenticationHelpers, :type => proc { |type, _metadata| [:request, :controller].include?(type) })
+  #   end
+  #
+  #   describe "edit profile", :preferences, :type => :request do
+  #   it "can be viewed by owning user" do
+  #   login_as preferences(users(:jdoe), :lang => 'es')
+  #   get "/profiles/jdoe"
+  #   assert_select ".username", :text => 'jdoe'
+  #   end
+  #   end
+  # @note Filtered module inclusions can also be applied to
+  #   individual examples that have matching metadata. Just like
+  #   Ruby's object model is that every object has a singleton class
+  #   which has only a single instance, RSpec's model is that every
+  #   example has a singleton example group containing just the one
+  #   example.
+  # @see #include_context
+  # @see #extend
+  # @see #prepend
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1428
+  def include(mod, *filters); end
+
+  # Tells RSpec to include the named shared example group in example groups.
+  # Use `filters` to constrain the groups or examples in which to include
+  # the example group.
+  #
+  # @example
+  #
+  #   RSpec.shared_context "example admin user" do
+  #   let(:admin_user) { create_user(:admin) }
+  #   end
+  #
+  #   RSpec.shared_context "example guest user" do
+  #   let(:guest_user) { create_user(:guest) }
+  #   end
+  #
+  #   RSpec.configure do |config|
+  #   config.include_context "example guest user", :type => :request
+  #   config.include_context "example admin user", :admin, :type => :request
+  #   end
+  #
+  #   RSpec.describe "The admin page", :type => :request do
+  #   it "can be viewed by admins", :admin do
+  #   login_with admin_user
+  #   get "/admin"
+  #   expect(response).to be_ok
+  #   end
+  #
+  #   it "cannot be viewed by guests" do
+  #   login_with guest_user
+  #   get "/admin"
+  #   expect(response).to be_forbidden
+  #   end
+  #   end
+  # @note Filtered context inclusions can also be applied to
+  #   individual examples that have matching metadata. Just like
+  #   Ruby's object model is that every object has a singleton class
+  #   which has only a single instance, RSpec's model is that every
+  #   example has a singleton example group containing just the one
+  #   example.
+  # @see #include
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1475
+  def include_context(shared_group_name, *filters); end
+
+  # Returns the `inclusion_filter`. If none has been set, returns an empty
+  # hash.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1313
+  def inclusion_filter; end
+
+  # Clears and reassigns the `inclusion_filter`. Set to `nil` if you don't
+  # want any inclusion filter at all.
+  #
+  # ### Warning
+  #
+  # This overrides any inclusion filters/tags set on the command line or in
+  # configuration files.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1304
+  def inclusion_filter=(filter); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1101
+  def last_run_statuses; end
+
+  # Returns dirs that have been prepended to the load path by the `-I`
+  # command line option.
+  #
+  # @return [Array<String>]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def libs; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#963
+  def libs=(libs); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1630
+  def load_spec_files; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#522
+  def loaded_spec_files; end
+
+  # Maximum count of failed source lines to display in the failure reports
+  # (defaults to `10`).
+  # return [Integer]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def max_displayed_failure_line_count; end
+
+  # Maximum count of failed source lines to display in the failure reports
+  # (defaults to `10`).
+  # return [Integer]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def max_displayed_failure_line_count=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def max_displayed_failure_line_count?; end
+
+  # Returns the configured mock framework adapter module.
+  #
+  # @return [Symbol]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#669
+  def mock_framework; end
+
+  # Delegates to mock_framework=(framework).
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#681
+  def mock_framework=(framework); end
+
+  # Sets the mock framework adapter module.
+  #
+  # `framework` can be a Symbol or a Module.
+  #
+  # Given any of `:rspec`, `:mocha`, `:flexmock`, or `:rr`, configures the
+  # named framework.
+  #
+  # Given `:nothing`, configures no framework. Use this if you don't use
+  # any mocking framework to save a little bit of overhead.
+  #
+  # Given a Module, includes that module in every example group. The module
+  # should adhere to RSpec's mock framework adapter API:
+  #
+  #     setup_mocks_for_rspec
+  #       - called before each example
+  #
+  #     verify_mocks_for_rspec
+  #       - called after each example if the example hasn't yet failed.
+  #         Framework should raise an exception when expectations fail
+  #
+  #     teardown_mocks_for_rspec
+  #       - called after verify_mocks_for_rspec (even if there are errors)
+  #
+  # If the module responds to `configuration` and `mock_with` receives a
+  # block, it will yield the configuration object to the block e.g.
+  #
+  #     config.mock_with OtherMockFrameworkAdapter do |mod_config|
+  #       mod_config.custom_setting = true
+  #     end
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#786
+  def mock_with(framework); end
+
+  # Invokes block before defining an example group
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2114
+  def on_example_group_definition(&block); end
+
+  # Returns an array of blocks to call before defining an example group
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2120
+  def on_example_group_definition_callbacks; end
+
+  # Indicates if the `--only-failures` (or `--next-failure`) flag is being used.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def only_failures; end
+
+  # Indicates if the `--only-failures` (or `--next-failure`) flag is being used.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def only_failures?; end
+
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#203
+  def only_failures_but_not_configured?; end
+
+  # Sets the default global ordering strategy. By default this can be one
+  # of `:defined`, `:random`, but is customizable through the
+  # `register_ordering` API. If order is set to `'rand:<seed>'`,
+  # the seed will also be set.
+  #
+  # @see #register_ordering
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1673
+  def order=(*args, &block); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#522
+  def ordering_manager; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#1673
+  def ordering_registry(*args, &block); end
+
+  # Determines where RSpec will send its output.
+  # Default: `$stdout`.
+  #
+  # @return [IO, String]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def output_stream; end
+
+  # Set the output stream for reporter.
+  #
+  # @attr value [IO, String] IO to write to or filename to write to, defaults to $stdout
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#274
+  def output_stream=(value); end
+
+  # Load files matching this pattern (default: `'**{,/*/**}/*_spec.rb'`).
+  #
+  # @return [String]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def pattern; end
+
+  # Set pattern to match files to load.
+  #
+  # @attr value [String] the filename pattern to filter spec files by
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#293
+  def pattern=(value); end
+
+  # Color to use to print pending examples.  Defaults to `:yellow` but can
+  # be set to one of the following: `[:black, :white, :red, :green,
+  # :yellow, :blue, :magenta, :cyan]`
+  #
+  # @return [Symbol]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def pending_color; end
+
+  # Color to use to print pending examples.  Defaults to `:yellow` but can
+  # be set to one of the following: `[:black, :white, :red, :green,
+  # :yellow, :blue, :magenta, :cyan]`
+  #
+  # @return [Symbol]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def pending_color=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def pending_color?; end
+
+  # Format the output for pending examples. Can be set to:
+  #  - :full (default) - pending examples appear similarly to failures
+  #  - :no_backtrace - same as above, but with no backtrace
+  #  - :skip - do not show the section at all
+  # return [Symbol]
+  #
+  # @raise [ArgumentError]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def pending_failure_output; end
+
+  # Format the output for pending examples. Can be set to:
+  #  - :full (default) - pending examples appear similarly to failures
+  #  - :no_backtrace - same as above, but with no backtrace
+  #  - :skip - do not show the section at all
+  # return [Symbol]
+  #
+  # @raise [ArgumentError]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#473
+  def pending_failure_output=(mode); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def pending_failure_output?; end
+
+  # Tells RSpec to prepend example groups with `mod`. Methods defined in
+  # `mod` are exposed to examples (not example groups). Use `filters` to
+  # constrain the groups in which to prepend the module.
+  #
+  # Similar to `include`, but module is included before the example group's class
+  # in the ancestor chain.
+  #
+  # @example
+  #
+  #   module OverrideMod
+  #   def override_me
+  #   "overridden"
+  #   end
+  #   end
+  #
+  #   RSpec.configure do |config|
+  #   config.prepend(OverrideMod, :method => :prepend)
+  #   end
+  #
+  #   describe "overriding example's class", :method => :prepend do
+  #   it "finds the user" do
+  #   self.class.class_eval do
+  #   def override_me
+  #   end
+  #   end
+  #   override_me # => "overridden"
+  #   # ...
+  #   end
+  #   end
+  # @see #include
+  # @see #extend
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1557
+  def prepend(mod, *filters); end
+
+  # Defines a `after` hook. See {Hooks#after} for full docs.
+  #
+  # This method differs from {Hooks#after} in only one way: it supports
+  # the `:suite` scope. Hooks with the `:suite` scope will be run once after
+  # the last example of the entire suite is executed. Conditions passed along
+  # with `:suite` are effectively ignored.
+  #
+  # @see #append_after
+  # @see #before
+  # @see #prepend_before
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2031
+  def prepend_after(scope = T.unsafe(nil), *meta, &block); end
+
+  # Adds `block` to the start of the list of `before` blocks in the same
+  # scope (`:example`, `:context`, or `:suite`), in contrast to {#before},
+  # which adds the hook to the end of the list.
+  #
+  # See {Hooks#before} for full `before` hook docs.
+  #
+  # This method differs from {Hooks#prepend_before} in only one way: it supports
+  # the `:suite` scope. Hooks with the `:suite` scope will be run once before
+  # the first example of the entire suite is executed. Conditions passed along
+  # with `:suite` are effectively ignored.
+  #
+  # @see #before
+  # @see #after
+  # @see #append_after
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2006
+  def prepend_before(scope = T.unsafe(nil), *meta, &block); end
+
+  # Defaults `profile_examples` to 10 examples when `@profile_examples` is
+  # `true`.
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1073
+  def profile_examples; end
+
+  # Report the times for the slowest examples (default: `false`).
+  # Use this to specify the number of examples to include in the profile.
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#322
+  def profile_examples=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def profile_examples?; end
+
+  # Specifies which directories contain the source code for your project.
+  # When a failure occurs, RSpec looks through the backtrace to find a
+  # a line of source to print. It first looks for a line coming from
+  # one of the project source directories so that, for example, it prints
+  # the expectation or assertion call rather than the source code from
+  # the expectation or assertion framework.
+  #
+  # @return [Array<String>]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def project_source_dirs; end
+
+  # Specifies which directories contain the source code for your project.
+  # When a failure occurs, RSpec looks through the backtrace to find a
+  # a line of source to print. It first looks for a line coming from
+  # one of the project source directories so that, for example, it prints
+  # the expectation or assertion call rather than the source code from
+  # the expectation or assertion framework.
+  #
+  # @return [Array<String>]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def project_source_dirs=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def project_source_dirs?; end
+
+  # Turns deprecation warnings into errors, in order to surface
+  # the full backtrace of the call site. This can be useful when
+  # you need more context to address a deprecation than the
+  # single-line call site normally provided.
+  #
+  # @example
+  #
+  #   RSpec.configure do |rspec|
+  #   rspec.raise_errors_for_deprecations!
+  #   end
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1833
+  def raise_errors_for_deprecations!; end
+
+  # Turns RSpec warnings into errors. This can be useful when
+  # you want RSpec to run in a 'strict' no warning situation.
+  # (Note this does not capture or raise on Ruby warnings).
+  #
+  # @example
+  #
+  #   RSpec.configure do |rspec|
+  #   rspec.raise_on_warning = true
+  #   end
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1781
+  def raise_on_warning=(value); end
+
+  # Registers a named ordering strategy that can later be
+  # used to order an example group's subgroups by adding
+  # `:order => <name>` metadata to the example group.
+  #
+  # @example
+  #   RSpec.configure do |rspec|
+  #   rspec.register_ordering :reverse do |list|
+  #   list.reverse
+  #   end
+  #   end
+  #
+  #   RSpec.describe 'MyClass', :order => :reverse do
+  #   # ...
+  #   end
+  # @example
+  #   RSpec.configure do |rspec|
+  #   rspec.register_ordering :global do |examples|
+  #   acceptance, other = examples.partition do |example|
+  #   example.metadata[:type] == :acceptance
+  #   end
+  #   other + acceptance
+  #   end
+  #   end
+  #
+  #   RSpec.describe 'MyClass', :type => :acceptance do
+  #   # will run last
+  #   end
+  #
+  #   RSpec.describe 'MyClass' do
+  #   # will run first
+  #   end
+  # @note Pass the symbol `:global` to set the ordering strategy that
+  #   will be used to order the top-level example groups and any example
+  #   groups that do not have declared `:order` metadata.
+  # @param name [Symbol] The name of the ordering.
+  # @yield Block that will order the given examples or example groups
+  # @yieldparam list [Array<RSpec::Core::Example>, Array<RSpec::Core::ExampleGroup>] The examples or groups to order
+  # @yieldreturn [Array<RSpec::Core::Example>, Array<RSpec::Core::ExampleGroup>] The re-ordered examples or groups
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1673
+  def register_ordering(*args, &block); end
+
+  # @return [RSpec::Core::Reporter] the currently configured reporter
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1056
+  def reporter; end
+
+  # Indicates files configured to be required.
+  #
+  # @return [Array<String>]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def requires; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1597
+  def requires=(paths); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#601
+  def reset; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#614
+  def reset_filters; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#607
+  def reset_reporter; end
+
+  # Run all examples if none match the configured filters
+  # (default: `false`).
+  #
+  # @deprecated Use {#filter_run_when_matching} instead for the specific
+  #   filters that you want to be ignored if none match.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def run_all_when_everything_filtered; end
+
+  # Run all examples if none match the configured filters
+  # (default: `false`).
+  #
+  # @deprecated Use {#filter_run_when_matching} instead for the specific
+  #   filters that you want to be ignored if none match.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def run_all_when_everything_filtered=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def run_all_when_everything_filtered?; end
+
+  # Seed for random ordering (default: generated randomly each run).
+  #
+  # When you run specs with `--order random`, RSpec generates a random seed
+  # for the randomization and prints it to the `output_stream` (assuming
+  # you're using RSpec's built-in formatters). If you discover an ordering
+  # dependency (i.e. examples fail intermittently depending on order), set
+  # this (on Configuration or on the command line with `--seed`) to run
+  # using the same seed while you debug the issue.
+  #
+  # We recommend, actually, that you use the command line approach so you
+  # don't accidentally leave the seed encoded.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1673
+  def seed(*args, &block); end
+
+  # Sets the seed value and sets the default global ordering to random.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1673
+  def seed=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#1673
+  def seed_used?(*args, &block); end
+
+  # Configures how RSpec treats metadata passed as part of a shared example
+  # group definition. For example, given this shared example group definition:
+  #
+  #     RSpec.shared_context "uses DB", :db => true do
+  #       around(:example) do |ex|
+  #         MyORM.transaction(:rollback => true, &ex)
+  #       end
+  #     end
+  #
+  # ...there are two ways RSpec can treat the `:db => true` metadata, each
+  # of which has a corresponding config option:
+  #
+  # 1. `:trigger_inclusion`: this shared context will be implicitly included
+  #    in any groups (or examples) that have `:db => true` metadata.
+  # 2. `:apply_to_host_groups`: the metadata will be inherited by the metadata
+  #    hash of all host groups and examples.
+  #
+  # `:trigger_inclusion` is the legacy behavior from before RSpec 3.5 but should
+  # be considered deprecated. Instead, you can explicitly include a group with
+  # `include_context`:
+  #
+  #     RSpec.describe "My model" do
+  #       include_context "uses DB"
+  #     end
+  #
+  # ...or you can configure RSpec to include the context based on matching metadata
+  # using an API that mirrors configured module inclusion:
+  #
+  #     RSpec.configure do |rspec|
+  #       rspec.include_context "uses DB", :db => true
+  #     end
+  #
+  # `:apply_to_host_groups` is a new feature of RSpec 3.5 and will be the only
+  # supported behavior in RSpec 4.
+  #
+  # @overload shared_context_metadata_behavior
+  # @overload shared_context_metadata_behavior=
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def shared_context_metadata_behavior; end
+
+  # @see shared_context_metadata_behavior
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#434
+  def shared_context_metadata_behavior=(value); end
+
+  # Don't print filter info i.e. "Run options: include {:focus=>true}"
+  # (default `false`).
+  # return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def silence_filter_announcements; end
+
+  # Don't print filter info i.e. "Run options: include {:focus=>true}"
+  # (default `false`).
+  # return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def silence_filter_announcements=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def silence_filter_announcements?; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1138
+  def spec_files_with_failures; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def start_time; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def start_time=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def start_time?; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#520
+  def static_config_filter_manager; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#520
+  def static_config_filter_manager=(_arg0); end
+
+  # Color to use to indicate success.  Defaults to `:green` but can be set
+  # to one of the following: `[:black, :white, :red, :green, :yellow,
+  # :blue, :magenta, :cyan]`
+  #
+  # @return [Symbol]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def success_color; end
+
+  # Color to use to indicate success.  Defaults to `:green` but can be set
+  # to one of the following: `[:black, :white, :red, :green, :yellow,
+  # :blue, :magenta, :cyan]`
+  #
+  # @return [Symbol]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def success_color=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def success_color?; end
+
+  # Use threadsafe options where available.
+  # Currently this will place a mutex around memoized values such as let blocks.
+  # return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def threadsafe; end
+
+  # Use threadsafe options where available.
+  # Currently this will place a mutex around memoized values such as let blocks.
+  # return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def threadsafe=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def threadsafe?; end
+
+  # @deprecated This config option was added in RSpec 2 to pave the way
+  #   for this being the default behavior in RSpec 3. Now this option is
+  #   a no-op.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#383
+  def treat_symbols_as_metadata_keys_with_true_values=(_value); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#66
+  def tty; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#89
+  def tty=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#78
+  def tty?; end
+
+  # Set Ruby warnings on or off.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1760
+  def warnings=(value); end
+
+  # @return [Boolean] Whether or not ruby warnings are enabled.
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1765
+  def warnings?; end
+
+  # Defines a callback that runs after the first example with matching
+  # metadata is defined. If no examples are defined with matching metadata,
+  # it will not get called at all.
+  #
+  # This can be used to ensure some setup is performed (such as bootstrapping
+  # a DB or loading a specific file that adds significantly to the boot time)
+  # if needed (as indicated by the presence of an example with matching metadata)
+  # but avoided otherwise.
+  #
+  # @example
+  #   RSpec.configure do |config|
+  #   config.when_first_matching_example_defined(:db) do
+  #   # Load a support file that does some heavyweight setup,
+  #   # including bootstrapping the DB, but only if we have loaded
+  #   # any examples tagged with `:db`.
+  #   require 'support/db'
+  #   end
+  #   end
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1923
+  def when_first_matching_example_defined(*filters); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2091
+  def with_suite_hooks; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#518
+  def world; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#518
+  def world=(_arg0); end
+
+  private
+
+  # :nocov:
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2254
+  def absolute_pattern?(pattern); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2355
+  def add_hook_to_existing_matching_groups(meta, scope, &block); end
+
+  # @raise [MustBeConfiguredBeforeExampleGroupsError]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2294
+  def assert_no_example_groups_defined(config_option); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2344
+  def clear_values_derived_from_example_status_persistence_file_path; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2276
+  def command; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2320
+  def conditionally_disable_expectations_monkey_patching; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2311
+  def conditionally_disable_mocks_monkey_patching; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2349
+  def configure_group_with(group, module_list, application_method); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2284
+  def define_built_in_hooks; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2407
+  def define_mixed_in_module(mod, filters, mod_list, config_method, &block); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2259
+  def extract_location(path); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2236
+  def file_glob_from(path, pattern); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2225
+  def gather_directories(path); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2204
+  def get_files_to_run(paths); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2231
+  def get_matching_files(path, pattern); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2171
+  def handle_suite_hook(scope, meta); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2143
+  def load_file_handling_errors(method, file); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2377
+  def metadata_applies_to_group?(meta, group); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2369
+  def on_existing_matching_groups(meta); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2307
+  def output_to_tty?(output = T.unsafe(nil)); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2303
+  def output_wrapper; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2216
+  def paths_to_check(paths); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2221
+  def pattern_might_load_specs_from_vendored_dirs?; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2330
+  def rspec_expectations_loaded?; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2326
+  def rspec_mocks_loaded?; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2186
+  def run_suite_hooks(hook_description, hooks); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2392
+  def safe_extend(mod, host); end
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#2388
+  def safe_include(mod, host); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2382
+  def safe_prepend(mod, host); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2334
+  def update_pattern_attr(name, value); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#2280
+  def value_for(key); end
+
+  class << self
+    # As `add_setting` but only add the reader.
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/configuration.rb#100
+    def add_read_only_setting(name, opts = T.unsafe(nil)); end
+
+    # Invoked by the `add_setting` instance method. Use that method on a
+    # `Configuration` instance rather than this class method.
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/configuration.rb#87
+    def add_setting(name, opts = T.unsafe(nil)); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/configuration.rb#70
+    def define_alias(name, alias_name); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/configuration.rb#77
+    def define_predicate(name); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/configuration.rb#60
+    def define_reader(name); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/configuration.rb#1671
+    def delegate_to_ordering_manager(*methods); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/configuration.rb#1651
+RSpec::Core::Configuration::DEFAULT_FORMATTER = T.let(T.unsafe(nil), Proc)
+
+# This buffer is used to capture all messages sent to the reporter during
+# reporter initialization. It can then replay those messages after the
+# formatter is correctly initialized. Otherwise, deprecation warnings
+# during formatter initialization can cause an infinite loop.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/configuration.rb#1039
+class RSpec::Core::Configuration::DeprecationReporterBuffer
+  # @return [DeprecationReporterBuffer] a new instance of DeprecationReporterBuffer
+  #
+  # source://rspec-core//lib/rspec/core/configuration.rb#1040
+  def initialize; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#1044
+  def deprecation(*args); end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#1048
+  def play_onto(reporter); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/configuration.rb#1821
+module RSpec::Core::Configuration::ExposeCurrentExample; end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/configuration.rb#1126
+RSpec::Core::Configuration::FAILED_STATUS = T.let(T.unsafe(nil), String)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/configuration.rb#749
+RSpec::Core::Configuration::MOCKING_ADAPTERS = T.let(T.unsafe(nil), Hash)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/configuration.rb#57
+class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError < ::StandardError; end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/configuration.rb#1129
+RSpec::Core::Configuration::PASSED_STATUS = T.let(T.unsafe(nil), String)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/configuration.rb#1132
+RSpec::Core::Configuration::PENDING_STATUS = T.let(T.unsafe(nil), String)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/configuration.rb#1770
+RSpec::Core::Configuration::RAISE_ERROR_WARNING_NOTIFIER = T.let(T.unsafe(nil), Proc)
+
+# Module that holds `attr_reader` declarations. It's in a separate
+# module to allow us to override those methods and use `super`.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/configuration.rb#53
+module RSpec::Core::Configuration::Readers
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def clear_lets_on_failure; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def default_color; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def default_path; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def default_retry_count; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def default_sleep_interval; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def deprecation_stream; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def detail_color; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def display_try_failure_messages; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def drb; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def drb_port; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def dry_run; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def error_exit_code; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def error_stream; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def example_status_persistence_file_path; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def exceptions_to_hard_fail; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def exceptions_to_retry; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def exclude_pattern; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def exponential_backoff; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def fail_fast; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def fail_if_no_examples; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def failure_color; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def failure_exit_code; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def fixed_color; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def full_cause_backtrace; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def libs; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def max_displayed_failure_line_count; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def only_failures; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def output_stream; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def pattern; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def pending_color; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def pending_failure_output; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def project_source_dirs; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def requires; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def retry_callback; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def retry_count_condition; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def run_all_when_everything_filtered; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def shared_context_metadata_behavior; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def silence_filter_announcements; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def start_time; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def success_color; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def threadsafe; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def tty; end
+
+  # source://rspec-core//lib/rspec/core/configuration.rb#63
+  def verbose_retry; end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/configuration.rb#1123
+RSpec::Core::Configuration::UNKNOWN_STATUS = T.let(T.unsafe(nil), String)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/configuration.rb#1135
+RSpec::Core::Configuration::VALID_STATUSES = T.let(T.unsafe(nil), Array)
+
+# Responsible for utilizing externally provided configuration options,
+# whether via the command line, `.rspec`, `~/.rspec`,
+# `$XDG_CONFIG_HOME/rspec/options`, `.rspec-local` or a custom options
+# file.
+#
+# source://rspec-core//lib/rspec/core/configuration_options.rb#10
+class RSpec::Core::ConfigurationOptions
+  # @param args [Array<String>] command line arguments
+  # @return [ConfigurationOptions] a new instance of ConfigurationOptions
+  #
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#12
+  def initialize(args); end
+
+  # @return [Array<String>] the original command-line arguments
+  #
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#40
+  def args; end
+
+  # Updates the provided {Configuration} instance based on the provided
+  # external configuration options.
+  #
+  # @param config [Configuration] the configuration instance to update
+  #
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#21
+  def configure(config); end
+
+  # Updates the provided {FilterManager} based on the filter options.
+  #
+  # @api private
+  # @param filter_manager [FilterManager] instance to update
+  #
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#30
+  def configure_filter_manager(filter_manager); end
+
+  # @return [Hash] the final merged options, drawn from all external sources
+  #
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#37
+  def options; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#173
+  def args_from_options_file(path); end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#142
+  def command_line_options; end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#146
+  def custom_options; end
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#190
+  def custom_options_file; end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#133
+  def env_options; end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#125
+  def file_options; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#66
+  def force?(key); end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#158
+  def global_options; end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#202
+  def global_options_file; end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#213
+  def home_options_file_path; end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#121
+  def load_formatters_into(config); end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#150
+  def local_options; end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#198
+  def local_options_file; end
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#181
+  def options_file_as_erb_string(path); end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#162
+  def options_from(path); end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#70
+  def order(keys); end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#44
+  def organize_options; end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#167
+  def parse_args_ignoring_files_or_dirs_to_run(args, source); end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#113
+  def process_options_into(config); end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#154
+  def project_options; end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#194
+  def project_options_file; end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#229
+  def resolve_xdg_config_home; end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#206
+  def xdg_options_file_if_exists; end
+
+  # source://rspec-core//lib/rspec/core/configuration_options.rb#222
+  def xdg_options_file_path; end
+end
+
+# source://rspec-core//lib/rspec/core/configuration_options.rb#77
+RSpec::Core::ConfigurationOptions::OPTIONS_ORDER = T.let(T.unsafe(nil), Array)
+
+# source://rspec-core//lib/rspec/core/configuration_options.rb#59
+RSpec::Core::ConfigurationOptions::UNFORCED_OPTIONS = T.let(T.unsafe(nil), RSpec::Core::Set)
+
+# source://rspec-core//lib/rspec/core/configuration_options.rb#64
+RSpec::Core::ConfigurationOptions::UNPROCESSABLE_OPTIONS = T.let(T.unsafe(nil), RSpec::Core::Set)
+
+# DSL defines methods to group examples, most notably `describe`,
+# and exposes them as class methods of {RSpec}. They can also be
+# exposed globally (on `main` and instances of `Module`) through
+# the {Configuration} option `expose_dsl_globally`.
+#
+# By default the methods `describe`, `context` and `example_group`
+# are exposed. These methods define a named context for one or
+# more examples. The given block is evaluated in the context of
+# a generated subclass of {RSpec::Core::ExampleGroup}.
+#
+# ## Examples:
+#
+#     RSpec.describe "something" do
+#       context "when something is a certain way" do
+#         it "does something" do
+#           # example code goes here
+#         end
+#       end
+#     end
+#
+# @see ExampleGroup
+# @see ExampleGroup.example_group
+#
+# source://rspec-core//lib/rspec/core/dsl.rb#25
+module RSpec::Core::DSL
+  class << self
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/dsl.rb#89
+    def change_global_dsl(&changes); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/dsl.rb#27
+    def example_group_aliases; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/dsl.rb#37
+    def expose_example_group_alias(name); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/dsl.rb#81
+    def expose_example_group_alias_globally(method_name); end
+
+    # Adds the describe method to Module and the top level binding.
+    #
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core/dsl.rb#58
+    def expose_globally!; end
+
+    # @private
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/dsl.rb#32
+    def exposed_globally?; end
+
+    # Removes the describe method from Module and the top level binding.
+    #
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core/dsl.rb#70
+    def remove_globally!; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/dsl.rb#53
+    def top_level; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/dsl.rb#53
+    def top_level=(_arg0); end
+  end
+end
+
+# Deprecation Error.
+#
+# source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#221
+class RSpec::Core::DeprecationError < ::StandardError; end
+
+# Wrapper around Ruby's `DidYouMean::SpellChecker` when available to provide file name suggestions.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/did_you_mean.rb#5
+class RSpec::Core::DidYouMean
+  # @return [DidYouMean] a new instance of DidYouMean
+  #
+  # source://rspec-core//lib/rspec/core/did_you_mean.rb#8
+  def initialize(relative_file_name); end
+
+  # return a hint if API for ::DidYouMean::SpellChecker not supported
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/did_you_mean.rb#15
+  def call; end
+
+  # Returns the value of attribute relative_file_name.
+  #
+  # source://rspec-core//lib/rspec/core/did_you_mean.rb#6
+  def relative_file_name; end
+
+  private
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/did_you_mean.rb#35
+  def formats(probables); end
+
+  # source://rspec-core//lib/rspec/core/did_you_mean.rb#45
+  def red_font(mytext); end
+
+  # source://rspec-core//lib/rspec/core/did_you_mean.rb#40
+  def top_and_tail(rspec_format); end
+end
+
+# Wrapper for an instance of a subclass of {ExampleGroup}. An instance of
+# `RSpec::Core::Example` is returned by example definition methods
+# such as {ExampleGroup.it it} and is yielded to the {ExampleGroup.it it},
+# {Hooks#before before}, {Hooks#after after}, {Hooks#around around},
+# {MemoizedHelpers::ClassMethods#let let} and
+# {MemoizedHelpers::ClassMethods#subject subject} blocks.
+#
+# This allows us to provide rich metadata about each individual
+# example without adding tons of methods directly to the ExampleGroup
+# that users may inadvertently redefine.
+#
+# Useful for configuring logging and/or taking some action based
+# on the state of an example's metadata.
+#
+# @example
+#
+#   RSpec.configure do |config|
+#   config.before do |example|
+#   log example.description
+#   end
+#
+#   config.after do |example|
+#   log example.description
+#   end
+#
+#   config.around do |example|
+#   log example.description
+#   example.run
+#   end
+#   end
+#
+#   shared_examples "auditable" do
+#   it "does something" do
+#   log "#{example.full_description}: #{auditable.inspect}"
+#   auditable.should do_something
+#   end
+#   end
+# @note Example blocks are evaluated in the context of an instance
+#   of an `ExampleGroup`, not in the context of an instance of `Example`.
+# @see ExampleGroup
+#
+# source://rspec-core//lib/rspec/core/example.rb#44
+class RSpec::Core::Example
+  # Creates a new instance of Example.
+  #
+  # @api private
+  # @param example_group_class [Class] the subclass of ExampleGroup in which
+  #   this Example is declared
+  # @param description [String] the String passed to the `it` method (or
+  #   alias)
+  # @param user_metadata [Hash] additional args passed to `it` to be used as
+  #   metadata
+  # @param example_block [Proc] the block of code that represents the
+  #   example
+  # @return [Example] a new instance of Example
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#186
+  def initialize(example_group_class, description, user_metadata, example_block = T.unsafe(nil)); end
+
+  # source://rspec-retry/0.6.2/lib/rspec_ext/rspec_ext.rb#4
+  def attempts; end
+
+  # source://rspec-retry/0.6.2/lib/rspec_ext/rspec_ext.rb#4
+  def attempts=(_arg0); end
+
+  # source://rspec-retry/0.6.2/lib/rspec_ext/rspec_ext.rb#6
+  def clear_exception; end
+
+  # @attr
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#174
+  def clock; end
+
+  # @attr
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#174
+  def clock=(_arg0); end
+
+  # Returns the string submitted to `example` or its aliases (e.g.
+  # `specify`, `it`, etc). If no string is submitted (e.g.
+  # `it { is_expected.to do_something }`) it returns the message generated
+  # by the matcher if there is one, otherwise returns a message including
+  # the location of the example.
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#76
+  def description; end
+
+  # The exception that will be displayed to the user -- either the failure of
+  # the example or the `pending_exception` if the example is pending.
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#388
+  def display_exception; end
+
+  # Assigns the exception that will be displayed to the user -- either the failure of
+  # the example or the `pending_exception` if the example is pending.
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#396
+  def display_exception=(ex); end
+
+  # Duplicates the example and overrides metadata with the provided
+  # hash.
+  #
+  # @param metadata_overrides [Hash] the hash to override the example metadata
+  # @return [Example] a duplicate of the example with modified metadata
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#132
+  def duplicate_with(metadata_overrides = T.unsafe(nil)); end
+
+  # Returns the example group class that provides the context for running
+  # this example.
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#230
+  def example_group; end
+
+  # Returns the example_group_instance that provides the context for
+  # running this example.
+  #
+  # @attr_reader
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#170
+  def example_group_instance; end
+
+  # Returns the first exception raised in the context of running this
+  # example (nil if no exception is raised).
+  #
+  # @attr_reader
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#158
+  def exception; end
+
+  # @return [ExecutionResult] represents the result of running this example.
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#49
+  def execution_result; end
+
+  # Used internally to set an exception and fail without actually executing
+  # the example when an exception is raised in before(:context).
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#439
+  def fail_with_exception(reporter, exception); end
+
+  # @return [String] the relative path to the file where this example was
+  #   defined.
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#49
+  def file_path; end
+
+  # @return [String] the full description (including the docstrings of
+  #   all parent example groups).
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#49
+  def full_description; end
+
+  # @return [String] the unique id of this example. Pass
+  #   this at the command line to re-run this exact example.
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#117
+  def id; end
+
+  # Provide a human-readable representation of this class
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#220
+  def inspect; end
+
+  # Returns a description of the example that always includes the location.
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#87
+  def inspect_output; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#456
+  def instance_exec(*args, &block); end
+
+  # @return [String] the exact source location of this example in a form
+  #   like `./path/to/spec.rb:17`
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#49
+  def location; end
+
+  # Returns the location-based argument that can be passed to the `rspec` command to rerun this example.
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#96
+  def location_rerun_argument; end
+
+  # Returns the metadata object associated with this example.
+  #
+  # @attr_reader
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#163
+  def metadata; end
+
+  # @return [Boolean] flag that indicates that the example is not expected
+  #   to pass. It will be run and will either have a pending result (if a
+  #   failure occurs) or a failed result (if no failure occurs).
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#49
+  def pending; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#234
+  def pending?; end
+
+  # @return [RSpec::Core::Reporter] the current reporter for the example
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#226
+  def reporter; end
+
+  # Returns the location-based argument that can be passed to the `rspec` command to rerun this example.
+  #
+  # @deprecated Use {#location_rerun_argument} instead.
+  # @note If there are multiple examples identified by this location, they will use {#id}
+  #   to rerun instead, but this method will still return the location (that's why it is deprecated!).
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#111
+  def rerun_argument; end
+
+  # instance_execs the block passed to the constructor in the context of
+  # the instance of {ExampleGroup}.
+  #
+  # @api private
+  # @param example_group_instance the instance of an ExampleGroup subclass
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#246
+  def run(example_group_instance, reporter); end
+
+  # Used to set the exception when `aggregate_failures` fails.
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#425
+  def set_aggregate_failures_exception(exception); end
+
+  # Used internally to set an exception in an after hook, which
+  # captures the exception but doesn't raise it.
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#412
+  def set_exception(exception); end
+
+  # @return [Boolean] flag that will cause the example to not run.
+  #   The {ExecutionResult} status will be `:pending`.
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#49
+  def skip; end
+
+  # Used internally to skip without actually executing the example when
+  # skip is used in before(:context).
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#449
+  def skip_with_exception(reporter, exception); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#238
+  def skipped?; end
+
+  # Provide a human-readable representation of this class
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#220
+  def to_s; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#148
+  def update_inherited_metadata(updates); end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/example.rb#534
+  def assign_generated_description; end
+
+  # source://rspec-core//lib/rspec/core/example.rb#478
+  def finish(reporter); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#543
+  def generate_description; end
+
+  # source://rspec-core//lib/rspec/core/example.rb#462
+  def hooks; end
+
+  # source://rspec-core//lib/rspec/core/example.rb#550
+  def location_description; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#530
+  def mocks_need_verification?; end
+
+  # source://rspec-core//lib/rspec/core/example.rb#498
+  def record_finished(status, reporter); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#516
+  def run_after_example; end
+
+  # source://rspec-core//lib/rspec/core/example.rb#503
+  def run_before_example; end
+
+  # source://rspec-core//lib/rspec/core/example.rb#473
+  def start(reporter); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#524
+  def verify_mocks; end
+
+  # source://rspec-core//lib/rspec/core/example.rb#508
+  def with_around_and_singleton_context_hooks; end
+
+  # source://rspec-core//lib/rspec/core/example.rb#466
+  def with_around_example_hooks; end
+
+  class << self
+    # Used to define methods that delegate to this example's metadata.
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example.rb#48
+    def delegate_to_metadata(key); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example.rb#122
+    def parse_id(id); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/example.rb#310
+RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
+
+# Represents the result of executing an example.
+# Behaves like a hash for backwards compatibility.
+#
+# source://rspec-core//lib/rspec/core/example.rb#556
+class RSpec::Core::Example::ExecutionResult
+  include ::RSpec::Core::HashImitatable
+  extend ::RSpec::Core::HashImitatable::ClassMethods
+
+  # Populates finished_at and run_time if it has not yet been set
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#610
+  def ensure_timing_set(clock); end
+
+  # @return [Boolean] Indicates if the example was completely skipped
+  #   (typically done via `:skip` metadata or the `skip` method). Skipped examples
+  #   will have a `:pending` result. A `:pending` result can also come from examples
+  #   that were marked as `:pending`, which causes them to be run, and produces a
+  #   `:failed` result if the example passes.
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#597
+  def example_skipped?; end
+
+  # @return [Exception, nil] The failure, if there was one.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def exception; end
+
+  # @return [Exception, nil] The failure, if there was one.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def exception=(_arg0); end
+
+  # @return [Time] When the example finished.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def finished_at; end
+
+  # @return [Time] When the example finished.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def finished_at=(_arg0); end
+
+  # @return [Exception, nil] The exception triggered while
+  #   executing the pending example. If no exception was triggered
+  #   it would no longer get a status of `:pending` unless it was
+  #   tagged with `:skip`.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def pending_exception; end
+
+  # @return [Exception, nil] The exception triggered while
+  #   executing the pending example. If no exception was triggered
+  #   it would no longer get a status of `:pending` unless it was
+  #   tagged with `:skip`.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def pending_exception=(_arg0); end
+
+  # @return [Boolean] For examples tagged with `:pending`,
+  #   this indicates whether or not it now passes.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def pending_fixed; end
+
+  # @return [Boolean] For examples tagged with `:pending`,
+  #   this indicates whether or not it now passes.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def pending_fixed=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#588
+  def pending_fixed?; end
+
+  # @return [String, nil] The reason the example was pending,
+  #   or nil if the example was not pending.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def pending_message; end
+
+  # @return [String, nil] The reason the example was pending,
+  #   or nil if the example was not pending.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def pending_message=(_arg0); end
+
+  # Records the finished status of the example.
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#603
+  def record_finished(status, finished_at); end
+
+  # @return [Float] How long the example took in seconds.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def run_time; end
+
+  # @return [Float] How long the example took in seconds.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def run_time=(_arg0); end
+
+  # @return [Time] When the example started.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def started_at; end
+
+  # @return [Time] When the example started.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def started_at=(_arg0); end
+
+  # @return [Symbol] `:passed`, `:failed` or `:pending`.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def status; end
+
+  # @return [Symbol] `:passed`, `:failed` or `:pending`.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#442
+  def status=(_arg0); end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/example.rb#616
+  def calculate_run_time(finished_at); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#634
+  def get_value(name); end
+
+  # For backwards compatibility we present `status` as a string
+  # when presenting the legacy hash interface.
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#623
+  def hash_for_delegation; end
+
+  # source://rspec-core//lib/rspec/core/example.rb#642
+  def issue_deprecation(_method_name, *_args); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#629
+  def set_value(name, value); end
+end
+
+# Wraps both a `Proc` and an {Example} for use in {Hooks#around
+# around} hooks. In around hooks we need to yield this special
+# kind of object (rather than the raw {Example}) because when
+# there are multiple `around` hooks we have to wrap them recursively.
+#
+# @example
+#
+#   RSpec.configure do |c|
+#   c.around do |ex| # Procsy which wraps the example
+#   if ex.metadata[:key] == :some_value && some_global_condition
+#   raise "some message"
+#   end
+#   ex.run         # run delegates to ex.call.
+#   end
+#   end
+# @note This class also exposes the instance methods of {Example},
+#   proxying them through to the wrapped {Example} instance.
+#
+# source://rspec-core//lib/rspec/core/example.rb#331
+class RSpec::Core::Example::Procsy
+  # @return [Procsy] a new instance of Procsy
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#362
+  def initialize(example, &block); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def <<(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def ==(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def ===(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def >>(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def [](*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def arity(*a, &b); end
+
+  # source://rspec-retry/0.6.2/lib/rspec_ext/rspec_ext.rb#15
+  def attempts; end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def binding(*a, &b); end
+
+  # Calls the proc and notes that the example has been executed.
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#350
+  def call(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def clock(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def clock=(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def clone(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def curry(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def description(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def dup(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def duplicate_with(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def eql?(*a, &b); end
+
+  # The {Example} instance.
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#333
+  def example; end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def example_group(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def example_group_instance(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def exception(*a, &b); end
+
+  # Indicates whether or not the around hook has executed the example.
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#374
+  def executed?; end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def execution_result(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def file_path(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def full_description(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def hash(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def id(*a, &b); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#379
+  def inspect; end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def inspect_output(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def lambda?(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def location(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def location_rerun_argument(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def metadata(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def parameters(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def pending(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def pending?(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def reporter(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def rerun_argument(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def ruby2_keywords(*a, &b); end
+
+  # Calls the proc and notes that the example has been executed.
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#350
+  def run(*args, &block); end
+
+  # source://rspec-retry/0.6.2/lib/rspec_ext/rspec_ext.rb#11
+  def run_with_retry(opts = T.unsafe(nil)); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def skip(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def skipped?(*a, &b); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def source_location(*a, &b); end
+
+  # Provides a wrapped proc that will update our `executed?` state when
+  # executed.
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#358
+  def to_proc; end
+
+  # source://rspec-core//lib/rspec/core/example.rb#339
+  def update_inherited_metadata(*a, &b); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#369
+  def wrap(&block); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#346
+  def yield(*a, &b); end
+end
+
+# ExampleGroup and {Example} are the main structural elements of
+# rspec-core. Consider this example:
+#
+#     RSpec.describe Thing do
+#       it "does something" do
+#       end
+#     end
+#
+# The object returned by `describe Thing` is a subclass of ExampleGroup.
+# The object returned by `it "does something"` is an instance of Example,
+# which serves as a wrapper for an instance of the ExampleGroup in which it
+# is declared.
+#
+# Example group bodies (e.g. `describe` or `context` blocks) are evaluated
+# in the context of a new subclass of ExampleGroup. Individual examples are
+# evaluated in the context of an instance of the specific ExampleGroup
+# subclass to which they belong.
+#
+# Besides the class methods defined here, there are other interesting macros
+# defined in {Hooks}, {MemoizedHelpers::ClassMethods} and
+# {SharedExampleGroup}. There are additional instance methods available to
+# your examples defined in {MemoizedHelpers} and {Pending}.
+#
+# source://rspec-core//lib/rspec/core/example_group.rb#29
+class RSpec::Core::ExampleGroup
+  include ::RSpec::Core::MemoizedHelpers
+  include ::RSpec::Core::Pending
+  extend ::RSpec::Core::Hooks
+  extend ::RSpec::Core::MemoizedHelpers::ClassMethods
+  extend ::RSpec::Core::SharedExampleGroup
+
+  # source://rspec-core//lib/rspec/core/example_group.rb#707
+  def initialize(inspect_output = T.unsafe(nil)); end
+
+  # source://rspec-retry/0.6.2/lib/rspec_ext/rspec_ext.rb#34
+  def clear_lets; end
+
+  # source://rspec-retry/0.6.2/lib/rspec_ext/rspec_ext.rb#26
+  def clear_memoized; end
+
+  # Returns the class or module passed to the `describe` method (or alias).
+  # Returns nil if the subject is not a class or module.
+  #
+  # @example
+  #   RSpec.describe Thing do
+  #   it "does something" do
+  #   described_class == Thing
+  #   end
+  #   end
+  #
+  # source://rspec-core//lib/rspec/core/example_group.rb#99
+  def described_class; end
+
+  # source://rspec-core//lib/rspec/core/example_group.rb#713
+  def inspect; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/example_group.rb#758
+  def method_missing(name, *args, **_arg2); end
+
+  class << self
+    # Adds an example to the example group
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#367
+    def add_example(example); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#529
+    def before_context_ivars; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#466
+    def children; end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#247
+    def context(*args, &example_group_block); end
+
+    # Returns true if a `before(:context)` or `after(:context)`
+    # hook is currently executing.
+    #
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#542
+    def currently_executing_a_context_hook?; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#667
+    def declaration_locations; end
+
+    # @private
+    # @see DSL#describe
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#246
+    def define_example_group_method(name, metadata = T.unsafe(nil)); end
+
+    # @example
+    #     $1 "does something", :slow, :load_factor => 100 do
+    #     end
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#145
+    def define_example_method(name, extra_options = T.unsafe(nil)); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#317
+    def define_nested_shared_group_method(new_name, report_label = T.unsafe(nil)); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#76
+    def delegate_to_metadata(*names); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#460
+    def descendant_filtered_examples; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#503
+    def descendants; end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#247
+    def describe(*args, &example_group_block); end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#78
+    def described_class; end
+
+    # @return [String] the current example group description
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#85
+    def description; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#700
+    def each_instance_variable_for_example(group); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#518
+    def ensure_example_groups_are_configured; end
+
+    # Defines an example within a group.
+    #
+    # @example
+    #   example do
+    #   end
+    #
+    #   example "does something" do
+    #   end
+    #
+    #   example "does something", :slow, :uses_js do
+    #   end
+    #
+    #   example "does something", :with => 'additional metadata' do
+    #   end
+    #
+    #   example "does something" do |ex|
+    #   # ex is the Example object that contains metadata about the example
+    #   end
+    # @overload example
+    # @overload example
+    # @overload example
+    # @overload example
+    # @yield [Example] the example object
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#146
+    def example(*all_args, &block); end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#247
+    def example_group(*args, &example_group_block); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#450
+    def examples; end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#247
+    def fcontext(*args, &example_group_block); end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#247
+    def fdescribe(*args, &example_group_block); end
+
+    # Shortcut to define an example with `:focus => true`.
+    #
+    # @example
+    #   fexample do
+    #   end
+    #
+    #   fexample "does something" do
+    #   end
+    #
+    #   fexample "does something", :slow, :uses_js do
+    #   end
+    #
+    #   fexample "does something", :with => 'additional metadata' do
+    #   end
+    #
+    #   fexample "does something" do |ex|
+    #   # ex is the Example object that contains metadata about the example
+    #   end
+    # @overload fexample
+    # @overload fexample
+    # @overload fexample
+    # @overload fexample
+    # @see example
+    # @yield [Example] the example object
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#146
+    def fexample(*all_args, &block); end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#78
+    def file_path; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#455
+    def filtered_examples; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#379
+    def find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end
+
+    # Shortcut to define an example with `:focus => true`.
+    #
+    # @example
+    #   fit do
+    #   end
+    #
+    #   fit "does something" do
+    #   end
+    #
+    #   fit "does something", :slow, :uses_js do
+    #   end
+    #
+    #   fit "does something", :with => 'additional metadata' do
+    #   end
+    #
+    #   fit "does something" do |ex|
+    #   # ex is the Example object that contains metadata about the example
+    #   end
+    # @overload fit
+    # @overload fit
+    # @overload fit
+    # @overload fit
+    # @see example
+    # @yield [Example] the example object
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#146
+    def fit(*all_args, &block); end
+
+    # Shortcut to define an example with `:focus => true`.
+    #
+    # @example
+    #   focus do
+    #   end
+    #
+    #   focus "does something" do
+    #   end
+    #
+    #   focus "does something", :slow, :uses_js do
+    #   end
+    #
+    #   focus "does something", :with => 'additional metadata' do
+    #   end
+    #
+    #   focus "does something" do |ex|
+    #   # ex is the Example object that contains metadata about the example
+    #   end
+    # @overload focus
+    # @overload focus
+    # @overload focus
+    # @overload focus
+    # @see example
+    # @yield [Example] the example object
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#146
+    def focus(*all_args, &block); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#655
+    def for_filtered_examples(reporter, &block); end
+
+    # Shortcut to define an example with `:focus => true`.
+    #
+    # @example
+    #   fspecify do
+    #   end
+    #
+    #   fspecify "does something" do
+    #   end
+    #
+    #   fspecify "does something", :slow, :uses_js do
+    #   end
+    #
+    #   fspecify "does something", :with => 'additional metadata' do
+    #   end
+    #
+    #   fspecify "does something" do |ex|
+    #   # ex is the Example object that contains metadata about the example
+    #   end
+    # @overload fspecify
+    # @overload fspecify
+    # @overload fspecify
+    # @overload fspecify
+    # @see example
+    # @yield [Example] the example object
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#146
+    def fspecify(*all_args, &block); end
+
+    # @return [String] the unique id of this example group. Pass
+    #   this at the command line to re-run this exact example group.
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#675
+    def id; end
+
+    # Define a singleton method for the singleton class (remove the method if
+    # it's already been defined).
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#40
+    def idempotently_define_singleton_method(name, &definition); end
+
+    # Includes shared content mapped to `name` directly in the group in which
+    # it is declared, as opposed to `it_behaves_like`, which creates a nested
+    # group. If given a block, that block is also eval'd in the current
+    # context.
+    #
+    # @see SharedExampleGroup
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#343
+    def include_context(name, *args, &block); end
+
+    # Includes shared content mapped to `name` directly in the group in which
+    # it is declared, as opposed to `it_behaves_like`, which creates a nested
+    # group. If given a block, that block is also eval'd in the current
+    # context.
+    #
+    # @see SharedExampleGroup
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#353
+    def include_examples(name, *args, &block); end
+
+    # Defines an example within a group.
+    # This is the primary API to define a code example.
+    #
+    # @example
+    #   it do
+    #   end
+    #
+    #   it "does something" do
+    #   end
+    #
+    #   it "does something", :slow, :uses_js do
+    #   end
+    #
+    #   it "does something", :with => 'additional metadata' do
+    #   end
+    #
+    #   it "does something" do |ex|
+    #   # ex is the Example object that contains metadata about the example
+    #   end
+    # @overload it
+    # @overload it
+    # @overload it
+    # @overload it
+    # @yield [Example] the example object
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#146
+    def it(*all_args, &block); end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#318
+    def it_behaves_like(name, *args, &customization_block); end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#318
+    def it_should_behave_like(name, *args, &customization_block); end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#78
+    def location; end
+
+    # The [Metadata](Metadata) object associated with this group.
+    #
+    # @see Metadata
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#51
+    def metadata; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#485
+    def next_runnable_index_for(file); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#625
+    def ordering_strategy; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#508
+    def parent_groups; end
+
+    # Shortcut to define an example with `:pending => true`
+    #
+    # @example
+    #   pending do
+    #   end
+    #
+    #   pending "does something" do
+    #   end
+    #
+    #   pending "does something", :slow, :uses_js do
+    #   end
+    #
+    #   pending "does something", :with => 'additional metadata' do
+    #   end
+    #
+    #   pending "does something" do |ex|
+    #   # ex is the Example object that contains metadata about the example
+    #   end
+    # @overload pending
+    # @overload pending
+    # @overload pending
+    # @overload pending
+    # @see example
+    # @yield [Example] the example object
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#146
+    def pending(*all_args, &block); end
+
+    # Removes an example from the example group
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#373
+    def remove_example(example); end
+
+    # Clear memoized values when adding/removing examples
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#359
+    def reset_memoized; end
+
+    # Runs all the examples in this group.
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#599
+    def run(reporter = T.unsafe(nil)); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#585
+    def run_after_context_hooks(example_group_instance); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#547
+    def run_before_context_hooks(example_group_instance); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#641
+    def run_examples(reporter); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#410
+    def set_it_up(description, args, registration_collection, &example_group_block); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#685
+    def set_ivars(instance, ivars); end
+
+    # Shortcut to define an example with `:skip => true`
+    #
+    # @example
+    #   skip do
+    #   end
+    #
+    #   skip "does something" do
+    #   end
+    #
+    #   skip "does something", :slow, :uses_js do
+    #   end
+    #
+    #   skip "does something", :with => 'additional metadata' do
+    #   end
+    #
+    #   skip "does something" do |ex|
+    #   # ex is the Example object that contains metadata about the example
+    #   end
+    # @overload skip
+    # @overload skip
+    # @overload skip
+    # @overload skip
+    # @see example
+    # @yield [Example] the example object
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#146
+    def skip(*all_args, &block); end
+
+    # Defines an example within a group.
+    # Useful for when your docstring does not read well off of `it`.
+    #
+    # @example
+    #   RSpec.describe MyClass do
+    #   specify "#do_something is deprecated" do
+    #   # ...
+    #   end
+    #   end
+    # @example
+    #   specify do
+    #   end
+    #
+    #   specify "does something" do
+    #   end
+    #
+    #   specify "does something", :slow, :uses_js do
+    #   end
+    #
+    #   specify "does something", :with => 'additional metadata' do
+    #   end
+    #
+    #   specify "does something" do |ex|
+    #   # ex is the Example object that contains metadata about the example
+    #   end
+    # @overload specify
+    # @overload specify
+    # @overload specify
+    # @overload specify
+    # @yield [Example] the example object
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#146
+    def specify(*all_args, &block); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#534
+    def store_before_context_ivars(example_group_instance); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#395
+    def subclass(parent, description, args, registration_collection, &example_group_block); end
+
+    # :nocov:
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#562
+    def superclass_before_context_ivars; end
+
+    # @private
+    # @return [Metadata] belonging to the parent of a nested {ExampleGroup}
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#71
+    def superclass_metadata; end
+
+    # @private
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#513
+    def top_level?; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#680
+    def top_level_description; end
+
+    # Traverses the tree of groups, starting with `self`, then the children, recursively.
+    # Halts the traversal of a branch of the tree as soon as the passed block returns true.
+    # Note that siblings groups and their sub-trees will continue to be explored.
+    # This is intended to make it easy to find the top-most group that satisfies some
+    # condition.
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#476
+    def traverse_tree_until(&block); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#727
+    def update_inherited_metadata(updates); end
+
+    # Temporarily replace the provided metadata.
+    # Intended primarily to allow an example group's singleton class
+    # to return the metadata of the example that it exists for. This
+    # is necessary for shared example group inclusion to work properly
+    # with singleton example groups.
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#61
+    def with_replaced_metadata(meta); end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#247
+    def xcontext(*args, &example_group_block); end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#247
+    def xdescribe(*args, &example_group_block); end
+
+    # Shortcut to define an example with `:skip => 'Temporarily skipped with xexample'`.
+    #
+    # @example
+    #   xexample do
+    #   end
+    #
+    #   xexample "does something" do
+    #   end
+    #
+    #   xexample "does something", :slow, :uses_js do
+    #   end
+    #
+    #   xexample "does something", :with => 'additional metadata' do
+    #   end
+    #
+    #   xexample "does something" do |ex|
+    #   # ex is the Example object that contains metadata about the example
+    #   end
+    # @overload xexample
+    # @overload xexample
+    # @overload xexample
+    # @overload xexample
+    # @see example
+    # @yield [Example] the example object
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#146
+    def xexample(*all_args, &block); end
+
+    # Shortcut to define an example with `:skip => 'Temporarily skipped with xit'`.
+    #
+    # @example
+    #   xit do
+    #   end
+    #
+    #   xit "does something" do
+    #   end
+    #
+    #   xit "does something", :slow, :uses_js do
+    #   end
+    #
+    #   xit "does something", :with => 'additional metadata' do
+    #   end
+    #
+    #   xit "does something" do |ex|
+    #   # ex is the Example object that contains metadata about the example
+    #   end
+    # @overload xit
+    # @overload xit
+    # @overload xit
+    # @overload xit
+    # @see example
+    # @yield [Example] the example object
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#146
+    def xit(*all_args, &block); end
+
+    # Shortcut to define an example with `:skip => 'Temporarily skipped with xspecify'`.
+    #
+    # @example
+    #   xspecify do
+    #   end
+    #
+    #   xspecify "does something" do
+    #   end
+    #
+    #   xspecify "does something", :slow, :uses_js do
+    #   end
+    #
+    #   xspecify "does something", :with => 'additional metadata' do
+    #   end
+    #
+    #   xspecify "does something" do |ex|
+    #   # ex is the Example object that contains metadata about the example
+    #   end
+    # @overload xspecify
+    # @overload xspecify
+    # @overload xspecify
+    # @overload xspecify
+    # @see example
+    # @yield [Example] the example object
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#146
+    def xspecify(*all_args, &block); end
+
+    private
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#742
+    def method_missing(name, *args); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/example_group.rb#696
+RSpec::Core::ExampleGroup::INSTANCE_VARIABLE_TO_IGNORE = T.let(T.unsafe(nil), Symbol)
+
+# Raised when an RSpec API is called in the wrong scope, such as `before`
+# being called from within an example rather than from within an example
+# group block.
+#
+# source://rspec-core//lib/rspec/core/example_group.rb#740
+class RSpec::Core::ExampleGroup::WrongScopeError < ::NoMethodError; end
+
+# Dumps a list of hashes in a pretty, human readable format
+# for later parsing. The hashes are expected to have symbol
+# keys and string values, and each hash should have the same
+# set of keys.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/example_status_persister.rb#143
+class RSpec::Core::ExampleStatusDumper
+  # @return [ExampleStatusDumper] a new instance of ExampleStatusDumper
+  #
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#148
+  def initialize(examples); end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#152
+  def dump; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#188
+  def column_widths; end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#159
+  def formatted_header_rows; end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#176
+  def formatted_row_from(row_values); end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#166
+  def formatted_value_rows; end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#184
+  def headers; end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#172
+  def rows; end
+
+  class << self
+    # source://rspec-core//lib/rspec/core/example_status_persister.rb#144
+    def dump(examples); end
+  end
+end
+
+# Merges together a list of example statuses from this run
+# and a list from previous runs (presumably loaded from disk).
+# Each example status object is expected to be a hash with
+# at least an `:example_id` and a `:status` key. Examples that
+# were loaded but not executed (due to filtering, `--fail-fast`
+# or whatever) should have a `:status` of `UNKNOWN_STATUS`.
+#
+# This will produce a new list that:
+#   - Will be missing examples from previous runs that we know for sure
+#     no longer exist.
+#   - Will have the latest known status for any examples that either
+#     definitively do exist or may still exist.
+#   - Is sorted by file name and example definition order, so that
+#     the saved file is easily scannable if users want to inspect it.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/example_status_persister.rb#74
+class RSpec::Core::ExampleStatusMerger
+  # @return [ExampleStatusMerger] a new instance of ExampleStatusMerger
+  #
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#79
+  def initialize(this_run, from_previous_runs); end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#85
+  def merge; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#102
+  def delete_previous_examples_that_no_longer_exist; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#108
+  def example_must_no_longer_exist?(ex_id); end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#95
+  def hash_from(example_list); end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#124
+  def loaded_spec_files; end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#132
+  def sort_value_from(example); end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#128
+  def spec_file_from(ex_id); end
+
+  class << self
+    # source://rspec-core//lib/rspec/core/example_status_persister.rb#75
+    def merge(this_run, from_previous_runs); end
+  end
+end
+
+# Parses a string that has been previously dumped by ExampleStatusDumper.
+# Note that this parser is a bit naive in that it does a simple split on
+# "\n" and " | ", with no concern for handling escaping. For now, that's
+# OK because the values we plan to persist (example id, status, and perhaps
+# example duration) are highly unlikely to contain "\n" or " | " -- after
+# all, who puts those in file names?
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/example_status_persister.rb#207
+class RSpec::Core::ExampleStatusParser
+  # @return [ExampleStatusParser] a new instance of ExampleStatusParser
+  #
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#212
+  def initialize(string); end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#216
+  def parse; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#226
+  def headers; end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#222
+  def parse_row(line); end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#230
+  def split_line(line); end
+
+  class << self
+    # source://rspec-core//lib/rspec/core/example_status_persister.rb#208
+    def parse(string); end
+  end
+end
+
+# Persists example ids and their statuses so that we can filter
+# to just the ones that failed the last time they ran.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/example_status_persister.rb#8
+class RSpec::Core::ExampleStatusPersister
+  # @return [ExampleStatusPersister] a new instance of ExampleStatusPersister
+  #
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#18
+  def initialize(examples, file_name); end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#23
+  def persist; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#40
+  def dump_statuses(unparsed_previous_runs); end
+
+  # source://rspec-core//lib/rspec/core/example_status_persister.rb#46
+  def statuses_from_this_run; end
+
+  class << self
+    # source://rspec-core//lib/rspec/core/example_status_persister.rb#9
+    def load_from(file_name); end
+
+    # source://rspec-core//lib/rspec/core/example_status_persister.rb#14
+    def persist(examples, file_name); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/filter_manager.rb#183
+RSpec::Core::ExclusionRules = RSpec::Core::FilterRules
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/filter_manager.rb#4
+class RSpec::Core::FilterManager
+  # @return [FilterManager] a new instance of FilterManager
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#7
+  def initialize; end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#22
+  def add_ids(rerun_path, scoped_ids); end
+
+  # @api private
+  # @param file_path [String]
+  # @param line_numbers [Array]
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#15
+  def add_location(file_path, line_numbers); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#30
+  def empty?; end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#57
+  def exclude(*args); end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#61
+  def exclude_only(*args); end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#65
+  def exclude_with_low_priority(*args); end
+
+  # Returns the value of attribute exclusions.
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#5
+  def exclusions; end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#69
+  def include(*args); end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#73
+  def include_only(*args); end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#77
+  def include_with_low_priority(*args); end
+
+  # Returns the value of attribute inclusions.
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#5
+  def inclusions; end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#34
+  def prune(examples); end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#83
+  def add_path_to_arrays_filter(filter_key, path, values); end
+
+  # When a user specifies a particular spec location, that takes priority
+  # over any exclusion filters (such as if the spec is tagged with `:slow`
+  # and there is a `:slow => true` exclusion filter), but only for specs
+  # defined in the same file as the location filters. Excluded specs in
+  # other files should still be excluded.
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#101
+  def file_scoped_include?(ex_metadata, ids, locations); end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#89
+  def prune_conditionally_filtered_examples(examples); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/filter_manager.rb#115
+class RSpec::Core::FilterRules
+  # @return [FilterRules] a new instance of FilterRules
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#130
+  def initialize(rules = T.unsafe(nil)); end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#161
+  def [](key); end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#134
+  def add(updated); end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#138
+  def add_with_low_priority(updated); end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#149
+  def clear; end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#153
+  def delete(key); end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#173
+  def description; end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#169
+  def each_pair(&block); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#165
+  def empty?; end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#157
+  def fetch(*args, &block); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#177
+  def include_example?(example); end
+
+  # Returns the value of attribute opposite.
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#119
+  def opposite; end
+
+  # Sets the attribute opposite
+  #
+  # @param value the value to set the attribute opposite to.
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#119
+  def opposite=(_arg0); end
+
+  # Returns the value of attribute rules.
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#120
+  def rules; end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#144
+  def use_only(updated); end
+
+  class << self
+    # source://rspec-core//lib/rspec/core/filter_manager.rb#122
+    def build; end
+  end
+end
+
+# source://rspec-core//lib/rspec/core/filter_manager.rb#116
+RSpec::Core::FilterRules::PROC_HEX_NUMBER = T.let(T.unsafe(nil), Regexp)
+
+# source://rspec-core//lib/rspec/core/filter_manager.rb#117
+RSpec::Core::FilterRules::PROJECT_DIR = T.let(T.unsafe(nil), String)
+
+# Tracks a collection of filterable items (e.g. modules, hooks, etc)
+# and provides an optimized API to get the applicable items for the
+# metadata of an example or example group.
+#
+# There are two implementations, optimized for different uses.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/metadata_filter.rb#87
+module RSpec::Core::FilterableItemRepository; end
+
+# This implementation is much more complex, and is optimized for
+# rare (or hopefully no) updates once the queries start. Updates
+# incur a cost as it has to clear the memoization and keep track
+# of applicable keys. Queries will be O(N) the first time an item
+# is provided with a given set of applicable metadata; subsequent
+# queries with items with the same set of applicable metadata will
+# be O(1) due to internal memoization.
+#
+# This is ideal for use by config, where filterable items (e.g. hooks)
+# are typically added at the start of the process (e.g. in `spec_helper`)
+# and then repeatedly queried as example groups and examples are defined.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/metadata_filter.rb#151
+class RSpec::Core::FilterableItemRepository::QueryOptimized < ::RSpec::Core::FilterableItemRepository::UpdateOptimized
+  # @return [QueryOptimized] a new instance of QueryOptimized
+  #
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#155
+  def initialize(applies_predicate); end
+
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#164
+  def append(item, metadata); end
+
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#174
+  def delete(item, metadata); end
+
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#179
+  def items_for(metadata); end
+
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#169
+  def prepend(item, metadata); end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#217
+  def applicable_metadata_from(metadata); end
+
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#118
+  def find_items_for(request_meta); end
+
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#211
+  def handle_mutation(metadata); end
+
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#235
+  def proc_keys_from(metadata); end
+
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#203
+  def reconstruct_caches; end
+end
+
+# This implementation is simple, and is optimized for frequent
+# updates but rare queries. `append` and `prepend` do no extra
+# processing, and no internal memoization is done, since this
+# is not optimized for queries.
+#
+# This is ideal for use by a example or example group, which may
+# be updated multiple times with globally configured hooks, etc,
+# but will not be queried frequently by other examples or example
+# groups.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/metadata_filter.rb#98
+class RSpec::Core::FilterableItemRepository::UpdateOptimized
+  # @return [UpdateOptimized] a new instance of UpdateOptimized
+  #
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#101
+  def initialize(applies_predicate); end
+
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#106
+  def append(item, metadata); end
+
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#114
+  def delete(item, metadata); end
+
+  # Returns the value of attribute items_and_filters.
+  #
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#99
+  def items_and_filters; end
+
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#118
+  def items_for(request_meta); end
+
+  # source://rspec-core//lib/rspec/core/metadata_filter.rb#110
+  def prepend(item, metadata); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/flat_map.rb#4
+module RSpec::Core::FlatMap
+  private
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/flat_map.rb#6
+  def flat_map(array, &block); end
+
+  class << self
+    # :nocov:
+    #
+    # source://rspec-core//lib/rspec/core/flat_map.rb#6
+    def flat_map(array, &block); end
+  end
+end
+
+# ## Built-in Formatters
+#
+# * progress (default) - Prints dots for passing examples, `F` for failures, `*`
+#                        for pending.
+# * documentation - Prints the docstrings passed to `describe` and `it` methods
+#                   (and their aliases).
+# * html
+# * json - Useful for archiving data for subsequent analysis.
+#
+# The progress formatter is the default, but you can choose any one or more of
+# the other formatters by passing with the `--format` (or `-f` for short)
+# command-line option, e.g.
+#
+#     rspec --format documentation
+#
+# You can also send the output of multiple formatters to different streams, e.g.
+#
+#     rspec --format documentation --format html --out results.html
+#
+# This example sends the output of the documentation formatter to `$stdout`, and
+# the output of the html formatter to results.html.
+#
+# ## Custom Formatters
+#
+# You can tell RSpec to use a custom formatter by passing its path and name to
+# the `rspec` command. For example, if you define MyCustomFormatter in
+# path/to/my_custom_formatter.rb, you would type this command:
+#
+#     rspec --require path/to/my_custom_formatter.rb --format MyCustomFormatter
+#
+# The reporter calls every formatter with this protocol:
+#
+# * To start
+#   * `start(StartNotification)`
+# * Once per example group
+#   * `example_group_started(GroupNotification)`
+# * Once per example
+#   * `example_started(ExampleNotification)`
+# * One of these per example, depending on outcome
+#   * `example_passed(ExampleNotification)`
+#   * `example_failed(FailedExampleNotification)`
+#   * `example_pending(ExampleNotification)`
+# * Optionally at any time
+#   * `message(MessageNotification)`
+# * At the end of the suite
+#   * `stop(ExamplesNotification)`
+#   * `start_dump(NullNotification)`
+#   * `dump_pending(ExamplesNotification)`
+#   * `dump_failures(ExamplesNotification)`
+#   * `dump_summary(SummaryNotification)`
+#   * `seed(SeedNotification)`
+#   * `close(NullNotification)`
+#
+# Only the notifications to which you subscribe your formatter will be called
+# on your formatter. To subscribe your formatter use:
+# `RSpec::Core::Formatters#register` e.g.
+#
+# `RSpec::Core::Formatters.register FormatterClassName, :example_passed, :example_failed`
+#
+# We recommend you implement the methods yourself; for simplicity we provide the
+# default formatter output via our notification objects but if you prefer you
+# can subclass `RSpec::Core::Formatters::BaseTextFormatter` and override the
+# methods you wish to enhance.
+#
+# @see RSpec::Core::Formatters::BaseTextFormatter
+# @see RSpec::Core::Reporter
+#
+# source://rspec-core//lib/rspec/core/formatters/console_codes.rb#3
+module RSpec::Core::Formatters
+  class << self
+    # Register the formatter class
+    #
+    # @param formatter_class [Class] formatter class to register
+    # @param notifications [Array<Symbol>] one or more notifications to be
+    #   registered to the specified formatter
+    # @see RSpec::Core::Formatters::BaseFormatter
+    #
+    # source://rspec-core//lib/rspec/core/formatters.rb#86
+    def register(formatter_class, *notifications); end
+  end
+end
+
+# Contains common logic for formatters used by `--bisect` to communicate results
+# back to the bisect runner.
+#
+# Subclasses must define a `notify_results(all_example_ids, failed_example_ids)`
+# method.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/base_bisect_formatter.rb#12
+class RSpec::Core::Formatters::BaseBisectFormatter
+  # @return [BaseBisectFormatter] a new instance of BaseBisectFormatter
+  #
+  # source://rspec-core//lib/rspec/core/formatters/base_bisect_formatter.rb#17
+  def initialize(expected_failures); end
+
+  # source://rspec-core//lib/rspec/core/formatters/base_bisect_formatter.rb#23
+  def example_failed(notification); end
+
+  # source://rspec-core//lib/rspec/core/formatters/base_bisect_formatter.rb#27
+  def example_finished(notification); end
+
+  # source://rspec-core//lib/rspec/core/formatters/base_bisect_formatter.rb#37
+  def start_dump(_notification); end
+
+  class << self
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/formatters/base_bisect_formatter.rb#13
+    def inherited(formatter); end
+  end
+end
+
+# RSpec's built-in formatters are all subclasses of
+# RSpec::Core::Formatters::BaseFormatter.
+#
+# @see RSpec::Core::Formatters::BaseTextFormatter
+# @see RSpec::Core::Reporter
+# @see RSpec::Core::Formatters::Protocol
+#
+# source://rspec-core//lib/rspec/core/formatters/base_formatter.rb#13
+class RSpec::Core::Formatters::BaseFormatter
+  # @api public
+  # @param output [IO] the formatter output
+  # @return [BaseFormatter] a new instance of BaseFormatter
+  # @see RSpec::Core::Formatters::Protocol#initialize
+  #
+  # source://rspec-core//lib/rspec/core/formatters/base_formatter.rb#23
+  def initialize(output); end
+
+  # @api public
+  # @param _notification [NullNotification] (Ignored)
+  # @see RSpec::Core::Formatters::Protocol#close
+  #
+  # source://rspec-core//lib/rspec/core/formatters/base_formatter.rb#50
+  def close(_notification); end
+
+  # Returns the value of attribute example_group.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/base_formatter.rb#17
+  def example_group; end
+
+  # Sets the attribute example_group
+  #
+  # @param value the value to set the attribute example_group to.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/base_formatter.rb#17
+  def example_group=(_arg0); end
+
+  # @api public
+  # @param notification [GroupNotification] containing example_group
+  #   subclass of `RSpec::Core::ExampleGroup`
+  # @see RSpec::Core::Formatters::Protocol#example_group_started
+  #
+  # source://rspec-core//lib/rspec/core/formatters/base_formatter.rb#42
+  def example_group_started(notification); end
+
+  # Returns the value of attribute output.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/base_formatter.rb#18
+  def output; end
+
+  # @api public
+  # @param notification [StartNotification]
+  # @see RSpec::Core::Formatters::Protocol#start
+  #
+  # source://rspec-core//lib/rspec/core/formatters/base_formatter.rb#32
+  def start(notification); end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/formatters/base_formatter.rb#64
+  def output_supports_sync; end
+
+  # source://rspec-core//lib/rspec/core/formatters/base_formatter.rb#60
+  def restore_sync_output; end
+
+  # source://rspec-core//lib/rspec/core/formatters/base_formatter.rb#56
+  def start_sync_output; end
+end
+
+# Base for all of RSpec's built-in formatters. See
+# RSpec::Core::Formatters::BaseFormatter to learn more about all of the
+# methods called by the reporter.
+#
+# @see RSpec::Core::Formatters::BaseFormatter
+# @see RSpec::Core::Reporter
+#
+# source://rspec-core//lib/rspec/core/formatters/base_text_formatter.rb#12
+class RSpec::Core::Formatters::BaseTextFormatter < ::RSpec::Core::Formatters::BaseFormatter
+  # Invoked at the end of a suite run. Allows the formatter to do any
+  # tidying up, but be aware that formatter output streams may be used
+  # elsewhere so don't actually close them.
+  #
+  # @api public
+  # @param _notification [NullNotification] (Ignored)
+  #
+  # source://rspec-core//lib/rspec/core/formatters/base_text_formatter.rb#65
+  def close(_notification); end
+
+  # Dumps detailed information about each example failure.
+  #
+  # @api public
+  # @param notification [NullNotification]
+  #
+  # source://rspec-core//lib/rspec/core/formatters/base_text_formatter.rb#30
+  def dump_failures(notification); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/formatters/base_text_formatter.rb#47
+  def dump_pending(notification); end
+
+  # This method is invoked after the dumping of examples and failures.
+  # Each parameter is assigned to a corresponding attribute.
+  #
+  # @api public
+  # @param summary [SummaryNotification] containing duration,
+  #   example_count, failure_count and pending_count
+  #
+  # source://rspec-core//lib/rspec/core/formatters/base_text_formatter.rb#42
+  def dump_summary(summary); end
+
+  # Used by the reporter to send messages to the output stream.
+  #
+  # @api public
+  # @param notification [MessageNotification] containing message
+  #
+  # source://rspec-core//lib/rspec/core/formatters/base_text_formatter.rb#21
+  def message(notification); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/formatters/base_text_formatter.rb#53
+  def seed(notification); end
+end
+
+# Used by `--bisect`. When it shells out and runs a portion of the suite, it uses
+# this formatter as a means to have the status reported back to it, via DRb.
+#
+# Note that since DRb calls carry considerable overhead compared to normal
+# method calls, we try to minimize the number of DRb calls for perf reasons,
+# opting to communicate only at the start and the end of the run, rather than
+# after each example.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/bisect_drb_formatter.rb#15
+class RSpec::Core::Formatters::BisectDRbFormatter < ::RSpec::Core::Formatters::BaseBisectFormatter
+  # @return [BisectDRbFormatter] a new instance of BisectDRbFormatter
+  #
+  # source://rspec-core//lib/rspec/core/formatters/bisect_drb_formatter.rb#16
+  def initialize(_output); end
+
+  # source://rspec-core//lib/rspec/core/formatters/bisect_drb_formatter.rb#23
+  def notify_results(results); end
+end
+
+# ConsoleCodes provides helpers for formatting console output
+# with ANSI codes, e.g. color's and bold.
+#
+# source://rspec-core//lib/rspec/core/formatters/console_codes.rb#6
+module RSpec::Core::Formatters::ConsoleCodes
+  private
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/formatters/console_codes.rb#34
+  def config_colors_to_methods; end
+
+  # Fetches the correct code for the supplied symbol, or checks
+  # that a code is valid. Defaults to white (37).
+  #
+  # @param code_or_symbol [Symbol, Fixnum] Symbol or code to check
+  # @return [Fixnum] a console code
+  #
+  # source://rspec-core//lib/rspec/core/formatters/console_codes.rb#47
+  def console_code_for(code_or_symbol); end
+
+  # Wraps a piece of text in ANSI codes with the supplied code. Will
+  # only apply the control code if `RSpec.configuration.color_enabled?`
+  # returns true.
+  #
+  # @param text [String] the text to wrap
+  # @param code_or_symbol [Symbol, Fixnum] the desired control code
+  # @return [String] the wrapped text
+  #
+  # source://rspec-core//lib/rspec/core/formatters/console_codes.rb#66
+  def wrap(text, code_or_symbol); end
+
+  class << self
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/formatters/console_codes.rb#34
+    def config_colors_to_methods; end
+
+    # Fetches the correct code for the supplied symbol, or checks
+    # that a code is valid. Defaults to white (37).
+    #
+    # @param code_or_symbol [Symbol, Fixnum] Symbol or code to check
+    # @return [Fixnum] a console code
+    #
+    # source://rspec-core//lib/rspec/core/formatters/console_codes.rb#47
+    def console_code_for(code_or_symbol); end
+
+    # Wraps a piece of text in ANSI codes with the supplied code. Will
+    # only apply the control code if `RSpec.configuration.color_enabled?`
+    # returns true.
+    #
+    # @param text [String] the text to wrap
+    # @param code_or_symbol [Symbol, Fixnum] the desired control code
+    # @return [String] the wrapped text
+    #
+    # source://rspec-core//lib/rspec/core/formatters/console_codes.rb#66
+    def wrap(text, code_or_symbol); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/console_codes.rb#8
+RSpec::Core::Formatters::ConsoleCodes::VT100_CODES = T.let(T.unsafe(nil), Hash)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/console_codes.rb#29
+RSpec::Core::Formatters::ConsoleCodes::VT100_CODE_VALUES = T.let(T.unsafe(nil), Hash)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#7
+class RSpec::Core::Formatters::DeprecationFormatter
+  # @return [DeprecationFormatter] a new instance of DeprecationFormatter
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#12
+  def initialize(deprecation_stream, summary_stream); end
+
+  # Returns the value of attribute count.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#10
+  def count; end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#32
+  def deprecation(notification); end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#44
+  def deprecation_message_for(data); end
+
+  # Returns the value of attribute deprecation_stream.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#10
+  def deprecation_stream; end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#40
+  def deprecation_summary(_notification); end
+
+  # Returns the value of attribute deprecation_stream.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#10
+  def output; end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#20
+  def printer; end
+
+  # Returns the value of attribute summary_stream.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#10
+  def summary_stream; end
+end
+
+# source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#60
+RSpec::Core::Formatters::DeprecationFormatter::DEPRECATION_STREAM_NOTICE = T.let(T.unsafe(nil), String)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#135
+class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter
+  # @return [DelayedPrinter] a new instance of DelayedPrinter
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#140
+  def initialize(deprecation_stream, summary_stream, deprecation_formatter); end
+
+  # Returns the value of attribute deprecation_formatter.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#138
+  def deprecation_formatter; end
+
+  # Returns the value of attribute deprecation_stream.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#138
+  def deprecation_stream; end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#163
+  def deprecation_summary; end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#172
+  def print_deferred_deprecation_warnings; end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#148
+  def print_deprecation_message(data); end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#155
+  def stash_deprecation_message(deprecation_message); end
+
+  # Returns the value of attribute summary_stream.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#138
+  def summary_stream; end
+end
+
+# source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#136
+RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter::TOO_MANY_USES_LIMIT = T.let(T.unsafe(nil), Integer)
+
+# Wraps a File object and provides file-specific operations.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#196
+class RSpec::Core::Formatters::DeprecationFormatter::FileStream
+  # @return [FileStream] a new instance of FileStream
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#197
+  def initialize(file); end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#207
+  def puts(*args); end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#211
+  def summarize(summary_stream, deprecation_count); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#94
+class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage < ::Struct
+  # @return [GeneratedDeprecationMessage] a new instance of GeneratedDeprecationMessage
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#95
+  def initialize(data); end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#100
+  def to_s; end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#107
+  def too_many_warnings_message; end
+
+  # Returns the value of attribute type
+  #
+  # @return [Object] the current value of type
+  def type; end
+
+  # Sets the attribute type
+  #
+  # @param value [Object] the value to set the attribute type to.
+  # @return [Object] the newly set value
+  def type=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#113
+class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter
+  # @return [ImmediatePrinter] a new instance of ImmediatePrinter
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#116
+  def initialize(deprecation_stream, summary_stream, deprecation_formatter); end
+
+  # Returns the value of attribute deprecation_formatter.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#114
+  def deprecation_formatter; end
+
+  # Returns the value of attribute deprecation_stream.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#114
+  def deprecation_stream; end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#128
+  def deprecation_summary; end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#123
+  def print_deprecation_message(data); end
+
+  # Returns the value of attribute summary_stream.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#114
+  def summary_stream; end
+end
+
+# source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#52
+RSpec::Core::Formatters::DeprecationFormatter::RAISE_ERROR_CONFIG_NOTICE = T.let(T.unsafe(nil), String)
+
+# Not really a stream, but is usable in place of one.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#184
+class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream
+  # @raise [DeprecationError]
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#185
+  def puts(message); end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#189
+  def summarize(summary_stream, deprecation_count); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#66
+class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage < ::Struct
+  # @return [SpecifiedDeprecationMessage] a new instance of SpecifiedDeprecationMessage
+  #
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#67
+  def initialize(data); end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#72
+  def to_s; end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#76
+  def too_many_warnings_message; end
+
+  # Returns the value of attribute type
+  #
+  # @return [Object] the current value of type
+  def type; end
+
+  # Sets the attribute type
+  #
+  # @param value [Object] the value to set the attribute type to.
+  # @return [Object] the newly set value
+  def type=(_); end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#88
+  def deprecation_type_for(data); end
+
+  # source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#82
+  def output_formatted(str); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rspec-core//lib/rspec/core/formatters/deprecation_formatter.rb#62
+RSpec::Core::Formatters::DeprecationFormatter::TOO_MANY_WARNINGS_NOTICE = T.let(T.unsafe(nil), String)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#8
+class RSpec::Core::Formatters::DocumentationFormatter < ::RSpec::Core::Formatters::BaseTextFormatter
+  # @return [DocumentationFormatter] a new instance of DocumentationFormatter
+  #
+  # source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#12
+  def initialize(output); end
+
+  # source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#50
+  def example_failed(failure); end
+
+  # source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#31
+  def example_group_finished(_notification); end
+
+  # source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#24
+  def example_group_started(notification); end
+
+  # source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#35
+  def example_passed(passed); end
+
+  # source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#42
+  def example_pending(pending); end
+
+  # source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#20
+  def example_started(_notification); end
+
+  # source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#57
+  def message(notification); end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#96
+  def current_indentation(offset = T.unsafe(nil)); end
+
+  # source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#85
+  def failure_output(example); end
+
+  # source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#67
+  def flush_messages; end
+
+  # source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#91
+  def next_failure_index; end
+
+  # source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#75
+  def passed_output(example); end
+
+  # source://rspec-core//lib/rspec/core/formatters/documentation_formatter.rb#79
+  def pending_output(example, message); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#11
+class RSpec::Core::Formatters::ExceptionPresenter
+  # @return [ExceptionPresenter] a new instance of ExceptionPresenter
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#16
+  def initialize(exception, example, options = T.unsafe(nil)); end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#78
+  def colorized_formatted_backtrace(colorizer = T.unsafe(nil)); end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#33
+  def colorized_message_lines(colorizer = T.unsafe(nil)); end
+
+  # Returns the value of attribute description.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#12
+  def description; end
+
+  # Returns the value of attribute example.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#12
+  def example; end
+
+  # Returns the value of attribute exception.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#12
+  def exception; end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#39
+  def formatted_backtrace(exception = T.unsafe(nil)); end
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#45
+  def formatted_cause(exception); end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#84
+  def fully_formatted(failure_number, colorizer = T.unsafe(nil)); end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#89
+  def fully_formatted_lines(failure_number, colorizer); end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#29
+  def message_lines; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#226
+  def add_shared_group_lines(lines, colorizer); end
+
+  # Returns the value of attribute backtrace_formatter.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#12
+  def backtrace_formatter; end
+
+  # Returns the value of attribute detail_formatter.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#12
+  def detail_formatter; end
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#286
+  def encoded_description(description); end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#120
+  def encoded_string(string); end
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#116
+  def encoding_of(string); end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#298
+  def exception_backtrace; end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#150
+  def exception_class_name(exception = T.unsafe(nil)); end
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#204
+  def exception_lines; end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#185
+  def exception_message_string(exception); end
+
+  # Returns the value of attribute extra_detail_formatter.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#12
+  def extra_detail_formatter; end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#215
+  def extra_failure_lines; end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#156
+  def failure_lines; end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#170
+  def failure_slash_error_lines; end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#104
+  def final_exception(exception, previous = T.unsafe(nil)); end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#262
+  def find_failed_line; end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#277
+  def formatted_message_and_backtrace(colorizer); end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#134
+  def indent_lines(lines, failure_number); end
+
+  # Returns the value of attribute message_color.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#12
+  def message_color; end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#236
+  def read_failed_lines; end
+end
+
+# Configuring the `ExceptionPresenter` with the right set of options to handle
+# pending vs failed vs skipped and aggregated (or not) failures is not simple.
+# This class takes care of building an appropriate `ExceptionPresenter` for the
+# provided example.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#307
+class RSpec::Core::Formatters::ExceptionPresenter::Factory
+  # @return [Factory] a new instance of Factory
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#314
+  def initialize(example); end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#308
+  def build; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#369
+  def multiple_exception_summarizer(exception, prior_detail_formatter, color); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#365
+  def multiple_exceptions_error?(exception); end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#324
+  def options; end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#328
+  def pending_options; end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#390
+  def sub_failure_list_formatter(exception, message_color); end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#349
+  def with_multiple_error_options_as_needed(exception, options); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#423
+class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater
+  # @return [CommonBacktraceTruncater] a new instance of CommonBacktraceTruncater
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#424
+  def initialize(parent); end
+
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#428
+  def with_truncated_backtrace(child); end
+end
+
+# Used to prevent a confusing backtrace from showing up from the `aggregate_failures`
+# block declared for `:aggregate_failures` metadata.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#416
+module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter
+  class << self
+    # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#417
+    def format_backtrace(*_arg0); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#448
+RSpec::Core::Formatters::ExceptionPresenter::PENDING_DETAIL_FORMATTER = T.let(T.unsafe(nil), Proc)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/failure_list_formatter.rb#7
+class RSpec::Core::Formatters::FailureListFormatter < ::RSpec::Core::Formatters::BaseFormatter
+  # Discard profile and messages
+  #
+  # These outputs are not really relevant in the context of this failure
+  # list formatter.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/failure_list_formatter.rb#18
+  def dump_profile(_profile); end
+
+  # source://rspec-core//lib/rspec/core/formatters/failure_list_formatter.rb#10
+  def example_failed(failure); end
+
+  # source://rspec-core//lib/rspec/core/formatters/failure_list_formatter.rb#19
+  def message(_message); end
+end
+
+# Formatter for providing message output as a fallback when no other
+# profiler implements #message
+#
+# @api private
+#
+# source://rspec-core//lib/rspec/core/formatters/fallback_message_formatter.rb#7
+class RSpec::Core::Formatters::FallbackMessageFormatter
+  # @api private
+  # @return [FallbackMessageFormatter] a new instance of FallbackMessageFormatter
+  #
+  # source://rspec-core//lib/rspec/core/formatters/fallback_message_formatter.rb#10
+  def initialize(output); end
+
+  # Used by the reporter to send messages to the output stream.
+  #
+  # @api public
+  # @param notification [MessageNotification] containing message
+  #
+  # source://rspec-core//lib/rspec/core/formatters/fallback_message_formatter.rb#22
+  def message(notification); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/formatters/fallback_message_formatter.rb#15
+  def output; end
+end
+
+# Formatters helpers.
+#
+# source://rspec-core//lib/rspec/core/formatters/helpers.rb#7
+module RSpec::Core::Formatters::Helpers
+  class << self
+    # Formats seconds into a human-readable string.
+    #
+    # @api private
+    # @example
+    #   format_duration(1) #=>  "1 minute 1 second"
+    #   format_duration(135.14) #=> "2 minutes 15.14 seconds"
+    # @param duration [Float, Fixnum] in seconds
+    # @return [String] human-readable time
+    #
+    # source://rspec-core//lib/rspec/core/formatters/helpers.rb#24
+    def format_duration(duration); end
+
+    # Formats seconds to have 5 digits of precision with trailing zeros
+    # removed if the number is less than 1 or with 2 digits of precision if
+    # the number is greater than zero.
+    #
+    # The precision used is set in {Helpers::SUB_SECOND_PRECISION} and
+    # {Helpers::DEFAULT_PRECISION}.
+    #
+    # @api private
+    # @example
+    #   format_seconds(0.000006) #=> "0.00001"
+    #   format_seconds(0.020000) #=> "0.02"
+    #   format_seconds(1.00000000001) #=> "1"
+    # @param float [Float]
+    # @return [String] formatted float
+    # @see #strip_trailing_zeroes
+    #
+    # source://rspec-core//lib/rspec/core/formatters/helpers.rb#60
+    def format_seconds(float, precision = T.unsafe(nil)); end
+
+    # Given a list of example ids, organizes them into a compact, ordered list.
+    #
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core/formatters/helpers.rb#102
+    def organize_ids(ids); end
+
+    # Pluralize a word based on a count.
+    #
+    # @api private
+    # @param count [Fixnum] number of objects
+    # @param string [String] word to be pluralized
+    # @return [String] pluralized word
+    #
+    # source://rspec-core//lib/rspec/core/formatters/helpers.rb#88
+    def pluralize(count, string); end
+
+    private
+
+    # Remove trailing zeros from a string.
+    #
+    # Only remove trailing zeros after a decimal place.
+    # see: http://rubular.com/r/ojtTydOgpn
+    #
+    # @api private
+    # @param string [String] string with trailing zeros
+    # @return [String] string with trailing zeros removed
+    #
+    # source://rspec-core//lib/rspec/core/formatters/helpers.rb#76
+    def strip_trailing_zeroes(string); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/helpers.rb#12
+RSpec::Core::Formatters::Helpers::DEFAULT_PRECISION = T.let(T.unsafe(nil), Integer)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/helpers.rb#9
+RSpec::Core::Formatters::Helpers::SUB_SECOND_PRECISION = T.let(T.unsafe(nil), Integer)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/html_formatter.rb#8
+class RSpec::Core::Formatters::HtmlFormatter < ::RSpec::Core::Formatters::BaseFormatter
+  # @return [HtmlFormatter] a new instance of HtmlFormatter
+  #
+  # source://rspec-core//lib/rspec/core/formatters/html_formatter.rb#13
+  def initialize(output); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_formatter.rb#103
+  def dump_summary(summary); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_formatter.rb#55
+  def example_failed(failure); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_formatter.rb#28
+  def example_group_started(notification); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_formatter.rb#49
+  def example_passed(passed); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_formatter.rb#93
+  def example_pending(pending); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_formatter.rb#45
+  def example_started(_notification); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_formatter.rb#22
+  def start(notification); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_formatter.rb#40
+  def start_dump(_notification); end
+
+  private
+
+  # The number of the currently running example_group.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/html_formatter.rb#120
+  def example_group_number; end
+
+  # The number of the currently running example (a global counter).
+  #
+  # source://rspec-core//lib/rspec/core/formatters/html_formatter.rb#125
+  def example_number; end
+
+  # Override this method if you wish to output extra HTML for a failed
+  # spec. For example, you could output links to images or other files
+  # produced during the specs.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/html_formatter.rb#141
+  def extra_failure_content(failure); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_formatter.rb#130
+  def percent_done; end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/html_printer.rb#7
+class RSpec::Core::Formatters::HtmlPrinter
+  include ::ERB::Escape
+  include ::ERB::Util
+
+  # @return [HtmlPrinter] a new instance of HtmlPrinter
+  #
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#9
+  def initialize(output); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#79
+  def flush; end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#96
+  def make_example_group_header_red(group_id); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#103
+  def make_example_group_header_yellow(group_id); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#88
+  def make_header_red; end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#92
+  def make_header_yellow; end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#83
+  def move_progress(percent_done); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#36
+  def print_example_failed(pending_fixed, description, run_time, failure_id, exception, extra_content); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#18
+  def print_example_group_end; end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#23
+  def print_example_group_start(group_id, description, number_of_parents); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#29
+  def print_example_passed(description, run_time); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#53
+  def print_example_pending(description, pending_message); end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#13
+  def print_html_start; end
+
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#59
+  def print_summary(duration, example_count, failure_count, pending_count); end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/formatters/html_printer.rb#112
+  def indentation_style(number_of_parents); end
+end
+
+# source://rspec-core//lib/rspec/core/formatters/html_printer.rb#140
+RSpec::Core::Formatters::HtmlPrinter::GLOBAL_SCRIPTS = T.let(T.unsafe(nil), String)
+
+# source://rspec-core//lib/rspec/core/formatters/html_printer.rb#218
+RSpec::Core::Formatters::HtmlPrinter::GLOBAL_STYLES = T.let(T.unsafe(nil), String)
+
+# source://rspec-core//lib/rspec/core/formatters/html_printer.rb#382
+RSpec::Core::Formatters::HtmlPrinter::HTML_HEADER = T.let(T.unsafe(nil), String)
+
+# source://rspec-core//lib/rspec/core/formatters/html_printer.rb#116
+RSpec::Core::Formatters::HtmlPrinter::REPORT_HEADER = T.let(T.unsafe(nil), String)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/json_formatter.rb#8
+class RSpec::Core::Formatters::JsonFormatter < ::RSpec::Core::Formatters::BaseFormatter
+  # @return [JsonFormatter] a new instance of JsonFormatter
+  #
+  # source://rspec-core//lib/rspec/core/formatters/json_formatter.rb#13
+  def initialize(output); end
+
+  # source://rspec-core//lib/rspec/core/formatters/json_formatter.rb#56
+  def close(_notification); end
+
+  # source://rspec-core//lib/rspec/core/formatters/json_formatter.rb#60
+  def dump_profile(profile); end
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters/json_formatter.rb#79
+  def dump_profile_slowest_example_groups(profile); end
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters/json_formatter.rb#67
+  def dump_profile_slowest_examples(profile); end
+
+  # source://rspec-core//lib/rspec/core/formatters/json_formatter.rb#24
+  def dump_summary(summary); end
+
+  # source://rspec-core//lib/rspec/core/formatters/json_formatter.rb#20
+  def message(notification); end
+
+  # Returns the value of attribute output_hash.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/json_formatter.rb#11
+  def output_hash; end
+
+  # source://rspec-core//lib/rspec/core/formatters/json_formatter.rb#51
+  def seed(notification); end
+
+  # source://rspec-core//lib/rspec/core/formatters/json_formatter.rb#35
+  def stop(group_notification); end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/formatters/json_formatter.rb#88
+  def format_example(example); end
+end
+
+# `RSpec::Core::Formatters::Loader` is an internal class for
+# managing formatters used by a particular configuration. It is
+# not expected to be used directly, but only through the configuration
+# interface.
+#
+# @api private
+#
+# source://rspec-core//lib/rspec/core/formatters.rb#96
+class RSpec::Core::Formatters::Loader
+  # @api private
+  # @return [Loader] a new instance of Loader
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#105
+  def initialize(reporter); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#144
+  def add(formatter_to_use, *paths); end
+
+  # @api private
+  # @return [String] the default formatter to setup, defaults to `progress`
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#118
+  def default_formatter; end
+
+  # @api private
+  # @return [String] the default formatter to setup, defaults to `progress`
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#118
+  def default_formatter=(_arg0); end
+
+  # @api private
+  # @return [Array] the loaded formatters
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#112
+  def formatters; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#121
+  def prepare_default(output_stream, deprecation_stream); end
+
+  # @api private
+  # @return [Reporter] the reporter
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#115
+  def reporter; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#126
+  def setup_default(output_stream, deprecation_stream); end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#211
+  def built_in_formatter(key); end
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#234
+  def custom_formatter(formatter_ref); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#195
+  def duplicate_formatter_exists?(new_formatter); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#207
+  def existing_formatter_implements?(notification); end
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#181
+  def find_formatter(formatter_to_use); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#202
+  def has_matching_output?(formatter, new_formatter); end
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#228
+  def notifications_for(formatter_class); end
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#269
+  def open_stream(path_or_wrapper); end
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#250
+  def path_for(const_ref); end
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#188
+  def register(formatter, notifications); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#246
+  def string_const?(str); end
+
+  # activesupport/lib/active_support/inflector/methods.rb, line 48
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#259
+  def underscore(camel_cased_word); end
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters.rb#254
+  def underscore_with_fix_for_non_standard_rspec_naming(string); end
+
+  class << self
+    # Internal formatters are stored here when loaded.
+    #
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core/formatters.rb#100
+    def formatters; end
+  end
+end
+
+# Formatter for providing profile output.
+#
+# @api private
+#
+# source://rspec-core//lib/rspec/core/formatters/profile_formatter.rb#8
+class RSpec::Core::Formatters::ProfileFormatter
+  # @api private
+  # @return [ProfileFormatter] a new instance of ProfileFormatter
+  #
+  # source://rspec-core//lib/rspec/core/formatters/profile_formatter.rb#11
+  def initialize(output); end
+
+  # This method is invoked after the dumping the summary if profiling is
+  # enabled.
+  #
+  # @api public
+  # @param profile [ProfileNotification] containing duration,
+  #   slowest_examples and slowest_example_groups
+  #
+  # source://rspec-core//lib/rspec/core/formatters/profile_formatter.rb#25
+  def dump_profile(profile); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/formatters/profile_formatter.rb#16
+  def output; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters/profile_formatter.rb#62
+  def bold(text); end
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters/profile_formatter.rb#44
+  def dump_profile_slowest_example_groups(profile); end
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters/profile_formatter.rb#32
+  def dump_profile_slowest_examples(profile); end
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/formatters/profile_formatter.rb#57
+  def format_caller(caller_info); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/progress_formatter.rb#8
+class RSpec::Core::Formatters::ProgressFormatter < ::RSpec::Core::Formatters::BaseTextFormatter
+  # source://rspec-core//lib/rspec/core/formatters/progress_formatter.rb#19
+  def example_failed(_notification); end
+
+  # source://rspec-core//lib/rspec/core/formatters/progress_formatter.rb#11
+  def example_passed(_notification); end
+
+  # source://rspec-core//lib/rspec/core/formatters/progress_formatter.rb#15
+  def example_pending(_notification); end
+
+  # source://rspec-core//lib/rspec/core/formatters/progress_formatter.rb#23
+  def start_dump(_notification); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#5
+class RSpec::Core::Formatters::SnippetExtractor
+  # @return [SnippetExtractor] a new instance of SnippetExtractor
+  #
+  # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#35
+  def initialize(source, beginning_line_number, max_line_count = T.unsafe(nil)); end
+
+  # Returns the value of attribute beginning_line_number.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#24
+  def beginning_line_number; end
+
+  # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#41
+  def expression_lines; end
+
+  # Returns the value of attribute max_line_count.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#24
+  def max_line_count; end
+
+  # Returns the value of attribute source.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#24
+  def source; end
+
+  private
+
+  # @raise [NoExpressionAtLineError]
+  #
+  # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#95
+  def expression_node; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#107
+  def expression_outmost_node?(node); end
+
+  # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#55
+  def line_range_of_expression; end
+
+  # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#87
+  def line_range_of_location_nodes_in_expression; end
+
+  # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#117
+  def location_nodes_at_beginning_line; end
+
+  # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#70
+  def unclosed_tokens_in_line_range(line_range); end
+
+  class << self
+    # :nocov:
+    #
+    # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#26
+    def extract_expression_lines_at(file_path, beginning_line_number, max_line_count = T.unsafe(nil)); end
+
+    # @raise [NoSuchLineError]
+    #
+    # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#9
+    def extract_line_at(file_path, line_number); end
+
+    # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#128
+    def least_indentation_from(lines); end
+
+    # @raise [NoSuchFileError]
+    #
+    # source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#16
+    def source_from_file(path); end
+  end
+end
+
+# source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#22
+class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError < ::StandardError; end
+
+# source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#6
+class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError < ::StandardError; end
+
+# source://rspec-core//lib/rspec/core/formatters/snippet_extractor.rb#7
+class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError < ::StandardError; end
+
+# Provides terminal syntax highlighting of code snippets
+# when coderay is available.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/syntax_highlighter.rb#7
+class RSpec::Core::Formatters::SyntaxHighlighter
+  # @return [SyntaxHighlighter] a new instance of SyntaxHighlighter
+  #
+  # source://rspec-core//lib/rspec/core/formatters/syntax_highlighter.rb#8
+  def initialize(configuration); end
+
+  # source://rspec-core//lib/rspec/core/formatters/syntax_highlighter.rb#12
+  def highlight(lines); end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/formatters/syntax_highlighter.rb#50
+  def color_enabled_implementation; end
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/formatters/syntax_highlighter.rb#44
+  def implementation; end
+
+  class << self
+    # source://rspec-core//lib/rspec/core/formatters/syntax_highlighter.rb#18
+    def attempt_to_add_rspec_terms_to_coderay_keywords; end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/syntax_highlighter.rb#61
+module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
+  class << self
+    # source://rspec-core//lib/rspec/core/formatters/syntax_highlighter.rb#64
+    def highlight_syntax(lines); end
+  end
+end
+
+# source://rspec-core//lib/rspec/core/formatters/syntax_highlighter.rb#62
+RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation::RESET_CODE = T.let(T.unsafe(nil), String)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/syntax_highlighter.rb#78
+module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
+  class << self
+    # source://rspec-core//lib/rspec/core/formatters/syntax_highlighter.rb#79
+    def highlight_syntax(lines); end
+  end
+end
+
+# Not sure why, but our code above (and/or coderay itself) does not work
+# on Windows, so we disable the feature on Windows.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/syntax_highlighter.rb#87
+RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
+
+# Mixin that makes the including class imitate a hash for backwards
+# compatibility. The including class should use `attr_accessor` to
+# declare attributes.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/metadata.rb#349
+module RSpec::Core::HashImitatable
+  mixes_in_class_methods ::RSpec::Core::HashImitatable::ClassMethods
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def <(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def <=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def >(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def >=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#388
+  def [](key); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#398
+  def []=(key, value); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def all?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def any?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def assoc(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def chain(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def chunk(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def chunk_while(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def clear(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def collect(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def collect_concat(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def compact(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def compact!(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def compare_by_identity(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def compare_by_identity?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def count(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def cycle(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def deconstruct_keys(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def default(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def default=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def default_proc(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def default_proc=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def delete(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def delete_if(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def detect(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def dig(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def drop(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def drop_while(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def each(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def each_cons(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def each_entry(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def each_key(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def each_pair(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def each_slice(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def each_value(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def each_with_index(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def each_with_object(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def empty?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def entries(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def except(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def fetch(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def fetch_values(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def filter(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def filter!(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def filter_map(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def find(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def find_all(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def find_index(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def first(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def flat_map(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def flatten(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def grep(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def grep_v(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def group_by(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def has_key?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def has_value?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def include?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def inject(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def invert(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def keep_if(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def key(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def key?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def keys(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def lazy(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def length(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def map(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def max(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def max_by(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def member?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def merge(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def merge!(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def min(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def min_by(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def minmax(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def minmax_by(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def none?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def one?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def partition(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def rassoc(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def reduce(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def rehash(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def reject(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def reject!(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def replace(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def reverse_each(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def save_plist(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def select(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def select!(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def shift(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def size(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def slice(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def slice_after(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def slice_before(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def slice_when(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def sort(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def sort_by(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def store(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def sum(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def take(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def take_while(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def tally(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def to_a(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#354
+  def to_h; end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def to_hash(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def to_plist(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def to_proc(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def to_set(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def transform_keys(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def transform_keys!(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def transform_values(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def transform_values!(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def uniq(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def update(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def value?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def values(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def values_at(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#367
+  def zip(*args, &block); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#414
+  def directly_supports_attribute?(name); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#410
+  def extra_hash_attributes; end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#418
+  def get_value(name); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#426
+  def hash_for_delegation; end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#430
+  def issue_deprecation(_method_name, *_args); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#422
+  def set_value(name, value); end
+
+  class << self
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/metadata.rb#350
+    def included(klass); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/metadata.rb#435
+module RSpec::Core::HashImitatable::ClassMethods
+  # source://rspec-core//lib/rspec/core/metadata.rb#440
+  def attr_accessor(*names); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#436
+  def hash_attribute_names; end
+end
+
+# Provides `before`, `after` and `around` hooks as a means of
+# supporting common setup and teardown. This module is extended
+# onto {ExampleGroup}, making the methods available from any `describe`
+# or `context` block and included in {Configuration}, making them
+# available off of the configuration object to define global setup
+# or teardown logic.
+#
+# source://rspec-core//lib/rspec/core/hooks.rb#9
+module RSpec::Core::Hooks
+  # Declare a block of code to be run after each example (using `:example`)
+  # or once after all examples n the context (using `:context`). See
+  # {#before} for more information about ordering.
+  #
+  # ### Exceptions
+  #
+  # `after` hooks are guaranteed to run even when there are exceptions in
+  # `before` hooks or examples. When an exception is raised in an after
+  # block, the exception is captured for later reporting, and subsequent
+  # `after` blocks are run.
+  #
+  # ### Order
+  #
+  # `after` hooks are stored in three scopes, which are run in order:
+  # `:example`, `:context`, and `:suite`. They can also be declared in
+  # several different places: `RSpec.configure`, a parent group, the current
+  # group. They are run in the following order:
+  #
+  #     after(:example) # Declared in the current group.
+  #     after(:example) # Declared in a parent group.
+  #     after(:example) # Declared in RSpec.configure.
+  #     after(:context) # Declared in the current group.
+  #     after(:context) # Declared in a parent group.
+  #     after(:context) # Declared in RSpec.configure.
+  #     after(:suite)   # Declared in RSpec.configure.
+  #
+  # This is the reverse of the order in which `before` hooks are run.
+  # Similarly, if more than one `after` is declared within any example
+  # group, they are run in reverse order of that in which they are declared.
+  # Also `around` hooks will run after any `after` example hooks are
+  # invoked but before any `after` context hooks.
+  #
+  # @api public
+  # @note The `:suite` scope is only supported for hooks registered on
+  #   `RSpec.configuration` since they exist independently of any
+  #   example or example group.
+  # @note The `:example` and `:context` scopes are also available as
+  #   `:each` and `:all`, respectively. Use whichever you prefer.
+  # @overload after
+  # @overload after
+  # @overload after
+  # @overload after
+  # @see #before
+  # @see #around
+  # @see ExampleGroup
+  # @see SharedContext
+  # @see SharedExampleGroup
+  # @see Configuration
+  #
+  # source://rspec-core//lib/rspec/core/hooks.rb#277
+  def after(*args, &block); end
+
+  # Adds `block` to the back of the list of `after` blocks in the same
+  # scope (`:example`, `:context`, or `:suite`).
+  #
+  # See {#after} for scoping semantics.
+  #
+  # source://rspec-core//lib/rspec/core/hooks.rb#287
+  def append_after(*args, &block); end
+
+  # Declare a block of code to be run before each example (using `:example`)
+  # or once before any example (using `:context`). These are usually
+  # declared directly in the {ExampleGroup} to which they apply, but they
+  # can also be shared across multiple groups.
+  #
+  # You can also use `before(:suite)` to run a block of code before any
+  # example groups are run. This should be declared in {RSpec.configure}.
+  #
+  # Instance variables declared in `before(:example)` or `before(:context)`
+  # are accessible within each example.
+  #
+  # ### Order
+  #
+  # `before` hooks are stored in three scopes, which are run in order:
+  # `:suite`, `:context`, and `:example`. They can also be declared in
+  # several different places: `RSpec.configure`, a parent group, the current
+  # group. They are run in the following order:
+  #
+  #     before(:suite)    # Declared in RSpec.configure.
+  #     before(:context)  # Declared in RSpec.configure.
+  #     before(:context)  # Declared in a parent group.
+  #     before(:context)  # Declared in the current group.
+  #     before(:example)  # Declared in RSpec.configure.
+  #     before(:example)  # Declared in a parent group.
+  #     before(:example)  # Declared in the current group.
+  #
+  # If more than one `before` is declared within any one example group, they
+  # are run in the order in which they are declared. Any `around` hooks will
+  # execute after `before` context hooks but before any `before` example
+  # hook regardless of where they are declared.
+  #
+  # ### Conditions
+  #
+  # When you add a conditions hash to `before(:example)` or
+  # `before(:context)`, RSpec will only apply that hook to groups or
+  # examples that match the conditions. e.g.
+  #
+  #     RSpec.configure do |config|
+  #       config.before(:example, :authorized => true) do
+  #         log_in_as :authorized_user
+  #       end
+  #     end
+  #
+  #     RSpec.describe Something, :authorized => true do
+  #       # The before hook will run in before each example in this group.
+  #     end
+  #
+  #     RSpec.describe SomethingElse do
+  #       it "does something", :authorized => true do
+  #         # The before hook will run before this example.
+  #       end
+  #
+  #       it "does something else" do
+  #         # The hook will not run before this example.
+  #       end
+  #     end
+  #
+  # Note that filtered config `:context` hooks can still be applied
+  # to individual examples that have matching metadata. Just like
+  # Ruby's object model is that every object has a singleton class
+  # which has only a single instance, RSpec's model is that every
+  # example has a singleton example group containing just the one
+  # example.
+  #
+  # ### Warning: `before(:suite, :with => :conditions)`
+  #
+  # The conditions hash is used to match against specific examples. Since
+  # `before(:suite)` is not run in relation to any specific example or
+  # group, conditions passed along with `:suite` are effectively ignored.
+  #
+  # ### Exceptions
+  #
+  # When an exception is raised in a `before` block, RSpec skips any
+  # subsequent `before` blocks and the example, but runs all of the
+  # `after(:example)` and `after(:context)` hooks.
+  #
+  # ### Warning: implicit before blocks
+  #
+  # `before` hooks can also be declared in shared contexts which get
+  # included implicitly either by you or by extension libraries. Since
+  # RSpec runs these in the order in which they are declared within each
+  # scope, load order matters, and can lead to confusing results when one
+  # before block depends on state that is prepared in another before block
+  # that gets run later.
+  #
+  # ### Warning: `before(:context)`
+  #
+  # It is very tempting to use `before(:context)` to speed things up, but we
+  # recommend that you avoid this as there are a number of gotchas, as well
+  # as things that simply don't work.
+  #
+  # #### Context
+  #
+  # `before(:context)` is run in an example that is generated to provide
+  # group context for the block.
+  #
+  # #### Instance variables
+  #
+  # Instance variables declared in `before(:context)` are shared across all
+  # the examples in the group. This means that each example can change the
+  # state of a shared object, resulting in an ordering dependency that can
+  # make it difficult to reason about failures.
+  #
+  # #### Unsupported RSpec constructs
+  #
+  # RSpec has several constructs that reset state between each example
+  # automatically. These are not intended for use from within
+  # `before(:context)`:
+  #
+  #   * `let` declarations
+  #   * `subject` declarations
+  #   * Any mocking, stubbing or test double declaration
+  #
+  # ### other frameworks
+  #
+  # Mock object frameworks and database transaction managers (like
+  # ActiveRecord) are typically designed around the idea of setting up
+  # before an example, running that one example, and then tearing down. This
+  # means that mocks and stubs can (sometimes) be declared in
+  # `before(:context)`, but get torn down before the first real example is
+  # ever run.
+  #
+  # You _can_ create database-backed model objects in a `before(:context)`
+  # in rspec-rails, but it will not be wrapped in a transaction for you, so
+  # you are on your own to clean up in an `after(:context)` block.
+  #
+  # @api public
+  # @example before(:example) declared in an {ExampleGroup}
+  #   RSpec.describe Thing do
+  #   before(:example) do
+  #   @thing = Thing.new
+  #   end
+  #
+  #   it "does something" do
+  #   # Here you can access @thing.
+  #   end
+  #   end
+  # @example before(:context) declared in an {ExampleGroup}
+  #   RSpec.describe Parser do
+  #   before(:context) do
+  #   File.open(file_to_parse, 'w') do |f|
+  #   f.write <<-CONTENT
+  #   stuff in the file
+  #   CONTENT
+  #   end
+  #   end
+  #
+  #   it "parses the file" do
+  #   Parser.parse(file_to_parse)
+  #   end
+  #
+  #   after(:context) do
+  #   File.delete(file_to_parse)
+  #   end
+  #   end
+  # @note The `:example` and `:context` scopes are also available as
+  #   `:each` and `:all`, respectively. Use whichever you prefer.
+  # @note The `:suite` scope is only supported for hooks registered on
+  #   `RSpec.configuration` since they exist independently of any
+  #   example or example group.
+  # @overload before
+  # @overload before
+  # @overload before
+  # @overload before
+  # @see #after
+  # @see #around
+  # @see ExampleGroup
+  # @see SharedContext
+  # @see SharedExampleGroup
+  # @see Configuration
+  #
+  # source://rspec-core//lib/rspec/core/hooks.rb#200
+  def append_before(*args, &block); end
+
+  # Declare a block of code, parts of which will be run before and parts
+  # after the example. It is your responsibility to run the example:
+  #
+  #     around(:example) do |ex|
+  #       # Do some stuff before.
+  #       ex.run
+  #       # Do some stuff after.
+  #     end
+  #
+  # The yielded example aliases `run` with `call`, which lets you treat it
+  # like a `Proc`. This is especially handy when working with libraries
+  # that manage their own setup and teardown using a block or proc syntax,
+  # e.g.
+  #
+  #     around(:example) {|ex| Database.transaction(&ex)}
+  #     around(:example) {|ex| FakeFS(&ex)}
+  #
+  # ### Order
+  #
+  # The `around` hooks execute surrounding an example and its hooks.
+  #
+  # This means after any `before` context hooks, but before any `before`
+  # example hooks, and similarly after any `after` example hooks but before
+  # any `after` context hooks.
+  #
+  # They are not a synonym for `before`/`after`.
+  #
+  # @api public
+  # @note `:example`/`:each` is the only supported scope.
+  # @note the syntax of `around` is similar to that of `before` and `after`
+  #   but the semantics are quite different. `before` and `after` hooks are
+  #   run in the context of the examples with which they are associated,
+  #   whereas `around` hooks are actually responsible for running the
+  #   examples. Consequently, `around` hooks do not have direct access to
+  #   resources that are made available within the examples and their
+  #   associated `before` and `after` hooks.
+  # @overload around
+  # @overload around
+  # @overload around
+  # @overload around
+  # @yield [Example] the example to run
+  #
+  # source://rspec-core//lib/rspec/core/hooks.rb#349
+  def around(*args, &block); end
+
+  # Declare a block of code to be run before each example (using `:example`)
+  # or once before any example (using `:context`). These are usually
+  # declared directly in the {ExampleGroup} to which they apply, but they
+  # can also be shared across multiple groups.
+  #
+  # You can also use `before(:suite)` to run a block of code before any
+  # example groups are run. This should be declared in {RSpec.configure}.
+  #
+  # Instance variables declared in `before(:example)` or `before(:context)`
+  # are accessible within each example.
+  #
+  # ### Order
+  #
+  # `before` hooks are stored in three scopes, which are run in order:
+  # `:suite`, `:context`, and `:example`. They can also be declared in
+  # several different places: `RSpec.configure`, a parent group, the current
+  # group. They are run in the following order:
+  #
+  #     before(:suite)    # Declared in RSpec.configure.
+  #     before(:context)  # Declared in RSpec.configure.
+  #     before(:context)  # Declared in a parent group.
+  #     before(:context)  # Declared in the current group.
+  #     before(:example)  # Declared in RSpec.configure.
+  #     before(:example)  # Declared in a parent group.
+  #     before(:example)  # Declared in the current group.
+  #
+  # If more than one `before` is declared within any one example group, they
+  # are run in the order in which they are declared. Any `around` hooks will
+  # execute after `before` context hooks but before any `before` example
+  # hook regardless of where they are declared.
+  #
+  # ### Conditions
+  #
+  # When you add a conditions hash to `before(:example)` or
+  # `before(:context)`, RSpec will only apply that hook to groups or
+  # examples that match the conditions. e.g.
+  #
+  #     RSpec.configure do |config|
+  #       config.before(:example, :authorized => true) do
+  #         log_in_as :authorized_user
+  #       end
+  #     end
+  #
+  #     RSpec.describe Something, :authorized => true do
+  #       # The before hook will run in before each example in this group.
+  #     end
+  #
+  #     RSpec.describe SomethingElse do
+  #       it "does something", :authorized => true do
+  #         # The before hook will run before this example.
+  #       end
+  #
+  #       it "does something else" do
+  #         # The hook will not run before this example.
+  #       end
+  #     end
+  #
+  # Note that filtered config `:context` hooks can still be applied
+  # to individual examples that have matching metadata. Just like
+  # Ruby's object model is that every object has a singleton class
+  # which has only a single instance, RSpec's model is that every
+  # example has a singleton example group containing just the one
+  # example.
+  #
+  # ### Warning: `before(:suite, :with => :conditions)`
+  #
+  # The conditions hash is used to match against specific examples. Since
+  # `before(:suite)` is not run in relation to any specific example or
+  # group, conditions passed along with `:suite` are effectively ignored.
+  #
+  # ### Exceptions
+  #
+  # When an exception is raised in a `before` block, RSpec skips any
+  # subsequent `before` blocks and the example, but runs all of the
+  # `after(:example)` and `after(:context)` hooks.
+  #
+  # ### Warning: implicit before blocks
+  #
+  # `before` hooks can also be declared in shared contexts which get
+  # included implicitly either by you or by extension libraries. Since
+  # RSpec runs these in the order in which they are declared within each
+  # scope, load order matters, and can lead to confusing results when one
+  # before block depends on state that is prepared in another before block
+  # that gets run later.
+  #
+  # ### Warning: `before(:context)`
+  #
+  # It is very tempting to use `before(:context)` to speed things up, but we
+  # recommend that you avoid this as there are a number of gotchas, as well
+  # as things that simply don't work.
+  #
+  # #### Context
+  #
+  # `before(:context)` is run in an example that is generated to provide
+  # group context for the block.
+  #
+  # #### Instance variables
+  #
+  # Instance variables declared in `before(:context)` are shared across all
+  # the examples in the group. This means that each example can change the
+  # state of a shared object, resulting in an ordering dependency that can
+  # make it difficult to reason about failures.
+  #
+  # #### Unsupported RSpec constructs
+  #
+  # RSpec has several constructs that reset state between each example
+  # automatically. These are not intended for use from within
+  # `before(:context)`:
+  #
+  #   * `let` declarations
+  #   * `subject` declarations
+  #   * Any mocking, stubbing or test double declaration
+  #
+  # ### other frameworks
+  #
+  # Mock object frameworks and database transaction managers (like
+  # ActiveRecord) are typically designed around the idea of setting up
+  # before an example, running that one example, and then tearing down. This
+  # means that mocks and stubs can (sometimes) be declared in
+  # `before(:context)`, but get torn down before the first real example is
+  # ever run.
+  #
+  # You _can_ create database-backed model objects in a `before(:context)`
+  # in rspec-rails, but it will not be wrapped in a transaction for you, so
+  # you are on your own to clean up in an `after(:context)` block.
+  #
+  # @api public
+  # @example before(:example) declared in an {ExampleGroup}
+  #
+  #   RSpec.describe Thing do
+  #   before(:example) do
+  #   @thing = Thing.new
+  #   end
+  #
+  #   it "does something" do
+  #   # Here you can access @thing.
+  #   end
+  #   end
+  # @example before(:context) declared in an {ExampleGroup}
+  #
+  #   RSpec.describe Parser do
+  #   before(:context) do
+  #   File.open(file_to_parse, 'w') do |f|
+  #   f.write <<-CONTENT
+  #   stuff in the file
+  #   CONTENT
+  #   end
+  #   end
+  #
+  #   it "parses the file" do
+  #   Parser.parse(file_to_parse)
+  #   end
+  #
+  #   after(:context) do
+  #   File.delete(file_to_parse)
+  #   end
+  #   end
+  # @note The `:example` and `:context` scopes are also available as
+  #   `:each` and `:all`, respectively. Use whichever you prefer.
+  # @note The `:suite` scope is only supported for hooks registered on
+  #   `RSpec.configuration` since they exist independently of any
+  #   example or example group.
+  # @overload before
+  # @overload before
+  # @overload before
+  # @overload before
+  # @see #after
+  # @see #around
+  # @see ExampleGroup
+  # @see SharedContext
+  # @see SharedExampleGroup
+  # @see Configuration
+  #
+  # source://rspec-core//lib/rspec/core/hooks.rb#200
+  def before(*args, &block); end
+
+  # Holds the various registered hooks.
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/hooks.rb#355
+  def hooks; end
+
+  # Declare a block of code to be run after each example (using `:example`)
+  # or once after all examples n the context (using `:context`). See
+  # {#before} for more information about ordering.
+  #
+  # ### Exceptions
+  #
+  # `after` hooks are guaranteed to run even when there are exceptions in
+  # `before` hooks or examples. When an exception is raised in an after
+  # block, the exception is captured for later reporting, and subsequent
+  # `after` blocks are run.
+  #
+  # ### Order
+  #
+  # `after` hooks are stored in three scopes, which are run in order:
+  # `:example`, `:context`, and `:suite`. They can also be declared in
+  # several different places: `RSpec.configure`, a parent group, the current
+  # group. They are run in the following order:
+  #
+  #     after(:example) # Declared in the current group.
+  #     after(:example) # Declared in a parent group.
+  #     after(:example) # Declared in RSpec.configure.
+  #     after(:context) # Declared in the current group.
+  #     after(:context) # Declared in a parent group.
+  #     after(:context) # Declared in RSpec.configure.
+  #     after(:suite)   # Declared in RSpec.configure.
+  #
+  # This is the reverse of the order in which `before` hooks are run.
+  # Similarly, if more than one `after` is declared within any example
+  # group, they are run in reverse order of that in which they are declared.
+  # Also `around` hooks will run after any `after` example hooks are
+  # invoked but before any `after` context hooks.
+  #
+  # @api public
+  # @note The `:suite` scope is only supported for hooks registered on
+  #   `RSpec.configuration` since they exist independently of any
+  #   example or example group.
+  # @note The `:example` and `:context` scopes are also available as
+  #   `:each` and `:all`, respectively. Use whichever you prefer.
+  # @overload after
+  # @overload after
+  # @overload after
+  # @overload after
+  # @see #before
+  # @see #around
+  # @see ExampleGroup
+  # @see SharedContext
+  # @see SharedExampleGroup
+  # @see Configuration
+  #
+  # source://rspec-core//lib/rspec/core/hooks.rb#277
+  def prepend_after(*args, &block); end
+
+  # Adds `block` to the front of the list of `before` blocks in the same
+  # scope (`:example`, `:context`, or `:suite`).
+  #
+  # See {#before} for scoping semantics.
+  #
+  # source://rspec-core//lib/rspec/core/hooks.rb#210
+  def prepend_before(*args, &block); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/hooks.rb#379
+class RSpec::Core::Hooks::AfterContextHook < ::RSpec::Core::Hooks::Hook
+  # source://rspec-core//lib/rspec/core/hooks.rb#380
+  def run(example); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/hooks.rb#370
+class RSpec::Core::Hooks::AfterHook < ::RSpec::Core::Hooks::Hook
+  # source://rspec-core//lib/rspec/core/hooks.rb#371
+  def run(example); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/hooks.rb#388
+class RSpec::Core::Hooks::AroundHook < ::RSpec::Core::Hooks::Hook
+  # source://rspec-core//lib/rspec/core/hooks.rb#389
+  def execute_with(example, procsy); end
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/hooks.rb#397
+  def hook_description; end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/hooks.rb#363
+class RSpec::Core::Hooks::BeforeHook < ::RSpec::Core::Hooks::Hook
+  # source://rspec-core//lib/rspec/core/hooks.rb#364
+  def run(example); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/hooks.rb#360
+class RSpec::Core::Hooks::Hook < ::Struct
+  # Returns the value of attribute block
+  #
+  # @return [Object] the current value of block
+  def block; end
+
+  # Sets the attribute block
+  #
+  # @param value [Object] the value to set the attribute block to.
+  # @return [Object] the newly set value
+  def block=(_); end
+
+  # Returns the value of attribute options
+  #
+  # @return [Object] the current value of options
+  def options; end
+
+  # Sets the attribute options
+  #
+  # @param value [Object] the value to set the attribute options to.
+  # @return [Object] the newly set value
+  def options=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# This provides the primary API used by other parts of rspec-core. By hiding all
+# implementation details behind this facade, it's allowed us to heavily optimize
+# this, so that, for example, hook collection objects are only instantiated when
+# a hook is added. This allows us to avoid many object allocations for the common
+# case of a group having no hooks.
+#
+# This is only possible because this interface provides a "tell, don't ask"-style
+# API, so that callers _tell_ this class what to do with the hooks, rather than
+# asking this class for a list of hooks, and then doing something with them.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/hooks.rb#420
+class RSpec::Core::Hooks::HookCollections
+  # @return [HookCollections] a new instance of HookCollections
+  #
+  # source://rspec-core//lib/rspec/core/hooks.rb#421
+  def initialize(owner, filterable_item_repo_class); end
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#449
+  def register(prepend_or_append, position, *args, &block); end
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#442
+  def register_global_singleton_context_hooks(example, globals); end
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#431
+  def register_globals(host, globals); end
+
+  # Runs all of the blocks stored with the hook in the context of the
+  # example. If no example is provided, just calls the hook directly.
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/hooks.rb#475
+  def run(position, scope, example_or_group); end
+
+  protected
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#523
+  def all_hooks_for(position, scope); end
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#507
+  def matching_hooks_for(position, scope, example_or_group); end
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#533
+  def processable_hooks_for(position, scope, host); end
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#527
+  def run_owned_hooks_for(position, scope, example_or_group); end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#553
+  def ensure_hooks_initialized_for(position, scope); end
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#591
+  def extract_scope_from(args); end
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#543
+  def hooks_for(position, scope); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/hooks.rb#605
+  def known_scope?(scope); end
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#609
+  def normalized_scope_for(scope); end
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/hooks.rb#633
+  def owner_parent_groups; end
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#571
+  def process(host, parent_groups, globals, position, scope); end
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#619
+  def run_around_example_hooks_for(example); end
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#613
+  def run_example_hooks_for(example, position, each_method); end
+
+  # source://rspec-core//lib/rspec/core/hooks.rb#584
+  def scope_and_options_from(*args); end
+end
+
+# source://rspec-core//lib/rspec/core/hooks.rb#505
+RSpec::Core::Hooks::HookCollections::EMPTY_HOOK_ARRAY = T.let(T.unsafe(nil), Array)
+
+# source://rspec-core//lib/rspec/core/hooks.rb#495
+RSpec::Core::Hooks::HookCollections::HOOK_TYPES = T.let(T.unsafe(nil), Hash)
+
+# source://rspec-core//lib/rspec/core/hooks.rb#491
+RSpec::Core::Hooks::HookCollections::SCOPES = T.let(T.unsafe(nil), Array)
+
+# source://rspec-core//lib/rspec/core/hooks.rb#493
+RSpec::Core::Hooks::HookCollections::SCOPE_ALIASES = T.let(T.unsafe(nil), Hash)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/filter_manager.rb#186
+class RSpec::Core::InclusionRules < ::RSpec::Core::FilterRules
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#187
+  def add(*args); end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#191
+  def add_with_low_priority(*args); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#195
+  def include_example?(example); end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#203
+  def split_file_scoped_rules; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#199
+  def standalone?; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#213
+  def apply_standalone_filter(updated); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#226
+  def is_standalone_filter?(rules); end
+
+  # source://rspec-core//lib/rspec/core/filter_manager.rb#221
+  def replace_filters(new_rules); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/invocations.rb#4
+module RSpec::Core::Invocations; end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/invocations.rb#28
+class RSpec::Core::Invocations::Bisect
+  # source://rspec-core//lib/rspec/core/invocations.rb#29
+  def call(options, err, out); end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/invocations.rb#45
+  def bisect_formatter_klass_for(argument); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/invocations.rb#15
+class RSpec::Core::Invocations::DRbWithFallback
+  # source://rspec-core//lib/rspec/core/invocations.rb#16
+  def call(options, err, out); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/invocations.rb#6
+class RSpec::Core::Invocations::InitializeProject
+  # source://rspec-core//lib/rspec/core/invocations.rb#7
+  def call(*_args); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/invocations.rb#78
+class RSpec::Core::Invocations::PrintHelp < ::Struct
+  # source://rspec-core//lib/rspec/core/invocations.rb#79
+  def call(_options, _err, out); end
+
+  # Returns the value of attribute hidden_options
+  #
+  # @return [Object] the current value of hidden_options
+  def hidden_options; end
+
+  # Sets the attribute hidden_options
+  #
+  # @param value [Object] the value to set the attribute hidden_options to.
+  # @return [Object] the newly set value
+  def hidden_options=(_); end
+
+  # Returns the value of attribute parser
+  #
+  # @return [Object] the current value of parser
+  def parser; end
+
+  # Sets the attribute parser
+  #
+  # @param value [Object] the value to set the attribute parser to.
+  # @return [Object] the newly set value
+  def parser=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/invocations.rb#52
+class RSpec::Core::Invocations::PrintVersion
+  # source://rspec-core//lib/rspec/core/invocations.rb#53
+  def call(_options, _err, out); end
+end
+
+# Together with the example group metadata hash default block,
+# provides backwards compatibility for the old `:example_group`
+# key. In RSpec 2.x, the computed keys of a group's metadata
+# were exposed from a nested subhash keyed by `[:example_group]`, and
+# then the parent group's metadata was exposed by sub-subhash
+# keyed by `[:example_group][:example_group]`.
+#
+# In RSpec 3, we reorganized this to that the computed keys are
+# exposed directly of the group metadata hash (no nesting), and
+# `:parent_example_group` returns the parent group's metadata.
+#
+# Maintaining backwards compatibility was difficult: we wanted
+# `:example_group` to return an object that:
+#
+#   * Exposes the top-level metadata keys that used to be nested
+#     under `:example_group`.
+#   * Supports mutation (rspec-rails, for example, assigns
+#     `metadata[:example_group][:described_class]` when you use
+#     anonymous controller specs) such that changes are written
+#     back to the top-level metadata hash.
+#   * Exposes the parent group metadata as
+#     `[:example_group][:example_group]`.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/metadata.rb#470
+class RSpec::Core::LegacyExampleGroupHash
+  include ::RSpec::Core::HashImitatable
+  extend ::RSpec::Core::HashImitatable::ClassMethods
+
+  # @return [LegacyExampleGroupHash] a new instance of LegacyExampleGroupHash
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#473
+  def initialize(metadata); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#479
+  def to_h; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#485
+  def directly_supports_attribute?(name); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#489
+  def get_value(name); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#493
+  def set_value(name, value); end
+end
+
+# This module is included in {ExampleGroup}, making the methods
+# available to be called from within example blocks.
+#
+# @see ClassMethods
+#
+# source://rspec-core//lib/rspec/core/memoized_helpers.rb#9
+module RSpec::Core::MemoizedHelpers
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#135
+  def initialize(*_arg0); end
+
+  # Wraps the `subject` in `expect` to make it the target of an expectation.
+  # Designed to read nicely for one-liners.
+  #
+  # @example
+  #
+  #   describe [1, 2, 3] do
+  #   it { is_expected.to be_an Array }
+  #   it { is_expected.not_to include 4 }
+  #   end
+  # @note This only works if you are using rspec-expectations.
+  # @see #subject
+  # @see #should
+  # @see #should_not
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#120
+  def is_expected; end
+
+  # When `should` is called with no explicit receiver, the call is
+  # delegated to the object returned by `subject`. Combined with an
+  # implicit subject this supports very concise expressions.
+  #
+  # @example
+  #
+  #   RSpec.describe Person do
+  #   it { should be_eligible_to_vote }
+  #   end
+  # @note This only works if you are using rspec-expectations.
+  # @note If you are using RSpec's newer expect-based syntax you may
+  #   want to use `is_expected.to` instead of `should`.
+  # @see #subject
+  # @see #is_expected
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#80
+  def should(matcher = T.unsafe(nil), message = T.unsafe(nil)); end
+
+  # Just like `should`, `should_not` delegates to the subject (implicit or
+  # explicit) of the example group.
+  #
+  # @example
+  #
+  #   RSpec.describe Person do
+  #   it { should_not be_eligible_to_vote }
+  #   end
+  # @note This only works if you are using rspec-expectations.
+  # @note If you are using RSpec's newer expect-based syntax you may
+  #   want to use `is_expected.to_not` instead of `should_not`.
+  # @see #subject
+  # @see #is_expected
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#100
+  def should_not(matcher = T.unsafe(nil), message = T.unsafe(nil)); end
+
+  # @example
+  #
+  #   # Explicit declaration of subject.
+  #   RSpec.describe Person do
+  #   subject { Person.new(:birthdate => 19.years.ago) }
+  #   it "should be eligible to vote" do
+  #   subject.should be_eligible_to_vote
+  #   # ^ ^ explicit reference to subject not recommended
+  #   end
+  #   end
+  #
+  #   # Implicit subject => { Person.new }.
+  #   RSpec.describe Person do
+  #   it "should be eligible to vote" do
+  #   subject.should be_eligible_to_vote
+  #   # ^ ^ explicit reference to subject not recommended
+  #   end
+  #   end
+  #
+  #   # One-liner syntax - expectation is set on the subject.
+  #   RSpec.describe Person do
+  #   it { is_expected.to be_eligible_to_vote }
+  #   # or
+  #   it { should be_eligible_to_vote }
+  #   end
+  # @note `subject` was contributed by Joe Ferris to support the one-liner
+  #   syntax embraced by shoulda matchers:
+  #
+  #   RSpec.describe Widget do
+  #   it { is_expected.to validate_presence_of(:name) }
+  #   # or
+  #   it { should validate_presence_of(:name) }
+  #   end
+  #
+  #   While the examples below demonstrate how to use `subject`
+  #   explicitly in examples, we recommend that you define a method with
+  #   an intention revealing name instead.
+  # @note Because `subject` is designed to create state that is reset
+  #   between each example, and `before(:context)` is designed to setup
+  #   state that is shared across _all_ examples in an example group,
+  #   `subject` is _not_ intended to be used in a `before(:context)` hook.
+  # @see #should
+  # @see #should_not
+  # @see #is_expected
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#57
+  def subject; end
+
+  private
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#141
+  def __init_memoized; end
+
+  # should just be placed in private section,
+  # but Ruby issues warnings on private attributes.
+  # and expanding it to the equivalent method upsets Rubocop,
+  # b/c it should obviously be a reader
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#129
+  def __memoized; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#150
+  def enforce_value_expectation(matcher, method_name); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#163
+  def matcher_supports_value_expectations?(matcher); end
+
+  class << self
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/memoized_helpers.rb#542
+    def define_helpers_on(example_group); end
+
+    # Gets the named constant or yields.
+    # On 1.9, const_defined? / const_get take into account the
+    # the inheritance by default, and accept an argument to
+    # disable this behavior. It's important that we don't
+    # consider inheritance here; each example group level that
+    # uses a `let` should get its own `LetDefinitions` module.
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/memoized_helpers.rb#570
+    def get_constant_or_yield(example_group, name); end
+
+    # Gets the LetDefinitions module. The module is mixed into
+    # the example group and is used to hold all let definitions.
+    # This is done so that the block passed to `let` can be
+    # forwarded directly on to `define_method`, so that all method
+    # constructs (including `super` and `return`) can be used in
+    # a `let` block.
+    #
+    # The memoization is provided by a method definition on the
+    # example group that supers to the LetDefinitions definition
+    # in order to get the value to memoize.
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/memoized_helpers.rb#528
+    def module_for(example_group); end
+  end
+end
+
+# This module is extended onto {ExampleGroup}, making the methods
+# available to be called from within example group blocks.
+# You can think of them as being analagous to class macros.
+#
+# source://rspec-core//lib/rspec/core/memoized_helpers.rb#274
+module RSpec::Core::MemoizedHelpers::ClassMethods
+  # Generates a method whose return value is memoized after the first
+  # call. Useful for reducing duplication between examples that assign
+  # values to the same local variable.
+  #
+  # @example
+  #
+  #   RSpec.describe Thing do
+  #   let(:thing) { Thing.new }
+  #
+  #   it "does something" do
+  #   # First invocation, executes block, memoizes and returns result.
+  #   thing.do_something
+  #
+  #   # Second invocation, returns the memoized value.
+  #   thing.should be_something
+  #   end
+  #   end
+  # @note `let` _can_ enhance readability when used sparingly (1,2, or
+  #   maybe 3 declarations) in any given example group, but that can
+  #   quickly degrade with overuse. YMMV.
+  # @note `let` can be configured to be threadsafe or not.
+  #   If it is threadsafe, it will take longer to access the value.
+  #   If it is not threadsafe, it may behave in surprising ways in examples
+  #   that spawn separate threads. Specify this on `RSpec.configure`
+  # @note Because `let` is designed to create state that is reset between
+  #   each example, and `before(:context)` is designed to setup state that
+  #   is shared across _all_ examples in an example group, `let` is _not_
+  #   intended to be used in a `before(:context)` hook.
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#306
+  def let(name, &block); end
+
+  # Just like `let`, except the block is invoked by an implicit `before`
+  # hook. This serves a dual purpose of setting up state and providing a
+  # memoized reference to that state.
+  #
+  # @example
+  #
+  #   class Thing
+  #   def self.count
+  #   @count ||= 0
+  #   end
+  #
+  #   def self.count=(val)
+  #   @count += val
+  #   end
+  #
+  #   def self.reset_count
+  #   @count = 0
+  #   end
+  #
+  #   def initialize
+  #   self.class.count += 1
+  #   end
+  #   end
+  #
+  #   RSpec.describe Thing do
+  #   after(:example) { Thing.reset_count }
+  #
+  #   context "using let" do
+  #   let(:thing) { Thing.new }
+  #
+  #   it "is not invoked implicitly" do
+  #   Thing.count.should eq(0)
+  #   end
+  #
+  #   it "can be invoked explicitly" do
+  #   thing
+  #   Thing.count.should eq(1)
+  #   end
+  #   end
+  #
+  #   context "using let!" do
+  #   let!(:thing) { Thing.new }
+  #
+  #   it "is invoked implicitly" do
+  #   Thing.count.should eq(1)
+  #   end
+  #
+  #   it "returns memoized version on first invocation" do
+  #   thing
+  #   Thing.count.should eq(1)
+  #   end
+  #   end
+  #   end
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#400
+  def let!(name, &block); end
+
+  # Declares a `subject` for an example group which can then be wrapped
+  # with `expect` using `is_expected` to make it the target of an
+  # expectation in a concise, one-line example.
+  #
+  # Given a `name`, defines a method with that name which returns the
+  # `subject`. This lets you declare the subject once and access it
+  # implicitly in one-liners and explicitly using an intention revealing
+  # name.
+  #
+  # When given a `name`, calling `super` in the block is not supported.
+  #
+  # @example
+  #
+  #   RSpec.describe CheckingAccount, "with $50" do
+  #   subject { CheckingAccount.new(Money.new(50, :USD)) }
+  #   it { is_expected.to have_a_balance_of(Money.new(50, :USD)) }
+  #   it { is_expected.not_to be_overdrawn }
+  #   end
+  #
+  #   RSpec.describe CheckingAccount, "with a non-zero starting balance" do
+  #   subject(:account) { CheckingAccount.new(Money.new(50, :USD)) }
+  #   it { is_expected.not_to be_overdrawn }
+  #   it "has a balance equal to the starting balance" do
+  #   account.balance.should eq(Money.new(50, :USD))
+  #   end
+  #   end
+  # @note `subject` can be configured to be threadsafe or not.
+  #   If it is threadsafe, it will take longer to access the value.
+  #   If it is not threadsafe, it may behave in surprising ways in examples
+  #   that spawn separate threads. Specify this on `RSpec.configure`
+  # @param name [String, Symbol] used to define an accessor with an
+  #   intention revealing name
+  # @param block defines the value to be returned by `subject` in examples
+  # @see MemoizedHelpers#should
+  # @see MemoizedHelpers#should_not
+  # @see MemoizedHelpers#is_expected
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#444
+  def subject(name = T.unsafe(nil), &block); end
+
+  # Just like `subject`, except the block is invoked by an implicit
+  # `before` hook. This serves a dual purpose of setting up state and
+  # providing a memoized reference to that state.
+  #
+  # @example
+  #
+  #   class Thing
+  #   def self.count
+  #   @count ||= 0
+  #   end
+  #
+  #   def self.count=(val)
+  #   @count += val
+  #   end
+  #
+  #   def self.reset_count
+  #   @count = 0
+  #   end
+  #
+  #   def initialize
+  #   self.class.count += 1
+  #   end
+  #   end
+  #
+  #   RSpec.describe Thing do
+  #   after(:example) { Thing.reset_count }
+  #
+  #   context "using subject" do
+  #   subject { Thing.new }
+  #
+  #   it "is not invoked implicitly" do
+  #   Thing.count.should eq(0)
+  #   end
+  #
+  #   it "can be invoked explicitly" do
+  #   subject
+  #   Thing.count.should eq(1)
+  #   end
+  #   end
+  #
+  #   context "using subject!" do
+  #   subject!(:thing) { Thing.new }
+  #
+  #   it "is invoked implicitly" do
+  #   Thing.count.should eq(1)
+  #   end
+  #
+  #   it "returns memoized version on first invocation" do
+  #   subject
+  #   Thing.count.should eq(1)
+  #   end
+  #   end
+  #   end
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#510
+  def subject!(name = T.unsafe(nil), &block); end
+end
+
+# Used internally to customize the behavior of the
+# memoized hash when used in a `before(:context)` hook.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/memoized_helpers.rb#200
+class RSpec::Core::MemoizedHelpers::ContextHookMemoized
+  class << self
+    # source://rspec-core//lib/rspec/core/memoized_helpers.rb#222
+    def fetch_or_store(key, &_block); end
+
+    # source://rspec-core//lib/rspec/core/memoized_helpers.rb#201
+    def isolate_for_context_hook(example_group_instance); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/memoized_helpers.rb#256
+class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After < ::RSpec::Core::MemoizedHelpers::ContextHookMemoized
+  class << self
+    # source://rspec-core//lib/rspec/core/memoized_helpers.rb#261
+    def article; end
+
+    # source://rspec-core//lib/rspec/core/memoized_helpers.rb#257
+    def hook_expression; end
+
+    # source://rspec-core//lib/rspec/core/memoized_helpers.rb#265
+    def hook_intention; end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/memoized_helpers.rb#241
+class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before < ::RSpec::Core::MemoizedHelpers::ContextHookMemoized
+  class << self
+    # source://rspec-core//lib/rspec/core/memoized_helpers.rb#246
+    def article; end
+
+    # source://rspec-core//lib/rspec/core/memoized_helpers.rb#242
+    def hook_expression; end
+
+    # source://rspec-core//lib/rspec/core/memoized_helpers.rb#250
+    def hook_intention; end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/memoized_helpers.rb#186
+class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized
+  # @return [NonThreadSafeMemoized] a new instance of NonThreadSafeMemoized
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#187
+  def initialize; end
+
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#191
+  def fetch_or_store(key); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/memoized_helpers.rb#170
+class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized
+  # @return [ThreadsafeMemoized] a new instance of ThreadsafeMemoized
+  #
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#171
+  def initialize; end
+
+  # source://rspec-core//lib/rspec/core/memoized_helpers.rb#176
+  def fetch_or_store(key); end
+end
+
+# Each ExampleGroup class and Example instance owns an instance of
+# Metadata, which is Hash extended to support lazy evaluation of values
+# associated with keys that may or may not be used by any example or group.
+#
+# In addition to metadata that is used internally, this also stores
+# user-supplied metadata, e.g.
+#
+#     RSpec.describe Something, :type => :ui do
+#       it "does something", :slow => true do
+#         # ...
+#       end
+#     end
+#
+# `:type => :ui` is stored in the Metadata owned by the example group, and
+# `:slow => true` is stored in the Metadata owned by the example. These can
+# then be used to select which examples are run using the `--tag` option on
+# the command line, or several methods on `Configuration` used to filter a
+# run (e.g. `filter_run_including`, `filter_run_excluding`, etc).
+#
+# @see Example#metadata
+# @see ExampleGroup.metadata
+# @see FilterManager
+# @see Configuration#filter_run_including
+# @see Configuration#filter_run_excluding
+#
+# source://rspec-core//lib/rspec/core/metadata.rb#27
+module RSpec::Core::Metadata
+  class << self
+    # Returns an enumerator that iteratively walks up the given metadata through all
+    # example group ancestors, yielding each metadata hash along the way.
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/metadata.rb#71
+    def ascend(metadata); end
+
+    # Iteratively walks up from the given metadata through all
+    # example group ancestors, yielding each metadata hash along the way.
+    #
+    # @private
+    # @yield [metadata]
+    #
+    # source://rspec-core//lib/rspec/core/metadata.rb#58
+    def ascending(metadata); end
+
+    # Used internally to build a hash from an args array.
+    # Symbols are converted into hash keys with a value of `true`.
+    # This is done to support simple tagging using a symbol, rather
+    # than needing to do `:symbol => true`.
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/metadata.rb#80
+    def build_hash_from(args, warn_about_example_group_filtering = T.unsafe(nil)); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/metadata.rb#94
+    def deep_hash_dup(object); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/metadata.rb#105
+    def id_from(metadata); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/metadata.rb#110
+    def location_tuple_from(metadata); end
+
+    # @api private
+    # @param line [String] current code line
+    # @return [String] relative path to line
+    #
+    # source://rspec-core//lib/rspec/core/metadata.rb#44
+    def relative_path(line); end
+
+    # Matches strings either at the beginning of the input or prefixed with a
+    # whitespace, containing the current path, either postfixed with the
+    # separator, or at the end of the string. Match groups are the character
+    # before and the character after the string if any.
+    #
+    # http://rubular.com/r/fT0gmX6VJX
+    # http://rubular.com/r/duOrD4i3wb
+    # http://rubular.com/r/sbAMHFrOx1
+    #
+    # source://rspec-core//lib/rspec/core/metadata.rb#36
+    def relative_path_regex; end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/metadata.rb#247
+class RSpec::Core::Metadata::ExampleGroupHash < ::RSpec::Core::Metadata::HashPopulator
+  private
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#304
+  def described_class; end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#311
+  def full_description; end
+
+  class << self
+    # source://rspec-core//lib/rspec/core/metadata.rb#265
+    def backwards_compatibility_default_proc(&example_group_selector); end
+
+    # source://rspec-core//lib/rspec/core/metadata.rb#248
+    def create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end
+
+    # source://rspec-core//lib/rspec/core/metadata.rb#261
+    def hash_with_backwards_compatibility_default_proc; end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/metadata.rb#213
+class RSpec::Core::Metadata::ExampleHash < ::RSpec::Core::Metadata::HashPopulator
+  private
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#234
+  def described_class; end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#238
+  def full_description; end
+
+  class << self
+    # source://rspec-core//lib/rspec/core/metadata.rb#214
+    def create(group_metadata, user_metadata, index_provider, description, block); end
+  end
+end
+
+# Used internally to populate metadata hashes with computed keys
+# managed by RSpec.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/metadata.rb#117
+class RSpec::Core::Metadata::HashPopulator
+  # @return [HashPopulator] a new instance of HashPopulator
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#120
+  def initialize(metadata, user_metadata, index_provider, description_args, block); end
+
+  # Returns the value of attribute block.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#118
+  def block; end
+
+  # Returns the value of attribute description_args.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#118
+  def description_args; end
+
+  # Returns the value of attribute metadata.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#118
+  def metadata; end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#128
+  def populate; end
+
+  # Returns the value of attribute user_metadata.
+  #
+  # source://rspec-core//lib/rspec/core/metadata.rb#118
+  def user_metadata; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#178
+  def build_description_from(parent_description = T.unsafe(nil), my_description = T.unsafe(nil)); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#185
+  def build_scoped_id_for(file_path); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#170
+  def description_separator(parent_part, child_part); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#191
+  def ensure_valid_user_keys; end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#164
+  def file_path_and_line_number_from(backtrace); end
+
+  # source://rspec-core//lib/rspec/core/metadata.rb#143
+  def populate_location_attributes; end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/metadata.rb#325
+RSpec::Core::Metadata::RESERVED_KEYS = T.let(T.unsafe(nil), Array)
+
+# Contains metadata filtering logic. This has been extracted from
+# the metadata classes because it operates ON a metadata hash but
+# does not manage any of the state in the hash. We're moving towards
+# having metadata be a raw hash (not a custom subclass), so externalizing
+# this filtering logic helps us move in that direction.
+#
+# source://rspec-core//lib/rspec/core/metadata_filter.rb#8
+module RSpec::Core::MetadataFilter
+  class << self
+    # @private
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/metadata_filter.rb#11
+    def apply?(predicate, filters, metadata); end
+
+    # @private
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/metadata_filter.rb#16
+    def filter_applies?(key, filter_value, metadata); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/metadata_filter.rb#33
+    def silence_metadata_example_group_deprecations; end
+
+    private
+
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/metadata_filter.rb#42
+    def filter_applies_to_any_value?(key, value, metadata); end
+
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/metadata_filter.rb#73
+    def filters_apply?(key, value, metadata); end
+
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/metadata_filter.rb#46
+    def id_filter_applies?(rerun_paths_to_scoped_ids, metadata); end
+
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/metadata_filter.rb#54
+    def location_filter_applies?(locations, metadata); end
+
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/metadata_filter.rb#65
+    def proc_filter_applies?(key, proc, metadata); end
+  end
+end
+
+# Provides a single exception instance that provides access to
+# multiple sub-exceptions. This is used in situations where a single
+# individual spec has multiple exceptions, such as one in the `it` block
+# and one in an `after` block.
+#
+# source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#458
+class RSpec::Core::MultipleExceptionError < ::StandardError
+  include ::RSpec::Core::MultipleExceptionError::InterfaceTag
+
+  # @param exceptions [Array<Exception>] The initial list of exceptions.
+  # @return [MultipleExceptionError] a new instance of MultipleExceptionError
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#519
+  def initialize(*exceptions); end
+
+  # @return [nil] Provided only for interface compatibility with
+  #   `RSpec::Expectations::MultipleExpectationsNotMetError`.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#516
+  def aggregation_block_label; end
+
+  # @return [Hash] Metadata used by RSpec for formatting purposes.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#512
+  def aggregation_metadata; end
+
+  # @return [Array<Exception>] The list of failures and other exceptions, combined.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#509
+  def all_exceptions; end
+
+  # return [String] A description of the failure/error counts.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#544
+  def exception_count_description; end
+
+  # @return [Array<Exception>] The list of failures.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#503
+  def failures; end
+
+  # @note RSpec does not actually use this -- instead it formats each exception
+  #   individually.
+  # @return [String] Combines all the exception messages into a single string.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#534
+  def message; end
+
+  # @return [Array<Exception>] The list of other errors.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#506
+  def other_errors; end
+
+  # @return [String] A summary of the failure, including the block label and a count of failures.
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#539
+  def summary; end
+end
+
+# Used so there is a common module in the ancestor chain of this class
+# and `RSpec::Expectations::MultipleExpectationsNotMetError`, which allows
+# code to detect exceptions that are instances of either, without first
+# checking to see if rspec-expectations is loaded.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#464
+module RSpec::Core::MultipleExceptionError::InterfaceTag
+  # Appends the provided exception to the list.
+  #
+  # @param exception [Exception] Exception to append to the list.
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#468
+  def add(exception); end
+
+  class << self
+    # Provides a way to force `ex` to be something that satisfies the multiple
+    # exception error interface. If it already satisfies it, it will be returned;
+    # otherwise it will wrap it in a `MultipleExceptionError`.
+    #
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/formatters/exception_presenter.rb#494
+    def for(ex); end
+  end
+end
+
+# Notifications are value objects passed to formatters to provide them
+# with information about a particular event of interest.
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#9
+module RSpec::Core::Notifications; end
+
+# `CustomNotification` is used when sending custom events to formatters /
+# other registered listeners, it creates attributes based on supplied hash
+# of options.
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#512
+class RSpec::Core::Notifications::CustomNotification < ::Struct
+  class << self
+    # Build a custom notification based on the supplied option key / values.
+    #
+    # @param options [Hash] A hash of method / value pairs to create on this notification
+    # @return [CustomNotification]
+    #
+    # source://rspec-core//lib/rspec/core/notifications.rb#517
+    def for(options = T.unsafe(nil)); end
+  end
+end
+
+# The `DeprecationNotification` is issued by the reporter when a deprecated
+# part of RSpec is encountered. It represents information about the
+# deprecated call site.
+#
+# @attr message [String] A custom message about the deprecation
+# @attr deprecated [String] A custom message about the deprecation (alias of
+#   message)
+# @attr replacement [String] An optional replacement for the deprecation
+# @attr call_site [String] An optional call site from which the deprecation
+#   was issued
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#493
+class RSpec::Core::Notifications::DeprecationNotification < ::Struct
+  # An optional call site from which the deprecation
+  # was issued
+  #
+  # @return [String] the current value of call_site
+  def call_site; end
+
+  # An optional call site from which the deprecation
+  # was issued
+  #
+  # @param value [String] the value to set the attribute call_site to.
+  # @return [String] the newly set value
+  def call_site=(_); end
+
+  # A custom message about the deprecation (alias of
+  # message)
+  #
+  # @return [String] the current value of deprecated
+  def deprecated; end
+
+  # A custom message about the deprecation (alias of
+  # message)
+  #
+  # @param value [String] the value to set the attribute deprecated to.
+  # @return [String] the newly set value
+  def deprecated=(_); end
+
+  # A custom message about the deprecation
+  #
+  # @return [String] the current value of message
+  def message; end
+
+  # A custom message about the deprecation
+  #
+  # @param value [String] the value to set the attribute message to.
+  # @return [String] the newly set value
+  def message=(_); end
+
+  # An optional replacement for the deprecation
+  #
+  # @return [String] the current value of replacement
+  def replacement; end
+
+  # An optional replacement for the deprecation
+  #
+  # @param value [String] the value to set the attribute replacement to.
+  # @return [String] the newly set value
+  def replacement=(_); end
+
+  class << self
+    def [](*_arg0); end
+
+    # Convenience way to initialize the notification
+    #
+    # @api
+    #
+    # source://rspec-core//lib/rspec/core/notifications.rb#499
+    def from_hash(data); end
+
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+
+    private
+
+    def new(*_arg0); end
+  end
+end
+
+# The `ExampleNotification` represents notifications sent by the reporter
+# which contain information about the current (or soon to be) example.
+# It is used by formatters to access information about that example.
+#
+# @attr example [RSpec::Core::Example] the current example
+# @example
+#   def example_started(notification)
+#   puts "Hey I started #{notification.example.description}"
+#   end
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#38
+class RSpec::Core::Notifications::ExampleNotification < ::Struct
+  # the current example
+  #
+  # @return [RSpec::Core::Example] the current value of example
+  def example; end
+
+  # the current example
+  #
+  # @param value [RSpec::Core::Example] the value to set the attribute example to.
+  # @return [RSpec::Core::Example] the newly set value
+  def example=(_); end
+
+  class << self
+    def [](*_arg0); end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/notifications.rb#41
+    def for(example); end
+
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+
+    private
+
+    def new(*_arg0); end
+  end
+end
+
+# The `ExamplesNotification` represents notifications sent by the reporter
+# which contain information about the suites examples.
+#
+# @example
+#   def stop(notification)
+#   puts "Hey I ran #{notification.examples.size}"
+#   end
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#69
+class RSpec::Core::Notifications::ExamplesNotification
+  # @return [ExamplesNotification] a new instance of ExamplesNotification
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#70
+  def initialize(reporter); end
+
+  # @return [Array<RSpec::Core::Example>] list of examples
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#75
+  def examples; end
+
+  # @return [Array<RSpec::Core::Example>] list of failed examples
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#80
+  def failed_examples; end
+
+  # @return [Array<RSpec::Core::Notifications::FailedExampleNotification>] returns failed examples as notifications
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#97
+  def failure_notifications; end
+
+  # @return [String] The list of failed examples, fully formatted in the way
+  #   that RSpec's built-in formatters emit.
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#110
+  def fully_formatted_failed_examples(colorizer = T.unsafe(nil)); end
+
+  # @return [String] The list of pending examples, fully formatted in the
+  #   way that RSpec's built-in formatters emit.
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#122
+  def fully_formatted_pending_examples(colorizer = T.unsafe(nil)); end
+
+  # @return [Array<RSpec::Core::Notifications::ExampleNotification>] returns examples as notifications
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#91
+  def notifications; end
+
+  # @return [Array<RSpec::Core::Example>] list of pending examples
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#85
+  def pending_examples; end
+
+  # returns pending examples as notifications
+  #
+  # @return [Array<RSpec::Core::Notifications::SkippedExampleNotification,
+  # RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification>]
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#104
+  def pending_notifications; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/notifications.rb#136
+  def format_examples(examples); end
+end
+
+# The `FailedExampleNotification` extends `ExampleNotification` with
+# things useful for examples that have failure info -- typically a
+# failed or pending spec.
+#
+# @attr example [RSpec::Core::Example] the current example
+# @example
+#   def example_failed(notification)
+#   puts "Hey I failed :("
+#   puts "Here's my stack trace"
+#   puts notification.exception.backtrace.join("\n")
+#   end
+# @see ExampleNotification
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#156
+class RSpec::Core::Notifications::FailedExampleNotification < ::RSpec::Core::Notifications::ExampleNotification
+  # @return [FailedExampleNotification] a new instance of FailedExampleNotification
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#213
+  def initialize(example, exception_presenter = T.unsafe(nil)); end
+
+  # Returns the failures colorized formatted backtrace.
+  #
+  # @param colorizer [#wrap] An object to colorize the message_lines by
+  # @return [Array<String>] the examples colorized backtrace lines
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#195
+  def colorized_formatted_backtrace(colorizer = T.unsafe(nil)); end
+
+  # Returns the message generated for this failure colorized line by line.
+  #
+  # @param colorizer [#wrap] An object to colorize the message_lines by
+  # @return [Array<String>] The example failure message colorized
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#180
+  def colorized_message_lines(colorizer = T.unsafe(nil)); end
+
+  # @return [String] The example description
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#165
+  def description; end
+
+  # @return [Exception] The example failure
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#160
+  def exception; end
+
+  # Returns the failures formatted backtrace.
+  #
+  # @return [Array<String>] the examples backtrace lines
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#187
+  def formatted_backtrace; end
+
+  # @return [String] The failure information fully formatted in the way that
+  #   RSpec's built-in formatters emit.
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#201
+  def fully_formatted(failure_number, colorizer = T.unsafe(nil)); end
+
+  # @return [Array<string>] The failure information fully formatted in the way that
+  #   RSpec's built-in formatters emit, split by line.
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#207
+  def fully_formatted_lines(failure_number, colorizer = T.unsafe(nil)); end
+
+  # Returns the message generated for this failure line by line.
+  #
+  # @return [Array<String>] The example failure message
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#172
+  def message_lines; end
+
+  class << self
+    def new(*_arg0); end
+  end
+end
+
+# The `GroupNotification` represents notifications sent by the reporter
+# which contain information about the currently running (or soon to be)
+# example group. It is used by formatters to access information about that
+# group.
+#
+# @attr group [RSpec::Core::ExampleGroup] the current group
+# @example
+#   def example_group_started(notification)
+#   puts "Hey I started #{notification.group.description}"
+#   end
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#258
+class RSpec::Core::Notifications::GroupNotification < ::Struct
+  # the current group
+  #
+  # @return [RSpec::Core::ExampleGroup] the current value of group
+  def group; end
+
+  # the current group
+  #
+  # @param value [RSpec::Core::ExampleGroup] the value to set the attribute group to.
+  # @return [RSpec::Core::ExampleGroup] the newly set value
+  def group=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# The `MessageNotification` encapsulates generic messages that the reporter
+# sends to formatters.
+#
+# @attr message [String] the message
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#264
+class RSpec::Core::Notifications::MessageNotification < ::Struct
+  # the message
+  #
+  # @return [String] the current value of message
+  def message; end
+
+  # the message
+  #
+  # @param value [String] the value to set the attribute message to.
+  # @return [String] the newly set value
+  def message=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#11
+module RSpec::Core::Notifications::NullColorizer
+  private
+
+  # source://rspec-core//lib/rspec/core/notifications.rb#14
+  def wrap(line, _code_or_symbol); end
+
+  class << self
+    # source://rspec-core//lib/rspec/core/notifications.rb#14
+    def wrap(line, _code_or_symbol); end
+  end
+end
+
+# `NullNotification` represents a placeholder value for notifications that
+# currently require no information, but we may wish to extend in future.
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#506
+class RSpec::Core::Notifications::NullNotification; end
+
+# @deprecated Use {FailedExampleNotification} instead.
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#223
+class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification < ::RSpec::Core::Notifications::FailedExampleNotification; end
+
+# @deprecated Use {FailedExampleNotification} instead.
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#220
+class RSpec::Core::Notifications::PendingExampleFixedNotification < ::RSpec::Core::Notifications::FailedExampleNotification; end
+
+# The `ProfileNotification` holds information about the results of running a
+# test suite when profiling is enabled. It is used by formatters to provide
+# information at the end of the test run for profiling information.
+#
+# @attr duration [Float] the time taken (in seconds) to run the suite
+# @attr examples [Array<RSpec::Core::Example>] the examples run
+# @attr number_of_examples [Fixnum] the number of examples to profile
+# @attr example_groups [Array<RSpec::Core::Profiler>] example groups run
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#429
+class RSpec::Core::Notifications::ProfileNotification
+  # @return [ProfileNotification] a new instance of ProfileNotification
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#430
+  def initialize(duration, examples, number_of_examples, example_groups); end
+
+  # the time taken (in seconds) to run the suite
+  #
+  # @return [Float] the current value of duration
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#436
+  def duration; end
+
+  # the examples run
+  #
+  # @return [Array<RSpec::Core::Example>] the current value of examples
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#436
+  def examples; end
+
+  # the number of examples to profile
+  #
+  # @return [Fixnum] the current value of number_of_examples
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#436
+  def number_of_examples; end
+
+  # @return [String] the percentage of total time taken
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#455
+  def percentage; end
+
+  # @return [Float] the time taken (in seconds) to run the slowest examples
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#447
+  def slow_duration; end
+
+  # @return [Array<RSpec::Core::Example>] the slowest examples
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#439
+  def slowest_examples; end
+
+  # @return [Array<RSpec::Core::Example>] the slowest example groups
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#464
+  def slowest_groups; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/notifications.rb#470
+  def calculate_slowest_groups; end
+end
+
+# The `SeedNotification` holds the seed used to randomize examples and
+# whether that seed has been used or not.
+#
+# @attr seed [Fixnum] the seed used to randomize ordering
+# @attr used [Boolean] whether the seed has been used or not
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#271
+class RSpec::Core::Notifications::SeedNotification < ::Struct
+  # @return [String] The seed information fully formatted in the way that
+  #   RSpec's built-in formatters emit.
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#282
+  def fully_formatted; end
+
+  # the seed used to randomize ordering
+  #
+  # @return [Fixnum] the current value of seed
+  def seed; end
+
+  # the seed used to randomize ordering
+  #
+  # @param value [Fixnum] the value to set the attribute seed to.
+  # @return [Fixnum] the newly set value
+  def seed=(_); end
+
+  # @api
+  # @return [Boolean] has the seed been used?
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#275
+  def seed_used?; end
+
+  # whether the seed has been used or not
+  #
+  # @param value [Boolean] the value to set the attribute used to.
+  # @return [Boolean] the newly set value
+  def used=(_); end
+
+  private
+
+  # whether the seed has been used or not
+  #
+  # @return [Boolean] the current value of used
+  def used; end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# The `SkippedExampleNotification` extends `ExampleNotification` with
+# things useful for specs that are skipped.
+#
+# @attr example [RSpec::Core::Example] the current example
+# @see ExampleNotification
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#230
+class RSpec::Core::Notifications::SkippedExampleNotification < ::RSpec::Core::Notifications::ExampleNotification
+  # @return [String] The pending detail fully formatted in the way that
+  #   RSpec's built-in formatters emit.
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#235
+  def fully_formatted(pending_number, colorizer = T.unsafe(nil)); end
+
+  class << self
+    def new(*_arg0); end
+  end
+end
+
+# The `StartNotification` represents a notification sent by the reporter
+# when the suite is started. It contains the expected amount of examples
+# to be executed, and the load time of RSpec.
+#
+# @attr count [Fixnum] the number counted
+# @attr load_time [Float] the number of seconds taken to boot RSpec
+#   and load the spec files
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#26
+class RSpec::Core::Notifications::StartNotification < ::Struct
+  # the number counted
+  #
+  # @return [Fixnum] the current value of count
+  def count; end
+
+  # the number counted
+  #
+  # @param value [Fixnum] the value to set the attribute count to.
+  # @return [Fixnum] the newly set value
+  def count=(_); end
+
+  # the number of seconds taken to boot RSpec
+  # and load the spec files
+  #
+  # @return [Float] the current value of load_time
+  def load_time; end
+
+  # the number of seconds taken to boot RSpec
+  # and load the spec files
+  #
+  # @param value [Float] the value to set the attribute load_time to.
+  # @return [Float] the newly set value
+  def load_time=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# The `SummaryNotification` holds information about the results of running
+# a test suite. It is used by formatters to provide information at the end
+# of the test run.
+#
+# @attr duration [Float] the time taken (in seconds) to run the suite
+# @attr examples [Array<RSpec::Core::Example>] the examples run
+# @attr failed_examples [Array<RSpec::Core::Example>] the failed examples
+# @attr pending_examples [Array<RSpec::Core::Example>] the pending examples
+# @attr load_time [Float] the number of seconds taken to boot RSpec
+#   and load the spec files
+# @attr errors_outside_of_examples_count [Integer] the number of errors that
+#   have occurred processing
+#   the spec suite
+#
+# source://rspec-core//lib/rspec/core/notifications.rb#300
+class RSpec::Core::Notifications::SummaryNotification < ::Struct
+  include ::RSpec::Core::ShellEscape
+
+  # Formats failures into a rerunable command format.
+  #
+  # @api public
+  # @param colorizer [#wrap] An object which supports wrapping text with
+  #   specific colors.
+  # @return [String] A colorized summary line.
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#364
+  def colorized_rerun_commands(colorizer = T.unsafe(nil)); end
+
+  # Wraps the results line with colors based on the configured
+  # colors for failure, pending, and success. Defaults to red,
+  # yellow, green accordingly.
+  #
+  # @api public
+  # @param colorizer [#wrap] An object which supports wrapping text with
+  #   specific colors.
+  # @return [String] A colorized results line.
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#347
+  def colorized_totals_line(colorizer = T.unsafe(nil)); end
+
+  # the time taken (in seconds) to run the suite
+  #
+  # @return [Float] the current value of duration
+  def duration; end
+
+  # the time taken (in seconds) to run the suite
+  #
+  # @param value [Float] the value to set the attribute duration to.
+  # @return [Float] the newly set value
+  def duration=(_); end
+
+  # the number of errors that
+  # have occurred processing
+  # the spec suite
+  #
+  # @return [Integer] the current value of errors_outside_of_examples_count
+  def errors_outside_of_examples_count; end
+
+  # the number of errors that
+  # have occurred processing
+  # the spec suite
+  #
+  # @param value [Integer] the value to set the attribute errors_outside_of_examples_count to.
+  # @return [Integer] the newly set value
+  def errors_outside_of_examples_count=(_); end
+
+  # @api
+  # @return [Fixnum] the number of examples run
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#306
+  def example_count; end
+
+  # the examples run
+  #
+  # @return [Array<RSpec::Core::Example>] the current value of examples
+  def examples; end
+
+  # the examples run
+  #
+  # @param value [Array<RSpec::Core::Example>] the value to set the attribute examples to.
+  # @return [Array<RSpec::Core::Example>] the newly set value
+  def examples=(_); end
+
+  # the failed examples
+  #
+  # @return [Array<RSpec::Core::Example>] the current value of failed_examples
+  def failed_examples; end
+
+  # the failed examples
+  #
+  # @param value [Array<RSpec::Core::Example>] the value to set the attribute failed_examples to.
+  # @return [Array<RSpec::Core::Example>] the newly set value
+  def failed_examples=(_); end
+
+  # @api
+  # @return [Fixnum] the number of failed examples
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#312
+  def failure_count; end
+
+  # @return [String] a formatted version of the time it took to run the
+  #   suite
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#374
+  def formatted_duration; end
+
+  # @return [String] a formatted version of the time it took to boot RSpec
+  #   and load the spec files
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#380
+  def formatted_load_time; end
+
+  # @return [String] The summary information fully formatted in the way that
+  #   RSpec's built-in formatters emit.
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#386
+  def fully_formatted(colorizer = T.unsafe(nil)); end
+
+  # the number of seconds taken to boot RSpec
+  # and load the spec files
+  #
+  # @return [Float] the current value of load_time
+  def load_time; end
+
+  # the number of seconds taken to boot RSpec
+  # and load the spec files
+  #
+  # @param value [Float] the value to set the attribute load_time to.
+  # @return [Float] the newly set value
+  def load_time=(_); end
+
+  # @api
+  # @return [Fixnum] the number of pending examples
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#318
+  def pending_count; end
+
+  # the pending examples
+  #
+  # @return [Array<RSpec::Core::Example>] the current value of pending_examples
+  def pending_examples; end
+
+  # the pending examples
+  #
+  # @param value [Array<RSpec::Core::Example>] the value to set the attribute pending_examples to.
+  # @return [Array<RSpec::Core::Example>] the newly set value
+  def pending_examples=(_); end
+
+  # @api
+  # @return [String] A line summarising the result totals of the spec run.
+  #
+  # source://rspec-core//lib/rspec/core/notifications.rb#324
+  def totals_line; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/notifications.rb#408
+  def duplicate_rerun_locations; end
+
+  # source://rspec-core//lib/rspec/core/notifications.rb#402
+  def rerun_argument_for(example); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# # Used in place of a {Reporter} for situations where we don't want reporting output.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/reporter.rb#259
+class RSpec::Core::NullReporter
+  class << self
+    private
+
+    # source://rspec-core//lib/rspec/core/reporter.rb#260
+    def method_missing(*_arg0); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/ordering.rb#4
+module RSpec::Core::Ordering; end
+
+# Manages ordering configuration.
+#
+# @note This is not intended to be used externally. Use
+#   the APIs provided by `RSpec::Core::Configuration` instead.
+# @private
+#
+# source://rspec-core//lib/rspec/core/ordering.rb#144
+class RSpec::Core::Ordering::ConfigurationManager
+  # @return [ConfigurationManager] a new instance of ConfigurationManager
+  #
+  # source://rspec-core//lib/rspec/core/ordering.rb#147
+  def initialize; end
+
+  # source://rspec-core//lib/rspec/core/ordering.rb#190
+  def force(hash); end
+
+  # source://rspec-core//lib/rspec/core/ordering.rb#164
+  def order=(type); end
+
+  # Returns the value of attribute ordering_registry.
+  #
+  # source://rspec-core//lib/rspec/core/ordering.rb#145
+  def ordering_registry; end
+
+  # source://rspec-core//lib/rspec/core/ordering.rb#201
+  def register_ordering(name, strategy = T.unsafe(nil)); end
+
+  # Returns the value of attribute seed.
+  #
+  # source://rspec-core//lib/rspec/core/ordering.rb#145
+  def seed; end
+
+  # source://rspec-core//lib/rspec/core/ordering.rb#158
+  def seed=(seed); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/ordering.rb#154
+  def seed_used?; end
+end
+
+# Orders items based on a custom block.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/ordering.rb#71
+class RSpec::Core::Ordering::Custom
+  # @return [Custom] a new instance of Custom
+  #
+  # source://rspec-core//lib/rspec/core/ordering.rb#72
+  def initialize(callable); end
+
+  # source://rspec-core//lib/rspec/core/ordering.rb#76
+  def order(list); end
+end
+
+# A strategy which delays looking up the ordering until needed
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/ordering.rb#83
+class RSpec::Core::Ordering::Delayed
+  # @return [Delayed] a new instance of Delayed
+  #
+  # source://rspec-core//lib/rspec/core/ordering.rb#84
+  def initialize(registry, name); end
+
+  # source://rspec-core//lib/rspec/core/ordering.rb#89
+  def order(list); end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/ordering.rb#99
+  def lookup_strategy; end
+
+  # source://rspec-core//lib/rspec/core/ordering.rb#95
+  def strategy; end
+end
+
+# The default global ordering (defined order).
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/ordering.rb#7
+class RSpec::Core::Ordering::Identity
+  # source://rspec-core//lib/rspec/core/ordering.rb#8
+  def order(items); end
+end
+
+# Orders items randomly.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/ordering.rb#15
+class RSpec::Core::Ordering::Random
+  # @return [Random] a new instance of Random
+  #
+  # source://rspec-core//lib/rspec/core/ordering.rb#16
+  def initialize(configuration); end
+
+  # source://rspec-core//lib/rspec/core/ordering.rb#25
+  def order(items); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/ordering.rb#21
+  def used?; end
+
+  private
+
+  # http://en.wikipedia.org/wiki/Jenkins_hash_function
+  # Jenkins provides a good distribution and is simpler than MD5.
+  # It's a bit slower than MD5 (primarily because `Digest::MD5` is
+  # implemented in C) but has the advantage of not requiring us
+  # to load another part of stdlib, which we try to minimize.
+  #
+  # source://rspec-core//lib/rspec/core/ordering.rb#39
+  def jenkins_hash_digest(string); end
+end
+
+# source://rspec-core//lib/rspec/core/ordering.rb#58
+RSpec::Core::Ordering::Random::MAX_32_BIT = T.let(T.unsafe(nil), Integer)
+
+# Orders items by modification time (most recent modified first).
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/ordering.rb#63
+class RSpec::Core::Ordering::RecentlyModified
+  # source://rspec-core//lib/rspec/core/ordering.rb#64
+  def order(list); end
+end
+
+# Stores the different ordering strategies.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/ordering.rb#107
+class RSpec::Core::Ordering::Registry
+  # @return [Registry] a new instance of Registry
+  #
+  # source://rspec-core//lib/rspec/core/ordering.rb#108
+  def initialize(configuration); end
+
+  # source://rspec-core//lib/rspec/core/ordering.rb#122
+  def fetch(name, &fallback); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/ordering.rb#126
+  def has_strategy?(name); end
+
+  # source://rspec-core//lib/rspec/core/ordering.rb#130
+  def register(sym, strategy); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/ordering.rb#134
+  def used_random_seed?; end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/output_wrapper.rb#4
+class RSpec::Core::OutputWrapper
+  # @private
+  # @return [OutputWrapper] a new instance of OutputWrapper
+  #
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#9
+  def initialize(output); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def <<(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def advise(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def autoclose=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def autoclose?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def beep(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def binmode(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def binmode?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def check_winsize_changed(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def clear_screen(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def close(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def close_on_exec=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def close_on_exec?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def close_read(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def close_write(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def closed?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def console_mode(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def console_mode=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def cooked(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def cooked!(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def cursor(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def cursor=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def cursor_down(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def cursor_left(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def cursor_right(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def cursor_up(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def each(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def each_byte(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def each_char(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def each_codepoint(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def each_line(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def echo=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def echo?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def eof(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def eof?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def erase_line(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def erase_screen(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def external_encoding(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def fcntl(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def fdatasync(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def fileno(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def flush(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def fsync(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def getbyte(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def getc(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def getch(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def getpass(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def gets(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def goto(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def goto_column(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def iflush(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def inspect(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def internal_encoding(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def ioctl(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def ioflush(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def isatty(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def lineno(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def lineno=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#17
+  def method_missing(name, *args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def noecho(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def nread(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def oflush(*args, &block); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#6
+  def output; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#6
+  def output=(_arg0); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def path(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def pathconf(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def pid(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def pos(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def pos=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def pread(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def pressed?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def print(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def printf(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def putc(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def puts(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def pwrite(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def raw(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def raw!(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def read(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def read_nonblock(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def readbyte(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def readchar(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def readline(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def readlines(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def readpartial(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def ready?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def reopen(*args, &block); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#13
+  def respond_to?(name, priv = T.unsafe(nil)); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def rewind(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def scroll_backward(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def scroll_forward(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def seek(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def set_encoding(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def set_encoding_by_bom(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def stat(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def sync(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def sync=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def sysread(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def sysseek(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def syswrite(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def tell(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def timeout(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def timeout=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def to_i(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def to_io(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def to_path(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def tty?(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def ungetbyte(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def ungetc(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def wait(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def wait_priority(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def wait_readable(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def wait_writable(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def winsize(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def winsize=(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def write(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/output_wrapper.rb#23
+  def write_nonblock(*args, &block); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/option_parser.rb#6
+class RSpec::Core::Parser
+  # @return [Parser] a new instance of Parser
+  #
+  # source://rspec-core//lib/rspec/core/option_parser.rb#13
+  def initialize(original_args); end
+
+  # Returns the value of attribute original_args.
+  #
+  # source://rspec-core//lib/rspec/core/option_parser.rb#11
+  def original_args; end
+
+  # source://rspec-core//lib/rspec/core/option_parser.rb#17
+  def parse(source = T.unsafe(nil)); end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/option_parser.rb#312
+  def add_tag_filter(options, filter_type, tag_name, value = T.unsafe(nil)); end
+
+  # source://rspec-core//lib/rspec/core/option_parser.rb#320
+  def configure_only_failures(options); end
+
+  # source://rspec-core//lib/rspec/core/option_parser.rb#39
+  def parser(options); end
+
+  # source://rspec-core//lib/rspec/core/option_parser.rb#316
+  def set_fail_fast(options, value); end
+
+  class << self
+    # source://rspec-core//lib/rspec/core/option_parser.rb#7
+    def parse(args, source = T.unsafe(nil)); end
+  end
+end
+
+# Provides methods to mark examples as pending. These methods are available
+# to be called from within any example or hook.
+#
+# source://rspec-core//lib/rspec/core/pending.rb#5
+module RSpec::Core::Pending
+  # Marks an example as pending. The rest of the example will still be
+  # executed, and if it passes the example will fail to indicate that the
+  # pending can be removed.
+  #
+  # @example
+  #   describe "some behaviour" do
+  #   # reported as "Pending: no reason given"
+  #   it "is pending with no message" do
+  #   pending
+  #   raise "broken"
+  #   end
+  #
+  #   # reported as "Pending: something else getting finished"
+  #   it "is pending with a custom message" do
+  #   pending("something else getting finished")
+  #   raise "broken"
+  #   end
+  #   end
+  # @note When using `pending` inside an example body using this method
+  #   hooks, such as `before(:example)`, have already be run. This means that
+  #   a failure from the code in the `before` hook will prevent the example
+  #   from being considered pending, as the example body would not be
+  #   executed. If you need to consider hooks as pending as well you can use
+  #   the pending metadata as an alternative, e.g.
+  #   `it "does something", pending: "message"`.
+  # @overload pending
+  # @overload pending
+  # @param message [String] optional message to add to the summary report.
+  #
+  # source://rspec-core//lib/rspec/core/pending.rb#62
+  def pending(message = T.unsafe(nil), &_block); end
+
+  # Marks an example as pending and skips execution.
+  #
+  # @example
+  #   describe "an example" do
+  #   # reported as "Pending: no reason given"
+  #   it "is skipped with no message" do
+  #   skip
+  #   end
+  #
+  #   # reported as "Pending: something else getting finished"
+  #   it "is skipped with a custom message" do
+  #   skip "something else getting finished"
+  #   end
+  #   end
+  # @overload skip
+  # @overload skip
+  # @param message [String] optional message to add to the summary report.
+  # @raise [SkipDeclaredInExample]
+  #
+  # source://rspec-core//lib/rspec/core/pending.rb#110
+  def skip(message = T.unsafe(nil)); end
+
+  class << self
+    # Mark example as fixed.
+    #
+    # @param example [RSpec::Core::Example] the example to mark as fixed
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/pending.rb#152
+    def mark_fixed!(example); end
+
+    # Mark example as pending.
+    #
+    # @param example [RSpec::Core::Example] the example to mark as pending
+    # @param message_or_bool [Boolean, String] the message to use, or true
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/pending.rb#135
+    def mark_pending!(example, message_or_bool); end
+
+    # Mark example as skipped.
+    #
+    # @param example [RSpec::Core::Example] the example to mark as skipped
+    # @param message_or_bool [Boolean, String] the message to use, or true
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/pending.rb#124
+    def mark_skipped!(example, message_or_bool); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/pending.rb#29
+RSpec::Core::Pending::NOT_YET_IMPLEMENTED = T.let(T.unsafe(nil), String)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/pending.rb#26
+RSpec::Core::Pending::NO_REASON_GIVEN = T.let(T.unsafe(nil), String)
+
+# source://rspec-core//lib/rspec/core/pending.rb#22
+class RSpec::Core::Pending::PendingExampleFixedError < ::StandardError; end
+
+# Raised in the middle of an example to indicate that it should be marked
+# as skipped.
+#
+# source://rspec-core//lib/rspec/core/pending.rb#8
+class RSpec::Core::Pending::SkipDeclaredInExample < ::StandardError
+  # @return [SkipDeclaredInExample] a new instance of SkipDeclaredInExample
+  #
+  # source://rspec-core//lib/rspec/core/pending.rb#11
+  def initialize(argument); end
+
+  # Returns the value of attribute argument.
+  #
+  # source://rspec-core//lib/rspec/core/pending.rb#9
+  def argument; end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/profiler.rb#4
+class RSpec::Core::Profiler
+  # @return [Profiler] a new instance of Profiler
+  #
+  # source://rspec-core//lib/rspec/core/profiler.rb#7
+  def initialize; end
+
+  # source://rspec-core//lib/rspec/core/profiler.rb#20
+  def example_group_finished(notification); end
+
+  # source://rspec-core//lib/rspec/core/profiler.rb#13
+  def example_group_started(notification); end
+
+  # Returns the value of attribute example_groups.
+  #
+  # source://rspec-core//lib/rspec/core/profiler.rb#11
+  def example_groups; end
+
+  # source://rspec-core//lib/rspec/core/profiler.rb#28
+  def example_started(notification); end
+end
+
+# source://rspec-core//lib/rspec/core/profiler.rb#5
+RSpec::Core::Profiler::NOTIFICATIONS = T.let(T.unsafe(nil), Array)
+
+# A reporter will send notifications to listeners, usually formatters for the
+# spec suite run.
+#
+# source://rspec-core//lib/rspec/core/reporter.rb#4
+class RSpec::Core::Reporter
+  # @return [Reporter] a new instance of Reporter
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#14
+  def initialize(configuration); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#214
+  def abort_with(msg, exit_status); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#193
+  def close_after; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#155
+  def deprecation(hash); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#143
+  def example_failed(example); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#133
+  def example_finished(example); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#122
+  def example_group_finished(group); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#117
+  def example_group_started(group); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#138
+  def example_passed(example); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#149
+  def example_pending(example); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#127
+  def example_started(example); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#28
+  def examples; end
+
+  # Reports a run that exited early without having run any examples.
+  #
+  # @param exit_code [Integer] the exit_code to be return by the reporter
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#84
+  def exit_early(exit_code); end
+
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#221
+  def fail_fast_limit_met?; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#28
+  def failed_examples; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#173
+  def finish; end
+
+  # Send a custom message to supporting formatters.
+  #
+  # @param message [#to_s] A message object to send to formatters
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#99
+  def message(message); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#206
+  def notify(event, notification); end
+
+  # Provides a way to notify of an exception that is not tied to any
+  # particular example (such as an exception encountered in a :suite hook).
+  # Exceptions will be formatted the same way they normally are.
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#163
+  def notify_non_example_exception(exception, context_description); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#28
+  def pending_examples; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#45
+  def prepare_default(loader, output_stream, deprecation_stream); end
+
+  # Publish a custom event to supporting registered formatters.
+  #
+  # @param event [Symbol] Name of the custom event to trigger on formatters
+  # @param options [Hash] Hash of arguments to provide via `CustomNotification`
+  # @see RSpec::Core::Notifications::CustomNotification
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#108
+  def publish(event, options = T.unsafe(nil)); end
+
+  # Registers a listener to a list of notifications. The reporter will send
+  # notification of events to all registered listeners.
+  #
+  # @param listener [Object] An object that wishes to be notified of reporter
+  #   events
+  # @param notifications [Array] Array of symbols represents the events a
+  #   listener wishes to subscribe too
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#37
+  def register_listener(listener, *notifications); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#52
+  def registered_listeners(notification); end
+
+  # Initializes the report run and yields itself for further reporting. The
+  # block is required, so that the reporter can manage cleaning up after the
+  # run.
+  #
+  # @example
+  #
+  #   reporter.report(group.examples.size) do |r|
+  #   example_groups.map {|g| g.run(r) }
+  #   end
+  # @overload report
+  # @overload report
+  # @param expected_example_count [Integer] the number of examples being run
+  # @yield [Block] block yields itself for further reporting.
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#71
+  def report(expected_example_count); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#89
+  def start(expected_example_count, time = T.unsafe(nil)); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#200
+  def stop; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/reporter.rb#242
+  def close; end
+
+  # source://rspec-core//lib/rspec/core/reporter.rb#233
+  def ensure_listeners_ready; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#246
+  def mute_profile_output?; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/reporter.rb#252
+  def seed_used?; end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/reporter.rb#6
+RSpec::Core::Reporter::RSPEC_NOTIFICATIONS = T.let(T.unsafe(nil), RSpec::Core::Set)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/ruby_project.rb#7
+module RSpec::Core::RubyProject
+  private
+
+  # source://rspec-core//lib/rspec/core/ruby_project.rb#12
+  def add_dir_to_load_path(dir); end
+
+  # source://rspec-core//lib/rspec/core/ruby_project.rb#8
+  def add_to_load_path(*dirs); end
+
+  # source://rspec-core//lib/rspec/core/ruby_project.rb#28
+  def ascend_until; end
+
+  # source://rspec-core//lib/rspec/core/ruby_project.rb#20
+  def determine_root; end
+
+  # source://rspec-core//lib/rspec/core/ruby_project.rb#24
+  def find_first_parent_containing(dir); end
+
+  # source://rspec-core//lib/rspec/core/ruby_project.rb#16
+  def root; end
+
+  class << self
+    # source://rspec-core//lib/rspec/core/ruby_project.rb#12
+    def add_dir_to_load_path(dir); end
+
+    # source://rspec-core//lib/rspec/core/ruby_project.rb#8
+    def add_to_load_path(*dirs); end
+
+    # source://rspec-core//lib/rspec/core/ruby_project.rb#28
+    def ascend_until; end
+
+    # source://rspec-core//lib/rspec/core/ruby_project.rb#20
+    def determine_root; end
+
+    # source://rspec-core//lib/rspec/core/ruby_project.rb#24
+    def find_first_parent_containing(dir); end
+
+    # source://rspec-core//lib/rspec/core/ruby_project.rb#16
+    def root; end
+  end
+end
+
+# Provides the main entry point to run a suite of RSpec examples.
+#
+# source://rspec-core//lib/rspec/core/runner.rb#4
+class RSpec::Core::Runner
+  # @return [Runner] a new instance of Runner
+  #
+  # source://rspec-core//lib/rspec/core/runner.rb#75
+  def initialize(options, configuration = T.unsafe(nil), world = T.unsafe(nil)); end
+
+  # @attr_reader
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/runner.rb#7
+  def configuration; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/runner.rb#129
+  def configure(err, out); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/runner.rb#194
+  def exit_code(examples_passed = T.unsafe(nil)); end
+
+  # @attr_reader
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/runner.rb#7
+  def options; end
+
+  # Configures and runs a spec suite.
+  #
+  # @param err [IO] error stream
+  # @param out [IO] output stream
+  #
+  # source://rspec-core//lib/rspec/core/runner.rb#85
+  def run(err, out); end
+
+  # Runs the provided example groups.
+  #
+  # @param example_groups [Array<RSpec::Core::ExampleGroup>] groups to run
+  # @return [Fixnum] exit status code. 0 if all specs passed,
+  #   or the configured failure exit code (1 by default) if specs
+  #   failed.
+  #
+  # source://rspec-core//lib/rspec/core/runner.rb#113
+  def run_specs(example_groups); end
+
+  # Wires together the various configuration objects and state holders.
+  #
+  # @param err [IO] error stream
+  # @param out [IO] output stream
+  #
+  # source://rspec-core//lib/rspec/core/runner.rb#98
+  def setup(err, out); end
+
+  # @attr_reader
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/runner.rb#7
+  def world; end
+
+  private
+
+  # source://rspec-core//lib/rspec/core/runner.rb#203
+  def persist_example_statuses; end
+
+  class << self
+    # Register an `at_exit` hook that runs the suite when the process exits.
+    #
+    # @note This is not generally needed. The `rspec` command takes care
+    #   of running examples for you without involving an `at_exit`
+    #   hook. This is only needed if you are running specs using
+    #   the `ruby` command, and even then, the normal way to invoke
+    #   this is by requiring `rspec/autorun`.
+    #
+    # source://rspec-core//lib/rspec/core/runner.rb#16
+    def autorun; end
+
+    # @private
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/runner.rb#141
+    def autorun_disabled?; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/runner.rb#136
+    def disable_autorun!; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/runner.rb#180
+    def handle_interrupt; end
+
+    # @private
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/runner.rb#146
+    def installed_at_exit?; end
+
+    # Runs the suite of specs and exits the process with an appropriate exit
+    # code.
+    #
+    # source://rspec-core//lib/rspec/core/runner.rb#43
+    def invoke; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/runner.rb#29
+    def perform_at_exit; end
+
+    # Run a suite of RSpec examples. Does not exit.
+    #
+    # This is used internally by RSpec to run a suite, but is available
+    # for use by any other automation tool.
+    #
+    # If you want to run this multiple times in the same process, and you
+    # want files like `spec_helper.rb` to be reloaded, be sure to load `load`
+    # instead of `require`.
+    #
+    # @param args [Array] command-line-supported arguments
+    # @param err [IO] error stream
+    # @param out [IO] output stream
+    # @return [Fixnum] exit status code. 0 if all specs passed,
+    #   or the configured failure exit code (1 by default) if specs
+    #   failed.
+    #
+    # source://rspec-core//lib/rspec/core/runner.rb#64
+    def run(args, err = T.unsafe(nil), out = T.unsafe(nil)); end
+
+    # @private
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/runner.rb#151
+    def running_in_drb?; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/runner.rb#175
+    def trap_interrupt; end
+  end
+end
+
+# We use this to replace `::Set` so we can have the advantage of
+# constant time key lookups for unique arrays but without the
+# potential to pollute a developers environment with an extra
+# piece of the stdlib. This helps to prevent false positive
+# builds.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/set.rb#11
+class RSpec::Core::Set
+  include ::Enumerable
+
+  # @return [Set] a new instance of Set
+  #
+  # source://rspec-core//lib/rspec/core/set.rb#14
+  def initialize(array = T.unsafe(nil)); end
+
+  # source://rspec-core//lib/rspec/core/set.rb#23
+  def <<(key); end
+
+  # source://rspec-core//lib/rspec/core/set.rb#48
+  def clear; end
+
+  # source://rspec-core//lib/rspec/core/set.rb#28
+  def delete(key); end
+
+  # source://rspec-core//lib/rspec/core/set.rb#32
+  def each(&block); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/set.rb#19
+  def empty?; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/set.rb#37
+  def include?(key); end
+
+  # source://rspec-core//lib/rspec/core/set.rb#41
+  def merge(values); end
+end
+
+# Exposes {ExampleGroup}-level methods to a module, so you can include that
+# module in an {ExampleGroup}.
+#
+# @example
+#
+#   module LoggedInAsAdmin
+#   extend RSpec::Core::SharedContext
+#   before(:example) do
+#   log_in_as :admin
+#   end
+#   end
+#
+#   describe "admin section" do
+#   include LoggedInAsAdmin
+#   # ...
+#   end
+#
+# source://rspec-core//lib/rspec/core/shared_context.rb#19
+module RSpec::Core::SharedContext
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/shared_context.rb#28
+  def __shared_context_recordings; end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#42
+  def after(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#42
+  def append_after(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#42
+  def append_before(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#42
+  def around(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#42
+  def before(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#42
+  def context(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#42
+  def describe(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#42
+  def hooks(*args, &block); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/shared_context.rb#21
+  def included(group); end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#42
+  def let(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#42
+  def let!(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#42
+  def prepend_after(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#42
+  def prepend_before(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#42
+  def subject(*args, &block); end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#42
+  def subject!(*args, &block); end
+
+  class << self
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/shared_context.rb#40
+    def record(methods); end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/shared_context.rb#33
+class RSpec::Core::SharedContext::Recording < ::Struct
+  # Returns the value of attribute args
+  #
+  # @return [Object] the current value of args
+  def args; end
+
+  # Sets the attribute args
+  #
+  # @param value [Object] the value to set the attribute args to.
+  # @return [Object] the newly set value
+  def args=(_); end
+
+  # Returns the value of attribute block
+  #
+  # @return [Object] the current value of block
+  def block; end
+
+  # Sets the attribute block
+  #
+  # @param value [Object] the value to set the attribute block to.
+  # @return [Object] the newly set value
+  def block=(_); end
+
+  # Returns the value of attribute method_name
+  #
+  # @return [Object] the current value of method_name
+  def method_name; end
+
+  # Sets the attribute method_name
+  #
+  # @param value [Object] the value to set the attribute method_name to.
+  # @return [Object] the newly set value
+  def method_name=(_); end
+
+  # source://rspec-core//lib/rspec/core/shared_context.rb#34
+  def playback_onto(group); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# Shared example groups let you define common context and/or common
+# examples that you wish to use in multiple example groups.
+#
+# When defined, the shared group block is stored for later evaluation.
+# It can later be included in an example group either explicitly
+# (using `include_examples`, `include_context` or `it_behaves_like`)
+# or implicitly (via matching metadata).
+#
+# Named shared example groups are scoped based on where they are
+# defined. Shared groups defined in an example group are available
+# for inclusion in that example group or any child example groups,
+# but not in any parent or sibling example groups. Shared example
+# groups defined at the top level can be included from any example group.
+#
+# source://rspec-core//lib/rspec/core/shared_example_group.rb#57
+module RSpec::Core::SharedExampleGroup
+  # Stores the block for later use. The block will be evaluated
+  # in the context of an example group via `include_examples`,
+  # `include_context`, or `it_behaves_like`.
+  #
+  # @example
+  #   shared_examples "auditable" do
+  #   it "stores an audit record on save!" do
+  #   expect { auditable.save! }.to change(Audit, :count).by(1)
+  #   end
+  #   end
+  #
+  #   RSpec.describe Account do
+  #   it_behaves_like "auditable" do
+  #   let(:auditable) { Account.new }
+  #   end
+  #   end
+  # @overload shared_examples
+  # @overload shared_examples
+  # @see ExampleGroup.it_behaves_like
+  # @see ExampleGroup.include_examples
+  # @see ExampleGroup.include_context
+  #
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#90
+  def shared_context(name, *args, &block); end
+
+  # Stores the block for later use. The block will be evaluated
+  # in the context of an example group via `include_examples`,
+  # `include_context`, or `it_behaves_like`.
+  #
+  # @example
+  #   shared_examples "auditable" do
+  #   it "stores an audit record on save!" do
+  #   expect { auditable.save! }.to change(Audit, :count).by(1)
+  #   end
+  #   end
+  #
+  #   RSpec.describe Account do
+  #   it_behaves_like "auditable" do
+  #   let(:auditable) { Account.new }
+  #   end
+  #   end
+  # @overload shared_examples
+  # @overload shared_examples
+  # @see ExampleGroup.it_behaves_like
+  # @see ExampleGroup.include_examples
+  # @see ExampleGroup.include_context
+  #
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#90
+  def shared_examples(name, *args, &block); end
+
+  # Stores the block for later use. The block will be evaluated
+  # in the context of an example group via `include_examples`,
+  # `include_context`, or `it_behaves_like`.
+  #
+  # @example
+  #   shared_examples "auditable" do
+  #   it "stores an audit record on save!" do
+  #   expect { auditable.save! }.to change(Audit, :count).by(1)
+  #   end
+  #   end
+  #
+  #   RSpec.describe Account do
+  #   it_behaves_like "auditable" do
+  #   let(:auditable) { Account.new }
+  #   end
+  #   end
+  # @overload shared_examples
+  # @overload shared_examples
+  # @see ExampleGroup.it_behaves_like
+  # @see ExampleGroup.include_examples
+  # @see ExampleGroup.include_context
+  #
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#90
+  def shared_examples_for(name, *args, &block); end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/shared_example_group.rb#149
+class RSpec::Core::SharedExampleGroup::Registry
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#150
+  def add(context, name, *metadata_args, &block); end
+
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#174
+  def find(lookup_contexts, name); end
+
+  private
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#257
+  def ensure_block_has_source_location(_block); end
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#245
+  def formatted_location(block); end
+
+  # TODO: remove this in RSpec 4. This exists only to support
+  # `config.shared_context_metadata_behavior == :trigger_inclusion`,
+  # the legacy behavior of shared context metadata, which we do
+  # not want to support in RSpec 4.
+  #
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#189
+  def legacy_add(context, name, *metadata_args, &block); end
+
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#204
+  def shared_example_groups; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#208
+  def valid_name?(candidate); end
+
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#215
+  def warn_if_key_taken(context, key, new_block); end
+end
+
+# Shared examples top level DSL.
+#
+# @api private
+#
+# source://rspec-core//lib/rspec/core/shared_example_group.rb#106
+module RSpec::Core::SharedExampleGroup::TopLevelDSL
+  class << self
+    # @api private
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/shared_example_group.rb#108
+    def definitions; end
+
+    # Adds the top level DSL methods to Module and the top level binding.
+    #
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core/shared_example_group.rb#126
+    def expose_globally!; end
+
+    # @api private
+    # @private
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/shared_example_group.rb#119
+    def exposed_globally?; end
+
+    # Removes the top level DSL methods to Module and the top level binding.
+    #
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core/shared_example_group.rb#135
+    def remove_globally!; end
+  end
+end
+
+# Contains information about the inclusion site of a shared example group.
+#
+# source://rspec-core//lib/rspec/core/example_group.rb#782
+class RSpec::Core::SharedExampleGroupInclusionStackFrame
+  # @private
+  # @return [SharedExampleGroupInclusionStackFrame] a new instance of SharedExampleGroupInclusionStackFrame
+  #
+  # source://rspec-core//lib/rspec/core/example_group.rb#789
+  def initialize(shared_group_name, inclusion_location); end
+
+  # @return [String] Description of this stack frame, in the form used by
+  #   RSpec's built-in formatters.
+  #
+  # source://rspec-core//lib/rspec/core/example_group.rb#805
+  def description; end
+
+  # @return [String] The {#inclusion_location}, formatted for display by a formatter.
+  #
+  # source://rspec-core//lib/rspec/core/example_group.rb#795
+  def formatted_inclusion_location; end
+
+  # @return [String] the location where the shared example was included
+  #
+  # source://rspec-core//lib/rspec/core/example_group.rb#786
+  def inclusion_location; end
+
+  # @return [String] the name of the shared example group
+  #
+  # source://rspec-core//lib/rspec/core/example_group.rb#784
+  def shared_group_name; end
+
+  class << self
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#811
+    def current_backtrace; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#829
+    def shared_example_group_inclusions; end
+
+    # @private
+    #
+    # source://rspec-core//lib/rspec/core/example_group.rb#816
+    def with_frame(name, location); end
+  end
+end
+
+# Represents some functionality that is shared with multiple example groups.
+# The functionality is defined by the provided block, which is lazily
+# eval'd when the `SharedExampleGroupModule` instance is included in an example
+# group.
+#
+# source://rspec-core//lib/rspec/core/shared_example_group.rb#9
+class RSpec::Core::SharedExampleGroupModule < ::Module
+  # @return [SharedExampleGroupModule] a new instance of SharedExampleGroupModule
+  #
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#13
+  def initialize(description, definition, metadata); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#11
+  def definition; end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#34
+  def include_in(klass, inclusion_line, args, customization_block); end
+
+  # Ruby callback for when a module is included in another module is class.
+  # Our definition evaluates the shared group block in the context of the
+  # including example group.
+  #
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#28
+  def included(klass); end
+
+  # Provides a human-readable representation of this module.
+  #
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#20
+  def inspect; end
+
+  # Provides a human-readable representation of this module.
+  #
+  # source://rspec-core//lib/rspec/core/shared_example_group.rb#20
+  def to_s; end
+end
+
+# Deals with the fact that `shellwords` only works on POSIX systems.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/shell_escape.rb#5
+module RSpec::Core::ShellEscape
+  private
+
+  # source://rspec-core//lib/rspec/core/shell_escape.rb#32
+  def conditionally_quote(id); end
+
+  # :nocov:
+  #
+  # source://rspec-core//lib/rspec/core/shell_escape.rb#19
+  def escape(shell_command); end
+
+  # source://rspec-core//lib/rspec/core/shell_escape.rb#8
+  def quote(argument); end
+
+  # source://rspec-core//lib/rspec/core/shell_escape.rb#37
+  def shell_allows_unquoted_ids?; end
+
+  class << self
+    # source://rspec-core//lib/rspec/core/shell_escape.rb#32
+    def conditionally_quote(id); end
+
+    # source://rspec-core//lib/rspec/core/shell_escape.rb#19
+    def escape(shell_command); end
+
+    # source://rspec-core//lib/rspec/core/shell_escape.rb#8
+    def quote(argument); end
+
+    # @return [Boolean]
+    #
+    # source://rspec-core//lib/rspec/core/shell_escape.rb#37
+    def shell_allows_unquoted_ids?; end
+  end
+end
+
+# Known shells that require quoting: zsh, csh, tcsh.
+#
+# Feel free to add other shells to this list that are known to
+# allow `rspec ./some_spec.rb[1:1]` syntax without quoting the id.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/shell_escape.rb#30
+RSpec::Core::ShellEscape::SHELLS_ALLOWING_UNQUOTED_IDS = T.let(T.unsafe(nil), Array)
+
+# Provides an execution context for before/after :suite hooks.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/example.rb#651
+class RSpec::Core::SuiteHookContext < ::RSpec::Core::Example
+  # @return [SuiteHookContext] a new instance of SuiteHookContext
+  #
+  # source://rspec-core//lib/rspec/core/example.rb#652
+  def initialize(hook_description, reporter); end
+
+  # source://rspec-core//lib/rspec/core/example.rb#659
+  def set_exception(exception); end
+end
+
+# This avoids issues with reporting time caused by examples that
+# change the value/meaning of Time.now without properly restoring
+# it.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core.rb#174
+class RSpec::Core::Time
+  class << self
+    def now(in: T.unsafe(nil)); end
+  end
+end
+
+# Version information for RSpec Core.
+#
+# source://rspec-core//lib/rspec/core/version.rb#4
+module RSpec::Core::Version; end
+
+# Current version of RSpec Core, in semantic versioning format.
+#
+# source://rspec-core//lib/rspec/core/version.rb#6
+RSpec::Core::Version::STRING = T.let(T.unsafe(nil), String)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/warnings.rb#6
+module RSpec::Core::Warnings
+  # Used internally to print deprecation warnings.
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/warnings.rb#10
+  def deprecate(deprecated, data = T.unsafe(nil)); end
+
+  # Used internally to print deprecation warnings.
+  #
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/warnings.rb#22
+  def warn_deprecation(message, opts = T.unsafe(nil)); end
+
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/warnings.rb#27
+  def warn_with(message, options = T.unsafe(nil)); end
+end
+
+# Internal container for global non-configuration data.
+#
+# @api private
+#
+# source://rspec-core//lib/rspec/core/world.rb#6
+class RSpec::Core::World
+  # @api private
+  # @return [World] a new instance of World
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#26
+  def initialize(configuration = T.unsafe(nil)); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#115
+  def all_example_groups; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#120
+  def all_examples; end
+
+  # Add exclusion filters to announcement message.
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#226
+  def announce_exclusion_filter(announcements); end
+
+  # Notify reporter of filters.
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#171
+  def announce_filters; end
+
+  # Add inclusion filters to announcement message.
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#217
+  def announce_inclusion_filter(announcements); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#210
+  def everything_filtered_message; end
+
+  # Get count of examples to be run.
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#109
+  def example_count(groups = T.unsafe(nil)); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#8
+  def example_group_counts_by_spec_file; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#8
+  def example_groups; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#102
+  def exclusion_filter; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#69
+  def filter_manager; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#8
+  def filtered_examples; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#97
+  def inclusion_filter; end
+
+  # Used internally to signal that a failure outside of an example
+  # has occurred, and that therefore the exit status should indicate
+  # the run failed.
+  #
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#24
+  def non_example_failure; end
+
+  # Used internally to signal that a failure outside of an example
+  # has occurred, and that therefore the exit status should indicate
+  # the run failed.
+  #
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#24
+  def non_example_failure=(_arg0); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#87
+  def num_example_groups_defined_in(file); end
+
+  # Apply ordering strategy from configuration to example groups.
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#52
+  def ordered_example_groups; end
+
+  # Find line number of previous declaration.
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#140
+  def preceding_declaration_line(absolute_file_name, filter_line); end
+
+  # Prepares filters so that they apply to example groups when they run.
+  #
+  # This is a separate method so that filters can be modified/replaced and
+  # examples refiltered during a process's lifetime, which can be useful for
+  # a custom runner.
+  #
+  # @api public
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#43
+  def prepare_example_filtering; end
+
+  # Records an example group.
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#81
+  def record(example_group); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#74
+  def registered_example_group_files; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#205
+  def report_filter_message(message); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#149
+  def reporter; end
+
+  # Reset world to 'scratch' before running suite.
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#60
+  def reset; end
+
+  # Used internally to signify that a SystemExit occurred in
+  # `Configuration#load_file_handling_errors`, and thus examples cannot
+  # be counted accurately. Specifically, we cannot accurately report
+  # "No examples found".
+  #
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#18
+  def rspec_is_quitting; end
+
+  # Used internally to signify that a SystemExit occurred in
+  # `Configuration#load_file_handling_errors`, and thus examples cannot
+  # be counted accurately. Specifically, we cannot accurately report
+  # "No examples found".
+  #
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#18
+  def rspec_is_quitting=(_arg0); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#92
+  def shared_example_group_registry; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#154
+  def source_from_file(path); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#164
+  def syntax_highlighter; end
+
+  # Traverses the tree of each top level group.
+  # For each it yields the group, then the children, recursively.
+  # Halts the traversal of a branch of the tree as soon as the passed block returns true.
+  # Note that siblings groups and their sub-trees will continue to be explored.
+  # This is intended to make it easy to find the top-most group that satisfies some
+  # condition.
+  #
+  # @api private
+  # @private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#131
+  def traverse_example_group_trees_until(&block); end
+
+  # Used internally to determine what to do when a SIGINT is received.
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#11
+  def wants_to_quit; end
+
+  # Used internally to determine what to do when a SIGINT is received.
+  #
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#11
+  def wants_to_quit=(_arg0); end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#234
+  def descending_declaration_line_numbers_by_file; end
+
+  # @api private
+  #
+  # source://rspec-core//lib/rspec/core/world.rb#252
+  def fail_if_config_and_cli_options_invalid; end
+end
+
+# Provides a null implementation for initial use by configuration.
+#
+# @api private
+# @private
+#
+# source://rspec-core//lib/rspec/core/world.rb#264
+module RSpec::Core::World::Null
+  class << self
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core/world.rb#280
+    def all_example_groups; end
+
+    # :nocov:
+    #
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core/world.rb#276
+    def example_groups; end
+
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core/world.rb#265
+    def non_example_failure; end
+
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core/world.rb#266
+    def non_example_failure=(_); end
+
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core/world.rb#268
+    def registered_example_group_files; end
+
+    # @api private
+    #
+    # source://rspec-core//lib/rspec/core/world.rb#272
+    def traverse_example_group_trees_until; end
+  end
+end
+
+# Namespace for the example group subclasses generated by top-level
+# `describe`.
+#
+# @private
+#
+# source://rspec-core//lib/rspec/core/example_group.rb#839
+module RSpec::ExampleGroups
+  extend ::RSpec::Support::RecursiveConstMethods
+
+  class << self
+    # source://rspec-core//lib/rspec/core/example_group.rb#842
+    def assign_const(group); end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#862
+    def base_name_for(group); end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#850
+    def constant_scope_for(group); end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#895
+    def disambiguate(name, const_scope); end
+
+    # source://rspec-core//lib/rspec/core/example_group.rb#856
+    def remove_all_constants; end
+  end
+end
+
+# @private
+#
+# source://rspec-core//lib/rspec/core.rb#187
+RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
+
+# @private
+#
+# source://rspec-core//lib/rspec/core/shared_context.rb#54
+RSpec::SharedContext = RSpec::Core::SharedContext
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.11.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.11.0.rbi
deleted file mode 100644
index 4d3323534f689..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.11.0.rbi
+++ /dev/null
@@ -1,1634 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rspec-expectations` gem.
-# Please instead update this file by running `bin/tapioca gem rspec-expectations`.
-
-module RSpec
-  extend ::RSpec::Support::Warnings
-  extend ::RSpec::Core::Warnings
-
-  class << self
-    def clear_examples; end
-    def configuration; end
-    def configuration=(_arg0); end
-    def configure; end
-    def const_missing(name); end
-    def context(*args, &example_group_block); end
-    def current_example; end
-    def current_example=(example); end
-    def current_scope; end
-    def current_scope=(scope); end
-    def describe(*args, &example_group_block); end
-    def example_group(*args, &example_group_block); end
-    def fcontext(*args, &example_group_block); end
-    def fdescribe(*args, &example_group_block); end
-    def reset; end
-    def shared_context(name, *args, &block); end
-    def shared_examples(name, *args, &block); end
-    def shared_examples_for(name, *args, &block); end
-    def world; end
-    def world=(_arg0); end
-    def xcontext(*args, &example_group_block); end
-    def xdescribe(*args, &example_group_block); end
-  end
-end
-
-module RSpec::Expectations
-  class << self
-    def configuration; end
-    def differ; end
-    def fail_with(message, expected = T.unsafe(nil), actual = T.unsafe(nil)); end
-  end
-end
-
-class RSpec::Expectations::BlockExpectationTarget < ::RSpec::Expectations::ExpectationTarget
-  def not_to(matcher, message = T.unsafe(nil), &block); end
-  def to(matcher, message = T.unsafe(nil), &block); end
-  def to_not(matcher, message = T.unsafe(nil), &block); end
-
-  private
-
-  def enforce_block_expectation(matcher); end
-  def supports_block_expectations?(matcher); end
-end
-
-class RSpec::Expectations::BlockSnippetExtractor
-  def initialize(proc, method_name); end
-
-  def body_content_lines; end
-  def method_name; end
-  def proc; end
-
-  private
-
-  def beginning_line_number; end
-  def block_token_extractor; end
-  def file_path; end
-  def raw_body_lines; end
-  def raw_body_snippet; end
-  def source; end
-  def source_location; end
-
-  class << self
-    def try_extracting_single_line_body_of(proc, method_name); end
-  end
-end
-
-class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < ::RSpec::Expectations::BlockSnippetExtractor::Error; end
-
-class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < ::Struct
-  def beginning_line_number; end
-  def beginning_line_number=(_); end
-  def body_content_locations; end
-  def method_call_location; end
-  def method_name; end
-  def method_name=(_); end
-  def source; end
-  def source=(_); end
-
-  private
-
-  def block_body_node; end
-  def block_wrapper_node; end
-  def candidate_block_wrapper_nodes; end
-  def candidate_method_ident_nodes; end
-  def method_ident_node; end
-  def method_ident_node?(node); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < ::Struct
-  def initialize(*_arg0); end
-
-  def beginning_line_number; end
-  def beginning_line_number=(_); end
-  def body_tokens; end
-  def method_name; end
-  def method_name=(_); end
-  def source; end
-  def source=(_); end
-  def state; end
-
-  private
-
-  def after_beginning_of_args_state(token); end
-  def after_beginning_of_body_state(token); end
-  def after_method_call_state(token); end
-  def after_opener_state(token); end
-  def block_locator; end
-  def correct_block?(body_tokens); end
-  def finalize_pending_tokens!; end
-  def finish!; end
-  def finish_or_find_next_block_if_incorrect!; end
-  def handle_closer_token(token); end
-  def handle_opener_token(token); end
-  def initial_state(token); end
-  def invoke_state_handler(token); end
-  def opener_token?(token); end
-  def opener_token_stack; end
-  def parse!; end
-  def pending_tokens; end
-  def pipe_token?(token); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Expectations::BlockSnippetExtractor::Error < ::StandardError; end
-class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < ::RSpec::Expectations::BlockSnippetExtractor::Error; end
-
-class RSpec::Expectations::Configuration
-  def initialize; end
-
-  def add_should_and_should_not_to(*modules); end
-  def backtrace_formatter; end
-  def backtrace_formatter=(_arg0); end
-  def color?; end
-  def false_positives_handler; end
-  def include_chain_clauses_in_custom_matcher_descriptions=(_arg0); end
-  def include_chain_clauses_in_custom_matcher_descriptions?; end
-  def max_formatted_output_length=(length); end
-  def on_potential_false_positives; end
-  def on_potential_false_positives=(behavior); end
-  def reset_syntaxes_to_default; end
-  def strict_predicate_matchers; end
-  def strict_predicate_matchers=(flag); end
-  def strict_predicate_matchers?; end
-  def syntax; end
-  def syntax=(values); end
-  def warn_about_potential_false_positives=(boolean); end
-  def warn_about_potential_false_positives?; end
-end
-
-RSpec::Expectations::Configuration::FALSE_POSITIVE_BEHAVIOURS = T.let(T.unsafe(nil), Hash)
-
-module RSpec::Expectations::Configuration::NullBacktraceFormatter
-  class << self
-    def format_backtrace(backtrace); end
-  end
-end
-
-module RSpec::Expectations::ExpectationHelper
-  class << self
-    def check_message(msg); end
-    def handle_failure(matcher, message, failure_message_method); end
-    def modern_matcher_from(matcher); end
-    def with_matcher(handler, matcher, message); end
-  end
-end
-
-class RSpec::Expectations::ExpectationNotMetError < ::Exception; end
-
-class RSpec::Expectations::ExpectationTarget
-  include ::RSpec::Expectations::ExpectationTarget::InstanceMethods
-
-  def initialize(value); end
-
-  def target; end
-
-  class << self
-    def for(value, block); end
-  end
-end
-
-module RSpec::Expectations::ExpectationTarget::InstanceMethods
-  def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
-  def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
-  def to_not(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
-
-  private
-
-  def prevent_operator_matchers(verb); end
-end
-
-module RSpec::Expectations::ExpectationTarget::UndefinedValue; end
-
-class RSpec::Expectations::FailureAggregator
-  def initialize(block_label, metadata); end
-
-  def aggregate; end
-  def block_label; end
-  def call(failure, options); end
-  def failures; end
-  def metadata; end
-  def other_errors; end
-
-  private
-
-  def assign_backtrace(failure); end
-  def notify_aggregated_failures; end
-end
-
-RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter
-
-class RSpec::Expectations::LegacyMatcherAdapter < ::RSpec::Matchers::MatcherDelegator
-  def initialize(matcher); end
-
-  class << self
-    def wrap(matcher); end
-  end
-end
-
-class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < ::RSpec::Expectations::LegacyMatcherAdapter
-  def failure_message; end
-  def failure_message_when_negated; end
-
-  class << self
-    def interface_matches?(matcher); end
-  end
-end
-
-class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < ::RSpec::Expectations::LegacyMatcherAdapter
-  def failure_message; end
-  def failure_message_when_negated; end
-
-  class << self
-    def interface_matches?(matcher); end
-  end
-end
-
-class RSpec::Expectations::MultipleExpectationsNotMetError < ::RSpec::Expectations::ExpectationNotMetError
-  def initialize(failure_aggregator); end
-
-  def aggregation_block_label; end
-  def aggregation_metadata; end
-  def all_exceptions; end
-  def exception_count_description; end
-  def failures; end
-  def message; end
-  def other_errors; end
-  def summary; end
-
-  private
-
-  def backtrace_line(line); end
-  def block_description; end
-  def enumerated(exceptions, index_offset); end
-  def enumerated_errors; end
-  def enumerated_failures; end
-  def exclusion_patterns; end
-  def format_backtrace(backtrace); end
-  def indentation; end
-  def indented(failure_message, index); end
-  def index_label(index); end
-  def longest_index_label_width; end
-  def pluralize(noun, count); end
-  def width_of_label(index); end
-end
-
-class RSpec::Expectations::NegativeExpectationHandler
-  class << self
-    def does_not_match?(matcher, actual, &block); end
-    def handle_matcher(actual, initial_matcher, custom_message = T.unsafe(nil), &block); end
-    def opposite_should_method; end
-    def should_method; end
-    def verb; end
-  end
-end
-
-class RSpec::Expectations::PositiveExpectationHandler
-  class << self
-    def handle_matcher(actual, initial_matcher, custom_message = T.unsafe(nil), &block); end
-    def opposite_should_method; end
-    def should_method; end
-    def verb; end
-  end
-end
-
-module RSpec::Expectations::Syntax
-  private
-
-  def default_should_host; end
-  def disable_expect(syntax_host = T.unsafe(nil)); end
-  def disable_should(syntax_host = T.unsafe(nil)); end
-  def enable_expect(syntax_host = T.unsafe(nil)); end
-  def enable_should(syntax_host = T.unsafe(nil)); end
-  def expect_enabled?(syntax_host = T.unsafe(nil)); end
-  def should_enabled?(syntax_host = T.unsafe(nil)); end
-  def warn_about_should!; end
-  def warn_about_should_unless_configured(method_name); end
-
-  class << self
-    def default_should_host; end
-    def disable_expect(syntax_host = T.unsafe(nil)); end
-    def disable_should(syntax_host = T.unsafe(nil)); end
-    def enable_expect(syntax_host = T.unsafe(nil)); end
-    def enable_should(syntax_host = T.unsafe(nil)); end
-    def expect_enabled?(syntax_host = T.unsafe(nil)); end
-    def should_enabled?(syntax_host = T.unsafe(nil)); end
-    def warn_about_should!; end
-    def warn_about_should_unless_configured(method_name); end
-  end
-end
-
-class RSpec::Expectations::ValueExpectationTarget < ::RSpec::Expectations::ExpectationTarget
-  def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
-  def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
-
-  private
-
-  def enforce_value_expectation(matcher); end
-  def supports_value_expectations?(matcher); end
-end
-
-module RSpec::Expectations::Version; end
-RSpec::Expectations::Version::STRING = T.let(T.unsafe(nil), String)
-RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
-
-module RSpec::Matchers
-  extend ::RSpec::Matchers::DSL
-
-  def a_block_changing(*args, &block); end
-  def a_block_outputting(*args, &block); end
-  def a_block_raising(*args, &block); end
-  def a_block_throwing(*args, &block); end
-  def a_block_yielding_control(*args, &block); end
-  def a_block_yielding_successive_args(*args, &block); end
-  def a_block_yielding_with_args(*args, &block); end
-  def a_block_yielding_with_no_args(*args, &block); end
-  def a_collection_containing_exactly(*args, &block); end
-  def a_collection_ending_with(*args, &block); end
-  def a_collection_including(*args, &block); end
-  def a_collection_starting_with(*args, &block); end
-  def a_falsey_value(*args, &block); end
-  def a_falsy_value(*args, &block); end
-  def a_hash_including(*args, &block); end
-  def a_kind_of(*args, &block); end
-  def a_nil_value(*args, &block); end
-  def a_range_covering(*args, &block); end
-  def a_string_ending_with(*args, &block); end
-  def a_string_including(*args, &block); end
-  def a_string_matching(*args, &block); end
-  def a_string_starting_with(*args, &block); end
-  def a_truthy_value(*args, &block); end
-  def a_value(*args, &block); end
-  def a_value_between(*args, &block); end
-  def a_value_within(*args, &block); end
-  def aggregate_failures(label = T.unsafe(nil), metadata = T.unsafe(nil), &block); end
-  def all(expected); end
-  def an_instance_of(*args, &block); end
-  def an_object_eq_to(*args, &block); end
-  def an_object_eql_to(*args, &block); end
-  def an_object_equal_to(*args, &block); end
-  def an_object_existing(*args, &block); end
-  def an_object_having_attributes(*args, &block); end
-  def an_object_matching(*args, &block); end
-  def an_object_responding_to(*args, &block); end
-  def an_object_satisfying(*args, &block); end
-  def be(*args); end
-  def be_a(klass); end
-  def be_a_kind_of(expected); end
-  def be_an(klass); end
-  def be_an_instance_of(expected); end
-  def be_between(min, max); end
-  def be_falsey; end
-  def be_falsy(*args, &block); end
-  def be_instance_of(expected); end
-  def be_kind_of(expected); end
-  def be_nil; end
-  def be_truthy; end
-  def be_within(delta); end
-  def change(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
-  def changing(*args, &block); end
-  def contain_exactly(*items); end
-  def containing_exactly(*args, &block); end
-  def cover(*values); end
-  def covering(*args, &block); end
-  def end_with(*expected); end
-  def ending_with(*args, &block); end
-  def eq(expected); end
-  def eq_to(*args, &block); end
-  def eql(expected); end
-  def eql_to(*args, &block); end
-  def equal(expected); end
-  def equal_to(*args, &block); end
-  def exist(*args); end
-  def existing(*args, &block); end
-  def expect(value = T.unsafe(nil), &block); end
-  def have_attributes(expected); end
-  def having_attributes(*args, &block); end
-  def include(*expected); end
-  def including(*args, &block); end
-  def match(expected); end
-  def match_array(items); end
-  def match_regex(*args, &block); end
-  def matching(*args, &block); end
-  def output(expected = T.unsafe(nil)); end
-  def raise_error(error = T.unsafe(nil), message = T.unsafe(nil), &block); end
-  def raise_exception(error = T.unsafe(nil), message = T.unsafe(nil), &block); end
-  def raising(*args, &block); end
-  def respond_to(*names); end
-  def responding_to(*args, &block); end
-  def satisfy(description = T.unsafe(nil), &block); end
-  def satisfying(*args, &block); end
-  def start_with(*expected); end
-  def starting_with(*args, &block); end
-  def throw_symbol(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
-  def throwing(*args, &block); end
-  def within(*args, &block); end
-  def yield_control; end
-  def yield_successive_args(*args); end
-  def yield_with_args(*args); end
-  def yield_with_no_args; end
-  def yielding_control(*args, &block); end
-  def yielding_successive_args(*args, &block); end
-  def yielding_with_args(*args, &block); end
-  def yielding_with_no_args(*args, &block); end
-
-  private
-
-  def method_missing(method, *args, &block); end
-  def respond_to_missing?(method, *_arg1); end
-
-  class << self
-    def alias_matcher(*args, &block); end
-    def clear_generated_description; end
-    def configuration; end
-    def generated_description; end
-    def is_a_describable_matcher?(obj); end
-    def is_a_matcher?(obj); end
-    def last_description; end
-    def last_expectation_handler; end
-    def last_expectation_handler=(_arg0); end
-    def last_matcher; end
-    def last_matcher=(_arg0); end
-  end
-end
-
-class RSpec::Matchers::AliasedMatcher < ::RSpec::Matchers::MatcherDelegator
-  def initialize(base_matcher, description_block); end
-
-  def description; end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def method_missing(*_arg0); end
-end
-
-class RSpec::Matchers::AliasedMatcherWithOperatorSupport < ::RSpec::Matchers::AliasedMatcher; end
-
-class RSpec::Matchers::AliasedNegatedMatcher < ::RSpec::Matchers::AliasedMatcher
-  def does_not_match?(*args, &block); end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(*args, &block); end
-
-  private
-
-  def optimal_failure_message(same, inverted); end
-end
-
-RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
-RSpec::Matchers::BE_PREDICATE_REGEX = T.let(T.unsafe(nil), Regexp)
-module RSpec::Matchers::BuiltIn; end
-
-class RSpec::Matchers::BuiltIn::All < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(matcher); end
-
-  def description; end
-  def does_not_match?(_actual); end
-  def failed_objects; end
-  def failure_message; end
-  def matcher; end
-
-  private
-
-  def add_new_line_if_needed(message); end
-  def failure_message_for_item(index, failure_message); end
-  def indent_multiline_message(message); end
-  def index_failed_objects; end
-  def initialize_copy(other); end
-  def iterable?; end
-  def match(_expected, _actual); end
-end
-
-class RSpec::Matchers::BuiltIn::BaseMatcher
-  include ::RSpec::Matchers::Composable
-  include ::RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
-  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
-
-  def initialize(expected = T.unsafe(nil)); end
-
-  def actual; end
-  def actual_formatted; end
-  def description; end
-  def diffable?; end
-  def expected; end
-  def expected_formatted; end
-  def expects_call_stack_jump?; end
-  def match_unless_raises(*exceptions); end
-  def matcher_name; end
-  def matcher_name=(_arg0); end
-  def matches?(actual); end
-  def present_ivars; end
-  def rescued_exception; end
-  def supports_block_expectations?; end
-  def supports_value_expectations?; end
-
-  private
-
-  def assert_ivars(*expected_ivars); end
-
-  class << self
-    def matcher_name; end
-
-    private
-
-    def underscore(camel_cased_word); end
-  end
-end
-
-module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
-  def failure_message; end
-  def failure_message_when_negated; end
-
-  class << self
-    def has_default_failure_messages?(matcher); end
-  end
-end
-
-module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
-  private
-
-  def improve_hash_formatting(inspect_string); end
-
-  class << self
-    def improve_hash_formatting(inspect_string); end
-  end
-end
-
-RSpec::Matchers::BuiltIn::BaseMatcher::UNDEFINED = T.let(T.unsafe(nil), Object)
-
-class RSpec::Matchers::BuiltIn::Be < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  include ::RSpec::Matchers::BuiltIn::BeHelpers
-
-  def initialize(*args); end
-
-  def <(operand); end
-  def <=(operand); end
-  def ==(operand); end
-  def ===(operand); end
-  def =~(operand); end
-  def >(operand); end
-  def >=(operand); end
-  def failure_message; end
-  def failure_message_when_negated; end
-
-  private
-
-  def match(_, actual); end
-end
-
-class RSpec::Matchers::BuiltIn::BeAKindOf < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  private
-
-  def match(expected, actual); end
-end
-
-class RSpec::Matchers::BuiltIn::BeAnInstanceOf < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def description; end
-
-  private
-
-  def match(expected, actual); end
-end
-
-class RSpec::Matchers::BuiltIn::BeBetween < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(min, max); end
-
-  def description; end
-  def exclusive; end
-  def failure_message; end
-  def inclusive; end
-  def matches?(actual); end
-
-  private
-
-  def comparable?; end
-  def compare; end
-  def not_comparable_clause; end
-end
-
-class RSpec::Matchers::BuiltIn::BeComparedTo < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  include ::RSpec::Matchers::BuiltIn::BeHelpers
-
-  def initialize(operand, operator); end
-
-  def description; end
-  def does_not_match?(actual); end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(actual); end
-
-  private
-
-  def perform_match(actual); end
-end
-
-class RSpec::Matchers::BuiltIn::BeFalsey < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def failure_message; end
-  def failure_message_when_negated; end
-
-  private
-
-  def match(_, actual); end
-end
-
-module RSpec::Matchers::BuiltIn::BeHelpers
-  private
-
-  def args_to_s; end
-  def args_to_sentence; end
-  def expected_to_sentence; end
-  def inspected_args; end
-  def parenthesize(string); end
-end
-
-class RSpec::Matchers::BuiltIn::BeNil < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def failure_message; end
-  def failure_message_when_negated; end
-
-  private
-
-  def match(_, actual); end
-end
-
-class RSpec::Matchers::BuiltIn::BePredicate < ::RSpec::Matchers::BuiltIn::DynamicPredicate
-  private
-
-  def failure_to_respond_explanation; end
-  def predicate; end
-  def predicate_accessible?; end
-  def predicate_method_name; end
-  def present_tense_predicate; end
-end
-
-RSpec::Matchers::BuiltIn::BePredicate::REGEX = T.let(T.unsafe(nil), Regexp)
-
-class RSpec::Matchers::BuiltIn::BeTruthy < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def failure_message; end
-  def failure_message_when_negated; end
-
-  private
-
-  def match(_, actual); end
-end
-
-class RSpec::Matchers::BuiltIn::BeWithin < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(delta); end
-
-  def description; end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(actual); end
-  def of(expected); end
-  def percent_of(expected); end
-
-  private
-
-  def needs_expected; end
-  def not_numeric_clause; end
-  def numeric?; end
-end
-
-module RSpec::Matchers::BuiltIn::CaptureStderr
-  class << self
-    def capture(block); end
-    def name; end
-  end
-end
-
-module RSpec::Matchers::BuiltIn::CaptureStdout
-  class << self
-    def capture(block); end
-    def name; end
-  end
-end
-
-class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < ::Struct
-  def capture(block); end
-end
-
-class RSpec::Matchers::BuiltIn::Change < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
-
-  def by(expected_delta); end
-  def by_at_least(minimum); end
-  def by_at_most(maximum); end
-  def description; end
-  def does_not_match?(event_proc); end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def from(value); end
-  def matches?(event_proc); end
-  def supports_block_expectations?; end
-  def supports_value_expectations?; end
-  def to(value); end
-
-  private
-
-  def change_details; end
-  def negative_failure_reason; end
-  def perform_change(event_proc); end
-  def positive_failure_reason; end
-  def raise_block_syntax_error; end
-end
-
-class RSpec::Matchers::BuiltIn::ChangeDetails
-  def initialize(matcher_name, receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
-
-  def actual_after; end
-  def actual_delta; end
-  def changed?; end
-  def perform_change(event_proc); end
-  def value_representation; end
-
-  private
-
-  def evaluate_value_proc; end
-  def extract_value_block_snippet; end
-  def message_notation(receiver, message); end
-end
-
-module RSpec::Matchers::BuiltIn::ChangeDetails::UNDEFINED; end
-
-class RSpec::Matchers::BuiltIn::ChangeFromValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange
-  def initialize(change_details, expected_before); end
-
-  def does_not_match?(event_proc); end
-  def failure_message_when_negated; end
-  def to(value); end
-
-  private
-
-  def change_description; end
-end
-
-class RSpec::Matchers::BuiltIn::ChangeRelatively < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(change_details, expected_delta, relativity, &comparer); end
-
-  def description; end
-  def does_not_match?(_event_proc); end
-  def failure_message; end
-  def matches?(event_proc); end
-  def supports_block_expectations?; end
-  def supports_value_expectations?; end
-
-  private
-
-  def failure_reason; end
-end
-
-class RSpec::Matchers::BuiltIn::ChangeToValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange
-  def initialize(change_details, expected_after); end
-
-  def does_not_match?(_event_proc); end
-  def from(value); end
-
-  private
-
-  def change_description; end
-end
-
-class RSpec::Matchers::BuiltIn::Compound < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(matcher_1, matcher_2); end
-
-  def description; end
-  def diffable?; end
-  def does_not_match?(_actual); end
-  def evaluator; end
-  def expected; end
-  def expects_call_stack_jump?; end
-  def matcher_1; end
-  def matcher_2; end
-  def supports_block_expectations?; end
-  def supports_value_expectations?; end
-
-  protected
-
-  def diffable_matcher_list; end
-
-  private
-
-  def compound_failure_message; end
-  def diffable_matcher_list_for(matcher); end
-  def indent_multiline_message(message); end
-  def initialize_copy(other); end
-  def match(_expected, actual); end
-  def matcher_1_matches?; end
-  def matcher_2_matches?; end
-  def matcher_is_diffable?(matcher); end
-  def matcher_supports_block_expectations?(matcher); end
-  def matcher_supports_value_expectations?(matcher); end
-end
-
-class RSpec::Matchers::BuiltIn::Compound::And < ::RSpec::Matchers::BuiltIn::Compound
-  def failure_message; end
-
-  private
-
-  def conjunction; end
-  def match(*_arg0); end
-end
-
-class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
-  def initialize(actual, matcher_1, matcher_2); end
-
-  def matcher_matches?(matcher); end
-
-  private
-
-  def inner_matcher_block(outer_args); end
-  def order_block_matchers; end
-
-  class << self
-    def matcher_expects_call_stack_jump?(matcher); end
-  end
-end
-
-class RSpec::Matchers::BuiltIn::Compound::Or < ::RSpec::Matchers::BuiltIn::Compound
-  def failure_message; end
-
-  private
-
-  def conjunction; end
-  def match(*_arg0); end
-end
-
-class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator
-  def initialize(actual, *_arg1); end
-
-  def matcher_matches?(matcher); end
-end
-
-class RSpec::Matchers::BuiltIn::ContainExactly < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def description; end
-  def failure_message; end
-  def failure_message_when_negated; end
-
-  private
-
-  def actual_collection_line; end
-  def best_solution; end
-  def convert_actual_to_an_array; end
-  def describe_collection(collection, surface_descriptions = T.unsafe(nil)); end
-  def expected_collection_line; end
-  def extra_elements_line; end
-  def extra_items; end
-  def generate_failure_message; end
-  def match(_expected, _actual); end
-  def match_when_sorted?; end
-  def message_line(prefix, collection, surface_descriptions = T.unsafe(nil)); end
-  def missing_elements_line; end
-  def missing_items; end
-  def pairings_maximizer; end
-  def safe_sort(array); end
-  def to_a_disallowed?(object); end
-end
-
-class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
-  def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end
-
-  def actual_to_expected_matched_indexes; end
-  def expected_to_actual_matched_indexes; end
-  def find_best_solution; end
-  def solution; end
-
-  private
-
-  def apply_pairing_to(indeterminates, original_matches, other_list_index); end
-  def best_solution_for_pairing(expected_index, actual_index); end
-  def categorize_indexes(indexes_to_categorize, other_indexes); end
-  def reciprocal_single_match?(matches, index, other_list); end
-end
-
-class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
-  class << self
-    def worse_than?(_other); end
-  end
-end
-
-class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < ::Struct
-  def +(derived_candidate_solution); end
-  def candidate?; end
-  def ideal?; end
-  def indeterminate_actual_indexes; end
-  def indeterminate_actual_indexes=(_); end
-  def indeterminate_expected_indexes; end
-  def indeterminate_expected_indexes=(_); end
-  def unmatched_actual_indexes; end
-  def unmatched_actual_indexes=(_); end
-  def unmatched_expected_indexes; end
-  def unmatched_expected_indexes=(_); end
-  def unmatched_item_count; end
-  def worse_than?(other); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-module RSpec::Matchers::BuiltIn::CountExpectation
-  def at_least(number); end
-  def at_most(number); end
-  def exactly(number); end
-  def once; end
-  def thrice; end
-  def times; end
-  def twice; end
-
-  protected
-
-  def count_expectation_type; end
-  def expected_count; end
-
-  private
-
-  def count_constraint_to_number(n); end
-  def count_expectation_description; end
-  def count_failure_reason(action); end
-  def cover?(count, number); end
-  def expected_count_matches?(actual_count); end
-  def has_expected_count?; end
-  def human_readable_count(count); end
-  def human_readable_expectation_type; end
-  def raise_impossible_count_expectation(count); end
-  def raise_unsupported_count_expectation; end
-  def set_expected_count(relativity, n); end
-  def unsupported_count_expectation?(relativity); end
-end
-
-class RSpec::Matchers::BuiltIn::Cover < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(*expected); end
-
-  def does_not_match?(range); end
-  def matches?(range); end
-end
-
-class RSpec::Matchers::BuiltIn::DynamicPredicate < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  include ::RSpec::Matchers::BuiltIn::BeHelpers
-
-  def initialize(method_name, *args, &block); end
-
-  def description; end
-  def does_not_match?(actual, &block); end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(actual, &block); end
-
-  private
-
-  def expectation_of(value); end
-  def failure_message_expecting(value); end
-  def failure_to_respond_explanation; end
-  def method_description; end
-  def predicate_accessible?; end
-  def predicate_matches?(value = T.unsafe(nil)); end
-  def predicate_method_name; end
-  def predicate_result; end
-  def private_predicate?; end
-  def root; end
-  def validity_message; end
-end
-
-class RSpec::Matchers::BuiltIn::EndWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith
-  private
-
-  def element_matches?; end
-  def subset_matches?; end
-end
-
-class RSpec::Matchers::BuiltIn::Eq < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def description; end
-  def diffable?; end
-  def failure_message; end
-  def failure_message_when_negated; end
-
-  private
-
-  def match(expected, actual); end
-end
-
-class RSpec::Matchers::BuiltIn::Eql < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def diffable?; end
-  def failure_message; end
-  def failure_message_when_negated; end
-
-  private
-
-  def match(expected, actual); end
-end
-
-class RSpec::Matchers::BuiltIn::Equal < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def diffable?; end
-  def failure_message; end
-  def failure_message_when_negated; end
-
-  private
-
-  def actual_inspected; end
-  def detailed_failure_message; end
-  def expected_is_a_literal_singleton?; end
-  def inspect_object(o); end
-  def match(expected, actual); end
-  def simple_failure_message; end
-end
-
-RSpec::Matchers::BuiltIn::Equal::LITERAL_SINGLETONS = T.let(T.unsafe(nil), Array)
-
-class RSpec::Matchers::BuiltIn::Exist < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(*expected); end
-
-  def does_not_match?(actual); end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(actual); end
-end
-
-class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < ::Struct
-  def actual_exists?; end
-  def valid_test?; end
-  def validity_message; end
-
-  private
-
-  def deprecated(predicate, actual); end
-  def existence_values; end
-  def predicates; end
-  def uniq_truthy_values; end
-end
-
-class RSpec::Matchers::BuiltIn::Has < ::RSpec::Matchers::BuiltIn::DynamicPredicate
-  private
-
-  def predicate; end
-end
-
-RSpec::Matchers::BuiltIn::Has::REGEX = T.let(T.unsafe(nil), Regexp)
-
-class RSpec::Matchers::BuiltIn::HaveAttributes < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(expected); end
-
-  def actual; end
-  def description; end
-  def diffable?; end
-  def does_not_match?(actual); end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(actual); end
-  def respond_to_failed; end
-
-  private
-
-  def actual_has_attribute?(attribute_key, attribute_value); end
-  def cache_all_values; end
-  def formatted_values; end
-  def perform_match(predicate); end
-  def respond_to_attributes?; end
-  def respond_to_failure_message_or; end
-  def respond_to_matcher; end
-end
-
-class RSpec::Matchers::BuiltIn::Include < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  include ::RSpec::Matchers::BuiltIn::CountExpectation
-
-  def initialize(*expecteds); end
-
-  def description; end
-  def diffable?; end
-  def does_not_match?(actual); end
-  def expected; end
-  def expecteds; end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(actual); end
-
-  private
-
-  def actual_collection_includes?(expected_item); end
-  def actual_hash_has_key?(expected_key); end
-  def actual_hash_includes?(expected_key, expected_value); end
-  def check_actual?(actual); end
-  def check_expected_count?; end
-  def comparing_hash_keys?(expected_item); end
-  def comparing_hash_to_a_subset?(expected_item); end
-  def convert_to_hash?(obj); end
-  def count_enumerable(expected_item); end
-  def count_inclusions; end
-  def diff_would_wrongly_highlight_matched_item?; end
-  def excluded_from_actual; end
-  def format_failure_message(preposition); end
-  def perform_match(&block); end
-  def readable_list_of(items); end
-end
-
-class RSpec::Matchers::BuiltIn::Match < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(expected); end
-
-  def description; end
-  def diffable?; end
-  def with_captures(*captures); end
-
-  private
-
-  def can_safely_call_match?(expected, actual); end
-  def match(expected, actual); end
-  def match_captures(expected, actual); end
-end
-
-class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher
-  def __delegate_operator(actual, operator, expected); end
-end
-
-module RSpec::Matchers::BuiltIn::NullCapture
-  class << self
-    def capture(_block); end
-    def name; end
-  end
-end
-
-class RSpec::Matchers::BuiltIn::OperatorMatcher
-  def initialize(actual); end
-
-  def !=(_expected); end
-  def !~(_expected); end
-  def <(expected); end
-  def <=(expected); end
-  def ==(expected); end
-  def ===(expected); end
-  def =~(expected); end
-  def >(expected); end
-  def >=(expected); end
-  def description; end
-  def fail_with_message(message); end
-
-  private
-
-  def eval_match(actual, operator, expected); end
-  def has_non_generic_implementation_of?(op); end
-
-  class << self
-    def get(klass, operator); end
-    def register(klass, operator, matcher); end
-    def registry; end
-    def unregister(klass, operator); end
-    def use_custom_matcher_or_delegate(operator); end
-  end
-end
-
-class RSpec::Matchers::BuiltIn::Output < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(expected); end
-
-  def description; end
-  def diffable?; end
-  def does_not_match?(block); end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(block); end
-  def supports_block_expectations?; end
-  def supports_value_expectations?; end
-  def to_stderr; end
-  def to_stderr_from_any_process; end
-  def to_stdout; end
-  def to_stdout_from_any_process; end
-
-  private
-
-  def actual_output_description; end
-  def captured?; end
-  def negative_failure_reason; end
-  def positive_failure_reason; end
-end
-
-class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher
-  def __delegate_operator(actual, operator, expected); end
-end
-
-class RSpec::Matchers::BuiltIn::RaiseError
-  include ::RSpec::Matchers::Composable
-
-  def initialize(expected_error_or_message, expected_message, &block); end
-
-  def description; end
-  def does_not_match?(given_proc); end
-  def expects_call_stack_jump?; end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(given_proc, negative_expectation = T.unsafe(nil), &block); end
-  def supports_block_expectations?; end
-  def supports_value_expectations?; end
-  def with_message(expected_message); end
-
-  private
-
-  def actual_error_message; end
-  def block_matches?; end
-  def error_and_message_match?; end
-  def eval_block; end
-  def expectation_matched?; end
-  def expected_error; end
-  def expecting_specific_exception?; end
-  def format_backtrace(backtrace); end
-  def given_error; end
-  def handle_warning(message); end
-  def raise_message_already_set; end
-  def ready_to_eval_block?; end
-  def verify_message; end
-  def warn_about_bare_error!; end
-  def warn_about_bare_error?; end
-  def warn_about_negative_false_positive!(expression); end
-  def warn_about_nil_error!; end
-  def warn_about_nil_error?; end
-  def warn_for_negative_false_positives!; end
-  def warning; end
-end
-
-RSpec::Matchers::BuiltIn::RaiseError::UndefinedValue = T.let(T.unsafe(nil), Object)
-
-class RSpec::Matchers::BuiltIn::ReliableMatchData
-  def initialize(match_data); end
-
-  def captures; end
-  def names; end
-
-  protected
-
-  def match_data; end
-end
-
-class RSpec::Matchers::BuiltIn::RespondTo < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(*names); end
-
-  def and_any_keywords; end
-  def and_keywords(*keywords); end
-  def and_unlimited_arguments; end
-  def argument; end
-  def arguments; end
-  def description; end
-  def does_not_match?(actual); end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def ignoring_method_signature_failure!; end
-  def matches?(actual); end
-  def with(n); end
-  def with_any_keywords; end
-  def with_keywords(*keywords); end
-  def with_unlimited_arguments; end
-
-  private
-
-  def find_failing_method_names(actual, filter_method); end
-  def matches_arity?(actual, name); end
-  def pp_names; end
-  def with_arity; end
-  def with_arity_string; end
-  def with_keywords_string; end
-end
-
-class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck
-  def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end
-
-  def matches?(actual, name); end
-  def method_signature_for(actual, name); end
-  def verifier_for(actual, name); end
-end
-
-class RSpec::Matchers::BuiltIn::Satisfy < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(description = T.unsafe(nil), &block); end
-
-  def description; end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(actual, &block); end
-
-  private
-
-  def block_representation; end
-  def extract_block_snippet; end
-end
-
-class RSpec::Matchers::BuiltIn::SpecificValuesChange < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(change_details, from, to); end
-
-  def description; end
-  def failure_message; end
-  def matches?(event_proc); end
-  def supports_block_expectations?; end
-  def supports_value_expectations?; end
-
-  private
-
-  def after_value_failure; end
-  def before_value_failure; end
-  def did_change_failure; end
-  def did_not_change_failure; end
-  def matches_after?; end
-  def not_given_a_block_failure; end
-  def perform_change(event_proc); end
-end
-
-RSpec::Matchers::BuiltIn::SpecificValuesChange::MATCH_ANYTHING = BasicObject
-RSpec::Matchers::BuiltIn::StartAndEndWith = RSpec::Matchers::BuiltIn::StartOrEndWith
-
-class RSpec::Matchers::BuiltIn::StartOrEndWith < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(*expected); end
-
-  def description; end
-  def failure_message; end
-
-  private
-
-  def match(_expected, actual); end
-  def subsets_comparable?; end
-end
-
-class RSpec::Matchers::BuiltIn::StartWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith
-  private
-
-  def element_matches?; end
-  def subset_matches?; end
-end
-
-class RSpec::Matchers::BuiltIn::ThrowSymbol
-  include ::RSpec::Matchers::Composable
-
-  def initialize(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
-
-  def description; end
-  def does_not_match?(given_proc); end
-  def expects_call_stack_jump?; end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(given_proc); end
-  def supports_block_expectations?; end
-  def supports_value_expectations?; end
-
-  private
-
-  def actual_result; end
-  def caught; end
-  def expected(symbol_desc = T.unsafe(nil)); end
-  def throw_description(symbol, arg); end
-end
-
-class RSpec::Matchers::BuiltIn::YieldControl < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  include ::RSpec::Matchers::BuiltIn::CountExpectation
-
-  def does_not_match?(block); end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(block); end
-  def supports_block_expectations?; end
-  def supports_value_expectations?; end
-
-  private
-
-  def failure_reason; end
-end
-
-class RSpec::Matchers::BuiltIn::YieldProbe
-  def initialize(block, &callback); end
-
-  def assert_used!; end
-  def assert_valid_expect_block!; end
-  def has_block?; end
-  def num_yields; end
-  def num_yields=(_arg0); end
-  def probe; end
-  def single_yield_args; end
-  def to_proc; end
-  def yielded_args; end
-  def yielded_args=(_arg0); end
-  def yielded_once?(matcher_name); end
-
-  class << self
-    def probe(block, &callback); end
-  end
-end
-
-class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(*args); end
-
-  def description; end
-  def does_not_match?(block); end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(block); end
-  def supports_block_expectations?; end
-  def supports_value_expectations?; end
-
-  private
-
-  def expected_arg_description; end
-  def negative_failure_reason; end
-  def positive_failure_reason; end
-end
-
-class RSpec::Matchers::BuiltIn::YieldWithArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def initialize(*args); end
-
-  def description; end
-  def does_not_match?(block); end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(block); end
-  def supports_block_expectations?; end
-  def supports_value_expectations?; end
-
-  private
-
-  def all_args_match?; end
-  def args_currently_match?; end
-  def expected_arg_description; end
-  def negative_failure_reason; end
-  def positive_failure_reason; end
-end
-
-class RSpec::Matchers::BuiltIn::YieldWithNoArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
-  def does_not_match?(block); end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(block); end
-  def supports_block_expectations?; end
-  def supports_value_expectations?; end
-
-  private
-
-  def negative_failure_reason; end
-  def positive_failure_reason; end
-end
-
-module RSpec::Matchers::Composable
-  def &(matcher); end
-  def ===(value); end
-  def and(matcher); end
-  def or(matcher); end
-  def |(matcher); end
-
-  private
-
-  def description_of(object); end
-  def should_enumerate?(item); end
-  def surface_descriptions_in(item); end
-  def unreadable_io?(object); end
-  def values_match?(expected, actual); end
-  def with_matchers_cloned(object); end
-
-  class << self
-    def should_enumerate?(item); end
-    def surface_descriptions_in(item); end
-    def unreadable_io?(object); end
-  end
-end
-
-class RSpec::Matchers::Composable::DescribableItem < ::Struct
-  def inspect; end
-  def item; end
-  def item=(_); end
-  def pretty_print(pp); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-module RSpec::Matchers::DSL
-  def alias_matcher(new_name, old_name, options = T.unsafe(nil), &description_override); end
-  def define(name, &declarations); end
-  def define_negated_matcher(negated_name, base_name, &description_override); end
-  def matcher(name, &declarations); end
-
-  private
-
-  def warn_about_block_args(name, declarations); end
-end
-
-module RSpec::Matchers::DSL::DefaultImplementations
-  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
-
-  def description; end
-  def diffable?; end
-  def expects_call_stack_jump?; end
-  def supports_block_expectations?; end
-  def supports_value_expectations?; end
-
-  private
-
-  def chained_method_clause_sentences; end
-end
-
-module RSpec::Matchers::DSL::Macros
-  def chain(method_name, *attr_names, &definition); end
-  def description(&definition); end
-  def diffable; end
-  def failure_message(&definition); end
-  def failure_message_when_negated(&definition); end
-  def match(options = T.unsafe(nil), &match_block); end
-  def match_unless_raises(expected_exception = T.unsafe(nil), &match_block); end
-  def match_when_negated(options = T.unsafe(nil), &match_block); end
-  def supports_block_expectations; end
-
-  private
-
-  def assign_attributes(attr_names); end
-  def define_user_override(method_name, user_def, &our_def); end
-end
-
-module RSpec::Matchers::DSL::Macros::Deprecated
-  def failure_message_for_should(&definition); end
-  def failure_message_for_should_not(&definition); end
-  def match_for_should(&definition); end
-  def match_for_should_not(&definition); end
-end
-
-RSpec::Matchers::DSL::Macros::RAISE_NOTIFIER = T.let(T.unsafe(nil), Proc)
-
-class RSpec::Matchers::DSL::Matcher
-  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
-  include ::RSpec::Matchers::DSL::DefaultImplementations
-  include ::RSpec::Matchers
-  include ::RSpec::Matchers::Composable
-  extend ::RSpec::Matchers::DSL::Macros
-  extend ::RSpec::Matchers::DSL::Macros::Deprecated
-
-  def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end
-
-  def actual; end
-  def block_arg; end
-  def expected; end
-  def expected_as_array; end
-  def inspect; end
-  def name; end
-  def rescued_exception; end
-
-  private
-
-  def actual_arg_for(block); end
-  def method_missing(method, *args, &block); end
-  def respond_to_missing?(method, include_private = T.unsafe(nil)); end
-end
-
-RSpec::Matchers::DYNAMIC_MATCHER_REGEX = T.let(T.unsafe(nil), Regexp)
-
-module RSpec::Matchers::EnglishPhrasing
-  class << self
-    def list(obj); end
-    def split_words(sym); end
-  end
-end
-
-class RSpec::Matchers::ExpectedsForMultipleDiffs
-  def initialize(expected_list); end
-
-  def message_with_diff(message, differ, actual); end
-
-  private
-
-  def diffs(differ, actual); end
-
-  class << self
-    def for_many_matchers(matchers); end
-    def from(expected); end
-
-    private
-
-    def diff_label_for(matcher); end
-    def truncated(description); end
-  end
-end
-
-RSpec::Matchers::ExpectedsForMultipleDiffs::DEFAULT_DIFF_LABEL = T.let(T.unsafe(nil), String)
-RSpec::Matchers::ExpectedsForMultipleDiffs::DESCRIPTION_MAX_LENGTH = T.let(T.unsafe(nil), Integer)
-RSpec::Matchers::HAS_REGEX = T.let(T.unsafe(nil), Regexp)
-
-class RSpec::Matchers::MatcherDelegator
-  include ::RSpec::Matchers::Composable
-
-  def initialize(base_matcher); end
-
-  def base_matcher; end
-  def method_missing(*args, &block); end
-
-  private
-
-  def initialize_copy(other); end
-  def respond_to_missing?(name, include_all = T.unsafe(nil)); end
-end
-
-RSpec::SharedContext = RSpec::Core::SharedContext
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.13.3.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.13.3.rbi
new file mode 100644
index 0000000000000..1dc0477091575
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.13.3.rbi
@@ -0,0 +1,8183 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rspec-expectations` gem.
+# Please instead update this file by running `bin/tapioca gem rspec-expectations`.
+
+
+# RSpec's top level namespace. All of rspec-expectations is contained
+# in the `RSpec::Expectations` and `RSpec::Matchers` namespaces.
+#
+# source://rspec-expectations//lib/rspec/matchers/english_phrasing.rb#1
+module RSpec
+  class << self
+    # source://rspec-core/3.13.1/lib/rspec/core.rb#70
+    def clear_examples; end
+
+    # source://rspec-core/3.13.1/lib/rspec/core.rb#85
+    def configuration; end
+
+    # source://rspec-core/3.13.1/lib/rspec/core.rb#49
+    def configuration=(_arg0); end
+
+    # source://rspec-core/3.13.1/lib/rspec/core.rb#97
+    def configure; end
+
+    # source://rspec-core/3.13.1/lib/rspec/core.rb#194
+    def const_missing(name); end
+
+    # source://rspec-core/3.13.1/lib/rspec/core/dsl.rb#42
+    def context(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.1/lib/rspec/core.rb#122
+    def current_example; end
+
+    # source://rspec-core/3.13.1/lib/rspec/core.rb#128
+    def current_example=(example); end
+
+    # source://rspec-core/3.13.1/lib/rspec/core.rb#154
+    def current_scope; end
+
+    # source://rspec-core/3.13.1/lib/rspec/core.rb#134
+    def current_scope=(scope); end
+
+    # source://rspec-core/3.13.1/lib/rspec/core/dsl.rb#42
+    def describe(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.1/lib/rspec/core/dsl.rb#42
+    def example_group(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.1/lib/rspec/core/dsl.rb#42
+    def fcontext(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.1/lib/rspec/core/dsl.rb#42
+    def fdescribe(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.1/lib/rspec/core.rb#58
+    def reset; end
+
+    # source://rspec-core/3.13.1/lib/rspec/core/shared_example_group.rb#110
+    def shared_context(name, *args, &block); end
+
+    # source://rspec-core/3.13.1/lib/rspec/core/shared_example_group.rb#110
+    def shared_examples(name, *args, &block); end
+
+    # source://rspec-core/3.13.1/lib/rspec/core/shared_example_group.rb#110
+    def shared_examples_for(name, *args, &block); end
+
+    # source://rspec-core/3.13.1/lib/rspec/core.rb#160
+    def world; end
+
+    # source://rspec-core/3.13.1/lib/rspec/core.rb#49
+    def world=(_arg0); end
+
+    # source://rspec-core/3.13.1/lib/rspec/core/dsl.rb#42
+    def xcontext(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.1/lib/rspec/core/dsl.rb#42
+    def xdescribe(*args, &example_group_block); end
+  end
+end
+
+# RSpec::Expectations provides a simple, readable API to express
+# the expected outcomes in a code example. To express an expected
+# outcome, wrap an object or block in `expect`, call `to` or `to_not`
+# (aliased as `not_to`) and pass it a matcher object:
+#
+#     expect(order.total).to eq(Money.new(5.55, :USD))
+#     expect(list).to include(user)
+#     expect(message).not_to match(/foo/)
+#     expect { do_something }.to raise_error
+#
+# The last form (the block form) is needed to match against ruby constructs
+# that are not objects, but can only be observed when executing a block
+# of code. This includes raising errors, throwing symbols, yielding,
+# and changing values.
+#
+# When `expect(...).to` is invoked with a matcher, it turns around
+# and calls `matcher.matches?(<object wrapped by expect>)`.  For example,
+# in the expression:
+#
+#     expect(order.total).to eq(Money.new(5.55, :USD))
+#
+# ...`eq(Money.new(5.55, :USD))` returns a matcher object, and it results
+# in the equivalent of `eq.matches?(order.total)`. If `matches?` returns
+# `true`, the expectation is met and execution continues. If `false`, then
+# the spec fails with the message returned by `eq.failure_message`.
+#
+# Given the expression:
+#
+#     expect(order.entries).not_to include(entry)
+#
+# ...the `not_to` method (also available as `to_not`) invokes the equivalent of
+# `include.matches?(order.entries)`, but it interprets `false` as success, and
+# `true` as a failure, using the message generated by
+# `include.failure_message_when_negated`.
+#
+# rspec-expectations ships with a standard set of useful matchers, and writing
+# your own matchers is quite simple.
+#
+# See [RSpec::Matchers](../RSpec/Matchers) for more information about the
+# built-in matchers that ship with rspec-expectations, and how to write your
+# own custom matchers.
+#
+# source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#2
+module RSpec::Expectations
+  class << self
+    # The configuration object.
+    #
+    # @return [RSpec::Expectations::Configuration] the configuration object
+    #
+    # source://rspec-expectations//lib/rspec/expectations/configuration.rb#228
+    def configuration; end
+
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/expectations/fail_with.rb#13
+    def differ; end
+
+    # Raises an RSpec::Expectations::ExpectationNotMetError with message.
+    # Adds a diff to the failure message when `expected` and `actual` are
+    # both present.
+    #
+    # @param message [String]
+    # @param expected [Object]
+    # @param actual [Object]
+    #
+    # source://rspec-expectations//lib/rspec/expectations/fail_with.rb#27
+    def fail_with(message, expected = T.unsafe(nil), actual = T.unsafe(nil)); end
+  end
+end
+
+# Validates the provided matcher to ensure it supports block
+# expectations, in order to avoid user confusion when they
+# use a block thinking the expectation will be on the return
+# value of the block rather than the block itself.
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#136
+class RSpec::Expectations::BlockExpectationTarget < ::RSpec::Expectations::ExpectationTarget
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#142
+  def not_to(matcher, message = T.unsafe(nil), &block); end
+
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#137
+  def to(matcher, message = T.unsafe(nil), &block); end
+
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#142
+  def to_not(matcher, message = T.unsafe(nil), &block); end
+
+  private
+
+  # @raise [ExpectationNotMetError]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#150
+  def enforce_block_expectation(matcher); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#158
+  def supports_block_expectations?(matcher); end
+end
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#4
+class RSpec::Expectations::BlockSnippetExtractor
+  # @return [BlockSnippetExtractor] a new instance of BlockSnippetExtractor
+  #
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#17
+  def initialize(proc, method_name); end
+
+  # Ideally we should properly handle indentations of multiline snippet,
+  # but it's not implemented yet since because we use result of this method only when it's a
+  # single line and implementing the logic introduces additional complexity.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#25
+  def body_content_lines; end
+
+  # rubocop should properly handle `Struct.new {}` as an inner class definition.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#7
+  def method_name; end
+
+  # rubocop should properly handle `Struct.new {}` as an inner class definition.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#7
+  def proc; end
+
+  private
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#62
+  def beginning_line_number; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#39
+  def block_token_extractor; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#58
+  def file_path; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#31
+  def raw_body_lines; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#35
+  def raw_body_snippet; end
+
+  # @raise [TargetNotFoundError]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#44
+  def source; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#66
+  def source_location; end
+
+  class << self
+    # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#9
+    def try_extracting_single_line_body_of(proc, method_name); end
+  end
+end
+
+# source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#72
+class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < ::RSpec::Expectations::BlockSnippetExtractor::Error; end
+
+# Locates target block with node information (semantics), which tokens don't have.
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#200
+class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < ::Struct
+  # Returns the value of attribute beginning_line_number
+  #
+  # @return [Object] the current value of beginning_line_number
+  def beginning_line_number; end
+
+  # Sets the attribute beginning_line_number
+  #
+  # @param value [Object] the value to set the attribute beginning_line_number to.
+  # @return [Object] the newly set value
+  def beginning_line_number=(_); end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#205
+  def body_content_locations; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#201
+  def method_call_location; end
+
+  # Returns the value of attribute method_name
+  #
+  # @return [Object] the current value of method_name
+  def method_name; end
+
+  # Sets the attribute method_name
+  #
+  # @param value [Object] the value to set the attribute method_name to.
+  # @return [Object] the newly set value
+  def method_name=(_); end
+
+  # Returns the value of attribute source
+  #
+  # @return [Object] the current value of source
+  def source; end
+
+  # Sets the attribute source
+  #
+  # @param value [Object] the value to set the attribute source to.
+  # @return [Object] the newly set value
+  def source=(_); end
+
+  private
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#218
+  def block_body_node; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#223
+  def block_wrapper_node; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#234
+  def candidate_block_wrapper_nodes; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#243
+  def candidate_method_ident_nodes; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#211
+  def method_ident_node; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#249
+  def method_ident_node?(node); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# Performs extraction of block body snippet using tokens,
+# which cannot be done with node information.
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#77
+class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < ::Struct
+  # @return [BlockTokenExtractor] a new instance of BlockTokenExtractor
+  #
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#80
+  def initialize(*_arg0); end
+
+  # Returns the value of attribute beginning_line_number
+  #
+  # @return [Object] the current value of beginning_line_number
+  def beginning_line_number; end
+
+  # Sets the attribute beginning_line_number
+  #
+  # @param value [Object] the value to set the attribute beginning_line_number to.
+  # @return [Object] the newly set value
+  def beginning_line_number=(_); end
+
+  # Returns the value of attribute body_tokens.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#78
+  def body_tokens; end
+
+  # Returns the value of attribute method_name
+  #
+  # @return [Object] the current value of method_name
+  def method_name; end
+
+  # Sets the attribute method_name
+  #
+  # @param value [Object] the value to set the attribute method_name to.
+  # @return [Object] the newly set value
+  def method_name=(_); end
+
+  # Returns the value of attribute source
+  #
+  # @return [Object] the current value of source
+  def source; end
+
+  # Sets the attribute source
+  #
+  # @param value [Object] the value to set the attribute source to.
+  # @return [Object] the newly set value
+  def source=(_); end
+
+  # Returns the value of attribute state.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#78
+  def state; end
+
+  private
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#126
+  def after_beginning_of_args_state(token); end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#130
+  def after_beginning_of_body_state(token); end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#109
+  def after_method_call_state(token); end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#113
+  def after_opener_state(token); end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#193
+  def block_locator; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#187
+  def correct_block?(body_tokens); end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#143
+  def finalize_pending_tokens!; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#97
+  def finish!; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#149
+  def finish_or_find_next_block_if_incorrect!; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#170
+  def handle_closer_token(token); end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#160
+  def handle_opener_token(token); end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#105
+  def initial_state(token); end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#101
+  def invoke_state_handler(token); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#166
+  def opener_token?(token); end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#179
+  def opener_token_stack; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#87
+  def parse!; end
+
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#139
+  def pending_tokens; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#183
+  def pipe_token?(token); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#70
+class RSpec::Expectations::BlockSnippetExtractor::Error < ::StandardError; end
+
+# source://rspec-expectations//lib/rspec/expectations/block_snippet_extractor.rb#71
+class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < ::RSpec::Expectations::BlockSnippetExtractor::Error; end
+
+# Provides configuration options for rspec-expectations.
+# If you are using rspec-core, you can access this via a
+# block passed to `RSpec::Core::Configuration#expect_with`.
+# Otherwise, you can access it via RSpec::Expectations.configuration.
+#
+# @example
+#   RSpec.configure do |rspec|
+#   rspec.expect_with :rspec do |c|
+#   # c is the config object
+#   end
+#   end
+#
+#   # or
+#
+#   RSpec::Expectations.configuration
+#
+# source://rspec-expectations//lib/rspec/expectations/configuration.rb#20
+class RSpec::Expectations::Configuration
+  # @return [Configuration] a new instance of Configuration
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#29
+  def initialize; end
+
+  # :nocov: Because this is only really _useful_ on 1.8, and hard to test elsewhere.
+  #
+  # Adds `should` and `should_not` to the given classes
+  # or modules. This can be used to ensure `should` works
+  # properly on things like proxy objects (particular
+  # `Delegator`-subclassed objects on 1.8).
+  #
+  # @param modules [Array<Module>] the list of classes or modules
+  #   to add `should` and `should_not` to.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#116
+  def add_should_and_should_not_to(*modules); end
+
+  # Sets or gets the backtrace formatter. The backtrace formatter should
+  # implement `#format_backtrace(Array<String>)`. This is used
+  # to format backtraces of errors handled by the `raise_error`
+  # matcher.
+  #
+  # If you are using rspec-core, rspec-core's backtrace formatting
+  # will be used (including respecting the presence or absence of
+  # the `--backtrace` option).
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#134
+  def backtrace_formatter; end
+
+  # Sets or gets the backtrace formatter. The backtrace formatter should
+  # implement `#format_backtrace(Array<String>)`. This is used
+  # to format backtraces of errors handled by the `raise_error`
+  # matcher.
+  #
+  # If you are using rspec-core, rspec-core's backtrace formatting
+  # will be used (including respecting the presence or absence of
+  # the `--backtrace` option).
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#133
+  def backtrace_formatter=(_arg0); end
+
+  # Indicates whether or not diffs should be colored.
+  # Delegates to rspec-core's color option if rspec-core
+  # is loaded; otherwise you can set it here.
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#88
+  def color?; end
+
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#221
+  def false_positives_handler; end
+
+  # Sets if custom matcher descriptions and failure messages
+  # should include clauses from methods defined using `chain`.
+  #
+  # @param value [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#145
+  def include_chain_clauses_in_custom_matcher_descriptions=(_arg0); end
+
+  # Indicates whether or not custom matcher descriptions and failure messages
+  # should include clauses from methods defined using `chain`. It is
+  # false by default for backwards compatibility.
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#150
+  def include_chain_clauses_in_custom_matcher_descriptions?; end
+
+  # Configures the maximum character length that RSpec will print while
+  # formatting an object. You can set length to nil to prevent RSpec from
+  # doing truncation.
+  #
+  # @example
+  #   RSpec.configure do |rspec|
+  #   rspec.expect_with :rspec do |c|
+  #   c.max_formatted_output_length = 200
+  #   end
+  #   end
+  # @param length [Fixnum] the number of characters to limit the formatted output to.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#70
+  def max_formatted_output_length=(length); end
+
+  # Indicates what RSpec will do about matcher use which will
+  # potentially cause false positives in tests, generally you want to
+  # avoid such scenarios so this defaults to `true`.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#211
+  def on_potential_false_positives; end
+
+  # Configures what RSpec will do about matcher use which will
+  # potentially cause false positives in tests.
+  #
+  # @param behavior [Symbol] can be set to :warn, :raise or :nothing
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#187
+  def on_potential_false_positives=(behavior); end
+
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#155
+  def reset_syntaxes_to_default; end
+
+  # Returns the value of attribute strict_predicate_matchers.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#202
+  def strict_predicate_matchers; end
+
+  # Configures RSpec to check predicate matchers to `be(true)` / `be(false)` (strict),
+  # or `be_truthy` / `be_falsey` (not strict).
+  # Historically, the default was `false`, but `true` is recommended.
+  #
+  # @raise [ArgumentError]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#197
+  def strict_predicate_matchers=(flag); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#204
+  def strict_predicate_matchers?; end
+
+  # The list of configured syntaxes.
+  #
+  # @example
+  #   unless RSpec::Matchers.configuration.syntax.include?(:expect)
+  #   raise "this RSpec extension gem requires the rspec-expectations `:expect` syntax"
+  #   end
+  # @return [Array<Symbol>] the list of configured syntaxes.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#80
+  def syntax; end
+
+  # Configures the supported syntax.
+  #
+  # @example
+  #   RSpec.configure do |rspec|
+  #   rspec.expect_with :rspec do |c|
+  #   c.syntax = :should
+  #   # or
+  #   c.syntax = :expect
+  #   # or
+  #   c.syntax = [:should, :expect]
+  #   end
+  #   end
+  # @param values [Array<Symbol>, Symbol] the syntaxes to enable
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#46
+  def syntax=(values); end
+
+  # Configures whether RSpec will warn about matcher use which will
+  # potentially cause false positives in tests.
+  #
+  # @param boolean [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#173
+  def warn_about_potential_false_positives=(boolean); end
+
+  # Indicates whether RSpec will warn about matcher use which will
+  # potentially cause false positives in tests, generally you want to
+  # avoid such scenarios so this defaults to `true`.
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/configuration.rb#216
+  def warn_about_potential_false_positives?; end
+end
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/configuration.rb#22
+RSpec::Expectations::Configuration::FALSE_POSITIVE_BEHAVIOURS = T.let(T.unsafe(nil), Hash)
+
+# Null implementation of a backtrace formatter used by default
+# when rspec-core is not loaded. Does no filtering.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/expectations/configuration.rb#163
+module RSpec::Expectations::Configuration::NullBacktraceFormatter
+  class << self
+    # source://rspec-expectations//lib/rspec/expectations/configuration.rb#164
+    def format_backtrace(backtrace); end
+  end
+end
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/handler.rb#4
+module RSpec::Expectations::ExpectationHelper
+  class << self
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#5
+    def check_message(msg); end
+
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#32
+    def handle_failure(matcher, message, failure_message_method); end
+
+    # Returns an RSpec-3+ compatible matcher, wrapping a legacy one
+    # in an adapter if necessary.
+    #
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#18
+    def modern_matcher_from(matcher); end
+
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#23
+    def with_matcher(handler, matcher, message); end
+  end
+end
+
+# Exception raised when an expectation fails.
+#
+# the user sets an expectation, it can't be caught in their
+# code by a bare `rescue`.
+#
+# @api public
+# @note We subclass Exception so that in a stub implementation if
+#
+# source://rspec-expectations//lib/rspec/expectations.rb#67
+class RSpec::Expectations::ExpectationNotMetError < ::Exception; end
+
+# Wraps the target of an expectation.
+#
+# @example
+#   expect(something)       # => ExpectationTarget wrapping something
+#   expect { do_something } # => ExpectationTarget wrapping the block
+#
+#   # used with `to`
+#   expect(actual).to eq(3)
+#
+#   # with `not_to`
+#   expect(actual).not_to eq(3)
+# @note `ExpectationTarget` is not intended to be instantiated
+#   directly by users. Use `expect` instead.
+#
+# source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#17
+class RSpec::Expectations::ExpectationTarget
+  include ::RSpec::Expectations::ExpectationTarget::InstanceMethods
+
+  # @api private
+  # @return [ExpectationTarget] a new instance of ExpectationTarget
+  #
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#31
+  def initialize(value); end
+
+  # @note this name aligns with `Minitest::Expectation` so that our
+  #   {InstanceMethods} module can be included in that class when
+  #   used in a Minitest context.
+  # @return [Object] the target of the expectation
+  #
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#28
+  def target; end
+
+  class << self
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#36
+    def for(value, block); end
+  end
+end
+
+# Defines instance {ExpectationTarget} instance methods. These are defined
+# in a module so we can include it in `Minitest::Expectation` when
+# `rspec/expectations/minitest_integration` is loaded in order to
+# support usage with Minitest.
+#
+# source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#53
+module RSpec::Expectations::ExpectationTarget::InstanceMethods
+  # Runs the given expectation, passing if `matcher` returns false.
+  #
+  # @example
+  #   expect(value).not_to eq(5)
+  # @param matcher [Matcher]
+  # @param message [String, Proc] optional message to display when the expectation fails
+  # @return [Boolean] false if the negative expectation succeeds (else raises)
+  # @see RSpec::Matchers
+  #
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#76
+  def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  # Runs the given expectation, passing if `matcher` returns true.
+  #
+  # @example
+  #   expect(value).to eq(5)
+  #   expect { perform }.to raise_error
+  # @param matcher [Matcher]
+  # @param message [String, Proc] optional message to display when the expectation fails
+  # @return [Boolean] true if the expectation succeeds (else raises)
+  # @see RSpec::Matchers
+  #
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#63
+  def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  # Runs the given expectation, passing if `matcher` returns false.
+  #
+  # @example
+  #   expect(value).not_to eq(5)
+  # @param matcher [Matcher]
+  # @param message [String, Proc] optional message to display when the expectation fails
+  # @return [Boolean] false if the negative expectation succeeds (else raises)
+  # @see RSpec::Matchers
+  #
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#76
+  def to_not(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  private
+
+  # @raise [ArgumentError]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#84
+  def prevent_operator_matchers(verb); end
+end
+
+# Used as a sentinel value to be able to tell when the user
+# did not pass an argument. We can't use `nil` for that because
+# `nil` is a valid value to pass.
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#22
+module RSpec::Expectations::ExpectationTarget::UndefinedValue; end
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#4
+class RSpec::Expectations::FailureAggregator
+  # @return [FailureAggregator] a new instance of FailureAggregator
+  #
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#97
+  def initialize(block_label, metadata); end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#27
+  def aggregate; end
+
+  # Returns the value of attribute block_label.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#5
+  def block_label; end
+
+  # This method is defined to satisfy the callable interface
+  # expected by `RSpec::Support.with_failure_notifier`.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#64
+  def call(failure, options); end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#54
+  def failures; end
+
+  # Returns the value of attribute metadata.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#5
+  def metadata; end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#58
+  def other_errors; end
+
+  private
+
+  # Using `caller` performs better (and is simpler) than `raise` on most Rubies.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#92
+  def assign_backtrace(failure); end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#103
+  def notify_aggregated_failures; end
+end
+
+# source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#25
+RSpec::Expectations::FailureAggregator::AGGREGATED_FAILURE = T.let(T.unsafe(nil), RSpec::Expectations::FailureAggregator::AggregatedFailure)
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#8
+class RSpec::Expectations::FailureAggregator::AggregatedFailure
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#19
+  def inspect; end
+end
+
+# :nocov:
+# `inspect` was apparently used by some versions early in ruby 3 while constructing
+# NoMethodError, but seems to be no longer.
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#14
+RSpec::Expectations::FailureAggregator::AggregatedFailure::MESSAGE = T.let(T.unsafe(nil), String)
+
+# RSpec 3.0 was released with the class name misspelled. For SemVer compatibility,
+# we will provide this misspelled alias until 4.0.
+#
+# @deprecated Use LegacyMatcherAdapter instead.
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/handler.rb#179
+RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter
+
+# Wraps a matcher written against one of the legacy protocols in
+# order to present the current protocol.
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/handler.rb#112
+class RSpec::Expectations::LegacyMatcherAdapter < ::RSpec::Matchers::MatcherDelegator
+  # @return [LegacyMatcherAdapter] a new instance of LegacyMatcherAdapter
+  #
+  # source://rspec-expectations//lib/rspec/expectations/handler.rb#113
+  def initialize(matcher); end
+
+  class << self
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#123
+    def wrap(matcher); end
+  end
+end
+
+# Before RSpec 1.2, the failure message protocol was:
+#   * `failure_message`
+#   * `negative_failure_message`
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/handler.rb#156
+class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < ::RSpec::Expectations::LegacyMatcherAdapter
+  # source://rspec-expectations//lib/rspec/expectations/handler.rb#157
+  def failure_message; end
+
+  # source://rspec-expectations//lib/rspec/expectations/handler.rb#161
+  def failure_message_when_negated; end
+
+  class << self
+    # Note: `failure_message` is part of the RSpec 3 protocol
+    # (paired with `failure_message_when_negated`), so we don't check
+    # for `failure_message` here.
+    #
+    # @return [Boolean]
+    #
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#168
+    def interface_matches?(matcher); end
+  end
+end
+
+# Starting in RSpec 1.2 (and continuing through all 2.x releases),
+# the failure message protocol was:
+#   * `failure_message_for_should`
+#   * `failure_message_for_should_not`
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/handler.rb#132
+class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < ::RSpec::Expectations::LegacyMatcherAdapter
+  # source://rspec-expectations//lib/rspec/expectations/handler.rb#133
+  def failure_message; end
+
+  # source://rspec-expectations//lib/rspec/expectations/handler.rb#137
+  def failure_message_when_negated; end
+
+  class << self
+    # @return [Boolean]
+    #
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#141
+    def interface_matches?(matcher); end
+  end
+end
+
+# Exception raised from `aggregate_failures` when multiple expectations fail.
+#
+# @note The constant is defined here but the extensive logic of this class
+#   is lazily defined when `FailureAggregator` is autoloaded, since we do
+#   not need to waste time defining that functionality unless
+#   `aggregate_failures` is used.
+#
+# source://rspec-expectations//lib/rspec/expectations.rb#76
+class RSpec::Expectations::MultipleExpectationsNotMetError < ::RSpec::Expectations::ExpectationNotMetError
+  # @return [MultipleExpectationsNotMetError] a new instance of MultipleExpectationsNotMetError
+  #
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#160
+  def initialize(failure_aggregator); end
+
+  # @return [String] The user-assigned label for the aggregation block.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#135
+  def aggregation_block_label; end
+
+  # @return [Hash] The metadata hash passed to `aggregate_failures`.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#140
+  def aggregation_metadata; end
+
+  # @return [Array<Exception>] The list of expectation failures and other exceptions, combined.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#132
+  def all_exceptions; end
+
+  # return [String] A description of the failure/error counts.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#151
+  def exception_count_description; end
+
+  # @return [Array<RSpec::Expectations::ExpectationNotMetError>] The list of expectation failures.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#122
+  def failures; end
+
+  # @return [String] The fully formatted exception message.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#117
+  def message; end
+
+  # @return [Array<Exception>] The list of other exceptions.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#127
+  def other_errors; end
+
+  # @return [String] A summary of the failure, including the block label and a count of failures.
+  #
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#145
+  def summary; end
+
+  private
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#192
+  def backtrace_line(line); end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#165
+  def block_description; end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#174
+  def enumerated(exceptions, index_offset); end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#204
+  def enumerated_errors; end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#200
+  def enumerated_failures; end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#182
+  def exclusion_patterns; end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#188
+  def format_backtrace(backtrace); end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#219
+  def indentation; end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#210
+  def indented(failure_message, index); end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#231
+  def index_label(index); end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#223
+  def longest_index_label_width; end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#170
+  def pluralize(noun, count); end
+
+  # source://rspec-expectations//lib/rspec/expectations/failure_aggregator.rb#227
+  def width_of_label(index); end
+end
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/handler.rb#73
+class RSpec::Expectations::NegativeExpectationHandler
+  class << self
+    # @return [Boolean]
+    #
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#87
+    def does_not_match?(matcher, actual, &block); end
+
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#74
+    def handle_matcher(actual, initial_matcher, custom_message = T.unsafe(nil), &block); end
+
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#103
+    def opposite_should_method; end
+
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#99
+    def should_method; end
+
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#95
+    def verb; end
+  end
+end
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/handler.rb#45
+class RSpec::Expectations::PositiveExpectationHandler
+  class << self
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#46
+    def handle_matcher(actual, initial_matcher, custom_message = T.unsafe(nil), &block); end
+
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#67
+    def opposite_should_method; end
+
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#63
+    def should_method; end
+
+    # source://rspec-expectations//lib/rspec/expectations/handler.rb#59
+    def verb; end
+  end
+end
+
+# Provides methods for enabling and disabling the available
+# syntaxes provided by rspec-expectations.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/expectations/syntax.rb#6
+module RSpec::Expectations::Syntax
+  private
+
+  # Determines where we add `should` and `should_not`.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/expectations/syntax.rb#11
+  def default_should_host; end
+
+  # Disables the `expect` syntax.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/expectations/syntax.rb#80
+  def disable_expect(syntax_host = T.unsafe(nil)); end
+
+  # Disables the `should` syntax.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/expectations/syntax.rb#57
+  def disable_should(syntax_host = T.unsafe(nil)); end
+
+  # Enables the `expect` syntax.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/expectations/syntax.rb#68
+  def enable_expect(syntax_host = T.unsafe(nil)); end
+
+  # Enables the `should` syntax.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/expectations/syntax.rb#38
+  def enable_should(syntax_host = T.unsafe(nil)); end
+
+  # Indicates whether or not the `expect` syntax is enabled.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/expectations/syntax.rb#96
+  def expect_enabled?(syntax_host = T.unsafe(nil)); end
+
+  # Indicates whether or not the `should` syntax is enabled.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/expectations/syntax.rb#90
+  def should_enabled?(syntax_host = T.unsafe(nil)); end
+
+  # Instructs rspec-expectations to warn on first usage of `should` or `should_not`.
+  # Enabled by default. This is largely here to facilitate testing.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/expectations/syntax.rb#18
+  def warn_about_should!; end
+
+  # Generates a deprecation warning for the given method if no warning
+  # has already been issued.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/expectations/syntax.rb#25
+  def warn_about_should_unless_configured(method_name); end
+
+  class << self
+    # Determines where we add `should` and `should_not`.
+    #
+    # @api private
+    #
+    # source://rspec-expectations//lib/rspec/expectations/syntax.rb#11
+    def default_should_host; end
+
+    # Disables the `expect` syntax.
+    #
+    # @api private
+    #
+    # source://rspec-expectations//lib/rspec/expectations/syntax.rb#80
+    def disable_expect(syntax_host = T.unsafe(nil)); end
+
+    # Disables the `should` syntax.
+    #
+    # @api private
+    #
+    # source://rspec-expectations//lib/rspec/expectations/syntax.rb#57
+    def disable_should(syntax_host = T.unsafe(nil)); end
+
+    # Enables the `expect` syntax.
+    #
+    # @api private
+    #
+    # source://rspec-expectations//lib/rspec/expectations/syntax.rb#68
+    def enable_expect(syntax_host = T.unsafe(nil)); end
+
+    # Enables the `should` syntax.
+    #
+    # @api private
+    #
+    # source://rspec-expectations//lib/rspec/expectations/syntax.rb#38
+    def enable_should(syntax_host = T.unsafe(nil)); end
+
+    # Indicates whether or not the `expect` syntax is enabled.
+    #
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-expectations//lib/rspec/expectations/syntax.rb#96
+    def expect_enabled?(syntax_host = T.unsafe(nil)); end
+
+    # Indicates whether or not the `should` syntax is enabled.
+    #
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-expectations//lib/rspec/expectations/syntax.rb#90
+    def should_enabled?(syntax_host = T.unsafe(nil)); end
+
+    # Instructs rspec-expectations to warn on first usage of `should` or `should_not`.
+    # Enabled by default. This is largely here to facilitate testing.
+    #
+    # @api private
+    #
+    # source://rspec-expectations//lib/rspec/expectations/syntax.rb#18
+    def warn_about_should!; end
+
+    # Generates a deprecation warning for the given method if no warning
+    # has already been issued.
+    #
+    # @api private
+    #
+    # source://rspec-expectations//lib/rspec/expectations/syntax.rb#25
+    def warn_about_should_unless_configured(method_name); end
+  end
+end
+
+# Validates the provided matcher to ensure it supports block
+# expectations, in order to avoid user confusion when they
+# use a block thinking the expectation will be on the return
+# value of the block rather than the block itself.
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#98
+class RSpec::Expectations::ValueExpectationTarget < ::RSpec::Expectations::ExpectationTarget
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#104
+  def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#99
+  def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  private
+
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#111
+  def enforce_value_expectation(matcher); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/expectations/expectation_target.rb#126
+  def supports_value_expectations?(matcher); end
+end
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/expectations/version.rb#4
+module RSpec::Expectations::Version; end
+
+# source://rspec-expectations//lib/rspec/expectations/version.rb#5
+RSpec::Expectations::Version::STRING = T.let(T.unsafe(nil), String)
+
+# RSpec::Matchers provides a number of useful matchers we use to define
+# expectations. Any object that implements the [matcher protocol](Matchers/MatcherProtocol)
+# can be used as a matcher.
+#
+# ## Predicates
+#
+# In addition to matchers that are defined explicitly, RSpec will create
+# custom matchers on the fly for any arbitrary predicate, giving your specs a
+# much more natural language feel.
+#
+# A Ruby predicate is a method that ends with a "?" and returns true or false.
+# Common examples are `empty?`, `nil?`, and `instance_of?`.
+#
+# All you need to do is write `expect(..).to be_` followed by the predicate
+# without the question mark, and RSpec will figure it out from there.
+# For example:
+#
+#     expect([]).to be_empty     # => [].empty?() | passes
+#     expect([]).not_to be_empty # => [].empty?() | fails
+#
+# In addition to prefixing the predicate matchers with "be_", you can also use "be_a_"
+# and "be_an_", making your specs read much more naturally:
+#
+#     expect("a string").to be_an_instance_of(String) # =>"a string".instance_of?(String) # passes
+#
+#     expect(3).to be_a_kind_of(Integer)          # => 3.kind_of?(Numeric)     | passes
+#     expect(3).to be_a_kind_of(Numeric)          # => 3.kind_of?(Numeric)     | passes
+#     expect(3).to be_an_instance_of(Integer)     # => 3.instance_of?(Integer) | passes
+#     expect(3).not_to be_an_instance_of(Numeric) # => 3.instance_of?(Numeric) | fails
+#
+# RSpec will also create custom matchers for predicates like `has_key?`. To
+# use this feature, just state that the object should have_key(:key) and RSpec will
+# call has_key?(:key) on the target. For example:
+#
+#     expect(:a => "A").to have_key(:a)
+#     expect(:a => "A").to have_key(:b) # fails
+#
+# You can use this feature to invoke any predicate that begins with "has_", whether it is
+# part of the Ruby libraries (like `Hash#has_key?`) or a method you wrote on your own class.
+#
+# Note that RSpec does not provide composable aliases for these dynamic predicate
+# matchers. You can easily define your own aliases, though:
+#
+#     RSpec::Matchers.alias_matcher :a_user_who_is_an_admin, :be_an_admin
+#     expect(user_list).to include(a_user_who_is_an_admin)
+#
+# ## Alias Matchers
+#
+# With {RSpec::Matchers.alias_matcher}, you can easily create an
+# alternate name for a given matcher.
+#
+# The description will also change according to the new name:
+#
+#     RSpec::Matchers.alias_matcher :a_list_that_sums_to, :sum_to
+#     sum_to(3).description # => "sum to 3"
+#     a_list_that_sums_to(3).description # => "a list that sums to 3"
+#
+# or you can specify a custom description like this:
+#
+#     RSpec::Matchers.alias_matcher :a_list_sorted_by, :be_sorted_by do |description|
+#       description.sub("be sorted by", "a list sorted by")
+#     end
+#
+#     be_sorted_by(:age).description # => "be sorted by age"
+#     a_list_sorted_by(:age).description # => "a list sorted by age"
+#
+# ## Custom Matchers
+#
+# When you find that none of the stock matchers provide a natural feeling
+# expectation, you can very easily write your own using RSpec's matcher DSL
+# or writing one from scratch.
+#
+# ### Matcher DSL
+#
+# Imagine that you are writing a game in which players can be in various
+# zones on a virtual board. To specify that bob should be in zone 4, you
+# could say:
+#
+#     expect(bob.current_zone).to eql(Zone.new("4"))
+#
+# But you might find it more expressive to say:
+#
+#     expect(bob).to be_in_zone("4")
+#
+# and/or
+#
+#     expect(bob).not_to be_in_zone("3")
+#
+# You can create such a matcher like so:
+#
+#     RSpec::Matchers.define :be_in_zone do |zone|
+#       match do |player|
+#         player.in_zone?(zone)
+#       end
+#     end
+#
+# This will generate a <tt>be_in_zone</tt> method that returns a matcher
+# with logical default messages for failures. You can override the failure
+# messages and the generated description as follows:
+#
+#     RSpec::Matchers.define :be_in_zone do |zone|
+#       match do |player|
+#         player.in_zone?(zone)
+#       end
+#
+#       failure_message do |player|
+#         # generate and return the appropriate string.
+#       end
+#
+#       failure_message_when_negated do |player|
+#         # generate and return the appropriate string.
+#       end
+#
+#       description do
+#         # generate and return the appropriate string.
+#       end
+#     end
+#
+# Each of the message-generation methods has access to the block arguments
+# passed to the <tt>create</tt> method (in this case, <tt>zone</tt>). The
+# failure message methods (<tt>failure_message</tt> and
+# <tt>failure_message_when_negated</tt>) are passed the actual value (the
+# receiver of <tt>expect(..)</tt> or <tt>expect(..).not_to</tt>).
+#
+# ### Custom Matcher from scratch
+#
+# You could also write a custom matcher from scratch, as follows:
+#
+#     class BeInZone
+#       def initialize(expected)
+#         @expected = expected
+#       end
+#
+#       def matches?(target)
+#         @target = target
+#         @target.current_zone.eql?(Zone.new(@expected))
+#       end
+#
+#       def failure_message
+#         "expected #{@target.inspect} to be in Zone #{@expected}"
+#       end
+#
+#       def failure_message_when_negated
+#         "expected #{@target.inspect} not to be in Zone #{@expected}"
+#       end
+#     end
+#
+# ... and a method like this:
+#
+#     def be_in_zone(expected)
+#       BeInZone.new(expected)
+#     end
+#
+# And then expose the method to your specs. This is normally done
+# by including the method and the class in a module, which is then
+# included in your spec:
+#
+#     module CustomGameMatchers
+#       class BeInZone
+#         # ...
+#       end
+#
+#       def be_in_zone(expected)
+#         # ...
+#       end
+#     end
+#
+#     describe "Player behaviour" do
+#       include CustomGameMatchers
+#       # ...
+#     end
+#
+# or you can include in globally in a spec_helper.rb file <tt>require</tt>d
+# from your spec file(s):
+#
+#     RSpec::configure do |config|
+#       config.include(CustomGameMatchers)
+#     end
+#
+# ### Making custom matchers composable
+#
+# RSpec's built-in matchers are designed to be composed, in expressions like:
+#
+#     expect(["barn", 2.45]).to contain_exactly(
+#       a_value_within(0.1).of(2.5),
+#       a_string_starting_with("bar")
+#     )
+#
+# Custom matchers can easily participate in composed matcher expressions like these.
+# Include {RSpec::Matchers::Composable} in your custom matcher to make it support
+# being composed (matchers defined using the DSL have this included automatically).
+# Within your matcher's `matches?` method (or the `match` block, if using the DSL),
+# use `values_match?(expected, actual)` rather than `expected == actual`.
+# Under the covers, `values_match?` is able to match arbitrary
+# nested data structures containing a mix of both matchers and non-matcher objects.
+# It uses `===` and `==` to perform the matching, considering the values to
+# match if either returns `true`. The `Composable` mixin also provides some helper
+# methods for surfacing the matcher descriptions within your matcher's description
+# or failure messages.
+#
+# RSpec's built-in matchers each have a number of aliases that rephrase the matcher
+# from a verb phrase (such as `be_within`) to a noun phrase (such as `a_value_within`),
+# which reads better when the matcher is passed as an argument in a composed matcher
+# expressions, and also uses the noun-phrase wording in the matcher's `description`,
+# for readable failure messages. You can alias your custom matchers in similar fashion
+# using {RSpec::Matchers.alias_matcher}.
+#
+# ## Negated Matchers
+#
+# Sometimes if you want to test for the opposite using a more descriptive name
+# instead of using `not_to`, you can use {RSpec::Matchers.define_negated_matcher}:
+#
+#     RSpec::Matchers.define_negated_matcher :exclude, :include
+#     include(1, 2).description # => "include 1 and 2"
+#     exclude(1, 2).description # => "exclude 1 and 2"
+#
+# While the most obvious negated form may be to add a `not_` prefix,
+# the failure messages you get with that form can be confusing (e.g.
+# "expected [actual] to not [verb], but did not"). We've found it works
+# best to find a more positive name for the negated form, such as
+# `avoid_changing` rather than `not_change`.
+#
+# source://rspec-expectations//lib/rspec/matchers/english_phrasing.rb#2
+module RSpec::Matchers
+  extend ::RSpec::Matchers::DSL
+
+  # Applied to a proc, specifies that its execution will cause some value to
+  # change.
+  #
+  # You can either pass <tt>receiver</tt> and <tt>message</tt>, or a block,
+  # but not both.
+  #
+  # When passing a block, it must use the `{ ... }` format, not
+  # do/end, as `{ ... }` binds to the `change` method, whereas do/end
+  # would errantly bind to the `expect(..).to` or `expect(...).not_to` method.
+  #
+  # You can chain any of the following off of the end to specify details
+  # about the change:
+  #
+  # * `from`
+  # * `to`
+  #
+  # or any one of:
+  #
+  # * `by`
+  # * `by_at_least`
+  # * `by_at_most`
+  #
+  # == Notes
+  #
+  # Evaluates `receiver.message` or `block` before and after it
+  # evaluates the block passed to `expect`. If the value is the same
+  # object, its before/after `hash` value is used to see if it has changed.
+  # Therefore, your object needs to properly implement `hash` to work correctly
+  # with this matcher.
+  #
+  # `expect( ... ).not_to change` supports the form that specifies `from`
+  # (which specifies what you expect the starting, unchanged value to be)
+  # but does not support forms with subsequent calls to `by`, `by_at_least`,
+  # `by_at_most` or `to`.
+  #
+  # @example
+  #   expect {
+  #   team.add_player(player)
+  #   }.to change(roster, :count)
+  #
+  #   expect {
+  #   team.add_player(player)
+  #   }.to change(roster, :count).by(1)
+  #
+  #   expect {
+  #   team.add_player(player)
+  #   }.to change(roster, :count).by_at_least(1)
+  #
+  #   expect {
+  #   team.add_player(player)
+  #   }.to change(roster, :count).by_at_most(1)
+  #
+  #   string = "string"
+  #   expect {
+  #   string.reverse!
+  #   }.to change { string }.from("string").to("gnirts")
+  #
+  #   string = "string"
+  #   expect {
+  #   string
+  #   }.not_to change { string }.from("string")
+  #
+  #   expect {
+  #   person.happy_birthday
+  #   }.to change(person, :birthday).from(32).to(33)
+  #
+  #   expect {
+  #   employee.develop_great_new_social_networking_app
+  #   }.to change(employee, :title).from("Mail Clerk").to("CEO")
+  #
+  #   expect {
+  #   doctor.leave_office
+  #   }.to change(doctor, :sign).from(/is in/).to(/is out/)
+  #
+  #   user = User.new(:type => "admin")
+  #   expect {
+  #   user.symbolize_type
+  #   }.to change(user, :type).from(String).to(Symbol)
+  # @param receiver [Object]
+  # @param message [Symbol] the message to send the receiver
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_block_changing(*args, **_arg1, &block); end
+
+  # With no arg, passes if the block outputs `to_stdout` or `to_stderr`.
+  # With a string, passes if the block outputs that specific string `to_stdout` or `to_stderr`.
+  # With a regexp or matcher, passes if the block outputs a string `to_stdout` or `to_stderr` that matches.
+  #
+  # To capture output from any spawned subprocess as well, use `to_stdout_from_any_process` or
+  # `to_stderr_from_any_process`. Output from any process that inherits the main process's corresponding
+  # standard stream will be captured.
+  #
+  # @example
+  #   expect { print 'foo' }.to output.to_stdout
+  #   expect { print 'foo' }.to output('foo').to_stdout
+  #   expect { print 'foo' }.to output(/foo/).to_stdout
+  #
+  #   expect { do_something }.to_not output.to_stdout
+  #
+  #   expect { warn('foo') }.to output.to_stderr
+  #   expect { warn('foo') }.to output('foo').to_stderr
+  #   expect { warn('foo') }.to output(/foo/).to_stderr
+  #
+  #   expect { do_something }.to_not output.to_stderr
+  #
+  #   expect { system('echo foo') }.to output("foo\n").to_stdout_from_any_process
+  #   expect { system('echo foo', out: :err) }.to output("foo\n").to_stderr_from_any_process
+  # @note `to_stdout` and `to_stderr` work by temporarily replacing `$stdout` or `$stderr`,
+  #   so they're not able to intercept stream output that explicitly uses `STDOUT`/`STDERR`
+  #   or that uses a reference to `$stdout`/`$stderr` that was stored before the
+  #   matcher was used.
+  # @note `to_stdout_from_any_process` and `to_stderr_from_any_process` use Tempfiles, and
+  #   are thus significantly (~30x) slower than `to_stdout` and `to_stderr`.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_block_outputting(*args, **_arg1, &block); end
+
+  # With no args, matches if any error is raised.
+  # With a named error, matches only if that specific error is raised.
+  # With a named error and message specified as a String, matches only if both match.
+  # With a named error and message specified as a Regexp, matches only if both match.
+  # Pass an optional block to perform extra verifications on the exception matched
+  #
+  # @example
+  #   expect { do_something_risky }.to raise_error
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError)
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError) { |error| expect(error.data).to eq 42 }
+  #   expect { do_something_risky }.to raise_error { |error| expect(error.data).to eq 42 }
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError, "that was too risky")
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError, /oo ri/)
+  #   expect { do_something_risky }.to raise_error("that was too risky")
+  #
+  #   expect { do_something_risky }.not_to raise_error
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_block_raising(*args, **_arg1, &block); end
+
+  # Given no argument, matches if a proc throws any Symbol.
+  #
+  # Given a Symbol, matches if the given proc throws the specified Symbol.
+  #
+  # Given a Symbol and an arg, matches if the given proc throws the
+  # specified Symbol with the specified arg.
+  #
+  # @example
+  #   expect { do_something_risky }.to throw_symbol
+  #   expect { do_something_risky }.to throw_symbol(:that_was_risky)
+  #   expect { do_something_risky }.to throw_symbol(:that_was_risky, 'culprit')
+  #
+  #   expect { do_something_risky }.not_to throw_symbol
+  #   expect { do_something_risky }.not_to throw_symbol(:that_was_risky)
+  #   expect { do_something_risky }.not_to throw_symbol(:that_was_risky, 'culprit')
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_block_throwing(*args, **_arg1, &block); end
+
+  # Passes if the method called in the expect block yields, regardless
+  # of whether or not arguments are yielded.
+  #
+  # @example
+  #   expect { |b| 5.tap(&b) }.to yield_control
+  #   expect { |b| "a".to_sym(&b) }.not_to yield_control
+  # @note Your expect block must accept a parameter and pass it on to
+  #   the method-under-test as a block.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_block_yielding_control(*args, **_arg1, &block); end
+
+  # Designed for use with methods that repeatedly yield (such as
+  # iterators). Passes if the method called in the expect block yields
+  # multiple times with arguments matching those given.
+  #
+  # Argument matching is done using `===` (the case match operator)
+  # and `==`. If the expected and actual arguments match with either
+  # operator, the matcher will pass.
+  #
+  # @example
+  #   expect { |b| [1, 2, 3].each(&b) }.to yield_successive_args(1, 2, 3)
+  #   expect { |b| { :a => 1, :b => 2 }.each(&b) }.to yield_successive_args([:a, 1], [:b, 2])
+  #   expect { |b| [1, 2, 3].each(&b) }.not_to yield_successive_args(1, 2)
+  # @note Your expect block must accept a parameter and pass it on to
+  #   the method-under-test as a block.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_block_yielding_successive_args(*args, **_arg1, &block); end
+
+  # Given no arguments, matches if the method called in the expect
+  # block yields with arguments (regardless of what they are or how
+  # many there are).
+  #
+  # Given arguments, matches if the method called in the expect block
+  # yields with arguments that match the given arguments.
+  #
+  # Argument matching is done using `===` (the case match operator)
+  # and `==`. If the expected and actual arguments match with either
+  # operator, the matcher will pass.
+  #
+  # @example
+  #   expect { |b| 5.tap(&b) }.to yield_with_args # because #tap yields an arg
+  #   expect { |b| 5.tap(&b) }.to yield_with_args(5) # because 5 == 5
+  #   expect { |b| 5.tap(&b) }.to yield_with_args(Integer) # because Integer === 5
+  #   expect { |b| File.open("f.txt", &b) }.to yield_with_args(/txt/) # because /txt/ === "f.txt"
+  #
+  #   expect { |b| User.transaction(&b) }.not_to yield_with_args # because it yields no args
+  #   expect { |b| 5.tap(&b) }.not_to yield_with_args(1, 2, 3)
+  # @note Your expect block must accept a parameter and pass it on to
+  #   the method-under-test as a block.
+  # @note This matcher is not designed for use with methods that yield
+  #   multiple times.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_block_yielding_with_args(*args, **_arg1, &block); end
+
+  # Passes if the method called in the expect block yields with
+  # no arguments. Fails if it does not yield, or yields with arguments.
+  #
+  # @example
+  #   expect { |b| User.transaction(&b) }.to yield_with_no_args
+  #   expect { |b| 5.tap(&b) }.not_to yield_with_no_args # because it yields with `5`
+  #   expect { |b| "a".to_sym(&b) }.not_to yield_with_no_args # because it does not yield
+  # @note Your expect block must accept a parameter and pass it on to
+  #   the method-under-test as a block.
+  # @note This matcher is not designed for use with methods that yield
+  #   multiple times.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_block_yielding_with_no_args(*args, **_arg1, &block); end
+
+  # Passes if actual contains all of the expected regardless of order.
+  # This works for collections. Pass in multiple args and it will only
+  # pass if all args are found in collection.
+  #
+  # @example
+  #   expect([1, 2, 3]).to contain_exactly(1, 2, 3)
+  #   expect([1, 2, 3]).to contain_exactly(1, 3, 2)
+  # @note This is also available using the `=~` operator with `should`,
+  #   but `=~` is not supported with `expect`.
+  # @see #match_array
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_collection_containing_exactly(*args, **_arg1, &block); end
+
+  # Matches if the actual value ends with the expected value(s). In the case
+  # of a string, matches against the last `expected.length` characters of the
+  # actual string. In the case of an array, matches against the last
+  # `expected.length` elements of the actual array.
+  #
+  # @example
+  #   expect("this string").to   end_with "string"
+  #   expect([0, 1, 2, 3, 4]).to end_with 4
+  #   expect([0, 2, 3, 4, 4]).to end_with 3, 4
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_collection_ending_with(*args, **_arg1, &block); end
+
+  # Passes if actual includes expected. This works for
+  # collections and Strings. You can also pass in multiple args
+  # and it will only pass if all args are found in collection.
+  #
+  # @example
+  #   expect([1,2,3]).to      include(3)
+  #   expect([1,2,3]).to      include(2,3)
+  #   expect([1,2,3]).to      include(2,3,4) # fails
+  #   expect([1,2,3]).not_to  include(4)
+  #   expect("spread").to     include("read")
+  #   expect("spread").not_to include("red")
+  #   expect(:a => 1, :b => 2).to include(:a)
+  #   expect(:a => 1, :b => 2).to include(:a, :b)
+  #   expect(:a => 1, :b => 2).to include(:a => 1)
+  #   expect(:a => 1, :b => 2).to include(:b => 2, :a => 1)
+  #   expect(:a => 1, :b => 2).to include(:c) # fails
+  #   expect(:a => 1, :b => 2).not_to include(:a => 2)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_collection_including(*args, **_arg1, &block); end
+
+  # Matches if the actual value starts with the expected value(s). In the
+  # case of a string, matches against the first `expected.length` characters
+  # of the actual string. In the case of an array, matches against the first
+  # `expected.length` elements of the actual array.
+  #
+  # @example
+  #   expect("this string").to   start_with "this s"
+  #   expect([0, 1, 2, 3, 4]).to start_with 0
+  #   expect([0, 2, 3, 4, 4]).to start_with 0, 1
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_collection_starting_with(*args, **_arg1, &block); end
+
+  # Passes if actual is falsey (false or nil)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_falsey_value(*args, **_arg1, &block); end
+
+  # Passes if actual is falsey (false or nil)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_falsy_value(*args, **_arg1, &block); end
+
+  # Passes if actual includes expected. This works for
+  # collections and Strings. You can also pass in multiple args
+  # and it will only pass if all args are found in collection.
+  #
+  # @example
+  #   expect([1,2,3]).to      include(3)
+  #   expect([1,2,3]).to      include(2,3)
+  #   expect([1,2,3]).to      include(2,3,4) # fails
+  #   expect([1,2,3]).not_to  include(4)
+  #   expect("spread").to     include("read")
+  #   expect("spread").not_to include("red")
+  #   expect(:a => 1, :b => 2).to include(:a)
+  #   expect(:a => 1, :b => 2).to include(:a, :b)
+  #   expect(:a => 1, :b => 2).to include(:a => 1)
+  #   expect(:a => 1, :b => 2).to include(:b => 2, :a => 1)
+  #   expect(:a => 1, :b => 2).to include(:c) # fails
+  #   expect(:a => 1, :b => 2).not_to include(:a => 2)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_hash_including(*args, **_arg1, &block); end
+
+  # Passes if actual.kind_of?(expected)
+  #
+  # @example
+  #   expect(5).to     be_a_kind_of(Integer)
+  #   expect(5).to     be_a_kind_of(Numeric)
+  #   expect(5).not_to be_a_kind_of(Float)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_kind_of(*args, **_arg1, &block); end
+
+  # Passes if actual is nil
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_nil_value(*args, **_arg1, &block); end
+
+  # Passes if actual covers expected. This works for
+  # Ranges. You can also pass in multiple args
+  # and it will only pass if all args are found in Range.
+  #
+  # ### Warning:: Ruby >= 1.9 only
+  #
+  # @example
+  #   expect(1..10).to     cover(5)
+  #   expect(1..10).to     cover(4, 6)
+  #   expect(1..10).to     cover(4, 6, 11) # fails
+  #   expect(1..10).not_to cover(11)
+  #   expect(1..10).not_to cover(5)        # fails
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_range_covering(*args, **_arg1, &block); end
+
+  # Matches if the actual value ends with the expected value(s). In the case
+  # of a string, matches against the last `expected.length` characters of the
+  # actual string. In the case of an array, matches against the last
+  # `expected.length` elements of the actual array.
+  #
+  # @example
+  #   expect("this string").to   end_with "string"
+  #   expect([0, 1, 2, 3, 4]).to end_with 4
+  #   expect([0, 2, 3, 4, 4]).to end_with 3, 4
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_string_ending_with(*args, **_arg1, &block); end
+
+  # Passes if actual includes expected. This works for
+  # collections and Strings. You can also pass in multiple args
+  # and it will only pass if all args are found in collection.
+  #
+  # @example
+  #   expect([1,2,3]).to      include(3)
+  #   expect([1,2,3]).to      include(2,3)
+  #   expect([1,2,3]).to      include(2,3,4) # fails
+  #   expect([1,2,3]).not_to  include(4)
+  #   expect("spread").to     include("read")
+  #   expect("spread").not_to include("red")
+  #   expect(:a => 1, :b => 2).to include(:a)
+  #   expect(:a => 1, :b => 2).to include(:a, :b)
+  #   expect(:a => 1, :b => 2).to include(:a => 1)
+  #   expect(:a => 1, :b => 2).to include(:b => 2, :a => 1)
+  #   expect(:a => 1, :b => 2).to include(:c) # fails
+  #   expect(:a => 1, :b => 2).not_to include(:a => 2)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_string_including(*args, **_arg1, &block); end
+
+  # Given a `Regexp` or `String`, passes if `actual.match(pattern)`
+  # Given an arbitrary nested data structure (e.g. arrays and hashes),
+  # matches if `expected === actual` || `actual == expected` for each
+  # pair of elements.
+  #
+  # @example
+  #   expect(email).to match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
+  #   expect(email).to match("@example.com")
+  # @example
+  #   hash = {
+  #   :a => {
+  #   :b => ["foo", 5],
+  #   :c => { :d => 2.05 }
+  #   }
+  #   }
+  #
+  #   expect(hash).to match(
+  #   :a => {
+  #   :b => a_collection_containing_exactly(
+  #   a_string_starting_with("f"),
+  #   an_instance_of(Integer)
+  #   ),
+  #   :c => { :d => (a_value < 3) }
+  #   }
+  #   )
+  # @note The `match_regex` alias is deprecated and is not recommended for use.
+  #   It was added in 2.12.1 to facilitate its use from within custom
+  #   matchers (due to how the custom matcher DSL was evaluated in 2.x,
+  #   `match` could not be used there), but is no longer needed in 3.x.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_string_matching(*args, **_arg1, &block); end
+
+  # Matches if the actual value starts with the expected value(s). In the
+  # case of a string, matches against the first `expected.length` characters
+  # of the actual string. In the case of an array, matches against the first
+  # `expected.length` elements of the actual array.
+  #
+  # @example
+  #   expect("this string").to   start_with "this s"
+  #   expect([0, 1, 2, 3, 4]).to start_with 0
+  #   expect([0, 2, 3, 4, 4]).to start_with 0, 1
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_string_starting_with(*args, **_arg1, &block); end
+
+  # Passes if actual is truthy (anything but false or nil)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_truthy_value(*args, **_arg1, &block); end
+
+  # Given true, false, or nil, will pass if actual value is true, false or
+  # nil (respectively). Given no args means the caller should satisfy an if
+  # condition (to be or not to be).
+  #
+  # Predicates are any Ruby method that ends in a "?" and returns true or
+  # false.  Given be_ followed by arbitrary_predicate (without the "?"),
+  # RSpec will match convert that into a query against the target object.
+  #
+  # The arbitrary_predicate feature will handle any predicate prefixed with
+  # "be_an_" (e.g. be_an_instance_of), "be_a_" (e.g. be_a_kind_of) or "be_"
+  # (e.g. be_empty), letting you choose the prefix that best suits the
+  # predicate.
+  #
+  # @example
+  #   expect(actual).to     be_truthy
+  #   expect(actual).to     be_falsey
+  #   expect(actual).to     be_nil
+  #   expect(actual).to     be_[arbitrary_predicate](*args)
+  #   expect(actual).not_to be_nil
+  #   expect(actual).not_to be_[arbitrary_predicate](*args)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_value(*args, **_arg1, &block); end
+
+  # Passes if actual.between?(min, max). Works with any Comparable object,
+  # including String, Symbol, Time, or Numeric (Fixnum, Bignum, Integer,
+  # Float, Complex, and Rational).
+  #
+  # By default, `be_between` is inclusive (i.e. passes when given either the max or min value),
+  # but you can make it `exclusive` by chaining that off the matcher.
+  #
+  # @example
+  #   expect(5).to      be_between(1, 10)
+  #   expect(11).not_to be_between(1, 10)
+  #   expect(10).not_to be_between(1, 10).exclusive
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_value_between(*args, **_arg1, &block); end
+
+  # Passes if actual == expected +/- delta
+  #
+  # @example
+  #   expect(result).to     be_within(0.5).of(3.0)
+  #   expect(result).not_to be_within(0.5).of(3.0)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def a_value_within(*args, **_arg1, &block); end
+
+  # Allows multiple expectations in the provided block to fail, and then
+  # aggregates them into a single exception, rather than aborting on the
+  # first expectation failure like normal. This allows you to see all
+  # failures from an entire set of expectations without splitting each
+  # off into its own example (which may slow things down if the example
+  # setup is expensive).
+  #
+  # @example
+  #   aggregate_failures("verifying response") do
+  #   expect(response.status).to eq(200)
+  #   expect(response.headers).to include("Content-Type" => "text/plain")
+  #   expect(response.body).to include("Success")
+  #   end
+  # @note The implementation of this feature uses a thread-local variable,
+  #   which means that if you have an expectation failure in another thread,
+  #   it'll abort like normal.
+  # @param label [String] label for this aggregation block, which will be
+  #   included in the aggregated exception message.
+  # @param metadata [Hash] additional metadata about this failure aggregation
+  #   block. If multiple expectations fail, it will be exposed from the
+  #   {Expectations::MultipleExpectationsNotMetError} exception. Mostly
+  #   intended for internal RSpec use but you can use it as well.
+  # @raise [Expectations::MultipleExpectationsNotMetError] raised when
+  #   multiple expectations fail.
+  # @raise [Expectations::ExpectationNotMetError] raised when a single
+  #   expectation fails.
+  # @raise [Exception] other sorts of exceptions will be raised as normal.
+  # @yield Block containing as many expectation as you want. The block is
+  #   simply yielded to, so you can trust that anything that works outside
+  #   the block should work within it.
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#305
+  def aggregate_failures(label = T.unsafe(nil), metadata = T.unsafe(nil), &block); end
+
+  # Passes if the provided matcher passes when checked against all
+  # elements of the collection.
+  #
+  # @example
+  #   expect([1, 3, 5]).to all be_odd
+  #   expect([1, 3, 6]).to all be_odd # fails
+  # @example
+  #   expect([1, 3, 5]).to all( be_odd.and be_an(Integer) )
+  # @note The negative form `not_to all` is not supported. Instead
+  #   use `not_to include` or pass a negative form of a matcher
+  #   as the argument (e.g. `all exclude(:foo)`).
+  # @note You can also use this with compound matchers as well.
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#662
+  def all(expected); end
+
+  # An alternate form of `contain_exactly` that accepts
+  # the expected contents as a single array arg rather
+  # than splatted out as individual items.
+  #
+  # @example
+  #   expect(results).to contain_exactly(1, 2)
+  #   # is identical to:
+  #   expect(results).to match_array([1, 2])
+  # @see #contain_exactly
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def an_array_matching(*args, **_arg1, &block); end
+
+  # Passes if actual.instance_of?(expected)
+  #
+  # @example
+  #   expect(5).to     be_an_instance_of(Integer)
+  #   expect(5).not_to be_an_instance_of(Numeric)
+  #   expect(5).not_to be_an_instance_of(Float)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def an_instance_of(*args, **_arg1, &block); end
+
+  # Passes if <tt>actual == expected</tt>.
+  #
+  # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more
+  # information about equality in Ruby.
+  #
+  # @example
+  #   expect(5).to     eq(5)
+  #   expect(5).not_to eq(3)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def an_object_eq_to(*args, **_arg1, &block); end
+
+  # Passes if `actual.eql?(expected)`
+  #
+  # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more
+  # information about equality in Ruby.
+  #
+  # @example
+  #   expect(5).to     eql(5)
+  #   expect(5).not_to eql(3)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def an_object_eql_to(*args, **_arg1, &block); end
+
+  # Passes if <tt>actual.equal?(expected)</tt> (object identity).
+  #
+  # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more
+  # information about equality in Ruby.
+  #
+  # @example
+  #   expect(5).to       equal(5)   # Integers are equal
+  #   expect("5").not_to equal("5") # Strings that look the same are not the same object
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def an_object_equal_to(*args, **_arg1, &block); end
+
+  # Passes if `actual.exist?` or `actual.exists?`
+  #
+  # @example
+  #   expect(File).to exist("path/to/file")
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def an_object_existing(*args, **_arg1, &block); end
+
+  # Passes if actual's attribute values match the expected attributes hash.
+  # This works no matter how you define your attribute readers.
+  #
+  # @example
+  #   Person = Struct.new(:name, :age)
+  #   person = Person.new("Bob", 32)
+  #
+  #   expect(person).to have_attributes(:name => "Bob", :age => 32)
+  #   expect(person).to have_attributes(:name => a_string_starting_with("B"), :age => (a_value > 30) )
+  # @example
+  #   expect(person).to have_attributes(:color => "red")
+  # @note It will fail if actual doesn't respond to any of the expected attributes.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def an_object_having_attributes(*args, **_arg1, &block); end
+
+  # Given a `Regexp` or `String`, passes if `actual.match(pattern)`
+  # Given an arbitrary nested data structure (e.g. arrays and hashes),
+  # matches if `expected === actual` || `actual == expected` for each
+  # pair of elements.
+  #
+  # @example
+  #   expect(email).to match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
+  #   expect(email).to match("@example.com")
+  # @example
+  #   hash = {
+  #   :a => {
+  #   :b => ["foo", 5],
+  #   :c => { :d => 2.05 }
+  #   }
+  #   }
+  #
+  #   expect(hash).to match(
+  #   :a => {
+  #   :b => a_collection_containing_exactly(
+  #   a_string_starting_with("f"),
+  #   an_instance_of(Integer)
+  #   ),
+  #   :c => { :d => (a_value < 3) }
+  #   }
+  #   )
+  # @note The `match_regex` alias is deprecated and is not recommended for use.
+  #   It was added in 2.12.1 to facilitate its use from within custom
+  #   matchers (due to how the custom matcher DSL was evaluated in 2.x,
+  #   `match` could not be used there), but is no longer needed in 3.x.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def an_object_matching(*args, **_arg1, &block); end
+
+  # Matches if the target object responds to all of the names
+  # provided. Names can be Strings or Symbols.
+  #
+  # @example
+  #   expect("string").to respond_to(:length)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def an_object_responding_to(*args, **_arg1, &block); end
+
+  # Passes if the submitted block returns true. Yields target to the
+  # block.
+  #
+  # Generally speaking, this should be thought of as a last resort when
+  # you can't find any other way to specify the behaviour you wish to
+  # specify.
+  #
+  # If you do find yourself in such a situation, you could always write
+  # a custom matcher, which would likely make your specs more expressive.
+  #
+  # @example
+  #   expect(5).to satisfy { |n| n > 3 }
+  #   expect(5).to satisfy("be greater than 3") { |n| n > 3 }
+  # @param description [String] optional description to be used for this matcher.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def an_object_satisfying(*args, **_arg1, &block); end
+
+  # Given true, false, or nil, will pass if actual value is true, false or
+  # nil (respectively). Given no args means the caller should satisfy an if
+  # condition (to be or not to be).
+  #
+  # Predicates are any Ruby method that ends in a "?" and returns true or
+  # false.  Given be_ followed by arbitrary_predicate (without the "?"),
+  # RSpec will match convert that into a query against the target object.
+  #
+  # The arbitrary_predicate feature will handle any predicate prefixed with
+  # "be_an_" (e.g. be_an_instance_of), "be_a_" (e.g. be_a_kind_of) or "be_"
+  # (e.g. be_empty), letting you choose the prefix that best suits the
+  # predicate.
+  #
+  # @example
+  #   expect(actual).to     be_truthy
+  #   expect(actual).to     be_falsey
+  #   expect(actual).to     be_nil
+  #   expect(actual).to     be_[arbitrary_predicate](*args)
+  #   expect(actual).not_to be_nil
+  #   expect(actual).not_to be_[arbitrary_predicate](*args)
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#349
+  def be(*args); end
+
+  # passes if target.kind_of?(klass)
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#355
+  def be_a(klass); end
+
+  # Passes if actual.kind_of?(expected)
+  #
+  # @example
+  #   expect(5).to     be_a_kind_of(Integer)
+  #   expect(5).to     be_a_kind_of(Numeric)
+  #   expect(5).not_to be_a_kind_of(Float)
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#378
+  def be_a_kind_of(expected); end
+
+  # passes if target.kind_of?(klass)
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#355
+  def be_an(klass); end
+
+  # Passes if actual.instance_of?(expected)
+  #
+  # @example
+  #   expect(5).to     be_an_instance_of(Integer)
+  #   expect(5).not_to be_an_instance_of(Numeric)
+  #   expect(5).not_to be_an_instance_of(Float)
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#366
+  def be_an_instance_of(expected); end
+
+  # Passes if actual.between?(min, max). Works with any Comparable object,
+  # including String, Symbol, Time, or Numeric (Fixnum, Bignum, Integer,
+  # Float, Complex, and Rational).
+  #
+  # By default, `be_between` is inclusive (i.e. passes when given either the max or min value),
+  # but you can make it `exclusive` by chaining that off the matcher.
+  #
+  # @example
+  #   expect(5).to      be_between(1, 10)
+  #   expect(11).not_to be_between(1, 10)
+  #   expect(10).not_to be_between(1, 10).exclusive
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#395
+  def be_between(min, max); end
+
+  # Passes if actual is falsey (false or nil)
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#316
+  def be_falsey; end
+
+  # Passes if actual is falsey (false or nil)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def be_falsy(*args, **_arg1, &block); end
+
+  # Passes if actual.instance_of?(expected)
+  #
+  # @example
+  #   expect(5).to     be_an_instance_of(Integer)
+  #   expect(5).not_to be_an_instance_of(Numeric)
+  #   expect(5).not_to be_an_instance_of(Float)
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#366
+  def be_instance_of(expected); end
+
+  # Passes if actual.kind_of?(expected)
+  #
+  # @example
+  #   expect(5).to     be_a_kind_of(Integer)
+  #   expect(5).to     be_a_kind_of(Numeric)
+  #   expect(5).not_to be_a_kind_of(Float)
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#378
+  def be_kind_of(expected); end
+
+  # Passes if actual is nil
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#324
+  def be_nil; end
+
+  # Passes if actual is truthy (anything but false or nil)
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#310
+  def be_truthy; end
+
+  # Passes if actual == expected +/- delta
+  #
+  # @example
+  #   expect(result).to     be_within(0.5).of(3.0)
+  #   expect(result).not_to be_within(0.5).of(3.0)
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#405
+  def be_within(delta); end
+
+  # Applied to a proc, specifies that its execution will cause some value to
+  # change.
+  #
+  # You can either pass <tt>receiver</tt> and <tt>message</tt>, or a block,
+  # but not both.
+  #
+  # When passing a block, it must use the `{ ... }` format, not
+  # do/end, as `{ ... }` binds to the `change` method, whereas do/end
+  # would errantly bind to the `expect(..).to` or `expect(...).not_to` method.
+  #
+  # You can chain any of the following off of the end to specify details
+  # about the change:
+  #
+  # * `from`
+  # * `to`
+  #
+  # or any one of:
+  #
+  # * `by`
+  # * `by_at_least`
+  # * `by_at_most`
+  #
+  # == Notes
+  #
+  # Evaluates `receiver.message` or `block` before and after it
+  # evaluates the block passed to `expect`. If the value is the same
+  # object, its before/after `hash` value is used to see if it has changed.
+  # Therefore, your object needs to properly implement `hash` to work correctly
+  # with this matcher.
+  #
+  # `expect( ... ).not_to change` supports the form that specifies `from`
+  # (which specifies what you expect the starting, unchanged value to be)
+  # but does not support forms with subsequent calls to `by`, `by_at_least`,
+  # `by_at_most` or `to`.
+  #
+  # @example
+  #   expect {
+  #   team.add_player(player)
+  #   }.to change(roster, :count)
+  #
+  #   expect {
+  #   team.add_player(player)
+  #   }.to change(roster, :count).by(1)
+  #
+  #   expect {
+  #   team.add_player(player)
+  #   }.to change(roster, :count).by_at_least(1)
+  #
+  #   expect {
+  #   team.add_player(player)
+  #   }.to change(roster, :count).by_at_most(1)
+  #
+  #   string = "string"
+  #   expect {
+  #   string.reverse!
+  #   }.to change { string }.from("string").to("gnirts")
+  #
+  #   string = "string"
+  #   expect {
+  #   string
+  #   }.not_to change { string }.from("string")
+  #
+  #   expect {
+  #   person.happy_birthday
+  #   }.to change(person, :birthday).from(32).to(33)
+  #
+  #   expect {
+  #   employee.develop_great_new_social_networking_app
+  #   }.to change(employee, :title).from("Mail Clerk").to("CEO")
+  #
+  #   expect {
+  #   doctor.leave_office
+  #   }.to change(doctor, :sign).from(/is in/).to(/is out/)
+  #
+  #   user = User.new(:type => "admin")
+  #   expect {
+  #   user.symbolize_type
+  #   }.to change(user, :type).from(String).to(Symbol)
+  # @param receiver [Object]
+  # @param message [Symbol] the message to send the receiver
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#492
+  def change(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  # Applied to a proc, specifies that its execution will cause some value to
+  # change.
+  #
+  # You can either pass <tt>receiver</tt> and <tt>message</tt>, or a block,
+  # but not both.
+  #
+  # When passing a block, it must use the `{ ... }` format, not
+  # do/end, as `{ ... }` binds to the `change` method, whereas do/end
+  # would errantly bind to the `expect(..).to` or `expect(...).not_to` method.
+  #
+  # You can chain any of the following off of the end to specify details
+  # about the change:
+  #
+  # * `from`
+  # * `to`
+  #
+  # or any one of:
+  #
+  # * `by`
+  # * `by_at_least`
+  # * `by_at_most`
+  #
+  # == Notes
+  #
+  # Evaluates `receiver.message` or `block` before and after it
+  # evaluates the block passed to `expect`. If the value is the same
+  # object, its before/after `hash` value is used to see if it has changed.
+  # Therefore, your object needs to properly implement `hash` to work correctly
+  # with this matcher.
+  #
+  # `expect( ... ).not_to change` supports the form that specifies `from`
+  # (which specifies what you expect the starting, unchanged value to be)
+  # but does not support forms with subsequent calls to `by`, `by_at_least`,
+  # `by_at_most` or `to`.
+  #
+  # @example
+  #   expect {
+  #   team.add_player(player)
+  #   }.to change(roster, :count)
+  #
+  #   expect {
+  #   team.add_player(player)
+  #   }.to change(roster, :count).by(1)
+  #
+  #   expect {
+  #   team.add_player(player)
+  #   }.to change(roster, :count).by_at_least(1)
+  #
+  #   expect {
+  #   team.add_player(player)
+  #   }.to change(roster, :count).by_at_most(1)
+  #
+  #   string = "string"
+  #   expect {
+  #   string.reverse!
+  #   }.to change { string }.from("string").to("gnirts")
+  #
+  #   string = "string"
+  #   expect {
+  #   string
+  #   }.not_to change { string }.from("string")
+  #
+  #   expect {
+  #   person.happy_birthday
+  #   }.to change(person, :birthday).from(32).to(33)
+  #
+  #   expect {
+  #   employee.develop_great_new_social_networking_app
+  #   }.to change(employee, :title).from("Mail Clerk").to("CEO")
+  #
+  #   expect {
+  #   doctor.leave_office
+  #   }.to change(doctor, :sign).from(/is in/).to(/is out/)
+  #
+  #   user = User.new(:type => "admin")
+  #   expect {
+  #   user.symbolize_type
+  #   }.to change(user, :type).from(String).to(Symbol)
+  # @param receiver [Object]
+  # @param message [Symbol] the message to send the receiver
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def changing(*args, **_arg1, &block); end
+
+  # Passes if actual contains all of the expected regardless of order.
+  # This works for collections. Pass in multiple args and it will only
+  # pass if all args are found in collection.
+  #
+  # @example
+  #   expect([1, 2, 3]).to contain_exactly(1, 2, 3)
+  #   expect([1, 2, 3]).to contain_exactly(1, 3, 2)
+  # @note This is also available using the `=~` operator with `should`,
+  #   but `=~` is not supported with `expect`.
+  # @see #match_array
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#510
+  def contain_exactly(*items); end
+
+  # Passes if actual contains all of the expected regardless of order.
+  # This works for collections. Pass in multiple args and it will only
+  # pass if all args are found in collection.
+  #
+  # @example
+  #   expect([1, 2, 3]).to contain_exactly(1, 2, 3)
+  #   expect([1, 2, 3]).to contain_exactly(1, 3, 2)
+  # @note This is also available using the `=~` operator with `should`,
+  #   but `=~` is not supported with `expect`.
+  # @see #match_array
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def containing_exactly(*args, **_arg1, &block); end
+
+  # Passes if actual covers expected. This works for
+  # Ranges. You can also pass in multiple args
+  # and it will only pass if all args are found in Range.
+  #
+  # ### Warning:: Ruby >= 1.9 only
+  #
+  # @example
+  #   expect(1..10).to     cover(5)
+  #   expect(1..10).to     cover(4, 6)
+  #   expect(1..10).to     cover(4, 6, 11) # fails
+  #   expect(1..10).not_to cover(11)
+  #   expect(1..10).not_to cover(5)        # fails
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#528
+  def cover(*values); end
+
+  # Passes if actual covers expected. This works for
+  # Ranges. You can also pass in multiple args
+  # and it will only pass if all args are found in Range.
+  #
+  # ### Warning:: Ruby >= 1.9 only
+  #
+  # @example
+  #   expect(1..10).to     cover(5)
+  #   expect(1..10).to     cover(4, 6)
+  #   expect(1..10).to     cover(4, 6, 11) # fails
+  #   expect(1..10).not_to cover(11)
+  #   expect(1..10).not_to cover(5)        # fails
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def covering(*args, **_arg1, &block); end
+
+  # Matches if the actual value ends with the expected value(s). In the case
+  # of a string, matches against the last `expected.length` characters of the
+  # actual string. In the case of an array, matches against the last
+  # `expected.length` elements of the actual array.
+  #
+  # @example
+  #   expect("this string").to   end_with "string"
+  #   expect([0, 1, 2, 3, 4]).to end_with 4
+  #   expect([0, 2, 3, 4, 4]).to end_with 3, 4
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#543
+  def end_with(*expected); end
+
+  # Matches if the actual value ends with the expected value(s). In the case
+  # of a string, matches against the last `expected.length` characters of the
+  # actual string. In the case of an array, matches against the last
+  # `expected.length` elements of the actual array.
+  #
+  # @example
+  #   expect("this string").to   end_with "string"
+  #   expect([0, 1, 2, 3, 4]).to end_with 4
+  #   expect([0, 2, 3, 4, 4]).to end_with 3, 4
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def ending_with(*args, **_arg1, &block); end
+
+  # Passes if <tt>actual == expected</tt>.
+  #
+  # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more
+  # information about equality in Ruby.
+  #
+  # @example
+  #   expect(5).to     eq(5)
+  #   expect(5).not_to eq(3)
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#558
+  def eq(expected); end
+
+  # Passes if <tt>actual == expected</tt>.
+  #
+  # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more
+  # information about equality in Ruby.
+  #
+  # @example
+  #   expect(5).to     eq(5)
+  #   expect(5).not_to eq(3)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def eq_to(*args, **_arg1, &block); end
+
+  # Passes if `actual.eql?(expected)`
+  #
+  # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more
+  # information about equality in Ruby.
+  #
+  # @example
+  #   expect(5).to     eql(5)
+  #   expect(5).not_to eql(3)
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#572
+  def eql(expected); end
+
+  # Passes if `actual.eql?(expected)`
+  #
+  # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more
+  # information about equality in Ruby.
+  #
+  # @example
+  #   expect(5).to     eql(5)
+  #   expect(5).not_to eql(3)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def eql_to(*args, **_arg1, &block); end
+
+  # Passes if <tt>actual.equal?(expected)</tt> (object identity).
+  #
+  # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more
+  # information about equality in Ruby.
+  #
+  # @example
+  #   expect(5).to       equal(5)   # Integers are equal
+  #   expect("5").not_to equal("5") # Strings that look the same are not the same object
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#586
+  def equal(expected); end
+
+  # Passes if <tt>actual.equal?(expected)</tt> (object identity).
+  #
+  # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more
+  # information about equality in Ruby.
+  #
+  # @example
+  #   expect(5).to       equal(5)   # Integers are equal
+  #   expect("5").not_to equal("5") # Strings that look the same are not the same object
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def equal_to(*args, **_arg1, &block); end
+
+  # Passes if `actual.exist?` or `actual.exists?`
+  #
+  # @example
+  #   expect(File).to exist("path/to/file")
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#596
+  def exist(*args); end
+
+  # Passes if `actual.exist?` or `actual.exists?`
+  #
+  # @example
+  #   expect(File).to exist("path/to/file")
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def existing(*args, **_arg1, &block); end
+
+  # Supports `expect(actual).to matcher` syntax by wrapping `actual` in an
+  # `ExpectationTarget`.
+  #
+  # @example
+  #   expect(actual).to eq(expected)
+  #   expect(actual).not_to eq(expected)
+  # @return [Expectations::ExpectationTarget]
+  # @see Expectations::ExpectationTarget#to
+  # @see Expectations::ExpectationTarget#not_to
+  #
+  # source://rspec-expectations//lib/rspec/expectations/syntax.rb#72
+  def expect(value = T.unsafe(nil), &block); end
+
+  # Passes if actual's attribute values match the expected attributes hash.
+  # This works no matter how you define your attribute readers.
+  #
+  # @example
+  #   Person = Struct.new(:name, :age)
+  #   person = Person.new("Bob", 32)
+  #
+  #   expect(person).to have_attributes(:name => "Bob", :age => 32)
+  #   expect(person).to have_attributes(:name => a_string_starting_with("B"), :age => (a_value > 30) )
+  # @example
+  #   expect(person).to have_attributes(:color => "red")
+  # @note It will fail if actual doesn't respond to any of the expected attributes.
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#616
+  def have_attributes(expected); end
+
+  # Passes if actual's attribute values match the expected attributes hash.
+  # This works no matter how you define your attribute readers.
+  #
+  # @example
+  #   Person = Struct.new(:name, :age)
+  #   person = Person.new("Bob", 32)
+  #
+  #   expect(person).to have_attributes(:name => "Bob", :age => 32)
+  #   expect(person).to have_attributes(:name => a_string_starting_with("B"), :age => (a_value > 30) )
+  # @example
+  #   expect(person).to have_attributes(:color => "red")
+  # @note It will fail if actual doesn't respond to any of the expected attributes.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def having_attributes(*args, **_arg1, &block); end
+
+  # Passes if actual includes expected. This works for
+  # collections and Strings. You can also pass in multiple args
+  # and it will only pass if all args are found in collection.
+  #
+  # @example
+  #   expect([1,2,3]).to      include(3)
+  #   expect([1,2,3]).to      include(2,3)
+  #   expect([1,2,3]).to      include(2,3,4) # fails
+  #   expect([1,2,3]).not_to  include(4)
+  #   expect("spread").to     include("read")
+  #   expect("spread").not_to include("red")
+  #   expect(:a => 1, :b => 2).to include(:a)
+  #   expect(:a => 1, :b => 2).to include(:a, :b)
+  #   expect(:a => 1, :b => 2).to include(:a => 1)
+  #   expect(:a => 1, :b => 2).to include(:b => 2, :a => 1)
+  #   expect(:a => 1, :b => 2).to include(:c) # fails
+  #   expect(:a => 1, :b => 2).not_to include(:a => 2)
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#639
+  def include(*expected); end
+
+  # Passes if actual includes expected. This works for
+  # collections and Strings. You can also pass in multiple args
+  # and it will only pass if all args are found in collection.
+  #
+  # @example
+  #   expect([1,2,3]).to      include(3)
+  #   expect([1,2,3]).to      include(2,3)
+  #   expect([1,2,3]).to      include(2,3,4) # fails
+  #   expect([1,2,3]).not_to  include(4)
+  #   expect("spread").to     include("read")
+  #   expect("spread").not_to include("red")
+  #   expect(:a => 1, :b => 2).to include(:a)
+  #   expect(:a => 1, :b => 2).to include(:a, :b)
+  #   expect(:a => 1, :b => 2).to include(:a => 1)
+  #   expect(:a => 1, :b => 2).to include(:b => 2, :a => 1)
+  #   expect(:a => 1, :b => 2).to include(:c) # fails
+  #   expect(:a => 1, :b => 2).not_to include(:a => 2)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def including(*args, **_arg1, &block); end
+
+  # Given a `Regexp` or `String`, passes if `actual.match(pattern)`
+  # Given an arbitrary nested data structure (e.g. arrays and hashes),
+  # matches if `expected === actual` || `actual == expected` for each
+  # pair of elements.
+  #
+  # @example
+  #   expect(email).to match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
+  #   expect(email).to match("@example.com")
+  # @example
+  #   hash = {
+  #   :a => {
+  #   :b => ["foo", 5],
+  #   :c => { :d => 2.05 }
+  #   }
+  #   }
+  #
+  #   expect(hash).to match(
+  #   :a => {
+  #   :b => a_collection_containing_exactly(
+  #   a_string_starting_with("f"),
+  #   an_instance_of(Integer)
+  #   ),
+  #   :c => { :d => (a_value < 3) }
+  #   }
+  #   )
+  # @note The `match_regex` alias is deprecated and is not recommended for use.
+  #   It was added in 2.12.1 to facilitate its use from within custom
+  #   matchers (due to how the custom matcher DSL was evaluated in 2.x,
+  #   `match` could not be used there), but is no longer needed in 3.x.
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#697
+  def match(expected); end
+
+  # An alternate form of `contain_exactly` that accepts
+  # the expected contents as a single array arg rather
+  # than splatted out as individual items.
+  #
+  # @example
+  #   expect(results).to contain_exactly(1, 2)
+  #   # is identical to:
+  #   expect(results).to match_array([1, 2])
+  # @see #contain_exactly
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#715
+  def match_array(items); end
+
+  # Given a `Regexp` or `String`, passes if `actual.match(pattern)`
+  # Given an arbitrary nested data structure (e.g. arrays and hashes),
+  # matches if `expected === actual` || `actual == expected` for each
+  # pair of elements.
+  #
+  # @example
+  #   expect(email).to match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
+  #   expect(email).to match("@example.com")
+  # @example
+  #   hash = {
+  #   :a => {
+  #   :b => ["foo", 5],
+  #   :c => { :d => 2.05 }
+  #   }
+  #   }
+  #
+  #   expect(hash).to match(
+  #   :a => {
+  #   :b => a_collection_containing_exactly(
+  #   a_string_starting_with("f"),
+  #   an_instance_of(Integer)
+  #   ),
+  #   :c => { :d => (a_value < 3) }
+  #   }
+  #   )
+  # @note The `match_regex` alias is deprecated and is not recommended for use.
+  #   It was added in 2.12.1 to facilitate its use from within custom
+  #   matchers (due to how the custom matcher DSL was evaluated in 2.x,
+  #   `match` could not be used there), but is no longer needed in 3.x.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def match_regex(*args, **_arg1, &block); end
+
+  # Given a `Regexp` or `String`, passes if `actual.match(pattern)`
+  # Given an arbitrary nested data structure (e.g. arrays and hashes),
+  # matches if `expected === actual` || `actual == expected` for each
+  # pair of elements.
+  #
+  # @example
+  #   expect(email).to match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
+  #   expect(email).to match("@example.com")
+  # @example
+  #   hash = {
+  #   :a => {
+  #   :b => ["foo", 5],
+  #   :c => { :d => 2.05 }
+  #   }
+  #   }
+  #
+  #   expect(hash).to match(
+  #   :a => {
+  #   :b => a_collection_containing_exactly(
+  #   a_string_starting_with("f"),
+  #   an_instance_of(Integer)
+  #   ),
+  #   :c => { :d => (a_value < 3) }
+  #   }
+  #   )
+  # @note The `match_regex` alias is deprecated and is not recommended for use.
+  #   It was added in 2.12.1 to facilitate its use from within custom
+  #   matchers (due to how the custom matcher DSL was evaluated in 2.x,
+  #   `match` could not be used there), but is no longer needed in 3.x.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def matching(*args, **_arg1, &block); end
+
+  # With no arg, passes if the block outputs `to_stdout` or `to_stderr`.
+  # With a string, passes if the block outputs that specific string `to_stdout` or `to_stderr`.
+  # With a regexp or matcher, passes if the block outputs a string `to_stdout` or `to_stderr` that matches.
+  #
+  # To capture output from any spawned subprocess as well, use `to_stdout_from_any_process` or
+  # `to_stderr_from_any_process`. Output from any process that inherits the main process's corresponding
+  # standard stream will be captured.
+  #
+  # @example
+  #   expect { print 'foo' }.to output.to_stdout
+  #   expect { print 'foo' }.to output('foo').to_stdout
+  #   expect { print 'foo' }.to output(/foo/).to_stdout
+  #
+  #   expect { do_something }.to_not output.to_stdout
+  #
+  #   expect { warn('foo') }.to output.to_stderr
+  #   expect { warn('foo') }.to output('foo').to_stderr
+  #   expect { warn('foo') }.to output(/foo/).to_stderr
+  #
+  #   expect { do_something }.to_not output.to_stderr
+  #
+  #   expect { system('echo foo') }.to output("foo\n").to_stdout_from_any_process
+  #   expect { system('echo foo', out: :err) }.to output("foo\n").to_stderr_from_any_process
+  # @note `to_stdout` and `to_stderr` work by temporarily replacing `$stdout` or `$stderr`,
+  #   so they're not able to intercept stream output that explicitly uses `STDOUT`/`STDERR`
+  #   or that uses a reference to `$stdout`/`$stderr` that was stored before the
+  #   matcher was used.
+  # @note `to_stdout_from_any_process` and `to_stderr_from_any_process` use Tempfiles, and
+  #   are thus significantly (~30x) slower than `to_stdout` and `to_stderr`.
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#752
+  def output(expected = T.unsafe(nil)); end
+
+  # With no args, matches if any error is raised.
+  # With a named error, matches only if that specific error is raised.
+  # With a named error and message specified as a String, matches only if both match.
+  # With a named error and message specified as a Regexp, matches only if both match.
+  # Pass an optional block to perform extra verifications on the exception matched
+  #
+  # @example
+  #   expect { do_something_risky }.to raise_error
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError)
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError) { |error| expect(error.data).to eq 42 }
+  #   expect { do_something_risky }.to raise_error { |error| expect(error.data).to eq 42 }
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError, "that was too risky")
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError, /oo ri/)
+  #   expect { do_something_risky }.to raise_error("that was too risky")
+  #
+  #   expect { do_something_risky }.not_to raise_error
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#773
+  def raise_error(error = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  # With no args, matches if any error is raised.
+  # With a named error, matches only if that specific error is raised.
+  # With a named error and message specified as a String, matches only if both match.
+  # With a named error and message specified as a Regexp, matches only if both match.
+  # Pass an optional block to perform extra verifications on the exception matched
+  #
+  # @example
+  #   expect { do_something_risky }.to raise_error
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError)
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError) { |error| expect(error.data).to eq 42 }
+  #   expect { do_something_risky }.to raise_error { |error| expect(error.data).to eq 42 }
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError, "that was too risky")
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError, /oo ri/)
+  #   expect { do_something_risky }.to raise_error("that was too risky")
+  #
+  #   expect { do_something_risky }.not_to raise_error
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#773
+  def raise_exception(error = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  # With no args, matches if any error is raised.
+  # With a named error, matches only if that specific error is raised.
+  # With a named error and message specified as a String, matches only if both match.
+  # With a named error and message specified as a Regexp, matches only if both match.
+  # Pass an optional block to perform extra verifications on the exception matched
+  #
+  # @example
+  #   expect { do_something_risky }.to raise_error
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError)
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError) { |error| expect(error.data).to eq 42 }
+  #   expect { do_something_risky }.to raise_error { |error| expect(error.data).to eq 42 }
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError, "that was too risky")
+  #   expect { do_something_risky }.to raise_error(PoorRiskDecisionError, /oo ri/)
+  #   expect { do_something_risky }.to raise_error("that was too risky")
+  #
+  #   expect { do_something_risky }.not_to raise_error
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def raising(*args, **_arg1, &block); end
+
+  # Matches if the target object responds to all of the names
+  # provided. Names can be Strings or Symbols.
+  #
+  # @example
+  #   expect("string").to respond_to(:length)
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#792
+  def respond_to(*names); end
+
+  # Matches if the target object responds to all of the names
+  # provided. Names can be Strings or Symbols.
+  #
+  # @example
+  #   expect("string").to respond_to(:length)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def responding_to(*args, **_arg1, &block); end
+
+  # Passes if the submitted block returns true. Yields target to the
+  # block.
+  #
+  # Generally speaking, this should be thought of as a last resort when
+  # you can't find any other way to specify the behaviour you wish to
+  # specify.
+  #
+  # If you do find yourself in such a situation, you could always write
+  # a custom matcher, which would likely make your specs more expressive.
+  #
+  # @example
+  #   expect(5).to satisfy { |n| n > 3 }
+  #   expect(5).to satisfy("be greater than 3") { |n| n > 3 }
+  # @param description [String] optional description to be used for this matcher.
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#813
+  def satisfy(description = T.unsafe(nil), &block); end
+
+  # Passes if the submitted block returns true. Yields target to the
+  # block.
+  #
+  # Generally speaking, this should be thought of as a last resort when
+  # you can't find any other way to specify the behaviour you wish to
+  # specify.
+  #
+  # If you do find yourself in such a situation, you could always write
+  # a custom matcher, which would likely make your specs more expressive.
+  #
+  # @example
+  #   expect(5).to satisfy { |n| n > 3 }
+  #   expect(5).to satisfy("be greater than 3") { |n| n > 3 }
+  # @param description [String] optional description to be used for this matcher.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def satisfying(*args, **_arg1, &block); end
+
+  # Matches if the actual value starts with the expected value(s). In the
+  # case of a string, matches against the first `expected.length` characters
+  # of the actual string. In the case of an array, matches against the first
+  # `expected.length` elements of the actual array.
+  #
+  # @example
+  #   expect("this string").to   start_with "this s"
+  #   expect([0, 1, 2, 3, 4]).to start_with 0
+  #   expect([0, 2, 3, 4, 4]).to start_with 0, 1
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#828
+  def start_with(*expected); end
+
+  # Matches if the actual value starts with the expected value(s). In the
+  # case of a string, matches against the first `expected.length` characters
+  # of the actual string. In the case of an array, matches against the first
+  # `expected.length` elements of the actual array.
+  #
+  # @example
+  #   expect("this string").to   start_with "this s"
+  #   expect([0, 1, 2, 3, 4]).to start_with 0
+  #   expect([0, 2, 3, 4, 4]).to start_with 0, 1
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def starting_with(*args, **_arg1, &block); end
+
+  # Given no argument, matches if a proc throws any Symbol.
+  #
+  # Given a Symbol, matches if the given proc throws the specified Symbol.
+  #
+  # Given a Symbol and an arg, matches if the given proc throws the
+  # specified Symbol with the specified arg.
+  #
+  # @example
+  #   expect { do_something_risky }.to throw_symbol
+  #   expect { do_something_risky }.to throw_symbol(:that_was_risky)
+  #   expect { do_something_risky }.to throw_symbol(:that_was_risky, 'culprit')
+  #
+  #   expect { do_something_risky }.not_to throw_symbol
+  #   expect { do_something_risky }.not_to throw_symbol(:that_was_risky)
+  #   expect { do_something_risky }.not_to throw_symbol(:that_was_risky, 'culprit')
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#850
+  def throw_symbol(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
+
+  # Given no argument, matches if a proc throws any Symbol.
+  #
+  # Given a Symbol, matches if the given proc throws the specified Symbol.
+  #
+  # Given a Symbol and an arg, matches if the given proc throws the
+  # specified Symbol with the specified arg.
+  #
+  # @example
+  #   expect { do_something_risky }.to throw_symbol
+  #   expect { do_something_risky }.to throw_symbol(:that_was_risky)
+  #   expect { do_something_risky }.to throw_symbol(:that_was_risky, 'culprit')
+  #
+  #   expect { do_something_risky }.not_to throw_symbol
+  #   expect { do_something_risky }.not_to throw_symbol(:that_was_risky)
+  #   expect { do_something_risky }.not_to throw_symbol(:that_was_risky, 'culprit')
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def throwing(*args, **_arg1, &block); end
+
+  # Passes if actual == expected +/- delta
+  #
+  # @example
+  #   expect(result).to     be_within(0.5).of(3.0)
+  #   expect(result).not_to be_within(0.5).of(3.0)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def within(*args, **_arg1, &block); end
+
+  # Passes if the method called in the expect block yields, regardless
+  # of whether or not arguments are yielded.
+  #
+  # @example
+  #   expect { |b| 5.tap(&b) }.to yield_control
+  #   expect { |b| "a".to_sym(&b) }.not_to yield_control
+  # @note Your expect block must accept a parameter and pass it on to
+  #   the method-under-test as a block.
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#871
+  def yield_control; end
+
+  # Designed for use with methods that repeatedly yield (such as
+  # iterators). Passes if the method called in the expect block yields
+  # multiple times with arguments matching those given.
+  #
+  # Argument matching is done using `===` (the case match operator)
+  # and `==`. If the expected and actual arguments match with either
+  # operator, the matcher will pass.
+  #
+  # @example
+  #   expect { |b| [1, 2, 3].each(&b) }.to yield_successive_args(1, 2, 3)
+  #   expect { |b| { :a => 1, :b => 2 }.each(&b) }.to yield_successive_args([:a, 1], [:b, 2])
+  #   expect { |b| [1, 2, 3].each(&b) }.not_to yield_successive_args(1, 2)
+  # @note Your expect block must accept a parameter and pass it on to
+  #   the method-under-test as a block.
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#940
+  def yield_successive_args(*args); end
+
+  # Given no arguments, matches if the method called in the expect
+  # block yields with arguments (regardless of what they are or how
+  # many there are).
+  #
+  # Given arguments, matches if the method called in the expect block
+  # yields with arguments that match the given arguments.
+  #
+  # Argument matching is done using `===` (the case match operator)
+  # and `==`. If the expected and actual arguments match with either
+  # operator, the matcher will pass.
+  #
+  # @example
+  #   expect { |b| 5.tap(&b) }.to yield_with_args # because #tap yields an arg
+  #   expect { |b| 5.tap(&b) }.to yield_with_args(5) # because 5 == 5
+  #   expect { |b| 5.tap(&b) }.to yield_with_args(Integer) # because Integer === 5
+  #   expect { |b| File.open("f.txt", &b) }.to yield_with_args(/txt/) # because /txt/ === "f.txt"
+  #
+  #   expect { |b| User.transaction(&b) }.not_to yield_with_args # because it yields no args
+  #   expect { |b| 5.tap(&b) }.not_to yield_with_args(1, 2, 3)
+  # @note Your expect block must accept a parameter and pass it on to
+  #   the method-under-test as a block.
+  # @note This matcher is not designed for use with methods that yield
+  #   multiple times.
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#919
+  def yield_with_args(*args); end
+
+  # Passes if the method called in the expect block yields with
+  # no arguments. Fails if it does not yield, or yields with arguments.
+  #
+  # @example
+  #   expect { |b| User.transaction(&b) }.to yield_with_no_args
+  #   expect { |b| 5.tap(&b) }.not_to yield_with_no_args # because it yields with `5`
+  #   expect { |b| "a".to_sym(&b) }.not_to yield_with_no_args # because it does not yield
+  # @note Your expect block must accept a parameter and pass it on to
+  #   the method-under-test as a block.
+  # @note This matcher is not designed for use with methods that yield
+  #   multiple times.
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#889
+  def yield_with_no_args; end
+
+  # Passes if the method called in the expect block yields, regardless
+  # of whether or not arguments are yielded.
+  #
+  # @example
+  #   expect { |b| 5.tap(&b) }.to yield_control
+  #   expect { |b| "a".to_sym(&b) }.not_to yield_control
+  # @note Your expect block must accept a parameter and pass it on to
+  #   the method-under-test as a block.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def yielding_control(*args, **_arg1, &block); end
+
+  # Designed for use with methods that repeatedly yield (such as
+  # iterators). Passes if the method called in the expect block yields
+  # multiple times with arguments matching those given.
+  #
+  # Argument matching is done using `===` (the case match operator)
+  # and `==`. If the expected and actual arguments match with either
+  # operator, the matcher will pass.
+  #
+  # @example
+  #   expect { |b| [1, 2, 3].each(&b) }.to yield_successive_args(1, 2, 3)
+  #   expect { |b| { :a => 1, :b => 2 }.each(&b) }.to yield_successive_args([:a, 1], [:b, 2])
+  #   expect { |b| [1, 2, 3].each(&b) }.not_to yield_successive_args(1, 2)
+  # @note Your expect block must accept a parameter and pass it on to
+  #   the method-under-test as a block.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def yielding_successive_args(*args, **_arg1, &block); end
+
+  # Given no arguments, matches if the method called in the expect
+  # block yields with arguments (regardless of what they are or how
+  # many there are).
+  #
+  # Given arguments, matches if the method called in the expect block
+  # yields with arguments that match the given arguments.
+  #
+  # Argument matching is done using `===` (the case match operator)
+  # and `==`. If the expected and actual arguments match with either
+  # operator, the matcher will pass.
+  #
+  # @example
+  #   expect { |b| 5.tap(&b) }.to yield_with_args # because #tap yields an arg
+  #   expect { |b| 5.tap(&b) }.to yield_with_args(5) # because 5 == 5
+  #   expect { |b| 5.tap(&b) }.to yield_with_args(Integer) # because Integer === 5
+  #   expect { |b| File.open("f.txt", &b) }.to yield_with_args(/txt/) # because /txt/ === "f.txt"
+  #
+  #   expect { |b| User.transaction(&b) }.not_to yield_with_args # because it yields no args
+  #   expect { |b| 5.tap(&b) }.not_to yield_with_args(1, 2, 3)
+  # @note Your expect block must accept a parameter and pass it on to
+  #   the method-under-test as a block.
+  # @note This matcher is not designed for use with methods that yield
+  #   multiple times.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def yielding_with_args(*args, **_arg1, &block); end
+
+  # Passes if the method called in the expect block yields with
+  # no arguments. Fails if it does not yield, or yields with arguments.
+  #
+  # @example
+  #   expect { |b| User.transaction(&b) }.to yield_with_no_args
+  #   expect { |b| 5.tap(&b) }.not_to yield_with_no_args # because it yields with `5`
+  #   expect { |b| "a".to_sym(&b) }.not_to yield_with_no_args # because it does not yield
+  # @note Your expect block must accept a parameter and pass it on to
+  #   the method-under-test as a block.
+  # @note This matcher is not designed for use with methods that yield
+  #   multiple times.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#38
+  def yielding_with_no_args(*args, **_arg1, &block); end
+
+  private
+
+  # source://rspec-expectations//lib/rspec/matchers.rb#961
+  def method_missing(method, *args, **_arg2, &block); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers.rb#974
+  def respond_to_missing?(method, *_arg1); end
+
+  class << self
+    # Extended from {RSpec::Matchers::DSL#alias_matcher}.
+    #
+    # source://rspec-expectations//lib/rspec/matchers.rb#250
+    def alias_matcher(*args, &block); end
+
+    # Used by rspec-core to clear the state used to generate
+    # descriptions after an example.
+    #
+    # @api private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/generated_descriptions.rb#11
+    def clear_generated_description; end
+
+    # Delegates to {RSpec::Expectations.configuration}.
+    # This is here because rspec-core's `expect_with` option
+    # looks for a `configuration` method on the mixin
+    # (`RSpec::Matchers`) to yield to a block.
+    #
+    # @return [RSpec::Expectations::Configuration] the configuration object
+    #
+    # source://rspec-expectations//lib/rspec/matchers.rb#951
+    def configuration; end
+
+    # Generates an an example description based on the last expectation.
+    # Used by rspec-core's one-liner syntax.
+    #
+    # @api private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/generated_descriptions.rb#19
+    def generated_description; end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-expectations//lib/rspec/matchers.rb#1008
+    def is_a_describable_matcher?(obj); end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-expectations//lib/rspec/matchers.rb#988
+    def is_a_matcher?(obj); end
+
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/generated_descriptions.rb#25
+    def last_description; end
+
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/generated_descriptions.rb#5
+    def last_expectation_handler; end
+
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/generated_descriptions.rb#5
+    def last_expectation_handler=(_arg0); end
+
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/generated_descriptions.rb#5
+    def last_matcher; end
+
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/generated_descriptions.rb#5
+    def last_matcher=(_arg0); end
+  end
+end
+
+# Decorator that wraps a matcher and overrides `description`
+# using the provided block in order to support an alias
+# of a matcher. This is intended for use when composing
+# matchers, so that you can use an expression like
+# `include( a_value_within(0.1).of(3) )` rather than
+# `include( be_within(0.1).of(3) )`, and have the corresponding
+# description read naturally.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/aliased_matcher.rb#12
+class RSpec::Matchers::AliasedMatcher < ::RSpec::Matchers::MatcherDelegator
+  # @api private
+  # @return [AliasedMatcher] a new instance of AliasedMatcher
+  #
+  # source://rspec-expectations//lib/rspec/matchers/aliased_matcher.rb#13
+  def initialize(base_matcher, description_block); end
+
+  # Provides the description of the aliased matcher. Aliased matchers
+  # are designed to behave identically to the original matcher except
+  # for the description and failure messages. The description is different
+  # to reflect the aliased name.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/aliased_matcher.rb#36
+  def description; end
+
+  # Provides the failure_message of the aliased matcher. Aliased matchers
+  # are designed to behave identically to the original matcher except
+  # for the description and failure messages. The failure_message is different
+  # to reflect the aliased name.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/aliased_matcher.rb#46
+  def failure_message; end
+
+  # Provides the failure_message_when_negated of the aliased matcher. Aliased matchers
+  # are designed to behave identically to the original matcher except
+  # for the description and failure messages. The failure_message_when_negated is different
+  # to reflect the aliased name.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/aliased_matcher.rb#56
+  def failure_message_when_negated; end
+
+  # Forward messages on to the wrapped matcher.
+  # Since many matchers provide a fluent interface
+  # (e.g. `a_value_within(0.1).of(3)`), we need to wrap
+  # the returned value if it responds to `description`,
+  # so that our override can be applied when it is eventually
+  # used.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/aliased_matcher.rb#24
+  def method_missing(*_arg0); end
+end
+
+# Decorator used for matchers that have special implementations of
+# operators like `==` and `===`.
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/aliased_matcher.rb#64
+class RSpec::Matchers::AliasedMatcherWithOperatorSupport < ::RSpec::Matchers::AliasedMatcher; end
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/aliased_matcher.rb#71
+class RSpec::Matchers::AliasedNegatedMatcher < ::RSpec::Matchers::AliasedMatcher
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/aliased_matcher.rb#80
+  def does_not_match?(*args, &block); end
+
+  # source://rspec-expectations//lib/rspec/matchers/aliased_matcher.rb#84
+  def failure_message; end
+
+  # source://rspec-expectations//lib/rspec/matchers/aliased_matcher.rb#88
+  def failure_message_when_negated; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/aliased_matcher.rb#72
+  def matches?(*args, &block); end
+
+  private
+
+  # For a matcher that uses the default failure messages, we prefer to
+  # use the override provided by the `description_block`, because it
+  # includes the phrasing that the user has expressed a preference for
+  # by going through the effort of defining a negated matcher.
+  #
+  # However, if the override didn't actually change anything, then we
+  # should return the opposite failure message instead -- the overridden
+  # message is going to be confusing if we return it as-is, as it represents
+  # the non-negated failure message for a negated match (or vice versa).
+  #
+  # source://rspec-expectations//lib/rspec/matchers/aliased_matcher.rb#105
+  def optimal_failure_message(same, inverted); end
+end
+
+# source://rspec-expectations//lib/rspec/matchers/aliased_matcher.rb#94
+RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
+
+# source://rspec-expectations//lib/rspec/matchers.rb#957
+RSpec::Matchers::BE_PREDICATE_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# Provides a base class with as little methods as possible, so that
+# most methods can be delegated via `method_missing`.
+#
+# On Ruby 2.0+ BasicObject could be used for this purpose, but it
+# introduce some extra complexity with constant resolution, so the
+# BlankSlate pattern was prefered.
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/matcher_delegator.rb#10
+class RSpec::Matchers::BaseDelegator; end
+
+# Container module for all built-in matchers. The matcher classes are here
+# (rather than directly under `RSpec::Matchers`) in order to prevent name
+# collisions, since `RSpec::Matchers` gets included into the user's namespace.
+#
+# Autoloading is used to delay when the matcher classes get loaded, allowing
+# rspec-matchers to boot faster, and avoiding loading matchers the user is
+# not using.
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#3
+module RSpec::Matchers::BuiltIn; end
+
+# Provides the implementation for `all`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/all.rb#7
+class RSpec::Matchers::BuiltIn::All < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [All] a new instance of All
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/all.rb#11
+  def initialize(matcher); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/all.rb#37
+  def description; end
+
+  # @api private
+  # @private
+  # @raise [NotImplementedError]
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/all.rb#17
+  def does_not_match?(_actual); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/all.rb#9
+  def failed_objects; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/all.rb#23
+  def failure_message; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/all.rb#9
+  def matcher; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/all.rb#63
+  def add_new_line_if_needed(message); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/all.rb#58
+  def failure_message_for_item(index, failure_message); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/all.rb#67
+  def indent_multiline_message(message); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/all.rb#50
+  def index_failed_objects; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/all.rb#74
+  def initialize_copy(other); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/all.rb#80
+  def iterable?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/all.rb#43
+  def match(_expected, _actual); end
+end
+
+# Used _internally_ as a base class for matchers that ship with
+# rspec-expectations and rspec-rails.
+#
+# ### Warning:
+#
+# This class is for internal use, and subject to change without notice.
+# We strongly recommend that you do not base your custom matchers on this
+# class. If/when this changes, we will announce it and remove this warning.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#14
+class RSpec::Matchers::BuiltIn::BaseMatcher
+  include ::RSpec::Matchers::Composable
+  include ::RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
+  include ::RSpec::Matchers::BuiltIn::BaseMatcher::StringEncodingFormatting
+  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
+
+  # @api private
+  # @return [BaseMatcher] a new instance of BaseMatcher
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#28
+  def initialize(expected = T.unsafe(nil)); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#23
+  def actual; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#97
+  def actual_formatted; end
+
+  # Generates a description using {EnglishPhrasing}.
+  #
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#60
+  def description; end
+
+  # Matchers are not diffable by default. Override this to make your
+  # subclass diffable.
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#69
+  def diffable?; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#23
+  def expected; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#92
+  def expected_formatted; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#87
+  def expects_call_stack_jump?; end
+
+  # Used to wrap a block of code that will indicate failure by
+  # raising one of the named exceptions.
+  #
+  # This is used by rspec-rails for some of its matchers that
+  # wrap rails' assertions.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#47
+  def match_unless_raises(*exceptions); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#107
+  def matcher_name; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#26
+  def matcher_name=(_arg0); end
+
+  # Indicates if the match is successful. Delegates to `match`, which
+  # should be defined on a subclass. Takes care of consistently
+  # initializing the `actual` attribute.
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#36
+  def matches?(actual); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#23
+  def rescued_exception; end
+
+  # Most matchers are value matchers (i.e. meant to work with `expect(value)`)
+  # rather than block matchers (i.e. meant to work with `expect { }`), so
+  # this defaults to false. Block matchers must override this to return true.
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#77
+  def supports_block_expectations?; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#82
+  def supports_value_expectations?; end
+
+  class << self
+    # @api private
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#102
+    def matcher_name; end
+
+    private
+
+    # Borrowed from ActiveSupport.
+    #
+    # @api private
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#117
+    def underscore(camel_cased_word); end
+  end
+end
+
+# Provides default implementations of failure messages, based on the `description`.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#193
+module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
+  # Provides a good generic failure message. Based on `description`.
+  # When subclassing, if you are not satisfied with this failure message
+  # you often only need to override `description`.
+  #
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#199
+  def failure_message; end
+
+  # Provides a good generic negative failure message. Based on `description`.
+  # When subclassing, if you are not satisfied with this failure message
+  # you often only need to override `description`.
+  #
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#208
+  def failure_message_when_negated; end
+
+  class << self
+    # @api private
+    # @private
+    # @return [Boolean]
+    #
+    # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#213
+    def has_default_failure_messages?(matcher); end
+  end
+end
+
+# @api private
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#128
+module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
+  private
+
+  # `{ :a => 5, :b => 2 }.inspect` produces:
+  #
+  #     {:a=>5, :b=>2}
+  #
+  # ...but it looks much better as:
+  #
+  #     {:a => 5, :b => 2}
+  #
+  # This is idempotent and safe to run on a string multiple times.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#138
+  def improve_hash_formatting(inspect_string); end
+
+  class << self
+    # `{ :a => 5, :b => 2 }.inspect` produces:
+    #
+    #     {:a=>5, :b=>2}
+    #
+    # ...but it looks much better as:
+    #
+    #     {:a => 5, :b => 2}
+    #
+    # This is idempotent and safe to run on a string multiple times.
+    #
+    # @api private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#138
+    def improve_hash_formatting(inspect_string); end
+  end
+end
+
+# @api private
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#147
+module RSpec::Matchers::BuiltIn::BaseMatcher::StringEncodingFormatting
+  private
+
+  # Formats a String's encoding as a human readable string
+  # :nocov:
+  #
+  # @api private
+  # @param _value [String]
+  # @return [nil] nil as the curent Ruby version does not support String encoding
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#172
+  def format_encoding(value); end
+
+  # :nocov:
+  #
+  # @api private
+  # @return [Boolean] False always as the curent Ruby version does not support String encoding
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#153
+  def string_encoding_differs?; end
+
+  class << self
+    # Formats a String's encoding as a human readable string
+    # :nocov:
+    #
+    # @api private
+    # @param _value [String]
+    # @return [nil] nil as the curent Ruby version does not support String encoding
+    #
+    # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#172
+    def format_encoding(value); end
+
+    # :nocov:
+    #
+    # @api private
+    # @return [Boolean] False always as the curent Ruby version does not support String encoding
+    #
+    # source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#153
+    def string_encoding_differs?; end
+  end
+end
+
+# Used to detect when no arg is passed to `initialize`.
+# `nil` cannot be used because it's a valid value to pass.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/base_matcher.rb#20
+RSpec::Matchers::BuiltIn::BaseMatcher::UNDEFINED = T.let(T.unsafe(nil), Object)
+
+# Provides the implementation for `be`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#101
+class RSpec::Matchers::BuiltIn::Be < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  include ::RSpec::Matchers::BuiltIn::BeHelpers
+
+  # @api private
+  # @return [Be] a new instance of Be
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#104
+  def initialize(*args); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#121
+  def <(operand); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#121
+  def <=(operand); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#121
+  def ==(operand); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#121
+  def ===(operand); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#121
+  def =~(operand); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#121
+  def >(operand); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#121
+  def >=(operand); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#110
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#116
+  def failure_message_when_negated; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#128
+  def match(_, actual); end
+end
+
+# Provides the implementation for `be_a_kind_of`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/be_kind_of.rb#7
+class RSpec::Matchers::BuiltIn::BeAKindOf < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_kind_of.rb#10
+  def match(expected, actual); end
+end
+
+# Provides the implementation for `be_an_instance_of`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/be_instance_of.rb#7
+class RSpec::Matchers::BuiltIn::BeAnInstanceOf < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_instance_of.rb#10
+  def description; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_instance_of.rb#16
+  def match(expected, actual); end
+end
+
+# Provides the implementation for `be_between`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/be_between.rb#7
+class RSpec::Matchers::BuiltIn::BeBetween < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [BeBetween] a new instance of BeBetween
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_between.rb#8
+  def initialize(min, max); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_between.rb#57
+  def description; end
+
+  # Makes the between comparison exclusive.
+  #
+  # @api public
+  # @example
+  #   expect(3).to be_between(2, 4).exclusive
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_between.rb#33
+  def exclusive; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_between.rb#51
+  def failure_message; end
+
+  # Makes the between comparison inclusive.
+  #
+  # @api public
+  # @example
+  #   expect(3).to be_between(2, 3).inclusive
+  # @note The matcher is inclusive by default; this simply provides
+  #   a way to be more explicit about it.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_between.rb#21
+  def inclusive; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_between.rb#42
+  def matches?(actual); end
+
+  private
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_between.rb#63
+  def comparable?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_between.rb#71
+  def compare; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_between.rb#67
+  def not_comparable_clause; end
+end
+
+# Provides the implementation of `be <operator> value`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#136
+class RSpec::Matchers::BuiltIn::BeComparedTo < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  include ::RSpec::Matchers::BuiltIn::BeHelpers
+
+  # @api private
+  # @return [BeComparedTo] a new instance of BeComparedTo
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#139
+  def initialize(operand, operator); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#178
+  def description; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#151
+  def does_not_match?(actual); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#159
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#166
+  def failure_message_when_negated; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#145
+  def matches?(actual); end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#184
+  def perform_match(actual); end
+end
+
+# Provides the implementation for `be_falsey`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#30
+class RSpec::Matchers::BuiltIn::BeFalsey < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#33
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#39
+  def failure_message_when_negated; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#45
+  def match(_, actual); end
+end
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#74
+module RSpec::Matchers::BuiltIn::BeHelpers
+  private
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#77
+  def args_to_s; end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#93
+  def args_to_sentence; end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#89
+  def expected_to_sentence; end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#85
+  def inspected_args; end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#81
+  def parenthesize(string); end
+end
+
+# Provides the implementation for `be_nil`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#53
+class RSpec::Matchers::BuiltIn::BeNil < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#56
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#62
+  def failure_message_when_negated; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#68
+  def match(_, actual); end
+end
+
+# Provides the implementation of `be_<predicate>`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#164
+class RSpec::Matchers::BuiltIn::BePredicate < ::RSpec::Matchers::BuiltIn::DynamicPredicate
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#176
+  def failure_to_respond_explanation; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#168
+  def predicate; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#184
+  def predicate_accessible?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#172
+  def predicate_method_name; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#188
+  def present_tense_predicate; end
+end
+
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#166
+RSpec::Matchers::BuiltIn::BePredicate::REGEX = T.let(T.unsafe(nil), Regexp)
+
+# Provides the implementation for `be_truthy`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#7
+class RSpec::Matchers::BuiltIn::BeTruthy < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#10
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#16
+  def failure_message_when_negated; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be.rb#22
+  def match(_, actual); end
+end
+
+# Provides the implementation for `be_within`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/be_within.rb#7
+class RSpec::Matchers::BuiltIn::BeWithin < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [BeWithin] a new instance of BeWithin
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_within.rb#8
+  def initialize(delta); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_within.rb#52
+  def description; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_within.rb#40
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_within.rb#46
+  def failure_message_when_negated; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_within.rb#32
+  def matches?(actual); end
+
+  # Sets the expected value.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_within.rb#14
+  def of(expected); end
+
+  # Sets the expected value, and makes the matcher do
+  # a percent comparison.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_within.rb#24
+  def percent_of(expected); end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_within.rb#62
+  def needs_expected; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_within.rb#66
+  def not_numeric_clause; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/be_within.rb#58
+  def numeric?; end
+end
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#159
+module RSpec::Matchers::BuiltIn::CaptureStderr
+  class << self
+    # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#164
+    def capture(block); end
+
+    # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#160
+    def name; end
+  end
+end
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#139
+module RSpec::Matchers::BuiltIn::CaptureStdout
+  class << self
+    # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#144
+    def capture(block); end
+
+    # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#140
+    def name; end
+  end
+end
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#179
+class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < ::Struct
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#180
+  def capture(block); end
+end
+
+# Provides the implementation for `change`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#7
+class RSpec::Matchers::BuiltIn::Change < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [Change] a new instance of Change
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#87
+  def initialize(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  # Specifies the delta of the expected change.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#10
+  def by(expected_delta); end
+
+  # Specifies a minimum delta of the expected change.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#18
+  def by_at_least(minimum); end
+
+  # Specifies a maximum delta of the expected change.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#26
+  def by_at_most(maximum); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#71
+  def description; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#50
+  def does_not_match?(event_proc); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#57
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#64
+  def failure_message_when_negated; end
+
+  # Specifies the original value.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#40
+  def from(value); end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#45
+  def matches?(event_proc); end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#76
+  def supports_block_expectations?; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#81
+  def supports_value_expectations?; end
+
+  # Specifies the new value you expect.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#34
+  def to(value); end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#93
+  def change_details; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#119
+  def negative_failure_reason; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#97
+  def perform_change(event_proc); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#114
+  def positive_failure_reason; end
+
+  # @api private
+  # @raise [SyntaxError]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#109
+  def raise_block_syntax_error; end
+end
+
+# Encapsulates the details of the before/after values.
+#
+# Note that this class exposes the `actual_after` value, to allow the
+# matchers above to derive failure messages, etc from the value on demand
+# as needed, but it intentionally does _not_ expose the `actual_before`
+# value. Some usages of the `change` matcher mutate a specific object
+# returned by the value proc, which means that failure message snippets,
+# etc, which are derived from the `before` value may not be accurate if
+# they are lazily computed as needed. We must pre-compute them before
+# applying the change in the `expect` block. To ensure that all `change`
+# matchers do that properly, we do not expose the `actual_before` value.
+# Instead, matchers must pass a block to `perform_change`, which yields
+# the `actual_before` value before applying the change.
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#352
+class RSpec::Matchers::BuiltIn::ChangeDetails
+  # @return [ChangeDetails] a new instance of ChangeDetails
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#357
+  def initialize(matcher_name, receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  # Returns the value of attribute actual_after.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#353
+  def actual_after; end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#418
+  def actual_delta; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#402
+  def changed?; end
+
+  # @yield [@actual_before]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#389
+  def perform_change(event_proc); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#378
+  def value_representation; end
+
+  private
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#424
+  def evaluate_value_proc; end
+
+  # :nocov:
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#438
+  def extract_value_block_snippet; end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#428
+  def message_notation(receiver, message); end
+end
+
+# source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#355
+module RSpec::Matchers::BuiltIn::ChangeDetails::UNDEFINED; end
+
+# Used to specify a change from a specific value
+# (and, optionally, to a specific value).
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#270
+class RSpec::Matchers::BuiltIn::ChangeFromValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange
+  # @api private
+  # @return [ChangeFromValue] a new instance of ChangeFromValue
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#271
+  def initialize(change_details, expected_before); end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#285
+  def does_not_match?(event_proc); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#295
+  def failure_message_when_negated; end
+
+  # Specifies the new value you expect.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#278
+  def to(value); end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#303
+  def change_description; end
+end
+
+# Used to specify a relative change.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#128
+class RSpec::Matchers::BuiltIn::ChangeRelatively < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [ChangeRelatively] a new instance of ChangeRelatively
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#129
+  def initialize(change_details, expected_delta, relativity, &comparer); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#156
+  def description; end
+
+  # @api private
+  # @private
+  # @raise [NotImplementedError]
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#150
+  def does_not_match?(_event_proc); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#137
+  def failure_message; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#144
+  def matches?(event_proc); end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#162
+  def supports_block_expectations?; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#167
+  def supports_value_expectations?; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#173
+  def failure_reason; end
+end
+
+# Used to specify a change to a specific value
+# (and, optionally, from a specific value).
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#311
+class RSpec::Matchers::BuiltIn::ChangeToValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange
+  # @api private
+  # @return [ChangeToValue] a new instance of ChangeToValue
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#312
+  def initialize(change_details, expected_after); end
+
+  # @api private
+  # @private
+  # @raise [NotImplementedError]
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#326
+  def does_not_match?(_event_proc); end
+
+  # Specifies the original value.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#319
+  def from(value); end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#333
+  def change_description; end
+end
+
+# Base class for `and` and `or` compound matchers.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#6
+class RSpec::Matchers::BuiltIn::Compound < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [Compound] a new instance of Compound
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#10
+  def initialize(matcher_1, matcher_2); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#25
+  def description; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#49
+  def diffable?; end
+
+  # @api private
+  # @private
+  # @raise [NotImplementedError]
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#16
+  def does_not_match?(_actual); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#8
+  def evaluator; end
+
+  # @api private
+  # @return [RSpec::Matchers::MultiMatcherDiff]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#55
+  def expected; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#42
+  def expects_call_stack_jump?; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#8
+  def matcher_1; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#8
+  def matcher_2; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#30
+  def supports_block_expectations?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#36
+  def supports_value_expectations?; end
+
+  protected
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#62
+  def diffable_matcher_list; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#96
+  def compound_failure_message; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#128
+  def diffable_matcher_list_for(matcher); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#90
+  def indent_multiline_message(message); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#71
+  def initialize_copy(other); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#77
+  def match(_expected, actual); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#102
+  def matcher_1_matches?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#106
+  def matcher_2_matches?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#122
+  def matcher_is_diffable?(matcher); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#110
+  def matcher_supports_block_expectations?(matcher); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#116
+  def matcher_supports_value_expectations?(matcher); end
+end
+
+# Matcher used to represent a compound `and` expectation.
+#
+# @api public
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#245
+class RSpec::Matchers::BuiltIn::Compound::And < ::RSpec::Matchers::BuiltIn::Compound
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#248
+  def failure_message; end
+
+  private
+
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#265
+  def conjunction; end
+
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#260
+  def match(*_arg0); end
+end
+
+# Normally, we evaluate the matching sequentially. For an expression like
+# `expect(x).to foo.and bar`, this becomes:
+#
+#   expect(x).to foo
+#   expect(x).to bar
+#
+# For block expectations, we need to nest them instead, so that
+# `expect { x }.to foo.and bar` becomes:
+#
+#   expect {
+#     expect { x }.to foo
+#   }.to bar
+#
+# This is necessary so that the `expect` block is only executed once.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#159
+class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
+  # @api private
+  # @return [NestedEvaluator] a new instance of NestedEvaluator
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#160
+  def initialize(actual, matcher_1, matcher_2); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#173
+  def matcher_matches?(matcher); end
+
+  private
+
+  # Some block matchers (such as `yield_xyz`) pass args to the `expect` block.
+  # When such a matcher is used as the outer matcher, we need to forward the
+  # the args on to the `expect` block.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#187
+  def inner_matcher_block(outer_args); end
+
+  # For a matcher like `raise_error` or `throw_symbol`, where the block will jump
+  # up the call stack, we need to order things so that it is the inner matcher.
+  # For example, we need it to be this:
+  #
+  #   expect {
+  #     expect {
+  #       x += 1
+  #       raise "boom"
+  #     }.to raise_error("boom")
+  #   }.to change { x }.by(1)
+  #
+  # ...rather than:
+  #
+  #   expect {
+  #     expect {
+  #       x += 1
+  #       raise "boom"
+  #     }.to change { x }.by(1)
+  #   }.to raise_error("boom")
+  #
+  # In the latter case, the after-block logic in the `change` matcher would never
+  # get executed because the `raise "boom"` line would jump to the `rescue` in the
+  # `raise_error` logic, so only the former case will work properly.
+  #
+  # This method figures out which matcher should be the inner matcher and which
+  # should be the outer matcher.
+  #
+  # @api private
+  # @raise [ArgumentError]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#227
+  def order_block_matchers; end
+
+  class << self
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#236
+    def matcher_expects_call_stack_jump?(matcher); end
+  end
+end
+
+# Matcher used to represent a compound `or` expectation.
+#
+# @api public
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#272
+class RSpec::Matchers::BuiltIn::Compound::Or < ::RSpec::Matchers::BuiltIn::Compound
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#275
+  def failure_message; end
+
+  private
+
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#286
+  def conjunction; end
+
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#281
+  def match(*_arg0); end
+end
+
+# For value expectations, we can evaluate the matchers sequentially.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#135
+class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator
+  # @api private
+  # @return [SequentialEvaluator] a new instance of SequentialEvaluator
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#136
+  def initialize(actual, *_arg1); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/compound.rb#140
+  def matcher_matches?(matcher); end
+end
+
+# Provides the implementation for `contain_exactly` and `match_array`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#8
+class RSpec::Matchers::BuiltIn::ContainExactly < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#29
+  def description; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#11
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#22
+  def failure_message_when_negated; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#34
+  def matches?(actual); end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#56
+  def actual_collection_line; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#137
+  def best_solution; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#94
+  def convert_actual_to_an_array; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#68
+  def describe_collection(collection, surface_descriptions = T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#52
+  def expected_collection_line; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#64
+  def extra_elements_line; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#131
+  def extra_items; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#44
+  def generate_failure_message; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#81
+  def match(_expected, _actual); end
+
+  # This cannot always work (e.g. when dealing with unsortable items,
+  # or matchers as expected items), but it's practically free compared to
+  # the slowness of the full matching algorithm, and in common cases this
+  # works, so it's worth a try.
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#90
+  def match_when_sorted?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#76
+  def message_line(prefix, collection, surface_descriptions = T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#60
+  def missing_elements_line; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#125
+  def missing_items; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#141
+  def pairings_maximizer; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#104
+  def safe_sort(array); end
+
+  # :nocov:
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#120
+  def to_a_disallowed?(object); end
+end
+
+# Once we started supporting composing matchers, the algorithm for this matcher got
+# much more complicated. Consider this expression:
+#
+#   expect(["fool", "food"]).to contain_exactly(/foo/, /fool/)
+#
+# This should pass (because we can pair /fool/ with "fool" and /foo/ with "food"), but
+# the original algorithm used by this matcher would pair the first elements it could
+# (/foo/ with "fool"), which would leave /fool/ and "food" unmatched.  When we have
+# an expected element which is a matcher that matches a superset of actual items
+# compared to another expected element matcher, we need to consider every possible pairing.
+#
+# This class is designed to maximize the number of actual/expected pairings -- or,
+# conversely, to minimize the number of unpaired items. It's essentially a brute
+# force solution, but with a few heuristics applied to reduce the size of the
+# problem space:
+#
+#   * Any items which match none of the items in the other list are immediately
+#     placed into the `unmatched_expected_indexes` or `unmatched_actual_indexes` array.
+#     The extra items and missing items in the matcher failure message are derived
+#     from these arrays.
+#   * Any items which reciprocally match only each other are paired up and not
+#     considered further.
+#
+# What's left is only the items which match multiple items from the other list
+# (or vice versa). From here, it performs a brute-force depth-first search,
+# looking for a solution which pairs all elements in both lists, or, barring that,
+# that produces the fewest unmatched items.
+#
+# @api private
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#188
+class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
+  # @api private
+  # @return [PairingsMaximizer] a new instance of PairingsMaximizer
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#225
+  def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#223
+  def actual_to_expected_matched_indexes; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#223
+  def expected_to_actual_matched_indexes; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#239
+  def find_best_solution; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#223
+  def solution; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#301
+  def apply_pairing_to(indeterminates, original_matches, other_list_index); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#285
+  def best_solution_for_pairing(expected_index, actual_index); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#265
+  def categorize_indexes(indexes_to_categorize, other_indexes); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#280
+  def reciprocal_single_match?(matches, index, other_list); end
+end
+
+# Starting solution that is worse than any other real solution.
+#
+# @api private
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#259
+class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
+  class << self
+    # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#260
+    def worse_than?(_other); end
+  end
+end
+
+# @api private
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#190
+class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < ::Struct
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#212
+  def +(derived_candidate_solution); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#196
+  def candidate?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#201
+  def ideal?; end
+
+  # Returns the value of attribute indeterminate_actual_indexes
+  #
+  # @return [Object] the current value of indeterminate_actual_indexes
+  def indeterminate_actual_indexes; end
+
+  # Sets the attribute indeterminate_actual_indexes
+  #
+  # @param value [Object] the value to set the attribute indeterminate_actual_indexes to.
+  # @return [Object] the newly set value
+  def indeterminate_actual_indexes=(_); end
+
+  # Returns the value of attribute indeterminate_expected_indexes
+  #
+  # @return [Object] the current value of indeterminate_expected_indexes
+  def indeterminate_expected_indexes; end
+
+  # Sets the attribute indeterminate_expected_indexes
+  #
+  # @param value [Object] the value to set the attribute indeterminate_expected_indexes to.
+  # @return [Object] the newly set value
+  def indeterminate_expected_indexes=(_); end
+
+  # Returns the value of attribute unmatched_actual_indexes
+  #
+  # @return [Object] the current value of unmatched_actual_indexes
+  def unmatched_actual_indexes; end
+
+  # Sets the attribute unmatched_actual_indexes
+  #
+  # @param value [Object] the value to set the attribute unmatched_actual_indexes to.
+  # @return [Object] the newly set value
+  def unmatched_actual_indexes=(_); end
+
+  # Returns the value of attribute unmatched_expected_indexes
+  #
+  # @return [Object] the current value of unmatched_expected_indexes
+  def unmatched_expected_indexes; end
+
+  # Sets the attribute unmatched_expected_indexes
+  #
+  # @param value [Object] the value to set the attribute unmatched_expected_indexes to.
+  # @return [Object] the newly set value
+  def unmatched_expected_indexes=(_); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#208
+  def unmatched_item_count; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/contain_exactly.rb#192
+  def worse_than?(other); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# Abstract class to implement `once`, `at_least` and other
+# count constraints.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#7
+module RSpec::Matchers::BuiltIn::CountExpectation
+  # Specifies the minimum number of times the method is expected to match
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#42
+  def at_least(number); end
+
+  # Specifies the maximum number of times the method is expected to match
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#35
+  def at_most(number); end
+
+  # Specifies that the method is expected to match the given number of times.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#28
+  def exactly(number); end
+
+  # Specifies that the method is expected to match once.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#10
+  def once; end
+
+  # Specifies that the method is expected to match thrice.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#22
+  def thrice; end
+
+  # No-op. Provides syntactic sugar.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#49
+  def times; end
+
+  # Specifies that the method is expected to match twice.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#16
+  def twice; end
+
+  protected
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#55
+  def count_expectation_type; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#55
+  def expected_count; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#122
+  def count_constraint_to_number(n); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#141
+  def count_expectation_description; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#145
+  def count_failure_reason(action); end
+
+  # :nocov:
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#60
+  def cover?(count, number); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#71
+  def expected_count_matches?(actual_count); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#79
+  def has_expected_count?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#159
+  def human_readable_count(count); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#150
+  def human_readable_expectation_type; end
+
+  # @api private
+  # @raise [ArgumentError]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#102
+  def raise_impossible_count_expectation(count); end
+
+  # @api private
+  # @raise [ArgumentError]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#111
+  def raise_unsupported_count_expectation; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#83
+  def set_expected_count(relativity, n); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/count_expectation.rb#134
+  def unsupported_count_expectation?(relativity); end
+end
+
+# Provides the implementation for `cover`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/cover.rb#7
+class RSpec::Matchers::BuiltIn::Cover < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [Cover] a new instance of Cover
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/cover.rb#8
+  def initialize(*expected); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/cover.rb#17
+  def does_not_match?(range); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/cover.rb#12
+  def matches?(range); end
+end
+
+# Provides the implementation for dynamic predicate matchers.
+# Not intended to be inherited directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#7
+class RSpec::Matchers::BuiltIn::DynamicPredicate < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  include ::RSpec::Matchers::BuiltIn::BeHelpers
+
+  # @api private
+  # @return [DynamicPredicate] a new instance of DynamicPredicate
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#10
+  def initialize(method_name, *args, **_arg2, &block); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#43
+  def description; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#23
+  def does_not_match?(actual, &block); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#31
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#37
+  def failure_message_when_negated; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#16
+  def matches?(actual, &block); end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#126
+  def expectation_of(value); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#121
+  def failure_message_expecting(value); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#142
+  def failure_to_respond_explanation; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#117
+  def method_description; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#88
+  def methods_include?(method); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#68
+  def predicate_accessible?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#101
+  def predicate_matches?(value = T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#97
+  def predicate_method_name; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#93
+  def predicate_result; end
+
+  # :nocov:
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#84
+  def private_predicate?; end
+
+  # :nocov:
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#53
+  def really_responds_to?(method); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#109
+  def root; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#136
+  def validity_message; end
+end
+
+# Provides the implementation for `end_with`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/start_or_end_with.rb#81
+class RSpec::Matchers::BuiltIn::EndWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith
+  private
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/start_or_end_with.rb#88
+  def element_matches?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/start_or_end_with.rb#84
+  def subset_matches?; end
+end
+
+# Provides the implementation for `eq`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/eq.rb#7
+class RSpec::Matchers::BuiltIn::Eq < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/eq.rb#26
+  def description; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/eq.rb#32
+  def diffable?; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/eq.rb#10
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/eq.rb#20
+  def failure_message_when_negated; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/eq.rb#38
+  def match(expected, actual); end
+end
+
+# Provides the implementation for `eql`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/eql.rb#7
+class RSpec::Matchers::BuiltIn::Eql < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/eql.rb#26
+  def diffable?; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/eql.rb#10
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/eql.rb#20
+  def failure_message_when_negated; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/eql.rb#32
+  def match(expected, actual); end
+end
+
+# Provides the implementation for `equal`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/equal.rb#7
+class RSpec::Matchers::BuiltIn::Equal < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/equal.rb#33
+  def diffable?; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/equal.rb#10
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/equal.rb#20
+  def failure_message_when_negated; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/equal.rb#49
+  def actual_inspected; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/equal.rb#61
+  def detailed_failure_message; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/equal.rb#45
+  def expected_is_a_literal_singleton?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/equal.rb#75
+  def inspect_object(o); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/equal.rb#39
+  def match(expected, actual); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/equal.rb#57
+  def simple_failure_message; end
+end
+
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/equal.rb#43
+RSpec::Matchers::BuiltIn::Equal::LITERAL_SINGLETONS = T.let(T.unsafe(nil), Array)
+
+# Provides the implementation for `exist`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/exist.rb#7
+class RSpec::Matchers::BuiltIn::Exist < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [Exist] a new instance of Exist
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/exist.rb#8
+  def initialize(*expected); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/exist.rb#22
+  def does_not_match?(actual); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/exist.rb#30
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/exist.rb#36
+  def failure_message_when_negated; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/exist.rb#14
+  def matches?(actual); end
+end
+
+# Simple class for memoizing actual/expected for this matcher
+# and examining the match
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/exist.rb#43
+class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < ::Struct
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/exist.rb#52
+  def actual_exists?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/exist.rb#46
+  def valid_test?; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/exist.rb#58
+  def validity_message; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/exist.rb#83
+  def deprecated(predicate, actual); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/exist.rb#75
+  def existence_values; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/exist.rb#79
+  def predicates; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/exist.rb#71
+  def uniq_truthy_values; end
+end
+
+# Provides the implementation for `has_<predicate>`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#152
+class RSpec::Matchers::BuiltIn::Has < ::RSpec::Matchers::BuiltIn::DynamicPredicate
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#156
+  def predicate; end
+end
+
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/has.rb#154
+RSpec::Matchers::BuiltIn::Has::REGEX = T.let(T.unsafe(nil), Regexp)
+
+# Provides the implementation for `have_attributes`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#7
+class RSpec::Matchers::BuiltIn::HaveAttributes < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [HaveAttributes] a new instance of HaveAttributes
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#11
+  def initialize(expected); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#19
+  def actual; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#43
+  def description; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#50
+  def diffable?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#34
+  def does_not_match?(actual); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#56
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#64
+  def failure_message_when_negated; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#25
+  def matches?(actual); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#9
+  def respond_to_failed; end
+
+  private
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#85
+  def actual_has_attribute?(attribute_key, attribute_value); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#70
+  def cache_all_values; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#107
+  def formatted_values; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#78
+  def perform_match(predicate); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#89
+  def respond_to_attributes?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#99
+  def respond_to_failure_message_or; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/have_attributes.rb#95
+  def respond_to_matcher; end
+end
+
+# Provides the implementation for `include`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#9
+class RSpec::Matchers::BuiltIn::Include < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  include ::RSpec::Matchers::BuiltIn::CountExpectation
+
+  # @api private
+  # @raise [ArgumentError]
+  # @return [Include] a new instance of Include
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#15
+  def initialize(*expecteds); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#44
+  def description; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#62
+  def diffable?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#33
+  def does_not_match?(actual); end
+
+  # @api private
+  # @return [Array, Hash]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#68
+  def expected; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#12
+  def expecteds; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#50
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#56
+  def failure_message_when_negated; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#22
+  def matches?(actual); end
+
+  private
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#168
+  def actual_collection_includes?(expected_item); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#154
+  def actual_hash_has_key?(expected_key); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#142
+  def actual_hash_includes?(expected_key, expected_value); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#78
+  def check_actual?(actual); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#84
+  def check_expected_count?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#150
+  def comparing_hash_keys?(expected_item); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#138
+  def comparing_hash_to_a_subset?(expected_item); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#212
+  def convert_to_hash?(obj); end
+
+  # :nocov:
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#185
+  def count_enumerable(expected_item); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#190
+  def count_inclusions; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#202
+  def diff_would_wrongly_highlight_matched_item?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#121
+  def excluded_from_actual; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#96
+  def format_failure_message(preposition); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#116
+  def perform_match(&block); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/include.rb#107
+  def readable_list_of(items); end
+end
+
+# Provides the implementation for `match`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/match.rb#7
+class RSpec::Matchers::BuiltIn::Match < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [Match] a new instance of Match
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/match.rb#8
+  def initialize(expected); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/match.rb#15
+  def description; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/match.rb#25
+  def diffable?; end
+
+  # Used to specify the captures we match against
+  #
+  # @api private
+  # @return [self]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/match.rb#31
+  def with_captures(*captures); end
+
+  private
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/match.rb#45
+  def can_safely_call_match?(expected, actual); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/match.rb#38
+  def match(expected, actual); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/match.rb#52
+  def match_captures(expected, actual); end
+end
+
+# Handles operator matcher for `should_not`.
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#116
+class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#117
+  def __delegate_operator(actual, operator, expected); end
+end
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#128
+module RSpec::Matchers::BuiltIn::NullCapture
+  class << self
+    # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#133
+    def capture(_block); end
+
+    # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#129
+    def name; end
+  end
+end
+
+# Provides the implementation for operator matchers.
+# Not intended to be instantiated directly.
+# Only available for use with `should`.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#10
+class RSpec::Matchers::BuiltIn::OperatorMatcher
+  # @api private
+  # @return [OperatorMatcher] a new instance of OperatorMatcher
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#41
+  def initialize(actual); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#57
+  def !=(_expected); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#57
+  def !~(_expected); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#47
+  def <(expected); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#47
+  def <=(expected); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#47
+  def ==(expected); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#47
+  def ===(expected); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#47
+  def =~(expected); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#47
+  def >(expected); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#47
+  def >=(expected); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#76
+  def description; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#70
+  def fail_with_message(message); end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#88
+  def eval_match(actual, operator, expected); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#82
+  def has_non_generic_implementation_of?(op); end
+
+  class << self
+    # @api private
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#29
+    def get(klass, operator); end
+
+    # @api private
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#18
+    def register(klass, operator, matcher); end
+
+    # @api private
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#13
+    def registry; end
+
+    # @api private
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#24
+    def unregister(klass, operator); end
+
+    # @api private
+    # @private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#46
+    def use_custom_matcher_or_delegate(operator); end
+  end
+end
+
+# Provides the implementation for `output`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#9
+class RSpec::Matchers::BuiltIn::Output < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [Output] a new instance of Output
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#10
+  def initialize(expected); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#76
+  def description; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#86
+  def diffable?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#24
+  def does_not_match?(block); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#64
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#70
+  def failure_message_when_negated; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#17
+  def matches?(block); end
+
+  # Indicates this matcher matches against a block.
+  #
+  # @api private
+  # @return [True]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#93
+  def supports_block_expectations?; end
+
+  # Indicates this matcher matches against a block only.
+  #
+  # @api private
+  # @return [False]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#100
+  def supports_value_expectations?; end
+
+  # Tells the matcher to match against stderr.
+  # Works only when the main Ruby process prints to stderr
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#39
+  def to_stderr; end
+
+  # Tells the matcher to match against stderr.
+  # Works when subprocesses print to stderr as well.
+  # This is significantly (~30x) slower than `to_stderr`
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#57
+  def to_stderr_from_any_process; end
+
+  # Tells the matcher to match against stdout.
+  # Works only when the main Ruby process prints to stdout
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#31
+  def to_stdout; end
+
+  # Tells the matcher to match against stdout.
+  # Works when subprocesses print to stdout as well.
+  # This is significantly (~30x) slower than `to_stdout`
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#48
+  def to_stdout_from_any_process; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#121
+  def actual_output_description; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#106
+  def captured?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#116
+  def negative_failure_reason; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/output.rb#110
+  def positive_failure_reason; end
+end
+
+# Handles operator matcher for `should`.
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#97
+class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher
+  # source://rspec-expectations//lib/rspec/matchers/built_in/operators.rb#98
+  def __delegate_operator(actual, operator, expected); end
+end
+
+# Provides the implementation for `raise_error`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#9
+class RSpec::Matchers::BuiltIn::RaiseError
+  include ::RSpec::Matchers::Composable
+
+  # @api private
+  # @return [RaiseError] a new instance of RaiseError
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#22
+  def initialize(expected_error_or_message, expected_message, &block); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#117
+  def description; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#83
+  def does_not_match?(given_proc); end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#99
+  def expects_call_stack_jump?; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#105
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#111
+  def failure_message_when_negated; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#52
+  def matches?(given_proc, negative_expectation = T.unsafe(nil), &block); end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#89
+  def supports_block_expectations?; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#94
+  def supports_value_expectations?; end
+
+  # Specifies the expected error message.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#43
+  def with_message(expected_message); end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#123
+  def actual_error_message; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#137
+  def block_matches?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#133
+  def error_and_message_match?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#145
+  def eval_block; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#129
+  def expectation_matched?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#226
+  def expected_error; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#257
+  def expecting_specific_exception?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#241
+  def format_backtrace(backtrace); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#246
+  def given_error; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#176
+  def handle_warning(message); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#261
+  def raise_message_already_set; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#141
+  def ready_to_eval_block?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#155
+  def verify_message; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#188
+  def warn_about_bare_error!; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#180
+  def warn_about_bare_error?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#214
+  def warn_about_negative_false_positive!(expression); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#201
+  def warn_about_nil_error!; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#184
+  def warn_about_nil_error?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#160
+  def warn_for_negative_false_positives!; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#266
+  def warning; end
+end
+
+# Used as a sentinel value to be able to tell when the user did not pass an
+# argument. We can't use `nil` for that because we need to warn when `nil` is
+# passed in a different way. It's an Object, not a Module, since Module's `===`
+# does not evaluate to true when compared to itself.
+#
+# Note; this _is_ the default value supplied for expected_error_or_message, but
+# because there are two method-calls involved, that default is actually supplied
+# in the definition of the _matcher_ method, `RSpec::Matchers#raise_error`
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/raise_error.rb#20
+RSpec::Matchers::BuiltIn::RaiseError::UndefinedValue = T.let(T.unsafe(nil), Object)
+
+# Used to wrap match data and make it reliable for 1.8.7
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/match.rb#72
+class RSpec::Matchers::BuiltIn::ReliableMatchData
+  # @api private
+  # @return [ReliableMatchData] a new instance of ReliableMatchData
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/match.rb#73
+  def initialize(match_data); end
+
+  # returns an array of captures from the match data
+  #
+  # @api private
+  # @return Array
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/match.rb#98
+  def captures; end
+
+  # Returns match data names for named captures
+  #
+  # @api private
+  # @return Array
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/match.rb#90
+  def names; end
+
+  protected
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/match.rb#104
+  def match_data; end
+end
+
+# Provides the implementation for `respond_to`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#9
+class RSpec::Matchers::BuiltIn::RespondTo < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [RespondTo] a new instance of RespondTo
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#10
+  def initialize(*names); end
+
+  # Specifies that the method accepts any keyword, i.e. the method has
+  #   a splatted keyword parameter of the form **kw_args.
+  #
+  # @api public
+  # @example
+  #   expect(obj).to respond_to(:message).with_any_keywords
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#48
+  def and_any_keywords; end
+
+  # Specifies keyword arguments, if any.
+  #
+  # @api public
+  # @example
+  #   expect(obj).to respond_to(:message).with_keywords(:color, :shape)
+  # @example with an expected number of arguments
+  #   expect(obj).to respond_to(:message).with(3).arguments.and_keywords(:color, :shape)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#36
+  def and_keywords(*keywords); end
+
+  # Specifies that the number of arguments has no upper limit, i.e. the
+  #   method has a splatted parameter of the form *args.
+  #
+  # @api public
+  # @example
+  #   expect(obj).to respond_to(:message).with_unlimited_arguments
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#60
+  def and_unlimited_arguments; end
+
+  # No-op. Intended to be used as syntactic sugar when using `with`.
+  #
+  # @api public
+  # @example
+  #   expect(obj).to respond_to(:message).with(3).arguments
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#71
+  def argument; end
+
+  # No-op. Intended to be used as syntactic sugar when using `with`.
+  #
+  # @api public
+  # @example
+  #   expect(obj).to respond_to(:message).with(3).arguments
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#71
+  def arguments; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#100
+  def description; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#82
+  def does_not_match?(actual); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#88
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#94
+  def failure_message_when_negated; end
+
+  # Used by other matchers to suppress a check
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#106
+  def ignoring_method_signature_failure!; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#77
+  def matches?(actual); end
+
+  # Specifies the number of expected arguments.
+  #
+  # @api public
+  # @example
+  #   expect(obj).to respond_to(:message).with(3).arguments
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#24
+  def with(n); end
+
+  # Specifies that the method accepts any keyword, i.e. the method has
+  #   a splatted keyword parameter of the form **kw_args.
+  #
+  # @api public
+  # @example
+  #   expect(obj).to respond_to(:message).with_any_keywords
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#48
+  def with_any_keywords; end
+
+  # Specifies keyword arguments, if any.
+  #
+  # @api public
+  # @example
+  #   expect(obj).to respond_to(:message).with_keywords(:color, :shape)
+  # @example with an expected number of arguments
+  #   expect(obj).to respond_to(:message).with(3).arguments.and_keywords(:color, :shape)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#36
+  def with_keywords(*keywords); end
+
+  # Specifies that the number of arguments has no upper limit, i.e. the
+  #   method has a splatted parameter of the form *args.
+  #
+  # @api public
+  # @example
+  #   expect(obj).to respond_to(:message).with_unlimited_arguments
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#60
+  def with_unlimited_arguments; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#112
+  def find_failing_method_names(actual, filter_method); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#119
+  def matches_arity?(actual, name); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#156
+  def pp_names; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#130
+  def with_arity; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#139
+  def with_arity_string; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#143
+  def with_keywords_string; end
+end
+
+# @api private
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#161
+class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck
+  # @api private
+  # @return [ArityCheck] a new instance of ArityCheck
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#162
+  def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#178
+  def matches?(actual, name); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#187
+  def method_signature_for(actual, name); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/respond_to.rb#183
+  def verifier_for(actual, name); end
+end
+
+# Provides the implementation for `satisfy`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/satisfy.rb#7
+class RSpec::Matchers::BuiltIn::Satisfy < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [Satisfy] a new instance of Satisfy
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/satisfy.rb#8
+  def initialize(description = T.unsafe(nil), &block); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/satisfy.rb#21
+  def description; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/satisfy.rb#27
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/satisfy.rb#33
+  def failure_message_when_negated; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/satisfy.rb#14
+  def matches?(actual, &block); end
+
+  private
+
+  # :nocov:
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/satisfy.rb#40
+  def block_representation; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/satisfy.rb#48
+  def extract_block_snippet; end
+end
+
+# Base class for specifying a change from and/or to specific values.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#181
+class RSpec::Matchers::BuiltIn::SpecificValuesChange < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [SpecificValuesChange] a new instance of SpecificValuesChange
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#185
+  def initialize(change_details, from, to); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#197
+  def description; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#202
+  def failure_message; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#192
+  def matches?(event_proc); end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#210
+  def supports_block_expectations?; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#215
+  def supports_value_expectations?; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#244
+  def after_value_failure; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#238
+  def before_value_failure; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#255
+  def did_change_failure; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#250
+  def did_not_change_failure; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#234
+  def matches_after?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#261
+  def not_given_a_block_failure; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#221
+  def perform_change(event_proc); end
+end
+
+# @api private
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/change.rb#183
+RSpec::Matchers::BuiltIn::SpecificValuesChange::MATCH_ANYTHING = BasicObject
+
+# For RSpec 3.1, the base class was named `StartAndEndWith`. For SemVer reasons,
+# we still provide this constant until 4.0.
+#
+# @deprecated Use StartOrEndWith instead.
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/start_or_end_with.rb#61
+RSpec::Matchers::BuiltIn::StartAndEndWith = RSpec::Matchers::BuiltIn::StartOrEndWith
+
+# Base class for the `end_with` and `start_with` matchers.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/start_or_end_with.rb#7
+class RSpec::Matchers::BuiltIn::StartOrEndWith < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [StartOrEndWith] a new instance of StartOrEndWith
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/start_or_end_with.rb#8
+  def initialize(*expected); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/start_or_end_with.rb#27
+  def description; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/start_or_end_with.rb#15
+  def failure_message; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/start_or_end_with.rb#36
+  def match(_expected, actual); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/start_or_end_with.rb#48
+  def subsets_comparable?; end
+end
+
+# Provides the implementation for `start_with`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/start_or_end_with.rb#66
+class RSpec::Matchers::BuiltIn::StartWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith
+  private
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/start_or_end_with.rb#73
+  def element_matches?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/start_or_end_with.rb#69
+  def subset_matches?; end
+end
+
+# Provides the implementation for `throw_symbol`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/throw_symbol.rb#7
+class RSpec::Matchers::BuiltIn::ThrowSymbol
+  include ::RSpec::Matchers::Composable
+
+  # @api private
+  # @return [ThrowSymbol] a new instance of ThrowSymbol
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/throw_symbol.rb#10
+  def initialize(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/throw_symbol.rb#86
+  def description; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/throw_symbol.rb#68
+  def does_not_match?(given_proc); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/throw_symbol.rb#103
+  def expects_call_stack_jump?; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/throw_symbol.rb#74
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/throw_symbol.rb#80
+  def failure_message_when_negated; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/throw_symbol.rb#18
+  def matches?(given_proc); end
+
+  # Indicates this matcher matches against a block.
+  #
+  # @api private
+  # @return [True]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/throw_symbol.rb#93
+  def supports_block_expectations?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/throw_symbol.rb#98
+  def supports_value_expectations?; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/throw_symbol.rb#109
+  def actual_result; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/throw_symbol.rb#118
+  def caught; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/throw_symbol.rb#114
+  def expected(symbol_desc = T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/throw_symbol.rb#122
+  def throw_description(symbol, arg); end
+end
+
+# Provides the implementation for `yield_control`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#101
+class RSpec::Matchers::BuiltIn::YieldControl < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  include ::RSpec::Matchers::BuiltIn::CountExpectation
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#111
+  def does_not_match?(block); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#117
+  def failure_message; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#123
+  def failure_message_when_negated; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#104
+  def matches?(block); end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#128
+  def supports_block_expectations?; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#133
+  def supports_value_expectations?; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#139
+  def failure_reason; end
+end
+
+# Object that is yielded to `expect` when one of the
+# yield matchers is used. Provides information about
+# the yield behavior of the object-under-test.
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#12
+class RSpec::Matchers::BuiltIn::YieldProbe
+  # @return [YieldProbe] a new instance of YieldProbe
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#21
+  def initialize(block, &callback); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#68
+  def assert_used!; end
+
+  # :nocov:
+  # On 1.8.7, `lambda { }.arity` and `lambda { |*a| }.arity` both return -1,
+  # so we can't distinguish between accepting no args and an arg splat.
+  # It's OK to skip, this, though; it just provides a nice error message
+  # when the user forgets to accept an arg in their block. They'll still get
+  # the `assert_used!` error message from above, which is sufficient.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#78
+  def assert_valid_expect_block!; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#29
+  def has_block?; end
+
+  # Returns the value of attribute num_yields.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#19
+  def num_yields; end
+
+  # Sets the attribute num_yields
+  #
+  # @param value the value to set the attribute num_yields to.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#19
+  def num_yields=(_arg0); end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#33
+  def probe; end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#53
+  def single_yield_args; end
+
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#40
+  def to_proc; end
+
+  # Returns the value of attribute yielded_args.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#19
+  def yielded_args; end
+
+  # Sets the attribute yielded_args
+  #
+  # @param value the value to set the attribute yielded_args to.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#19
+  def yielded_args=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#57
+  def yielded_once?(matcher_name); end
+
+  class << self
+    # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#13
+    def probe(block, &callback); end
+  end
+end
+
+# Provides the implementation for `yield_successive_args`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#296
+class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [YieldSuccessiveArgs] a new instance of YieldSuccessiveArgs
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#297
+  def initialize(*args); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#337
+  def description; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#320
+  def does_not_match?(block); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#325
+  def failure_message; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#331
+  def failure_message_when_negated; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#302
+  def matches?(block); end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#342
+  def supports_block_expectations?; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#347
+  def supports_value_expectations?; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#353
+  def expected_arg_description; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#365
+  def negative_failure_reason; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#357
+  def positive_failure_reason; end
+end
+
+# Provides the implementation for `yield_with_args`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#199
+class RSpec::Matchers::BuiltIn::YieldWithArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @return [YieldWithArgs] a new instance of YieldWithArgs
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#200
+  def initialize(*args); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#233
+  def description; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#218
+  def does_not_match?(block); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#223
+  def failure_message; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#228
+  def failure_message_when_negated; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#205
+  def matches?(block); end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#240
+  def supports_block_expectations?; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#245
+  def supports_value_expectations?; end
+
+  private
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#288
+  def all_args_match?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#273
+  def args_currently_match?; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#257
+  def expected_arg_description; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#261
+  def negative_failure_reason; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#251
+  def positive_failure_reason; end
+end
+
+# Provides the implementation for `yield_with_no_args`.
+# Not intended to be instantiated directly.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#149
+class RSpec::Matchers::BuiltIn::YieldWithNoArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#158
+  def does_not_match?(block); end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#163
+  def failure_message; end
+
+  # @api private
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#168
+  def failure_message_when_negated; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#151
+  def matches?(block); end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#173
+  def supports_block_expectations?; end
+
+  # @api private
+  # @private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#178
+  def supports_value_expectations?; end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#190
+  def negative_failure_reason; end
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/built_in/yield.rb#184
+  def positive_failure_reason; end
+end
+
+# Mixin designed to support the composable matcher features
+# of RSpec 3+. Mix it into your custom matcher classes to
+# allow them to be used in a composable fashion.
+#
+# @api public
+#
+# source://rspec-expectations//lib/rspec/matchers/composable.rb#10
+module RSpec::Matchers::Composable
+  # Creates a compound `and` expectation. The matcher will
+  # only pass if both sub-matchers pass.
+  # This can be chained together to form an arbitrarily long
+  # chain of matchers.
+  #
+  # @api public
+  # @example
+  #   expect(alphabet).to start_with("a").and end_with("z")
+  #   expect(alphabet).to start_with("a") & end_with("z")
+  # @note The negative form (`expect(...).not_to matcher.and other`)
+  #   is not supported at this time.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/composable.rb#22
+  def &(matcher); end
+
+  # Delegates to `#matches?`. Allows matchers to be used in composable
+  # fashion and also supports using matchers in case statements.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/composable.rb#45
+  def ===(value); end
+
+  # Creates a compound `and` expectation. The matcher will
+  # only pass if both sub-matchers pass.
+  # This can be chained together to form an arbitrarily long
+  # chain of matchers.
+  #
+  # @api public
+  # @example
+  #   expect(alphabet).to start_with("a").and end_with("z")
+  #   expect(alphabet).to start_with("a") & end_with("z")
+  # @note The negative form (`expect(...).not_to matcher.and other`)
+  #   is not supported at this time.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/composable.rb#22
+  def and(matcher); end
+
+  # Creates a compound `or` expectation. The matcher will
+  # pass if either sub-matcher passes.
+  # This can be chained together to form an arbitrarily long
+  # chain of matchers.
+  #
+  # @api public
+  # @example
+  #   expect(stoplight.color).to eq("red").or eq("green").or eq("yellow")
+  #   expect(stoplight.color).to eq("red") | eq("green") | eq("yellow")
+  # @note The negative form (`expect(...).not_to matcher.or other`)
+  #   is not supported at this time.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/composable.rb#38
+  def or(matcher); end
+
+  # Creates a compound `or` expectation. The matcher will
+  # pass if either sub-matcher passes.
+  # This can be chained together to form an arbitrarily long
+  # chain of matchers.
+  #
+  # @api public
+  # @example
+  #   expect(stoplight.color).to eq("red").or eq("green").or eq("yellow")
+  #   expect(stoplight.color).to eq("red") | eq("green") | eq("yellow")
+  # @note The negative form (`expect(...).not_to matcher.or other`)
+  #   is not supported at this time.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/composable.rb#38
+  def |(matcher); end
+
+  private
+
+  # Returns the description of the given object in a way that is
+  # aware of composed matchers. If the object is a matcher with
+  # a `description` method, returns the description; otherwise
+  # returns `object.inspect`.
+  #
+  # You are encouraged to use this in your custom matcher's
+  # `description`, `failure_message` or
+  # `failure_message_when_negated` implementation if you are
+  # supporting matcher arguments.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/composable.rb#82
+  def description_of(object); end
+
+  # We should enumerate arrays as long as they are not recursive.
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/composable.rb#142
+  def should_enumerate?(item); end
+
+  # Transforms the given data structure (typically a hash or array)
+  # into a new data structure that, when `#inspect` is called on it,
+  # will provide descriptions of any contained matchers rather than
+  # the normal `#inspect` output.
+  #
+  # You are encouraged to use this in your custom matcher's
+  # `description`, `failure_message` or
+  # `failure_message_when_negated` implementation if you are
+  # supporting any arguments which may be a data structure
+  # containing matchers.
+  #
+  # @api public
+  #
+  # source://rspec-expectations//lib/rspec/matchers/composable.rb#98
+  def surface_descriptions_in(item); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/composable.rb#147
+  def unreadable_io?(object); end
+
+  # This provides a generic way to fuzzy-match an expected value against
+  # an actual value. It understands nested data structures (e.g. hashes
+  # and arrays) and is able to match against a matcher being used as
+  # the expected value or within the expected value at any level of
+  # nesting.
+  #
+  # Within a custom matcher you are encouraged to use this whenever your
+  # matcher needs to match two values, unless it needs more precise semantics.
+  # For example, the `eq` matcher _does not_ use this as it is meant to
+  # use `==` (and only `==`) for matching.
+  #
+  # @api public
+  # @param expected [Object] what is expected
+  # @param actual [Object] the actual value
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/composable.rb#66
+  def values_match?(expected, actual); end
+
+  # Historically, a single matcher instance was only checked
+  # against a single value. Given that the matcher was only
+  # used once, it's been common to memoize some intermediate
+  # calculation that is derived from the `actual` value in
+  # order to reuse that intermediate result in the failure
+  # message.
+  #
+  # This can cause a problem when using such a matcher as an
+  # argument to another matcher in a composed matcher expression,
+  # since the matcher instance may be checked against multiple
+  # values and produce invalid results due to the memoization.
+  #
+  # To deal with this, we clone any matchers in `expected` via
+  # this method when using `values_match?`, so that any memoization
+  # does not "leak" between checks.
+  #
+  # @api public
+  # @private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/composable.rb#128
+  def with_matchers_cloned(object); end
+
+  class << self
+    # We should enumerate arrays as long as they are not recursive.
+    #
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-expectations//lib/rspec/matchers/composable.rb#142
+    def should_enumerate?(item); end
+
+    # Transforms the given data structure (typically a hash or array)
+    # into a new data structure that, when `#inspect` is called on it,
+    # will provide descriptions of any contained matchers rather than
+    # the normal `#inspect` output.
+    #
+    # You are encouraged to use this in your custom matcher's
+    # `description`, `failure_message` or
+    # `failure_message_when_negated` implementation if you are
+    # supporting any arguments which may be a data structure
+    # containing matchers.
+    #
+    # @api public
+    #
+    # source://rspec-expectations//lib/rspec/matchers/composable.rb#98
+    def surface_descriptions_in(item); end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-expectations//lib/rspec/matchers/composable.rb#147
+    def unreadable_io?(object); end
+  end
+end
+
+# Wraps an item in order to surface its `description` via `inspect`.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/composable.rb#158
+class RSpec::Matchers::Composable::DescribableItem < ::Struct
+  # Inspectable version of the item description
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/composable.rb#160
+  def inspect; end
+
+  # Returns the value of attribute item
+  #
+  # @return [Object] the current value of item
+  def item; end
+
+  # Sets the attribute item
+  #
+  # @param value [Object] the value to set the attribute item to.
+  # @return [Object] the newly set value
+  def item=(_); end
+
+  # A pretty printed version of the item description.
+  #
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/composable.rb#165
+  def pretty_print(pp); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# Defines the custom matcher DSL.
+#
+# source://rspec-expectations//lib/rspec/matchers/dsl.rb#6
+module RSpec::Matchers::DSL
+  # Defines a matcher alias. The returned matcher's `description` will be overridden
+  # to reflect the phrasing of the new name, which will be used in failure messages
+  # when passed as an argument to another matcher in a composed matcher expression.
+  #
+  # @example
+  #   RSpec::Matchers.alias_matcher :a_list_sorted_by, :be_sorted_by do |description|
+  #   description.sub("be sorted by", "a list sorted by")
+  #   end
+  #
+  #   be_sorted_by(:age).description # => "be sorted by age"
+  #   a_list_sorted_by(:age).description # => "a list sorted by age"
+  # @example
+  #   RSpec::Matchers.alias_matcher :a_list_that_sums_to, :sum_to
+  #   sum_to(3).description # => "sum to 3"
+  #   a_list_that_sums_to(3).description # => "a list that sums to 3"
+  # @option options
+  # @param old_name [Symbol] the original name for the matcher
+  # @param new_name [Symbol] the new name for the matcher
+  # @param options [Hash] options for the aliased matcher
+  # @see RSpec::Matchers
+  # @yield [String] optional block that, when given, is used to define the overridden
+  #   logic. The yielded arg is the original description or failure message. If no
+  #   block is provided, a default override is used based on the old and new names.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#32
+  def alias_matcher(new_name, old_name, options = T.unsafe(nil), &description_override); end
+
+  # Defines a custom matcher.
+  #
+  # @param name [Symbol] the name for the matcher
+  # @see RSpec::Matchers
+  # @yield [Object] block that is used to define the matcher.
+  #   The block is evaluated in the context of your custom matcher class.
+  #   When args are passed to your matcher, they will be yielded here,
+  #   usually representing the expected value(s).
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#73
+  def define(name, &declarations); end
+
+  # Defines a negated matcher. The returned matcher's `description` and `failure_message`
+  # will be overridden to reflect the phrasing of the new name, and the match logic will
+  # be based on the original matcher but negated.
+  #
+  # @example
+  #   RSpec::Matchers.define_negated_matcher :exclude, :include
+  #   include(1, 2).description # => "include 1 and 2"
+  #   exclude(1, 2).description # => "exclude 1 and 2"
+  # @param negated_name [Symbol] the name for the negated matcher
+  # @param base_name [Symbol] the name of the original matcher that will be negated
+  # @see RSpec::Matchers
+  # @yield [String] optional block that, when given, is used to define the overridden
+  #   logic. The yielded arg is the original description or failure message. If no
+  #   block is provided, a default override is used based on the old and new names.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#61
+  def define_negated_matcher(negated_name, base_name, &description_override); end
+
+  # Defines a custom matcher.
+  #
+  # @param name [Symbol] the name for the matcher
+  # @see RSpec::Matchers
+  # @yield [Object] block that is used to define the matcher.
+  #   The block is evaluated in the context of your custom matcher class.
+  #   When args are passed to your matcher, they will be yielded here,
+  #   usually representing the expected value(s).
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#73
+  def matcher(name, &declarations); end
+
+  private
+
+  # :nocov:
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#84
+  def warn_about_block_args(name, declarations); end
+end
+
+# Defines default implementations of the matcher
+# protocol methods for custom matchers. You can
+# override any of these using the {RSpec::Matchers::DSL::Macros Macros} methods
+# from within an `RSpec::Matchers.define` block.
+#
+# source://rspec-expectations//lib/rspec/matchers/dsl.rb#385
+module RSpec::Matchers::DSL::DefaultImplementations
+  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
+
+  # The default description.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#395
+  def description; end
+
+  # Used internally by objects returns by `should` and `should_not`.
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#390
+  def diffable?; end
+
+  # Most matchers do not expect call stack jumps.
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#412
+  def expects_call_stack_jump?; end
+
+  # Matchers do not support block expectations by default. You
+  # must opt-in.
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#403
+  def supports_block_expectations?; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#407
+  def supports_value_expectations?; end
+
+  private
+
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#418
+  def chained_method_clause_sentences; end
+end
+
+# Contains the methods that are available from within the
+# `RSpec::Matchers.define` DSL for creating custom matchers.
+#
+# source://rspec-expectations//lib/rspec/matchers/dsl.rb#104
+module RSpec::Matchers::DSL::Macros
+  # Convenience for defining methods on this matcher to create a fluent
+  # interface. The trick about fluent interfaces is that each method must
+  # return self in order to chain methods together. `chain` handles that
+  # for you. If the method is invoked and the
+  # `include_chain_clauses_in_custom_matcher_descriptions` config option
+  # hash been enabled, the chained method name and args will be added to the
+  # default description and failure message.
+  #
+  # In the common case where you just want the chained method to store some
+  # value(s) for later use (e.g. in `match`), you can provide one or more
+  # attribute names instead of a block; the chained method will store its
+  # arguments in instance variables with those names, and the values will
+  # be exposed via getters.
+  #
+  # @example
+  #
+  #   RSpec::Matchers.define :have_errors_on do |key|
+  #   chain :with do |message|
+  #   @message = message
+  #   end
+  #
+  #   match do |actual|
+  #   actual.errors[key] == @message
+  #   end
+  #   end
+  #
+  #   expect(minor).to have_errors_on(:age).with("Not old enough to participate")
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#298
+  def chain(method_name, *attr_names, &definition); end
+
+  # Customize the description to use for one-liners.  Only use this when
+  # the description generated by default doesn't suit your needs.
+  #
+  # @example
+  #
+  #   RSpec::Matchers.define :qualify_for do |expected|
+  #   match { your_match_logic }
+  #
+  #   description do
+  #   "qualify for #{expected}"
+  #   end
+  #   end
+  # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#253
+  def description(&definition); end
+
+  # Tells the matcher to diff the actual and expected values in the failure
+  # message.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#259
+  def diffable; end
+
+  # Customizes the failure message to use when this matcher is
+  # asked to positively match. Only use this when the message
+  # generated by default doesn't suit your needs.
+  #
+  # @example
+  #
+  #   RSpec::Matchers.define :have_strength do |expected|
+  #   match { your_match_logic }
+  #
+  #   failure_message do |actual|
+  #   "Expected strength of #{expected}, but had #{actual.strength}"
+  #   end
+  #   end
+  # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#216
+  def failure_message(&definition); end
+
+  # Customize the failure message to use when this matcher is asked
+  # to negatively match. Only use this when the message generated by
+  # default doesn't suit your needs.
+  #
+  # @example
+  #
+  #   RSpec::Matchers.define :have_strength do |expected|
+  #   match { your_match_logic }
+  #
+  #   failure_message_when_negated do |actual|
+  #   "Expected not to have strength of #{expected}, but did"
+  #   end
+  #   end
+  # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#235
+  def failure_message_when_negated(&definition); end
+
+  # Stores the block that is used to determine whether this matcher passes
+  # or fails. The block should return a boolean value. When the matcher is
+  # passed to `expect(...).to` and the block returns `true`, then the expectation
+  # passes. Similarly, when the matcher is passed to `expect(...).not_to` and the
+  # block returns `false`, then the expectation passes.
+  #
+  # By default the match block will swallow expectation errors (e.g.
+  # caused by using an expectation such as `expect(1).to eq 2`), if you
+  # wish to allow these to bubble up, pass in the option
+  # `:notify_expectation_failures => true`.
+  #
+  # @example
+  #
+  #   RSpec::Matchers.define :be_even do
+  #   match do |actual|
+  #   actual.even?
+  #   end
+  #   end
+  #
+  #   expect(4).to be_even     # passes
+  #   expect(3).not_to be_even # passes
+  #   expect(3).to be_even     # fails
+  #   expect(4).not_to be_even # fails
+  # @param options [Hash] for defining the behavior of the match block.
+  # @yield [Object] actual the actual value (i.e. the value wrapped by `expect`)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#131
+  def match(options = T.unsafe(nil), &match_block); end
+
+  # Use this instead of `match` when the block will raise an exception
+  # rather than returning false to indicate a failure.
+  #
+  # @example
+  #
+  #   RSpec::Matchers.define :accept_as_valid do |candidate_address|
+  #   match_unless_raises ValidationException do |validator|
+  #   validator.validate(candidate_address)
+  #   end
+  #   end
+  #
+  #   expect(email_validator).to accept_as_valid("person@company.com")
+  # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#188
+  def match_unless_raises(expected_exception = T.unsafe(nil), &match_block); end
+
+  # Use this to define the block for a negative expectation (`expect(...).not_to`)
+  # when the positive and negative forms require different handling. This
+  # is rarely necessary, but can be helpful, for example, when specifying
+  # asynchronous processes that require different timeouts.
+  #
+  # By default the match block will swallow expectation errors (e.g.
+  # caused by using an expectation such as `expect(1).to eq 2`), if you
+  # wish to allow these to bubble up, pass in the option
+  # `:notify_expectation_failures => true`.
+  #
+  # @param options [Hash] for defining the behavior of the match block.
+  # @yield [Object] actual the actual value (i.e. the value wrapped by `expect`)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#160
+  def match_when_negated(options = T.unsafe(nil), &match_block); end
+
+  # Declares that the matcher can be used in a block expectation.
+  # Users will not be able to use your matcher in a block
+  # expectation without declaring this.
+  # (e.g. `expect { do_something }.to matcher`).
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#267
+  def supports_block_expectations; end
+
+  private
+
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#312
+  def assign_attributes(attr_names); end
+
+  # Does the following:
+  #
+  # - Defines the named method using a user-provided block
+  #   in @user_method_defs, which is included as an ancestor
+  #   in the singleton class in which we eval the `define` block.
+  # - Defines an overridden definition for the same method
+  #   usign the provided `our_def` block.
+  # - Provides a default `our_def` block for the common case
+  #   of needing to call the user's definition with `@actual`
+  #   as an arg, but only if their block's arity can handle it.
+  #
+  # This compiles the user block into an actual method, allowing
+  # them to use normal method constructs like `return`
+  # (e.g. for an early guard statement), while allowing us to define
+  # an override that can provide the wrapped handling
+  # (e.g. assigning `@actual`, rescueing errors, etc) and
+  # can `super` to the user's definition.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#346
+  def define_user_override(method_name, user_def, &our_def); end
+end
+
+# Defines deprecated macro methods from RSpec 2 for backwards compatibility.
+#
+# @deprecated Use the methods from {Macros} instead.
+#
+# source://rspec-expectations//lib/rspec/matchers/dsl.rb#354
+module RSpec::Matchers::DSL::Macros::Deprecated
+  # @deprecated Use {Macros#failure_message} instead.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#368
+  def failure_message_for_should(&definition); end
+
+  # @deprecated Use {Macros#failure_message_when_negated} instead.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#374
+  def failure_message_for_should_not(&definition); end
+
+  # @deprecated Use {Macros#match} instead.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#356
+  def match_for_should(&definition); end
+
+  # @deprecated Use {Macros#match_when_negated} instead.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#362
+  def match_for_should_not(&definition); end
+end
+
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/dsl.rb#146
+RSpec::Matchers::DSL::Macros::RAISE_NOTIFIER = T.let(T.unsafe(nil), Proc)
+
+# The class used for custom matchers. The block passed to
+# `RSpec::Matchers.define` will be evaluated in the context
+# of the singleton class of an instance, and will have the
+# {RSpec::Matchers::DSL::Macros Macros} methods available.
+#
+# source://rspec-expectations//lib/rspec/matchers/dsl.rb#433
+class RSpec::Matchers::DSL::Matcher
+  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
+  include ::RSpec::Matchers::DSL::DefaultImplementations
+  include ::RSpec::Matchers
+  include ::RSpec::Matchers::Composable
+  extend ::RSpec::Matchers::DSL::Macros
+  extend ::RSpec::Matchers::DSL::Macros::Deprecated
+
+  # @api private
+  # @return [Matcher] a new instance of Matcher
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#462
+  def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end
+
+  # Exposes the value being matched against -- generally the object
+  # object wrapped by `expect`.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#449
+  def actual; end
+
+  # The block parameter used in the expectation
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#456
+  def block_arg; end
+
+  # Provides the expected value. This will return an array if
+  # multiple arguments were passed to the matcher; otherwise it
+  # will return a single value.
+  #
+  # @see #expected_as_array
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#482
+  def expected; end
+
+  # Returns the expected value as an an array. This exists primarily
+  # to aid in upgrading from RSpec 2.x, since in RSpec 2, `expected`
+  # always returned an array.
+  #
+  # @see #expected
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#494
+  def expected_as_array; end
+
+  # Adds the name (rather than a cryptic hex number)
+  # so we can identify an instance of
+  # the matcher in error messages (e.g. for `NoMethodError`)
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#499
+  def inspect; end
+
+  # The name of the matcher.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#459
+  def name; end
+
+  # Exposes the exception raised during the matching by `match_unless_raises`.
+  # Could be useful to extract details for a failure message.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#453
+  def rescued_exception; end
+
+  private
+
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#522
+  def actual_arg_for(block); end
+
+  # Takes care of forwarding unhandled messages to the
+  # `@matcher_execution_context` (typically the current
+  # running `RSpec::Core::Example`). This is needed by
+  # rspec-rails so that it can define matchers that wrap
+  # Rails' test helper methods, but it's also a useful
+  # feature in its own right.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#532
+  def method_missing(method, *args, **_arg2, &block); end
+
+  # Indicates that this matcher responds to messages
+  # from the `@matcher_execution_context` as well.
+  # Also, supports getting a method object for such methods.
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/dsl.rb#507
+  def respond_to_missing?(method, include_private = T.unsafe(nil)); end
+end
+
+# source://rspec-expectations//lib/rspec/matchers.rb#959
+RSpec::Matchers::DYNAMIC_MATCHER_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# Facilitates converting ruby objects to English phrases.
+#
+# source://rspec-expectations//lib/rspec/matchers/english_phrasing.rb#4
+module RSpec::Matchers::EnglishPhrasing
+  class << self
+    # when given an empty list.
+    #
+    # Converts an object (often a collection of objects)
+    # into an English list.
+    #
+    #     list(['banana', 'kiwi', 'mango'])
+    #     #=> " \"banana\", \"kiwi\", and \"mango\""
+    #
+    # Given an empty collection, returns the empty string.
+    #
+    #     list([]) #=> ""
+    #
+    # @note The returned string has a leading space except
+    #
+    # source://rspec-expectations//lib/rspec/matchers/english_phrasing.rb#26
+    def list(obj); end
+
+    # Converts a symbol into an English expression.
+    #
+    #     split_words(:banana_creme_pie) #=> "banana creme pie"
+    #
+    # source://rspec-expectations//lib/rspec/matchers/english_phrasing.rb#9
+    def split_words(sym); end
+  end
+end
+
+# source://rspec-expectations//lib/rspec/matchers.rb#958
+RSpec::Matchers::HAS_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# Provides the necessary plumbing to wrap a matcher with a decorator.
+#
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/matcher_delegator.rb#31
+class RSpec::Matchers::MatcherDelegator < ::RSpec::Matchers::BaseDelegator
+  include ::RSpec::Matchers::Composable
+
+  # @return [MatcherDelegator] a new instance of MatcherDelegator
+  #
+  # source://rspec-expectations//lib/rspec/matchers/matcher_delegator.rb#35
+  def initialize(base_matcher); end
+
+  # Returns the value of attribute base_matcher.
+  #
+  # source://rspec-expectations//lib/rspec/matchers/matcher_delegator.rb#33
+  def base_matcher; end
+
+  # source://rspec-expectations//lib/rspec/matchers/matcher_delegator.rb#39
+  def method_missing(*args, &block); end
+
+  private
+
+  # source://rspec-expectations//lib/rspec/matchers/matcher_delegator.rb#55
+  def initialize_copy(other); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/matcher_delegator.rb#44
+  def respond_to_missing?(name, include_all = T.unsafe(nil)); end
+end
+
+# Handles list of expected and actual value pairs when there is a need
+# to render multiple diffs. Also can handle one pair.
+#
+# @api private
+#
+# source://rspec-expectations//lib/rspec/matchers/multi_matcher_diff.rb#6
+class RSpec::Matchers::MultiMatcherDiff
+  # @api private
+  # @return [MultiMatcherDiff] a new instance of MultiMatcherDiff
+  #
+  # source://rspec-expectations//lib/rspec/matchers/multi_matcher_diff.rb#16
+  def initialize(expected_list); end
+
+  # Returns message with diff(s) appended for provided differ
+  # factory and actual value if there are any
+  #
+  # @api private
+  # @param message [String] original failure message
+  # @param differ [Proc]
+  # @return [String]
+  #
+  # source://rspec-expectations//lib/rspec/matchers/multi_matcher_diff.rb#47
+  def message_with_diff(message, differ); end
+
+  private
+
+  # @api private
+  #
+  # source://rspec-expectations//lib/rspec/matchers/multi_matcher_diff.rb#68
+  def diffs(differ); end
+
+  class << self
+    # Wraps provided matcher list in instance of
+    # MultiMatcherDiff.
+    #
+    # @api private
+    # @param matchers [Array<Any>] list of matchers to wrap
+    # @return [RSpec::Matchers::MultiMatcherDiff]
+    #
+    # source://rspec-expectations//lib/rspec/matchers/multi_matcher_diff.rb#37
+    def for_many_matchers(matchers); end
+
+    # Wraps provided expected value in instance of
+    # MultiMatcherDiff. If provided value is already an
+    # MultiMatcherDiff then it just returns it.
+    #
+    # @api private
+    # @param expected [Any] value to be wrapped
+    # @param actual [Any] value
+    # @return [RSpec::Matchers::MultiMatcherDiff]
+    #
+    # source://rspec-expectations//lib/rspec/matchers/multi_matcher_diff.rb#27
+    def from(expected, actual); end
+
+    private
+
+    # @api private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/multi_matcher_diff.rb#58
+    def diff_label_for(matcher); end
+
+    # @api private
+    #
+    # source://rspec-expectations//lib/rspec/matchers/multi_matcher_diff.rb#62
+    def truncated(description); end
+  end
+end
+
+# Default diff label when there is only one matcher in diff
+# output
+#
+# @api private
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/multi_matcher_diff.rb#10
+RSpec::Matchers::MultiMatcherDiff::DEFAULT_DIFF_LABEL = T.let(T.unsafe(nil), String)
+
+# Maximum readable matcher description length
+#
+# @api private
+# @private
+#
+# source://rspec-expectations//lib/rspec/matchers/multi_matcher_diff.rb#14
+RSpec::Matchers::MultiMatcherDiff::DESCRIPTION_MAX_LENGTH = T.let(T.unsafe(nil), Integer)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.3.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.3.1.rbi
deleted file mode 100644
index b914a4df249ff..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.3.1.rbi
+++ /dev/null
@@ -1,62 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rspec-github` gem.
-# Please instead update this file by running `bin/tapioca gem rspec-github`.
-
-module RSpec
-  extend ::RSpec::Support::Warnings
-  extend ::RSpec::Core::Warnings
-
-  class << self
-    def clear_examples; end
-    def configuration; end
-    def configuration=(_arg0); end
-    def configure; end
-    def const_missing(name); end
-    def context(*args, &example_group_block); end
-    def current_example; end
-    def current_example=(example); end
-    def current_scope; end
-    def current_scope=(scope); end
-    def describe(*args, &example_group_block); end
-    def example_group(*args, &example_group_block); end
-    def fcontext(*args, &example_group_block); end
-    def fdescribe(*args, &example_group_block); end
-    def reset; end
-    def shared_context(name, *args, &block); end
-    def shared_examples(name, *args, &block); end
-    def shared_examples_for(name, *args, &block); end
-    def world; end
-    def world=(_arg0); end
-    def xcontext(*args, &example_group_block); end
-    def xdescribe(*args, &example_group_block); end
-  end
-end
-
-module RSpec::Github; end
-
-class RSpec::Github::Formatter < ::RSpec::Core::Formatters::BaseFormatter
-  def example_failed(failure); end
-  def example_pending(pending); end
-end
-
-class RSpec::Github::NotificationDecorator
-  def initialize(notification); end
-
-  def annotation; end
-  def line; end
-  def path; end
-
-  private
-
-  def example; end
-  def message; end
-  def raw_path; end
-  def workspace; end
-end
-
-RSpec::Github::NotificationDecorator::ESCAPE_MAP = T.let(T.unsafe(nil), Hash)
-RSpec::Github::VERSION = T.let(T.unsafe(nil), String)
-RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
-RSpec::SharedContext = RSpec::Core::SharedContext
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi
deleted file mode 100644
index a7d7d2ab228f2..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi
+++ /dev/null
@@ -1,43 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rspec-its` gem.
-# Please instead update this file by running `bin/tapioca gem rspec-its`.
-
-module RSpec
-  extend ::RSpec::Support::Warnings
-  extend ::RSpec::Core::Warnings
-
-  class << self
-    def clear_examples; end
-    def configuration; end
-    def configuration=(_arg0); end
-    def configure; end
-    def const_missing(name); end
-    def context(*args, &example_group_block); end
-    def current_example; end
-    def current_example=(example); end
-    def current_scope; end
-    def current_scope=(scope); end
-    def describe(*args, &example_group_block); end
-    def example_group(*args, &example_group_block); end
-    def fcontext(*args, &example_group_block); end
-    def fdescribe(*args, &example_group_block); end
-    def reset; end
-    def shared_context(name, *args, &block); end
-    def shared_examples(name, *args, &block); end
-    def shared_examples_for(name, *args, &block); end
-    def world; end
-    def world=(_arg0); end
-    def xcontext(*args, &example_group_block); end
-    def xdescribe(*args, &example_group_block); end
-  end
-end
-
-module RSpec::Its
-  def its(attribute, *options, &block); end
-end
-
-RSpec::Its::VERSION = T.let(T.unsafe(nil), String)
-RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
-RSpec::SharedContext = RSpec::Core::SharedContext
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.11.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.11.1.rbi
deleted file mode 100644
index 5652af094ed23..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.11.1.rbi
+++ /dev/null
@@ -1,1497 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rspec-mocks` gem.
-# Please instead update this file by running `bin/tapioca gem rspec-mocks`.
-
-module RSpec
-  extend ::RSpec::Support::Warnings
-  extend ::RSpec::Core::Warnings
-
-  class << self
-    def clear_examples; end
-    def configuration; end
-    def configuration=(_arg0); end
-    def configure; end
-    def const_missing(name); end
-    def context(*args, &example_group_block); end
-    def current_example; end
-    def current_example=(example); end
-    def current_scope; end
-    def current_scope=(scope); end
-    def describe(*args, &example_group_block); end
-    def example_group(*args, &example_group_block); end
-    def fcontext(*args, &example_group_block); end
-    def fdescribe(*args, &example_group_block); end
-    def reset; end
-    def shared_context(name, *args, &block); end
-    def shared_examples(name, *args, &block); end
-    def shared_examples_for(name, *args, &block); end
-    def world; end
-    def world=(_arg0); end
-    def xcontext(*args, &example_group_block); end
-    def xdescribe(*args, &example_group_block); end
-  end
-end
-
-RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
-
-module RSpec::Mocks
-  class << self
-    def allow_message(subject, message, opts = T.unsafe(nil), &block); end
-    def configuration; end
-    def error_generator; end
-    def expect_message(subject, message, opts = T.unsafe(nil), &block); end
-    def setup; end
-    def space; end
-    def teardown; end
-    def verify; end
-    def with_temporary_scope; end
-  end
-end
-
-class RSpec::Mocks::AllowanceTarget < ::RSpec::Mocks::TargetBase
-  def expression; end
-  def not_to(matcher, *_args); end
-  def to(matcher, &block); end
-  def to_not(matcher, *_args); end
-end
-
-class RSpec::Mocks::AndInvokeImplementation
-  def initialize(procs_to_invoke); end
-
-  def call(*args, &block); end
-end
-
-class RSpec::Mocks::AndReturnImplementation
-  def initialize(values_to_return); end
-
-  def call(*_args_to_ignore, &_block); end
-end
-
-class RSpec::Mocks::AndWrapOriginalImplementation
-  def initialize(method, block); end
-
-  def call(*args, &block); end
-  def initial_action=(_value); end
-  def inner_action; end
-  def inner_action=(_value); end
-  def present?; end
-  def terminal_action=(_value); end
-
-  private
-
-  def cannot_modify_further_error; end
-end
-
-class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError < ::StandardError; end
-
-class RSpec::Mocks::AndYieldImplementation
-  def initialize(args_to_yield, eval_context, error_generator); end
-
-  def call(*_args_to_ignore, &block); end
-end
-
-module RSpec::Mocks::AnyInstance
-  class << self
-    def error_generator; end
-  end
-end
-
-class RSpec::Mocks::AnyInstance::Chain
-  include ::RSpec::Mocks::AnyInstance::Chain::Customizations
-
-  def initialize(recorder, *args, &block); end
-
-  def constrained_to_any_of?(*constraints); end
-  def expectation_fulfilled!; end
-  def matches_args?(*args); end
-  def never; end
-  def playback!(instance); end
-  def with(*args, &block); end
-
-  private
-
-  def last_message; end
-  def messages; end
-  def negated?; end
-  def record(rspec_method_name, *args, &block); end
-end
-
-module RSpec::Mocks::AnyInstance::Chain::Customizations
-  def and_call_original(*args, &block); end
-  def and_raise(*args, &block); end
-  def and_return(*args, &block); end
-  def and_throw(*args, &block); end
-  def and_wrap_original(*args, &block); end
-  def and_yield(*args, &block); end
-  def at_least(*args, &block); end
-  def at_most(*args, &block); end
-  def exactly(*args, &block); end
-  def never(*args, &block); end
-  def once(*args, &block); end
-  def thrice(*args, &block); end
-  def time(*args, &block); end
-  def times(*args, &block); end
-  def twice(*args, &block); end
-  def with(*args, &block); end
-
-  class << self
-    def record(method_name); end
-  end
-end
-
-class RSpec::Mocks::AnyInstance::ErrorGenerator < ::RSpec::Mocks::ErrorGenerator
-  def raise_does_not_implement_error(klass, method_name); end
-  def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end
-  def raise_not_supported_with_prepend_error(method_name, problem_mod); end
-  def raise_second_instance_received_message_error(unfulfilled_expectations); end
-end
-
-class RSpec::Mocks::AnyInstance::ExpectChainChain < ::RSpec::Mocks::AnyInstance::StubChain
-  def initialize(*args); end
-
-  def expectation_fulfilled?; end
-  def playback!(instance); end
-
-  private
-
-  def create_message_expectation_on(instance); end
-  def invocation_order; end
-end
-
-class RSpec::Mocks::AnyInstance::ExpectationChain < ::RSpec::Mocks::AnyInstance::Chain
-  def initialize(*args, &block); end
-
-  def expectation_fulfilled?; end
-
-  private
-
-  def verify_invocation_order(_rspec_method_name, *_args, &_block); end
-end
-
-class RSpec::Mocks::AnyInstance::FluentInterfaceProxy
-  def initialize(targets); end
-
-  def method_missing(*args, &block); end
-
-  private
-
-  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
-end
-
-class RSpec::Mocks::AnyInstance::MessageChains
-  def initialize; end
-
-  def [](method_name); end
-  def add(method_name, chain); end
-  def all_expectations_fulfilled?; end
-  def each_unfulfilled_expectation_matching(method_name, *args); end
-  def has_expectation?(method_name); end
-  def playback!(instance, method_name); end
-  def received_expected_message!(method_name); end
-  def remove_stub_chains_for!(method_name); end
-  def unfulfilled_expectations; end
-
-  private
-
-  def raise_if_second_instance_to_receive_message(instance); end
-end
-
-class RSpec::Mocks::AnyInstance::PositiveExpectationChain < ::RSpec::Mocks::AnyInstance::ExpectationChain
-  private
-
-  def create_message_expectation_on(instance); end
-  def invocation_order; end
-end
-
-RSpec::Mocks::AnyInstance::PositiveExpectationChain::ExpectationInvocationOrder = T.let(T.unsafe(nil), Hash)
-
-class RSpec::Mocks::AnyInstance::Proxy
-  def initialize(recorder, target_proxies); end
-
-  def expect_chain(*chain, &block); end
-  def klass; end
-  def should_not_receive(method_name, &block); end
-  def should_receive(method_name, &block); end
-  def stub(method_name_or_method_map, &block); end
-  def stub_chain(*chain, &block); end
-  def unstub(method_name); end
-
-  private
-
-  def perform_proxying(method_name, args, block, &target_proxy_block); end
-end
-
-class RSpec::Mocks::AnyInstance::Recorder
-  def initialize(klass); end
-
-  def already_observing?(method_name); end
-  def build_alias_method_name(method_name); end
-  def expect_chain(*method_names_and_optional_return_values, &block); end
-  def instance_that_received(method_name); end
-  def klass; end
-  def message_chains; end
-  def notify_received_message(_object, message, args, _blk); end
-  def playback!(instance, method_name); end
-  def should_not_receive(method_name, &block); end
-  def should_receive(method_name, &block); end
-  def stop_all_observation!; end
-  def stub(method_name, &block); end
-  def stub_chain(*method_names_and_optional_return_values, &block); end
-  def stubs; end
-  def unstub(method_name); end
-  def verify; end
-
-  protected
-
-  def stop_observing!(method_name); end
-
-  private
-
-  def allow_no_prepended_module_definition_of(method_name); end
-  def ancestor_is_an_observer?(method_name); end
-  def backup_method!(method_name); end
-  def mark_invoked!(method_name); end
-  def normalize_chain(*args); end
-  def observe!(method_name); end
-  def public_protected_or_private_method_defined?(method_name); end
-  def received_expected_message!(method_name); end
-  def remove_dummy_method!(method_name); end
-  def restore_method!(method_name); end
-  def restore_original_method!(method_name); end
-  def super_class_observers_for(method_name); end
-  def super_class_observing?(method_name); end
-end
-
-class RSpec::Mocks::AnyInstance::StubChain < ::RSpec::Mocks::AnyInstance::Chain
-  def expectation_fulfilled?; end
-
-  private
-
-  def create_message_expectation_on(instance); end
-  def invocation_order; end
-  def verify_invocation_order(rspec_method_name, *_args, &_block); end
-end
-
-RSpec::Mocks::AnyInstance::StubChain::EmptyInvocationOrder = T.let(T.unsafe(nil), Hash)
-RSpec::Mocks::AnyInstance::StubChain::InvocationOrder = T.let(T.unsafe(nil), Hash)
-
-class RSpec::Mocks::AnyInstance::StubChainChain < ::RSpec::Mocks::AnyInstance::StubChain
-  def initialize(*args); end
-
-  private
-
-  def create_message_expectation_on(instance); end
-  def invocation_order; end
-end
-
-class RSpec::Mocks::AnyInstanceAllowanceTarget < ::RSpec::Mocks::TargetBase
-  def expression; end
-  def not_to(matcher, *_args); end
-  def to(matcher, &block); end
-  def to_not(matcher, *_args); end
-end
-
-class RSpec::Mocks::AnyInstanceExpectationTarget < ::RSpec::Mocks::TargetBase
-  def expression; end
-  def not_to(matcher, &block); end
-  def to(matcher, &block); end
-  def to_not(matcher, &block); end
-end
-
-class RSpec::Mocks::ArgumentListMatcher
-  def initialize(*expected_args); end
-
-  def args_match?(*actual_args); end
-  def expected_args; end
-  def resolve_expected_args_based_on(actual_args); end
-
-  private
-
-  def ensure_expected_args_valid!; end
-  def replace_any_args_with_splat_of_anything(before_count, actual_args_count); end
-end
-
-RSpec::Mocks::ArgumentListMatcher::MATCH_ALL = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentListMatcher)
-
-module RSpec::Mocks::ArgumentMatchers
-  def a_kind_of(klass); end
-  def an_instance_of(klass); end
-  def any_args; end
-  def anything; end
-  def array_including(*args); end
-  def boolean; end
-  def duck_type(*args); end
-  def hash_excluding(*args); end
-  def hash_including(*args); end
-  def hash_not_including(*args); end
-  def instance_of(klass); end
-  def kind_of(klass); end
-  def no_args; end
-
-  class << self
-    def anythingize_lonely_keys(*args); end
-  end
-end
-
-class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
-  def ===(_other); end
-  def description; end
-end
-
-RSpec::Mocks::ArgumentMatchers::AnyArgMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::AnyArgMatcher)
-
-class RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
-  def description; end
-end
-
-RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher)
-
-class RSpec::Mocks::ArgumentMatchers::ArrayIncludingMatcher
-  def initialize(expected); end
-
-  def ===(actual); end
-  def description; end
-
-  private
-
-  def formatted_expected_values; end
-end
-
-class RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
-  def initialize(expected); end
-
-  def ===(predicate, actual); end
-  def description(name); end
-
-  private
-
-  def formatted_expected_hash; end
-end
-
-class RSpec::Mocks::ArgumentMatchers::BooleanMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
-  def ===(value); end
-  def description; end
-end
-
-RSpec::Mocks::ArgumentMatchers::BooleanMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::BooleanMatcher)
-
-class RSpec::Mocks::ArgumentMatchers::DuckTypeMatcher
-  def initialize(*methods_to_respond_to); end
-
-  def ===(value); end
-  def description; end
-end
-
-class RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher < ::RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
-  def ===(actual); end
-  def description; end
-end
-
-class RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher < ::RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
-  def ===(actual); end
-  def description; end
-end
-
-class RSpec::Mocks::ArgumentMatchers::InstanceOf
-  def initialize(klass); end
-
-  def ===(actual); end
-  def description; end
-end
-
-class RSpec::Mocks::ArgumentMatchers::KindOf
-  def initialize(klass); end
-
-  def ===(actual); end
-  def description; end
-end
-
-class RSpec::Mocks::ArgumentMatchers::NoArgsMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
-  def description; end
-end
-
-RSpec::Mocks::ArgumentMatchers::NoArgsMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::NoArgsMatcher)
-
-class RSpec::Mocks::ArgumentMatchers::SingletonMatcher
-  class << self
-    def inherited(subklass); end
-  end
-end
-
-class RSpec::Mocks::CallbackInvocationStrategy
-  def call(doubled_module); end
-end
-
-class RSpec::Mocks::CannotSupportArgMutationsError < ::StandardError; end
-
-class RSpec::Mocks::ClassNewMethodReference < ::RSpec::Mocks::ObjectMethodReference
-  def with_signature; end
-
-  class << self
-    def applies_to?(method_name); end
-  end
-end
-
-class RSpec::Mocks::ClassVerifyingDouble < ::Module
-  include ::RSpec::Mocks::TestDouble
-  include ::RSpec::Mocks::VerifyingDouble
-  include ::RSpec::Mocks::ObjectVerifyingDoubleMethods
-end
-
-class RSpec::Mocks::Configuration
-  def initialize; end
-
-  def add_stub_and_should_receive_to(*modules); end
-  def allow_message_expectations_on_nil; end
-  def allow_message_expectations_on_nil=(_arg0); end
-  def before_verifying_doubles(&block); end
-  def color?; end
-  def patch_marshal_to_support_partial_doubles=(val); end
-  def reset_syntaxes_to_default; end
-  def syntax; end
-  def syntax=(*values); end
-  def temporarily_suppress_partial_double_verification; end
-  def temporarily_suppress_partial_double_verification=(_arg0); end
-  def transfer_nested_constants=(_arg0); end
-  def transfer_nested_constants?; end
-  def verify_doubled_constant_names=(_arg0); end
-  def verify_doubled_constant_names?; end
-  def verify_partial_doubles=(val); end
-  def verify_partial_doubles?; end
-  def verifying_double_callbacks; end
-  def when_declaring_verifying_double(&block); end
-  def yield_receiver_to_any_instance_implementation_blocks=(_arg0); end
-  def yield_receiver_to_any_instance_implementation_blocks?; end
-end
-
-class RSpec::Mocks::Constant
-  extend ::RSpec::Support::RecursiveConstMethods
-
-  def initialize(name); end
-
-  def hidden=(_arg0); end
-  def hidden?; end
-  def inspect; end
-  def mutated?; end
-  def name; end
-  def original_value; end
-  def original_value=(_arg0); end
-  def previously_defined=(_arg0); end
-  def previously_defined?; end
-  def stubbed=(_arg0); end
-  def stubbed?; end
-  def to_s; end
-  def valid_name=(_arg0); end
-  def valid_name?; end
-
-  class << self
-    def original(name); end
-    def unmutated(name); end
-  end
-end
-
-class RSpec::Mocks::ConstantMutator
-  extend ::RSpec::Support::RecursiveConstMethods
-
-  class << self
-    def hide(constant_name); end
-    def mutate(mutator); end
-    def raise_on_invalid_const; end
-    def stub(constant_name, value, options = T.unsafe(nil)); end
-  end
-end
-
-class RSpec::Mocks::ConstantMutator::BaseMutator
-  include ::RSpec::Support::RecursiveConstMethods
-
-  def initialize(full_constant_name, mutated_value, transfer_nested_constants); end
-
-  def full_constant_name; end
-  def idempotently_reset; end
-  def original_value; end
-  def to_constant; end
-end
-
-class RSpec::Mocks::ConstantMutator::ConstantHider < ::RSpec::Mocks::ConstantMutator::BaseMutator
-  def mutate; end
-  def reset; end
-  def to_constant; end
-end
-
-class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer < ::RSpec::Mocks::ConstantMutator::BaseMutator
-  def initialize(*args); end
-
-  def mutate; end
-  def reset; end
-  def should_transfer_nested_constants?; end
-  def to_constant; end
-  def transfer_nested_constants; end
-  def verify_constants_to_transfer!; end
-end
-
-class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter < ::RSpec::Mocks::ConstantMutator::BaseMutator
-  def mutate; end
-  def reset; end
-  def to_constant; end
-
-  private
-
-  def name_for(parent, name); end
-end
-
-RSpec::Mocks::DEFAULT_CALLBACK_INVOCATION_STRATEGY = T.let(T.unsafe(nil), RSpec::Mocks::CallbackInvocationStrategy)
-
-class RSpec::Mocks::DirectObjectReference
-  def initialize(object); end
-
-  def const_to_replace; end
-  def defined?; end
-  def description; end
-  def target; end
-  def when_loaded; end
-end
-
-class RSpec::Mocks::Double
-  include ::RSpec::Mocks::TestDouble
-end
-
-class RSpec::Mocks::ErrorGenerator
-  def initialize(target = T.unsafe(nil)); end
-
-  def default_error_message(expectation, expected_args, actual_args); end
-  def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end
-  def expectation_on_nil_message(method_name); end
-  def intro(unwrapped = T.unsafe(nil)); end
-  def method_call_args_description(args, generic_prefix = T.unsafe(nil), matcher_prefix = T.unsafe(nil)); end
-  def opts; end
-  def opts=(_arg0); end
-  def raise_already_invoked_error(message, calling_customization); end
-  def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end
-  def raise_double_negation_error(wrapped_expression); end
-  def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line = T.unsafe(nil), source_id = T.unsafe(nil)); end
-  def raise_expectation_on_mocked_method(method); end
-  def raise_expectation_on_nil_error(method_name); end
-  def raise_expectation_on_unstubbed_method(method); end
-  def raise_expired_test_double_error; end
-  def raise_have_received_disallowed(type, reason); end
-  def raise_invalid_arguments_error(verifier); end
-  def raise_method_not_stubbed_error(method_name); end
-  def raise_missing_block_error(args_to_yield); end
-  def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end
-  def raise_non_public_error(method_name, visibility); end
-  def raise_only_valid_on_a_partial_double(method); end
-  def raise_out_of_order_error(message); end
-  def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line = T.unsafe(nil)); end
-  def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id = T.unsafe(nil)); end
-  def raise_unexpected_message_error(message, args); end
-  def raise_unimplemented_error(doubled_module, method_name, object); end
-  def raise_verifying_double_not_defined_error(ref); end
-  def raise_wrong_arity_error(args_to_yield, signature); end
-
-  private
-
-  def __raise(message, backtrace_line = T.unsafe(nil), source_id = T.unsafe(nil)); end
-  def arg_list(args); end
-  def count_message(count, expectation_count_type = T.unsafe(nil)); end
-  def diff_message(expected_args, actual_args); end
-  def differ; end
-  def error_message(expectation, args_for_multiple_calls); end
-  def expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher); end
-  def format_args(args); end
-  def format_received_args(args_for_multiple_calls); end
-  def group_count(index, args); end
-  def grouped_args(args); end
-  def list_of_exactly_one_string?(args); end
-  def notify(*args); end
-  def prepend_to_backtrace(exception, line); end
-  def received_part_of_expectation_error(actual_received_count, args); end
-  def times(count); end
-  def unexpected_arguments_message(expected_args_string, actual_args_string); end
-  def unpack_string_args(formatted_expected_args, actual_args); end
-end
-
-module RSpec::Mocks::ExampleMethods
-  include ::RSpec::Mocks::ArgumentMatchers
-  include ::RSpec::Mocks::ExampleMethods::ExpectHost
-
-  def allow(target); end
-  def allow_any_instance_of(klass); end
-  def allow_message_expectations_on_nil; end
-  def class_double(doubled_class, *args); end
-  def class_spy(*args); end
-  def double(*args); end
-  def expect_any_instance_of(klass); end
-  def have_received(method_name, &block); end
-  def hide_const(constant_name); end
-  def instance_double(doubled_class, *args); end
-  def instance_spy(*args); end
-  def object_double(object_or_name, *args); end
-  def object_spy(*args); end
-  def receive(method_name, &block); end
-  def receive_message_chain(*messages, &block); end
-  def receive_messages(message_return_value_hash); end
-  def spy(*args); end
-  def stub_const(constant_name, value, options = T.unsafe(nil)); end
-  def without_partial_double_verification; end
-
-  class << self
-    def declare_double(type, *args); end
-    def declare_verifying_double(type, ref, *args); end
-    def extended(object); end
-    def included(klass); end
-  end
-end
-
-module RSpec::Mocks::ExampleMethods::ExpectHost
-  def expect(target); end
-end
-
-class RSpec::Mocks::ExpectChain < ::RSpec::Mocks::MessageChain
-  private
-
-  def expectation(object, message, &return_block); end
-
-  class << self
-    def expect_chain_on(object, *chain, &blk); end
-  end
-end
-
-class RSpec::Mocks::ExpectationTarget < ::RSpec::Mocks::TargetBase
-  include ::RSpec::Mocks::ExpectationTargetMethods
-end
-
-module RSpec::Mocks::ExpectationTargetMethods
-  include ::RSpec::Mocks::TargetDelegationInstanceMethods
-  extend ::RSpec::Mocks::TargetDelegationClassMethods
-
-  def expression; end
-  def not_to(matcher, &block); end
-  def to(matcher, &block); end
-  def to_not(matcher, &block); end
-end
-
-class RSpec::Mocks::ExpiredTestDoubleError < ::RSpec::Mocks::MockExpectationError; end
-RSpec::Mocks::IGNORED_BACKTRACE_LINE = T.let(T.unsafe(nil), String)
-
-class RSpec::Mocks::Implementation
-  def call(*args, &block); end
-  def initial_action; end
-  def initial_action=(_arg0); end
-  def inner_action; end
-  def inner_action=(_arg0); end
-  def present?; end
-  def terminal_action; end
-  def terminal_action=(_arg0); end
-
-  private
-
-  def actions; end
-end
-
-class RSpec::Mocks::InstanceMethodReference < ::RSpec::Mocks::MethodReference
-  private
-
-  def find_method(mod); end
-  def method_defined?(mod); end
-  def method_implemented?(mod); end
-  def visibility_from(mod); end
-end
-
-class RSpec::Mocks::InstanceMethodStasher
-  def initialize(object, method); end
-
-  def handle_restoration_failures; end
-  def method_is_stashed?; end
-  def original_method; end
-  def restore; end
-  def stash; end
-
-  private
-
-  def method_defined_directly_on_klass?; end
-  def method_defined_on_klass?(klass = T.unsafe(nil)); end
-  def method_owned_by_klass?; end
-end
-
-class RSpec::Mocks::InstanceVerifyingDouble
-  include ::RSpec::Mocks::TestDouble
-  include ::RSpec::Mocks::VerifyingDouble
-
-  def __build_mock_proxy(order_group); end
-end
-
-class RSpec::Mocks::MarshalExtension
-  class << self
-    def patch!; end
-    def unpatch!; end
-  end
-end
-
-module RSpec::Mocks::Matchers; end
-
-class RSpec::Mocks::Matchers::ExpectationCustomization
-  def initialize(method_name, args, block); end
-
-  def block; end
-  def block=(_arg0); end
-  def playback_onto(expectation); end
-end
-
-class RSpec::Mocks::Matchers::HaveReceived
-  include ::RSpec::Mocks::Matchers::Matcher
-
-  def initialize(method_name, &block); end
-
-  def at_least(*args); end
-  def at_most(*args); end
-  def description; end
-  def does_not_match?(subject); end
-  def exactly(*args); end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def matches?(subject, &block); end
-  def name; end
-  def once(*args); end
-  def ordered(*args); end
-  def setup_allowance(_subject, &_block); end
-  def setup_any_instance_allowance(_subject, &_block); end
-  def setup_any_instance_expectation(_subject, &_block); end
-  def setup_any_instance_negative_expectation(_subject, &_block); end
-  def setup_expectation(subject, &block); end
-  def setup_negative_expectation(subject, &block); end
-  def thrice(*args); end
-  def time(*args); end
-  def times(*args); end
-  def twice(*args); end
-  def with(*args); end
-
-  private
-
-  def apply_constraints_to(expectation); end
-  def capture_failure_message; end
-  def count_constraint; end
-  def disallow(type, reason = T.unsafe(nil)); end
-  def ensure_count_unconstrained; end
-  def expect; end
-  def expected_messages_received_in_order?; end
-  def mock_proxy; end
-  def notify_failure_message; end
-end
-
-RSpec::Mocks::Matchers::HaveReceived::ARGS_CONSTRAINTS = T.let(T.unsafe(nil), Array)
-RSpec::Mocks::Matchers::HaveReceived::CONSTRAINTS = T.let(T.unsafe(nil), Array)
-RSpec::Mocks::Matchers::HaveReceived::COUNT_CONSTRAINTS = T.let(T.unsafe(nil), Array)
-module RSpec::Mocks::Matchers::Matcher; end
-
-class RSpec::Mocks::Matchers::Receive
-  include ::RSpec::Mocks::Matchers::Matcher
-
-  def initialize(message, block); end
-
-  def and_call_original(*args, &block); end
-  def and_invoke(*args, &block); end
-  def and_raise(*args, &block); end
-  def and_return(*args, &block); end
-  def and_throw(*args, &block); end
-  def and_wrap_original(*args, &block); end
-  def and_yield(*args, &block); end
-  def at_least(*args, &block); end
-  def at_most(*args, &block); end
-  def description; end
-  def does_not_match?(subject, &block); end
-  def exactly(*args, &block); end
-  def matches?(subject, &block); end
-  def name; end
-  def never(*args, &block); end
-  def once(*args, &block); end
-  def ordered(*args, &block); end
-  def setup_allowance(subject, &block); end
-  def setup_any_instance_allowance(subject, &block); end
-  def setup_any_instance_expectation(subject, &block); end
-  def setup_any_instance_negative_expectation(subject, &block); end
-  def setup_expectation(subject, &block); end
-  def setup_negative_expectation(subject, &block); end
-  def thrice(*args, &block); end
-  def time(*args, &block); end
-  def times(*args, &block); end
-  def twice(*args, &block); end
-  def with(*args, &block); end
-
-  private
-
-  def describable; end
-  def move_block_to_last_customization(block); end
-  def setup_any_instance_method_substitute(subject, method, block); end
-  def setup_method_substitute(host, method, block, *args); end
-  def setup_mock_proxy_method_substitute(subject, method, block); end
-  def warn_if_any_instance(expression, subject); end
-end
-
-class RSpec::Mocks::Matchers::Receive::DefaultDescribable
-  def initialize(message); end
-
-  def description_for(verb); end
-end
-
-class RSpec::Mocks::Matchers::ReceiveMessageChain
-  include ::RSpec::Mocks::Matchers::Matcher
-
-  def initialize(chain, &block); end
-
-  def and_call_original(*args, &block); end
-  def and_invoke(*args, &block); end
-  def and_raise(*args, &block); end
-  def and_return(*args, &block); end
-  def and_throw(*args, &block); end
-  def and_yield(*args, &block); end
-  def description; end
-  def does_not_match?(*_args); end
-  def matches?(subject, &block); end
-  def name; end
-  def setup_allowance(subject, &block); end
-  def setup_any_instance_allowance(subject, &block); end
-  def setup_any_instance_expectation(subject, &block); end
-  def setup_expectation(subject, &block); end
-  def setup_negative_expectation(*_args); end
-  def with(*args, &block); end
-
-  private
-
-  def formatted_chain; end
-  def replay_customizations(chain); end
-end
-
-class RSpec::Mocks::Matchers::ReceiveMessages
-  include ::RSpec::Mocks::Matchers::Matcher
-
-  def initialize(message_return_value_hash); end
-
-  def description; end
-  def does_not_match?(_subject); end
-  def matches?(subject); end
-  def name; end
-  def setup_allowance(subject); end
-  def setup_any_instance_allowance(subject); end
-  def setup_any_instance_expectation(subject); end
-  def setup_expectation(subject); end
-  def setup_negative_expectation(_subject); end
-  def warn_about_block; end
-
-  private
-
-  def any_instance_of(subject); end
-  def each_message_on(host); end
-  def proxy_on(subject); end
-end
-
-class RSpec::Mocks::MessageChain
-  def initialize(object, *chain, &blk); end
-
-  def block; end
-  def chain; end
-  def object; end
-  def setup_chain; end
-
-  private
-
-  def chain_on(object, *chain, &block); end
-  def find_matching_expectation; end
-  def find_matching_stub; end
-  def format_chain(*chain, &blk); end
-end
-
-class RSpec::Mocks::MessageExpectation
-  include ::RSpec::Mocks::MessageExpectation::ImplementationDetails
-
-  def and_call_original; end
-  def and_invoke(first_proc, *procs); end
-  def and_raise(*args); end
-  def and_return(first_value, *values); end
-  def and_throw(*args); end
-  def and_wrap_original(&block); end
-  def and_yield(*args, &block); end
-  def at_least(n, &block); end
-  def at_most(n, &block); end
-  def exactly(n, &block); end
-  def inspect; end
-  def never; end
-  def once(&block); end
-  def ordered(&block); end
-  def thrice(&block); end
-  def time(&block); end
-  def times(&block); end
-  def to_s; end
-  def twice(&block); end
-  def with(*args, &block); end
-end
-
-module RSpec::Mocks::MessageExpectation::ImplementationDetails
-  def initialize(error_generator, expectation_ordering, expected_from, method_double, type = T.unsafe(nil), opts = T.unsafe(nil), &implementation_block); end
-
-  def actual_received_count_matters?; end
-  def additional_expected_calls; end
-  def advise(*args); end
-  def and_yield_receiver_to_implementation; end
-  def argument_list_matcher=(_arg0); end
-  def called_max_times?; end
-  def description_for(verb); end
-  def ensure_expected_ordering_received!; end
-  def error_generator; end
-  def expectation_count_type; end
-  def expected_args; end
-  def expected_messages_received?; end
-  def generate_error; end
-  def ignoring_args?; end
-  def implementation; end
-  def increase_actual_received_count!; end
-  def invoke(parent_stub, *args, &block); end
-  def invoke_without_incrementing_received_count(parent_stub, *args, &block); end
-  def matches?(message, *args); end
-  def matches_at_least_count?; end
-  def matches_at_most_count?; end
-  def matches_exact_count?; end
-  def matches_name_but_not_args(message, *args); end
-  def message; end
-  def negative?; end
-  def negative_expectation_for?(message); end
-  def ordered?; end
-  def orig_object; end
-  def raise_out_of_order_error; end
-  def raise_unexpected_message_args_error(args_for_multiple_calls); end
-  def safe_invoke(parent_stub, *args, &block); end
-  def similar_messages; end
-  def type; end
-  def unadvise(args); end
-  def verify_messages_received; end
-  def yield_receiver_to_implementation_block?; end
-
-  protected
-
-  def error_generator=(_arg0); end
-  def expected_from=(_arg0); end
-  def expected_received_count=(_arg0); end
-  def implementation=(_arg0); end
-
-  private
-
-  def exception_source_id; end
-  def has_been_invoked?; end
-  def initial_implementation_action=(action); end
-  def inner_implementation_action=(action); end
-  def invoke_incrementing_actual_calls_by(increment, allowed_to_fail, parent_stub, *args, &block); end
-  def raise_already_invoked_error_if_necessary(calling_customization); end
-  def set_expected_received_count(relativity, n); end
-  def terminal_implementation_action=(action); end
-  def warn_about_stub_override; end
-  def wrap_original(method_name, &block); end
-end
-
-class RSpec::Mocks::MethodDouble
-  def initialize(object, method_name, proxy); end
-
-  def add_default_stub(*args, &implementation); end
-  def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end
-  def add_simple_expectation(method_name, response, error_generator, backtrace_line); end
-  def add_simple_stub(method_name, response); end
-  def add_stub(error_generator, expectation_ordering, expected_from, opts = T.unsafe(nil), &implementation); end
-  def build_expectation(error_generator, expectation_ordering); end
-  def clear; end
-  def configure_method; end
-  def define_proxy_method; end
-  def expectations; end
-  def message_expectation_class; end
-  def method_name; end
-  def method_stasher; end
-  def object; end
-  def object_singleton_class; end
-  def original_implementation_callable; end
-  def original_method; end
-  def proxy_method_invoked(_obj, *args, &block); end
-  def raise_method_not_stubbed_error; end
-  def remove_stub; end
-  def remove_stub_if_present; end
-  def reset; end
-  def restore_original_method; end
-  def restore_original_visibility; end
-  def save_original_implementation_callable!; end
-  def setup_simple_method_double(method_name, response, collection, error_generator = T.unsafe(nil), backtrace_line = T.unsafe(nil)); end
-  def show_frozen_warning; end
-  def stubs; end
-  def verify; end
-  def visibility; end
-
-  private
-
-  def definition_target; end
-  def new_rspec_prepended_module; end
-  def remove_method_from_definition_target; end
-  def usable_rspec_prepended_module; end
-end
-
-class RSpec::Mocks::MethodDouble::RSpecPrependedModule < ::Module; end
-
-class RSpec::Mocks::MethodReference
-  def initialize(object_reference, method_name); end
-
-  def defined?; end
-  def implemented?; end
-  def unimplemented?; end
-  def visibility; end
-  def with_signature; end
-
-  private
-
-  def original_method; end
-
-  class << self
-    def for(object_reference, method_name); end
-    def instance_method_visibility_for(klass, method_name); end
-    def method_defined_at_any_visibility?(klass, method_name); end
-    def method_visibility_for(object, method_name); end
-  end
-end
-
-class RSpec::Mocks::MockExpectationAlreadyInvokedError < ::Exception; end
-class RSpec::Mocks::MockExpectationError < ::Exception; end
-
-class RSpec::Mocks::NamedObjectReference
-  def initialize(const_name); end
-
-  def const_to_replace; end
-  def defined?; end
-  def description; end
-  def target; end
-  def when_loaded; end
-
-  private
-
-  def object; end
-end
-
-class RSpec::Mocks::NegationUnsupportedError < ::StandardError; end
-
-class RSpec::Mocks::NestedSpace < ::RSpec::Mocks::Space
-  def initialize(parent); end
-
-  def constant_mutator_for(name); end
-  def proxies_of(klass); end
-  def registered?(object); end
-
-  private
-
-  def any_instance_recorder_not_found_for(id, klass); end
-  def proxy_not_found_for(id, object); end
-end
-
-class RSpec::Mocks::NoCallbackInvocationStrategy
-  def call(_doubled_module); end
-end
-
-class RSpec::Mocks::ObjectMethodReference < ::RSpec::Mocks::MethodReference
-  private
-
-  def find_method(object); end
-  def method_defined?(object); end
-  def method_implemented?(object); end
-  def visibility_from(object); end
-
-  class << self
-    def for(object_reference, method_name); end
-  end
-end
-
-class RSpec::Mocks::ObjectReference
-  class << self
-    def for(object_module_or_name, allow_direct_object_refs = T.unsafe(nil)); end
-
-    private
-
-    def anonymous_module?(mod); end
-    def name_of(mod); end
-  end
-end
-
-RSpec::Mocks::ObjectReference::MODULE_NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-class RSpec::Mocks::ObjectVerifyingDouble
-  include ::RSpec::Mocks::TestDouble
-  include ::RSpec::Mocks::VerifyingDouble
-  include ::RSpec::Mocks::ObjectVerifyingDoubleMethods
-end
-
-module RSpec::Mocks::ObjectVerifyingDoubleMethods
-  include ::RSpec::Mocks::TestDouble
-  include ::RSpec::Mocks::VerifyingDouble
-
-  def as_stubbed_const(options = T.unsafe(nil)); end
-
-  private
-
-  def __build_mock_proxy(order_group); end
-end
-
-class RSpec::Mocks::OrderGroup
-  def initialize; end
-
-  def clear; end
-  def consume; end
-  def empty?; end
-  def handle_order_constraint(expectation); end
-  def invoked(message); end
-  def ready_for?(expectation); end
-  def register(expectation); end
-  def verify_invocation_order(expectation); end
-
-  private
-
-  def expectation_for(message); end
-  def expectations_invoked_in_order?; end
-  def expected_invocations; end
-  def invoked_expectations; end
-  def remaining_expectations; end
-end
-
-class RSpec::Mocks::OutsideOfExampleError < ::StandardError; end
-
-class RSpec::Mocks::PartialClassDoubleProxy < ::RSpec::Mocks::PartialDoubleProxy
-  include ::RSpec::Mocks::PartialClassDoubleProxyMethods
-end
-
-module RSpec::Mocks::PartialClassDoubleProxyMethods
-  def initialize(source_space, *args); end
-
-  def original_method_handle_for(message); end
-
-  protected
-
-  def method_double_from_ancestor_for(message); end
-  def original_unbound_method_handle_from_ancestor_for(message); end
-  def superclass_proxy; end
-end
-
-class RSpec::Mocks::PartialDoubleProxy < ::RSpec::Mocks::Proxy
-  def add_simple_expectation(method_name, response, location); end
-  def add_simple_stub(method_name, response); end
-  def message_received(message, *args, &block); end
-  def original_method_handle_for(message); end
-  def reset; end
-  def visibility_for(method_name); end
-
-  private
-
-  def any_instance_class_recorder_observing_method?(klass, method_name); end
-end
-
-class RSpec::Mocks::Proxy
-  def initialize(object, order_group, options = T.unsafe(nil)); end
-
-  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
-  def add_simple_expectation(method_name, response, location); end
-  def add_simple_stub(method_name, response); end
-  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
-  def as_null_object; end
-  def build_expectation(method_name); end
-  def check_for_unexpected_arguments(expectation); end
-  def ensure_can_be_proxied!(object); end
-  def ensure_implemented(*_args); end
-  def has_negative_expectation?(message); end
-  def message_received(message, *args, &block); end
-  def messages_arg_list; end
-  def method_double_if_exists_for_message(message); end
-  def null_object?; end
-  def object; end
-  def original_method_handle_for(_message); end
-  def prepended_modules_of_singleton_class; end
-  def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end
-  def raise_unexpected_message_error(method_name, args); end
-  def received_message?(method_name, *args, &block); end
-  def record_message_received(message, *args, &block); end
-  def remove_stub(method_name); end
-  def remove_stub_if_present(method_name); end
-  def replay_received_message_on(expectation, &block); end
-  def reset; end
-  def verify; end
-  def visibility_for(_method_name); end
-
-  private
-
-  def find_almost_matching_expectation(method_name, *args); end
-  def find_almost_matching_stub(method_name, *args); end
-  def find_best_matching_expectation_for(method_name); end
-  def find_matching_expectation(method_name, *args); end
-  def find_matching_method_stub(method_name, *args); end
-  def method_double_for(message); end
-
-  class << self
-    def prepended_modules_of(klass); end
-  end
-end
-
-RSpec::Mocks::Proxy::DEFAULT_MESSAGE_EXPECTATION_OPTS = T.let(T.unsafe(nil), Hash)
-
-class RSpec::Mocks::Proxy::SpecificMessage < ::Struct
-  def ==(expectation); end
-  def args; end
-  def args=(_); end
-  def message; end
-  def message=(_); end
-  def object; end
-  def object=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Mocks::ProxyForNil < ::RSpec::Mocks::PartialDoubleProxy
-  def initialize(order_group); end
-
-  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
-  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
-  def disallow_expectations; end
-  def disallow_expectations=(_arg0); end
-  def warn_about_expectations; end
-  def warn_about_expectations=(_arg0); end
-
-  private
-
-  def raise_error(method_name); end
-  def set_expectation_behavior; end
-  def warn(method_name); end
-  def warn_or_raise!(method_name); end
-end
-
-class RSpec::Mocks::RootSpace
-  def any_instance_proxy_for(*_args); end
-  def any_instance_recorder_for(*_args); end
-  def any_instance_recorders_from_ancestry_of(_object); end
-  def new_scope; end
-  def proxy_for(*_args); end
-  def register_constant_mutator(_mutator); end
-  def registered?(_object); end
-  def reset_all; end
-  def superclass_proxy_for(*_args); end
-  def verify_all; end
-
-  private
-
-  def raise_lifecycle_message; end
-end
-
-class RSpec::Mocks::SimpleMessageExpectation
-  def initialize(message, response, error_generator, backtrace_line = T.unsafe(nil)); end
-
-  def called_max_times?; end
-  def invoke(*_); end
-  def matches?(message, *_); end
-  def unadvise(_); end
-  def verify_messages_received; end
-end
-
-class RSpec::Mocks::Space
-  def initialize; end
-
-  def any_instance_mutex; end
-  def any_instance_proxy_for(klass); end
-  def any_instance_recorder_for(klass, only_return_existing = T.unsafe(nil)); end
-  def any_instance_recorders; end
-  def any_instance_recorders_from_ancestry_of(object); end
-  def constant_mutator_for(name); end
-  def ensure_registered(object); end
-  def new_scope; end
-  def proxies; end
-  def proxies_of(klass); end
-  def proxy_for(object); end
-  def proxy_mutex; end
-  def register_constant_mutator(mutator); end
-  def registered?(object); end
-  def reset_all; end
-  def superclass_proxy_for(klass); end
-  def verify_all; end
-
-  private
-
-  def any_instance_recorder_not_found_for(id, klass); end
-  def class_proxy_with_callback_verification_strategy(object, strategy); end
-  def id_for(object); end
-  def new_mutex; end
-  def proxy_not_found_for(id, object); end
-  def superclass_proxy_not_found_for(id, object); end
-end
-
-class RSpec::Mocks::StubChain < ::RSpec::Mocks::MessageChain
-  private
-
-  def expectation(object, message, &return_block); end
-
-  class << self
-    def stub_chain_on(object, *chain, &blk); end
-  end
-end
-
-module RSpec::Mocks::Syntax
-  class << self
-    def default_should_syntax_host; end
-    def disable_expect(syntax_host = T.unsafe(nil)); end
-    def disable_should(syntax_host = T.unsafe(nil)); end
-    def enable_expect(syntax_host = T.unsafe(nil)); end
-    def enable_should(syntax_host = T.unsafe(nil)); end
-    def expect_enabled?(syntax_host = T.unsafe(nil)); end
-    def should_enabled?(syntax_host = T.unsafe(nil)); end
-    def warn_about_should!; end
-    def warn_unless_should_configured(method_name, replacement = T.unsafe(nil)); end
-  end
-end
-
-class RSpec::Mocks::TargetBase
-  include ::RSpec::Mocks::TargetDelegationInstanceMethods
-  extend ::RSpec::Mocks::TargetDelegationClassMethods
-
-  def initialize(target); end
-end
-
-module RSpec::Mocks::TargetDelegationClassMethods
-  def delegate_not_to(matcher_method, options = T.unsafe(nil)); end
-  def delegate_to(matcher_method); end
-  def disallow_negation(method_name); end
-end
-
-module RSpec::Mocks::TargetDelegationInstanceMethods
-  def target; end
-
-  private
-
-  def define_matcher(matcher, name, &block); end
-  def matcher_allowed?(matcher); end
-  def raise_negation_unsupported(method_name, matcher); end
-  def raise_unsupported_matcher(method_name, matcher); end
-end
-
-module RSpec::Mocks::TestDouble
-  def initialize(name = T.unsafe(nil), stubs = T.unsafe(nil)); end
-
-  def ==(other); end
-  def __build_mock_proxy_unless_expired(order_group); end
-  def __disallow_further_usage!; end
-  def as_null_object; end
-  def freeze; end
-  def inspect; end
-  def null_object?; end
-  def respond_to?(message, incl_private = T.unsafe(nil)); end
-  def to_s; end
-
-  private
-
-  def __build_mock_proxy(order_group); end
-  def __mock_proxy; end
-  def __raise_expired_error; end
-  def assign_stubs(stubs); end
-  def initialize_copy(other); end
-  def method_missing(message, *args, &block); end
-end
-
-module RSpec::Mocks::TestDoubleFormatter
-  class << self
-    def format(dbl, unwrap = T.unsafe(nil)); end
-
-    private
-
-    def name_desc(dbl); end
-    def type_desc(dbl); end
-    def verified_module_desc(dbl); end
-  end
-end
-
-class RSpec::Mocks::TestDoubleProxy < ::RSpec::Mocks::Proxy
-  def reset; end
-end
-
-class RSpec::Mocks::UnsupportedMatcherError < ::StandardError; end
-
-module RSpec::Mocks::VerifyingDouble
-  def initialize(doubled_module, *args); end
-
-  def __send__(name, *args, &block); end
-  def method_missing(message, *args, &block); end
-  def respond_to?(message, include_private = T.unsafe(nil)); end
-  def send(name, *args, &block); end
-end
-
-class RSpec::Mocks::VerifyingDoubleNotDefinedError < ::StandardError; end
-
-class RSpec::Mocks::VerifyingExistingClassNewMethodDouble < ::RSpec::Mocks::VerifyingExistingMethodDouble
-  def with_signature; end
-end
-
-class RSpec::Mocks::VerifyingExistingMethodDouble < ::RSpec::Mocks::VerifyingMethodDouble
-  def initialize(object, method_name, proxy); end
-
-  def unimplemented?; end
-  def with_signature; end
-
-  class << self
-    def for(object, method_name, proxy); end
-  end
-end
-
-class RSpec::Mocks::VerifyingMessageExpectation < ::RSpec::Mocks::MessageExpectation
-  def initialize(*args); end
-
-  def method_reference; end
-  def method_reference=(_arg0); end
-  def with(*args, &block); end
-
-  private
-
-  def validate_expected_arguments!; end
-end
-
-class RSpec::Mocks::VerifyingMethodDouble < ::RSpec::Mocks::MethodDouble
-  def initialize(object, method_name, proxy, method_reference); end
-
-  def add_expectation(*args, &block); end
-  def add_stub(*args, &block); end
-  def message_expectation_class; end
-  def proxy_method_invoked(obj, *args, &block); end
-  def validate_arguments!(actual_args); end
-end
-
-class RSpec::Mocks::VerifyingPartialClassDoubleProxy < ::RSpec::Mocks::VerifyingPartialDoubleProxy
-  include ::RSpec::Mocks::PartialClassDoubleProxyMethods
-end
-
-class RSpec::Mocks::VerifyingPartialDoubleProxy < ::RSpec::Mocks::PartialDoubleProxy
-  include ::RSpec::Mocks::VerifyingProxyMethods
-
-  def initialize(object, expectation_ordering, optional_callback_invocation_strategy = T.unsafe(nil)); end
-
-  def ensure_implemented(_method_name); end
-  def method_reference; end
-end
-
-class RSpec::Mocks::VerifyingProxy < ::RSpec::Mocks::TestDoubleProxy
-  include ::RSpec::Mocks::VerifyingProxyMethods
-
-  def initialize(object, order_group, doubled_module, method_reference_class); end
-
-  def method_reference; end
-  def validate_arguments!(method_name, args); end
-  def visibility_for(method_name); end
-end
-
-module RSpec::Mocks::VerifyingProxyMethods
-  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
-  def add_simple_stub(method_name, *args); end
-  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
-  def ensure_implemented(method_name); end
-  def ensure_publicly_implemented(method_name, _object); end
-end
-
-module RSpec::Mocks::Version; end
-RSpec::Mocks::Version::STRING = T.let(T.unsafe(nil), String)
-RSpec::SharedContext = RSpec::Core::SharedContext
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi
deleted file mode 100644
index cfd169a1b85cb..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi
+++ /dev/null
@@ -1,284 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rspec-retry` gem.
-# Please instead update this file by running `bin/tapioca gem rspec-retry`.
-
-module RSpec
-  extend ::RSpec::Support::Warnings
-  extend ::RSpec::Core::Warnings
-
-  class << self
-    def clear_examples; end
-    def configuration; end
-    def configuration=(_arg0); end
-    def configure; end
-    def const_missing(name); end
-    def context(*args, &example_group_block); end
-    def current_example; end
-    def current_example=(example); end
-    def current_scope; end
-    def current_scope=(scope); end
-    def describe(*args, &example_group_block); end
-    def example_group(*args, &example_group_block); end
-    def fcontext(*args, &example_group_block); end
-    def fdescribe(*args, &example_group_block); end
-    def reset; end
-    def shared_context(name, *args, &block); end
-    def shared_examples(name, *args, &block); end
-    def shared_examples_for(name, *args, &block); end
-    def world; end
-    def world=(_arg0); end
-    def xcontext(*args, &example_group_block); end
-    def xdescribe(*args, &example_group_block); end
-  end
-end
-
-module RSpec::Core
-  class << self
-    def path_to_executable; end
-  end
-end
-
-class RSpec::Core::DeprecationError < ::StandardError; end
-
-class RSpec::Core::Example
-  def initialize(example_group_class, description, user_metadata, example_block = T.unsafe(nil)); end
-
-  def attempts; end
-  def attempts=(_arg0); end
-  def clear_exception; end
-  def clock; end
-  def clock=(_arg0); end
-  def description; end
-  def display_exception; end
-  def display_exception=(ex); end
-  def duplicate_with(metadata_overrides = T.unsafe(nil)); end
-  def example_group; end
-  def example_group_instance; end
-  def exception; end
-  def execution_result; end
-  def fail_with_exception(reporter, exception); end
-  def file_path; end
-  def full_description; end
-  def id; end
-  def inspect; end
-  def inspect_output; end
-  def instance_exec(*args, &block); end
-  def location; end
-  def location_rerun_argument; end
-  def metadata; end
-  def pending; end
-  def pending?; end
-  def reporter; end
-  def rerun_argument; end
-  def run(example_group_instance, reporter); end
-  def set_aggregate_failures_exception(exception); end
-  def set_exception(exception); end
-  def skip; end
-  def skip_with_exception(reporter, exception); end
-  def skipped?; end
-  def to_s; end
-  def update_inherited_metadata(updates); end
-
-  private
-
-  def assign_generated_description; end
-  def finish(reporter); end
-  def generate_description; end
-  def hooks; end
-  def location_description; end
-  def mocks_need_verification?; end
-  def record_finished(status, reporter); end
-  def run_after_example; end
-  def run_before_example; end
-  def start(reporter); end
-  def verify_mocks; end
-  def with_around_and_singleton_context_hooks; end
-  def with_around_example_hooks; end
-
-  class << self
-    def delegate_to_metadata(key); end
-    def parse_id(id); end
-  end
-end
-
-RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
-
-class RSpec::Core::Example::Procsy
-  def initialize(example, &block); end
-
-  def <<(*a, &b); end
-  def ===(*a, &b); end
-  def >>(*a, &b); end
-  def [](*a, &b); end
-  def arity(*a, &b); end
-  def attempts; end
-  def binding(*a, &b); end
-  def call(*args, &block); end
-  def clock(*a, &b); end
-  def clock=(*a, &b); end
-  def clone(*a, &b); end
-  def curry(*a, &b); end
-  def description(*a, &b); end
-  def dup(*a, &b); end
-  def duplicate_with(*a, &b); end
-  def example; end
-  def example_group(*a, &b); end
-  def example_group_instance(*a, &b); end
-  def exception(*a, &b); end
-  def executed?; end
-  def execution_result(*a, &b); end
-  def file_path(*a, &b); end
-  def full_description(*a, &b); end
-  def hash(*a, &b); end
-  def id(*a, &b); end
-  def inspect; end
-  def inspect_output(*a, &b); end
-  def lambda?(*a, &b); end
-  def location(*a, &b); end
-  def location_rerun_argument(*a, &b); end
-  def metadata(*a, &b); end
-  def parameters(*a, &b); end
-  def pending(*a, &b); end
-  def pending?(*a, &b); end
-  def reporter(*a, &b); end
-  def rerun_argument(*a, &b); end
-  def run(*args, &block); end
-  def run_with_retry(opts = T.unsafe(nil)); end
-  def skip(*a, &b); end
-  def skipped?(*a, &b); end
-  def source_location(*a, &b); end
-  def to_proc; end
-  def update_inherited_metadata(*a, &b); end
-  def wrap(&block); end
-  def yield(*a, &b); end
-end
-
-class RSpec::Core::ExampleGroup
-  include ::RSpec::Core::MemoizedHelpers
-  include ::RSpec::Core::Pending
-  extend ::RSpec::Core::Hooks
-  extend ::RSpec::Core::MemoizedHelpers::ClassMethods
-  extend ::RSpec::Core::SharedExampleGroup
-
-  def initialize(inspect_output = T.unsafe(nil)); end
-
-  def clear_lets; end
-  def clear_memoized; end
-  def described_class; end
-  def inspect; end
-
-  private
-
-  def method_missing(name, *args); end
-
-  class << self
-    def add_example(example); end
-    def before_context_ivars; end
-    def children; end
-    def context(*args, &example_group_block); end
-    def currently_executing_a_context_hook?; end
-    def declaration_locations; end
-    def define_example_group_method(name, metadata = T.unsafe(nil)); end
-    def define_example_method(name, extra_options = T.unsafe(nil)); end
-    def define_nested_shared_group_method(new_name, report_label = T.unsafe(nil)); end
-    def delegate_to_metadata(*names); end
-    def descendant_filtered_examples; end
-    def descendants; end
-    def describe(*args, &example_group_block); end
-    def described_class; end
-    def description; end
-    def each_instance_variable_for_example(group); end
-    def ensure_example_groups_are_configured; end
-    def example(*all_args, &block); end
-    def example_group(*args, &example_group_block); end
-    def examples; end
-    def fcontext(*args, &example_group_block); end
-    def fdescribe(*args, &example_group_block); end
-    def fexample(*all_args, &block); end
-    def file_path; end
-    def filtered_examples; end
-    def find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end
-    def fit(*all_args, &block); end
-    def focus(*all_args, &block); end
-    def for_filtered_examples(reporter, &block); end
-    def fspecify(*all_args, &block); end
-    def id; end
-    def idempotently_define_singleton_method(name, &definition); end
-    def include_context(name, *args, &block); end
-    def include_examples(name, *args, &block); end
-    def it(*all_args, &block); end
-    def it_behaves_like(name, *args, &customization_block); end
-    def it_should_behave_like(name, *args, &customization_block); end
-    def location; end
-    def metadata; end
-    def next_runnable_index_for(file); end
-    def ordering_strategy; end
-    def parent_groups; end
-    def pending(*all_args, &block); end
-    def remove_example(example); end
-    def reset_memoized; end
-    def run(reporter = T.unsafe(nil)); end
-    def run_after_context_hooks(example_group_instance); end
-    def run_before_context_hooks(example_group_instance); end
-    def run_examples(reporter); end
-    def set_it_up(description, args, registration_collection, &example_group_block); end
-    def set_ivars(instance, ivars); end
-    def skip(*all_args, &block); end
-    def specify(*all_args, &block); end
-    def store_before_context_ivars(example_group_instance); end
-    def subclass(parent, description, args, registration_collection, &example_group_block); end
-    def superclass_before_context_ivars; end
-    def superclass_metadata; end
-    def top_level?; end
-    def top_level_description; end
-    def traverse_tree_until(&block); end
-    def update_inherited_metadata(updates); end
-    def with_replaced_metadata(meta); end
-    def xcontext(*args, &example_group_block); end
-    def xdescribe(*args, &example_group_block); end
-    def xexample(*all_args, &block); end
-    def xit(*all_args, &block); end
-    def xspecify(*all_args, &block); end
-
-    private
-
-    def method_missing(name, *args); end
-  end
-end
-
-RSpec::Core::ExampleGroup::INSTANCE_VARIABLE_TO_IGNORE = T.let(T.unsafe(nil), Symbol)
-class RSpec::Core::ExampleGroup::WrongScopeError < ::NoMethodError; end
-RSpec::Core::ExclusionRules = RSpec::Core::FilterRules
-RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
-
-class RSpec::Retry
-  def initialize(ex, opts = T.unsafe(nil)); end
-
-  def attempts; end
-  def attempts=(val); end
-  def clear_lets; end
-  def context; end
-  def current_example; end
-  def display_try_failure_messages?; end
-  def ex; end
-  def exceptions_to_hard_fail; end
-  def exceptions_to_retry; end
-  def retry_count; end
-  def run; end
-  def sleep_interval; end
-  def verbose_retry?; end
-
-  private
-
-  def exception_exists_in?(list, exception); end
-  def ordinalize(number); end
-
-  class << self
-    def setup; end
-  end
-end
-
-RSpec::Retry::VERSION = T.let(T.unsafe(nil), String)
-RSpec::SharedContext = RSpec::Core::SharedContext
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.8.3.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.8.3.rbi
deleted file mode 100644
index e0a60bf71f7db..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.8.3.rbi
+++ /dev/null
@@ -1,59 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rspec-sorbet` gem.
-# Please instead update this file by running `bin/tapioca gem rspec-sorbet`.
-
-module RSpec
-  extend ::RSpec::Support::Warnings
-  extend ::RSpec::Core::Warnings
-
-  class << self
-    def clear_examples; end
-    def configuration; end
-    def configuration=(_arg0); end
-    def configure; end
-    def const_missing(name); end
-    def context(*args, &example_group_block); end
-    def current_example; end
-    def current_example=(example); end
-    def current_scope; end
-    def current_scope=(scope); end
-    def describe(*args, &example_group_block); end
-    def example_group(*args, &example_group_block); end
-    def fcontext(*args, &example_group_block); end
-    def fdescribe(*args, &example_group_block); end
-    def reset; end
-    def shared_context(name, *args, &block); end
-    def shared_examples(name, *args, &block); end
-    def shared_examples_for(name, *args, &block); end
-    def world; end
-    def world=(_arg0); end
-    def xcontext(*args, &example_group_block); end
-    def xdescribe(*args, &example_group_block); end
-  end
-end
-
-RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
-RSpec::SharedContext = RSpec::Core::SharedContext
-
-module RSpec::Sorbet
-  extend ::RSpec::Sorbet::Doubles
-end
-
-module RSpec::Sorbet::Doubles
-  def allow_doubles!; end
-  def allow_instance_doubles!; end
-
-  private
-
-  def call_validation_error_handler(_signature, opts); end
-  def double_message_with_ellipsis?(message); end
-  def inline_type_error_handler(error); end
-  def typed_array_message?(message); end
-  def unable_to_check_type_for_message?(message); end
-end
-
-RSpec::Sorbet::Doubles::INLINE_DOUBLE_REGEX = T.let(T.unsafe(nil), Regexp)
-RSpec::Sorbet::Doubles::TYPED_ARRAY_MESSAGE = T.let(T.unsafe(nil), Regexp)
-RSpec::Sorbet::Doubles::VERIFYING_DOUBLE_OR_DOUBLE = T.let(T.unsafe(nil), Regexp)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.9.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.9.2.rbi
new file mode 100644
index 0000000000000..095907b67c970
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.9.2.rbi
@@ -0,0 +1,163 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rspec-sorbet` gem.
+# Please instead update this file by running `bin/tapioca gem rspec-sorbet`.
+
+# source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#6
+module RSpec
+  class << self
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#70
+    def clear_examples; end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#85
+    def configuration; end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#49
+    def configuration=(_arg0); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#97
+    def configure; end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#194
+    def const_missing(name); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42
+    def context(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#122
+    def current_example; end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#128
+    def current_example=(example); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#154
+    def current_scope; end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#134
+    def current_scope=(scope); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42
+    def describe(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42
+    def example_group(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42
+    def fcontext(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42
+    def fdescribe(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#58
+    def reset; end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110
+    def shared_context(name, *args, &block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110
+    def shared_examples(name, *args, &block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110
+    def shared_examples_for(name, *args, &block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#160
+    def world; end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#49
+    def world=(_arg0); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42
+    def xcontext(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42
+    def xdescribe(*args, &example_group_block); end
+  end
+end
+
+# source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#7
+module RSpec::Sorbet
+  extend ::RSpec::Sorbet::Doubles
+end
+
+# source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#8
+module RSpec::Sorbet::Doubles
+  requires_ancestor { Kernel }
+
+  # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#15
+  sig { void }
+  def allow_doubles!; end
+
+  # @return [void]
+  #
+  # source://sorbet-runtime/0.5.11258/lib/types/private/methods/_methods.rb#257
+  def allow_instance_doubles!(*args, **_arg1, &blk); end
+
+  # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#36
+  sig { params(clear_existing: T::Boolean).void }
+  def reset!(clear_existing: T.unsafe(nil)); end
+
+  private
+
+  # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#139
+  sig { params(signature: T.untyped, opts: T::Hash[T.untyped, T.untyped]).void }
+  def call_validation_error_handler(signature, opts); end
+
+  # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#65
+  sig { returns(T.nilable(T::Boolean)) }
+  def configured; end
+
+  # @return [Boolean, nil]
+  #
+  # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#65
+  def configured=(_arg0); end
+
+  # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#127
+  sig { params(message: ::String).returns(T::Boolean) }
+  def double_message_with_ellipsis?(message); end
+
+  # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#62
+  sig { returns(T.nilable(T.proc.params(signature: T.untyped, opts: T::Hash[T.untyped, T.untyped]).void)) }
+  def existing_call_validation_error_handler; end
+
+  # @return [T.proc.params(signature: T.untyped, opts: T::Hash[T.untyped, T.untyped]).void, nil]
+  #
+  # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#62
+  def existing_call_validation_error_handler=(_arg0); end
+
+  # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#59
+  sig { returns(T.nilable(T.proc.params(signature: ::Exception).void)) }
+  def existing_inline_type_error_handler; end
+
+  # @return [T.proc.params(signature: Exception).void, nil]
+  #
+  # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#59
+  def existing_inline_type_error_handler=(_arg0); end
+
+  # @raise [TypeError]
+  #
+  # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#73
+  sig { params(signature: T.untyped, opts: T.untyped).void }
+  def handle_call_validation_error(signature, opts); end
+
+  # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#80
+  sig { params(error: ::Exception).void }
+  def inline_type_error_handler(error); end
+
+  # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#134
+  sig { params(message: ::String).returns(T::Boolean) }
+  def typed_array_message?(message); end
+
+  # source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#118
+  sig { params(message: ::String).returns(T::Boolean) }
+  def unable_to_check_type_for_message?(message); end
+end
+
+# source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#68
+RSpec::Sorbet::Doubles::INLINE_DOUBLE_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#131
+RSpec::Sorbet::Doubles::TYPED_ARRAY_MESSAGE = T.let(T.unsafe(nil), Regexp)
+
+# source://rspec-sorbet//lib/rspec/sorbet/doubles.rb#123
+RSpec::Sorbet::Doubles::VERIFYING_DOUBLE_OR_DOUBLE = T.let(T.unsafe(nil), Regexp)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.11.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.11.0.rbi
deleted file mode 100644
index 71f0c8571a538..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.11.0.rbi
+++ /dev/null
@@ -1,511 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rspec-support` gem.
-# Please instead update this file by running `bin/tapioca gem rspec-support`.
-
-module RSpec
-  extend ::RSpec::Support::Warnings
-  extend ::RSpec::Core::Warnings
-
-  class << self
-    def clear_examples; end
-    def configuration; end
-    def configuration=(_arg0); end
-    def configure; end
-    def const_missing(name); end
-    def context(*args, &example_group_block); end
-    def current_example; end
-    def current_example=(example); end
-    def current_scope; end
-    def current_scope=(scope); end
-    def describe(*args, &example_group_block); end
-    def example_group(*args, &example_group_block); end
-    def fcontext(*args, &example_group_block); end
-    def fdescribe(*args, &example_group_block); end
-    def reset; end
-    def shared_context(name, *args, &block); end
-    def shared_examples(name, *args, &block); end
-    def shared_examples_for(name, *args, &block); end
-    def world; end
-    def world=(_arg0); end
-    def xcontext(*args, &example_group_block); end
-    def xdescribe(*args, &example_group_block); end
-  end
-end
-
-class RSpec::CallerFilter
-  class << self
-    def first_non_rspec_line(skip_frames = T.unsafe(nil), increment = T.unsafe(nil)); end
-  end
-end
-
-RSpec::CallerFilter::ADDITIONAL_TOP_LEVEL_FILES = T.let(T.unsafe(nil), Array)
-RSpec::CallerFilter::IGNORE_REGEX = T.let(T.unsafe(nil), Regexp)
-RSpec::CallerFilter::LIB_REGEX = T.let(T.unsafe(nil), Regexp)
-RSpec::CallerFilter::RSPEC_LIBS = T.let(T.unsafe(nil), Array)
-RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
-RSpec::SharedContext = RSpec::Core::SharedContext
-
-module RSpec::Support
-  class << self
-    def class_of(object); end
-    def define_optimized_require_for_rspec(lib, &require_relative); end
-    def deregister_matcher_definition(&block); end
-    def failure_notifier; end
-    def failure_notifier=(callable); end
-    def is_a_matcher?(object); end
-    def matcher_definitions; end
-    def method_handle_for(object, method_name); end
-    def notify_failure(failure, options = T.unsafe(nil)); end
-    def register_matcher_definition(&block); end
-    def require_rspec_core(f); end
-    def require_rspec_expectations(f); end
-    def require_rspec_matchers(f); end
-    def require_rspec_mocks(f); end
-    def require_rspec_support(f); end
-    def rspec_description_for_object(object); end
-    def thread_local_data; end
-    def warning_notifier; end
-    def warning_notifier=(_arg0); end
-    def with_failure_notifier(callable); end
-  end
-end
-
-module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
-  class << self
-    def ===(exception); end
-  end
-end
-
-RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue::AVOID_RESCUING = T.let(T.unsafe(nil), Array)
-
-class RSpec::Support::BlockSignature < ::RSpec::Support::MethodSignature
-  def classify_parameters; end
-end
-
-class RSpec::Support::ComparableVersion
-  include ::Comparable
-
-  def initialize(string); end
-
-  def <=>(other); end
-  def segments; end
-  def string; end
-end
-
-RSpec::Support::DEFAULT_FAILURE_NOTIFIER = T.let(T.unsafe(nil), Proc)
-RSpec::Support::DEFAULT_WARNING_NOTIFIER = T.let(T.unsafe(nil), Proc)
-
-class RSpec::Support::Differ
-  def initialize(opts = T.unsafe(nil)); end
-
-  def color?; end
-  def diff(actual, expected); end
-  def diff_as_object(actual, expected); end
-  def diff_as_string(actual, expected); end
-
-  private
-
-  def add_old_hunk_to_hunk(hunk, oldhunk); end
-  def add_to_output(output, string); end
-  def all_strings?(*args); end
-  def any_multiline_strings?(*args); end
-  def blue(text); end
-  def build_hunks(actual, expected); end
-  def coerce_to_string(string_or_array); end
-  def color(text, color_code); end
-  def color_diff(diff); end
-  def diffably_stringify(array); end
-  def finalize_output(output, final_line); end
-  def format_type; end
-  def green(text); end
-  def handle_encoding_errors(actual, expected); end
-  def hash_to_string(hash); end
-  def multiline?(string); end
-  def no_numbers?(*args); end
-  def no_procs?(*args); end
-  def normal(text); end
-  def object_to_string(object); end
-  def red(text); end
-  def safely_flatten(array); end
-end
-
-class RSpec::Support::DirectoryMaker
-  class << self
-    def mkdir_p(path); end
-
-    private
-
-    def directory_exists?(dirname); end
-    def generate_path(stack, part); end
-    def generate_stack(path); end
-  end
-end
-
-class RSpec::Support::EncodedString
-  def initialize(string, encoding = T.unsafe(nil)); end
-
-  def <<(string); end
-  def ==(*args, &block); end
-  def empty?(*args, &block); end
-  def encoding(*args, &block); end
-  def eql?(*args, &block); end
-  def lines(*args, &block); end
-  def source_encoding; end
-  def split(regex_or_string); end
-  def to_s; end
-  def to_str; end
-
-  private
-
-  def detect_source_encoding(string); end
-  def matching_encoding(string); end
-  def remove_invalid_bytes(string); end
-
-  class << self
-    def pick_encoding(source_a, source_b); end
-  end
-end
-
-RSpec::Support::EncodedString::REPLACE = T.let(T.unsafe(nil), String)
-RSpec::Support::EncodedString::US_ASCII = T.let(T.unsafe(nil), String)
-RSpec::Support::EncodedString::UTF_8 = T.let(T.unsafe(nil), String)
-
-module RSpec::Support::FuzzyMatcher
-  class << self
-    def values_match?(expected, actual); end
-
-    private
-
-    def arrays_match?(expected_list, actual_list); end
-    def hashes_match?(expected_hash, actual_hash); end
-  end
-end
-
-class RSpec::Support::HunkGenerator
-  def initialize(actual, expected); end
-
-  def hunks; end
-
-  private
-
-  def actual_lines; end
-  def build_hunk(piece); end
-  def context_lines; end
-  def diffs; end
-  def expected_lines; end
-end
-
-RSpec::Support::KERNEL_METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-class RSpec::Support::LooseSignatureVerifier < ::RSpec::Support::MethodSignatureVerifier
-  private
-
-  def split_args(*args); end
-end
-
-class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher
-  def initialize(signature); end
-
-  def has_kw_args_in?(args); end
-  def invalid_kw_args_from(_kw_args); end
-  def missing_kw_args_from(_kw_args); end
-  def non_kw_args_arity_description; end
-  def valid_non_kw_args?(*args); end
-end
-
-class RSpec::Support::MethodSignature
-  def initialize(method); end
-
-  def arbitrary_kw_args?; end
-  def classify_arity(arity = T.unsafe(nil)); end
-  def classify_parameters; end
-  def could_contain_kw_args?(args); end
-  def description; end
-  def has_kw_args_in?(args); end
-  def invalid_kw_args_from(given_kw_args); end
-  def max_non_kw_args; end
-  def min_non_kw_args; end
-  def missing_kw_args_from(given_kw_args); end
-  def non_kw_args_arity_description; end
-  def optional_kw_args; end
-  def required_kw_args; end
-  def unlimited_args?; end
-  def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = T.unsafe(nil)); end
-end
-
-RSpec::Support::MethodSignature::INFINITY = T.let(T.unsafe(nil), Float)
-
-class RSpec::Support::MethodSignatureExpectation
-  def initialize; end
-
-  def empty?; end
-  def expect_arbitrary_keywords; end
-  def expect_arbitrary_keywords=(_arg0); end
-  def expect_unlimited_arguments; end
-  def expect_unlimited_arguments=(_arg0); end
-  def keywords; end
-  def keywords=(values); end
-  def max_count; end
-  def max_count=(number); end
-  def min_count; end
-  def min_count=(number); end
-end
-
-class RSpec::Support::MethodSignatureVerifier
-  def initialize(signature, args = T.unsafe(nil)); end
-
-  def error_message; end
-  def kw_args; end
-  def max_non_kw_args; end
-  def min_non_kw_args; end
-  def non_kw_args; end
-  def valid?; end
-  def with_expectation(expectation); end
-
-  private
-
-  def arbitrary_kw_args?; end
-  def invalid_kw_args; end
-  def missing_kw_args; end
-  def split_args(*args); end
-  def unlimited_args?; end
-  def valid_non_kw_args?; end
-end
-
-class RSpec::Support::Mutex < ::Thread::Mutex
-  class << self
-    def new; end
-  end
-end
-
-RSpec::Support::Mutex::NEW_MUTEX_METHOD = T.let(T.unsafe(nil), Method)
-
-module RSpec::Support::OS
-  private
-
-  def windows?; end
-  def windows_file_path?; end
-
-  class << self
-    def windows?; end
-    def windows_file_path?; end
-  end
-end
-
-class RSpec::Support::ObjectFormatter
-  def initialize(max_formatted_output_length = T.unsafe(nil)); end
-
-  def format(object); end
-  def max_formatted_output_length; end
-  def max_formatted_output_length=(_arg0); end
-  def prepare_array(array); end
-  def prepare_element(element); end
-  def prepare_for_inspection(object); end
-  def prepare_hash(input_hash); end
-  def recursive_structure?(object); end
-  def sort_hash_keys(input_hash); end
-  def with_entering_structure(structure); end
-
-  private
-
-  def truncate_string(str, start_index, end_index); end
-
-  class << self
-    def default_instance; end
-    def format(object); end
-    def prepare_for_inspection(object); end
-  end
-end
-
-class RSpec::Support::ObjectFormatter::BaseInspector < ::Struct
-  def formatter; end
-  def formatter=(_); end
-  def inspect; end
-  def object; end
-  def object=(_); end
-  def pretty_print(pp); end
-
-  class << self
-    def [](*_arg0); end
-    def can_inspect?(_object); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Support::ObjectFormatter::BigDecimalInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
-  def inspect; end
-
-  class << self
-    def can_inspect?(object); end
-  end
-end
-
-class RSpec::Support::ObjectFormatter::DateTimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
-  def inspect; end
-
-  class << self
-    def can_inspect?(object); end
-  end
-end
-
-RSpec::Support::ObjectFormatter::DateTimeInspector::FORMAT = T.let(T.unsafe(nil), String)
-
-class RSpec::Support::ObjectFormatter::DelegatorInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
-  def inspect; end
-
-  class << self
-    def can_inspect?(object); end
-  end
-end
-
-class RSpec::Support::ObjectFormatter::DescribableMatcherInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
-  def inspect; end
-
-  class << self
-    def can_inspect?(object); end
-  end
-end
-
-RSpec::Support::ObjectFormatter::ELLIPSIS = T.let(T.unsafe(nil), String)
-RSpec::Support::ObjectFormatter::INSPECTOR_CLASSES = T.let(T.unsafe(nil), Array)
-
-class RSpec::Support::ObjectFormatter::InspectableItem < ::Struct
-  def inspect; end
-  def pretty_print(pp); end
-  def text; end
-  def text=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RSpec::Support::ObjectFormatter::InspectableObjectInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
-  def inspect; end
-
-  class << self
-    def can_inspect?(object); end
-  end
-end
-
-class RSpec::Support::ObjectFormatter::TimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
-  def inspect; end
-
-  class << self
-    def can_inspect?(object); end
-  end
-end
-
-RSpec::Support::ObjectFormatter::TimeInspector::FORMAT = T.let(T.unsafe(nil), String)
-
-class RSpec::Support::ObjectFormatter::UninspectableObjectInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
-  def inspect; end
-  def klass; end
-  def native_object_id; end
-
-  class << self
-    def can_inspect?(object); end
-  end
-end
-
-RSpec::Support::ObjectFormatter::UninspectableObjectInspector::OBJECT_ID_FORMAT = T.let(T.unsafe(nil), String)
-
-module RSpec::Support::RecursiveConstMethods
-  def const_defined_on?(mod, const_name); end
-  def constants_defined_on(mod); end
-  def get_const_defined_on(mod, const_name); end
-  def normalize_const_name(const_name); end
-  def recursive_const_defined?(const_name); end
-  def recursive_const_get(const_name); end
-end
-
-class RSpec::Support::ReentrantMutex
-  def initialize; end
-
-  def synchronize; end
-
-  private
-
-  def enter; end
-  def exit; end
-end
-
-module RSpec::Support::Ruby
-  private
-
-  def jruby?; end
-  def jruby_9000?; end
-  def jruby_version; end
-  def mri?; end
-  def non_mri?; end
-  def rbx?; end
-  def truffleruby?; end
-
-  class << self
-    def jruby?; end
-    def jruby_9000?; end
-    def jruby_version; end
-    def mri?; end
-    def non_mri?; end
-    def rbx?; end
-    def truffleruby?; end
-  end
-end
-
-module RSpec::Support::RubyFeatures
-  private
-
-  def caller_locations_supported?; end
-  def fork_supported?; end
-  def kw_args_supported?; end
-  def module_prepends_supported?; end
-  def module_refinement_supported?; end
-  def optional_and_splat_args_supported?; end
-  def required_kw_args_supported?; end
-  def ripper_supported?; end
-  def supports_exception_cause?; end
-  def supports_rebinding_module_methods?; end
-  def supports_taint?; end
-
-  class << self
-    def caller_locations_supported?; end
-    def fork_supported?; end
-    def kw_args_supported?; end
-    def module_prepends_supported?; end
-    def module_refinement_supported?; end
-    def optional_and_splat_args_supported?; end
-    def required_kw_args_supported?; end
-    def ripper_supported?; end
-    def supports_exception_cause?; end
-    def supports_rebinding_module_methods?; end
-    def supports_taint?; end
-  end
-end
-
-RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier
-module RSpec::Support::Version; end
-RSpec::Support::Version::STRING = T.let(T.unsafe(nil), String)
-
-module RSpec::Support::Warnings
-  def deprecate(deprecated, options = T.unsafe(nil)); end
-  def warn_deprecation(message, options = T.unsafe(nil)); end
-  def warn_with(message, options = T.unsafe(nil)); end
-  def warning(text, options = T.unsafe(nil)); end
-end
-
-module RSpec::Support::WithKeywordsWhenNeeded
-  private
-
-  def class_exec(klass, *args, &block); end
-
-  class << self
-    def class_exec(klass, *args, &block); end
-  end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.13.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.13.1.rbi
new file mode 100644
index 0000000000000..347082dfbd009
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.13.1.rbi
@@ -0,0 +1,1667 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rspec-support` gem.
+# Please instead update this file by running `bin/tapioca gem rspec-support`.
+
+# source://rspec-support//lib/rspec/support.rb#3
+module RSpec
+  extend ::RSpec::Support::Warnings
+
+  class << self
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#70
+    def clear_examples; end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#85
+    def configuration; end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#49
+    def configuration=(_arg0); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#97
+    def configure; end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#194
+    def const_missing(name); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42
+    def context(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#122
+    def current_example; end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#128
+    def current_example=(example); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#154
+    def current_scope; end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#134
+    def current_scope=(scope); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42
+    def describe(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42
+    def example_group(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42
+    def fcontext(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42
+    def fdescribe(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#58
+    def reset; end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110
+    def shared_context(name, *args, &block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110
+    def shared_examples(name, *args, &block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/shared_example_group.rb#110
+    def shared_examples_for(name, *args, &block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#160
+    def world; end
+
+    # source://rspec-core/3.13.0/lib/rspec/core.rb#49
+    def world=(_arg0); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42
+    def xcontext(*args, &example_group_block); end
+
+    # source://rspec-core/3.13.0/lib/rspec/core/dsl.rb#42
+    def xdescribe(*args, &example_group_block); end
+  end
+end
+
+# Consistent implementation for "cleaning" the caller method to strip out
+# non-rspec lines. This enables errors to be reported at the call site in
+# the code using the library, which is far more useful than the particular
+# internal method that raised an error.
+#
+# source://rspec-support//lib/rspec/support/caller_filter.rb#10
+class RSpec::CallerFilter
+  class << self
+    # Earlier rubies do not support the two argument form of `caller`. This
+    # fallback is logically the same, but slower.
+    #
+    # source://rspec-support//lib/rspec/support/caller_filter.rb#49
+    def first_non_rspec_line(skip_frames = T.unsafe(nil), increment = T.unsafe(nil)); end
+  end
+end
+
+# source://rspec-support//lib/rspec/support/caller_filter.rb#20
+RSpec::CallerFilter::ADDITIONAL_TOP_LEVEL_FILES = T.let(T.unsafe(nil), Array)
+
+# rubygems/core_ext/kernel_require.rb isn't actually part of rspec (obviously) but we want
+# it ignored when we are looking for the first meaningful line of the backtrace outside
+# of RSpec. It can show up in the backtrace as the immediate first caller
+# when `CallerFilter.first_non_rspec_line` is called from the top level of a required
+# file, but it depends on if rubygems is loaded or not. We don't want to have to deal
+# with this complexity in our `RSpec.deprecate` calls, so we ignore it here.
+#
+# source://rspec-support//lib/rspec/support/caller_filter.rb#30
+RSpec::CallerFilter::IGNORE_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://rspec-support//lib/rspec/support/caller_filter.rb#22
+RSpec::CallerFilter::LIB_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://rspec-support//lib/rspec/support/caller_filter.rb#11
+RSpec::CallerFilter::RSPEC_LIBS = T.let(T.unsafe(nil), Array)
+
+# source://rspec-support//lib/rspec/support.rb#4
+module RSpec::Support
+  class << self
+    # Used internally to get a class of a given object, even if it does not respond to #class.
+    #
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support.rb#86
+    def class_of(object); end
+
+    # Defines a helper method that is optimized to require files from the
+    # named lib. The passed block MUST be `{ |f| require_relative f }`
+    # because for `require_relative` to work properly from within the named
+    # lib the line of code must be IN that lib.
+    #
+    # `require_relative` is preferred when available because it is always O(1),
+    # regardless of the number of dirs in $LOAD_PATH. `require`, on the other
+    # hand, does a linear O(N) search over the dirs in the $LOAD_PATH until
+    # it can resolve the file relative to one of the dirs.
+    #
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support.rb#16
+    def define_optimized_require_for_rspec(lib, &require_relative); end
+
+    # Remove a previously registered matcher. Useful for cleaning up after
+    # yourself in specs.
+    #
+    # @private
+    #
+    # source://rspec-support//lib/rspec/support/matcher_definition.rb#24
+    def deregister_matcher_definition(&block); end
+
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support.rb#113
+    def failure_notifier; end
+
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support.rb#105
+    def failure_notifier=(callable); end
+
+    # @private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/matcher_definition.rb#29
+    def is_a_matcher?(object); end
+
+    # @private
+    #
+    # source://rspec-support//lib/rspec/support/matcher_definition.rb#6
+    def matcher_definitions; end
+
+    # source://rspec-support//lib/rspec/support.rb#54
+    def method_handle_for(object, method_name); end
+
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support.rb#118
+    def notify_failure(failure, options = T.unsafe(nil)); end
+
+    # Used internally to break cyclic dependency between mocks, expectations,
+    # and support. We don't currently have a consistent implementation of our
+    # matchers, though we are considering changing that:
+    # https://github.com/rspec/rspec-mocks/issues/513
+    #
+    # @private
+    #
+    # source://rspec-support//lib/rspec/support/matcher_definition.rb#16
+    def register_matcher_definition(&block); end
+
+    # source://rspec-support//lib/rspec/support.rb#25
+    def require_rspec_core(f); end
+
+    # source://rspec-support//lib/rspec/support.rb#25
+    def require_rspec_expectations(f); end
+
+    # source://rspec-support//lib/rspec/support.rb#25
+    def require_rspec_matchers(f); end
+
+    # source://rspec-support//lib/rspec/support.rb#25
+    def require_rspec_mocks(f); end
+
+    # source://rspec-support//lib/rspec/support.rb#25
+    def require_rspec_support(f); end
+
+    # gives a string representation of an object for use in RSpec descriptions
+    #
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support/matcher_definition.rb#36
+    def rspec_description_for_object(object); end
+
+    # source://rspec-support//lib/rspec/support.rb#95
+    def thread_local_data; end
+
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support.rb#140
+    def warning_notifier; end
+
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support.rb#133
+    def warning_notifier=(_arg0); end
+
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support.rb#123
+    def with_failure_notifier(callable); end
+  end
+end
+
+# @private
+#
+# source://rspec-support//lib/rspec/support.rb#145
+module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
+  class << self
+    # source://rspec-support//lib/rspec/support.rb#150
+    def ===(exception); end
+  end
+end
+
+# These exceptions are dangerous to rescue as rescuing them
+# would interfere with things we should not interfere with.
+#
+# source://rspec-support//lib/rspec/support.rb#148
+RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue::AVOID_RESCUING = T.let(T.unsafe(nil), Array)
+
+# Deals with the slightly different semantics of block arguments.
+# For methods, arguments are required unless a default value is provided.
+# For blocks, arguments are optional, even if no default value is provided.
+#
+# However, we want to treat block args as required since you virtually
+# always want to pass a value for each received argument and our
+# `and_yield` has treated block args as required for many years.
+#
+# @api private
+#
+# source://rspec-support//lib/rspec/support/method_signature_verifier.rb#268
+class RSpec::Support::BlockSignature < ::RSpec::Support::MethodSignature
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#270
+  def classify_parameters; end
+end
+
+# @private
+#
+# source://rspec-support//lib/rspec/support/comparable_version.rb#6
+class RSpec::Support::ComparableVersion
+  include ::Comparable
+
+  # @return [ComparableVersion] a new instance of ComparableVersion
+  #
+  # source://rspec-support//lib/rspec/support/comparable_version.rb#11
+  def initialize(string); end
+
+  # source://rspec-support//lib/rspec/support/comparable_version.rb#15
+  def <=>(other); end
+
+  # source://rspec-support//lib/rspec/support/comparable_version.rb#37
+  def segments; end
+
+  # Returns the value of attribute string.
+  #
+  # source://rspec-support//lib/rspec/support/comparable_version.rb#9
+  def string; end
+end
+
+# @private
+#
+# source://rspec-support//lib/rspec/support.rb#110
+RSpec::Support::DEFAULT_FAILURE_NOTIFIER = T.let(T.unsafe(nil), Proc)
+
+# @private
+#
+# source://rspec-support//lib/rspec/support.rb#137
+RSpec::Support::DEFAULT_WARNING_NOTIFIER = T.let(T.unsafe(nil), Proc)
+
+# source://rspec-support//lib/rspec/support/differ.rb#12
+class RSpec::Support::Differ
+  # @return [Differ] a new instance of Differ
+  #
+  # source://rspec-support//lib/rspec/support/differ.rb#69
+  def initialize(opts = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/differ.rb#65
+  def color?; end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#13
+  def diff(actual, expected); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#59
+  def diff_as_object(actual, expected); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#30
+  def diff_as_string(actual, expected); end
+
+  private
+
+  # source://rspec-support//lib/rspec/support/differ.rb#130
+  def add_old_hunk_to_hunk(hunk, oldhunk); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#126
+  def add_to_output(output, string); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/differ.rb#80
+  def all_strings?(*args); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/differ.rb#84
+  def any_multiline_strings?(*args); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#155
+  def blue(text); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#117
+  def build_hunks(actual, expected); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#92
+  def coerce_to_string(string_or_array); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#143
+  def color(text, color_code); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#163
+  def color_diff(diff); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#97
+  def diffably_stringify(array); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#121
+  def finalize_output(output, final_line); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#139
+  def format_type; end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#151
+  def green(text); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#204
+  def handle_encoding_errors(actual, expected); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#194
+  def hash_to_string(hash); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/differ.rb#108
+  def multiline?(string); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/differ.rb#88
+  def no_numbers?(*args); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/differ.rb#76
+  def no_procs?(*args); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#159
+  def normal(text); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#180
+  def object_to_string(object); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#147
+  def red(text); end
+
+  # source://rspec-support//lib/rspec/support/differ.rb#134
+  def safely_flatten(array); end
+end
+
+# Replacement for fileutils#mkdir_p because we don't want to require parts
+# of stdlib in RSpec.
+#
+# @api private
+#
+# source://rspec-support//lib/rspec/support/directory_maker.rb#11
+class RSpec::Support::DirectoryMaker
+  class << self
+    # Implements nested directory construction
+    #
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support/directory_maker.rb#15
+    def mkdir_p(path); end
+
+    private
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/directory_maker.rb#57
+    def directory_exists?(dirname); end
+
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support/directory_maker.rb#52
+    def generate_path(stack, part); end
+
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support/directory_maker.rb#49
+    def generate_stack(path); end
+  end
+end
+
+# @private
+#
+# source://rspec-support//lib/rspec/support/encoded_string.rb#6
+class RSpec::Support::EncodedString
+  # @return [EncodedString] a new instance of EncodedString
+  #
+  # source://rspec-support//lib/rspec/support/encoded_string.rb#16
+  def initialize(string, encoding = T.unsafe(nil)); end
+
+  # source://rspec-support//lib/rspec/support/encoded_string.rb#28
+  def <<(string); end
+
+  # source://rspec-support//lib/rspec/support/encoded_string.rb#25
+  def ==(*args, &block); end
+
+  # source://rspec-support//lib/rspec/support/encoded_string.rb#25
+  def empty?(*args, &block); end
+
+  # source://rspec-support//lib/rspec/support/encoded_string.rb#25
+  def encoding(*args, &block); end
+
+  # source://rspec-support//lib/rspec/support/encoded_string.rb#25
+  def eql?(*args, &block); end
+
+  # source://rspec-support//lib/rspec/support/encoded_string.rb#25
+  def lines(*args, &block); end
+
+  # Returns the value of attribute source_encoding.
+  #
+  # source://rspec-support//lib/rspec/support/encoded_string.rb#21
+  def source_encoding; end
+
+  # source://rspec-support//lib/rspec/support/encoded_string.rb#41
+  def split(regex_or_string); end
+
+  # source://rspec-support//lib/rspec/support/encoded_string.rb#46
+  def to_s; end
+
+  # source://rspec-support//lib/rspec/support/encoded_string.rb#46
+  def to_str; end
+
+  private
+
+  # source://rspec-support//lib/rspec/support/encoded_string.rb#139
+  def detect_source_encoding(string); end
+
+  # Encoding Exceptions:
+  #
+  # Raised by Encoding and String methods:
+  #   Encoding::UndefinedConversionError:
+  #     when a transcoding operation fails
+  #     if the String contains characters invalid for the target encoding
+  #     e.g. "\x80".encode('UTF-8','ASCII-8BIT')
+  #     vs "\x80".encode('UTF-8','ASCII-8BIT', undef: :replace, replace: '<undef>')
+  #     # => '<undef>'
+  #   Encoding::CompatibilityError
+  #     when Encoding.compatible?(str1, str2) is nil
+  #     e.g. utf_16le_emoji_string.split("\n")
+  #     e.g. valid_unicode_string.encode(utf8_encoding) << ascii_string
+  #   Encoding::InvalidByteSequenceError:
+  #     when the string being transcoded contains a byte invalid for
+  #     either the source or target encoding
+  #     e.g. "\x80".encode('UTF-8','US-ASCII')
+  #     vs "\x80".encode('UTF-8','US-ASCII', invalid: :replace, replace: '<byte>')
+  #     # => '<byte>'
+  #   ArgumentError
+  #     when operating on a string with invalid bytes
+  #     e.g."\x80".split("\n")
+  #   TypeError
+  #     when a symbol is passed as an encoding
+  #     Encoding.find(:"UTF-8")
+  #     when calling force_encoding on an object
+  #     that doesn't respond to #to_str
+  #
+  # Raised by transcoding methods:
+  #   Encoding::ConverterNotFoundError:
+  #     when a named encoding does not correspond with a known converter
+  #     e.g. 'abc'.force_encoding('UTF-8').encode('foo')
+  #     or a converter path cannot be found
+  #     e.g. "\x80".force_encoding('ASCII-8BIT').encode('Emacs-Mule')
+  #
+  # Raised by byte <-> char conversions
+  #   RangeError: out of char range
+  #     e.g. the UTF-16LE emoji: 128169.chr
+  #
+  # source://rspec-support//lib/rspec/support/encoded_string.rb#93
+  def matching_encoding(string); end
+
+  # http://stackoverflow.com/a/8711118/879854
+  # Loop over chars in a string replacing chars
+  # with invalid encoding, which is a pretty good proxy
+  # for the invalid byte sequence that causes an ArgumentError
+  #
+  # source://rspec-support//lib/rspec/support/encoded_string.rb#124
+  def remove_invalid_bytes(string); end
+
+  class << self
+    # source://rspec-support//lib/rspec/support/encoded_string.rb#143
+    def pick_encoding(source_a, source_b); end
+  end
+end
+
+# Ruby's default replacement string is:
+#   U+FFFD ("\xEF\xBF\xBD"), for Unicode encoding forms, else
+#   ?      ("\x3F")
+#
+# source://rspec-support//lib/rspec/support/encoded_string.rb#14
+RSpec::Support::EncodedString::REPLACE = T.let(T.unsafe(nil), String)
+
+# source://rspec-support//lib/rspec/support/encoded_string.rb#9
+RSpec::Support::EncodedString::US_ASCII = T.let(T.unsafe(nil), String)
+
+# Reduce allocations by storing constants.
+#
+# source://rspec-support//lib/rspec/support/encoded_string.rb#8
+RSpec::Support::EncodedString::UTF_8 = T.let(T.unsafe(nil), String)
+
+# Provides a means to fuzzy-match between two arbitrary objects.
+# Understands array/hash nesting. Uses `===` or `==` to
+# perform the matching.
+#
+# source://rspec-support//lib/rspec/support/fuzzy_matcher.rb#8
+module RSpec::Support::FuzzyMatcher
+  class << self
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/fuzzy_matcher.rb#10
+    def values_match?(expected, actual); end
+
+    private
+
+    # @private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/fuzzy_matcher.rb#29
+    def arrays_match?(expected_list, actual_list); end
+
+    # @private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/fuzzy_matcher.rb#38
+    def hashes_match?(expected_hash, actual_hash); end
+  end
+end
+
+# @private
+#
+# source://rspec-support//lib/rspec/support/hunk_generator.rb#9
+class RSpec::Support::HunkGenerator
+  # @return [HunkGenerator] a new instance of HunkGenerator
+  #
+  # source://rspec-support//lib/rspec/support/hunk_generator.rb#10
+  def initialize(actual, expected); end
+
+  # source://rspec-support//lib/rspec/support/hunk_generator.rb#15
+  def hunks; end
+
+  private
+
+  # source://rspec-support//lib/rspec/support/hunk_generator.rb#32
+  def actual_lines; end
+
+  # source://rspec-support//lib/rspec/support/hunk_generator.rb#36
+  def build_hunk(piece); end
+
+  # source://rspec-support//lib/rspec/support/hunk_generator.rb#44
+  def context_lines; end
+
+  # source://rspec-support//lib/rspec/support/hunk_generator.rb#24
+  def diffs; end
+
+  # source://rspec-support//lib/rspec/support/hunk_generator.rb#28
+  def expected_lines; end
+end
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support.rb#40
+RSpec::Support::KERNEL_METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# Allows matchers to be used instead of providing keyword arguments. In
+# practice, when this happens only the arity of the method is verified.
+#
+# @private
+#
+# source://rspec-support//lib/rspec/support/method_signature_verifier.rb#395
+class RSpec::Support::LooseSignatureVerifier < ::RSpec::Support::MethodSignatureVerifier
+  private
+
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#398
+  def split_args(*args); end
+end
+
+# If a matcher is used in a signature in place of keyword arguments, all
+# keyword argument validation needs to be skipped since the matcher is
+# opaque.
+#
+# Instead, keyword arguments will be validated when the method is called
+# and they are actually known.
+#
+# @private
+#
+# source://rspec-support//lib/rspec/support/method_signature_verifier.rb#415
+class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher
+  # @return [SignatureWithKeywordArgumentsMatcher] a new instance of SignatureWithKeywordArgumentsMatcher
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#416
+  def initialize(signature); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#436
+  def has_kw_args_in?(args); end
+
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#424
+  def invalid_kw_args_from(_kw_args); end
+
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#420
+  def missing_kw_args_from(_kw_args); end
+
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#428
+  def non_kw_args_arity_description; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#432
+  def valid_non_kw_args?(*args); end
+end
+
+# Extracts info about the number of arguments and allowed/required
+# keyword args of a given method.
+#
+# @private
+#
+# source://rspec-support//lib/rspec/support/method_signature_verifier.rb#13
+class RSpec::Support::MethodSignature
+  # @return [MethodSignature] a new instance of MethodSignature
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#16
+  def initialize(method); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#98
+  def arbitrary_kw_args?; end
+
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#38
+  def classify_arity(arity = T.unsafe(nil)); end
+
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#106
+  def classify_parameters; end
+
+  # Without considering what the last arg is, could it
+  # contain keyword arguments?
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#92
+  def could_contain_kw_args?(args); end
+
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#51
+  def description; end
+
+  # If the last argument is Hash, Ruby will treat only symbol keys as keyword arguments
+  # the rest will be grouped in another Hash and passed as positional argument.
+  #
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#84
+  def has_kw_args_in?(args); end
+
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#77
+  def invalid_kw_args_from(given_kw_args); end
+
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#14
+  def max_non_kw_args; end
+
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#14
+  def min_non_kw_args; end
+
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#73
+  def missing_kw_args_from(given_kw_args); end
+
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#23
+  def non_kw_args_arity_description; end
+
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#14
+  def optional_kw_args; end
+
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#14
+  def required_kw_args; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#102
+  def unlimited_args?; end
+
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#31
+  def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = T.unsafe(nil)); end
+end
+
+# source://rspec-support//lib/rspec/support/method_signature_verifier.rb#162
+RSpec::Support::MethodSignature::INFINITY = T.let(T.unsafe(nil), Float)
+
+# Encapsulates expectations about the number of arguments and
+# allowed/required keyword args of a given method.
+#
+# @api private
+#
+# source://rspec-support//lib/rspec/support/method_signature_verifier.rb#219
+class RSpec::Support::MethodSignatureExpectation
+  # @api private
+  # @return [MethodSignatureExpectation] a new instance of MethodSignatureExpectation
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#220
+  def initialize; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#247
+  def empty?; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#231
+  def expect_arbitrary_keywords; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#231
+  def expect_arbitrary_keywords=(_arg0); end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#231
+  def expect_unlimited_arguments; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#231
+  def expect_unlimited_arguments=(_arg0); end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#229
+  def keywords; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#254
+  def keywords=(values); end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#229
+  def max_count; end
+
+  # @api private
+  # @raise [ArgumentError]
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#233
+  def max_count=(number); end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#229
+  def min_count; end
+
+  # @api private
+  # @raise [ArgumentError]
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#240
+  def min_count=(number); end
+end
+
+# Abstract base class for signature verifiers.
+#
+# @api private
+#
+# source://rspec-support//lib/rspec/support/method_signature_verifier.rb#280
+class RSpec::Support::MethodSignatureVerifier
+  # @api private
+  # @return [MethodSignatureVerifier] a new instance of MethodSignatureVerifier
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#283
+  def initialize(signature, args = T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#326
+  def error_message; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#281
+  def kw_args; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#281
+  def max_non_kw_args; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#281
+  def min_non_kw_args; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#281
+  def non_kw_args; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#318
+  def valid?; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#290
+  def with_expectation(expectation); end
+
+  private
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#357
+  def arbitrary_kw_args?; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#353
+  def invalid_kw_args; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#349
+  def missing_kw_args; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#365
+  def split_args(*args); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#361
+  def unlimited_args?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/method_signature_verifier.rb#345
+  def valid_non_kw_args?; end
+end
+
+# On 1.9 and up, this is in core, so we just use the real one
+#
+# source://rspec-support//lib/rspec/support/reentrant_mutex.rb#67
+class RSpec::Support::Mutex < ::Thread::Mutex
+  class << self
+    # source://rspec-support//lib/rspec/support/reentrant_mutex.rb#70
+    def new; end
+  end
+end
+
+# If you mock Mutex.new you break our usage of Mutex, so
+# instead we capture the original method to return Mutexes.
+#
+# source://rspec-support//lib/rspec/support/reentrant_mutex.rb#68
+RSpec::Support::Mutex::NEW_MUTEX_METHOD = T.let(T.unsafe(nil), Method)
+
+# Provides query methods for different OS or OS features.
+#
+# @api private
+#
+# source://rspec-support//lib/rspec/support/ruby_features.rb#11
+module RSpec::Support::OS
+  private
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#14
+  def windows?; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#18
+  def windows_file_path?; end
+
+  class << self
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#14
+    def windows?; end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#18
+    def windows_file_path?; end
+  end
+end
+
+# Provide additional output details beyond what `inspect` provides when
+# printing Time, DateTime, or BigDecimal
+#
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#10
+class RSpec::Support::ObjectFormatter
+  # @api private
+  # @return [ObjectFormatter] a new instance of ObjectFormatter
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#29
+  def initialize(max_formatted_output_length = T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#34
+  def format(object); end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#13
+  def max_formatted_output_length; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#13
+  def max_formatted_output_length=(_arg0); end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#70
+  def prepare_array(array); end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#94
+  def prepare_element(element); end
+
+  # Prepares the provided object to be formatted by wrapping it as needed
+  # in something that, when `inspect` is called on it, will produce the
+  # desired output.
+  #
+  # This allows us to apply the desired formatting to hash/array data structures
+  # at any level of nesting, simply by walking that structure and replacing items
+  # with custom items that have `inspect` defined to return the desired output
+  # for that item. Then we can just use `Array#inspect` or `Hash#inspect` to
+  # format the entire thing.
+  #
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#58
+  def prepare_for_inspection(object); end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#76
+  def prepare_hash(input_hash); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#113
+  def recursive_structure?(object); end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#86
+  def sort_hash_keys(input_hash); end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#106
+  def with_entering_structure(structure); end
+
+  private
+
+  # Returns the substring defined by the start_index and end_index
+  # If the string ends with a partial ANSI code code then that
+  # will be removed as printing partial ANSI
+  # codes to the terminal can lead to corruption
+  #
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#268
+  def truncate_string(str, start_index, end_index); end
+
+  class << self
+    # Methods are deferred to a default instance of the class to maintain the interface
+    # For example, calling ObjectFormatter.format is still possible
+    #
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support/object_formatter.rb#17
+    def default_instance; end
+
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support/object_formatter.rb#21
+    def format(object); end
+
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support/object_formatter.rb#25
+    def prepare_for_inspection(object); end
+  end
+end
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#127
+class RSpec::Support::ObjectFormatter::BaseInspector < ::Struct
+  # Returns the value of attribute formatter
+  #
+  # @return [Object] the current value of formatter
+  def formatter; end
+
+  # Sets the attribute formatter
+  #
+  # @param value [Object] the value to set the attribute formatter to.
+  # @return [Object] the newly set value
+  def formatter=(_); end
+
+  # @api private
+  # @raise [NotImplementedError]
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#132
+  def inspect; end
+
+  # Returns the value of attribute object
+  #
+  # @return [Object] the current value of object
+  def object; end
+
+  # Sets the attribute object
+  #
+  # @param value [Object] the value to set the attribute object to.
+  # @return [Object] the newly set value
+  def object=(_); end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#136
+  def pretty_print(pp); end
+
+  class << self
+    def [](*_arg0); end
+
+    # @api private
+    # @raise [NotImplementedError]
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/object_formatter.rb#128
+    def can_inspect?(_object); end
+
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#177
+class RSpec::Support::ObjectFormatter::BigDecimalInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#182
+  def inspect; end
+
+  class << self
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/object_formatter.rb#178
+    def can_inspect?(object); end
+  end
+end
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#159
+class RSpec::Support::ObjectFormatter::DateTimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  # ActiveSupport sometimes overrides inspect. If `ActiveSupport` is
+  # defined use a custom format string that includes more time precision.
+  #
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#168
+  def inspect; end
+
+  class << self
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/object_formatter.rb#162
+    def can_inspect?(object); end
+  end
+end
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#160
+RSpec::Support::ObjectFormatter::DateTimeInspector::FORMAT = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#224
+class RSpec::Support::ObjectFormatter::DelegatorInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#229
+  def inspect; end
+
+  class << self
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/object_formatter.rb#225
+    def can_inspect?(object); end
+  end
+end
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#187
+class RSpec::Support::ObjectFormatter::DescribableMatcherInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#192
+  def inspect; end
+
+  class << self
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/object_formatter.rb#188
+    def can_inspect?(object); end
+  end
+end
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#11
+RSpec::Support::ObjectFormatter::ELLIPSIS = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#247
+RSpec::Support::ObjectFormatter::INSPECTOR_CLASSES = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#117
+class RSpec::Support::ObjectFormatter::InspectableItem < ::Struct
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#118
+  def inspect; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#122
+  def pretty_print(pp); end
+
+  # Returns the value of attribute text
+  #
+  # @return [Object] the current value of text
+  def text; end
+
+  # Sets the attribute text
+  #
+  # @param value [Object] the value to set the attribute text to.
+  # @return [Object] the newly set value
+  def text=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#234
+class RSpec::Support::ObjectFormatter::InspectableObjectInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#242
+  def inspect; end
+
+  class << self
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/object_formatter.rb#235
+    def can_inspect?(object); end
+  end
+end
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#141
+class RSpec::Support::ObjectFormatter::TimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  # for 1.8.7
+  #
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#149
+  def inspect; end
+
+  class << self
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/object_formatter.rb#144
+    def can_inspect?(object); end
+  end
+end
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#142
+RSpec::Support::ObjectFormatter::TimeInspector::FORMAT = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#197
+class RSpec::Support::ObjectFormatter::UninspectableObjectInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#207
+  def inspect; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#211
+  def klass; end
+
+  # http://stackoverflow.com/a/2818916
+  #
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/object_formatter.rb#216
+  def native_object_id; end
+
+  class << self
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/object_formatter.rb#200
+    def can_inspect?(object); end
+  end
+end
+
+# @api private
+#
+# source://rspec-support//lib/rspec/support/object_formatter.rb#198
+RSpec::Support::ObjectFormatter::UninspectableObjectInspector::OBJECT_ID_FORMAT = T.let(T.unsafe(nil), String)
+
+# Provides recursive constant lookup methods useful for
+# constant stubbing.
+#
+# source://rspec-support//lib/rspec/support/recursive_const_methods.rb#7
+module RSpec::Support::RecursiveConstMethods
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/recursive_const_methods.rb#45
+  def const_defined_on?(mod, const_name); end
+
+  # source://rspec-support//lib/rspec/support/recursive_const_methods.rb#53
+  def constants_defined_on(mod); end
+
+  # @raise [NameError]
+  #
+  # source://rspec-support//lib/rspec/support/recursive_const_methods.rb#49
+  def get_const_defined_on(mod, const_name); end
+
+  # source://rspec-support//lib/rspec/support/recursive_const_methods.rb#73
+  def normalize_const_name(const_name); end
+
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/recursive_const_methods.rb#64
+  def recursive_const_defined?(const_name); end
+
+  # source://rspec-support//lib/rspec/support/recursive_const_methods.rb#58
+  def recursive_const_get(const_name); end
+end
+
+# Allows a thread to lock out other threads from a critical section of code,
+# while allowing the thread with the lock to reenter that section.
+#
+# Based on Monitor as of 2.2 -
+# https://github.com/ruby/ruby/blob/eb7ddaa3a47bf48045d26c72eb0f263a53524ebc/lib/monitor.rb#L9
+#
+# Depends on Mutex, but Mutex is only available as part of core since 1.9.1:
+#   exists - http://ruby-doc.org/core-1.9.1/Mutex.html
+#   dne    - http://ruby-doc.org/core-1.9.0/Mutex.html
+#
+# @private
+#
+# source://rspec-support//lib/rspec/support/reentrant_mutex.rb#16
+class RSpec::Support::ReentrantMutex
+  # @return [ReentrantMutex] a new instance of ReentrantMutex
+  #
+  # source://rspec-support//lib/rspec/support/reentrant_mutex.rb#17
+  def initialize; end
+
+  # source://rspec-support//lib/rspec/support/reentrant_mutex.rb#23
+  def synchronize; end
+
+  private
+
+  # source://rspec-support//lib/rspec/support/reentrant_mutex.rb#35
+  def enter; end
+
+  # source://rspec-support//lib/rspec/support/reentrant_mutex.rb#40
+  def exit; end
+end
+
+# Provides query methods for different rubies
+#
+# @api private
+#
+# source://rspec-support//lib/rspec/support/ruby_features.rb#26
+module RSpec::Support::Ruby
+  private
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#29
+  def jruby?; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#37
+  def jruby_9000?; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#33
+  def jruby_version; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#49
+  def mri?; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#45
+  def non_mri?; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#41
+  def rbx?; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#53
+  def truffleruby?; end
+
+  class << self
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#29
+    def jruby?; end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#37
+    def jruby_9000?; end
+
+    # @api private
+    #
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#33
+    def jruby_version; end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#49
+    def mri?; end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#45
+    def non_mri?; end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#41
+    def rbx?; end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#53
+    def truffleruby?; end
+  end
+end
+
+# Provides query methods for ruby features that differ among
+# implementations.
+#
+# @api private
+#
+# source://rspec-support//lib/rspec/support/ruby_features.rb#62
+module RSpec::Support::RubyFeatures
+  private
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#85
+  def caller_locations_supported?; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#155
+  def distincts_kw_args_from_positional_hash?; end
+
+  # On JRuby 1.7 `--1.8` mode, `Process.respond_to?(:fork)` returns true,
+  # but when you try to fork, it raises an error:
+  #   NotImplementedError: fork is not available on this platform
+  #
+  # When we drop support for JRuby 1.7 and/or Ruby 1.8, we can drop
+  # this special case.
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#76
+  def fork_supported?; end
+
+  # https://rubyreferences.github.io/rubychanges/3.0.html#keyword-arguments-are-now-fully-separated-from-positional-arguments
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#111
+  def kw_arg_separation?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#160
+  def kw_args_supported?; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#216
+  def module_prepends_supported?; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#212
+  def module_refinement_supported?; end
+
+  # @api private
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#81
+  def optional_and_splat_args_supported?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#164
+  def required_kw_args_supported?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#146
+  def ripper_supported?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#90
+  def supports_exception_cause?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#168
+  def supports_rebinding_module_methods?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#104
+  def supports_syntax_suggest?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rspec-support//lib/rspec/support/ruby_features.rb#121
+  def supports_taint?; end
+
+  class << self
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#85
+    def caller_locations_supported?; end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#155
+    def distincts_kw_args_from_positional_hash?; end
+
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#76
+    def fork_supported?; end
+
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#111
+    def kw_arg_separation?; end
+
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#160
+    def kw_args_supported?; end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#216
+    def module_prepends_supported?; end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#212
+    def module_refinement_supported?; end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#81
+    def optional_and_splat_args_supported?; end
+
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#164
+    def required_kw_args_supported?; end
+
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#146
+    def ripper_supported?; end
+
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#90
+    def supports_exception_cause?; end
+
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#168
+    def supports_rebinding_module_methods?; end
+
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#104
+    def supports_syntax_suggest?; end
+
+    # source://rspec-support//lib/rspec/support/ruby_features.rb#121
+    def supports_taint?; end
+  end
+end
+
+# Figures out whether a given method can accept various arguments.
+# Surprisingly non-trivial.
+#
+# @private
+#
+# source://rspec-support//lib/rspec/support/method_signature_verifier.rb#389
+RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier
+
+# source://rspec-support//lib/rspec/support/version.rb#5
+module RSpec::Support::Version; end
+
+# source://rspec-support//lib/rspec/support/version.rb#6
+RSpec::Support::Version::STRING = T.let(T.unsafe(nil), String)
+
+# source://rspec-support//lib/rspec/support/warnings.rb#8
+module RSpec::Support::Warnings
+  # source://rspec-support//lib/rspec/support/warnings.rb#9
+  def deprecate(deprecated, options = T.unsafe(nil)); end
+
+  # Used internally to print deprecation warnings
+  # when rspec-core isn't loaded
+  #
+  # @private
+  #
+  # source://rspec-support//lib/rspec/support/warnings.rb#17
+  def warn_deprecation(message, options = T.unsafe(nil)); end
+
+  # Used internally to print longer warnings
+  #
+  # @private
+  #
+  # source://rspec-support//lib/rspec/support/warnings.rb#31
+  def warn_with(message, options = T.unsafe(nil)); end
+
+  # Used internally to print warnings
+  #
+  # @private
+  #
+  # source://rspec-support//lib/rspec/support/warnings.rb#24
+  def warning(text, options = T.unsafe(nil)); end
+end
+
+# source://rspec-support//lib/rspec/support/with_keywords_when_needed.rb#7
+module RSpec::Support::WithKeywordsWhenNeeded
+  private
+
+  # Remove this in RSpec 4 in favour of explicitly passed in kwargs where
+  # this is used. Works around a warning in Ruby 2.7
+  #
+  # source://rspec-support//lib/rspec/support/with_keywords_when_needed.rb#17
+  def class_exec(klass, *args, **_arg2, &block); end
+
+  class << self
+    # source://rspec-support//lib/rspec/support/with_keywords_when_needed.rb#17
+    def class_exec(klass, *args, **_arg2, &block); end
+  end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi
deleted file mode 100644
index e91ffd7b181a2..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi
+++ /dev/null
@@ -1,91 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rspec-wait` gem.
-# Please instead update this file by running `bin/tapioca gem rspec-wait`.
-
-module RSpec
-  extend ::RSpec::Support::Warnings
-  extend ::RSpec::Core::Warnings
-
-  class << self
-    def clear_examples; end
-    def configuration; end
-    def configuration=(_arg0); end
-    def configure; end
-    def const_missing(name); end
-    def context(*args, &example_group_block); end
-    def current_example; end
-    def current_example=(example); end
-    def current_scope; end
-    def current_scope=(scope); end
-    def describe(*args, &example_group_block); end
-    def example_group(*args, &example_group_block); end
-    def fcontext(*args, &example_group_block); end
-    def fdescribe(*args, &example_group_block); end
-    def reset; end
-    def shared_context(name, *args, &block); end
-    def shared_examples(name, *args, &block); end
-    def shared_examples_for(name, *args, &block); end
-    def world; end
-    def world=(_arg0); end
-    def xcontext(*args, &example_group_block); end
-    def xdescribe(*args, &example_group_block); end
-  end
-end
-
-RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
-RSpec::SharedContext = RSpec::Core::SharedContext
-
-module RSpec::Wait
-  private
-
-  def wait(timeout = T.unsafe(nil), options = T.unsafe(nil)); end
-  def wait_for(value = T.unsafe(nil), &block); end
-  def with_wait(options); end
-
-  class << self
-    def wait(timeout = T.unsafe(nil), options = T.unsafe(nil)); end
-    def wait_for(value = T.unsafe(nil), &block); end
-    def with_wait(options); end
-  end
-end
-
-class RSpec::Wait::Error < ::StandardError; end
-
-module RSpec::Wait::Handler
-  def handle_matcher(target, *args, &block); end
-end
-
-class RSpec::Wait::NegativeHandler < ::RSpec::Expectations::NegativeExpectationHandler
-  extend ::RSpec::Wait::Handler
-end
-
-class RSpec::Wait::PositiveHandler < ::RSpec::Expectations::PositiveExpectationHandler
-  extend ::RSpec::Wait::Handler
-end
-
-class RSpec::Wait::Proxy
-  def initialize(options); end
-
-  def for(value = T.unsafe(nil), &block); end
-end
-
-class RSpec::Wait::Target < ::RSpec::Expectations::ExpectationTarget
-  def initialize(target, options); end
-
-  def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
-  def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
-  def to_not(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
-
-  private
-
-  def with_wait; end
-
-  class << self
-    def for(value, block, options = T.unsafe(nil)); end
-  end
-end
-
-module RSpec::Wait::Target::UndefinedValue; end
-class RSpec::Wait::TimeoutError < ::RSpec::Wait::Error; end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec@3.11.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec@3.11.0.rbi
deleted file mode 100644
index 2ceaf83924452..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rspec@3.11.0.rbi
+++ /dev/null
@@ -1,40 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rspec` gem.
-# Please instead update this file by running `bin/tapioca gem rspec`.
-
-module RSpec
-  extend ::RSpec::Support::Warnings
-  extend ::RSpec::Core::Warnings
-
-  class << self
-    def clear_examples; end
-    def configuration; end
-    def configuration=(_arg0); end
-    def configure; end
-    def const_missing(name); end
-    def context(*args, &example_group_block); end
-    def current_example; end
-    def current_example=(example); end
-    def current_scope; end
-    def current_scope=(scope); end
-    def describe(*args, &example_group_block); end
-    def example_group(*args, &example_group_block); end
-    def fcontext(*args, &example_group_block); end
-    def fdescribe(*args, &example_group_block); end
-    def reset; end
-    def shared_context(name, *args, &block); end
-    def shared_examples(name, *args, &block); end
-    def shared_examples_for(name, *args, &block); end
-    def world; end
-    def world=(_arg0); end
-    def xcontext(*args, &example_group_block); end
-    def xdescribe(*args, &example_group_block); end
-  end
-end
-
-RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
-RSpec::SharedContext = RSpec::Core::SharedContext
-module RSpec::Version; end
-RSpec::Version::STRING = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec_junit_formatter@0.5.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec_junit_formatter@0.5.1.rbi
deleted file mode 100644
index baa1708af50ab..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rspec_junit_formatter@0.5.1.rbi
+++ /dev/null
@@ -1,50 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rspec_junit_formatter` gem.
-# Please instead update this file by running `bin/tapioca gem rspec_junit_formatter`.
-
-class RSpecJUnitFormatter < ::RSpec::Core::Formatters::BaseFormatter
-  def dump_summary(notification); end
-  def start(notification); end
-  def stop(notification); end
-
-  private
-
-  def classname_for(notification); end
-  def description_for(notification); end
-  def duration; end
-  def duration_for(notification); end
-  def error_count; end
-  def escape(text); end
-  def example_count; end
-  def example_group_file_path_for(notification); end
-  def examples; end
-  def exception_for(notification); end
-  def failure_count; end
-  def failure_for(notification); end
-  def failure_message_for(example); end
-  def failure_type_for(example); end
-  def pending_count; end
-  def result_of(notification); end
-  def started; end
-  def stderr_for(example_notification); end
-  def stdout_for(example_notification); end
-  def strip_diff_colors(string); end
-  def swap_rspec_configuration(key, value); end
-  def without_color(&block); end
-  def xml_dump; end
-  def xml_dump_example(example); end
-  def xml_dump_examples; end
-  def xml_dump_failed(example); end
-  def xml_dump_output(example); end
-  def xml_dump_pending(example); end
-end
-
-RSpecJUnitFormatter::DISCOURAGED_REGEXP = T.let(T.unsafe(nil), Regexp)
-RSpecJUnitFormatter::DISCOURAGED_REPLACEMENTS = T.let(T.unsafe(nil), Hash)
-RSpecJUnitFormatter::ILLEGAL_REGEXP = T.let(T.unsafe(nil), Regexp)
-RSpecJUnitFormatter::ILLEGAL_REPLACEMENT = T.let(T.unsafe(nil), Hash)
-RSpecJUnitFormatter::STRIP_DIFF_COLORS_BLOCK_REGEXP = T.let(T.unsafe(nil), Regexp)
-RSpecJUnitFormatter::STRIP_DIFF_COLORS_CODES_REGEXP = T.let(T.unsafe(nil), Regexp)
-RspecJunitFormatter = RSpecJUnitFormatter
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@1.19.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@1.19.1.rbi
deleted file mode 100644
index bc0c467c000a7..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@1.19.1.rbi
+++ /dev/null
@@ -1,1988 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rubocop-ast` gem.
-# Please instead update this file by running `bin/tapioca gem rubocop-ast`.
-
-module RuboCop; end
-
-module RuboCop::AST
-  extend ::RuboCop::AST::RuboCopCompatibility
-end
-
-class RuboCop::AST::AliasNode < ::RuboCop::AST::Node
-  def new_identifier; end
-  def old_identifier; end
-end
-
-class RuboCop::AST::AndAsgnNode < ::RuboCop::AST::OpAsgnNode
-  def operator; end
-end
-
-class RuboCop::AST::AndNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::BinaryOperatorNode
-  include ::RuboCop::AST::PredicateOperatorNode
-
-  def alternate_operator; end
-  def inverse_operator; end
-end
-
-class RuboCop::AST::ArgNode < ::RuboCop::AST::Node
-  def default?; end
-  def default_value; end
-  def name; end
-end
-
-class RuboCop::AST::ArgsNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::CollectionNode
-
-  def argument_list; end
-  def empty_and_without_delimiters?; end
-end
-
-class RuboCop::AST::ArrayNode < ::RuboCop::AST::Node
-  def bracketed?; end
-  def each_value(&block); end
-  def percent_literal?(type = T.unsafe(nil)); end
-  def square_brackets?; end
-  def values; end
-end
-
-RuboCop::AST::ArrayNode::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::AST::AsgnNode < ::RuboCop::AST::Node
-  def expression; end
-  def name; end
-end
-
-module RuboCop::AST::BasicLiteralNode
-  def value; end
-end
-
-module RuboCop::AST::BinaryOperatorNode
-  def conditions; end
-  def lhs; end
-  def rhs; end
-end
-
-class RuboCop::AST::BlockNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::MethodIdentifierPredicates
-
-  def argument_list; end
-  def arguments; end
-  def arguments?; end
-  def body; end
-  def braces?; end
-  def closing_delimiter; end
-  def delimiters; end
-  def keywords?; end
-  def lambda?; end
-  def method_name; end
-  def multiline?; end
-  def opening_delimiter; end
-  def send_node; end
-  def single_line?; end
-  def void_context?; end
-
-  private
-
-  def numbered_arguments; end
-end
-
-RuboCop::AST::BlockNode::VOID_CONTEXT_METHODS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::AST::BreakNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ParameterizedNode
-  include ::RuboCop::AST::ParameterizedNode::WrappedArguments
-end
-
-class RuboCop::AST::Builder < ::Parser::Builders::Default
-  def n(type, children, source_map); end
-  def string_value(token); end
-
-  private
-
-  def node_klass(type); end
-end
-
-RuboCop::AST::Builder::NODE_MAP = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::AST::CaseMatchNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ConditionalNode
-
-  def branches; end
-  def each_in_pattern(&block); end
-  def else?; end
-  def else_branch; end
-  def in_pattern_branches; end
-  def keyword; end
-end
-
-class RuboCop::AST::CaseNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ConditionalNode
-
-  def branches; end
-  def each_when(&block); end
-  def else?; end
-  def else_branch; end
-  def keyword; end
-  def when_branches; end
-end
-
-class RuboCop::AST::CasgnNode < ::RuboCop::AST::Node
-  def expression; end
-  def name; end
-  def namespace; end
-end
-
-class RuboCop::AST::ClassNode < ::RuboCop::AST::Node
-  def body; end
-  def identifier; end
-  def parent_class; end
-end
-
-module RuboCop::AST::CollectionNode
-  extend ::Forwardable
-
-  def &(*args, &block); end
-  def *(*args, &block); end
-  def +(*args, &block); end
-  def -(*args, &block); end
-  def <<(*args, &block); end
-  def [](*args, &block); end
-  def []=(*args, &block); 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 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 empty?(*args, &block); end
-  def entries(*args, &block); 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 include?(*args, &block); end
-  def index(*args, &block); end
-  def inject(*args, &block); end
-  def insert(*args, &block); end
-  def join(*args, &block); end
-  def keep_if(*args, &block); 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(*args, &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 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 save_plist(*args, &block); end
-  def select(*args, &block); end
-  def select!(*args, &block); 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 sum(*args, &block); end
-  def take(*args, &block); end
-  def take_while(*args, &block); end
-  def to_ary(*args, &block); end
-  def to_h(*args, &block); end
-  def to_plist(*args, &block); 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
-end
-
-RuboCop::AST::CollectionNode::ARRAY_METHODS = T.let(T.unsafe(nil), Array)
-
-module RuboCop::AST::ConditionalNode
-  def body; end
-  def condition; end
-  def multiline_condition?; end
-  def single_line_condition?; end
-end
-
-class RuboCop::AST::ConstNode < ::RuboCop::AST::Node
-  def absolute?; end
-  def class_name?; end
-  def each_path(&block); end
-  def module_name?; end
-  def namespace; end
-  def relative?; end
-  def short_name; end
-end
-
-class RuboCop::AST::DefNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ParameterizedNode
-  include ::RuboCop::AST::MethodIdentifierPredicates
-
-  def argument_forwarding?; end
-  def arguments; end
-  def body; end
-  def endless?; end
-  def method_name; end
-  def receiver; end
-  def void_context?; end
-end
-
-class RuboCop::AST::DefinedNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ParameterizedNode
-  include ::RuboCop::AST::MethodIdentifierPredicates
-  include ::RuboCop::AST::MethodDispatchNode
-
-  def arguments; end
-  def node_parts; end
-end
-
-module RuboCop::AST::Descendence
-  def child_nodes; end
-  def descendants; end
-  def each_child_node(*types); end
-  def each_descendant(*types, &block); end
-  def each_node(*types, &block); end
-
-  protected
-
-  def visit_descendants(types, &block); end
-end
-
-class RuboCop::AST::DstrNode < ::RuboCop::AST::StrNode
-  def value; end
-end
-
-class RuboCop::AST::EnsureNode < ::RuboCop::AST::Node
-  def body; end
-end
-
-module RuboCop::AST::Ext; end
-
-module RuboCop::AST::Ext::Range
-  def line_span(exclude_end: T.unsafe(nil)); end
-end
-
-module RuboCop::AST::Ext::RangeMinMax; end
-
-class RuboCop::AST::FloatNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::BasicLiteralNode
-  include ::RuboCop::AST::NumericNode
-end
-
-class RuboCop::AST::ForNode < ::RuboCop::AST::Node
-  def body; end
-  def collection; end
-  def do?; end
-  def keyword; end
-  def variable; end
-  def void_context?; end
-end
-
-class RuboCop::AST::ForwardArgsNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::CollectionNode
-
-  def to_a; end
-end
-
-module RuboCop::AST::HashElementNode
-  def delimiter_delta(other); end
-  def key; end
-  def key_delta(other, alignment = T.unsafe(nil)); end
-  def same_line?(other); end
-  def value; end
-  def value_delta(other); end
-end
-
-class RuboCop::AST::HashElementNode::HashElementDelta
-  def initialize(first, second); end
-
-  def delimiter_delta; end
-  def key_delta(alignment = T.unsafe(nil)); end
-  def value_delta; end
-
-  private
-
-  def delta(first, second, alignment = T.unsafe(nil)); end
-  def first; end
-  def keyword_splat?; end
-  def second; end
-  def valid_argument_types?; end
-end
-
-class RuboCop::AST::HashNode < ::RuboCop::AST::Node
-  def braces?; end
-  def each_key(&block); end
-  def each_pair; end
-  def each_value(&block); end
-  def empty?; end
-  def keys; end
-  def mixed_delimiters?; end
-  def pairs; end
-  def pairs_on_same_line?; end
-  def values; end
-end
-
-class RuboCop::AST::IfNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ConditionalNode
-  include ::RuboCop::AST::ModifierNode
-
-  def branches; end
-  def each_branch(&block); end
-  def else?; end
-  def else_branch; end
-  def elsif?; end
-  def elsif_conditional?; end
-  def if?; end
-  def if_branch; end
-  def inverse_keyword; end
-  def keyword; end
-  def modifier_form?; end
-  def nested_conditional?; end
-  def node_parts; end
-  def ternary?; end
-  def unless?; end
-end
-
-class RuboCop::AST::InPatternNode < ::RuboCop::AST::Node
-  def body; end
-  def branch_index; end
-  def pattern; end
-  def then?; end
-end
-
-class RuboCop::AST::IndexNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ParameterizedNode
-  include ::RuboCop::AST::ParameterizedNode::RestArguments
-  include ::RuboCop::AST::MethodIdentifierPredicates
-  include ::RuboCop::AST::MethodDispatchNode
-
-  def assignment_method?; end
-  def attribute_accessor?; end
-  def method_name; end
-
-  private
-
-  def first_argument_index; end
-end
-
-class RuboCop::AST::IndexasgnNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ParameterizedNode
-  include ::RuboCop::AST::ParameterizedNode::RestArguments
-  include ::RuboCop::AST::MethodIdentifierPredicates
-  include ::RuboCop::AST::MethodDispatchNode
-
-  def assignment_method?; end
-  def attribute_accessor?; end
-  def method_name; end
-
-  private
-
-  def first_argument_index; end
-end
-
-class RuboCop::AST::IntNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::BasicLiteralNode
-  include ::RuboCop::AST::NumericNode
-end
-
-class RuboCop::AST::KeywordSplatNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::HashElementNode
-
-  def colon?; end
-  def hash_rocket?; end
-  def node_parts; end
-  def operator; end
-end
-
-RuboCop::AST::KeywordSplatNode::DOUBLE_SPLAT = T.let(T.unsafe(nil), String)
-
-class RuboCop::AST::LambdaNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ParameterizedNode
-  include ::RuboCop::AST::ParameterizedNode::RestArguments
-  include ::RuboCop::AST::MethodIdentifierPredicates
-  include ::RuboCop::AST::MethodDispatchNode
-
-  def assignment_method?; end
-  def attribute_accessor?; end
-  def lambda?; end
-  def lambda_literal?; end
-  def method_name; end
-  def receiver; end
-
-  private
-
-  def first_argument_index; end
-end
-
-module RuboCop::AST::MethodDispatchNode
-  include ::RuboCop::AST::MethodIdentifierPredicates
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def access_modifier?; end
-  def adjacent_def_modifier?(param0 = T.unsafe(nil)); end
-  def arithmetic_operation?; end
-  def assignment?; end
-  def bare_access_modifier?; end
-  def bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end
-  def binary_operation?; end
-  def block_literal?; end
-  def block_node; end
-  def command?(name); end
-  def const_receiver?; end
-  def def_modifier(node = T.unsafe(nil)); end
-  def def_modifier?(node = T.unsafe(nil)); end
-  def dot?; end
-  def double_colon?; end
-  def implicit_call?; end
-  def in_macro_scope?(param0 = T.unsafe(nil)); end
-  def lambda?; end
-  def lambda_literal?; end
-  def macro?; end
-  def method_name; end
-  def non_bare_access_modifier?; end
-  def non_bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end
-  def receiver; end
-  def safe_navigation?; end
-  def self_receiver?; end
-  def setter_method?; end
-  def special_modifier?; end
-  def unary_operation?; end
-end
-
-RuboCop::AST::MethodDispatchNode::ARITHMETIC_OPERATORS = T.let(T.unsafe(nil), Array)
-RuboCop::AST::MethodDispatchNode::SPECIAL_MODIFIERS = T.let(T.unsafe(nil), Array)
-
-module RuboCop::AST::MethodIdentifierPredicates
-  def assignment_method?; end
-  def bang_method?; end
-  def camel_case_method?; end
-  def comparison_method?; end
-  def const_receiver?; end
-  def enumerable_method?; end
-  def enumerator_method?; end
-  def method?(name); end
-  def negation_method?; end
-  def nonmutating_array_method?; end
-  def nonmutating_binary_operator_method?; end
-  def nonmutating_hash_method?; end
-  def nonmutating_operator_method?; end
-  def nonmutating_string_method?; end
-  def nonmutating_unary_operator_method?; end
-  def operator_method?; end
-  def predicate_method?; end
-  def prefix_bang?; end
-  def prefix_not?; end
-  def self_receiver?; end
-end
-
-RuboCop::AST::MethodIdentifierPredicates::ENUMERABLE_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::MethodIdentifierPredicates::ENUMERATOR_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_ARRAY_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_BINARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_HASH_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_STRING_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_UNARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::MethodIdentifierPredicates::OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
-
-module RuboCop::AST::ModifierNode
-  def modifier_form?; end
-end
-
-class RuboCop::AST::ModuleNode < ::RuboCop::AST::Node
-  def body; end
-  def identifier; end
-end
-
-class RuboCop::AST::NextNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ParameterizedNode
-  include ::RuboCop::AST::ParameterizedNode::WrappedArguments
-end
-
-class RuboCop::AST::Node < ::Parser::AST::Node
-  include ::RuboCop::AST::Sexp
-  include ::RuboCop::AST::Descendence
-  include ::RuboCop::RSpec::Node
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
-
-  def __ENCODING___type?; end
-  def __FILE___type?; end
-  def __LINE___type?; end
-  def alias_type?; end
-  def ancestors; end
-  def and_asgn_type?; end
-  def and_type?; end
-  def arg_expr_type?; end
-  def arg_type?; end
-  def args_type?; end
-  def argument?; end
-  def argument_type?; end
-  def array_pattern_type?; end
-  def array_pattern_with_tail_type?; end
-  def array_type?; end
-  def assignment?; end
-  def assignment_or_similar?(param0 = T.unsafe(nil)); end
-  def back_ref_type?; end
-  def basic_conditional?; end
-  def basic_literal?; end
-  def begin_type?; end
-  def block_pass_type?; end
-  def block_type?; end
-  def blockarg_expr_type?; end
-  def blockarg_type?; end
-  def boolean_type?; end
-  def break_type?; end
-  def call_type?; end
-  def case_match_type?; end
-  def case_type?; end
-  def casgn_type?; end
-  def cbase_type?; end
-  def chained?; end
-  def class_constructor?(param0 = T.unsafe(nil)); end
-  def class_definition?(param0 = T.unsafe(nil)); end
-  def class_type?; end
-  def complete!; end
-  def complete?; end
-  def complex_type?; end
-  def conditional?; end
-  def const_name; end
-  def const_pattern_type?; end
-  def const_type?; end
-  def csend_type?; end
-  def cvar_type?; end
-  def cvasgn_type?; end
-  def def_type?; end
-  def defined_module; end
-  def defined_module_name; end
-  def defined_type?; end
-  def defs_type?; end
-  def dstr_type?; end
-  def dsym_type?; end
-  def each_ancestor(*types, &block); end
-  def eflipflop_type?; end
-  def empty_else_type?; end
-  def empty_source?; end
-  def ensure_type?; end
-  def equals_asgn?; end
-  def erange_type?; end
-  def false_type?; end
-  def falsey_literal?; end
-  def find_pattern_type?; end
-  def first_line; end
-  def float_type?; end
-  def for_type?; end
-  def forward_arg_type?; end
-  def forward_args_type?; end
-  def forwarded_args_type?; end
-  def global_const?(param0 = T.unsafe(nil), param1); end
-  def guard_clause?; end
-  def gvar_type?; end
-  def gvasgn_type?; end
-  def hash_pattern_type?; end
-  def hash_type?; end
-  def ident_type?; end
-  def if_guard_type?; end
-  def if_type?; end
-  def iflipflop_type?; end
-  def immutable_literal?; end
-  def in_match_type?; end
-  def in_pattern_type?; end
-  def index_type?; end
-  def indexasgn_type?; end
-  def int_type?; end
-  def irange_type?; end
-  def ivar_type?; end
-  def ivasgn_type?; end
-  def keyword?; end
-  def kwarg_type?; end
-  def kwargs_type?; end
-  def kwbegin_type?; end
-  def kwnilarg_type?; end
-  def kwoptarg_type?; end
-  def kwrestarg_type?; end
-  def kwsplat_type?; end
-  def lambda?(param0 = T.unsafe(nil)); end
-  def lambda_or_proc?(param0 = T.unsafe(nil)); end
-  def lambda_type?; end
-  def last_line; end
-  def left_sibling; end
-  def left_siblings; end
-  def line_count; end
-  def literal?; end
-  def loop_keyword?; end
-  def lvar_type?; end
-  def lvasgn_type?; end
-  def masgn_type?; end
-  def match_alt_type?; end
-  def match_as_type?; end
-  def match_current_line_type?; end
-  def match_guard_clause?(param0 = T.unsafe(nil)); end
-  def match_nil_pattern_type?; end
-  def match_pattern_p_type?; end
-  def match_pattern_type?; end
-  def match_rest_type?; end
-  def match_var_type?; end
-  def match_with_lvasgn_type?; end
-  def match_with_trailing_comma_type?; end
-  def mlhs_type?; end
-  def module_definition?(param0 = T.unsafe(nil)); end
-  def module_type?; end
-  def multiline?; end
-  def mutable_literal?; end
-  def new_class_or_module_block?(param0 = T.unsafe(nil)); end
-  def next_type?; end
-  def nil_type?; end
-  def node_parts; end
-  def nonempty_line_count; end
-  def not_type?; end
-  def nth_ref_type?; end
-  def numargs_type?; end
-  def numblock_type?; end
-  def numeric_type?; end
-  def objc_kwarg_type?; end
-  def objc_restarg_type?; end
-  def objc_varargs_type?; end
-  def op_asgn_type?; end
-  def operator_keyword?; end
-  def optarg_type?; end
-  def or_asgn_type?; end
-  def or_type?; end
-  def pair_type?; end
-  def parent; end
-  def parent?; end
-  def parent_module_name; end
-  def parenthesized_call?; end
-  def pin_type?; end
-  def post_condition_loop?; end
-  def postexe_type?; end
-  def preexe_type?; end
-  def proc?(param0 = T.unsafe(nil)); end
-  def procarg0_type?; end
-  def pure?; end
-  def range_type?; end
-  def rational_type?; end
-  def receiver(param0 = T.unsafe(nil)); end
-  def recursive_basic_literal?; end
-  def recursive_literal?; end
-  def redo_type?; end
-  def reference?; end
-  def regexp_type?; end
-  def regopt_type?; end
-  def resbody_type?; end
-  def rescue_type?; end
-  def restarg_expr_type?; end
-  def restarg_type?; end
-  def retry_type?; end
-  def return_type?; end
-  def right_sibling; end
-  def right_siblings; end
-  def root?; end
-  def sclass_type?; end
-  def self_type?; end
-  def send_type?; end
-  def shadowarg_type?; end
-  def shorthand_asgn?; end
-  def sibling_index; end
-  def single_line?; end
-  def source; end
-  def source_length; end
-  def source_range; end
-  def special_keyword?; end
-  def splat_type?; end
-  def str_content(param0 = T.unsafe(nil)); end
-  def str_type?; end
-  def struct_constructor?(param0 = T.unsafe(nil)); end
-  def super_type?; end
-  def sym_type?; end
-  def true_type?; end
-  def truthy_literal?; end
-  def undef_type?; end
-  def unless_guard_type?; end
-  def until_post_type?; end
-  def until_type?; end
-  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
-  def value_used?; end
-  def variable?; end
-  def when_type?; end
-  def while_post_type?; end
-  def while_type?; end
-  def xstr_type?; end
-  def yield_type?; end
-  def zsuper_type?; end
-
-  protected
-
-  def parent=(node); end
-
-  private
-
-  def begin_value_used?; end
-  def case_if_value_used?; end
-  def defined_module0(param0 = T.unsafe(nil)); end
-  def for_value_used?; end
-  def parent_module_name_for_block(ancestor); end
-  def parent_module_name_for_sclass(sclass_node); end
-  def parent_module_name_part(node); end
-  def visit_ancestors(types); end
-  def while_until_value_used?; end
-end
-
-RuboCop::AST::Node::ARGUMENT_TYPES = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::ASSIGNMENTS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::BASIC_CONDITIONALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::BASIC_LITERALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::COMPOSITE_LITERALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::CONDITIONALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::EQUALS_ASSIGNMENTS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::FALSEY_LITERALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::IMMUTABLE_LITERALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::KEYWORDS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::LITERALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::LITERAL_RECURSIVE_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::LITERAL_RECURSIVE_TYPES = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::LOOP_TYPES = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::MUTABLE_LITERALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::OPERATOR_KEYWORDS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::REFERENCES = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::SPECIAL_KEYWORDS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::TRUTHY_LITERALS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Node::VARIABLES = T.let(T.unsafe(nil), Set)
-
-class RuboCop::AST::NodePattern
-  include ::RuboCop::AST::NodePattern::MethodDefiner
-  extend ::Forwardable
-
-  def initialize(str, compiler: T.unsafe(nil)); end
-
-  def ==(other); end
-  def as_json(_options = T.unsafe(nil)); end
-  def ast; end
-  def captures(*args, &block); end
-  def encode_with(coder); end
-  def eql?(other); end
-  def freeze; end
-  def init_with(coder); end
-  def marshal_dump; end
-  def marshal_load(pattern); end
-  def match(*args, **rest, &block); end
-  def match_code; end
-  def named_parameters(*args, &block); end
-  def pattern; end
-  def positional_parameters(*args, &block); end
-  def to_s; end
-
-  class << self
-    def descend(element, &block); end
-  end
-end
-
-class RuboCop::AST::NodePattern::Builder
-  def emit_atom(type, value); end
-  def emit_call(type, selector, args = T.unsafe(nil)); end
-  def emit_capture(capture_token, node); end
-  def emit_list(type, _begin, children, _end); end
-  def emit_subsequence(node_list); end
-  def emit_unary_op(type, _operator = T.unsafe(nil), *children); end
-  def emit_union(begin_t, pattern_lists, end_t); end
-
-  private
-
-  def n(type, *args); end
-  def optimizable_as_set?(children); end
-  def union_children(pattern_lists); end
-end
-
-class RuboCop::AST::NodePattern::Comment
-  def initialize(range); end
-
-  def ==(other); end
-  def inspect; end
-  def loc; end
-  def location; end
-  def text; end
-end
-
-class RuboCop::AST::NodePattern::Compiler
-  extend ::Forwardable
-
-  def initialize; end
-
-  def bind(*args, &block); end
-  def binding; end
-  def captures; end
-  def compile_as_atom(node); end
-  def compile_as_node_pattern(node, **options); end
-  def compile_sequence(sequence, var:); end
-  def each_union(enum, &block); end
-  def freeze; end
-  def named_parameter(name); end
-  def named_parameters; end
-  def next_capture; end
-  def parser; end
-  def positional_parameter(number); end
-  def positional_parameters; end
-  def with_temp_variables(*names, &block); end
-
-  private
-
-  def enforce_same_captures(enum); end
-  def new_capture; end
-end
-
-class RuboCop::AST::NodePattern::Compiler::AtomSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
-  private
-
-  def visit_const; end
-  def visit_named_parameter; end
-  def visit_number; end
-  def visit_other_type; end
-  def visit_positional_parameter; end
-  def visit_regexp; end
-  def visit_set; end
-  def visit_string; end
-  def visit_symbol; end
-  def visit_unify; end
-end
-
-class RuboCop::AST::NodePattern::Compiler::Binding
-  def initialize; end
-
-  def bind(name); end
-  def union_bind(enum); end
-
-  private
-
-  def forbid(names); end
-end
-
-class RuboCop::AST::NodePattern::Compiler::Debug < ::RuboCop::AST::NodePattern::Compiler
-  def initialize; end
-
-  def comments(*args, &block); end
-  def named_parameters; end
-  def node_ids; end
-  def parser; end
-  def tokens(*args, &block); end
-end
-
-class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer
-  def initialize(pattern, compiler: T.unsafe(nil)); end
-
-  def compiler; end
-  def node_pattern; end
-  def pattern; end
-  def test(ruby, trace: T.unsafe(nil)); end
-
-  private
-
-  def ruby_ast(ruby); end
-  def ruby_parser; end
-end
-
-RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::COLOR_SCHEME = T.let(T.unsafe(nil), Hash)
-RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Compiler = RuboCop::AST::NodePattern::Compiler::Debug
-
-class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Result < ::Struct
-  def color_map(color_scheme = T.unsafe(nil)); end
-  def colorize(color_scheme = T.unsafe(nil)); end
-  def colorizer; end
-  def colorizer=(_); end
-  def match_map; end
-  def matched?(node); end
-  def returned; end
-  def returned=(_); end
-  def ruby_ast; end
-  def ruby_ast=(_); end
-  def trace; end
-  def trace=(_); end
-
-  private
-
-  def ast; end
-  def color_map_for(node, color); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-module RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
-  def do_compile; end
-
-  private
-
-  def node_id; end
-  def tracer(kind); end
-end
-
-class RuboCop::AST::NodePattern::Compiler::Debug::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler
-  include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
-end
-
-class RuboCop::AST::NodePattern::Compiler::Debug::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler
-  include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
-end
-
-class RuboCop::AST::NodePattern::Compiler::Debug::Trace
-  def initialize; end
-
-  def enter(node_id); end
-  def matched?(node_id); end
-  def success(node_id); end
-end
-
-class RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
-  def initialize(compiler, var: T.unsafe(nil), access: T.unsafe(nil), seq_head: T.unsafe(nil)); end
-
-  def access; end
-  def seq_head; end
-
-  private
-
-  def access_element; end
-  def access_node; end
-  def compile_args(arg_list, first: T.unsafe(nil)); end
-  def compile_guard_clause; end
-  def compile_value_match(value); end
-  def multiple_access(kind); end
-  def visit_ascend; end
-  def visit_capture; end
-  def visit_descend; end
-  def visit_function_call; end
-  def visit_intersection; end
-  def visit_negation; end
-  def visit_node_type; end
-  def visit_other_type; end
-  def visit_predicate; end
-  def visit_sequence; end
-  def visit_unify; end
-  def visit_union; end
-  def visit_wildcard; end
-end
-
-class RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
-  def initialize(compiler, sequence:, var:); end
-
-  def compile_sequence; end
-  def in_sync; end
-
-  protected
-
-  def compile_terms(children = T.unsafe(nil), last_arity = T.unsafe(nil)); end
-  def cur_index; end
-  def sync; end
-
-  private
-
-  def compile_and_advance(term); end
-  def compile_any_order_branches(matched_var); end
-  def compile_any_order_else; end
-  def compile_captured_repetition(child_code, child_captures); end
-  def compile_case(when_branches, else_code); end
-  def compile_child_nb_guard(arity_range); end
-  def compile_cur_index; end
-  def compile_index(cur = T.unsafe(nil)); end
-  def compile_loop(term); end
-  def compile_loop_advance(to = T.unsafe(nil)); end
-  def compile_matched(kind); end
-  def compile_max_matched; end
-  def compile_min_check; end
-  def compile_remaining; end
-  def compile_union_forks; end
-  def empty_loop; end
-  def handle_prev; end
-  def merge_forks!(forks); end
-  def preserve_union_start(forks); end
-  def remaining_arities(children, last_arity); end
-  def use_index_from_end; end
-  def visit_any_order; end
-  def visit_capture; end
-  def visit_other_type; end
-  def visit_repetition; end
-  def visit_rest; end
-  def visit_union; end
-  def within_loop; end
-end
-
-RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::DELTA = T.let(T.unsafe(nil), Integer)
-RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::POSITIVE = T.let(T.unsafe(nil), Proc)
-
-class RuboCop::AST::NodePattern::Compiler::Subcompiler
-  def initialize(compiler); end
-
-  def compile(node); end
-  def compiler; end
-
-  private
-
-  def do_compile; end
-  def node; end
-
-  class << self
-    def inherited(base); end
-    def method_added(method); end
-    def registry; end
-  end
-end
-
-class RuboCop::AST::NodePattern::Invalid < ::StandardError; end
-
-class RuboCop::AST::NodePattern::Lexer < ::RuboCop::AST::NodePattern::LexerRex
-  def initialize(source); end
-
-  def comments; end
-  def source_buffer; end
-  def tokens; end
-
-  private
-
-  def do_parse; end
-  def emit(type); end
-  def emit_comment; end
-  def emit_regexp; end
-  def token(type, value); end
-end
-
-RuboCop::AST::NodePattern::Lexer::Error = RuboCop::AST::NodePattern::LexerRex::ScanError
-RuboCop::AST::NodePattern::Lexer::REGEXP_OPTIONS = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::AST::NodePattern::LexerRex
-  def action; end
-  def filename; end
-  def filename=(_arg0); end
-  def location; end
-  def match; end
-  def matches; end
-  def next_token; end
-  def parse(str); end
-  def parse_file(path); end
-  def scanner_class; end
-  def ss; end
-  def ss=(_arg0); end
-  def state; end
-  def state=(_arg0); end
-end
-
-RuboCop::AST::NodePattern::LexerRex::CALL = T.let(T.unsafe(nil), Regexp)
-RuboCop::AST::NodePattern::LexerRex::CONST_NAME = T.let(T.unsafe(nil), Regexp)
-RuboCop::AST::NodePattern::LexerRex::IDENTIFIER = T.let(T.unsafe(nil), Regexp)
-class RuboCop::AST::NodePattern::LexerRex::LexerError < ::StandardError; end
-RuboCop::AST::NodePattern::LexerRex::NODE_TYPE = T.let(T.unsafe(nil), Regexp)
-RuboCop::AST::NodePattern::LexerRex::REGEXP = T.let(T.unsafe(nil), Regexp)
-RuboCop::AST::NodePattern::LexerRex::REGEXP_BODY = T.let(T.unsafe(nil), Regexp)
-RuboCop::AST::NodePattern::LexerRex::SYMBOL_NAME = T.let(T.unsafe(nil), Regexp)
-class RuboCop::AST::NodePattern::LexerRex::ScanError < ::RuboCop::AST::NodePattern::LexerRex::LexerError; end
-
-module RuboCop::AST::NodePattern::Macros
-  def def_node_matcher(method_name, pattern_str, **keyword_defaults); end
-  def def_node_search(method_name, pattern_str, **keyword_defaults); end
-end
-
-module RuboCop::AST::NodePattern::MethodDefiner
-  def as_lambda; end
-  def compile_as_lambda; end
-  def def_node_matcher(base, method_name, **defaults); end
-  def def_node_search(base, method_name, **defaults); end
-
-  private
-
-  def compile_init; end
-  def def_helper(base, method_name, **defaults); end
-  def emit_keyword_list(forwarding: T.unsafe(nil)); end
-  def emit_lambda_code; end
-  def emit_method_code; end
-  def emit_node_search(method_name); end
-  def emit_node_search_body(method_name, prelude:, on_match:); end
-  def emit_param_list; end
-  def emit_params(*first, forwarding: T.unsafe(nil)); end
-  def emit_retval; end
-  def emit_yield_capture(when_no_capture = T.unsafe(nil), yield_with: T.unsafe(nil)); end
-  def wrapping_block(method_name, **defaults); end
-end
-
-class RuboCop::AST::NodePattern::Node < ::Parser::AST::Node
-  include ::RuboCop::AST::Descendence
-  extend ::Forwardable
-
-  def arity; end
-  def arity_range; end
-  def capture?; end
-  def child; end
-  def children_nodes; end
-  def in_sequence_head; end
-  def matches_within_set?; end
-  def nb_captures; end
-  def rest?; end
-  def variadic?; end
-  def with(type: T.unsafe(nil), children: T.unsafe(nil), location: T.unsafe(nil)); end
-end
-
-class RuboCop::AST::NodePattern::Node::AnyOrder < ::RuboCop::AST::NodePattern::Node
-  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
-
-  def arity; end
-  def ends_with_rest?; end
-  def rest_node; end
-  def term_nodes; end
-end
-
-RuboCop::AST::NodePattern::Node::AnyOrder::ARITIES = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::AST::NodePattern::Node::Capture < ::RuboCop::AST::NodePattern::Node
-  def arity(*args, &block); end
-  def capture?; end
-  def in_sequence_head; end
-  def nb_captures; end
-  def rest?(*args, &block); end
-end
-
-module RuboCop::AST::NodePattern::Node::ForbidInSeqHead
-  def in_sequence_head; end
-end
-
-RuboCop::AST::NodePattern::Node::FunctionCall = RuboCop::AST::NodePattern::Node::Predicate
-RuboCop::AST::NodePattern::Node::INT_TO_RANGE = T.let(T.unsafe(nil), Hash)
-RuboCop::AST::NodePattern::Node::MAP = T.let(T.unsafe(nil), Hash)
-RuboCop::AST::NodePattern::Node::MATCHES_WITHIN_SET = T.let(T.unsafe(nil), Set)
-
-class RuboCop::AST::NodePattern::Node::Predicate < ::RuboCop::AST::NodePattern::Node
-  def arg_list; end
-  def method_name; end
-end
-
-class RuboCop::AST::NodePattern::Node::Repetition < ::RuboCop::AST::NodePattern::Node
-  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
-
-  def arity; end
-  def operator; end
-end
-
-RuboCop::AST::NodePattern::Node::Repetition::ARITIES = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::AST::NodePattern::Node::Rest < ::RuboCop::AST::NodePattern::Node
-  def arity; end
-  def in_sequence_head; end
-  def rest?; end
-end
-
-RuboCop::AST::NodePattern::Node::Rest::ARITY = T.let(T.unsafe(nil), Range)
-
-class RuboCop::AST::NodePattern::Node::Sequence < ::RuboCop::AST::NodePattern::Node
-  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
-
-  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
-end
-
-class RuboCop::AST::NodePattern::Node::Subsequence < ::RuboCop::AST::NodePattern::Node
-  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
-
-  def arity; end
-  def in_sequence_head; end
-end
-
-class RuboCop::AST::NodePattern::Node::Union < ::RuboCop::AST::NodePattern::Node
-  def arity; end
-  def in_sequence_head; end
-end
-
-class RuboCop::AST::NodePattern::Parser < ::Racc::Parser
-  extend ::Forwardable
-
-  def initialize(builder = T.unsafe(nil)); end
-
-  def _reduce_10(val, _values); end
-  def _reduce_11(val, _values); end
-  def _reduce_13(val, _values); end
-  def _reduce_14(val, _values); end
-  def _reduce_15(val, _values); end
-  def _reduce_16(val, _values); end
-  def _reduce_17(val, _values); end
-  def _reduce_18(val, _values); end
-  def _reduce_19(val, _values); end
-  def _reduce_2(val, _values); end
-  def _reduce_20(val, _values); end
-  def _reduce_21(val, _values); end
-  def _reduce_22(val, _values); end
-  def _reduce_25(val, _values); end
-  def _reduce_26(val, _values); end
-  def _reduce_3(val, _values); end
-  def _reduce_33(val, _values); end
-  def _reduce_37(val, _values); end
-  def _reduce_38(val, _values); end
-  def _reduce_39(val, _values); end
-  def _reduce_4(val, _values); end
-  def _reduce_40(val, _values); end
-  def _reduce_41(val, _values); end
-  def _reduce_42(val, _values); end
-  def _reduce_43(val, _values); end
-  def _reduce_44(val, _values); end
-  def _reduce_45(val, _values); end
-  def _reduce_46(val, _values); end
-  def _reduce_5(val, _values); end
-  def _reduce_6(val, _values); end
-  def _reduce_7(val, _values); end
-  def _reduce_8(val, _values); end
-  def _reduce_9(val, _values); end
-  def _reduce_none(val, _values); end
-  def emit_atom(*args, &block); end
-  def emit_call(*args, &block); end
-  def emit_capture(*args, &block); end
-  def emit_list(*args, &block); end
-  def emit_unary_op(*args, &block); end
-  def emit_union(*args, &block); end
-  def inspect; end
-  def next_token(*args, &block); end
-  def parse(source); end
-
-  private
-
-  def enforce_unary(node); end
-  def on_error(token, val, _vstack); end
-end
-
-RuboCop::AST::NodePattern::Parser::Builder = RuboCop::AST::NodePattern::Builder
-RuboCop::AST::NodePattern::Parser::Lexer = RuboCop::AST::NodePattern::Lexer
-RuboCop::AST::NodePattern::Parser::Racc_arg = T.let(T.unsafe(nil), Array)
-RuboCop::AST::NodePattern::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
-
-class RuboCop::AST::NodePattern::Parser::WithMeta < ::RuboCop::AST::NodePattern::Parser
-  def comments; end
-  def do_parse; end
-  def tokens; end
-end
-
-class RuboCop::AST::NodePattern::Parser::WithMeta::Builder < ::RuboCop::AST::NodePattern::Builder
-  def emit_atom(type, token); end
-  def emit_call(type, selector_t, args = T.unsafe(nil)); end
-  def emit_list(type, begin_t, children, end_t); end
-  def emit_unary_op(type, operator_t = T.unsafe(nil), *children); end
-
-  private
-
-  def join_exprs(left_expr, right_expr); end
-  def loc(token_or_range); end
-  def n(type, children, source_map); end
-  def source_map(token_or_range, begin_t: T.unsafe(nil), end_t: T.unsafe(nil), operator_t: T.unsafe(nil), selector_t: T.unsafe(nil)); end
-end
-
-class RuboCop::AST::NodePattern::Parser::WithMeta::Lexer < ::RuboCop::AST::NodePattern::Lexer
-  def initialize(str_or_buffer); end
-
-  def emit_comment; end
-  def pos; end
-  def source_buffer; end
-  def token(type, value); end
-end
-
-module RuboCop::AST::NodePattern::Sets
-  class << self
-    def [](set); end
-    def name(set); end
-    def uniq(name); end
-  end
-end
-
-RuboCop::AST::NodePattern::Sets::MAX = T.let(T.unsafe(nil), Integer)
-RuboCop::AST::NodePattern::Sets::REGISTRY = T.let(T.unsafe(nil), Hash)
-RuboCop::AST::NodePattern::Sets::SET_0_1 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_0_1_2 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_10_10 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_1_1 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_1_2 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ABSTRACT_OVERRIDE_OVERRIDABLE_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ADD_DEPENDENCY_ADD_RUNTIME_DEPENDENCY_ADD_DEVELOPMENT_DEPENDENCY = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_AFTER_ACTION_APPEND_AFTER_ACTION_APPEND_AROUND_ACTION_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ALL_CONTEXT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_AND_RETURN_AND_RAISE_AND_THROW_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ANY_ALL_NORETURN_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_AP_P_PP_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR_ATTR = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_BACKGROUND_SCENARIO_XSCENARIO_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_BEFORE_AFTER = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_BELONGS_TO_HAS_ONE_HAS_MANY_HAS_AND_BELONGS_TO_MANY = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_BE_EQ_EQL_EQUAL = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_BE_TRUTHY_BE_FALSEY_BE_FALSY_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_BINWRITE_SYSWRITE_WRITE_WRITE_NONBLOCK = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_BRANCH_REF_TAG = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CALLER_CALLER_LOCATIONS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CALL_RUN = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CAPTURE2_CAPTURE2E_CAPTURE3_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CHANGE_COLUMN_EXECUTE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CIPHER_DIGEST = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_INSTANCE_EVAL = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE_STRUCT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CONSTANTIZE_CONSTANTS_CONST_GET = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CONTEXT_SHARED_CONTEXT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_COUNT_LENGTH_SIZE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CREATED_AT_UPDATED_AT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_CREATED_AT_UPDATED_AT_2 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD_DEFINE_SINGLETON_METHOD = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_DOUBLE_SPY = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_DOWNCASE_UPCASE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_EACH_EXAMPLE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_INDEX_WITH_INDEX = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_OBJECT_WITH_OBJECT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ENUMERATOR_RATIONAL_COMPLEX_THREAD = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_EQL_EQ_BE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ESCAPE_ENCODE_UNESCAPE_DECODE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_EXACTLY_AT_LEAST_AT_MOST = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_EXIST_EXISTS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_EXPECT_ALLOW = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_FACTORYGIRL_FACTORYBOT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_FILETEST_FILE_DIR_SHELL = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_FIRST_LAST__ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_FIXNUM_BIGNUM = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_FLATTEN_FLATTEN = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_FORMAT_SPRINTF_PRINTF = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_GET_POST_PUT_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_GSUB_GSUB = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_GSUB_GSUB_SUB_SUB = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_HAS_MANY_HAS_ONE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_HAS_MANY_HAS_ONE_BELONGS_TO = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_INCLUDE_EXTEND_PREPEND = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_INCLUDE_MEMBER = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_INSERT_INSERT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EVAL_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EXEC_CLASS_EXEC_MODULE_EXEC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_IO_FILE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_IS_EXPECTED_SHOULD_SHOULD_NOT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_KEYS_VALUES = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_KEY_HAS_KEY_FETCH_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_LAST_FIRST = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_LENGTH_SIZE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_LOAD_RESTORE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_MAP_COLLECT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_MATCH_MATCH = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_MATCH__MATCH = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_MESSAGES_DETAILS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_NEW_ = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_NEW_COMPILE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_NEW_OPEN = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_NIL_ = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_NOTICE_ALERT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ONLY_EXCEPT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_PIPELINE_PIPELINE_R_PIPELINE_RW_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED_PUBLIC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_PROC_LAMBDA = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_PROP_CONST = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_PUBLIC_CONSTANT_PRIVATE_CONSTANT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_PUBLIC_PROTECTED_PRIVATE_MODULE_FUNCTION = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RAISE_ERROR_RAISE_EXCEPTION = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL_THROW_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RECEIVE_HAVE_RECEIVED = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RECEIVE_MESSAGE_CHAIN_STUB_CHAIN = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RECEIVE_RECEIVE_MESSAGES_RECEIVE_MESSAGE_CHAIN_HAVE_RECEIVED = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RECEIVE_RECEIVE_MESSAGE_CHAIN = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_REDUCE_INJECT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_REFERER_REFERRER = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_REJECT_DELETE_IF_REJECT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_REJECT_REJECT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RENDER_REDIRECT_TO = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_REQUIRE_REQUIRE_RELATIVE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_RETURNING_UNIQUE_BY = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ROOT_PUBLIC_PATH = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SELECT_FILTER_FIND_ALL_REJECT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SELECT_SELECT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SEND_PUBLIC_SEND___SEND__ = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SHOULD_SHOULD_NOT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SKIP_AFTER_ACTION_SKIP_AROUND_ACTION_SKIP_BEFORE_ACTION_SKIP_ACTION_CALLBACK = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SKIP_PENDING = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SORT_BY_SORT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SORT_MIN_MAX = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SPAWN_SYSTEM = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SPRINTF_FORMAT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_START_WITH_END_WITH = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_START_WITH_STARTS_WITH_END_WITH_ENDS_WITH = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_STRUCT_CLASS = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_SUCC_PRED_NEXT = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TEMPFILE_STRINGIO = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TO_ENUM_ENUM_FOR = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TO_H_TO_HASH = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TO_I_TO_F_TO_C_TO_R = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TRANSLATE_LOCALIZE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TRANSLATE_T = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TRUE_FALSE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TRY_TRY = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_TYPE_TEMPLATE_TYPE_MEMBER = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_ZERO_POSITIVE_NEGATIVE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET__ = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET__AT_SLICE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET__EQL_ = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET__EQUAL_EQL = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET__FETCH = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET__GLOB = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___ = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___2 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___3 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___4 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___5 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___6 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___7 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___8 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___EQL_ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___EQL_INCLUDE = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET___METHOD_____CALLEE__ = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET____ = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET____ETC = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET____ETC_2 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET____ETC_3 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::Sets::SET_____2 = T.let(T.unsafe(nil), Set)
-RuboCop::AST::NodePattern::VAR = T.let(T.unsafe(nil), String)
-
-module RuboCop::AST::NumericNode
-  def sign?; end
-end
-
-RuboCop::AST::NumericNode::SIGN_REGEX = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::AST::OpAsgnNode < ::RuboCop::AST::Node
-  def assignment_node; end
-  def expression; end
-  def name; end
-  def operator; end
-end
-
-class RuboCop::AST::OrAsgnNode < ::RuboCop::AST::OpAsgnNode
-  def operator; end
-end
-
-class RuboCop::AST::OrNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::BinaryOperatorNode
-  include ::RuboCop::AST::PredicateOperatorNode
-
-  def alternate_operator; end
-  def inverse_operator; end
-end
-
-class RuboCop::AST::PairNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::HashElementNode
-
-  def colon?; end
-  def delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
-  def hash_rocket?; end
-  def inverse_delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
-  def value_omission?; end
-  def value_on_new_line?; end
-end
-
-RuboCop::AST::PairNode::COLON = T.let(T.unsafe(nil), String)
-RuboCop::AST::PairNode::HASH_ROCKET = T.let(T.unsafe(nil), String)
-RuboCop::AST::PairNode::SPACED_COLON = T.let(T.unsafe(nil), String)
-RuboCop::AST::PairNode::SPACED_HASH_ROCKET = T.let(T.unsafe(nil), String)
-
-module RuboCop::AST::ParameterizedNode
-  def arguments?; end
-  def block_argument?; end
-  def first_argument; end
-  def last_argument; end
-  def parenthesized?; end
-  def rest_argument?; end
-  def splat_argument?; end
-end
-
-module RuboCop::AST::ParameterizedNode::RestArguments
-  include ::RuboCop::AST::ParameterizedNode
-
-  def arguments; end
-  def arguments?; end
-  def first_argument; end
-  def last_argument; end
-end
-
-module RuboCop::AST::ParameterizedNode::WrappedArguments
-  include ::RuboCop::AST::ParameterizedNode
-
-  def arguments; end
-end
-
-module RuboCop::AST::PredicateOperatorNode
-  def logical_operator?; end
-  def operator; end
-  def semantic_operator?; end
-end
-
-RuboCop::AST::PredicateOperatorNode::LOGICAL_AND = T.let(T.unsafe(nil), String)
-RuboCop::AST::PredicateOperatorNode::LOGICAL_OR = T.let(T.unsafe(nil), String)
-RuboCop::AST::PredicateOperatorNode::SEMANTIC_AND = T.let(T.unsafe(nil), String)
-RuboCop::AST::PredicateOperatorNode::SEMANTIC_OR = T.let(T.unsafe(nil), String)
-
-class RuboCop::AST::Procarg0Node < ::RuboCop::AST::ArgNode
-  def name; end
-end
-
-class RuboCop::AST::ProcessedSource
-  include ::RuboCop::Ext::ProcessedSource
-
-  def initialize(source, ruby_version, path = T.unsafe(nil)); end
-
-  def [](*args); end
-  def ast; end
-  def ast_with_comments; end
-  def blank?; end
-  def buffer; end
-  def checksum; end
-  def comment_at_line(line); end
-  def commented?(source_range); end
-  def comments; end
-  def comments_before_line(line); end
-  def contains_comment?(source_range); end
-  def current_line(token); end
-  def diagnostics; end
-  def each_comment(&block); end
-  def each_comment_in_lines(line_range); end
-  def each_token(&block); end
-  def file_path; end
-  def find_comment(&block); end
-  def find_token(&block); end
-  def first_token_of(range_or_node); end
-  def following_line(token); end
-  def last_token_of(range_or_node); end
-  def line_indentation(line_number); end
-  def line_with_comment?(line); end
-  def lines; end
-  def parser_error; end
-  def path; end
-  def preceding_line(token); end
-  def raw_source; end
-  def ruby_version; end
-  def sorted_tokens; end
-  def start_with?(string); end
-  def tokens; end
-  def tokens_within(range_or_node); end
-  def valid_syntax?; end
-
-  private
-
-  def comment_index; end
-  def create_parser(ruby_version); end
-  def first_token_index(range_or_node); end
-  def last_token_index(range_or_node); end
-  def parse(source, ruby_version); end
-  def parser_class(ruby_version); end
-  def source_range(range_or_node); end
-  def tokenize(parser); end
-
-  class << self
-    def from_file(path, ruby_version); end
-  end
-end
-
-RuboCop::AST::ProcessedSource::INVALID_LEVELS = T.let(T.unsafe(nil), Array)
-RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME = T.let(T.unsafe(nil), String)
-
-class RuboCop::AST::RangeNode < ::RuboCop::AST::Node
-  def begin; end
-  def end; end
-end
-
-class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node
-  include ::RuboCop::Ext::RegexpNode
-
-  def content; end
-  def delimiter?(char); end
-  def delimiters; end
-  def extended?; end
-  def ignore_case?; end
-  def interpolation?; end
-  def multiline_mode?; end
-  def no_encoding?; end
-  def options; end
-  def percent_r_literal?; end
-  def regopt; end
-  def single_interpolation?; end
-  def slash_literal?; end
-  def to_regexp; end
-
-  private
-
-  def regopt_include?(option); end
-end
-
-RuboCop::AST::RegexpNode::OPTIONS = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::AST::ResbodyNode < ::RuboCop::AST::Node
-  def body; end
-  def branch_index; end
-  def exception_variable; end
-  def exceptions; end
-end
-
-class RuboCop::AST::RescueNode < ::RuboCop::AST::Node
-  def body; end
-  def branches; end
-  def else?; end
-  def else_branch; end
-  def resbody_branches; end
-end
-
-class RuboCop::AST::ReturnNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ParameterizedNode
-  include ::RuboCop::AST::ParameterizedNode::WrappedArguments
-end
-
-module RuboCop::AST::RuboCopCompatibility
-  def rubocop_loaded; end
-end
-
-RuboCop::AST::RuboCopCompatibility::INCOMPATIBLE_COPS = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::AST::SelfClassNode < ::RuboCop::AST::Node
-  def body; end
-  def identifier; end
-end
-
-class RuboCop::AST::SendNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ParameterizedNode
-  include ::RuboCop::AST::ParameterizedNode::RestArguments
-  include ::RuboCop::AST::MethodIdentifierPredicates
-  include ::RuboCop::AST::MethodDispatchNode
-
-  def attribute_accessor?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def first_argument_index; end
-end
-
-module RuboCop::AST::Sexp
-  def s(type, *children); end
-end
-
-class RuboCop::AST::StrNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::BasicLiteralNode
-
-  def heredoc?; end
-end
-
-class RuboCop::AST::SuperNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ParameterizedNode
-  include ::RuboCop::AST::MethodIdentifierPredicates
-  include ::RuboCop::AST::MethodDispatchNode
-
-  def arguments; end
-  def node_parts; end
-end
-
-class RuboCop::AST::SymbolNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::BasicLiteralNode
-end
-
-class RuboCop::AST::Token
-  def initialize(pos, type, text); end
-
-  def begin_pos; end
-  def column; end
-  def comma?; end
-  def comment?; end
-  def end?; end
-  def end_pos; end
-  def equal_sign?; end
-  def left_array_bracket?; end
-  def left_brace?; end
-  def left_bracket?; end
-  def left_curly_brace?; end
-  def left_parens?; end
-  def left_ref_bracket?; end
-  def line; end
-  def pos; end
-  def regexp_dots?; end
-  def rescue_modifier?; end
-  def right_bracket?; end
-  def right_curly_brace?; end
-  def right_parens?; end
-  def semicolon?; end
-  def space_after?; end
-  def space_before?; end
-  def text; end
-  def to_s; end
-  def type; end
-
-  class << self
-    def from_parser_token(parser_token); end
-  end
-end
-
-module RuboCop::AST::Traversal
-  extend ::RuboCop::AST::Traversal::CallbackCompiler
-
-  def on_(node); end
-  def on___ENCODING__(node); end
-  def on___FILE__(node); end
-  def on___LINE__(node); end
-  def on_alias(node); end
-  def on_and(node); end
-  def on_and_asgn(node); end
-  def on_arg(node); end
-  def on_arg_expr(node); end
-  def on_args(node); end
-  def on_array(node); end
-  def on_array_pattern(node); end
-  def on_array_pattern_with_tail(node); end
-  def on_back_ref(node); end
-  def on_begin(node); end
-  def on_block(node); end
-  def on_block_pass(node); end
-  def on_blockarg(node); end
-  def on_break(node); end
-  def on_case(node); end
-  def on_case_match(node); end
-  def on_casgn(node); end
-  def on_cbase(node); end
-  def on_class(node); end
-  def on_complex(node); end
-  def on_const(node); end
-  def on_const_pattern(node); end
-  def on_csend(node); end
-  def on_cvar(node); end
-  def on_cvasgn(node); end
-  def on_def(node); end
-  def on_defined?(node); end
-  def on_defs(node); end
-  def on_dstr(node); end
-  def on_dsym(node); end
-  def on_eflipflop(node); end
-  def on_empty_else(node); end
-  def on_ensure(node); end
-  def on_erange(node); end
-  def on_false(node); end
-  def on_find_pattern(node); end
-  def on_float(node); end
-  def on_for(node); end
-  def on_forward_arg(node); end
-  def on_forward_args(node); end
-  def on_forwarded_args(node); end
-  def on_gvar(node); end
-  def on_gvasgn(node); end
-  def on_hash(node); end
-  def on_hash_pattern(node); end
-  def on_if(node); end
-  def on_if_guard(node); end
-  def on_iflipflop(node); end
-  def on_in_match(node); end
-  def on_in_pattern(node); end
-  def on_index(node); end
-  def on_indexasgn(node); end
-  def on_int(node); end
-  def on_irange(node); end
-  def on_ivar(node); end
-  def on_ivasgn(node); end
-  def on_kwarg(node); end
-  def on_kwargs(node); end
-  def on_kwbegin(node); end
-  def on_kwnilarg(node); end
-  def on_kwoptarg(node); end
-  def on_kwrestarg(node); end
-  def on_kwsplat(node); end
-  def on_lambda(node); end
-  def on_lvar(node); end
-  def on_lvasgn(node); end
-  def on_masgn(node); end
-  def on_match_alt(node); end
-  def on_match_as(node); end
-  def on_match_current_line(node); end
-  def on_match_nil_pattern(node); end
-  def on_match_pattern(node); end
-  def on_match_pattern_p(node); end
-  def on_match_rest(node); end
-  def on_match_var(node); end
-  def on_match_with_lvasgn(node); end
-  def on_match_with_trailing_comma(node); end
-  def on_mlhs(node); end
-  def on_module(node); end
-  def on_mrasgn(node); end
-  def on_next(node); end
-  def on_nil(node); end
-  def on_not(node); end
-  def on_nth_ref(node); end
-  def on_numblock(node); end
-  def on_op_asgn(node); end
-  def on_optarg(node); end
-  def on_or(node); end
-  def on_or_asgn(node); end
-  def on_pair(node); end
-  def on_pin(node); end
-  def on_postexe(node); end
-  def on_preexe(node); end
-  def on_procarg0(node); end
-  def on_rasgn(node); end
-  def on_rational(node); end
-  def on_redo(node); end
-  def on_regexp(node); end
-  def on_regopt(node); end
-  def on_resbody(node); end
-  def on_rescue(node); end
-  def on_restarg(node); end
-  def on_retry(node); end
-  def on_return(node); end
-  def on_sclass(node); end
-  def on_self(node); end
-  def on_send(node); end
-  def on_shadowarg(node); end
-  def on_splat(node); end
-  def on_str(node); end
-  def on_super(node); end
-  def on_sym(node); end
-  def on_true(node); end
-  def on_undef(node); end
-  def on_unless_guard(node); end
-  def on_until(node); end
-  def on_until_post(node); end
-  def on_when(node); end
-  def on_while(node); end
-  def on_while_post(node); end
-  def on_xstr(node); end
-  def on_yield(node); end
-  def on_zsuper(node); end
-  def walk(node); end
-end
-
-module RuboCop::AST::Traversal::CallbackCompiler
-  def arity_check(range); end
-  def body(signature, prelude); end
-  def def_callback(type, *signature, arity: T.unsafe(nil), arity_check: T.unsafe(nil), body: T.unsafe(nil)); end
-end
-
-RuboCop::AST::Traversal::CallbackCompiler::SEND = T.let(T.unsafe(nil), String)
-RuboCop::AST::Traversal::CallbackCompiler::TEMPLATE = T.let(T.unsafe(nil), Hash)
-class RuboCop::AST::Traversal::DebugError < ::RuntimeError; end
-RuboCop::AST::Traversal::NO_CHILD_NODES = T.let(T.unsafe(nil), Set)
-RuboCop::AST::Traversal::TYPE_TO_METHOD = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::AST::UntilNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ConditionalNode
-  include ::RuboCop::AST::ModifierNode
-
-  def do?; end
-  def inverse_keyword; end
-  def keyword; end
-end
-
-module RuboCop::AST::Version; end
-RuboCop::AST::Version::STRING = T.let(T.unsafe(nil), String)
-
-class RuboCop::AST::WhenNode < ::RuboCop::AST::Node
-  def body; end
-  def branch_index; end
-  def conditions; end
-  def each_condition(&block); end
-  def then?; end
-end
-
-class RuboCop::AST::WhileNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ConditionalNode
-  include ::RuboCop::AST::ModifierNode
-
-  def do?; end
-  def inverse_keyword; end
-  def keyword; end
-end
-
-class RuboCop::AST::YieldNode < ::RuboCop::AST::Node
-  include ::RuboCop::AST::ParameterizedNode
-  include ::RuboCop::AST::MethodIdentifierPredicates
-  include ::RuboCop::AST::MethodDispatchNode
-
-  def arguments; end
-  def node_parts; end
-end
-
-RuboCop::NodePattern = RuboCop::AST::NodePattern
-RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource
-RuboCop::Token = RuboCop::AST::Token
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@1.33.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@1.33.0.rbi
new file mode 100644
index 0000000000000..4e3b2828dd25b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@1.33.0.rbi
@@ -0,0 +1,7613 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rubocop-ast` gem.
+# Please instead update this file by running `bin/tapioca gem rubocop-ast`.
+
+
+class Parser::Source::Range
+  include ::RuboCop::AST::Ext::Range
+end
+
+# source://rubocop-ast//lib/rubocop/ast/ext/range.rb#3
+module RuboCop; end
+
+# ...
+#
+# source://rubocop-ast//lib/rubocop/ast/ext/range.rb#4
+module RuboCop::AST
+  extend ::RuboCop::AST::RuboCopCompatibility
+end
+
+# A node extension for `alias` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `alias` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/alias_node.rb#8
+class RuboCop::AST::AliasNode < ::RuboCop::AST::Node
+  # Returns the new identifier as specified by the `alias`.
+  #
+  # @return [SymbolNode] the new identifier
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/alias_node.rb#19
+  def new_identifier; end
+
+  # Returns the old identifier as specified by the `alias`.
+  #
+  # @return [SymbolNode] the old identifier
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/alias_node.rb#12
+  def old_identifier; end
+end
+
+# A node extension for `op_asgn` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all assignment nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/and_asgn_node.rb#8
+class RuboCop::AST::AndAsgnNode < ::RuboCop::AST::OpAsgnNode
+  # The operator being used for assignment as a symbol.
+  #
+  # @return [Symbol] the assignment operator
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/and_asgn_node.rb#12
+  def operator; end
+end
+
+# A node extension for `until` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `until` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/and_node.rb#8
+class RuboCop::AST::AndNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::BinaryOperatorNode
+  include ::RuboCop::AST::PredicateOperatorNode
+
+  # Returns the alternate operator of the `and` as a string.
+  # Returns `and` for `&&` and vice versa.
+  #
+  # @return [String] the alternate of the `and` operator
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/and_node.rb#16
+  def alternate_operator; end
+
+  # Returns the inverse keyword of the `and` node as a string.
+  # Returns `||` for `&&` and `or` for `and`.
+  #
+  # @return [String] the inverse of the `and` operator
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/and_node.rb#24
+  def inverse_operator; end
+end
+
+# A node extension for `arg`, `optarg`, `restarg`, `kwarg`, `kwoptarg`,
+# `kwrestarg`, `blockarg`, `shadowarg` and `forward_arg` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all `arg` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/arg_node.rb#9
+class RuboCop::AST::ArgNode < ::RuboCop::AST::Node
+  # Checks whether the argument has a default value
+  #
+  # @return [Boolean] whether the argument has a default value
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/arg_node.rb#29
+  def default?; end
+
+  # Returns the default value of the argument, if any.
+  #
+  # @return [Node, nil] the default value of the argument
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/arg_node.rb#20
+  def default_value; end
+
+  # Returns the name of an argument.
+  #
+  # @return [Symbol, nil] the name of the argument
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/arg_node.rb#13
+  def name; end
+end
+
+# A node extension for `args` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `args` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/args_node.rb#8
+class RuboCop::AST::ArgsNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::CollectionNode
+
+  # Yield each argument from the collection.
+  # Arguments can be inside `mlhs` nodes in the case of destructuring, so this
+  # flattens the collection to just `arg`, `optarg`, `restarg`, `kwarg`,
+  # `kwoptarg`, `kwrestarg`, `blockarg`, `forward_arg` and `shadowarg`.
+  #
+  # @return [Array<Node>] array of argument nodes.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/args_node.rb#34
+  def argument_list; end
+
+  # It returns true if arguments are empty and delimiters do not exist.
+  # @example:
+  #   # true
+  #   def x; end
+  #   x { }
+  #   -> {}
+  #
+  #   # false
+  #   def x(); end
+  #   def x a; end
+  #   x { || }
+  #   -> () {}
+  #   -> a {}
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/args_node.rb#24
+  def empty_and_without_delimiters?; end
+end
+
+# A node extension for `array` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `array` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/array_node.rb#8
+class RuboCop::AST::ArrayNode < ::RuboCop::AST::Node
+  # Checks whether the `array` literal is delimited by either percent or
+  # square brackets
+  #
+  # brackets
+  #
+  # @return [Boolean] whether the array is enclosed in percent or square
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/array_node.rb#64
+  def bracketed?; end
+
+  # Calls the given block for each `value` node in the `array` literal.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/array_node.rb#25
+  def each_value(&block); end
+
+  # Checks whether the `array` literal is delimited by percent brackets.
+  #
+  # @overload percent_literal?
+  # @overload percent_literal?
+  # @return [Boolean] whether the array is enclosed in percent brackets
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/array_node.rb#51
+  def percent_literal?(type = T.unsafe(nil)); end
+
+  # Checks whether the `array` literal is delimited by square brackets.
+  #
+  # @return [Boolean] whether the array is enclosed in square brackets
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/array_node.rb#36
+  def square_brackets?; end
+
+  # Returns an array of all value nodes in the `array` literal.
+  #
+  # @return [Array<Node>] an array of value nodes
+  #
+  # source://ast/2.4.2/lib/ast/node.rb#56
+  def values; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node/array_node.rb#9
+RuboCop::AST::ArrayNode::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Hash)
+
+# A node extension for `lvasgn`, `ivasgn`, `cvasgn`, and `gvasgn` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all assignment nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/asgn_node.rb#8
+class RuboCop::AST::AsgnNode < ::RuboCop::AST::Node
+  # The expression being assigned to the variable.
+  #
+  # @return [Node] the expression being assigned.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/asgn_node.rb#19
+  def expression; end
+
+  # The name of the variable being assigned as a symbol.
+  #
+  # @return [Symbol] the name of the variable being assigned
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/asgn_node.rb#12
+  def name; end
+end
+
+# Common functionality for primitive literal nodes: `sym`, `str`,
+# `int`, `float`, `rational`...
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/basic_literal_node.rb#7
+module RuboCop::AST::BasicLiteralNode
+  # Returns the value of the literal.
+  #
+  # @return [mixed] the value of the literal
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/basic_literal_node.rb#11
+  def value; end
+end
+
+# Common functionality for nodes that are binary operations:
+# `or`, `and` ...
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/binary_operator_node.rb#7
+module RuboCop::AST::BinaryOperatorNode
+  # Returns all of the conditions, including nested conditions,
+  # of the binary operation.
+  #
+  # operation and the let and right hand side of any nested binary
+  # operators
+  #
+  # @return [Array<Node>] the left and right hand side of the binary
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/binary_operator_node.rb#28
+  def conditions; end
+
+  # Returns the left hand side node of the binary operation.
+  #
+  # @return [Node] the left hand side of the binary operation
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/binary_operator_node.rb#11
+  def lhs; end
+
+  # Returns the right hand side node of the binary operation.
+  #
+  # @return [Node] the right hand side of the binary operation
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/binary_operator_node.rb#18
+  def rhs; end
+end
+
+# A node extension for `block` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `send` nodes within RuboCop.
+#
+# A `block` node is essentially a method send with a block. Parser nests
+# the `send` node inside the `block` node.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#11
+class RuboCop::AST::BlockNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::MethodIdentifierPredicates
+
+  # Returns a collection of all descendants of this node that are
+  # argument type nodes. See `ArgsNode#argument_list` for details.
+  #
+  # @return [Array<Node>]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#60
+  def argument_list; end
+
+  # The arguments of this block.
+  # Note that if the block has destructured arguments, `arguments` will
+  # return a `mlhs` node, whereas `argument_list` will return only
+  # actual argument nodes.
+  #
+  # @return [Array<Node>]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#48
+  def arguments; end
+
+  # Checks whether this block takes any arguments.
+  #
+  # @return [Boolean] whether this `block` node takes any arguments
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#85
+  def arguments?; end
+
+  # The body of this block.
+  #
+  # @return [Node, nil] the body of the `block` node or `nil`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#71
+  def body; end
+
+  # Checks whether the `block` literal is delimited by curly braces.
+  #
+  # @return [Boolean] whether the `block` literal is enclosed in braces
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#92
+  def braces?; end
+
+  # The closing delimiter for this `block` literal.
+  #
+  # @return [String] the closing delimiter for the `block` literal
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#120
+  def closing_delimiter; end
+
+  # The delimiters for this `block` literal.
+  #
+  # @return [Array<String>] the delimiters for the `block` literal
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#106
+  def delimiters; end
+
+  # A shorthand for getting the first argument of this block.
+  # Equivalent to `arguments.first`.
+  #
+  # @return [Node, nil] the first argument of this block,
+  #   or `nil` if there are no arguments
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#29
+  def first_argument; end
+
+  # Checks whether the `block` literal is delimited by `do`-`end` keywords.
+  #
+  # @return [Boolean] whether the `block` literal is enclosed in `do`-`end`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#99
+  def keywords?; end
+
+  # Checks whether this `block` literal belongs to a lambda.
+  #
+  # @return [Boolean] whether the `block` literal belongs to a lambda
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#143
+  def lambda?; end
+
+  # A shorthand for getting the last argument of this block.
+  # Equivalent to `arguments.last`.
+  #
+  # @return [Node, nil] the last argument of this block,
+  #   or `nil` if there are no arguments
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#38
+  def last_argument; end
+
+  # The name of the dispatched method as a symbol.
+  #
+  # @return [Symbol] the name of the dispatched method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#78
+  def method_name; end
+
+  # Checks whether this is a multiline block. This is overridden here
+  # because the general version in `Node` does not work for `block` nodes.
+  #
+  # @return [Boolean] whether the `block` literal is on a several lines
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#136
+  def multiline?; end
+
+  # The opening delimiter for this `block` literal.
+  #
+  # @return [String] the opening delimiter for the `block` literal
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#113
+  def opening_delimiter; end
+
+  # The `send` node associated with this block.
+  #
+  # @return [SendNode] the `send` node associated with the `block` node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#20
+  def send_node; end
+
+  # Checks whether this is a single line block. This is overridden here
+  # because the general version in `Node` does not work for `block` nodes.
+  #
+  # @return [Boolean] whether the `block` literal is on a single line
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#128
+  def single_line?; end
+
+  # Checks whether this node body is a void context.
+  #
+  # @return [Boolean] whether the `block` node body is a void context
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#150
+  def void_context?; end
+
+  private
+
+  # Numbered arguments of this `numblock`.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#157
+  def numbered_arguments; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node/block_node.rb#14
+RuboCop::AST::BlockNode::VOID_CONTEXT_METHODS = T.let(T.unsafe(nil), Array)
+
+# A node extension for `break` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `break` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/break_node.rb#8
+class RuboCop::AST::BreakNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::ParameterizedNode::WrappedArguments
+end
+
+# `RuboCop::AST::Builder` is an AST builder that is utilized to let `Parser`
+# generate ASTs with {RuboCop::AST::Node}.
+#
+# @example
+#   buffer = Parser::Source::Buffer.new('(string)')
+#   buffer.source = 'puts :foo'
+#
+#   builder = RuboCop::AST::Builder.new
+#   require 'parser/ruby25'
+#   parser = Parser::Ruby25.new(builder)
+#   root_node = parser.parse(buffer)
+#
+# source://rubocop-ast//lib/rubocop/ast/builder.rb#16
+class RuboCop::AST::Builder < ::Parser::Builders::Default
+  # Generates {Node} from the given information.
+  #
+  # @return [Node] the generated node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/builder.rb#105
+  def n(type, children, source_map); end
+
+  # TODO: Figure out what to do about literal encoding handling...
+  # More details here https://github.com/whitequark/parser/issues/283
+  #
+  # source://rubocop-ast//lib/rubocop/ast/builder.rb#111
+  def string_value(token); end
+
+  private
+
+  # source://rubocop-ast//lib/rubocop/ast/builder.rb#117
+  def node_klass(type); end
+end
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/builder.rb#21
+RuboCop::AST::Builder::NODE_MAP = T.let(T.unsafe(nil), Hash)
+
+# A node extension for `case_match` nodes. This will be used in place of
+# a plain node when the builder constructs the AST, making its methods
+# available to all `case_match` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/case_match_node.rb#8
+class RuboCop::AST::CaseMatchNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ConditionalNode
+
+  # Returns an array of all the when branches in the `case` statement.
+  #
+  # and the `else` (if any). Note that these bodies could be nil.
+  #
+  # @return [Array<Node, nil>] an array of the bodies of the `in` branches
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/case_match_node.rb#38
+  def branches; end
+
+  # @deprecated Use `in_pattern_branches.each`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/case_match_node.rb#19
+  def each_in_pattern(&block); end
+
+  # Checks whether this case statement has an `else` branch.
+  #
+  # @return [Boolean] whether the `case` statement has an `else` branch
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/case_match_node.rb#59
+  def else?; end
+
+  # Returns the else branch of the `case` statement, if any.
+  #
+  # @return [Node] the else branch node of the `case` statement
+  # @return [EmptyElse] the empty else branch node of the `case` statement
+  # @return [nil] if the case statement does not have an else branch.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/case_match_node.rb#52
+  def else_branch; end
+
+  # Returns an array of all the `in` pattern branches in the `case` statement.
+  #
+  # @return [Array<InPatternNode>] an array of `in_pattern` nodes
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/case_match_node.rb#30
+  def in_pattern_branches; end
+
+  # Returns the keyword of the `case` statement as a string.
+  #
+  # @return [String] the keyword of the `case` statement
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/case_match_node.rb#14
+  def keyword; end
+end
+
+# A node extension for `case` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `case` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/case_node.rb#8
+class RuboCop::AST::CaseNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ConditionalNode
+
+  # Returns an array of all the when branches in the `case` statement.
+  #
+  # and the else (if any). Note that these bodies could be nil.
+  #
+  # @return [Array<Node, nil>] an array of the bodies of the when branches
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/case_node.rb#38
+  def branches; end
+
+  # @deprecated Use `when_branches.each`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/case_node.rb#19
+  def each_when(&block); end
+
+  # Checks whether this case statement has an `else` branch.
+  #
+  # @return [Boolean] whether the `case` statement has an `else` branch
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/case_node.rb#55
+  def else?; end
+
+  # Returns the else branch of the `case` statement, if any.
+  #
+  # @return [Node] the else branch node of the `case` statement
+  # @return [nil] if the case statement does not have an else branch.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/case_node.rb#48
+  def else_branch; end
+
+  # Returns the keyword of the `case` statement as a string.
+  #
+  # @return [String] the keyword of the `case` statement
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/case_node.rb#14
+  def keyword; end
+
+  # Returns an array of all the when branches in the `case` statement.
+  #
+  # @return [Array<WhenNode>] an array of `when` nodes
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/case_node.rb#30
+  def when_branches; end
+end
+
+# A node extension for `casgn` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all assignment nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/casgn_node.rb#8
+class RuboCop::AST::CasgnNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ConstantNode
+
+  # The expression being assigned to the variable.
+  #
+  # @return [Node] the expression being assigned.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/casgn_node.rb#16
+  def expression; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/constant_node.rb#14
+  def name; end
+end
+
+# A node extension for `class` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `class` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/class_node.rb#8
+class RuboCop::AST::ClassNode < ::RuboCop::AST::Node
+  # The body of this `class` node.
+  #
+  # @return [Node, nil] the body of the class
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/class_node.rb#26
+  def body; end
+
+  # The identifier for this `class` node.
+  #
+  # @return [Node] the identifier of the class
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/class_node.rb#12
+  def identifier; end
+
+  # The parent class for this `class` node.
+  #
+  # @return [Node, nil] the parent class of the class
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/class_node.rb#19
+  def parent_class; end
+end
+
+# A mixin that helps give collection nodes array polymorphism.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/collection_node.rb#6
+module RuboCop::AST::CollectionNode
+  extend ::RuboCop::SimpleForwardable
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def &(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def *(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def +(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def -(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def <<(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def [](*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def []=(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def all?(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def any?(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def append(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def assoc(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def at(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def bsearch(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def bsearch_index(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def chain(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def chunk(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def chunk_while(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def clear(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def collect(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def collect!(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def collect_concat(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def combination(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def compact(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def compact!(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def concat(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def count(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def cycle(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def deconstruct(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def delete(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def delete_at(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def delete_if(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def detect(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def difference(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def dig(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def drop(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def drop_while(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def each(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def each_cons(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def each_entry(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def each_index(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def each_slice(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def each_with_index(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def each_with_object(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def empty?(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def entries(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def fetch(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def fill(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def filter(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def filter!(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def filter_map(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def find(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def find_all(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def find_index(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def first(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def flat_map(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def flatten(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def flatten!(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def grep(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def grep_v(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def group_by(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def include?(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def index(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def inject(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def insert(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def intersect?(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def intersection(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def join(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def keep_if(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def last(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def lazy(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def length(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def map(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def map!(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def max(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def max_by(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def member?(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def min(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def min_by(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def minmax(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def minmax_by(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def none?(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def one?(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def pack(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def partition(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def permutation(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def place(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def pop(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def prepend(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def product(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def push(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def rassoc(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def reduce(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def reject(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def reject!(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def repeated_combination(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def repeated_permutation(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def replace(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def reverse(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def reverse!(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def reverse_each(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def rindex(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def rotate(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def rotate!(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def sample(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def select(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def select!(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def shelljoin(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def shift(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def shuffle(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def shuffle!(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def size(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def slice(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def slice!(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def slice_after(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def slice_before(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def slice_when(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def sort(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def sort!(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def sort_by(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def sort_by!(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def sum(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def take(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def take_while(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def tally(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def to_ary(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def to_h(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def to_set(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def transpose(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def union(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def uniq(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def uniq!(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def unshift(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def values_at(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def zip(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def |(*_arg0, **_arg1, &_arg2); end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/collection_node.rb#9
+RuboCop::AST::CollectionNode::ARRAY_METHODS = T.let(T.unsafe(nil), Array)
+
+# Common functionality for nodes that have conditions:
+# `if`, `while`, `until`, `case`.
+# This currently doesn't include `when` nodes, because they have multiple
+# conditions, and need to be checked for that.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/conditional_node.rb#9
+module RuboCop::AST::ConditionalNode
+  # Returns the body associated with the condition. This works together with
+  # each node's custom destructuring method to select the correct part of
+  # the node.
+  #
+  # @note For `if` nodes, this is the truthy branch.
+  # @return [Node, nil] the body of the node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/conditional_node.rb#40
+  def body; end
+
+  # Returns the condition of the node. This works together with each node's
+  # custom destructuring method to select the correct part of the node.
+  #
+  # @return [Node, nil] the condition of the node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/conditional_node.rb#29
+  def condition; end
+
+  # Checks whether the condition of the node is written on more than
+  # one line.
+  #
+  # @return [Boolean] whether the condition is on more than one line
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/conditional_node.rb#21
+  def multiline_condition?; end
+
+  # Checks whether the condition of the node is written on a single line.
+  #
+  # @return [Boolean] whether the condition is on a single line
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/conditional_node.rb#13
+  def single_line_condition?; end
+end
+
+# A node extension for `const` nodes.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/const_node.rb#6
+class RuboCop::AST::ConstNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ConstantNode
+end
+
+# Common functionality for nodes that deal with constants:
+# `const`, `casgn`.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/constant_node.rb#7
+module RuboCop::AST::ConstantNode
+  # @return [Boolean] if the constant starts with `::` (aka s(:cbase))
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/constant_node.rb#27
+  def absolute?; end
+
+  # @return [Boolean] if the constant is a Module / Class, according to the standard convention.
+  #   Note: some classes might have uppercase in which case this method
+  #   returns false
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/constant_node.rb#21
+  def class_name?; end
+
+  # Yield nodes for the namespace
+  #
+  #   For `::Foo::Bar::BAZ` => yields:
+  #      s(:cbase), then
+  #      s(:const, :Foo), then
+  #      s(:const, s(:const, :Foo), :Bar)
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/constant_node.rb#44
+  def each_path(&block); end
+
+  # @return [Boolean] if the constant is a Module / Class, according to the standard convention.
+  #   Note: some classes might have uppercase in which case this method
+  #   returns false
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/constant_node.rb#21
+  def module_name?; end
+
+  # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...)
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/constant_node.rb#9
+  def namespace; end
+
+  # @return [Boolean] if the constant does not start with `::` (aka s(:cbase))
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/constant_node.rb#34
+  def relative?; end
+
+  # @return [Symbol] the demodulized name of the constant: "::Foo::Bar" => :Bar
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/constant_node.rb#14
+  def short_name; end
+end
+
+# A node extension for `csend` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `csend` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/csend_node.rb#8
+class RuboCop::AST::CsendNode < ::RuboCop::AST::SendNode
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/csend_node.rb#9
+  def send_type?; end
+end
+
+# A node extension for `def` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `def` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#8
+class RuboCop::AST::DefNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+
+  # Checks whether this method definition node forwards its arguments
+  # as per the feature added in Ruby 2.7.
+  #
+  # @note This is written in a way that may support lead arguments
+  #   which are rumored to be added in a later version of Ruby.
+  # @return [Boolean] whether the `def` node uses argument forwarding
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#26
+  def argument_forwarding?; end
+
+  # An array containing the arguments of the method definition.
+  #
+  # @return [Array<Node>] the arguments of the method definition
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#40
+  def arguments; end
+
+  # The body of the method definition.
+  #
+  # @note this can be either a `begin` node, if the method body contains
+  #   multiple expressions, or any other node, if it contains a single
+  #   expression.
+  # @return [Node] the body of the method definition
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#51
+  def body; end
+
+  # @return [Boolean] if the definition is without an `end` or not.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#63
+  def endless?; end
+
+  # The name of the defined method as a symbol.
+  #
+  # @return [Symbol] the name of the defined method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#33
+  def method_name; end
+
+  # The receiver of the method definition, if any.
+  #
+  # @return [Node, nil] the receiver of the method definition, or `nil`.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#58
+  def receiver; end
+
+  # Checks whether this node body is a void context.
+  #
+  # @return [Boolean] whether the `def` node body is a void context
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/def_node.rb#15
+  def void_context?; end
+end
+
+# A node extension for `defined?` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `send` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/defined_node.rb#8
+class RuboCop::AST::DefinedNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::MethodDispatchNode
+
+  # source://ast/2.4.2/lib/ast/node.rb#56
+  def arguments; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node/defined_node.rb#12
+  def node_parts; end
+end
+
+# Common functionality for primitive literal nodes: `sym`, `str`,
+# `int`, `float`, ...
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/descendence.rb#7
+module RuboCop::AST::Descendence
+  # Returns an array of child nodes.
+  # This is a shorthand for `node.each_child_node.to_a`.
+  #
+  # @return [Array<Node>] an array of child nodes
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/descendence.rb#38
+  def child_nodes; end
+
+  # Returns an array of descendant nodes.
+  # This is a shorthand for `node.each_descendant.to_a`.
+  #
+  # @return [Array<Node>] an array of descendant nodes
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/descendence.rb#72
+  def descendants; end
+
+  # Calls the given block for each child node.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # Note that this is different from `node.children.each { |child| ... }`
+  # which yields all children including non-node elements.
+  #
+  # @overload each_child_node
+  # @overload each_child_node
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  # @yieldparam node [Node] each child node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/descendence.rb#22
+  def each_child_node(*types); end
+
+  # Calls the given block for each descendant node with depth first order.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # @overload each_descendant
+  # @overload each_descendant
+  # @overload each_descendant
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  # @yieldparam node [Node] each descendant node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/descendence.rb#60
+  def each_descendant(*types, &block); end
+
+  # Calls the given block for the receiver and each descendant node in
+  # depth-first order.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # This method would be useful when you treat the receiver node as the root
+  # of a tree and want to iterate over all nodes in the tree.
+  #
+  # @overload each_node
+  # @overload each_node
+  # @overload each_node
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  # @yieldparam node [Node] each node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/descendence.rb#95
+  def each_node(*types, &block); end
+
+  protected
+
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/descendence.rb#107
+  def visit_descendants(types, &block); end
+end
+
+# A node extension for `dstr` nodes. This will be used
+# in place of a plain node when the builder constructs the AST, making
+# its methods available to all `dstr` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/dstr_node.rb#8
+class RuboCop::AST::DstrNode < ::RuboCop::AST::StrNode
+  # source://rubocop-ast//lib/rubocop/ast/node/dstr_node.rb#9
+  def value; end
+end
+
+# A node extension for `ensure` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `ensure` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/ensure_node.rb#8
+class RuboCop::AST::EnsureNode < ::RuboCop::AST::Node
+  # Returns the body of the `ensure` clause.
+  #
+  # @return [Node, nil] The body of the `ensure`.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/ensure_node.rb#12
+  def body; end
+
+  # Checks whether this node body is a void context.
+  # Always `true` for `ensure`.
+  #
+  # @return [true] whether the `ensure` node body is a void context
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/ensure_node.rb#20
+  def void_context?; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/ext/range.rb#5
+module RuboCop::AST::Ext; end
+
+# Extensions to Parser::AST::Range
+#
+# source://rubocop-ast//lib/rubocop/ast/ext/range.rb#7
+module RuboCop::AST::Ext::Range
+  # If `exclude_end` is `true`, then the range will be exclusive.
+  #
+  # Assume that `node` corresponds to the following array literal:
+  #
+  #   [
+  #     :foo,
+  #     :bar
+  #   ]
+  #
+  #   node.loc.begin.line_span                       # => 1..1
+  #   node.source_range.line_span(exclude_end: true) # => 1...4
+  #
+  # @return [Range] the range of line numbers for the node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/ext/range.rb#20
+  def line_span(exclude_end: T.unsafe(nil)); end
+end
+
+# A node extension for `float` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available to
+# all `float` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/float_node.rb#8
+class RuboCop::AST::FloatNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::BasicLiteralNode
+  include ::RuboCop::AST::NumericNode
+end
+
+# A node extension for `for` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `for` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#8
+class RuboCop::AST::ForNode < ::RuboCop::AST::Node
+  # Returns the body of the `for` loop.
+  #
+  # @return [Node, nil] The body of the `for` loop.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#48
+  def body; end
+
+  # Returns the collection the `for` loop is iterating over.
+  #
+  # @return [Node] The collection the `for` loop is iterating over
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#41
+  def collection; end
+
+  # Checks whether the `for` node has a `do` keyword.
+  #
+  # @return [Boolean] whether the `for` node has a `do` keyword
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#19
+  def do?; end
+
+  # Returns the keyword of the `for` statement as a string.
+  #
+  # @return [String] the keyword of the `until` statement
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#12
+  def keyword; end
+
+  # Returns the iteration variable of the `for` loop.
+  #
+  # @return [Node] The iteration variable of the `for` loop
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#34
+  def variable; end
+
+  # Checks whether this node body is a void context.
+  # Always `true` for `for`.
+  #
+  # @return [true] whether the `for` node body is a void context
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/for_node.rb#27
+  def void_context?; end
+end
+
+# A node extension for `forward-args` nodes. This will be used in place
+# of a plain node when the builder constructs the AST, making its methods
+# available to all `forward-args` nodes within RuboCop.
+#
+# Not used with modern emitters:
+#
+#   $ ruby-parse -e "def foo(...); end"
+#   (def :foo
+#     (args
+#       (forward-arg)) nil)
+#   $ ruby-parse --legacy -e "->(foo) { bar }"
+#   (def :foo
+#     (forward-args) nil)
+#
+# Note the extra 's' with legacy form.
+#
+# The main RuboCop runs in legacy mode; this node is only used
+# if user `AST::Builder.modernize` or `AST::Builder.emit_lambda=true`
+#
+# source://rubocop-ast//lib/rubocop/ast/node/forward_args_node.rb#23
+class RuboCop::AST::ForwardArgsNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::CollectionNode
+
+  # Node wraps itself in an array to be compatible with other
+  # enumerable argument types.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/forward_args_node.rb#28
+  def to_a; end
+end
+
+# Common functionality for nodes that can be used as hash elements:
+# `pair`, `kwsplat`
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#7
+module RuboCop::AST::HashElementNode
+  # Returns the delta between this element's delimiter and the argument's.
+  #
+  # @note Pairs with different delimiter styles return a delta of 0
+  # @return [Integer] the delta between the two delimiters
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#61
+  def delimiter_delta(other); end
+
+  # Returns the key of this `hash` element.
+  #
+  # @note For keyword splats, this returns the whole node
+  # @return [Node] the key of the hash element
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#13
+  def key; end
+
+  # Returns the delta between this pair's key and the argument pair's.
+  #
+  # @note Keys on the same line always return a delta of 0
+  # @note Keyword splats always return a delta of 0 for right alignment
+  # @param alignment [Symbol] whether to check the left or right side
+  # @return [Integer] the delta between the two keys
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#43
+  def key_delta(other, alignment = T.unsafe(nil)); end
+
+  # Checks whether this `hash` element is on the same line as `other`.
+  #
+  # @note A multiline element is considered to be on the same line if it
+  #   shares any of its lines with `other`
+  # @return [Boolean] whether this element is on the same line as `other`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#32
+  def same_line?(other); end
+
+  # Returns the value of this `hash` element.
+  #
+  # @note For keyword splats, this returns the whole node
+  # @return [Node] the value of the hash element
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#22
+  def value; end
+
+  # Returns the delta between this element's value and the argument's.
+  #
+  # @note Keyword splats always return a delta of 0
+  # @return [Integer] the delta between the two values
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#52
+  def value_delta(other); end
+end
+
+# A helper class for comparing the positions of different parts of a
+# `pair` node.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#67
+class RuboCop::AST::HashElementNode::HashElementDelta
+  # @raise [ArgumentError]
+  # @return [HashElementDelta] a new instance of HashElementDelta
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#68
+  def initialize(first, second); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#89
+  def delimiter_delta; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#75
+  def key_delta(alignment = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#82
+  def value_delta; end
+
+  private
+
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#106
+  def delta(first, second, alignment = T.unsafe(nil)); end
+
+  # Returns the value of attribute first.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#98
+  def first; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#117
+  def keyword_splat?; end
+
+  # Returns the value of attribute second.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#98
+  def second; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/hash_element_node.rb#100
+  def valid_argument_types?; end
+end
+
+# A node extension for `hash` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `hash` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#8
+class RuboCop::AST::HashNode < ::RuboCop::AST::Node
+  # Checks whether the `hash` literal is delimited by curly braces.
+  #
+  # @return [Boolean] whether the `hash` literal is enclosed in braces
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#117
+  def braces?; end
+
+  # Calls the given block for each `key` node in the `hash` literal.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # @note `kwsplat` nodes are ignored.
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#59
+  def each_key(&block); end
+
+  # Calls the given block for each `pair` node in the `hash` literal.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # @note `kwsplat` nodes are ignored.
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#33
+  def each_pair; end
+
+  # Calls the given block for each `value` node in the `hash` literal.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # @note `kwsplat` nodes are ignored.
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#83
+  def each_value(&block); end
+
+  # Checks whether the `hash` node contains any `pair`- or `kwsplat` nodes.
+  #
+  # @return[Boolean] whether the `hash` is empty
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#22
+  def empty?; end
+
+  # Returns an array of all the keys in the `hash` literal.
+  #
+  # @note `kwsplat` nodes are ignored.
+  # @return [Array<Node>] an array of keys in the `hash` literal
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#48
+  def keys; end
+
+  # Checks whether this `hash` uses a mix of hash rocket and colon
+  # delimiters for its pairs.
+  #
+  # @note `kwsplat` nodes are ignored.
+  # @return [Boolean] whether the `hash` uses mixed delimiters
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#110
+  def mixed_delimiters?; end
+
+  # Returns an array of all the key value pairs in the `hash` literal.
+  #
+  # ignored.
+  #
+  # @note this may be different from children as `kwsplat` nodes are
+  # @return [Array<PairNode>] an array of `pair` nodes
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#15
+  def pairs; end
+
+  # Checks whether any of the key value pairs in the `hash` literal are on
+  # the same line.
+  #
+  # @note A multiline `pair` is considered to be on the same line if it
+  #   shares any of its lines with another `pair`
+  # @note `kwsplat` nodes are ignored.
+  # @return [Boolean] whether any `pair` nodes are on the same line
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#100
+  def pairs_on_same_line?; end
+
+  # Returns an array of all the values in the `hash` literal.
+  #
+  # @note `kwsplat` nodes are ignored.
+  # @return [Array<Node>] an array of values in the `hash` literal
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/hash_node.rb#72
+  def values; end
+end
+
+# A node extension for `if` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `if` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#8
+class RuboCop::AST::IfNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ConditionalNode
+  include ::RuboCop::AST::ModifierNode
+
+  # Returns an array of all the branches in the conditional statement.
+  #
+  # @return [Array<Node>] an array of branch nodes
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#147
+  def branches; end
+
+  # @deprecated Use `branches.each`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#164
+  def each_branch(&block); end
+
+  # Checks whether the `if` node has an `else` clause.
+  #
+  # @note This returns `true` for nodes containing an `elsif` clause.
+  #   This is legacy behavior, and many cops rely on it.
+  # @return [Boolean] whether the node has an `else` clause
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#42
+  def else?; end
+
+  # Returns the branch of the `if` node that gets evaluated when its
+  # condition is falsey.
+  #
+  # @note This is normalized for `unless` nodes.
+  # @return [Node] the falsey branch node of the `if` node
+  # @return [nil] when there is no else branch
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#126
+  def else_branch; end
+
+  # Checks whether the `if` is an `elsif`. Parser handles these by nesting
+  # `if` nodes in the `else` branch.
+  #
+  # @return [Boolean] whether the node is an `elsif`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#32
+  def elsif?; end
+
+  # Checks whether the `if` node has at least one `elsif` branch. Returns
+  # true if this `if` node itself is an `elsif`.
+  #
+  # @return [Boolean] whether the `if` node has at least one `elsif` branch
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#104
+  def elsif_conditional?; end
+
+  # Checks whether this node is an `if` statement. (This is not true of
+  # ternary operators and `unless` statements.)
+  #
+  # @return [Boolean] whether the node is an `if` statement
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#16
+  def if?; end
+
+  # Returns the branch of the `if` node that gets evaluated when its
+  # condition is truthy.
+  #
+  # @note This is normalized for `unless` nodes.
+  # @return [Node] the truthy branch node of the `if` node
+  # @return [nil] if the truthy branch is empty
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#115
+  def if_branch; end
+
+  # Returns the inverse keyword of the `if` node as a string. Returns `if`
+  # for `unless` nodes and vice versa. Returns an empty string for ternary
+  # operators.
+  #
+  # @return [String] the inverse keyword of the `if` statement
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#66
+  def inverse_keyword; end
+
+  # Returns the keyword of the `if` statement as a string. Returns an empty
+  # string for ternary operators.
+  #
+  # @return [String] the keyword of the `if` statement
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#57
+  def keyword; end
+
+  # Checks whether the `if` node is in a modifier form, i.e. a condition
+  # trailing behind an expression. Only `if` and `unless` nodes without
+  # other branches can be modifiers.
+  #
+  # @return [Boolean] whether the `if` node is a modifier
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#80
+  def modifier_form?; end
+
+  # Checks whether the `if` node has nested `if` nodes in any of its
+  # branches.
+  #
+  # @note This performs a shallow search.
+  # @return [Boolean] whether the `if` node contains nested conditionals
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#90
+  def nested_conditional?; end
+
+  # Custom destructuring method. This is used to normalize the branches
+  # for `if` and `unless` nodes, to aid comparisons and conversions.
+  #
+  # @return [Array<Node>] the different parts of the `if` statement
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#134
+  def node_parts; end
+
+  # Checks whether the `if` node is a ternary operator.
+  #
+  # @return [Boolean] whether the `if` node is a ternary operator
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#49
+  def ternary?; end
+
+  # Checks whether this node is an `unless` statement. (This is not true
+  # of ternary operators and `if` statements.)
+  #
+  # @return [Boolean] whether the node is an `unless` statement
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/if_node.rb#24
+  def unless?; end
+end
+
+# A node extension for `in` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `in` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/in_pattern_node.rb#8
+class RuboCop::AST::InPatternNode < ::RuboCop::AST::Node
+  # Returns the body of the `in` node.
+  #
+  # @return [Node, nil] the body of the `in` node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/in_pattern_node.rb#33
+  def body; end
+
+  # Returns the index of the `in` branch within the `case` statement.
+  #
+  # @return [Integer] the index of the `in` branch
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/in_pattern_node.rb#19
+  def branch_index; end
+
+  # Returns a node of the pattern in the `in` branch.
+  #
+  # @return [Node] a pattern node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/in_pattern_node.rb#12
+  def pattern; end
+
+  # Checks whether the `in` node has a `then` keyword.
+  #
+  # @return [Boolean] whether the `in` node has a `then` keyword
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/in_pattern_node.rb#26
+  def then?; end
+end
+
+# Used for modern support only!
+# Not as thoroughly tested as legacy equivalent
+#
+#   $ ruby-parse -e "foo[:bar]"
+#   (index
+#     (send nil :foo)
+#     (sym :bar))
+#   $ ruby-parse --legacy -e "foo[:bar]"
+#   (send
+#     (send nil :foo) :[]
+#     (sym :bar))
+#
+# The main RuboCop runs in legacy mode; this node is only used
+# if user `AST::Builder.modernize` or `AST::Builder.emit_index=true`
+#
+# source://rubocop-ast//lib/rubocop/ast/node/index_node.rb#19
+class RuboCop::AST::IndexNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::ParameterizedNode::RestArguments
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::MethodDispatchNode
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/index_node.rb#29
+  def assignment_method?; end
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/index_node.rb#24
+  def attribute_accessor?; end
+
+  # For similarity with legacy mode
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/index_node.rb#34
+  def method_name; end
+
+  private
+
+  # An array containing the arguments of the dispatched method.
+  #
+  # @return [Array<Node>] the arguments of the dispatched method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/index_node.rb#43
+  def first_argument_index; end
+end
+
+# Used for modern support only!
+# Not as thoroughly tested as legacy equivalent
+#
+#   $ ruby-parse -e "foo[:bar] = :baz"
+#   (indexasgn
+#     (send nil :foo)
+#     (sym :bar)
+#     (sym :baz))
+#   $ ruby-parse --legacy -e "foo[:bar] = :baz"
+#   (send
+#     (send nil :foo) :[]=
+#     (sym :bar)
+#     (sym :baz))
+#
+# The main RuboCop runs in legacy mode; this node is only used
+# if user `AST::Builder.modernize` or `AST::Builder.emit_index=true`
+#
+# source://rubocop-ast//lib/rubocop/ast/node/indexasgn_node.rb#21
+class RuboCop::AST::IndexasgnNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::ParameterizedNode::RestArguments
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::MethodDispatchNode
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/indexasgn_node.rb#31
+  def assignment_method?; end
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/indexasgn_node.rb#26
+  def attribute_accessor?; end
+
+  # For similarity with legacy mode
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/indexasgn_node.rb#36
+  def method_name; end
+
+  private
+
+  # An array containing the arguments of the dispatched method.
+  #
+  # @return [Array<Node>] the arguments of the dispatched method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/indexasgn_node.rb#45
+  def first_argument_index; end
+end
+
+# A node extension for `int` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available to
+# all `int` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/int_node.rb#8
+class RuboCop::AST::IntNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::BasicLiteralNode
+  include ::RuboCop::AST::NumericNode
+end
+
+# A node extension for `kwsplat` and `forwarded_kwrestarg` nodes. This will be used in
+# place of a plain node when the builder constructs the AST, making its methods available to
+# all `kwsplat` and `forwarded_kwrestarg` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#8
+class RuboCop::AST::KeywordSplatNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::HashElementNode
+
+  # This is used for duck typing with `pair` nodes which also appear as
+  # `hash` elements.
+  #
+  # @return [false]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#26
+  def colon?; end
+
+  # This is used for duck typing with `pair` nodes which also appear as
+  # `hash` elements.
+  #
+  # @return [false]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#18
+  def hash_rocket?; end
+
+  # This provides `forwarded_kwrestarg` node to return true to be compatible with `kwsplat` node.
+  #
+  # @return [true]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#48
+  def kwsplat_type?; end
+
+  # Custom destructuring method. This is used to normalize the branches
+  # for `pair` and `kwsplat` nodes, to add duck typing to `hash` elements.
+  #
+  # @return [Array<KeywordSplatNode>] the different parts of the `kwsplat`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#41
+  def node_parts; end
+
+  # Returns the operator for the `kwsplat` as a string.
+  #
+  # @return [String] the double splat operator
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#33
+  def operator; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node/keyword_splat_node.rb#11
+RuboCop::AST::KeywordSplatNode::DOUBLE_SPLAT = T.let(T.unsafe(nil), String)
+
+# Used for modern support only:
+# Not as thoroughly tested as legacy equivalent
+#
+#   $ ruby-parse -e "->(foo) { bar }"
+#   (block
+#     (lambda)
+#     (args
+#       (arg :foo))
+#     (send nil :bar))
+#   $ ruby-parse --legacy -e "->(foo) { bar }"
+#   (block
+#     (send nil :lambda)
+#     (args
+#       (arg :foo))
+#     (send nil :bar))
+#
+# The main RuboCop runs in legacy mode; this node is only used
+# if user `AST::Builder.modernize` or `AST::Builder.emit_lambda=true`
+#
+# source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#23
+class RuboCop::AST::LambdaNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::ParameterizedNode::RestArguments
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::MethodDispatchNode
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#43
+  def assignment_method?; end
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#38
+  def attribute_accessor?; end
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#28
+  def lambda?; end
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#33
+  def lambda_literal?; end
+
+  # For similarity with legacy mode
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#53
+  def method_name; end
+
+  # For similarity with legacy mode
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#48
+  def receiver; end
+
+  private
+
+  # For similarity with legacy mode
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/lambda_node.rb#60
+  def first_argument_index; end
+end
+
+# A node extension for `masgn` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all assignment nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/masgn_node.rb#8
+class RuboCop::AST::MasgnNode < ::RuboCop::AST::Node
+  # @return [Array<Node>] the assignment nodes of the multiple assignment
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/masgn_node.rb#16
+  def assignments; end
+
+  # The RHS (right hand side) of the multiple assignment. This returns
+  # the nodes as parsed: either a single node if the RHS has a single value,
+  # or an `array` node containing multiple nodes.
+  #
+  # NOTE: Due to how parsing works, `expression` will return the same for
+  # `a, b = x, y` and `a, b = [x, y]`.
+  #
+  # @return [Node] the right hand side of a multiple assignment.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/masgn_node.rb#39
+  def expression; end
+
+  # @return [MlhsNode] the `mlhs` node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/masgn_node.rb#10
+  def lhs; end
+
+  # @return [Array<Symbol>] names of all the variables being assigned
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/masgn_node.rb#21
+  def names; end
+
+  # The RHS (right hand side) of the multiple assignment. This returns
+  # the nodes as parsed: either a single node if the RHS has a single value,
+  # or an `array` node containing multiple nodes.
+  #
+  # NOTE: Due to how parsing works, `expression` will return the same for
+  # `a, b = x, y` and `a, b = [x, y]`.
+  #
+  # @return [Node] the right hand side of a multiple assignment.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/masgn_node.rb#39
+  def rhs; end
+
+  # In contrast to `expression`, `values` always returns a Ruby array
+  # containing all the nodes being assigned on the RHS.
+  #
+  # Literal arrays are considered a singular value; but unlike `expression`,
+  # implied `array` nodes from assigning multiple values on the RHS are treated
+  # as separate.
+  #
+  # @return [Array<Node>] individual values being assigned on the RHS of the multiple assignment
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/masgn_node.rb#52
+  def values; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/masgn_node.rb#58
+  def multiple_rhs?; end
+end
+
+# Common functionality for nodes that are a kind of method dispatch:
+# `send`, `csend`, `super`, `zsuper`, `yield`, `defined?`,
+# and (modern only): `index`, `indexasgn`, `lambda`
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#8
+module RuboCop::AST::MethodDispatchNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # Checks whether the dispatched method is an access modifier.
+  #
+  # @return [Boolean] whether the dispatched method is an access modifier
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#64
+  def access_modifier?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#273
+  def adjacent_def_modifier?(param0 = T.unsafe(nil)); end
+
+  # Checks whether this node is an arithmetic operation
+  #
+  # @return [Boolean] whether the dispatched method is an arithmetic
+  #   operation
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#175
+  def arithmetic_operation?; end
+
+  # Checks whether the dispatched method is a setter method.
+  #
+  # @return [Boolean] whether the dispatched method is a setter
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#107
+  def assignment?; end
+
+  # Checks whether the dispatched method is a bare access modifier that
+  # affects all methods defined after the macro.
+  #
+  # @return [Boolean] whether the dispatched method is a bare
+  #   access modifier
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#73
+  def bare_access_modifier?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#278
+  def bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end
+
+  # Checks whether this is a binary operation.
+  #
+  # @example
+  #
+  #   foo + bar
+  # @return [Boolean] whether this method is a binary operation
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#248
+  def binary_operation?; end
+
+  # Whether this method dispatch has an explicit block.
+  #
+  # @return [Boolean] whether the dispatched method has a block
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#167
+  def block_literal?; end
+
+  # The `block` or `numblock` node associated with this method dispatch, if any.
+  #
+  # @return [BlockNode, nil] the `block` or `numblock` node associated with this method
+  #   call or `nil`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#46
+  def block_node; end
+
+  # Checks whether the name of the dispatched method matches the argument
+  # and has an implicit receiver.
+  #
+  # @param name [Symbol, String] the method name to check for
+  # @return [Boolean] whether the method name matches the argument
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#100
+  def command?(name); end
+
+  # Checks whether the *explicit* receiver of this method dispatch is a
+  # `const` node.
+  #
+  # @return [Boolean] whether the receiver of this method dispatch
+  #   is a `const` node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#152
+  def const_receiver?; end
+
+  # Checks if this node is part of a chain of `def` or `defs` modifiers.
+  #
+  # or `nil` if it isn't a def modifier
+  #
+  # @example
+  #
+  #   private def foo; end
+  # @return [Node | nil] returns the `def|defs` node this is a modifier for,
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#199
+  def def_modifier(node = T.unsafe(nil)); end
+
+  # Checks if this node is part of a chain of `def` or `defs` modifiers.
+  #
+  # See also `def_modifier` that returns the node or `nil`
+  #
+  # @example
+  #
+  #   private def foo; end
+  # @return [Boolean] whether the `def|defs` node is a modifier or not.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#187
+  def def_modifier?(node = T.unsafe(nil)); end
+
+  # Checks whether the dispatched method uses a dot to connect the
+  # receiver and the method name.
+  #
+  # This is useful for comparison operators, which can be called either
+  # with or without a dot, i.e. `foo == bar` or `foo.== bar`.
+  #
+  # @return [Boolean] whether the method was called with a connecting dot
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#119
+  def dot?; end
+
+  # Checks whether the dispatched method uses a double colon to connect the
+  # receiver and the method name.
+  #
+  # @return [Boolean] whether the method was called with a connecting dot
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#127
+  def double_colon?; end
+
+  # Checks whether the method dispatch is the implicit form of `#call`,
+  # e.g. `foo.(bar)`.
+  #
+  # @return [Boolean] whether the method is the implicit form of `#call`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#160
+  def implicit_call?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#257
+  def in_macro_scope?(param0 = T.unsafe(nil)); end
+
+  # Checks whether this is a lambda. Some versions of parser parses
+  # non-literal lambdas as a method send.
+  #
+  # @return [Boolean] whether this method is a lambda
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#213
+  def lambda?; end
+
+  # Checks whether this is a lambda literal (stabby lambda.)
+  #
+  # @example
+  #
+  #   -> (foo) { bar }
+  # @return [Boolean] whether this method is a lambda literal
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#224
+  def lambda_literal?; end
+
+  # Checks whether the dispatched method is a macro method. A macro method
+  # is defined as a method that sits in a class, module, or block body and
+  # has an implicit receiver.
+  #
+  # @note This does not include DSLs that use nested blocks, like RSpec
+  # @return [Boolean] whether the dispatched method is a macro method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#57
+  def macro?; end
+
+  # The name of the dispatched method as a symbol.
+  #
+  # @return [Symbol] the name of the dispatched method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#27
+  def method_name; end
+
+  # Checks whether the dispatched method is a non-bare access modifier that
+  # affects only the method it receives.
+  #
+  # @return [Boolean] whether the dispatched method is a non-bare
+  #   access modifier
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#82
+  def non_bare_access_modifier?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#283
+  def non_bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end
+
+  # The receiving node of the method dispatch.
+  #
+  # @return [Node, nil] the receiver of the dispatched method or `nil`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#20
+  def receiver; end
+
+  # Checks whether the dispatched method uses a safe navigation operator to
+  # connect the receiver and the method name.
+  #
+  # @return [Boolean] whether the method was called with a connecting dot
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#135
+  def safe_navigation?; end
+
+  # The source range for the method name or keyword that dispatches this call.
+  #
+  # @return [Parser::Source::Range] the source range for the method name or keyword
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#34
+  def selector; end
+
+  # Checks whether the *explicit* receiver of this method dispatch is
+  # `self`.
+  #
+  # @return [Boolean] whether the receiver of this method dispatch is `self`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#143
+  def self_receiver?; end
+
+  # Checks whether the dispatched method is a setter method.
+  #
+  # @return [Boolean] whether the dispatched method is a setter
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#107
+  def setter_method?; end
+
+  # Checks whether the dispatched method is a bare `private` or `protected`
+  # access modifier that affects all methods defined after the macro.
+  #
+  # @return [Boolean] whether the dispatched method is a bare
+  #   `private` or `protected` access modifier
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#91
+  def special_modifier?; end
+
+  # Checks whether this is a unary operation.
+  #
+  # @example
+  #
+  #   -foo
+  # @return [Boolean] whether this method is a unary operation
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#235
+  def unary_operation?; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#12
+RuboCop::AST::MethodDispatchNode::ARITHMETIC_OPERATORS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_dispatch_node.rb#14
+RuboCop::AST::MethodDispatchNode::SPECIAL_MODIFIERS = T.let(T.unsafe(nil), Array)
+
+# Common predicates for nodes that reference method identifiers:
+# `send`, `csend`, `def`, `defs`, `super`, `zsuper`
+#
+# @note this mixin expects `#method_name` and `#receiver` to be implemented
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#9
+module RuboCop::AST::MethodIdentifierPredicates
+  # Checks whether the method is an assignment method.
+  #
+  # @return [Boolean] whether the method is an assignment
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#142
+  def assignment_method?; end
+
+  # Checks whether the method is a bang method.
+  #
+  # @return [Boolean] whether the method is a bang method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#171
+  def bang_method?; end
+
+  # Checks whether the method is a camel case method,
+  # e.g. `Integer()`.
+  #
+  # @return [Boolean] whether the method is a camel case method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#179
+  def camel_case_method?; end
+
+  # Checks whether the method is a comparison method.
+  #
+  # @return [Boolean] whether the method is a comparison
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#135
+  def comparison_method?; end
+
+  # Checks whether the *explicit* receiver of node is a `const` node.
+  #
+  # @return [Boolean] whether the receiver of this node is a `const` node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#193
+  def const_receiver?; end
+
+  # Checks whether the method is an Enumerable method.
+  #
+  # @return [Boolean] whether the method is an Enumerable method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#157
+  def enumerable_method?; end
+
+  # Checks whether the method is an enumerator method.
+  #
+  # @return [Boolean] whether the method is an enumerator
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#149
+  def enumerator_method?; end
+
+  # Checks whether the method name matches the argument.
+  #
+  # @param name [Symbol, String] the method name to check for
+  # @return [Boolean] whether the method name matches the argument
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#79
+  def method?(name); end
+
+  # Checks whether this is a negation method, i.e. `!` or keyword `not`.
+  #
+  # @return [Boolean] whether this method is a negation method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#200
+  def negation_method?; end
+
+  # Checks whether the method is a nonmutating Array method.
+  #
+  # @return [Boolean] whether the method is a nonmutating Array method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#114
+  def nonmutating_array_method?; end
+
+  # Checks whether the method is a nonmutating binary operator method.
+  #
+  # @return [Boolean] whether the method is a nonmutating binary operator method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#93
+  def nonmutating_binary_operator_method?; end
+
+  # Checks whether the method is a nonmutating Hash method.
+  #
+  # @return [Boolean] whether the method is a nonmutating Hash method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#121
+  def nonmutating_hash_method?; end
+
+  # Checks whether the method is a nonmutating operator method.
+  #
+  # @return [Boolean] whether the method is a nonmutating operator method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#107
+  def nonmutating_operator_method?; end
+
+  # Checks whether the method is a nonmutating String method.
+  #
+  # @return [Boolean] whether the method is a nonmutating String method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#128
+  def nonmutating_string_method?; end
+
+  # Checks whether the method is a nonmutating unary operator method.
+  #
+  # @return [Boolean] whether the method is a nonmutating unary operator method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#100
+  def nonmutating_unary_operator_method?; end
+
+  # Checks whether the method is an operator method.
+  #
+  # @return [Boolean] whether the method is an operator
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#86
+  def operator_method?; end
+
+  # Checks whether the method is a predicate method.
+  #
+  # @return [Boolean] whether the method is a predicate method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#164
+  def predicate_method?; end
+
+  # Checks whether this is a prefix bang method, e.g. `!foo`.
+  #
+  # @return [Boolean] whether this method is a prefix bang
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#214
+  def prefix_bang?; end
+
+  # Checks whether this is a prefix not method, e.g. `not foo`.
+  #
+  # @return [Boolean] whether this method is a prefix not
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#207
+  def prefix_not?; end
+
+  # Checks whether the *explicit* receiver of this node is `self`.
+  #
+  # @return [Boolean] whether the receiver of this node is `self`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#186
+  def self_receiver?; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#16
+RuboCop::AST::MethodIdentifierPredicates::ENUMERABLE_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#10
+RuboCop::AST::MethodIdentifierPredicates::ENUMERATOR_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#32
+RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_ARRAY_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#24
+RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_BINARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#48
+RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_HASH_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#28
+RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#59
+RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_STRING_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#26
+RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_UNARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
+
+# http://phrogz.net/programmingruby/language.html#table_18.4
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/method_identifier_predicates.rb#20
+RuboCop::AST::MethodIdentifierPredicates::OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
+
+# A node extension for `mlhs` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all assignment nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mlhs_node.rb#8
+class RuboCop::AST::MlhsNode < ::RuboCop::AST::Node
+  # Returns all the assignment nodes on the left hand side (LHS) of a multiple assignment.
+  # These are generally assignment nodes (`lvasgn`, `ivasgn`, `cvasgn`, `gvasgn`, `casgn`)
+  # but can also be `send` nodes in case of `foo.bar, ... =` or `foo[:bar], ... =`.
+  #
+  # @return [Array<Node>] the assignment nodes of the multiple assignment LHS
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mlhs_node.rb#14
+  def assignments; end
+end
+
+# Common functionality for nodes that can be used as modifiers:
+# `if`, `while`, `until`
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/modifier_node.rb#7
+module RuboCop::AST::ModifierNode
+  # Checks whether the node is in a modifier form, i.e. a condition
+  # trailing behind an expression.
+  #
+  # @return [Boolean] whether the node is a modifier
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/modifier_node.rb#12
+  def modifier_form?; end
+end
+
+# A node extension for `module` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `module` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/module_node.rb#8
+class RuboCop::AST::ModuleNode < ::RuboCop::AST::Node
+  # The body of this `module` node.
+  #
+  # @return [Node, nil] the body of the module
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/module_node.rb#19
+  def body; end
+
+  # The identifier for this `module` node.
+  #
+  # @return [Node] the identifier of the module
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/module_node.rb#12
+  def identifier; end
+end
+
+# A node extension for `next` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `next` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/next_node.rb#8
+class RuboCop::AST::NextNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::ParameterizedNode::WrappedArguments
+end
+
+# `RuboCop::AST::Node` is a subclass of `Parser::AST::Node`. It provides
+# access to parent nodes and an object-oriented way to traverse an AST with
+# the power of `Enumerable`.
+#
+# It has predicate methods for every node type, like this:
+#
+# @example
+#   node.send_type?    # Equivalent to: `node.type == :send`
+#   node.op_asgn_type? # Equivalent to: `node.type == :op_asgn`
+#
+#   # Non-word characters (other than a-zA-Z0-9_) in type names are omitted.
+#   node.defined_type? # Equivalent to: `node.type == :defined?`
+#
+#   # Find the first lvar node under the receiver node.
+#   lvar_node = node.each_descendant.find(&:lvar_type?)
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#21
+class RuboCop::AST::Node < ::Parser::AST::Node
+  include ::RuboCop::AST::Sexp
+  include ::RuboCop::AST::Descendence
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # @return [Node] a new instance of Node
+  # @see https://www.rubydoc.info/gems/ast/AST/Node:initialize
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#113
+  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def __ENCODING___type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def __FILE___type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def __LINE___type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def alias_type?; end
+
+  # Returns an array of ancestor nodes.
+  # This is a shorthand for `node.each_ancestor.to_a`.
+  #
+  # @return [Array<Node>] an array of ancestor nodes
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#268
+  def ancestors; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def and_asgn_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def and_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def arg_expr_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def arg_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def args_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#474
+  def argument?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#478
+  def argument_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def array_pattern_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def array_pattern_with_tail_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def array_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#426
+  def assignment?; end
+
+  # Some cops treat the shovel operator as a kind of assignment.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#376
+  def assignment_or_similar?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def back_ref_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#430
+  def basic_conditional?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#384
+  def basic_literal?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def begin_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def block_pass_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def block_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def blockarg_expr_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def blockarg_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#482
+  def boolean_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def break_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#466
+  def call_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def case_match_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def case_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def casgn_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def cbase_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#470
+  def chained?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#522
+  def class_constructor?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#540
+  def class_definition?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def class_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#165
+  def complete!; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#170
+  def complete?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def complex_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#434
+  def conditional?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#314
+  def const_name; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def const_pattern_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def const_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def csend_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def cvar_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def cvasgn_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def def_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#335
+  def defined_module; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#340
+  def defined_module_name; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def defined_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def defs_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def dstr_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def dsym_type?; end
+
+  # Calls the given block for each ancestor node from parent to root.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # @overload each_ancestor
+  # @overload each_ancestor
+  # @overload each_ancestor
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  # @yieldparam node [Node] each ancestor node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#256
+  def each_ancestor(*types, &block); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def eflipflop_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def empty_else_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#370
+  def empty_source?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def ensure_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#418
+  def equals_asgn?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def erange_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def false_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#392
+  def falsey_literal?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def find_pattern_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#282
+  def first_line; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def float_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def for_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def forward_arg_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def forward_args_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def forwarded_args_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def forwarded_kwrestarg_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def forwarded_restarg_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#519
+  def global_const?(param0 = T.unsafe(nil), param1); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#494
+  def guard_clause?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def gvar_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def gvasgn_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def hash_pattern_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def hash_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def ident_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def if_guard_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def if_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def iflipflop_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#400
+  def immutable_literal?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def in_match_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def in_pattern_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def index_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def indexasgn_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def int_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def irange_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def ivar_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def ivasgn_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#447
+  def keyword?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def kwarg_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def kwargs_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def kwbegin_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def kwnilarg_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def kwoptarg_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def kwrestarg_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def kwsplat_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#513
+  def lambda?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#516
+  def lambda_or_proc?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def lambda_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#286
+  def last_line; end
+
+  # Use is discouraged, this is a potentially slow method and can lead
+  # to even slower algorithms
+  #
+  # @return [Node, nil] the left (aka previous) sibling
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#208
+  def left_sibling; end
+
+  # Use is discouraged, this is a potentially slow method and can lead
+  # to even slower algorithms
+  #
+  # @return [Array<Node>] the left (aka previous) siblings
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#218
+  def left_siblings; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#290
+  def line_count; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#380
+  def literal?; end
+
+  # NOTE: `loop { }` is a normal method call and thus not a loop keyword.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#443
+  def loop_keyword?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def lvar_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def lvasgn_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def masgn_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def match_alt_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def match_as_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def match_current_line_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#501
+  def match_guard_clause?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def match_nil_pattern_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def match_pattern_p_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def match_pattern_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def match_rest_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def match_var_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def match_with_lvasgn_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def match_with_trailing_comma_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def mlhs_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#547
+  def module_definition?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def module_type?; end
+
+  # Predicates
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#362
+  def multiline?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#396
+  def mutable_literal?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#679
+  def new_class_or_module_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def next_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def nil_type?; end
+
+  # Common destructuring method. This can be used to normalize
+  # destructuring for different variations of the node.
+  # Some node types override this with their own custom
+  # destructuring method.
+  #
+  # @return [Array<Node>] the different parts of the ndde
+  #
+  # source://ast/2.4.2/lib/ast/node.rb#56
+  def node_parts; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#296
+  def nonempty_line_count; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def not_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def nth_ref_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def numargs_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def numblock_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#486
+  def numeric_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def objc_kwarg_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def objc_restarg_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def objc_varargs_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def op_asgn_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#458
+  def operator_keyword?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def optarg_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def or_asgn_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def or_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def pair_type?; end
+
+  # Returns the parent node, or `nil` if the receiver is a root node.
+  #
+  # @return [Node, nil] the parent node or `nil`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#147
+  def parent; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#156
+  def parent?; end
+
+  # Searching the AST
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#346
+  def parent_module_name; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#462
+  def parenthesized_call?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def pin_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#438
+  def post_condition_loop?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def postexe_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def preexe_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#506
+  def proc?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def procarg0_type?; end
+
+  # Some expressions are evaluated for their value, some for their side
+  # effects, and some for both.
+  # If we know that expressions are useful only for their return values,
+  # and have no side effects, that means we can reorder them, change the
+  # number of times they are evaluated, or replace them with other
+  # expressions which are equivalent in value.
+  # So, is evaluation of this node free of side effects?
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#590
+  def pure?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#490
+  def range_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def rational_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#307
+  def receiver(param0 = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#97
+  def recursive_basic_literal?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#97
+  def recursive_literal?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def redo_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#414
+  def reference?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def regexp_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def regopt_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def resbody_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def rescue_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def restarg_expr_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def restarg_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def retry_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def return_type?; end
+
+  # Use is discouraged, this is a potentially slow method and can lead
+  # to even slower algorithms
+  #
+  # @return [Node, nil] the right (aka next) sibling
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#199
+  def right_sibling; end
+
+  # Use is discouraged, this is a potentially slow method and can lead
+  # to even slower algorithms
+  #
+  # @return [Array<Node>] the right (aka next) siblings
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#227
+  def right_siblings; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#161
+  def root?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def sclass_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def self_type?; end
+
+  # Most nodes are of 'send' type, so this method is defined
+  # separately to make this check as fast as possible.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#140
+  def send_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def shadowarg_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#422
+  def shorthand_asgn?; end
+
+  # Returns the index of the receiver node in its siblings. (Sibling index
+  # uses zero based numbering.)
+  # Use is discouraged, this is a potentially slow method.
+  #
+  # @return [Integer, nil] the index of the receiver node in its siblings
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#192
+  def sibling_index; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#366
+  def single_line?; end
+
+  # NOTE: Some rare nodes may have no source, like `s(:args)` in `foo {}`
+  #
+  # @return [String, nil]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#274
+  def source; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#300
+  def source_length; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#278
+  def source_range; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#454
+  def special_keyword?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def splat_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#312
+  def str_content(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def str_type?; end
+
+  # @deprecated Use `:class_constructor?`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#535
+  def struct_constructor?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def super_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def sym_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def true_type?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#388
+  def truthy_literal?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def undef_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def unless_guard_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def until_post_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def until_type?; end
+
+  # Override `AST::Node#updated` so that `AST::Processor` does not try to
+  # mutate our ASTs. Since we keep references from children to parents and
+  # not just the other way around, we cannot update an AST and share
+  # identical subtrees. Rather, the entire AST must be copied any time any
+  # part of it is changed.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#181
+  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
+
+  # Some expressions are evaluated for their value, some for their side
+  # effects, and some for both
+  # If we know that an expression is useful only for its side effects, that
+  # means we can transform it in ways which preserve the side effects, but
+  # change the return value
+  # So, does the return value of this node matter? If we changed it to
+  # `(...; nil)`, might that affect anything?
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#560
+  def value_used?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#410
+  def variable?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def when_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def while_post_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def while_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def xstr_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def yield_type?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#132
+  def zsuper_type?; end
+
+  protected
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#151
+  def parent=(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#618
+  def begin_value_used?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#629
+  def case_if_value_used?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#326
+  def defined_module0(param0 = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#623
+  def for_value_used?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#665
+  def parent_module_name_for_block(ancestor); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#653
+  def parent_module_name_for_sclass(sclass_node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#640
+  def parent_module_name_part(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#608
+  def visit_ancestors(types); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node.rb#635
+  def while_until_value_used?; end
+
+  class << self
+    private
+
+    # source://rubocop-ast//lib/rubocop/ast/node.rb#92
+    def def_recursive_literal_predicate(kind); end
+  end
+end
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#80
+RuboCop::AST::Node::ARGUMENT_TYPES = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#55
+RuboCop::AST::Node::ASSIGNMENTS = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#58
+RuboCop::AST::Node::BASIC_CONDITIONALS = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#42
+RuboCop::AST::Node::BASIC_LITERALS = T.let(T.unsafe(nil), Set)
+
+# <=> isn't included here, because it doesn't return a boolean.
+#
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#28
+RuboCop::AST::Node::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#39
+RuboCop::AST::Node::COMPOSITE_LITERALS = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#60
+RuboCop::AST::Node::CONDITIONALS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node.rb#87
+RuboCop::AST::Node::EMPTY_CHILDREN = T.let(T.unsafe(nil), Array)
+
+# source://rubocop-ast//lib/rubocop/ast/node.rb#88
+RuboCop::AST::Node::EMPTY_PROPERTIES = T.let(T.unsafe(nil), Hash)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#50
+RuboCop::AST::Node::EQUALS_ASSIGNMENTS = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#35
+RuboCop::AST::Node::FALSEY_LITERALS = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#47
+RuboCop::AST::Node::IMMUTABLE_LITERALS = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#70
+RuboCop::AST::Node::KEYWORDS = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#37
+RuboCop::AST::Node::LITERALS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node.rb#83
+RuboCop::AST::Node::LITERAL_RECURSIVE_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node.rb#84
+RuboCop::AST::Node::LITERAL_RECURSIVE_TYPES = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#64
+RuboCop::AST::Node::LOOP_TYPES = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#44
+RuboCop::AST::Node::MUTABLE_LITERALS = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#76
+RuboCop::AST::Node::OPERATOR_KEYWORDS = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#62
+RuboCop::AST::Node::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#68
+RuboCop::AST::Node::REFERENCES = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#53
+RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#78
+RuboCop::AST::Node::SPECIAL_KEYWORDS = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#31
+RuboCop::AST::Node::TRUTHY_LITERALS = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node.rb#66
+RuboCop::AST::Node::VARIABLES = T.let(T.unsafe(nil), Set)
+
+# This class performs a pattern-matching operation on an AST node.
+#
+# Detailed syntax: /docs/modules/ROOT/pages/node_pattern.adoc
+#
+# Initialize a new `NodePattern` with `NodePattern.new(pattern_string)`, then
+# pass an AST node to `NodePattern#match`. Alternatively, use one of the class
+# macros in `NodePattern::Macros` to define your own pattern-matching method.
+#
+# If the match fails, `nil` will be returned. If the match succeeds, the
+# return value depends on whether a block was provided to `#match`, and
+# whether the pattern contained any "captures" (values which are extracted
+# from a matching AST.)
+#
+# - With block: #match yields the captures (if any) and passes the return
+#               value of the block through.
+# - With no block, but one capture: the capture is returned.
+# - With no block, but multiple captures: captures are returned as an array.
+# - With no block and no captures: #match returns `true`.
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#5
+class RuboCop::AST::NodePattern
+  include ::RuboCop::AST::NodePattern::MethodDefiner
+  extend ::RuboCop::SimpleForwardable
+
+  # @return [NodePattern] a new instance of NodePattern
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#77
+  def initialize(str, compiler: T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#90
+  def ==(other); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#107
+  def as_json(_options = T.unsafe(nil)); end
+
+  # Returns the value of attribute ast.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#73
+  def ast; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def captures(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#111
+  def encode_with(coder); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#90
+  def eql?(other); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#119
+  def freeze; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#115
+  def init_with(coder); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#103
+  def marshal_dump; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#99
+  def marshal_load(pattern); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#85
+  def match(*args, **rest, &block); end
+
+  # Returns the value of attribute match_code.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#73
+  def match_code; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def named_parameters(*_arg0, **_arg1, &_arg2); end
+
+  # Returns the value of attribute pattern.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#73
+  def pattern; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def positional_parameters(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#95
+  def to_s; end
+
+  class << self
+    # Yields its argument and any descendants, depth-first.
+    #
+    # @yield [element]
+    #
+    # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#59
+    def descend(element, &block); end
+  end
+end
+
+# Responsible to build the AST nodes for `NodePattern`
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#10
+class RuboCop::AST::NodePattern::Builder
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#17
+  def emit_atom(type, value); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#29
+  def emit_call(type, selector, args = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#11
+  def emit_capture(capture_token, node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#25
+  def emit_list(type, _begin, children, _end); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#41
+  def emit_subsequence(node_list); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#21
+  def emit_unary_op(type, _operator = T.unsafe(nil), *children); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#34
+  def emit_union(begin_t, pattern_lists, end_t); end
+
+  private
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#53
+  def n(type, *args); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#49
+  def optimizable_as_set?(children); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/builder.rb#57
+  def union_children(pattern_lists); end
+end
+
+# A NodePattern comment, simplified version of ::Parser::Source::Comment
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/comment.rb#7
+class RuboCop::AST::NodePattern::Comment
+  # @param range [Parser::Source::Range]
+  # @return [Comment] a new instance of Comment
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/comment.rb#14
+  def initialize(range); end
+
+  # Compares comments. Two comments are equal if they
+  # correspond to the same source range.
+  #
+  # @param other [Object]
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/comment.rb#31
+  def ==(other); end
+
+  # @return [String] a human-readable representation of this comment
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/comment.rb#39
+  def inspect; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/comment.rb#8
+  def loc; end
+
+  # Returns the value of attribute location.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/comment.rb#8
+  def location; end
+
+  # @return [String]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/comment.rb#20
+  def text; end
+end
+
+# The top-level compiler holding the global state
+# Defers work to its subcompilers
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#11
+class RuboCop::AST::NodePattern::Compiler
+  extend ::RuboCop::SimpleForwardable
+
+  # @return [Compiler] a new instance of Compiler
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#15
+  def initialize; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def bind(*_arg0, **_arg1, &_arg2); end
+
+  # Returns the value of attribute binding.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#13
+  def binding; end
+
+  # Returns the value of attribute captures.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#13
+  def captures; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#42
+  def compile_as_atom(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#46
+  def compile_as_node_pattern(node, **options); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#50
+  def compile_sequence(sequence, var:); end
+
+  # Enumerates `enum` while keeping track of state across
+  # union branches (captures and unification).
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#38
+  def each_union(enum, &block); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#74
+  def freeze; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#31
+  def named_parameter(name); end
+
+  # Returns the value of attribute named_parameters.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#13
+  def named_parameters; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#70
+  def next_capture; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#54
+  def parser; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#26
+  def positional_parameter(number); end
+
+  # Returns the value of attribute positional_parameters.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#13
+  def positional_parameters; end
+
+  # Utilities
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#60
+  def with_temp_variables(*names, &block); end
+
+  private
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#81
+  def enforce_same_captures(enum); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler.rb#96
+  def new_capture; end
+end
+
+# Generates code that evaluates to a value (Ruby object)
+# This value responds to `===`.
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#12
+class RuboCop::AST::NodePattern::Compiler::AtomSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
+  private
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#28
+  def visit_const; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#32
+  def visit_named_parameter; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#21
+  def visit_number; end
+
+  # Assumes other types are node patterns.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#46
+  def visit_other_type; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#36
+  def visit_positional_parameter; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#21
+  def visit_regexp; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#40
+  def visit_set; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#21
+  def visit_string; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#21
+  def visit_symbol; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb#15
+  def visit_unify; end
+end
+
+# Holds the list of bound variable names
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/binding.rb#8
+class RuboCop::AST::NodePattern::Compiler::Binding
+  # @return [Binding] a new instance of Binding
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/binding.rb#9
+  def initialize; end
+
+  # Yields the first time a given name is bound
+  #
+  # @return [String] bound variable name
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/binding.rb#16
+  def bind(name); end
+
+  # Yields for each branch of the given union, forbidding unification of
+  # bindings which only appear in a subset of the union.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/binding.rb#31
+  def union_bind(enum); end
+
+  private
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/binding.rb#69
+  def forbid(names); end
+end
+
+# Variant of the Compiler with tracing information for nodes
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#10
+class RuboCop::AST::NodePattern::Compiler::Debug < ::RuboCop::AST::NodePattern::Compiler
+  # @return [Debug] a new instance of Debug
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#123
+  def initialize; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def comments(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#128
+  def named_parameters; end
+
+  # Returns the value of attribute node_ids.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#33
+  def node_ids; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#132
+  def parser; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def tokens(*_arg0, **_arg1, &_arg2); end
+end
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#36
+class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer
+  # @api private
+  # @return [Colorizer] a new instance of Colorizer
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#96
+  def initialize(pattern, compiler: T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#94
+  def compiler; end
+
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#94
+  def node_pattern; end
+
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#94
+  def pattern; end
+
+  # @api private
+  # @return [Node] the Ruby AST
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#103
+  def test(ruby, trace: T.unsafe(nil)); end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#111
+  def ruby_ast(ruby); end
+
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#116
+  def ruby_parser; end
+end
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#37
+RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::COLOR_SCHEME = T.let(T.unsafe(nil), Hash)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#92
+RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Compiler = RuboCop::AST::NodePattern::Compiler::Debug
+
+# Result of a NodePattern run against a particular AST
+# Consider constructor is private
+#
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#46
+class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Result < ::Struct
+  # @api private
+  # @return [Hash] a map for {character_position => color}
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#56
+  def color_map(color_scheme = T.unsafe(nil)); end
+
+  # @api private
+  # @return [String] a Rainbow colorized version of ruby
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#48
+  def colorize(color_scheme = T.unsafe(nil)); end
+
+  # Returns the value of attribute colorizer
+  #
+  # @return [Object] the current value of colorizer
+  def colorizer; end
+
+  # Sets the attribute colorizer
+  #
+  # @param value [Object] the value to set the attribute colorizer to.
+  # @return [Object] the newly set value
+  def colorizer=(_); end
+
+  # @api private
+  # @return [Hash] a map for {node => matched?}, depth-first
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#66
+  def match_map; end
+
+  # @api private
+  # @return [Boolean] a value of `Trace#matched?` or `:not_visitable`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#74
+  def matched?(node); end
+
+  # Returns the value of attribute returned
+  #
+  # @return [Object] the current value of returned
+  def returned; end
+
+  # Sets the attribute returned
+  #
+  # @param value [Object] the value to set the attribute returned to.
+  # @return [Object] the newly set value
+  def returned=(_); end
+
+  # Returns the value of attribute ruby_ast
+  #
+  # @return [Object] the current value of ruby_ast
+  def ruby_ast; end
+
+  # Sets the attribute ruby_ast
+  #
+  # @param value [Object] the value to set the attribute ruby_ast to.
+  # @return [Object] the newly set value
+  def ruby_ast=(_); end
+
+  # Returns the value of attribute trace
+  #
+  # @return [Object] the current value of trace
+  def trace; end
+
+  # Sets the attribute trace
+  #
+  # @param value [Object] the value to set the attribute trace to.
+  # @return [Object] the newly set value
+  def trace=(_); end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#87
+  def ast; end
+
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#81
+  def color_map_for(node, color); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#139
+module RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#140
+  def do_compile; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#150
+  def node_id; end
+
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#146
+  def tracer(kind); end
+end
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#156
+class RuboCop::AST::NodePattern::Compiler::Debug::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler
+  include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
+end
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#161
+class RuboCop::AST::NodePattern::Compiler::Debug::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler
+  include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
+end
+
+# Compiled node pattern requires a named parameter `trace`,
+# which should be an instance of this class
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#13
+class RuboCop::AST::NodePattern::Compiler::Debug::Trace
+  # @return [Trace] a new instance of Trace
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#14
+  def initialize; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#18
+  def enter(node_id); end
+
+  # return nil (not visited), false (not matched) or true (matched)
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#28
+  def matched?(node_id); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/debug.rb#23
+  def success(node_id); end
+end
+
+# Compiles code that evalues to true or false
+# for a given value `var` (typically a RuboCop::AST::Node)
+# or it's `node.type` if `seq_head` is true
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#13
+class RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
+  # @return [NodePatternSubcompiler] a new instance of NodePatternSubcompiler
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#16
+  def initialize(compiler, var: T.unsafe(nil), access: T.unsafe(nil), seq_head: T.unsafe(nil)); end
+
+  # Returns the value of attribute access.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#14
+  def access; end
+
+  # Returns the value of attribute seq_head.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#14
+  def seq_head; end
+
+  private
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#119
+  def access_element; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#123
+  def access_node; end
+
+  # @param [Array<Node>, nil]
+  # @return [String, nil]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#113
+  def compile_args(arg_list, first: T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#129
+  def compile_guard_clause; end
+
+  # Compiling helpers
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#107
+  def compile_value_match(value); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#133
+  def multiple_access(kind); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#30
+  def visit_ascend; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#58
+  def visit_capture; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#37
+  def visit_descend; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#84
+  def visit_function_call; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#73
+  def visit_intersection; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#25
+  def visit_negation; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#88
+  def visit_node_type; end
+
+  # Assumes other types are atoms.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#100
+  def visit_other_type; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#80
+  def visit_predicate; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#92
+  def visit_sequence; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#49
+  def visit_unify; end
+
+  # Lists
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#64
+  def visit_union; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb#45
+  def visit_wildcard; end
+end
+
+# Compiles terms within a sequence to code that evalues to true or false.
+# Compilation of the nodes that can match only a single term is deferred to
+# `NodePatternSubcompiler`; only nodes that can match multiple terms are
+# compiled here.
+# Assumes the given `var` is a `::RuboCop::AST::Node`
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#17
+class RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
+  # Calls `compile_sequence`; the actual `compile` method
+  # will be used for the different terms of the sequence.
+  # The only case of re-entrant call to `compile` is `visit_capture`
+  #
+  # @return [SequenceSubcompiler] a new instance of SequenceSubcompiler
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#25
+  def initialize(compiler, sequence:, var:); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#31
+  def compile_sequence; end
+
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#251
+  def in_sync; end
+
+  protected
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#226
+  def compile_terms(children = T.unsafe(nil), last_arity = T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#251
+  def cur_index; end
+
+  # yield `sync_code` iff not already in sync
+  #
+  # @yield [code]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#242
+  def sync; end
+
+  private
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#20
+  def compile(node); end
+
+  # Compilation helpers
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#165
+  def compile_and_advance(term); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#128
+  def compile_any_order_branches(matched_var); end
+
+  # @return [Array<String>] Else code, and init code (if any)
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#137
+  def compile_any_order_else; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#180
+  def compile_captured_repetition(child_code, child_captures); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#119
+  def compile_case(when_branches, else_code); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#361
+  def compile_child_nb_guard(arity_range); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#319
+  def compile_cur_index; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#325
+  def compile_index(cur = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#353
+  def compile_loop(term); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#347
+  def compile_loop_advance(to = T.unsafe(nil)); end
+
+  # Assumes `@cur_index` is already updated
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#198
+  def compile_matched(kind); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#304
+  def compile_max_matched; end
+
+  # @return [String] code that evaluates to `false` if the matched arity is too small
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#270
+  def compile_min_check; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#285
+  def compile_remaining; end
+
+  # @return [Hash] of {subcompiler => code}
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#373
+  def compile_union_forks; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#313
+  def empty_loop; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#214
+  def handle_prev; end
+
+  # Modifies in place `forks`
+  # Syncs our state
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#400
+  def merge_forks!(forks); end
+
+  # Modifies in place `forks` to insure that `cur_{child|index}_var` are ok
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#384
+  def preserve_union_start(forks); end
+
+  # E.g. For sequence `(_  _? <_ _>)`, arities are: 1, 0..1, 2
+  # and remaining arities are: 3..4, 2..3, 2..2, 0..0
+  #
+  # @return [Array<Range>] total arities (as Ranges) of remaining children nodes
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#259
+  def remaining_arities(children, last_arity); end
+
+  # returns truthy iff `@cur_index` switched to relative from end mode (i.e. < 0)
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#341
+  def use_index_from_end; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#88
+  def visit_any_order; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#150
+  def visit_capture; end
+
+  # Single node patterns are all handled here
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#62
+  def visit_other_type; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#78
+  def visit_repetition; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#159
+  def visit_rest; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#104
+  def visit_union; end
+
+  # NOTE: assumes `@cur_index != :seq_head`. Node types using `within_loop` must
+  # have `def in_sequence_head; :raise; end`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#333
+  def within_loop; end
+end
+
+# Shift of 1 from standard Ruby indices
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#18
+RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::DELTA = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb#19
+RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::POSITIVE = T.let(T.unsafe(nil), Proc)
+
+# Base class for subcompilers
+# Implements visitor pattern
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#12
+class RuboCop::AST::NodePattern::Compiler::Subcompiler
+  # @return [Subcompiler] a new instance of Subcompiler
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#15
+  def initialize(compiler); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#20
+  def compile(node); end
+
+  # Returns the value of attribute compiler.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#13
+  def compiler; end
+
+  private
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#34
+  def do_compile; end
+
+  # Returns the value of attribute node.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#32
+  def node; end
+
+  class << self
+    # @private
+    #
+    # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#47
+    def inherited(base); end
+
+    # @private
+    #
+    # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#42
+    def method_added(method); end
+
+    # Returns the value of attribute registry.
+    #
+    # source://rubocop-ast//lib/rubocop/ast/node_pattern/compiler/subcompiler.rb#40
+    def registry; end
+  end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#53
+class RuboCop::AST::NodePattern::Invalid < ::StandardError; end
+
+# Lexer class for `NodePattern`
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#18
+class RuboCop::AST::NodePattern::Lexer < ::RuboCop::AST::NodePattern::LexerRex
+  # @return [Lexer] a new instance of Lexer
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#31
+  def initialize(source); end
+
+  # Returns the value of attribute comments.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#29
+  def comments; end
+
+  # Returns the value of attribute source_buffer.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#29
+  def source_buffer; end
+
+  # Returns the value of attribute tokens.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#29
+  def tokens; end
+
+  private
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#60
+  def do_parse; end
+
+  # @return [token]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#40
+  def emit(type); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#48
+  def emit_comment; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#52
+  def emit_regexp; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#64
+  def token(type, value); end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#19
+RuboCop::AST::NodePattern::Lexer::Error = RuboCop::AST::NodePattern::LexerRex::ScanError
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rb#21
+RuboCop::AST::NodePattern::Lexer::REGEXP_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+# The generated lexer RuboCop::AST::NodePattern::LexerRex
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#23
+class RuboCop::AST::NodePattern::LexerRex
+  # Yields on the current action.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#69
+  def action; end
+
+  # The file name / path
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#43
+  def filename; end
+
+  # The file name / path
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#43
+  def filename=(_arg0); end
+
+  # The current location in the parse.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#103
+  def location; end
+
+  # The StringScanner for this lexer.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#48
+  def match; end
+
+  # The match groups for the current scan.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#60
+  def matches; end
+
+  # Lex the next token.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#112
+  def next_token; end
+
+  # Parse the given string.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#83
+  def parse(str); end
+
+  # Read in and parse the file at +path+.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#93
+  def parse_file(path); end
+
+  # The current scanner class. Must be overridden in subclasses.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#76
+  def scanner_class; end
+
+  # The StringScanner for this lexer.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#48
+  def ss; end
+
+  # The StringScanner for this lexer.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#48
+  def ss=(_arg0); end
+
+  # The current lexical state.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#53
+  def state; end
+
+  # The current lexical state.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#53
+  def state=(_arg0); end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#31
+RuboCop::AST::NodePattern::LexerRex::CALL = T.let(T.unsafe(nil), Regexp)
+
+# :stopdoc:
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#27
+RuboCop::AST::NodePattern::LexerRex::CONST_NAME = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#29
+RuboCop::AST::NodePattern::LexerRex::IDENTIFIER = T.let(T.unsafe(nil), Regexp)
+
+# :startdoc:
+# :stopdoc:
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#36
+class RuboCop::AST::NodePattern::LexerRex::LexerError < ::StandardError; end
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#30
+RuboCop::AST::NodePattern::LexerRex::NODE_TYPE = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#33
+RuboCop::AST::NodePattern::LexerRex::REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#32
+RuboCop::AST::NodePattern::LexerRex::REGEXP_BODY = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#28
+RuboCop::AST::NodePattern::LexerRex::SYMBOL_NAME = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/lexer.rex.rb#37
+class RuboCop::AST::NodePattern::LexerRex::ScanError < ::RuboCop::AST::NodePattern::LexerRex::LexerError; end
+
+# Helpers for defining methods based on a pattern string
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#28
+module RuboCop::AST::NodePattern::Macros
+  # Define a method which applies a pattern to an AST node
+  #
+  # The new method will return nil if the node does not match.
+  # If the node matches, and a block is provided, the new method will
+  # yield to the block (passing any captures as block arguments).
+  # If the node matches, and no block is provided, the new method will
+  # return the captures, or `true` if there were none.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#36
+  def def_node_matcher(method_name, pattern_str, **keyword_defaults); end
+
+  # Define a method which recurses over the descendants of an AST node,
+  # checking whether any of them match the provided pattern
+  #
+  # If the method name ends with '?', the new method will return `true`
+  # as soon as it finds a descendant which matches. Otherwise, it will
+  # yield all descendants which match.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#46
+  def def_node_search(method_name, pattern_str, **keyword_defaults); end
+end
+
+# Functionality to turn `match_code` into methods/lambda
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#7
+module RuboCop::AST::NodePattern::MethodDefiner
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#37
+  def as_lambda; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#27
+  def compile_as_lambda; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#8
+  def def_node_matcher(base, method_name, **defaults); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#21
+  def def_node_search(base, method_name, **defaults); end
+
+  private
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#139
+  def compile_init; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#50
+  def def_helper(base, method_name, **defaults); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#114
+  def emit_keyword_list(forwarding: T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#132
+  def emit_lambda_code; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#125
+  def emit_method_code; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#63
+  def emit_node_search(method_name); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#74
+  def emit_node_search_body(method_name, prelude:, on_match:); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#110
+  def emit_param_list; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#119
+  def emit_params(*first, forwarding: T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#100
+  def emit_retval; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#89
+  def emit_yield_capture(when_no_capture = T.unsafe(nil), yield_with: T.unsafe(nil)); end
+
+  # This method minimizes the closure for our method
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/method_definer.rb#44
+  def wrapping_block(method_name, **defaults); end
+end
+
+# Base class for AST Nodes of a `NodePattern`
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#7
+class RuboCop::AST::NodePattern::Node < ::Parser::AST::Node
+  include ::RuboCop::AST::Descendence
+  extend ::RuboCop::SimpleForwardable
+
+  # Note: `arity.end` may be `Float::INFINITY`
+  #
+  # @return [Integer, Range] An Integer for fixed length terms, otherwise a Range.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#28
+  def arity; end
+
+  # @return [Range] arity as a Range
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#68
+  def arity_range; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#22
+  def capture?; end
+
+  # @return [Node] most nodes have only one child
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#47
+  def child; end
+
+  # @return [Array<Node>]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#42
+  def children_nodes; end
+
+  # @return [Array<Node>, nil] replace node with result, or `nil` if no change requested.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#33
+  def in_sequence_head; end
+
+  # that matches within a Set (e.g. `42`, `:sym` but not `/regexp/`)
+  #
+  # @return [Boolean] returns true for nodes having a Ruby literal equivalent
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#63
+  def matches_within_set?; end
+
+  # @return [Integer] nb of captures of that node and its descendants
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#52
+  def nb_captures; end
+
+  # To be overridden by subclasses
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#18
+  def rest?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#77
+  def source_range; end
+
+  # @return [Boolean] returns whether it matches a variable number of elements
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#57
+  def variadic?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#73
+  def with(type: T.unsafe(nil), children: T.unsafe(nil), location: T.unsafe(nil)); end
+end
+
+# Node class for `<int str ...>`
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#179
+class RuboCop::AST::NodePattern::Node::AnyOrder < ::RuboCop::AST::NodePattern::Node
+  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#197
+  def arity; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#189
+  def ends_with_rest?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#193
+  def rest_node; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#185
+  def term_nodes; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#182
+RuboCop::AST::NodePattern::Node::AnyOrder::ARITIES = T.let(T.unsafe(nil), Hash)
+
+# Node class for `$something`
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#96
+class RuboCop::AST::NodePattern::Node::Capture < ::RuboCop::AST::NodePattern::Node
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def arity(*_arg0, **_arg1, &_arg2); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#100
+  def capture?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#108
+  def in_sequence_head; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#104
+  def nb_captures; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def rest?(*_arg0, **_arg1, &_arg2); end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#85
+module RuboCop::AST::NodePattern::Node::ForbidInSeqHead
+  # @raise [NodePattern::Invalid]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#86
+  def in_sequence_head; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#139
+RuboCop::AST::NodePattern::Node::FunctionCall = RuboCop::AST::NodePattern::Node::Predicate
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#81
+RuboCop::AST::NodePattern::Node::INT_TO_RANGE = T.let(T.unsafe(nil), Hash)
+
+# Registry
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#249
+RuboCop::AST::NodePattern::Node::MAP = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#11
+RuboCop::AST::NodePattern::Node::MATCHES_WITHIN_SET = T.let(T.unsafe(nil), Set)
+
+# Node class for `predicate?(:arg, :list)`
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#130
+class RuboCop::AST::NodePattern::Node::Predicate < ::RuboCop::AST::NodePattern::Node
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#135
+  def arg_list; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#131
+  def method_name; end
+end
+
+# Node class for `int+`
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#142
+class RuboCop::AST::NodePattern::Node::Repetition < ::RuboCop::AST::NodePattern::Node
+  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#155
+  def arity; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#145
+  def operator; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#149
+RuboCop::AST::NodePattern::Node::Repetition::ARITIES = T.let(T.unsafe(nil), Hash)
+
+# Node class for `...`
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#161
+class RuboCop::AST::NodePattern::Node::Rest < ::RuboCop::AST::NodePattern::Node
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#169
+  def arity; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#173
+  def in_sequence_head; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#165
+  def rest?; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#162
+RuboCop::AST::NodePattern::Node::Rest::ARITY = T.let(T.unsafe(nil), Range)
+
+# Node class for `(type first second ...)`
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#117
+class RuboCop::AST::NodePattern::Node::Sequence < ::RuboCop::AST::NodePattern::Node
+  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
+
+  # @return [Sequence] a new instance of Sequence
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#120
+  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
+end
+
+# A list (potentially empty) of nodes; part of a Union
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#205
+class RuboCop::AST::NodePattern::Node::Subsequence < ::RuboCop::AST::NodePattern::Node
+  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#208
+  def arity; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#213
+  def in_sequence_head; end
+end
+
+# Node class for `{ ... }`
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#223
+class RuboCop::AST::NodePattern::Node::Union < ::RuboCop::AST::NodePattern::Node
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#224
+  def arity; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/node.rb#231
+  def in_sequence_head; end
+end
+
+# Parser for NodePattern
+# Note: class reopened in `parser.racc`
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#12
+class RuboCop::AST::NodePattern::Parser < ::Racc::Parser
+  extend ::RuboCop::SimpleForwardable
+
+  # @return [Parser] a new instance of Parser
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#19
+  def initialize(builder = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#335
+  def _reduce_10(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#339
+  def _reduce_11(val, _values); end
+
+  # reduce 12 omitted
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#345
+  def _reduce_13(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#349
+  def _reduce_14(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#353
+  def _reduce_15(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#357
+  def _reduce_16(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#361
+  def _reduce_17(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#365
+  def _reduce_18(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#369
+  def _reduce_19(val, _values); end
+
+  # reduce 1 omitted
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#303
+  def _reduce_2(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#373
+  def _reduce_20(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#377
+  def _reduce_21(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#381
+  def _reduce_22(val, _values); end
+
+  # reduce 24 omitted
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#389
+  def _reduce_25(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#395
+  def _reduce_26(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#307
+  def _reduce_3(val, _values); end
+
+  # reduce 32 omitted
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#415
+  def _reduce_33(val, _values); end
+
+  # reduce 36 omitted
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#425
+  def _reduce_37(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#429
+  def _reduce_38(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#433
+  def _reduce_39(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#311
+  def _reduce_4(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#437
+  def _reduce_40(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#441
+  def _reduce_41(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#445
+  def _reduce_42(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#449
+  def _reduce_43(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#453
+  def _reduce_44(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#457
+  def _reduce_45(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#461
+  def _reduce_46(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#315
+  def _reduce_5(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#319
+  def _reduce_6(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#323
+  def _reduce_7(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#327
+  def _reduce_8(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#331
+  def _reduce_9(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#465
+  def _reduce_none(val, _values); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def emit_atom(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def emit_call(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def emit_capture(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def emit_list(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def emit_unary_op(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def emit_union(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#40
+  def inspect; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def next_token(*_arg0, **_arg1, &_arg2); end
+
+  # (Similar API to `parser` gem)
+  # Parses a source and returns the AST.
+  #
+  # @param source_buffer [Parser::Source::Buffer, String] The source buffer to parse.
+  # @return [NodePattern::Node]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#31
+  def parse(source); end
+
+  private
+
+  # @raise [NodePattern::Invalid]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#50
+  def enforce_unary(node); end
+
+  # Overrides Racc::Parser's method:
+  #
+  # @raise [NodePattern::Invalid]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#59
+  def on_error(token, val, _vstack); end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#16
+RuboCop::AST::NodePattern::Parser::Builder = RuboCop::AST::NodePattern::Builder
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.rb#17
+RuboCop::AST::NodePattern::Parser::Lexer = RuboCop::AST::NodePattern::Lexer
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#227
+RuboCop::AST::NodePattern::Parser::Racc_arg = T.let(T.unsafe(nil), Array)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#295
+RuboCop::AST::NodePattern::Parser::Racc_debug_parser = T.let(T.unsafe(nil), FalseClass)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/parser.racc.rb#244
+RuboCop::AST::NodePattern::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
+
+# Overrides Parser to use `WithMeta` variants and provide additional methods
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#8
+class RuboCop::AST::NodePattern::Parser::WithMeta < ::RuboCop::AST::NodePattern::Parser
+  # Returns the value of attribute comments.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#98
+  def comments; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#100
+  def do_parse; end
+
+  # Returns the value of attribute tokens.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#98
+  def tokens; end
+end
+
+# Overrides Builder to emit nodes with locations
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#39
+class RuboCop::AST::NodePattern::Parser::WithMeta::Builder < ::RuboCop::AST::NodePattern::Builder
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#40
+  def emit_atom(type, token); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#61
+  def emit_call(type, selector_t, args = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#55
+  def emit_list(type, begin_t, children, end_t); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#49
+  def emit_unary_op(type, operator_t = T.unsafe(nil), *children); end
+
+  private
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#81
+  def join_exprs(left_expr, right_expr); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#75
+  def loc(token_or_range); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#71
+  def n(type, children, source_map); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#85
+  def source_map(token_or_range, begin_t: T.unsafe(nil), end_t: T.unsafe(nil), operator_t: T.unsafe(nil), selector_t: T.unsafe(nil)); end
+end
+
+# Overrides Lexer to token locations and comments
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#10
+class RuboCop::AST::NodePattern::Parser::WithMeta::Lexer < ::RuboCop::AST::NodePattern::Lexer
+  # @return [Lexer] a new instance of Lexer
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#13
+  def initialize(str_or_buffer); end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#27
+  def emit_comment; end
+
+  # @return [::Parser::Source::Range] last match's position
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#33
+  def pos; end
+
+  # Returns the value of attribute source_buffer.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#11
+  def source_buffer; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node_pattern/with_meta.rb#23
+  def token(type, value); end
+end
+
+# Utility to assign a set of values to a constant
+#
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#7
+module RuboCop::AST::NodePattern::Sets
+  class << self
+    # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#31
+    def [](set); end
+
+    # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#15
+    def name(set); end
+
+    # source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#22
+    def uniq(name); end
+  end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#14
+RuboCop::AST::NodePattern::Sets::MAX = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#8
+RuboCop::AST::NodePattern::Sets::REGISTRY = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_0_1 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_0_1_2 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_10_10 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_1_1 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_1_2 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_ADD_DEPENDENCY_ADD_RUNTIME_DEPENDENCY_ADD_DEVELOPMENT_DEPENDENCY = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_ALL_ANY_CLASS_OF_ETC = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_ALL_CONTEXT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_AND_RETURN_AND_RAISE_AND_THROW_ETC = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_ANY_EMPTY = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_ANY_EMPTY_NONE_ETC = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR_ATTR = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_BE_EQ_EQL_EQUAL = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_BE_TRUTHY_BE_FALSEY_BE_FALSY_ETC = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_BRANCH_REF_TAG = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_CALLER_CALLER_LOCATIONS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_CALL_RUN = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_CAPTURE2_CAPTURE2E_CAPTURE3_ETC = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_CIPHER_DIGEST = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_INSTANCE_EVAL = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE_STRUCT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_CLONE_DUP_FREEZE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_CONTEXT_SHARED_CONTEXT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_COUNT_LENGTH_SIZE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD_DEFINE_SINGLETON_METHOD = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_DOUBLE_SPY = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_DOWNCASE_UPCASE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_EACH_EXAMPLE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_INDEX_WITH_INDEX = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_OBJECT_WITH_OBJECT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_EQL_EQ_BE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_ESCAPE_ENCODE_UNESCAPE_DECODE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_EXACTLY_AT_LEAST_AT_MOST = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_EXIST_EXISTS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_EXPECT_ALLOW = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_FILETEST_FILE_DIR_SHELL = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_FILE_DIR = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_FILE_FILETEST = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_FILE_TEMPFILE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_FILE_TEMPFILE_STRINGIO = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_FIRST_LAST__ETC = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_FIXNUM_BIGNUM = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_FLATTEN_FLATTEN = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_FORMAT_SPRINTF_PRINTF = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_GETHOSTBYADDR_GETHOSTBYNAME = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_GSUB_GSUB = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_GSUB_GSUB_SUB_SUB = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_IF_UNLESS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_INCLUDE_EXTEND_PREPEND = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_INCLUDE_MEMBER = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_INCLUDE_PREPEND = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EVAL_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EXEC_CLASS_EXEC_MODULE_EXEC = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_IO_FILE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_IS_EXPECTED_SHOULD_SHOULD_NOT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_KEYS_VALUES = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_KEY_HAS_KEY_FETCH_ETC = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_LAST_FIRST = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_LENGTH_SIZE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_LOAD_RESTORE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_MAP_COLLECT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_MAP_FILTER_MAP = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_MATCH_MATCH = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_MATCH_MATCH_ = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_MATCH__MATCH = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_MATCH___MATCH = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_MODULE_FUNCTION_RUBY2_KEYWORDS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_NEW_ = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_NEW_COMPILE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_NEW_OPEN = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_NIL_ = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_PIPELINE_PIPELINE_R_PIPELINE_RW_ETC = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_PRESENT_ANY_BLANK_EMPTY = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED_PRIVATE_CLASS_METHOD = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED_PUBLIC = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_PROC_LAMBDA = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_PROP_CONST = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_PUBLIC_CONSTANT_PRIVATE_CONSTANT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_PUBLIC_PROTECTED_PRIVATE_MODULE_FUNCTION = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL_THROW_ETC = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_READ_BINREAD = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_RECEIVE_HAVE_RECEIVED = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_RECEIVE_MESSAGE_CHAIN_STUB_CHAIN = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_RECEIVE_RECEIVE_MESSAGES_RECEIVE_MESSAGE_CHAIN_HAVE_RECEIVED = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_RECEIVE_RECEIVE_MESSAGE_CHAIN = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_REDUCE_INJECT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_REJECT_REJECT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_REQUIRE_REQUIRE_RELATIVE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_SELECT_FILTER_FIND_ALL = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_SELECT_FILTER_FIND_ALL_REJECT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_SELECT_SELECT_FILTER_FILTER = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_SEND_PUBLIC_SEND___SEND__ = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_SEND___SEND__ = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_SHOULD_SHOULD_NOT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_SIG_HELPERS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_SKIP_PENDING = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_SORT_BY_SORT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_SORT_SORT_MIN_ETC = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_SPAWN_SYSTEM = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_SPRINTF_FORMAT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_START_WITH_END_WITH = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_START_WITH_STARTS_WITH_END_WITH_ENDS_WITH = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_STRUCT_CLASS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_STRUCT_IMMUTABLESTRUCT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_STRUCT_IMMUTABLESTRUCT_INEXACTSTRUCT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_SUCC_PRED_NEXT = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_TO_ENUM_ENUM_FOR = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_TO_H_TO_HASH = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_TO_I_TO_F_TO_C_TO_R = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_TRUE_FALSE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_ZERO_POSITIVE_NEGATIVE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET__ = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET__AT_SLICE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET__EQL_ = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET__EQUAL_EQL = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET__FETCH = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET__GLOB = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET__PUSH_APPEND = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET___ = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET___2 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET___3 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET___4 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET___5 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET___6 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET___7 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET___8 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET___9 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET___EQL_ETC = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET___EQL_INCLUDE = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET___METHOD_____CALLEE__ = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET____ = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET____2 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET____ETC = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET____ETC_2 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET____ETC_3 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET____ETC_4 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern/sets.rb#10
+RuboCop::AST::NodePattern::Sets::SET_____2 = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/node_pattern.rb#55
+RuboCop::AST::NodePattern::VAR = T.let(T.unsafe(nil), String)
+
+# Common functionality for primitive numeric nodes: `int`, `float`, `rational`...
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/numeric_node.rb#6
+module RuboCop::AST::NumericNode
+  # Checks whether this is literal has a sign.
+  #
+  # @example
+  #
+  #   +42
+  # @return [Boolean] whether this literal has a sign.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/numeric_node.rb#17
+  def sign?; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/numeric_node.rb#7
+RuboCop::AST::NumericNode::SIGN_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# A node extension for `op_asgn` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all assignment nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/op_asgn_node.rb#8
+class RuboCop::AST::OpAsgnNode < ::RuboCop::AST::Node
+  # @return [AsgnNode] the assignment node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/op_asgn_node.rb#10
+  def assignment_node; end
+
+  # The expression being assigned to the variable.
+  #
+  # @return [Node] the expression being assigned.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/op_asgn_node.rb#31
+  def expression; end
+
+  # The name of the variable being assigned as a symbol.
+  #
+  # @return [Symbol] the name of the variable being assigned
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/op_asgn_node.rb#17
+  def name; end
+
+  # The operator being used for assignment as a symbol.
+  #
+  # @return [Symbol] the assignment operator
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/op_asgn_node.rb#24
+  def operator; end
+end
+
+# A node extension for `op_asgn` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all assignment nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/or_asgn_node.rb#8
+class RuboCop::AST::OrAsgnNode < ::RuboCop::AST::OpAsgnNode
+  # The operator being used for assignment as a symbol.
+  #
+  # @return [Symbol] the assignment operator
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/or_asgn_node.rb#12
+  def operator; end
+end
+
+# A node extension for `or` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `or` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/or_node.rb#8
+class RuboCop::AST::OrNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::BinaryOperatorNode
+  include ::RuboCop::AST::PredicateOperatorNode
+
+  # Returns the alternate operator of the `or` as a string.
+  # Returns `or` for `||` and vice versa.
+  #
+  # @return [String] the alternate of the `or` operator
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/or_node.rb#16
+  def alternate_operator; end
+
+  # Returns the inverse keyword of the `or` node as a string.
+  # Returns `and` for `or` and `&&` for `||`.
+  #
+  # @return [String] the inverse of the `or` operator
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/or_node.rb#24
+  def inverse_operator; end
+end
+
+# A node extension for `pair` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `pair` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#8
+class RuboCop::AST::PairNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::HashElementNode
+
+  # Checks whether the `pair` uses a colon delimiter.
+  #
+  # @return [Boolean] whether this `pair` uses a colon delimiter
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#30
+  def colon?; end
+
+  # Returns the delimiter of the `pair` as a string. Returns `=>` for a
+  # colon delimited `pair` and `:` for a hash rocket delimited `pair`.
+  #
+  # @param with_spacing [Boolean] whether to include spacing
+  # @return [String] the delimiter of the `pair`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#39
+  def delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
+
+  # Checks whether the `pair` uses a hash rocket delimiter.
+  #
+  # @return [Boolean] whether this `pair` uses a hash rocket delimiter
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#23
+  def hash_rocket?; end
+
+  # Returns the inverse delimiter of the `pair` as a string.
+  #
+  # @param with_spacing [Boolean] whether to include spacing
+  # @return [String] the inverse delimiter of the `pair`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#51
+  def inverse_delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
+
+  # Checks whether the `pair` uses hash value omission.
+  #
+  # @return [Boolean] whether this `pair` uses hash value omission
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#69
+  def value_omission?; end
+
+  # Checks whether the value starts on its own line.
+  #
+  # @return [Boolean] whether the value in the `pair` starts its own line
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#62
+  def value_on_new_line?; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#15
+RuboCop::AST::PairNode::COLON = T.let(T.unsafe(nil), String)
+
+# source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#11
+RuboCop::AST::PairNode::HASH_ROCKET = T.let(T.unsafe(nil), String)
+
+# source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#17
+RuboCop::AST::PairNode::SPACED_COLON = T.let(T.unsafe(nil), String)
+
+# source://rubocop-ast//lib/rubocop/ast/node/pair_node.rb#13
+RuboCop::AST::PairNode::SPACED_HASH_ROCKET = T.let(T.unsafe(nil), String)
+
+# Requires implementing `arguments`.
+#
+# Common functionality for nodes that are parameterized:
+# `send`, `super`, `zsuper`, `def`, `defs`
+# and (modern only): `index`, `indexasgn`, `lambda`
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#10
+module RuboCop::AST::ParameterizedNode
+  # Checks whether this node has any arguments.
+  #
+  # @return [Boolean] whether this node has any arguments
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#40
+  def arguments?; end
+
+  # Whether the last argument of the node is a block pass,
+  # i.e. `&block`.
+  #
+  # @return [Boolean] whether the last argument of the node is a block pass
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#58
+  def block_argument?; end
+
+  # A shorthand for getting the first argument of the node.
+  # Equivalent to `arguments.first`.
+  #
+  # @return [Node, nil] the first argument of the node,
+  #   or `nil` if there are no arguments
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#24
+  def first_argument; end
+
+  # A shorthand for getting the last argument of the node.
+  # Equivalent to `arguments.last`.
+  #
+  # @return [Node, nil] the last argument of the node,
+  #   or `nil` if there are no arguments
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#33
+  def last_argument; end
+
+  # Checks whether this node's arguments are wrapped in parentheses.
+  #
+  # @return [Boolean] whether this node's arguments are
+  #   wrapped in parentheses
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#15
+  def parenthesized?; end
+
+  # Checks whether any argument of the node is a splat
+  # argument, i.e. `*splat`.
+  #
+  # @return [Boolean] whether the node is a splat argument
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#48
+  def rest_argument?; end
+
+  # Checks whether any argument of the node is a splat
+  # argument, i.e. `*splat`.
+  #
+  # @return [Boolean] whether the node is a splat argument
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#48
+  def splat_argument?; end
+end
+
+# A specialized `ParameterizedNode`.
+# Requires implementing `first_argument_index`
+# Implements `arguments` as `children[first_argument_index..-1]`
+# and optimizes other calls
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#83
+module RuboCop::AST::ParameterizedNode::RestArguments
+  include ::RuboCop::AST::ParameterizedNode
+
+  # @return [Array<Node>] arguments, if any
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#89
+  def arguments; end
+
+  # Checks whether this node has any arguments.
+  #
+  # @return [Boolean] whether this node has any arguments
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#119
+  def arguments?; end
+
+  # A shorthand for getting the first argument of the node.
+  # Equivalent to `arguments.first`.
+  #
+  # @return [Node, nil] the first argument of the node,
+  #   or `nil` if there are no arguments
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#103
+  def first_argument; end
+
+  # A shorthand for getting the last argument of the node.
+  # Equivalent to `arguments.last`.
+  #
+  # @return [Node, nil] the last argument of the node,
+  #   or `nil` if there are no arguments
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#112
+  def last_argument; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#86
+RuboCop::AST::ParameterizedNode::RestArguments::EMPTY_ARGUMENTS = T.let(T.unsafe(nil), Array)
+
+# A specialized `ParameterizedNode` for node that have a single child
+# containing either `nil`, an argument, or a `begin` node with all the
+# arguments
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#66
+module RuboCop::AST::ParameterizedNode::WrappedArguments
+  include ::RuboCop::AST::ParameterizedNode
+
+  # @return [Array] The arguments of the node.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/parameterized_node.rb#69
+  def arguments; end
+end
+
+# Common functionality for nodes that are predicates:
+# `or`, `and` ...
+#
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#7
+module RuboCop::AST::PredicateOperatorNode
+  # Checks whether this is a logical operator.
+  #
+  # @return [Boolean] whether this is a logical operator
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#27
+  def logical_operator?; end
+
+  # Returns the operator as a string.
+  #
+  # @return [String] the operator
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#20
+  def operator; end
+
+  # Checks whether this is a semantic operator.
+  #
+  # @return [Boolean] whether this is a semantic operator
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#34
+  def semantic_operator?; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#8
+RuboCop::AST::PredicateOperatorNode::LOGICAL_AND = T.let(T.unsafe(nil), String)
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#12
+RuboCop::AST::PredicateOperatorNode::LOGICAL_OR = T.let(T.unsafe(nil), String)
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#10
+RuboCop::AST::PredicateOperatorNode::SEMANTIC_AND = T.let(T.unsafe(nil), String)
+
+# source://rubocop-ast//lib/rubocop/ast/node/mixin/predicate_operator_node.rb#14
+RuboCop::AST::PredicateOperatorNode::SEMANTIC_OR = T.let(T.unsafe(nil), String)
+
+# A node extension for `procarg0` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all `arg` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/procarg0_node.rb#8
+class RuboCop::AST::Procarg0Node < ::RuboCop::AST::ArgNode
+  # Returns the name of an argument.
+  #
+  # @return [Symbol, nil] the name of the argument
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/procarg0_node.rb#12
+  def name; end
+end
+
+# ProcessedSource contains objects which are generated by Parser
+# and other information such as disabled lines for cops.
+# It also provides a convenient way to access source lines.
+#
+# source://rubocop-ast//lib/rubocop/ast/processed_source.rb#10
+class RuboCop::AST::ProcessedSource
+  # @return [ProcessedSource] a new instance of ProcessedSource
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#28
+  def initialize(source, ruby_version, path = T.unsafe(nil), parser_engine: T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#72
+  def [](*args); end
+
+  # Returns the value of attribute ast.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#20
+  def ast; end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#50
+  def ast_with_comments; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#111
+  def blank?; end
+
+  # Returns the value of attribute buffer.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#20
+  def buffer; end
+
+  # Raw source checksum for tracking infinite loops.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#83
+  def checksum; end
+
+  # @return [Comment, nil] the comment at that line, if any.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#116
+  def comment_at_line(line); end
+
+  # Consider using `each_comment_in_lines` instead
+  #
+  # @deprecated use contains_comment?
+  # @return [Boolean] if any of the lines in the given `source_range` has a comment.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#138
+  def commented?(source_range); end
+
+  # Returns the value of attribute comments.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#20
+  def comments; end
+
+  # Should have been called `comments_before_or_at_line`. Doubtful it has of any valid use.
+  #
+  # @deprecated Use `each_comment_in_lines`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#146
+  def comments_before_line(line); end
+
+  # Consider using `each_comment_in_lines` instead
+  #
+  # @return [Boolean] if any of the lines in the given `source_range` has a comment.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#138
+  def contains_comment?(source_range); end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#160
+  def current_line(token); end
+
+  # Returns the value of attribute diagnostics.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#20
+  def diagnostics; end
+
+  # @deprecated Use `comments.each`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#88
+  def each_comment(&block); end
+
+  # Enumerates on the comments contained with the given `line_range`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#126
+  def each_comment_in_lines(line_range); end
+
+  # @deprecated Use `tokens.each`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#98
+  def each_token(&block); end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#107
+  def file_path; end
+
+  # @deprecated Use `comment_at_line`, `each_comment_in_lines`, or `comments.find`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#93
+  def find_comment(&block); end
+
+  # @deprecated Use `tokens.find`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#103
+  def find_token(&block); end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#181
+  def first_token_of(range_or_node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#164
+  def following_line(token); end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#185
+  def last_token_of(range_or_node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#168
+  def line_indentation(line_number); end
+
+  # @return [Boolean] if the given line number has a comment.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#121
+  def line_with_comment?(line); end
+
+  # Returns the source lines, line break characters removed, excluding a
+  # possible __END__ and everything that comes after.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#58
+  def lines; end
+
+  # source://rubocop-md/1.2.4/lib/rubocop/markdown/rubocop_ext.rb#98
+  def parse(src, *args); end
+
+  # Returns the value of attribute parser_engine.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#20
+  def parser_engine; end
+
+  # Returns the value of attribute parser_error.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#20
+  def parser_error; end
+
+  # Returns the value of attribute path.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#20
+  def path; end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#156
+  def preceding_line(token); end
+
+  # Returns the value of attribute raw_source.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#20
+  def raw_source; end
+
+  # Returns the value of attribute ruby_version.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#20
+  def ruby_version; end
+
+  # The tokens list is always sorted by token position, except for cases when heredoc
+  # is passed as a method argument. In this case tokens are interleaved by
+  # heredoc contents' tokens.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#192
+  def sorted_tokens; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#150
+  def start_with?(string); end
+
+  # Returns the value of attribute tokens.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#20
+  def tokens; end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#175
+  def tokens_within(range_or_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#76
+  def valid_syntax?; end
+
+  private
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#199
+  def comment_index; end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#309
+  def create_parser(ruby_version, parser_engine); end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#325
+  def first_token_index(range_or_node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#330
+  def last_token_index(range_or_node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#238
+  def parser_class(ruby_version, parser_engine); end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#335
+  def source_range(range_or_node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#222
+  def tokenize(parser); end
+
+  class << self
+    # source://rubocop-ast//lib/rubocop/ast/processed_source.rb#23
+    def from_file(path, ruby_version, parser_engine: T.unsafe(nil)); end
+  end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/processed_source.rb#14
+RuboCop::AST::ProcessedSource::INVALID_LEVELS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop-ast//lib/rubocop/ast/processed_source.rb#17
+RuboCop::AST::ProcessedSource::PARSER_ENGINES = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/processed_source.rb#12
+RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME = T.let(T.unsafe(nil), String)
+
+# A node extension for `irange` and `erange` nodes. This will be used in
+# place of a plain node when the builder constructs the AST, making its
+# methods available to all `irange` and `erange` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/range_node.rb#8
+class RuboCop::AST::RangeNode < ::RuboCop::AST::Node
+  # source://rubocop-ast//lib/rubocop/ast/node/range_node.rb#9
+  def begin; end
+
+  # source://rubocop-ast//lib/rubocop/ast/node/range_node.rb#13
+  def end; end
+end
+
+# A node extension for `rational` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available to
+# all `rational` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/rational_node.rb#8
+class RuboCop::AST::RationalNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::BasicLiteralNode
+  include ::RuboCop::AST::NumericNode
+end
+
+# A node extension for `regexp` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `regexp` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#8
+class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node
+  # @return [String] a string of regexp content
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#37
+  def content; end
+
+  # @return [Bool] if char is one of the delimiters
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#57
+  def delimiter?(char); end
+
+  # @return [String] the regexp delimiters (without %r)
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#52
+  def delimiters; end
+
+  # @return [Bool] if regexp uses the extended regopt
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#72
+  def extended?; end
+
+  # @return [Bool] if regexp uses the fixed-encoding regopt
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#92
+  def fixed_encoding?; end
+
+  # @return [Bool] if regexp uses the ignore-case regopt
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#77
+  def ignore_case?; end
+
+  # @return [Bool] if regexp contains interpolation
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#62
+  def interpolation?; end
+
+  # @return [Bool] if regexp uses the multiline regopt
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#67
+  def multiline_mode?; end
+
+  # @return [Bool] if regexp uses the no-encoding regopt
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#87
+  def no_encoding?; end
+
+  # NOTE: The 'o' option is ignored.
+  #
+  # @return [Integer] the Regexp option bits as returned by Regexp#options
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#32
+  def options; end
+
+  # @return [Bool] if the regexp is a %r{...} literal (using any delimiters)
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#47
+  def percent_r_literal?; end
+
+  # @return [RuboCop::AST::Node] a regopt node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#25
+  def regopt; end
+
+  # @return [Bool] if regexp uses the single-interpolation regopt
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#82
+  def single_interpolation?; end
+
+  # @return [Bool] if the regexp is a /.../ literal
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#42
+  def slash_literal?; end
+
+  # @return [Regexp] a regexp of this node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#20
+  def to_regexp; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#98
+  def regopt_include?(option); end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/node/regexp_node.rb#9
+RuboCop::AST::RegexpNode::OPTIONS = T.let(T.unsafe(nil), Hash)
+
+# A node extension for `resbody` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `resbody` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/resbody_node.rb#8
+class RuboCop::AST::ResbodyNode < ::RuboCop::AST::Node
+  # Returns the body of the `rescue` clause.
+  #
+  # @return [Node, nil] The body of the `resbody`.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/resbody_node.rb#12
+  def body; end
+
+  # Returns the index of the `resbody` branch within the exception handling statement.
+  #
+  # @return [Integer] the index of the `resbody` branch
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/resbody_node.rb#40
+  def branch_index; end
+
+  # Returns the exception variable of the `rescue` clause.
+  #
+  # @return [Node, nil] The exception variable of the `resbody`.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/resbody_node.rb#33
+  def exception_variable; end
+
+  # Returns an array of all the exceptions in the `rescue` clause.
+  #
+  # @return [Array<Node>] an array of exception nodes
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/resbody_node.rb#19
+  def exceptions; end
+end
+
+# A node extension for `rescue` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `rescue` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/rescue_node.rb#8
+class RuboCop::AST::RescueNode < ::RuboCop::AST::Node
+  # Returns the body of the rescue node.
+  #
+  # @return [Node, nil] The body of the rescue node.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/rescue_node.rb#12
+  def body; end
+
+  # Returns an array of all the rescue branches in the exception handling statement.
+  #
+  # and the else (if any). Note that these bodies could be nil.
+  #
+  # @return [Array<Node, nil>] an array of the bodies of the rescue branches
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/rescue_node.rb#27
+  def branches; end
+
+  # Checks whether this exception handling statement has an `else` branch.
+  #
+  # @return [Boolean] whether the exception handling statement has an `else` branch
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/rescue_node.rb#44
+  def else?; end
+
+  # Returns the else branch of the exception handling statement, if any.
+  #
+  # @return [Node] the else branch node of the exception handling statement
+  # @return [nil] if the exception handling statement does not have an else branch.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/rescue_node.rb#37
+  def else_branch; end
+
+  # Returns an array of all the rescue branches in the exception handling statement.
+  #
+  # @return [Array<ResbodyNode>] an array of `resbody` nodes
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/rescue_node.rb#19
+  def resbody_branches; end
+end
+
+# A node extension for `return` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `return` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/return_node.rb#8
+class RuboCop::AST::ReturnNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::ParameterizedNode::WrappedArguments
+end
+
+# Responsible for compatibility with main gem
+#
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/rubocop_compatibility.rb#8
+module RuboCop::AST::RuboCopCompatibility
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/rubocop_compatibility.rb#13
+  def rubocop_loaded; end
+end
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/rubocop_compatibility.rb#9
+RuboCop::AST::RuboCopCompatibility::INCOMPATIBLE_COPS = T.let(T.unsafe(nil), Hash)
+
+# A node extension for `sclass` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `sclass` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/self_class_node.rb#8
+class RuboCop::AST::SelfClassNode < ::RuboCop::AST::Node
+  # The body of this `sclass` node.
+  #
+  # @return [Node, nil] the body of the class
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/self_class_node.rb#19
+  def body; end
+
+  # The identifier for this `sclass` node. (Always `self`.)
+  #
+  # @return [Node] the identifier of the class
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/self_class_node.rb#12
+  def identifier; end
+end
+
+# A node extension for `send` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `send` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/send_node.rb#8
+class RuboCop::AST::SendNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::ParameterizedNode::RestArguments
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::MethodDispatchNode
+
+  # source://rubocop-ast//lib/rubocop/ast/node/send_node.rb#13
+  def attribute_accessor?(param0 = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/send_node.rb#18
+  def send_type?; end
+
+  private
+
+  # source://rubocop-ast//lib/rubocop/ast/node/send_node.rb#24
+  def first_argument_index; end
+end
+
+# This module provides a shorthand method to create a {Node} like
+# `Parser::AST::Sexp`.
+#
+# @see https://www.rubydoc.info/gems/ast/AST/Sexp
+#
+# source://rubocop-ast//lib/rubocop/ast/sexp.rb#9
+module RuboCop::AST::Sexp
+  # Creates a {Node} with type `type` and children `children`.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/sexp.rb#11
+  def s(type, *children); end
+end
+
+# A node extension for `str`, `dstr`, and `xstr` nodes. This will be used
+# in place of a plain node when the builder constructs the AST, making
+# its methods available to all `str` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/str_node.rb#8
+class RuboCop::AST::StrNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::BasicLiteralNode
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/str_node.rb#11
+  def character_literal?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/str_node.rb#15
+  def heredoc?; end
+end
+
+# A node extension for `super`- and `zsuper` nodes. This will be used in
+# place of a plain node when the builder constructs the AST, making its
+# methods available to all `super`- and `zsuper` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/super_node.rb#8
+class RuboCop::AST::SuperNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::MethodDispatchNode
+
+  # source://ast/2.4.2/lib/ast/node.rb#56
+  def arguments; end
+
+  # Custom destructuring method. This can be used to normalize
+  # destructuring for different variations of the node.
+  #
+  # @return [Array] the different parts of the `super` node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/super_node.rb#16
+  def node_parts; end
+end
+
+# A node extension for `sym` nodes. This will be used in  place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `sym` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/symbol_node.rb#8
+class RuboCop::AST::SymbolNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::BasicLiteralNode
+end
+
+# A basic wrapper around Parser's tokens.
+#
+# source://rubocop-ast//lib/rubocop/ast/token.rb#6
+class RuboCop::AST::Token
+  # @return [Token] a new instance of Token
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#17
+  def initialize(pos, type, text); end
+
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#32
+  def begin_pos; end
+
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#28
+  def column; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#101
+  def comma?; end
+
+  # Type Predicates
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#57
+  def comment?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#105
+  def dot?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#117
+  def end?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#36
+  def end_pos; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#121
+  def equal_sign?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#65
+  def left_array_bracket?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#81
+  def left_brace?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#73
+  def left_bracket?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#85
+  def left_curly_brace?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#93
+  def left_parens?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#69
+  def left_ref_bracket?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#24
+  def line; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#125
+  def new_line?; end
+
+  # Returns the value of attribute pos.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#9
+  def pos; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#109
+  def regexp_dots?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#113
+  def rescue_modifier?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#77
+  def right_bracket?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#89
+  def right_curly_brace?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#97
+  def right_parens?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#61
+  def semicolon?; end
+
+  # Checks if there is whitespace after token
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#45
+  def space_after?; end
+
+  # Checks if there is whitespace before token
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#50
+  def space_before?; end
+
+  # Returns the value of attribute text.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#9
+  def text; end
+
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#40
+  def to_s; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/token.rb#9
+  def type; end
+
+  class << self
+    # source://rubocop-ast//lib/rubocop/ast/token.rb#11
+    def from_parser_token(parser_token); end
+  end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/token.rb#7
+RuboCop::AST::Token::LEFT_PAREN_TYPES = T.let(T.unsafe(nil), Array)
+
+# Provides methods for traversing an AST.
+# Does not transform an AST; for that, use Parser::AST::Processor.
+# Override methods to perform custom processing. Remember to call `super`
+# if you want to recursively process descendant nodes.
+#
+# source://rubocop-ast//lib/rubocop/ast/traversal.rb#9
+module RuboCop::AST::Traversal
+  extend ::RuboCop::AST::Traversal::CallbackCompiler
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#173
+  def on_(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on___ENCODING__(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on___FILE__(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on___LINE__(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_alias(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_and(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_and_asgn(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_arg(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128
+  def on_arg_expr(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_args(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_array(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_array_pattern(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_array_pattern_with_tail(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_back_ref(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_begin(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#151
+  def on_block(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#129
+  def on_block_pass(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_blockarg(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_break(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139
+  def on_case(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139
+  def on_case_match(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#146
+  def on_casgn(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_cbase(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#147
+  def on_class(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_complex(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#145
+  def on_const(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_const_pattern(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#155
+  def on_csend(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_cvar(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#131
+  def on_cvasgn(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#148
+  def on_def(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128
+  def on_defined?(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#153
+  def on_defs(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_dstr(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_dsym(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_eflipflop(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_empty_else(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139
+  def on_ensure(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139
+  def on_erange(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_false(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_find_pattern(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_float(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139
+  def on_for(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_forward_arg(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_forward_args(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_forwarded_args(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_forwarded_kwrestarg(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_forwarded_restarg(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_gvar(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#131
+  def on_gvasgn(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_hash(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_hash_pattern(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#150
+  def on_if(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128
+  def on_if_guard(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_iflipflop(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_in_match(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139
+  def on_in_pattern(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_index(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_indexasgn(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_int(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139
+  def on_irange(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_ivar(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#131
+  def on_ivasgn(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_kwarg(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_kwargs(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_kwbegin(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_kwnilarg(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#132
+  def on_kwoptarg(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#124
+  def on_kwrestarg(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#125
+  def on_kwsplat(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_lambda(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_lvar(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#131
+  def on_lvasgn(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_masgn(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_match_alt(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_match_as(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128
+  def on_match_current_line(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_match_nil_pattern(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139
+  def on_match_pattern(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139
+  def on_match_pattern_p(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#125
+  def on_match_rest(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_match_var(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_match_with_lvasgn(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128
+  def on_match_with_trailing_comma(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_mlhs(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#133
+  def on_module(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_mrasgn(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_next(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_nil(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128
+  def on_not(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_nth_ref(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#152
+  def on_numblock(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#149
+  def on_op_asgn(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#132
+  def on_optarg(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_or(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_or_asgn(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_pair(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128
+  def on_pin(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#129
+  def on_postexe(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#129
+  def on_preexe(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_procarg0(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_rasgn(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_rational(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_redo(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_regexp(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#135
+  def on_regopt(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139
+  def on_resbody(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139
+  def on_rescue(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#124
+  def on_restarg(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_retry(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_return(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#133
+  def on_sclass(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_self(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#155
+  def on_send(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_shadowarg(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#125
+  def on_splat(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_str(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_super(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#127
+  def on_sym(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_true(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_undef(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#128
+  def on_unless_guard(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#133
+  def on_until(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_until_post(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#139
+  def on_when(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#133
+  def on_while(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_while_post(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_xstr(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#136
+  def on_yield(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#123
+  def on_zsuper(node); end
+
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#17
+  def walk(node); end
+end
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/traversal.rb#25
+module RuboCop::AST::Traversal::CallbackCompiler
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#61
+  def arity_check(range); end
+
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#52
+  def body(signature, prelude); end
+
+  # @api private
+  #
+  # source://rubocop-ast//lib/rubocop/ast/traversal.rb#35
+  def def_callback(type, *signature, arity: T.unsafe(nil), arity_check: T.unsafe(nil), body: T.unsafe(nil)); end
+end
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/traversal.rb#26
+RuboCop::AST::Traversal::CallbackCompiler::SEND = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/traversal.rb#29
+RuboCop::AST::Traversal::CallbackCompiler::TEMPLATE = T.let(T.unsafe(nil), Hash)
+
+# Only for debugging.
+#
+# @api private
+#
+# source://rubocop-ast//lib/rubocop/ast/traversal.rb#12
+class RuboCop::AST::Traversal::DebugError < ::RuntimeError; end
+
+# source://rubocop-ast//lib/rubocop/ast/traversal.rb#100
+RuboCop::AST::Traversal::NO_CHILD_NODES = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-ast//lib/rubocop/ast/traversal.rb#15
+RuboCop::AST::Traversal::TYPE_TO_METHOD = T.let(T.unsafe(nil), Hash)
+
+# A node extension for `until` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `until` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/until_node.rb#8
+class RuboCop::AST::UntilNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ConditionalNode
+  include ::RuboCop::AST::ModifierNode
+
+  # Checks whether the `until` node has a `do` keyword.
+  #
+  # @return [Boolean] whether the `until` node has a `do` keyword
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/until_node.rb#30
+  def do?; end
+
+  # Returns the inverse keyword of the `until` node as a string.
+  # Returns `while` for `until` nodes and vice versa.
+  #
+  # @return [String] the inverse keyword of the `until` statement
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/until_node.rb#23
+  def inverse_keyword; end
+
+  # Returns the keyword of the `until` statement as a string.
+  #
+  # @return [String] the keyword of the `until` statement
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/until_node.rb#15
+  def keyword; end
+end
+
+# A node extension for `lvar`, `ivar`, `cvar` and `gvar` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all assignment nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/var_node.rb#8
+class RuboCop::AST::VarNode < ::RuboCop::AST::Node
+  # @return [Symbol] The name of the variable.
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/var_node.rb#10
+  def name; end
+end
+
+# source://rubocop-ast//lib/rubocop/ast/version.rb#5
+module RuboCop::AST::Version; end
+
+# source://rubocop-ast//lib/rubocop/ast/version.rb#6
+RuboCop::AST::Version::STRING = T.let(T.unsafe(nil), String)
+
+# A node extension for `when` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `when` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/when_node.rb#8
+class RuboCop::AST::WhenNode < ::RuboCop::AST::Node
+  # Returns the body of the `when` node.
+  #
+  # @return [Node, nil] the body of the `when` node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/when_node.rb#42
+  def body; end
+
+  # Returns the index of the `when` branch within the `case` statement.
+  #
+  # @return [Integer] the index of the `when` branch
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/when_node.rb#28
+  def branch_index; end
+
+  # Returns an array of all the conditions in the `when` branch.
+  #
+  # @return [Array<Node>] an array of condition nodes
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/when_node.rb#12
+  def conditions; end
+
+  # @deprecated Use `conditions.each`
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/when_node.rb#17
+  def each_condition(&block); end
+
+  # Checks whether the `when` node has a `then` keyword.
+  #
+  # @return [Boolean] whether the `when` node has a `then` keyword
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/when_node.rb#35
+  def then?; end
+end
+
+# A node extension for `while` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `while` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/while_node.rb#8
+class RuboCop::AST::WhileNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ConditionalNode
+  include ::RuboCop::AST::ModifierNode
+
+  # Checks whether the `until` node has a `do` keyword.
+  #
+  # @return [Boolean] whether the `until` node has a `do` keyword
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/while_node.rb#30
+  def do?; end
+
+  # Returns the inverse keyword of the `while` node as a string.
+  # Returns `until` for `while` nodes and vice versa.
+  #
+  # @return [String] the inverse keyword of the `while` statement
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/while_node.rb#23
+  def inverse_keyword; end
+
+  # Returns the keyword of the `while` statement as a string.
+  #
+  # @return [String] the keyword of the `while` statement
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/while_node.rb#15
+  def keyword; end
+end
+
+# A node extension for `yield` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `yield` nodes within RuboCop.
+#
+# source://rubocop-ast//lib/rubocop/ast/node/yield_node.rb#8
+class RuboCop::AST::YieldNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::MethodDispatchNode
+
+  # source://ast/2.4.2/lib/ast/node.rb#56
+  def arguments; end
+
+  # Custom destructuring method. This can be used to normalize
+  # destructuring for different variations of the node.
+  #
+  # @return [Array] the different parts of the `send` node
+  #
+  # source://rubocop-ast//lib/rubocop/ast/node/yield_node.rb#16
+  def node_parts; end
+end
+
+class RuboCop::CommentConfig
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#34
+  def initialize(processed_source); end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#63
+  def comment_only_line?(line_number); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def config(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#51
+  def cop_disabled_line_ranges; end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#39
+  def cop_enabled_at_line?(cop, line_number); end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#47
+  def cop_opted_in?(cop); end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#55
+  def extra_enabled_comments; end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#30
+  def processed_source; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def registry(*_arg0, **_arg1, &_arg2); end
+
+  private
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#96
+  def analyze; end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#124
+  def analyze_cop(analysis, directive); end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#144
+  def analyze_disabled(analysis, directive); end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#155
+  def analyze_rest(analysis, directive); end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#135
+  def analyze_single_line(analysis, directive); end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#164
+  def cop_line_ranges(analysis); end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#170
+  def each_directive; end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#69
+  def extra_enabled_comments_with_names(extras:, names:); end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#190
+  def handle_enable_all(directive, names, extras); end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#204
+  def handle_switch(directive, names, extras); end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#115
+  def inject_disabled_cops_directives(analyses); end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#183
+  def non_comment_token_line_numbers; end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#83
+  def opt_in_cops; end
+
+  # source://rubocop/1.67.0/lib/rubocop/comment_config.rb#179
+  def qualified_cop_name(cop_name); end
+end
+
+class RuboCop::Config
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#30
+  def initialize(hash = T.unsafe(nil), loaded_path = T.unsafe(nil)); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def [](*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def []=(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#170
+  def active_support_extensions_enabled?; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#96
+  def add_excludes_from_higher_level(highest_config); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#197
+  def allowed_camel_case_file?(file); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#241
+  def base_dir_for_path_parameters; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#271
+  def bundler_lock_file_path; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#51
+  def check; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#142
+  def clusivity_config_for_badge?(badge); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def delete(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#108
+  def deprecation_check; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def dig(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#162
+  def disabled_new_cops?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def each(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def each_key(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#166
+  def enabled_new_cops?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def fetch(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#219
+  def file_to_exclude?(file); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#178
+  def file_to_include?(file); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#158
+  def for_all_cops; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#128
+  def for_badge(badge); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#122
+  def for_cop(cop); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#153
+  def for_department(department_name); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#296
+  def gem_versions_in_target; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#300
+  def inspect; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#76
+  def internal?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def key?(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def keys(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#47
+  def loaded_features; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#20
+  def loaded_path; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#81
+  def make_excludes_absolute; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def map(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def merge(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#251
+  def parser_engine; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#232
+  def path_relative_to_config(path); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#228
+  def patterns_to_exclude; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#224
+  def patterns_to_include; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#282
+  def pending_cops; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#211
+  def possibly_include_hidden?; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def replace(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#71
+  def signature; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#266
+  def smart_loaded_path; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#174
+  def string_literals_frozen_by_default?; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#255
+  def target_rails_version; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def target_ruby_version(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def to_h(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def to_hash(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#67
+  def to_s; end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def transform_values(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def validate(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#58
+  def validate_after_resolution; end
+
+  private
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#350
+  def department_of(qualified_cop_name); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#338
+  def enable_cop?(qualified_cop_name, cop_options); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#325
+  def gem_version_to_major_minor_float(gem_version); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#331
+  def read_gem_versions_from_target_lockfile; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#312
+  def read_rails_version_from_bundler_lock_file; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config.rb#307
+  def target_rails_version_from_bundler_lock_file; end
+
+  class << self
+    # source://rubocop/1.67.0/lib/rubocop/config.rb#22
+    def create(hash, path, check: T.unsafe(nil)); end
+  end
+end
+
+class RuboCop::ConfigValidator
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#27
+  def initialize(config); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def for_all_cops(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def smart_loaded_path(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#63
+  def target_ruby_version; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#33
+  def validate; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#59
+  def validate_after_resolution; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#67
+  def validate_section_presence(name); end
+
+  private
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#104
+  def alert_about_unrecognized_cops(invalid_cop_names); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#254
+  def check_cop_config_value(hash, parent = T.unsafe(nil)); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#77
+  def check_obsoletions; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#84
+  def check_target_ruby; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#195
+  def each_invalid_parameter(cop_name); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#120
+  def list_unknown_cops(invalid_cop_names); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#274
+  def param_error_message(parent, key, value, supposed_values); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#242
+  def reject_conflicting_safe_settings; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#233
+  def reject_mutually_exclusive_defaults; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#142
+  def suggestion(name); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#75
+  def target_ruby; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#207
+  def validate_enforced_styles(valid_cop_names); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#169
+  def validate_new_cops_parameter; end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#180
+  def validate_parameter_names(valid_cop_names); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#227
+  def validate_support_and_has_list(name, formats, valid); end
+
+  # source://rubocop/1.67.0/lib/rubocop/config_validator.rb#158
+  def validate_syntax_cop; end
+end
+
+# Similar to `Forwardable#def_delegators`, but simpler & faster
+#
+# source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#5
+module RuboCop::SimpleForwardable
+  # source://rubocop-ast//lib/rubocop/ast/utilities/simple_forwardable.rb#6
+  def def_delegators(accessor, *methods); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-performance@1.14.3.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-performance@1.14.3.rbi
deleted file mode 100644
index 377295ca1cdfc..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rubocop-performance@1.14.3.rbi
+++ /dev/null
@@ -1,922 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rubocop-performance` gem.
-# Please instead update this file by running `bin/tapioca gem rubocop-performance`.
-
-module RuboCop; end
-module RuboCop::Cop; end
-RuboCop::Cop::IgnoredPattern = RuboCop::Cop::AllowedPattern
-module RuboCop::Cop::Performance; end
-
-class RuboCop::Cop::Performance::AncestorsInclude < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def ancestors_include_candidate?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def range(node); end
-end
-
-RuboCop::Cop::Performance::AncestorsInclude::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::AncestorsInclude::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::ArraySemiInfiniteRangeSlice < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def endless_range?(param0 = T.unsafe(nil)); end
-  def endless_range_slice?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def correction(receiver, range_node); end
-end
-
-RuboCop::Cop::Performance::ArraySemiInfiniteRangeSlice::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::ArraySemiInfiniteRangeSlice::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Performance::ArraySemiInfiniteRangeSlice::SLICE_METHODS = T.let(T.unsafe(nil), Set)
-
-class RuboCop::Cop::Performance::BigDecimalWithNumericArgument < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def big_decimal_with_numeric_argument?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def to_d?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Performance::BigDecimalWithNumericArgument::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::BigDecimalWithNumericArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::BindCall < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def bind_with_call_method?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def build_call_args(call_args_node); end
-  def correction_range(receiver, node); end
-  def message(bind_arg, call_args); end
-end
-
-RuboCop::Cop::Performance::BindCall::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::BindCall::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::BlockGivenWithExplicitBlock < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def reassigns_block_arg?(param0 = T.unsafe(nil), param1); end
-end
-
-RuboCop::Cop::Performance::BlockGivenWithExplicitBlock::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::BlockGivenWithExplicitBlock::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::Caller < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def caller_with_scope_method?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def slow_caller?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def int_value(node); end
-end
-
-RuboCop::Cop::Performance::Caller::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::Caller::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::CaseWhenSplat < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_case(case_node); end
-
-  private
-
-  def autocorrect(corrector, when_node); end
-  def indent_for(node); end
-  def inline_fix_branch(corrector, when_node); end
-  def needs_reorder?(when_node); end
-  def new_branch_without_then(node, new_condition); end
-  def new_condition_with_then(node, new_condition); end
-  def non_splat?(condition); end
-  def range(node); end
-  def reorder_condition(corrector, when_node); end
-  def reordering_correction(when_node); end
-  def replacement(conditions); end
-  def splat_offenses(when_conditions); end
-  def when_branch_range(when_node); end
-end
-
-RuboCop::Cop::Performance::CaseWhenSplat::ARRAY_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::CaseWhenSplat::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Performance::Casecmp < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def downcase_downcase(param0 = T.unsafe(nil)); end
-  def downcase_eq(param0 = T.unsafe(nil)); end
-  def eq_downcase(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def autocorrect(corrector, node, replacement); end
-  def build_good_method(method, arg, variable); end
-  def take_method_apart(node); end
-end
-
-RuboCop::Cop::Performance::Casecmp::CASE_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Performance::Casecmp::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::Casecmp::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::ChainArrayAllocation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def chain_array_allocation?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Performance::ChainArrayAllocation::ALWAYS_RETURNS_NEW_ARRAY = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Performance::ChainArrayAllocation::HAS_MUTATION_ALTERNATIVE = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Performance::ChainArrayAllocation::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::ChainArrayAllocation::RETURNS_NEW_ARRAY = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Performance::ChainArrayAllocation::RETURNS_NEW_ARRAY_WHEN_NO_BLOCK = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Performance::ChainArrayAllocation::RETURN_NEW_ARRAY_WHEN_ARGS = T.let(T.unsafe(nil), Set)
-
-class RuboCop::Cop::Performance::CollectionLiteralInLoop < ::RuboCop::Cop::Base
-  def enumerable_loop?(param0 = T.unsafe(nil)); end
-  def kernel_loop?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def check_literal?(node, method); end
-  def enumerable_method?(method_name); end
-  def keyword_loop?(type); end
-  def literal_class(node); end
-  def loop?(ancestor, node); end
-  def min_size; end
-  def node_within_enumerable_loop?(node, ancestor); end
-  def nonmutable_method_of_array_or_hash?(node, method); end
-  def parent_is_loop?(node); end
-end
-
-RuboCop::Cop::Performance::CollectionLiteralInLoop::ARRAY_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Performance::CollectionLiteralInLoop::ENUMERABLE_METHOD_NAMES = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Performance::CollectionLiteralInLoop::HASH_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Performance::CollectionLiteralInLoop::LOOP_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Performance::CollectionLiteralInLoop::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::CollectionLiteralInLoop::NONMUTATING_ARRAY_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Performance::CollectionLiteralInLoop::NONMUTATING_HASH_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Performance::CollectionLiteralInLoop::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::CompareWithBlock < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def compare?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def replaceable_body?(param0 = T.unsafe(nil), param1, param2); end
-
-  private
-
-  def compare_range(send, node); end
-  def message(send, method, var_a, var_b, args); end
-  def slow_compare?(method, args_a, args_b); end
-end
-
-RuboCop::Cop::Performance::CompareWithBlock::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Performance::ConcurrentMonotonicTime < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def concurrent_monotonic_time?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Performance::ConcurrentMonotonicTime::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::ConcurrentMonotonicTime::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::ConstantRegexp < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_regexp(node); end
-  def regexp_escape?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def include_interpolated_const?(node); end
-  def within_allowed_assignment?(node); end
-end
-
-RuboCop::Cop::Performance::ConstantRegexp::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Performance::Count < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def count_candidate?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def autocorrect(corrector, node, selector_node, selector); end
-  def eligible_node?(node); end
-  def source_starting_at(node); end
-end
-
-RuboCop::Cop::Performance::Count::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::Count::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::DeletePrefix < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RegexpMetacharacter
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def delete_prefix_candidate?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Performance::DeletePrefix::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::DeletePrefix::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Performance::DeletePrefix::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::DeleteSuffix < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RegexpMetacharacter
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def delete_suffix_candidate?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Performance::DeleteSuffix::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::DeleteSuffix::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Performance::DeleteSuffix::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::Detect < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def detect_candidate?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def accept_first_call?(receiver, body); end
-  def autocorrect(corrector, node, replacement); end
-  def lazy?(node); end
-  def message_for_method(method, index); end
-  def preferred_method; end
-  def register_offense(node, receiver, second_method, index); end
-  def replacement(method, index); end
-end
-
-RuboCop::Cop::Performance::Detect::CANDIDATE_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Performance::Detect::INDEX_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::Detect::INDEX_REVERSE_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::Detect::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::Detect::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Performance::Detect::REVERSE_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Performance::DoubleStartEndWith < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def check_with_active_support_aliases(param0 = T.unsafe(nil)); end
-  def on_or(node); end
-  def two_start_end_with_calls(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, first_call_args, second_call_args, combined_args); end
-  def check_for_active_support_aliases?; end
-  def combine_args(first_call_args, second_call_args); end
-  def message(node, receiver, method, combined_args); end
-  def process_source(node); end
-end
-
-RuboCop::Cop::Performance::DoubleStartEndWith::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Performance::EndWith < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RegexpMetacharacter
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_match_with_lvasgn(node); end
-  def on_send(node); end
-  def redundant_regex?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Performance::EndWith::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::EndWith::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::FixedSize < ::RuboCop::Cop::Base
-  def counter(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def allowed_argument?(arg); end
-  def allowed_parent?(node); end
-  def allowed_variable?(var); end
-  def contains_double_splat?(node); end
-  def contains_splat?(node); end
-  def non_string_argument?(node); end
-end
-
-RuboCop::Cop::Performance::FixedSize::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::FixedSize::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::FlatMap < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def flat_map_candidate?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def offense_for_levels(node, map_node, first_method, flatten); end
-  def offense_for_method(node, map_node, first_method, flatten); end
-  def register_offense(node, map_node, first_method, flatten, message); end
-end
-
-RuboCop::Cop::Performance::FlatMap::FLATTEN_MULTIPLE_LEVELS = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::FlatMap::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::FlatMap::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::InefficientHashSearch < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def inefficient_include?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def autocorrect_argument(node); end
-  def autocorrect_hash_expression(node); end
-  def autocorrect_method(node); end
-  def current_method(node); end
-  def message(node); end
-  def use_long_method; end
-end
-
-RuboCop::Cop::Performance::InefficientHashSearch::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::IoReadlines < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def readlines_on_class?(param0 = T.unsafe(nil)); end
-  def readlines_on_instance?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, enumerable_call, readlines_call, receiver); end
-  def build_bad_method(enumerable_call); end
-  def build_call_args(call_args_node); end
-  def build_good_method(enumerable_call); end
-  def correction_range(enumerable_call, readlines_call); end
-  def offense_range(enumerable_call, readlines_call); end
-end
-
-RuboCop::Cop::Performance::IoReadlines::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::IoReadlines::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::MapCompact < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def map_compact(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def compact_method_with_final_newline_range(compact_method_range); end
-  def invoke_method_after_map_compact_on_same_line?(compact_node, chained_method); end
-  def map_method_and_compact_method_on_same_line?(map_node, compact_node); end
-  def remove_compact_method(corrector, map_node, compact_node, chained_method); end
-end
-
-RuboCop::Cop::Performance::MapCompact::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::MapCompact::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::MethodObjectAsBlock < ::RuboCop::Cop::Base
-  def method_object_as_argument?(param0 = T.unsafe(nil)); end
-  def on_block_pass(node); end
-end
-
-RuboCop::Cop::Performance::MethodObjectAsBlock::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Performance::OpenStruct < ::RuboCop::Cop::Base
-  def on_send(node); end
-  def open_struct(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Performance::OpenStruct::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::OpenStruct::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::RangeInclude < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def range_include(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Performance::RangeInclude::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::RangeInclude::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::RedundantBlockCall < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def blockarg_assigned?(param0, param1); end
-  def blockarg_calls(param0, param1); end
-  def blockarg_def(param0 = T.unsafe(nil)); end
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def args_include_block_pass?(blockcall); end
-  def autocorrect(corrector, node); end
-  def calls_to_report(argname, body); end
-  def shadowed_block_argument?(body, block_argument_of_method_signature); end
-end
-
-RuboCop::Cop::Performance::RedundantBlockCall::CLOSE_PAREN = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::RedundantBlockCall::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::RedundantBlockCall::OPEN_PAREN = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::RedundantBlockCall::SPACE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::RedundantBlockCall::YIELD = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Performance::RedundantEqualityComparisonBlock < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_block(node); end
-
-  private
-
-  def new_argument(block_argument, block_body); end
-  def offense_range(node); end
-  def one_block_argument?(block_arguments); end
-  def same_block_argument_and_is_a_argument?(block_body, block_argument); end
-  def use_block_argument_in_method_argument_of_operand?(block_argument, operand); end
-  def use_equality_comparison_block?(block_body); end
-end
-
-RuboCop::Cop::Performance::RedundantEqualityComparisonBlock::COMPARISON_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Performance::RedundantEqualityComparisonBlock::IS_A_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Performance::RedundantEqualityComparisonBlock::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::RedundantEqualityComparisonBlock::TARGET_METHODS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::RedundantMatch < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def match_call?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def only_truthiness_matters?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node); end
-end
-
-RuboCop::Cop::Performance::RedundantMatch::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::RedundantMatch::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::RedundantMerge < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def modifier_flow_control?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def redundant_merge_candidate(param0 = T.unsafe(nil)); end
-
-  private
-
-  def correct_multiple_elements(corrector, node, parent, new_source); end
-  def correct_single_element(corrector, node, new_source); end
-  def each_redundant_merge(node); end
-  def indent_width; end
-  def kwsplat_used?(pairs); end
-  def leading_spaces(node); end
-  def max_key_value_pairs; end
-  def message(node); end
-  def non_redundant_merge?(node, receiver, pairs); end
-  def non_redundant_pairs?(receiver, pairs); end
-  def non_redundant_value_used?(receiver, node); end
-  def rewrite_with_modifier(node, parent, new_source); end
-  def to_assignments(receiver, pairs); end
-end
-
-RuboCop::Cop::Performance::RedundantMerge::AREF_ASGN = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Performance::RedundantMerge::EachWithObjectInspector
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def initialize(node, receiver); end
-
-  def each_with_object_node(param0 = T.unsafe(nil)); end
-  def value_used?; end
-
-  private
-
-  def eligible_receiver?; end
-  def node; end
-  def receiver; end
-  def second_argument; end
-  def unwind(receiver); end
-end
-
-RuboCop::Cop::Performance::RedundantMerge::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::RedundantMerge::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Performance::RedundantMerge::WITH_MODIFIER_CORRECTION = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Performance::RedundantSortBlock < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::SortBlock
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-
-  private
-
-  def message(var_a, var_b); end
-end
-
-RuboCop::Cop::Performance::RedundantSortBlock::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Performance::RedundantSplitRegexpArgument < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def split_call_with_regexp?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def determinist_regexp?(regexp_node); end
-  def replacement(regexp_node); end
-end
-
-RuboCop::Cop::Performance::RedundantSplitRegexpArgument::DETERMINISTIC_REGEX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Performance::RedundantSplitRegexpArgument::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::RedundantSplitRegexpArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Performance::RedundantSplitRegexpArgument::STR_SPECIAL_CHARS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::RedundantStringChars < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def redundant_chars_call?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def build_bad_method(method, args); end
-  def build_call_args(call_args_node); end
-  def build_good_method(method, args); end
-  def build_good_method_for_brackets_or_first_method(method, args); end
-  def build_message(method, args); end
-  def correction_range(receiver, node); end
-  def offense_range(receiver, node); end
-end
-
-RuboCop::Cop::Performance::RedundantStringChars::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::RedundantStringChars::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::RegexpMatch < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def last_matches(param0); end
-  def match_method?(param0 = T.unsafe(nil)); end
-  def match_node?(param0 = T.unsafe(nil)); end
-  def match_operator?(param0 = T.unsafe(nil)); end
-  def match_threequals?(param0 = T.unsafe(nil)); end
-  def match_with_int_arg_method?(param0 = T.unsafe(nil)); end
-  def match_with_lvasgn?(node); end
-  def on_case(node); end
-  def on_if(node); end
-  def search_match_nodes(param0); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def check_condition(cond); end
-  def correct_operator(corrector, recv, arg, oper = T.unsafe(nil)); end
-  def correction_range(recv, arg); end
-  def find_last_match(body, range, scope_root); end
-  def last_match_used?(match_node); end
-  def match_gvar?(sym); end
-  def message(node); end
-  def modifier_form?(match_node); end
-  def next_match_pos(body, match_node_pos, scope_root); end
-  def range_to_search_for_last_matches(match_node, body, scope_root); end
-  def replace_with_match_predicate_method(corrector, recv, arg, op_range); end
-  def scope_body(node); end
-  def scope_root(node); end
-  def swap_receiver_and_arg(corrector, recv, arg); end
-end
-
-RuboCop::Cop::Performance::RegexpMatch::MATCH_NODE_PATTERN = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::RegexpMatch::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::RegexpMatch::TYPES_IMPLEMENTING_MATCH = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::ReverseEach < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def reverse_each?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def offense_range(node); end
-  def use_return_value?(node); end
-end
-
-RuboCop::Cop::Performance::ReverseEach::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::ReverseEach::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::ReverseFirst < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def reverse_first_candidate?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def build_bad_method(node); end
-  def build_good_method(node); end
-  def build_message(node); end
-  def correction_range(receiver, node); end
-end
-
-RuboCop::Cop::Performance::ReverseFirst::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::ReverseFirst::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::SelectMap < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def bad_method?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def map_method_candidate(node); end
-  def offense_range(node, map_method); end
-end
-
-RuboCop::Cop::Performance::SelectMap::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::SelectMap::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::Size < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def array?(param0 = T.unsafe(nil)); end
-  def count?(param0 = T.unsafe(nil)); end
-  def hash?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Performance::Size::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::Size::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::SortReverse < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::SortBlock
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-
-  private
-
-  def message(var_a, var_b); end
-end
-
-RuboCop::Cop::Performance::SortReverse::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Performance::Squeeze < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def squeeze_candidate?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def repeating_literal?(regex_str); end
-end
-
-RuboCop::Cop::Performance::Squeeze::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::Squeeze::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Performance::Squeeze::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::StartWith < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RegexpMetacharacter
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_match_with_lvasgn(node); end
-  def on_send(node); end
-  def redundant_regex?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Performance::StartWith::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::StartWith::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::StringIdentifierArgument < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-end
-
-RuboCop::Cop::Performance::StringIdentifierArgument::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::StringIdentifierArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::StringInclude < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_match_with_lvasgn(node); end
-  def on_send(node); end
-  def redundant_regex?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def literal?(regex_str); end
-end
-
-RuboCop::Cop::Performance::StringInclude::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::StringInclude::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::StringReplacement < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def string_replacement?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def accept_first_param?(first_param); end
-  def accept_second_param?(second_param); end
-  def autocorrect(corrector, node); end
-  def first_source(first_param); end
-  def message(node, first_source, second_source); end
-  def method_suffix(node); end
-  def offense(node, first_param, second_param); end
-  def range(node); end
-  def remove_second_param(corrector, node, first_param); end
-  def replace_method(corrector, node, first_source, second_source, first_param); end
-  def replacement_method(node, first_source, second_source); end
-  def source_from_regex_constructor(node); end
-  def source_from_regex_literal(node); end
-end
-
-RuboCop::Cop::Performance::StringReplacement::BANG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::StringReplacement::DELETE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::StringReplacement::DETERMINISTIC_REGEX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Performance::StringReplacement::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::StringReplacement::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Performance::StringReplacement::TR = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Performance::Sum < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def acc_plus_elem?(param0 = T.unsafe(nil), param1, param2); end
-  def elem_plus_acc?(param0 = T.unsafe(nil), param1, param2); end
-  def on_block(node); end
-  def on_send(node); end
-  def sum_candidate?(param0 = T.unsafe(nil)); end
-  def sum_map_candidate?(param0 = T.unsafe(nil)); end
-  def sum_with_block_candidate?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def array_literal?(node); end
-  def autocorrect(corrector, init, range); end
-  def autocorrect_sum_map(corrector, sum, map, init); end
-  def build_block_bad_method(method, init, var_acc, var_elem, body); end
-  def build_block_message(send, init, var_acc, var_elem, body); end
-  def build_good_method(init, block_pass = T.unsafe(nil)); end
-  def build_method_bad_method(init, method, operation); end
-  def build_method_message(node, method, init, operation); end
-  def build_sum_map_message(method, init); end
-  def empty_array_literal?(node); end
-  def handle_sum_candidate(node); end
-  def handle_sum_map_candidate(node); end
-  def method_call_with_args_range(node); end
-  def sum_block_range(send, node); end
-  def sum_map_range(map, sum); end
-  def sum_method_range(node); end
-end
-
-RuboCop::Cop::Performance::Sum::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::Sum::MSG_IF_NO_INIT_VALUE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::Sum::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::TimesMap < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def on_send(node); end
-  def times_map_call(param0 = T.unsafe(nil)); end
-
-  private
-
-  def check(node); end
-  def message(map_or_collect, count); end
-end
-
-RuboCop::Cop::Performance::TimesMap::MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::TimesMap::MESSAGE_ONLY_IF = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::TimesMap::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::UnfreezeString < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def dup_string?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def string_new?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def string_value(node); end
-end
-
-RuboCop::Cop::Performance::UnfreezeString::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::UnfreezeString::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Performance::UriDefaultParser < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def uri_parser_new?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Performance::UriDefaultParser::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Performance::UriDefaultParser::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-module RuboCop::Cop::RegexpMetacharacter
-  private
-
-  def drop_end_metacharacter(regexp_string); end
-  def drop_start_metacharacter(regexp_string); end
-  def literal_at_end?(regexp); end
-  def literal_at_end_with_backslash_z?(regex_str); end
-  def literal_at_end_with_dollar?(regex_str); end
-  def literal_at_start?(regexp); end
-  def literal_at_start_with_backslash_a?(regex_str); end
-  def literal_at_start_with_caret?(regex_str); end
-  def safe_multiline?; end
-end
-
-module RuboCop::Cop::SortBlock
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def replaceable_body?(param0 = T.unsafe(nil), param1, param2); end
-  def sort_with_block?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def sort_range(send, node); end
-end
-
-RuboCop::NodePattern = RuboCop::AST::NodePattern
-module RuboCop::Performance; end
-RuboCop::Performance::CONFIG = T.let(T.unsafe(nil), Hash)
-RuboCop::Performance::CONFIG_DEFAULT = T.let(T.unsafe(nil), Pathname)
-
-module RuboCop::Performance::Inject
-  class << self
-    def defaults!; end
-  end
-end
-
-RuboCop::Performance::PROJECT_ROOT = T.let(T.unsafe(nil), Pathname)
-
-module RuboCop::Performance::Version
-  class << self
-    def document_version; end
-  end
-end
-
-RuboCop::Performance::Version::STRING = T.let(T.unsafe(nil), String)
-RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource
-RuboCop::Token = RuboCop::AST::Token
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-rails@2.15.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-rails@2.15.2.rbi
deleted file mode 100644
index fe2e98a76f561..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rubocop-rails@2.15.2.rbi
+++ /dev/null
@@ -1,2210 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rubocop-rails` gem.
-# Please instead update this file by running `bin/tapioca gem rubocop-rails`.
-
-module RuboCop; end
-module RuboCop::Cop; end
-
-module RuboCop::Cop::ActiveRecordHelper
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def active_record?(param0 = T.unsafe(nil)); end
-  def external_dependency_checksum; end
-  def find_belongs_to(param0); end
-  def find_set_table_name(param0); end
-  def foreign_key_of(belongs_to); end
-  def in_where?(node); end
-  def inherit_active_record_base?(node); end
-  def polymorphic?(belongs_to); end
-  def resolve_relation_into_column(name:, class_node:, table:); end
-  def schema; end
-  def table_name(class_node); end
-end
-
-RuboCop::Cop::ActiveRecordHelper::WHERE_METHODS = T.let(T.unsafe(nil), Array)
-
-module RuboCop::Cop::ActiveRecordMigrationsHelper
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def create_table_with_block?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::ActiveRecordMigrationsHelper::MYSQL_SCHEMA_DEFINITIONS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::ActiveRecordMigrationsHelper::POSTGRES_SCHEMA_DEFINITIONS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::ActiveRecordMigrationsHelper::RAILS_ABSTRACT_SCHEMA_DEFINITIONS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::ActiveRecordMigrationsHelper::RAILS_ABSTRACT_SCHEMA_DEFINITIONS_HELPERS = T.let(T.unsafe(nil), Array)
-
-module RuboCop::Cop::ClassSendNodeHelper
-  def class_send_nodes(class_node); end
-end
-
-module RuboCop::Cop::EnforceSuperclass
-  def on_class(node); end
-  def on_send(node); end
-
-  private
-
-  def register_offense(offense_node); end
-
-  class << self
-    def included(base); end
-  end
-end
-
-RuboCop::Cop::IgnoredPattern = RuboCop::Cop::AllowedPattern
-
-module RuboCop::Cop::IndexMethod
-  def on_block(node); end
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def execute_correction(corrector, node, correction); end
-  def extract_captures(match); end
-  def handle_possible_offense(node, match, match_desc); end
-  def new_method_name; end
-  def on_bad_each_with_object(_node); end
-  def on_bad_hash_brackets_map(_node); end
-  def on_bad_map_to_h(_node); end
-  def on_bad_to_h(_node); end
-  def prepare_correction(node); end
-end
-
-class RuboCop::Cop::IndexMethod::Autocorrection < ::Struct
-  def block_node; end
-  def block_node=(_); end
-  def leading; end
-  def leading=(_); end
-  def match; end
-  def match=(_); end
-  def set_new_arg_name(transformed_argname, corrector); end
-  def set_new_body_expression(transforming_body_expr, corrector); end
-  def set_new_method_name(new_method_name, corrector); end
-  def strip_prefix_and_suffix(node, corrector); end
-  def trailing; end
-  def trailing=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def from_each_with_object(node, match); end
-    def from_hash_brackets_map(node, match); end
-    def from_map_to_h(node, match); end
-    def from_to_h(node, match); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RuboCop::Cop::IndexMethod::Captures < ::Struct
-  def noop_transformation?; end
-  def transformed_argname; end
-  def transformed_argname=(_); end
-  def transforming_body_expr; end
-  def transforming_body_expr=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-RuboCop::Cop::IndexMethod::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-module RuboCop::Cop::MigrationsHelper
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def in_migration?(node); end
-  def migration_class?(param0 = T.unsafe(nil)); end
-end
-
-module RuboCop::Cop::Rails; end
-
-class RuboCop::Cop::Rails::ActionControllerTestCase < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def action_controller_test_case?(param0 = T.unsafe(nil)); end
-  def on_class(node); end
-end
-
-RuboCop::Cop::Rails::ActionControllerTestCase::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::ActionFilter < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def on_send(node); end
-
-  private
-
-  def bad_methods; end
-  def check_method_node(node); end
-  def good_methods; end
-  def preferred_method(method); end
-end
-
-RuboCop::Cop::Rails::ActionFilter::ACTION_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::ActionFilter::FILTER_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::ActionFilter::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ActionFilter::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::ActiveRecordAliases < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Rails::ActiveRecordAliases::ALIASES = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Rails::ActiveRecordAliases::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ActiveRecordAliases::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::ActiveRecordCallbacksOrder < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_class(class_node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def begin_pos_with_comment(node); end
-  def buffer; end
-  def callback?(node); end
-  def defined_callbacks(class_node); end
-  def end_position_for(node); end
-  def inline_comment?(comment); end
-  def source_range_with_comment(node); end
-  def start_line_position(node); end
-end
-
-RuboCop::Cop::Rails::ActiveRecordCallbacksOrder::CALLBACKS_IN_ORDER = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::ActiveRecordCallbacksOrder::CALLBACKS_ORDER_MAP = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Rails::ActiveRecordCallbacksOrder::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::ActiveRecordOverride < ::RuboCop::Cop::Base
-  def on_def(node); end
-
-  private
-
-  def active_model?(parent_class_name); end
-  def callback_names(method_name); end
-  def find_parent_class_name(node); end
-  def message(method_name); end
-end
-
-RuboCop::Cop::Rails::ActiveRecordOverride::ACTIVE_RECORD_CLASSES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::ActiveRecordOverride::BAD_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::ActiveRecordOverride::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::ActiveSupportAliases < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def append(param0 = T.unsafe(nil)); end
-  def ends_with?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def prepend(param0 = T.unsafe(nil)); end
-  def starts_with?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Rails::ActiveSupportAliases::ALIASES = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Rails::ActiveSupportAliases::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ActiveSupportAliases::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::AddColumnIndex < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def add_column_with_index(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def index_range(pair_node); end
-end
-
-RuboCop::Cop::Rails::AddColumnIndex::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::AddColumnIndex::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::AfterCommitOverride < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ClassSendNodeHelper
-
-  def on_class(class_node); end
-
-  private
-
-  def after_commit_callback?(node); end
-  def each_after_commit_callback(class_node); end
-  def named_callback?(node); end
-end
-
-RuboCop::Cop::Rails::AfterCommitOverride::AFTER_COMMIT_CALLBACKS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::AfterCommitOverride::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::ApplicationController < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::EnforceSuperclass
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def class_definition(param0 = T.unsafe(nil)); end
-  def class_new_definition(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Rails::ApplicationController::BASE_PATTERN = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ApplicationController::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ApplicationController::SUPERCLASS = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::ApplicationJob < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::EnforceSuperclass
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def autocorrect(node); end
-  def class_definition(param0 = T.unsafe(nil)); end
-  def class_new_definition(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Rails::ApplicationJob::BASE_PATTERN = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ApplicationJob::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ApplicationJob::SUPERCLASS = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::ApplicationMailer < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::EnforceSuperclass
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def class_definition(param0 = T.unsafe(nil)); end
-  def class_new_definition(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Rails::ApplicationMailer::BASE_PATTERN = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ApplicationMailer::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ApplicationMailer::SUPERCLASS = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::ApplicationRecord < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::EnforceSuperclass
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def class_definition(param0 = T.unsafe(nil)); end
-  def class_new_definition(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Rails::ApplicationRecord::BASE_PATTERN = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ApplicationRecord::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ApplicationRecord::SUPERCLASS = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::ArelStar < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def star_bracket?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Rails::ArelStar::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ArelStar::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::AssertNot < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def offensive?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def corrected_source(source); end
-end
-
-RuboCop::Cop::Rails::AssertNot::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::AssertNot::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::AttributeDefaultBlockValue < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def attribute(param0 = T.unsafe(nil)); end
-  def default_attribute(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Rails::AttributeDefaultBlockValue::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::AttributeDefaultBlockValue::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::AttributeDefaultBlockValue::TYPE_OFFENDERS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::BelongsTo < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def match_belongs_to_with_options(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Rails::BelongsTo::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::BelongsTo::SUPERFLOUS_REQUIRE_FALSE_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::BelongsTo::SUPERFLOUS_REQUIRE_TRUE_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::Blank < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def defining_blank?(param0 = T.unsafe(nil)); end
-  def nil_or_empty?(param0 = T.unsafe(nil)); end
-  def not_present?(param0 = T.unsafe(nil)); end
-  def on_if(node); end
-  def on_or(node); end
-  def on_send(node); end
-  def unless_present?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def replacement(node); end
-  def unless_condition(node, method_call); end
-end
-
-RuboCop::Cop::Rails::Blank::MSG_NIL_OR_EMPTY = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::Blank::MSG_NOT_PRESENT = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::Blank::MSG_UNLESS_PRESENT = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::Blank::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::BulkChangeTable < ::RuboCop::Cop::Base
-  def on_def(node); end
-  def on_send(node); end
-
-  private
-
-  def add_offense_for_alter_methods(node); end
-  def add_offense_for_change_table(node); end
-  def call_to_combinable_alter_method?(child_node); end
-  def combinable_alter_methods; end
-  def combinable_transformations; end
-  def count_transformations(send_nodes); end
-  def database; end
-  def database_from_yaml; end
-  def database_yaml; end
-  def include_bulk_options?(node); end
-  def send_nodes_from_change_table_block(body); end
-  def support_bulk_alter?; end
-end
-
-class RuboCop::Cop::Rails::BulkChangeTable::AlterMethodsRecorder
-  def initialize; end
-
-  def flush; end
-  def offensive_nodes; end
-  def process(new_node); end
-end
-
-RuboCop::Cop::Rails::BulkChangeTable::COMBINABLE_ALTER_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::BulkChangeTable::COMBINABLE_TRANSFORMATIONS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::BulkChangeTable::MIGRATION_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::BulkChangeTable::MSG_FOR_ALTER_METHODS = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::BulkChangeTable::MSG_FOR_CHANGE_TABLE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::BulkChangeTable::MYSQL = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::BulkChangeTable::MYSQL_COMBINABLE_ALTER_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::BulkChangeTable::MYSQL_COMBINABLE_TRANSFORMATIONS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::BulkChangeTable::POSTGRESQL = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::BulkChangeTable::POSTGRESQL_COMBINABLE_ALTER_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::BulkChangeTable::POSTGRESQL_COMBINABLE_TRANSFORMATIONS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::CompactBlank < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def on_send(node); end
-  def reject_with_block?(param0 = T.unsafe(nil)); end
-  def reject_with_block_pass?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def bad_method?(node); end
-  def offense_range(node); end
-  def preferred_method(node); end
-  def use_hash_value_block_argument?(arguments, receiver_in_block); end
-  def use_single_value_block_argument?(arguments, receiver_in_block); end
-end
-
-RuboCop::Cop::Rails::CompactBlank::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::CompactBlank::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::ContentTag < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def on_new_investigation; end
-  def on_send(node); end
-
-  private
-
-  def allowed_argument?(argument); end
-  def allowed_name?(argument); end
-  def autocorrect(corrector, node, preferred_method); end
-  def corrected_ancestor?(node); end
-  def correction_range(node); end
-  def register_offense(node, message, preferred_method); end
-end
-
-RuboCop::Cop::Rails::ContentTag::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ContentTag::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::CreateTableWithTimestamps < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ActiveRecordMigrationsHelper
-
-  def create_table_with_timestamps_proc?(param0 = T.unsafe(nil)); end
-  def created_at_or_updated_at_included?(param0); end
-  def on_send(node); end
-  def timestamps_included?(param0); end
-
-  private
-
-  def time_columns_included?(node); end
-end
-
-RuboCop::Cop::Rails::CreateTableWithTimestamps::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::CreateTableWithTimestamps::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::Date < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-
-  def on_const(node); end
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def allow_to_time?; end
-  def bad_days; end
-  def bad_methods; end
-  def check_date_node(node); end
-  def check_deprecated_methods(node); end
-  def extract_method_chain(node); end
-  def good_days; end
-  def good_methods; end
-  def method_send?(node); end
-  def safe_chain?(node); end
-  def safe_to_time?(node); end
-end
-
-RuboCop::Cop::Rails::Date::BAD_DAYS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::Date::DEPRECATED_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::Date::DEPRECATED_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::Date::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::Date::MSG_SEND = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::Date::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::DefaultScope < ::RuboCop::Cop::Base
-  def class_method_definition?(param0 = T.unsafe(nil)); end
-  def eigenclass_method_definition?(param0 = T.unsafe(nil)); end
-  def method_call?(param0 = T.unsafe(nil)); end
-  def on_defs(node); end
-  def on_sclass(node); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Rails::DefaultScope::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::DefaultScope::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::Delegate < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::VisibilityHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def delegate?(param0 = T.unsafe(nil)); end
-  def on_def(node); end
-
-  private
-
-  def arguments_match?(arg_array, body); end
-  def include_prefix_case?; end
-  def method_name_matches?(method_name, body); end
-  def prefixed_method_name(body); end
-  def private_or_protected_delegation(node); end
-  def private_or_protected_inline(node); end
-  def register_offense(node); end
-  def trivial_delegate?(def_node); end
-end
-
-RuboCop::Cop::Rails::Delegate::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::DelegateAllowBlank < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def allow_blank_option(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Rails::DelegateAllowBlank::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::DelegateAllowBlank::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::DeprecatedActiveModelErrorsMethods < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def any_manipulation?(param0 = T.unsafe(nil)); end
-  def errors_keys?(param0 = T.unsafe(nil)); end
-  def messages_details_assignment?(param0 = T.unsafe(nil)); end
-  def messages_details_manipulation?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def receiver_matcher_inside_model(param0 = T.unsafe(nil)); end
-  def receiver_matcher_outside_model(param0 = T.unsafe(nil)); end
-  def root_assignment?(param0 = T.unsafe(nil)); end
-  def root_manipulation?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def model_file?; end
-  def offense_range(node, receiver); end
-  def receiver_matcher(node); end
-  def replacement(node, receiver); end
-end
-
-RuboCop::Cop::Rails::DeprecatedActiveModelErrorsMethods::AUTOCORECTABLE_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::DeprecatedActiveModelErrorsMethods::MANIPULATIVE_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Rails::DeprecatedActiveModelErrorsMethods::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::DotSeparatedKeys < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def translate_with_scope?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def new_key(key_node, scope_node); end
-  def scopes(scope_node); end
-  def should_convert_scope?(scope_node); end
-end
-
-RuboCop::Cop::Rails::DotSeparatedKeys::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::DotSeparatedKeys::TRANSLATE_METHODS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::DuplicateAssociation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::ClassSendNodeHelper
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def association(param0 = T.unsafe(nil)); end
-  def on_class(class_node); end
-
-  private
-
-  def offenses(class_node); end
-end
-
-RuboCop::Cop::Rails::DuplicateAssociation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::DuplicateScope < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ClassSendNodeHelper
-
-  def on_class(class_node); end
-  def scope(param0 = T.unsafe(nil)); end
-
-  private
-
-  def offenses(class_node); end
-end
-
-RuboCop::Cop::Rails::DuplicateScope::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::DurationArithmetic < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def duration?(param0 = T.unsafe(nil)); end
-  def duration_arithmetic_argument?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def time_current?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def corrected_source(operator, duration); end
-end
-
-RuboCop::Cop::Rails::DurationArithmetic::DURATIONS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Rails::DurationArithmetic::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::DurationArithmetic::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::DynamicFindBy < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ActiveRecordHelper
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def allowed_invocation?(node); end
-  def allowed_method?(node); end
-  def allowed_receiver?(node); end
-  def autocorrect(corrector, node); end
-  def autocorrect_argument_keywords(corrector, node, keywords); end
-  def autocorrect_method_name(corrector, node); end
-  def column_keywords(method); end
-  def static_method_name(method_name); end
-  def whitelisted?(node); end
-end
-
-RuboCop::Cop::Rails::DynamicFindBy::IGNORED_ARGUMENT_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::DynamicFindBy::METHOD_PATTERN = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Rails::DynamicFindBy::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::EagerEvaluationLogMessage < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def interpolated_string_passed_to_debug(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def replacement_range(node); end
-  def replacement_source(node, arguments); end
-end
-
-RuboCop::Cop::Rails::EagerEvaluationLogMessage::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::EagerEvaluationLogMessage::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::EnumHash < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def array_pair?(param0 = T.unsafe(nil)); end
-  def enum?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def enum_name(key); end
-  def source(elem); end
-end
-
-RuboCop::Cop::Rails::EnumHash::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::EnumHash::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::EnumUniqueness < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Duplication
-
-  def enum?(param0 = T.unsafe(nil)); end
-  def enum_values(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def enum_name(key); end
-end
-
-RuboCop::Cop::Rails::EnumUniqueness::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::EnumUniqueness::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::EnvironmentComparison < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def comparing_str_env_with_rails_env_on_lhs?(param0 = T.unsafe(nil)); end
-  def comparing_str_env_with_rails_env_on_rhs?(param0 = T.unsafe(nil)); end
-  def comparing_sym_env_with_rails_env_on_lhs?(param0 = T.unsafe(nil)); end
-  def comparing_sym_env_with_rails_env_on_rhs?(param0 = T.unsafe(nil)); end
-  def content(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def build_predicate_method(node); end
-  def build_predicate_method_for_rails_env_on_lhs(node); end
-  def build_predicate_method_for_rails_env_on_rhs(node); end
-  def rails_env_on_lhs?(node); end
-end
-
-RuboCop::Cop::Rails::EnvironmentComparison::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::EnvironmentComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::EnvironmentComparison::SYM_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::EnvironmentVariableAccess < ::RuboCop::Cop::Base
-  def env_read?(param0); end
-  def env_write?(param0); end
-  def on_const(node); end
-
-  private
-
-  def allow_reads?; end
-  def allow_writes?; end
-end
-
-RuboCop::Cop::Rails::EnvironmentVariableAccess::READ_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::EnvironmentVariableAccess::WRITE_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::Exit < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-
-  def on_send(node); end
-
-  private
-
-  def offending_node?(node); end
-  def right_argument_count?(arg_nodes); end
-  def right_receiver?(receiver_node); end
-end
-
-RuboCop::Cop::Rails::Exit::EXPLICIT_RECEIVERS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::Exit::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::Exit::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::ExpandedDateRange < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def on_irange(node); end
-
-  private
-
-  def allow?(begin_node, end_node); end
-  def any_arguments?(begin_node, end_node); end
-  def preferred_method(begin_node); end
-  def receiver_source(node); end
-  def register_offense(node, preferred_method); end
-  def same_argument?(begin_node, end_node); end
-end
-
-RuboCop::Cop::Rails::ExpandedDateRange::MAPPED_DATE_RANGE_METHODS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Rails::ExpandedDateRange::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ExpandedDateRange::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Cop::Rails::FilePath < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-
-  def file_join_nodes?(param0 = T.unsafe(nil)); end
-  def on_dstr(node); end
-  def on_send(node); end
-  def rails_root_join_nodes?(param0 = T.unsafe(nil)); end
-  def rails_root_nodes?(param0); end
-
-  private
-
-  def check_for_file_join_with_rails_root(node); end
-  def check_for_rails_root_join_with_slash_separated_path(node); end
-  def check_for_rails_root_join_with_string_arguments(node); end
-  def message(_range); end
-  def register_offense(node); end
-  def string_with_slash?(node); end
-end
-
-RuboCop::Cop::Rails::FilePath::MSG_ARGUMENTS = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::FilePath::MSG_SLASHES = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::FilePath::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::FindBy < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def ignore_where_first?; end
-  def offense_range(node); end
-  def where_method?(receiver); end
-end
-
-RuboCop::Cop::Rails::FindBy::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::FindBy::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::FindById < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def find_by?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def where_take?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def build_find_by_bad_method(node, id_value); end
-  def build_good_method(id_value); end
-  def build_where_take_bad_method(id_value); end
-  def find_by_offense_range(node); end
-  def register_offense(range, id_value, bad_method); end
-  def where_take_offense_range(node, where); end
-end
-
-RuboCop::Cop::Rails::FindById::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::FindById::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::FindEach < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ActiveRecordHelper
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def active_model_error?(node); end
-  def active_model_error_where?(node); end
-  def ignored?(node); end
-end
-
-RuboCop::Cop::Rails::FindEach::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::FindEach::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::FindEach::SCOPE_METHODS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::HasAndBelongsToMany < ::RuboCop::Cop::Base
-  def on_send(node); end
-end
-
-RuboCop::Cop::Rails::HasAndBelongsToMany::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::HasAndBelongsToMany::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::HasManyOrHasOneDependent < ::RuboCop::Cop::Base
-  def active_resource_class?(param0); end
-  def association_extension_block?(param0 = T.unsafe(nil)); end
-  def association_with_options?(param0 = T.unsafe(nil)); end
-  def association_without_options?(param0 = T.unsafe(nil)); end
-  def dependent_option?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def present_option?(param0 = T.unsafe(nil)); end
-  def readonly?(param0 = T.unsafe(nil)); end
-  def with_options_block(param0 = T.unsafe(nil)); end
-
-  private
-
-  def active_resource?(node); end
-  def contain_valid_options_in_with_options_block?(node); end
-  def extract_option_if_kwsplat(options); end
-  def readonly_model?(node); end
-  def valid_options?(options); end
-  def valid_options_in_with_options_block?(node); end
-end
-
-RuboCop::Cop::Rails::HasManyOrHasOneDependent::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::HasManyOrHasOneDependent::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::HelperInstanceVariable < ::RuboCop::Cop::Base
-  def form_builder_class?(param0 = T.unsafe(nil)); end
-  def on_ivar(node); end
-  def on_ivasgn(node); end
-
-  private
-
-  def inherit_form_builder?(node); end
-end
-
-RuboCop::Cop::Rails::HelperInstanceVariable::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::HttpPositionalArguments < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def http_request?(param0 = T.unsafe(nil)); end
-  def kwsplat_hash?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def convert_hash_data(data, type); end
-  def correction(node); end
-  def correction_template(node); end
-  def format_arg?(node); end
-  def highlight_range(node); end
-  def in_routing_block?(node); end
-  def needs_conversion?(data); end
-  def special_keyword_arg?(node); end
-end
-
-RuboCop::Cop::Rails::HttpPositionalArguments::KEYWORD_ARGS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::HttpPositionalArguments::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::HttpPositionalArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::HttpPositionalArguments::ROUTING_METHODS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::HttpStatus < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def http_status(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def status_code(param0 = T.unsafe(nil)); end
-
-  private
-
-  def checker_class; end
-end
-
-class RuboCop::Cop::Rails::HttpStatus::NumericStyleChecker
-  def initialize(node); end
-
-  def message; end
-  def node; end
-  def offensive?; end
-  def preferred_style; end
-
-  private
-
-  def number; end
-  def permitted_symbol?; end
-  def symbol; end
-end
-
-RuboCop::Cop::Rails::HttpStatus::NumericStyleChecker::DEFAULT_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::HttpStatus::NumericStyleChecker::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::HttpStatus::NumericStyleChecker::PERMITTED_STATUS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::HttpStatus::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::HttpStatus::SymbolicStyleChecker
-  def initialize(node); end
-
-  def message; end
-  def node; end
-  def offensive?; end
-  def preferred_style; end
-
-  private
-
-  def custom_http_status_code?; end
-  def number; end
-  def symbol; end
-end
-
-RuboCop::Cop::Rails::HttpStatus::SymbolicStyleChecker::DEFAULT_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::HttpStatus::SymbolicStyleChecker::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::I18nLazyLookup < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::VisibilityHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def translate_call?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def controller_and_action(node); end
-  def controller_path(controller); end
-  def get_scoped_key(key_node, controller, action); end
-end
-
-RuboCop::Cop::Rails::I18nLazyLookup::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::I18nLocaleAssignment < ::RuboCop::Cop::Base
-  def i18n_locale_assignment?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Rails::I18nLocaleAssignment::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::I18nLocaleAssignment::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::I18nLocaleTexts < ::RuboCop::Cop::Base
-  def flash_assignment?(param0 = T.unsafe(nil)); end
-  def mail_subject(param0); end
-  def on_send(node); end
-  def redirect_to_flash(param0); end
-  def validation_message(param0); end
-end
-
-RuboCop::Cop::Rails::I18nLocaleTexts::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::I18nLocaleTexts::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::IgnoredSkipActionFilterOption < ::RuboCop::Cop::Base
-  def filter_options(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def if_and_except?(options); end
-  def if_and_only?(options); end
-  def options_hash(options); end
-end
-
-RuboCop::Cop::Rails::IgnoredSkipActionFilterOption::FILTERS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::IgnoredSkipActionFilterOption::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::IgnoredSkipActionFilterOption::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::IndexBy < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::IndexMethod
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_bad_each_with_object(param0 = T.unsafe(nil)); end
-  def on_bad_hash_brackets_map(param0 = T.unsafe(nil)); end
-  def on_bad_map_to_h(param0 = T.unsafe(nil)); end
-  def on_bad_to_h(param0 = T.unsafe(nil)); end
-
-  private
-
-  def new_method_name; end
-end
-
-class RuboCop::Cop::Rails::IndexWith < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::IndexMethod
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def on_bad_each_with_object(param0 = T.unsafe(nil)); end
-  def on_bad_hash_brackets_map(param0 = T.unsafe(nil)); end
-  def on_bad_map_to_h(param0 = T.unsafe(nil)); end
-  def on_bad_to_h(param0 = T.unsafe(nil)); end
-
-  private
-
-  def new_method_name; end
-end
-
-class RuboCop::Cop::Rails::Inquiry < ::RuboCop::Cop::Base
-  def on_send(node); end
-end
-
-RuboCop::Cop::Rails::Inquiry::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::Inquiry::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::InverseOf < ::RuboCop::Cop::Base
-  def as_option?(param0 = T.unsafe(nil)); end
-  def association_recv_arguments(param0 = T.unsafe(nil)); end
-  def conditions_option?(param0 = T.unsafe(nil)); end
-  def foreign_key_option?(param0 = T.unsafe(nil)); end
-  def inverse_of_nil_option?(param0 = T.unsafe(nil)); end
-  def inverse_of_option?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def options_contain_inverse_of?(options); end
-  def options_from_argument(param0 = T.unsafe(nil)); end
-  def options_ignoring_inverse_of?(options); end
-  def options_requiring_inverse_of?(options); end
-  def polymorphic_option?(param0 = T.unsafe(nil)); end
-  def same_context_in_with_options?(arg, recv); end
-  def scope?(arguments); end
-  def through_option?(param0 = T.unsafe(nil)); end
-  def with_options_arguments(recv, node); end
-
-  private
-
-  def ignore_scopes?; end
-  def message(options); end
-end
-
-RuboCop::Cop::Rails::InverseOf::NIL_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::InverseOf::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::InverseOf::SPECIFY_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::LexicallyScopedActionFilter < ::RuboCop::Cop::Base
-  def on_send(node); end
-  def only_or_except_filter_methods(param0 = T.unsafe(nil)); end
-
-  private
-
-  def aliased_action_methods(node, defined_methods); end
-  def array_values(node); end
-  def defined_action_methods(block); end
-  def message(methods, parent); end
-end
-
-RuboCop::Cop::Rails::LexicallyScopedActionFilter::FILTERS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::LexicallyScopedActionFilter::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::LexicallyScopedActionFilter::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::LinkToBlank < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def blank_target?(param0 = T.unsafe(nil)); end
-  def includes_noopener?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def rel_node?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def add_rel(send_node, offense_node, corrector); end
-  def append_to_rel(rel_node, corrector); end
-  def autocorrect(corrector, send_node, node, option_nodes); end
-  def contains_noopener?(value); end
-end
-
-RuboCop::Cop::Rails::LinkToBlank::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::LinkToBlank::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::MailerName < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def class_definition?(param0 = T.unsafe(nil)); end
-  def class_new_definition?(param0 = T.unsafe(nil)); end
-  def mailer_base_class?(param0 = T.unsafe(nil)); end
-  def on_class(node); end
-  def on_send(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def mailer_suffix?(mailer_name); end
-end
-
-RuboCop::Cop::Rails::MailerName::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::MatchRoute < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def match_method_call?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def routes_draw?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def extract_via(node); end
-  def http_method?(method); end
-  def http_method_and_options(node); end
-  def register_offense(node, http_method); end
-  def replacement(path_node, options_node); end
-  def via_pair(node); end
-  def within_routes?(node); end
-end
-
-RuboCop::Cop::Rails::MatchRoute::HTTP_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::MatchRoute::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::MatchRoute::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::MigrationClassName < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::MigrationsHelper
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_class(node); end
-
-  private
-
-  def basename_without_timestamp_and_suffix(filepath); end
-  def camelize(word); end
-  def remove_gem_suffix(file_name); end
-end
-
-RuboCop::Cop::Rails::MigrationClassName::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::NegateInclude < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def negate_include_call?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Rails::NegateInclude::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::NegateInclude::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::NotNullColumn < ::RuboCop::Cop::Base
-  def add_not_null_column?(param0 = T.unsafe(nil)); end
-  def add_not_null_reference?(param0 = T.unsafe(nil)); end
-  def default_option?(param0 = T.unsafe(nil)); end
-  def null_false?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def check_add_column(node); end
-  def check_add_reference(node); end
-  def check_pairs(pairs); end
-end
-
-RuboCop::Cop::Rails::NotNullColumn::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::NotNullColumn::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::OrderById < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_send(node); end
-  def order_by_id?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def offense_range(node); end
-end
-
-RuboCop::Cop::Rails::OrderById::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::OrderById::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::Output < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def io_output?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def output?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def match_gvar?(sym); end
-  def offense_range(node); end
-end
-
-RuboCop::Cop::Rails::Output::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::Output::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::OutputSafety < ::RuboCop::Cop::Base
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def looks_like_rails_html_safe?(node); end
-  def looks_like_rails_raw?(node); end
-  def looks_like_rails_safe_concat?(node); end
-  def non_interpolated_string?(node); end
-end
-
-RuboCop::Cop::Rails::OutputSafety::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::OutputSafety::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::Pick < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def on_send(node); end
-  def pick_candidate?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def message(receiver); end
-end
-
-RuboCop::Cop::Rails::Pick::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::Pick::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::Pluck < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def on_block(node); end
-  def on_numblock(node); end
-  def pluck_candidate?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def message(value, node); end
-  def offense_range(node); end
-end
-
-RuboCop::Cop::Rails::Pluck::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::PluckId < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::ActiveRecordHelper
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def pluck_id_call?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def offense_range(node); end
-end
-
-RuboCop::Cop::Rails::PluckId::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::PluckId::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::PluckInWhere < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ActiveRecordHelper
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def root_receiver(node); end
-end
-
-RuboCop::Cop::Rails::PluckInWhere::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::PluckInWhere::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::PluralizationGrammar < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def correct_method(method_name); end
-  def duration_method?(method_name); end
-  def literal_number?(node); end
-  def message(number, method_name); end
-  def offense?(node); end
-  def plural_method?(method_name); end
-  def plural_receiver?(number); end
-  def pluralize(method_name); end
-  def singular_method?(method_name); end
-  def singular_receiver?(number); end
-  def singularize(method_name); end
-end
-
-RuboCop::Cop::Rails::PluralizationGrammar::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::PluralizationGrammar::PLURAL_DURATION_METHODS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Rails::PluralizationGrammar::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::PluralizationGrammar::SINGULAR_DURATION_METHODS = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Cop::Rails::Presence < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-  def redundant_negative_receiver_and_other(param0 = T.unsafe(nil)); end
-  def redundant_receiver_and_other(param0 = T.unsafe(nil)); end
-
-  private
-
-  def build_source_for_or_method(other); end
-  def ignore_if_node?(node); end
-  def ignore_other_node?(node); end
-  def message(node, receiver, other); end
-  def register_offense(node, receiver, other); end
-  def replacement(receiver, other); end
-end
-
-RuboCop::Cop::Rails::Presence::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::Present < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def autocorrect(corrector, node); end
-  def exists_and_not_empty?(param0 = T.unsafe(nil)); end
-  def not_blank?(param0 = T.unsafe(nil)); end
-  def on_and(node); end
-  def on_if(node); end
-  def on_or(node); end
-  def on_send(node); end
-  def unless_blank?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def replacement(node); end
-  def unless_condition(node, method_call); end
-end
-
-RuboCop::Cop::Rails::Present::MSG_EXISTS_AND_NOT_EMPTY = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::Present::MSG_NOT_BLANK = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::Present::MSG_UNLESS_BLANK = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::Present::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::RakeEnvironment < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def task_definition?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def correct_task_dependency(task_name); end
-  def task_name(node); end
-  def with_dependencies?(node); end
-  def with_hash_style_dependencies?(hash_node); end
-end
-
-RuboCop::Cop::Rails::RakeEnvironment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::ReadWriteAttribute < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def read_write_attribute?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def build_message(node); end
-  def multi_line_message(node); end
-  def node_replacement(node); end
-  def read_attribute_replacement(node); end
-  def single_line_message(node); end
-  def within_shadowing_method?(node); end
-  def write_attribute_replacement(node); end
-end
-
-RuboCop::Cop::Rails::ReadWriteAttribute::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ReadWriteAttribute::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::RedundantAllowNil < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def find_allow_nil_and_allow_blank(node); end
-  def node_beg(node); end
-  def node_end(node); end
-  def register_offense(allow_nil, message); end
-end
-
-RuboCop::Cop::Rails::RedundantAllowNil::MSG_ALLOW_NIL_FALSE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::RedundantAllowNil::MSG_SAME = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::RedundantAllowNil::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::RedundantForeignKey < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def association_with_foreign_key(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def default_foreign_key(node, association_type, association_name, options); end
-  def find_as_option(options); end
-  def redundant?(node, association_type, association_name, options, foreign_key); end
-end
-
-RuboCop::Cop::Rails::RedundantForeignKey::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::RedundantForeignKey::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::RedundantPresenceValidationOnBelongsTo < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def any_belongs_to?(param0 = T.unsafe(nil), association:); end
-  def belongs_to?(param0 = T.unsafe(nil), key:, fk:); end
-  def belongs_to_with_a_matching_fk?(param0 = T.unsafe(nil), param1); end
-  def belongs_to_without_fk?(param0 = T.unsafe(nil), param1); end
-  def on_send(node); end
-  def optional?(param0 = T.unsafe(nil)); end
-  def optional_option?(param0 = T.unsafe(nil)); end
-  def presence_validation?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def add_offense_and_correct(node, all_keys, keys, options, presence); end
-  def belongs_to_for(model_class_node, key); end
-  def extract_validation_for_keys(corrector, node, keys, options); end
-  def message_for(keys); end
-  def non_optional_belongs_to(node, keys); end
-  def remove_keys_from_validation(corrector, node, keys); end
-  def remove_presence_option(corrector, presence); end
-  def remove_validation(corrector, node); end
-  def validation_range(node); end
-end
-
-RuboCop::Cop::Rails::RedundantPresenceValidationOnBelongsTo::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::RedundantPresenceValidationOnBelongsTo::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::RedundantReceiverInWithOptions < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def all_block_nodes_in(param0); end
-  def all_send_nodes_in(param0); end
-  def on_block(node); end
-  def with_options?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def block_argument_range(node); end
-  def same_value?(arg_node, recv_node); end
-  def search_begin_pos_of_space_before_block_argument(begin_pos); end
-end
-
-RuboCop::Cop::Rails::RedundantReceiverInWithOptions::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::RedundantTravelBack < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def on_send(node); end
-end
-
-RuboCop::Cop::Rails::RedundantTravelBack::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::RedundantTravelBack::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::ReflectionClassName < ::RuboCop::Cop::Base
-  def association_with_reflection(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def reflection_class_name(param0 = T.unsafe(nil)); end
-
-  private
-
-  def reflection_class_value?(class_value); end
-end
-
-RuboCop::Cop::Rails::ReflectionClassName::ALLOWED_REFLECTION_CLASS_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::ReflectionClassName::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ReflectionClassName::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::RefuteMethods < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def offensive?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def bad_method?(method_name); end
-  def convert_good_method(bad_method); end
-  def offense_message(method_name); end
-end
-
-RuboCop::Cop::Rails::RefuteMethods::ASSERT_NOT_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::RefuteMethods::CORRECTIONS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Rails::RefuteMethods::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::RefuteMethods::REFUTE_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::RefuteMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::RelativeDateConstant < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_casgn(node); end
-  def on_masgn(node); end
-  def on_or_asgn(node); end
-  def relative_date(param0 = T.unsafe(nil)); end
-  def relative_date_or_assignment(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def message(method_name); end
-  def nested_relative_date(node, &callback); end
-  def offense_range(name, value); end
-end
-
-RuboCop::Cop::Rails::RelativeDateConstant::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::RelativeDateConstant::RELATIVE_DATE_METHODS = T.let(T.unsafe(nil), Set)
-
-class RuboCop::Cop::Rails::RenderInline < ::RuboCop::Cop::Base
-  def on_send(node); end
-  def render_with_inline_option?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Rails::RenderInline::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::RenderInline::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::RenderPlainText < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def render_plain_text?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def compatible_content_type?(node); end
-  def find_content_type(node); end
-  def replacement(rest_options, option_value); end
-end
-
-RuboCop::Cop::Rails::RenderPlainText::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::RenderPlainText::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::RequestReferer < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def referer?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def message(_range); end
-  def wrong_method_name; end
-end
-
-RuboCop::Cop::Rails::RequestReferer::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::RequestReferer::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::RequireDependency < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def on_send(node); end
-  def require_dependency_call?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Rails::RequireDependency::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::RequireDependency::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::ReversibleMigration < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::MigrationsHelper
-
-  def change_table_call(param0 = T.unsafe(nil)); end
-  def drop_table_call(param0 = T.unsafe(nil)); end
-  def irreversible_schema_statement_call(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def on_send(node); end
-  def remove_column_call(param0 = T.unsafe(nil)); end
-  def remove_columns_call(param0 = T.unsafe(nil)); end
-  def remove_foreign_key_call(param0 = T.unsafe(nil)); end
-  def remove_index_call(param0 = T.unsafe(nil)); end
-
-  private
-
-  def all_hash_key?(args, *keys); end
-  def check_change_table_node(node, block); end
-  def check_change_table_offense(receiver, node); end
-  def check_drop_table_node(node); end
-  def check_irreversible_schema_statement_node(node); end
-  def check_remove_column_node(node); end
-  def check_remove_columns_node(node); end
-  def check_remove_foreign_key_node(node); end
-  def check_remove_index_node(node); end
-  def check_reversible_hash_node(node); end
-  def reversible_change_table_call?(node); end
-  def within_change_method?(node); end
-  def within_reversible_or_up_only_block?(node); end
-end
-
-RuboCop::Cop::Rails::ReversibleMigration::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::ReversibleMigrationMethodDefinition < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::MigrationsHelper
-
-  def change_method?(param0 = T.unsafe(nil)); end
-  def on_class(node); end
-  def up_and_down_methods?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Rails::ReversibleMigrationMethodDefinition::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::RootJoinChain < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def join?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def rails_root?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def evidence(node); end
-end
-
-RuboCop::Cop::Rails::RootJoinChain::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::RootJoinChain::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
-
-class RuboCop::Cop::Rails::RootPublicPath < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def rails_root_public(param0 = T.unsafe(nil)); end
-
-  private
-
-  def public_path?(string); end
-end
-
-RuboCop::Cop::Rails::RootPublicPath::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::RootPublicPath::PATTERN = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Rails::RootPublicPath::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
-
-class RuboCop::Cop::Rails::SafeNavigation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_send(node); end
-  def try_call(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def replacement(method, params); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Rails::SafeNavigation::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::SafeNavigation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::SafeNavigationWithBlank < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-  def safe_navigation_blank_in_conditional?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Rails::SafeNavigationWithBlank::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::SaveBang < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::NegativeConditional
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def after_leaving_scope(scope, _variable_table); end
-  def check_assignment(assignment); end
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def allowed_receiver?(node); end
-  def argument?(node); end
-  def array_parent(node); end
-  def assignable_node(node); end
-  def call_to_persisted?(node); end
-  def check_used_in_condition_or_compound_boolean(node); end
-  def checked_immediately?(node); end
-  def conditional?(parent); end
-  def const_matches?(const, allowed_const); end
-  def expected_signature?(node); end
-  def explicit_return?(node); end
-  def find_method_with_sibling_index(node, sibling_index = T.unsafe(nil)); end
-  def hash_parent(node); end
-  def implicit_return?(node); end
-  def in_condition_or_compound_boolean?(node); end
-  def operator_or_single_negative?(node); end
-  def persist_method?(node, methods = T.unsafe(nil)); end
-  def persisted_referenced?(assignment); end
-  def receiver_chain_matches?(node, allowed_receiver); end
-  def register_offense(node, msg); end
-  def return_value_assigned?(node); end
-  def right_assignment_node(assignment); end
-
-  class << self
-    def joining_forces; end
-  end
-end
-
-RuboCop::Cop::Rails::SaveBang::CREATE_CONDITIONAL_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::SaveBang::CREATE_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::SaveBang::CREATE_PERSIST_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::SaveBang::MODIFY_PERSIST_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::SaveBang::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::SaveBang::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::SchemaComment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ActiveRecordMigrationsHelper
-
-  def add_column?(param0 = T.unsafe(nil)); end
-  def add_column_with_comment?(param0 = T.unsafe(nil)); end
-  def comment_present?(param0 = T.unsafe(nil)); end
-  def create_table?(param0 = T.unsafe(nil)); end
-  def create_table_with_comment?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def t_column?(param0 = T.unsafe(nil)); end
-  def t_column_with_comment?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def add_column_without_comment?(node); end
-  def create_table_column_call_without_comment?(node); end
-  def create_table_without_comment?(node); end
-end
-
-RuboCop::Cop::Rails::SchemaComment::COLUMN_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::SchemaComment::CREATE_TABLE_COLUMN_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Rails::SchemaComment::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::SchemaComment::TABLE_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::ScopeArgs < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def scope?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Rails::ScopeArgs::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ScopeArgs::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::ShortI18n < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def long_i18n?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Rails::ShortI18n::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ShortI18n::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Rails::ShortI18n::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::SkipsModelValidations < ::RuboCop::Cop::Base
-  def initialize(*_arg0); end
-
-  def good_insert?(param0 = T.unsafe(nil)); end
-  def good_touch?(param0 = T.unsafe(nil)); end
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def allowed_method?(node); end
-  def allowed_methods; end
-  def forbidden_methods; end
-  def message(node); end
-end
-
-RuboCop::Cop::Rails::SkipsModelValidations::METHODS_WITH_ARGUMENTS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::SkipsModelValidations::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::SquishedSQLHeredocs < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Heredoc
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_heredoc(node); end
-
-  private
-
-  def message(node); end
-  def offense_detected?(node); end
-  def sql_heredoc?(node); end
-  def using_squish?(node); end
-end
-
-RuboCop::Cop::Rails::SquishedSQLHeredocs::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::SquishedSQLHeredocs::SQL = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::SquishedSQLHeredocs::SQUISH = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::StripHeredoc < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_send(node); end
-
-  private
-
-  def register_offense(node, heredoc); end
-end
-
-RuboCop::Cop::Rails::StripHeredoc::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::StripHeredoc::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::TableNameAssignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ActiveRecordHelper
-
-  def base_class?(param0 = T.unsafe(nil)); end
-  def on_class(class_node); end
-end
-
-RuboCop::Cop::Rails::TableNameAssignment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::TimeZone < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_const(node); end
-
-  private
-
-  def acceptable_methods(klass, method_name, node); end
-  def attach_timezone_specifier?(date); end
-  def autocorrect(corrector, node); end
-  def autocorrect_time_new(node, corrector); end
-  def build_message(klass, method_name, node); end
-  def check_localtime(node); end
-  def check_time_node(klass, node); end
-  def extract_method_chain(node); end
-  def flexible?; end
-  def good_methods; end
-  def method_from_time_class?(node); end
-  def method_send?(node); end
-  def need_check_localtime?(chain); end
-  def not_danger_chain?(chain); end
-  def offset_provided?(node); end
-  def remove_redundant_in_time_zone(corrector, node); end
-  def safe_method(method_name, node); end
-  def strict?; end
-end
-
-RuboCop::Cop::Rails::TimeZone::ACCEPTED_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::TimeZone::DANGEROUS_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::TimeZone::GOOD_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::TimeZone::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::TimeZone::MSG_ACCEPTABLE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::TimeZone::MSG_LOCALTIME = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::TimeZone::TIMEZONE_SPECIFIER = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::Rails::TimeZoneAssignment < ::RuboCop::Cop::Base
-  def on_send(node); end
-  def time_zone_assignment?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Rails::TimeZoneAssignment::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::TimeZoneAssignment::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::ToFormattedS < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRailsVersion
-
-  def on_csend(node); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Rails::ToFormattedS::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::ToFormattedS::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::TransactionExitStatement < ::RuboCop::Cop::Base
-  def exit_statements(param0); end
-  def on_send(node); end
-  def rescue_body_return_node?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def nested_block?(statement_node); end
-  def statement(statement_node); end
-end
-
-RuboCop::Cop::Rails::TransactionExitStatement::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::TransactionExitStatement::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::UniqBeforePluck < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def aggressive_node_match(param0 = T.unsafe(nil)); end
-  def conservative_node_match(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def dot_method_begin_pos(method, node); end
-  def dot_method_with_whitespace(method, node); end
-end
-
-RuboCop::Cop::Rails::UniqBeforePluck::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::UniqBeforePluck::NEWLINE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::UniqBeforePluck::PATTERN = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::UniqBeforePluck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::UniqueValidationWithoutIndex < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ActiveRecordHelper
-
-  def on_send(node); end
-
-  private
-
-  def array_node_to_array(node); end
-  def class_node(node); end
-  def column_names(node); end
-  def column_names_from_scope(node); end
-  def condition_part?(node); end
-  def find_schema_information(node); end
-  def find_scope(pairs); end
-  def include_column_names_in_expression_index?(index, column_names); end
-  def unfreeze_scope(scope); end
-  def uniqueness_part(node); end
-  def with_index?(klass, table, names); end
-end
-
-RuboCop::Cop::Rails::UniqueValidationWithoutIndex::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::UniqueValidationWithoutIndex::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::UnknownEnv < ::RuboCop::Cop::Base
-  def on_send(node); end
-  def rails_env?(param0 = T.unsafe(nil)); end
-  def unknown_environment_equal?(param0 = T.unsafe(nil)); end
-  def unknown_environment_predicate?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def collect_variable_like_names(_scope); end
-  def environments; end
-  def message(name); end
-  def unknown_env_name?(name); end
-  def unknown_env_predicate?(name); end
-end
-
-RuboCop::Cop::Rails::UnknownEnv::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::UnknownEnv::MSG_SIMILAR = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Rails::UnusedIgnoredColumns < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ActiveRecordHelper
-
-  def column_name(param0 = T.unsafe(nil)); end
-  def ignored_columns(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def check_column_existence(column_node, table); end
-  def class_node(node); end
-  def table(node); end
-end
-
-RuboCop::Cop::Rails::UnusedIgnoredColumns::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::UnusedIgnoredColumns::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::Validation < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def braced_options(options); end
-  def correct_validate_type(corrector, node); end
-  def correct_validate_type_for_array(corrector, node, arguments, loc); end
-  def correct_validate_type_for_hash(corrector, node, arguments); end
-  def frozen_array_argument?(argument); end
-  def message(node); end
-  def preferred_method(method); end
-  def validate_type(node); end
-end
-
-RuboCop::Cop::Rails::Validation::ALLOWLIST = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::Validation::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::Validation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Rails::Validation::TYPES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::WhereEquals < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def where_method_call?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def build_good_method(column, value); end
-  def extract_column_and_value(template_node, value_node); end
-  def offense_range(node); end
-end
-
-RuboCop::Cop::Rails::WhereEquals::EQ_ANONYMOUS_RE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Rails::WhereEquals::EQ_NAMED_RE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Rails::WhereEquals::IN_ANONYMOUS_RE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Rails::WhereEquals::IN_NAMED_RE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Rails::WhereEquals::IS_NULL_RE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Rails::WhereEquals::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::WhereEquals::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::WhereExists < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def exists_with_args?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def where_exists_call?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def build_good_method(args); end
-  def build_good_method_exists(args); end
-  def build_good_method_where(args); end
-  def convertable_args?(args); end
-  def correction_range(node); end
-  def exists_style?; end
-  def find_offenses(node, &block); end
-  def where_style?; end
-end
-
-RuboCop::Cop::Rails::WhereExists::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::WhereExists::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Rails::WhereNot < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def where_method_call?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def build_good_method(column, value); end
-  def extract_column_and_value(template_node, value_node); end
-  def offense_range(node); end
-end
-
-RuboCop::Cop::Rails::WhereNot::IS_NOT_NULL_RE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Rails::WhereNot::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Rails::WhereNot::NOT_EQ_ANONYMOUS_RE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Rails::WhereNot::NOT_EQ_NAMED_RE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Rails::WhereNot::NOT_IN_ANONYMOUS_RE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Rails::WhereNot::NOT_IN_NAMED_RE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Rails::WhereNot::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-module RuboCop::Cop::TargetRailsVersion
-  def minimum_target_rails_version(version); end
-  def support_target_rails_version?(version); end
-end
-
-RuboCop::NodePattern = RuboCop::AST::NodePattern
-RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource
-module RuboCop::Rails; end
-RuboCop::Rails::CONFIG = T.let(T.unsafe(nil), Hash)
-RuboCop::Rails::CONFIG_DEFAULT = T.let(T.unsafe(nil), Pathname)
-
-module RuboCop::Rails::Inject
-  class << self
-    def defaults!; end
-  end
-end
-
-RuboCop::Rails::PROJECT_ROOT = T.let(T.unsafe(nil), Pathname)
-
-module RuboCop::Rails::SchemaLoader
-  extend ::RuboCop::Rails::SchemaLoader
-
-  def db_schema_path; end
-  def load(target_ruby_version); end
-  def reset!; end
-
-  private
-
-  def load!(target_ruby_version); end
-  def parse(path, target_ruby_version); end
-end
-
-class RuboCop::Rails::SchemaLoader::AddIndex < ::RuboCop::Rails::SchemaLoader::Index
-  def initialize(node); end
-
-  def table_name; end
-end
-
-class RuboCop::Rails::SchemaLoader::Column
-  def initialize(node); end
-
-  def name; end
-  def not_null; end
-  def type; end
-
-  private
-
-  def analyze_keywords!(node); end
-end
-
-class RuboCop::Rails::SchemaLoader::Index
-  def initialize(node); end
-
-  def columns; end
-  def expression; end
-  def name; end
-  def unique; end
-
-  private
-
-  def analyze_keywords!(node); end
-  def build_columns_or_expr(columns); end
-end
-
-class RuboCop::Rails::SchemaLoader::Schema
-  def initialize(ast); end
-
-  def add_indices; end
-  def add_indices_by(table_name:); end
-  def table_by(name:); end
-  def tables; end
-
-  private
-
-  def build!(ast); end
-  def each_add_index(ast); end
-  def each_table(ast); end
-end
-
-class RuboCop::Rails::SchemaLoader::Table
-  def initialize(node); end
-
-  def columns; end
-  def indices; end
-  def name; end
-  def with_column?(name:); end
-
-  private
-
-  def build_columns(node); end
-  def build_indices(node); end
-  def each_content(node, &block); end
-end
-
-module RuboCop::Rails::Version
-  class << self
-    def document_version; end
-  end
-end
-
-RuboCop::Rails::Version::STRING = T.let(T.unsafe(nil), String)
-RuboCop::Token = RuboCop::AST::Token
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@2.12.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@2.12.1.rbi
deleted file mode 100644
index 40930f07a22da..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@2.12.1.rbi
+++ /dev/null
@@ -1,1927 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rubocop-rspec` gem.
-# Please instead update this file by running `bin/tapioca gem rubocop-rspec`.
-
-module RuboCop; end
-module RuboCop::Cop; end
-RuboCop::Cop::IgnoredPattern = RuboCop::Cop::AllowedPattern
-module RuboCop::Cop::RSpec; end
-
-class RuboCop::Cop::RSpec::AlignLeftLetBrace < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def token_aligner; end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::RSpec::AlignLeftLetBrace::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::AlignRightLetBrace < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def token_aligner; end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::RSpec::AlignRightLetBrace::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::AnyInstance < ::RuboCop::Cop::RSpec::Base
-  def on_send(node); end
-end
-
-RuboCop::Cop::RSpec::AnyInstance::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::AnyInstance::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::AroundBlock < ::RuboCop::Cop::RSpec::Base
-  def find_arg_usage(param0); end
-  def hook(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-
-  private
-
-  def add_no_arg_offense(node); end
-  def check_for_unused_proxy(block, proxy); end
-end
-
-RuboCop::Cop::RSpec::AroundBlock::MSG_NO_ARG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::AroundBlock::MSG_UNUSED_ARG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::Base < ::RuboCop::Cop::Base
-  include ::RuboCop::RSpec::Language
-  extend ::RuboCop::RSpec::Language::NodePattern
-
-  def on_new_investigation; end
-
-  class << self
-    def inherited(subclass); end
-  end
-end
-
-class RuboCop::Cop::RSpec::Be < ::RuboCop::Cop::RSpec::Base
-  def be_without_args(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::RSpec::Be::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::BeEq < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def eq_type_with_identity?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::RSpec::BeEq::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::BeEq::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::BeEql < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def eql_type_with_identity(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::RSpec::BeEql::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::BeEql::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::BeNil < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def be_nil_matcher?(param0 = T.unsafe(nil)); end
-  def nil_value_expectation?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def check_be_nil_style(node); end
-  def check_be_style(node); end
-end
-
-RuboCop::Cop::RSpec::BeNil::BE_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::BeNil::BE_NIL_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::BeNil::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::BeforeAfterAll < ::RuboCop::Cop::RSpec::Base
-  def before_or_after_all(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::RSpec::BeforeAfterAll::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::BeforeAfterAll::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-module RuboCop::Cop::RSpec::Capybara; end
-
-class RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def as_is_matcher(param0 = T.unsafe(nil)); end
-  def expectation_set_on_current_path(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def regexp_str_matcher(param0 = T.unsafe(nil)); end
-
-  private
-
-  def add_ignore_query_options(corrector, node); end
-  def autocorrect(corrector, node); end
-  def convert_regexp_str_to_literal(corrector, matcher_node, regexp_str); end
-  def rewrite_expectation(corrector, node, to_symbol, matcher_node); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::Capybara::FeatureMethods < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RSpec::InsideExampleGroup
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def capybara_speak(param0 = T.unsafe(nil)); end
-  def feature_method(param0 = T.unsafe(nil)); end
-  def message(range); end
-  def on_block(node); end
-
-  private
-
-  def enabled?(method_name); end
-  def enabled_methods; end
-end
-
-RuboCop::Cop::RSpec::Capybara::FeatureMethods::MAP = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::RSpec::Capybara::FeatureMethods::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::Capybara::SpecificMatcher < ::RuboCop::Cop::RSpec::Base
-  def first_argument(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def acceptable_pattern?(arg); end
-  def good_matcher(node, matcher); end
-  def message(node, matcher); end
-  def specific_matcher(arg); end
-end
-
-RuboCop::Cop::RSpec::Capybara::SpecificMatcher::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::Capybara::SpecificMatcher::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::RSpec::Capybara::SpecificMatcher::SPECIFIC_MATCHER = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Cop::RSpec::Capybara::VisibilityMatcher < ::RuboCop::Cop::RSpec::Base
-  def on_send(node); end
-  def visible_false?(param0 = T.unsafe(nil)); end
-  def visible_true?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def capybara_matcher?(method_name); end
-end
-
-RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::CAPYBARA_MATCHER_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::MSG_FALSE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::MSG_TRUE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::ChangeByZero < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def expect_change_with_arguments(param0 = T.unsafe(nil)); end
-  def expect_change_with_block(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def check_offense(node); end
-  def compound_expectations?(node); end
-end
-
-RuboCop::Cop::RSpec::ChangeByZero::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ChangeByZero::MSG_COMPOUND = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ChangeByZero::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-module RuboCop::Cop::RSpec::CommentsHelp
-  include ::RuboCop::Cop::RSpec::FinalEndLocation
-
-  def begin_pos_with_comment(node); end
-  def buffer; end
-  def end_line_position(node); end
-  def source_range_with_comment(node); end
-  def start_line_position(node); end
-end
-
-class RuboCop::Cop::RSpec::ContextMethod < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def context_method(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-
-  private
-
-  def method_name?(description); end
-end
-
-RuboCop::Cop::RSpec::ContextMethod::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::ContextWording < ::RuboCop::Cop::RSpec::Base
-  def context_wording(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-
-  private
-
-  def bad_prefix?(description); end
-  def joined_prefixes; end
-  def prefix_regex; end
-  def prefixes; end
-end
-
-RuboCop::Cop::RSpec::ContextWording::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::DescribeClass < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RSpec::TopLevelGroup
-
-  def example_group_with_ignored_metadata?(param0 = T.unsafe(nil)); end
-  def not_a_const_described(param0 = T.unsafe(nil)); end
-  def on_top_level_group(node); end
-  def sym_pair(param0 = T.unsafe(nil)); end
-
-  private
-
-  def ignored_metadata; end
-  def ignored_metadata?(node); end
-  def string_constant?(described); end
-end
-
-RuboCop::Cop::RSpec::DescribeClass::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::DescribeMethod < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RSpec::TopLevelGroup
-
-  def on_top_level_group(node); end
-  def second_argument(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::RSpec::DescribeMethod::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::DescribeSymbol < ::RuboCop::Cop::RSpec::Base
-  def describe_symbol?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::RSpec::DescribeSymbol::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::DescribeSymbol::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::DescribedClass < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def common_instance_exec_closure?(param0 = T.unsafe(nil)); end
-  def contains_described_class?(param0); end
-  def described_constant(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def rspec_block?(param0 = T.unsafe(nil)); end
-  def scope_changing_syntax?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, match); end
-  def collapse_namespace(namespace, const); end
-  def const_name(node); end
-  def find_usage(node, &block); end
-  def full_const_name(node); end
-  def message(offense); end
-  def namespace(node); end
-  def offensive?(node); end
-  def offensive_described_class?(node); end
-  def scope_change?(node); end
-  def skippable_block?(node); end
-end
-
-RuboCop::Cop::RSpec::DescribedClass::DESCRIBED_CLASS = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::DescribedClass::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::DescribedClassModuleWrapping < ::RuboCop::Cop::RSpec::Base
-  def find_rspec_blocks(param0); end
-  def on_module(node); end
-end
-
-RuboCop::Cop::RSpec::DescribedClassModuleWrapping::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::Dialect < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::MethodPreference
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def rspec_method?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::RSpec::Dialect::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::EmptyExampleGroup < ::RuboCop::Cop::RSpec::Base
-  def example_group_body(param0 = T.unsafe(nil)); end
-  def example_or_group_or_include?(param0 = T.unsafe(nil)); end
-  def examples?(param0 = T.unsafe(nil)); end
-  def examples_directly_or_in_block?(param0 = T.unsafe(nil)); end
-  def examples_inside_block?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-
-  private
-
-  def conditionals_with_examples?(body); end
-  def examples_in_branches?(condition_node); end
-  def offensive?(body); end
-end
-
-RuboCop::Cop::RSpec::EmptyExampleGroup::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::EmptyHook < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def empty_hook?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-end
-
-RuboCop::Cop::RSpec::EmptyHook::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::EmptyLineAfterExample < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RSpec::FinalEndLocation
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def allow_consecutive_one_liners?; end
-  def allowed_one_liner?(node); end
-  def consecutive_one_liner?(node); end
-  def next_one_line_example?(node); end
-  def next_sibling(node); end
-  def on_block(node); end
-end
-
-RuboCop::Cop::RSpec::EmptyLineAfterExample::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RSpec::FinalEndLocation
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-end
-
-RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::EmptyLineAfterFinalLet < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RSpec::FinalEndLocation
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-end
-
-RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::EmptyLineAfterHook < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RSpec::FinalEndLocation
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-end
-
-RuboCop::Cop::RSpec::EmptyLineAfterHook::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::EmptyLineAfterSubject < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RSpec::FinalEndLocation
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
-  include ::RuboCop::Cop::RSpec::InsideExampleGroup
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-end
-
-RuboCop::Cop::RSpec::EmptyLineAfterSubject::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::RSpec::EmptyLineSeparation
-  include ::RuboCop::Cop::RSpec::FinalEndLocation
-  include ::RuboCop::Cop::RangeHelp
-
-  def last_child?(node); end
-  def missing_separating_line(node); end
-  def missing_separating_line_offense(node); end
-  def offending_loc(last_line); end
-end
-
-class RuboCop::Cop::RSpec::ExampleLength < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::CodeLength
-
-  def on_block(node); end
-
-  private
-
-  def cop_label; end
-end
-
-RuboCop::Cop::RSpec::ExampleLength::LABEL = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::ExampleWithoutDescription < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-
-  def example_description(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-
-  private
-
-  def check_example_without_description(node); end
-  def disallow_empty_description?(node); end
-end
-
-RuboCop::Cop::RSpec::ExampleWithoutDescription::MSG_ADD_DESCRIPTION = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ExampleWithoutDescription::MSG_DEFAULT_ARGUMENT = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::ExampleWording < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def it_description(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-
-  private
-
-  def add_wording_offense(node, message); end
-  def custom_transform; end
-  def docstring(node); end
-  def ignored_words; end
-  def replacement_text(node); end
-  def text(node); end
-end
-
-RuboCop::Cop::RSpec::ExampleWording::IT_PREFIX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::RSpec::ExampleWording::MSG_IT = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ExampleWording::MSG_SHOULD = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ExampleWording::SHOULD_PREFIX = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::RSpec::ExcessiveDocstringSpacing < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def example_description(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def add_whitespace_offense(node, text); end
-  def docstring(node); end
-  def excessive_whitespace?(text); end
-  def strip_excessive_whitespace(text); end
-  def text(node); end
-end
-
-RuboCop::Cop::RSpec::ExcessiveDocstringSpacing::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::ExpectActual < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def expect_literal(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def complex_literal?(node); end
-  def literal?(node); end
-  def simple_literal?(node); end
-  def swap(corrector, actual, expected); end
-end
-
-RuboCop::Cop::RSpec::ExpectActual::COMPLEX_LITERALS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::RSpec::ExpectActual::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ExpectActual::SIMPLE_LITERALS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::RSpec::ExpectActual::SUPPORTED_MATCHERS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::ExpectChange < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def expect_change_with_arguments(param0 = T.unsafe(nil)); end
-  def expect_change_with_block(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::RSpec::ExpectChange::MSG_BLOCK = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ExpectChange::MSG_CALL = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ExpectChange::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::ExpectInHook < ::RuboCop::Cop::RSpec::Base
-  def expectation(param0); end
-  def on_block(node); end
-
-  private
-
-  def message(expect, hook); end
-end
-
-RuboCop::Cop::RSpec::ExpectInHook::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::ExpectOutput < ::RuboCop::Cop::RSpec::Base
-  def on_gvasgn(node); end
-
-  private
-
-  def inside_example_scope?(node); end
-end
-
-RuboCop::Cop::RSpec::ExpectOutput::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::RSpec::ExplicitHelper
-  include ::RuboCop::RSpec::Language
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def predicate_matcher?(param0 = T.unsafe(nil)); end
-  def predicate_matcher_block?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def allowed_explicit_matchers; end
-  def check_explicit(node); end
-  def corrector_explicit(corrector, to_node, actual, matcher, block_child); end
-  def message_explicit(matcher); end
-  def move_predicate(corrector, actual, matcher, block_child); end
-  def predicate_matcher_name?(name); end
-  def replacement_matcher(node); end
-  def to_predicate_method(matcher); end
-end
-
-RuboCop::Cop::RSpec::ExplicitHelper::BUILT_IN_MATCHERS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::RSpec::ExplicitHelper::MSG_EXPLICIT = T.let(T.unsafe(nil), String)
-module RuboCop::Cop::RSpec::FactoryBot; end
-
-class RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def association?(param0 = T.unsafe(nil)); end
-  def factory_attributes(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def value_matcher(param0 = T.unsafe(nil)); end
-
-  private
-
-  def attribute_defining_method?(method_name); end
-  def autocorrect(corrector, node); end
-  def autocorrect_replacing_parens(corrector, node); end
-  def autocorrect_without_parens(corrector, node); end
-  def braces(node); end
-  def offensive_receiver?(receiver, node); end
-  def proc?(attribute); end
-  def receiver_matches_first_block_argument?(receiver, node); end
-  def reserved_method?(method_name); end
-  def value_hash_without_braces?(node); end
-end
-
-RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::FactoryBot::CreateList < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::RSpec::FactoryBot::Language
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def arguments_include_method_call?(param0 = T.unsafe(nil)); end
-  def factory_call(param0 = T.unsafe(nil)); end
-  def factory_list_call(param0 = T.unsafe(nil)); end
-  def n_times_block?(param0 = T.unsafe(nil)); end
-  def n_times_block_with_arg_and_used?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def on_send(node); end
-
-  private
-
-  def contains_only_factory?(node); end
-end
-
-module RuboCop::Cop::RSpec::FactoryBot::CreateList::Corrector
-  private
-
-  def build_options_string(options); end
-  def format_method_call(node, method, arguments); end
-  def format_receiver(receiver); end
-end
-
-class RuboCop::Cop::RSpec::FactoryBot::CreateList::CreateListCorrector
-  include ::RuboCop::Cop::RSpec::FactoryBot::CreateList::Corrector
-
-  def initialize(node); end
-
-  def call(corrector); end
-
-  private
-
-  def build_arguments(node, count); end
-  def call_replacement(node); end
-  def call_with_block_replacement(node); end
-  def format_block(node); end
-  def format_multiline_block(node); end
-  def format_singleline_block(node); end
-  def node; end
-end
-
-RuboCop::Cop::RSpec::FactoryBot::CreateList::MSG_CREATE_LIST = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::FactoryBot::CreateList::MSG_N_TIMES = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::FactoryBot::CreateList::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::FactoryBot::CreateList::TimesCorrector
-  include ::RuboCop::Cop::RSpec::FactoryBot::CreateList::Corrector
-
-  def initialize(node); end
-
-  def call(corrector); end
-
-  private
-
-  def generate_n_times_block(node); end
-  def node; end
-end
-
-class RuboCop::Cop::RSpec::FactoryBot::FactoryClassName < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def class_name(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def allowed?(const_name); end
-end
-
-RuboCop::Cop::RSpec::FactoryBot::FactoryClassName::ALLOWED_CONSTANTS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::RSpec::FactoryBot::FactoryClassName::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::FactoryBot::FactoryClassName::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::FactoryBot::SyntaxMethods < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RSpec::InsideExampleGroup
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::RSpec::FactoryBot::Language
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def crime_scene(node); end
-  def offense(node); end
-end
-
-RuboCop::Cop::RSpec::FactoryBot::SyntaxMethods::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::FactoryBot::SyntaxMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
-
-class RuboCop::Cop::RSpec::FilePath < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RSpec::TopLevelGroup
-
-  def example_group(param0 = T.unsafe(nil)); end
-  def on_top_level_example_group(node); end
-  def routing_metadata?(param0); end
-
-  private
-
-  def camel_to_snake_case(string); end
-  def custom_transform; end
-  def ensure_correct_file_path(send_node, example_group, arguments); end
-  def expected_path(constant); end
-  def filename_ends_with?(pattern); end
-  def ignore_methods?; end
-  def name_pattern(method_name); end
-  def pattern_for(example_group, method_name); end
-  def pattern_for_spec_suffix_only?; end
-  def relevant_rubocop_rspec_file?(_file); end
-  def routing_spec?(args); end
-  def spec_suffix_only?; end
-end
-
-RuboCop::Cop::RSpec::FilePath::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::RSpec::FinalEndLocation
-  def final_end_location(start_node); end
-end
-
-class RuboCop::Cop::RSpec::Focus < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def focusable_selector?(param0 = T.unsafe(nil)); end
-  def focused_block?(param0 = T.unsafe(nil)); end
-  def metadata(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def correct_send(corrector, focus); end
-  def focus_metadata(node, &block); end
-  def with_surrounding(focus); end
-end
-
-RuboCop::Cop::RSpec::Focus::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::HookArgument < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def scoped_hook(param0 = T.unsafe(nil)); end
-  def unscoped_hook(param0 = T.unsafe(nil)); end
-
-  private
-
-  def argument_range(send_node); end
-  def check_implicit(method_send); end
-  def explicit_message(scope); end
-  def hook(node, &block); end
-  def implicit_style?; end
-end
-
-RuboCop::Cop::RSpec::HookArgument::EXPLICIT_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::HookArgument::IMPLICIT_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::HooksBeforeExamples < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def example_or_group?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-
-  private
-
-  def autocorrect(corrector, node, first_example); end
-  def check_hooks(node); end
-  def find_first_example(node); end
-  def multiline_block?(block); end
-end
-
-RuboCop::Cop::RSpec::HooksBeforeExamples::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::IdenticalEqualityAssertion < ::RuboCop::Cop::RSpec::Base
-  def equality_check?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::RSpec::IdenticalEqualityAssertion::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::IdenticalEqualityAssertion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::ImplicitBlockExpectation < ::RuboCop::Cop::RSpec::Base
-  def implicit_expect(param0 = T.unsafe(nil)); end
-  def lambda?(param0 = T.unsafe(nil)); end
-  def lambda_subject?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def find_subject(block_node); end
-  def multi_statement_example_group?(node); end
-  def nearest_subject(node); end
-end
-
-RuboCop::Cop::RSpec::ImplicitBlockExpectation::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ImplicitBlockExpectation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::ImplicitExpect < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def implicit_expect(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def is_expected_range(source_map); end
-  def offending_expect(node); end
-  def offense_message(offending_source); end
-  def replacement_source(offending_source); end
-end
-
-RuboCop::Cop::RSpec::ImplicitExpect::ENFORCED_REPLACEMENTS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::RSpec::ImplicitExpect::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::ImplicitSubject < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def implicit_subject?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def allowed_by_style?(example); end
-  def autocorrect(corrector, node); end
-  def valid_usage?(node); end
-end
-
-RuboCop::Cop::RSpec::ImplicitSubject::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ImplicitSubject::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-module RuboCop::Cop::RSpec::InflectedHelper
-  include ::RuboCop::RSpec::Language
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def be_bool?(param0 = T.unsafe(nil)); end
-  def be_boolthy?(param0 = T.unsafe(nil)); end
-  def predicate_in_actual?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def boolean_matcher?(node); end
-  def check_inflected(node); end
-  def message_inflected(predicate); end
-  def predicate?(sym); end
-  def remove_predicate(corrector, predicate); end
-  def rewrite_matcher(corrector, predicate, matcher); end
-  def to_predicate_matcher(name); end
-  def true?(to_symbol, matcher); end
-end
-
-RuboCop::Cop::RSpec::InflectedHelper::MSG_INFLECTED = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::RSpec::InsideExampleGroup
-  private
-
-  def example_group_root?(node); end
-  def example_group_root_with_siblings?(node); end
-  def inside_example_group?(node); end
-end
-
-class RuboCop::Cop::RSpec::InstanceSpy < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def have_received_usage(param0); end
-  def null_double(param0); end
-  def on_block(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-end
-
-RuboCop::Cop::RSpec::InstanceSpy::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::InstanceVariable < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RSpec::TopLevelGroup
-
-  def custom_matcher?(param0 = T.unsafe(nil)); end
-  def dynamic_class?(param0 = T.unsafe(nil)); end
-  def ivar_assigned?(param0, param1); end
-  def ivar_usage(param0); end
-  def on_top_level_group(node); end
-
-  private
-
-  def assignment_only?; end
-  def valid_usage?(node); end
-end
-
-RuboCop::Cop::RSpec::InstanceVariable::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::ItBehavesLike < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def example_inclusion_offense(param0 = T.unsafe(nil), param1); end
-  def on_send(node); end
-
-  private
-
-  def message(_node); end
-end
-
-RuboCop::Cop::RSpec::ItBehavesLike::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ItBehavesLike::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::IteratedExpectation < ::RuboCop::Cop::RSpec::Base
-  def each?(param0 = T.unsafe(nil)); end
-  def expectation?(param0 = T.unsafe(nil), param1); end
-  def on_block(node); end
-
-  private
-
-  def only_expectations?(body, arg); end
-  def single_expectation?(body, arg); end
-end
-
-RuboCop::Cop::RSpec::IteratedExpectation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::LeadingSubject < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RSpec::InsideExampleGroup
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def check_previous_nodes(node); end
-  def on_block(node); end
-
-  private
-
-  def autocorrect(corrector, node, sibling); end
-  def offending?(node); end
-  def offending_node(node); end
-  def parent(node); end
-end
-
-RuboCop::Cop::RSpec::LeadingSubject::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::LeakyConstantDeclaration < ::RuboCop::Cop::RSpec::Base
-  def on_casgn(node); end
-  def on_class(node); end
-  def on_module(node); end
-
-  private
-
-  def inside_describe_block?(node); end
-end
-
-RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_CLASS = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_CONST = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_MODULE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::LetBeforeExamples < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def example_or_group?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-
-  private
-
-  def autocorrect(corrector, node, first_example); end
-  def check_let_declarations(node); end
-  def find_first_example(node); end
-  def multiline_block?(block); end
-end
-
-RuboCop::Cop::RSpec::LetBeforeExamples::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::LetSetup < ::RuboCop::Cop::RSpec::Base
-  def example_or_shared_group_or_including?(param0 = T.unsafe(nil)); end
-  def let_bang(param0 = T.unsafe(nil)); end
-  def method_called?(param0, param1); end
-  def on_block(node); end
-
-  private
-
-  def child_let_bang(node, &block); end
-  def unused_let_bang(node); end
-end
-
-RuboCop::Cop::RSpec::LetSetup::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::MessageChain < ::RuboCop::Cop::RSpec::Base
-  def on_send(node); end
-end
-
-RuboCop::Cop::RSpec::MessageChain::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::MessageChain::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::MessageExpectation < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-
-  def message_expectation(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def receive_message?(param0); end
-
-  private
-
-  def preferred_style?(expectation); end
-end
-
-RuboCop::Cop::RSpec::MessageExpectation::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::MessageExpectation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::RSpec::MessageExpectation::SUPPORTED_STYLES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::MessageSpies < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-
-  def message_expectation(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def receive_message(param0); end
-
-  private
-
-  def error_message(receiver); end
-  def preferred_style?(expectation); end
-  def receive_message_matcher(node); end
-end
-
-RuboCop::Cop::RSpec::MessageSpies::MSG_HAVE_RECEIVED = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::MessageSpies::MSG_RECEIVE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::MessageSpies::SUPPORTED_STYLES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::MissingExampleGroupArgument < ::RuboCop::Cop::RSpec::Base
-  def on_block(node); end
-end
-
-RuboCop::Cop::RSpec::MissingExampleGroupArgument::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::MultipleDescribes < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RSpec::TopLevelGroup
-
-  def on_top_level_group(node); end
-end
-
-RuboCop::Cop::RSpec::MultipleDescribes::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::MultipleExpectations < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableMax
-
-  def aggregate_failures?(param0 = T.unsafe(nil), param1); end
-  def aggregate_failures_block?(param0 = T.unsafe(nil)); end
-  def expect?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-
-  private
-
-  def example_with_aggregate_failures?(example_node); end
-  def find_aggregate_failures(example_node); end
-  def find_expectation(node, &block); end
-  def flag_example(node, expectation_count:); end
-  def max_expectations; end
-end
-
-RuboCop::Cop::RSpec::MultipleExpectations::ANYTHING = T.let(T.unsafe(nil), Proc)
-RuboCop::Cop::RSpec::MultipleExpectations::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::MultipleExpectations::TRUE = T.let(T.unsafe(nil), Proc)
-
-class RuboCop::Cop::RSpec::MultipleMemoizedHelpers < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableMax
-  include ::RuboCop::Cop::RSpec::Variable
-
-  def on_block(node); end
-  def on_new_investigation; end
-
-  private
-
-  def all_helpers(node); end
-  def allow_subject?; end
-  def example_group_memoized_helpers; end
-  def helpers(node); end
-  def max; end
-  def variable_nodes(node); end
-end
-
-RuboCop::Cop::RSpec::MultipleMemoizedHelpers::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::MultipleSubjects < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-
-  private
-
-  def autocorrect(corrector, subject); end
-  def named_subject?(node); end
-  def remove_autocorrect(corrector, node); end
-  def rename_autocorrect(corrector, node); end
-end
-
-RuboCop::Cop::RSpec::MultipleSubjects::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::NamedSubject < ::RuboCop::Cop::RSpec::Base
-  def example_or_hook_block?(param0 = T.unsafe(nil)); end
-  def ignored_shared_example?(node); end
-  def on_block(node); end
-  def shared_example?(param0 = T.unsafe(nil)); end
-  def subject_usage(param0); end
-end
-
-RuboCop::Cop::RSpec::NamedSubject::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::NestedGroups < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableMax
-  include ::RuboCop::Cop::RSpec::TopLevelGroup
-
-  def on_top_level_group(node); end
-
-  private
-
-  def find_nested_example_groups(node, nesting: T.unsafe(nil), &block); end
-  def max_nesting; end
-  def max_nesting_config; end
-  def message(nesting); end
-end
-
-RuboCop::Cop::RSpec::NestedGroups::DEPRECATED_MAX_KEY = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::NestedGroups::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::NestedGroups::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::NotToNot < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def not_to_not_offense(param0 = T.unsafe(nil), param1); end
-  def on_send(node); end
-
-  private
-
-  def message(_node); end
-end
-
-RuboCop::Cop::RSpec::NotToNot::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::NotToNot::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::OverwritingSetup < ::RuboCop::Cop::RSpec::Base
-  def first_argument_name(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def setup?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def common_setup?(node); end
-  def find_duplicates(node); end
-end
-
-RuboCop::Cop::RSpec::OverwritingSetup::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::Pending < ::RuboCop::Cop::RSpec::Base
-  def on_send(node); end
-  def pending_block?(param0 = T.unsafe(nil)); end
-  def skip_or_pending?(param0 = T.unsafe(nil)); end
-  def skippable?(param0 = T.unsafe(nil)); end
-  def skipped_in_metadata?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def skipped?(node); end
-end
-
-RuboCop::Cop::RSpec::Pending::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::PredicateMatcher < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RSpec::InflectedHelper
-  include ::RuboCop::Cop::RSpec::ExplicitHelper
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def on_send(node); end
-
-  private
-
-  def args_loc(send_node); end
-  def block_loc(send_node); end
-end
-
-module RuboCop::Cop::RSpec::Rails; end
-
-class RuboCop::Cop::RSpec::Rails::AvoidSetupHook < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def setup_call(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::RSpec::Rails::AvoidSetupHook::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::Rails::HaveHttpStatus < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def match_status(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::RSpec::Rails::HaveHttpStatus::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::Rails::HttpStatus < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def http_status(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def checker_class; end
-end
-
-class RuboCop::Cop::RSpec::Rails::HttpStatus::NumericStyleChecker
-  def initialize(node); end
-
-  def message; end
-  def node; end
-  def offensive?; end
-  def preferred_style; end
-
-  private
-
-  def allowed_symbol?; end
-  def number; end
-  def symbol; end
-end
-
-RuboCop::Cop::RSpec::Rails::HttpStatus::NumericStyleChecker::ALLOWED_STATUSES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::RSpec::Rails::HttpStatus::NumericStyleChecker::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::Rails::HttpStatus::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::Rails::HttpStatus::SymbolicStyleChecker
-  def initialize(node); end
-
-  def message; end
-  def node; end
-  def offensive?; end
-  def preferred_style; end
-
-  private
-
-  def custom_http_status_code?; end
-  def number; end
-  def symbol; end
-end
-
-RuboCop::Cop::RSpec::Rails::HttpStatus::SymbolicStyleChecker::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::ReceiveCounts < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def receive_counts(param0 = T.unsafe(nil)); end
-  def stub?(param0); end
-
-  private
-
-  def autocorrect(corrector, node, range); end
-  def matcher_for(method, count); end
-  def message_for(node, source); end
-  def range(node, offending_node); end
-end
-
-RuboCop::Cop::RSpec::ReceiveCounts::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ReceiveCounts::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::ReceiveNever < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def method_on_stub?(param0); end
-  def on_send(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-end
-
-RuboCop::Cop::RSpec::ReceiveNever::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ReceiveNever::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::RepeatedDescription < ::RuboCop::Cop::RSpec::Base
-  def on_block(node); end
-
-  private
-
-  def example_signature(example); end
-  def repeated_descriptions(node); end
-end
-
-RuboCop::Cop::RSpec::RepeatedDescription::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::RepeatedExample < ::RuboCop::Cop::RSpec::Base
-  def on_block(node); end
-
-  private
-
-  def example_signature(example); end
-  def repeated_examples(node); end
-end
-
-RuboCop::Cop::RSpec::RepeatedExample::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::RepeatedExampleGroupBody < ::RuboCop::Cop::RSpec::Base
-  def body(param0 = T.unsafe(nil)); end
-  def const_arg(param0 = T.unsafe(nil)); end
-  def metadata(param0 = T.unsafe(nil)); end
-  def on_begin(node); end
-  def several_example_groups?(param0 = T.unsafe(nil)); end
-  def skip_or_pending?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def add_repeated_lines(groups); end
-  def message(group, repeats); end
-  def repeated_group_bodies(node); end
-  def signature_keys(group); end
-end
-
-RuboCop::Cop::RSpec::RepeatedExampleGroupBody::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::RepeatedExampleGroupDescription < ::RuboCop::Cop::RSpec::Base
-  def doc_string_and_metadata(param0 = T.unsafe(nil)); end
-  def empty_description?(param0 = T.unsafe(nil)); end
-  def on_begin(node); end
-  def several_example_groups?(param0 = T.unsafe(nil)); end
-  def skip_or_pending?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def add_repeated_lines(groups); end
-  def message(group, repeats); end
-  def repeated_group_descriptions(node); end
-end
-
-RuboCop::Cop::RSpec::RepeatedExampleGroupDescription::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::RepeatedIncludeExample < ::RuboCop::Cop::RSpec::Base
-  def include_examples?(param0 = T.unsafe(nil)); end
-  def on_begin(node); end
-  def several_include_examples?(param0 = T.unsafe(nil)); end
-  def shared_examples_name(param0 = T.unsafe(nil)); end
-
-  private
-
-  def add_repeated_lines(items); end
-  def literal_include_examples?(node); end
-  def message(item, repeats); end
-  def repeated_include_examples(node); end
-  def signature_keys(item); end
-end
-
-RuboCop::Cop::RSpec::RepeatedIncludeExample::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::ReturnFromStub < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def and_return_value(param0); end
-  def contains_stub?(param0); end
-  def on_block(node); end
-  def on_send(node); end
-  def stub_with_block?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def check_and_return_call(node); end
-  def check_block_body(block); end
-  def dynamic?(node); end
-end
-
-class RuboCop::Cop::RSpec::ReturnFromStub::AndReturnCallCorrector
-  def initialize(node); end
-
-  def call(corrector); end
-
-  private
-
-  def arg; end
-  def hash_without_braces?; end
-  def heredoc?; end
-  def node; end
-  def range; end
-  def receiver; end
-  def replacement; end
-end
-
-class RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector
-  def initialize(block); end
-
-  def call(corrector); end
-
-  private
-
-  def block; end
-  def body; end
-  def heredoc?; end
-  def node; end
-end
-
-RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector::NULL_BLOCK_BODY = T.let(T.unsafe(nil), T.untyped)
-RuboCop::Cop::RSpec::ReturnFromStub::MSG_AND_RETURN = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ReturnFromStub::MSG_BLOCK = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::ReturnFromStub::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::ScatteredLet < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-
-  private
-
-  def check_let_declarations(body); end
-  def find_first_let(node); end
-end
-
-RuboCop::Cop::RSpec::ScatteredLet::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::ScatteredSetup < ::RuboCop::Cop::RSpec::Base
-  def lines_msg(numbers); end
-  def on_block(node); end
-  def repeated_hooks(node); end
-end
-
-RuboCop::Cop::RSpec::ScatteredSetup::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::SharedContext < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def context?(param0); end
-  def examples?(param0); end
-  def on_block(node); end
-  def shared_context(param0 = T.unsafe(nil)); end
-  def shared_example(param0 = T.unsafe(nil)); end
-
-  private
-
-  def context_with_only_examples(node); end
-  def examples_with_only_context(node); end
-end
-
-RuboCop::Cop::RSpec::SharedContext::MSG_CONTEXT = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::SharedContext::MSG_EXAMPLES = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::SharedExamples < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def shared_examples(param0 = T.unsafe(nil)); end
-end
-
-class RuboCop::Cop::RSpec::SharedExamples::Checker
-  def initialize(node); end
-
-  def message; end
-  def node; end
-  def preferred_style; end
-
-  private
-
-  def symbol; end
-  def wrap_with_single_quotes(string); end
-end
-
-RuboCop::Cop::RSpec::SharedExamples::Checker::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::SingleArgumentMessageChain < ::RuboCop::Cop::RSpec::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def message_chain(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def single_key_hash?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node, method, arg); end
-  def autocorrect_array_arg(corrector, arg); end
-  def autocorrect_hash_arg(corrector, arg); end
-  def key_to_arg(node); end
-  def replacement(method); end
-  def single_element_array?(node); end
-  def valid_usage?(node); end
-end
-
-RuboCop::Cop::RSpec::SingleArgumentMessageChain::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::SingleArgumentMessageChain::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::StubbedMock < ::RuboCop::Cop::RSpec::Base
-  def configured_response?(param0 = T.unsafe(nil)); end
-  def expectation(param0 = T.unsafe(nil)); end
-  def matcher_with_blockpass(param0 = T.unsafe(nil)); end
-  def matcher_with_configured_response(param0 = T.unsafe(nil)); end
-  def matcher_with_hash(param0 = T.unsafe(nil)); end
-  def matcher_with_return_block(param0 = T.unsafe(nil)); end
-  def message_expectation?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def msg(method_name); end
-  def on_expectation(expectation, method_name, matcher); end
-  def replacement(method_name); end
-end
-
-RuboCop::Cop::RSpec::StubbedMock::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::SubjectDeclaration < ::RuboCop::Cop::RSpec::Base
-  def offensive_subject_declaration?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def message_for(offense); end
-end
-
-RuboCop::Cop::RSpec::SubjectDeclaration::MSG_LET = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::SubjectDeclaration::MSG_REDUNDANT = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::SubjectStub < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RSpec::TopLevelGroup
-
-  def let?(param0 = T.unsafe(nil)); end
-  def message_expectation?(param0 = T.unsafe(nil), param1); end
-  def message_expectation_matcher?(param0); end
-  def on_top_level_group(node); end
-  def subject?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def find_all_explicit(node); end
-  def find_subject_expectations(node, subject_names = T.unsafe(nil), &block); end
-end
-
-RuboCop::Cop::RSpec::SubjectStub::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::RSpec::TopLevelGroup
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def on_new_investigation; end
-  def top_level_groups; end
-
-  private
-
-  def on_top_level_example_group(_node); end
-  def on_top_level_group(_node); end
-  def root_node; end
-  def top_level_group?(node); end
-  def top_level_nodes(node); end
-end
-
-class RuboCop::Cop::RSpec::UnspecifiedException < ::RuboCop::Cop::RSpec::Base
-  def block_with_args?(node); end
-  def empty_exception_matcher?(node); end
-  def empty_raise_error_or_exception(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::RSpec::UnspecifiedException::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::UnspecifiedException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-module RuboCop::Cop::RSpec::Variable
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def variable_definition?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::RSpec::Variable::Helpers = RuboCop::RSpec::Language::Helpers
-RuboCop::Cop::RSpec::Variable::Subjects = RuboCop::RSpec::Language::Subjects
-
-class RuboCop::Cop::RSpec::VariableDefinition < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RSpec::Variable
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def correct_variable(variable); end
-  def string?(node); end
-  def style_violation?(variable); end
-  def symbol?(node); end
-end
-
-RuboCop::Cop::RSpec::VariableDefinition::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::VariableName < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::ConfigurableFormatting
-  include ::RuboCop::Cop::ConfigurableNaming
-  include ::RuboCop::Cop::AllowedPattern
-  include ::RuboCop::Cop::RSpec::Variable
-
-  def on_send(node); end
-
-  private
-
-  def message(style); end
-end
-
-RuboCop::Cop::RSpec::VariableName::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::RSpec::VerifiedDoubleReference < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def verified_double(param0 = T.unsafe(nil)); end
-
-  private
-
-  def correct_style(violation); end
-  def opposing_style?(class_reference); end
-end
-
-RuboCop::Cop::RSpec::VerifiedDoubleReference::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::VerifiedDoubleReference::REFERENCE_TYPE_STYLES = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::RSpec::VerifiedDoubleReference::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
-
-class RuboCop::Cop::RSpec::VerifiedDoubles < ::RuboCop::Cop::RSpec::Base
-  def on_send(node); end
-  def unverified_double(param0 = T.unsafe(nil)); end
-
-  private
-
-  def symbol?(name); end
-end
-
-RuboCop::Cop::RSpec::VerifiedDoubles::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::VerifiedDoubles::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::VoidExpect < ::RuboCop::Cop::RSpec::Base
-  def expect?(param0 = T.unsafe(nil)); end
-  def expect_block?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def on_send(node); end
-
-  private
-
-  def check_expect(node); end
-  def void?(expect); end
-end
-
-RuboCop::Cop::RSpec::VoidExpect::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::RSpec::VoidExpect::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::RSpec::Yield < ::RuboCop::Cop::RSpec::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def block_arg(param0 = T.unsafe(nil)); end
-  def block_call?(param0 = T.unsafe(nil), param1); end
-  def method_on_stub?(param0); end
-  def on_block(node); end
-
-  private
-
-  def autocorrect(corrector, node, range); end
-  def block_range(node); end
-  def calling_block?(node, block); end
-  def convert_block_to_yield(node); end
-  def generate_replacement(node); end
-end
-
-RuboCop::Cop::RSpec::Yield::MSG = T.let(T.unsafe(nil), String)
-RuboCop::NodePattern = RuboCop::AST::NodePattern
-RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource
-module RuboCop::RSpec; end
-
-class RuboCop::RSpec::AlignLetBrace
-  include ::RuboCop::RSpec::Language
-  include ::RuboCop::PathUtil
-  include ::RuboCop::Cop::Util
-
-  def initialize(root, token); end
-
-  def indent_for(node); end
-  def offending_tokens; end
-
-  private
-
-  def adjacent_let_chunks; end
-  def let_group_for(let); end
-  def let_token(node); end
-  def root; end
-  def single_line_lets; end
-  def target_column_for(let); end
-  def token; end
-end
-
-class RuboCop::RSpec::Concept
-  include ::RuboCop::RSpec::Language
-  extend ::RuboCop::AST::NodePattern::Macros
-  extend ::RuboCop::RSpec::Language::NodePattern
-
-  def initialize(node); end
-
-  def ==(other); end
-  def eql?(other); end
-  def hash; end
-  def to_node; end
-
-  protected
-
-  def node; end
-end
-
-module RuboCop::RSpec::Corrector; end
-
-class RuboCop::RSpec::Corrector::MoveNode
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::RSpec::FinalEndLocation
-  include ::RuboCop::Cop::RSpec::CommentsHelp
-
-  def initialize(node, corrector, processed_source); end
-
-  def corrector; end
-  def move_after(other); end
-  def move_before(other); end
-  def original; end
-  def processed_source; end
-
-  private
-
-  def node_range(node); end
-  def node_range_with_surrounding_space(node); end
-  def source(node); end
-end
-
-class RuboCop::RSpec::Example < ::RuboCop::RSpec::Concept
-  def definition; end
-  def doc_string; end
-  def extract_doc_string(param0 = T.unsafe(nil)); end
-  def extract_implementation(param0 = T.unsafe(nil)); end
-  def extract_metadata(param0 = T.unsafe(nil)); end
-  def implementation; end
-  def metadata; end
-end
-
-class RuboCop::RSpec::ExampleGroup < ::RuboCop::RSpec::Concept
-  def examples; end
-  def hooks; end
-  def lets; end
-  def scope_change?(param0 = T.unsafe(nil)); end
-  def subjects; end
-
-  private
-
-  def find_all(node, predicate); end
-  def find_all_in_scope(node, predicate); end
-end
-
-module RuboCop::RSpec::FactoryBot
-  class << self
-    def attribute_defining_methods; end
-    def reserved_methods; end
-  end
-end
-
-RuboCop::RSpec::FactoryBot::ATTRIBUTE_DEFINING_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::RSpec::FactoryBot::DEFINITION_PROXY_METHODS = T.let(T.unsafe(nil), Array)
-
-module RuboCop::RSpec::FactoryBot::Language
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def factory_bot?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::RSpec::FactoryBot::RESERVED_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::RSpec::FactoryBot::UNPROXIED_METHODS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::RSpec::Hook < ::RuboCop::RSpec::Concept
-  def example?; end
-  def extract_metadata(param0 = T.unsafe(nil)); end
-  def knowable_scope?; end
-  def metadata; end
-  def name; end
-  def scope; end
-
-  private
-
-  def scope_argument; end
-  def scope_name; end
-  def transform_metadata(meta); end
-  def transform_true(node); end
-  def valid_scope?(node); end
-end
-
-module RuboCop::RSpec::Inject
-  class << self
-    def defaults!; end
-  end
-end
-
-module RuboCop::RSpec::Language
-  extend ::RuboCop::AST::NodePattern::Macros
-  extend ::RuboCop::RSpec::Language::NodePattern
-
-  def example?(param0 = T.unsafe(nil)); end
-  def example_group?(param0 = T.unsafe(nil)); end
-  def example_group_with_body?(param0 = T.unsafe(nil)); end
-  def hook?(param0 = T.unsafe(nil)); end
-  def include?(param0 = T.unsafe(nil)); end
-  def let?(param0 = T.unsafe(nil)); end
-  def rspec?(param0 = T.unsafe(nil)); end
-  def shared_group?(param0 = T.unsafe(nil)); end
-  def spec_group?(param0 = T.unsafe(nil)); end
-  def subject?(param0 = T.unsafe(nil)); end
-
-  class << self
-    def config; end
-    def config=(_arg0); end
-  end
-end
-
-module RuboCop::RSpec::Language::ALL
-  class << self
-    def all(element); end
-  end
-end
-
-module RuboCop::RSpec::Language::ExampleGroups
-  class << self
-    def all(element); end
-    def focused(element); end
-    def regular(element); end
-    def skipped(element); end
-  end
-end
-
-module RuboCop::RSpec::Language::Examples
-  class << self
-    def all(element); end
-    def focused(element); end
-    def pending(element); end
-    def regular(element); end
-    def skipped(element); end
-  end
-end
-
-module RuboCop::RSpec::Language::Expectations
-  class << self
-    def all(element); end
-  end
-end
-
-module RuboCop::RSpec::Language::Helpers
-  class << self
-    def all(element); end
-  end
-end
-
-module RuboCop::RSpec::Language::HookScopes
-  class << self
-    def all(element); end
-  end
-end
-
-module RuboCop::RSpec::Language::Hooks
-  class << self
-    def all(element); end
-  end
-end
-
-module RuboCop::RSpec::Language::Includes
-  class << self
-    def all(element); end
-    def context(element); end
-    def examples(element); end
-  end
-end
-
-module RuboCop::RSpec::Language::NodePattern
-  def block_pattern(string); end
-  def send_pattern(string); end
-end
-
-module RuboCop::RSpec::Language::Runners
-  class << self
-    def all(element); end
-  end
-end
-
-module RuboCop::RSpec::Language::SharedGroups
-  class << self
-    def all(element); end
-    def context(element); end
-    def examples(element); end
-  end
-end
-
-module RuboCop::RSpec::Language::Subjects
-  class << self
-    def all(element); end
-  end
-end
-
-module RuboCop::RSpec::Node
-  def recursive_literal_or_const?; end
-end
-
-module RuboCop::RSpec::Version; end
-RuboCop::RSpec::Version::STRING = T.let(T.unsafe(nil), String)
-
-class RuboCop::RSpec::Wording
-  def initialize(text, ignore:, replace:); end
-
-  def rewrite; end
-
-  private
-
-  def append_suffix(word, suffix); end
-  def ignored_word?(word); end
-  def ignores; end
-  def remove_should_and_pluralize; end
-  def replace_prefix(pattern, replacement); end
-  def replacements; end
-  def substitute(word); end
-  def text; end
-  def uppercase?(word); end
-end
-
-RuboCop::RSpec::Wording::ES_SUFFIX_PATTERN = T.let(T.unsafe(nil), Regexp)
-RuboCop::RSpec::Wording::IES_SUFFIX_PATTERN = T.let(T.unsafe(nil), Regexp)
-RuboCop::RSpec::Wording::SHOULDNT_BE_PREFIX = T.let(T.unsafe(nil), Regexp)
-RuboCop::RSpec::Wording::SHOULDNT_PREFIX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Token = RuboCop::AST::Token
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@3.2.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@3.2.0.rbi
new file mode 100644
index 0000000000000..e21b66846f1cb
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/rubocop-rspec@3.2.0.rbi
@@ -0,0 +1,7588 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rubocop-rspec` gem.
+# Please instead update this file by running `bin/tapioca gem rubocop-rspec`.
+
+
+# source://rubocop-rspec//lib/rubocop/rspec.rb#3
+module RuboCop; end
+
+class RuboCop::AST::Node < ::Parser::AST::Node
+  include ::RuboCop::RSpec::Node
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/file_help.rb#4
+module RuboCop::Cop; end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/file_help.rb#5
+module RuboCop::Cop::RSpec; end
+
+# Checks that left braces for adjacent single line lets are aligned.
+#
+# @example
+#   # bad
+#   let(:foobar) { blahblah }
+#   let(:baz) { bar }
+#   let(:a) { b }
+#
+#   # good
+#   let(:foobar) { blahblah }
+#   let(:baz)    { bar }
+#   let(:a)      { b }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/align_left_let_brace.rb#19
+class RuboCop::Cop::RSpec::AlignLeftLetBrace < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/align_left_let_brace.rb#28
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/align_left_let_brace.rb#43
+  def token_aligner; end
+
+  class << self
+    # source://rubocop-rspec//lib/rubocop/cop/rspec/align_left_let_brace.rb#24
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/align_left_let_brace.rb#22
+RuboCop::Cop::RSpec::AlignLeftLetBrace::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that right braces for adjacent single line lets are aligned.
+#
+# @example
+#   # bad
+#   let(:foobar) { blahblah }
+#   let(:baz)    { bar }
+#   let(:a)      { b }
+#
+#   # good
+#   let(:foobar) { blahblah }
+#   let(:baz)    { bar      }
+#   let(:a)      { b        }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/align_right_let_brace.rb#19
+class RuboCop::Cop::RSpec::AlignRightLetBrace < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/align_right_let_brace.rb#28
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/align_right_let_brace.rb#43
+  def token_aligner; end
+
+  class << self
+    # source://rubocop-rspec//lib/rubocop/cop/rspec/align_right_let_brace.rb#24
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/align_right_let_brace.rb#22
+RuboCop::Cop::RSpec::AlignRightLetBrace::MSG = T.let(T.unsafe(nil), String)
+
+# Check that instances are not being stubbed globally.
+#
+# Prefer instance doubles over stubbing any instance of a class
+#
+# @example
+#   # bad
+#   describe MyClass do
+#   before { allow_any_instance_of(MyClass).to receive(:foo) }
+#   end
+#
+#   # good
+#   describe MyClass do
+#   let(:my_instance) { instance_double(MyClass) }
+#
+#   before do
+#   allow(MyClass).to receive(:new).and_return(my_instance)
+#   allow(my_instance).to receive(:foo)
+#   end
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/any_instance.rb#26
+class RuboCop::Cop::RSpec::AnyInstance < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/any_instance.rb#34
+  def on_send(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/any_instance.rb#27
+RuboCop::Cop::RSpec::AnyInstance::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/any_instance.rb#28
+RuboCop::Cop::RSpec::AnyInstance::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks that around blocks actually run the test.
+#
+# @example
+#   # bad
+#   around do
+#   some_method
+#   end
+#
+#   around do |test|
+#   some_method
+#   end
+#
+#   # good
+#   around do |test|
+#   some_method
+#   test.call
+#   end
+#
+#   around do |test|
+#   some_method
+#   test.run
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#29
+class RuboCop::Cop::RSpec::AroundBlock < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#45
+  def find_arg_usage(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#35
+  def hook_block(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#40
+  def hook_numblock(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#49
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#59
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#67
+  def add_no_arg_offense(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#84
+  def check_for_numblock(block); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#71
+  def check_for_unused_proxy(block, proxy); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#30
+RuboCop::Cop::RSpec::AroundBlock::MSG_NO_ARG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/around_block.rb#31
+RuboCop::Cop::RSpec::AroundBlock::MSG_UNUSED_ARG = T.let(T.unsafe(nil), String)
+
+# @abstract parent class to RSpec cops
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/base.rb#7
+class RuboCop::Cop::RSpec::Base < ::RuboCop::Cop::Base
+  include ::RuboCop::RSpec::Language
+
+  # Set the config for dynamic DSL configuration-aware helpers
+  # that have no other means of accessing the configuration.
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/base.rb#19
+  def on_new_investigation; end
+
+  class << self
+    # Invoke the original inherited hook so our cops are recognized
+    #
+    # source://rubocop-rspec//lib/rubocop/cop/rspec/base.rb#13
+    def inherited(subclass); end
+  end
+end
+
+# Check for expectations where `be` is used without argument.
+#
+# The `be` matcher is too generic, as it pass on everything that is not
+# nil or false. If that is the exact intend, use `be_truthy`. In all other
+# cases it's better to specify what exactly is the expected value.
+#
+# @example
+#   # bad
+#   expect(foo).to be
+#
+#   # good
+#   expect(foo).to be_truthy
+#   expect(foo).to be 1.0
+#   expect(foo).to be(true)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be.rb#21
+class RuboCop::Cop::RSpec::Be < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/be.rb#27
+  def be_without_args(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/be.rb#31
+  def on_send(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be.rb#22
+RuboCop::Cop::RSpec::Be::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be.rb#24
+RuboCop::Cop::RSpec::Be::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Prefer using `be_empty` when checking for an empty array.
+#
+# @example
+#   # bad
+#   expect(array).to contain_exactly
+#   expect(array).to match_array([])
+#
+#   # good
+#   expect(array).to be_empty
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be_empty.rb#16
+class RuboCop::Cop::RSpec::BeEmpty < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/be_empty.rb#23
+  def expect_array_matcher?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/be_empty.rb#35
+  def on_send(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be_empty.rb#19
+RuboCop::Cop::RSpec::BeEmpty::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be_empty.rb#20
+RuboCop::Cop::RSpec::BeEmpty::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Check for expectations where `be(...)` can replace `eq(...)`.
+#
+# The `be` matcher compares by identity while the `eq` matcher compares
+# using `==`. Booleans and nil can be compared by identity and therefore
+# the `be` matcher is preferable as it is a more strict test.
+#
+# @example
+#   # bad
+#   expect(foo).to eq(true)
+#   expect(foo).to eq(false)
+#   expect(foo).to eq(nil)
+#
+#   # good
+#   expect(foo).to be(true)
+#   expect(foo).to be(false)
+#   expect(foo).to be(nil)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be_eq.rb#26
+class RuboCop::Cop::RSpec::BeEq < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/be_eq.rb#33
+  def eq_type_with_identity?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/be_eq.rb#37
+  def on_send(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be_eq.rb#29
+RuboCop::Cop::RSpec::BeEq::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be_eq.rb#30
+RuboCop::Cop::RSpec::BeEq::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Check for expectations where `be(...)` can replace `eql(...)`.
+#
+# The `be` matcher compares by identity while the `eql` matcher
+# compares using `eql?`. Integers, floats, booleans, symbols, and nil
+# can be compared by identity and therefore the `be` matcher is
+# preferable as it is a more strict test.
+#
+# This cop only looks for instances of `expect(...).to eql(...)`. We
+# do not check `to_not` or `not_to` since `!eql?` is more strict
+# than `!equal?`. We also do not try to flag `eq` because if
+# `a == b`, and `b` is comparable by identity, `a` is still not
+# necessarily the same type as `b` since the `#==` operator can
+# coerce objects for comparison.
+#
+# @example
+#   # bad
+#   expect(foo).to eql(1)
+#   expect(foo).to eql(1.0)
+#   expect(foo).to eql(true)
+#   expect(foo).to eql(false)
+#   expect(foo).to eql(:bar)
+#   expect(foo).to eql(nil)
+#
+#   # good
+#   expect(foo).to be(1)
+#   expect(foo).to be(1.0)
+#   expect(foo).to be(true)
+#   expect(foo).to be(false)
+#   expect(foo).to be(:bar)
+#   expect(foo).to be(nil)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be_eql.rb#40
+class RuboCop::Cop::RSpec::BeEql < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/be_eql.rb#47
+  def eql_type_with_identity(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/be_eql.rb#51
+  def on_send(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be_eql.rb#43
+RuboCop::Cop::RSpec::BeEql::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be_eql.rb#44
+RuboCop::Cop::RSpec::BeEql::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Ensures a consistent style is used when matching `nil`.
+#
+# You can either use the more specific `be_nil` matcher, or the more
+# generic `be` matcher with a `nil` argument.
+#
+# This cop can be configured using the `EnforcedStyle` option
+#
+# @example `EnforcedStyle: be_nil` (default)
+#   # bad
+#   expect(foo).to be(nil)
+#
+#   # good
+#   expect(foo).to be_nil
+# @example `EnforcedStyle: be`
+#   # bad
+#   expect(foo).to be_nil
+#
+#   # good
+#   expect(foo).to be(nil)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#27
+class RuboCop::Cop::RSpec::BeNil < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#36
+  def be_nil_matcher?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#41
+  def nil_value_expectation?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#45
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#64
+  def check_be_nil_style(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#56
+  def check_be_style(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#31
+RuboCop::Cop::RSpec::BeNil::BE_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#32
+RuboCop::Cop::RSpec::BeNil::BE_NIL_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/be_nil.rb#33
+RuboCop::Cop::RSpec::BeNil::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Check that before/after(:all/:context) isn't being used.
+#
+# @example
+#   # bad - Faster but risk of state leaking between examples
+#   describe MyClass do
+#   before(:all) { Widget.create }
+#   after(:context) { Widget.delete_all }
+#   end
+#
+#   # good - Slower but examples are properly isolated
+#   describe MyClass do
+#   before(:each) { Widget.create }
+#   after(:each) { Widget.delete_all }
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/before_after_all.rb#21
+class RuboCop::Cop::RSpec::BeforeAfterAll < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/before_after_all.rb#30
+  def before_or_after_all(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/before_after_all.rb#34
+  def on_send(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/before_after_all.rb#22
+RuboCop::Cop::RSpec::BeforeAfterAll::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/before_after_all.rb#27
+RuboCop::Cop::RSpec::BeforeAfterAll::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
+
+# Prefer negated matchers over `to change.by(0)`.
+#
+# In the case of composite expectations, cop suggest using the
+# negation matchers of `RSpec::Matchers#change`.
+#
+# By default the cop does not support autocorrect of
+# compound expectations, but if you set the
+# negated matcher for `change`, e.g. `not_change` with
+# the `NegatedMatcher` option, the cop will perform the autocorrection.
+#
+# @example NegatedMatcher: ~ (default)
+#   # bad
+#   expect { run }.to change(Foo, :bar).by(0)
+#   expect { run }.to change { Foo.bar }.by(0)
+#
+#   # bad - compound expectations (does not support autocorrection)
+#   expect { run }
+#   .to change(Foo, :bar).by(0)
+#   .and change(Foo, :baz).by(0)
+#   expect { run }
+#   .to change { Foo.bar }.by(0)
+#   .and change { Foo.baz }.by(0)
+#
+#   # good
+#   expect { run }.not_to change(Foo, :bar)
+#   expect { run }.not_to change { Foo.bar }
+#
+#   # good - compound expectations
+#   define_negated_matcher :not_change, :change
+#   expect { run }
+#   .to not_change(Foo, :bar)
+#   .and not_change(Foo, :baz)
+#   expect { run }
+#   .to not_change { Foo.bar }
+#   .and not_change { Foo.baz }
+# @example NegatedMatcher: not_change
+#   # bad (support autocorrection to good case)
+#   expect { run }
+#   .to change(Foo, :bar).by(0)
+#   .and change(Foo, :baz).by(0)
+#   expect { run }
+#   .to change { Foo.bar }.by(0)
+#   .and change { Foo.baz }.by(0)
+#
+#   # good
+#   define_negated_matcher :not_change, :change
+#   expect { run }
+#   .to not_change(Foo, :bar)
+#   .and not_change(Foo, :baz)
+#   expect { run }
+#   .to not_change { Foo.bar }
+#   .and not_change { Foo.baz }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#60
+class RuboCop::Cop::RSpec::ChangeByZero < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#88
+  def change_nodes(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#71
+  def expect_change_with_arguments(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#78
+  def expect_change_with_block(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#92
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#134
+  def autocorrect(corrector, node, change_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#141
+  def autocorrect_compound(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#120
+  def compound_expectations?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#151
+  def insert_operator(corrector, node, change_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#125
+  def message(change_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#129
+  def message_compound(change_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#175
+  def negated_matcher; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#179
+  def preferred_method; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#105
+  def register_offense(node, change_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#164
+  def remove_by_zero(corrector, node, change_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#160
+  def replace_node(node, change_node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#67
+RuboCop::Cop::RSpec::ChangeByZero::CHANGE_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#64
+RuboCop::Cop::RSpec::ChangeByZero::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#65
+RuboCop::Cop::RSpec::ChangeByZero::MSG_COMPOUND = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/change_by_zero.rb#68
+RuboCop::Cop::RSpec::ChangeByZero::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
+
+# Enforces consistent use of `be_a` or `be_kind_of`.
+#
+# @example EnforcedStyle: be_a (default)
+#   # bad
+#   expect(object).to be_kind_of(String)
+#   expect(object).to be_a_kind_of(String)
+#
+#   # good
+#   expect(object).to be_a(String)
+#   expect(object).to be_an(String)
+# @example EnforcedStyle: be_kind_of
+#   # bad
+#   expect(object).to be_a(String)
+#   expect(object).to be_an(String)
+#
+#   # good
+#   expect(object).to be_kind_of(String)
+#   expect(object).to be_a_kind_of(String)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#26
+class RuboCop::Cop::RSpec::ClassCheck < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#54
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#67
+  def autocorrect(corrector, node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#71
+  def format_message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#79
+  def offending?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#87
+  def preferred_method_name; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#83
+  def preferred_method_name?(method_name); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#91
+  def preferred_method_names; end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#32
+RuboCop::Cop::RSpec::ClassCheck::METHOD_NAMES_FOR_BE_A = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#37
+RuboCop::Cop::RSpec::ClassCheck::METHOD_NAMES_FOR_KIND_OF = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#30
+RuboCop::Cop::RSpec::ClassCheck::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#42
+RuboCop::Cop::RSpec::ClassCheck::PREFERRED_METHOD_NAME_BY_STYLE = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/class_check.rb#47
+RuboCop::Cop::RSpec::ClassCheck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Help methods for working with nodes containing comments.
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/comments_help.rb#7
+module RuboCop::Cop::RSpec::CommentsHelp
+  include ::RuboCop::Cop::RSpec::FinalEndLocation
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/comments_help.rb#17
+  def begin_pos_with_comment(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/comments_help.rb#32
+  def buffer; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/comments_help.rb#27
+  def end_line_position(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/comments_help.rb#10
+  def source_range_with_comment(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/comments_help.rb#23
+  def start_line_position(node); end
+end
+
+# Checks where `contain_exactly` is used.
+#
+# This cop checks for the following:
+# - Prefer `match_array` when matching array values.
+# - Prefer `be_empty` when using `contain_exactly` with no arguments.
+#
+# @example
+#   # bad
+#   it { is_expected.to contain_exactly(*array1, *array2) }
+#
+#   # good
+#   it { is_expected.to match_array(array1 + array2) }
+#
+#   # good
+#   it { is_expected.to contain_exactly(content, *array) }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/contain_exactly.rb#22
+class RuboCop::Cop::RSpec::ContainExactly < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/contain_exactly.rb#28
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/contain_exactly.rb#44
+  def autocorrect_for_populated_array(node, corrector); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/contain_exactly.rb#36
+  def check_populated_collection(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/contain_exactly.rb#25
+RuboCop::Cop::RSpec::ContainExactly::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/contain_exactly.rb#26
+RuboCop::Cop::RSpec::ContainExactly::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# `context` should not be used for specifying methods.
+#
+# @example
+#   # bad
+#   context '#foo_bar' do
+#   # ...
+#   end
+#
+#   context '.foo_bar' do
+#   # ...
+#   end
+#
+#   # good
+#   describe '#foo_bar' do
+#   # ...
+#   end
+#
+#   describe '.foo_bar' do
+#   # ...
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/context_method.rb#27
+class RuboCop::Cop::RSpec::ContextMethod < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/context_method.rb#33
+  def context_method(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/context_method.rb#41
+  def on_block(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/context_method.rb#51
+  def method_name?(description); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/context_method.rb#30
+RuboCop::Cop::RSpec::ContextMethod::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that `context` docstring starts with an allowed prefix.
+#
+# The default list of prefixes is minimal. Users are encouraged to tailor
+# the configuration to meet project needs. Other acceptable prefixes may
+# include `if`, `unless`, `for`, `before`, `after`, or `during`.
+# They may consist of multiple words if desired.
+#
+# If both `Prefixes` and `AllowedPatterns` are empty, this cop will always
+# report an offense. So you need to set at least one of them.
+#
+# This cop can be customized allowed context description pattern
+# with `AllowedPatterns`. By default, there are no checking by pattern.
+#
+# @example `Prefixes` configuration
+#   # .rubocop.yml
+#   # RSpec/ContextWording:
+#   #   Prefixes:
+#   #     - when
+#   #     - with
+#   #     - without
+#   #     - if
+#   #     - unless
+#   #     - for
+# @example
+#   # bad
+#   context 'the display name not present' do
+#   # ...
+#   end
+#
+#   # good
+#   context 'when the display name is not present' do
+#   # ...
+#   end
+# @example `AllowedPatterns` configuration
+#
+#   # .rubocop.yml
+#   # RSpec/ContextWording:
+#   #   AllowedPatterns:
+#   #     - とき$
+# @example
+#   # bad
+#   context '条件を満たす' do
+#   # ...
+#   end
+#
+#   # good
+#   context '条件を満たすとき' do
+#   # ...
+#   end
+# @see http://www.betterspecs.org/#contexts
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#61
+class RuboCop::Cop::RSpec::ContextWording < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::AllowedPattern
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#69
+  def context_wording(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#73
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#83
+  def allowed_patterns; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#91
+  def description(context); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#107
+  def expect_patterns; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#99
+  def message; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#87
+  def prefix_regexes; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#117
+  def prefixes; end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#65
+RuboCop::Cop::RSpec::ContextWording::MSG_ALWAYS = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/context_wording.rb#64
+RuboCop::Cop::RSpec::ContextWording::MSG_MATCH = T.let(T.unsafe(nil), String)
+
+# Check that the first argument to the top-level describe is a constant.
+#
+# It can be configured to ignore strings when certain metadata is passed.
+#
+# Ignores Rails and Aruba `type` metadata by default.
+#
+# @example `IgnoredMetadata` configuration
+#   # .rubocop.yml
+#   # RSpec/DescribeClass:
+#   #   IgnoredMetadata:
+#   #     type:
+#   #       - request
+#   #       - controller
+# @example
+#   # bad
+#   describe 'Do something' do
+#   end
+#
+#   # good
+#   describe TestedClass do
+#   subject { described_class }
+#   end
+#
+#   describe 'TestedClass::VERSION' do
+#   subject { Object.const_get(self.class.description) }
+#   end
+#
+#   describe "A feature example", type: :feature do
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#37
+class RuboCop::Cop::RSpec::DescribeClass < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::TopLevelGroup
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#44
+  def example_group_with_ignored_metadata?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#49
+  def not_a_const_described(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#58
+  def on_top_level_group(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#54
+  def sym_pair(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#79
+  def ignored_metadata; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#68
+  def ignored_metadata?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#74
+  def string_constant?(described); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/describe_class.rb#40
+RuboCop::Cop::RSpec::DescribeClass::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that the second argument to `describe` specifies a method.
+#
+# @example
+#   # bad
+#   describe MyClass, 'do something' do
+#   end
+#
+#   # good
+#   describe MyClass, '#my_instance_method' do
+#   end
+#
+#   describe MyClass, '.my_class_method' do
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/describe_method.rb#20
+class RuboCop::Cop::RSpec::DescribeMethod < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::TopLevelGroup
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_method.rb#34
+  def method_name?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_method.rb#38
+  def on_top_level_group(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_method.rb#27
+  def second_string_literal_argument(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_method.rb#46
+  def method_name_prefix?(description); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/describe_method.rb#23
+RuboCop::Cop::RSpec::DescribeMethod::MSG = T.let(T.unsafe(nil), String)
+
+# Avoid describing symbols.
+#
+# @example
+#   # bad
+#   describe :my_method do
+#   # ...
+#   end
+#
+#   # good
+#   describe '#my_method' do
+#   # ...
+#   end
+# @see https://github.com/rspec/rspec-core/issues/1610
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/describe_symbol.rb#20
+class RuboCop::Cop::RSpec::DescribeSymbol < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_symbol.rb#25
+  def describe_symbol?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/describe_symbol.rb#29
+  def on_send(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/describe_symbol.rb#21
+RuboCop::Cop::RSpec::DescribeSymbol::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/describe_symbol.rb#22
+RuboCop::Cop::RSpec::DescribeSymbol::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks that tests use `described_class`.
+#
+# If the first argument of describe is a class, the class is exposed to
+# each example via described_class.
+#
+# This cop can be configured using the `EnforcedStyle`, `SkipBlocks`
+# and `OnlyStaticConstants` options.
+# `OnlyStaticConstants` is only relevant when `EnforcedStyle` is
+# `described_class`.
+#
+# There's a known caveat with rspec-rails's `controller` helper that
+# runs its block in a different context, and `described_class` is not
+# available to it. `SkipBlocks` option excludes detection in all
+# non-RSpec related blocks.
+#
+# To narrow down this setting to only a specific directory, it is
+# possible to use an overriding configuration file local to that
+# directory.
+#
+# @example `EnforcedStyle: described_class` (default)
+#   # bad
+#   describe MyClass do
+#   subject { MyClass.do_something }
+#   end
+#
+#   # good
+#   describe MyClass do
+#   subject { described_class.do_something }
+#   end
+# @example `OnlyStaticConstants: true` (default)
+#   # good
+#   describe MyClass do
+#   subject { MyClass::CONSTANT }
+#   end
+# @example `OnlyStaticConstants: false`
+#   # bad
+#   describe MyClass do
+#   subject { MyClass::CONSTANT }
+#   end
+# @example `EnforcedStyle: explicit`
+#   # bad
+#   describe MyClass do
+#   subject { described_class.do_something }
+#   end
+#
+#   # good
+#   describe MyClass do
+#   subject { MyClass.do_something }
+#   end
+# @example `SkipBlocks: true`
+#   # spec/controllers/.rubocop.yml
+#   # RSpec/DescribedClass:
+#   #   SkipBlocks: true
+#
+#   # acceptable
+#   describe MyConcern do
+#   controller(ApplicationController) do
+#   include MyConcern
+#   end
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#71
+class RuboCop::Cop::RSpec::DescribedClass < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RSpec::Namespace
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#80
+  def common_instance_exec_closure?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#97
+  def contains_described_class?(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#92
+  def described_constant(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#100
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#85
+  def rspec_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#89
+  def scope_changing_syntax?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#136
+  def allowed?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#117
+  def autocorrect(corrector, match); end
+
+  # @example
+  #   # nil represents base constant
+  #   collapse_namespace([], [:C])                # => [:C]
+  #   collapse_namespace([:A, :B], [:C])          # => [:A, :B, :C]
+  #   collapse_namespace([:A, :B], [:B, :C])      # => [:A, :B, :C]
+  #   collapse_namespace([:A, :B], [nil, :C])     # => [nil, :C]
+  #   collapse_namespace([:A, :B], [nil, :B, :C]) # => [nil, :B, :C]
+  # @param namespace [Array<Symbol>]
+  # @param const [Array<Symbol>]
+  # @return [Array<Symbol>]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#200
+  def collapse_namespace(namespace, const); end
+
+  # @example
+  #   const_name(s(:const, nil, :C))                # => [:C]
+  #   const_name(s(:const, s(:const, nil, :M), :C)) # => [:M, :C]
+  #   const_name(s(:const, s(:cbase), :C))          # => [nil, :C]
+  # @param node [RuboCop::AST::Node]
+  # @return [Array<Symbol>]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#217
+  def const_name(node); end
+
+  # @yield [node]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#127
+  def find_usage(node, &block); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#185
+  def full_const_name(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#140
+  def message(offense); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#163
+  def offensive?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#171
+  def offensive_described_class?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#159
+  def only_static_constants?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#149
+  def scope_change?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#155
+  def skippable_block?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#76
+RuboCop::Cop::RSpec::DescribedClass::DESCRIBED_CLASS = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/described_class.rb#77
+RuboCop::Cop::RSpec::DescribedClass::MSG = T.let(T.unsafe(nil), String)
+
+# Avoid opening modules and defining specs within them.
+#
+# @example
+#   # bad
+#   module MyModule
+#   RSpec.describe MyClass do
+#   # ...
+#   end
+#   end
+#
+#   # good
+#   RSpec.describe MyModule::MyClass do
+#   # ...
+#   end
+# @see https://github.com/rubocop/rubocop-rspec/issues/735
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/described_class_module_wrapping.rb#22
+class RuboCop::Cop::RSpec::DescribedClassModuleWrapping < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class_module_wrapping.rb#26
+  def include_rspec_blocks?(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/described_class_module_wrapping.rb#30
+  def on_module(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/described_class_module_wrapping.rb#23
+RuboCop::Cop::RSpec::DescribedClassModuleWrapping::MSG = T.let(T.unsafe(nil), String)
+
+# Enforces custom RSpec dialects.
+#
+# A dialect can be based on the following RSpec methods:
+#
+# - describe, context, feature, example_group
+# - xdescribe, xcontext, xfeature
+# - fdescribe, fcontext, ffeature
+# - shared_examples, shared_examples_for, shared_context
+# - it, specify, example, scenario, its
+# - fit, fspecify, fexample, fscenario, focus
+# - xit, xspecify, xexample, xscenario, skip
+# - pending
+# - prepend_before, before, append_before,
+# - around
+# - prepend_after, after, append_after
+# - let, let!
+# - subject, subject!
+# - expect, is_expected, expect_any_instance_of
+#
+# By default all of the RSpec methods and aliases are allowed. By setting
+# a config like:
+#
+#   RSpec/Dialect:
+#     PreferredMethods:
+#       context: describe
+#
+# If you were previously using the `RSpec/Capybara/FeatureMethods` cop and
+# want to keep disabling all Capybara-specific methods that have the same
+# native RSpec method (e.g. are just aliases), use the following config:
+#
+#   RSpec/Dialect:
+#     PreferredMethods:
+#       background: :before
+#       scenario:   :it
+#       xscenario:  :xit
+#       given:      :let
+#       given!:     :let!
+#       feature:    :describe
+#
+# You can expect the following behavior:
+#
+# @example
+#   # bad
+#   context 'display name presence' do
+#   # ...
+#   end
+#
+#   # good
+#   describe 'display name presence' do
+#   # ...
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/dialect.rb#58
+class RuboCop::Cop::RSpec::Dialect < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::MethodPreference
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/dialect.rb#67
+  def on_send(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/dialect.rb#65
+  def rspec_method?(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/dialect.rb#62
+RuboCop::Cop::RSpec::Dialect::MSG = T.let(T.unsafe(nil), String)
+
+# Avoid duplicated metadata.
+#
+# @example
+#   # bad
+#   describe 'Something', :a, :a
+#
+#   # good
+#   describe 'Something', :a
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/duplicated_metadata.rb#14
+class RuboCop::Cop::RSpec::DuplicatedMetadata < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::Metadata
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/duplicated_metadata.rb#22
+  def on_metadata(symbols, _hash); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/duplicated_metadata.rb#38
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/duplicated_metadata.rb#50
+  def duplicated?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/duplicated_metadata.rb#30
+  def on_metadata_symbol(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/duplicated_metadata.rb#20
+RuboCop::Cop::RSpec::DuplicatedMetadata::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if an example group does not include any tests.
+#
+# @example usage
+#   # bad
+#   describe Bacon do
+#   let(:bacon)      { Bacon.new(chunkiness) }
+#   let(:chunkiness) { false                 }
+#
+#   context 'extra chunky' do   # flagged by rubocop
+#   let(:chunkiness) { true }
+#   end
+#
+#   it 'is chunky' do
+#   expect(bacon.chunky?).to be_truthy
+#   end
+#   end
+#
+#   # good
+#   describe Bacon do
+#   let(:bacon)      { Bacon.new(chunkiness) }
+#   let(:chunkiness) { false                 }
+#
+#   it 'is chunky' do
+#   expect(bacon.chunky?).to be_truthy
+#   end
+#   end
+#
+#   # good
+#   describe Bacon do
+#   pending 'will add tests later'
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#38
+class RuboCop::Cop::RSpec::EmptyExampleGroup < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # Match example group blocks and yield their body
+  #
+  # @example source that matches
+  #   describe 'example group' do
+  #   it { is_expected.to be }
+  #   end
+  # @param node [RuboCop::AST::Node]
+  # @yield [RuboCop::AST::Node] example group body
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#55
+  def example_group_body(param0 = T.unsafe(nil)); end
+
+  # Match examples, example groups and includes
+  #
+  # @example source that matches
+  #   it { is_expected.to fly }
+  #   describe('non-empty example groups too') { }
+  #   it_behaves_like 'an animal'
+  #   it_behaves_like('a cat') { let(:food) { 'milk' } }
+  #   it_has_root_access
+  #   skip
+  #   it 'will be implemented later'
+  # @param node [RuboCop::AST::Node]
+  # @return [Array<RuboCop::AST::Node>] matching nodes
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#73
+  def example_or_group_or_include?(param0 = T.unsafe(nil)); end
+
+  # Matches examples defined in scopes where they could run
+  #
+  # @example source that matches
+  #   it { expect(myself).to be_run }
+  #   describe { it { i_run_as_well } }
+  # @example source that does not match
+  #   before { it { whatever here won't run anyway } }
+  # @param node [RuboCop::AST::Node]
+  # @return [Array<RuboCop::AST::Node>] matching nodes
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#130
+  def examples?(param0 = T.unsafe(nil)); end
+
+  # Match examples or examples inside blocks
+  #
+  # @example source that matches
+  #   it { expect(drink).to be_cold }
+  #   context('when winter') { it { expect(drink).to be_hot } }
+  #   (1..5).each { |divisor| it { is_expected.to divide_by(divisor) } }
+  # @param node [RuboCop::AST::Node]
+  # @return [Array<RuboCop::AST::Node>] matching nodes
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#111
+  def examples_directly_or_in_block?(param0 = T.unsafe(nil)); end
+
+  # Match examples defined inside a block which is not a hook
+  #
+  # @example source that matches
+  #   %w(r g b).each do |color|
+  #   it { is_expected.to have_color(color) }
+  #   end
+  # @example source that does not match
+  #   before do
+  #   it { is_expected.to fall_into_oblivion }
+  #   end
+  # @param node [RuboCop::AST::Node]
+  # @return [Array<RuboCop::AST::Node>] matching nodes
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#97
+  def examples_inside_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#138
+  def on_block(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#164
+  def conditionals_with_examples?(body); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#172
+  def examples_in_branches?(condition_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#153
+  def offensive?(body); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#178
+  def removed_range(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_example_group.rb#43
+RuboCop::Cop::RSpec::EmptyExampleGroup::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for empty before and after hooks.
+#
+# @example
+#   # bad
+#   before {}
+#   after do; end
+#   before(:all) do
+#   end
+#   after(:all) { }
+#
+#   # good
+#   before { create_users }
+#   after do
+#   cleanup_users
+#   end
+#   before(:all) do
+#   create_feed
+#   end
+#   after(:all) { cleanup_feed }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_hook.rb#26
+class RuboCop::Cop::RSpec::EmptyHook < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_hook.rb#33
+  def empty_hook?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_hook.rb#37
+  def on_block(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_hook.rb#30
+RuboCop::Cop::RSpec::EmptyHook::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if there is an empty line after example blocks.
+#
+# @example
+#   # bad
+#   RSpec.describe Foo do
+#   it 'does this' do
+#   end
+#   it 'does that' do
+#   end
+#   end
+#
+#   # good
+#   RSpec.describe Foo do
+#   it 'does this' do
+#   end
+#
+#   it 'does that' do
+#   end
+#   end
+#
+#   # fair - it's ok to have non-separated one-liners
+#   RSpec.describe Foo do
+#   it { one }
+#   it { two }
+#   end
+# @example with AllowConsecutiveOneLiners configuration
+#   # rubocop.yml
+#   # RSpec/EmptyLineAfterExample:
+#   #   AllowConsecutiveOneLiners: false
+#
+#   # bad
+#   RSpec.describe Foo do
+#   it { one }
+#   it { two }
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example.rb#43
+class RuboCop::Cop::RSpec::EmptyLineAfterExample < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::FinalEndLocation
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example.rb#49
+  def on_block(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example.rb#64
+  def allow_consecutive_one_liners?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example.rb#60
+  def allowed_one_liner?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example.rb#68
+  def consecutive_one_liner?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example.rb#72
+  def next_one_line_example?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example.rb#47
+RuboCop::Cop::RSpec::EmptyLineAfterExample::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if there is an empty line after example group blocks.
+#
+# @example
+#   # bad
+#   RSpec.describe Foo do
+#   describe '#bar' do
+#   end
+#   describe '#baz' do
+#   end
+#   end
+#
+#   # good
+#   RSpec.describe Foo do
+#   describe '#bar' do
+#   end
+#
+#   describe '#baz' do
+#   end
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example_group.rb#26
+class RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::FinalEndLocation
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example_group.rb#32
+  def on_block(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_example_group.rb#30
+RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if there is an empty line after the last let block.
+#
+# @example
+#   # bad
+#   let(:foo) { bar }
+#   let(:something) { other }
+#   it { does_something }
+#
+#   # good
+#   let(:foo) { bar }
+#   let(:something) { other }
+#
+#   it { does_something }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_final_let.rb#20
+class RuboCop::Cop::RSpec::EmptyLineAfterFinalLet < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::FinalEndLocation
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_final_let.rb#26
+  def on_block(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_final_let.rb#24
+RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if there is an empty line after hook blocks.
+#
+# `AllowConsecutiveOneLiners` configures whether adjacent
+# one-line definitions are considered an offense.
+#
+# @example
+#   # bad
+#   before { do_something }
+#   it { does_something }
+#
+#   # bad
+#   after { do_something }
+#   it { does_something }
+#
+#   # bad
+#   around { |test| test.run }
+#   it { does_something }
+#
+#   # good
+#   after { do_something }
+#
+#   it { does_something }
+#
+#   # fair - it's ok to have non-separated one-liners hooks
+#   around { |test| test.run }
+#   after { do_something }
+#
+#   it { does_something }
+# @example with AllowConsecutiveOneLiners configuration
+#   # rubocop.yml
+#   # RSpec/EmptyLineAfterHook:
+#   #   AllowConsecutiveOneLiners: false
+#
+#   # bad
+#   around { |test| test.run }
+#   after { do_something }
+#
+#   it { does_something }
+#
+#   # good
+#   around { |test| test.run }
+#
+#   after { do_something }
+#
+#   it { does_something }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_hook.rb#53
+class RuboCop::Cop::RSpec::EmptyLineAfterHook < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RSpec::FinalEndLocation
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_hook.rb#60
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_hook.rb#60
+  def on_numblock(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_hook.rb#74
+  def chained_single_line_hooks?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_hook.rb#58
+RuboCop::Cop::RSpec::EmptyLineAfterHook::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if there is an empty line after subject block.
+#
+# @example
+#   # bad
+#   subject(:obj) { described_class }
+#   let(:foo) { bar }
+#
+#   # good
+#   subject(:obj) { described_class }
+#
+#   let(:foo) { bar }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_subject.rb#18
+class RuboCop::Cop::RSpec::EmptyLineAfterSubject < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::FinalEndLocation
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
+  include ::RuboCop::Cop::RSpec::InsideExampleGroup
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_subject.rb#25
+  def on_block(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_line_after_subject.rb#23
+RuboCop::Cop::RSpec::EmptyLineAfterSubject::MSG = T.let(T.unsafe(nil), String)
+
+# Helps determine the offending location if there is not an empty line
+# following the node. Allows comments to follow directly after
+# in the following cases.
+# - followed by empty line(s)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/empty_line_separation.rb#11
+module RuboCop::Cop::RSpec::EmptyLineSeparation
+  include ::RuboCop::Cop::RSpec::FinalEndLocation
+  include ::RuboCop::Cop::RangeHelp
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/empty_line_separation.rb#51
+  def last_child?(node); end
+
+  # @yield [offending_loc(enable_directive_line || final_end_line)]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/empty_line_separation.rb#26
+  def missing_separating_line(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/empty_line_separation.rb#15
+  def missing_separating_line_offense(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/empty_line_separation.rb#41
+  def offending_loc(last_line); end
+end
+
+# Avoid empty metadata hash.
+#
+# @example EnforcedStyle: symbol (default)
+#   # bad
+#   describe 'Something', {}
+#
+#   # good
+#   describe 'Something'
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_metadata.rb#14
+class RuboCop::Cop::RSpec::EmptyMetadata < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::Metadata
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_metadata.rb#22
+  def on_metadata(_symbols, hash); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_metadata.rb#32
+  def remove_empty_metadata(corrector, node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_metadata.rb#20
+RuboCop::Cop::RSpec::EmptyMetadata::MSG = T.let(T.unsafe(nil), String)
+
+# Check that the `output` matcher is not called with an empty string.
+#
+# @example
+#   # bad
+#   expect { foo }.to output('').to_stdout
+#   expect { bar }.not_to output('').to_stderr
+#
+#   # good
+#   expect { foo }.not_to output.to_stdout
+#   expect { bar }.to output.to_stderr
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_output.rb#17
+class RuboCop::Cop::RSpec::EmptyOutput < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_output.rb#24
+  def matching_empty_output(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/empty_output.rb#34
+  def on_send(send_node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_output.rb#20
+RuboCop::Cop::RSpec::EmptyOutput::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/empty_output.rb#21
+RuboCop::Cop::RSpec::EmptyOutput::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Use `eq` instead of `be ==` to compare objects.
+#
+# @example
+#   # bad
+#   expect(foo).to be == 42
+#
+#   # good
+#   expect(foo).to eq 42
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/eq.rb#15
+class RuboCop::Cop::RSpec::Eq < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/eq.rb#23
+  def be_equals(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/eq.rb#27
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/eq.rb#38
+  def offense_range(matcher); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/eq.rb#19
+RuboCop::Cop::RSpec::Eq::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/eq.rb#20
+RuboCop::Cop::RSpec::Eq::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for long examples.
+#
+# A long example is usually more difficult to understand. Consider
+# extracting out some behavior, e.g. with a `let` block, or a helper
+# method.
+#
+# You can set constructs you want to fold with `CountAsOne`.
+# Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+# Each construct will be counted as one line regardless of
+# its actual size.
+#
+# @example
+#   # bad
+#   it do
+#   service = described_class.new
+#   more_setup
+#   more_setup
+#   result = service.call
+#   expect(result).to be(true)
+#   end
+#
+#   # good
+#   it do
+#   service = described_class.new
+#   result = service.call
+#   expect(result).to be(true)
+#   end
+# @example CountAsOne: ['array', 'heredoc', 'method_call']
+#
+#   it do
+#   array = [         # +1
+#   1,
+#   2
+#   ]
+#
+#   hash = {          # +3
+#   key: 'value'
+#   }
+#
+#   msg = <<~HEREDOC  # +1
+#   Heredoc
+#   content.
+#   HEREDOC
+#
+#   foo(            # +1
+#   1,
+#   2
+#   )
+#   end               # 6 points
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/example_length.rb#57
+class RuboCop::Cop::RSpec::ExampleLength < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::CodeLength
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_length.rb#62
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_length.rb#70
+  def cop_label; end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/example_length.rb#60
+RuboCop::Cop::RSpec::ExampleLength::LABEL = T.let(T.unsafe(nil), String)
+
+# Checks for examples without a description.
+#
+# RSpec allows for auto-generated example descriptions when there is no
+# description provided or the description is an empty one.
+# It is acceptable to use `specify` without a description
+#
+# This cop removes empty descriptions.
+# It also defines whether auto-generated description is allowed, based
+# on the configured style.
+#
+# This cop can be configured using the `EnforcedStyle` option
+#
+# @example
+#   # always good
+#   specify do
+#   result = service.call
+#   expect(result).to be(true)
+#   end
+# @example `EnforcedStyle: always_allow` (default)
+#   # bad
+#   it('') { is_expected.to be_good }
+#   specify '' do
+#   result = service.call
+#   expect(result).to be(true)
+#   end
+#
+#   # good
+#   it { is_expected.to be_good }
+#   specify do
+#   result = service.call
+#   expect(result).to be(true)
+#   end
+# @example `EnforcedStyle: single_line_only`
+#   # bad
+#   it('') { is_expected.to be_good }
+#   it do
+#   result = service.call
+#   expect(result).to be(true)
+#   end
+#
+#   # good
+#   it { is_expected.to be_good }
+# @example `EnforcedStyle: disallow`
+#   # bad
+#   it { is_expected.to be_good }
+#   it do
+#   result = service.call
+#   expect(result).to be(true)
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/example_without_description.rb#59
+class RuboCop::Cop::RSpec::ExampleWithoutDescription < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_without_description.rb#67
+  def example_description(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_without_description.rb#69
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_without_description.rb#83
+  def check_example_without_description(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_without_description.rb#91
+  def disallow_empty_description?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/example_without_description.rb#64
+RuboCop::Cop::RSpec::ExampleWithoutDescription::MSG_ADD_DESCRIPTION = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/example_without_description.rb#62
+RuboCop::Cop::RSpec::ExampleWithoutDescription::MSG_DEFAULT_ARGUMENT = T.let(T.unsafe(nil), String)
+
+# Checks for common mistakes in example descriptions.
+#
+# This cop will correct docstrings that begin with 'should' and 'it'.
+# This cop will also look for insufficient examples and call them out.
+#
+# The autocorrect is experimental - use with care! It can be configured
+# with CustomTransform (e.g. have => has) and IgnoredWords (e.g. only).
+#
+# Use the DisallowedExamples setting to prevent unclear or insufficient
+# descriptions. Please note that this config will not be treated as
+# case sensitive.
+#
+# @example
+#   # bad
+#   it 'should find nothing' do
+#   end
+#
+#   it 'will find nothing' do
+#   end
+#
+#   # good
+#   it 'finds nothing' do
+#   end
+# @example
+#   # bad
+#   it 'it does things' do
+#   end
+#
+#   # good
+#   it 'does things' do
+#   end
+# @example `DisallowedExamples: ['works']` (default)
+#   # bad
+#   it 'works' do
+#   end
+#
+#   # good
+#   it 'marks the task as done' do
+#   end
+# @see http://betterspecs.org/#should
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#49
+class RuboCop::Cop::RSpec::ExampleWording < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#63
+  def it_description(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#71
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#89
+  def add_wording_offense(node, message); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#136
+  def custom_transform; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#99
+  def docstring(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#140
+  def ignored_words; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#144
+  def insufficient_docstring?(description_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#148
+  def insufficient_examples; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#153
+  def preprocess(message); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#109
+  def replacement_text(node); end
+
+  # Recursive processing is required to process nested dstr nodes
+  # that is the case for \-separated multiline strings with interpolation.
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#125
+  def text(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#60
+RuboCop::Cop::RSpec::ExampleWording::IT_PREFIX = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#55
+RuboCop::Cop::RSpec::ExampleWording::MSG_INSUFFICIENT_DESCRIPTION = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#54
+RuboCop::Cop::RSpec::ExampleWording::MSG_IT = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#52
+RuboCop::Cop::RSpec::ExampleWording::MSG_SHOULD = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#53
+RuboCop::Cop::RSpec::ExampleWording::MSG_WILL = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#58
+RuboCop::Cop::RSpec::ExampleWording::SHOULD_PREFIX = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/example_wording.rb#59
+RuboCop::Cop::RSpec::ExampleWording::WILL_PREFIX = T.let(T.unsafe(nil), Regexp)
+
+# Checks for excessive whitespace in example descriptions.
+#
+# @example
+#   # bad
+#   it '  has  excessive   spacing  ' do
+#   end
+#
+#   # good
+#   it 'has excessive spacing' do
+#   end
+# @example
+#   # bad
+#   context '  when a condition   is met  ' do
+#   end
+#
+#   # good
+#   context 'when a condition is met' do
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#26
+class RuboCop::Cop::RSpec::ExcessiveDocstringSpacing < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#32
+  def example_description(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#39
+  def on_send(node); end
+
+  private
+
+  # @param node [RuboCop::AST::Node]
+  # @param text [String]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#76
+  def add_whitespace_offense(node, text); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#85
+  def docstring(node); end
+
+  # @param text [String]
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#54
+  def excessive_whitespace?(text); end
+
+  # @param text [String]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#68
+  def strip_excessive_whitespace(text); end
+
+  # Recursive processing is required to process nested dstr nodes
+  # that is the case for \-separated multiline strings with interpolation.
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#97
+  def text(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/excessive_docstring_spacing.rb#29
+RuboCop::Cop::RSpec::ExcessiveDocstringSpacing::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for `expect(...)` calls containing literal values.
+#
+# Autocorrection is performed when the expected is not a literal.
+#
+# @example
+#   # bad
+#   expect(5).to eq(price)
+#   expect(/foo/).to eq(pattern)
+#   expect("John").to eq(name)
+#
+#   # good
+#   expect(price).to eq(5)
+#   expect(pattern).to eq(/foo/)
+#   expect(name).to eq("John")
+#
+#   # bad (not supported autocorrection)
+#   expect(false).to eq(true)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#24
+class RuboCop::Cop::RSpec::ExpectActual < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#57
+  def expect_literal(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#68
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#98
+  def complex_literal?(node); end
+
+  # This is not implemented using a NodePattern because it seems
+  # to not be able to match against an explicit (nil) sexp
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#90
+  def literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#94
+  def simple_literal?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#44
+RuboCop::Cop::RSpec::ExpectActual::COMPLEX_LITERALS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#54
+RuboCop::Cop::RSpec::ExpectActual::CORRECTABLE_MATCHERS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#27
+RuboCop::Cop::RSpec::ExpectActual::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#29
+RuboCop::Cop::RSpec::ExpectActual::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#31
+RuboCop::Cop::RSpec::ExpectActual::SIMPLE_LITERALS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_actual.rb#53
+RuboCop::Cop::RSpec::ExpectActual::SKIPPED_MATCHERS = T.let(T.unsafe(nil), Array)
+
+# Checks for consistent style of change matcher.
+#
+# Enforces either passing object and attribute as arguments to the matcher
+# or passing a block that reads the attribute value.
+#
+# This cop can be configured using the `EnforcedStyle` option.
+#
+# @example `EnforcedStyle: method_call` (default)
+#   # bad
+#   expect { run }.to change { Foo.bar }
+#   expect { run }.to change { foo.baz }
+#
+#   # good
+#   expect { run }.to change(Foo, :bar)
+#   expect { run }.to change(foo, :baz)
+#   # also good when there are arguments or chained method calls
+#   expect { run }.to change { Foo.bar(:count) }
+#   expect { run }.to change { user.reload.name }
+# @example `EnforcedStyle: block`
+#   # bad
+#   expect { run }.to change(Foo, :bar)
+#
+#   # good
+#   expect { run }.to change { Foo.bar }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#32
+class RuboCop::Cop::RSpec::ExpectChange < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#41
+  def expect_change_with_arguments(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#46
+  def expect_change_with_block(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#72
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#60
+  def on_send(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#36
+RuboCop::Cop::RSpec::ExpectChange::MSG_BLOCK = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#37
+RuboCop::Cop::RSpec::ExpectChange::MSG_CALL = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_change.rb#38
+RuboCop::Cop::RSpec::ExpectChange::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Do not use `expect` in hooks such as `before`.
+#
+# @example
+#   # bad
+#   before do
+#   expect(something).to eq 'foo'
+#   end
+#
+#   # bad
+#   after do
+#   expect_any_instance_of(Something).to receive(:foo)
+#   end
+#
+#   # good
+#   it do
+#   expect(something).to eq 'foo'
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_hook.rb#24
+class RuboCop::Cop::RSpec::ExpectInHook < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_hook.rb#28
+  def expectation(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_hook.rb#30
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_hook.rb#30
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_hook.rb#44
+  def message(expect, hook); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_hook.rb#25
+RuboCop::Cop::RSpec::ExpectInHook::MSG = T.let(T.unsafe(nil), String)
+
+# Do not use `expect` in let.
+#
+# @example
+#   # bad
+#   let(:foo) do
+#   expect(something).to eq 'foo'
+#   end
+#
+#   # good
+#   it do
+#   expect(something).to eq 'foo'
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_let.rb#19
+class RuboCop::Cop::RSpec::ExpectInLet < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_let.rb#23
+  def expectation(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_let.rb#25
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_let.rb#36
+  def message(expect); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_in_let.rb#20
+RuboCop::Cop::RSpec::ExpectInLet::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for opportunities to use `expect { ... }.to output`.
+#
+# @example
+#   # bad
+#   $stdout = StringIO.new
+#   my_app.print_report
+#   $stdout = STDOUT
+#   expect($stdout.string).to eq('Hello World')
+#
+#   # good
+#   expect { my_app.print_report }.to output('Hello World').to_stdout
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_output.rb#18
+class RuboCop::Cop::RSpec::ExpectOutput < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_output.rb#22
+  def on_gvasgn(node); end
+
+  private
+
+  # Detect if we are inside the scope of a single example
+  #
+  # We want to encourage using `expect { ... }.to output` so
+  # we only care about situations where you would replace with
+  # an expectation. Therefore, assignments to stderr or stdout
+  # within a `before(:all)` or otherwise outside of an example
+  # don't matter.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/expect_output.rb#40
+  def inside_example_scope?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/expect_output.rb#19
+RuboCop::Cop::RSpec::ExpectOutput::MSG = T.let(T.unsafe(nil), String)
+
+# A helper for `explicit` style
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#121
+module RuboCop::Cop::RSpec::ExplicitHelper
+  include ::RuboCop::RSpec::Language
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#182
+  def predicate_matcher?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#195
+  def predicate_matcher_block?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#135
+  def allowed_explicit_matchers; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#139
+  def check_explicit(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#219
+  def corrector_explicit(corrector, to_node, actual, matcher, block_child); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#175
+  def heredoc_argument?(matcher); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#213
+  def message_explicit(matcher); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#226
+  def move_predicate(corrector, actual, matcher, block_child); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#204
+  def predicate_matcher_name?(name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#162
+  def replaceable_matcher?(matcher); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#255
+  def replacement_matcher(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#237
+  def to_predicate_method(matcher); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#171
+  def uncorrectable_matcher?(node, matcher); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#127
+RuboCop::Cop::RSpec::ExplicitHelper::BUILT_IN_MATCHERS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#125
+RuboCop::Cop::RSpec::ExplicitHelper::MSG_EXPLICIT = T.let(T.unsafe(nil), String)
+
+# Help methods for file.
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/file_help.rb#7
+module RuboCop::Cop::RSpec::FileHelp
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/file_help.rb#8
+  def expanded_file_path; end
+end
+
+# Helps find the true end location of nodes which might contain heredocs.
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/final_end_location.rb#7
+module RuboCop::Cop::RSpec::FinalEndLocation
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/final_end_location.rb#8
+  def final_end_location(start_node); end
+end
+
+# Checks if examples are focused.
+#
+# This cop does not support autocorrection in some cases.
+#
+# @example
+#   # bad
+#   describe MyClass, focus: true do
+#   end
+#
+#   describe MyClass, :focus do
+#   end
+#
+#   fdescribe MyClass do
+#   end
+#
+#   # good
+#   describe MyClass do
+#   end
+#
+#   # bad
+#   fdescribe 'test' do; end
+#
+#   # good
+#   describe 'test' do; end
+#
+#   # bad
+#   fdescribe 'test' do; end
+#
+#   # good
+#   describe 'test' do; end
+#
+#   # bad
+#   shared_examples 'test', focus: true do; end
+#
+#   # good
+#   shared_examples 'test' do; end
+#
+#   # bad
+#   shared_context 'test', focus: true do; end
+#
+#   # good
+#   shared_context 'test' do; end
+#
+#   # bad (does not support autocorrection)
+#   focus 'test' do; end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#52
+class RuboCop::Cop::RSpec::Focus < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#59
+  def focusable_selector?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#77
+  def focused_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#71
+  def metadata(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#81
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#110
+  def correct_send(corrector, focus); end
+
+  # @yield [node]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#97
+  def focus_metadata(node, &block); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#103
+  def with_surrounding(focus); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/focus.rb#56
+RuboCop::Cop::RSpec::Focus::MSG = T.let(T.unsafe(nil), String)
+
+# Checks the arguments passed to `before`, `around`, and `after`.
+#
+# This cop checks for consistent style when specifying RSpec
+# hooks which run for each example. There are three supported
+# styles: "implicit", "each", and "example." All styles have
+# the same behavior.
+#
+# @example `EnforcedStyle: implicit` (default)
+#   # bad
+#   before(:each) do
+#   # ...
+#   end
+#
+#   # bad
+#   before(:example) do
+#   # ...
+#   end
+#
+#   # good
+#   before do
+#   # ...
+#   end
+# @example `EnforcedStyle: each`
+#   # bad
+#   before(:example) do
+#   # ...
+#   end
+#
+#   # bad
+#   before do
+#   # ...
+#   end
+#
+#   # good
+#   before(:each) do
+#   # ...
+#   end
+# @example `EnforcedStyle: example`
+#   # bad
+#   before(:each) do
+#   # ...
+#   end
+#
+#   # bad
+#   before do
+#   # ...
+#   end
+#
+#   # good
+#   before(:example) do
+#   # ...
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#61
+class RuboCop::Cop::RSpec::HookArgument < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#78
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#78
+  def on_numblock(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#69
+  def scoped_hook(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#74
+  def unscoped_hook(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#95
+  def autocorrect(corrector, _node, method_send); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#102
+  def check_implicit(method_send); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#116
+  def explicit_message(scope); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#128
+  def hook(node, &block); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#124
+  def implicit_style?; end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#66
+RuboCop::Cop::RSpec::HookArgument::EXPLICIT_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/hook_argument.rb#65
+RuboCop::Cop::RSpec::HookArgument::IMPLICIT_MSG = T.let(T.unsafe(nil), String)
+
+# Checks for before/around/after hooks that come after an example.
+#
+# @example
+#   # bad
+#   it 'checks what foo does' do
+#   expect(foo).to be
+#   end
+#
+#   before { prepare }
+#   after { clean_up }
+#
+#   # good
+#   before { prepare }
+#   after { clean_up }
+#
+#   it 'checks what foo does' do
+#   expect(foo).to be
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#25
+class RuboCop::Cop::RSpec::HooksBeforeExamples < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#31
+  def example_or_group?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#41
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#41
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#73
+  def autocorrect(corrector, node, first_example); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#55
+  def check_hooks(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#69
+  def find_first_example(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#51
+  def multiline_block?(block); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/hooks_before_examples.rb#28
+RuboCop::Cop::RSpec::HooksBeforeExamples::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for equality assertions with identical expressions on both sides.
+#
+# @example
+#   # bad
+#   expect(foo.bar).to eq(foo.bar)
+#   expect(foo.bar).to eql(foo.bar)
+#
+#   # good
+#   expect(foo.bar).to eq(2)
+#   expect(foo.bar).to eql(2)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/identical_equality_assertion.rb#17
+class RuboCop::Cop::RSpec::IdenticalEqualityAssertion < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/identical_equality_assertion.rb#23
+  def equality_check?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/identical_equality_assertion.rb#29
+  def on_send(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/identical_equality_assertion.rb#18
+RuboCop::Cop::RSpec::IdenticalEqualityAssertion::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/identical_equality_assertion.rb#20
+RuboCop::Cop::RSpec::IdenticalEqualityAssertion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Check that implicit block expectation syntax is not used.
+#
+# Prefer using explicit block expectations.
+#
+# @example
+#   # bad
+#   subject { -> { do_something } }
+#   it { is_expected.to change(something).to(new_value) }
+#
+#   # good
+#   it 'changes something to a new value' do
+#   expect { do_something }.to change(something).to(new_value)
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#20
+class RuboCop::Cop::RSpec::ImplicitBlockExpectation < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#36
+  def implicit_expect(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#25
+  def lambda?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#33
+  def lambda_subject?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#40
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#62
+  def find_subject(block_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#58
+  def multi_statement_example_group?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#49
+  def nearest_subject(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#21
+RuboCop::Cop::RSpec::ImplicitBlockExpectation::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_block_expectation.rb#22
+RuboCop::Cop::RSpec::ImplicitBlockExpectation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Check that a consistent implicit expectation style is used.
+#
+# This cop can be configured using the `EnforcedStyle` option
+# and supports the `--auto-gen-config` flag.
+#
+# @example `EnforcedStyle: is_expected` (default)
+#   # bad
+#   it { should be_truthy }
+#
+#   # good
+#   it { is_expected.to be_truthy }
+# @example `EnforcedStyle: should`
+#   # bad
+#   it { is_expected.to be_truthy }
+#
+#   # good
+#   it { should be_truthy }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#25
+class RuboCop::Cop::RSpec::ImplicitExpect < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#34
+  def implicit_expect(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#49
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#78
+  def is_expected_range(source_map); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#69
+  def offending_expect(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#86
+  def offense_message(offending_source); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#94
+  def replacement_source(offending_source); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#47
+RuboCop::Cop::RSpec::ImplicitExpect::ENFORCED_REPLACEMENTS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#29
+RuboCop::Cop::RSpec::ImplicitExpect::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_expect.rb#31
+RuboCop::Cop::RSpec::ImplicitExpect::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for usage of implicit subject (`is_expected` / `should`).
+#
+# This cop can be configured using the `EnforcedStyle` option
+#
+# @example `EnforcedStyle: single_line_only` (default)
+#   # bad
+#   it do
+#   is_expected.to be_truthy
+#   end
+#
+#   # good
+#   it { is_expected.to be_truthy }
+#   it do
+#   expect(subject).to be_truthy
+#   end
+# @example `EnforcedStyle: single_statement_only`
+#   # bad
+#   it do
+#   foo = 1
+#   is_expected.to be_truthy
+#   end
+#
+#   # good
+#   it do
+#   foo = 1
+#   expect(subject).to be_truthy
+#   end
+#   it do
+#   is_expected.to be_truthy
+#   end
+# @example `EnforcedStyle: disallow`
+#   # bad
+#   it { is_expected.to be_truthy }
+#
+#   # good
+#   it { expect(subject).to be_truthy }
+# @example `EnforcedStyle: require_implicit`
+#   # bad
+#   it { expect(subject).to be_truthy }
+#
+#   # good
+#   it { is_expected.to be_truthy }
+#
+#   # bad
+#   it do
+#   expect(subject).to be_truthy
+#   end
+#
+#   # good
+#   it do
+#   is_expected.to be_truthy
+#   end
+#
+#   # good
+#   it { expect(named_subject).to be_truthy }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#65
+class RuboCop::Cop::RSpec::ImplicitSubject < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#81
+  def explicit_unnamed_subject?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#86
+  def implicit_subject?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#90
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#100
+  def autocorrect(corrector, node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#159
+  def example_of(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#135
+  def implicit_subject_in_non_its?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#139
+  def implicit_subject_in_non_its_and_non_single_line?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#143
+  def implicit_subject_in_non_its_and_non_single_statement?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#122
+  def invalid?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#147
+  def its?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#113
+  def message(_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#151
+  def single_line?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#155
+  def single_statement?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#69
+RuboCop::Cop::RSpec::ImplicitSubject::MSG_REQUIRE_EXPLICIT = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#71
+RuboCop::Cop::RSpec::ImplicitSubject::MSG_REQUIRE_IMPLICIT = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/implicit_subject.rb#73
+RuboCop::Cop::RSpec::ImplicitSubject::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Do not set up test data using indexes (e.g., `item_1`, `item_2`).
+#
+# It makes reading the test harder because it's not clear what exactly
+# is tested by this particular example.
+#
+# The configurable options `AllowedIdentifiers` and `AllowedPatterns`
+# will also read those set in `Naming/VariableNumber`.
+#
+# @example `Max: 1 (default)`
+#   # bad
+#   let(:item_1) { create(:item) }
+#   let(:item_2) { create(:item) }
+#
+#   let(:item1) { create(:item) }
+#   let(:item2) { create(:item) }
+#
+#   # good
+#
+#   let(:visible_item) { create(:item, visible: true) }
+#   let(:invisible_item) { create(:item, visible: false) }
+# @example `Max: 2`
+#   # bad
+#   let(:item_1) { create(:item) }
+#   let(:item_2) { create(:item) }
+#   let(:item_3) { create(:item) }
+#
+#   # good
+#   let(:item_1) { create(:item) }
+#   let(:item_2) { create(:item) }
+# @example `AllowedIdentifiers: ['item_1', 'item_2']`
+#   # good
+#   let(:item_1) { create(:item) }
+#   let(:item_2) { create(:item) }
+# @example `AllowedPatterns: ['item']`
+#   # good
+#   let(:item_1) { create(:item) }
+#   let(:item_2) { create(:item) }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#47
+class RuboCop::Cop::RSpec::IndexedLet < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::AllowedIdentifiers
+  include ::RuboCop::Cop::AllowedPattern
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#55
+  def let_name(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#62
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#105
+  def allowed_identifiers; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#99
+  def cop_config_patterns_values; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#79
+  def filter_indexed_lets(candidates); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#88
+  def indexed_let?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#95
+  def let_name_stripped_index(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#77
+RuboCop::Cop::RSpec::IndexedLet::INDEX_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#51
+RuboCop::Cop::RSpec::IndexedLet::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/indexed_let.rb#76
+RuboCop::Cop::RSpec::IndexedLet::SUFFIX_INDEX_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# A helper for `inflected` style
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#7
+module RuboCop::Cop::RSpec::InflectedHelper
+  include ::RuboCop::RSpec::Language
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#39
+  def be_bool?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#44
+  def be_boolthy?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#29
+  def predicate_in_actual?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#48
+  def boolean_matcher?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#16
+  def check_inflected(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#60
+  def message_inflected(predicate); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#56
+  def predicate?(sym); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#85
+  def remove_predicate(corrector, predicate); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#96
+  def rewrite_matcher(corrector, predicate, matcher); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#67
+  def to_predicate_matcher(name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#107
+  def true?(to_symbol, matcher); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#11
+RuboCop::Cop::RSpec::InflectedHelper::MSG_INFLECTED = T.let(T.unsafe(nil), String)
+
+# Helps you identify whether a given node
+# is within an example group or not.
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/inside_example_group.rb#8
+module RuboCop::Cop::RSpec::InsideExampleGroup
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/inside_example_group.rb#19
+  def example_group_root?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/inside_example_group.rb#23
+  def example_group_root_with_siblings?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/inside_example_group.rb#11
+  def inside_example_group?(node); end
+end
+
+# Checks for `instance_double` used with `have_received`.
+#
+# @example
+#   # bad
+#   it do
+#   foo = instance_double(Foo).as_null_object
+#   expect(foo).to have_received(:bar)
+#   end
+#
+#   # good
+#   it do
+#   foo = instance_spy(Foo)
+#   expect(foo).to have_received(:bar)
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/instance_spy.rb#21
+class RuboCop::Cop::RSpec::InstanceSpy < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_spy.rb#36
+  def have_received_usage(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_spy.rb#28
+  def null_double(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_spy.rb#45
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_spy.rb#61
+  def autocorrect(corrector, node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/instance_spy.rb#24
+RuboCop::Cop::RSpec::InstanceSpy::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for instance variable usage in specs.
+#
+# This cop can be configured with the option `AssignmentOnly` which
+# will configure the cop to only register offenses on instance
+# variable usage if the instance variable is also assigned within
+# the spec
+#
+# @example
+#   # bad
+#   describe MyClass do
+#   before { @foo = [] }
+#   it { expect(@foo).to be_empty }
+#   end
+#
+#   # good
+#   describe MyClass do
+#   let(:foo) { [] }
+#   it { expect(foo).to be_empty }
+#   end
+# @example with AssignmentOnly configuration
+#   # rubocop.yml
+#   # RSpec/InstanceVariable:
+#   #   AssignmentOnly: true
+#
+#   # bad
+#   describe MyClass do
+#   before { @foo = [] }
+#   it { expect(@foo).to be_empty }
+#   end
+#
+#   # allowed
+#   describe MyClass do
+#   it { expect(@foo).to be_empty }
+#   end
+#
+#   # good
+#   describe MyClass do
+#   let(:foo) { [] }
+#   it { expect(foo).to be_empty }
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#48
+class RuboCop::Cop::RSpec::InstanceVariable < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::TopLevelGroup
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#60
+  def custom_matcher?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#55
+  def dynamic_class?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#71
+  def ivar_assigned?(param0, param1); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#68
+  def ivar_usage(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#73
+  def on_top_level_group(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#90
+  def assignment_only?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#84
+  def valid_usage?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/instance_variable.rb#51
+RuboCop::Cop::RSpec::InstanceVariable::MSG = T.let(T.unsafe(nil), String)
+
+# Check for `specify` with `is_expected` and one-liner expectations.
+#
+# @example
+#   # bad
+#   specify { is_expected.to be_truthy }
+#
+#   # good
+#   it { is_expected.to be_truthy }
+#
+#   # good
+#   specify do
+#   # ...
+#   end
+#   specify { expect(sqrt(4)).to eq(2) }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/is_expected_specify.rb#21
+class RuboCop::Cop::RSpec::IsExpectedSpecify < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/is_expected_specify.rb#29
+  def offense?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/is_expected_specify.rb#33
+  def on_send(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/is_expected_specify.rb#25
+RuboCop::Cop::RSpec::IsExpectedSpecify::IS_EXPECTED_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/is_expected_specify.rb#26
+RuboCop::Cop::RSpec::IsExpectedSpecify::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/is_expected_specify.rb#24
+RuboCop::Cop::RSpec::IsExpectedSpecify::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks that only one `it_behaves_like` style is used.
+#
+# @example `EnforcedStyle: it_behaves_like` (default)
+#   # bad
+#   it_should_behave_like 'a foo'
+#
+#   # good
+#   it_behaves_like 'a foo'
+# @example `EnforcedStyle: it_should_behave_like`
+#   # bad
+#   it_behaves_like 'a foo'
+#
+#   # good
+#   it_should_behave_like 'a foo'
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/it_behaves_like.rb#22
+class RuboCop::Cop::RSpec::ItBehavesLike < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/it_behaves_like.rb#31
+  def example_inclusion_offense(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/it_behaves_like.rb#33
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/it_behaves_like.rb#43
+  def message(_node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/it_behaves_like.rb#26
+RuboCop::Cop::RSpec::ItBehavesLike::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/it_behaves_like.rb#28
+RuboCop::Cop::RSpec::ItBehavesLike::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Check that `all` matcher is used instead of iterating over an array.
+#
+# @example
+#   # bad
+#   it 'validates users' do
+#   [user1, user2, user3].each { |user| expect(user).to be_valid }
+#   end
+#
+#   # good
+#   it 'validates users' do
+#   expect([user1, user2, user3]).to all(be_valid)
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#19
+class RuboCop::Cop::RSpec::IteratedExpectation < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#24
+  def each?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#33
+  def each_numblock?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#40
+  def expectation?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#44
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#52
+  def on_numblock(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#66
+  def only_expectations?(body, arg); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#62
+  def single_expectation?(body, arg); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/iterated_expectation.rb#20
+RuboCop::Cop::RSpec::IteratedExpectation::MSG = T.let(T.unsafe(nil), String)
+
+# Enforce that subject is the first definition in the test.
+#
+# @example
+#   # bad
+#   let(:params) { blah }
+#   subject { described_class.new(params) }
+#
+#   before { do_something }
+#   subject { described_class.new(params) }
+#
+#   it { expect_something }
+#   subject { described_class.new(params) }
+#   it { expect_something_else }
+#
+#   # good
+#   subject { described_class.new(params) }
+#   let(:params) { blah }
+#
+#   # good
+#   subject { described_class.new(params) }
+#   before { do_something }
+#
+#   # good
+#   subject { described_class.new(params) }
+#   it { expect_something }
+#   it { expect_something_else }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#34
+class RuboCop::Cop::RSpec::LeadingSubject < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::InsideExampleGroup
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#40
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#70
+  def autocorrect(corrector, node, sibling); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#49
+  def check_previous_nodes(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#76
+  def offending?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#58
+  def offending_node(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#66
+  def parent(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/leading_subject.rb#38
+RuboCop::Cop::RSpec::LeadingSubject::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that no class, module, or constant is declared.
+#
+# Constants, including classes and modules, when declared in a block
+# scope, are defined in global namespace, and leak between examples.
+#
+# If several examples may define a `DummyClass`, instead of being a
+# blank slate class as it will be in the first example, subsequent
+# examples will be reopening it and modifying its behavior in
+# unpredictable ways.
+# Even worse when a class that exists in the codebase is reopened.
+#
+# Anonymous classes are fine, since they don't result in global
+# namespace name clashes.
+#
+# @example Constants leak between examples
+#   # bad
+#   describe SomeClass do
+#   OtherClass = Struct.new
+#   CONSTANT_HERE = 'I leak into global namespace'
+#   end
+#
+#   # good
+#   describe SomeClass do
+#   before do
+#   stub_const('OtherClass', Struct.new)
+#   stub_const('CONSTANT_HERE', 'I only exist during this example')
+#   end
+#   end
+# @example
+#   # bad
+#   describe SomeClass do
+#   class FooClass < described_class
+#   def double_that
+#   some_base_method * 2
+#   end
+#   end
+#
+#   it { expect(FooClass.new.double_that).to eq(4) }
+#   end
+#
+#   # good - anonymous class, no constant needs to be defined
+#   describe SomeClass do
+#   let(:foo_class) do
+#   Class.new(described_class) do
+#   def double_that
+#   some_base_method * 2
+#   end
+#   end
+#   end
+#
+#   it { expect(foo_class.new.double_that).to eq(4) }
+#   end
+#
+#   # good - constant is stubbed
+#   describe SomeClass do
+#   before do
+#   foo_class = Class.new(described_class) do
+#   def do_something
+#   end
+#   end
+#   stub_const('FooClass', foo_class)
+#   end
+#
+#   it { expect(FooClass.new.double_that).to eq(4) }
+#   end
+# @example
+#   # bad
+#   describe SomeClass do
+#   module SomeModule
+#   class SomeClass
+#   def do_something
+#   end
+#   end
+#   end
+#   end
+#
+#   # good
+#   describe SomeClass do
+#   before do
+#   foo_class = Class.new(described_class) do
+#   def do_something
+#   end
+#   end
+#   stub_const('SomeModule::SomeClass', foo_class)
+#   end
+#   end
+# @see https://rspec.info/features/3-12/rspec-mocks/mutating-constants
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#96
+class RuboCop::Cop::RSpec::LeakyConstantDeclaration < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#101
+  def on_casgn(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#107
+  def on_class(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#113
+  def on_module(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#121
+  def inside_describe_block?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#98
+RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_CLASS = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#97
+RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_CONST = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/leaky_constant_declaration.rb#99
+RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_MODULE = T.let(T.unsafe(nil), String)
+
+# Checks for `let` definitions that come after an example.
+#
+# @example
+#   # bad
+#   let(:foo) { bar }
+#
+#   it 'checks what foo does' do
+#   expect(foo).to be
+#   end
+#
+#   let(:some) { other }
+#
+#   it 'checks what some does' do
+#   expect(some).to be
+#   end
+#
+#   # good
+#   let(:foo) { bar }
+#   let(:some) { other }
+#
+#   it 'checks what foo does' do
+#   expect(foo).to be
+#   end
+#
+#   it 'checks what some does' do
+#   expect(some).to be
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#33
+class RuboCop::Cop::RSpec::LetBeforeExamples < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#39
+  def example_or_group?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#47
+  def include_examples?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#58
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#93
+  def autocorrect(corrector, node, first_example); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#74
+  def check_let_declarations(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#66
+  def example_group_with_include_examples?(body); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#89
+  def find_first_example(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#70
+  def multiline_block?(block); end
+
+  class << self
+    # source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#54
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/let_before_examples.rb#36
+RuboCop::Cop::RSpec::LetBeforeExamples::MSG = T.let(T.unsafe(nil), String)
+
+# Checks unreferenced `let!` calls being used for test setup.
+#
+# @example
+#   # bad
+#   let!(:my_widget) { create(:widget) }
+#
+#   it 'counts widgets' do
+#   expect(Widget.count).to eq(1)
+#   end
+#
+#   # good
+#   it 'counts widgets' do
+#   create(:widget)
+#   expect(Widget.count).to eq(1)
+#   end
+#
+#   # good
+#   before { create(:widget) }
+#
+#   it 'counts widgets' do
+#   expect(Widget.count).to eq(1)
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#28
+class RuboCop::Cop::RSpec::LetSetup < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#32
+  def example_or_shared_group_or_including?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#40
+  def let_bang(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#48
+  def method_called?(param0, param1); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#50
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#66
+  def child_let_bang(node, &block); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#60
+  def unused_let_bang(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/let_setup.rb#29
+RuboCop::Cop::RSpec::LetSetup::MSG = T.let(T.unsafe(nil), String)
+
+# Helper methods to location.
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/location_help.rb#7
+module RuboCop::Cop::RSpec::LocationHelp
+  private
+
+  # @example
+  #   foo 1, 2
+  #   ^^^^^
+  # @param node [RuboCop::AST::SendNode]
+  # @return [Parser::Source::Range]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/location_help.rb#15
+  def arguments_with_whitespace(node); end
+
+  # @example
+  #   foo { bar }
+  #   ^^^^^^^^
+  # @param node [RuboCop::AST::SendNode]
+  # @return [Parser::Source::Range]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/location_help.rb#26
+  def block_with_whitespace(node); end
+
+  class << self
+    # @example
+    #   foo 1, 2
+    #   ^^^^^
+    # @param node [RuboCop::AST::SendNode]
+    # @return [Parser::Source::Range]
+    #
+    # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/location_help.rb#15
+    def arguments_with_whitespace(node); end
+
+    # @example
+    #   foo { bar }
+    #   ^^^^^^^^
+    # @param node [RuboCop::AST::SendNode]
+    # @return [Parser::Source::Range]
+    #
+    # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/location_help.rb#26
+    def block_with_whitespace(node); end
+  end
+end
+
+# Checks where `match_array` is used.
+#
+# This cop checks for the following:
+# - Prefer `contain_exactly` when matching an array with values.
+# - Prefer `eq` when using `match_array` with an empty array literal.
+#
+# @example
+#   # bad
+#   it { is_expected.to match_array([content1, content2]) }
+#
+#   # good
+#   it { is_expected.to contain_exactly(content1, content2) }
+#
+#   # good
+#   it { is_expected.to match_array([content] + array) }
+#
+#   # good
+#   it { is_expected.to match_array(%w(tremble in fear foolish mortals)) }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/match_array.rb#25
+class RuboCop::Cop::RSpec::MatchArray < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/match_array.rb#32
+  def match_array_with_empty_array?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/match_array.rb#36
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/match_array.rb#45
+  def check_populated_array(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/match_array.rb#28
+RuboCop::Cop::RSpec::MatchArray::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/match_array.rb#29
+RuboCop::Cop::RSpec::MatchArray::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Check that chains of messages are not being stubbed.
+#
+# @example
+#   # bad
+#   allow(foo).to receive_message_chain(:bar, :baz).and_return(42)
+#
+#   # good
+#   thing = Thing.new(baz: 42)
+#   allow(foo).to receive(:bar).and_return(thing)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/message_chain.rb#16
+class RuboCop::Cop::RSpec::MessageChain < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/message_chain.rb#20
+  def on_send(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/message_chain.rb#17
+RuboCop::Cop::RSpec::MessageChain::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/message_chain.rb#18
+RuboCop::Cop::RSpec::MessageChain::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for consistent message expectation style.
+#
+# This cop can be configured in your configuration using the
+# `EnforcedStyle` option and supports `--auto-gen-config`.
+#
+# @example `EnforcedStyle: allow` (default)
+#
+#   # bad
+#   expect(foo).to receive(:bar)
+#
+#   # good
+#   allow(foo).to receive(:bar)
+# @example `EnforcedStyle: expect`
+#
+#   # bad
+#   allow(foo).to receive(:bar)
+#
+#   # good
+#   expect(foo).to receive(:bar)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/message_expectation.rb#27
+class RuboCop::Cop::RSpec::MessageExpectation < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/message_expectation.rb#35
+  def message_expectation(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/message_expectation.rb#42
+  def on_send(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/message_expectation.rb#40
+  def receive_message?(param0); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/message_expectation.rb#55
+  def preferred_style?(expectation); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/message_expectation.rb#30
+RuboCop::Cop::RSpec::MessageExpectation::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/message_expectation.rb#32
+RuboCop::Cop::RSpec::MessageExpectation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks that message expectations are set using spies.
+#
+# This cop can be configured in your configuration using the
+# `EnforcedStyle` option and supports `--auto-gen-config`.
+#
+# @example `EnforcedStyle: have_received` (default)
+#
+#   # bad
+#   expect(foo).to receive(:bar)
+#   do_something
+#
+#   # good
+#   allow(foo).to receive(:bar) # or use instance_spy
+#   do_something
+#   expect(foo).to have_received(:bar)
+# @example `EnforcedStyle: receive`
+#
+#   # bad
+#   allow(foo).to receive(:bar)
+#   do_something
+#   expect(foo).to have_received(:bar)
+#
+#   # good
+#   expect(foo).to receive(:bar)
+#   do_something
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#33
+class RuboCop::Cop::RSpec::MessageSpies < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#45
+  def message_expectation(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#54
+  def on_send(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#50
+  def receive_message(param0); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#77
+  def error_message(receiver); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#73
+  def preferred_style?(expectation); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#67
+  def receive_message_matcher(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#38
+RuboCop::Cop::RSpec::MessageSpies::MSG_HAVE_RECEIVED = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#36
+RuboCop::Cop::RSpec::MessageSpies::MSG_RECEIVE = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/message_spies.rb#42
+RuboCop::Cop::RSpec::MessageSpies::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Helper methods to find RSpec metadata.
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#7
+module RuboCop::Cop::RSpec::Metadata
+  include ::RuboCop::RSpec::Language
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#26
+  def metadata_in_block(param0, param1); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#30
+  def on_block(node); end
+
+  # @raise [::NotImplementedError]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#43
+  def on_metadata(_symbols, _hash); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#30
+  def on_numblock(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#21
+  def rspec_configure(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#13
+  def rspec_metadata(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/metadata.rb#49
+  def on_metadata_arguments(metadata_arguments); end
+end
+
+# Use consistent metadata style.
+#
+# This cop does not support autocorrection in the case of
+# `EnforcedStyle: hash` where the trailing metadata type is ambiguous.
+# (e.g. `describe 'Something', :a, b`)
+#
+# @example EnforcedStyle: symbol (default)
+#   # bad
+#   describe 'Something', a: true
+#
+#   # good
+#   describe 'Something', :a
+# @example EnforcedStyle: hash
+#   # bad
+#   describe 'Something', :a
+#
+#   # good
+#   describe 'Something', a: true
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#25
+class RuboCop::Cop::RSpec::MetadataStyle < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RSpec::Metadata
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#33
+  def extract_metadata_hash(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#43
+  def match_ambiguous_trailing_metadata?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#38
+  def match_boolean_metadata_pair?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#47
+  def on_metadata(symbols, hash); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#61
+  def autocorrect_pair(corrector, node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#66
+  def autocorrect_symbol(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#73
+  def bad_metadata_pair?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#77
+  def bad_metadata_symbol?(_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#81
+  def format_symbol_to_pair_source(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#85
+  def insert_pair(corrector, node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#96
+  def insert_pair_as_last_argument(corrector, node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#105
+  def insert_pair_to_empty_hash_metadata(corrector, node, hash_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#112
+  def insert_pair_to_non_empty_hash_metadata(corrector, node, hash_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#119
+  def insert_symbol(corrector, node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#126
+  def message_for_style; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#133
+  def on_metadata_pair(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#141
+  def on_metadata_symbol(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#149
+  def remove_pair(corrector, node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#159
+  def remove_pair_following(corrector, node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#171
+  def remove_pair_preceding(corrector, node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/metadata_style.rb#183
+  def remove_symbol(corrector, node); end
+end
+
+# Checks that the first argument to an example group is not empty.
+#
+# @example
+#   # bad
+#   describe do
+#   end
+#
+#   RSpec.describe do
+#   end
+#
+#   # good
+#   describe TestedClass do
+#   end
+#
+#   describe "A feature example" do
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/missing_example_group_argument.rb#23
+class RuboCop::Cop::RSpec::MissingExampleGroupArgument < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/missing_example_group_argument.rb#26
+  def on_block(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/missing_example_group_argument.rb#24
+RuboCop::Cop::RSpec::MissingExampleGroupArgument::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if `.to`, `not_to` or `to_not` are used.
+#
+# The RSpec::Expectations::ExpectationTarget must use `to`, `not_to` or
+# `to_not` to run. Therefore, this cop checks if other methods are used.
+#
+# @example
+#   # bad
+#   expect(something).kind_of? Foo
+#   is_expected == 42
+#   expect{something}.eq? BarError
+#
+#   # good
+#   expect(something).to be_a Foo
+#   is_expected.to eq 42
+#   expect{something}.to raise_error BarError
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/missing_expectation_target_method.rb#22
+class RuboCop::Cop::RSpec::MissingExpectationTargetMethod < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/missing_expectation_target_method.rb#27
+  def expect?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/missing_expectation_target_method.rb#35
+  def expect_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/missing_expectation_target_method.rb#40
+  def expectation_without_runner?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/missing_expectation_target_method.rb#44
+  def on_send(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/missing_expectation_target_method.rb#23
+RuboCop::Cop::RSpec::MissingExpectationTargetMethod::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/missing_expectation_target_method.rb#24
+RuboCop::Cop::RSpec::MissingExpectationTargetMethod::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for multiple top-level example groups.
+#
+# Multiple descriptions for the same class or module should either
+# be nested or separated into different test files.
+#
+# @example
+#   # bad
+#   describe MyClass, '.do_something' do
+#   end
+#   describe MyClass, '.do_something_else' do
+#   end
+#
+#   # good
+#   describe MyClass do
+#   describe '.do_something' do
+#   end
+#   describe '.do_something_else' do
+#   end
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_describes.rb#26
+class RuboCop::Cop::RSpec::MultipleDescribes < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::TopLevelGroup
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_describes.rb#31
+  def on_top_level_group(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_describes.rb#29
+RuboCop::Cop::RSpec::MultipleDescribes::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if examples contain too many `expect` calls.
+#
+# This cop is configurable using the `Max` option
+# and works with `--auto-gen-config`.
+#
+# @example
+#   # bad
+#   describe UserCreator do
+#   it 'builds a user' do
+#   expect(user.name).to eq("John")
+#   expect(user.age).to eq(22)
+#   end
+#   end
+#
+#   # good
+#   describe UserCreator do
+#   it 'sets the users name' do
+#   expect(user.name).to eq("John")
+#   end
+#
+#   it 'sets the users age' do
+#   expect(user.age).to eq(22)
+#   end
+#   end
+# @example `aggregate_failures: true` (default)
+#   # good - the cop ignores when RSpec aggregates failures
+#   describe UserCreator do
+#   it 'builds a user', :aggregate_failures do
+#   expect(user.name).to eq("John")
+#   expect(user.age).to eq(22)
+#   end
+#   end
+# @example `aggregate_failures: false`
+#   # Detected as an offense
+#   describe UserCreator do
+#   it 'builds a user', aggregate_failures: false do
+#   expect(user.name).to eq("John")
+#   expect(user.age).to eq(22)
+#   end
+#   end
+# @example `Max: 1` (default)
+#   # bad
+#   describe UserCreator do
+#   it 'builds a user' do
+#   expect(user.name).to eq("John")
+#   expect(user.age).to eq(22)
+#   end
+#   end
+# @example `Max: 2`
+#   # good
+#   describe UserCreator do
+#   it 'builds a user' do
+#   expect(user.name).to eq("John")
+#   expect(user.age).to eq(22)
+#   end
+#   end
+# @see http://betterspecs.org/#single Single expectation test
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#69
+class RuboCop::Cop::RSpec::MultipleExpectations < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#78
+  def aggregate_failures?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#89
+  def aggregate_failures_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#86
+  def expect?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop/1.67.0/lib/rubocop/cop/exclude_limit.rb#11
+  def max=(value); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#93
+  def on_block(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#109
+  def example_with_aggregate_failures?(example_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#116
+  def find_aggregate_failures(example_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#121
+  def find_expectation(node, &block); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#132
+  def flag_example(node, expectation_count:); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#143
+  def max_expectations; end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#72
+RuboCop::Cop::RSpec::MultipleExpectations::ANYTHING = T.let(T.unsafe(nil), Proc)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#70
+RuboCop::Cop::RSpec::MultipleExpectations::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_expectations.rb#73
+RuboCop::Cop::RSpec::MultipleExpectations::TRUE_NODE = T.let(T.unsafe(nil), Proc)
+
+# Checks if example groups contain too many `let` and `subject` calls.
+#
+# This cop is configurable using the `Max` option and the `AllowSubject`
+# which will configure the cop to only register offenses on calls to
+# `let` and not calls to `subject`.
+#
+# @example
+#   # bad
+#   describe MyClass do
+#   let(:foo) { [] }
+#   let(:bar) { [] }
+#   let!(:baz) { [] }
+#   let(:qux) { [] }
+#   let(:quux) { [] }
+#   let(:quuz) { {} }
+#   end
+#
+#   describe MyClass do
+#   let(:foo) { [] }
+#   let(:bar) { [] }
+#   let!(:baz) { [] }
+#
+#   context 'when stuff' do
+#   let(:qux) { [] }
+#   let(:quux) { [] }
+#   let(:quuz) { {} }
+#   end
+#   end
+#
+#   # good
+#   describe MyClass do
+#   let(:bar) { [] }
+#   let!(:baz) { [] }
+#   let(:qux) { [] }
+#   let(:quux) { [] }
+#   let(:quuz) { {} }
+#   end
+#
+#   describe MyClass do
+#   context 'when stuff' do
+#   let(:foo) { [] }
+#   let(:bar) { [] }
+#   let!(:booger) { [] }
+#   end
+#
+#   context 'when other stuff' do
+#   let(:qux) { [] }
+#   let(:quux) { [] }
+#   let(:quuz) { {} }
+#   end
+#   end
+# @example when disabling AllowSubject configuration
+#   # rubocop.yml
+#   # RSpec/MultipleMemoizedHelpers:
+#   #   AllowSubject: false
+#
+#   # bad - `subject` counts towards memoized helpers
+#   describe MyClass do
+#   subject { {} }
+#   let(:foo) { [] }
+#   let(:bar) { [] }
+#   let!(:baz) { [] }
+#   let(:qux) { [] }
+#   let(:quux) { [] }
+#   end
+# @example with Max configuration
+#   # rubocop.yml
+#   # RSpec/MultipleMemoizedHelpers:
+#   #   Max: 1
+#
+#   # bad
+#   describe MyClass do
+#   let(:foo) { [] }
+#   let(:bar) { [] }
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#84
+class RuboCop::Cop::RSpec::MultipleMemoizedHelpers < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::Variable
+
+  # source://rubocop/1.67.0/lib/rubocop/cop/exclude_limit.rb#11
+  def max=(value); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#91
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#102
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#111
+  def all_helpers(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#141
+  def allow_subject?; end
+
+  # Returns the value of attribute example_group_memoized_helpers.
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#109
+  def example_group_memoized_helpers; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#116
+  def helpers(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#137
+  def max; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#127
+  def variable_nodes(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#87
+RuboCop::Cop::RSpec::MultipleMemoizedHelpers::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if an example group defines `subject` multiple times.
+#
+# This cop does not support autocorrection in some cases.
+# The autocorrect behavior for this cop depends on the type of
+# duplication:
+#
+#   - If multiple named subjects are defined then this probably indicates
+#     that the overwritten subjects (all subjects except the last
+#     definition) are effectively being used to define helpers. In this
+#     case they are replaced with `let`.
+#
+#   - If multiple unnamed subjects are defined though then this can *only*
+#     be dead code and we remove the overwritten subject definitions.
+#
+#   - If subjects are defined with `subject!` then we don't autocorrect.
+#     This is enough of an edge case that people can just move this to
+#     a `before` hook on their own
+#
+# @example
+#   # bad
+#   describe Foo do
+#   subject(:user) { User.new }
+#   subject(:post) { Post.new }
+#   end
+#
+#   # good
+#   describe Foo do
+#   let(:user) { User.new }
+#   subject(:post) { Post.new }
+#   end
+#
+#   # bad (does not support autocorrection)
+#   describe Foo do
+#   subject!(:user) { User.new }
+#   subject!(:post) { Post.new }
+#   end
+#
+#   # good
+#   describe Foo do
+#   before do
+#   User.new
+#   Post.new
+#   end
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_subjects.rb#51
+class RuboCop::Cop::RSpec::MultipleSubjects < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_subjects.rb#57
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_subjects.rb#71
+  def autocorrect(corrector, subject); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_subjects.rb#81
+  def named_subject?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_subjects.rb#89
+  def remove_autocorrect(corrector, node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_subjects.rb#85
+  def rename_autocorrect(corrector, node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/multiple_subjects.rb#55
+RuboCop::Cop::RSpec::MultipleSubjects::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for explicitly referenced test subjects.
+#
+# RSpec lets you declare an "implicit subject" using `subject { ... }`
+# which allows for tests like `it { is_expected.to be_valid }`.
+# If you need to reference your test subject you should explicitly
+# name it using `subject(:your_subject_name) { ... }`. Your test subjects
+# should be the most important object in your tests so they deserve
+# a descriptive name.
+#
+# This cop can be configured in your configuration using `EnforcedStyle`,
+# and `IgnoreSharedExamples` which will not report offenses for implicit
+# subjects in shared example groups.
+#
+# @example `EnforcedStyle: always` (default)
+#   # bad
+#   RSpec.describe User do
+#   subject { described_class.new }
+#
+#   it 'is valid' do
+#   expect(subject.valid?).to be(true)
+#   end
+#   end
+#
+#   # good
+#   RSpec.describe User do
+#   subject(:user) { described_class.new }
+#
+#   it 'is valid' do
+#   expect(user.valid?).to be(true)
+#   end
+#   end
+#
+#   # also good
+#   RSpec.describe User do
+#   subject(:user) { described_class.new }
+#
+#   it { is_expected.to be_valid }
+#   end
+# @example `EnforcedStyle: named_only`
+#   # bad
+#   RSpec.describe User do
+#   subject(:user) { described_class.new }
+#
+#   it 'is valid' do
+#   expect(subject.valid?).to be(true)
+#   end
+#   end
+#
+#   # good
+#   RSpec.describe User do
+#   subject(:user) { described_class.new }
+#
+#   it 'is valid' do
+#   expect(user.valid?).to be(true)
+#   end
+#   end
+#
+#   # also good
+#   RSpec.describe User do
+#   subject { described_class.new }
+#
+#   it { is_expected.to be_valid }
+#   end
+#
+#   # acceptable
+#   RSpec.describe User do
+#   subject { described_class.new }
+#
+#   it 'is valid' do
+#   expect(subject.valid?).to be(true)
+#   end
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#79
+class RuboCop::Cop::RSpec::NamedSubject < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#85
+  def example_or_hook_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#97
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#90
+  def shared_example?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#95
+  def subject_usage(param0); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#123
+  def allow_explicit_subject?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#127
+  def always?; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#117
+  def check_explicit_subject(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#150
+  def find_subject(block_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#109
+  def ignored_shared_example?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#131
+  def named_only?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#142
+  def nearest_subject(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#136
+  def subject_definition_is_named?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/named_subject.rb#82
+RuboCop::Cop::RSpec::NamedSubject::MSG = T.let(T.unsafe(nil), String)
+
+# Helps to find namespace of the node.
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/namespace.rb#7
+module RuboCop::Cop::RSpec::Namespace
+  private
+
+  # @example
+  #   namespace(node) # => ['A', 'B', 'C']
+  # @param node [RuboCop::AST::Node]
+  # @return [Array<String>]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/namespace.rb#14
+  def namespace(node); end
+end
+
+# Checks for nested example groups.
+#
+# This cop is configurable using the `Max` option
+# and supports `--auto-gen-config`.
+#
+# @example
+#   # bad
+#   context 'when using some feature' do
+#   let(:some)    { :various }
+#   let(:feature) { :setup   }
+#
+#   context 'when user is signed in' do  # flagged by rubocop
+#   let(:user) do
+#   UserCreate.call(user_attributes)
+#   end
+#
+#   let(:user_attributes) do
+#   {
+#   name: 'John',
+#   age:  22,
+#   role: role
+#   }
+#   end
+#
+#   context 'when user is an admin' do # flagged by rubocop
+#   let(:role) { 'admin' }
+#
+#   it 'blah blah'
+#   it 'yada yada'
+#   end
+#   end
+#   end
+#
+#   # good
+#   context 'using some feature as an admin' do
+#   let(:some)    { :various }
+#   let(:feature) { :setup   }
+#
+#   let(:user) do
+#   UserCreate.call(
+#   name: 'John',
+#   age:  22,
+#   role: 'admin'
+#   )
+#   end
+#
+#   it 'blah blah'
+#   it 'yada yada'
+#   end
+# @example `Max: 3` (default)
+#   # bad
+#   describe Foo do
+#   context 'foo' do
+#   context 'bar' do
+#   context 'baz' do # flagged by rubocop
+#   end
+#   end
+#   end
+#   end
+# @example `Max: 2`
+#   # bad
+#   describe Foo do
+#   context 'foo' do
+#   context 'bar' do # flagged by rubocop
+#   context 'baz' do # flagged by rubocop
+#   end
+#   end
+#   end
+#   end
+# @example `AllowedGroups: [] (default)`
+#   describe Foo do # <-- nested groups 1
+#   context 'foo' do # <-- nested groups 2
+#   context 'bar' do # <-- nested groups 3
+#   end
+#   end
+#   end
+# @example `AllowedGroups: [path]`
+#   describe Foo do # <-- nested groups 1
+#   path '/foo' do # <-- nested groups 1 (not counted)
+#   context 'bar' do # <-- nested groups 2
+#   end
+#   end
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#94
+class RuboCop::Cop::RSpec::NestedGroups < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::TopLevelGroup
+
+  # source://rubocop/1.67.0/lib/rubocop/cop/exclude_limit.rb#11
+  def max=(value); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#107
+  def on_top_level_group(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#157
+  def allowed_groups; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#134
+  def count_up_nesting?(node, example_group); end
+
+  # @yield [node, nesting]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#119
+  def find_nested_example_groups(node, nesting: T.unsafe(nil), &block); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#144
+  def max_nesting; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#148
+  def max_nesting_config; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#140
+  def message(nesting); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#99
+RuboCop::Cop::RSpec::NestedGroups::DEPRECATED_MAX_KEY = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#101
+RuboCop::Cop::RSpec::NestedGroups::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/nested_groups.rb#97
+RuboCop::Cop::RSpec::NestedGroups::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if an example contains any expectation.
+#
+# All RSpec's example and expectation methods are covered by default.
+# If you are using your own custom methods,
+# add the following configuration:
+#
+#   RSpec:
+#     Language:
+#       Examples:
+#         Regular:
+#           - custom_it
+#       Expectations:
+#         - custom_expect
+#
+# This cop can be customized with an allowed expectation methods pattern
+# with an `AllowedPatterns` option. ^expect_ and ^assert_ are allowed
+# by default.
+#
+# @example
+#   # bad
+#   it do
+#   a?
+#   end
+#
+#   # good
+#   it do
+#   expect(a?).to be(true)
+#   end
+# @example `AllowedPatterns` configuration
+#
+#   # .rubocop.yml
+#   # RSpec/NoExpectationExample:
+#   #   AllowedPatterns:
+#   #     - ^expect_
+#   #     - ^assert_
+# @example
+#   # bad
+#   it do
+#   not_expect_something
+#   end
+#
+#   # good
+#   it do
+#   expect_something
+#   end
+#
+#   it do
+#   assert_something
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/no_expectation_example.rb#58
+class RuboCop::Cop::RSpec::NoExpectationExample < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::AllowedPattern
+  include ::RuboCop::Cop::RSpec::SkipOrPending
+
+  # @param node [RuboCop::AST::Node]
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/no_expectation_example.rb#74
+  def includes_expectation?(param0); end
+
+  # @param node [RuboCop::AST::Node]
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/no_expectation_example.rb#84
+  def includes_skip_example?(param0); end
+
+  # @param node [RuboCop::AST::BlockNode]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/no_expectation_example.rb#89
+  def on_block(node); end
+
+  # @param node [RuboCop::AST::BlockNode]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/no_expectation_example.rb#89
+  def on_numblock(node); end
+
+  # @param node [RuboCop::AST::Node]
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/no_expectation_example.rb#67
+  def regular_or_focused_example?(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/no_expectation_example.rb#62
+RuboCop::Cop::RSpec::NoExpectationExample::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for consistent method usage for negating expectations.
+#
+# @example `EnforcedStyle: not_to` (default)
+#   # bad
+#   it '...' do
+#   expect(false).to_not be_true
+#   end
+#
+#   # good
+#   it '...' do
+#   expect(false).not_to be_true
+#   end
+# @example `EnforcedStyle: to_not`
+#   # bad
+#   it '...' do
+#   expect(false).not_to be_true
+#   end
+#
+#   # good
+#   it '...' do
+#   expect(false).to_not be_true
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/not_to_not.rb#30
+class RuboCop::Cop::RSpec::NotToNot < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/not_to_not.rb#38
+  def not_to_not_offense(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/not_to_not.rb#40
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/not_to_not.rb#50
+  def message(_node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/not_to_not.rb#34
+RuboCop::Cop::RSpec::NotToNot::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/not_to_not.rb#35
+RuboCop::Cop::RSpec::NotToNot::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks if there is a let/subject that overwrites an existing one.
+#
+# @example
+#   # bad
+#   let(:foo) { bar }
+#   let(:foo) { baz }
+#
+#   subject(:foo) { bar }
+#   let(:foo) { baz }
+#
+#   let(:foo) { bar }
+#   let!(:foo) { baz }
+#
+#   # good
+#   subject(:test) { something }
+#   let(:foo) { bar }
+#   let(:baz) { baz }
+#   let!(:other) { other }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/overwriting_setup.rb#25
+class RuboCop::Cop::RSpec::OverwritingSetup < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/overwriting_setup.rb#34
+  def first_argument_name(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/overwriting_setup.rb#36
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/overwriting_setup.rb#29
+  def setup?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/overwriting_setup.rb#64
+  def common_setup?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/overwriting_setup.rb#49
+  def find_duplicates(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/overwriting_setup.rb#26
+RuboCop::Cop::RSpec::OverwritingSetup::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for any pending or skipped examples.
+#
+# @example
+#   # bad
+#   describe MyClass do
+#   it "should be true"
+#   end
+#
+#   describe MyClass do
+#   it "should be true", skip: true do
+#   expect(1).to eq(2)
+#   end
+#   end
+#
+#   describe MyClass do
+#   it "should be true" do
+#   pending
+#   end
+#   end
+#
+#   describe MyClass do
+#   xit "should be true" do
+#   end
+#   end
+#
+#   # good
+#   describe MyClass do
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#35
+class RuboCop::Cop::RSpec::Pending < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::SkipOrPending
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#61
+  def on_send(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#54
+  def pending_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#41
+  def skippable?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#49
+  def skippable_example?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#69
+  def skipped?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#74
+  def skipped_regular_example_without_body?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/pending.rb#38
+RuboCop::Cop::RSpec::Pending::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for pending or skipped examples without reason.
+#
+# @example
+#   # bad
+#   pending 'does something' do
+#   end
+#
+#   # bad
+#   it 'does something', :pending do
+#   end
+#
+#   # bad
+#   it 'does something' do
+#   pending
+#   end
+#
+#   # bad
+#   xdescribe 'something' do
+#   end
+#
+#   # bad
+#   skip 'does something' do
+#   end
+#
+#   # bad
+#   it 'does something', :skip do
+#   end
+#
+#   # bad
+#   it 'does something' do
+#   skip
+#   end
+#
+#   # bad
+#   it 'does something'
+#
+#   # good
+#   it 'does something' do
+#   pending 'reason'
+#   end
+#
+#   # good
+#   it 'does something' do
+#   skip 'reason'
+#   end
+#
+#   # good
+#   it 'does something', pending: 'reason' do
+#   end
+#
+#   # good
+#   it 'does something', skip: 'reason' do
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#59
+class RuboCop::Cop::RSpec::PendingWithoutReason < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#82
+  def metadata_without_reason?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#102
+  def on_send(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#98
+  def pending_step_without_reason?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#93
+  def skipped_by_example_group_method?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#72
+  def skipped_by_example_method?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#77
+  def skipped_by_example_method_with_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#63
+  def skipped_in_example?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#123
+  def block_node_example_group?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#135
+  def on_pending_by_metadata(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#151
+  def on_skipped_by_example_group_method(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#141
+  def on_skipped_by_example_method(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#129
+  def on_skipped_by_in_example_method(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#116
+  def parent_node(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/pending_without_reason.rb#60
+RuboCop::Cop::RSpec::PendingWithoutReason::MSG = T.let(T.unsafe(nil), String)
+
+# Prefer using predicate matcher over using predicate method directly.
+#
+# RSpec defines magic matchers for predicate methods.
+# This cop recommends to use the predicate matcher instead of using
+# predicate method directly.
+#
+# @example Strict: true, EnforcedStyle: inflected (default)
+#   # bad
+#   expect(foo.something?).to be_truthy
+#
+#   # good
+#   expect(foo).to be_something
+#
+#   # also good - It checks "true" strictly.
+#   expect(foo.something?).to be(true)
+# @example Strict: false, EnforcedStyle: inflected
+#   # bad
+#   expect(foo.something?).to be_truthy
+#   expect(foo.something?).to be(true)
+#
+#   # good
+#   expect(foo).to be_something
+# @example Strict: true, EnforcedStyle: explicit
+#   # bad
+#   expect(foo).to be_something
+#
+#   # good - the above code is rewritten to it by this cop
+#   expect(foo.something?).to be(true)
+#
+#   # bad - no autocorrect
+#   expect(foo)
+#   .to be_something(<<~TEXT)
+#   bar
+#   TEXT
+#
+#   # good
+#   expect(foo.something?(<<~TEXT)).to be(true)
+#   bar
+#   TEXT
+# @example Strict: false, EnforcedStyle: explicit
+#   # bad
+#   expect(foo).to be_something
+#
+#   # good - the above code is rewritten to it by this cop
+#   expect(foo.something?).to be_truthy
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#318
+class RuboCop::Cop::RSpec::PredicateMatcher < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RSpec::InflectedHelper
+  include ::RuboCop::Cop::RSpec::ExplicitHelper
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#335
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#326
+  def on_send(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/predicate_matcher.rb#324
+RuboCop::Cop::RSpec::PredicateMatcher::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Check for `once` and `twice` receive counts matchers usage.
+#
+# @example
+#   # bad
+#   expect(foo).to receive(:bar).exactly(1).times
+#   expect(foo).to receive(:bar).exactly(2).times
+#   expect(foo).to receive(:bar).at_least(1).times
+#   expect(foo).to receive(:bar).at_least(2).times
+#   expect(foo).to receive(:bar).at_most(1).times
+#   expect(foo).to receive(:bar).at_most(2).times
+#
+#   # good
+#   expect(foo).to receive(:bar).once
+#   expect(foo).to receive(:bar).twice
+#   expect(foo).to receive(:bar).at_least(:once)
+#   expect(foo).to receive(:bar).at_least(:twice)
+#   expect(foo).to receive(:bar).at_most(:once)
+#   expect(foo).to receive(:bar).at_most(:twice).times
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#25
+class RuboCop::Cop::RSpec::ReceiveCounts < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#40
+  def on_send(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#33
+  def receive_counts(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#38
+  def stub?(param0); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#55
+  def autocorrect(corrector, node, range); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#72
+  def matcher_for(method, count); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#64
+  def message_for(node, source); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#81
+  def range(node, offending_node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#28
+RuboCop::Cop::RSpec::ReceiveCounts::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_counts.rb#30
+RuboCop::Cop::RSpec::ReceiveCounts::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for multiple messages stubbed on the same object.
+#
+# @example
+#   # bad
+#   before do
+#   allow(Service).to receive(:foo).and_return(bar)
+#   allow(Service).to receive(:baz).and_return(qux)
+#   end
+#
+#   # good
+#   before do
+#   allow(Service).to receive_messages(foo: bar, baz: qux)
+#   end
+#
+#   # good - ignore same message
+#   before do
+#   allow(Service).to receive(:foo).and_return(bar)
+#   allow(Service).to receive(:foo).and_return(qux)
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#31
+class RuboCop::Cop::RSpec::ReceiveMessages < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#44
+  def allow_argument(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#39
+  def allow_receive_message?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#63
+  def on_begin(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#59
+  def receive_and_return_argument(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#54
+  def receive_arg(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#49
+  def receive_node(param0); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#83
+  def add_repeated_lines_and_arguments(items); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#100
+  def arguments(items); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#150
+  def heredoc_or_splat?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#146
+  def item_range_by_whole_lines(item); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#135
+  def message(repeated_lines); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#109
+  def normalize_receive_arg(receive_arg); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#117
+  def normalize_return_arg(return_arg); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#125
+  def register_offense(item, repeated_lines, args); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#73
+  def repeated_receive_message(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#139
+  def replace_to_receive_messages(corrector, item, args); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#155
+  def requires_quotes?(value); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#91
+  def uniq_items(items); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_messages.rb#35
+RuboCop::Cop::RSpec::ReceiveMessages::MSG = T.let(T.unsafe(nil), String)
+
+# Prefer `not_to receive(...)` over `receive(...).never`.
+#
+# @example
+#   # bad
+#   expect(foo).to receive(:bar).never
+#
+#   # good
+#   expect(foo).not_to receive(:bar)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_never.rb#15
+class RuboCop::Cop::RSpec::ReceiveNever < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_never.rb#21
+  def method_on_stub?(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_never.rb#23
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/receive_never.rb#33
+  def autocorrect(corrector, node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_never.rb#17
+RuboCop::Cop::RSpec::ReceiveNever::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/receive_never.rb#18
+RuboCop::Cop::RSpec::ReceiveNever::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Remove redundant `around` hook.
+#
+# @example
+#   # bad
+#   around do |example|
+#   example.run
+#   end
+#
+#   # good
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#16
+class RuboCop::Cop::RSpec::RedundantAround < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#43
+  def match_redundant_around_hook_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#48
+  def match_redundant_around_hook_send?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#23
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#23
+  def on_numblock(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#32
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#59
+  def autocorrect(corrector, node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#19
+RuboCop::Cop::RSpec::RedundantAround::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_around.rb#21
+RuboCop::Cop::RSpec::RedundantAround::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for redundant predicate matcher.
+#
+# @example
+#   # bad
+#   expect(foo).to be_exist(bar)
+#   expect(foo).not_to be_include(bar)
+#   expect(foo).to be_all(bar)
+#
+#   # good
+#   expect(foo).to exist(bar)
+#   expect(foo).not_to include(bar)
+#   expect(foo).to all be(bar)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_predicate_matcher.rb#19
+class RuboCop::Cop::RSpec::RedundantPredicateMatcher < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_predicate_matcher.rb#28
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_predicate_matcher.rb#44
+  def message(bad_method, good_method); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_predicate_matcher.rb#48
+  def replaceable_arguments?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_predicate_matcher.rb#56
+  def replaced_method_name(method_name); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_predicate_matcher.rb#22
+RuboCop::Cop::RSpec::RedundantPredicateMatcher::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/redundant_predicate_matcher.rb#23
+RuboCop::Cop::RSpec::RedundantPredicateMatcher::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks that `remove_const` is not used in specs.
+#
+# @example
+#   # bad
+#   it 'does something' do
+#   Object.send(:remove_const, :SomeConstant)
+#   end
+#
+#   before do
+#   SomeClass.send(:remove_const, :SomeConstant)
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/remove_const.rb#18
+class RuboCop::Cop::RSpec::RemoveConst < ::RuboCop::Cop::RSpec::Base
+  # Check for offenses
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/remove_const.rb#31
+  def on_send(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/remove_const.rb#26
+  def remove_const(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/remove_const.rb#21
+RuboCop::Cop::RSpec::RemoveConst::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/remove_const.rb#23
+RuboCop::Cop::RSpec::RemoveConst::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Check for repeated description strings in example groups.
+#
+# @example
+#   # bad
+#   RSpec.describe User do
+#   it 'is valid' do
+#   # ...
+#   end
+#
+#   it 'is valid' do
+#   # ...
+#   end
+#   end
+#
+#   # good
+#   RSpec.describe User do
+#   it 'is valid when first and last name are present' do
+#   # ...
+#   end
+#
+#   it 'is valid when last name only is present' do
+#   # ...
+#   end
+#   end
+#
+#   # good
+#   RSpec.describe User do
+#   it 'is valid' do
+#   # ...
+#   end
+#
+#   it 'is valid', :flag do
+#   # ...
+#   end
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_description.rb#42
+class RuboCop::Cop::RSpec::RepeatedDescription < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_description.rb#45
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_description.rb#88
+  def example_signature(example); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_description.rb#92
+  def its_signature(example); end
+
+  # Select examples in the current scope with repeated description strings
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_description.rb#60
+  def repeated_descriptions(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_description.rb#74
+  def repeated_its(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_description.rb#43
+RuboCop::Cop::RSpec::RepeatedDescription::MSG = T.let(T.unsafe(nil), String)
+
+# Check for repeated examples within example groups.
+#
+# @example
+#
+#   it 'is valid' do
+#   expect(user).to be_valid
+#   end
+#
+#   it 'validates the user' do
+#   expect(user).to be_valid
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example.rb#18
+class RuboCop::Cop::RSpec::RepeatedExample < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example.rb#21
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example.rb#41
+  def example_signature(example); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example.rb#31
+  def repeated_examples(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example.rb#19
+RuboCop::Cop::RSpec::RepeatedExample::MSG = T.let(T.unsafe(nil), String)
+
+# Check for repeated describe and context block body.
+#
+# @example
+#   # bad
+#   describe 'cool feature x' do
+#   it { cool_predicate }
+#   end
+#
+#   describe 'cool feature y' do
+#   it { cool_predicate }
+#   end
+#
+#   # good
+#   describe 'cool feature' do
+#   it { cool_predicate }
+#   end
+#
+#   describe 'another cool feature' do
+#   it { another_predicate }
+#   end
+#
+#   # good
+#   context 'when case x', :tag do
+#   it { cool_predicate }
+#   end
+#
+#   context 'when case y' do
+#   it { cool_predicate }
+#   end
+#
+#   # good
+#   context Array do
+#   it { is_expected.to respond_to :each }
+#   end
+#
+#   context Hash do
+#   it { is_expected.to respond_to :each }
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#45
+class RuboCop::Cop::RSpec::RepeatedExampleGroupBody < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::SkipOrPending
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#59
+  def body(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#62
+  def const_arg(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#56
+  def metadata(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#64
+  def on_begin(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#51
+  def several_example_groups?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#85
+  def add_repeated_lines(groups); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#94
+  def message(group, repeats); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#74
+  def repeated_group_bodies(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#90
+  def signature_keys(group); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_body.rb#48
+RuboCop::Cop::RSpec::RepeatedExampleGroupBody::MSG = T.let(T.unsafe(nil), String)
+
+# Check for repeated example group descriptions.
+#
+# @example
+#   # bad
+#   describe 'cool feature' do
+#   # example group
+#   end
+#
+#   describe 'cool feature' do
+#   # example group
+#   end
+#
+#   # bad
+#   context 'when case x' do
+#   # example group
+#   end
+#
+#   describe 'when case x' do
+#   # example group
+#   end
+#
+#   # good
+#   describe 'cool feature' do
+#   # example group
+#   end
+#
+#   describe 'another cool feature' do
+#   # example group
+#   end
+#
+#   # good
+#   context 'when case x' do
+#   # example group
+#   end
+#
+#   context 'when another case' do
+#   # example group
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#45
+class RuboCop::Cop::RSpec::RepeatedExampleGroupDescription < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::SkipOrPending
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#56
+  def doc_string_and_metadata(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#61
+  def empty_description?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#63
+  def on_begin(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#51
+  def several_example_groups?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#85
+  def add_repeated_lines(groups); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#90
+  def message(group, repeats); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#73
+  def repeated_group_descriptions(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_example_group_description.rb#48
+RuboCop::Cop::RSpec::RepeatedExampleGroupDescription::MSG = T.let(T.unsafe(nil), String)
+
+# Check for repeated include of shared examples.
+#
+# @example
+#   # bad
+#   describe 'foo' do
+#   include_examples 'cool stuff'
+#   include_examples 'cool stuff'
+#   end
+#
+#   # bad
+#   describe 'foo' do
+#   it_behaves_like 'a cool', 'thing'
+#   it_behaves_like 'a cool', 'thing'
+#   end
+#
+#   # bad
+#   context 'foo' do
+#   it_should_behave_like 'a duck'
+#   it_should_behave_like 'a duck'
+#   end
+#
+#   # good
+#   describe 'foo' do
+#   include_examples 'cool stuff'
+#   end
+#
+#   describe 'bar' do
+#   include_examples 'cool stuff'
+#   end
+#
+#   # good
+#   describe 'foo' do
+#   it_behaves_like 'a cool', 'thing'
+#   it_behaves_like 'a cool', 'person'
+#   end
+#
+#   # good
+#   context 'foo' do
+#   it_should_behave_like 'a duck'
+#   it_should_behave_like 'a goose'
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#48
+class RuboCop::Cop::RSpec::RepeatedIncludeExample < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#58
+  def include_examples?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#65
+  def on_begin(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#53
+  def several_include_examples?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#62
+  def shared_examples_name(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#90
+  def add_repeated_lines(items); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#85
+  def literal_include_examples?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#99
+  def message(item, repeats); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#75
+  def repeated_include_examples(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#95
+  def signature_keys(item); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_include_example.rb#49
+RuboCop::Cop::RSpec::RepeatedIncludeExample::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for repeated calls to subject missing that it is memoized.
+#
+# @example
+#   # bad
+#   it do
+#   subject
+#   expect { subject }.to not_change { A.count }
+#   end
+#
+#   it do
+#   expect { subject }.to change { A.count }
+#   expect { subject }.to not_change { A.count }
+#   end
+#
+#   # good
+#   it do
+#   expect { my_method }.to change { A.count }
+#   expect { my_method }.to not_change { A.count }
+#   end
+#
+#   # also good
+#   it do
+#   expect { subject.a }.to change { A.count }
+#   expect { subject.b }.to not_change { A.count }
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#32
+class RuboCop::Cop::RSpec::RepeatedSubjectCall < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::TopLevelGroup
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#65
+  def on_top_level_group(node); end
+
+  # Find a named or unnamed subject definition
+  #
+  # @example anonymous subject
+  #   subject?(parse('subject { foo }').ast) do |name|
+  #   name # => :subject
+  #   end
+  # @example named subject
+  #   subject?(parse('subject(:thing) { foo }').ast) do |name|
+  #   name # => :thing
+  #   end
+  # @param node [RuboCop::AST::Node]
+  # @yield [Symbol] subject name
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#53
+  def subject?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#61
+  def subject_calls(param0, param1); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#73
+  def detect_offense(subject_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#85
+  def detect_offenses_in_block(node, subject_names = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#97
+  def detect_offenses_in_example(node, subject_names); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#111
+  def detect_subjects_in_scope(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#81
+  def expect_block(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/repeated_subject_call.rb#35
+RuboCop::Cop::RSpec::RepeatedSubjectCall::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for consistent style of stub's return setting.
+#
+# Enforces either `and_return` or block-style return in the cases
+# where the returned value is constant. Ignores dynamic returned values
+# are the result would be different
+#
+# This cop can be configured using the `EnforcedStyle` option
+#
+# @example `EnforcedStyle: and_return` (default)
+#   # bad
+#   allow(Foo).to receive(:bar) { "baz" }
+#   expect(Foo).to receive(:bar) { "baz" }
+#
+#   # good
+#   allow(Foo).to receive(:bar).and_return("baz")
+#   expect(Foo).to receive(:bar).and_return("baz")
+#   # also good as the returned value is dynamic
+#   allow(Foo).to receive(:bar) { bar.baz }
+# @example `EnforcedStyle: block`
+#   # bad
+#   allow(Foo).to receive(:bar).and_return("baz")
+#   expect(Foo).to receive(:bar).and_return("baz")
+#
+#   # good
+#   allow(Foo).to receive(:bar) { "baz" }
+#   expect(Foo).to receive(:bar) { "baz" }
+#   # also good as the returned value is dynamic
+#   allow(Foo).to receive(:bar).and_return(bar.baz)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#36
+class RuboCop::Cop::RSpec::ReturnFromStub < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#51
+  def and_return_value(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#45
+  def contains_stub?(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#62
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#55
+  def on_send(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#48
+  def stub_with_block?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#71
+  def check_and_return_call(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#81
+  def check_block_body(block); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#90
+  def dynamic?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#95
+class RuboCop::Cop::RSpec::ReturnFromStub::AndReturnCallCorrector
+  # @return [AndReturnCallCorrector] a new instance of AndReturnCallCorrector
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#96
+  def initialize(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#102
+  def call(corrector); end
+
+  private
+
+  # Returns the value of attribute arg.
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#111
+  def arg; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#133
+  def hash_without_braces?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#113
+  def heredoc?; end
+
+  # Returns the value of attribute node.
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#111
+  def node; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#117
+  def range; end
+
+  # Returns the value of attribute receiver.
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#111
+  def receiver; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#125
+  def replacement; end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#139
+class RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector
+  # @return [BlockBodyCorrector] a new instance of BlockBodyCorrector
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#140
+  def initialize(block); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#146
+  def call(corrector); end
+
+  private
+
+  # Returns the value of attribute block.
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#158
+  def block; end
+
+  # Returns the value of attribute body.
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#158
+  def body; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#160
+  def heredoc?; end
+
+  # Returns the value of attribute node.
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#158
+  def node; end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#164
+RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector::NULL_BLOCK_BODY = T.let(T.unsafe(nil), T.untyped)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#40
+RuboCop::Cop::RSpec::ReturnFromStub::MSG_AND_RETURN = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#41
+RuboCop::Cop::RSpec::ReturnFromStub::MSG_BLOCK = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/return_from_stub.rb#42
+RuboCop::Cop::RSpec::ReturnFromStub::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for let scattered across the example group.
+#
+# Group lets together
+#
+# @example
+#   # bad
+#   describe Foo do
+#   let(:foo) { 1 }
+#   subject { Foo }
+#   let(:bar) { 2 }
+#   before { prepare }
+#   let!(:baz) { 3 }
+#   end
+#
+#   # good
+#   describe Foo do
+#   subject { Foo }
+#   before { prepare }
+#   let(:foo) { 1 }
+#   let(:bar) { 2 }
+#   let!(:baz) { 3 }
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_let.rb#29
+class RuboCop::Cop::RSpec::ScatteredLet < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_let.rb#34
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_let.rb#42
+  def check_let_declarations(body); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_let.rb#32
+RuboCop::Cop::RSpec::ScatteredLet::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for setup scattered across multiple hooks in an example group.
+#
+# Unify `before`, `after`, and `around` hooks when possible.
+#
+# @example
+#   # bad
+#   describe Foo do
+#   before { setup1 }
+#   before { setup2 }
+#   end
+#
+#   # good
+#   describe Foo do
+#   before do
+#   setup1
+#   setup2
+#   end
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_setup.rb#25
+class RuboCop::Cop::RSpec::ScatteredSetup < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::FinalEndLocation
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_setup.rb#33
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_setup.rb#76
+  def autocorrect(corrector, first_occurrence, occurrence); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_setup.rb#61
+  def lines_msg(numbers); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_setup.rb#69
+  def message(occurrences, occurrence); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_setup.rb#48
+  def repeated_hooks(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/scattered_setup.rb#30
+RuboCop::Cop::RSpec::ScatteredSetup::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for proper shared_context and shared_examples usage.
+#
+# If there are no examples defined, use shared_context.
+# If there is no setup defined, use shared_examples.
+#
+# @example
+#   # bad
+#   RSpec.shared_context 'only examples here' do
+#   it 'does x' do
+#   end
+#
+#   it 'does y' do
+#   end
+#   end
+#
+#   # good
+#   RSpec.shared_examples 'only examples here' do
+#   it 'does x' do
+#   end
+#
+#   it 'does y' do
+#   end
+#   end
+# @example
+#   # bad
+#   RSpec.shared_examples 'only setup here' do
+#   subject(:foo) { :bar }
+#
+#   let(:baz) { :bazz }
+#
+#   before do
+#   something
+#   end
+#   end
+#
+#   # good
+#   RSpec.shared_context 'only setup here' do
+#   subject(:foo) { :bar }
+#
+#   let(:baz) { :bazz }
+#
+#   before do
+#   something
+#   end
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#53
+class RuboCop::Cop::RSpec::SharedContext < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#65
+  def context?(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#60
+  def examples?(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#81
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#72
+  def shared_context(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#77
+  def shared_example(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#97
+  def context_with_only_examples(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#101
+  def examples_with_only_context(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#57
+RuboCop::Cop::RSpec::SharedContext::MSG_CONTEXT = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_context.rb#56
+RuboCop::Cop::RSpec::SharedContext::MSG_EXAMPLES = T.let(T.unsafe(nil), String)
+
+# Checks for consistent style for shared example names.
+#
+# Enforces either `string` or `symbol` for shared example names.
+#
+# This cop can be configured using the `EnforcedStyle` option
+#
+# @example `EnforcedStyle: string` (default)
+#   # bad
+#   it_behaves_like :foo_bar_baz
+#   it_should_behave_like :foo_bar_baz
+#   shared_examples :foo_bar_baz
+#   shared_examples_for :foo_bar_baz
+#   include_examples :foo_bar_baz
+#
+#   # good
+#   it_behaves_like 'foo bar baz'
+#   it_should_behave_like 'foo bar baz'
+#   shared_examples 'foo bar baz'
+#   shared_examples_for 'foo bar baz'
+#   include_examples 'foo bar baz'
+# @example `EnforcedStyle: symbol`
+#   # bad
+#   it_behaves_like 'foo bar baz'
+#   it_should_behave_like 'foo bar baz'
+#   shared_examples 'foo bar baz'
+#   shared_examples_for 'foo bar baz'
+#   include_examples 'foo bar baz'
+#
+#   # good
+#   it_behaves_like :foo_bar_baz
+#   it_should_behave_like :foo_bar_baz
+#   shared_examples :foo_bar_baz
+#   shared_examples_for :foo_bar_baz
+#   include_examples :foo_bar_baz
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#42
+class RuboCop::Cop::RSpec::SharedExamples < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#54
+  def on_send(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#47
+  def shared_examples(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#75
+  def new_checker(ast_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#67
+  def offense?(ast_node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#104
+class RuboCop::Cop::RSpec::SharedExamples::StringChecker
+  # @return [StringChecker] a new instance of StringChecker
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#110
+  def initialize(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#114
+  def message; end
+
+  # Returns the value of attribute node.
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#108
+  def node; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#118
+  def preferred_style; end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#105
+RuboCop::Cop::RSpec::SharedExamples::StringChecker::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#84
+class RuboCop::Cop::RSpec::SharedExamples::SymbolChecker
+  # @return [SymbolChecker] a new instance of SymbolChecker
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#90
+  def initialize(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#94
+  def message; end
+
+  # Returns the value of attribute node.
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#88
+  def node; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#98
+  def preferred_style; end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/shared_examples.rb#85
+RuboCop::Cop::RSpec::SharedExamples::SymbolChecker::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that chains of messages contain more than one element.
+#
+# @example
+#   # bad
+#   allow(foo).to receive_message_chain(:bar).and_return(42)
+#
+#   # good
+#   allow(foo).to receive(:bar).and_return(42)
+#
+#   # also good
+#   allow(foo).to receive(:bar, :baz)
+#   allow(foo).to receive("bar.baz")
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#19
+class RuboCop::Cop::RSpec::SingleArgumentMessageChain < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#27
+  def message_chain(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#34
+  def on_send(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#32
+  def single_key_hash?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#49
+  def autocorrect(corrector, node, method, arg); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#77
+  def autocorrect_array_arg(corrector, arg); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#69
+  def autocorrect_hash_arg(corrector, arg); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#83
+  def key_to_arg(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#87
+  def replacement(method); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#65
+  def single_element_array?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#55
+  def valid_usage?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#22
+RuboCop::Cop::RSpec::SingleArgumentMessageChain::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/single_argument_message_chain.rb#24
+RuboCop::Cop::RSpec::SingleArgumentMessageChain::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for passing a block to `skip` within examples.
+#
+# @example
+#   # bad
+#   it 'does something' do
+#   skip 'not yet implemented' do
+#   do_something
+#   end
+#   end
+#
+#   # good
+#   it 'does something' do
+#   skip 'not yet implemented'
+#   do_something
+#   end
+#
+#   # good - when outside example
+#   skip 'not yet implemented' do
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/skip_block_inside_example.rb#26
+class RuboCop::Cop::RSpec::SkipBlockInsideExample < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/skip_block_inside_example.rb#29
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/skip_block_inside_example.rb#29
+  def on_numblock(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/skip_block_inside_example.rb#40
+  def inside_example?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/skip_block_inside_example.rb#27
+RuboCop::Cop::RSpec::SkipBlockInsideExample::MSG = T.let(T.unsafe(nil), String)
+
+# Helps check offenses with variable definitions
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/skip_or_pending.rb#7
+module RuboCop::Cop::RSpec::SkipOrPending
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # Match skip/pending statements inside a block (e.g. `context`)
+  #
+  # @example source that matches
+  #   context 'when color is blue' do
+  #   skip 'not implemented yet'
+  #   pending 'not implemented yet'
+  #   end
+  # @example source that does not match
+  #   skip 'not implemented yet'
+  #   pending 'not implemented yet'
+  # @param node [RuboCop::AST::Node]
+  # @return [Array<RuboCop::AST::Node>] matching nodes
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/skip_or_pending.rb#33
+  def skip_or_pending_inside_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/skip_or_pending.rb#11
+  def skipped_in_metadata?(param0 = T.unsafe(nil)); end
+end
+
+# Sort RSpec metadata alphabetically.
+#
+# @example
+#   # bad
+#   describe 'Something', :b, :a
+#   context 'Something', foo: 'bar', baz: true
+#   it 'works', :b, :a, foo: 'bar', baz: true
+#
+#   # good
+#   describe 'Something', :a, :b
+#   context 'Something', baz: true, foo: 'bar'
+#   it 'works', :a, :b, baz: true, foo: 'bar'
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#19
+class RuboCop::Cop::RSpec::SortMetadata < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::Metadata
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#26
+  def on_metadata(symbols, hash); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#38
+  def crime_scene(symbols, pairs); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#47
+  def replacement(symbols, pairs); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#55
+  def sort_pairs(pairs); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#59
+  def sort_symbols(symbols); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#51
+  def sorted?(symbols, pairs); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/sort_metadata.rb#24
+RuboCop::Cop::RSpec::SortMetadata::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that spec file paths are consistent and well-formed.
+#
+# @example
+#   # bad
+#   whatever_spec.rb         # describe MyClass
+#   my_class_spec.rb         # describe MyClass, '#method'
+#
+#   # good
+#   my_class_spec.rb         # describe MyClass
+#   my_class_method_spec.rb  # describe MyClass, '#method'
+#   my_class/method_spec.rb  # describe MyClass, '#method'
+# @example `CustomTransform: {RuboCop=>rubocop, RSpec=>rspec}` (default)
+#   # good
+#   rubocop_spec.rb          # describe RuboCop
+#   rspec_spec.rb            # describe RSpec
+# @example `IgnoreMethods: false` (default)
+#   # bad
+#   my_class_spec.rb         # describe MyClass, '#method'
+# @example `IgnoreMethods: true`
+#   # good
+#   my_class_spec.rb         # describe MyClass, '#method'
+# @example `IgnoreMetadata: {type=>routing}` (default)
+#   # good
+#   whatever_spec.rb         # describe MyClass, type: :routing do; end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#35
+class RuboCop::Cop::RSpec::SpecFilePathFormat < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::TopLevelGroup
+  include ::RuboCop::Cop::RSpec::Namespace
+  include ::RuboCop::Cop::RSpec::FileHelp
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#43
+  def example_group_arguments(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#48
+  def metadata_key_value(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#50
+  def on_top_level_example_group(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#108
+  def camel_to_snake_case(string); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#81
+  def correct_path_pattern(class_name, arguments); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#115
+  def custom_transform; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#62
+  def ensure_correct_file_path(send_node, class_name, arguments); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#98
+  def expected_path(constant); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#127
+  def filename_ends_with?(pattern); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#94
+  def ignore?(method_name); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#123
+  def ignore_metadata; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#73
+  def ignore_metadata?(arguments); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#119
+  def ignore_methods?; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#88
+  def name_pattern(method_name); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_format.rb#40
+RuboCop::Cop::RSpec::SpecFilePathFormat::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that spec file paths suffix are consistent and well-formed.
+#
+# @example
+#   # bad
+#   my_class/foo_specorb.rb   # describe MyClass
+#   spec/models/user.rb       # describe User
+#   spec/models/user_specxrb  # describe User
+#
+#   # good
+#   my_class_spec.rb          # describe MyClass
+#
+#   # good - shared examples are allowed
+#   spec/models/user.rb       # shared_examples_for 'foo'
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_suffix.rb#20
+class RuboCop::Cop::RSpec::SpecFilePathSuffix < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::TopLevelGroup
+  include ::RuboCop::Cop::RSpec::FileHelp
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_suffix.rb#26
+  def on_top_level_example_group(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_suffix.rb#34
+  def correct_path?; end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/spec_file_path_suffix.rb#24
+RuboCop::Cop::RSpec::SpecFilePathSuffix::MSG = T.let(T.unsafe(nil), String)
+
+# Do not use a string as `instance_double` constant.
+#
+# @example
+#   # bad
+#   instance_double('User', name: 'John')
+#
+#   # good
+#   instance_double(User, name: 'John')
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/string_as_instance_double_constant.rb#20
+class RuboCop::Cop::RSpec::StringAsInstanceDoubleConstant < ::RuboCop::Cop::RSpec::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/string_as_instance_double_constant.rb#39
+  def autocorrect(corrector, node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/string_as_instance_double_constant.rb#31
+  def on_send(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/string_as_instance_double_constant.rb#27
+  def stringified_instance_double_const?(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/string_as_instance_double_constant.rb#23
+RuboCop::Cop::RSpec::StringAsInstanceDoubleConstant::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/string_as_instance_double_constant.rb#24
+RuboCop::Cop::RSpec::StringAsInstanceDoubleConstant::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks that message expectations do not have a configured response.
+#
+# @example
+#   # bad
+#   expect(foo).to receive(:bar).with(42).and_return("hello world")
+#
+#   # good (without spies)
+#   allow(foo).to receive(:bar).with(42).and_return("hello world")
+#   expect(foo).to receive(:bar).with(42)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#16
+class RuboCop::Cop::RSpec::StubbedMock < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#42
+  def configured_response?(param0 = T.unsafe(nil)); end
+
+  # Match expectation
+  #
+  # @example source that matches
+  #   is_expected.to be_in_the_bar
+  # @example source that matches
+  #   expect(cocktail).to contain_exactly(:fresh_orange_juice, :campari)
+  # @example source that matches
+  #   expect_any_instance_of(Officer).to be_alert
+  # @param node [RuboCop::AST::Node]
+  # @yield [RuboCop::AST::Node] expectation, method name, matcher
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#61
+  def expectation(param0 = T.unsafe(nil)); end
+
+  # Match matcher with a configured response in block-pass
+  #
+  # @example source that matches
+  #   receive(:foo, &canned)
+  # @example source that matches
+  #   receive_message_chain(:foo, :bar, &canned)
+  # @example source that matches
+  #   receive(:foo).with('bar', &canned)
+  # @param node [RuboCop::AST::Node]
+  # @yield [RuboCop::AST::Node] matcher
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#129
+  def matcher_with_blockpass(param0 = T.unsafe(nil)); end
+
+  # Match matcher with a configured response
+  #
+  # @example source that matches
+  #   receive(:foo).and_return('bar')
+  # @example source that matches
+  #   receive(:lower).and_raise(SomeError)
+  # @example source that matches
+  #   receive(:redirect).and_call_original
+  # @param node [RuboCop::AST::Node]
+  # @yield [RuboCop::AST::Node] matcher
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#81
+  def matcher_with_configured_response(param0 = T.unsafe(nil)); end
+
+  # Match matcher with a configured response defined as a hash
+  #
+  # @example source that matches
+  #   receive_messages(foo: 'bar', baz: 'qux')
+  # @example source that matches
+  #   receive_message_chain(:foo, bar: 'baz')
+  # @param node [RuboCop::AST::Node]
+  # @yield [RuboCop::AST::Node] matcher
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#108
+  def matcher_with_hash(param0 = T.unsafe(nil)); end
+
+  # Match matcher with a return block
+  #
+  # @example source that matches
+  #   receive(:foo) { 'bar' }
+  # @param node [RuboCop::AST::Node]
+  # @yield [RuboCop::AST::Node] matcher
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#93
+  def matcher_with_return_block(param0 = T.unsafe(nil)); end
+
+  # Match message expectation matcher
+  #
+  # @example source that matches
+  #   receive(:foo)
+  # @example source that matches
+  #   receive_message_chain(:foo, :bar)
+  # @example source that matches
+  #   receive(:foo).with('bar')
+  # @param node [RuboCop::AST::Node]
+  # @return [Array<RuboCop::AST::Node>] matching nodes
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#34
+  def message_expectation?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#138
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#157
+  def msg(method_name); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#146
+  def on_expectation(expectation, method_name, matcher); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#163
+  def replacement(method_name); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#17
+RuboCop::Cop::RSpec::StubbedMock::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/stubbed_mock.rb#136
+RuboCop::Cop::RSpec::StubbedMock::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Ensure that subject is defined using subject helper.
+#
+# @example
+#   # bad
+#   let(:subject) { foo }
+#   let!(:subject) { foo }
+#   subject(:subject) { foo }
+#   subject!(:subject) { foo }
+#
+#   # bad
+#   block = -> {}
+#   let(:subject, &block)
+#
+#   # good
+#   subject(:test_subject) { foo }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/subject_declaration.rb#22
+class RuboCop::Cop::RSpec::SubjectDeclaration < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_declaration.rb#27
+  def offensive_subject_declaration?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_declaration.rb#31
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_declaration.rb#40
+  def message_for(offense); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/subject_declaration.rb#23
+RuboCop::Cop::RSpec::SubjectDeclaration::MSG_LET = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/subject_declaration.rb#24
+RuboCop::Cop::RSpec::SubjectDeclaration::MSG_REDUNDANT = T.let(T.unsafe(nil), String)
+
+# Checks for stubbed test subjects.
+#
+# Checks nested subject stubs for innermost subject definition
+# when subject is also defined in parent example groups.
+#
+# @example
+#   # bad
+#   describe Article do
+#   subject(:article) { Article.new }
+#
+#   it 'indicates that the author is unknown' do
+#   allow(article).to receive(:author).and_return(nil)
+#   expect(article.description).to include('by an unknown author')
+#   end
+#   end
+#
+#   # bad
+#   describe Article do
+#   subject(:foo) { Article.new }
+#
+#   context 'nested subject' do
+#   subject(:article) { Article.new }
+#
+#   it 'indicates that the author is unknown' do
+#   allow(article).to receive(:author).and_return(nil)
+#   expect(article.description).to include('by an unknown author')
+#   end
+#   end
+#   end
+#
+#   # good
+#   describe Article do
+#   subject(:article) { Article.new(author: nil) }
+#
+#   it 'indicates that the author is unknown' do
+#   expect(article.description).to include('by an unknown author')
+#   end
+#   end
+# @see https://robots.thoughtbot.com/don-t-stub-the-system-under-test
+# @see https://penelope.zone/2015/12/27/introducing-rspec-smells-and-where-to-find-them.html#smell-1-stubjec
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#50
+class RuboCop::Cop::RSpec::SubjectStub < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RSpec::TopLevelGroup
+
+  # Find a memoized helper
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#80
+  def let?(param0 = T.unsafe(nil)); end
+
+  # Match `allow` and `expect(...).to receive`
+  #
+  # @example source that matches
+  #   allow(foo).to  receive(:bar)
+  #   allow(foo).to  receive(:bar).with(1)
+  #   allow(foo).to  receive(:bar).with(1).and_return(2)
+  #   expect(foo).to receive(:bar)
+  #   expect(foo).to receive(:bar).with(1)
+  #   expect(foo).to receive(:bar).with(1).and_return(2)
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#97
+  def message_expectation?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#109
+  def message_expectation_matcher?(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#115
+  def on_top_level_group(node); end
+
+  # Find a named or unnamed subject definition
+  #
+  # @example anonymous subject
+  #   subject?(parse('subject { foo }').ast) do |name|
+  #   name # => :subject
+  #   end
+  # @example named subject
+  #   subject?(parse('subject(:thing) { foo }').ast) do |name|
+  #   name # => :thing
+  #   end
+  # @param node [RuboCop::AST::Node]
+  # @yield [Symbol] subject name
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#71
+  def subject?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#126
+  def find_all_explicit(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#140
+  def find_subject_expectations(node, subject_names = T.unsafe(nil), &block); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/subject_stub.rb#53
+RuboCop::Cop::RSpec::SubjectStub::MSG = T.let(T.unsafe(nil), String)
+
+# Helper methods for top level example group cops
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#7
+module RuboCop::Cop::RSpec::TopLevelGroup
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#10
+  def on_new_investigation; end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#19
+  def top_level_groups; end
+
+  private
+
+  # Dummy methods to be overridden in the consumer
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#27
+  def on_top_level_example_group(_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#29
+  def on_top_level_group(_node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#48
+  def root_node; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#31
+  def top_level_group?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/top_level_group.rb#35
+  def top_level_nodes(node); end
+end
+
+# Description should be descriptive.
+#
+# If example group or example contains only `execute string`, numbers
+# and regular expressions, the description is not clear.
+#
+# @example
+#   # bad
+#   describe `time` do
+#   # ...
+#   end
+#
+#   # bad
+#   context /when foo/ do
+#   # ...
+#   end
+#
+#   # bad
+#   it 10000 do
+#   # ...
+#   end
+#
+#   # good
+#   describe Foo do
+#   # ...
+#   end
+#
+#   # good
+#   describe '#foo' do
+#   # ...
+#   end
+#
+#   # good
+#   context "when #{foo} is bar" do
+#   # ...
+#   end
+#
+#   # good
+#   it 'does something' do
+#   # ...
+#   end
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/undescriptive_literals_description.rb#47
+class RuboCop::Cop::RSpec::UndescriptiveLiteralsDescription < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/undescriptive_literals_description.rb#51
+  def example_groups_or_example?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/undescriptive_literals_description.rb#55
+  def on_block(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/undescriptive_literals_description.rb#63
+  def offense?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/undescriptive_literals_description.rb#48
+RuboCop::Cop::RSpec::UndescriptiveLiteralsDescription::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for a specified error in checking raised errors.
+#
+# Enforces one of an Exception type, a string, or a regular
+# expression to match against the exception message as a parameter
+# to `raise_error`
+#
+# @example
+#   # bad
+#   expect {
+#   raise StandardError.new('error')
+#   }.to raise_error
+#
+#   # good
+#   expect {
+#   raise StandardError.new('error')
+#   }.to raise_error(StandardError)
+#
+#   expect {
+#   raise StandardError.new('error')
+#   }.to raise_error('error')
+#
+#   expect {
+#   raise StandardError.new('error')
+#   }.to raise_error(/err/)
+#
+#   expect { do_something }.not_to raise_error
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/unspecified_exception.rb#33
+class RuboCop::Cop::RSpec::UnspecifiedException < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/unspecified_exception.rb#42
+  def expect_to?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/unspecified_exception.rb#46
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/unspecified_exception.rb#54
+  def empty_exception_matcher?(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/unspecified_exception.rb#64
+  def find_expect_to(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/unspecified_exception.rb#34
+RuboCop::Cop::RSpec::UnspecifiedException::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/unspecified_exception.rb#36
+RuboCop::Cop::RSpec::UnspecifiedException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Helps check offenses with variable definitions
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/variable.rb#7
+module RuboCop::Cop::RSpec::Variable
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/variable.rb#14
+  def variable_definition?(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/variable.rb#11
+RuboCop::Cop::RSpec::Variable::Helpers = RuboCop::RSpec::Language::Helpers
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/mixin/variable.rb#10
+RuboCop::Cop::RSpec::Variable::Subjects = RuboCop::RSpec::Language::Subjects
+
+# Checks that memoized helpers names are symbols or strings.
+#
+# @example EnforcedStyle: symbols (default)
+#   # bad
+#   subject('user') { create_user }
+#   let('user_name') { 'Adam' }
+#
+#   # good
+#   subject(:user) { create_user }
+#   let(:user_name) { 'Adam' }
+# @example EnforcedStyle: strings
+#   # bad
+#   subject(:user) { create_user }
+#   let(:user_name) { 'Adam' }
+#
+#   # good
+#   subject('user') { create_user }
+#   let('user_name') { 'Adam' }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/variable_definition.rb#26
+class RuboCop::Cop::RSpec::VariableDefinition < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RSpec::Variable
+  include ::RuboCop::Cop::RSpec::InsideExampleGroup
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/variable_definition.rb#34
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/variable_definition.rb#51
+  def correct_variable(variable); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/variable_definition.rb#67
+  def string?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/variable_definition.rb#62
+  def style_offense?(variable); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/variable_definition.rb#71
+  def symbol?(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/variable_definition.rb#32
+RuboCop::Cop::RSpec::VariableDefinition::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that memoized helper names use the configured style.
+#
+# Variables can be excluded from checking using the `AllowedPatterns`
+# option.
+#
+# @example EnforcedStyle: snake_case (default)
+#   # bad
+#   subject(:userName1) { 'Adam' }
+#   let(:userName2) { 'Adam' }
+#
+#   # good
+#   subject(:user_name_1) { 'Adam' }
+#   let(:user_name_2) { 'Adam' }
+# @example EnforcedStyle: camelCase
+#   # bad
+#   subject(:user_name_1) { 'Adam' }
+#   let(:user_name_2) { 'Adam' }
+#
+#   # good
+#   subject(:userName1) { 'Adam' }
+#   let(:userName2) { 'Adam' }
+# @example AllowedPatterns configuration
+#   # rubocop.yml
+#   # RSpec/VariableName:
+#   #   EnforcedStyle: snake_case
+#   #   AllowedPatterns:
+#   #     - ^userFood
+# @example
+#   # okay because it matches the `^userFood` regex in `AllowedPatterns`
+#   subject(:userFood_1) { 'spaghetti' }
+#   let(:userFood_2) { 'fettuccine' }
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/variable_name.rb#41
+class RuboCop::Cop::RSpec::VariableName < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::ConfigurableFormatting
+  include ::RuboCop::Cop::ConfigurableNaming
+  include ::RuboCop::Cop::AllowedPattern
+  include ::RuboCop::Cop::RSpec::Variable
+  include ::RuboCop::Cop::RSpec::InsideExampleGroup
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/variable_name.rb#49
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/variable_name.rb#62
+  def message(style); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/variable_name.rb#47
+RuboCop::Cop::RSpec::VariableName::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for consistent verified double reference style.
+#
+# Only investigates references that are one of the supported styles.
+#
+# This cop can be configured in your configuration using the
+# `EnforcedStyle` option and supports `--auto-gen-config`.
+#
+# @example `EnforcedStyle: constant` (default)
+#   # bad
+#   let(:foo) do
+#   instance_double('ClassName', method_name: 'returned_value')
+#   end
+#
+#   # good
+#   let(:foo) do
+#   instance_double(ClassName, method_name: 'returned_value')
+#   end
+# @example `EnforcedStyle: string`
+#   # bad
+#   let(:foo) do
+#   instance_double(ClassName, method_name: 'returned_value')
+#   end
+#
+#   # good
+#   let(:foo) do
+#   instance_double('ClassName', method_name: 'returned_value')
+#   end
+# @example Reference is not in the supported style list. No enforcement
+#
+#   # good
+#   let(:foo) do
+#   instance_double(@klass, method_name: 'returned_value')
+#   end
+# @see https://rspec.info/features/3-12/rspec-mocks/verifying-doubles
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#43
+class RuboCop::Cop::RSpec::VerifiedDoubleReference < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#74
+  def on_send(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#66
+  def verified_double(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#101
+  def correct_style(offense); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#92
+  def opposing_style?(class_reference); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#47
+RuboCop::Cop::RSpec::VerifiedDoubleReference::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#60
+RuboCop::Cop::RSpec::VerifiedDoubleReference::REFERENCE_TYPE_STYLES = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/verified_double_reference.rb#49
+RuboCop::Cop::RSpec::VerifiedDoubleReference::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
+
+# Prefer using verifying doubles over normal doubles.
+#
+# @example
+#   # bad
+#   let(:foo) do
+#   double(method_name: 'returned value')
+#   end
+#
+#   # bad
+#   let(:foo) do
+#   double("ClassName", method_name: 'returned value')
+#   end
+#
+#   # good
+#   let(:foo) do
+#   instance_double("ClassName", method_name: 'returned value')
+#   end
+# @see https://rspec.info/features/3-12/rspec-mocks/verifying-doubles
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/verified_doubles.rb#26
+class RuboCop::Cop::RSpec::VerifiedDoubles < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/verified_doubles.rb#35
+  def on_send(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/verified_doubles.rb#31
+  def unverified_double(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/verified_doubles.rb#46
+  def symbol?(name); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/verified_doubles.rb#27
+RuboCop::Cop::RSpec::VerifiedDoubles::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/verified_doubles.rb#28
+RuboCop::Cop::RSpec::VerifiedDoubles::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks void `expect()`.
+#
+# @example
+#   # bad
+#   expect(something)
+#
+#   # good
+#   expect(something).to be(1)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#15
+class RuboCop::Cop::RSpec::VoidExpect < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#21
+  def expect?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#26
+  def expect_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#37
+  def on_block(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#30
+  def on_send(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#46
+  def check_expect(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#59
+  def inside_example?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#52
+  def void?(expect); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#16
+RuboCop::Cop::RSpec::VoidExpect::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/void_expect.rb#18
+RuboCop::Cop::RSpec::VoidExpect::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for calling a block within a stub.
+#
+# @example
+#   # bad
+#   allow(foo).to receive(:bar) { |&block| block.call(1) }
+#
+#   # good
+#   expect(foo).to receive(:bar).and_yield(1)
+#
+# source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#15
+class RuboCop::Cop::RSpec::Yield < ::RuboCop::Cop::RSpec::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#25
+  def block_arg(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#28
+  def block_call?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#22
+  def method_on_stub?(param0); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#30
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#46
+  def autocorrect(corrector, node, range); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#61
+  def block_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#53
+  def calling_block?(node, block); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#73
+  def convert_block_to_yield(node); end
+
+  # source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#65
+  def generate_replacement(node); end
+end
+
+# source://rubocop-rspec//lib/rubocop/cop/rspec/yield.rb#19
+RuboCop::Cop::RSpec::Yield::MSG = T.let(T.unsafe(nil), String)
+
+# RuboCop RSpec project namespace
+#
+# source://rubocop-rspec//lib/rubocop/rspec.rb#5
+module RuboCop::RSpec; end
+
+# Shared behavior for aligning braces for single line lets
+#
+# source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#6
+class RuboCop::RSpec::AlignLetBrace
+  include ::RuboCop::RSpec::Language
+  include ::RuboCop::PathUtil
+  include ::RuboCop::Cop::Util
+
+  # @return [AlignLetBrace] a new instance of AlignLetBrace
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#10
+  def initialize(root, token); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#21
+  def indent_for(node); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#15
+  def offending_tokens; end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#43
+  def adjacent_let_chunks; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#35
+  def let_group_for(let); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#27
+  def let_token(node); end
+
+  # Returns the value of attribute root.
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#60
+  def root; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#53
+  def single_line_lets; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#31
+  def target_column_for(let); end
+
+  # Returns the value of attribute token.
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/align_let_brace.rb#60
+  def token; end
+end
+
+# source://rubocop-rspec//lib/rubocop/rspec.rb#7
+RuboCop::RSpec::CONFIG_DEFAULT = T.let(T.unsafe(nil), Pathname)
+
+# Wrapper for RSpec DSL methods
+#
+# source://rubocop-rspec//lib/rubocop/rspec/concept.rb#6
+class RuboCop::RSpec::Concept
+  include ::RuboCop::RSpec::Language
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # @return [Concept] a new instance of Concept
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/concept.rb#10
+  def initialize(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/concept.rb#14
+  def ==(other); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/concept.rb#14
+  def eql?(other); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/concept.rb#20
+  def hash; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/concept.rb#24
+  def to_node; end
+
+  protected
+
+  # Returns the value of attribute node.
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/concept.rb#30
+  def node; end
+end
+
+# source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#5
+module RuboCop::RSpec::Corrector; end
+
+# Helper methods to move a node
+#
+# source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#7
+class RuboCop::RSpec::Corrector::MoveNode
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::RSpec::FinalEndLocation
+  include ::RuboCop::Cop::RSpec::CommentsHelp
+
+  # @return [MoveNode] a new instance of MoveNode
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#14
+  def initialize(node, corrector, processed_source); end
+
+  # Returns the value of attribute corrector.
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#12
+  def corrector; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#27
+  def move_after(other); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#20
+  def move_before(other); end
+
+  # Returns the value of attribute original.
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#12
+  def original; end
+
+  # Returns the value of attribute processed_source.
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#12
+  def processed_source; end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#40
+  def node_range(node); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#44
+  def node_range_with_surrounding_space(node); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/corrector/move_node.rb#36
+  def source(node); end
+end
+
+# Wrapper for RSpec examples
+#
+# source://rubocop-rspec//lib/rubocop/rspec/example.rb#6
+class RuboCop::RSpec::Example < ::RuboCop::RSpec::Concept
+  # source://rubocop-rspec//lib/rubocop/rspec/example.rb#28
+  def definition; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/example.rb#16
+  def doc_string; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/example.rb#8
+  def extract_doc_string(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/example.rb#14
+  def extract_implementation(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/example.rb#11
+  def extract_metadata(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/example.rb#24
+  def implementation; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/example.rb#20
+  def metadata; end
+end
+
+# Wrapper for RSpec example groups
+#
+# source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#6
+class RuboCop::RSpec::ExampleGroup < ::RuboCop::RSpec::Concept
+  # source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#28
+  def examples; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#34
+  def hooks; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#20
+  def lets; end
+
+  # Detect if the node is an example group or shared example
+  #
+  # Selectors which indicate that we should stop searching
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#13
+  def scope_change?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#24
+  def subjects; end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#56
+  def find_all(node, predicate); end
+
+  # Recursively search for predicate within the current scope
+  #
+  # Searches node and halts when a scope change is detected
+  #
+  # @param node [RuboCop::AST::Node] node to recursively search
+  # @param predicate [Symbol] method to call with node as argument
+  # @return [Array<RuboCop::AST::Node>] discovered nodes
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/example_group.rb#50
+  def find_all_in_scope(node, predicate); end
+end
+
+# Wrapper for RSpec hook
+#
+# source://rubocop-rspec//lib/rubocop/rspec/hook.rb#6
+class RuboCop::RSpec::Hook < ::RuboCop::RSpec::Concept
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#24
+  def example?; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#8
+  def extract_metadata(param0 = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#18
+  def knowable_scope?; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#38
+  def metadata; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#14
+  def name; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#28
+  def scope; end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#74
+  def scope_argument; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#70
+  def scope_name; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#51
+  def transform_metadata(meta); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#66
+  def transform_true(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/hook.rb#47
+  def valid_scope?(node); end
+end
+
+# Because RuboCop doesn't yet support plugins, we have to monkey patch in a
+# bit of our configuration.
+#
+# source://rubocop-rspec//lib/rubocop/rspec/inject.rb#7
+module RuboCop::RSpec::Inject
+  class << self
+    # source://rubocop-rspec//lib/rubocop/rspec/inject.rb#8
+    def defaults!; end
+  end
+end
+
+# Contains node matchers for common RSpec DSL.
+#
+# RSpec allows for configuring aliases for commonly used DSL elements, e.g.
+# example groups and hooks. It is possible to configure RuboCop RSpec to
+# be able to properly detect these elements in the `RSpec/Language` section
+# of the RuboCop YAML configuration file.
+#
+# In addition to providing useful matchers, this class is responsible for
+# using the configured aliases.
+#
+# source://rubocop-rspec//lib/rubocop/rspec/language.rb#14
+module RuboCop::RSpec::Language
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop-rspec//lib/rubocop/rspec/language.rb#49
+  def example?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/language.rb#28
+  def example_group?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/language.rb#44
+  def example_group_with_body?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/language.rb#25
+  def explicit_rspec?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/language.rb#52
+  def hook?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/language.rb#68
+  def include?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/language.rb#60
+  def let?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/language.rb#22
+  def rspec?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/language.rb#33
+  def shared_group?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/language.rb#37
+  def spec_group?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/language.rb#76
+  def subject?(param0 = T.unsafe(nil)); end
+
+  class << self
+    # Returns the value of attribute config.
+    #
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#18
+    def config; end
+
+    # Sets the attribute config
+    #
+    # @param value the value to set the attribute config to.
+    #
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#18
+    def config=(_arg0); end
+  end
+end
+
+# This is used in Dialect and DescribeClass cops to detect RSpec blocks.
+#
+# source://rubocop-rspec//lib/rubocop/rspec/language.rb#204
+module RuboCop::RSpec::Language::ALL
+  class << self
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#205
+    def all(element); end
+  end
+end
+
+# source://rubocop-rspec//lib/rubocop/rspec/language.rb#78
+module RuboCop::RSpec::Language::ExampleGroups
+  class << self
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#80
+    def all(element); end
+
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#90
+    def focused(element); end
+
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#86
+    def regular(element); end
+
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#94
+    def skipped(element); end
+  end
+end
+
+# source://rubocop-rspec//lib/rubocop/rspec/language.rb#100
+module RuboCop::RSpec::Language::Examples
+  class << self
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#102
+    def all(element); end
+
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#113
+    def focused(element); end
+
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#121
+    def pending(element); end
+
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#109
+    def regular(element); end
+
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#117
+    def skipped(element); end
+  end
+end
+
+# source://rubocop-rspec//lib/rubocop/rspec/language.rb#127
+module RuboCop::RSpec::Language::Expectations
+  class << self
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#128
+    def all(element); end
+  end
+end
+
+# source://rubocop-rspec//lib/rubocop/rspec/language.rb#133
+module RuboCop::RSpec::Language::Helpers
+  class << self
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#134
+    def all(element); end
+  end
+end
+
+# source://rubocop-rspec//lib/rubocop/rspec/language.rb#145
+module RuboCop::RSpec::Language::HookScopes
+  class << self
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#147
+    def all(element); end
+  end
+end
+
+# source://rubocop-rspec//lib/rubocop/rspec/language.rb#146
+RuboCop::RSpec::Language::HookScopes::ALL = T.let(T.unsafe(nil), Array)
+
+# source://rubocop-rspec//lib/rubocop/rspec/language.rb#139
+module RuboCop::RSpec::Language::Hooks
+  class << self
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#140
+    def all(element); end
+  end
+end
+
+# source://rubocop-rspec//lib/rubocop/rspec/language.rb#152
+module RuboCop::RSpec::Language::Includes
+  class << self
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#154
+    def all(element); end
+
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#163
+    def context(element); end
+
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#159
+    def examples(element); end
+  end
+end
+
+# source://rubocop-rspec//lib/rubocop/rspec/language.rb#169
+module RuboCop::RSpec::Language::Runners
+  class << self
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#172
+    def all(element = T.unsafe(nil)); end
+  end
+end
+
+# source://rubocop-rspec//lib/rubocop/rspec/language.rb#170
+RuboCop::RSpec::Language::Runners::ALL = T.let(T.unsafe(nil), Array)
+
+# source://rubocop-rspec//lib/rubocop/rspec/language.rb#180
+module RuboCop::RSpec::Language::SharedGroups
+  class << self
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#182
+    def all(element); end
+
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#191
+    def context(element); end
+
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#187
+    def examples(element); end
+  end
+end
+
+# source://rubocop-rspec//lib/rubocop/rspec/language.rb#197
+module RuboCop::RSpec::Language::Subjects
+  class << self
+    # source://rubocop-rspec//lib/rubocop/rspec/language.rb#198
+    def all(element); end
+  end
+end
+
+# RuboCop RSpec specific extensions of RuboCop::AST::Node
+#
+# source://rubocop-rspec//lib/rubocop/rspec/node.rb#6
+module RuboCop::RSpec::Node
+  # In various cops we want to regard const as literal although it's not
+  # strictly literal.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/node.rb#9
+  def recursive_literal_or_const?; end
+end
+
+# source://rubocop-rspec//lib/rubocop/rspec.rb#6
+RuboCop::RSpec::PROJECT_ROOT = T.let(T.unsafe(nil), Pathname)
+
+# Version information for the RSpec RuboCop plugin.
+#
+# source://rubocop-rspec//lib/rubocop/rspec/version.rb#6
+module RuboCop::RSpec::Version; end
+
+# source://rubocop-rspec//lib/rubocop/rspec/version.rb#7
+RuboCop::RSpec::Version::STRING = T.let(T.unsafe(nil), String)
+
+# RSpec example wording rewriter
+#
+# source://rubocop-rspec//lib/rubocop/rspec/wording.rb#6
+class RuboCop::RSpec::Wording
+  # @return [Wording] a new instance of Wording
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#14
+  def initialize(text, ignore:, replace:); end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#21
+  def rewrite; end
+
+  private
+
+  # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#80
+  def append_suffix(word, suffix); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#65
+  def ignored_word?(word); end
+
+  # Returns the value of attribute ignores.
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#39
+  def ignores; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#51
+  def remove_should_and_pluralize; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#41
+  def replace_prefix(pattern, replacement); end
+
+  # Returns the value of attribute replacements.
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#39
+  def replacements; end
+
+  # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#69
+  def substitute(word); end
+
+  # Returns the value of attribute text.
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#39
+  def text; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop-rspec//lib/rubocop/rspec/wording.rb#47
+  def uppercase?(word); end
+end
+
+# source://rubocop-rspec//lib/rubocop/rspec/wording.rb#11
+RuboCop::RSpec::Wording::ES_SUFFIX_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop-rspec//lib/rubocop/rspec/wording.rb#12
+RuboCop::RSpec::Wording::IES_SUFFIX_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop-rspec//lib/rubocop/rspec/wording.rb#8
+RuboCop::RSpec::Wording::SHOULDNT_BE_PREFIX = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop-rspec//lib/rubocop/rspec/wording.rb#7
+RuboCop::RSpec::Wording::SHOULDNT_PREFIX = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop-rspec//lib/rubocop/rspec/wording.rb#9
+RuboCop::RSpec::Wording::WILL_NOT_PREFIX = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop-rspec//lib/rubocop/rspec/wording.rb#10
+RuboCop::RSpec::Wording::WONT_PREFIX = T.let(T.unsafe(nil), Regexp)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-sorbet@0.6.11.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-sorbet@0.6.11.rbi
deleted file mode 100644
index 63eea9ee29cec..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rubocop-sorbet@0.6.11.rbi
+++ /dev/null
@@ -1,317 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rubocop-sorbet` gem.
-# Please instead update this file by running `bin/tapioca gem rubocop-sorbet`.
-
-module RuboCop; end
-module RuboCop::Cop; end
-RuboCop::Cop::IgnoredPattern = RuboCop::Cop::AllowedPattern
-module RuboCop::Cop::Sorbet; end
-
-class RuboCop::Cop::Sorbet::AllowIncompatibleOverride < ::RuboCop::Cop::Cop
-  def allow_incompatible?(param0); end
-  def allow_incompatible_override?(param0 = T.unsafe(nil)); end
-  def not_nil?(node); end
-  def on_send(node); end
-  def sig?(param0); end
-end
-
-class RuboCop::Cop::Sorbet::BindingConstantWithoutTypeAlias < ::RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def binding_unaliased_type?(param0 = T.unsafe(nil)); end
-  def dynamic_type_creation_with_block?(param0 = T.unsafe(nil)); end
-  def generic_parameter_decl_block_call?(param0 = T.unsafe(nil)); end
-  def generic_parameter_decl_call?(param0 = T.unsafe(nil)); end
-  def method_needing_aliasing_on_t?(param0); end
-  def not_dynamic_type_creation_with_block?(node); end
-  def not_generic_parameter_decl?(node); end
-  def not_nil?(node); end
-  def not_t_let?(node); end
-  def on_casgn(node); end
-  def t_let?(param0 = T.unsafe(nil)); end
-  def using_deprecated_type_alias_syntax?(param0 = T.unsafe(nil)); end
-  def using_type_alias?(param0 = T.unsafe(nil)); end
-end
-
-class RuboCop::Cop::Sorbet::CallbackConditionalsBinding < ::RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Sorbet::CallbackConditionalsBinding::CALLBACKS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Sorbet::CheckedTrueInSignature < ::RuboCop::Cop::Sorbet::SignatureCop
-  include ::RuboCop::Cop::RangeHelp
-
-  def offending_node(param0); end
-  def on_signature(node); end
-end
-
-RuboCop::Cop::Sorbet::CheckedTrueInSignature::MESSAGE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Sorbet::ConstantsFromStrings < ::RuboCop::Cop::Cop
-  def constant_from_string?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-class RuboCop::Cop::Sorbet::EnforceSigilOrder < ::RuboCop::Cop::Sorbet::ValidSigil
-  include ::RuboCop::Cop::RangeHelp
-
-  def autocorrect(_node); end
-  def investigate(processed_source); end
-
-  protected
-
-  def check_magic_comments_order(tokens); end
-  def extract_magic_comments(processed_source); end
-end
-
-RuboCop::Cop::Sorbet::EnforceSigilOrder::CODING_REGEX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Sorbet::EnforceSigilOrder::FROZEN_REGEX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Sorbet::EnforceSigilOrder::INDENT_REGEX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Sorbet::EnforceSigilOrder::MAGIC_REGEX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Sorbet::EnforceSigilOrder::PREFERRED_ORDER = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Cop::Sorbet::EnforceSignatures < ::RuboCop::Cop::Sorbet::SignatureCop
-  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def accessor?(param0 = T.unsafe(nil)); end
-  def autocorrect(node); end
-  def on_def(node); end
-  def on_defs(node); end
-  def on_send(node); end
-  def on_signature(node); end
-  def scope(node); end
-
-  private
-
-  def check_node(node); end
-  def param_type_placeholder; end
-  def return_type_placeholder; end
-end
-
-class RuboCop::Cop::Sorbet::EnforceSignatures::SigSuggestion
-  def initialize(indent, param_placeholder, return_placeholder); end
-
-  def params; end
-  def params=(_arg0); end
-  def returns; end
-  def returns=(_arg0); end
-  def to_autocorrect; end
-
-  private
-
-  def generate_params; end
-  def generate_return; end
-end
-
-class RuboCop::Cop::Sorbet::EnforceSingleSigil < ::RuboCop::Cop::Sorbet::ValidSigil
-  include ::RuboCop::Cop::RangeHelp
-
-  def autocorrect(_node); end
-  def investigate(processed_source); end
-
-  protected
-
-  def extract_all_sigils(processed_source); end
-end
-
-class RuboCop::Cop::Sorbet::FalseSigil < ::RuboCop::Cop::Sorbet::HasSigil
-  def minimum_strictness; end
-end
-
-class RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims < ::RuboCop::Cop::Cop
-  include ::RuboCop::Cop::RangeHelp
-
-  def autocorrect(node); end
-  def extend_t_helpers?(param0 = T.unsafe(nil)); end
-  def extend_t_sig?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Sorbet::ForbidIncludeConstLiteral < ::RuboCop::Cop::Cop
-  def initialize(*_arg0); end
-
-  def autocorrect(node); end
-  def not_lit_const_include?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def used_names; end
-  def used_names=(_arg0); end
-end
-
-RuboCop::Cop::Sorbet::ForbidIncludeConstLiteral::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Sorbet::ForbidRBIOutsideOfAllowedPaths < ::RuboCop::Cop::Cop
-  include ::RuboCop::Cop::RangeHelp
-
-  def investigate(processed_source); end
-
-  private
-
-  def allowed_paths; end
-end
-
-class RuboCop::Cop::Sorbet::ForbidSuperclassConstLiteral < ::RuboCop::Cop::Cop
-  def not_lit_const_superclass?(param0 = T.unsafe(nil)); end
-  def on_class(node); end
-end
-
-RuboCop::Cop::Sorbet::ForbidSuperclassConstLiteral::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Sorbet::ForbidTUnsafe < ::RuboCop::Cop::Cop
-  def on_send(node); end
-  def t_unsafe?(param0 = T.unsafe(nil)); end
-end
-
-class RuboCop::Cop::Sorbet::ForbidTUntyped < ::RuboCop::Cop::Cop
-  def on_send(node); end
-  def t_untyped?(param0 = T.unsafe(nil)); end
-end
-
-class RuboCop::Cop::Sorbet::ForbidUntypedStructProps < ::RuboCop::Cop::Cop
-  def on_class(node); end
-  def subclass_of_t_struct?(param0 = T.unsafe(nil)); end
-  def t_nilable_untyped(param0 = T.unsafe(nil)); end
-  def t_struct(param0 = T.unsafe(nil)); end
-  def t_untyped(param0 = T.unsafe(nil)); end
-  def untyped_props(param0); end
-end
-
-RuboCop::Cop::Sorbet::ForbidUntypedStructProps::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Sorbet::HasSigil < ::RuboCop::Cop::Sorbet::ValidSigil
-  def require_sigil_on_all_files?; end
-end
-
-class RuboCop::Cop::Sorbet::IgnoreSigil < ::RuboCop::Cop::Sorbet::HasSigil
-  def minimum_strictness; end
-end
-
-class RuboCop::Cop::Sorbet::KeywordArgumentOrdering < ::RuboCop::Cop::Sorbet::SignatureCop
-  def on_signature(node); end
-
-  private
-
-  def check_order_for_kwoptargs(parameters); end
-end
-
-module RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour
-  def on_assignment(value); end
-
-  class << self
-    def prepended(base); end
-  end
-end
-
-class RuboCop::Cop::Sorbet::OneAncestorPerLine < ::RuboCop::Cop::Cop
-  def abstract?(param0); end
-  def autocorrect(node); end
-  def more_than_one_ancestor(param0 = T.unsafe(nil)); end
-  def on_class(node); end
-  def on_module(node); end
-  def requires_ancestors(param0); end
-
-  private
-
-  def new_ra_line(indent_count); end
-  def process_node(node); end
-end
-
-RuboCop::Cop::Sorbet::OneAncestorPerLine::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Sorbet::SignatureBuildOrder < ::RuboCop::Cop::Sorbet::SignatureCop
-  def autocorrect(node); end
-  def on_signature(node); end
-  def root_call(param0); end
-
-  private
-
-  def call_chain(sig_child_node); end
-  def can_autocorrect?; end
-  def node_reparsed_with_modern_features(node); end
-end
-
-class RuboCop::Cop::Sorbet::SignatureBuildOrder::ModernBuilder < ::RuboCop::AST::Builder; end
-RuboCop::Cop::Sorbet::SignatureBuildOrder::ORDER = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Cop::Sorbet::SignatureCop < ::RuboCop::Cop::Cop
-  def allowed_recv(recv); end
-  def on_block(node); end
-  def on_signature(_); end
-  def signature?(param0 = T.unsafe(nil)); end
-  def with_runtime?(param0 = T.unsafe(nil)); end
-  def without_runtime?(param0 = T.unsafe(nil)); end
-end
-
-class RuboCop::Cop::Sorbet::SingleLineRbiClassModuleDefinitions < ::RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def on_class(node); end
-  def on_module(node); end
-
-  protected
-
-  def convert_newlines(source); end
-  def process_node(node); end
-end
-
-RuboCop::Cop::Sorbet::SingleLineRbiClassModuleDefinitions::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Sorbet::StrictSigil < ::RuboCop::Cop::Sorbet::HasSigil
-  def minimum_strictness; end
-end
-
-class RuboCop::Cop::Sorbet::StrongSigil < ::RuboCop::Cop::Sorbet::HasSigil
-  def minimum_strictness; end
-end
-
-class RuboCop::Cop::Sorbet::TrueSigil < ::RuboCop::Cop::Sorbet::HasSigil
-  def minimum_strictness; end
-end
-
-class RuboCop::Cop::Sorbet::TypeAliasName < ::RuboCop::Cop::Cop
-  def casgn_type_alias?(param0 = T.unsafe(nil)); end
-  def on_casgn(node); end
-end
-
-RuboCop::Cop::Sorbet::TypeAliasName::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Sorbet::ValidSigil < ::RuboCop::Cop::Cop
-  def autocorrect(_node); end
-  def investigate(processed_source); end
-
-  protected
-
-  def check_sigil_present(sigil); end
-  def check_strictness_level(sigil, strictness); end
-  def check_strictness_not_empty(sigil, strictness); end
-  def check_strictness_valid(sigil, strictness); end
-  def extract_sigil(processed_source); end
-  def extract_strictness(sigil); end
-  def minimum_strictness; end
-  def require_sigil_on_all_files?; end
-  def suggested_strictness; end
-  def suggested_strictness_level(minimum_strictness, suggested_strictness); end
-end
-
-RuboCop::Cop::Sorbet::ValidSigil::SIGIL_REGEX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Sorbet::ValidSigil::STRICTNESS_LEVELS = T.let(T.unsafe(nil), Array)
-RuboCop::NodePattern = RuboCop::AST::NodePattern
-RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource
-module RuboCop::Sorbet; end
-RuboCop::Sorbet::CONFIG = T.let(T.unsafe(nil), Hash)
-RuboCop::Sorbet::CONFIG_DEFAULT = T.let(T.unsafe(nil), Pathname)
-class RuboCop::Sorbet::Error < ::StandardError; end
-
-module RuboCop::Sorbet::Inject
-  class << self
-    def defaults!; end
-  end
-end
-
-RuboCop::Sorbet::PROJECT_ROOT = T.let(T.unsafe(nil), Pathname)
-RuboCop::Sorbet::VERSION = T.let(T.unsafe(nil), String)
-RuboCop::Token = RuboCop::AST::Token
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop@1.32.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop@1.32.0.rbi
deleted file mode 100644
index fb54326192157..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rubocop@1.32.0.rbi
+++ /dev/null
@@ -1,13946 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rubocop` gem.
-# Please instead update this file by running `bin/tapioca gem rubocop`.
-
-module RuboCop; end
-
-class RuboCop::CLI
-  def initialize; end
-
-  def config_store; end
-  def options; end
-  def run(args = T.unsafe(nil)); end
-
-  private
-
-  def act_on_options; end
-  def apply_default_formatter; end
-  def execute_runners; end
-  def handle_exiting_options; end
-  def parallel_by_default!; end
-  def run_command(name); end
-  def set_options_to_config_loader; end
-  def suggest_extensions; end
-  def validate_options_vs_config; end
-end
-
-module RuboCop::CLI::Command
-  class << self
-    def run(env, name); end
-
-    private
-
-    def class_for(name); end
-  end
-end
-
-class RuboCop::CLI::Command::AutoGenerateConfig < ::RuboCop::CLI::Command::Base
-  def run; end
-
-  private
-
-  def add_formatter; end
-  def add_inheritance_from_auto_generated_file(config_file); end
-  def execute_runner; end
-  def existing_configuration(config_file); end
-  def line_length_cop(config); end
-  def line_length_enabled?(config); end
-  def max_line_length(config); end
-  def maybe_run_line_length_cop; end
-  def options_config_in_root?; end
-  def relative_path_to_todo_from_options_config; end
-  def reset_config_and_auto_gen_file; end
-  def run_all_cops(line_length_contents); end
-  def run_line_length_cop; end
-  def same_max_line_length?(config1, config2); end
-  def skip_line_length_cop(reason); end
-  def write_config_file(file_name, file_string, rubocop_yml_contents); end
-end
-
-RuboCop::CLI::Command::AutoGenerateConfig::AUTO_GENERATED_FILE = T.let(T.unsafe(nil), String)
-RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1 = T.let(T.unsafe(nil), String)
-RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1_DISABLED = T.let(T.unsafe(nil), String)
-RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1_OVERRIDDEN = T.let(T.unsafe(nil), String)
-RuboCop::CLI::Command::AutoGenerateConfig::PHASE_2 = T.let(T.unsafe(nil), String)
-RuboCop::CLI::Command::AutoGenerateConfig::YAML_OPTIONAL_DOC_START = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::CLI::Command::Base
-  def initialize(env); end
-
-  def env; end
-
-  class << self
-    def by_command_name(name); end
-    def command_name; end
-    def command_name=(_arg0); end
-    def inherited(subclass); end
-  end
-end
-
-class RuboCop::CLI::Command::ExecuteRunner < ::RuboCop::CLI::Command::Base
-  include ::RuboCop::Formatter::TextUtil
-
-  def run; end
-
-  private
-
-  def display_error_summary(errors); end
-  def display_summary(runner); end
-  def display_warning_summary(warnings); end
-  def execute_runner(paths); end
-  def maybe_print_corrected_source; end
-  def with_redirect; end
-end
-
-RuboCop::CLI::Command::ExecuteRunner::INTEGRATION_FORMATTERS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::CLI::Command::InitDotfile < ::RuboCop::CLI::Command::Base
-  def run; end
-end
-
-RuboCop::CLI::Command::InitDotfile::DOTFILE = T.let(T.unsafe(nil), String)
-
-class RuboCop::CLI::Command::ShowCops < ::RuboCop::CLI::Command::Base
-  def initialize(env); end
-
-  def run; end
-
-  private
-
-  def config_lines(cop); end
-  def cops_of_department(cops, department); end
-  def print_available_cops; end
-  def print_cop_details(cops); end
-  def print_cops_of_department(registry, department, show_all); end
-  def selected_cops_of_department(cops, department); end
-end
-
-class RuboCop::CLI::Command::ShowDocsUrl < ::RuboCop::CLI::Command::Base
-  def initialize(env); end
-
-  def run; end
-
-  private
-
-  def cops_array; end
-  def print_documentation_url; end
-  def registry_hash; end
-end
-
-class RuboCop::CLI::Command::SuggestExtensions < ::RuboCop::CLI::Command::Base
-  def run; end
-
-  private
-
-  def current_formatter; end
-  def dependent_gems; end
-  def extensions; end
-  def installed_gems; end
-  def lockfile; end
-  def puts(*args); end
-  def skip?; end
-end
-
-RuboCop::CLI::Command::SuggestExtensions::INCLUDED_FORMATTERS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::CLI::Command::Version < ::RuboCop::CLI::Command::Base
-  def run; end
-end
-
-RuboCop::CLI::DEFAULT_PARALLEL_OPTIONS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::CLI::Environment
-  def initialize(options, config_store, paths); end
-
-  def config_store; end
-  def options; end
-  def paths; end
-  def run(name); end
-end
-
-class RuboCop::CLI::Finished < ::StandardError; end
-RuboCop::CLI::STATUS_ERROR = T.let(T.unsafe(nil), Integer)
-RuboCop::CLI::STATUS_INTERRUPTED = T.let(T.unsafe(nil), Integer)
-RuboCop::CLI::STATUS_OFFENSES = T.let(T.unsafe(nil), Integer)
-RuboCop::CLI::STATUS_SUCCESS = T.let(T.unsafe(nil), Integer)
-
-class RuboCop::CachedData
-  def initialize(filename); end
-
-  def from_json(text); end
-  def to_json(offenses); end
-
-  private
-
-  def deserialize_offenses(offenses); end
-  def message(offense); end
-  def serialize_offense(offense); end
-end
-
-class RuboCop::CommentConfig
-  def initialize(processed_source); end
-
-  def comment_only_line?(line_number); end
-  def cop_disabled_line_ranges; end
-  def cop_enabled_at_line?(cop, line_number); end
-  def extra_enabled_comments; end
-  def processed_source; end
-
-  private
-
-  def analyze; end
-  def analyze_cop(analysis, directive); end
-  def analyze_disabled(analysis, directive); end
-  def analyze_rest(analysis, directive); end
-  def analyze_single_line(analysis, directive); end
-  def cop_line_ranges(analysis); end
-  def each_directive; end
-  def extra_enabled_comments_with_names(extras:, names:); end
-  def handle_enable_all(directive, names, extras); end
-  def handle_switch(directive, names, extras); end
-  def non_comment_token_line_numbers; end
-  def qualified_cop_name(cop_name); end
-end
-
-class RuboCop::CommentConfig::CopAnalysis < ::Struct
-  def line_ranges; end
-  def line_ranges=(_); end
-  def start_line_number; end
-  def start_line_number=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RuboCop::Config
-  include ::RuboCop::PathUtil
-  include ::RuboCop::FileFinder
-  extend ::Forwardable
-
-  def initialize(hash = T.unsafe(nil), loaded_path = T.unsafe(nil)); end
-
-  def [](*args, &block); end
-  def []=(*args, &block); end
-  def active_support_extensions_enabled?; end
-  def add_excludes_from_higher_level(highest_config); end
-  def allowed_camel_case_file?(file); end
-  def base_dir_for_path_parameters; end
-  def bundler_lock_file_path; end
-  def check; end
-  def delete(*args, &block); end
-  def deprecation_check; end
-  def dig(*args, &block); end
-  def disabled_new_cops?; end
-  def each(*args, &block); end
-  def each_key(*args, &block); end
-  def enabled_new_cops?; end
-  def fetch(*args, &block); end
-  def file_to_exclude?(file); end
-  def file_to_include?(file); end
-  def for_all_cops; end
-  def for_badge(badge); end
-  def for_cop(cop); end
-  def for_department(department_name); end
-  def internal?; end
-  def key?(*args, &block); end
-  def keys(*args, &block); end
-  def loaded_features; end
-  def loaded_path; end
-  def make_excludes_absolute; end
-  def map(*args, &block); end
-  def merge(*args, &block); end
-  def path_relative_to_config(path); end
-  def patterns_to_exclude; end
-  def patterns_to_include; end
-  def pending_cops; end
-  def possibly_include_hidden?; end
-  def replace(*args, &block); end
-  def signature; end
-  def smart_loaded_path; end
-  def target_rails_version; end
-  def target_ruby_version(*args, &block); end
-  def to_h(*args, &block); end
-  def to_hash(*args, &block); end
-  def to_s; end
-  def transform_values(*args, &block); end
-  def validate(*args, &block); end
-  def validate_after_resolution; end
-
-  private
-
-  def department_of(qualified_cop_name); end
-  def enable_cop?(qualified_cop_name, cop_options); end
-  def read_rails_version_from_bundler_lock_file; end
-  def target_rails_version_from_bundler_lock_file; end
-
-  class << self
-    def create(hash, path, check: T.unsafe(nil)); end
-  end
-end
-
-class RuboCop::Config::CopConfig < ::Struct
-  def metadata; end
-  def metadata=(_); end
-  def name; end
-  def name=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-RuboCop::Config::DEFAULT_RAILS_VERSION = T.let(T.unsafe(nil), Float)
-
-class RuboCop::ConfigLoader
-  extend ::RuboCop::FileFinder
-
-  class << self
-    def add_excludes_from_files(config, config_file); end
-    def add_loaded_features(loaded_features); end
-    def add_missing_namespaces(path, hash); end
-    def clear_options; end
-    def configuration_file_for(target_dir); end
-    def configuration_from_file(config_file, check: T.unsafe(nil)); end
-    def debug; end
-    def debug=(_arg0); end
-    def debug?; end
-    def default_configuration; end
-    def default_configuration=(_arg0); end
-    def disable_pending_cops; end
-    def disable_pending_cops=(_arg0); end
-    def enable_pending_cops; end
-    def enable_pending_cops=(_arg0); end
-    def ignore_parent_exclusion; end
-    def ignore_parent_exclusion=(_arg0); end
-    def ignore_parent_exclusion?; end
-    def ignore_unrecognized_cops; end
-    def ignore_unrecognized_cops=(_arg0); end
-    def load_file(file, check: T.unsafe(nil)); end
-    def load_yaml_configuration(absolute_path); end
-    def loaded_features; end
-    def merge(base_hash, derived_hash); end
-    def merge_with_default(config, config_file, unset_nil: T.unsafe(nil)); end
-    def possible_new_cops?(config); end
-    def project_root; end
-    def project_root=(_arg0); end
-    def warn_on_pending_cops(pending_cops); end
-    def warn_pending_cop(cop); end
-
-    private
-
-    def check_duplication(yaml_code, absolute_path); end
-    def expand_path(path); end
-    def file_path(file); end
-    def find_project_dotfile(target_dir); end
-    def find_project_root; end
-    def find_user_dotfile; end
-    def find_user_xdg_config; end
-    def read_file(absolute_path); end
-    def resolver; end
-    def yaml_safe_load(yaml_code, filename); end
-    def yaml_safe_load!(yaml_code, filename); end
-  end
-end
-
-RuboCop::ConfigLoader::DEFAULT_FILE = T.let(T.unsafe(nil), String)
-RuboCop::ConfigLoader::DOTFILE = T.let(T.unsafe(nil), String)
-RuboCop::ConfigLoader::RUBOCOP_HOME = T.let(T.unsafe(nil), String)
-RuboCop::ConfigLoader::XDG_CONFIG = T.let(T.unsafe(nil), String)
-
-class RuboCop::ConfigLoaderResolver
-  def fix_include_paths(base_config_path, hash, path, key, value); end
-  def merge(base_hash, derived_hash, **opts); end
-  def merge_with_default(config, config_file, unset_nil:); end
-  def override_department_setting_for_cops(base_hash, derived_hash); end
-  def override_enabled_for_disabled_departments(base_hash, derived_hash); end
-  def resolve_inheritance(path, hash, file, debug); end
-  def resolve_inheritance_from_gems(hash); end
-  def resolve_requires(path, hash); end
-
-  private
-
-  def base_configs(path, inherit_from, file); end
-  def determine_inherit_mode(hash, key); end
-  def disabled?(hash, department); end
-  def duplicate_setting?(base_hash, derived_hash, key, inherited_file); end
-  def gem_config_path(gem_name, relative_config_path); end
-  def handle_disabled_by_default(config, new_default_configuration); end
-  def inherited_file(path, inherit_from, file); end
-  def merge_hashes?(base_hash, derived_hash, key); end
-  def remote_file?(uri); end
-  def should_merge?(mode, key); end
-  def should_override?(mode, key); end
-  def should_union?(derived_hash, base_hash, root_mode, key); end
-  def transform(config, &block); end
-  def warn_on_duplicate_setting(base_hash, derived_hash, key, **opts); end
-end
-
-class RuboCop::ConfigNotFoundError < ::RuboCop::Error; end
-
-class RuboCop::ConfigObsoletion
-  def initialize(config); end
-
-  def reject_obsolete!; end
-  def rules; end
-  def warnings; end
-
-  private
-
-  def load_cop_rules(rules); end
-  def load_parameter_rules(rules); end
-  def load_rules; end
-  def obsoletions; end
-
-  class << self
-    def files; end
-    def files=(_arg0); end
-    def legacy_cop_names; end
-  end
-end
-
-RuboCop::ConfigObsoletion::COP_RULE_CLASSES = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::ConfigObsoletion::ChangedEnforcedStyles < ::RuboCop::ConfigObsoletion::ParameterRule
-  def message; end
-  def violated?; end
-
-  private
-
-  def value; end
-end
-
-RuboCop::ConfigObsoletion::ChangedEnforcedStyles::BASE_MESSAGE = T.let(T.unsafe(nil), String)
-
-class RuboCop::ConfigObsoletion::ChangedParameter < ::RuboCop::ConfigObsoletion::ParameterRule
-  def message; end
-end
-
-RuboCop::ConfigObsoletion::ChangedParameter::BASE_MESSAGE = T.let(T.unsafe(nil), String)
-
-class RuboCop::ConfigObsoletion::CopRule < ::RuboCop::ConfigObsoletion::Rule
-  def initialize(config, old_name); end
-
-  def cop_rule?; end
-  def message; end
-  def old_name; end
-  def violated?; end
-  def warning?; end
-end
-
-RuboCop::ConfigObsoletion::DEFAULT_RULES_FILE = T.let(T.unsafe(nil), String)
-
-class RuboCop::ConfigObsoletion::ExtractedCop < ::RuboCop::ConfigObsoletion::CopRule
-  def initialize(config, old_name, gem); end
-
-  def department; end
-  def gem; end
-  def rule_message; end
-  def violated?; end
-
-  private
-
-  def affected_cops; end
-  def feature_loaded?; end
-end
-
-RuboCop::ConfigObsoletion::PARAMETER_RULE_CLASSES = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::ConfigObsoletion::ParameterRule < ::RuboCop::ConfigObsoletion::Rule
-  def initialize(config, cop, parameter, metadata); end
-
-  def cop; end
-  def metadata; end
-  def parameter; end
-  def parameter_rule?; end
-  def violated?; end
-  def warning?; end
-
-  private
-
-  def alternative; end
-  def reason; end
-  def severity; end
-end
-
-class RuboCop::ConfigObsoletion::RemovedCop < ::RuboCop::ConfigObsoletion::CopRule
-  def initialize(config, old_name, metadata); end
-
-  def metadata; end
-  def old_name; end
-  def rule_message; end
-
-  private
-
-  def alternatives; end
-  def reason; end
-end
-
-RuboCop::ConfigObsoletion::RemovedCop::BASE_MESSAGE = T.let(T.unsafe(nil), String)
-
-class RuboCop::ConfigObsoletion::RenamedCop < ::RuboCop::ConfigObsoletion::CopRule
-  def initialize(config, old_name, new_name); end
-
-  def new_name; end
-  def rule_message; end
-
-  private
-
-  def moved?; end
-  def verb; end
-end
-
-class RuboCop::ConfigObsoletion::Rule
-  def initialize(config); end
-
-  def cop_rule?; end
-  def parameter_rule?; end
-  def violated?; end
-
-  private
-
-  def config; end
-  def smart_loaded_path; end
-  def to_sentence(collection, connector: T.unsafe(nil)); end
-end
-
-class RuboCop::ConfigObsoletion::SplitCop < ::RuboCop::ConfigObsoletion::CopRule
-  def initialize(config, old_name, metadata); end
-
-  def metadata; end
-  def rule_message; end
-
-  private
-
-  def alternatives; end
-end
-
-class RuboCop::ConfigRegeneration
-  def options; end
-
-  private
-
-  def generation_command; end
-  def todo_exists?; end
-end
-
-RuboCop::ConfigRegeneration::AUTO_GENERATED_FILE = T.let(T.unsafe(nil), String)
-RuboCop::ConfigRegeneration::COMMAND_REGEX = T.let(T.unsafe(nil), Regexp)
-RuboCop::ConfigRegeneration::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::ConfigStore
-  def initialize; end
-
-  def for(file_or_dir); end
-  def for_dir(dir); end
-  def for_file(file); end
-  def for_pwd; end
-  def force_default_config!; end
-  def options_config=(options_config); end
-  def unvalidated; end
-  def validated; end
-  def validated?; end
-end
-
-class RuboCop::ConfigValidator
-  extend ::Forwardable
-
-  def initialize(config); end
-
-  def for_all_cops(*args, &block); end
-  def smart_loaded_path(*args, &block); end
-  def target_ruby_version; end
-  def validate; end
-  def validate_after_resolution; end
-  def validate_section_presence(name); end
-
-  private
-
-  def alert_about_unrecognized_cops(invalid_cop_names); end
-  def check_cop_config_value(hash, parent = T.unsafe(nil)); end
-  def check_obsoletions; end
-  def check_target_ruby; end
-  def each_invalid_parameter(cop_name); end
-  def list_unknown_cops(invalid_cop_names); end
-  def msg_not_boolean(parent, key, value); end
-  def reject_conflicting_safe_settings; end
-  def reject_mutually_exclusive_defaults; end
-  def suggestion(name); end
-  def target_ruby; end
-  def validate_enforced_styles(valid_cop_names); end
-  def validate_new_cops_parameter; end
-  def validate_parameter_names(valid_cop_names); end
-  def validate_support_and_has_list(name, formats, valid); end
-  def validate_syntax_cop; end
-end
-
-RuboCop::ConfigValidator::COMMON_PARAMS = T.let(T.unsafe(nil), Array)
-RuboCop::ConfigValidator::CONFIG_CHECK_DEPARTMENTS = T.let(T.unsafe(nil), Array)
-RuboCop::ConfigValidator::CONFIG_CHECK_KEYS = T.let(T.unsafe(nil), Set)
-RuboCop::ConfigValidator::INTERNAL_PARAMS = T.let(T.unsafe(nil), Array)
-RuboCop::ConfigValidator::NEW_COPS_VALUES = T.let(T.unsafe(nil), Array)
-module RuboCop::Cop; end
-
-module RuboCop::Cop::Alignment
-  private
-
-  def check_alignment(items, base_column = T.unsafe(nil)); end
-  def column_delta; end
-  def configured_indentation_width; end
-  def display_column(range); end
-  def each_bad_alignment(items, base_column); end
-  def end_of_line_comment(line); end
-  def indentation(node); end
-  def offset(node); end
-  def register_offense(offense_node, message_node); end
-  def within?(inner, outer); end
-end
-
-RuboCop::Cop::Alignment::SPACE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::AlignmentCorrector
-  extend ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::Alignment
-
-  class << self
-    def align_end(corrector, processed_source, node, align_to); end
-    def correct(corrector, processed_source, node, column_delta); end
-    def processed_source; end
-
-    private
-
-    def alignment_column(align_to); end
-    def autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges); end
-    def block_comment_within?(expr); end
-    def calculate_range(expr, line_begin_pos, column_delta); end
-    def delimited_string_literal?(node); end
-    def each_line(expr); end
-    def inside_string_range(node); end
-    def inside_string_ranges(node); end
-    def remove(range, corrector); end
-    def whitespace_range(node); end
-  end
-end
-
-module RuboCop::Cop::AllowedIdentifiers
-  def allowed_identifier?(name); end
-  def allowed_identifiers; end
-end
-
-RuboCop::Cop::AllowedIdentifiers::SIGILS = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::AllowedMethods
-  private
-
-  def allowed_method?(name); end
-  def allowed_methods; end
-end
-
-module RuboCop::Cop::AllowedPattern
-  private
-
-  def allowed_line?(line); end
-  def allowed_patterns; end
-  def ignored_line?(line); end
-  def matches_allowed_pattern?(line); end
-  def matches_ignored_pattern?(line); end
-end
-
-class RuboCop::Cop::AmbiguousCopName < ::RuboCop::Error
-  def initialize(name, origin, badges); end
-end
-
-RuboCop::Cop::AmbiguousCopName::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::AnnotationComment
-  extend ::Forwardable
-
-  def initialize(comment, keywords); end
-
-  def annotation?; end
-  def bounds; end
-  def colon; end
-  def comment; end
-  def correct?(colon:); end
-  def keyword; end
-  def margin; end
-  def note; end
-  def space; end
-
-  private
-
-  def just_keyword_of_sentence?; end
-  def keyword_appearance?; end
-  def keywords; end
-  def split_comment(comment); end
-end
-
-module RuboCop::Cop::ArrayMinSize
-  private
-
-  def array_style_detected(style, ary_size); end
-  def below_array_length?(node); end
-  def largest_brackets_size(style, ary_size); end
-  def min_size_config; end
-  def smallest_percent_size(style, ary_size); end
-end
-
-module RuboCop::Cop::ArraySyntax
-  private
-
-  def bracketed_array_of?(element_type, node); end
-end
-
-module RuboCop::Cop::AutoCorrector
-  def support_autocorrect?; end
-end
-
-module RuboCop::Cop::AutocorrectLogic
-  def autocorrect?; end
-  def autocorrect_enabled?; end
-  def autocorrect_requested?; end
-  def autocorrect_with_disable_uncorrectable?; end
-  def correctable?; end
-  def disable_uncorrectable?; end
-  def safe_autocorrect?; end
-
-  private
-
-  def disable_offense(range); end
-  def disable_offense_at_end_of_line(range, eol_comment); end
-  def disable_offense_before_and_after(range_by_lines); end
-  def max_line_length; end
-  def range_by_lines(range); end
-  def range_of_first_line(range); end
-  def surrounding_heredoc(offense_range); end
-end
-
-class RuboCop::Cop::Badge
-  def initialize(class_name_parts); end
-
-  def ==(other); end
-  def cop_name; end
-  def department; end
-  def eql?(other); end
-  def hash; end
-  def match?(other); end
-  def qualified?; end
-  def to_s; end
-  def with_department(department); end
-
-  class << self
-    def camel_case(name_part); end
-    def for(class_name); end
-    def parse(identifier); end
-  end
-end
-
-class RuboCop::Cop::Base
-  include ::RuboCop::AST::Sexp
-  include ::RuboCop::PathUtil
-  include ::RuboCop::Cop::Util
-  include ::RuboCop::Cop::IgnoredNode
-  include ::RuboCop::Cop::AutocorrectLogic
-  extend ::RuboCop::AST::Sexp
-  extend ::RuboCop::AST::NodePattern::Macros
-  extend ::RuboCop::ExcludeLimit
-
-  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def active_support_extensions_enabled?; end
-  def add_global_offense(message = T.unsafe(nil), severity: T.unsafe(nil)); end
-  def add_offense(node_or_range, message: T.unsafe(nil), severity: T.unsafe(nil), &block); end
-  def callbacks_needed; end
-  def config; end
-  def config_to_allow_offenses; end
-  def config_to_allow_offenses=(hash); end
-  def cop_config; end
-  def cop_name; end
-  def excluded_file?(file); end
-  def external_dependency_checksum; end
-  def message(_range = T.unsafe(nil)); end
-  def name; end
-  def offenses; end
-  def on_investigation_end; end
-  def on_new_investigation; end
-  def on_other_file; end
-  def parse(source, path = T.unsafe(nil)); end
-  def processed_source; end
-  def ready; end
-  def relevant_file?(file); end
-  def target_rails_version; end
-  def target_ruby_version; end
-
-  private
-
-  def annotate(message); end
-  def apply_correction(corrector); end
-  def attempt_correction(range, corrector); end
-  def begin_investigation(processed_source); end
-  def callback_argument(range); end
-  def complete_investigation; end
-  def correct(range); end
-  def current_offense_locations; end
-  def currently_disabled_lines; end
-  def custom_severity; end
-  def default_severity; end
-  def disable_uncorrectable(range); end
-  def enabled_line?(line_number); end
-  def file_name_matches_any?(file, parameter, default_result); end
-  def find_message(range, message); end
-  def find_severity(_range, severity); end
-  def range_from_node_or_range(node_or_range); end
-  def reset_investigation; end
-  def use_corrector(range, corrector); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-    def badge; end
-    def callbacks_needed; end
-    def cop_name; end
-    def department; end
-    def documentation_url; end
-    def exclude_from_registry; end
-    def inherited(subclass); end
-    def joining_forces; end
-    def lint?; end
-    def match?(given_names); end
-    def support_autocorrect?; end
-    def support_multiple_source?; end
-
-    private
-
-    def builtin?; end
-    def restrict_on_send; end
-  end
-end
-
-class RuboCop::Cop::Base::InvestigationReport < ::Struct
-  def cop; end
-  def cop=(_); end
-  def corrector; end
-  def corrector=(_); end
-  def offenses; end
-  def offenses=(_); end
-  def processed_source; end
-  def processed_source=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-RuboCop::Cop::Base::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
-module RuboCop::Cop::Bundler; end
-
-class RuboCop::Cop::Bundler::DuplicatedGem < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def gem_declarations(param0); end
-  def on_new_investigation; end
-
-  private
-
-  def conditional_declaration?(nodes); end
-  def duplicated_gem_nodes; end
-  def register_offense(node, gem_name, line_of_first_occurrence); end
-  def within_conditional?(node, conditional_node); end
-end
-
-RuboCop::Cop::Bundler::DuplicatedGem::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Bundler::GemComment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::VisibilityHelp
-  include ::RuboCop::Cop::DefNode
-  include ::RuboCop::Cop::GemDeclaration
-
-  def on_send(node); end
-
-  private
-
-  def checked_options_present?(node); end
-  def commented?(node); end
-  def commented_any_descendant?(node); end
-  def contains_checked_options?(node); end
-  def gem_options(node); end
-  def ignored_gem?(node); end
-  def precede?(node1, node2); end
-  def preceding_comment?(node1, node2); end
-  def preceding_lines(node); end
-  def restrictive_version_specified_gem?(node); end
-  def version_specified_gem?(node); end
-end
-
-RuboCop::Cop::Bundler::GemComment::CHECKED_OPTIONS_CONFIG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Bundler::GemComment::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Bundler::GemComment::RESTRICTIVE_VERSION_PATTERN = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Bundler::GemComment::RESTRICTIVE_VERSION_SPECIFIERS_OPTION = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Bundler::GemComment::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Bundler::GemComment::VERSION_SPECIFIERS_OPTION = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Bundler::GemFilename < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_new_investigation; end
-
-  private
-
-  def expected_gemfile?(basename); end
-  def gemfile_offense?(basename); end
-  def gemfile_required?; end
-  def gems_rb_offense?(basename); end
-  def gems_rb_required?; end
-  def register_gemfile_offense(file_path, basename); end
-  def register_gems_rb_offense(file_path, basename); end
-  def register_offense(file_path, basename); end
-end
-
-RuboCop::Cop::Bundler::GemFilename::GEMFILE_FILES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Bundler::GemFilename::GEMS_RB_FILES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Bundler::GemFilename::MSG_GEMFILE_MISMATCHED = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Bundler::GemFilename::MSG_GEMFILE_REQUIRED = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Bundler::GemFilename::MSG_GEMS_RB_MISMATCHED = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Bundler::GemFilename::MSG_GEMS_RB_REQUIRED = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Bundler::GemVersion < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::GemDeclaration
-
-  def includes_commit_reference?(param0 = T.unsafe(nil)); end
-  def includes_version_specification?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def allowed_gem?(node); end
-  def allowed_gems; end
-  def forbidden_offense?(node); end
-  def forbidden_style?; end
-  def message(range); end
-  def offense?(node); end
-  def required_offense?(node); end
-  def required_style?; end
-  def version_specification?(expression); end
-end
-
-RuboCop::Cop::Bundler::GemVersion::FORBIDDEN_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Bundler::GemVersion::REQUIRED_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Bundler::GemVersion::VERSION_SPECIFICATION_REGEX = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::Bundler::InsecureProtocolSource < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def insecure_protocol_source?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def allow_http_protocol?; end
-end
-
-RuboCop::Cop::Bundler::InsecureProtocolSource::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Bundler::InsecureProtocolSource::MSG_HTTP_PROTOCOL = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Bundler::InsecureProtocolSource::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Bundler::OrderedGems < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::OrderedGemNode
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def gem_declarations(param0); end
-  def on_new_investigation; end
-
-  private
-
-  def previous_declaration(node); end
-end
-
-RuboCop::Cop::Bundler::OrderedGems::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::CheckAssignment
-  def on_and_asgn(node); end
-  def on_casgn(node); end
-  def on_cvasgn(node); end
-  def on_gvasgn(node); end
-  def on_ivasgn(node); end
-  def on_lvasgn(node); end
-  def on_masgn(node); end
-  def on_op_asgn(node); end
-  def on_or_asgn(node); end
-  def on_send(node); end
-
-  private
-
-  def extract_rhs(node); end
-
-  class << self
-    def extract_rhs(node); end
-  end
-end
-
-module RuboCop::Cop::CheckLineBreakable
-  def extract_breakable_node(node, max); end
-
-  private
-
-  def all_on_same_line?(nodes); end
-  def already_on_multiple_lines?(node); end
-  def breakable_collection?(node, elements); end
-  def children_could_be_broken_up?(children); end
-  def contained_by_breakable_collection_on_same_line?(node); end
-  def contained_by_multiline_collection_that_could_be_broken_up?(node); end
-  def extract_breakable_node_from_elements(node, elements, max); end
-  def extract_first_element_over_column_limit(node, elements, max); end
-  def first_argument_is_heredoc?(node); end
-  def process_args(args); end
-  def safe_to_ignore?(node); end
-  def shift_elements_for_heredoc_arg(node, elements, index); end
-  def within_column_limit?(element, max, line); end
-end
-
-module RuboCop::Cop::CodeLength
-  extend ::RuboCop::ExcludeLimit
-
-  def max=(value); end
-
-  private
-
-  def build_code_length_calculator(node); end
-  def check_code_length(node); end
-  def count_as_one; end
-  def count_comments?; end
-  def irrelevant_line(source_line); end
-  def max_length; end
-  def message(length, max_length); end
-end
-
-RuboCop::Cop::CodeLength::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::CommentsHelp
-  def contains_comments?(node); end
-  def source_range_with_comment(node); end
-
-  private
-
-  def begin_pos_with_comment(node); end
-  def buffer; end
-  def end_position_for(node); end
-  def find_end_line(node); end
-  def start_line_position(node); end
-end
-
-class RuboCop::Cop::Commissioner
-  include ::RuboCop::AST::Traversal
-
-  def initialize(cops, forces = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def errors; end
-  def investigate(processed_source); end
-  def on___ENCODING__(node); end
-  def on___FILE__(node); end
-  def on___LINE__(node); end
-  def on_alias(node); end
-  def on_and(node); end
-  def on_and_asgn(node); end
-  def on_arg(node); end
-  def on_arg_expr(node); end
-  def on_args(node); end
-  def on_array(node); end
-  def on_array_pattern(node); end
-  def on_array_pattern_with_tail(node); end
-  def on_back_ref(node); end
-  def on_begin(node); end
-  def on_block(node); end
-  def on_block_pass(node); end
-  def on_blockarg(node); end
-  def on_break(node); end
-  def on_case(node); end
-  def on_case_match(node); end
-  def on_casgn(node); end
-  def on_cbase(node); end
-  def on_class(node); end
-  def on_complex(node); end
-  def on_const(node); end
-  def on_const_pattern(node); end
-  def on_csend(node); end
-  def on_cvar(node); end
-  def on_cvasgn(node); end
-  def on_def(node); end
-  def on_defined?(node); end
-  def on_defs(node); end
-  def on_dstr(node); end
-  def on_dsym(node); end
-  def on_eflipflop(node); end
-  def on_empty_else(node); end
-  def on_ensure(node); end
-  def on_erange(node); end
-  def on_false(node); end
-  def on_find_pattern(node); end
-  def on_float(node); end
-  def on_for(node); end
-  def on_forward_arg(node); end
-  def on_forward_args(node); end
-  def on_forwarded_args(node); end
-  def on_gvar(node); end
-  def on_gvasgn(node); end
-  def on_hash(node); end
-  def on_hash_pattern(node); end
-  def on_if(node); end
-  def on_if_guard(node); end
-  def on_iflipflop(node); end
-  def on_in_match(node); end
-  def on_in_pattern(node); end
-  def on_index(node); end
-  def on_indexasgn(node); end
-  def on_int(node); end
-  def on_irange(node); end
-  def on_ivar(node); end
-  def on_ivasgn(node); end
-  def on_kwarg(node); end
-  def on_kwargs(node); end
-  def on_kwbegin(node); end
-  def on_kwnilarg(node); end
-  def on_kwoptarg(node); end
-  def on_kwrestarg(node); end
-  def on_kwsplat(node); end
-  def on_lambda(node); end
-  def on_lvar(node); end
-  def on_lvasgn(node); end
-  def on_masgn(node); end
-  def on_match_alt(node); end
-  def on_match_as(node); end
-  def on_match_current_line(node); end
-  def on_match_nil_pattern(node); end
-  def on_match_pattern(node); end
-  def on_match_pattern_p(node); end
-  def on_match_rest(node); end
-  def on_match_var(node); end
-  def on_match_with_lvasgn(node); end
-  def on_match_with_trailing_comma(node); end
-  def on_mlhs(node); end
-  def on_module(node); end
-  def on_next(node); end
-  def on_nil(node); end
-  def on_not(node); end
-  def on_nth_ref(node); end
-  def on_numblock(node); end
-  def on_op_asgn(node); end
-  def on_optarg(node); end
-  def on_or(node); end
-  def on_or_asgn(node); end
-  def on_pair(node); end
-  def on_pin(node); end
-  def on_postexe(node); end
-  def on_preexe(node); end
-  def on_procarg0(node); end
-  def on_rational(node); end
-  def on_redo(node); end
-  def on_regexp(node); end
-  def on_regopt(node); end
-  def on_resbody(node); end
-  def on_rescue(node); end
-  def on_restarg(node); end
-  def on_retry(node); end
-  def on_return(node); end
-  def on_sclass(node); end
-  def on_self(node); end
-  def on_send(node); end
-  def on_shadowarg(node); end
-  def on_splat(node); end
-  def on_str(node); end
-  def on_super(node); end
-  def on_sym(node); end
-  def on_true(node); end
-  def on_undef(node); end
-  def on_unless_guard(node); end
-  def on_until(node); end
-  def on_until_post(node); end
-  def on_when(node); end
-  def on_while(node); end
-  def on_while_post(node); end
-  def on_xstr(node); end
-  def on_yield(node); end
-  def on_zsuper(node); end
-
-  private
-
-  def build_callbacks(cops); end
-  def initialize_callbacks; end
-  def invoke(callback, cops, *args); end
-  def reset; end
-  def restrict_callbacks(callbacks); end
-  def restricted_map(callbacks); end
-  def trigger_responding_cops(callback, node); end
-  def trigger_restricted_cops(event, node); end
-  def with_cop_error_handling(cop, node = T.unsafe(nil)); end
-end
-
-class RuboCop::Cop::Commissioner::InvestigationReport < ::Struct
-  def cop_reports; end
-  def cop_reports=(_); end
-  def cops; end
-  def correctors; end
-  def errors; end
-  def errors=(_); end
-  def merge(investigation); end
-  def offenses; end
-  def offenses_per_cop; end
-  def processed_source; end
-  def processed_source=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-RuboCop::Cop::Commissioner::RESTRICTED_CALLBACKS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::ConditionCorrector
-  class << self
-    def correct_negative_condition(corrector, node); end
-
-    private
-
-    def negated_condition(node); end
-  end
-end
-
-module RuboCop::Cop::ConfigurableEnforcedStyle
-  def alternative_style; end
-  def alternative_styles; end
-  def ambiguous_style_detected(*possibilities); end
-  def conflicting_styles_detected; end
-  def correct_style_detected; end
-  def detected_style; end
-  def detected_style=(style); end
-  def no_acceptable_style!; end
-  def no_acceptable_style?; end
-  def opposite_style_detected; end
-  def style; end
-  def style_configured?; end
-  def style_detected(detected); end
-  def style_parameter_name; end
-  def supported_styles; end
-  def unexpected_style_detected(unexpected); end
-  def unrecognized_style_detected; end
-end
-
-module RuboCop::Cop::ConfigurableFormatting
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-
-  def check_name(node, name, name_range); end
-  def class_emitter_method?(node, name); end
-  def report_opposing_styles(node, name); end
-  def valid_name?(node, name, given_style = T.unsafe(nil)); end
-end
-
-module RuboCop::Cop::ConfigurableMax
-  private
-
-  def max=(value); end
-  def max_parameter_name; end
-end
-
-module RuboCop::Cop::ConfigurableNaming
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::ConfigurableFormatting
-end
-
-RuboCop::Cop::ConfigurableNaming::FORMATS = T.let(T.unsafe(nil), Hash)
-
-module RuboCop::Cop::ConfigurableNumbering
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::ConfigurableFormatting
-end
-
-RuboCop::Cop::ConfigurableNumbering::FORMATS = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Cop::Cop < ::RuboCop::Cop::Base
-  def add_offense(node_or_range, location: T.unsafe(nil), message: T.unsafe(nil), severity: T.unsafe(nil), &block); end
-  def corrections; end
-  def find_location(node, loc); end
-  def offenses; end
-  def on_investigation_end; end
-  def on_new_investigation; end
-  def support_autocorrect?; end
-
-  private
-
-  def apply_correction(corrector); end
-  def begin_investigation(processed_source); end
-  def callback_argument(_range); end
-  def correction_lambda; end
-  def dedup_on_node(node); end
-  def emulate_v0_callsequence(corrector); end
-  def suppress_clobbering; end
-
-  class << self
-    def all; end
-    def joining_forces; end
-    def qualified_cop_name(name, origin); end
-    def registry; end
-    def support_autocorrect?; end
-  end
-end
-
-class RuboCop::Cop::Cop::Correction < ::Struct
-  def call(corrector); end
-  def cop; end
-  def cop=(_); end
-  def lambda; end
-  def lambda=(_); end
-  def node; end
-  def node=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RuboCop::Cop::Corrector < ::Parser::Source::TreeRewriter
-  def initialize(source); end
-
-  def remove_leading(node_or_range, size); end
-  def remove_preceding(node_or_range, size); end
-  def remove_trailing(node_or_range, size); end
-  def rewrite; end
-
-  private
-
-  def check_range_validity(node_or_range); end
-  def to_range(node_or_range); end
-  def validate_buffer(buffer); end
-
-  class << self
-    def source_buffer(source); end
-  end
-end
-
-RuboCop::Cop::Corrector::NOOP_CONSUMER = T.let(T.unsafe(nil), Proc)
-
-module RuboCop::Cop::DefNode
-  include ::RuboCop::Cop::VisibilityHelp
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def non_public_modifier?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def non_public?(node); end
-  def preceding_non_public_modifier?(node); end
-end
-
-module RuboCop::Cop::Documentation
-  private
-
-  def base_url_for(cop_class, config); end
-  def default_base_url; end
-  def department_to_basename(department); end
-  def url_for(cop_class, config = T.unsafe(nil)); end
-
-  class << self
-    def base_url_for(cop_class, config); end
-    def default_base_url; end
-    def department_to_basename(department); end
-    def url_for(cop_class, config = T.unsafe(nil)); end
-  end
-end
-
-module RuboCop::Cop::DocumentationComment
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  private
-
-  def annotation_keywords; end
-  def documentation_comment?(node); end
-  def interpreter_directive_comment?(comment); end
-  def precede?(node1, node2); end
-  def preceding_comment?(node1, node2); end
-  def preceding_lines(node); end
-  def rubocop_directive_comment?(comment); end
-end
-
-module RuboCop::Cop::Duplication
-  private
-
-  def consecutive_duplicates(collection); end
-  def duplicates(collection); end
-  def duplicates?(collection); end
-  def grouped_duplicates(collection); end
-end
-
-class RuboCop::Cop::EachToForCorrector
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def initialize(block_node); end
-
-  def call(corrector); end
-
-  private
-
-  def argument_node; end
-  def block_node; end
-  def collection_node; end
-  def correction; end
-  def offending_range; end
-  def replacement_range(end_pos); end
-end
-
-RuboCop::Cop::EachToForCorrector::CORRECTION_WITHOUT_ARGUMENTS = T.let(T.unsafe(nil), String)
-RuboCop::Cop::EachToForCorrector::CORRECTION_WITH_ARGUMENTS = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::EmptyLineCorrector
-  class << self
-    def correct(corrector, node); end
-    def insert_before(corrector, node); end
-  end
-end
-
-module RuboCop::Cop::EmptyParameter
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def empty_arguments?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def check(node); end
-end
-
-module RuboCop::Cop::EndKeywordAlignment
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-
-  private
-
-  def accept_end_kw_alignment?(end_loc); end
-  def add_offense_for_misalignment(node, align_with); end
-  def check_end_kw_alignment(node, align_ranges); end
-  def check_end_kw_in_node(node); end
-  def line_break_before_keyword?(whole_expression, rhs); end
-  def matching_ranges(end_loc, align_ranges); end
-  def start_line_range(node); end
-  def style_parameter_name; end
-  def variable_alignment?(whole_expression, rhs, end_alignment_style); end
-end
-
-RuboCop::Cop::EndKeywordAlignment::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::EnforceSuperclass
-  def on_class(node); end
-  def on_send(node); end
-
-  private
-
-  def register_offense(offense_node); end
-
-  class << self
-    def included(base); end
-  end
-end
-
-module RuboCop::Cop::FirstElementLineBreak
-  private
-
-  def check_children_line_break(node, children, start = T.unsafe(nil)); end
-  def check_method_line_break(node, children); end
-  def first_by_line(nodes); end
-  def last_by_line(nodes); end
-  def method_uses_parens?(node, limit); end
-end
-
-class RuboCop::Cop::ForToEachCorrector
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def initialize(for_node); end
-
-  def call(corrector); end
-
-  private
-
-  def collection_end; end
-  def collection_node; end
-  def collection_source; end
-  def correction; end
-  def end_position; end
-  def for_node; end
-  def keyword_begin; end
-  def offending_range; end
-  def replacement_range(end_pos); end
-  def requires_parentheses?; end
-  def variable_node; end
-end
-
-RuboCop::Cop::ForToEachCorrector::CORRECTION = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Force
-  def initialize(cops); end
-
-  def cops; end
-  def investigate(_processed_source); end
-  def name; end
-  def run_hook(method_name, *args); end
-
-  class << self
-    def all; end
-    def force_name; end
-    def inherited(subclass); end
-  end
-end
-
-module RuboCop::Cop::FrozenStringLiteral
-  private
-
-  def frozen_heredoc?(node); end
-  def frozen_string_literal?(node); end
-  def frozen_string_literal_comment_exists?; end
-  def frozen_string_literal_specified?; end
-  def frozen_string_literals_disabled?; end
-  def frozen_string_literals_enabled?; end
-  def leading_comment_lines; end
-  def uninterpolated_string?(node); end
-
-  class << self
-    def frozen_string_literal_comment_exists?; end
-  end
-end
-
-RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL = T.let(T.unsafe(nil), String)
-RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL_ENABLED = T.let(T.unsafe(nil), String)
-RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL_TYPES_RUBY27 = T.let(T.unsafe(nil), Array)
-
-module RuboCop::Cop::GemDeclaration
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def gem_declaration?(param0 = T.unsafe(nil)); end
-end
-
-module RuboCop::Cop::Gemspec; end
-
-class RuboCop::Cop::Gemspec::DependencyVersion < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::GemspecHelp
-
-  def add_dependency_method_declarations(param0); end
-  def includes_commit_reference?(param0 = T.unsafe(nil)); end
-  def includes_version_specification?(param0 = T.unsafe(nil)); end
-  def on_new_investigation; end
-
-  private
-
-  def add_dependency_method?(method_name); end
-  def add_dependency_method_nodes; end
-  def allowed_gem?(node); end
-  def allowed_gems; end
-  def forbidden_offense?(node); end
-  def forbidden_style?; end
-  def match_block_variable_name?(receiver_name); end
-  def message(range); end
-  def offense?(node); end
-  def required_offense?(node); end
-  def required_style?; end
-  def version_specification?(expression); end
-end
-
-RuboCop::Cop::Gemspec::DependencyVersion::FORBIDDEN_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Gemspec::DependencyVersion::REQUIRED_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Gemspec::DependencyVersion::VERSION_SPECIFICATION_REGEX = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def gem_specification(param0 = T.unsafe(nil)); end
-  def on_block(block_node); end
-
-  private
-
-  def format_message_from; end
-  def node_and_method_name(node, attribute); end
-  def use_deprecated_attributes?(node, block_parameter); end
-end
-
-RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Gemspec::DuplicatedAssignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::GemspecHelp
-
-  def assignment_method_declarations(param0); end
-  def on_new_investigation; end
-
-  private
-
-  def duplicated_assignment_method_nodes; end
-  def match_block_variable_name?(receiver_name); end
-  def register_offense(node, assignment, line_of_first_occurrence); end
-end
-
-RuboCop::Cop::Gemspec::DuplicatedAssignment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Gemspec::OrderedDependencies < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::OrderedGemNode
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def dependency_declarations(param0); end
-  def on_new_investigation; end
-
-  private
-
-  def get_dependency_name(node); end
-  def previous_declaration(node); end
-end
-
-RuboCop::Cop::Gemspec::OrderedDependencies::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Gemspec::RequireMFA < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::GemspecHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def metadata(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def rubygems_mfa_required(param0); end
-  def true_string?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node, block_var, metadata); end
-  def change_value(corrector, value); end
-  def correct_metadata(corrector, metadata); end
-  def insert_mfa_required(corrector, node, block_var); end
-  def mfa_value(metadata_value); end
-end
-
-RuboCop::Cop::Gemspec::RequireMFA::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Gemspec::RequiredRubyVersion < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def defined_ruby_version(param0 = T.unsafe(nil)); end
-  def on_new_investigation; end
-  def on_send(node); end
-  def required_ruby_version?(param0); end
-
-  private
-
-  def dynamic_version?(node); end
-  def extract_ruby_version(required_ruby_version); end
-  def not_equal_message(required_ruby_version, target_ruby_version); end
-end
-
-RuboCop::Cop::Gemspec::RequiredRubyVersion::MISSING_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Gemspec::RequiredRubyVersion::NOT_EQUAL_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Gemspec::RequiredRubyVersion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::GemspecHelp
-
-  def on_const(node); end
-  def ruby_version?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def gem_spec_with_ruby_version?(node); end
-end
-
-RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::GemspecHelp
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def gem_specification(param0); end
-  def gem_specification?(param0 = T.unsafe(nil)); end
-end
-
-class RuboCop::Cop::Generator
-  def initialize(name, output: T.unsafe(nil)); end
-
-  def inject_config(config_file_path: T.unsafe(nil), version_added: T.unsafe(nil)); end
-  def inject_require(root_file_path: T.unsafe(nil)); end
-  def todo; end
-  def write_source; end
-  def write_spec; end
-
-  private
-
-  def badge; end
-  def generate(template); end
-  def generated_source; end
-  def generated_spec; end
-  def output; end
-  def snake_case(camel_case_string); end
-  def source_path; end
-  def spec_path; end
-  def write_unless_file_exists(path, contents); end
-end
-
-RuboCop::Cop::Generator::CONFIGURATION_ADDED_MESSAGE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Generator::ConfigurationInjector
-  def initialize(configuration_file_path:, badge:, version_added: T.unsafe(nil)); end
-
-  def inject; end
-
-  private
-
-  def badge; end
-  def configuration_entries; end
-  def configuration_file_path; end
-  def cop_name_line?(yaml); end
-  def find_target_line; end
-  def new_configuration_entry; end
-  def output; end
-  def version_added; end
-end
-
-RuboCop::Cop::Generator::ConfigurationInjector::TEMPLATE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Generator::RequireFileInjector
-  def initialize(source_path:, root_file_path:, output: T.unsafe(nil)); end
-
-  def inject; end
-
-  private
-
-  def injectable_require_directive; end
-  def output; end
-  def require_entries; end
-  def require_exists?; end
-  def require_path; end
-  def require_path_fragments(require_directove); end
-  def root_file_path; end
-  def source_path; end
-  def target_line; end
-  def updated_directives; end
-end
-
-RuboCop::Cop::Generator::RequireFileInjector::REQUIRE_PATH = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Generator::SOURCE_TEMPLATE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Generator::SPEC_TEMPLATE = T.let(T.unsafe(nil), String)
-module RuboCop::Cop::HashAlignmentStyles; end
-
-class RuboCop::Cop::HashAlignmentStyles::KeyAlignment
-  def checkable_layout?(_node); end
-  def deltas(first_pair, current_pair); end
-  def deltas_for_first_pair(first_pair, _node); end
-
-  private
-
-  def separator_delta(pair); end
-  def value_delta(pair); end
-end
-
-class RuboCop::Cop::HashAlignmentStyles::KeywordSplatAlignment
-  def deltas(first_pair, current_pair); end
-end
-
-class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment
-  include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment
-
-  def deltas_for_first_pair(*_nodes); end
-
-  private
-
-  def hash_rocket_delta(first_pair, current_pair); end
-  def key_delta(first_pair, current_pair); end
-  def value_delta(first_pair, current_pair); end
-end
-
-class RuboCop::Cop::HashAlignmentStyles::TableAlignment
-  include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment
-
-  def initialize; end
-
-  def deltas_for_first_pair(first_pair, node); end
-
-  private
-
-  def hash_rocket_delta(first_pair, current_pair); end
-  def key_delta(first_pair, current_pair); end
-  def max_key_width; end
-  def max_key_width=(_arg0); end
-  def value_delta(first_pair, current_pair); end
-end
-
-module RuboCop::Cop::HashAlignmentStyles::ValueAlignment
-  def checkable_layout?(node); end
-  def deltas(first_pair, current_pair); end
-
-  private
-
-  def separator_delta(first_pair, current_pair, key_delta); end
-end
-
-module RuboCop::Cop::HashShorthandSyntax
-  def on_pair(node); end
-
-  private
-
-  def enforced_shorthand_syntax; end
-  def ignore_hash_shorthand_syntax?(pair_node); end
-  def register_offense(node, message, replacement); end
-  def require_hash_value?(hash_key_source, node); end
-  def require_hash_value_for_around_hash_literal?(node); end
-  def use_element_of_hash_literal_as_receiver?(ancestor, parent); end
-  def use_modifier_form_without_parenthesized_method_call?(ancestor); end
-  def without_parentheses_call_expr_follows?(ancestor); end
-end
-
-RuboCop::Cop::HashShorthandSyntax::EXPLICIT_HASH_VALUE_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::HashShorthandSyntax::OMIT_HASH_VALUE_MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::HashTransformMethod
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def array_receiver?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def execute_correction(corrector, node, correction); end
-  def extract_captures(_match); end
-  def handle_possible_offense(node, match, match_desc); end
-  def new_method_name; end
-  def on_bad_each_with_object(_node); end
-  def on_bad_hash_brackets_map(_node); end
-  def on_bad_map_to_h(_node); end
-  def on_bad_to_h(_node); end
-  def prepare_correction(node); end
-end
-
-class RuboCop::Cop::HashTransformMethod::Autocorrection < ::Struct
-  def block_node; end
-  def block_node=(_); end
-  def leading; end
-  def leading=(_); end
-  def match; end
-  def match=(_); end
-  def set_new_arg_name(transformed_argname, corrector); end
-  def set_new_body_expression(transforming_body_expr, corrector); end
-  def set_new_method_name(new_method_name, corrector); end
-  def strip_prefix_and_suffix(node, corrector); end
-  def trailing; end
-  def trailing=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def from_each_with_object(node, match); end
-    def from_hash_brackets_map(node, match); end
-    def from_map_to_h(node, match); end
-    def from_to_h(node, match); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RuboCop::Cop::HashTransformMethod::Captures < ::Struct
-  def noop_transformation?; end
-  def transformation_uses_both_args?; end
-  def transformed_argname; end
-  def transformed_argname=(_); end
-  def transforming_body_expr; end
-  def transforming_body_expr=(_); end
-  def unchanged_body_expr; end
-  def unchanged_body_expr=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-RuboCop::Cop::HashTransformMethod::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-module RuboCop::Cop::Heredoc
-  def on_dstr(node); end
-  def on_heredoc(_node); end
-  def on_str(node); end
-  def on_xstr(node); end
-
-  private
-
-  def delimiter_string(node); end
-  def heredoc_type(node); end
-  def indent_level(str); end
-end
-
-RuboCop::Cop::Heredoc::OPENING_DELIMITER = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::IfThenCorrector
-  def initialize(if_node, indentation: T.unsafe(nil)); end
-
-  def call(corrector); end
-
-  private
-
-  def branch_body_indentation; end
-  def if_node; end
-  def indentation; end
-  def replacement(node = T.unsafe(nil), indentation = T.unsafe(nil)); end
-  def rewrite_else_branch(else_branch, indentation); end
-end
-
-RuboCop::Cop::IfThenCorrector::DEFAULT_INDENTATION_WIDTH = T.let(T.unsafe(nil), Integer)
-
-module RuboCop::Cop::IgnoredMethods
-  mixes_in_class_methods ::RuboCop::Cop::IgnoredMethods::Config
-
-  def ignored_method?(name); end
-  def ignored_methods; end
-
-  private
-
-  def deprecated_key; end
-
-  class << self
-    def included(base); end
-  end
-end
-
-module RuboCop::Cop::IgnoredMethods::Config
-  def deprecated_key; end
-  def deprecated_key=(_arg0); end
-  def ignored_methods(**config); end
-end
-
-module RuboCop::Cop::IgnoredNode
-  def ignore_node(node); end
-  def ignored_node?(node); end
-  def part_of_ignored_node?(node); end
-
-  private
-
-  def ignored_nodes; end
-end
-
-RuboCop::Cop::IgnoredPattern = RuboCop::Cop::AllowedPattern
-
-module RuboCop::Cop::IntegerNode
-  private
-
-  def integer_part(node); end
-end
-
-module RuboCop::Cop::Interpolation
-  def on_dstr(node); end
-  def on_dsym(node); end
-  def on_node_with_interpolations(node); end
-  def on_regexp(node); end
-  def on_xstr(node); end
-end
-
-class RuboCop::Cop::LambdaLiteralToMethodCorrector
-  def initialize(block_node); end
-
-  def call(corrector); end
-
-  private
-
-  def arg_to_unparenthesized_call?; end
-  def arguments; end
-  def arguments_begin_pos; end
-  def arguments_end_pos; end
-  def block_begin; end
-  def block_end; end
-  def block_node; end
-  def insert_arguments(corrector); end
-  def insert_separating_space(corrector); end
-  def lambda_arg_string; end
-  def method; end
-  def needs_separating_space?; end
-  def remove_arguments(corrector); end
-  def remove_leading_whitespace(corrector); end
-  def remove_trailing_whitespace(corrector); end
-  def remove_unparenthesized_whitespace(corrector); end
-  def replace_delimiters(corrector); end
-  def replace_selector(corrector); end
-  def selector_end; end
-  def separating_space?; end
-end
-
-module RuboCop::Cop::Layout; end
-
-class RuboCop::Cop::Layout::AccessModifierIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def on_class(node); end
-  def on_module(node); end
-  def on_sclass(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def check_body(body, node); end
-  def check_modifier(send_node, end_range); end
-  def expected_indent_offset; end
-  def message(range); end
-  def unexpected_indent_offset; end
-end
-
-RuboCop::Cop::Layout::AccessModifierIndentation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::ArgumentAlignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def arguments_or_first_arg_pairs(node); end
-  def arguments_with_last_arg_pairs(node); end
-  def autocorrect(corrector, node); end
-  def autocorrect_incompatible_with_other_cops?; end
-  def base_column(node, first_argument); end
-  def enforce_hash_argument_with_separator?; end
-  def fixed_indentation?; end
-  def flattened_arguments(node); end
-  def hash_argument_config; end
-  def message(_node); end
-  def multiple_arguments?(node); end
-  def target_method_lineno(node); end
-  def with_first_argument_style?; end
-end
-
-RuboCop::Cop::Layout::ArgumentAlignment::ALIGN_PARAMS_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::ArgumentAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::ArrayAlignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_array(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def base_column(node, args); end
-  def fixed_indentation?; end
-  def message(_range); end
-  def target_method_lineno(node); end
-end
-
-RuboCop::Cop::Layout::ArrayAlignment::ALIGN_ELEMENTS_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::ArrayAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::AssignmentIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::CheckAssignment
-  include ::RuboCop::Cop::Alignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  private
-
-  def autocorrect(corrector, node); end
-  def check_assignment(node, rhs); end
-  def leftmost_multiple_assignment(node); end
-end
-
-RuboCop::Cop::Layout::AssignmentIndentation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::BeginEndAlignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::EndKeywordAlignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_kwbegin(node); end
-
-  private
-
-  def alignment_node(node); end
-  def autocorrect(corrector, node); end
-  def check_begin_alignment(node); end
-end
-
-RuboCop::Cop::Layout::BeginEndAlignment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::BlockAlignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def block_end_align_target?(param0 = T.unsafe(nil), param1); end
-  def on_block(node); end
-  def style_parameter_name; end
-
-  private
-
-  def add_space_before(corrector, loc, delta); end
-  def alt_start_msg(start_loc, source_line_column); end
-  def autocorrect(corrector, node); end
-  def block_end_align_target(node); end
-  def check_block_alignment(start_node, block_node); end
-  def compute_do_source_line_column(node, end_loc); end
-  def compute_start_col(ancestor_node, node); end
-  def disqualified_parent?(parent, node); end
-  def end_align_target?(node, parent); end
-  def format_message(start_loc, end_loc, do_source_line_column, error_source_line_column); end
-  def format_source_line_column(source_line_column); end
-  def loc_to_source_line_column(loc); end
-  def register_offense(block_node, start_loc, end_loc, do_source_line_column); end
-  def remove_space_before(corrector, end_pos, delta); end
-  def start_for_block_node(block_node); end
-end
-
-RuboCop::Cop::Layout::BlockAlignment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::BlockEndNewline < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-
-  private
-
-  def delimiter_range(node); end
-  def message(node); end
-end
-
-RuboCop::Cop::Layout::BlockEndNewline::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::CaseIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_case(case_node); end
-  def on_case_match(case_match_node); end
-
-  private
-
-  def base_column(case_node, base); end
-  def check_when(when_node, branch_type); end
-  def detect_incorrect_style(when_node); end
-  def end_and_last_conditional_same_line?(node); end
-  def enforced_style_end?; end
-  def incorrect_style(when_node, branch_type); end
-  def indent_one_step?; end
-  def indentation_width; end
-  def replacement(node); end
-  def whitespace_range(node); end
-end
-
-RuboCop::Cop::Layout::CaseIndentation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::VisibilityHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def dynamic_constant?(param0 = T.unsafe(nil)); end
-  def on_class(class_node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def begin_pos_with_comment(node); end
-  def buffer; end
-  def categories; end
-  def class_elements(class_node); end
-  def classify(node); end
-  def end_position_for(node); end
-  def expected_order; end
-  def find_category(node); end
-  def find_heredoc(node); end
-  def humanize_node(node); end
-  def ignore?(classification); end
-  def ignore_for_autocorrect?(node, sibling); end
-  def source_range_with_comment(node); end
-  def start_line_position(node); end
-  def walk_over_nested_class_definition(class_node); end
-  def whole_line_comment_at_line?(line); end
-end
-
-RuboCop::Cop::Layout::ClassStructure::HUMANIZED_NODE_TYPE = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Layout::ClassStructure::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::ClosingHeredocIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Heredoc
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_heredoc(node); end
-
-  private
-
-  def argument_indentation_correct?(node); end
-  def closing_indentation(node); end
-  def find_node_used_heredoc_argument(node); end
-  def heredoc_closing(node); end
-  def heredoc_opening(node); end
-  def indent_level(source_line); end
-  def indented_end(node); end
-  def message(node); end
-  def opening_indentation(node); end
-end
-
-RuboCop::Cop::Layout::ClosingHeredocIndentation::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::ClosingHeredocIndentation::MSG_ARG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::ClosingHeredocIndentation::SIMPLE_HEREDOC = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::ClosingParenthesisIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_begin(node); end
-  def on_csend(node); end
-  def on_def(node); end
-  def on_defs(node); end
-  def on_send(node); end
-
-  private
-
-  def all_elements_aligned?(elements); end
-  def autocorrect(corrector, node); end
-  def check(node, elements); end
-  def check_for_elements(node, elements); end
-  def check_for_no_elements(node); end
-  def correct_column_candidates(node, left_paren); end
-  def expected_column(left_paren, elements); end
-  def first_argument_line(elements); end
-  def indentation_width; end
-  def line_break_after_left_paren?(left_paren, elements); end
-  def message(correct_column, left_paren, right_paren); end
-end
-
-RuboCop::Cop::Layout::ClosingParenthesisIndentation::MSG_ALIGN = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::ClosingParenthesisIndentation::MSG_INDENT = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::CommentIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def autocorrect(corrector, comment); end
-  def autocorrect_one(corrector, comment); end
-  def autocorrect_preceding_comments(corrector, comment); end
-  def check(comment, comment_index); end
-  def correct_indentation(next_line); end
-  def correctly_aligned_with_preceding_comment?(comment_index, column); end
-  def less_indented?(line); end
-  def line_after_comment(comment); end
-  def message(column, correct_comment_indentation); end
-  def own_line_comment?(comment); end
-  def should_correct?(preceding_comment, reference_comment); end
-  def two_alternatives?(line); end
-end
-
-RuboCop::Cop::Layout::CommentIndentation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::ConditionPosition < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-  def on_until(node); end
-  def on_while(node); end
-
-  private
-
-  def check(node); end
-  def message(condition); end
-end
-
-RuboCop::Cop::Layout::ConditionPosition::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::DefEndAlignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::EndKeywordAlignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-  def on_send(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-end
-
-RuboCop::Cop::Layout::DefEndAlignment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::DotPosition < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def ampersand_dot?(node); end
-  def autocorrect(corrector, dot, node); end
-  def correct_dot_position_style?(dot_line, selector_line); end
-  def end_range(node); end
-  def heredoc?(node); end
-  def last_heredoc_line(node); end
-  def line_between?(first_line, second_line); end
-  def message(dot); end
-  def proper_dot_position?(node); end
-  def receiver_end_line(node); end
-  def selector_range(node); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-class RuboCop::Cop::Layout::ElseAlignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::EndKeywordAlignment
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::CheckAssignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_case(node); end
-  def on_case_match(node); end
-  def on_if(node, base = T.unsafe(nil)); end
-  def on_rescue(node); end
-
-  private
-
-  def assignment_node(node); end
-  def autocorrect(corrector, node); end
-  def base_for_method_definition(node); end
-  def base_range_of_if(node, base); end
-  def base_range_of_rescue(node); end
-  def check_alignment(base_range, else_range); end
-  def check_assignment(node, rhs); end
-  def check_nested(node, base); end
-end
-
-RuboCop::Cop::Layout::ElseAlignment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyComment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def allow_border_comment?; end
-  def allow_margin_comment?; end
-  def autocorrect(corrector, node); end
-  def comment_text(comment); end
-  def concat_consecutive_comments(comments); end
-  def current_token(comment); end
-  def empty_comment_only?(comment_text); end
-  def investigate(comments); end
-  def previous_token(node); end
-end
-
-RuboCop::Cop::Layout::EmptyComment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyLineAfterGuardClause < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::PathUtil
-  extend ::RuboCop::Cop::Util
-
-  def on_if(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def contains_guard_clause?(node); end
-  def correct_style?(node); end
-  def heredoc?(node); end
-  def heredoc_line(node, heredoc_node); end
-  def last_heredoc_argument(node); end
-  def last_heredoc_argument_node(node); end
-  def multiple_statements_on_line?(node); end
-  def next_line_empty?(line); end
-  def next_line_empty_or_enable_directive_comment?(line); end
-  def next_line_enable_directive_comment?(line); end
-  def next_line_rescue_or_ensure?(node); end
-  def next_sibling_empty_or_guard_clause?(node); end
-  def next_sibling_parent_empty_or_else?(node); end
-  def offense_location(node); end
-end
-
-RuboCop::Cop::Layout::EmptyLineAfterGuardClause::END_OF_HEREDOC_LINE = T.let(T.unsafe(nil), Integer)
-RuboCop::Cop::Layout::EmptyLineAfterGuardClause::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyLineAfterMagicComment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def last_magic_comment(source); end
-  def offending_range(last_magic_comment); end
-end
-
-RuboCop::Cop::Layout::EmptyLineAfterMagicComment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_case(node); end
-  def on_if(node); end
-  def on_rescue(node); end
-  def on_until(node); end
-  def on_until_post(node); end
-  def on_while(node); end
-  def on_while_post(node); end
-
-  private
-
-  def autocorrect(node); end
-  def check_condition(condition); end
-  def multiline_rescue_exceptions?(exception_nodes); end
-  def multiline_when_condition?(when_node); end
-  def next_line_empty?(line); end
-end
-
-RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyLineBetweenDefs < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def autocorrect(corrector, prev_def, node, count); end
-  def check_defs(nodes); end
-  def on_begin(node); end
-
-  private
-
-  def allowance_range?; end
-  def autocorrect_insert_lines(corrector, newline_pos, count); end
-  def autocorrect_remove_lines(corrector, newline_pos, count); end
-  def blank_lines_count_between(first_def_node, second_def_node); end
-  def candidate?(node); end
-  def class_candidate?(node); end
-  def def_end(node); end
-  def def_start(node); end
-  def end_loc(node); end
-  def expected_lines; end
-  def line_count_allowed?(count); end
-  def lines_between_defs(first_def_node, second_def_node); end
-  def maximum_empty_lines; end
-  def message(node, count: T.unsafe(nil)); end
-  def method_candidate?(node); end
-  def minimum_empty_lines; end
-  def module_candidate?(node); end
-  def multiple_blank_lines_groups?(first_def_node, second_def_node); end
-  def node_type(node); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Layout::EmptyLineBetweenDefs::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyLines < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def each_extra_empty_line(lines); end
-  def exceeds_line_offset?(line_diff); end
-  def previous_and_current_lines_empty?(line); end
-end
-
-RuboCop::Cop::Layout::EmptyLines::LINE_OFFSET = T.let(T.unsafe(nil), Integer)
-RuboCop::Cop::Layout::EmptyLines::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def on_block(node); end
-  def on_class(node); end
-  def on_module(node); end
-  def on_sclass(node); end
-  def on_send(node); end
-
-  private
-
-  def allowed_only_before_style?(node); end
-  def block_start?(line); end
-  def body_end?(line); end
-  def class_def?(line); end
-  def correct_next_line_if_denied_style(corrector, node, line); end
-  def empty_lines_around?(node); end
-  def expected_empty_lines?(node); end
-  def message(node); end
-  def message_for_around_style(node); end
-  def message_for_only_before_style(node); end
-  def next_empty_line_range(node); end
-  def next_line_empty?(last_send_line); end
-  def previous_line_empty?(send_line); end
-  def previous_line_ignoring_comments(processed_source, send_line); end
-end
-
-RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_AFTER = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_AFTER_FOR_ONLY_BEFORE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_BEFORE_AND_AFTER = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_BEFORE_FOR_ONLY_BEFORE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyLinesAroundArguments < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def empty_lines(node); end
-  def extra_lines(node); end
-  def inner_lines(node); end
-  def line_numbers(node); end
-  def outer_lines(node); end
-  def processed_lines(node); end
-  def receiver_and_method_call_on_different_lines?(node); end
-end
-
-RuboCop::Cop::Layout::EmptyLinesAroundArguments::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::AllowedMethods
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def allow_alias?(node); end
-  def allow_alias_syntax?; end
-  def attribute_or_allowed_method?(node); end
-  def autocorrect(corrector, node); end
-  def next_line_empty?(line); end
-  def next_line_empty_or_enable_directive_comment?(line); end
-  def next_line_enable_directive_comment?(line); end
-  def next_line_node(node); end
-  def require_empty_line?(node); end
-end
-
-RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_kwbegin(node); end
-
-  private
-
-  def style; end
-end
-
-RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::KIND = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-end
-
-RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::KIND = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::Layout::EmptyLinesAroundBody
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def constant_definition?(param0 = T.unsafe(nil)); end
-  def empty_line_required?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def check(node, body, adjusted_first_line: T.unsafe(nil)); end
-  def check_beginning(style, first_line); end
-  def check_both(style, first_line, last_line); end
-  def check_deferred_empty_line(body); end
-  def check_empty_lines_except_namespace(body, first_line, last_line); end
-  def check_empty_lines_special(body, first_line, last_line); end
-  def check_ending(style, last_line); end
-  def check_line(style, line, msg); end
-  def check_source(style, line_no, desc); end
-  def deferred_message(node); end
-  def first_child_requires_empty_line?(body); end
-  def first_empty_line_required_child(body); end
-  def message(type, desc); end
-  def namespace?(body, with_one_child: T.unsafe(nil)); end
-  def previous_line_ignoring_comments(send_line); end
-  def valid_body_style?(body); end
-end
-
-RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_DEFERRED = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_EXTRA = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_MISSING = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyLinesAroundClassBody < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_class(node); end
-  def on_sclass(node); end
-end
-
-RuboCop::Cop::Layout::EmptyLinesAroundClassBody::KIND = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-  def on_kwbegin(node); end
-
-  private
-
-  def check_body(body, line_of_def_or_kwbegin); end
-  def keyword_locations(node); end
-  def keyword_locations_in_ensure(node); end
-  def keyword_locations_in_rescue(node); end
-  def last_rescue_and_end_on_same_line(body); end
-  def message(location, keyword); end
-  def style; end
-end
-
-RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def style; end
-end
-
-RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::KIND = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_module(node); end
-end
-
-RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::KIND = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::EndAlignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::CheckAssignment
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::EndKeywordAlignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_case(node); end
-  def on_class(node); end
-  def on_if(node); end
-  def on_module(node); end
-  def on_until(node); end
-  def on_while(node); end
-
-  private
-
-  def alignment_node(node); end
-  def alignment_node_for_variable_style(node); end
-  def asgn_variable_align_with(outer_node, inner_node); end
-  def assignment_or_operator_method(node); end
-  def autocorrect(corrector, node); end
-  def check_asgn_alignment(outer_node, inner_node); end
-  def check_assignment(node, rhs); end
-  def check_other_alignment(node); end
-end
-
-class RuboCop::Cop::Layout::EndOfLine < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-
-  def offense_message(line); end
-  def on_new_investigation; end
-  def unimportant_missing_cr?(index, last_line, line); end
-
-  private
-
-  def last_line(processed_source); end
-end
-
-RuboCop::Cop::Layout::EndOfLine::MSG_DETECTED = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::EndOfLine::MSG_MISSING = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::ExtraSpacing < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::PrecedingFollowingAlignment
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def align_column(asgn_token); end
-  def align_equal_sign(corrector, token, align_to); end
-  def align_equal_signs(range, corrector); end
-  def aligned_locations(locs); end
-  def aligned_tok?(token); end
-  def all_relevant_assignment_lines(line_number); end
-  def allow_for_trailing_comments?; end
-  def check_assignment(token); end
-  def check_other(token1, token2, ast); end
-  def check_tokens(ast, token1, token2); end
-  def extra_space_range(token1, token2); end
-  def force_equal_sign_alignment?; end
-  def ignored_range?(ast, start_pos); end
-  def ignored_ranges(ast); end
-end
-
-RuboCop::Cop::Layout::ExtraSpacing::MSG_UNALIGNED_ASGN = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::ExtraSpacing::MSG_UNNECESSARY = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def eligible_method_call?(param0 = T.unsafe(nil)); end
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def argument_alignment_config; end
-  def autocorrect(corrector, node); end
-  def bare_operator?(node); end
-  def base_indentation(node); end
-  def base_range(send_node, arg_node); end
-  def column_of(range); end
-  def comment_lines; end
-  def enforce_first_argument_with_fixed_indentation?; end
-  def message(arg_node); end
-  def on_new_investigation; end
-  def previous_code_line(line_number); end
-  def special_inner_call_indentation?(node); end
-end
-
-RuboCop::Cop::Layout::FirstArgumentIndentation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::FirstArrayElementIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::MultilineElementIndentation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_array(node); end
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def base_description(indent_base_type); end
-  def brace_alignment_style; end
-  def check(array_node, left_parenthesis); end
-  def check_right_bracket(right_bracket, first_elem, left_bracket, left_parenthesis); end
-  def message(base_description); end
-  def message_for_right_bracket(indent_base_type); end
-end
-
-RuboCop::Cop::Layout::FirstArrayElementIndentation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::FirstArrayElementLineBreak < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::FirstElementLineBreak
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_array(node); end
-
-  private
-
-  def assignment_on_same_line?(node); end
-end
-
-RuboCop::Cop::Layout::FirstArrayElementLineBreak::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::FirstHashElementIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::MultilineElementIndentation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_hash(node); end
-  def on_send(node); end
-
-  private
-
-  def argument_alignment_config; end
-  def autocorrect(corrector, node); end
-  def base_description(indent_base_type); end
-  def brace_alignment_style; end
-  def check(hash_node, left_parenthesis); end
-  def check_based_on_longest_key(hash_node, left_brace, left_parenthesis); end
-  def check_right_brace(right_brace, first_pair, left_brace, left_parenthesis); end
-  def enforce_first_argument_with_fixed_indentation?; end
-  def message(base_description); end
-  def message_for_right_brace(indent_base_type); end
-  def separator_style?(first_pair); end
-end
-
-RuboCop::Cop::Layout::FirstHashElementIndentation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::FirstHashElementLineBreak < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::FirstElementLineBreak
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_hash(node); end
-end
-
-RuboCop::Cop::Layout::FirstHashElementLineBreak::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::FirstElementLineBreak
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-  def on_super(node); end
-end
-
-RuboCop::Cop::Layout::FirstMethodArgumentLineBreak::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::FirstMethodParameterLineBreak < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::FirstElementLineBreak
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-end
-
-RuboCop::Cop::Layout::FirstMethodParameterLineBreak::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::FirstParameterIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::MultilineElementIndentation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def base_description(_); end
-  def brace_alignment_style; end
-  def check(def_node); end
-  def message(base_description); end
-end
-
-RuboCop::Cop::Layout::FirstParameterIndentation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::HashAlignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::HashAlignmentStyles
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def column_deltas; end
-  def column_deltas=(_arg0); end
-  def offenses_by; end
-  def offenses_by=(_arg0); end
-  def on_hash(node); end
-  def on_send(node); end
-  def on_super(node); end
-  def on_yield(node); end
-
-  private
-
-  def add_offenses; end
-  def adjust(corrector, delta, range); end
-  def alignment_for(pair); end
-  def alignment_for_colons; end
-  def alignment_for_hash_rockets; end
-  def argument_alignment_config; end
-  def argument_before_hash(hash_node); end
-  def autocorrect_incompatible_with_other_cops?(node); end
-  def check_delta(delta, node:, alignment:); end
-  def check_pairs(node); end
-  def correct_key_value(corrector, delta, key, value, separator); end
-  def correct_no_value(corrector, key_delta, key); end
-  def correct_node(corrector, node, delta); end
-  def double_splat?(node); end
-  def enforce_first_argument_with_fixed_indentation?; end
-  def good_alignment?(column_deltas); end
-  def ignore_hash_argument?(node); end
-  def new_alignment(key); end
-  def register_offenses_with_format(offenses, format); end
-  def reset!; end
-end
-
-RuboCop::Cop::Layout::HashAlignment::MESSAGES = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Layout::HashAlignment::SEPARATOR_ALIGNMENT_STYLES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def add_correct_closing_paren(node, corrector); end
-  def add_correct_external_trailing_comma(node, corrector); end
-  def autocorrect(corrector, node); end
-  def exist_argument_between_heredoc_end_and_closing_parentheses?(node); end
-  def external_trailing_comma?(node); end
-  def external_trailing_comma_offset_from_loc_end(node); end
-  def extract_heredoc(node); end
-  def extract_heredoc_argument(node); end
-  def find_most_bottom_of_heredoc_end(arguments); end
-  def fix_closing_parenthesis(node, corrector); end
-  def fix_external_trailing_comma(node, corrector); end
-  def heredoc_node?(node); end
-  def incorrect_parenthesis_removal_begin(node); end
-  def incorrect_parenthesis_removal_end(node); end
-  def internal_trailing_comma?(node); end
-  def internal_trailing_comma_offset_from_last_arg(node); end
-  def outermost_send_on_same_line(heredoc); end
-  def remove_incorrect_closing_paren(node, corrector); end
-  def remove_incorrect_external_trailing_comma(node, corrector); end
-  def remove_internal_trailing_comma(node, corrector); end
-  def safe_to_remove_line_containing_closing_paren?(node); end
-  def send_missing_closing_parens?(parent, child, heredoc); end
-  def single_line_send_with_heredoc_receiver?(node); end
-  def space?(pos); end
-  def subsequent_closing_parentheses_in_same_line?(outermost_send); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::HeredocIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Heredoc
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_heredoc(node); end
-
-  private
-
-  def adjust_minus(corrector, node); end
-  def adjust_squiggly(corrector, node); end
-  def base_indent_level(node); end
-  def heredoc_body(node); end
-  def heredoc_end(node); end
-  def heredoc_indent_type(node); end
-  def indentation_width; end
-  def indented_body(node); end
-  def indented_end(node); end
-  def line_too_long?(node); end
-  def longest_line(lines); end
-  def max_line_length; end
-  def message(heredoc_indent_type); end
-  def register_offense(node, heredoc_indent_type); end
-  def type_message(indentation_width, current_indent_type); end
-  def unlimited_heredoc_length?; end
-  def width_message(indentation_width); end
-end
-
-RuboCop::Cop::Layout::HeredocIndentation::TYPE_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::HeredocIndentation::WIDTH_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::IndentationConsistency < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_begin(node); end
-  def on_kwbegin(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def bare_access_modifier?(node); end
-  def base_column_for_normal_style(node); end
-  def check(node); end
-  def check_indented_internal_methods_style(node); end
-  def check_normal_style(node); end
-end
-
-RuboCop::Cop::Layout::IndentationConsistency::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::IndentationStyle < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def autocorrect(corrector, range); end
-  def autocorrect_lambda_for_spaces(corrector, range); end
-  def autocorrect_lambda_for_tabs(corrector, range); end
-  def find_offense(line, lineno); end
-  def in_string_literal?(ranges, tabs_range); end
-  def message(_node); end
-  def string_literal_ranges(ast); end
-end
-
-RuboCop::Cop::Layout::IndentationStyle::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::IndentationWidth < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::EndKeywordAlignment
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::CheckAssignment
-  include ::RuboCop::Cop::AllowedPattern
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def access_modifier?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def on_case(case_node); end
-  def on_case_match(case_match); end
-  def on_class(node); end
-  def on_csend(node); end
-  def on_def(node); end
-  def on_defs(node); end
-  def on_ensure(node); end
-  def on_for(node); end
-  def on_if(node, base = T.unsafe(nil)); end
-  def on_kwbegin(node); end
-  def on_module(node); end
-  def on_resbody(node); end
-  def on_rescue(node); end
-  def on_sclass(node); end
-  def on_send(node); end
-  def on_until(node, base = T.unsafe(nil)); end
-  def on_while(node, base = T.unsafe(nil)); end
-
-  private
-
-  def access_modifier_indentation_style; end
-  def autocorrect(corrector, node); end
-  def check_assignment(node, rhs); end
-  def check_if(node, body, else_clause, base_loc); end
-  def check_indentation(base_loc, body_node, style = T.unsafe(nil)); end
-  def check_members(base, members); end
-  def check_members_for_indented_internal_methods_style(members); end
-  def check_members_for_normal_style(base, members); end
-  def check_rescue?(rescue_node); end
-  def configured_indentation_width; end
-  def each_member(members); end
-  def indentation_consistency_style; end
-  def indentation_to_check?(base_loc, body_node); end
-  def indented_internal_methods_style?; end
-  def leftmost_modifier_of(node); end
-  def message(configured_indentation_width, indentation, name); end
-  def offending_range(body_node, indentation); end
-  def offense(body_node, indentation, style); end
-  def other_offense_in_same_range?(node); end
-  def select_check_member(member); end
-  def skip_check?(base_loc, body_node); end
-  def special_modifier?(node); end
-  def starts_with_access_modifier?(body_node); end
-end
-
-RuboCop::Cop::Layout::IndentationWidth::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::InitialIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def first_token; end
-  def space_before(token); end
-end
-
-RuboCop::Cop::Layout::InitialIndentation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::LeadingCommentSpace < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def allow_doxygen_comment?; end
-  def allow_gemfile_ruby_comment?; end
-  def allowed_on_first_line?(comment); end
-  def doxygen_comment_style?(comment); end
-  def gemfile?; end
-  def gemfile_ruby_comment?(comment); end
-  def hash_mark(expr); end
-  def rackup_config_file?; end
-  def rackup_options?(comment); end
-  def ruby_comment_in_gemfile?(comment); end
-  def shebang?(comment); end
-end
-
-RuboCop::Cop::Layout::LeadingCommentSpace::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::LeadingEmptyLines < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-end
-
-RuboCop::Cop::Layout::LeadingEmptyLines::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::LineContinuationLeadingSpace < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_dstr(node); end
-
-  private
-
-  def continuation?(line); end
-  def enforced_style_leading?; end
-  def investigate_leading_style(first_line, end_of_first_line); end
-  def investigate_trailing_style(second_line, end_of_first_line); end
-  def leading_offense_range(end_of_first_line, matches); end
-  def message(_range); end
-  def raw_lines(node); end
-  def trailing_offense_range(end_of_first_line, matches); end
-end
-
-class RuboCop::Cop::Layout::LineContinuationSpacing < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def autocorrect(corrector, range); end
-  def comment_ranges(comments); end
-  def find_offensive_spacing(line); end
-  def ignore_range?(backtick_range); end
-  def investigate(line, line_number); end
-  def last_line(processed_source); end
-  def message(_range); end
-  def no_space_style?; end
-  def space_style?; end
-  def string_literal_ranges(ast); end
-end
-
-class RuboCop::Cop::Layout::LineEndStringConcatenationIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::Alignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def autocorrect(corrector, node); end
-  def on_dstr(node); end
-
-  private
-
-  def add_offense_and_correction(node, message); end
-  def always_indented?(dstr_node); end
-  def base_column(child); end
-  def check_aligned(children, start_index); end
-  def check_indented(children); end
-  def strings_concatenated_with_backslash?(dstr_node); end
-end
-
-RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::MSG_ALIGN = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::MSG_INDENT = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::PARENT_TYPES_FOR_INDENTED = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Layout::LineLength < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::CheckLineBreakable
-  include ::RuboCop::Cop::AllowedPattern
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::LineLengthHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def max=(value); end
-  def on_array(node); end
-  def on_block(node); end
-  def on_def(node); end
-  def on_hash(node); end
-  def on_investigation_end; end
-  def on_new_investigation; end
-  def on_potential_breakable_node(node); end
-  def on_send(node); end
-
-  private
-
-  def allow_heredoc?; end
-  def allowed_heredoc; end
-  def allowed_line?(line, line_index); end
-  def breakable_block_range(block_node); end
-  def breakable_range; end
-  def breakable_range=(_arg0); end
-  def breakable_range_after_semicolon(semicolon_token); end
-  def breakable_range_by_line_index; end
-  def check_directive_line(line, line_index); end
-  def check_for_breakable_block(block_node); end
-  def check_for_breakable_node(node); end
-  def check_for_breakable_semicolons(processed_source); end
-  def check_line(line, line_index); end
-  def check_uri_line(line, line_index); end
-  def excess_range(uri_range, line, line_index); end
-  def extract_heredocs(ast); end
-  def heredocs; end
-  def highlight_start(line); end
-  def line_in_heredoc?(line_number); end
-  def line_in_permitted_heredoc?(line_number); end
-  def max; end
-  def register_offense(loc, line, line_index, length: T.unsafe(nil)); end
-  def shebang?(line, line_index); end
-end
-
-RuboCop::Cop::Layout::LineLength::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::MultilineArrayBraceLayout < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::MultilineLiteralBraceLayout
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_array(node); end
-end
-
-RuboCop::Cop::Layout::MultilineArrayBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineArrayBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineArrayBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineArrayBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::MultilineArrayLineBreaks < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::MultilineElementLineBreaks
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_array(node); end
-end
-
-RuboCop::Cop::Layout::MultilineArrayLineBreaks::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::MultilineAssignmentLayout < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::CheckAssignment
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def check_assignment(node, rhs); end
-  def check_by_enforced_style(node, rhs); end
-  def check_new_line_offense(node, rhs); end
-  def check_same_line_offense(node, rhs); end
-
-  private
-
-  def supported_types; end
-end
-
-RuboCop::Cop::Layout::MultilineAssignmentLayout::NEW_LINE_OFFENSE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineAssignmentLayout::SAME_LINE_OFFENSE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::MultilineBlockLayout < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-
-  private
-
-  def add_offense_for_expression(node, expr, msg); end
-  def args_on_beginning_line?(node); end
-  def autocorrect(corrector, node); end
-  def autocorrect_arguments(corrector, node); end
-  def autocorrect_body(corrector, node, block_body); end
-  def block_arg_string(node, args); end
-  def characters_needed_for_space_and_pipes(node); end
-  def include_trailing_comma?(args); end
-  def line_break_necessary_in_args?(node); end
-  def needed_length_for_args(node); end
-end
-
-RuboCop::Cop::Layout::MultilineBlockLayout::ARG_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineBlockLayout::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineBlockLayout::PIPE_SIZE = T.let(T.unsafe(nil), Integer)
-
-class RuboCop::Cop::Layout::MultilineHashBraceLayout < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::MultilineLiteralBraceLayout
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_hash(node); end
-end
-
-RuboCop::Cop::Layout::MultilineHashBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineHashBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineHashBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineHashBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::MultilineElementLineBreaks
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_hash(node); end
-
-  private
-
-  def starts_with_curly_brace?(node); end
-end
-
-RuboCop::Cop::Layout::MultilineHashKeyLineBreaks::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::MultilineElementLineBreaks
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-end
-
-RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::MultilineLiteralBraceLayout
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def children(node); end
-  def ignored_literal?(node); end
-  def single_line_ignoring_receiver?(node); end
-end
-
-RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::MultilineMethodCallIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::MultilineExpressionIndentation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def validate_config; end
-
-  private
-
-  def align_with_base_message(rhs); end
-  def alignment_base(node, rhs, given_style); end
-  def autocorrect(corrector, node); end
-  def base_source; end
-  def extra_indentation(given_style, parent); end
-  def first_call_has_a_dot(node); end
-  def get_dot_right_above(node); end
-  def message(node, lhs, rhs); end
-  def no_base_message(lhs, rhs, node); end
-  def offending_range(node, lhs, rhs, given_style); end
-  def operation_rhs(node); end
-  def operator_rhs?(node, receiver); end
-  def receiver_alignment_base(node); end
-  def relative_to_receiver_message(rhs); end
-  def relevant_node?(send_node); end
-  def right_hand_side(send_node); end
-  def semantic_alignment_base(node, rhs); end
-  def semantic_alignment_node(node); end
-  def should_align_with_base?; end
-  def should_indent_relative_to_receiver?; end
-  def syntactic_alignment_base(lhs, rhs); end
-end
-
-class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::MultilineLiteralBraceLayout
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-end
-
-RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::MultilineElementLineBreaks
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-end
-
-RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::MultilineOperationIndentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::MultilineExpressionIndentation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_and(node); end
-  def on_or(node); end
-  def validate_config; end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def check_and_or(node); end
-  def message(node, lhs, rhs); end
-  def offending_range(node, lhs, rhs, given_style); end
-  def relevant_node?(node); end
-  def right_hand_side(send_node); end
-  def should_align?(node, rhs, given_style); end
-end
-
-class RuboCop::Cop::Layout::ParameterAlignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def base_column(node, args); end
-  def fixed_indentation?; end
-  def message(_node); end
-  def target_method_lineno(node); end
-end
-
-RuboCop::Cop::Layout::ParameterAlignment::ALIGN_PARAMS_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::ParameterAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::RedundantLineBreak < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::CheckAssignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def check_assignment(node, _rhs); end
-  def comment_within?(node); end
-  def configured_to_not_be_inspected?(node); end
-  def convertible_block?(node); end
-  def max_line_length; end
-  def offense?(node); end
-  def other_cop_takes_precedence?(node); end
-  def register_offense(node); end
-  def single_line_block_chain_enabled?; end
-  def suitable_as_single_line?(node); end
-  def to_single_line(source); end
-  def too_long?(node); end
-end
-
-RuboCop::Cop::Layout::RedundantLineBreak::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::RescueEnsureAlignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::EndKeywordAlignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_ensure(node); end
-  def on_new_investigation; end
-  def on_resbody(node); end
-
-  private
-
-  def access_modifier?(node); end
-  def access_modifier_node(node); end
-  def aligned_with_leading_dot?(do_keyword_line, send_node_loc, rescue_keyword_column); end
-  def aligned_with_line_break_method?(ancestor_node, node); end
-  def alignment_location(alignment_node); end
-  def alignment_node(node); end
-  def alignment_source(node, starting_loc); end
-  def ancestor_node(node); end
-  def assignment_node(node); end
-  def autocorrect(corrector, node, alignment_location); end
-  def begin_end_alignment_style; end
-  def check(node); end
-  def format_message(alignment_node, alignment_loc, kw_loc); end
-  def modifier?(node); end
-  def whitespace_range(node); end
-end
-
-RuboCop::Cop::Layout::RescueEnsureAlignment::ALTERNATIVE_ACCESS_MODIFIERS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Layout::RescueEnsureAlignment::ANCESTOR_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Layout::RescueEnsureAlignment::ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Layout::RescueEnsureAlignment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SingleLineBlockChain < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def call_method_after_block?(node, dot_range, closing_block_delimiter_line_num); end
-  def offending_range(node); end
-  def selector_range(node); end
-end
-
-RuboCop::Cop::Layout::SingleLineBlockChain::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SpaceAfterColon < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_kwoptarg(node); end
-  def on_pair(node); end
-
-  private
-
-  def followed_by_space?(colon); end
-  def register_offense(colon); end
-end
-
-RuboCop::Cop::Layout::SpaceAfterColon::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SpaceAfterComma < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::SpaceAfterPunctuation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def kind(token); end
-  def space_style_before_rcurly; end
-end
-
-class RuboCop::Cop::Layout::SpaceAfterMethodName < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-end
-
-RuboCop::Cop::Layout::SpaceAfterMethodName::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SpaceAfterNot < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def whitespace_after_operator?(node); end
-end
-
-RuboCop::Cop::Layout::SpaceAfterNot::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceAfterNot::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Layout::SpaceAfterSemicolon < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::SpaceAfterPunctuation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def kind(token); end
-  def space_style_before_rcurly; end
-end
-
-class RuboCop::Cop::Layout::SpaceAroundBlockParameters < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-
-  private
-
-  def check_after_closing_pipe(arguments); end
-  def check_arg(arg); end
-  def check_closing_pipe_space(arguments, closing_pipe); end
-  def check_each_arg(args); end
-  def check_inside_pipes(arguments); end
-  def check_no_space(space_begin_pos, space_end_pos, msg); end
-  def check_no_space_style_inside_pipes(arguments); end
-  def check_opening_pipe_space(arguments, opening_pipe); end
-  def check_space(space_begin_pos, space_end_pos, range, msg, node = T.unsafe(nil)); end
-  def check_space_style_inside_pipes(arguments); end
-  def last_end_pos_inside_pipes(arguments, range); end
-  def pipes(arguments); end
-  def pipes?(arguments); end
-  def style_parameter_name; end
-end
-
-class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::SurroundingSpace
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_optarg(node); end
-
-  private
-
-  def autocorrect(corrector, range); end
-  def check_optarg(arg, equals, value); end
-  def incorrect_style_detected(arg, value); end
-  def message(_node); end
-  def no_surrounding_space?(arg, equals); end
-  def space_on_both_sides?(arg, equals); end
-end
-
-RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SpaceAroundKeyword < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_and(node); end
-  def on_block(node); end
-  def on_break(node); end
-  def on_case(node); end
-  def on_case_match(node); end
-  def on_defined?(node); end
-  def on_ensure(node); end
-  def on_for(node); end
-  def on_if(node); end
-  def on_if_guard(node); end
-  def on_in_pattern(node); end
-  def on_kwbegin(node); end
-  def on_match_pattern(node); end
-  def on_match_pattern_p(node); end
-  def on_next(node); end
-  def on_or(node); end
-  def on_postexe(node); end
-  def on_preexe(node); end
-  def on_resbody(node); end
-  def on_rescue(node); end
-  def on_return(node); end
-  def on_send(node); end
-  def on_super(node); end
-  def on_unless_guard(node); end
-  def on_until(node); end
-  def on_when(node); end
-  def on_while(node); end
-  def on_yield(node); end
-  def on_zsuper(node); end
-
-  private
-
-  def accept_left_parenthesis?(range); end
-  def accept_left_square_bracket?(range); end
-  def accept_namespace_operator?(range); end
-  def accepted_opening_delimiter?(range, char); end
-  def check(node, locations, begin_keyword = T.unsafe(nil)); end
-  def check_begin(node, range, begin_keyword); end
-  def check_end(node, range, begin_keyword); end
-  def check_keyword(node, range); end
-  def do?(node); end
-  def namespace_operator?(range, pos); end
-  def preceded_by_operator?(node, _range); end
-  def safe_navigation_call?(range, pos); end
-  def space_after_missing?(range); end
-  def space_before_missing?(range); end
-end
-
-RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_LEFT_PAREN = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_LEFT_SQUARE_BRACKET = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_NAMESPACE_OPERATOR = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceAroundKeyword::DO = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceAroundKeyword::MSG_AFTER = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceAroundKeyword::MSG_BEFORE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceAroundKeyword::NAMESPACE_OPERATOR = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceAroundKeyword::SAFE_NAVIGATION = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SpaceAroundMethodCallOperator < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_const(node); end
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def check_space(begin_pos, end_pos); end
-  def check_space_after_dot(node); end
-  def check_space_after_double_colon(node); end
-  def check_space_before_dot(node); end
-end
-
-RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::SPACES_REGEXP = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::Layout::SpaceAroundOperators < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::PrecedingFollowingAlignment
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::RationalLiteral
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_and(node); end
-  def on_and_asgn(node); end
-  def on_assignment(node); end
-  def on_binary(node); end
-  def on_casgn(node); end
-  def on_class(node); end
-  def on_cvasgn(node); end
-  def on_gvasgn(node); end
-  def on_if(node); end
-  def on_ivasgn(node); end
-  def on_lvasgn(node); end
-  def on_masgn(node); end
-  def on_match_pattern(node); end
-  def on_op_asgn(node); end
-  def on_or(node); end
-  def on_or_asgn(node); end
-  def on_pair(node); end
-  def on_resbody(node); end
-  def on_sclass(node); end
-  def on_send(node); end
-  def on_special_asgn(node); end
-
-  private
-
-  def align_hash_cop_config; end
-  def autocorrect(corrector, range); end
-  def check_operator(type, operator, right_operand); end
-  def enclose_operator_with_space(corrector, range); end
-  def excess_leading_space?(type, operator, with_space); end
-  def excess_trailing_space?(right_operand, with_space); end
-  def force_equal_sign_alignment?; end
-  def hash_table_style?; end
-  def offense(type, operator, with_space, right_operand); end
-  def offense_message(type, operator, with_space, right_operand); end
-  def operator_with_regular_syntax?(send_node); end
-  def regular_operator?(send_node); end
-  def should_not_have_surrounding_space?(operator); end
-  def space_around_exponent_operator?; end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Layout::SpaceAroundOperators::EXCESSIVE_SPACE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceAroundOperators::IRREGULAR_METHODS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Layout::SpaceBeforeBlockBraces < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-
-  private
-
-  def autocorrect(corrector, range); end
-  def block_delimiters_style; end
-  def check_empty(left_brace, space_plus_brace, used_style); end
-  def check_non_empty(left_brace, space_plus_brace, used_style); end
-  def conflict_with_block_delimiters?(node); end
-  def empty_braces?(loc); end
-  def space_detected(left_brace, space_plus_brace); end
-  def space_missing(left_brace); end
-  def style_for_empty_braces; end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Layout::SpaceBeforeBlockBraces::DETECTED_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceBeforeBlockBraces::MISSING_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SpaceBeforeBrackets < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def dot_before_brackets?(node, receiver_end_pos, selector_begin_pos); end
-  def offense_range(node, begin_pos); end
-  def offense_range_for_assignment(node, begin_pos); end
-  def reference_variable_with_brackets?(node); end
-  def register_offense(range); end
-end
-
-RuboCop::Cop::Layout::SpaceBeforeBrackets::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceBeforeBrackets::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Layout::SpaceBeforeComma < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::SpaceBeforePunctuation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def kind(token); end
-end
-
-class RuboCop::Cop::Layout::SpaceBeforeComment < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-end
-
-RuboCop::Cop::Layout::SpaceBeforeComment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SpaceBeforeFirstArg < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::PrecedingFollowingAlignment
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def expect_params_after_method_name?(node); end
-  def no_space_between_method_name_and_first_argument?(node); end
-  def regular_method_call_with_arguments?(node); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Layout::SpaceBeforeFirstArg::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SpaceBeforeSemicolon < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::SpaceBeforePunctuation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def kind(token); end
-end
-
-class RuboCop::Cop::Layout::SpaceInLambdaLiteral < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def arrow_lambda_with_args?(node); end
-  def lambda_arguments(node); end
-  def range_of_offense(node); end
-  def space_after_arrow(lambda_node); end
-  def space_after_arrow?(lambda_node); end
-end
-
-RuboCop::Cop::Layout::SpaceInLambdaLiteral::MSG_REQUIRE_NO_SPACE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceInLambdaLiteral::MSG_REQUIRE_SPACE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::SurroundingSpace
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_array(node); end
-
-  private
-
-  def array_brackets(node); end
-  def autocorrect(corrector, node); end
-  def compact(corrector, bracket, side); end
-  def compact_corrections(corrector, node, left, right); end
-  def compact_offense(node, token, side: T.unsafe(nil)); end
-  def compact_offenses(node, left, right, start_ok, end_ok); end
-  def empty_config; end
-  def end_has_own_line?(token); end
-  def index_for(node, token); end
-  def issue_offenses(node, left, right, start_ok, end_ok); end
-  def left_array_bracket(node); end
-  def line_and_column_for(token); end
-  def multi_dimensional_array?(node, token, side: T.unsafe(nil)); end
-  def next_to_bracket?(token, side: T.unsafe(nil)); end
-  def next_to_comment?(node, token); end
-  def next_to_newline?(node, token); end
-  def qualifies_for_compact?(node, token, side: T.unsafe(nil)); end
-  def right_array_bracket(node); end
-end
-
-RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::EMPTY_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::MatchRange
-  include ::RuboCop::Cop::PercentLiteral
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_array(node); end
-  def on_percent_literal(node); end
-
-  private
-
-  def each_unnecessary_space_match(node, &blk); end
-end
-
-RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::Layout::SpaceInsideBlockBraces < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::SurroundingSpace
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def on_numblock(node); end
-
-  private
-
-  def adjacent_braces(left_brace, right_brace); end
-  def aligned_braces?(left_brace, right_brace); end
-  def braces_with_contents_inside(node, inner); end
-  def check_inside(node, left_brace, right_brace); end
-  def check_left_brace(inner, left_brace, args_delimiter); end
-  def check_right_brace(inner, left_brace, right_brace, single_line); end
-  def multiline_block?(left_brace, right_brace); end
-  def no_space(begin_pos, end_pos, msg); end
-  def no_space_inside_left_brace(left_brace, args_delimiter); end
-  def offense(begin_pos, end_pos, msg, style_param = T.unsafe(nil)); end
-  def pipe?(args_delimiter); end
-  def space(begin_pos, end_pos, msg); end
-  def space_inside_left_brace(left_brace, args_delimiter); end
-  def space_inside_right_brace(right_brace); end
-  def style_for_empty_braces; end
-end
-
-class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::SurroundingSpace
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_hash(node); end
-
-  private
-
-  def ambiguous_or_unexpected_style_detected(style, is_match); end
-  def autocorrect(corrector, range); end
-  def check(token1, token2); end
-  def expect_space?(token1, token2); end
-  def incorrect_style_detected(token1, token2, expect_space, is_empty_braces); end
-  def message(brace, is_empty_braces, expect_space); end
-  def offense?(token1, expect_space); end
-  def range_of_space_to_the_left(range); end
-  def range_of_space_to_the_right(range); end
-  def space_range(token_range); end
-end
-
-RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SpaceInsideParens < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::SurroundingSpace
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def can_be_ignored?(token1, token2); end
-  def correct_extaneus_space_between_consecutive_parens(token1, token2); end
-  def correct_extraneous_space(tokens); end
-  def correct_extraneous_space_in_empty_parens(token1, token2); end
-  def correct_missing_space(token1, token2); end
-  def left_parens?(token1, token2); end
-  def parens?(token1, token2); end
-  def process_with_compact_style(tokens); end
-  def process_with_space_style(tokens); end
-  def right_parens?(token1, token2); end
-end
-
-RuboCop::Cop::Layout::SpaceInsideParens::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceInsideParens::MSG_SPACE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::MatchRange
-  include ::RuboCop::Cop::PercentLiteral
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_array(node); end
-  def on_percent_literal(node); end
-  def on_xstr(node); end
-
-  private
-
-  def add_offenses_for_unnecessary_spaces(node); end
-  def regex_matches(node, &blk); end
-end
-
-RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::BEGIN_REGEX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::END_REGEX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SpaceInsideRangeLiteral < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_erange(node); end
-  def on_irange(node); end
-
-  private
-
-  def check(node); end
-end
-
-RuboCop::Cop::Layout::SpaceInsideRangeLiteral::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::SurroundingSpace
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def closing_bracket(tokens, opening_bracket); end
-  def empty_config; end
-  def left_ref_bracket(node, tokens); end
-  def previous_token(current_token); end
-  def reference_brackets(node); end
-end
-
-RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::EMPTY_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Layout::SpaceInsideStringInterpolation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Interpolation
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::SurroundingSpace
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_interpolation(begin_node); end
-
-  private
-
-  def autocorrect(corrector, begin_node); end
-  def delimiters(begin_node); end
-end
-
-RuboCop::Cop::Layout::SpaceInsideStringInterpolation::NO_SPACE_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Layout::SpaceInsideStringInterpolation::SPACE_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Layout::TrailingEmptyLines < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def ends_in_end?(processed_source); end
-  def message(wanted_blank_lines, blank_lines); end
-  def offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end); end
-end
-
-class RuboCop::Cop::Layout::TrailingWhitespace < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::Heredoc
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_heredoc(_node); end
-  def on_new_investigation; end
-
-  private
-
-  def extract_heredocs(ast); end
-  def find_heredoc(line_number); end
-  def offense_range(lineno, line); end
-  def process_line(line, lineno); end
-  def process_line_in_heredoc(corrector, range, heredoc); end
-  def skip_heredoc?; end
-  def static?(heredoc); end
-  def whitespace_is_indentation?(range, level); end
-  def whitespace_only?(range); end
-end
-
-RuboCop::Cop::Layout::TrailingWhitespace::MSG = T.let(T.unsafe(nil), String)
-module RuboCop::Cop::Legacy; end
-
-class RuboCop::Cop::Legacy::CorrectionsProxy
-  def initialize(corrector); end
-
-  def <<(callable); end
-  def concat(corrections); end
-  def empty?; end
-
-  protected
-
-  def corrector; end
-
-  private
-
-  def suppress_clobbering; end
-end
-
-class RuboCop::Cop::LineBreakCorrector
-  extend ::RuboCop::Cop::Alignment
-  extend ::RuboCop::Cop::TrailingBody
-  extend ::RuboCop::PathUtil
-  extend ::RuboCop::Cop::Util
-
-  class << self
-    def break_line_before(range:, node:, corrector:, configured_width:, indent_steps: T.unsafe(nil)); end
-    def correct_trailing_body(configured_width:, corrector:, node:, processed_source:); end
-    def move_comment(eol_comment:, node:, corrector:); end
-    def processed_source; end
-
-    private
-
-    def remove_semicolon(node, corrector); end
-    def semicolon(node); end
-    def trailing_class_definition?(token, body); end
-  end
-end
-
-module RuboCop::Cop::LineLengthHelp
-  private
-
-  def allow_uri?; end
-  def allowed_uri_position?(line, uri_range); end
-  def directive_on_source_line?(line_index); end
-  def extend_uri_end_position(line, end_position); end
-  def find_excessive_uri_range(line); end
-  def ignore_cop_directives?; end
-  def indentation_difference(line); end
-  def line_length(line); end
-  def line_length_without_directive(line); end
-  def match_uris(string); end
-  def tab_indentation_width; end
-  def uri_regexp; end
-  def valid_uri?(uri_ish_string); end
-end
-
-module RuboCop::Cop::Lint; end
-
-class RuboCop::Cop::Lint::AmbiguousAssignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_asgn(node); end
-  def on_casgn(node); end
-  def on_cvasgn(node); end
-  def on_gvasgn(node); end
-  def on_ivasgn(node); end
-  def on_lvasgn(node); end
-
-  private
-
-  def rhs(node); end
-end
-
-RuboCop::Cop::Lint::AmbiguousAssignment::MISTAKES = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Lint::AmbiguousAssignment::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::AmbiguousAssignment::SIMPLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::AmbiguousBlockAssociation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::IgnoredMethods
-  extend ::RuboCop::Cop::IgnoredMethods::Config
-
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def allowed_method?(node); end
-  def ambiguous_block_association?(send_node); end
-  def message(send_node); end
-end
-
-RuboCop::Cop::Lint::AmbiguousBlockAssociation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::AmbiguousOperator < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def find_offense_node_by(diagnostic); end
-  def message(diagnostic); end
-  def offense_node(node); end
-  def offense_position?(node, diagnostic); end
-  def unary_operator?(node, diagnostic); end
-end
-
-RuboCop::Cop::Lint::AmbiguousOperator::AMBIGUITIES = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Lint::AmbiguousOperator::MSG_FORMAT = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::AmbiguousOperatorPrecedence < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_and(node); end
-  def on_new_investigation; end
-  def on_send(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def greater_precedence?(node1, node2); end
-  def operator?(node); end
-  def operator_name(node); end
-  def precedence(node); end
-end
-
-RuboCop::Cop::Lint::AmbiguousOperatorPrecedence::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::AmbiguousOperatorPrecedence::PRECEDENCE = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::AmbiguousOperatorPrecedence::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::AmbiguousRange < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_erange(node); end
-  def on_irange(node); end
-
-  private
-
-  def acceptable?(node); end
-  def acceptable_call?(node); end
-  def each_boundary(range); end
-  def require_parentheses_for_method_chain?; end
-end
-
-RuboCop::Cop::Lint::AmbiguousRange::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::AmbiguousRegexpLiteral < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def find_offense_node(node, regexp_receiver); end
-  def find_offense_node_by(diagnostic); end
-  def first_argument_is_regexp?(node); end
-  def method_chain_to_regexp_receiver?(node, regexp_receiver); end
-end
-
-RuboCop::Cop::Lint::AmbiguousRegexpLiteral::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::AssignmentInCondition < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::SafeAssignment
-
-  def on_if(node); end
-  def on_until(node); end
-  def on_while(node); end
-
-  private
-
-  def allowed_construct?(asgn_node); end
-  def conditional_assignment?(asgn_node); end
-  def message(_node); end
-  def skip_children?(asgn_node); end
-  def traverse_node(node, &block); end
-end
-
-RuboCop::Cop::Lint::AssignmentInCondition::ASGN_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::AssignmentInCondition::MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::AssignmentInCondition::MSG_WITH_SAFE_ASSIGNMENT_ALLOWED = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::BigDecimalNew < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def big_decimal_new(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Lint::BigDecimalNew::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::BigDecimalNew::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands < ::RuboCop::Cop::Base
-  def on_and(node); end
-  def on_or(node); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands::ALLOWED_MATH_OPERATORS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::BooleanSymbol < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def boolean_symbol?(param0 = T.unsafe(nil)); end
-  def on_sym(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-end
-
-RuboCop::Cop::Lint::BooleanSymbol::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::CircularArgumentReference < ::RuboCop::Cop::Base
-  def on_kwoptarg(node); end
-  def on_optarg(node); end
-
-  private
-
-  def check_for_circular_argument_references(arg_name, arg_value); end
-end
-
-RuboCop::Cop::Lint::CircularArgumentReference::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::ConstantDefinitionInBlock < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::AllowedMethods
-
-  def constant_assigned_in_block?(param0 = T.unsafe(nil)); end
-  def module_defined_in_block?(param0 = T.unsafe(nil)); end
-  def on_casgn(node); end
-  def on_class(node); end
-  def on_module(node); end
-
-  private
-
-  def method_name(node); end
-end
-
-RuboCop::Cop::Lint::ConstantDefinitionInBlock::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::ConstantOverwrittenInRescue < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_resbody(node); end
-  def overwritten_constant(param0 = T.unsafe(nil)); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Lint::ConstantOverwrittenInRescue::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::ConstantResolution < ::RuboCop::Cop::Base
-  def on_const(node); end
-  def unqualified_const?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def allowed_names; end
-  def const_name?(name); end
-  def ignored_names; end
-end
-
-RuboCop::Cop::Lint::ConstantResolution::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::Debugger < ::RuboCop::Cop::Base
-  def kernel?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def valid_receiver?(param0 = T.unsafe(nil), param1); end
-
-  private
-
-  def debugger_method?(send_node); end
-  def debugger_methods; end
-  def message(node); end
-end
-
-RuboCop::Cop::Lint::Debugger::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::DeprecatedClassMethods < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def check(node); end
-  def replacement(deprecated); end
-end
-
-RuboCop::Cop::Lint::DeprecatedClassMethods::CLASS_METHOD_DELIMETER = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::DeprecatedClassMethods::DEPRECATED_METHODS_OBJECT = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod
-  include ::RuboCop::AST::Sexp
-
-  def initialize(method, class_constant: T.unsafe(nil), correctable: T.unsafe(nil)); end
-
-  def class_constant; end
-  def class_nodes; end
-  def correctable?; end
-  def method; end
-  def to_s; end
-
-  private
-
-  def delimiter; end
-end
-
-RuboCop::Cop::Lint::DeprecatedClassMethods::INSTANCE_METHOD_DELIMETER = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::DeprecatedClassMethods::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::DeprecatedClassMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::DeprecatedClassMethods::Replacement
-  def initialize(method, class_constant: T.unsafe(nil), instance_method: T.unsafe(nil)); end
-
-  def class_constant; end
-  def method; end
-  def to_s; end
-
-  private
-
-  def delimiter; end
-  def instance_method?; end
-end
-
-class RuboCop::Cop::Lint::DeprecatedConstants < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_const(node); end
-
-  private
-
-  def constant_name(node, nested_constant_name); end
-  def deprecated_constants; end
-  def message(good, bad, deprecated_version); end
-end
-
-RuboCop::Cop::Lint::DeprecatedConstants::DO_NOT_USE_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::DeprecatedConstants::SUGGEST_GOOD_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::DeprecatedOpenSSLConstant < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def algorithm_const(param0 = T.unsafe(nil)); end
-  def digest_const?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def algorithm_name(node); end
-  def autocorrect(corrector, node); end
-  def build_cipher_arguments(node, algorithm_name, no_arguments); end
-  def correction_range(node); end
-  def message(node); end
-  def openssl_class(node); end
-  def replacement_args(node); end
-  def sanitize_arguments(arguments); end
-end
-
-RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::NO_ARG_ALGORITHM = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-
-  private
-
-  def check(node); end
-  def check_body(body); end
-  def check_body_lines(lines); end
-  def check_disjunctive_assignment(node); end
-end
-
-RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::DuplicateBranch < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RescueNode
-
-  def on_branching_statement(node); end
-  def on_case(node); end
-  def on_case_match(node); end
-  def on_if(node); end
-  def on_rescue(node); end
-
-  private
-
-  def branches(node); end
-  def consider_branch?(branch); end
-  def const_branch?(branch); end
-  def ignore_constant_branches?; end
-  def ignore_literal_branches?; end
-  def literal_branch?(branch); end
-  def offense_range(duplicate_branch); end
-end
-
-RuboCop::Cop::Lint::DuplicateBranch::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::DuplicateCaseCondition < ::RuboCop::Cop::Base
-  def on_case(case_node); end
-end
-
-RuboCop::Cop::Lint::DuplicateCaseCondition::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::DuplicateElsifCondition < ::RuboCop::Cop::Base
-  def on_if(node); end
-end
-
-RuboCop::Cop::Lint::DuplicateElsifCondition::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::DuplicateHashKey < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Duplication
-
-  def on_hash(node); end
-end
-
-RuboCop::Cop::Lint::DuplicateHashKey::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::DuplicateMethods < ::RuboCop::Cop::Base
-  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def alias_method?(param0 = T.unsafe(nil)); end
-  def method_alias?(param0 = T.unsafe(nil)); end
-  def on_alias(node); end
-  def on_def(node); end
-  def on_defs(node); end
-  def on_send(node); end
-  def sym_name(param0 = T.unsafe(nil)); end
-
-  private
-
-  def check_const_receiver(node, name, const_name); end
-  def check_self_receiver(node, name); end
-  def found_attr(node, args, readable: T.unsafe(nil), writable: T.unsafe(nil)); end
-  def found_instance_method(node, name); end
-  def found_method(node, method_name); end
-  def lookup_constant(node, const_name); end
-  def message_for_dup(node, method_name); end
-  def on_attr(node, attr_name, args); end
-  def possible_dsl?(node); end
-  def qualified_name(enclosing, namespace, mod_name); end
-  def source_location(node); end
-end
-
-RuboCop::Cop::Lint::DuplicateMethods::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::DuplicateMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def each_repeated_character_class_element_loc(node); end
-  def on_regexp(node); end
-
-  private
-
-  def interpolation_locs(node); end
-  def within_interpolation?(node, child); end
-end
-
-RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement::MSG_REPEATED_ELEMENT = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::DuplicateRequire < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-  def on_send(node); end
-  def require_call?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Lint::DuplicateRequire::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::DuplicateRequire::REQUIRE_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Lint::DuplicateRequire::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
-
-class RuboCop::Cop::Lint::DuplicateRescueException < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RescueNode
-
-  def on_rescue(node); end
-end
-
-RuboCop::Cop::Lint::DuplicateRescueException::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::EachWithObjectArgument < ::RuboCop::Cop::Base
-  def each_with_object?(param0 = T.unsafe(nil)); end
-  def on_csend(node); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Lint::EachWithObjectArgument::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::EachWithObjectArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::ElseLayout < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-
-  private
-
-  def autocorrect(corrector, node, first_else); end
-  def check(node); end
-  def check_else(node); end
-  def indentation_width; end
-end
-
-RuboCop::Cop::Lint::ElseLayout::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::EmptyBlock < ::RuboCop::Cop::Base
-  def on_block(node); end
-
-  private
-
-  def allow_comment?(node); end
-  def allow_empty_lambdas?; end
-  def comment_disables_cop?(comment); end
-  def lambda_or_proc?(node); end
-end
-
-RuboCop::Cop::Lint::EmptyBlock::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::EmptyClass < ::RuboCop::Cop::Base
-  def on_class(node); end
-  def on_sclass(node); end
-
-  private
-
-  def body_or_allowed_comment_lines?(node); end
-end
-
-RuboCop::Cop::Lint::EmptyClass::CLASS_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::EmptyClass::METACLASS_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::EmptyConditionalBody < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::CommentsHelp
-
-  def on_if(node); end
-end
-
-RuboCop::Cop::Lint::EmptyConditionalBody::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::EmptyEnsure < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_ensure(node); end
-end
-
-RuboCop::Cop::Lint::EmptyEnsure::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::EmptyExpression < ::RuboCop::Cop::Base
-  def on_begin(node); end
-
-  private
-
-  def empty_expression?(begin_node); end
-end
-
-RuboCop::Cop::Lint::EmptyExpression::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::EmptyFile < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_new_investigation; end
-
-  private
-
-  def contains_only_comments?; end
-  def empty_file?; end
-  def offending?; end
-end
-
-RuboCop::Cop::Lint::EmptyFile::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::EmptyInPattern < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::CommentsHelp
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_case_match(node); end
-end
-
-RuboCop::Cop::Lint::EmptyInPattern::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::EmptyInterpolation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Interpolation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_interpolation(begin_node); end
-end
-
-RuboCop::Cop::Lint::EmptyInterpolation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::EmptyWhen < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::CommentsHelp
-
-  def on_case(node); end
-end
-
-RuboCop::Cop::Lint::EmptyWhen::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::EnsureReturn < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_ensure(node); end
-end
-
-RuboCop::Cop::Lint::EnsureReturn::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::ErbNewArguments < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def erb_new_with_non_keyword_arguments(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def arguments_range(node); end
-  def autocorrect(corrector, node); end
-  def build_kwargs(node); end
-  def correct_arguments?(arguments); end
-  def override_by_legacy_args(kwargs, node); end
-end
-
-RuboCop::Cop::Lint::ErbNewArguments::MESSAGES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::ErbNewArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::FlipFlop < ::RuboCop::Cop::Base
-  def on_eflipflop(node); end
-  def on_iflipflop(node); end
-end
-
-RuboCop::Cop::Lint::FlipFlop::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::FloatComparison < ::RuboCop::Cop::Base
-  def on_send(node); end
-
-  private
-
-  def check_numeric_returning_method(node); end
-  def check_send(node); end
-  def float?(node); end
-end
-
-RuboCop::Cop::Lint::FloatComparison::EQUALITY_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::FloatComparison::FLOAT_INSTANCE_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Lint::FloatComparison::FLOAT_RETURNING_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::FloatComparison::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::FloatComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::FloatOutOfRange < ::RuboCop::Cop::Base
-  def on_float(node); end
-end
-
-RuboCop::Cop::Lint::FloatOutOfRange::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::FormatParameterMismatch < ::RuboCop::Cop::Base
-  def called_on_string?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def count_format_matches(node); end
-  def count_matches(node); end
-  def count_percent_matches(node); end
-  def countable_format?(node); end
-  def countable_percent?(node); end
-  def expected_fields_count(node); end
-  def format?(node); end
-  def format_method?(name, node); end
-  def format_string?(node); end
-  def heredoc?(node); end
-  def invalid_format_string?(node); end
-  def matched_arguments_count?(expected, passed); end
-  def message(node); end
-  def method_with_format_args?(node); end
-  def offending_node?(node); end
-  def percent?(node); end
-  def splat_args?(node); end
-  def sprintf?(node); end
-end
-
-RuboCop::Cop::Lint::FormatParameterMismatch::KERNEL = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::FormatParameterMismatch::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::FormatParameterMismatch::MSG_INVALID = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::FormatParameterMismatch::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::FormatParameterMismatch::SHOVEL = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::FormatParameterMismatch::STRING_TYPES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::HashCompareByIdentity < ::RuboCop::Cop::Base
-  def id_as_hash_key?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Lint::HashCompareByIdentity::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::HashCompareByIdentity::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::HeredocMethodCallPosition < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def all_on_same_line?(nodes); end
-  def autocorrect(corrector, node, heredoc); end
-  def call_after_heredoc_range(heredoc); end
-  def call_end_pos(node); end
-  def call_line_range(node); end
-  def call_range_to_safely_reposition(node, heredoc); end
-  def calls_on_multiple_lines?(node, _heredoc); end
-  def correctly_positioned?(node, heredoc); end
-  def heredoc_begin_line_range(heredoc); end
-  def heredoc_end_pos(heredoc); end
-  def heredoc_node?(node); end
-  def heredoc_node_descendent_receiver(node); end
-  def send_node?(node); end
-  def trailing_comma?(call_source, call_line_source); end
-end
-
-RuboCop::Cop::Lint::HeredocMethodCallPosition::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::IdentityComparison < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def compare_between_object_id_by_double_equal?(node); end
-  def object_id_method?(node); end
-end
-
-RuboCop::Cop::Lint::IdentityComparison::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::IdentityComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::ImplicitStringConcatenation < ::RuboCop::Cop::Base
-  def on_dstr(node); end
-
-  private
-
-  def display_str(node); end
-  def each_bad_cons(node); end
-  def ending_delimiter(str); end
-  def str_content(node); end
-  def string_literal?(node); end
-  def string_literals?(node1, node2); end
-end
-
-RuboCop::Cop::Lint::ImplicitStringConcatenation::FOR_ARRAY = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::ImplicitStringConcatenation::FOR_METHOD = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::ImplicitStringConcatenation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def io_select(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def preferred_method(read, write, timeout); end
-  def scheduler_compatible?(io1, io2); end
-end
-
-RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::IneffectiveAccessModifier < ::RuboCop::Cop::Base
-  def on_class(node); end
-  def on_module(node); end
-  def private_class_methods(param0); end
-
-  private
-
-  def access_modifier?(node); end
-  def check_node(node); end
-  def correct_visibility?(node, modifier, ignored_methods); end
-  def format_message(modifier); end
-  def ineffective_modifier(node, ignored_methods = T.unsafe(nil), modifier = T.unsafe(nil), &block); end
-  def private_class_method_names(node); end
-end
-
-RuboCop::Cop::Lint::IneffectiveAccessModifier::ALTERNATIVE_PRIVATE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::IneffectiveAccessModifier::ALTERNATIVE_PROTECTED = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::IneffectiveAccessModifier::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::InheritException < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def class_new_call?(param0 = T.unsafe(nil)); end
-  def on_class(node); end
-  def on_send(node); end
-
-  private
-
-  def exception_class?(class_node); end
-  def message(node); end
-  def preferred_base_class; end
-end
-
-RuboCop::Cop::Lint::InheritException::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::InheritException::PREFERRED_BASE_CLASS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Lint::InheritException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::InterpolationCheck < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_str(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def heredoc?(node); end
-end
-
-RuboCop::Cop::Lint::InterpolationCheck::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::LambdaWithoutLiteralBlock < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def lambda_with_symbol_proc?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Lint::LambdaWithoutLiteralBlock::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::LambdaWithoutLiteralBlock::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::LiteralAsCondition < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def message(node); end
-  def on_case(case_node); end
-  def on_case_match(case_match_node); end
-  def on_if(node); end
-  def on_send(node); end
-  def on_until(node); end
-  def on_until_post(node); end
-  def on_while(node); end
-  def on_while_post(node); end
-
-  private
-
-  def basic_literal?(node); end
-  def check_case(case_node); end
-  def check_for_literal(node); end
-  def check_node(node); end
-  def condition(node); end
-  def handle_node(node); end
-  def primitive_array?(node); end
-  def when_conditions_range(when_node); end
-end
-
-RuboCop::Cop::Lint::LiteralAsCondition::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::LiteralInInterpolation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Interpolation
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::PercentLiteral
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_interpolation(begin_node); end
-
-  private
-
-  def autocorrected_value(node); end
-  def autocorrected_value_for_array(node); end
-  def autocorrected_value_for_string(node); end
-  def autocorrected_value_for_symbol(node); end
-  def ends_heredoc_line?(node); end
-  def in_array_percent_literal?(node); end
-  def offending?(node); end
-  def prints_as_self?(node); end
-  def space_literal?(node); end
-  def special_keyword?(node); end
-end
-
-RuboCop::Cop::Lint::LiteralInInterpolation::COMPOSITE = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::LiteralInInterpolation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::Loop < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_until_post(node); end
-  def on_while_post(node); end
-
-  private
-
-  def build_break_line(node); end
-  def keyword_and_condition_range(node); end
-  def register_offense(node); end
-end
-
-RuboCop::Cop::Lint::Loop::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::MissingCopEnableDirective < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_new_investigation; end
-
-  private
-
-  def department_enabled?(cop, comment); end
-  def each_missing_enable; end
-  def max_range; end
-  def message(cop, comment, type = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Lint::MissingCopEnableDirective::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::MissingCopEnableDirective::MSG_BOUND = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::MissingSuper < ::RuboCop::Cop::Base
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def callback_method_def?(node); end
-  def contains_super?(node); end
-  def inside_class_with_stateful_parent?(node); end
-  def offender?(node); end
-  def stateless_class?(node); end
-end
-
-RuboCop::Cop::Lint::MissingSuper::CALLBACKS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Lint::MissingSuper::CALLBACK_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::MissingSuper::CLASS_LIFECYCLE_CALLBACKS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::MissingSuper::CONSTRUCTOR_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::MissingSuper::METHOD_LIFECYCLE_CALLBACKS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::MissingSuper::STATELESS_CLASSES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::MixedRegexpCaptureTypes < ::RuboCop::Cop::Base
-  def on_regexp(node); end
-end
-
-RuboCop::Cop::Lint::MixedRegexpCaptureTypes::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::MultipleComparison < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def multiple_compare?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Lint::MultipleComparison::COMPARISON_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::MultipleComparison::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::MultipleComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::MultipleComparison::SET_OPERATION_OPERATORS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::NestedMethodDefinition < ::RuboCop::Cop::Base
-  def class_or_module_or_struct_new_call?(param0 = T.unsafe(nil)); end
-  def eval_call?(param0 = T.unsafe(nil)); end
-  def exec_call?(param0 = T.unsafe(nil)); end
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def scoping_method_call?(child); end
-end
-
-RuboCop::Cop::Lint::NestedMethodDefinition::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::NestedPercentLiteral < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::PercentLiteral
-
-  def on_array(node); end
-  def on_percent_literal(node); end
-
-  private
-
-  def contains_percent_literals?(node); end
-end
-
-RuboCop::Cop::Lint::NestedPercentLiteral::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::NestedPercentLiteral::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::NestedPercentLiteral::REGEXES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::NextWithoutAccumulator < ::RuboCop::Cop::Base
-  def on_block(node); end
-  def on_body_of_reduce(param0 = T.unsafe(nil)); end
-
-  private
-
-  def parent_block_node(node); end
-end
-
-RuboCop::Cop::Lint::NextWithoutAccumulator::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::NoReturnInBeginEndBlocks < ::RuboCop::Cop::Base
-  def on_lvasgn(node); end
-  def on_op_asgn(node); end
-  def on_or_asgn(node); end
-end
-
-RuboCop::Cop::Lint::NoReturnInBeginEndBlocks::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::NonAtomicFileOperation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def explicit_not_force?(param0); end
-  def force?(param0); end
-  def on_send(node); end
-  def receiver_and_method_name(param0 = T.unsafe(nil)); end
-  def send_exist_node(param0); end
-
-  private
-
-  def allowable_use_with_if?(if_node); end
-  def autocorrect(corrector, node, range); end
-  def autocorrect_replace_method(corrector, node); end
-  def force_method?(node); end
-  def force_method_name?(node); end
-  def force_option?(node); end
-  def if_node_child?(node); end
-  def message_remove_file_exist_check(node); end
-  def register_offense(node, exist_node); end
-  def replacement_method(node); end
-end
-
-RuboCop::Cop::Lint::NonAtomicFileOperation::MAKE_FORCE_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::NonAtomicFileOperation::MAKE_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::NonAtomicFileOperation::MSG_CHANGE_FORCE_METHOD = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::NonAtomicFileOperation::MSG_REMOVE_FILE_EXIST_CHECK = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::NonAtomicFileOperation::REMOVE_FORCE_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::NonAtomicFileOperation::REMOVE_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::NonAtomicFileOperation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::NonDeterministicRequireOrder < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def loop_variable(param0 = T.unsafe(nil)); end
-  def method_require?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def on_block_pass(node); end
-  def unsorted_dir_block?(param0 = T.unsafe(nil)); end
-  def unsorted_dir_each?(param0 = T.unsafe(nil)); end
-  def unsorted_dir_each_pass?(param0 = T.unsafe(nil)); end
-  def unsorted_dir_glob_pass?(param0 = T.unsafe(nil)); end
-  def var_is_required?(param0, param1); end
-
-  private
-
-  def correct_block(corrector, node); end
-  def correct_block_pass(corrector, node); end
-  def last_arg_range(node); end
-  def unsorted_dir_loop?(node); end
-  def unsorted_dir_pass?(node); end
-end
-
-RuboCop::Cop::Lint::NonDeterministicRequireOrder::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::NonLocalExitFromIterator < ::RuboCop::Cop::Base
-  def chained_send?(param0 = T.unsafe(nil)); end
-  def define_method?(param0 = T.unsafe(nil)); end
-  def on_return(return_node); end
-
-  private
-
-  def return_value?(return_node); end
-  def scoped_node?(node); end
-end
-
-RuboCop::Cop::Lint::NonLocalExitFromIterator::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::NumberConversion < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::IgnoredMethods
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::IgnoredMethods::Config
-
-  def on_send(node); end
-  def to_method(param0 = T.unsafe(nil)); end
-  def to_method_symbol(param0 = T.unsafe(nil)); end
-
-  private
-
-  def conversion_method?(method_name); end
-  def correct_method(node, receiver); end
-  def correct_sym_method(to_method); end
-  def handle_as_symbol(node); end
-  def handle_conversion_method(node); end
-  def ignore_receiver?(receiver); end
-  def ignored_class?(name); end
-  def ignored_classes; end
-  def remove_parentheses(corrector, node); end
-  def top_receiver(node); end
-end
-
-RuboCop::Cop::Lint::NumberConversion::CONVERSION_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::NumberConversion::CONVERSION_METHOD_CLASS_MAPPING = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Lint::NumberConversion::METHODS = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::NumberConversion::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::NumberedParameterAssignment < ::RuboCop::Cop::Base
-  def on_lvasgn(node); end
-end
-
-RuboCop::Cop::Lint::NumberedParameterAssignment::LVAR_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::NumberedParameterAssignment::NUMBERED_PARAMETER_RANGE = T.let(T.unsafe(nil), Range)
-RuboCop::Cop::Lint::NumberedParameterAssignment::NUM_PARAM_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::OrAssignmentToConstant < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_or_asgn(node); end
-end
-
-RuboCop::Cop::Lint::OrAssignmentToConstant::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::OrderedMagicComments < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::FrozenStringLiteral
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def autocorrect(corrector, encoding_line, frozen_string_literal_line); end
-  def magic_comment_lines; end
-  def magic_comments; end
-end
-
-RuboCop::Cop::Lint::OrderedMagicComments::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::OutOfRangeRegexpRef < ::RuboCop::Cop::Base
-  def after_send(node); end
-  def on_match_with_lvasgn(node); end
-  def on_new_investigation; end
-  def on_nth_ref(node); end
-  def on_when(node); end
-
-  private
-
-  def check_regexp(node); end
-  def nth_ref_receiver?(send_node); end
-  def regexp_first_argument?(send_node); end
-  def regexp_receiver?(send_node); end
-end
-
-RuboCop::Cop::Lint::OutOfRangeRegexpRef::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::OutOfRangeRegexpRef::REGEXP_ARGUMENT_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Lint::OutOfRangeRegexpRef::REGEXP_CAPTURE_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Lint::OutOfRangeRegexpRef::REGEXP_RECEIVER_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Lint::OutOfRangeRegexpRef::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
-
-class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def chained_calls?(node); end
-  def first_argument_starts_with_left_parenthesis?(node); end
-  def space_range(expr, space_length); end
-  def spaces_before_left_parenthesis(node); end
-  def ternary_expression?(node); end
-  def valid_context?(node); end
-  def valid_first_argument?(first_arg); end
-end
-
-RuboCop::Cop::Lint::ParenthesesAsGroupedExpression::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::PercentStringArray < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::PercentLiteral
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_array(node); end
-  def on_percent_literal(node); end
-
-  private
-
-  def contains_quotes_or_commas?(node); end
-end
-
-RuboCop::Cop::Lint::PercentStringArray::LEADING_QUOTE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Lint::PercentStringArray::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::PercentStringArray::QUOTES_AND_COMMAS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::PercentStringArray::TRAILING_QUOTE = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::Lint::PercentSymbolArray < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::PercentLiteral
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_array(node); end
-  def on_percent_literal(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def contains_colons_or_commas?(node); end
-  def non_alphanumeric_literal?(literal); end
-end
-
-RuboCop::Cop::Lint::PercentSymbolArray::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::RaiseException < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def exception?(param0 = T.unsafe(nil)); end
-  def exception_new_with_message?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def allow_implicit_namespaces; end
-  def check(node); end
-  def implicit_namespace?(node); end
-end
-
-RuboCop::Cop::Lint::RaiseException::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RaiseException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::RandOne < ::RuboCop::Cop::Base
-  def on_send(node); end
-  def rand_one?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def message(node); end
-end
-
-RuboCop::Cop::Lint::RandOne::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RandOne::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::RedundantCopDisableDirective < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def initialize(config = T.unsafe(nil), options = T.unsafe(nil), offenses = T.unsafe(nil)); end
-
-  def offenses_to_check; end
-  def offenses_to_check=(_arg0); end
-  def on_new_investigation; end
-
-  private
-
-  def add_department_marker(department); end
-  def add_offense_for_entire_comment(comment, cops); end
-  def add_offense_for_some_cops(comment, cops); end
-  def add_offenses(redundant_cops); end
-  def all_cop_names; end
-  def all_disabled?(comment); end
-  def comment_range_with_surrounding_space(directive_comment_range, line_comment_range); end
-  def cop_disabled_line_ranges; end
-  def cop_range(comment, cop); end
-  def department_disabled?(cop, comment); end
-  def department_marker?(department); end
-  def describe(cop); end
-  def directive_count(comment); end
-  def directive_range_in_list(range, ranges); end
-  def disabled_ranges; end
-  def each_already_disabled(cop, line_ranges); end
-  def each_line_range(cop, line_ranges); end
-  def each_redundant_disable(&block); end
-  def ends_its_line?(range); end
-  def find_redundant_all(range, next_range); end
-  def find_redundant_cop(cop, range); end
-  def find_redundant_department(cop, range); end
-  def followed_ranges?(range, next_range); end
-  def ignore_offense?(line_range); end
-  def matching_range(haystack, needle); end
-  def message(cop_names); end
-  def previous_line_blank?(range); end
-  def range_with_offense?(range, offenses = T.unsafe(nil)); end
-  def remove_department_marker(department); end
-  def trailing_range?(ranges, range); end
-end
-
-RuboCop::Cop::Lint::RedundantCopDisableDirective::COP_NAME = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RedundantCopDisableDirective::DEPARTMENT_MARKER = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::RedundantCopEnableDirective < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::SurroundingSpace
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def all_or_name(name); end
-  def comment_start(comment); end
-  def cop_name_indention(comment, name); end
-  def department?(directive, name); end
-  def range_of_offense(comment, name); end
-  def range_to_remove(begin_pos, end_pos, comment); end
-  def range_with_comma(comment, name); end
-  def range_with_comma_after(comment, start, begin_pos, end_pos); end
-  def range_with_comma_before(start, begin_pos, end_pos); end
-  def register_offense(comment, cop_names); end
-end
-
-RuboCop::Cop::Lint::RedundantCopEnableDirective::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::RedundantDirGlobSort < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_send(node); end
-end
-
-RuboCop::Cop::Lint::RedundantDirGlobSort::GLOB_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::RedundantDirGlobSort::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RedundantDirGlobSort::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::RedundantRequireStatement < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_send(node); end
-  def unnecessary_require_statement?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Lint::RedundantRequireStatement::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RedundantRequireStatement::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::RedundantSafeNavigation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::AllowedMethods
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def respond_to_nil_specific_method?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def check?(node); end
-  def condition?(parent, node); end
-end
-
-RuboCop::Cop::Lint::RedundantSafeNavigation::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RedundantSafeNavigation::NIL_SPECIFIC_METHODS = T.let(T.unsafe(nil), Set)
-
-class RuboCop::Cop::Lint::RedundantSplatExpansion < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def array_new?(param0 = T.unsafe(nil)); end
-  def literal_expansion(param0 = T.unsafe(nil)); end
-  def on_splat(node); end
-
-  private
-
-  def allow_percent_literal_array_argument?; end
-  def array_new_inside_array_literal?(array_new_node); end
-  def array_splat?(node); end
-  def autocorrect(corrector, node); end
-  def method_argument?(node); end
-  def part_of_an_array?(node); end
-  def redundant_brackets?(node); end
-  def redundant_splat_expansion(node); end
-  def remove_brackets(array); end
-  def replacement_range_and_content(node); end
-  def use_percent_literal_array_argument?(node); end
-end
-
-RuboCop::Cop::Lint::RedundantSplatExpansion::ARRAY_PARAM_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RedundantSplatExpansion::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::RedundantSplatExpansion::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_CAPITAL_I = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_CAPITAL_W = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_I = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_W = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::RedundantStringCoercion < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Interpolation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_interpolation(begin_node); end
-  def to_s_without_args?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Lint::RedundantStringCoercion::MSG_DEFAULT = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RedundantStringCoercion::MSG_SELF = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::RedundantWithIndex < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def redundant_with_index?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def message(node); end
-  def with_index_range(send); end
-end
-
-RuboCop::Cop::Lint::RedundantWithIndex::MSG_EACH_WITH_INDEX = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RedundantWithIndex::MSG_WITH_INDEX = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::RedundantWithObject < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def redundant_with_object?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def message(node); end
-  def with_object_range(send); end
-end
-
-RuboCop::Cop::Lint::RedundantWithObject::MSG_EACH_WITH_OBJECT = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RedundantWithObject::MSG_WITH_OBJECT = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::RefinementImportMethods < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_send(node); end
-end
-
-RuboCop::Cop::Lint::RefinementImportMethods::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RefinementImportMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::RegexpAsCondition < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_match_current_line(node); end
-end
-
-RuboCop::Cop::Lint::RegexpAsCondition::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::RequireParentheses < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def check_predicate(predicate, node); end
-  def check_ternary(ternary, node); end
-end
-
-RuboCop::Cop::Lint::RequireParentheses::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::RequireRangeParentheses < ::RuboCop::Cop::Base
-  def on_erange(node); end
-  def on_irange(node); end
-end
-
-RuboCop::Cop::Lint::RequireRangeParentheses::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::RequireRelativeSelfPath < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def remove_ext(file_path); end
-  def same_file?(file_path, required_feature); end
-end
-
-RuboCop::Cop::Lint::RequireRelativeSelfPath::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::RequireRelativeSelfPath::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::RescueException < ::RuboCop::Cop::Base
-  def on_resbody(node); end
-  def targets_exception?(rescue_arg_node); end
-end
-
-RuboCop::Cop::Lint::RescueException::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::RescueType < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def autocorrect(corrector, node); end
-  def on_resbody(node); end
-
-  private
-
-  def correction(*exceptions); end
-  def invalid_exceptions(exceptions); end
-  def valid_exceptions(exceptions); end
-end
-
-RuboCop::Cop::Lint::RescueType::INVALID_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::RescueType::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::ReturnInVoidContext < ::RuboCop::Cop::Base
-  def on_return(return_node); end
-
-  private
-
-  def non_void_context(return_node); end
-end
-
-RuboCop::Cop::Lint::ReturnInVoidContext::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::SafeNavigationChain < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::AllowedMethods
-  include ::RuboCop::Cop::NilMethods
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def bad_method?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def add_safe_navigation_operator(offense_range:, send_node:); end
-  def autocorrect(corrector, offense_range:, send_node:); end
-  def method_chain(node); end
-end
-
-RuboCop::Cop::Lint::SafeNavigationChain::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::SafeNavigationConsistency < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::AllowedMethods
-  include ::RuboCop::Cop::NilMethods
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def check(node); end
-  def on_csend(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def location(node, unsafe_method_call); end
-  def top_conditional_ancestor(node); end
-  def unsafe_method_calls(method_calls, safe_nav_receiver); end
-end
-
-RuboCop::Cop::Lint::SafeNavigationConsistency::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::SafeNavigationWithEmpty < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-  def safe_navigation_empty_in_conditional?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Lint::SafeNavigationWithEmpty::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::ScriptPermission < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def autocorrect(comment); end
-  def executable?(processed_source); end
-  def format_message_from(processed_source); end
-end
-
-RuboCop::Cop::Lint::ScriptPermission::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::ScriptPermission::SHEBANG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::SelfAssignment < ::RuboCop::Cop::Base
-  def on_and_asgn(node); end
-  def on_casgn(node); end
-  def on_cvasgn(node); end
-  def on_gvasgn(node); end
-  def on_ivasgn(node); end
-  def on_lvasgn(node); end
-  def on_masgn(node); end
-  def on_or_asgn(node); end
-
-  private
-
-  def multiple_self_assignment?(node); end
-  def rhs_matches_lhs?(rhs, lhs); end
-end
-
-RuboCop::Cop::Lint::SelfAssignment::ASSIGNMENT_TYPE_TO_RHS_TYPE = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Lint::SelfAssignment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::SendWithMixinArgument < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def send_with_mixin_argument?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def bad_location(node); end
-  def message(method, module_name, bad_method); end
-  def mixin_method?(node); end
-end
-
-RuboCop::Cop::Lint::SendWithMixinArgument::MIXIN_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::SendWithMixinArgument::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::SendWithMixinArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::SendWithMixinArgument::SEND_METHODS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::ShadowedArgument < ::RuboCop::Cop::Base
-  def after_leaving_scope(scope, _variable_table); end
-  def uses_var?(param0, param1); end
-
-  private
-
-  def argument_references(argument); end
-  def assignment_without_argument_usage(argument); end
-  def check_argument(argument); end
-  def ignore_implicit_references?; end
-  def node_within_block_or_conditional?(node, stop_search_node); end
-  def reference_pos(node); end
-  def shadowing_assignment(argument); end
-
-  class << self
-    def joining_forces; end
-  end
-end
-
-RuboCop::Cop::Lint::ShadowedArgument::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::ShadowedException < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RescueNode
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_rescue(node); end
-
-  private
-
-  def compare_exceptions(exception, other_exception); end
-  def contains_multiple_levels_of_exceptions?(group); end
-  def evaluate_exceptions(group); end
-  def find_shadowing_rescue(rescues); end
-  def offense_range(rescues); end
-  def rescued_exceptions(rescue_group); end
-  def rescued_groups_for(rescues); end
-  def sorted?(rescued_groups); end
-  def system_call_err?(error); end
-end
-
-RuboCop::Cop::Lint::ShadowedException::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::ShadowingOuterLocalVariable < ::RuboCop::Cop::Base
-  def before_declaring_variable(variable, variable_table); end
-  def ractor_block?(param0 = T.unsafe(nil)); end
-  def same_conditions_node_different_branch?(variable, outer_local_variable); end
-
-  class << self
-    def joining_forces; end
-  end
-end
-
-RuboCop::Cop::Lint::ShadowingOuterLocalVariable::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::StructNewOverride < ::RuboCop::Cop::Base
-  def on_send(node); end
-  def struct_new(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Lint::StructNewOverride::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::StructNewOverride::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::StructNewOverride::STRUCT_MEMBER_NAME_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::StructNewOverride::STRUCT_METHOD_NAMES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::SuppressedException < ::RuboCop::Cop::Base
-  def on_resbody(node); end
-
-  private
-
-  def comment_between_rescue_and_end?(node); end
-  def nil_body?(node); end
-end
-
-RuboCop::Cop::Lint::SuppressedException::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::SymbolConversion < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::SymbolHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_hash(node); end
-  def on_send(node); end
-  def on_sym(node); end
-
-  private
-
-  def correct_hash_key(node); end
-  def correct_inconsistent_hash_keys(keys); end
-  def in_alias?(node); end
-  def in_percent_literal_array?(node); end
-  def properly_quoted?(source, value); end
-  def register_offense(node, correction:, message: T.unsafe(nil)); end
-  def requires_quotes?(sym_node); end
-end
-
-RuboCop::Cop::Lint::SymbolConversion::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::SymbolConversion::MSG_CONSISTENCY = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::SymbolConversion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::Syntax < ::RuboCop::Cop::Base
-  def on_other_file; end
-
-  private
-
-  def add_offense_from_diagnostic(diagnostic, ruby_version); end
-  def add_offense_from_error(error); end
-  def beautify_message(message); end
-end
-
-class RuboCop::Cop::Lint::ToEnumArguments < ::RuboCop::Cop::Base
-  def enum_conversion_call?(param0 = T.unsafe(nil)); end
-  def method_name?(param0 = T.unsafe(nil), param1); end
-  def on_send(node); end
-  def passing_keyword_arg?(param0 = T.unsafe(nil), param1); end
-
-  private
-
-  def argument_match?(send_arg, def_arg); end
-  def arguments_match?(arguments, def_node); end
-end
-
-RuboCop::Cop::Lint::ToEnumArguments::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::ToEnumArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::ToJSON < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-end
-
-RuboCop::Cop::Lint::ToJSON::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::TopLevelReturnWithArgument < ::RuboCop::Cop::Base
-  def on_return(return_node); end
-
-  private
-
-  def ancestors_valid?(return_node); end
-end
-
-RuboCop::Cop::Lint::TopLevelReturnWithArgument::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def trailing_comma_range(node); end
-end
-
-RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::TripleQuotes < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_dstr(node); end
-
-  private
-
-  def empty_str_nodes(node); end
-end
-
-RuboCop::Cop::Lint::TripleQuotes::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::UnderscorePrefixedVariableName < ::RuboCop::Cop::Base
-  def after_leaving_scope(scope, _variable_table); end
-  def check_variable(variable); end
-
-  private
-
-  def allowed_keyword_block_argument?(variable); end
-
-  class << self
-    def joining_forces; end
-  end
-end
-
-RuboCop::Cop::Lint::UnderscorePrefixedVariableName::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::UnexpectedBlockArity < ::RuboCop::Cop::Base
-  def on_block(node); end
-  def on_numblock(node); end
-
-  private
-
-  def acceptable?(node); end
-  def arg_count(node); end
-  def expected_arity(method); end
-  def included_method?(name); end
-  def methods; end
-end
-
-RuboCop::Cop::Lint::UnexpectedBlockArity::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::UnifiedInteger < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def fixnum_or_bignum_const(param0 = T.unsafe(nil)); end
-  def on_const(node); end
-end
-
-RuboCop::Cop::Lint::UnifiedInteger::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::UnmodifiedReduceAccumulator < ::RuboCop::Cop::Base
-  def accumulator_index?(param0 = T.unsafe(nil), param1); end
-  def element_modified?(param0, param1); end
-  def expression_values(param0); end
-  def lvar_used?(param0 = T.unsafe(nil), param1); end
-  def on_block(node); end
-  def on_numblock(node); end
-  def reduce_with_block?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def acceptable_return?(return_val, element_name); end
-  def allowed_type?(parent_node); end
-  def block_arg_name(node, index); end
-  def check_return_values(block_node); end
-  def potential_offense?(return_values, block_body, element_name, accumulator_name); end
-  def return_values(block_body_node); end
-  def returned_accumulator_index(return_values, accumulator_name, element_name); end
-  def returns_accumulator_anywhere?(return_values, accumulator_name); end
-end
-
-RuboCop::Cop::Lint::UnmodifiedReduceAccumulator::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::UnmodifiedReduceAccumulator::MSG_INDEX = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::UnreachableCode < ::RuboCop::Cop::Base
-  def flow_command?(param0 = T.unsafe(nil)); end
-  def on_begin(node); end
-  def on_kwbegin(node); end
-
-  private
-
-  def check_case(node); end
-  def check_if(node); end
-  def flow_expression?(node); end
-end
-
-RuboCop::Cop::Lint::UnreachableCode::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::UnreachableLoop < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::AllowedPattern
-
-  def break_command?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def on_for(node); end
-  def on_until(node); end
-  def on_until_post(node); end
-  def on_while(node); end
-  def on_while_post(node); end
-
-  private
-
-  def break_statement?(node); end
-  def check(node); end
-  def check_case(node); end
-  def check_if(node); end
-  def conditional_continue_keyword?(break_statement); end
-  def loop_method?(node); end
-  def preceded_by_continue_statement?(break_statement); end
-  def statements(node); end
-end
-
-RuboCop::Cop::Lint::UnreachableLoop::CONTINUE_KEYWORDS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::UnreachableLoop::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::Lint::UnusedArgument
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def after_leaving_scope(scope, _variable_table); end
-
-  private
-
-  def check_argument(variable); end
-end
-
-class RuboCop::Cop::Lint::UnusedBlockArgument < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Lint::UnusedArgument
-  extend ::RuboCop::Cop::AutoCorrector
-
-  private
-
-  def allow_unused_keyword_arguments?; end
-  def allowed_block?(variable); end
-  def allowed_keyword_argument?(variable); end
-  def augment_message(message, variable); end
-  def autocorrect(corrector, node); end
-  def check_argument(variable); end
-  def define_method_call?(variable); end
-  def empty_block?(variable); end
-  def ignore_empty_blocks?; end
-  def message(variable); end
-  def message_for_lambda(variable, all_arguments); end
-  def message_for_normal_block(variable, all_arguments); end
-  def message_for_underscore_prefix(variable); end
-  def used_block_local?(variable); end
-  def variable_type(variable); end
-
-  class << self
-    def joining_forces; end
-  end
-end
-
-class RuboCop::Cop::Lint::UnusedMethodArgument < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Lint::UnusedArgument
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def not_implemented?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def check_argument(variable); end
-  def ignored_method?(body); end
-  def message(variable); end
-
-  class << self
-    def joining_forces; end
-  end
-end
-
-class RuboCop::Cop::Lint::UriEscapeUnescape < ::RuboCop::Cop::Base
-  def on_send(node); end
-  def uri_escape_unescape?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Lint::UriEscapeUnescape::ALTERNATE_METHODS_OF_URI_ESCAPE = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::UriEscapeUnescape::ALTERNATE_METHODS_OF_URI_UNESCAPE = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::UriEscapeUnescape::METHOD_NAMES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::UriEscapeUnescape::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::UriEscapeUnescape::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::UriRegexp < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-end
-
-RuboCop::Cop::Lint::UriRegexp::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::UriRegexp::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::UriRegexp::URI_CONSTANTS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::UselessAccessModifier < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def class_or_instance_eval?(param0 = T.unsafe(nil)); end
-  def class_or_module_or_struct_new_call?(param0 = T.unsafe(nil)); end
-  def dynamic_method_definition?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def on_class(node); end
-  def on_module(node); end
-  def on_sclass(node); end
-  def static_method_definition?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def access_modifier?(node); end
-  def any_context_creating_methods?(child); end
-  def any_method_definition?(child); end
-  def autocorrect(corrector, node); end
-  def check_child_nodes(node, unused, cur_vis); end
-  def check_new_visibility(node, unused, new_vis, cur_vis); end
-  def check_node(node); end
-  def check_scope(node); end
-  def check_send_node(node, cur_vis, unused); end
-  def eval_call?(child); end
-  def method_definition?(child); end
-  def start_of_new_scope?(child); end
-end
-
-RuboCop::Cop::Lint::UselessAccessModifier::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::UselessAssignment < ::RuboCop::Cop::Base
-  def after_leaving_scope(scope, _variable_table); end
-  def check_for_unused_assignments(variable); end
-  def collect_variable_like_names(scope); end
-  def message_for_useless_assignment(assignment); end
-  def message_specification(assignment, variable); end
-  def multiple_assignment_message(variable_name); end
-  def operator_assignment_message(scope, assignment); end
-  def return_value_node_of_scope(scope); end
-  def similar_name_message(variable); end
-  def variable_like_method_invocation?(node); end
-
-  class << self
-    def joining_forces; end
-  end
-end
-
-RuboCop::Cop::Lint::UselessAssignment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::UselessElseWithoutRescue < ::RuboCop::Cop::Base
-  def on_new_investigation; end
-end
-
-RuboCop::Cop::Lint::UselessElseWithoutRescue::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::UselessMethodDefinition < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def delegating?(node, def_node); end
-  def optional_args?(node); end
-end
-
-RuboCop::Cop::Lint::UselessMethodDefinition::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::UselessRuby2Keywords < ::RuboCop::Cop::Base
-  def method_definition(param0 = T.unsafe(nil), param1); end
-  def on_send(node); end
-
-  private
-
-  def allowed_arguments(arguments); end
-  def inspect_def(node, def_node); end
-  def inspect_sym(node, sym_node); end
-end
-
-RuboCop::Cop::Lint::UselessRuby2Keywords::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::UselessRuby2Keywords::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::UselessSetterCall < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-  def setter_call_to_local_variable?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def last_expression(body); end
-end
-
-RuboCop::Cop::Lint::UselessSetterCall::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::UselessSetterCall::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker
-  def initialize(body_node); end
-
-  def constructor?(node); end
-  def contain_local_object?(variable_name); end
-  def process_assignment(asgn_node, rhs_node); end
-  def process_assignment_node(node); end
-  def process_binary_operator_assignment(op_asgn_node); end
-  def process_logical_operator_assignment(asgn_node); end
-  def process_multiple_assignment(masgn_node); end
-  def scan(node, &block); end
-end
-
-class RuboCop::Cop::Lint::UselessTimes < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def block_arg(param0 = T.unsafe(nil)); end
-  def block_reassigns_arg?(param0, param1); end
-  def on_send(node); end
-  def times_call?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, count, node, proc_name); end
-  def autocorrect_block(corrector, node); end
-  def autocorrect_block_pass(corrector, node, proc_name); end
-  def fix_indentation(source, range); end
-  def never_process?(count, node); end
-  def own_line?(node); end
-  def remove_node(corrector, node); end
-end
-
-RuboCop::Cop::Lint::UselessTimes::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::UselessTimes::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Lint::Void < ::RuboCop::Cop::Base
-  def on_begin(node); end
-  def on_block(node); end
-  def on_kwbegin(node); end
-
-  private
-
-  def check_begin(node); end
-  def check_defined(node); end
-  def check_expression(expr); end
-  def check_literal(node); end
-  def check_nonmutating(node); end
-  def check_self(node); end
-  def check_var(node); end
-  def check_void_op(node); end
-  def in_void_context?(node); end
-end
-
-RuboCop::Cop::Lint::Void::BINARY_OPERATORS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::Void::DEFINED_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::Void::LIT_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::Void::NONMUTATING_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::Void::NONMUTATING_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::Void::OPERATORS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::Void::OP_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::Void::SELF_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::Void::UNARY_OPERATORS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Lint::Void::VAR_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Lint::Void::VOID_CONTEXT_TYPES = T.let(T.unsafe(nil), Array)
-
-module RuboCop::Cop::MatchRange
-  include ::RuboCop::Cop::RangeHelp
-
-  private
-
-  def each_match_range(range, regex); end
-  def match_range(range, match); end
-end
-
-class RuboCop::Cop::MessageAnnotator
-  def initialize(config, cop_name, cop_config, options); end
-
-  def annotate(message); end
-  def config; end
-  def cop_config; end
-  def cop_name; end
-  def options; end
-  def urls; end
-
-  private
-
-  def debug?; end
-  def details; end
-  def display_cop_names?; end
-  def display_style_guide?; end
-  def extra_details?; end
-  def reference_urls; end
-  def style_guide_base_url; end
-  def style_guide_url; end
-
-  class << self
-    def style_guide_urls; end
-  end
-end
-
-module RuboCop::Cop::MethodComplexity
-  include ::RuboCop::Cop::IgnoredMethods
-  include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount
-  extend ::RuboCop::Cop::IgnoredMethods::Config
-  extend ::RuboCop::AST::NodePattern::Macros
-  extend ::RuboCop::ExcludeLimit
-
-  mixes_in_class_methods ::RuboCop::Cop::IgnoredMethods::Config
-
-  def define_method?(param0 = T.unsafe(nil)); end
-  def max=(value); end
-  def on_block(node); end
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def check_complexity(node, method_name); end
-  def complexity(body); end
-
-  class << self
-    def included(base); end
-  end
-end
-
-module RuboCop::Cop::MethodPreference
-  private
-
-  def default_cop_config; end
-  def preferred_method(method); end
-  def preferred_methods; end
-end
-
-module RuboCop::Cop::Metrics; end
-
-class RuboCop::Cop::Metrics::AbcSize < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::IgnoredMethods
-  include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount
-  include ::RuboCop::Cop::MethodComplexity
-  extend ::RuboCop::Cop::IgnoredMethods::Config
-
-  private
-
-  def complexity(node); end
-end
-
-RuboCop::Cop::Metrics::AbcSize::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Metrics::BlockLength < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::CodeLength
-  include ::RuboCop::Cop::IgnoredMethods
-  extend ::RuboCop::Cop::IgnoredMethods::Config
-
-  def on_block(node); end
-  def on_numblock(node); end
-
-  private
-
-  def cop_label; end
-  def method_receiver_excluded?(node); end
-end
-
-RuboCop::Cop::Metrics::BlockLength::LABEL = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Metrics::BlockNesting < ::RuboCop::Cop::Base
-  def max=(value); end
-  def on_new_investigation; end
-
-  private
-
-  def check_nesting_level(node, max, current_level); end
-  def consider_node?(node); end
-  def count_blocks?; end
-  def message(max); end
-end
-
-RuboCop::Cop::Metrics::BlockNesting::NESTING_BLOCKS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Metrics::ClassLength < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::CodeLength
-
-  def on_casgn(node); end
-  def on_class(node); end
-
-  private
-
-  def message(length, max_length); end
-end
-
-class RuboCop::Cop::Metrics::CyclomaticComplexity < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::IgnoredMethods
-  include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount
-  include ::RuboCop::Cop::MethodComplexity
-  include ::RuboCop::Cop::Metrics::Utils::IteratingBlock
-  extend ::RuboCop::Cop::IgnoredMethods::Config
-
-  private
-
-  def complexity_score_for(node); end
-  def count_block?(block); end
-end
-
-RuboCop::Cop::Metrics::CyclomaticComplexity::COUNTED_NODES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Metrics::CyclomaticComplexity::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Metrics::MethodLength < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::CodeLength
-  include ::RuboCop::Cop::IgnoredMethods
-  extend ::RuboCop::Cop::IgnoredMethods::Config
-
-  def on_block(node); end
-  def on_def(node); end
-  def on_defs(node); end
-  def on_numblock(node); end
-
-  private
-
-  def cop_label; end
-end
-
-RuboCop::Cop::Metrics::MethodLength::LABEL = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Metrics::ModuleLength < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::CodeLength
-
-  def module_definition?(param0 = T.unsafe(nil)); end
-  def on_casgn(node); end
-  def on_module(node); end
-
-  private
-
-  def message(length, max_length); end
-end
-
-class RuboCop::Cop::Metrics::ParameterLists < ::RuboCop::Cop::Base
-  def argument_to_lambda_or_proc?(param0 = T.unsafe(nil)); end
-  def max=(value); end
-  def max_optional_parameters=(value); end
-  def on_args(node); end
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def args_count(node); end
-  def count_keyword_args?; end
-  def max_optional_parameters; end
-  def max_params; end
-end
-
-RuboCop::Cop::Metrics::ParameterLists::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Metrics::ParameterLists::NAMED_KEYWORD_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Metrics::ParameterLists::OPTIONAL_PARAMETERS_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Metrics::PerceivedComplexity < ::RuboCop::Cop::Metrics::CyclomaticComplexity
-  private
-
-  def complexity_score_for(node); end
-end
-
-RuboCop::Cop::Metrics::PerceivedComplexity::COUNTED_NODES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Metrics::PerceivedComplexity::MSG = T.let(T.unsafe(nil), String)
-module RuboCop::Cop::Metrics::Utils; end
-
-class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator
-  include ::RuboCop::AST::Sexp
-  include ::RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount
-  include ::RuboCop::Cop::Metrics::Utils::IteratingBlock
-  include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount
-
-  def calculate; end
-  def else_branch?(node); end
-  def evaluate_condition_node(node); end
-
-  private
-
-  def argument?(node); end
-  def assignment?(node); end
-  def branch?(node); end
-  def capturing_variable?(name); end
-  def compound_assignment(node); end
-  def condition?(node); end
-  def simple_assignment?(node); end
-  def visit_depth_last(node, &block); end
-
-  class << self
-    def calculate(node, discount_repeated_attributes: T.unsafe(nil)); end
-  end
-end
-
-RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::ARGUMENT_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::BRANCH_NODES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::CONDITION_NODES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Metrics::Utils::CodeLengthCalculator
-  include ::RuboCop::PathUtil
-  include ::RuboCop::Cop::Util
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def initialize(node, processed_source, count_comments: T.unsafe(nil), foldable_types: T.unsafe(nil)); end
-
-  def calculate; end
-
-  private
-
-  def another_args?(node); end
-  def build_foldable_checks(types); end
-  def classlike_code_length(node); end
-  def classlike_node?(node); end
-  def code_length(node); end
-  def count_comments?; end
-  def each_top_level_descendant(node, types, &block); end
-  def extract_body(node); end
-  def foldable_node?(node); end
-  def heredoc_length(node); end
-  def heredoc_node?(node); end
-  def irrelevant_line?(source_line); end
-  def line_numbers_of_inner_nodes(node, *types); end
-  def namespace_module?(node); end
-  def normalize_foldable_types(types); end
-  def omit_length(descendant); end
-  def parenthesized?(node); end
-end
-
-RuboCop::Cop::Metrics::Utils::CodeLengthCalculator::CLASSLIKE_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Metrics::Utils::CodeLengthCalculator::FOLDABLE_TYPES = T.let(T.unsafe(nil), Array)
-
-module RuboCop::Cop::Metrics::Utils::IteratingBlock
-  def block_method_name(node); end
-  def iterating_block?(node); end
-  def iterating_method?(name); end
-end
-
-RuboCop::Cop::Metrics::Utils::IteratingBlock::KNOWN_ITERATING_METHODS = T.let(T.unsafe(nil), Set)
-
-module RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount
-  include ::RuboCop::AST::Sexp
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def initialize(node, discount_repeated_attributes: T.unsafe(nil)); end
-
-  def attribute_call?(param0 = T.unsafe(nil)); end
-  def calculate_node(node); end
-  def discount_repeated_attributes?; end
-  def evaluate_branch_nodes(node); end
-  def root_node?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def discount_repeated_attribute?(send_node); end
-  def find_attributes(node, &block); end
-  def setter_to_getter(node); end
-  def update_repeated_attribute(node); end
-end
-
-RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount::VAR_SETTER_TO_GETTER = T.let(T.unsafe(nil), Hash)
-
-module RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount
-  def discount_for_repeated_csend?(csend_node); end
-  def reset_on_lvasgn(node); end
-  def reset_repeated_csend; end
-end
-
-module RuboCop::Cop::Migration; end
-
-class RuboCop::Cop::Migration::DepartmentName < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def check_cop_name(name, comment, offset); end
-  def contain_unexpected_character_for_department_name?(name); end
-  def disable_comment_offset; end
-  def qualified_legacy_cop_name(cop_name); end
-  def valid_content_token?(content_token); end
-end
-
-RuboCop::Cop::Migration::DepartmentName::DISABLE_COMMENT_FORMAT = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Migration::DepartmentName::DISABLING_COPS_CONTENT_TOKEN = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Migration::DepartmentName::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::MinBodyLength
-  private
-
-  def min_body_length; end
-  def min_body_length?(node); end
-end
-
-module RuboCop::Cop::MultilineElementIndentation
-  private
-
-  def check_expected_style(styles); end
-  def check_first(first, left_brace, left_parenthesis, offset); end
-  def detected_styles(actual_column, offset, left_parenthesis, left_brace); end
-  def detected_styles_for_column(column, left_parenthesis, left_brace); end
-  def each_argument_node(node, type); end
-  def hash_pair_where_value_beginning_with(left_brace, first); end
-  def incorrect_style_detected(styles, first, base_column_type); end
-  def indent_base(left_brace, first, left_parenthesis); end
-  def key_and_value_begin_on_same_line?(pair); end
-  def right_sibling_begins_on_subsequent_line?(pair); end
-end
-
-module RuboCop::Cop::MultilineElementLineBreaks
-  private
-
-  def all_on_same_line?(nodes); end
-  def check_line_breaks(_node, children); end
-end
-
-module RuboCop::Cop::MultilineExpressionIndentation
-  def on_send(node); end
-
-  private
-
-  def argument_in_method_call(node, kind); end
-  def assignment_rhs(node); end
-  def check(range, node, lhs, rhs); end
-  def correct_indentation(node); end
-  def disqualified_rhs?(candidate, ancestor); end
-  def grouped_expression?(node); end
-  def incorrect_style_detected(range, node, lhs, rhs); end
-  def indentation(node); end
-  def indented_keyword_expression(node); end
-  def inside_arg_list_parentheses?(node, ancestor); end
-  def keyword_message_tail(node); end
-  def kw_node_with_special_indentation(node); end
-  def left_hand_side(lhs); end
-  def not_for_this_cop?(node); end
-  def operation_description(node, rhs); end
-  def part_of_assignment_rhs(node, candidate); end
-  def part_of_block_body?(candidate, block_node); end
-  def postfix_conditional?(node); end
-  def valid_method_rhs_candidate?(candidate, node); end
-  def valid_rhs?(candidate, ancestor); end
-  def valid_rhs_candidate?(candidate, node); end
-  def within_node?(inner, outer); end
-end
-
-RuboCop::Cop::MultilineExpressionIndentation::ASSIGNMENT_MESSAGE_TAIL = T.let(T.unsafe(nil), String)
-RuboCop::Cop::MultilineExpressionIndentation::DEFAULT_MESSAGE_TAIL = T.let(T.unsafe(nil), String)
-RuboCop::Cop::MultilineExpressionIndentation::KEYWORD_ANCESTOR_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::MultilineExpressionIndentation::KEYWORD_MESSAGE_TAIL = T.let(T.unsafe(nil), String)
-RuboCop::Cop::MultilineExpressionIndentation::UNALIGNED_RHS_TYPES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::MultilineLiteralBraceCorrector
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::MultilineLiteralBraceLayout
-  include ::RuboCop::Cop::RangeHelp
-
-  def initialize(corrector, node, processed_source); end
-
-  def call; end
-
-  private
-
-  def content_if_comment_present(corrector, node); end
-  def correct_next_line_brace(corrector); end
-  def correct_same_line_brace(corrector); end
-  def corrector; end
-  def last_element_range_with_trailing_comma(node); end
-  def last_element_trailing_comma_range(node); end
-  def node; end
-  def processed_source; end
-  def remove_trailing_content_of_comment(corrector, range); end
-  def select_content_to_be_inserted_after_last_element(corrector, node); end
-
-  class << self
-    def correct(corrector, node, processed_source); end
-  end
-end
-
-module RuboCop::Cop::MultilineLiteralBraceLayout
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-
-  private
-
-  def check(node); end
-  def check_brace_layout(node); end
-  def check_new_line(node); end
-  def check_same_line(node); end
-  def check_symmetrical(node); end
-  def children(node); end
-  def closing_brace_on_same_line?(node); end
-  def empty_literal?(node); end
-  def ignored_literal?(node); end
-  def implicit_literal?(node); end
-  def last_line_heredoc?(node, parent = T.unsafe(nil)); end
-  def new_line_needed_before_closing_brace?(node); end
-  def opening_brace_on_same_line?(node); end
-end
-
-module RuboCop::Cop::Naming; end
-
-class RuboCop::Cop::Naming::AccessorMethodName < ::RuboCop::Cop::Base
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def bad_reader_name?(node); end
-  def bad_writer_name?(node); end
-  def message(node); end
-end
-
-RuboCop::Cop::Naming::AccessorMethodName::MSG_READER = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Naming::AccessorMethodName::MSG_WRITER = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Naming::AsciiIdentifiers < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_new_investigation; end
-
-  private
-
-  def first_non_ascii_chars(string); end
-  def first_offense_range(identifier); end
-  def should_check?(token); end
-end
-
-RuboCop::Cop::Naming::AsciiIdentifiers::CONSTANT_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Naming::AsciiIdentifiers::IDENTIFIER_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Naming::BinaryOperatorParameterName < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def op_method_candidate?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def op_method?(name); end
-end
-
-RuboCop::Cop::Naming::BinaryOperatorParameterName::EXCLUDED = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Naming::BinaryOperatorParameterName::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Naming::BinaryOperatorParameterName::OP_LIKE_METHODS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Naming::BlockForwarding < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def anonymous_block_argument?(node); end
-  def block_forwarding_name; end
-  def expected_block_forwarding_style?(node, last_argument); end
-  def explicit_block_argument?(node); end
-  def register_offense(block_argument, node); end
-  def use_block_argument_as_local_variable?(node, last_argument); end
-  def use_kwarg_in_method_definition?(node); end
-end
-
-RuboCop::Cop::Naming::BlockForwarding::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Naming::BlockParameterName < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::UncommunicativeName
-
-  def on_block(node); end
-end
-
-class RuboCop::Cop::Naming::ClassAndModuleCamelCase < ::RuboCop::Cop::Base
-  def on_class(node); end
-  def on_module(node); end
-end
-
-RuboCop::Cop::Naming::ClassAndModuleCamelCase::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Naming::ConstantName < ::RuboCop::Cop::Base
-  def class_or_struct_return_method?(param0 = T.unsafe(nil)); end
-  def literal_receiver?(param0 = T.unsafe(nil)); end
-  def on_casgn(node); end
-
-  private
-
-  def allowed_assignment?(value); end
-  def allowed_conditional_expression_on_rhs?(node); end
-  def allowed_method_call_on_rhs?(node); end
-  def contains_contant?(node); end
-end
-
-RuboCop::Cop::Naming::ConstantName::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Naming::ConstantName::SNAKE_CASE = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::Naming::FileName < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_new_investigation; end
-  def struct_definition(param0 = T.unsafe(nil)); end
-
-  private
-
-  def allowed_acronyms; end
-  def bad_filename_allowed?; end
-  def check_definition_path_hierarchy?; end
-  def defined_struct(node); end
-  def definition_path_hierarchy_roots; end
-  def expect_matching_definition?; end
-  def filename_good?(basename); end
-  def find_class_or_module(node, namespace); end
-  def find_definition(node); end
-  def for_bad_filename(file_path); end
-  def ignore_executable_scripts?; end
-  def match?(expected); end
-  def match_acronym?(expected, name); end
-  def match_namespace(node, namespace, expected); end
-  def matching_class?(file_name); end
-  def matching_definition?(file_path); end
-  def no_definition_message(basename, file_path); end
-  def other_message(basename); end
-  def partial_matcher!(expected); end
-  def perform_class_and_module_naming_checks(file_path, basename); end
-  def regex; end
-  def to_module_name(basename); end
-  def to_namespace(path); end
-end
-
-RuboCop::Cop::Naming::FileName::MSG_NO_DEFINITION = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Naming::FileName::MSG_REGEX = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Naming::FileName::MSG_SNAKE_CASE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Naming::FileName::SNAKE_CASE = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::Naming::HeredocDelimiterCase < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Heredoc
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_heredoc(node); end
-
-  private
-
-  def correct_case_delimiters?(node); end
-  def correct_delimiters(source); end
-  def message(_node); end
-end
-
-RuboCop::Cop::Naming::HeredocDelimiterCase::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Naming::HeredocDelimiterNaming < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Heredoc
-
-  def on_heredoc(node); end
-
-  private
-
-  def forbidden_delimiters; end
-  def meaningful_delimiters?(node); end
-end
-
-RuboCop::Cop::Naming::HeredocDelimiterNaming::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Naming::InclusiveLanguage < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def on_new_investigation; end
-
-  private
-
-  def add_offenses_for_token(token, word_locations); end
-  def add_to_flagged_term_hash(regex_string, term, term_definition); end
-  def array_to_ignorecase_regex(strings); end
-  def check_token?(type); end
-  def create_message(word, message = T.unsafe(nil)); end
-  def create_multiple_word_message_for_file(words); end
-  def create_single_word_message_for_file(word); end
-  def ensure_regex_string(regex); end
-  def extract_regexp(term, term_definition); end
-  def find_flagged_term(word); end
-  def format_suggestions(suggestions); end
-  def investigate_filepath; end
-  def investigate_tokens; end
-  def mask_input(str); end
-  def preprocess_check_config; end
-  def preprocess_flagged_terms; end
-  def preprocess_suggestions(suggestions); end
-  def process_allowed_regex(allowed); end
-  def scan_for_words(input); end
-  def set_regexes(flagged_term_strings, allowed_strings); end
-end
-
-RuboCop::Cop::Naming::InclusiveLanguage::EMPTY_ARRAY = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Naming::InclusiveLanguage::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Naming::InclusiveLanguage::MSG_FOR_FILE_PATH = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Naming::InclusiveLanguage::WordLocation < ::Struct
-  def position; end
-  def position=(_); end
-  def word; end
-  def word=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RuboCop::Cop::Naming::MemoizedInstanceVariableName < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-
-  def defined_memoized?(param0 = T.unsafe(nil), param1); end
-  def method_definition?(param0 = T.unsafe(nil)); end
-  def on_defined?(node); end
-  def on_or_asgn(node); end
-
-  private
-
-  def find_definition(node); end
-  def matches?(method_name, ivar_assign); end
-  def message(variable); end
-  def style_parameter_name; end
-  def suggested_var(method_name); end
-  def variable_name_candidates(method_name); end
-end
-
-RuboCop::Cop::Naming::MemoizedInstanceVariableName::DYNAMIC_DEFINE_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Naming::MemoizedInstanceVariableName::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Naming::MemoizedInstanceVariableName::UNDERSCORE_REQUIRED = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Naming::MethodName < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::ConfigurableFormatting
-  include ::RuboCop::Cop::ConfigurableNaming
-  include ::RuboCop::Cop::AllowedPattern
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_def(node); end
-  def on_defs(node); end
-  def on_send(node); end
-  def str_name(param0 = T.unsafe(nil)); end
-  def sym_name(param0 = T.unsafe(nil)); end
-
-  private
-
-  def attr_name(name_item); end
-  def message(style); end
-  def range_position(node); end
-end
-
-RuboCop::Cop::Naming::MethodName::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Naming::MethodParameterName < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::UncommunicativeName
-
-  def on_def(node); end
-  def on_defs(node); end
-end
-
-class RuboCop::Cop::Naming::PredicateName < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::AllowedMethods
-
-  def dynamic_method_define(param0 = T.unsafe(nil)); end
-  def on_def(node); end
-  def on_defs(node); end
-  def on_send(node); end
-
-  private
-
-  def allowed_method_name?(method_name, prefix); end
-  def expected_name(method_name, prefix); end
-  def forbidden_prefixes; end
-  def message(method_name, new_name); end
-  def method_definition_macros(macro_name); end
-  def predicate_prefixes; end
-end
-
-class RuboCop::Cop::Naming::RescuedExceptionsVariableName < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_resbody(node); end
-
-  private
-
-  def correct_node(corrector, node, offending_name, preferred_name); end
-  def correct_reassignment(corrector, node, offending_name, preferred_name); end
-  def message(node); end
-  def offense_range(resbody); end
-  def preferred_name(variable_name); end
-  def shadowed_variable_name?(node); end
-  def variable_name(node); end
-  def variable_name_matches?(node, name); end
-end
-
-RuboCop::Cop::Naming::RescuedExceptionsVariableName::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Naming::VariableName < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::AllowedIdentifiers
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::ConfigurableFormatting
-  include ::RuboCop::Cop::ConfigurableNaming
-  include ::RuboCop::Cop::AllowedPattern
-
-  def on_arg(node); end
-  def on_blockarg(node); end
-  def on_cvasgn(node); end
-  def on_ivasgn(node); end
-  def on_kwarg(node); end
-  def on_kwoptarg(node); end
-  def on_kwrestarg(node); end
-  def on_lvar(node); end
-  def on_lvasgn(node); end
-  def on_optarg(node); end
-  def on_restarg(node); end
-  def valid_name?(node, name, given_style = T.unsafe(nil)); end
-
-  private
-
-  def message(style); end
-end
-
-RuboCop::Cop::Naming::VariableName::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Naming::VariableNumber < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::AllowedIdentifiers
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::ConfigurableFormatting
-  include ::RuboCop::Cop::ConfigurableNumbering
-  include ::RuboCop::Cop::AllowedPattern
-
-  def on_arg(node); end
-  def on_cvasgn(node); end
-  def on_def(node); end
-  def on_defs(node); end
-  def on_gvasgn(node); end
-  def on_ivasgn(node); end
-  def on_lvasgn(node); end
-  def on_sym(node); end
-  def valid_name?(node, name, given_style = T.unsafe(nil)); end
-
-  private
-
-  def message(style); end
-end
-
-RuboCop::Cop::Naming::VariableNumber::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::NegativeConditional
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def empty_condition?(param0 = T.unsafe(nil)); end
-  def single_negative?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def check_negative_conditional(node, message:, &block); end
-end
-
-RuboCop::Cop::NegativeConditional::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::NilMethods
-  include ::RuboCop::Cop::AllowedMethods
-
-  private
-
-  def nil_methods; end
-  def other_stdlib_methods; end
-end
-
-class RuboCop::Cop::Offense
-  include ::Comparable
-
-  def initialize(severity, location, message, cop_name, status = T.unsafe(nil), corrector = T.unsafe(nil)); end
-
-  def <=>(other); end
-  def ==(other); end
-  def column; end
-  def column_length; end
-  def column_range; end
-  def cop_name; end
-  def correctable?; end
-  def corrected?; end
-  def corrected_with_todo?; end
-  def corrector; end
-  def disabled?; end
-  def eql?(other); end
-  def first_line; end
-  def hash; end
-  def highlighted_area; end
-  def last_column; end
-  def last_line; end
-  def line; end
-  def location; end
-  def message; end
-  def real_column; end
-  def severity; end
-  def source_line; end
-  def status; end
-  def to_s; end
-end
-
-RuboCop::Cop::Offense::COMPARISON_ATTRIBUTES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Offense::NO_LOCATION = T.let(T.unsafe(nil), RuboCop::Cop::Offense::PseudoSourceRange)
-
-class RuboCop::Cop::Offense::PseudoSourceRange < ::Struct
-  def begin_pos; end
-  def begin_pos=(_); end
-  def column; end
-  def column=(_); end
-  def column_range; end
-  def end_pos; end
-  def end_pos=(_); end
-  def first_line; end
-  def last_column; end
-  def last_line; end
-  def length; end
-  def line; end
-  def line=(_); end
-  def size; end
-  def source_line; end
-  def source_line=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-module RuboCop::Cop::OnNormalIfUnless
-  def on_if(node); end
-end
-
-class RuboCop::Cop::OrderedGemCorrector
-  extend ::RuboCop::Cop::OrderedGemNode
-  extend ::RuboCop::Cop::RangeHelp
-
-  class << self
-    def comments_as_separators; end
-    def correct(processed_source, node, previous_declaration, comments_as_separators); end
-    def processed_source; end
-
-    private
-
-    def declaration_with_comment(node); end
-    def swap_range(corrector, range1, range2); end
-  end
-end
-
-module RuboCop::Cop::OrderedGemNode
-  private
-
-  def case_insensitive_out_of_order?(string_a, string_b); end
-  def consecutive_lines(previous, current); end
-  def find_gem_name(gem_node); end
-  def gem_canonical_name(name); end
-  def gem_name(declaration_node); end
-  def get_source_range(node, comments_as_separators); end
-  def register_offense(previous, current); end
-  def treat_comments_as_separators; end
-end
-
-module RuboCop::Cop::Parentheses
-  private
-
-  def parens_required?(node); end
-end
-
-class RuboCop::Cop::ParenthesesCorrector
-  class << self
-    def correct(corrector, node); end
-
-    private
-
-    def next_char_is_question_mark?(node); end
-    def ternary_condition?(node); end
-  end
-end
-
-module RuboCop::Cop::PercentArray
-  private
-
-  def allowed_bracket_array?(node); end
-  def build_bracketed_array_with_appropriate_whitespace(elements:, node:); end
-  def build_message_for_bracketed_array(preferred_array_code); end
-  def check_bracketed_array(node, literal_prefix); end
-  def check_percent_array(node); end
-  def comments_in_array?(node); end
-  def invalid_percent_array_contents?(_node); end
-  def invalid_percent_array_context?(node); end
-  def whitespace_between(node); end
-  def whitespace_leading(node); end
-  def whitespace_trailing(node); end
-end
-
-module RuboCop::Cop::PercentLiteral
-  include ::RuboCop::Cop::RangeHelp
-
-  private
-
-  def begin_source(node); end
-  def percent_literal?(node); end
-  def process(node, *types); end
-  def type(node); end
-end
-
-class RuboCop::Cop::PercentLiteralCorrector
-  include ::RuboCop::PathUtil
-  include ::RuboCop::Cop::Util
-
-  def initialize(config, preferred_delimiters); end
-
-  def config; end
-  def correct(corrector, node, char); end
-  def preferred_delimiters; end
-
-  private
-
-  def autocorrect_multiline_words(node, escape, delimiters); end
-  def autocorrect_words(node, escape, delimiters); end
-  def delimiters_for(type); end
-  def end_content(source); end
-  def escape_words?(node); end
-  def first_line?(node, previous_line_num); end
-  def fix_escaped_content(word_node, escape, delimiters); end
-  def line_breaks(node, source, previous_line_num, base_line_num, node_indx); end
-  def new_contents(node, escape, delimiters); end
-  def process_lines(node, previous_line_num, base_line_num, source_in_lines); end
-  def process_multiline_words(node, escape, delimiters); end
-  def substitute_escaped_delimiters(content, delimiters); end
-  def wrap_contents(corrector, node, contents, char, delimiters); end
-end
-
-module RuboCop::Cop::PrecedingFollowingAlignment
-  private
-
-  def aligned_assignment?(range, line); end
-  def aligned_char?(range, line); end
-  def aligned_comment_lines; end
-  def aligned_identical?(range, line); end
-  def aligned_operator?(range, line); end
-  def aligned_token?(range, line); end
-  def aligned_with_adjacent_line?(range, predicate); end
-  def aligned_with_any_line?(line_ranges, range, indent = T.unsafe(nil), &predicate); end
-  def aligned_with_any_line_range?(line_ranges, range, &predicate); end
-  def aligned_with_append_operator?(range, line); end
-  def aligned_with_assignment(token, line_range); end
-  def aligned_with_line?(line_nos, range, indent = T.unsafe(nil)); end
-  def aligned_with_operator?(range); end
-  def aligned_with_preceding_assignment(token); end
-  def aligned_with_something?(range); end
-  def aligned_with_subsequent_assignment(token); end
-  def aligned_words?(range, line); end
-  def allow_for_alignment?; end
-  def assignment_lines; end
-  def assignment_tokens; end
-  def relevant_assignment_lines(line_range); end
-  def remove_optarg_equals(asgn_tokens, processed_source); end
-end
-
-class RuboCop::Cop::PreferredDelimiters
-  def initialize(type, config, preferred_delimiters); end
-
-  def config; end
-  def delimiters; end
-  def type; end
-
-  private
-
-  def ensure_valid_preferred_delimiters; end
-  def preferred_delimiters; end
-  def preferred_delimiters_config; end
-end
-
-RuboCop::Cop::PreferredDelimiters::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::PunctuationCorrector
-  class << self
-    def add_space(corrector, token); end
-    def remove_space(corrector, space_before); end
-    def swap_comma(corrector, range); end
-  end
-end
-
-module RuboCop::Cop::RangeHelp
-  private
-
-  def column_offset_between(base_range, range); end
-  def contents_range(node); end
-  def directions(side); end
-  def effective_column(range); end
-  def final_pos(src, pos, increment, continuations, newlines, whitespace); end
-  def move_pos(src, pos, step, condition, regexp); end
-  def move_pos_str(src, pos, step, condition, needle); end
-  def range_between(start_pos, end_pos); end
-  def range_by_whole_lines(range, include_final_newline: T.unsafe(nil)); end
-  def range_with_surrounding_comma(range, side = T.unsafe(nil)); end
-  def range_with_surrounding_space(range_positional = T.unsafe(nil), range: T.unsafe(nil), side: T.unsafe(nil), newlines: T.unsafe(nil), whitespace: T.unsafe(nil), continuations: T.unsafe(nil)); end
-  def source_range(source_buffer, line_number, column, length = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::RangeHelp::BYTE_ORDER_MARK = T.let(T.unsafe(nil), Integer)
-module RuboCop::Cop::RangeHelp::NOT_GIVEN; end
-
-module RuboCop::Cop::RationalLiteral
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def rational_literal?(param0 = T.unsafe(nil)); end
-end
-
-class RuboCop::Cop::Registry
-  include ::Enumerable
-
-  def initialize(cops = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def ==(other); end
-  def contains_cop_matching?(names); end
-  def cops; end
-  def department?(name); end
-  def department_missing?(badge, name); end
-  def departments; end
-  def dismiss(cop); end
-  def each(&block); end
-  def enabled(config, only = T.unsafe(nil), only_safe: T.unsafe(nil)); end
-  def enabled?(cop, config, only_safe); end
-  def enabled_pending_cop?(cop_cfg, config); end
-  def enlist(cop); end
-  def find_by_cop_name(cop_name); end
-  def freeze; end
-  def length; end
-  def names; end
-  def names_for_department(department); end
-  def options; end
-  def print_warning(name, path); end
-  def qualified_cop_name(name, path, warn: T.unsafe(nil)); end
-  def select(&block); end
-  def sort!; end
-  def to_h; end
-  def unqualified_cop_names; end
-  def with_department(department); end
-  def without_department(department); end
-
-  private
-
-  def clear_enrollment_queue; end
-  def initialize_copy(reg); end
-  def qualify_badge(badge); end
-  def registered?(badge); end
-  def resolve_badge(given_badge, real_badge, source_path); end
-  def with(cops); end
-
-  class << self
-    def all; end
-    def global; end
-    def qualified_cop_name(name, origin); end
-    def reset!; end
-    def with_temporary_global(temp_global = T.unsafe(nil)); end
-  end
-end
-
-module RuboCop::Cop::RequireLibrary
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def ensure_required(corrector, node, library_name); end
-  def on_send(node); end
-  def remove_subsequent_requires(corrector, node, library_name); end
-  def require_any_library?(param0 = T.unsafe(nil)); end
-  def require_library_name?(param0 = T.unsafe(nil), param1); end
-
-  private
-
-  def on_new_investigation; end
-end
-
-class RuboCop::Cop::RequireLibraryCorrector
-  extend ::RuboCop::Cop::RangeHelp
-
-  class << self
-    def correct(corrector, node, library_name); end
-    def require_statement(library_name); end
-  end
-end
-
-module RuboCop::Cop::RescueNode
-  def on_new_investigation; end
-
-  private
-
-  def rescue_modifier?(node); end
-  def rescued_exceptions(resbody); end
-end
-
-module RuboCop::Cop::SafeAssignment
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def empty_condition?(param0 = T.unsafe(nil)); end
-  def safe_assignment?(param0 = T.unsafe(nil)); end
-  def setter_method?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def safe_assignment_allowed?; end
-end
-
-module RuboCop::Cop::Security; end
-
-class RuboCop::Cop::Security::CompoundHash < ::RuboCop::Cop::Base
-  def bad_hash_combinator?(param0 = T.unsafe(nil)); end
-  def contained_in_hash_method?(node, &block); end
-  def dynamic_hash_method_definition?(param0 = T.unsafe(nil)); end
-  def hash_method_definition?(param0 = T.unsafe(nil)); end
-  def monuple_hash?(param0 = T.unsafe(nil)); end
-  def on_op_asgn(node); end
-  def on_send(node); end
-  def outer_bad_hash_combinator?(node); end
-  def redundant_hash?(param0 = T.unsafe(nil)); end
-  def static_hash_method_definition?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Security::CompoundHash::COMBINATOR_IN_HASH_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Security::CompoundHash::MONUPLE_HASH_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Security::CompoundHash::REDUNDANT_HASH_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Security::Eval < ::RuboCop::Cop::Base
-  def eval?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Security::Eval::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Security::Eval::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Security::IoMethods < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-end
-
-RuboCop::Cop::Security::IoMethods::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Security::IoMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Security::JSONLoad < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def json_load(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Security::JSONLoad::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Security::JSONLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Security::MarshalLoad < ::RuboCop::Cop::Base
-  def marshal_load(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Security::MarshalLoad::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Security::MarshalLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Security::Open < ::RuboCop::Cop::Base
-  def on_send(node); end
-  def open?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def composite_string?(node); end
-  def concatenated_string?(node); end
-  def interpolated_string?(node); end
-  def safe?(node); end
-  def safe_argument?(argument); end
-  def simple_string?(node); end
-end
-
-RuboCop::Cop::Security::Open::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Security::Open::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Security::YAMLLoad < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def yaml_load(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Security::YAMLLoad::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Security::YAMLLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Severity
-  include ::Comparable
-
-  def initialize(name_or_code); end
-
-  def <=>(other); end
-  def ==(other); end
-  def code; end
-  def hash; end
-  def level; end
-  def name; end
-  def to_s; end
-
-  class << self
-    def name_from_code(code); end
-  end
-end
-
-RuboCop::Cop::Severity::CODE_TABLE = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Severity::NAMES = T.let(T.unsafe(nil), Array)
-
-module RuboCop::Cop::SpaceAfterPunctuation
-  def on_new_investigation; end
-
-  private
-
-  def allowed_type?(token); end
-  def each_missing_space(tokens); end
-  def offset; end
-  def space_forbidden_before_rcurly?; end
-  def space_missing?(token1, token2); end
-  def space_required_before?(token); end
-end
-
-RuboCop::Cop::SpaceAfterPunctuation::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::SpaceBeforePunctuation
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_new_investigation; end
-
-  private
-
-  def each_missing_space(tokens); end
-  def space_missing?(token1, token2); end
-  def space_required_after?(token); end
-  def space_required_after_lcurly?; end
-end
-
-RuboCop::Cop::SpaceBeforePunctuation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::SpaceCorrector
-  extend ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::SurroundingSpace
-
-  class << self
-    def add_space(processed_source, corrector, left_token, right_token); end
-    def empty_corrections(processed_source, corrector, empty_config, left_token, right_token); end
-    def processed_source; end
-    def remove_space(processed_source, corrector, left_token, right_token); end
-  end
-end
-
-module RuboCop::Cop::StatementModifier
-  include ::RuboCop::Cop::LineLengthHelp
-
-  private
-
-  def code_after(node); end
-  def comment_disables_cop?(comment); end
-  def first_line_comment(node); end
-  def length_in_modifier_form(node); end
-  def max_line_length; end
-  def modifier_fits_on_single_line?(node); end
-  def non_eligible_body?(body); end
-  def non_eligible_condition?(condition); end
-  def non_eligible_node?(node); end
-  def parenthesize?(node); end
-  def single_line_as_modifier?(node); end
-  def to_modifier_form(node); end
-end
-
-module RuboCop::Cop::StringHelp
-  def on_regexp(node); end
-  def on_str(node); end
-
-  private
-
-  def inside_interpolation?(node); end
-end
-
-class RuboCop::Cop::StringLiteralCorrector
-  extend ::RuboCop::PathUtil
-  extend ::RuboCop::Cop::Util
-
-  class << self
-    def correct(corrector, node, style); end
-  end
-end
-
-module RuboCop::Cop::StringLiteralsHelp
-  private
-
-  def wrong_quotes?(src_or_node); end
-end
-
-module RuboCop::Cop::Style; end
-
-class RuboCop::Cop::Style::AccessModifierDeclarations < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-
-  def access_modifier_with_symbol?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def access_modifier_is_inlined?(node); end
-  def access_modifier_is_not_inlined?(node); end
-  def allow_modifiers_on_symbols?(node); end
-  def group_style?; end
-  def inline_style?; end
-  def message(range); end
-  def offense?(node); end
-end
-
-RuboCop::Cop::Style::AccessModifierDeclarations::GROUP_STYLE_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::AccessModifierDeclarations::INLINE_STYLE_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::AccessModifierDeclarations::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::AccessorGrouping < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::VisibilityHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_class(node); end
-  def on_module(node); end
-  def on_sclass(node); end
-
-  private
-
-  def accessor?(send_node); end
-  def autocorrect(corrector, node); end
-  def check(send_node); end
-  def class_send_elements(class_node); end
-  def group_accessors(node, accessors); end
-  def grouped_style?; end
-  def message(send_node); end
-  def preferred_accessors(node); end
-  def previous_line_comment?(node); end
-  def separate_accessors(node); end
-  def separated_style?; end
-  def sibling_accessors(send_node); end
-end
-
-RuboCop::Cop::Style::AccessorGrouping::ACCESSOR_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::AccessorGrouping::GROUPED_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::AccessorGrouping::SEPARATED_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::Alias < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def identifier(param0 = T.unsafe(nil)); end
-  def on_alias(node); end
-  def on_send(node); end
-
-  private
-
-  def add_offense_for_args(node, &block); end
-  def alias_keyword_possible?(node); end
-  def alias_method_possible?(node); end
-  def autocorrect(corrector, node); end
-  def bareword?(sym_node); end
-  def correct_alias_method_to_alias(corrector, send_node); end
-  def correct_alias_to_alias_method(corrector, node); end
-  def correct_alias_with_symbol_args(corrector, node); end
-  def lexical_scope_type(node); end
-  def scope_type(node); end
-end
-
-RuboCop::Cop::Style::Alias::MSG_ALIAS = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::Alias::MSG_ALIAS_METHOD = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::Alias::MSG_SYMBOL_ARGS = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::Alias::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::AndOr < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_and(node); end
-  def on_if(node); end
-  def on_or(node); end
-  def on_until(node); end
-  def on_until_post(node); end
-  def on_while(node); end
-  def on_while_post(node); end
-
-  private
-
-  def correct_not(node, receiver, corrector); end
-  def correct_other(node, corrector); end
-  def correct_send(node, corrector); end
-  def correct_setter(node, corrector); end
-  def correctable_send?(node); end
-  def keep_operator_precedence(corrector, node); end
-  def message(node); end
-  def on_conditionals(node); end
-  def process_logical_operator(node); end
-  def whitespace_before_arg(node); end
-end
-
-RuboCop::Cop::Style::AndOr::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::ArgumentsForwarding < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def forwarding_method_arguments?(param0 = T.unsafe(nil), param1, param2, param3); end
-  def on_def(node); end
-  def on_defs(node); end
-  def only_rest_arguments?(param0 = T.unsafe(nil), param1); end
-  def use_rest_arguments?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def all_lvars_as_forwarding_method_arguments?(def_node, forwarding_method); end
-  def allow_only_rest_arguments?; end
-  def arguments_range(node); end
-  def extract_argument_names_from(args); end
-  def forwarding_method?(node, rest_arg, kwargs, block_arg); end
-  def register_offense_to_forwarding_method_arguments(forwarding_method); end
-  def register_offense_to_method_definition_arguments(method_definition); end
-end
-
-RuboCop::Cop::Style::ArgumentsForwarding::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::ArrayCoercion < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def array_splat?(param0 = T.unsafe(nil)); end
-  def on_array(node); end
-  def on_if(node); end
-  def unless_array?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Style::ArrayCoercion::CHECK_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ArrayCoercion::SPLAT_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::ArrayJoin < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def join_candidate?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Style::ArrayJoin::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ArrayJoin::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::AsciiComments < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_new_investigation; end
-
-  private
-
-  def allowed_non_ascii_chars; end
-  def first_non_ascii_chars(string); end
-  def first_offense_range(comment); end
-  def only_allowed_non_ascii_chars?(string); end
-end
-
-RuboCop::Cop::Style::AsciiComments::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::Attr < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def class_eval?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def message(node); end
-  def replacement_method(node); end
-end
-
-RuboCop::Cop::Style::Attr::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::Attr::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::AutoResourceCleanup < ::RuboCop::Cop::Base
-  def on_send(node); end
-
-  private
-
-  def cleanup?(node); end
-end
-
-RuboCop::Cop::Style::AutoResourceCleanup::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::AutoResourceCleanup::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::AutoResourceCleanup::TARGET_METHODS = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Cop::Style::BarePercentLiterals < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_dstr(node); end
-  def on_str(node); end
-
-  private
-
-  def add_offense_for_wrong_style(node, good, bad); end
-  def check(node); end
-  def requires_bare_percent?(source); end
-  def requires_percent_q?(source); end
-end
-
-RuboCop::Cop::Style::BarePercentLiterals::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::BeginBlock < ::RuboCop::Cop::Base
-  def on_preexe(node); end
-end
-
-RuboCop::Cop::Style::BeginBlock::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::BisectedAttrAccessor < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def after_class(class_node); end
-  def after_module(class_node); end
-  def after_sclass(class_node); end
-  def on_class(class_node); end
-  def on_module(class_node); end
-  def on_new_investigation; end
-  def on_sclass(class_node); end
-
-  private
-
-  def correct_reader(corrector, macro, node, range); end
-  def correct_writer(corrector, macro, node, range); end
-  def find_bisection(macros); end
-  def find_macros(class_def); end
-  def register_offense(attr); end
-end
-
-RuboCop::Cop::Style::BisectedAttrAccessor::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::BisectedAttrAccessor::Macro
-  include ::RuboCop::Cop::VisibilityHelp
-
-  def initialize(node); end
-
-  def all_bisected?; end
-  def attr_names; end
-  def attrs; end
-  def bisect(*names); end
-  def bisected_names; end
-  def bisection; end
-  def node; end
-  def reader?; end
-  def rest; end
-  def visibility; end
-  def writer?; end
-
-  class << self
-    def macro?(node); end
-  end
-end
-
-class RuboCop::Cop::Style::BlockComments < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def eq_end_part(comment, expr); end
-  def parts(comment); end
-end
-
-RuboCop::Cop::Style::BlockComments::BEGIN_LENGTH = T.let(T.unsafe(nil), Integer)
-RuboCop::Cop::Style::BlockComments::END_LENGTH = T.let(T.unsafe(nil), Integer)
-RuboCop::Cop::Style::BlockComments::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::BlockDelimiters < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::IgnoredMethods
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::IgnoredMethods::Config
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def on_numblock(node); end
-  def on_send(node); end
-
-  private
-
-  def array_or_range?(node); end
-  def autocorrect(corrector, node); end
-  def begin_required?(block_node); end
-  def braces_for_chaining_message(node); end
-  def braces_for_chaining_style?(node); end
-  def braces_required_message(node); end
-  def braces_required_method?(method_name); end
-  def braces_required_methods; end
-  def braces_style?(node); end
-  def conditional?(node); end
-  def correction_would_break_code?(node); end
-  def end_of_chain(node); end
-  def functional_block?(node); end
-  def functional_method?(method_name); end
-  def get_blocks(node, &block); end
-  def line_count_based_block_style?(node); end
-  def line_count_based_message(node); end
-  def message(node); end
-  def move_comment_before_block(corrector, comment, block_node, closing_brace); end
-  def procedural_method?(method_name); end
-  def procedural_oneliners_may_have_braces?; end
-  def proper_block_style?(node); end
-  def replace_braces_with_do_end(corrector, loc); end
-  def replace_do_end_with_braces(corrector, node); end
-  def return_value_of_scope?(node); end
-  def return_value_used?(node); end
-  def semantic_block_style?(node); end
-  def semantic_message(node); end
-  def special_method?(method_name); end
-  def special_method_proper_block_style?(node); end
-  def whitespace_after?(range, length = T.unsafe(nil)); end
-  def whitespace_before?(range); end
-  def with_block?(node); end
-end
-
-RuboCop::Cop::Style::BlockDelimiters::ALWAYS_BRACES_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::BlockDelimiters::BRACES_REQUIRED_MESSAGE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::CaseCorrector
-  extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper
-  extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper
-
-  class << self
-    def correct(corrector, cop, node); end
-    def move_assignment_inside_condition(corrector, node); end
-
-    private
-
-    def extract_branches(case_node); end
-    def extract_tail_branches(node); end
-    def move_branch_inside_condition(corrector, branch, condition, assignment, column); end
-  end
-end
-
-class RuboCop::Cop::Style::CaseEquality < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def case_equality?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def const?(node); end
-  def replacement(lhs, rhs); end
-end
-
-RuboCop::Cop::Style::CaseEquality::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::CaseEquality::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::CaseLikeIf < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def branch_conditions(node); end
-  def class_reference?(node); end
-  def collect_conditions(node, target, conditions); end
-  def condition_from_binary_op(lhs, rhs, target); end
-  def condition_from_equality_node(node, target); end
-  def condition_from_include_or_cover_node(node, target); end
-  def condition_from_match_node(node, target); end
-  def condition_from_send_node(node, target); end
-  def const_reference?(node); end
-  def correction_range(node); end
-  def deparenthesize(node); end
-  def find_target(node); end
-  def find_target_in_equality_node(node); end
-  def find_target_in_include_or_cover_node(node); end
-  def find_target_in_match_node(node); end
-  def find_target_in_send_node(node); end
-  def regexp_with_named_captures?(node); end
-  def regexp_with_working_captures?(node); end
-  def should_check?(node); end
-end
-
-RuboCop::Cop::Style::CaseLikeIf::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::CharacterLiteral < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::StringHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def autocorrect(corrector, node); end
-  def correct_style_detected; end
-  def offense?(node); end
-  def opposite_style_detected; end
-end
-
-RuboCop::Cop::Style::CharacterLiteral::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::ClassAndModuleChildren < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_class(node); end
-  def on_module(node); end
-
-  private
-
-  def add_trailing_end(corrector, node, padding); end
-  def autocorrect(corrector, node); end
-  def check_compact_style(node, body); end
-  def check_nested_style(node); end
-  def check_style(node, body); end
-  def compact_definition(corrector, node); end
-  def compact_identifier_name(node); end
-  def compact_node(corrector, node); end
-  def compact_node_name?(node); end
-  def compact_replacement(node); end
-  def configured_indentation_width; end
-  def indent_width; end
-  def leading_spaces(node); end
-  def needs_compacting?(body); end
-  def nest_definition(corrector, node); end
-  def nest_or_compact(corrector, node); end
-  def remove_end(corrector, body); end
-  def replace_namespace_keyword(corrector, node); end
-  def split_on_double_colon(corrector, node, padding); end
-  def unindent(corrector, node); end
-end
-
-RuboCop::Cop::Style::ClassAndModuleChildren::COMPACT_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ClassAndModuleChildren::NESTED_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::ClassCheck < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def message(node); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Style::ClassCheck::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ClassCheck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::ClassEqualityComparison < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::IgnoredMethods
-  extend ::RuboCop::Cop::IgnoredMethods::Config
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def class_comparison_candidate?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def class_name(class_node, node); end
-  def offense_range(receiver_node, node); end
-end
-
-RuboCop::Cop::Style::ClassEqualityComparison::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ClassEqualityComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::ClassMethods < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_class(node); end
-  def on_module(node); end
-
-  private
-
-  def check_defs(name, node); end
-end
-
-RuboCop::Cop::Style::ClassMethods::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::ClassMethodsDefinitions < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::CommentsHelp
-  include ::RuboCop::Cop::VisibilityHelp
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_defs(node); end
-  def on_sclass(node); end
-
-  private
-
-  def all_methods_public?(sclass_node); end
-  def autocorrect_sclass(node, corrector); end
-  def def_nodes(sclass_node); end
-  def def_self_style?; end
-  def extract_def_from_sclass(def_node, sclass_node); end
-  def indentation_diff(node1, node2); end
-  def sclass_only_has_methods?(node); end
-end
-
-RuboCop::Cop::Style::ClassMethodsDefinitions::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ClassMethodsDefinitions::MSG_SCLASS = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::ClassVars < ::RuboCop::Cop::Base
-  def on_cvasgn(node); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Style::ClassVars::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ClassVars::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::CollectionCompact < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def reject_method?(param0 = T.unsafe(nil)); end
-  def reject_method_with_block_pass?(param0 = T.unsafe(nil)); end
-  def select_method?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def good_method_name(node); end
-  def offense_range(node); end
-  def range(begin_pos_node, end_pos_node); end
-end
-
-RuboCop::Cop::Style::CollectionCompact::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::CollectionCompact::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::CollectionMethods < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::MethodPreference
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def on_send(node); end
-
-  private
-
-  def check_method_node(node); end
-  def implicit_block?(node); end
-  def message(node); end
-  def methods_accepting_symbol; end
-end
-
-RuboCop::Cop::Style::CollectionMethods::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::ColonMethodCall < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def java_type_node?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Style::ColonMethodCall::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::ColonMethodDefinition < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_defs(node); end
-end
-
-RuboCop::Cop::Style::ColonMethodDefinition::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::CombinableLoops < ::RuboCop::Cop::Base
-  def on_block(node); end
-  def on_for(node); end
-
-  private
-
-  def collection_looping_method?(node); end
-  def same_collection_looping?(node, sibling); end
-end
-
-RuboCop::Cop::Style::CombinableLoops::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::CommandLiteral < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_xstr(node); end
-
-  private
-
-  def allow_inner_backticks?; end
-  def allowed_backtick_literal?(node); end
-  def allowed_percent_x_literal?(node); end
-  def autocorrect(corrector, node); end
-  def backtick_literal?(node); end
-  def check_backtick_literal(node, message); end
-  def check_percent_x_literal(node, message); end
-  def command_delimiter; end
-  def contains_backtick?(node); end
-  def contains_disallowed_backtick?(node); end
-  def default_delimiter; end
-  def node_body(node); end
-  def preferred_delimiter; end
-  def preferred_delimiters_config; end
-end
-
-RuboCop::Cop::Style::CommandLiteral::MSG_USE_BACKTICKS = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::CommandLiteral::MSG_USE_PERCENT_X = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::CommentAnnotation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def annotation_range(annotation); end
-  def correct_offense(corrector, range, keyword); end
-  def first_comment_line?(comments, index); end
-  def inline_comment?(comment); end
-  def keywords; end
-  def register_offense(annotation); end
-  def requires_colon?; end
-end
-
-RuboCop::Cop::Style::CommentAnnotation::MISSING_NOTE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::CommentAnnotation::MSG_COLON_STYLE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::CommentAnnotation::MSG_SPACE_STYLE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::CommentedKeyword < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def offensive?(comment); end
-  def register_offense(comment, matched_keyword); end
-  def source_line(comment); end
-end
-
-RuboCop::Cop::Style::CommentedKeyword::ALLOWED_COMMENTS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::CommentedKeyword::ALLOWED_COMMENT_REGEXES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::CommentedKeyword::KEYWORDS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::CommentedKeyword::KEYWORD_REGEXES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::CommentedKeyword::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::CommentedKeyword::REGEXP = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::Style::ConditionalAssignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Style::ConditionalAssignmentHelper
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def assignment_type?(param0 = T.unsafe(nil)); end
-  def candidate_condition?(param0 = T.unsafe(nil)); end
-  def on_and_asgn(node); end
-  def on_case(node); end
-  def on_case_match(node); end
-  def on_casgn(node); end
-  def on_cvasgn(node); end
-  def on_gvasgn(node); end
-  def on_if(node); end
-  def on_ivasgn(node); end
-  def on_lvasgn(node); end
-  def on_masgn(node); end
-  def on_op_asgn(node); end
-  def on_or_asgn(node); end
-  def on_send(node); end
-
-  private
-
-  def allowed_single_line?(branches); end
-  def allowed_statements?(branches); end
-  def allowed_ternary?(assignment); end
-  def assignment_node(node); end
-  def assignment_types_match?(*nodes); end
-  def autocorrect(corrector, node); end
-  def candidate_node?(node); end
-  def check_assignment_to_condition(node); end
-  def check_node(node, branches); end
-  def correction_exceeds_line_limit?(node, branches); end
-  def include_ternary?; end
-  def indentation_width; end
-  def lhs_all_match?(branches); end
-  def line_length_cop_enabled?; end
-  def longest_line(node, assignment); end
-  def longest_line_exceeds_line_limit?(node, assignment); end
-  def max_line_length; end
-  def move_assignment_inside_condition(corrector, node); end
-  def move_assignment_outside_condition(corrector, node); end
-  def single_line_conditions_only?; end
-  def ternary_condition?(node); end
-end
-
-RuboCop::Cop::Style::ConditionalAssignment::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::ConditionalAssignment::ASSIGN_TO_CONDITION_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ConditionalAssignment::ENABLED = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ConditionalAssignment::INDENTATION_WIDTH = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ConditionalAssignment::LINE_LENGTH = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ConditionalAssignment::MAX = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ConditionalAssignment::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ConditionalAssignment::SINGLE_LINE_CONDITIONS_ONLY = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::ConditionalAssignment::WIDTH = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::Style::ConditionalAssignmentHelper
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def end_with_eq?(sym); end
-  def expand_elses(branch); end
-  def expand_when_branches(when_branches); end
-  def indent(cop, source); end
-  def lhs(node); end
-  def tail(branch); end
-
-  private
-
-  def assignment_rhs_exist?(node); end
-  def expand_elsif(node, elsif_branches = T.unsafe(nil)); end
-  def lhs_for_casgn(node); end
-  def lhs_for_send(node); end
-  def setter_method?(method_name); end
-end
-
-RuboCop::Cop::Style::ConditionalAssignmentHelper::ALIGN_WITH = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ConditionalAssignmentHelper::END_ALIGNMENT = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ConditionalAssignmentHelper::EQUAL = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ConditionalAssignmentHelper::KEYWORD = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::Style::ConditionalCorrectorHelper
-  def assignment(node); end
-  def correct_branches(corrector, branches); end
-  def correct_if_branches(corrector, cop, node); end
-  def remove_whitespace_in_branches(corrector, branch, condition, column); end
-  def replace_branch_assignment(corrector, branch); end
-  def white_space_range(node, column); end
-end
-
-class RuboCop::Cop::Style::ConstantVisibility < ::RuboCop::Cop::Base
-  def on_casgn(node); end
-  def visibility_declaration_for?(param0 = T.unsafe(nil), param1); end
-
-  private
-
-  def class_or_module_scope?(node); end
-  def ignore_modules?; end
-  def match_name?(name, constant_name); end
-  def message(node); end
-  def module?(node); end
-  def visibility_declaration?(node); end
-end
-
-RuboCop::Cop::Style::ConstantVisibility::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::Copyright < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def autocorrect_notice; end
-  def encoding_token?(processed_source, token_index); end
-  def insert_notice_before(processed_source); end
-  def notice; end
-  def notice_found?(processed_source); end
-  def offense_range; end
-  def shebang_token?(processed_source, token_index); end
-  def verify_autocorrect_notice!; end
-end
-
-RuboCop::Cop::Style::Copyright::AUTOCORRECT_EMPTY_WARNING = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::Copyright::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::DateTime < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def date_time?(param0 = T.unsafe(nil)); end
-  def historic_date?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def to_datetime?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def disallow_coercion?; end
-end
-
-RuboCop::Cop::Style::DateTime::CLASS_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::DateTime::COERCION_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::DefWithParentheses < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-end
-
-RuboCop::Cop::Style::DefWithParentheses::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::Dir < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def dir_replacement?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def file_keyword?(node); end
-end
-
-RuboCop::Cop::Style::Dir::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::Dir::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def allowed_cops; end
-  def any_cops_allowed?; end
-  def directive_cops(comment); end
-  def register_offense(comment, directive_cops, disallowed_cops); end
-end
-
-RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::MSG_FOR_COPS = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::DocumentDynamicEvalDefinition < ::RuboCop::Cop::Base
-  def on_send(node); end
-
-  private
-
-  def comment_block_docs?(arg_node); end
-  def comment_regexp(arg_node); end
-  def heredoc_comment_blocks(heredoc_body); end
-  def inline_comment_docs?(node); end
-  def interpolated?(arg_node); end
-  def merge_adjacent_comments(line, index, hash); end
-  def preceding_comment_blocks(node); end
-  def source_to_regexp(source); end
-end
-
-RuboCop::Cop::Style::DocumentDynamicEvalDefinition::BLOCK_COMMENT_REGEXP = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Style::DocumentDynamicEvalDefinition::COMMENT_REGEXP = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Style::DocumentDynamicEvalDefinition::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::DocumentDynamicEvalDefinition::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::Documentation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::DocumentationComment
-  include ::RuboCop::Cop::RangeHelp
-
-  def constant_definition?(param0 = T.unsafe(nil)); end
-  def constant_visibility_declaration?(param0 = T.unsafe(nil)); end
-  def on_class(node); end
-  def on_module(node); end
-  def outer_module(param0); end
-
-  private
-
-  def allowed_constants; end
-  def check(node, body); end
-  def compact_namespace?(node); end
-  def constant_allowed?(node); end
-  def constant_declaration?(node); end
-  def identifier(node); end
-  def macro_only?(body); end
-  def namespace?(node); end
-  def nodoc(node); end
-  def nodoc?(comment, require_all: T.unsafe(nil)); end
-  def nodoc_comment?(node, require_all: T.unsafe(nil)); end
-  def nodoc_self_or_outer_module?(node); end
-  def qualify_const(node); end
-end
-
-RuboCop::Cop::Style::Documentation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::DocumentationMethod < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::DocumentationComment
-  include ::RuboCop::Cop::VisibilityHelp
-  include ::RuboCop::Cop::DefNode
-
-  def module_function_node?(param0 = T.unsafe(nil)); end
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def check(node); end
-  def require_for_non_public_methods?; end
-end
-
-RuboCop::Cop::Style::DocumentationMethod::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::DoubleCopDisableDirective < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-end
-
-RuboCop::Cop::Style::DoubleCopDisableDirective::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::DoubleNegation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def double_negative?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def allowed_in_returns?(node); end
-  def define_mehod?(node); end
-  def double_negative_condition_return_value?(node, last_child, conditional_node); end
-  def end_of_method_definition?(node); end
-  def find_conditional_node_from_ascendant(node); end
-  def find_def_node_from_ascendant(node); end
-  def find_last_child(node); end
-  def find_parent_not_enumerable(node); end
-end
-
-RuboCop::Cop::Style::DoubleNegation::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::DoubleNegation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::EachForSimpleLoop < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def offending_each_range(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-end
-
-RuboCop::Cop::Style::EachForSimpleLoop::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::EachWithObject < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def each_with_object_candidate?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-
-  private
-
-  def accumulator_param_assigned_to?(body, args); end
-  def autocorrect(corrector, node, return_value); end
-  def first_argument_returned?(args, return_value); end
-  def return_value(body); end
-  def return_value_occupies_whole_line?(node); end
-  def simple_method_arg?(method_arg); end
-  def whole_line_expression(node); end
-end
-
-RuboCop::Cop::Style::EachWithObject::METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::EachWithObject::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::EmptyBlockParameter < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::EmptyParameter
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-end
-
-RuboCop::Cop::Style::EmptyBlockParameter::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::EmptyCaseCondition < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_case(case_node); end
-
-  private
-
-  def autocorrect(corrector, case_node); end
-  def correct_case_when(corrector, case_node, when_nodes); end
-  def correct_when_conditions(corrector, when_nodes); end
-  def keep_first_when_comment(case_range, corrector); end
-  def replace_then_with_line_break(corrector, conditions, when_node); end
-end
-
-RuboCop::Cop::Style::EmptyCaseCondition::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::EmptyElse < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::OnNormalIfUnless
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_case(node); end
-  def on_normal_if_unless(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def autocorrect_forbidden?(type); end
-  def base_node(node); end
-  def check(node); end
-  def comment_in_else?(loc); end
-  def empty_check(node); end
-  def empty_style?; end
-  def missing_else_style; end
-  def nil_check(node); end
-  def nil_style?; end
-end
-
-RuboCop::Cop::Style::EmptyElse::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::EmptyHeredoc < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Heredoc
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_heredoc(node); end
-end
-
-RuboCop::Cop::Style::EmptyHeredoc::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::EmptyLambdaParameter < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::EmptyParameter
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-end
-
-RuboCop::Cop::Style::EmptyLambdaParameter::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::EmptyLiteral < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::FrozenStringLiteral
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def array_node(param0 = T.unsafe(nil)); end
-  def array_with_block(param0 = T.unsafe(nil)); end
-  def hash_node(param0 = T.unsafe(nil)); end
-  def hash_with_block(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def str_node(param0 = T.unsafe(nil)); end
-
-  private
-
-  def correction(node); end
-  def enforce_double_quotes?; end
-  def first_argument_unparenthesized?(node); end
-  def frozen_strings?; end
-  def offense_array_node?(node); end
-  def offense_hash_node?(node); end
-  def offense_message(node); end
-  def preferred_string_literal; end
-  def replacement_range(node); end
-  def string_literals_config; end
-end
-
-RuboCop::Cop::Style::EmptyLiteral::ARR_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::EmptyLiteral::HASH_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::EmptyLiteral::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::EmptyLiteral::STR_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::EmptyMethod < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def compact?(node); end
-  def compact_style?; end
-  def correct_style?(node); end
-  def corrected(node); end
-  def expanded?(node); end
-  def expanded_style?; end
-  def joint(node); end
-  def max_line_length; end
-  def message(_range); end
-end
-
-RuboCop::Cop::Style::EmptyMethod::MSG_COMPACT = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::EmptyMethod::MSG_EXPANDED = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::Encoding < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def comments; end
-  def offense?(comment); end
-  def register_offense(line_number, comment); end
-end
-
-RuboCop::Cop::Style::Encoding::ENCODING_PATTERN = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Style::Encoding::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::Encoding::SHEBANG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::EndBlock < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_postexe(node); end
-end
-
-RuboCop::Cop::Style::EndBlock::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::EndlessMethod < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::TargetRubyVersion
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-
-  private
-
-  def arguments(node, missing = T.unsafe(nil)); end
-  def correct_to_multiline(corrector, node); end
-  def handle_allow_style(node); end
-  def handle_disallow_style(node); end
-end
-
-RuboCop::Cop::Style::EndlessMethod::CORRECTION_STYLES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::EndlessMethod::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::EndlessMethod::MSG_MULTI_LINE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::EnvHome < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def env_home?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Style::EnvHome::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::EnvHome::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::EvalWithLocation < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def line_with_offset?(param0 = T.unsafe(nil), param1, param2); end
-  def on_send(node); end
-  def valid_eval_receiver?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def add_offense_for_different_line(node, line_node, line_diff); end
-  def add_offense_for_incorrect_line(method_name, line_node, sign, line_diff); end
-  def add_offense_for_missing_line(node, code); end
-  def add_offense_for_missing_location(node, code); end
-  def add_offense_for_same_line(node, line_node); end
-  def check_file(node, file_node); end
-  def check_line(node, code); end
-  def check_location(node, code); end
-  def expected_line(sign, line_diff); end
-  def file_and_line(node); end
-  def line_difference(line_node, code); end
-  def missing_line(node, code); end
-  def register_offense(node, &block); end
-  def special_file_keyword?(node); end
-  def special_line_keyword?(node); end
-  def string_first_line(str_node); end
-  def with_binding?(node); end
-  def with_lineno?(node); end
-end
-
-RuboCop::Cop::Style::EvalWithLocation::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::EvalWithLocation::MSG_EVAL = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::EvalWithLocation::MSG_INCORRECT_FILE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::EvalWithLocation::MSG_INCORRECT_LINE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::EvalWithLocation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::EvenOdd < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def even_odd_candidate?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def replacement_method(arg, method); end
-end
-
-RuboCop::Cop::Style::EvenOdd::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::EvenOdd::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::ExpandPathArguments < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def file_expand_path(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def pathname_new_parent_expand_path(param0 = T.unsafe(nil)); end
-  def pathname_parent_expand_path(param0 = T.unsafe(nil)); end
-
-  private
-
-  def arguments_range(node); end
-  def autocorrect(corrector, node); end
-  def autocorrect_expand_path(corrector, current_path, default_dir); end
-  def depth(current_path); end
-  def inspect_offense_for_expand_path(node, current_path, default_dir); end
-  def parent_path(current_path); end
-  def remove_parent_method(corrector, default_dir); end
-  def strip_surrounded_quotes!(path_string); end
-  def unrecommended_argument?(default_dir); end
-end
-
-RuboCop::Cop::Style::ExpandPathArguments::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ExpandPathArguments::PATHNAME_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ExpandPathArguments::PATHNAME_NEW_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ExpandPathArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::ExplicitBlockArgument < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def on_yield(node); end
-  def yielding_block?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def add_block_argument(node, corrector, block_name); end
-  def block_body_range(block_node, send_node); end
-  def call_like?(node); end
-  def correct_call_node(node, corrector, block_name); end
-  def empty_arguments?(node); end
-  def extract_block_name(def_node); end
-  def insert_argument(node, corrector, block_name); end
-  def yielding_arguments?(block_args, yield_args); end
-end
-
-RuboCop::Cop::Style::ExplicitBlockArgument::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::ExponentialNotation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-
-  def on_float(node); end
-
-  private
-
-  def engineering?(node); end
-  def integral(node); end
-  def message(_node); end
-  def offense?(node); end
-  def scientific?(node); end
-end
-
-RuboCop::Cop::Style::ExponentialNotation::MESSAGES = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Cop::Style::FetchEnvVar < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def env_with_bracket?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def allowable_use?(node); end
-  def allowed_var?(node); end
-  def assigned?(node); end
-  def message_chained_with_dot?(node); end
-  def new_code(name_node); end
-  def offensive?(node); end
-  def or_lhs?(node); end
-  def partial_matched?(node, condition); end
-  def used_as_flag?(node); end
-  def used_if_condition_in_body(node); end
-  def used_in_condition?(node, condition); end
-end
-
-RuboCop::Cop::Style::FetchEnvVar::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::FileRead < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def block_read?(param0 = T.unsafe(nil)); end
-  def file_open?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def send_read?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def evidence(node); end
-  def file_open_read?(node); end
-  def read_method(mode); end
-  def read_node?(node, block_pass); end
-end
-
-RuboCop::Cop::Style::FileRead::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::FileRead::READ_FILE_START_TO_FINISH_MODES = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Style::FileRead::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::FileWrite < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def block_write?(param0 = T.unsafe(nil)); end
-  def evidence(node); end
-  def file_open?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def send_write?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def file_open_write?(node); end
-  def heredoc?(write_node); end
-  def heredoc_range(first_argument); end
-  def replacement(mode, filename, content, write_node); end
-  def write_method(mode); end
-end
-
-RuboCop::Cop::Style::FileWrite::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::FileWrite::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Style::FileWrite::TRUNCATING_WRITE_MODES = T.let(T.unsafe(nil), Set)
-
-class RuboCop::Cop::Style::FloatDivision < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def any_coerce?(param0 = T.unsafe(nil)); end
-  def both_coerce?(param0 = T.unsafe(nil)); end
-  def left_coerce?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def right_coerce?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def add_to_f_method(corrector, node); end
-  def correct_from_slash_to_fdiv(corrector, node, receiver, argument); end
-  def extract_receiver_source(node); end
-  def message(_node); end
-  def offense_condition?(node); end
-  def remove_to_f_method(corrector, send_node); end
-end
-
-RuboCop::Cop::Style::FloatDivision::MESSAGES = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Style::FloatDivision::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::For < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def on_for(node); end
-
-  private
-
-  def suspect_enumerable?(node); end
-end
-
-RuboCop::Cop::Style::For::EACH_LENGTH = T.let(T.unsafe(nil), Integer)
-RuboCop::Cop::Style::For::PREFER_EACH = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::For::PREFER_FOR = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::FormatString < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def formatter(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def variable_argument?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def autocorrect_from_percent(corrector, node); end
-  def autocorrect_to_percent(corrector, node); end
-  def format_single_parameter(arg); end
-  def message(detected_style); end
-  def method_name(style_name); end
-end
-
-RuboCop::Cop::Style::FormatString::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::FormatString::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::FormatStringToken < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::IgnoredMethods
-  extend ::RuboCop::Cop::IgnoredMethods::Config
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def format_string_in_typical_context?(param0 = T.unsafe(nil)); end
-  def on_str(node); end
-
-  private
-
-  def allowed_unannotated?(detections); end
-  def autocorrect_sequence(corrector, detected_sequence, token_range); end
-  def check_sequence(detected_sequence, token_range); end
-  def collect_detections(node); end
-  def correctable_sequence?(detected_type); end
-  def format_string_token?(node); end
-  def max_unannotated_placeholders_allowed; end
-  def message(detected_style); end
-  def message_text(style); end
-  def str_contents(source_map); end
-  def token_ranges(contents); end
-  def tokens(str_node, &block); end
-  def unannotated_format?(node, detected_style); end
-  def use_ignored_method?(node); end
-end
-
-class RuboCop::Cop::Style::FrozenStringLiteralComment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::FrozenStringLiteral
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_new_investigation; end
-
-  private
-
-  def disabled_offense(processed_source); end
-  def enable_comment(corrector); end
-  def ensure_comment(processed_source); end
-  def ensure_enabled_comment(processed_source); end
-  def ensure_no_comment(processed_source); end
-  def following_comment; end
-  def frozen_string_literal_comment(processed_source); end
-  def insert_comment(corrector); end
-  def last_special_comment(processed_source); end
-  def line_range(line); end
-  def missing_offense(processed_source); end
-  def missing_true_offense(processed_source); end
-  def preceding_comment; end
-  def remove_comment(corrector, node); end
-  def unnecessary_comment_offense(processed_source); end
-end
-
-RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_DISABLED = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_MISSING = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_MISSING_TRUE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_UNNECESSARY = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::FrozenStringLiteralComment::SHEBANG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::GlobalStdStream < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def const_to_gvar_assignment?(param0 = T.unsafe(nil), param1); end
-  def on_const(node); end
-
-  private
-
-  def gvar_name(const_name); end
-  def message(const_name); end
-end
-
-RuboCop::Cop::Style::GlobalStdStream::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::GlobalStdStream::STD_STREAMS = T.let(T.unsafe(nil), Set)
-
-class RuboCop::Cop::Style::GlobalVars < ::RuboCop::Cop::Base
-  def allowed_var?(global_var); end
-  def check(node); end
-  def on_gvar(node); end
-  def on_gvasgn(node); end
-  def user_vars; end
-end
-
-RuboCop::Cop::Style::GlobalVars::BUILT_IN_VARS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::GlobalVars::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::MinBodyLength
-  include ::RuboCop::Cop::LineLengthHelp
-  include ::RuboCop::Cop::StatementModifier
-
-  def on_def(node); end
-  def on_defs(node); end
-  def on_if(node); end
-
-  private
-
-  def accepted_form?(node, ending: T.unsafe(nil)); end
-  def accepted_if?(node, ending); end
-  def allowed_consecutive_conditionals?; end
-  def check_ending_if(node); end
-  def consecutive_conditionals?(parent, node); end
-  def guard_clause_source(guard_clause); end
-  def register_offense(node, scope_exiting_keyword, conditional_keyword); end
-  def too_long_for_single_line?(node, example); end
-  def trivial?(node); end
-end
-
-RuboCop::Cop::Style::GuardClause::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::HashAsLastArrayItem < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_hash(node); end
-
-  private
-
-  def braces_style?; end
-  def check_braces(node); end
-  def check_no_braces(node); end
-  def containing_array(hash_node); end
-  def explicit_array?(array); end
-  def last_array_item?(array, node); end
-  def remove_last_element_trailing_comma(corrector, node); end
-end
-
-class RuboCop::Cop::Style::HashConversion < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def hash_from_array?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def allowed_splat_argument?; end
-  def args_to_hash(args); end
-  def multi_argument(node); end
-  def register_offense_for_hash(node, hash_argument); end
-  def register_offense_for_zip_method(node, zip_method); end
-  def requires_parens?(node); end
-  def single_argument(node); end
-  def use_zip_method_without_argument?(first_argument); end
-end
-
-RuboCop::Cop::Style::HashConversion::MSG_LITERAL_HASH_ARG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::HashConversion::MSG_LITERAL_MULTI_ARG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::HashConversion::MSG_SPLAT = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::HashConversion::MSG_TO_H = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::HashConversion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::HashEachMethods < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Lint::UnusedArgument
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def kv_each(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-
-  private
-
-  def allowed_receiver?(receiver); end
-  def allowed_receivers; end
-  def check_argument(variable); end
-  def correct_args(node, corrector); end
-  def correct_implicit(node, corrector, method_name); end
-  def correct_key_value_each(node, corrector); end
-  def kv_range(outer_node); end
-  def register_kv_offense(node); end
-  def used?(arg); end
-end
-
-RuboCop::Cop::Style::HashEachMethods::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::HashExcept < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::TargetRubyVersion
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def bad_method_with_active_support?(param0 = T.unsafe(nil)); end
-  def bad_method_with_poro?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def bad_method?(block); end
-  def decorate_source(value); end
-  def except_key(node); end
-  def except_key_source(key); end
-  def extract_body_if_nagated(body); end
-  def included?(negated, body); end
-  def not_included?(negated, body); end
-  def offense_range(node); end
-  def safe_to_register_offense?(block, except_key); end
-  def semantically_except_method?(send, block); end
-end
-
-RuboCop::Cop::Style::HashExcept::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::HashExcept::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::HashLikeCase < ::RuboCop::Cop::Base
-  def hash_like_case?(param0 = T.unsafe(nil)); end
-  def on_case(node); end
-
-  private
-
-  def min_branches_count; end
-  def nodes_of_same_type?(nodes); end
-end
-
-RuboCop::Cop::Style::HashLikeCase::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::HashSyntax < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::HashShorthandSyntax
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def alternative_style; end
-  def hash_rockets_check(pairs); end
-  def no_mixed_keys_check(pairs); end
-  def on_hash(node); end
-  def ruby19_check(pairs); end
-  def ruby19_no_mixed_keys_check(pairs); end
-
-  private
-
-  def acceptable_19_syntax_symbol?(sym_name); end
-  def argument_without_space?(node); end
-  def autocorrect(corrector, node); end
-  def autocorrect_hash_rockets(corrector, pair_node); end
-  def autocorrect_no_mixed_keys(corrector, pair_node); end
-  def autocorrect_ruby19(corrector, pair_node); end
-  def check(pairs, delim, msg); end
-  def force_hash_rockets?(pairs); end
-  def range_for_autocorrect_ruby19(pair_node); end
-  def sym_indices?(pairs); end
-  def word_symbol_pair?(pair); end
-end
-
-RuboCop::Cop::Style::HashSyntax::MSG_19 = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::HashSyntax::MSG_HASH_ROCKETS = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::HashSyntax::MSG_NO_MIXED_KEYS = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::HashTransformKeys < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::HashTransformMethod
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_bad_each_with_object(param0 = T.unsafe(nil)); end
-  def on_bad_hash_brackets_map(param0 = T.unsafe(nil)); end
-  def on_bad_map_to_h(param0 = T.unsafe(nil)); end
-  def on_bad_to_h(param0 = T.unsafe(nil)); end
-
-  private
-
-  def extract_captures(match); end
-  def new_method_name; end
-end
-
-class RuboCop::Cop::Style::HashTransformValues < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::HashTransformMethod
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_bad_each_with_object(param0 = T.unsafe(nil)); end
-  def on_bad_hash_brackets_map(param0 = T.unsafe(nil)); end
-  def on_bad_map_to_h(param0 = T.unsafe(nil)); end
-  def on_bad_to_h(param0 = T.unsafe(nil)); end
-
-  private
-
-  def extract_captures(match); end
-  def new_method_name; end
-end
-
-class RuboCop::Cop::Style::IdenticalConditionalBranches < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_case(node); end
-  def on_case_match(node); end
-  def on_if(node); end
-
-  private
-
-  def check_branches(node, branches); end
-  def check_expressions(node, expressions, insert_position); end
-  def duplicated_expressions?(node, expressions); end
-  def expand_elses(branch); end
-  def head(node); end
-  def message(node); end
-  def tail(node); end
-end
-
-RuboCop::Cop::Style::IdenticalConditionalBranches::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::IfCorrector
-  extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper
-  extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper
-
-  class << self
-    def correct(corrector, cop, node); end
-    def move_assignment_inside_condition(corrector, node); end
-
-    private
-
-    def extract_tail_branches(node); end
-    def move_branch_inside_condition(corrector, branch, condition, assignment, column); end
-  end
-end
-
-class RuboCop::Cop::Style::IfInsideElse < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-
-  private
-
-  def allow_if_modifier?; end
-  def allow_if_modifier_in_else_branch?(else_branch); end
-  def autocorrect(corrector, node); end
-  def correct_to_elsif_from_if_inside_else_form(corrector, node, condition); end
-  def correct_to_elsif_from_modifier_form(corrector, node); end
-  def find_end_range(node); end
-  def if_condition_range(node, condition); end
-  def then?(node); end
-end
-
-RuboCop::Cop::Style::IfInsideElse::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::IfUnlessModifier < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::LineLengthHelp
-  include ::RuboCop::Cop::StatementModifier
-  include ::RuboCop::Cop::AllowedPattern
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-
-  private
-
-  def allowed_patterns; end
-  def another_statement_on_same_line?(node); end
-  def autocorrect(corrector, node); end
-  def extract_heredoc_from(last_argument); end
-  def line_length_enabled_at_line?(line); end
-  def named_capture_in_condition?(node); end
-  def non_eligible_node?(node); end
-  def non_simple_if_unless?(node); end
-  def remove_heredoc(corrector, heredoc); end
-  def to_normal_form(node, indentation); end
-  def to_normal_form_with_heredoc(node, indentation, heredoc); end
-  def too_long_due_to_modifier?(node); end
-  def too_long_line_based_on_allow_uri?(line); end
-  def too_long_line_based_on_config?(range, line); end
-  def too_long_line_based_on_ignore_cop_directives?(range, line); end
-  def too_long_single_line?(node); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_MODIFIER = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_NORMAL = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::LineLengthHelp
-  include ::RuboCop::Cop::StatementModifier
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-end
-
-RuboCop::Cop::Style::IfUnlessModifierOfIfUnless::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::IfWithBooleanLiteralBranches < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::AllowedMethods
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def double_negative?(param0 = T.unsafe(nil)); end
-  def if_with_boolean_literal_branches?(param0 = T.unsafe(nil)); end
-  def on_if(node); end
-
-  private
-
-  def assume_boolean_value?(condition); end
-  def message(node, keyword); end
-  def offense_range_with_keyword(node, condition); end
-  def opposite_condition?(node); end
-  def replacement_condition(node, condition); end
-  def require_parentheses?(condition); end
-  def return_boolean_value?(condition); end
-end
-
-RuboCop::Cop::Style::IfWithBooleanLiteralBranches::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::IfWithBooleanLiteralBranches::MSG_FOR_ELSIF = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::IfWithSemicolon < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::OnNormalIfUnless
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_normal_if_unless(node); end
-
-  private
-
-  def autocorrect(node); end
-  def build_else_branch(second_condition); end
-  def correct_elsif(node); end
-end
-
-RuboCop::Cop::Style::IfWithSemicolon::MSG_IF_ELSE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::IfWithSemicolon::MSG_TERNARY = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::ImplicitRuntimeError < ::RuboCop::Cop::Base
-  def implicit_runtime_error_raise_or_fail(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Style::ImplicitRuntimeError::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ImplicitRuntimeError::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::InPatternThen < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_in_pattern(node); end
-
-  private
-
-  def alternative_pattern_source(pattern); end
-end
-
-RuboCop::Cop::Style::InPatternThen::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::InfiniteLoop < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def after_leaving_scope(scope, _variable_table); end
-  def on_until(node); end
-  def on_until_post(node); end
-  def on_while(node); end
-  def on_while_post(node); end
-
-  private
-
-  def assigned_before_loop?(var, range); end
-  def assigned_inside_loop?(var, range); end
-  def autocorrect(corrector, node); end
-  def configured_indent; end
-  def modifier_replacement(node); end
-  def non_modifier_range(node); end
-  def referenced_after_loop?(var, range); end
-  def replace_begin_end_with_modifier(corrector, node); end
-  def replace_source(corrector, range, replacement); end
-  def while_or_until(node); end
-
-  class << self
-    def joining_forces; end
-  end
-end
-
-RuboCop::Cop::Style::InfiniteLoop::LEADING_SPACE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Style::InfiniteLoop::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::InlineComment < ::RuboCop::Cop::Base
-  def on_new_investigation; end
-end
-
-RuboCop::Cop::Style::InlineComment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::InverseMethods < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def inverse_block?(param0 = T.unsafe(nil)); end
-  def inverse_candidate?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def on_send(node); end
-
-  private
-
-  def camel_case_constant?(node); end
-  def correct_inverse_block(corrector, node); end
-  def correct_inverse_method(corrector, node); end
-  def correct_inverse_selector(block, corrector); end
-  def dot_range(loc); end
-  def end_parentheses(node, method_call); end
-  def inverse_blocks; end
-  def inverse_methods; end
-  def message(method, inverse); end
-  def negated?(node); end
-  def not_to_receiver(node, method_call); end
-  def possible_class_hierarchy_check?(lhs, rhs, method); end
-  def remove_end_parenthesis(corrector, node, method, method_call); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Style::InverseMethods::CAMEL_CASE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Style::InverseMethods::CLASS_COMPARISON_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::InverseMethods::EQUALITY_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::InverseMethods::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::InverseMethods::NEGATED_EQUALITY_METHODS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::IpAddresses < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::StringHelp
-
-  def correct_style_detected; end
-  def offense?(node); end
-  def opposite_style_detected; end
-
-  private
-
-  def allowed_addresses; end
-  def could_be_ip?(str); end
-  def starts_with_hex_or_colon?(str); end
-  def too_long?(str); end
-end
-
-RuboCop::Cop::Style::IpAddresses::IPV6_MAX_SIZE = T.let(T.unsafe(nil), Integer)
-RuboCop::Cop::Style::IpAddresses::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::KeywordParametersOrder < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_kwoptarg(node); end
-
-  private
-
-  def append_newline_to_last_kwoptarg(arguments, corrector); end
-  def remove_kwargs(kwarg_nodes, corrector); end
-end
-
-RuboCop::Cop::Style::KeywordParametersOrder::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::Lambda < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def on_numblock(node); end
-
-  private
-
-  def arguments_with_whitespace(node); end
-  def autocorrect_method_to_literal(corrector, node); end
-  def lambda_arg_string(args); end
-  def message(node, selector); end
-  def message_line_modifier(node); end
-  def offending_selector?(node, selector); end
-end
-
-RuboCop::Cop::Style::Lambda::LITERAL_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::Lambda::METHOD_MESSAGE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::Lambda::OFFENDING_SELECTORS = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Cop::Style::LambdaCall < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def explicit_style?; end
-  def implicit_style?; end
-  def offense?(node); end
-  def prefer(node); end
-end
-
-RuboCop::Cop::Style::LambdaCall::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::LambdaCall::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::LineEndConcatenation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-
-  private
-
-  def autocorrect(corrector, operator_range); end
-  def check_token_set(index); end
-  def eligible_next_successor?(next_successor); end
-  def eligible_operator?(operator); end
-  def eligible_predecessor?(predecessor); end
-  def eligible_successor?(successor); end
-  def eligible_token_set?(predecessor, operator, successor); end
-  def standard_string_literal?(token); end
-  def token_after_last_string(successor, base_index); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Style::LineEndConcatenation::COMPLEX_STRING_BEGIN_TOKEN = T.let(T.unsafe(nil), Symbol)
-RuboCop::Cop::Style::LineEndConcatenation::COMPLEX_STRING_END_TOKEN = T.let(T.unsafe(nil), Symbol)
-RuboCop::Cop::Style::LineEndConcatenation::CONCAT_TOKEN_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::LineEndConcatenation::HIGH_PRECEDENCE_OP_TOKEN_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::LineEndConcatenation::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::LineEndConcatenation::QUOTE_DELIMITERS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::LineEndConcatenation::SIMPLE_STRING_TOKEN_TYPE = T.let(T.unsafe(nil), Symbol)
-
-class RuboCop::Cop::Style::MapCompactWithConditionalBlock < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def map_and_compact?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def range(node); end
-  def returns_block_argument?(block_argument_node, return_value_node); end
-  def truthy_branch?(node); end
-  def truthy_branch_for_guard?(node); end
-  def truthy_branch_for_if?(node); end
-end
-
-RuboCop::Cop::Style::MapCompactWithConditionalBlock::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MapToHash < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def map_to_h?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def autocorrect(corrector, to_h, map); end
-end
-
-RuboCop::Cop::Style::MapToHash::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::MapToHash::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::MethodCallWithArgsParentheses < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::IgnoredMethods
-  include ::RuboCop::Cop::AllowedPattern
-  include ::RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses
-  include ::RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
-  extend ::RuboCop::Cop::IgnoredMethods::Config
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-  def on_super(node); end
-  def on_yield(node); end
-
-  private
-
-  def args_begin(node); end
-  def args_end(node); end
-  def args_parenthesized?(node); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
-  private
-
-  def allowed_camel_case_method_call?(node); end
-  def allowed_chained_call_with_parentheses?(node); end
-  def allowed_multiline_call_with_parentheses?(node); end
-  def allowed_string_interpolation_method_call?(node); end
-  def ambigious_literal?(node); end
-  def assigned_before?(node, target); end
-  def autocorrect(corrector, node); end
-  def call_as_argument_or_chain?(node); end
-  def call_in_literals?(node); end
-  def call_in_logical_operators?(node); end
-  def call_in_optional_arguments?(node); end
-  def call_in_single_line_inheritance?(node); end
-  def call_with_ambiguous_arguments?(node); end
-  def call_with_braced_block?(node); end
-  def exist_next_line_expression?(node); end
-  def hash_literal?(node); end
-  def hash_literal_in_arguments?(node); end
-  def inside_endless_method_def?(node); end
-  def inside_string_interpolation?(node); end
-  def legitimate_call_with_parentheses?(node); end
-  def logical_operator?(node); end
-  def modifier_form?(node); end
-  def offense_range(node); end
-  def omit_parentheses(node); end
-  def parentheses_at_the_end_of_multiline_call?(node); end
-  def regexp_slash_literal?(node); end
-  def require_parentheses_for_hash_value_omission?(node); end
-  def splat?(node); end
-  def super_call_without_arguments?(node); end
-  def syntax_like_method_call?(node); end
-  def ternary_if?(node); end
-  def unary_literal?(node); end
-end
-
-RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses::OMIT_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses::TRAILING_WHITESPACE_REGEX = T.let(T.unsafe(nil), Regexp)
-
-module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses
-  private
-
-  def eligible_for_parentheses_omission?(node); end
-  def ignored_macro?(node); end
-  def included_macros_list; end
-  def require_parentheses(node); end
-end
-
-RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses::REQUIRE_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::IgnoredMethods
-  extend ::RuboCop::Cop::IgnoredMethods::Config
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def any_assignment?(node); end
-  def default_argument?(node); end
-  def ineligible_node?(node); end
-  def offense_range(node); end
-  def register_offense(node); end
-  def same_name_assignment?(node); end
-  def variable_in_mass_assignment?(variable_name, node); end
-end
-
-RuboCop::Cop::Style::MethodCallWithoutArgsParentheses::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MethodCalledOnDoEndBlock < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_block(node); end
-  def on_csend(node); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Style::MethodCalledOnDoEndBlock::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MethodDefParentheses < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def anonymous_block_arg?(node); end
-  def arguments_without_parentheses?(node); end
-  def correct_arguments(arg_node, corrector); end
-  def forced_parentheses?(node); end
-  def missing_parentheses(node); end
-  def require_parentheses?(args); end
-  def unwanted_parentheses(args); end
-end
-
-RuboCop::Cop::Style::MethodDefParentheses::MSG_MISSING = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::MethodDefParentheses::MSG_PRESENT = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MinMax < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def min_max_candidate(param0 = T.unsafe(nil)); end
-  def on_array(node); end
-  def on_return(node); end
-
-  private
-
-  def argument_range(node); end
-  def message(offender, receiver); end
-  def offending_range(node); end
-end
-
-RuboCop::Cop::Style::MinMax::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MissingElse < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::OnNormalIfUnless
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-
-  def on_case(node); end
-  def on_case_match(node); end
-  def on_normal_if_unless(node); end
-
-  private
-
-  def case_style?; end
-  def check(node); end
-  def empty_else_config; end
-  def empty_else_cop_enabled?; end
-  def empty_else_style; end
-  def if_style?; end
-  def message_template; end
-  def unless_else_config; end
-  def unless_else_cop_enabled?; end
-end
-
-RuboCop::Cop::Style::MissingElse::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::MissingElse::MSG_EMPTY = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::MissingElse::MSG_NIL = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MissingRespondToMissing < ::RuboCop::Cop::Base
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def implements_respond_to_missing?(node); end
-end
-
-RuboCop::Cop::Style::MissingRespondToMissing::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MixinGrouping < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_class(node); end
-  def on_module(node); end
-
-  private
-
-  def check(send_node); end
-  def check_grouped_style(send_node); end
-  def check_separated_style(send_node); end
-  def group_mixins(node, mixins); end
-  def grouped_style?; end
-  def range_to_remove_for_subsequent_mixin(mixins, node); end
-  def separate_mixins(node); end
-  def separated_style?; end
-  def sibling_mixins(send_node); end
-end
-
-RuboCop::Cop::Style::MixinGrouping::MIXIN_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::MixinGrouping::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MixinUsage < ::RuboCop::Cop::Base
-  def in_top_level_scope?(param0 = T.unsafe(nil)); end
-  def include_statement(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Style::MixinUsage::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::MixinUsage::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::ModuleFunction < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def extend_self_node?(param0 = T.unsafe(nil)); end
-  def module_function_node?(param0 = T.unsafe(nil)); end
-  def on_module(node); end
-  def private_directive?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def check_extend_self(nodes); end
-  def check_forbidden(nodes); end
-  def check_module_function(nodes); end
-  def each_wrong_style(nodes, &block); end
-  def message(_range); end
-end
-
-RuboCop::Cop::Style::ModuleFunction::EXTEND_SELF_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ModuleFunction::FORBIDDEN_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ModuleFunction::MODULE_FUNCTION_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MultilineBlockChain < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-
-  def on_block(node); end
-end
-
-RuboCop::Cop::Style::MultilineBlockChain::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MultilineIfModifier < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::LineLengthHelp
-  include ::RuboCop::Cop::StatementModifier
-  include ::RuboCop::Cop::Alignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-
-  private
-
-  def configured_indentation_width; end
-  def indented_body(body, node); end
-  def to_normal_if(node); end
-end
-
-RuboCop::Cop::Style::MultilineIfModifier::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MultilineIfThen < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::OnNormalIfUnless
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_normal_if_unless(node); end
-
-  private
-
-  def non_modifier_then?(node); end
-end
-
-RuboCop::Cop::Style::MultilineIfThen::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::MultilineIfThen::NON_MODIFIER_THEN = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::Style::MultilineInPatternThen < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_in_pattern(node); end
-
-  private
-
-  def require_then?(in_pattern_node); end
-end
-
-RuboCop::Cop::Style::MultilineInPatternThen::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MultilineMemoization < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def message(_node); end
-  def on_or_asgn(node); end
-
-  private
-
-  def bad_rhs?(rhs); end
-  def keyword_autocorrect(node, corrector); end
-  def keyword_begin_str(node, node_buf); end
-  def keyword_end_str(node, node_buf); end
-end
-
-RuboCop::Cop::Style::MultilineMemoization::BRACES_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::MultilineMemoization::KEYWORD_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MultilineMethodSignature < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def arguments_range(node); end
-  def autocorrect(corrector, node); end
-  def closing_line(node); end
-  def correction_exceeds_max_line_length?(node); end
-  def definition_width(node); end
-  def indentation_width(node); end
-  def last_line_source_of_arguments(arguments); end
-  def max_line_length; end
-  def opening_line(node); end
-end
-
-RuboCop::Cop::Style::MultilineMethodSignature::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MultilineTernaryOperator < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-
-  private
-
-  def enforce_single_line_ternary_operator?(node); end
-  def offense?(node); end
-  def replacement(node); end
-  def use_assignment_method?(node); end
-end
-
-RuboCop::Cop::Style::MultilineTernaryOperator::MSG_IF = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::MultilineTernaryOperator::MSG_SINGLE_LINE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::MultilineTernaryOperator::SINGLE_LINE_TYPES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::MultilineWhenThen < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_when(node); end
-
-  private
-
-  def accept_node_type?(node); end
-  def require_then?(when_node); end
-end
-
-RuboCop::Cop::Style::MultilineWhenThen::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MultipleComparison < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-  def on_or(node); end
-  def simple_comparison_lhs?(param0 = T.unsafe(nil)); end
-  def simple_comparison_rhs?(param0 = T.unsafe(nil)); end
-  def simple_double_comparison?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def allow_method_comparison?; end
-  def comparison?(node); end
-  def nested_comparison?(node); end
-  def nested_variable_comparison?(node); end
-  def reset_comparison; end
-  def root_of_or_node(or_node); end
-  def switch_comparison?(node); end
-  def variable_name(node); end
-  def variables_in_node(node); end
-  def variables_in_simple_node(node); end
-end
-
-RuboCop::Cop::Style::MultipleComparison::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour
-  include ::RuboCop::Cop::Style::MutableConstant::ShareableConstantValue
-  include ::RuboCop::Cop::FrozenStringLiteral
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_casgn(node); end
-  def operation_produces_immutable_object?(param0 = T.unsafe(nil)); end
-  def range_enclosed_in_parentheses?(param0 = T.unsafe(nil)); end
-  def splat_value(param0 = T.unsafe(nil)); end
-  def t_let(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def check(value); end
-  def correct_splat_expansion(corrector, expr, splat_value); end
-  def frozen_regexp_or_range_literals?(node); end
-  def immutable_literal?(node); end
-  def mutable_literal?(value); end
-  def requires_parentheses?(node); end
-  def shareable_constant_value?(node); end
-  def strict_check(value); end
-end
-
-RuboCop::Cop::Style::MutableConstant::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::Style::MutableConstant::ShareableConstantValue
-  private
-
-  def magic_comment_in_scope(node); end
-  def processed_source_till_node(node); end
-  def recent_shareable_value?(node); end
-  def shareable_constant_value_enabled?(value); end
-
-  class << self
-    def magic_comment_in_scope(node); end
-    def recent_shareable_value?(node); end
-  end
-end
-
-class RuboCop::Cop::Style::NegatedIf < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::NegativeConditional
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-
-  private
-
-  def correct_style?(node); end
-  def message(node); end
-end
-
-class RuboCop::Cop::Style::NegatedIfElseCondition < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def double_negation?(param0 = T.unsafe(nil)); end
-  def on_if(node); end
-  def on_new_investigation; end
-
-  private
-
-  def correct_negated_condition(corrector, node); end
-  def corrected_ancestor?(node); end
-  def else_range(node); end
-  def if_else?(node); end
-  def if_range(node); end
-  def negated_condition?(node); end
-  def swap_branches(corrector, node); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Style::NegatedIfElseCondition::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::NegatedIfElseCondition::NEGATED_EQUALITY_METHODS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::NegatedUnless < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::NegativeConditional
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-
-  private
-
-  def correct_style?(node); end
-  def message(node); end
-end
-
-class RuboCop::Cop::Style::NegatedWhile < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::NegativeConditional
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_until(node); end
-  def on_while(node); end
-end
-
-class RuboCop::Cop::Style::NestedFileDirname < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def file_dirname?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def offense_range(node); end
-  def path_with_dir_level(node, level); end
-end
-
-RuboCop::Cop::Style::NestedFileDirname::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::NestedFileDirname::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::NestedModifier < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-  def on_until(node); end
-  def on_while(node); end
-
-  private
-
-  def add_parentheses_to_method_arguments(send_node); end
-  def autocorrect(corrector, node); end
-  def check(node); end
-  def left_hand_operand(node, operator); end
-  def modifier?(node); end
-  def new_expression(inner_node); end
-  def replacement_operator(keyword); end
-  def requires_parens?(node); end
-  def right_hand_operand(node, left_hand_keyword); end
-end
-
-RuboCop::Cop::Style::NestedModifier::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::NestedParenthesizedCalls < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::AllowedMethods
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def allowed?(send_node); end
-  def allowed_omission?(send_node); end
-  def autocorrect(corrector, nested); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Style::NestedParenthesizedCalls::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::NestedTernaryOperator < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-
-  private
-
-  def autocorrect(corrector, if_node); end
-  def if_node(node); end
-  def remove_parentheses(source); end
-  def replace_loc_and_whitespace(corrector, range, replacement); end
-end
-
-RuboCop::Cop::Style::NestedTernaryOperator::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::Next < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::MinBodyLength
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def on_for(node); end
-  def on_new_investigation; end
-  def on_until(node); end
-  def on_while(node); end
-
-  private
-
-  def actual_indent(lines, buffer); end
-  def allowed_modifier_if?(node); end
-  def autocorrect_block(corrector, node); end
-  def autocorrect_modifier(corrector, node); end
-  def check(node); end
-  def cond_range(node, cond); end
-  def end_followed_by_whitespace_only?(source_buffer, end_pos); end
-  def end_range(node); end
-  def ends_with_condition?(body); end
-  def exit_body_type?(node); end
-  def heredoc_lines(node); end
-  def if_else_children?(node); end
-  def if_without_else?(node); end
-  def offense_location(offense_node); end
-  def offense_node(body); end
-  def reindent(lines, node, corrector); end
-  def reindent_line(corrector, lineno, delta, buffer); end
-  def reindentable_lines(node); end
-  def simple_if_without_break?(node); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Style::Next::EXIT_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::Next::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::NilComparison < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def nil_check?(param0 = T.unsafe(nil)); end
-  def nil_comparison?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def message(_node); end
-  def prefer_comparison?; end
-  def style_check?(node, &block); end
-end
-
-RuboCop::Cop::Style::NilComparison::EXPLICIT_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::NilComparison::PREDICATE_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::NilComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::NilLambda < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def nil_return?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-end
-
-RuboCop::Cop::Style::NilLambda::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::NonNilCheck < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def nil_check?(param0 = T.unsafe(nil)); end
-  def not_and_nil_check?(param0 = T.unsafe(nil)); end
-  def not_equal_to_nil?(param0 = T.unsafe(nil)); end
-  def on_def(node); end
-  def on_defs(node); end
-  def on_send(node); end
-  def unless_check?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def autocorrect_comparison(corrector, node); end
-  def autocorrect_non_nil(corrector, node, inner_node); end
-  def autocorrect_unless_nil(corrector, node, receiver); end
-  def include_semantic_changes?; end
-  def message(node); end
-  def nil_comparison_style; end
-  def register_offense?(node); end
-  def unless_and_nil_check?(send_node); end
-end
-
-RuboCop::Cop::Style::NonNilCheck::MSG_FOR_REDUNDANCY = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::NonNilCheck::MSG_FOR_REPLACEMENT = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::NonNilCheck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::Not < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def correct_opposite_method(corrector, range, child); end
-  def correct_with_parens(corrector, range, node); end
-  def correct_without_parens(corrector, range); end
-  def opposite_method?(child); end
-  def requires_parens?(child); end
-end
-
-RuboCop::Cop::Style::Not::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::Not::OPPOSITE_METHODS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Style::Not::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::NumberedParameters < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_numblock(node); end
-end
-
-RuboCop::Cop::Style::NumberedParameters::MSG_DISALLOW = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::NumberedParameters::MSG_MULTI_LINE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::NumberedParametersLimit < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def max=(value); end
-  def on_numblock(node); end
-
-  private
-
-  def max_count; end
-end
-
-RuboCop::Cop::Style::NumberedParametersLimit::DEFAULT_MAX_VALUE = T.let(T.unsafe(nil), Integer)
-RuboCop::Cop::Style::NumberedParametersLimit::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::NumericLiteralPrefix < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::IntegerNode
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_int(node); end
-
-  private
-
-  def format_binary(source); end
-  def format_decimal(source); end
-  def format_hex(source); end
-  def format_octal(source); end
-  def format_octal_zero_only(source); end
-  def hex_bin_dec_literal_type(literal); end
-  def literal_type(node); end
-  def message(node); end
-  def octal_literal_type(literal); end
-  def octal_zero_only?; end
-end
-
-RuboCop::Cop::Style::NumericLiteralPrefix::BINARY_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::NumericLiteralPrefix::BINARY_REGEX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Style::NumericLiteralPrefix::DECIMAL_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::NumericLiteralPrefix::DECIMAL_REGEX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Style::NumericLiteralPrefix::HEX_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::NumericLiteralPrefix::HEX_REGEX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_REGEX = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_ZERO_ONLY_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_ZERO_ONLY_REGEX = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::Style::NumericLiterals < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::IntegerNode
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def min_digits=(value); end
-  def on_float(node); end
-  def on_int(node); end
-
-  private
-
-  def allowed_numbers; end
-  def check(node); end
-  def format_int_part(int_part); end
-  def format_number(node); end
-  def min_digits; end
-  def register_offense(node, &_block); end
-  def short_group_regex; end
-end
-
-RuboCop::Cop::Style::NumericLiterals::DELIMITER_REGEXP = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Style::NumericLiterals::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::NumericPredicate < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::IgnoredMethods
-  extend ::RuboCop::Cop::IgnoredMethods::Config
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def comparison(param0 = T.unsafe(nil)); end
-  def inverted_comparison(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def predicate(param0 = T.unsafe(nil)); end
-
-  private
-
-  def check(node); end
-  def invert; end
-  def parenthesized_source(node); end
-  def replacement(numeric, operation); end
-  def replacement_supported?(operator); end
-  def require_parentheses?(node); end
-end
-
-RuboCop::Cop::Style::NumericPredicate::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::NumericPredicate::REPLACEMENTS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Style::NumericPredicate::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::ObjectThen < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def on_send(node); end
-
-  private
-
-  def check_method_node(node); end
-  def message(node); end
-  def preferred_method(node); end
-end
-
-RuboCop::Cop::Style::ObjectThen::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::OneLineConditional < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::OnNormalIfUnless
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_normal_if_unless(node); end
-
-  private
-
-  def always_multiline?; end
-  def autocorrect(corrector, node); end
-  def cannot_replace_to_ternary?(node); end
-  def expr_replacement(node); end
-  def indentation_width; end
-  def keyword_with_changed_precedence?(node); end
-  def message(node); end
-  def method_call_with_changed_precedence?(node); end
-  def requires_parentheses?(node); end
-  def ternary_correction(node); end
-  def ternary_replacement(node); end
-end
-
-RuboCop::Cop::Style::OneLineConditional::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::OpenStructUse < ::RuboCop::Cop::Base
-  def on_const(node); end
-  def uses_open_struct?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def custom_class_or_module_definition?(node); end
-end
-
-RuboCop::Cop::Style::OpenStructUse::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::OptionHash < ::RuboCop::Cop::Base
-  def on_args(node); end
-  def option_hash(param0 = T.unsafe(nil)); end
-
-  private
-
-  def allowlist; end
-  def super_used?(node); end
-  def suspicious_name?(arg_name); end
-end
-
-RuboCop::Cop::Style::OptionHash::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::OptionalArguments < ::RuboCop::Cop::Base
-  def on_def(node); end
-
-  private
-
-  def argument_positions(arguments); end
-  def each_misplaced_optional_arg(arguments); end
-end
-
-RuboCop::Cop::Style::OptionalArguments::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::OptionalBooleanParameter < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::AllowedMethods
-
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def format_message(argument); end
-end
-
-RuboCop::Cop::Style::OptionalBooleanParameter::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::OrAssignment < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_cvasgn(node); end
-  def on_gvasgn(node); end
-  def on_if(node); end
-  def on_ivasgn(node); end
-  def on_lvasgn(node); end
-  def ternary_assignment?(param0 = T.unsafe(nil)); end
-  def unless_assignment?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def take_variable_and_default_from_ternary(node); end
-  def take_variable_and_default_from_unless(node); end
-end
-
-RuboCop::Cop::Style::OrAssignment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::ParallelAssignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RescueNode
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def implicit_self_getter?(param0 = T.unsafe(nil)); end
-  def on_masgn(node); end
-
-  private
-
-  def add_self_to_getters(right_elements); end
-  def allowed_lhs?(node); end
-  def allowed_masign?(lhs_elements, rhs_elements); end
-  def allowed_rhs?(node); end
-  def assignment_corrector(node, order); end
-  def autocorrect(corrector, node); end
-  def find_valid_order(left_elements, right_elements); end
-  def modifier_statement?(node); end
-  def return_of_method_call?(node); end
-end
-
-class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter
-  include ::TSort
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def initialize(assignments); end
-
-  def accesses?(rhs, lhs); end
-  def dependency?(lhs, rhs); end
-  def matching_calls(param0, param1, param2); end
-  def tsort_each_child(assignment); end
-  def tsort_each_node(&block); end
-  def uses_var?(param0, param1); end
-  def var_name(param0 = T.unsafe(nil)); end
-end
-
-class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector
-  include ::RuboCop::Cop::Alignment
-
-  def initialize(node, config, new_elements); end
-
-  def config; end
-  def correction; end
-  def correction_range; end
-  def node; end
-
-  protected
-
-  def assignment; end
-
-  private
-
-  def cop_config; end
-  def extract_sources(node); end
-  def source(node); end
-end
-
-RuboCop::Cop::Style::ParallelAssignment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector < ::RuboCop::Cop::Style::ParallelAssignment::GenericCorrector
-  def correction; end
-  def correction_range; end
-
-  private
-
-  def modifier_range(node); end
-end
-
-class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector < ::RuboCop::Cop::Style::ParallelAssignment::GenericCorrector
-  def correction; end
-  def correction_range; end
-
-  private
-
-  def begin_correction(rescue_result); end
-  def def_correction(rescue_result); end
-end
-
-class RuboCop::Cop::Style::ParenthesesAroundCondition < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::SafeAssignment
-  include ::RuboCop::Cop::Parentheses
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def control_op_condition(param0 = T.unsafe(nil)); end
-  def on_if(node); end
-  def on_until(node); end
-  def on_while(node); end
-
-  private
-
-  def allow_multiline_conditions?; end
-  def message(node); end
-  def modifier_op?(node); end
-  def parens_allowed?(node); end
-  def process_control_op(node); end
-  def semicolon_separated_expressions?(first_exp, rest_exps); end
-end
-
-class RuboCop::Cop::Style::PercentLiteralDelimiters < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::PercentLiteral
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_array(node); end
-  def on_dstr(node); end
-  def on_regexp(node); end
-  def on_str(node); end
-  def on_sym(node); end
-  def on_xstr(node); end
-
-  private
-
-  def contains_delimiter?(node, delimiters); end
-  def contains_preferred_delimiter?(node, type); end
-  def include_same_character_as_used_for_delimiter?(node, type); end
-  def matchpairs(begin_delimiter); end
-  def message(type); end
-  def on_percent_literal(node); end
-  def preferred_delimiters_for(type); end
-  def string_source(node); end
-  def uses_preferred_delimiter?(node, type); end
-end
-
-class RuboCop::Cop::Style::PercentQLiterals < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::PercentLiteral
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_str(node); end
-
-  private
-
-  def correct_literal_style?(node); end
-  def corrected(src); end
-  def message(_range); end
-  def on_percent_literal(node); end
-end
-
-RuboCop::Cop::Style::PercentQLiterals::LOWER_CASE_Q_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::PercentQLiterals::UPPER_CASE_Q_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::PerlBackrefs < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_back_ref(node); end
-  def on_gvar(node); end
-  def on_nth_ref(node); end
-
-  private
-
-  def derived_from_braceless_interpolation?(node); end
-  def format_message(node:, preferred_expression:); end
-  def on_back_ref_or_gvar_or_nth_ref(node); end
-  def original_expression_of(node); end
-  def preferred_expression_to(node); end
-end
-
-RuboCop::Cop::Style::PerlBackrefs::MESSAGE_FORMAT = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::PreferredHashMethods < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-
-  private
-
-  def message(method_name); end
-  def offending_selector?(method_name); end
-  def proper_method_name(method_name); end
-end
-
-RuboCop::Cop::Style::PreferredHashMethods::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::PreferredHashMethods::OFFENDING_SELECTORS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Style::PreferredHashMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::Proc < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def proc_new?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Style::Proc::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::QuotedSymbols < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::SymbolHelp
-  include ::RuboCop::Cop::StringLiteralsHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_sym(node); end
-
-  private
-
-  def alternative_style; end
-  def autocorrect(corrector, node); end
-  def correct_quotes(str); end
-  def hash_colon_key?(node); end
-  def invalid_double_quotes?(source); end
-  def quoted?(sym_node); end
-  def style; end
-  def wrong_quotes?(node); end
-end
-
-RuboCop::Cop::Style::QuotedSymbols::MSG_DOUBLE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::QuotedSymbols::MSG_SINGLE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RaiseArgs < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def acceptable_exploded_args?(args); end
-  def allowed_non_exploded_type?(arg); end
-  def check_compact(node); end
-  def check_exploded(node); end
-  def correction_compact_to_exploded(node); end
-  def correction_exploded_to_compact(node); end
-  def requires_parens?(parent); end
-  def use_new_method?(first_arg); end
-end
-
-RuboCop::Cop::Style::RaiseArgs::COMPACT_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RaiseArgs::EXPLODED_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RaiseArgs::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::RandomWithOffset < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def integer_op_rand?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def rand_modified?(param0 = T.unsafe(nil)); end
-  def rand_op_integer?(param0 = T.unsafe(nil)); end
-  def random_call(param0 = T.unsafe(nil)); end
-  def to_int(param0 = T.unsafe(nil)); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def boundaries_from_random_node(random_node); end
-  def corrected_integer_op_rand(node); end
-  def corrected_rand_modified(node); end
-  def corrected_rand_op_integer(node); end
-  def prefix_from_prefix_node(node); end
-end
-
-RuboCop::Cop::Style::RandomWithOffset::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RandomWithOffset::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::RedundantArgument < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def argument_range(node); end
-  def redundant_arg_for_method(method_name); end
-  def redundant_argument?(node); end
-end
-
-RuboCop::Cop::Style::RedundantArgument::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RedundantAssignment < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-  def redundant_assignment?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def check_begin_node(node); end
-  def check_branch(node); end
-  def check_case_node(node); end
-  def check_ensure_node(node); end
-  def check_if_node(node); end
-  def check_rescue_node(node); end
-end
-
-RuboCop::Cop::Style::RedundantAssignment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RedundantBegin < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def offensive_kwbegins(param0); end
-  def on_block(node); end
-  def on_def(node); end
-  def on_defs(node); end
-  def on_kwbegin(node); end
-
-  private
-
-  def allowable_kwbegin?(node); end
-  def begin_block_has_multiline_statements?(node); end
-  def condition_range(node); end
-  def contain_rescue_or_ensure?(node); end
-  def correct_modifier_form_after_multiline_begin_block(corrector, node); end
-  def empty_begin?(node); end
-  def register_offense(node); end
-  def replace_begin_with_statement(corrector, offense_range, node); end
-  def restore_removed_comments(corrector, offense_range, node, first_child); end
-  def use_modifier_form_after_multiline_begin_block?(node); end
-  def valid_begin_assignment?(node); end
-  def valid_context_using_only_begin?(node); end
-end
-
-RuboCop::Cop::Style::RedundantBegin::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RedundantCapitalW < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::PercentLiteral
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_array(node); end
-
-  private
-
-  def on_percent_literal(node); end
-  def requires_interpolation?(node); end
-end
-
-RuboCop::Cop::Style::RedundantCapitalW::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RedundantCondition < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-
-  private
-
-  def asgn_type?(node); end
-  def branches_have_assignment?(node); end
-  def branches_have_method?(node); end
-  def correct_ternary(corrector, node); end
-  def else_source(else_branch); end
-  def else_source_if_has_assignment(else_branch); end
-  def else_source_if_has_method(else_branch); end
-  def if_source(if_branch); end
-  def make_ternary_form(node); end
-  def message(node); end
-  def offense?(node); end
-  def range_of_offense(node); end
-  def redundant_condition?(node); end
-  def require_braces?(node); end
-  def require_parentheses?(node); end
-  def same_method?(if_branch, else_branch); end
-  def synonymous_condition_and_branch?(node); end
-  def use_hash_key_access?(node); end
-  def use_hash_key_assignment?(else_branch); end
-  def use_if_branch?(else_branch); end
-  def without_argument_parentheses_method?(node); end
-end
-
-RuboCop::Cop::Style::RedundantCondition::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantCondition::REDUNDANT_CONDITION = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RedundantConditional < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-  def redundant_condition?(param0 = T.unsafe(nil)); end
-  def redundant_condition_inverted?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def configured_indentation_width; end
-  def indented_else_node(expression, node); end
-  def invert_expression?(node); end
-  def message(node); end
-  def offense?(node); end
-  def replacement_condition(node); end
-end
-
-RuboCop::Cop::Style::RedundantConditional::COMPARISON_OPERATOR_MATCHER = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantConditional::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RedundantException < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def compact?(param0 = T.unsafe(nil)); end
-  def exploded?(param0 = T.unsafe(nil)); end
-  def fix_compact(node); end
-  def fix_exploded(node); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Style::RedundantException::MSG_1 = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantException::MSG_2 = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::RedundantFetchBlock < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::FrozenStringLiteral
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def rails_cache?(param0 = T.unsafe(nil)); end
-  def redundant_fetch_block_candidate?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def basic_literal?(node); end
-  def build_bad_method(send, body); end
-  def build_good_method(send, body); end
-  def check_for_constant?; end
-  def check_for_string?; end
-  def const_type?(node); end
-  def fetch_range(send, node); end
-  def should_not_check?(send, body); end
-end
-
-RuboCop::Cop::Style::RedundantFetchBlock::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RedundantFileExtensionInRequire < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def require_call?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def extension_range(name_node); end
-end
-
-RuboCop::Cop::Style::RedundantFileExtensionInRequire::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantFileExtensionInRequire::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::RedundantFreeze < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::FrozenStringLiteral
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def operation_produces_immutable_object?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def immutable_literal?(node); end
-  def strip_parenthesis(node); end
-end
-
-RuboCop::Cop::Style::RedundantFreeze::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantFreeze::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::RedundantInitialize < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::CommentsHelp
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def initialize_forwards?(param0 = T.unsafe(nil)); end
-  def on_def(node); end
-
-  private
-
-  def acceptable?(node); end
-  def allow_comments?(node); end
-  def forwards?(node); end
-  def register_offense(node, message); end
-  def same_args?(super_node, args); end
-end
-
-RuboCop::Cop::Style::RedundantInitialize::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantInitialize::MSG_EMPTY = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RedundantInterpolation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::PercentLiteral
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_dstr(node); end
-
-  private
-
-  def autocorrect_other(corrector, embedded_node, node); end
-  def autocorrect_single_variable_interpolation(corrector, embedded_node, node); end
-  def autocorrect_variable_interpolation(corrector, embedded_node, node); end
-  def embedded_in_percent_array?(node); end
-  def implicit_concatenation?(node); end
-  def interpolation?(node); end
-  def require_parentheses?(node); end
-  def single_interpolation?(node); end
-  def single_variable_interpolation?(node); end
-  def variable_interpolation?(node); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Style::RedundantInterpolation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RedundantParentheses < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Parentheses
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def arg_in_call_with_block?(param0 = T.unsafe(nil)); end
-  def first_send_argument?(param0 = T.unsafe(nil)); end
-  def first_super_argument?(param0 = T.unsafe(nil)); end
-  def first_yield_argument?(param0 = T.unsafe(nil)); end
-  def interpolation?(param0 = T.unsafe(nil)); end
-  def method_node_and_args(param0 = T.unsafe(nil)); end
-  def on_begin(node); end
-  def range_end?(param0 = T.unsafe(nil)); end
-  def rescue?(param0 = T.unsafe(nil)); end
-  def square_brackets?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def allowed_ancestor?(node); end
-  def allowed_array_or_hash_element?(node); end
-  def allowed_expression?(node); end
-  def allowed_method_call?(node); end
-  def allowed_multiple_expression?(node); end
-  def call_chain_starts_with_int?(begin_node, send_node); end
-  def check(begin_node); end
-  def check_send(begin_node, node); end
-  def check_unary(begin_node, node); end
-  def disallowed_literal?(begin_node, node); end
-  def empty_parentheses?(node); end
-  def first_arg_begins_with_hash_literal?(node); end
-  def first_argument?(node); end
-  def hash_or_array_element?(node); end
-  def ignore_syntax?(node); end
-  def keyword_ancestor?(node); end
-  def keyword_with_redundant_parentheses?(node); end
-  def like_method_argument_parentheses?(node); end
-  def method_call_with_redundant_parentheses?(node); end
-  def method_chain_begins_with_hash_literal?(node); end
-  def offense(node, msg); end
-  def only_begin_arg?(args); end
-  def only_closing_paren_before_comma?(node); end
-  def parens_allowed?(node); end
-  def raised_to_power_negative_numeric?(begin_node, node); end
-  def suspect_unary?(node); end
-end
-
-class RuboCop::Cop::Style::RedundantPercentQ < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_dstr(node); end
-  def on_str(node); end
-
-  private
-
-  def acceptable_capital_q?(node); end
-  def acceptable_q?(node); end
-  def allowed_percent_q?(node); end
-  def check(node); end
-  def interpolated_quotes?(node); end
-  def message(node); end
-  def start_with_percent_q_variant?(string); end
-  def string_literal?(node); end
-end
-
-RuboCop::Cop::Style::RedundantPercentQ::DYNAMIC_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantPercentQ::EMPTY = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantPercentQ::ESCAPED_NON_BACKSLASH = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Style::RedundantPercentQ::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantPercentQ::PERCENT_CAPITAL_Q = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantPercentQ::PERCENT_Q = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantPercentQ::QUOTE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantPercentQ::SINGLE_QUOTE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantPercentQ::STRING_INTERPOLATION_REGEXP = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::Style::RedundantRegexpCharacterClass < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_regexp(node); end
-
-  private
-
-  def backslash_b?(elem); end
-  def each_redundant_character_class(node); end
-  def each_single_element_character_class(node); end
-  def multiple_codepoins?(expression); end
-  def redundant_single_element_character_class?(node, char_class); end
-  def requires_escape_outside_char_class?(elem); end
-  def whitespace_in_free_space_mode?(node, elem); end
-  def without_character_class(loc); end
-end
-
-RuboCop::Cop::Style::RedundantRegexpCharacterClass::MSG_REDUNDANT_CHARACTER_CLASS = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantRegexpCharacterClass::REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::RedundantRegexpEscape < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_regexp(node); end
-
-  private
-
-  def allowed_escape?(node, char, within_character_class); end
-  def delimiter?(node, char); end
-  def each_escape(node); end
-  def escape_range_at_index(node, index); end
-end
-
-RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_ALWAYS_ESCAPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::RedundantRegexpEscape::MSG_REDUNDANT_ESCAPE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RedundantReturn < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def add_braces(corrector, node); end
-  def add_brackets(corrector, node); end
-  def allow_multiple_return_values?; end
-  def check_begin_node(node); end
-  def check_branch(node); end
-  def check_case_node(node); end
-  def check_ensure_node(node); end
-  def check_if_node(node); end
-  def check_resbody_node(node); end
-  def check_rescue_node(node); end
-  def check_return_node(node); end
-  def correct_with_arguments(return_node, corrector); end
-  def correct_without_arguments(return_node, corrector); end
-  def hash_without_braces?(node); end
-  def message(node); end
-end
-
-RuboCop::Cop::Style::RedundantReturn::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantReturn::MULTI_RETURN_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RedundantSelf < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def on_and_asgn(node); end
-  def on_args(node); end
-  def on_block(node); end
-  def on_blockarg(node); end
-  def on_def(node); end
-  def on_defs(node); end
-  def on_if(node); end
-  def on_in_pattern(node); end
-  def on_lvasgn(node); end
-  def on_masgn(node); end
-  def on_op_asgn(node); end
-  def on_or_asgn(node); end
-  def on_send(node); end
-  def on_until(node); end
-  def on_while(node); end
-
-  private
-
-  def add_lhs_to_local_variables_scopes(rhs, lhs); end
-  def add_masgn_lhs_variables(rhs, lhs); end
-  def add_match_var_scopes(in_pattern_node); end
-  def add_scope(node, local_variables = T.unsafe(nil)); end
-  def allow_self(node); end
-  def allowed_send_node?(node); end
-  def on_argument(node); end
-  def regular_method_call?(node); end
-end
-
-RuboCop::Cop::Style::RedundantSelf::KERNEL_METHODS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::RedundantSelf::KEYWORDS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::RedundantSelf::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RedundantSelfAssignment < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_cvasgn(node); end
-  def on_gvasgn(node); end
-  def on_ivasgn(node); end
-  def on_lvasgn(node); end
-  def on_send(node); end
-  def redundant_nonself_assignment?(param0 = T.unsafe(nil), param1, param2); end
-  def redundant_self_assignment?(param0 = T.unsafe(nil), param1); end
-
-  private
-
-  def correction_range(node); end
-  def method_returning_self?(method_name); end
-  def redundant_assignment?(node); end
-end
-
-RuboCop::Cop::Style::RedundantSelfAssignment::ASSIGNMENT_TYPE_TO_RECEIVER_TYPE = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Style::RedundantSelfAssignment::METHODS_RETURNING_SELF = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Style::RedundantSelfAssignment::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RedundantSelfAssignmentBranch < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def bad_method?(param0 = T.unsafe(nil)); end
-  def on_lvasgn(node); end
-
-  private
-
-  def inconvertible_to_modifier?(if_branch, else_branch); end
-  def multiple_statements?(branch); end
-  def register_offense(if_node, offense_branch, opposite_branch, keyword); end
-  def self_assign?(variable, branch); end
-  def use_if_and_else_branch?(expression); end
-end
-
-RuboCop::Cop::Style::RedundantSelfAssignmentBranch::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RedundantSort < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def redundant_sort?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def accessor_start(node); end
-  def arg_node(node); end
-  def arg_value(node); end
-  def base(accessor, arg); end
-  def find_redundant_sort(*nodes); end
-  def message(node, sorter, accessor); end
-  def offense_range(sort_node, node); end
-  def register_offense(node, sort_node, sorter, accessor); end
-  def suffix(sorter); end
-  def suggestion(sorter, accessor, arg); end
-end
-
-RuboCop::Cop::Style::RedundantSort::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RedundantSort::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::RedundantSortBy < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-  def redundant_sort_by(param0 = T.unsafe(nil)); end
-
-  private
-
-  def sort_by_range(send, node); end
-end
-
-RuboCop::Cop::Style::RedundantSortBy::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RegexpLiteral < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_regexp(node); end
-
-  private
-
-  def allow_inner_slashes?; end
-  def allowed_mixed_percent_r?(node); end
-  def allowed_mixed_slash?(node); end
-  def allowed_omit_parentheses_with_percent_r_literal?(node); end
-  def allowed_percent_r_literal?(node); end
-  def allowed_slash_literal?(node); end
-  def calculate_replacement(node); end
-  def contains_disallowed_slash?(node); end
-  def contains_slash?(node); end
-  def correct_delimiters(node, corrector); end
-  def correct_inner_slashes(node, corrector); end
-  def inner_slash_after_correction(node); end
-  def inner_slash_before_correction(node); end
-  def inner_slash_for(opening_delimiter); end
-  def inner_slash_indices(node); end
-  def node_body(node, include_begin_nodes: T.unsafe(nil)); end
-  def preferred_delimiters; end
-  def slash_literal?(node); end
-end
-
-RuboCop::Cop::Style::RegexpLiteral::MSG_USE_PERCENT_R = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RegexpLiteral::MSG_USE_SLASHES = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RescueModifier < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::RescueNode
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_resbody(node); end
-
-  private
-
-  def correct_rescue_block(corrector, node, parenthesized); end
-  def indentation_and_offset(node, parenthesized); end
-  def parenthesized?(node); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Style::RescueModifier::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::RescueStandardError < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RescueNode
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_resbody(node); end
-  def rescue_standard_error?(param0 = T.unsafe(nil)); end
-  def rescue_without_error_class?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def offense_for_explicit_enforced_style(node); end
-  def offense_for_implicit_enforced_style(node, error); end
-end
-
-RuboCop::Cop::Style::RescueStandardError::MSG_EXPLICIT = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::RescueStandardError::MSG_IMPLICIT = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::ReturnNil < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def chained_send?(param0 = T.unsafe(nil)); end
-  def define_method?(param0 = T.unsafe(nil)); end
-  def on_return(node); end
-  def return_nil_node?(param0 = T.unsafe(nil)); end
-  def return_node?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def correct_style?(node); end
-  def message(_node); end
-  def scoped_node?(node); end
-end
-
-RuboCop::Cop::Style::ReturnNil::RETURN_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ReturnNil::RETURN_NIL_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::SafeNavigation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::AllowedMethods
-  include ::RuboCop::Cop::NilMethods
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def check_node(node); end
-  def modifier_if_safe_navigation_candidate(param0 = T.unsafe(nil)); end
-  def not_nil_check?(param0 = T.unsafe(nil)); end
-  def on_and(node); end
-  def on_if(node); end
-  def use_var_only_in_unless_modifier?(node, variable); end
-
-  private
-
-  def add_safe_nav_to_all_methods_in_chain(corrector, start_method, method_chain); end
-  def allowed_if_condition?(node); end
-  def autocorrect(corrector, node); end
-  def begin_range(node, method_call); end
-  def chain_length(method_chain, method); end
-  def comments(node); end
-  def end_range(node, method_call); end
-  def extract_common_parts(method_chain, checked_variable); end
-  def extract_parts(node); end
-  def extract_parts_from_and(node); end
-  def extract_parts_from_if(node); end
-  def find_matching_receiver_invocation(method_chain, checked_variable); end
-  def handle_comments(corrector, node, method_call); end
-  def max_chain_length; end
-  def method_call(node); end
-  def method_called?(send_node); end
-  def negated?(send_node); end
-  def relevant_comment_ranges(node); end
-  def unsafe_method?(send_node); end
-  def unsafe_method_used?(method_chain, method); end
-end
-
-RuboCop::Cop::Style::SafeNavigation::LOGIC_JUMP_KEYWORDS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::SafeNavigation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::Sample < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def sample_candidate?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def correction(shuffle_arg, method, method_args); end
-  def extract_source(args); end
-  def message(shuffle_arg, method, method_args, range); end
-  def offensive?(method, method_args); end
-  def range_size(range_node); end
-  def sample_arg(method, method_args); end
-  def sample_size(method_args); end
-  def sample_size_for_one_arg(arg); end
-  def sample_size_for_two_args(first, second); end
-  def source_range(shuffle_node, node); end
-end
-
-RuboCop::Cop::Style::Sample::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::Sample::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::SelectByRegexp < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def calls_lvar?(param0 = T.unsafe(nil), param1); end
-  def creates_hash?(param0 = T.unsafe(nil)); end
-  def env_const?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def regexp_match?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def extract_send_node(block_node); end
-  def find_regexp(node, block); end
-  def match_predicate_without_receiver?(node); end
-  def receiver_allowed?(node); end
-  def register_offense(node, block_node, regexp); end
-end
-
-RuboCop::Cop::Style::SelectByRegexp::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::SelectByRegexp::REGEXP_METHODS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Style::SelectByRegexp::REPLACEMENTS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Style::SelectByRegexp::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::SelfAssignment < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_cvasgn(node); end
-  def on_ivasgn(node); end
-  def on_lvasgn(node); end
-
-  private
-
-  def apply_autocorrect(corrector, node, rhs, operator, new_rhs); end
-  def autocorrect(corrector, node); end
-  def autocorrect_boolean_node(corrector, node, rhs); end
-  def autocorrect_send_node(corrector, node, rhs); end
-  def check(node, var_type); end
-  def check_boolean_node(node, rhs, var_name, var_type); end
-  def check_send_node(node, rhs, var_name, var_type); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Style::SelfAssignment::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::SelfAssignment::OPS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::Semicolon < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_begin(node); end
-  def on_new_investigation; end
-
-  private
-
-  def check_for_line_terminator_or_opener; end
-  def each_semicolon; end
-  def expressions_per_line(exprs); end
-  def find_range_node(token_before_semicolon); end
-  def find_semicolon_positions(line); end
-  def range_nodes; end
-  def register_semicolon(line, column, after_expression, token_before_semicolon = T.unsafe(nil)); end
-  def tokens_for_lines; end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Style::Semicolon::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::Send < ::RuboCop::Cop::Base
-  def on_csend(node); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Style::Send::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::Send::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::SignalException < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def custom_fail_methods(param0); end
-  def kernel_call?(param0 = T.unsafe(nil), param1); end
-  def on_new_investigation; end
-  def on_rescue(node); end
-  def on_send(node); end
-
-  private
-
-  def allow(method_name, node); end
-  def autocorrect(corrector, node); end
-  def check_scope(method_name, node); end
-  def check_send(method_name, node); end
-  def command_or_kernel_call?(name, node); end
-  def each_command_or_kernel_call(method_name, node); end
-  def message(method_name); end
-end
-
-RuboCop::Cop::Style::SignalException::FAIL_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::SignalException::RAISE_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::SignalException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::SingleArgumentDig < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def single_argument_dig?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Style::SingleArgumentDig::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::SingleArgumentDig::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::SingleLineBlockParams < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-
-  private
-
-  def args_match?(method_name, args); end
-  def autocorrect(corrector, node, preferred_block_arguments, joined_block_arguments); end
-  def build_preferred_arguments_map(node, preferred_arguments); end
-  def eligible_arguments?(node); end
-  def eligible_method?(node); end
-  def method_name(method); end
-  def method_names; end
-  def methods; end
-  def target_args(method_name); end
-end
-
-RuboCop::Cop::Style::SingleLineBlockParams::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::SingleLineMethods < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def allow_empty?; end
-  def autocorrect(corrector, node); end
-  def break_line_before(corrector, node, range, indent_steps: T.unsafe(nil)); end
-  def correct_to_endless(corrector, node); end
-  def correct_to_endless?(body_node); end
-  def correct_to_multiline(corrector, node); end
-  def disallow_endless_method_style?; end
-  def each_part(body); end
-  def method_body_source(method_body); end
-  def move_comment(node, corrector); end
-  def require_parentheses?(method_body); end
-end
-
-RuboCop::Cop::Style::SingleLineMethods::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::SingleLineMethods::NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::SlicingWithRange < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_send(node); end
-  def range_till_minus_one?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Style::SlicingWithRange::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::SlicingWithRange::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::SoleNestedConditional < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-
-  private
-
-  def allow_modifier?; end
-  def arguments_range(node); end
-  def assigned_variables(condition); end
-  def autocorrect(corrector, node, if_branch); end
-  def autocorrect_outer_condition_basic(corrector, node, if_branch); end
-  def autocorrect_outer_condition_modify_form(corrector, node, if_branch); end
-  def correct_for_basic_condition_style(corrector, node, if_branch, and_operator); end
-  def correct_for_comment(corrector, node, if_branch); end
-  def correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator); end
-  def correct_for_outer_condition_modify_form_style(corrector, node, if_branch); end
-  def correct_from_unless_to_if(corrector, node, is_modify_form: T.unsafe(nil)); end
-  def correct_outer_condition(corrector, condition); end
-  def insert_bang(corrector, node, is_modify_form); end
-  def insert_bang_for_and(corrector, node); end
-  def offending_branch?(node, branch); end
-  def outer_condition_modify_form?(node, if_branch); end
-  def replace_condition(condition); end
-  def require_parentheses?(condition); end
-  def use_variable_assignment_in_condition?(condition, if_branch); end
-  def wrap_condition?(node); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Style::SoleNestedConditional::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::SpecialGlobalVars < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::RequireLibrary
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def autocorrect(corrector, node, global_var); end
-  def message(global_var); end
-  def on_gvar(node); end
-  def on_new_investigation; end
-
-  private
-
-  def add_require_english?; end
-  def english_name_replacement(preferred_name, node); end
-  def format_english_message(global_var); end
-  def format_list(items); end
-  def format_message(english, regular, global); end
-  def matching_styles(global); end
-  def preferred_names(global); end
-  def replacement(node, global_var); end
-  def should_require_english?(global_var); end
-end
-
-RuboCop::Cop::Style::SpecialGlobalVars::BUILTIN_VARS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Style::SpecialGlobalVars::ENGLISH_VARS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Style::SpecialGlobalVars::LIBRARY_NAME = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::SpecialGlobalVars::MSG_BOTH = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::SpecialGlobalVars::MSG_ENGLISH = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::SpecialGlobalVars::MSG_REGULAR = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::SpecialGlobalVars::NON_ENGLISH_VARS = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Style::SpecialGlobalVars::PERL_VARS = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::Style::SpecialGlobalVars::STYLE_VARS_MAP = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Cop::Style::StabbyLambdaParentheses < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-
-  private
-
-  def message(_node); end
-  def missing_parentheses?(node); end
-  def missing_parentheses_corrector(corrector, node); end
-  def parentheses?(node); end
-  def redundant_parentheses?(node); end
-  def stabby_lambda_with_args?(node); end
-  def unwanted_parentheses_corrector(corrector, node); end
-end
-
-RuboCop::Cop::Style::StabbyLambdaParentheses::MSG_NO_REQUIRE = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::StabbyLambdaParentheses::MSG_REQUIRE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::StaticClass < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::VisibilityHelp
-
-  def on_class(class_node); end
-
-  private
-
-  def class_convertible_to_module?(class_node); end
-  def class_elements(class_node); end
-  def extend_call?(node); end
-  def sclass_convertible_to_module?(node); end
-end
-
-RuboCop::Cop::Style::StaticClass::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::StderrPuts < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-  def stderr_puts?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def message(node); end
-  def stderr_gvar?(sym); end
-  def stderr_puts_range(send); end
-end
-
-RuboCop::Cop::Style::StderrPuts::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::StderrPuts::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::StringChars < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_send(node); end
-end
-
-RuboCop::Cop::Style::StringChars::BAD_ARGUMENTS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::StringChars::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::StringChars::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::StringConcatenation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_new_investigation; end
-  def on_send(node); end
-  def string_concatenation?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def collect_parts(node, parts = T.unsafe(nil)); end
-  def corrected_ancestor?(node); end
-  def find_topmost_plus_node(node); end
-  def handle_quotes(parts); end
-  def heredoc?(node); end
-  def line_end_concatenation?(node); end
-  def mode; end
-  def plus_node?(node); end
-  def register_offense(topmost_plus_node, parts); end
-  def replacement(parts); end
-  def single_quoted?(str_node); end
-  def uncorrectable?(part); end
-end
-
-RuboCop::Cop::Style::StringConcatenation::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::StringConcatenation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::StringHashKeys < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_pair(node); end
-  def receive_environments_method?(param0 = T.unsafe(nil)); end
-  def string_hash_key?(param0 = T.unsafe(nil)); end
-end
-
-RuboCop::Cop::Style::StringHashKeys::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::StringLiterals < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::StringLiteralsHelp
-  include ::RuboCop::Cop::StringHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_dstr(node); end
-
-  private
-
-  def accept_child_double_quotes?(nodes); end
-  def all_string_literals?(nodes); end
-  def autocorrect(corrector, node); end
-  def check_multiline_quote_style(node, quote); end
-  def consistent_multiline?; end
-  def detect_quote_styles(node); end
-  def message(_node); end
-  def offense?(node); end
-  def register_offense(node, message: T.unsafe(nil)); end
-  def unexpected_double_quotes?(quote); end
-  def unexpected_single_quotes?(quote); end
-end
-
-RuboCop::Cop::Style::StringLiterals::MSG_INCONSISTENT = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::StringLiteralsInInterpolation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::StringLiteralsHelp
-  include ::RuboCop::Cop::StringHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def autocorrect(corrector, node); end
-
-  private
-
-  def message(_node); end
-  def offense?(node); end
-end
-
-class RuboCop::Cop::Style::StringMethods < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::MethodPreference
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Style::StringMethods::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::Strip < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def lstrip_rstrip(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-end
-
-RuboCop::Cop::Style::Strip::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::Strip::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::StructInheritance < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_class(node); end
-  def struct_constructor?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def correct_parent(parent, corrector); end
-  def range_for_empty_class_body(class_node, struct_new); end
-end
-
-RuboCop::Cop::Style::StructInheritance::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::SwapValues < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_asgn(node); end
-  def on_casgn(node); end
-  def on_cvasgn(node); end
-  def on_gvasgn(node); end
-  def on_ivasgn(node); end
-  def on_lvasgn(node); end
-
-  private
-
-  def allowed_assignment?(node); end
-  def correction_range(tmp_assign, y_assign); end
-  def lhs(node); end
-  def message(x_assign, y_assign); end
-  def replacement(x_assign); end
-  def rhs(node); end
-  def simple_assignment?(node); end
-  def swapping_values?(tmp_assign, x_assign, y_assign); end
-end
-
-RuboCop::Cop::Style::SwapValues::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::SwapValues::SIMPLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Set)
-
-class RuboCop::Cop::Style::SymbolArray < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ArrayMinSize
-  include ::RuboCop::Cop::ArraySyntax
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::PercentArray
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_array(node); end
-
-  private
-
-  def build_bracketed_array(node); end
-  def symbol_without_quote?(string); end
-  def symbols_contain_spaces?(node); end
-  def to_symbol_literal(string); end
-
-  class << self
-    def largest_brackets; end
-    def largest_brackets=(_arg0); end
-  end
-end
-
-RuboCop::Cop::Style::SymbolArray::ARRAY_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::SymbolArray::PERCENT_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::SymbolLiteral < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_sym(node); end
-end
-
-RuboCop::Cop::Style::SymbolLiteral::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::SymbolProc < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::CommentsHelp
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::IgnoredMethods
-  extend ::RuboCop::Cop::IgnoredMethods::Config
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def destructuring_block_argument?(argument_node); end
-  def on_block(node); end
-  def on_numblock(node); end
-  def proc_node?(param0 = T.unsafe(nil)); end
-  def symbol_proc?(param0 = T.unsafe(nil)); end
-  def symbol_proc_receiver?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def allow_comments?; end
-  def allow_if_method_has_argument?(send_node); end
-  def autocorrect(corrector, node); end
-  def autocorrect_with_args(corrector, node, args, method_name); end
-  def autocorrect_without_args(corrector, node); end
-  def begin_pos_for_replacement(node); end
-  def block_range_with_space(node); end
-  def register_offense(node, method_name, block_method_name); end
-
-  class << self
-    def autocorrect_incompatible_with; end
-  end
-end
-
-RuboCop::Cop::Style::SymbolProc::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::SymbolProc::SUPER_TYPES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::TernaryCorrector
-  extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper
-  extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper
-
-  class << self
-    def correct(corrector, node); end
-    def move_assignment_inside_condition(corrector, node); end
-
-    private
-
-    def correction(node); end
-    def element_assignment?(node); end
-    def extract_branches(node); end
-    def move_branch_inside_condition(corrector, branch, assignment); end
-    def remove_parentheses(corrector, node); end
-    def ternary(node); end
-  end
-end
-
-class RuboCop::Cop::Style::TernaryParentheses < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::SafeAssignment
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::SurroundingSpace
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def method_name(param0 = T.unsafe(nil)); end
-  def on_if(node); end
-
-  private
-
-  def autocorrect(corrector, node); end
-  def below_ternary_precedence?(child); end
-  def complex_condition?(condition); end
-  def condition_as_parenthesized_one_line_pattern_matching?(condition); end
-  def correct_parenthesized(corrector, condition); end
-  def correct_unparenthesized(corrector, condition); end
-  def infinite_loop?; end
-  def message(node); end
-  def non_complex_expression?(condition); end
-  def non_complex_send?(node); end
-  def offense?(node); end
-  def only_closing_parenthesis_is_last_line?(condition); end
-  def parenthesized?(node); end
-  def redundant_parentheses_enabled?; end
-  def require_parentheses?; end
-  def require_parentheses_when_complex?; end
-  def unparenthesized_method_call?(child); end
-  def unsafe_autocorrect?(condition); end
-  def whitespace_after?(node); end
-end
-
-RuboCop::Cop::Style::TernaryParentheses::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::TernaryParentheses::MSG_COMPLEX = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::TernaryParentheses::NON_COMPLEX_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::TernaryParentheses::VARIABLE_TYPES = T.let(T.unsafe(nil), Set)
-
-class RuboCop::Cop::Style::TopLevelMethodDefinition < ::RuboCop::Cop::Base
-  def define_method_block?(param0 = T.unsafe(nil)); end
-  def on_block(node); end
-  def on_def(node); end
-  def on_defs(node); end
-  def on_send(node); end
-
-  private
-
-  def top_level_method_definition?(node); end
-end
-
-RuboCop::Cop::Style::TopLevelMethodDefinition::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::TopLevelMethodDefinition::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::TrailingBodyOnClass < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::TrailingBody
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_class(node); end
-end
-
-RuboCop::Cop::Style::TrailingBodyOnClass::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::TrailingBody
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-  def on_defs(node); end
-end
-
-RuboCop::Cop::Style::TrailingBodyOnMethodDefinition::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::TrailingBodyOnModule < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Alignment
-  include ::RuboCop::Cop::TrailingBody
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_module(node); end
-end
-
-RuboCop::Cop::Style::TrailingBodyOnModule::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::TrailingCommaInArguments < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::TrailingComma
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_csend(node); end
-  def on_send(node); end
-end
-
-class RuboCop::Cop::Style::TrailingCommaInArrayLiteral < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::TrailingComma
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_array(node); end
-end
-
-class RuboCop::Cop::Style::TrailingCommaInBlockArgs < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_block(node); end
-
-  private
-
-  def arg_count(node); end
-  def argument_tokens(node); end
-  def last_comma(node); end
-  def trailing_comma?(node); end
-  def useless_trailing_comma?(node); end
-end
-
-RuboCop::Cop::Style::TrailingCommaInBlockArgs::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::TrailingCommaInHashLiteral < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::TrailingComma
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_hash(node); end
-end
-
-class RuboCop::Cop::Style::TrailingMethodEndStatement < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_def(node); end
-
-  private
-
-  def body_and_end_on_same_line?(node); end
-  def trailing_end?(node); end
-end
-
-RuboCop::Cop::Style::TrailingMethodEndStatement::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::TrailingUnderscoreVariable < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  include ::RuboCop::Cop::SurroundingSpace
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_masgn(node); end
-
-  private
-
-  def allow_named_underscore_variables; end
-  def children_offenses(variables); end
-  def find_first_offense(variables); end
-  def find_first_possible_offense(variables); end
-  def main_node_offense(node); end
-  def range_for_parentheses(offense, left); end
-  def reverse_index(collection, item); end
-  def splat_variable_before?(first_offense, variables); end
-  def unneeded_ranges(node); end
-  def unused_range(node_type, mlhs_node, right); end
-  def unused_variables_only?(offense, variables); end
-end
-
-RuboCop::Cop::Style::TrailingUnderscoreVariable::DISALLOW = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::TrailingUnderscoreVariable::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::TrailingUnderscoreVariable::UNDERSCORE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::TrivialAccessors < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::AllowedMethods
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def looks_like_trivial_writer?(param0 = T.unsafe(nil)); end
-  def on_def(node); end
-  def on_defs(node); end
-
-  private
-
-  def accessor(kind, method_name); end
-  def allow_dsl_writers?; end
-  def allow_predicates?; end
-  def allowed_method_name?(node); end
-  def allowed_method_names; end
-  def allowed_reader?(node); end
-  def allowed_writer?(node); end
-  def autocorrect(corrector, node); end
-  def autocorrect_class(corrector, node); end
-  def autocorrect_instance(corrector, node); end
-  def dsl_writer?(node); end
-  def exact_name_match?; end
-  def ignore_class_methods?; end
-  def in_module_or_instance_eval?(node); end
-  def looks_like_trivial_reader?(node); end
-  def names_match?(node); end
-  def on_method_def(node); end
-  def top_level_node?(node); end
-  def trivial_accessor_kind(node); end
-  def trivial_reader?(node); end
-  def trivial_writer?(node); end
-end
-
-RuboCop::Cop::Style::TrivialAccessors::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::UnlessElse < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_if(node); end
-  def range_between_condition_and_else(node, condition); end
-  def range_between_else_and_end(node); end
-end
-
-RuboCop::Cop::Style::UnlessElse::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::UnlessLogicalOperators < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-
-  def and_with_or?(param0 = T.unsafe(nil)); end
-  def logical_operator?(param0 = T.unsafe(nil)); end
-  def on_if(node); end
-  def or_with_and?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def mixed_logical_operator?(node); end
-  def mixed_precedence_and?(node); end
-  def mixed_precedence_or?(node); end
-end
-
-RuboCop::Cop::Style::UnlessLogicalOperators::FORBID_LOGICAL_OPERATORS = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::UnlessLogicalOperators::FORBID_MIXED_LOGICAL_OPERATORS = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::UnpackFirst < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-  extend ::RuboCop::Cop::TargetRubyVersion
-
-  def on_send(node); end
-  def unpack_and_first_element?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def first_element_range(node, unpack_call); end
-end
-
-RuboCop::Cop::Style::UnpackFirst::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::UnpackFirst::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::Style::VariableInterpolation < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::Interpolation
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_node_with_interpolations(node); end
-
-  private
-
-  def message(range); end
-  def var_nodes(nodes); end
-end
-
-RuboCop::Cop::Style::VariableInterpolation::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::WhenThen < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_when(node); end
-end
-
-RuboCop::Cop::Style::WhenThen::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::WhileUntilDo < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_until(node); end
-  def on_while(node); end
-end
-
-RuboCop::Cop::Style::WhileUntilDo::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::WhileUntilModifier < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::LineLengthHelp
-  include ::RuboCop::Cop::StatementModifier
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_until(node); end
-  def on_while(node); end
-end
-
-RuboCop::Cop::Style::WhileUntilModifier::MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::WordArray < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ArrayMinSize
-  include ::RuboCop::Cop::ArraySyntax
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::PercentArray
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def on_array(node); end
-
-  private
-
-  def build_bracketed_array(node); end
-  def complex_content?(strings, complex_regex: T.unsafe(nil)); end
-  def invalid_percent_array_contents?(node); end
-  def word_regex; end
-
-  class << self
-    def largest_brackets; end
-    def largest_brackets=(_arg0); end
-  end
-end
-
-RuboCop::Cop::Style::WordArray::ARRAY_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::WordArray::PERCENT_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::Style::YodaCondition < ::RuboCop::Cop::Base
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def file_constant_equal_program_name?(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-
-  private
-
-  def actual_code_range(node); end
-  def corrected_code(node); end
-  def enforce_yoda?; end
-  def equality_only?; end
-  def interpolation?(node); end
-  def message(node); end
-  def non_equality_operator?(node); end
-  def noncommutative_operator?(node); end
-  def program_name?(name); end
-  def reverse_comparison(operator); end
-  def source_file_path_constant?(node); end
-  def valid_yoda?(node); end
-  def yoda_compatible_condition?(node); end
-end
-
-RuboCop::Cop::Style::YodaCondition::EQUALITY_OPERATORS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::YodaCondition::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::YodaCondition::NONCOMMUTATIVE_OPERATORS = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::YodaCondition::PROGRAM_NAMES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::YodaCondition::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
-RuboCop::Cop::Style::YodaCondition::REVERSE_COMPARISON = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Cop::Style::ZeroLengthPredicate < ::RuboCop::Cop::Base
-  extend ::RuboCop::Cop::AutoCorrector
-
-  def non_polymorphic_collection?(param0 = T.unsafe(nil)); end
-  def nonzero_length_predicate(param0 = T.unsafe(nil)); end
-  def on_send(node); end
-  def other_receiver(param0 = T.unsafe(nil)); end
-  def zero_length_predicate(param0 = T.unsafe(nil)); end
-  def zero_length_receiver(param0 = T.unsafe(nil)); end
-
-  private
-
-  def check_nonzero_length_predicate(node); end
-  def check_zero_length_predicate(node); end
-  def replacement(node); end
-end
-
-RuboCop::Cop::Style::ZeroLengthPredicate::NONZERO_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::Style::ZeroLengthPredicate::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::Style::ZeroLengthPredicate::ZERO_MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::SurroundingSpace
-  include ::RuboCop::Cop::RangeHelp
-
-  private
-
-  def empty_brackets?(left_bracket_token, right_bracket_token); end
-  def empty_offense(node, range, message, command); end
-  def empty_offenses(node, left, right, message); end
-  def extra_space?(token, side); end
-  def no_space_between?(left_bracket_token, right_bracket_token); end
-  def no_space_offenses(node, left_token, right_token, message, start_ok: T.unsafe(nil), end_ok: T.unsafe(nil)); end
-  def offending_empty_no_space?(config, left_token, right_token); end
-  def offending_empty_space?(config, left_token, right_token); end
-  def on_new_investigation; end
-  def reposition(src, pos, step); end
-  def side_space_range(range:, side:); end
-  def space_between?(left_bracket_token, right_bracket_token); end
-  def space_offense(node, token, side, message, command); end
-  def space_offenses(node, left_token, right_token, message, start_ok: T.unsafe(nil), end_ok: T.unsafe(nil)); end
-end
-
-RuboCop::Cop::SurroundingSpace::NO_SPACE_COMMAND = T.let(T.unsafe(nil), String)
-RuboCop::Cop::SurroundingSpace::SINGLE_SPACE_REGEXP = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::SurroundingSpace::SPACE_COMMAND = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::SymbolHelp
-  def hash_key?(node); end
-end
-
-module RuboCop::Cop::TargetRubyVersion
-  def minimum_target_ruby_version(version); end
-  def required_minimum_ruby_version; end
-  def support_target_ruby_version?(version); end
-end
-
-class RuboCop::Cop::Team
-  def initialize(cops, config = T.unsafe(nil), options = T.unsafe(nil)); end
-
-  def autocorrect?; end
-  def cops; end
-  def debug?; end
-  def errors; end
-  def external_dependency_checksum; end
-  def forces; end
-  def inspect_file(processed_source); end
-  def investigate(processed_source); end
-  def updated_source_file; end
-  def updated_source_file?; end
-  def warnings; end
-
-  private
-
-  def autocorrect(processed_source, report); end
-  def autocorrect_report(report); end
-  def be_ready; end
-  def collate_corrections(report); end
-  def each_corrector(report); end
-  def handle_error(error, location, cop); end
-  def handle_warning(error, location); end
-  def investigate_partial(cops, processed_source); end
-  def process_errors(file, errors); end
-  def reset; end
-  def roundup_relevant_cops(filename); end
-  def support_target_rails_version?(cop); end
-  def support_target_ruby_version?(cop); end
-  def suppress_clobbering; end
-  def validate_config; end
-
-  class << self
-    def forces_for(cops); end
-    def mobilize(cop_classes, config, options = T.unsafe(nil)); end
-    def mobilize_cops(cop_classes, config, options = T.unsafe(nil)); end
-    def new(cop_or_classes, config, options = T.unsafe(nil)); end
-  end
-end
-
-module RuboCop::Cop::TrailingBody
-  def body_on_first_line?(node, body); end
-  def first_part_of(body); end
-  def trailing_body?(node); end
-end
-
-module RuboCop::Cop::TrailingComma
-  include ::RuboCop::Cop::ConfigurableEnforcedStyle
-  include ::RuboCop::Cop::RangeHelp
-
-  private
-
-  def allowed_multiline_argument?(node); end
-  def any_heredoc?(items); end
-  def autocorrect_range(item); end
-  def avoid_comma(kind, comma_begin_pos, extra_info); end
-  def brackets?(node); end
-  def check(node, items, kind, begin_pos, end_pos); end
-  def check_comma(node, kind, comma_pos); end
-  def check_literal(node, kind); end
-  def comma_offset(items, range); end
-  def elements(node); end
-  def extra_avoid_comma_info; end
-  def heredoc?(node); end
-  def heredoc_send?(node); end
-  def inside_comment?(range, comma_offset); end
-  def method_name_and_arguments_on_same_line?(node); end
-  def multiline?(node); end
-  def no_elements_on_same_line?(node); end
-  def on_same_line?(range1, range2); end
-  def put_comma(items, kind); end
-  def should_have_comma?(style, node); end
-  def style_parameter_name; end
-end
-
-RuboCop::Cop::TrailingComma::MSG = T.let(T.unsafe(nil), String)
-
-module RuboCop::Cop::UncommunicativeName
-  def check(node, args); end
-
-  private
-
-  def allow_nums; end
-  def allowed_names; end
-  def arg_range(arg, length); end
-  def case_offense(node, range); end
-  def ends_with_num?(name); end
-  def forbidden_names; end
-  def forbidden_offense(node, range, name); end
-  def issue_offenses(node, range, name); end
-  def length_offense(node, range); end
-  def long_enough?(name); end
-  def min_length; end
-  def name_type(node); end
-  def num_offense(node, range); end
-  def uppercase?(name); end
-end
-
-RuboCop::Cop::UncommunicativeName::CASE_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::UncommunicativeName::FORBIDDEN_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::UncommunicativeName::LENGTH_MSG = T.let(T.unsafe(nil), String)
-RuboCop::Cop::UncommunicativeName::NUM_MSG = T.let(T.unsafe(nil), String)
-
-class RuboCop::Cop::UnusedArgCorrector
-  extend ::RuboCop::Cop::RangeHelp
-
-  class << self
-    def correct(corrector, processed_source, node); end
-    def correct_for_blockarg_type(corrector, node); end
-    def processed_source; end
-  end
-end
-
-module RuboCop::Cop::Util
-  include ::RuboCop::PathUtil
-
-  private
-
-  def add_parentheses(node, corrector); end
-  def args_begin(node); end
-  def args_end(node); end
-  def begins_its_line?(range); end
-  def comment_line?(line_source); end
-  def comment_lines?(node); end
-  def compatible_external_encoding_for?(src); end
-  def double_quotes_required?(string); end
-  def escape_string(string); end
-  def first_part_of_call_chain(node); end
-  def indent(node, offset: T.unsafe(nil)); end
-  def interpret_string_escapes(string); end
-  def line(node_or_range); end
-  def line_range(node); end
-  def needs_escaping?(string); end
-  def on_node(syms, sexp, excludes = T.unsafe(nil), &block); end
-  def parentheses?(node); end
-  def same_line?(node1, node2); end
-  def to_string_literal(string); end
-  def to_supported_styles(enforced_style); end
-  def trim_string_interporation_escape_character(str); end
-
-  class << self
-    def add_parentheses(node, corrector); end
-    def args_begin(node); end
-    def args_end(node); end
-    def begins_its_line?(range); end
-    def comment_line?(line_source); end
-    def comment_lines?(node); end
-    def double_quotes_required?(string); end
-    def escape_string(string); end
-    def first_part_of_call_chain(node); end
-    def indent(node, offset: T.unsafe(nil)); end
-    def interpret_string_escapes(string); end
-    def line(node_or_range); end
-    def line_range(node); end
-    def needs_escaping?(string); end
-    def on_node(syms, sexp, excludes = T.unsafe(nil), &block); end
-    def parentheses?(node); end
-    def same_line?(node1, node2); end
-    def to_string_literal(string); end
-    def to_supported_styles(enforced_style); end
-    def trim_string_interporation_escape_character(str); end
-  end
-end
-
-RuboCop::Cop::Util::LITERAL_REGEX = T.let(T.unsafe(nil), Regexp)
-module RuboCop::Cop::Utils; end
-
-class RuboCop::Cop::Utils::FormatString
-  def initialize(string); end
-
-  def format_sequences; end
-  def max_digit_dollar_num; end
-  def named_interpolation?; end
-  def valid?; end
-
-  private
-
-  def mixed_formats?; end
-  def parse; end
-end
-
-RuboCop::Cop::Utils::FormatString::DIGIT_DOLLAR = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Utils::FormatString::FLAG = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::Utils::FormatString::FormatSequence
-  def initialize(match); end
-
-  def annotated?; end
-  def arity; end
-  def begin_pos; end
-  def end_pos; end
-  def flags; end
-  def max_digit_dollar_num; end
-  def name; end
-  def percent?; end
-  def precision; end
-  def style; end
-  def template?; end
-  def type; end
-  def width; end
-end
-
-RuboCop::Cop::Utils::FormatString::NAME = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Utils::FormatString::NUMBER = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Utils::FormatString::NUMBER_ARG = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Utils::FormatString::PRECISION = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Utils::FormatString::SEQUENCE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Utils::FormatString::TEMPLATE_NAME = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Utils::FormatString::TYPE = T.let(T.unsafe(nil), Regexp)
-RuboCop::Cop::Utils::FormatString::WIDTH = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::Cop::VariableForce < ::RuboCop::Cop::Force
-  def investigate(processed_source); end
-  def process_node(node); end
-  def variable_table; end
-
-  private
-
-  def after_declaring_variable(arg); end
-  def after_entering_scope(arg); end
-  def after_leaving_scope(arg); end
-  def before_declaring_variable(arg); end
-  def before_entering_scope(arg); end
-  def before_leaving_scope(arg); end
-  def descendant_reference(node); end
-  def each_descendant_reference(loop_node); end
-  def find_variables_in_loop(loop_node); end
-  def inspect_variables_in_scope(scope_node); end
-  def mark_assignments_as_referenced_in_loop(node); end
-  def node_handler_method_name(node); end
-  def process_children(origin_node); end
-  def process_loop(node); end
-  def process_regexp_named_captures(node); end
-  def process_rescue(node); end
-  def process_scope(node); end
-  def process_send(node); end
-  def process_variable_assignment(node); end
-  def process_variable_declaration(node); end
-  def process_variable_multiple_assignment(node); end
-  def process_variable_operator_assignment(node); end
-  def process_variable_referencing(node); end
-  def process_zero_arity_super(node); end
-  def regexp_captured_names(node); end
-  def scanned_node?(node); end
-  def scanned_nodes; end
-  def skip_children!; end
-  def twisted_nodes(node); end
-end
-
-RuboCop::Cop::VariableForce::ARGUMENT_DECLARATION_TYPES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::VariableForce::Assignment
-  include ::RuboCop::Cop::VariableForce::Branchable
-
-  def initialize(node, variable); end
-
-  def meta_assignment_node; end
-  def multiple_assignment?; end
-  def name; end
-  def node; end
-  def operator; end
-  def operator_assignment?; end
-  def reference!(node); end
-  def referenced; end
-  def referenced?; end
-  def references; end
-  def regexp_named_capture?; end
-  def scope; end
-  def used?; end
-  def variable; end
-
-  private
-
-  def multiple_assignment_node; end
-  def operator_assignment_node; end
-end
-
-RuboCop::Cop::VariableForce::Assignment::MULTIPLE_LEFT_HAND_SIDE_TYPE = T.let(T.unsafe(nil), Symbol)
-
-class RuboCop::Cop::VariableForce::AssignmentReference < ::Struct
-  def assignment?; end
-  def node; end
-  def node=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-module RuboCop::Cop::VariableForce::Branch
-  class << self
-    def of(target_node, scope: T.unsafe(nil)); end
-  end
-end
-
-class RuboCop::Cop::VariableForce::Branch::And < ::RuboCop::Cop::VariableForce::Branch::Base
-  include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator
-
-  def left_body?; end
-  def right_body?; end
-end
-
-class RuboCop::Cop::VariableForce::Branch::Base < ::Struct
-  def ==(other); end
-  def always_run?; end
-  def branched?; end
-  def child_node; end
-  def child_node=(_); end
-  def control_node; end
-  def each_ancestor(include_self: T.unsafe(nil), &block); end
-  def eql?(other); end
-  def exclusive_with?(other); end
-  def hash; end
-  def may_jump_to_other_branch?; end
-  def may_run_incompletely?; end
-  def parent; end
-  def scope; end
-  def scope=(_); end
-
-  private
-
-  def scan_ancestors; end
-
-  class << self
-    def [](*_arg0); end
-    def classes; end
-    def define_predicate(name, child_index: T.unsafe(nil)); end
-    def inherited(subclass); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-    def type; end
-  end
-end
-
-RuboCop::Cop::VariableForce::Branch::CLASSES_BY_TYPE = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Cop::VariableForce::Branch::Case < ::RuboCop::Cop::VariableForce::Branch::Base
-  def always_run?; end
-  def else_body?; end
-  def target?; end
-  def when_clause?; end
-end
-
-class RuboCop::Cop::VariableForce::Branch::CaseMatch < ::RuboCop::Cop::VariableForce::Branch::Base
-  def always_run?; end
-  def else_body?; end
-  def in_pattern?; end
-  def target?; end
-end
-
-class RuboCop::Cop::VariableForce::Branch::Ensure < ::RuboCop::Cop::VariableForce::Branch::Base
-  include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler
-
-  def always_run?; end
-  def ensure_body?; end
-  def main_body?; end
-end
-
-module RuboCop::Cop::VariableForce::Branch::ExceptionHandler
-  def may_jump_to_other_branch?; end
-  def may_run_incompletely?; end
-end
-
-class RuboCop::Cop::VariableForce::Branch::For < ::RuboCop::Cop::VariableForce::Branch::Base
-  def always_run?; end
-  def collection?; end
-  def element?; end
-  def loop_body?; end
-end
-
-class RuboCop::Cop::VariableForce::Branch::If < ::RuboCop::Cop::VariableForce::Branch::Base
-  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
-
-  def conditional_clause?; end
-  def falsey_body?; end
-  def truthy_body?; end
-end
-
-module RuboCop::Cop::VariableForce::Branch::LogicalOperator
-  def always_run?; end
-end
-
-class RuboCop::Cop::VariableForce::Branch::Or < ::RuboCop::Cop::VariableForce::Branch::Base
-  include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator
-
-  def left_body?; end
-  def right_body?; end
-end
-
-class RuboCop::Cop::VariableForce::Branch::Rescue < ::RuboCop::Cop::VariableForce::Branch::Base
-  include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler
-
-  def always_run?; end
-  def else_body?; end
-  def main_body?; end
-  def rescue_clause?; end
-end
-
-module RuboCop::Cop::VariableForce::Branch::SimpleConditional
-  def always_run?; end
-  def conditional_clause?; end
-end
-
-class RuboCop::Cop::VariableForce::Branch::Until < ::RuboCop::Cop::VariableForce::Branch::Base
-  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
-
-  def conditional_clause?; end
-  def loop_body?; end
-end
-
-class RuboCop::Cop::VariableForce::Branch::UntilPost < ::RuboCop::Cop::VariableForce::Branch::Base
-  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
-
-  def conditional_clause?; end
-  def loop_body?; end
-end
-
-class RuboCop::Cop::VariableForce::Branch::While < ::RuboCop::Cop::VariableForce::Branch::Base
-  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
-
-  def conditional_clause?; end
-  def loop_body?; end
-end
-
-class RuboCop::Cop::VariableForce::Branch::WhilePost < ::RuboCop::Cop::VariableForce::Branch::Base
-  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
-
-  def conditional_clause?; end
-  def loop_body?; end
-end
-
-module RuboCop::Cop::VariableForce::Branchable
-  def branch; end
-  def run_exclusively_with?(other); end
-end
-
-RuboCop::Cop::VariableForce::LOGICAL_OPERATOR_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::VariableForce::LOOP_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::VariableForce::MULTIPLE_ASSIGNMENT_TYPE = T.let(T.unsafe(nil), Symbol)
-RuboCop::Cop::VariableForce::OPERATOR_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::VariableForce::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::VariableForce::REGEXP_NAMED_CAPTURE_TYPE = T.let(T.unsafe(nil), Symbol)
-RuboCop::Cop::VariableForce::RESCUE_TYPE = T.let(T.unsafe(nil), Symbol)
-
-class RuboCop::Cop::VariableForce::Reference
-  include ::RuboCop::Cop::VariableForce::Branchable
-
-  def initialize(node, scope); end
-
-  def explicit?; end
-  def node; end
-  def scope; end
-end
-
-RuboCop::Cop::VariableForce::Reference::VARIABLE_REFERENCE_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::VariableForce::SCOPE_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::VariableForce::SEND_TYPE = T.let(T.unsafe(nil), Symbol)
-
-class RuboCop::Cop::VariableForce::Scope
-  def initialize(node); end
-
-  def ==(other); end
-  def body_node; end
-  def each_node(&block); end
-  def include?(target_node); end
-  def naked_top_level; end
-  def naked_top_level?; end
-  def name; end
-  def node; end
-  def variables; end
-
-  private
-
-  def ancestor_node?(target_node); end
-  def belong_to_inner_scope?(target_node); end
-  def belong_to_outer_scope?(target_node); end
-  def scan_node(node, &block); end
-end
-
-RuboCop::Cop::VariableForce::Scope::OUTER_SCOPE_CHILD_INDICES = T.let(T.unsafe(nil), Hash)
-RuboCop::Cop::VariableForce::TWISTED_SCOPE_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::VariableForce::VARIABLE_ASSIGNMENT_TYPE = T.let(T.unsafe(nil), Symbol)
-RuboCop::Cop::VariableForce::VARIABLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
-RuboCop::Cop::VariableForce::VARIABLE_REFERENCE_TYPE = T.let(T.unsafe(nil), Symbol)
-
-class RuboCop::Cop::VariableForce::Variable
-  def initialize(name, declaration_node, scope); end
-
-  def argument?; end
-  def assign(node); end
-  def assignments; end
-  def block_argument?; end
-  def capture_with_block!; end
-  def captured_by_block; end
-  def captured_by_block?; end
-  def declaration_node; end
-  def explicit_block_local_variable?; end
-  def in_modifier_if?(assignment); end
-  def keyword_argument?; end
-  def method_argument?; end
-  def name; end
-  def reference!(node); end
-  def referenced?; end
-  def references; end
-  def scope; end
-  def should_be_unused?; end
-  def used?; end
-end
-
-RuboCop::Cop::VariableForce::Variable::VARIABLE_DECLARATION_TYPES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Cop::VariableForce::VariableReference < ::Struct
-  def assignment?; end
-  def name; end
-  def name=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RuboCop::Cop::VariableForce::VariableTable
-  def initialize(hook_receiver = T.unsafe(nil)); end
-
-  def accessible_variables; end
-  def assign_to_variable(name, node); end
-  def current_scope; end
-  def current_scope_level; end
-  def declare_variable(name, node); end
-  def find_variable(name); end
-  def invoke_hook(hook_name, *args); end
-  def pop_scope; end
-  def push_scope(scope_node); end
-  def reference_variable(name, node); end
-  def scope_stack; end
-  def variable_exist?(name); end
-
-  private
-
-  def mark_variable_as_captured_by_block_if_so(variable); end
-end
-
-RuboCop::Cop::VariableForce::ZERO_ARITY_SUPER_TYPE = T.let(T.unsafe(nil), Symbol)
-
-module RuboCop::Cop::VisibilityHelp
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def visibility_block?(param0 = T.unsafe(nil)); end
-
-  private
-
-  def find_visibility_end(node); end
-  def find_visibility_start(node); end
-  def node_visibility(node); end
-end
-
-RuboCop::Cop::VisibilityHelp::VISIBILITY_SCOPES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::DirectiveComment
-  def initialize(comment, cop_registry = T.unsafe(nil)); end
-
-  def all_cops?; end
-  def comment; end
-  def cop_names; end
-  def cop_registry; end
-  def cops; end
-  def department_names; end
-  def directive_count; end
-  def disabled?; end
-  def disabled_all?; end
-  def enabled?; end
-  def enabled_all?; end
-  def in_directive_department?(cop); end
-  def line_number; end
-  def match?(cop_names); end
-  def match_captures; end
-  def mode; end
-  def overridden_by_department?(cop); end
-  def range; end
-  def single_line?; end
-
-  private
-
-  def all_cop_names; end
-  def cop_names_for_department(department); end
-  def department?(name); end
-  def exclude_redundant_directive_cop(cops); end
-  def parsed_cop_names; end
-  def splitted_cops_string; end
-
-  class << self
-    def before_comment(line); end
-  end
-end
-
-RuboCop::DirectiveComment::COPS_PATTERN = T.let(T.unsafe(nil), String)
-RuboCop::DirectiveComment::COP_NAMES_PATTERN = T.let(T.unsafe(nil), String)
-RuboCop::DirectiveComment::COP_NAME_PATTERN = T.let(T.unsafe(nil), String)
-RuboCop::DirectiveComment::DIRECTIVE_COMMENT_REGEXP = T.let(T.unsafe(nil), Regexp)
-RuboCop::DirectiveComment::REDUNDANT_DIRECTIVE_COP = T.let(T.unsafe(nil), String)
-RuboCop::DirectiveComment::REDUNDANT_DIRECTIVE_COP_DEPARTMENT = T.let(T.unsafe(nil), String)
-class RuboCop::Error < ::StandardError; end
-
-class RuboCop::ErrorWithAnalyzedFileLocation < ::RuboCop::Error
-  def initialize(cause:, node:, cop:); end
-
-  def cause; end
-  def column; end
-  def cop; end
-  def line; end
-  def message; end
-end
-
-module RuboCop::ExcludeLimit
-  def exclude_limit(parameter_name, method_name: T.unsafe(nil)); end
-
-  private
-
-  def transform(parameter_name); end
-end
-
-module RuboCop::Ext; end
-
-module RuboCop::Ext::ProcessedSource
-  def comment_config; end
-  def disabled_line_ranges; end
-end
-
-module RuboCop::Ext::RegexpNode
-  def assign_properties(*_arg0); end
-  def each_capture(named: T.unsafe(nil)); end
-  def parsed_tree; end
-
-  private
-
-  def with_interpolations_blanked; end
-end
-
-RuboCop::Ext::RegexpNode::ANY = T.let(T.unsafe(nil), Object)
-module RuboCop::Ext::RegexpParser; end
-module RuboCop::Ext::RegexpParser::Expression; end
-
-module RuboCop::Ext::RegexpParser::Expression::Base
-  def expression; end
-  def loc; end
-  def origin; end
-  def origin=(_arg0); end
-
-  private
-
-  def build_location; end
-end
-
-module RuboCop::Ext::RegexpParser::Expression::CharacterSet
-  def build_location; end
-end
-
-class RuboCop::Ext::RegexpParser::Map < ::Parser::Source::Map
-  def initialize(expression, body:, quantifier: T.unsafe(nil), begin_l: T.unsafe(nil), end_l: T.unsafe(nil)); end
-
-  def begin; end
-  def body; end
-  def end; end
-  def quantifier; end
-end
-
-module RuboCop::FileFinder
-  def find_file_upwards(filename, start_dir, stop_dir = T.unsafe(nil)); end
-  def find_last_file_upwards(filename, start_dir, stop_dir = T.unsafe(nil)); end
-
-  private
-
-  def traverse_files_upwards(filename, start_dir, stop_dir); end
-
-  class << self
-    def root_level=(level); end
-    def root_level?(path, stop_dir); end
-  end
-end
-
-module RuboCop::Formatter; end
-
-class RuboCop::Formatter::AutoGenConfigFormatter < ::RuboCop::Formatter::ProgressFormatter
-  def finished(inspected_files); end
-end
-
-class RuboCop::Formatter::BaseFormatter
-  def initialize(output, options = T.unsafe(nil)); end
-
-  def file_finished(file, offenses); end
-  def file_started(file, options); end
-  def finished(inspected_files); end
-  def options; end
-  def output; end
-  def started(target_files); end
-end
-
-class RuboCop::Formatter::ClangStyleFormatter < ::RuboCop::Formatter::SimpleTextFormatter
-  def report_file(file, offenses); end
-
-  private
-
-  def report_highlighted_area(highlighted_area); end
-  def report_line(location); end
-  def report_offense(file, offense); end
-  def valid_line?(offense); end
-end
-
-RuboCop::Formatter::ClangStyleFormatter::ELLIPSES = T.let(T.unsafe(nil), String)
-
-module RuboCop::Formatter::Colorizable
-  def black(string); end
-  def blue(string); end
-  def colorize(string, *args); end
-  def cyan(string); end
-  def green(string); end
-  def magenta(string); end
-  def rainbow; end
-  def red(string); end
-  def white(string); end
-  def yellow(string); end
-end
-
-class RuboCop::Formatter::DisabledConfigFormatter < ::RuboCop::Formatter::BaseFormatter
-  include ::RuboCop::PathUtil
-
-  def initialize(output, options = T.unsafe(nil)); end
-
-  def file_finished(file, offenses); end
-  def file_started(_file, _file_info); end
-  def finished(_inspected_files); end
-
-  private
-
-  def command; end
-  def cop_config_params(default_cfg, cfg); end
-  def default_config(cop_name); end
-  def excludes(offending_files, cop_name, parent); end
-  def merge_mode_for_exclude?(cfg); end
-  def output_cop(cop_name, offense_count); end
-  def output_cop_comments(output_buffer, cfg, cop_name, offense_count); end
-  def output_cop_config(output_buffer, cfg, cop_name); end
-  def output_cop_param_comments(output_buffer, params, default_cfg); end
-  def output_exclude_list(output_buffer, offending_files, cop_name); end
-  def output_exclude_path(output_buffer, exclude_path, parent); end
-  def output_offending_files(output_buffer, cfg, cop_name); end
-  def output_offenses; end
-  def safe_autocorrect?(config); end
-  def set_max(cfg, cop_name); end
-  def show_offense_counts?; end
-  def show_timestamp?; end
-  def supports_safe_autocorrect?(cop_class, default_cfg); end
-  def supports_unsafe_autocorrect?(cop_class, default_cfg); end
-  def timestamp; end
-
-  class << self
-    def config_to_allow_offenses; end
-    def config_to_allow_offenses=(_arg0); end
-    def detected_styles; end
-    def detected_styles=(_arg0); end
-  end
-end
-
-RuboCop::Formatter::DisabledConfigFormatter::HEADING = T.let(T.unsafe(nil), String)
-
-class RuboCop::Formatter::EmacsStyleFormatter < ::RuboCop::Formatter::BaseFormatter
-  def file_finished(file, offenses); end
-
-  private
-
-  def message(offense); end
-end
-
-class RuboCop::Formatter::FileListFormatter < ::RuboCop::Formatter::BaseFormatter
-  def file_finished(file, offenses); end
-end
-
-class RuboCop::Formatter::FormatterSet < ::Array
-  def initialize(options = T.unsafe(nil)); end
-
-  def add_formatter(formatter_type, output_path = T.unsafe(nil)); end
-  def close_output_files; end
-  def file_finished(file, offenses); end
-  def file_started(file, options); end
-  def finished(*args); end
-  def started(*args); end
-
-  private
-
-  def builtin_formatter_class(specified_key); end
-  def custom_formatter_class(specified_class_name); end
-  def formatter_class(formatter_type); end
-end
-
-RuboCop::Formatter::FormatterSet::BUILTIN_FORMATTERS_FOR_KEYS = T.let(T.unsafe(nil), Hash)
-RuboCop::Formatter::FormatterSet::FORMATTER_APIS = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Formatter::FuubarStyleFormatter < ::RuboCop::Formatter::ClangStyleFormatter
-  def initialize(*output); end
-
-  def count_stats(offenses); end
-  def file_finished(file, offenses); end
-  def progressbar_color; end
-  def started(target_files); end
-  def with_color; end
-end
-
-RuboCop::Formatter::FuubarStyleFormatter::RESET_SEQUENCE = T.let(T.unsafe(nil), String)
-
-class RuboCop::Formatter::GitHubActionsFormatter < ::RuboCop::Formatter::BaseFormatter
-  def file_finished(file, offenses); end
-  def finished(_inspected_files); end
-  def started(_target_files); end
-
-  private
-
-  def github_escape(string); end
-  def github_severity(offense); end
-  def minimum_severity_to_fail; end
-  def report_offense(file, offense); end
-end
-
-RuboCop::Formatter::GitHubActionsFormatter::ESCAPE_MAP = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Formatter::HTMLFormatter < ::RuboCop::Formatter::BaseFormatter
-  def initialize(output, options = T.unsafe(nil)); end
-
-  def file_finished(file, offenses); end
-  def files; end
-  def finished(inspected_files); end
-  def render_html; end
-  def started(target_files); end
-  def summary; end
-end
-
-class RuboCop::Formatter::HTMLFormatter::Color < ::Struct
-  def alpha; end
-  def alpha=(_); end
-  def blue; end
-  def blue=(_); end
-  def fade_out(amount); end
-  def green; end
-  def green=(_); end
-  def red; end
-  def red=(_); end
-  def to_s; end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-RuboCop::Formatter::HTMLFormatter::ELLIPSES = T.let(T.unsafe(nil), String)
-
-class RuboCop::Formatter::HTMLFormatter::ERBContext
-  include ::RuboCop::PathUtil
-  include ::RuboCop::Formatter::TextUtil
-
-  def initialize(files, summary); end
-
-  def base64_encoded_logo_image; end
-  def binding; end
-  def decorated_message(offense); end
-  def escape(string); end
-  def files; end
-  def highlighted_source_line(offense); end
-  def hightlight_source_tag(offense); end
-  def possible_ellipses(location); end
-  def source_after_highlight(offense); end
-  def source_before_highlight(offense); end
-  def summary; end
-end
-
-RuboCop::Formatter::HTMLFormatter::ERBContext::LOGO_IMAGE_PATH = T.let(T.unsafe(nil), String)
-RuboCop::Formatter::HTMLFormatter::ERBContext::SEVERITY_COLORS = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Formatter::HTMLFormatter::FileOffenses < ::Struct
-  def offenses; end
-  def offenses=(_); end
-  def path; end
-  def path=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class RuboCop::Formatter::HTMLFormatter::Summary < ::Struct
-  def inspected_files; end
-  def inspected_files=(_); end
-  def offense_count; end
-  def offense_count=(_); end
-  def target_files; end
-  def target_files=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-RuboCop::Formatter::HTMLFormatter::TEMPLATE_PATH = T.let(T.unsafe(nil), String)
-
-class RuboCop::Formatter::JSONFormatter < ::RuboCop::Formatter::BaseFormatter
-  include ::RuboCop::PathUtil
-
-  def initialize(output, options = T.unsafe(nil)); end
-
-  def file_finished(file, offenses); end
-  def finished(inspected_files); end
-  def hash_for_file(file, offenses); end
-  def hash_for_location(offense); end
-  def hash_for_offense(offense); end
-  def metadata_hash; end
-  def output_hash; end
-  def started(target_files); end
-end
-
-class RuboCop::Formatter::JUnitFormatter < ::RuboCop::Formatter::BaseFormatter
-  def initialize(output, options = T.unsafe(nil)); end
-
-  def add_testcase_element_to_testsuite_element(file, target_offenses, cop); end
-  def classname_attribute_value(file); end
-  def file_finished(file, offenses); end
-  def finished(_inspected_files); end
-  def offenses_for_cop(all_offenses, cop); end
-  def relevant_for_output?(options, target_offenses); end
-
-  private
-
-  def add_failure_to(testcase, offenses, cop_name); end
-  def reset_count; end
-end
-
-class RuboCop::Formatter::MarkdownFormatter < ::RuboCop::Formatter::BaseFormatter
-  include ::RuboCop::Formatter::TextUtil
-  include ::RuboCop::PathUtil
-
-  def initialize(output, options = T.unsafe(nil)); end
-
-  def file_finished(file, offenses); end
-  def files; end
-  def finished(inspected_files); end
-  def started(target_files); end
-  def summary; end
-
-  private
-
-  def possible_ellipses(location); end
-  def render_markdown; end
-  def write_code(offense); end
-  def write_context(offense); end
-  def write_file_messages; end
-  def write_heading(file); end
-end
-
-class RuboCop::Formatter::OffenseCountFormatter < ::RuboCop::Formatter::BaseFormatter
-  def file_finished(_file, offenses); end
-  def finished(_inspected_files); end
-  def offense_counts; end
-  def ordered_offense_counts(offense_counts); end
-  def report_summary(offense_counts); end
-  def started(target_files); end
-  def total_offense_count(offense_counts); end
-end
-
-class RuboCop::Formatter::PacmanFormatter < ::RuboCop::Formatter::ClangStyleFormatter
-  include ::RuboCop::Formatter::TextUtil
-
-  def initialize(output, options = T.unsafe(nil)); end
-
-  def cols; end
-  def file_finished(file, offenses); end
-  def file_started(_file, _options); end
-  def next_step(offenses); end
-  def pacdots(number); end
-  def progress_line; end
-  def progress_line=(_arg0); end
-  def started(target_files); end
-  def step(character); end
-  def update_progress_line; end
-end
-
-RuboCop::Formatter::PacmanFormatter::FALLBACK_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer)
-RuboCop::Formatter::PacmanFormatter::GHOST = T.let(T.unsafe(nil), String)
-RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::NullPresenter)
-RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::NullPresenter)
-
-class RuboCop::Formatter::ProgressFormatter < ::RuboCop::Formatter::ClangStyleFormatter
-  include ::RuboCop::Formatter::TextUtil
-
-  def initialize(output, options = T.unsafe(nil)); end
-
-  def file_finished(file, offenses); end
-  def finished(inspected_files); end
-  def report_file_as_mark(offenses); end
-  def started(target_files); end
-end
-
-RuboCop::Formatter::ProgressFormatter::DOT = T.let(T.unsafe(nil), String)
-
-class RuboCop::Formatter::QuietFormatter < ::RuboCop::Formatter::SimpleTextFormatter
-  def report_summary(file_count, offense_count, correction_count, correctable_count); end
-end
-
-class RuboCop::Formatter::SimpleTextFormatter < ::RuboCop::Formatter::BaseFormatter
-  include ::RuboCop::Formatter::Colorizable
-  include ::RuboCop::PathUtil
-
-  def file_finished(file, offenses); end
-  def finished(inspected_files); end
-  def report_file(file, offenses); end
-  def report_summary(file_count, offense_count, correction_count, correctable_count); end
-  def started(_target_files); end
-
-  private
-
-  def annotate_message(msg); end
-  def colored_severity_code(offense); end
-  def count_stats(offenses); end
-  def message(offense); end
-end
-
-RuboCop::Formatter::SimpleTextFormatter::COLOR_FOR_SEVERITY = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::Formatter::SimpleTextFormatter::Report
-  include ::RuboCop::Formatter::Colorizable
-  include ::RuboCop::Formatter::TextUtil
-
-  def initialize(file_count, offense_count, correction_count, correctable_count, rainbow, safe_autocorrect: T.unsafe(nil)); end
-
-  def summary; end
-
-  private
-
-  def correctable; end
-  def corrections; end
-  def files; end
-  def offenses; end
-  def rainbow; end
-end
-
-class RuboCop::Formatter::TapFormatter < ::RuboCop::Formatter::ClangStyleFormatter
-  def file_finished(file, offenses); end
-  def started(target_files); end
-
-  private
-
-  def annotate_message(msg); end
-  def message(offense); end
-  def report_highlighted_area(highlighted_area); end
-  def report_line(location); end
-  def report_offense(file, offense); end
-end
-
-module RuboCop::Formatter::TextUtil
-  private
-
-  def pluralize(number, thing, options = T.unsafe(nil)); end
-
-  class << self
-    def pluralize(number, thing, options = T.unsafe(nil)); end
-  end
-end
-
-class RuboCop::Formatter::WorstOffendersFormatter < ::RuboCop::Formatter::BaseFormatter
-  def file_finished(file, offenses); end
-  def finished(_inspected_files); end
-  def offense_counts; end
-  def ordered_offense_counts(offense_counts); end
-  def report_summary(offense_counts); end
-  def started(target_files); end
-  def total_offense_count(offense_counts); end
-end
-
-class RuboCop::IncorrectCopNameError < ::StandardError; end
-
-class RuboCop::Lockfile
-  def dependencies; end
-  def gems; end
-  def includes_gem?(name); end
-
-  private
-
-  def parser; end
-end
-
-class RuboCop::MagicComment
-  def initialize(comment); end
-
-  def any?; end
-  def encoding_specified?; end
-  def frozen_string_literal; end
-  def frozen_string_literal?; end
-  def frozen_string_literal_specified?; end
-  def shareable_constant_value; end
-  def shareable_constant_value_specified?; end
-  def typed; end
-  def typed_specified?; end
-  def valid?; end
-  def valid_literal_value?; end
-  def valid_shareable_constant_value?; end
-
-  private
-
-  def extract(pattern); end
-  def specified?(value); end
-
-  class << self
-    def parse(comment); end
-  end
-end
-
-class RuboCop::MagicComment::EditorComment < ::RuboCop::MagicComment
-  def encoding; end
-  def without(type); end
-
-  private
-
-  def match(keyword); end
-  def tokens; end
-end
-
-class RuboCop::MagicComment::EmacsComment < ::RuboCop::MagicComment::EditorComment
-  private
-
-  def extract_frozen_string_literal; end
-  def extract_shareable_constant_value; end
-  def extract_typed; end
-end
-
-RuboCop::MagicComment::EmacsComment::FORMAT = T.let(T.unsafe(nil), String)
-RuboCop::MagicComment::EmacsComment::OPERATOR = T.let(T.unsafe(nil), String)
-RuboCop::MagicComment::EmacsComment::REGEXP = T.let(T.unsafe(nil), Regexp)
-RuboCop::MagicComment::EmacsComment::SEPARATOR = T.let(T.unsafe(nil), String)
-RuboCop::MagicComment::KEYWORDS = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::MagicComment::SimpleComment < ::RuboCop::MagicComment
-  def encoding; end
-  def without(type); end
-
-  private
-
-  def extract_frozen_string_literal; end
-  def extract_shareable_constant_value; end
-  def extract_typed; end
-end
-
-RuboCop::MagicComment::TOKEN = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::MagicComment::VimComment < ::RuboCop::MagicComment::EditorComment
-  def encoding; end
-  def extract_typed; end
-  def frozen_string_literal; end
-  def shareable_constant_value; end
-end
-
-RuboCop::MagicComment::VimComment::FORMAT = T.let(T.unsafe(nil), String)
-RuboCop::MagicComment::VimComment::KEYWORDS = T.let(T.unsafe(nil), Hash)
-RuboCop::MagicComment::VimComment::OPERATOR = T.let(T.unsafe(nil), String)
-RuboCop::MagicComment::VimComment::REGEXP = T.let(T.unsafe(nil), Regexp)
-RuboCop::MagicComment::VimComment::SEPARATOR = T.let(T.unsafe(nil), String)
-
-module RuboCop::NameSimilarity
-  private
-
-  def find_similar_name(target_name, names); end
-  def find_similar_names(target_name, names); end
-
-  class << self
-    def find_similar_name(target_name, names); end
-    def find_similar_names(target_name, names); end
-  end
-end
-
-RuboCop::NodePattern = RuboCop::AST::NodePattern
-class RuboCop::OptionArgumentError < ::StandardError; end
-
-class RuboCop::Options
-  def initialize; end
-
-  def parse(command_line_args); end
-
-  private
-
-  def add_additional_modes(opts); end
-  def add_autocorrection_options(opts); end
-  def add_cache_options(opts); end
-  def add_check_options(opts); end
-  def add_config_generation_options(opts); end
-  def add_cop_selection_csv_option(option, opts); end
-  def add_general_options(opts); end
-  def add_output_options(opts); end
-  def add_server_options(opts); end
-  def add_severity_option(opts); end
-  def args_from_env; end
-  def args_from_file; end
-  def define_options; end
-  def handle_deprecated_option(old_option, new_option); end
-  def long_opt_symbol(args); end
-  def option(opts, *args); end
-  def rainbow; end
-  def require_feature(file); end
-  def section(opts, heading, &_block); end
-end
-
-RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS = T.let(T.unsafe(nil), Integer)
-RuboCop::Options::EXITING_OPTIONS = T.let(T.unsafe(nil), Array)
-RuboCop::Options::E_STDIN_NO_PATH = T.let(T.unsafe(nil), String)
-module RuboCop::OptionsHelp; end
-RuboCop::OptionsHelp::FORMATTER_OPTION_LIST = T.let(T.unsafe(nil), Array)
-RuboCop::OptionsHelp::MAX_EXCL = T.let(T.unsafe(nil), String)
-RuboCop::OptionsHelp::TEXT = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::OptionsValidator
-  def initialize(options); end
-
-  def boolean_or_empty_cache?; end
-  def disable_parallel_when_invalid_option_combo; end
-  def display_only_fail_level_offenses_with_autocorrect?; end
-  def except_syntax?; end
-  def incompatible_options; end
-  def invalid_arguments_for_parallel; end
-  def only_includes_redundant_disable?; end
-  def validate_auto_gen_config; end
-  def validate_autocorrect; end
-  def validate_cache_enabled_for_cache_root; end
-  def validate_compatibility; end
-  def validate_cop_options; end
-  def validate_display_only_correctable_and_autocorrect; end
-  def validate_display_only_failed; end
-  def validate_display_only_failed_and_display_only_correctable; end
-  def validate_exclude_limit_option; end
-
-  class << self
-    def validate_cop_list(names); end
-
-    private
-
-    def format_message_from(name, cop_names); end
-  end
-end
-
-module RuboCop::PathUtil
-  private
-
-  def absolute?(path); end
-  def hidden_dir?(path); end
-  def hidden_file?(path); end
-  def hidden_file_in_not_hidden_dir?(pattern, path); end
-  def match_path?(pattern, path); end
-  def maybe_hidden_file?(path); end
-  def relative_path(path, base_dir = T.unsafe(nil)); end
-  def smart_path(path); end
-
-  class << self
-    def absolute?(path); end
-    def hidden_dir?(path); end
-    def hidden_file?(path); end
-    def hidden_file_in_not_hidden_dir?(pattern, path); end
-    def match_path?(pattern, path); end
-    def maybe_hidden_file?(path); end
-    def relative_path(path, base_dir = T.unsafe(nil)); end
-    def smart_path(path); end
-  end
-end
-
-module RuboCop::Platform
-  class << self
-    def windows?; end
-  end
-end
-
-RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource
-
-class RuboCop::RemoteConfig
-  def initialize(url, base_dir); end
-
-  def file; end
-  def inherit_from_remote(file, path); end
-  def uri; end
-
-  private
-
-  def cache_name_from_uri; end
-  def cache_path; end
-  def cache_path_exists?; end
-  def cache_path_expired?; end
-  def cloned_url; end
-  def generate_request(uri); end
-  def handle_response(response, limit, &block); end
-  def request(uri = T.unsafe(nil), limit = T.unsafe(nil), &block); end
-end
-
-RuboCop::RemoteConfig::CACHE_LIFETIME = T.let(T.unsafe(nil), Integer)
-
-class RuboCop::ResultCache
-  def initialize(file, team, options, config_store, cache_root = T.unsafe(nil)); end
-
-  def debug?; end
-  def load; end
-  def path; end
-  def save(offenses); end
-  def valid?; end
-
-  private
-
-  def any_symlink?(path); end
-  def context_checksum(team, options); end
-  def file_checksum(file, config_store); end
-  def relevant_options_digest(options); end
-  def rubocop_checksum; end
-  def rubocop_extra_features; end
-  def symlink_protection_triggered?(path); end
-  def team_checksum(team); end
-
-  class << self
-    def allow_symlinks_in_cache_location?(config_store); end
-    def cache_root(config_store); end
-    def cleanup(config_store, verbose, cache_root = T.unsafe(nil)); end
-    def inhibit_cleanup; end
-    def inhibit_cleanup=(_arg0); end
-    def rubocop_required_features; end
-    def rubocop_required_features=(_arg0); end
-    def source_checksum; end
-    def source_checksum=(_arg0); end
-
-    private
-
-    def remove_files(files, dirs, remove_count); end
-    def remove_oldest_files(files, dirs, cache_root, verbose); end
-    def requires_file_removal?(file_count, config_store); end
-  end
-end
-
-RuboCop::ResultCache::NON_CHANGING = T.let(T.unsafe(nil), Array)
-
-class RuboCop::Runner
-  def initialize(options, config_store); end
-
-  def aborting=(_arg0); end
-  def aborting?; end
-  def errors; end
-  def run(paths); end
-  def warnings; end
-
-  private
-
-  def add_redundant_disables(file, offenses, source); end
-  def cached_result(file, team); end
-  def cached_run?; end
-  def check_for_infinite_loop(processed_source, offenses_by_iteration); end
-  def check_for_redundant_disables?(source); end
-  def considered_failure?(offense); end
-  def default_config(cop_name); end
-  def do_inspection_loop(file); end
-  def each_inspected_file(files); end
-  def file_finished(file, offenses); end
-  def file_offense_cache(file); end
-  def file_offenses(file); end
-  def file_started(file); end
-  def filter_cop_classes(cop_classes, config); end
-  def filtered_run?; end
-  def find_target_files(paths); end
-  def formatter_set; end
-  def get_processed_source(file); end
-  def inspect_file(processed_source, team = T.unsafe(nil)); end
-  def inspect_files(files); end
-  def iterate_until_no_changes(source, offenses_by_iteration); end
-  def list_files(paths); end
-  def mark_as_safe_by_config?(config); end
-  def minimum_severity_to_fail; end
-  def mobilize_team(processed_source); end
-  def mobilized_cop_classes(config); end
-  def offenses_to_report(offenses); end
-  def process_file(file); end
-  def qualify_option_cop_names; end
-  def redundant_cop_disable_directive(file); end
-  def save_in_cache(cache, offenses); end
-  def standby_team(config); end
-  def style_guide_cops_only?(config); end
-  def supports_safe_autocorrect?(offense); end
-  def team_for_redundant_disables(file, offenses, source); end
-  def warm_cache(target_files); end
-end
-
-class RuboCop::Runner::InfiniteCorrectionLoop < ::StandardError
-  def initialize(path, offenses_by_iteration, loop_start: T.unsafe(nil)); end
-
-  def offenses; end
-end
-
-RuboCop::Runner::MAX_ITERATIONS = T.let(T.unsafe(nil), Integer)
-
-class RuboCop::StringInterpreter
-  class << self
-    def interpret(string); end
-
-    private
-
-    def interpret_hex(escape); end
-    def interpret_octal(escape); end
-    def interpret_string_escape(escape); end
-    def interpret_unicode(escape); end
-  end
-end
-
-RuboCop::StringInterpreter::STRING_ESCAPES = T.let(T.unsafe(nil), Hash)
-RuboCop::StringInterpreter::STRING_ESCAPE_REGEX = T.let(T.unsafe(nil), Regexp)
-
-class RuboCop::TargetFinder
-  def initialize(config_store, options = T.unsafe(nil)); end
-
-  def all_cops_include; end
-  def combined_exclude_glob_patterns(base_dir); end
-  def configured_include?(file); end
-  def debug?; end
-  def fail_fast?; end
-  def find(args, mode); end
-  def find_files(base_dir, flags); end
-  def force_exclusion?; end
-  def included_file?(file); end
-  def process_explicit_path(path, mode); end
-  def ruby_executable?(file); end
-  def ruby_extension?(file); end
-  def ruby_extensions; end
-  def ruby_file?(file); end
-  def ruby_filename?(file); end
-  def ruby_filenames; end
-  def ruby_interpreters(file); end
-  def stdin?; end
-  def symlink_excluded_or_infinite_loop?(base_dir, current_dir, exclude_pattern, flags); end
-  def target_files_in_dir(base_dir = T.unsafe(nil)); end
-  def to_inspect?(file, hidden_files, base_dir_config); end
-  def wanted_dir_patterns(base_dir, exclude_pattern, flags); end
-
-  private
-
-  def order; end
-end
-
-RuboCop::TargetFinder::HIDDEN_PATH_SUBSTRING = T.let(T.unsafe(nil), String)
-
-class RuboCop::TargetRuby
-  def initialize(config); end
-
-  def rubocop_version_with_support; end
-  def source; end
-  def supported?; end
-  def version; end
-
-  class << self
-    def supported_versions; end
-  end
-end
-
-class RuboCop::TargetRuby::BundlerLockFile < ::RuboCop::TargetRuby::Source
-  def name; end
-
-  private
-
-  def bundler_lock_file_path; end
-  def find_version; end
-end
-
-RuboCop::TargetRuby::DEFAULT_VERSION = T.let(T.unsafe(nil), Float)
-
-class RuboCop::TargetRuby::Default < ::RuboCop::TargetRuby::Source
-  def name; end
-
-  private
-
-  def find_version; end
-end
-
-class RuboCop::TargetRuby::GemspecFile < ::RuboCop::TargetRuby::Source
-  extend ::RuboCop::AST::NodePattern::Macros
-
-  def gem_requirement?(param0 = T.unsafe(nil)); end
-  def name; end
-  def required_ruby_version(param0); end
-
-  private
-
-  def find_default_minimal_known_ruby(right_hand_side); end
-  def find_version; end
-  def gemspec_filename; end
-  def gemspec_filepath; end
-  def version_from_array(array); end
-  def version_from_gemspec_file(file); end
-  def version_from_right_hand_side(right_hand_side); end
-end
-
-RuboCop::TargetRuby::GemspecFile::GEMSPEC_EXTENSION = T.let(T.unsafe(nil), String)
-RuboCop::TargetRuby::KNOWN_RUBIES = T.let(T.unsafe(nil), Array)
-RuboCop::TargetRuby::OBSOLETE_RUBIES = T.let(T.unsafe(nil), Hash)
-
-class RuboCop::TargetRuby::RuboCopConfig < ::RuboCop::TargetRuby::Source
-  def name; end
-
-  private
-
-  def find_version; end
-end
-
-class RuboCop::TargetRuby::RubyVersionFile < ::RuboCop::TargetRuby::Source
-  def name; end
-
-  private
-
-  def filename; end
-  def find_version; end
-  def pattern; end
-  def version_file; end
-end
-
-RuboCop::TargetRuby::RubyVersionFile::RUBY_VERSION_FILENAME = T.let(T.unsafe(nil), String)
-RuboCop::TargetRuby::RubyVersionFile::RUBY_VERSION_PATTERN = T.let(T.unsafe(nil), Regexp)
-RuboCop::TargetRuby::SOURCES = T.let(T.unsafe(nil), Array)
-
-class RuboCop::TargetRuby::Source
-  def initialize(config); end
-
-  def name; end
-  def to_s; end
-  def version; end
-end
-
-class RuboCop::TargetRuby::ToolVersionsFile < ::RuboCop::TargetRuby::RubyVersionFile
-  def name; end
-
-  private
-
-  def filename; end
-  def pattern; end
-end
-
-RuboCop::TargetRuby::ToolVersionsFile::TOOL_VERSIONS_FILENAME = T.let(T.unsafe(nil), String)
-RuboCop::TargetRuby::ToolVersionsFile::TOOL_VERSIONS_PATTERN = T.let(T.unsafe(nil), Regexp)
-RuboCop::Token = RuboCop::AST::Token
-
-module RuboCop::Util
-  class << self
-    def silence_warnings; end
-  end
-end
-
-class RuboCop::ValidationError < ::RuboCop::Error; end
-
-module RuboCop::Version
-  class << self
-    def document_version; end
-    def extension_versions(env); end
-    def feature_version(feature); end
-    def version(debug: T.unsafe(nil), env: T.unsafe(nil)); end
-  end
-end
-
-RuboCop::Version::CANONICAL_FEATURE_NAMES = T.let(T.unsafe(nil), Hash)
-RuboCop::Version::EXTENSION_PATH_NAMES = T.let(T.unsafe(nil), Hash)
-RuboCop::Version::MSG = T.let(T.unsafe(nil), String)
-RuboCop::Version::STRING = T.let(T.unsafe(nil), String)
-class RuboCop::Warning < ::StandardError; end
-
-module RuboCop::YAMLDuplicationChecker
-  class << self
-    def check(yaml_string, filename, &on_duplicated); end
-
-    private
-
-    def traverse(tree, &on_duplicated); end
-  end
-end
-
-class String
-  include ::Comparable
-  include ::JSON::Ext::Generator::GeneratorMethods::String
-  include ::MessagePack::CoreExt
-  extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
-end
-
-String::BLANK_RE = T.let(T.unsafe(nil), Regexp)
-String::ENCODED_BLANKS = T.let(T.unsafe(nil), Concurrent::Map)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop@1.67.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop@1.67.0.rbi
new file mode 100644
index 0000000000000..09e4571123f33
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/rubocop@1.67.0.rbi
@@ -0,0 +1,58696 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rubocop` gem.
+# Please instead update this file by running `bin/tapioca gem rubocop`.
+
+
+class Parser::Source::Comment
+  include ::RuboCop::Ext::Comment
+end
+
+class Parser::Source::Range
+  include ::RuboCop::Ext::Range
+end
+
+class Regexp::Expression::Base
+  include ::RuboCop::Ext::RegexpParser::Expression::Base
+end
+
+class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
+  include ::RuboCop::Ext::RegexpParser::Expression::CharacterSet
+end
+
+class Regexp::Expression::Quantifier
+  include ::RuboCop::Ext::RegexpParser::Expression::Base
+end
+
+# source://rubocop//lib/rubocop/version.rb#3
+module RuboCop; end
+
+class RuboCop::AST::ProcessedSource
+  include ::RuboCop::Ext::ProcessedSource
+end
+
+class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node
+  include ::RuboCop::Ext::RegexpNode
+end
+
+# This is a class that reads optional command line arguments to rubocop from environment variable.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/arguments_env.rb#6
+class RuboCop::ArgumentsEnv
+  class << self
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/arguments_env.rb#7
+    def read_as_arguments; end
+  end
+end
+
+# This is a class that reads optional command line arguments to rubocop from .rubocop file.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/arguments_file.rb#6
+class RuboCop::ArgumentsFile
+  class << self
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/arguments_file.rb#7
+    def read_as_arguments; end
+  end
+end
+
+# The CLI is a class responsible of handling all the command line interface
+# logic.
+#
+# source://rubocop//lib/rubocop/cli.rb#8
+class RuboCop::CLI
+  # @return [CLI] a new instance of CLI
+  #
+  # source://rubocop//lib/rubocop/cli.rb#24
+  def initialize; end
+
+  # Returns the value of attribute config_store.
+  #
+  # source://rubocop//lib/rubocop/cli.rb#22
+  def config_store; end
+
+  # Returns the value of attribute options.
+  #
+  # source://rubocop//lib/rubocop/cli.rb#22
+  def options; end
+
+  # Entry point for the application logic. Here we
+  # do the command line arguments processing and inspect
+  # the target files.
+  #
+  #
+  # @api public
+  # @param args [Array<String>] command line arguments
+  # @return [Integer] UNIX exit code
+  #
+  # source://rubocop//lib/rubocop/cli.rb#39
+  def run(args = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cli.rb#156
+  def act_on_options; end
+
+  # source://rubocop//lib/rubocop/cli.rb#198
+  def apply_default_formatter; end
+
+  # source://rubocop//lib/rubocop/cli.rb#125
+  def execute_runners; end
+
+  # source://rubocop//lib/rubocop/cli.rb#182
+  def handle_editor_mode; end
+
+  # @raise [Finished]
+  #
+  # source://rubocop//lib/rubocop/cli.rb#187
+  def handle_exiting_options; end
+
+  # source://rubocop//lib/rubocop/cli.rb#144
+  def parallel_by_default!; end
+
+  # source://rubocop//lib/rubocop/cli.rb#80
+  def profile_if_needed; end
+
+  # source://rubocop//lib/rubocop/cli.rb#113
+  def require_gem(name); end
+
+  # source://rubocop//lib/rubocop/cli.rb#121
+  def run_command(name); end
+
+  # source://rubocop//lib/rubocop/cli.rb#174
+  def set_options_to_config_loader; end
+
+  # source://rubocop//lib/rubocop/cli.rb#133
+  def suggest_extensions; end
+
+  # @raise [OptionArgumentError]
+  #
+  # source://rubocop//lib/rubocop/cli.rb#137
+  def validate_options_vs_config; end
+end
+
+# Home of subcommands in the CLI.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command.rb#7
+module RuboCop::CLI::Command
+  class << self
+    # Find the command with a given name and run it in an environment.
+    #
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/cli/command.rb#10
+    def run(env, name); end
+
+    private
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/cli/command.rb#16
+    def class_for(name); end
+  end
+end
+
+# Generate a configuration file acting as a TODO list.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#8
+class RuboCop::CLI::Command::AutoGenerateConfig < ::RuboCop::CLI::Command::Base
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#25
+  def run; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#107
+  def add_formatter; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#115
+  def add_inheritance_from_auto_generated_file(config_file); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#111
+  def execute_runner; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#136
+  def existing_configuration(config_file); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#65
+  def line_length_cop(config); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#53
+  def line_length_enabled?(config); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#61
+  def max_line_length(config); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#34
+  def maybe_run_line_length_cop; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#73
+  def only_exclude?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#69
+  def options_has_only_flag?; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#153
+  def relative_path_to_todo_from_options_config; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#100
+  def reset_config_and_auto_gen_file; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#91
+  def run_all_cops(line_length_contents); end
+
+  # Do an initial run with only Layout/LineLength so that cops that
+  # depend on Layout/LineLength:Max get the correct value for that
+  # parameter.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#80
+  def run_line_length_cop; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#57
+  def same_max_line_length?(config1, config2); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#48
+  def skip_line_length_cop(reason); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#142
+  def write_config_file(file_name, file_string, rubocop_yml_contents); end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#11
+RuboCop::CLI::Command::AutoGenerateConfig::AUTO_GENERATED_FILE = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#15
+RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1 = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#19
+RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1_DISABLED = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#18
+RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1_OVERRIDDEN = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#20
+RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1_SKIPPED_ONLY_COPS = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#22
+RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1_SKIPPED_ONLY_EXCLUDE = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#16
+RuboCop::CLI::Command::AutoGenerateConfig::PHASE_2 = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#13
+RuboCop::CLI::Command::AutoGenerateConfig::PLACEHOLDER = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/auto_generate_config.rb#12
+RuboCop::CLI::Command::AutoGenerateConfig::YAML_OPTIONAL_DOC_START = T.let(T.unsafe(nil), Regexp)
+
+# A subcommand in the CLI.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/base.rb#8
+class RuboCop::CLI::Command::Base
+  # @api private
+  # @return [Base] a new instance of Base
+  #
+  # source://rubocop//lib/rubocop/cli/command/base.rb#26
+  def initialize(env); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/base.rb#9
+  def env; end
+
+  class << self
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/cli/command/base.rb#21
+    def by_command_name(name); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/cli/command/base.rb#14
+    def command_name; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/cli/command/base.rb#14
+    def command_name=(_arg0); end
+
+    # @api private
+    # @private
+    #
+    # source://rubocop//lib/rubocop/cli/command/base.rb#16
+    def inherited(subclass); end
+  end
+end
+
+# Run all the selected cops and report the result.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/execute_runner.rb#8
+class RuboCop::CLI::Command::ExecuteRunner < ::RuboCop::CLI::Command::Base
+  include ::RuboCop::Formatter::TextUtil
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#16
+  def run; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#85
+  def bug_tracker_uri; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#69
+  def display_error_summary(errors); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#56
+  def display_summary(runner); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#61
+  def display_warning_summary(warnings); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#22
+  def execute_runner(paths); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#91
+  def maybe_print_corrected_source; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/execute_runner.rb#42
+  def with_redirect; end
+end
+
+# Combination of short and long formatter names.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/execute_runner.rb#12
+RuboCop::CLI::Command::ExecuteRunner::INTEGRATION_FORMATTERS = T.let(T.unsafe(nil), Array)
+
+# Generate a .rubocop.yml file in the current directory.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/init_dotfile.rb#8
+class RuboCop::CLI::Command::InitDotfile < ::RuboCop::CLI::Command::Base
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/init_dotfile.rb#13
+  def run; end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/init_dotfile.rb#9
+RuboCop::CLI::Command::InitDotfile::DOTFILE = T.let(T.unsafe(nil), String)
+
+# Start Language Server Protocol of RuboCop.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/lsp.rb#8
+class RuboCop::CLI::Command::LSP < ::RuboCop::CLI::Command::Base
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/lsp.rb#11
+  def run; end
+end
+
+# Shows the given cops, or all cops by default, and their configurations
+# for the current directory.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/show_cops.rb#9
+class RuboCop::CLI::Command::ShowCops < ::RuboCop::CLI::Command::Base
+  # @api private
+  # @return [ShowCops] a new instance of ShowCops
+  #
+  # source://rubocop//lib/rubocop/cli/command/show_cops.rb#12
+  def initialize(env); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/show_cops.rb#19
+  def run; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/show_cops.rb#67
+  def config_lines(cop); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/show_cops.rb#63
+  def cops_of_department(cops, department); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/show_cops.rb#25
+  def print_available_cops; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/show_cops.rb#48
+  def print_cop_details(cops); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/show_cops.rb#36
+  def print_cops_of_department(registry, department, show_all); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/show_cops.rb#57
+  def selected_cops_of_department(cops, department); end
+end
+
+# Prints out url to documentation of provided cops
+# or documentation base url by default.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/show_docs_url.rb#9
+class RuboCop::CLI::Command::ShowDocsUrl < ::RuboCop::CLI::Command::Base
+  # @api private
+  # @return [ShowDocsUrl] a new instance of ShowDocsUrl
+  #
+  # source://rubocop//lib/rubocop/cli/command/show_docs_url.rb#12
+  def initialize(env); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/show_docs_url.rb#18
+  def run; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/show_docs_url.rb#38
+  def cops_array; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/show_docs_url.rb#24
+  def print_documentation_url; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/show_docs_url.rb#42
+  def registry_hash; end
+end
+
+# Suggest RuboCop extensions to install based on Gemfile dependencies.
+# Only primary dependencies are evaluated, so if a dependency depends on a
+# gem with an extension, it is not suggested. However, if an extension is
+# a transitive dependency, it will not be suggested.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#11
+class RuboCop::CLI::Command::SuggestExtensions < ::RuboCop::CLI::Command::Base
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#17
+  def run; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#73
+  def all_extensions; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#69
+  def current_formatter; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#111
+  def dependent_gems; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#87
+  def extensions; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#103
+  def installed_and_not_loaded_extensions; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#91
+  def installed_extensions; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#115
+  def installed_gems; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#99
+  def loaded_extensions; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#107
+  def lockfile; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#95
+  def not_installed_extensions; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#41
+  def print_install_suggestions; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#51
+  def print_load_suggestions; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#60
+  def print_opt_out_instruction; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#119
+  def puts(*args); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#30
+  def skip?; end
+end
+
+# Combination of short and long formatter names.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/suggest_extensions.rb#13
+RuboCop::CLI::Command::SuggestExtensions::INCLUDED_FORMATTERS = T.let(T.unsafe(nil), Array)
+
+# Display version.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/command/version.rb#8
+class RuboCop::CLI::Command::Version < ::RuboCop::CLI::Command::Base
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/command/version.rb#11
+  def run; end
+end
+
+# source://rubocop//lib/rubocop/cli.rb#13
+RuboCop::CLI::DEFAULT_PARALLEL_OPTIONS = T.let(T.unsafe(nil), Array)
+
+# Execution environment for a CLI command.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cli/environment.rb#7
+class RuboCop::CLI::Environment
+  # @api private
+  # @return [Environment] a new instance of Environment
+  #
+  # source://rubocop//lib/rubocop/cli/environment.rb#10
+  def initialize(options, config_store, paths); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/environment.rb#8
+  def config_store; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/environment.rb#8
+  def options; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/environment.rb#8
+  def paths; end
+
+  # Run a command in this environment.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cli/environment.rb#17
+  def run(name); end
+end
+
+# source://rubocop//lib/rubocop/cli.rb#20
+class RuboCop::CLI::Finished < ::StandardError; end
+
+# source://rubocop//lib/rubocop/cli.rb#11
+RuboCop::CLI::STATUS_ERROR = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop//lib/rubocop/cli.rb#12
+RuboCop::CLI::STATUS_INTERRUPTED = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop//lib/rubocop/cli.rb#10
+RuboCop::CLI::STATUS_OFFENSES = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop//lib/rubocop/cli.rb#9
+RuboCop::CLI::STATUS_SUCCESS = T.let(T.unsafe(nil), Integer)
+
+# This class represents the cache config of the caching RuboCop runs.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cache_config.rb#6
+class RuboCop::CacheConfig
+  class << self
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/cache_config.rb#7
+    def root_dir; end
+  end
+end
+
+# Converts RuboCop objects to and from the serialization format JSON.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cached_data.rb#8
+class RuboCop::CachedData
+  # @api private
+  # @return [CachedData] a new instance of CachedData
+  #
+  # source://rubocop//lib/rubocop/cached_data.rb#9
+  def initialize(filename); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cached_data.rb#13
+  def from_json(text); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cached_data.rb#17
+  def to_json(offenses); end
+
+  private
+
+  # Restore an offense object loaded from a JSON file.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cached_data.rb#47
+  def deserialize_offenses(offenses); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cached_data.rb#56
+  def location_from_source_buffer(offense, source_buffer); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cached_data.rb#40
+  def message(offense); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cached_data.rb#23
+  def serialize_offense(offense); end
+end
+
+# and provides a way to check if each cop is enabled at arbitrary line.
+#
+# source://rubocop//lib/rubocop/comment_config.rb#6
+class RuboCop::CommentConfig
+  extend ::RuboCop::SimpleForwardable
+
+  # @return [CommentConfig] a new instance of CommentConfig
+  #
+  # source://rubocop//lib/rubocop/comment_config.rb#34
+  def initialize(processed_source); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/comment_config.rb#63
+  def comment_only_line?(line_number); end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def config(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop//lib/rubocop/comment_config.rb#51
+  def cop_disabled_line_ranges; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/comment_config.rb#39
+  def cop_enabled_at_line?(cop, line_number); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/comment_config.rb#47
+  def cop_opted_in?(cop); end
+
+  # source://rubocop//lib/rubocop/comment_config.rb#55
+  def extra_enabled_comments; end
+
+  # Returns the value of attribute processed_source.
+  #
+  # source://rubocop//lib/rubocop/comment_config.rb#30
+  def processed_source; end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def registry(*_arg0, **_arg1, &_arg2); end
+
+  private
+
+  # source://rubocop//lib/rubocop/comment_config.rb#96
+  def analyze; end
+
+  # source://rubocop//lib/rubocop/comment_config.rb#124
+  def analyze_cop(analysis, directive); end
+
+  # source://rubocop//lib/rubocop/comment_config.rb#144
+  def analyze_disabled(analysis, directive); end
+
+  # source://rubocop//lib/rubocop/comment_config.rb#155
+  def analyze_rest(analysis, directive); end
+
+  # source://rubocop//lib/rubocop/comment_config.rb#135
+  def analyze_single_line(analysis, directive); end
+
+  # source://rubocop//lib/rubocop/comment_config.rb#164
+  def cop_line_ranges(analysis); end
+
+  # source://rubocop//lib/rubocop/comment_config.rb#170
+  def each_directive; end
+
+  # source://rubocop//lib/rubocop/comment_config.rb#69
+  def extra_enabled_comments_with_names(extras:, names:); end
+
+  # source://rubocop//lib/rubocop/comment_config.rb#190
+  def handle_enable_all(directive, names, extras); end
+
+  # Collect cops that have been disabled or enabled by name in a directive comment
+  # so that `Lint/RedundantCopEnableDirective` can register offenses correctly.
+  #
+  # source://rubocop//lib/rubocop/comment_config.rb#204
+  def handle_switch(directive, names, extras); end
+
+  # source://rubocop//lib/rubocop/comment_config.rb#115
+  def inject_disabled_cops_directives(analyses); end
+
+  # source://rubocop//lib/rubocop/comment_config.rb#183
+  def non_comment_token_line_numbers; end
+
+  # source://rubocop//lib/rubocop/comment_config.rb#83
+  def opt_in_cops; end
+
+  # source://rubocop//lib/rubocop/comment_config.rb#179
+  def qualified_cop_name(cop_name); end
+end
+
+# source://rubocop//lib/rubocop/comment_config.rb#9
+RuboCop::CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN = T.let(T.unsafe(nil), Float)
+
+# This class provides an API compatible with RuboCop::DirectiveComment
+# to be used for cops that are disabled in the config file
+#
+# source://rubocop//lib/rubocop/comment_config.rb#13
+class RuboCop::CommentConfig::ConfigDisabledCopDirectiveComment
+  include ::RuboCop::Ext::Comment
+
+  # @return [ConfigDisabledCopDirectiveComment] a new instance of ConfigDisabledCopDirectiveComment
+  #
+  # source://rubocop//lib/rubocop/comment_config.rb#21
+  def initialize(cop_name); end
+
+  # Returns the value of attribute line_number.
+  #
+  # source://rubocop//lib/rubocop/comment_config.rb#16
+  def line_number; end
+
+  # Returns the value of attribute loc.
+  #
+  # source://rubocop//lib/rubocop/comment_config.rb#16
+  def loc; end
+
+  # Returns the value of attribute text.
+  #
+  # source://rubocop//lib/rubocop/comment_config.rb#16
+  def text; end
+end
+
+# source://rubocop//lib/rubocop/comment_config.rb#19
+class RuboCop::CommentConfig::ConfigDisabledCopDirectiveComment::Expression < ::Struct
+  # Returns the value of attribute line
+  #
+  # @return [Object] the current value of line
+  def line; end
+
+  # Sets the attribute line
+  #
+  # @param value [Object] the value to set the attribute line to.
+  # @return [Object] the newly set value
+  def line=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rubocop//lib/rubocop/comment_config.rb#18
+class RuboCop::CommentConfig::ConfigDisabledCopDirectiveComment::Loc < ::Struct
+  # Returns the value of attribute expression
+  #
+  # @return [Object] the current value of expression
+  def expression; end
+
+  # Sets the attribute expression
+  #
+  # @param value [Object] the value to set the attribute expression to.
+  # @return [Object] the newly set value
+  def expression=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rubocop//lib/rubocop/comment_config.rb#28
+class RuboCop::CommentConfig::CopAnalysis < ::Struct
+  # Returns the value of attribute line_ranges
+  #
+  # @return [Object] the current value of line_ranges
+  def line_ranges; end
+
+  # Sets the attribute line_ranges
+  #
+  # @param value [Object] the value to set the attribute line_ranges to.
+  # @return [Object] the newly set value
+  def line_ranges=(_); end
+
+  # Returns the value of attribute start_line_number
+  #
+  # @return [Object] the current value of start_line_number
+  def start_line_number; end
+
+  # Sets the attribute start_line_number
+  #
+  # @param value [Object] the value to set the attribute start_line_number to.
+  # @return [Object] the newly set value
+  def start_line_number=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# This class represents the configuration of the RuboCop application
+# and all its cops. A Config is associated with a YAML configuration
+# file from which it was read. Several different Configs can be used
+# during a run of the rubocop program, if files in several
+# directories are inspected.
+#
+# source://rubocop//lib/rubocop/config.rb#12
+class RuboCop::Config
+  include ::RuboCop::PathUtil
+  include ::RuboCop::FileFinder
+  extend ::RuboCop::SimpleForwardable
+
+  # @return [Config] a new instance of Config
+  #
+  # source://rubocop//lib/rubocop/config.rb#30
+  def initialize(hash = T.unsafe(nil), loaded_path = T.unsafe(nil)); end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def [](*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def []=(*_arg0, **_arg1, &_arg2); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config.rb#170
+  def active_support_extensions_enabled?; end
+
+  # source://rubocop//lib/rubocop/config.rb#96
+  def add_excludes_from_higher_level(highest_config); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config.rb#197
+  def allowed_camel_case_file?(file); end
+
+  # Paths specified in configuration files starting with .rubocop are
+  # relative to the directory where that file is. Paths in other config files
+  # are relative to the current directory. This is so that paths in
+  # config/default.yml, for example, are not relative to RuboCop's config
+  # directory since that wouldn't work.
+  #
+  # source://rubocop//lib/rubocop/config.rb#241
+  def base_dir_for_path_parameters; end
+
+  # @return [String, nil]
+  #
+  # source://rubocop//lib/rubocop/config.rb#271
+  def bundler_lock_file_path; end
+
+  # source://rubocop//lib/rubocop/config.rb#51
+  def check; end
+
+  # @api private
+  # @return [Boolean] whether config for this badge has 'Include' or 'Exclude' keys
+  #
+  # source://rubocop//lib/rubocop/config.rb#142
+  def clusivity_config_for_badge?(badge); end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def delete(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop//lib/rubocop/config.rb#108
+  def deprecation_check; end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def dig(*_arg0, **_arg1, &_arg2); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config.rb#162
+  def disabled_new_cops?; end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def each(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def each_key(*_arg0, **_arg1, &_arg2); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config.rb#166
+  def enabled_new_cops?; end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def fetch(*_arg0, **_arg1, &_arg2); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config.rb#219
+  def file_to_exclude?(file); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config.rb#178
+  def file_to_include?(file); end
+
+  # source://rubocop//lib/rubocop/config.rb#158
+  def for_all_cops; end
+
+  # Note: the 'Enabled' attribute is same as that returned by `for_cop`
+  #
+  # @return [Config] for the given cop merged with that of its department (if any)
+  #
+  # source://rubocop//lib/rubocop/config.rb#128
+  def for_badge(badge); end
+
+  # Note: the 'Enabled' attribute is calculated according to the department's
+  # and 'AllCops' configuration; other attributes are not inherited.
+  #
+  # @return [Config] for the given cop / cop name.
+  #
+  # source://rubocop//lib/rubocop/config.rb#122
+  def for_cop(cop); end
+
+  # Note: the 'Enabled' attribute will be present only if specified
+  # at the department's level
+  #
+  # @return [Config] for the given department name.
+  #
+  # source://rubocop//lib/rubocop/config.rb#153
+  def for_department(department_name); end
+
+  # Returns target's locked gem versions (i.e. from Gemfile.lock or gems.locked)
+  #
+  # source://rubocop//lib/rubocop/config.rb#296
+  def gem_versions_in_target; end
+
+  # source://rubocop//lib/rubocop/config.rb#300
+  def inspect; end
+
+  # True if this is a config file that is shipped with RuboCop
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config.rb#76
+  def internal?; end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def key?(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def keys(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop//lib/rubocop/config.rb#47
+  def loaded_features; end
+
+  # Returns the value of attribute loaded_path.
+  #
+  # source://rubocop//lib/rubocop/config.rb#20
+  def loaded_path; end
+
+  # source://rubocop//lib/rubocop/config.rb#81
+  def make_excludes_absolute; end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def map(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def merge(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop//lib/rubocop/config.rb#251
+  def parser_engine; end
+
+  # source://rubocop//lib/rubocop/config.rb#232
+  def path_relative_to_config(path); end
+
+  # source://rubocop//lib/rubocop/config.rb#228
+  def patterns_to_exclude; end
+
+  # source://rubocop//lib/rubocop/config.rb#224
+  def patterns_to_include; end
+
+  # source://rubocop//lib/rubocop/config.rb#282
+  def pending_cops; end
+
+  # Returns true if there's a chance that an Include pattern matches hidden
+  # files, false if that's definitely not possible.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config.rb#211
+  def possibly_include_hidden?; end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def replace(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop//lib/rubocop/config.rb#71
+  def signature; end
+
+  # source://rubocop//lib/rubocop/config.rb#266
+  def smart_loaded_path; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config.rb#174
+  def string_literals_frozen_by_default?; end
+
+  # source://rubocop//lib/rubocop/config.rb#255
+  def target_rails_version; end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def target_ruby_version(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def to_h(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def to_hash(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop//lib/rubocop/config.rb#67
+  def to_s; end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def transform_values(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def validate(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop//lib/rubocop/config.rb#58
+  def validate_after_resolution; end
+
+  private
+
+  # source://rubocop//lib/rubocop/config.rb#350
+  def department_of(qualified_cop_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config.rb#338
+  def enable_cop?(qualified_cop_name, cop_options); end
+
+  # @param gem_version [Gem::Version] an object like `Gem::Version.new("7.1.2.3")`
+  # @return [Float] The major and minor version, like `7.1`
+  #
+  # source://rubocop//lib/rubocop/config.rb#325
+  def gem_version_to_major_minor_float(gem_version); end
+
+  # source://rubocop//lib/rubocop/config.rb#331
+  def read_gem_versions_from_target_lockfile; end
+
+  # @return [Float, nil] The Rails version as a `major.minor` Float.
+  #
+  # source://rubocop//lib/rubocop/config.rb#312
+  def read_rails_version_from_bundler_lock_file; end
+
+  # @return [Float, nil] The Rails version as a `major.minor` Float.
+  #
+  # source://rubocop//lib/rubocop/config.rb#307
+  def target_rails_version_from_bundler_lock_file; end
+
+  class << self
+    # source://rubocop//lib/rubocop/config.rb#22
+    def create(hash, path, check: T.unsafe(nil)); end
+  end
+end
+
+# source://rubocop//lib/rubocop/config.rb#17
+class RuboCop::Config::CopConfig < ::Struct
+  # Returns the value of attribute metadata
+  #
+  # @return [Object] the current value of metadata
+  def metadata; end
+
+  # Sets the attribute metadata
+  #
+  # @param value [Object] the value to set the attribute metadata to.
+  # @return [Object] the newly set value
+  def metadata=(_); end
+
+  # Returns the value of attribute name
+  #
+  # @return [Object] the current value of name
+  def name; end
+
+  # Sets the attribute name
+  #
+  # @param value [Object] the value to set the attribute name to.
+  # @return [Object] the newly set value
+  def name=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rubocop//lib/rubocop/config.rb#19
+RuboCop::Config::DEFAULT_RAILS_VERSION = T.let(T.unsafe(nil), Float)
+
+# This class has methods related to finding configuration path.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/config_finder.rb#8
+class RuboCop::ConfigFinder
+  extend ::RuboCop::FileFinder
+
+  class << self
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/config_finder.rb#19
+    def find_config_path(target_dir); end
+
+    # Returns the path RuboCop inferred as the root of the project. No file
+    # searches will go past this directory.
+    #
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/config_finder.rb#26
+    def project_root; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/config_finder.rb#17
+    def project_root=(_arg0); end
+
+    private
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/config_finder.rb#69
+    def expand_path(path); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/config_finder.rb#40
+    def find_project_dotfile(target_dir); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/config_finder.rb#32
+    def find_project_root; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/config_finder.rb#44
+    def find_project_root_dot_config; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/config_finder.rb#54
+    def find_user_dotfile; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/config_finder.rb#62
+    def find_user_xdg_config; end
+  end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_finder.rb#12
+RuboCop::ConfigFinder::DEFAULT_FILE = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_finder.rb#9
+RuboCop::ConfigFinder::DOTFILE = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_finder.rb#11
+RuboCop::ConfigFinder::RUBOCOP_HOME = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_finder.rb#10
+RuboCop::ConfigFinder::XDG_CONFIG = T.let(T.unsafe(nil), String)
+
+# This class represents the configuration of the RuboCop application
+# and all its cops. A Config is associated with a YAML configuration
+# file from which it was read. Several different Configs can be used
+# during a run of the rubocop program, if files in several
+# directories are inspected.
+#
+# source://rubocop//lib/rubocop/config_loader.rb#17
+class RuboCop::ConfigLoader
+  extend ::RuboCop::FileFinder
+
+  class << self
+    # source://rubocop//lib/rubocop/config_loader.rb#137
+    def add_excludes_from_files(config, config_file); end
+
+    # Used to add features that were required inside a config or from
+    # the CLI using `--require`.
+    #
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#198
+    def add_loaded_features(loaded_features); end
+
+    # source://rubocop//lib/rubocop/config_loader.rb#80
+    def add_missing_namespaces(path, hash); end
+
+    # source://rubocop//lib/rubocop/config_loader.rb#41
+    def clear_options; end
+
+    # Returns the path of .rubocop.yml searching upwards in the
+    # directory structure starting at the given directory where the
+    # inspected file is. If no .rubocop.yml is found there, the
+    # user's home directory is checked. If there's no .rubocop.yml
+    # there either, the path to the default file is returned.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#104
+    def configuration_file_for(target_dir); end
+
+    # source://rubocop//lib/rubocop/config_loader.rb#108
+    def configuration_from_file(config_file, check: T.unsafe(nil)); end
+
+    # Returns the value of attribute debug.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#33
+    def debug; end
+
+    # Sets the attribute debug
+    #
+    # @param value the value to set the attribute debug to.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#33
+    def debug=(_arg0); end
+
+    # Returns the value of attribute debug.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#33
+    def debug?; end
+
+    # source://rubocop//lib/rubocop/config_loader.rb#147
+    def default_configuration; end
+
+    # Sets the attribute default_configuration
+    #
+    # @param value the value to set the attribute default_configuration to.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#35
+    def default_configuration=(_arg0); end
+
+    # Returns the value of attribute disable_pending_cops.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#33
+    def disable_pending_cops; end
+
+    # Sets the attribute disable_pending_cops
+    #
+    # @param value the value to set the attribute disable_pending_cops to.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#33
+    def disable_pending_cops=(_arg0); end
+
+    # Returns the value of attribute enable_pending_cops.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#33
+    def enable_pending_cops; end
+
+    # Sets the attribute enable_pending_cops
+    #
+    # @param value the value to set the attribute enable_pending_cops to.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#33
+    def enable_pending_cops=(_arg0); end
+
+    # Returns the value of attribute ignore_parent_exclusion.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#33
+    def ignore_parent_exclusion; end
+
+    # Sets the attribute ignore_parent_exclusion
+    #
+    # @param value the value to set the attribute ignore_parent_exclusion to.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#33
+    def ignore_parent_exclusion=(_arg0); end
+
+    # Returns the value of attribute ignore_parent_exclusion.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#33
+    def ignore_parent_exclusion?; end
+
+    # Returns the value of attribute ignore_unrecognized_cops.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#33
+    def ignore_unrecognized_cops; end
+
+    # Sets the attribute ignore_unrecognized_cops
+    #
+    # @param value the value to set the attribute ignore_unrecognized_cops to.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#33
+    def ignore_unrecognized_cops=(_arg0); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#155
+    def inject_defaults!(project_root); end
+
+    # source://rubocop//lib/rubocop/config_loader.rb#47
+    def load_file(file, check: T.unsafe(nil)); end
+
+    # @raise [TypeError]
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#67
+    def load_yaml_configuration(absolute_path); end
+
+    # Returns the value of attribute loaded_features.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#36
+    def loaded_features; end
+
+    # Return a recursive merge of two hashes. That is, a normal hash merge,
+    # with the addition that any value that is a hash, and occurs in both
+    # arguments, will also be merged. And so on.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#95
+    def merge(base_hash, derived_hash); end
+
+    # Merges the given configuration with the default one.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#191
+    def merge_with_default(config, config_file, unset_nil: T.unsafe(nil)); end
+
+    # source://rubocop//lib/rubocop/config_loader.rb#128
+    def pending_cops_only_qualified(pending_cops); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#132
+    def possible_new_cops?(config); end
+
+    # Returns the path RuboCop inferred as the root of the project. No file
+    # searches will go past this directory.
+    #
+    # @deprecated Use `RuboCop::ConfigFinder.project_root` instead.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#166
+    def project_root; end
+
+    # source://rubocop//lib/rubocop/config_loader.rb#175
+    def warn_on_pending_cops(pending_cops); end
+
+    # source://rubocop//lib/rubocop/config_loader.rb#183
+    def warn_pending_cop(cop); end
+
+    private
+
+    # source://rubocop//lib/rubocop/config_loader.rb#212
+    def check_duplication(yaml_code, absolute_path); end
+
+    # source://rubocop//lib/rubocop/config_loader.rb#204
+    def file_path(file); end
+
+    # Read the specified file, or exit with a friendly, concise message on
+    # stderr. Care is taken to use the standard OS exit code for a "file not
+    # found" error.
+    #
+    # source://rubocop//lib/rubocop/config_loader.rb#232
+    def read_file(absolute_path); end
+
+    # source://rubocop//lib/rubocop/config_loader.rb#208
+    def resolver; end
+
+    # source://rubocop//lib/rubocop/config_loader.rb#238
+    def yaml_tree_to_hash(yaml_tree); end
+
+    # source://rubocop//lib/rubocop/config_loader.rb#248
+    def yaml_tree_to_hash!(yaml_tree); end
+  end
+end
+
+# source://rubocop//lib/rubocop/config_loader.rb#20
+RuboCop::ConfigLoader::DEFAULT_FILE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/config_loader.rb#18
+RuboCop::ConfigLoader::DOTFILE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/config_loader.rb#19
+RuboCop::ConfigLoader::RUBOCOP_HOME = T.let(T.unsafe(nil), String)
+
+# A help class for ConfigLoader that handles configuration resolution.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/config_loader_resolver.rb#9
+class RuboCop::ConfigLoaderResolver
+  # When one .rubocop.yml file inherits from another .rubocop.yml file, the Include paths in the
+  # base configuration are relative to the directory where the base configuration file is. For the
+  # derived configuration, we need to make those paths relative to where the derived configuration
+  # file is.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#45
+  def fix_include_paths(base_config_path, hash, path, key, value); end
+
+  # Return a recursive merge of two hashes. That is, a normal hash merge,
+  # with the addition that any value that is a hash, and occurs in both
+  # arguments, will also be merged. And so on.
+  #
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#99
+  def merge(base_hash, derived_hash, **opts); end
+
+  # Merges the given configuration with the default one. If
+  # AllCops:DisabledByDefault is true, it changes the Enabled params so that
+  # only cops from user configuration are enabled. If
+  # AllCops:EnabledByDefault is true, it changes the Enabled params so that
+  # only cops explicitly disabled in user configuration are disabled.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#75
+  def merge_with_default(config, config_file, unset_nil:); end
+
+  # An `Enabled: true` setting in user configuration for a cop overrides an
+  # `Enabled: false` setting for its department.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#119
+  def override_department_setting_for_cops(base_hash, derived_hash); end
+
+  # If a cop was previously explicitly enabled, but then superseded by the
+  # department being disabled, disable it.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#136
+  def override_enabled_for_disabled_departments(base_hash, derived_hash); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#19
+  def resolve_inheritance(path, hash, file, debug); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#55
+  def resolve_inheritance_from_gems(hash); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#10
+  def resolve_requires(path, hash); end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#208
+  def base_configs(path, inherit_from, file); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#176
+  def determine_inherit_mode(hash, key); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#152
+  def disabled?(hash, department); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#156
+  def duplicate_setting?(base_hash, derived_hash, key, inherited_file); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#267
+  def gem_config_path(gem_name, relative_config_path); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#245
+  def handle_disabled_by_default(config, new_default_configuration); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#220
+  def inherited_file(path, inherit_from, file); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#204
+  def merge_hashes?(base_hash, derived_hash, key); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#241
+  def remote_file?(uri); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#196
+  def should_merge?(mode, key); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#200
+  def should_override?(mode, key); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#182
+  def should_union?(derived_hash, base_hash, root_mode, key); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#263
+  def transform(config, &block); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_loader_resolver.rb#165
+  def warn_on_duplicate_setting(base_hash, derived_hash, key, **opts); end
+end
+
+# Raised when a RuboCop configuration file is not found.
+#
+# source://rubocop//lib/rubocop/config_loader.rb#9
+class RuboCop::ConfigNotFoundError < ::RuboCop::Error; end
+
+# This class handles obsolete configuration.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion/rule.rb#4
+class RuboCop::ConfigObsoletion
+  # @api private
+  # @return [ConfigObsoletion] a new instance of ConfigObsoletion
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion.rb#35
+  def initialize(config); end
+
+  # @api private
+  # @raise [ValidationError]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion.rb#41
+  def reject_obsolete!; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion.rb#21
+  def rules; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion.rb#21
+  def warnings; end
+
+  private
+
+  # Cop rules are keyed by the name of the original cop
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion.rb#72
+  def load_cop_rules(rules); end
+
+  # Parameter rules may apply to multiple cops and multiple parameters
+  # and are given as an array. Each combination is turned into a separate
+  # rule object.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion.rb#85
+  def load_parameter_rules(rules); end
+
+  # Default rules for obsoletions are in config/obsoletion.yml
+  # Additional rules files can be added with `RuboCop::ConfigObsoletion.files << filename`
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion.rb#52
+  def load_rules; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion.rb#98
+  def obsoletions; end
+
+  class << self
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/config_obsoletion.rb#24
+    def files; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/config_obsoletion.rb#24
+    def files=(_arg0); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/config_obsoletion.rb#26
+    def legacy_cop_names; end
+  end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion.rb#8
+RuboCop::ConfigObsoletion::COP_RULE_CLASSES = T.let(T.unsafe(nil), Hash)
+
+# Encapsulation of a ConfigObsoletion rule for changing a parameter
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion/changed_enforced_styles.rb#7
+class RuboCop::ConfigObsoletion::ChangedEnforcedStyles < ::RuboCop::ConfigObsoletion::ParameterRule
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/changed_enforced_styles.rb#14
+  def message; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/changed_enforced_styles.rb#10
+  def violated?; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/changed_enforced_styles.rb#28
+  def value; end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion/changed_enforced_styles.rb#8
+RuboCop::ConfigObsoletion::ChangedEnforcedStyles::BASE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# Encapsulation of a ConfigObsoletion rule for changing a parameter
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion/changed_parameter.rb#7
+class RuboCop::ConfigObsoletion::ChangedParameter < ::RuboCop::ConfigObsoletion::ParameterRule
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/changed_parameter.rb#10
+  def message; end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion/changed_parameter.rb#8
+RuboCop::ConfigObsoletion::ChangedParameter::BASE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# Base class for ConfigObsoletion rules relating to cops
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion/cop_rule.rb#7
+class RuboCop::ConfigObsoletion::CopRule < ::RuboCop::ConfigObsoletion::Rule
+  # @api private
+  # @return [CopRule] a new instance of CopRule
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/cop_rule.rb#10
+  def initialize(config, old_name); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/cop_rule.rb#15
+  def cop_rule?; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/cop_rule.rb#19
+  def message; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/cop_rule.rb#8
+  def old_name; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/cop_rule.rb#28
+  def violated?; end
+
+  # Cop rules currently can only be failures, not warnings
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/cop_rule.rb#24
+  def warning?; end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion.rb#7
+RuboCop::ConfigObsoletion::DEFAULT_RULES_FILE = T.let(T.unsafe(nil), String)
+
+# Encapsulation of a ConfigObsoletion rule for splitting a cop's
+# functionality into multiple new cops.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#8
+class RuboCop::ConfigObsoletion::ExtractedCop < ::RuboCop::ConfigObsoletion::CopRule
+  # @api private
+  # @return [ExtractedCop] a new instance of ExtractedCop
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#11
+  def initialize(config, old_name, gem); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#9
+  def department; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#9
+  def gem; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#23
+  def rule_message; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#17
+  def violated?; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#32
+  def affected_cops; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/extracted_cop.rb#41
+  def feature_loaded?; end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion.rb#18
+RuboCop::ConfigObsoletion::LOAD_RULES_CACHE = T.let(T.unsafe(nil), Hash)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion.rb#14
+RuboCop::ConfigObsoletion::PARAMETER_RULE_CLASSES = T.let(T.unsafe(nil), Hash)
+
+# Base class for ConfigObsoletion rules relating to parameters
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#7
+class RuboCop::ConfigObsoletion::ParameterRule < ::RuboCop::ConfigObsoletion::Rule
+  # @api private
+  # @return [ParameterRule] a new instance of ParameterRule
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#10
+  def initialize(config, cop, parameter, metadata); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#8
+  def cop; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#8
+  def metadata; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#8
+  def parameter; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#17
+  def parameter_rule?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#21
+  def violated?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#25
+  def warning?; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#39
+  def alternative; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#43
+  def alternatives; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#31
+  def applies_to_current_ruby_version?; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#47
+  def reason; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/parameter_rule.rb#51
+  def severity; end
+end
+
+# Encapsulation of a ConfigObsoletion rule for removing
+# a previously defined cop.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#8
+class RuboCop::ConfigObsoletion::RemovedCop < ::RuboCop::ConfigObsoletion::CopRule
+  # @api private
+  # @return [RemovedCop] a new instance of RemovedCop
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#13
+  def initialize(config, old_name, metadata); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#9
+  def metadata; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#9
+  def old_name; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#18
+  def rule_message; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#36
+  def alternatives; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#32
+  def reason; end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion/removed_cop.rb#11
+RuboCop::ConfigObsoletion::RemovedCop::BASE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# Encapsulation of a ConfigObsoletion rule for renaming
+# a cop or moving it to a new department.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion/renamed_cop.rb#8
+class RuboCop::ConfigObsoletion::RenamedCop < ::RuboCop::ConfigObsoletion::CopRule
+  # @api private
+  # @return [RenamedCop] a new instance of RenamedCop
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/renamed_cop.rb#11
+  def initialize(config, old_name, new_name); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/renamed_cop.rb#9
+  def new_name; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/renamed_cop.rb#16
+  def rule_message; end
+
+  private
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/renamed_cop.rb#22
+  def moved?; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/renamed_cop.rb#29
+  def verb; end
+end
+
+# Abstract base class for ConfigObsoletion rules
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion/rule.rb#7
+class RuboCop::ConfigObsoletion::Rule
+  # @api private
+  # @return [Rule] a new instance of Rule
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/rule.rb#8
+  def initialize(config); end
+
+  # Does this rule relate to cops?
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/rule.rb#13
+  def cop_rule?; end
+
+  # Does this rule relate to parameters?
+  #
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/rule.rb#18
+  def parameter_rule?; end
+
+  # @api private
+  # @raise [NotImplementedError]
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/rule.rb#22
+  def violated?; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/rule.rb#28
+  def config; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/rule.rb#36
+  def smart_loaded_path; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/rule.rb#30
+  def to_sentence(collection, connector: T.unsafe(nil)); end
+end
+
+# Encapsulation of a ConfigObsoletion rule for splitting a cop's
+# functionality into multiple new cops.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/config_obsoletion/split_cop.rb#8
+class RuboCop::ConfigObsoletion::SplitCop < ::RuboCop::ConfigObsoletion::CopRule
+  # @api private
+  # @return [SplitCop] a new instance of SplitCop
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/split_cop.rb#11
+  def initialize(config, old_name, metadata); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/split_cop.rb#9
+  def metadata; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/split_cop.rb#16
+  def rule_message; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_obsoletion/split_cop.rb#22
+  def alternatives; end
+end
+
+# This class handles collecting the options for regenerating a TODO file.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/config_regeneration.rb#6
+class RuboCop::ConfigRegeneration
+  # Get options from the comment in the TODO file, and parse them as options
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_regeneration.rb#12
+  def options; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/config_regeneration.rb#29
+  def generation_command; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/config_regeneration.rb#25
+  def todo_exists?; end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_regeneration.rb#7
+RuboCop::ConfigRegeneration::AUTO_GENERATED_FILE = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_regeneration.rb#8
+RuboCop::ConfigRegeneration::COMMAND_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_regeneration.rb#9
+RuboCop::ConfigRegeneration::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+# Handles caching of configurations and association of inspected
+# ruby files to configurations.
+#
+# source://rubocop//lib/rubocop/config_store.rb#6
+class RuboCop::ConfigStore
+  # @return [ConfigStore] a new instance of ConfigStore
+  #
+  # source://rubocop//lib/rubocop/config_store.rb#10
+  def initialize; end
+
+  # If type (file/dir) is known beforehand,
+  # prefer using #for_file or #for_dir for improved performance
+  #
+  # source://rubocop//lib/rubocop/config_store.rb#52
+  def for(file_or_dir); end
+
+  # source://rubocop//lib/rubocop/config_store.rb#61
+  def for_dir(dir); end
+
+  # source://rubocop//lib/rubocop/config_store.rb#42
+  def for_file(file); end
+
+  # source://rubocop//lib/rubocop/config_store.rb#46
+  def for_pwd; end
+
+  # source://rubocop//lib/rubocop/config_store.rb#33
+  def force_default_config!; end
+
+  # source://rubocop//lib/rubocop/config_store.rb#28
+  def options_config=(options_config); end
+
+  # source://rubocop//lib/rubocop/config_store.rb#37
+  def unvalidated; end
+
+  # Returns the value of attribute validated.
+  #
+  # source://rubocop//lib/rubocop/config_store.rb#7
+  def validated; end
+
+  # Returns the value of attribute validated.
+  #
+  # source://rubocop//lib/rubocop/config_store.rb#7
+  def validated?; end
+end
+
+# Handles validation of configuration, for example cop names, parameter
+# names, and Ruby versions.
+#
+# source://rubocop//lib/rubocop/config_validator.rb#6
+class RuboCop::ConfigValidator
+  extend ::RuboCop::SimpleForwardable
+
+  # @return [ConfigValidator] a new instance of ConfigValidator
+  #
+  # source://rubocop//lib/rubocop/config_validator.rb#27
+  def initialize(config); end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def for_all_cops(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def smart_loaded_path(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop//lib/rubocop/config_validator.rb#63
+  def target_ruby_version; end
+
+  # source://rubocop//lib/rubocop/config_validator.rb#33
+  def validate; end
+
+  # Validations that should only be run after all config resolving has
+  # taken place:
+  # * The target ruby version is only checked once the entire inheritance
+  # chain has been loaded so that only the final value is validated, and
+  # any obsolete but overridden values are ignored.
+  #
+  # source://rubocop//lib/rubocop/config_validator.rb#59
+  def validate_after_resolution; end
+
+  # @raise [ValidationError]
+  #
+  # source://rubocop//lib/rubocop/config_validator.rb#67
+  def validate_section_presence(name); end
+
+  private
+
+  # @raise [ValidationError]
+  #
+  # source://rubocop//lib/rubocop/config_validator.rb#104
+  def alert_about_unrecognized_cops(invalid_cop_names); end
+
+  # source://rubocop//lib/rubocop/config_validator.rb#254
+  def check_cop_config_value(hash, parent = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/config_validator.rb#77
+  def check_obsoletions; end
+
+  # @raise [ValidationError]
+  #
+  # source://rubocop//lib/rubocop/config_validator.rb#84
+  def check_target_ruby; end
+
+  # source://rubocop//lib/rubocop/config_validator.rb#195
+  def each_invalid_parameter(cop_name); end
+
+  # source://rubocop//lib/rubocop/config_validator.rb#120
+  def list_unknown_cops(invalid_cop_names); end
+
+  # FIXME: Handling colors in exception messages like this is ugly.
+  #
+  # source://rubocop//lib/rubocop/config_validator.rb#274
+  def param_error_message(parent, key, value, supposed_values); end
+
+  # source://rubocop//lib/rubocop/config_validator.rb#242
+  def reject_conflicting_safe_settings; end
+
+  # @raise [ValidationError]
+  #
+  # source://rubocop//lib/rubocop/config_validator.rb#233
+  def reject_mutually_exclusive_defaults; end
+
+  # source://rubocop//lib/rubocop/config_validator.rb#142
+  def suggestion(name); end
+
+  # Returns the value of attribute target_ruby.
+  #
+  # source://rubocop//lib/rubocop/config_validator.rb#75
+  def target_ruby; end
+
+  # source://rubocop//lib/rubocop/config_validator.rb#207
+  def validate_enforced_styles(valid_cop_names); end
+
+  # @raise [ValidationError]
+  #
+  # source://rubocop//lib/rubocop/config_validator.rb#169
+  def validate_new_cops_parameter; end
+
+  # source://rubocop//lib/rubocop/config_validator.rb#180
+  def validate_parameter_names(valid_cop_names); end
+
+  # source://rubocop//lib/rubocop/config_validator.rb#227
+  def validate_support_and_has_list(name, formats, valid); end
+
+  # @raise [ValidationError]
+  #
+  # source://rubocop//lib/rubocop/config_validator.rb#158
+  def validate_syntax_cop; end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_validator.rb#10
+RuboCop::ConfigValidator::COMMON_PARAMS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/config_validator.rb#22
+RuboCop::ConfigValidator::CONFIG_CHECK_AUTOCORRECTS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/config_validator.rb#21
+RuboCop::ConfigValidator::CONFIG_CHECK_DEPARTMENTS = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_validator.rb#20
+RuboCop::ConfigValidator::CONFIG_CHECK_KEYS = T.let(T.unsafe(nil), Set)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_validator.rb#13
+RuboCop::ConfigValidator::INTERNAL_PARAMS = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/config_validator.rb#17
+RuboCop::ConfigValidator::NEW_COPS_VALUES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/util.rb#4
+module RuboCop::Cop; end
+
+# This module checks for nodes that should be aligned to the left or right.
+# This amount is determined by the instance variable @column_delta.
+#
+# source://rubocop//lib/rubocop/cop/mixin/alignment.rb#7
+module RuboCop::Cop::Alignment
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#26
+  def check_alignment(items, base_column = T.unsafe(nil)); end
+
+  # Returns the value of attribute column_delta.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#12
+  def column_delta; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#14
+  def configured_indentation_width; end
+
+  # @api public
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#58
+  def display_column(range); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#45
+  def each_bad_alignment(items, base_column); end
+
+  # @deprecated Use processed_source.line_with_comment?(line)
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#69
+  def end_of_line_comment(line); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#18
+  def indentation(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#22
+  def offset(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#78
+  def register_offense(offense_node, message_node); end
+
+  # @api public
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/alignment.rb#64
+  def within?(inner, outer); end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/alignment.rb#10
+RuboCop::Cop::Alignment::SPACE = T.let(T.unsafe(nil), String)
+
+# This class does autocorrection of nodes that should just be moved to
+# the left or to the right, amount being determined by the instance
+# variable column_delta.
+#
+# source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#8
+class RuboCop::Cop::AlignmentCorrector
+  extend ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::Alignment
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#29
+    def align_end(corrector, processed_source, node, align_to); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#15
+    def correct(corrector, processed_source, node, column_delta); end
+
+    # Returns the value of attribute processed_source.
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#13
+    def processed_source; end
+
+    private
+
+    # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#124
+    def alignment_column(align_to); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#40
+    def autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#81
+    def block_comment_within?(expr); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#87
+    def calculate_range(expr, line_begin_pos, column_delta); end
+
+    # Some special kinds of string literals are not composed of literal
+    # characters between two delimiters:
+    # - The source map of `?a` responds to :begin and :end but its end is
+    #   nil.
+    # - The source map of `__FILE__` responds to neither :begin nor :end.
+    #
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#75
+    def delimited_string_literal?(node); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#110
+    def each_line(expr); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#60
+    def inside_string_range(node); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#54
+    def inside_string_ranges(node); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#99
+    def remove(range, corrector); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/alignment_corrector.rb#118
+    def whitespace_range(node); end
+  end
+end
+
+# This module encapsulates the ability to allow certain identifiers in a cop.
+#
+# source://rubocop//lib/rubocop/cop/mixin/allowed_identifiers.rb#6
+module RuboCop::Cop::AllowedIdentifiers
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_identifiers.rb#9
+  def allowed_identifier?(name); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_identifiers.rb#13
+  def allowed_identifiers; end
+end
+
+# if a variable starts with a sigil it will be removed
+#
+# source://rubocop//lib/rubocop/cop/mixin/allowed_identifiers.rb#7
+RuboCop::Cop::AllowedIdentifiers::SIGILS = T.let(T.unsafe(nil), String)
+
+# This module encapsulates the ability to allow certain methods when
+# parsing. Even if the code is in offense, if it contains methods
+# that are allowed. This module is equivalent to the IgnoredMethods module,
+# which will be deprecated in RuboCop 2.0.
+#
+# source://rubocop//lib/rubocop/cop/mixin/allowed_methods.rb#9
+module RuboCop::Cop::AllowedMethods
+  private
+
+  # @api public
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_methods.rb#13
+  def allowed_method?(name); end
+
+  # @api public
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_methods.rb#27
+  def allowed_methods; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_methods.rb#35
+  def cop_config_allowed_methods; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_methods.rb#39
+  def cop_config_deprecated_values; end
+
+  # @deprecated Use allowed_method? instead
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_methods.rb#18
+  def ignored_method?; end
+end
+
+# This module encapsulates the ability to ignore certain lines when
+# parsing.
+#
+# source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#7
+module RuboCop::Cop::AllowedPattern
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#10
+  def allowed_line?(line); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#42
+  def allowed_patterns; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#58
+  def cop_config_deprecated_methods_values; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#52
+  def cop_config_patterns_values; end
+
+  # @deprecated Use allowed_line? instead
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#21
+  def ignored_line?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#29
+  def matches_allowed_pattern?(line); end
+
+  # @deprecated Use matches_allowed_pattern? instead
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#34
+  def matches_ignored_pattern?; end
+end
+
+# This module encapsulates the ability to allow certain receivers in a cop.
+#
+# source://rubocop//lib/rubocop/cop/mixin/allowed_receivers.rb#6
+module RuboCop::Cop::AllowedReceivers
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_receivers.rb#7
+  def allowed_receiver?(receiver); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_receivers.rb#29
+  def allowed_receivers; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/allowed_receivers.rb#13
+  def receiver_name(receiver); end
+end
+
+# Error raised when an unqualified cop name is used that could
+# refer to two or more cops under different departments
+#
+# source://rubocop//lib/rubocop/cop/registry.rb#7
+class RuboCop::Cop::AmbiguousCopName < ::RuboCop::Error
+  # @return [AmbiguousCopName] a new instance of AmbiguousCopName
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#11
+  def initialize(name, origin, badges); end
+end
+
+# source://rubocop//lib/rubocop/cop/registry.rb#8
+RuboCop::Cop::AmbiguousCopName::MSG = T.let(T.unsafe(nil), String)
+
+# Representation of an annotation comment in source code (eg. `# TODO: blah blah blah`).
+#
+# source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#6
+class RuboCop::Cop::AnnotationComment
+  # @param comment [Parser::Source::Comment]
+  # @param keywords [Array<String>]
+  # @return [AnnotationComment] a new instance of AnnotationComment
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#11
+  def initialize(comment, keywords); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#17
+  def annotation?; end
+
+  # Returns the range bounds for just the annotation
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#29
+  def bounds; end
+
+  # Returns the value of attribute colon.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#7
+  def colon; end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#7
+  def comment; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#21
+  def correct?(colon:); end
+
+  # Returns the value of attribute keyword.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#7
+  def keyword; end
+
+  # Returns the value of attribute margin.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#7
+  def margin; end
+
+  # Returns the value of attribute note.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#7
+  def note; end
+
+  # Returns the value of attribute space.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#7
+  def space; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#65
+  def just_keyword_of_sentence?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#61
+  def keyword_appearance?; end
+
+  # Returns the value of attribute keywords.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#37
+  def keywords; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#51
+  def regex; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#39
+  def split_comment(comment); end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/annotation_comment.rb#48
+RuboCop::Cop::AnnotationComment::KEYWORDS_REGEX_CACHE = T.let(T.unsafe(nil), Hash)
+
+# Handles the `MinSize` configuration option for array-based cops
+# `Style/SymbolArray` and `Style/WordArray`, which check for use of the
+# relevant percent literal syntax such as `%i[...]` and `%w[...]`
+#
+# source://rubocop//lib/rubocop/cop/mixin/array_min_size.rb#8
+module RuboCop::Cop::ArrayMinSize
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/array_min_size.rb#19
+  def array_style_detected(style, ary_size); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/array_min_size.rb#11
+  def below_array_length?(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/array_min_size.rb#38
+  def largest_brackets_size(style, ary_size); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/array_min_size.rb#15
+  def min_size_config; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/array_min_size.rb#48
+  def smallest_percent_size(style, ary_size); end
+end
+
+# Common code for ordinary arrays with [] that can be written with %
+# syntax.
+#
+# source://rubocop//lib/rubocop/cop/mixin/array_syntax.rb#7
+module RuboCop::Cop::ArraySyntax
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/array_syntax.rb#10
+  def bracketed_array_of?(element_type, node); end
+end
+
+# extend this module to signal autocorrection support
+#
+# source://rubocop//lib/rubocop/cop/mixin/auto_corrector.rb#6
+module RuboCop::Cop::AutoCorrector
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/auto_corrector.rb#7
+  def support_autocorrect?; end
+end
+
+# This module encapsulates the logic for autocorrect behavior for a cop.
+#
+# source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#6
+module RuboCop::Cop::AutocorrectLogic
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#7
+  def autocorrect?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#31
+  def autocorrect_enabled?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#15
+  def autocorrect_requested?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#11
+  def autocorrect_with_disable_uncorrectable?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#19
+  def correctable?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#23
+  def disable_uncorrectable?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#27
+  def safe_autocorrect?; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#51
+  def disable_offense(offense_range); end
+
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#118
+  def disable_offense_at_end_of_line(range, eol_comment); end
+
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#122
+  def disable_offense_before_and_after(range_by_lines); end
+
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#61
+  def disable_offense_with_eol_or_surround_comment(range); end
+
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#114
+  def max_line_length; end
+
+  # Expand the given range to include all of any lines it covers. Does not
+  # include newline at end of the last line.
+  #
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#104
+  def range_by_lines(range); end
+
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#95
+  def range_of_first_line(range); end
+
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#72
+  def surrounding_heredoc(offense_range); end
+
+  # source://rubocop//lib/rubocop/cop/autocorrect_logic.rb#83
+  def surrounding_percent_array(offense_range); end
+end
+
+# Identifier of all cops containing a department and cop name.
+#
+# All cops are identified by their badge. For example, the badge for
+# `RuboCop::Cop::Layout::IndentationStyle` is `Layout/IndentationStyle`.
+# Badges can be parsed as either `Department/CopName` or just `CopName` to
+# allow for badge references in source files that omit the department for
+# RuboCop to infer.
+#
+# source://rubocop//lib/rubocop/cop/badge.rb#12
+class RuboCop::Cop::Badge
+  # @return [Badge] a new instance of Badge
+  #
+  # source://rubocop//lib/rubocop/cop/badge.rb#34
+  def initialize(class_name_parts); end
+
+  # source://rubocop//lib/rubocop/cop/badge.rb#41
+  def ==(other); end
+
+  # Returns the value of attribute cop_name.
+  #
+  # source://rubocop//lib/rubocop/cop/badge.rb#13
+  def cop_name; end
+
+  # Returns the value of attribute department.
+  #
+  # source://rubocop//lib/rubocop/cop/badge.rb#13
+  def department; end
+
+  # Returns the value of attribute department_name.
+  #
+  # source://rubocop//lib/rubocop/cop/badge.rb#13
+  def department_name; end
+
+  # source://rubocop//lib/rubocop/cop/badge.rb#41
+  def eql?(other); end
+
+  # source://rubocop//lib/rubocop/cop/badge.rb#46
+  def hash; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/badge.rb#51
+  def match?(other); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/badge.rb#59
+  def qualified?; end
+
+  # source://rubocop//lib/rubocop/cop/badge.rb#55
+  def to_s; end
+
+  # source://rubocop//lib/rubocop/cop/badge.rb#63
+  def with_department(department); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/badge.rb#27
+    def camel_case(name_part); end
+
+    # source://rubocop//lib/rubocop/cop/badge.rb#15
+    def for(class_name); end
+
+    # source://rubocop//lib/rubocop/cop/badge.rb#23
+    def parse(identifier); end
+  end
+end
+
+# A scaffold for concrete cops.
+#
+# The Cop::Base class is meant to be extended.
+#
+# Cops track offenses and can autocorrect them on the fly.
+#
+# A commissioner object is responsible for traversing the AST and invoking
+# the specific callbacks on each cop.
+#
+# First the callback `on_new_investigation` is called;
+# if a cop needs to do its own processing of the AST or depends on
+# something else.
+#
+# Then callbacks like `on_def`, `on_send` (see AST::Traversal) are called
+# with their respective nodes.
+#
+# Finally the callback `on_investigation_end` is called.
+#
+# Within these callbacks, cops are meant to call `add_offense` or
+# `add_global_offense`. Use the `processed_source` method to
+# get the currently processed source being investigated.
+#
+# In case of invalid syntax / unparsable content,
+# the callback `on_other_file` is called instead of all the other
+# `on_...` callbacks.
+#
+# Private methods are not meant for custom cops consumption,
+# nor are any instance variables.
+#
+# source://rubocop//lib/rubocop/cop/base.rb#34
+class RuboCop::Cop::Base
+  include ::RuboCop::AST::Sexp
+  include ::RuboCop::PathUtil
+  include ::RuboCop::Cop::Util
+  include ::RuboCop::Cop::IgnoredNode
+  include ::RuboCop::Cop::AutocorrectLogic
+  extend ::RuboCop::AST::Sexp
+  extend ::RuboCop::AST::NodePattern::Macros
+  extend ::RuboCop::ExcludeLimit
+
+  # @return [Base] a new instance of Base
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#156
+  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#272
+  def active_support_extensions_enabled?; end
+
+  # Adds an offense that has no particular location.
+  # No correction can be applied to global offenses
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#189
+  def add_global_offense(message = T.unsafe(nil), severity: T.unsafe(nil)); end
+
+  # Adds an offense on the specified range (or node with an expression)
+  # Unless that offense is disabled for this range, a corrector will be yielded
+  # to provide the cop the opportunity to autocorrect the offense.
+  # If message is not specified, the method `message` will be called.
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#201
+  def add_offense(node_or_range, message: T.unsafe(nil), severity: T.unsafe(nil), &block); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#351
+  def always_autocorrect?; end
+
+  # Called before any investigation
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#337
+  def begin_investigation(processed_source, offset: T.unsafe(nil), original: T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#318
+  def callbacks_needed; end
+
+  # Returns the value of attribute config.
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#43
+  def config; end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#252
+  def config_to_allow_offenses; end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#256
+  def config_to_allow_offenses=(hash); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#357
+  def contextual_autocorrect?; end
+
+  # Configuration Helpers
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#246
+  def cop_config; end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#238
+  def cop_name; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#289
+  def excluded_file?(file); end
+
+  # This method should be overridden when a cop's behavior depends
+  # on state that lives outside of these locations:
+  #
+  #   (1) the file under inspection
+  #   (2) the cop's source code
+  #   (3) the config (eg a .rubocop.yml file)
+  #
+  # For example, some cops may want to look at other parts of
+  # the codebase being inspected to find violations. A cop may
+  # use the presence or absence of file `foo.rb` to determine
+  # whether a certain violation exists in `bar.rb`.
+  #
+  # Overriding this method allows the cop to indicate to RuboCop's
+  # ResultCache system when those external dependencies change,
+  # ie when the ResultCache should be invalidated.
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#234
+  def external_dependency_checksum; end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#361
+  def inspect; end
+
+  # Gets called if no message is specified when calling `add_offense` or
+  # `add_global_offense`
+  # Cops are discouraged to override this; instead pass your message directly
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#183
+  def message(_range = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#238
+  def name; end
+
+  # @deprecated Make potential errors with previous API more obvious
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#309
+  def offenses; end
+
+  # Called after all on_... have been called
+  # When refining this method, always call `super`
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#170
+  def on_investigation_end; end
+
+  # Called before all on_... have been called
+  # When refining this method, always call `super`
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#164
+  def on_new_investigation; end
+
+  # Called instead of all on_... callbacks for unrecognized files / syntax errors
+  # When refining this method, always call `super`
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#176
+  def on_other_file; end
+
+  # There should be very limited reasons for a Cop to do it's own parsing
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#294
+  def parse(source, path = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#264
+  def parser_engine; end
+
+  # Returns the value of attribute processed_source.
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#43
+  def processed_source; end
+
+  # Called between investigations
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#300
+  def ready; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#280
+  def relevant_file?(file); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#276
+  def string_literals_frozen_by_default?; end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#268
+  def target_rails_version; end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#260
+  def target_ruby_version; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/base.rb#479
+  def annotate(message); end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#373
+  def apply_correction(corrector); end
+
+  # @return [Symbol] offense status
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#443
+  def attempt_correction(range, corrector); end
+
+  # Reserved for Cop::Cop
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#369
+  def callback_argument(range); end
+
+  # Called to complete an investigation
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#402
+  def complete_investigation; end
+
+  # @return [Symbol, Corrector] offense status
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#417
+  def correct(range); end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#387
+  def current_corrector; end
+
+  # Reserved for Commissioner:
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#379
+  def current_offense_locations; end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#391
+  def current_offenses; end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#383
+  def currently_disabled_lines; end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#507
+  def custom_severity; end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#503
+  def default_severity; end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#457
+  def disable_uncorrectable(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#493
+  def enabled_line?(line_number); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#485
+  def file_name_matches_any?(file, parameter, default_result); end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#475
+  def find_message(range, message); end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#499
+  def find_severity(_range, severity); end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#520
+  def range_for_original(range); end
+
+  # source://rubocop//lib/rubocop/cop/base.rb#464
+  def range_from_node_or_range(node_or_range); end
+
+  # Actually private methods
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#412
+  def reset_investigation; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#528
+  def target_satisfies_all_gem_version_requirements?; end
+
+  # @return [Symbol] offense status
+  #
+  # source://rubocop//lib/rubocop/cop/base.rb#432
+  def use_corrector(range, corrector); end
+
+  class << self
+    # List of cops that should not try to autocorrect at the same
+    # time as this cop
+    #
+    # @api public
+    # @return [Array<RuboCop::Cop::Base>]
+    #
+    # source://rubocop//lib/rubocop/cop/base.rb#59
+    def autocorrect_incompatible_with; end
+
+    # Naming
+    #
+    # source://rubocop//lib/rubocop/cop/base.rb#93
+    def badge; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/cop/base.rb#323
+    def callbacks_needed; end
+
+    # source://rubocop//lib/rubocop/cop/base.rb#97
+    def cop_name; end
+
+    # source://rubocop//lib/rubocop/cop/base.rb#101
+    def department; end
+
+    # Returns an url to view this cops documentation online.
+    # Requires 'DocumentationBaseURL' to be set for your department.
+    # Will follow the convention of RuboCops own documentation structure,
+    # overwrite this method to accommodate your custom layout.
+    #
+    # @api public
+    # @return [String, nil]
+    #
+    # source://rubocop//lib/rubocop/cop/base.rb#70
+    def documentation_url(config = T.unsafe(nil)); end
+
+    # Call for abstract Cop classes
+    #
+    # source://rubocop//lib/rubocop/cop/base.rb#81
+    def exclude_from_registry; end
+
+    # Returns the value of attribute gem_requirements.
+    #
+    # source://rubocop//lib/rubocop/cop/base.rb#138
+    def gem_requirements; end
+
+    # @private
+    #
+    # source://rubocop//lib/rubocop/cop/base.rb#74
+    def inherited(subclass); end
+
+    # Override and return the Force class(es) you need to join
+    #
+    # source://rubocop//lib/rubocop/cop/base.rb#118
+    def joining_forces; end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/base.rb#105
+    def lint?; end
+
+    # Returns true if the cop name or the cop namespace matches any of the
+    # given names.
+    #
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/base.rb#111
+    def match?(given_names); end
+
+    # Register a version requirement for the given gem name.
+    # This cop will be skipped unless the target satisfies *all* requirements.
+    #
+    # @api public
+    # @param gem_name [String]
+    # @param version_requirements [Array<String>] The version requirements,
+    #   using the same syntax as a Gemfile, e.g. ">= 1.2.3"
+    #
+    #   If omitted, any version of the gem will be accepted.
+    #
+    #   https://guides.rubygems.org/patterns/#declaring-dependencies
+    #
+    # source://rubocop//lib/rubocop/cop/base.rb#151
+    def requires_gem(gem_name, *version_requirements); end
+
+    # Returns if class supports autocorrect.
+    # It is recommended to extend AutoCorrector instead of overriding
+    #
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/base.rb#87
+    def support_autocorrect?; end
+
+    # Override if your cop should be called repeatedly for multiple investigations
+    # Between calls to `on_new_investigation` and `on_investigation_end`,
+    # the result of `processed_source` will remain constant.
+    # You should invalidate any caches that depend on the current `processed_source`
+    # in the `on_new_investigation` callback.
+    # If your cop does autocorrections, be aware that your instance may be called
+    # multiple times with the same `processed_source.path` but different content.
+    #
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/base.rb#129
+    def support_multiple_source?; end
+
+    private
+
+    # source://rubocop//lib/rubocop/cop/base.rb#395
+    def restrict_on_send; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/base.rb#399
+RuboCop::Cop::Base::EMPTY_OFFENSES = T.let(T.unsafe(nil), Array)
+
+# Reports of an investigation.
+# Immutable
+# Consider creation API private
+#
+# source://rubocop//lib/rubocop/cop/base.rb#48
+class RuboCop::Cop::Base::InvestigationReport < ::Struct
+  # Returns the value of attribute cop
+  #
+  # @return [Object] the current value of cop
+  def cop; end
+
+  # Sets the attribute cop
+  #
+  # @param value [Object] the value to set the attribute cop to.
+  # @return [Object] the newly set value
+  def cop=(_); end
+
+  # Returns the value of attribute corrector
+  #
+  # @return [Object] the current value of corrector
+  def corrector; end
+
+  # Sets the attribute corrector
+  #
+  # @param value [Object] the value to set the attribute corrector to.
+  # @return [Object] the newly set value
+  def corrector=(_); end
+
+  # Returns the value of attribute offenses
+  #
+  # @return [Object] the current value of offenses
+  def offenses; end
+
+  # Sets the attribute offenses
+  #
+  # @param value [Object] the value to set the attribute offenses to.
+  # @return [Object] the newly set value
+  def offenses=(_); end
+
+  # Returns the value of attribute processed_source
+  #
+  # @return [Object] the current value of processed_source
+  def processed_source; end
+
+  # Sets the attribute processed_source
+  #
+  # @param value [Object] the value to set the attribute processed_source to.
+  # @return [Object] the newly set value
+  def processed_source=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# List of methods names to restrict calls for `on_send` / `on_csend`
+#
+# source://rubocop//lib/rubocop/cop/base.rb#51
+RuboCop::Cop::Base::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#5
+module RuboCop::Cop::Bundler; end
+
+# A Gem's requirements should be listed only once in a Gemfile.
+#
+# @example
+#   # bad
+#   gem 'rubocop'
+#   gem 'rubocop'
+#
+#   # bad
+#   group :development do
+#   gem 'rubocop'
+#   end
+#
+#   group :test do
+#   gem 'rubocop'
+#   end
+#
+#   # good
+#   group :development, :test do
+#   gem 'rubocop'
+#   end
+#
+#   # good
+#   gem 'rubocop', groups: [:development, :test]
+#
+#   # good - conditional declaration
+#   if Dir.exist?(local)
+#   gem 'rubocop', path: local
+#   elsif ENV['RUBOCOP_VERSION'] == 'master'
+#   gem 'rubocop', git: 'https://github.com/rubocop/rubocop.git'
+#   else
+#   gem 'rubocop', '~> 0.90.0'
+#   end
+#
+# source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#39
+class RuboCop::Cop::Bundler::DuplicatedGem < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#58
+  def gem_declarations(param0); end
+
+  # source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#45
+  def on_new_investigation; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#67
+  def conditional_declaration?(nodes); end
+
+  # source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#60
+  def duplicated_gem_nodes; end
+
+  # source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#81
+  def register_offense(node, gem_name, line_of_first_occurrence); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#75
+  def within_conditional?(node, conditional_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/bundler/duplicated_gem.rb#42
+RuboCop::Cop::Bundler::DuplicatedGem::MSG = T.let(T.unsafe(nil), String)
+
+# A Gem group, or a set of groups, should be listed only once in a Gemfile.
+#
+# For example, if the values of `source`, `git`, `platforms`, or `path`
+# surrounding `group` are different, no offense will be registered:
+#
+# [source,ruby]
+# -----
+# platforms :ruby do
+#   group :default do
+#     gem 'openssl'
+#   end
+# end
+#
+# platforms :jruby do
+#   group :default do
+#     gem 'jruby-openssl'
+#   end
+# end
+# -----
+#
+# @example
+#   # bad
+#   group :development do
+#   gem 'rubocop'
+#   end
+#
+#   group :development do
+#   gem 'rubocop-rails'
+#   end
+#
+#   # bad (same set of groups declared twice)
+#   group :development, :test do
+#   gem 'rubocop'
+#   end
+#
+#   group :test, :development do
+#   gem 'rspec'
+#   end
+#
+#   # good
+#   group :development do
+#   gem 'rubocop'
+#   end
+#
+#   group :development, :test do
+#   gem 'rspec'
+#   end
+#
+#   # good
+#   gem 'rubocop', groups: [:development, :test]
+#   gem 'rspec', groups: [:development, :test]
+#
+# source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#58
+class RuboCop::Cop::Bundler::DuplicatedGroup < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#66
+  def group_declarations(param0); end
+
+  # source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#68
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#82
+  def duplicated_group_nodes; end
+
+  # source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#105
+  def find_source_key(node); end
+
+  # source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#115
+  def group_attributes(node); end
+
+  # source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#94
+  def register_offense(node, group_name, line_of_first_occurrence); end
+end
+
+# source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#61
+RuboCop::Cop::Bundler::DuplicatedGroup::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/bundler/duplicated_group.rb#63
+RuboCop::Cop::Bundler::DuplicatedGroup::SOURCE_BLOCK_NAMES = T.let(T.unsafe(nil), Array)
+
+# Each gem in the Gemfile should have a comment explaining
+# its purpose in the project, or the reason for its version
+# or source.
+#
+# The optional "OnlyFor" configuration array
+# can be used to only register offenses when the gems
+# use certain options or have version specifiers.
+#
+# When "version_specifiers" is included, a comment
+# will be enforced if the gem has any version specifier.
+#
+# When "restrictive_version_specifiers" is included, a comment
+# will be enforced if the gem has a version specifier that
+# holds back the version of the gem.
+#
+# For any other value in the array, a comment will be enforced for
+# a gem if an option by the same name is present.
+# A useful use case is to enforce a comment when using
+# options that change the source of a gem:
+#
+# - `bitbucket`
+# - `gist`
+# - `git`
+# - `github`
+# - `source`
+#
+# For a full list of options supported by bundler,
+# see https://bundler.io/man/gemfile.5.html
+# .
+#
+# @example OnlyFor: [] (default)
+#   # bad
+#
+#   gem 'foo'
+#
+#   # good
+#
+#   # Helpers for the foo things.
+#   gem 'foo'
+# @example OnlyFor: ['version_specifiers']
+#   # bad
+#
+#   gem 'foo', '< 2.1'
+#
+#   # good
+#
+#   # Version 2.1 introduces breaking change baz
+#   gem 'foo', '< 2.1'
+# @example OnlyFor: ['restrictive_version_specifiers']
+#   # bad
+#
+#   gem 'foo', '< 2.1'
+#
+#   # good
+#
+#   gem 'foo', '>= 1.0'
+#
+#   # Version 2.1 introduces breaking change baz
+#   gem 'foo', '< 2.1'
+# @example OnlyFor: ['version_specifiers', 'github']
+#   # bad
+#
+#   gem 'foo', github: 'some_account/some_fork_of_foo'
+#
+#   gem 'bar', '< 2.1'
+#
+#   # good
+#
+#   # Using this fork because baz
+#   gem 'foo', github: 'some_account/some_fork_of_foo'
+#
+#   # Version 2.1 introduces breaking change baz
+#   gem 'bar', '< 2.1'
+#
+# source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#83
+class RuboCop::Cop::Bundler::GemComment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::VisibilityHelp
+  include ::RuboCop::Cop::DefNode
+  include ::RuboCop::Cop::GemDeclaration
+
+  # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#94
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#135
+  def checked_options_present?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#109
+  def commented?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#105
+  def commented_any_descendant?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#159
+  def contains_checked_options?(node); end
+
+  # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#163
+  def gem_options(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#130
+  def ignored_gem?(node); end
+
+  # The args node1 & node2 may represent a RuboCop::AST::Node
+  # or a Parser::Source::Comment. Both respond to #loc.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#116
+  def precede?(node1, node2); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#126
+  def preceding_comment?(node1, node2); end
+
+  # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#120
+  def preceding_lines(node); end
+
+  # Version specifications that restrict all updates going forward. This excludes versions
+  # like ">= 1.0" or "!= 2.0.3".
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#152
+  def restrictive_version_specified_gem?(node); end
+
+  # Besides the gem name, all other *positional* arguments to `gem` are version specifiers,
+  # as long as it has one we know there's at least one version specifier.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#145
+  def version_specified_gem?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#88
+RuboCop::Cop::Bundler::GemComment::CHECKED_OPTIONS_CONFIG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#87
+RuboCop::Cop::Bundler::GemComment::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#91
+RuboCop::Cop::Bundler::GemComment::RESTRICTIVE_VERSION_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#90
+RuboCop::Cop::Bundler::GemComment::RESTRICTIVE_VERSION_SPECIFIERS_OPTION = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#92
+RuboCop::Cop::Bundler::GemComment::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_comment.rb#89
+RuboCop::Cop::Bundler::GemComment::VERSION_SPECIFIERS_OPTION = T.let(T.unsafe(nil), String)
+
+# Verifies that a project contains Gemfile or gems.rb file and correct
+# associated lock file based on the configuration.
+#
+# @example EnforcedStyle: Gemfile (default)
+#   # bad
+#   Project contains gems.rb and gems.locked files
+#
+#   # bad
+#   Project contains Gemfile and gems.locked file
+#
+#   # good
+#   Project contains Gemfile and Gemfile.lock
+# @example EnforcedStyle: gems.rb
+#   # bad
+#   Project contains Gemfile and Gemfile.lock files
+#
+#   # bad
+#   Project contains gems.rb and Gemfile.lock file
+#
+#   # good
+#   Project contains gems.rb and gems.locked files
+#
+# source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#28
+class RuboCop::Cop::Bundler::GemFilename < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#43
+  def on_new_investigation; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#88
+  def expected_gemfile?(basename); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#80
+  def gemfile_offense?(basename); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#93
+  def gemfile_required?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#84
+  def gems_rb_offense?(basename); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#97
+  def gems_rb_required?; end
+
+  # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#58
+  def register_gemfile_offense(file_path, basename); end
+
+  # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#69
+  def register_gems_rb_offense(file_path, basename); end
+
+  # source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#53
+  def register_offense(file_path, basename); end
+end
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#40
+RuboCop::Cop::Bundler::GemFilename::GEMFILE_FILES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#41
+RuboCop::Cop::Bundler::GemFilename::GEMS_RB_FILES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#36
+RuboCop::Cop::Bundler::GemFilename::MSG_GEMFILE_MISMATCHED = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#32
+RuboCop::Cop::Bundler::GemFilename::MSG_GEMFILE_REQUIRED = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#38
+RuboCop::Cop::Bundler::GemFilename::MSG_GEMS_RB_MISMATCHED = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_filename.rb#34
+RuboCop::Cop::Bundler::GemFilename::MSG_GEMS_RB_REQUIRED = T.let(T.unsafe(nil), String)
+
+# Enforce that Gem version specifications or a commit reference (branch,
+# ref, or tag) are either required or forbidden.
+#
+# @example EnforcedStyle: required (default)
+#   # bad
+#   gem 'rubocop'
+#
+#   # good
+#   gem 'rubocop', '~> 1.12'
+#
+#   # good
+#   gem 'rubocop', '>= 1.10.0'
+#
+#   # good
+#   gem 'rubocop', '>= 1.5.0', '< 1.10.0'
+#
+#   # good
+#   gem 'rubocop', branch: 'feature-branch'
+#
+#   # good
+#   gem 'rubocop', ref: '74b5bfbb2c4b6fd6cdbbc7254bd7084b36e0c85b'
+#
+#   # good
+#   gem 'rubocop', tag: 'v1.17.0'
+# @example EnforcedStyle: forbidden
+#   # good
+#   gem 'rubocop'
+#
+#   # bad
+#   gem 'rubocop', '~> 1.12'
+#
+#   # bad
+#   gem 'rubocop', '>= 1.10.0'
+#
+#   # bad
+#   gem 'rubocop', '>= 1.5.0', '< 1.10.0'
+#
+#   # bad
+#   gem 'rubocop', branch: 'feature-branch'
+#
+#   # bad
+#   gem 'rubocop', ref: '74b5bfbb2c4b6fd6cdbbc7254bd7084b36e0c85b'
+#
+#   # bad
+#   gem 'rubocop', tag: 'v1.17.0'
+#
+# source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#53
+class RuboCop::Cop::Bundler::GemVersion < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::GemDeclaration
+
+  # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#68
+  def includes_commit_reference?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#63
+  def includes_version_specification?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#72
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#86
+  def allowed_gem?(node); end
+
+  # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#90
+  def allowed_gems; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#112
+  def forbidden_offense?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#118
+  def forbidden_style?; end
+
+  # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#94
+  def message(_range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#102
+  def offense?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#106
+  def required_offense?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#122
+  def required_style?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#126
+  def version_specification?(expression); end
+end
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#58
+RuboCop::Cop::Bundler::GemVersion::FORBIDDEN_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#57
+RuboCop::Cop::Bundler::GemVersion::REQUIRED_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#59
+RuboCop::Cop::Bundler::GemVersion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/bundler/gem_version.rb#60
+RuboCop::Cop::Bundler::GemVersion::VERSION_SPECIFICATION_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# Passing symbol arguments to `source` (e.g. `source :rubygems`) is
+# deprecated because they default to using HTTP requests. Instead, specify
+# `'https://rubygems.org'` if possible, or `'http://rubygems.org'` if not.
+#
+# When autocorrecting, this cop will replace symbol arguments with
+# `'https://rubygems.org'`.
+#
+# This cop will not replace existing sources that use `http://`. This may
+# be necessary where HTTPS is not available. For example, where using an
+# internal gem server via an intranet, or where HTTPS is prohibited.
+# However, you should strongly prefer `https://` where possible, as it is
+# more secure.
+#
+# If you don't allow `http://`, please set `false` to `AllowHttpProtocol`.
+# This option is `true` by default for safe autocorrection.
+#
+# @example
+#   # bad
+#   source :gemcutter
+#   source :rubygems
+#   source :rubyforge
+#
+#   # good
+#   source 'https://rubygems.org' # strongly recommended
+# @example AllowHttpProtocol: true (default)
+#
+#   # good
+#   source 'http://rubygems.org' # use only if HTTPS is unavailable
+# @example AllowHttpProtocol: false
+#
+#   # bad
+#   source 'http://rubygems.org'
+#
+# source://rubocop//lib/rubocop/cop/bundler/insecure_protocol_source.rb#41
+class RuboCop::Cop::Bundler::InsecureProtocolSource < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/bundler/insecure_protocol_source.rb#54
+  def insecure_protocol_source?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/bundler/insecure_protocol_source.rb#59
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/bundler/insecure_protocol_source.rb#80
+  def allow_http_protocol?; end
+end
+
+# source://rubocop//lib/rubocop/cop/bundler/insecure_protocol_source.rb#45
+RuboCop::Cop::Bundler::InsecureProtocolSource::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/bundler/insecure_protocol_source.rb#49
+RuboCop::Cop::Bundler::InsecureProtocolSource::MSG_HTTP_PROTOCOL = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/bundler/insecure_protocol_source.rb#51
+RuboCop::Cop::Bundler::InsecureProtocolSource::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Gems should be alphabetically sorted within groups.
+#
+# @example
+#   # bad
+#   gem 'rubocop'
+#   gem 'rspec'
+#
+#   # good
+#   gem 'rspec'
+#   gem 'rubocop'
+#
+#   # good
+#   gem 'rubocop'
+#
+#   gem 'rspec'
+# @example TreatCommentsAsGroupSeparators: true (default)
+#   # good
+#   # For code quality
+#   gem 'rubocop'
+#   # For tests
+#   gem 'rspec'
+# @example TreatCommentsAsGroupSeparators: false
+#   # bad
+#   # For code quality
+#   gem 'rubocop'
+#   # For tests
+#   gem 'rspec'
+#
+# source://rubocop//lib/rubocop/cop/bundler/ordered_gems.rb#35
+class RuboCop::Cop::Bundler::OrderedGems < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::OrderedGemNode
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/bundler/ordered_gems.rb#64
+  def gem_declarations(param0); end
+
+  # source://rubocop//lib/rubocop/cop/bundler/ordered_gems.rb#43
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/bundler/ordered_gems.rb#57
+  def previous_declaration(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/bundler/ordered_gems.rb#39
+RuboCop::Cop::Bundler::OrderedGems::MSG = T.let(T.unsafe(nil), String)
+
+# Common functionality for checking assignment nodes.
+#
+# source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#6
+module RuboCop::Cop::CheckAssignment
+  # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7
+  def on_and_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7
+  def on_casgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7
+  def on_cvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7
+  def on_gvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7
+  def on_ivasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7
+  def on_lvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7
+  def on_masgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7
+  def on_op_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#7
+  def on_or_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#19
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#29
+  def extract_rhs(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/mixin/check_assignment.rb#29
+    def extract_rhs(node); end
+  end
+end
+
+# This mixin detects collections that are safe to "break"
+# by inserting new lines. This is useful for breaking
+# up long lines.
+#
+# Let's look at hashes as an example:
+#
+# We know hash keys are safe to break across lines. We can add
+# linebreaks into hashes on lines longer than the specified maximum.
+# Then in further passes cops can clean up the multi-line hash.
+# For example, say the maximum line length is as indicated below:
+#
+#                                         |
+#                                         v
+# {foo: "0000000000", bar: "0000000000", baz: "0000000000"}
+#
+# In a LineLength autocorrection pass, a line is added before
+# the first key that exceeds the column limit:
+#
+# {foo: "0000000000", bar: "0000000000",
+# baz: "0000000000"}
+#
+# In a MultilineHashKeyLineBreaks pass, lines are inserted
+# before all keys:
+#
+# {foo: "0000000000",
+# bar: "0000000000",
+# baz: "0000000000"}
+#
+# Then in future passes FirstHashElementLineBreak,
+# MultilineHashBraceLayout, and TrailingCommaInHashLiteral will
+# manipulate as well until we get:
+#
+# {
+#   foo: "0000000000",
+#   bar: "0000000000",
+#   baz: "0000000000",
+# }
+#
+# (Note: Passes may not happen exactly in this sequence.)
+#
+# source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#44
+module RuboCop::Cop::CheckLineBreakable
+  # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#45
+  def extract_breakable_node(node, max); end
+
+  private
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#200
+  def all_on_same_line?(nodes); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#220
+  def already_on_multiple_lines?(node); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#133
+  def breakable_collection?(node, elements); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#187
+  def children_could_be_broken_up?(children); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#150
+  def contained_by_breakable_collection_on_same_line?(node); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#170
+  def contained_by_multiline_collection_that_could_be_broken_up?(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#60
+  def extract_breakable_node_from_elements(node, elements, max); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#72
+  def extract_first_element_over_column_limit(node, elements, max); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#92
+  def first_argument_is_heredoc?(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#207
+  def process_args(args); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#117
+  def safe_to_ignore?(node); end
+
+  # If a send node contains a heredoc argument, splitting cannot happen
+  # after the heredoc or else it will cause a syntax error.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#101
+  def shift_elements_for_heredoc_arg(node, elements, index); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/check_line_breakable.rb#112
+  def within_column_limit?(element, max, line); end
+end
+
+# Common functionality for checking length of code segments.
+#
+# source://rubocop//lib/rubocop/cop/mixin/code_length.rb#6
+module RuboCop::Cop::CodeLength
+  extend ::RuboCop::ExcludeLimit
+
+  # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11
+  def max=(value); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#49
+  def build_code_length_calculator(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#31
+  def check_code_length(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#27
+  def count_as_one; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#23
+  def count_comments?; end
+
+  # Returns true for lines that shall not be included in the count.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#45
+  def irrelevant_line(source_line); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#58
+  def location(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#19
+  def max_length; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/code_length.rb#15
+  def message(length, max_length); end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/code_length.rb#9
+RuboCop::Cop::CodeLength::MSG = T.let(T.unsafe(nil), String)
+
+# Help methods for working with nodes containing comments.
+#
+# source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#6
+module RuboCop::Cop::CommentsHelp
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#25
+  def comments_contain_disables?(node, cop_name); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#18
+  def comments_in_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#14
+  def contains_comments?(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#7
+  def source_range_with_comment(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#44
+  def begin_pos_with_comment(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#58
+  def buffer; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#39
+  def end_position_for(node); end
+
+  # Returns the end line of a node, which might be a comment and not part of the AST
+  # End line is considered either the line at which another node starts, or
+  # the line at which the parent node ends.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#66
+  def find_end_line(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/comments_help.rb#54
+  def start_line_position(node); end
+end
+
+# Commissioner class is responsible for processing the AST and delegating
+# work to the specified cops.
+#
+# source://rubocop//lib/rubocop/cop/commissioner.rb#7
+class RuboCop::Cop::Commissioner
+  include ::RuboCop::AST::Traversal
+
+  # @return [Commissioner] a new instance of Commissioner
+  #
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#44
+  def initialize(cops, forces = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  # Returns the value of attribute errors.
+  #
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#42
+  def errors; end
+
+  # @return [InvestigationReport]
+  #
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#79
+  def investigate(processed_source, offset: T.unsafe(nil), original: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on___ENCODING__(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on___FILE__(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on___LINE__(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_alias(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_and(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_and_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_arg(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_arg_expr(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_args(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_array(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_array_pattern(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_array_pattern_with_tail(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_back_ref(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_begin(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_block_pass(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_blockarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_break(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_case(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_case_match(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_casgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_cbase(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_complex(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_const(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_const_pattern(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_cvar(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_cvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_defined?(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_dstr(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_dsym(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_eflipflop(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_empty_else(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_ensure(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_erange(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_false(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_find_pattern(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_float(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_for(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_forward_arg(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_forward_args(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_forwarded_args(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_forwarded_kwrestarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_forwarded_restarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_gvar(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_gvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_hash(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_hash_pattern(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_if_guard(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_iflipflop(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_in_match(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_in_pattern(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_index(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_indexasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_int(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_irange(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_ivar(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_ivasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_kwarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_kwargs(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_kwbegin(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_kwnilarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_kwoptarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_kwrestarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_kwsplat(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_lambda(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_lvar(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_lvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_masgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_match_alt(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_match_as(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_match_current_line(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_match_nil_pattern(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_match_pattern(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_match_pattern_p(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_match_rest(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_match_var(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_match_with_lvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_match_with_trailing_comma(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_mlhs(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_module(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_next(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_nil(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_not(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_nth_ref(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_op_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_optarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_or(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_or_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_pair(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_pin(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_postexe(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_preexe(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_procarg0(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_rational(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_redo(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_regexp(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_regopt(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_resbody(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_rescue(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_restarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_retry(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_return(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_sclass(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_self(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_shadowarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_splat(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_str(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_super(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_sym(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_true(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_undef(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_unless_guard(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_until_post(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_when(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_while(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_while_post(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_xstr(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_yield(node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#68
+  def on_zsuper(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#98
+  def begin_investigation(processed_source, offset:, original:); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#121
+  def build_callbacks(cops); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#116
+  def initialize_callbacks; end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#159
+  def invoke(callback, cops); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#163
+  def invoke_with_argument(callback, cops, arg); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#112
+  def reset; end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#131
+  def restrict_callbacks(callbacks); end
+
+  # NOTE: mutates `callbacks` in place
+  #
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#149
+  def restricted_map(callbacks); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#104
+  def trigger_responding_cops(callback, node); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#139
+  def trigger_restricted_cops(event, node); end
+
+  # Allow blind rescues here, since we're absorbing and packaging or
+  # re-raising exceptions that can be raised from within the individual
+  # cops' `#investigate` methods.
+  #
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#170
+  def with_cop_error_handling(cop, node = T.unsafe(nil)); end
+end
+
+# How a Commissioner returns the results of the investigation
+# as a list of Cop::InvestigationReport and any errors caught
+# during the investigation.
+# Immutable
+# Consider creation API private
+#
+# source://rubocop//lib/rubocop/cop/commissioner.rb#18
+class RuboCop::Cop::Commissioner::InvestigationReport < ::Struct
+  # Returns the value of attribute cop_reports
+  #
+  # @return [Object] the current value of cop_reports
+  def cop_reports; end
+
+  # Sets the attribute cop_reports
+  #
+  # @param value [Object] the value to set the attribute cop_reports to.
+  # @return [Object] the newly set value
+  def cop_reports=(_); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#19
+  def cops; end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#27
+  def correctors; end
+
+  # Returns the value of attribute errors
+  #
+  # @return [Object] the current value of errors
+  def errors; end
+
+  # Sets the attribute errors
+  #
+  # @param value [Object] the value to set the attribute errors to.
+  # @return [Object] the newly set value
+  def errors=(_); end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#35
+  def merge(investigation); end
+
+  # source://rubocop-md/1.2.4/lib/rubocop/markdown/rubocop_ext.rb#77
+  def offenses; end
+
+  # source://rubocop//lib/rubocop/cop/commissioner.rb#23
+  def offenses_per_cop; end
+
+  # Returns the value of attribute processed_source
+  #
+  # @return [Object] the current value of processed_source
+  def processed_source; end
+
+  # Sets the attribute processed_source
+  #
+  # @param value [Object] the value to set the attribute processed_source to.
+  # @return [Object] the newly set value
+  def processed_source=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/commissioner.rb#10
+RuboCop::Cop::Commissioner::RESTRICTED_CALLBACKS = T.let(T.unsafe(nil), Array)
+
+# This class does condition autocorrection
+#
+# source://rubocop//lib/rubocop/cop/correctors/condition_corrector.rb#6
+class RuboCop::Cop::ConditionCorrector
+  class << self
+    # source://rubocop//lib/rubocop/cop/correctors/condition_corrector.rb#8
+    def correct_negative_condition(corrector, node); end
+
+    private
+
+    # source://rubocop//lib/rubocop/cop/correctors/condition_corrector.rb#17
+    def negated_condition(node); end
+  end
+end
+
+# Handles `EnforcedStyle` configuration parameters.
+#
+# source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#6
+module RuboCop::Cop::ConfigurableEnforcedStyle
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#88
+  def alternative_style; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#96
+  def alternative_styles; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#19
+  def ambiguous_style_detected(*possibilities); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#60
+  def conflicting_styles_detected; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#11
+  def correct_style_detected; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#64
+  def detected_style; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#68
+  def detected_style=(style); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#60
+  def no_acceptable_style!; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#56
+  def no_acceptable_style?; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#7
+  def opposite_style_detected; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#79
+  def style; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#75
+  def style_configured?; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#29
+  def style_detected(detected); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#107
+  def style_parameter_name; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#100
+  def supported_styles; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#15
+  def unexpected_style_detected(unexpected); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#60
+  def unrecognized_style_detected; end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/configurable_enforced_style.rb#23
+RuboCop::Cop::ConfigurableEnforcedStyle::SYMBOL_TO_STRING_CACHE = T.let(T.unsafe(nil), Hash)
+
+# Shared functionality between mixins that enforce naming conventions
+#
+# source://rubocop//lib/rubocop/cop/mixin/configurable_formatting.rb#6
+module RuboCop::Cop::ConfigurableFormatting
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_formatting.rb#9
+  def check_name(node, name, name_range); end
+
+  # A class emitter method is a singleton method in a class/module, where
+  # the method has the same name as a class defined in the class/module.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_formatting.rb#30
+  def class_emitter_method?(node, name); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_formatting.rb#17
+  def report_opposing_styles(node, name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_formatting.rb#24
+  def valid_name?(node, name, given_style = T.unsafe(nil)); end
+end
+
+# Handles `Max` configuration parameters, especially setting them to an
+# appropriate value with --auto-gen-config.
+#
+# @deprecated Use `exclude_limit <ParameterName>` instead.
+#
+# source://rubocop//lib/rubocop/cop/mixin/configurable_max.rb#8
+module RuboCop::Cop::ConfigurableMax
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_max.rb#11
+  def max=(value); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/configurable_max.rb#23
+  def max_parameter_name; end
+end
+
+# This module provides functionality for checking if names match the
+# configured EnforcedStyle.
+#
+# source://rubocop//lib/rubocop/cop/mixin/configurable_naming.rb#7
+module RuboCop::Cop::ConfigurableNaming
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::ConfigurableFormatting
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/configurable_naming.rb#10
+RuboCop::Cop::ConfigurableNaming::FORMATS = T.let(T.unsafe(nil), Hash)
+
+# This module provides functionality for checking if numbering match the
+# configured EnforcedStyle.
+#
+# source://rubocop//lib/rubocop/cop/mixin/configurable_numbering.rb#7
+module RuboCop::Cop::ConfigurableNumbering
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::ConfigurableFormatting
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/configurable_numbering.rb#11
+RuboCop::Cop::ConfigurableNumbering::FORMATS = T.let(T.unsafe(nil), Hash)
+
+# Monkey-patch Cop for tests to provide easy access to messages and
+# highlights.
+#
+# source://rubocop//lib/rubocop/cop/cop.rb#11
+class RuboCop::Cop::Cop < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/cop.rb#73
+  def add_offense(node_or_range, location: T.unsafe(nil), message: T.unsafe(nil), severity: T.unsafe(nil), &block); end
+
+  # Called before any investigation
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/cop.rb#129
+  def begin_investigation(processed_source, offset: T.unsafe(nil), original: T.unsafe(nil)); end
+
+  # @deprecated
+  #
+  # source://rubocop//lib/rubocop/cop/cop.rb#105
+  def corrections; end
+
+  # source://rubocop//lib/rubocop/cop/cop.rb#90
+  def find_location(node, loc); end
+
+  # Returns the value of attribute offenses.
+  #
+  # source://rubocop//lib/rubocop/cop/cop.rb#12
+  def offenses; end
+
+  # Called after all on_... have been called
+  #
+  # source://rubocop//lib/rubocop/cop/cop.rb#122
+  def on_investigation_end; end
+
+  # Called before all on_... have been called
+  #
+  # source://rubocop//lib/rubocop/cop/cop.rb#116
+  def on_new_investigation; end
+
+  # @deprecated Use class method
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/cop.rb#96
+  def support_autocorrect?; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/cop.rb#147
+  def apply_correction(corrector); end
+
+  # Override Base
+  #
+  # source://rubocop//lib/rubocop/cop/cop.rb#143
+  def callback_argument(_range); end
+
+  # source://rubocop//lib/rubocop/cop/cop.rb#164
+  def correction_lambda; end
+
+  # source://rubocop//lib/rubocop/cop/cop.rb#170
+  def dedupe_on_node(node); end
+
+  # Just for legacy
+  #
+  # @yield [corrector]
+  #
+  # source://rubocop//lib/rubocop/cop/cop.rb#152
+  def emulate_v0_callsequence(corrector); end
+
+  # source://rubocop//lib/rubocop/cop/cop.rb#183
+  def range_for_original(range); end
+
+  # source://rubocop//lib/rubocop/cop/cop.rb#177
+  def suppress_clobbering; end
+
+  class << self
+    # @deprecated Use Registry.all
+    #
+    # source://rubocop//lib/rubocop/cop/cop.rb#56
+    def all; end
+
+    # @private
+    #
+    # source://rubocop//lib/rubocop/cop/cop.rb#25
+    def inherited(_subclass); end
+
+    # source://rubocop//lib/rubocop/cop/cop.rb#37
+    def joining_forces; end
+
+    # @deprecated Use Registry.qualified_cop_name
+    #
+    # source://rubocop//lib/rubocop/cop/cop.rb#65
+    def qualified_cop_name(name, origin); end
+
+    # @deprecated Use Registry.global
+    #
+    # source://rubocop//lib/rubocop/cop/cop.rb#47
+    def registry; end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/cop.rb#33
+    def support_autocorrect?; end
+  end
+end
+
+# @deprecated
+#
+# source://rubocop//lib/rubocop/cop/cop.rb#17
+class RuboCop::Cop::Cop::Correction < ::Struct
+  # source://rubocop//lib/rubocop/cop/cop.rb#18
+  def call(corrector); end
+
+  # Returns the value of attribute cop
+  #
+  # @return [Object] the current value of cop
+  def cop; end
+
+  # Sets the attribute cop
+  #
+  # @param value [Object] the value to set the attribute cop to.
+  # @return [Object] the newly set value
+  def cop=(_); end
+
+  # Returns the value of attribute lambda
+  #
+  # @return [Object] the current value of lambda
+  def lambda; end
+
+  # Sets the attribute lambda
+  #
+  # @param value [Object] the value to set the attribute lambda to.
+  # @return [Object] the newly set value
+  def lambda=(_); end
+
+  # Returns the value of attribute node
+  #
+  # @return [Object] the current value of node
+  def node; end
+
+  # Sets the attribute node
+  #
+  # @param value [Object] the value to set the attribute node to.
+  # @return [Object] the newly set value
+  def node=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# This class takes a source buffer and rewrite its source
+# based on the different correction rules supplied.
+#
+# Important!
+# The nodes modified by the corrections should be part of the
+# AST of the source_buffer.
+#
+# source://rubocop//lib/rubocop/cop/corrector.rb#11
+class RuboCop::Cop::Corrector < ::Parser::Source::TreeRewriter
+  # corrector = Corrector.new(cop)
+  #
+  # @param source [Parser::Source::Buffer, or anything
+  # leading to one via `(processed_source.)buffer`]
+  # @return [Corrector] a new instance of Corrector
+  #
+  # source://rubocop//lib/rubocop/cop/corrector.rb#32
+  def initialize(source); end
+
+  # Removes `size` characters from the beginning of the given range.
+  # If `size` is greater than the size of `range`, the removed region can
+  # overrun the end of `range`.
+  #
+  # @param range [Parser::Source::Range, RuboCop::AST::Node] or node
+  # @param size [Integer]
+  #
+  # source://rubocop//lib/rubocop/cop/corrector.rb#63
+  def remove_leading(node_or_range, size); end
+
+  # Removes `size` characters prior to the source range.
+  #
+  # @param range [Parser::Source::Range, RuboCop::AST::Node] or node
+  # @param size [Integer]
+  #
+  # source://rubocop//lib/rubocop/cop/corrector.rb#51
+  def remove_preceding(node_or_range, size); end
+
+  # Removes `size` characters from the end of the given range.
+  # If `size` is greater than the size of `range`, the removed region can
+  # overrun the beginning of `range`.
+  #
+  # @param range [Parser::Source::Range, RuboCop::AST::Node] or node
+  # @param size [Integer]
+  #
+  # source://rubocop//lib/rubocop/cop/corrector.rb#75
+  def remove_trailing(node_or_range, size); end
+
+  # Legacy
+  #
+  # source://parser/3.3.5.0/lib/parser/source/tree_rewriter.rb#252
+  def rewrite; end
+
+  # Swaps sources at the given ranges.
+  #
+  # @param node_or_range1 [Parser::Source::Range, RuboCop::AST::Node]
+  # @param node_or_range2 [Parser::Source::Range, RuboCop::AST::Node]
+  #
+  # source://rubocop//lib/rubocop/cop/corrector.rb#85
+  def swap(node_or_range1, node_or_range2); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/corrector.rb#119
+  def check_range_validity(node_or_range); end
+
+  # source://rubocop//lib/rubocop/cop/corrector.rb#104
+  def to_range(node_or_range); end
+
+  # source://rubocop//lib/rubocop/cop/corrector.rb#123
+  def validate_buffer(buffer); end
+
+  class << self
+    # Duck typing for get to a ::Parser::Source::Buffer
+    #
+    # source://rubocop//lib/rubocop/cop/corrector.rb#15
+    def source_buffer(source); end
+  end
+end
+
+# noop
+#
+# source://rubocop//lib/rubocop/cop/corrector.rb#12
+RuboCop::Cop::Corrector::NOOP_CONSUMER = T.let(T.unsafe(nil), Proc)
+
+# Common functionality for checking def nodes.
+#
+# source://rubocop//lib/rubocop/cop/mixin/def_node.rb#6
+module RuboCop::Cop::DefNode
+  include ::RuboCop::Cop::VisibilityHelp
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop//lib/rubocop/cop/mixin/def_node.rb#21
+  def non_public_modifier?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/def_node.rb#12
+  def non_public?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/def_node.rb#16
+  def preceding_non_public_modifier?(node); end
+end
+
+# Helpers for builtin documentation
+#
+# source://rubocop//lib/rubocop/cop/documentation.rb#6
+module RuboCop::Cop::Documentation
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/documentation.rb#25
+  def base_url_for(cop_class, config); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/documentation.rb#57
+  def builtin?(cop_class); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/documentation.rb#47
+  def default_base_url; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/documentation.rb#52
+  def default_extension; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/documentation.rb#10
+  def department_to_basename(department); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/documentation.rb#36
+  def extension_for(cop_class, config); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/documentation.rb#15
+  def url_for(cop_class, config = T.unsafe(nil)); end
+
+  class << self
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/cop/documentation.rb#25
+    def base_url_for(cop_class, config); end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/documentation.rb#57
+    def builtin?(cop_class); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/cop/documentation.rb#47
+    def default_base_url; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/cop/documentation.rb#52
+    def default_extension; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/cop/documentation.rb#10
+    def department_to_basename(department); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/cop/documentation.rb#36
+    def extension_for(cop_class, config); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/cop/documentation.rb#15
+    def url_for(cop_class, config = T.unsafe(nil)); end
+  end
+end
+
+# Common functionality for checking documentation.
+#
+# source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#6
+module RuboCop::Cop::DocumentationComment
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#47
+  def annotation_keywords; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#11
+  def documentation_comment?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#39
+  def interpreter_directive_comment?(comment); end
+
+  # The args node1 & node2 may represent a RuboCop::AST::Node
+  # or a Parser::Source::Comment. Both respond to #loc.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#31
+  def precede?(node1, node2); end
+
+  # The args node1 & node2 may represent a RuboCop::AST::Node
+  # or a Parser::Source::Comment. Both respond to #loc.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#25
+  def preceding_comment?(node1, node2); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#35
+  def preceding_lines(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/documentation_comment.rb#43
+  def rubocop_directive_comment?(comment); end
+end
+
+# Common functionality for dealing with duplication.
+#
+# source://rubocop//lib/rubocop/cop/mixin/duplication.rb#6
+module RuboCop::Cop::Duplication
+  private
+
+  # Returns the consecutive duplicates, leaving out the first instance of
+  # the duplicated elements.
+  #
+  # @param collection [Array] an array to return consecutive duplicates for
+  # @return [Array] the consecutive duplicates
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/duplication.rb#31
+  def consecutive_duplicates(collection); end
+
+  # Returns all duplicates, including the first instance of the duplicated
+  # elements.
+  #
+  # @param collection [Array] an array to return duplicates for
+  # @return [Array] all the duplicates
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/duplication.rb#22
+  def duplicates(collection); end
+
+  # Whether the `collection` contains any duplicates.
+  #
+  # @param collection [Array] an array to check for duplicates
+  # @return [Boolean] whether the array contains any duplicates
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/duplication.rb#13
+  def duplicates?(collection); end
+
+  # Returns a hash of grouped duplicates. The key will be the first
+  # instance of the element, and  the value an `array` of the initial
+  # element and all duplicate instances.
+  #
+  # @param collection [Array] an array to group duplicates for
+  # @return [Array] the grouped duplicates
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/duplication.rb#41
+  def grouped_duplicates(collection); end
+end
+
+# This class autocorrects `#each` enumeration to `for` iteration.
+#
+# source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#6
+class RuboCop::Cop::EachToForCorrector
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # @return [EachToForCorrector] a new instance of EachToForCorrector
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#12
+  def initialize(block_node); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#18
+  def call(corrector); end
+
+  private
+
+  # Returns the value of attribute argument_node.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#24
+  def argument_node; end
+
+  # Returns the value of attribute block_node.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#24
+  def block_node; end
+
+  # Returns the value of attribute collection_node.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#24
+  def collection_node; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#26
+  def correction; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#36
+  def offending_range; end
+end
+
+# source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#10
+RuboCop::Cop::EachToForCorrector::CORRECTION_WITHOUT_ARGUMENTS = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/correctors/each_to_for_corrector.rb#9
+RuboCop::Cop::EachToForCorrector::CORRECTION_WITH_ARGUMENTS = T.let(T.unsafe(nil), String)
+
+# This class does empty line autocorrection
+#
+# source://rubocop//lib/rubocop/cop/correctors/empty_line_corrector.rb#6
+class RuboCop::Cop::EmptyLineCorrector
+  class << self
+    # source://rubocop//lib/rubocop/cop/correctors/empty_line_corrector.rb#8
+    def correct(corrector, node); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/empty_line_corrector.rb#19
+    def insert_before(corrector, node); end
+  end
+end
+
+# Common code for empty parameter cops.
+#
+# source://rubocop//lib/rubocop/cop/mixin/empty_parameter.rb#6
+module RuboCop::Cop::EmptyParameter
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_parameter.rb#12
+  def empty_arguments?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_parameter.rb#16
+  def check(node); end
+end
+
+# Functions for checking the alignment of the `end` keyword.
+#
+# source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#6
+module RuboCop::Cop::EndKeywordAlignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#60
+  def accept_end_kw_alignment?(end_loc); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#50
+  def add_offense_for_misalignment(node, align_with); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#19
+  def check_end_kw_alignment(node, align_ranges); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#15
+  def check_end_kw_in_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#75
+  def line_break_before_keyword?(whole_expression, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#35
+  def matching_ranges(end_loc, align_ranges); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#41
+  def start_line_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#65
+  def style_parameter_name; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#69
+  def variable_alignment?(whole_expression, rhs, end_alignment_style); end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/end_keyword_alignment.rb#10
+RuboCop::Cop::EndKeywordAlignment::MSG = T.let(T.unsafe(nil), String)
+
+# Common functionality for enforcing a specific superclass.
+#
+# IMPORTANT: RuboCop core depended on this module when it supported Rails department.
+# Rails department has been extracted to RuboCop Rails gem.
+#
+# It will not be updated to `RuboCop::Cop::Base` v1 API to maintain compatibility
+# with existing RuboCop Rails 2.8 or lower.
+#
+# @api private
+# @deprecated This module is deprecated and will be removed by RuboCop 2.0.
+#
+# source://rubocop//lib/rubocop/cop/mixin/enforce_superclass.rb#15
+module RuboCop::Cop::EnforceSuperclass
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/enforce_superclass.rb#35
+  def on_class(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/enforce_superclass.rb#39
+  def on_send(node); end
+
+  class << self
+    # @api private
+    # @private
+    #
+    # source://rubocop//lib/rubocop/cop/mixin/enforce_superclass.rb#16
+    def included(base); end
+  end
+end
+
+# Common functionality for checking for a line break before the first
+# element in a multi-line collection.
+#
+# source://rubocop//lib/rubocop/cop/mixin/first_element_line_break.rb#7
+module RuboCop::Cop::FirstElementLineBreak
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/first_element_line_break.rb#23
+  def check_children_line_break(node, children, start = T.unsafe(nil), ignore_last: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/first_element_line_break.rb#10
+  def check_method_line_break(node, children, ignore_last: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/first_element_line_break.rb#37
+  def first_by_line(nodes); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/first_element_line_break.rb#41
+  def last_line(nodes, ignore_last:); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/first_element_line_break.rb#18
+  def method_uses_parens?(node, limit); end
+end
+
+# This class autocorrects `for` iteration to `#each` enumeration.
+#
+# source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#6
+class RuboCop::Cop::ForToEachCorrector
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # @return [ForToEachCorrector] a new instance of ForToEachCorrector
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#11
+  def initialize(for_node); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#17
+  def call(corrector); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#57
+  def collection_end; end
+
+  # Returns the value of attribute collection_node.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#25
+  def collection_node; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#31
+  def collection_source; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#27
+  def correction; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#45
+  def end_range; end
+
+  # Returns the value of attribute for_node.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#25
+  def for_node; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#53
+  def keyword_begin; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#39
+  def requires_parentheses?; end
+
+  # Returns the value of attribute variable_node.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#25
+  def variable_node; end
+end
+
+# source://rubocop//lib/rubocop/cop/correctors/for_to_each_corrector.rb#9
+RuboCop::Cop::ForToEachCorrector::CORRECTION = T.let(T.unsafe(nil), String)
+
+# A scaffold for concrete forces.
+#
+# source://rubocop//lib/rubocop/cop/force.rb#6
+class RuboCop::Cop::Force
+  # @return [Force] a new instance of Force
+  #
+  # source://rubocop//lib/rubocop/cop/force.rb#32
+  def initialize(cops); end
+
+  # Returns the value of attribute cops.
+  #
+  # source://rubocop//lib/rubocop/cop/force.rb#17
+  def cops; end
+
+  # source://rubocop//lib/rubocop/cop/force.rb#50
+  def investigate(_processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/force.rb#36
+  def name; end
+
+  # source://rubocop//lib/rubocop/cop/force.rb#40
+  def run_hook(method_name, *args); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/force.rb#19
+    def all; end
+
+    # source://rubocop//lib/rubocop/cop/force.rb#28
+    def force_name; end
+
+    # @private
+    #
+    # source://rubocop//lib/rubocop/cop/force.rb#23
+    def inherited(subclass); end
+  end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/force.rb#8
+class RuboCop::Cop::Force::HookError < ::StandardError
+  # @api private
+  # @return [HookError] a new instance of HookError
+  #
+  # source://rubocop//lib/rubocop/cop/force.rb#11
+  def initialize(joining_cop); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/force.rb#9
+  def joining_cop; end
+end
+
+# Common functionality for dealing with frozen string literals.
+#
+# source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#6
+module RuboCop::Cop::FrozenStringLiteral
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#35
+  def frozen_heredoc?(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#21
+  def frozen_string_literal?(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#15
+  def frozen_string_literal_comment_exists?; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#76
+  def frozen_string_literal_specified?; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#70
+  def frozen_string_literals_disabled?; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#42
+  def frozen_string_literals_enabled?; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#86
+  def leading_comment_lines; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#82
+  def leading_magic_comments; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#35
+  def uninterpolated_heredoc?(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#31
+  def uninterpolated_string?(node); end
+
+  class << self
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#15
+    def frozen_string_literal_comment_exists?; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#9
+RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#10
+RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL_ENABLED = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/frozen_string_literal.rb#11
+RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL_TYPES_RUBY27 = T.let(T.unsafe(nil), Array)
+
+# Common functionality for checking gem declarations.
+#
+# source://rubocop//lib/rubocop/cop/mixin/gem_declaration.rb#6
+module RuboCop::Cop::GemDeclaration
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop//lib/rubocop/cop/mixin/gem_declaration.rb#10
+  def gem_declaration?(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/gemspec/add_runtime_dependency.rb#5
+module RuboCop::Cop::Gemspec; end
+
+# Prefer `add_dependency` over `add_runtime_dependency` as the latter is
+# considered soft-deprecated.
+#
+# @example
+#
+#   # bad
+#   Gem::Specification.new do |spec|
+#   spec.add_runtime_dependency('rubocop')
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.add_dependency('rubocop')
+#   end
+#
+# source://rubocop//lib/rubocop/cop/gemspec/add_runtime_dependency.rb#21
+class RuboCop::Cop::Gemspec::AddRuntimeDependency < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/gemspec/add_runtime_dependency.rb#28
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/gemspec/add_runtime_dependency.rb#24
+RuboCop::Cop::Gemspec::AddRuntimeDependency::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/gemspec/add_runtime_dependency.rb#26
+RuboCop::Cop::Gemspec::AddRuntimeDependency::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Enforce that gem dependency version specifications or a commit reference (branch,
+# ref, or tag) are either required or forbidden.
+#
+# @example EnforcedStyle: required (default)
+#
+#   # bad
+#   Gem::Specification.new do |spec|
+#   spec.add_dependency 'parser'
+#   end
+#
+#   # bad
+#   Gem::Specification.new do |spec|
+#   spec.add_development_dependency 'parser'
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.add_dependency 'parser', '>= 2.3.3.1', '< 3.0'
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.add_development_dependency 'parser', '>= 2.3.3.1', '< 3.0'
+#   end
+# @example EnforcedStyle: forbidden
+#
+#   # bad
+#   Gem::Specification.new do |spec|
+#   spec.add_dependency 'parser', '>= 2.3.3.1', '< 3.0'
+#   end
+#
+#   # bad
+#   Gem::Specification.new do |spec|
+#   spec.add_development_dependency 'parser', '>= 2.3.3.1', '< 3.0'
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.add_dependency 'parser'
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.add_development_dependency 'parser'
+#   end
+#
+# source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#53
+class RuboCop::Cop::Gemspec::DependencyVersion < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::GemspecHelp
+
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#67
+  def add_dependency_method_declaration?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#78
+  def includes_commit_reference?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#73
+  def includes_version_specification?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#82
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#118
+  def add_dependency_method?(method_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#96
+  def allowed_gem?(node); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#100
+  def allowed_gems; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#132
+  def forbidden_offense?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#138
+  def forbidden_style?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#112
+  def match_block_variable_name?(receiver_name); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#104
+  def message(_range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#122
+  def offense?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#126
+  def required_offense?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#142
+  def required_style?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#146
+  def version_specification?(expression); end
+end
+
+# source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#61
+RuboCop::Cop::Gemspec::DependencyVersion::ADD_DEPENDENCY_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#58
+RuboCop::Cop::Gemspec::DependencyVersion::FORBIDDEN_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#57
+RuboCop::Cop::Gemspec::DependencyVersion::REQUIRED_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#64
+RuboCop::Cop::Gemspec::DependencyVersion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/gemspec/dependency_version.rb#59
+RuboCop::Cop::Gemspec::DependencyVersion::VERSION_SPECIFICATION_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# Checks that deprecated attributes are not set in a gemspec file.
+# Removing deprecated attributes allows the user to receive smaller packed gems.
+#
+# @example
+#
+#   # bad
+#   Gem::Specification.new do |spec|
+#   spec.name = 'your_cool_gem_name'
+#   spec.test_files = Dir.glob('test/**/*')
+#   end
+#
+#   # bad
+#   Gem::Specification.new do |spec|
+#   spec.name = 'your_cool_gem_name'
+#   spec.test_files += Dir.glob('test/**/*')
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.name = 'your_cool_gem_name'
+#   end
+#
+# source://rubocop//lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb#28
+class RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb#35
+  def gem_specification(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb#43
+  def on_block(block_node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb#86
+  def format_message_from; end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb#63
+  def node_and_method_name(node, attribute); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb#72
+  def use_deprecated_attributes?(node, block_parameter); end
+end
+
+# source://rubocop//lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb#32
+RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment::MSG = T.let(T.unsafe(nil), String)
+
+# Enforce that development dependencies for a gem are specified in
+# `Gemfile`, rather than in the `gemspec` using
+# `add_development_dependency`. Alternatively, using `EnforcedStyle:
+# gemspec`, enforce that all dependencies are specified in `gemspec`,
+# rather than in `Gemfile`.
+#
+# @example EnforcedStyle: Gemfile (default)
+#   # Specify runtime dependencies in your gemspec,
+#   # but all other dependencies in your Gemfile.
+#
+#   # bad
+#   # example.gemspec
+#   s.add_development_dependency "foo"
+#
+#   # good
+#   # Gemfile
+#   gem "foo"
+#
+#   # good
+#   # gems.rb
+#   gem "foo"
+#
+#   # good (with AllowedGems: ["bar"])
+#   # example.gemspec
+#   s.add_development_dependency "bar"
+# @example EnforcedStyle: gems.rb
+#   # Specify runtime dependencies in your gemspec,
+#   # but all other dependencies in your Gemfile.
+#   #
+#   # Identical to `EnforcedStyle: Gemfile`, but with a different error message.
+#   # Rely on Bundler/GemFilename to enforce the use of `Gemfile` vs `gems.rb`.
+#
+#   # bad
+#   # example.gemspec
+#   s.add_development_dependency "foo"
+#
+#   # good
+#   # Gemfile
+#   gem "foo"
+#
+#   # good
+#   # gems.rb
+#   gem "foo"
+#
+#   # good (with AllowedGems: ["bar"])
+#   # example.gemspec
+#   s.add_development_dependency "bar"
+# @example EnforcedStyle: gemspec
+#   # Specify all dependencies in your gemspec.
+#
+#   # bad
+#   # Gemfile
+#   gem "foo"
+#
+#   # good
+#   # example.gemspec
+#   s.add_development_dependency "foo"
+#
+#   # good (with AllowedGems: ["bar"])
+#   # Gemfile
+#   gem "bar"
+#
+# source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#70
+class RuboCop::Cop::Gemspec::DevelopmentDependencies < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+
+  # source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#77
+  def add_development_dependency?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#82
+  def gem?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#86
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#97
+  def forbidden_gem?(gem_name); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#101
+  def message(_range); end
+end
+
+# source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#73
+RuboCop::Cop::Gemspec::DevelopmentDependencies::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/gemspec/development_dependencies.rb#74
+RuboCop::Cop::Gemspec::DevelopmentDependencies::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# An attribute assignment method calls should be listed only once
+# in a gemspec.
+#
+# Assigning to an attribute with the same name using `spec.foo =` will be
+# an unintended usage. On the other hand, duplication of methods such
+# as `spec.requirements`, `spec.add_runtime_dependency`, and others are
+# permitted because it is the intended use of appending values.
+#
+# @example
+#   # bad
+#   Gem::Specification.new do |spec|
+#   spec.name = 'rubocop'
+#   spec.name = 'rubocop2'
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.name = 'rubocop'
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.requirements << 'libmagick, v6.0'
+#   spec.requirements << 'A good graphics card'
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.add_dependency('parallel', '~> 1.10')
+#   spec.add_dependency('parser', '>= 2.3.3.1', '< 3.0')
+#   end
+#
+# source://rubocop//lib/rubocop/cop/gemspec/duplicated_assignment.rb#37
+class RuboCop::Cop::Gemspec::DuplicatedAssignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::GemspecHelp
+
+  # source://rubocop//lib/rubocop/cop/gemspec/duplicated_assignment.rb#45
+  def assignment_method_declarations(param0); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/duplicated_assignment.rb#50
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/gemspec/duplicated_assignment.rb#68
+  def duplicated_assignment_method_nodes; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/gemspec/duplicated_assignment.rb#62
+  def match_block_variable_name?(receiver_name); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/duplicated_assignment.rb#76
+  def register_offense(node, assignment, line_of_first_occurrence); end
+end
+
+# source://rubocop//lib/rubocop/cop/gemspec/duplicated_assignment.rb#41
+RuboCop::Cop::Gemspec::DuplicatedAssignment::MSG = T.let(T.unsafe(nil), String)
+
+# Dependencies in the gemspec should be alphabetically sorted.
+#
+# @example
+#   # bad
+#   spec.add_dependency 'rubocop'
+#   spec.add_dependency 'rspec'
+#
+#   # good
+#   spec.add_dependency 'rspec'
+#   spec.add_dependency 'rubocop'
+#
+#   # good
+#   spec.add_dependency 'rubocop'
+#
+#   spec.add_dependency 'rspec'
+#
+#   # bad
+#   spec.add_development_dependency 'rubocop'
+#   spec.add_development_dependency 'rspec'
+#
+#   # good
+#   spec.add_development_dependency 'rspec'
+#   spec.add_development_dependency 'rubocop'
+#
+#   # good
+#   spec.add_development_dependency 'rubocop'
+#
+#   spec.add_development_dependency 'rspec'
+#
+#   # bad
+#   spec.add_runtime_dependency 'rubocop'
+#   spec.add_runtime_dependency 'rspec'
+#
+#   # good
+#   spec.add_runtime_dependency 'rspec'
+#   spec.add_runtime_dependency 'rubocop'
+#
+#   # good
+#   spec.add_runtime_dependency 'rubocop'
+#
+#   spec.add_runtime_dependency 'rspec'
+# @example TreatCommentsAsGroupSeparators: true (default)
+#   # good
+#   # For code quality
+#   spec.add_dependency 'rubocop'
+#   # For tests
+#   spec.add_dependency 'rspec'
+# @example TreatCommentsAsGroupSeparators: false
+#   # bad
+#   # For code quality
+#   spec.add_dependency 'rubocop'
+#   # For tests
+#   spec.add_dependency 'rspec'
+#
+# source://rubocop//lib/rubocop/cop/gemspec/ordered_dependencies.rb#61
+class RuboCop::Cop::Gemspec::OrderedDependencies < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::OrderedGemNode
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/gemspec/ordered_dependencies.rb#95
+  def dependency_declarations(param0); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/ordered_dependencies.rb#69
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/gemspec/ordered_dependencies.rb#90
+  def get_dependency_name(node); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/ordered_dependencies.rb#84
+  def previous_declaration(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/gemspec/ordered_dependencies.rb#65
+RuboCop::Cop::Gemspec::OrderedDependencies::MSG = T.let(T.unsafe(nil), String)
+
+# Requires a gemspec to have `rubygems_mfa_required` metadata set.
+#
+# This setting tells RubyGems that MFA (Multi-Factor Authentication) is
+# required for accounts to be able perform privileged operations, such as
+# (see RubyGems' documentation for the full list of privileged
+# operations):
+#
+# * `gem push`
+# * `gem yank`
+# * `gem owner --add/remove`
+# * adding or removing owners using gem ownership page
+#
+# This helps make your gem more secure, as users can be more
+# confident that gem updates were pushed by maintainers.
+#
+# @example
+#   # bad
+#   Gem::Specification.new do |spec|
+#   # no `rubygems_mfa_required` metadata specified
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.metadata = {
+#   'rubygems_mfa_required' => 'true'
+#   }
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.metadata['rubygems_mfa_required'] = 'true'
+#   end
+#
+#   # bad
+#   Gem::Specification.new do |spec|
+#   spec.metadata = {
+#   'rubygems_mfa_required' => 'false'
+#   }
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.metadata = {
+#   'rubygems_mfa_required' => 'true'
+#   }
+#   end
+#
+#   # bad
+#   Gem::Specification.new do |spec|
+#   spec.metadata['rubygems_mfa_required'] = 'false'
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.metadata['rubygems_mfa_required'] = 'true'
+#   end
+#
+# source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#63
+class RuboCop::Cop::Gemspec::RequireMFA < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::GemspecHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#70
+  def metadata(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#87
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#78
+  def rubygems_mfa_required(param0); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#83
+  def true_string?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#115
+  def autocorrect(corrector, node, block_var, metadata); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#139
+  def change_value(corrector, value); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#125
+  def correct_metadata(corrector, metadata); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#133
+  def insert_mfa_required(corrector, node, block_var); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#108
+  def mfa_value(metadata_value); end
+end
+
+# source://rubocop//lib/rubocop/cop/gemspec/require_mfa.rb#67
+RuboCop::Cop::Gemspec::RequireMFA::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that `required_ruby_version` in a gemspec file is set to a valid
+# value (non-blank) and matches `TargetRubyVersion` as set in RuboCop's
+# configuration for the gem.
+#
+# This ensures that RuboCop is using the same Ruby version as the gem.
+#
+# @example
+#   # When `TargetRubyVersion` of .rubocop.yml is `2.5`.
+#
+#   # bad
+#   Gem::Specification.new do |spec|
+#   # no `required_ruby_version` specified
+#   end
+#
+#   # bad
+#   Gem::Specification.new do |spec|
+#   spec.required_ruby_version = '>= 2.4.0'
+#   end
+#
+#   # bad
+#   Gem::Specification.new do |spec|
+#   spec.required_ruby_version = '>= 2.6.0'
+#   end
+#
+#   # bad
+#   Gem::Specification.new do |spec|
+#   spec.required_ruby_version = ''
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.required_ruby_version = '>= 2.5.0'
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.required_ruby_version = '>= 2.5'
+#   end
+#
+#   # accepted but not recommended
+#   Gem::Specification.new do |spec|
+#   spec.required_ruby_version = ['>= 2.5.0', '< 2.7.0']
+#   end
+#
+#   # accepted but not recommended, since
+#   # Ruby does not really follow semantic versioning
+#   Gem::Specification.new do |spec|
+#   spec.required_ruby_version = '~> 2.5'
+#   end
+#
+# source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#55
+class RuboCop::Cop::Gemspec::RequiredRubyVersion < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#70
+  def defined_ruby_version(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#78
+  def on_new_investigation; end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#84
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#65
+  def required_ruby_version?(param0); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#96
+  def dynamic_version?(node); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#102
+  def extract_ruby_version(required_ruby_version); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#120
+  def not_equal_message(required_ruby_version, target_ruby_version); end
+end
+
+# source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#62
+RuboCop::Cop::Gemspec::RequiredRubyVersion::MISSING_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#59
+RuboCop::Cop::Gemspec::RequiredRubyVersion::NOT_EQUAL_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/gemspec/required_ruby_version.rb#58
+RuboCop::Cop::Gemspec::RequiredRubyVersion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks that `RUBY_VERSION` constant is not used in gemspec.
+# Using `RUBY_VERSION` is dangerous because value of the
+# constant is determined by `rake release`.
+# It's possible to have dependency based on ruby version used
+# to execute `rake release` and not user's ruby version.
+#
+# @example
+#
+#   # bad
+#   Gem::Specification.new do |spec|
+#   if RUBY_VERSION >= '3.0'
+#   spec.add_dependency 'gem_a'
+#   else
+#   spec.add_dependency 'gem_b'
+#   end
+#   end
+#
+#   # good
+#   Gem::Specification.new do |spec|
+#   spec.add_dependency 'gem_a'
+#   end
+#
+# source://rubocop//lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb#28
+class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::GemspecHelp
+
+  # source://rubocop//lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb#36
+  def on_const(node); end
+
+  # source://rubocop//lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb#34
+  def ruby_version?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb#44
+  def gem_spec_with_ruby_version?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb#31
+RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage::MSG = T.let(T.unsafe(nil), String)
+
+# Common functionality for checking gem declarations.
+#
+# source://rubocop//lib/rubocop/cop/mixin/gemspec_help.rb#6
+module RuboCop::Cop::GemspecHelp
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop//lib/rubocop/cop/mixin/gemspec_help.rb#20
+  def gem_specification(param0); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/gemspec_help.rb#10
+  def gem_specification?(param0 = T.unsafe(nil)); end
+end
+
+# Source and spec generator for new cops
+#
+# This generator will take a cop name and generate a source file
+# and spec file when given a valid qualified cop name.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/generator.rb#10
+class RuboCop::Cop::Generator
+  # @api private
+  # @raise [ArgumentError]
+  # @return [Generator] a new instance of Generator
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#113
+  def initialize(name, output: T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#133
+  def inject_config(config_file_path: T.unsafe(nil), version_added: T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#129
+  def inject_require(root_file_path: T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#146
+  def todo; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#121
+  def write_source; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#125
+  def write_spec; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#160
+  def badge; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#183
+  def generate(template); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#175
+  def generated_source; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#179
+  def generated_spec; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#160
+  def output; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#208
+  def snake_case(camel_case_string); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#198
+  def source_path; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#188
+  def spec_path; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/generator.rb#162
+  def write_unless_file_exists(path, contents); end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/generator.rb#109
+RuboCop::Cop::Generator::CONFIGURATION_ADDED_MESSAGE = T.let(T.unsafe(nil), String)
+
+# A class that injects a require directive into the root RuboCop file.
+# It looks for other directives that require files in the same (cop)
+# namespace and injects the provided one in alpha
+#
+# source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#9
+class RuboCop::Cop::Generator::ConfigurationInjector
+  # @return [ConfigurationInjector] a new instance of ConfigurationInjector
+  #
+  # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#17
+  def initialize(configuration_file_path:, badge:, version_added: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#24
+  def inject; end
+
+  private
+
+  # Returns the value of attribute badge.
+  #
+  # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#39
+  def badge; end
+
+  # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#41
+  def configuration_entries; end
+
+  # Returns the value of attribute configuration_file_path.
+  #
+  # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#39
+  def configuration_file_path; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#59
+  def cop_name_line?(yaml); end
+
+  # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#49
+  def find_target_line; end
+
+  # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#45
+  def new_configuration_entry; end
+
+  # Returns the value of attribute output.
+  #
+  # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#39
+  def output; end
+
+  # Returns the value of attribute version_added.
+  #
+  # source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#39
+  def version_added; end
+end
+
+# source://rubocop//lib/rubocop/cop/generator/configuration_injector.rb#10
+RuboCop::Cop::Generator::ConfigurationInjector::TEMPLATE = T.let(T.unsafe(nil), String)
+
+# A class that injects a require directive into the root RuboCop file.
+# It looks for other directives that require files in the same (cop)
+# namespace and injects the provided one in alpha
+#
+# source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#9
+class RuboCop::Cop::Generator::RequireFileInjector
+  # @return [RequireFileInjector] a new instance of RequireFileInjector
+  #
+  # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#12
+  def initialize(source_path:, root_file_path:, output: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#19
+  def inject; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#64
+  def injectable_require_directive; end
+
+  # Returns the value of attribute output.
+  #
+  # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#29
+  def output; end
+
+  # Returns the value of attribute require_entries.
+  #
+  # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#29
+  def require_entries; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#31
+  def require_exists?; end
+
+  # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#68
+  def require_path; end
+
+  # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#58
+  def require_path_fragments(require_directive); end
+
+  # Returns the value of attribute root_file_path.
+  #
+  # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#29
+  def root_file_path; end
+
+  # Returns the value of attribute source_path.
+  #
+  # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#29
+  def source_path; end
+
+  # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#39
+  def target_line; end
+
+  # source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#35
+  def updated_directives; end
+end
+
+# source://rubocop//lib/rubocop/cop/generator/require_file_injector.rb#10
+RuboCop::Cop::Generator::RequireFileInjector::REQUIRE_PATH = T.let(T.unsafe(nil), Regexp)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/generator.rb#11
+RuboCop::Cop::Generator::SOURCE_TEMPLATE = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/generator.rb#85
+RuboCop::Cop::Generator::SPEC_TEMPLATE = T.let(T.unsafe(nil), String)
+
+# Common functionality for checking hash alignment.
+#
+# source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#6
+module RuboCop::Cop::HashAlignmentStyles; end
+
+# Handles calculation of deltas when the enforced style is 'key'.
+#
+# source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#8
+class RuboCop::Cop::HashAlignmentStyles::KeyAlignment
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#9
+  def checkable_layout?(_node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#20
+  def deltas(first_pair, current_pair); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#13
+  def deltas_for_first_pair(first_pair, _node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#34
+  def separator_delta(pair); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#45
+  def value_delta(pair); end
+end
+
+# Handles calculation of deltas for `kwsplat` nodes.
+# This is a special case that just ensures the kwsplat is aligned with the rest of the hash
+# since a `kwsplat` does not have a key, separator or value.
+#
+# source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#145
+class RuboCop::Cop::HashAlignmentStyles::KeywordSplatAlignment
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#146
+  def deltas(first_pair, current_pair); end
+end
+
+# Handles calculation of deltas when the enforced style is 'separator'.
+#
+# source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#120
+class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment
+  include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#123
+  def deltas_for_first_pair(*_nodes); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#133
+  def hash_rocket_delta(first_pair, current_pair); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#129
+  def key_delta(first_pair, current_pair); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#137
+  def value_delta(first_pair, current_pair); end
+end
+
+# Handles calculation of deltas when the enforced style is 'table'.
+#
+# source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#81
+class RuboCop::Cop::HashAlignmentStyles::TableAlignment
+  include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment
+
+  # @return [TableAlignment] a new instance of TableAlignment
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#84
+  def initialize; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#88
+  def deltas_for_first_pair(first_pair, node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#106
+  def hash_rocket_delta(first_pair, current_pair); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#102
+  def key_delta(first_pair, current_pair); end
+
+  # Returns the value of attribute max_key_width.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#100
+  def max_key_width; end
+
+  # Sets the attribute max_key_width
+  #
+  # @param value the value to set the attribute max_key_width to.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#100
+  def max_key_width=(_arg0); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#110
+  def value_delta(first_pair, current_pair); end
+end
+
+# Common functionality for checking alignment of hash values.
+#
+# source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#56
+module RuboCop::Cop::HashAlignmentStyles::ValueAlignment
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#57
+  def checkable_layout?(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#61
+  def deltas(first_pair, current_pair); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_alignment_styles.rb#71
+  def separator_delta(first_pair, current_pair, key_delta); end
+end
+
+# This module checks for Ruby 3.1's hash value omission syntax.
+#
+# source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#7
+module RuboCop::Cop::HashShorthandSyntax
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#14
+  def on_hash_for_mixed_shorthand(hash_node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#26
+  def on_pair(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#126
+  def brackets?(method_dispatch_node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#156
+  def breakdown_value_types_of_hash(hash_node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#103
+  def def_node_that_require_parentheses(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#185
+  def each_omittable_value_pair(hash_value_type_breakdown, &block); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#181
+  def each_omitted_value_pair(hash_value_type_breakdown, &block); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#81
+  def enforced_shorthand_syntax; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#118
+  def find_ancestor_method_dispatch_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#168
+  def hash_with_mixed_shorthand_syntax?(hash_value_type_breakdown); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#172
+  def hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#176
+  def ignore_explicit_omissible_hash_shorthand_syntax?(hash_value_type_breakdown); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#75
+  def ignore_hash_shorthand_syntax?(pair_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#69
+  def ignore_mixed_hash_shorthand_syntax?(hash_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#141
+  def last_expression?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#149
+  def method_dispatch_as_argument?(method_dispatch_node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#189
+  def mixed_shorthand_syntax_check(hash_value_type_breakdown); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#205
+  def no_mixed_shorthand_syntax_check(hash_value_type_breakdown); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#49
+  def register_offense(node, message, replacement); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#85
+  def require_hash_value?(hash_key_source, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#94
+  def require_hash_value_for_around_hash_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#130
+  def use_element_of_hash_literal_as_receiver?(ancestor, parent); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#135
+  def use_modifier_form_without_parenthesized_method_call?(ancestor); end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#12
+RuboCop::Cop::HashShorthandSyntax::DO_NOT_MIX_EXPLICIT_VALUE_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#10
+RuboCop::Cop::HashShorthandSyntax::DO_NOT_MIX_MSG_PREFIX = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#11
+RuboCop::Cop::HashShorthandSyntax::DO_NOT_MIX_OMIT_VALUE_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#216
+class RuboCop::Cop::HashShorthandSyntax::DefNode < ::Struct
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#225
+  def first_argument; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#229
+  def last_argument; end
+
+  # Returns the value of attribute node
+  #
+  # @return [Object] the current value of node
+  def node; end
+
+  # Sets the attribute node
+  #
+  # @param value [Object] the value to set the attribute node to.
+  # @return [Object] the newly set value
+  def node=(_); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#217
+  def selector; end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#9
+RuboCop::Cop::HashShorthandSyntax::EXPLICIT_HASH_VALUE_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/hash_shorthand_syntax.rb#8
+RuboCop::Cop::HashShorthandSyntax::OMIT_HASH_VALUE_MSG = T.let(T.unsafe(nil), String)
+
+# Common functionality for Style/HashTransformKeys and
+# Style/HashTransformValues
+#
+# source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#7
+module RuboCop::Cop::HashTransformMethod
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#13
+  def array_receiver?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#17
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#34
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#27
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#108
+  def execute_correction(corrector, node, correction); end
+
+  # @abstract
+  # @raise [NotImplementedError]
+  # @return [Captures]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#83
+  def extract_captures(_match); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#60
+  def handle_possible_offense(node, match, match_desc); end
+
+  # @abstract
+  # @raise [NotImplementedError]
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#90
+  def new_method_name; end
+
+  # @abstract Implemented with `def_node_matcher`
+  # @raise [NotImplementedError]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#41
+  def on_bad_each_with_object(_node); end
+
+  # @abstract Implemented with `def_node_matcher`
+  # @raise [NotImplementedError]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#46
+  def on_bad_hash_brackets_map(_node); end
+
+  # @abstract Implemented with `def_node_matcher`
+  # @raise [NotImplementedError]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#51
+  def on_bad_map_to_h(_node); end
+
+  # @abstract Implemented with `def_node_matcher`
+  # @raise [NotImplementedError]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#56
+  def on_bad_to_h(_node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#94
+  def prepare_correction(node); end
+end
+
+# Internal helper class to hold autocorrect data
+#
+# source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#136
+class RuboCop::Cop::HashTransformMethod::Autocorrection < ::Struct
+  # Returns the value of attribute block_node
+  #
+  # @return [Object] the current value of block_node
+  def block_node; end
+
+  # Sets the attribute block_node
+  #
+  # @param value [Object] the value to set the attribute block_node to.
+  # @return [Object] the newly set value
+  def block_node=(_); end
+
+  # Returns the value of attribute leading
+  #
+  # @return [Object] the current value of leading
+  def leading; end
+
+  # Sets the attribute leading
+  #
+  # @param value [Object] the value to set the attribute leading to.
+  # @return [Object] the newly set value
+  def leading=(_); end
+
+  # Returns the value of attribute match
+  #
+  # @return [Object] the current value of match
+  def match; end
+
+  # Sets the attribute match
+  #
+  # @param value [Object] the value to set the attribute match to.
+  # @return [Object] the newly set value
+  def match=(_); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#177
+  def set_new_arg_name(transformed_argname, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#181
+  def set_new_body_expression(transforming_body_expr, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#167
+  def set_new_method_name(new_method_name, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#161
+  def strip_prefix_and_suffix(node, corrector); end
+
+  # Returns the value of attribute trailing
+  #
+  # @return [Object] the current value of trailing
+  def trailing; end
+
+  # Sets the attribute trailing
+  #
+  # @param value [Object] the value to set the attribute trailing to.
+  # @return [Object] the newly set value
+  def trailing=(_); end
+
+  class << self
+    def [](*_arg0); end
+
+    # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#137
+    def from_each_with_object(node, match); end
+
+    # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#141
+    def from_hash_brackets_map(node, match); end
+
+    # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#145
+    def from_map_to_h(node, match); end
+
+    # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#157
+    def from_to_h(node, match); end
+
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# Internal helper class to hold match data
+#
+# source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#118
+class RuboCop::Cop::HashTransformMethod::Captures < ::Struct
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#119
+  def noop_transformation?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#124
+  def transformation_uses_both_args?; end
+
+  # Returns the value of attribute transformed_argname
+  #
+  # @return [Object] the current value of transformed_argname
+  def transformed_argname; end
+
+  # Sets the attribute transformed_argname
+  #
+  # @param value [Object] the value to set the attribute transformed_argname to.
+  # @return [Object] the newly set value
+  def transformed_argname=(_); end
+
+  # Returns the value of attribute transforming_body_expr
+  #
+  # @return [Object] the current value of transforming_body_expr
+  def transforming_body_expr; end
+
+  # Sets the attribute transforming_body_expr
+  #
+  # @param value [Object] the value to set the attribute transforming_body_expr to.
+  # @return [Object] the newly set value
+  def transforming_body_expr=(_); end
+
+  # Returns the value of attribute unchanged_body_expr
+  #
+  # @return [Object] the current value of unchanged_body_expr
+  def unchanged_body_expr; end
+
+  # Sets the attribute unchanged_body_expr
+  #
+  # @param value [Object] the value to set the attribute unchanged_body_expr to.
+  # @return [Object] the newly set value
+  def unchanged_body_expr=(_); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#128
+  def use_transformed_argname?; end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/hash_transform_method.rb#10
+RuboCop::Cop::HashTransformMethod::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Common functionality for working with heredoc strings.
+#
+# source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#6
+module RuboCop::Cop::Heredoc
+  # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#9
+  def on_dstr(node); end
+
+  # @raise [NotImplementedError]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#17
+  def on_heredoc(_node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#9
+  def on_str(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#9
+  def on_xstr(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#28
+  def delimiter_string(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#34
+  def heredoc_type(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#23
+  def indent_level(str); end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/heredoc.rb#7
+RuboCop::Cop::Heredoc::OPENING_DELIMITER = T.let(T.unsafe(nil), Regexp)
+
+# This class autocorrects `if...then` structures to a multiline `if` statement
+#
+# source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#6
+class RuboCop::Cop::IfThenCorrector
+  # @return [IfThenCorrector] a new instance of IfThenCorrector
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#9
+  def initialize(if_node, indentation: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#14
+  def call(corrector); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#50
+  def branch_body_indentation; end
+
+  # Returns the value of attribute if_node.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#20
+  def if_node; end
+
+  # Returns the value of attribute indentation.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#20
+  def indentation; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#22
+  def replacement(node = T.unsafe(nil), indentation = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#36
+  def rewrite_else_branch(else_branch, indentation); end
+end
+
+# source://rubocop//lib/rubocop/cop/correctors/if_then_corrector.rb#7
+RuboCop::Cop::IfThenCorrector::DEFAULT_INDENTATION_WIDTH = T.let(T.unsafe(nil), Integer)
+
+# @deprecated IgnoredMethods class has been replaced with AllowedMethods.
+#
+# source://rubocop//lib/rubocop/cop/mixin/allowed_methods.rb#46
+RuboCop::Cop::IgnoredMethods = RuboCop::Cop::AllowedMethods
+
+# Handles adding and checking ignored nodes.
+#
+# source://rubocop//lib/rubocop/cop/ignored_node.rb#6
+module RuboCop::Cop::IgnoredNode
+  # source://rubocop//lib/rubocop/cop/ignored_node.rb#7
+  def ignore_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/ignored_node.rb#24
+  def ignored_node?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/ignored_node.rb#11
+  def part_of_ignored_node?(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/ignored_node.rb#31
+  def ignored_nodes; end
+end
+
+# @deprecated IgnoredPattern class has been replaced with AllowedPattern.
+#
+# source://rubocop//lib/rubocop/cop/mixin/allowed_pattern.rb#66
+RuboCop::Cop::IgnoredPattern = RuboCop::Cop::AllowedPattern
+
+# Common functionality for checking integer nodes.
+#
+# source://rubocop//lib/rubocop/cop/mixin/integer_node.rb#6
+module RuboCop::Cop::IntegerNode
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/integer_node.rb#9
+  def integer_part(node); end
+end
+
+# Common functionality for working with string interpolations.
+#
+# @abstract Subclasses are expected to implement {#on_interpolation}.
+#
+# source://rubocop//lib/rubocop/cop/mixin/interpolation.rb#8
+module RuboCop::Cop::Interpolation
+  # source://rubocop//lib/rubocop/cop/mixin/interpolation.rb#9
+  def on_dstr(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/interpolation.rb#9
+  def on_dsym(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/interpolation.rb#17
+  def on_node_with_interpolations(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/interpolation.rb#9
+  def on_regexp(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/interpolation.rb#9
+  def on_xstr(node); end
+end
+
+# This class autocorrects lambda literal to method notation.
+#
+# source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#6
+class RuboCop::Cop::LambdaLiteralToMethodCorrector
+  # @return [LambdaLiteralToMethodCorrector] a new instance of LambdaLiteralToMethodCorrector
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#7
+  def initialize(block_node); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#13
+  def call(corrector); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#118
+  def arg_to_unparenthesized_call?; end
+
+  # Returns the value of attribute arguments.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#34
+  def arguments; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#102
+  def arguments_begin_pos; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#98
+  def arguments_end_pos; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#110
+  def block_begin; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#106
+  def block_end; end
+
+  # Returns the value of attribute block_node.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#34
+  def block_node; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#59
+  def insert_arguments(corrector); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#43
+  def insert_separating_space(corrector); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#88
+  def lambda_arg_string; end
+
+  # Returns the value of attribute method.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#34
+  def method; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#92
+  def needs_separating_space?; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#53
+  def remove_arguments(corrector); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#66
+  def remove_leading_whitespace(corrector); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#74
+  def remove_trailing_whitespace(corrector); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#36
+  def remove_unparenthesized_whitespace(corrector); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#79
+  def replace_delimiters(corrector); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#49
+  def replace_selector(corrector); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#114
+  def selector_end; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb#134
+  def separating_space?; end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#5
+module RuboCop::Cop::Layout; end
+
+# Bare access modifiers (those not applying to specific methods) should be
+# indented as deep as method definitions, or as deep as the class/module
+# keyword, depending on configuration.
+#
+# @example EnforcedStyle: indent (default)
+#   # bad
+#   class Plumbus
+#   private
+#   def smooth; end
+#   end
+#
+#   # good
+#   class Plumbus
+#   private
+#   def smooth; end
+#   end
+# @example EnforcedStyle: outdent
+#   # bad
+#   class Plumbus
+#   private
+#   def smooth; end
+#   end
+#
+#   # good
+#   class Plumbus
+#   private
+#   def smooth; end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#35
+class RuboCop::Cop::Layout::AccessModifierIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#43
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#43
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#43
+  def on_module(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#43
+  def on_sclass(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#54
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#58
+  def check_body(body, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#69
+  def check_modifier(send_node, end_range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#92
+  def expected_indent_offset; end
+
+  # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#88
+  def message(range); end
+
+  # An offset that is not expected, but correct if the configuration is
+  # changed.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#98
+  def unexpected_indent_offset; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/access_modifier_indentation.rb#41
+RuboCop::Cop::Layout::AccessModifierIndentation::MSG = T.let(T.unsafe(nil), String)
+
+# Here we check if the arguments on a multi-line method
+# definition are aligned.
+#
+# @example EnforcedStyle: with_first_argument (default)
+#   # good
+#
+#   foo :bar,
+#   :baz,
+#   key: value
+#
+#   foo(
+#   :bar,
+#   :baz,
+#   key: value
+#   )
+#
+#   # bad
+#
+#   foo :bar,
+#   :baz,
+#   key: value
+#
+#   foo(
+#   :bar,
+#   :baz,
+#   key: value
+#   )
+# @example EnforcedStyle: with_fixed_indentation
+#   # good
+#
+#   foo :bar,
+#   :baz,
+#   key: value
+#
+#   # bad
+#
+#   foo :bar,
+#   :baz,
+#   key: value
+#
+# source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#46
+class RuboCop::Cop::Layout::ArgumentAlignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#55
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#55
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#92
+  def arguments_or_first_arg_pairs(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#80
+  def arguments_with_last_arg_pairs(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#108
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#68
+  def autocorrect_incompatible_with_other_cops?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#124
+  def base_column(node, first_argument); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#144
+  def enforce_hash_argument_with_separator?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#116
+  def fixed_indentation?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#72
+  def flattened_arguments(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#152
+  def hash_argument_config; end
+
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#112
+  def message(_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#101
+  def multiple_arguments?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#135
+  def target_method_lineno(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#120
+  def with_first_argument_style?; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#50
+RuboCop::Cop::Layout::ArgumentAlignment::ALIGN_PARAMS_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/argument_alignment.rb#52
+RuboCop::Cop::Layout::ArgumentAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String)
+
+# Here we check if the elements of a multi-line array literal are
+# aligned.
+#
+# @example EnforcedStyle: with_first_element (default)
+#   # good
+#
+#   array = [1, 2, 3,
+#   4, 5, 6]
+#   array = ['run',
+#   'forrest',
+#   'run']
+#
+#   # bad
+#
+#   array = [1, 2, 3,
+#   4, 5, 6]
+#   array = ['run',
+#   'forrest',
+#   'run']
+# @example EnforcedStyle: with_fixed_indentation
+#   # good
+#
+#   array = [1, 2, 3,
+#   4, 5, 6]
+#
+#   # bad
+#
+#   array = [1, 2, 3,
+#   4, 5, 6]
+#
+# source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#36
+class RuboCop::Cop::Layout::ArrayAlignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#46
+  def on_array(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#55
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#67
+  def base_column(node, args); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#63
+  def fixed_indentation?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#59
+  def message(_range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#78
+  def target_method_lineno(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#40
+RuboCop::Cop::Layout::ArrayAlignment::ALIGN_ELEMENTS_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/array_alignment.rb#43
+RuboCop::Cop::Layout::ArrayAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String)
+
+# Checks the indentation of the first line of the
+# right-hand-side of a multi-line assignment.
+#
+# The indentation of the remaining lines can be corrected with
+# other cops such as `Layout/IndentationConsistency` and `Layout/EndAlignment`.
+#
+# @example
+#   # bad
+#   value =
+#   if foo
+#   'bar'
+#   end
+#
+#   # good
+#   value =
+#   if foo
+#   'bar'
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/assignment_indentation.rb#25
+class RuboCop::Cop::Layout::AssignmentIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CheckAssignment
+  include ::RuboCop::Cop::Alignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/assignment_indentation.rb#43
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/assignment_indentation.rb#34
+  def check_assignment(node, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/layout/assignment_indentation.rb#47
+  def leftmost_multiple_assignment(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/assignment_indentation.rb#30
+RuboCop::Cop::Layout::AssignmentIndentation::MSG = T.let(T.unsafe(nil), String)
+
+# Checks whether the end keyword of `begin` is aligned properly.
+#
+# Two modes are supported through the `EnforcedStyleAlignWith` configuration
+# parameter. If it's set to `start_of_line` (which is the default), the
+# `end` shall be aligned with the start of the line where the `begin`
+# keyword is. If it's set to `begin`, the `end` shall be aligned with the
+# `begin` keyword.
+#
+# `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
+# by default. On the other hand, `||= begin` that this cop targets tends to
+# align with the start of the line, it defaults to `EnforcedStyleAlignWith: start_of_line`.
+# These style can be configured by each cop.
+#
+# @example EnforcedStyleAlignWith: start_of_line (default)
+#   # bad
+#   foo ||= begin
+#   do_something
+#   end
+#
+#   # good
+#   foo ||= begin
+#   do_something
+#   end
+# @example EnforcedStyleAlignWith: begin
+#   # bad
+#   foo ||= begin
+#   do_something
+#   end
+#
+#   # good
+#   foo ||= begin
+#   do_something
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/begin_end_alignment.rb#41
+class RuboCop::Cop::Layout::BeginEndAlignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::EndKeywordAlignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/begin_end_alignment.rb#48
+  def on_kwbegin(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/begin_end_alignment.rb#63
+  def alignment_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/begin_end_alignment.rb#59
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/begin_end_alignment.rb#54
+  def check_begin_alignment(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/begin_end_alignment.rb#46
+RuboCop::Cop::Layout::BeginEndAlignment::MSG = T.let(T.unsafe(nil), String)
+
+# Checks whether the end keywords are aligned properly for do
+# end blocks.
+#
+# Three modes are supported through the `EnforcedStyleAlignWith`
+# configuration parameter:
+#
+# `start_of_block` : the `end` shall be aligned with the
+# start of the line where the `do` appeared.
+#
+# `start_of_line` : the `end` shall be aligned with the
+# start of the line where the expression started.
+#
+# `either` (which is the default) : the `end` is allowed to be in either
+# location. The autocorrect will default to `start_of_line`.
+#
+# @example EnforcedStyleAlignWith: either (default)
+#   # bad
+#
+#   foo.bar
+#   .each do
+#   baz
+#   end
+#
+#   # good
+#
+#   foo.bar
+#   .each do
+#   baz
+#   end
+# @example EnforcedStyleAlignWith: start_of_block
+#   # bad
+#
+#   foo.bar
+#   .each do
+#   baz
+#   end
+#
+#   # good
+#
+#   foo.bar
+#   .each do
+#   baz
+#   end
+# @example EnforcedStyleAlignWith: start_of_line
+#   # bad
+#
+#   foo.bar
+#   .each do
+#   baz
+#   end
+#
+#   # good
+#
+#   foo.bar
+#   .each do
+#   baz
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#66
+class RuboCop::Cop::Layout::BlockAlignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#74
+  def block_end_align_target?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#83
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#83
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#89
+  def style_parameter_name; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#246
+  def add_space_before(corrector, loc, delta); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#223
+  def alt_start_msg(start_loc, source_line_column); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#145
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#95
+  def block_end_align_target(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#113
+  def check_block_alignment(start_node, block_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#196
+  def compute_do_source_line_column(node, end_loc); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#238
+  def compute_start_col(ancestor_node, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#109
+  def disqualified_parent?(parent, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#105
+  def end_align_target?(node, parent); end
+
+  # In offense message, we want to show the assignment LHS rather than
+  # the entire assignment.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#191
+  def find_lhs_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#162
+  def format_message(start_loc, end_loc, do_source_line_column, error_source_line_column); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#233
+  def format_source_line_column(source_line_column); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#215
+  def loc_to_source_line_column(loc); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#126
+  def register_offense(block_node, start_loc, end_loc, do_source_line_column); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#250
+  def remove_space_before(corrector, end_pos, delta); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#172
+  def start_for_block_node(block_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#179
+  def start_for_line_node(block_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/block_alignment.rb#71
+RuboCop::Cop::Layout::BlockAlignment::MSG = T.let(T.unsafe(nil), String)
+
+# Checks whether the end statement of a do..end block
+# is on its own line.
+#
+# @example
+#   # bad
+#   blah do |i|
+#   foo(i) end
+#
+#   # good
+#   blah do |i|
+#   foo(i)
+#   end
+#
+#   # bad
+#   blah { |i|
+#   foo(i) }
+#
+#   # good
+#   blah { |i|
+#   foo(i)
+#   }
+#
+# source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#27
+class RuboCop::Cop::Layout::BlockEndNewline < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#33
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#33
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#66
+  def last_heredoc_argument(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#62
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#76
+  def offense_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#49
+  def register_offense(node, offense_range); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/block_end_newline.rb#31
+RuboCop::Cop::Layout::BlockEndNewline::MSG = T.let(T.unsafe(nil), String)
+
+# Checks how the `when` and ``in``s of a `case` expression
+# are indented in relation to its `case` or `end` keyword.
+#
+# It will register a separate offense for each misaligned `when` and `in`.
+#
+# @example
+#   # If Layout/EndAlignment is set to keyword style (default)
+#   # *case* and *end* should always be aligned to same depth,
+#   # and therefore *when* should always be aligned to both -
+#   # regardless of configuration.
+#
+#   # bad for all styles
+#   case n
+#   when 0
+#   x * 2
+#   else
+#   y / 3
+#   end
+#
+#   case n
+#   in pattern
+#   x * 2
+#   else
+#   y / 3
+#   end
+#
+#   # good for all styles
+#   case n
+#   when 0
+#   x * 2
+#   else
+#   y / 3
+#   end
+#
+#   case n
+#   in pattern
+#   x * 2
+#   else
+#   y / 3
+#   end
+# @example EnforcedStyle: case (default)
+#   # if EndAlignment is set to other style such as
+#   # start_of_line (as shown below), then *when* alignment
+#   # configuration does have an effect.
+#
+#   # bad
+#   a = case n
+#   when 0
+#   x * 2
+#   else
+#   y / 3
+#   end
+#
+#   a = case n
+#   in pattern
+#   x * 2
+#   else
+#   y / 3
+#   end
+#
+#   # good
+#   a = case n
+#   when 0
+#   x * 2
+#   else
+#   y / 3
+#   end
+#
+#   a = case n
+#   in pattern
+#   x * 2
+#   else
+#   y / 3
+#   end
+# @example EnforcedStyle: end
+#   # bad
+#   a = case n
+#   when 0
+#   x * 2
+#   else
+#   y / 3
+#   end
+#
+#   a = case n
+#   in pattern
+#   x * 2
+#   else
+#   y / 3
+#   end
+#
+#   # good
+#   a = case n
+#   when 0
+#   x * 2
+#   else
+#   y / 3
+#   end
+#
+#   a = case n
+#   in pattern
+#   x * 2
+#   else
+#   y / 3
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#112
+class RuboCop::Cop::Layout::CaseIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#120
+  def on_case(case_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#127
+  def on_case_match(case_match_node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#193
+  def base_column(case_node, base); end
+
+  # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#150
+  def check_when(when_node, branch_type); end
+
+  # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#182
+  def detect_incorrect_style(when_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#136
+  def end_and_last_conditional_same_line?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#146
+  def enforced_style_end?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#169
+  def incorrect_style(when_node, branch_type); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#161
+  def indent_one_step?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#165
+  def indentation_width; end
+
+  # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#207
+  def replacement(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#200
+  def whitespace_range(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/case_indentation.rb#118
+RuboCop::Cop::Layout::CaseIndentation::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if the code style follows the ExpectedOrder configuration:
+#
+# `Categories` allows us to map macro names into a category.
+#
+# Consider an example of code style that covers the following order:
+#
+# * Module inclusion (include, prepend, extend)
+# * Constants
+# * Associations (has_one, has_many)
+# * Public attribute macros (attr_accessor, attr_writer, attr_reader)
+# * Other macros (validates, validate)
+# * Public class methods
+# * Initializer
+# * Public instance methods
+# * Protected attribute macros (attr_accessor, attr_writer, attr_reader)
+# * Protected instance methods
+# * Private attribute macros (attr_accessor, attr_writer, attr_reader)
+# * Private instance methods
+#
+# You can configure the following order:
+#
+# [source,yaml]
+# ----
+#  Layout/ClassStructure:
+#    ExpectedOrder:
+#      - module_inclusion
+#      - constants
+#      - association
+#      - public_attribute_macros
+#      - public_delegate
+#      - macros
+#      - public_class_methods
+#      - initializer
+#      - public_methods
+#      - protected_attribute_macros
+#      - protected_methods
+#      - private_attribute_macros
+#      - private_delegate
+#      - private_methods
+# ----
+#
+# Instead of putting all literals in the expected order, is also
+# possible to group categories of macros. Visibility levels are handled
+# automatically.
+#
+# [source,yaml]
+# ----
+#  Layout/ClassStructure:
+#    Categories:
+#      association:
+#        - has_many
+#        - has_one
+#      attribute_macros:
+#        - attr_accessor
+#        - attr_reader
+#        - attr_writer
+#      macros:
+#        - validates
+#        - validate
+#      module_inclusion:
+#        - include
+#        - prepend
+#        - extend
+# ----
+#
+# @example
+#   # bad
+#   # Expect extend be before constant
+#   class Person < ApplicationRecord
+#   has_many :orders
+#   ANSWER = 42
+#
+#   extend SomeModule
+#   include AnotherModule
+#   end
+#
+#   # good
+#   class Person
+#   # extend and include go first
+#   extend SomeModule
+#   include AnotherModule
+#
+#   # inner classes
+#   CustomError = Class.new(StandardError)
+#
+#   # constants are next
+#   SOME_CONSTANT = 20
+#
+#   # afterwards we have public attribute macros
+#   attr_reader :name
+#
+#   # followed by other macros (if any)
+#   validates :name
+#
+#   # then we have public delegate macros
+#   delegate :to_s, to: :name
+#
+#   # public class methods are next in line
+#   def self.some_method
+#   end
+#
+#   # initialization goes between class methods and instance methods
+#   def initialize
+#   end
+#
+#   # followed by other public instance methods
+#   def some_method
+#   end
+#
+#   # protected attribute macros and methods go next
+#   protected
+#
+#   attr_reader :protected_name
+#
+#   def some_protected_method
+#   end
+#
+#   # private attribute macros, delegate macros and methods
+#   # are grouped near the end
+#   private
+#
+#   attr_reader :private_name
+#
+#   delegate :some_private_delegate, to: :name
+#
+#   def some_private_method
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/class_structure.rb#142
+class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::VisibilityHelp
+  include ::RuboCop::Cop::CommentsHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # Validates code style on class declaration.
+  # Add offense when find a node out of expected order.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#158
+  def on_class(class_node); end
+
+  # Validates code style on class declaration.
+  # Add offense when find a node out of expected order.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#158
+  def on_sclass(class_node); end
+
+  private
+
+  # Autocorrect by swapping between two nodes autocorrecting them
+  #
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#174
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#305
+  def begin_pos_with_comment(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#328
+  def buffer; end
+
+  # Setting categories hash allow you to group methods in group to match
+  # in the {expected_order}.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#340
+  def categories; end
+
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#234
+  def class_elements(class_node); end
+
+  # Classifies a node to match with something in the {expected_order}
+  #
+  # @param node to be analysed
+  # @return String when the node type is a `:block` then
+  #   {classify} recursively with the first children
+  # @return String when the node type is a `:send` then {find_category}
+  #   by method name
+  # @return String otherwise trying to {humanize_node} of the current node
+  #
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#194
+  def classify(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#271
+  def dynamic_constant?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#295
+  def end_position_for(node); end
+
+  # Load expected order from `ExpectedOrder` config.
+  # Define new terms in the expected order by adding new {categories}.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#334
+  def expected_order; end
+
+  # Categorize a node according to the {expected_order}
+  # Try to match {categories} values against the node's method_name given
+  # also its visibility.
+  #
+  # @param node to be analysed.
+  # @return [String] with the key category or the `method_name` as string
+  #
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#212
+  def find_category(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#324
+  def find_heredoc(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#262
+  def humanize_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#246
+  def ignore?(node, classification); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#253
+  def ignore_for_autocorrect?(node, sibling); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#289
+  def marked_as_private_constant?(node, name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#279
+  def private_constant?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#320
+  def start_line_position(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#225
+  def walk_over_nested_class_definition(class_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/class_structure.rb#316
+  def whole_line_comment_at_line?(line); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/class_structure.rb#147
+RuboCop::Cop::Layout::ClassStructure::HUMANIZED_NODE_TYPE = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/layout/class_structure.rb#154
+RuboCop::Cop::Layout::ClassStructure::MSG = T.let(T.unsafe(nil), String)
+
+# Checks the indentation of here document closings.
+#
+# @example
+#
+#   # bad
+#   class Foo
+#   def bar
+#   <<~SQL
+#   'Hi'
+#   SQL
+#   end
+#   end
+#
+#   # good
+#   class Foo
+#   def bar
+#   <<~SQL
+#   'Hi'
+#   SQL
+#   end
+#   end
+#
+#   # bad
+#
+#   # heredoc contents is before closing heredoc.
+#   foo arg,
+#   <<~EOS
+#   Hi
+#   EOS
+#
+#   # good
+#   foo arg,
+#   <<~EOS
+#   Hi
+#   EOS
+#
+#   # good
+#   foo arg,
+#   <<~EOS
+#   Hi
+#   EOS
+#
+# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#48
+class RuboCop::Cop::Layout::ClosingHeredocIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Heredoc
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#57
+  def on_heredoc(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#74
+  def argument_indentation_correct?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#82
+  def closing_indentation(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#101
+  def find_node_used_heredoc_argument(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#90
+  def heredoc_closing(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#86
+  def heredoc_opening(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#117
+  def indent_level(source_line); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#94
+  def indented_end(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#109
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#70
+  def opening_indentation(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#53
+RuboCop::Cop::Layout::ClosingHeredocIndentation::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#54
+RuboCop::Cop::Layout::ClosingHeredocIndentation::MSG_ARG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/closing_heredoc_indentation.rb#52
+RuboCop::Cop::Layout::ClosingHeredocIndentation::SIMPLE_HEREDOC = T.let(T.unsafe(nil), String)
+
+# Checks the indentation of hanging closing parentheses in
+# method calls, method definitions, and grouped expressions. A hanging
+# closing parenthesis means `)` preceded by a line break.
+#
+# @example
+#
+#   # bad
+#   some_method(
+#   a,
+#   b
+#   )
+#
+#   some_method(
+#   a, b
+#   )
+#
+#   some_method(a, b, c
+#   )
+#
+#   some_method(a,
+#   b,
+#   c
+#   )
+#
+#   some_method(a,
+#   x: 1,
+#   y: 2
+#   )
+#
+#   # Scenario 1: When First Parameter Is On Its Own Line
+#
+#   # good: when first param is on a new line, right paren is *always*
+#   #       outdented by IndentationWidth
+#   some_method(
+#   a,
+#   b
+#   )
+#
+#   # good
+#   some_method(
+#   a, b
+#   )
+#
+#   # Scenario 2: When First Parameter Is On The Same Line
+#
+#   # good: when all other params are also on the same line, outdent
+#   #       right paren by IndentationWidth
+#   some_method(a, b, c
+#   )
+#
+#   # good: when all other params are on multiple lines, but are lined
+#   #       up, align right paren with left paren
+#   some_method(a,
+#   b,
+#   c
+#   )
+#
+#   # good: when other params are not lined up on multiple lines, outdent
+#   #       right paren by IndentationWidth
+#   some_method(a,
+#   x: 1,
+#   y: 2
+#   )
+#
+# source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#71
+class RuboCop::Cop::Layout::ClosingParenthesisIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#84
+  def on_begin(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#79
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#88
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#88
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#79
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#157
+  def all_elements_aligned?(elements); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#95
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#99
+  def check(node, elements); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#107
+  def check_for_elements(node, elements); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#125
+  def check_for_no_elements(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#171
+  def correct_column_candidates(node, left_paren); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#144
+  def expected_column(left_paren, elements); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#167
+  def first_argument_line(elements); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#187
+  def line_break_after_left_paren?(left_paren, elements); end
+
+  # source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#179
+  def message(correct_column, left_paren, right_paren); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#77
+RuboCop::Cop::Layout::ClosingParenthesisIndentation::MSG_ALIGN = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/closing_parenthesis_indentation.rb#75
+RuboCop::Cop::Layout::ClosingParenthesisIndentation::MSG_INDENT = T.let(T.unsafe(nil), String)
+
+# Checks the indentation of comments.
+#
+# @example
+#   # bad
+#   # comment here
+#   def method_name
+#   end
+#
+#   # comment here
+#   a = 'hello'
+#
+#   # yet another comment
+#   if true
+#   true
+#   end
+#
+#   # good
+#   # comment here
+#   def method_name
+#   end
+#
+#   # comment here
+#   a = 'hello'
+#
+#   # yet another comment
+#   if true
+#   true
+#   end
+# @example AllowForAlignment: false (default)
+#   # bad
+#   a = 1 # A really long comment
+#   # spanning two lines.
+#
+#   # good
+#   # A really long comment spanning one line.
+#   a = 1
+# @example AllowForAlignment: true
+#   # good
+#   a = 1 # A really long comment
+#   # spanning two lines.
+#
+# source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#48
+class RuboCop::Cop::Layout::CommentIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#55
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#61
+  def autocorrect(corrector, comment); end
+
+  # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#88
+  def autocorrect_one(corrector, comment); end
+
+  # Corrects all comment lines that occur immediately before the given
+  # comment and have the same indentation. This is to avoid a long chain
+  # of correcting, saving the file, parsing and inspecting again, and
+  # then correcting one more line, and so on.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#71
+  def autocorrect_preceding_comments(corrector, comment); end
+
+  # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#92
+  def check(comment, comment_index); end
+
+  # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#145
+  def correct_indentation(next_line); end
+
+  # Returns true if:
+  # a) the cop is configured to allow extra indentation for alignment, and
+  # b) the currently inspected comment is aligned with the nearest preceding end-of-line
+  #    comment.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#121
+  def correctly_aligned_with_preceding_comment?(comment_index, column); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#156
+  def less_indented?(line); end
+
+  # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#140
+  def line_after_comment(comment); end
+
+  # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#131
+  def message(column, correct_comment_indentation); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#135
+  def own_line_comment?(comment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#82
+  def should_correct?(preceding_comment, reference_comment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#162
+  def two_alternatives?(line); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/comment_indentation.rb#52
+RuboCop::Cop::Layout::CommentIndentation::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for conditions that are not on the same line as
+# if/while/until.
+#
+# @example
+#
+#   # bad
+#   if
+#   some_condition
+#   do_something
+#   end
+#
+#   # good
+#   if some_condition
+#   do_something
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/condition_position.rb#21
+class RuboCop::Cop::Layout::ConditionPosition < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/condition_position.rb#27
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/condition_position.rb#33
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/condition_position.rb#33
+  def on_while(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/condition_position.rb#40
+  def check(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/condition_position.rb#54
+  def message(condition); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/condition_position.rb#25
+RuboCop::Cop::Layout::ConditionPosition::MSG = T.let(T.unsafe(nil), String)
+
+# Checks whether the end keywords of method definitions are
+# aligned properly.
+#
+# Two modes are supported through the EnforcedStyleAlignWith configuration
+# parameter. If it's set to `start_of_line` (which is the default), the
+# `end` shall be aligned with the start of the line where the `def`
+# keyword is. If it's set to `def`, the `end` shall be aligned with the
+# `def` keyword.
+#
+# @example EnforcedStyleAlignWith: start_of_line (default)
+#   # bad
+#
+#   private def foo
+#   end
+#
+#   # good
+#
+#   private def foo
+#   end
+# @example EnforcedStyleAlignWith: def
+#   # bad
+#
+#   private def foo
+#   end
+#
+#   # good
+#
+#   private def foo
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/def_end_alignment.rb#36
+class RuboCop::Cop::Layout::DefEndAlignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::EndKeywordAlignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/def_end_alignment.rb#43
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/def_end_alignment.rb#43
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/def_end_alignment.rb#48
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/def_end_alignment.rb#63
+  def autocorrect(corrector, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/def_end_alignment.rb#41
+RuboCop::Cop::Layout::DefEndAlignment::MSG = T.let(T.unsafe(nil), String)
+
+# Checks the . position in multi-line method calls.
+#
+# @example EnforcedStyle: leading (default)
+#   # bad
+#   something.
+#   method
+#
+#   # good
+#   something
+#   .method
+# @example EnforcedStyle: trailing
+#   # bad
+#   something
+#   .method
+#
+#   # good
+#   something.
+#   method
+#
+# source://rubocop//lib/rubocop/cop/layout/dot_position.rb#25
+class RuboCop::Cop::Layout::DotPosition < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#34
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#34
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#49
+  def autocorrect(corrector, dot, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#99
+  def correct_dot_position_style?(dot_line, selector_line); end
+
+  # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#126
+  def end_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#122
+  def heredoc?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#114
+  def last_heredoc_line(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#95
+  def line_between?(first_line, second_line); end
+
+  # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#64
+  def message(dot); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#74
+  def proper_dot_position?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#106
+  def receiver_end_line(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#130
+  def selector_range(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/layout/dot_position.rb#30
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# Checks the alignment of else keywords. Normally they should
+# be aligned with an if/unless/while/until/begin/def/rescue keyword, but there
+# are special cases when they should follow the same rules as the
+# alignment of end.
+#
+# @example
+#   # bad
+#   if something
+#   code
+#   else
+#   code
+#   end
+#
+#   # bad
+#   if something
+#   code
+#   elsif something
+#   code
+#   end
+#
+#   # good
+#   if something
+#   code
+#   else
+#   code
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#32
+class RuboCop::Cop::Layout::ElseAlignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::EndKeywordAlignment
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::CheckAssignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#57
+  def on_case(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#63
+  def on_case_match(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#40
+  def on_if(node, base = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#51
+  def on_rescue(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#147
+  def assignment_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#71
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#106
+  def base_for_method_definition(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#80
+  def base_range_of_if(node, base); end
+
+  # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#89
+  def base_range_of_rescue(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#131
+  def check_alignment(base_range, else_range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#115
+  def check_assignment(node, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#75
+  def check_nested(node, base); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/else_alignment.rb#38
+RuboCop::Cop::Layout::ElseAlignment::MSG = T.let(T.unsafe(nil), String)
+
+# Checks empty comment.
+#
+# @example
+#   # bad
+#
+#   #
+#   class Foo
+#   end
+#
+#   # good
+#
+#   #
+#   # Description of `Foo` class.
+#   #
+#   class Foo
+#   end
+# @example AllowBorderComment: true (default)
+#   # good
+#
+#   def foo
+#   end
+#
+#   #################
+#
+#   def bar
+#   end
+# @example AllowBorderComment: false
+#   # bad
+#
+#   def foo
+#   end
+#
+#   #################
+#
+#   def bar
+#   end
+# @example AllowMarginComment: true (default)
+#   # good
+#
+#   #
+#   # Description of `Foo` class.
+#   #
+#   class Foo
+#   end
+# @example AllowMarginComment: false
+#   # bad
+#
+#   #
+#   # Description of `Foo` class.
+#   #
+#   class Foo
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#63
+class RuboCop::Cop::Layout::EmptyComment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#69
+  def on_new_investigation; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#133
+  def allow_border_comment?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#137
+  def allow_margin_comment?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#97
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#129
+  def comment_text(comment); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#108
+  def concat_consecutive_comments(comments); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#141
+  def current_token(comment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#119
+  def empty_comment_only?(comment_text); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#85
+  def investigate(comments); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#145
+  def previous_token(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_comment.rb#67
+RuboCop::Cop::Layout::EmptyComment::MSG = T.let(T.unsafe(nil), String)
+
+# Enforces empty line after guard clause.
+#
+# This cop allows `# :nocov:` directive after guard clause because
+# SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+#
+# [source,ruby]
+# ----
+# def foo
+#   # :nocov:
+#   return if condition
+#   # :nocov:
+#   bar
+# end
+# ----
+#
+# Refer to SimpleCov's documentation for more details:
+# https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
+#
+# @example
+#
+#   # bad
+#   def foo
+#   return if need_return?
+#   bar
+#   end
+#
+#   # good
+#   def foo
+#   return if need_return?
+#
+#   bar
+#   end
+#
+#   # good
+#   def foo
+#   return if something?
+#   return if something_different?
+#
+#   bar
+#   end
+#
+#   # also good
+#   def foo
+#   if something?
+#   do_something
+#   return if need_return?
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#54
+class RuboCop::Cop::Layout::EmptyLineAfterGuardClause < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::PathUtil
+  extend ::RuboCop::Cop::Util
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#63
+  def on_if(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#84
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#106
+  def contains_guard_clause?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#99
+  def correct_style?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#181
+  def heredoc?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#174
+  def heredoc_line(node, heredoc_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#148
+  def last_heredoc_argument(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#162
+  def last_heredoc_argument_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#199
+  def multiple_statements_on_line?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#121
+  def next_line_allowed_directive_comment?(line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#117
+  def next_line_empty?(line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#110
+  def next_line_empty_or_allowed_directive_comment?(line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#127
+  def next_line_rescue_or_ensure?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#141
+  def next_sibling_empty_or_guard_clause?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#132
+  def next_sibling_parent_empty_or_else?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#191
+  def offense_location(node); end
+
+  # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+  # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#208
+  def simplecov_directive_comment?(comment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#185
+  def use_heredoc_in_condition?(condition); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#60
+RuboCop::Cop::Layout::EmptyLineAfterGuardClause::END_OF_HEREDOC_LINE = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#59
+RuboCop::Cop::Layout::EmptyLineAfterGuardClause::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/empty_line_after_guard_clause.rb#61
+RuboCop::Cop::Layout::EmptyLineAfterGuardClause::SIMPLE_DIRECTIVE_COMMENT_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# Checks for a newline after the final magic comment.
+#
+# @example
+#   # good
+#   # frozen_string_literal: true
+#
+#   # Some documentation for Person
+#   class Person
+#   # Some code
+#   end
+#
+#   # bad
+#   # frozen_string_literal: true
+#   # Some documentation for Person
+#   class Person
+#   # Some code
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_line_after_magic_comment.rb#23
+class RuboCop::Cop::Layout::EmptyLineAfterMagicComment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_magic_comment.rb#29
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_magic_comment.rb#61
+  def comments_before_code(source); end
+
+  # Find the last magic comment in the source file.
+  #
+  # Take all comments that precede the first line of code (or just take
+  # them all in the case when there is no code), select the
+  # magic comments, and return the last magic comment in the file.
+  #
+  # @return [Parser::Source::Comment] if magic comments exist before code
+  # @return [nil] otherwise
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_magic_comment.rb#55
+  def last_magic_comment(source); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_magic_comment.rb#43
+  def offending_range(last_magic_comment); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_line_after_magic_comment.rb#27
+RuboCop::Cop::Layout::EmptyLineAfterMagicComment::MSG = T.let(T.unsafe(nil), String)
+
+# Enforces empty line after multiline condition.
+#
+# @example
+#   # bad
+#   if multiline &&
+#   condition
+#   do_something
+#   end
+#
+#   # good
+#   if multiline &&
+#   condition
+#
+#   do_something
+#   end
+#
+#   # bad
+#   case x
+#   when foo,
+#   bar
+#   do_something
+#   end
+#
+#   # good
+#   case x
+#   when foo,
+#   bar
+#
+#   do_something
+#   end
+#
+#   # bad
+#   begin
+#   do_something
+#   rescue FooError,
+#   BarError
+#   handle_error
+#   end
+#
+#   # good
+#   begin
+#   do_something
+#   rescue FooError,
+#   BarError
+#
+#   handle_error
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#54
+class RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#82
+  def on_case(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#60
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#93
+  def on_rescue(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#70
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#75
+  def on_until_post(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#70
+  def on_while(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#75
+  def on_while_post(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#127
+  def autocorrect(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#105
+  def check_condition(condition); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#120
+  def multiline_rescue_exceptions?(exception_nodes); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#116
+  def multiline_when_condition?(when_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#112
+  def next_line_empty?(line); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb#58
+RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition::MSG = T.let(T.unsafe(nil), String)
+
+# Checks whether class/module/method definitions are
+# separated by one or more empty lines.
+#
+# `NumberOfEmptyLines` can be an integer (default is 1) or
+# an array (e.g. [1, 2]) to specify a minimum and maximum
+# number of empty lines permitted.
+#
+# `AllowAdjacentOneLineDefs` configures whether adjacent
+# one-line definitions are considered an offense.
+#
+# @example AllowAdjacentOneLineDefs: false
+#
+#   # bad
+#   class ErrorA < BaseError; end
+#   class ErrorB < BaseError; end
+#   class ErrorC < BaseError; end
+#
+#   # good
+#   class ErrorA < BaseError; end
+#
+#   class ErrorB < BaseError; end
+#
+#   class ErrorC < BaseError; end
+# @example
+#
+#   # good
+#   def a
+#   end
+#
+#   def b
+#   end
+# @example EmptyLineBetweenClassDefs: true (default)
+#   # checks for empty lines between class definitions.
+#
+#   # bad
+#   class A
+#   end
+#   class B
+#   end
+#   def b
+#   end
+# @example
+#
+#   # good
+#   class A
+#   end
+#
+#   class B
+#   end
+#
+#   def b
+#   end
+# @example EmptyLineBetweenModuleDefs: true (default)
+#   # checks for empty lines between module definitions.
+#
+#   # bad
+#   module A
+#   end
+#   module B
+#   end
+#   def b
+#   end
+# @example
+#
+#   # good
+#   module A
+#   end
+#
+#   module B
+#   end
+#
+#   def b
+#   end
+# @example AllowAdjacentOneLineDefs: true (default)
+#
+#   # good
+#   class ErrorA < BaseError; end
+#   class ErrorB < BaseError; end
+#   class ErrorC < BaseError; end
+#
+#   # good
+#   class ErrorA < BaseError; end
+#
+#   class ErrorB < BaseError; end
+#
+#   class ErrorC < BaseError; end
+# @example EmptyLineBetweenMethodDefs: true (default)
+#   # checks for empty lines between method definitions.
+#
+#   # bad
+#   def a
+#   end
+#   def b
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#108
+class RuboCop::Cop::Layout::EmptyLineBetweenDefs < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#145
+  def autocorrect(corrector, prev_def, node, count); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#130
+  def check_defs(nodes); end
+
+  # We operate on `begin` nodes, instead of using `OnMethodDef`,
+  # so that we can walk over pairs of consecutive nodes and
+  # efficiently access a node's predecessor; #prev_node ends up
+  # doing a linear scan over siblings, so we don't want to call
+  # it on each def.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#123
+  def on_begin(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#291
+  def allowance_range?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#275
+  def autocorrect_insert_lines(corrector, newline_pos, count); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#268
+  def autocorrect_remove_lines(corrector, newline_pos, count); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#228
+  def blank_lines_count_between(first_def_node, second_def_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#172
+  def candidate?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#192
+  def class_candidate?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#256
+  def def_end(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#164
+  def def_location(correction_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#248
+  def def_start(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#179
+  def empty_line_between_macros; end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#260
+  def end_loc(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#206
+  def expected_lines; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#224
+  def line_count_allowed?(count); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#240
+  def lines_between_defs(first_def_node, second_def_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#183
+  def macro_candidate?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#236
+  def maximum_empty_lines; end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#200
+  def message(node, count: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#188
+  def method_candidate?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#232
+  def minimum_empty_lines; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#196
+  def module_candidate?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#215
+  def multiple_blank_lines_groups?(first_def_node, second_def_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#282
+  def node_type(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#114
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_line_between_defs.rb#112
+RuboCop::Cop::Layout::EmptyLineBetweenDefs::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for two or more consecutive blank lines.
+#
+# @example
+#
+#   # bad - It has two empty lines.
+#   some_method
+#   # one empty line
+#   # two empty lines
+#   some_method
+#
+#   # good
+#   some_method
+#   # one empty line
+#   some_method
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_lines.rb#21
+class RuboCop::Cop::Layout::EmptyLines < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines.rb#28
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines.rb#45
+  def each_extra_empty_line(lines); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines.rb#63
+  def exceeds_line_offset?(line_diff); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines.rb#67
+  def previous_and_current_lines_empty?(line); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines.rb#26
+RuboCop::Cop::Layout::EmptyLines::LINE_OFFSET = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines.rb#25
+RuboCop::Cop::Layout::EmptyLines::MSG = T.let(T.unsafe(nil), String)
+
+# Access modifiers should be surrounded by blank lines.
+#
+# @example EnforcedStyle: around (default)
+#
+#   # bad
+#   class Foo
+#   def bar; end
+#   private
+#   def baz; end
+#   end
+#
+#   # good
+#   class Foo
+#   def bar; end
+#
+#   private
+#
+#   def baz; end
+#   end
+# @example EnforcedStyle: only_before
+#
+#   # bad
+#   class Foo
+#   def bar; end
+#   private
+#   def baz; end
+#   end
+#
+#   # good
+#   class Foo
+#   def bar; end
+#
+#   private
+#   def baz; end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#43
+class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # @return [EmptyLinesAroundAccessModifier] a new instance of EmptyLinesAroundAccessModifier
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#56
+  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#81
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#62
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#71
+  def on_module(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#81
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#76
+  def on_sclass(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#87
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#115
+  def allowed_only_before_style?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#164
+  def block_start?(line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#170
+  def body_end?(line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#158
+  def class_def?(line); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#124
+  def correct_next_line_if_denied_style(corrector, node, line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#154
+  def empty_lines_around?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#104
+  def expected_empty_lines?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#180
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#189
+  def message_for_around_style(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#199
+  def message_for_only_before_style(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#176
+  def next_empty_line_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#148
+  def next_line_empty?(last_send_line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#141
+  def previous_line_empty?(send_line); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#137
+  def previous_line_ignoring_comments(processed_source, send_line); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#48
+RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_AFTER = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#52
+RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_AFTER_FOR_ONLY_BEFORE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#49
+RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_BEFORE_AND_AFTER = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#51
+RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_BEFORE_FOR_ONLY_BEFORE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb#54
+RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks if empty lines exist around the arguments
+# of a method invocation.
+#
+# @example
+#   # bad
+#   do_something(
+#   foo
+#
+#   )
+#
+#   process(bar,
+#
+#   baz: qux,
+#   thud: fred)
+#
+#   some_method(
+#
+#   [1,2,3],
+#   x: y
+#   )
+#
+#   # good
+#   do_something(
+#   foo
+#   )
+#
+#   process(bar,
+#   baz: qux,
+#   thud: fred)
+#
+#   some_method(
+#   [1,2,3],
+#   x: y
+#   )
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#41
+class RuboCop::Cop::Layout::EmptyLinesAroundArguments < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#47
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#47
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#65
+  def empty_lines(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#71
+  def extra_lines(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#93
+  def inner_lines(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#84
+  def line_numbers(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#97
+  def outer_lines(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#78
+  def processed_lines(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#61
+  def receiver_and_method_call_on_different_lines?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_arguments.rb#45
+RuboCop::Cop::Layout::EmptyLinesAroundArguments::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for a newline after an attribute accessor or a group of them.
+# `alias` syntax and `alias_method`, `public`, `protected`, and `private` methods are allowed
+# by default. These are customizable with `AllowAliasSyntax` and `AllowedMethods` options.
+#
+# @example
+#   # bad
+#   attr_accessor :foo
+#   def do_something
+#   end
+#
+#   # good
+#   attr_accessor :foo
+#
+#   def do_something
+#   end
+#
+#   # good
+#   attr_accessor :foo
+#   attr_reader :bar
+#   attr_writer :baz
+#   attr :qux
+#
+#   def do_something
+#   end
+# @example AllowAliasSyntax: true (default)
+#   # good
+#   attr_accessor :foo
+#   alias :foo? :foo
+#
+#   def do_something
+#   end
+# @example AllowAliasSyntax: false
+#   # bad
+#   attr_accessor :foo
+#   alias :foo? :foo
+#
+#   def do_something
+#   end
+#
+#   # good
+#   attr_accessor :foo
+#
+#   alias :foo? :foo
+#
+#   def do_something
+#   end
+# @example AllowedMethods: ['private']
+#   # good
+#   attr_accessor :foo
+#   private :foo
+#
+#   def do_something
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#63
+class RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::AllowedMethods
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#70
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#123
+  def allow_alias?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#133
+  def allow_alias_syntax?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#127
+  def attribute_or_allowed_method?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#83
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#107
+  def next_line_empty?(line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#94
+  def next_line_empty_or_enable_directive_comment?(line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#101
+  def next_line_enable_directive_comment?(line); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#117
+  def next_line_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#111
+  def require_empty_line?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb#68
+RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if empty lines exist around the bodies of begin-end
+# blocks.
+#
+# @example
+#
+#   # good
+#
+#   begin
+#   # ...
+#   end
+#
+#   # bad
+#
+#   begin
+#
+#   # ...
+#
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_begin_body.rb#24
+class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_begin_body.rb#30
+  def on_kwbegin(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_begin_body.rb#36
+  def style; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_begin_body.rb#28
+RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::KIND = T.let(T.unsafe(nil), String)
+
+# Checks if empty lines around the bodies of blocks match
+# the configuration.
+#
+# @example EnforcedStyle: no_empty_lines (default)
+#   # good
+#
+#   foo do |bar|
+#   # ...
+#   end
+# @example EnforcedStyle: empty_lines
+#   # good
+#
+#   foo do |bar|
+#
+#   # ...
+#
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_block_body.rb#24
+class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_block_body.rb#30
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_block_body.rb#30
+  def on_numblock(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_block_body.rb#28
+RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::KIND = T.let(T.unsafe(nil), String)
+
+# Common functionality for checking if presence/absence of empty lines
+# around some kind of body matches the configuration.
+#
+# source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#8
+module RuboCop::Cop::Layout::EmptyLinesAroundBody
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#20
+  def constant_definition?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#23
+  def empty_line_required?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#26
+  def check(node, body, adjusted_first_line: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#81
+  def check_beginning(style, first_line); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#67
+  def check_both(style, first_line, last_line); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#108
+  def check_deferred_empty_line(body); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#43
+  def check_empty_lines_except_namespace(body, first_line, last_line); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#51
+  def check_empty_lines_special(body, first_line, last_line); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#85
+  def check_ending(style, last_line); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#98
+  def check_line(style, line, msg); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#89
+  def check_source(style, line_no, desc); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#159
+  def deferred_message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#132
+  def first_child_requires_empty_line?(body); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#140
+  def first_empty_line_required_child(body); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#155
+  def message(type, desc); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#122
+  def namespace?(body, with_one_child: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#148
+  def previous_line_ignoring_comments(send_line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#163
+  def valid_body_style?(body); end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#15
+RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_DEFERRED = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#13
+RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_EXTRA = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/empty_lines_around_body.rb#14
+RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_MISSING = T.let(T.unsafe(nil), String)
+
+# Checks if empty lines around the bodies of classes match
+# the configuration.
+#
+# @example EnforcedStyle: no_empty_lines (default)
+#   # good
+#
+#   class Foo
+#   def bar
+#   # ...
+#   end
+#   end
+# @example EnforcedStyle: empty_lines
+#   # good
+#
+#   class Foo
+#
+#   def bar
+#   # ...
+#   end
+#
+#   end
+# @example EnforcedStyle: empty_lines_except_namespace
+#   # good
+#
+#   class Foo
+#   class Bar
+#
+#   # ...
+#
+#   end
+#   end
+# @example EnforcedStyle: empty_lines_special
+#   # good
+#   class Foo
+#
+#   def bar; end
+#
+#   end
+# @example EnforcedStyle: beginning_only
+#   # good
+#
+#   class Foo
+#
+#   def bar
+#   # ...
+#   end
+#   end
+# @example EnforcedStyle: ending_only
+#   # good
+#
+#   class Foo
+#   def bar
+#   # ...
+#   end
+#
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_class_body.rb#67
+class RuboCop::Cop::Layout::EmptyLinesAroundClassBody < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_class_body.rb#73
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_class_body.rb#79
+  def on_sclass(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_class_body.rb#71
+RuboCop::Cop::Layout::EmptyLinesAroundClassBody::KIND = T.let(T.unsafe(nil), String)
+
+# Checks if empty lines exist around the bodies of `begin`
+# sections. This cop doesn't check empty lines at `begin` body
+# beginning/end and around method definition body.
+# `Style/EmptyLinesAroundBeginBody` or `Style/EmptyLinesAroundMethodBody`
+# can be used for this purpose.
+#
+# @example
+#
+#   # good
+#
+#   begin
+#   do_something
+#   rescue
+#   do_something2
+#   else
+#   do_something3
+#   ensure
+#   do_something4
+#   end
+#
+#   # good
+#
+#   def foo
+#   do_something
+#   rescue
+#   do_something2
+#   end
+#
+#   # bad
+#
+#   begin
+#   do_something
+#
+#   rescue
+#
+#   do_something2
+#
+#   else
+#
+#   do_something3
+#
+#   ensure
+#
+#   do_something4
+#   end
+#
+#   # bad
+#
+#   def foo
+#   do_something
+#
+#   rescue
+#
+#   do_something2
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#61
+class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#67
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#67
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#67
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#74
+  def on_kwbegin(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#67
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#81
+  def check_body(body, line_of_def_or_kwbegin); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#113
+  def keyword_locations(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#130
+  def keyword_locations_in_ensure(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#126
+  def keyword_locations_in_rescue(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#96
+  def last_body_and_end_on_same_line?(body); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#105
+  def message(location, keyword); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#109
+  def style; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb#65
+RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if empty lines exist around the bodies of methods.
+#
+# @example
+#
+#   # good
+#
+#   def foo
+#   # ...
+#   end
+#
+#   # bad
+#
+#   def bar
+#
+#   # ...
+#
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_method_body.rb#23
+class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_method_body.rb#29
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_method_body.rb#29
+  def on_defs(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_method_body.rb#36
+  def style; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_method_body.rb#27
+RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::KIND = T.let(T.unsafe(nil), String)
+
+# Checks if empty lines around the bodies of modules match
+# the configuration.
+#
+# @example EnforcedStyle: no_empty_lines (default)
+#   # good
+#
+#   module Foo
+#   def bar
+#   # ...
+#   end
+#   end
+# @example EnforcedStyle: empty_lines
+#   # good
+#
+#   module Foo
+#
+#   def bar
+#   # ...
+#   end
+#
+#   end
+# @example EnforcedStyle: empty_lines_except_namespace
+#   # good
+#
+#   module Foo
+#   module Bar
+#
+#   # ...
+#
+#   end
+#   end
+# @example EnforcedStyle: empty_lines_special
+#   # good
+#   module Foo
+#
+#   def bar; end
+#
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_module_body.rb#47
+class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/empty_lines_around_module_body.rb#53
+  def on_module(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/empty_lines_around_module_body.rb#51
+RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::KIND = T.let(T.unsafe(nil), String)
+
+# Checks whether the end keywords are aligned properly.
+#
+# Three modes are supported through the `EnforcedStyleAlignWith`
+# configuration parameter:
+#
+# If it's set to `keyword` (which is the default), the `end`
+# shall be aligned with the start of the keyword (if, class, etc.).
+#
+# If it's set to `variable` the `end` shall be aligned with the
+# left-hand-side of the variable assignment, if there is one.
+#
+# If it's set to `start_of_line`, the `end` shall be aligned with the
+# start of the line where the matching keyword appears.
+#
+# This `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
+# by default. On the other hand, `Layout/BeginEndAlignment` cop aligns with
+# `EnforcedStyleAlignWith: start_of_line` by default due to `||= begin` tends
+# to align with the start of the line. `Layout/DefEndAlignment` cop also aligns with
+# `EnforcedStyleAlignWith: start_of_line` by default.
+# These style can be configured by each cop.
+#
+# @example EnforcedStyleAlignWith: keyword (default)
+#   # bad
+#
+#   variable = if true
+#   end
+#
+#   # good
+#
+#   variable = if true
+#   end
+#
+#   variable =
+#   if true
+#   end
+# @example EnforcedStyleAlignWith: variable
+#   # bad
+#
+#   variable = if true
+#   end
+#
+#   # good
+#
+#   variable = if true
+#   end
+#
+#   variable =
+#   if true
+#   end
+# @example EnforcedStyleAlignWith: start_of_line
+#   # bad
+#
+#   variable = if true
+#   end
+#
+#   puts(if true
+#   end)
+#
+#   # good
+#
+#   variable = if true
+#   end
+#
+#   puts(if true
+#   end)
+#
+#   variable =
+#   if true
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#77
+class RuboCop::Cop::Layout::EndAlignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CheckAssignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::EndKeywordAlignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#111
+  def on_case(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#111
+  def on_case_match(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#83
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#99
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#95
+  def on_module(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#87
+  def on_sclass(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#107
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#103
+  def on_while(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#167
+  def alignment_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#184
+  def alignment_node_for_variable_style(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#148
+  def asgn_variable_align_with(outer_node, inner_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#202
+  def assignment_or_operator_method(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#122
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#137
+  def check_asgn_alignment(outer_node, inner_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#126
+  def check_assignment(node, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_alignment.rb#158
+  def check_other_alignment(node); end
+end
+
+# Checks for Windows-style line endings in the source code.
+#
+# @example EnforcedStyle: native (default)
+#   # The `native` style means that CR+LF (Carriage Return + Line Feed) is
+#   # enforced on Windows, and LF is enforced on other platforms.
+#
+#   # bad
+#   puts 'Hello' # Return character is LF on Windows.
+#   puts 'Hello' # Return character is CR+LF on other than Windows.
+#
+#   # good
+#   puts 'Hello' # Return character is CR+LF on Windows.
+#   puts 'Hello' # Return character is LF on other than Windows.
+# @example EnforcedStyle: lf
+#   # The `lf` style means that LF (Line Feed) is enforced on
+#   # all platforms.
+#
+#   # bad
+#   puts 'Hello' # Return character is CR+LF on all platforms.
+#
+#   # good
+#   puts 'Hello' # Return character is LF on all platforms.
+# @example EnforcedStyle: crlf
+#   # The `crlf` style means that CR+LF (Carriage Return + Line Feed) is
+#   # enforced on all platforms.
+#
+#   # bad
+#   puts 'Hello' # Return character is LF on all platforms.
+#
+#   # good
+#   puts 'Hello' # Return character is CR+LF on all platforms.
+#
+# source://rubocop//lib/rubocop/cop/layout/end_of_line.rb#40
+class RuboCop::Cop::Layout::EndOfLine < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/layout/end_of_line.rb#71
+  def offense_message(line); end
+
+  # source://rubocop//lib/rubocop/cop/layout/end_of_line.rb#47
+  def on_new_investigation; end
+
+  # If there is no LF on the last line, we don't care if there's no CR.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/end_of_line.rb#67
+  def unimportant_missing_cr?(index, last_line, line); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/end_of_line.rb#85
+  def last_line(processed_source); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/end_of_line.rb#44
+RuboCop::Cop::Layout::EndOfLine::MSG_DETECTED = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/end_of_line.rb#45
+RuboCop::Cop::Layout::EndOfLine::MSG_MISSING = T.let(T.unsafe(nil), String)
+
+# Checks for extra/unnecessary whitespace.
+#
+# @example
+#
+#   # good if AllowForAlignment is true
+#   name      = "RuboCop"
+#   # Some comment and an empty line
+#
+#   website  += "/rubocop/rubocop" unless cond
+#   puts        "rubocop"          if     debug
+#
+#   # bad for any configuration
+#   set_app("RuboCop")
+#   website  = "https://github.com/rubocop/rubocop"
+#
+#   # good only if AllowBeforeTrailingComments is true
+#   object.method(arg)  # this is a comment
+#
+#   # good even if AllowBeforeTrailingComments is false or not set
+#   object.method(arg) # this is a comment
+#
+#   # good with either AllowBeforeTrailingComments or AllowForAlignment
+#   object.method(arg)         # this is a comment
+#   another_object.method(arg) # this is another comment
+#   some_object.method(arg)    # this is some comment
+#
+# source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#31
+class RuboCop::Cop::Layout::ExtraSpacing < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::PrecedingFollowingAlignment
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#39
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#170
+  def align_column(asgn_token); end
+
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#147
+  def align_equal_sign(corrector, token, align_to); end
+
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#137
+  def align_equal_signs(range, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#52
+  def aligned_locations(locs); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#103
+  def aligned_tok?(token); end
+
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#159
+  def all_relevant_assignment_lines(line_number); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#179
+  def allow_for_trailing_comments?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#72
+  def check_assignment(token); end
+
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#81
+  def check_other(token1, token2, ast); end
+
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#62
+  def check_tokens(ast, token1, token2); end
+
+  # @yield [range_between(start_pos, end_pos)]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#91
+  def extra_space_range(token1, token2); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#133
+  def force_equal_sign_alignment?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#111
+  def ignored_range?(ast, start_pos); end
+
+  # Returns an array of ranges that should not be reported. It's the
+  # extra spaces between the keys and values in a multiline hash,
+  # since those are handled by the Layout/HashAlignment cop.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#118
+  def ignored_ranges(ast); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#37
+RuboCop::Cop::Layout::ExtraSpacing::MSG_UNALIGNED_ASGN = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/extra_spacing.rb#36
+RuboCop::Cop::Layout::ExtraSpacing::MSG_UNNECESSARY = T.let(T.unsafe(nil), String)
+
+# Checks the indentation of the first argument in a method call.
+# Arguments after the first one are checked by `Layout/ArgumentAlignment`,
+# not by this cop.
+#
+# For indenting the first parameter of method _definitions_, check out
+# `Layout/FirstParameterIndentation`.
+#
+# This cop will respect `Layout/ArgumentAlignment` and will not work when
+# `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArgumentAlignment`.
+#
+# @example
+#
+#   # bad
+#   some_method(
+#   first_param,
+#   second_param)
+#
+#   foo = some_method(
+#   first_param,
+#   second_param)
+#
+#   foo = some_method(nested_call(
+#   nested_first_param),
+#   second_param)
+#
+#   foo = some_method(
+#   nested_call(
+#   nested_first_param),
+#   second_param)
+#
+#   some_method nested_call(
+#   nested_first_param),
+#   second_param
+# @example EnforcedStyle: special_for_inner_method_call_in_parentheses (default)
+#   # Same as `special_for_inner_method_call` except that the special rule
+#   # only applies if the outer method call encloses its arguments in
+#   # parentheses.
+#
+#   # good
+#   some_method(
+#   first_param,
+#   second_param)
+#
+#   foo = some_method(
+#   first_param,
+#   second_param)
+#
+#   foo = some_method(nested_call(
+#   nested_first_param),
+#   second_param)
+#
+#   foo = some_method(
+#   nested_call(
+#   nested_first_param),
+#   second_param)
+#
+#   some_method nested_call(
+#   nested_first_param),
+#   second_param
+# @example EnforcedStyle: consistent
+#   # The first argument should always be indented one step more than the
+#   # preceding line.
+#
+#   # good
+#   some_method(
+#   first_param,
+#   second_param)
+#
+#   foo = some_method(
+#   first_param,
+#   second_param)
+#
+#   foo = some_method(nested_call(
+#   nested_first_param),
+#   second_param)
+#
+#   foo = some_method(
+#   nested_call(
+#   nested_first_param),
+#   second_param)
+#
+#   some_method nested_call(
+#   nested_first_param),
+#   second_param
+# @example EnforcedStyle: consistent_relative_to_receiver
+#   # The first argument should always be indented one level relative to
+#   # the parent that is receiving the argument
+#
+#   # good
+#   some_method(
+#   first_param,
+#   second_param)
+#
+#   foo = some_method(
+#   first_param,
+#   second_param)
+#
+#   foo = some_method(nested_call(
+#   nested_first_param),
+#   second_param)
+#
+#   foo = some_method(
+#   nested_call(
+#   nested_first_param),
+#   second_param)
+#
+#   some_method nested_call(
+#   nested_first_param),
+#   second_params
+# @example EnforcedStyle: special_for_inner_method_call
+#   # The first argument should normally be indented one step more than
+#   # the preceding line, but if it's an argument for a method call that
+#   # is itself an argument in a method call, then the inner argument
+#   # should be indented relative to the inner method.
+#
+#   # good
+#   some_method(
+#   first_param,
+#   second_param)
+#
+#   foo = some_method(
+#   first_param,
+#   second_param)
+#
+#   foo = some_method(nested_call(
+#   nested_first_param),
+#   second_param)
+#
+#   foo = some_method(
+#   nested_call(
+#   nested_first_param),
+#   second_param)
+#
+#   some_method nested_call(
+#   nested_first_param),
+#   second_param
+#
+# source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#147
+class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#222
+  def eligible_method_call?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#155
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#155
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#155
+  def on_super(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#281
+  def argument_alignment_config; end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#174
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#178
+  def bare_operator?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#198
+  def base_indentation(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#226
+  def base_range(send_node, arg_node); end
+
+  # Returns the column of the given range. For single line ranges, this
+  # is simple. For ranges with line breaks, we look a the last code line.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#238
+  def column_of(range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#259
+  def comment_lines; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#277
+  def enable_layout_first_method_argument_line_break?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#271
+  def enforce_first_argument_with_fixed_indentation?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#182
+  def message(arg_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#267
+  def on_new_investigation; end
+
+  # Takes the line number of a given code line and returns a string
+  # containing the previous line that's not a comment line or a blank
+  # line.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#250
+  def previous_code_line(line_number); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#170
+  def should_check?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#206
+  def special_inner_call_indentation?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/first_argument_indentation.rb#153
+RuboCop::Cop::Layout::FirstArgumentIndentation::MSG = T.let(T.unsafe(nil), String)
+
+# Checks the indentation of the first element in an array literal
+# where the opening bracket and the first element are on separate lines.
+# The other elements' indentations are handled by `Layout/ArrayAlignment` cop.
+#
+# This cop will respect `Layout/ArrayAlignment` and will not work when
+# `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArrayAlignment`.
+#
+# By default, array literals that are arguments in a method call with
+# parentheses, and where the opening square bracket of the array is on the
+# same line as the opening parenthesis of the method call, shall have
+# their first element indented one step (two spaces) more than the
+# position inside the opening parenthesis.
+#
+# Other array literals shall have their first element indented one step
+# more than the start of the line where the opening square bracket is.
+#
+# This default style is called 'special_inside_parentheses'. Alternative
+# styles are 'consistent' and 'align_brackets'. Here are examples:
+#
+# @example EnforcedStyle: special_inside_parentheses (default)
+#   # The `special_inside_parentheses` style enforces that the first
+#   # element in an array literal where the opening bracket and first
+#   # element are on separate lines is indented one step (two spaces) more
+#   # than the position inside the opening parenthesis.
+#
+#   # bad
+#   array = [
+#   :value
+#   ]
+#   and_in_a_method_call([
+#   :no_difference
+#   ])
+#
+#   # good
+#   array = [
+#   :value
+#   ]
+#   but_in_a_method_call([
+#   :its_like_this
+#   ])
+# @example EnforcedStyle: consistent
+#   # The `consistent` style enforces that the first element in an array
+#   # literal where the opening bracket and the first element are on
+#   # separate lines is indented the same as an array literal which is not
+#   # defined inside a method call.
+#
+#   # bad
+#   array = [
+#   :value
+#   ]
+#   but_in_a_method_call([
+#   :its_like_this
+#   ])
+#
+#   # good
+#   array = [
+#   :value
+#   ]
+#   and_in_a_method_call([
+#   :no_difference
+#   ])
+# @example EnforcedStyle: align_brackets
+#   # The `align_brackets` style enforces that the opening and closing
+#   # brackets are indented to the same position.
+#
+#   # bad
+#   and_now_for_something = [
+#   :completely_different
+#   ]
+#
+#   # good
+#   and_now_for_something = [
+#   :completely_different
+#   ]
+#
+# source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#82
+class RuboCop::Cop::Layout::FirstArrayElementIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::MultilineElementIndentation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#91
+  def on_array(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#97
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#97
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#188
+  def array_alignment_config; end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#108
+  def autocorrect(corrector, node); end
+
+  # Returns the description of what the correct indentation is based on.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#146
+  def base_description(indent_base_type); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#112
+  def brace_alignment_style; end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#116
+  def check(array_node, left_parenthesis); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#130
+  def check_right_bracket(right_bracket, first_elem, left_bracket, left_parenthesis); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#182
+  def enforce_first_argument_with_fixed_indentation?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#159
+  def message(base_description); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#167
+  def message_for_right_bracket(indent_base_type); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/first_array_element_indentation.rb#88
+RuboCop::Cop::Layout::FirstArrayElementIndentation::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for a line break before the first element in a
+# multi-line array.
+#
+# @example
+#
+#   # bad
+#   [ :a,
+#   :b]
+#
+#   # good
+#   [
+#   :a,
+#   :b]
+#
+#   # good
+#   [:a, :b]
+# @example AllowMultilineFinalElement: false (default)
+#
+#   # bad
+#   [ :a, {
+#   :b => :c
+#   }]
+#
+#   # good
+#   [
+#   :a, {
+#   :b => :c
+#   }]
+# @example AllowMultilineFinalElement: true
+#
+#   # good
+#   [:a, {
+#   :b => :c
+#   }]
+#
+# source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#43
+class RuboCop::Cop::Layout::FirstArrayElementLineBreak < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::FirstElementLineBreak
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#49
+  def on_array(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#57
+  def assignment_on_same_line?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#62
+  def ignore_last_element?; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/first_array_element_line_break.rb#47
+RuboCop::Cop::Layout::FirstArrayElementLineBreak::MSG = T.let(T.unsafe(nil), String)
+
+# Checks the indentation of the first key in a hash literal
+# where the opening brace and the first key are on separate lines. The
+# other keys' indentations are handled by the HashAlignment cop.
+#
+# By default, Hash literals that are arguments in a method call with
+# parentheses, and where the opening curly brace of the hash is on the
+# same line as the opening parenthesis of the method call, shall have
+# their first key indented one step (two spaces) more than the position
+# inside the opening parenthesis.
+#
+# Other hash literals shall have their first key indented one step more
+# than the start of the line where the opening curly brace is.
+#
+# This default style is called 'special_inside_parentheses'. Alternative
+# styles are 'consistent' and 'align_braces'. Here are examples:
+#
+# @example EnforcedStyle: special_inside_parentheses (default)
+#   # The `special_inside_parentheses` style enforces that the first key
+#   # in a hash literal where the opening brace and the first key are on
+#   # separate lines is indented one step (two spaces) more than the
+#   # position inside the opening parentheses.
+#
+#   # bad
+#   hash = {
+#   key: :value
+#   }
+#   and_in_a_method_call({
+#   no: :difference
+#   })
+#   takes_multi_pairs_hash(x: {
+#   a: 1,
+#   b: 2
+#   },
+#   y: {
+#   c: 1,
+#   d: 2
+#   })
+#
+#   # good
+#   special_inside_parentheses
+#   hash = {
+#   key: :value
+#   }
+#   but_in_a_method_call({
+#   its_like: :this
+#   })
+#   takes_multi_pairs_hash(x: {
+#   a: 1,
+#   b: 2
+#   },
+#   y: {
+#   c: 1,
+#   d: 2
+#   })
+# @example EnforcedStyle: consistent
+#   # The `consistent` style enforces that the first key in a hash
+#   # literal where the opening brace and the first key are on
+#   # separate lines is indented the same as a hash literal which is not
+#   # defined inside a method call.
+#
+#   # bad
+#   hash = {
+#   key: :value
+#   }
+#   but_in_a_method_call({
+#   its_like: :this
+#   })
+#
+#   # good
+#   hash = {
+#   key: :value
+#   }
+#   and_in_a_method_call({
+#   no: :difference
+#   })
+# @example EnforcedStyle: align_braces
+#   # The `align_brackets` style enforces that the opening and closing
+#   # braces are indented to the same position.
+#
+#   # bad
+#   and_now_for_something = {
+#   completely: :different
+#   }
+#   takes_multi_pairs_hash(x: {
+#   a: 1,
+#   b: 2
+#   },
+#   y: {
+#   c: 1,
+#   d: 2
+#   })
+#
+#   # good
+#   and_now_for_something = {
+#   completely: :different
+#   }
+#   takes_multi_pairs_hash(x: {
+#   a: 1,
+#   b: 2
+#   },
+#   y: {
+#   c: 1,
+#   d: 2
+#   })
+#
+# source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#113
+class RuboCop::Cop::Layout::FirstHashElementIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::MultilineElementIndentation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#126
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#122
+  def on_hash(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#126
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#233
+  def argument_alignment_config; end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#137
+  def autocorrect(corrector, node); end
+
+  # Returns the description of what the correct indentation is based on.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#191
+  def base_description(indent_base_type); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#141
+  def brace_alignment_style; end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#145
+  def check(hash_node, left_parenthesis); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#184
+  def check_based_on_longest_key(hash_node, left_brace, left_parenthesis); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#164
+  def check_right_brace(right_brace, first_pair, left_brace, left_parenthesis); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#227
+  def enforce_first_argument_with_fixed_indentation?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#204
+  def message(base_description); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#212
+  def message_for_right_brace(indent_base_type); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#178
+  def separator_style?(first_pair); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/first_hash_element_indentation.rb#119
+RuboCop::Cop::Layout::FirstHashElementIndentation::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for a line break before the first element in a
+# multi-line hash.
+#
+# @example
+#
+#   # bad
+#   { a: 1,
+#   b: 2}
+#
+#   # good
+#   {
+#   a: 1,
+#   b: 2 }
+#
+#   # good
+#   {
+#   a: 1, b: {
+#   c: 3
+#   }}
+# @example AllowMultilineFinalElement: false (default)
+#
+#   # bad
+#   { a: 1, b: {
+#   c: 3
+#   }}
+# @example AllowMultilineFinalElement: true
+#
+#   # bad
+#   { a: 1,
+#   b: {
+#   c: 3
+#   }}
+#
+#   # good
+#   { a: 1, b: {
+#   c: 3
+#   }}
+#
+# source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#46
+class RuboCop::Cop::Layout::FirstHashElementLineBreak < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::FirstElementLineBreak
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#52
+  def on_hash(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#62
+  def ignore_last_element?; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/first_hash_element_line_break.rb#50
+RuboCop::Cop::Layout::FirstHashElementLineBreak::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for a line break before the first argument in a
+# multi-line method call.
+#
+# @example
+#
+#   # bad
+#   method(foo, bar,
+#   baz)
+#
+#   # good
+#   method(
+#   foo, bar,
+#   baz)
+#
+#   # ignored
+#   method foo, bar,
+#   baz
+# @example AllowMultilineFinalElement: false (default)
+#
+#   # bad
+#   method(foo, bar, {
+#   baz: "a",
+#   qux: "b",
+#   })
+#
+#   # good
+#   method(
+#   foo, bar, {
+#   baz: "a",
+#   qux: "b",
+#   })
+# @example AllowMultilineFinalElement: true
+#
+#   # bad
+#   method(foo,
+#   bar,
+#   {
+#   baz: "a",
+#   qux: "b",
+#   }
+#   )
+#
+#   # good
+#   method(foo, bar, {
+#   baz: "a",
+#   qux: "b",
+#   })
+#
+#   # good
+#   method(
+#   foo,
+#   bar,
+#   {
+#   baz: "a",
+#   qux: "b",
+#   }
+#   )
+# @example AllowedMethods: ['some_method']
+#
+#   # good
+#   some_method(foo, bar,
+#   baz)
+#
+# source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#71
+class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::FirstElementLineBreak
+  include ::RuboCop::Cop::AllowedMethods
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#78
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#78
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#78
+  def on_super(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#99
+  def ignore_last_element?; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/first_method_argument_line_break.rb#76
+RuboCop::Cop::Layout::FirstMethodArgumentLineBreak::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for a line break before the first parameter in a
+# multi-line method parameter definition.
+#
+# @example
+#
+#   # bad
+#   def method(foo, bar,
+#   baz)
+#   do_something
+#   end
+#
+#   # good
+#   def method(
+#   foo, bar,
+#   baz)
+#   do_something
+#   end
+#
+#   # ignored
+#   def method foo,
+#   bar
+#   do_something
+#   end
+# @example AllowMultilineFinalElement: false (default)
+#
+#   # bad
+#   def method(foo, bar, baz = {
+#   :a => "b",
+#   })
+#   do_something
+#   end
+#
+#   # good
+#   def method(
+#   foo, bar, baz = {
+#   :a => "b",
+#   })
+#   do_something
+#   end
+# @example AllowMultilineFinalElement: true
+#
+#   # good
+#   def method(foo, bar, baz = {
+#   :a => "b",
+#   })
+#   do_something
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#56
+class RuboCop::Cop::Layout::FirstMethodParameterLineBreak < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::FirstElementLineBreak
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#62
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#62
+  def on_defs(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#69
+  def ignore_last_element?; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/first_method_parameter_line_break.rb#60
+RuboCop::Cop::Layout::FirstMethodParameterLineBreak::MSG = T.let(T.unsafe(nil), String)
+
+# Checks the indentation of the first parameter in a method
+# definition. Parameters after the first one are checked by
+# Layout/ParameterAlignment, not by this cop.
+#
+# For indenting the first argument of method _calls_, check out
+# Layout/FirstArgumentIndentation, which supports options related to
+# nesting that are irrelevant for method _definitions_.
+#
+# @example
+#
+#   # bad
+#   def some_method(
+#   first_param,
+#   second_param)
+#   123
+#   end
+# @example EnforcedStyle: consistent (default)
+#   # The first parameter should always be indented one step more than the
+#   # preceding line.
+#
+#   # good
+#   def some_method(
+#   first_param,
+#   second_param)
+#   123
+#   end
+# @example EnforcedStyle: align_parentheses
+#   # The first parameter should always be indented one step more than the
+#   # opening parenthesis.
+#
+#   # good
+#   def some_method(
+#   first_param,
+#   second_param)
+#   123
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#44
+class RuboCop::Cop::Layout::FirstParameterIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::MultilineElementIndentation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#53
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#53
+  def on_defs(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#63
+  def autocorrect(corrector, node); end
+
+  # Returns the description of what the correct indentation is based on.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#83
+  def base_description(_); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#67
+  def brace_alignment_style; end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#71
+  def check(def_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#91
+  def message(base_description); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/first_parameter_indentation.rb#50
+RuboCop::Cop::Layout::FirstParameterIndentation::MSG = T.let(T.unsafe(nil), String)
+
+# Check that the keys, separators, and values of a multi-line hash
+# literal are aligned according to configuration. The configuration
+# options are:
+#
+# * key (left align keys, one space before hash rockets and values)
+# * separator (align hash rockets and colons, right align keys)
+# * table (left align keys, hash rockets, and values)
+#
+# The treatment of hashes passed as the last argument to a method call
+# can also be configured. The options are:
+#
+# * always_inspect
+# * always_ignore
+# * ignore_implicit (without curly braces)
+#
+# Alternatively you can specify multiple allowed styles. That's done by
+# passing a list of styles to EnforcedStyles.
+#
+# @example EnforcedLastArgumentHashStyle: ignore_explicit
+#   # Ignore only explicit hashes.
+#
+#   # bad
+#   do_something(foo: 1,
+#   bar: 2)
+#
+#   # good
+#   do_something({foo: 1,
+#   bar: 2})
+# @example EnforcedHashRocketStyle: separator
+#   # bad
+#   {
+#   :foo => bar,
+#   :ba => baz
+#   }
+#   {
+#   :foo => bar,
+#   :ba  => baz
+#   }
+#
+#   # good
+#   {
+#   :foo => bar,
+#   :ba => baz
+#   }
+# @example EnforcedHashRocketStyle: table
+#   # bad
+#   {
+#   :foo => bar,
+#   :ba => baz
+#   }
+#
+#   # good
+#   {
+#   :foo => bar,
+#   :ba  => baz
+#   }
+# @example EnforcedColonStyle: key (default)
+#   # bad
+#   {
+#   foo: bar,
+#   ba: baz
+#   }
+#   {
+#   foo: bar,
+#   ba:  baz
+#   }
+#
+#   # good
+#   {
+#   foo: bar,
+#   ba: baz
+#   }
+# @example EnforcedColonStyle: separator
+#   # bad
+#   {
+#   foo: bar,
+#   ba: baz
+#   }
+#
+#   # good
+#   {
+#   foo: bar,
+#   ba: baz
+#   }
+# @example EnforcedColonStyle: table
+#   # bad
+#   {
+#   foo: bar,
+#   ba: baz
+#   }
+#
+#   # good
+#   {
+#   foo: bar,
+#   ba:  baz
+#   }
+# @example EnforcedLastArgumentHashStyle: always_inspect (default)
+#   # Inspect both implicit and explicit hashes.
+#
+#   # bad
+#   do_something(foo: 1,
+#   bar: 2)
+#
+#   # bad
+#   do_something({foo: 1,
+#   bar: 2})
+#
+#   # good
+#   do_something(foo: 1,
+#   bar: 2)
+#
+#   # good
+#   do_something(
+#   foo: 1,
+#   bar: 2
+#   )
+#
+#   # good
+#   do_something({foo: 1,
+#   bar: 2})
+#
+#   # good
+#   do_something({
+#   foo: 1,
+#   bar: 2
+#   })
+# @example EnforcedLastArgumentHashStyle: always_ignore
+#   # Ignore both implicit and explicit hashes.
+#
+#   # good
+#   do_something(foo: 1,
+#   bar: 2)
+#
+#   # good
+#   do_something({foo: 1,
+#   bar: 2})
+# @example EnforcedLastArgumentHashStyle: ignore_implicit
+#   # Ignore only implicit hashes.
+#
+#   # bad
+#   do_something({foo: 1,
+#   bar: 2})
+#
+#   # good
+#   do_something(foo: 1,
+#   bar: 2)
+# @example EnforcedHashRocketStyle: key (default)
+#   # bad
+#   {
+#   :foo => bar,
+#   :ba => baz
+#   }
+#   {
+#   :foo => bar,
+#   :ba  => baz
+#   }
+#
+#   # good
+#   {
+#   :foo => bar,
+#   :ba => baz
+#   }
+#
+# source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#178
+class RuboCop::Cop::Layout::HashAlignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::HashAlignmentStyles
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # Returns the value of attribute column_deltas.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#218
+  def column_deltas; end
+
+  # Sets the attribute column_deltas
+  #
+  # @param value the value to set the attribute column_deltas to.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#218
+  def column_deltas=(_arg0); end
+
+  # Returns the value of attribute offenses_by.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#218
+  def offenses_by; end
+
+  # Sets the attribute offenses_by
+  #
+  # @param value the value to set the attribute offenses_by to.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#218
+  def offenses_by=(_arg0); end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#208
+  def on_hash(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#195
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#195
+  def on_super(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#195
+  def on_yield(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#265
+  def add_offenses; end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#371
+  def adjust(corrector, delta, range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#300
+  def alignment_for(pair); end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#314
+  def alignment_for_colons; end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#310
+  def alignment_for_hash_rockets; end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#390
+  def argument_alignment_config; end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#233
+  def argument_before_hash(hash_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#222
+  def autocorrect_incompatible_with_other_cops?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#283
+  def check_delta(delta, node:, alignment:); end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#246
+  def check_pairs(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#337
+  def correct_key_value(corrector, delta, key, value, separator); end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#333
+  def correct_no_value(corrector, key_delta, key); end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#318
+  def correct_node(corrector, node, delta); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#242
+  def double_splat?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#384
+  def enforce_first_argument_with_fixed_indentation?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#380
+  def good_alignment?(column_deltas); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#291
+  def ignore_hash_argument?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#353
+  def new_alignment(key); end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#273
+  def register_offenses_with_format(offenses, format); end
+
+  # source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#237
+  def reset!; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#183
+RuboCop::Cop::Layout::HashAlignment::MESSAGES = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/layout/hash_alignment.rb#193
+RuboCop::Cop::Layout::HashAlignment::SEPARATOR_ALIGNMENT_STYLES = T.let(T.unsafe(nil), Array)
+
+# Checks for the placement of the closing parenthesis
+# in a method call that passes a HEREDOC string as an argument.
+# It should be placed at the end of the line containing the
+# opening HEREDOC tag.
+#
+# @example
+#   # bad
+#
+#   foo(<<-SQL
+#   bar
+#   SQL
+#   )
+#
+#   foo(<<-SQL, 123, <<-NOSQL,
+#   bar
+#   SQL
+#   baz
+#   NOSQL
+#   )
+#
+#   foo(
+#   bar(<<-SQL
+#   baz
+#   SQL
+#   ),
+#   123,
+#   )
+#
+#   # good
+#
+#   foo(<<-SQL)
+#   bar
+#   SQL
+#
+#   foo(<<-SQL, 123, <<-NOSQL)
+#   bar
+#   SQL
+#   baz
+#   NOSQL
+#
+#   foo(
+#   bar(<<-SQL),
+#   baz
+#   SQL
+#   123,
+#   )
+#
+# source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#53
+class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#64
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#184
+  def add_correct_closing_paren(node, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#271
+  def add_correct_external_trailing_comma(node, corrector); end
+
+  # Autocorrection note:
+  #
+  # Commas are a bit tricky to handle when the method call is
+  # embedded in another expression. Here's an example:
+  #
+  # [
+  #   first_array_value,
+  #   foo(<<-SQL, 123, 456,
+  #     SELECT * FROM db
+  #   SQL
+  #   ),
+  #   third_array_value,
+  # ]
+  #
+  # The "internal" trailing comma is after `456`.
+  # The "external" trailing comma is after `)`.
+  #
+  # To autocorrect, we remove the latter, and move the former up:
+  #
+  # [
+  #   first_array_value,
+  #   foo(<<-SQL, 123, 456),
+  #     SELECT * FROM db
+  #   SQL
+  #   third_array_value,
+  # ]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#107
+  def autocorrect(corrector, node); end
+
+  # Closing parenthesis helpers.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#162
+  def end_keyword_before_closing_parenthesis?(parenthesized_send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#222
+  def exist_argument_between_heredoc_end_and_closing_parentheses?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#289
+  def external_trailing_comma?(node); end
+
+  # Returns nil if no trailing external comma.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#294
+  def external_trailing_comma_offset_from_loc_end(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#137
+  def extract_heredoc(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#133
+  def extract_heredoc_argument(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#230
+  def find_most_bottom_of_heredoc_end(arguments); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#179
+  def fix_closing_parenthesis(node, corrector); end
+
+  # External trailing comma helpers.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#266
+  def fix_external_trailing_comma(node, corrector); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#149
+  def heredoc_node?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#197
+  def incorrect_parenthesis_removal_begin(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#213
+  def incorrect_parenthesis_removal_end(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#244
+  def internal_trailing_comma?(node); end
+
+  # Returns nil if no trailing internal comma.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#249
+  def internal_trailing_comma_offset_from_last_arg(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#115
+  def outermost_send_on_same_line(heredoc); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#188
+  def remove_incorrect_closing_paren(node, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#277
+  def remove_incorrect_external_trailing_comma(node, corrector); end
+
+  # Internal trailing comma helpers.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#238
+  def remove_internal_trailing_comma(node, corrector); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#207
+  def safe_to_remove_line_containing_closing_paren?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#126
+  def send_missing_closing_parens?(parent, child, heredoc); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#153
+  def single_line_send_with_heredoc_receiver?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#305
+  def space?(pos); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#168
+  def subsequent_closing_parentheses_in_same_line?(outermost_send); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#60
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb#57
+RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis::MSG = T.let(T.unsafe(nil), String)
+
+# Checks the indentation of the here document bodies. The bodies
+# are indented one step.
+#
+# NOTE: When ``Layout/LineLength``'s `AllowHeredoc` is false (not default),
+#       this cop does not add any offenses for long here documents to
+#       avoid ``Layout/LineLength``'s offenses.
+#
+# @example
+#   # bad
+#   <<-RUBY
+#   something
+#   RUBY
+#
+#   # good
+#   <<~RUBY
+#   something
+#   RUBY
+#
+# source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#24
+class RuboCop::Cop::Layout::HeredocIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::Heredoc
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#36
+  def on_heredoc(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#120
+  def adjust_minus(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#115
+  def adjust_squiggly(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#144
+  def base_indent_level(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#155
+  def heredoc_body(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#159
+  def heredoc_end(node); end
+
+  # Returns '~', '-' or nil
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#151
+  def heredoc_indent_type(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#126
+  def indented_body(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#133
+  def indented_end(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#91
+  def line_too_long?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#103
+  def longest_line(lines); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#111
+  def max_line_length; end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#69
+  def message(heredoc_indent_type); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#57
+  def register_offense(node, heredoc_indent_type); end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#79
+  def type_message(indentation_width, current_indent_type); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#107
+  def unlimited_heredoc_length?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#87
+  def width_message(indentation_width); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#32
+RuboCop::Cop::Layout::HeredocIndentation::TYPE_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/heredoc_indentation.rb#34
+RuboCop::Cop::Layout::HeredocIndentation::WIDTH_MSG = T.let(T.unsafe(nil), String)
+
+# Checks for inconsistent indentation.
+#
+# The difference between `indented_internal_methods` and `normal` is
+# that the `indented_internal_methods` style prescribes that in
+# classes and modules the `protected` and `private` modifier keywords
+# shall be indented the same as public methods and that protected and
+# private members shall be indented one step more than the modifiers.
+# Other than that, both styles mean that entities on the same logical
+# depth shall have the same indentation.
+#
+# @example EnforcedStyle: normal (default)
+#   # bad
+#   class A
+#   def test
+#   puts 'hello'
+#   puts 'world'
+#   end
+#   end
+#
+#   # bad
+#   class A
+#   def test
+#   puts 'hello'
+#   puts 'world'
+#   end
+#
+#   protected
+#
+#   def foo
+#   end
+#
+#   private
+#
+#   def bar
+#   end
+#   end
+#
+#   # good
+#   class A
+#   def test
+#   puts 'hello'
+#   puts 'world'
+#   end
+#   end
+#
+#   # good
+#   class A
+#   def test
+#   puts 'hello'
+#   puts 'world'
+#   end
+#
+#   protected
+#
+#   def foo
+#   end
+#
+#   private
+#
+#   def bar
+#   end
+#   end
+# @example EnforcedStyle: indented_internal_methods
+#   # bad
+#   class A
+#   def test
+#   puts 'hello'
+#   puts 'world'
+#   end
+#   end
+#
+#   # bad
+#   class A
+#   def test
+#   puts 'hello'
+#   puts 'world'
+#   end
+#
+#   protected
+#
+#   def foo
+#   end
+#
+#   private
+#
+#   def bar
+#   end
+#   end
+#
+#   # good
+#   class A
+#   def test
+#   puts 'hello'
+#   puts 'world'
+#   end
+#   end
+#
+#   # good
+#   class A
+#   def test
+#   puts 'hello'
+#   puts 'world'
+#   end
+#
+#   protected
+#
+#   def foo
+#   end
+#
+#   private
+#
+#   def bar
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#121
+class RuboCop::Cop::Layout::IndentationConsistency < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#128
+  def on_begin(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#132
+  def on_kwbegin(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#138
+  def autocorrect(corrector, node); end
+
+  # Not all nodes define `bare_access_modifier?` (for example,
+  # `RuboCop::AST::DefNode` does not), so we must check `send_type?` first
+  # to avoid a NoMethodError.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#145
+  def bare_access_modifier?(node); end
+
+  # Returns an integer representing the correct indentation, or nil to
+  # indicate that the correct indentation is that of the first child that
+  # is not an access modifier.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#152
+  def base_column_for_normal_style(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#172
+  def check(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#187
+  def check_indented_internal_methods_style(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#180
+  def check_normal_style(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/indentation_consistency.rb#126
+RuboCop::Cop::Layout::IndentationConsistency::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that the indentation method is consistent.
+# Either tabs only or spaces only are used for indentation.
+#
+# @example EnforcedStyle: spaces (default)
+#   # bad
+#   # This example uses a tab to indent bar.
+#   def foo
+#   bar
+#   end
+#
+#   # good
+#   # This example uses spaces to indent bar.
+#   def foo
+#   bar
+#   end
+# @example EnforcedStyle: tabs
+#   # bad
+#   # This example uses spaces to indent bar.
+#   def foo
+#   bar
+#   end
+#
+#   # good
+#   # This example uses a tab to indent bar.
+#   def foo
+#   bar
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#34
+class RuboCop::Cop::Layout::IndentationStyle < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#42
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#58
+  def autocorrect(corrector, range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#82
+  def autocorrect_lambda_for_spaces(corrector, range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#77
+  def autocorrect_lambda_for_tabs(corrector, range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#66
+  def find_offense(line, lineno); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#88
+  def in_string_literal?(ranges, tabs_range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#109
+  def message(_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#92
+  def string_literal_ranges(ast); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/indentation_style.rb#40
+RuboCop::Cop::Layout::IndentationStyle::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for indentation that doesn't use the specified number of spaces.
+# The indentation width can be configured using the `Width` setting. The default width is 2.
+#
+# See also the `Layout/IndentationConsistency` cop which is the companion to this one.
+#
+# @example Width: 2 (default)
+#   # bad
+#   class A
+#   def test
+#   puts 'hello'
+#   end
+#   end
+#
+#   # good
+#   class A
+#   def test
+#   puts 'hello'
+#   end
+#   end
+# @example AllowedPatterns: ['^\s*module']
+#   # bad
+#   module A
+#   class B
+#   def test
+#   puts 'hello'
+#   end
+#   end
+#   end
+#
+#   # good
+#   module A
+#   class B
+#   def test
+#   puts 'hello'
+#   end
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#44
+class RuboCop::Cop::Layout::IndentationWidth < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::EndKeywordAlignment
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::CheckAssignment
+  include ::RuboCop::Cop::AllowedPattern
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#56
+  def access_modifier?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#80
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#137
+  def on_case(case_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#145
+  def on_case_match(case_match); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#94
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#103
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#120
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#120
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#65
+  def on_ensure(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#65
+  def on_for(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#155
+  def on_if(node, base = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#72
+  def on_kwbegin(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#94
+  def on_module(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#80
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#65
+  def on_resbody(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#60
+  def on_rescue(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#94
+  def on_sclass(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#103
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#127
+  def on_until(node, base = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#127
+  def on_while(node, base = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#226
+  def access_modifier_indentation_style; end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#164
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#234
+  def check_assignment(node, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#254
+  def check_if(node, body, else_clause, base_loc); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#267
+  def check_indentation(base_loc, body_node, style = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#168
+  def check_members(base, members); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#192
+  def check_members_for_indented_internal_methods_style(members); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#198
+  def check_members_for_normal_style(base, members); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#340
+  def check_rescue?(rescue_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#376
+  def configured_indentation_width; end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#206
+  def each_member(members); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#230
+  def indentation_consistency_style; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#322
+  def indentation_to_check?(base_loc, body_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#218
+  def indented_internal_methods_style?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#380
+  def leftmost_modifier_of(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#301
+  def message(configured_indentation_width, indentation, name); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#359
+  def offending_range(body_node, indentation); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#277
+  def offense(body_node, indentation, style); end
+
+  # Returns true if the given node is within another node that has
+  # already been marked for autocorrection by this cop.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#312
+  def other_offense_in_same_range?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#180
+  def select_check_member(member); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#344
+  def skip_check?(base_loc, body_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#222
+  def special_modifier?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#367
+  def starts_with_access_modifier?(body_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/indentation_width.rb#52
+RuboCop::Cop::Layout::IndentationWidth::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for indentation of the first non-blank non-comment
+# line in a file.
+#
+# @example
+#   # bad
+#   class A
+#   def foo; end
+#   end
+#
+#   # good
+#   class A
+#   def foo; end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/initial_indentation.rb#20
+class RuboCop::Cop::Layout::InitialIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/initial_indentation.rb#26
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/initial_indentation.rb#36
+  def first_token; end
+
+  # @yield [range_between(space_range.begin_pos, token.begin_pos)]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/initial_indentation.rb#40
+  def space_before(token); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/initial_indentation.rb#24
+RuboCop::Cop::Layout::InitialIndentation::MSG = T.let(T.unsafe(nil), String)
+
+# Checks whether comments have a leading space after the
+# `#` denoting the start of the comment. The leading space is not
+# required for some RDoc special syntax, like `#++`, `#--`,
+# `#:nodoc`, `=begin`- and `=end` comments, "shebang" directives,
+# or rackup options.
+#
+# @example
+#
+#   # bad
+#   #Some comment
+#
+#   # good
+#   # Some comment
+# @example AllowDoxygenCommentStyle: false (default)
+#
+#   # bad
+#
+#   #**
+#   # Some comment
+#   # Another line of comment
+#   #*
+# @example AllowDoxygenCommentStyle: true
+#
+#   # good
+#
+#   #**
+#   # Some comment
+#   # Another line of comment
+#   #*
+# @example AllowGemfileRubyComment: false (default)
+#
+#   # bad
+#
+#   #ruby=2.7.0
+#   #ruby-gemset=myproject
+# @example AllowGemfileRubyComment: true
+#
+#   # good
+#
+#   #ruby=2.7.0
+#   #ruby-gemset=myproject
+# @example AllowRBSInlineAnnotation: false (default)
+#
+#   # bad
+#
+#   include Enumerable #[Integer]
+#
+#   attr_reader :name #: String
+#   attr_reader :age  #: Integer?
+# @example AllowRBSInlineAnnotation: true
+#
+#   # good
+#
+#   include Enumerable #[Integer]
+#
+#   attr_reader :name #: String
+#   attr_reader :age  #: Integer?
+#
+# source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#70
+class RuboCop::Cop::Layout::LeadingCommentSpace < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#76
+  def on_new_investigation; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#114
+  def allow_doxygen_comment?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#122
+  def allow_gemfile_ruby_comment?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#138
+  def allow_rbs_inline_annotation?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#98
+  def allowed_on_first_line?(comment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#118
+  def doxygen_comment_style?(comment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#126
+  def gemfile?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#134
+  def gemfile_ruby_comment?(comment); end
+
+  # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#94
+  def hash_mark(expr); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#110
+  def rackup_config_file?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#106
+  def rackup_options?(comment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#142
+  def rbs_inline_annotation?(comment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#130
+  def ruby_comment_in_gemfile?(comment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#102
+  def shebang?(comment); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/leading_comment_space.rb#74
+RuboCop::Cop::Layout::LeadingCommentSpace::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for unnecessary leading blank lines at the beginning
+# of a file.
+#
+# @example
+#
+#   # bad
+#   # (start of file)
+#
+#   class Foo
+#   end
+#
+#   # bad
+#   # (start of file)
+#
+#   # a comment
+#
+#   # good
+#   # (start of file)
+#   class Foo
+#   end
+#
+#   # good
+#   # (start of file)
+#   # a comment
+#
+# source://rubocop//lib/rubocop/cop/layout/leading_empty_lines.rb#30
+class RuboCop::Cop::Layout::LeadingEmptyLines < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/leading_empty_lines.rb#35
+  def on_new_investigation; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/leading_empty_lines.rb#33
+RuboCop::Cop::Layout::LeadingEmptyLines::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that strings broken over multiple lines (by a backslash) contain
+# trailing spaces instead of leading spaces (default) or leading spaces
+# instead of trailing spaces.
+#
+# @example EnforcedStyle: trailing (default)
+#   # bad
+#   'this text contains a lot of' \
+#   '               spaces'
+#
+#   # good
+#   'this text contains a lot of               ' \
+#   'spaces'
+#
+#   # bad
+#   'this text is too' \
+#   ' long'
+#
+#   # good
+#   'this text is too ' \
+#   'long'
+# @example EnforcedStyle: leading
+#   # bad
+#   'this text contains a lot of               ' \
+#   'spaces'
+#
+#   # good
+#   'this text contains a lot of' \
+#   '               spaces'
+#
+#   # bad
+#   'this text is too ' \
+#   'long'
+#
+#   # good
+#   'this text is too' \
+#   ' long'
+#
+# source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#43
+class RuboCop::Cop::Layout::LineContinuationLeadingSpace < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#54
+  def on_dstr(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#113
+  def autocorrect(corrector, offense_range, insert_pos, spaces); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#106
+  def continuation?(line, line_num, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#138
+  def enforced_style_leading?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#76
+  def investigate(first_line, second_line, end_of_first_line); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#84
+  def investigate_leading_style(first_line, second_line, end_of_first_line); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#95
+  def investigate_trailing_style(first_line, second_line, end_of_first_line); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#118
+  def leading_offense_range(end_of_first_line, matches); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#130
+  def message(_range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#72
+  def raw_lines(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#124
+  def trailing_offense_range(end_of_first_line, matches); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#49
+RuboCop::Cop::Layout::LineContinuationLeadingSpace::LEADING_STYLE_OFFENSE = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#47
+RuboCop::Cop::Layout::LineContinuationLeadingSpace::LINE_1_ENDING = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#48
+RuboCop::Cop::Layout::LineContinuationLeadingSpace::LINE_2_BEGINNING = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/layout/line_continuation_leading_space.rb#50
+RuboCop::Cop::Layout::LineContinuationLeadingSpace::TRAILING_STYLE_OFFENSE = T.let(T.unsafe(nil), Regexp)
+
+# Checks that the backslash of a line continuation is separated from
+# preceding text by exactly one space (default) or zero spaces.
+#
+# @example EnforcedStyle: space (default)
+#   # bad
+#   'a'\
+#   'b'  \
+#   'c'
+#
+#   # good
+#   'a' \
+#   'b' \
+#   'c'
+# @example EnforcedStyle: no_space
+#   # bad
+#   'a' \
+#   'b'  \
+#   'c'
+#
+#   # good
+#   'a'\
+#   'b'\
+#   'c'
+#
+# source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#30
+class RuboCop::Cop::Layout::LineContinuationSpacing < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#34
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#81
+  def autocorrect(corrector, range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#111
+  def comment_ranges(comments); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#65
+  def find_offensive_spacing(line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#121
+  def ignore_range?(backtick_range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#91
+  def ignored_literal_ranges(ast); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#125
+  def ignored_ranges; end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#49
+  def investigate(line, line_number); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#115
+  def last_line(processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#73
+  def message(_range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#130
+  def no_space_style?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/line_continuation_spacing.rb#134
+  def space_style?; end
+end
+
+# Checks the indentation of the next line after a line that ends with a string
+# literal and a backslash.
+#
+# If `EnforcedStyle: aligned` is set, the concatenated string parts shall be aligned with the
+# first part. There are some exceptions, such as implicit return values, where the
+# concatenated string parts shall be indented regardless of `EnforcedStyle` configuration.
+#
+# If `EnforcedStyle: indented` is set, it's the second line that shall be indented one step
+# more than the first line. Lines 3 and forward shall be aligned with line 2.
+#
+# @example
+#   # bad
+#   def some_method
+#   'x' \
+#   'y' \
+#   'z'
+#   end
+#
+#   my_hash = {
+#   first: 'a message' \
+#   'in two parts'
+#   }
+#
+#   # good
+#   def some_method
+#   'x' \
+#   'y' \
+#   'z'
+#   end
+# @example EnforcedStyle: aligned (default)
+#   # bad
+#   puts 'x' \
+#   'y'
+#
+#   my_hash = {
+#   first: 'a message' \
+#   'in two parts'
+#   }
+#
+#   # good
+#   puts 'x' \
+#   'y'
+#
+#   my_hash = {
+#   first: 'a message' \
+#   'in two parts'
+#   }
+# @example EnforcedStyle: indented
+#   # bad
+#   result = 'x' \
+#   'y'
+#
+#   my_hash = {
+#   first: 'a message' \
+#   'in two parts'
+#   }
+#
+#   # good
+#   result = 'x' \
+#   'y'
+#
+#   my_hash = {
+#   first: 'a message' \
+#   'in two parts'
+#   }
+#
+# source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#74
+class RuboCop::Cop::Layout::LineEndStringConcatenationIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::Alignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#97
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#83
+  def on_dstr(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#137
+  def add_offense_and_correction(node, message); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#109
+  def always_indented?(dstr_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#128
+  def base_column(child); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#113
+  def check_aligned(children, start_index); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#122
+  def check_indented(children); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#103
+  def strings_concatenated_with_backslash?(dstr_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#79
+RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::MSG_ALIGN = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#80
+RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::MSG_INDENT = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb#81
+RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::PARENT_TYPES_FOR_INDENTED = T.let(T.unsafe(nil), Array)
+
+# Checks the length of lines in the source code.
+# The maximum length is configurable.
+# The tab size is configured in the `IndentationWidth`
+# of the `Layout/IndentationStyle` cop.
+# It also ignores a shebang line by default.
+#
+# This cop has some autocorrection capabilities.
+# It can programmatically shorten certain long lines by
+# inserting line breaks into expressions that can be safely
+# split across lines. These include arrays, hashes, and
+# method calls with argument lists.
+#
+# If autocorrection is enabled, the following cops
+# are recommended to further format the broken lines.
+# (Many of these are enabled by default.)
+#
+# * `Layout/ArgumentAlignment`
+# * `Layout/ArrayAlignment`
+# * `Layout/BlockAlignment`
+# * `Layout/BlockEndNewline`
+# * `Layout/ClosingParenthesisIndentation`
+# * `Layout/FirstArgumentIndentation`
+# * `Layout/FirstArrayElementIndentation`
+# * `Layout/FirstHashElementIndentation`
+# * `Layout/FirstParameterIndentation`
+# * `Layout/HashAlignment`
+# * `Layout/IndentationWidth`
+# * `Layout/MultilineArrayLineBreaks`
+# * `Layout/MultilineBlockLayout`
+# * `Layout/MultilineHashBraceLayout`
+# * `Layout/MultilineHashKeyLineBreaks`
+# * `Layout/MultilineMethodArgumentLineBreaks`
+# * `Layout/MultilineMethodParameterLineBreaks`
+# * `Layout//ParameterAlignment`
+# * `Style/BlockDelimiters`
+#
+# Together, these cops will pretty print hashes, arrays,
+# method calls, etc. For example, let's say the max columns
+# is 25:
+#
+# @example
+#
+#   # bad
+#   {foo: "0000000000", bar: "0000000000", baz: "0000000000"}
+#
+#   # good
+#   {foo: "0000000000",
+#   bar: "0000000000", baz: "0000000000"}
+#
+#   # good (with recommended cops enabled)
+#   {
+#   foo: "0000000000",
+#   bar: "0000000000",
+#   baz: "0000000000",
+#   }
+#
+# source://rubocop//lib/rubocop/cop/layout/line_length.rb#63
+class RuboCop::Cop::Layout::LineLength < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CheckLineBreakable
+  include ::RuboCop::Cop::AllowedPattern
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::LineLengthHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11
+  def max=(value); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#80
+  def on_array(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#74
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#80
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#80
+  def on_hash(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#94
+  def on_investigation_end; end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#88
+  def on_new_investigation; end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#74
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#80
+  def on_potential_breakable_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#80
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#219
+  def allow_heredoc?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#223
+  def allowed_heredoc; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#183
+  def allowed_line?(line, line_index); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#135
+  def breakable_block_range(block_node); end
+
+  # Returns the value of attribute breakable_range.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#102
+  def breakable_range; end
+
+  # Sets the attribute breakable_range
+  #
+  # @param value the value to set the attribute breakable_range to.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#102
+  def breakable_range=(_arg0); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#143
+  def breakable_range_after_semicolon(semicolon_token); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#156
+  def breakable_range_by_line_index; end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#250
+  def check_directive_line(line, line_index); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#125
+  def check_for_breakable_block(block_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#104
+  def check_for_breakable_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#117
+  def check_for_breakable_semicolons(processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#171
+  def check_line(line, line_index); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#267
+  def check_uri_line(line, line_index); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#204
+  def excess_range(uri_range, line, line_index); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#227
+  def extract_heredocs(ast); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#160
+  def heredocs; end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#164
+  def highlight_start(line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#246
+  def line_in_heredoc?(line_number); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#237
+  def line_in_permitted_heredoc?(line_number); end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#215
+  def max; end
+
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#193
+  def register_offense(loc, line, line_index, length: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/line_length.rb#189
+  def shebang?(line, line_index); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/line_length.rb#72
+RuboCop::Cop::Layout::LineLength::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that the closing brace in an array literal is either
+# on the same line as the last array element or on a new line.
+#
+# When using the `symmetrical` (default) style:
+#
+# If an array's opening brace is on the same line as the first element
+# of the array, then the closing brace should be on the same line as
+# the last element of the array.
+#
+# If an array's opening brace is on the line above the first element
+# of the array, then the closing brace should be on the line below
+# the last element of the array.
+#
+# When using the `new_line` style:
+#
+# The closing brace of a multi-line array literal must be on the line
+# after the last element of the array.
+#
+# When using the `same_line` style:
+#
+# The closing brace of a multi-line array literal must be on the same
+# line as the last element of the array.
+#
+# @example EnforcedStyle: symmetrical (default)
+#   # bad
+#   [ :a,
+#   :b
+#   ]
+#
+#   # bad
+#   [
+#   :a,
+#   :b ]
+#
+#   # good
+#   [ :a,
+#   :b ]
+#
+#   # good
+#   [
+#   :a,
+#   :b
+#   ]
+# @example EnforcedStyle: new_line
+#   # bad
+#   [
+#   :a,
+#   :b ]
+#
+#   # bad
+#   [ :a,
+#   :b ]
+#
+#   # good
+#   [ :a,
+#   :b
+#   ]
+#
+#   # good
+#   [
+#   :a,
+#   :b
+#   ]
+# @example EnforcedStyle: same_line
+#   # bad
+#   [ :a,
+#   :b
+#   ]
+#
+#   # bad
+#   [
+#   :a,
+#   :b
+#   ]
+#
+#   # good
+#   [
+#   :a,
+#   :b ]
+#
+#   # good
+#   [ :a,
+#   :b ]
+#
+# source://rubocop//lib/rubocop/cop/layout/multiline_array_brace_layout.rb#91
+class RuboCop::Cop::Layout::MultilineArrayBraceLayout < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::MultilineLiteralBraceLayout
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_array_brace_layout.rb#109
+  def on_array(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_array_brace_layout.rb#103
+RuboCop::Cop::Layout::MultilineArrayBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_array_brace_layout.rb#106
+RuboCop::Cop::Layout::MultilineArrayBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_array_brace_layout.rb#99
+RuboCop::Cop::Layout::MultilineArrayBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_array_brace_layout.rb#95
+RuboCop::Cop::Layout::MultilineArrayBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# Ensures that each item in a multi-line array
+# starts on a separate line.
+#
+# @example
+#
+#   # bad
+#   [
+#   a, b,
+#   c
+#   ]
+#
+#   # good
+#   [
+#   a,
+#   b,
+#   c
+#   ]
+#
+#   # good
+#   [
+#   a,
+#   b,
+#   foo(
+#   bar
+#   )
+#   ]
+# @example AllowMultilineFinalElement: false (default)
+#
+#   # bad
+#   [a, b, foo(
+#   bar
+#   )]
+# @example AllowMultilineFinalElement: true
+#
+#   # good
+#   [a, b, foo(
+#   bar
+#   )]
+#
+# source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#47
+class RuboCop::Cop::Layout::MultilineArrayLineBreaks < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::MultilineElementLineBreaks
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#53
+  def on_array(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#59
+  def ignore_last_element?; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_array_line_breaks.rb#51
+RuboCop::Cop::Layout::MultilineArrayLineBreaks::MSG = T.let(T.unsafe(nil), String)
+
+# Checks whether the multiline assignments have a newline
+# after the assignment operator.
+#
+# @example EnforcedStyle: new_line (default)
+#   # bad
+#   foo = if expression
+#   'bar'
+#   end
+#
+#   # good
+#   foo =
+#   if expression
+#   'bar'
+#   end
+#
+#   # good
+#   foo =
+#   begin
+#   compute
+#   rescue => e
+#   nil
+#   end
+# @example EnforcedStyle: same_line
+#   # good
+#   foo = if expression
+#   'bar'
+#   end
+# @example SupportedTypes: ['block', 'case', 'class', 'if', 'kwbegin', 'module'] (default)
+#   # good
+#   foo =
+#   if expression
+#   'bar'
+#   end
+#
+#   # good
+#   foo =
+#   [1].map do |i|
+#   i + 1
+#   end
+# @example SupportedTypes: ['block']
+#   # good
+#   foo = if expression
+#   'bar'
+#   end
+#
+#   # good
+#   foo =
+#   [1].map do |i|
+#   'bar' * i
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#60
+class RuboCop::Cop::Layout::MultilineAssignmentLayout < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CheckAssignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#72
+  def check_assignment(node, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#81
+  def check_by_enforced_style(node, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#90
+  def check_new_line_offense(node, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#98
+  def check_same_line_offense(node, rhs); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#111
+  def supported_types; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#66
+RuboCop::Cop::Layout::MultilineAssignmentLayout::NEW_LINE_OFFENSE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_assignment_layout.rb#69
+RuboCop::Cop::Layout::MultilineAssignmentLayout::SAME_LINE_OFFENSE = T.let(T.unsafe(nil), String)
+
+# Checks whether the multiline do end blocks have a newline
+# after the start of the block. Additionally, it checks whether the block
+# arguments, if any, are on the same line as the start of the
+# block. Putting block arguments on separate lines, because the whole
+# line would otherwise be too long, is accepted.
+#
+# @example
+#   # bad
+#   blah do |i| foo(i)
+#   bar(i)
+#   end
+#
+#   # bad
+#   blah do
+#   |i| foo(i)
+#   bar(i)
+#   end
+#
+#   # good
+#   blah do |i|
+#   foo(i)
+#   bar(i)
+#   end
+#
+#   # bad
+#   blah { |i| foo(i)
+#   bar(i)
+#   }
+#
+#   # good
+#   blah { |i|
+#   foo(i)
+#   bar(i)
+#   }
+#
+#   # good
+#   blah { |
+#   long_list,
+#   of_parameters,
+#   that_would_not,
+#   fit_on_one_line
+#   |
+#   foo(i)
+#   bar(i)
+#   }
+#
+# source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#51
+class RuboCop::Cop::Layout::MultilineBlockLayout < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#59
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#59
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#98
+  def add_offense_for_expression(node, expr, msg); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#75
+  def args_on_beginning_line?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#105
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#120
+  def autocorrect_arguments(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#130
+  def autocorrect_body(corrector, node, block_body); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#142
+  def block_arg_string(node, args); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#90
+  def characters_needed_for_space_and_pipes(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#154
+  def include_trailing_comma?(args); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#79
+  def line_break_necessary_in_args?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#83
+  def needed_length_for_args(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#56
+RuboCop::Cop::Layout::MultilineBlockLayout::ARG_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#55
+RuboCop::Cop::Layout::MultilineBlockLayout::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_block_layout.rb#57
+RuboCop::Cop::Layout::MultilineBlockLayout::PIPE_SIZE = T.let(T.unsafe(nil), Integer)
+
+# Checks that the closing brace in a hash literal is either
+# on the same line as the last hash element, or a new line.
+#
+# When using the `symmetrical` (default) style:
+#
+# If a hash's opening brace is on the same line as the first element
+# of the hash, then the closing brace should be on the same line as
+# the last element of the hash.
+#
+# If a hash's opening brace is on the line above the first element
+# of the hash, then the closing brace should be on the line below
+# the last element of the hash.
+#
+# When using the `new_line` style:
+#
+# The closing brace of a multi-line hash literal must be on the line
+# after the last element of the hash.
+#
+# When using the `same_line` style:
+#
+# The closing brace of a multi-line hash literal must be on the same
+# line as the last element of the hash.
+#
+# @example EnforcedStyle: symmetrical (default)
+#
+#   # bad
+#   { a: 1,
+#   b: 2
+#   }
+#   # bad
+#   {
+#   a: 1,
+#   b: 2 }
+#
+#   # good
+#   { a: 1,
+#   b: 2 }
+#
+#   # good
+#   {
+#   a: 1,
+#   b: 2
+#   }
+# @example EnforcedStyle: new_line
+#   # bad
+#   {
+#   a: 1,
+#   b: 2 }
+#
+#   # bad
+#   { a: 1,
+#   b: 2 }
+#
+#   # good
+#   { a: 1,
+#   b: 2
+#   }
+#
+#   # good
+#   {
+#   a: 1,
+#   b: 2
+#   }
+# @example EnforcedStyle: same_line
+#   # bad
+#   { a: 1,
+#   b: 2
+#   }
+#
+#   # bad
+#   {
+#   a: 1,
+#   b: 2
+#   }
+#
+#   # good
+#   {
+#   a: 1,
+#   b: 2 }
+#
+#   # good
+#   { a: 1,
+#   b: 2 }
+#
+# source://rubocop//lib/rubocop/cop/layout/multiline_hash_brace_layout.rb#91
+class RuboCop::Cop::Layout::MultilineHashBraceLayout < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::MultilineLiteralBraceLayout
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_hash_brace_layout.rb#109
+  def on_hash(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_hash_brace_layout.rb#103
+RuboCop::Cop::Layout::MultilineHashBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_hash_brace_layout.rb#106
+RuboCop::Cop::Layout::MultilineHashBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_hash_brace_layout.rb#99
+RuboCop::Cop::Layout::MultilineHashBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_hash_brace_layout.rb#95
+RuboCop::Cop::Layout::MultilineHashBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# Ensures that each key in a multi-line hash
+# starts on a separate line.
+#
+# @example
+#
+#   # bad
+#   {
+#   a: 1, b: 2,
+#   c: 3
+#   }
+#
+#   # good
+#   {
+#   a: 1,
+#   b: 2,
+#   c: 3
+#   }
+#
+#   # good
+#   {
+#   a: 1,
+#   b: {
+#   c: 3,
+#   }
+#   }
+# @example AllowMultilineFinalElement: false (default)
+#
+#   # bad
+#   { a: 1, b: {
+#   c: 3,
+#   }}
+# @example AllowMultilineFinalElement: true
+#
+#   # good
+#   { a: 1, b: {
+#   c: 3,
+#   }}
+#
+# source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#46
+class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::MultilineElementLineBreaks
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#52
+  def on_hash(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#68
+  def ignore_last_element?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#64
+  def starts_with_curly_brace?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb#50
+RuboCop::Cop::Layout::MultilineHashKeyLineBreaks::MSG = T.let(T.unsafe(nil), String)
+
+# Ensures that each argument in a multi-line method call
+# starts on a separate line.
+#
+# NOTE: This cop does not move the first argument, if you want that to
+# be on a separate line, see `Layout/FirstMethodArgumentLineBreak`.
+#
+# @example
+#
+#   # bad
+#   foo(a, b,
+#   c
+#   )
+#
+#   # bad
+#   foo(a, b, {
+#   foo: "bar",
+#   })
+#
+#   # good
+#   foo(
+#   a,
+#   b,
+#   c
+#   )
+#
+#   # good
+#   foo(a, b, c)
+# @example AllowMultilineFinalElement: false (default)
+#
+#   # good
+#   foo(
+#   a,
+#   b,
+#   {
+#   foo: "bar",
+#   }
+#   )
+# @example AllowMultilineFinalElement: true
+#
+#   # good
+#   foo(
+#   a,
+#   b,
+#   {
+#   foo: "bar",
+#   }
+#   )
+#
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#56
+class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::MultilineElementLineBreaks
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#62
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#81
+  def ignore_last_element?; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb#60
+RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that the closing brace in a method call is either
+# on the same line as the last method argument, or a new line.
+#
+# When using the `symmetrical` (default) style:
+#
+# If a method call's opening brace is on the same line as the first
+# argument of the call, then the closing brace should be on the same
+# line as the last argument of the call.
+#
+# If an method call's opening brace is on the line above the first
+# argument of the call, then the closing brace should be on the line
+# below the last argument of the call.
+#
+# When using the `new_line` style:
+#
+# The closing brace of a multi-line method call must be on the line
+# after the last argument of the call.
+#
+# When using the `same_line` style:
+#
+# The closing brace of a multi-line method call must be on the same
+# line as the last argument of the call.
+#
+# @example EnforcedStyle: symmetrical (default)
+#   # bad
+#   foo(a,
+#   b
+#   )
+#
+#   # bad
+#   foo(
+#   a,
+#   b)
+#
+#   # good
+#   foo(a,
+#   b)
+#
+#   # good
+#   foo(
+#   a,
+#   b
+#   )
+# @example EnforcedStyle: new_line
+#   # bad
+#   foo(
+#   a,
+#   b)
+#
+#   # bad
+#   foo(a,
+#   b)
+#
+#   # good
+#   foo(a,
+#   b
+#   )
+#
+#   # good
+#   foo(
+#   a,
+#   b
+#   )
+# @example EnforcedStyle: same_line
+#   # bad
+#   foo(a,
+#   b
+#   )
+#
+#   # bad
+#   foo(
+#   a,
+#   b
+#   )
+#
+#   # good
+#   foo(
+#   a,
+#   b)
+#
+#   # good
+#   foo(a,
+#   b)
+#
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#91
+class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::MultilineLiteralBraceLayout
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#109
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#115
+  def children(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#119
+  def ignored_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#123
+  def single_line_ignoring_receiver?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#103
+RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#106
+RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#99
+RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb#95
+RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# Checks the indentation of the method name part in method calls
+# that span more than one line.
+#
+# @example EnforcedStyle: aligned (default)
+#   # bad
+#   while myvariable
+#   .b
+#   # do something
+#   end
+#
+#   # good
+#   while myvariable
+#   .b
+#   # do something
+#   end
+#
+#   # good
+#   Thing.a
+#   .b
+#   .c
+# @example EnforcedStyle: indented
+#   # good
+#   while myvariable
+#   .b
+#
+#   # do something
+#   end
+# @example EnforcedStyle: indented_relative_to_receiver
+#   # good
+#   while myvariable
+#   .a
+#   .b
+#
+#   # do something
+#   end
+#
+#   # good
+#   myvariable = Thing
+#   .a
+#   .b
+#   .c
+#
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#49
+class RuboCop::Cop::Layout::MultilineMethodCallIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::MultilineExpressionIndentation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # @raise [ValidationError]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#55
+  def validate_config; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#136
+  def align_with_base_message(rhs); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#152
+  def alignment_base(node, rhs, given_style); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#67
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#140
+  def base_source; end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#101
+  def extra_indentation(given_style, parent); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#226
+  def find_multiline_block_chain_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#237
+  def first_call_has_a_dot(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#217
+  def get_dot_right_above(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#113
+  def message(node, lhs, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#144
+  def no_base_message(lhs, rhs, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#87
+  def offending_range(node, lhs, rhs, given_style); end
+
+  # @yield [operation_rhs.first_argument]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#247
+  def operation_rhs(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#257
+  def operator_rhs?(node, receiver); end
+
+  # a
+  #   .b
+  #   .c
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#193
+  def receiver_alignment_base(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#131
+  def relative_to_receiver_message(rhs); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#71
+  def relevant_node?(send_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#75
+  def right_hand_side(send_node); end
+
+  # a.b
+  #  .c
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#181
+  def semantic_alignment_base(node, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#201
+  def semantic_alignment_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#127
+  def should_align_with_base?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#123
+  def should_indent_relative_to_receiver?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_call_indentation.rb#163
+  def syntactic_alignment_base(lhs, rhs); end
+end
+
+# Checks that the closing brace in a method definition is either
+# on the same line as the last method parameter, or a new line.
+#
+# When using the `symmetrical` (default) style:
+#
+# If a method definition's opening brace is on the same line as the
+# first parameter of the definition, then the closing brace should be
+# on the same line as the last parameter of the definition.
+#
+# If an method definition's opening brace is on the line above the first
+# parameter of the definition, then the closing brace should be on the
+# line below the last parameter of the definition.
+#
+# When using the `new_line` style:
+#
+# The closing brace of a multi-line method definition must be on the line
+# after the last parameter of the definition.
+#
+# When using the `same_line` style:
+#
+# The closing brace of a multi-line method definition must be on the same
+# line as the last parameter of the definition.
+#
+# @example EnforcedStyle: symmetrical (default)
+#   # bad
+#   def foo(a,
+#   b
+#   )
+#   end
+#
+#   # bad
+#   def foo(
+#   a,
+#   b)
+#   end
+#
+#   # good
+#   def foo(a,
+#   b)
+#   end
+#
+#   # good
+#   def foo(
+#   a,
+#   b
+#   )
+#   end
+# @example EnforcedStyle: new_line
+#   # bad
+#   def foo(
+#   a,
+#   b)
+#   end
+#
+#   # bad
+#   def foo(a,
+#   b)
+#   end
+#
+#   # good
+#   def foo(a,
+#   b
+#   )
+#   end
+#
+#   # good
+#   def foo(
+#   a,
+#   b
+#   )
+#   end
+# @example EnforcedStyle: same_line
+#   # bad
+#   def foo(a,
+#   b
+#   )
+#   end
+#
+#   # bad
+#   def foo(
+#   a,
+#   b
+#   )
+#   end
+#
+#   # good
+#   def foo(
+#   a,
+#   b)
+#   end
+#
+#   # good
+#   def foo(a,
+#   b)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb#103
+class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::MultilineLiteralBraceLayout
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb#121
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb#121
+  def on_defs(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb#115
+RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb#118
+RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb#111
+RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb#107
+RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# Ensures that each parameter in a multi-line method definition
+# starts on a separate line.
+#
+# NOTE: This cop does not move the first argument, if you want that to
+# be on a separate line, see `Layout/FirstMethodParameterLineBreak`.
+#
+# @example
+#
+#   # bad
+#   def foo(a, b,
+#   c
+#   )
+#   end
+#
+#   # good
+#   def foo(
+#   a,
+#   b,
+#   c
+#   )
+#   end
+#
+#   # good
+#   def foo(
+#   a,
+#   b = {
+#   foo: "bar",
+#   }
+#   )
+#   end
+#
+#   # good
+#   def foo(a, b, c)
+#   end
+# @example AllowMultilineFinalElement: false (default)
+#
+#   # bad
+#   def foo(a, b = {
+#   foo: "bar",
+#   })
+#   end
+# @example AllowMultilineFinalElement: true
+#
+#   # good
+#   def foo(a, b = {
+#   foo: "bar",
+#   })
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#57
+class RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::MultilineElementLineBreaks
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#63
+  def on_def(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#71
+  def ignore_last_element?; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb#61
+RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks::MSG = T.let(T.unsafe(nil), String)
+
+# Checks the indentation of the right hand side operand in binary operations that
+# span more than one line.
+#
+# The `aligned` style checks that operators are aligned if they are part of an `if` or `while`
+# condition, an explicit `return` statement, etc. In other contexts, the second operand should
+# be indented regardless of enforced style.
+#
+# @example EnforcedStyle: aligned (default)
+#   # bad
+#   if a +
+#   b
+#   something &&
+#   something_else
+#   end
+#
+#   # good
+#   if a +
+#   b
+#   something &&
+#   something_else
+#   end
+# @example EnforcedStyle: indented
+#   # bad
+#   if a +
+#   b
+#   something &&
+#   something_else
+#   end
+#
+#   # good
+#   if a +
+#   b
+#   something &&
+#   something_else
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#43
+class RuboCop::Cop::Layout::MultilineOperationIndentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::MultilineExpressionIndentation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#49
+  def on_and(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#53
+  def on_or(node); end
+
+  # @raise [ValidationError]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#57
+  def validate_config; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#68
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#78
+  def check_and_or(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#110
+  def message(node, lhs, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#84
+  def offending_range(node, lhs, rhs, given_style); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#72
+  def relevant_node?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#121
+  def right_hand_side(send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/multiline_operation_indentation.rb#97
+  def should_align?(node, rhs, given_style); end
+end
+
+# Here we check if the parameters on a multi-line method call or
+# definition are aligned.
+#
+# To set the alignment of the first argument, use the cop
+# FirstParameterIndentation.
+#
+# @example EnforcedStyle: with_first_parameter (default)
+#   # good
+#
+#   def foo(bar,
+#   baz)
+#   123
+#   end
+#
+#   def foo(
+#   bar,
+#   baz
+#   )
+#   123
+#   end
+#
+#   # bad
+#
+#   def foo(bar,
+#   baz)
+#   123
+#   end
+#
+#   # bad
+#
+#   def foo(
+#   bar,
+#   baz)
+#   123
+#   end
+# @example EnforcedStyle: with_fixed_indentation
+#   # good
+#
+#   def foo(bar,
+#   baz)
+#   123
+#   end
+#
+#   def foo(
+#   bar,
+#   baz
+#   )
+#   123
+#   end
+#
+#   # bad
+#
+#   def foo(bar,
+#   baz)
+#   123
+#   end
+#
+#   # bad
+#
+#   def foo(
+#   bar,
+#   baz)
+#   123
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#71
+class RuboCop::Cop::Layout::ParameterAlignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#81
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#81
+  def on_defs(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#90
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#102
+  def base_column(node, args); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#98
+  def fixed_indentation?; end
+
+  # source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#94
+  def message(_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#113
+  def target_method_lineno(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#75
+RuboCop::Cop::Layout::ParameterAlignment::ALIGN_PARAMS_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/parameter_alignment.rb#78
+RuboCop::Cop::Layout::ParameterAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String)
+
+# Checks whether certain expressions, e.g. method calls, that could fit
+# completely on a single line, are broken up into multiple lines unnecessarily.
+#
+# @example any configuration
+#   # bad
+#   foo(
+#   a,
+#   b
+#   )
+#
+#   puts 'string that fits on ' \
+#   'a single line'
+#
+#   things
+#   .select { |thing| thing.cond? }
+#   .join('-')
+#
+#   # good
+#   foo(a, b)
+#
+#   puts 'string that fits on a single line'
+#
+#   things.select { |thing| thing.cond? }.join('-')
+# @example InspectBlocks: false (default)
+#   # good
+#   foo(a) do |x|
+#   puts x
+#   end
+# @example InspectBlocks: true
+#   # bad
+#   foo(a) do |x|
+#   puts x
+#   end
+#
+#   # good
+#   foo(a) { |x| puts x }
+#
+# source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#45
+class RuboCop::Cop::Layout::RedundantLineBreak < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CheckAssignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#55
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#51
+  def on_lvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#55
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#73
+  def check_assignment(node, _rhs); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#133
+  def comment_within?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#103
+  def configured_to_not_be_inspected?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#127
+  def convertible_block?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#69
+  def end_with_percent_blank_string?(processed_source); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#97
+  def index_access_call_chained?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#155
+  def max_line_length; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#86
+  def offense?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#110
+  def other_cop_takes_precedence?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#79
+  def register_offense(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#93
+  def require_backslash?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#116
+  def single_line_block_chain_enabled?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#120
+  def suitable_as_single_line?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#146
+  def to_single_line(source); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#141
+  def too_long?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/redundant_line_break.rb#49
+RuboCop::Cop::Layout::RedundantLineBreak::MSG = T.let(T.unsafe(nil), String)
+
+# Checks whether the rescue and ensure keywords are aligned
+# properly.
+#
+# @example
+#
+#   # bad
+#   begin
+#   something
+#   rescue
+#   puts 'error'
+#   end
+#
+#   # good
+#   begin
+#   something
+#   rescue
+#   puts 'error'
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#24
+class RuboCop::Cop::Layout::RescueEnsureAlignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::EndKeywordAlignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#40
+  def on_ensure(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#44
+  def on_new_investigation; end
+
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#36
+  def on_resbody(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#186
+  def access_modifier?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#163
+  def access_modifier_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#149
+  def aligned_with_leading_dot?(do_keyword_line, send_node_loc, rescue_keyword_column); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#136
+  def aligned_with_line_break_method?(ancestor_node, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#195
+  def alignment_location(alignment_node); end
+
+  # We will use ancestor or wrapper with access modifier.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#116
+  def alignment_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#95
+  def alignment_source(node, starting_loc); end
+
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#132
+  def ancestor_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#155
+  def assignment_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#73
+  def autocorrect(corrector, node, alignment_location); end
+
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#203
+  def begin_end_alignment_style; end
+
+  # Check alignment of node with rescue or ensure modifiers.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#57
+  def check(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#83
+  def format_message(alignment_node, alignment_loc, kw_loc); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#173
+  def modifier?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#179
+  def whitespace_range(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#34
+RuboCop::Cop::Layout::RescueEnsureAlignment::ALTERNATIVE_ACCESS_MODIFIERS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#32
+RuboCop::Cop::Layout::RescueEnsureAlignment::ANCESTOR_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#33
+RuboCop::Cop::Layout::RescueEnsureAlignment::ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/layout/rescue_ensure_alignment.rb#29
+RuboCop::Cop::Layout::RescueEnsureAlignment::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if method calls are chained onto single line blocks. It considers that a
+# line break before the dot improves the readability of the code.
+#
+# @example
+#   # bad
+#   example.select { |item| item.cond? }.join('-')
+#
+#   # good
+#   example.select { |item| item.cond? }
+#   .join('-')
+#
+#   # good (not a concern for this cop)
+#   example.select do |item|
+#   item.cond?
+#   end.join('-')
+#
+# source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#22
+class RuboCop::Cop::Layout::SingleLineBlockChain < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#32
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#32
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#56
+  def call_method_after_block?(node, dot_range, closing_block_delimiter_line_num); end
+
+  # source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#40
+  def offending_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#62
+  def selector_range(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#28
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/single_line_block_chain.rb#26
+RuboCop::Cop::Layout::SingleLineBlockChain::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for colon (:) not followed by some kind of space.
+# N.B. this cop does not handle spaces after a ternary operator, which are
+# instead handled by Layout/SpaceAroundOperators.
+#
+# @example
+#   # bad
+#   def f(a:, b:2); {a:3}; end
+#
+#   # good
+#   def f(a:, b: 2); {a: 3}; end
+#
+# source://rubocop//lib/rubocop/cop/layout/space_after_colon.rb#16
+class RuboCop::Cop::Layout::SpaceAfterColon < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_after_colon.rb#29
+  def on_kwoptarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_after_colon.rb#21
+  def on_pair(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_after_colon.rb#43
+  def followed_by_space?(colon); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_after_colon.rb#39
+  def register_offense(colon); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_after_colon.rb#19
+RuboCop::Cop::Layout::SpaceAfterColon::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for comma (,) not followed by some kind of space.
+#
+# @example
+#
+#   # bad
+#   [1,2]
+#   { foo:bar,}
+#
+#   # good
+#   [1, 2]
+#   { foo:bar, }
+#
+# source://rubocop//lib/rubocop/cop/layout/space_after_comma.rb#17
+class RuboCop::Cop::Layout::SpaceAfterComma < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::SpaceAfterPunctuation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_after_comma.rb#26
+  def kind(token); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_after_comma.rb#21
+  def space_style_before_rcurly; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_after_comma.rb#32
+  def before_semicolon?(token); end
+end
+
+# Checks for space between a method name and a left parenthesis in defs.
+#
+# @example
+#
+#   # bad
+#   def func (x) end
+#   def method= (y) end
+#
+#   # good
+#   def func(x) end
+#   def method=(y) end
+#
+# source://rubocop//lib/rubocop/cop/layout/space_after_method_name.rb#17
+class RuboCop::Cop::Layout::SpaceAfterMethodName < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_after_method_name.rb#23
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_after_method_name.rb#23
+  def on_defs(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_after_method_name.rb#21
+RuboCop::Cop::Layout::SpaceAfterMethodName::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for space after `!`.
+#
+# @example
+#   # bad
+#   ! something
+#
+#   # good
+#   !something
+#
+# source://rubocop//lib/rubocop/cop/layout/space_after_not.rb#14
+class RuboCop::Cop::Layout::SpaceAfterNot < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_after_not.rb#21
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_after_not.rb#33
+  def whitespace_after_operator?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_after_not.rb#18
+RuboCop::Cop::Layout::SpaceAfterNot::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_after_not.rb#19
+RuboCop::Cop::Layout::SpaceAfterNot::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for semicolon (;) not followed by some kind of space.
+#
+# @example
+#   # bad
+#   x = 1;y = 2
+#
+#   # good
+#   x = 1; y = 2
+#
+# source://rubocop//lib/rubocop/cop/layout/space_after_semicolon.rb#14
+class RuboCop::Cop::Layout::SpaceAfterSemicolon < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::SpaceAfterPunctuation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_after_semicolon.rb#23
+  def kind(token); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_after_semicolon.rb#18
+  def space_style_before_rcurly; end
+end
+
+# Checks the spacing inside and after block parameters pipes. Line breaks
+# inside parameter pipes are checked by `Layout/MultilineBlockLayout` and
+# not by this cop.
+#
+# @example EnforcedStyleInsidePipes: no_space (default)
+#   # bad
+#   {}.each { | x,  y |puts x }
+#   ->( x,  y ) { puts x }
+#
+#   # good
+#   {}.each { |x, y| puts x }
+#   ->(x, y) { puts x }
+# @example EnforcedStyleInsidePipes: space
+#   # bad
+#   {}.each { |x,  y| puts x }
+#   ->(x,  y) { puts x }
+#
+#   # good
+#   {}.each { | x, y | puts x }
+#   ->( x, y ) { puts x }
+#
+# source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#27
+class RuboCop::Cop::Layout::SpaceAroundBlockParameters < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#32
+  def on_block(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#65
+  def check_after_closing_pipe(arguments); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#125
+  def check_arg(arg); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#103
+  def check_closing_pipe_space(arguments, closing_pipe); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#121
+  def check_each_arg(args); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#56
+  def check_inside_pipes(arguments); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#150
+  def check_no_space(space_begin_pos, space_end_pos, msg); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#73
+  def check_no_space_style_inside_pipes(arguments); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#92
+  def check_opening_pipe_space(arguments, opening_pipe); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#136
+  def check_space(space_begin_pos, space_end_pos, range, msg, node = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#85
+  def check_space_style_inside_pipes(arguments); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#113
+  def last_end_pos_inside_pipes(arguments, range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#44
+  def pipes(arguments); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#48
+  def pipes?(arguments); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_block_parameters.rb#52
+  def style_parameter_name; end
+end
+
+# Checks that the equals signs in parameter default assignments
+# have or don't have surrounding space depending on configuration.
+#
+# @example EnforcedStyle: space (default)
+#   # bad
+#   def some_method(arg1=:default, arg2=nil, arg3=[])
+#   # do something...
+#   end
+#
+#   # good
+#   def some_method(arg1 = :default, arg2 = nil, arg3 = [])
+#   # do something...
+#   end
+# @example EnforcedStyle: no_space
+#   # bad
+#   def some_method(arg1 = :default, arg2 = nil, arg3 = [])
+#   # do something...
+#   end
+#
+#   # good
+#   def some_method(arg1=:default, arg2=nil, arg3=[])
+#   # do something...
+#   end
+#
+# source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#30
+class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#38
+  def on_optarg(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#67
+  def autocorrect(corrector, range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#46
+  def check_optarg(arg, equals, value); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#58
+  def incorrect_style_detected(arg, value); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#83
+  def message(_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#79
+  def no_surrounding_space?(arg, equals); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#75
+  def space_on_both_sides?(arg, equals); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb#36
+RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::MSG = T.let(T.unsafe(nil), String)
+
+# Checks the spacing around the keywords.
+#
+# @example
+#
+#   # bad
+#   something 'test'do|x|
+#   end
+#
+#   while(something)
+#   end
+#
+#   something = 123if test
+#
+#   # good
+#   something 'test' do |x|
+#   end
+#
+#   while (something)
+#   end
+#
+#   something = 123 if test
+#
+# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#27
+class RuboCop::Cop::Layout::SpaceAroundKeyword < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#40
+  def on_and(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#44
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#48
+  def on_break(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#52
+  def on_case(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#56
+  def on_case_match(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#156
+  def on_defined?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#60
+  def on_ensure(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#64
+  def on_for(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#68
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#72
+  def on_if_guard(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#76
+  def on_in_pattern(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#80
+  def on_kwbegin(node); end
+
+  # Handle one-line pattern matching syntax (`in`) with `Parser::Ruby27`.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#85
+  def on_match_pattern(node); end
+
+  # Handle one-line pattern matching syntax (`in`) with `Parser::Ruby30`.
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#92
+  def on_match_pattern_p(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#96
+  def on_next(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#100
+  def on_or(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#104
+  def on_postexe(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#108
+  def on_preexe(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#112
+  def on_resbody(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#116
+  def on_rescue(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#120
+  def on_return(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#124
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#128
+  def on_super(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#136
+  def on_unless_guard(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#140
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#144
+  def on_when(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#148
+  def on_while(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#152
+  def on_yield(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#132
+  def on_zsuper(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#235
+  def accept_left_parenthesis?(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#239
+  def accept_left_square_bracket?(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#243
+  def accept_namespace_operator?(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#228
+  def accepted_opening_delimiter?(range, char); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#162
+  def check(node, locations, begin_keyword = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#177
+  def check_begin(node, range, begin_keyword); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#183
+  def check_end(node, range, begin_keyword); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#196
+  def check_keyword(node, range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#192
+  def do?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#251
+  def namespace_operator?(range, pos); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#255
+  def preceded_by_operator?(node, _range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#247
+  def safe_navigation_call?(range, pos); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#217
+  def space_after_missing?(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#210
+  def space_before_missing?(range); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#36
+RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_LEFT_PAREN = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#37
+RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_LEFT_SQUARE_BRACKET = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#38
+RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_NAMESPACE_OPERATOR = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#33
+RuboCop::Cop::Layout::SpaceAroundKeyword::DO = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#31
+RuboCop::Cop::Layout::SpaceAroundKeyword::MSG_AFTER = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#30
+RuboCop::Cop::Layout::SpaceAroundKeyword::MSG_BEFORE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#35
+RuboCop::Cop::Layout::SpaceAroundKeyword::NAMESPACE_OPERATOR = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_around_keyword.rb#34
+RuboCop::Cop::Layout::SpaceAroundKeyword::SAFE_NAVIGATION = T.let(T.unsafe(nil), String)
+
+# Checks method call operators to not have spaces around them.
+#
+# @example
+#   # bad
+#   foo. bar
+#   foo .bar
+#   foo . bar
+#   foo. bar .buzz
+#   foo
+#   . bar
+#   . buzz
+#   foo&. bar
+#   foo &.bar
+#   foo &. bar
+#   foo &. bar&. buzz
+#   RuboCop:: Cop
+#   RuboCop:: Cop:: Base
+#   :: RuboCop::Cop
+#
+#   # good
+#   foo.bar
+#   foo.bar.buzz
+#   foo
+#   .bar
+#   .buzz
+#   foo&.bar
+#   foo&.bar&.buzz
+#   RuboCop::Cop
+#   RuboCop::Cop::Base
+#   ::RuboCop::Cop
+#
+# source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#37
+class RuboCop::Cop::Layout::SpaceAroundMethodCallOperator < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#53
+  def on_const(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#45
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#45
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#87
+  def check_space(begin_pos, end_pos); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#67
+  def check_space_after_dot(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#81
+  def check_space_after_double_colon(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#61
+  def check_space_before_dot(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#43
+RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_around_method_call_operator.rb#41
+RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::SPACES_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# Checks that operators have space around them, except for ** which
+# should or shouldn't have surrounding space depending on configuration.
+# It allows vertical alignment consisting of one or more whitespace
+# around operators.
+#
+# This cop has `AllowForAlignment` option. When `true`, allows most
+# uses of extra spacing if the intent is to align with an operator on
+# the previous or next line, not counting empty lines or comment lines.
+#
+# @example
+#   # bad
+#   total = 3*4
+#   "apple"+"juice"
+#   my_number = 38/4
+#
+#   # good
+#   total = 3 * 4
+#   "apple" + "juice"
+#   my_number = 38 / 4
+# @example AllowForAlignment: true (default)
+#   # good
+#   {
+#   1 =>  2,
+#   11 => 3
+#   }
+# @example AllowForAlignment: false
+#   # bad
+#   {
+#   1 =>  2,
+#   11 => 3
+#   }
+# @example EnforcedStyleForExponentOperator: no_space (default)
+#   # bad
+#   a ** b
+#
+#   # good
+#   a**b
+# @example EnforcedStyleForExponentOperator: space
+#   # bad
+#   a**b
+#
+#   # good
+#   a ** b
+# @example EnforcedStyleForRationalLiterals: no_space (default)
+#   # bad
+#   1 / 48r
+#
+#   # good
+#   1/48r
+# @example EnforcedStyleForRationalLiterals: space
+#   # bad
+#   1/48r
+#
+#   # good
+#   1 / 48r
+#
+# source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#67
+class RuboCop::Cop::Layout::SpaceAroundOperators < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::PrecedingFollowingAlignment
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::RationalLiteral
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#133
+  def on_and(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117
+  def on_and_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117
+  def on_assignment(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#133
+  def on_binary(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#125
+  def on_casgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#133
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117
+  def on_cvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117
+  def on_gvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#92
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117
+  def on_ivasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117
+  def on_lvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117
+  def on_masgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#149
+  def on_match_pattern(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#141
+  def on_op_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#133
+  def on_or(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#117
+  def on_or_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#84
+  def on_pair(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#99
+  def on_resbody(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#80
+  def on_sclass(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#107
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#141
+  def on_special_asgn(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#259
+  def align_hash_cop_config; end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#198
+  def autocorrect(corrector, range, right_operand); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#179
+  def check_operator(type, operator, right_operand); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#212
+  def enclose_operator_with_space(corrector, range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#239
+  def excess_leading_space?(type, operator, with_space); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#254
+  def excess_trailing_space?(right_operand, with_space); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#277
+  def force_equal_sign_alignment?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#263
+  def hash_table_style?; end
+
+  # @yield [msg]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#193
+  def offense(type, operator, with_space, right_operand); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#225
+  def offense_message(type, operator, with_space, right_operand); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#175
+  def operator_with_regular_syntax?(send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#169
+  def regular_operator?(send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#281
+  def should_not_have_surrounding_space?(operator, right_operand); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#267
+  def space_around_exponent_operator?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#271
+  def space_around_slash_operator?(right_operand); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#76
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#74
+RuboCop::Cop::Layout::SpaceAroundOperators::EXCESSIVE_SPACE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_around_operators.rb#73
+RuboCop::Cop::Layout::SpaceAroundOperators::IRREGULAR_METHODS = T.let(T.unsafe(nil), Array)
+
+# Checks that block braces have or don't have a space before the opening
+# brace depending on configuration.
+#
+# @example EnforcedStyle: space (default)
+#   # bad
+#   foo.map{ |a|
+#   a.bar.to_s
+#   }
+#
+#   # good
+#   foo.map { |a|
+#   a.bar.to_s
+#   }
+# @example EnforcedStyle: no_space
+#   # bad
+#   foo.map { |a|
+#   a.bar.to_s
+#   }
+#
+#   # good
+#   foo.map{ |a|
+#   a.bar.to_s
+#   }
+# @example EnforcedStyleForEmptyBraces: space (default)
+#   # bad
+#   7.times{}
+#
+#   # good
+#   7.times {}
+# @example EnforcedStyleForEmptyBraces: no_space
+#   # bad
+#   7.times {}
+#
+#   # good
+#   7.times{}
+#
+# source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#44
+class RuboCop::Cop::Layout::SpaceBeforeBlockBraces < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#56
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#56
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#133
+  def autocorrect(corrector, range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#153
+  def block_delimiters_style; end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#83
+  def check_empty(left_brace, space_plus_brace, used_style); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#109
+  def check_non_empty(left_brace, space_plus_brace, used_style); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#149
+  def conflict_with_block_delimiters?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#157
+  def empty_braces?(loc); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#101
+  def handle_different_styles_for_empty_braces(used_style); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#124
+  def space_detected(left_brace, space_plus_brace); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#117
+  def space_missing(left_brace); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#140
+  def style_for_empty_braces; end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#52
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#50
+RuboCop::Cop::Layout::SpaceBeforeBlockBraces::DETECTED_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_before_block_braces.rb#49
+RuboCop::Cop::Layout::SpaceBeforeBlockBraces::MISSING_MSG = T.let(T.unsafe(nil), String)
+
+# Checks for space between the name of a receiver and a left
+# brackets.
+#
+# @example
+#
+#   # bad
+#   collection [index_or_key]
+#
+#   # good
+#   collection[index_or_key]
+#
+# source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#17
+class RuboCop::Cop::Layout::SpaceBeforeBrackets < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#24
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#48
+  def dot_before_brackets?(node, receiver_end_pos, selector_begin_pos); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#35
+  def offense_range(node, begin_pos); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#54
+  def offense_range_for_assignment(node, begin_pos); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#67
+  def reference_variable_with_brackets?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#63
+  def register_offense(range); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#21
+RuboCop::Cop::Layout::SpaceBeforeBrackets::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_before_brackets.rb#22
+RuboCop::Cop::Layout::SpaceBeforeBrackets::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for comma (,) preceded by space.
+#
+# @example
+#   # bad
+#   [1 , 2 , 3]
+#   a(1 , 2)
+#   each { |a , b| }
+#
+#   # good
+#   [1, 2, 3]
+#   a(1, 2)
+#   each { |a, b| }
+#
+# source://rubocop//lib/rubocop/cop/layout/space_before_comma.rb#19
+class RuboCop::Cop::Layout::SpaceBeforeComma < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::SpaceBeforePunctuation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_comma.rb#23
+  def kind(token); end
+end
+
+# Checks for missing space between a token and a comment on the
+# same line.
+#
+# @example
+#   # bad
+#   1 + 1# this operation does ...
+#
+#   # good
+#   1 + 1 # this operation does ...
+#
+# source://rubocop//lib/rubocop/cop/layout/space_before_comment.rb#15
+class RuboCop::Cop::Layout::SpaceBeforeComment < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_comment.rb#20
+  def on_new_investigation; end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_before_comment.rb#18
+RuboCop::Cop::Layout::SpaceBeforeComment::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that exactly one space is used between a method name and the
+# first argument for method calls without parentheses.
+#
+# Alternatively, extra spaces can be added to align the argument with
+# something on a preceding or following line, if the AllowForAlignment
+# config parameter is true.
+#
+# @example
+#   # bad
+#   something  x
+#   something   y, z
+#   something'hello'
+#
+#   # good
+#   something x
+#   something y, z
+#   something 'hello'
+#
+# source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#24
+class RuboCop::Cop::Layout::SpaceBeforeFirstArg < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::PrecedingFollowingAlignment
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#35
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#35
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#55
+  def expect_params_after_method_name?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#64
+  def no_space_between_method_name_and_first_argument?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#51
+  def regular_method_call_with_arguments?(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#31
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_before_first_arg.rb#29
+RuboCop::Cop::Layout::SpaceBeforeFirstArg::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for semicolon (;) preceded by space.
+#
+# @example
+#   # bad
+#   x = 1 ; y = 2
+#
+#   # good
+#   x = 1; y = 2
+#
+# source://rubocop//lib/rubocop/cop/layout/space_before_semicolon.rb#14
+class RuboCop::Cop::Layout::SpaceBeforeSemicolon < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::SpaceBeforePunctuation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_before_semicolon.rb#18
+  def kind(token); end
+end
+
+# Checks for spaces between `->` and opening parameter
+# parenthesis (`(`) in lambda literals.
+#
+# @example EnforcedStyle: require_no_space (default)
+#   # bad
+#   a = -> (x, y) { x + y }
+#
+#   # good
+#   a = ->(x, y) { x + y }
+# @example EnforcedStyle: require_space
+#   # bad
+#   a = ->(x, y) { x + y }
+#
+#   # good
+#   a = -> (x, y) { x + y }
+#
+# source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#22
+class RuboCop::Cop::Layout::SpaceInLambdaLiteral < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#30
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#50
+  def arrow_lambda_with_args?(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#72
+  def lambda_arguments(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#65
+  def range_of_offense(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#58
+  def space_after_arrow(lambda_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#54
+  def space_after_arrow?(lambda_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#28
+RuboCop::Cop::Layout::SpaceInLambdaLiteral::MSG_REQUIRE_NO_SPACE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_in_lambda_literal.rb#27
+RuboCop::Cop::Layout::SpaceInLambdaLiteral::MSG_REQUIRE_SPACE = T.let(T.unsafe(nil), String)
+
+# Checks that brackets used for array literals have or don't have
+# surrounding space depending on configuration.
+#
+# @example EnforcedStyle: no_space (default)
+#   # The `no_space` style enforces that array literals have
+#   # no surrounding space.
+#
+#   # bad
+#   array = [ a, b, c, d ]
+#
+#   # good
+#   array = [a, b, c, d]
+# @example EnforcedStyle: space
+#   # The `space` style enforces that array literals have
+#   # surrounding space.
+#
+#   # bad
+#   array = [a, b, c, d]
+#
+#   # good
+#   array = [ a, b, c, d ]
+# @example EnforcedStyle: compact
+#   # The `compact` style normally requires a space inside
+#   # array brackets, with the exception that successive left
+#   # or right brackets are collapsed together in nested arrays.
+#
+#   # bad
+#   array = [ a, [ b, c ] ]
+#   array = [
+#   [ a ],
+#   [ b, c ]
+#   ]
+#
+#   # good
+#   array = [ a, [ b, c ]]
+#   array = [[ a ],
+#   [ b, c ]]
+# @example EnforcedStyleForEmptyBrackets: no_space (default)
+#   # The `no_space` EnforcedStyleForEmptyBrackets style enforces that
+#   # empty array brackets do not contain spaces.
+#
+#   # bad
+#   foo = [ ]
+#   bar = [     ]
+#
+#   # good
+#   foo = []
+#   bar = []
+# @example EnforcedStyleForEmptyBrackets: space
+#   # The `space` EnforcedStyleForEmptyBrackets style enforces that
+#   # empty array brackets contain exactly one space.
+#
+#   # bad
+#   foo = []
+#   bar = [    ]
+#
+#   # good
+#   foo = [ ]
+#   bar = [ ]
+#
+# source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#70
+class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#78
+  def on_array(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#109
+  def array_brackets(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#95
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#217
+  def compact(corrector, bracket, side); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#203
+  def compact_corrections(corrector, node, left, right); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#195
+  def compact_offense(node, token, side: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#157
+  def compact_offenses(node, left, right, start_ok, end_ok); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#118
+  def empty_config; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#126
+  def end_has_own_line?(token); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#133
+  def index_for(node, token); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#141
+  def issue_offenses(node, left, right, start_ok, end_ok); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#137
+  def line_and_column_for(token); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#178
+  def multi_dimensional_array?(node, token, side: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#189
+  def next_to_bracket?(token, side: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#153
+  def next_to_comment?(node, token); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#122
+  def next_to_newline?(node, token); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#170
+  def qualifies_for_compact?(node, token, side: T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#76
+RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::EMPTY_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb#75
+RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for unnecessary additional spaces inside array percent literals
+# (i.e. %i/%w).
+#
+# Note that blank percent literals (e.g. `%i( )`) are checked by
+# `Layout/SpaceInsidePercentLiteralDelimiters`.
+#
+# @example
+#
+#   # bad
+#   %w(foo  bar  baz)
+#   # good
+#   %i(foo bar baz)
+#
+# source://rubocop//lib/rubocop/cop/layout/space_inside_array_percent_literal.rb#18
+class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::MatchRange
+  include ::RuboCop::Cop::PercentLiteral
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_percent_literal.rb#26
+  def on_array(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_percent_literal.rb#30
+  def on_percent_literal(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_array_percent_literal.rb#40
+  def each_unnecessary_space_match(node, &blk); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_array_percent_literal.rb#23
+RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_array_percent_literal.rb#24
+RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# Checks that block braces have or don't have surrounding space inside
+# them on configuration. For blocks taking parameters, it checks that the
+# left brace has or doesn't have trailing space depending on
+# configuration.
+#
+# @example EnforcedStyle: space (default)
+#   # The `space` style enforces that block braces have
+#   # surrounding space.
+#
+#   # bad
+#   some_array.each {puts e}
+#
+#   # good
+#   some_array.each { puts e }
+# @example EnforcedStyle: no_space
+#   # The `no_space` style enforces that block braces don't
+#   # have surrounding space.
+#
+#   # bad
+#   some_array.each { puts e }
+#
+#   # good
+#   some_array.each {puts e}
+# @example EnforcedStyleForEmptyBraces: no_space (default)
+#   # The `no_space` EnforcedStyleForEmptyBraces style enforces that
+#   # block braces don't have a space in between when empty.
+#
+#   # bad
+#   some_array.each {   }
+#   some_array.each {  }
+#   some_array.each { }
+#
+#   # good
+#   some_array.each {}
+# @example EnforcedStyleForEmptyBraces: space
+#   # The `space` EnforcedStyleForEmptyBraces style enforces that
+#   # block braces have at least a space in between when empty.
+#
+#   # bad
+#   some_array.each {}
+#
+#   # good
+#   some_array.each { }
+#   some_array.each {  }
+#   some_array.each {   }
+# @example SpaceBeforeBlockParameters: true (default)
+#   # The SpaceBeforeBlockParameters style set to `true` enforces that
+#   # there is a space between `{` and `|`. Overrides `EnforcedStyle`
+#   # if there is a conflict.
+#
+#   # bad
+#   [1, 2, 3].each {|n| n * 2 }
+#
+#   # good
+#   [1, 2, 3].each { |n| n * 2 }
+# @example SpaceBeforeBlockParameters: false
+#   # The SpaceBeforeBlockParameters style set to `false` enforces that
+#   # there is no space between `{` and `|`. Overrides `EnforcedStyle`
+#   # if there is a conflict.
+#
+#   # bad
+#   [1, 2, 3].each { |n| n * 2 }
+#
+#   # good
+#   [1, 2, 3].each {|n| n * 2 }
+#
+# source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#79
+class RuboCop::Cop::Layout::SpaceInsideBlockBraces < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::SurroundingSpace
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#85
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#85
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#122
+  def adjacent_braces(left_brace, right_brace); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#161
+  def aligned_braces?(inner, right_brace, column); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#130
+  def braces_with_contents_inside(node, inner); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#105
+  def check_inside(node, left_brace, right_brace); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#137
+  def check_left_brace(inner, left_brace, args_delimiter); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#145
+  def check_right_brace(node, inner, left_brace, right_brace, single_line); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#165
+  def inner_last_space_count(inner); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#157
+  def multiline_block?(left_brace, right_brace); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#222
+  def no_space(begin_pos, end_pos, msg); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#169
+  def no_space_inside_left_brace(left_brace, args_delimiter); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#238
+  def offense(begin_pos, end_pos, msg, style_param = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#201
+  def pipe?(args_delimiter); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#230
+  def space(begin_pos, end_pos, msg); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#186
+  def space_inside_left_brace(left_brace, args_delimiter); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#205
+  def space_inside_right_brace(inner, right_brace, column); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_block_braces.rb#253
+  def style_for_empty_braces; end
+end
+
+# Checks that braces used for hash literals have or don't have
+# surrounding space depending on configuration.
+#
+# @example EnforcedStyle: space (default)
+#   # The `space` style enforces that hash literals have
+#   # surrounding space.
+#
+#   # bad
+#   h = {a: 1, b: 2}
+#
+#   # good
+#   h = { a: 1, b: 2 }
+# @example EnforcedStyle: no_space
+#   # The `no_space` style enforces that hash literals have
+#   # no surrounding space.
+#
+#   # bad
+#   h = { a: 1, b: 2 }
+#
+#   # good
+#   h = {a: 1, b: 2}
+# @example EnforcedStyle: compact
+#   # The `compact` style normally requires a space inside
+#   # hash braces, with the exception that successive left
+#   # braces or right braces are collapsed together in nested hashes.
+#
+#   # bad
+#   h = { a: { b: 2 } }
+#   foo = { { a: 1 } => { b: { c: 2 } } }
+#
+#   # good
+#   h = { a: { b: 2 }}
+#   foo = {{ a: 1 } => { b: { c: 2 }}}
+# @example EnforcedStyleForEmptyBraces: no_space (default)
+#   # The `no_space` EnforcedStyleForEmptyBraces style enforces that
+#   # empty hash braces do not contain spaces.
+#
+#   # bad
+#   foo = { }
+#   bar = {    }
+#   baz = {
+#   }
+#
+#   # good
+#   foo = {}
+#   bar = {}
+#   baz = {}
+# @example EnforcedStyleForEmptyBraces: space
+#   # The `space` EnforcedStyleForEmptyBraces style enforces that
+#   # empty hash braces contain space.
+#
+#   # bad
+#   foo = {}
+#
+#   # good
+#   foo = { }
+#   foo = {    }
+#   foo = {
+#   }
+#
+# source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#70
+class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#78
+  def on_hash(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#137
+  def ambiguous_or_unexpected_style_detected(style, is_match); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#129
+  def autocorrect(corrector, range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#89
+  def check(token1, token2); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#184
+  def check_whitespace_only_hash(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#202
+  def enforce_no_space_style_for_empty_braces?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#104
+  def expect_space?(token1, token2); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#117
+  def incorrect_style_detected(token1, token2, expect_space, is_empty_braces); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#150
+  def message(brace, is_empty_braces, expect_space); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#145
+  def offense?(token1, expect_space); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#196
+  def range_inside_hash(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#176
+  def range_of_space_to_the_left(range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#168
+  def range_of_space_to_the_right(range); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#160
+  def space_range(token_range); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb#76
+RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for spaces inside ordinary round parentheses.
+#
+# @example EnforcedStyle: no_space (default)
+#   # The `no_space` style enforces that parentheses do not have spaces.
+#
+#   # bad
+#   f( 3)
+#   g = (a + 3 )
+#   f( )
+#
+#   # good
+#   f(3)
+#   g = (a + 3)
+#   f()
+# @example EnforcedStyle: space
+#   # The `space` style enforces that parentheses have a space at the
+#   # beginning and end.
+#   # Note: Empty parentheses should not have spaces.
+#
+#   # bad
+#   f(3)
+#   g = (a + 3)
+#   y( )
+#
+#   # good
+#   f( 3 )
+#   g = ( a + 3 )
+#   y()
+# @example EnforcedStyle: compact
+#   # The `compact` style enforces that parentheses have a space at the
+#   # beginning with the exception that successive parentheses are allowed.
+#   # Note: Empty parentheses should not have spaces.
+#
+#   # bad
+#   f(3)
+#   g = (a + 3)
+#   y( )
+#   g( f( x ) )
+#   g( f( x( 3 ) ), 5 )
+#   g( ( ( 3 + 5 ) * f) ** x, 5 )
+#
+#   # good
+#   f( 3 )
+#   g = ( a + 3 )
+#   y()
+#   g( f( x ))
+#   g( f( x( 3 )), 5 )
+#   g((( 3 + 5 ) * f ) ** x, 5 )
+#
+# source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#57
+class RuboCop::Cop::Layout::SpaceInsideParens < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#66
+  def on_new_investigation; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#161
+  def can_be_ignored?(token1, token2); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#99
+  def correct_extraneous_space(tokens); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#115
+  def correct_extraneous_space_between_consecutive_parens(token1, token2); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#124
+  def correct_extraneous_space_in_empty_parens(token1, token2); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#135
+  def correct_missing_space(token1, token2); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#153
+  def left_parens?(token1, token2); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#149
+  def parens?(token1, token2); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#88
+  def process_with_compact_style(tokens); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#81
+  def process_with_space_style(tokens); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#157
+  def right_parens?(token1, token2); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#63
+RuboCop::Cop::Layout::SpaceInsideParens::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_parens.rb#64
+RuboCop::Cop::Layout::SpaceInsideParens::MSG_SPACE = T.let(T.unsafe(nil), String)
+
+# Checks for unnecessary additional spaces inside the delimiters of
+# %i/%w/%x literals.
+#
+# @example
+#
+#   # bad
+#   %i( foo bar baz )
+#
+#   # good
+#   %i(foo bar baz)
+#
+#   # bad
+#   %w( foo bar baz )
+#
+#   # good
+#   %w(foo bar baz)
+#
+#   # bad
+#   %x(  ls -l )
+#
+#   # good
+#   %x(ls -l)
+#
+#   # bad
+#   %w( )
+#   %w(
+#   )
+#
+#   # good
+#   %w()
+#
+# source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#36
+class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::MatchRange
+  include ::RuboCop::Cop::PercentLiteral
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#45
+  def on_array(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#53
+  def on_percent_literal(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#49
+  def on_xstr(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#60
+  def add_offenses_for_blank_spaces(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#69
+  def add_offenses_for_unnecessary_spaces(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#85
+  def body_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#79
+  def regex_matches(node, &blk); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#42
+RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::BEGIN_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#43
+RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::END_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb#41
+RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for spaces inside range literals.
+#
+# @example
+#   # bad
+#   1 .. 3
+#
+#   # good
+#   1..3
+#
+#   # bad
+#   'a' .. 'z'
+#
+#   # good
+#   'a'..'z'
+#
+# source://rubocop//lib/rubocop/cop/layout/space_inside_range_literal.rb#20
+class RuboCop::Cop::Layout::SpaceInsideRangeLiteral < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_range_literal.rb#29
+  def on_erange(node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_range_literal.rb#25
+  def on_irange(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_range_literal.rb#35
+  def check(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_range_literal.rb#23
+RuboCop::Cop::Layout::SpaceInsideRangeLiteral::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that reference brackets have or don't have
+# surrounding space depending on configuration.
+#
+# @example EnforcedStyle: no_space (default)
+#   # The `no_space` style enforces that reference brackets have
+#   # no surrounding space.
+#
+#   # bad
+#   hash[ :key ]
+#   array[ index ]
+#
+#   # good
+#   hash[:key]
+#   array[index]
+# @example EnforcedStyle: space
+#   # The `space` style enforces that reference brackets have
+#   # surrounding space.
+#
+#   # bad
+#   hash[:key]
+#   array[index]
+#
+#   # good
+#   hash[ :key ]
+#   array[ index ]
+# @example EnforcedStyleForEmptyBrackets: no_space (default)
+#   # The `no_space` EnforcedStyleForEmptyBrackets style enforces that
+#   # empty reference brackets do not contain spaces.
+#
+#   # bad
+#   foo[ ]
+#   foo[     ]
+#   foo[
+#   ]
+#
+#   # good
+#   foo[]
+# @example EnforcedStyleForEmptyBrackets: space
+#   # The `space` EnforcedStyleForEmptyBrackets style enforces that
+#   # empty reference brackets contain exactly one space.
+#
+#   # bad
+#   foo[]
+#   foo[    ]
+#   foo[
+#   ]
+#
+#   # good
+#   foo[ ]
+#
+# source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#60
+class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#70
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#92
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#121
+  def closing_bracket(tokens, opening_bracket); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#137
+  def empty_config; end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#110
+  def left_ref_bracket(node, tokens); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#132
+  def previous_token(current_token); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#104
+  def reference_brackets(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#66
+RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::EMPTY_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#65
+RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_reference_brackets.rb#68
+RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for whitespace within string interpolations.
+#
+# @example EnforcedStyle: no_space (default)
+#   # bad
+#   var = "This is the #{ space } example"
+#
+#   # good
+#   var = "This is the #{no_space} example"
+# @example EnforcedStyle: space
+#   # bad
+#   var = "This is the #{no_space} example"
+#
+#   # good
+#   var = "This is the #{ space } example"
+#
+# source://rubocop//lib/rubocop/cop/layout/space_inside_string_interpolation.rb#21
+class RuboCop::Cop::Layout::SpaceInsideStringInterpolation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Interpolation
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_string_interpolation.rb#30
+  def on_interpolation(begin_node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_string_interpolation.rb#46
+  def autocorrect(corrector, begin_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/space_inside_string_interpolation.rb#56
+  def delimiters(begin_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/space_inside_string_interpolation.rb#28
+RuboCop::Cop::Layout::SpaceInsideStringInterpolation::MSG = T.let(T.unsafe(nil), String)
+
+# Looks for trailing blank lines and a final newline in the
+# source code.
+#
+# @example EnforcedStyle: final_newline (default)
+#   # `final_newline` looks for one newline at the end of files.
+#
+#   # bad
+#   class Foo; end
+#
+#   # EOF
+#
+#   # bad
+#   class Foo; end # EOF
+#
+#   # good
+#   class Foo; end
+#   # EOF
+# @example EnforcedStyle: final_blank_line
+#   # `final_blank_line` looks for one blank line followed by a new line
+#   # at the end of files.
+#
+#   # bad
+#   class Foo; end
+#   # EOF
+#
+#   # bad
+#   class Foo; end # EOF
+#
+#   # good
+#   class Foo; end
+#
+#   # EOF
+#
+# source://rubocop//lib/rubocop/cop/layout/trailing_empty_lines.rb#40
+class RuboCop::Cop::Layout::TrailingEmptyLines < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/trailing_empty_lines.rb#45
+  def on_new_investigation; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/trailing_empty_lines.rb#90
+  def end_with_percent_blank_string?(processed_source); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/trailing_empty_lines.rb#80
+  def ends_in_end?(processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/layout/trailing_empty_lines.rb#94
+  def message(wanted_blank_lines, blank_lines); end
+
+  # source://rubocop//lib/rubocop/cop/layout/trailing_empty_lines.rb#67
+  def offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end); end
+end
+
+# Looks for trailing whitespace in the source code.
+#
+# @example
+#   # The line in this example contains spaces after the 0.
+#   # bad
+#   x = 0
+#
+#   # The line in this example ends directly after the 0.
+#   # good
+#   x = 0
+# @example AllowInHeredoc: false (default)
+#   # The line in this example contains spaces after the 0.
+#   # bad
+#   code = <<~RUBY
+#   x = 0
+#   RUBY
+#
+#   # ok
+#   code = <<~RUBY
+#   x = 0 #{}
+#   RUBY
+#
+#   # good
+#   trailing_whitespace = ' '
+#   code = <<~RUBY
+#   x = 0#{trailing_whitespace}
+#   RUBY
+# @example AllowInHeredoc: true
+#   # The line in this example contains spaces after the 0.
+#   # good
+#   code = <<~RUBY
+#   x = 0
+#   RUBY
+#
+# source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#42
+class RuboCop::Cop::Layout::TrailingWhitespace < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::Heredoc
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#57
+  def on_heredoc(_node); end
+
+  # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#49
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#112
+  def extract_heredocs(ast); end
+
+  # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#103
+  def find_heredoc(line_number); end
+
+  # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#108
+  def heredocs; end
+
+  # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#125
+  def offense_range(lineno, line); end
+
+  # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#61
+  def process_line(line, lineno); end
+
+  # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#75
+  def process_line_in_heredoc(corrector, range, heredoc); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#99
+  def skip_heredoc?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#95
+  def static?(heredoc); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#86
+  def whitespace_is_indentation?(range, level); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#90
+  def whitespace_only?(range); end
+end
+
+# source://rubocop//lib/rubocop/cop/layout/trailing_whitespace.rb#47
+RuboCop::Cop::Layout::TrailingWhitespace::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#5
+module RuboCop::Cop::Legacy; end
+
+# Legacy support for Corrector#corrections
+# See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
+#
+# source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#8
+class RuboCop::Cop::Legacy::CorrectionsProxy
+  # @return [CorrectionsProxy] a new instance of CorrectionsProxy
+  #
+  # source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#9
+  def initialize(corrector); end
+
+  # source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#13
+  def <<(callable); end
+
+  # source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#21
+  def concat(corrections); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#17
+  def empty?; end
+
+  protected
+
+  # Returns the value of attribute corrector.
+  #
+  # source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#31
+  def corrector; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/legacy/corrections_proxy.rb#35
+  def suppress_clobbering; end
+end
+
+# This class handles autocorrection for code that needs to be moved
+# to new lines.
+#
+# source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#7
+class RuboCop::Cop::LineBreakCorrector
+  extend ::RuboCop::Cop::Alignment
+  extend ::RuboCop::Cop::TrailingBody
+  extend ::RuboCop::PathUtil
+  extend ::RuboCop::Cop::Util
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#27
+    def break_line_before(range:, node:, corrector:, configured_width:, indent_steps: T.unsafe(nil)); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#15
+    def correct_trailing_body(configured_width:, corrector:, node:, processed_source:); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#35
+    def move_comment(eol_comment:, node:, corrector:); end
+
+    # Returns the value of attribute processed_source.
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#13
+    def processed_source; end
+
+    private
+
+    # source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#45
+    def remove_semicolon(node, corrector); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#51
+    def semicolon(node); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/line_break_corrector.rb#60
+    def trailing_class_definition?(token, body); end
+  end
+end
+
+# Help methods for determining if a line is too long.
+#
+# source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#6
+module RuboCop::Cop::LineLengthHelp
+  include ::RuboCop::Cop::Alignment
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#24
+  def allow_uri?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#28
+  def allowed_uri_position?(line, uri_range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#15
+  def directive_on_source_line?(line_index); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#72
+  def extend_uri_end_position(line, end_position); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#36
+  def find_excessive_uri_range(line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#11
+  def ignore_cop_directives?; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#59
+  def indentation_difference(line); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#32
+  def line_length(line); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#110
+  def line_length_without_directive(line); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#51
+  def match_uris(string); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#88
+  def tab_indentation_width; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#93
+  def uri_regexp; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/line_length_help.rb#103
+  def valid_uri?(uri_ish_string); end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/unused_argument.rb#5
+module RuboCop::Cop::Lint; end
+
+# Checks for mistyped shorthand assignments.
+#
+# @example
+#   # bad
+#   x =- y
+#   x =+ y
+#   x =* y
+#   x =! y
+#
+#   # good
+#   x -= y # or x = -y
+#   x += y # or x = +y
+#   x *= y # or x = *y
+#   x != y # or x = !y
+#
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#21
+class RuboCop::Cop::Lint::AmbiguousAssignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#30
+  def on_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#30
+  def on_casgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#30
+  def on_cvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#30
+  def on_gvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#30
+  def on_ivasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#30
+  def on_lvasgn(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#44
+  def rhs(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#28
+RuboCop::Cop::Lint::AmbiguousAssignment::MISTAKES = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#24
+RuboCop::Cop::Lint::AmbiguousAssignment::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_assignment.rb#26
+RuboCop::Cop::Lint::AmbiguousAssignment::SIMPLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
+
+# Checks for ambiguous block association with method
+# when param passed without parentheses.
+#
+# This cop can customize allowed methods with `AllowedMethods`.
+# By default, there are no methods to allowed.
+#
+# @example
+#
+#   # bad
+#   some_method a { |val| puts val }
+#
+#   # good
+#   # With parentheses, there's no ambiguity.
+#   some_method(a { |val| puts val })
+#   # or (different meaning)
+#   some_method(a) { |val| puts val }
+#
+#   # good
+#   # Operator methods require no disambiguation
+#   foo == bar { |b| b.baz }
+#
+#   # good
+#   # Lambda arguments require no disambiguation
+#   foo = ->(bar) { bar.baz }
+# @example AllowedMethods: [] (default)
+#
+#   # bad
+#   expect { do_something }.to change { object.attribute }
+# @example AllowedMethods: [change]
+#
+#   # good
+#   expect { do_something }.to change { object.attribute }
+# @example AllowedPatterns: [] (default)
+#
+#   # bad
+#   expect { do_something }.to change { object.attribute }
+# @example AllowedPatterns: ['change']
+#
+#   # good
+#   expect { do_something }.to change { object.attribute }
+#   expect { do_something }.to not_change { object.attribute }
+#
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#52
+class RuboCop::Cop::Lint::AmbiguousBlockAssociation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#62
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#62
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#83
+  def allowed_method_pattern?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#79
+  def ambiguous_block_association?(send_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#89
+  def message(send_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#95
+  def wrap_in_parentheses(corrector, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_block_association.rb#58
+RuboCop::Cop::Lint::AmbiguousBlockAssociation::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for ambiguous operators in the first argument of a
+# method invocation without parentheses.
+#
+# @example
+#
+#   # bad
+#
+#   # The `*` is interpreted as a splat operator but it could possibly be
+#   # a `*` method invocation (i.e. `do_something.*(some_array)`).
+#   do_something *some_array
+#
+#   # good
+#
+#   # With parentheses, there's no ambiguity.
+#   do_something(*some_array)
+#
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#21
+class RuboCop::Cop::Lint::AmbiguousOperator < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#43
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#62
+  def find_offense_node_by(diagnostic); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#80
+  def message(diagnostic); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#90
+  def offense_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#86
+  def offense_position?(node, diagnostic); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#99
+  def unary_operator?(node, diagnostic); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#39
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#24
+RuboCop::Cop::Lint::AmbiguousOperator::AMBIGUITIES = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_operator.rb#34
+RuboCop::Cop::Lint::AmbiguousOperator::MSG_FORMAT = T.let(T.unsafe(nil), String)
+
+# Looks for expressions containing multiple binary operators
+# where precedence is ambiguous due to lack of parentheses. For example,
+# in `1 + 2 * 3`, the multiplication will happen before the addition, but
+# lexically it appears that the addition will happen first.
+#
+# The cop does not consider unary operators (ie. `!a` or `-b`) or comparison
+# operators (ie. `a =~ b`) because those are not ambiguous.
+#
+# NOTE: Ranges are handled by `Lint/AmbiguousRange`.
+#
+# @example
+#   # bad
+#   a + b * c
+#   a || b && c
+#   a ** b + c
+#
+#   # good (different precedence)
+#   a + (b * c)
+#   a || (b && c)
+#   (a ** b) + c
+#
+#   # good (same precedence)
+#   a + b + c
+#   a * b / c % d
+#
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#30
+class RuboCop::Cop::Lint::AmbiguousOperatorPrecedence < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#54
+  def on_and(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#47
+  def on_new_investigation; end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#65
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#105
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#89
+  def greater_precedence?(node1, node2); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#85
+  def operator?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#97
+  def operator_name(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#79
+  def precedence(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#45
+RuboCop::Cop::Lint::AmbiguousOperatorPrecedence::MSG = T.let(T.unsafe(nil), String)
+
+# See https://ruby-doc.org/core-3.0.2/doc/syntax/precedence_rdoc.html
+#
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#34
+RuboCop::Cop::Lint::AmbiguousOperatorPrecedence::PRECEDENCE = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_operator_precedence.rb#44
+RuboCop::Cop::Lint::AmbiguousOperatorPrecedence::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for ambiguous ranges.
+#
+# Ranges have quite low precedence, which leads to unexpected behavior when
+# using a range with other operators. This cop avoids that by making ranges
+# explicit by requiring parenthesis around complex range boundaries (anything
+# that is not a literal: numerics, strings, symbols, etc.).
+#
+# This cop can be configured with `RequireParenthesesForMethodChains` in order to
+# specify whether method chains (including `self.foo`) should be wrapped in parens
+# by this cop.
+#
+# NOTE: Regardless of this configuration, if a method receiver is a basic literal
+# value, it will be wrapped in order to prevent the ambiguity of `1..2.to_a`.
+#
+# @example
+#   # bad
+#   x || 1..2
+#   (x || 1..2)
+#   1..2.to_a
+#
+#   # good, unambiguous
+#   1..2
+#   'a'..'z'
+#   :bar..:baz
+#   MyClass::MIN..MyClass::MAX
+#   @min..@max
+#   a..b
+#   -a..b
+#
+#   # good, ambiguity removed
+#   x || (1..2)
+#   (x || 1)..2
+#   (x || 1)..(y || 2)
+#   (1..2).to_a
+# @example RequireParenthesesForMethodChains: false (default)
+#   # good
+#   a.foo..b.bar
+#   (a.foo)..(b.bar)
+# @example RequireParenthesesForMethodChains: true
+#   # bad
+#   a.foo..b.bar
+#
+#   # good
+#   (a.foo)..(b.bar)
+#
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#59
+class RuboCop::Cop::Lint::AmbiguousRange < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RationalLiteral
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#65
+  def on_erange(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#65
+  def on_irange(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#84
+  def acceptable?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#92
+  def acceptable_call?(node); end
+
+  # @yield [range.begin]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#78
+  def each_boundary(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#102
+  def require_parentheses_for_method_chain?; end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_range.rb#63
+RuboCop::Cop::Lint::AmbiguousRange::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for ambiguous regexp literals in the first argument of
+# a method invocation without parentheses.
+#
+# @example
+#
+#   # bad
+#
+#   # This is interpreted as a method invocation with a regexp literal,
+#   # but it could possibly be `/` method invocations.
+#   # (i.e. `do_something./(pattern)./(i)`)
+#   do_something /pattern/i
+#
+#   # good
+#
+#   # With parentheses, there's no ambiguity.
+#   do_something(/pattern/i)
+#
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_regexp_literal.rb#22
+class RuboCop::Cop::Lint::AmbiguousRegexpLiteral < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_regexp_literal.rb#29
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_regexp_literal.rb#54
+  def find_offense_node(node, regexp_receiver); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_regexp_literal.rb#47
+  def find_offense_node_by(diagnostic); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_regexp_literal.rb#65
+  def first_argument_is_regexp?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/ambiguous_regexp_literal.rb#69
+  def method_chain_to_regexp_receiver?(node, regexp_receiver); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/ambiguous_regexp_literal.rb#25
+RuboCop::Cop::Lint::AmbiguousRegexpLiteral::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for assignments in the conditions of
+# if/while/until.
+#
+# `AllowSafeAssignment` option for safe assignment.
+# By safe assignment we mean putting parentheses around
+# an assignment to indicate "I know I'm using an assignment
+# as a condition. It's not a mistake."
+#
+# @example
+#   # bad
+#   if some_var = value
+#   do_something
+#   end
+#
+#   # good
+#   if some_var == value
+#   do_something
+#   end
+# @example AllowSafeAssignment: true (default)
+#   # good
+#   if (some_var = value)
+#   do_something
+#   end
+# @example AllowSafeAssignment: false
+#   # bad
+#   if (some_var = value)
+#   do_something
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#41
+class RuboCop::Cop::Lint::AssignmentInCondition < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::SafeAssignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#55
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#55
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#55
+  def on_while(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#82
+  def allowed_construct?(asgn_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#86
+  def conditional_assignment?(asgn_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#74
+  def message(_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#90
+  def skip_children?(asgn_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#96
+  def traverse_node(node, &block); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#53
+RuboCop::Cop::Lint::AssignmentInCondition::ASGN_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#50
+RuboCop::Cop::Lint::AssignmentInCondition::MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/assignment_in_condition.rb#46
+RuboCop::Cop::Lint::AssignmentInCondition::MSG_WITH_SAFE_ASSIGNMENT_ALLOWED = T.let(T.unsafe(nil), String)
+
+# `BigDecimal.new()` is deprecated since BigDecimal 1.3.3.
+# This cop identifies places where `BigDecimal.new()`
+# can be replaced by `BigDecimal()`.
+#
+# @example
+#   # bad
+#   BigDecimal.new(123.456, 3)
+#
+#   # good
+#   BigDecimal(123.456, 3)
+#
+# source://rubocop//lib/rubocop/cop/lint/big_decimal_new.rb#17
+class RuboCop::Cop::Lint::BigDecimalNew < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/big_decimal_new.rb#24
+  def big_decimal_new(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/big_decimal_new.rb#29
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/big_decimal_new.rb#20
+RuboCop::Cop::Lint::BigDecimalNew::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/big_decimal_new.rb#21
+RuboCop::Cop::Lint::BigDecimalNew::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for places where binary operator has identical operands.
+#
+# It covers arithmetic operators: `-`, `/`, `%`;
+# comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, ``<=``;
+# bitwise operators: `|`, `^`, `&`;
+# boolean operators: `&&`, `||`
+# and "spaceship" operator - ``<=>``.
+#
+# Simple arithmetic operations are allowed by this cop: `+`, `*`, `**`, `<<` and `>>`.
+# Although these can be rewritten in a different way, it should not be necessary to
+# do so. This does not include operations such as `-` or `/` where the result will
+# always be the same (`x - x` will always be 0; `x / x` will always be 1), and
+# thus are legitimate offenses.
+#
+# @example
+#   # bad
+#   x / x
+#   x.top >= x.top
+#
+#   if a.x != 0 && a.x != 0
+#   do_something
+#   end
+#
+#   def child?
+#   left_child || left_child
+#   end
+#
+#   # good
+#   x + x
+#   1 << 1
+#
+# source://rubocop//lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb#48
+class RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb#61
+  def on_and(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb#61
+  def on_or(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb#52
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb#50
+RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands::ALLOWED_MATH_OPERATORS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb#49
+RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for `:true` and `:false` symbols.
+# In most cases it would be a typo.
+#
+# @example
+#
+#   # bad
+#   :true
+#
+#   # good
+#   true
+#
+#   # bad
+#   :false
+#
+#   # good
+#   false
+#
+# source://rubocop//lib/rubocop/cop/lint/boolean_symbol.rb#27
+class RuboCop::Cop::Lint::BooleanSymbol < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/boolean_symbol.rb#33
+  def boolean_symbol?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/boolean_symbol.rb#35
+  def on_sym(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/boolean_symbol.rb#48
+  def autocorrect(corrector, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/boolean_symbol.rb#30
+RuboCop::Cop::Lint::BooleanSymbol::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for circular argument references in optional keyword
+# arguments and optional ordinal arguments.
+#
+# This cop mirrors a warning produced by MRI since 2.2.
+#
+# @example
+#
+#   # bad
+#   def bake(pie: pie)
+#   pie.heat_up
+#   end
+#
+#   # good
+#   def bake(pie:)
+#   pie.refrigerate
+#   end
+#
+#   # good
+#   def bake(pie: self.pie)
+#   pie.feed_to(user)
+#   end
+#
+#   # bad
+#   def cook(dry_ingredients = dry_ingredients)
+#   dry_ingredients.reduce(&:+)
+#   end
+#
+#   # good
+#   def cook(dry_ingredients = self.dry_ingredients)
+#   dry_ingredients.combine
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/circular_argument_reference.rb#37
+class RuboCop::Cop::Lint::CircularArgumentReference < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/circular_argument_reference.rb#40
+  def on_kwoptarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/circular_argument_reference.rb#44
+  def on_optarg(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/circular_argument_reference.rb#50
+  def check_for_circular_argument_references(arg_name, arg_value); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/circular_argument_reference.rb#38
+RuboCop::Cop::Lint::CircularArgumentReference::MSG = T.let(T.unsafe(nil), String)
+
+# Do not define constants within a block, since the block's scope does not
+# isolate or namespace the constant in any way.
+#
+# If you are trying to define that constant once, define it outside of
+# the block instead, or use a variable or method if defining the constant
+# in the outer scope would be problematic.
+#
+# For meta-programming, use `const_set`.
+#
+# @example
+#   # bad
+#   task :lint do
+#   FILES_TO_LINT = Dir['lib/*.rb']
+#   end
+#
+#   # bad
+#   describe 'making a request' do
+#   class TestRequest; end
+#   end
+#
+#   # bad
+#   module M
+#   extend ActiveSupport::Concern
+#   included do
+#   LIST = []
+#   end
+#   end
+#
+#   # good
+#   task :lint do
+#   files_to_lint = Dir['lib/*.rb']
+#   end
+#
+#   # good
+#   describe 'making a request' do
+#   let(:test_request) { Class.new }
+#   # see also `stub_const` for RSpec
+#   end
+#
+#   # good
+#   module M
+#   extend ActiveSupport::Concern
+#   included do
+#   const_set(:LIST, [])
+#   end
+#   end
+# @example AllowedMethods: ['enums'] (default)
+#   # good
+#
+#   # `enums` for Typed Enums via `T::Enum` in Sorbet.
+#   # https://sorbet.org/docs/tenum
+#   class TestEnum < T::Enum
+#   enums do
+#   Foo = new("foo")
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#64
+class RuboCop::Cop::Lint::ConstantDefinitionInBlock < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+
+  # source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#70
+  def constant_assigned_in_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#75
+  def module_defined_in_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#79
+  def on_casgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#85
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#85
+  def on_module(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#94
+  def method_name(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/constant_definition_in_block.rb#67
+RuboCop::Cop::Lint::ConstantDefinitionInBlock::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for overwriting an exception with an exception result by use ``rescue =>``.
+#
+# You intended to write as `rescue StandardError`.
+# However, you have written `rescue => StandardError`.
+# In that case, the result of `rescue` will overwrite `StandardError`.
+#
+# @example
+#
+#   # bad
+#   begin
+#   something
+#   rescue => StandardError
+#   end
+#
+#   # good
+#   begin
+#   something
+#   rescue StandardError
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb#26
+class RuboCop::Cop::Lint::ConstantOverwrittenInRescue < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb#41
+  def on_resbody(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb#33
+  def overwritten_constant(param0 = T.unsafe(nil)); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb#37
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb#30
+RuboCop::Cop::Lint::ConstantOverwrittenInRescue::MSG = T.let(T.unsafe(nil), String)
+
+# Check that certain constants are fully qualified.
+#
+# This is not enabled by default because it would mark a lot of offenses
+# unnecessarily.
+#
+# Generally, gems should fully qualify all constants to avoid conflicts with
+# the code that uses the gem. Enable this cop without using `Only`/`Ignore`
+#
+# Large projects will over time end up with one or two constant names that
+# are problematic because of a conflict with a library or just internally
+# using the same name a namespace and a class. To avoid too many unnecessary
+# offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
+#
+# NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled to prevent
+# conflicting rules. Because it respects user configurations that want to enable
+# this cop which is disabled by default.
+#
+# @example
+#   # By default checks every constant
+#
+#   # bad
+#   User
+#
+#   # bad
+#   User::Login
+#
+#   # good
+#   ::User
+#
+#   # good
+#   ::User::Login
+# @example Only: ['Login']
+#   # Restrict this cop to only being concerned about certain constants
+#
+#   # bad
+#   Login
+#
+#   # good
+#   ::Login
+#
+#   # good
+#   User::Login
+# @example Ignore: ['Login']
+#   # Restrict this cop not being concerned about certain constants
+#
+#   # bad
+#   User
+#
+#   # good
+#   ::User::Login
+#
+#   # good
+#   Login
+#
+# source://rubocop//lib/rubocop/cop/lint/constant_resolution.rb#62
+class RuboCop::Cop::Lint::ConstantResolution < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/constant_resolution.rb#70
+  def on_const(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/constant_resolution.rb#66
+  def unqualified_const?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/constant_resolution.rb#83
+  def allowed_names; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/constant_resolution.rb#78
+  def const_name?(name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/constant_resolution.rb#87
+  def ignored_names; end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/constant_resolution.rb#63
+RuboCop::Cop::Lint::ConstantResolution::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for debug calls (such as `debugger` or `binding.pry`) that should
+# not be kept for production code.
+#
+# The cop can be configured using `DebuggerMethods`. By default, a number of gems
+# debug entrypoints are configured (`Kernel`, `Byebug`, `Capybara`, `debug.rb`,
+# `Pry`, `Rails`, `RubyJard`, and `WebConsole`). Additional methods can be added.
+#
+# Specific default groups can be disabled if necessary:
+#
+# [source,yaml]
+# ----
+# Lint/Debugger:
+#   DebuggerMethods:
+#     WebConsole: ~
+# ----
+#
+# You can also add your own methods by adding a new category:
+#
+# [source,yaml]
+# ----
+# Lint/Debugger:
+#   DebuggerMethods:
+#     MyDebugger:
+#       MyDebugger.debug_this
+# ----
+#
+# Some gems also ship files that will start a debugging session when required,
+# for example `require 'debug/start'` from `ruby/debug`. These requires can
+# be configured through `DebuggerRequires`. It has the same structure as
+# `DebuggerMethods`, which you can read about above.
+#
+# @example
+#
+#   # bad (ok during development)
+#
+#   # using pry
+#   def some_method
+#   binding.pry
+#   do_something
+#   end
+#
+#   # bad (ok during development)
+#
+#   # using byebug
+#   def some_method
+#   byebug
+#   do_something
+#   end
+#
+#   # good
+#
+#   def some_method
+#   do_something
+#   end
+# @example DebuggerMethods: [my_debugger]
+#
+#   # bad (ok during development)
+#
+#   def some_method
+#   my_debugger
+#   end
+# @example DebuggerRequires: [my_debugger/start]
+#
+#   # bad (ok during development)
+#
+#   require 'my_debugger/start'
+#
+# source://rubocop//lib/rubocop/cop/lint/debugger.rb#74
+class RuboCop::Cop::Lint::Debugger < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/debugger.rb#78
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/debugger.rb#138
+  def assumed_argument?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/debugger.rb#117
+  def assumed_usage_context?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/debugger.rb#127
+  def chained_method_name(send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/debugger.rb#104
+  def debugger_method?(send_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/debugger.rb#90
+  def debugger_methods; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/debugger.rb#110
+  def debugger_require?(send_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/debugger.rb#97
+  def debugger_requires; end
+
+  # source://rubocop//lib/rubocop/cop/lint/debugger.rb#86
+  def message(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/debugger.rb#76
+RuboCop::Cop::Lint::Debugger::BLOCK_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/debugger.rb#75
+RuboCop::Cop::Lint::Debugger::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for uses of the deprecated class method usages.
+#
+# @example
+#
+#   # bad
+#   File.exists?(some_path)
+#   Dir.exists?(some_path)
+#   iterator?
+#   attr :name, true
+#   attr :name, false
+#   ENV.freeze # Calling `Env.freeze` raises `TypeError` since Ruby 2.7.
+#   ENV.clone
+#   ENV.dup # Calling `Env.dup` raises `TypeError` since Ruby 3.1.
+#   Socket.gethostbyname(host)
+#   Socket.gethostbyaddr(host)
+#
+#   # good
+#   File.exist?(some_path)
+#   Dir.exist?(some_path)
+#   block_given?
+#   attr_accessor :name
+#   attr_reader :name
+#   ENV # `ENV.freeze` cannot prohibit changes to environment variables.
+#   ENV.to_h
+#   ENV.to_h # `ENV.dup` cannot dup `ENV`, use `ENV.to_h` to get a copy of `ENV` as a hash.
+#   Addrinfo.getaddrinfo(nodename, service)
+#   Addrinfo.tcp(host, port).getnameinfo
+#
+# source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#33
+class RuboCop::Cop::Lint::DeprecatedClassMethods < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#53
+  def deprecated_class_method?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#63
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#112
+  def dir_env_file_const?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#83
+  def offense_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#93
+  def preferred_method(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#108
+  def socket_const?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#50
+RuboCop::Cop::Lint::DeprecatedClassMethods::DIR_ENV_FILE_CONSTANTS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#36
+RuboCop::Cop::Lint::DeprecatedClassMethods::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#41
+RuboCop::Cop::Lint::DeprecatedClassMethods::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/lint/deprecated_class_methods.rb#37
+RuboCop::Cop::Lint::DeprecatedClassMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for deprecated constants.
+#
+# It has `DeprecatedConstants` config. If there is an alternative method, you can set
+# alternative value as `Alternative`. And you can set the deprecated version as
+# `DeprecatedVersion`. These options can be omitted if they are not needed.
+#
+#   DeprecatedConstants:
+#     'DEPRECATED_CONSTANT':
+#       Alternative: 'alternative_value'
+#       DeprecatedVersion: 'deprecated_version'
+#
+# By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException, `Random::DEFAULT`,
+# `Struct::Group`, and `Struct::Passwd` are configured.
+#
+# @example
+#
+#   # bad
+#   NIL
+#   TRUE
+#   FALSE
+#   Net::HTTPServerException
+#   Random::DEFAULT # Return value of Ruby 2 is `Random` instance, Ruby 3.0 is `Random` class.
+#   Struct::Group
+#   Struct::Passwd
+#
+#   # good
+#   nil
+#   true
+#   false
+#   Net::HTTPClientException
+#   Random.new # `::DEFAULT` has been deprecated in Ruby 3, `.new` is compatible with Ruby 2.
+#   Etc::Group
+#   Etc::Passwd
+#
+# source://rubocop//lib/rubocop/cop/lint/deprecated_constants.rb#40
+class RuboCop::Cop::Lint::DeprecatedConstants < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_constants.rb#46
+  def on_const(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_constants.rb#66
+  def constant_name(node, nested_constant_name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_constants.rb#82
+  def deprecated_constants; end
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_constants.rb#72
+  def message(good, bad, deprecated_version); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/deprecated_constants.rb#44
+RuboCop::Cop::Lint::DeprecatedConstants::DO_NOT_USE_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/deprecated_constants.rb#43
+RuboCop::Cop::Lint::DeprecatedConstants::SUGGEST_GOOD_MSG = T.let(T.unsafe(nil), String)
+
+# Algorithmic constants for `OpenSSL::Cipher` and `OpenSSL::Digest`
+# deprecated since OpenSSL version 2.2.0. Prefer passing a string
+# instead.
+#
+# @example
+#
+#   # bad
+#   OpenSSL::Cipher::AES.new(128, :GCM)
+#
+#   # good
+#   OpenSSL::Cipher.new('aes-128-gcm')
+#
+#   # bad
+#   OpenSSL::Digest::SHA256.new
+#
+#   # good
+#   OpenSSL::Digest.new('SHA256')
+#
+#   # bad
+#   OpenSSL::Digest::SHA256.digest('foo')
+#
+#   # good
+#   OpenSSL::Digest.digest('SHA256', 'foo')
+#
+# source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#30
+class RuboCop::Cop::Lint::DeprecatedOpenSSLConstant < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#39
+  def algorithm_const(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#49
+  def digest_const?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#53
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#100
+  def algorithm_name(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#65
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#129
+  def build_cipher_arguments(node, algorithm_name, no_arguments); end
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#92
+  def correction_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#77
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#96
+  def openssl_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#118
+  def replacement_args(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#110
+  def sanitize_arguments(arguments); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#34
+RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb#36
+RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::NO_ARG_ALGORITHM = T.let(T.unsafe(nil), Array)
+
+# Checks constructors for disjunctive assignments (`||=`) that should
+# be plain assignments.
+#
+# So far, this cop is only concerned with disjunctive assignment of
+# instance variables.
+#
+# In ruby, an instance variable is nil until a value is assigned, so the
+# disjunction is unnecessary. A plain assignment has the same effect.
+#
+# @example
+#   # bad
+#   def initialize
+#   @x ||= 1
+#   end
+#
+#   # good
+#   def initialize
+#   @x = 1
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb#48
+class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb#53
+  def on_def(node); end
+
+  private
+
+  # @param node [DefNode] a constructor definition
+  #
+  # source://rubocop//lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb#60
+  def check(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb#66
+  def check_body(body); end
+
+  # @param lines [Array] the logical lines of the constructor
+  #
+  # source://rubocop//lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb#78
+  def check_body_lines(lines); end
+
+  # Add an offense if the LHS of the given disjunctive assignment is
+  # an instance variable.
+  #
+  # For now, we only care about assignments to instance variables.
+  #
+  # @param node [Node] a disjunctive assignment
+  #
+  # source://rubocop//lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb#99
+  def check_disjunctive_assignment(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb#51
+RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that there are no repeated bodies
+# within `if/unless`, `case-when`, `case-in` and `rescue` constructs.
+#
+# With `IgnoreLiteralBranches: true`, branches are not registered
+# as offenses if they return a basic literal value (string, symbol,
+# integer, float, rational, complex, `true`, `false`, or `nil`), or
+# return an array, hash, regexp or range that only contains one of
+# the above basic literal values.
+#
+# With `IgnoreConstantBranches: true`, branches are not registered
+# as offenses if they return a constant value.
+#
+# @example
+#   # bad
+#   if foo
+#   do_foo
+#   do_something_else
+#   elsif bar
+#   do_foo
+#   do_something_else
+#   end
+#
+#   # good
+#   if foo || bar
+#   do_foo
+#   do_something_else
+#   end
+#
+#   # bad
+#   case x
+#   when foo
+#   do_foo
+#   when bar
+#   do_foo
+#   else
+#   do_something_else
+#   end
+#
+#   # good
+#   case x
+#   when foo, bar
+#   do_foo
+#   else
+#   do_something_else
+#   end
+#
+#   # bad
+#   begin
+#   do_something
+#   rescue FooError
+#   handle_error
+#   rescue BarError
+#   handle_error
+#   end
+#
+#   # good
+#   begin
+#   do_something
+#   rescue FooError, BarError
+#   handle_error
+#   end
+# @example IgnoreLiteralBranches: true
+#   # good
+#   case size
+#   when "small" then 100
+#   when "medium" then 250
+#   when "large" then 1000
+#   else 250
+#   end
+# @example IgnoreConstantBranches: true
+#   # good
+#   case size
+#   when "small" then SMALL_SIZE
+#   when "medium" then MEDIUM_SIZE
+#   when "large" then LARGE_SIZE
+#   else MEDIUM_SIZE
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#86
+class RuboCop::Cop::Lint::DuplicateBranch < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#89
+  def on_branching_statement(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#89
+  def on_case(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#89
+  def on_case_match(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#89
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#89
+  def on_rescue(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#117
+  def branches(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#121
+  def consider_branch?(branch); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#147
+  def const_branch?(branch); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#132
+  def ignore_constant_branches?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#128
+  def ignore_literal_branches?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#136
+  def literal_branch?(branch); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#103
+  def offense_range(duplicate_branch); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_branch.rb#87
+RuboCop::Cop::Lint::DuplicateBranch::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that there are no repeated conditions
+# used in case 'when' expressions.
+#
+# @example
+#
+#   # bad
+#   case x
+#   when 'first'
+#   do_something
+#   when 'first'
+#   do_something_else
+#   end
+#
+#   # good
+#   case x
+#   when 'first'
+#   do_something
+#   when 'second'
+#   do_something_else
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/duplicate_case_condition.rb#26
+class RuboCop::Cop::Lint::DuplicateCaseCondition < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_case_condition.rb#29
+  def on_case(case_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_case_condition.rb#27
+RuboCop::Cop::Lint::DuplicateCaseCondition::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that there are no repeated conditions used in if 'elsif'.
+#
+# @example
+#   # bad
+#   if x == 1
+#   do_something
+#   elsif x == 1
+#   do_something_else
+#   end
+#
+#   # good
+#   if x == 1
+#   do_something
+#   elsif x == 2
+#   do_something_else
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/duplicate_elsif_condition.rb#23
+class RuboCop::Cop::Lint::DuplicateElsifCondition < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_elsif_condition.rb#26
+  def on_if(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_elsif_condition.rb#24
+RuboCop::Cop::Lint::DuplicateElsifCondition::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for duplicated keys in hash literals.
+# This cop considers both primitive types and constants for the hash keys.
+#
+# This cop mirrors a warning in Ruby 2.2.
+#
+# @example
+#
+#   # bad
+#   hash = { food: 'apple', food: 'orange' }
+#
+#   # good
+#   hash = { food: 'apple', other_food: 'orange' }
+#
+# source://rubocop//lib/rubocop/cop/lint/duplicate_hash_key.rb#18
+class RuboCop::Cop::Lint::DuplicateHashKey < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Duplication
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_hash_key.rb#23
+  def on_hash(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_hash_key.rb#21
+RuboCop::Cop::Lint::DuplicateHashKey::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for duplicated magic comments.
+#
+# @example
+#
+#   # bad
+#
+#   # encoding: ascii
+#   # encoding: ascii
+#
+#   # good
+#
+#   # encoding: ascii
+#
+#   # bad
+#
+#   # frozen_string_literal: true
+#   # frozen_string_literal: true
+#
+#   # good
+#
+#   # frozen_string_literal: true
+#
+# source://rubocop//lib/rubocop/cop/lint/duplicate_magic_comment.rb#28
+class RuboCop::Cop::Lint::DuplicateMagicComment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::FrozenStringLiteral
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_magic_comment.rb#35
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_magic_comment.rb#51
+  def magic_comment_lines; end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_magic_comment.rb#65
+  def register_offense(range); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_magic_comment.rb#33
+RuboCop::Cop::Lint::DuplicateMagicComment::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that there are no repeated patterns used in `in` keywords.
+#
+# @example
+#
+#   # bad
+#   case x
+#   in 'first'
+#   do_something
+#   in 'first'
+#   do_something_else
+#   end
+#
+#   # good
+#   case x
+#   in 'first'
+#   do_something
+#   in 'second'
+#   do_something_else
+#   end
+#
+#   # bad - repeated alternate patterns with the same conditions don't depend on the order
+#   case x
+#   in foo | bar
+#   first_method
+#   in bar | foo
+#   second_method
+#   end
+#
+#   # good
+#   case x
+#   in foo | bar
+#   first_method
+#   in bar | baz
+#   second_method
+#   end
+#
+#   # bad - repeated hash patterns with the same conditions don't depend on the order
+#   case x
+#   in foo: a, bar: b
+#   first_method
+#   in bar: b, foo: a
+#   second_method
+#   end
+#
+#   # good
+#   case x
+#   in foo: a, bar: b
+#   first_method
+#   in bar: b, baz: c
+#   second_method
+#   end
+#
+#   # bad - repeated array patterns with elements in the same order
+#   case x
+#   in [foo, bar]
+#   first_method
+#   in [foo, bar]
+#   second_method
+#   end
+#
+#   # good
+#   case x
+#   in [foo, bar]
+#   first_method
+#   in [bar, foo]
+#   second_method
+#   end
+#
+#   # bad - repeated the same patterns and guard conditions
+#   case x
+#   in foo if bar
+#   first_method
+#   in foo if bar
+#   second_method
+#   end
+#
+#   # good
+#   case x
+#   in foo if bar
+#   first_method
+#   in foo if baz
+#   second_method
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/duplicate_match_pattern.rb#90
+class RuboCop::Cop::Lint::DuplicateMatchPattern < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_match_pattern.rb#97
+  def on_case_match(case_node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_match_pattern.rb#108
+  def pattern_identity(pattern); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_match_pattern.rb#93
+RuboCop::Cop::Lint::DuplicateMatchPattern::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for duplicated instance (or singleton) method
+# definitions.
+#
+# @example
+#
+#   # bad
+#   def foo
+#   1
+#   end
+#
+#   def foo
+#   2
+#   end
+#
+#   # bad
+#   def foo
+#   1
+#   end
+#
+#   alias foo bar
+#
+#   # good
+#   def foo
+#   1
+#   end
+#
+#   def bar
+#   2
+#   end
+#
+#   # good
+#   def foo
+#   1
+#   end
+#
+#   alias bar foo
+#
+# source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#42
+class RuboCop::Cop::Lint::DuplicateMethods < ::RuboCop::Cop::Base
+  # @return [DuplicateMethods] a new instance of DuplicateMethods
+  #
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#47
+  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#88
+  def alias_method?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#75
+  def method_alias?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#79
+  def on_alias(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#53
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#62
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#94
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#93
+  def sym_name(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#107
+  def check_const_receiver(node, name, const_name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#114
+  def check_self_receiver(node, name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#198
+  def found_attr(node, args, readable: T.unsafe(nil), writable: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#126
+  def found_instance_method(node, name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#149
+  def found_method(node, method_name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#139
+  def found_sclass_method(node, name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#176
+  def location(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#208
+  def lookup_constant(node, const_name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#121
+  def message_for_dup(node, method_name, key); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#168
+  def method_key(node, method_name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#184
+  def on_attr(node, attr_name, args); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#240
+  def possible_dsl?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#226
+  def qualified_name(enclosing, namespace, mod_name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#250
+  def source_location(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#45
+RuboCop::Cop::Lint::DuplicateMethods::DEF_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#43
+RuboCop::Cop::Lint::DuplicateMethods::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_methods.rb#44
+RuboCop::Cop::Lint::DuplicateMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for duplicate elements in Regexp character classes.
+#
+# @example
+#
+#   # bad
+#   r = /[xyx]/
+#
+#   # bad
+#   r = /[0-9x0-9]/
+#
+#   # good
+#   r = /[xy]/
+#
+#   # good
+#   r = /[0-9x]/
+#
+# source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#21
+class RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#37
+  def each_repeated_character_class_element_loc(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#29
+  def on_regexp(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#102
+  def escaped_octal?(string); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#54
+  def group_expressions(node, expressions); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#110
+  def interpolation_locs(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#106
+  def octal?(char); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#71
+  def pop_octal_digits(current_child, expressions); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#89
+  def skip_expression?(expr); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#80
+  def source_range(children); end
+
+  # Since we blank interpolations with a space for every char of the interpolation, we would
+  # mark every space (except the first) as duplicate if we do not skip regexp_parser nodes
+  # that are within an interpolation.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#96
+  def within_interpolation?(node, child); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#25
+RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement::MSG_REPEATED_ELEMENT = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb#27
+RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement::OCTAL_DIGITS_AFTER_ESCAPE = T.let(T.unsafe(nil), Integer)
+
+# Checks for duplicate ``require``s and ``require_relative``s.
+#
+# @example
+#   # bad
+#   require 'foo'
+#   require 'bar'
+#   require 'foo'
+#
+#   # good
+#   require 'foo'
+#   require 'bar'
+#
+#   # good
+#   require 'foo'
+#   require_relative 'foo'
+#
+# source://rubocop//lib/rubocop/cop/lint/duplicate_require.rb#26
+class RuboCop::Cop::Lint::DuplicateRequire < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_require.rb#39
+  def on_new_investigation; end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_require.rb#45
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_require.rb#35
+  def require_call?(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_require.rb#30
+RuboCop::Cop::Lint::DuplicateRequire::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_require.rb#31
+RuboCop::Cop::Lint::DuplicateRequire::REQUIRE_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_require.rb#32
+RuboCop::Cop::Lint::DuplicateRequire::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
+
+# Checks that there are no repeated exceptions
+# used in 'rescue' expressions.
+#
+# @example
+#   # bad
+#   begin
+#   something
+#   rescue FirstException
+#   handle_exception
+#   rescue FirstException
+#   handle_other_exception
+#   end
+#
+#   # good
+#   begin
+#   something
+#   rescue FirstException
+#   handle_exception
+#   rescue SecondException
+#   handle_other_exception
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/duplicate_rescue_exception.rb#28
+class RuboCop::Cop::Lint::DuplicateRescueException < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RescueNode
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_rescue_exception.rb#33
+  def on_rescue(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_rescue_exception.rb#31
+RuboCop::Cop::Lint::DuplicateRescueException::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for duplicate literal, constant, or variable elements in Set.
+#
+# @example
+#
+#   # bad
+#   Set[:foo, :bar, :foo]
+#
+#   # good
+#   Set[:foo, :bar]
+#
+#   # bad
+#   Set.new([:foo, :bar, :foo])
+#
+#   # good
+#   Set.new([:foo, :bar])
+#
+#   # bad
+#   [:foo, :bar, :foo].to_set
+#
+#   # good
+#   [:foo, :bar].to_set
+#
+# source://rubocop//lib/rubocop/cop/lint/duplicate_set_element.rb#28
+class RuboCop::Cop::Lint::DuplicateSetElement < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_set_element.rb#43
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_set_element.rb#43
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_set_element.rb#35
+  def set_init_elements(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/duplicate_set_element.rb#64
+  def register_offense(current_element, prev_element); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_set_element.rb#31
+RuboCop::Cop::Lint::DuplicateSetElement::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/duplicate_set_element.rb#32
+RuboCop::Cop::Lint::DuplicateSetElement::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks if each_with_object is called with an immutable
+# argument. Since the argument is the object that the given block shall
+# make calls on to build something based on the enumerable that
+# each_with_object iterates over, an immutable argument makes no sense.
+# It's definitely a bug.
+#
+# @example
+#
+#   # bad
+#   sum = numbers.each_with_object(0) { |e, a| a += e }
+#
+#   # good
+#   num = 0
+#   sum = numbers.each_with_object(num) { |e, a| a += e }
+#
+# source://rubocop//lib/rubocop/cop/lint/each_with_object_argument.rb#20
+class RuboCop::Cop::Lint::EachWithObjectArgument < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/each_with_object_argument.rb#25
+  def each_with_object?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/each_with_object_argument.rb#29
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/each_with_object_argument.rb#29
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/each_with_object_argument.rb#21
+RuboCop::Cop::Lint::EachWithObjectArgument::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/each_with_object_argument.rb#22
+RuboCop::Cop::Lint::EachWithObjectArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for odd `else` block layout - like
+# having an expression on the same line as the `else` keyword,
+# which is usually a mistake.
+#
+# Its autocorrection tweaks layout to keep the syntax. So, this autocorrection
+# is compatible correction for bad case syntax, but if your code makes a mistake
+# with `elsif` and `else`, you will have to correct it manually.
+#
+# @example
+#
+#   # bad
+#
+#   if something
+#   # ...
+#   else do_this
+#   do_that
+#   end
+#
+#   # good
+#
+#   # This code is compatible with the bad case. It will be autocorrected like this.
+#   if something
+#   # ...
+#   else
+#   do_this
+#   do_that
+#   end
+#
+#   # This code is incompatible with the bad case.
+#   # If `do_this` is a condition, `elsif` should be used instead of `else`.
+#   if something
+#   # ...
+#   elsif do_this
+#   do_that
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/else_layout.rb#41
+class RuboCop::Cop::Lint::ElseLayout < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/else_layout.rb#48
+  def on_if(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/else_layout.rb#79
+  def autocorrect(corrector, node, first_else); end
+
+  # source://rubocop//lib/rubocop/cop/lint/else_layout.rb#59
+  def check(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/else_layout.rb#69
+  def check_else(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/else_layout.rb#46
+RuboCop::Cop::Lint::ElseLayout::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for blocks without a body.
+# Such empty blocks are typically an oversight or we should provide a comment
+# to clarify what we're aiming for.
+#
+# Empty lambdas and procs are ignored by default.
+#
+# NOTE: For backwards compatibility, the configuration that allows/disallows
+# empty lambdas and procs is called `AllowEmptyLambdas`, even though it also
+# applies to procs.
+#
+# @example
+#   # bad
+#   items.each { |item| }
+#
+#   # good
+#   items.each { |item| puts item }
+# @example AllowComments: true (default)
+#   # good
+#   items.each do |item|
+#   # TODO: implement later (inner comment)
+#   end
+#
+#   items.each { |item| } # TODO: implement later (inline comment)
+# @example AllowComments: false
+#   # bad
+#   items.each do |item|
+#   # TODO: implement later (inner comment)
+#   end
+#
+#   items.each { |item| } # TODO: implement later (inline comment)
+# @example AllowEmptyLambdas: true (default)
+#   # good
+#   allow(subject).to receive(:callable).and_return(-> {})
+#
+#   placeholder = lambda do
+#   end
+#   (callable || placeholder).call
+#
+#   proc { }
+#
+#   Proc.new { }
+# @example AllowEmptyLambdas: false
+#   # bad
+#   allow(subject).to receive(:callable).and_return(-> {})
+#
+#   placeholder = lambda do
+#   end
+#   (callable || placeholder).call
+#
+#   proc { }
+#
+#   Proc.new { }
+#
+# source://rubocop//lib/rubocop/cop/lint/empty_block.rb#63
+class RuboCop::Cop::Lint::EmptyBlock < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/empty_block.rb#66
+  def on_block(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/empty_block.rb#76
+  def allow_comment?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/empty_block.rb#83
+  def allow_empty_lambdas?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/empty_block.rb#87
+  def comment_disables_cop?(comment); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/empty_block.rb#64
+RuboCop::Cop::Lint::EmptyBlock::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for classes and metaclasses without a body.
+# Such empty classes and metaclasses are typically an oversight or we should provide a comment
+# to be clearer what we're aiming for.
+#
+# @example
+#   # bad
+#   class Foo
+#   end
+#
+#   class Bar
+#   class << self
+#   end
+#   end
+#
+#   class << obj
+#   end
+#
+#   # good
+#   class Foo
+#   def do_something
+#   # ... code
+#   end
+#   end
+#
+#   class Bar
+#   class << self
+#   attr_reader :bar
+#   end
+#   end
+#
+#   class << obj
+#   attr_reader :bar
+#   end
+# @example AllowComments: false (default)
+#   # bad
+#   class Foo
+#   # TODO: implement later
+#   end
+#
+#   class Bar
+#   class << self
+#   # TODO: implement later
+#   end
+#   end
+#
+#   class << obj
+#   # TODO: implement later
+#   end
+# @example AllowComments: true
+#   # good
+#   class Foo
+#   # TODO: implement later
+#   end
+#
+#   class Bar
+#   class << self
+#   # TODO: implement later
+#   end
+#   end
+#
+#   class << obj
+#   # TODO: implement later
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/empty_class.rb#72
+class RuboCop::Cop::Lint::EmptyClass < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/empty_class.rb#76
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/empty_class.rb#81
+  def on_sclass(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/empty_class.rb#87
+  def body_or_allowed_comment_lines?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/empty_class.rb#73
+RuboCop::Cop::Lint::EmptyClass::CLASS_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/empty_class.rb#74
+RuboCop::Cop::Lint::EmptyClass::METACLASS_MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the presence of `if`, `elsif` and `unless` branches without a body.
+#
+# NOTE: empty `else` branches are handled by `Style/EmptyElse`.
+#
+# @example
+#   # bad
+#   if condition
+#   end
+#
+#   # bad
+#   unless condition
+#   end
+#
+#   # bad
+#   if condition
+#   do_something
+#   elsif other_condition
+#   end
+#
+#   # good
+#   if condition
+#   do_something
+#   end
+#
+#   # good
+#   unless condition
+#   do_something
+#   end
+#
+#   # good
+#   if condition
+#   do_something
+#   elsif other_condition
+#   do_something_else
+#   end
+# @example AllowComments: true (default)
+#   # good
+#   if condition
+#   do_something
+#   elsif other_condition
+#   # noop
+#   end
+# @example AllowComments: false
+#   # bad
+#   if condition
+#   do_something
+#   elsif other_condition
+#   # noop
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#63
+class RuboCop::Cop::Lint::EmptyConditionalBody < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CommentsHelp
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#71
+  def on_if(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#177
+  def all_branches_body_missing?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#95
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#163
+  def branch_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#125
+  def correct_other_branches(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#183
+  def deletion_range(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#158
+  def else_branch?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#152
+  def empty_elsif_branch?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#144
+  def empty_if_branch?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#87
+  def offense_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#101
+  def remove_comments(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#109
+  def remove_empty_branch(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#137
+  def require_other_branches_correction?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/empty_conditional_body.rb#68
+RuboCop::Cop::Lint::EmptyConditionalBody::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for empty `ensure` blocks.
+#
+# @example
+#
+#   # bad
+#   def some_method
+#   do_something
+#   ensure
+#   end
+#
+#   # bad
+#   begin
+#   do_something
+#   ensure
+#   end
+#
+#   # good
+#   def some_method
+#   do_something
+#   ensure
+#   do_something_else
+#   end
+#
+#   # good
+#   begin
+#   do_something
+#   ensure
+#   do_something_else
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/empty_ensure.rb#35
+class RuboCop::Cop::Lint::EmptyEnsure < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/empty_ensure.rb#40
+  def on_ensure(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/empty_ensure.rb#38
+RuboCop::Cop::Lint::EmptyEnsure::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the presence of empty expressions.
+#
+# @example
+#
+#   # bad
+#
+#   foo = ()
+#   if ()
+#   bar
+#   end
+# @example
+#
+#   # good
+#
+#   foo = (some_expression)
+#   if (some_expression)
+#   bar
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/empty_expression.rb#25
+class RuboCop::Cop::Lint::EmptyExpression < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/empty_expression.rb#28
+  def on_begin(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/empty_expression.rb#36
+  def empty_expression?(begin_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/empty_expression.rb#26
+RuboCop::Cop::Lint::EmptyExpression::MSG = T.let(T.unsafe(nil), String)
+
+# Enforces that Ruby source files are not empty.
+#
+# @example
+#   # bad
+#   # Empty file
+#
+#   # good
+#   # File containing non commented source lines
+# @example AllowComments: true (default)
+#   # good
+#   # File consisting only of comments
+# @example AllowComments: false
+#   # bad
+#   # File consisting only of comments
+#
+# source://rubocop//lib/rubocop/cop/lint/empty_file.rb#23
+class RuboCop::Cop::Lint::EmptyFile < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/lint/empty_file.rb#28
+  def on_new_investigation; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/empty_file.rb#42
+  def contains_only_comments?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/empty_file.rb#38
+  def empty_file?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/empty_file.rb#34
+  def offending?; end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/empty_file.rb#26
+RuboCop::Cop::Lint::EmptyFile::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the presence of `in` pattern branches without a body.
+#
+# @example
+#
+#   # bad
+#   case condition
+#   in [a]
+#   do_something
+#   in [a, b]
+#   end
+#
+#   # good
+#   case condition
+#   in [a]
+#   do_something
+#   in [a, b]
+#   nil
+#   end
+# @example AllowComments: true (default)
+#
+#   # good
+#   case condition
+#   in [a]
+#   do_something
+#   in [a, b]
+#   # noop
+#   end
+# @example AllowComments: false
+#
+#   # bad
+#   case condition
+#   in [a]
+#   do_something
+#   in [a, b]
+#   # noop
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/empty_in_pattern.rb#45
+class RuboCop::Cop::Lint::EmptyInPattern < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CommentsHelp
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/lint/empty_in_pattern.rb#53
+  def on_case_match(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/empty_in_pattern.rb#49
+RuboCop::Cop::Lint::EmptyInPattern::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for empty interpolation.
+#
+# @example
+#
+#   # bad
+#   "result is #{}"
+#
+#   # good
+#   "result is #{some_result}"
+#
+# source://rubocop//lib/rubocop/cop/lint/empty_interpolation.rb#15
+class RuboCop::Cop::Lint::EmptyInterpolation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Interpolation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/empty_interpolation.rb#21
+  def on_interpolation(begin_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/empty_interpolation.rb#19
+RuboCop::Cop::Lint::EmptyInterpolation::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the presence of `when` branches without a body.
+#
+# @example
+#
+#   # bad
+#   case foo
+#   when bar
+#   do_something
+#   when baz
+#   end
+#
+#   # good
+#   case condition
+#   when foo
+#   do_something
+#   when bar
+#   nil
+#   end
+# @example AllowComments: true (default)
+#
+#   # good
+#   case condition
+#   when foo
+#   do_something
+#   when bar
+#   # noop
+#   end
+# @example AllowComments: false
+#
+#   # bad
+#   case condition
+#   when foo
+#   do_something
+#   when bar
+#   # do nothing
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/empty_when.rb#45
+class RuboCop::Cop::Lint::EmptyWhen < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CommentsHelp
+
+  # source://rubocop//lib/rubocop/cop/lint/empty_when.rb#50
+  def on_case(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/empty_when.rb#48
+RuboCop::Cop::Lint::EmptyWhen::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for `return` from an `ensure` block.
+# `return` from an ensure block is a dangerous code smell as it
+# will take precedence over any exception being raised,
+# and the exception will be silently thrown away as if it were rescued.
+#
+# If you want to rescue some (or all) exceptions, best to do it explicitly
+#
+# @example
+#
+#   # bad
+#   def foo
+#   do_something
+#   ensure
+#   cleanup
+#   return self
+#   end
+#
+#   # good
+#   def foo
+#   do_something
+#   self
+#   ensure
+#   cleanup
+#   end
+#
+#   # good
+#   def foo
+#   begin
+#   do_something
+#   rescue SomeException
+#   # Let's ignore this exception
+#   end
+#   self
+#   ensure
+#   cleanup
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/ensure_return.rb#42
+class RuboCop::Cop::Lint::EnsureReturn < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/ensure_return.rb#45
+  def on_ensure(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/ensure_return.rb#43
+RuboCop::Cop::Lint::EnsureReturn::MSG = T.let(T.unsafe(nil), String)
+
+# Emulates the following Ruby warnings in Ruby 2.6.
+#
+# [source,console]
+# ----
+# $ cat example.rb
+# ERB.new('hi', nil, '-', '@output_buffer')
+# $ ruby -rerb example.rb
+# example.rb:1: warning: Passing safe_level with the 2nd argument of ERB.new is
+# deprecated. Do not use it, and specify other arguments as keyword arguments.
+# example.rb:1: warning: Passing trim_mode with the 3rd argument of ERB.new is
+# deprecated. Use keyword argument like ERB.new(str, trim_mode:...) instead.
+# example.rb:1: warning: Passing eoutvar with the 4th argument of ERB.new is
+# deprecated. Use keyword argument like ERB.new(str, eoutvar: ...) instead.
+# ----
+#
+# Now non-keyword arguments other than first one are softly deprecated
+# and will be removed when Ruby 2.5 becomes EOL.
+# `ERB.new` with non-keyword arguments is deprecated since ERB 2.2.0.
+# Use `:trim_mode` and `:eoutvar` keyword arguments to `ERB.new`.
+# This cop identifies places where `ERB.new(str, trim_mode, eoutvar)` can
+# be replaced by `ERB.new(str, :trim_mode: trim_mode, eoutvar: eoutvar)`.
+#
+# @example
+#   # Target codes supports Ruby 2.6 and higher only
+#   # bad
+#   ERB.new(str, nil, '-', '@output_buffer')
+#
+#   # good
+#   ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+#
+#   # Target codes supports Ruby 2.5 and lower only
+#   # good
+#   ERB.new(str, nil, '-', '@output_buffer')
+#
+#   # Target codes supports Ruby 2.6, 2.5 and lower
+#   # bad
+#   ERB.new(str, nil, '-', '@output_buffer')
+#
+#   # good
+#   # Ruby standard library style
+#   # https://github.com/ruby/ruby/commit/3406c5d
+#   if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+
+#   ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+#   else
+#   ERB.new(str, nil, '-', '@output_buffer')
+#   end
+#
+#   # good
+#   # Use `RUBY_VERSION` style
+#   if RUBY_VERSION >= '2.6'
+#   ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer')
+#   else
+#   ERB.new(str, nil, '-', '@output_buffer')
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#61
+class RuboCop::Cop::Lint::ErbNewArguments < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#81
+  def erb_new_with_non_keyword_arguments(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#86
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#160
+  def arguments_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#115
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#130
+  def build_kwargs(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#126
+  def correct_arguments?(arguments); end
+
+  # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#104
+  def message(positional_argument_index, arg_value); end
+
+  # source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#147
+  def override_by_legacy_args(kwargs, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#74
+RuboCop::Cop::Lint::ErbNewArguments::MESSAGE_EOUTVAR = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#68
+RuboCop::Cop::Lint::ErbNewArguments::MESSAGE_SAFE_LEVEL = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#71
+RuboCop::Cop::Lint::ErbNewArguments::MESSAGE_TRIM_MODE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/erb_new_arguments.rb#78
+RuboCop::Cop::Lint::ErbNewArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Looks for uses of flip-flop operator
+# based on the Ruby Style Guide.
+#
+# Here is the history of flip-flops in Ruby.
+# flip-flop operator is deprecated in Ruby 2.6.0 and
+# the deprecation has been reverted by Ruby 2.7.0 and
+# backported to Ruby 2.6.
+# See: https://bugs.ruby-lang.org/issues/5400
+#
+# @example
+#   # bad
+#   (1..20).each do |x|
+#   puts x if (x == 5) .. (x == 10)
+#   end
+#
+#   # good
+#   (1..20).each do |x|
+#   puts x if (x >= 5) && (x <= 10)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/flip_flop.rb#25
+class RuboCop::Cop::Lint::FlipFlop < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/flip_flop.rb#32
+  def on_eflipflop(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/flip_flop.rb#28
+  def on_iflipflop(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/flip_flop.rb#26
+RuboCop::Cop::Lint::FlipFlop::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the presence of precise comparison of floating point numbers.
+#
+# Floating point values are inherently inaccurate, and comparing them for exact equality
+# is almost never the desired semantics. Comparison via the `==/!=` operators checks
+# floating-point value representation to be exactly the same, which is very unlikely
+# if you perform any arithmetic operations involving precision loss.
+#
+# @example
+#   # bad
+#   x == 0.1
+#   x != 0.1
+#
+#   # good - using BigDecimal
+#   x.to_d == 0.1.to_d
+#
+#   # good - comparing against zero
+#   x == 0.0
+#   x != 0.0
+#
+#   # good
+#   (x - 0.1).abs < Float::EPSILON
+#
+#   # good
+#   tolerance = 0.0001
+#   (x - 0.1).abs < tolerance
+#
+#   # Or some other epsilon based type of comparison:
+#   # https://www.embeddeduse.com/2019/08/26/qt-compare-two-floats/
+#
+# source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#35
+class RuboCop::Cop::Lint::FloatComparison < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#44
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#89
+  def check_numeric_returning_method(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#73
+  def check_send(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#53
+  def float?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#68
+  def literal_zero?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#38
+RuboCop::Cop::Lint::FloatComparison::EQUALITY_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#40
+RuboCop::Cop::Lint::FloatComparison::FLOAT_INSTANCE_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#39
+RuboCop::Cop::Lint::FloatComparison::FLOAT_RETURNING_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#36
+RuboCop::Cop::Lint::FloatComparison::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/float_comparison.rb#42
+RuboCop::Cop::Lint::FloatComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Identifies Float literals which are, like, really really really
+# really really really really really big. Too big. No-one needs Floats
+# that big. If you need a float that big, something is wrong with you.
+#
+# @example
+#
+#   # bad
+#   float = 3.0e400
+#
+#   # good
+#   float = 42.9
+#
+# source://rubocop//lib/rubocop/cop/lint/float_out_of_range.rb#17
+class RuboCop::Cop::Lint::FloatOutOfRange < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/float_out_of_range.rb#20
+  def on_float(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/float_out_of_range.rb#18
+RuboCop::Cop::Lint::FloatOutOfRange::MSG = T.let(T.unsafe(nil), String)
+
+# This lint sees if there is a mismatch between the number of
+# expected fields for format/sprintf/#% and what is actually
+# passed as arguments.
+#
+# In addition it checks whether different formats are used in the same
+# format string. Do not mix numbered, unnumbered, and named formats in
+# the same format string.
+#
+# @example
+#
+#   # bad
+#   format('A value: %s and another: %i', a_value)
+#
+#   # good
+#   format('A value: %s and another: %i', a_value, another)
+#
+#   # bad
+#   format('Unnumbered format: %s and numbered: %2$s', a_value, another)
+#
+#   # good
+#   format('Numbered format: %1$s and numbered %2$s', a_value, another)
+#
+# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#27
+class RuboCop::Cop::Lint::FormatParameterMismatch < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#90
+  def called_on_string?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#39
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#127
+  def count_format_matches(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#109
+  def count_matches(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#131
+  def count_percent_matches(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#119
+  def countable_format?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#123
+  def countable_percent?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#143
+  def expected_fields_count(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#158
+  def format?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#136
+  def format_method?(name, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#54
+  def format_string?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#105
+  def heredoc?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#58
+  def invalid_format_string?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#81
+  def matched_arguments_count?(expected, passed); end
+
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#176
+  def message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#95
+  def method_with_format_args?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#67
+  def offending_node?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#166
+  def percent?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#99
+  def splat_args?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#162
+  def sprintf?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#185
+  def string_type?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#34
+RuboCop::Cop::Lint::FormatParameterMismatch::KERNEL = T.let(T.unsafe(nil), String)
+
+# http://rubular.com/r/CvpbxkcTzy
+#
+# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#29
+RuboCop::Cop::Lint::FormatParameterMismatch::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#31
+RuboCop::Cop::Lint::FormatParameterMismatch::MSG_INVALID = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#37
+RuboCop::Cop::Lint::FormatParameterMismatch::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#35
+RuboCop::Cop::Lint::FormatParameterMismatch::SHOVEL = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/format_parameter_mismatch.rb#36
+RuboCop::Cop::Lint::FormatParameterMismatch::STRING_TYPES = T.let(T.unsafe(nil), Array)
+
+# Prefer using `Hash#compare_by_identity` rather than using `object_id`
+# for hash keys.
+#
+# This cop looks for hashes being keyed by objects' `object_id`, using
+# one of these methods: `key?`, `has_key?`, `fetch`, `[]` and `[]=`.
+#
+# @example
+#   # bad
+#   hash = {}
+#   hash[foo.object_id] = :bar
+#   hash.key?(baz.object_id)
+#
+#   # good
+#   hash = {}.compare_by_identity
+#   hash[foo] = :bar
+#   hash.key?(baz)
+#
+# source://rubocop//lib/rubocop/cop/lint/hash_compare_by_identity.rb#31
+class RuboCop::Cop::Lint::HashCompareByIdentity < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/hash_compare_by_identity.rb#37
+  def id_as_hash_key?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/hash_compare_by_identity.rb#41
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/hash_compare_by_identity.rb#41
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/hash_compare_by_identity.rb#34
+RuboCop::Cop::Lint::HashCompareByIdentity::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/hash_compare_by_identity.rb#32
+RuboCop::Cop::Lint::HashCompareByIdentity::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for the ordering of a method call where
+# the receiver of the call is a HEREDOC.
+#
+# @example
+#   # bad
+#   <<-SQL
+#   bar
+#   SQL
+#   .strip_indent
+#
+#   <<-SQL
+#   bar
+#   SQL
+#   .strip_indent
+#   .trim
+#
+#   # good
+#   <<~SQL
+#   bar
+#   SQL
+#
+#   <<~SQL.trim
+#   bar
+#   SQL
+#
+# source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#31
+class RuboCop::Cop::Lint::HeredocMethodCallPosition < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#37
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#37
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#97
+  def all_on_same_line?(nodes); end
+
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#50
+  def autocorrect(corrector, node, heredoc); end
+
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#77
+  def call_after_heredoc_range(heredoc); end
+
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#107
+  def call_end_pos(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#116
+  def call_line_range(node); end
+
+  # Returns nil if no range can be safely repositioned.
+  #
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#122
+  def call_range_to_safely_reposition(node, heredoc); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#86
+  def calls_on_multiple_lines?(node, _heredoc); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#82
+  def correctly_positioned?(node, heredoc); end
+
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#111
+  def heredoc_begin_line_range(heredoc); end
+
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#103
+  def heredoc_end_pos(heredoc); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#73
+  def heredoc_node?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#59
+  def heredoc_node_descendent_receiver(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#67
+  def send_node?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#146
+  def trailing_comma?(call_source, call_line_source); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/heredoc_method_call_position.rb#35
+RuboCop::Cop::Lint::HeredocMethodCallPosition::MSG = T.let(T.unsafe(nil), String)
+
+# Prefer `equal?` over `==` when comparing `object_id`.
+#
+# `Object#equal?` is provided to compare objects for identity, and in contrast
+# `Object#==` is provided for the purpose of doing value comparison.
+#
+# @example
+#   # bad
+#   foo.object_id == bar.object_id
+#
+#   # good
+#   foo.equal?(bar)
+#
+# source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#18
+class RuboCop::Cop::Lint::IdentityComparison < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#24
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#40
+  def compare_between_object_id_by_double_equal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#44
+  def object_id_method?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#21
+RuboCop::Cop::Lint::IdentityComparison::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/identity_comparison.rb#22
+RuboCop::Cop::Lint::IdentityComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for implicit string concatenation of string literals
+# which are on the same line.
+#
+# @example
+#
+#   # bad
+#   array = ['Item 1' 'Item 2']
+#
+#   # good
+#   array = ['Item 1Item 2']
+#   array = ['Item 1' + 'Item 2']
+#   array = [
+#   'Item 1' \
+#   'Item 2'
+#   ]
+#
+# source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#21
+class RuboCop::Cop::Lint::ImplicitStringConcatenation < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#32
+  def on_dstr(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#92
+  def display_str(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#59
+  def each_bad_cons(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#74
+  def ending_delimiter(str); end
+
+  # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#100
+  def str_content(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#84
+  def string_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#88
+  def string_literals?(node1, node2); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#26
+RuboCop::Cop::Lint::ImplicitStringConcatenation::FOR_ARRAY = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#28
+RuboCop::Cop::Lint::ImplicitStringConcatenation::FOR_METHOD = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/implicit_string_concatenation.rb#24
+RuboCop::Cop::Lint::ImplicitStringConcatenation::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for `IO.select` that is incompatible with Fiber Scheduler since Ruby 3.0.
+#
+# When an array of IO objects waiting for an exception (the third argument of `IO.select`)
+# is used as an argument, there is no alternative API, so offenses are not registered.
+#
+# NOTE: When the method is successful the return value of `IO.select` is `[[IO]]`,
+# and the return value of `io.wait_readable` and `io.wait_writable` are `self`.
+# They are not autocorrected when assigning a return value because these types are different.
+# It's up to user how to handle the return value.
+#
+# @example
+#
+#   # bad
+#   IO.select([io], [], [], timeout)
+#
+#   # good
+#   io.wait_readable(timeout)
+#
+#   # bad
+#   IO.select([], [io], [], timeout)
+#
+#   # good
+#   io.wait_writable(timeout)
+#
+# source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#34
+class RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#41
+  def io_select(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#46
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#69
+  def preferred_method(read, write, timeout); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#63
+  def scheduler_compatible?(io1, io2); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#37
+RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb#38
+RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for `private` or `protected` access modifiers which are
+# applied to a singleton method. These access modifiers do not make
+# singleton methods private/protected. `private_class_method` can be
+# used for that.
+#
+# @example
+#
+#   # bad
+#   class C
+#   private
+#
+#   def self.method
+#   puts 'hi'
+#   end
+#   end
+#
+#   # good
+#   class C
+#   def self.method
+#   puts 'hi'
+#   end
+#
+#   private_class_method :method
+#   end
+#
+#   # good
+#   class C
+#   class << self
+#   private
+#
+#   def method
+#   puts 'hi'
+#   end
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#41
+class RuboCop::Cop::Lint::IneffectiveAccessModifier < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#52
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#52
+  def on_module(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#48
+  def private_class_methods(param0); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#102
+  def access_modifier?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#59
+  def check_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#106
+  def correct_visibility?(node, modifier, ignored_methods); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#71
+  def format_message(modifier); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#84
+  def ineffective_modifier(node, ignored_methods = T.unsafe(nil), modifier = T.unsafe(nil), &block); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#67
+  def private_class_method_names(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#44
+RuboCop::Cop::Lint::IneffectiveAccessModifier::ALTERNATIVE_PRIVATE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#45
+RuboCop::Cop::Lint::IneffectiveAccessModifier::ALTERNATIVE_PROTECTED = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/ineffective_access_modifier.rb#42
+RuboCop::Cop::Lint::IneffectiveAccessModifier::MSG = T.let(T.unsafe(nil), String)
+
+# Looks for error classes inheriting from `Exception`.
+# It is configurable to suggest using either `StandardError` (default) or
+# `RuntimeError` instead.
+#
+# @example EnforcedStyle: standard_error (default)
+#   # bad
+#
+#   class C < Exception; end
+#
+#   C = Class.new(Exception)
+#
+#   # good
+#
+#   class C < StandardError; end
+#
+#   C = Class.new(StandardError)
+# @example EnforcedStyle: runtime_error
+#   # bad
+#
+#   class C < Exception; end
+#
+#   C = Class.new(Exception)
+#
+#   # good
+#
+#   class C < RuntimeError; end
+#
+#   C = Class.new(RuntimeError)
+#
+# source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#40
+class RuboCop::Cop::Lint::InheritException < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#53
+  def class_new_call?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#59
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#70
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#87
+  def exception_class?(class_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#91
+  def inherit_exception_class_with_omitted_namespace?(class_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#83
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#99
+  def preferred_base_class; end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#44
+RuboCop::Cop::Lint::InheritException::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#45
+RuboCop::Cop::Lint::InheritException::PREFERRED_BASE_CLASS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/lint/inherit_exception.rb#50
+RuboCop::Cop::Lint::InheritException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for interpolation in a single quoted string.
+#
+# @example
+#
+#   # bad
+#   foo = 'something with #{interpolation} inside'
+#
+#   # good
+#   foo = "something with #{interpolation} inside"
+#
+# source://rubocop//lib/rubocop/cop/lint/interpolation_check.rb#21
+class RuboCop::Cop::Lint::InterpolationCheck < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/interpolation_check.rb#27
+  def on_str(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/interpolation_check.rb#38
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/interpolation_check.rb#49
+  def heredoc?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/interpolation_check.rb#24
+RuboCop::Cop::Lint::InterpolationCheck::MSG = T.let(T.unsafe(nil), String)
+
+# Emulates the following Ruby warning in Ruby 3.3.
+#
+# [source,ruby]
+# ----
+# $ ruby -e '0.times { it }'
+# -e:1: warning: `it` calls without arguments will refer to the first block param in Ruby 3.4;
+# use it() or self.it
+# ----
+#
+# `it` calls without arguments will refer to the first block param in Ruby 3.4.
+# So use `it()` or `self.it` to ensure compatibility.
+#
+# @example
+#
+#   # bad
+#   do_something { it }
+#
+#   # good
+#   do_something { it() }
+#   do_something { self.it }
+#
+# source://rubocop//lib/rubocop/cop/lint/it_without_arguments_in_block.rb#27
+class RuboCop::Cop::Lint::ItWithoutArgumentsInBlock < ::RuboCop::Cop::Base
+  include ::RuboCop::AST::NodePattern::Macros
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/it_without_arguments_in_block.rb#41
+  def deprecated_it_method?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/it_without_arguments_in_block.rb#34
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/it_without_arguments_in_block.rb#30
+RuboCop::Cop::Lint::ItWithoutArgumentsInBlock::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/it_without_arguments_in_block.rb#32
+RuboCop::Cop::Lint::ItWithoutArgumentsInBlock::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks uses of lambda without a literal block.
+# It emulates the following warning in Ruby 3.0:
+#
+#   $ ruby -vwe 'lambda(&proc {})'
+#   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
+#   -e:1: warning: lambda without a literal block is deprecated; use the proc without
+#   lambda instead
+#
+# This way, proc object is never converted to lambda.
+# Autocorrection replaces with compatible proc argument.
+#
+# @example
+#
+#   # bad
+#   lambda(&proc { do_something })
+#   lambda(&Proc.new { do_something })
+#
+#   # good
+#   proc { do_something }
+#   Proc.new { do_something }
+#   lambda { do_something } # If you use lambda.
+#
+# source://rubocop//lib/rubocop/cop/lint/lambda_without_literal_block.rb#28
+class RuboCop::Cop::Lint::LambdaWithoutLiteralBlock < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/lambda_without_literal_block.rb#35
+  def lambda_with_symbol_proc?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/lambda_without_literal_block.rb#39
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/lambda_without_literal_block.rb#31
+RuboCop::Cop::Lint::LambdaWithoutLiteralBlock::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/lambda_without_literal_block.rb#32
+RuboCop::Cop::Lint::LambdaWithoutLiteralBlock::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for literals used as the conditions or as
+# operands in and/or expressions serving as the conditions of
+# if/while/until/case-when/case-in.
+#
+# NOTE: Literals in `case-in` condition where the match variable is used in
+# `in` are accepted as a pattern matching.
+#
+# @example
+#
+#   # bad
+#   if 20
+#   do_something
+#   end
+#
+#   # bad
+#   if some_var && true
+#   do_something
+#   end
+#
+#   # good
+#   if some_var && some_condition
+#   do_something
+#   end
+#
+#   # good
+#   # When using a boolean value for an infinite loop.
+#   while true
+#   break if condition
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#35
+class RuboCop::Cop::Lint::LiteralAsCondition < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#93
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#58
+  def on_case(case_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#73
+  def on_case_match(case_match_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#40
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#87
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#51
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#51
+  def on_until_post(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#44
+  def on_while(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#44
+  def on_while_post(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#108
+  def basic_literal?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#138
+  def check_case(case_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#99
+  def check_for_literal(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#120
+  def check_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#147
+  def condition(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#130
+  def handle_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#116
+  def primitive_array?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#155
+  def when_conditions_range(when_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/literal_as_condition.rb#38
+RuboCop::Cop::Lint::LiteralAsCondition::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for literal assignments in the conditions of `if`, `while`, and `until`.
+# It emulates the following Ruby warning:
+#
+# [source,console]
+# ----
+# $ ruby -we 'if x = true; end'
+# -e:1: warning: found `= literal' in conditional, should be ==
+# ----
+#
+# As a lint cop, it cannot be determined if `==` is appropriate as intended,
+# therefore this cop does not provide autocorrection.
+#
+# @example
+#
+#   # bad
+#   if x = 42
+#   do_something
+#   end
+#
+#   # good
+#   if x == 42
+#   do_something
+#   end
+#
+#   # good
+#   if x = y
+#   do_something
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#35
+class RuboCop::Cop::Lint::LiteralAssignmentInCondition < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#39
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#39
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#39
+  def on_while(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#62
+  def all_literals?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#79
+  def offense_range(asgn_node, rhs); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#75
+  def parallel_assignment_with_splat_operator?(node); end
+
+  # @yield [node]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#56
+  def traverse_node(node, &block); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/literal_assignment_in_condition.rb#36
+RuboCop::Cop::Lint::LiteralAssignmentInCondition::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for interpolated literals.
+#
+# @example
+#
+#   # bad
+#   "result is #{10}"
+#
+#   # good
+#   "result is 10"
+#
+# source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#15
+class RuboCop::Cop::Lint::LiteralInInterpolation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Interpolation
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::PercentLiteral
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#24
+  def on_interpolation(begin_node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#60
+  def autocorrected_value(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#127
+  def autocorrected_value_for_array(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#133
+  def autocorrected_value_for_hash(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#103
+  def autocorrected_value_for_string(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#111
+  def autocorrected_value_for_symbol(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#144
+  def autocorrected_value_in_hash(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#118
+  def autocorrected_value_in_hash_for_symbol(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#174
+  def ends_heredoc_line?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#82
+  def handle_special_regexp_chars(begin_node, value); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#182
+  def in_array_percent_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#46
+  def offending?(node); end
+
+  # Does node print its own source when converted to a string?
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#165
+  def prints_as_self?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#170
+  def space_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#54
+  def special_keyword?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#22
+RuboCop::Cop::Lint::LiteralInInterpolation::COMPOSITE = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/literal_in_interpolation.rb#21
+RuboCop::Cop::Lint::LiteralInInterpolation::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for uses of `begin...end while/until something`.
+#
+# @example
+#
+#   # bad
+#
+#   # using while
+#   begin
+#   do_something
+#   end while some_condition
+#
+#   # good
+#
+#   # while replacement
+#   loop do
+#   do_something
+#   break unless some_condition
+#   end
+#
+#   # bad
+#
+#   # using until
+#   begin
+#   do_something
+#   end until some_condition
+#
+#   # good
+#
+#   # until replacement
+#   loop do
+#   do_something
+#   break if some_condition
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/loop.rb#44
+class RuboCop::Cop::Lint::Loop < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/loop.rb#53
+  def on_until_post(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/loop.rb#49
+  def on_while_post(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/loop.rb#73
+  def build_break_line(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/loop.rb#69
+  def keyword_and_condition_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/loop.rb#59
+  def register_offense(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/loop.rb#47
+RuboCop::Cop::Lint::Loop::MSG = T.let(T.unsafe(nil), String)
+
+# cop disables on wide ranges of code, that latter contributors to
+# a file wouldn't be aware of.
+#
+# @example
+#   # Lint/MissingCopEnableDirective:
+#   #   MaximumRangeSize: .inf
+#
+#   # good
+#   # rubocop:disable Layout/SpaceAroundOperators
+#   x= 0
+#   # rubocop:enable Layout/SpaceAroundOperators
+#   # y = 1
+#   # EOF
+#
+#   # bad
+#   # rubocop:disable Layout/SpaceAroundOperators
+#   x= 0
+#   # EOF
+# @example
+#   # Lint/MissingCopEnableDirective:
+#   #   MaximumRangeSize: 2
+#
+#   # good
+#   # rubocop:disable Layout/SpaceAroundOperators
+#   x= 0
+#   # With the previous, there are 2 lines on which cop is disabled.
+#   # rubocop:enable Layout/SpaceAroundOperators
+#
+#   # bad
+#   # rubocop:disable Layout/SpaceAroundOperators
+#   x= 0
+#   x += 1
+#   # Including this, that's 3 lines on which the cop is disabled.
+#   # rubocop:enable Layout/SpaceAroundOperators
+#
+# source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#45
+class RuboCop::Cop::Lint::MissingCopEnableDirective < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#51
+  def on_new_investigation; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#70
+  def acceptable_range?(cop, line_range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#104
+  def department_enabled?(cop, comment); end
+
+  # source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#64
+  def each_missing_enable; end
+
+  # source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#87
+  def max_range; end
+
+  # source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#91
+  def message(cop, comment, type = T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#48
+RuboCop::Cop::Lint::MissingCopEnableDirective::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/missing_cop_enable_directive.rb#49
+RuboCop::Cop::Lint::MissingCopEnableDirective::MSG_BOUND = T.let(T.unsafe(nil), String)
+
+# Checks for the presence of constructors and lifecycle callbacks
+# without calls to `super`.
+#
+# This cop does not consider `method_missing` (and `respond_to_missing?`)
+# because in some cases it makes sense to overtake what is considered a
+# missing method. In other cases, the theoretical ideal handling could be
+# challenging or verbose for no actual gain.
+#
+# Autocorrection is not supported because the position of `super` cannot be
+# determined automatically.
+#
+# `Object` and `BasicObject` are allowed by this cop because of their
+# stateless nature. However, sometimes you might want to allow other parent
+# classes from this cop, for example in the case of an abstract class that is
+# not meant to be called with `super`. In those cases, you can use the
+# `AllowedParentClasses` option to specify which classes should be allowed
+# *in addition to* `Object` and `BasicObject`.
+#
+# @example
+#   # bad
+#   class Employee < Person
+#   def initialize(name, salary)
+#   @salary = salary
+#   end
+#   end
+#
+#   # good
+#   class Employee < Person
+#   def initialize(name, salary)
+#   super(name)
+#   @salary = salary
+#   end
+#   end
+#
+#   # bad
+#   Employee = Class.new(Person) do
+#   def initialize(name, salary)
+#   @salary = salary
+#   end
+#   end
+#
+#   # good
+#   Employee = Class.new(Person) do
+#   def initialize(name, salary)
+#   super(name)
+#   @salary = salary
+#   end
+#   end
+#
+#   # bad
+#   class Parent
+#   def self.inherited(base)
+#   do_something
+#   end
+#   end
+#
+#   # good
+#   class Parent
+#   def self.inherited(base)
+#   super
+#   do_something
+#   end
+#   end
+#
+#   # good
+#   class ClassWithNoParent
+#   def initialize
+#   do_something
+#   end
+#   end
+# @example AllowedParentClasses: [MyAbstractClass]
+#   # good
+#   class MyConcreteClass < MyAbstractClass
+#   def initialize
+#   do_something
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#85
+class RuboCop::Cop::Lint::MissingSuper < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#99
+  def class_new_block(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#105
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#115
+  def on_defs(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#149
+  def allowed_class?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#153
+  def allowed_classes; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#127
+  def callback_method_def?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#133
+  def contains_super?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#137
+  def inside_class_with_stateful_parent?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/missing_super.rb#123
+  def offender?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#96
+RuboCop::Cop::Lint::MissingSuper::CALLBACKS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#87
+RuboCop::Cop::Lint::MissingSuper::CALLBACK_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#91
+RuboCop::Cop::Lint::MissingSuper::CLASS_LIFECYCLE_CALLBACKS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#86
+RuboCop::Cop::Lint::MissingSuper::CONSTRUCTOR_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#92
+RuboCop::Cop::Lint::MissingSuper::METHOD_LIFECYCLE_CALLBACKS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/missing_super.rb#89
+RuboCop::Cop::Lint::MissingSuper::STATELESS_CLASSES = T.let(T.unsafe(nil), Array)
+
+# Checks for mixed-case character ranges since they include likely unintended characters.
+#
+# Offenses are registered for regexp character classes like `/[A-z]/`
+# as well as range objects like `('A'..'z')`.
+#
+# NOTE: Range objects cannot be autocorrected.
+#
+# @example
+#
+#   # bad
+#   r = /[A-z]/
+#
+#   # good
+#   r = /[A-Za-z]/
+#
+# source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#28
+class RuboCop::Cop::Lint::MixedCaseRange < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#58
+  def each_unsafe_regexp_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#37
+  def on_erange(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#37
+  def on_irange(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#48
+  def on_regexp(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#74
+  def build_source_range(range_start, range_end); end
+
+  # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#78
+  def range_for(char); end
+
+  # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#84
+  def range_pairs(expr); end
+
+  # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#104
+  def regexp_range(source); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#94
+  def skip_expression?(expr); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#98
+  def skip_range?(range_start, range_end); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#88
+  def unsafe_range?(range_start, range_end); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#32
+RuboCop::Cop::Lint::MixedCaseRange::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/mixed_case_range.rb#35
+RuboCop::Cop::Lint::MixedCaseRange::RANGES = T.let(T.unsafe(nil), Array)
+
+# Do not mix named captures and numbered captures in a Regexp literal
+# because numbered capture is ignored if they're mixed.
+# Replace numbered captures with non-capturing groupings or
+# named captures.
+#
+# @example
+#   # bad
+#   /(?<foo>FOO)(BAR)/
+#
+#   # good
+#   /(?<foo>FOO)(?<bar>BAR)/
+#
+#   # good
+#   /(?<foo>FOO)(?:BAR)/
+#
+#   # good
+#   /(FOO)(BAR)/
+#
+# source://rubocop//lib/rubocop/cop/lint/mixed_regexp_capture_types.rb#24
+class RuboCop::Cop::Lint::MixedRegexpCaptureTypes < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/mixed_regexp_capture_types.rb#27
+  def on_regexp(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/mixed_regexp_capture_types.rb#25
+RuboCop::Cop::Lint::MixedRegexpCaptureTypes::MSG = T.let(T.unsafe(nil), String)
+
+# In math and Python, we can use `x < y < z` style comparison to compare
+# multiple value. However, we can't use the comparison in Ruby. However,
+# the comparison is not syntax error. This cop checks the bad usage of
+# comparison operators.
+#
+# @example
+#
+#   # bad
+#   x < y < z
+#   10 <= x <= 20
+#
+#   # good
+#   x < y && y < z
+#   10 <= x && x <= 20
+#
+# source://rubocop//lib/rubocop/cop/lint/multiple_comparison.rb#20
+class RuboCop::Cop::Lint::MultipleComparison < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/multiple_comparison.rb#29
+  def multiple_compare?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/multiple_comparison.rb#33
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/multiple_comparison.rb#24
+RuboCop::Cop::Lint::MultipleComparison::COMPARISON_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/multiple_comparison.rb#23
+RuboCop::Cop::Lint::MultipleComparison::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/multiple_comparison.rb#26
+RuboCop::Cop::Lint::MultipleComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/multiple_comparison.rb#25
+RuboCop::Cop::Lint::MultipleComparison::SET_OPERATION_OPERATORS = T.let(T.unsafe(nil), Array)
+
+# Checks for nested method definitions.
+#
+# @example
+#
+#   # bad
+#
+#   # `bar` definition actually produces methods in the same scope
+#   # as the outer `foo` method. Furthermore, the `bar` method
+#   # will be redefined every time `foo` is invoked.
+#   def foo
+#   def bar
+#   end
+#   end
+#
+#   # good
+#
+#   def foo
+#   bar = -> { puts 'hello' }
+#   bar.call
+#   end
+#
+#   # good
+#
+#   # `class_eval`, `instance_eval`, `module_eval`, `class_exec`, `instance_exec`, and
+#   # `module_exec` blocks are allowed by default.
+#
+#   def foo
+#   self.class.class_eval do
+#   def bar
+#   end
+#   end
+#   end
+#
+#   def foo
+#   self.class.module_exec do
+#   def bar
+#   end
+#   end
+#   end
+#
+#   # good
+#
+#   def foo
+#   class << self
+#   def bar
+#   end
+#   end
+#   end
+# @example AllowedMethods: [] (default)
+#   # bad
+#   def do_something
+#   has_many :articles do
+#   def find_or_create_by_name(name)
+#   end
+#   end
+#   end
+# @example AllowedMethods: ['has_many']
+#   # bad
+#   def do_something
+#   has_many :articles do
+#   def find_or_create_by_name(name)
+#   end
+#   end
+#   end
+# @example AllowedPatterns: [] (default)
+#   # bad
+#   def foo(obj)
+#   obj.do_baz do
+#   def bar
+#   end
+#   end
+#   end
+# @example AllowedPatterns: ['baz']
+#   # good
+#   def foo(obj)
+#   obj.do_baz do
+#   def bar
+#   end
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#91
+class RuboCop::Cop::Lint::NestedMethodDefinition < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+
+  # source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#127
+  def eval_call?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#132
+  def exec_call?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#97
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#97
+  def on_defs(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#120
+  def allowed_method_name?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#115
+  def scoping_method_call?(child); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/nested_method_definition.rb#95
+RuboCop::Cop::Lint::NestedMethodDefinition::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for nested percent literals.
+#
+# @example
+#
+#   # bad
+#
+#   # The percent literal for nested_attributes is parsed as four tokens,
+#   # yielding the array [:name, :content, :"%i[incorrectly", :"nested]"].
+#   attributes = {
+#   valid_attributes: %i[name content],
+#   nested_attributes: %i[name content %i[incorrectly nested]]
+#   }
+#
+#   # good
+#
+#   # Neither is incompatible with the bad case, but probably the intended code.
+#   attributes = {
+#   valid_attributes: %i[name content],
+#   nested_attributes: [:name, :content, %i[incorrectly nested]]
+#   }
+#
+#   attributes = {
+#   valid_attributes: %i[name content],
+#   nested_attributes: [:name, :content, [:incorrectly, :nested]]
+#   }
+#
+# source://rubocop//lib/rubocop/cop/lint/nested_percent_literal.rb#32
+class RuboCop::Cop::Lint::NestedPercentLiteral < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::PercentLiteral
+
+  # source://rubocop//lib/rubocop/cop/lint/nested_percent_literal.rb#44
+  def on_array(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/nested_percent_literal.rb#48
+  def on_percent_literal(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/nested_percent_literal.rb#54
+  def contains_percent_literals?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/nested_percent_literal.rb#35
+RuboCop::Cop::Lint::NestedPercentLiteral::MSG = T.let(T.unsafe(nil), String)
+
+# The array of regular expressions representing percent literals that,
+# if found within a percent literal expression, will cause a
+# NestedPercentLiteral violation to be emitted.
+#
+# source://rubocop//lib/rubocop/cop/lint/nested_percent_literal.rb#41
+RuboCop::Cop::Lint::NestedPercentLiteral::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/nested_percent_literal.rb#42
+RuboCop::Cop::Lint::NestedPercentLiteral::REGEXES = T.let(T.unsafe(nil), Array)
+
+# Don't omit the accumulator when calling `next` in a `reduce` block.
+#
+# @example
+#
+#   # bad
+#   result = (1..4).reduce(0) do |acc, i|
+#   next if i.odd?
+#   acc + i
+#   end
+#
+#   # good
+#   result = (1..4).reduce(0) do |acc, i|
+#   next acc if i.odd?
+#   acc + i
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/next_without_accumulator.rb#21
+class RuboCop::Cop::Lint::NextWithoutAccumulator < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/next_without_accumulator.rb#24
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/next_without_accumulator.rb#38
+  def on_block_body_of_reduce(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/next_without_accumulator.rb#24
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/next_without_accumulator.rb#45
+  def parent_block_node(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/next_without_accumulator.rb#22
+RuboCop::Cop::Lint::NextWithoutAccumulator::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the presence of a `return` inside a `begin..end` block
+# in assignment contexts.
+# In this situation, the `return` will result in an exit from the current
+# method, possibly leading to unexpected behavior.
+#
+# @example
+#
+#   # bad
+#   @some_variable ||= begin
+#   return some_value if some_condition_is_met
+#
+#   do_something
+#   end
+#
+#   # good
+#   @some_variable ||= begin
+#   if some_condition_is_met
+#   some_value
+#   else
+#   do_something
+#   end
+#   end
+#
+#   # good
+#   some_variable = if some_condition_is_met
+#   return if another_condition_is_met
+#
+#   some_value
+#   else
+#   do_something
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb#38
+class RuboCop::Cop::Lint::NoReturnInBeginEndBlocks < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb#41
+  def on_lvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb#41
+  def on_op_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb#41
+  def on_or_asgn(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb#39
+RuboCop::Cop::Lint::NoReturnInBeginEndBlocks::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for non-atomic file operation.
+# And then replace it with a nearly equivalent and atomic method.
+#
+# These can cause problems that are difficult to reproduce,
+# especially in cases of frequent file operations in parallel,
+# such as test runs with parallel_rspec.
+#
+# For examples: creating a directory if there is none, has the following problems
+#
+# An exception occurs when the directory didn't exist at the time of `exist?`,
+# but someone else created it before `mkdir` was executed.
+#
+# Subsequent processes are executed without the directory that should be there
+# when the directory existed at the time of `exist?`,
+# but someone else deleted it shortly afterwards.
+#
+# @example
+#   # bad - race condition with another process may result in an error in `mkdir`
+#   unless Dir.exist?(path)
+#   FileUtils.mkdir(path)
+#   end
+#
+#   # good - atomic and idempotent creation
+#   FileUtils.mkdir_p(path)
+#
+#   # bad - race condition with another process may result in an error in `remove`
+#   if File.exist?(path)
+#   FileUtils.remove(path)
+#   end
+#
+#   # good - atomic and idempotent removal
+#   FileUtils.rm_f(path)
+#
+# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#44
+class RuboCop::Cop::Lint::NonAtomicFileOperation < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#76
+  def explicit_not_force?(param0); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#71
+  def force?(param0); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#80
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#66
+  def receiver_and_method_name(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#61
+  def send_exist_node(param0); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#97
+  def allowable_use_with_if?(if_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#121
+  def autocorrect(corrector, node, range); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#132
+  def autocorrect_replace_method(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#151
+  def force_method?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#159
+  def force_method_name?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#155
+  def force_option?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#91
+  def if_node_child?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#112
+  def message_change_force_method(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#116
+  def message_remove_file_exist_check(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#101
+  def register_offense(node, exist_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#139
+  def replacement_method(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#50
+RuboCop::Cop::Lint::NonAtomicFileOperation::MAKE_FORCE_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#51
+RuboCop::Cop::Lint::NonAtomicFileOperation::MAKE_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#49
+RuboCop::Cop::Lint::NonAtomicFileOperation::MSG_CHANGE_FORCE_METHOD = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#47
+RuboCop::Cop::Lint::NonAtomicFileOperation::MSG_REMOVE_FILE_EXIST_CHECK = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#54
+RuboCop::Cop::Lint::NonAtomicFileOperation::RECURSIVE_REMOVE_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#52
+RuboCop::Cop::Lint::NonAtomicFileOperation::REMOVE_FORCE_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#53
+RuboCop::Cop::Lint::NonAtomicFileOperation::REMOVE_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/non_atomic_file_operation.rb#55
+RuboCop::Cop::Lint::NonAtomicFileOperation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# `Dir[...]` and `Dir.glob(...)` do not make any guarantees about
+# the order in which files are returned. The final order is
+# determined by the operating system and file system.
+# This means that using them in cases where the order matters,
+# such as requiring files, can lead to intermittent failures
+# that are hard to debug. To ensure this doesn't happen,
+# always sort the list.
+#
+# `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0.
+# So all bad cases are acceptable when Ruby 3.0 or higher are used.
+#
+# NOTE: This cop will be deprecated and removed when supporting only Ruby 3.0 and higher.
+#
+# @example
+#
+#   # bad
+#   Dir["./lib/**/*.rb"].each do |file|
+#   require file
+#   end
+#
+#   # good
+#   Dir["./lib/**/*.rb"].sort.each do |file|
+#   require file
+#   end
+#
+#   # bad
+#   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file|
+#   require file
+#   end
+#
+#   # good
+#   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')).sort.each do |file|
+#   require file
+#   end
+#
+#   # bad
+#   Dir['./lib/**/*.rb'].each(&method(:require))
+#
+#   # good
+#   Dir['./lib/**/*.rb'].sort.each(&method(:require))
+#
+#   # bad
+#   Dir.glob(Rails.root.join('test', '*.rb'), &method(:require))
+#
+#   # good
+#   Dir.glob(Rails.root.join('test', '*.rb')).sort.each(&method(:require))
+#
+#   # good - Respect intent if `sort` keyword option is specified in Ruby 3.0 or higher.
+#   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb'), sort: false).each(&method(:require))
+#
+# source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#60
+class RuboCop::Cop::Lint::NonDeterministicRequireOrder < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#172
+  def loop_variable(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#155
+  def method_require?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#65
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#89
+  def on_block_pass(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#77
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#145
+  def unsorted_dir_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#150
+  def unsorted_dir_each?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#166
+  def unsorted_dir_each_pass?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#160
+  def unsorted_dir_glob_pass?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#177
+  def var_is_required?(param0, param1); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#107
+  def correct_block(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#117
+  def correct_block_pass(corrector, node); end
+
+  # Returns range of last argument including comma and whitespace.
+  #
+  # @return [Parser::Source::Range]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#132
+  def last_arg_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#136
+  def unsorted_dir_loop?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#140
+  def unsorted_dir_pass?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/non_deterministic_require_order.rb#63
+RuboCop::Cop::Lint::NonDeterministicRequireOrder::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for non-local exits from iterators without a return
+# value. It registers an offense under these conditions:
+#
+# * No value is returned,
+# * the block is preceded by a method chain,
+# * the block has arguments,
+# * the method which receives the block is not `define_method`
+# or `define_singleton_method`,
+# * the return is not contained in an inner scope, e.g. a lambda or a
+# method definition.
+#
+# @example
+#
+#   class ItemApi
+#   rescue_from ValidationError do |e| # non-iteration block with arg
+#   return { message: 'validation error' } unless e.errors # allowed
+#   error_array = e.errors.map do |error| # block with method chain
+#   return if error.suppress? # warned
+#   return "#{error.param}: invalid" unless error.message # allowed
+#   "#{error.param}: #{error.message}"
+#   end
+#   { message: 'validation error', errors: error_array }
+#   end
+#
+#   def update_items
+#   transaction do # block without arguments
+#   return unless update_necessary? # allowed
+#   find_each do |item| # block without method chain
+#   return if item.stock == 0 # false-negative...
+#   item.update!(foobar: true)
+#   end
+#   end
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/non_local_exit_from_iterator.rb#41
+class RuboCop::Cop::Lint::NonLocalExitFromIterator < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/non_local_exit_from_iterator.rb#77
+  def chained_send?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_local_exit_from_iterator.rb#80
+  def define_method?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/non_local_exit_from_iterator.rb#46
+  def on_return(return_node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/non_local_exit_from_iterator.rb#72
+  def return_value?(return_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/non_local_exit_from_iterator.rb#68
+  def scoped_node?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/non_local_exit_from_iterator.rb#42
+RuboCop::Cop::Lint::NonLocalExitFromIterator::MSG = T.let(T.unsafe(nil), String)
+
+# Warns the usage of unsafe number conversions. Unsafe
+# number conversion can cause unexpected error if auto type conversion
+# fails. Cop prefer parsing with number class instead.
+#
+# Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError`
+# if given input that is not numeric (eg. an empty string), whereas
+# `to_i`, etc. will try to convert regardless of input (``''.to_i => 0``).
+# As such, this cop is disabled by default because it's not necessarily
+# always correct to raise if a value is not numeric.
+#
+# NOTE: Some values cannot be converted properly using one of the `Kernel`
+# method (for instance, `Time` and `DateTime` values are allowed by this
+# cop by default). Similarly, Rails' duration methods do not work well
+# with `Integer()` and can be allowed with `AllowedMethods`. By default,
+# there are no methods to allowed.
+#
+# @example
+#
+#   # bad
+#
+#   '10'.to_i
+#   '10.2'.to_f
+#   '10'.to_c
+#   '1/3'.to_r
+#   ['1', '2', '3'].map(&:to_i)
+#   foo.try(:to_f)
+#   bar.send(:to_c)
+#
+#   # good
+#
+#   Integer('10', 10)
+#   Float('10.2')
+#   Complex('10')
+#   Rational('1/3')
+#   ['1', '2', '3'].map { |i| Integer(i, 10) }
+#   foo.try { |i| Float(i) }
+#   bar.send { |i| Complex(i) }
+# @example AllowedMethods: [] (default)
+#
+#   # bad
+#   10.minutes.to_i
+# @example AllowedMethods: [minutes]
+#
+#   # good
+#   10.minutes.to_i
+# @example AllowedPatterns: [] (default)
+#
+#   # bad
+#   10.minutes.to_i
+# @example AllowedPatterns: ['min*']
+#
+#   # good
+#   10.minutes.to_i
+# @example IgnoredClasses: [Time, DateTime] (default)
+#
+#   # good
+#   Time.now.to_datetime.to_i
+#
+# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#73
+class RuboCop::Cop::Lint::NumberConversion < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#107
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#107
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#93
+  def to_method(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#98
+  def to_method_symbol(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#165
+  def allow_receiver?(receiver); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#177
+  def allowed_method_name?(name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#187
+  def conversion_method?(method_name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#151
+  def correct_method(node, receiver); end
+
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#155
+  def correct_sym_method(to_method); end
+
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#134
+  def handle_as_symbol(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#115
+  def handle_conversion_method(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#195
+  def ignored_class?(name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#191
+  def ignored_classes; end
+
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#160
+  def remove_parentheses(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#181
+  def top_receiver(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#89
+RuboCop::Cop::Lint::NumberConversion::CONVERSION_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#79
+RuboCop::Cop::Lint::NumberConversion::CONVERSION_METHOD_CLASS_MAPPING = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#90
+RuboCop::Cop::Lint::NumberConversion::METHODS = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/number_conversion.rb#85
+RuboCop::Cop::Lint::NumberConversion::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for uses of numbered parameter assignment.
+# It emulates the following warning in Ruby 2.7:
+#
+#   $ ruby -ve '_1 = :value'
+#   ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19]
+#   -e:1: warning: `_1' is reserved for numbered parameter; consider another name
+#
+# Assigning to a numbered parameter (from `_1` to `_9`) causes an error in Ruby 3.0.
+#
+#   $ ruby -ve '_1 = :value'
+#   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
+#   -e:1: _1 is reserved for numbered parameter
+#
+# NOTE: The parametered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
+# as well to prevent confusion.
+#
+# @example
+#
+#   # bad
+#   _1 = :value
+#
+#   # good
+#   non_numbered_parameter_name = :value
+#
+# source://rubocop//lib/rubocop/cop/lint/numbered_parameter_assignment.rb#30
+class RuboCop::Cop::Lint::NumberedParameterAssignment < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/numbered_parameter_assignment.rb#35
+  def on_lvasgn(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/numbered_parameter_assignment.rb#32
+RuboCop::Cop::Lint::NumberedParameterAssignment::LVAR_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/numbered_parameter_assignment.rb#33
+RuboCop::Cop::Lint::NumberedParameterAssignment::NUMBERED_PARAMETER_RANGE = T.let(T.unsafe(nil), Range)
+
+# source://rubocop//lib/rubocop/cop/lint/numbered_parameter_assignment.rb#31
+RuboCop::Cop::Lint::NumberedParameterAssignment::NUM_PARAM_MSG = T.let(T.unsafe(nil), String)
+
+# Checks for unintended or-assignment to a constant.
+#
+# Constants should always be assigned in the same location. And its value
+# should always be the same. If constants are assigned in multiple
+# locations, the result may vary depending on the order of `require`.
+#
+# @example
+#
+#   # bad
+#   CONST ||= 1
+#
+#   # good
+#   CONST = 1
+#
+# source://rubocop//lib/rubocop/cop/lint/or_assignment_to_constant.rb#24
+class RuboCop::Cop::Lint::OrAssignmentToConstant < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/or_assignment_to_constant.rb#29
+  def on_or_asgn(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/or_assignment_to_constant.rb#27
+RuboCop::Cop::Lint::OrAssignmentToConstant::MSG = T.let(T.unsafe(nil), String)
+
+# Checks the proper ordering of magic comments and whether
+# a magic comment is not placed before a shebang.
+#
+# @example
+#   # bad
+#
+#   # frozen_string_literal: true
+#   # encoding: ascii
+#   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:UTF-8>]
+#
+#   # good
+#
+#   # encoding: ascii
+#   # frozen_string_literal: true
+#   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:US-ASCII>]
+#
+#   # good
+#
+#   #!/usr/bin/env ruby
+#   # encoding: ascii
+#   # frozen_string_literal: true
+#   p [''.frozen?, ''.encoding] #=> [true, #<Encoding:US-ASCII>]
+#
+# source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#32
+class RuboCop::Cop::Lint::OrderedMagicComments < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::FrozenStringLiteral
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#38
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#55
+  def autocorrect(corrector, encoding_line, frozen_string_literal_line); end
+
+  # source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#63
+  def magic_comment_lines; end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/ordered_magic_comments.rb#36
+RuboCop::Cop::Lint::OrderedMagicComments::MSG = T.let(T.unsafe(nil), String)
+
+# Looks for references of Regexp captures that are out of range
+# and thus always returns nil.
+#
+# @example
+#
+#   /(foo)bar/ =~ 'foobar'
+#
+#   # bad - always returns nil
+#
+#   puts $2 # => nil
+#
+#   # good
+#
+#   puts $1 # => foo
+#
+# source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#38
+class RuboCop::Cop::Lint::OutOfRangeRegexpRef < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#55
+  def after_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#71
+  def on_in_pattern(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#51
+  def on_match_with_lvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#47
+  def on_new_investigation; end
+
+  # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#77
+  def on_nth_ref(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#65
+  def on_when(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#102
+  def check_regexp(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#122
+  def nth_ref_receiver?(send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#113
+  def regexp_first_argument?(send_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#93
+  def regexp_patterns(in_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#118
+  def regexp_receiver?(send_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#39
+RuboCop::Cop::Lint::OutOfRangeRegexpRef::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#42
+RuboCop::Cop::Lint::OutOfRangeRegexpRef::REGEXP_ARGUMENT_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#44
+RuboCop::Cop::Lint::OutOfRangeRegexpRef::REGEXP_CAPTURE_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#41
+RuboCop::Cop::Lint::OutOfRangeRegexpRef::REGEXP_RECEIVER_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/lint/out_of_range_regexp_ref.rb#45
+RuboCop::Cop::Lint::OutOfRangeRegexpRef::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
+
+# Checks for space between the name of a called method and a left
+# parenthesis.
+#
+# @example
+#
+#   # bad
+#   do_something (foo)
+#
+#   # good
+#   do_something(foo)
+#   do_something (2 + 3) * 4
+#   do_something (foo * bar).baz
+#
+# source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#18
+class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#24
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#24
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#60
+  def chained_calls?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#56
+  def compound_range?(first_arg); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#47
+  def first_argument_block_type?(first_arg); end
+
+  # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#85
+  def space_range(expr, space_length); end
+
+  # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#69
+  def spaces_before_left_parenthesis(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#65
+  def ternary_expression?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#39
+  def valid_context?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#51
+  def valid_first_argument?(first_arg); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb#22
+RuboCop::Cop::Lint::ParenthesesAsGroupedExpression::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for quotes and commas in %w, e.g. `%w('foo', "bar")`
+#
+# It is more likely that the additional characters are unintended (for
+# example, mistranslating an array of literals to percent string notation)
+# rather than meant to be part of the resulting strings.
+#
+# @example
+#
+#   # bad
+#   %w('foo', "bar")
+#
+#   # good
+#   %w(foo bar)
+#
+# source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#29
+class RuboCop::Cop::Lint::PercentStringArray < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::PercentLiteral
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#40
+  def on_array(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#44
+  def on_percent_literal(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#61
+  def contains_quotes_or_commas?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#34
+RuboCop::Cop::Lint::PercentStringArray::LEADING_QUOTE = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#37
+RuboCop::Cop::Lint::PercentStringArray::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#33
+RuboCop::Cop::Lint::PercentStringArray::QUOTES_AND_COMMAS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/percent_string_array.rb#35
+RuboCop::Cop::Lint::PercentStringArray::TRAILING_QUOTE = T.let(T.unsafe(nil), Regexp)
+
+# Checks for colons and commas in %i, e.g. `%i(:foo, :bar)`
+#
+# It is more likely that the additional characters are unintended (for
+# example, mistranslating an array of literals to percent string notation)
+# rather than meant to be part of the resulting symbols.
+#
+# @example
+#
+#   # bad
+#   %i(:foo, :bar)
+#
+#   # good
+#   %i(foo bar)
+#
+# source://rubocop//lib/rubocop/cop/lint/percent_symbol_array.rb#19
+class RuboCop::Cop::Lint::PercentSymbolArray < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::PercentLiteral
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/percent_symbol_array.rb#26
+  def on_array(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/percent_symbol_array.rb#30
+  def on_percent_literal(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/percent_symbol_array.rb#38
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/percent_symbol_array.rb#48
+  def contains_colons_or_commas?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/percent_symbol_array.rb#58
+  def non_alphanumeric_literal?(literal); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/percent_symbol_array.rb#23
+RuboCop::Cop::Lint::PercentSymbolArray::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for `raise` or `fail` statements which are
+# raising `Exception` class.
+#
+# You can specify a module name that will be an implicit namespace
+# using `AllowedImplicitNamespaces` option. The cop cause a false positive
+# for namespaced `Exception` when a namespace is omitted. This option can
+# prevent the false positive by specifying a namespace to be omitted for
+# `Exception`. Alternatively, make `Exception` a fully qualified class
+# name with an explicit namespace.
+#
+# @example
+#   # bad
+#   raise Exception, 'Error message here'
+#
+#   # good
+#   raise StandardError, 'Error message here'
+# @example AllowedImplicitNamespaces: ['Gem']
+#   # good
+#   module Gem
+#   def self.foo
+#   raise Exception # This exception means `Gem::Exception`.
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#34
+class RuboCop::Cop::Lint::RaiseException < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#41
+  def exception?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#46
+  def exception_new_with_message?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#51
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#85
+  def allow_implicit_namespaces; end
+
+  # source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#57
+  def check(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#73
+  def implicit_namespace?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#37
+RuboCop::Cop::Lint::RaiseException::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/raise_exception.rb#38
+RuboCop::Cop::Lint::RaiseException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for `rand(1)` calls.
+# Such calls always return `0`.
+#
+# @example
+#
+#   # bad
+#   rand 1
+#   Kernel.rand(-1)
+#   rand 1.0
+#   rand(-1.0)
+#
+#   # good
+#   0 # just use 0 instead
+#
+# source://rubocop//lib/rubocop/cop/lint/rand_one.rb#19
+class RuboCop::Cop::Lint::RandOne < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/rand_one.rb#28
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/rand_one.rb#24
+  def rand_one?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/rand_one.rb#36
+  def message(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/rand_one.rb#20
+RuboCop::Cop::Lint::RandOne::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/rand_one.rb#21
+RuboCop::Cop::Lint::RandOne::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# removed without causing any offenses to be reported. It's implemented
+# as a cop in that it inherits from the Cop base class and calls
+# add_offense. The unusual part of its implementation is that it doesn't
+# have any on_* methods or an investigate method. This means that it
+# doesn't take part in the investigation phase when the other cops do
+# their work. Instead, it waits until it's called in a later stage of the
+# execution. The reason it can't be implemented as a normal cop is that
+# it depends on the results of all other cops to do its work.
+#
+# @example
+#   # bad
+#   # rubocop:disable Layout/LineLength
+#   x += 1
+#   # rubocop:enable Layout/LineLength
+#
+#   # good
+#   x += 1
+#
+# source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#28
+class RuboCop::Cop::Lint::RedundantCopDisableDirective < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # @return [RedundantCopDisableDirective] a new instance of RedundantCopDisableDirective
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#37
+  def initialize(config = T.unsafe(nil), options = T.unsafe(nil), offenses = T.unsafe(nil)); end
+
+  # Returns the value of attribute offenses_to_check.
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#35
+  def offenses_to_check; end
+
+  # Sets the attribute offenses_to_check
+  #
+  # @param value the value to set the attribute offenses_to_check to.
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#35
+  def offenses_to_check=(_arg0); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#42
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#323
+  def add_department_marker(department); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#229
+  def add_offense_for_entire_comment(comment, cops); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#244
+  def add_offense_for_some_cops(comment, cops); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#219
+  def add_offenses(redundant_cops); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#306
+  def all_cop_names; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#190
+  def all_disabled?(comment); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#69
+  def comment_range_with_surrounding_space(directive_comment_range, line_comment_range); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#57
+  def cop_disabled_line_ranges; end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#264
+  def cop_range(comment, cop); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#210
+  def department_disabled?(cop, comment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#315
+  def department_marker?(department); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#293
+  def describe(cop); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#215
+  def directive_count(comment); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#92
+  def directive_range_in_list(range, ranges); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#61
+  def disabled_ranges; end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#132
+  def each_already_disabled(cop, line_ranges); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#113
+  def each_line_range(cop, line_ranges); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#106
+  def each_redundant_disable(&block); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#310
+  def ends_its_line?(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#202
+  def expected_final_disable?(cop, line_range); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#166
+  def find_redundant_all(range, next_range); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#161
+  def find_redundant_cop(cop, range); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#176
+  def find_redundant_department(cop, range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#182
+  def followed_ranges?(range, next_range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#194
+  def ignore_offense?(line_range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#258
+  def leave_free_comment?(comment, range); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#271
+  def matching_range(haystack, needle); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#302
+  def message(cop_names); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#65
+  def previous_line_blank?(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#186
+  def range_with_offense?(range, offenses = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#319
+  def remove_department_marker(department); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#279
+  def trailing_range?(ranges, range); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#32
+RuboCop::Cop::Lint::RedundantCopDisableDirective::COP_NAME = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#33
+RuboCop::Cop::Lint::RedundantCopDisableDirective::DEPARTMENT_MARKER = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_cop_disable_directive.rb#287
+RuboCop::Cop::Lint::RedundantCopDisableDirective::SIMILAR_COP_NAMES_CACHE = T.let(T.unsafe(nil), Hash)
+
+# removed.
+#
+# that cop checks whether any cop was actually enabled.
+#
+# @example
+#
+#   # bad
+#   foo = 1
+#   # rubocop:enable Layout/LineLength
+#
+#   # good
+#   foo = 1
+#
+#   # bad
+#   # rubocop:disable Style/StringLiterals
+#   foo = "1"
+#   # rubocop:enable Style/StringLiterals
+#   baz
+#   # rubocop:enable all
+#
+#   # good
+#   # rubocop:disable Style/StringLiterals
+#   foo = "1"
+#   # rubocop:enable all
+#   baz
+#
+# source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#39
+class RuboCop::Cop::Lint::RedundantCopEnableDirective < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::SurroundingSpace
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#46
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#122
+  def all_or_name(name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#78
+  def comment_start(comment); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#82
+  def cop_name_indention(comment, name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#126
+  def department?(directive, name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#73
+  def range_of_offense(comment, name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#97
+  def range_to_remove(begin_pos, end_pos, comment); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#86
+  def range_with_comma(comment, name); end
+
+  # If the list of cops is comma-separated, but without a empty space after the comma,
+  # we should **not** remove the prepending empty space, thus begin_pos += 1
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#116
+  def range_with_comma_after(comment, start, begin_pos, end_pos); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#110
+  def range_with_comma_before(start, begin_pos, end_pos); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#55
+  def register_offense(comment, cop_names); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_cop_enable_directive.rb#44
+RuboCop::Cop::Lint::RedundantCopEnableDirective::MSG = T.let(T.unsafe(nil), String)
+
+# Sort globbed results by default in Ruby 3.0.
+# This cop checks for redundant `sort` method to `Dir.glob` and `Dir[]`.
+#
+# @example
+#
+#   # bad
+#   Dir.glob('./lib/**/*.rb').sort.each do |file|
+#   end
+#
+#   Dir['./lib/**/*.rb'].sort.each do |file|
+#   end
+#
+#   # good
+#   Dir.glob('./lib/**/*.rb').each do |file|
+#   end
+#
+#   Dir['./lib/**/*.rb'].each do |file|
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/redundant_dir_glob_sort.rb#30
+class RuboCop::Cop::Lint::RedundantDirGlobSort < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_dir_glob_sort.rb#40
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_dir_glob_sort.rb#56
+  def multiple_argument?(glob_method); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_dir_glob_sort.rb#38
+RuboCop::Cop::Lint::RedundantDirGlobSort::GLOB_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_dir_glob_sort.rb#36
+RuboCop::Cop::Lint::RedundantDirGlobSort::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_dir_glob_sort.rb#37
+RuboCop::Cop::Lint::RedundantDirGlobSort::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for redundant quantifiers inside Regexp literals.
+#
+# It is always allowed when interpolation is used in a regexp literal,
+# because it's unknown what kind of string will be expanded as a result:
+#
+# [source,ruby]
+# ----
+# /(?:a*#{interpolation})?/x
+# ----
+#
+# @example
+#   # bad
+#   /(?:x+)+/
+#
+#   # good
+#   /(?:x)+/
+#
+#   # good
+#   /(?:x+)/
+#
+#   # bad
+#   /(?:x+)?/
+#
+#   # good
+#   /(?:x)*/
+#
+#   # good
+#   /(?:x*)/
+#
+# source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#34
+class RuboCop::Cop::Lint::RedundantRegexpQuantifiers < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#42
+  def on_regexp(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#83
+  def character_set?(expr); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#61
+  def each_redundantly_quantified_pair(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#87
+  def mergeable_quantifier(expr); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#103
+  def merged_quantifier(exp1, exp2); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#119
+  def message(group, child, replacement); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#115
+  def quantifier_range(group, child); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#75
+  def redundant_group?(expr); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#79
+  def redundantly_quantifiable?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_regexp_quantifiers.rb#38
+RuboCop::Cop::Lint::RedundantRegexpQuantifiers::MSG_REDUNDANT_QUANTIFIER = T.let(T.unsafe(nil), String)
+
+# Checks for unnecessary `require` statement.
+#
+# The following features are unnecessary `require` statement because
+# they are already loaded. e.g. Ruby 2.2:
+#
+#   ruby -ve 'p $LOADED_FEATURES.reject { |feature| %r|/| =~ feature }'
+#   ruby 2.2.8p477 (2017-09-14 revision 59906) [x86_64-darwin13]
+#   ["enumerator.so", "rational.so", "complex.so", "thread.rb"]
+#
+# Below are the features that each `TargetRubyVersion` targets.
+#
+#   * 2.0+ ... `enumerator`
+#   * 2.1+ ... `thread`
+#   * 2.2+ ... Add `rational` and `complex` above
+#   * 2.5+ ... Add `pp` above
+#   * 2.7+ ... Add `ruby2_keywords` above
+#   * 3.1+ ... Add `fiber` above
+#   * 3.2+ ... `set`
+#
+# This cop target those features.
+#
+# @example
+#   # bad
+#   require 'unloaded_feature'
+#   require 'thread'
+#
+#   # good
+#   require 'unloaded_feature'
+#
+# source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#38
+class RuboCop::Cop::Lint::RedundantRequireStatement < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#61
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#57
+  def pp_const?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#51
+  def redundant_require_statement?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#91
+  def need_to_require_pp?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#80
+  def redundant_feature?(feature_name); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#42
+RuboCop::Cop::Lint::RedundantRequireStatement::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#45
+RuboCop::Cop::Lint::RedundantRequireStatement::PRETTY_PRINT_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#43
+RuboCop::Cop::Lint::RedundantRequireStatement::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_require_statement.rb#44
+RuboCop::Cop::Lint::RedundantRequireStatement::RUBY_22_LOADED_FEATURES = T.let(T.unsafe(nil), Array)
+
+# Checks for redundant safe navigation calls.
+# Use cases where a constant, named in camel case for classes and modules is `nil` are rare,
+# and an offense is not detected when the receiver is a constant. The detection also applies
+# to literal receivers, except for `nil`.
+#
+# For all receivers, the `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`,
+# and `equal?` methods are checked by default.
+# These are customizable with `AllowedMethods` option.
+#
+# The `AllowedMethods` option specifies nil-safe methods,
+# in other words, it is a method that is allowed to skip safe navigation.
+# Note that the `AllowedMethod` option is not an option that specifies methods
+# for which to suppress (allow) this cop's check.
+#
+# In the example below, the safe navigation operator (`&.`) is unnecessary
+# because `NilClass` has methods like `respond_to?` and `is_a?`.
+#
+# @example
+#   # bad
+#   CamelCaseConst&.do_something
+#
+#   # bad
+#   do_something if attrs&.respond_to?(:[])
+#
+#   # good
+#   do_something if attrs.respond_to?(:[])
+#
+#   # bad
+#   while node&.is_a?(BeginNode)
+#   node = node.parent
+#   end
+#
+#   # good
+#   CamelCaseConst.do_something
+#
+#   # good
+#   while node.is_a?(BeginNode)
+#   node = node.parent
+#   end
+#
+#   # good - without `&.` this will always return `true`
+#   foo&.respond_to?(:to_a)
+#
+#   # bad - for `nil`s conversion methods return default values for the type
+#   foo&.to_h || {}
+#   foo&.to_h { |k, v| [k, v] } || {}
+#   foo&.to_a || []
+#   foo&.to_i || 0
+#   foo&.to_f || 0.0
+#   foo&.to_s || ''
+#
+#   # good
+#   foo.to_h
+#   foo.to_h { |k, v| [k, v] }
+#   foo.to_a
+#   foo.to_i
+#   foo.to_f
+#   foo.to_s
+# @example AllowedMethods: [nil_safe_method]
+#   # bad
+#   do_something if attrs&.nil_safe_method(:[])
+#
+#   # good
+#   do_something if attrs.nil_safe_method(:[])
+#   do_something if attrs&.not_nil_safe_method(:[])
+#
+# source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#78
+class RuboCop::Cop::Lint::RedundantSafeNavigation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#95
+  def conversion_with_default?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#107
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#117
+  def on_or(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#90
+  def respond_to_nil_specific_method?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#133
+  def assume_receiver_instance_exists?(receiver); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#139
+  def check?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#149
+  def condition?(parent, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#82
+RuboCop::Cop::Lint::RedundantSafeNavigation::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#83
+RuboCop::Cop::Lint::RedundantSafeNavigation::MSG_LITERAL = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#85
+RuboCop::Cop::Lint::RedundantSafeNavigation::NIL_SPECIFIC_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_safe_navigation.rb#87
+RuboCop::Cop::Lint::RedundantSafeNavigation::SNAKE_CASE = T.let(T.unsafe(nil), Regexp)
+
+# Checks for unneeded usages of splat expansion.
+#
+# @example
+#
+#   # bad
+#   a = *[1, 2, 3]
+#   a = *'a'
+#   a = *1
+#   ['a', 'b', *%w(c d e), 'f', 'g']
+#
+#   # good
+#   c = [1, 2, 3]
+#   a = *c
+#   a, b = *c
+#   a, *b = *c
+#   a = *1..10
+#   a = ['a']
+#   ['a', 'b', 'c', 'd', 'e', 'f', 'g']
+#
+#   # bad
+#   do_something(*['foo', 'bar', 'baz'])
+#
+#   # good
+#   do_something('foo', 'bar', 'baz')
+#
+#   # bad
+#   begin
+#   foo
+#   rescue *[StandardError, ApplicationError]
+#   bar
+#   end
+#
+#   # good
+#   begin
+#   foo
+#   rescue StandardError, ApplicationError
+#   bar
+#   end
+#
+#   # bad
+#   case foo
+#   when *[1, 2, 3]
+#   bar
+#   else
+#   baz
+#   end
+#
+#   # good
+#   case foo
+#   when 1, 2, 3
+#   bar
+#   else
+#   baz
+#   end
+# @example AllowPercentLiteralArrayArgument: true (default)
+#
+#   # good
+#   do_something(*%w[foo bar baz])
+# @example AllowPercentLiteralArrayArgument: false
+#
+#   # bad
+#   do_something(*%w[foo bar baz])
+#
+# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#71
+class RuboCop::Cop::Lint::RedundantSplatExpansion < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#83
+  def array_new?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#91
+  def literal_expansion(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#95
+  def on_splat(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#203
+  def allow_percent_literal_array_argument?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#131
+  def array_new_inside_array_literal?(array_new_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#155
+  def array_splat?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#112
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#159
+  def method_argument?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#163
+  def part_of_an_array?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#170
+  def redundant_brackets?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#118
+  def redundant_splat_expansion(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#178
+  def remove_brackets(array); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#138
+  def replacement_range_and_content(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#196
+  def use_percent_literal_array_argument?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#75
+RuboCop::Cop::Lint::RedundantSplatExpansion::ARRAY_PARAM_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#80
+RuboCop::Cop::Lint::RedundantSplatExpansion::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#74
+RuboCop::Cop::Lint::RedundantSplatExpansion::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#79
+RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_CAPITAL_I = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#77
+RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_CAPITAL_W = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#78
+RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_I = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_splat_expansion.rb#76
+RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_W = T.let(T.unsafe(nil), String)
+
+# Checks for string conversion in string interpolation, `print`, `puts`, and `warn` arguments,
+# which is redundant.
+#
+# @example
+#
+#   # bad
+#   "result is #{something.to_s}"
+#   print something.to_s
+#   puts something.to_s
+#   warn something.to_s
+#
+#   # good
+#   "result is #{something}"
+#   print something
+#   puts something
+#   warn something
+#
+# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#23
+class RuboCop::Cop::Lint::RedundantStringCoercion < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Interpolation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#34
+  def on_interpolation(begin_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#42
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#32
+  def to_s_without_args?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#54
+  def register_offense(node, context); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#27
+RuboCop::Cop::Lint::RedundantStringCoercion::MSG_DEFAULT = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#28
+RuboCop::Cop::Lint::RedundantStringCoercion::MSG_SELF = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_string_coercion.rb#29
+RuboCop::Cop::Lint::RedundantStringCoercion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for redundant `with_index`.
+#
+# @example
+#   # bad
+#   ary.each_with_index do |v|
+#   v
+#   end
+#
+#   # good
+#   ary.each do |v|
+#   v
+#   end
+#
+#   # bad
+#   ary.each.with_index do |v|
+#   v
+#   end
+#
+#   # good
+#   ary.each do |v|
+#   v
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#29
+class RuboCop::Cop::Lint::RedundantWithIndex < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#37
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#37
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#60
+  def redundant_with_index?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#70
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#78
+  def with_index_range(send); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#33
+RuboCop::Cop::Lint::RedundantWithIndex::MSG_EACH_WITH_INDEX = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_with_index.rb#34
+RuboCop::Cop::Lint::RedundantWithIndex::MSG_WITH_INDEX = T.let(T.unsafe(nil), String)
+
+# Checks for redundant `with_object`.
+#
+# @example
+#   # bad
+#   ary.each_with_object([]) do |v|
+#   v
+#   end
+#
+#   # good
+#   ary.each do |v|
+#   v
+#   end
+#
+#   # bad
+#   ary.each.with_object([]) do |v|
+#   v
+#   end
+#
+#   # good
+#   ary.each do |v|
+#   v
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#29
+class RuboCop::Cop::Lint::RedundantWithObject < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#36
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#36
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#56
+  def redundant_with_object?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#65
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#73
+  def with_object_range(send); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#33
+RuboCop::Cop::Lint::RedundantWithObject::MSG_EACH_WITH_OBJECT = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/redundant_with_object.rb#34
+RuboCop::Cop::Lint::RedundantWithObject::MSG_WITH_OBJECT = T.let(T.unsafe(nil), String)
+
+# Checks if `include` or `prepend` is called in `refine` block.
+# These methods are deprecated and should be replaced with `Refinement#import_methods`.
+#
+# It emulates deprecation warnings in Ruby 3.1.
+#
+# @example
+#
+#   # bad
+#   refine Foo do
+#   include Bar
+#   end
+#
+#   # bad
+#   refine Foo do
+#   prepend Bar
+#   end
+#
+#   # good
+#   refine Foo do
+#   import_methods Bar
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/refinement_import_methods.rb#34
+class RuboCop::Cop::Lint::RefinementImportMethods < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/lint/refinement_import_methods.rb#42
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/refinement_import_methods.rb#37
+RuboCop::Cop::Lint::RefinementImportMethods::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/refinement_import_methods.rb#38
+RuboCop::Cop::Lint::RefinementImportMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for regexp literals used as `match-current-line`.
+# If a regexp literal is in condition, the regexp matches `$_` implicitly.
+#
+# @example
+#   # bad
+#   if /foo/
+#   do_something
+#   end
+#
+#   # good
+#   if /foo/ =~ $_
+#   do_something
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/regexp_as_condition.rb#19
+class RuboCop::Cop::Lint::RegexpAsCondition < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/regexp_as_condition.rb#26
+  def on_match_current_line(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/regexp_as_condition.rb#23
+RuboCop::Cop::Lint::RegexpAsCondition::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for expressions where there is a call to a predicate
+# method with at least one argument, where no parentheses are used around
+# the parameter list, and a boolean operator, && or ||, is used in the
+# last argument.
+#
+# The idea behind warning for these constructs is that the user might
+# be under the impression that the return value from the method call is
+# an operand of &&/||.
+#
+# @example
+#
+#   # bad
+#   if day.is? :tuesday && month == :jan
+#   # ...
+#   end
+#
+#   # good
+#   if day.is?(:tuesday) && month == :jan
+#   # ...
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/require_parentheses.rb#26
+class RuboCop::Cop::Lint::RequireParentheses < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/lint/require_parentheses.rb#31
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/require_parentheses.rb#31
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/require_parentheses.rb#54
+  def check_predicate(predicate, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/require_parentheses.rb#44
+  def check_ternary(ternary, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/require_parentheses.rb#29
+RuboCop::Cop::Lint::RequireParentheses::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that a range literal is enclosed in parentheses when the end of the range is
+# at a line break.
+#
+# NOTE: The following is maybe intended for `(42..)`. But, compatible is `42..do_something`.
+# So, this cop does not provide autocorrection because it is left to user.
+#
+# [source,ruby]
+# ----
+# case condition
+# when 42..
+#   do_something
+# end
+# ----
+#
+# @example
+#
+#   # bad - Represents `(1..42)`, not endless range.
+#   1..
+#   42
+#
+#   # good - It's incompatible, but your intentions when using endless range may be:
+#   (1..)
+#   42
+#
+#   # good
+#   1..42
+#
+#   # good
+#   (1..42)
+#
+#   # good
+#   (1..
+#   42)
+#
+# source://rubocop//lib/rubocop/cop/lint/require_range_parentheses.rb#40
+class RuboCop::Cop::Lint::RequireRangeParentheses < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/require_range_parentheses.rb#43
+  def on_erange(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/require_range_parentheses.rb#43
+  def on_irange(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/require_range_parentheses.rb#41
+RuboCop::Cop::Lint::RequireRangeParentheses::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for uses a file requiring itself with `require_relative`.
+#
+# @example
+#
+#   # bad
+#
+#   # foo.rb
+#   require_relative 'foo'
+#   require_relative 'bar'
+#
+#   # good
+#
+#   # foo.rb
+#   require_relative 'bar'
+#
+# source://rubocop//lib/rubocop/cop/lint/require_relative_self_path.rb#21
+class RuboCop::Cop::Lint::RequireRelativeSelfPath < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/require_relative_self_path.rb#28
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/require_relative_self_path.rb#44
+  def remove_ext(file_path); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/require_relative_self_path.rb#40
+  def same_file?(file_path, required_feature); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/require_relative_self_path.rb#25
+RuboCop::Cop::Lint::RequireRelativeSelfPath::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/require_relative_self_path.rb#26
+RuboCop::Cop::Lint::RequireRelativeSelfPath::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for `rescue` blocks targeting the Exception class.
+#
+# @example
+#
+#   # bad
+#   begin
+#   do_something
+#   rescue Exception
+#   handle_exception
+#   end
+#
+#   # good
+#   begin
+#   do_something
+#   rescue ArgumentError
+#   handle_exception
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/rescue_exception.rb#23
+class RuboCop::Cop::Lint::RescueException < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/rescue_exception.rb#26
+  def on_resbody(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/rescue_exception.rb#35
+  def targets_exception?(rescue_arg_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/rescue_exception.rb#24
+RuboCop::Cop::Lint::RescueException::MSG = T.let(T.unsafe(nil), String)
+
+# Check for arguments to `rescue` that will result in a `TypeError`
+# if an exception is raised.
+#
+# @example
+#   # bad
+#   begin
+#   bar
+#   rescue nil
+#   baz
+#   end
+#
+#   # bad
+#   def foo
+#   bar
+#   rescue 1, 'a', "#{b}", 0.0, [], {}
+#   baz
+#   end
+#
+#   # good
+#   begin
+#   bar
+#   rescue
+#   baz
+#   end
+#
+#   # good
+#   def foo
+#   bar
+#   rescue NameError
+#   baz
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#37
+class RuboCop::Cop::Lint::RescueType < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#60
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#44
+  def on_resbody(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#69
+  def correction(*exceptions); end
+
+  # source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#80
+  def invalid_exceptions(exceptions); end
+
+  # source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#76
+  def valid_exceptions(exceptions); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#42
+RuboCop::Cop::Lint::RescueType::INVALID_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/rescue_type.rb#40
+RuboCop::Cop::Lint::RescueType::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the use of a return with a value in a context
+# where the value will be ignored. (initialize and setter methods)
+#
+# @example
+#
+#   # bad
+#   def initialize
+#   foo
+#   return :qux if bar?
+#   baz
+#   end
+#
+#   def foo=(bar)
+#   return 42
+#   end
+#
+#   # good
+#   def initialize
+#   foo
+#   return if bar?
+#   baz
+#   end
+#
+#   def foo=(bar)
+#   return
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/return_in_void_context.rb#32
+class RuboCop::Cop::Lint::ReturnInVoidContext < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/return_in_void_context.rb#35
+  def on_return(return_node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/return_in_void_context.rb#51
+  def non_void_context(return_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/return_in_void_context.rb#33
+RuboCop::Cop::Lint::ReturnInVoidContext::MSG = T.let(T.unsafe(nil), String)
+
+# The safe navigation operator returns nil if the receiver is
+# nil. If you chain an ordinary method call after a safe
+# navigation operator, it raises NoMethodError. We should use a
+# safe navigation operator after a safe navigation operator.
+# This cop checks for the problem outlined above.
+#
+# @example
+#
+#   # bad
+#   x&.foo.bar
+#   x&.foo + bar
+#   x&.foo[bar]
+#
+#   # good
+#   x&.foo&.bar
+#   x&.foo || bar
+#
+# source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#22
+class RuboCop::Cop::Lint::SafeNavigationChain < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::NilMethods
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#33
+  def bad_method?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#40
+  def on_send(node); end
+
+  private
+
+  # @param offense_range [Parser::Source::Range]
+  # @param send_node [RuboCop::AST::SendNode]
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#58
+  def add_safe_navigation_operator(offense_range:, send_node:); end
+
+  # @param corrector [RuboCop::Cop::Corrector]
+  # @param offense_range [Parser::Source::Range]
+  # @param send_node [RuboCop::AST::SendNode]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#77
+  def autocorrect(corrector, offense_range:, send_node:); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#86
+  def brackets?(send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#90
+  def require_parentheses?(send_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#29
+RuboCop::Cop::Lint::SafeNavigationChain::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/safe_navigation_chain.rb#30
+RuboCop::Cop::Lint::SafeNavigationChain::PLUS_MINUS_METHODS = T.let(T.unsafe(nil), Array)
+
+# Check to make sure that if safe navigation is used in an `&&` or `||` condition,
+# consistent and appropriate safe navigation, without excess or deficiency,
+# is used for all method calls on the same object.
+#
+# @example
+#   # bad
+#   foo&.bar && foo&.baz
+#
+#   # good
+#   foo&.bar && foo.baz
+#
+#   # bad
+#   foo.bar && foo&.baz
+#
+#   # good
+#   foo.bar && foo.baz
+#
+#   # bad
+#   foo&.bar || foo.baz
+#
+#   # good
+#   foo&.bar || foo&.baz
+#
+#   # bad
+#   foo.bar || foo&.baz
+#
+#   # good
+#   foo.bar || foo.baz
+#
+#   # bad
+#   foo&.bar && (foobar.baz || foo&.baz)
+#
+#   # good
+#   foo&.bar && (foobar.baz || foo.baz)
+#
+# source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#41
+class RuboCop::Cop::Lint::SafeNavigationConsistency < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::NilMethods
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#48
+  def on_and(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#48
+  def on_or(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#96
+  def already_appropriate_call?(operand, dot_op); end
+
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#67
+  def collect_operands(node, operand_nodes); end
+
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#83
+  def find_consistent_parts(grouped_operands); end
+
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#120
+  def most_left_indices(grouped_operands); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#150
+  def nilable?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#134
+  def operand_in_and?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#142
+  def operand_in_or?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#111
+  def operand_nodes(operand, operand_nodes); end
+
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#74
+  def receiver_name_as_key(method, fully_receivers); end
+
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#100
+  def register_offense(operand, dot_operator); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#45
+RuboCop::Cop::Lint::SafeNavigationConsistency::USE_DOT_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/safe_navigation_consistency.rb#46
+RuboCop::Cop::Lint::SafeNavigationConsistency::USE_SAFE_NAVIGATION_MSG = T.let(T.unsafe(nil), String)
+
+# Checks to make sure safe navigation isn't used with `empty?` in
+# a conditional.
+#
+# While the safe navigation operator is generally a good idea, when
+# checking `foo&.empty?` in a conditional, `foo` being `nil` will actually
+# do the opposite of what the author intends.
+#
+# @example
+#   # bad
+#   return if foo&.empty?
+#   return unless foo&.empty?
+#
+#   # good
+#   return if foo && foo.empty?
+#   return unless foo && foo.empty?
+#
+# source://rubocop//lib/rubocop/cop/lint/safe_navigation_with_empty.rb#22
+class RuboCop::Cop::Lint::SafeNavigationWithEmpty < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_with_empty.rb#32
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/safe_navigation_with_empty.rb#28
+  def safe_navigation_empty_in_conditional?(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/safe_navigation_with_empty.rb#25
+RuboCop::Cop::Lint::SafeNavigationWithEmpty::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if a file which has a shebang line as
+# its first line is granted execute permission.
+#
+# @example
+#   # bad
+#
+#   # A file which has a shebang line as its first line is not
+#   # granted execute permission.
+#
+#   #!/usr/bin/env ruby
+#   puts 'hello, world'
+#
+#   # good
+#
+#   # A file which has a shebang line as its first line is
+#   # granted execute permission.
+#
+#   #!/usr/bin/env ruby
+#   puts 'hello, world'
+#
+#   # good
+#
+#   # A file which has not a shebang line as its first line is not
+#   # granted execute permission.
+#
+#   puts 'hello, world'
+#
+# source://rubocop//lib/rubocop/cop/lint/script_permission.rb#33
+class RuboCop::Cop::Lint::ScriptPermission < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/script_permission.rb#39
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/script_permission.rb#55
+  def autocorrect; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/script_permission.rb#59
+  def executable?(processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/lint/script_permission.rb#66
+  def format_message_from(processed_source); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/script_permission.rb#36
+RuboCop::Cop::Lint::ScriptPermission::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/script_permission.rb#37
+RuboCop::Cop::Lint::ScriptPermission::SHEBANG = T.let(T.unsafe(nil), String)
+
+# Checks for self-assignments.
+#
+# @example
+#   # bad
+#   foo = foo
+#   foo, bar = foo, bar
+#   Foo = Foo
+#   hash['foo'] = hash['foo']
+#   obj.attr = obj.attr
+#
+#   # good
+#   foo = bar
+#   foo, bar = bar, foo
+#   Foo = Bar
+#   hash['foo'] = hash['bar']
+#   obj.attr = obj.attr2
+#
+#   # good (method calls possibly can return different results)
+#   hash[foo] = hash[foo]
+#
+# source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#26
+class RuboCop::Cop::Lint::SelfAssignment < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#69
+  def on_and_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#57
+  def on_casgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#36
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#45
+  def on_cvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#45
+  def on_gvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#45
+  def on_ivasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#45
+  def on_lvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#65
+  def on_masgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#69
+  def on_or_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#36
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#103
+  def handle_attribute_assignment(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#92
+  def handle_key_assignment(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#77
+  def multiple_self_assignment?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#87
+  def rhs_matches_lhs?(rhs, lhs); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#29
+RuboCop::Cop::Lint::SelfAssignment::ASSIGNMENT_TYPE_TO_RHS_TYPE = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/lint/self_assignment.rb#27
+RuboCop::Cop::Lint::SelfAssignment::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for `send`, `public_send`, and `__send__` methods
+# when using mix-in.
+#
+# `include` and `prepend` methods were private methods until Ruby 2.0,
+# they were mixed-in via `send` method. This cop uses Ruby 2.1 or
+# higher style that can be called by public methods.
+# And `extend` method that was originally a public method is also targeted
+# for style unification.
+#
+# @example
+#   # bad
+#   Foo.send(:include, Bar)
+#   Foo.send(:prepend, Bar)
+#   Foo.send(:extend, Bar)
+#
+#   # bad
+#   Foo.public_send(:include, Bar)
+#   Foo.public_send(:prepend, Bar)
+#   Foo.public_send(:extend, Bar)
+#
+#   # bad
+#   Foo.__send__(:include, Bar)
+#   Foo.__send__(:prepend, Bar)
+#   Foo.__send__(:extend, Bar)
+#
+#   # good
+#   Foo.include Bar
+#   Foo.prepend Bar
+#   Foo.extend Bar
+#
+# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#36
+class RuboCop::Cop::Lint::SendWithMixinArgument < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#53
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#46
+  def send_with_mixin_argument?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#67
+  def bad_location(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#73
+  def message(method, module_name, bad_method); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#77
+  def mixin_method?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#41
+RuboCop::Cop::Lint::SendWithMixinArgument::MIXIN_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#40
+RuboCop::Cop::Lint::SendWithMixinArgument::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#43
+RuboCop::Cop::Lint::SendWithMixinArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/send_with_mixin_argument.rb#42
+RuboCop::Cop::Lint::SendWithMixinArgument::SEND_METHODS = T.let(T.unsafe(nil), Array)
+
+# Checks for shadowed arguments.
+#
+# This cop has `IgnoreImplicitReferences` configuration option.
+# It means argument shadowing is used in order to pass parameters
+# to zero arity `super` when `IgnoreImplicitReferences` is `true`.
+#
+# @example
+#
+#   # bad
+#   do_something do |foo|
+#   foo = 42
+#   puts foo
+#   end
+#
+#   def do_something(foo)
+#   foo = 42
+#   puts foo
+#   end
+#
+#   # good
+#   do_something do |foo|
+#   foo = foo + 42
+#   puts foo
+#   end
+#
+#   def do_something(foo)
+#   foo = foo + 42
+#   puts foo
+#   end
+#
+#   def do_something(foo)
+#   puts foo
+#   end
+# @example IgnoreImplicitReferences: false (default)
+#
+#   # bad
+#   def do_something(foo)
+#   foo = 42
+#   super
+#   end
+#
+#   def do_something(foo)
+#   foo = super
+#   bar
+#   end
+# @example IgnoreImplicitReferences: true
+#
+#   # good
+#   def do_something(foo)
+#   foo = 42
+#   super
+#   end
+#
+#   def do_something(foo)
+#   foo = super
+#   bar
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#66
+class RuboCop::Cop::Lint::ShadowedArgument < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#76
+  def after_leaving_scope(scope, _variable_table); end
+
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#70
+  def uses_var?(param0, param1); end
+
+  private
+
+  # Get argument references without assignments' references
+  #
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#161
+  def argument_references(argument); end
+
+  # Find the first argument assignment, which doesn't reference the
+  # argument at the rhs. If the assignment occurs inside a branch or
+  # block, it is impossible to tell whether it's executed, so precise
+  # shadowing location is not known.
+  #
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#120
+  def assignment_without_argument_usage(argument); end
+
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#82
+  def check_argument(argument); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#171
+  def ignore_implicit_references?; end
+
+  # Check whether the given node is nested into block or conditional.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#152
+  def node_within_block_or_conditional?(node, stop_search_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#144
+  def reference_pos(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#95
+  def shadowing_assignment(argument); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#72
+    def joining_forces; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/shadowed_argument.rb#67
+RuboCop::Cop::Lint::ShadowedArgument::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for a rescued exception that get shadowed by a
+# less specific exception being rescued before a more specific
+# exception is rescued.
+#
+# An exception is considered shadowed if it is rescued after its
+# ancestor is, or if it and its ancestor are both rescued in the
+# same `rescue` statement. In both cases, the more specific rescue is
+# unnecessary because it is covered by rescuing the less specific
+# exception. (ie. `rescue Exception, StandardError` has the same behavior
+# whether `StandardError` is included or not, because all ``StandardError``s
+# are rescued by `rescue Exception`).
+#
+# @example
+#
+#   # bad
+#
+#   begin
+#   something
+#   rescue Exception
+#   handle_exception
+#   rescue StandardError
+#   handle_standard_error
+#   end
+#
+#   # bad
+#   begin
+#   something
+#   rescue Exception, StandardError
+#   handle_error
+#   end
+#
+#   # good
+#
+#   begin
+#   something
+#   rescue StandardError
+#   handle_standard_error
+#   rescue Exception
+#   handle_exception
+#   end
+#
+#   # good, however depending on runtime environment.
+#   #
+#   # This is a special case for system call errors.
+#   # System dependent error code depends on runtime environment.
+#   # For example, whether `Errno::EAGAIN` and `Errno::EWOULDBLOCK` are
+#   # the same error code or different error code depends on environment.
+#   # This good case is for `Errno::EAGAIN` and `Errno::EWOULDBLOCK` with
+#   # the same error code.
+#   begin
+#   something
+#   rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+#   handle_standard_error
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#61
+class RuboCop::Cop::Lint::ShadowedException < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RescueNode
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#67
+  def on_rescue(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#101
+  def compare_exceptions(exception, other_exception); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#94
+  def contains_multiple_levels_of_exceptions?(group); end
+
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#119
+  def evaluate_exceptions(group); end
+
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#152
+  def find_shadowing_rescue(rescues); end
+
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#84
+  def offense_range(rescues); end
+
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#90
+  def rescued_groups_for(rescues); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#137
+  def sorted?(rescued_groups); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#115
+  def system_call_err?(error); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/shadowed_exception.rb#65
+RuboCop::Cop::Lint::ShadowedException::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the use of local variable names from an outer scope
+# in block arguments or block-local variables. This mirrors the warning
+# given by `ruby -cw` prior to Ruby 2.6:
+# "shadowing outer local variable - foo".
+#
+# NOTE: Shadowing of variables in block passed to `Ractor.new` is allowed
+# because `Ractor` should not access outer variables.
+# eg. following style is encouraged:
+#
+# [source,ruby]
+# ----
+# worker_id, pipe = env
+# Ractor.new(worker_id, pipe) do |worker_id, pipe|
+# end
+# ----
+#
+# @example
+#
+#   # bad
+#   def some_method
+#   foo = 1
+#
+#   2.times do |foo| # shadowing outer `foo`
+#   do_something(foo)
+#   end
+#   end
+#
+#   # good
+#   def some_method
+#   foo = 1
+#
+#   2.times do |bar|
+#   do_something(bar)
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#41
+class RuboCop::Cop::Lint::ShadowingOuterLocalVariable < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#53
+  def before_declaring_variable(variable, variable_table); end
+
+  # source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#89
+  def find_conditional_node_from_ascendant(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#96
+  def node_or_its_ascendant_conditional?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#45
+  def ractor_block?(param0 = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#65
+  def same_conditions_node_different_branch?(variable, outer_local_variable); end
+
+  # source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#79
+  def variable_node(variable); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#49
+    def joining_forces; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/shadowing_outer_local_variable.rb#42
+RuboCop::Cop::Lint::ShadowingOuterLocalVariable::MSG = T.let(T.unsafe(nil), String)
+
+# Checks unexpected overrides of the `Struct` built-in methods
+# via `Struct.new`.
+#
+# @example
+#   # bad
+#   Bad = Struct.new(:members, :clone, :count)
+#   b = Bad.new([], true, 1)
+#   b.members #=> [] (overriding `Struct#members`)
+#   b.clone #=> true (overriding `Object#clone`)
+#   b.count #=> 1 (overriding `Enumerable#count`)
+#
+#   # good
+#   Good = Struct.new(:id, :name)
+#   g = Good.new(1, "foo")
+#   g.members #=> [:id, :name]
+#   g.clone #=> #<struct Good id=1, name="foo">
+#   g.count #=> 2
+#
+# source://rubocop//lib/rubocop/cop/lint/struct_new_override.rb#24
+class RuboCop::Cop::Lint::StructNewOverride < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/struct_new_override.rb#38
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/struct_new_override.rb#33
+  def struct_new(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/struct_new_override.rb#25
+RuboCop::Cop::Lint::StructNewOverride::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/struct_new_override.rb#27
+RuboCop::Cop::Lint::StructNewOverride::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/struct_new_override.rb#30
+RuboCop::Cop::Lint::StructNewOverride::STRUCT_MEMBER_NAME_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/struct_new_override.rb#29
+RuboCop::Cop::Lint::StructNewOverride::STRUCT_METHOD_NAMES = T.let(T.unsafe(nil), Array)
+
+# Checks for `rescue` blocks with no body.
+#
+# @example
+#
+#   # bad
+#   def some_method
+#   do_something
+#   rescue
+#   end
+#
+#   # bad
+#   begin
+#   do_something
+#   rescue
+#   end
+#
+#   # good
+#   def some_method
+#   do_something
+#   rescue
+#   handle_exception
+#   end
+#
+#   # good
+#   begin
+#   do_something
+#   rescue
+#   handle_exception
+#   end
+# @example AllowComments: true (default)
+#
+#   # good
+#   def some_method
+#   do_something
+#   rescue
+#   # do nothing
+#   end
+#
+#   # good
+#   begin
+#   do_something
+#   rescue
+#   # do nothing
+#   end
+# @example AllowComments: false
+#
+#   # bad
+#   def some_method
+#   do_something
+#   rescue
+#   # do nothing
+#   end
+#
+#   # bad
+#   begin
+#   do_something
+#   rescue
+#   # do nothing
+#   end
+# @example AllowNil: true (default)
+#
+#   # good
+#   def some_method
+#   do_something
+#   rescue
+#   nil
+#   end
+#
+#   # good
+#   begin
+#   do_something
+#   rescue
+#   # do nothing
+#   end
+#
+#   # good
+#   do_something rescue nil
+# @example AllowNil: false
+#
+#   # bad
+#   def some_method
+#   do_something
+#   rescue
+#   nil
+#   end
+#
+#   # bad
+#   begin
+#   do_something
+#   rescue
+#   nil
+#   end
+#
+#   # bad
+#   do_something rescue nil
+#
+# source://rubocop//lib/rubocop/cop/lint/suppressed_exception.rb#105
+class RuboCop::Cop::Lint::SuppressedException < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/suppressed_exception.rb#108
+  def on_resbody(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/suppressed_exception.rb#118
+  def comment_between_rescue_and_end?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/suppressed_exception.rb#126
+  def nil_body?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/suppressed_exception.rb#106
+RuboCop::Cop::Lint::SuppressedException::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for uses of literal strings converted to
+# a symbol where a literal symbol could be used instead.
+#
+# There are two possible styles for this cop.
+# `strict` (default) will register an offense for any incorrect usage.
+# `consistent` additionally requires hashes to use the same style for
+# every symbol key (ie. if any symbol key needs to be quoted it requires
+# all keys to be quoted).
+#
+# @example
+#   # bad
+#   'string'.to_sym
+#   :symbol.to_sym
+#   'underscored_string'.to_sym
+#   :'underscored_symbol'
+#   'hyphenated-string'.to_sym
+#   "string_#{interpolation}".to_sym
+#
+#   # good
+#   :string
+#   :symbol
+#   :underscored_string
+#   :underscored_symbol
+#   :'hyphenated-string'
+#   :"string_#{interpolation}"
+# @example EnforcedStyle: strict (default)
+#
+#   # bad
+#   {
+#   'a': 1,
+#   "b": 2,
+#   'c-d': 3
+#   }
+#
+#   # good (don't quote keys that don't require quoting)
+#   {
+#   a: 1,
+#   b: 2,
+#   'c-d': 3
+#   }
+# @example EnforcedStyle: consistent
+#
+#   # bad
+#   {
+#   a: 1,
+#   'b-c': 2
+#   }
+#
+#   # good (quote all keys if any need quoting)
+#   {
+#   'a': 1,
+#   'b-c': 2
+#   }
+#
+#   # good (no quoting required)
+#   {
+#   a: 1,
+#   b: 2
+#   }
+#
+# source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#68
+class RuboCop::Cop::Lint::SymbolConversion < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::SymbolHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#105
+  def on_hash(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#78
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#88
+  def on_sym(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#147
+  def correct_hash_key(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#166
+  def correct_inconsistent_hash_keys(keys); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#139
+  def in_alias?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#143
+  def in_percent_literal_array?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#126
+  def properly_quoted?(source, value); end
+
+  # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#122
+  def register_offense(node, correction:, message: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#135
+  def requires_quotes?(sym_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#73
+RuboCop::Cop::Lint::SymbolConversion::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#74
+RuboCop::Cop::Lint::SymbolConversion::MSG_CONSISTENCY = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/symbol_conversion.rb#76
+RuboCop::Cop::Lint::SymbolConversion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Repacks Parser's diagnostics/errors
+# into RuboCop's offenses.
+#
+# source://rubocop//lib/rubocop/cop/lint/syntax.rb#8
+class RuboCop::Cop::Lint::Syntax < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/syntax.rb#9
+  def on_other_file; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/syntax.rb#19
+  def add_offense_from_diagnostic(diagnostic, ruby_version); end
+
+  # source://rubocop//lib/rubocop/cop/lint/syntax.rb#29
+  def add_offense_from_error(error); end
+
+  # source://rubocop//lib/rubocop/cop/lint/syntax.rb#34
+  def beautify_message(message); end
+
+  # source://rubocop//lib/rubocop/cop/lint/syntax.rb#40
+  def find_severity(_range, _severity); end
+end
+
+# Ensures that `to_enum`/`enum_for`, called for the current method,
+# has correct arguments.
+#
+# @example
+#   # bad
+#   def foo(x, y = 1)
+#   return to_enum(__callee__, x) # `y` is missing
+#   end
+#
+#   # good
+#   def foo(x, y = 1)
+#   # Alternatives to `__callee__` are `__method__` and `:foo`.
+#   return to_enum(__callee__, x, y)
+#   end
+#
+#   # good
+#   def foo(x, y = 1)
+#   # It is also allowed if it is wrapped in some method like Sorbet.
+#   return to_enum(T.must(__callee__), x, y)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#27
+class RuboCop::Cop::Lint::ToEnumArguments < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#33
+  def enum_conversion_call?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#38
+  def method_name?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#47
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#43
+  def passing_keyword_arg?(param0 = T.unsafe(nil), param1); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#76
+  def argument_match?(send_arg, def_arg); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#61
+  def arguments_match?(arguments, def_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#28
+RuboCop::Cop::Lint::ToEnumArguments::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/to_enum_arguments.rb#30
+RuboCop::Cop::Lint::ToEnumArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks to make sure `#to_json` includes an optional argument.
+# When overriding `#to_json`, callers may invoke JSON
+# generation via `JSON.generate(your_obj)`.  Since `JSON#generate` allows
+# for an optional argument, your method should too.
+#
+# @example
+#   class Point
+#   attr_reader :x, :y
+#
+#   # bad, incorrect arity
+#   def to_json
+#   JSON.generate([x, y])
+#   end
+#
+#   # good, preserving args
+#   def to_json(*args)
+#   JSON.generate([x, y], *args)
+#   end
+#
+#   # good, discarding args
+#   def to_json(*_args)
+#   JSON.generate([x, y])
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/to_json.rb#31
+class RuboCop::Cop::Lint::ToJSON < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/to_json.rb#36
+  def on_def(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/to_json.rb#34
+RuboCop::Cop::Lint::ToJSON::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for top level return with arguments. If there is a
+# top-level return statement with an argument, then the argument is
+# always ignored. This is detected automatically since Ruby 2.7.
+#
+# @example
+#   # bad
+#   return 1
+#
+#   # good
+#   return
+#
+# source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#16
+class RuboCop::Cop::Lint::TopLevelReturnWithArgument < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#21
+  def on_return(return_node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#35
+  def remove_arguments(corrector, return_node); end
+
+  # This cop works by validating the ancestors of the return node. A
+  # top-level return node's ancestors should not be of block, def, or
+  # defs type.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#42
+  def top_level_return?(return_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#31
+  def top_level_return_with_any_argument?(return_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/top_level_return_with_argument.rb#19
+RuboCop::Cop::Lint::TopLevelReturnWithArgument::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for trailing commas in attribute declarations, such as
+# `#attr_reader`. Leaving a trailing comma will nullify the next method
+# definition by overriding it with a getter method.
+#
+# @example
+#
+#   # bad
+#   class Foo
+#   attr_reader :foo,
+#
+#   def bar
+#   puts "Unreachable."
+#   end
+#   end
+#
+#   # good
+#   class Foo
+#   attr_reader :foo
+#
+#   def bar
+#   puts "No problem!"
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/trailing_comma_in_attribute_declaration.rb#30
+class RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/trailing_comma_in_attribute_declaration.rb#36
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/trailing_comma_in_attribute_declaration.rb#46
+  def trailing_comma_range(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/trailing_comma_in_attribute_declaration.rb#34
+RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for "triple quotes" (strings delimited by any odd number
+# of quotes greater than 1).
+#
+# Ruby allows multiple strings to be implicitly concatenated by just
+# being adjacent in a statement (ie. `"foo""bar" == "foobar"`). This sometimes
+# gives the impression that there is something special about triple quotes, but
+# in fact it is just extra unnecessary quotes and produces the same string. Each
+# pair of quotes produces an additional concatenated empty string, so the result
+# is still only the "actual" string within the delimiters.
+#
+# NOTE: Although this cop is called triple quotes, the same behavior is present
+# for strings delimited by 5, 7, etc. quotation marks.
+#
+# @example
+#   # bad
+#   """
+#   A string
+#   """
+#
+#   # bad
+#   '''
+#   A string
+#   '''
+#
+#   # good
+#   "
+#   A string
+#   "
+#
+#   # good
+#   <<STRING
+#   A string
+#   STRING
+#
+#   # good (but not the same spacing as the bad case)
+#   'A string'
+#
+# source://rubocop//lib/rubocop/cop/lint/triple_quotes.rb#42
+class RuboCop::Cop::Lint::TripleQuotes < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/triple_quotes.rb#47
+  def on_dstr(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/triple_quotes.rb#65
+  def empty_str_nodes(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/triple_quotes.rb#45
+RuboCop::Cop::Lint::TripleQuotes::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for underscore-prefixed variables that are actually
+# used.
+#
+# Since block keyword arguments cannot be arbitrarily named at call
+# sites, the `AllowKeywordBlockArguments` will allow use of underscore-
+# prefixed block keyword arguments.
+#
+# @example AllowKeywordBlockArguments: false (default)
+#
+#   # bad
+#
+#   [1, 2, 3].each do |_num|
+#   do_something(_num)
+#   end
+#
+#   query(:sales) do |_id:, revenue:, cost:|
+#   {_id: _id, profit: revenue - cost}
+#   end
+#
+#   # good
+#
+#   [1, 2, 3].each do |num|
+#   do_something(num)
+#   end
+#
+#   [1, 2, 3].each do |_num|
+#   do_something # not using `_num`
+#   end
+# @example AllowKeywordBlockArguments: true
+#
+#   # good
+#
+#   query(:sales) do |_id:, revenue:, cost:|
+#   {_id: _id, profit: revenue - cost}
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb#43
+class RuboCop::Cop::Lint::UnderscorePrefixedVariableName < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb#50
+  def after_leaving_scope(scope, _variable_table); end
+
+  # source://rubocop//lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb#54
+  def check_variable(variable); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb#72
+  def allowed_keyword_block_argument?(variable); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb#46
+    def joining_forces; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb#44
+RuboCop::Cop::Lint::UnderscorePrefixedVariableName::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for a block that is known to need more positional
+# block arguments than are given (by default this is configured for
+# `Enumerable` methods needing 2 arguments). Optional arguments are allowed,
+# although they don't generally make sense as the default value will
+# be used. Blocks that have no receiver, or take splatted arguments
+# (ie. `*args`) are always accepted.
+#
+# Keyword arguments (including `**kwargs`) do not get counted towards
+# this, as they are not used by the methods in question.
+#
+# Method names and their expected arity can be configured like this:
+#
+# [source,yaml]
+# ----
+# Methods:
+#   inject: 2
+#   reduce: 2
+# ----
+#
+# @example
+#   # bad
+#   values.reduce {}
+#   values.min { |a| a }
+#   values.sort { |a; b| a + b }
+#
+#   # good
+#   values.reduce { |memo, obj| memo << obj }
+#   values.min { |a, b| a <=> b }
+#   values.sort { |*x| x[0] <=> x[1] }
+#
+# source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#41
+class RuboCop::Cop::Lint::UnexpectedBlockArity < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#44
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#44
+  def on_numblock(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#63
+  def acceptable?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#75
+  def arg_count(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#71
+  def expected_arity(method); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#67
+  def included_method?(name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#59
+  def methods; end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/unexpected_block_arity.rb#42
+RuboCop::Cop::Lint::UnexpectedBlockArity::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for using Fixnum or Bignum constant.
+#
+# @example
+#
+#   # bad
+#   1.is_a?(Fixnum)
+#   1.is_a?(Bignum)
+#
+#   # good
+#   1.is_a?(Integer)
+#
+# source://rubocop//lib/rubocop/cop/lint/unified_integer.rb#16
+class RuboCop::Cop::Lint::UnifiedInteger < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/unified_integer.rb#22
+  def fixnum_or_bignum_const(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unified_integer.rb#26
+  def on_const(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/unified_integer.rb#19
+RuboCop::Cop::Lint::UnifiedInteger::MSG = T.let(T.unsafe(nil), String)
+
+# Looks for `reduce` or `inject` blocks where the value returned (implicitly or
+# explicitly) does not include the accumulator. A block is considered valid as
+# long as at least one return value includes the accumulator.
+#
+# If the accumulator is not included in the return value, then the entire
+# block will just return a transformation of the last element value, and
+# could be rewritten as such without a loop.
+#
+# Also catches instances where an index of the accumulator is returned, as
+# this may change the type of object being retained.
+#
+# NOTE: For the purpose of reducing false positives, this cop only flags
+# returns in `reduce` blocks where the element is the only variable in
+# the expression (since we will not be able to tell what other variables
+# relate to via static analysis).
+#
+# @example
+#
+#   # bad
+#   (1..4).reduce(0) do |acc, el|
+#   el * 2
+#   end
+#
+#   # bad, may raise a NoMethodError after the first iteration
+#   %w(a b c).reduce({}) do |acc, letter|
+#   acc[letter] = true
+#   end
+#
+#   # good
+#   (1..4).reduce(0) do |acc, el|
+#   acc + el * 2
+#   end
+#
+#   # good, element is returned but modified using the accumulator
+#   values.reduce do |acc, el|
+#   el << acc
+#   el
+#   end
+#
+#   # good, returns the accumulator instead of the index
+#   %w(a b c).reduce({}) do |acc, letter|
+#   acc[letter] = true
+#   acc
+#   end
+#
+#   # good, at least one branch returns the accumulator
+#   values.reduce(nil) do |result, value|
+#   break result if something?
+#   value
+#   end
+#
+#   # good, recursive
+#   keys.reduce(self) { |result, key| result[key] }
+#
+#   # ignored as the return value cannot be determined
+#   enum.reduce do |acc, el|
+#   x = foo(acc, el)
+#   bar(x)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#65
+class RuboCop::Cop::Lint::UnmodifiedReduceAccumulator < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#78
+  def accumulator_index?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#83
+  def element_modified?(param0, param1); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#104
+  def expression_values(param0); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#93
+  def lvar_used?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#115
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#115
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#70
+  def reduce_with_block?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # Determine if a return value is acceptable for the purposes of this cop
+  # If it is an expression containing the accumulator, it is acceptable
+  # Otherwise, it is only unacceptable if it contains the iterated element, since we
+  # otherwise do not have enough information to prevent false positives.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#191
+  def acceptable_return?(return_val, element_name); end
+
+  # Exclude `begin` nodes inside a `dstr` from being collected by `return_values`
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#199
+  def allowed_type?(parent_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#159
+  def block_arg_name(node, index); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#142
+  def check_return_values(block_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#176
+  def potential_offense?(return_values, block_body, element_name, accumulator_name); end
+
+  # Return values in a block are either the value given to next,
+  # the last line of a multiline block, or the only line of the block
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#128
+  def return_values(block_body_node); end
+
+  # Look for an index of the accumulator being returned, except where the index
+  # is the element.
+  # This is always an offense, in order to try to catch potential exceptions
+  # due to type mismatches
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#167
+  def returned_accumulator_index(return_values, accumulator_name, element_name); end
+
+  # If the accumulator is used in any return value, the node is acceptable since
+  # the accumulator has a chance to change each iteration
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#183
+  def returns_accumulator_anywhere?(return_values, accumulator_name); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#66
+RuboCop::Cop::Lint::UnmodifiedReduceAccumulator::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb#67
+RuboCop::Cop::Lint::UnmodifiedReduceAccumulator::MSG_INDEX = T.let(T.unsafe(nil), String)
+
+# Checks for unreachable code.
+# The check are based on the presence of flow of control
+# statement in non-final position in `begin` (implicit) blocks.
+#
+# @example
+#
+#   # bad
+#   def some_method
+#   return
+#   do_something
+#   end
+#
+#   # bad
+#   def some_method
+#   if cond
+#   return
+#   else
+#   return
+#   end
+#   do_something
+#   end
+#
+#   # good
+#   def some_method
+#   do_something
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#32
+class RuboCop::Cop::Lint::UnreachableCode < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#50
+  def flow_command?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#35
+  def on_begin(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#35
+  def on_kwbegin(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#82
+  def check_case(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#76
+  def check_if(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#60
+  def flow_expression?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/unreachable_code.rb#33
+RuboCop::Cop::Lint::UnreachableCode::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for loops that will have at most one iteration.
+#
+# A loop that can never reach the second iteration is a possible error in the code.
+# In rare cases where only one iteration (or at most one iteration) is intended behavior,
+# the code should be refactored to use `if` conditionals.
+#
+# NOTE: Block methods that are used with ``Enumerable``s are considered to be loops.
+#
+# `AllowedPatterns` can be used to match against the block receiver in order to allow
+# code that would otherwise be registered as an offense (eg. `times` used not in an
+# `Enumerable` context).
+#
+# @example
+#   # bad
+#   while node
+#   do_something(node)
+#   node = node.parent
+#   break
+#   end
+#
+#   # good
+#   while node
+#   do_something(node)
+#   node = node.parent
+#   end
+#
+#   # bad
+#   def verify_list(head)
+#   item = head
+#   begin
+#   if verify(item)
+#   return true
+#   else
+#   return false
+#   end
+#   end while(item)
+#   end
+#
+#   # good
+#   def verify_list(head)
+#   item = head
+#   begin
+#   if verify(item)
+#   item = item.next
+#   else
+#   return false
+#   end
+#   end while(item)
+#
+#   true
+#   end
+#
+#   # bad
+#   def find_something(items)
+#   items.each do |item|
+#   if something?(item)
+#   return item
+#   else
+#   raise NotFoundError
+#   end
+#   end
+#   end
+#
+#   # good
+#   def find_something(items)
+#   items.each do |item|
+#   if something?(item)
+#   return item
+#   end
+#   end
+#   raise NotFoundError
+#   end
+#
+#   # bad
+#   2.times { raise ArgumentError }
+# @example AllowedPatterns: ['(exactly|at_least|at_most)\(\d+\)\.times'] (default)
+#
+#   # good
+#   exactly(2).times { raise StandardError }
+#
+# source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#86
+class RuboCop::Cop::Lint::UnreachableLoop < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedPattern
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#143
+  def break_command?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#100
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#92
+  def on_for(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#104
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#92
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#92
+  def on_until_post(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#92
+  def on_while(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#92
+  def on_while_post(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#153
+  def break_statement?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#119
+  def check(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#176
+  def check_case(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#170
+  def check_if(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#200
+  def conditional_continue_keyword?(break_statement); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#110
+  def loop_method?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#190
+  def preceded_by_continue_statement?(break_statement); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#130
+  def statements(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#90
+RuboCop::Cop::Lint::UnreachableLoop::CONTINUE_KEYWORDS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/unreachable_loop.rb#89
+RuboCop::Cop::Lint::UnreachableLoop::MSG = T.let(T.unsafe(nil), String)
+
+# Common functionality for cops handling unused arguments.
+#
+# source://rubocop//lib/rubocop/cop/mixin/unused_argument.rb#7
+module RuboCop::Cop::Lint::UnusedArgument
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop//lib/rubocop/cop/mixin/unused_argument.rb#10
+  def after_leaving_scope(scope, _variable_table); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/unused_argument.rb#16
+  def check_argument(variable); end
+end
+
+# Checks for unused block arguments.
+#
+# @example
+#   # bad
+#   do_something do |used, unused|
+#   puts used
+#   end
+#
+#   do_something do |bar|
+#   puts :foo
+#   end
+#
+#   define_method(:foo) do |bar|
+#   puts :baz
+#   end
+#
+#   # good
+#   do_something do |used, _unused|
+#   puts used
+#   end
+#
+#   do_something do
+#   puts :foo
+#   end
+#
+#   define_method(:foo) do |_bar|
+#   puts :baz
+#   end
+# @example IgnoreEmptyBlocks: true (default)
+#   # good
+#   do_something { |unused| }
+# @example IgnoreEmptyBlocks: false
+#   # bad
+#   do_something { |unused| }
+# @example AllowUnusedKeywordArguments: false (default)
+#   # bad
+#   do_something do |unused: 42|
+#   foo
+#   end
+# @example AllowUnusedKeywordArguments: true
+#   # good
+#   do_something do |unused: 42|
+#   foo
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#55
+class RuboCop::Cop::Lint::UnusedBlockArgument < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Lint::UnusedArgument
+  extend ::RuboCop::Cop::AutoCorrector
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#162
+  def allow_unused_keyword_arguments?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#81
+  def allowed_block?(variable); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#85
+  def allowed_keyword_argument?(variable); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#99
+  def augment_message(message, variable); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#65
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#69
+  def check_argument(variable); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#149
+  def define_method_call?(variable); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#156
+  def empty_block?(variable); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#166
+  def ignore_empty_blocks?; end
+
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#89
+  def message(variable); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#132
+  def message_for_lambda(variable, all_arguments); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#120
+  def message_for_normal_block(variable, all_arguments); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#144
+  def message_for_underscore_prefix(variable); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#77
+  def used_block_local?(variable); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#112
+  def variable_type(variable); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/lint/unused_block_argument.rb#59
+    def joining_forces; end
+  end
+end
+
+# Checks for unused method arguments.
+#
+# @example
+#   # bad
+#   def some_method(used, unused, _unused_but_allowed)
+#   puts used
+#   end
+#
+#   # good
+#   def some_method(used, _unused, _unused_but_allowed)
+#   puts used
+#   end
+# @example AllowUnusedKeywordArguments: false (default)
+#   # bad
+#   def do_something(used, unused: 42)
+#   used
+#   end
+# @example AllowUnusedKeywordArguments: true
+#   # good
+#   def do_something(used, unused: 42)
+#   used
+#   end
+# @example IgnoreEmptyMethods: true (default)
+#   # good
+#   def do_something(unused)
+#   end
+# @example IgnoreEmptyMethods: false
+#   # bad
+#   def do_something(unused)
+#   end
+# @example IgnoreNotImplementedMethods: true (default)
+#   # good
+#   def do_something(unused)
+#   raise NotImplementedError
+#   end
+#
+#   def do_something_else(unused)
+#   fail "TODO"
+#   end
+# @example IgnoreNotImplementedMethods: false
+#   # bad
+#   def do_something(unused)
+#   raise NotImplementedError
+#   end
+#
+#   def do_something_else(unused)
+#   fail "TODO"
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/unused_method_argument.rb#61
+class RuboCop::Cop::Lint::UnusedMethodArgument < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Lint::UnusedArgument
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/unused_method_argument.rb#66
+  def not_implemented?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/unused_method_argument.rb#81
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unused_method_argument.rb#85
+  def check_argument(variable); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/unused_method_argument.rb#93
+  def ignored_method?(body); end
+
+  # source://rubocop//lib/rubocop/cop/lint/unused_method_argument.rb#98
+  def message(variable); end
+
+  class << self
+    # source://rubocop-performance/1.22.1/lib/rubocop-performance.rb#15
+    def autocorrect_incompatible_with; end
+
+    # source://rubocop//lib/rubocop/cop/lint/unused_method_argument.rb#75
+    def joining_forces; end
+  end
+end
+
+# Identifies places where `URI.escape` can be replaced by
+# `CGI.escape`, `URI.encode_www_form`, or `URI.encode_www_form_component`
+# depending on your specific use case.
+# Also this cop identifies places where `URI.unescape` can be replaced by
+# `CGI.unescape`, `URI.decode_www_form`,
+# or `URI.decode_www_form_component` depending on your specific use case.
+#
+# @example
+#   # bad
+#   URI.escape('http://example.com')
+#   URI.encode('http://example.com')
+#
+#   # good
+#   CGI.escape('http://example.com')
+#   URI.encode_www_form([['example', 'param'], ['lang', 'en']])
+#   URI.encode_www_form(page: 10, locale: 'en')
+#   URI.encode_www_form_component('http://example.com')
+#
+#   # bad
+#   URI.unescape(enc_uri)
+#   URI.decode(enc_uri)
+#
+#   # good
+#   CGI.unescape(enc_uri)
+#   URI.decode_www_form(enc_uri)
+#   URI.decode_www_form_component(enc_uri)
+#
+# source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#32
+class RuboCop::Cop::Lint::UriEscapeUnescape < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#57
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#51
+  def uri_escape_unescape?(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#33
+RuboCop::Cop::Lint::UriEscapeUnescape::ALTERNATE_METHODS_OF_URI_ESCAPE = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#38
+RuboCop::Cop::Lint::UriEscapeUnescape::ALTERNATE_METHODS_OF_URI_UNESCAPE = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#47
+RuboCop::Cop::Lint::UriEscapeUnescape::METHOD_NAMES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#44
+RuboCop::Cop::Lint::UriEscapeUnescape::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/uri_escape_unescape.rb#48
+RuboCop::Cop::Lint::UriEscapeUnescape::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Identifies places where `URI.regexp` is obsolete and should not be used.
+#
+# For Ruby 3.3 or lower, use `URI::DEFAULT_PARSER.make_regexp`.
+# For Ruby 3.4 or higher, use `URI::RFC2396_PARSER.make_regexp`.
+#
+# NOTE: If you need to support both Ruby 3.3 and lower as well as Ruby 3.4 and higher,
+# consider manually changing the code as follows:
+#
+# [source,ruby]
+# ----
+# defined?(URI::RFC2396_PARSER) ? URI::RFC2396_PARSER : URI::DEFAULT_PARSER
+# ----
+#
+# @example
+#   # bad
+#   URI.regexp('http://example.com')
+#
+#   # good - Ruby 3.3 or lower
+#   URI::DEFAULT_PARSER.make_regexp('http://example.com')
+#
+#   # good - Ruby 3.4 or higher
+#   URI::RFC2396_PARSER.make_regexp('http://example.com')
+#
+# source://rubocop//lib/rubocop/cop/lint/uri_regexp.rb#29
+class RuboCop::Cop::Lint::UriRegexp < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/uri_regexp.rb#40
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/uri_regexp.rb#36
+  def uri_constant?(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/uri_regexp.rb#32
+RuboCop::Cop::Lint::UriRegexp::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/uri_regexp.rb#33
+RuboCop::Cop::Lint::UriRegexp::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for redundant access modifiers, including those with no
+# code, those which are repeated, and leading `public` modifiers in a
+# class or module body. Conditionally-defined methods are considered as
+# always being defined, and thus access modifiers guarding such methods
+# are not redundant.
+#
+# This cop has `ContextCreatingMethods` option. The default setting value
+# is an empty array that means no method is specified.
+# This setting is an array of methods which, when called, are known to
+# create its own context in the module's current access context.
+#
+# It also has `MethodCreatingMethods` option. The default setting value
+# is an empty array that means no method is specified.
+# This setting is an array of methods which, when called, are known to
+# create other methods in the module's current access context.
+#
+# @example
+#   # bad
+#   class Foo
+#   public # this is redundant (default access is public)
+#
+#   def method
+#   end
+#   end
+#
+#   # bad
+#   class Foo
+#   # The following is redundant (methods defined on the class'
+#   # singleton class are not affected by the private modifier)
+#   private
+#
+#   def self.method3
+#   end
+#   end
+#
+#   # bad
+#   class Foo
+#   protected
+#
+#   define_method(:method2) do
+#   end
+#
+#   protected # this is redundant (repeated from previous modifier)
+#
+#   [1,2,3].each do |i|
+#   define_method("foo#{i}") do
+#   end
+#   end
+#   end
+#
+#   # bad
+#   class Foo
+#   private # this is redundant (no following methods are defined)
+#   end
+#
+#   # good
+#   class Foo
+#   private # this is not redundant (a method is defined)
+#
+#   def method2
+#   end
+#   end
+#
+#   # good
+#   class Foo
+#   # The following is not redundant (conditionally defined methods are
+#   # considered as always defining a method)
+#   private
+#
+#   if condition?
+#   def method
+#   end
+#   end
+#   end
+#
+#   # good
+#   class Foo
+#   protected # this is not redundant (a method is defined)
+#
+#   define_method(:method2) do
+#   end
+#   end
+# @example ContextCreatingMethods: concerning
+#   # Lint/UselessAccessModifier:
+#   #   ContextCreatingMethods:
+#   #     - concerning
+#
+#   # good
+#   require 'active_support/concern'
+#   class Foo
+#   concerning :Bar do
+#   def some_public_method
+#   end
+#
+#   private
+#
+#   def some_private_method
+#   end
+#   end
+#
+#   # this is not redundant because `concerning` created its own context
+#   private
+#
+#   def some_other_private_method
+#   end
+#   end
+# @example MethodCreatingMethods: delegate
+#   # Lint/UselessAccessModifier:
+#   #   MethodCreatingMethods:
+#   #     - delegate
+#
+#   # good
+#   require 'active_support/core_ext/module/delegation'
+#   class Foo
+#   # this is not redundant because `delegate` creates methods
+#   private
+#
+#   delegate :method_a, to: :method_b
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#127
+class RuboCop::Cop::Lint::UselessAccessModifier < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#166
+  def class_or_instance_eval?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#161
+  def dynamic_method_definition?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#139
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#133
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#133
+  def on_module(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#139
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#133
+  def on_sclass(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#156
+  def static_method_definition?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#182
+  def access_modifier?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#280
+  def any_context_creating_methods?(child); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#257
+  def any_method_definition?(child); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#149
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#196
+  def check_child_nodes(node, unused, cur_vis); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#226
+  def check_new_visibility(node, unused, new_vis, cur_vis); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#170
+  def check_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#186
+  def check_scope(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#215
+  def check_send_node(node, cur_vis, unused); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#274
+  def eval_call?(child); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#247
+  def included_block?(block_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#251
+  def method_definition?(child); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#270
+  def start_of_new_scope?(child); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/useless_access_modifier.rb#131
+RuboCop::Cop::Lint::UselessAccessModifier::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for every useless assignment to local variable in every
+# scope.
+# The basic idea for this cop was from the warning of `ruby -cw`:
+#
+# [source,console]
+# ----
+# assigned but unused variable - foo
+# ----
+#
+# Currently this cop has advanced logic that detects unreferenced
+# reassignments and properly handles varied cases such as branch, loop,
+# rescue, ensure, etc.
+#
+# This cop's autocorrection avoids cases like `a ||= 1` because removing assignment from
+# operator assignment can cause NameError if this assignment has been used to declare
+# a local variable. For example, replacing `a ||= 1` with `a || 1` may cause
+# "undefined local variable or method `a' for main:Object (NameError)".
+#
+# NOTE: Given the assignment `foo = 1, bar = 2`, removing unused variables
+# can lead to a syntax error, so this case is not autocorrected.
+#
+# @example
+#
+#   # bad
+#   def some_method
+#   some_var = 1
+#   do_something
+#   end
+#
+#   # good
+#   def some_method
+#   some_var = 1
+#   do_something(some_var)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#40
+class RuboCop::Cop::Lint::UselessAssignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#51
+  def after_leaving_scope(scope, _variable_table); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#165
+  def autocorrect(corrector, assignment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#106
+  def chained_assignment?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#56
+  def check_for_unused_assignments(variable); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#149
+  def collect_variable_like_names(scope); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#82
+  def message_for_useless_assignment(assignment); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#110
+  def message_specification(assignment, variable); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#120
+  def multiple_assignment_message(variable_name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#88
+  def offense_range(assignment); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#125
+  def operator_assignment_message(scope, assignment); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#182
+  def remove_exception_assignment_part(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#206
+  def remove_local_variable_assignment_part(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#195
+  def remove_trailing_character_from_operator(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#191
+  def rename_variable_with_underscore(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#199
+  def replace_named_capture_group_with_non_capturing_group(corrector, node, variable_name); end
+
+  # TODO: More precise handling (rescue, ensure, nested begin, etc.)
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#139
+  def return_value_node_of_scope(scope); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#96
+  def sequential_assignment?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#132
+  def similar_name_message(variable); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#158
+  def variable_like_method_invocation?(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#47
+    def joining_forces; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/useless_assignment.rb#45
+RuboCop::Cop::Lint::UselessAssignment::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for useless `else` in `begin..end` without `rescue`.
+#
+# NOTE: This syntax is no longer valid on Ruby 2.6 or higher.
+#
+# @example
+#
+#   # bad
+#   begin
+#   do_something
+#   else
+#   do_something_else # This will never be run.
+#   end
+#
+#   # good
+#   begin
+#   do_something
+#   rescue
+#   handle_errors
+#   else
+#   do_something_else
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/useless_else_without_rescue.rb#27
+class RuboCop::Cop::Lint::UselessElseWithoutRescue < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/useless_else_without_rescue.rb#30
+  def on_new_investigation; end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/useless_else_without_rescue.rb#28
+RuboCop::Cop::Lint::UselessElseWithoutRescue::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for useless method definitions, specifically: empty constructors
+# and methods just delegating to `super`.
+#
+# @example
+#   # bad
+#   def initialize
+#   super
+#   end
+#
+#   def method
+#   super
+#   end
+#
+#   # good - with default arguments
+#   def initialize(x = Object.new)
+#   super
+#   end
+#
+#   # good
+#   def initialize
+#   super
+#   initialize_internals
+#   end
+#
+#   def method(*args)
+#   super(:extra_arg, *args)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#38
+class RuboCop::Cop::Lint::UselessMethodDefinition < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#43
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#43
+  def on_defs(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#65
+  def delegating?(node, def_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#57
+  def method_definition_with_modifier?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#61
+  def use_rest_or_optional_args?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/useless_method_definition.rb#41
+RuboCop::Cop::Lint::UselessMethodDefinition::MSG = T.let(T.unsafe(nil), String)
+
+# Certain numeric operations have no impact, being:
+# Adding or subtracting 0, multiplying or dividing by 1 or raising to the power of 1.
+# These are probably leftover from debugging, or are mistakes.
+#
+# @example
+#
+#   # bad
+#   x + 0
+#   x - 0
+#   x * 1
+#   x / 1
+#   x ** 1
+#
+#   # good
+#   x
+#
+#   # bad
+#   x += 0
+#   x -= 0
+#   x *= 1
+#   x /= 1
+#   x **= 1
+#
+#   # good
+#   x = x
+#
+# source://rubocop//lib/rubocop/cop/lint/useless_numeric_operation.rb#32
+class RuboCop::Cop::Lint::UselessNumericOperation < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_numeric_operation.rb#54
+  def on_op_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_numeric_operation.rb#43
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_numeric_operation.rb#41
+  def useless_abbreviated_assignment?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_numeric_operation.rb#38
+  def useless_operation?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_numeric_operation.rb#67
+  def useless?(operation, number); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/useless_numeric_operation.rb#34
+RuboCop::Cop::Lint::UselessNumericOperation::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/useless_numeric_operation.rb#35
+RuboCop::Cop::Lint::UselessNumericOperation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for useless `rescue`s, which only reraise rescued exceptions.
+#
+# @example
+#   # bad
+#   def foo
+#   do_something
+#   rescue
+#   raise
+#   end
+#
+#   # bad
+#   def foo
+#   do_something
+#   rescue => e
+#   raise # or 'raise e', or 'raise $!', or 'raise $ERROR_INFO'
+#   end
+#
+#   # good
+#   def foo
+#   do_something
+#   rescue
+#   do_cleanup
+#   raise
+#   end
+#
+#   # bad (latest rescue)
+#   def foo
+#   do_something
+#   rescue ArgumentError
+#   # noop
+#   rescue
+#   raise
+#   end
+#
+#   # good (not the latest rescue)
+#   def foo
+#   do_something
+#   rescue ArgumentError
+#   raise
+#   rescue
+#   # noop
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/useless_rescue.rb#49
+class RuboCop::Cop::Lint::UselessRescue < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/lint/useless_rescue.rb#52
+  def on_rescue(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_rescue.rb#83
+  def exception_objects(resbody_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_rescue.rb#60
+  def only_reraising?(resbody_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_rescue.rb#75
+  def use_exception_variable_in_ensure?(resbody_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/useless_rescue.rb#50
+RuboCop::Cop::Lint::UselessRescue::MSG = T.let(T.unsafe(nil), String)
+
+# Looks for `ruby2_keywords` calls for methods that do not need it.
+#
+# `ruby2_keywords` should only be called on methods that accept an argument splat
+# (`\*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
+# a keyword splat (`**kwargs`).
+#
+# @example
+#   # good (splat argument without keyword arguments)
+#   ruby2_keywords def foo(*args); end
+#
+#   # bad (no arguments)
+#   ruby2_keywords def foo; end
+#
+#   # good
+#   def foo; end
+#
+#   # bad (positional argument)
+#   ruby2_keywords def foo(arg); end
+#
+#   # good
+#   def foo(arg); end
+#
+#   # bad (double splatted argument)
+#   ruby2_keywords def foo(**args); end
+#
+#   # good
+#   def foo(**args); end
+#
+#   # bad (keyword arguments)
+#   ruby2_keywords def foo(i:, j:); end
+#
+#   # good
+#   def foo(i:, j:); end
+#
+#   # bad (splat argument with keyword arguments)
+#   ruby2_keywords def foo(*args, i:, j:); end
+#
+#   # good
+#   def foo(*args, i:, j:); end
+#
+#   # bad (splat argument with double splat)
+#   ruby2_keywords def foo(*args, **kwargs); end
+#
+#   # good
+#   def foo(*args, **kwargs); end
+#
+#   # bad (ruby2_keywords given a symbol)
+#   def foo; end
+#   ruby2_keywords :foo
+#
+#   # good
+#   def foo; end
+#
+#   # bad (ruby2_keywords with dynamic method)
+#   define_method(:foo) { |arg| }
+#   ruby2_keywords :foo
+#
+#   # good
+#   define_method(:foo) { |arg| }
+#
+# source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#66
+class RuboCop::Cop::Lint::UselessRuby2Keywords < ::RuboCop::Cop::Base
+  # Looks for statically or dynamically defined methods with a given name
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#72
+  def method_definition(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#79
+  def on_send(node); end
+
+  private
+
+  # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#118
+  def allowed_arguments(arguments); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#109
+  def find_method_definition(node, method_name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#91
+  def inspect_def(node, def_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#97
+  def inspect_sym(node, sym_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#67
+RuboCop::Cop::Lint::UselessRuby2Keywords::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/useless_ruby2_keywords.rb#68
+RuboCop::Cop::Lint::UselessRuby2Keywords::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for setter call to local variable as the final
+# expression of a function definition.
+#
+# @example
+#
+#   # bad
+#   def something
+#   x = Something.new
+#   x.attr = 5
+#   end
+#
+#   # good
+#   def something
+#   x = Something.new
+#   x.attr = 5
+#   x
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#31
+class RuboCop::Cop::Lint::UselessSetterCall < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#37
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#37
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#59
+  def setter_call_to_local_variable?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#63
+  def last_expression(body); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#35
+RuboCop::Cop::Lint::UselessSetterCall::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#34
+RuboCop::Cop::Lint::UselessSetterCall::MSG = T.let(T.unsafe(nil), String)
+
+# This class tracks variable assignments in a method body
+# and if a variable contains object passed as argument at the end of
+# the method.
+#
+# source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#72
+class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker
+  # @return [MethodVariableTracker] a new instance of MethodVariableTracker
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#73
+  def initialize(body_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#159
+  def constructor?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#78
+  def contain_local_object?(variable_name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#148
+  def process_assignment(asgn_node, rhs_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#96
+  def process_assignment_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#138
+  def process_binary_operator_assignment(op_asgn_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#129
+  def process_logical_operator_assignment(asgn_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#110
+  def process_multiple_assignment(masgn_node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_setter_call.rb#88
+  def scan(node, &block); end
+end
+
+# Checks for uses of `Integer#times` that will never yield
+# (when the integer ``<= 0``) or that will only ever yield once
+# (`1.times`).
+#
+# @example
+#   # bad
+#   -5.times { do_something }
+#   0.times { do_something }
+#   1.times { do_something  }
+#   1.times { |i| do_something(i) }
+#
+#   # good
+#   do_something
+#   do_something(1)
+#
+# source://rubocop//lib/rubocop/cop/lint/useless_times.rb#24
+class RuboCop::Cop::Lint::UselessTimes < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#37
+  def block_arg(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#42
+  def block_reassigns_arg?(param0, param1); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#46
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#32
+  def times_call?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#62
+  def autocorrect(corrector, count, node, proc_name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#84
+  def autocorrect_block(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#80
+  def autocorrect_block_pass(corrector, node, proc_name); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#94
+  def fix_indentation(source, range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#72
+  def never_process?(count, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#106
+  def own_line?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/useless_times.rb#76
+  def remove_node(corrector, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/useless_times.rb#28
+RuboCop::Cop::Lint::UselessTimes::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/useless_times.rb#29
+RuboCop::Cop::Lint::UselessTimes::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for operators, variables, literals, lambda, proc and nonmutating
+# methods used in void context.
+#
+# `each` blocks are allowed to prevent false positives.
+# For example, the expression inside the `each` block below.
+# It's not void, especially when the receiver is an `Enumerator`:
+#
+# [source,ruby]
+# ----
+# enumerator = [1, 2, 3].filter
+# enumerator.each { |item| item >= 2 } #=> [2, 3]
+# ----
+#
+# @example CheckForMethodsWithNoSideEffects: false (default)
+#   # bad
+#   def some_method
+#   some_num * 10
+#   do_something
+#   end
+#
+#   def some_method(some_var)
+#   some_var
+#   do_something
+#   end
+# @example CheckForMethodsWithNoSideEffects: true
+#   # bad
+#   def some_method(some_array)
+#   some_array.sort
+#   do_something(some_array)
+#   end
+#
+#   # good
+#   def some_method
+#   do_something
+#   some_num * 10
+#   end
+#
+#   def some_method(some_var)
+#   do_something
+#   some_var
+#   end
+#
+#   def some_method(some_array)
+#   some_array.sort!
+#   do_something(some_array)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/lint/void.rb#53
+class RuboCop::Cop::Lint::Void < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#90
+  def on_begin(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#81
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#95
+  def on_ensure(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#90
+  def on_kwbegin(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#81
+  def on_numblock(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#258
+  def all_keys_entirely_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#262
+  def all_values_entirely_literal?(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#236
+  def autocorrect_nonmutating_send(corrector, node, suggestion); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#230
+  def autocorrect_void_expression(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#218
+  def autocorrect_void_op(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#101
+  def check_begin(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#198
+  def check_ensure(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#115
+  def check_expression(expr); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#156
+  def check_literal(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#180
+  def check_nonmutating(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#164
+  def check_self(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#138
+  def check_var(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#172
+  def check_void_expression(node); end
+
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#127
+  def check_void_op(node, &block); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#245
+  def entirely_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/lint/void.rb#211
+  def in_void_context?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/lint/void.rb#66
+RuboCop::Cop::Lint::Void::BINARY_OPERATORS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/void.rb#60
+RuboCop::Cop::Lint::Void::CONST_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/void.rb#63
+RuboCop::Cop::Lint::Void::EXPRESSION_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/void.rb#61
+RuboCop::Cop::Lint::Void::LIT_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/void.rb#76
+RuboCop::Cop::Lint::Void::METHODS_REPLACEABLE_BY_EACH = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/void.rb#78
+RuboCop::Cop::Lint::Void::NONMUTATING_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/void.rb#69
+RuboCop::Cop::Lint::Void::NONMUTATING_METHODS_WITH_BANG_VERSION = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/void.rb#64
+RuboCop::Cop::Lint::Void::NONMUTATING_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/void.rb#68
+RuboCop::Cop::Lint::Void::OPERATORS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/void.rb#58
+RuboCop::Cop::Lint::Void::OP_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/void.rb#62
+RuboCop::Cop::Lint::Void::SELF_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/lint/void.rb#67
+RuboCop::Cop::Lint::Void::UNARY_OPERATORS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/lint/void.rb#59
+RuboCop::Cop::Lint::Void::VAR_MSG = T.let(T.unsafe(nil), String)
+
+# Common functionality for obtaining source ranges from regexp matches
+#
+# source://rubocop//lib/rubocop/cop/mixin/match_range.rb#6
+module RuboCop::Cop::MatchRange
+  include ::RuboCop::Cop::RangeHelp
+
+  private
+
+  # Return a new `Range` covering the first matching group number for each
+  # match of `regex` inside `range`
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/match_range.rb#13
+  def each_match_range(range, regex); end
+
+  # For a `match` inside `range`, return a new `Range` covering the match
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/match_range.rb#18
+  def match_range(range, match); end
+end
+
+# Message Annotator class annotates a basic offense message
+# based on params passed into initializer.
+#
+#  #=> 'Cop/CopName: message (http://example.org/styleguide)'
+#
+# @example
+#   RuboCop::Cop::MessageAnnotator.new(
+#   config, cop_name, cop_config, @options
+#   ).annotate('message')
+# @see #initialize
+#
+# source://rubocop//lib/rubocop/cop/message_annotator.rb#15
+class RuboCop::Cop::MessageAnnotator
+  # @option cop_config
+  # @option cop_config
+  # @option cop_config
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @param config [RuboCop::Config] Check configs for all cops
+  #   @note Message Annotator specifically checks the
+  #   following config options for_all_cops
+  #   :StyleGuideBaseURL [String] URL for styleguide
+  #   :DisplayStyleGuide [Boolean] Include styleguide and reference URLs
+  #   :ExtraDetails [Boolean] Include cop details
+  #   :DisplayCopNames [Boolean] Include cop name
+  # @param cop_name [String] for specific cop name
+  # @param cop_config [Hash] configs for specific cop, from config#for_cop
+  # @param options [Hash, nil] optional
+  # @return [MessageAnnotator] a new instance of MessageAnnotator
+  #
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#47
+  def initialize(config, cop_name, cop_config, options); end
+
+  # Returns the annotated message,
+  # based on params passed into initializer
+  #
+  # @return [String] annotated message
+  #
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#58
+  def annotate(message); end
+
+  # Returns the value of attribute config.
+  #
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#16
+  def config; end
+
+  # Returns the value of attribute cop_config.
+  #
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#16
+  def cop_config; end
+
+  # Returns the value of attribute cop_name.
+  #
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#16
+  def cop_name; end
+
+  # Returns the value of attribute options.
+  #
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#16
+  def options; end
+
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#68
+  def urls; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#111
+  def debug?; end
+
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#124
+  def details; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#115
+  def display_cop_names?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#98
+  def display_style_guide?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#107
+  def extra_details?; end
+
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#102
+  def reference_urls; end
+
+  # Returns the base style guide URL from AllCops or the specific department
+  #
+  # @return [String] style guide URL
+  #
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#91
+  def style_guide_base_url; end
+
+  # source://rubocop//lib/rubocop/cop/message_annotator.rb#74
+  def style_guide_url; end
+
+  class << self
+    # Returns the value of attribute style_guide_urls.
+    #
+    # source://rubocop//lib/rubocop/cop/message_annotator.rb#21
+    def style_guide_urls; end
+  end
+end
+
+# This module handles measurement and reporting of complexity in methods.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#8
+module RuboCop::Cop::MethodComplexity
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+  include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount
+  extend ::RuboCop::AST::NodePattern::Macros
+  extend ::RuboCop::ExcludeLimit
+
+  # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#37
+  def define_method?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11
+  def max=(value); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#24
+  def on_block(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#17
+  def on_def(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#17
+  def on_defs(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#24
+  def on_numblock(node); end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#42
+  def check_complexity(node, method_name); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#61
+  def complexity(body); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/method_complexity.rb#73
+  def location(node); end
+end
+
+# Common code for cops that deal with preferred methods.
+#
+# source://rubocop//lib/rubocop/cop/mixin/method_preference.rb#6
+module RuboCop::Cop::MethodPreference
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/method_preference.rb#25
+  def default_cop_config; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/method_preference.rb#9
+  def preferred_method(method); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/method_preference.rb#13
+  def preferred_methods; end
+end
+
+# source://rubocop//lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb#5
+module RuboCop::Cop::Metrics; end
+
+# Checks that the ABC size of methods is not higher than the
+# configured maximum. The ABC size is based on assignments, branches
+# (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
+# and https://en.wikipedia.org/wiki/ABC_Software_Metric.
+#
+# Interpreting ABC size:
+#
+# * ``<= 17`` satisfactory
+# * `18..30` unsatisfactory
+# * `>` 30 dangerous
+#
+# You can have repeated "attributes" calls count as a single "branch".
+# For this purpose, attributes are any method with no argument; no attempt
+# is meant to distinguish actual `attr_reader` from other methods.
+#
+# This cop also takes into account `AllowedMethods` (defaults to `[]`)
+# And `AllowedPatterns` (defaults to `[]`)
+#
+# @example CountRepeatedAttributes: false (default is true)
+#
+#   # `model` and `current_user`, referenced 3 times each,
+#   # are each counted as only 1 branch each if
+#   # `CountRepeatedAttributes` is set to 'false'
+#
+#   def search
+#   @posts = model.active.visible_by(current_user)
+#   .search(params[:q])
+#   @posts = model.some_process(@posts, current_user)
+#   @posts = model.another_process(@posts, current_user)
+#
+#   render 'pages/search/page'
+#   end
+#
+# source://rubocop//lib/rubocop/cop/metrics/abc_size.rb#39
+class RuboCop::Cop::Metrics::AbcSize < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+  include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount
+  include ::RuboCop::Cop::MethodComplexity
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/metrics/abc_size.rb#47
+  def complexity(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/metrics/abc_size.rb#42
+RuboCop::Cop::Metrics::AbcSize::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if the length of a block exceeds some maximum value.
+# Comment lines can optionally be ignored.
+# The maximum allowed length is configurable.
+# The cop can be configured to ignore blocks passed to certain methods.
+#
+# You can set constructs you want to fold with `CountAsOne`.
+#
+# Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+# Each construct will be counted as one line regardless of its actual size.
+#
+# NOTE: This cop does not apply for `Struct` definitions.
+#
+# NOTE: The `ExcludedMethods` configuration is deprecated and only kept
+# for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
+# instead. By default, there are no methods to allowed.
+#
+# @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
+#
+#   something do
+#   array = [         # +1
+#   1,
+#   2
+#   ]
+#
+#   hash = {          # +1
+#   key: 'value'
+#   }
+#
+#   msg = <<~HEREDOC  # +1
+#   Heredoc
+#   content.
+#   HEREDOC
+#
+#   foo(              # +1
+#   1,
+#   2
+#   )
+#   end                 # 4 points
+#
+# source://rubocop//lib/rubocop/cop/metrics/block_length.rb#45
+class RuboCop::Cop::Metrics::BlockLength < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CodeLength
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+
+  # source://rubocop//lib/rubocop/cop/metrics/block_length.rb#52
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/block_length.rb#52
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/metrics/block_length.rb#81
+  def cop_label; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/block_length.rb#63
+  def method_receiver_excluded?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/metrics/block_length.rb#50
+RuboCop::Cop::Metrics::BlockLength::LABEL = T.let(T.unsafe(nil), String)
+
+# Checks for excessive nesting of conditional and looping constructs.
+#
+# You can configure if blocks are considered using the `CountBlocks` and `CountModifierForms`
+# options. When both are set to `false` (the default) blocks and modifier forms are not
+# counted towards the nesting level. Set them to `true` to include these in the nesting level
+# calculation as well.
+#
+# The maximum level of nesting allowed is configurable.
+#
+# source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#14
+class RuboCop::Cop::Metrics::BlockNesting < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11
+  def max=(value); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#19
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#28
+  def check_nesting_level(node, max, current_level); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#52
+  def consider_node?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#62
+  def count_blocks?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#44
+  def count_if_block?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#66
+  def count_modifier_forms?; end
+
+  # source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#58
+  def message(max); end
+end
+
+# source://rubocop//lib/rubocop/cop/metrics/block_nesting.rb#15
+RuboCop::Cop::Metrics::BlockNesting::NESTING_BLOCKS = T.let(T.unsafe(nil), Array)
+
+# Checks if the length of a class exceeds some maximum value.
+# Comment lines can optionally be ignored.
+# The maximum allowed length is configurable.
+#
+# You can set constructs you want to fold with `CountAsOne`.
+#
+# Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+# Each construct will be counted as one line regardless of its actual size.
+#
+# NOTE: This cop also applies for `Struct` definitions.
+#
+# @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
+#
+#   class Foo
+#   ARRAY = [         # +1
+#   1,
+#   2
+#   ]
+#
+#   HASH = {          # +1
+#   key: 'value'
+#   }
+#
+#   MSG = <<~HEREDOC  # +1
+#   Heredoc
+#   content.
+#   HEREDOC
+#
+#   foo(              # +1
+#   1,
+#   2
+#   )
+#   end                 # 4 points
+#
+# source://rubocop//lib/rubocop/cop/metrics/class_length.rb#40
+class RuboCop::Cop::Metrics::ClassLength < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CodeLength
+
+  # source://rubocop//lib/rubocop/cop/metrics/class_length.rb#53
+  def on_casgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/class_length.rb#43
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/class_length.rb#47
+  def on_sclass(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/metrics/class_length.rb#71
+  def message(length, max_length); end
+end
+
+# Checks for literals with extremely many entries. This is indicative of
+# configuration or data that may be better extracted somewhere else, like
+# a database, fetched from an API, or read from a non-code file (CSV,
+# JSON, YAML, etc.).
+#
+# @example
+#   # bad
+#   # Huge Array literal
+#   [1, 2, '...', 999_999_999]
+#
+#   # bad
+#   # Huge Hash literal
+#   { 1 => 1, 2 => 2, '...' => '...', 999_999_999 => 999_999_999}
+#
+#   # bad
+#   # Huge Set "literal"
+#   Set[1, 2, '...', 999_999_999]
+#
+#   # good
+#   # Reasonably sized Array literal
+#   [1, 2, '...', 10]
+#
+#   # good
+#   # Reading huge Array from external data source
+#   # File.readlines('numbers.txt', chomp: true).map!(&:to_i)
+#
+#   # good
+#   # Reasonably sized Hash literal
+#   { 1 => 1, 2 => 2, '...' => '...', 10 => 10}
+#
+#   # good
+#   # Reading huge Hash from external data source
+#   CSV.foreach('numbers.csv', headers: true).each_with_object({}) do |row, hash|
+#   hash[row["key"].to_i] = row["value"].to_i
+#   end
+#
+#   # good
+#   # Reasonably sized Set "literal"
+#   Set[1, 2, '...', 10]
+#
+#   # good
+#   # Reading huge Set from external data source
+#   SomeFramework.config_for(:something)[:numbers].to_set
+#
+# source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#50
+class RuboCop::Cop::Metrics::CollectionLiteralLength < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#55
+  def on_array(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#55
+  def on_hash(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#60
+  def on_index(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#64
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#70
+  def collection_threshold; end
+end
+
+# source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#51
+RuboCop::Cop::Metrics::CollectionLiteralLength::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/metrics/collection_literal_length.rb#53
+RuboCop::Cop::Metrics::CollectionLiteralLength::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks that the cyclomatic complexity of methods is not higher
+# than the configured maximum. The cyclomatic complexity is the number of
+# linearly independent paths through a method. The algorithm counts
+# decision points and adds one.
+#
+# An if statement (or unless or ?:) increases the complexity by one. An
+# else branch does not, since it doesn't add a decision point. The &&
+# operator (or keyword and) can be converted to a nested if statement,
+# and ||/or is shorthand for a sequence of ifs, so they also add one.
+# Loops can be said to have an exit condition, so they add one.
+# Blocks that are calls to builtin iteration methods
+# (e.g. `ary.map{...}) also add one, others are ignored.
+#
+#   def each_child_node(*types)               # count begins: 1
+#     unless block_given?                     # unless: +1
+#       return to_enum(__method__, *types)
+#
+#     children.each do |child|                # each{}: +1
+#       next unless child.is_a?(Node)         # unless: +1
+#
+#       yield child if types.empty? ||        # if: +1, ||: +1
+#                      types.include?(child.type)
+#     end
+#
+#     self
+#   end                                       # total: 6
+#
+# source://rubocop//lib/rubocop/cop/metrics/cyclomatic_complexity.rb#32
+class RuboCop::Cop::Metrics::CyclomaticComplexity < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+  include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount
+  include ::RuboCop::Cop::MethodComplexity
+  include ::RuboCop::Cop::Metrics::Utils::IteratingBlock
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/metrics/cyclomatic_complexity.rb#42
+  def complexity_score_for(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/cyclomatic_complexity.rb#49
+  def count_block?(block); end
+end
+
+# source://rubocop//lib/rubocop/cop/metrics/cyclomatic_complexity.rb#37
+RuboCop::Cop::Metrics::CyclomaticComplexity::COUNTED_NODES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/metrics/cyclomatic_complexity.rb#36
+RuboCop::Cop::Metrics::CyclomaticComplexity::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if the length of a method exceeds some maximum value.
+# Comment lines can optionally be allowed.
+# The maximum allowed length is configurable.
+#
+# You can set constructs you want to fold with `CountAsOne`.
+#
+# Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+# Each construct will be counted as one line regardless of its actual size.
+#
+# NOTE: The `ExcludedMethods` and `IgnoredMethods` configuration is
+# deprecated and only kept for backwards compatibility.
+# Please use `AllowedMethods` and `AllowedPatterns` instead.
+# By default, there are no methods to allowed.
+#
+# @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
+#
+#   def m
+#   array = [       # +1
+#   1,
+#   2
+#   ]
+#
+#   hash = {        # +1
+#   key: 'value'
+#   }
+#
+#   <<~HEREDOC      # +1
+#   Heredoc
+#   content.
+#   HEREDOC
+#
+#   foo(            # +1
+#   1,
+#   2
+#   )
+#   end               # 4 points
+#
+# source://rubocop//lib/rubocop/cop/metrics/method_length.rb#43
+class RuboCop::Cop::Metrics::MethodLength < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CodeLength
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+
+  # source://rubocop//lib/rubocop/cop/metrics/method_length.rb#57
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/method_length.rb#50
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/method_length.rb#50
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/method_length.rb#57
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/metrics/method_length.rb#66
+  def cop_label; end
+end
+
+# source://rubocop//lib/rubocop/cop/metrics/method_length.rb#48
+RuboCop::Cop::Metrics::MethodLength::LABEL = T.let(T.unsafe(nil), String)
+
+# Checks if the length of a module exceeds some maximum value.
+# Comment lines can optionally be ignored.
+# The maximum allowed length is configurable.
+#
+# You can set constructs you want to fold with `CountAsOne`.
+#
+# Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+# Each construct will be counted as one line regardless of its actual size.
+#
+# @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
+#
+#   module M
+#   ARRAY = [         # +1
+#   1,
+#   2
+#   ]
+#
+#   HASH = {          # +1
+#   key: 'value'
+#   }
+#
+#   MSG = <<~HEREDOC  # +1
+#   Heredoc
+#   content.
+#   HEREDOC
+#
+#   foo(              # +1
+#   1,
+#   2
+#   )
+#   end                 # 4 points
+#
+# source://rubocop//lib/rubocop/cop/metrics/module_length.rb#38
+class RuboCop::Cop::Metrics::ModuleLength < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CodeLength
+
+  # source://rubocop//lib/rubocop/cop/metrics/module_length.rb#52
+  def module_definition?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/module_length.rb#45
+  def on_casgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/module_length.rb#41
+  def on_module(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/metrics/module_length.rb#56
+  def message(length, max_length); end
+end
+
+# Checks for methods with too many parameters.
+#
+# The maximum number of parameters is configurable.
+# Keyword arguments can optionally be excluded from the total count,
+# as they add less complexity than positional or optional parameters.
+#
+# Any number of arguments for `initialize` method inside a block of
+# `Struct.new` and `Data.define` like this is always allowed:
+#
+# [source,ruby]
+# ----
+# Struct.new(:one, :two, :three, :four, :five, keyword_init: true) do
+#   def initialize(one:, two:, three:, four:, five:)
+#   end
+# end
+# ----
+#
+# This is because checking the number of arguments of the `initialize` method
+# does not make sense.
+#
+# NOTE: Explicit block argument `&block` is not counted to prevent
+# erroneous change that is avoided by making block argument implicit.
+#
+# This cop also checks for the maximum number of optional parameters.
+# This can be configured using the `MaxOptionalParameters` config option.
+#
+# @example Max: 3
+#   # good
+#   def foo(a, b, c = 1)
+#   end
+# @example Max: 2
+#   # bad
+#   def foo(a, b, c = 1)
+#   end
+# @example CountKeywordArgs: true (default)
+#   # counts keyword args towards the maximum
+#
+#   # bad (assuming Max is 3)
+#   def foo(a, b, c, d: 1)
+#   end
+#
+#   # good (assuming Max is 3)
+#   def foo(a, b, c: 1)
+#   end
+# @example CountKeywordArgs: false
+#   # don't count keyword args towards the maximum
+#
+#   # good (assuming Max is 3)
+#   def foo(a, b, c, d: 1)
+#   end
+# @example MaxOptionalParameters: 3 (default)
+#   # good
+#   def foo(a = 1, b = 2, c = 3)
+#   end
+# @example MaxOptionalParameters: 2
+#   # bad
+#   def foo(a = 1, b = 2, c = 3)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#70
+class RuboCop::Cop::Metrics::ParameterLists < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#121
+  def argument_to_lambda_or_proc?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11
+  def max=(value); end
+
+  # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11
+  def max_optional_parameters=(value); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#104
+  def on_args(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#90
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#90
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#81
+  def struct_new_or_data_define_block?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#125
+  def args_count(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#141
+  def count_keyword_args?; end
+
+  # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#137
+  def max_optional_parameters; end
+
+  # source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#133
+  def max_params; end
+end
+
+# source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#74
+RuboCop::Cop::Metrics::ParameterLists::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#77
+RuboCop::Cop::Metrics::ParameterLists::NAMED_KEYWORD_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/metrics/parameter_lists.rb#75
+RuboCop::Cop::Metrics::ParameterLists::OPTIONAL_PARAMETERS_MSG = T.let(T.unsafe(nil), String)
+
+# Tries to produce a complexity score that's a measure of the
+# complexity the reader experiences when looking at a method. For that
+# reason it considers `when` nodes as something that doesn't add as much
+# complexity as an `if` or a `&&`. Except if it's one of those special
+# `case`/`when` constructs where there's no expression after `case`. Then
+# the cop treats it as an `if`/`elsif`/`elsif`... and lets all the `when`
+# nodes count. In contrast to the CyclomaticComplexity cop, this cop
+# considers `else` nodes as adding complexity.
+#
+# @example
+#
+#   def my_method                   # 1
+#   if cond                       # 1
+#   case var                    # 2 (0.8 + 4 * 0.2, rounded)
+#   when 1 then func_one
+#   when 2 then func_two
+#   when 3 then func_three
+#   when 4..10 then func_other
+#   end
+#   else                          # 1
+#   do_something until a && b   # 2
+#   end                           # ===
+#   end                             # 7 complexity points
+#
+# source://rubocop//lib/rubocop/cop/metrics/perceived_complexity.rb#29
+class RuboCop::Cop::Metrics::PerceivedComplexity < ::RuboCop::Cop::Metrics::CyclomaticComplexity
+  private
+
+  # source://rubocop//lib/rubocop/cop/metrics/perceived_complexity.rb#36
+  def complexity_score_for(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/metrics/perceived_complexity.rb#32
+RuboCop::Cop::Metrics::PerceivedComplexity::COUNTED_NODES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/metrics/perceived_complexity.rb#30
+RuboCop::Cop::Metrics::PerceivedComplexity::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb#6
+module RuboCop::Cop::Metrics::Utils; end
+
+# > ABC is .. a software size metric .. computed by counting the number
+# > of assignments, branches and conditions for a section of code.
+# > http://c2.com/cgi/wiki?AbcMetric
+#
+# We separate the *calculator* from the *cop* so that the calculation,
+# the formula itself, is easier to test.
+#
+# source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#13
+class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator
+  include ::RuboCop::AST::Sexp
+  include ::RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount
+  include ::RuboCop::Cop::Metrics::Utils::IteratingBlock
+  include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount
+
+  # @return [AbcSizeCalculator] a new instance of AbcSizeCalculator
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#30
+  def initialize(node, discount_repeated_attributes: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#42
+  def calculate; end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#53
+  def calculate_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#65
+  def else_branch?(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#47
+  def evaluate_branch_nodes(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#60
+  def evaluate_condition_node(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#127
+  def argument?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#86
+  def assignment?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#123
+  def branch?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#119
+  def capturing_variable?(name); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#95
+  def compound_assignment(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#131
+  def condition?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#108
+  def simple_assignment?(node); end
+
+  # @yield [node]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#71
+  def visit_depth_last(node, &block); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#30
+    def calculate(node, discount_repeated_attributes: T.unsafe(nil)); end
+  end
+end
+
+# > Branch -- an explicit forward program branch out of scope -- a
+# > function call, class method call ..
+# > http://c2.com/cgi/wiki?AbcMetric
+#
+# source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#21
+RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::BRANCH_NODES = T.let(T.unsafe(nil), Array)
+
+# > Condition -- a logical/Boolean test, == != <= >= < > else case
+# > default try catch ? and unary conditionals.
+# > http://c2.com/cgi/wiki?AbcMetric
+#
+# source://rubocop//lib/rubocop/cop/metrics/utils/abc_size_calculator.rb#26
+RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::CONDITION_NODES = T.let(T.unsafe(nil), Array)
+
+# Helps to calculate code length for the provided node.
+#
+# source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#8
+class RuboCop::Cop::Metrics::Utils::CodeLengthCalculator
+  include ::RuboCop::PathUtil
+  include ::RuboCop::Cop::Util
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # @return [CodeLengthCalculator] a new instance of CodeLengthCalculator
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#16
+  def initialize(node, processed_source, count_comments: T.unsafe(nil), foldable_types: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#24
+  def calculate; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#182
+  def another_args?(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#42
+  def build_foldable_checks(types); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#90
+  def classlike_code_length(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#138
+  def classlike_node?(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#66
+  def code_length(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#163
+  def count_comments?; end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#126
+  def each_top_level_descendant(node, types, &block); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#146
+  def extract_body(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#142
+  def foldable_node?(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#121
+  def heredoc_length(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#86
+  def heredoc_node?(node); end
+
+  # Returns true for lines that shall not be included in the count.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#159
+  def irrelevant_line?(source_line); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#110
+  def line_numbers_of_inner_nodes(node, *types); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#106
+  def namespace_module?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#186
+  def node_with_heredoc?(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#60
+  def normalize_foldable_types(types); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#167
+  def omit_length(descendant); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#178
+  def parenthesized?(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#190
+  def source_from_node_with_heredoc(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#13
+RuboCop::Cop::Metrics::Utils::CodeLengthCalculator::CLASSLIKE_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/metrics/utils/code_length_calculator.rb#12
+RuboCop::Cop::Metrics::Utils::CodeLengthCalculator::FOLDABLE_TYPES = T.let(T.unsafe(nil), Array)
+
+# Used to identify iterating blocks like `.map{}` and `.map(&:...)`
+#
+# source://rubocop//lib/rubocop/cop/metrics/utils/iterating_block.rb#8
+module RuboCop::Cop::Metrics::Utils::IteratingBlock
+  # Returns the name of the method called with a block
+  # if node is a block node, or a block-pass node.
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/iterating_block.rb#37
+  def block_method_name(node); end
+
+  # Returns nil if node is neither a block node or a block-pass node.
+  # Otherwise returns true/false if method call is a known iterating call
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/iterating_block.rb#53
+  def iterating_block?(node); end
+
+  # Returns true iff name is a known iterating type (e.g. :each, :transform_values)
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/iterating_block.rb#47
+  def iterating_method?(name); end
+end
+
+# source://rubocop//lib/rubocop/cop/metrics/utils/iterating_block.rb#33
+RuboCop::Cop::Metrics::Utils::IteratingBlock::KNOWN_ITERATING_METHODS = T.let(T.unsafe(nil), Set)
+
+# Identifies repetitions `{c}send` calls with no arguments:
+#
+#   foo.bar
+#   foo.bar # => repeated
+#   foo.bar.baz.qux # => inner send repeated
+#   foo.bar.baz.other # => both inner send repeated
+#   foo.bar(2) # => not repeated
+#
+# It also invalidates sequences if a receiver is reassigned:
+#
+#   xx.foo.bar
+#   xx.foo.baz      # => inner send repeated
+#   self.xx = any   # => invalidates everything so far
+#   xx.foo.baz      # => no repetition
+#   self.xx.foo.baz # => all repeated
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#25
+module RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount
+  include ::RuboCop::AST::Sexp
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # Plug into the calculator
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#30
+  def initialize(node, discount_repeated_attributes: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#61
+  def attribute_call?(param0 = T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#53
+  def calculate_node(node); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#43
+  def discount_repeated_attributes?; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#47
+  def evaluate_branch_nodes(node); end
+
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#92
+  def root_node?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#66
+  def discount_repeated_attribute?(send_node); end
+
+  # Returns the "known_attributes" for the `node` by walking the receiver tree
+  # If at any step the subdirectory does not exist, it is yielded with the
+  # associated key (method_name)
+  # If the node is not a series of `(c)send` calls with no arguments,
+  # then `nil` is yielded
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#103
+  def find_attributes(node, &block); end
+
+  # or `nil` if it is not a setter.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#126
+  def setter_to_getter(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#80
+  def update_repeated_attribute(node); end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb#117
+RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount::VAR_SETTER_TO_GETTER = T.let(T.unsafe(nil), Hash)
+
+# Identifies repetitions `&.` on the same variable:
+#
+#  my_var&.foo
+#  my_var&.bar # => repeated
+#  my_var = baz # => reset
+#  my_var&.qux # => not repeated
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb#15
+module RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb#20
+  def discount_for_repeated_csend?(csend_node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb#34
+  def reset_on_lvasgn(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb#16
+  def reset_repeated_csend; end
+end
+
+# source://rubocop//lib/rubocop/cop/migration/department_name.rb#5
+module RuboCop::Cop::Migration; end
+
+# department name.
+#
+# source://rubocop//lib/rubocop/cop/migration/department_name.rb#8
+class RuboCop::Cop::Migration::DepartmentName < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/migration/department_name.rb#21
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/migration/department_name.rb#47
+  def check_cop_name(name, comment, offset); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/migration/department_name.rb#69
+  def contain_unexpected_character_for_department_name?(name); end
+
+  # source://rubocop//lib/rubocop/cop/migration/department_name.rb#43
+  def disable_comment_offset; end
+
+  # source://rubocop//lib/rubocop/cop/migration/department_name.rb#73
+  def qualified_legacy_cop_name(cop_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/migration/department_name.rb#63
+  def valid_content_token?(content_token); end
+end
+
+# source://rubocop//lib/rubocop/cop/migration/department_name.rb#14
+RuboCop::Cop::Migration::DepartmentName::DISABLE_COMMENT_FORMAT = T.let(T.unsafe(nil), Regexp)
+
+# The token that makes up a disable comment.
+# `DepartmentName/CopName` or` all`.
+#
+# source://rubocop//lib/rubocop/cop/migration/department_name.rb#19
+RuboCop::Cop::Migration::DepartmentName::DISABLING_COPS_CONTENT_TOKEN = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/migration/department_name.rb#12
+RuboCop::Cop::Migration::DepartmentName::MSG = T.let(T.unsafe(nil), String)
+
+# Common functionality for checking minimum body length.
+#
+# source://rubocop//lib/rubocop/cop/mixin/min_body_length.rb#6
+module RuboCop::Cop::MinBodyLength
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/min_body_length.rb#13
+  def min_body_length; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/min_body_length.rb#9
+  def min_body_length?(node); end
+end
+
+# Common functionality for checking minimum branches count.
+#
+# source://rubocop//lib/rubocop/cop/mixin/min_branches_count.rb#6
+module RuboCop::Cop::MinBranchesCount
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/min_branches_count.rb#29
+  def if_conditional_branches(node, branches = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/min_branches_count.rb#22
+  def min_branches_count; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/min_branches_count.rb#9
+  def min_branches_count?(node); end
+end
+
+# Common code for indenting the first elements in multiline
+# array literals, hash literals, and method definitions.
+#
+# source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#7
+module RuboCop::Cop::MultilineElementIndentation
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#42
+  def check_expected_style(styles); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#26
+  def check_first(first, left_brace, left_parenthesis, offset); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#80
+  def detected_styles(actual_column, offset, left_parenthesis, left_brace); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#85
+  def detected_styles_for_column(column, left_parenthesis, left_brace); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#10
+  def each_argument_node(node, type); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#66
+  def hash_pair_where_value_beginning_with(left_brace, first); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#98
+  def incorrect_style_detected(styles, first, base_column_type); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#50
+  def indent_base(left_brace, first, left_parenthesis); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#72
+  def key_and_value_begin_on_same_line?(pair); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_element_indentation.rb#76
+  def right_sibling_begins_on_subsequent_line?(pair); end
+end
+
+# Common functionality for checking for a line break before each
+# element in a multi-line collection.
+#
+# source://rubocop//lib/rubocop/cop/mixin/multiline_element_line_breaks.rb#7
+module RuboCop::Cop::MultilineElementLineBreaks
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_element_line_breaks.rb#23
+  def all_on_same_line?(nodes, ignore_last: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_element_line_breaks.rb#10
+  def check_line_breaks(_node, children, ignore_last: T.unsafe(nil)); end
+end
+
+# Common functionality for checking multiline method calls and binary
+# operations.
+#
+# source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#7
+module RuboCop::Cop::MultilineExpressionIndentation
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#14
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#14
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#132
+  def argument_in_method_call(node, kind); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#188
+  def assignment_rhs(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#65
+  def check(range, node, lhs, rhs); end
+
+  # The correct indentation of `node` is usually `IndentationWidth`, with
+  # one exception: prefix keywords.
+  #
+  # ```
+  # while foo &&  # Here, `while` is called a "prefix keyword"
+  #     bar       # This is called "special indentation"
+  #   baz
+  # end
+  # ```
+  #
+  # Note that *postfix conditionals* do *not* get "special indentation".
+  #
+  # ```
+  # next if foo &&
+  #   bar # normal indentation, not special
+  # ```
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#55
+  def correct_indentation(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#160
+  def disqualified_rhs?(candidate, ancestor); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#204
+  def grouped_expression?(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#73
+  def incorrect_style_detected(range, node, lhs, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#85
+  def indentation(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#122
+  def indented_keyword_expression(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#208
+  def inside_arg_list_parentheses?(node, ancestor); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#99
+  def keyword_message_tail(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#107
+  def kw_node_with_special_indentation(node); end
+
+  # In a chain of method calls, we regard the top call node as the base
+  # for indentation of all lines following the first. For example:
+  # a.
+  #   b c { block }.            <-- b is indented relative to a
+  #   d                         <-- d is indented relative to a
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#32
+  def left_hand_side(lhs); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#198
+  def not_for_this_cop?(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#89
+  def operation_description(node, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#146
+  def part_of_assignment_rhs(node, candidate); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#184
+  def part_of_block_body?(candidate, block_node); end
+
+  # Returns true if `node` is a conditional whose `body` and `condition`
+  # begin on the same line.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#217
+  def postfix_conditional?(node); end
+
+  # The []= operator and setters (a.b = c) are parsed as :send nodes.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#176
+  def valid_method_rhs_candidate?(candidate, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#165
+  def valid_rhs?(candidate, ancestor); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#180
+  def valid_rhs_candidate?(candidate, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#221
+  def within_node?(inner, outer); end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#11
+RuboCop::Cop::MultilineExpressionIndentation::ASSIGNMENT_MESSAGE_TAIL = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#10
+RuboCop::Cop::MultilineExpressionIndentation::DEFAULT_MESSAGE_TAIL = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#8
+RuboCop::Cop::MultilineExpressionIndentation::KEYWORD_ANCESTOR_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#12
+RuboCop::Cop::MultilineExpressionIndentation::KEYWORD_MESSAGE_TAIL = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/multiline_expression_indentation.rb#9
+RuboCop::Cop::MultilineExpressionIndentation::UNALIGNED_RHS_TYPES = T.let(T.unsafe(nil), Array)
+
+# Autocorrection logic for the closing brace of a literal either
+# on the same line as the last contained elements, or a new line.
+#
+# source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#7
+class RuboCop::Cop::MultilineLiteralBraceCorrector
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::MultilineLiteralBraceLayout
+  include ::RuboCop::Cop::RangeHelp
+
+  # @return [MultilineLiteralBraceCorrector] a new instance of MultilineLiteralBraceCorrector
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#15
+  def initialize(corrector, node, processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#21
+  def call; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#61
+  def content_if_comment_present(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#51
+  def correct_heredoc_argument_method_chain(corrector, end_range); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#46
+  def correct_next_line_brace(corrector, end_range); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#42
+  def correct_same_line_brace(corrector); end
+
+  # Returns the value of attribute corrector.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#40
+  def corrector; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#94
+  def last_element_range_with_trailing_comma(node); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#103
+  def last_element_trailing_comma_range(node); end
+
+  # Returns the value of attribute node.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#40
+  def node; end
+
+  # Returns the value of attribute processed_source.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#40
+  def processed_source; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#90
+  def remove_trailing_content_of_comment(corrector, range); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#80
+  def select_content_to_be_inserted_after_last_element(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#73
+  def use_heredoc_argument_method_chain?(parent); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb#11
+    def correct(corrector, node, processed_source); end
+  end
+end
+
+# Common functionality for checking the closing brace of a literal is
+# either on the same line as the last contained elements or a new line.
+#
+# source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#7
+module RuboCop::Cop::MultilineLiteralBraceLayout
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#34
+  def check(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#12
+  def check_brace_layout(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#42
+  def check_new_line(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#50
+  def check_same_line(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#58
+  def check_symmetrical(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#86
+  def children(node); end
+
+  # This method depends on the fact that we have guarded
+  # against implicit and empty literals.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#98
+  def closing_brace_on_same_line?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#74
+  def empty_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#82
+  def ignored_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#78
+  def implicit_literal?(node); end
+
+  # Starting with the parent node and recursively for the parent node's
+  # children, check if the node is a HEREDOC and if the HEREDOC ends below
+  # or on the last line of the parent node.
+  #
+  # Example:
+  #
+  #   # node is `b: ...` parameter
+  #   # last_line_heredoc?(node) => false
+  #   foo(a,
+  #     b: {
+  #       a: 1,
+  #       c: <<-EOM
+  #         baz
+  #       EOM
+  #     }
+  #   )
+  #
+  #   # node is `b: ...` parameter
+  #   # last_line_heredoc?(node) => true
+  #   foo(a,
+  #     b: <<-EOM
+  #       baz
+  #     EOM
+  #   )
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#126
+  def last_line_heredoc?(node, parent = T.unsafe(nil)); end
+
+  # Returns true for the case
+  #   [a,
+  #    b # comment
+  #   ].some_method
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#26
+  def new_line_needed_before_closing_brace?(node); end
+
+  # This method depends on the fact that we have guarded
+  # against implicit and empty literals.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb#92
+  def opening_brace_on_same_line?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#5
+module RuboCop::Cop::Naming; end
+
+# Makes sure that accessor methods are named properly. Applies
+# to both instance and class methods.
+#
+# NOTE: Offenses are only registered for methods with the expected
+# arity. Getters (`get_attribute`) must have no arguments to be
+# registered, and setters (`set_attribute(value)`) must have exactly
+# one.
+#
+# @example
+#   # bad
+#   def set_attribute(value)
+#   end
+#
+#   # good
+#   def attribute=(value)
+#   end
+#
+#   # bad
+#   def get_attribute
+#   end
+#
+#   # good
+#   def attribute
+#   end
+#
+#   # accepted, incorrect arity for getter
+#   def get_value(attr)
+#   end
+#
+#   # accepted, incorrect arity for setter
+#   def set_value
+#   end
+#
+# source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#38
+class RuboCop::Cop::Naming::AccessorMethodName < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#42
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#42
+  def on_defs(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#66
+  def bad_reader_name?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#70
+  def bad_writer_name?(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#54
+  def message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#62
+  def proper_attribute_name?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#39
+RuboCop::Cop::Naming::AccessorMethodName::MSG_READER = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/naming/accessor_method_name.rb#40
+RuboCop::Cop::Naming::AccessorMethodName::MSG_WRITER = T.let(T.unsafe(nil), String)
+
+# Checks for non-ascii characters in identifier and constant names.
+# Identifiers are always checked and whether constants are checked
+# can be controlled using AsciiConstants config.
+#
+# @example
+#   # bad
+#   def καλημερα # Greek alphabet (non-ascii)
+#   end
+#
+#   # bad
+#   def こんにちはと言う # Japanese character (non-ascii)
+#   end
+#
+#   # bad
+#   def hello_🍣 # Emoji (non-ascii)
+#   end
+#
+#   # good
+#   def say_hello
+#   end
+#
+#   # bad
+#   신장 = 10 # Hangul character (non-ascii)
+#
+#   # good
+#   height = 10
+#
+#   # bad
+#   params[:عرض_gteq] # Arabic character (non-ascii)
+#
+#   # good
+#   params[:width_gteq]
+# @example AsciiConstants: true (default)
+#   # bad
+#   class Foö
+#   end
+#
+#   FOÖ = "foo"
+# @example AsciiConstants: false
+#   # good
+#   class Foö
+#   end
+#
+#   FOÖ = "foo"
+#
+# source://rubocop//lib/rubocop/cop/naming/ascii_identifiers.rb#53
+class RuboCop::Cop::Naming::AsciiIdentifiers < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/naming/ascii_identifiers.rb#59
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/naming/ascii_identifiers.rb#84
+  def first_non_ascii_chars(string); end
+
+  # source://rubocop//lib/rubocop/cop/naming/ascii_identifiers.rb#74
+  def first_offense_range(identifier); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/ascii_identifiers.rb#70
+  def should_check?(token); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/ascii_identifiers.rb#57
+RuboCop::Cop::Naming::AsciiIdentifiers::CONSTANT_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/naming/ascii_identifiers.rb#56
+RuboCop::Cop::Naming::AsciiIdentifiers::IDENTIFIER_MSG = T.let(T.unsafe(nil), String)
+
+# Makes sure that certain binary operator methods have their
+# sole  parameter named `other`.
+#
+# @example
+#
+#   # bad
+#   def +(amount); end
+#
+#   # good
+#   def +(other); end
+#
+# source://rubocop//lib/rubocop/cop/naming/binary_operator_parameter_name.rb#16
+class RuboCop::Cop::Naming::BinaryOperatorParameterName < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/naming/binary_operator_parameter_name.rb#29
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/binary_operator_parameter_name.rb#25
+  def op_method_candidate?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/binary_operator_parameter_name.rb#45
+  def op_method?(name); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/binary_operator_parameter_name.rb#22
+RuboCop::Cop::Naming::BinaryOperatorParameterName::EXCLUDED = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/naming/binary_operator_parameter_name.rb#19
+RuboCop::Cop::Naming::BinaryOperatorParameterName::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/naming/binary_operator_parameter_name.rb#21
+RuboCop::Cop::Naming::BinaryOperatorParameterName::OP_LIKE_METHODS = T.let(T.unsafe(nil), Array)
+
+# In Ruby 3.1, anonymous block forwarding has been added.
+#
+# This cop identifies places where `do_something(&block)` can be replaced
+# by `do_something(&)`.
+#
+# It also supports the opposite style by alternative `explicit` option.
+# You can specify the block variable name for autocorrection with `BlockForwardingName`.
+# The default variable name is `block`. If the name is already in use, it will not be
+# autocorrected.
+#
+# @example EnforcedStyle: anonymous (default)
+#
+#   # bad
+#   def foo(&block)
+#   bar(&block)
+#   end
+#
+#   # good
+#   def foo(&)
+#   bar(&)
+#   end
+# @example EnforcedStyle: explicit
+#
+#   # bad
+#   def foo(&)
+#   bar(&)
+#   end
+#
+#   # good
+#   def foo(&block)
+#   bar(&block)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#40
+class RuboCop::Cop::Naming::BlockForwarding < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#54
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#54
+  def on_defs(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#114
+  def anonymous_block_argument?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#87
+  def block_argument_name_matched?(block_pass_node, last_argument); end
+
+  # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#146
+  def block_forwarding_name; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#77
+  def expected_block_forwarding_style?(node, last_argument); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#118
+  def explicit_block_argument?(node); end
+
+  # Prevents the following syntax error:
+  #
+  # # foo.rb
+  # def foo(&)
+  #   block_method do
+  #     bar(&)
+  #   end
+  # end
+  #
+  # $ ruby -vc foo.rb
+  # ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [x86_64-darwin22]
+  # foo.rb: foo.rb:4: anonymous block parameter is also used within block (SyntaxError)
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#106
+  def invalidates_syntax?(block_pass_node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#122
+  def register_offense(block_argument, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#138
+  def use_block_argument_as_local_variable?(node, last_argument); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#110
+  def use_kwarg_in_method_definition?(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#50
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/block_forwarding.rb#48
+RuboCop::Cop::Naming::BlockForwarding::MSG = T.let(T.unsafe(nil), String)
+
+# Checks block parameter names for how descriptive they
+# are. It is highly configurable.
+#
+# The `MinNameLength` config option takes an integer. It represents
+# the minimum amount of characters the name must be. Its default is 1.
+# The `AllowNamesEndingInNumbers` config option takes a boolean. When
+# set to false, this cop will register offenses for names ending with
+# numbers. Its default is false. The `AllowedNames` config option
+# takes an array of permitted names that will never register an
+# offense. The `ForbiddenNames` config option takes an array of
+# restricted names that will always register an offense.
+#
+# @example
+#   # bad
+#   bar do |varOne, varTwo|
+#   varOne + varTwo
+#   end
+#
+#   # With `AllowNamesEndingInNumbers` set to false
+#   foo { |num1, num2| num1 * num2 }
+#
+#   # With `MinNameLength` set to number greater than 1
+#   baz { |a, b, c| do_stuff(a, b, c) }
+#
+#   # good
+#   bar do |thud, fred|
+#   thud + fred
+#   end
+#
+#   foo { |speed, distance| speed * distance }
+#
+#   baz { |age, height, gender| do_stuff(age, height, gender) }
+#
+# source://rubocop//lib/rubocop/cop/naming/block_parameter_name.rb#38
+class RuboCop::Cop::Naming::BlockParameterName < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::UncommunicativeName
+
+  # source://rubocop//lib/rubocop/cop/naming/block_parameter_name.rb#41
+  def on_block(node); end
+end
+
+# Checks for class and module names with
+# an underscore in them.
+#
+# `AllowedNames` config takes an array of permitted names.
+# Its default value is `['module_parent']`.
+# These names can be full class/module names or part of the name.
+# eg. Adding `my_class` to the `AllowedNames` config will allow names like
+# `my_class`, `my_class::User`, `App::my_class`, `App::my_class::User`, etc.
+#
+# @example
+#   # bad
+#   class My_Class
+#   end
+#   module My_Module
+#   end
+#
+#   # good
+#   class MyClass
+#   end
+#   module MyModule
+#   end
+#   class module_parent::MyModule
+#   end
+#
+# source://rubocop//lib/rubocop/cop/naming/class_and_module_camel_case.rb#29
+class RuboCop::Cop::Naming::ClassAndModuleCamelCase < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/naming/class_and_module_camel_case.rb#32
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/class_and_module_camel_case.rb#32
+  def on_module(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/class_and_module_camel_case.rb#30
+RuboCop::Cop::Naming::ClassAndModuleCamelCase::MSG = T.let(T.unsafe(nil), String)
+
+# Checks whether constant names are written using
+# SCREAMING_SNAKE_CASE.
+#
+# To avoid false positives, it ignores cases in which we cannot know
+# for certain the type of value that would be assigned to a constant.
+#
+# @example
+#   # bad
+#   InchInCm = 2.54
+#   INCHinCM = 2.54
+#   Inch_In_Cm = 2.54
+#
+#   # good
+#   INCH_IN_CM = 2.54
+#
+# source://rubocop//lib/rubocop/cop/naming/constant_name.rb#20
+class RuboCop::Cop::Naming::ConstantName < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/naming/constant_name.rb#27
+  def class_or_struct_return_method?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/naming/constant_name.rb#68
+  def literal_receiver?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/naming/constant_name.rb#33
+  def on_casgn(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/constant_name.rb#56
+  def allowed_assignment?(value); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/constant_name.rb#73
+  def allowed_conditional_expression_on_rhs?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/constant_name.rb#63
+  def allowed_method_call_on_rhs?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/constant_name.rb#77
+  def contains_constant?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/constant_name.rb#21
+RuboCop::Cop::Naming::ConstantName::MSG = T.let(T.unsafe(nil), String)
+
+# Use POSIX character classes, so we allow accented characters rather
+# than just standard ASCII characters
+#
+# source://rubocop//lib/rubocop/cop/naming/constant_name.rb#24
+RuboCop::Cop::Naming::ConstantName::SNAKE_CASE = T.let(T.unsafe(nil), Regexp)
+
+# Makes sure that Ruby source files have snake_case
+# names. Ruby scripts (i.e. source files with a shebang in the
+# first line) are ignored.
+#
+# The cop also ignores `.gemspec` files, because Bundler
+# recommends using dashes to separate namespaces in nested gems
+# (i.e. `bundler-console` becomes `Bundler::Console`). As such, the
+# gemspec is supposed to be named `bundler-console.gemspec`.
+#
+# When `ExpectMatchingDefinition` (default: `false`) is `true`, the cop requires
+# each file to have a class, module or `Struct` defined in it that matches
+# the filename. This can be further configured using
+# `CheckDefinitionPathHierarchy` (default: `true`) to determine whether the
+# path should match the namespace of the above definition.
+#
+# When `IgnoreExecutableScripts` (default: `true`) is `true`, files that start
+# with a shebang line are not considered by the cop.
+#
+# When `Regex` is set, the cop will flag any filename that does not match
+# the regular expression.
+#
+# @example
+#   # bad
+#   lib/layoutManager.rb
+#
+#   anything/usingCamelCase
+#
+#   # good
+#   lib/layout_manager.rb
+#
+#   anything/using_snake_case.rake
+#
+# source://rubocop//lib/rubocop/cop/naming/file_name.rb#39
+class RuboCop::Cop::Naming::FileName < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#56
+  def on_new_investigation; end
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#49
+  def struct_definition(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#134
+  def allowed_acronyms; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#96
+  def bad_filename_allowed?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#122
+  def check_definition_path_hierarchy?; end
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#169
+  def defined_struct(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#126
+  def definition_path_hierarchy_roots; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#118
+  def expect_matching_definition?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#138
+  def filename_good?(basename); end
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#147
+  def find_class_or_module(node, namespace); end
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#165
+  def find_definition(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#65
+  def for_bad_filename(file_path); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#114
+  def ignore_executable_scripts?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#202
+  def match?(expected); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#206
+  def match_acronym?(expected, name); end
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#174
+  def match_namespace(node, namespace, expected); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#92
+  def matching_class?(file_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#88
+  def matching_definition?(file_path); end
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#100
+  def no_definition_message(basename, file_path); end
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#106
+  def other_message(basename); end
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#188
+  def partial_matcher!(expected); end
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#77
+  def perform_class_and_module_naming_checks(file_path, basename); end
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#130
+  def regex; end
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#240
+  def to_module_name(basename); end
+
+  # source://rubocop//lib/rubocop/cop/naming/file_name.rb#213
+  def to_namespace(path); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/file_name.rb#43
+RuboCop::Cop::Naming::FileName::MSG_NO_DEFINITION = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/naming/file_name.rb#44
+RuboCop::Cop::Naming::FileName::MSG_REGEX = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/naming/file_name.rb#42
+RuboCop::Cop::Naming::FileName::MSG_SNAKE_CASE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/naming/file_name.rb#46
+RuboCop::Cop::Naming::FileName::SNAKE_CASE = T.let(T.unsafe(nil), Regexp)
+
+# Checks that your heredocs are using the configured case.
+# By default it is configured to enforce uppercase heredocs.
+#
+# @example EnforcedStyle: uppercase (default)
+#   # bad
+#   <<-sql
+#   SELECT * FROM foo
+#   sql
+#
+#   # good
+#   <<-SQL
+#   SELECT * FROM foo
+#   SQL
+# @example EnforcedStyle: lowercase
+#   # bad
+#   <<-SQL
+#   SELECT * FROM foo
+#   SQL
+#
+#   # good
+#   <<-sql
+#   SELECT * FROM foo
+#   sql
+#
+# source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_case.rb#30
+class RuboCop::Cop::Naming::HeredocDelimiterCase < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Heredoc
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_case.rb#37
+  def on_heredoc(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_case.rb#54
+  def correct_case_delimiters?(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_case.rb#58
+  def correct_delimiters(source); end
+
+  # source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_case.rb#50
+  def message(_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_case.rb#35
+RuboCop::Cop::Naming::HeredocDelimiterCase::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that your heredocs are using meaningful delimiters.
+# By default it disallows `END` and `EO*`, and can be configured through
+# forbidden listing additional delimiters.
+#
+# @example
+#
+#   # good
+#   <<-SQL
+#   SELECT * FROM foo
+#   SQL
+#
+#   # bad
+#   <<-END
+#   SELECT * FROM foo
+#   END
+#
+#   # bad
+#   <<-EOS
+#   SELECT * FROM foo
+#   EOS
+#
+# source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_naming.rb#26
+class RuboCop::Cop::Naming::HeredocDelimiterNaming < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Heredoc
+
+  # source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_naming.rb#31
+  def on_heredoc(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_naming.rb#51
+  def forbidden_delimiters; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_naming.rb#41
+  def meaningful_delimiters?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/heredoc_delimiter_naming.rb#29
+RuboCop::Cop::Naming::HeredocDelimiterNaming::MSG = T.let(T.unsafe(nil), String)
+
+# Recommends the use of inclusive language instead of problematic terms.
+# The cop can check the following locations for offenses:
+#
+# - identifiers
+# - constants
+# - variables
+# - strings
+# - symbols
+# - comments
+# - file paths
+#
+# Each of these locations can be individually enabled/disabled via configuration,
+# for example CheckIdentifiers = true/false.
+#
+# Flagged terms are configurable for the cop. For each flagged term an optional
+# Regex can be specified to identify offenses. Suggestions for replacing a flagged term can
+# be configured and will be displayed as part of the offense message.
+# An AllowedRegex can be specified for a flagged term to exempt allowed uses of the term.
+# `WholeWord: true` can be set on a flagged term to indicate the cop should only match when
+# a term matches the whole word (partial matches will not be offenses).
+#
+# The cop supports autocorrection when there is only one suggestion. When there are multiple
+# suggestions, the best suggestion cannot be identified and will not be autocorrected.
+#
+# @example FlaggedTerms: { whitelist: { Suggestions: ['allowlist'] } }
+#   # Suggest replacing identifier whitelist with allowlist
+#
+#   # bad
+#   whitelist_users = %w(user1 user1)
+#
+#   # good
+#   allowlist_users = %w(user1 user2)
+# @example FlaggedTerms: { master: { Suggestions: ['main', 'primary', 'leader'] } }
+#   # Suggest replacing master in an instance variable name with main, primary, or leader
+#
+#   # bad
+#   @master_node = 'node1.example.com'
+#
+#   # good
+#   @primary_node = 'node1.example.com'
+# @example FlaggedTerms: { whitelist: { Regex: !ruby/regexp '/white[-_\s]?list' } }
+#   # Identify problematic terms using a Regexp
+#
+#   # bad
+#   white_list = %w(user1 user2)
+#
+#   # good
+#   allow_list = %w(user1 user2)
+# @example FlaggedTerms: { master: { AllowedRegex: 'master\'?s degree' } }
+#   # Specify allowed uses of the flagged term as a string or regexp.
+#
+#   # bad
+#   # They had a masters
+#
+#   # good
+#   # They had a master's degree
+# @example FlaggedTerms: { slave: { WholeWord: true } }
+#   # Specify that only terms that are full matches will be flagged.
+#
+#   # bad
+#   Slave
+#
+#   # good (won't be flagged despite containing `slave`)
+#   TeslaVehicle
+#
+# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#74
+class RuboCop::Cop::Naming::InclusiveLanguage < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # @return [InclusiveLanguage] a new instance of InclusiveLanguage
+  #
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#84
+  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#93
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#111
+  def add_offenses_for_token(token, word_locations); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#176
+  def add_to_flagged_term_hash(regex_string, term, term_definition); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#202
+  def array_to_ignorecase_regex(strings); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#126
+  def check_token?(type); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#252
+  def create_message(word, message = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#226
+  def create_multiple_word_message_for_file(words); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#222
+  def create_single_word_message_for_file(word); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#198
+  def ensure_regex_string(regex); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#169
+  def extract_regexp(term, term_definition); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#260
+  def find_flagged_term(word); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#274
+  def format_suggestions(suggestions); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#206
+  def investigate_filepath; end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#100
+  def investigate_tokens; end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#240
+  def mask_input(str); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#289
+  def offense_range(token, word); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#160
+  def preferred_sole_term(suggestions); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#130
+  def preprocess_check_config; end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#144
+  def preprocess_flagged_terms; end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#267
+  def preprocess_suggestions(suggestions); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#188
+  def process_allowed_regex(allowed); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#230
+  def scan_for_words(input); end
+
+  # source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#183
+  def set_regexes(flagged_term_strings, allowed_strings); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#78
+RuboCop::Cop::Naming::InclusiveLanguage::EMPTY_ARRAY = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#79
+RuboCop::Cop::Naming::InclusiveLanguage::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#80
+RuboCop::Cop::Naming::InclusiveLanguage::MSG_FOR_FILE_PATH = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/naming/inclusive_language.rb#82
+class RuboCop::Cop::Naming::InclusiveLanguage::WordLocation < ::Struct
+  # Returns the value of attribute position
+  #
+  # @return [Object] the current value of position
+  def position; end
+
+  # Sets the attribute position
+  #
+  # @param value [Object] the value to set the attribute position to.
+  # @return [Object] the newly set value
+  def position=(_); end
+
+  # Returns the value of attribute word
+  #
+  # @return [Object] the current value of word
+  def word; end
+
+  # Sets the attribute word
+  #
+  # @param value [Object] the value to set the attribute word to.
+  # @return [Object] the newly set value
+  def word=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# Checks for memoized methods whose instance variable name
+# does not match the method name. Applies to both regular methods
+# (defined with `def`) and dynamic methods (defined with
+# `define_method` or `define_singleton_method`).
+#
+# This cop can be configured with the EnforcedStyleForLeadingUnderscores
+# directive. It can be configured to allow for memoized instance variables
+# prefixed with an underscore. Prefixing ivars with an underscore is a
+# convention that is used to implicitly indicate that an ivar should not
+# be set or referenced outside of the memoization method.
+#
+# @example EnforcedStyleForLeadingUnderscores: disallowed (default)
+#   # bad
+#   # Method foo is memoized using an instance variable that is
+#   # not `@foo`. This can cause confusion and bugs.
+#   def foo
+#   @something ||= calculate_expensive_thing
+#   end
+#
+#   def foo
+#   return @something if defined?(@something)
+#   @something = calculate_expensive_thing
+#   end
+#
+#   # good
+#   def _foo
+#   @foo ||= calculate_expensive_thing
+#   end
+#
+#   # good
+#   def foo
+#   @foo ||= calculate_expensive_thing
+#   end
+#
+#   # good
+#   def foo
+#   @foo ||= begin
+#   calculate_expensive_thing
+#   end
+#   end
+#
+#   # good
+#   def foo
+#   helper_variable = something_we_need_to_calculate_foo
+#   @foo ||= calculate_expensive_thing(helper_variable)
+#   end
+#
+#   # good
+#   define_method(:foo) do
+#   @foo ||= calculate_expensive_thing
+#   end
+#
+#   # good
+#   define_method(:foo) do
+#   return @foo if defined?(@foo)
+#   @foo = calculate_expensive_thing
+#   end
+# @example EnforcedStyleForLeadingUnderscores: required
+#   # bad
+#   def foo
+#   @something ||= calculate_expensive_thing
+#   end
+#
+#   # bad
+#   def foo
+#   @foo ||= calculate_expensive_thing
+#   end
+#
+#   def foo
+#   return @foo if defined?(@foo)
+#   @foo = calculate_expensive_thing
+#   end
+#
+#   # good
+#   def foo
+#   @_foo ||= calculate_expensive_thing
+#   end
+#
+#   # good
+#   def _foo
+#   @_foo ||= calculate_expensive_thing
+#   end
+#
+#   def foo
+#   return @_foo if defined?(@_foo)
+#   @_foo = calculate_expensive_thing
+#   end
+#
+#   # good
+#   define_method(:foo) do
+#   @_foo ||= calculate_expensive_thing
+#   end
+#
+#   # good
+#   define_method(:foo) do
+#   return @_foo if defined?(@_foo)
+#   @_foo = calculate_expensive_thing
+#   end
+# @example EnforcedStyleForLeadingUnderscores :optional
+#   # bad
+#   def foo
+#   @something ||= calculate_expensive_thing
+#   end
+#
+#   # good
+#   def foo
+#   @foo ||= calculate_expensive_thing
+#   end
+#
+#   # good
+#   def foo
+#   @_foo ||= calculate_expensive_thing
+#   end
+#
+#   # good
+#   def _foo
+#   @_foo ||= calculate_expensive_thing
+#   end
+#
+#   # good
+#   def foo
+#   return @_foo if defined?(@_foo)
+#   @_foo = calculate_expensive_thing
+#   end
+#
+#   # good
+#   define_method(:foo) do
+#   @foo ||= calculate_expensive_thing
+#   end
+#
+#   # good
+#   define_method(:foo) do
+#   @_foo ||= calculate_expensive_thing
+#   end
+#
+# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#148
+class RuboCop::Cop::Naming::MemoizedInstanceVariableName < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#197
+  def defined_memoized?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#160
+  def method_definition?(param0 = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#205
+  def on_defined?(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#170
+  def on_or_asgn(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#242
+  def find_definition(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#253
+  def matches?(method_name, ivar_assign); end
+
+  # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#263
+  def message(variable); end
+
+  # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#238
+  def style_parameter_name; end
+
+  # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#271
+  def suggested_var(method_name); end
+
+  # source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#277
+  def variable_name_candidates(method_name); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#157
+RuboCop::Cop::Naming::MemoizedInstanceVariableName::DYNAMIC_DEFINE_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#153
+RuboCop::Cop::Naming::MemoizedInstanceVariableName::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/naming/memoized_instance_variable_name.rb#155
+RuboCop::Cop::Naming::MemoizedInstanceVariableName::UNDERSCORE_REQUIRED = T.let(T.unsafe(nil), String)
+
+# Makes sure that all methods use the configured style,
+# snake_case or camelCase, for their names.
+#
+# This cop has `AllowedPatterns` configuration option.
+#
+#   Naming/MethodName:
+#     AllowedPatterns:
+#       - '\AonSelectionBulkChange\z'
+#       - '\AonSelectionCleared\z'
+#
+# Method names matching patterns are always allowed.
+#
+# @example EnforcedStyle: snake_case (default)
+#   # bad
+#   def fooBar; end
+#
+#   # good
+#   def foo_bar; end
+# @example EnforcedStyle: camelCase
+#   # bad
+#   def foo_bar; end
+#
+#   # good
+#   def fooBar; end
+#
+# source://rubocop//lib/rubocop/cop/naming/method_name.rb#31
+class RuboCop::Cop::Naming::MethodName < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::ConfigurableFormatting
+  include ::RuboCop::Cop::ConfigurableNaming
+  include ::RuboCop::Cop::AllowedPattern
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/naming/method_name.rb#55
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/method_name.rb#55
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/method_name.rb#44
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/method_name.rb#42
+  def str_name(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/naming/method_name.rb#39
+  def sym_name(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/naming/method_name.rb#64
+  def attr_name(name_item); end
+
+  # source://rubocop//lib/rubocop/cop/naming/method_name.rb#75
+  def message(style); end
+
+  # source://rubocop//lib/rubocop/cop/naming/method_name.rb#68
+  def range_position(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/method_name.rb#36
+RuboCop::Cop::Naming::MethodName::MSG = T.let(T.unsafe(nil), String)
+
+# Checks method parameter names for how descriptive they
+# are. It is highly configurable.
+#
+# The `MinNameLength` config option takes an integer. It represents
+# the minimum amount of characters the name must be. Its default is 3.
+# The `AllowNamesEndingInNumbers` config option takes a boolean. When
+# set to false, this cop will register offenses for names ending with
+# numbers. Its default is false. The `AllowedNames` config option
+# takes an array of permitted names that will never register an
+# offense. The `ForbiddenNames` config option takes an array of
+# restricted names that will always register an offense.
+#
+# @example
+#   # bad
+#   def bar(varOne, varTwo)
+#   varOne + varTwo
+#   end
+#
+#   # With `AllowNamesEndingInNumbers` set to false
+#   def foo(num1, num2)
+#   num1 * num2
+#   end
+#
+#   # With `MinNameLength` set to number greater than 1
+#   def baz(a, b, c)
+#   do_stuff(a, b, c)
+#   end
+#
+#   # good
+#   def bar(thud, fred)
+#   thud + fred
+#   end
+#
+#   def foo(speed, distance)
+#   speed * distance
+#   end
+#
+#   def baz(age_a, height_b, gender_c)
+#   do_stuff(age_a, height_b, gender_c)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/naming/method_parameter_name.rb#46
+class RuboCop::Cop::Naming::MethodParameterName < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::UncommunicativeName
+
+  # source://rubocop//lib/rubocop/cop/naming/method_parameter_name.rb#49
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/method_parameter_name.rb#49
+  def on_defs(node); end
+end
+
+# Checks that predicate method names end with a question mark and
+# do not start with a forbidden prefix.
+#
+# A method is determined to be a predicate method if its name starts with
+# one of the prefixes listed in the `NamePrefix` configuration. The list
+# defaults to `is_`, `has_`, and `have_` but may be overridden.
+#
+# Predicate methods must end with a question mark.
+#
+# When `ForbiddenPrefixes` is also set (as it is by default), predicate
+# methods which begin with a forbidden prefix are not allowed, even if
+# they end with a `?`. These methods should be changed to remove the
+# prefix.
+#
+# @example NamePrefix: ['is_', 'has_', 'have_'] (default)
+#   # bad
+#   def is_even(value)
+#   end
+#
+#   # When ForbiddenPrefixes: ['is_', 'has_', 'have_'] (default)
+#   # good
+#   def even?(value)
+#   end
+#
+#   # When ForbiddenPrefixes: []
+#   # good
+#   def is_even?(value)
+#   end
+# @example NamePrefix: ['seems_to_be_']
+#   # bad
+#   def seems_to_be_even(value)
+#   end
+#
+#   # When ForbiddenPrefixes: ['seems_to_be_']
+#   # good
+#   def even?(value)
+#   end
+#
+#   # When ForbiddenPrefixes: []
+#   # good
+#   def seems_to_be_even?(value)
+#   end
+# @example AllowedMethods: ['is_a?'] (default)
+#   # Despite starting with the `is_` prefix, this method is allowed
+#   # good
+#   def is_a?(value)
+#   end
+# @example AllowedMethods: ['is_even?']
+#   # good
+#   def is_even?(value)
+#   end
+# @example MethodDefinitionMacros: ['define_method', 'define_singleton_method'] (default)
+#   # bad
+#   define_method(:is_even) { |value| }
+#
+#   # good
+#   define_method(:even?) { |value| }
+# @example MethodDefinitionMacros: ['def_node_matcher']
+#   # bad
+#   def_node_matcher(:is_even) { |value| }
+#
+#   # good
+#   def_node_matcher(:even?) { |value| }
+#
+# source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#75
+class RuboCop::Cop::Naming::PredicateName < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+
+  # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#79
+  def dynamic_method_define(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#98
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#98
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#85
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#112
+  def validate_config; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#124
+  def allowed_method_name?(method_name, prefix); end
+
+  # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#132
+  def expected_name(method_name, prefix); end
+
+  # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#146
+  def forbidden_prefixes; end
+
+  # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#142
+  def message(method_name, new_name); end
+
+  # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#154
+  def method_definition_macros(macro_name); end
+
+  # source://rubocop//lib/rubocop/cop/naming/predicate_name.rb#150
+  def predicate_prefixes; end
+end
+
+# Makes sure that rescued exceptions variables are named as
+# expected.
+#
+# The `PreferredName` config option takes a `String`. It represents
+# the required name of the variable. Its default is `e`.
+#
+# NOTE: This cop does not consider nested rescues because it cannot
+# guarantee that the variable from the outer rescue is not used within
+# the inner rescue (in which case, changing the inner variable would
+# shadow the outer variable).
+#
+# @example PreferredName: e (default)
+#   # bad
+#   begin
+#   # do something
+#   rescue MyException => exception
+#   # do something
+#   end
+#
+#   # good
+#   begin
+#   # do something
+#   rescue MyException => e
+#   # do something
+#   end
+#
+#   # good
+#   begin
+#   # do something
+#   rescue MyException => _e
+#   # do something
+#   end
+# @example PreferredName: exception
+#   # bad
+#   begin
+#   # do something
+#   rescue MyException => e
+#   # do something
+#   end
+#
+#   # good
+#   begin
+#   # do something
+#   rescue MyException => exception
+#   # do something
+#   end
+#
+#   # good
+#   begin
+#   # do something
+#   rescue MyException => _exception
+#   # do something
+#   end
+#
+# source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#61
+class RuboCop::Cop::Naming::RescuedExceptionsVariableName < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#66
+  def on_resbody(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#96
+  def autocorrect(corrector, node, range, offending_name, preferred_name); end
+
+  # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#117
+  def correct_node(corrector, node, offending_name, preferred_name); end
+
+  # If the exception variable is reassigned, that assignment needs to be corrected.
+  # Further `lvar` nodes will not be corrected though since they now refer to a
+  # different variable.
+  #
+  # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#143
+  def correct_reassignment(corrector, node, offending_name, preferred_name); end
+
+  # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#168
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#91
+  def offense_range(resbody); end
+
+  # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#152
+  def preferred_name(variable_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#174
+  def shadowed_variable_name?(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#161
+  def variable_name(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#106
+  def variable_name_matches?(node, name); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb#64
+RuboCop::Cop::Naming::RescuedExceptionsVariableName::MSG = T.let(T.unsafe(nil), String)
+
+# Makes sure that all variables use the configured style,
+# snake_case or camelCase, for their names.
+#
+# @example EnforcedStyle: snake_case (default)
+#   # bad
+#   fooBar = 1
+#
+#   # good
+#   foo_bar = 1
+# @example EnforcedStyle: camelCase
+#   # bad
+#   foo_bar = 1
+#
+#   # good
+#   fooBar = 1
+# @example AllowedIdentifiers: ['fooBar']
+#   # good (with EnforcedStyle: snake_case)
+#   fooBar = 1
+# @example AllowedPatterns: ['_v\d+\z']
+#   # good (with EnforcedStyle: camelCase)
+#   :release_v1
+#
+# source://rubocop//lib/rubocop/cop/naming/variable_name.rb#31
+class RuboCop::Cop::Naming::VariableName < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedIdentifiers
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::ConfigurableFormatting
+  include ::RuboCop::Cop::ConfigurableNaming
+  include ::RuboCop::Cop::AllowedPattern
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42
+  def on_arg(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42
+  def on_blockarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42
+  def on_cvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42
+  def on_ivasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42
+  def on_kwarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42
+  def on_kwoptarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42
+  def on_kwrestarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42
+  def on_lvar(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42
+  def on_lvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42
+  def on_optarg(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#42
+  def on_restarg(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#38
+  def valid_name?(node, name, given_style = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_name.rb#62
+  def message(style); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/variable_name.rb#36
+RuboCop::Cop::Naming::VariableName::MSG = T.let(T.unsafe(nil), String)
+
+# Makes sure that all numbered variables use the
+# configured style, snake_case, normalcase, or non_integer,
+# for their numbering.
+#
+# Additionally, `CheckMethodNames` and `CheckSymbols` configuration options
+# can be used to specify whether method names and symbols should be checked.
+# Both are enabled by default.
+#
+# @example AllowedPatterns: ['_v\d+\z']
+#   # good
+#   :some_sym_v1
+# @example EnforcedStyle: snake_case
+#   # bad
+#   :some_sym1
+#   variable1 = 1
+#
+#   def some_method1; end
+#
+#   def some_method_1(arg1); end
+#
+#   # good
+#   :some_sym_1
+#   variable_1 = 1
+#
+#   def some_method_1; end
+#
+#   def some_method_1(arg_1); end
+# @example EnforcedStyle: non_integer
+#   # bad
+#   :some_sym1
+#   :some_sym_1
+#
+#   variable1 = 1
+#   variable_1 = 1
+#
+#   def some_method1; end
+#
+#   def some_method_1; end
+#
+#   def some_methodone(arg1); end
+#   def some_methodone(arg_1); end
+#
+#   # good
+#   :some_symone
+#   :some_sym_one
+#
+#   variableone = 1
+#   variable_one = 1
+#
+#   def some_methodone; end
+#
+#   def some_method_one; end
+#
+#   def some_methodone(argone); end
+#   def some_methodone(arg_one); end
+#
+#   # In the following examples, we assume `EnforcedStyle: normalcase` (default).
+# @example CheckMethodNames: true (default)
+#   # bad
+#   def some_method_1; end
+# @example CheckMethodNames: false
+#   # good
+#   def some_method_1; end
+# @example CheckSymbols: true (default)
+#   # bad
+#   :some_sym_1
+# @example CheckSymbols: false
+#   # good
+#   :some_sym_1
+# @example AllowedIdentifiers: [capture3]
+#   # good
+#   expect(Open3).to receive(:capture3)
+# @example EnforcedStyle: normalcase (default)
+#   # bad
+#   :some_sym_1
+#   variable_1 = 1
+#
+#   def some_method_1; end
+#
+#   def some_method1(arg_1); end
+#
+#   # good
+#   :some_sym1
+#   variable1 = 1
+#
+#   def some_method1; end
+#
+#   def some_method1(arg1); end
+#
+# source://rubocop//lib/rubocop/cop/naming/variable_number.rb#103
+class RuboCop::Cop::Naming::VariableNumber < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedIdentifiers
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::ConfigurableFormatting
+  include ::RuboCop::Cop::ConfigurableNumbering
+  include ::RuboCop::Cop::AllowedPattern
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#114
+  def on_arg(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#114
+  def on_cvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#126
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#126
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#114
+  def on_gvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#114
+  def on_ivasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#114
+  def on_lvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#134
+  def on_sym(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#110
+  def valid_name?(node, name, given_style = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/naming/variable_number.rb#143
+  def message(style); end
+end
+
+# source://rubocop//lib/rubocop/cop/naming/variable_number.rb#108
+RuboCop::Cop::Naming::VariableNumber::MSG = T.let(T.unsafe(nil), String)
+
+# Some common code shared between `NegatedIf` and
+# `NegatedWhile` cops.
+#
+# source://rubocop//lib/rubocop/cop/mixin/negative_conditional.rb#7
+module RuboCop::Cop::NegativeConditional
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop//lib/rubocop/cop/mixin/negative_conditional.rb#18
+  def empty_condition?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/negative_conditional.rb#15
+  def single_negative?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/negative_conditional.rb#20
+  def check_negative_conditional(node, message:, &block); end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/negative_conditional.rb#10
+RuboCop::Cop::NegativeConditional::MSG = T.let(T.unsafe(nil), String)
+
+# This module provides a list of methods that are:
+# 1. In the NilClass by default
+# 2. Added to NilClass by explicitly requiring any standard libraries
+# 3. Cop's configuration parameter AllowedMethods.
+#
+# source://rubocop//lib/rubocop/cop/mixin/nil_methods.rb#9
+module RuboCop::Cop::NilMethods
+  include ::RuboCop::Cop::AllowedMethods
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/nil_methods.rb#14
+  def nil_methods; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/nil_methods.rb#18
+  def other_stdlib_methods; end
+end
+
+# An offense represents a style violation detected by RuboCop.
+#
+# source://rubocop//lib/rubocop/cop/offense.rb#6
+class RuboCop::Cop::Offense
+  include ::Comparable
+
+  # @api private
+  # @return [Offense] a new instance of Offense
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#84
+  def initialize(severity, location, message, cop_name, status = T.unsafe(nil), corrector = T.unsafe(nil)); end
+
+  # Returns `-1`, `0`, or `+1`
+  # if this offense is less than, equal to, or greater than `other`.
+  #
+  # @api public
+  # @return [Integer] comparison result
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#230
+  def <=>(other); end
+
+  # @api public
+  # @return [Boolean] returns `true` if two offenses contain same attributes
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#211
+  def ==(other); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#160
+  def column; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#170
+  def column_length; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#194
+  def column_range; end
+
+  # @api public
+  # @example
+  #   'LineLength'
+  # @return [String] a cop class name without department.
+  #   i.e. type of the violation.
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#51
+  def cop_name; end
+
+  # @api public
+  # @return [Boolean] whether this offense can be automatically corrected via autocorrect.
+  #   This includes todo comments, for example when requested with `--disable-uncorrectable`.
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#102
+  def correctable?; end
+
+  # @api public
+  # @return [Boolean] whether this offense is automatically corrected via
+  #   autocorrect or a todo.
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#113
+  def corrected?; end
+
+  # @api public
+  # @return [Boolean] whether this offense is automatically disabled via a todo.
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#123
+  def corrected_with_todo?; end
+
+  # @api public
+  # @return [Corrector | nil] the autocorrection for this offense, or `nil` when not available
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#62
+  def corrector; end
+
+  # @api public
+  # @return [Boolean] whether this offense was locally disabled with a
+  #   disable or todo where it occurred.
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#134
+  def disabled?; end
+
+  # @api public
+  # @return [Boolean] returns `true` if two offenses contain same attributes
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#211
+  def eql?(other); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#179
+  def first_line; end
+
+  # source://rubocop//lib/rubocop/cop/offense.rb#219
+  def hash; end
+
+  # @api public
+  # @return [Parser::Source::Range] the range of the code that is highlighted
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#142
+  def highlighted_area; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#189
+  def last_column; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#184
+  def last_line; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#155
+  def line; end
+
+  # @api public
+  # @return [Parser::Source::Range] the location where the violation is detected.
+  # @see https://www.rubydoc.info/gems/parser/Parser/Source/Range Parser::Source::Range
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#28
+  def location; end
+
+  # @api public
+  # @example
+  #   'Line is too long. [90/80]'
+  # @return [String] human-readable message
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#39
+  def message; end
+
+  # Internally we use column number that start at 0, but when
+  # outputting column numbers, we want them to start at 1. One
+  # reason is that editors, such as Emacs, expect this.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#203
+  def real_column; end
+
+  # @api public
+  # @return [RuboCop::Cop::Severity]
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#17
+  def severity; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#165
+  def source_line; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#54
+  def status; end
+
+  # This is just for debugging purpose.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/offense.rb#148
+  def to_s; end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/offense.rb#10
+RuboCop::Cop::Offense::COMPARISON_ATTRIBUTES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/offense.rb#81
+RuboCop::Cop::Offense::NO_LOCATION = T.let(T.unsafe(nil), RuboCop::Cop::Offense::PseudoSourceRange)
+
+# source://rubocop//lib/rubocop/cop/offense.rb#64
+class RuboCop::Cop::Offense::PseudoSourceRange < ::Struct
+  # Returns the value of attribute begin_pos
+  #
+  # @return [Object] the current value of begin_pos
+  def begin_pos; end
+
+  # Sets the attribute begin_pos
+  #
+  # @param value [Object] the value to set the attribute begin_pos to.
+  # @return [Object] the newly set value
+  def begin_pos=(_); end
+
+  # Returns the value of attribute column
+  #
+  # @return [Object] the current value of column
+  def column; end
+
+  # Sets the attribute column
+  #
+  # @param value [Object] the value to set the attribute column to.
+  # @return [Object] the newly set value
+  def column=(_); end
+
+  # source://rubocop//lib/rubocop/cop/offense.rb#70
+  def column_range; end
+
+  # Returns the value of attribute end_pos
+  #
+  # @return [Object] the current value of end_pos
+  def end_pos; end
+
+  # Sets the attribute end_pos
+  #
+  # @param value [Object] the value to set the attribute end_pos to.
+  # @return [Object] the newly set value
+  def end_pos=(_); end
+
+  # Returns the value of attribute line
+  #
+  # @return [Object] the current value of line
+  def first_line; end
+
+  # Returns the value of attribute column
+  #
+  # @return [Object] the current value of column
+  def last_column; end
+
+  # Returns the value of attribute line
+  #
+  # @return [Object] the current value of line
+  def last_line; end
+
+  # source://rubocop//lib/rubocop/cop/offense.rb#74
+  def length; end
+
+  # Returns the value of attribute line
+  #
+  # @return [Object] the current value of line
+  def line; end
+
+  # Sets the attribute line
+  #
+  # @param value [Object] the value to set the attribute line to.
+  # @return [Object] the newly set value
+  def line=(_); end
+
+  # source://rubocop//lib/rubocop/cop/offense.rb#74
+  def size; end
+
+  # Returns the value of attribute source_line
+  #
+  # @return [Object] the current value of source_line
+  def source_line; end
+
+  # Sets the attribute source_line
+  #
+  # @param value [Object] the value to set the attribute source_line to.
+  # @return [Object] the newly set value
+  def source_line=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# Common functionality for cops checking if and unless expressions.
+#
+# source://rubocop//lib/rubocop/cop/mixin/on_normal_if_unless.rb#6
+module RuboCop::Cop::OnNormalIfUnless
+  # source://rubocop//lib/rubocop/cop/mixin/on_normal_if_unless.rb#7
+  def on_if(node); end
+end
+
+# This autocorrects gem dependency order
+#
+# source://rubocop//lib/rubocop/cop/correctors/ordered_gem_corrector.rb#6
+class RuboCop::Cop::OrderedGemCorrector
+  extend ::RuboCop::Cop::OrderedGemNode
+  extend ::RuboCop::Cop::RangeHelp
+
+  class << self
+    # Returns the value of attribute comments_as_separators.
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/ordered_gem_corrector.rb#11
+    def comments_as_separators; end
+
+    # source://rubocop//lib/rubocop/cop/correctors/ordered_gem_corrector.rb#13
+    def correct(processed_source, node, previous_declaration, comments_as_separators); end
+
+    # Returns the value of attribute processed_source.
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/ordered_gem_corrector.rb#11
+    def processed_source; end
+
+    private
+
+    # source://rubocop//lib/rubocop/cop/correctors/ordered_gem_corrector.rb#26
+    def declaration_with_comment(node); end
+  end
+end
+
+# Common functionality for Bundler/OrderedGems and
+# Gemspec/OrderedDependencies.
+#
+# source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#7
+module RuboCop::Cop::OrderedGemNode
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#23
+  def case_insensitive_out_of_order?(string_a, string_b); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#27
+  def consecutive_lines(previous, current); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#55
+  def find_gem_name(gem_node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#18
+  def gem_canonical_name(name); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#49
+  def gem_name(declaration_node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#10
+  def get_source_range(node, comments_as_separators); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#32
+  def register_offense(previous, current); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/ordered_gem_node.rb#61
+  def treat_comments_as_separators; end
+end
+
+# Common functionality for handling parentheses.
+#
+# source://rubocop//lib/rubocop/cop/mixin/parentheses.rb#6
+module RuboCop::Cop::Parentheses
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/parentheses.rb#9
+  def parens_required?(node); end
+end
+
+# This autocorrects parentheses
+#
+# source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#6
+class RuboCop::Cop::ParenthesesCorrector
+  extend ::RuboCop::Cop::RangeHelp
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#12
+    def correct(corrector, node); end
+
+    private
+
+    # Add a comma back after the heredoc identifier
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#74
+    def add_heredoc_comma(corrector, node); end
+
+    # If the node contains a heredoc, remove the comma too
+    # It'll be added back in the right place later
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#64
+    def extend_range_for_heredoc(node, range); end
+
+    # If removing parentheses leaves a comma on its own line, remove all the whitespace
+    # preceding it to prevent a syntax error.
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#41
+    def handle_orphaned_comma(corrector, node); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#80
+    def heredoc?(node); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#28
+    def next_char_is_question_mark?(node); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#32
+    def only_closing_paren_before_comma?(node); end
+
+    # Get a range for the closing parenthesis and all whitespace to the left of it
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#51
+    def parens_range(node); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/parentheses_corrector.rb#24
+    def ternary_condition?(node); end
+  end
+end
+
+# Common functionality for handling percent arrays.
+#
+# source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#6
+module RuboCop::Cop::PercentArray
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#26
+  def allowed_bracket_array?(node); end
+
+  # @param node [RuboCop::AST::ArrayNode]
+  # @param elements [Array<String>]
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#83
+  def build_bracketed_array_with_appropriate_whitespace(elements:, node:); end
+
+  # @param preferred_array_code [String]
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#56
+  def build_message_for_bracketed_array(preferred_array_code); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#67
+  def check_bracketed_array(node, literal_prefix); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#36
+  def check_percent_array(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#31
+  def comments_in_array?(node); end
+
+  # Override to determine values that are invalid in a percent array
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#22
+  def invalid_percent_array_contents?(_node); end
+
+  # Ruby does not allow percent arrays in an ambiguous block context.
+  #
+  # @example
+  #
+  #   foo %i[bar baz] { qux }
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#14
+  def invalid_percent_array_context?(node); end
+
+  # Provides whitespace between elements for building a bracketed array.
+  #   %w[  a   b   c    ]
+  #         ^^^
+  #
+  # @param node [RuboCop::AST::ArrayNode]
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#98
+  def whitespace_between(node); end
+
+  # Provides leading whitespace for building a bracketed array.
+  #   %w[  a   b   c    ]
+  #      ^^
+  #
+  # @param node [RuboCop::AST::ArrayNode]
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#111
+  def whitespace_leading(node); end
+
+  # Provides trailing whitespace for building a bracketed array.
+  #   %w[  a   b   c    ]
+  #                 ^^^^
+  #
+  # @param node [RuboCop::AST::ArrayNode]
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/percent_array.rb#120
+  def whitespace_trailing(node); end
+end
+
+# Common functionality for handling percent literals.
+#
+# source://rubocop//lib/rubocop/cop/mixin/percent_literal.rb#6
+module RuboCop::Cop::PercentLiteral
+  include ::RuboCop::Cop::RangeHelp
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/percent_literal.rb#23
+  def begin_source(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/percent_literal.rb#11
+  def percent_literal?(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/percent_literal.rb#17
+  def process(node, *types); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/percent_literal.rb#27
+  def type(node); end
+end
+
+# This autocorrects percent literals
+#
+# source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#6
+class RuboCop::Cop::PercentLiteralCorrector
+  include ::RuboCop::PathUtil
+  include ::RuboCop::Cop::Util
+
+  # @return [PercentLiteralCorrector] a new instance of PercentLiteralCorrector
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#11
+  def initialize(config, preferred_delimiters); end
+
+  # Returns the value of attribute config.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#9
+  def config; end
+
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#16
+  def correct(corrector, node, char); end
+
+  # Returns the value of attribute preferred_delimiters.
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#9
+  def preferred_delimiters; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#46
+  def autocorrect_multiline_words(node, escape, delimiters); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#52
+  def autocorrect_words(node, escape, delimiters); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#34
+  def delimiters_for(type); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#100
+  def end_content(source); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#30
+  def escape_words?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#78
+  def first_line?(node, previous_line_num); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#89
+  def fix_escaped_content(word_node, escape, delimiters); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#69
+  def line_breaks(node, source, previous_line_num, base_line_num, node_index); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#38
+  def new_contents(node, escape, delimiters); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#82
+  def process_lines(node, previous_line_num, base_line_num, source_in_lines); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#58
+  def process_multiline_words(node, escape, delimiters); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#96
+  def substitute_escaped_delimiters(content, delimiters); end
+
+  # source://rubocop//lib/rubocop/cop/correctors/percent_literal_corrector.rb#26
+  def wrap_contents(corrector, node, contents, char, delimiters); end
+end
+
+# Common functionality for checking whether an AST node/token is aligned
+# with something on a preceding or following line
+#
+# source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#7
+module RuboCop::Cop::PrecedingFollowingAlignment
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#93
+  def aligned_assignment?(range, line); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#70
+  def aligned_comment_lines; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#105
+  def aligned_identical?(range, line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#81
+  def aligned_operator?(range, line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#77
+  def aligned_token?(range, line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#34
+  def aligned_with_adjacent_line?(range, predicate); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#52
+  def aligned_with_any_line?(line_ranges, range, indent = T.unsafe(nil), &predicate); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#42
+  def aligned_with_any_line_range?(line_ranges, range, &predicate); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#98
+  def aligned_with_append_operator?(range, line); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#109
+  def aligned_with_assignment(token, line_range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#56
+  def aligned_with_line?(line_nos, range, indent = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#18
+  def aligned_with_operator?(range); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#22
+  def aligned_with_preceding_assignment(token); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#14
+  def aligned_with_something?(range); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#28
+  def aligned_with_subsequent_assignment(token); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#85
+  def aligned_words?(range, line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#10
+  def allow_for_alignment?; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#127
+  def assignment_lines; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#131
+  def assignment_tokens; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#147
+  def relevant_assignment_lines(line_range); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/preceding_following_alignment.rb#174
+  def remove_optarg_equals(asgn_tokens, processed_source); end
+end
+
+# Common functionality for handling percent literal delimiters.
+#
+# source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#6
+class RuboCop::Cop::PreferredDelimiters
+  # @return [PreferredDelimiters] a new instance of PreferredDelimiters
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#11
+  def initialize(type, config, preferred_delimiters); end
+
+  # Returns the value of attribute config.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#7
+  def config; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#17
+  def delimiters; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#7
+  def type; end
+
+  private
+
+  # @raise [ArgumentError]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#23
+  def ensure_valid_preferred_delimiters; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#30
+  def preferred_delimiters; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#45
+  def preferred_delimiters_config; end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/preferred_delimiters.rb#9
+RuboCop::Cop::PreferredDelimiters::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Array)
+
+# This autocorrects punctuation
+#
+# source://rubocop//lib/rubocop/cop/correctors/punctuation_corrector.rb#6
+class RuboCop::Cop::PunctuationCorrector
+  class << self
+    # source://rubocop//lib/rubocop/cop/correctors/punctuation_corrector.rb#12
+    def add_space(corrector, token); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/punctuation_corrector.rb#8
+    def remove_space(corrector, space_before); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/punctuation_corrector.rb#16
+    def swap_comma(corrector, range); end
+  end
+end
+
+module RuboCop::Cop::RSpec; end
+
+class RuboCop::Cop::RSpec::MultipleExpectations < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_expectations.rb#78
+  def aggregate_failures?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_expectations.rb#89
+  def aggregate_failures_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_expectations.rb#86
+  def expect?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11
+  def max=(value); end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_expectations.rb#93
+  def on_block(node); end
+
+  private
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_expectations.rb#109
+  def example_with_aggregate_failures?(example_node); end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_expectations.rb#116
+  def find_aggregate_failures(example_node); end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_expectations.rb#121
+  def find_expectation(node, &block); end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_expectations.rb#132
+  def flag_example(node, expectation_count:); end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_expectations.rb#143
+  def max_expectations; end
+end
+
+class RuboCop::Cop::RSpec::MultipleMemoizedHelpers < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11
+  def max=(value); end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#91
+  def on_block(node); end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#102
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#111
+  def all_helpers(node); end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#141
+  def allow_subject?; end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#109
+  def example_group_memoized_helpers; end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#116
+  def helpers(node); end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#137
+  def max; end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb#127
+  def variable_nodes(node); end
+end
+
+class RuboCop::Cop::RSpec::NestedGroups < ::RuboCop::Cop::RSpec::Base
+  # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11
+  def max=(value); end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/nested_groups.rb#107
+  def on_top_level_group(node); end
+
+  private
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/nested_groups.rb#157
+  def allowed_groups; end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/nested_groups.rb#134
+  def count_up_nesting?(node, example_group); end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/nested_groups.rb#119
+  def find_nested_example_groups(node, nesting: T.unsafe(nil), &block); end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/nested_groups.rb#144
+  def max_nesting; end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/nested_groups.rb#148
+  def max_nesting_config; end
+
+  # source://rubocop-rspec/3.1.0/lib/rubocop/cop/rspec/nested_groups.rb#140
+  def message(nesting); end
+end
+
+# Methods that calculate and return Parser::Source::Ranges
+#
+# source://rubocop//lib/rubocop/cop/mixin/range_help.rb#6
+module RuboCop::Cop::RangeHelp
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#141
+  def add_range(range1, range2); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#82
+  def column_offset_between(base_range, range); end
+
+  # A range containing only the contents of a literal with delimiters (e.g. in
+  # `%i{1 2 3}` this will be the range covering `1 2 3` only).
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#32
+  def contents_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#100
+  def directions(side); end
+
+  # Returns the column attribute of the range, except if the range is on
+  # the first line and there's a byte order mark at the beginning of that
+  # line, in which case 1 is subtracted from the column value. This gives
+  # the column as it appears when viewing the file in an editor.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#92
+  def effective_column(range); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#109
+  def final_pos(src, pos, increment, continuations, newlines, whitespace); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#117
+  def move_pos(src, pos, step, condition, regexp); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#123
+  def move_pos_str(src, pos, step, condition, needle); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#36
+  def range_between(start_pos, end_pos); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#73
+  def range_by_whole_lines(range, include_final_newline: T.unsafe(nil), buffer: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#134
+  def range_with_comments(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#130
+  def range_with_comments_and_lines(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#40
+  def range_with_surrounding_comma(range, side = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#55
+  def range_with_surrounding_space(range_positional = T.unsafe(nil), range: T.unsafe(nil), side: T.unsafe(nil), newlines: T.unsafe(nil), whitespace: T.unsafe(nil), continuations: T.unsafe(nil), buffer: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/range_help.rb#11
+  def source_range(source_buffer, line_number, column, length = T.unsafe(nil)); end
+end
+
+# The Unicode codepoint
+#
+# source://rubocop//lib/rubocop/cop/mixin/range_help.rb#9
+RuboCop::Cop::RangeHelp::BYTE_ORDER_MARK = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop//lib/rubocop/cop/mixin/range_help.rb#54
+module RuboCop::Cop::RangeHelp::NOT_GIVEN; end
+
+# Common functionality for handling Rational literals.
+#
+# source://rubocop//lib/rubocop/cop/mixin/rational_literal.rb#6
+module RuboCop::Cop::RationalLiteral
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop//lib/rubocop/cop/mixin/rational_literal.rb#12
+  def rational_literal?(param0 = T.unsafe(nil)); end
+end
+
+# Registry that tracks all cops by their badge and department.
+#
+# source://rubocop//lib/rubocop/cop/registry.rb#19
+class RuboCop::Cop::Registry
+  include ::Enumerable
+
+  # @return [Registry] a new instance of Registry
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#51
+  def initialize(cops = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#232
+  def ==(other); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#97
+  def contains_cop_matching?(names); end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#179
+  def cops; end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#224
+  def cops_for_department(department); end
+
+  # @return [Boolean] Checks if given name is department
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#93
+  def department?(name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#147
+  def department_missing?(badge, name); end
+
+  # @return [Array<Symbol>] list of departments for current cops.
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#72
+  def departments; end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#193
+  def disabled(config); end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#67
+  def dismiss(cop); end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#247
+  def each(&block); end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#189
+  def enabled(config); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#197
+  def enabled?(cop, config); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#213
+  def enabled_pending_cop?(cop_cfg, config); end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#63
+  def enlist(cop); end
+
+  # @param cop_name [String]
+  # @return [Class, nil]
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#253
+  def find_by_cop_name(cop_name); end
+
+  # When a cop name is given returns a single-element array with the cop class.
+  # When a department name is given returns an array with all the cop classes
+  # for that department.
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#260
+  def find_cops_by_directive(directive); end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#265
+  def freeze; end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#184
+  def length; end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#220
+  def names; end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#228
+  def names_for_department(department); end
+
+  # Returns the value of attribute options.
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#49
+  def options; end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#151
+  def print_warning(name, path); end
+
+  # Convert a user provided cop name into a properly namespaced name
+  #
+  # @example gives back a correctly qualified cop name
+  #
+  #   registry = RuboCop::Cop::Registry
+  #   registry.qualified_cop_name('Layout/EndOfLine', '') # => 'Layout/EndOfLine'
+  # @example fixes incorrect namespaces
+  #
+  #   registry = RuboCop::Cop::Registry
+  #   registry.qualified_cop_name('Lint/EndOfLine', '') # => 'Layout/EndOfLine'
+  # @example namespaces bare cop identifiers
+  #
+  #   registry = RuboCop::Cop::Registry
+  #   registry.qualified_cop_name('EndOfLine', '') # => 'Layout/EndOfLine'
+  # @example passes back unrecognized cop names
+  #
+  #   registry = RuboCop::Cop::Registry
+  #   registry.qualified_cop_name('NotACop', '') # => 'NotACop'
+  # @note Emits a warning if the provided name has an incorrect namespace
+  # @param name [String] Cop name extracted from config
+  # @param path [String, nil] Path of file that `name` was extracted from
+  # @param warn [Boolean] Print a warning if no department given for `name`
+  # @raise [AmbiguousCopName] if a bare identifier with two possible namespaces is provided
+  # @return [String] Qualified cop name
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#133
+  def qualified_cop_name(name, path, warn: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#166
+  def qualify_badge(badge); end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#243
+  def select(&block); end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#236
+  def sort!; end
+
+  # @return [Hash{String => Array<Class>}]
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#174
+  def to_h; end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#159
+  def unqualified_cop_names; end
+
+  # @return [Registry] Cops for that specific department.
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#78
+  def with_department(department); end
+
+  # @return [Registry] Cops not for a specific department.
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#84
+  def without_department(department); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#283
+  def clear_enrollment_queue; end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#279
+  def initialize_copy(reg); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/registry.rb#309
+  def registered?(badge); end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#299
+  def resolve_badge(given_badge, real_badge, source_path); end
+
+  # source://rubocop//lib/rubocop/cop/registry.rb#295
+  def with(cops); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/registry.rb#22
+    def all; end
+
+    # Returns the value of attribute global.
+    #
+    # source://rubocop//lib/rubocop/cop/registry.rb#274
+    def global; end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/registry.rb#44
+    def qualified_cop?(name); end
+
+    # source://rubocop//lib/rubocop/cop/registry.rb#26
+    def qualified_cop_name(name, origin); end
+
+    # source://rubocop//lib/rubocop/cop/registry.rb#40
+    def reset!; end
+
+    # Changes momentarily the global registry
+    # Intended for testing purposes
+    #
+    # source://rubocop//lib/rubocop/cop/registry.rb#32
+    def with_temporary_global(temp_global = T.unsafe(nil)); end
+  end
+end
+
+# Ensure a require statement is present for a standard library determined
+# by variable library_name
+#
+# source://rubocop//lib/rubocop/cop/mixin/require_library.rb#7
+module RuboCop::Cop::RequireLibrary
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop//lib/rubocop/cop/mixin/require_library.rb#12
+  def ensure_required(corrector, node, library_name); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/require_library.rb#33
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/require_library.rb#24
+  def remove_subsequent_requires(corrector, node, library_name); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/require_library.rb#51
+  def require_any_library?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/require_library.rb#56
+  def require_library_name?(param0 = T.unsafe(nil), param1); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/require_library.rb#44
+  def on_new_investigation; end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/require_library.rb#10
+RuboCop::Cop::RequireLibrary::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# This class ensures a require statement is present for a standard library
+# determined by the variable library_name
+#
+# source://rubocop//lib/rubocop/cop/correctors/require_library_corrector.rb#7
+class RuboCop::Cop::RequireLibraryCorrector
+  extend ::RuboCop::Cop::RangeHelp
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/correctors/require_library_corrector.rb#11
+    def correct(corrector, node, library_name); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/require_library_corrector.rb#17
+    def require_statement(library_name); end
+  end
+end
+
+# Common functionality for checking `rescue` nodes.
+#
+# source://rubocop//lib/rubocop/cop/mixin/rescue_node.rb#6
+module RuboCop::Cop::RescueNode
+  # source://rubocop//lib/rubocop/cop/mixin/rescue_node.rb#7
+  def modifier_locations; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/rescue_node.rb#13
+  def rescue_modifier?(node); end
+
+  # @deprecated Use ResbodyNode#exceptions instead
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/rescue_node.rb#20
+  def rescued_exceptions(resbody); end
+end
+
+# Common functionality for safe assignment. By safe assignment we mean
+# putting parentheses around an assignment to indicate "I know I'm using an
+# assignment as a condition. It's not a mistake."
+#
+# source://rubocop//lib/rubocop/cop/mixin/safe_assignment.rb#8
+module RuboCop::Cop::SafeAssignment
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop//lib/rubocop/cop/mixin/safe_assignment.rb#14
+  def empty_condition?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/safe_assignment.rb#20
+  def safe_assignment?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/safe_assignment.rb#17
+  def setter_method?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/safe_assignment.rb#22
+  def safe_assignment_allowed?; end
+end
+
+# source://rubocop//lib/rubocop/cop/security/compound_hash.rb#5
+module RuboCop::Cop::Security; end
+
+# Checks for implementations of the `hash` method which combine
+# values using custom logic instead of delegating to `Array#hash`.
+#
+# Manually combining hashes is error prone and hard to follow, especially
+# when there are many values. Poor implementations may also introduce
+# performance or security concerns if they are prone to collisions.
+# Delegating to `Array#hash` is clearer and safer, although it might be slower
+# depending on the use case.
+#
+# @example
+#
+#   # bad
+#   def hash
+#   @foo ^ @bar
+#   end
+#
+#   # good
+#   def hash
+#   [@foo, @bar].hash
+#   end
+#
+# source://rubocop//lib/rubocop/cop/security/compound_hash.rb#30
+class RuboCop::Cop::Security::CompoundHash < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#58
+  def bad_hash_combinator?(param0 = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#75
+  def contained_in_hash_method?(node, &block); end
+
+  # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#42
+  def dynamic_hash_method_definition?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#37
+  def hash_method_definition?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#63
+  def monuple_hash?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#87
+  def on_op_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#87
+  def on_send(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#81
+  def outer_bad_hash_combinator?(node); end
+
+  # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#68
+  def redundant_hash?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/security/compound_hash.rb#51
+  def static_hash_method_definition?(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/security/compound_hash.rb#31
+RuboCop::Cop::Security::CompoundHash::COMBINATOR_IN_HASH_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/security/compound_hash.rb#32
+RuboCop::Cop::Security::CompoundHash::MONUPLE_HASH_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/security/compound_hash.rb#34
+RuboCop::Cop::Security::CompoundHash::REDUNDANT_HASH_MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the use of `Kernel#eval` and `Binding#eval`.
+#
+# @example
+#
+#   # bad
+#
+#   eval(something)
+#   binding.eval(something)
+#
+# source://rubocop//lib/rubocop/cop/security/eval.rb#14
+class RuboCop::Cop::Security::Eval < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/security/eval.rb#19
+  def eval?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/security/eval.rb#23
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/security/eval.rb#15
+RuboCop::Cop::Security::Eval::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/security/eval.rb#16
+RuboCop::Cop::Security::Eval::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for the first argument to `IO.read`, `IO.binread`, `IO.write`, `IO.binwrite`,
+# `IO.foreach`, and `IO.readlines`.
+#
+# If argument starts with a pipe character (`'|'`) and the receiver is the `IO` class,
+# a subprocess is created in the same way as `Kernel#open`, and its output is returned.
+# `Kernel#open` may allow unintentional command injection, which is the reason these
+# `IO` methods are a security risk.
+# Consider to use `File.read` to disable the behavior of subprocess invocation.
+#
+# @example
+#
+#   # bad
+#   IO.read(path)
+#   IO.read('path')
+#
+#   # good
+#   File.read(path)
+#   File.read('path')
+#   IO.read('| command') # Allow intentional command invocation.
+#
+# source://rubocop//lib/rubocop/cop/security/io_methods.rb#30
+class RuboCop::Cop::Security::IoMethods < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/security/io_methods.rb#36
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/security/io_methods.rb#33
+RuboCop::Cop::Security::IoMethods::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/security/io_methods.rb#34
+RuboCop::Cop::Security::IoMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for the use of JSON class methods which have potential
+# security issues.
+#
+# @example
+#   # bad
+#   JSON.load("{}")
+#   JSON.restore("{}")
+#
+#   # good
+#   JSON.parse("{}")
+#
+# source://rubocop//lib/rubocop/cop/security/json_load.rb#26
+class RuboCop::Cop::Security::JSONLoad < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/security/json_load.rb#33
+  def json_load(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/security/json_load.rb#37
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/security/json_load.rb#29
+RuboCop::Cop::Security::JSONLoad::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/security/json_load.rb#30
+RuboCop::Cop::Security::JSONLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for the use of Marshal class methods which have
+# potential security issues leading to remote code execution when
+# loading from an untrusted source.
+#
+# @example
+#   # bad
+#   Marshal.load("{}")
+#   Marshal.restore("{}")
+#
+#   # good
+#   Marshal.dump("{}")
+#
+#   # okish - deep copy hack
+#   Marshal.load(Marshal.dump({}))
+#
+# source://rubocop//lib/rubocop/cop/security/marshal_load.rb#21
+class RuboCop::Cop::Security::MarshalLoad < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/security/marshal_load.rb#26
+  def marshal_load(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/security/marshal_load.rb#31
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/security/marshal_load.rb#22
+RuboCop::Cop::Security::MarshalLoad::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/security/marshal_load.rb#23
+RuboCop::Cop::Security::MarshalLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for the use of `Kernel#open` and `URI.open` with dynamic
+# data.
+#
+# `Kernel#open` and `URI.open` enable not only file access but also process
+# invocation by prefixing a pipe symbol (e.g., `open("| ls")`).
+# So, it may lead to a serious security risk by using variable input to
+# the argument of `Kernel#open` and `URI.open`. It would be better to use
+# `File.open`, `IO.popen` or `URI.parse#open` explicitly.
+#
+# NOTE: `open` and `URI.open` with literal strings are not flagged by this
+# cop.
+#
+# @example
+#   # bad
+#   open(something)
+#   open("| #{something}")
+#   open("| foo")
+#   URI.open(something)
+#
+#   # good
+#   File.open(something)
+#   IO.popen(something)
+#   URI.parse(something).open
+#
+#   # good (literal strings)
+#   open("foo.text")
+#   URI.open("http://example.com")
+#
+# source://rubocop//lib/rubocop/cop/security/open.rb#37
+class RuboCop::Cop::Security::Open < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/security/open.rb#46
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/security/open.rb#42
+  def open?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/security/open.rb#75
+  def composite_string?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/security/open.rb#83
+  def concatenated_string?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/security/open.rb#79
+  def interpolated_string?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/security/open.rb#57
+  def safe?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/security/open.rb#67
+  def safe_argument?(argument); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/security/open.rb#71
+  def simple_string?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/security/open.rb#38
+RuboCop::Cop::Security::Open::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/security/open.rb#39
+RuboCop::Cop::Security::Open::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for the use of YAML class methods which have
+# potential security issues leading to remote code execution when
+# loading from an untrusted source.
+#
+# NOTE: Ruby 3.1+ (Psych 4) uses `Psych.load` as `Psych.safe_load` by default.
+#
+# @example
+#   # bad
+#   YAML.load("--- !ruby/object:Foo {}") # Psych 3 is unsafe by default
+#
+#   # good
+#   YAML.safe_load("--- !ruby/object:Foo {}", [Foo])                    # Ruby 2.5  (Psych 3)
+#   YAML.safe_load("--- !ruby/object:Foo {}", permitted_classes: [Foo]) # Ruby 3.0- (Psych 3)
+#   YAML.load("--- !ruby/object:Foo {}", permitted_classes: [Foo])      # Ruby 3.1+ (Psych 4)
+#   YAML.dump(foo)
+#
+# source://rubocop//lib/rubocop/cop/security/yaml_load.rb#26
+class RuboCop::Cop::Security::YAMLLoad < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/security/yaml_load.rb#37
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/security/yaml_load.rb#33
+  def yaml_load(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/security/yaml_load.rb#29
+RuboCop::Cop::Security::YAMLLoad::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/security/yaml_load.rb#30
+RuboCop::Cop::Security::YAMLLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Severity class is simple value object about severity
+#
+# source://rubocop//lib/rubocop/cop/severity.rb#6
+class RuboCop::Cop::Severity
+  include ::Comparable
+
+  # @api private
+  # @raise [ArgumentError]
+  # @return [Severity] a new instance of Severity
+  #
+  # source://rubocop//lib/rubocop/cop/severity.rb#30
+  def initialize(name_or_code); end
+
+  # source://rubocop//lib/rubocop/cop/severity.rb#62
+  def <=>(other); end
+
+  # source://rubocop//lib/rubocop/cop/severity.rb#50
+  def ==(other); end
+
+  # source://rubocop//lib/rubocop/cop/severity.rb#42
+  def code; end
+
+  # source://rubocop//lib/rubocop/cop/severity.rb#58
+  def hash; end
+
+  # source://rubocop//lib/rubocop/cop/severity.rb#46
+  def level; end
+
+  # @api public
+  # @return [Symbol] severity.
+  #   any of `:info`, `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
+  #
+  # source://rubocop//lib/rubocop/cop/severity.rb#22
+  def name; end
+
+  # source://rubocop//lib/rubocop/cop/severity.rb#38
+  def to_s; end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/severity.rb#24
+    def name_from_code(code); end
+  end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/severity.rb#12
+RuboCop::Cop::Severity::CODE_TABLE = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/severity.rb#9
+RuboCop::Cop::Severity::NAMES = T.let(T.unsafe(nil), Array)
+
+# Common functionality for cops checking for missing space after
+# punctuation.
+#
+# source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#7
+module RuboCop::Cop::SpaceAfterPunctuation
+  # source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#10
+  def on_new_investigation; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#38
+  def allowed_type?(token); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#20
+  def each_missing_space(tokens); end
+
+  # The normal offset, i.e., the distance from the punctuation
+  # token where a space should be, is 1.
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#49
+  def offset; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#42
+  def space_forbidden_before_rcurly?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#30
+  def space_missing?(token1, token2); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#34
+  def space_required_before?(token); end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/space_after_punctuation.rb#8
+RuboCop::Cop::SpaceAfterPunctuation::MSG = T.let(T.unsafe(nil), String)
+
+# Common functionality for cops checking for space before
+# punctuation.
+#
+# source://rubocop//lib/rubocop/cop/mixin/space_before_punctuation.rb#7
+module RuboCop::Cop::SpaceBeforePunctuation
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/mixin/space_before_punctuation.rb#12
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/space_before_punctuation.rb#22
+  def each_missing_space(tokens); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/space_before_punctuation.rb#34
+  def space_missing?(token1, token2); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/space_before_punctuation.rb#38
+  def space_required_after?(token); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/space_before_punctuation.rb#42
+  def space_required_after_lcurly?; end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/space_before_punctuation.rb#10
+RuboCop::Cop::SpaceBeforePunctuation::MSG = T.let(T.unsafe(nil), String)
+
+# This autocorrects whitespace
+#
+# source://rubocop//lib/rubocop/cop/correctors/space_corrector.rb#6
+class RuboCop::Cop::SpaceCorrector
+  extend ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::SurroundingSpace
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/correctors/space_corrector.rb#36
+    def add_space(processed_source, corrector, left_token, right_token); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/space_corrector.rb#12
+    def empty_corrections(processed_source, corrector, empty_config, left_token, right_token); end
+
+    # Returns the value of attribute processed_source.
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/space_corrector.rb#10
+    def processed_source; end
+
+    # source://rubocop//lib/rubocop/cop/correctors/space_corrector.rb#24
+    def remove_space(processed_source, corrector, left_token, right_token); end
+  end
+end
+
+# Common functionality for modifier cops.
+#
+# source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#6
+module RuboCop::Cop::StatementModifier
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::LineLengthHelp
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#80
+  def code_after(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#104
+  def comment_disables_cop?(comment); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#72
+  def first_line_comment(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#57
+  def if_body_source(if_body); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#43
+  def length_in_modifier_form(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#98
+  def max_line_length; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#66
+  def method_source(if_body); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#37
+  def modifier_fits_on_single_line?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#26
+  def non_eligible_body?(body); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#33
+  def non_eligible_condition?(condition); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#19
+  def non_eligible_node?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#86
+  def parenthesize?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#11
+  def single_line_as_modifier?(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/statement_modifier.rb#50
+  def to_modifier_form(node); end
+end
+
+# Classes that include this module just implement functions to determine
+# what is an offense and how to do autocorrection. They get help with
+# adding offenses for the faulty string nodes, and with filtering out
+# nodes.
+#
+# source://rubocop//lib/rubocop/cop/mixin/string_help.rb#9
+module RuboCop::Cop::StringHelp
+  # source://rubocop//lib/rubocop/cop/mixin/string_help.rb#26
+  def on_regexp(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/string_help.rb#10
+  def on_str(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/string_help.rb#32
+  def inside_interpolation?(node); end
+end
+
+# This autocorrects string literals
+#
+# source://rubocop//lib/rubocop/cop/correctors/string_literal_corrector.rb#6
+class RuboCop::Cop::StringLiteralCorrector
+  extend ::RuboCop::PathUtil
+  extend ::RuboCop::Cop::Util
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/correctors/string_literal_corrector.rb#10
+    def correct(corrector, node, style); end
+  end
+end
+
+# Common functionality for cops checking single/double quotes.
+#
+# source://rubocop//lib/rubocop/cop/mixin/string_literals_help.rb#6
+module RuboCop::Cop::StringLiteralsHelp
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/string_literals_help.rb#24
+  def enforce_double_quotes?; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/string_literals_help.rb#20
+  def preferred_string_literal; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/string_literals_help.rb#28
+  def string_literals_config; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/string_literals_help.rb#9
+  def wrong_quotes?(src_or_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#5
+module RuboCop::Cop::Style; end
+
+# Access modifiers should be declared to apply to a group of methods
+# or inline before each method, depending on configuration.
+# EnforcedStyle config covers only method definitions.
+# Applications of visibility methods to symbols can be controlled
+# using AllowModifiersOnSymbols config.
+# Also, the visibility of `attr*` methods can be controlled using
+# AllowModifiersOnAttrs config.
+#
+# In Ruby 3.0, `attr*` methods now return an array of defined method names
+# as symbols. So we can write the modifier and `attr*` in inline style.
+# AllowModifiersOnAttrs config allows `attr*` methods to be written in
+# inline style without modifying applications that have been maintained
+# for a long time in group style. Furthermore, developers who are not very
+# familiar with Ruby may know that the modifier applies to `def`, but they
+# may not know that it also applies to `attr*` methods. It would be easier
+# to understand if we could write `attr*` methods in inline style.
+#
+# @example EnforcedStyle: group (default)
+#   # bad
+#   class Foo
+#
+#   private def bar; end
+#   private def baz; end
+#
+#   end
+#
+#   # good
+#   class Foo
+#
+#   private
+#
+#   def bar; end
+#   def baz; end
+#
+#   end
+# @example EnforcedStyle: inline
+#   # bad
+#   class Foo
+#
+#   private
+#
+#   def bar; end
+#   def baz; end
+#
+#   end
+#
+#   # good
+#   class Foo
+#
+#   private def bar; end
+#   private def baz; end
+#
+#   end
+# @example AllowModifiersOnSymbols: true (default)
+#   # good
+#   class Foo
+#
+#   private :bar, :baz
+#   private *%i[qux quux]
+#   private *METHOD_NAMES
+#
+#   end
+# @example AllowModifiersOnSymbols: false
+#   # bad
+#   class Foo
+#
+#   private :bar, :baz
+#   private *%i[qux quux]
+#   private *METHOD_NAMES
+#
+#   end
+# @example AllowModifiersOnAttrs: true (default)
+#   # good
+#   class Foo
+#
+#   public attr_reader :bar
+#   protected attr_writer :baz
+#   private attr_accessor :qux
+#   private attr :quux
+#
+#   def public_method; end
+#
+#   private
+#
+#   def private_method; end
+#
+#   end
+# @example AllowModifiersOnAttrs: false
+#   # bad
+#   class Foo
+#
+#   public attr_reader :bar
+#   protected attr_writer :baz
+#   private attr_accessor :qux
+#   private attr :quux
+#
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#113
+class RuboCop::Cop::Style::AccessModifierDeclarations < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#141
+  def access_modifier_with_attr?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#134
+  def access_modifier_with_symbol?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#146
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#205
+  def access_modifier_is_inlined?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#209
+  def access_modifier_is_not_inlined?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#187
+  def allow_modifiers_on_attrs?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#183
+  def allow_modifiers_on_symbols?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#164
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#279
+  def def_source(node, def_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#240
+  def find_argument_less_modifier_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#229
+  def find_corresponding_def_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#197
+  def group_style?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#201
+  def inline_style?; end
+
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#271
+  def insert_inline_modifier(corrector, node, modifier_name); end
+
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#219
+  def message(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#191
+  def offense?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#179
+  def percent_symbol_array?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#275
+  def remove_node(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#254
+  def replace_def(corrector, node, def_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#213
+  def right_siblings_same_inline_method?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#248
+  def select_grouped_def_nodes(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#131
+RuboCop::Cop::Style::AccessModifierDeclarations::ALLOWED_NODE_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#119
+RuboCop::Cop::Style::AccessModifierDeclarations::GROUP_STYLE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#124
+RuboCop::Cop::Style::AccessModifierDeclarations::INLINE_STYLE_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/access_modifier_declarations.rb#129
+RuboCop::Cop::Style::AccessModifierDeclarations::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for grouping of accessors in `class` and `module` bodies.
+# By default it enforces accessors to be placed in grouped declarations,
+# but it can be configured to enforce separating them in multiple declarations.
+#
+# NOTE: If there is a method call before the accessor method it is always allowed
+# as it might be intended like Sorbet.
+#
+# NOTE: If there is a RBS::Inline annotation comment just after the accessor method
+# it is always allowed.
+#
+# @example EnforcedStyle: grouped (default)
+#   # bad
+#   class Foo
+#   attr_reader :bar
+#   attr_reader :bax
+#   attr_reader :baz
+#   end
+#
+#   # good
+#   class Foo
+#   attr_reader :bar, :bax, :baz
+#   end
+#
+#   # good
+#   class Foo
+#   # may be intended comment for bar.
+#   attr_reader :bar
+#
+#   sig { returns(String) }
+#   attr_reader :bax
+#
+#   may_be_intended_annotation :baz
+#   attr_reader :baz
+#   end
+# @example EnforcedStyle: separated
+#   # bad
+#   class Foo
+#   attr_reader :bar, :baz
+#   end
+#
+#   # good
+#   class Foo
+#   attr_reader :bar
+#   attr_reader :baz
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#53
+class RuboCop::Cop::Style::AccessorGrouping < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::VisibilityHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#62
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#62
+  def on_module(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#62
+  def on_sclass(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#85
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#74
+  def check(send_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#122
+  def class_send_elements(class_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#165
+  def group_accessors(node, accessors); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#99
+  def groupable_accessor?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#142
+  def groupable_sibling_accessors(send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#134
+  def grouped_style?; end
+
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#151
+  def message(send_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#156
+  def preferred_accessors(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#94
+  def previous_line_comment?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#171
+  def separate_accessors(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#138
+  def separated_style?; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#59
+RuboCop::Cop::Style::AccessorGrouping::GROUPED_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/accessor_grouping.rb#60
+RuboCop::Cop::Style::AccessorGrouping::SEPARATED_MSG = T.let(T.unsafe(nil), String)
+
+# Enforces the use of either `#alias` or `#alias_method`
+# depending on configuration.
+# It also flags uses of `alias :symbol` rather than `alias bareword`.
+#
+# However, it will always enforce `method_alias` when used `alias`
+# in an instance method definition and in a singleton method definition.
+# If used in a block, always enforce `alias_method`
+# unless it is an `instance_eval` block.
+#
+# @example EnforcedStyle: prefer_alias (default)
+#   # bad
+#   alias_method :bar, :foo
+#   alias :bar :foo
+#
+#   # good
+#   alias bar foo
+# @example EnforcedStyle: prefer_alias_method
+#   # bad
+#   alias :bar :foo
+#   alias bar foo
+#
+#   # good
+#   alias_method :bar, :foo
+#
+# source://rubocop//lib/rubocop/cop/style/alias.rb#31
+class RuboCop::Cop::Style::Alias < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/alias.rb#52
+  def on_alias(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/alias.rb#41
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/alias.rb#86
+  def add_offense_for_args(node, &block); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/alias.rb#76
+  def alias_keyword_possible?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/alias.rb#80
+  def alias_method_possible?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/alias.rb#66
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/alias.rb#125
+  def bareword?(sym_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/alias.rb#129
+  def correct_alias_method_to_alias(corrector, send_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/alias.rb#136
+  def correct_alias_to_alias_method(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/alias.rb#143
+  def correct_alias_with_symbol_args(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/alias.rb#148
+  def identifier(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/alias.rb#114
+  def lexical_scope_type(node); end
+
+  # In this expression, will `self` be the same as the innermost enclosing
+  # class or module block (:lexical)? Or will it be something else
+  # (:dynamic)? If we're in an instance_eval block, return that.
+  #
+  # source://rubocop//lib/rubocop/cop/style/alias.rb#97
+  def scope_type(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/alias.rb#35
+RuboCop::Cop::Style::Alias::MSG_ALIAS = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/alias.rb#36
+RuboCop::Cop::Style::Alias::MSG_ALIAS_METHOD = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/alias.rb#37
+RuboCop::Cop::Style::Alias::MSG_SYMBOL_ARGS = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/alias.rb#39
+RuboCop::Cop::Style::Alias::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for uses of `and` and `or`, and suggests using `&&` and
+# `||` instead. It can be configured to check only in conditions or in
+# all contexts.
+#
+# @example EnforcedStyle: conditionals (default)
+#   # bad
+#   if foo and bar
+#   end
+#
+#   # good
+#   foo.save && return
+#
+#   # good
+#   foo.save and return
+#
+#   # good
+#   if foo && bar
+#   end
+# @example EnforcedStyle: always
+#   # bad
+#   foo.save and return
+#
+#   # bad
+#   if foo and bar
+#   end
+#
+#   # good
+#   foo.save && return
+#
+#   # good
+#   if foo && bar
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/and_or.rb#44
+class RuboCop::Cop::Style::AndOr < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#51
+  def on_and(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#56
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#51
+  def on_or(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#56
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#56
+  def on_until_post(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#56
+  def on_while(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#56
+  def on_while_post(node); end
+
+  private
+
+  # ! is a special case:
+  # 'x and !obj.method arg' can be autocorrected if we
+  # recurse down a level and add parens to 'obj.method arg'
+  # however, 'not x' also parses as (send x :!)
+  #
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#117
+  def correct_not(node, receiver, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#129
+  def correct_other(node, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#95
+  def correct_send(node, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#108
+  def correct_setter(node, corrector); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#143
+  def correctable_send?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#135
+  def keep_operator_precedence(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#91
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#85
+  def on_conditionals(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#66
+  def process_logical_operator(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/and_or.rb#147
+  def whitespace_before_arg(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/and_or.rb#49
+RuboCop::Cop::Style::AndOr::MSG = T.let(T.unsafe(nil), String)
+
+# In Ruby 2.7, arguments forwarding has been added.
+#
+# This cop identifies places where `do_something(*args, &block)`
+# can be replaced by `do_something(...)`.
+#
+# In Ruby 3.1, anonymous block forwarding has been added.
+#
+# This cop identifies places where `do_something(&block)` can be replaced
+# by `do_something(&)`; if desired, this functionality can be disabled
+# by setting `UseAnonymousForwarding: false`.
+#
+# In Ruby 3.2, anonymous args/kwargs forwarding has been added.
+#
+# This cop also identifies places where `use_args(*args)`/`use_kwargs(**kwargs)` can be
+# replaced by `use_args(*)`/`use_kwargs(**)`; if desired, this functionality can be disabled
+# by setting `UseAnonymousForwarding: false`.
+#
+# And this cop has `RedundantRestArgumentNames`, `RedundantKeywordRestArgumentNames`,
+# and `RedundantBlockArgumentNames` options. This configuration is a list of redundant names
+# that are sufficient for anonymizing meaningless naming.
+#
+# Meaningless names that are commonly used can be anonymized by default:
+# e.g., `*args`, `**options`, `&block`, and so on.
+#
+# Names not on this list are likely to be meaningful and are allowed by default.
+#
+# This cop handles not only method forwarding but also forwarding to `super`.
+#
+# @example RedundantBlockArgumentNames: ['blk', 'block', 'proc'] (default)
+#   # bad - But it is good with `EnforcedStyle: explicit` set for `Naming/BlockForwarding`.
+#   def foo(&block)
+#   bar(&block)
+#   end
+#
+#   # good
+#   def foo(&)
+#   bar(&)
+#   end
+# @example UseAnonymousForwarding: true (default, only relevant for Ruby >= 3.2)
+#   # bad
+#   def foo(*args, **kwargs, &block)
+#   args_only(*args)
+#   kwargs_only(**kwargs)
+#   block_only(&block)
+#   end
+#
+#   # good
+#   def foo(*, **, &)
+#   args_only(*)
+#   kwargs_only(**)
+#   block_only(&)
+#   end
+# @example UseAnonymousForwarding: false (only relevant for Ruby >= 3.2)
+#   # good
+#   def foo(*args, **kwargs, &block)
+#   args_only(*args)
+#   kwargs_only(**kwargs)
+#   block_only(&block)
+#   end
+# @example AllowOnlyRestArgument: true (default, only relevant for Ruby < 3.2)
+#   # good
+#   def foo(*args)
+#   bar(*args)
+#   end
+#
+#   def foo(**kwargs)
+#   bar(**kwargs)
+#   end
+# @example AllowOnlyRestArgument: false (only relevant for Ruby < 3.2)
+#   # bad
+#   # The following code can replace the arguments with `...`,
+#   # but it will change the behavior. Because `...` forwards block also.
+#   def foo(*args)
+#   bar(*args)
+#   end
+#
+#   def foo(**kwargs)
+#   bar(**kwargs)
+#   end
+# @example RedundantRestArgumentNames: ['args', 'arguments'] (default)
+#   # bad
+#   def foo(*args)
+#   bar(*args)
+#   end
+#
+#   # good
+#   def foo(*)
+#   bar(*)
+#   end
+# @example RedundantKeywordRestArgumentNames: ['kwargs', 'options', 'opts'] (default)
+#   # bad
+#   def foo(**kwargs)
+#   bar(**kwargs)
+#   end
+#
+#   # good
+#   def foo(**)
+#   bar(**)
+#   end
+# @example
+#   # bad
+#   def foo(*args, &block)
+#   bar(*args, &block)
+#   end
+#
+#   # bad
+#   def foo(*args, **kwargs, &block)
+#   bar(*args, **kwargs, &block)
+#   end
+#
+#   # good
+#   def foo(...)
+#   bar(...)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#127
+class RuboCop::Cop::Style::ArgumentsForwarding < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#146
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#146
+  def on_defs(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#188
+  def add_forward_all_offenses(node, send_classifications, forwardable_args); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#366
+  def add_parens_if_missing(node, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#215
+  def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#352
+  def allow_only_rest_arguments?; end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#340
+  def arguments_range(node, first_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#267
+  def classification_and_forwards(def_node, send_node, referenced_lvars, forwardable_args); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#252
+  def classify_send_nodes(def_node, send_nodes, referenced_lvars, forwardable_args); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#542
+  def explicit_block_name?; end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#170
+  def extract_forwardable_args(args); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#242
+  def non_splat_or_block_pass_lvar_references(body); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#182
+  def only_forwards_all?(send_classifications); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#296
+  def outside_block?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#174
+  def redundant_forwardable_named_args(restarg, kwrestarg, blockarg); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#286
+  def redundant_named_arg(arg, config_name, keyword); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#329
+  def register_forward_all_offense(def_or_send, send_or_arguments, rest_or_splat); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#302
+  def register_forward_args_offense(def_arguments_or_send, rest_arg_or_splat); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#318
+  def register_forward_block_arg_offense(add_parens, def_arguments_or_send, block_arg); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#310
+  def register_forward_kwargs_offense(add_parens, def_arguments_or_send, kwrest_arg_or_splat); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#360
+  def send_inside_block?(send_classifications); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#356
+  def use_anonymous_forwarding?; end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#142
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#135
+RuboCop::Cop::Style::ArgumentsForwarding::ADDITIONAL_ARG_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#138
+RuboCop::Cop::Style::ArgumentsForwarding::ARGS_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#140
+RuboCop::Cop::Style::ArgumentsForwarding::BLOCK_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#134
+RuboCop::Cop::Style::ArgumentsForwarding::FORWARDING_LVAR_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#137
+RuboCop::Cop::Style::ArgumentsForwarding::FORWARDING_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#139
+RuboCop::Cop::Style::ArgumentsForwarding::KWARGS_MSG = T.let(T.unsafe(nil), String)
+
+# Classifies send nodes for possible rest/kwrest/all (including block) forwarding.
+#
+# source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#374
+class RuboCop::Cop::Style::ArgumentsForwarding::SendNodeClassifier
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # @return [SendNodeClassifier] a new instance of SendNodeClassifier
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#403
+  def initialize(def_node, send_node, referenced_lvars, forwardable_args, **config); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#431
+  def classification; end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#387
+  def def_all_anonymous_args?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#381
+  def extract_forwarded_kwrest_arg(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#425
+  def forwarded_block_arg; end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#384
+  def forwarded_block_arg?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#419
+  def forwarded_kwrest_arg; end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#413
+  def forwarded_rest_arg; end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#378
+  def forwarded_rest_arg?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#396
+  def send_all_anonymous_args?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#513
+  def additional_kwargs?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#509
+  def additional_kwargs_or_forwarded_kwargs?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#523
+  def allow_offense_for_no_block?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#494
+  def any_arg_referenced?; end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#478
+  def arguments; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#446
+  def can_forward_all?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#517
+  def forward_additional_kwargs?; end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#474
+  def forwarded_rest_and_kwrest_args; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#536
+  def missing_rest_arg_or_kwrest_arg?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#527
+  def no_additional_args?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#502
+  def no_post_splat_args?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#470
+  def offensive_block_forwarding?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#490
+  def referenced_block_arg?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#486
+  def referenced_kwrest_arg?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#482
+  def referenced_rest_arg?; end
+
+  # def foo(a = 41, ...) is a syntax error in 3.0.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#458
+  def ruby_30_or_lower_optarg?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#462
+  def ruby_32_only_anonymous_forwarding?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#466
+  def ruby_32_or_higher_missing_rest_or_kwest?; end
+
+  # source://rubocop//lib/rubocop/cop/style/arguments_forwarding.rb#498
+  def target_ruby_version; end
+end
+
+# Enforces the use of `Array()` instead of explicit `Array` check or `[*var]`.
+#
+# The cop is disabled by default due to safety concerns.
+#
+# @example
+#   # bad
+#   paths = [paths] unless paths.is_a?(Array)
+#   paths.each { |path| do_something(path) }
+#
+#   # bad (always creates a new Array instance)
+#   [*paths].each { |path| do_something(path) }
+#
+#   # good (and a bit more readable)
+#   Array(paths).each { |path| do_something(path) }
+#
+# source://rubocop//lib/rubocop/cop/style/array_coercion.rb#41
+class RuboCop::Cop::Style::ArrayCoercion < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/array_coercion.rb#48
+  def array_splat?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/array_coercion.rb#63
+  def on_array(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/array_coercion.rb#74
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/array_coercion.rb#53
+  def unless_array?(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/array_coercion.rb#45
+RuboCop::Cop::Style::ArrayCoercion::CHECK_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/array_coercion.rb#44
+RuboCop::Cop::Style::ArrayCoercion::SPLAT_MSG = T.let(T.unsafe(nil), String)
+
+# Identifies usages of `arr[0]` and `arr[-1]` and suggests to change
+# them to use `arr.first` and `arr.last` instead.
+#
+# The cop is disabled by default due to safety concerns.
+#
+# @example
+#   # bad
+#   arr[0]
+#   arr[-1]
+#
+#   # good
+#   arr.first
+#   arr.last
+#   arr[0] = 2
+#   arr[0][-2]
+#
+# source://rubocop//lib/rubocop/cop/style/array_first_last.rb#28
+class RuboCop::Cop::Style::ArrayFirstLast < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/array_first_last.rb#35
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/array_first_last.rb#58
+  def brace_method?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/array_first_last.rb#53
+  def innermost_braces_node(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/array_first_last.rb#31
+RuboCop::Cop::Style::ArrayFirstLast::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/array_first_last.rb#32
+RuboCop::Cop::Style::ArrayFirstLast::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# In Ruby 3.1, `Array#intersect?` has been added.
+#
+# This cop identifies places where `(array1 & array2).any?`
+# can be replaced by `array1.intersect?(array2)`.
+#
+# The `array1.intersect?(array2)` method is faster than
+# `(array1 & array2).any?` and is more readable.
+#
+# In cases like the following, compatibility is not ensured,
+# so it will not be detected when using block argument.
+#
+# [source,ruby]
+# ----
+# ([1] & [1,2]).any? { |x| false }    # => false
+# [1].intersect?([1,2]) { |x| false } # => true
+# ----
+#
+# @example
+#   # bad
+#   (array1 & array2).any?
+#   (array1 & array2).empty?
+#
+#   # good
+#   array1.intersect?(array2)
+#   !array1.intersect?(array2)
+# @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+#   # good
+#   (array1 & array2).present?
+#   (array1 & array2).blank?
+# @example AllCops:ActiveSupportExtensionsEnabled: true
+#   # bad
+#   (array1 & array2).present?
+#   (array1 & array2).blank?
+#
+#   # good
+#   array1.intersect?(array2)
+#   !array1.intersect?(array2)
+#
+# source://rubocop//lib/rubocop/cop/style/array_intersect.rb#49
+class RuboCop::Cop::Style::ArrayIntersect < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/array_intersect.rb#65
+  def active_support_bad_intersection_check?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/array_intersect.rb#79
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/array_intersect.rb#56
+  def regular_bad_intersection_check?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/array_intersect.rb#94
+  def bad_intersection_check?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/array_intersect.rb#106
+  def message(receiver, argument, method_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/array_intersect.rb#102
+  def straight?(method_name); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/array_intersect.rb#73
+RuboCop::Cop::Style::ArrayIntersect::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/array_intersect.rb#76
+RuboCop::Cop::Style::ArrayIntersect::NEGATED_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/array_intersect.rb#77
+RuboCop::Cop::Style::ArrayIntersect::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/array_intersect.rb#75
+RuboCop::Cop::Style::ArrayIntersect::STRAIGHT_METHODS = T.let(T.unsafe(nil), Array)
+
+# Checks for uses of "*" as a substitute for _join_.
+#
+# Not all cases can reliably checked, due to Ruby's dynamic
+# types, so we consider only cases when the first argument is an
+# array literal or the second is a string literal.
+#
+# @example
+#
+#   # bad
+#   %w(foo bar baz) * ","
+#
+#   # good
+#   %w(foo bar baz).join(",")
+#
+# source://rubocop//lib/rubocop/cop/style/array_join.rb#20
+class RuboCop::Cop::Style::ArrayJoin < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/array_join.rb#27
+  def join_candidate?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/array_join.rb#29
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/array_join.rb#23
+RuboCop::Cop::Style::ArrayJoin::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/array_join.rb#24
+RuboCop::Cop::Style::ArrayJoin::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/ascii_comments.rb#16
+class RuboCop::Cop::Style::AsciiComments < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/style/ascii_comments.rb#21
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/ascii_comments.rb#51
+  def allowed_non_ascii_chars; end
+
+  # source://rubocop//lib/rubocop/cop/style/ascii_comments.rb#42
+  def first_non_ascii_chars(string); end
+
+  # source://rubocop//lib/rubocop/cop/style/ascii_comments.rb#32
+  def first_offense_range(comment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ascii_comments.rb#46
+  def only_allowed_non_ascii_chars?(string); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/ascii_comments.rb#19
+RuboCop::Cop::Style::AsciiComments::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for uses of Module#attr.
+#
+# @example
+#   # bad - creates a single attribute accessor (deprecated in Ruby 1.9)
+#   attr :something, true
+#   attr :one, :two, :three # behaves as attr_reader
+#
+#   # good
+#   attr_accessor :something
+#   attr_reader :one, :two, :three
+#
+# source://rubocop//lib/rubocop/cop/style/attr.rb#17
+class RuboCop::Cop::Style::Attr < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/attr.rb#74
+  def class_eval?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/attr.rb#24
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/attr.rb#37
+  def allowed_context?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/attr.rb#47
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/attr.rb#43
+  def define_attr_method?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/attr.rb#59
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/attr.rb#63
+  def replacement_method(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/attr.rb#21
+RuboCop::Cop::Style::Attr::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/attr.rb#22
+RuboCop::Cop::Style::Attr::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for cases when you could use a block
+# accepting version of a method that does automatic
+# resource cleanup.
+#
+# @example
+#
+#   # bad
+#   f = File.open('file')
+#
+#   # good
+#   File.open('file') do |f|
+#   # ...
+#   end
+#
+#   # bad
+#   f = Tempfile.open('temp')
+#
+#   # good
+#   Tempfile.open('temp') do |f|
+#   # ...
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/auto_resource_cleanup.rb#27
+class RuboCop::Cop::Style::AutoResourceCleanup < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/style/auto_resource_cleanup.rb#32
+  def file_open_method?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/auto_resource_cleanup.rb#36
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/auto_resource_cleanup.rb#46
+  def cleanup?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/auto_resource_cleanup.rb#28
+RuboCop::Cop::Style::AutoResourceCleanup::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/auto_resource_cleanup.rb#29
+RuboCop::Cop::Style::AutoResourceCleanup::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks if usage of %() or %Q() matches configuration.
+#
+# @example EnforcedStyle: bare_percent (default)
+#   # bad
+#   %Q(He said: "#{greeting}")
+#   %q{She said: 'Hi'}
+#
+#   # good
+#   %(He said: "#{greeting}")
+#   %{She said: 'Hi'}
+# @example EnforcedStyle: percent_q
+#   # bad
+#   %|He said: "#{greeting}"|
+#   %/She said: 'Hi'/
+#
+#   # good
+#   %Q|He said: "#{greeting}"|
+#   %q/She said: 'Hi'/
+#
+# source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#26
+class RuboCop::Cop::Style::BarePercentLiterals < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#32
+  def on_dstr(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#36
+  def on_str(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#63
+  def add_offense_for_wrong_style(node, good, bad); end
+
+  # source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#42
+  def check(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#59
+  def requires_bare_percent?(source); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#55
+  def requires_percent_q?(source); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/bare_percent_literals.rb#30
+RuboCop::Cop::Style::BarePercentLiterals::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for BEGIN blocks.
+#
+# @example
+#   # bad
+#   BEGIN { test }
+#
+# source://rubocop//lib/rubocop/cop/style/begin_block.rb#12
+class RuboCop::Cop::Style::BeginBlock < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/style/begin_block.rb#15
+  def on_preexe(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/begin_block.rb#13
+RuboCop::Cop::Style::BeginBlock::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for places where `attr_reader` and `attr_writer`
+# for the same method can be combined into single `attr_accessor`.
+#
+# @example
+#   # bad
+#   class Foo
+#   attr_reader :bar
+#   attr_writer :bar
+#   end
+#
+#   # good
+#   class Foo
+#   attr_accessor :bar
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#21
+class RuboCop::Cop::Style::BisectedAttrAccessor < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # Each offending macro is captured and registered in `on_class` but correction
+  # happens in `after_class` because a macro might have multiple attributes
+  # rewritten from it
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#55
+  def after_class(class_node); end
+
+  # Each offending macro is captured and registered in `on_class` but correction
+  # happens in `after_class` because a macro might have multiple attributes
+  # rewritten from it
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#55
+  def after_module(class_node); end
+
+  # Each offending macro is captured and registered in `on_class` but correction
+  # happens in `after_class` because a macro might have multiple attributes
+  # rewritten from it
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#55
+  def after_sclass(class_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#33
+  def on_class(class_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#33
+  def on_module(class_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#29
+  def on_new_investigation; end
+
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#33
+  def on_sclass(class_node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#102
+  def correct_reader(corrector, macro, node, range); end
+
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#114
+  def correct_writer(corrector, macro, node, range); end
+
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#91
+  def find_bisection(macros); end
+
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#74
+  def find_macros(class_def); end
+
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#98
+  def register_offense(attr); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor.rb#27
+RuboCop::Cop::Style::BisectedAttrAccessor::MSG = T.let(T.unsafe(nil), String)
+
+# Representation of an `attr_reader`, `attr_writer` or `attr` macro
+# for use by `Style/BisectedAttrAccessor`.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#10
+class RuboCop::Cop::Style::BisectedAttrAccessor::Macro
+  include ::RuboCop::Cop::VisibilityHelp
+
+  # @api private
+  # @return [Macro] a new instance of Macro
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#19
+  def initialize(node); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#49
+  def all_bisected?; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#29
+  def attr_names; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#13
+  def attrs; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#25
+  def bisect(*names); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#33
+  def bisected_names; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#13
+  def bisection; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#13
+  def node; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#41
+  def reader?; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#53
+  def rest; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#37
+  def visibility; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#45
+  def writer?; end
+
+  class << self
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/style/bisected_attr_accessor/macro.rb#15
+    def macro?(node); end
+  end
+end
+
+# Looks for uses of block comments (=begin...=end).
+#
+# @example
+#   # bad
+#   =begin
+#   Multiple lines
+#   of comments...
+#   =end
+#
+#   # good
+#   # Multiple lines
+#   # of comments...
+#
+# source://rubocop//lib/rubocop/cop/style/block_comments.rb#19
+class RuboCop::Cop::Style::BlockComments < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/block_comments.rb#27
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/block_comments.rb#56
+  def eq_end_part(comment, expr); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_comments.rb#48
+  def parts(comment); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/block_comments.rb#24
+RuboCop::Cop::Style::BlockComments::BEGIN_LENGTH = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop//lib/rubocop/cop/style/block_comments.rb#25
+RuboCop::Cop::Style::BlockComments::END_LENGTH = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop//lib/rubocop/cop/style/block_comments.rb#23
+RuboCop::Cop::Style::BlockComments::MSG = T.let(T.unsafe(nil), String)
+
+# Check for uses of braces or do/end around single line or
+# multi-line blocks.
+#
+# Methods that can be either procedural or functional and cannot be
+# categorised from their usage alone is ignored.
+# `lambda`, `proc`, and `it` are their defaults.
+# Additional methods can be added to the `AllowedMethods`.
+#
+# @example AllowedPatterns: ['map']
+#
+#   # good
+#   things.map { |thing|
+#   something = thing.some_method
+#   process(something)
+#   }
+# @example EnforcedStyle: semantic
+#   # Prefer `do...end` over `{...}` for procedural blocks.
+#
+#   # return value is used/assigned
+#   # bad
+#   foo = map do |x|
+#   x
+#   end
+#   puts (map do |x|
+#   x
+#   end)
+#
+#   # return value is not used out of scope
+#   # good
+#   map do |x|
+#   x
+#   end
+#
+#   # Prefer `{...}` over `do...end` for functional blocks.
+#
+#   # return value is not used out of scope
+#   # bad
+#   each { |x|
+#   x
+#   }
+#
+#   # return value is used/assigned
+#   # good
+#   foo = map { |x|
+#   x
+#   }
+#   map { |x|
+#   x
+#   }.inspect
+#
+#   # The AllowBracesOnProceduralOneLiners option is allowed unless the
+#   # EnforcedStyle is set to `semantic`. If so:
+#
+#   # If the AllowBracesOnProceduralOneLiners option is unspecified, or
+#   # set to `false` or any other falsey value, then semantic purity is
+#   # maintained, so one-line procedural blocks must use do-end, not
+#   # braces.
+#
+#   # bad
+#   collection.each { |element| puts element }
+#
+#   # good
+#   collection.each do |element| puts element end
+#
+#   # If the AllowBracesOnProceduralOneLiners option is set to `true`, or
+#   # any other truthy value, then one-line procedural blocks may use
+#   # either style. (There is no setting for requiring braces on them.)
+#
+#   # good
+#   collection.each { |element| puts element }
+#
+#   # also good
+#   collection.each do |element| puts element end
+# @example EnforcedStyle: braces_for_chaining
+#   # bad
+#   words.each do |word|
+#   word.flip.flop
+#   end.join("-")
+#
+#   # good
+#   words.each { |word|
+#   word.flip.flop
+#   }.join("-")
+# @example EnforcedStyle: always_braces
+#   # bad
+#   words.each do |word|
+#   word.flip.flop
+#   end
+#
+#   # good
+#   words.each { |word|
+#   word.flip.flop
+#   }
+# @example BracesRequiredMethods: ['sig']
+#
+#   # Methods listed in the BracesRequiredMethods list, such as 'sig'
+#   # in this example, will require `{...}` braces. This option takes
+#   # precedence over all other configurations except AllowedMethods.
+#
+#   # bad
+#   sig do
+#   params(
+#   foo: string,
+#   ).void
+#   end
+#   def bar(foo)
+#   puts foo
+#   end
+#
+#   # good
+#   sig {
+#   params(
+#   foo: string,
+#   ).void
+#   }
+#   def bar(foo)
+#   puts foo
+#   end
+# @example AllowedMethods: ['lambda', 'proc', 'it' ] (default)
+#
+#   # good
+#   foo = lambda do |x|
+#   puts "Hello, #{x}"
+#   end
+#
+#   foo = lambda do |x|
+#   x * 100
+#   end
+# @example AllowedPatterns: [] (default)
+#
+#   # bad
+#   things.map { |thing|
+#   something = thing.some_method
+#   process(something)
+#   }
+# @example EnforcedStyle: line_count_based (default)
+#   # bad - single line block
+#   items.each do |item| item / 5 end
+#
+#   # good - single line block
+#   items.each { |item| item / 5 }
+#
+#   # bad - multi-line block
+#   things.map { |thing|
+#   something = thing.some_method
+#   process(something)
+#   }
+#
+#   # good - multi-line block
+#   things.map do |thing|
+#   something = thing.some_method
+#   process(something)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#168
+class RuboCop::Cop::Style::BlockDelimiters < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#198
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#198
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#183
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#472
+  def array_or_range?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#212
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#476
+  def begin_required?(block_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#240
+  def braces_for_chaining_message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#413
+  def braces_for_chaining_style?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#252
+  def braces_required_message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#390
+  def braces_required_method?(method_name); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#394
+  def braces_required_methods; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#423
+  def braces_style?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#468
+  def conditional?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#427
+  def correction_would_break_code?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#313
+  def end_of_chain(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#437
+  def functional_block?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#433
+  def functional_method?(method_name); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#330
+  def get_blocks(node, &block); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#398
+  def line_count_based_block_style?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#222
+  def line_count_based_message(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#256
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#304
+  def move_comment_before_block(corrector, comment, block_node, closing_brace); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#445
+  def procedural_method?(method_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#441
+  def procedural_oneliners_may_have_braces?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#349
+  def proper_block_style?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#320
+  def remove_trailing_whitespace(corrector, range, comment); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#267
+  def replace_braces_with_do_end(corrector, loc); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#283
+  def replace_do_end_with_braces(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#362
+  def require_braces?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#370
+  def require_do_end?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#461
+  def return_value_of_scope?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#449
+  def return_value_used?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#402
+  def semantic_block_style?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#230
+  def semantic_message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#377
+  def special_method?(method_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#383
+  def special_method_proper_block_style?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#300
+  def whitespace_after?(range, length = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#296
+  def whitespace_before?(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#326
+  def with_block?(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#179
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#175
+RuboCop::Cop::Style::BlockDelimiters::ALWAYS_BRACES_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/block_delimiters.rb#177
+RuboCop::Cop::Style::BlockDelimiters::BRACES_REQUIRED_MESSAGE = T.let(T.unsafe(nil), String)
+
+# Corrector to correct conditional assignment in `case` statements.
+#
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#604
+class RuboCop::Cop::Style::CaseCorrector
+  extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper
+  extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#609
+    def correct(corrector, cop, node); end
+
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#619
+    def move_assignment_inside_condition(corrector, node); end
+
+    private
+
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#639
+    def extract_branches(case_node); end
+
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#633
+    def extract_tail_branches(node); end
+
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#649
+    def move_branch_inside_condition(corrector, branch, condition, assignment, column); end
+  end
+end
+
+# If `AllowOnSelfClass` option is enabled, the cop will ignore violations when the receiver of
+# the case equality operator is `self.class`. Note intermediate variables are not accepted.
+#
+# @example
+#   # bad
+#   (1..100) === 7
+#   /something/ === some_string
+#
+#   # good
+#   something.is_a?(Array)
+#   (1..100).include?(7)
+#   /something/.match?(some_string)
+# @example AllowOnConstant: false (default)
+#   # bad
+#   Array === something
+# @example AllowOnConstant: true
+#   # good
+#   Array === something
+# @example AllowOnSelfClass: false (default)
+#   # bad
+#   self.class === something
+# @example AllowOnSelfClass: true
+#   # good
+#   self.class === something
+#
+# source://rubocop//lib/rubocop/cop/style/case_equality.rb#40
+class RuboCop::Cop::Style::CaseEquality < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/case_equality.rb#47
+  def case_equality?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_equality.rb#52
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_equality.rb#50
+  def self_class?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/case_equality.rb#90
+  def begin_replacement(lhs, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_equality.rb#96
+  def const_replacement(lhs, rhs); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/case_equality.rb#65
+  def offending_receiver?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_equality.rb#72
+  def replacement(lhs, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_equality.rb#100
+  def send_replacement(lhs, rhs); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/case_equality.rb#43
+RuboCop::Cop::Style::CaseEquality::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/case_equality.rb#44
+RuboCop::Cop::Style::CaseEquality::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Identifies places where `if-elsif` constructions
+# can be replaced with `case-when`.
+#
+# @example MinBranchesCount: 3 (default)
+#   # bad
+#   if status == :active
+#   perform_action
+#   elsif status == :inactive || status == :hibernating
+#   check_timeout
+#   elsif status == :invalid
+#   report_invalid
+#   else
+#   final_action
+#   end
+#
+#   # good
+#   case status
+#   when :active
+#   perform_action
+#   when :inactive, :hibernating
+#   check_timeout
+#   when :invalid
+#   report_invalid
+#   else
+#   final_action
+#   end
+# @example MinBranchesCount: 4
+#   # good
+#   if status == :active
+#   perform_action
+#   elsif status == :inactive || status == :hibernating
+#   check_timeout
+#   elsif status == :invalid
+#   report_invalid
+#   else
+#   final_action
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/case_like_if.rb#50
+class RuboCop::Cop::Style::CaseLikeIf < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::MinBranchesCount
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#57
+  def on_if(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#81
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#231
+  def branch_conditions(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#249
+  def class_reference?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#166
+  def collect_conditions(node, target, conditions); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#220
+  def condition_from_binary_op(lhs, rhs, target); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#202
+  def condition_from_equality_node(node, target); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#213
+  def condition_from_include_or_cover_node(node, target); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#208
+  def condition_from_match_node(node, target); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#185
+  def condition_from_send_node(node, target); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#240
+  def const_reference?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#258
+  def correction_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#253
+  def deparenthesize(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#102
+  def find_target(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#136
+  def find_target_in_equality_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#148
+  def find_target_in_include_or_cover_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#154
+  def find_target_in_match_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#121
+  def find_target_in_send_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#274
+  def regexp_with_named_captures?(node); end
+
+  # Named captures work with `=~` (if regexp is on lhs) and with `match` (both sides)
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#263
+  def regexp_with_working_captures?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/case_like_if.rb#96
+  def should_check?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/case_like_if.rb#55
+RuboCop::Cop::Style::CaseLikeIf::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for uses of the character literal ?x.
+# Starting with Ruby 1.9 character literals are
+# essentially one-character strings, so this syntax
+# is mostly redundant at this point.
+#
+# ? character literal can be used to express meta and control character.
+# That's a good use case of ? literal so it doesn't count it as an offense.
+#
+# @example
+#   # bad
+#   ?x
+#
+#   # good
+#   'x'
+#
+#   # good - control & meta escapes
+#   ?\C-\M-d
+#   "\C-\M-d" # same as above
+#
+# source://rubocop//lib/rubocop/cop/style/character_literal.rb#24
+class RuboCop::Cop::Style::CharacterLiteral < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::StringHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/character_literal.rb#35
+  def autocorrect(corrector, node); end
+
+  # Dummy implementation of method in ConfigurableEnforcedStyle that is
+  # called from StringHelp.
+  #
+  # source://rubocop//lib/rubocop/cop/style/character_literal.rb#53
+  def correct_style_detected; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/character_literal.rb#30
+  def offense?(node); end
+
+  # Dummy implementation of method in ConfigurableEnforcedStyle that is
+  # called from StringHelp.
+  #
+  # source://rubocop//lib/rubocop/cop/style/character_literal.rb#49
+  def opposite_style_detected; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/character_literal.rb#28
+RuboCop::Cop::Style::CharacterLiteral::MSG = T.let(T.unsafe(nil), String)
+
+# Checks the style of children definitions at classes and
+# modules. Basically there are two different styles:
+#
+# The compact style is only forced for classes/modules with one child.
+#
+# @example EnforcedStyle: nested (default)
+#   # good
+#   # have each child on its own line
+#   class Foo
+#   class Bar
+#   end
+#   end
+# @example EnforcedStyle: compact
+#   # good
+#   # combine definitions as much as possible
+#   class Foo::Bar
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#33
+class RuboCop::Cop::Style::ClassAndModuleChildren < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#42
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#48
+  def on_module(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#89
+  def add_trailing_end(corrector, node, padding); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#170
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#159
+  def check_compact_style(node, body); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#151
+  def check_nested_style(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#141
+  def check_style(node, body); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#94
+  def compact_definition(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#115
+  def compact_identifier_name(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#100
+  def compact_node(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#180
+  def compact_node_name?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#105
+  def compact_replacement(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#137
+  def leading_spaces(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#176
+  def needs_compacting?(body); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#62
+  def nest_definition(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#54
+  def nest_or_compact(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#120
+  def remove_end(corrector, body); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#71
+  def replace_namespace_keyword(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#80
+  def split_on_double_colon(corrector, node, padding); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#128
+  def unindent(corrector, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#40
+RuboCop::Cop::Style::ClassAndModuleChildren::COMPACT_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/class_and_module_children.rb#39
+RuboCop::Cop::Style::ClassAndModuleChildren::NESTED_MSG = T.let(T.unsafe(nil), String)
+
+# Enforces consistent use of `Object#is_a?` or `Object#kind_of?`.
+#
+# @example EnforcedStyle: is_a? (default)
+#   # bad
+#   var.kind_of?(Date)
+#   var.kind_of?(Integer)
+#
+#   # good
+#   var.is_a?(Date)
+#   var.is_a?(Integer)
+# @example EnforcedStyle: kind_of?
+#   # bad
+#   var.is_a?(Time)
+#   var.is_a?(String)
+#
+#   # good
+#   var.kind_of?(Time)
+#   var.kind_of?(String)
+#
+# source://rubocop//lib/rubocop/cop/style/class_check.rb#26
+class RuboCop::Cop::Style::ClassCheck < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/class_check.rb#45
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_check.rb#33
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_check.rb#33
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/class_check.rb#30
+RuboCop::Cop::Style::ClassCheck::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/class_check.rb#31
+RuboCop::Cop::Style::ClassCheck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Enforces the use of `Object#instance_of?` instead of class comparison
+# for equality.
+# `==`, `equal?`, and `eql?` custom method definitions are allowed by default.
+# These are customizable with `AllowedMethods` option.
+#
+# @example
+#   # bad
+#   var.class == Date
+#   var.class.equal?(Date)
+#   var.class.eql?(Date)
+#   var.class.name == 'Date'
+#
+#   # good
+#   var.instance_of?(Date)
+# @example AllowedMethods: ['==', 'equal?', 'eql?'] (default)
+#   # good
+#   def ==(other)
+#   self.class == other.class && name == other.name
+#   end
+#
+#   def equal?(other)
+#   self.class.equal?(other.class) && name.equal?(other.name)
+#   end
+#
+#   def eql?(other)
+#   self.class.eql?(other.class) && name.eql?(other.name)
+#   end
+# @example AllowedPatterns: [] (default)
+#   # bad
+#   def eq(other)
+#   self.class.eq(other.class) && name.eq(other.name)
+#   end
+# @example AllowedPatterns: ['eq']
+#   # good
+#   def eq(other)
+#   self.class.eq(other.class) && name.eq(other.name)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#52
+class RuboCop::Cop::Style::ClassEqualityComparison < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#64
+  def class_comparison_candidate?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#70
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#92
+  def class_name(class_node, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#112
+  def class_name_method?(method_name); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#128
+  def offense_range(receiver_node, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#116
+  def require_cbase?(class_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#124
+  def trim_string_quotes(class_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#120
+  def unable_to_determine_type?(class_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#61
+RuboCop::Cop::Style::ClassEqualityComparison::CLASS_NAME_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#58
+RuboCop::Cop::Style::ClassEqualityComparison::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/class_equality_comparison.rb#60
+RuboCop::Cop::Style::ClassEqualityComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for uses of the class/module name instead of
+# self, when defining class/module methods.
+#
+# @example
+#   # bad
+#   class SomeClass
+#   def SomeClass.class_method
+#   # ...
+#   end
+#   end
+#
+#   # good
+#   class SomeClass
+#   def self.class_method
+#   # ...
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/class_methods.rb#23
+class RuboCop::Cop::Style::ClassMethods < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/class_methods.rb#28
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_methods.rb#28
+  def on_module(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/class_methods.rb#41
+  def check_defs(name, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/class_methods.rb#26
+RuboCop::Cop::Style::ClassMethods::MSG = T.let(T.unsafe(nil), String)
+
+# Enforces using `def self.method_name` or `class << self` to define class methods.
+#
+# @example EnforcedStyle: def_self (default)
+#   # bad
+#   class SomeClass
+#   class << self
+#   attr_accessor :class_accessor
+#
+#   def class_method
+#   # ...
+#   end
+#   end
+#   end
+#
+#   # good
+#   class SomeClass
+#   def self.class_method
+#   # ...
+#   end
+#
+#   class << self
+#   attr_accessor :class_accessor
+#   end
+#   end
+#
+#   # good - contains private method
+#   class SomeClass
+#   class << self
+#   attr_accessor :class_accessor
+#
+#   private
+#
+#   def private_class_method
+#   # ...
+#   end
+#   end
+#   end
+# @example EnforcedStyle: self_class
+#   # bad
+#   class SomeClass
+#   def self.class_method
+#   # ...
+#   end
+#   end
+#
+#   # good
+#   class SomeClass
+#   class << self
+#   def class_method
+#   # ...
+#   end
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#61
+class RuboCop::Cop::Style::ClassMethodsDefinitions < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::CommentsHelp
+  include ::RuboCop::Cop::VisibilityHelp
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#81
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#71
+  def on_sclass(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#95
+  def all_methods_public?(sclass_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#115
+  def autocorrect_sclass(node, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#102
+  def def_nodes(sclass_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#91
+  def def_self_style?; end
+
+  # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#141
+  def extract_def_from_sclass(def_node, sclass_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#152
+  def indentation_diff(node1, node2); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#137
+  def sclass_only_has_methods?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#68
+RuboCop::Cop::Style::ClassMethodsDefinitions::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/class_methods_definitions.rb#69
+RuboCop::Cop::Style::ClassMethodsDefinitions::MSG_SCLASS = T.let(T.unsafe(nil), String)
+
+# Checks for uses of class variables. Offenses
+# are signaled only on assignment to class variables to
+# reduce the number of offenses that would be reported.
+#
+# You have to be careful when setting a value for a class
+# variable; if a class has been inherited, changing the
+# value of a class variable also affects the inheriting
+# classes. This means that it's almost always better to
+# use a class instance variable instead.
+#
+# @example
+#   # bad
+#   class A
+#   @@test = 10
+#   end
+#
+#   class A
+#   def self.test(name, value)
+#   class_variable_set("@@#{name}", value)
+#   end
+#   end
+#
+#   class A; end
+#   A.class_variable_set(:@@test, 10)
+#
+#   # good
+#   class A
+#   @test = 10
+#   end
+#
+#   class A
+#   def test
+#   @@test # you can access class variable without offense
+#   end
+#   end
+#
+#   class A
+#   def self.test(name)
+#   class_variable_get("@@#{name}") # you can access without offense
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/class_vars.rb#48
+class RuboCop::Cop::Style::ClassVars < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/style/class_vars.rb#52
+  def on_cvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/class_vars.rb#56
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/class_vars.rb#49
+RuboCop::Cop::Style::ClassVars::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/class_vars.rb#50
+RuboCop::Cop::Style::ClassVars::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for places where custom logic on rejection nils from arrays
+# and hashes can be replaced with `{Array,Hash}#{compact,compact!}`.
+#
+# @example
+#   # bad
+#   array.reject(&:nil?)
+#   array.reject { |e| e.nil? }
+#   array.select { |e| !e.nil? }
+#   array.filter { |e| !e.nil? }
+#   array.grep_v(nil)
+#   array.grep_v(NilClass)
+#
+#   # good
+#   array.compact
+#
+#   # bad
+#   hash.reject!(&:nil?)
+#   hash.reject! { |k, v| v.nil? }
+#   hash.select! { |k, v| !v.nil? }
+#   hash.filter! { |k, v| !v.nil? }
+#
+#   # good
+#   hash.compact!
+# @example AllowedReceivers: ['params']
+#   # good
+#   params.reject(&:nil?)
+#
+# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#44
+class RuboCop::Cop::Style::CollectionCompact < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedReceivers
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#86
+  def grep_v_with_nil?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#90
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#90
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#65
+  def reject_method?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#58
+  def reject_method_with_block_pass?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#75
+  def select_method?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#129
+  def good_method_name(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#106
+  def offense_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#137
+  def range(begin_pos_node, end_pos_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/collection_compact.rb#123
+  def to_enum_method?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#53
+RuboCop::Cop::Style::CollectionCompact::FILTER_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#50
+RuboCop::Cop::Style::CollectionCompact::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#51
+RuboCop::Cop::Style::CollectionCompact::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/collection_compact.rb#52
+RuboCop::Cop::Style::CollectionCompact::TO_ENUM_METHODS = T.let(T.unsafe(nil), Array)
+
+# Enforces the use of consistent method names
+# from the Enumerable module.
+#
+# You can customize the mapping from undesired method to desired method.
+#
+# e.g. to use `detect` over `find`:
+#
+#   Style/CollectionMethods:
+#     PreferredMethods:
+#       find: detect
+#
+# @example
+#   # These examples are based on the default mapping for `PreferredMethods`.
+#
+#   # bad
+#   items.collect
+#   items.collect!
+#   items.collect_concat
+#   items.inject
+#   items.detect
+#   items.find_all
+#   items.member?
+#
+#   # good
+#   items.map
+#   items.map!
+#   items.flat_map
+#   items.reduce
+#   items.find
+#   items.select
+#   items.include?
+#
+# source://rubocop//lib/rubocop/cop/style/collection_methods.rb#43
+class RuboCop::Cop::Style::CollectionMethods < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::MethodPreference
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#49
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#49
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#55
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#63
+  def check_method_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#72
+  def implicit_block?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#80
+  def message(node); end
+
+  # Some enumerable methods accept a bare symbol (ie. _not_ Symbol#to_proc) instead
+  # of a block.
+  #
+  # source://rubocop//lib/rubocop/cop/style/collection_methods.rb#86
+  def methods_accepting_symbol; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/collection_methods.rb#47
+RuboCop::Cop::Style::CollectionMethods::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for methods invoked via the `::` operator instead
+# of the `.` operator (like `FileUtils::rmdir` instead of `FileUtils.rmdir`).
+#
+# @example
+#   # bad
+#   Timeout::timeout(500) { do_something }
+#   FileUtils::rmdir(dir)
+#   Marshal::dump(obj)
+#
+#   # good
+#   Timeout.timeout(500) { do_something }
+#   FileUtils.rmdir(dir)
+#   Marshal.dump(obj)
+#
+# source://rubocop//lib/rubocop/cop/style/colon_method_call.rb#20
+class RuboCop::Cop::Style::ColonMethodCall < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/colon_method_call.rb#26
+  def java_type_node?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/colon_method_call.rb#35
+  def on_send(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/colon_method_call.rb#31
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/colon_method_call.rb#23
+RuboCop::Cop::Style::ColonMethodCall::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for class methods that are defined using the `::`
+# operator instead of the `.` operator.
+#
+# @example
+#   # bad
+#   class Foo
+#   def self::bar
+#   end
+#   end
+#
+#   # good
+#   class Foo
+#   def self.bar
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/colon_method_definition.rb#22
+class RuboCop::Cop::Style::ColonMethodDefinition < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/colon_method_definition.rb#27
+  def on_defs(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/colon_method_definition.rb#25
+RuboCop::Cop::Style::ColonMethodDefinition::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for places where multiple consecutive loops over the same data
+# can be combined into a single loop. It is very likely that combining them
+# will make the code more efficient and more concise.
+#
+# NOTE: Autocorrection is not applied when the block variable names differ in separate loops,
+# as it is impossible to determine which variable name should be prioritized.
+#
+# @example
+#   # bad
+#   def method
+#   items.each do |item|
+#   do_something(item)
+#   end
+#
+#   items.each do |item|
+#   do_something_else(item)
+#   end
+#   end
+#
+#   # good
+#   def method
+#   items.each do |item|
+#   do_something(item)
+#   do_something_else(item)
+#   end
+#   end
+#
+#   # bad
+#   def method
+#   for item in items do
+#   do_something(item)
+#   end
+#
+#   for item in items do
+#   do_something_else(item)
+#   end
+#   end
+#
+#   # good
+#   def method
+#   for item in items do
+#   do_something(item)
+#   do_something_else(item)
+#   end
+#   end
+#
+#   # good
+#   def method
+#   each_slice(2) { |slice| do_something(slice) }
+#   each_slice(3) { |slice| do_something(slice) }
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#62
+class RuboCop::Cop::Style::CombinableLoops < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#68
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#84
+  def on_for(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#68
+  def on_numblock(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#95
+  def collection_looping_method?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#112
+  def combine_with_left_sibling(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#119
+  def correct_end_of_block(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#100
+  def same_collection_looping_block?(node, sibling); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#108
+  def same_collection_looping_for?(node, sibling); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/combinable_loops.rb#65
+RuboCop::Cop::Style::CombinableLoops::MSG = T.let(T.unsafe(nil), String)
+
+# Enforces using `` or %x around command literals.
+#
+# @example EnforcedStyle: backticks (default)
+#   # bad
+#   folders = %x(find . -type d).split
+#
+#   # bad
+#   %x(
+#   ln -s foo.example.yml foo.example
+#   ln -s bar.example.yml bar.example
+#   )
+#
+#   # good
+#   folders = `find . -type d`.split
+#
+#   # good
+#   `
+#   ln -s foo.example.yml foo.example
+#   ln -s bar.example.yml bar.example
+#   `
+# @example EnforcedStyle: mixed
+#   # bad
+#   folders = %x(find . -type d).split
+#
+#   # bad
+#   `
+#   ln -s foo.example.yml foo.example
+#   ln -s bar.example.yml bar.example
+#   `
+#
+#   # good
+#   folders = `find . -type d`.split
+#
+#   # good
+#   %x(
+#   ln -s foo.example.yml foo.example
+#   ln -s bar.example.yml bar.example
+#   )
+# @example EnforcedStyle: percent_x
+#   # bad
+#   folders = `find . -type d`.split
+#
+#   # bad
+#   `
+#   ln -s foo.example.yml foo.example
+#   ln -s bar.example.yml bar.example
+#   `
+#
+#   # good
+#   folders = %x(find . -type d).split
+#
+#   # good
+#   %x(
+#   ln -s foo.example.yml foo.example
+#   ln -s bar.example.yml bar.example
+#   )
+# @example AllowInnerBackticks: false (default)
+#   # If `false`, the cop will always recommend using `%x` if one or more
+#   # backticks are found in the command string.
+#
+#   # bad
+#   `echo \`ls\``
+#
+#   # good
+#   %x(echo `ls`)
+# @example AllowInnerBackticks: true
+#   # good
+#   `echo \`ls\``
+#
+# source://rubocop//lib/rubocop/cop/style/command_literal.rb#78
+class RuboCop::Cop::Style::CommandLiteral < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#85
+  def on_xstr(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#146
+  def allow_inner_backticks?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#122
+  def allowed_backtick_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#131
+  def allowed_percent_x_literal?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#109
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#159
+  def backtick_literal?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#97
+  def check_backtick_literal(node, message); end
+
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#103
+  def check_percent_x_literal(node, message); end
+
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#167
+  def command_delimiter; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#150
+  def contains_backtick?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#142
+  def contains_disallowed_backtick?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#171
+  def default_delimiter; end
+
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#154
+  def node_body(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#163
+  def preferred_delimiter; end
+
+  # source://rubocop//lib/rubocop/cop/style/command_literal.rb#175
+  def preferred_delimiters_config; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/command_literal.rb#82
+RuboCop::Cop::Style::CommandLiteral::MSG_USE_BACKTICKS = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/command_literal.rb#83
+RuboCop::Cop::Style::CommandLiteral::MSG_USE_PERCENT_X = T.let(T.unsafe(nil), String)
+
+# Checks that comment annotation keywords are written according
+# to guidelines.
+#
+# Annotation keywords can be specified by overriding the cop's `Keywords`
+# configuration. Keywords are allowed to be single words or phrases.
+#
+# NOTE: With a multiline comment block (where each line is only a
+# comment), only the first line will be able to register an offense, even
+# if an annotation keyword starts another line. This is done to prevent
+# incorrect registering of keywords (eg. `review`) inside a paragraph as an
+# annotation.
+#
+# @example RequireColon: true (default)
+#   # bad
+#   # TODO make better
+#
+#   # good
+#   # TODO: make better
+#
+#   # bad
+#   # TODO:make better
+#
+#   # good
+#   # TODO: make better
+#
+#   # bad
+#   # fixme: does not work
+#
+#   # good
+#   # FIXME: does not work
+#
+#   # bad
+#   # Optimize does not work
+#
+#   # good
+#   # OPTIMIZE: does not work
+# @example RequireColon: false
+#   # bad
+#   # TODO: make better
+#
+#   # good
+#   # TODO make better
+#
+#   # bad
+#   # fixme does not work
+#
+#   # good
+#   # FIXME does not work
+#
+#   # bad
+#   # Optimize does not work
+#
+#   # good
+#   # OPTIMIZE does not work
+#
+# source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#61
+class RuboCop::Cop::Style::CommentAnnotation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#73
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#110
+  def annotation_range(annotation); end
+
+  # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#114
+  def correct_offense(corrector, range, keyword); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#102
+  def first_comment_line?(comments, index); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#106
+  def inline_comment?(comment); end
+
+  # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#124
+  def keywords; end
+
+  # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#87
+  def register_offense(annotation); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#120
+  def requires_colon?; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#71
+RuboCop::Cop::Style::CommentAnnotation::MISSING_NOTE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#65
+RuboCop::Cop::Style::CommentAnnotation::MSG_COLON_STYLE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/comment_annotation.rb#68
+RuboCop::Cop::Style::CommentAnnotation::MSG_SPACE_STYLE = T.let(T.unsafe(nil), String)
+
+# Checks for comments put on the same line as some keywords.
+# These keywords are: `class`, `module`, `def`, `begin`, `end`.
+#
+# Note that some comments
+# and RBS::Inline annotation comments are allowed.
+#
+# Autocorrection removes comments from `end` keyword and keeps comments
+# for `class`, `module`, `def` and `begin` above the keyword.
+#
+# @example
+#   # bad
+#   if condition
+#   statement
+#   end # end if
+#
+#   # bad
+#   class X # comment
+#   statement
+#   end
+#
+#   # bad
+#   def x; end # comment
+#
+#   # good
+#   if condition
+#   statement
+#   end
+#
+#   # good
+#   class X # :nodoc:
+#   y
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#45
+class RuboCop::Cop::Style::CommentedKeyword < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#60
+  def on_new_investigation; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#83
+  def offensive?(comment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#95
+  def rbs_inline_annotation?(line, comment); end
+
+  # source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#70
+  def register_offense(comment, matched_keyword); end
+
+  # source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#91
+  def source_line(comment); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#54
+RuboCop::Cop::Style::CommentedKeyword::ALLOWED_COMMENTS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#55
+RuboCop::Cop::Style::CommentedKeyword::ALLOWED_COMMENT_REGEXES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#51
+RuboCop::Cop::Style::CommentedKeyword::KEYWORDS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#52
+RuboCop::Cop::Style::CommentedKeyword::KEYWORD_REGEXES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#49
+RuboCop::Cop::Style::CommentedKeyword::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/commented_keyword.rb#58
+RuboCop::Cop::Style::CommentedKeyword::REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# Enforces the use of `Comparable#clamp` instead of comparison by minimum and maximum.
+#
+# This cop supports autocorrection for `if/elsif/else` bad style only.
+# Because `ArgumentError` occurs if the minimum and maximum of `clamp` arguments are reversed.
+# When these are variables, it is not possible to determine which is the minimum and maximum:
+#
+# [source,ruby]
+# ----
+# [1, [2, 3].max].min # => 1
+# 1.clamp(3, 1)       # => min argument must be smaller than max argument (ArgumentError)
+# ----
+#
+# @example
+#
+#   # bad
+#   [[x, low].max, high].min
+#
+#   # bad
+#   if x < low
+#   low
+#   elsif high < x
+#   high
+#   else
+#   x
+#   end
+#
+#   # good
+#   x.clamp(low, high)
+#
+# source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#35
+class RuboCop::Cop::Style::ComparableClamp < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#61
+  def array_min_max?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#47
+  def if_elsif_else_condition?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#78
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#100
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#108
+  def autocorrect(corrector, node, prefer); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#117
+  def min_condition?(if_condition, else_body); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#42
+RuboCop::Cop::Style::ComparableClamp::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#43
+RuboCop::Cop::Style::ComparableClamp::MSG_MIN_MAX = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/comparable_clamp.rb#44
+RuboCop::Cop::Style::ComparableClamp::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Enforces the use of `Array#push(item)` instead of `Array#concat([item])`
+# to avoid redundant array literals.
+#
+# @example
+#
+#   # bad
+#   list.concat([foo])
+#   list.concat([bar, baz])
+#   list.concat([qux, quux], [corge])
+#
+#   # good
+#   list.push(foo)
+#   list.push(bar, baz)
+#   list.push(qux, quux, corge)
+#
+# source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#25
+class RuboCop::Cop::Style::ConcatArrayLiterals < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#34
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#34
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#70
+  def offense_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#87
+  def percent_literals_includes_only_basic_literals?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#74
+  def preferred_method(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#28
+RuboCop::Cop::Style::ConcatArrayLiterals::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#29
+RuboCop::Cop::Style::ConcatArrayLiterals::MSG_FOR_PERCENT_LITERALS = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/concat_array_literals.rb#31
+RuboCop::Cop::Style::ConcatArrayLiterals::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Check for `if` and `case` statements where each branch is used for
+# both the assignment and comparison of the same variable
+# when using the return of the condition can be used instead.
+#
+# @example EnforcedStyle: assign_to_condition (default)
+#   # bad
+#   if foo
+#   bar = 1
+#   else
+#   bar = 2
+#   end
+#
+#   case foo
+#   when 'a'
+#   bar += 1
+#   else
+#   bar += 2
+#   end
+#
+#   if foo
+#   some_method
+#   bar = 1
+#   else
+#   some_other_method
+#   bar = 2
+#   end
+#
+#   # good
+#   bar = if foo
+#   1
+#   else
+#   2
+#   end
+#
+#   bar += case foo
+#   when 'a'
+#   1
+#   else
+#   2
+#   end
+#
+#   bar << if foo
+#   some_method
+#   1
+#   else
+#   some_other_method
+#   2
+#   end
+# @example EnforcedStyle: assign_inside_condition
+#   # bad
+#   bar = if foo
+#   1
+#   else
+#   2
+#   end
+#
+#   bar += case foo
+#   when 'a'
+#   1
+#   else
+#   2
+#   end
+#
+#   bar << if foo
+#   some_method
+#   1
+#   else
+#   some_other_method
+#   2
+#   end
+#
+#   # good
+#   if foo
+#   bar = 1
+#   else
+#   bar = 2
+#   end
+#
+#   case foo
+#   when 'a'
+#   bar += 1
+#   else
+#   bar += 2
+#   end
+#
+#   if foo
+#   some_method
+#   bar = 1
+#   else
+#   some_other_method
+#   bar = 2
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#210
+class RuboCop::Cop::Style::ConditionalAssignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Style::ConditionalAssignmentHelper
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # The shovel operator `<<` does not have its own type. It is a `send`
+  # type.
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#228
+  def assignment_type?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#309
+  def candidate_condition?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236
+  def on_and_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#264
+  def on_case(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#274
+  def on_case_match(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236
+  def on_casgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236
+  def on_cvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236
+  def on_gvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#250
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236
+  def on_ivasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236
+  def on_lvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236
+  def on_masgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236
+  def on_op_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#236
+  def on_or_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#244
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#315
+  def allowed_single_line?(branches); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#386
+  def allowed_statements?(branches); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#311
+  def allowed_ternary?(assignment); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#319
+  def assignment_node(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#363
+  def assignment_types_match?(*nodes); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#378
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#304
+  def candidate_node?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#286
+  def check_assignment_to_condition(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#369
+  def check_node(node, branches); end
+
+  # If `Layout/LineLength` is enabled, we do not want to introduce an
+  # offense by autocorrecting this cop. Find the max configured line
+  # length. Find the longest line of condition. Remove the assignment
+  # from lines that contain the offending assignment because after
+  # correcting, this will not be on the line anymore. Check if the length
+  # of the longest line + the length of the corrected assignment is
+  # greater than the max configured line length
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#402
+  def correction_exceeds_line_limit?(node, branches); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#433
+  def include_ternary?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#356
+  def lhs_all_match?(branches); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#421
+  def line_length_cop_enabled?; end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#414
+  def longest_line(node, assignment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#410
+  def longest_line_exceeds_line_limit?(node, assignment); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#425
+  def max_line_length; end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#340
+  def move_assignment_inside_condition(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#330
+  def move_assignment_outside_condition(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#429
+  def single_line_conditions_only?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#352
+  def ternary_condition?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#219
+RuboCop::Cop::Style::ConditionalAssignment::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#217
+RuboCop::Cop::Style::ConditionalAssignment::ASSIGN_TO_CONDITION_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#221
+RuboCop::Cop::Style::ConditionalAssignment::ENABLED = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#220
+RuboCop::Cop::Style::ConditionalAssignment::LINE_LENGTH = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#222
+RuboCop::Cop::Style::ConditionalAssignment::MAX = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#216
+RuboCop::Cop::Style::ConditionalAssignment::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#223
+RuboCop::Cop::Style::ConditionalAssignment::SINGLE_LINE_CONDITIONS_ONLY = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#218
+RuboCop::Cop::Style::ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
+
+# Helper module to provide common methods to classes needed for the
+# ConditionalAssignment Cop.
+#
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#8
+module RuboCop::Cop::Style::ConditionalAssignmentHelper
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#64
+  def end_with_eq?(sym); end
+
+  # `elsif` branches show up in the `node` as an `else`. We need
+  # to recursively iterate over all `else` branches and consider all
+  # but the last `node` an `elsif` branch and consider the last `node`
+  # the actual `else` branch.
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#20
+  def expand_elses(branch); end
+
+  # `when` nodes contain the entire branch including the condition.
+  # We only need the contents of the branch, not the condition.
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#28
+  def expand_when_branches(when_branches); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#55
+  def indent(cop, source); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#37
+  def lhs(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#32
+  def tail(branch); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#109
+  def assignment_rhs_exist?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#70
+  def expand_elsif(node, elsif_branches = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#96
+  def lhs_for_casgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#83
+  def lhs_for_send(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#105
+  def setter_method?(method_name); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#13
+RuboCop::Cop::Style::ConditionalAssignmentHelper::ALIGN_WITH = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#12
+RuboCop::Cop::Style::ConditionalAssignmentHelper::END_ALIGNMENT = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#11
+RuboCop::Cop::Style::ConditionalAssignmentHelper::EQUAL = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#14
+RuboCop::Cop::Style::ConditionalAssignmentHelper::KEYWORD = T.let(T.unsafe(nil), String)
+
+# Helper module to provide common methods to ConditionalAssignment
+# correctors
+#
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#440
+module RuboCop::Cop::Style::ConditionalCorrectorHelper
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#461
+  def assignment(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#490
+  def correct_branches(corrector, branches); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#467
+  def correct_if_branches(corrector, cop, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#441
+  def remove_whitespace_in_branches(corrector, branch, condition, column); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#477
+  def replace_branch_assignment(corrector, branch); end
+
+  # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#454
+  def white_space_range(node, column); end
+end
+
+# Checks that constants defined in classes and modules have
+# an explicit visibility declaration. By default, Ruby makes all class-
+# and module constants public, which litters the public API of the
+# class or module. Explicitly declaring a visibility makes intent more
+# clear, and prevents outside actors from touching private state.
+#
+# @example
+#
+#   # bad
+#   class Foo
+#   BAR = 42
+#   BAZ = 43
+#   end
+#
+#   # good
+#   class Foo
+#   BAR = 42
+#   private_constant :BAR
+#
+#   BAZ = 43
+#   public_constant :BAZ
+#   end
+# @example IgnoreModules: false (default)
+#   # bad
+#   class Foo
+#   MyClass = Struct.new()
+#   end
+#
+#   # good
+#   class Foo
+#   MyClass = Struct.new()
+#   public_constant :MyClass
+#   end
+# @example IgnoreModules: true
+#   # good
+#   class Foo
+#   MyClass = Struct.new()
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#47
+class RuboCop::Cop::Style::ConstantVisibility < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#51
+  def on_casgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#96
+  def visibility_declaration_for?(param0 = T.unsafe(nil), param1); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#76
+  def class_or_module_scope?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#62
+  def ignore_modules?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#100
+  def match_name?(name, constant_name); end
+
+  # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#70
+  def message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#66
+  def module?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#87
+  def visibility_declaration?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/constant_visibility.rb#48
+RuboCop::Cop::Style::ConstantVisibility::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/copyright.rb#21
+class RuboCop::Cop::Style::Copyright < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/copyright.rb#28
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/copyright.rb#45
+  def autocorrect(corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/copyright.rb#56
+  def autocorrect_notice; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/copyright.rb#86
+  def encoding_token?(processed_source, token_index); end
+
+  # source://rubocop//lib/rubocop/cop/style/copyright.rb#72
+  def insert_notice_before(processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/style/copyright.rb#52
+  def notice; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/copyright.rb#93
+  def notice_found?(processed_source); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/copyright.rb#79
+  def shebang_token?(processed_source, token_index); end
+
+  # @raise [Warning]
+  #
+  # source://rubocop//lib/rubocop/cop/style/copyright.rb#60
+  def verify_autocorrect_notice!; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/copyright.rb#26
+RuboCop::Cop::Style::Copyright::AUTOCORRECT_EMPTY_WARNING = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/copyright.rb#25
+RuboCop::Cop::Style::Copyright::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for inheritance from `Data.define` to avoid creating the anonymous parent class.
+#
+# @example
+#   # bad
+#   class Person < Data.define(:first_name, :last_name)
+#   def age
+#   42
+#   end
+#   end
+#
+#   # good
+#   Person = Data.define(:first_name, :last_name) do
+#   def age
+#   42
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#26
+class RuboCop::Cop::Style::DataInheritance < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#48
+  def data_define?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#36
+  def on_class(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#55
+  def correct_parent(parent, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#65
+  def range_for_empty_class_body(class_node, data_define); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/data_inheritance.rb#31
+RuboCop::Cop::Style::DataInheritance::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for consistent usage of the `DateTime` class over the
+# `Time` class. This cop is disabled by default since these classes,
+# although highly overlapping, have particularities that make them not
+# replaceable in certain situations when dealing with multiple timezones
+# and/or DST.
+#
+# @example
+#
+#   # bad - uses `DateTime` for current time
+#   DateTime.now
+#
+#   # good - uses `Time` for current time
+#   Time.now
+#
+#   # bad - uses `DateTime` for modern date
+#   DateTime.iso8601('2016-06-29')
+#
+#   # good - uses `Time` for modern date
+#   Time.iso8601('2016-06-29')
+#
+#   # good - uses `DateTime` with start argument for historical date
+#   DateTime.iso8601('1751-04-23', Date::ENGLAND)
+# @example AllowCoercion: false (default)
+#
+#   # bad - coerces to `DateTime`
+#   something.to_datetime
+#
+#   # good - coerces to `Time`
+#   something.to_time
+# @example AllowCoercion: true
+#
+#   # good
+#   something.to_datetime
+#
+#   # good
+#   something.to_time
+#
+# source://rubocop//lib/rubocop/cop/style/date_time.rb#49
+class RuboCop::Cop::Style::DateTime < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/date_time.rb#56
+  def date_time?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/date_time.rb#61
+  def historic_date?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/date_time.rb#70
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/date_time.rb#70
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/date_time.rb#66
+  def to_datetime?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/date_time.rb#86
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/date_time.rb#82
+  def disallow_coercion?; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/date_time.rb#52
+RuboCop::Cop::Style::DateTime::CLASS_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/date_time.rb#53
+RuboCop::Cop::Style::DateTime::COERCION_MSG = T.let(T.unsafe(nil), String)
+
+# Checks for parentheses in the definition of a method,
+# that does not take any arguments. Both instance and
+# class/singleton methods are checked.
+#
+# @example
+#
+#   # bad
+#   def foo()
+#   do_something
+#   end
+#
+#   # good
+#   def foo
+#   do_something
+#   end
+#
+#   # bad
+#   def foo() = do_something
+#
+#   # good
+#   def foo = do_something
+#
+#   # good (without parentheses it's a syntax error)
+#   def foo() do_something end
+#
+#   # bad
+#   def Baz.foo()
+#   do_something
+#   end
+#
+#   # good
+#   def Baz.foo
+#   do_something
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/def_with_parentheses.rb#40
+class RuboCop::Cop::Style::DefWithParentheses < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/def_with_parentheses.rb#45
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/def_with_parentheses.rb#45
+  def on_defs(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/def_with_parentheses.rb#43
+RuboCop::Cop::Style::DefWithParentheses::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for places where the `#\_\_dir\_\_` method can replace more
+# complex constructs to retrieve a canonicalized absolute path to the
+# current file.
+#
+# @example
+#   # bad
+#   path = File.expand_path(File.dirname(__FILE__))
+#
+#   # bad
+#   path = File.dirname(File.realpath(__FILE__))
+#
+#   # good
+#   path = __dir__
+#
+# source://rubocop//lib/rubocop/cop/style/dir.rb#19
+class RuboCop::Cop::Style::Dir < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/dir.rb#29
+  def dir_replacement?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/dir.rb#34
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/dir.rb#44
+  def file_keyword?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/dir.rb#25
+RuboCop::Cop::Style::Dir::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/dir.rb#26
+RuboCop::Cop::Style::Dir::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Prefer to use `Dir.empty?('path/to/dir')` when checking if a directory is empty.
+#
+# @example
+#   # bad
+#   Dir.entries('path/to/dir').size == 2
+#   Dir.children('path/to/dir').empty?
+#   Dir.children('path/to/dir').size == 0
+#   Dir.each_child('path/to/dir').none?
+#
+#   # good
+#   Dir.empty?('path/to/dir')
+#
+# source://rubocop//lib/rubocop/cop/style/dir_empty.rb#18
+class RuboCop::Cop::Style::DirEmpty < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/dir_empty.rb#28
+  def offensive?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/dir_empty.rb#37
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/dir_empty.rb#48
+  def bang(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/dir_empty.rb#22
+RuboCop::Cop::Style::DirEmpty::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/dir_empty.rb#23
+RuboCop::Cop::Style::DirEmpty::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Detects comments to enable/disable RuboCop.
+# This is useful if want to make sure that every RuboCop error gets fixed
+# and not quickly disabled with a comment.
+#
+# Specific cops can be allowed with the `AllowedCops` configuration. Note that
+#
+# @example
+#   # bad
+#   # rubocop:disable Metrics/AbcSize
+#   def foo
+#   end
+#   # rubocop:enable Metrics/AbcSize
+#
+#   # good
+#   def foo
+#   end
+# @example AllowedCops: [Metrics/AbcSize]
+#   # good
+#   # rubocop:disable Metrics/AbcSize
+#   def foo
+#   end
+#   # rubocop:enable Metrics/AbcSize
+#
+# source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#33
+class RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#40
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#77
+  def allowed_cops; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#81
+  def any_cops_allowed?; end
+
+  # source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#72
+  def directive_cops(comment); end
+
+  # source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#53
+  def register_offense(comment, directive_cops, disallowed_cops); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#37
+RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb#38
+RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::MSG_FOR_COPS = T.let(T.unsafe(nil), String)
+
+# When using `class_eval` (or other `eval`) with string interpolation,
+# add a comment block showing its appearance if interpolated (a practice used in Rails code).
+#
+# @example
+#   # from activesupport/lib/active_support/core_ext/string/output_safety.rb
+#
+#   # bad
+#   UNSAFE_STRING_METHODS.each do |unsafe_method|
+#   if 'String'.respond_to?(unsafe_method)
+#   class_eval <<-EOT, __FILE__, __LINE__ + 1
+#   def #{unsafe_method}(*params, &block)
+#   to_str.#{unsafe_method}(*params, &block)
+#   end
+#
+#   def #{unsafe_method}!(*params)
+#   @dirty = true
+#   super
+#   end
+#   EOT
+#   end
+#   end
+#
+#   # good, inline comments in heredoc
+#   UNSAFE_STRING_METHODS.each do |unsafe_method|
+#   if 'String'.respond_to?(unsafe_method)
+#   class_eval <<-EOT, __FILE__, __LINE__ + 1
+#   def #{unsafe_method}(*params, &block)       # def capitalize(*params, &block)
+#   to_str.#{unsafe_method}(*params, &block)  #   to_str.capitalize(*params, &block)
+#   end                                         # end
+#
+#   def #{unsafe_method}!(*params)              # def capitalize!(*params)
+#   @dirty = true                             #   @dirty = true
+#   super                                     #   super
+#   end                                         # end
+#   EOT
+#   end
+#   end
+#
+#   # good, block comments in heredoc
+#   class_eval <<-EOT, __FILE__, __LINE__ + 1
+#   # def capitalize!(*params)
+#   #   @dirty = true
+#   #   super
+#   # end
+#
+#   def #{unsafe_method}!(*params)
+#   @dirty = true
+#   super
+#   end
+#   EOT
+#
+#   # good, block comments before heredoc
+#   class_eval(
+#   # def capitalize!(*params)
+#   #   @dirty = true
+#   #   super
+#   # end
+#
+#   <<-EOT, __FILE__, __LINE__ + 1
+#   def #{unsafe_method}!(*params)
+#   @dirty = true
+#   super
+#   end
+#   EOT
+#   )
+#
+#   # bad - interpolated string without comment
+#   class_eval("def #{unsafe_method}!(*params); end")
+#
+#   # good - with inline comment or replace it with block comment using heredoc
+#   class_eval("def #{unsafe_method}!(*params); end # def capitalize!(*params); end")
+#
+# source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#77
+class RuboCop::Cop::Style::DocumentDynamicEvalDefinition < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#84
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#107
+  def comment_block_docs?(arg_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#147
+  def comment_regexp(arg_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#126
+  def heredoc_comment_blocks(heredoc_body); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#100
+  def inline_comment_docs?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#96
+  def interpolated?(arg_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#136
+  def merge_adjacent_comments(line, index, hash); end
+
+  # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#117
+  def preceding_comment_blocks(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#156
+  def source_to_regexp(source); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#78
+RuboCop::Cop::Style::DocumentDynamicEvalDefinition::BLOCK_COMMENT_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#79
+RuboCop::Cop::Style::DocumentDynamicEvalDefinition::COMMENT_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#80
+RuboCop::Cop::Style::DocumentDynamicEvalDefinition::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/document_dynamic_eval_definition.rb#82
+RuboCop::Cop::Style::DocumentDynamicEvalDefinition::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for missing top-level documentation of classes and
+# modules. Classes with no body are exempt from the check and so are
+# namespace modules - modules that have nothing in their bodies except
+# classes, other modules, constant definitions or constant visibility
+# declarations.
+#
+# The documentation requirement is annulled if the class or module has
+# same for all its children.
+#
+# @example
+#   # bad
+#   class Person
+#   # ...
+#   end
+#
+#   module Math
+#   end
+#
+#   # good
+#   # Description/Explanation of Person class
+#   class Person
+#   # ...
+#   end
+#
+#   # allowed
+#   # Class without body
+#   class Person
+#   end
+#
+#   # Namespace - A namespace can be a class or a module
+#   # Containing a class
+#   module Namespace
+#   # Description/Explanation of Person class
+#   class Person
+#   # ...
+#   end
+#   end
+#
+#   # Containing constant visibility declaration
+#   module Namespace
+#   class Private
+#   end
+#
+#   private_constant :Private
+#   end
+#
+#   # Containing constant definition
+#   module Namespace
+#   Public = Class.new
+#   end
+#
+#   # Macro calls
+#   module Namespace
+#   extend Foo
+#   end
+# @example AllowedConstants: ['ClassMethods']
+#
+#   # good
+#   module A
+#   module ClassMethods
+#   # ...
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/documentation.rb#72
+class RuboCop::Cop::Style::Documentation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::DocumentationComment
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#79
+  def constant_definition?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#85
+  def constant_visibility_declaration?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#90
+  def include_statement?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#94
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#100
+  def on_module(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#82
+  def outer_module(param0); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#174
+  def allowed_constants; end
+
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#106
+  def check(node, body); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#147
+  def compact_namespace?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#143
+  def constant_allowed?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#139
+  def constant_declaration?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#178
+  def identifier(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#123
+  def include_statement_only?(body); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#129
+  def namespace?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#170
+  def nodoc(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#166
+  def nodoc?(comment, require_all: T.unsafe(nil)); end
+
+  # Note: How end-of-line comments are associated with code changed in
+  # parser-2.2.0.4.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#156
+  def nodoc_comment?(node, require_all: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#118
+  def nodoc_self_or_outer_module?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/documentation.rb#186
+  def qualify_const(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/documentation.rb#76
+RuboCop::Cop::Style::Documentation::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for missing documentation comment for public methods.
+# It can optionally be configured to also require documentation for
+# non-public methods.
+#
+# NOTE: This cop allows `initialize` method because `initialize` is
+# a special method called from `new`. In some programming languages
+# they are called constructor to distinguish it from method.
+#
+# @example
+#
+#   # bad
+#
+#   class Foo
+#   def bar
+#   puts baz
+#   end
+#   end
+#
+#   module Foo
+#   def bar
+#   puts baz
+#   end
+#   end
+#
+#   def foo.bar
+#   puts baz
+#   end
+#
+#   # good
+#
+#   class Foo
+#   # Documentation
+#   def bar
+#   puts baz
+#   end
+#   end
+#
+#   module Foo
+#   # Documentation
+#   def bar
+#   puts baz
+#   end
+#   end
+#
+#   # Documentation
+#   def foo.bar
+#   puts baz
+#   end
+# @example RequireForNonPublicMethods: false (default)
+#   # good
+#   class Foo
+#   protected
+#   def do_something
+#   end
+#   end
+#
+#   class Foo
+#   private
+#   def do_something
+#   end
+#   end
+# @example RequireForNonPublicMethods: true
+#   # bad
+#   class Foo
+#   protected
+#   def do_something
+#   end
+#   end
+#
+#   class Foo
+#   private
+#   def do_something
+#   end
+#   end
+#
+#   # good
+#   class Foo
+#   protected
+#   # Documentation
+#   def do_something
+#   end
+#   end
+#
+#   class Foo
+#   private
+#   # Documentation
+#   def do_something
+#   end
+#   end
+# @example AllowedMethods: ['method_missing', 'respond_to_missing?']
+#
+#   # good
+#   class Foo
+#   def method_missing(name, *args)
+#   end
+#
+#   def respond_to_missing?(symbol, include_private)
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/documentation_method.rb#109
+class RuboCop::Cop::Style::DocumentationMethod < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::DocumentationComment
+  include ::RuboCop::Cop::VisibilityHelp
+  include ::RuboCop::Cop::DefNode
+
+  # source://rubocop//lib/rubocop/cop/style/documentation_method.rb#116
+  def modifier_node?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/documentation_method.rb#120
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/documentation_method.rb#120
+  def on_defs(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/documentation_method.rb#146
+  def allowed_methods; end
+
+  # source://rubocop//lib/rubocop/cop/style/documentation_method.rb#130
+  def check(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/documentation_method.rb#142
+  def method_allowed?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/documentation_method.rb#138
+  def require_for_non_public_methods?; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/documentation_method.rb#113
+RuboCop::Cop::Style::DocumentationMethod::MSG = T.let(T.unsafe(nil), String)
+
+# Detects double disable comments on one line. This is mostly to catch
+# automatically generated comments that need to be regenerated.
+#
+# @example
+#   # bad
+#   def f # rubocop:disable Style/For # rubocop:disable Metrics/AbcSize
+#   end
+#
+#   # good
+#   # rubocop:disable Metrics/AbcSize
+#   def f # rubocop:disable Style/For
+#   end
+#   # rubocop:enable Metrics/AbcSize
+#
+#   # if both fit on one line
+#   def f # rubocop:disable Style/For, Metrics/AbcSize
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/double_cop_disable_directive.rb#27
+class RuboCop::Cop::Style::DoubleCopDisableDirective < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/double_cop_disable_directive.rb#34
+  def on_new_investigation; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/double_cop_disable_directive.rb#32
+RuboCop::Cop::Style::DoubleCopDisableDirective::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for uses of double negation (`!!`) to convert something to a boolean value.
+#
+# When using `EnforcedStyle: allowed_in_returns`, allow double negation in contexts
+# that use boolean as a return value. When using `EnforcedStyle: forbidden`, double negation
+# should be forbidden always.
+#
+# NOTE: when `something` is a boolean value
+# `!!something` and `!something.nil?` are not the same thing.
+# As you're unlikely to write code that can accept values of any type
+# this is rarely a problem in practice.
+#
+# @example
+#   # bad
+#   !!something
+#
+#   # good
+#   !something.nil?
+# @example EnforcedStyle: allowed_in_returns (default)
+#   # good
+#   def foo?
+#   !!return_value
+#   end
+#
+#   define_method :foo? do
+#   !!return_value
+#   end
+#
+#   define_singleton_method :foo? do
+#   !!return_value
+#   end
+# @example EnforcedStyle: forbidden
+#   # bad
+#   def foo?
+#   !!return_value
+#   end
+#
+#   define_method :foo? do
+#   !!return_value
+#   end
+#
+#   define_singleton_method :foo? do
+#   !!return_value
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/double_negation.rb#61
+class RuboCop::Cop::Style::DoubleNegation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/double_negation.rb#69
+  def double_negative?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/double_negation.rb#71
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/double_negation.rb#84
+  def allowed_in_returns?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/double_negation.rb#111
+  def define_method?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/double_negation.rb#138
+  def double_negative_condition_return_value?(node, last_child, conditional_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/double_negation.rb#88
+  def end_of_method_definition?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/double_negation.rb#120
+  def find_conditional_node_from_ascendant(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/double_negation.rb#103
+  def find_def_node_from_ascendant(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/double_negation.rb#127
+  def find_last_child(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/double_negation.rb#147
+  def find_parent_not_enumerable(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/double_negation.rb#65
+RuboCop::Cop::Style::DoubleNegation::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/double_negation.rb#66
+RuboCop::Cop::Style::DoubleNegation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for loops which iterate a constant number of times,
+# using a Range literal and `#each`. This can be done more readably using
+# `Integer#times`.
+#
+# This check only applies if the block takes no parameters.
+#
+# @example
+#   # bad
+#   (1..5).each { }
+#
+#   # good
+#   5.times { }
+#
+#   # bad
+#   (0...10).each {}
+#
+#   # good
+#   10.times {}
+#
+# source://rubocop//lib/rubocop/cop/style/each_for_simple_loop.rb#24
+class RuboCop::Cop::Style::EachForSimpleLoop < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/each_for_simple_loop.rb#52
+  def each_range(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/each_for_simple_loop.rb#64
+  def each_range_with_zero_origin?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/each_for_simple_loop.rb#76
+  def each_range_without_block_argument?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/each_for_simple_loop.rb#29
+  def on_block(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/each_for_simple_loop.rb#45
+  def offending?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/each_for_simple_loop.rb#27
+RuboCop::Cop::Style::EachForSimpleLoop::MSG = T.let(T.unsafe(nil), String)
+
+# Looks for inject / reduce calls where the passed in object is
+# returned at the end and so could be replaced by each_with_object without
+# the need to return the object at the end.
+#
+# However, we can't replace with each_with_object if the accumulator
+# parameter is assigned to within the block.
+#
+# @example
+#   # bad
+#   [1, 2].inject({}) { |a, e| a[e] = e; a }
+#
+#   # good
+#   [1, 2].each_with_object({}) { |e, a| a[e] = e }
+#
+# source://rubocop//lib/rubocop/cop/style/each_with_object.rb#19
+class RuboCop::Cop::Style::EachWithObject < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#60
+  def each_with_object_block_candidate?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#65
+  def each_with_object_numblock_candidate?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#26
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#43
+  def on_numblock(node); end
+
+  private
+
+  # if the accumulator parameter is assigned to in the block,
+  # then we can't convert to each_with_object
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#102
+  def accumulator_param_assigned_to?(body, args); end
+
+  # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#69
+  def autocorrect_block(corrector, node, return_value); end
+
+  # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#84
+  def autocorrect_numblock(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#121
+  def first_argument_returned?(args, return_value); end
+
+  # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#114
+  def return_value(body); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#129
+  def return_value_occupies_whole_line?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#96
+  def simple_method_arg?(method_arg); end
+
+  # source://rubocop//lib/rubocop/cop/style/each_with_object.rb#133
+  def whole_line_expression(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/each_with_object.rb#24
+RuboCop::Cop::Style::EachWithObject::METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/each_with_object.rb#23
+RuboCop::Cop::Style::EachWithObject::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for pipes for empty block parameters. Pipes for empty
+# block parameters do not cause syntax errors, but they are redundant.
+#
+# @example
+#   # bad
+#   a do ||
+#   do_something
+#   end
+#
+#   # bad
+#   a { || do_something }
+#
+#   # good
+#   a do
+#   end
+#
+#   # good
+#   a { do_something }
+#
+# source://rubocop//lib/rubocop/cop/style/empty_block_parameter.rb#24
+class RuboCop::Cop::Style::EmptyBlockParameter < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::EmptyParameter
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/empty_block_parameter.rb#31
+  def on_block(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/empty_block_parameter.rb#38
+  def autocorrect(corrector, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/empty_block_parameter.rb#29
+RuboCop::Cop::Style::EmptyBlockParameter::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for case statements with an empty condition.
+#
+# @example
+#
+#   # bad:
+#   case
+#   when x == 0
+#   puts 'x is 0'
+#   when y == 0
+#   puts 'y is 0'
+#   else
+#   puts 'neither is 0'
+#   end
+#
+#   # good:
+#   if x == 0
+#   puts 'x is 0'
+#   elsif y == 0
+#   puts 'y is 0'
+#   else
+#   puts 'neither is 0'
+#   end
+#
+#   # good: (the case condition node is not empty)
+#   case n
+#   when 0
+#   puts 'zero'
+#   when 1
+#   puts 'one'
+#   else
+#   puts 'more'
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#38
+class RuboCop::Cop::Style::EmptyCaseCondition < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#46
+  def on_case(case_node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#63
+  def autocorrect(corrector, case_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#70
+  def correct_case_when(corrector, case_node, when_nodes); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#82
+  def correct_when_conditions(corrector, when_nodes); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#97
+  def keep_first_when_comment(case_range, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#107
+  def replace_then_with_line_break(corrector, conditions, when_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#42
+RuboCop::Cop::Style::EmptyCaseCondition::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/empty_case_condition.rb#43
+RuboCop::Cop::Style::EmptyCaseCondition::NOT_SUPPORTED_PARENT_TYPES = T.let(T.unsafe(nil), Array)
+
+# Checks for empty else-clauses, possibly including comments and/or an
+# explicit `nil` depending on the EnforcedStyle.
+#
+# @example EnforcedStyle: both (default)
+#   # warn on empty else and else with nil in it
+#
+#   # bad
+#   if condition
+#   statement
+#   else
+#   nil
+#   end
+#
+#   # bad
+#   if condition
+#   statement
+#   else
+#   end
+#
+#   # good
+#   if condition
+#   statement
+#   else
+#   statement
+#   end
+#
+#   # good
+#   if condition
+#   statement
+#   end
+# @example EnforcedStyle: empty
+#   # warn only on empty else
+#
+#   # bad
+#   if condition
+#   statement
+#   else
+#   end
+#
+#   # good
+#   if condition
+#   statement
+#   else
+#   nil
+#   end
+#
+#   # good
+#   if condition
+#   statement
+#   else
+#   statement
+#   end
+#
+#   # good
+#   if condition
+#   statement
+#   end
+# @example EnforcedStyle: nil
+#   # warn on else with nil in it
+#
+#   # bad
+#   if condition
+#   statement
+#   else
+#   nil
+#   end
+#
+#   # good
+#   if condition
+#   statement
+#   else
+#   end
+#
+#   # good
+#   if condition
+#   statement
+#   else
+#   statement
+#   end
+#
+#   # good
+#   if condition
+#   statement
+#   end
+# @example AllowComments: false (default)
+#
+#   # bad
+#   if condition
+#   statement
+#   else
+#   # something comment
+#   nil
+#   end
+#
+#   # bad
+#   if condition
+#   statement
+#   else
+#   # something comment
+#   end
+# @example AllowComments: true
+#
+#   # good
+#   if condition
+#   statement
+#   else
+#   # something comment
+#   nil
+#   end
+#
+#   # good
+#   if condition
+#   statement
+#   else
+#   # something comment
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/empty_else.rb#127
+class RuboCop::Cop::Style::EmptyElse < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::OnNormalIfUnless
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/empty_else.rb#139
+  def on_case(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_else.rb#135
+  def on_normal_if_unless(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/empty_else.rb#172
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/empty_else.rb#194
+  def autocorrect_forbidden?(type); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_else.rb#187
+  def base_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_else.rb#145
+  def check(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/empty_else.rb#180
+  def comment_in_else?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_else.rb#160
+  def empty_check(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/empty_else.rb#156
+  def empty_style?; end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_else.rb#198
+  def missing_else_style; end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_else.rb#166
+  def nil_check(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/empty_else.rb#152
+  def nil_style?; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/empty_else.rb#133
+RuboCop::Cop::Style::EmptyElse::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for using empty heredoc to reduce redundancy.
+#
+# @example
+#
+#   # bad
+#   <<~EOS
+#   EOS
+#
+#   <<-EOS
+#   EOS
+#
+#   <<EOS
+#   EOS
+#
+#   # good
+#   ''
+#
+#   # bad
+#   do_something(<<~EOS)
+#   EOS
+#
+#   do_something(<<-EOS)
+#   EOS
+#
+#   do_something(<<EOS)
+#   EOS
+#
+#   # good
+#   do_something('')
+#
+# source://rubocop//lib/rubocop/cop/style/empty_heredoc.rb#36
+class RuboCop::Cop::Style::EmptyHeredoc < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Heredoc
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::StringLiteralsHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/empty_heredoc.rb#44
+  def on_heredoc(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/empty_heredoc.rb#42
+RuboCop::Cop::Style::EmptyHeredoc::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for parentheses for empty lambda parameters. Parentheses
+# for empty lambda parameters do not cause syntax errors, but they are
+# redundant.
+#
+# @example
+#   # bad
+#   -> () { do_something }
+#
+#   # good
+#   -> { do_something }
+#
+#   # good
+#   -> (arg) { do_something(arg) }
+#
+# source://rubocop//lib/rubocop/cop/style/empty_lambda_parameter.rb#19
+class RuboCop::Cop::Style::EmptyLambdaParameter < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::EmptyParameter
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/empty_lambda_parameter.rb#26
+  def on_block(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/empty_lambda_parameter.rb#35
+  def autocorrect(corrector, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/empty_lambda_parameter.rb#24
+RuboCop::Cop::Style::EmptyLambdaParameter::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the use of a method, the result of which
+# would be a literal, like an empty array, hash, or string.
+#
+# @example
+#   # bad
+#   a = Array.new
+#   a = Array[]
+#   h = Hash.new
+#   h = Hash[]
+#   s = String.new
+#
+#   # good
+#   a = []
+#   h = {}
+#   s = ''
+#
+# source://rubocop//lib/rubocop/cop/style/empty_literal.rb#21
+class RuboCop::Cop::Style::EmptyLiteral < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::FrozenStringLiteral
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::StringLiteralsHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#34
+  def array_node(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#43
+  def array_with_block(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#54
+  def array_with_index(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#37
+  def hash_node(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#46
+  def hash_with_block(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#62
+  def hash_with_index(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#69
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#40
+  def str_node(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#118
+  def correction(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#89
+  def first_argument_unparenthesized?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#136
+  def frozen_strings?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#109
+  def offense_array_node?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#113
+  def offense_hash_node?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#79
+  def offense_message(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_literal.rb#96
+  def replacement_range(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/empty_literal.rb#27
+RuboCop::Cop::Style::EmptyLiteral::ARR_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/empty_literal.rb#28
+RuboCop::Cop::Style::EmptyLiteral::HASH_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/empty_literal.rb#31
+RuboCop::Cop::Style::EmptyLiteral::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/empty_literal.rb#29
+RuboCop::Cop::Style::EmptyLiteral::STR_MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the formatting of empty method definitions.
+# By default it enforces empty method definitions to go on a single
+# line (compact style), but it can be configured to enforce the `end`
+# to go on its own line (expanded style).
+#
+# NOTE: A method definition is not considered empty if it contains
+# comments.
+#
+# NOTE: Autocorrection will not be applied for the `compact` style
+# if the resulting code is longer than the `Max` configuration for
+# `Layout/LineLength`, but an offense will still be registered.
+#
+# @example EnforcedStyle: compact (default)
+#   # bad
+#   def foo(bar)
+#   end
+#
+#   def self.foo(bar)
+#   end
+#
+#   # good
+#   def foo(bar); end
+#
+#   def foo(bar)
+#   # baz
+#   end
+#
+#   def self.foo(bar); end
+# @example EnforcedStyle: expanded
+#   # bad
+#   def foo(bar); end
+#
+#   def self.foo(bar); end
+#
+#   # good
+#   def foo(bar)
+#   end
+#
+#   def self.foo(bar)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/empty_method.rb#47
+class RuboCop::Cop::Style::EmptyMethod < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/empty_method.rb#54
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_method.rb#54
+  def on_defs(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/empty_method.rb#95
+  def compact?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/empty_method.rb#103
+  def compact_style?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/empty_method.rb#73
+  def correct_style?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_method.rb#77
+  def corrected(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/empty_method.rb#99
+  def expanded?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/empty_method.rb#107
+  def expanded_style?; end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_method.rb#89
+  def joint(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_method.rb#111
+  def max_line_length; end
+
+  # source://rubocop//lib/rubocop/cop/style/empty_method.rb#69
+  def message(_range); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/empty_method.rb#51
+RuboCop::Cop::Style::EmptyMethod::MSG_COMPACT = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/empty_method.rb#52
+RuboCop::Cop::Style::EmptyMethod::MSG_EXPANDED = T.let(T.unsafe(nil), String)
+
+# Checks ensures source files have no utf-8 encoding comments.
+#
+# @example
+#   # bad
+#   # encoding: UTF-8
+#   # coding: UTF-8
+#   # -*- coding: UTF-8 -*-
+#
+# source://rubocop//lib/rubocop/cop/style/encoding.rb#12
+class RuboCop::Cop::Style::Encoding < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/encoding.rb#20
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/encoding.rb#32
+  def comments; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/encoding.rb#43
+  def offense?(comment); end
+
+  # source://rubocop//lib/rubocop/cop/style/encoding.rb#47
+  def register_offense(line_number, comment); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/encoding.rb#17
+RuboCop::Cop::Style::Encoding::ENCODING_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/encoding.rb#16
+RuboCop::Cop::Style::Encoding::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/encoding.rb#18
+RuboCop::Cop::Style::Encoding::SHEBANG = T.let(T.unsafe(nil), String)
+
+# Checks for END blocks.
+#
+# @example
+#   # bad
+#   END { puts 'Goodbye!' }
+#
+#   # good
+#   at_exit { puts 'Goodbye!' }
+#
+# source://rubocop//lib/rubocop/cop/style/end_block.rb#15
+class RuboCop::Cop::Style::EndBlock < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/end_block.rb#20
+  def on_postexe(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/end_block.rb#18
+RuboCop::Cop::Style::EndBlock::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for endless methods.
+#
+# It can enforce either the use of endless methods definitions
+# for single-lined method bodies, or disallow endless methods.
+#
+# Other method definition types are not considered by this cop.
+#
+# The supported styles are:
+#
+# * allow_single_line (default) - only single line endless method definitions are allowed.
+# * allow_always - all endless method definitions are allowed.
+# * disallow - all endless method definitions are disallowed.
+#
+# NOTE: Incorrect endless method definitions will always be
+# corrected to a multi-line definition.
+#
+# @example EnforcedStyle: allow_single_line (default)
+#   # good
+#   def my_method() = x
+#
+#   # bad, multi-line endless method
+#   def my_method() = x.foo
+#   .bar
+#   .baz
+# @example EnforcedStyle: allow_always
+#   # good
+#   def my_method() = x
+#
+#   # good
+#   def my_method() = x.foo
+#   .bar
+#   .baz
+# @example EnforcedStyle: disallow
+#   # bad
+#   def my_method() = x
+#
+#   # bad
+#   def my_method() = x.foo
+#   .bar
+#   .baz
+#
+# source://rubocop//lib/rubocop/cop/style/endless_method.rb#49
+class RuboCop::Cop::Style::EndlessMethod < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::TargetRubyVersion
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/endless_method.rb#60
+  def on_def(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/endless_method.rb#95
+  def arguments(node, missing = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/endless_method.rb#85
+  def correct_to_multiline(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/endless_method.rb#70
+  def handle_allow_style(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/endless_method.rb#79
+  def handle_disallow_style(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/endless_method.rb#56
+RuboCop::Cop::Style::EndlessMethod::CORRECTION_STYLES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/endless_method.rb#57
+RuboCop::Cop::Style::EndlessMethod::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/endless_method.rb#58
+RuboCop::Cop::Style::EndlessMethod::MSG_MULTI_LINE = T.let(T.unsafe(nil), String)
+
+# Checks for consistent usage of `ENV['HOME']`. If `nil` is used as
+# the second argument of `ENV.fetch`, it is treated as a bad case like `ENV[]`.
+#
+# @example
+#
+#   # bad
+#   ENV['HOME']
+#   ENV.fetch('HOME', nil)
+#
+#   # good
+#   Dir.home
+#
+#   # good
+#   ENV.fetch('HOME', default)
+#
+# source://rubocop//lib/rubocop/cop/style/env_home.rb#31
+class RuboCop::Cop::Style::EnvHome < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/env_home.rb#38
+  def env_home?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/env_home.rb#45
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/env_home.rb#34
+RuboCop::Cop::Style::EnvHome::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/env_home.rb#35
+RuboCop::Cop::Style::EnvHome::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Ensures that eval methods (`eval`, `instance_eval`, `class_eval`
+# and `module_eval`) are given filename and line number values (`\_\_FILE\_\_`
+# and `\_\_LINE\_\_`). This data is used to ensure that any errors raised
+# within the evaluated code will be given the correct identification
+# in a backtrace.
+#
+# The cop also checks that the line number given relative to `\_\_LINE\_\_` is
+# correct.
+#
+# This cop will autocorrect incorrect or missing filename and line number
+# values. However, if `eval` is called without a binding argument, the cop
+# will not attempt to automatically add a binding, or add filename and
+# line values.
+#
+# NOTE: This cop works only when a string literal is given as a code string.
+# No offense is reported if a string variable is given as below:
+#
+# [source,ruby]
+# ----
+# code = <<-RUBY
+#   def do_something
+#   end
+# RUBY
+# eval code # not checked.
+# ----
+#
+# @example
+#   # bad
+#   eval <<-RUBY
+#   def do_something
+#   end
+#   RUBY
+#
+#   # bad
+#   C.class_eval <<-RUBY
+#   def do_something
+#   end
+#   RUBY
+#
+#   # good
+#   eval <<-RUBY, binding, __FILE__, __LINE__ + 1
+#   def do_something
+#   end
+#   RUBY
+#
+#   # good
+#   C.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+#   def do_something
+#   end
+#   RUBY
+#
+# source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#57
+class RuboCop::Cop::Style::EvalWithLocation < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#75
+  def line_with_offset?(param0 = T.unsafe(nil), param1, param2); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#82
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#70
+  def valid_eval_receiver?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#187
+  def add_offense_for_different_line(node, line_node, line_diff); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#132
+  def add_offense_for_incorrect_line(method_name, line_node, sign, line_diff); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#202
+  def add_offense_for_missing_line(node, code); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#209
+  def add_offense_for_missing_location(node, code); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#181
+  def add_offense_for_same_line(node, line_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#144
+  def check_file(node, file_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#157
+  def check_line(node, code); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#96
+  def check_location(node, code); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#194
+  def expected_line(sign, line_diff); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#123
+  def file_and_line(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#169
+  def line_difference(line_node, code); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#221
+  def missing_line(node, code); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#110
+  def register_offense(node, &block); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#115
+  def special_file_keyword?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#119
+  def special_line_keyword?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#173
+  def string_first_line(str_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#128
+  def with_binding?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#60
+RuboCop::Cop::Style::EvalWithLocation::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#61
+RuboCop::Cop::Style::EvalWithLocation::MSG_EVAL = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#62
+RuboCop::Cop::Style::EvalWithLocation::MSG_INCORRECT_FILE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#64
+RuboCop::Cop::Style::EvalWithLocation::MSG_INCORRECT_LINE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/eval_with_location.rb#67
+RuboCop::Cop::Style::EvalWithLocation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for places where `Integer#even?` or `Integer#odd?`
+# can be used.
+#
+# @example
+#
+#   # bad
+#   if x % 2 == 0
+#   end
+#
+#   # good
+#   if x.even?
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/even_odd.rb#18
+class RuboCop::Cop::Style::EvenOdd < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/even_odd.rb#25
+  def even_odd_candidate?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/even_odd.rb#33
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/even_odd.rb#45
+  def replacement_method(arg, method); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/even_odd.rb#21
+RuboCop::Cop::Style::EvenOdd::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/even_odd.rb#22
+RuboCop::Cop::Style::EvenOdd::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for exact regexp match inside Regexp literals.
+#
+# @example
+#
+#   # bad
+#   string =~ /\Astring\z/
+#   string === /\Astring\z/
+#   string.match(/\Astring\z/)
+#   string.match?(/\Astring\z/)
+#
+#   # good
+#   string == 'string'
+#
+#   # bad
+#   string !~ /\Astring\z/
+#
+#   # good
+#   string != 'string'
+#
+# source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#25
+class RuboCop::Cop::Style::ExactRegexpMatch < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#32
+  def exact_regexp_match(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#40
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#40
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#57
+  def exact_match_pattern?(parsed_regexp); end
+
+  # source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#64
+  def new_method(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#28
+RuboCop::Cop::Style::ExactRegexpMatch::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/exact_regexp_match.rb#29
+RuboCop::Cop::Style::ExactRegexpMatch::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for use of the `File.expand_path` arguments.
+# Likewise, it also checks for the `Pathname.new` argument.
+#
+# Contrastive bad case and good case are alternately shown in
+# the following examples.
+#
+# @example
+#   # bad
+#   File.expand_path('..', __FILE__)
+#
+#   # good
+#   File.expand_path(__dir__)
+#
+#   # bad
+#   File.expand_path('../..', __FILE__)
+#
+#   # good
+#   File.expand_path('..', __dir__)
+#
+#   # bad
+#   File.expand_path('.', __FILE__)
+#
+#   # good
+#   File.expand_path(__FILE__)
+#
+#   # bad
+#   Pathname(__FILE__).parent.expand_path
+#
+#   # good
+#   Pathname(__dir__).expand_path
+#
+#   # bad
+#   Pathname.new(__FILE__).parent.expand_path
+#
+#   # good
+#   Pathname.new(__dir__).expand_path
+#
+# source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#43
+class RuboCop::Cop::Style::ExpandPathArguments < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#58
+  def file_expand_path(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#82
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#74
+  def pathname_new_parent_expand_path(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#66
+  def pathname_parent_expand_path(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#189
+  def arguments_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#100
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#135
+  def autocorrect_expand_path(corrector, current_path, default_dir); end
+
+  # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#162
+  def depth(current_path); end
+
+  # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#113
+  def inspect_offense_for_expand_path(node, current_path, default_dir); end
+
+  # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#168
+  def parent_path(current_path); end
+
+  # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#182
+  def remove_parent_method(corrector, default_dir); end
+
+  # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#155
+  def strip_surrounded_quotes!(path_string); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#109
+  def unrecommended_argument?(default_dir); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#47
+RuboCop::Cop::Style::ExpandPathArguments::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#49
+RuboCop::Cop::Style::ExpandPathArguments::PATHNAME_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#51
+RuboCop::Cop::Style::ExpandPathArguments::PATHNAME_NEW_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/expand_path_arguments.rb#55
+RuboCop::Cop::Style::ExpandPathArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Enforces the use of explicit block argument to avoid writing
+# block literal that just passes its arguments to another block.
+#
+# NOTE: This cop only registers an offense if the block args match the
+# yield args exactly.
+#
+# @example
+#   # bad
+#   def with_tmp_dir
+#   Dir.mktmpdir do |tmp_dir|
+#   Dir.chdir(tmp_dir) { |dir| yield dir } # block just passes arguments
+#   end
+#   end
+#
+#   # bad
+#   def nine_times
+#   9.times { yield }
+#   end
+#
+#   # good
+#   def with_tmp_dir(&block)
+#   Dir.mktmpdir do |tmp_dir|
+#   Dir.chdir(tmp_dir, &block)
+#   end
+#   end
+#
+#   with_tmp_dir do |dir|
+#   puts "dir is accessible as a parameter and pwd is set: #{dir}"
+#   end
+#
+#   # good
+#   def nine_times(&block)
+#   9.times(&block)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#41
+class RuboCop::Cop::Style::ExplicitBlockArgument < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # @return [ExplicitBlockArgument] a new instance of ExplicitBlockArgument
+  #
+  # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#57
+  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#62
+  def on_yield(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#49
+  def yielding_block?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#108
+  def add_block_argument(node, corrector, block_name); end
+
+  # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#147
+  def block_body_range(block_node, send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#125
+  def call_like?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#137
+  def correct_call_node(node, corrector, block_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#120
+  def empty_arguments?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#87
+  def extract_block_name(def_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#129
+  def insert_argument(node, corrector, block_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#95
+  def yielding_arguments?(block_args, yield_args); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#53
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/explicit_block_argument.rb#45
+RuboCop::Cop::Style::ExplicitBlockArgument::MSG = T.let(T.unsafe(nil), String)
+
+# Enforces consistency when using exponential notation
+# for numbers in the code (eg 1.2e4). Different styles are supported:
+#
+# * `scientific` which enforces a mantissa between 1 (inclusive) and 10 (exclusive).
+# * `engineering` which enforces the exponent to be a multiple of 3 and the mantissa
+#   to be between 0.1 (inclusive) and 10 (exclusive).
+# * `integral` which enforces the mantissa to always be a whole number without
+#   trailing zeroes.
+#
+# @example EnforcedStyle: scientific (default)
+#   # Enforces a mantissa between 1 (inclusive) and 10 (exclusive).
+#
+#   # bad
+#   10e6
+#   0.3e4
+#   11.7e5
+#   3.14e0
+#
+#   # good
+#   1e7
+#   3e3
+#   1.17e6
+#   3.14
+# @example EnforcedStyle: engineering
+#   # Enforces using multiple of 3 exponents,
+#   # mantissa should be between 0.1 (inclusive) and 1000 (exclusive)
+#
+#   # bad
+#   3.2e7
+#   0.1e5
+#   12e5
+#   1232e6
+#
+#   # good
+#   32e6
+#   10e3
+#   1.2e6
+#   1.232e9
+# @example EnforcedStyle: integral
+#   # Enforces the mantissa to have no decimal part and no
+#   # trailing zeroes.
+#
+#   # bad
+#   3.2e7
+#   0.1e5
+#   120e4
+#
+#   # good
+#   32e6
+#   1e4
+#   12e5
+#
+# source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#60
+class RuboCop::Cop::Style::ExponentialNotation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+
+  # source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#68
+  def on_float(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#79
+  def engineering?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#90
+  def integral(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#110
+  def message(_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#95
+  def offense?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#74
+  def scientific?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/exponential_notation.rb#62
+RuboCop::Cop::Style::ExponentialNotation::MESSAGES = T.let(T.unsafe(nil), Hash)
+
+# Suggests `ENV.fetch` for the replacement of `ENV[]`.
+# `ENV[]` silently fails and returns `nil` when the environment variable is unset,
+# which may cause unexpected behaviors when the developer forgets to set it.
+# On the other hand, `ENV.fetch` raises KeyError or returns the explicitly
+# specified default value.
+#
+# @example
+#   # bad
+#   ENV['X']
+#   x = ENV['X']
+#
+#   # good
+#   ENV.fetch('X')
+#   x = ENV.fetch('X')
+#
+#   # also good
+#   !ENV['X']
+#   ENV['X'].some_method # (e.g. `.nil?`)
+#
+# source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#25
+class RuboCop::Cop::Style::FetchEnvVar < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#31
+  def env_with_bracket?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#35
+  def on_send(node); end
+
+  private
+
+  # The following are allowed cases:
+  #
+  # - Used as a flag (e.g., `if ENV['X']` or `!ENV['X']`) because
+  #   it simply checks whether the variable is set.
+  # - Receiving a message with dot syntax, e.g. `ENV['X'].nil?`.
+  # - `ENV['key']` assigned by logical AND/OR assignment.
+  # - `ENV['key']` is the LHS of a `||`.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#105
+  def allowable_use?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#48
+  def allowed_var?(node); end
+
+  # The following are allowed cases:
+  #
+  # - `ENV['key']` is a receiver of `||=`, e.g. `ENV['X'] ||= y`.
+  # - `ENV['key']` is a receiver of `&&=`, e.g. `ENV['X'] &&= y`.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#113
+  def assigned?(node); end
+
+  # Check if the node is a receiver and receives a message with dot syntax.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#89
+  def message_chained_with_dot?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#126
+  def new_code(name_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#84
+  def offensive?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#120
+  def or_lhs?(node); end
+
+  # Avoid offending in the following cases:
+  # `ENV['key'] if ENV['key'] = x`
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#80
+  def partial_matched?(node, condition); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#53
+  def used_as_flag?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#60
+  def used_if_condition_in_body(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#69
+  def used_in_condition?(node, condition); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/fetch_env_var.rb#28
+RuboCop::Cop::Style::FetchEnvVar::MSG = T.let(T.unsafe(nil), String)
+
+# Prefer to use `File.empty?('path/to/file')` when checking if a file is empty.
+#
+# @example
+#   # bad
+#   File.zero?('path/to/file')
+#   File.size('path/to/file') == 0
+#   File.size('path/to/file') >= 0
+#   File.size('path/to/file').zero?
+#   File.read('path/to/file').empty?
+#   File.binread('path/to/file') == ''
+#   FileTest.zero?('path/to/file')
+#
+#   # good
+#   File.empty?('path/to/file')
+#   FileTest.empty?('path/to/file')
+#
+# source://rubocop//lib/rubocop/cop/style/file_empty.rb#27
+class RuboCop::Cop::Style::FileEmpty < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/file_empty.rb#37
+  def offensive?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/file_empty.rb#49
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/file_empty.rb#62
+  def bang(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/file_empty.rb#31
+RuboCop::Cop::Style::FileEmpty::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/file_empty.rb#32
+RuboCop::Cop::Style::FileEmpty::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Favor `File.(bin)read` convenience methods.
+#
+# @example
+#   # bad - text mode
+#   File.open(filename).read
+#   File.open(filename, &:read)
+#   File.open(filename) { |f| f.read }
+#   File.open(filename) do |f|
+#   f.read
+#   end
+#   File.open(filename, 'r').read
+#   File.open(filename, 'r', &:read)
+#   File.open(filename, 'r') do |f|
+#   f.read
+#   end
+#
+#   # good
+#   File.read(filename)
+#
+#   # bad - binary mode
+#   File.open(filename, 'rb').read
+#   File.open(filename, 'rb', &:read)
+#   File.open(filename, 'rb') do |f|
+#   f.read
+#   end
+#
+#   # good
+#   File.binread(filename)
+#
+# source://rubocop//lib/rubocop/cop/style/file_read.rb#35
+class RuboCop::Cop::Style::FileRead < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/file_read.rb#62
+  def block_read?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/file_read.rb#46
+  def file_open?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/file_read.rb#66
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/file_read.rb#57
+  def send_read?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/file_read.rb#81
+  def evidence(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/file_read.rb#97
+  def file_open_read?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/file_read.rb#103
+  def read_method(mode); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/file_read.rb#89
+  def read_node?(node, block_pass); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/file_read.rb#39
+RuboCop::Cop::Style::FileRead::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/file_read.rb#43
+RuboCop::Cop::Style::FileRead::READ_FILE_START_TO_FINISH_MODES = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/style/file_read.rb#41
+RuboCop::Cop::Style::FileRead::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Favor `File.(bin)write` convenience methods.
+#
+# NOTE: There are different method signatures between `File.write` (class method)
+# and `File#write` (instance method). The following case will be allowed because
+# static analysis does not know the contents of the splat argument:
+#
+# [source,ruby]
+# ----
+# File.open(filename, 'w') do |f|
+#   f.write(*objects)
+# end
+# ----
+#
+# @example
+#   # bad - text mode
+#   File.open(filename, 'w').write(content)
+#   File.open(filename, 'w') do |f|
+#   f.write(content)
+#   end
+#
+#   # good
+#   File.write(filename, content)
+#
+#   # bad - binary mode
+#   File.open(filename, 'wb').write(content)
+#   File.open(filename, 'wb') do |f|
+#   f.write(content)
+#   end
+#
+#   # good
+#   File.binwrite(filename, content)
+#
+# source://rubocop//lib/rubocop/cop/style/file_write.rb#38
+class RuboCop::Cop::Style::FileWrite < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/file_write.rb#65
+  def block_write?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/file_write.rb#82
+  def evidence(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/file_write.rb#49
+  def file_open?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/file_write.rb#69
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/file_write.rb#60
+  def send_write?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  # @yield [content]
+  #
+  # source://rubocop//lib/rubocop/cop/style/file_write.rb#92
+  def file_open_write?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/file_write.rb#120
+  def heredoc?(write_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/file_write.rb#125
+  def heredoc_range(first_argument); end
+
+  # source://rubocop//lib/rubocop/cop/style/file_write.rb#105
+  def replacement(mode, filename, content, write_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/file_write.rb#101
+  def write_method(mode); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/file_write.rb#42
+RuboCop::Cop::Style::FileWrite::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/file_write.rb#44
+RuboCop::Cop::Style::FileWrite::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/style/file_write.rb#46
+RuboCop::Cop::Style::FileWrite::TRUNCATING_WRITE_MODES = T.let(T.unsafe(nil), Set)
+
+# Checks for division with integers coerced to floats.
+# It is recommended to either always use `fdiv` or coerce one side only.
+# This cop also provides other options for code consistency.
+#
+# @example EnforcedStyle: single_coerce (default)
+#   # bad
+#   a.to_f / b.to_f
+#
+#   # good
+#   a.to_f / b
+#   a / b.to_f
+# @example EnforcedStyle: left_coerce
+#   # bad
+#   a / b.to_f
+#   a.to_f / b.to_f
+#
+#   # good
+#   a.to_f / b
+# @example EnforcedStyle: right_coerce
+#   # bad
+#   a.to_f / b
+#   a.to_f / b.to_f
+#
+#   # good
+#   a / b.to_f
+# @example EnforcedStyle: fdiv
+#   # bad
+#   a / b.to_f
+#   a.to_f / b
+#   a.to_f / b.to_f
+#
+#   # good
+#   a.fdiv(b)
+#
+# source://rubocop//lib/rubocop/cop/style/float_division.rb#53
+class RuboCop::Cop::Style::FloatDivision < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/float_division.rb#79
+  def any_coerce?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/float_division.rb#75
+  def both_coerce?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/float_division.rb#71
+  def left_coerce?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/float_division.rb#83
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/float_division.rb#67
+  def right_coerce?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/float_division.rb#121
+  def add_to_f_method(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/float_division.rb#130
+  def correct_from_slash_to_fdiv(corrector, node, receiver, argument); end
+
+  # source://rubocop//lib/rubocop/cop/style/float_division.rb#141
+  def extract_receiver_source(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/float_division.rb#117
+  def message(_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/float_division.rb#102
+  def offense_condition?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/float_division.rb#125
+  def remove_to_f_method(corrector, send_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/float_division.rb#57
+RuboCop::Cop::Style::FloatDivision::MESSAGES = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/style/float_division.rb#64
+RuboCop::Cop::Style::FloatDivision::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Looks for uses of the `for` keyword or `each` method. The
+# preferred alternative is set in the EnforcedStyle configuration
+# parameter. An `each` call with a block on a single line is always
+# allowed.
+#
+# @example EnforcedStyle: each (default)
+#   # bad
+#   def foo
+#   for n in [1, 2, 3] do
+#   puts n
+#   end
+#   end
+#
+#   # good
+#   def foo
+#   [1, 2, 3].each do |n|
+#   puts n
+#   end
+#   end
+# @example EnforcedStyle: for
+#   # bad
+#   def foo
+#   [1, 2, 3].each do |n|
+#   puts n
+#   end
+#   end
+#
+#   # good
+#   def foo
+#   for n in [1, 2, 3] do
+#   puts n
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/for.rb#45
+class RuboCop::Cop::Style::For < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/for.rb#65
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/for.rb#54
+  def on_for(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/for.rb#65
+  def on_numblock(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/for.rb#84
+  def suspect_enumerable?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/for.rb#50
+RuboCop::Cop::Style::For::EACH_LENGTH = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop//lib/rubocop/cop/style/for.rb#51
+RuboCop::Cop::Style::For::PREFER_EACH = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/for.rb#52
+RuboCop::Cop::Style::For::PREFER_FOR = T.let(T.unsafe(nil), String)
+
+# Enforces the use of a single string formatting utility.
+# Valid options include `Kernel#format`, `Kernel#sprintf`, and `String#%`.
+#
+# The detection of `String#%` cannot be implemented in a reliable
+# manner for all cases, so only two scenarios are considered -
+# if the first argument is a string literal and if the second
+# argument is an array literal.
+#
+# Autocorrection will be applied when using argument is a literal or known built-in conversion
+# methods such as `to_d`, `to_f`, `to_h`, `to_i`, `to_r`, `to_s`, and `to_sym` on variables,
+# provided that their return value is not an array. For example, when using `to_s`,
+# `'%s' % [1, 2, 3].to_s` can be autocorrected without any incompatibility:
+#
+# [source,ruby]
+# ----
+# '%s' % [1, 2, 3]        #=> '1'
+# format('%s', [1, 2, 3]) #=> '[1, 2, 3]'
+# '%s' % [1, 2, 3].to_s   #=> '[1, 2, 3]'
+# ----
+#
+# @example EnforcedStyle: format (default)
+#   # bad
+#   puts sprintf('%10s', 'foo')
+#   puts '%10s' % 'foo'
+#
+#   # good
+#   puts format('%10s', 'foo')
+# @example EnforcedStyle: sprintf
+#   # bad
+#   puts format('%10s', 'foo')
+#   puts '%10s' % 'foo'
+#
+#   # good
+#   puts sprintf('%10s', 'foo')
+# @example EnforcedStyle: percent
+#   # bad
+#   puts format('%10s', 'foo')
+#   puts sprintf('%10s', 'foo')
+#
+#   # good
+#   puts '%10s' % 'foo'
+#
+# source://rubocop//lib/rubocop/cop/style/format_string.rb#50
+class RuboCop::Cop::Style::FormatString < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/format_string.rb#61
+  def formatter(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string.rb#74
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string.rb#70
+  def variable_argument?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/format_string.rb#102
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string.rb#118
+  def autocorrect_from_percent(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string.rb#132
+  def autocorrect_to_percent(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/format_string.rb#88
+  def autocorrectable?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string.rb#145
+  def format_single_parameter(arg); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string.rb#94
+  def message(detected_style); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string.rb#98
+  def method_name(style_name); end
+end
+
+# Known conversion methods whose return value is not an array.
+#
+# source://rubocop//lib/rubocop/cop/style/format_string.rb#58
+RuboCop::Cop::Style::FormatString::AUTOCORRECTABLE_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/format_string.rb#54
+RuboCop::Cop::Style::FormatString::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/format_string.rb#55
+RuboCop::Cop::Style::FormatString::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Use a consistent style for named format string tokens.
+#
+# NOTE: `unannotated` style cop only works for strings
+# which are passed as arguments to those methods:
+# `printf`, `sprintf`, `format`, `%`.
+# The reason is that _unannotated_ format is very similar
+# to encoded URLs or Date/Time formatting strings.
+#
+# This cop's allowed methods can be customized with `AllowedMethods`.
+# By default, there are no allowed methods.
+#
+# It is allowed to contain unannotated token
+# if the number of them is less than or equals to
+# `MaxUnannotatedPlaceholdersAllowed`.
+#
+# @example AllowedPatterns: ['redirect']
+#
+#   # good
+#   redirect('foo/%{bar_id}')
+# @example EnforcedStyle: template
+#
+#   # bad
+#   format('%<greeting>s', greeting: 'Hello')
+#   format('%s', 'Hello')
+#
+#   # good
+#   format('%{greeting}', greeting: 'Hello')
+# @example EnforcedStyle: unannotated
+#
+#   # bad
+#   format('%<greeting>s', greeting: 'Hello')
+#   format('%{greeting}', greeting: 'Hello')
+#
+#   # good
+#   format('%s', 'Hello')
+# @example MaxUnannotatedPlaceholdersAllowed: 0
+#
+#   # bad
+#   format('%06d', 10)
+#   format('%s %s.', 'Hello', 'world')
+#
+#   # good
+#   format('%<number>06d', number: 10)
+# @example MaxUnannotatedPlaceholdersAllowed: 1 (default)
+#
+#   # bad
+#   format('%s %s.', 'Hello', 'world')
+#
+#   # good
+#   format('%06d', 10)
+# @example AllowedMethods: [] (default)
+#
+#   # bad
+#   redirect('foo/%{bar_id}')
+# @example AllowedMethods: [redirect]
+#
+#   # good
+#   redirect('foo/%{bar_id}')
+# @example AllowedPatterns: [] (default)
+#
+#   # bad
+#   redirect('foo/%{bar_id}')
+# @example EnforcedStyle: annotated (default)
+#
+#   # bad
+#   format('%{greeting}', greeting: 'Hello')
+#   format('%s', 'Hello')
+#
+#   # good
+#   format('%<greeting>s', greeting: 'Hello')
+#
+# source://rubocop//lib/rubocop/cop/style/format_string_token.rb#85
+class RuboCop::Cop::Style::FormatStringToken < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#106
+  def format_string_in_typical_context?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#91
+  def on_str(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#213
+  def allowed_unannotated?(detections); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#139
+  def autocorrect_sequence(corrector, detected_sequence, token_range); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#124
+  def check_sequence(detected_sequence, token_range); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#203
+  def collect_detections(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#135
+  def correctable_sequence?(detected_type); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#113
+  def format_string_token?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#222
+  def max_unannotated_placeholders_allowed; end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#160
+  def message(detected_style); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#165
+  def message_text(style); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#180
+  def str_contents(source_map); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#190
+  def token_ranges(contents); end
+
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#174
+  def tokens(str_node, &block); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#156
+  def unannotated_format?(node, detected_style); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/format_string_token.rb#117
+  def use_allowed_method?(node); end
+end
+
+# Helps you transition from mutable string literals
+# to frozen string literals.
+# of files to enable frozen string literals. Frozen string literals may be
+# default in future Ruby. The comment will be added below a shebang and
+# encoding comment. The frozen string literal comment is only valid in Ruby 2.3+.
+#
+# Note that the cop will accept files where the comment exists but is set
+# to `false` instead of `true`.
+#
+# To require a blank line after this comment, please see
+# `Layout/EmptyLineAfterMagicComment` cop.
+#
+# @example EnforcedStyle: always (default)
+#   # The `always` style will always add the frozen string literal comment
+#   # to a file, regardless of the Ruby version or if `freeze` or `<<` are
+#   # called on a string literal.
+#   # bad
+#   module Bar
+#   # ...
+#   end
+#
+#   # good
+#   # frozen_string_literal: true
+#
+#   module Bar
+#   # ...
+#   end
+#
+#   # good
+#   # frozen_string_literal: false
+#
+#   module Bar
+#   # ...
+#   end
+# @example EnforcedStyle: never
+#   # The `never` will enforce that the frozen string literal comment does
+#   # not exist in a file.
+#   # bad
+#   # frozen_string_literal: true
+#
+#   module Baz
+#   # ...
+#   end
+#
+#   # good
+#   module Baz
+#   # ...
+#   end
+# @example EnforcedStyle: always_true
+#   # The `always_true` style enforces that the frozen string literal
+#   # comment is set to `true`. This is a stricter option than `always`
+#   # and forces projects to use frozen string literals.
+#   # bad
+#   # frozen_string_literal: false
+#
+#   module Baz
+#   # ...
+#   end
+#
+#   # bad
+#   module Baz
+#   # ...
+#   end
+#
+#   # good
+#   # frozen_string_literal: true
+#
+#   module Bar
+#   # ...
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#84
+class RuboCop::Cop::Style::FrozenStringLiteralComment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::FrozenStringLiteral
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#99
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#178
+  def disabled_offense(processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#190
+  def enable_comment(corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#120
+  def ensure_comment(processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#126
+  def ensure_enabled_comment(processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#114
+  def ensure_no_comment(processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#214
+  def following_comment; end
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#152
+  def frozen_string_literal_comment(processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#196
+  def insert_comment(corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#137
+  def last_special_comment(processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#206
+  def line_range(line); end
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#158
+  def missing_offense(processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#164
+  def missing_true_offense(processed_source); end
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#210
+  def preceding_comment; end
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#186
+  def remove_comment(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#170
+  def unnecessary_comment_offense(processed_source); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#96
+RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_DISABLED = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#94
+RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_MISSING = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#93
+RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_MISSING_TRUE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#95
+RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_UNNECESSARY = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/frozen_string_literal_comment.rb#97
+RuboCop::Cop::Style::FrozenStringLiteralComment::SHEBANG = T.let(T.unsafe(nil), String)
+
+# Enforces the use of `$stdout/$stderr/$stdin` instead of `STDOUT/STDERR/STDIN`.
+# `STDOUT/STDERR/STDIN` are constants, and while you can actually
+# reassign (possibly to redirect some stream) constants in Ruby, you'll get
+# an interpreter warning if you do so.
+#
+# @example
+#   # bad
+#   STDOUT.puts('hello')
+#
+#   hash = { out: STDOUT, key: value }
+#
+#   def m(out = STDOUT)
+#   out.puts('hello')
+#   end
+#
+#   # good
+#   $stdout.puts('hello')
+#
+#   hash = { out: $stdout, key: value }
+#
+#   def m(out = $stdout)
+#   out.puts('hello')
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#34
+class RuboCop::Cop::Style::GlobalStdStream < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#42
+  def const_to_gvar_assignment?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#46
+  def on_const(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#70
+  def gvar_name(const_name); end
+
+  # source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#62
+  def message(const_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#66
+  def namespaced?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#37
+RuboCop::Cop::Style::GlobalStdStream::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/global_std_stream.rb#39
+RuboCop::Cop::Style::GlobalStdStream::STD_STREAMS = T.let(T.unsafe(nil), Set)
+
+# Looks for uses of global variables.
+# It does not report offenses for built-in global variables.
+# Built-in global variables are allowed by default. Additionally
+# users can allow additional variables via the AllowedVariables option.
+#
+# Note that backreferences like $1, $2, etc are not global variables.
+#
+# @example
+#   # bad
+#   $foo = 2
+#   bar = $foo + 5
+#
+#   # good
+#   FOO = 2
+#   foo = 2
+#   $stdin.read
+#
+# source://rubocop//lib/rubocop/cop/style/global_vars.rb#22
+class RuboCop::Cop::Style::GlobalVars < ::RuboCop::Cop::Base
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/global_vars.rb#60
+  def allowed_var?(global_var); end
+
+  # source://rubocop//lib/rubocop/cop/style/global_vars.rb#72
+  def check(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/global_vars.rb#64
+  def on_gvar(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/global_vars.rb#68
+  def on_gvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/global_vars.rb#56
+  def user_vars; end
+end
+
+# built-in global variables and their English aliases
+# https://www.zenspider.com/ruby/quickref.html
+#
+# source://rubocop//lib/rubocop/cop/style/global_vars.rb#27
+RuboCop::Cop::Style::GlobalVars::BUILT_IN_VARS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/global_vars.rb#23
+RuboCop::Cop::Style::GlobalVars::MSG = T.let(T.unsafe(nil), String)
+
+# Use a guard clause instead of wrapping the code inside a conditional
+# expression
+#
+# A condition with an `elsif` or `else` branch is allowed unless
+# one of `return`, `break`, `next`, `raise`, or `fail` is used
+# in the body of the conditional expression.
+#
+# NOTE: Autocorrect works in most cases except with if-else statements
+#   that contain logical operators such as `foo || raise('exception')`
+#
+# @example
+#   # bad
+#   def test
+#   if something
+#   work
+#   end
+#   end
+#
+#   # good
+#   def test
+#   return unless something
+#
+#   work
+#   end
+#
+#   # also good
+#   def test
+#   work if something
+#   end
+#
+#   # bad
+#   if something
+#   raise 'exception'
+#   else
+#   ok
+#   end
+#
+#   # good
+#   raise 'exception' if something
+#   ok
+#
+#   # bad
+#   if something
+#   foo || raise('exception')
+#   else
+#   ok
+#   end
+#
+#   # good
+#   foo || raise('exception') if something
+#   ok
+#
+#   # bad
+#   define_method(:test) do
+#   if something
+#   work
+#   end
+#   end
+#
+#   # good
+#   define_method(:test) do
+#   return unless something
+#
+#   work
+#   end
+#
+#   # also good
+#   define_method(:test) do
+#   work if something
+#   end
+# @example AllowConsecutiveConditionals: false (default)
+#   # bad
+#   def test
+#   if foo?
+#   work
+#   end
+#
+#   if bar?  # <- reports an offense
+#   work
+#   end
+#   end
+# @example AllowConsecutiveConditionals: true
+#   # good
+#   def test
+#   if foo?
+#   work
+#   end
+#
+#   if bar?
+#   work
+#   end
+#   end
+#
+#   # bad
+#   def test
+#   if foo?
+#   work
+#   end
+#
+#   do_something
+#
+#   if bar?  # <- reports an offense
+#   work
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/guard_clause.rb#114
+class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::MinBodyLength
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::LineLengthHelp
+  include ::RuboCop::Cop::StatementModifier
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#132
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#123
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#123
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#139
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#132
+  def on_numblock(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#275
+  def accepted_form?(node, ending: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#285
+  def accepted_if?(node, ending); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#299
+  def allowed_consecutive_conditionals?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#265
+  def and_or_guard_clause?(guard_clause); end
+
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#210
+  def autocorrect(corrector, node, condition, replacement, guard); end
+
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#236
+  def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard); end
+
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#159
+  def check_ending_body(body); end
+
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#170
+  def check_ending_if(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#180
+  def consecutive_conditionals?(parent, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#257
+  def guard_clause_source(guard_clause); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#232
+  def heredoc?(argument); end
+
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#248
+  def range_of_branch_to_remove(node, guard); end
+
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#188
+  def register_offense(node, scope_exiting_keyword, conditional_keyword, guard = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#295
+  def remove_whole_lines(corrector, range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#270
+  def too_long_for_single_line?(node, example); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/guard_clause.rb#279
+  def trivial?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/guard_clause.rb#120
+RuboCop::Cop::Style::GuardClause::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for presence or absence of braces around hash literal as a last
+# array item depending on configuration.
+#
+# NOTE: This cop will ignore arrays where all items are hashes, regardless of
+# EnforcedStyle.
+#
+# @example EnforcedStyle: braces (default)
+#   # bad
+#   [1, 2, one: 1, two: 2]
+#
+#   # good
+#   [1, 2, { one: 1, two: 2 }]
+#
+#   # good
+#   [{ one: 1 }, { two: 2 }]
+# @example EnforcedStyle: no_braces
+#   # bad
+#   [1, 2, { one: 1, two: 2 }]
+#
+#   # good
+#   [1, 2, one: 1, two: 2]
+#
+#   # good
+#   [{ one: 1 }, { two: 2 }]
+#
+# source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#31
+class RuboCop::Cop::Style::HashAsLastArrayItem < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#36
+  def on_hash(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#85
+  def braces_style?; end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#66
+  def check_braces(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#74
+  def check_no_braces(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#50
+  def containing_array(hash_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#61
+  def explicit_array?(array); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#55
+  def last_array_item?(array, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_as_last_array_item.rb#89
+  def remove_last_element_trailing_comma(corrector, node); end
+end
+
+# Checks the usage of pre-2.1 `Hash[args]` method of converting enumerables and
+# sequences of values to hashes.
+#
+# Correction code from splat argument (`Hash[*ary]`) is not simply determined. For example,
+# `Hash[*ary]` can be replaced with `ary.each_slice(2).to_h` but it will be complicated.
+# So, `AllowSplatArgument` option is true by default to allow splat argument for simple code.
+#
+# @example
+#   # bad
+#   Hash[ary]
+#
+#   # good
+#   ary.to_h
+#
+#   # bad
+#   Hash[key1, value1, key2, value2]
+#
+#   # good
+#   {key1 => value1, key2 => value2}
+# @example AllowSplatArgument: true (default)
+#   # good
+#   Hash[*ary]
+# @example AllowSplatArgument: false
+#   # bad
+#   Hash[*ary]
+#
+# source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#44
+class RuboCop::Cop::Style::HashConversion < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#54
+  def hash_from_array?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#56
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#138
+  def allowed_splat_argument?; end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#131
+  def args_to_hash(args); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#118
+  def multi_argument(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#94
+  def register_offense_for_hash(node, hash_argument); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#103
+  def register_offense_for_zip_method(node, zip_method); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#113
+  def requires_parens?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#71
+  def single_argument(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#88
+  def use_zip_method_without_argument?(first_argument); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#49
+RuboCop::Cop::Style::HashConversion::MSG_LITERAL_HASH_ARG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#48
+RuboCop::Cop::Style::HashConversion::MSG_LITERAL_MULTI_ARG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#50
+RuboCop::Cop::Style::HashConversion::MSG_SPLAT = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#47
+RuboCop::Cop::Style::HashConversion::MSG_TO_H = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/hash_conversion.rb#51
+RuboCop::Cop::Style::HashConversion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for uses of `each_key` and `each_value` Hash methods.
+#
+# NOTE: If you have an array of two-element arrays, you can put
+#   parentheses around the block arguments to indicate that you're not
+#   working with a hash, and suppress RuboCop offenses.
+#
+# @example
+#   # bad
+#   hash.keys.each { |k| p k }
+#   hash.each { |k, unused_value| p k }
+#
+#   # good
+#   hash.each_key { |k| p k }
+#
+#   # bad
+#   hash.values.each { |v| p v }
+#   hash.each { |unused_key, v| p v }
+#
+#   # good
+#   hash.each_value { |v| p v }
+# @example AllowedReceivers: ['execute']
+#   # good
+#   execute(sql).keys.each { |v| p v }
+#   execute(sql).values.each { |v| p v }
+#
+# source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#36
+class RuboCop::Cop::Style::HashEachMethods < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedReceivers
+  include ::RuboCop::Cop::Lint::UnusedArgument
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#79
+  def check_unused_block_args(node, key, value); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#51
+  def each_arguments(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#61
+  def hash_mutated?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#46
+  def kv_each(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#56
+  def kv_each_with_block_pass(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#65
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#100
+  def on_block_pass(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#65
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#186
+  def check_argument(variable); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#210
+  def correct_args(node, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#196
+  def correct_implicit(node, corrector, method_name); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#201
+  def correct_key_value_each(node, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#182
+  def format_message(method_name, current); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#108
+  def handleable?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#217
+  def kv_range(outer_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#139
+  def message(prefer, method_name, unused_code); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#145
+  def register_each_args_offense(node, message, prefer, unused_range); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#116
+  def register_kv_offense(target, method); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#152
+  def register_kv_with_block_pass_offense(node, target, method); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#173
+  def root_receiver(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#127
+  def unused_block_arg_exist?(node, block_arg); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#163
+  def use_array_converter_method_as_preceding?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#192
+  def used?(arg); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#43
+RuboCop::Cop::Style::HashEachMethods::ARRAY_CONVERTER_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#41
+RuboCop::Cop::Style::HashEachMethods::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/hash_each_methods.rb#42
+RuboCop::Cop::Style::HashEachMethods::UNUSED_BLOCK_ARG_MSG = T.let(T.unsafe(nil), String)
+
+# Checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods
+# that can be replaced with `Hash#except` method.
+#
+# This cop should only be enabled on Ruby version 3.0 or higher.
+# (`Hash#except` was added in Ruby 3.0.)
+#
+# For safe detection, it is limited to commonly used string and symbol comparisons
+# when used `==`.
+# And do not check `Hash#delete_if` and `Hash#keep_if` to change receiver object.
+#
+# @example
+#
+#   # bad
+#   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k == :bar }
+#   {foo: 1, bar: 2, baz: 3}.select {|k, v| k != :bar }
+#   {foo: 1, bar: 2, baz: 3}.filter {|k, v| k != :bar }
+#   {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[bar].include?(k) }
+#   {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[bar].include?(k) }
+#   {foo: 1, bar: 2, baz: 3}.filter {|k, v| !%i[bar].include?(k) }
+#
+#   # good
+#   {foo: 1, bar: 2, baz: 3}.except(:bar)
+#
+# source://rubocop//lib/rubocop/cop/style/hash_except.rb#33
+class RuboCop::Cop::Style::HashExcept < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::TargetRubyVersion
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/hash_except.rb#60
+  def bad_method_with_active_support?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_except.rb#44
+  def bad_method_with_poro?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_except.rb#75
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_except.rb#75
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_except.rb#95
+  def bad_method?(method_name, block); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_except.rb#169
+  def decorate_source(value); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_except.rb#177
+  def except_key(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_except.rb#156
+  def except_key_source(key); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_except.rb#150
+  def extract_body_if_negated(body); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_except.rb#131
+  def included?(negated, body); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_except.rb#135
+  def not_included?(negated, body); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_except.rb#186
+  def offense_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_except.rb#139
+  def safe_to_register_offense?(block, except_key); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_except.rb#115
+  def semantically_except_method?(send, block); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/hash_except.rb#40
+RuboCop::Cop::Style::HashExcept::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/hash_except.rb#41
+RuboCop::Cop::Style::HashExcept::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for places where `case-when` represents a simple 1:1
+# mapping and can be replaced with a hash lookup.
+#
+# @example MinBranchesCount: 3 (default)
+#   # bad
+#   case country
+#   when 'europe'
+#   'http://eu.example.com'
+#   when 'america'
+#   'http://us.example.com'
+#   when 'australia'
+#   'http://au.example.com'
+#   end
+#
+#   # good
+#   SITES = {
+#   'europe'    => 'http://eu.example.com',
+#   'america'   => 'http://us.example.com',
+#   'australia' => 'http://au.example.com'
+#   }
+#   SITES[country]
+# @example MinBranchesCount: 4
+#   # good
+#   case country
+#   when 'europe'
+#   'http://eu.example.com'
+#   when 'america'
+#   'http://us.example.com'
+#   when 'australia'
+#   'http://au.example.com'
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/hash_like_case.rb#39
+class RuboCop::Cop::Style::HashLikeCase < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::MinBranchesCount
+
+  # source://rubocop//lib/rubocop/cop/style/hash_like_case.rb#45
+  def hash_like_case?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_like_case.rb#53
+  def on_case(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_like_case.rb#65
+  def nodes_of_same_type?(nodes); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/hash_like_case.rb#42
+RuboCop::Cop::Style::HashLikeCase::MSG = T.let(T.unsafe(nil), String)
+
+# Checks hash literal syntax.
+#
+# It can enforce either the use of the class hash rocket syntax or
+# the use of the newer Ruby 1.9 syntax (when applicable).
+#
+# A separate offense is registered for each problematic pair.
+#
+# The supported styles are:
+#
+# * ruby19 - forces use of the 1.9 syntax (e.g. `{a: 1}`) when hashes have
+# all symbols for keys
+# * hash_rockets - forces use of hash rockets for all hashes
+# * no_mixed_keys - simply checks for hashes with mixed syntaxes
+# * ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed
+# syntax hashes
+#
+# This cop has `EnforcedShorthandSyntax` option.
+# It can enforce either the use of the explicit hash value syntax or
+# the use of Ruby 3.1's hash value shorthand syntax.
+#
+# The supported styles are:
+#
+# * always - forces use of the 3.1 syntax (e.g. {foo:})
+# * never - forces use of explicit hash literal value
+# * either - accepts both shorthand and explicit use of hash literal value
+# * consistent - forces use of the 3.1 syntax only if all values can be omitted in the hash
+# * either_consistent - accepts both shorthand and explicit use of hash literal value,
+#                       but they must be consistent
+#
+# @example EnforcedShorthandSyntax: either_consistent
+#
+#   # good - `foo` and `bar` values can be omitted, but they are consistent, so it's accepted
+#   {foo: foo, bar: bar}
+#
+#   # bad - `bar` value can be omitted
+#   {foo:, bar: bar}
+#
+#   # bad - mixed syntaxes
+#   {foo:, bar: baz}
+#
+#   # good
+#   {foo:, bar:}
+#
+#   # good - can't omit `baz`
+#   {foo: foo, bar: baz}
+# @example EnforcedStyle: hash_rockets
+#   # bad
+#   {a: 1, b: 2}
+#   {c: 1, 'd' => 5}
+#
+#   # good
+#   {:a => 1, :b => 2}
+# @example EnforcedStyle: no_mixed_keys
+#   # bad
+#   {:a => 1, b: 2}
+#   {c: 1, 'd' => 2}
+#
+#   # good
+#   {:a => 1, :b => 2}
+#   {c: 1, d: 2}
+# @example EnforcedStyle: ruby19_no_mixed_keys
+#   # bad
+#   {:a => 1, :b => 2}
+#   {c: 2, 'd' => 3} # should just use hash rockets
+#
+#   # good
+#   {a: 1, b: 2}
+#   {:c => 3, 'd' => 4}
+# @example EnforcedShorthandSyntax: always
+#
+#   # bad
+#   {foo: foo, bar: bar}
+#
+#   # good
+#   {foo:, bar:}
+# @example EnforcedShorthandSyntax: never
+#
+#   # bad
+#   {foo:, bar:}
+#
+#   # good
+#   {foo: foo, bar: bar}
+# @example EnforcedShorthandSyntax: either (default)
+#
+#   # good
+#   {foo: foo, bar: bar}
+#
+#   # good
+#   {foo: foo, bar:}
+#
+#   # good
+#   {foo:, bar:}
+# @example EnforcedShorthandSyntax: consistent
+#
+#   # bad - `foo` and `bar` values can be omitted
+#   {foo: foo, bar: bar}
+#
+#   # bad - `bar` value can be omitted
+#   {foo:, bar: bar}
+#
+#   # bad - mixed syntaxes
+#   {foo:, bar: baz}
+#
+#   # good
+#   {foo:, bar:}
+#
+#   # good - can't omit `baz`
+#   {foo: foo, bar: baz}
+# @example EnforcedStyle: ruby19 (default)
+#   # bad
+#   {:a => 2}
+#   {b: 1, :c => 2}
+#
+#   # good
+#   {a: 2, b: 1}
+#   {:c => 2, 'd' => 2} # acceptable since 'd' isn't a symbol
+#   {d: 1, 'e' => 2} # technically not forbidden
+#
+# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#131
+class RuboCop::Cop::Style::HashSyntax < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::HashShorthandSyntax
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#185
+  def alternative_style; end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#163
+  def hash_rockets_check(pairs); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#177
+  def no_mixed_keys_check(pairs); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#141
+  def on_hash(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#159
+  def ruby19_check(pairs); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#167
+  def ruby19_no_mixed_keys_check(pairs); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#217
+  def acceptable_19_syntax_symbol?(sym_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#274
+  def argument_without_space?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#196
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#278
+  def autocorrect_hash_rockets(corrector, pair_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#287
+  def autocorrect_no_mixed_keys(corrector, pair_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#253
+  def autocorrect_ruby19(corrector, pair_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#238
+  def check(pairs, delim, msg); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#295
+  def force_hash_rockets?(pairs); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#266
+  def range_for_autocorrect_ruby19(pair_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#206
+  def sym_indices?(pairs); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#210
+  def word_symbol_pair?(pair); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#137
+RuboCop::Cop::Style::HashSyntax::MSG_19 = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#139
+RuboCop::Cop::Style::HashSyntax::MSG_HASH_ROCKETS = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/hash_syntax.rb#138
+RuboCop::Cop::Style::HashSyntax::MSG_NO_MIXED_KEYS = T.let(T.unsafe(nil), String)
+
+# Looks for uses of `\_.each_with_object({}) {...}`,
+# `\_.map {...}.to_h`, and `Hash[\_.map {...}]` that are actually just
+# transforming the keys of a hash, and tries to use a simpler & faster
+# call to `transform_keys` instead.
+# It should only be enabled on Ruby version 2.5 or newer.
+# (`transform_keys` was added in Ruby 2.5.)
+#
+# @example
+#   # bad
+#   {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[foo(k)] = v }
+#   Hash[{a: 1, b: 2}.collect { |k, v| [foo(k), v] }]
+#   {a: 1, b: 2}.map { |k, v| [k.to_s, v] }.to_h
+#   {a: 1, b: 2}.to_h { |k, v| [k.to_s, v] }
+#
+#   # good
+#   {a: 1, b: 2}.transform_keys { |k| foo(k) }
+#   {a: 1, b: 2}.transform_keys { |k| k.to_s }
+#
+# source://rubocop//lib/rubocop/cop/style/hash_transform_keys.rb#28
+class RuboCop::Cop::Style::HashTransformKeys < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::HashTransformMethod
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/hash_transform_keys.rb#36
+  def on_bad_each_with_object(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_transform_keys.rb#48
+  def on_bad_hash_brackets_map(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_transform_keys.rb#61
+  def on_bad_map_to_h(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_transform_keys.rb#73
+  def on_bad_to_h(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/hash_transform_keys.rb#84
+  def extract_captures(match); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_transform_keys.rb#89
+  def new_method_name; end
+end
+
+# Looks for uses of `\_.each_with_object({}) {...}`,
+# `\_.map {...}.to_h`, and `Hash[\_.map {...}]` that are actually just
+# transforming the values of a hash, and tries to use a simpler & faster
+# call to `transform_values` instead.
+#
+# @example
+#   # bad
+#   {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[k] = foo(v) }
+#   Hash[{a: 1, b: 2}.collect { |k, v| [k, foo(v)] }]
+#   {a: 1, b: 2}.map { |k, v| [k, v * v] }.to_h
+#   {a: 1, b: 2}.to_h { |k, v| [k, v * v] }
+#
+#   # good
+#   {a: 1, b: 2}.transform_values { |v| foo(v) }
+#   {a: 1, b: 2}.transform_values { |v| v * v }
+#
+# source://rubocop//lib/rubocop/cop/style/hash_transform_values.rb#26
+class RuboCop::Cop::Style::HashTransformValues < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::HashTransformMethod
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/hash_transform_values.rb#34
+  def on_bad_each_with_object(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_transform_values.rb#46
+  def on_bad_hash_brackets_map(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_transform_values.rb#59
+  def on_bad_map_to_h(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_transform_values.rb#71
+  def on_bad_to_h(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/hash_transform_values.rb#82
+  def extract_captures(match); end
+
+  # source://rubocop//lib/rubocop/cop/style/hash_transform_values.rb#87
+  def new_method_name; end
+end
+
+# Checks for identical expressions at the beginning or end of
+# each branch of a conditional expression. Such expressions should normally
+# be placed outside the conditional expression - before or after it.
+#
+# NOTE: The cop is poorly named and some people might think that it actually
+# checks for duplicated conditional branches. The name will probably be changed
+# in a future major RuboCop release.
+#
+# @example
+#   # bad
+#   if condition
+#   do_x
+#   do_z
+#   else
+#   do_y
+#   do_z
+#   end
+#
+#   # good
+#   if condition
+#   do_x
+#   else
+#   do_y
+#   end
+#   do_z
+#
+#   # bad
+#   if condition
+#   do_z
+#   do_x
+#   else
+#   do_z
+#   do_y
+#   end
+#
+#   # good
+#   do_z
+#   if condition
+#   do_x
+#   else
+#   do_y
+#   end
+#
+#   # bad
+#   case foo
+#   when 1
+#   do_x
+#   when 2
+#   do_x
+#   else
+#   do_x
+#   end
+#
+#   # good
+#   case foo
+#   when 1
+#   do_x
+#   do_y
+#   when 2
+#   # nothing
+#   else
+#   do_x
+#   do_z
+#   end
+#
+#   # bad
+#   case foo
+#   in 1
+#   do_x
+#   in 2
+#   do_x
+#   else
+#   do_x
+#   end
+#
+#   # good
+#   case foo
+#   in 1
+#   do_x
+#   do_y
+#   in 2
+#   # nothing
+#   else
+#   do_x
+#   do_z
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#110
+class RuboCop::Cop::Style::IdenticalConditionalBranches < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#123
+  def on_case(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#130
+  def on_case_match(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#116
+  def on_if(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#184
+  def assignable_condition_value(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#140
+  def check_branches(node, branches); end
+
+  # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#193
+  def check_expressions(node, expressions, insert_position); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#173
+  def duplicated_expressions?(node, expressions); end
+
+  # `elsif` branches show up in the if node as nested `else` branches. We
+  # need to recursively iterate over all `else` branches.
+  #
+  # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#233
+  def expand_elses(branch); end
+
+  # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#248
+  def head(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#217
+  def last_child_of_parent?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#227
+  def message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#223
+  def single_child_branch?(branch_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#244
+  def tail(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/identical_conditional_branches.rb#114
+RuboCop::Cop::Style::IdenticalConditionalBranches::MSG = T.let(T.unsafe(nil), String)
+
+# Corrector to correct conditional assignment in `if` statements.
+#
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#559
+class RuboCop::Cop::Style::IfCorrector
+  extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper
+  extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#564
+    def correct(corrector, cop, node); end
+
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#568
+    def move_assignment_inside_condition(corrector, node); end
+
+    private
+
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#582
+    def extract_tail_branches(node); end
+
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#589
+    def move_branch_inside_condition(corrector, branch, condition, assignment, column); end
+  end
+end
+
+# If the `else` branch of a conditional consists solely of an `if` node,
+# it can be combined with the `else` to become an `elsif`.
+# This helps to keep the nesting level from getting too deep.
+#
+# @example
+#   # bad
+#   if condition_a
+#   action_a
+#   else
+#   if condition_b
+#   action_b
+#   else
+#   action_c
+#   end
+#   end
+#
+#   # good
+#   if condition_a
+#   action_a
+#   elsif condition_b
+#   action_b
+#   else
+#   action_c
+#   end
+# @example AllowIfModifier: false (default)
+#   # bad
+#   if condition_a
+#   action_a
+#   else
+#   action_b if condition_b
+#   end
+#
+#   # good
+#   if condition_a
+#   action_a
+#   elsif condition_b
+#   action_b
+#   end
+# @example AllowIfModifier: true
+#   # good
+#   if condition_a
+#   action_a
+#   else
+#   action_b if condition_b
+#   end
+#
+#   # good
+#   if condition_a
+#   action_a
+#   elsif condition_b
+#   action_b
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#61
+class RuboCop::Cop::Style::IfInsideElse < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#69
+  def on_if(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#150
+  def allow_if_modifier?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#146
+  def allow_if_modifier_in_else_branch?(else_branch); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#88
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#117
+  def correct_to_elsif_from_if_inside_else_form(corrector, node, condition); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#109
+  def correct_to_elsif_from_modifier_form(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#135
+  def find_end_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#142
+  def if_condition_range(node, condition); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#131
+  def then?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/if_inside_else.rb#66
+RuboCop::Cop::Style::IfInsideElse::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for `if` and `unless` statements that would fit on one line if
+# written as modifier `if`/`unless`. The cop also checks for modifier
+# `if`/`unless` lines that exceed the maximum line length.
+#
+# The maximum line length is configured in the `Layout/LineLength`
+# cop. The tab size is configured in the `IndentationWidth` of the
+# `Layout/IndentationStyle` cop.
+#
+# One-line pattern matching is always allowed. To ensure that there are few cases
+# where the match variable is not used, and to prevent oversights. The variable `x`
+# becomes undefined and raises `NameError` when the following example is changed to
+# the modifier form:
+#
+# [source,ruby]
+# ----
+# if [42] in [x]
+#   x # `x` is undefined when using modifier form.
+# end
+# ----
+#
+# NOTE: It is allowed when `defined?` argument has an undefined value,
+# because using the modifier form causes the following incompatibility:
+#
+# [source,ruby]
+# ----
+# unless defined?(undefined_foo)
+#   undefined_foo = 'default_value'
+# end
+# undefined_foo # => 'default_value'
+#
+# undefined_bar = 'default_value' unless defined?(undefined_bar)
+# undefined_bar # => nil
+# ----
+#
+# @example
+#   # bad
+#   if condition
+#   do_stuff(bar)
+#   end
+#
+#   unless qux.empty?
+#   Foo.do_something
+#   end
+#
+#   do_something_with_a_long_name(arg) if long_condition_that_prevents_code_fit_on_single_line
+#
+#   # good
+#   do_stuff(bar) if condition
+#   Foo.do_something unless qux.empty?
+#
+#   if long_condition_that_prevents_code_fit_on_single_line
+#   do_something_with_a_long_name(arg)
+#   end
+#
+#   if short_condition # a long comment that makes it too long if it were just a single line
+#   do_something
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#63
+class RuboCop::Cop::Style::IfUnlessModifier < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::LineLengthHelp
+  include ::RuboCop::Cop::StatementModifier
+  include ::RuboCop::Cop::AllowedPattern
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::CommentsHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#80
+  def on_if(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#171
+  def allowed_patterns; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#231
+  def another_statement_on_same_line?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#132
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#285
+  def comment_on_node_line(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#104
+  def defined_argument_is_undefined?(if_node, defined_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#96
+  def defined_nodes(condition); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#272
+  def extract_heredoc_from(last_argument); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#215
+  def line_length_enabled_at_line?(line); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#124
+  def message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#219
+  def named_capture_in_condition?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#223
+  def non_eligible_node?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#227
+  def non_simple_if_unless?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#114
+  def pattern_matching_nodes(condition); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#289
+  def remove_comment(corrector, _node, comment); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#279
+  def remove_heredoc(corrector, heredoc); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#141
+  def replacement_for_modifier_form(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#265
+  def to_modifier_form_with_move_comment(node, indentation, comment); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#245
+  def to_normal_form(node, indentation); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#253
+  def to_normal_form_with_heredoc(node, indentation, heredoc); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#165
+  def too_long_due_to_comment_after_modifier?(node, comment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#160
+  def too_long_due_to_modifier?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#206
+  def too_long_line_based_on_allow_uri?(line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#189
+  def too_long_line_based_on_config?(range, line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#198
+  def too_long_line_based_on_ignore_cop_directives?(range, line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#176
+  def too_long_single_line?(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#76
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#71
+RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_MODIFIER = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/if_unless_modifier.rb#74
+RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_NORMAL = T.let(T.unsafe(nil), String)
+
+# Checks for if and unless statements used as modifiers of other if or
+# unless statements.
+#
+# @example
+#
+#   # bad
+#   tired? ? 'stop' : 'go faster' if running?
+#
+#   # bad
+#   if tired?
+#   "please stop"
+#   else
+#   "keep going"
+#   end if running?
+#
+#   # good
+#   if running?
+#   tired? ? 'stop' : 'go faster'
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/if_unless_modifier_of_if_unless.rb#25
+class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::LineLengthHelp
+  include ::RuboCop::Cop::StatementModifier
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/if_unless_modifier_of_if_unless.rb#31
+  def on_if(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/if_unless_modifier_of_if_unless.rb#29
+RuboCop::Cop::Style::IfUnlessModifierOfIfUnless::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for redundant `if` with boolean literal branches.
+# It checks only conditions to return boolean value (`true` or `false`) for safe detection.
+# The conditions to be checked are comparison methods, predicate methods, and
+# double negation (!!).
+# `nonzero?` method is allowed by default.
+# These are customizable with `AllowedMethods` option.
+#
+# This cop targets only `if`s with a single `elsif` or `else` branch. The following
+# code will be allowed, because it has two `elsif` branches:
+#
+# [source,ruby]
+# ----
+# if foo
+#   true
+# elsif bar > baz
+#   true
+# elsif qux > quux # Single `elsif` is warned, but two or more `elsif`s are not.
+#   true
+# else
+#   false
+# end
+# ----
+#
+# @example
+#   # bad
+#   if foo == bar
+#   true
+#   else
+#   false
+#   end
+#
+#   # bad
+#   foo == bar ? true : false
+#
+#   # good
+#   foo == bar
+#
+#   # bad
+#   if foo.do_something?
+#   true
+#   else
+#   false
+#   end
+#
+#   # good (but potentially an unsafe correction)
+#   foo.do_something?
+# @example AllowedMethods: ['nonzero?'] (default)
+#   # good
+#   num.nonzero? ? true : false
+#
+# source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#61
+class RuboCop::Cop::Style::IfWithBooleanLiteralBranches < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#73
+  def double_negative?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#69
+  def if_with_boolean_literal_branches?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#75
+  def on_if(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#135
+  def assume_boolean_value?(condition); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#113
+  def message(node, keyword); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#95
+  def multiple_elsif?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#101
+  def offense_range_with_keyword(node, condition); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#152
+  def opposite_condition?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#142
+  def replacement_condition(node, condition); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#157
+  def require_parentheses?(condition); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#121
+  def return_boolean_value?(condition); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#65
+RuboCop::Cop::Style::IfWithBooleanLiteralBranches::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/if_with_boolean_literal_branches.rb#66
+RuboCop::Cop::Style::IfWithBooleanLiteralBranches::MSG_FOR_ELSIF = T.let(T.unsafe(nil), String)
+
+# Checks for uses of semicolon in if statements.
+#
+# @example
+#
+#   # bad
+#   result = if some_condition; something else another_thing end
+#
+#   # good
+#   result = some_condition ? something : another_thing
+#
+# source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#16
+class RuboCop::Cop::Style::IfWithSemicolon < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::OnNormalIfUnless
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#24
+  def on_normal_if_unless(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#54
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#93
+  def build_else_branch(second_condition); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#84
+  def build_expression(expr); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#75
+  def correct_elsif(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#40
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#66
+  def replacement(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#113
+  def require_argument_parentheses?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#62
+  def use_block_in_branches?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#20
+RuboCop::Cop::Style::IfWithSemicolon::MSG_IF_ELSE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#21
+RuboCop::Cop::Style::IfWithSemicolon::MSG_NEWLINE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/if_with_semicolon.rb#22
+RuboCop::Cop::Style::IfWithSemicolon::MSG_TERNARY = T.let(T.unsafe(nil), String)
+
+# Checks for `raise` or `fail` statements which do not specify an
+# explicit exception class. (This raises a `RuntimeError`. Some projects
+# might prefer to use exception classes which more precisely identify the
+# nature of the error.)
+#
+# @example
+#   # bad
+#   raise 'Error message here'
+#
+#   # good
+#   raise ArgumentError, 'Error message here'
+#
+# source://rubocop//lib/rubocop/cop/style/implicit_runtime_error.rb#17
+class RuboCop::Cop::Style::ImplicitRuntimeError < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/style/implicit_runtime_error.rb#23
+  def implicit_runtime_error_raise_or_fail(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/implicit_runtime_error.rb#26
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/implicit_runtime_error.rb#18
+RuboCop::Cop::Style::ImplicitRuntimeError::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/implicit_runtime_error.rb#20
+RuboCop::Cop::Style::ImplicitRuntimeError::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for `in;` uses in `case` expressions.
+#
+# @example
+#   # bad
+#   case expression
+#   in pattern_a; foo
+#   in pattern_b; bar
+#   end
+#
+#   # good
+#   case expression
+#   in pattern_a then foo
+#   in pattern_b then bar
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/in_pattern_then.rb#21
+class RuboCop::Cop::Style::InPatternThen < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/in_pattern_then.rb#29
+  def on_in_pattern(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/in_pattern_then.rb#46
+  def alternative_pattern_source(pattern); end
+
+  # source://rubocop//lib/rubocop/cop/style/in_pattern_then.rb#50
+  def collect_alternative_patterns(pattern); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/in_pattern_then.rb#27
+RuboCop::Cop::Style::InPatternThen::MSG = T.let(T.unsafe(nil), String)
+
+# Use `Kernel#loop` for infinite loops.
+#
+# @example
+#   # bad
+#   while true
+#   work
+#   end
+#
+#   # good
+#   loop do
+#   work
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#23
+class RuboCop::Cop::Style::InfiniteLoop < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#35
+  def after_leaving_scope(scope, _variable_table); end
+
+  # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#44
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#44
+  def on_until_post(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#40
+  def on_while(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#40
+  def on_while_post(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#84
+  def assigned_before_loop?(var, range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#80
+  def assigned_inside_loop?(var, range); end
+
+  # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#70
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#103
+  def modifier_replacement(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#114
+  def non_modifier_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#89
+  def referenced_after_loop?(var, range); end
+
+  # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#94
+  def replace_begin_end_with_modifier(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#99
+  def replace_source(corrector, range, replacement); end
+
+  # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#53
+  def while_or_until(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#31
+    def joining_forces; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#27
+RuboCop::Cop::Style::InfiniteLoop::LEADING_SPACE = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/infinite_loop.rb#29
+RuboCop::Cop::Style::InfiniteLoop::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for trailing inline comments.
+#
+# @example
+#
+#   # good
+#   foo.each do |f|
+#   # Standalone comment
+#   f.bar
+#   end
+#
+#   # bad
+#   foo.each do |f|
+#   f.bar # Trailing inline comment
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/inline_comment.rb#20
+class RuboCop::Cop::Style::InlineComment < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/style/inline_comment.rb#23
+  def on_new_investigation; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/inline_comment.rb#21
+RuboCop::Cop::Style::InlineComment::MSG = T.let(T.unsafe(nil), String)
+
+# Check for usages of not (`not` or `!`) called on a method
+# when an inverse of that method can be used instead.
+#
+# Methods that can be inverted by a not (`not` or `!`) should be defined
+# in `InverseMethods`.
+#
+# Methods that are inverted by inverting the return
+# of the block that is passed to the method should be defined in
+# `InverseBlocks`.
+#
+# @example
+#   # bad
+#   !foo.none?
+#   !foo.any? { |f| f.even? }
+#   !foo.blank?
+#   !(foo == bar)
+#   foo.select { |f| !f.even? }
+#   foo.reject { |f| f != 7 }
+#
+#   # good
+#   foo.none?
+#   foo.blank?
+#   foo.any? { |f| f.even? }
+#   foo != bar
+#   foo == bar
+#   !!('foo' =~ /^\w+$/)
+#   !(foo.class < Numeric) # Checking class hierarchy is allowed
+#   # Blocks with guard clauses are ignored:
+#   foo.select do |f|
+#   next if f.zero?
+#   f != 1
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#43
+class RuboCop::Cop::Style::InverseMethods < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#70
+  def inverse_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#61
+  def inverse_candidate?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#92
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#78
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#92
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#78
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#177
+  def camel_case_constant?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#121
+  def correct_inverse_block(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#112
+  def correct_inverse_method(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#128
+  def correct_inverse_selector(block, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#181
+  def dot_range(loc); end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#166
+  def end_parentheses(node, method_call); end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#150
+  def inverse_blocks; end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#145
+  def inverse_methods; end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#191
+  def message(method, inverse); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#154
+  def negated?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#162
+  def not_to_receiver(node, method_call); end
+
+  # When comparing classes, `!(Integer < Numeric)` is not the same as
+  # `Integer > Numeric`.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#172
+  def possible_class_hierarchy_check?(lhs, rhs, method); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#158
+  def relational_comparison_with_safe_navigation?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#185
+  def remove_end_parenthesis(corrector, node, method, method_call); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#56
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#52
+RuboCop::Cop::Style::InverseMethods::CAMEL_CASE = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#49
+RuboCop::Cop::Style::InverseMethods::CLASS_COMPARISON_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#50
+RuboCop::Cop::Style::InverseMethods::EQUALITY_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#48
+RuboCop::Cop::Style::InverseMethods::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#51
+RuboCop::Cop::Style::InverseMethods::NEGATED_EQUALITY_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/inverse_methods.rb#54
+RuboCop::Cop::Style::InverseMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for usages of `unless` which can be replaced by `if` with inverted condition.
+# Code without `unless` is easier to read, but that is subjective, so this cop
+# is disabled by default.
+#
+# Methods that can be inverted should be defined in `InverseMethods`. Note that
+# the relationship of inverse methods needs to be defined in both directions.
+# For example,
+#
+# [source,yaml]
+# ----
+# InverseMethods:
+#   :!=: :==
+#   :even?: :odd?
+#   :odd?: :even?
+# ----
+#
+# will suggest both `even?` and `odd?` to be inverted, but only `!=` (and not `==`).
+#
+# @example
+#   # bad (simple condition)
+#   foo unless !bar
+#   foo unless x != y
+#   foo unless x >= 10
+#   foo unless x.even?
+#   foo unless odd?
+#
+#   # good
+#   foo if bar
+#   foo if x == y
+#   foo if x < 10
+#   foo if x.odd?
+#   foo if even?
+#
+#   # bad (complex condition)
+#   foo unless x != y || x.even?
+#
+#   # good
+#   foo if x == y && x.odd?
+#
+#   # good (if)
+#   foo if !condition
+#
+# source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#53
+class RuboCop::Cop::Style::InvertibleUnlessCondition < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#58
+  def on_if(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#133
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#146
+  def autocorrect_send_node(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#90
+  def inheritance_check?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#154
+  def inverse_methods; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#75
+  def invertible?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#96
+  def preferred_condition(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#126
+  def preferred_logical_condition(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#104
+  def preferred_send_condition(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/invertible_unless_condition.rb#56
+RuboCop::Cop::Style::InvertibleUnlessCondition::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for hardcoded IP addresses, which can make code
+# brittle. IP addresses are likely to need to be changed when code
+# is deployed to a different server or environment, which may break
+# a deployment if forgotten. Prefer setting IP addresses in ENV or
+# other configuration.
+#
+# @example
+#
+#   # bad
+#   ip_address = '127.59.241.29'
+#
+#   # good
+#   ip_address = ENV['DEPLOYMENT_IP_ADDRESS']
+#
+# source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#21
+class RuboCop::Cop::Style::IpAddresses < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::StringHelp
+
+  # Dummy implementation of method in ConfigurableEnforcedStyle that is
+  # called from StringHelp.
+  #
+  # source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#46
+  def correct_style_detected; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#27
+  def offense?(node); end
+
+  # Dummy implementation of method in ConfigurableEnforcedStyle that is
+  # called from StringHelp.
+  #
+  # source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#42
+  def opposite_style_detected; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#50
+  def allowed_addresses; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#55
+  def could_be_ip?(str); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#68
+  def starts_with_hex_or_colon?(str); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#64
+  def too_long?(str); end
+end
+
+# IPv4-mapped IPv6 is the longest
+#
+# source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#24
+RuboCop::Cop::Style::IpAddresses::IPV6_MAX_SIZE = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop//lib/rubocop/cop/style/ip_addresses.rb#25
+RuboCop::Cop::Style::IpAddresses::MSG = T.let(T.unsafe(nil), String)
+
+# Enforces that optional keyword parameters are placed at the
+# end of the parameters list.
+#
+# This improves readability, because when looking through the source,
+# it is expected to find required parameters at the beginning of parameters list
+# and optional parameters at the end.
+#
+# @example
+#   # bad
+#   def some_method(first: false, second:, third: 10)
+#   # body omitted
+#   end
+#
+#   # good
+#   def some_method(second:, first: false, third: 10)
+#   # body omitted
+#   end
+#
+#   # bad
+#   do_something do |first: false, second:, third: 10|
+#   # body omitted
+#   end
+#
+#   # good
+#   do_something do |second:, first: false, third: 10|
+#   # body omitted
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/keyword_parameters_order.rb#34
+class RuboCop::Cop::Style::KeywordParametersOrder < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/keyword_parameters_order.rb#40
+  def on_kwoptarg(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/keyword_parameters_order.rb#58
+  def append_newline_to_last_kwoptarg(arguments, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/keyword_parameters_order.rb#66
+  def remove_kwargs(kwarg_nodes, corrector); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/keyword_parameters_order.rb#38
+RuboCop::Cop::Style::KeywordParametersOrder::MSG = T.let(T.unsafe(nil), String)
+
+# (by default) checks for uses of the lambda literal syntax for
+# single line lambdas, and the method call syntax for multiline lambdas.
+# It is configurable to enforce one of the styles for both single line
+# and multiline lambdas as well.
+#
+# @example EnforcedStyle: line_count_dependent (default)
+#   # bad
+#   f = lambda { |x| x }
+#   f = ->(x) do
+#   x
+#   end
+#
+#   # good
+#   f = ->(x) { x }
+#   f = lambda do |x|
+#   x
+#   end
+# @example EnforcedStyle: lambda
+#   # bad
+#   f = ->(x) { x }
+#   f = ->(x) do
+#   x
+#   end
+#
+#   # good
+#   f = lambda { |x| x }
+#   f = lambda do |x|
+#   x
+#   end
+# @example EnforcedStyle: literal
+#   # bad
+#   f = lambda { |x| x }
+#   f = lambda do |x|
+#   x
+#   end
+#
+#   # good
+#   f = ->(x) { x }
+#   f = ->(x) do
+#   x
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/lambda.rb#49
+class RuboCop::Cop::Style::Lambda < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/lambda.rb#64
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/lambda.rb#64
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/lambda.rb#115
+  def arguments_with_whitespace(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/lambda.rb#104
+  def autocorrect_method_to_literal(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/lambda.rb#119
+  def lambda_arg_string(args); end
+
+  # source://rubocop//lib/rubocop/cop/style/lambda.rb#89
+  def message(node, selector); end
+
+  # source://rubocop//lib/rubocop/cop/style/lambda.rb#95
+  def message_line_modifier(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/lambda.rb#83
+  def offending_selector?(node, selector); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/lambda.rb#53
+RuboCop::Cop::Style::Lambda::LITERAL_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/lambda.rb#54
+RuboCop::Cop::Style::Lambda::METHOD_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/lambda.rb#56
+RuboCop::Cop::Style::Lambda::OFFENDING_SELECTORS = T.let(T.unsafe(nil), Hash)
+
+# Checks for use of the lambda.(args) syntax.
+#
+# @example EnforcedStyle: call (default)
+#   # bad
+#   lambda.(x, y)
+#
+#   # good
+#   lambda.call(x, y)
+# @example EnforcedStyle: braces
+#   # bad
+#   lambda.call(x, y)
+#
+#   # good
+#   lambda.(x, y)
+#
+# source://rubocop//lib/rubocop/cop/style/lambda_call.rb#21
+class RuboCop::Cop::Style::LambdaCall < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/lambda_call.rb#29
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/lambda_call.rb#67
+  def explicit_style?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/lambda_call.rb#63
+  def implicit_style?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/lambda_call.rb#51
+  def offense?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/lambda_call.rb#55
+  def prefer(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/lambda_call.rb#26
+RuboCop::Cop::Style::LambdaCall::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/lambda_call.rb#27
+RuboCop::Cop::Style::LambdaCall::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for string literal concatenation at
+# the end of a line.
+#
+# @example
+#
+#   # bad
+#   some_str = 'ala' +
+#   'bala'
+#
+#   some_str = 'ala' <<
+#   'bala'
+#
+#   # good
+#   some_str = 'ala' \
+#   'bala'
+#
+# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#35
+class RuboCop::Cop::Style::LineEndConcatenation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#51
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#74
+  def autocorrect(corrector, operator_range); end
+
+  # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#57
+  def check_token_set(index); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#101
+  def eligible_next_successor?(next_successor); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#97
+  def eligible_operator?(operator); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#105
+  def eligible_predecessor?(predecessor); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#93
+  def eligible_successor?(successor); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#87
+  def eligible_token_set?(predecessor, operator, successor); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#124
+  def standard_string_literal?(token); end
+
+  # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#109
+  def token_after_last_string(successor, base_index); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#47
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#42
+RuboCop::Cop::Style::LineEndConcatenation::COMPLEX_STRING_BEGIN_TOKEN = T.let(T.unsafe(nil), Symbol)
+
+# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#43
+RuboCop::Cop::Style::LineEndConcatenation::COMPLEX_STRING_END_TOKEN = T.let(T.unsafe(nil), Symbol)
+
+# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#40
+RuboCop::Cop::Style::LineEndConcatenation::CONCAT_TOKEN_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#44
+RuboCop::Cop::Style::LineEndConcatenation::HIGH_PRECEDENCE_OP_TOKEN_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#39
+RuboCop::Cop::Style::LineEndConcatenation::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#45
+RuboCop::Cop::Style::LineEndConcatenation::QUOTE_DELIMITERS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/line_end_concatenation.rb#41
+RuboCop::Cop::Style::LineEndConcatenation::SIMPLE_STRING_TOKEN_TYPE = T.let(T.unsafe(nil), Symbol)
+
+# Ensures magic comments are written consistently throughout your code base.
+# Looks for discrepancies in separators (`-` vs `_`) and capitalization for
+# both magic comment directives and values.
+#
+# Required capitalization can be set with the `DirectiveCapitalization` and
+# `ValueCapitalization` configuration keys.
+#
+# NOTE: If one of these configuration is set to nil, any capitalization is allowed.
+#
+# @example ValueCapitalization: uppercase
+#   # bad
+#   # frozen-string-literal: true
+#
+#   # good
+#   # frozen-string-literal: TRUE
+# @example EnforcedStyle: kebab_case
+#   # The `kebab_case` style will enforce that the frozen string literal
+#   # comment is written in kebab case. (Words separated by hyphens)
+#   # bad
+#   # frozen_string_literal: true
+#
+#   module Baz
+#   # ...
+#   end
+#
+#   # good
+#   # frozen-string-literal: true
+#
+#   module Baz
+#   # ...
+#   end
+# @example DirectiveCapitalization: lowercase (default)
+#   # bad
+#   # FROZEN-STRING-LITERAL: true
+#
+#   # good
+#   # frozen-string-literal: true
+# @example DirectiveCapitalization: uppercase
+#   # bad
+#   # frozen-string-literal: true
+#
+#   # good
+#   # FROZEN-STRING-LITERAL: true
+# @example DirectiveCapitalization: nil
+#   # any capitalization is accepted
+#
+#   # good
+#   # frozen-string-literal: true
+#
+#   # good
+#   # FROZEN-STRING-LITERAL: true
+# @example ValueCapitalization: nil (default)
+#   # any capitalization is accepted
+#
+#   # good
+#   # frozen-string-literal: true
+#
+#   # good
+#   # frozen-string-literal: TRUE
+# @example ValueCapitalization: lowercase
+#   # when a value is not given, any capitalization is accepted
+#
+#   # bad
+#   # frozen-string-literal: TRUE
+#
+#   # good
+#   # frozen-string-literal: TRUE
+# @example EnforcedStyle: snake_case (default)
+#   # The `snake_case` style will enforce that the frozen string literal
+#   # comment is written in snake case. (Words separated by underscores)
+#   # bad
+#   # frozen-string-literal: true
+#
+#   module Bar
+#   # ...
+#   end
+#
+#   # good
+#   # frozen_string_literal: false
+#
+#   module Bar
+#   # ...
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#97
+class RuboCop::Cop::Style::MagicCommentFormat < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#156
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#241
+  def correct_separator; end
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#279
+  def directive_capitalization; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#197
+  def directive_offends?(directive); end
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#233
+  def expected_style; end
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#183
+  def find_issues(comment); end
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#207
+  def fix_directives(issues); end
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#221
+  def fix_values(issues); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#245
+  def incorrect_separator?(text); end
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#173
+  def leading_comment_lines; end
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#275
+  def line_range(line); end
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#167
+  def magic_comments; end
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#202
+  def register_offenses(issues); end
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#264
+  def replace_capitalization(text, style); end
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#260
+  def replace_separator(text); end
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#301
+  def supported_capitalizations; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#295
+  def valid_capitalization?(style); end
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#287
+  def value_capitalization; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#249
+  def wrong_capitalization?(text, expected_case); end
+
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#237
+  def wrong_separator; end
+end
+
+# Value object to extract source ranges for the different parts of a magic comment
+#
+# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#107
+class RuboCop::Cop::Style::MagicCommentFormat::CommentRange
+  extend ::RuboCop::SimpleForwardable
+
+  # @return [CommentRange] a new instance of CommentRange
+  #
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#119
+  def initialize(comment); end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#117
+  def comment; end
+
+  # A magic comment can contain one directive (normal style) or
+  # multiple directives (emacs style)
+  #
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#125
+  def directives; end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def loc(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop-ast/1.32.3/lib/rubocop/ast/utilities/simple_forwardable.rb#9
+  def text(*_arg0, **_arg1, &_arg2); end
+
+  # A magic comment can contain one value (normal style) or
+  # multiple directives (emacs style)
+  #
+  # source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#141
+  def values; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#110
+RuboCop::Cop::Style::MagicCommentFormat::CommentRange::DIRECTIVE_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#114
+RuboCop::Cop::Style::MagicCommentFormat::CommentRange::VALUE_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#102
+RuboCop::Cop::Style::MagicCommentFormat::KEBAB_SEPARATOR = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#103
+RuboCop::Cop::Style::MagicCommentFormat::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#104
+RuboCop::Cop::Style::MagicCommentFormat::MSG_VALUE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/magic_comment_format.rb#101
+RuboCop::Cop::Style::MagicCommentFormat::SNAKE_SEPARATOR = T.let(T.unsafe(nil), String)
+
+# Prefer `select` or `reject` over `map { ... }.compact`.
+# This cop also handles `filter_map { ... }`, similar to `map { ... }.compact`.
+#
+# @example
+#
+#   # bad
+#   array.map { |e| some_condition? ? e : next }.compact
+#
+#   # bad
+#   array.filter_map { |e| some_condition? ? e : next }
+#
+#   # bad
+#   array.map do |e|
+#   if some_condition?
+#   e
+#   else
+#   next
+#   end
+#   end.compact
+#
+#   # bad
+#   array.map do |e|
+#   next if some_condition?
+#
+#   e
+#   end.compact
+#
+#   # bad
+#   array.map do |e|
+#   e if some_condition?
+#   end.compact
+#
+#   # good
+#   array.select { |e| some_condition? }
+#
+#   # good
+#   array.reject { |e| some_condition? }
+#
+# source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#44
+class RuboCop::Cop::Style::MapCompactWithConditionalBlock < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#51
+  def conditional_block(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#76
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#76
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#148
+  def current(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#162
+  def filter_map_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#96
+  def inspect(node, block_argument_node, condition_node, return_value_node, range); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#158
+  def map_with_compact_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#114
+  def returns_block_argument?(block_argument_node, return_value_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#118
+  def truthy_branch?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#138
+  def truthy_branch_for_guard?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#128
+  def truthy_branch_for_if?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#47
+RuboCop::Cop::Style::MapCompactWithConditionalBlock::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/map_compact_with_conditional_block.rb#48
+RuboCop::Cop::Style::MapCompactWithConditionalBlock::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for usages of `each` with `<<`, `push`, or `append` which
+# can be replaced by `map`.
+#
+# If `PreferredMethods` is configured for `map` in `Style/CollectionMethods`,
+# this cop uses the specified method for replacement.
+#
+# NOTE: The return value of `Enumerable#each` is `self`, whereas the
+# return value of `Enumerable#map` is an `Array`. They are not autocorrected
+# when a return value could be used because these types differ.
+#
+# NOTE: It only detects when the mapping destination is either:
+# * a local variable initialized as an empty array and referred to only by the
+# pushing operation;
+# * or, if it is the single block argument to a `[].tap` block.
+# This is because, if not, it's challenging to statically guarantee that the
+# mapping destination variable remains an empty array:
+#
+# [source,ruby]
+# ----
+# ret = []
+# src.each { |e| ret << e * 2 } # `<<` method may mutate `ret`
+#
+# dest = []
+# src.each { |e| dest << transform(e, dest) } # `transform` method may mutate `dest`
+# ----
+#
+# @example
+#   # bad
+#   dest = []
+#   src.each { |e| dest << e * 2 }
+#   dest
+#
+#   # good
+#   dest = src.map { |e| e * 2 }
+#
+#   # bad
+#   [].tap do |dest|
+#   src.each { |e| dest << e * 2 }
+#   end
+#
+#   # good
+#   dest = src.map { |e| e * 2 }
+#
+#   # good - contains another operation
+#   dest = []
+#   src.each { |e| dest << e * 2; puts e }
+#   dest
+#
+# source://rubocop//lib/rubocop/cop/style/map_into_array.rb#60
+class RuboCop::Cop::Style::MapIntoArray < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#104
+  def after_leaving_scope(scope, _variable_table); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#67
+  def each_block_with_push?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#76
+  def empty_array_asgn?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#88
+  def empty_array_tap(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#98
+  def lvar_ref?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#108
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#108
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#208
+  def correct_push_node(corrector, push_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#216
+  def correct_return_value_handling(corrector, block, dest_var); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#151
+  def dest_used_only_for_mapping?(block, dest_var, asgn); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#145
+  def find_closest_assignment(block, dest_var); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#128
+  def find_dest_var(block); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#176
+  def new_method_name; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#136
+  def offending_empty_array_tap?(node, dest_var); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#159
+  def register_offense(block, dest_var, asgn); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#195
+  def remove_assignment(corrector, asgn); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#202
+  def remove_tap(corrector, node, block_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#182
+  def return_value_used?(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/map_into_array.rb#100
+    def joining_forces; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/map_into_array.rb#64
+RuboCop::Cop::Style::MapIntoArray::MSG = T.let(T.unsafe(nil), String)
+
+# Looks for uses of `map.to_h` or `collect.to_h` that could be
+# written with just `to_h` in Ruby >= 2.6.
+#
+# NOTE: `Style/HashTransformKeys` and `Style/HashTransformValues` will
+# also change this pattern if only hash keys or hash values are being
+# transformed.
+#
+# @example
+#   # bad
+#   something.map { |v| [v, v * 2] }.to_h
+#
+#   # good
+#   something.to_h { |v| [v, v * 2] }
+#
+#   # bad
+#   {foo: bar}.collect { |k, v| [k.to_s, v.do_something] }.to_h
+#
+#   # good
+#   {foo: bar}.to_h { |k, v| [k.to_s, v.do_something] }
+#
+# source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#30
+class RuboCop::Cop::Style::MapToHash < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#41
+  def map_to_h(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#52
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#52
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#68
+  def autocorrect(corrector, to_h, map); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#48
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#37
+RuboCop::Cop::Style::MapToHash::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/map_to_hash.rb#38
+RuboCop::Cop::Style::MapToHash::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Looks for uses of `map.to_set` or `collect.to_set` that could be
+# written with just `to_set`.
+#
+# @example
+#   # bad
+#   something.map { |i| i * 2 }.to_set
+#
+#   # good
+#   something.to_set { |i| i * 2 }
+#
+#   # bad
+#   [1, 2, 3].collect { |i| i.to_s }.to_set
+#
+#   # good
+#   [1, 2, 3].to_set { |i| i.to_s }
+#
+# source://rubocop//lib/rubocop/cop/style/map_to_set.rb#26
+class RuboCop::Cop::Style::MapToSet < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/map_to_set.rb#34
+  def map_to_set?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/map_to_set.rb#41
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/map_to_set.rb#55
+  def autocorrect(corrector, to_set, map); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/map_to_set.rb#30
+RuboCop::Cop::Style::MapToSet::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/map_to_set.rb#31
+RuboCop::Cop::Style::MapToSet::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Enforces the presence (default) or absence of parentheses in
+# method calls containing arguments.
+#
+# In the default style (require_parentheses), macro methods are allowed.
+# Additional methods can be added to the `AllowedMethods` or
+# `AllowedPatterns` list. These options are valid only in the default
+# style. Macros can be included by either setting `IgnoreMacros` to false
+# or adding specific macros to the `IncludedMacros` list.
+#
+# Precedence of options is as follows:
+#
+# 1. `AllowedMethods`
+# 2. `AllowedPatterns`
+# 3. `IncludedMacros`
+#
+# If a method is listed in both `IncludedMacros` and `AllowedMethods`,
+# then the latter takes precedence (that is, the method is allowed).
+#
+# In the alternative style (omit_parentheses), there are three additional
+# options.
+#
+# 1. `AllowParenthesesInChaining` is `false` by default. Setting it to
+#    `true` allows the presence of parentheses in the last call during
+#    method chaining.
+#
+# 2. `AllowParenthesesInMultilineCall` is `false` by default. Setting it
+#     to `true` allows the presence of parentheses in multi-line method
+#     calls.
+#
+# 3. `AllowParenthesesInCamelCaseMethod` is `false` by default. This
+#     allows the presence of parentheses when calling a method whose name
+#     begins with a capital letter and which has no arguments. Setting it
+#     to `true` allows the presence of parentheses in such a method call
+#     even with arguments.
+#
+# NOTE: The style of `omit_parentheses` allows parentheses in cases where
+# omitting them results in ambiguous or syntactically incorrect code.
+#
+# Non-exhaustive list of examples:
+#
+# - Parentheses are required allowed in method calls with arguments inside
+#   literals, logical operators, setting default values in position and
+#   keyword arguments, chaining and more.
+# - Parentheses are allowed in method calls with arguments inside
+#   operators to avoid ambiguity.
+#   triple-dot syntax introduced in Ruby 2.7 as omitting them starts an
+#   endless range.
+# - Parentheses are allowed when forwarding arguments with the
+#   triple-dot syntax introduced in Ruby 2.7 as omitting them starts an
+#   endless range.
+# - Parentheses are required in calls with arguments when inside an
+#   endless method definition introduced in Ruby 3.0.
+# - Ruby 3.1's hash omission syntax allows parentheses if the method call
+#   is in conditionals and requires parentheses if the call
+#   is not the value-returning expression. See
+#   https://bugs.ruby-lang.org/issues/18396.
+# - Parentheses are required in anonymous arguments, keyword arguments
+#   and block passing in Ruby 3.2.
+#
+# @example AllowParenthesesInStringInterpolation: true
+#
+#   # good
+#   "#{t('this.is.good')}"
+#
+#   # good
+#   "#{t 'this.is.also.good'}"
+# @example EnforcedStyle: omit_parentheses
+#
+#   # bad
+#   array.delete(e)
+#
+#   # good
+#   array.delete e
+#
+#   # bad
+#   action.enforce(strict: true)
+#
+#   # good
+#   action.enforce strict: true
+#
+#   # good
+#   # Parentheses are allowed for code that can be ambiguous without
+#   # them.
+#   action.enforce(condition) || other_condition
+#
+#   # good
+#   # Parentheses are allowed for calls that won't produce valid Ruby
+#   # without them.
+#   yield path, File.basename(path)
+#
+#   # good
+#   # Omitting the parentheses in Ruby 3.1 hash omission syntax can lead
+#   # to ambiguous code. We allow them in conditionals and non-last
+#   # expressions. See https://bugs.ruby-lang.org/issues/18396
+#   if meets(criteria:, action:)
+#   safe_action(action) || dangerous_action(action)
+#   end
+# @example IgnoreMacros: true (default)
+#
+#   # good
+#   class Foo
+#   bar :baz
+#   end
+# @example IgnoreMacros: false
+#
+#   # bad
+#   class Foo
+#   bar :baz
+#   end
+# @example AllowParenthesesInMultilineCall: false (default)
+#
+#   # bad
+#   foo.enforce(
+#   strict: true
+#   )
+#
+#   # good
+#   foo.enforce \
+#   strict: true
+# @example AllowParenthesesInMultilineCall: true
+#
+#   # good
+#   foo.enforce(
+#   strict: true
+#   )
+#
+#   # good
+#   foo.enforce \
+#   strict: true
+# @example AllowParenthesesInChaining: false (default)
+#
+#   # bad
+#   foo().bar(1)
+#
+#   # good
+#   foo().bar 1
+# @example AllowParenthesesInChaining: true
+#
+#   # good
+#   foo().bar(1)
+#
+#   # good
+#   foo().bar 1
+# @example AllowParenthesesInCamelCaseMethod: false (default)
+#
+#   # bad
+#   Array(1)
+#
+#   # good
+#   Array 1
+# @example AllowParenthesesInCamelCaseMethod: true
+#
+#   # good
+#   Array(1)
+#
+#   # good
+#   Array 1
+# @example AllowParenthesesInStringInterpolation: false (default)
+#
+#   # bad
+#   "#{t('this.is.bad')}"
+#
+#   # good
+#   "#{t 'this.is.better'}"
+# @example EnforcedStyle: require_parentheses (default)
+#
+#   # bad
+#   array.delete e
+#
+#   # good
+#   array.delete(e)
+#
+#   # good
+#   # Operators don't need parens
+#   foo == bar
+#
+#   # good
+#   # Setter methods don't need parens
+#   foo.bar = baz
+#
+#   # okay with `puts` listed in `AllowedMethods`
+#   puts 'test'
+#
+#   # okay with `^assert` listed in `AllowedPatterns`
+#   assert_equal 'test', x
+#
+# source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#202
+class RuboCop::Cop::Style::MethodCallWithArgsParentheses < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+  include ::RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#217
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#217
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#217
+  def on_yield(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#225
+  def args_begin(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#233
+  def args_end(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#237
+  def args_parenthesized?(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses.rb#213
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# Style omit_parentheses
+#
+# source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#9
+module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
+  include ::RuboCop::Cop::RangeHelp
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#80
+  def allowed_camel_case_method_call?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#184
+  def allowed_chained_call_with_parentheses?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#180
+  def allowed_multiline_call_with_parentheses?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#85
+  def allowed_string_interpolation_method_call?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#193
+  def ambiguous_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#222
+  def assigned_before?(node, target); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#230
+  def assignment_in_condition?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#34
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#161
+  def call_as_argument_or_chain?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#154
+  def call_in_argument_with_block?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#110
+  def call_in_literals?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#121
+  def call_in_logical_operators?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#167
+  def call_in_match_pattern?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#130
+  def call_in_optional_arguments?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#134
+  def call_in_single_line_inheritance?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#138
+  def call_with_ambiguous_arguments?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#150
+  def call_with_braced_block?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#240
+  def forwards_anonymous_rest_arguments?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#209
+  def hash_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#173
+  def hash_literal_in_arguments?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#50
+  def inside_endless_method_def?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#226
+  def inside_string_interpolation?(node); end
+
+  # Require hash value omission be enclosed in parentheses to prevent the following issue:
+  # https://bugs.ruby-lang.org/issues/18396.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#64
+  def last_expression?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#97
+  def legitimate_call_with_parentheses?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#205
+  def logical_operator?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#72
+  def method_call_before_constant_resolution?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#46
+  def offense_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#18
+  def omit_parentheses(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#90
+  def parentheses_at_the_end_of_multiline_call?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#213
+  def regexp_slash_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#55
+  def require_parentheses_for_hash_value_omission?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#197
+  def splat?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#76
+  def super_call_without_arguments?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#68
+  def syntax_like_method_call?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#201
+  def ternary_if?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#217
+  def unary_literal?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#13
+RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses::OMIT_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb#12
+RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses::TRAILING_WHITESPACE_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# Style require_parentheses
+#
+# source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb#8
+module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb#27
+  def allowed_method_name?(name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb#31
+  def eligible_for_parentheses_omission?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb#39
+  def ignored_macro?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb#35
+  def included_macros_list; end
+
+  # source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb#14
+  def require_parentheses(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb#9
+RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses::REQUIRE_MSG = T.let(T.unsafe(nil), String)
+
+# Checks for unwanted parentheses in parameterless method calls.
+#
+# This cop's allowed methods can be customized with `AllowedMethods`.
+# By default, there are no allowed methods.
+#
+# NOTE: This cop allows the use of `it()` without arguments in blocks,
+# as in `0.times { it() }`, following `Lint/ItWithoutArgumentsInBlock` cop.
+#
+# @example
+#   # bad
+#   object.some_method()
+#
+#   # good
+#   object.some_method
+# @example AllowedMethods: [] (default)
+#   # bad
+#   object.foo()
+# @example AllowedMethods: [foo]
+#   # good
+#   object.foo()
+#
+# source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#29
+class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#37
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#66
+  def allowed_method_name?(name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#94
+  def any_assignment?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#62
+  def default_argument?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#58
+  def ineligible_node?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#117
+  def offense_range(node); end
+
+  # Respects `Lint/ItWithoutArgumentsInBlock` cop and the following Ruby 3.3's warning:
+  #
+  # $ ruby -e '0.times { begin; it; end }'
+  # -e:1: warning: `it` calls without arguments will refer to the first block param in
+  # Ruby 3.4; use it() or self.it
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#86
+  def parenthesized_it_method_in_block?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#51
+  def register_offense(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#70
+  def same_name_assignment?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#110
+  def variable_in_mass_assignment?(variable_name, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/method_call_without_args_parentheses.rb#34
+RuboCop::Cop::Style::MethodCallWithoutArgsParentheses::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for methods called on a do...end block. The point of
+# this check is that it's easy to miss the call tacked on to the block
+# when reading code.
+#
+# @example
+#   # bad
+#   a do
+#   b
+#   end.c
+#
+#   # good
+#   a { b }.c
+#
+#   # good
+#   foo = a do
+#   b
+#   end
+#   foo.c
+#
+# source://rubocop//lib/rubocop/cop/style/method_called_on_do_end_block.rb#24
+class RuboCop::Cop::Style::MethodCalledOnDoEndBlock < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/style/method_called_on_do_end_block.rb#29
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_called_on_do_end_block.rb#40
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_called_on_do_end_block.rb#29
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_called_on_do_end_block.rb#40
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/method_called_on_do_end_block.rb#27
+RuboCop::Cop::Style::MethodCalledOnDoEndBlock::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for parentheses around the arguments in method
+# definitions. Both instance and class/singleton methods are checked.
+#
+# Regardless of style, parentheses are necessary for:
+#
+# 1. Endless methods
+# 2. Argument lists containing a `forward-arg` (`...`)
+# 3. Argument lists containing an anonymous rest arguments forwarding (`*`)
+# 4. Argument lists containing an anonymous keyword rest arguments forwarding (`**`)
+# 5. Argument lists containing an anonymous block forwarding (`&`)
+#
+# Removing the parens would be a syntax error here.
+#
+# @example EnforcedStyle: require_parentheses (default)
+#   # The `require_parentheses` style requires method definitions
+#   # to always use parentheses
+#
+#   # bad
+#   def bar num1, num2
+#   num1 + num2
+#   end
+#
+#   def foo descriptive_var_name,
+#   another_descriptive_var_name,
+#   last_descriptive_var_name
+#   do_something
+#   end
+#
+#   # good
+#   def bar(num1, num2)
+#   num1 + num2
+#   end
+#
+#   def foo(descriptive_var_name,
+#   another_descriptive_var_name,
+#   last_descriptive_var_name)
+#   do_something
+#   end
+# @example EnforcedStyle: require_no_parentheses
+#   # The `require_no_parentheses` style requires method definitions
+#   # to never use parentheses
+#
+#   # bad
+#   def bar(num1, num2)
+#   num1 + num2
+#   end
+#
+#   def foo(descriptive_var_name,
+#   another_descriptive_var_name,
+#   last_descriptive_var_name)
+#   do_something
+#   end
+#
+#   # good
+#   def bar num1, num2
+#   num1 + num2
+#   end
+#
+#   def foo descriptive_var_name,
+#   another_descriptive_var_name,
+#   last_descriptive_var_name
+#   do_something
+#   end
+# @example EnforcedStyle: require_no_parentheses_except_multiline
+#   # The `require_no_parentheses_except_multiline` style prefers no
+#   # parentheses when method definition arguments fit on single line,
+#   # but prefers parentheses when arguments span multiple lines.
+#
+#   # bad
+#   def bar(num1, num2)
+#   num1 + num2
+#   end
+#
+#   def foo descriptive_var_name,
+#   another_descriptive_var_name,
+#   last_descriptive_var_name
+#   do_something
+#   end
+#
+#   # good
+#   def bar num1, num2
+#   num1 + num2
+#   end
+#
+#   def foo(descriptive_var_name,
+#   another_descriptive_var_name,
+#   last_descriptive_var_name)
+#   do_something
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#97
+class RuboCop::Cop::Style::MethodDefParentheses < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#105
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#105
+  def on_defs(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#169
+  def anonymous_arguments?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#147
+  def arguments_without_parentheses?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#126
+  def correct_arguments(arg_node, corrector); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#131
+  def forced_parentheses?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#151
+  def missing_parentheses(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#142
+  def require_parentheses?(args); end
+
+  # source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#161
+  def unwanted_parentheses(args); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#103
+RuboCop::Cop::Style::MethodDefParentheses::MSG_MISSING = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/method_def_parentheses.rb#102
+RuboCop::Cop::Style::MethodDefParentheses::MSG_PRESENT = T.let(T.unsafe(nil), String)
+
+# Checks for potential uses of `Enumerable#minmax`.
+#
+# @example
+#
+#   # bad
+#   bar = [foo.min, foo.max]
+#   return foo.min, foo.max
+#
+#   # good
+#   bar = foo.minmax
+#   return foo.minmax
+#
+# source://rubocop//lib/rubocop/cop/style/min_max.rb#17
+class RuboCop::Cop::Style::MinMax < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/min_max.rb#38
+  def min_max_candidate(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/min_max.rb#22
+  def on_array(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/min_max.rb#22
+  def on_return(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/min_max.rb#55
+  def argument_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/min_max.rb#42
+  def message(offender, receiver); end
+
+  # source://rubocop//lib/rubocop/cop/style/min_max.rb#46
+  def offending_range(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/min_max.rb#20
+RuboCop::Cop::Style::MinMax::MSG = T.let(T.unsafe(nil), String)
+
+# Enforces the use of `max` or `min` instead of comparison for greater or less.
+#
+# NOTE: It can be used if you want to present limit or threshold in Ruby 2.7+.
+# That it is slow though. So autocorrection will apply generic `max` or `min`:
+#
+# [source,ruby]
+# ----
+# a.clamp(b..) # Same as `[a, b].max`
+# a.clamp(..b) # Same as `[a, b].min`
+# ----
+#
+# @example
+#
+#   # bad
+#   a > b ? a : b
+#   a >= b ? a : b
+#
+#   # good
+#   [a, b].max
+#
+#   # bad
+#   a < b ? a : b
+#   a <= b ? a : b
+#
+#   # good
+#   [a, b].min
+#
+# source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#37
+class RuboCop::Cop::Style::MinMaxComparison < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#46
+  def on_if(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#72
+  def autocorrect(corrector, node, replacement); end
+
+  # source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#64
+  def preferred_method(operator, lhs, rhs, if_branch, else_branch); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#44
+RuboCop::Cop::Style::MinMaxComparison::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#42
+RuboCop::Cop::Style::MinMaxComparison::GRATER_OPERATORS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#43
+RuboCop::Cop::Style::MinMaxComparison::LESS_OPERATORS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/min_max_comparison.rb#41
+RuboCop::Cop::Style::MinMaxComparison::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for `if` expressions that do not have an `else` branch.
+#
+# NOTE: Pattern matching is allowed to have no `else` branch because unlike `if` and `case`,
+# it raises `NoMatchingPatternError` if the pattern doesn't match and without having `else`.
+#
+# Supported styles are: if, case, both.
+#
+# @example EnforcedStyle: both (default)
+#   # warn when an `if` or `case` expression is missing an `else` branch.
+#
+#   # bad
+#   if condition
+#   statement
+#   end
+#
+#   # bad
+#   case var
+#   when condition
+#   statement
+#   end
+#
+#   # good
+#   if condition
+#   statement
+#   else
+#   # the content of `else` branch will be determined by Style/EmptyElse
+#   end
+#
+#   # good
+#   case var
+#   when condition
+#   statement
+#   else
+#   # the content of `else` branch will be determined by Style/EmptyElse
+#   end
+# @example EnforcedStyle: if
+#   # warn when an `if` expression is missing an `else` branch.
+#
+#   # bad
+#   if condition
+#   statement
+#   end
+#
+#   # good
+#   if condition
+#   statement
+#   else
+#   # the content of `else` branch will be determined by Style/EmptyElse
+#   end
+#
+#   # good
+#   case var
+#   when condition
+#   statement
+#   end
+#
+#   # good
+#   case var
+#   when condition
+#   statement
+#   else
+#   # the content of `else` branch will be determined by Style/EmptyElse
+#   end
+# @example EnforcedStyle: case
+#   # warn when a `case` expression is missing an `else` branch.
+#
+#   # bad
+#   case var
+#   when condition
+#   statement
+#   end
+#
+#   # good
+#   case var
+#   when condition
+#   statement
+#   else
+#   # the content of `else` branch will be determined by Style/EmptyElse
+#   end
+#
+#   # good
+#   if condition
+#   statement
+#   end
+#
+#   # good
+#   if condition
+#   statement
+#   else
+#   # the content of `else` branch will be determined by Style/EmptyElse
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/missing_else.rb#99
+class RuboCop::Cop::Style::MissingElse < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::OnNormalIfUnless
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/missing_else.rb#115
+  def on_case(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/missing_else.rb#121
+  def on_case_match(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/missing_else.rb#108
+  def on_normal_if_unless(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/missing_else.rb#146
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/missing_else.rb#159
+  def case_style?; end
+
+  # source://rubocop//lib/rubocop/cop/style/missing_else.rb#127
+  def check(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/missing_else.rb#177
+  def empty_else_config; end
+
+  # source://rubocop//lib/rubocop/cop/style/missing_else.rb#171
+  def empty_else_style; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/missing_else.rb#155
+  def if_style?; end
+
+  # source://rubocop//lib/rubocop/cop/style/missing_else.rb#135
+  def message_template; end
+
+  # source://rubocop//lib/rubocop/cop/style/missing_else.rb#167
+  def unless_else_config; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/missing_else.rb#163
+  def unless_else_cop_enabled?; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/missing_else.rb#104
+RuboCop::Cop::Style::MissingElse::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/missing_else.rb#106
+RuboCop::Cop::Style::MissingElse::MSG_EMPTY = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/missing_else.rb#105
+RuboCop::Cop::Style::MissingElse::MSG_NIL = T.let(T.unsafe(nil), String)
+
+# Checks for the presence of `method_missing` without also
+# defining `respond_to_missing?`.
+#
+# @example
+#   # bad
+#   def method_missing(name, *args)
+#   # ...
+#   end
+#
+#   # good
+#   def respond_to_missing?(name, include_private)
+#   # ...
+#   end
+#
+#   def method_missing(name, *args)
+#   # ...
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/missing_respond_to_missing.rb#24
+class RuboCop::Cop::Style::MissingRespondToMissing < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/style/missing_respond_to_missing.rb#27
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/missing_respond_to_missing.rb#27
+  def on_defs(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/missing_respond_to_missing.rb#37
+  def implements_respond_to_missing?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/missing_respond_to_missing.rb#25
+RuboCop::Cop::Style::MissingRespondToMissing::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for grouping of mixins in `class` and `module` bodies.
+# By default it enforces mixins to be placed in separate declarations,
+# but it can be configured to enforce grouping them in one declaration.
+#
+# @example EnforcedStyle: separated (default)
+#   # bad
+#   class Foo
+#   include Bar, Qox
+#   end
+#
+#   # good
+#   class Foo
+#   include Qox
+#   include Bar
+#   end
+# @example EnforcedStyle: grouped
+#   # bad
+#   class Foo
+#   extend Bar
+#   extend Qox
+#   end
+#
+#   # good
+#   class Foo
+#   extend Qox, Bar
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#33
+class RuboCop::Cop::Style::MixinGrouping < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#40
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#40
+  def on_module(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#64
+  def check(send_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#72
+  def check_grouped_style(send_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#91
+  def check_separated_style(send_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#127
+  def group_mixins(node, mixins); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#110
+  def grouped_style?; end
+
+  # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#53
+  def range_to_remove_for_subsequent_mixin(mixins, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#118
+  def separate_mixins(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#114
+  def separated_style?; end
+
+  # source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#104
+  def sibling_mixins(send_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#37
+RuboCop::Cop::Style::MixinGrouping::MIXIN_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/mixin_grouping.rb#38
+RuboCop::Cop::Style::MixinGrouping::MSG = T.let(T.unsafe(nil), String)
+
+# Checks that `include`, `extend` and `prepend` statements appear
+# inside classes and modules, not at the top level, so as to not affect
+# the behavior of `Object`.
+#
+# @example
+#   # bad
+#   include M
+#
+#   class C
+#   end
+#
+#   # bad
+#   extend M
+#
+#   class C
+#   end
+#
+#   # bad
+#   prepend M
+#
+#   class C
+#   end
+#
+#   # good
+#   class C
+#   include M
+#   end
+#
+#   # good
+#   class C
+#   extend M
+#   end
+#
+#   # good
+#   class C
+#   prepend M
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/mixin_usage.rb#43
+class RuboCop::Cop::Style::MixinUsage < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/style/mixin_usage.rb#54
+  def in_top_level_scope?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/mixin_usage.rb#48
+  def include_statement(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/mixin_usage.rb#62
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/mixin_usage.rb#44
+RuboCop::Cop::Style::MixinUsage::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/mixin_usage.rb#45
+RuboCop::Cop::Style::MixinUsage::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for use of `extend self` or `module_function` in a module.
+#
+# Supported styles are: `module_function` (default), `extend_self` and `forbidden`.
+#
+# A couple of things to keep in mind:
+#
+# - `forbidden` style prohibits the usage of both styles
+# - in default mode (`module_function`), the cop won't be activated when the module
+#   contains any private methods
+#
+# @example EnforcedStyle: module_function (default)
+#   # bad
+#   module Test
+#   extend self
+#   # ...
+#   end
+#
+#   # good
+#   module Test
+#   module_function
+#   # ...
+#   end
+#
+#   # good
+#   module Test
+#   extend self
+#   # ...
+#   private
+#   # ...
+#   end
+#
+#   # good
+#   module Test
+#   class << self
+#   # ...
+#   end
+#   end
+# @example EnforcedStyle: extend_self
+#   # bad
+#   module Test
+#   module_function
+#   # ...
+#   end
+#
+#   # good
+#   module Test
+#   extend self
+#   # ...
+#   end
+#
+#   # good
+#   module Test
+#   class << self
+#   # ...
+#   end
+#   end
+# @example EnforcedStyle: forbidden
+#   # bad
+#   module Test
+#   module_function
+#   # ...
+#   end
+#
+#   # bad
+#   module Test
+#   extend self
+#   # ...
+#   end
+#
+#   # bad
+#   module Test
+#   extend self
+#   # ...
+#   private
+#   # ...
+#   end
+#
+#   # good
+#   module Test
+#   class << self
+#   # ...
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/module_function.rb#95
+class RuboCop::Cop::Style::ModuleFunction < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/module_function.rb#107
+  def extend_self_node?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/module_function.rb#104
+  def module_function_node?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/module_function.rb#112
+  def on_module(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/module_function.rb#110
+  def private_directive?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/module_function.rb#149
+  def check_extend_self(nodes); end
+
+  # source://rubocop//lib/rubocop/cop/style/module_function.rb#155
+  def check_forbidden(nodes); end
+
+  # source://rubocop//lib/rubocop/cop/style/module_function.rb#141
+  def check_module_function(nodes); end
+
+  # source://rubocop//lib/rubocop/cop/style/module_function.rb#130
+  def each_wrong_style(nodes, &block); end
+
+  # source://rubocop//lib/rubocop/cop/style/module_function.rb#162
+  def message(_range); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/module_function.rb#100
+RuboCop::Cop::Style::ModuleFunction::EXTEND_SELF_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/module_function.rb#101
+RuboCop::Cop::Style::ModuleFunction::FORBIDDEN_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/module_function.rb#99
+RuboCop::Cop::Style::ModuleFunction::MODULE_FUNCTION_MSG = T.let(T.unsafe(nil), String)
+
+# Checks for chaining of a block after another block that spans
+# multiple lines.
+#
+# @example
+#
+#   # bad
+#   Thread.list.select do |t|
+#   t.alive?
+#   end.map do |t|
+#   t.object_id
+#   end
+#
+#   # good
+#   alive_threads = Thread.list.select do |t|
+#   t.alive?
+#   end
+#   alive_threads.map do |t|
+#   t.object_id
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/multiline_block_chain.rb#25
+class RuboCop::Cop::Style::MultilineBlockChain < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_block_chain.rb#30
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_block_chain.rb#30
+  def on_numblock(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/multiline_block_chain.rb#28
+RuboCop::Cop::Style::MultilineBlockChain::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for uses of if/unless modifiers with multiple-lines bodies.
+#
+# @example
+#
+#   # bad
+#   {
+#   result: 'this should not happen'
+#   } unless cond
+#
+#   # good
+#   { result: 'ok' } if cond
+#
+# source://rubocop//lib/rubocop/cop/style/multiline_if_modifier.rb#17
+class RuboCop::Cop::Style::MultilineIfModifier < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::LineLengthHelp
+  include ::RuboCop::Cop::StatementModifier
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_if_modifier.rb#25
+  def on_if(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_if_modifier.rb#43
+  def indented_body(body, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_if_modifier.rb#35
+  def to_normal_if(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/multiline_if_modifier.rb#22
+RuboCop::Cop::Style::MultilineIfModifier::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for uses of the `then` keyword in multi-line if statements.
+#
+# @example
+#   # bad
+#   # This is considered bad practice.
+#   if cond then
+#   end
+#
+#   # good
+#   # If statements can contain `then` on the same line.
+#   if cond then a
+#   elsif cond then b
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/multiline_if_then.rb#19
+class RuboCop::Cop::Style::MultilineIfThen < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::OnNormalIfUnless
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_if_then.rb#28
+  def on_normal_if_unless(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/multiline_if_then.rb#38
+  def non_modifier_then?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/multiline_if_then.rb#26
+RuboCop::Cop::Style::MultilineIfThen::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/multiline_if_then.rb#24
+RuboCop::Cop::Style::MultilineIfThen::NON_MODIFIER_THEN = T.let(T.unsafe(nil), Regexp)
+
+# Checks uses of the `then` keyword in multi-line `in` statement.
+#
+# @example
+#   # bad
+#   case expression
+#   in pattern then
+#   end
+#
+#   # good
+#   case expression
+#   in pattern
+#   end
+#
+#   # good
+#   case expression
+#   in pattern then do_something
+#   end
+#
+#   # good
+#   case expression
+#   in pattern then do_something(arg1,
+#   arg2)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/multiline_in_pattern_then.rb#30
+class RuboCop::Cop::Style::MultilineInPatternThen < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_in_pattern_then.rb#39
+  def on_in_pattern(node); end
+
+  private
+
+  # Requires `then` for write `in` and its body on the same line.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/multiline_in_pattern_then.rb#51
+  def require_then?(in_pattern_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/multiline_in_pattern_then.rb#37
+RuboCop::Cop::Style::MultilineInPatternThen::MSG = T.let(T.unsafe(nil), String)
+
+# Checks expressions wrapping styles for multiline memoization.
+#
+# @example EnforcedStyle: keyword (default)
+#   # bad
+#   foo ||= (
+#   bar
+#   baz
+#   )
+#
+#   # good
+#   foo ||= begin
+#   bar
+#   baz
+#   end
+# @example EnforcedStyle: braces
+#   # bad
+#   foo ||= begin
+#   bar
+#   baz
+#   end
+#
+#   # good
+#   foo ||= (
+#   bar
+#   baz
+#   )
+#
+# source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#33
+class RuboCop::Cop::Style::MultilineMemoization < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#56
+  def message(_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#41
+  def on_or_asgn(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#62
+  def bad_rhs?(rhs); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#72
+  def keyword_autocorrect(node, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#78
+  def keyword_begin_str(node, node_buf); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#86
+  def keyword_end_str(node, node_buf); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#39
+RuboCop::Cop::Style::MultilineMemoization::BRACES_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/multiline_memoization.rb#38
+RuboCop::Cop::Style::MultilineMemoization::KEYWORD_MSG = T.let(T.unsafe(nil), String)
+
+# Checks for method signatures that span multiple lines.
+#
+# @example
+#
+#   # good
+#
+#   def foo(bar, baz)
+#   end
+#
+#   # bad
+#
+#   def foo(bar,
+#   baz)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#21
+class RuboCop::Cop::Style::MultilineMethodSignature < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#27
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#27
+  def on_defs(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#69
+  def arguments_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#42
+  def autocorrect(corrector, node, begin_of_arguments); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#81
+  def closing_line(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#85
+  def correction_exceeds_max_line_length?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#93
+  def definition_width(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#89
+  def indentation_width(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#65
+  def last_line_source_of_arguments(arguments); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#97
+  def max_line_length; end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#77
+  def opening_line(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/multiline_method_signature.rb#25
+RuboCop::Cop::Style::MultilineMethodSignature::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for multi-line ternary op expressions.
+#
+# NOTE: `return if ... else ... end` is syntax error. If `return` is used before
+# multiline ternary operator expression, it will be autocorrected to single-line
+# ternary operator. The same is true for `break`, `next`, and method call.
+#
+# @example
+#   # bad
+#   a = cond ?
+#   b : c
+#   a = cond ? b :
+#   c
+#   a = cond ?
+#   b :
+#   c
+#
+#   return cond ?
+#   b :
+#   c
+#
+#   # good
+#   a = cond ? b : c
+#   a = if cond
+#   b
+#   else
+#   c
+#   end
+#
+#   return cond ? b : c
+#
+# source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#36
+class RuboCop::Cop::Style::MultilineTernaryOperator < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CommentsHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#44
+  def on_if(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#64
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#86
+  def comments_in_condition(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#92
+  def enforce_single_line_ternary_operator?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#60
+  def offense?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#72
+  def replacement(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#96
+  def use_assignment_method?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#40
+RuboCop::Cop::Style::MultilineTernaryOperator::MSG_IF = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#41
+RuboCop::Cop::Style::MultilineTernaryOperator::MSG_SINGLE_LINE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/multiline_ternary_operator.rb#42
+RuboCop::Cop::Style::MultilineTernaryOperator::SINGLE_LINE_TYPES = T.let(T.unsafe(nil), Array)
+
+# Checks uses of the `then` keyword
+# in multi-line when statements.
+#
+# @example
+#   # bad
+#   case foo
+#   when bar then
+#   end
+#
+#   # good
+#   case foo
+#   when bar
+#   end
+#
+#   # good
+#   case foo
+#   when bar then do_something
+#   end
+#
+#   # good
+#   case foo
+#   when bar then do_something(arg1,
+#   arg2)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/multiline_when_then.rb#31
+class RuboCop::Cop::Style::MultilineWhenThen < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/multiline_when_then.rb#37
+  def on_when(node); end
+
+  private
+
+  # Requires `then` for write `when` and its body on the same line.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/multiline_when_then.rb#49
+  def require_then?(when_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/multiline_when_then.rb#35
+RuboCop::Cop::Style::MultilineWhenThen::MSG = T.let(T.unsafe(nil), String)
+
+# Checks against comparing a variable with multiple items, where
+# `Array#include?`, `Set#include?` or a `case` could be used instead
+# to avoid code repetition.
+# It accepts comparisons of multiple method calls to avoid unnecessary method calls
+# by default. It can be configured by `AllowMethodComparison` option.
+#
+# @example
+#   # bad
+#   a = 'a'
+#   foo if a == 'a' || a == 'b' || a == 'c'
+#
+#   # good
+#   a = 'a'
+#   foo if ['a', 'b', 'c'].include?(a)
+#
+#   VALUES = Set['a', 'b', 'c'].freeze
+#   # elsewhere...
+#   foo if VALUES.include?(a)
+#
+#   case foo
+#   when 'a', 'b', 'c' then foo
+#   # ...
+#   end
+#
+#   # accepted (but consider `case` as above)
+#   foo if a == b.lightweight || a == b.heavyweight
+# @example AllowMethodComparison: true (default)
+#   # good
+#   foo if a == b.lightweight || a == b.heavyweight
+# @example AllowMethodComparison: false
+#   # bad
+#   foo if a == b.lightweight || a == b.heavyweight
+#
+#   # good
+#   foo if [b.lightweight, b.heavyweight].include?(a)
+# @example ComparisonsThreshold: 2 (default)
+#   # bad
+#   foo if a == 'a' || a == 'b'
+# @example ComparisonsThreshold: 3
+#   # good
+#   foo if a == 'a' || a == 'b'
+#
+# source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#52
+class RuboCop::Cop::Style::MultipleComparison < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#58
+  def on_new_investigation; end
+
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#62
+  def on_or(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#86
+  def simple_comparison_lhs?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#91
+  def simple_comparison_rhs?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#83
+  def simple_double_comparison?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#153
+  def allow_method_comparison?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#134
+  def comparison?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#157
+  def comparisons_threshold; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#126
+  def nested_comparison?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#95
+  def nested_variable_comparison?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#148
+  def reset_comparison; end
+
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#138
+  def root_of_or_node(or_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#122
+  def variable_name(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#101
+  def variables_in_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#109
+  def variables_in_simple_node(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/multiple_comparison.rb#55
+RuboCop::Cop::Style::MultipleComparison::MSG = T.let(T.unsafe(nil), String)
+
+# Checks whether some constant value isn't a
+# mutable literal (e.g. array or hash).
+#
+# Strict mode can be used to freeze all constants, rather than
+# just literals.
+# Strict mode is considered an experimental feature. It has not been
+# updated with an exhaustive list of all methods that will produce
+# frozen objects so there is a decent chance of getting some false
+# positives. Luckily, there is no harm in freezing an already
+# frozen object.
+#
+# From Ruby 3.0, this cop honours the magic comment
+# 'shareable_constant_value'. When this magic comment is set to any
+# acceptable value other than none, it will suppress the offenses
+# raised by this cop. It enforces frozen state.
+#
+# NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
+#
+# NOTE: From Ruby 3.0, interpolated strings are not frozen when
+# `# frozen-string-literal: true` is used, so this cop enforces explicit
+# freezing for such strings.
+#
+# NOTE: From Ruby 3.0, this cop allows explicit freezing of constants when
+# the `shareable_constant_value` directive is used.
+#
+# @example EnforcedStyle: literals (default)
+#   # bad
+#   CONST = [1, 2, 3]
+#
+#   # good
+#   CONST = [1, 2, 3].freeze
+#
+#   # good
+#   CONST = <<~TESTING.freeze
+#   This is a heredoc
+#   TESTING
+#
+#   # good
+#   CONST = Something.new
+# @example EnforcedStyle: strict
+#   # bad
+#   CONST = Something.new
+#
+#   # bad
+#   CONST = Struct.new do
+#   def foo
+#   puts 1
+#   end
+#   end
+#
+#   # good
+#   CONST = Something.new.freeze
+#
+#   # good
+#   CONST = Struct.new do
+#   def foo
+#   puts 1
+#   end
+#   end.freeze
+# @example
+#   # Magic comment - shareable_constant_value: literal
+#
+#   # bad
+#   CONST = [1, 2, 3]
+#
+#   # good
+#   # shareable_constant_value: literal
+#   CONST = [1, 2, 3]
+#
+# source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#83
+class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Style::MutableConstant::ShareableConstantValue
+  include ::RuboCop::Cop::FrozenStringLiteral
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop-sorbet/0.8.6/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb#18
+  def on_assignment(value); end
+
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#127
+  def on_casgn(node); end
+
+  # Some of these patterns may not actually return an immutable object,
+  # but we want to consider them immutable for this cop.
+  #
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#224
+  def operation_produces_immutable_object?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#241
+  def range_enclosed_in_parentheses?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#217
+  def splat_value(param0 = T.unsafe(nil)); end
+
+  # source://rubocop-sorbet/0.8.6/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb#12
+  def t_let(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#169
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#158
+  def check(value); end
+
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#208
+  def correct_splat_expansion(corrector, expr, splat_value); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#200
+  def frozen_regexp_or_range_literals?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#190
+  def immutable_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#184
+  def mutable_literal?(value); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#204
+  def requires_parentheses?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#194
+  def shareable_constant_value?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#149
+  def strict_check(value); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#125
+RuboCop::Cop::Style::MutableConstant::MSG = T.let(T.unsafe(nil), String)
+
+# Handles magic comment shareable_constant_value with O(n ^ 2) complexity
+# n - number of lines in the source
+# Iterates over all lines before a CONSTANT
+# until it reaches shareable_constant_value
+#
+# source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#88
+module RuboCop::Cop::Style::MutableConstant::ShareableConstantValue
+  private
+
+  # Identifies the most recent magic comment with valid shareable constant values
+  # that's in scope for this node
+  #
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#102
+  def magic_comment_in_scope(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#110
+  def processed_source_till_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#91
+  def recent_shareable_value?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#114
+  def shareable_constant_value_enabled?(value); end
+
+  class << self
+    # Identifies the most recent magic comment with valid shareable constant values
+    # that's in scope for this node
+    #
+    # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#102
+    def magic_comment_in_scope(node); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/style/mutable_constant.rb#91
+    def recent_shareable_value?(node); end
+  end
+end
+
+# Checks for uses of if with a negated condition. Only ifs
+# without else are considered. There are three different styles:
+#
+# * both
+# * prefix
+# * postfix
+#
+# @example EnforcedStyle: both (default)
+#   # enforces `unless` for `prefix` and `postfix` conditionals
+#
+#   # bad
+#
+#   if !foo
+#   bar
+#   end
+#
+#   # good
+#
+#   unless foo
+#   bar
+#   end
+#
+#   # bad
+#
+#   bar if !foo
+#
+#   # good
+#
+#   bar unless foo
+# @example EnforcedStyle: prefix
+#   # enforces `unless` for just `prefix` conditionals
+#
+#   # bad
+#
+#   if !foo
+#   bar
+#   end
+#
+#   # good
+#
+#   unless foo
+#   bar
+#   end
+#
+#   # good
+#
+#   bar if !foo
+# @example EnforcedStyle: postfix
+#   # enforces `unless` for just `postfix` conditionals
+#
+#   # bad
+#
+#   bar if !foo
+#
+#   # good
+#
+#   bar unless foo
+#
+#   # good
+#
+#   if !foo
+#   bar
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/negated_if.rb#71
+class RuboCop::Cop::Style::NegatedIf < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::NegativeConditional
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/negated_if.rb#76
+  def on_if(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/negated_if.rb#92
+  def correct_style?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/negated_if.rb#88
+  def message(node); end
+end
+
+# Checks for uses of `if-else` and ternary operators with a negated condition
+# which can be simplified by inverting condition and swapping branches.
+#
+# @example
+#   # bad
+#   if !x
+#   do_something
+#   else
+#   do_something_else
+#   end
+#
+#   # good
+#   if x
+#   do_something_else
+#   else
+#   do_something
+#   end
+#
+#   # bad
+#   !x ? do_something : do_something_else
+#
+#   # good
+#   x ? do_something_else : do_something
+#
+# source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#30
+class RuboCop::Cop::Style::NegatedIfElseCondition < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#39
+  def double_negation?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#49
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#45
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#94
+  def correct_negated_condition(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#90
+  def corrected_ancestor?(node); end
+
+  # Collect the entire else branch, including whitespace and comments
+  #
+  # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#125
+  def else_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#68
+  def if_else?(node); end
+
+  # Collect the entire if branch, including whitespace and comments
+  #
+  # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#116
+  def if_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#84
+  def message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#79
+  def negated_condition?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#107
+  def swap_branches(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#73
+  def unwrap_begin_nodes(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#41
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#34
+RuboCop::Cop::Style::NegatedIfElseCondition::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/negated_if_else_condition.rb#36
+RuboCop::Cop::Style::NegatedIfElseCondition::NEGATED_EQUALITY_METHODS = T.let(T.unsafe(nil), Array)
+
+# Checks for uses of unless with a negated condition. Only unless
+# without else are considered. There are three different styles:
+#
+# * both
+# * prefix
+# * postfix
+#
+# @example EnforcedStyle: both (default)
+#   # enforces `if` for `prefix` and `postfix` conditionals
+#
+#   # bad
+#   unless !foo
+#   bar
+#   end
+#
+#   # good
+#   if foo
+#   bar
+#   end
+#
+#   # bad
+#   bar unless !foo
+#
+#   # good
+#   bar if foo
+# @example EnforcedStyle: prefix
+#   # enforces `if` for just `prefix` conditionals
+#
+#   # bad
+#   unless !foo
+#   bar
+#   end
+#
+#   # good
+#   if foo
+#   bar
+#   end
+#
+#   # good
+#   bar unless !foo
+# @example EnforcedStyle: postfix
+#   # enforces `if` for just `postfix` conditionals
+#
+#   # bad
+#   bar unless !foo
+#
+#   # good
+#   bar if foo
+#
+#   # good
+#   unless !foo
+#   bar
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/negated_unless.rb#61
+class RuboCop::Cop::Style::NegatedUnless < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::NegativeConditional
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/negated_unless.rb#66
+  def on_if(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/negated_unless.rb#82
+  def correct_style?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/negated_unless.rb#78
+  def message(node); end
+end
+
+# Checks for uses of while with a negated condition.
+#
+# @example
+#   # bad
+#   while !foo
+#   bar
+#   end
+#
+#   # good
+#   until foo
+#   bar
+#   end
+#
+#   # bad
+#   bar until !foo
+#
+#   # good
+#   bar while foo
+#   bar while !foo && baz
+#
+# source://rubocop//lib/rubocop/cop/style/negated_while.rb#25
+class RuboCop::Cop::Style::NegatedWhile < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::NegativeConditional
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/negated_while.rb#29
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/negated_while.rb#29
+  def on_while(node); end
+end
+
+# Checks for nested `File.dirname`.
+# It replaces nested `File.dirname` with the level argument introduced in Ruby 3.1.
+#
+# @example
+#
+#   # bad
+#   File.dirname(File.dirname(path))
+#
+#   # good
+#   File.dirname(path, 2)
+#
+# source://rubocop//lib/rubocop/cop/style/nested_file_dirname.rb#17
+class RuboCop::Cop::Style::NestedFileDirname < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/nested_file_dirname.rb#28
+  def file_dirname?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/nested_file_dirname.rb#33
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/nested_file_dirname.rb#60
+  def offense_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/nested_file_dirname.rb#49
+  def path_with_dir_level(node, level); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/nested_file_dirname.rb#22
+RuboCop::Cop::Style::NestedFileDirname::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/nested_file_dirname.rb#23
+RuboCop::Cop::Style::NestedFileDirname::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for nested use of if, unless, while and until in their
+# modifier form.
+#
+# @example
+#
+#   # bad
+#   something if a if b
+#
+#   # good
+#   something if b && a
+#
+# source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#16
+class RuboCop::Cop::Style::NestedModifier < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#22
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#22
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#22
+  def on_while(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#85
+  def add_parentheses_to_method_arguments(send_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#42
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#30
+  def check(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#65
+  def left_hand_operand(node, operator); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#38
+  def modifier?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#51
+  def new_expression(inner_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#61
+  def replacement_operator(keyword); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#94
+  def requires_parens?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#71
+  def right_hand_operand(node, left_hand_keyword); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/nested_modifier.rb#20
+RuboCop::Cop::Style::NestedModifier::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for unparenthesized method calls in the argument list
+# of a parenthesized method call.
+# `be`, `be_a`, `be_an`, `be_between`, `be_falsey`, `be_kind_of`, `be_instance_of`,
+# `be_truthy`, `be_within`, `eq`, `eql`, `end_with`, `include`, `match`, `raise_error`,
+# `respond_to`, and `start_with` methods are allowed by default.
+# These are customizable with `AllowedMethods` option.
+#
+# @example
+#   # good
+#   method1(method2(arg))
+#
+#   # bad
+#   method1(method2 arg)
+# @example AllowedMethods: [foo]
+#   # good
+#   method1(foo arg)
+#
+# source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#24
+class RuboCop::Cop::Style::NestedParenthesizedCalls < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::AllowedMethods
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#35
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#35
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#71
+  def allowed?(send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#65
+  def allowed_omission?(send_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#51
+  def autocorrect(corrector, nested); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#31
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/nested_parenthesized_calls.rb#29
+RuboCop::Cop::Style::NestedParenthesizedCalls::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for nested ternary op expressions.
+#
+# @example
+#   # bad
+#   a ? (b ? b1 : b2) : a2
+#
+#   # good
+#   if a
+#   b ? b1 : b2
+#   else
+#   a2
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/nested_ternary_operator.rb#18
+class RuboCop::Cop::Style::NestedTernaryOperator < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/nested_ternary_operator.rb#25
+  def on_if(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/nested_ternary_operator.rb#40
+  def autocorrect(corrector, if_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/nested_ternary_operator.rb#47
+  def remove_parentheses(source); end
+
+  # source://rubocop//lib/rubocop/cop/style/nested_ternary_operator.rb#53
+  def replace_loc_and_whitespace(corrector, range, replacement); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/nested_ternary_operator.rb#23
+RuboCop::Cop::Style::NestedTernaryOperator::MSG = T.let(T.unsafe(nil), String)
+
+# Use `next` to skip iteration instead of a condition at the end.
+#
+# @example EnforcedStyle: skip_modifier_ifs (default)
+#   # bad
+#   [1, 2].each do |a|
+#   if a == 1
+#   puts a
+#   end
+#   end
+#
+#   # good
+#   [1, 2].each do |a|
+#   next unless a == 1
+#   puts a
+#   end
+#
+#   # good
+#   [1, 2].each do |a|
+#   puts a if a == 1
+#   end
+# @example EnforcedStyle: always
+#   # With `always` all conditions at the end of an iteration needs to be
+#   # replaced by next - with `skip_modifier_ifs` the modifier if like
+#   # this one are ignored: `[1, 2].each { |a| puts a if a == 1 }`
+#
+#   # bad
+#   [1, 2].each do |a|
+#   puts a if a == 1
+#   end
+#
+#   # bad
+#   [1, 2].each do |a|
+#   if a == 1
+#   puts a
+#   end
+#   end
+#
+#   # good
+#   [1, 2].each do |a|
+#   next unless a == 1
+#   puts a
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/next.rb#49
+class RuboCop::Cop::Style::Next < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::MinBodyLength
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#68
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#76
+  def on_for(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#62
+  def on_new_investigation; end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#68
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#76
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#76
+  def on_while(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#213
+  def actual_indent(lines, buffer); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/next.rb#112
+  def allowed_modifier_if?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#155
+  def autocorrect_block(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#145
+  def autocorrect_modifier(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#84
+  def check(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#170
+  def cond_range(node, cond); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/next.rb#189
+  def end_followed_by_whitespace_only?(source_buffer, end_pos); end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#180
+  def end_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/next.rb#98
+  def ends_with_condition?(body); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/next.rb#128
+  def exit_body_type?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#217
+  def heredoc_lines(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/next.rb#120
+  def if_else_children?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/next.rb#124
+  def if_without_else?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#140
+  def offense_location(offense_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#134
+  def offense_node(body); end
+
+  # Adjust indentation of `lines` to match `node`
+  #
+  # source://rubocop//lib/rubocop/cop/style/next.rb#204
+  def reindent(lines, node, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#224
+  def reindent_line(corrector, lineno, delta, buffer); end
+
+  # source://rubocop//lib/rubocop/cop/style/next.rb#193
+  def reindentable_lines(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/next.rb#104
+  def simple_if_without_break?(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/next.rb#58
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/next.rb#56
+RuboCop::Cop::Style::Next::EXIT_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/next.rb#55
+RuboCop::Cop::Style::Next::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for comparison of something with nil using `==` and
+# `nil?`.
+#
+# Supported styles are: predicate, comparison.
+#
+# @example EnforcedStyle: predicate (default)
+#
+#   # bad
+#   if x == nil
+#   end
+#
+#   # good
+#   if x.nil?
+#   end
+# @example EnforcedStyle: comparison
+#
+#   # bad
+#   if x.nil?
+#   end
+#
+#   # good
+#   if x == nil
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#31
+class RuboCop::Cop::Style::NilComparison < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#44
+  def nil_check?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#41
+  def nil_comparison?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#46
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#67
+  def message(_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#79
+  def prefer_comparison?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#71
+  def style_check?(node, &block); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#36
+RuboCop::Cop::Style::NilComparison::EXPLICIT_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#35
+RuboCop::Cop::Style::NilComparison::PREDICATE_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/nil_comparison.rb#38
+RuboCop::Cop::Style::NilComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for lambdas and procs that always return nil,
+# which can be replaced with an empty lambda or proc instead.
+#
+# @example
+#   # bad
+#   -> { nil }
+#
+#   lambda do
+#   next nil
+#   end
+#
+#   proc { nil }
+#
+#   Proc.new do
+#   break nil
+#   end
+#
+#   # good
+#   -> {}
+#
+#   lambda do
+#   end
+#
+#   -> (x) { nil if x }
+#
+#   proc {}
+#
+#   Proc.new { nil if x }
+#
+# source://rubocop//lib/rubocop/cop/style/nil_lambda.rb#35
+class RuboCop::Cop::Style::NilLambda < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/nil_lambda.rb#42
+  def nil_return?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/nil_lambda.rb#46
+  def on_block(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/nil_lambda.rb#58
+  def autocorrect(corrector, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/nil_lambda.rb#39
+RuboCop::Cop::Style::NilLambda::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for non-nil checks, which are usually redundant.
+#
+# With `IncludeSemanticChanges` set to `false` by default, this cop
+# does not report offenses for `!x.nil?` and does no changes that might
+# change behavior.
+# Also `IncludeSemanticChanges` set to `false` with `EnforcedStyle: comparison` of
+# `Style/NilComparison` cop, this cop does not report offenses for `x != nil` and
+# does no changes to `!x.nil?` style.
+#
+# With `IncludeSemanticChanges` set to `true`, this cop reports offenses
+# for `!x.nil?` and autocorrects that and `x != nil` to solely `x`, which
+# is *usually* OK, but might change behavior.
+#
+# @example
+#   # bad
+#   if x != nil
+#   end
+#
+#   # good
+#   if x
+#   end
+#
+#   # Non-nil checks are allowed if they are the final nodes of predicate.
+#   # good
+#   def signed_in?
+#   !current_user.nil?
+#   end
+# @example IncludeSemanticChanges: false (default)
+#   # good
+#   if !x.nil?
+#   end
+# @example IncludeSemanticChanges: true
+#   # bad
+#   if !x.nil?
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#44
+class RuboCop::Cop::Style::NonNilCheck < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#59
+  def nil_check?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#62
+  def not_and_nil_check?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#53
+  def not_equal_to_nil?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#73
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#73
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#64
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#56
+  def unless_check?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#93
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#123
+  def autocorrect_comparison(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#137
+  def autocorrect_non_nil(corrector, node, inner_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#145
+  def autocorrect_unless_nil(corrector, node, receiver); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#119
+  def include_semantic_changes?; end
+
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#110
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#150
+  def nil_comparison_style; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#88
+  def register_offense?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#104
+  def unless_and_nil_check?(send_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#48
+RuboCop::Cop::Style::NonNilCheck::MSG_FOR_REDUNDANCY = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#47
+RuboCop::Cop::Style::NonNilCheck::MSG_FOR_REPLACEMENT = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/non_nil_check.rb#50
+RuboCop::Cop::Style::NonNilCheck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for uses of the keyword `not` instead of `!`.
+#
+# @example
+#
+#   # bad - parentheses are required because of op precedence
+#   x = (not something)
+#
+#   # good
+#   x = !something
+#
+# source://rubocop//lib/rubocop/cop/style/not.rb#16
+class RuboCop::Cop::Style::Not < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/not.rb#32
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/not.rb#60
+  def correct_opposite_method(corrector, range, child); end
+
+  # source://rubocop//lib/rubocop/cop/style/not.rb#65
+  def correct_with_parens(corrector, range, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/not.rb#70
+  def correct_without_parens(corrector, range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/not.rb#50
+  def opposite_method?(child); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/not.rb#54
+  def requires_parens?(child); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/not.rb#20
+RuboCop::Cop::Style::Not::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/not.rb#23
+RuboCop::Cop::Style::Not::OPPOSITE_METHODS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/style/not.rb#21
+RuboCop::Cop::Style::Not::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for numbered parameters.
+#
+# It can either restrict the use of numbered parameters to
+# single-lined blocks, or disallow completely numbered parameters.
+#
+# @example EnforcedStyle: allow_single_line (default)
+#   # bad
+#   collection.each do
+#   puts _1
+#   end
+#
+#   # good
+#   collection.each { puts _1 }
+# @example EnforcedStyle: disallow
+#   # bad
+#   collection.each { puts _1 }
+#
+#   # good
+#   collection.each { |item| puts item }
+#
+# source://rubocop//lib/rubocop/cop/style/numbered_parameters.rb#27
+class RuboCop::Cop::Style::NumberedParameters < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/numbered_parameters.rb#36
+  def on_numblock(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/numbered_parameters.rb#31
+RuboCop::Cop::Style::NumberedParameters::MSG_DISALLOW = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/numbered_parameters.rb#32
+RuboCop::Cop::Style::NumberedParameters::MSG_MULTI_LINE = T.let(T.unsafe(nil), String)
+
+# Detects use of an excessive amount of numbered parameters in a
+# single block. Having too many numbered parameters can make code too
+# cryptic and hard to read.
+#
+# The cop defaults to registering an offense if there is more than 1 numbered
+# parameter but this maximum can be configured by setting `Max`.
+#
+# @example Max: 1 (default)
+#   # bad
+#   use_multiple_numbered_parameters { _1.call(_2, _3, _4) }
+#
+#   # good
+#   array.each { use_array_element_as_numbered_parameter(_1) }
+#   hash.each { use_only_hash_value_as_numbered_parameter(_2) }
+#
+# source://rubocop//lib/rubocop/cop/style/numbered_parameters_limit.rb#20
+class RuboCop::Cop::Style::NumberedParametersLimit < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11
+  def max=(value); end
+
+  # source://rubocop//lib/rubocop/cop/style/numbered_parameters_limit.rb#32
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/numbered_parameters_limit.rb#49
+  def max_count; end
+
+  # source://rubocop//lib/rubocop/cop/style/numbered_parameters_limit.rb#43
+  def numbered_parameter_nodes(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/numbered_parameters_limit.rb#24
+RuboCop::Cop::Style::NumberedParametersLimit::DEFAULT_MAX_VALUE = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop//lib/rubocop/cop/style/numbered_parameters_limit.rb#29
+RuboCop::Cop::Style::NumberedParametersLimit::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/numbered_parameters_limit.rb#30
+RuboCop::Cop::Style::NumberedParametersLimit::NUMBERED_PARAMETER_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# Checks for octal, hex, binary, and decimal literals using
+# uppercase prefixes and corrects them to lowercase prefix
+# or no prefix (in case of decimals).
+#
+# @example EnforcedOctalStyle: zero_with_o (default)
+#   # bad - missing octal prefix
+#   num = 01234
+#
+#   # bad - uppercase prefix
+#   num = 0O1234
+#   num = 0X12AB
+#   num = 0B10101
+#
+#   # bad - redundant decimal prefix
+#   num = 0D1234
+#   num = 0d1234
+#
+#   # good
+#   num = 0o1234
+#   num = 0x12AB
+#   num = 0b10101
+#   num = 1234
+# @example EnforcedOctalStyle: zero_only
+#   # bad
+#   num = 0o1234
+#   num = 0O1234
+#
+#   # good
+#   num = 01234
+#
+# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#36
+class RuboCop::Cop::Style::NumericLiteralPrefix < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::IntegerNode
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#52
+  def on_int(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#109
+  def format_binary(source); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#113
+  def format_decimal(source); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#105
+  def format_hex(source); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#97
+  def format_octal(source); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#101
+  def format_octal_zero_only(source); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#82
+  def hex_bin_dec_literal_type(literal); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#68
+  def literal_type(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#64
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#74
+  def octal_literal_type(literal); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#93
+  def octal_zero_only?; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#49
+RuboCop::Cop::Style::NumericLiteralPrefix::BINARY_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#43
+RuboCop::Cop::Style::NumericLiteralPrefix::BINARY_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#50
+RuboCop::Cop::Style::NumericLiteralPrefix::DECIMAL_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#44
+RuboCop::Cop::Style::NumericLiteralPrefix::DECIMAL_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#48
+RuboCop::Cop::Style::NumericLiteralPrefix::HEX_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#42
+RuboCop::Cop::Style::NumericLiteralPrefix::HEX_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#47
+RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#41
+RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#46
+RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_ZERO_ONLY_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/numeric_literal_prefix.rb#40
+RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_ZERO_ONLY_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# Checks for big numeric literals without `_` between groups
+# of digits in them.
+#
+# Additional allowed patterns can be added by adding regexps to
+# the `AllowedPatterns` configuration. All regexps are treated
+# as anchored even if the patterns do not contain anchors (so
+# `\d{4}_\d{4}` will allow `1234_5678` but not `1234_5678_9012`).
+#
+# NOTE: Even if `AllowedPatterns` are given, autocorrection will
+# only correct to the standard pattern of an `_` every 3 digits.
+#
+# @example
+#
+#   # bad
+#   1000000
+#   1_00_000
+#   1_0000
+#
+#   # good
+#   1_000_000
+#   1000
+# @example Strict: false (default)
+#
+#   # good
+#   10_000_00 # typical representation of $10,000 in cents
+# @example Strict: true
+#
+#   # bad
+#   10_000_00 # typical representation of $10,000 in cents
+# @example AllowedNumbers: [3000]
+#
+#   # good
+#   3000 # You can specify allowed numbers. (e.g. port number)
+#
+# source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#43
+class RuboCop::Cop::Style::NumericLiterals < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::IntegerNode
+  include ::RuboCop::Cop::AllowedPattern
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/exclude_limit.rb#11
+  def min_digits=(value); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#60
+  def on_float(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#56
+  def on_int(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#118
+  def allowed_numbers; end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#122
+  def allowed_patterns; end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#66
+  def check(node); end
+
+  # @param int_part [String]
+  #
+  # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#107
+  def format_int_part(int_part); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#93
+  def format_number(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#114
+  def min_digits; end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#82
+  def register_offense(node, &_block); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#89
+  def short_group_regex; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#49
+RuboCop::Cop::Style::NumericLiterals::DELIMITER_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/numeric_literals.rb#48
+RuboCop::Cop::Style::NumericLiterals::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for usage of comparison operators (`==`,
+# `>`, `<`) to test numbers as zero, positive, or negative.
+# These can be replaced by their respective predicate methods.
+# This cop can also be configured to do the reverse.
+#
+# This cop's allowed methods can be customized with `AllowedMethods`.
+# By default, there are no allowed methods.
+#
+# This cop disregards `#nonzero?` as its value is truthy or falsey,
+# but not `true` and `false`, and thus not always interchangeable with
+# `!= 0`.
+#
+# This cop allows comparisons to global variables, since they are often
+# populated with objects which can be compared with integers, but are
+# not themselves `Integer` polymorphic.
+#
+# @example EnforcedStyle: predicate (default)
+#   # bad
+#   foo == 0
+#   0 > foo
+#   bar.baz > 0
+#
+#   # good
+#   foo.zero?
+#   foo.negative?
+#   bar.baz.positive?
+# @example EnforcedStyle: comparison
+#   # bad
+#   foo.zero?
+#   foo.negative?
+#   bar.baz.positive?
+#
+#   # good
+#   foo == 0
+#   0 > foo
+#   bar.baz > 0
+# @example AllowedMethods: [] (default) with EnforcedStyle: predicate
+#   # bad
+#   foo == 0
+#   0 > foo
+#   bar.baz > 0
+# @example AllowedMethods: [==] with EnforcedStyle: predicate
+#   # good
+#   foo == 0
+#
+#   # bad
+#   0 > foo
+#   bar.baz > 0
+# @example AllowedPatterns: [] (default) with EnforcedStyle: comparison
+#   # bad
+#   foo.zero?
+#   foo.negative?
+#   bar.baz.positive?
+# @example AllowedPatterns: ['zero'] with EnforcedStyle: predicate
+#   # good
+#   # bad
+#   foo.zero?
+#
+#   # bad
+#   foo.negative?
+#   bar.baz.positive?
+#
+# source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#78
+class RuboCop::Cop::Style::NumericPredicate < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#174
+  def comparison(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#179
+  def inverted_comparison(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#90
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#169
+  def predicate(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#107
+  def allowed_method_name?(name); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#111
+  def check(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#154
+  def invert; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#162
+  def negated?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#134
+  def parenthesized_source(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#124
+  def replacement(node, numeric, operation); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#146
+  def replacement_supported?(operator); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#142
+  def require_parentheses?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#84
+RuboCop::Cop::Style::NumericPredicate::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#86
+RuboCop::Cop::Style::NumericPredicate::REPLACEMENTS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/style/numeric_predicate.rb#88
+RuboCop::Cop::Style::NumericPredicate::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Enforces the use of consistent method names
+# `Object#yield_self` or `Object#then`.
+#
+# @example EnforcedStyle: then (default)
+#
+#   # bad
+#   obj.yield_self { |x| x.do_something }
+#
+#   # good
+#   obj.then { |x| x.do_something }
+# @example EnforcedStyle: yield_self
+#
+#   # bad
+#   obj.then { |x| x.do_something }
+#
+#   # good
+#   obj.yield_self { |x| x.do_something }
+#
+# source://rubocop//lib/rubocop/cop/style/object_then.rb#25
+class RuboCop::Cop::Style::ObjectThen < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/object_then.rb#34
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/object_then.rb#34
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/object_then.rb#40
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/object_then.rb#48
+  def check_method_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/object_then.rb#70
+  def message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/object_then.rb#59
+  def preferred_method?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/object_then.rb#32
+RuboCop::Cop::Style::ObjectThen::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for uses of if/then/else/end constructs on a single line.
+# AlwaysCorrectToMultiline config option can be set to true to auto-convert all offenses to
+# multi-line constructs. When AlwaysCorrectToMultiline is false (default case) the
+# autocorrect will first try converting them to ternary operators.
+#
+# @example
+#   # bad
+#   if foo then bar else baz end
+#
+#   # bad
+#   unless foo then baz else bar end
+#
+#   # good
+#   foo ? bar : baz
+#
+#   # good
+#   bar if foo
+#
+#   # good
+#   if foo then bar end
+#
+#   # good
+#   if foo
+#   bar
+#   else
+#   baz
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#33
+class RuboCop::Cop::Style::OneLineConditional < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::OnNormalIfUnless
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#42
+  def on_normal_if_unless(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#81
+  def always_multiline?; end
+
+  # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#63
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#85
+  def cannot_replace_to_ternary?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#97
+  def expr_replacement(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#118
+  def keyword_with_changed_precedence?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#59
+  def message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#111
+  def method_call_with_changed_precedence?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#103
+  def requires_parentheses?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#71
+  def ternary_correction(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#89
+  def ternary_replacement(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/one_line_conditional.rb#39
+RuboCop::Cop::Style::OneLineConditional::MSG = T.let(T.unsafe(nil), String)
+
+# Flags uses of OpenStruct, as it is now officially discouraged
+# to be used for performance, version compatibility, and potential security issues.
+#
+# @example
+#
+#   # bad
+#   point = OpenStruct.new(x: 0, y: 1)
+#
+#   # good
+#   Point = Struct.new(:x, :y)
+#   point = Point.new(0, 1)
+#
+#   # also good
+#   point = { x: 0, y: 1 }
+#
+#   # bad
+#   test_double = OpenStruct.new(a: 'b')
+#
+#   # good (assumes test using rspec-mocks)
+#   test_double = double
+#   allow(test_double).to receive(:a).and_return('b')
+#
+# source://rubocop//lib/rubocop/cop/style/open_struct_use.rb#44
+class RuboCop::Cop::Style::OpenStructUse < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/style/open_struct_use.rb#52
+  def on_const(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/open_struct_use.rb#48
+  def uses_open_struct?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/open_struct_use.rb#61
+  def custom_class_or_module_definition?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/open_struct_use.rb#45
+RuboCop::Cop::Style::OpenStructUse::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for redundant dot before operator method call.
+# The target operator methods are `|`, `^`, `&`, ``<=>``, `==`, `===`, `=~`, `>`, `>=`, `<`,
+# ``<=``, `<<`, `>>`, `+`, `-`, `*`, `/`, `%`, `**`, `~`, `!`, `!=`, and `!~`.
+#
+# @example
+#
+#   # bad
+#   foo.+ bar
+#   foo.& bar
+#
+#   # good
+#   foo + bar
+#   foo & bar
+#
+# source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#20
+class RuboCop::Cop::Style::OperatorMethodCall < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#30
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#75
+  def insert_space_after?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#58
+  def invalid_syntax_argument?(argument); end
+
+  # Checks for an acceptable case of `foo.+(bar).baz`.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#52
+  def method_call_with_parenthesized_arg?(argument); end
+
+  # source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#64
+  def wrap_in_parentheses_if_chained(corrector, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#25
+RuboCop::Cop::Style::OperatorMethodCall::INVALID_SYNTAX_ARG_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#23
+RuboCop::Cop::Style::OperatorMethodCall::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/operator_method_call.rb#24
+RuboCop::Cop::Style::OperatorMethodCall::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for options hashes and discourages them if the
+# current Ruby version supports keyword arguments.
+#
+# @example
+#
+#   # bad
+#   def fry(options = {})
+#   temperature = options.fetch(:temperature, 300)
+#   # ...
+#   end
+#
+#   # good
+#   def fry(temperature: 300)
+#   # ...
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/option_hash.rb#22
+class RuboCop::Cop::Style::OptionHash < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/style/option_hash.rb#30
+  def on_args(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/option_hash.rb#26
+  def option_hash(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/option_hash.rb#39
+  def allowlist; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/option_hash.rb#48
+  def super_used?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/option_hash.rb#43
+  def suspicious_name?(arg_name); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/option_hash.rb#23
+RuboCop::Cop::Style::OptionHash::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for optional arguments to methods
+# that do not come at the end of the argument list.
+#
+# @example
+#   # bad
+#   def foo(a = 1, b, c)
+#   end
+#
+#   # good
+#   def baz(a, b, c = 1)
+#   end
+#
+#   def foobar(a = 1, b = 2, c = 3)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/optional_arguments.rb#24
+class RuboCop::Cop::Style::OptionalArguments < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/style/optional_arguments.rb#27
+  def on_def(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/optional_arguments.rb#45
+  def argument_positions(arguments); end
+
+  # source://rubocop//lib/rubocop/cop/style/optional_arguments.rb#33
+  def each_misplaced_optional_arg(arguments); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/optional_arguments.rb#25
+RuboCop::Cop::Style::OptionalArguments::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for places where keyword arguments can be used instead of
+# boolean arguments when defining methods. `respond_to_missing?` method is allowed by default.
+# These are customizable with `AllowedMethods` option.
+#
+# @example
+#   # bad
+#   def some_method(bar = false)
+#   puts bar
+#   end
+#
+#   # bad - common hack before keyword args were introduced
+#   def some_method(options = {})
+#   bar = options.fetch(:bar, false)
+#   puts bar
+#   end
+#
+#   # good
+#   def some_method(bar: false)
+#   puts bar
+#   end
+# @example AllowedMethods: ['some_method']
+#   # good
+#   def some_method(bar = false)
+#   puts bar
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/optional_boolean_parameter.rb#37
+class RuboCop::Cop::Style::OptionalBooleanParameter < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+
+  # source://rubocop//lib/rubocop/cop/style/optional_boolean_parameter.rb#43
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/optional_boolean_parameter.rb#43
+  def on_defs(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/optional_boolean_parameter.rb#56
+  def format_message(argument); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/optional_boolean_parameter.rb#40
+RuboCop::Cop::Style::OptionalBooleanParameter::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for potential usage of the `||=` operator.
+#
+# @example
+#   # bad
+#   name = name ? name : 'Bozhidar'
+#
+#   # bad
+#   name = if name
+#   name
+#   else
+#   'Bozhidar'
+#   end
+#
+#   # bad
+#   unless name
+#   name = 'Bozhidar'
+#   end
+#
+#   # bad
+#   name = 'Bozhidar' unless name
+#
+#   # good - set name to 'Bozhidar', only if it's nil or false
+#   name ||= 'Bozhidar'
+#
+# source://rubocop//lib/rubocop/cop/style/or_assignment.rb#29
+class RuboCop::Cop::Style::OrAssignment < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#57
+  def on_cvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#57
+  def on_gvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#51
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#57
+  def on_ivasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#57
+  def on_lvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#35
+  def ternary_assignment?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#44
+  def unless_assignment?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#70
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#80
+  def take_variable_and_default_from_ternary(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/or_assignment.rb#85
+  def take_variable_and_default_from_unless(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/or_assignment.rb#32
+RuboCop::Cop::Style::OrAssignment::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for simple usages of parallel assignment.
+# This will only complain when the number of variables
+# being assigned matched the number of assigning variables.
+#
+# @example
+#   # bad
+#   a, b, c = 1, 2, 3
+#   a, b, c = [1, 2, 3]
+#
+#   # good
+#   one, two = *foo
+#   a, b = foo()
+#   a, b = b, a
+#
+#   a = 1
+#   b = 2
+#   c = 3
+#
+# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#25
+class RuboCop::Cop::Style::ParallelAssignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RescueNode
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#124
+  def implicit_self_getter?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#31
+  def on_masgn(node); end
+
+  private
+
+  # Converts (send nil :something) nodes to (send (:self) :something).
+  # This makes the sorting algorithm work for expressions such as
+  # `self.a, self.b = b, a`.
+  #
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#117
+  def add_self_to_getters(right_elements); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#64
+  def allowed_lhs?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#58
+  def allowed_masign?(lhs_elements, rhs_elements); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#72
+  def allowed_rhs?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#84
+  def assignment_corrector(node, rhs, order); end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#49
+  def autocorrect(corrector, node, lhs, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#100
+  def find_valid_order(left_elements, right_elements); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#183
+  def modifier_statement?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#80
+  def return_of_method_call?(node); end
+end
+
+# Helper class necessitated by silly design of TSort prior to Ruby 2.1
+# Newer versions have a better API, but that doesn't help us
+#
+# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#128
+class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter
+  include ::TSort
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # @return [AssignmentSorter] a new instance of AssignmentSorter
+  #
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#141
+  def initialize(assignments); end
+
+  # `lhs` is an assignment method call like `obj.attr=` or `ary[idx]=`.
+  # Does `rhs` access the same value which is assigned by `lhs`?
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#170
+  def accesses?(rhs, lhs); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#163
+  def dependency?(lhs, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#139
+  def matching_calls(param0, param1, param2); end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#149
+  def tsort_each_child(assignment); end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#145
+  def tsort_each_node(*_arg0, **_arg1, &_arg2); end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#136
+  def uses_var?(param0, param1); end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#133
+  def var_name(param0 = T.unsafe(nil)); end
+end
+
+# An internal class for correcting parallel assignment
+#
+# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#190
+class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector
+  include ::RuboCop::Cop::Alignment
+
+  # @return [GenericCorrector] a new instance of GenericCorrector
+  #
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#195
+  def initialize(node, rhs, modifier, config, new_elements); end
+
+  # Returns the value of attribute config.
+  #
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#193
+  def config; end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#203
+  def correction; end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#207
+  def correction_range; end
+
+  # Returns the value of attribute node.
+  #
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#193
+  def node; end
+
+  # Returns the value of attribute rescue_result.
+  #
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#193
+  def rescue_result; end
+
+  # Returns the value of attribute rhs.
+  #
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#193
+  def rhs; end
+
+  protected
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#213
+  def assignment; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#234
+  def cop_config; end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#230
+  def extract_sources(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#219
+  def source(node, loc); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#29
+RuboCop::Cop::Style::ParallelAssignment::MSG = T.let(T.unsafe(nil), String)
+
+# An internal class for correcting parallel assignment
+# guarded by if, unless, while, or until
+#
+# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#276
+class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector < ::RuboCop::Cop::Style::ParallelAssignment::GenericCorrector
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#277
+  def correction; end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#286
+  def correction_range; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#292
+  def modifier_range(node); end
+end
+
+# An internal class for correcting parallel assignment
+# protected by rescue
+#
+# source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#241
+class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector < ::RuboCop::Cop::Style::ParallelAssignment::GenericCorrector
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#242
+  def correction; end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#253
+  def correction_range; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#264
+  def begin_correction(rescue_result); end
+
+  # source://rubocop//lib/rubocop/cop/style/parallel_assignment.rb#259
+  def def_correction(rescue_result); end
+end
+
+# Checks for the presence of superfluous parentheses around the
+# condition of if/unless/while/until.
+#
+# `AllowSafeAssignment` option for safe assignment.
+# By safe assignment we mean putting parentheses around
+# an assignment to indicate "I know I'm using an assignment
+# as a condition. It's not a mistake."
+#
+# @example
+#   # bad
+#   x += 1 while (x < 10)
+#   foo unless (bar || baz)
+#
+#   if (x > 10)
+#   elsif (x < 3)
+#   end
+#
+#   # good
+#   x += 1 while x < 10
+#   foo unless bar || baz
+#
+#   if x > 10
+#   elsif x < 3
+#   end
+# @example AllowSafeAssignment: true (default)
+#   # good
+#   foo unless (bar = baz)
+# @example AllowSafeAssignment: false
+#   # bad
+#   foo unless (bar = baz)
+# @example AllowInMultilineConditions: false (default)
+#   # bad
+#   if (x > 10 &&
+#   y > 10)
+#   end
+#
+#   # good
+#   if x > 10 &&
+#   y > 10
+#   end
+# @example AllowInMultilineConditions: true
+#   # good
+#   if (x > 10 &&
+#   y > 10)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#56
+class RuboCop::Cop::Style::ParenthesesAroundCondition < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::SafeAssignment
+  include ::RuboCop::Cop::Parentheses
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#76
+  def control_op_condition(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#62
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#68
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#68
+  def on_while(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#130
+  def allow_multiline_conditions?; end
+
+  # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#118
+  def message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#111
+  def modifier_op?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#124
+  def parens_allowed?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#80
+  def process_control_op(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#96
+  def require_parentheses?(node, condition_body); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/parentheses_around_condition.rb#103
+  def semicolon_separated_expressions?(first_exp, rest_exps); end
+end
+
+# Enforces the consistent usage of `%`-literal delimiters.
+#
+# Specify the 'default' key to set all preferred delimiters at once. You
+# can continue to specify individual preferred delimiters to override the
+# default.
+#
+# @example
+#   # Style/PercentLiteralDelimiters:
+#   #   PreferredDelimiters:
+#   #     default: '[]'
+#   #     '%i':    '()'
+#
+#   # good
+#   %w[alpha beta] + %i(gamma delta)
+#
+#   # bad
+#   %W(alpha #{beta})
+#
+#   # bad
+#   %I(alpha beta)
+#
+# source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#26
+class RuboCop::Cop::Style::PercentLiteralDelimiters < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::PercentLiteral
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#30
+  def on_array(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#38
+  def on_dstr(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#34
+  def on_regexp(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#38
+  def on_str(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#43
+  def on_sym(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#47
+  def on_xstr(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#93
+  def contains_delimiter?(node, delimiters); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#82
+  def contains_preferred_delimiter?(node, type); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#86
+  def include_same_character_as_used_for_delimiter?(node, type); end
+
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#107
+  def matchpairs(begin_delimiter); end
+
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#67
+  def message(type); end
+
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#53
+  def on_percent_literal(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#74
+  def preferred_delimiters_for(type); end
+
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#99
+  def string_source(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/percent_literal_delimiters.rb#78
+  def uses_preferred_delimiter?(node, type); end
+end
+
+# Checks for usage of the %Q() syntax when %q() would do.
+#
+# @example EnforcedStyle: lower_case_q (default)
+#   # The `lower_case_q` style prefers `%q` unless
+#   # interpolation is needed.
+#   # bad
+#   %Q[Mix the foo into the baz.]
+#   %Q(They all said: 'Hooray!')
+#
+#   # good
+#   %q[Mix the foo into the baz]
+#   %q(They all said: 'Hooray!')
+# @example EnforcedStyle: upper_case_q
+#   # The `upper_case_q` style requires the sole use of `%Q`.
+#   # bad
+#   %q/Mix the foo into the baz./
+#   %q{They all said: 'Hooray!'}
+#
+#   # good
+#   %Q/Mix the foo into the baz./
+#   %Q{They all said: 'Hooray!'}
+#
+# source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#28
+class RuboCop::Cop::Style::PercentQLiterals < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::PercentLiteral
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#36
+  def on_str(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#55
+  def correct_literal_style?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#64
+  def corrected(src); end
+
+  # source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#60
+  def message(_range); end
+
+  # source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#42
+  def on_percent_literal(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#33
+RuboCop::Cop::Style::PercentQLiterals::LOWER_CASE_Q_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/percent_q_literals.rb#34
+RuboCop::Cop::Style::PercentQLiterals::UPPER_CASE_Q_MSG = T.let(T.unsafe(nil), String)
+
+# Looks for uses of Perl-style regexp match
+# backreferences and their English versions like
+# $1, $2, $&, &+, $MATCH, $PREMATCH, etc.
+#
+# @example
+#   # bad
+#   puts $1
+#
+#   # good
+#   puts Regexp.last_match(1)
+#
+# source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#16
+class RuboCop::Cop::Style::PerlBackrefs < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#21
+  def on_back_ref(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#25
+  def on_gvar(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#29
+  def on_nth_ref(node); end
+
+  private
+
+  # @param node [RuboCop::AST::Node]
+  # @private
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#99
+  def constant_prefix(node); end
+
+  # @param node [RuboCop::AST::Node]
+  # @private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#38
+  def derived_from_braceless_interpolation?(node); end
+
+  # @param node [RuboCop::AST::Node]
+  # @param preferred_expression [String]
+  # @private
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#46
+  def format_message(node:, preferred_expression:); end
+
+  # @param node [RuboCop::AST::Node]
+  # @private
+  #
+  # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#109
+  def on_back_ref_or_gvar_or_nth_ref(node); end
+
+  # @param node [RuboCop::AST::Node]
+  # @private
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#58
+  def original_expression_of(node); end
+
+  # @param node [RuboCop::AST::Node]
+  # @private
+  # @return [String, nil]
+  #
+  # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#70
+  def preferred_expression_to(node); end
+
+  # @param node [RuboCop::AST::Node]
+  # @private
+  # @return [String, nil]
+  #
+  # source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#89
+  def preferred_expression_to_node_with_constant_prefix(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/perl_backrefs.rb#19
+RuboCop::Cop::Style::PerlBackrefs::MESSAGE_FORMAT = T.let(T.unsafe(nil), String)
+
+# Checks for uses of methods `Hash#has_key?` and
+# `Hash#has_value?`, and suggests using `Hash#key?` and `Hash#value?` instead.
+#
+# It is configurable to enforce the verbose method names, by using the
+# `EnforcedStyle: verbose` configuration.
+#
+# @example EnforcedStyle: short (default)
+#   # bad
+#   Hash#has_key?
+#   Hash#has_value?
+#
+#   # good
+#   Hash#key?
+#   Hash#value?
+# @example EnforcedStyle: verbose
+#   # bad
+#   Hash#key?
+#   Hash#value?
+#
+#   # good
+#   Hash#has_key?
+#   Hash#has_value?
+#
+# source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#33
+class RuboCop::Cop::Style::PreferredHashMethods < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#43
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#43
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#56
+  def message(method_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#68
+  def offending_selector?(method_name); end
+
+  # source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#60
+  def proper_method_name(method_name); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#37
+RuboCop::Cop::Style::PreferredHashMethods::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#39
+RuboCop::Cop::Style::PreferredHashMethods::OFFENDING_SELECTORS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/style/preferred_hash_methods.rb#41
+RuboCop::Cop::Style::PreferredHashMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for uses of Proc.new where Kernel#proc
+# would be more appropriate.
+#
+# @example
+#   # bad
+#   p = Proc.new { |n| puts n }
+#
+#   # good
+#   p = proc { |n| puts n }
+#
+# source://rubocop//lib/rubocop/cop/style/proc.rb#16
+class RuboCop::Cop::Style::Proc < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/proc.rb#25
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/proc.rb#25
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/proc.rb#22
+  def proc_new?(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/proc.rb#19
+RuboCop::Cop::Style::Proc::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if the quotes used for quoted symbols match the configured defaults.
+# By default uses the same configuration as `Style/StringLiterals`; if that
+# cop is not enabled, the default `EnforcedStyle` is `single_quotes`.
+#
+# String interpolation is always kept in double quotes.
+#
+# NOTE: `Lint/SymbolConversion` can be used in parallel to ensure that symbols
+# are not quoted that don't need to be. This cop is for configuring the quoting
+# style to use for symbols that require quotes.
+#
+# @example EnforcedStyle: same_as_string_literals (default) / single_quotes
+#   # bad
+#   :"abc-def"
+#
+#   # good
+#   :'abc-def'
+#   :"#{str}"
+#   :"a\'b"
+# @example EnforcedStyle: double_quotes
+#   # bad
+#   :'abc-def'
+#
+#   # good
+#   :"abc-def"
+#   :"#{str}"
+#   :"a\'b"
+#
+# source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#33
+class RuboCop::Cop::Style::QuotedSymbols < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::SymbolHelp
+  include ::RuboCop::Cop::StringLiteralsHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#44
+  def on_sym(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#106
+  def alternative_style; end
+
+  # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#71
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#88
+  def correct_quotes(str); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#83
+  def hash_colon_key?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#61
+  def invalid_double_quotes?(source); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#110
+  def quoted?(sym_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#99
+  def style; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#114
+  def wrong_quotes?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#41
+RuboCop::Cop::Style::QuotedSymbols::MSG_DOUBLE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/quoted_symbols.rb#39
+RuboCop::Cop::Style::QuotedSymbols::MSG_SINGLE = T.let(T.unsafe(nil), String)
+
+# Checks the args passed to `fail` and `raise`. For exploded
+# style (default), it recommends passing the exception class and message
+# to `raise`, rather than construct an instance of the error. It will
+# still allow passing just a message, or the construction of an error
+# with more than one argument.
+#
+# The exploded style works identically, but with the addition that it
+# will also suggest constructing error objects when the exception is
+# passed multiple arguments.
+#
+# The exploded style has an `AllowedCompactTypes` configuration
+# option that takes an Array of exception name Strings.
+#
+# @example EnforcedStyle: exploded (default)
+#   # bad
+#   raise StandardError.new('message')
+#
+#   # good
+#   raise StandardError, 'message'
+#   fail 'message'
+#   raise MyCustomError
+#   raise MyCustomError.new(arg1, arg2, arg3)
+#   raise MyKwArgError.new(key1: val1, key2: val2)
+#
+#   # With `AllowedCompactTypes` set to ['MyWrappedError']
+#   raise MyWrappedError.new(obj)
+#   raise MyWrappedError.new(obj), 'message'
+# @example EnforcedStyle: compact
+#   # bad
+#   raise StandardError, 'message'
+#   raise RuntimeError, arg1, arg2, arg3
+#
+#   # good
+#   raise StandardError.new('message')
+#   raise MyCustomError
+#   raise MyCustomError.new(arg1, arg2, arg3)
+#   fail 'message'
+#
+# source://rubocop//lib/rubocop/cop/style/raise_args.rb#47
+class RuboCop::Cop::Style::RaiseArgs < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/raise_args.rb#56
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/raise_args.rb#132
+  def acceptable_exploded_args?(args); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/raise_args.rb#146
+  def allowed_non_exploded_type?(arg); end
+
+  # source://rubocop//lib/rubocop/cop/style/raise_args.rb#95
+  def check_compact(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/raise_args.rb#111
+  def check_exploded(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/raise_args.rb#69
+  def correction_compact_to_exploded(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/raise_args.rb#81
+  def correction_exploded_to_compact(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/raise_args.rb#152
+  def requires_parens?(parent); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/raise_args.rb#128
+  def use_new_method?(first_arg); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/raise_args.rb#52
+RuboCop::Cop::Style::RaiseArgs::COMPACT_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/raise_args.rb#51
+RuboCop::Cop::Style::RaiseArgs::EXPLODED_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/raise_args.rb#54
+RuboCop::Cop::Style::RaiseArgs::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for the use of randomly generated numbers,
+# added/subtracted with integer literals, as well as those with
+# Integer#succ and Integer#pred methods. Prefer using ranges instead,
+# as it clearly states the intentions.
+#
+# @example
+#   # bad
+#   rand(6) + 1
+#   1 + rand(6)
+#   rand(6) - 1
+#   1 - rand(6)
+#   rand(6).succ
+#   rand(6).pred
+#   Random.rand(6) + 1
+#   Kernel.rand(6) + 1
+#   rand(0..5) + 1
+#
+#   # good
+#   rand(1..6)
+#   rand(1...7)
+#
+# source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#26
+class RuboCop::Cop::Style::RandomWithOffset < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#33
+  def integer_op_rand?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#63
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#54
+  def rand_modified?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#43
+  def rand_op_integer?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#73
+  def random_call(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#147
+  def to_int(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#78
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#135
+  def boundaries_from_random_node(random_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#88
+  def corrected_integer_op_rand(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#118
+  def corrected_rand_modified(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#103
+  def corrected_rand_op_integer(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#131
+  def prefix_from_prefix_node(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#29
+RuboCop::Cop::Style::RandomWithOffset::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/random_with_offset.rb#30
+RuboCop::Cop::Style::RandomWithOffset::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for a redundant argument passed to certain methods.
+#
+# NOTE: This cop is limited to methods with single parameter.
+#
+# Method names and their redundant arguments can be configured like this:
+#
+# [source,yaml]
+# ----
+# Methods:
+#   join: ''
+#   sum: 0
+#   split: ' '
+#   chomp: "\n"
+#   chomp!: "\n"
+#   foo: 2
+# ----
+#
+# @example
+#   # bad
+#   array.join('')
+#   [1, 2, 3].join("")
+#   array.sum(0)
+#   exit(true)
+#   exit!(false)
+#   string.split(" ")
+#   "first\nsecond".split(" ")
+#   string.chomp("\n")
+#   string.chomp!("\n")
+#   A.foo(2)
+#
+#   # good
+#   array.join
+#   [1, 2, 3].join
+#   array.sum
+#   exit
+#   exit!
+#   string.split
+#   "first second".split
+#   string.chomp
+#   string.chomp!
+#   A.foo
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#57
+class RuboCop::Cop::Style::RedundantArgument < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#64
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#64
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#108
+  def argument_matched?(target_argument, redundant_argument); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#100
+  def argument_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#120
+  def exclude_cntrl_character?(target_argument, redundant_argument); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#93
+  def redundant_arg_for_method(method_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#80
+  def redundant_argument?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#61
+RuboCop::Cop::Style::RedundantArgument::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_argument.rb#62
+RuboCop::Cop::Style::RedundantArgument::NO_RECEIVER_METHODS = T.let(T.unsafe(nil), Array)
+
+# Checks for the instantiation of array using redundant `Array` constructor.
+# Autocorrect replaces to array literal which is the simplest and fastest.
+#
+# @example
+#
+#   # bad
+#   Array.new([])
+#   Array[]
+#   Array([])
+#   Array.new(['foo', 'foo', 'foo'])
+#   Array['foo', 'foo', 'foo']
+#   Array(['foo', 'foo', 'foo'])
+#
+#   # good
+#   []
+#   ['foo', 'foo', 'foo']
+#   Array.new(3, 'foo')
+#   Array.new(3) { 'foo' }
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#25
+class RuboCop::Cop::Style::RedundantArrayConstructor < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#47
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#33
+  def redundant_array_constructor(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#69
+  def register_offense(range, node, replacement); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#28
+RuboCop::Cop::Style::RedundantArrayConstructor::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_array_constructor.rb#30
+RuboCop::Cop::Style::RedundantArrayConstructor::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for redundant assignment before returning.
+#
+# @example
+#   # bad
+#   def test
+#   x = foo
+#   x
+#   end
+#
+#   # bad
+#   def test
+#   if x
+#   z = foo
+#   z
+#   elsif y
+#   z = bar
+#   z
+#   end
+#   end
+#
+#   # good
+#   def test
+#   foo
+#   end
+#
+#   # good
+#   def test
+#   if x
+#   foo
+#   elsif y
+#   bar
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#40
+class RuboCop::Cop::Style::RedundantAssignment < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#50
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#50
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#46
+  def redundant_assignment?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#99
+  def check_begin_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#58
+  def check_branch(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#79
+  def check_case_match_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#74
+  def check_case_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#95
+  def check_ensure_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#84
+  def check_if_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#91
+  def check_rescue_node(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_assignment.rb#43
+RuboCop::Cop::Style::RedundantAssignment::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for redundant `begin` blocks.
+#
+# Currently it checks for code like this:
+#
+# @example
+#
+#   # bad
+#   def redundant
+#   begin
+#   ala
+#   bala
+#   rescue StandardError => e
+#   something
+#   end
+#   end
+#
+#   # good
+#   def preferred
+#   ala
+#   bala
+#   rescue StandardError => e
+#   something
+#   end
+#
+#   # bad
+#   begin
+#   do_something
+#   end
+#
+#   # good
+#   do_something
+#
+#   # bad
+#   # When using Ruby 2.5 or later.
+#   do_something do
+#   begin
+#   something
+#   rescue => ex
+#   anything
+#   end
+#   end
+#
+#   # good
+#   # In Ruby 2.5 or later, you can omit `begin` in `do-end` block.
+#   do_something do
+#   something
+#   rescue => ex
+#   anything
+#   end
+#
+#   # good
+#   # Stabby lambdas don't support implicit `begin` in `do-end` blocks.
+#   -> do
+#   begin
+#   foo
+#   rescue Bar
+#   baz
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#65
+class RuboCop::Cop::Style::RedundantBegin < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#76
+  def offensive_kwbegins(param0); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#88
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#80
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#80
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#99
+  def on_kwbegin(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#88
+  def on_numblock(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#107
+  def allowable_kwbegin?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#181
+  def begin_block_has_multiline_statements?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#173
+  def condition_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#185
+  def contain_rescue_or_ensure?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#166
+  def correct_modifier_form_after_multiline_begin_block(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#177
+  def empty_begin?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#114
+  def register_offense(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#143
+  def remove_begin(corrector, offense_range, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#131
+  def replace_begin_with_statement(corrector, offense_range, node); end
+
+  # Restore comments that occur between "begin" and "first_child".
+  # These comments will be moved to above the assignment line.
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#153
+  def restore_removed_comments(corrector, offense_range, node, first_child); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#160
+  def use_modifier_form_after_multiline_begin_block?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#198
+  def valid_begin_assignment?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#191
+  def valid_context_using_only_begin?(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#71
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_begin.rb#69
+RuboCop::Cop::Style::RedundantBegin::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for usage of the %W() syntax when %w() would do.
+#
+# @example
+#   # bad
+#   %W(cat dog pig)
+#   %W[door wall floor]
+#
+#   # good
+#   %w/swim run bike/
+#   %w[shirt pants shoes]
+#   %W(apple #{fruit} grape)
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_capital_w.rb#17
+class RuboCop::Cop::Style::RedundantCapitalW < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::PercentLiteral
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_capital_w.rb#23
+  def on_array(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_capital_w.rb#29
+  def on_percent_literal(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_capital_w.rb#38
+  def requires_interpolation?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_capital_w.rb#21
+RuboCop::Cop::Style::RedundantCapitalW::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for unnecessary conditional expressions.
+#
+# @example
+#   # bad
+#   a = b ? b : c
+#
+#   # good
+#   a = b || c
+#
+#   # bad
+#   if b
+#   b
+#   else
+#   c
+#   end
+#
+#   # good
+#   b || c
+#
+#   # good
+#   if b
+#   b
+#   elsif cond
+#   c
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#32
+class RuboCop::Cop::Style::RedundantCondition < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#43
+  def on_if(node); end
+
+  private
+
+  # If the argument is using an operator, it is an invalid syntax.
+  # e.g. `foo || *bar`, `foo || **bar`, and `foo || &bar`.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#167
+  def argument_with_operator?(argument); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#142
+  def asgn_type?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#132
+  def branches_have_assignment?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#146
+  def branches_have_method?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#240
+  def correct_ternary(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#187
+  def else_source(else_branch, arithmetic_operation); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#213
+  def else_source_if_has_assignment(else_branch); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#203
+  def else_source_if_has_method(else_branch); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#175
+  def if_source(if_branch, arithmetic_operation); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#223
+  def make_ternary_form(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#64
+  def message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#79
+  def offense?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#72
+  def range_of_offense(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#88
+  def redundant_condition?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#255
+  def require_braces?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#248
+  def require_parentheses?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#161
+  def same_method?(if_branch, else_branch); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#155
+  def single_argument_method?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#104
+  def synonymous_condition_and_branch?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#259
+  def use_arithmetic_operation?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#100
+  def use_hash_key_access?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#96
+  def use_hash_key_assignment?(else_branch); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#92
+  def use_if_branch?(else_branch); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#263
+  def without_argument_parentheses_method?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#38
+RuboCop::Cop::Style::RedundantCondition::ARGUMENT_WITH_OPERATOR_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#36
+RuboCop::Cop::Style::RedundantCondition::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_condition.rb#37
+RuboCop::Cop::Style::RedundantCondition::REDUNDANT_CONDITION = T.let(T.unsafe(nil), String)
+
+# Checks for redundant returning of true/false in conditionals.
+#
+# @example
+#   # bad
+#   x == y ? true : false
+#
+#   # bad
+#   if x == y
+#   true
+#   else
+#   false
+#   end
+#
+#   # good
+#   x == y
+#
+#   # bad
+#   x == y ? false : true
+#
+#   # good
+#   x != y
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#27
+class RuboCop::Cop::Style::RedundantConditional < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#36
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#56
+  def redundant_condition?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#61
+  def redundant_condition_inverted?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#78
+  def indented_else_node(expression, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#48
+  def message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#65
+  def offense?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#71
+  def replacement_condition(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#32
+RuboCop::Cop::Style::RedundantConditional::COMPARISON_OPERATOR_MATCHER = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_conditional.rb#34
+RuboCop::Cop::Style::RedundantConditional::MSG = T.let(T.unsafe(nil), String)
+
+# Avoid redundant `::` prefix on constant.
+#
+# How Ruby searches constant is a bit complicated, and it can often be difficult to
+# understand from the code whether the `::` is intended or not. Where `Module.nesting`
+# is empty, there is no need to prepend `::`, so it would be nice to consistently
+# avoid such meaningless `::` prefix to avoid confusion.
+#
+# NOTE: This cop is disabled if `Lint/ConstantResolution` cop is enabled to prevent
+# conflicting rules. Because it respects user configurations that want to enable
+# `Lint/ConstantResolution` cop which is disabled by default.
+#
+# @example
+#   # bad
+#   ::Const
+#
+#   # good
+#   Const
+#
+#   # bad
+#   class << self
+#   ::Const
+#   end
+#
+#   # good
+#   class << self
+#   Const
+#   end
+#
+#   # good
+#   class A
+#   ::Const
+#   end
+#
+#   # good
+#   module A
+#   ::Const
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#43
+class RuboCop::Cop::Style::RedundantConstantBase < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#48
+  def on_cbase(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#67
+  def bad?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#63
+  def lint_constant_resolution_config; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#59
+  def lint_constant_resolution_cop_enabled?; end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#71
+  def module_nesting_ancestors_of(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#77
+  def used_in_super_class_part?(node, class_node:); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_constant_base.rb#46
+RuboCop::Cop::Style::RedundantConstantBase::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for uses a redundant current directory in path.
+#
+# @example
+#
+#   # bad
+#   require_relative './path/to/feature'
+#
+#   # good
+#   require_relative 'path/to/feature'
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_current_directory_in_path.rb#16
+class RuboCop::Cop::Style::RedundantCurrentDirectoryInPath < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_current_directory_in_path.rb#24
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_current_directory_in_path.rb#22
+RuboCop::Cop::Style::RedundantCurrentDirectoryInPath::CURRENT_DIRECTORY_PATH = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_current_directory_in_path.rb#20
+RuboCop::Cop::Style::RedundantCurrentDirectoryInPath::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_current_directory_in_path.rb#21
+RuboCop::Cop::Style::RedundantCurrentDirectoryInPath::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for redundant uses of double splat hash braces.
+#
+# @example
+#
+#   # bad
+#   do_something(**{foo: bar, baz: qux})
+#
+#   # good
+#   do_something(foo: bar, baz: qux)
+#
+#   # bad
+#   do_something(**{foo: bar, baz: qux}.merge(options))
+#
+#   # good
+#   do_something(foo: bar, baz: qux, **options)
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#22
+class RuboCop::Cop::Style::RedundantDoubleSplatHashBraces < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#29
+  def on_hash(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#45
+  def allowed_double_splat_receiver?(kwsplat); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#55
+  def autocorrect(corrector, node, kwsplat); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#89
+  def autocorrect_merge_methods(corrector, merge_methods, kwsplat); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#85
+  def closing_brace(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#111
+  def convert_to_new_arguments(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#107
+  def extract_send_methods(kwsplat); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#123
+  def mergeable?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#81
+  def opening_brace(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#100
+  def range_of_merge_methods(merge_methods); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#66
+  def root_receiver(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#75
+  def select_merge_method_nodes(kwsplat); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#26
+RuboCop::Cop::Style::RedundantDoubleSplatHashBraces::MERGE_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb#25
+RuboCop::Cop::Style::RedundantDoubleSplatHashBraces::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for redundant `each`.
+#
+# @example
+#
+#   # bad
+#   array.each.each { |v| do_something(v) }
+#
+#   # good
+#   array.each { |v| do_something(v) }
+#
+#   # bad
+#   array.each.each_with_index { |v, i| do_something(v, i) }
+#
+#   # good
+#   array.each.with_index { |v, i| do_something(v, i) }
+#   array.each_with_index { |v, i| do_something(v, i) }
+#
+#   # bad
+#   array.each.each_with_object { |v, o| do_something(v, o) }
+#
+#   # good
+#   array.each.with_object { |v, o| do_something(v, o) }
+#   array.each_with_object { |v, o| do_something(v, o) }
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_each.rb#34
+class RuboCop::Cop::Style::RedundantEach < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_each.rb#43
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_each.rb#43
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_each.rb#96
+  def message(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_each.rb#86
+  def range(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_each.rb#64
+  def redundant_each_method(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_each.rb#107
+  def remove_redundant_each(corrector, range, redundant_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_each.rb#37
+RuboCop::Cop::Style::RedundantEach::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_each.rb#38
+RuboCop::Cop::Style::RedundantEach::MSG_WITH_INDEX = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_each.rb#39
+RuboCop::Cop::Style::RedundantEach::MSG_WITH_OBJECT = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_each.rb#41
+RuboCop::Cop::Style::RedundantEach::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for RuntimeError as the argument of raise/fail.
+#
+# @example
+#   # bad
+#   raise RuntimeError, 'message'
+#   raise RuntimeError.new('message')
+#
+#   # good
+#   raise 'message'
+#
+#   # bad - message is not a string
+#   raise RuntimeError, Object.new
+#   raise RuntimeError.new(Object.new)
+#
+#   # good
+#   raise Object.new.to_s
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#23
+class RuboCop::Cop::Style::RedundantException < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#79
+  def compact?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#74
+  def exploded?(param0 = T.unsafe(nil)); end
+
+  # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
+  # `raise RuntimeError.new('message')` to `raise 'message'`.
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#33
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#57
+  def fix_compact(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#39
+  def fix_exploded(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#65
+  def replaced_compact(message); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#47
+  def replaced_exploded(node, command, message); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#53
+  def string_message?(message); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#26
+RuboCop::Cop::Style::RedundantException::MSG_1 = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#27
+RuboCop::Cop::Style::RedundantException::MSG_2 = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_exception.rb#29
+RuboCop::Cop::Style::RedundantException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Identifies places where `fetch(key) { value }` can be replaced by `fetch(key, value)`.
+#
+# In such cases `fetch(key, value)` method is faster than `fetch(key) { value }`.
+#
+# NOTE: The block string `'value'` in `hash.fetch(:key) { 'value' }` is detected
+# but not when disabled.
+#
+# @example SafeForConstants: false (default)
+#   # bad
+#   hash.fetch(:key) { 5 }
+#   hash.fetch(:key) { true }
+#   hash.fetch(:key) { nil }
+#   array.fetch(5) { :value }
+#   ENV.fetch(:key) { 'value' }
+#
+#   # good
+#   hash.fetch(:key, 5)
+#   hash.fetch(:key, true)
+#   hash.fetch(:key, nil)
+#   array.fetch(5, :value)
+#   ENV.fetch(:key, 'value')
+# @example SafeForConstants: true
+#   # bad
+#   ENV.fetch(:key) { VALUE }
+#
+#   # good
+#   ENV.fetch(:key, VALUE)
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#40
+class RuboCop::Cop::Style::RedundantFetchBlock < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::FrozenStringLiteral
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#55
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#89
+  def rails_cache?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#48
+  def redundant_fetch_block_candidate?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#74
+  def basic_literal?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#104
+  def build_bad_method(send, body); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#97
+  def build_good_method(send, body); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#111
+  def check_for_constant?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#115
+  def check_for_string?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#78
+  def const_type?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#93
+  def fetch_range(send, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#82
+  def should_not_check?(send, body); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_fetch_block.rb#45
+RuboCop::Cop::Style::RedundantFetchBlock::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the presence of superfluous `.rb` extension in
+# the filename provided to `require` and `require_relative`.
+#
+# NOTE: If the extension is omitted, Ruby tries adding '.rb', '.so',
+#       and so on to the name until found. If the file named cannot be found,
+#       a `LoadError` will be raised.
+#       There is an edge case where `foo.so` file is loaded instead of a `LoadError`
+#       if `foo.so` file exists when `require 'foo.rb'` will be changed to `require 'foo'`,
+#       but that seems harmless.
+#
+# @example
+#   # bad
+#   require 'foo.rb'
+#   require_relative '../foo.rb'
+#
+#   # good
+#   require 'foo'
+#   require 'foo.so'
+#   require_relative '../foo'
+#   require_relative '../foo.so'
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_file_extension_in_require.rb#27
+class RuboCop::Cop::Style::RedundantFileExtensionInRequire < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_file_extension_in_require.rb#39
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_file_extension_in_require.rb#35
+  def require_call?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_file_extension_in_require.rb#53
+  def extension_range(name_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_file_extension_in_require.rb#31
+RuboCop::Cop::Style::RedundantFileExtensionInRequire::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_file_extension_in_require.rb#32
+RuboCop::Cop::Style::RedundantFileExtensionInRequire::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Identifies usages of `any?`, `empty?` or `none?` predicate methods
+# chained to `select`/`filter`/`find_all` and change them to use predicate method instead.
+#
+# @example
+#   # bad
+#   arr.select { |x| x > 1 }.any?
+#
+#   # good
+#   arr.any? { |x| x > 1 }
+#
+#   # bad
+#   arr.select { |x| x > 1 }.empty?
+#   arr.select { |x| x > 1 }.none?
+#
+#   # good
+#   arr.none? { |x| x > 1 }
+#
+#   # good
+#   relation.select(:name).any?
+#   arr.select { |x| x > 1 }.any?(&:odd?)
+# @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+#   # good
+#   arr.select { |x| x > 1 }.many?
+#
+#   # good
+#   arr.select { |x| x > 1 }.present?
+# @example AllCops:ActiveSupportExtensionsEnabled: true
+#   # bad
+#   arr.select { |x| x > 1 }.many?
+#
+#   # good
+#   arr.many? { |x| x > 1 }
+#
+#   # bad
+#   arr.select { |x| x > 1 }.present?
+#
+#   # good
+#   arr.any? { |x| x > 1 }
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#53
+class RuboCop::Cop::Style::RedundantFilterChain < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#81
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#81
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#62
+  def select_predicate?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#108
+  def offense_range(select_node, predicate_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#112
+  def predicate_range(predicate_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#94
+  def register_offense(select_node, predicate_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#56
+RuboCop::Cop::Style::RedundantFilterChain::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#58
+RuboCop::Cop::Style::RedundantFilterChain::RAILS_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#71
+RuboCop::Cop::Style::RedundantFilterChain::REPLACEMENT_METHODS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_filter_chain.rb#59
+RuboCop::Cop::Style::RedundantFilterChain::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Check for uses of `Object#freeze` on immutable objects.
+#
+# NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
+#
+# NOTE: From Ruby 3.0, this cop allows explicit freezing of interpolated
+# string literals when `# frozen-string-literal: true` is used.
+#
+# @example
+#   # bad
+#   CONST = 1.freeze
+#
+#   # good
+#   CONST = 1
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_freeze.rb#19
+class RuboCop::Cop::Style::RedundantFreeze < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::FrozenStringLiteral
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_freeze.rb#26
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_freeze.rb#57
+  def operation_produces_immutable_object?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_freeze.rb#39
+  def immutable_literal?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_freeze.rb#48
+  def strip_parenthesis(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_freeze.rb#23
+RuboCop::Cop::Style::RedundantFreeze::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_freeze.rb#24
+RuboCop::Cop::Style::RedundantFreeze::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for redundant heredoc delimiter quotes.
+#
+# @example
+#
+#   # bad
+#   do_something(<<~'EOS')
+#   no string interpolation style text
+#   EOS
+#
+#   # good
+#   do_something(<<~EOS)
+#   no string interpolation style text
+#   EOS
+#
+#   do_something(<<~'EOS')
+#   #{string_interpolation_style_text_not_evaluated}
+#   EOS
+#
+#   do_something(<<~'EOS')
+#   Preserve \
+#   newlines
+#   EOS
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_heredoc_delimiter_quotes.rb#29
+class RuboCop::Cop::Style::RedundantHeredocDelimiterQuotes < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Heredoc
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_heredoc_delimiter_quotes.rb#36
+  def on_heredoc(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_heredoc_delimiter_quotes.rb#48
+  def need_heredoc_delimiter_quotes?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_heredoc_delimiter_quotes.rb#33
+RuboCop::Cop::Style::RedundantHeredocDelimiterQuotes::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_heredoc_delimiter_quotes.rb#34
+RuboCop::Cop::Style::RedundantHeredocDelimiterQuotes::STRING_INTERPOLATION_OR_ESCAPED_CHARACTER_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# Checks for `initialize` methods that are redundant.
+#
+# An initializer is redundant if it does not do anything, or if it only
+# calls `super` with the same arguments given to it. If the initializer takes
+# an argument that accepts multiple values (`restarg`, `kwrestarg`, etc.) it
+# will not register an offense, because it allows the initializer to take a different
+# number of arguments as its superclass potentially does.
+#
+# NOTE: If an initializer argument has a default value, RuboCop assumes it
+# to *not* be redundant.
+#
+# NOTE: Empty initializers are registered as offenses, but it is possible
+# to purposely create an empty `initialize` method to override a superclass's
+# initializer.
+#
+# @example
+#   # bad
+#   def initialize
+#   end
+#
+#   # bad
+#   def initialize
+#   super
+#   end
+#
+#   # bad
+#   def initialize(a, b)
+#   super
+#   end
+#
+#   # bad
+#   def initialize(a, b)
+#   super(a, b)
+#   end
+#
+#   # good
+#   def initialize
+#   do_something
+#   end
+#
+#   # good
+#   def initialize
+#   do_something
+#   super
+#   end
+#
+#   # good (different number of parameters)
+#   def initialize(a, b)
+#   super(a)
+#   end
+#
+#   # good (default value)
+#   def initialize(a, b = 5)
+#   super
+#   end
+#
+#   # good (default value)
+#   def initialize(a, b: 5)
+#   super
+#   end
+#
+#   # good (changes the parameter requirements)
+#   def initialize(*)
+#   end
+#
+#   # good (changes the parameter requirements)
+#   def initialize(**)
+#   end
+#
+#   # good (changes the parameter requirements)
+#   def initialize(...)
+#   end
+# @example AllowComments: true (default)
+#
+#   # good
+#   def initialize
+#   # Overriding to negate superclass `initialize` method.
+#   end
+# @example AllowComments: false
+#
+#   # bad
+#   def initialize
+#   # Overriding to negate superclass `initialize` method.
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#97
+class RuboCop::Cop::Style::RedundantInitialize < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CommentsHelp
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#106
+  def initialize_forwards?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#110
+  def on_def(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#134
+  def acceptable?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#142
+  def allow_comments?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#138
+  def forwards?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#128
+  def register_offense(node, message); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#148
+  def same_args?(super_node, args); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#102
+RuboCop::Cop::Style::RedundantInitialize::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_initialize.rb#103
+RuboCop::Cop::Style::RedundantInitialize::MSG_EMPTY = T.let(T.unsafe(nil), String)
+
+# Checks for strings that are just an interpolated expression.
+#
+# @example
+#
+#   # bad
+#   "#{@var}"
+#
+#   # good
+#   @var.to_s
+#
+#   # good if @var is already a String
+#   @var
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#39
+class RuboCop::Cop::Style::RedundantInterpolation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::PercentLiteral
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#49
+  def on_dstr(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#122
+  def autocorrect_other(corrector, embedded_node, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#105
+  def autocorrect_single_variable_interpolation(corrector, embedded_node, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#99
+  def autocorrect_variable_interpolation(corrector, embedded_node, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#95
+  def embedded_in_percent_array?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#91
+  def implicit_concatenation?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#83
+  def interpolation?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#132
+  def require_parentheses?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#67
+  def single_interpolation?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#74
+  def single_variable_interpolation?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#87
+  def variable_interpolation?(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#45
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_interpolation.rb#43
+RuboCop::Cop::Style::RedundantInterpolation::MSG = T.let(T.unsafe(nil), String)
+
+# Before Ruby 3.0, interpolated strings followed the frozen string literal
+# magic comment which sometimes made it necessary to explicitly unfreeze them.
+# Ruby 3.0 changed interpolated strings to always be unfrozen which makes
+# unfreezing them redundant.
+#
+# @example
+#   # bad
+#   +"#{foo} bar"
+#
+#   # bad
+#   "#{foo} bar".dup
+#
+#   # good
+#   "#{foo} bar"
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_interpolation_unfreeze.rb#21
+class RuboCop::Cop::Style::RedundantInterpolationUnfreeze < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::FrozenStringLiteral
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_interpolation_unfreeze.rb#32
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_interpolation_unfreeze.rb#26
+RuboCop::Cop::Style::RedundantInterpolationUnfreeze::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_interpolation_unfreeze.rb#28
+RuboCop::Cop::Style::RedundantInterpolationUnfreeze::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Check for redundant line continuation.
+#
+# This cop marks a line continuation as redundant if removing the backslash
+# does not result in a syntax error.
+# However, a backslash at the end of a comment or
+# for string concatenation is not redundant and is not considered an offense.
+#
+# @example
+#   # bad
+#   foo. \
+#   bar
+#   foo \
+#   &.bar \
+#   .baz
+#
+#   # good
+#   foo.
+#   bar
+#   foo
+#   &.bar
+#   .baz
+#
+#   # bad
+#   [foo, \
+#   bar]
+#   {foo: \
+#   bar}
+#
+#   # good
+#   [foo,
+#   bar]
+#   {foo:
+#   bar}
+#
+#   # bad
+#   foo(bar, \
+#   baz)
+#
+#   # good
+#   foo(bar,
+#   baz)
+#
+#   # also good - backslash in string concatenation is not redundant
+#   foo('bar' \
+#   'baz')
+#
+#   # also good - backslash at the end of a comment is not redundant
+#   foo(bar, # \
+#   baz)
+#
+#   # also good - backslash at the line following the newline begins with a + or -,
+#   # it is not redundant
+#   1 \
+#   + 2 \
+#   - 3
+#
+#   # also good - backslash with newline between the method name and its arguments,
+#   # it is not redundant.
+#   some_method \
+#   (argument)
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#67
+class RuboCop::Cop::Style::RedundantLineContinuation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::MatchRange
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#79
+  def on_new_investigation; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#183
+  def argument_is_method?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#147
+  def argument_newline?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#102
+  def ends_with_backslash_without_comment?(source_line); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#163
+  def find_node_for_line(last_line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#132
+  def inside_string_literal?(range, token); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#110
+  def inside_string_literal_or_method_with_argument?(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#118
+  def leading_dot_method_chain_with_blank_line?(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#190
+  def method_call_with_arguments?(node); end
+
+  # A method call without parentheses such as the following cannot remove `\`:
+  #
+  #   do_something \
+  #     argument
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#140
+  def method_with_argument?(current_token, next_token); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#124
+  def redundant_line_continuation?(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#94
+  def require_line_continuation?(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#169
+  def same_line?(node, line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#194
+  def start_with_arithmetic_operator?(source_line); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#106
+  def string_concatenation?(source_line); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#72
+RuboCop::Cop::Style::RedundantLineContinuation::ALLOWED_STRING_TOKENS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#77
+RuboCop::Cop::Style::RedundantLineContinuation::ARGUMENT_TAKING_FLOW_TOKEN_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#73
+RuboCop::Cop::Style::RedundantLineContinuation::ARGUMENT_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_line_continuation.rb#71
+RuboCop::Cop::Style::RedundantLineContinuation::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for redundant parentheses.
+#
+# @example
+#
+#   # bad
+#   (x) if ((y.z).nil?)
+#
+#   # good
+#   x if y.z.nil?
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#16
+class RuboCop::Cop::Style::RedundantParentheses < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Parentheses
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#32
+  def allowed_pin_operator?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#35
+  def arg_in_call_with_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#269
+  def first_send_argument?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#274
+  def first_super_argument?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#279
+  def first_yield_argument?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#175
+  def interpolation?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#26
+  def method_node_and_args(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#37
+  def on_begin(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#29
+  def rescue?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#23
+  def square_brackets?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#177
+  def allow_in_multiline_conditions?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#68
+  def allowed_ancestor?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#60
+  def allowed_expression?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#73
+  def allowed_method_call?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#78
+  def allowed_multiple_expression?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#87
+  def allowed_ternary?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#283
+  def call_chain_starts_with_int?(begin_node, send_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#136
+  def check(begin_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#184
+  def check_send(begin_node, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#193
+  def check_unary(begin_node, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#217
+  def disallowed_literal?(begin_node, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#114
+  def empty_parentheses?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#147
+  def find_offense_message(begin_node, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#119
+  def first_arg_begins_with_hash_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#258
+  def first_argument?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#53
+  def ignore_syntax?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#213
+  def keyword_ancestor?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#232
+  def keyword_with_redundant_parentheses?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#100
+  def like_method_argument_parentheses?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#245
+  def method_call_with_redundant_parentheses?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#128
+  def method_chain_begins_with_hash_literal(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#107
+  def multiline_control_flow_statements?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#203
+  def offense(node, msg); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#254
+  def only_begin_arg?(args); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#45
+  def parens_allowed?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#221
+  def raised_to_power_negative_numeric?(begin_node, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#209
+  def suspect_unary?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#93
+  def ternary_parentheses_required?; end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_parentheses.rb#20
+RuboCop::Cop::Style::RedundantParentheses::ALLOWED_NODE_TYPES = T.let(T.unsafe(nil), Array)
+
+# Checks for usage of the %q/%Q syntax when '' or "" would do.
+#
+# @example
+#
+#   # bad
+#   name = %q(Bruce Wayne)
+#   time = %q(8 o'clock)
+#   question = %q("What did you say?")
+#
+#   # good
+#   name = 'Bruce Wayne'
+#   time = "8 o'clock"
+#   question = '"What did you say?"'
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#20
+class RuboCop::Cop::Style::RedundantPercentQ < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#34
+  def on_dstr(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#40
+  def on_str(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#99
+  def acceptable_capital_q?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#91
+  def acceptable_q?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#67
+  def allowed_percent_q?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#51
+  def check(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#63
+  def interpolated_quotes?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#72
+  def message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#87
+  def start_with_percent_q_variant?(string); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#82
+  def string_literal?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#25
+RuboCop::Cop::Style::RedundantPercentQ::DYNAMIC_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#28
+RuboCop::Cop::Style::RedundantPercentQ::EMPTY = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#32
+RuboCop::Cop::Style::RedundantPercentQ::ESCAPED_NON_BACKSLASH = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#23
+RuboCop::Cop::Style::RedundantPercentQ::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#30
+RuboCop::Cop::Style::RedundantPercentQ::PERCENT_CAPITAL_Q = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#29
+RuboCop::Cop::Style::RedundantPercentQ::PERCENT_Q = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#27
+RuboCop::Cop::Style::RedundantPercentQ::QUOTE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#26
+RuboCop::Cop::Style::RedundantPercentQ::SINGLE_QUOTE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_percent_q.rb#31
+RuboCop::Cop::Style::RedundantPercentQ::STRING_INTERPOLATION_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# Identifies places where argument can be replaced from
+# a deterministic regexp to a string.
+#
+# @example
+#   # bad
+#   'foo'.byteindex(/f/)
+#   'foo'.byterindex(/f/)
+#   'foo'.gsub(/f/, 'x')
+#   'foo'.gsub!(/f/, 'x')
+#   'foo'.partition(/f/)
+#   'foo'.rpartition(/f/)
+#   'foo'.scan(/f/)
+#   'foo'.split(/f/)
+#   'foo'.start_with?(/f/)
+#   'foo'.sub(/f/, 'x')
+#   'foo'.sub!(/f/, 'x')
+#
+#   # good
+#   'foo'.byteindex('f')
+#   'foo'.byterindex('f')
+#   'foo'.gsub('f', 'x')
+#   'foo'.gsub!('f', 'x')
+#   'foo'.partition('f')
+#   'foo'.rpartition('f')
+#   'foo'.scan('f')
+#   'foo'.split('f')
+#   'foo'.start_with?('f')
+#   'foo'.sub('f', 'x')
+#   'foo'.sub!('f', 'x')
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#35
+class RuboCop::Cop::Style::RedundantRegexpArgument < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::StringLiteralsHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#48
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#48
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#65
+  def determinist_regexp?(regexp_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#69
+  def preferred_argument(regexp_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#84
+  def replacement(regexp_node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#43
+RuboCop::Cop::Style::RedundantRegexpArgument::DETERMINISTIC_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#39
+RuboCop::Cop::Style::RedundantRegexpArgument::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#40
+RuboCop::Cop::Style::RedundantRegexpArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_argument.rb#44
+RuboCop::Cop::Style::RedundantRegexpArgument::STR_SPECIAL_CHARS = T.let(T.unsafe(nil), Array)
+
+# Checks for unnecessary single-element Regexp character classes.
+#
+# @example
+#
+#   # bad
+#   r = /[x]/
+#
+#   # good
+#   r = /x/
+#
+#   # bad
+#   r = /[\s]/
+#
+#   # good
+#   r = /\s/
+#
+#   # bad
+#   r = %r{/[b]}
+#
+#   # good
+#   r = %r{/b}
+#
+#   # good
+#   r = /[ab]/
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#30
+class RuboCop::Cop::Style::RedundantRegexpCharacterClass < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#37
+  def on_regexp(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#101
+  def backslash_b?(elem); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#53
+  def each_redundant_character_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#61
+  def each_single_element_character_class(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#83
+  def multiple_codepoints?(expression); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#107
+  def octal_requiring_char_class?(elem); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#72
+  def redundant_single_element_character_class?(node, char_class); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#113
+  def requires_escape_outside_char_class?(elem); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#95
+  def whitespace_in_free_space_mode?(node, elem); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#87
+  def without_character_class(loc); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#34
+RuboCop::Cop::Style::RedundantRegexpCharacterClass::MSG_REDUNDANT_CHARACTER_CLASS = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_character_class.rb#33
+RuboCop::Cop::Style::RedundantRegexpCharacterClass::REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS = T.let(T.unsafe(nil), Array)
+
+# Checks for the instantiation of regexp using redundant `Regexp.new` or `Regexp.compile`.
+# Autocorrect replaces to regexp literal which is the simplest and fastest.
+#
+# @example
+#
+#   # bad
+#   Regexp.new(/regexp/)
+#   Regexp.compile(/regexp/)
+#
+#   # good
+#   /regexp/
+#   Regexp.new('regexp')
+#   Regexp.compile('regexp')
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#20
+class RuboCop::Cop::Style::RedundantRegexpConstructor < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#33
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#27
+  def redundant_regexp_constructor(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#23
+RuboCop::Cop::Style::RedundantRegexpConstructor::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_constructor.rb#24
+RuboCop::Cop::Style::RedundantRegexpConstructor::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for redundant escapes inside Regexp literals.
+#
+# @example
+#   # bad
+#   %r{foo\/bar}
+#
+#   # good
+#   %r{foo/bar}
+#
+#   # good
+#   /foo\/bar/
+#
+#   # good
+#   %r/foo\/bar/
+#
+#   # good
+#   %r!foo\!bar!
+#
+#   # bad
+#   /a\-b/
+#
+#   # good
+#   /a-b/
+#
+#   # bad
+#   /[\+\-]\d/
+#
+#   # good
+#   /[+\-]\d/
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#35
+class RuboCop::Cop::Style::RedundantRegexpEscape < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#45
+  def on_regexp(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#60
+  def allowed_escape?(node, char, index, within_character_class); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#76
+  def char_class_begins_or_ends_with_escaped_hyphen?(node, index); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#92
+  def delimiter?(node, char); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#98
+  def each_escape(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#110
+  def escape_range_at_index(node, index); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#41
+RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_ALWAYS_ESCAPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#43
+RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#42
+RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_regexp_escape.rb#39
+RuboCop::Cop::Style::RedundantRegexpEscape::MSG_REDUNDANT_ESCAPE = T.let(T.unsafe(nil), String)
+
+# Checks for redundant `return` expressions.
+#
+# @example
+#   # These bad cases should be extended to handle methods whose body is
+#   # if/else or a case expression with a default branch.
+#
+#   # bad
+#   def test
+#   return something
+#   end
+#
+#   # bad
+#   def test
+#   one
+#   two
+#   three
+#   return something
+#   end
+#
+#   # bad
+#   def test
+#   return something if something_else
+#   end
+#
+#   # good
+#   def test
+#   something if something_else
+#   end
+#
+#   # good
+#   def test
+#   if x
+#   elsif y
+#   else
+#   end
+#   end
+# @example AllowMultipleReturnValues: false (default)
+#   # bad
+#   def test
+#   return x, y
+#   end
+# @example AllowMultipleReturnValues: true
+#   # good
+#   def test
+#   return x, y
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_return.rb#55
+class RuboCop::Cop::Style::RedundantReturn < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#69
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#69
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#63
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#104
+  def add_braces(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#99
+  def add_brackets(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#175
+  def allow_multiple_return_values?; end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#170
+  def check_begin_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#110
+  def check_branch(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#144
+  def check_case_match_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#139
+  def check_case_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#165
+  def check_ensure_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#149
+  def check_if_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#161
+  def check_resbody_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#156
+  def check_rescue_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#127
+  def check_return_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#80
+  def correct_with_arguments(return_node, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#76
+  def correct_without_arguments(return_node, corrector); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#95
+  def hash_without_braces?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_return.rb#179
+  def message(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_return.rb#59
+RuboCop::Cop::Style::RedundantReturn::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_return.rb#60
+RuboCop::Cop::Style::RedundantReturn::MULTI_RETURN_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_return.rb#61
+RuboCop::Cop::Style::RedundantReturn::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for redundant uses of `self`.
+#
+# The usage of `self` is only needed when:
+#
+# * Sending a message to same object with zero arguments in
+#   presence of a method name clash with an argument or a local
+#   variable.
+#
+# * Calling an attribute writer to prevent a local variable assignment.
+#
+# Note, with using explicit self you can only send messages with public or
+# protected scope, you cannot send private messages this way.
+#
+# Note we allow uses of `self` with operators because it would be awkward
+# otherwise. Also allows the use of `self.it` without arguments in blocks,
+# as in `0.times { self.it }`, following `Lint/ItWithoutArgumentsInBlock` cop.
+#
+# @example
+#
+#   # bad
+#   def foo(bar)
+#   self.baz
+#   end
+#
+#   # good
+#   def foo(bar)
+#   self.bar  # Resolves name clash with the argument.
+#   end
+#
+#   def foo
+#   bar = 1
+#   self.bar  # Resolves name clash with the local variable.
+#   end
+#
+#   def foo
+#   %w[x y z].select do |bar|
+#   self.bar == bar  # Resolves name clash with argument of the block.
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_self.rb#45
+class RuboCop::Cop::Style::RedundantSelf < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # @return [RedundantSelf] a new instance of RedundantSelf
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#60
+  def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  # Assignment of self.x
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#68
+  def on_and_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#86
+  def on_args(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#120
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#90
+  def on_blockarg(node); end
+
+  # Using self.x to distinguish from local variable x
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#81
+  def on_def(node); end
+
+  # Using self.x to distinguish from local variable x
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#81
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#126
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#104
+  def on_in_pattern(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#99
+  def on_lvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#94
+  def on_masgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#120
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#74
+  def on_op_asgn(node); end
+
+  # Assignment of self.x
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#68
+  def on_or_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#108
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#126
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#126
+  def on_while(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#196
+  def add_lhs_to_local_variables_scopes(rhs, lhs); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#204
+  def add_masgn_lhs_variables(rhs, lhs); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#210
+  def add_match_var_scopes(in_pattern_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#144
+  def add_scope(node, local_variables = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#190
+  def allow_self(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#150
+  def allowed_send_node?(node); end
+
+  # Respects `Lint/ItWithoutArgumentsInBlock` cop and the following Ruby 3.3's warning:
+  #
+  # $ ruby -e '0.times { begin; it; end }'
+  # -e:1: warning: `it` calls without arguments will refer to the first block param in
+  # Ruby 3.4; use it() or self.it
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#165
+  def it_method_in_block?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#181
+  def on_argument(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#173
+  def regular_method_call?(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/redundant_self.rb#56
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_self.rb#49
+RuboCop::Cop::Style::RedundantSelf::KERNEL_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_self.rb#50
+RuboCop::Cop::Style::RedundantSelf::KEYWORDS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_self.rb#48
+RuboCop::Cop::Style::RedundantSelf::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for places where redundant assignments are made for in place
+# modification methods.
+#
+# @example
+#   # bad
+#   args = args.concat(ary)
+#   hash = hash.merge!(other)
+#
+#   # good
+#   args.concat(foo)
+#   args += foo
+#   hash.merge!(other)
+#
+#   # bad
+#   self.foo = foo.concat(ary)
+#
+#   # good
+#   foo.concat(ary)
+#   self.foo += ary
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#31
+class RuboCop::Cop::Style::RedundantSelfAssignment < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#52
+  def on_cvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#52
+  def on_gvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#52
+  def on_ivasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#52
+  def on_lvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#69
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#96
+  def redundant_nonself_assignment?(param0 = T.unsafe(nil), param1, param2); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#86
+  def redundant_self_assignment?(param0 = T.unsafe(nil), param1); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#112
+  def correction_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#81
+  def method_returning_self?(method_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#105
+  def redundant_assignment?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#45
+RuboCop::Cop::Style::RedundantSelfAssignment::ASSIGNMENT_TYPE_TO_RECEIVER_TYPE = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#38
+RuboCop::Cop::Style::RedundantSelfAssignment::METHODS_RETURNING_SELF = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_self_assignment.rb#35
+RuboCop::Cop::Style::RedundantSelfAssignment::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for places where conditional branch makes redundant self-assignment.
+#
+# It only detects local variable because it may replace state of instance variable,
+# class variable, and global variable that have state across methods with `nil`.
+#
+# @example
+#
+#   # bad
+#   foo = condition ? bar : foo
+#
+#   # good
+#   foo = bar if condition
+#
+#   # bad
+#   foo = condition ? foo : bar
+#
+#   # good
+#   foo = bar unless condition
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#25
+class RuboCop::Cop::Style::RedundantSelfAssignmentBranch < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#32
+  def bad_method?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#36
+  def on_lvasgn(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#59
+  def inconvertible_to_modifier?(if_branch, else_branch); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#64
+  def multiple_statements?(branch); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#74
+  def register_offense(if_node, offense_branch, opposite_branch, keyword); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#70
+  def self_assign?(variable, branch); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#53
+  def use_if_and_else_branch?(expression); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_self_assignment_branch.rb#29
+RuboCop::Cop::Style::RedundantSelfAssignmentBranch::MSG = T.let(T.unsafe(nil), String)
+
+# Identifies instances of sorting and then
+# taking only the first or last element. The same behavior can
+# be accomplished without a relatively expensive sort by using
+# `Enumerable#min` instead of sorting and taking the first
+# element and `Enumerable#max` instead of sorting and taking the
+# last element. Similarly, `Enumerable#min_by` and
+# `Enumerable#max_by` can replace `Enumerable#sort_by` calls
+# after which only the first or last element is used.
+#
+# @example
+#   # bad
+#   [2, 1, 3].sort.first
+#   [2, 1, 3].sort[0]
+#   [2, 1, 3].sort.at(0)
+#   [2, 1, 3].sort.slice(0)
+#
+#   # good
+#   [2, 1, 3].min
+#
+#   # bad
+#   [2, 1, 3].sort.last
+#   [2, 1, 3].sort[-1]
+#   [2, 1, 3].sort.at(-1)
+#   [2, 1, 3].sort.slice(-1)
+#
+#   # good
+#   [2, 1, 3].max
+#
+#   # bad
+#   arr.sort_by(&:foo).first
+#   arr.sort_by(&:foo)[0]
+#   arr.sort_by(&:foo).at(0)
+#   arr.sort_by(&:foo).slice(0)
+#
+#   # good
+#   arr.min_by(&:foo)
+#
+#   # bad
+#   arr.sort_by(&:foo).last
+#   arr.sort_by(&:foo)[-1]
+#   arr.sort_by(&:foo).at(-1)
+#   arr.sort_by(&:foo).slice(-1)
+#
+#   # good
+#   arr.max_by(&:foo)
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#79
+class RuboCop::Cop::Style::RedundantSort < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#104
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#104
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#88
+  def redundant_sort?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # This gets the start of the accessor whether it has a dot
+  # (e.g. `.first`) or doesn't (e.g. `[0]`)
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#193
+  def accessor_start(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#183
+  def arg_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#187
+  def arg_value(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#148
+  def autocorrect(corrector, node, sort_node, sorter, accessor); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#166
+  def base(accessor, arg); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#115
+  def find_redundant_sort(*nodes); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#136
+  def message(node, sorter, accessor); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#132
+  def offense_range(sort_node, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#125
+  def register_offense(node, sort_node, sorter, accessor); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#157
+  def replace_with_logical_operator(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#174
+  def suffix(sorter); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#162
+  def suggestion(sorter, accessor, arg); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#201
+  def with_logical_operator?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#83
+RuboCop::Cop::Style::RedundantSort::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_sort.rb#85
+RuboCop::Cop::Style::RedundantSort::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Identifies places where `sort_by { ... }` can be replaced by
+# `sort`.
+#
+# @example
+#   # bad
+#   array.sort_by { |x| x }
+#   array.sort_by do |var|
+#   var
+#   end
+#
+#   # good
+#   array.sort
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#18
+class RuboCop::Cop::Style::RedundantSortBy < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#25
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#35
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#48
+  def redundant_sort_by_block(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#53
+  def redundant_sort_by_numblock(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#57
+  def sort_by_range(send, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#22
+RuboCop::Cop::Style::RedundantSortBy::MSG_BLOCK = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/redundant_sort_by.rb#23
+RuboCop::Cop::Style::RedundantSortBy::MSG_NUMBLOCK = T.let(T.unsafe(nil), String)
+
+# Checks for redundant escapes in string literals.
+#
+# @example
+#   # bad - no need to escape # without following {/$/@
+#   "\#foo"
+#
+#   # bad - no need to escape single quotes inside double quoted string
+#   "\'foo\'"
+#
+#   # bad - heredocs are also checked for unnecessary escapes
+#   <<~STR
+#   \#foo \"foo\"
+#   STR
+#
+#   # good
+#   "#foo"
+#
+#   # good
+#   "\#{no_interpolation}"
+#
+#   # good
+#   "'foo'"
+#
+#   # good
+#   "foo\
+#   bar"
+#
+#   # good
+#   <<~STR
+#   #foo "foo"
+#   STR
+#
+# source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#37
+class RuboCop::Cop::Style::RedundantStringEscape < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::MatchRange
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#43
+  def on_str(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#79
+  def allowed_escape?(node, range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#119
+  def array_literal?(node, prefix); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#73
+  def begin_loc_present?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#153
+  def delimiter?(node, char); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#171
+  def disabling_interpolation?(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#149
+  def heredoc?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#139
+  def heredoc_with_disabled_interpolation?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#100
+  def interpolation_not_enabled?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#167
+  def literal_in_interpolated_or_multiline_string?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#59
+  def message(range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#135
+  def percent_array_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#111
+  def percent_q_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#127
+  def percent_w_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#131
+  def percent_w_upper_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#107
+  def single_quoted?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#63
+  def str_contents_range(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/redundant_string_escape.rb#41
+RuboCop::Cop::Style::RedundantStringEscape::MSG = T.let(T.unsafe(nil), String)
+
+# Enforces using `//` or `%r` around regular expressions.
+#
+# NOTE: The following `%r` cases using a regexp starts with a blank or `=`
+# as a method argument allowed to prevent syntax errors.
+#
+# [source,ruby]
+# ----
+# do_something %r{ regexp} # `do_something / regexp/` is an invalid syntax.
+# do_something %r{=regexp} # `do_something /=regexp/` is an invalid syntax.
+# ----
+#
+# @example EnforcedStyle: slashes (default)
+#   # bad
+#   snake_case = %r{^[\dA-Z_]+$}
+#
+#   # bad
+#   regex = %r{
+#   foo
+#   (bar)
+#   (baz)
+#   }x
+#
+#   # good
+#   snake_case = /^[\dA-Z_]+$/
+#
+#   # good
+#   regex = /
+#   foo
+#   (bar)
+#   (baz)
+#   /x
+# @example EnforcedStyle: percent_r
+#   # bad
+#   snake_case = /^[\dA-Z_]+$/
+#
+#   # bad
+#   regex = /
+#   foo
+#   (bar)
+#   (baz)
+#   /x
+#
+#   # good
+#   snake_case = %r{^[\dA-Z_]+$}
+#
+#   # good
+#   regex = %r{
+#   foo
+#   (bar)
+#   (baz)
+#   }x
+# @example EnforcedStyle: mixed
+#   # bad
+#   snake_case = %r{^[\dA-Z_]+$}
+#
+#   # bad
+#   regex = /
+#   foo
+#   (bar)
+#   (baz)
+#   /x
+#
+#   # good
+#   snake_case = /^[\dA-Z_]+$/
+#
+#   # good
+#   regex = %r{
+#   foo
+#   (bar)
+#   (baz)
+#   }x
+# @example AllowInnerSlashes: false (default)
+#   # If `false`, the cop will always recommend using `%r` if one or more
+#   # slashes are found in the regexp string.
+#
+#   # bad
+#   x =~ /home\//
+#
+#   # good
+#   x =~ %r{home/}
+# @example AllowInnerSlashes: true
+#   # good
+#   x =~ /home\//
+#
+# source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#93
+class RuboCop::Cop::Style::RegexpLiteral < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#101
+  def on_regexp(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#144
+  def allow_inner_slashes?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#132
+  def allowed_mixed_percent_r?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#122
+  def allowed_mixed_slash?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#161
+  def allowed_omit_parentheses_with_percent_r_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#126
+  def allowed_percent_r_literal?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#118
+  def allowed_slash_literal?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#221
+  def calculate_replacement(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#136
+  def contains_disallowed_slash?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#140
+  def contains_slash?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#170
+  def correct_delimiters(node, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#176
+  def correct_inner_slashes(node, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#209
+  def inner_slash_after_correction(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#205
+  def inner_slash_before_correction(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#213
+  def inner_slash_for(opening_delimiter); end
+
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#192
+  def inner_slash_indices(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#148
+  def node_body(node, include_begin_nodes: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#157
+  def preferred_delimiters; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#153
+  def slash_literal?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#99
+RuboCop::Cop::Style::RegexpLiteral::MSG_USE_PERCENT_R = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/regexp_literal.rb#98
+RuboCop::Cop::Style::RegexpLiteral::MSG_USE_SLASHES = T.let(T.unsafe(nil), String)
+
+# Sort `require` and `require_relative` in alphabetical order.
+#
+# @example
+#   # bad
+#   require 'b'
+#   require 'a'
+#
+#   # good
+#   require 'a'
+#   require 'b'
+#
+#   # bad
+#   require_relative 'b'
+#   require_relative 'a'
+#
+#   # good
+#   require_relative 'a'
+#   require_relative 'b'
+#
+#   # good (sorted within each section separated by a blank line)
+#   require 'a'
+#   require 'd'
+#
+#   require 'b'
+#   require 'c'
+#
+#   # good
+#   require 'b'
+#   require_relative 'c'
+#   require 'a'
+#
+#   # bad
+#   require 'a'
+#   require 'c' if foo
+#   require 'b'
+#
+#   # good
+#   require 'a'
+#   require 'b'
+#   require 'c' if foo
+#
+#   # bad
+#   require 'c'
+#   if foo
+#   require 'd'
+#   require 'b'
+#   end
+#   require 'a'
+#
+#   # good
+#   require 'c'
+#   if foo
+#   require 'b'
+#   require 'd'
+#   end
+#   require 'a'
+#
+# source://rubocop//lib/rubocop/cop/style/require_order.rb#66
+class RuboCop::Cop::Style::RequireOrder < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/require_order.rb#76
+  def if_inside_only_require(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/require_order.rb#83
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/require_order.rb#115
+  def autocorrect(corrector, node, previous_older_sibling); end
+
+  # source://rubocop//lib/rubocop/cop/style/require_order.rb#101
+  def find_previous_older_sibling(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/require_order.rb#133
+  def in_same_section?(node1, node2); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/require_order.rb#97
+  def not_modifier_form?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/require_order.rb#123
+  def search_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/require_order.rb#127
+  def sibling_node(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/require_order.rb#73
+RuboCop::Cop::Style::RequireOrder::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/require_order.rb#71
+RuboCop::Cop::Style::RequireOrder::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for uses of `rescue` in its modifier form is added for following
+# reasons:
+#
+# * The syntax of modifier form `rescue` can be misleading because it
+#   might lead us to believe that `rescue` handles the given exception
+#   but it actually rescue all exceptions to return the given rescue
+#   block. In this case, value returned by handle_error or
+#   SomeException.
+#
+# * Modifier form `rescue` would rescue all the exceptions. It would
+#   silently skip all exception or errors and handle the error.
+#   Example: If `NoMethodError` is raised, modifier form rescue would
+#   handle the exception.
+#
+# @example
+#   # bad
+#   some_method rescue handle_error
+#
+#   # bad
+#   some_method rescue SomeException
+#
+#   # good
+#   begin
+#   some_method
+#   rescue
+#   handle_error
+#   end
+#
+#   # good
+#   begin
+#   some_method
+#   rescue SomeException
+#   handle_error
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#40
+class RuboCop::Cop::Style::RescueModifier < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::RescueNode
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#52
+  def on_resbody(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#70
+  def correct_rescue_block(corrector, node, parenthesized); end
+
+  # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#96
+  def heredoc_end(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#86
+  def indentation_and_offset(node, parenthesized); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#66
+  def parenthesized?(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#48
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/rescue_modifier.rb#46
+RuboCop::Cop::Style::RescueModifier::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for rescuing `StandardError`. There are two supported
+# styles `implicit` and `explicit`. This cop will not register an offense
+# if any error other than `StandardError` is specified.
+#
+# @example EnforcedStyle: explicit (default)
+#   # `explicit` will enforce using `rescue StandardError`
+#   # instead of `rescue`.
+#
+#   # bad
+#   begin
+#   foo
+#   rescue
+#   bar
+#   end
+#
+#   # good
+#   begin
+#   foo
+#   rescue StandardError
+#   bar
+#   end
+#
+#   # good
+#   begin
+#   foo
+#   rescue OtherError
+#   bar
+#   end
+#
+#   # good
+#   begin
+#   foo
+#   rescue StandardError, SecurityError
+#   bar
+#   end
+# @example EnforcedStyle: implicit
+#   # `implicit` will enforce using `rescue` instead of
+#   # `rescue StandardError`.
+#
+#   # bad
+#   begin
+#   foo
+#   rescue StandardError
+#   bar
+#   end
+#
+#   # good
+#   begin
+#   foo
+#   rescue
+#   bar
+#   end
+#
+#   # good
+#   begin
+#   foo
+#   rescue OtherError
+#   bar
+#   end
+#
+#   # good
+#   begin
+#   foo
+#   rescue StandardError, SecurityError
+#   bar
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#73
+class RuboCop::Cop::Style::RescueStandardError < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RescueNode
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#92
+  def on_resbody(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#88
+  def rescue_standard_error?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#83
+  def rescue_without_error_class?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#118
+  def offense_for_explicit_enforced_style(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#107
+  def offense_for_implicit_enforced_style(node, error); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#80
+RuboCop::Cop::Style::RescueStandardError::MSG_EXPLICIT = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/rescue_standard_error.rb#79
+RuboCop::Cop::Style::RescueStandardError::MSG_IMPLICIT = T.let(T.unsafe(nil), String)
+
+# Enforces consistency between `return nil` and `return`.
+#
+# This cop is disabled by default. Because there seems to be a perceived semantic difference
+# between `return` and `return nil`. The former can be seen as just halting evaluation,
+# while the latter might be used when the return value is of specific concern.
+#
+# Supported styles are `return` and `return_nil`.
+#
+# @example EnforcedStyle: return (default)
+#   # bad
+#   def foo(arg)
+#   return nil if arg
+#   end
+#
+#   # good
+#   def foo(arg)
+#   return if arg
+#   end
+# @example EnforcedStyle: return_nil
+#   # bad
+#   def foo(arg)
+#   return if arg
+#   end
+#
+#   # good
+#   def foo(arg)
+#   return nil if arg
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/return_nil.rb#35
+class RuboCop::Cop::Style::ReturnNil < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil.rb#90
+  def chained_send?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil.rb#93
+  def define_method?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil.rb#48
+  def on_return(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil.rb#46
+  def return_nil_node?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil.rb#43
+  def return_node?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/return_nil.rb#80
+  def correct_style?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil.rb#76
+  def message(_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/return_nil.rb#85
+  def scoped_node?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/return_nil.rb#39
+RuboCop::Cop::Style::ReturnNil::RETURN_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/return_nil.rb#40
+RuboCop::Cop::Style::ReturnNil::RETURN_NIL_MSG = T.let(T.unsafe(nil), String)
+
+# Checks for predicate method definitions that return `nil`.
+# A predicate method should only return a boolean value.
+#
+# @example
+#   # bad
+#   def foo?
+#   return if condition
+#
+#   do_something?
+#   end
+#
+#   # bad
+#   def foo?
+#   return nil if condition
+#
+#   do_something?
+#   end
+#
+#   # good
+#   def foo?
+#   return false if condition
+#
+#   do_something?
+#   end
+#
+#   # bad
+#   def foo?
+#   if condition
+#   nil
+#   else
+#   true
+#   end
+#   end
+#
+#   # good
+#   def foo?
+#   if condition
+#   false
+#   else
+#   true
+#   end
+#   end
+# @example AllowedMethods: ['foo?']
+#   # good
+#   def foo?
+#   return if condition
+#
+#   do_something?
+#   end
+# @example AllowedPatterns: [/foo/]
+#   # good
+#   def foo?
+#   return if condition
+#
+#   do_something?
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#69
+class RuboCop::Cop::Style::ReturnNilInPredicateMethodDefinition < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#81
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#81
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#77
+  def return_nil?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#128
+  def handle_if(if_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#113
+  def handle_implicit_return_values(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#122
+  def handle_nil(nil_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#118
+  def handle_return(return_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#94
+  def last_node_of_type(node, type); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#103
+  def node_type?(node, type); end
+
+  # source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#107
+  def register_offense(offense_node, replacement); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb#74
+RuboCop::Cop::Style::ReturnNilInPredicateMethodDefinition::MSG = T.let(T.unsafe(nil), String)
+
+# Transforms usages of a method call safeguarded by a non `nil`
+# check for the variable whose method is being called to
+# safe navigation (`&.`). If there is a method chain, all of the methods
+# in the chain need to be checked for safety, and all of the methods will
+# need to be changed to use safe navigation.
+#
+# The default for `ConvertCodeThatCanStartToReturnNil` is `false`.
+# When configured to `true`, this will
+# check for code in the format `!foo.nil? && foo.bar`. As it is written,
+# the return of this code is limited to `false` and whatever the return
+# of the method is. If this is converted to safe navigation,
+# `foo&.bar` can start returning `nil` as well as what the method
+# returns.
+#
+# The default for `MaxChainLength` is `2`.
+# We have limited the cop to not register an offense for method chains
+# that exceed this option's value.
+#
+# @example
+#   # bad
+#   foo.bar if foo
+#   foo.bar.baz if foo
+#   foo.bar(param1, param2) if foo
+#   foo.bar { |e| e.something } if foo
+#   foo.bar(param) { |e| e.something } if foo
+#
+#   foo.bar if !foo.nil?
+#   foo.bar unless !foo
+#   foo.bar unless foo.nil?
+#
+#   foo && foo.bar
+#   foo && foo.bar.baz
+#   foo && foo.bar(param1, param2)
+#   foo && foo.bar { |e| e.something }
+#   foo && foo.bar(param) { |e| e.something }
+#
+#   foo ? foo.bar : nil
+#   foo.nil? ? nil : foo.bar
+#   !foo.nil? ? foo.bar : nil
+#   !foo ? nil : foo.bar
+#
+#   # good
+#   foo&.bar
+#   foo&.bar&.baz
+#   foo&.bar(param1, param2)
+#   foo&.bar { |e| e.something }
+#   foo&.bar(param) { |e| e.something }
+#   foo && foo.bar.baz.qux # method chain with more than 2 methods
+#   foo && foo.nil? # method that `nil` responds to
+#
+#   # Method calls that do not use `.`
+#   foo && foo < bar
+#   foo < bar if foo
+#
+#   # When checking `foo&.empty?` in a conditional, `foo` being `nil` will actually
+#   # do the opposite of what the author intends.
+#   foo && foo.empty?
+#
+#   # This could start returning `nil` as well as the return of the method
+#   foo.nil? || foo.bar
+#   !foo || foo.bar
+#
+#   # Methods that are used on assignment, arithmetic operation or
+#   # comparison should not be converted to use safe navigation
+#   foo.baz = bar if foo
+#   foo.baz + bar if foo
+#   foo.bar > 2 if foo
+#
+# source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#84
+class RuboCop::Cop::Style::SafeNavigation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::NilMethods
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#128
+  def and_inside_begin?(param0 = T.unsafe(nil)); end
+
+  # if format: (if checked_variable body nil)
+  # unless format: (if checked_variable nil body)
+  #
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#99
+  def modifier_if_safe_navigation_candidate(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#125
+  def not_nil_check?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#149
+  def on_and(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#133
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#173
+  def report_offense(node, rhs, rhs_receiver, *removal_ranges, offense_range: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#131
+  def strip_begin(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#114
+  def ternary_safe_navigation_candidate(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#348
+  def add_safe_nav_to_all_methods_in_chain(corrector, start_method, method_chain); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#265
+  def allowed_if_condition?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#210
+  def and_parts(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#340
+  def begin_range(node, method_call); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#302
+  def chain_length(method_chain, method); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#192
+  def collect_and_clauses(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#246
+  def comments(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#204
+  def concat_nodes(nodes, and_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#344
+  def end_range(node, method_call); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#284
+  def extract_common_parts(method_chain, checked_variable); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#231
+  def extract_if_body(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#269
+  def extract_parts_from_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#292
+  def find_matching_receiver_invocation(method_chain, checked_variable); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#186
+  def find_method_chain(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#239
+  def handle_comments(corrector, node, method_call); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#362
+  def max_chain_length; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#336
+  def method_called?(send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#328
+  def negated?(send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#217
+  def offending_node?(node, lhs_receiver, rhs, rhs_receiver); end
+
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#252
+  def relevant_comment_ranges(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#322
+  def unsafe_method?(send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#310
+  def unsafe_method_used?(method_chain, method); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#227
+  def use_var_only_in_unless_modifier?(node, variable); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#92
+RuboCop::Cop::Style::SafeNavigation::LOGIC_JUMP_KEYWORDS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/safe_navigation.rb#90
+RuboCop::Cop::Style::SafeNavigation::MSG = T.let(T.unsafe(nil), String)
+
+# Identifies usages of `shuffle.first`,
+# `shuffle.last`, and `shuffle[]` and change them to use
+# `sample` instead.
+#
+# @example
+#   # bad
+#   [1, 2, 3].shuffle.first
+#   [1, 2, 3].shuffle.first(2)
+#   [1, 2, 3].shuffle.last
+#   [2, 1, 3].shuffle.at(0)
+#   [2, 1, 3].shuffle.slice(0)
+#   [1, 2, 3].shuffle[2]
+#   [1, 2, 3].shuffle[0, 2]    # sample(2) will do the same
+#   [1, 2, 3].shuffle[0..2]    # sample(3) will do the same
+#   [1, 2, 3].shuffle(random: Random.new).first
+#
+#   # good
+#   [1, 2, 3].shuffle
+#   [1, 2, 3].sample
+#   [1, 2, 3].sample(3)
+#   [1, 2, 3].shuffle[1, 3]    # sample(3) might return a longer Array
+#   [1, 2, 3].shuffle[1..3]    # sample(3) might return a longer Array
+#   [1, 2, 3].shuffle[foo, bar]
+#   [1, 2, 3].shuffle(random: Random.new)
+#
+# source://rubocop//lib/rubocop/cop/style/sample.rb#30
+class RuboCop::Cop::Style::Sample < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/sample.rb#41
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/sample.rb#41
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/sample.rb#37
+  def sample_candidate?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/sample.rb#122
+  def correction(shuffle_arg, method, method_args); end
+
+  # source://rubocop//lib/rubocop/cop/style/sample.rb#138
+  def extract_source(args); end
+
+  # source://rubocop//lib/rubocop/cop/style/sample.rb#116
+  def message(shuffle_arg, method, method_args, range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/sample.rb#59
+  def offensive?(method, method_args); end
+
+  # source://rubocop//lib/rubocop/cop/style/sample.rb#96
+  def range_size(range_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/sample.rb#129
+  def sample_arg(method, method_args); end
+
+  # source://rubocop//lib/rubocop/cop/style/sample.rb#70
+  def sample_size(method_args); end
+
+  # source://rubocop//lib/rubocop/cop/style/sample.rb#79
+  def sample_size_for_one_arg(arg); end
+
+  # source://rubocop//lib/rubocop/cop/style/sample.rb#89
+  def sample_size_for_two_args(first, second); end
+
+  # source://rubocop//lib/rubocop/cop/style/sample.rb#112
+  def source_range(shuffle_node, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/sample.rb#33
+RuboCop::Cop::Style::Sample::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/sample.rb#34
+RuboCop::Cop::Style::Sample::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Looks for places where an subset of an Enumerable (array,
+# range, set, etc.; see note below) is calculated based on a `Regexp`
+# match, and suggests `grep` or `grep_v` instead.
+#
+# NOTE: Hashes do not behave as you may expect with `grep`, which
+# means that `hash.grep` is not equivalent to `hash.select`. Although
+# RuboCop is limited by static analysis, this cop attempts to avoid
+# registering an offense when the receiver is a hash (hash literal,
+# `Hash.new`, `Hash#[]`, or `to_h`/`to_hash`).
+#
+# NOTE: `grep` and `grep_v` were optimized when used without a block
+# in Ruby 3.0, but may be slower in previous versions.
+# See https://bugs.ruby-lang.org/issues/17030
+#
+# @example
+#   # bad (select, filter, or find_all)
+#   array.select { |x| x.match? /regexp/ }
+#   array.select { |x| /regexp/.match?(x) }
+#   array.select { |x| x =~ /regexp/ }
+#   array.select { |x| /regexp/ =~ x }
+#
+#   # bad (reject)
+#   array.reject { |x| x.match? /regexp/ }
+#   array.reject { |x| /regexp/.match?(x) }
+#   array.reject { |x| x =~ /regexp/ }
+#   array.reject { |x| /regexp/ =~ x }
+#
+#   # good
+#   array.grep(regexp)
+#   array.grep_v(regexp)
+#
+# source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#45
+class RuboCop::Cop::Style::SelectByRegexp < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#81
+  def calls_lvar?(param0 = T.unsafe(nil), param1); end
+
+  # Returns true if a node appears to return a hash
+  #
+  # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#67
+  def creates_hash?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#76
+  def env_const?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#90
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#90
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#58
+  def regexp_match?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#136
+  def extract_send_node(block_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#149
+  def find_regexp(node, block); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#160
+  def match_predicate_without_receiver?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#145
+  def opposite?(regexp_method_send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#110
+  def receiver_allowed?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#124
+  def register_offense(node, block_node, regexp, replacement); end
+
+  # source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#116
+  def replacement(regexp_method_send_node, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#49
+RuboCop::Cop::Style::SelectByRegexp::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#52
+RuboCop::Cop::Style::SelectByRegexp::OPPOSITE_REPLACEMENTS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#55
+RuboCop::Cop::Style::SelectByRegexp::REGEXP_METHODS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#51
+RuboCop::Cop::Style::SelectByRegexp::REPLACEMENTS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/style/select_by_regexp.rb#50
+RuboCop::Cop::Style::SelectByRegexp::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Enforces the use the shorthand for self-assignment.
+#
+# @example
+#
+#   # bad
+#   x = x + 1
+#
+#   # good
+#   x += 1
+#
+# source://rubocop//lib/rubocop/cop/style/self_assignment.rb#15
+class RuboCop::Cop::Style::SelfAssignment < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#33
+  def on_cvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#29
+  def on_ivasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#25
+  def on_lvasgn(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#94
+  def apply_autocorrect(corrector, node, rhs, operator, new_rhs); end
+
+  # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#74
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#89
+  def autocorrect_boolean_node(corrector, node, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#84
+  def autocorrect_send_node(corrector, node, rhs); end
+
+  # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#39
+  def check(node, var_type); end
+
+  # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#62
+  def check_boolean_node(node, rhs, var_name, var_type); end
+
+  # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#50
+  def check_send_node(node, rhs, var_name, var_type); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/self_assignment.rb#21
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/self_assignment.rb#18
+RuboCop::Cop::Style::SelfAssignment::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/self_assignment.rb#19
+RuboCop::Cop::Style::SelfAssignment::OPS = T.let(T.unsafe(nil), Array)
+
+# Checks for multiple expressions placed on the same line.
+# It also checks for lines terminated with a semicolon.
+#
+# This cop has `AllowAsExpressionSeparator` configuration option.
+# It allows `;` to separate several expressions on the same line.
+#
+# @example
+#   # bad
+#   foo = 1; bar = 2;
+#   baz = 3;
+#
+#   # good
+#   foo = 1
+#   bar = 2
+#   baz = 3
+# @example AllowAsExpressionSeparator: false (default)
+#   # bad
+#   foo = 1; bar = 2
+# @example AllowAsExpressionSeparator: true
+#   # good
+#   foo = 1; bar = 2
+#
+# source://rubocop//lib/rubocop/cop/style/semicolon.rb#29
+class RuboCop::Cop::Style::Semicolon < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#45
+  def on_begin(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#39
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#64
+  def check_for_line_terminator_or_opener; end
+
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#70
+  def each_semicolon; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#106
+  def exist_semicolon_after_left_curly_brace?(tokens); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#110
+  def exist_semicolon_after_left_lambda_curly_brace?(tokens); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#118
+  def exist_semicolon_after_left_string_interpolation_brace?(tokens); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#102
+  def exist_semicolon_before_right_curly_brace?(tokens); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#114
+  def exist_semicolon_before_right_string_interpolation_brace?(tokens); end
+
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#142
+  def expressions_per_line(exprs); end
+
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#156
+  def find_range_node(token_before_semicolon); end
+
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#148
+  def find_semicolon_positions(line); end
+
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#162
+  def range_nodes; end
+
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#122
+  def register_semicolon(line, column, after_expression, token_before_semicolon = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#84
+  def semicolon_position(tokens); end
+
+  # source://rubocop//lib/rubocop/cop/style/semicolon.rb#79
+  def tokens_for_lines; end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/semicolon.rb#35
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/semicolon.rb#33
+RuboCop::Cop::Style::Semicolon::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the use of the send method.
+#
+# @example
+#   # bad
+#   Foo.send(bar)
+#   quuz.send(fred)
+#
+#   # good
+#   Foo.__send__(bar)
+#   quuz.public_send(fred)
+#
+# source://rubocop//lib/rubocop/cop/style/send.rb#16
+class RuboCop::Cop::Style::Send < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/style/send.rb#20
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/send.rb#20
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/send.rb#17
+RuboCop::Cop::Style::Send::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/send.rb#18
+RuboCop::Cop::Style::Send::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Detects the use of the `public_send` method with a literal method name argument.
+# Since the `send` method can be used to call private methods, by default,
+# only the `public_send` method is detected.
+#
+# NOTE: Writer methods with names ending in `=` are always permitted because their
+# behavior differs as follows:
+#
+# [source,ruby]
+# ----
+# def foo=(foo)
+#   @foo = foo
+#   42
+# end
+#
+# self.foo = 1   # => 1
+# send(:foo=, 1) # => 42
+# ----
+#
+# @example
+#   # bad
+#   obj.public_send(:method_name)
+#   obj.public_send('method_name')
+#
+#   # good
+#   obj.method_name
+# @example AllowSend: true (default)
+#   # good
+#   obj.send(:method_name)
+#   obj.send('method_name')
+#   obj.__send__(:method_name)
+#   obj.__send__('method_name')
+# @example AllowSend: false
+#   # bad
+#   obj.send(:method_name)
+#   obj.send('method_name')
+#   obj.__send__(:method_name)
+#   obj.__send__('method_name')
+#
+#   # good
+#   obj.method_name
+#
+# source://rubocop//lib/rubocop/cop/style/send_with_literal_method_name.rb#54
+class RuboCop::Cop::Style::SendWithLiteralMethodName < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/send_with_literal_method_name.rb#68
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/send_with_literal_method_name.rb#90
+  def allow_send?; end
+
+  # source://rubocop//lib/rubocop/cop/style/send_with_literal_method_name.rb#94
+  def offense_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/send_with_literal_method_name.rb#98
+  def removal_argument_range(first_argument, second_argument); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/send_with_literal_method_name.rb#60
+RuboCop::Cop::Style::SendWithLiteralMethodName::METHOD_NAME_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/style/send_with_literal_method_name.rb#57
+RuboCop::Cop::Style::SendWithLiteralMethodName::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/send_with_literal_method_name.rb#61
+RuboCop::Cop::Style::SendWithLiteralMethodName::RESERVED_WORDS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/send_with_literal_method_name.rb#58
+RuboCop::Cop::Style::SendWithLiteralMethodName::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/send_with_literal_method_name.rb#59
+RuboCop::Cop::Style::SendWithLiteralMethodName::STATIC_METHOD_NAME_NODE_TYPES = T.let(T.unsafe(nil), Array)
+
+# Checks for uses of `fail` and `raise`.
+#
+# @example EnforcedStyle: only_raise (default)
+#   # The `only_raise` style enforces the sole use of `raise`.
+#   # bad
+#   begin
+#   fail
+#   rescue Exception
+#   # handle it
+#   end
+#
+#   def watch_out
+#   fail
+#   rescue Exception
+#   # handle it
+#   end
+#
+#   Kernel.fail
+#
+#   # good
+#   begin
+#   raise
+#   rescue Exception
+#   # handle it
+#   end
+#
+#   def watch_out
+#   raise
+#   rescue Exception
+#   # handle it
+#   end
+#
+#   Kernel.raise
+# @example EnforcedStyle: only_fail
+#   # The `only_fail` style enforces the sole use of `fail`.
+#   # bad
+#   begin
+#   raise
+#   rescue Exception
+#   # handle it
+#   end
+#
+#   def watch_out
+#   raise
+#   rescue Exception
+#   # handle it
+#   end
+#
+#   Kernel.raise
+#
+#   # good
+#   begin
+#   fail
+#   rescue Exception
+#   # handle it
+#   end
+#
+#   def watch_out
+#   fail
+#   rescue Exception
+#   # handle it
+#   end
+#
+#   Kernel.fail
+# @example EnforcedStyle: semantic
+#   # The `semantic` style enforces the use of `fail` to signal an
+#   # exception, then will use `raise` to trigger an offense after
+#   # it has been rescued.
+#   # bad
+#   begin
+#   raise
+#   rescue Exception
+#   # handle it
+#   end
+#
+#   def watch_out
+#   # Error thrown
+#   rescue Exception
+#   fail
+#   end
+#
+#   Kernel.fail
+#   Kernel.raise
+#
+#   # good
+#   begin
+#   fail
+#   rescue Exception
+#   # handle it
+#   end
+#
+#   def watch_out
+#   fail
+#   rescue Exception
+#   raise 'Preferably with descriptive message'
+#   end
+#
+#   explicit_receiver.fail
+#   explicit_receiver.raise
+#
+# source://rubocop//lib/rubocop/cop/style/signal_exception.rb#107
+class RuboCop::Cop::Style::SignalException < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#120
+  def custom_fail_methods(param0); end
+
+  # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#117
+  def kernel_call?(param0 = T.unsafe(nil), param1); end
+
+  # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#122
+  def on_rescue(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#134
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#206
+  def allow(method_name, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#188
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#167
+  def check_scope(method_name, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#180
+  def check_send(method_name, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#200
+  def command_or_kernel_call?(name, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#149
+  def custom_fail_defined?; end
+
+  # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#210
+  def each_command_or_kernel_call(method_name, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/signal_exception.rb#156
+  def message(method_name); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/signal_exception.rb#111
+RuboCop::Cop::Style::SignalException::FAIL_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/signal_exception.rb#112
+RuboCop::Cop::Style::SignalException::RAISE_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/signal_exception.rb#114
+RuboCop::Cop::Style::SignalException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Sometimes using `dig` method ends up with just a single
+# argument. In such cases, dig should be replaced with `[]`.
+#
+# Since replacing `hash&.dig(:key)` with `hash[:key]` could potentially lead to error,
+# calls to the `dig` method using safe navigation will be ignored.
+#
+# @example
+#   # bad
+#   { key: 'value' }.dig(:key)
+#   [1, 2, 3].dig(0)
+#
+#   # good
+#   { key: 'value' }[:key]
+#   [1, 2, 3][0]
+#
+#   # good
+#   { key1: { key2: 'value' } }.dig(:key1, :key2)
+#   [1, [2, [3]]].dig(1, 1)
+#
+#   # good
+#   keys = %i[key1 key2]
+#   { key1: { key2: 'value' } }.dig(*keys)
+#
+# source://rubocop//lib/rubocop/cop/style/single_argument_dig.rb#34
+class RuboCop::Cop::Style::SingleArgumentDig < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/single_argument_dig.rb#46
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/single_argument_dig.rb#42
+  def single_argument_dig?(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/single_argument_dig.rb#39
+RuboCop::Cop::Style::SingleArgumentDig::IGNORED_ARGUMENT_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/single_argument_dig.rb#37
+RuboCop::Cop::Style::SingleArgumentDig::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/single_argument_dig.rb#38
+RuboCop::Cop::Style::SingleArgumentDig::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks whether the block parameters of a single-line
+# method accepting a block match the names specified via configuration.
+#
+# For instance one can configure `reduce`(`inject`) to use |a, e| as
+# parameters.
+#
+# Configuration option: Methods
+# Should be set to use this cop. Array of hashes, where each key is the
+# method name and value - array of argument names.
+#
+# @example Methods: [{reduce: %w[a b]}]
+#   # bad
+#   foo.reduce { |c, d| c + d }
+#   foo.reduce { |_, _d| 1 }
+#
+#   # good
+#   foo.reduce { |a, b| a + b }
+#   foo.reduce { |a, _b| a }
+#   foo.reduce { |a, (id, _)| a + id }
+#   foo.reduce { true }
+#
+#   # good
+#   foo.reduce do |c, d|
+#   c + d
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#31
+class RuboCop::Cop::Style::SingleLineBlockParams < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#36
+  def on_block(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#105
+  def args_match?(method_name, args); end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#69
+  def autocorrect(corrector, node, preferred_block_arguments, joined_block_arguments); end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#57
+  def build_preferred_arguments_map(node, preferred_arguments); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#79
+  def eligible_arguments?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#83
+  def eligible_method?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#95
+  def method_name(method); end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#91
+  def method_names; end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#87
+  def methods; end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#99
+  def target_args(method_name); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/single_line_block_params.rb#34
+RuboCop::Cop::Style::SingleLineBlockParams::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for single-line `do`...`end` block.
+#
+# In practice a single line `do`...`end` is autocorrected when `EnforcedStyle: semantic`
+# in `Style/BlockDelimiters`. The autocorrection maintains the `do` ... `end` syntax to
+# preserve semantics and does not change it to `{`...`}` block.
+#
+# @example
+#
+#   # bad
+#   foo do |arg| bar(arg) end
+#
+#   # good
+#   foo do |arg|
+#   bar(arg)
+#   end
+#
+#   # bad
+#   ->(arg) do bar(arg) end
+#
+#   # good
+#   ->(arg) { bar(arg) }
+#
+# source://rubocop//lib/rubocop/cop/style/single_line_do_end_block.rb#28
+class RuboCop::Cop::Style::SingleLineDoEndBlock < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_do_end_block.rb#34
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_do_end_block.rb#34
+  def on_numblock(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_do_end_block.rb#55
+  def do_line(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_do_end_block.rb#63
+  def x(corrector, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/single_line_do_end_block.rb#31
+RuboCop::Cop::Style::SingleLineDoEndBlock::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for single-line method definitions that contain a body.
+# It will accept single-line methods with no body.
+#
+# Endless methods added in Ruby 3.0 are also accepted by this cop.
+#
+# If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line` or
+# `allow_always`, single-line methods will be autocorrected to endless
+# methods if there is only one statement in the body.
+#
+# @example
+#   # bad
+#   def some_method; body end
+#   def link_to(url); {:name => url}; end
+#   def @table.columns; super; end
+#
+#   # good
+#   def self.resource_class=(klass); end
+#   def @table.columns; end
+#   def some_method() = body
+# @example AllowIfMethodIsEmpty: true (default)
+#   # good
+#   def no_op; end
+# @example AllowIfMethodIsEmpty: false
+#   # bad
+#   def no_op; end
+#
+# source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#34
+class RuboCop::Cop::Style::SingleLineMethods < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#41
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#41
+  def on_defs(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#60
+  def allow_empty?; end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#52
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#97
+  def break_line_before(corrector, node, range, indent_steps: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#88
+  def correct_to_endless(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#64
+  def correct_to_endless?(body_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#74
+  def correct_to_multiline(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#136
+  def disallow_endless_method_style?; end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#104
+  def each_part(body); end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#121
+  def method_body_source(method_body); end
+
+  # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#114
+  def move_comment(node, corrector); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#132
+  def require_parentheses?(method_body); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#38
+RuboCop::Cop::Style::SingleLineMethods::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/single_line_methods.rb#39
+RuboCop::Cop::Style::SingleLineMethods::NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES = T.let(T.unsafe(nil), Array)
+
+# Checks that arrays are not sliced with the redundant `ary[0..-1]`, replacing it with `ary`,
+# and ensures arrays are sliced with endless ranges instead of `ary[start..-1]` on Ruby 2.6+,
+# and with beginless ranges instead of `ary[nil..end]` on Ruby 2.7+.
+#
+# @example
+#   # bad
+#   items[0..-1]
+#   items[0..nil]
+#   items[0...nil]
+#
+#   # good
+#   items
+#
+#   # bad
+#   items[1..-1]   # Ruby 2.6+
+#   items[1..nil]  # Ruby 2.6+
+#
+#   # good
+#   items[1..]     # Ruby 2.6+
+#
+#   # bad
+#   items[nil..42] # Ruby 2.7+
+#
+#   # good
+#   items[..42]    # Ruby 2.7+
+#   items[0..42]   # Ruby 2.7+
+#
+# source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#46
+class RuboCop::Cop::Style::SlicingWithRange < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#77
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#73
+  def range_from_zero?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#57
+  def range_from_zero_till_minus_one?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#65
+  def range_till_minus_one?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#111
+  def beginless(range_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#107
+  def endless(range_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#93
+  def offense_message_with_removal_range(range_node, selector); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#52
+RuboCop::Cop::Style::SlicingWithRange::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#53
+RuboCop::Cop::Style::SlicingWithRange::MSG_USELESS_RANGE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/slicing_with_range.rb#54
+RuboCop::Cop::Style::SlicingWithRange::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# If the branch of a conditional consists solely of a conditional node,
+# its conditions can be combined with the conditions of the outer branch.
+# This helps to keep the nesting level from getting too deep.
+#
+# @example
+#   # bad
+#   if condition_a
+#   if condition_b
+#   do_something
+#   end
+#   end
+#
+#   # bad
+#   if condition_b
+#   do_something
+#   end if condition_a
+#
+#   # good
+#   if condition_a && condition_b
+#   do_something
+#   end
+# @example AllowModifier: false (default)
+#   # bad
+#   if condition_a
+#   do_something if condition_b
+#   end
+#
+#   # bad
+#   if condition_b
+#   do_something
+#   end if condition_a
+# @example AllowModifier: true
+#   # good
+#   if condition_a
+#   do_something if condition_b
+#   end
+#
+#   # good
+#   if condition_b
+#   do_something
+#   end if condition_a
+#
+# source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#49
+class RuboCop::Cop::Style::SoleNestedConditional < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#59
+  def on_if(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#261
+  def allow_modifier?; end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#233
+  def arguments_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#81
+  def assigned_variables(condition); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#98
+  def autocorrect(corrector, node, if_branch); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#110
+  def autocorrect_outer_condition_basic(corrector, node, if_branch); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#125
+  def autocorrect_outer_condition_modify_form(corrector, node, if_branch); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#145
+  def correct_for_basic_condition_style(corrector, node, if_branch, and_operator); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#181
+  def correct_for_comment(corrector, node, if_branch); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#136
+  def correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#171
+  def correct_for_outer_condition_modify_form_style(corrector, node, if_branch); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#130
+  def correct_from_unless_to_if(corrector, node, is_modify_form: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#190
+  def correct_outer_condition(corrector, condition); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#203
+  def insert_bang(corrector, node, is_modify_form); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#216
+  def insert_bang_for_and(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#89
+  def offending_branch?(node, branch); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#265
+  def outer_condition_modify_form?(node, if_branch); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#254
+  def parenthesized_method_arguments(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#244
+  def replace_condition(condition); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#228
+  def require_parentheses?(condition); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#74
+  def use_variable_assignment_in_condition?(condition, if_branch); end
+
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#155
+  def wrap_condition(corrector, condition); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#239
+  def wrap_condition?(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#55
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/sole_nested_conditional.rb#53
+RuboCop::Cop::Style::SoleNestedConditional::MSG = T.let(T.unsafe(nil), String)
+
+# Looks for uses of Perl-style global variables.
+# Correcting to global variables in the 'English' library
+# will add a require statement to the top of the file if
+# enabled by RequireEnglish config.
+#
+# @example EnforcedStyle: use_english_names (default)
+#   # good
+#   require 'English' # or this could be in another file.
+#
+#   puts $LOAD_PATH
+#   puts $LOADED_FEATURES
+#   puts $PROGRAM_NAME
+#   puts $ERROR_INFO
+#   puts $ERROR_POSITION
+#   puts $FIELD_SEPARATOR # or $FS
+#   puts $OUTPUT_FIELD_SEPARATOR # or $OFS
+#   puts $INPUT_RECORD_SEPARATOR # or $RS
+#   puts $OUTPUT_RECORD_SEPARATOR # or $ORS
+#   puts $INPUT_LINE_NUMBER # or $NR
+#   puts $LAST_READ_LINE
+#   puts $DEFAULT_OUTPUT
+#   puts $DEFAULT_INPUT
+#   puts $PROCESS_ID # or $PID
+#   puts $CHILD_STATUS
+#   puts $LAST_MATCH_INFO
+#   puts $IGNORECASE
+#   puts $ARGV # or ARGV
+# @example EnforcedStyle: use_perl_names
+#   # good
+#   puts $:
+#   puts $"
+#   puts $0
+#   puts $!
+#   puts $@
+#   puts $;
+#   puts $,
+#   puts $/
+#   puts $\
+#   puts $.
+#   puts $_
+#   puts $>
+#   puts $<
+#   puts $$
+#   puts $?
+#   puts $~
+#   puts $=
+#   puts $*
+# @example EnforcedStyle: use_builtin_english_names
+#
+#   # good
+#   # Like `use_perl_names` but allows builtin global vars.
+#   puts $LOAD_PATH
+#   puts $LOADED_FEATURES
+#   puts $PROGRAM_NAME
+#   puts ARGV
+#   puts $:
+#   puts $"
+#   puts $0
+#   puts $!
+#   puts $@
+#   puts $;
+#   puts $,
+#   puts $/
+#   puts $\
+#   puts $.
+#   puts $_
+#   puts $>
+#   puts $<
+#   puts $$
+#   puts $?
+#   puts $~
+#   puts $=
+#   puts $*
+#
+# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#86
+class RuboCop::Cop::Style::SpecialGlobalVars < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::RequireLibrary
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#175
+  def autocorrect(corrector, node, global_var); end
+
+  # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#167
+  def message(global_var); end
+
+  # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#151
+  def on_gvar(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#146
+  def on_new_investigation; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#246
+  def add_require_english?; end
+
+  # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#240
+  def english_name_replacement(preferred_name, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#189
+  def format_english_message(global_var); end
+
+  # For now, we assume that lists are 2 items or less. Easy grammar!
+  #
+  # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#211
+  def format_list(items); end
+
+  # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#197
+  def format_message(english, regular, global); end
+
+  # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#234
+  def matching_styles(global); end
+
+  # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#226
+  def preferred_names(global); end
+
+  # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#215
+  def replacement(node, global_var); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#250
+  def should_require_english?(global_var); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#127
+RuboCop::Cop::Style::SpecialGlobalVars::BUILTIN_VARS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#99
+RuboCop::Cop::Style::SpecialGlobalVars::ENGLISH_VARS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#144
+RuboCop::Cop::Style::SpecialGlobalVars::LIBRARY_NAME = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#92
+RuboCop::Cop::Style::SpecialGlobalVars::MSG_BOTH = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#95
+RuboCop::Cop::Style::SpecialGlobalVars::MSG_ENGLISH = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#97
+RuboCop::Cop::Style::SpecialGlobalVars::MSG_REGULAR = T.let(T.unsafe(nil), String)
+
+# Anything *not* in this set is provided by the English library.
+#
+# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#121
+RuboCop::Cop::Style::SpecialGlobalVars::NON_ENGLISH_VARS = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#123
+RuboCop::Cop::Style::SpecialGlobalVars::PERL_VARS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/cop/style/special_global_vars.rb#138
+RuboCop::Cop::Style::SpecialGlobalVars::STYLE_VARS_MAP = T.let(T.unsafe(nil), Hash)
+
+# Check for parentheses around stabby lambda arguments.
+# There are two different styles. Defaults to `require_parentheses`.
+#
+# @example EnforcedStyle: require_parentheses (default)
+#   # bad
+#   ->a,b,c { a + b + c }
+#
+#   # good
+#   ->(a,b,c) { a + b + c}
+# @example EnforcedStyle: require_no_parentheses
+#   # bad
+#   ->(a,b,c) { a + b + c }
+#
+#   # good
+#   ->a,b,c { a + b + c}
+#
+# source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#22
+class RuboCop::Cop::Style::StabbyLambdaParentheses < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#28
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#54
+  def message(_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#46
+  def missing_parentheses?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#58
+  def missing_parentheses_corrector(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#73
+  def parentheses?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#50
+  def redundant_parentheses?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#69
+  def stabby_lambda_with_args?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#62
+  def unwanted_parentheses_corrector(corrector, node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#27
+RuboCop::Cop::Style::StabbyLambdaParentheses::MSG_NO_REQUIRE = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/stabby_lambda_parentheses.rb#26
+RuboCop::Cop::Style::StabbyLambdaParentheses::MSG_REQUIRE = T.let(T.unsafe(nil), String)
+
+# Checks for places where classes with only class methods can be
+# replaced with a module. Classes should be used only when it makes sense to create
+# instances out of them.
+#
+# @example
+#   # bad
+#   class SomeClass
+#   def self.some_method
+#   # body omitted
+#   end
+#
+#   def self.some_other_method
+#   # body omitted
+#   end
+#   end
+#
+#   # good
+#   module SomeModule
+#   module_function
+#
+#   def some_method
+#   # body omitted
+#   end
+#
+#   def some_other_method
+#   # body omitted
+#   end
+#   end
+#
+#   # good - has instance method
+#   class SomeClass
+#   def instance_method; end
+#   def self.class_method; end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/static_class.rb#46
+class RuboCop::Cop::Style::StaticClass < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::VisibilityHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/static_class.rb#53
+  def on_class(class_node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/static_class.rb#64
+  def autocorrect(corrector, class_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/static_class.rb#77
+  def autocorrect_def(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/static_class.rb#83
+  def autocorrect_sclass(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/static_class.rb#90
+  def class_convertible_to_module?(class_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/static_class.rb#114
+  def class_elements(class_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/static_class.rb#102
+  def extend_call?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/static_class.rb#106
+  def sclass_convertible_to_module?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/static_class.rb#51
+RuboCop::Cop::Style::StaticClass::MSG = T.let(T.unsafe(nil), String)
+
+# Identifies places where `$stderr.puts` can be replaced by
+# `warn`. The latter has the advantage of easily being disabled by,
+# the `-W0` interpreter flag or setting `$VERBOSE` to `nil`.
+#
+# @example
+#   # bad
+#   $stderr.puts('hello')
+#
+#   # good
+#   warn('hello')
+#
+# source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#17
+class RuboCop::Cop::Style::StderrPuts < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#32
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#25
+  def stderr_puts?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#43
+  def message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#47
+  def stderr_gvar?(sym); end
+
+  # source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#51
+  def stderr_puts_range(send); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#21
+RuboCop::Cop::Style::StderrPuts::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/stderr_puts.rb#22
+RuboCop::Cop::Style::StderrPuts::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for uses of `String#split` with empty string or regexp literal argument.
+#
+# @example
+#   # bad
+#   string.split(//)
+#   string.split('')
+#
+#   # good
+#   string.chars
+#
+# source://rubocop//lib/rubocop/cop/style/string_chars.rb#21
+class RuboCop::Cop::Style::StringChars < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/string_chars.rb#29
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/string_chars.rb#29
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/string_chars.rb#27
+RuboCop::Cop::Style::StringChars::BAD_ARGUMENTS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/string_chars.rb#25
+RuboCop::Cop::Style::StringChars::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/string_chars.rb#26
+RuboCop::Cop::Style::StringChars::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for places where string concatenation
+# can be replaced with string interpolation.
+#
+# The cop can autocorrect simple cases but will skip autocorrecting
+# more complex cases where the resulting code would be harder to read.
+# In those cases, it might be useful to extract statements to local
+# variables or methods which you can then interpolate in a string.
+#
+# NOTE: When concatenation between two strings is broken over multiple
+# lines, this cop does not register an offense; instead,
+# `Style/LineEndConcatenation` will pick up the offense if enabled.
+#
+# Two modes are supported:
+# 1. `aggressive` style checks and corrects all occurrences of `+` where
+# either the left or right side of `+` is a string literal.
+# 2. `conservative` style on the other hand, checks and corrects only if
+# left side (receiver of `+` method call) is a string literal.
+# This is useful when the receiver is some expression that returns string like `Pathname`
+# instead of a string literal.
+#
+# @example Mode: aggressive (default)
+#   # bad
+#   email_with_name = user.name + ' <' + user.email + '>'
+#   Pathname.new('/') + 'test'
+#
+#   # good
+#   email_with_name = "#{user.name} <#{user.email}>"
+#   email_with_name = format('%s <%s>', user.name, user.email)
+#   "#{Pathname.new('/')}test"
+#
+#   # accepted, line-end concatenation
+#   name = 'First' +
+#   'Last'
+# @example Mode: conservative
+#   # bad
+#   'Hello' + user.name
+#
+#   # good
+#   "Hello #{user.name}"
+#   user.name + '!!'
+#   Pathname.new('/') + 'test'
+#
+# source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#53
+class RuboCop::Cop::Style::StringConcatenation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#69
+  def on_new_investigation; end
+
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#73
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#62
+  def string_concatenation?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#116
+  def collect_parts(node, parts = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#141
+  def corrected_ancestor?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#108
+  def find_topmost_plus_node(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#162
+  def handle_quotes(parts); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#135
+  def heredoc?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#98
+  def line_end_concatenation?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#172
+  def mode; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#127
+  def plus_node?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#86
+  def register_offense(topmost_plus_node, parts); end
+
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#145
+  def replacement(parts); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#168
+  def single_quoted?(str_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#131
+  def uncorrectable?(part); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#58
+RuboCop::Cop::Style::StringConcatenation::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/string_concatenation.rb#59
+RuboCop::Cop::Style::StringConcatenation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for the use of strings as keys in hashes. The use of
+# symbols is preferred instead.
+#
+# @example
+#   # bad
+#   { 'one' => 1, 'two' => 2, 'three' => 3 }
+#
+#   # good
+#   { one: 1, two: 2, three: 3 }
+#
+# source://rubocop//lib/rubocop/cop/style/string_hash_keys.rb#19
+class RuboCop::Cop::Style::StringHashKeys < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/string_hash_keys.rb#42
+  def on_pair(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/string_hash_keys.rb#30
+  def receive_environments_method?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/string_hash_keys.rb#25
+  def string_hash_key?(param0 = T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/string_hash_keys.rb#22
+RuboCop::Cop::Style::StringHashKeys::MSG = T.let(T.unsafe(nil), String)
+
+# Checks if uses of quotes match the configured preference.
+#
+# @example EnforcedStyle: single_quotes (default)
+#   # bad
+#   "No special symbols"
+#   "No string interpolation"
+#   "Just text"
+#
+#   # good
+#   'No special symbols'
+#   'No string interpolation'
+#   'Just text'
+#   "Wait! What's #{this}!"
+# @example EnforcedStyle: double_quotes
+#   # bad
+#   'Just some text'
+#   'No special chars or interpolation'
+#
+#   # good
+#   "Just some text"
+#   "No special chars or interpolation"
+#   "Every string in #{project} uses double_quotes"
+#
+# source://rubocop//lib/rubocop/cop/style/string_literals.rb#29
+class RuboCop::Cop::Style::StringLiterals < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::StringLiteralsHelp
+  include ::RuboCop::Cop::StringHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/string_literals.rb#37
+  def on_dstr(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/string_literals.rb#123
+  def accept_child_double_quotes?(nodes); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/string_literals.rb#71
+  def all_string_literals?(nodes); end
+
+  # source://rubocop//lib/rubocop/cop/style/string_literals.rb#61
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/string_literals.rb#105
+  def check_multiline_quote_style(node, quote); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/string_literals.rb#101
+  def consistent_multiline?; end
+
+  # source://rubocop//lib/rubocop/cop/style/string_literals.rb#75
+  def detect_quote_styles(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/string_literals.rb#87
+  def message(_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/string_literals.rb#97
+  def offense?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/string_literals.rb#65
+  def register_offense(node, message: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/string_literals.rb#119
+  def unexpected_double_quotes?(quote); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/string_literals.rb#115
+  def unexpected_single_quotes?(quote); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/string_literals.rb#35
+RuboCop::Cop::Style::StringLiterals::MSG_INCONSISTENT = T.let(T.unsafe(nil), String)
+
+# Checks that quotes inside string, symbol, and regexp interpolations
+# match the configured preference.
+#
+# @example EnforcedStyle: single_quotes (default)
+#   # bad
+#   string = "Tests #{success ? "PASS" : "FAIL"}"
+#   symbol = :"Tests #{success ? "PASS" : "FAIL"}"
+#   heredoc = <<~TEXT
+#   Tests #{success ? "PASS" : "FAIL"}
+#   TEXT
+#   regexp = /Tests #{success ? "PASS" : "FAIL"}/
+#
+#   # good
+#   string = "Tests #{success ? 'PASS' : 'FAIL'}"
+#   symbol = :"Tests #{success ? 'PASS' : 'FAIL'}"
+#   heredoc = <<~TEXT
+#   Tests #{success ? 'PASS' : 'FAIL'}
+#   TEXT
+#   regexp = /Tests #{success ? 'PASS' : 'FAIL'}/
+# @example EnforcedStyle: double_quotes
+#   # bad
+#   string = "Tests #{success ? 'PASS' : 'FAIL'}"
+#   symbol = :"Tests #{success ? 'PASS' : 'FAIL'}"
+#   heredoc = <<~TEXT
+#   Tests #{success ? 'PASS' : 'FAIL'}
+#   TEXT
+#   regexp = /Tests #{success ? 'PASS' : 'FAIL'}/
+#
+#   # good
+#   string = "Tests #{success ? "PASS" : "FAIL"}"
+#   symbol = :"Tests #{success ? "PASS" : "FAIL"}"
+#   heredoc = <<~TEXT
+#   Tests #{success ? "PASS" : "FAIL"}
+#   TEXT
+#   regexp = /Tests #{success ? "PASS" : "FAIL"}/
+#
+# source://rubocop//lib/rubocop/cop/style/string_literals_in_interpolation.rb#42
+class RuboCop::Cop::Style::StringLiteralsInInterpolation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::StringLiteralsHelp
+  include ::RuboCop::Cop::StringHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/string_literals_in_interpolation.rb#48
+  def autocorrect(corrector, node); end
+
+  # Cop classes that include the StringHelp module usually ignore regexp
+  # nodes. Not so for this cop, which is why we override the on_regexp
+  # definition with an empty one.
+  #
+  # source://rubocop//lib/rubocop/cop/style/string_literals_in_interpolation.rb#55
+  def on_regexp(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/string_literals_in_interpolation.rb#59
+  def message(_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/string_literals_in_interpolation.rb#66
+  def offense?(node); end
+end
+
+# Enforces the use of consistent method names
+# from the String class.
+#
+# @example
+#   # bad
+#   'name'.intern
+#   'var'.unfavored_method
+#
+#   # good
+#   'name'.to_sym
+#   'var'.preferred_method
+#
+# source://rubocop//lib/rubocop/cop/style/string_methods.rb#17
+class RuboCop::Cop::Style::StringMethods < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::MethodPreference
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/string_methods.rb#23
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/string_methods.rb#23
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/string_methods.rb#21
+RuboCop::Cop::Style::StringMethods::MSG = T.let(T.unsafe(nil), String)
+
+# Identifies places where `lstrip.rstrip` can be replaced by
+# `strip`.
+#
+# @example
+#   # bad
+#   'abc'.lstrip.rstrip
+#   'abc'.rstrip.lstrip
+#
+#   # good
+#   'abc'.strip
+#
+# source://rubocop//lib/rubocop/cop/style/strip.rb#16
+class RuboCop::Cop::Style::Strip < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/strip.rb#24
+  def lstrip_rstrip(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/strip.rb#31
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/strip.rb#31
+  def on_send(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/strip.rb#20
+RuboCop::Cop::Style::Strip::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/strip.rb#21
+RuboCop::Cop::Style::Strip::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for inheritance from Struct.new.
+#
+# @example
+#   # bad
+#   class Person < Struct.new(:first_name, :last_name)
+#   def age
+#   42
+#   end
+#   end
+#
+#   # good
+#   Person = Struct.new(:first_name, :last_name) do
+#   def age
+#   42
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/struct_inheritance.rb#26
+class RuboCop::Cop::Style::StructInheritance < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/struct_inheritance.rb#33
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/struct_inheritance.rb#45
+  def struct_constructor?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/struct_inheritance.rb#52
+  def correct_parent(parent, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/style/struct_inheritance.rb#62
+  def range_for_empty_class_body(class_node, struct_new); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/struct_inheritance.rb#30
+RuboCop::Cop::Style::StructInheritance::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for redundant argument forwarding when calling super with arguments identical to
+# the method definition.
+#
+# Using zero arity `super` within a `define_method` block results in `RuntimeError`:
+#
+# [source,ruby]
+# ----
+# def m
+#   define_method(:foo) { super() } # => OK
+# end
+#
+# def m
+#   define_method(:foo) { super }   # => RuntimeError
+# end
+# ----
+#
+# Furthermore, any arguments accompanied by a block may potentially be delegating to
+# `define_method`, therefore, `super` used within these blocks will be allowed.
+# This approach might result in false negatives, yet ensuring safe detection takes precedence.
+#
+# @example
+#   # bad
+#   def method(*args, **kwargs)
+#   super(*args, **kwargs)
+#   end
+#
+#   # good - implicitly passing all arguments
+#   def method(*args, **kwargs)
+#   super
+#   end
+#
+#   # good - forwarding a subset of the arguments
+#   def method(*args, **kwargs)
+#   super(*args)
+#   end
+#
+#   # good - forwarding no arguments
+#   def method(*args, **kwargs)
+#   super()
+#   end
+#
+#   # good - assigning to the block variable before calling super
+#   def method(&block)
+#   # Assigning to the block variable would pass the old value to super,
+#   # under this circumstance the block must be referenced explicitly.
+#   block ||= proc { 'fallback behavior' }
+#   super(&block)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/super_arguments.rb#54
+class RuboCop::Cop::Style::SuperArguments < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/super_arguments.rb#62
+  def on_super(super_node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/super_arguments.rb#81
+  def arguments_identical?(def_node, def_args, super_args); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/super_arguments.rb#136
+  def block_arg_same?(def_node, def_arg, super_arg); end
+
+  # Reassigning the block argument will still pass along the original block to super
+  # https://bugs.ruby-lang.org/issues/20505
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/super_arguments.rb#147
+  def block_reassigned?(def_node, block_arg_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/super_arguments.rb#158
+  def forward_arg_same?(def_arg, super_arg); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/super_arguments.rb#116
+  def keyword_arg_same?(def_arg, super_arg); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/super_arguments.rb#126
+  def keyword_rest_arg_same?(def_arg, super_arg); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/super_arguments.rb#99
+  def positional_arg_same?(def_arg, super_arg); end
+
+  # source://rubocop//lib/rubocop/cop/style/super_arguments.rb#106
+  def positional_rest_arg_same(def_arg, super_arg); end
+
+  # source://rubocop//lib/rubocop/cop/style/super_arguments.rb#162
+  def preprocess_super_args(super_args); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/super_arguments.rb#58
+RuboCop::Cop::Style::SuperArguments::ASSIGN_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/super_arguments.rb#57
+RuboCop::Cop::Style::SuperArguments::DEF_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/super_arguments.rb#60
+RuboCop::Cop::Style::SuperArguments::MSG = T.let(T.unsafe(nil), String)
+
+# Enforces the presence of parentheses in `super` containing arguments.
+#
+# `super` is a keyword and is provided as a distinct cop from those designed for method call.
+#
+# @example
+#
+#   # bad
+#   super name, age
+#
+#   # good
+#   super(name, age)
+#
+# source://rubocop//lib/rubocop/cop/style/super_with_args_parentheses.rb#18
+class RuboCop::Cop::Style::SuperWithArgsParentheses < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/super_with_args_parentheses.rb#23
+  def on_super(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/super_with_args_parentheses.rb#21
+RuboCop::Cop::Style::SuperWithArgsParentheses::MSG = T.let(T.unsafe(nil), String)
+
+# Enforces the use of shorthand-style swapping of 2 variables.
+#
+# @example
+#   # bad
+#   tmp = x
+#   x = y
+#   y = tmp
+#
+#   # good
+#   x, y = y, x
+#
+# source://rubocop//lib/rubocop/cop/style/swap_values.rb#21
+class RuboCop::Cop::Style::SwapValues < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/swap_values.rb#30
+  def on_asgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/swap_values.rb#30
+  def on_casgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/swap_values.rb#30
+  def on_cvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/swap_values.rb#30
+  def on_gvasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/swap_values.rb#30
+  def on_ivasgn(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/swap_values.rb#30
+  def on_lvasgn(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/swap_values.rb#47
+  def allowed_assignment?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/swap_values.rb#104
+  def correction_range(tmp_assign, y_assign); end
+
+  # source://rubocop//lib/rubocop/cop/style/swap_values.rb#81
+  def lhs(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/swap_values.rb#66
+  def message(x_assign, y_assign); end
+
+  # source://rubocop//lib/rubocop/cop/style/swap_values.rb#75
+  def replacement(x_assign); end
+
+  # source://rubocop//lib/rubocop/cop/style/swap_values.rb#95
+  def rhs(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/swap_values.rb#60
+  def simple_assignment?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/swap_values.rb#51
+  def swapping_values?(tmp_assign, x_assign, y_assign); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/swap_values.rb#25
+RuboCop::Cop::Style::SwapValues::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/swap_values.rb#28
+RuboCop::Cop::Style::SwapValues::SIMPLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Set)
+
+# Checks for array literals made up of symbols that are not
+# using the %i() syntax.
+#
+# Alternatively, it checks for symbol arrays using the %i() syntax on
+# projects which do not want to use that syntax, perhaps because they
+# support a version of Ruby lower than 2.0.
+#
+# Configuration option: MinSize
+# If set, arrays with fewer elements than this value will not trigger the
+# cop. For example, a `MinSize` of `3` will not enforce a style on an
+# array of 2 or fewer elements.
+#
+# @example EnforcedStyle: percent (default)
+#   # good
+#   %i[foo bar baz]
+#
+#   # bad
+#   [:foo, :bar, :baz]
+#
+#   # bad (contains spaces)
+#   %i[foo\ bar baz\ quux]
+#
+#   # bad (contains [] with spaces)
+#   %i[foo \[ \]]
+#
+#   # bad (contains () with spaces)
+#   %i(foo \( \))
+# @example EnforcedStyle: brackets
+#   # good
+#   [:foo, :bar, :baz]
+#
+#   # bad
+#   %i[foo bar baz]
+#
+# source://rubocop//lib/rubocop/cop/style/symbol_array.rb#40
+class RuboCop::Cop::Style::SymbolArray < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ArrayMinSize
+  include ::RuboCop::Cop::ArraySyntax
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::PercentArray
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#66
+  def on_array(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#96
+  def build_bracketed_array(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#78
+  def complex_content?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#92
+  def invalid_percent_array_contents?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#119
+  def symbol_without_quote?(string); end
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#111
+  def to_symbol_literal(string); end
+
+  class << self
+    # Returns the value of attribute largest_brackets.
+    #
+    # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#63
+    def largest_brackets; end
+
+    # Sets the attribute largest_brackets
+    #
+    # @param value the value to set the attribute largest_brackets to.
+    #
+    # source://rubocop//lib/rubocop/cop/style/symbol_array.rb#63
+    def largest_brackets=(_arg0); end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/symbol_array.rb#51
+RuboCop::Cop::Style::SymbolArray::ARRAY_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/symbol_array.rb#52
+RuboCop::Cop::Style::SymbolArray::DELIMITERS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/symbol_array.rb#50
+RuboCop::Cop::Style::SymbolArray::PERCENT_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/symbol_array.rb#57
+RuboCop::Cop::Style::SymbolArray::REDEFINABLE_OPERATORS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/symbol_array.rb#53
+RuboCop::Cop::Style::SymbolArray::SPECIAL_GVARS = T.let(T.unsafe(nil), Array)
+
+# Checks symbol literal syntax.
+#
+# @example
+#
+#   # bad
+#   :"symbol"
+#
+#   # good
+#   :symbol
+#
+# source://rubocop//lib/rubocop/cop/style/symbol_literal.rb#15
+class RuboCop::Cop::Style::SymbolLiteral < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_literal.rb#20
+  def on_sym(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/symbol_literal.rb#18
+RuboCop::Cop::Style::SymbolLiteral::MSG = T.let(T.unsafe(nil), String)
+
+# Use symbols as procs when possible.
+#
+# If you prefer a style that allows block for method with arguments,
+# please set `true` to `AllowMethodsWithArguments`.
+# `define_method?` methods are allowed by default.
+# These are customizable with `AllowedMethods` option.
+#
+# @example AllCops:ActiveSupportExtensionsEnabled: true
+#   # good
+#   ->(x) { x.foo }
+#   proc { |x| x.foo }
+#   Proc.new { |x| x.foo }
+# @example AllowMethodsWithArguments: false (default)
+#   # bad
+#   something.do_something(foo) { |o| o.bar }
+#
+#   # good
+#   something.do_something(foo, &:bar)
+# @example AllowMethodsWithArguments: true
+#   # good
+#   something.do_something(foo) { |o| o.bar }
+# @example AllowComments: false (default)
+#   # bad
+#   something.do_something do |s| # some comment
+#   # some comment
+#   s.upcase # some comment
+#   # some comment
+#   end
+# @example AllowComments: true
+#   # good  - if there are comment in either position
+#   something.do_something do |s| # some comment
+#   # some comment
+#   s.upcase # some comment
+#   # some comment
+#   end
+# @example AllowedMethods: [define_method] (default)
+#   # good
+#   define_method(:foo) { |foo| foo.bar }
+# @example AllowedPatterns: [] (default)
+#   # bad
+#   something.map { |s| s.upcase }
+# @example AllowedPatterns: ['map'] (default)
+#   # good
+#   something.map { |s| s.upcase }
+# @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+#   # bad
+#   ->(x) { x.foo }
+#   proc { |x| x.foo }
+#   Proc.new { |x| x.foo }
+#
+#   # good
+#   lambda(&:foo)
+#   proc(&:foo)
+#   Proc.new(&:foo)
+# @example
+#   # bad
+#   something.map { |s| s.upcase }
+#   something.map { _1.upcase }
+#
+#   # good
+#   something.map(&:upcase)
+#
+# source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#140
+class RuboCop::Cop::Style::SymbolProc < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::CommentsHelp
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::AllowedMethods
+  include ::RuboCop::Cop::AllowedPattern
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#189
+  def destructuring_block_argument?(argument_node); end
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#170
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#170
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#152
+  def proc_node?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#158
+  def symbol_proc?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#155
+  def symbol_proc_receiver?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#274
+  def allow_comments?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#270
+  def allow_if_method_has_argument?(send_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#204
+  def allowed_method_name?(name); end
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#217
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#247
+  def autocorrect_lambda_block(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#238
+  def autocorrect_with_args(corrector, node, args, method_name); end
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#225
+  def autocorrect_without_args(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#260
+  def begin_pos_for_replacement(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#255
+  def block_range_with_space(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#208
+  def register_offense(node, method_name, block_method_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#200
+  def unsafe_array_usage?(node); end
+
+  # See: https://github.com/rubocop/rubocop/issues/10864
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#196
+  def unsafe_hash_usage?(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#165
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#149
+RuboCop::Cop::Style::SymbolProc::LAMBDA_OR_PROC = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#147
+RuboCop::Cop::Style::SymbolProc::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/symbol_proc.rb#148
+RuboCop::Cop::Style::SymbolProc::SUPER_TYPES = T.let(T.unsafe(nil), Array)
+
+# Corrector to correct conditional assignment in ternary conditions.
+#
+# source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#499
+class RuboCop::Cop::Style::TernaryCorrector
+  extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper
+  extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#504
+    def correct(corrector, node); end
+
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#508
+    def move_assignment_inside_condition(corrector, node); end
+
+    private
+
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#522
+    def correction(node); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#535
+    def element_assignment?(node); end
+
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#539
+    def extract_branches(node); end
+
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#552
+    def move_branch_inside_condition(corrector, branch, assignment); end
+
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#547
+    def remove_parentheses(corrector, node); end
+
+    # source://rubocop//lib/rubocop/cop/style/conditional_assignment.rb#526
+    def ternary(node); end
+  end
+end
+
+# Checks for the presence of parentheses around ternary
+# conditions. It is configurable to enforce inclusion or omission of
+# parentheses using `EnforcedStyle`. Omission is only enforced when
+# removing the parentheses won't cause a different behavior.
+#
+# `AllowSafeAssignment` option for safe assignment.
+# By safe assignment we mean putting parentheses around
+# an assignment to indicate "I know I'm using an assignment
+# as a condition. It's not a mistake."
+#
+# @example EnforcedStyle: require_no_parentheses (default)
+#   # bad
+#   foo = (bar?) ? a : b
+#   foo = (bar.baz?) ? a : b
+#   foo = (bar && baz) ? a : b
+#
+#   # good
+#   foo = bar? ? a : b
+#   foo = bar.baz? ? a : b
+#   foo = bar && baz ? a : b
+# @example EnforcedStyle: require_parentheses
+#   # bad
+#   foo = bar? ? a : b
+#   foo = bar.baz? ? a : b
+#   foo = bar && baz ? a : b
+#
+#   # good
+#   foo = (bar?) ? a : b
+#   foo = (bar.baz?) ? a : b
+#   foo = (bar && baz) ? a : b
+# @example EnforcedStyle: require_parentheses_when_complex
+#   # bad
+#   foo = (bar?) ? a : b
+#   foo = (bar.baz?) ? a : b
+#   foo = bar && baz ? a : b
+#
+#   # good
+#   foo = bar? ? a : b
+#   foo = bar.baz? ? a : b
+#   foo = (bar && baz) ? a : b
+# @example AllowSafeAssignment: true (default)
+#   # good
+#   foo = (bar = baz) ? a : b
+# @example AllowSafeAssignment: false
+#   # bad
+#   foo = (bar = baz) ? a : b
+#
+# source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#57
+class RuboCop::Cop::Style::TernaryParentheses < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::SafeAssignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::SurroundingSpace
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#193
+  def method_name(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#69
+  def on_if(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#100
+  def autocorrect(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#183
+  def below_ternary_precedence?(child); end
+
+  # If the condition is parenthesized we recurse and check for any
+  # complex expressions within it.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#131
+  def complex_condition?(condition); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#89
+  def condition_as_parenthesized_one_line_pattern_matching?(condition); end
+
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#198
+  def correct_parenthesized(corrector, condition); end
+
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#208
+  def correct_unparenthesized(corrector, condition); end
+
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#151
+  def message(node); end
+
+  # Anything that is not a variable, constant, or method/.method call
+  # will be counted as a complex expression.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#141
+  def non_complex_expression?(condition); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#145
+  def non_complex_send?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#113
+  def offense?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#85
+  def only_closing_parenthesis_is_last_line?(condition); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#169
+  def parenthesized?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#161
+  def require_parentheses?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#165
+  def require_parentheses_when_complex?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#179
+  def unparenthesized_method_call?(child); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#173
+  def unsafe_autocorrect?(condition); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#212
+  def whitespace_after?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#66
+RuboCop::Cop::Style::TernaryParentheses::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#67
+RuboCop::Cop::Style::TernaryParentheses::MSG_COMPLEX = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#64
+RuboCop::Cop::Style::TernaryParentheses::NON_COMPLEX_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/ternary_parentheses.rb#63
+RuboCop::Cop::Style::TernaryParentheses::VARIABLE_TYPES = T.let(T.unsafe(nil), Set)
+
+# Newcomers to ruby applications may write top-level methods,
+# when ideally they should be organized in appropriate classes or modules.
+# This cop looks for definitions of top-level methods and warns about them.
+#
+# However for ruby scripts it is perfectly fine to use top-level methods.
+# Hence this cop is disabled by default.
+#
+# @example
+#   # bad
+#   def some_method
+#   end
+#
+#   # bad
+#   def self.some_method
+#   end
+#
+#   # bad
+#   define_method(:foo) { puts 1 }
+#
+#   # good
+#   module Foo
+#   def some_method
+#   end
+#   end
+#
+#   # good
+#   class Foo
+#   def self.some_method
+#   end
+#   end
+#
+#   # good
+#   Struct.new do
+#   def some_method
+#   end
+#   end
+#
+#   # good
+#   class Foo
+#   define_method(:foo) { puts 1 }
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#47
+class RuboCop::Cop::Style::TopLevelMethodDefinition < ::RuboCop::Cop::Base
+  # source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#79
+  def define_method_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#60
+  def on_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#52
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#52
+  def on_defs(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#60
+  def on_numblock(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#52
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#70
+  def top_level_method_definition?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#48
+RuboCop::Cop::Style::TopLevelMethodDefinition::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/top_level_method_definition.rb#50
+RuboCop::Cop::Style::TopLevelMethodDefinition::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for trailing code after the class definition.
+#
+# @example
+#   # bad
+#   class Foo; def foo; end
+#   end
+#
+#   # good
+#   class Foo
+#   def foo; end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/trailing_body_on_class.rb#18
+class RuboCop::Cop::Style::TrailingBodyOnClass < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::TrailingBody
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_body_on_class.rb#25
+  def on_class(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_body_on_class.rb#25
+  def on_sclass(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/trailing_body_on_class.rb#23
+RuboCop::Cop::Style::TrailingBodyOnClass::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for trailing code after the method definition.
+#
+# NOTE: It always accepts endless method definitions that are basically on the same line.
+#
+# @example
+#   # bad
+#   def some_method; do_stuff
+#   end
+#
+#   def f(x); b = foo
+#   b[c: x]
+#   end
+#
+#   # good
+#   def some_method
+#   do_stuff
+#   end
+#
+#   def f(x)
+#   b = foo
+#   b[c: x]
+#   end
+#
+#   def endless_method = do_stuff
+#
+# source://rubocop//lib/rubocop/cop/style/trailing_body_on_method_definition.rb#31
+class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::TrailingBody
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_body_on_method_definition.rb#38
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_body_on_method_definition.rb#38
+  def on_defs(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/trailing_body_on_method_definition.rb#36
+RuboCop::Cop::Style::TrailingBodyOnMethodDefinition::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for trailing code after the module definition.
+#
+# @example
+#   # bad
+#   module Foo extend self
+#   end
+#
+#   # good
+#   module Foo
+#   extend self
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/trailing_body_on_module.rb#18
+class RuboCop::Cop::Style::TrailingBodyOnModule < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::TrailingBody
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_body_on_module.rb#25
+  def on_module(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/trailing_body_on_module.rb#23
+RuboCop::Cop::Style::TrailingBodyOnModule::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for trailing comma in argument lists.
+# The supported styles are:
+#
+# * `consistent_comma`: Requires a comma after the last argument,
+# for all parenthesized method calls with arguments.
+# * `comma`: Requires a comma after the last argument, but only for
+# parenthesized method calls where each argument is on its own line.
+# * `no_comma`: Requires that there is no comma after the last
+# argument.
+#
+# @example EnforcedStyleForMultiline: consistent_comma
+#   # bad
+#   method(1, 2,)
+#
+#   # good
+#   method(1, 2)
+#
+#   # good
+#   method(
+#   1, 2,
+#   3,
+#   )
+#
+#   # good
+#   method(
+#   1, 2, 3,
+#   )
+#
+#   # good
+#   method(
+#   1,
+#   2,
+#   )
+# @example EnforcedStyleForMultiline: comma
+#   # bad
+#   method(1, 2,)
+#
+#   # good
+#   method(1, 2)
+#
+#   # bad
+#   method(
+#   1, 2,
+#   3,
+#   )
+#
+#   # good
+#   method(
+#   1, 2,
+#   3
+#   )
+#
+#   # bad
+#   method(
+#   1, 2, 3,
+#   )
+#
+#   # good
+#   method(
+#   1, 2, 3
+#   )
+#
+#   # good
+#   method(
+#   1,
+#   2,
+#   )
+# @example EnforcedStyleForMultiline: no_comma (default)
+#   # bad
+#   method(1, 2,)
+#
+#   # good
+#   method(1, 2)
+#
+#   # good
+#   method(
+#   1,
+#   2
+#   )
+#
+# source://rubocop//lib/rubocop/cop/style/trailing_comma_in_arguments.rb#87
+class RuboCop::Cop::Style::TrailingCommaInArguments < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::TrailingComma
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_arguments.rb#95
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_arguments.rb#95
+  def on_send(node); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_arguments.rb#91
+    def autocorrect_incompatible_with; end
+  end
+end
+
+# Checks for trailing comma in array literals.
+# The configuration options are:
+#
+# * `consistent_comma`: Requires a comma after the
+# last item of all non-empty, multiline array literals.
+# * `comma`: Requires a comma after last item in an array,
+# but only when each item is on its own line.
+# * `no_comma`: Does not require a comma after the
+# last item in an array
+#
+# @example EnforcedStyleForMultiline: consistent_comma
+#   # bad
+#   a = [1, 2,]
+#
+#   # good
+#   a = [1, 2]
+#
+#   # good
+#   a = [
+#   1, 2,
+#   3,
+#   ]
+#
+#   # good
+#   a = [
+#   1, 2, 3,
+#   ]
+#
+#   # good
+#   a = [
+#   1,
+#   2,
+#   ]
+# @example EnforcedStyleForMultiline: comma
+#   # bad
+#   a = [1, 2,]
+#
+#   # good
+#   a = [1, 2]
+#
+#   # bad
+#   a = [
+#   1, 2,
+#   3,
+#   ]
+#
+#   # good
+#   a = [
+#   1, 2,
+#   3
+#   ]
+#
+#   # bad
+#   a = [
+#   1, 2, 3,
+#   ]
+#
+#   # good
+#   a = [
+#   1, 2, 3
+#   ]
+#
+#   # good
+#   a = [
+#   1,
+#   2,
+#   ]
+# @example EnforcedStyleForMultiline: no_comma (default)
+#   # bad
+#   a = [1, 2,]
+#
+#   # good
+#   a = [
+#   1,
+#   2
+#   ]
+#
+# source://rubocop//lib/rubocop/cop/style/trailing_comma_in_array_literal.rb#84
+class RuboCop::Cop::Style::TrailingCommaInArrayLiteral < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::TrailingComma
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_array_literal.rb#88
+  def on_array(node); end
+end
+
+# Checks whether trailing commas in block arguments are
+# required. Blocks with only one argument and a trailing comma require
+# that comma to be present. Blocks with more than one argument never
+# require a trailing comma.
+#
+# @example
+#   # bad
+#   add { |foo, bar,| foo + bar }
+#
+#   # good
+#   add { |foo, bar| foo + bar }
+#
+#   # good
+#   add { |foo,| foo }
+#
+#   # good
+#   add { foo }
+#
+#   # bad
+#   add do |foo, bar,|
+#   foo + bar
+#   end
+#
+#   # good
+#   add do |foo, bar|
+#   foo + bar
+#   end
+#
+#   # good
+#   add do |foo,|
+#   foo
+#   end
+#
+#   # good
+#   add do
+#   foo + bar
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#62
+class RuboCop::Cop::Style::TrailingCommaInBlockArgs < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#67
+  def on_block(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#83
+  def arg_count(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#95
+  def argument_tokens(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#91
+  def last_comma(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#87
+  def trailing_comma?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#79
+  def useless_trailing_comma?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/trailing_comma_in_block_args.rb#65
+RuboCop::Cop::Style::TrailingCommaInBlockArgs::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for trailing comma in hash literals.
+# The configuration options are:
+#
+# * `consistent_comma`: Requires a comma after the
+# last item of all non-empty, multiline hash literals.
+# * `comma`: Requires a comma after the last item in a hash,
+# but only when each item is on its own line.
+# * `no_comma`: Does not require a comma after the
+# last item in a hash
+#
+# @example EnforcedStyleForMultiline: consistent_comma
+#
+#   # bad
+#   a = { foo: 1, bar: 2, }
+#
+#   # good
+#   a = { foo: 1, bar: 2 }
+#
+#   # good
+#   a = {
+#   foo: 1, bar: 2,
+#   qux: 3,
+#   }
+#
+#   # good
+#   a = {
+#   foo: 1, bar: 2, qux: 3,
+#   }
+#
+#   # good
+#   a = {
+#   foo: 1,
+#   bar: 2,
+#   }
+# @example EnforcedStyleForMultiline: comma
+#
+#   # bad
+#   a = { foo: 1, bar: 2, }
+#
+#   # good
+#   a = { foo: 1, bar: 2 }
+#
+#   # bad
+#   a = {
+#   foo: 1, bar: 2,
+#   qux: 3,
+#   }
+#
+#   # good
+#   a = {
+#   foo: 1, bar: 2,
+#   qux: 3
+#   }
+#
+#   # bad
+#   a = {
+#   foo: 1, bar: 2, qux: 3,
+#   }
+#
+#   # good
+#   a = {
+#   foo: 1, bar: 2, qux: 3
+#   }
+#
+#   # good
+#   a = {
+#   foo: 1,
+#   bar: 2,
+#   }
+# @example EnforcedStyleForMultiline: no_comma (default)
+#
+#   # bad
+#   a = { foo: 1, bar: 2, }
+#
+#   # good
+#   a = {
+#   foo: 1,
+#   bar: 2
+#   }
+#
+# source://rubocop//lib/rubocop/cop/style/trailing_comma_in_hash_literal.rb#87
+class RuboCop::Cop::Style::TrailingCommaInHashLiteral < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::TrailingComma
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_comma_in_hash_literal.rb#91
+  def on_hash(node); end
+end
+
+# Checks for trailing code after the method definition.
+#
+# @example
+#   # bad
+#   def some_method
+#   do_stuff; end
+#
+#   def do_this(x)
+#   baz.map { |b| b.this(x) } end
+#
+#   def foo
+#   block do
+#   bar
+#   end end
+#
+#   # good
+#   def some_method
+#   do_stuff
+#   end
+#
+#   def do_this(x)
+#   baz.map { |b| b.this(x) }
+#   end
+#
+#   def foo
+#   block do
+#   bar
+#   end
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/trailing_method_end_statement.rb#36
+class RuboCop::Cop::Style::TrailingMethodEndStatement < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_method_end_statement.rb#41
+  def on_def(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trailing_method_end_statement.rb#55
+  def body_and_end_on_same_line?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trailing_method_end_statement.rb#51
+  def trailing_end?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/trailing_method_end_statement.rb#39
+RuboCop::Cop::Style::TrailingMethodEndStatement::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for extra underscores in variable assignment.
+#
+# @example
+#   # bad
+#   a, b, _ = foo()
+#   a, b, _, = foo()
+#   a, _, _ = foo()
+#   a, _, _, = foo()
+#
+#   # good
+#   a, b, = foo()
+#   a, = foo()
+#   *a, b, _ = foo()
+#   # => We need to know to not include 2 variables in a
+#   a, *b, _ = foo()
+#   # => The correction `a, *b, = foo()` is a syntax error
+# @example AllowNamedUnderscoreVariables: true (default)
+#   # good
+#   a, b, _something = foo()
+# @example AllowNamedUnderscoreVariables: false
+#   # bad
+#   a, b, _something = foo()
+#
+# source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#31
+class RuboCop::Cop::Style::TrailingUnderscoreVariable < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::SurroundingSpace
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#41
+  def on_masgn(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#92
+  def allow_named_underscore_variables; end
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#125
+  def children_offenses(variables); end
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#57
+  def find_first_offense(variables); end
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#66
+  def find_first_possible_offense(variables); end
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#108
+  def main_node_offense(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#146
+  def range_for_parentheses(offense, left); end
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#88
+  def reverse_index(collection, item); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#80
+  def splat_variable_before?(first_offense, variables); end
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#96
+  def unneeded_ranges(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#133
+  def unused_range(node_type, mlhs_node, right); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#129
+  def unused_variables_only?(offense, variables); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#38
+RuboCop::Cop::Style::TrailingUnderscoreVariable::DISALLOW = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#36
+RuboCop::Cop::Style::TrailingUnderscoreVariable::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/trailing_underscore_variable.rb#37
+RuboCop::Cop::Style::TrailingUnderscoreVariable::UNDERSCORE = T.let(T.unsafe(nil), String)
+
+# Looks for trivial reader/writer methods, that could
+# have been created with the attr_* family of functions automatically.
+# `to_ary`, `to_a`, `to_c`, `to_enum`, `to_h`, `to_hash`, `to_i`, `to_int`, `to_io`,
+# `to_open`, `to_path`, `to_proc`, `to_r`, `to_regexp`, `to_str`, `to_s`, and `to_sym` methods
+# are allowed by default. These are customizable with `AllowedMethods` option.
+#
+# @example AllowedMethods: ['allowed_method']
+#   # good
+#   def allowed_method
+#   @foo
+#   end
+# @example ExactNameMatch: true (default)
+#   # good
+#   def name
+#   @other_name
+#   end
+# @example ExactNameMatch: false
+#   # bad
+#   def name
+#   @other_name
+#   end
+# @example AllowPredicates: true (default)
+#   # good
+#   def foo?
+#   @foo
+#   end
+# @example AllowPredicates: false
+#   # bad
+#   def foo?
+#   @foo
+#   end
+#
+#   # good
+#   attr_reader :foo
+# @example AllowDSLWriters: true (default)
+#   # good
+#   def on_exception(action)
+#   @on_exception=action
+#   end
+# @example AllowDSLWriters: false
+#   # bad
+#   def on_exception(action)
+#   @on_exception=action
+#   end
+#
+#   # good
+#   attr_writer :on_exception
+# @example IgnoreClassMethods: false (default)
+#   # bad
+#   def self.foo
+#   @foo
+#   end
+#
+#   # good
+#   class << self
+#   attr_reader :foo
+#   end
+# @example IgnoreClassMethods: true
+#   # good
+#   def self.foo
+#   @foo
+#   end
+# @example
+#   # bad
+#   def foo
+#   @foo
+#   end
+#
+#   def bar=(val)
+#   @bar = val
+#   end
+#
+#   def self.baz
+#   @baz
+#   end
+#
+#   # good
+#   attr_reader :foo
+#   attr_writer :bar
+#
+#   class << self
+#   attr_reader :baz
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#98
+class RuboCop::Cop::Style::TrivialAccessors < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::AllowedMethods
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#190
+  def looks_like_trivial_writer?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#104
+  def on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#104
+  def on_defs(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#222
+  def accessor(kind, method_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#161
+  def allow_dsl_writers?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#157
+  def allow_predicates?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#195
+  def allowed_method_name?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#169
+  def allowed_method_names; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#204
+  def allowed_reader?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#200
+  def allowed_writer?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#142
+  def autocorrect(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#234
+  def autocorrect_class(corrector, node); end
+
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#226
+  def autocorrect_instance(corrector, node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#173
+  def dsl_writer?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#153
+  def exact_name_match?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#165
+  def ignore_class_methods?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#115
+  def in_module_or_instance_eval?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#181
+  def looks_like_trivial_reader?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#208
+  def names_match?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#129
+  def on_method_def(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#248
+  def top_level_node?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#214
+  def trivial_accessor_kind(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#177
+  def trivial_reader?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#185
+  def trivial_writer?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/trivial_accessors.rb#102
+RuboCop::Cop::Style::TrivialAccessors::MSG = T.let(T.unsafe(nil), String)
+
+# Looks for `unless` expressions with `else` clauses.
+#
+# @example
+#   # bad
+#   unless foo_bar.nil?
+#   # do something...
+#   else
+#   # do a different thing...
+#   end
+#
+#   # good
+#   if foo_bar.present?
+#   # do something...
+#   else
+#   # do a different thing...
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/unless_else.rb#22
+class RuboCop::Cop::Style::UnlessElse < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/unless_else.rb#28
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/unless_else.rb#45
+  def range_between_condition_and_else(node, condition); end
+
+  # source://rubocop//lib/rubocop/cop/style/unless_else.rb#49
+  def range_between_else_and_end(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/unless_else.rb#26
+RuboCop::Cop::Style::UnlessElse::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the use of logical operators in an `unless` condition.
+# It discourages such code, as the condition becomes more difficult
+# to read and understand.
+#
+# This cop supports two styles:
+#
+# - `forbid_mixed_logical_operators` (default)
+# - `forbid_logical_operators`
+#
+# `forbid_mixed_logical_operators` style forbids the use of more than one type
+# of logical operators. This makes the `unless` condition easier to read
+# because either all conditions need to be met or any condition need to be met
+# in order for the expression to be truthy or falsey.
+#
+# `forbid_logical_operators` style forbids any use of logical operator.
+# This makes it even more easy to read the `unless` condition as
+# there is only one condition in the expression.
+#
+# @example EnforcedStyle: forbid_mixed_logical_operators (default)
+#   # bad
+#   return unless a || b && c
+#   return unless a && b || c
+#   return unless a && b and c
+#   return unless a || b or c
+#   return unless a && b or c
+#   return unless a || b and c
+#
+#   # good
+#   return unless a && b && c
+#   return unless a || b || c
+#   return unless a and b and c
+#   return unless a or b or c
+#   return unless a?
+# @example EnforcedStyle: forbid_logical_operators
+#   # bad
+#   return unless a || b
+#   return unless a && b
+#   return unless a or b
+#   return unless a and b
+#
+#   # good
+#   return unless a
+#   return unless a?
+#
+# source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#50
+class RuboCop::Cop::Style::UnlessLogicalOperators < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+
+  # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#62
+  def and_with_or?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#67
+  def logical_operator?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#71
+  def on_if(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#57
+  def or_with_and?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#83
+  def mixed_logical_operator?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#90
+  def mixed_precedence_and?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#97
+  def mixed_precedence_or?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#54
+RuboCop::Cop::Style::UnlessLogicalOperators::FORBID_LOGICAL_OPERATORS = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/unless_logical_operators.rb#53
+RuboCop::Cop::Style::UnlessLogicalOperators::FORBID_MIXED_LOGICAL_OPERATORS = T.let(T.unsafe(nil), String)
+
+# Checks for accessing the first element of `String#unpack`
+# which can be replaced with the shorter method `unpack1`.
+#
+# @example
+#
+#   # bad
+#   'foo'.unpack('h*').first
+#   'foo'.unpack('h*')[0]
+#   'foo'.unpack('h*').slice(0)
+#   'foo'.unpack('h*').at(0)
+#
+#   # good
+#   'foo'.unpack1('h*')
+#
+# source://rubocop//lib/rubocop/cop/style/unpack_first.rb#20
+class RuboCop::Cop::Style::UnpackFirst < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+  extend ::RuboCop::Cop::TargetRubyVersion
+
+  # source://rubocop//lib/rubocop/cop/style/unpack_first.rb#37
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/unpack_first.rb#37
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/unpack_first.rb#30
+  def unpack_and_first_element?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/unpack_first.rb#53
+  def first_element_range(node, unpack_call); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/unpack_first.rb#26
+RuboCop::Cop::Style::UnpackFirst::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/unpack_first.rb#27
+RuboCop::Cop::Style::UnpackFirst::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for variable interpolation (like "#@ivar").
+#
+# @example
+#   # bad
+#   "His name is #$name"
+#   /check #$pattern/
+#   "Let's go to the #@store"
+#
+#   # good
+#   "His name is #{$name}"
+#   /check #{$pattern}/
+#   "Let's go to the #{@store}"
+#
+# source://rubocop//lib/rubocop/cop/style/variable_interpolation.rb#18
+class RuboCop::Cop::Style::VariableInterpolation < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Interpolation
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/variable_interpolation.rb#25
+  def on_node_with_interpolations(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/variable_interpolation.rb#35
+  def message(range); end
+
+  # source://rubocop//lib/rubocop/cop/style/variable_interpolation.rb#39
+  def var_nodes(nodes); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/variable_interpolation.rb#22
+RuboCop::Cop::Style::VariableInterpolation::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for `when;` uses in `case` expressions.
+#
+# @example
+#   # bad
+#   case foo
+#   when 1; 'baz'
+#   when 2; 'bar'
+#   end
+#
+#   # good
+#   case foo
+#   when 1 then 'baz'
+#   when 2 then 'bar'
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/when_then.rb#20
+class RuboCop::Cop::Style::WhenThen < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/when_then.rb#25
+  def on_when(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/when_then.rb#23
+RuboCop::Cop::Style::WhenThen::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for uses of `do` in multi-line `while/until` statements.
+#
+# @example
+#
+#   # bad
+#   while x.any? do
+#   do_something(x.pop)
+#   end
+#
+#   # good
+#   while x.any?
+#   do_something(x.pop)
+#   end
+#
+#   # bad
+#   until x.empty? do
+#   do_something(x.pop)
+#   end
+#
+#   # good
+#   until x.empty?
+#   do_something(x.pop)
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/while_until_do.rb#29
+class RuboCop::Cop::Style::WhileUntilDo < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/while_until_do.rb#34
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/while_until_do.rb#34
+  def on_while(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/while_until_do.rb#32
+RuboCop::Cop::Style::WhileUntilDo::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for while and until statements that would fit on one line
+# if written as a modifier while/until. The maximum line length is
+# configured in the `Layout/LineLength` cop.
+#
+# @example
+#   # bad
+#   while x < 10
+#   x += 1
+#   end
+#
+#   # good
+#   x += 1 while x < 10
+#
+#   # bad
+#   until x > 10
+#   x += 1
+#   end
+#
+#   # good
+#   x += 1 until x > 10
+# @example
+#   # bad
+#   x += 100 while x < 500 # a long comment that makes code too long if it were a single line
+#
+#   # good
+#   while x < 500 # a long comment that makes code too long if it were a single line
+#   x += 100
+#   end
+#
+# source://rubocop//lib/rubocop/cop/style/while_until_modifier.rb#35
+class RuboCop::Cop::Style::WhileUntilModifier < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::LineLengthHelp
+  include ::RuboCop::Cop::StatementModifier
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/while_until_modifier.rb#41
+  def on_until(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/while_until_modifier.rb#41
+  def on_while(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/while_until_modifier.rb#39
+RuboCop::Cop::Style::WhileUntilModifier::MSG = T.let(T.unsafe(nil), String)
+
+# Checks for array literals made up of word-like
+# strings, that are not using the %w() syntax.
+#
+# Alternatively, it can check for uses of the %w() syntax, in projects
+# which do not want to include that syntax.
+#
+# NOTE: When using the `percent` style, %w() arrays containing a space
+# will be registered as offenses.
+#
+# Configuration option: MinSize
+# If set, arrays with fewer elements than this value will not trigger the
+# cop. For example, a `MinSize` of `3` will not enforce a style on an
+# array of 2 or fewer elements.
+#
+# @example EnforcedStyle: percent (default)
+#   # good
+#   %w[foo bar baz]
+#
+#   # bad
+#   ['foo', 'bar', 'baz']
+#
+#   # bad (contains spaces)
+#   %w[foo\ bar baz\ quux]
+#
+#   # bad
+#   [
+#   ['one', 'One'],
+#   ['two', 'Two']
+#   ]
+#
+#   # good
+#   [
+#   %w[one One],
+#   %w[two Two]
+#   ]
+#
+#   # good (2d array containing spaces)
+#   [
+#   ['one', 'One'],
+#   ['two', 'Two'],
+#   ['forty two', 'Forty Two']
+#   ]
+# @example EnforcedStyle: brackets
+#   # good
+#   ['foo', 'bar', 'baz']
+#
+#   # bad
+#   %w[foo bar baz]
+#
+#   # good (contains spaces)
+#   ['foo bar', 'baz quux']
+#
+#   # good
+#   [
+#   ['one', 'One'],
+#   ['two', 'Two']
+#   ]
+#
+#   # bad
+#   [
+#   %w[one One],
+#   %w[two Two]
+#   ]
+#
+# source://rubocop//lib/rubocop/cop/style/word_array.rb#71
+class RuboCop::Cop::Style::WordArray < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ArrayMinSize
+  include ::RuboCop::Cop::ArraySyntax
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::PercentArray
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/word_array.rb#94
+  def on_array(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/word_array.rb#85
+  def on_new_investigation; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/word_array.rb#138
+  def build_bracketed_array(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/word_array.rb#118
+  def complex_content?(strings, complex_regex: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/word_array.rb#129
+  def invalid_percent_array_contents?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/word_array.rb#113
+  def matrix_of_complex_content?(array); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/word_array.rb#107
+  def within_matrix_of_complex_content?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/word_array.rb#134
+  def word_regex; end
+
+  class << self
+    # Returns the value of attribute largest_brackets.
+    #
+    # source://rubocop//lib/rubocop/cop/style/word_array.rb#82
+    def largest_brackets; end
+
+    # Sets the attribute largest_brackets
+    #
+    # @param value the value to set the attribute largest_brackets to.
+    #
+    # source://rubocop//lib/rubocop/cop/style/word_array.rb#82
+    def largest_brackets=(_arg0); end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/style/word_array.rb#79
+RuboCop::Cop::Style::WordArray::ARRAY_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/word_array.rb#78
+RuboCop::Cop::Style::WordArray::PERCENT_MSG = T.let(T.unsafe(nil), String)
+
+# Checks for the use of `YAML.load`, `YAML.safe_load`, and `YAML.parse` with
+# `File.read` argument.
+#
+# NOTE: `YAML.safe_load_file` was introduced in Ruby 3.0.
+#
+# @example
+#
+#   # bad
+#   YAML.load(File.read(path))
+#   YAML.parse(File.read(path))
+#
+#   # good
+#   YAML.load_file(path)
+#   YAML.parse_file(path)
+#
+#   # bad
+#   YAML.safe_load(File.read(path)) # Ruby 3.0 and newer
+#
+#   # good
+#   YAML.safe_load_file(path)       # Ruby 3.0 and newer
+#
+# source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#27
+class RuboCop::Cop::Style::YAMLFileRead < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#41
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#34
+  def yaml_file_read?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#60
+  def offense_range(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#30
+RuboCop::Cop::Style::YAMLFileRead::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/yaml_file_read.rb#31
+RuboCop::Cop::Style::YAMLFileRead::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Enforces or forbids Yoda conditions,
+# i.e. comparison operations where the order of expression is reversed.
+# eg. `5 == x`
+#
+# @example EnforcedStyle: forbid_for_all_comparison_operators (default)
+#   # bad
+#   99 == foo
+#   "bar" != foo
+#   42 >= foo
+#   10 < bar
+#   99 == CONST
+#
+#   # good
+#   foo == 99
+#   foo == "bar"
+#   foo <= 42
+#   bar > 10
+#   CONST == 99
+#   "#{interpolation}" == foo
+#   /#{interpolation}/ == foo
+# @example EnforcedStyle: forbid_for_equality_operators_only
+#   # bad
+#   99 == foo
+#   "bar" != foo
+#
+#   # good
+#   99 >= foo
+#   3 < a && a < 5
+# @example EnforcedStyle: require_for_all_comparison_operators
+#   # bad
+#   foo == 99
+#   foo == "bar"
+#   foo <= 42
+#   bar > 10
+#
+#   # good
+#   99 == foo
+#   "bar" != foo
+#   42 >= foo
+#   10 < bar
+# @example EnforcedStyle: require_for_equality_operators_only
+#   # bad
+#   99 >= foo
+#   3 < a && a < 5
+#
+#   # good
+#   99 == foo
+#   "bar" != foo
+#
+# source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#77
+class RuboCop::Cop::Style::YodaCondition < ::RuboCop::Cop::Base
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#90
+  def file_constant_equal_program_name?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#94
+  def on_send(node); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#149
+  def actual_code_range(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#145
+  def constant_portion?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#138
+  def corrected_code(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#107
+  def enforce_yoda?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#112
+  def equality_only?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#173
+  def interpolation?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#134
+  def message(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#157
+  def non_equality_operator?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#161
+  def noncommutative_operator?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#169
+  def program_name?(name); end
+
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#153
+  def reverse_comparison(operator); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#165
+  def source_file_path_constant?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#122
+  def valid_yoda?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#117
+  def yoda_compatible_condition?(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#84
+RuboCop::Cop::Style::YodaCondition::EQUALITY_OPERATORS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#82
+RuboCop::Cop::Style::YodaCondition::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#85
+RuboCop::Cop::Style::YodaCondition::NONCOMMUTATIVE_OPERATORS = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#86
+RuboCop::Cop::Style::YodaCondition::PROGRAM_NAMES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#87
+RuboCop::Cop::Style::YodaCondition::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)
+
+# source://rubocop//lib/rubocop/cop/style/yoda_condition.rb#83
+RuboCop::Cop::Style::YodaCondition::REVERSE_COMPARISON = T.let(T.unsafe(nil), Hash)
+
+# Forbids Yoda expressions, i.e. binary operations (using `*`, `+`, `&`, `|`,
+# and `^` operators) where the order of expression is reversed, eg. `1 + x`.
+# This cop complements `Style/YodaCondition` cop, which has a similar purpose.
+#
+# This cop is disabled by default to respect user intentions such as:
+#
+# [source,ruby]
+# ----
+# config.server_port = 9000 + ENV["TEST_ENV_NUMBER"].to_i
+# ----
+#
+# @example SupportedOperators: ['*', '+', '&', '|', '^'] (default)
+#   # bad
+#   10 * y
+#   1 + x
+#   1 & z
+#   1 | x
+#   1 ^ x
+#   1 + CONST
+#
+#   # good
+#   y * 10
+#   x + 1
+#   z & 1
+#   x | 1
+#   x ^ 1
+#   CONST + 1
+#   60 * 24
+#
+# source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#40
+class RuboCop::Cop::Style::YodaExpression < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#47
+  def on_new_investigation; end
+
+  # source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#51
+  def on_send(node); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#73
+  def constant_portion?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#81
+  def offended_ancestor?(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#85
+  def offended_nodes; end
+
+  # source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#77
+  def supported_operators; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#69
+  def yoda_expression_constant?(lhs, rhs); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#43
+RuboCop::Cop::Style::YodaExpression::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/yoda_expression.rb#45
+RuboCop::Cop::Style::YodaExpression::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# Checks for numeric comparisons that can be replaced
+# by a predicate method, such as `receiver.length == 0`,
+# `receiver.length > 0`, and `receiver.length != 0`,
+# `receiver.length < 1` and `receiver.size == 0` that can be
+# replaced by `receiver.empty?` and `!receiver.empty?`.
+#
+# NOTE: `File`, `Tempfile`, and `StringIO` do not have `empty?`
+# so allow `size == 0` and `size.zero?`.
+#
+# @example
+#   # bad
+#   [1, 2, 3].length == 0
+#   0 == "foobar".length
+#   array.length < 1
+#   {a: 1, b: 2}.length != 0
+#   string.length > 0
+#   hash.size > 0
+#
+#   # good
+#   [1, 2, 3].empty?
+#   "foobar".empty?
+#   array.empty?
+#   !{a: 1, b: 2}.empty?
+#   !string.empty?
+#   !hash.empty?
+#
+# source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#37
+class RuboCop::Cop::Style::ZeroLengthPredicate < ::RuboCop::Cop::Base
+  extend ::RuboCop::Cop::AutoCorrector
+
+  # Some collection like objects in the Ruby standard library
+  # implement `#size`, but not `#empty`. We ignore those to
+  # reduce false positives.
+  #
+  # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#147
+  def non_polymorphic_collection?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#114
+  def nonzero_length_comparison(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#51
+  def on_csend(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#45
+  def on_send(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#138
+  def other_length_node(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#106
+  def zero_length_comparison(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#130
+  def zero_length_node(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#101
+  def zero_length_predicate?(param0 = T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#85
+  def check_nonzero_length_comparison(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#70
+  def check_zero_length_comparison(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#58
+  def check_zero_length_predicate(node); end
+
+  # source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#119
+  def replacement(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#41
+RuboCop::Cop::Style::ZeroLengthPredicate::NONZERO_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#43
+RuboCop::Cop::Style::ZeroLengthPredicate::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/cop/style/zero_length_predicate.rb#40
+RuboCop::Cop::Style::ZeroLengthPredicate::ZERO_MSG = T.let(T.unsafe(nil), String)
+
+# Common functionality for checking and correcting surrounding whitespace.
+#
+# source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#6
+module RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::RangeHelp
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#110
+  def empty_brackets?(left_bracket_token, right_bracket_token, tokens: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#104
+  def empty_offense(node, range, message, command); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#94
+  def empty_offenses(node, left, right, message); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#68
+  def extra_space?(token, side); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#129
+  def no_character_between?(left_bracket_token, right_bracket_token); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#38
+  def no_space_offenses(node, left_token, right_token, message, start_ok: T.unsafe(nil), end_ok: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#120
+  def offending_empty_no_space?(config, left_token, right_token); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#116
+  def offending_empty_space?(config, left_token, right_token); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#33
+  def on_new_investigation; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#78
+  def reposition(src, pos, step, include_newlines: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#16
+  def side_space_range(range:, side:, include_newlines: T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#124
+  def space_between?(left_bracket_token, right_bracket_token); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#85
+  def space_offense(node, token, side, message, command); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#53
+  def space_offenses(node, left_token, right_token, message, start_ok: T.unsafe(nil), end_ok: T.unsafe(nil)); end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#9
+RuboCop::Cop::SurroundingSpace::NO_SPACE_COMMAND = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#12
+RuboCop::Cop::SurroundingSpace::SINGLE_SPACE_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/mixin/surrounding_space.rb#10
+RuboCop::Cop::SurroundingSpace::SPACE_COMMAND = T.let(T.unsafe(nil), String)
+
+# Classes that include this module just implement functions for working
+# with symbol nodes.
+#
+# source://rubocop//lib/rubocop/cop/mixin/symbol_help.rb#7
+module RuboCop::Cop::SymbolHelp
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/symbol_help.rb#8
+  def hash_key?(node); end
+end
+
+# Common functionality for checking target ruby version.
+#
+# source://rubocop//lib/rubocop/cop/mixin/target_ruby_version.rb#6
+module RuboCop::Cop::TargetRubyVersion
+  # source://rubocop//lib/rubocop/cop/mixin/target_ruby_version.rb#11
+  def minimum_target_ruby_version(version); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/target_ruby_version.rb#7
+  def required_minimum_ruby_version; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/target_ruby_version.rb#15
+  def support_target_ruby_version?(version); end
+end
+
+# A group of cops, ready to be called on duty to inspect files.
+# Team is responsible for selecting only relevant cops to be sent on duty,
+# as well as insuring that the needed forces are sent along with them.
+#
+# For performance reasons, Team will first dispatch cops & forces in two groups,
+# first the ones needed for autocorrection (if any), then the rest
+# (unless autocorrections happened).
+#
+# source://rubocop//lib/rubocop/cop/team.rb#13
+class RuboCop::Cop::Team
+  # @return [Team] a new instance of Team
+  #
+  # source://rubocop//lib/rubocop/cop/team.rb#61
+  def initialize(cops, config = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/team.rb#72
+  def autocorrect?; end
+
+  # Returns the value of attribute cops.
+  #
+  # source://rubocop//lib/rubocop/cop/team.rb#57
+  def cops; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/team.rb#76
+  def debug?; end
+
+  # Returns the value of attribute errors.
+  #
+  # source://rubocop//lib/rubocop/cop/team.rb#57
+  def errors; end
+
+  # source://rubocop//lib/rubocop/cop/team.rb#128
+  def external_dependency_checksum; end
+
+  # @deprecated
+  #
+  # source://rubocop//lib/rubocop/cop/team.rb#120
+  def forces; end
+
+  # source://rubocop//lib/rubocop/cop/team.rb#82
+  def inspect_file(processed_source); end
+
+  # @return [Commissioner::InvestigationReport]
+  #
+  # source://rubocop//lib/rubocop/cop/team.rb#91
+  def investigate(processed_source, offset: T.unsafe(nil), original: T.unsafe(nil)); end
+
+  # Returns the value of attribute updated_source_file.
+  #
+  # source://rubocop//lib/rubocop/cop/team.rb#57
+  def updated_source_file; end
+
+  # Returns the value of attribute updated_source_file.
+  #
+  # source://rubocop//lib/rubocop/cop/team.rb#57
+  def updated_source_file?; end
+
+  # Returns the value of attribute warnings.
+  #
+  # source://rubocop//lib/rubocop/cop/team.rb#57
+  def warnings; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/team.rb#139
+  def autocorrect(processed_source, report, original:, offset:); end
+
+  # source://rubocop//lib/rubocop/cop/team.rb#203
+  def autocorrect_report(report, offset:, original:); end
+
+  # source://rubocop//lib/rubocop/cop/team.rb#158
+  def be_ready; end
+
+  # source://rubocop//lib/rubocop/cop/team.rb#209
+  def collate_corrections(report, offset:, original:); end
+
+  # source://rubocop//lib/rubocop/cop/team.rb#225
+  def each_corrector(report); end
+
+  # source://rubocop//lib/rubocop/cop/team.rb#277
+  def handle_error(error, location, cop); end
+
+  # source://rubocop//lib/rubocop/cop/team.rb#269
+  def handle_warning(error, location); end
+
+  # @return [Commissioner::InvestigationReport]
+  #
+  # source://rubocop//lib/rubocop/cop/team.rb#172
+  def investigate_partial(cops, processed_source, offset:, original:); end
+
+  # source://rubocop//lib/rubocop/cop/team.rb#252
+  def process_errors(file, errors); end
+
+  # source://rubocop//lib/rubocop/cop/team.rb#166
+  def reset; end
+
+  # @return [Array<cop>]
+  #
+  # source://rubocop//lib/rubocop/cop/team.rb#178
+  def roundup_relevant_cops(processed_source); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/team.rb#194
+  def support_target_rails_version?(cop); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/team.rb#188
+  def support_target_ruby_version?(cop); end
+
+  # source://rubocop//lib/rubocop/cop/team.rb#240
+  def suppress_clobbering; end
+
+  # source://rubocop//lib/rubocop/cop/team.rb#246
+  def validate_config; end
+
+  class << self
+    # @return [Array<Force>] needed for the given cops
+    #
+    # source://rubocop//lib/rubocop/cop/team.rb#43
+    def forces_for(cops); end
+
+    # @return [Team] with cops assembled from the given `cop_classes`
+    #
+    # source://rubocop//lib/rubocop/cop/team.rb#28
+    def mobilize(cop_classes, config, options = T.unsafe(nil)); end
+
+    # @return [Array<Cop::Base>]
+    #
+    # source://rubocop//lib/rubocop/cop/team.rb#34
+    def mobilize_cops(cop_classes, config, options = T.unsafe(nil)); end
+
+    # @return [Team]
+    #
+    # source://rubocop//lib/rubocop/cop/team.rb#15
+    def new(cop_or_classes, config, options = T.unsafe(nil)); end
+  end
+end
+
+# Common methods shared by TrailingBody cops
+#
+# source://rubocop//lib/rubocop/cop/mixin/trailing_body.rb#6
+module RuboCop::Cop::TrailingBody
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_body.rb#12
+  def body_on_first_line?(node, body); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_body.rb#16
+  def first_part_of(body); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_body.rb#7
+  def trailing_body?(node); end
+end
+
+# Common methods shared by Style/TrailingCommaInArguments and
+# Style/TrailingCommaInLiteral
+#
+# source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#7
+module RuboCop::Cop::TrailingComma
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+
+  private
+
+  # A single argument with the closing bracket on the same line as the end
+  # of the argument is not considered multiline, even if the argument
+  # itself might span multiple lines.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#104
+  def allowed_multiline_argument?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#167
+  def any_heredoc?(items); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#159
+  def autocorrect_range(item); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#133
+  def avoid_comma(kind, comma_begin_pos, extra_info); end
+
+  # Returns true if the node has round/square/curly brackets.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#82
+  def brackets?(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#19
+  def check(node, items, kind, begin_pos, end_pos); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#37
+  def check_comma(node, kind, comma_pos); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#43
+  def check_literal(node, kind); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#30
+  def comma_offset(items, range); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#108
+  def elements(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#54
+  def extra_avoid_comma_info; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#171
+  def heredoc?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#189
+  def heredoc_send?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#76
+  def inside_comment?(range, comma_offset); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#93
+  def method_name_and_arguments_on_same_line?(node); end
+
+  # Returns true if the round/square/curly brackets of the given node are
+  # on different lines, each item within is on its own line, and the
+  # closing bracket is on its own line.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#89
+  def multiline?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#123
+  def no_elements_on_same_line?(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#129
+  def on_same_line?(range1, range2); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#147
+  def put_comma(items, kind); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#65
+  def should_have_comma?(style, node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#15
+  def style_parameter_name; end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/trailing_comma.rb#11
+RuboCop::Cop::TrailingComma::MSG = T.let(T.unsafe(nil), String)
+
+# Common functionality shared by Uncommunicative cops
+#
+# source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#6
+module RuboCop::Cop::UncommunicativeName
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#12
+  def check(node, args); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#95
+  def allow_nums; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#87
+  def allowed_names; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#78
+  def arg_range(arg, length); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#45
+  def case_offense(node, range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#64
+  def ends_with_num?(name); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#91
+  def forbidden_names; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#83
+  def forbidden_offense(node, range, name); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#36
+  def issue_offenses(node, range, name); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#68
+  def length_offense(node, range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#74
+  def long_enough?(name); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#99
+  def min_length; end
+
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#53
+  def name_type(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#60
+  def num_offense(node, range); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#49
+  def uppercase?(name); end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#7
+RuboCop::Cop::UncommunicativeName::CASE_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#10
+RuboCop::Cop::UncommunicativeName::FORBIDDEN_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#9
+RuboCop::Cop::UncommunicativeName::LENGTH_MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/cop/mixin/uncommunicative_name.rb#8
+RuboCop::Cop::UncommunicativeName::NUM_MSG = T.let(T.unsafe(nil), String)
+
+# This autocorrects unused arguments.
+#
+# source://rubocop//lib/rubocop/cop/correctors/unused_arg_corrector.rb#6
+class RuboCop::Cop::UnusedArgCorrector
+  extend ::RuboCop::Cop::RangeHelp
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/correctors/unused_arg_corrector.rb#12
+    def correct(corrector, processed_source, node); end
+
+    # source://rubocop//lib/rubocop/cop/correctors/unused_arg_corrector.rb#31
+    def correct_for_blockarg_type(corrector, node); end
+
+    # Returns the value of attribute processed_source.
+    #
+    # source://rubocop//lib/rubocop/cop/correctors/unused_arg_corrector.rb#10
+    def processed_source; end
+  end
+end
+
+# This module contains a collection of useful utility methods.
+#
+# source://rubocop//lib/rubocop/cop/util.rb#7
+module RuboCop::Cop::Util
+  include ::RuboCop::PathUtil
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/util.rb#39
+  def add_parentheses(node, corrector); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#60
+  def any_descendant?(node, *types); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#75
+  def args_begin(node); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#87
+  def args_end(node); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#108
+  def begins_its_line?(range); end
+
+  # This is a bad API
+  #
+  # source://rubocop//lib/rubocop/cop/util.rb#17
+  def comment_line?(line_source); end
+
+  # @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar
+  #
+  # source://rubocop//lib/rubocop/cop/util.rb#22
+  def comment_lines?(node); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#198
+  def compatible_external_encoding_for?(src); end
+
+  # If converting a string to Ruby string literal source code, must
+  # double quotes be used?
+  #
+  # source://rubocop//lib/rubocop/cop/util.rb#134
+  def double_quotes_required?(string); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#148
+  def escape_string(string); end
+
+  # Returns, for example, a bare `if` node if the given node is an `if`
+  # with calls chained to the end of it.
+  #
+  # source://rubocop//lib/rubocop/cop/util.rb#118
+  def first_part_of_call_chain(node); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#203
+  def include_or_equal?(source, target); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#185
+  def indent(node, offset: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#165
+  def interpret_string_escapes(string); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#169
+  def line(node_or_range); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#30
+  def line_range(node); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#144
+  def needs_escaping?(string); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#91
+  def on_node(syms, sexp, excludes = T.unsafe(nil), &block); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#34
+  def parentheses?(node); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#177
+  def same_line?(node1, node2); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#152
+  def to_string_literal(string); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#191
+  def to_supported_styles(enforced_style); end
+
+  # source://rubocop//lib/rubocop/cop/util.rb#161
+  def trim_string_interpolation_escape_character(str); end
+
+  class << self
+    # source://rubocop//lib/rubocop/cop/util.rb#39
+    def add_parentheses(node, corrector); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/util.rb#60
+    def any_descendant?(node, *types); end
+
+    # source://rubocop//lib/rubocop/cop/util.rb#75
+    def args_begin(node); end
+
+    # source://rubocop//lib/rubocop/cop/util.rb#87
+    def args_end(node); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/util.rb#108
+    def begins_its_line?(range); end
+
+    # This is a bad API
+    #
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/util.rb#17
+    def comment_line?(line_source); end
+
+    # @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/util.rb#22
+    def comment_lines?(node); end
+
+    # If converting a string to Ruby string literal source code, must
+    # double quotes be used?
+    #
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/util.rb#134
+    def double_quotes_required?(string); end
+
+    # source://rubocop//lib/rubocop/cop/util.rb#148
+    def escape_string(string); end
+
+    # Returns, for example, a bare `if` node if the given node is an `if`
+    # with calls chained to the end of it.
+    #
+    # source://rubocop//lib/rubocop/cop/util.rb#118
+    def first_part_of_call_chain(node); end
+
+    # source://rubocop//lib/rubocop/cop/util.rb#185
+    def indent(node, offset: T.unsafe(nil)); end
+
+    # source://rubocop//lib/rubocop/cop/util.rb#165
+    def interpret_string_escapes(string); end
+
+    # source://rubocop//lib/rubocop/cop/util.rb#169
+    def line(node_or_range); end
+
+    # source://rubocop//lib/rubocop/cop/util.rb#30
+    def line_range(node); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/util.rb#144
+    def needs_escaping?(string); end
+
+    # @yield [sexp]
+    #
+    # source://rubocop//lib/rubocop/cop/util.rb#91
+    def on_node(syms, sexp, excludes = T.unsafe(nil), &block); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/util.rb#34
+    def parentheses?(node); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/cop/util.rb#177
+    def same_line?(node1, node2); end
+
+    # source://rubocop//lib/rubocop/cop/util.rb#152
+    def to_string_literal(string); end
+
+    # source://rubocop//lib/rubocop/cop/util.rb#191
+    def to_supported_styles(enforced_style); end
+
+    # source://rubocop//lib/rubocop/cop/util.rb#161
+    def trim_string_interpolation_escape_character(str); end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/util.rb#103
+RuboCop::Cop::Util::LINE_BEGINS_REGEX_CACHE = T.let(T.unsafe(nil), Hash)
+
+# Match literal regex characters, not including anchors, character
+# classes, alternatives, groups, repetitions, references, etc
+#
+# source://rubocop//lib/rubocop/cop/util.rb#12
+RuboCop::Cop::Util::LITERAL_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# Arbitrarily chosen value, should be enough to cover
+# the most nested source code in real world projects.
+#
+# source://rubocop//lib/rubocop/cop/util.rb#102
+RuboCop::Cop::Util::MAX_LINE_BEGINS_REGEX_INDEX = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop//lib/rubocop/cop/utils/format_string.rb#5
+module RuboCop::Cop::Utils; end
+
+# Parses {Kernel#sprintf} format strings.
+#
+# source://rubocop//lib/rubocop/cop/utils/format_string.rb#7
+class RuboCop::Cop::Utils::FormatString
+  # @return [FormatString] a new instance of FormatString
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#89
+  def initialize(string); end
+
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#93
+  def format_sequences; end
+
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#105
+  def max_digit_dollar_num; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#101
+  def named_interpolation?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#97
+  def valid?; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#117
+  def mixed_formats?; end
+
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#111
+  def parse; end
+end
+
+# source://rubocop//lib/rubocop/cop/utils/format_string.rb#8
+RuboCop::Cop::Utils::FormatString::DIGIT_DOLLAR = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/utils/format_string.rb#9
+RuboCop::Cop::Utils::FormatString::FLAG = T.let(T.unsafe(nil), Regexp)
+
+# The syntax of a format sequence is as follows.
+#
+# ```
+# %[flags][width][.precision]type
+# ```
+#
+# A format sequence consists of a percent sign, followed by optional
+# flags, width, and precision indicators, then terminated with a field
+# type character.
+#
+# For more complex formatting, Ruby supports a reference by name.
+#
+# @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format
+#
+# source://rubocop//lib/rubocop/cop/utils/format_string.rb#43
+class RuboCop::Cop::Utils::FormatString::FormatSequence
+  # @return [FormatSequence] a new instance of FormatSequence
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#46
+  def initialize(match); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#61
+  def annotated?; end
+
+  # Number of arguments required for the format sequence
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#70
+  def arity; end
+
+  # Returns the value of attribute begin_pos.
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#44
+  def begin_pos; end
+
+  # Returns the value of attribute end_pos.
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#44
+  def end_pos; end
+
+  # Returns the value of attribute flags.
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#44
+  def flags; end
+
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#74
+  def max_digit_dollar_num; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#44
+  def name; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#57
+  def percent?; end
+
+  # Returns the value of attribute precision.
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#44
+  def precision; end
+
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#78
+  def style; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#65
+  def template?; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#44
+  def type; end
+
+  # Returns the value of attribute width.
+  #
+  # source://rubocop//lib/rubocop/cop/utils/format_string.rb#44
+  def width; end
+end
+
+# source://rubocop//lib/rubocop/cop/utils/format_string.rb#15
+RuboCop::Cop::Utils::FormatString::NAME = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/utils/format_string.rb#11
+RuboCop::Cop::Utils::FormatString::NUMBER = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/utils/format_string.rb#10
+RuboCop::Cop::Utils::FormatString::NUMBER_ARG = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/utils/format_string.rb#13
+RuboCop::Cop::Utils::FormatString::PRECISION = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/utils/format_string.rb#18
+RuboCop::Cop::Utils::FormatString::SEQUENCE = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/utils/format_string.rb#16
+RuboCop::Cop::Utils::FormatString::TEMPLATE_NAME = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/utils/format_string.rb#14
+RuboCop::Cop::Utils::FormatString::TYPE = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/cop/utils/format_string.rb#12
+RuboCop::Cop::Utils::FormatString::WIDTH = T.let(T.unsafe(nil), Regexp)
+
+# Helper to abstract complexity of building range pairs
+# with octal escape reconstruction (needed for regexp_parser < 2.7).
+#
+# source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#8
+class RuboCop::Cop::Utils::RegexpRanges
+  # @return [RegexpRanges] a new instance of RegexpRanges
+  #
+  # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#11
+  def initialize(root); end
+
+  # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#18
+  def compound_token; end
+
+  # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#24
+  def pairs; end
+
+  # Returns the value of attribute root.
+  #
+  # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#9
+  def root; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#78
+  def compose_range(expressions, current); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#90
+  def escaped_octal?(expr); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#94
+  def octal_digit?(char); end
+
+  # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#98
+  def pop_octal_digits(expressions); end
+
+  # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#44
+  def populate(expr); end
+
+  # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#32
+  def populate_all; end
+
+  # source://rubocop//lib/rubocop/cop/utils/regexp_ranges.rb#63
+  def process_set(expressions, current); end
+end
+
+# This force provides a way to track local variables and scopes of Ruby.
+# Cops interact with this force need to override some of the hook methods.
+#
+#     def before_entering_scope(scope, variable_table)
+#     end
+#
+#     def after_entering_scope(scope, variable_table)
+#     end
+#
+#     def before_leaving_scope(scope, variable_table)
+#     end
+#
+#     def after_leaving_scope(scope, variable_table)
+#     end
+#
+#     def before_declaring_variable(variable, variable_table)
+#     end
+#
+#     def after_declaring_variable(variable, variable_table)
+#     end
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#27
+class RuboCop::Cop::VariableForce < ::RuboCop::Cop::Force
+  # Starting point.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#79
+  def investigate(processed_source); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#88
+  def process_node(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#74
+  def variable_table; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#380
+  def after_declaring_variable(arg); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#380
+  def after_entering_scope(arg); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#380
+  def after_leaving_scope(arg); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#380
+  def before_declaring_variable(arg); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#380
+  def before_entering_scope(arg); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#380
+  def before_leaving_scope(arg); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#351
+  def descendant_reference(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#341
+  def each_descendant_reference(loop_node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#326
+  def find_variables_in_loop(loop_node); end
+
+  # This is called for each scope recursively.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#97
+  def inspect_variables_in_scope(scope_node); end
+
+  # Mark all assignments which are referenced in the same loop
+  # as referenced by ignoring AST order since they would be referenced
+  # in next iteration.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#307
+  def mark_assignments_as_referenced_in_loop(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#130
+  def node_handler_method_name(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#103
+  def process_children(origin_node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#243
+  def process_loop(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#182
+  def process_pattern_match_variable(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#164
+  def process_regexp_named_captures(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#258
+  def process_rescue(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#277
+  def process_scope(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#296
+  def process_send(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#146
+  def process_variable_assignment(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#134
+  def process_variable_declaration(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#231
+  def process_variable_multiple_assignment(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#196
+  def process_variable_operator_assignment(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#238
+  def process_variable_referencing(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#269
+  def process_zero_arity_super(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#190
+  def regexp_captured_names(node); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#363
+  def scanned_node?(node); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#367
+  def scanned_nodes; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#111
+  def skip_children!; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#290
+  def twisted_nodes(node); end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#35
+RuboCop::Cop::VariableForce::ARGUMENT_DECLARATION_TYPES = T.let(T.unsafe(nil), Array)
+
+# This class represents each assignment of a variable.
+#
+# source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#7
+class RuboCop::Cop::VariableForce::Assignment
+  include ::RuboCop::Cop::VariableForce::Branchable
+
+  # @return [Assignment] a new instance of Assignment
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#16
+  def initialize(node, variable); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#50
+  def exception_assignment?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#72
+  def for_assignment?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#83
+  def meta_assignment_node; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#60
+  def multiple_assignment?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#29
+  def name; end
+
+  # Returns the value of attribute node.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#12
+  def node; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#78
+  def operator; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#54
+  def operator_assignment?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#37
+  def reference!(node); end
+
+  # Returns the value of attribute referenced.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#12
+  def referenced; end
+
+  # Returns the value of attribute referenced.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#12
+  def referenced?; end
+
+  # Returns the value of attribute references.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#12
+  def references; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#46
+  def regexp_named_capture?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#66
+  def rest_assignment?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#33
+  def scope; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#42
+  def used?; end
+
+  # Returns the value of attribute variable.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#12
+  def variable; end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#125
+  def find_multiple_assignment_node(grandparent_node); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#121
+  def for_assignment_node; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#104
+  def multiple_assignment_node; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#96
+  def operator_assignment_node; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#114
+  def rest_assignment_node; end
+end
+
+# source://rubocop//lib/rubocop/cop/variable_force/assignment.rb#10
+RuboCop::Cop::VariableForce::Assignment::MULTIPLE_LEFT_HAND_SIDE_TYPE = T.let(T.unsafe(nil), Symbol)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#68
+class RuboCop::Cop::VariableForce::AssignmentReference < ::Struct
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#69
+  def assignment?; end
+
+  # Returns the value of attribute node
+  #
+  # @return [Object] the current value of node
+  def node; end
+
+  # Sets the attribute node
+  #
+  # @param value [Object] the value to set the attribute node to.
+  # @return [Object] the newly set value
+  def node=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# Namespace for branch classes for each control structure.
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#7
+module RuboCop::Cop::VariableForce::Branch
+  class << self
+    # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#8
+    def of(target_node, scope: T.unsafe(nil)); end
+  end
+end
+
+# left_body && right_body
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#265
+class RuboCop::Cop::VariableForce::Branch::And < ::RuboCop::Cop::VariableForce::Branch::Base
+  include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def left_body?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def right_body?; end
+end
+
+# Abstract base class for branch classes.
+# A branch represents a conditional branch in a scope.
+#
+# @example
+#   def some_scope
+#   do_something     # no branch
+#
+#   if foo
+#   do_something   # branch A
+#   do_something   # branch A
+#   else
+#   do_something   # branch B
+#   if bar
+#   do_something # branch C (whose parent is branch B)
+#   end
+#   end
+#
+#   do_something     # no branch
+#   end
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#42
+class RuboCop::Cop::VariableForce::Branch::Base < ::Struct
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#121
+  def ==(other); end
+
+  # @raise [NotImplementedError]
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#92
+  def always_run?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#88
+  def branched?; end
+
+  # Returns the value of attribute child_node
+  #
+  # @return [Object] the current value of child_node
+  def child_node; end
+
+  # Sets the attribute child_node
+  #
+  # @param value [Object] the value to set the attribute child_node to.
+  # @return [Object] the newly set value
+  def child_node=(_); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#70
+  def control_node; end
+
+  # @yield [_self]
+  # @yieldparam _self [RuboCop::Cop::VariableForce::Branch::Base] the object that the method was called on
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#80
+  def each_ancestor(include_self: T.unsafe(nil), &block); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#121
+  def eql?(other); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#104
+  def exclusive_with?(other); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#129
+  def hash; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#96
+  def may_jump_to_other_branch?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#100
+  def may_run_incompletely?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#74
+  def parent; end
+
+  # Returns the value of attribute scope
+  #
+  # @return [Object] the current value of scope
+  def scope; end
+
+  # Sets the attribute scope
+  #
+  # @param value [Object] the value to set the attribute scope to.
+  # @return [Object] the newly set value
+  def scope=(_); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#135
+  def scan_ancestors; end
+
+  class << self
+    def [](*_arg0); end
+
+    # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#43
+    def classes; end
+
+    # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#56
+    def define_predicate(name, child_index: T.unsafe(nil)); end
+
+    # @private
+    #
+    # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#47
+    def inherited(subclass); end
+
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+
+    # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#52
+    def type; end
+  end
+end
+
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#325
+RuboCop::Cop::VariableForce::Branch::CLASSES_BY_TYPE = T.let(T.unsafe(nil), Hash)
+
+# case target
+# when /pattern/ # when_clause
+# else
+#   else_body
+# end
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#219
+class RuboCop::Cop::VariableForce::Branch::Case < ::RuboCop::Cop::VariableForce::Branch::Base
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#224
+  def always_run?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def else_body?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def target?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def when_clause?; end
+end
+
+# case target
+# in pattern # in_pattern
+# else
+#   else_body
+# end
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#234
+class RuboCop::Cop::VariableForce::Branch::CaseMatch < ::RuboCop::Cop::VariableForce::Branch::Base
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#239
+  def always_run?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def else_body?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def in_pattern?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def target?; end
+end
+
+# begin
+#     main_body
+#   ensure
+#     ensure_body
+#   end
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#314
+class RuboCop::Cop::VariableForce::Branch::Ensure < ::RuboCop::Cop::VariableForce::Branch::Base
+  include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#320
+  def always_run?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def ensure_body?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def main_body?; end
+end
+
+# Mix-in module for exception handling control structures.
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#281
+module RuboCop::Cop::VariableForce::Branch::ExceptionHandler
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#282
+  def may_jump_to_other_branch?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#286
+  def may_run_incompletely?; end
+end
+
+# for element in collection
+#   loop_body
+# end
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#247
+class RuboCop::Cop::VariableForce::Branch::For < ::RuboCop::Cop::VariableForce::Branch::Base
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#252
+  def always_run?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def collection?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def element?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def loop_body?; end
+end
+
+# if conditional_clause
+#   truthy_body
+# else
+#   falsey_body
+# end
+#
+# unless conditional_clause
+#   falsey_body
+# else
+#   truthy_body
+# end
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#166
+class RuboCop::Cop::VariableForce::Branch::If < ::RuboCop::Cop::VariableForce::Branch::Base
+  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def conditional_clause?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def falsey_body?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def truthy_body?; end
+end
+
+# Mix-in module for logical operator control structures.
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#258
+module RuboCop::Cop::VariableForce::Branch::LogicalOperator
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#259
+  def always_run?; end
+end
+
+# left_body || right_body
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#273
+class RuboCop::Cop::VariableForce::Branch::Or < ::RuboCop::Cop::VariableForce::Branch::Base
+  include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def left_body?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def right_body?; end
+end
+
+# begin
+#     main_body
+#   rescue StandardError => error # rescue_clause
+#   else
+#     else_body
+#   end
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#297
+class RuboCop::Cop::VariableForce::Branch::Rescue < ::RuboCop::Cop::VariableForce::Branch::Base
+  include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#304
+  def always_run?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def else_body?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def main_body?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def rescue_clause?; end
+end
+
+# Mix-in module for simple conditional control structures.
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#145
+module RuboCop::Cop::VariableForce::Branch::SimpleConditional
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#150
+  def always_run?; end
+
+  # @raise [NotImplementedError]
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#146
+  def conditional_clause?; end
+end
+
+# until conditional_clause
+#   loop_body
+# end
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#187
+class RuboCop::Cop::VariableForce::Branch::Until < ::RuboCop::Cop::VariableForce::Branch::Base
+  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def conditional_clause?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def loop_body?; end
+end
+
+# begin
+#   loop_body
+# end until conditional_clause
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#207
+class RuboCop::Cop::VariableForce::Branch::UntilPost < ::RuboCop::Cop::VariableForce::Branch::Base
+  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def conditional_clause?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def loop_body?; end
+end
+
+# while conditional_clause
+#   loop_body
+# end
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#177
+class RuboCop::Cop::VariableForce::Branch::While < ::RuboCop::Cop::VariableForce::Branch::Base
+  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def conditional_clause?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def loop_body?; end
+end
+
+# begin
+#   loop_body
+# end while conditional_clause
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branch.rb#197
+class RuboCop::Cop::VariableForce::Branch::WhilePost < ::RuboCop::Cop::VariableForce::Branch::Base
+  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def conditional_clause?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/branch.rb#57
+  def loop_body?; end
+end
+
+# Mix-in module for classes which own a node and need branch information
+# of the node. The user classes must implement #node and #scope.
+#
+# source://rubocop//lib/rubocop/cop/variable_force/branchable.rb#8
+module RuboCop::Cop::VariableForce::Branchable
+  # source://rubocop//lib/rubocop/cop/variable_force/branchable.rb#9
+  def branch; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/branchable.rb#15
+  def run_exclusively_with?(other); end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#42
+RuboCop::Cop::VariableForce::LOGICAL_OPERATOR_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#51
+RuboCop::Cop::VariableForce::LOOP_TYPES = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#45
+RuboCop::Cop::VariableForce::MULTIPLE_ASSIGNMENT_TYPE = T.let(T.unsafe(nil), Symbol)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#115
+RuboCop::Cop::VariableForce::NODE_HANDLER_METHOD_NAMES = T.let(T.unsafe(nil), Hash)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#43
+RuboCop::Cop::VariableForce::OPERATOR_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#30
+RuboCop::Cop::VariableForce::PATTERN_MATCH_VARIABLE_TYPE = T.let(T.unsafe(nil), Symbol)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#50
+RuboCop::Cop::VariableForce::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#29
+RuboCop::Cop::VariableForce::REGEXP_NAMED_CAPTURE_TYPE = T.let(T.unsafe(nil), Symbol)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#53
+RuboCop::Cop::VariableForce::RESCUE_TYPE = T.let(T.unsafe(nil), Symbol)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#46
+RuboCop::Cop::VariableForce::REST_ASSIGNMENT_TYPE = T.let(T.unsafe(nil), Symbol)
+
+# This class represents each reference of a variable.
+#
+# source://rubocop//lib/rubocop/cop/variable_force/reference.rb#7
+class RuboCop::Cop::VariableForce::Reference
+  include ::RuboCop::Cop::VariableForce::Branchable
+
+  # @return [Reference] a new instance of Reference
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/reference.rb#16
+  def initialize(node, scope); end
+
+  # There's an implicit variable reference by the zero-arity `super`:
+  #
+  #     def some_method(foo)
+  #       super
+  #     end
+  #
+  # Another case is `binding`:
+  #
+  #     def some_method(foo)
+  #       do_something(binding)
+  #     end
+  #
+  # In these cases, the variable `foo` is not explicitly referenced,
+  # but it can be considered used implicitly by the `super` or `binding`.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/reference.rb#41
+  def explicit?; end
+
+  # Returns the value of attribute node.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/reference.rb#14
+  def node; end
+
+  # Returns the value of attribute scope.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/reference.rb#14
+  def scope; end
+end
+
+# source://rubocop//lib/rubocop/cop/variable_force/reference.rb#10
+RuboCop::Cop::VariableForce::Reference::VARIABLE_REFERENCE_TYPES = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#58
+RuboCop::Cop::VariableForce::SCOPE_TYPES = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#60
+RuboCop::Cop::VariableForce::SEND_TYPE = T.let(T.unsafe(nil), Symbol)
+
+# A Scope represents a context of local variable visibility.
+# This is a place where local variables belong to.
+# A scope instance holds a scope node and variable entries.
+#
+# source://rubocop//lib/rubocop/cop/variable_force/scope.rb#9
+class RuboCop::Cop::VariableForce::Scope
+  # @return [Scope] a new instance of Scope
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#22
+  def initialize(node); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#35
+  def ==(other); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#43
+  def body_node; end
+
+  # @yield [node]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#61
+  def each_node(&block); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#57
+  def include?(target_node); end
+
+  # Returns the value of attribute naked_top_level.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#18
+  def naked_top_level; end
+
+  # Returns the value of attribute naked_top_level.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#18
+  def naked_top_level?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#39
+  def name; end
+
+  # Returns the value of attribute node.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#18
+  def node; end
+
+  # Returns the value of attribute variables.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#18
+  def variables; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#100
+  def ancestor_node?(target_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#90
+  def belong_to_inner_scope?(target_node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#79
+  def belong_to_outer_scope?(target_node); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/scope.rb#70
+  def scan_node(node, &block); end
+end
+
+# source://rubocop//lib/rubocop/cop/variable_force/scope.rb#10
+RuboCop::Cop::VariableForce::Scope::OUTER_SCOPE_CHILD_INDICES = T.let(T.unsafe(nil), Hash)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#57
+RuboCop::Cop::VariableForce::TWISTED_SCOPE_TYPES = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#28
+RuboCop::Cop::VariableForce::VARIABLE_ASSIGNMENT_TYPE = T.let(T.unsafe(nil), Symbol)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#31
+RuboCop::Cop::VariableForce::VARIABLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#48
+RuboCop::Cop::VariableForce::VARIABLE_REFERENCE_TYPE = T.let(T.unsafe(nil), Symbol)
+
+# A Variable represents existence of a local variable.
+# This holds a variable declaration node and some states of the variable.
+#
+# source://rubocop//lib/rubocop/cop/variable_force/variable.rb#8
+class RuboCop::Cop::VariableForce::Variable
+  # @return [Variable] a new instance of Variable
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#15
+  def initialize(name, declaration_node, scope); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#94
+  def argument?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#31
+  def assign(node); end
+
+  # Returns the value of attribute assignments.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#11
+  def assignments; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#102
+  def block_argument?; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#74
+  def capture_with_block!; end
+
+  # Returns the value of attribute captured_by_block.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#11
+  def captured_by_block; end
+
+  # Returns the value of attribute captured_by_block.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#11
+  def captured_by_block?; end
+
+  # Returns the value of attribute declaration_node.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#11
+  def declaration_node; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#110
+  def explicit_block_local_variable?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#66
+  def in_modifier_conditional?(assignment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#106
+  def keyword_argument?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#98
+  def method_argument?; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#11
+  def name; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#40
+  def reference!(node); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#35
+  def referenced?; end
+
+  # Returns the value of attribute references.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#11
+  def references; end
+
+  # Returns the value of attribute scope.
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#11
+  def scope; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#90
+  def should_be_unused?; end
+
+  # This is a convenient way to check whether the variable is used
+  # in its entire variable lifetime.
+  # For more precise usage check, refer Assignment#used?.
+  #
+  # Once the variable is captured by a block, we have no idea
+  # when, where, and how many times the block would be invoked.
+  # This means we cannot track the usage of the variable.
+  # So we consider it's used to suppress false positive offenses.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable.rb#86
+  def used?; end
+end
+
+# source://rubocop//lib/rubocop/cop/variable_force/variable.rb#9
+RuboCop::Cop::VariableForce::Variable::VARIABLE_DECLARATION_TYPES = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#62
+class RuboCop::Cop::VariableForce::VariableReference < ::Struct
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force.rb#63
+  def assignment?; end
+
+  # Returns the value of attribute name
+  #
+  # @return [Object] the current value of name
+  def name; end
+
+  # Sets the attribute name
+  #
+  # @param value [Object] the value to set the attribute name to.
+  # @return [Object] the newly set value
+  def name=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# A VariableTable manages the lifetime of all scopes and local variables
+# in a program.
+# This holds scopes as stack structure, provides a way to add local
+# variables to current scope, and find local variables by considering
+# variable visibility of the current scope.
+#
+# source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#11
+class RuboCop::Cop::VariableForce::VariableTable
+  # @return [VariableTable] a new instance of VariableTable
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#12
+  def initialize(hook_receiver = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#113
+  def accessible_variables; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#56
+  def assign_to_variable(name, node); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#40
+  def current_scope; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#44
+  def current_scope_level; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#48
+  def declare_variable(name, node); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#94
+  def find_variable(name); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#16
+  def invoke_hook(hook_name, *args); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#32
+  def pop_scope; end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#24
+  def push_scope(scope_node); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#68
+  def reference_variable(name, node); end
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#20
+  def scope_stack; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#109
+  def variable_exist?(name); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/variable_force/variable_table.rb#122
+  def mark_variable_as_captured_by_block_if_so(variable); end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/cop/variable_force.rb#55
+RuboCop::Cop::VariableForce::ZERO_ARITY_SUPER_TYPE = T.let(T.unsafe(nil), Symbol)
+
+# Help methods for determining node visibility.
+#
+# source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#8
+module RuboCop::Cop::VisibilityHelp
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#57
+  def visibility_block?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#62
+  def visibility_inline_on_def?(param0 = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#67
+  def visibility_inline_on_method_name?(param0 = T.unsafe(nil), method_name:); end
+
+  private
+
+  # Navigate to find the last protected method
+  #
+  # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#48
+  def find_visibility_end(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#43
+  def find_visibility_start(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#15
+  def node_visibility(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#39
+  def node_visibility_from_visibility_block(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#21
+  def node_visibility_from_visibility_inline(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#28
+  def node_visibility_from_visibility_inline_on_def(node); end
+
+  # source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#33
+  def node_visibility_from_visibility_inline_on_method_name(node); end
+end
+
+# source://rubocop//lib/rubocop/cop/mixin/visibility_help.rb#11
+RuboCop::Cop::VisibilityHelp::VISIBILITY_SCOPES = T.let(T.unsafe(nil), Set)
+
+# This class wraps the `Parser::Source::Comment` object that represents a
+# cops it contains.
+#
+# source://rubocop//lib/rubocop/directive_comment.rb#7
+class RuboCop::DirectiveComment
+  # @return [DirectiveComment] a new instance of DirectiveComment
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#32
+  def initialize(comment, cop_registry = T.unsafe(nil)); end
+
+  # Checks if all cops specified in this directive
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#82
+  def all_cops?; end
+
+  # Returns the value of attribute comment.
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#30
+  def comment; end
+
+  # Returns array of specified in this directive cop names
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#87
+  def cop_names; end
+
+  # Returns the value of attribute cop_registry.
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#30
+  def cop_registry; end
+
+  # Returns the value of attribute cops.
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#30
+  def cops; end
+
+  # Returns array of specified in this directive department names
+  # when all department disabled
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#93
+  def department_names; end
+
+  # source://rubocop//lib/rubocop/directive_comment.rb#107
+  def directive_count; end
+
+  # Checks if this directive disables cops
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#62
+  def disabled?; end
+
+  # Checks if this directive disables all cops
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#77
+  def disabled_all?; end
+
+  # Checks if this directive enables cops
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#67
+  def enabled?; end
+
+  # Checks if this directive enables all cops
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#72
+  def enabled_all?; end
+
+  # Checks if directive departments include cop
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#98
+  def in_directive_department?(cop); end
+
+  # Returns line number for directive
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#112
+  def line_number; end
+
+  # Checks if this directive contains all the given cop names
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#44
+  def match?(cop_names); end
+
+  # Returns match captures to directive comment pattern
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#57
+  def match_captures; end
+
+  # Returns the value of attribute mode.
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#30
+  def mode; end
+
+  # Checks if cop department has already used in directive comment
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#103
+  def overridden_by_department?(cop); end
+
+  # source://rubocop//lib/rubocop/directive_comment.rb#48
+  def range; end
+
+  # Checks if this directive relates to single line
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#39
+  def single_line?; end
+
+  private
+
+  # source://rubocop//lib/rubocop/directive_comment.rb#133
+  def all_cop_names; end
+
+  # source://rubocop//lib/rubocop/directive_comment.rb#137
+  def cop_names_for_department(department); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/directive_comment.rb#129
+  def department?(name); end
+
+  # source://rubocop//lib/rubocop/directive_comment.rb#142
+  def exclude_lint_department_cops(cops); end
+
+  # source://rubocop//lib/rubocop/directive_comment.rb#122
+  def parsed_cop_names; end
+
+  # source://rubocop//lib/rubocop/directive_comment.rb#118
+  def splitted_cops_string; end
+
+  class << self
+    # source://rubocop//lib/rubocop/directive_comment.rb#26
+    def before_comment(line); end
+  end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/directive_comment.rb#19
+RuboCop::DirectiveComment::COPS_PATTERN = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/directive_comment.rb#17
+RuboCop::DirectiveComment::COP_NAMES_PATTERN = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/directive_comment.rb#15
+RuboCop::DirectiveComment::COP_NAME_PATTERN = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/directive_comment.rb#21
+RuboCop::DirectiveComment::DIRECTIVE_COMMENT_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/directive_comment.rb#9
+RuboCop::DirectiveComment::LINT_DEPARTMENT = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/directive_comment.rb#11
+RuboCop::DirectiveComment::LINT_REDUNDANT_DIRECTIVE_COP = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/directive_comment.rb#13
+RuboCop::DirectiveComment::LINT_SYNTAX_COP = T.let(T.unsafe(nil), String)
+
+# An Error exception is different from an Offense with severity 'error'
+# When this exception is raised, it means that RuboCop is unable to perform
+# a requested action (probably due to misconfiguration) and must stop
+# immediately, rather than carrying on
+#
+# source://rubocop//lib/rubocop/error.rb#8
+class RuboCop::Error < ::StandardError; end
+
+# A wrapper to display errored location of analyzed file.
+#
+# source://rubocop//lib/rubocop/error.rb#13
+class RuboCop::ErrorWithAnalyzedFileLocation < ::RuboCop::Error
+  # @return [ErrorWithAnalyzedFileLocation] a new instance of ErrorWithAnalyzedFileLocation
+  #
+  # source://rubocop//lib/rubocop/error.rb#14
+  def initialize(cause:, node:, cop:); end
+
+  # Returns the value of attribute cause.
+  #
+  # source://rubocop//lib/rubocop/error.rb#21
+  def cause; end
+
+  # source://rubocop//lib/rubocop/error.rb#27
+  def column; end
+
+  # Returns the value of attribute cop.
+  #
+  # source://rubocop//lib/rubocop/error.rb#21
+  def cop; end
+
+  # source://rubocop//lib/rubocop/error.rb#23
+  def line; end
+
+  # source://rubocop//lib/rubocop/error.rb#31
+  def message; end
+end
+
+# Allows specified configuration options to have an exclude limit
+# ie. a maximum value tracked that it can be used by `--auto-gen-config`.
+#
+# source://rubocop//lib/rubocop/cop/exclude_limit.rb#6
+module RuboCop::ExcludeLimit
+  # Sets up a configuration option to have an exclude limit tracked.
+  # The parameter name given is transformed into a method name (eg. `Max`
+  # becomes `self.max=` and `MinDigits` becomes `self.min_digits=`).
+  #
+  # source://rubocop//lib/rubocop/cop/exclude_limit.rb#10
+  def exclude_limit(parameter_name, method_name: T.unsafe(nil)); end
+
+  private
+
+  # source://rubocop//lib/rubocop/cop/exclude_limit.rb#22
+  def transform(parameter_name); end
+end
+
+# source://rubocop//lib/rubocop/ext/comment.rb#4
+module RuboCop::Ext; end
+
+# Extensions to `Parser::Source::Comment`.
+#
+# source://rubocop//lib/rubocop/ext/comment.rb#6
+module RuboCop::Ext::Comment
+  # source://rubocop//lib/rubocop/ext/comment.rb#7
+  def source; end
+
+  # source://rubocop//lib/rubocop/ext/comment.rb#11
+  def source_range; end
+end
+
+# Extensions to AST::ProcessedSource for our cached comment_config
+#
+# source://rubocop//lib/rubocop/ext/processed_source.rb#6
+module RuboCop::Ext::ProcessedSource
+  # source://rubocop//lib/rubocop/ext/processed_source.rb#9
+  def comment_config; end
+
+  # Returns the value of attribute config.
+  #
+  # source://rubocop//lib/rubocop/ext/processed_source.rb#7
+  def config; end
+
+  # Sets the attribute config
+  #
+  # @param value the value to set the attribute config to.
+  #
+  # source://rubocop//lib/rubocop/ext/processed_source.rb#7
+  def config=(_arg0); end
+
+  # source://rubocop//lib/rubocop/ext/processed_source.rb#13
+  def disabled_line_ranges; end
+
+  # Returns the value of attribute registry.
+  #
+  # source://rubocop//lib/rubocop/ext/processed_source.rb#7
+  def registry; end
+
+  # Sets the attribute registry
+  #
+  # @param value the value to set the attribute registry to.
+  #
+  # source://rubocop//lib/rubocop/ext/processed_source.rb#7
+  def registry=(_arg0); end
+end
+
+# Extensions to Parser::Source::Range
+#
+# source://rubocop//lib/rubocop/ext/range.rb#6
+module RuboCop::Ext::Range
+  # Adds `Range#single_line?` to parallel `Node#single_line?`
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/ext/range.rb#8
+  def single_line?; end
+end
+
+# Extensions to AST::RegexpNode for our cached parsed regexp info
+#
+# source://rubocop//lib/rubocop/ext/regexp_node.rb#6
+module RuboCop::Ext::RegexpNode
+  # source://rubocop//lib/rubocop/ext/regexp_node.rb#18
+  def assign_properties(*_arg0); end
+
+  # source://rubocop//lib/rubocop/ext/regexp_node.rb#31
+  def each_capture(named: T.unsafe(nil)); end
+
+  # Note: we extend Regexp nodes to provide `loc` and `expression`
+  # see `ext/regexp_parser`.
+  #
+  # @return [Regexp::Expression::Root, nil]
+  #
+  # source://rubocop//lib/rubocop/ext/regexp_node.rb#16
+  def parsed_tree; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/ext/regexp_node.rb#43
+  def named_capturing?(exp, event, named); end
+
+  # source://rubocop//lib/rubocop/ext/regexp_node.rb#51
+  def with_interpolations_blanked; end
+end
+
+# source://rubocop//lib/rubocop/ext/regexp_node.rb#7
+RuboCop::Ext::RegexpNode::ANY = T.let(T.unsafe(nil), Object)
+
+# Extensions for `regexp_parser` gem
+#
+# source://rubocop//lib/rubocop/ext/regexp_parser.rb#6
+module RuboCop::Ext::RegexpParser; end
+
+# source://rubocop//lib/rubocop/ext/regexp_parser.rb#20
+module RuboCop::Ext::RegexpParser::Expression; end
+
+# Add `expression` and `loc` to all `regexp_parser` nodes
+#
+# source://rubocop//lib/rubocop/ext/regexp_parser.rb#22
+module RuboCop::Ext::RegexpParser::Expression::Base
+  # Shortcut to `loc.expression`
+  #
+  # source://rubocop//lib/rubocop/ext/regexp_parser.rb#26
+  def expression; end
+
+  # E.g.
+  #     [a-z]{2,}
+  #     ^^^^^^^^^ expression
+  #          ^^^^ quantifier
+  #     ^^^^^     body
+  #     ^         begin
+  #         ^     end
+  #
+  # Please open issue if you need other locations
+  #
+  # source://rubocop//lib/rubocop/ext/regexp_parser.rb#44
+  def loc; end
+
+  # Returns the value of attribute origin.
+  #
+  # source://rubocop//lib/rubocop/ext/regexp_parser.rb#23
+  def origin; end
+
+  # Sets the attribute origin
+  #
+  # @param value the value to set the attribute origin to.
+  #
+  # source://rubocop//lib/rubocop/ext/regexp_parser.rb#23
+  def origin=(_arg0); end
+
+  private
+
+  # source://rubocop//lib/rubocop/ext/regexp_parser.rb#50
+  def build_location; end
+end
+
+# Provide `CharacterSet` with `begin` and `end` locations.
+#
+# source://rubocop//lib/rubocop/ext/regexp_parser.rb#62
+module RuboCop::Ext::RegexpParser::Expression::CharacterSet
+  # source://rubocop//lib/rubocop/ext/regexp_parser.rb#63
+  def build_location; end
+end
+
+# Source map for RegexpParser nodes
+#
+# source://rubocop//lib/rubocop/ext/regexp_parser.rb#8
+class RuboCop::Ext::RegexpParser::Map < ::Parser::Source::Map
+  # @return [Map] a new instance of Map
+  #
+  # source://rubocop//lib/rubocop/ext/regexp_parser.rb#11
+  def initialize(expression, body:, quantifier: T.unsafe(nil), begin_l: T.unsafe(nil), end_l: T.unsafe(nil)); end
+
+  # Returns the value of attribute begin.
+  #
+  # source://rubocop//lib/rubocop/ext/regexp_parser.rb#9
+  def begin; end
+
+  # Returns the value of attribute body.
+  #
+  # source://rubocop//lib/rubocop/ext/regexp_parser.rb#9
+  def body; end
+
+  # Returns the value of attribute end.
+  #
+  # source://rubocop//lib/rubocop/ext/regexp_parser.rb#9
+  def end; end
+
+  # Returns the value of attribute quantifier.
+  #
+  # source://rubocop//lib/rubocop/ext/regexp_parser.rb#9
+  def quantifier; end
+end
+
+# This class handles loading files (a.k.a. features in Ruby) specified
+# by `--require` command line option and `require` directive in the config.
+#
+# Normally, the given string is directly passed to `require`. If a string
+# beginning with `.` is given, it is assumed to be relative to the given
+# directory.
+#
+# If a string containing `-` is given, it will be used as is, but if we
+# cannot find the file to load, we will replace `-` with `/` and try it
+# again as when Bundler loads gems.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/feature_loader.rb#16
+class RuboCop::FeatureLoader
+  # @api private
+  # @param config_directory_path [String]
+  # @param feature [String]
+  # @return [FeatureLoader] a new instance of FeatureLoader
+  #
+  # source://rubocop//lib/rubocop/feature_loader.rb#27
+  def initialize(config_directory_path:, feature:); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/feature_loader.rb#32
+  def load; end
+
+  private
+
+  # @api private
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/feature_loader.rb#55
+  def namespaced_feature; end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/feature_loader.rb#60
+  def namespaced_target; end
+
+  # @api private
+  # @param [String]
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/feature_loader.rb#70
+  def relative(feature); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/feature_loader.rb#75
+  def relative?; end
+
+  # @api private
+  # @param error [LoadError]
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/feature_loader.rb#81
+  def seems_cannot_load_such_file_error?(error); end
+
+  # @api private
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/feature_loader.rb#86
+  def target; end
+
+  class << self
+    # @api private
+    # @param config_directory_path [String]
+    # @param feature [String]
+    #
+    # source://rubocop//lib/rubocop/feature_loader.rb#20
+    def load(config_directory_path:, feature:); end
+  end
+end
+
+# Common methods for finding files.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/file_finder.rb#8
+module RuboCop::FileFinder
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/file_finder.rb#13
+  def find_file_upwards(filename, start_dir, stop_dir = T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/file_finder.rb#20
+  def find_last_file_upwards(filename, start_dir, stop_dir = T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/file_finder.rb#26
+  def traverse_directories_upwards(start_dir, stop_dir = T.unsafe(nil)); end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/file_finder.rb#36
+  def traverse_files_upwards(filename, start_dir, stop_dir); end
+
+  class << self
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/file_finder.rb#10
+    def root_level; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/file_finder.rb#10
+    def root_level=(_arg0); end
+  end
+end
+
+# A wrapper around patterns array to perform optimized search.
+#
+# For projects with a large set of rubocop todo files, most items in `Exclude`/`Include`
+# are exact file names. It is wasteful to linearly check the list of patterns over and over
+# to check if the file is relevant to the cop.
+#
+# This class partitions an array of patterns into a set of exact match strings and the rest
+# of the patterns. This way we can firstly do a cheap check in the set and then proceed via
+# the costly patterns check, if needed.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/file_patterns.rb#14
+class RuboCop::FilePatterns
+  # @api private
+  # @return [FilePatterns] a new instance of FilePatterns
+  #
+  # source://rubocop//lib/rubocop/file_patterns.rb#21
+  def initialize(patterns); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/file_patterns.rb#27
+  def match?(path); end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/file_patterns.rb#33
+  def partition_patterns(patterns); end
+
+  class << self
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/file_patterns.rb#17
+    def from(patterns); end
+  end
+end
+
+# The bootstrap module for formatter.
+#
+# source://rubocop//lib/rubocop/formatter.rb#5
+module RuboCop::Formatter; end
+
+# Does not show individual offenses in the console.
+#
+# source://rubocop//lib/rubocop/formatter/auto_gen_config_formatter.rb#6
+class RuboCop::Formatter::AutoGenConfigFormatter < ::RuboCop::Formatter::ProgressFormatter
+  # source://rubocop//lib/rubocop/formatter/auto_gen_config_formatter.rb#7
+  def finished(inspected_files); end
+end
+
+# Abstract base class for formatter, implements all public API methods.
+#
+# ## Creating Custom Formatter
+#
+# You can create a custom formatter by subclassing
+# `RuboCop::Formatter::BaseFormatter` and overriding some methods
+# or by implementing all the methods by duck typing.
+#
+# ## Using Custom Formatter in Command Line
+#
+# You can tell RuboCop to use your custom formatter with a combination of
+# `--format` and `--require` option.
+# For example, when you have defined `MyCustomFormatter` in
+# `./path/to/my_custom_formatter.rb`, you would type this command:
+#
+#     rubocop --require ./path/to/my_custom_formatter --format MyCustomFormatter
+#
+# Note: The path passed to `--require` is directly passed to
+# `Kernel.require`.
+# If your custom formatter file is not in `$LOAD_PATH`,
+# you need to specify the path as relative path prefixed with `./`
+# explicitly or absolute path.
+#
+# ## Method Invocation Order
+#
+# For example, when RuboCop inspects 2 files,
+# the invocation order should be like this:
+#
+# * `#initialize`
+# * `#started`
+# * `#file_started`
+# * `#file_finished`
+# * `#file_started`
+# * `#file_finished`
+# * `#finished`
+#
+# source://rubocop//lib/rubocop/formatter/base_formatter.rb#41
+class RuboCop::Formatter::BaseFormatter
+  # @api public
+  # @param output [IO] `$stdout` or opened file
+  # @return [BaseFormatter] a new instance of BaseFormatter
+  #
+  # source://rubocop//lib/rubocop/formatter/base_formatter.rb#63
+  def initialize(output, options = T.unsafe(nil)); end
+
+  # Invoked at the end of inspecting each files.
+  #
+  # @api public
+  # @param file [String] the file path
+  # @param offenses [Array(RuboCop::Cop::Offense)] all detected offenses for the file
+  # @return [void]
+  # @see RuboCop::Cop::Offense
+  #
+  # source://rubocop//lib/rubocop/formatter/base_formatter.rb#104
+  def file_finished(file, offenses); end
+
+  # Invoked at the beginning of inspecting each files.
+  #
+  # @api public
+  # @param file [String] the file path
+  # @param options [Hash] file specific information, currently this is always empty.
+  # @return [void]
+  #
+  # source://rubocop//lib/rubocop/formatter/base_formatter.rb#89
+  def file_started(file, options); end
+
+  # Invoked after all files are inspected or interrupted by user.
+  #
+  # @api public
+  # @param inspected_files [Array(String)] the inspected file paths.
+  #   This would be same as `target_files` passed to `#started`
+  #   unless RuboCop is interrupted by user.
+  # @return [void]
+  #
+  # source://rubocop//lib/rubocop/formatter/base_formatter.rb#116
+  def finished(inspected_files); end
+
+  # @api public
+  # @return [Hash]
+  #
+  # source://rubocop//lib/rubocop/formatter/base_formatter.rb#57
+  def options; end
+
+  # @api public
+  # @return [IO] the IO object passed to `#initialize`
+  # @see #initialize
+  #
+  # source://rubocop//lib/rubocop/formatter/base_formatter.rb#50
+  def output; end
+
+  # Invoked once before any files are inspected.
+  #
+  # @api public
+  # @param target_files [Array(String)] all target file paths to be inspected
+  # @return [void]
+  #
+  # source://rubocop//lib/rubocop/formatter/base_formatter.rb#76
+  def started(target_files); end
+end
+
+# This formatter formats report data in clang style.
+# The precise location of the problem is shown together with the
+# relevant source code.
+#
+# source://rubocop//lib/rubocop/formatter/clang_style_formatter.rb#8
+class RuboCop::Formatter::ClangStyleFormatter < ::RuboCop::Formatter::SimpleTextFormatter
+  # source://rubocop//lib/rubocop/formatter/clang_style_formatter.rb#11
+  def report_file(file, offenses); end
+
+  private
+
+  # source://rubocop//lib/rubocop/formatter/clang_style_formatter.rb#47
+  def report_highlighted_area(highlighted_area); end
+
+  # source://rubocop//lib/rubocop/formatter/clang_style_formatter.rb#37
+  def report_line(location); end
+
+  # source://rubocop//lib/rubocop/formatter/clang_style_formatter.rb#17
+  def report_offense(file, offense); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/formatter/clang_style_formatter.rb#33
+  def valid_line?(offense); end
+end
+
+# source://rubocop//lib/rubocop/formatter/clang_style_formatter.rb#9
+RuboCop::Formatter::ClangStyleFormatter::ELLIPSES = T.let(T.unsafe(nil), String)
+
+# This mix-in module provides string coloring methods for terminals.
+# It automatically disables coloring if coloring is disabled in the process
+# globally or the formatter's output is not a terminal.
+#
+# source://rubocop//lib/rubocop/formatter/colorizable.rb#8
+module RuboCop::Formatter::Colorizable
+  # source://rubocop//lib/rubocop/formatter/colorizable.rb#35
+  def black(string); end
+
+  # source://rubocop//lib/rubocop/formatter/colorizable.rb#35
+  def blue(string); end
+
+  # source://rubocop//lib/rubocop/formatter/colorizable.rb#21
+  def colorize(string, *args); end
+
+  # source://rubocop//lib/rubocop/formatter/colorizable.rb#35
+  def cyan(string); end
+
+  # source://rubocop//lib/rubocop/formatter/colorizable.rb#35
+  def green(string); end
+
+  # source://rubocop//lib/rubocop/formatter/colorizable.rb#35
+  def magenta(string); end
+
+  # source://rubocop//lib/rubocop/formatter/colorizable.rb#9
+  def rainbow; end
+
+  # source://rubocop//lib/rubocop/formatter/colorizable.rb#35
+  def red(string); end
+
+  # source://rubocop//lib/rubocop/formatter/colorizable.rb#35
+  def white(string); end
+
+  # source://rubocop//lib/rubocop/formatter/colorizable.rb#35
+  def yellow(string); end
+end
+
+# This formatter displays a YAML configuration file where all cops that
+# detected any offenses are configured to not detect the offense.
+#
+# source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#7
+class RuboCop::Formatter::DisabledConfigFormatter < ::RuboCop::Formatter::BaseFormatter
+  include ::RuboCop::PathUtil
+
+  # @return [DisabledConfigFormatter] a new instance of DisabledConfigFormatter
+  #
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#27
+  def initialize(output, options = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#40
+  def file_finished(file, offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#33
+  def file_started(_file, options); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#48
+  def finished(_inspected_files); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#69
+  def auto_gen_enforced_style?; end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#73
+  def command; end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#165
+  def cop_config_params(default_cfg, cfg); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#185
+  def default_config(cop_name); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#229
+  def excludes(offending_files, cop_name, parent); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#200
+  def filtered_config(cfg); end
+
+  # Returns true if the given arr include the given elm or if any of the
+  # given arr is a regexp that matches the given elm.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#277
+  def include_or_match?(arr, elm); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#250
+  def merge_mode_for_exclude?(cfg); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#271
+  def no_exclude_limit?; end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#102
+  def output_cop(cop_name, offense_count); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#137
+  def output_cop_comments(output_buffer, cfg, cop_name, offense_count); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#189
+  def output_cop_config(output_buffer, cfg, cop_name); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#172
+  def output_cop_param_comments(output_buffer, params, default_cfg); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#219
+  def output_exclude_list(output_buffer, offending_files, cop_name); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#254
+  def output_exclude_path(output_buffer, exclude_path, parent); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#208
+  def output_offending_files(output_buffer, cfg, cop_name); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#96
+  def output_offenses; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#267
+  def safe_autocorrect?(config); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#116
+  def set_max(cfg, cop_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#125
+  def should_set_max?(cop_name); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#65
+  def show_offense_counts?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#61
+  def show_timestamp?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#157
+  def supports_safe_autocorrect?(cop_class, default_cfg); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#161
+  def supports_unsafe_autocorrect?(cop_class, default_cfg); end
+
+  # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#92
+  def timestamp; end
+
+  class << self
+    # Returns the value of attribute config_to_allow_offenses.
+    #
+    # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#24
+    def config_to_allow_offenses; end
+
+    # Sets the attribute config_to_allow_offenses
+    #
+    # @param value the value to set the attribute config_to_allow_offenses to.
+    #
+    # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#24
+    def config_to_allow_offenses=(_arg0); end
+
+    # Returns the value of attribute detected_styles.
+    #
+    # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#24
+    def detected_styles; end
+
+    # Sets the attribute detected_styles
+    #
+    # @param value the value to set the attribute detected_styles to.
+    #
+    # source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#24
+    def detected_styles=(_arg0); end
+  end
+end
+
+# source://rubocop//lib/rubocop/formatter/disabled_config_formatter.rb#10
+RuboCop::Formatter::DisabledConfigFormatter::HEADING = T.let(T.unsafe(nil), String)
+
+# This formatter displays the report data in format that's
+# easy to process in the Emacs text editor.
+# The output is machine-parsable.
+#
+# source://rubocop//lib/rubocop/formatter/emacs_style_formatter.rb#8
+class RuboCop::Formatter::EmacsStyleFormatter < ::RuboCop::Formatter::BaseFormatter
+  # source://rubocop//lib/rubocop/formatter/emacs_style_formatter.rb#9
+  def file_finished(file, offenses); end
+
+  private
+
+  # source://rubocop//lib/rubocop/formatter/emacs_style_formatter.rb#24
+  def message(offense); end
+end
+
+# This formatter displays just a list of the files with offenses in them,
+# separated by newlines. The output is machine-parsable.
+#
+# Here's the format:
+#
+# /some/file
+# /some/other/file
+#
+# source://rubocop//lib/rubocop/formatter/file_list_formatter.rb#12
+class RuboCop::Formatter::FileListFormatter < ::RuboCop::Formatter::BaseFormatter
+  # source://rubocop//lib/rubocop/formatter/file_list_formatter.rb#13
+  def file_finished(file, offenses); end
+end
+
+# This is a collection of formatters. A FormatterSet can hold multiple
+# formatter instances and provides transparent formatter API methods
+# which invoke same method of each formatters.
+#
+# source://rubocop//lib/rubocop/formatter/formatter_set.rb#10
+class RuboCop::Formatter::FormatterSet < ::Array
+  # @return [FormatterSet] a new instance of FormatterSet
+  #
+  # source://rubocop//lib/rubocop/formatter/formatter_set.rb#40
+  def initialize(options = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/formatter/formatter_set.rb#56
+  def add_formatter(formatter_type, output_path = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/formatter/formatter_set.rb#68
+  def close_output_files; end
+
+  # source://rubocop//lib/rubocop/formatter/formatter_set.rb#51
+  def file_finished(file, offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/formatter_set.rb#45
+  def file_started(file, options); end
+
+  # source://rubocop//lib/rubocop/formatter/formatter_set.rb#35
+  def finished(*args); end
+
+  # source://rubocop//lib/rubocop/formatter/formatter_set.rb#35
+  def started(*args); end
+
+  private
+
+  # source://rubocop//lib/rubocop/formatter/formatter_set.rb#87
+  def builtin_formatter_class(specified_key); end
+
+  # source://rubocop//lib/rubocop/formatter/formatter_set.rb#105
+  def custom_formatter_class(specified_class_name); end
+
+  # source://rubocop//lib/rubocop/formatter/formatter_set.rb#76
+  def formatter_class(formatter_type); end
+end
+
+# source://rubocop//lib/rubocop/formatter/formatter_set.rb#11
+RuboCop::Formatter::FormatterSet::BUILTIN_FORMATTERS_FOR_KEYS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/formatter/formatter_set.rb#30
+RuboCop::Formatter::FormatterSet::BUILTIN_FORMATTER_NAMES = T.let(T.unsafe(nil), Array)
+
+# source://rubocop//lib/rubocop/formatter/formatter_set.rb#32
+RuboCop::Formatter::FormatterSet::FORMATTER_APIS = T.let(T.unsafe(nil), Array)
+
+# This formatter displays a progress bar and shows details of offenses as
+# soon as they are detected.
+# This is inspired by the Fuubar formatter for RSpec by Jeff Kreeftmeijer.
+# https://github.com/jeffkreeftmeijer/fuubar
+#
+# source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#11
+class RuboCop::Formatter::FuubarStyleFormatter < ::RuboCop::Formatter::ClangStyleFormatter
+  # @return [FuubarStyleFormatter] a new instance of FuubarStyleFormatter
+  #
+  # source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#14
+  def initialize(*output); end
+
+  # source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#51
+  def count_stats(offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#40
+  def file_finished(file, offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#71
+  def progressbar_color; end
+
+  # source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#20
+  def started(target_files); end
+
+  # source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#61
+  def with_color; end
+end
+
+# source://rubocop//lib/rubocop/formatter/fuubar_style_formatter.rb#12
+RuboCop::Formatter::FuubarStyleFormatter::RESET_SEQUENCE = T.let(T.unsafe(nil), String)
+
+# This formatter formats report data as GitHub Workflow commands resulting
+# in GitHub check annotations when run within GitHub Actions.
+#
+# source://rubocop//lib/rubocop/formatter/github_actions_formatter.rb#7
+class RuboCop::Formatter::GitHubActionsFormatter < ::RuboCop::Formatter::BaseFormatter
+  # source://rubocop//lib/rubocop/formatter/github_actions_formatter.rb#14
+  def file_finished(file, offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/github_actions_formatter.rb#18
+  def finished(_inspected_files); end
+
+  # source://rubocop//lib/rubocop/formatter/github_actions_formatter.rb#10
+  def started(_target_files); end
+
+  private
+
+  # source://rubocop//lib/rubocop/formatter/github_actions_formatter.rb#29
+  def github_escape(string); end
+
+  # source://rubocop//lib/rubocop/formatter/github_actions_formatter.rb#41
+  def github_severity(offense); end
+
+  # source://rubocop//lib/rubocop/formatter/github_actions_formatter.rb#33
+  def minimum_severity_to_fail; end
+
+  # source://rubocop//lib/rubocop/formatter/github_actions_formatter.rb#45
+  def report_offense(file, offense); end
+end
+
+# source://rubocop//lib/rubocop/formatter/github_actions_formatter.rb#8
+RuboCop::Formatter::GitHubActionsFormatter::ESCAPE_MAP = T.let(T.unsafe(nil), Hash)
+
+# This formatter saves the output as an html file.
+#
+# source://rubocop//lib/rubocop/formatter/html_formatter.rb#9
+class RuboCop::Formatter::HTMLFormatter < ::RuboCop::Formatter::BaseFormatter
+  # @return [HTMLFormatter] a new instance of HTMLFormatter
+  #
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#29
+  def initialize(output, options = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#39
+  def file_finished(file, offenses); end
+
+  # Returns the value of attribute files.
+  #
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#27
+  def files; end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#44
+  def finished(inspected_files); end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#50
+  def render_html; end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#35
+  def started(target_files); end
+
+  # Returns the value of attribute summary.
+  #
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#27
+  def summary; end
+end
+
+# This class provides helper methods used in the ERB CSS template.
+#
+# source://rubocop//lib/rubocop/formatter/html_formatter.rb#137
+class RuboCop::Formatter::HTMLFormatter::CSSContext
+  # Make Kernel#binding public.
+  #
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#148
+  def binding; end
+end
+
+# source://rubocop//lib/rubocop/formatter/html_formatter.rb#138
+RuboCop::Formatter::HTMLFormatter::CSSContext::SEVERITY_COLORS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/formatter/html_formatter.rb#12
+RuboCop::Formatter::HTMLFormatter::CSS_PATH = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/formatter/html_formatter.rb#14
+class RuboCop::Formatter::HTMLFormatter::Color < ::Struct
+  # Returns the value of attribute alpha
+  #
+  # @return [Object] the current value of alpha
+  def alpha; end
+
+  # Sets the attribute alpha
+  #
+  # @param value [Object] the value to set the attribute alpha to.
+  # @return [Object] the newly set value
+  def alpha=(_); end
+
+  # Returns the value of attribute blue
+  #
+  # @return [Object] the current value of blue
+  def blue; end
+
+  # Sets the attribute blue
+  #
+  # @param value [Object] the value to set the attribute blue to.
+  # @return [Object] the newly set value
+  def blue=(_); end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#19
+  def fade_out(amount); end
+
+  # Returns the value of attribute green
+  #
+  # @return [Object] the current value of green
+  def green; end
+
+  # Sets the attribute green
+  #
+  # @param value [Object] the value to set the attribute green to.
+  # @return [Object] the newly set value
+  def green=(_); end
+
+  # Returns the value of attribute red
+  #
+  # @return [Object] the current value of red
+  def red; end
+
+  # Sets the attribute red
+  #
+  # @param value [Object] the value to set the attribute red to.
+  # @return [Object] the newly set value
+  def red=(_); end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#15
+  def to_s; end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rubocop//lib/rubocop/formatter/html_formatter.rb#10
+RuboCop::Formatter::HTMLFormatter::ELLIPSES = T.let(T.unsafe(nil), String)
+
+# This class provides helper methods used in the ERB template.
+#
+# source://rubocop//lib/rubocop/formatter/html_formatter.rb#63
+class RuboCop::Formatter::HTMLFormatter::ERBContext
+  include ::RuboCop::PathUtil
+  include ::RuboCop::Formatter::TextUtil
+
+  # @return [ERBContext] a new instance of ERBContext
+  #
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#71
+  def initialize(files, summary); end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#118
+  def base64_encoded_logo_image; end
+
+  # Make Kernel#binding public.
+  #
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#78
+  def binding; end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#83
+  def decorated_message(offense); end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#114
+  def escape(string); end
+
+  # Returns the value of attribute files.
+  #
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#69
+  def files; end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#94
+  def highlight_source_tag(offense); end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#87
+  def highlighted_source_line(offense); end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#110
+  def possible_ellipses(location); end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#126
+  def render_css; end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#105
+  def source_after_highlight(offense); end
+
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#100
+  def source_before_highlight(offense); end
+
+  # Returns the value of attribute summary.
+  #
+  # source://rubocop//lib/rubocop/formatter/html_formatter.rb#69
+  def summary; end
+end
+
+# source://rubocop//lib/rubocop/formatter/html_formatter.rb#67
+RuboCop::Formatter::HTMLFormatter::ERBContext::LOGO_IMAGE_PATH = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/formatter/html_formatter.rb#25
+class RuboCop::Formatter::HTMLFormatter::FileOffenses < ::Struct
+  # Returns the value of attribute offenses
+  #
+  # @return [Object] the current value of offenses
+  def offenses; end
+
+  # Sets the attribute offenses
+  #
+  # @param value [Object] the value to set the attribute offenses to.
+  # @return [Object] the newly set value
+  def offenses=(_); end
+
+  # Returns the value of attribute path
+  #
+  # @return [Object] the current value of path
+  def path; end
+
+  # Sets the attribute path
+  #
+  # @param value [Object] the value to set the attribute path to.
+  # @return [Object] the newly set value
+  def path=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rubocop//lib/rubocop/formatter/html_formatter.rb#24
+class RuboCop::Formatter::HTMLFormatter::Summary < ::Struct
+  # Returns the value of attribute inspected_files
+  #
+  # @return [Object] the current value of inspected_files
+  def inspected_files; end
+
+  # Sets the attribute inspected_files
+  #
+  # @param value [Object] the value to set the attribute inspected_files to.
+  # @return [Object] the newly set value
+  def inspected_files=(_); end
+
+  # Returns the value of attribute offense_count
+  #
+  # @return [Object] the current value of offense_count
+  def offense_count; end
+
+  # Sets the attribute offense_count
+  #
+  # @param value [Object] the value to set the attribute offense_count to.
+  # @return [Object] the newly set value
+  def offense_count=(_); end
+
+  # Returns the value of attribute target_files
+  #
+  # @return [Object] the current value of target_files
+  def target_files; end
+
+  # Sets the attribute target_files
+  #
+  # @param value [Object] the value to set the attribute target_files to.
+  # @return [Object] the newly set value
+  def target_files=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://rubocop//lib/rubocop/formatter/html_formatter.rb#11
+RuboCop::Formatter::HTMLFormatter::TEMPLATE_PATH = T.let(T.unsafe(nil), String)
+
+# This formatter formats the report data in JSON format.
+#
+# source://rubocop//lib/rubocop/formatter/json_formatter.rb#8
+class RuboCop::Formatter::JSONFormatter < ::RuboCop::Formatter::BaseFormatter
+  include ::RuboCop::PathUtil
+
+  # @return [JSONFormatter] a new instance of JSONFormatter
+  #
+  # source://rubocop//lib/rubocop/formatter/json_formatter.rb#13
+  def initialize(output, options = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/formatter/json_formatter.rb#22
+  def file_finished(file, offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/json_formatter.rb#27
+  def finished(inspected_files); end
+
+  # source://rubocop//lib/rubocop/formatter/json_formatter.rb#42
+  def hash_for_file(file, offenses); end
+
+  # TODO: Consider better solution for Offense#real_column.
+  #       The minimum value of `start_column: real_column` is 1.
+  #       So, the minimum value of `last_column` should be 1.
+  #       And non-zero value of `last_column` should be used as is.
+  #
+  # source://rubocop//lib/rubocop/formatter/json_formatter.rb#64
+  def hash_for_location(offense); end
+
+  # source://rubocop//lib/rubocop/formatter/json_formatter.rb#49
+  def hash_for_offense(offense); end
+
+  # source://rubocop//lib/rubocop/formatter/json_formatter.rb#32
+  def metadata_hash; end
+
+  # Returns the value of attribute output_hash.
+  #
+  # source://rubocop//lib/rubocop/formatter/json_formatter.rb#11
+  def output_hash; end
+
+  # source://rubocop//lib/rubocop/formatter/json_formatter.rb#18
+  def started(target_files); end
+end
+
+# This formatter formats the report data in JUnit format.
+#
+# source://rubocop//lib/rubocop/formatter/junit_formatter.rb#15
+class RuboCop::Formatter::JUnitFormatter < ::RuboCop::Formatter::BaseFormatter
+  # @return [JUnitFormatter] a new instance of JUnitFormatter
+  #
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#24
+  def initialize(output, options = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#32
+  def file_finished(file, offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#51
+  def finished(_inspected_files); end
+
+  private
+
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#106
+  def add_failure_to(testcase, offenses, cop_name); end
+
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#85
+  def add_testcase_element_to_testsuite_element(file, target_offenses, cop); end
+
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#94
+  def classname_attribute_value(file); end
+
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#81
+  def offenses_for_cop(all_offenses, cop); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#77
+  def relevant_for_output?(options, target_offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#101
+  def reset_count; end
+
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#118
+  def xml_escape(string); end
+end
+
+# source://rubocop//lib/rubocop/formatter/junit_formatter.rb#16
+RuboCop::Formatter::JUnitFormatter::ESCAPE_MAP = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/formatter/junit_formatter.rb#132
+class RuboCop::Formatter::JUnitFormatter::FailureElement
+  # @return [FailureElement] a new instance of FailureElement
+  #
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#135
+  def initialize(type:, message:, text:); end
+
+  # Returns the value of attribute message.
+  #
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#133
+  def message; end
+
+  # Returns the value of attribute text.
+  #
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#133
+  def text; end
+
+  # Returns the value of attribute type.
+  #
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#133
+  def type; end
+end
+
+# source://rubocop//lib/rubocop/formatter/junit_formatter.rb#122
+class RuboCop::Formatter::JUnitFormatter::TestCaseElement
+  # @return [TestCaseElement] a new instance of TestCaseElement
+  #
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#125
+  def initialize(classname:, name:); end
+
+  # Returns the value of attribute classname.
+  #
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#123
+  def classname; end
+
+  # Returns the value of attribute failures.
+  #
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#123
+  def failures; end
+
+  # Returns the value of attribute name.
+  #
+  # source://rubocop//lib/rubocop/formatter/junit_formatter.rb#123
+  def name; end
+end
+
+# This formatter displays the report data in markdown
+#
+# source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#6
+class RuboCop::Formatter::MarkdownFormatter < ::RuboCop::Formatter::BaseFormatter
+  include ::RuboCop::Formatter::TextUtil
+  include ::RuboCop::PathUtil
+
+  # @return [MarkdownFormatter] a new instance of MarkdownFormatter
+  #
+  # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#11
+  def initialize(output, options = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#21
+  def file_finished(file, offenses); end
+
+  # Returns the value of attribute files.
+  #
+  # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#9
+  def files; end
+
+  # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#26
+  def finished(inspected_files); end
+
+  # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#17
+  def started(target_files); end
+
+  # Returns the value of attribute summary.
+  #
+  # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#9
+  def summary; end
+
+  private
+
+  # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#73
+  def possible_ellipses(location); end
+
+  # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#33
+  def render_markdown; end
+
+  # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#67
+  def write_code(offense); end
+
+  # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#61
+  def write_context(offense); end
+
+  # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#42
+  def write_file_messages; end
+
+  # source://rubocop//lib/rubocop/formatter/markdown_formatter.rb#54
+  def write_heading(file); end
+end
+
+# This formatter displays the list of offended cops with a count of how
+# many offenses of their kind were found. Ordered by desc offense count
+#
+# Here's the format:
+#
+# 26  LineLength
+# 3   OneLineConditional
+# --
+# 29  Total in 5 files
+#
+# source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#16
+class RuboCop::Formatter::OffenseCountFormatter < ::RuboCop::Formatter::BaseFormatter
+  # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#81
+  def cop_information(cop_name); end
+
+  # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#42
+  def file_finished(_file, offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#51
+  def finished(_inspected_files); end
+
+  # Returns the value of attribute offense_counts.
+  #
+  # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#17
+  def offense_counts; end
+
+  # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#73
+  def ordered_offense_counts(offense_counts); end
+
+  # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#56
+  def report_summary(offense_counts, offending_files_count); end
+
+  # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#19
+  def started(target_files); end
+
+  # source://rubocop//lib/rubocop/formatter/offense_count_formatter.rb#77
+  def total_offense_count(offense_counts); end
+end
+
+# This formatter prints a PACDOT per every file to be analyzed.
+# Pacman will "eat" one PACDOT per file when no offense is detected.
+# Otherwise it will print a Ghost.
+# This is inspired by the Pacman formatter for RSpec by Carlos Rojas.
+# https://github.com/go-labs/rspec_pacman_formatter
+#
+# source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#10
+class RuboCop::Formatter::PacmanFormatter < ::RuboCop::Formatter::ClangStyleFormatter
+  include ::RuboCop::Formatter::TextUtil
+
+  # @return [PacmanFormatter] a new instance of PacmanFormatter
+  #
+  # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#19
+  def initialize(output, options = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#50
+  def cols; end
+
+  # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#37
+  def file_finished(file, offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#33
+  def file_started(_file, _options); end
+
+  # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#43
+  def next_step(offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#64
+  def pacdots(number); end
+
+  # Returns the value of attribute progress_line.
+  #
+  # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#12
+  def progress_line; end
+
+  # Sets the attribute progress_line
+  #
+  # @param value the value to set the attribute progress_line to.
+  #
+  # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#12
+  def progress_line=(_arg0); end
+
+  # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#26
+  def started(target_files); end
+
+  # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#68
+  def step(character); end
+
+  # source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#57
+  def update_progress_line; end
+end
+
+# source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#14
+RuboCop::Formatter::PacmanFormatter::FALLBACK_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer)
+
+# source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#15
+RuboCop::Formatter::PacmanFormatter::GHOST = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#17
+RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::NullPresenter)
+
+# source://rubocop//lib/rubocop/formatter/pacman_formatter.rb#16
+RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::NullPresenter)
+
+# This formatter display dots for files with no offenses and
+# letters for files with problems in the them. In the end it
+# appends the regular report data in the clang style format.
+#
+# source://rubocop//lib/rubocop/formatter/progress_formatter.rb#8
+class RuboCop::Formatter::ProgressFormatter < ::RuboCop::Formatter::ClangStyleFormatter
+  include ::RuboCop::Formatter::TextUtil
+
+  # @return [ProgressFormatter] a new instance of ProgressFormatter
+  #
+  # source://rubocop//lib/rubocop/formatter/progress_formatter.rb#13
+  def initialize(output, options = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/formatter/progress_formatter.rb#24
+  def file_finished(file, offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/progress_formatter.rb#33
+  def finished(inspected_files); end
+
+  # source://rubocop//lib/rubocop/formatter/progress_formatter.rb#50
+  def report_file_as_mark(offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/progress_formatter.rb#18
+  def started(target_files); end
+end
+
+# source://rubocop//lib/rubocop/formatter/progress_formatter.rb#11
+RuboCop::Formatter::ProgressFormatter::DOT = T.let(T.unsafe(nil), String)
+
+# If no offenses are found, no output is displayed.
+# Otherwise, SimpleTextFormatter's output is displayed.
+#
+# source://rubocop//lib/rubocop/formatter/quiet_formatter.rb#7
+class RuboCop::Formatter::QuietFormatter < ::RuboCop::Formatter::SimpleTextFormatter
+  # source://rubocop//lib/rubocop/formatter/quiet_formatter.rb#8
+  def report_summary(file_count, offense_count, correction_count, correctable_count); end
+end
+
+# A basic formatter that displays only files with offenses.
+# Offenses are displayed at compact form - just the
+# location of the problem and the associated message.
+#
+# source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#10
+class RuboCop::Formatter::SimpleTextFormatter < ::RuboCop::Formatter::BaseFormatter
+  include ::RuboCop::Formatter::Colorizable
+  include ::RuboCop::PathUtil
+
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#29
+  def file_finished(file, offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#36
+  def finished(inspected_files); end
+
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#43
+  def report_file(file, offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#57
+  def report_summary(file_count, offense_count, correction_count, correctable_count); end
+
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#23
+  def started(_target_files); end
+
+  private
+
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#85
+  def annotate_message(msg); end
+
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#80
+  def colored_severity_code(offense); end
+
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#73
+  def count_stats(offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#89
+  def message(offense); end
+end
+
+# source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#14
+RuboCop::Formatter::SimpleTextFormatter::COLOR_FOR_SEVERITY = T.let(T.unsafe(nil), Hash)
+
+# A helper class for building the report summary text.
+#
+# source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#105
+class RuboCop::Formatter::SimpleTextFormatter::Report
+  include ::RuboCop::Formatter::Colorizable
+  include ::RuboCop::Formatter::TextUtil
+
+  # @return [Report] a new instance of Report
+  #
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#110
+  def initialize(file_count, offense_count, correction_count, correctable_count, rainbow, safe_autocorrect: T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#123
+  def summary; end
+
+  private
+
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#160
+  def correctable; end
+
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#153
+  def corrections; end
+
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#142
+  def files; end
+
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#146
+  def offenses; end
+
+  # Returns the value of attribute rainbow.
+  #
+  # source://rubocop//lib/rubocop/formatter/simple_text_formatter.rb#140
+  def rainbow; end
+end
+
+# This formatter formats report data using the Test Anything Protocol.
+# TAP allows for to communicate tests results in a language agnostics way.
+#
+# source://rubocop//lib/rubocop/formatter/tap_formatter.rb#7
+class RuboCop::Formatter::TapFormatter < ::RuboCop::Formatter::ClangStyleFormatter
+  # source://rubocop//lib/rubocop/formatter/tap_formatter.rb#14
+  def file_finished(file, offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/tap_formatter.rb#8
+  def started(target_files); end
+
+  private
+
+  # source://rubocop//lib/rubocop/formatter/tap_formatter.rb#62
+  def annotate_message(msg); end
+
+  # source://rubocop//lib/rubocop/formatter/tap_formatter.rb#66
+  def message(offense); end
+
+  # source://rubocop//lib/rubocop/formatter/tap_formatter.rb#39
+  def report_highlighted_area(highlighted_area); end
+
+  # source://rubocop//lib/rubocop/formatter/tap_formatter.rb#29
+  def report_line(location); end
+
+  # source://rubocop//lib/rubocop/formatter/tap_formatter.rb#46
+  def report_offense(file, offense); end
+end
+
+# Common logic for UI texts.
+#
+# source://rubocop//lib/rubocop/formatter/text_util.rb#6
+module RuboCop::Formatter::TextUtil
+  private
+
+  # source://rubocop//lib/rubocop/formatter/text_util.rb#9
+  def pluralize(number, thing, options = T.unsafe(nil)); end
+
+  class << self
+    # source://rubocop//lib/rubocop/formatter/text_util.rb#9
+    def pluralize(number, thing, options = T.unsafe(nil)); end
+  end
+end
+
+# This formatter displays the list of offensive files, sorted by number of
+# offenses with the worst offenders first.
+#
+# Here's the format:
+#
+# 26  this/file/is/really/bad.rb
+# 3   just/ok.rb
+# --
+# 29  Total in 2 files
+#
+# source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#16
+class RuboCop::Formatter::WorstOffendersFormatter < ::RuboCop::Formatter::BaseFormatter
+  # source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#24
+  def file_finished(file, offenses); end
+
+  # source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#31
+  def finished(_inspected_files); end
+
+  # Returns the value of attribute offense_counts.
+  #
+  # source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#17
+  def offense_counts; end
+
+  # source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#55
+  def ordered_offense_counts(offense_counts); end
+
+  # source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#36
+  def report_summary(offense_counts); end
+
+  # source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#19
+  def started(target_files); end
+
+  # source://rubocop//lib/rubocop/formatter/worst_offenders_formatter.rb#59
+  def total_offense_count(offense_counts); end
+end
+
+# source://rubocop//lib/rubocop/options.rb#8
+class RuboCop::IncorrectCopNameError < ::StandardError; end
+
+# The RuboCop's built-in LSP module.
+#
+# source://rubocop//lib/rubocop/lsp.rb#5
+module RuboCop::LSP
+  private
+
+  # Disable LSP.
+  #
+  # @return [void]
+  #
+  # source://rubocop//lib/rubocop/lsp.rb#25
+  def disable(&block); end
+
+  # Enable LSP.
+  #
+  # @return [void]
+  #
+  # source://rubocop//lib/rubocop/lsp.rb#18
+  def enable; end
+
+  # Returns true when LSP is enabled, false when disabled.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/lsp.rb#11
+  def enabled?; end
+
+  class << self
+    # Disable LSP.
+    #
+    # @return [void]
+    #
+    # source://rubocop//lib/rubocop/lsp.rb#25
+    def disable(&block); end
+
+    # Enable LSP.
+    #
+    # @return [void]
+    #
+    # source://rubocop//lib/rubocop/lsp.rb#18
+    def enable; end
+
+    # Returns true when LSP is enabled, false when disabled.
+    #
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/lsp.rb#11
+    def enabled?; end
+  end
+end
+
+# Encapsulation of a lockfile for use when checking for gems.
+# Does not actually resolve gems, just parses the lockfile.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/lockfile.rb#15
+class RuboCop::Lockfile
+  # @api private
+  # @param lockfile_path [String, Pathname, nil]
+  # @return [Lockfile] a new instance of Lockfile
+  #
+  # source://rubocop//lib/rubocop/lockfile.rb#17
+  def initialize(lockfile_path = T.unsafe(nil)); end
+
+  # Gems that the bundle directly depends on.
+  #
+  # @api private
+  # @return [Array<Bundler::Dependency>, nil]
+  #
+  # source://rubocop//lib/rubocop/lockfile.rb#29
+  def dependencies; end
+
+  # Returns the locked versions of gems from this lockfile.
+  #
+  # @api private
+  # @param include_transitive_dependencies: [Boolean] When false, only direct dependencies
+  #   are returned, i.e. those listed explicitly in the `Gemfile`.
+  #
+  # source://rubocop//lib/rubocop/lockfile.rb#49
+  def gem_versions(include_transitive_dependencies: T.unsafe(nil)); end
+
+  # All activated gems, including transitive dependencies.
+  #
+  # @api private
+  # @return [Array<Bundler::Dependency>, nil]
+  #
+  # source://rubocop//lib/rubocop/lockfile.rb#37
+  def gems; end
+
+  # Whether this lockfile includes the named gem, directly or indirectly.
+  #
+  # @api private
+  # @param name [String]
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/lockfile.rb#65
+  def includes_gem?(name); end
+
+  private
+
+  # @api private
+  # @return [Bundler::LockfileParser, nil]
+  #
+  # source://rubocop//lib/rubocop/lockfile.rb#72
+  def parser; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/lockfile.rb#85
+  def use_bundler_lock_parser?; end
+end
+
+# Parse different formats of magic comments.
+#
+# @abstract parent of three different magic comment handlers
+#
+# source://rubocop//lib/rubocop/magic_comment.rb#7
+class RuboCop::MagicComment
+  # @return [MagicComment] a new instance of MagicComment
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#32
+  def initialize(comment); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#36
+  def any?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#104
+  def encoding_specified?; end
+
+  # Expose the `frozen_string_literal` value coerced to a boolean if possible.
+  #
+  # @return [Boolean] if value is `true` or `false`
+  # @return [nil] if frozen_string_literal comment isn't found
+  # @return [String] if comment is found but isn't true or false
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#86
+  def frozen_string_literal; end
+
+  # Does the magic comment enable the frozen string literal feature.
+  #
+  # Test whether the frozen string literal value is `true`. Cannot
+  # just return `frozen_string_literal` since an invalid magic comment
+  # `'yes'` does not actually enable the feature
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#55
+  def frozen_string_literal?; end
+
+  # Was a magic comment for the frozen string literal found?
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#70
+  def frozen_string_literal_specified?; end
+
+  # Expose the `shareable_constant_value` value coerced to a boolean if possible.
+  #
+  # @return [String] for shareable_constant_value config
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#100
+  def shareable_constant_value; end
+
+  # Was a shareable_constant_value specified?
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#77
+  def shareable_constant_value_specified?; end
+
+  # source://rubocop//lib/rubocop/magic_comment.rb#115
+  def typed; end
+
+  # Was the Sorbet `typed` sigil specified?
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#111
+  def typed_specified?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#43
+  def valid?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#59
+  def valid_literal_value?; end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#63
+  def valid_shareable_constant_value?; end
+
+  private
+
+  # Match the entire comment string with a pattern and take the first capture.
+  #
+  # @param pattern [Regexp]
+  # @return [String] if pattern matched
+  # @return [nil] otherwise
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#131
+  def extract(pattern); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#121
+  def specified?(value); end
+
+  class << self
+    # Detect magic comment format and pass it to the appropriate wrapper.
+    #
+    # @param comment [String]
+    # @return [RuboCop::MagicComment]
+    #
+    # source://rubocop//lib/rubocop/magic_comment.rb#23
+    def parse(comment); end
+  end
+end
+
+# Parent to Vim and Emacs magic comment handling.
+#
+# @abstract
+#
+# source://rubocop//lib/rubocop/magic_comment.rb#138
+class RuboCop::MagicComment::EditorComment < ::RuboCop::MagicComment
+  # source://rubocop//lib/rubocop/magic_comment.rb#139
+  def encoding; end
+
+  # Rewrite the comment without a given token type
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#144
+  def without(type); end
+
+  private
+
+  # Find a token starting with the provided keyword and extract its value.
+  #
+  # @param keyword [String]
+  # @return [String] extracted value if it is found
+  # @return [nil] otherwise
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#159
+  def match(keyword); end
+
+  # Individual tokens composing an editor specific comment string.
+  #
+  # @return [Array<String>]
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#174
+  def tokens; end
+end
+
+# Wrapper for Emacs style magic comments.
+#
+# @example Emacs style comment
+#   comment = RuboCop::MagicComment.parse(
+#   '# -*- encoding: ASCII-8BIT -*-'
+#   )
+#
+#   comment.encoding # => 'ascii-8bit'
+# @see https://www.gnu.org/software/emacs/manual/html_node/emacs/Specify-Coding.html
+# @see https://github.com/ruby/ruby/blob/3f306dc/parse.y#L6873-L6892 Emacs handling in parse.y
+#
+# source://rubocop//lib/rubocop/magic_comment.rb#190
+class RuboCop::MagicComment::EmacsComment < ::RuboCop::MagicComment::EditorComment
+  private
+
+  # source://rubocop//lib/rubocop/magic_comment.rb#198
+  def extract_frozen_string_literal; end
+
+  # source://rubocop//lib/rubocop/magic_comment.rb#202
+  def extract_shareable_constant_value; end
+
+  # Emacs comments cannot specify Sorbet typechecking behavior.
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#207
+  def extract_typed; end
+end
+
+# source://rubocop//lib/rubocop/magic_comment.rb#192
+RuboCop::MagicComment::EmacsComment::FORMAT = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/magic_comment.rb#194
+RuboCop::MagicComment::EmacsComment::OPERATOR = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/magic_comment.rb#191
+RuboCop::MagicComment::EmacsComment::REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/magic_comment.rb#193
+RuboCop::MagicComment::EmacsComment::SEPARATOR = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/magic_comment.rb#11
+RuboCop::MagicComment::KEYWORDS = T.let(T.unsafe(nil), Hash)
+
+# Wrapper for regular magic comments not bound to an editor.
+#
+# Simple comments can only specify one setting per comment.
+#
+# @example frozen string literal comments
+#   comment1 = RuboCop::MagicComment.parse('# frozen_string_literal: true')
+#   comment1.frozen_string_literal # => true
+#   comment1.encoding              # => nil
+# @example encoding comments
+#   comment2 = RuboCop::MagicComment.parse('# encoding: utf-8')
+#   comment2.frozen_string_literal # => nil
+#   comment2.encoding              # => 'utf-8'
+#
+# source://rubocop//lib/rubocop/magic_comment.rb#261
+class RuboCop::MagicComment::SimpleComment < ::RuboCop::MagicComment
+  # Match `encoding` or `coding`
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#265
+  def encoding; end
+
+  # Rewrite the comment without a given token type
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#270
+  def without(type); end
+
+  private
+
+  # Extract `frozen_string_literal`.
+  #
+  # The `frozen_string_literal` magic comment only works if it
+  # is the only text in the comment.
+  #
+  # Case-insensitive and dashes/underscores are acceptable.
+  #
+  # @see https://github.com/ruby/ruby/blob/78b95b4/parse.y#L7134-L7138
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#287
+  def extract_frozen_string_literal; end
+
+  # source://rubocop//lib/rubocop/magic_comment.rb#291
+  def extract_shareable_constant_value; end
+
+  # source://rubocop//lib/rubocop/magic_comment.rb#295
+  def extract_typed; end
+end
+
+# source://rubocop//lib/rubocop/magic_comment.rb#262
+RuboCop::MagicComment::SimpleComment::FSTRING_LITERAL_COMMENT = T.let(T.unsafe(nil), String)
+
+# IRB's pattern for matching magic comment tokens.
+#
+# @see https://github.com/ruby/ruby/blob/b4a55c1/lib/irb/magic-file.rb#L5
+#
+# source://rubocop//lib/rubocop/magic_comment.rb#10
+RuboCop::MagicComment::TOKEN = T.let(T.unsafe(nil), String)
+
+# Wrapper for Vim style magic comments.
+#
+# @example Vim style comment
+#   comment = RuboCop::MagicComment.parse(
+#   '# vim: filetype=ruby, fileencoding=ascii-8bit'
+#   )
+#
+#   comment.encoding # => 'ascii-8bit'
+#
+# source://rubocop//lib/rubocop/magic_comment.rb#218
+class RuboCop::MagicComment::VimComment < ::RuboCop::MagicComment::EditorComment
+  # For some reason the fileencoding keyword only works if there
+  # is at least one other token included in the string. For example
+  #
+  #    # works
+  #      # vim: foo=bar, fileencoding=ascii-8bit
+  #
+  #    # does nothing
+  #      # vim: foo=bar, fileencoding=ascii-8bit
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#234
+  def encoding; end
+
+  # Vim comments cannot specify Sorbet typechecking behavior.
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#245
+  def extract_typed; end
+
+  # Vim comments cannot specify frozen string literal behavior.
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#239
+  def frozen_string_literal; end
+
+  # Vim comments cannot specify shareable constant values behavior.
+  #
+  # source://rubocop//lib/rubocop/magic_comment.rb#242
+  def shareable_constant_value; end
+end
+
+# source://rubocop//lib/rubocop/magic_comment.rb#220
+RuboCop::MagicComment::VimComment::FORMAT = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/magic_comment.rb#223
+RuboCop::MagicComment::VimComment::KEYWORDS = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/magic_comment.rb#222
+RuboCop::MagicComment::VimComment::OPERATOR = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/magic_comment.rb#219
+RuboCop::MagicComment::VimComment::REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/magic_comment.rb#221
+RuboCop::MagicComment::VimComment::SEPARATOR = T.let(T.unsafe(nil), String)
+
+# Common functionality for finding names that are similar to a given name.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/name_similarity.rb#6
+module RuboCop::NameSimilarity
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/name_similarity.rb#9
+  def find_similar_name(target_name, names); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/name_similarity.rb#15
+  def find_similar_names(target_name, names); end
+
+  class << self
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/name_similarity.rb#9
+    def find_similar_name(target_name, names); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/name_similarity.rb#15
+    def find_similar_names(target_name, names); end
+  end
+end
+
+# source://rubocop//lib/rubocop/ast_aliases.rb#5
+RuboCop::NodePattern = RuboCop::AST::NodePattern
+
+# source://rubocop//lib/rubocop/options.rb#10
+class RuboCop::OptionArgumentError < ::StandardError; end
+
+# This class handles command line options.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/options.rb#14
+class RuboCop::Options
+  # @api private
+  # @return [Options] a new instance of Options
+  #
+  # source://rubocop//lib/rubocop/options.rb#22
+  def initialize; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#27
+  def parse(command_line_args); end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#229
+  def add_additional_modes(opts); end
+
+  # the autocorrect command-line arguments map to the autocorrect @options values like so:
+  #                            :fix_layout  :autocorrect  :safe_autocorrect  :autocorrect_all
+  # -x, --fix-layout           true         true          -                  -
+  # -a, --auto-correct         -            true          true               -
+  #     --safe-auto-correct    -            true          true               -
+  # -A, --auto-correct-all     -            true          -                  true
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#140
+  def add_autocorrection_options(opts); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#205
+  def add_cache_options(opts); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#73
+  def add_check_options(opts); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#163
+  def add_config_generation_options(opts); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#181
+  def add_cop_selection_csv_option(option, opts); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#241
+  def add_general_options(opts); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#212
+  def add_lsp_option(opts); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#105
+  def add_output_options(opts); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#253
+  def add_profile_options(opts); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#218
+  def add_server_options(opts); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#196
+  def add_severity_option(opts); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#53
+  def define_options; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#263
+  def handle_deprecated_option(old_option, new_option); end
+
+  # Finds the option in `args` starting with -- and converts it to a symbol,
+  # e.g. [..., '--autocorrect', ...] to :autocorrect.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#297
+  def long_opt_symbol(args); end
+
+  # Sets a value in the @options hash, based on the given long option and its
+  # value, in addition to calling the block if a block is given.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#286
+  def option(opts, *args); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#268
+  def rainbow; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#302
+  def require_feature(file); end
+
+  # Creates a section of options in order to separate them visually when
+  # using `--help`.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#278
+  def section(opts, heading, &_block); end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/options.rb#20
+RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS = T.let(T.unsafe(nil), Integer)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/options.rb#19
+RuboCop::Options::EXITING_OPTIONS = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/options.rb#15
+RuboCop::Options::E_STDIN_NO_PATH = T.let(T.unsafe(nil), String)
+
+# This module contains help texts for command line options.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/options.rb#498
+module RuboCop::OptionsHelp; end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/options.rb#500
+RuboCop::OptionsHelp::FORMATTER_OPTION_LIST = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/options.rb#499
+RuboCop::OptionsHelp::MAX_EXCL = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/options.rb#502
+RuboCop::OptionsHelp::TEXT = T.let(T.unsafe(nil), Hash)
+
+# Validates option arguments and the options' compatibility with each other.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/options.rb#312
+class RuboCop::OptionsValidator
+  # @api private
+  # @return [OptionsValidator] a new instance of OptionsValidator
+  #
+  # source://rubocop//lib/rubocop/options.rb#350
+  def initialize(options); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/options.rb#472
+  def boolean_or_empty_cache?; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#442
+  def disable_parallel_when_invalid_option_combo; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/options.rb#468
+  def except_syntax?; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#476
+  def incompatible_options; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#455
+  def invalid_arguments_for_parallel; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/options.rb#463
+  def only_includes_redundant_disable?; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#382
+  def validate_auto_gen_config; end
+
+  # @api private
+  # @raise [OptionArgumentError]
+  #
+  # source://rubocop//lib/rubocop/options.rb#428
+  def validate_autocorrect; end
+
+  # @api private
+  # @raise [OptionArgumentError]
+  #
+  # source://rubocop//lib/rubocop/options.rb#488
+  def validate_cache_enabled_for_cache_root; end
+
+  # @api private
+  # @raise [OptionArgumentError]
+  #
+  # source://rubocop//lib/rubocop/options.rb#359
+  def validate_compatibility; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/options.rb#354
+  def validate_cop_options; end
+
+  # @api private
+  # @raise [OptionArgumentError]
+  #
+  # source://rubocop//lib/rubocop/options.rb#403
+  def validate_display_only_correctable_and_autocorrect; end
+
+  # @api private
+  # @raise [OptionArgumentError]
+  #
+  # source://rubocop//lib/rubocop/options.rb#395
+  def validate_display_only_failed; end
+
+  # @api private
+  # @raise [OptionArgumentError]
+  #
+  # source://rubocop//lib/rubocop/options.rb#412
+  def validate_display_only_failed_and_display_only_correctable; end
+
+  # @api private
+  # @raise [OptionParser::MissingArgument]
+  #
+  # source://rubocop//lib/rubocop/options.rb#480
+  def validate_exclude_limit_option; end
+
+  # @api private
+  # @raise [OptionArgumentError]
+  #
+  # source://rubocop//lib/rubocop/options.rb#421
+  def validate_lsp_and_editor_mode; end
+
+  class << self
+    # Cop name validation must be done later than option parsing, so it's not
+    # called from within Options.
+    #
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/options.rb#319
+    def validate_cop_list(names); end
+
+    private
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/options.rb#336
+    def format_message_from(name, cop_names); end
+  end
+end
+
+# Common methods and behaviors for dealing with paths.
+#
+# source://rubocop//lib/rubocop/path_util.rb#5
+module RuboCop::PathUtil
+  private
+
+  # Returns true for an absolute Unix or Windows path.
+  #
+  # source://rubocop//lib/rubocop/path_util.rb#76
+  def absolute?(path); end
+
+  # Returns true for a glob
+  #
+  # source://rubocop//lib/rubocop/path_util.rb#81
+  def glob?(path); end
+
+  # source://rubocop//lib/rubocop/path_util.rb#111
+  def hidden_dir?(path); end
+
+  # source://rubocop//lib/rubocop/path_util.rb#94
+  def hidden_file?(path); end
+
+  # source://rubocop//lib/rubocop/path_util.rb#85
+  def hidden_file_in_not_hidden_dir?(pattern, path); end
+
+  # source://rubocop//lib/rubocop/path_util.rb#48
+  def match_path?(pattern, path); end
+
+  # Loose check to reduce memory allocations
+  #
+  # source://rubocop//lib/rubocop/path_util.rb#101
+  def maybe_hidden_file?(path); end
+
+  # source://rubocop//lib/rubocop/path_util.rb#13
+  def relative_path(path, base_dir = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/path_util.rb#34
+  def smart_path(path); end
+
+  class << self
+    # Returns true for an absolute Unix or Windows path.
+    #
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/path_util.rb#76
+    def absolute?(path); end
+
+    # Returns true for a glob
+    #
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/path_util.rb#81
+    def glob?(path); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/path_util.rb#111
+    def hidden_dir?(path); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/path_util.rb#94
+    def hidden_file?(path); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/path_util.rb#85
+    def hidden_file_in_not_hidden_dir?(pattern, path); end
+
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/path_util.rb#48
+    def match_path?(pattern, path); end
+
+    # Loose check to reduce memory allocations
+    #
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/path_util.rb#101
+    def maybe_hidden_file?(path); end
+
+    # source://rubocop//lib/rubocop/path_util.rb#13
+    def relative_path(path, base_dir = T.unsafe(nil)); end
+
+    # Returns the value of attribute relative_paths_cache.
+    #
+    # source://rubocop//lib/rubocop/path_util.rb#7
+    def relative_paths_cache; end
+
+    # Sets the attribute relative_paths_cache
+    #
+    # @param value the value to set the attribute relative_paths_cache to.
+    #
+    # source://rubocop//lib/rubocop/path_util.rb#7
+    def relative_paths_cache=(_arg0); end
+
+    # source://rubocop//lib/rubocop/path_util.rb#34
+    def smart_path(path); end
+  end
+end
+
+# source://rubocop//lib/rubocop/path_util.rb#98
+RuboCop::PathUtil::HIDDEN_FILE_PATTERN = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/path_util.rb#31
+RuboCop::PathUtil::SMART_PATH_CACHE = T.let(T.unsafe(nil), Hash)
+
+# This module provides information on the platform that RuboCop is being run
+# on.
+#
+# source://rubocop//lib/rubocop/platform.rb#6
+module RuboCop::Platform
+  class << self
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/platform.rb#7
+    def windows?; end
+  end
+end
+
+# source://rubocop//lib/rubocop/ast_aliases.rb#6
+RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource
+
+# source://rubocop//lib/rubocop/rspec/expect_offense.rb#4
+module RuboCop::RSpec; end
+
+# Mixin for `expect_offense` and `expect_no_offenses`
+#
+# This mixin makes it easier to specify strict offense expectations
+# in a declarative and visual fashion. Just type out the code that
+# should generate an offense, annotate code by writing '^'s
+# underneath each character that should be highlighted, and follow
+# the carets with a string (separated by a space) that is the
+# message of the offense. You can include multiple offenses in
+# one code snippet.
+#
+# Autocorrection can be tested using `expect_correction` after
+# `expect_offense`.
+#
+# If you do not want to specify an offense then use the
+# companion method `expect_no_offenses`. This method is a much
+# simpler assertion since it just inspects the source and checks
+# that there were no offenses. The `expect_offense` method has
+# to do more work by parsing out lines that contain carets.
+#
+# If the code produces an offense that could not be autocorrected, you can
+# use `expect_no_corrections` after `expect_offense`.
+#
+# If your code has variables of different lengths, you can use `%{foo}`,
+# `^{foo}`, and `_{foo}` to format your template; you can also abbreviate
+# offense messages with `[...]`:
+#
+#   %w[raise fail].each do |keyword|
+#     expect_offense(<<~RUBY, keyword: keyword)
+#       %{keyword}(RuntimeError, msg)
+#       ^{keyword}^^^^^^^^^^^^^^^^^^^ Redundant `RuntimeError` argument [...]
+#     RUBY
+#
+#   %w[has_one has_many].each do |type|
+#     expect_offense(<<~RUBY, type: type)
+#       class Book
+#         %{type} :chapter, foreign_key: 'book_id'
+#         _{type}           ^^^^^^^^^^^^^^^^^^^^^^ Specifying the default [...]
+#       end
+#     RUBY
+#   end
+#
+# If you need to specify an offense on a blank line, use the empty `^{}` marker:
+#
+# @example Usage
+#
+#   expect_offense(<<~RUBY)
+#   a do
+#   b
+#   end.c
+#   ^^^^^ Avoid chaining a method call on a do...end block.
+#   RUBY
+# @example Equivalent assertion without `expect_offense`
+#
+#   inspect_source(<<~RUBY)
+#   a do
+#   b
+#   end.c
+#   RUBY
+#
+#   expect(cop.offenses.size).to be(1)
+#
+#   offense = cop.offenses.first
+#   expect(offense.line).to be(3)
+#   expect(offense.column_range).to be(0...5)
+#   expect(offense.message).to eql(
+#   'Avoid chaining a method call on a do...end block.'
+#   )
+# @example `expect_offense` and `expect_correction`
+#
+#   expect_offense(<<~RUBY)
+#   x % 2 == 0
+#   ^^^^^^^^^^ Replace with `Integer#even?`.
+#   RUBY
+#
+#   expect_correction(<<~RUBY)
+#   x.even?
+#   RUBY
+# @example `expect_offense` and `expect_no_corrections`
+#
+#   expect_offense(<<~RUBY)
+#   a do
+#   b
+#   end.c
+#   ^^^^^ Avoid chaining a method call on a do...end block.
+#   RUBY
+#
+#   expect_no_corrections
+# @example `^{}` empty line offense
+#
+#   expect_offense(<<~RUBY)
+#
+#   ^{} Missing frozen string literal comment.
+#   puts 1
+#   RUBY
+#
+# source://rubocop//lib/rubocop/rspec/expect_offense.rb#103
+module RuboCop::RSpec::ExpectOffense
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#138
+  def expect_correction(correction, loop: T.unsafe(nil), source: T.unsafe(nil)); end
+
+  # @raise [RuboCop::Runner::InfiniteCorrectionLoop]
+  #
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#176
+  def expect_no_corrections; end
+
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#190
+  def expect_no_offenses(source, file = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#115
+  def expect_offense(source, file = T.unsafe(nil), severity: T.unsafe(nil), chomp: T.unsafe(nil), **replacements); end
+
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#104
+  def format_offense(source, **replacements); end
+
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#198
+  def parse_annotations(source, raise_error: T.unsafe(nil), **replacements); end
+
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#208
+  def parse_processed_source(source, file = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#216
+  def set_formatter_options; end
+end
+
+# Parsed representation of code annotated with the `^^^ Message` style
+#
+# source://rubocop//lib/rubocop/rspec/expect_offense.rb#223
+class RuboCop::RSpec::ExpectOffense::AnnotatedSource
+  # @note annotations are sorted so that reconstructing the annotation
+  #   text via {#to_s} is deterministic
+  # @param lines [Array<String>]
+  # @param annotations [Array<(Integer, String)>] each entry is the annotated line number and the annotation text
+  # @return [AnnotatedSource] a new instance of AnnotatedSource
+  #
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#255
+  def initialize(lines, annotations); end
+
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#260
+  def ==(other); end
+
+  # Construct annotated source string (like what we parse)
+  #
+  # Reconstruct a deterministic annotated source string. This is
+  # useful for eliminating semantically irrelevant annotation
+  # ordering differences.
+  #
+  # @example standardization
+  #   source1 = AnnotatedSource.parse(<<-RUBY)
+  #   line1
+  #   ^ Annotation 1
+  #   ^^ Annotation 2
+  #   RUBY
+  #
+  #   source2 = AnnotatedSource.parse(<<-RUBY)
+  #   line1
+  #   ^^ Annotation 2
+  #   ^ Annotation 1
+  #   RUBY
+  #
+  #   source1.to_s == source2.to_s # => true
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#302
+  def inspect; end
+
+  # Dirty hack: expectations with [...] are rewritten when they match
+  # This way the diff is clean.
+  #
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#266
+  def match_annotations?(other); end
+
+  # Return the plain source code without annotations
+  #
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#316
+  def plain_source; end
+
+  # Construct annotated source string (like what we parse)
+  #
+  # Reconstruct a deterministic annotated source string. This is
+  # useful for eliminating semantically irrelevant annotation
+  # ordering differences.
+  #
+  # @example standardization
+  #
+  #   source1 = AnnotatedSource.parse(<<-RUBY)
+  #   line1
+  #   ^ Annotation 1
+  #   ^^ Annotation 2
+  #   RUBY
+  #
+  #   source2 = AnnotatedSource.parse(<<-RUBY)
+  #   line1
+  #   ^^ Annotation 2
+  #   ^ Annotation 1
+  #   RUBY
+  #
+  #   source1.to_s == source2.to_s # => true
+  # @return [String]
+  #
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#302
+  def to_s; end
+
+  # Annotate the source code with the RuboCop offenses provided
+  #
+  # @param offenses [Array<RuboCop::Cop::Offense>]
+  # @return [self]
+  #
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#325
+  def with_offense_annotations(offenses); end
+
+  protected
+
+  # Returns the value of attribute annotations.
+  #
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#340
+  def annotations; end
+
+  # Returns the value of attribute lines.
+  #
+  # source://rubocop//lib/rubocop/rspec/expect_offense.rb#340
+  def lines; end
+
+  class << self
+    # Separates annotation lines from source lines. Tracks the real
+    # source line number that each annotation corresponds to.
+    #
+    # @param annotated_source [String] string passed to the matchers
+    # @return [AnnotatedSource]
+    #
+    # source://rubocop//lib/rubocop/rspec/expect_offense.rb#233
+    def parse(annotated_source); end
+  end
+end
+
+# source://rubocop//lib/rubocop/rspec/expect_offense.rb#225
+RuboCop::RSpec::ExpectOffense::AnnotatedSource::ABBREV = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/rspec/expect_offense.rb#224
+RuboCop::RSpec::ExpectOffense::AnnotatedSource::ANNOTATION_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# Common methods and behaviors for dealing with remote config files.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/remote_config.rb#9
+class RuboCop::RemoteConfig
+  # @api private
+  # @return [RemoteConfig] a new instance of RemoteConfig
+  #
+  # source://rubocop//lib/rubocop/remote_config.rb#14
+  def initialize(url, base_dir); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/remote_config.rb#23
+  def file; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/remote_config.rb#36
+  def inherit_from_remote(file, path); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/remote_config.rb#10
+  def uri; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/remote_config.rb#99
+  def cache_name_from_uri; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/remote_config.rb#82
+  def cache_path; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/remote_config.rb#86
+  def cache_path_exists?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/remote_config.rb#90
+  def cache_path_expired?; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/remote_config.rb#105
+  def cloned_url; end
+
+  # @api private
+  # @yield [request]
+  #
+  # source://rubocop//lib/rubocop/remote_config.rb#57
+  def generate_request(uri); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/remote_config.rb#66
+  def handle_response(response, limit, &block); end
+
+  # @api private
+  # @raise [ArgumentError]
+  #
+  # source://rubocop//lib/rubocop/remote_config.rb#44
+  def request(uri = T.unsafe(nil), limit = T.unsafe(nil), &block); end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/remote_config.rb#12
+RuboCop::RemoteConfig::CACHE_LIFETIME = T.let(T.unsafe(nil), Integer)
+
+# Provides functionality for caching RuboCop runs.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/result_cache.rb#11
+class RuboCop::ResultCache
+  # @api private
+  # @return [ResultCache] a new instance of ResultCache
+  #
+  # source://rubocop//lib/rubocop/result_cache.rb#87
+  def initialize(file, team, options, config_store, cache_root = T.unsafe(nil)); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/result_cache.rb#100
+  def debug?; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/result_cache.rb#108
+  def load; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/result_cache.rb#85
+  def path; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/result_cache.rb#113
+  def save(offenses); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/result_cache.rb#104
+  def valid?; end
+
+  private
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/result_cache.rb#146
+  def any_symlink?(path); end
+
+  # We combine team and options into a single "context" checksum to avoid
+  # making file names that are too long for some filesystems to handle.
+  # This context is for anything that's not (1) the RuboCop executable
+  # checksum or (2) the inspected file checksum.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/result_cache.rb#229
+  def context_checksum(team, options); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/result_cache.rb#189
+  def digest(path); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/result_cache.rb#157
+  def file_checksum(file, config_store); end
+
+  # Return a hash of the options given at invocation, minus the ones that have
+  # no effect on which offenses and disabled line ranges are found, and thus
+  # don't affect caching.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/result_cache.rb#220
+  def relevant_options_digest(options); end
+
+  # The checksum of the RuboCop program running the inspection.
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/result_cache.rb#174
+  def rubocop_checksum; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/result_cache.rb#200
+  def rubocop_extra_features; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/result_cache.rb#142
+  def symlink_protection_triggered?(path); end
+
+  class << self
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/result_cache.rb#81
+    def allow_symlinks_in_cache_location?(config_store); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/result_cache.rb#75
+    def cache_root(config_store); end
+
+    # Remove old files so that the cache doesn't grow too big. When the
+    # threshold MaxFilesInCache has been exceeded, the oldest 50% of all the
+    # files in the cache are removed. The reason for removing so much is that
+    # cleaning should be done relatively seldom, since there is a slight risk
+    # that some other RuboCop process was just about to read the file, when
+    # there's parallel execution and the cache is shared.
+    #
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/result_cache.rb#28
+    def cleanup(config_store, verbose, cache_root = T.unsafe(nil)); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/result_cache.rb#170
+    def inhibit_cleanup; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/result_cache.rb#170
+    def inhibit_cleanup=(_arg0); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/result_cache.rb#42
+    def rubocop_required_features; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/result_cache.rb#42
+    def rubocop_required_features=(_arg0); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/result_cache.rb#170
+    def source_checksum; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/result_cache.rb#170
+    def source_checksum=(_arg0); end
+
+    private
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/result_cache.rb#65
+    def remove_files(files, dirs, remove_count); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/result_cache.rb#52
+    def remove_oldest_files(files, dirs, cache_root, verbose); end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://rubocop//lib/rubocop/result_cache.rb#48
+    def requires_file_removal?(file_count, config_store); end
+  end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/result_cache.rb#16
+RuboCop::ResultCache::DL_EXTENSIONS = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/result_cache.rb#12
+RuboCop::ResultCache::NON_CHANGING = T.let(T.unsafe(nil), Array)
+
+# This class handles the processing of files, which includes dealing with
+# formatters and letting cops inspect the files.
+#
+# source://rubocop//lib/rubocop/runner.rb#8
+class RuboCop::Runner
+  # @return [Runner] a new instance of Runner
+  #
+  # source://rubocop//lib/rubocop/runner.rb#63
+  def initialize(options, config_store); end
+
+  # Sets the attribute aborting
+  #
+  # @param value the value to set the attribute aborting to.
+  #
+  # source://rubocop//lib/rubocop/runner.rb#61
+  def aborting=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/runner.rb#87
+  def aborting?; end
+
+  # Returns the value of attribute errors.
+  #
+  # source://rubocop//lib/rubocop/runner.rb#60
+  def errors; end
+
+  # source://rubocop-md/1.2.4/lib/rubocop/markdown/rubocop_ext.rb#63
+  def file_finished(file, offenses); end
+
+  # source://rubocop-md/1.2.4/lib/rubocop/markdown/rubocop_ext.rb#57
+  def file_offense_cache(file); end
+
+  # source://rubocop-md/1.2.4/lib/rubocop/markdown/rubocop_ext.rb#49
+  def get_processed_source(*args); end
+
+  # source://rubocop//lib/rubocop/runner.rb#71
+  def run(paths); end
+
+  # Returns the value of attribute warnings.
+  #
+  # source://rubocop//lib/rubocop/runner.rb#60
+  def warnings; end
+
+  private
+
+  # source://rubocop//lib/rubocop/runner.rb#200
+  def add_redundant_disables(file, offenses, source); end
+
+  # source://rubocop//lib/rubocop/runner.rb#174
+  def cached_result(file, team); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/runner.rb#254
+  def cached_run?; end
+
+  # Check whether a run created source identical to a previous run, which
+  # means that we definitely have an infinite loop.
+  #
+  # source://rubocop//lib/rubocop/runner.rb#332
+  def check_for_infinite_loop(processed_source, offenses_by_iteration); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/runner.rb#226
+  def check_for_redundant_disables?(source); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/runner.rb#430
+  def considered_failure?(offense); end
+
+  # source://rubocop//lib/rubocop/runner.rb#463
+  def default_config(cop_name); end
+
+  # source://rubocop//lib/rubocop/runner.rb#276
+  def do_inspection_loop(file); end
+
+  # source://rubocop//lib/rubocop/runner.rb#137
+  def each_inspected_file(files); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/runner.rb#240
+  def except_redundant_cop_disable_directive?; end
+
+  # source://rubocop//lib/rubocop/runner.rb#361
+  def extract_ruby_sources(processed_source); end
+
+  # source://rubocop//lib/rubocop/runner.rb#166
+  def file_offenses(file); end
+
+  # source://rubocop//lib/rubocop/runner.rb#244
+  def file_started(file); end
+
+  # source://rubocop//lib/rubocop/runner.rb#410
+  def filter_cop_classes(cop_classes, config); end
+
+  # source://rubocop//lib/rubocop/runner.rb#108
+  def find_target_files(paths); end
+
+  # source://rubocop//lib/rubocop/runner.rb#421
+  def formatter_set; end
+
+  # source://rubocop//lib/rubocop/runner.rb#346
+  def inspect_file(processed_source, team = T.unsafe(nil)); end
+
+  # source://rubocop//lib/rubocop/runner.rb#119
+  def inspect_files(files); end
+
+  # source://rubocop//lib/rubocop/runner.rb#307
+  def iterate_until_no_changes(source, offenses_by_iteration); end
+
+  # source://rubocop//lib/rubocop/runner.rb#152
+  def list_files(paths); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/runner.rb#459
+  def mark_as_safe_by_config?(config); end
+
+  # source://rubocop//lib/rubocop/runner.rb#467
+  def minimum_severity_to_fail; end
+
+  # source://rubocop//lib/rubocop/runner.rb#371
+  def mobilize_team(processed_source); end
+
+  # source://rubocop//lib/rubocop/runner.rb#376
+  def mobilized_cop_classes(config); end
+
+  # source://rubocop//lib/rubocop/runner.rb#439
+  def offenses_to_report(offenses); end
+
+  # source://rubocop//lib/rubocop/runner.rb#156
+  def process_file(file); end
+
+  # source://rubocop//lib/rubocop/runner.rb#400
+  def qualify_option_cop_names; end
+
+  # @yield [cop]
+  #
+  # source://rubocop//lib/rubocop/runner.rb#232
+  def redundant_cop_disable_directive(file); end
+
+  # source://rubocop//lib/rubocop/runner.rb#266
+  def save_in_cache(cache, offenses); end
+
+  # A Cop::Team instance is stateful and may change when inspecting.
+  # The "standby" team for a given config is an initialized but
+  # otherwise dormant team that can be used for config- and option-
+  # level caching in ResultCache.
+  #
+  # source://rubocop//lib/rubocop/runner.rb#506
+  def standby_team(config); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/runner.rb#417
+  def style_guide_cops_only?(config); end
+
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/runner.rb#451
+  def supports_safe_autocorrect?(offense); end
+
+  # @yield [team]
+  #
+  # source://rubocop//lib/rubocop/runner.rb#215
+  def team_for_redundant_disables(file, offenses, source); end
+
+  # Warms up the RuboCop cache by forking a suitable number of RuboCop
+  # instances that each inspects its allotted group of files.
+  #
+  # source://rubocop//lib/rubocop/runner.rb#95
+  def warm_cache(target_files); end
+
+  class << self
+    # @return [Array<#call>]
+    #
+    # source://rubocop//lib/rubocop/runner.rb#33
+    def ruby_extractors; end
+
+    private
+
+    # @return [#call]
+    #
+    # source://rubocop//lib/rubocop/runner.rb#40
+    def default_ruby_extractor; end
+  end
+end
+
+# An exception indicating that the inspection loop got stuck correcting
+# offenses back and forth.
+#
+# source://rubocop//lib/rubocop/runner.rb#11
+class RuboCop::Runner::InfiniteCorrectionLoop < ::StandardError
+  # @return [InfiniteCorrectionLoop] a new instance of InfiniteCorrectionLoop
+  #
+  # source://rubocop//lib/rubocop/runner.rb#14
+  def initialize(path, offenses_by_iteration, loop_start: T.unsafe(nil)); end
+
+  # Returns the value of attribute offenses.
+  #
+  # source://rubocop//lib/rubocop/runner.rb#12
+  def offenses; end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/runner.rb#53
+RuboCop::Runner::MAX_ITERATIONS = T.let(T.unsafe(nil), Integer)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/runner.rb#56
+RuboCop::Runner::REDUNDANT_COP_DISABLE_DIRECTIVE_RULES = T.let(T.unsafe(nil), Array)
+
+# Take a string with embedded escapes, and convert the escapes as the Ruby
+# interpreter would when reading a double-quoted string literal.
+# For example, "\\n" will be converted to "\n".
+#
+# source://rubocop//lib/rubocop/string_interpreter.rb#7
+class RuboCop::StringInterpreter
+  class << self
+    # source://rubocop//lib/rubocop/string_interpreter.rb#24
+    def interpret(string); end
+
+    private
+
+    # source://rubocop//lib/rubocop/string_interpreter.rb#51
+    def interpret_hex(escape); end
+
+    # source://rubocop//lib/rubocop/string_interpreter.rb#55
+    def interpret_octal(escape); end
+
+    # source://rubocop//lib/rubocop/string_interpreter.rb#33
+    def interpret_string_escape(escape); end
+
+    # source://rubocop//lib/rubocop/string_interpreter.rb#43
+    def interpret_unicode(escape); end
+  end
+end
+
+# source://rubocop//lib/rubocop/string_interpreter.rb#8
+RuboCop::StringInterpreter::STRING_ESCAPES = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/string_interpreter.rb#12
+RuboCop::StringInterpreter::STRING_ESCAPE_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# This class finds target files to inspect by scanning the directory tree and picking ruby files.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/target_finder.rb#6
+class RuboCop::TargetFinder
+  # @api private
+  # @return [TargetFinder] a new instance of TargetFinder
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#9
+  def initialize(config_store, options = T.unsafe(nil)); end
+
+  # Generate a list of target files by expanding globbing patterns (if any). If args is empty,
+  # recursively find all Ruby source files under the current directory
+  #
+  # @api private
+  # @return [Array] array of file paths
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#17
+  def find(args, mode); end
+
+  # Search for files recursively starting at the given base directory using the given flags that
+  # determine how the match is made. Excluded files will be removed later by the caller, but as an
+  # optimization find_files removes the top level directories that are excluded in configuration
+  # in the normal way (dir/**/*).
+  #
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#58
+  def find_files(base_dir, flags); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop-md/1.2.4/lib/rubocop/markdown/rubocop_ext.rb#91
+  def ruby_file?(file); end
+
+  # Finds all Ruby source files under the current or other supplied directory. A Ruby source file
+  # is defined as a file with the `.rb` extension or a file with no extension that has a ruby
+  # shebang line as its first line.
+  # It is possible to specify includes and excludes using the config file, so you can include
+  # other Ruby files like Rakefiles and gemspecs.
+  #
+  # @api private
+  # @param base_dir Root directory under which to search for
+  #   ruby source files
+  # @return [Array] Array of filenames
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#41
+  def target_files_in_dir(base_dir = T.unsafe(nil)); end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#120
+  def all_cops_include; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#106
+  def combined_exclude_glob_patterns(base_dir); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#172
+  def configured_include?(file); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#208
+  def debug?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#212
+  def fail_fast?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#200
+  def force_exclusion?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#204
+  def ignore_parent_exclusion?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#145
+  def included_file?(file); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#191
+  def order; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#124
+  def process_explicit_path(path, mode); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#176
+  def ruby_executable?(file); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#157
+  def ruby_extension?(file); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#161
+  def ruby_extensions; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#168
+  def ruby_filename?(file); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#113
+  def ruby_filenames; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#187
+  def ruby_interpreters(file); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#153
+  def stdin?; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#98
+  def symlink_excluded_or_infinite_loop?(base_dir, current_dir, exclude_pattern, flags); end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#73
+  def to_inspect?(file, hidden_files, base_dir_config); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#82
+  def wanted_dir_patterns(base_dir, exclude_pattern, flags); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_finder.rb#134
+  def without_excluded(files); end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/target_finder.rb#7
+RuboCop::TargetFinder::HIDDEN_PATH_SUBSTRING = T.let(T.unsafe(nil), String)
+
+# The kind of Ruby that code inspected by RuboCop is written in.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#6
+class RuboCop::TargetRuby
+  # @api private
+  # @return [TargetRuby] a new instance of TargetRuby
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#258
+  def initialize(config); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#274
+  def rubocop_version_with_support; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#262
+  def source; end
+
+  # @api private
+  # @return [Boolean]
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#270
+  def supported?; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#266
+  def version; end
+
+  class << self
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/target_ruby.rb#244
+    def supported_versions; end
+  end
+end
+
+# The lock file of Bundler may identify the target ruby version.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#191
+class RuboCop::TargetRuby::BundlerLockFile < ::RuboCop::TargetRuby::Source
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#192
+  def name; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#225
+  def bundler_lock_file_path; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#198
+  def find_version; end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#8
+RuboCop::TargetRuby::DEFAULT_VERSION = T.let(T.unsafe(nil), Float)
+
+# If all else fails, a default version will be picked.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#232
+class RuboCop::TargetRuby::Default < ::RuboCop::TargetRuby::Source
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#233
+  def name; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#239
+  def find_version; end
+end
+
+# The target ruby version may be found in a .gemspec file.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#53
+class RuboCop::TargetRuby::GemspecFile < ::RuboCop::TargetRuby::Source
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # source://rubocop//lib/rubocop/target_ruby.rb#62
+  def gem_requirement_versions(param0 = T.unsafe(nil)); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#68
+  def name; end
+
+  # source://rubocop//lib/rubocop/target_ruby.rb#57
+  def required_ruby_version(param0); end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#123
+  def find_minimal_known_ruby(right_hand_side); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#74
+  def find_version; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#84
+  def gemspec_filepath; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#119
+  def version_from_array(array); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#98
+  def version_from_gemspec_file(file); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#107
+  def version_from_right_hand_side(right_hand_side); end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#7
+RuboCop::TargetRuby::KNOWN_RUBIES = T.let(T.unsafe(nil), Array)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#10
+RuboCop::TargetRuby::OBSOLETE_RUBIES = T.let(T.unsafe(nil), Hash)
+
+# The target ruby version may be configured in RuboCop's config.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#39
+class RuboCop::TargetRuby::RuboCopConfig < ::RuboCop::TargetRuby::Source
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#40
+  def name; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#46
+  def find_version; end
+end
+
+# The target ruby version may be found in a .ruby-version file.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#137
+class RuboCop::TargetRuby::RubyVersionFile < ::RuboCop::TargetRuby::Source
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#141
+  def name; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#147
+  def filename; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#155
+  def find_version; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#151
+  def pattern; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#162
+  def version_file; end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#138
+RuboCop::TargetRuby::RubyVersionFile::RUBY_VERSION_FILENAME = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#139
+RuboCop::TargetRuby::RubyVersionFile::RUBY_VERSION_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#248
+RuboCop::TargetRuby::SOURCES = T.let(T.unsafe(nil), Array)
+
+# A place where information about a target ruby version is found.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#24
+class RuboCop::TargetRuby::Source
+  # @api private
+  # @return [Source] a new instance of Source
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#27
+  def initialize(config); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#25
+  def name; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#32
+  def to_s; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#25
+  def version; end
+end
+
+# The target ruby version may be found in a .tool-versions file, in a line
+# starting with `ruby`.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#170
+class RuboCop::TargetRuby::ToolVersionsFile < ::RuboCop::TargetRuby::RubyVersionFile
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#174
+  def name; end
+
+  private
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#180
+  def filename; end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/target_ruby.rb#184
+  def pattern; end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#171
+RuboCop::TargetRuby::ToolVersionsFile::TOOL_VERSIONS_FILENAME = T.let(T.unsafe(nil), String)
+
+# @api private
+#
+# source://rubocop//lib/rubocop/target_ruby.rb#172
+RuboCop::TargetRuby::ToolVersionsFile::TOOL_VERSIONS_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# source://rubocop//lib/rubocop/ast_aliases.rb#7
+RuboCop::Token = RuboCop::AST::Token
+
+# This module contains a collection of useful utility methods.
+#
+# source://rubocop//lib/rubocop/util.rb#5
+module RuboCop::Util
+  class << self
+    # source://rubocop//lib/rubocop/util.rb#6
+    def silence_warnings; end
+  end
+end
+
+# source://rubocop//lib/rubocop/error.rb#10
+class RuboCop::ValidationError < ::RuboCop::Error; end
+
+# This module holds the RuboCop version information.
+#
+# source://rubocop//lib/rubocop/version.rb#5
+module RuboCop::Version
+  class << self
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/version.rb#110
+    def document_version; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/version.rb#60
+    def extension_versions(env); end
+
+    # Returns feature version in one of two ways:
+    #
+    # * Find by RuboCop core version style (e.g. rubocop-performance, rubocop-rspec)
+    # * Find by `bundle gem` version style (e.g. rubocop-rake)
+    #
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/version.rb#94
+    def feature_version(feature); end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/version.rb#45
+    def parser_version; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/version.rb#115
+    def server_mode; end
+
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/version.rb#22
+    def version(debug: T.unsafe(nil), env: T.unsafe(nil)); end
+  end
+end
+
+# source://rubocop//lib/rubocop/version.rb#13
+RuboCop::Version::CANONICAL_FEATURE_NAMES = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/version.rb#17
+RuboCop::Version::EXTENSION_PATH_NAMES = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop//lib/rubocop/version.rb#8
+RuboCop::Version::MSG = T.let(T.unsafe(nil), String)
+
+# source://rubocop//lib/rubocop/version.rb#6
+RuboCop::Version::STRING = T.let(T.unsafe(nil), String)
+
+# A Warning exception is different from an Offense with severity 'warning'
+# When a Warning is raised, this means that RuboCop was unable to perform a
+# requested operation (such as inspecting or correcting a source file) due to
+# user error
+# For example, a configuration value in .rubocop.yml might be malformed
+#
+# source://rubocop//lib/rubocop/warning.rb#9
+class RuboCop::Warning < ::StandardError; end
+
+# Find duplicated keys from YAML.
+#
+# @api private
+#
+# source://rubocop//lib/rubocop/yaml_duplication_checker.rb#6
+module RuboCop::YAMLDuplicationChecker
+  class << self
+    # @api private
+    #
+    # source://rubocop//lib/rubocop/yaml_duplication_checker.rb#7
+    def check(yaml_string, filename, &on_duplicated); end
+  end
+end
+
+# @api private
+#
+# source://rubocop//lib/rubocop/yaml_duplication_checker.rb#14
+class RuboCop::YAMLDuplicationChecker::DuplicationCheckHandler < ::Psych::TreeBuilder
+  # @api private
+  # @return [DuplicationCheckHandler] a new instance of DuplicationCheckHandler
+  #
+  # source://rubocop//lib/rubocop/yaml_duplication_checker.rb#15
+  def initialize(&block); end
+
+  # @api private
+  #
+  # source://rubocop//lib/rubocop/yaml_duplication_checker.rb#20
+  def end_mapping; end
+end
+
+# Extensions to the core String class
+#
+# source://rubocop//lib/rubocop/core_ext/string.rb#4
+class String
+  include ::Comparable
+
+  # Checks whether a string is blank. A string is considered blank if it
+  # is either empty or contains only whitespace characters.
+  #
+  # @example
+  #   ''.blank?       #=> true
+  #   '    '.blank?   #=> true
+  #   '  test'.blank? #=> false
+  # @return [Boolean] true is the string is blank, false otherwise
+  #
+  # source://rubocop//lib/rubocop/core_ext/string.rb#15
+  def blank?; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/ruby-lsp@0.21.2.rbi b/Library/Homebrew/sorbet/rbi/gems/ruby-lsp@0.21.2.rbi
new file mode 100644
index 0000000000000..62a7db7a953c3
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/ruby-lsp@0.21.2.rbi
@@ -0,0 +1,12 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `ruby-lsp` gem.
+# Please instead update this file by running `bin/tapioca gem ruby-lsp`.
+
+
+# source://ruby-lsp//lib/ruby-lsp.rb#4
+module RubyLsp; end
+
+# source://ruby-lsp//lib/ruby-lsp.rb#5
+RubyLsp::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/ruby-macho@3.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/ruby-macho@3.0.0.rbi
deleted file mode 100644
index d271ed05e1f0a..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/ruby-macho@3.0.0.rbi
+++ /dev/null
@@ -1,1003 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `ruby-macho` gem.
-# Please instead update this file by running `bin/tapioca gem ruby-macho`.
-
-module MachO
-  class << self
-    def codesign!(filename); end
-    def open(filename); end
-  end
-end
-
-class MachO::CPUSubtypeError < ::MachO::MachOError
-  def initialize(cputype, cpusubtype); end
-end
-
-class MachO::CPUTypeError < ::MachO::MachOError
-  def initialize(cputype); end
-end
-
-class MachO::CodeSigningError < ::MachO::MachOError; end
-class MachO::CompressedMachOError < ::MachO::MachOError; end
-class MachO::DecompressionError < ::MachO::MachOError; end
-
-class MachO::DylibIdMissingError < ::MachO::RecoverableModificationError
-  def initialize; end
-end
-
-class MachO::DylibUnknownError < ::MachO::RecoverableModificationError
-  def initialize(dylib); end
-end
-
-class MachO::FatArchOffsetOverflowError < ::MachO::MachOError
-  def initialize(offset); end
-end
-
-class MachO::FatBinaryError < ::MachO::MachOError
-  def initialize; end
-end
-
-class MachO::FatFile
-  extend ::Forwardable
-
-  def initialize(filename, **opts); end
-
-  def add_rpath(path, options = T.unsafe(nil)); end
-  def bundle?(*args, &block); end
-  def change_dylib(old_name, new_name, options = T.unsafe(nil)); end
-  def change_dylib_id(new_id, options = T.unsafe(nil)); end
-  def change_install_name(old_name, new_name, options = T.unsafe(nil)); end
-  def change_rpath(old_path, new_path, options = T.unsafe(nil)); end
-  def core?(*args, &block); end
-  def delete_rpath(path, options = T.unsafe(nil)); end
-  def dsym?(*args, &block); end
-  def dylib?(*args, &block); end
-  def dylib_id(*args, &block); end
-  def dylib_id=(new_id, options = T.unsafe(nil)); end
-  def dylib_load_commands; end
-  def dylinker?(*args, &block); end
-  def executable?(*args, &block); end
-  def extract(cputype); end
-  def fat_archs; end
-  def filename; end
-  def filename=(_arg0); end
-  def filetype(*args, &block); end
-  def fvmlib?(*args, &block); end
-  def header; end
-  def initialize_from_bin(bin, opts); end
-  def kext?(*args, &block); end
-  def linked_dylibs; end
-  def machos; end
-  def magic(*args, &block); end
-  def magic_string; end
-  def object?(*args, &block); end
-  def options; end
-  def populate_fields; end
-  def preload?(*args, &block); end
-  def rpaths; end
-  def serialize; end
-  def to_h; end
-  def write(filename); end
-  def write!; end
-
-  private
-
-  def canonical_macho; end
-  def each_macho(options = T.unsafe(nil)); end
-  def populate_fat_archs; end
-  def populate_fat_header; end
-  def populate_machos; end
-  def repopulate_raw_machos; end
-
-  class << self
-    def new_from_bin(bin, **opts); end
-    def new_from_machos(*machos, fat64: T.unsafe(nil)); end
-  end
-end
-
-class MachO::FiletypeError < ::MachO::MachOError
-  def initialize(num); end
-end
-
-class MachO::HeaderPadError < ::MachO::ModificationError
-  def initialize(filename); end
-end
-
-module MachO::Headers; end
-MachO::Headers::COMPRESSED_MAGIC = T.let(T.unsafe(nil), Integer)
-MachO::Headers::COMP_TYPE_FASTLIB = T.let(T.unsafe(nil), Integer)
-MachO::Headers::COMP_TYPE_LZSS = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_ARCH_ABI32 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_ARCH_ABI64 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPES = T.let(T.unsafe(nil), Hash)
-MachO::Headers::CPU_SUBTYPE_486 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_486SX = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_586 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM64E = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM64_32_V8 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM64_ALL = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM64_V8 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM_ALL = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM_V4T = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM_V5TEJ = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM_V6 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM_V6M = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM_V7 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM_V7EM = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM_V7F = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM_V7K = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM_V7M = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM_V7S = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM_V8 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_ARM_XSCALE = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_I386 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_LIB64 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_MASK = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_MC68030 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_MC68030_ONLY = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_MC68040 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_MC680X0_ALL = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_MC88000_ALL = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_MC88100 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_MC88110 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_MMAX_JPC = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_PENT = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_PENTII_M3 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_PENTII_M5 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_PENTIUM_4 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_PENTPRO = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_POWERPC64_ALL = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_POWERPC_601 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_POWERPC_602 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_POWERPC_603 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_POWERPC_603E = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_POWERPC_603EV = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_POWERPC_604 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_POWERPC_604E = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_POWERPC_620 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_POWERPC_7400 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_POWERPC_7450 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_POWERPC_750 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_POWERPC_970 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_POWERPC_ALL = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_X86_64_ALL = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_SUBTYPE_X86_64_H = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_TYPES = T.let(T.unsafe(nil), Hash)
-MachO::Headers::CPU_TYPE_ANY = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_TYPE_ARM = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_TYPE_ARM64 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_TYPE_ARM64_32 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_TYPE_I386 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_TYPE_MC680X0 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_TYPE_MC88000 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_TYPE_POWERPC = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_TYPE_POWERPC64 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::CPU_TYPE_X86_64 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::FAT_CIGAM = T.let(T.unsafe(nil), Integer)
-MachO::Headers::FAT_CIGAM_64 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::FAT_MAGIC = T.let(T.unsafe(nil), Integer)
-MachO::Headers::FAT_MAGIC_64 = T.let(T.unsafe(nil), Integer)
-
-class MachO::Headers::FatArch < ::MachO::MachOStructure
-  def initialize(cputype, cpusubtype, offset, size, align); end
-
-  def align; end
-  def cpusubtype; end
-  def cputype; end
-  def offset; end
-  def serialize; end
-  def size; end
-  def to_h; end
-end
-
-class MachO::Headers::FatArch64 < ::MachO::Headers::FatArch
-  def initialize(cputype, cpusubtype, offset, size, align, reserved = T.unsafe(nil)); end
-
-  def reserved; end
-  def serialize; end
-  def to_h; end
-end
-
-MachO::Headers::FatArch64::FORMAT = T.let(T.unsafe(nil), String)
-MachO::Headers::FatArch64::SIZEOF = T.let(T.unsafe(nil), Integer)
-MachO::Headers::FatArch::FORMAT = T.let(T.unsafe(nil), String)
-MachO::Headers::FatArch::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::Headers::FatHeader < ::MachO::MachOStructure
-  def initialize(magic, nfat_arch); end
-
-  def magic; end
-  def nfat_arch; end
-  def serialize; end
-  def to_h; end
-end
-
-MachO::Headers::FatHeader::FORMAT = T.let(T.unsafe(nil), String)
-MachO::Headers::FatHeader::SIZEOF = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_BUNDLE = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_CIGAM = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_CIGAM_64 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_CORE = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_DSYM = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_DYLIB = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_DYLIB_STUB = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_DYLINKER = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_EXECUTE = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_FILESET = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_FILETYPES = T.let(T.unsafe(nil), Hash)
-MachO::Headers::MH_FLAGS = T.let(T.unsafe(nil), Hash)
-MachO::Headers::MH_FVMLIB = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_KEXT_BUNDLE = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_MAGIC = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_MAGICS = T.let(T.unsafe(nil), Hash)
-MachO::Headers::MH_MAGIC_64 = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_OBJECT = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MH_PRELOAD = T.let(T.unsafe(nil), Integer)
-
-class MachO::Headers::MachHeader < ::MachO::MachOStructure
-  def initialize(magic, cputype, cpusubtype, filetype, ncmds, sizeofcmds, flags); end
-
-  def alignment; end
-  def bundle?; end
-  def core?; end
-  def cpusubtype; end
-  def cputype; end
-  def dsym?; end
-  def dylib?; end
-  def dylinker?; end
-  def executable?; end
-  def fileset?; end
-  def filetype; end
-  def flag?(flag); end
-  def flags; end
-  def fvmlib?; end
-  def kext?; end
-  def magic; end
-  def magic32?; end
-  def magic64?; end
-  def ncmds; end
-  def object?; end
-  def preload?; end
-  def sizeofcmds; end
-  def to_h; end
-end
-
-class MachO::Headers::MachHeader64 < ::MachO::Headers::MachHeader
-  def initialize(magic, cputype, cpusubtype, filetype, ncmds, sizeofcmds, flags, reserved); end
-
-  def reserved; end
-  def to_h; end
-end
-
-MachO::Headers::MachHeader64::FORMAT = T.let(T.unsafe(nil), String)
-MachO::Headers::MachHeader64::SIZEOF = T.let(T.unsafe(nil), Integer)
-MachO::Headers::MachHeader::FORMAT = T.let(T.unsafe(nil), String)
-MachO::Headers::MachHeader::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::Headers::PrelinkedKernelHeader < ::MachO::MachOStructure
-  def initialize(signature, compress_type, adler32, uncompressed_size, compressed_size, prelink_version, reserved, platform_name, root_path); end
-
-  def adler32; end
-  def compress_type; end
-  def compressed_size; end
-  def kaslr?; end
-  def lzss?; end
-  def lzvn?; end
-  def platform_name; end
-  def prelink_version; end
-  def reserved; end
-  def root_path; end
-  def signature; end
-  def to_h; end
-  def uncompressed_size; end
-end
-
-MachO::Headers::PrelinkedKernelHeader::FORMAT = T.let(T.unsafe(nil), String)
-MachO::Headers::PrelinkedKernelHeader::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::JavaClassFileError < ::MachO::NotAMachOError
-  def initialize; end
-end
-
-class MachO::LCStrMalformedError < ::MachO::MachOError
-  def initialize(lc); end
-end
-
-class MachO::LoadCommandCreationArityError < ::MachO::MachOError
-  def initialize(cmd_sym, expected_arity, actual_arity); end
-end
-
-class MachO::LoadCommandError < ::MachO::MachOError
-  def initialize(num); end
-end
-
-class MachO::LoadCommandNotCreatableError < ::MachO::MachOError
-  def initialize(cmd_sym); end
-end
-
-class MachO::LoadCommandNotSerializableError < ::MachO::MachOError
-  def initialize(cmd_sym); end
-end
-
-module MachO::LoadCommands; end
-
-class MachO::LoadCommands::BuildVersionCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, platform, minos, sdk, ntools); end
-
-  def minos; end
-  def minos_string; end
-  def platform; end
-  def sdk; end
-  def sdk_string; end
-  def to_h; end
-  def tool_entries; end
-end
-
-MachO::LoadCommands::BuildVersionCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::BuildVersionCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::BuildVersionCommand::ToolEntries
-  def initialize(view, ntools); end
-
-  def tools; end
-end
-
-class MachO::LoadCommands::BuildVersionCommand::ToolEntries::Tool
-  def initialize(tool, version); end
-
-  def to_h; end
-  def tool; end
-  def version; end
-end
-
-MachO::LoadCommands::CREATABLE_LOAD_COMMANDS = T.let(T.unsafe(nil), Array)
-MachO::LoadCommands::DYLIB_LOAD_COMMANDS = T.let(T.unsafe(nil), Array)
-
-class MachO::LoadCommands::DyldInfoCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, rebase_off, rebase_size, bind_off, bind_size, weak_bind_off, weak_bind_size, lazy_bind_off, lazy_bind_size, export_off, export_size); end
-
-  def bind_off; end
-  def bind_size; end
-  def export_off; end
-  def export_size; end
-  def lazy_bind_off; end
-  def lazy_bind_size; end
-  def rebase_off; end
-  def rebase_size; end
-  def to_h; end
-  def weak_bind_off; end
-  def weak_bind_size; end
-end
-
-MachO::LoadCommands::DyldInfoCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::DyldInfoCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::DylibCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, name, timestamp, current_version, compatibility_version); end
-
-  def compatibility_version; end
-  def current_version; end
-  def name; end
-  def serialize(context); end
-  def timestamp; end
-  def to_h; end
-end
-
-MachO::LoadCommands::DylibCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::DylibCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::DylinkerCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, name); end
-
-  def name; end
-  def serialize(context); end
-  def to_h; end
-end
-
-MachO::LoadCommands::DylinkerCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::DylinkerCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::DysymtabCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, ilocalsym, nlocalsym, iextdefsym, nextdefsym, iundefsym, nundefsym, tocoff, ntoc, modtaboff, nmodtab, extrefsymoff, nextrefsyms, indirectsymoff, nindirectsyms, extreloff, nextrel, locreloff, nlocrel); end
-
-  def extrefsymoff; end
-  def extreloff; end
-  def iextdefsym; end
-  def ilocalsym; end
-  def indirectsymoff; end
-  def iundefsym; end
-  def locreloff; end
-  def modtaboff; end
-  def nextdefsym; end
-  def nextrefsyms; end
-  def nextrel; end
-  def nindirectsyms; end
-  def nlocalsym; end
-  def nlocrel; end
-  def nmodtab; end
-  def ntoc; end
-  def nundefsym; end
-  def to_h; end
-  def tocoff; end
-end
-
-MachO::LoadCommands::DysymtabCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::DysymtabCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::EncryptionInfoCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, cryptoff, cryptsize, cryptid); end
-
-  def cryptid; end
-  def cryptoff; end
-  def cryptsize; end
-  def to_h; end
-end
-
-class MachO::LoadCommands::EncryptionInfoCommand64 < ::MachO::LoadCommands::EncryptionInfoCommand
-  def initialize(view, cmd, cmdsize, cryptoff, cryptsize, cryptid, pad); end
-
-  def pad; end
-  def to_h; end
-end
-
-MachO::LoadCommands::EncryptionInfoCommand64::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::EncryptionInfoCommand64::SIZEOF = T.let(T.unsafe(nil), Integer)
-MachO::LoadCommands::EncryptionInfoCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::EncryptionInfoCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::EntryPointCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, entryoff, stacksize); end
-
-  def entryoff; end
-  def stacksize; end
-  def to_h; end
-end
-
-MachO::LoadCommands::EntryPointCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::EntryPointCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::FilesetEntryCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, vmaddr, fileoff, entry_id, reserved); end
-
-  def entry_id; end
-  def fileoff; end
-  def reserved; end
-  def to_h; end
-  def vmaddr; end
-end
-
-MachO::LoadCommands::FilesetEntryCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::FilesetEntryCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::FvmfileCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, name, header_addr); end
-
-  def header_addr; end
-  def name; end
-  def to_h; end
-end
-
-MachO::LoadCommands::FvmfileCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::FvmfileCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::FvmlibCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, name, minor_version, header_addr); end
-
-  def header_addr; end
-  def minor_version; end
-  def name; end
-  def to_h; end
-end
-
-MachO::LoadCommands::FvmlibCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::FvmlibCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-class MachO::LoadCommands::IdentCommand < ::MachO::LoadCommands::LoadCommand; end
-MachO::LoadCommands::IdentCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::IdentCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-MachO::LoadCommands::LC_REQ_DYLD = T.let(T.unsafe(nil), Integer)
-MachO::LoadCommands::LC_STRUCTURES = T.let(T.unsafe(nil), Hash)
-MachO::LoadCommands::LOAD_COMMANDS = T.let(T.unsafe(nil), Hash)
-MachO::LoadCommands::LOAD_COMMAND_CONSTANTS = T.let(T.unsafe(nil), Hash)
-
-class MachO::LoadCommands::LinkeditDataCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, dataoff, datasize); end
-
-  def dataoff; end
-  def datasize; end
-  def to_h; end
-end
-
-MachO::LoadCommands::LinkeditDataCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::LinkeditDataCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::LinkerOptionCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, count); end
-
-  def count; end
-  def to_h; end
-end
-
-MachO::LoadCommands::LinkerOptionCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::LinkerOptionCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::LoadCommand < ::MachO::MachOStructure
-  def initialize(view, cmd, cmdsize); end
-
-  def cmd; end
-  def cmdsize; end
-  def offset; end
-  def serializable?; end
-  def serialize(context); end
-  def to_h; end
-  def to_s; end
-  def to_sym; end
-  def type; end
-  def view; end
-
-  class << self
-    def create(cmd_sym, *args); end
-    def new_from_bin(view); end
-  end
-end
-
-MachO::LoadCommands::LoadCommand::FORMAT = T.let(T.unsafe(nil), String)
-
-class MachO::LoadCommands::LoadCommand::LCStr
-  def initialize(lc, lc_str); end
-
-  def to_h; end
-  def to_i; end
-  def to_s; end
-end
-
-MachO::LoadCommands::LoadCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::LoadCommand::SerializationContext
-  def initialize(endianness, alignment); end
-
-  def alignment; end
-  def endianness; end
-
-  class << self
-    def context_for(macho); end
-  end
-end
-
-class MachO::LoadCommands::NoteCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, data_owner, offset, size); end
-
-  def data_owner; end
-  def offset; end
-  def size; end
-  def to_h; end
-end
-
-MachO::LoadCommands::NoteCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::NoteCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::PrebindCksumCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, cksum); end
-
-  def cksum; end
-  def to_h; end
-end
-
-MachO::LoadCommands::PrebindCksumCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::PrebindCksumCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::PreboundDylibCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, name, nmodules, linked_modules); end
-
-  def linked_modules; end
-  def name; end
-  def nmodules; end
-  def to_h; end
-end
-
-MachO::LoadCommands::PreboundDylibCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::PreboundDylibCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::RoutinesCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, init_address, init_module, reserved1, reserved2, reserved3, reserved4, reserved5, reserved6); end
-
-  def init_address; end
-  def init_module; end
-  def reserved1; end
-  def reserved2; end
-  def reserved3; end
-  def reserved4; end
-  def reserved5; end
-  def reserved6; end
-  def to_h; end
-end
-
-class MachO::LoadCommands::RoutinesCommand64 < ::MachO::LoadCommands::RoutinesCommand; end
-MachO::LoadCommands::RoutinesCommand64::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::RoutinesCommand64::SIZEOF = T.let(T.unsafe(nil), Integer)
-MachO::LoadCommands::RoutinesCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::RoutinesCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::RpathCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, path); end
-
-  def path; end
-  def serialize(context); end
-  def to_h; end
-end
-
-MachO::LoadCommands::RpathCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::RpathCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-MachO::LoadCommands::SEGMENT_FLAGS = T.let(T.unsafe(nil), Hash)
-MachO::LoadCommands::SEGMENT_NAMES = T.let(T.unsafe(nil), Hash)
-
-class MachO::LoadCommands::SegmentCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, segname, vmaddr, vmsize, fileoff, filesize, maxprot, initprot, nsects, flags); end
-
-  def fileoff; end
-  def filesize; end
-  def flag?(flag); end
-  def flags; end
-  def guess_align; end
-  def initprot; end
-  def maxprot; end
-  def nsects; end
-  def sections; end
-  def segname; end
-  def to_h; end
-  def vmaddr; end
-  def vmsize; end
-end
-
-class MachO::LoadCommands::SegmentCommand64 < ::MachO::LoadCommands::SegmentCommand; end
-MachO::LoadCommands::SegmentCommand64::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::SegmentCommand64::SIZEOF = T.let(T.unsafe(nil), Integer)
-MachO::LoadCommands::SegmentCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::SegmentCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::SourceVersionCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, version); end
-
-  def to_h; end
-  def version; end
-  def version_string; end
-end
-
-MachO::LoadCommands::SourceVersionCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::SourceVersionCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::SubClientCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, sub_client); end
-
-  def sub_client; end
-  def to_h; end
-end
-
-MachO::LoadCommands::SubClientCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::SubClientCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::SubFrameworkCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, umbrella); end
-
-  def to_h; end
-  def umbrella; end
-end
-
-MachO::LoadCommands::SubFrameworkCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::SubFrameworkCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::SubLibraryCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, sub_library); end
-
-  def sub_library; end
-  def to_h; end
-end
-
-MachO::LoadCommands::SubLibraryCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::SubLibraryCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::SubUmbrellaCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, sub_umbrella); end
-
-  def sub_umbrella; end
-  def to_h; end
-end
-
-MachO::LoadCommands::SubUmbrellaCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::SubUmbrellaCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::SymsegCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, offset, size); end
-
-  def offset; end
-  def size; end
-  def to_h; end
-end
-
-MachO::LoadCommands::SymsegCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::SymsegCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::SymtabCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, symoff, nsyms, stroff, strsize); end
-
-  def nsyms; end
-  def stroff; end
-  def strsize; end
-  def symoff; end
-  def to_h; end
-end
-
-MachO::LoadCommands::SymtabCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::SymtabCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-class MachO::LoadCommands::ThreadCommand < ::MachO::LoadCommands::LoadCommand; end
-MachO::LoadCommands::ThreadCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::ThreadCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::TwolevelHintsCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, htoffset, nhints); end
-
-  def htoffset; end
-  def nhints; end
-  def table; end
-  def to_h; end
-end
-
-MachO::LoadCommands::TwolevelHintsCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::TwolevelHintsCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::TwolevelHintsCommand::TwolevelHintsTable
-  def initialize(view, htoffset, nhints); end
-
-  def hints; end
-end
-
-class MachO::LoadCommands::TwolevelHintsCommand::TwolevelHintsTable::TwolevelHint
-  def initialize(blob); end
-
-  def isub_image; end
-  def itoc; end
-  def to_h; end
-end
-
-class MachO::LoadCommands::UUIDCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, uuid); end
-
-  def to_h; end
-  def uuid; end
-  def uuid_string; end
-end
-
-MachO::LoadCommands::UUIDCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::UUIDCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::LoadCommands::VersionMinCommand < ::MachO::LoadCommands::LoadCommand
-  def initialize(view, cmd, cmdsize, version, sdk); end
-
-  def sdk; end
-  def sdk_string; end
-  def to_h; end
-  def version; end
-  def version_string; end
-end
-
-MachO::LoadCommands::VersionMinCommand::FORMAT = T.let(T.unsafe(nil), String)
-MachO::LoadCommands::VersionMinCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::MachOBinaryError < ::MachO::MachOError
-  def initialize; end
-end
-
-class MachO::MachOError < ::RuntimeError; end
-
-class MachO::MachOFile
-  extend ::Forwardable
-
-  def initialize(filename, **opts); end
-
-  def [](name); end
-  def add_command(lc, options = T.unsafe(nil)); end
-  def add_rpath(path, _options = T.unsafe(nil)); end
-  def alignment(*args, &block); end
-  def bundle?(*args, &block); end
-  def change_dylib(old_name, new_name, _options = T.unsafe(nil)); end
-  def change_dylib_id(new_id, _options = T.unsafe(nil)); end
-  def change_install_name(old_name, new_name, _options = T.unsafe(nil)); end
-  def change_rpath(old_path, new_path, options = T.unsafe(nil)); end
-  def command(name); end
-  def core?(*args, &block); end
-  def cpusubtype; end
-  def cputype; end
-  def delete_command(lc, options = T.unsafe(nil)); end
-  def delete_rpath(path, options = T.unsafe(nil)); end
-  def dsym?(*args, &block); end
-  def dylib?(*args, &block); end
-  def dylib_id; end
-  def dylib_id=(new_id, _options = T.unsafe(nil)); end
-  def dylib_load_commands; end
-  def dylinker?(*args, &block); end
-  def endianness; end
-  def executable?(*args, &block); end
-  def filename; end
-  def filename=(_arg0); end
-  def filetype; end
-  def flags(*args, &block); end
-  def fvmlib?(*args, &block); end
-  def header; end
-  def initialize_from_bin(bin, opts); end
-  def insert_command(offset, lc, options = T.unsafe(nil)); end
-  def kext?(*args, &block); end
-  def linked_dylibs; end
-  def load_commands; end
-  def magic(*args, &block); end
-  def magic32?(*args, &block); end
-  def magic64?(*args, &block); end
-  def magic_string; end
-  def ncmds(*args, &block); end
-  def object?(*args, &block); end
-  def options; end
-  def populate_fields; end
-  def preload?(*args, &block); end
-  def replace_command(old_lc, new_lc); end
-  def rpaths; end
-  def segment_alignment; end
-  def segments; end
-  def serialize; end
-  def sizeofcmds(*args, &block); end
-  def to_h; end
-  def write(filename); end
-  def write!; end
-
-  private
-
-  def check_cpusubtype(cputype, cpusubtype); end
-  def check_cputype(cputype); end
-  def check_filetype(filetype); end
-  def decompress_macho_lzvn; end
-  def low_fileoff; end
-  def populate_and_check_magic; end
-  def populate_load_commands; end
-  def populate_mach_header; end
-  def populate_prelinked_kernel_header; end
-  def update_ncmds(ncmds); end
-  def update_sizeofcmds(size); end
-
-  class << self
-    def new_from_bin(bin, **opts); end
-  end
-end
-
-class MachO::MachOStructure
-  def to_h; end
-
-  class << self
-    def bytesize; end
-    def new_from_bin(endianness, bin); end
-  end
-end
-
-MachO::MachOStructure::FORMAT = T.let(T.unsafe(nil), String)
-MachO::MachOStructure::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-class MachO::MachOView
-  def initialize(raw_data, endianness, offset); end
-
-  def endianness; end
-  def offset; end
-  def raw_data; end
-  def to_h; end
-end
-
-class MachO::MagicError < ::MachO::NotAMachOError
-  def initialize(magic); end
-end
-
-class MachO::ModificationError < ::MachO::MachOError; end
-class MachO::NotAMachOError < ::MachO::MachOError; end
-
-class MachO::OffsetInsertionError < ::MachO::ModificationError
-  def initialize(offset); end
-end
-
-class MachO::RecoverableModificationError < ::MachO::ModificationError
-  def macho_slice; end
-  def macho_slice=(_arg0); end
-  def to_s; end
-end
-
-class MachO::RpathExistsError < ::MachO::RecoverableModificationError
-  def initialize(path); end
-end
-
-class MachO::RpathUnknownError < ::MachO::RecoverableModificationError
-  def initialize(path); end
-end
-
-module MachO::Sections; end
-MachO::Sections::MAX_SECT_ALIGN = T.let(T.unsafe(nil), Integer)
-MachO::Sections::SECTION_ATTRIBUTES = T.let(T.unsafe(nil), Hash)
-MachO::Sections::SECTION_ATTRIBUTES_MASK = T.let(T.unsafe(nil), Integer)
-MachO::Sections::SECTION_ATTRIBUTES_SYS_MASK = T.let(T.unsafe(nil), Integer)
-MachO::Sections::SECTION_ATTRIBUTES_USR_MASK = T.let(T.unsafe(nil), Integer)
-MachO::Sections::SECTION_FLAGS = T.let(T.unsafe(nil), Hash)
-MachO::Sections::SECTION_NAMES = T.let(T.unsafe(nil), Hash)
-MachO::Sections::SECTION_TYPES = T.let(T.unsafe(nil), Hash)
-MachO::Sections::SECTION_TYPE_MASK = T.let(T.unsafe(nil), Integer)
-
-class MachO::Sections::Section < ::MachO::MachOStructure
-  def initialize(sectname, segname, addr, size, offset, align, reloff, nreloc, flags, reserved1, reserved2); end
-
-  def addr; end
-  def align; end
-  def attribute?(attr_sym); end
-  def attributes; end
-  def empty?; end
-  def flag?(flag); end
-  def flags; end
-  def nreloc; end
-  def offset; end
-  def reloff; end
-  def reserved1; end
-  def reserved2; end
-  def section_name; end
-  def sectname; end
-  def segment_name; end
-  def segname; end
-  def size; end
-  def to_h; end
-  def type; end
-  def type?(type_sym); end
-end
-
-class MachO::Sections::Section64 < ::MachO::Sections::Section
-  def initialize(sectname, segname, addr, size, offset, align, reloff, nreloc, flags, reserved1, reserved2, reserved3); end
-
-  def reserved3; end
-  def to_h; end
-end
-
-MachO::Sections::Section64::FORMAT = T.let(T.unsafe(nil), String)
-MachO::Sections::Section64::SIZEOF = T.let(T.unsafe(nil), Integer)
-MachO::Sections::Section::FORMAT = T.let(T.unsafe(nil), String)
-MachO::Sections::Section::SIZEOF = T.let(T.unsafe(nil), Integer)
-
-module MachO::Tools
-  class << self
-    def add_rpath(filename, new_path, options = T.unsafe(nil)); end
-    def change_dylib_id(filename, new_id, options = T.unsafe(nil)); end
-    def change_install_name(filename, old_name, new_name, options = T.unsafe(nil)); end
-    def change_rpath(filename, old_path, new_path, options = T.unsafe(nil)); end
-    def delete_rpath(filename, old_path, options = T.unsafe(nil)); end
-    def dylibs(filename); end
-    def merge_machos(filename, *files, fat64: T.unsafe(nil)); end
-  end
-end
-
-class MachO::TruncatedFileError < ::MachO::NotAMachOError
-  def initialize; end
-end
-
-class MachO::UnimplementedError < ::MachO::MachOError
-  def initialize(thing); end
-end
-
-module MachO::Utils
-  class << self
-    def big_magic?(num); end
-    def compressed_magic?(num); end
-    def fat_magic32?(num); end
-    def fat_magic64?(num); end
-    def fat_magic?(num); end
-    def little_magic?(num); end
-    def magic32?(num); end
-    def magic64?(num); end
-    def magic?(num); end
-    def nullpad(size); end
-    def pack_strings(fixed_offset, alignment, strings = T.unsafe(nil)); end
-    def padding_for(size, alignment); end
-    def round(value, round); end
-    def specialize_format(format, endianness); end
-  end
-end
-
-MachO::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/ruby-macho@4.1.0.rbi b/Library/Homebrew/sorbet/rbi/gems/ruby-macho@4.1.0.rbi
new file mode 100644
index 0000000000000..943f1e37cc8e9
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/ruby-macho@4.1.0.rbi
@@ -0,0 +1,4329 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `ruby-macho` gem.
+# Please instead update this file by running `bin/tapioca gem ruby-macho`.
+
+
+# The primary namespace for ruby-macho.
+#
+# source://ruby-macho//lib/macho/utils.rb#3
+module MachO
+  class << self
+    # Signs the dylib using an ad-hoc identity.
+    # Necessary after making any changes to a dylib, since otherwise
+    # changing a signed file invalidates its signature.
+    #
+    # @param filename [String] the file being opened
+    # @raise [ModificationError] if the operation fails
+    # @return [void]
+    #
+    # source://ruby-macho//lib/macho.rb#51
+    def codesign!(filename); end
+
+    # Opens the given filename as a MachOFile or FatFile, depending on its magic.
+    #
+    # @param filename [String] the file being opened
+    # @raise [ArgumentError] if the given file does not exist
+    # @raise [TruncatedFileError] if the file is too small to have a valid header
+    # @raise [MagicError] if the file's magic is not valid Mach-O magic
+    # @return [MachOFile] if the file is a Mach-O
+    # @return [FatFile] if the file is a Fat file
+    #
+    # source://ruby-macho//lib/macho.rb#28
+    def open(filename); end
+  end
+end
+
+# Raised when the CPU type/sub-type pair is unknown.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#104
+class MachO::CPUSubtypeError < ::MachO::MachOError
+  # @param cputype [Integer] the CPU type of the unknown pair
+  # @param cpusubtype [Integer] the CPU sub-type of the unknown pair
+  # @return [CPUSubtypeError] a new instance of CPUSubtypeError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#107
+  def initialize(cputype, cpusubtype); end
+end
+
+# Raised when the CPU type is unknown.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#96
+class MachO::CPUTypeError < ::MachO::MachOError
+  # @param cputype [Integer] the unknown CPU type
+  # @return [CPUTypeError] a new instance of CPUTypeError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#98
+  def initialize(cputype); end
+end
+
+# Raised when there is a mismatch between the fat arch
+# and internal slice cputype or cpusubtype.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#68
+class MachO::CPUTypeMismatchError < ::MachO::NotAMachOError
+  # @return [CPUTypeMismatchError] a new instance of CPUTypeMismatchError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#69
+  def initialize(fat_cputype, fat_cpusubtype, macho_cputype, macho_cpusubtype); end
+end
+
+# Raised when codesigning fails. Certain environments
+# may want to rescue this to treat it as non-fatal.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#14
+class MachO::CodeSigningError < ::MachO::MachOError; end
+
+# Raised when attempting to parse a compressed Mach-O without explicitly
+# requesting decompression.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#235
+class MachO::CompressedMachOError < ::MachO::MachOError; end
+
+# Raised when attempting to decompress a compressed Mach-O without adequate
+# dependencies, or on other decompression errors.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#240
+class MachO::DecompressionError < ::MachO::MachOError; end
+
+# Raised when a dylib is missing an ID
+#
+# source://ruby-macho//lib/macho/exceptions.rb#193
+class MachO::DylibIdMissingError < ::MachO::RecoverableModificationError
+  # @return [DylibIdMissingError] a new instance of DylibIdMissingError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#194
+  def initialize; end
+end
+
+# Raised when attempting to change a dylib name that doesn't exist.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#185
+class MachO::DylibUnknownError < ::MachO::RecoverableModificationError
+  # @param dylib [String] the unknown shared library name
+  # @return [DylibUnknownError] a new instance of DylibUnknownError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#187
+  def initialize(dylib); end
+end
+
+# Raised when attempting to create a {FatFile} from one or more {MachOFile}s
+#  whose offsets will not fit within the resulting 32-bit {Headers::FatArch#offset} fields.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#225
+class MachO::FatArchOffsetOverflowError < ::MachO::MachOError
+  # @param offset [Integer] the offending offset
+  # @return [FatArchOffsetOverflowError] a new instance of FatArchOffsetOverflowError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#227
+  def initialize(offset); end
+end
+
+# Raised when a fat binary is loaded with MachOFile.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#82
+class MachO::FatBinaryError < ::MachO::MachOError
+  # @return [FatBinaryError] a new instance of FatBinaryError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#83
+  def initialize; end
+end
+
+# Represents a "Fat" file, which contains a header, a listing of available
+# architectures, and one or more Mach-O binaries.
+#
+# @see https://en.wikipedia.org/wiki/Mach-O#Multi-architecture_binaries
+# @see MachOFile
+#
+# source://ruby-macho//lib/macho/fat_file.rb#10
+class MachO::FatFile
+  extend ::Forwardable
+
+  # Creates a new FatFile from the given filename.
+  #
+  # @note see {MachOFile#initialize} for currently valid options
+  # @param filename [String] the fat file to load from
+  # @param opts [Hash] options to control the parser with
+  # @raise [ArgumentError] if the given file does not exist
+  # @return [FatFile] a new instance of FatFile
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#94
+  def initialize(filename, **opts); end
+
+  # Add the given runtime path to the file's Mach-Os.
+  #
+  # @option options
+  # @param path [String] the new runtime path
+  # @param options [Hash]
+  # @return [void]
+  # @see MachOFile#add_rpath
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#260
+  def add_rpath(path, options = T.unsafe(nil)); end
+
+  # @return [Boolean] whether or not the file is of type `MH_BUNDLE`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def bundle?(*args, **_arg1, &block); end
+
+  # Changes all dependent shared library install names from `old_name` to
+  # `new_name`. In a fat file, this changes install names in all internal
+  # Mach-Os.
+  #
+  # @example
+  #   file.change_install_name('/usr/lib/libFoo.dylib', '/usr/lib/libBar.dylib')
+  # @option options
+  # @param old_name [String] the shared library name being changed
+  # @param new_name [String] the new name
+  # @param options [Hash]
+  # @return [void]
+  # @see MachOFile#change_install_name
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#217
+  def change_dylib(old_name, new_name, options = T.unsafe(nil)); end
+
+  # Changes the file's dylib ID to `new_id`. If the file is not a dylib,
+  #  does nothing.
+  #
+  # @example
+  #   file.change_dylib_id('libFoo.dylib')
+  # @option options
+  # @param new_id [String] the new dylib ID
+  # @param options [Hash]
+  # @raise [ArgumentError] if `new_id` is not a String
+  # @return [void]
+  # @see MachOFile#linked_dylibs
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#182
+  def change_dylib_id(new_id, options = T.unsafe(nil)); end
+
+  # Changes all dependent shared library install names from `old_name` to
+  # `new_name`. In a fat file, this changes install names in all internal
+  # Mach-Os.
+  #
+  # @example
+  #   file.change_install_name('/usr/lib/libFoo.dylib', '/usr/lib/libBar.dylib')
+  # @option options
+  # @param old_name [String] the shared library name being changed
+  # @param new_name [String] the new name
+  # @param options [Hash]
+  # @return [void]
+  # @see MachOFile#change_install_name
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#217
+  def change_install_name(old_name, new_name, options = T.unsafe(nil)); end
+
+  # Change the runtime path `old_path` to `new_path` in the file's Mach-Os.
+  #
+  # @option options
+  # @option options
+  # @param old_path [String] the old runtime path
+  # @param new_path [String] the new runtime path
+  # @param options [Hash]
+  # @return [void]
+  # @see MachOFile#change_rpath
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#245
+  def change_rpath(old_path, new_path, options = T.unsafe(nil)); end
+
+  # @return [Boolean] whether or not the file is of type `MH_CORE`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def core?(*args, **_arg1, &block); end
+
+  # Delete the given runtime path from the file's Mach-Os.
+  #
+  # @option options
+  # @option options
+  # @param path [String] the runtime path to delete
+  # @param options [Hash]
+  # @return void
+  # @see MachOFile#delete_rpath
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#278
+  def delete_rpath(path, options = T.unsafe(nil)); end
+
+  # @return [Boolean] whether or not the file is of type `MH_DSYM`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def dsym?(*args, **_arg1, &block); end
+
+  # @return [Boolean] whether or not the file is of type `MH_DYLIB`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def dylib?(*args, **_arg1, &block); end
+
+  # @return [String, nil] the Mach-O's dylib ID
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def dylib_id(*args, **_arg1, &block); end
+
+  # Changes the file's dylib ID to `new_id`. If the file is not a dylib,
+  #  does nothing.
+  #
+  # @example
+  #   file.change_dylib_id('libFoo.dylib')
+  # @option options
+  # @param new_id [String] the new dylib ID
+  # @param options [Hash]
+  # @raise [ArgumentError] if `new_id` is not a String
+  # @return [void]
+  # @see MachOFile#linked_dylibs
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#182
+  def dylib_id=(new_id, options = T.unsafe(nil)); end
+
+  # All load commands responsible for loading dylibs in the file's Mach-O's.
+  #
+  # @return [Array<LoadCommands::DylibCommand>] an array of DylibCommands
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#167
+  def dylib_load_commands; end
+
+  # @return [Boolean] whether or not the file is of type `MH_DYLINKER`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def dylinker?(*args, **_arg1, &block); end
+
+  # @return [Boolean] whether or not the file is of type `MH_EXECUTE`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def executable?(*args, **_arg1, &block); end
+
+  # Extract a Mach-O with the given CPU type from the file.
+  #
+  # @example
+  #   file.extract(:i386) # => MachO::MachOFile
+  # @param cputype [Symbol] the CPU type of the Mach-O being extracted
+  # @return [MachOFile, nil] the extracted Mach-O or nil if no Mach-O has the given CPU type
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#291
+  def extract(cputype); end
+
+  # @return [Array<Headers::FatArch>, Array<Headers::FatArch64] an array of fat architectures] Array<Headers::FatArch>, Array<Headers::FatArch64] an array of fat architectures
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#24
+  def fat_archs; end
+
+  # @return [String] the filename loaded from, or nil if loaded from a binary string
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#14
+  def filename; end
+
+  # @return [String] the filename loaded from, or nil if loaded from a binary string
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#14
+  def filename=(_arg0); end
+
+  # @return [Symbol] a string representation of the Mach-O's filetype
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def filetype(*args, **_arg1, &block); end
+
+  # @return [Boolean] whether or not the file is of type `MH_FVMLIB`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def fvmlib?(*args, **_arg1, &block); end
+
+  # @return [Headers::FatHeader] the file's header
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#21
+  def header; end
+
+  # Initializes a new FatFile instance from a binary string with the given options.
+  #
+  # @api private
+  # @see new_from_bin
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#106
+  def initialize_from_bin(bin, opts); end
+
+  # @return [Boolean] whether or not the file is of type `MH_KEXT_BUNDLE`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def kext?(*args, **_arg1, &block); end
+
+  # All shared libraries linked to the file's Mach-Os.
+  #
+  # @return [Array<String>] an array of all shared libraries
+  # @see MachOFile#linked_dylibs
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#198
+  def linked_dylibs; end
+
+  # @return [Array<MachOFile>] an array of Mach-O binaries
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#27
+  def machos; end
+
+  # @return [Integer] the magic number of the header (and file)
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def magic(*args, **_arg1, &block); end
+
+  # @return [String] a string representation of the file's magic number
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#152
+  def magic_string; end
+
+  # @return [Boolean] whether or not the file is of type `MH_OBJECT`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def object?(*args, **_arg1, &block); end
+
+  # @note Options specified in a {FatFile} trickle down into the internal {MachOFile}s.
+  # @return [Hash] any parser options that the instance was created with
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#18
+  def options; end
+
+  # Populate the instance's fields with the raw Fat Mach-O data.
+  #
+  # @note This method is public, but should (almost) never need to be called.
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#159
+  def populate_fields; end
+
+  # @return [Boolean] whether or not the file is of type `MH_PRELOAD`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def preload?(*args, **_arg1, &block); end
+
+  # All runtime paths associated with the file's Mach-Os.
+  #
+  # @return [Array<String>] an array of all runtime paths
+  # @see MachOFile#rpaths
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#230
+  def rpaths; end
+
+  # The file's raw fat data.
+  #
+  # @return [String] the raw fat data
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#115
+  def serialize; end
+
+  # @return [Hash] a hash representation of this {FatFile}
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#313
+  def to_h; end
+
+  # Write all (fat) data to the given filename.
+  #
+  # @param filename [String] the file to write to
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#298
+  def write(filename); end
+
+  # Write all (fat) data to the file used to initialize the instance.
+  #
+  # @note Overwrites all data in the file!
+  # @raise [MachOError] if the instance was initialized without a file
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#306
+  def write!; end
+
+  private
+
+  # Return a single-arch Mach-O that represents this fat Mach-O for purposes
+  #  of delegation.
+  #
+  # @api private
+  # @return [MachOFile] the Mach-O file
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#436
+  def canonical_macho; end
+
+  # Yield each Mach-O object in the file, rescuing and accumulating errors.
+  #
+  # @api private
+  # @option options
+  # @param options [Hash]
+  # @raise [RecoverableModificationError] under the conditions of
+  #   the `:strict` option above.
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#413
+  def each_macho(options = T.unsafe(nil)); end
+
+  # Obtain an array of fat architectures from raw file data.
+  #
+  # @api private
+  # @return [Array<Headers::FatArch>] an array of fat architectures
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#360
+  def populate_fat_archs; end
+
+  # Obtain the fat header from raw file data.
+  #
+  # @api private
+  # @raise [TruncatedFileError] if the file is too small to have a
+  #   valid header
+  # @raise [MagicError] if the magic is not valid Mach-O magic
+  # @raise [MachOBinaryError] if the magic is for a non-fat Mach-O file
+  # @raise [JavaClassFileError] if the file is a Java classfile
+  # @raise [ZeroArchitectureError] if the file has no internal slices
+  #   (i.e., nfat_arch == 0) and the permissive option is not set
+  # @return [Headers::FatHeader] the fat header
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#333
+  def populate_fat_header; end
+
+  # Obtain an array of Mach-O blobs from raw file data.
+  #
+  # @api private
+  # @return [Array<MachOFile>] an array of Mach-Os
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#377
+  def populate_machos; end
+
+  # Repopulate the raw Mach-O data with each internal Mach-O object.
+  #
+  # @api private
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/fat_file.rb#397
+  def repopulate_raw_machos; end
+
+  class << self
+    # Creates a new FatFile instance from a binary string.
+    #
+    # @note see {MachOFile#initialize} for currently valid options
+    # @param bin [String] a binary string containing raw Mach-O data
+    # @param opts [Hash] options to control the parser with
+    # @return [FatFile] a new FatFile
+    #
+    # source://ruby-macho//lib/macho/fat_file.rb#82
+    def new_from_bin(bin, **opts); end
+
+    # Creates a new FatFile from the given (single-arch) Mach-Os
+    #
+    # @param machos [Array<MachOFile>] the machos to combine
+    # @param fat64 [Boolean] whether to use {Headers::FatArch64}s to represent each slice
+    # @raise [ArgumentError] if less than one Mach-O is given
+    # @raise [FatArchOffsetOverflowError] if the Mach-Os are too big to be represented
+    #   in a 32-bit {Headers::FatArch} and `fat64` is `false`.
+    # @return [FatFile] a new FatFile containing the give machos
+    #
+    # source://ruby-macho//lib/macho/fat_file.rb#36
+    def new_from_machos(*machos, fat64: T.unsafe(nil)); end
+  end
+end
+
+# Raised when a mach-o file's filetype field is unknown.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#114
+class MachO::FiletypeError < ::MachO::MachOError
+  # @param num [Integer] the unknown number
+  # @return [FiletypeError] a new instance of FiletypeError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#116
+  def initialize(num); end
+end
+
+# Raised when load commands are too large to fit in the current file.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#175
+class MachO::HeaderPadError < ::MachO::ModificationError
+  # @param filename [String] the filename
+  # @return [HeaderPadError] a new instance of HeaderPadError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#177
+  def initialize(filename); end
+end
+
+# Classes and constants for parsing the headers of Mach-O binaries.
+#
+# source://ruby-macho//lib/macho/headers.rb#5
+module MachO::Headers; end
+
+# compressed mach-o magic
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#42
+MachO::Headers::COMPRESSED_MAGIC = T.let(T.unsafe(nil), Integer)
+
+# a compressed mach-o slice, using LZVN ("FastLib") for compression
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#50
+MachO::Headers::COMP_TYPE_FASTLIB = T.let(T.unsafe(nil), Integer)
+
+# a compressed mach-o slice, using LZSS for compression
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#46
+MachO::Headers::COMP_TYPE_LZSS = T.let(T.unsafe(nil), Integer)
+
+# mask for CPUs with 64-bit architectures (when running a 32-bit ABI?)
+#
+# @api private
+# @see https://github.com/Homebrew/ruby-macho/issues/113
+#
+# source://ruby-macho//lib/macho/headers.rb#70
+MachO::Headers::CPU_ARCH_ABI32 = T.let(T.unsafe(nil), Integer)
+
+# mask for CPUs with 64-bit architectures (when running a 64-bit ABI?)
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#65
+MachO::Headers::CPU_ARCH_ABI64 = T.let(T.unsafe(nil), Integer)
+
+# association of CPU types/subtype pairs to symbol representations in
+# (very) roughly descending order of commonness
+#
+# @api private
+# @see https://opensource.apple.com/source/cctools/cctools-877.8/libstuff/arch.c
+#
+# source://ruby-macho//lib/macho/headers.rb#338
+MachO::Headers::CPU_SUBTYPES = T.let(T.unsafe(nil), Hash)
+
+# the i486 sub-type for `CPU_TYPE_I386`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#140
+MachO::Headers::CPU_SUBTYPE_486 = T.let(T.unsafe(nil), Integer)
+
+# the i486SX sub-type for `CPU_TYPE_I386`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#144
+MachO::Headers::CPU_SUBTYPE_486SX = T.let(T.unsafe(nil), Integer)
+
+# the i586 (P5, Pentium) sub-type for `CPU_TYPE_I386`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#148
+MachO::Headers::CPU_SUBTYPE_586 = T.let(T.unsafe(nil), Integer)
+
+# the e (A12) sub-type for `CPU_TYPE_ARM64`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#260
+MachO::Headers::CPU_SUBTYPE_ARM64E = T.let(T.unsafe(nil), Integer)
+
+# the v8 sub-type for `CPU_TYPE_ARM64_32`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#256
+MachO::Headers::CPU_SUBTYPE_ARM64_32_V8 = T.let(T.unsafe(nil), Integer)
+
+# the lowest common sub-type for `CPU_TYPE_ARM64`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#248
+MachO::Headers::CPU_SUBTYPE_ARM64_ALL = T.let(T.unsafe(nil), Integer)
+
+# the v8 sub-type for `CPU_TYPE_ARM64`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#252
+MachO::Headers::CPU_SUBTYPE_ARM64_V8 = T.let(T.unsafe(nil), Integer)
+
+# the lowest common sub-type for `CPU_TYPE_ARM`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#196
+MachO::Headers::CPU_SUBTYPE_ARM_ALL = T.let(T.unsafe(nil), Integer)
+
+# the v4t sub-type for `CPU_TYPE_ARM`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#200
+MachO::Headers::CPU_SUBTYPE_ARM_V4T = T.let(T.unsafe(nil), Integer)
+
+# the v5 sub-type for `CPU_TYPE_ARM`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#208
+MachO::Headers::CPU_SUBTYPE_ARM_V5TEJ = T.let(T.unsafe(nil), Integer)
+
+# the v6 sub-type for `CPU_TYPE_ARM`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#204
+MachO::Headers::CPU_SUBTYPE_ARM_V6 = T.let(T.unsafe(nil), Integer)
+
+# the v6m sub-type for `CPU_TYPE_ARM`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#232
+MachO::Headers::CPU_SUBTYPE_ARM_V6M = T.let(T.unsafe(nil), Integer)
+
+# the v7 sub-type for `CPU_TYPE_ARM`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#216
+MachO::Headers::CPU_SUBTYPE_ARM_V7 = T.let(T.unsafe(nil), Integer)
+
+# the v7em sub-type for `CPU_TYPE_ARM`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#240
+MachO::Headers::CPU_SUBTYPE_ARM_V7EM = T.let(T.unsafe(nil), Integer)
+
+# the v7f (Cortex A9) sub-type for `CPU_TYPE_ARM`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#220
+MachO::Headers::CPU_SUBTYPE_ARM_V7F = T.let(T.unsafe(nil), Integer)
+
+# the v7k ("Kirkwood40") sub-type for `CPU_TYPE_ARM`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#228
+MachO::Headers::CPU_SUBTYPE_ARM_V7K = T.let(T.unsafe(nil), Integer)
+
+# the v7m sub-type for `CPU_TYPE_ARM`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#236
+MachO::Headers::CPU_SUBTYPE_ARM_V7M = T.let(T.unsafe(nil), Integer)
+
+# the v7s ("Swift") sub-type for `CPU_TYPE_ARM`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#224
+MachO::Headers::CPU_SUBTYPE_ARM_V7S = T.let(T.unsafe(nil), Integer)
+
+# the v8 sub-type for `CPU_TYPE_ARM`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#244
+MachO::Headers::CPU_SUBTYPE_ARM_V8 = T.let(T.unsafe(nil), Integer)
+
+# the xscale (v5 family) sub-type for `CPU_TYPE_ARM`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#212
+MachO::Headers::CPU_SUBTYPE_ARM_XSCALE = T.let(T.unsafe(nil), Integer)
+
+# the lowest common sub-type for `CPU_TYPE_I386`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#136
+MachO::Headers::CPU_SUBTYPE_I386 = T.let(T.unsafe(nil), Integer)
+
+# 64-bit libraries (undocumented!)
+#
+# @api private
+# @see http://llvm.org/docs/doxygen/html/Support_2MachO_8h_source.html
+#
+# source://ruby-macho//lib/macho/headers.rb#132
+MachO::Headers::CPU_SUBTYPE_LIB64 = T.let(T.unsafe(nil), Integer)
+
+# mask for CPU subtype capabilities
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#127
+MachO::Headers::CPU_SUBTYPE_MASK = T.let(T.unsafe(nil), Integer)
+
+# @api private
+# @see CPU_SUBTYPE_MC680X0_ALL
+#
+# source://ruby-macho//lib/macho/headers.rb#176
+MachO::Headers::CPU_SUBTYPE_MC68030 = T.let(T.unsafe(nil), Integer)
+
+# the 030 subtype for `CPU_TYPE_MC680X0`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#184
+MachO::Headers::CPU_SUBTYPE_MC68030_ONLY = T.let(T.unsafe(nil), Integer)
+
+# the 040 subtype for `CPU_TYPE_MC680X0`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#180
+MachO::Headers::CPU_SUBTYPE_MC68040 = T.let(T.unsafe(nil), Integer)
+
+# the lowest common sub-type for `CPU_TYPE_MC680X0`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#172
+MachO::Headers::CPU_SUBTYPE_MC680X0_ALL = T.let(T.unsafe(nil), Integer)
+
+# the lowest common sub-type for `CPU_TYPE_MC88000`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#264
+MachO::Headers::CPU_SUBTYPE_MC88000_ALL = T.let(T.unsafe(nil), Integer)
+
+# the 100 sub-type for `CPU_TYPE_MC88000`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#272
+MachO::Headers::CPU_SUBTYPE_MC88100 = T.let(T.unsafe(nil), Integer)
+
+# the 110 sub-type for `CPU_TYPE_MC88000`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#276
+MachO::Headers::CPU_SUBTYPE_MC88110 = T.let(T.unsafe(nil), Integer)
+
+# @api private
+# @see CPU_SUBTYPE_MC88000_ALL
+#
+# source://ruby-macho//lib/macho/headers.rb#268
+MachO::Headers::CPU_SUBTYPE_MMAX_JPC = T.let(T.unsafe(nil), Integer)
+
+# @api private
+# @see CPU_SUBTYPE_586
+#
+# source://ruby-macho//lib/macho/headers.rb#152
+MachO::Headers::CPU_SUBTYPE_PENT = T.let(T.unsafe(nil), Integer)
+
+# the Pentium II (P6, M3?) sub-type for `CPU_TYPE_I386`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#160
+MachO::Headers::CPU_SUBTYPE_PENTII_M3 = T.let(T.unsafe(nil), Integer)
+
+# the Pentium II (P6, M5?) sub-type for `CPU_TYPE_I386`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#164
+MachO::Headers::CPU_SUBTYPE_PENTII_M5 = T.let(T.unsafe(nil), Integer)
+
+# the Pentium 4 (Netburst) sub-type for `CPU_TYPE_I386`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#168
+MachO::Headers::CPU_SUBTYPE_PENTIUM_4 = T.let(T.unsafe(nil), Integer)
+
+# the Pentium Pro (P6) sub-type for `CPU_TYPE_I386`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#156
+MachO::Headers::CPU_SUBTYPE_PENTPRO = T.let(T.unsafe(nil), Integer)
+
+# any CPU sub-type for CPU type `CPU_TYPE_POWERPC64`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#332
+MachO::Headers::CPU_SUBTYPE_POWERPC64_ALL = T.let(T.unsafe(nil), Integer)
+
+# the 601 sub-type for `CPU_TYPE_POWERPC`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#284
+MachO::Headers::CPU_SUBTYPE_POWERPC_601 = T.let(T.unsafe(nil), Integer)
+
+# the 602 sub-type for `CPU_TYPE_POWERPC`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#288
+MachO::Headers::CPU_SUBTYPE_POWERPC_602 = T.let(T.unsafe(nil), Integer)
+
+# the 603 sub-type for `CPU_TYPE_POWERPC`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#292
+MachO::Headers::CPU_SUBTYPE_POWERPC_603 = T.let(T.unsafe(nil), Integer)
+
+# the 603e (G2) sub-type for `CPU_TYPE_POWERPC`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#296
+MachO::Headers::CPU_SUBTYPE_POWERPC_603E = T.let(T.unsafe(nil), Integer)
+
+# the 603ev sub-type for `CPU_TYPE_POWERPC`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#300
+MachO::Headers::CPU_SUBTYPE_POWERPC_603EV = T.let(T.unsafe(nil), Integer)
+
+# the 604 sub-type for `CPU_TYPE_POWERPC`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#304
+MachO::Headers::CPU_SUBTYPE_POWERPC_604 = T.let(T.unsafe(nil), Integer)
+
+# the 604e sub-type for `CPU_TYPE_POWERPC`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#308
+MachO::Headers::CPU_SUBTYPE_POWERPC_604E = T.let(T.unsafe(nil), Integer)
+
+# the 620 sub-type for `CPU_TYPE_POWERPC`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#312
+MachO::Headers::CPU_SUBTYPE_POWERPC_620 = T.let(T.unsafe(nil), Integer)
+
+# the 7400 (G4) sub-type for `CPU_TYPE_POWERPC`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#320
+MachO::Headers::CPU_SUBTYPE_POWERPC_7400 = T.let(T.unsafe(nil), Integer)
+
+# the 7450 (G4 "Voyager") sub-type for `CPU_TYPE_POWERPC`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#324
+MachO::Headers::CPU_SUBTYPE_POWERPC_7450 = T.let(T.unsafe(nil), Integer)
+
+# the 750 (G3) sub-type for `CPU_TYPE_POWERPC`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#316
+MachO::Headers::CPU_SUBTYPE_POWERPC_750 = T.let(T.unsafe(nil), Integer)
+
+# the 970 (G5) sub-type for `CPU_TYPE_POWERPC`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#328
+MachO::Headers::CPU_SUBTYPE_POWERPC_970 = T.let(T.unsafe(nil), Integer)
+
+# the lowest common sub-type for `CPU_TYPE_POWERPC`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#280
+MachO::Headers::CPU_SUBTYPE_POWERPC_ALL = T.let(T.unsafe(nil), Integer)
+
+# the lowest common sub-type for `CPU_TYPE_X86_64`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#188
+MachO::Headers::CPU_SUBTYPE_X86_64_ALL = T.let(T.unsafe(nil), Integer)
+
+# the Haskell sub-type for `CPU_TYPE_X86_64`
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#192
+MachO::Headers::CPU_SUBTYPE_X86_64_H = T.let(T.unsafe(nil), Integer)
+
+# association of cpu types to symbol representations
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#114
+MachO::Headers::CPU_TYPES = T.let(T.unsafe(nil), Hash)
+
+# any CPU (unused?)
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#74
+MachO::Headers::CPU_TYPE_ANY = T.let(T.unsafe(nil), Integer)
+
+# 32-bit ARM compatible CPUs
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#90
+MachO::Headers::CPU_TYPE_ARM = T.let(T.unsafe(nil), Integer)
+
+# 64-bit ARM compatible CPUs
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#98
+MachO::Headers::CPU_TYPE_ARM64 = T.let(T.unsafe(nil), Integer)
+
+# 64-bit ARM compatible CPUs (running in 32-bit mode?)
+#
+# @see https://github.com/Homebrew/ruby-macho/issues/113
+#
+# source://ruby-macho//lib/macho/headers.rb#102
+MachO::Headers::CPU_TYPE_ARM64_32 = T.let(T.unsafe(nil), Integer)
+
+# i386 and later compatible CPUs
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#82
+MachO::Headers::CPU_TYPE_I386 = T.let(T.unsafe(nil), Integer)
+
+# m68k compatible CPUs
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#78
+MachO::Headers::CPU_TYPE_MC680X0 = T.let(T.unsafe(nil), Integer)
+
+# m88k compatible CPUs
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#94
+MachO::Headers::CPU_TYPE_MC88000 = T.let(T.unsafe(nil), Integer)
+
+# PowerPC compatible CPUs
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#106
+MachO::Headers::CPU_TYPE_POWERPC = T.let(T.unsafe(nil), Integer)
+
+# PowerPC64 compatible CPUs
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#110
+MachO::Headers::CPU_TYPE_POWERPC64 = T.let(T.unsafe(nil), Integer)
+
+# x86_64 (AMD64) compatible CPUs
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#86
+MachO::Headers::CPU_TYPE_X86_64 = T.let(T.unsafe(nil), Integer)
+
+# little-endian fat magic
+#
+# @api private
+# @note This is defined for completeness, but should never appear in ruby-macho code,
+#   since fat headers are always big-endian.
+#
+# source://ruby-macho//lib/macho/headers.rb#14
+MachO::Headers::FAT_CIGAM = T.let(T.unsafe(nil), Integer)
+
+# 64-bit little-endian fat magic
+#
+# @note This is defined for completeness, but should never appear in ruby-macho code,
+#   since fat headers are always big-endian.
+#
+# source://ruby-macho//lib/macho/headers.rb#22
+MachO::Headers::FAT_CIGAM_64 = T.let(T.unsafe(nil), Integer)
+
+# big-endian fat magic
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#8
+MachO::Headers::FAT_MAGIC = T.let(T.unsafe(nil), Integer)
+
+# 64-bit big-endian fat magic
+#
+# source://ruby-macho//lib/macho/headers.rb#17
+MachO::Headers::FAT_MAGIC_64 = T.let(T.unsafe(nil), Integer)
+
+# 32-bit fat binary header architecture structure. A 32-bit fat Mach-O has one or more of
+#  these, indicating one or more internal Mach-O blobs.
+#
+# @note "32-bit" indicates the fact that this structure stores 32-bit offsets, not that the
+#   Mach-Os that it points to necessarily *are* 32-bit.
+# @see MachO::Headers::FatHeader
+#
+# source://ruby-macho//lib/macho/headers.rb#533
+class MachO::Headers::FatArch < ::MachO::MachOStructure
+  # @return [Integer] the alignment, as a power of 2
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def align; end
+
+  # @return [Integer] the CPU subtype of the Mach-O
+  #
+  # source://ruby-macho//lib/macho/structure.rb#228
+  def cpusubtype; end
+
+  # @return [Integer] the CPU type of the Mach-O
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def cputype; end
+
+  # @return [Integer] the file offset to the beginning of the Mach-O data
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def offset; end
+
+  # @return [String] the serialized fields of the fat arch
+  #
+  # source://ruby-macho//lib/macho/headers.rb#550
+  def serialize; end
+
+  # @return [Integer] the size, in bytes, of the Mach-O data
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def size; end
+
+  # @return [Hash] a hash representation of this {FatArch}
+  #
+  # source://ruby-macho//lib/macho/headers.rb#555
+  def to_h; end
+end
+
+# 64-bit fat binary header architecture structure. A 64-bit fat Mach-O has one or more of
+#  these, indicating one or more internal Mach-O blobs.
+#
+# @note "64-bit" indicates the fact that this structure stores 64-bit offsets, not that the
+#   Mach-Os that it points to necessarily *are* 64-bit.
+# @see MachO::Headers::FatHeader
+#
+# source://ruby-macho//lib/macho/headers.rb#573
+class MachO::Headers::FatArch64 < ::MachO::Headers::FatArch
+  # @return [Integer] the file offset to the beginning of the Mach-O data
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def offset; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#256
+  def reserved; end
+
+  # @return [String] the serialized fields of the fat arch
+  #
+  # source://ruby-macho//lib/macho/headers.rb#584
+  def serialize; end
+
+  # @return [Integer] the size, in bytes, of the Mach-O data
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def size; end
+
+  # @return [Hash] a hash representation of this {FatArch64}
+  #
+  # source://ruby-macho//lib/macho/headers.rb#589
+  def to_h; end
+end
+
+# Fat binary header structure
+#
+# @see MachO::FatArch
+#
+# source://ruby-macho//lib/macho/headers.rb#506
+class MachO::Headers::FatHeader < ::MachO::MachOStructure
+  # @return [Integer] the magic number of the header (and file)
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def magic; end
+
+  # @return [Integer] the number of fat architecture structures following the header
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def nfat_arch; end
+
+  # @return [String] the serialized fields of the fat header
+  #
+  # source://ruby-macho//lib/macho/headers.rb#514
+  def serialize; end
+
+  # @return [Hash] a hash representation of this {FatHeader}
+  #
+  # source://ruby-macho//lib/macho/headers.rb#519
+  def to_h; end
+end
+
+# dynamically bound bundle file
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#434
+MachO::Headers::MH_BUNDLE = T.let(T.unsafe(nil), Integer)
+
+# 32-bit little-endian magic
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#30
+MachO::Headers::MH_CIGAM = T.let(T.unsafe(nil), Integer)
+
+# 64-bit little-endian magic
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#38
+MachO::Headers::MH_CIGAM_64 = T.let(T.unsafe(nil), Integer)
+
+# core dump file
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#418
+MachO::Headers::MH_CORE = T.let(T.unsafe(nil), Integer)
+
+# companion file with only debug sections
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#442
+MachO::Headers::MH_DSYM = T.let(T.unsafe(nil), Integer)
+
+# dynamically bound shared library
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#426
+MachO::Headers::MH_DYLIB = T.let(T.unsafe(nil), Integer)
+
+# shared library stub for static linking only, no section contents
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#438
+MachO::Headers::MH_DYLIB_STUB = T.let(T.unsafe(nil), Integer)
+
+# dynamic link editor
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#430
+MachO::Headers::MH_DYLINKER = T.let(T.unsafe(nil), Integer)
+
+# demand paged executable file
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#410
+MachO::Headers::MH_EXECUTE = T.let(T.unsafe(nil), Integer)
+
+# a set of Mach-Os, running in the same userspace, sharing a linkedit.  The kext collection files are an example
+# of this object type
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#451
+MachO::Headers::MH_FILESET = T.let(T.unsafe(nil), Integer)
+
+# association of filetypes to Symbol representations
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#455
+MachO::Headers::MH_FILETYPES = T.let(T.unsafe(nil), Hash)
+
+# association of mach header flag symbols to values
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#472
+MachO::Headers::MH_FLAGS = T.let(T.unsafe(nil), Hash)
+
+# fixed VM shared library file
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#414
+MachO::Headers::MH_FVMLIB = T.let(T.unsafe(nil), Integer)
+
+# x86_64 kexts
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#446
+MachO::Headers::MH_KEXT_BUNDLE = T.let(T.unsafe(nil), Integer)
+
+# 32-bit big-endian magic
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#26
+MachO::Headers::MH_MAGIC = T.let(T.unsafe(nil), Integer)
+
+# association of magic numbers to string representations
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#54
+MachO::Headers::MH_MAGICS = T.let(T.unsafe(nil), Hash)
+
+# 64-bit big-endian magic
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#34
+MachO::Headers::MH_MAGIC_64 = T.let(T.unsafe(nil), Integer)
+
+# relocatable object file
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#406
+MachO::Headers::MH_OBJECT = T.let(T.unsafe(nil), Integer)
+
+# preloaded executable file
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/headers.rb#422
+MachO::Headers::MH_PRELOAD = T.let(T.unsafe(nil), Integer)
+
+# 32-bit Mach-O file header structure
+#
+# source://ruby-macho//lib/macho/headers.rb#597
+class MachO::Headers::MachHeader < ::MachO::MachOStructure
+  # @return [Integer] the file's internal alignment
+  #
+  # source://ruby-macho//lib/macho/headers.rb#697
+  def alignment; end
+
+  # @return [Boolean] whether or not the file is of type `MH_BUNDLE`
+  #
+  # source://ruby-macho//lib/macho/headers.rb#667
+  def bundle?; end
+
+  # @return [Boolean] whether or not the file is of type `MH_CORE`
+  #
+  # source://ruby-macho//lib/macho/headers.rb#647
+  def core?; end
+
+  # @return [Integer] the CPU subtype of the Mach-O
+  #
+  # source://ruby-macho//lib/macho/structure.rb#228
+  def cpusubtype; end
+
+  # @return [Integer] the CPU type of the Mach-O
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def cputype; end
+
+  # @return [Boolean] whether or not the file is of type `MH_DSYM`
+  #
+  # source://ruby-macho//lib/macho/headers.rb#672
+  def dsym?; end
+
+  # @return [Boolean] whether or not the file is of type `MH_DYLIB`
+  #
+  # source://ruby-macho//lib/macho/headers.rb#657
+  def dylib?; end
+
+  # @return [Boolean] whether or not the file is of type `MH_DYLINKER`
+  #
+  # source://ruby-macho//lib/macho/headers.rb#662
+  def dylinker?; end
+
+  # @return [Boolean] whether or not the file is of type `MH_EXECUTE`
+  #
+  # source://ruby-macho//lib/macho/headers.rb#637
+  def executable?; end
+
+  # @return [Boolean] whether or not the file is of type `MH_FILESET`
+  #
+  # source://ruby-macho//lib/macho/headers.rb#682
+  def fileset?; end
+
+  # @return [Integer] the file type of the Mach-O
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def filetype; end
+
+  # @example
+  #   puts "this mach-o has position-independent execution" if header.flag?(:MH_PIE)
+  # @param flag [Symbol] a mach header flag symbol
+  # @return [Boolean] true if `flag` is present in the header's flag section
+  #
+  # source://ruby-macho//lib/macho/headers.rb#623
+  def flag?(flag); end
+
+  # @return [Integer] the header flags associated with the Mach-O
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def flags; end
+
+  # @return [Boolean] whether or not the file is of type `MH_FVMLIB`
+  #
+  # source://ruby-macho//lib/macho/headers.rb#642
+  def fvmlib?; end
+
+  # @return [Boolean] whether or not the file is of type `MH_KEXT_BUNDLE`
+  #
+  # source://ruby-macho//lib/macho/headers.rb#677
+  def kext?; end
+
+  # @return [Integer] the magic number
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def magic; end
+
+  # @return [Boolean] true if the Mach-O has 32-bit magic, false otherwise
+  #
+  # source://ruby-macho//lib/macho/headers.rb#687
+  def magic32?; end
+
+  # @return [Boolean] true if the Mach-O has 64-bit magic, false otherwise
+  #
+  # source://ruby-macho//lib/macho/headers.rb#692
+  def magic64?; end
+
+  # @return [Integer] the number of load commands in the Mach-O
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def ncmds; end
+
+  # @return [Boolean] whether or not the file is of type `MH_OBJECT`
+  #
+  # source://ruby-macho//lib/macho/headers.rb#632
+  def object?; end
+
+  # @return [Boolean] whether or not the file is of type `MH_PRELOAD`
+  #
+  # source://ruby-macho//lib/macho/headers.rb#652
+  def preload?; end
+
+  # @return [Integer] the size of all load commands, in bytes, in the Mach-O
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def sizeofcmds; end
+
+  # @return [Hash] a hash representation of this {MachHeader}
+  #
+  # source://ruby-macho//lib/macho/headers.rb#702
+  def to_h; end
+end
+
+# 64-bit Mach-O file header structure
+#
+# source://ruby-macho//lib/macho/headers.rb#721
+class MachO::Headers::MachHeader64 < ::MachO::Headers::MachHeader
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved; end
+
+  # @return [Hash] a hash representation of this {MachHeader64}
+  #
+  # source://ruby-macho//lib/macho/headers.rb#726
+  def to_h; end
+end
+
+# Prelinked kernel/"kernelcache" header structure
+#
+# source://ruby-macho//lib/macho/headers.rb#734
+class MachO::Headers::PrelinkedKernelHeader < ::MachO::MachOStructure
+  # @return [Integer] a checksum for the uncompressed data
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def adler32; end
+
+  # @return [Integer] the type of compression used
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def compress_type; end
+
+  # @return [Integer] the size of the compressed data, in bytes
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def compressed_size; end
+
+  # @return [Boolean] whether this prelinked kernel supports KASLR
+  #
+  # source://ruby-macho//lib/macho/headers.rb#763
+  def kaslr?; end
+
+  # @return [Boolean] whether this prelinked kernel is compressed with LZSS
+  #
+  # source://ruby-macho//lib/macho/headers.rb#768
+  def lzss?; end
+
+  # @return [Boolean] whether this prelinked kernel is compressed with LZVN
+  #
+  # source://ruby-macho//lib/macho/headers.rb#773
+  def lzvn?; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def platform_name; end
+
+  # @return [Integer] the version of the prelink format
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def prelink_version; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#242
+  def reserved; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def root_path; end
+
+  # @return [Integer] the magic number for a compressed header ({COMPRESSED_MAGIC})
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def signature; end
+
+  # @return [Hash] a hash representation of this {PrelinkedKernelHeader}
+  #
+  # source://ruby-macho//lib/macho/headers.rb#778
+  def to_h; end
+
+  # @return [Integer] the size of the uncompressed data, in bytes
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def uncompressed_size; end
+end
+
+# Raised when a file is a Java classfile instead of a fat Mach-O.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#53
+class MachO::JavaClassFileError < ::MachO::NotAMachOError
+  # @return [JavaClassFileError] a new instance of JavaClassFileError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#54
+  def initialize; end
+end
+
+# Raised when a load command string is malformed in some way.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#158
+class MachO::LCStrMalformedError < ::MachO::MachOError
+  # @param lc [MachO::LoadCommand] the load command containing the string
+  # @return [LCStrMalformedError] a new instance of LCStrMalformedError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#160
+  def initialize(lc); end
+end
+
+# Raised when the number of arguments used to create a load command manually
+# is wrong.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#139
+class MachO::LoadCommandCreationArityError < ::MachO::MachOError
+  # @param cmd_sym [Symbol] the load command's symbol
+  # @param expected_arity [Integer] the number of arguments expected
+  # @param actual_arity [Integer] the number of arguments received
+  # @return [LoadCommandCreationArityError] a new instance of LoadCommandCreationArityError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#143
+  def initialize(cmd_sym, expected_arity, actual_arity); end
+end
+
+# Raised when an unknown load command is encountered.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#122
+class MachO::LoadCommandError < ::MachO::MachOError
+  # @param num [Integer] the unknown number
+  # @return [LoadCommandError] a new instance of LoadCommandError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#124
+  def initialize(num); end
+end
+
+# Raised when a load command can't be created manually.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#130
+class MachO::LoadCommandNotCreatableError < ::MachO::MachOError
+  # @param cmd_sym [Symbol] the uncreatable load command's symbol
+  # @return [LoadCommandNotCreatableError] a new instance of LoadCommandNotCreatableError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#132
+  def initialize(cmd_sym); end
+end
+
+# Raised when a load command can't be serialized.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#150
+class MachO::LoadCommandNotSerializableError < ::MachO::MachOError
+  # @param cmd_sym [Symbol] the load command's symbol
+  # @return [LoadCommandNotSerializableError] a new instance of LoadCommandNotSerializableError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#152
+  def initialize(cmd_sym); end
+end
+
+# Classes and constants for parsing load commands in Mach-O binaries.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#5
+module MachO::LoadCommands; end
+
+# A load command containing the minimum OS version on which
+# the binary was built for its platform.
+# Corresponds to LC_BUILD_VERSION.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1159
+class MachO::LoadCommands::BuildVersionCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the minimum OS version X.Y.Z packed as x16.y8.z8
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def minos; end
+
+  # A string representation of the binary's minimum OS version.
+  #
+  # @return [String] a string representing the minimum OS version.
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1174
+  def minos_string; end
+
+  # @return [Integer]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def platform; end
+
+  # @return [Integer] the SDK version X.Y.Z packed as x16.y8.z8
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def sdk; end
+
+  # A string representation of the binary's SDK version.
+  #
+  # @return [String] a string representing the SDK version.
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1185
+  def sdk_string; end
+
+  # @return [Hash] a hash representation of this {BuildVersionCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1195
+  def to_h; end
+
+  # @return [ToolEntries] tool entries
+  #
+  # source://ruby-macho//lib/macho/structure.rb#213
+  def tool_entries; end
+end
+
+# A representation of the tool versions exposed
+# by a {BuildVersionCommand} (`LC_BUILD_VERSION`).
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1208
+class MachO::LoadCommands::BuildVersionCommand::ToolEntries
+  # @api private
+  # @param view [MachO::MachOView] the view into the current Mach-O
+  # @param ntools [Integer] the number of tools
+  # @return [ToolEntries] a new instance of ToolEntries
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1215
+  def initialize(view, ntools); end
+
+  # @return [Array<Tool>] all tools
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1210
+  def tools; end
+end
+
+# An individual tool.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1224
+class MachO::LoadCommands::BuildVersionCommand::ToolEntries::Tool
+  # @api private
+  # @param tool [Integer] 32-bit integer
+  # @param version [Integer] 32-bit integer
+  # @return [Tool] a new instance of Tool
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1234
+  def initialize(tool, version); end
+
+  # @return [Hash] a hash representation of this {Tool}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1240
+  def to_h; end
+
+  # @return [Integer] the enum for the tool
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1226
+  def tool; end
+
+  # @return [Integer] the tool's version number
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1229
+  def version; end
+end
+
+# load commands that can be created manually via {LoadCommand.create}
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/load_commands.rb#87
+MachO::LoadCommands::CREATABLE_LOAD_COMMANDS = T.let(T.unsafe(nil), Array)
+
+# load commands responsible for loading dylibs
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/load_commands.rb#77
+MachO::LoadCommands::DYLIB_LOAD_COMMANDS = T.let(T.unsafe(nil), Array)
+
+# association of dylib use flag symbols to values
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/load_commands.rb#200
+MachO::LoadCommands::DYLIB_USE_FLAGS = T.let(T.unsafe(nil), Hash)
+
+# the marker used to denote a newer style dylib use command.
+# the value is the timestamp 24 January 1984 18:12:16
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/load_commands.rb#210
+MachO::LoadCommands::DYLIB_USE_MARKER = T.let(T.unsafe(nil), Integer)
+
+# A load command containing the file offsets and sizes of the new
+# compressed form of the information dyld needs to load the image.
+# Corresponds to LC_DYLD_INFO and LC_DYLD_INFO_ONLY.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1253
+class MachO::LoadCommands::DyldInfoCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the file offset to the binding information
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def bind_off; end
+
+  # @return [Integer] the size of the binding information
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def bind_size; end
+
+  # @return [Integer] the file offset to the export information
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def export_off; end
+
+  # @return [Integer] the size of the export information
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def export_size; end
+
+  # @return [Integer] the file offset to the lazy binding information
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def lazy_bind_off; end
+
+  # @return [Integer] the size of the lazy binding information
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def lazy_bind_size; end
+
+  # @return [Integer] the file offset to the rebase information
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def rebase_off; end
+
+  # @return [Integer] the size of the rebase information
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def rebase_size; end
+
+  # @return [Hash] a hash representation of this {DyldInfoCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1285
+  def to_h; end
+
+  # @return [Integer] the file offset to the weak binding information
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def weak_bind_off; end
+
+  # @return [Integer] the size of the weak binding information
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def weak_bind_size; end
+end
+
+# A load command representing some aspect of shared libraries, depending
+# on filetype. Corresponds to LC_ID_DYLIB, LC_LOAD_DYLIB,
+# LC_LOAD_WEAK_DYLIB, and LC_REEXPORT_DYLIB.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#538
+class MachO::LoadCommands::DylibCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the library's compatibility version number
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def compatibility_version; end
+
+  # @return [Integer] the library's current version number
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def current_version; end
+
+  # @example
+  #   puts "this dylib is weakly loaded" if dylib_command.flag?(:DYLIB_USE_WEAK_LINK)
+  # @param flag [Symbol] a dylib use command flag symbol
+  # @return [Boolean] true if `flag` applies to this dylib command
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#556
+  def flag?(flag); end
+
+  # @return [LCStr] the library's path
+  #   name as an LCStr
+  #
+  # source://ruby-macho//lib/macho/structure.rb#199
+  def name; end
+
+  # @api private
+  # @param context [SerializationContext] the context
+  # @return [String] the serialized fields of the load command
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#573
+  def serialize(context); end
+
+  # @return [Integer] the library's build time stamp
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def timestamp; end
+
+  # @return [Hash] a hash representation of this {DylibCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#584
+  def to_h; end
+
+  # source://ruby-macho//lib/macho/structure.rb#278
+  def to_s; end
+end
+
+# The newer format of load command representing some aspect of shared libraries,
+# depending on filetype. Corresponds to LC_LOAD_DYLIB or LC_LOAD_WEAK_DYLIB.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#596
+class MachO::LoadCommands::DylibUseCommand < ::MachO::LoadCommands::DylibCommand
+  # @example
+  #   puts "this dylib is weakly loaded" if dylib_command.flag?(:DYLIB_USE_WEAK_LINK)
+  # @param flag [Symbol] a dylib use command flag symbol
+  # @return [Boolean] true if `flag` applies to this dylib command
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#623
+  def flag?(flag); end
+
+  # @return [Integer] any flags associated with this dylib use command
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def flags; end
+
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def marker; end
+
+  # @api private
+  # @param context [SerializationContext] the context
+  # @return [String] the serialized fields of the load command
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#635
+  def serialize(context); end
+
+  # @return [Hash] a hash representation of this {DylibUseCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#646
+  def to_h; end
+
+  class << self
+    # Instantiates a new DylibCommand or DylibUseCommand.
+    # macOS 15 and later use a new format for dylib commands (DylibUseCommand),
+    # which is determined based on a special timestamp and the name offset.
+    #
+    # @api private
+    # @param view [MachO::MachOView] the load command's raw view
+    # @return [DylibCommand] the new dylib load command
+    #
+    # source://ruby-macho//lib/macho/load_commands.rb#608
+    def new_from_bin(view); end
+  end
+end
+
+# A load command representing some aspect of the dynamic linker, depending
+# on filetype. Corresponds to LC_ID_DYLINKER, LC_LOAD_DYLINKER, and
+# LC_DYLD_ENVIRONMENT.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#656
+class MachO::LoadCommands::DylinkerCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [LCStr] the dynamic linker's
+  #   path name as an LCStr
+  #
+  # source://ruby-macho//lib/macho/structure.rb#199
+  def name; end
+
+  # @api private
+  # @param context [SerializationContext] the context
+  # @return [String] the serialized fields of the load command
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#665
+  def serialize(context); end
+
+  # @return [Hash] a hash representation of this {DylinkerCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#675
+  def to_h; end
+
+  # source://ruby-macho//lib/macho/structure.rb#278
+  def to_s; end
+end
+
+# A load command containing symbolic information needed to support data
+# structures used by the dynamic link editor. Corresponds to LC_DYSYMTAB.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#869
+class MachO::LoadCommands::DysymtabCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the file offset to the referenced symbol table
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def extrefsymoff; end
+
+  # @return [Integer] the file offset to the external relocation entries
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def extreloff; end
+
+  # @return [Integer] the index to externally defined symbols
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def iextdefsym; end
+
+  # @return [Integer] the index to local symbols
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def ilocalsym; end
+
+  # @return [Integer] the file offset to the indirect symbol table
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def indirectsymoff; end
+
+  # @return [Integer] the index to undefined symbols
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def iundefsym; end
+
+  # @return [Integer] the file offset to the local relocation entries
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def locreloff; end
+
+  # @return [Integer] the file offset to the module table
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def modtaboff; end
+
+  # @return [Integer] the number of externally defined symbols
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def nextdefsym; end
+
+  # @return [Integer] the number of entries in the referenced symbol table
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def nextrefsyms; end
+
+  # @return [Integer] the number of external relocation entries
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def nextrel; end
+
+  # @return [Integer] the number of entries in the indirect symbol table
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def nindirectsyms; end
+
+  # @return [Integer] the number of local symbols
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def nlocalsym; end
+
+  # @return [Integer] the number of local relocation entries
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def nlocrel; end
+
+  # @return [Integer] the number of entries in the module table
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def nmodtab; end
+
+  # @return [Integer] the number of entries in the table of contents
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def ntoc; end
+
+  # @return [Integer] the number of undefined symbols
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def nundefsym; end
+
+  # @return [Hash] a hash representation of this {DysymtabCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#925
+  def to_h; end
+
+  # @return [Integer] the file offset to the table of contents
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def tocoff; end
+end
+
+# A load command representing the offset to and size of an encrypted
+# segment. Corresponds to LC_ENCRYPTION_INFO.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1079
+class MachO::LoadCommands::EncryptionInfoCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the encryption system, or 0 if not encrypted yet
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def cryptid; end
+
+  # @return [Integer] the offset to the encrypted segment
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def cryptoff; end
+
+  # @return [Integer] the size of the encrypted segment
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def cryptsize; end
+
+  # @return [Hash] a hash representation of this {EncryptionInfoCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1090
+  def to_h; end
+end
+
+# A load command representing the offset to and size of an encrypted
+# segment. Corresponds to LC_ENCRYPTION_INFO_64.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1101
+class MachO::LoadCommands::EncryptionInfoCommand64 < ::MachO::LoadCommands::EncryptionInfoCommand
+  # @return [Integer] 64-bit padding value
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def pad; end
+
+  # @return [Hash] a hash representation of this {EncryptionInfoCommand64}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1106
+  def to_h; end
+end
+
+# A load command specifying the offset of main(). Corresponds to LC_MAIN.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1316
+class MachO::LoadCommands::EntryPointCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the file (__TEXT) offset of main()
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def entryoff; end
+
+  # @return [Integer] if not 0, the initial stack size.
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def stacksize; end
+
+  # @return [Hash] a hash representation of this {EntryPointCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1324
+  def to_h; end
+end
+
+# A load command containing a description of a Mach-O that is a constituent of a fileset.
+# Each entry is further described by its own Mach header.
+# Corresponds to LC_FILESET_ENTRY.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1448
+class MachO::LoadCommands::FilesetEntryCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [LCStr] the entry's ID
+  #
+  # source://ruby-macho//lib/macho/structure.rb#199
+  def entry_id; end
+
+  # @return [Integer] the file offset of the entry
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def fileoff; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved; end
+
+  # @return [SegmentCommand64, nil] the matching segment command or nil if nothing matches
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1472
+  def segment; end
+
+  # @return [Hash] a hash representation of this {FilesetEntryCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1462
+  def to_h; end
+
+  # source://ruby-macho//lib/macho/structure.rb#278
+  def to_s; end
+
+  # @return [Integer] the virtual memory address of the entry
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def vmaddr; end
+end
+
+# An obsolete load command containing the path to a file to be loaded into
+# memory. Corresponds to LC_FVMFILE.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1385
+class MachO::LoadCommands::FvmfileCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the virtual address being loaded at
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def header_addr; end
+
+  # @return [LCStr] the pathname of the file being loaded
+  #
+  # source://ruby-macho//lib/macho/structure.rb#199
+  def name; end
+
+  # @return [Hash] a hash representation of this {FvmfileCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1393
+  def to_h; end
+
+  # source://ruby-macho//lib/macho/structure.rb#278
+  def to_s; end
+end
+
+# An obsolete load command containing the path to a library to be loaded
+# into memory. Corresponds to LC_LOADFVMLIB and LC_IDFVMLIB.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1403
+class MachO::LoadCommands::FvmlibCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the library's header address
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def header_addr; end
+
+  # @return [Integer] the library's minor version number
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def minor_version; end
+
+  # @return [LCStr] the library's target pathname
+  #
+  # source://ruby-macho//lib/macho/structure.rb#199
+  def name; end
+
+  # @return [Hash] a hash representation of this {FvmlibCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1414
+  def to_h; end
+
+  # source://ruby-macho//lib/macho/structure.rb#278
+  def to_s; end
+end
+
+# An obsolete load command containing a free format string table. Each
+# string is null-terminated and the command is zero-padded to a multiple of
+# 4. Corresponds to LC_IDENT.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1380
+class MachO::LoadCommands::IdentCommand < ::MachO::LoadCommands::LoadCommand; end
+
+# load commands added after OS X 10.1 need to be bitwise ORed with
+# LC_REQ_DYLD to be recognized by the dynamic linker (dyld)
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/load_commands.rb#9
+MachO::LoadCommands::LC_REQ_DYLD = T.let(T.unsafe(nil), Integer)
+
+# association of load command symbols to string representations of classes
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/load_commands.rb#95
+MachO::LoadCommands::LC_STRUCTURES = T.let(T.unsafe(nil), Hash)
+
+# association of load commands to symbol representations
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/load_commands.rb#13
+MachO::LoadCommands::LOAD_COMMANDS = T.let(T.unsafe(nil), Hash)
+
+# association of symbol representations to load command constants
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/load_commands.rb#73
+MachO::LoadCommands::LOAD_COMMAND_CONSTANTS = T.let(T.unsafe(nil), Hash)
+
+# A load command representing the offsets and sizes of a blob of data in
+# the __LINKEDIT segment. Corresponds to LC_CODE_SIGNATURE,
+# LC_SEGMENT_SPLIT_INFO, LC_FUNCTION_STARTS, LC_DATA_IN_CODE,
+# LC_DYLIB_CODE_SIGN_DRS, LC_LINKER_OPTIMIZATION_HINT, LC_DYLD_EXPORTS_TRIE,
+# LC_DYLD_CHAINED_FIXUPS, or LC_ATOM_INFO.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1061
+class MachO::LoadCommands::LinkeditDataCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] offset to the data in the __LINKEDIT segment
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def dataoff; end
+
+  # @return [Integer] size of the data in the __LINKEDIT segment
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def datasize; end
+
+  # @return [Hash] a hash representation of this {LinkeditDataCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1069
+  def to_h; end
+end
+
+# A load command containing linker options embedded in object files.
+# Corresponds to LC_LINKER_OPTION.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1303
+class MachO::LoadCommands::LinkerOptionCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the number of strings
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def count; end
+
+  # @return [Hash] a hash representation of this {LinkerOptionCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1308
+  def to_h; end
+end
+
+# The top-level Mach-O load command structure.
+#
+# This is the most generic load command -- only the type ID and size are
+# represented. Used when a more specific class isn't available or isn't implemented.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#216
+class MachO::LoadCommands::LoadCommand < ::MachO::MachOStructure
+  # @return [Integer] the load command's type ID
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def cmd; end
+
+  # @return [Integer] the size of the load command, in bytes
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def cmdsize; end
+
+  # @deprecated use {#view} instead
+  # @return [Integer] the load command's offset in the source file
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#281
+  def offset; end
+
+  # @return [Boolean] whether the load command can be serialized
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#263
+  def serializable?; end
+
+  # @api private
+  # @param context [SerializationContext] the context
+  #   to serialize into
+  # @raise [LoadCommandNotSerializableError]
+  # @return [String, nil] the serialized fields of the load command, or nil
+  #   if the load command can't be serialized
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#272
+  def serialize(context); end
+
+  # @note Children should override this to include additional information.
+  # @return [Hash] a hash representation of this load command
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#301
+  def to_h; end
+
+  # @return [String] a string representation of the load command's
+  #   identifying number
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#295
+  def to_s; end
+
+  # @return [Symbol, nil] a symbol representation of the load command's
+  #   type ID, or nil if the ID doesn't correspond to a known load command class
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#287
+  def to_sym; end
+
+  # @return [Symbol, nil] a symbol representation of the load command's
+  #   type ID, or nil if the ID doesn't correspond to a known load command class
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#287
+  def type; end
+
+  # @return [MachO::MachOView, nil] the raw view associated with the load command,
+  #   or nil if the load command was created via {create}.
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def view; end
+
+  class << self
+    # Creates a new (viewless) command corresponding to the symbol provided
+    #
+    # @param cmd_sym [Symbol] the symbol of the load command being created
+    # @param args [Array] the arguments for the load command being created
+    # @raise [LoadCommandNotCreatableError]
+    #
+    # source://ruby-macho//lib/macho/load_commands.rb#241
+    def create(cmd_sym, *args); end
+
+    # Instantiates a new LoadCommand given a view into its origin Mach-O
+    #
+    # @api private
+    # @param view [MachO::MachOView] the load command's raw view
+    # @return [LoadCommand] the new load command
+    #
+    # source://ruby-macho//lib/macho/load_commands.rb#231
+    def new_from_bin(view); end
+  end
+end
+
+# Represents a Load Command string. A rough analogue to the lc_str
+# struct used internally by OS X. This class allows ruby-macho to
+# pretend that strings stored in LCs are immediately available without
+# explicit operations on the raw Mach-O data.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#314
+class MachO::LoadCommands::LoadCommand::LCStr
+  # @api private
+  # @param lc [LoadCommand] the load command
+  # @param lc_str [Integer, String] the offset to the beginning of the
+  #   string, or the string itself if not being initialized with a view.
+  # @raise [MachO::LCStrMalformedError] if the string is malformed
+  # @return [LCStr] a new instance of LCStr
+  # @todo devise a solution such that the `lc_str` parameter is not
+  #   interpreted differently depending on `lc.view`. The current behavior
+  #   is a hack to allow viewless load command creation.
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#323
+  def initialize(lc, lc_str); end
+
+  # @return [Hash] a hash representation of this {LCStr}.
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#353
+  def to_h; end
+
+  # @return [Integer] the offset to the beginning of the string in the
+  #   load command
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#348
+  def to_i; end
+
+  # @return [String] a string representation of the LCStr
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#342
+  def to_s; end
+end
+
+# Represents the contextual information needed by a load command to
+# serialize itself correctly into a binary string.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#363
+class MachO::LoadCommands::LoadCommand::SerializationContext
+  # @api private
+  # @param endianness [Symbol] the endianness of the context
+  # @param alignment [Integer] the alignment of the context
+  # @return [SerializationContext] a new instance of SerializationContext
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#381
+  def initialize(endianness, alignment); end
+
+  # @return [Integer] the constant alignment value used to pad the
+  #   serialized load command
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#369
+  def alignment; end
+
+  # @return [Symbol] the endianness of the serialized load command
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#365
+  def endianness; end
+
+  class << self
+    # @param macho [MachO::MachOFile] the file to contextualize
+    # @return [SerializationContext] the
+    #   resulting context
+    #
+    # source://ruby-macho//lib/macho/load_commands.rb#374
+    def context_for(macho); end
+  end
+end
+
+# A load command containing an owner name and offset/size for an arbitrary data region.
+# Corresponds to LC_NOTE.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1425
+class MachO::LoadCommands::NoteCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [String] the name of the owner for this note
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def data_owner; end
+
+  # @return [Integer] the offset, within the file, of the note
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def offset; end
+
+  # @return [Integer] the size, in bytes, of the note
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def size; end
+
+  # @return [Hash] a hash representation of this {NoteCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1436
+  def to_h; end
+
+  # source://ruby-macho//lib/macho/structure.rb#278
+  def to_s; end
+end
+
+# A load command containing the value of the original checksum for prebound
+# files, or zero. Corresponds to LC_PREBIND_CKSUM.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1017
+class MachO::LoadCommands::PrebindCksumCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the checksum or 0
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def cksum; end
+
+  # @return [Hash] a hash representation of this {PrebindCksumCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1022
+  def to_h; end
+end
+
+# A load command used to indicate dynamic libraries used in prebinding.
+# Corresponds to LC_PREBOUND_DYLIB.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#684
+class MachO::LoadCommands::PreboundDylibCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] a bit vector of linked modules
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def linked_modules; end
+
+  # @return [LCStr] the library's path
+  #   name as an LCStr
+  #
+  # source://ruby-macho//lib/macho/structure.rb#199
+  def name; end
+
+  # @return [Integer] the number of modules in the library
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def nmodules; end
+
+  # @return [Hash] a hash representation of this {PreboundDylibCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#696
+  def to_h; end
+
+  # source://ruby-macho//lib/macho/structure.rb#278
+  def to_s; end
+end
+
+# A load command containing the address of the dynamic shared library
+# initialization routine and an index into the module table for the module
+# that defines the routine. Corresponds to LC_ROUTINES.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#714
+class MachO::LoadCommands::RoutinesCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the address of the initialization routine
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def init_address; end
+
+  # @return [Integer] the index into the module table that the init routine
+  #   is defined in
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def init_module; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved1; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved2; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved3; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved4; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved5; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved6; end
+
+  # @return [Hash] a hash representation of this {RoutinesCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#741
+  def to_h; end
+end
+
+# A load command containing the address of the dynamic shared library
+# initialization routine and an index into the module table for the module
+# that defines the routine. Corresponds to LC_ROUTINES_64.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#758
+class MachO::LoadCommands::RoutinesCommand64 < ::MachO::LoadCommands::RoutinesCommand
+  # @return [Integer] the address of the initialization routine
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def init_address; end
+
+  # @return [Integer] the index into the module table that the init routine
+  #   is defined in
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def init_module; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved1; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved2; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved3; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved4; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved5; end
+
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved6; end
+end
+
+# A load command representing an rpath, which specifies a path that should
+# be added to the current run path used to find @rpath prefixed dylibs.
+# Corresponds to LC_RPATH.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1032
+class MachO::LoadCommands::RpathCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [LCStr] the path to add to the run path as an LCStr
+  #
+  # source://ruby-macho//lib/macho/structure.rb#199
+  def path; end
+
+  # @api private
+  # @param context [SerializationContext] the context
+  # @return [String] the serialized fields of the load command
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1039
+  def serialize(context); end
+
+  # @return [Hash] a hash representation of this {RpathCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1049
+  def to_h; end
+
+  # source://ruby-macho//lib/macho/structure.rb#278
+  def to_s; end
+end
+
+# association of segment flag symbols to values
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/load_commands.rb#190
+MachO::LoadCommands::SEGMENT_FLAGS = T.let(T.unsafe(nil), Hash)
+
+# association of segment name symbols to names
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/load_commands.rb#162
+MachO::LoadCommands::SEGMENT_NAMES = T.let(T.unsafe(nil), Hash)
+
+# A load command indicating that part of this file is to be mapped into
+# the task's address space. Corresponds to LC_SEGMENT.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#422
+class MachO::LoadCommands::SegmentCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the file offset of the segment
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def fileoff; end
+
+  # @return [Integer] the amount to map from the file
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def filesize; end
+
+  # @example
+  #   puts "this segment relocated in/to it" if sect.flag?(:SG_NORELOC)
+  # @param flag [Symbol] a segment flag symbol
+  # @return [Boolean] true if `flag` is present in the segment's flag field
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#474
+  def flag?(flag); end
+
+  # @return [Integer] any flags associated with the segment
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def flags; end
+
+  # Guesses the alignment of the segment.
+  #
+  # @note See `guess_align` in `cctools/misc/lipo.c`
+  # @return [Integer] the guessed alignment, as a power of 2
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#485
+  def guess_align; end
+
+  # @return [Integer] the initial VM protection
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def initprot; end
+
+  # @return [Integer] the maximum VM protection
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def maxprot; end
+
+  # @return [Integer] the number of sections in the segment
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def nsects; end
+
+  # All sections referenced within this segment.
+  #
+  # @return [Array<MachO::Sections::Section>] if the Mach-O is 32-bit
+  # @return [Array<MachO::Sections::Section64>] if the Mach-O is 64-bit
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#453
+  def sections; end
+
+  # @return [String] the name of the segment
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def segname; end
+
+  # @return [Hash] a hash representation of this {SegmentCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#503
+  def to_h; end
+
+  # source://ruby-macho//lib/macho/structure.rb#278
+  def to_s; end
+
+  # @return [Integer] the memory address of the segment
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def vmaddr; end
+
+  # @return [Integer] the memory size of the segment
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def vmsize; end
+end
+
+# A load command indicating that part of this file is to be mapped into
+# the task's address space. Corresponds to LC_SEGMENT_64.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#521
+class MachO::LoadCommands::SegmentCommand64 < ::MachO::LoadCommands::SegmentCommand
+  # @return [Integer] the file offset of the segment
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def fileoff; end
+
+  # @return [Integer] the amount to map from the file
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def filesize; end
+
+  # @return [Integer] the memory address of the segment
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def vmaddr; end
+
+  # @return [Integer] the memory size of the segment
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def vmsize; end
+end
+
+# A load command specifying the version of the sources used to build the
+# binary. Corresponds to LC_SOURCE_VERSION.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1334
+class MachO::LoadCommands::SourceVersionCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Hash] a hash representation of this {SourceVersionCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1351
+  def to_h; end
+
+  # @return [Integer] the version packed as a24.b10.c10.d10.e10
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def version; end
+
+  # A string representation of the sources used to build the binary.
+  #
+  # @return [String] a string representation of the version
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1340
+  def version_string; end
+end
+
+# A load command signifying a shared library that is a subframework of
+# an umbrella framework. Corresponds to LC_SUB_CLIENT.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#829
+class MachO::LoadCommands::SubClientCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [LCStr] the subclient name as an LCStr
+  #
+  # source://ruby-macho//lib/macho/structure.rb#199
+  def sub_client; end
+
+  # @return [Hash] a hash representation of this {SubClientCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#834
+  def to_h; end
+
+  # source://ruby-macho//lib/macho/structure.rb#278
+  def to_s; end
+end
+
+# A load command signifying membership of a subframework containing the name
+# of an umbrella framework. Corresponds to LC_SUB_FRAMEWORK.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#787
+class MachO::LoadCommands::SubFrameworkCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Hash] a hash representation of this {SubFrameworkCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#792
+  def to_h; end
+
+  # source://ruby-macho//lib/macho/structure.rb#278
+  def to_s; end
+
+  # @return [LCStr] the umbrella framework name as an LCStr
+  #
+  # source://ruby-macho//lib/macho/structure.rb#199
+  def umbrella; end
+end
+
+# A load command signifying a sublibrary of a shared library. Corresponds
+# to LC_SUB_LIBRARY.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#815
+class MachO::LoadCommands::SubLibraryCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [LCStr] the sublibrary name as an LCStr
+  #
+  # source://ruby-macho//lib/macho/structure.rb#199
+  def sub_library; end
+
+  # @return [Hash] a hash representation of this {SubLibraryCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#820
+  def to_h; end
+
+  # source://ruby-macho//lib/macho/structure.rb#278
+  def to_s; end
+end
+
+# A load command signifying membership of a subumbrella containing the name
+# of an umbrella framework. Corresponds to LC_SUB_UMBRELLA.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#801
+class MachO::LoadCommands::SubUmbrellaCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [LCStr] the subumbrella framework name as an LCStr
+  #
+  # source://ruby-macho//lib/macho/structure.rb#199
+  def sub_umbrella; end
+
+  # @return [Hash] a hash representation of this {SubUmbrellaCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#806
+  def to_h; end
+
+  # source://ruby-macho//lib/macho/structure.rb#278
+  def to_s; end
+end
+
+# An obsolete load command containing the offset and size of the (GNU style)
+# symbol table information. Corresponds to LC_SYMSEG.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1361
+class MachO::LoadCommands::SymsegCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the offset to the symbol segment
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def offset; end
+
+  # @return [Integer] the size of the symbol segment in bytes
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def size; end
+
+  # @return [Hash] a hash representation of this {SymsegCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1369
+  def to_h; end
+end
+
+# A load command containing the offsets and sizes of the link-edit 4.3BSD
+# "stab" style symbol table information. Corresponds to LC_SYMTAB.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#843
+class MachO::LoadCommands::SymtabCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the number of symbol table entries
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def nsyms; end
+
+  # @return [Integer] the string table's offset
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def stroff; end
+
+  # @return [Integer] the string table size in bytes
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def strsize; end
+
+  # @return [Integer] the symbol table's offset
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def symoff; end
+
+  # @return [Hash] a hash representation of this {SymtabCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#857
+  def to_h; end
+end
+
+# A load command used to represent threads.
+# out except the common ones (cmd, cmdsize)
+#
+# @note cctools-870 and onwards have all fields of thread_command commented
+#
+# source://ruby-macho//lib/macho/load_commands.rb#708
+class MachO::LoadCommands::ThreadCommand < ::MachO::LoadCommands::LoadCommand; end
+
+# A load command containing the offset and number of hints in the two-level
+# namespace lookup hints table. Corresponds to LC_TWOLEVEL_HINTS.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#951
+class MachO::LoadCommands::TwolevelHintsCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the offset to the hint table
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def htoffset; end
+
+  # @return [Integer] the number of hints in the hint table
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def nhints; end
+
+  # @return [TwolevelHintsTable] the hint table
+  #
+  # source://ruby-macho//lib/macho/structure.rb#206
+  def table; end
+
+  # @return [Hash] a hash representation of this {TwolevelHintsCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#963
+  def to_h; end
+end
+
+# A representation of the two-level namespace lookup hints table exposed
+# by a {TwolevelHintsCommand} (`LC_TWOLEVEL_HINTS`).
+#
+# source://ruby-macho//lib/macho/load_commands.rb#973
+class MachO::LoadCommands::TwolevelHintsCommand::TwolevelHintsTable
+  # @api private
+  # @param view [MachO::MachOView] the view into the current Mach-O
+  # @param htoffset [Integer] the offset of the hints table
+  # @param nhints [Integer] the number of two-level hints in the table
+  # @return [TwolevelHintsTable] a new instance of TwolevelHintsTable
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#981
+  def initialize(view, htoffset, nhints); end
+
+  # @return [Array<TwolevelHint>] all hints in the table
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#975
+  def hints; end
+end
+
+# An individual two-level namespace lookup hint.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#990
+class MachO::LoadCommands::TwolevelHintsCommand::TwolevelHintsTable::TwolevelHint
+  # @api private
+  # @param blob [Integer] the 32-bit number containing the lookup hint
+  # @return [TwolevelHint] a new instance of TwolevelHint
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#999
+  def initialize(blob); end
+
+  # @return [Integer] the index into the sub-images
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#992
+  def isub_image; end
+
+  # @return [Integer] the index into the table of contents
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#995
+  def itoc; end
+
+  # @return [Hash] a hash representation of this {TwolevelHint}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1005
+  def to_h; end
+end
+
+# A load command containing a single 128-bit unique random number
+# identifying an object produced by static link editor. Corresponds to
+# LC_UUID.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#391
+class MachO::LoadCommands::UUIDCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Hash] returns a hash representation of this {UUIDCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#412
+  def to_h; end
+
+  # @return [String] an alias for uuid_string
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#407
+  def to_s; end
+
+  # @return [Array<Integer>] the UUID
+  #
+  # source://ruby-macho//lib/macho/structure.rb#242
+  def uuid; end
+
+  # @return [String] a string representation of the UUID
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#396
+  def uuid_string; end
+end
+
+# A load command containing the minimum OS version on which the binary
+# was built to run. Corresponds to LC_VERSION_MIN_MACOSX and
+# LC_VERSION_MIN_IPHONEOS.
+#
+# source://ruby-macho//lib/macho/load_commands.rb#1116
+class MachO::LoadCommands::VersionMinCommand < ::MachO::LoadCommands::LoadCommand
+  # @return [Integer] the SDK version X.Y.Z packed as x16.y8.z8
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def sdk; end
+
+  # A string representation of the binary's SDK version.
+  #
+  # @return [String] a string representing the SDK version.
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1136
+  def sdk_string; end
+
+  # @return [Hash] a hash representation of this {VersionMinCommand}
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1146
+  def to_h; end
+
+  # @return [Integer] the version X.Y.Z packed as x16.y8.z8
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def version; end
+
+  # A string representation of the binary's minimum OS version.
+  #
+  # @return [String] a string representing the minimum OS version.
+  #
+  # source://ruby-macho//lib/macho/load_commands.rb#1125
+  def version_string; end
+end
+
+# Raised when a Mach-O is loaded with FatFile.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#89
+class MachO::MachOBinaryError < ::MachO::MachOError
+  # @return [MachOBinaryError] a new instance of MachOBinaryError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#90
+  def initialize; end
+end
+
+# A generic Mach-O error in execution.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#5
+class MachO::MachOError < ::RuntimeError; end
+
+# Represents a Mach-O file, which contains a header and load commands
+# as well as binary executable instructions. Mach-O binaries are
+# architecture specific.
+#
+# @see https://en.wikipedia.org/wiki/Mach-O
+# @see FatFile
+#
+# source://ruby-macho//lib/macho/macho_file.rb#11
+class MachO::MachOFile
+  extend ::Forwardable
+
+  # Creates a new instance from data read from the given filename.
+  #
+  # @note The `:decompress` option relies on non-default dependencies. Compression
+  #   is only used in niche Mach-Os, so leaving this disabled is a reasonable default for
+  #   virtually all normal uses.
+  # @option opts
+  # @option opts
+  # @param filename [String] the Mach-O file to load from
+  # @param opts [Hash] options to control the parser with
+  # @raise [ArgumentError] if the given file does not exist
+  # @return [MachOFile] a new instance of MachOFile
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#58
+  def initialize(filename, **opts); end
+
+  # All load commands of a given name.
+  #
+  # @example
+  #   file.command("LC_LOAD_DYLIB")
+  #   file[:LC_LOAD_DYLIB]
+  # @param name [String, Symbol] the load command ID
+  # @return [Array<LoadCommands::LoadCommand>] an array of load commands
+  #   corresponding to `name`
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#149
+  def [](name); end
+
+  # Appends a new load command to the Mach-O.
+  #
+  # @note This is public, but methods like {#add_rpath} should be preferred.
+  #   Setting `repopulate` to false **will leave the instance in an
+  #   inconsistent state** unless {#populate_fields} is called **immediately**
+  #   afterwards.
+  # @option f
+  # @param lc [LoadCommands::LoadCommand] the load command being added
+  # @param options [Hash]
+  # @param f [Hash] a customizable set of options
+  # @return [void]
+  # @see #insert_command
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#215
+  def add_command(lc, options = T.unsafe(nil)); end
+
+  # Add the given runtime path to the Mach-O.
+  #
+  # @example
+  #   file.rpaths # => ["/lib"]
+  #   file.add_rpath("/usr/lib")
+  #   file.rpaths # => ["/lib", "/usr/lib"]
+  # @note `_options` is currently unused and is provided for signature
+  #   compatibility with {MachO::FatFile#add_rpath}
+  # @param path [String] the new runtime path
+  # @param _options [Hash]
+  # @raise [RpathExistsError] if the runtime path already exists
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#405
+  def add_rpath(path, _options = T.unsafe(nil)); end
+
+  # @return [Integer] the file's internal alignment
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def alignment(*args, **_arg1, &block); end
+
+  # @return [Boolean] whether or not the file is of type `MH_BUNDLE`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def bundle?(*args, **_arg1, &block); end
+
+  # Changes the shared library `old_name` to `new_name`
+  #
+  # @example
+  #   file.change_install_name("abc.dylib", "def.dylib")
+  # @note `_options` is currently unused and is provided for signature
+  #   compatibility with {MachO::FatFile#change_install_name}
+  # @param old_name [String] the shared library's old name
+  # @param new_name [String] the shared library's new name
+  # @param _options [Hash]
+  # @raise [DylibUnknownError] if no shared library has the old name
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#354
+  def change_dylib(old_name, new_name, _options = T.unsafe(nil)); end
+
+  # Changes the Mach-O's dylib ID to `new_id`. Does nothing if not a dylib.
+  #
+  # @example
+  #   file.change_dylib_id("libFoo.dylib")
+  # @note `_options` is currently unused and is provided for signature
+  #   compatibility with {MachO::FatFile#change_dylib_id}
+  # @param new_id [String] the dylib's new ID
+  # @param _options [Hash]
+  # @raise [ArgumentError] if `new_id` is not a String
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#317
+  def change_dylib_id(new_id, _options = T.unsafe(nil)); end
+
+  # Changes the shared library `old_name` to `new_name`
+  #
+  # @example
+  #   file.change_install_name("abc.dylib", "def.dylib")
+  # @note `_options` is currently unused and is provided for signature
+  #   compatibility with {MachO::FatFile#change_install_name}
+  # @param old_name [String] the shared library's old name
+  # @param new_name [String] the shared library's new name
+  # @param _options [Hash]
+  # @raise [DylibUnknownError] if no shared library has the old name
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#354
+  def change_install_name(old_name, new_name, _options = T.unsafe(nil)); end
+
+  # Changes the runtime path `old_path` to `new_path`
+  #
+  # @example
+  #   file.change_rpath("/usr/lib", "/usr/local/lib")
+  # @option options
+  # @param old_path [String] the old runtime path
+  # @param new_path [String] the new runtime path
+  # @param options [Hash]
+  # @raise [RpathUnknownError] if no such old runtime path exists
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#384
+  def change_rpath(old_path, new_path, options = T.unsafe(nil)); end
+
+  # All load commands of a given name.
+  #
+  # @example
+  #   file.command("LC_LOAD_DYLIB")
+  #   file[:LC_LOAD_DYLIB]
+  # @param name [String, Symbol] the load command ID
+  # @return [Array<LoadCommands::LoadCommand>] an array of load commands
+  #   corresponding to `name`
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#149
+  def command(name); end
+
+  # @return [Boolean] whether or not the file is of type `MH_CORE`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def core?(*args, **_arg1, &block); end
+
+  # @return [Symbol] a symbol representation of the Mach-O's CPU subtype
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#138
+  def cpusubtype; end
+
+  # @return [Symbol] a symbol representation of the Mach-O's CPU type
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#133
+  def cputype; end
+
+  # Delete a load command from the Mach-O.
+  #
+  # @note This is public, but methods like {#delete_rpath} should be preferred.
+  #   Setting `repopulate` to false **will leave the instance in an
+  #   inconsistent state** unless {#populate_fields} is called **immediately**
+  #   afterwards.
+  # @option options
+  # @param lc [LoadCommands::LoadCommand] the load command being deleted
+  # @param options [Hash]
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#229
+  def delete_command(lc, options = T.unsafe(nil)); end
+
+  # Delete the given runtime path from the Mach-O.
+  #
+  # @example
+  #   file1.rpaths # => ["/lib", "/usr/lib", "/lib"]
+  #   file1.delete_rpath("/lib")
+  #   file1.rpaths # => ["/usr/lib", "/lib"]
+  #   file2.rpaths # => ["foo", "foo"]
+  #   file2.delete_rpath("foo", :uniq => true)
+  #   file2.rpaths # => []
+  #   file3.rpaths # => ["foo", "bar", "foo"]
+  #   file3.delete_rpath("foo", :last => true)
+  #   file3.rpaths # => ["foo", "bar"]
+  # @option options
+  # @option options
+  # @param options [Hash]
+  # @param path [String] the runtime path to delete
+  # @raise [RpathUnknownError] if no such runtime path exists
+  # @raise [ArgumentError] if both :uniq and :last are true
+  # @return void
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#434
+  def delete_rpath(path, options = T.unsafe(nil)); end
+
+  # @return [Boolean] whether or not the file is of type `MH_DSYM`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def dsym?(*args, **_arg1, &block); end
+
+  # @return [Boolean] whether or not the file is of type `MH_DYLIB`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def dylib?(*args, **_arg1, &block); end
+
+  # The Mach-O's dylib ID, or `nil` if not a dylib.
+  #
+  # @example
+  #   file.dylib_id # => 'libBar.dylib'
+  # @return [String, nil] the Mach-O's dylib ID
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#300
+  def dylib_id; end
+
+  # Changes the Mach-O's dylib ID to `new_id`. Does nothing if not a dylib.
+  #
+  # @example
+  #   file.change_dylib_id("libFoo.dylib")
+  # @note `_options` is currently unused and is provided for signature
+  #   compatibility with {MachO::FatFile#change_dylib_id}
+  # @param new_id [String] the dylib's new ID
+  # @param _options [Hash]
+  # @raise [ArgumentError] if `new_id` is not a String
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#317
+  def dylib_id=(new_id, _options = T.unsafe(nil)); end
+
+  # All load commands responsible for loading dylibs.
+  #
+  # @return [Array<LoadCommands::DylibCommand>] an array of DylibCommands
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#254
+  def dylib_load_commands; end
+
+  # @return [Boolean] whether or not the file is of type `MH_DYLINKER`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def dylinker?(*args, **_arg1, &block); end
+
+  # @return [Symbol] the endianness of the file, :big or :little
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#22
+  def endianness; end
+
+  # @return [Boolean] whether or not the file is of type `MH_EXECUTE`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def executable?(*args, **_arg1, &block); end
+
+  # @return [String, nil] the filename loaded from, or nil if loaded from a binary
+  #   string
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#16
+  def filename; end
+
+  # @return [String, nil] the filename loaded from, or nil if loaded from a binary
+  #   string
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#16
+  def filename=(_arg0); end
+
+  # @return [Symbol] a string representation of the Mach-O's filetype
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#128
+  def filetype; end
+
+  # @return [Integer] the header flags associated with the Mach-O
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def flags(*args, **_arg1, &block); end
+
+  # @return [Boolean] whether or not the file is of type `MH_FVMLIB`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def fvmlib?(*args, **_arg1, &block); end
+
+  # @return [Headers::MachHeader] if the Mach-O is 32-bit
+  # @return [Headers::MachHeader64] if the Mach-O is 64-bit
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#26
+  def header; end
+
+  # Initializes a new MachOFile instance from a binary string with the given options.
+  #
+  # @api private
+  # @see MachO::MachOFile.new_from_bin
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#70
+  def initialize_from_bin(bin, opts); end
+
+  # Inserts a load command at the given offset.
+  # **will leave the object in an inconsistent state**.
+  #
+  # @note Calling this method with an arbitrary offset in the load command region
+  # @option options
+  # @param offset [Integer] the offset to insert at
+  # @param lc [LoadCommands::LoadCommand] the load command to insert
+  # @param options [Hash]
+  # @raise [OffsetInsertionError] if the offset is not in the load command region
+  # @raise [HeaderPadError] if the new command exceeds the header pad buffer
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#165
+  def insert_command(offset, lc, options = T.unsafe(nil)); end
+
+  # @return [Boolean] whether or not the file is of type `MH_KEXT_BUNDLE`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def kext?(*args, **_arg1, &block); end
+
+  # All shared libraries linked to the Mach-O.
+  #
+  # @return [Array<String>] an array of all shared libraries
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#336
+  def linked_dylibs; end
+
+  # @note load commands are provided in order of ascending offset.
+  # @return [Array<LoadCommands::LoadCommand>] an array of the file's load
+  #   commands
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#31
+  def load_commands; end
+
+  # @return [Integer] the magic number
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def magic(*args, **_arg1, &block); end
+
+  # @return [Boolean] true if the Mach-O has 32-bit magic, false otherwise
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def magic32?(*args, **_arg1, &block); end
+
+  # @return [Boolean] true if the Mach-O has 64-bit magic, false otherwise
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def magic64?(*args, **_arg1, &block); end
+
+  # @return [String] a string representation of the file's magic number
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#123
+  def magic_string; end
+
+  # @return [Integer] the number of load commands in the Mach-O
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def ncmds(*args, **_arg1, &block); end
+
+  # @return [Boolean] whether or not the file is of type `MH_OBJECT`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def object?(*args, **_arg1, &block); end
+
+  # @return [Hash] any parser options that the instance was created with
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#19
+  def options; end
+
+  # Populate the instance's fields with the raw Mach-O data.
+  #
+  # @note This method is public, but should (almost) never need to be called.
+  #   The exception to this rule is when methods like {#add_command} and
+  #   {#delete_command} have been called with `repopulate = false`.
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#247
+  def populate_fields; end
+
+  # @return [Boolean] whether or not the file is of type `MH_PRELOAD`
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def preload?(*args, **_arg1, &block); end
+
+  # Replace a load command with another command in the Mach-O, preserving location.
+  #
+  # @note This is public, but methods like {#dylib_id=} should be preferred.
+  # @param old_lc [LoadCommands::LoadCommand] the load command being replaced
+  # @param new_lc [LoadCommands::LoadCommand] the load command being added
+  # @raise [HeaderPadError] if the new command exceeds the header pad buffer
+  # @return [void]
+  # @see #insert_command
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#193
+  def replace_command(old_lc, new_lc); end
+
+  # All runtime paths searched by the dynamic linker for the Mach-O.
+  #
+  # @return [Array<String>] an array of all runtime paths
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#370
+  def rpaths; end
+
+  # The segment alignment for the Mach-O. Guesses conservatively.
+  #
+  # @note This is **not** the same as {#alignment}!
+  # @note See `get_align` and `get_align_64` in `cctools/misc/lipo.c`
+  # @return [Integer] the alignment, as a power of 2
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#273
+  def segment_alignment; end
+
+  # All segment load commands in the Mach-O.
+  #
+  # @return [Array<LoadCommands::SegmentCommand>] if the Mach-O is 32-bit
+  # @return [Array<LoadCommands::SegmentCommand64>] if the Mach-O is 64-bit
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#261
+  def segments; end
+
+  # The file's raw Mach-O data.
+  #
+  # @return [String] the raw Mach-O data
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#79
+  def serialize; end
+
+  # @return [Integer] the size of all load commands, in bytes, in the Mach-O
+  #
+  # source://forwardable/1.3.3/forwardable.rb#231
+  def sizeofcmds(*args, **_arg1, &block); end
+
+  # @return [Hash] a hash representation of this {MachOFile}
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#469
+  def to_h; end
+
+  # Write all Mach-O data to the given filename.
+  #
+  # @param filename [String] the file to write to
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#454
+  def write(filename); end
+
+  # Write all Mach-O data to the file used to initialize the instance.
+  #
+  # @note Overwrites all data in the file!
+  # @raise [MachOError] if the instance was initialized without a file
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#462
+  def write!; end
+
+  private
+
+  # Check the file's CPU type/subtype pair.
+  #
+  # @api private
+  # @param cpusubtype [Integer] the CPU subtype
+  # @raise [CPUSubtypeError] if the CPU sub-type is unknown
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#571
+  def check_cpusubtype(cputype, cpusubtype); end
+
+  # Check the file's CPU type.
+  #
+  # @api private
+  # @param cputype [Integer] the CPU type
+  # @raise [CPUTypeError] if the CPU type is unknown
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#563
+  def check_cputype(cputype); end
+
+  # Check the file's type.
+  #
+  # @api private
+  # @param filetype [Integer] the file type
+  # @raise [FiletypeError] if the file type is unknown
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#580
+  def check_filetype(filetype); end
+
+  # Attempt to decompress a Mach-O file from the data specified in a prelinked kernel header.
+  #
+  # @api private
+  # @note This method rewrites the internal state of {MachOFile} to pretend as if it was never
+  #   compressed to begin with, allowing all other APIs to transparently act on compressed Mach-Os.
+  # @raise [DecompressionError] if decompression is impossible or fails
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#524
+  def decompress_macho_lzvn; end
+
+  # The low file offset (offset to first section data).
+  #
+  # @api private
+  # @return [Integer] the offset
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#621
+  def low_fileoff; end
+
+  # Read just the file's magic number and check its validity.
+  #
+  # @api private
+  # @raise [MagicError] if the magic is not valid Mach-O magic
+  # @raise [FatBinaryError] if the magic is for a Fat file
+  # @return [Integer] the magic
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#548
+  def populate_and_check_magic; end
+
+  # All load commands in the file.
+  #
+  # @api private
+  # @raise [LoadCommandError] if an unknown load command is encountered
+  # @return [Array<LoadCommands::LoadCommand>] an array of load commands
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#588
+  def populate_load_commands; end
+
+  # The file's Mach-O header structure.
+  #
+  # @api private
+  # @raise [TruncatedFileError] if the file is too small to have a valid header
+  # @return [Headers::MachHeader] if the Mach-O is 32-bit
+  # @return [Headers::MachHeader64] if the Mach-O is 64-bit
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#483
+  def populate_mach_header; end
+
+  # Read a compressed Mach-O header and check its validity, as well as whether we're able
+  # to parse it.
+  #
+  # @api private
+  # @raise [CompressedMachOError] if we weren't asked to perform decompression
+  # @raise [DecompressionError] if decompression is impossible or fails
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#507
+  def populate_prelinked_kernel_header; end
+
+  # Updates the number of load commands in the raw data.
+  #
+  # @api private
+  # @param ncmds [Integer] the new number of commands
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#642
+  def update_ncmds(ncmds); end
+
+  # Updates the size of all load commands in the raw data.
+  #
+  # @api private
+  # @param size [Integer] the new size, in bytes
+  # @return [void]
+  #
+  # source://ruby-macho//lib/macho/macho_file.rb#652
+  def update_sizeofcmds(size); end
+
+  class << self
+    # Creates a new instance from a binary string.
+    #
+    # @note The `:decompress` option relies on non-default dependencies. Compression
+    #   is only used in niche Mach-Os, so leaving this disabled is a reasonable default for
+    #   virtually all normal uses.
+    # @option opts
+    # @option opts
+    # @param bin [String] a binary string containing raw Mach-O data
+    # @param opts [Hash] options to control the parser with
+    # @return [MachOFile] a new MachOFile
+    #
+    # source://ruby-macho//lib/macho/macho_file.rb#42
+    def new_from_bin(bin, **opts); end
+  end
+end
+
+# A general purpose pseudo-structure. Described in detail in docs/machostructure-dsl.md.
+#
+# @abstract
+#
+# source://ruby-macho//lib/macho/structure.rb#6
+class MachO::MachOStructure
+  # @param args [Array[Value]] list of field parameters
+  # @raise [ArgumentError]
+  # @return [MachOStructure] a new instance of MachOStructure
+  #
+  # source://ruby-macho//lib/macho/structure.rb#75
+  def initialize(*args); end
+
+  # @return [Hash] a hash representation of this {MachOStructure}.
+  #
+  # source://ruby-macho//lib/macho/structure.rb#82
+  def to_h; end
+
+  class << self
+    # source://ruby-macho//lib/macho/structure.rb#108
+    def bytesize; end
+
+    # source://ruby-macho//lib/macho/structure.rb#104
+    def format; end
+
+    # Returns the value of attribute min_args.
+    #
+    # source://ruby-macho//lib/macho/structure.rb#92
+    def min_args; end
+
+    # @api private
+    # @param endianness [Symbol] either `:big` or `:little`
+    # @param bin [String] the string to be unpacked into the new structure
+    # @return [MachO::MachOStructure] the resulting structure
+    #
+    # source://ruby-macho//lib/macho/structure.rb#98
+    def new_from_bin(endianness, bin); end
+
+    private
+
+    # Generates a reader method for classes that need to be initialized.
+    # These classes are defined in the Fields::CLASSES_TO_INIT array.
+    #
+    # @api private
+    # @param name [Symbol] name of internal field
+    # @param type [Symbol] type of field in terms of binary size
+    # @param idx [Integer] the index of the field value in the @values array
+    #
+    # source://ruby-macho//lib/macho/structure.rb#196
+    def def_class_reader(name, type, idx); end
+
+    # Generates a reader method for fields that have default values.
+    #
+    # @api private
+    # @param name [Symbol] name of internal field
+    # @param idx [Integer] the index of the field value in the @values array
+    # @param default [Value] the default value
+    #
+    # source://ruby-macho//lib/macho/structure.rb#255
+    def def_default_reader(name, idx, default); end
+
+    # Generates a reader method for fields that need to be bitmasked.
+    #
+    # @api private
+    # @param name [Symbol] name of internal field
+    # @param idx [Integer] the index of the field value in the @values array
+    # @param mask [Integer] the bitmask
+    #
+    # source://ruby-macho//lib/macho/structure.rb#227
+    def def_mask_reader(name, idx, mask); end
+
+    # Generates an attr_reader like method for a field.
+    #
+    # @api private
+    # @param name [Symbol] name of internal field
+    # @param idx [Integer] the index of the field value in the @values array
+    #
+    # source://ruby-macho//lib/macho/structure.rb#268
+    def def_reader(name, idx); end
+
+    # Generates the to_s method based on the named field.
+    #
+    # @api private
+    # @param name [Symbol] name of the field
+    #
+    # source://ruby-macho//lib/macho/structure.rb#277
+    def def_to_s(name); end
+
+    # Generates a reader method for fields that need further unpacking.
+    #
+    # @api private
+    # @param name [Symbol] name of internal field
+    # @param idx [Integer] the index of the field value in the @values array
+    # @param unpack [String] the format code used for further binary unpacking
+    #
+    # source://ruby-macho//lib/macho/structure.rb#241
+    def def_unpack_reader(name, idx, unpack); end
+
+    # Expected options
+    #   :size [Integer] size in bytes
+    #   :mask [Integer] bitmask
+    #   :unpack [String] string format
+    #   :default [Value] default value
+    #   :to_s [Boolean] flag for generating #to_s
+    #   :endian [Symbol] optionally specify :big or :little endian
+    #   :padding [Symbol] optionally specify :null padding
+    #
+    # @api private
+    # @param name [Symbol] name of internal field
+    # @param type [Symbol] type of field in terms of binary size
+    # @param options [Hash] set of additional options
+    # @raise [ArgumentError]
+    #
+    # source://ruby-macho//lib/macho/structure.rb#144
+    def field(name, type, **options); end
+
+    # @api private
+    # @param subclass [Class] subclass type
+    #
+    # source://ruby-macho//lib/macho/structure.rb#116
+    def inherited(subclass); end
+  end
+end
+
+# Constants used for parsing MachOStructure fields
+#
+# source://ruby-macho//lib/macho/structure.rb#8
+module MachO::MachOStructure::Fields; end
+
+# association of field types to byte size
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/structure.rb#16
+MachO::MachOStructure::Fields::BYTE_SIZE = T.let(T.unsafe(nil), Hash)
+
+# A list of classes that must get initialized
+# To add a new class append it here and add the init method to the def_class_reader method
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/structure.rb#54
+MachO::MachOStructure::Fields::CLASSES_TO_INIT = T.let(T.unsafe(nil), Array)
+
+# association of field types with ruby format codes
+# Binary format codes can be found here:
+# https://docs.ruby-lang.org/en/2.6.0/String.html#method-i-unpack
+#
+# The equals sign is used to manually change endianness using
+# the Utils#specialize_format() method.
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/structure.rb#37
+MachO::MachOStructure::Fields::FORMAT_CODE = T.let(T.unsafe(nil), Hash)
+
+# A list of fields that don't require arguments in the initializer
+# Used to calculate MachOStructure#min_args
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/structure.rb#59
+MachO::MachOStructure::Fields::NO_ARG_REQUIRED = T.let(T.unsafe(nil), Array)
+
+# A representation of some unspecified Mach-O data.
+#
+# source://ruby-macho//lib/macho/view.rb#5
+class MachO::MachOView
+  # Creates a new MachOView.
+  #
+  # @param macho_file [MachOFile] the file this view slice is from
+  # @param raw_data [String] the raw Mach-O data
+  # @param endianness [Symbol] the endianness of the data
+  # @param offset [Integer] the offset of the relevant data
+  # @return [MachOView] a new instance of MachOView
+  #
+  # source://ruby-macho//lib/macho/view.rb#23
+  def initialize(macho_file, raw_data, endianness, offset); end
+
+  # @return [Symbol] the endianness of the data (`:big` or `:little`)
+  #
+  # source://ruby-macho//lib/macho/view.rb#13
+  def endianness; end
+
+  # source://ruby-macho//lib/macho/view.rb#38
+  def inspect; end
+
+  # @return [MachOFile] that this view belongs to
+  #
+  # source://ruby-macho//lib/macho/view.rb#7
+  def macho_file; end
+
+  # @return [Integer] the offset of the relevant data (in {#raw_data})
+  #
+  # source://ruby-macho//lib/macho/view.rb#16
+  def offset; end
+
+  # @return [String] the raw Mach-O data
+  #
+  # source://ruby-macho//lib/macho/view.rb#10
+  def raw_data; end
+
+  # @return [Hash] a hash representation of this {MachOView}.
+  #
+  # source://ruby-macho//lib/macho/view.rb#31
+  def to_h; end
+end
+
+# Raised when a file's magic bytes are not valid Mach-O magic.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#45
+class MachO::MagicError < ::MachO::NotAMachOError
+  # @param num [Integer] the unknown number
+  # @return [MagicError] a new instance of MagicError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#47
+  def initialize(magic); end
+end
+
+# Raised when a Mach-O file modification fails.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#9
+class MachO::ModificationError < ::MachO::MachOError; end
+
+# Raised when a file is not a Mach-O.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#34
+class MachO::NotAMachOError < ::MachO::MachOError; end
+
+# Raised when a change at an offset is not valid.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#167
+class MachO::OffsetInsertionError < ::MachO::ModificationError
+  # @param offset [Integer] the invalid offset
+  # @return [OffsetInsertionError] a new instance of OffsetInsertionError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#169
+  def initialize(offset); end
+end
+
+# Raised when a Mach-O file modification fails but can be recovered when
+# operating on multiple Mach-O slices of a fat binary in non-strict mode.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#19
+class MachO::RecoverableModificationError < ::MachO::ModificationError
+  # @return [Integer, nil] The index of the Mach-O slice of a fat binary for
+  #   which modification failed or `nil` if not a fat binary. This is used to
+  #   make the error message more useful.
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#23
+  def macho_slice; end
+
+  # @return [Integer, nil] The index of the Mach-O slice of a fat binary for
+  #   which modification failed or `nil` if not a fat binary. This is used to
+  #   make the error message more useful.
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#23
+  def macho_slice=(_arg0); end
+
+  # @return [String] The exception message.
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#26
+  def to_s; end
+end
+
+# Raised when attempting to add an rpath that already exists.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#208
+class MachO::RpathExistsError < ::MachO::RecoverableModificationError
+  # @param path [String] the extant path
+  # @return [RpathExistsError] a new instance of RpathExistsError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#210
+  def initialize(path); end
+end
+
+# Raised when attempting to change an rpath that doesn't exist.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#200
+class MachO::RpathUnknownError < ::MachO::RecoverableModificationError
+  # @param path [String] the unknown runtime path
+  # @return [RpathUnknownError] a new instance of RpathUnknownError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#202
+  def initialize(path); end
+end
+
+# Classes and constants for parsing sections in Mach-O binaries.
+#
+# source://ruby-macho//lib/macho/sections.rb#5
+module MachO::Sections; end
+
+# maximum specifiable section alignment, as a power of 2
+#
+# @note see `MAXSECTALIGN` macro in `cctools/misc/lipo.c`
+#
+# source://ruby-macho//lib/macho/sections.rb#20
+MachO::Sections::MAX_SECT_ALIGN = T.let(T.unsafe(nil), Integer)
+
+# association of section attribute symbols to values
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/sections.rb#52
+MachO::Sections::SECTION_ATTRIBUTES = T.let(T.unsafe(nil), Hash)
+
+# attributes mask
+#
+# source://ruby-macho//lib/macho/sections.rb#10
+MachO::Sections::SECTION_ATTRIBUTES_MASK = T.let(T.unsafe(nil), Integer)
+
+# system settable attributes mask
+#
+# source://ruby-macho//lib/macho/sections.rb#16
+MachO::Sections::SECTION_ATTRIBUTES_SYS_MASK = T.let(T.unsafe(nil), Integer)
+
+# user settable attributes mask
+#
+# source://ruby-macho//lib/macho/sections.rb#13
+MachO::Sections::SECTION_ATTRIBUTES_USR_MASK = T.let(T.unsafe(nil), Integer)
+
+# association of section flag symbols to values
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/sections.rb#67
+MachO::Sections::SECTION_FLAGS = T.let(T.unsafe(nil), Hash)
+
+# association of section name symbols to names
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/sections.rb#74
+MachO::Sections::SECTION_NAMES = T.let(T.unsafe(nil), Hash)
+
+# association of section type symbols to values
+#
+# @api private
+#
+# source://ruby-macho//lib/macho/sections.rb#24
+MachO::Sections::SECTION_TYPES = T.let(T.unsafe(nil), Hash)
+
+# type mask
+#
+# source://ruby-macho//lib/macho/sections.rb#7
+MachO::Sections::SECTION_TYPE_MASK = T.let(T.unsafe(nil), Integer)
+
+# Represents a section of a segment for 32-bit architectures.
+#
+# source://ruby-macho//lib/macho/sections.rb#90
+class MachO::Sections::Section < ::MachO::MachOStructure
+  # @return [Integer] the memory address of the section
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def addr; end
+
+  # @return [Integer] the section alignment (power of 2) of the section
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def align; end
+
+  # @example
+  #   puts "pure instructions" if sect.attribute?(:S_ATTR_PURE_INSTRUCTIONS)
+  # @param attr_sym [Symbol] a section attribute symbol
+  # @return [Boolean] whether this section is of the given type
+  #
+  # source://ruby-macho//lib/macho/sections.rb#162
+  def attribute?(attr_sym); end
+
+  # @return [Integer] the raw numeric attributes of this section
+  #
+  # source://ruby-macho//lib/macho/sections.rb#154
+  def attributes; end
+
+  # @return [Boolean] whether the section is empty (i.e, {size} is 0)
+  #
+  # source://ruby-macho//lib/macho/sections.rb#136
+  def empty?; end
+
+  # @deprecated Use {#type?} or {#attribute?} instead.
+  # @example
+  #   puts "this section is regular" if sect.flag?(:S_REGULAR)
+  # @param flag [Symbol] a section flag symbol
+  # @return [Boolean] whether the flag is present in the section's {flags}
+  #
+  # source://ruby-macho//lib/macho/sections.rb#171
+  def flag?(flag); end
+
+  # @return [Integer] flags for type and attributes of the section
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def flags; end
+
+  # @return [Integer] the number of relocation entries
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def nreloc; end
+
+  # @return [Integer] the file offset of the section
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def offset; end
+
+  # @return [Integer] the file offset of the section's relocation entries
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reloff; end
+
+  # @return [void] reserved (for offset or index)
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved1; end
+
+  # @return [void] reserved (for count or sizeof)
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved2; end
+
+  # @return [String] the section's name
+  #
+  # source://ruby-macho//lib/macho/sections.rb#126
+  def section_name; end
+
+  # @return [String] the name of the section, including null pad bytes
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def sectname; end
+
+  # @return [String] the parent segment's name
+  #
+  # source://ruby-macho//lib/macho/sections.rb#131
+  def segment_name; end
+
+  # @return [String] the name of the segment's section, including null
+  #   pad bytes
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def segname; end
+
+  # @return [Integer] the size, in bytes, of the section
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def size; end
+
+  # @return [Hash] a hash representation of this {Section}
+  #
+  # source://ruby-macho//lib/macho/sections.rb#180
+  def to_h; end
+
+  # @return [Integer] the raw numeric type of this section
+  #
+  # source://ruby-macho//lib/macho/sections.rb#141
+  def type; end
+
+  # @example
+  #   puts "this section is regular" if sect.type?(:S_REGULAR)
+  # @param type_sym [Symbol] a section type symbol
+  # @return [Boolean] whether this section is of the given type
+  #
+  # source://ruby-macho//lib/macho/sections.rb#149
+  def type?(type_sym); end
+end
+
+# Represents a section of a segment for 64-bit architectures.
+#
+# source://ruby-macho//lib/macho/sections.rb#198
+class MachO::Sections::Section64 < ::MachO::Sections::Section
+  # @return [Integer] the memory address of the section
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def addr; end
+
+  # @return [void] reserved
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def reserved3; end
+
+  # @return [Integer] the size, in bytes, of the section
+  #
+  # source://ruby-macho//lib/macho/structure.rb#269
+  def size; end
+
+  # @return [Hash] a hash representation of this {Section64}
+  #
+  # source://ruby-macho//lib/macho/sections.rb#209
+  def to_h; end
+end
+
+# A collection of convenient methods for common operations on Mach-O and Fat
+# binaries.
+#
+# source://ruby-macho//lib/macho/tools.rb#6
+module MachO::Tools
+  class << self
+    # Add a runtime path to a Mach-O or Fat binary, overwriting the source file.
+    #
+    # @option options
+    # @param filename [String] the Mach-O or Fat binary being modified
+    # @param new_path [String] the new runtime path
+    # @param options [Hash]
+    # @return [void]
+    #
+    # source://ruby-macho//lib/macho/tools.rb#71
+    def add_rpath(filename, new_path, options = T.unsafe(nil)); end
+
+    # Changes the dylib ID of a Mach-O or Fat binary, overwriting the source
+    #  file.
+    #
+    # @option options
+    # @param filename [String] the Mach-O or Fat binary being modified
+    # @param new_id [String] the new dylib ID for the binary
+    # @param options [Hash]
+    # @return [void]
+    #
+    # source://ruby-macho//lib/macho/tools.rb#23
+    def change_dylib_id(filename, new_id, options = T.unsafe(nil)); end
+
+    # Changes a shared library install name in a Mach-O or Fat binary,
+    #  overwriting the source file.
+    #
+    # @option options
+    # @param filename [String] the Mach-O or Fat binary being modified
+    # @param old_name [String] the old shared library name
+    # @param new_name [String] the new shared library name
+    # @param options [Hash]
+    # @return [void]
+    #
+    # source://ruby-macho//lib/macho/tools.rb#39
+    def change_install_name(filename, old_name, new_name, options = T.unsafe(nil)); end
+
+    # Changes a runtime path in a Mach-O or Fat binary, overwriting the source
+    #  file.
+    #
+    # @option options
+    # @option options
+    # @param filename [String] the Mach-O or Fat binary being modified
+    # @param old_path [String] the old runtime path
+    # @param new_path [String] the new runtime path
+    # @param options [Hash]
+    # @return [void]
+    #
+    # source://ruby-macho//lib/macho/tools.rb#57
+    def change_rpath(filename, old_path, new_path, options = T.unsafe(nil)); end
+
+    # Delete a runtime path from a Mach-O or Fat binary, overwriting the source
+    #  file.
+    #
+    # @option options
+    # @option options
+    # @param filename [String] the Mach-O or Fat binary being modified
+    # @param old_path [String] the old runtime path
+    # @param options [Hash]
+    # @return [void]
+    #
+    # source://ruby-macho//lib/macho/tools.rb#88
+    def delete_rpath(filename, old_path, options = T.unsafe(nil)); end
+
+    # @param filename [String] the Mach-O or Fat binary being read
+    # @return [Array<String>] an array of all dylibs linked to the binary
+    #
+    # source://ruby-macho//lib/macho/tools.rb#9
+    def dylibs(filename); end
+
+    # Merge multiple Mach-Os into one universal (Fat) binary.
+    #
+    # @param filename [String] the fat binary to create
+    # @param files [Array<String>] the files to merge
+    # @param fat64 [Boolean] whether to use {Headers::FatArch64}s to represent each slice
+    # @return [void]
+    #
+    # source://ruby-macho//lib/macho/tools.rb#100
+    def merge_machos(filename, *files, fat64: T.unsafe(nil)); end
+  end
+end
+
+# Raised when a file is too short to be a valid Mach-O file.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#38
+class MachO::TruncatedFileError < ::MachO::NotAMachOError
+  # @return [TruncatedFileError] a new instance of TruncatedFileError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#39
+  def initialize; end
+end
+
+# Raised whenever unfinished code is called.
+#
+# source://ruby-macho//lib/macho/exceptions.rb#216
+class MachO::UnimplementedError < ::MachO::MachOError
+  # @param thing [String] the thing that is unimplemented
+  # @return [UnimplementedError] a new instance of UnimplementedError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#218
+  def initialize(thing); end
+end
+
+# A collection of utility functions used throughout ruby-macho.
+#
+# source://ruby-macho//lib/macho/utils.rb#5
+module MachO::Utils
+  class << self
+    # Compares the given number to valid big-endian magic numbers.
+    #
+    # @param num [Integer] the number being checked
+    # @return [Boolean] whether `num` is a valid big-endian magic number
+    #
+    # source://ruby-macho//lib/macho/utils.rb#121
+    def big_magic?(num); end
+
+    # Compares the given number to the known magic number for a compressed Mach-O slice.
+    #
+    # @param num [Integer] the number being checked
+    # @return [Boolean] whether `num` is a valid compressed header magic number
+    #
+    # source://ruby-macho//lib/macho/utils.rb#128
+    def compressed_magic?(num); end
+
+    # Compares the given number to valid 32-bit Fat magic numbers.
+    #
+    # @param num [Integer] the number being checked
+    # @return [Boolean] whether `num` is a valid 32-bit fat magic number
+    #
+    # source://ruby-macho//lib/macho/utils.rb#86
+    def fat_magic32?(num); end
+
+    # Compares the given number to valid 64-bit Fat magic numbers.
+    #
+    # @param num [Integer] the number being checked
+    # @return [Boolean] whether `num` is a valid 64-bit fat magic number
+    #
+    # source://ruby-macho//lib/macho/utils.rb#93
+    def fat_magic64?(num); end
+
+    # Compares the given number to valid Fat magic numbers.
+    #
+    # @param num [Integer] the number being checked
+    # @return [Boolean] whether `num` is a valid Fat magic number
+    #
+    # source://ruby-macho//lib/macho/utils.rb#79
+    def fat_magic?(num); end
+
+    # Compares the given number to valid little-endian magic numbers.
+    #
+    # @param num [Integer] the number being checked
+    # @return [Boolean] whether `num` is a valid little-endian magic number
+    #
+    # source://ruby-macho//lib/macho/utils.rb#114
+    def little_magic?(num); end
+
+    # Compares the given number to valid 32-bit Mach-O magic numbers.
+    #
+    # @param num [Integer] the number being checked
+    # @return [Boolean] whether `num` is a valid 32-bit magic number
+    #
+    # source://ruby-macho//lib/macho/utils.rb#100
+    def magic32?(num); end
+
+    # Compares the given number to valid 64-bit Mach-O magic numbers.
+    #
+    # @param num [Integer] the number being checked
+    # @return [Boolean] whether `num` is a valid 64-bit magic number
+    #
+    # source://ruby-macho//lib/macho/utils.rb#107
+    def magic64?(num); end
+
+    # Compares the given number to valid Mach-O magic numbers.
+    #
+    # @param num [Integer] the number being checked
+    # @return [Boolean] whether `num` is a valid Mach-O magic number
+    #
+    # source://ruby-macho//lib/macho/utils.rb#72
+    def magic?(num); end
+
+    # Returns a string of null bytes of the requested (non-negative) size
+    #
+    # @param size [Integer] the size of the nullpad
+    # @raise [ArgumentError] if a non-positive nullpad is requested
+    # @return [String] the null string (or empty string, for `size = 0`)
+    #
+    # source://ruby-macho//lib/macho/utils.rb#31
+    def nullpad(size); end
+
+    # Packs tagged strings into an aligned payload.
+    #
+    # @param fixed_offset [Integer] the baseline offset for the first packed
+    #   string
+    # @param alignment [Integer] the alignment value to use for packing
+    # @param strings [Hash] the labeled strings to pack
+    # @return [Array<String, Hash>] the packed string and labeled offsets
+    #
+    # source://ruby-macho//lib/macho/utils.rb#53
+    def pack_strings(fixed_offset, alignment, strings = T.unsafe(nil)); end
+
+    # Returns the number of bytes needed to pad the given size to the given
+    #  alignment.
+    #
+    # @param size [Integer] the unpadded size
+    # @param alignment [Integer] the number to alignment the size with
+    # @return [Integer] the number of pad bytes required
+    #
+    # source://ruby-macho//lib/macho/utils.rb#23
+    def padding_for(size, alignment); end
+
+    # Rounds a value to the next multiple of the given round.
+    #
+    # @param value [Integer] the number being rounded
+    # @param round [Integer] the number being rounded with
+    # @return [Integer] the rounded value
+    # @see http://www.opensource.apple.com/source/cctools/cctools-870/libstuff/rnd.c
+    #
+    # source://ruby-macho//lib/macho/utils.rb#11
+    def round(value, round); end
+
+    # Converts an abstract (native-endian) String#unpack format to big or
+    #  little.
+    #
+    # @param format [String] the format string being converted
+    # @param endianness [Symbol] either `:big` or `:little`
+    # @return [String] the converted string
+    #
+    # source://ruby-macho//lib/macho/utils.rb#42
+    def specialize_format(format, endianness); end
+  end
+end
+
+# release version
+#
+# source://ruby-macho//lib/macho.rb#19
+MachO::VERSION = T.let(T.unsafe(nil), String)
+
+# Raised when a a fat Mach-O file has zero architectures
+#
+# source://ruby-macho//lib/macho/exceptions.rb#60
+class MachO::ZeroArchitectureError < ::MachO::NotAMachOError
+  # @return [ZeroArchitectureError] a new instance of ZeroArchitectureError
+  #
+  # source://ruby-macho//lib/macho/exceptions.rb#61
+  def initialize; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi b/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi
deleted file mode 100644
index 5d5a84fe10c3f..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi
+++ /dev/null
@@ -1,405 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `ruby-progressbar` gem.
-# Please instead update this file by running `bin/tapioca gem ruby-progressbar`.
-
-class ProgressBar
-  class << self
-    def create(*args); end
-  end
-end
-
-class ProgressBar::Base
-  extend ::Forwardable
-
-  def initialize(options = T.unsafe(nil)); end
-
-  def clear(*args, &block); end
-  def decrement; end
-  def finish; end
-  def finished?; end
-  def format(other); end
-  def format=(other); end
-  def increment; end
-  def inspect; end
-  def log(*args, &block); end
-  def pause; end
-  def paused?; end
-  def progress(*args, &block); end
-  def progress=(new_progress); end
-  def progress_mark=(mark); end
-  def refresh(*args, &block); end
-  def remainder_mark=(mark); end
-  def reset; end
-  def resume; end
-  def start(options = T.unsafe(nil)); end
-  def started?; end
-  def stop; end
-  def stopped?; end
-  def title; end
-  def title=(title); end
-  def to_h; end
-  def to_s(new_format = T.unsafe(nil)); end
-  def total(*args, &block); end
-  def total=(new_total); end
-
-  protected
-
-  def autofinish; end
-  def autofinish=(_arg0); end
-  def autostart; end
-  def autostart=(_arg0); end
-  def bar; end
-  def bar=(_arg0); end
-  def finished; end
-  def finished=(_arg0); end
-  def output; end
-  def output=(_arg0); end
-  def percentage; end
-  def percentage=(_arg0); end
-  def progressable; end
-  def progressable=(_arg0); end
-  def rate; end
-  def rate=(_arg0); end
-  def time; end
-  def time=(_arg0); end
-  def timer; end
-  def timer=(_arg0); end
-  def title_comp; end
-  def title_comp=(_arg0); end
-  def update_progress(*args); end
-end
-
-module ProgressBar::Calculators; end
-
-class ProgressBar::Calculators::Length
-  def initialize(options = T.unsafe(nil)); end
-
-  def calculate_length; end
-  def current_length; end
-  def current_length=(_arg0); 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
-
-  private
-
-  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 terminal_width; end
-  def unix?; end
-end
-
-class ProgressBar::Calculators::RunningAverage
-  class << self
-    def calculate(current_average, new_value_to_average, smoothing_factor); end
-  end
-end
-
-module ProgressBar::Components; end
-
-class ProgressBar::Components::Bar
-  def initialize(options = T.unsafe(nil)); 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 to_s(options = T.unsafe(nil)); end
-  def upa_steps; end
-  def upa_steps=(_arg0); end
-
-  private
-
-  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 integrated_percentage_complete_string; end
-  def standard_complete_string; end
-  def unknown_progress_frame; end
-  def unknown_string; end
-end
-
-ProgressBar::Components::Bar::DEFAULT_PROGRESS_MARK = T.let(T.unsafe(nil), String)
-ProgressBar::Components::Bar::DEFAULT_REMAINDER_MARK = T.let(T.unsafe(nil), String)
-ProgressBar::Components::Bar::DEFAULT_UPA_STEPS = T.let(T.unsafe(nil), Array)
-
-class ProgressBar::Components::Percentage
-  def initialize(options = T.unsafe(nil)); end
-
-  def progress; end
-  def progress=(_arg0); end
-
-  private
-
-  def justified_percentage; end
-  def justified_percentage_with_precision; end
-  def percentage; end
-  def percentage_with_precision; end
-end
-
-class ProgressBar::Components::Rate
-  def initialize(options = T.unsafe(nil)); end
-
-  def progress; end
-  def progress=(_arg0); end
-  def rate_scale; end
-  def rate_scale=(_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
-
-  private
-
-  def base_rate; end
-  def elapsed_seconds; end
-  def rate_of_change(format_string = T.unsafe(nil)); end
-  def rate_of_change_with_precision; end
-  def scaled_rate; end
-end
-
-class ProgressBar::Components::Time
-  def initialize(options = T.unsafe(nil)); end
-
-  def elapsed_with_label; end
-  def estimated_with_label; end
-
-  protected
-
-  def estimated_with_friendly_oob; end
-  def estimated_with_no_oob; end
-  def estimated_with_unknown_oob; 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
-
-  private
-
-  def elapsed; end
-  def estimated; end
-  def estimated_seconds_remaining; end
-  def estimated_with_elapsed_fallback; end
-end
-
-ProgressBar::Components::Time::ELAPSED_LABEL = T.let(T.unsafe(nil), String)
-ProgressBar::Components::Time::ESTIMATED_LABEL = T.let(T.unsafe(nil), String)
-ProgressBar::Components::Time::NO_TIME_ELAPSED_TEXT = T.let(T.unsafe(nil), String)
-ProgressBar::Components::Time::OOB_FRIENDLY_TIME_TEXT = T.let(T.unsafe(nil), String)
-ProgressBar::Components::Time::OOB_LIMIT_IN_HOURS = T.let(T.unsafe(nil), Integer)
-ProgressBar::Components::Time::OOB_TEXT_TO_FORMAT = T.let(T.unsafe(nil), Hash)
-ProgressBar::Components::Time::OOB_TIME_FORMATS = T.let(T.unsafe(nil), Array)
-ProgressBar::Components::Time::OOB_UNKNOWN_TIME_TEXT = T.let(T.unsafe(nil), String)
-ProgressBar::Components::Time::TIME_FORMAT = T.let(T.unsafe(nil), String)
-
-class ProgressBar::Components::Title
-  def initialize(options = T.unsafe(nil)); end
-
-  def title; end
-  def title=(_arg0); end
-end
-
-ProgressBar::Components::Title::DEFAULT_TITLE = T.let(T.unsafe(nil), String)
-module ProgressBar::Format; end
-
-class ProgressBar::Format::Formatter
-  class << self
-    def process(format_string, max_length, bar); end
-  end
-end
-
-class ProgressBar::Format::Molecule
-  def initialize(letter); end
-
-  def bar_molecule?; end
-  def full_key; end
-  def key; end
-  def key=(_arg0); end
-  def lookup_value(environment, length = T.unsafe(nil)); end
-  def method_name; end
-  def method_name=(_arg0); end
-  def non_bar_molecule?; end
-end
-
-ProgressBar::Format::Molecule::BAR_MOLECULES = T.let(T.unsafe(nil), Array)
-ProgressBar::Format::Molecule::MOLECULES = T.let(T.unsafe(nil), Hash)
-
-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
-
-ProgressBar::Format::String::ANSI_SGR_PATTERN = T.let(T.unsafe(nil), Regexp)
-ProgressBar::Format::String::MOLECULE_PATTERN = T.let(T.unsafe(nil), Regexp)
-class ProgressBar::InvalidProgressError < ::RuntimeError; end
-
-class ProgressBar::Output
-  def initialize(options = T.unsafe(nil)); end
-
-  def clear_string; end
-  def length; end
-  def log(string); end
-  def refresh(options = T.unsafe(nil)); end
-  def stream; end
-  def stream=(_arg0); end
-  def with_refresh; end
-
-  protected
-
-  def bar; end
-  def bar=(_arg0); end
-  def length_calculator; end
-  def length_calculator=(_arg0); end
-  def throttle; end
-  def throttle=(_arg0); end
-
-  private
-
-  def print_and_flush; end
-
-  class << self
-    def detect(options = T.unsafe(nil)); end
-  end
-end
-
-ProgressBar::Output::DEFAULT_OUTPUT_STREAM = T.let(T.unsafe(nil), IO)
-module ProgressBar::Outputs; 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 refresh_with_format_change(*_arg0); end
-  def resolve_format(*_arg0); end
-
-  protected
-
-  def last_update_length=(_arg0); end
-end
-
-ProgressBar::Outputs::NonTty::DEFAULT_FORMAT_STRING = T.let(T.unsafe(nil), String)
-
-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
-
-ProgressBar::Outputs::Tty::DEFAULT_FORMAT_STRING = T.let(T.unsafe(nil), String)
-
-class ProgressBar::Progress
-  def initialize(options = T.unsafe(nil)); end
-
-  def absolute; end
-  def decrement; end
-  def finish; end
-  def finished?; end
-  def increment; 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 = T.unsafe(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
-
-ProgressBar::Progress::DEFAULT_BEGINNING_POSITION = T.let(T.unsafe(nil), Integer)
-ProgressBar::Progress::DEFAULT_SMOOTHING = T.let(T.unsafe(nil), Float)
-ProgressBar::Progress::DEFAULT_TOTAL = T.let(T.unsafe(nil), Integer)
-module ProgressBar::Refinements; end
-module ProgressBar::Refinements::Enumerator; end
-
-class ProgressBar::Throttle
-  def initialize(options = T.unsafe(nil)); end
-
-  def choke(options = T.unsafe(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
-
-class ProgressBar::Time
-  def initialize(time = T.unsafe(nil)); end
-
-  def now; end
-  def unmocked_time_method; end
-
-  protected
-
-  def time; end
-  def time=(_arg0); end
-end
-
-ProgressBar::Time::TIME_MOCKING_LIBRARY_METHODS = T.let(T.unsafe(nil), Array)
-
-class ProgressBar::Timer
-  def initialize(options = T.unsafe(nil)); end
-
-  def divide_seconds(seconds); end
-  def elapsed_seconds; end
-  def elapsed_whole_seconds; 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
-
-  protected
-
-  def time; end
-  def time=(_arg0); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.13.0.rbi b/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.13.0.rbi
new file mode 100644
index 0000000000000..598477e511a40
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.13.0.rbi
@@ -0,0 +1,1317 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `ruby-progressbar` gem.
+# Please instead update this file by running `bin/tapioca gem ruby-progressbar`.
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#4
+class ProgressBar
+  class << self
+    # source://ruby-progressbar//lib/ruby-progressbar.rb#9
+    def create(*args); end
+  end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/base.rb#17
+class ProgressBar::Base
+  extend ::Forwardable
+
+  # @return [Base] a new instance of Base
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#45
+  def initialize(options = T.unsafe(nil)); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def clear(*args, **_arg1, &block); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#137
+  def decrement; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#92
+  def finish; end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#129
+  def finished?; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#203
+  def format(other); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#203
+  def format=(other); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#141
+  def increment; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#199
+  def inspect; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def log(*args, **_arg1, &block); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#102
+  def pause; end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#123
+  def paused?; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def progress(*args, **_arg1, &block); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#145
+  def progress=(new_progress); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#153
+  def progress_mark=(mark); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def refresh(*args, **_arg1, &block); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#157
+  def remainder_mark=(mark); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#114
+  def reset; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#110
+  def resume; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#87
+  def start(options = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#133
+  def started?; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#106
+  def stop; end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#123
+  def stopped?; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#161
+  def title; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#165
+  def title=(title); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#176
+  def to_h; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#169
+  def to_s(new_format = T.unsafe(nil)); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def total(*args, **_arg1, &block); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#149
+  def total=(new_total); end
+
+  protected
+
+  # Returns the value of attribute autofinish.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def autofinish; end
+
+  # Sets the attribute autofinish
+  #
+  # @param value the value to set the attribute autofinish to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def autofinish=(_arg0); end
+
+  # Returns the value of attribute autostart.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def autostart; end
+
+  # Sets the attribute autostart
+  #
+  # @param value the value to set the attribute autostart to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def autostart=(_arg0); end
+
+  # Returns the value of attribute bar_component.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def bar_component; end
+
+  # Sets the attribute bar_component
+  #
+  # @param value the value to set the attribute bar_component to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def bar_component=(_arg0); end
+
+  # Returns the value of attribute finished.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def finished; end
+
+  # Sets the attribute finished
+  #
+  # @param value the value to set the attribute finished to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def finished=(_arg0); end
+
+  # Returns the value of attribute output.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def output; end
+
+  # Sets the attribute output
+  #
+  # @param value the value to set the attribute output to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def output=(_arg0); end
+
+  # Returns the value of attribute percentage_component.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def percentage_component; end
+
+  # Sets the attribute percentage_component
+  #
+  # @param value the value to set the attribute percentage_component to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def percentage_component=(_arg0); end
+
+  # Returns the value of attribute progressable.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def progressable; end
+
+  # Sets the attribute progressable
+  #
+  # @param value the value to set the attribute progressable to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def progressable=(_arg0); end
+
+  # Returns the value of attribute projector.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def projector; end
+
+  # Sets the attribute projector
+  #
+  # @param value the value to set the attribute projector to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def projector=(_arg0); end
+
+  # Returns the value of attribute rate_component.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def rate_component; end
+
+  # Sets the attribute rate_component
+  #
+  # @param value the value to set the attribute rate_component to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def rate_component=(_arg0); end
+
+  # Returns the value of attribute time_component.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def time_component; end
+
+  # Sets the attribute time_component
+  #
+  # @param value the value to set the attribute time_component to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def time_component=(_arg0); end
+
+  # Returns the value of attribute timer.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def timer; end
+
+  # Sets the attribute timer
+  #
+  # @param value the value to set the attribute timer to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def timer=(_arg0); end
+
+  # Returns the value of attribute title_component.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def title_component; end
+
+  # Sets the attribute title_component
+  #
+  # @param value the value to set the attribute title_component to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#213
+  def title_component=(_arg0); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/base.rb#226
+  def update_progress(*args); end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/base.rb#28
+ProgressBar::Base::RUNNING_AVERAGE_RATE_DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/base.rb#21
+ProgressBar::Base::SMOOTHING_DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#2
+module ProgressBar::Calculators; end
+
+# source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#3
+class ProgressBar::Calculators::Length
+  # @return [Length] a new instance of Length
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#8
+  def initialize(options = T.unsafe(nil)); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#25
+  def calculate_length; end
+
+  # Returns the value of attribute current_length.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#5
+  def current_length; end
+
+  # Sets the attribute current_length
+  #
+  # @param value the value to set the attribute current_length to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#5
+  def current_length=(_arg0); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#14
+  def length; end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#18
+  def length_changed?; end
+
+  # Returns the value of attribute length_override.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#4
+  def length_override; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#33
+  def length_override=(other); end
+
+  # Returns the value of attribute output.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#5
+  def output; end
+
+  # Sets the attribute output
+  #
+  # @param value the value to set the attribute output to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#5
+  def output=(_arg0); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#29
+  def reset_length; end
+
+  private
+
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#56
+  def dynamic_width; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#85
+  def dynamic_width_stty; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#89
+  def dynamic_width_tput; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#76
+  def dynamic_width_via_io_object; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#71
+  def dynamic_width_via_output_stream_object; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#81
+  def dynamic_width_via_system_calls; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#43
+  def terminal_width; end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/calculators/length.rb#93
+  def unix?; end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#5
+module ProgressBar::Components; end
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#6
+class ProgressBar::Components::Bar
+  # @return [Bar] a new instance of Bar
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#17
+  def initialize(options = T.unsafe(nil)); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#35
+  def bar(length); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#63
+  def bar_with_percentage(length); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#41
+  def complete_bar(length); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#47
+  def complete_bar_with_percentage(length); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#53
+  def incomplete_space(length); end
+
+  # Returns the value of attribute length.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#11
+  def length; end
+
+  # Sets the attribute length
+  #
+  # @param value the value to set the attribute length to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#11
+  def length=(_arg0); end
+
+  # Returns the value of attribute progress.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#11
+  def progress; end
+
+  # Sets the attribute progress
+  #
+  # @param value the value to set the attribute progress to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#11
+  def progress=(_arg0); end
+
+  # Returns the value of attribute progress_mark.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#11
+  def progress_mark; end
+
+  # Sets the attribute progress_mark
+  #
+  # @param value the value to set the attribute progress_mark to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#11
+  def progress_mark=(_arg0); end
+
+  # Returns the value of attribute remainder_mark.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#11
+  def remainder_mark; end
+
+  # Sets the attribute remainder_mark
+  #
+  # @param value the value to set the attribute remainder_mark to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#11
+  def remainder_mark=(_arg0); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#25
+  def to_s(options = T.unsafe(nil)); end
+
+  # Returns the value of attribute upa_steps.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#11
+  def upa_steps; end
+
+  # Sets the attribute upa_steps
+  #
+  # @param value the value to set the attribute upa_steps to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#11
+  def upa_steps=(_arg0); end
+
+  private
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#91
+  def completed_length; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#81
+  def incomplete_string; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#71
+  def integrated_percentage_complete_string; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#77
+  def standard_complete_string; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#95
+  def unknown_progress_frame; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#85
+  def unknown_string; end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#7
+ProgressBar::Components::Bar::DEFAULT_PROGRESS_MARK = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#8
+ProgressBar::Components::Bar::DEFAULT_REMAINDER_MARK = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/bar.rb#9
+ProgressBar::Components::Bar::DEFAULT_UPA_STEPS = T.let(T.unsafe(nil), Array)
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/percentage.rb#3
+class ProgressBar::Components::Percentage
+  # @return [Percentage] a new instance of Percentage
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/percentage.rb#6
+  def initialize(options = T.unsafe(nil)); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/percentage.rb#14
+  def justified_percentage; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/percentage.rb#22
+  def justified_percentage_with_precision; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/percentage.rb#10
+  def percentage; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/percentage.rb#18
+  def percentage_with_precision; end
+
+  # Returns the value of attribute progress.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/percentage.rb#4
+  def progress; end
+
+  # Sets the attribute progress
+  #
+  # @param value the value to set the attribute progress to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/percentage.rb#4
+  def progress=(_arg0); end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/rate.rb#3
+class ProgressBar::Components::Rate
+  # @return [Rate] a new instance of Rate
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/rate.rb#8
+  def initialize(options = T.unsafe(nil)); end
+
+  # Returns the value of attribute progress.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/rate.rb#4
+  def progress; end
+
+  # Sets the attribute progress
+  #
+  # @param value the value to set the attribute progress to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/rate.rb#4
+  def progress=(_arg0); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/rate.rb#14
+  def rate_of_change(format_string = T.unsafe(nil)); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/rate.rb#20
+  def rate_of_change_with_precision; end
+
+  # Returns the value of attribute rate_scale.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/rate.rb#4
+  def rate_scale; end
+
+  # Sets the attribute rate_scale
+  #
+  # @param value the value to set the attribute rate_scale to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/rate.rb#4
+  def rate_scale=(_arg0); end
+
+  # Returns the value of attribute timer.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/rate.rb#4
+  def timer; end
+
+  # Sets the attribute timer
+  #
+  # @param value the value to set the attribute timer to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/rate.rb#4
+  def timer=(_arg0); end
+
+  private
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/rate.rb#30
+  def base_rate; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/rate.rb#34
+  def elapsed_seconds; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/rate.rb#26
+  def scaled_rate; end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#6
+class ProgressBar::Components::Time
+  # @return [Time] a new instance of Time
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#21
+  def initialize(options = T.unsafe(nil)); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#31
+  def elapsed_with_label; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#47
+  def estimated_wall_clock; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#43
+  def estimated_with_friendly_oob; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#27
+  def estimated_with_label(out_of_bounds_time_format = T.unsafe(nil)); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#35
+  def estimated_with_no_oob; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#39
+  def estimated_with_unknown_oob; end
+
+  protected
+
+  # Returns the value of attribute progress.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#60
+  def progress; end
+
+  # Sets the attribute progress
+  #
+  # @param value the value to set the attribute progress to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#60
+  def progress=(_arg0); end
+
+  # Returns the value of attribute projector.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#60
+  def projector; end
+
+  # Sets the attribute projector
+  #
+  # @param value the value to set the attribute projector to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#60
+  def projector=(_arg0); end
+
+  # Returns the value of attribute timer.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#60
+  def timer; end
+
+  # Sets the attribute timer
+  #
+  # @param value the value to set the attribute timer to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#60
+  def timer=(_arg0); end
+
+  private
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#80
+  def elapsed; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#66
+  def estimated(out_of_bounds_time_format); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#94
+  def estimated_seconds_remaining; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#88
+  def estimated_with_elapsed_fallback(out_of_bounds_time_format); end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#14
+ProgressBar::Components::Time::ELAPSED_LABEL = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#13
+ProgressBar::Components::Time::ESTIMATED_LABEL = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#12
+ProgressBar::Components::Time::NO_TIME_ELAPSED_TEXT = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#11
+ProgressBar::Components::Time::OOB_FRIENDLY_TIME_TEXT = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#9
+ProgressBar::Components::Time::OOB_LIMIT_IN_HOURS = T.let(T.unsafe(nil), Integer)
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#16
+ProgressBar::Components::Time::OOB_TEXT_TO_FORMAT = T.let(T.unsafe(nil), Hash)
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#8
+ProgressBar::Components::Time::OOB_TIME_FORMATS = T.let(T.unsafe(nil), Array)
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#10
+ProgressBar::Components::Time::OOB_UNKNOWN_TIME_TEXT = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#7
+ProgressBar::Components::Time::TIME_FORMAT = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/time.rb#15
+ProgressBar::Components::Time::WALL_CLOCK_FORMAT = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/title.rb#3
+class ProgressBar::Components::Title
+  # @return [Title] a new instance of Title
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/title.rb#8
+  def initialize(options = T.unsafe(nil)); end
+
+  # Returns the value of attribute title.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/title.rb#6
+  def title; end
+
+  # Sets the attribute title
+  #
+  # @param value the value to set the attribute title to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/components/title.rb#6
+  def title=(_arg0); end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/components/title.rb#4
+ProgressBar::Components::Title::DEFAULT_TITLE = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/format/formatter.rb#2
+module ProgressBar::Format; end
+
+# source://ruby-progressbar//lib/ruby-progressbar/format/formatter.rb#3
+class ProgressBar::Format::Formatter
+  class << self
+    # source://ruby-progressbar//lib/ruby-progressbar/format/formatter.rb#4
+    def process(format_string, max_length, bar); end
+  end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/format/molecule.rb#3
+class ProgressBar::Format::Molecule
+  # @return [Molecule] a new instance of Molecule
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/format/molecule.rb#33
+  def initialize(letter); end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/format/molecule.rb#38
+  def bar_molecule?; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/format/molecule.rb#46
+  def full_key; end
+
+  # Returns the value of attribute key.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/format/molecule.rb#30
+  def key; end
+
+  # Sets the attribute key
+  #
+  # @param value the value to set the attribute key to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/format/molecule.rb#30
+  def key=(_arg0); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/format/molecule.rb#50
+  def lookup_value(environment, length = T.unsafe(nil)); end
+
+  # Returns the value of attribute method_name.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/format/molecule.rb#30
+  def method_name; end
+
+  # Sets the attribute method_name
+  #
+  # @param value the value to set the attribute method_name to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/format/molecule.rb#30
+  def method_name=(_arg0); end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/format/molecule.rb#42
+  def non_bar_molecule?; end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/format/molecule.rb#28
+ProgressBar::Format::Molecule::BAR_MOLECULES = T.let(T.unsafe(nil), Array)
+
+# source://ruby-progressbar//lib/ruby-progressbar/format/molecule.rb#4
+ProgressBar::Format::Molecule::MOLECULES = T.let(T.unsafe(nil), Hash)
+
+# source://ruby-progressbar//lib/ruby-progressbar/format/string.rb#5
+class ProgressBar::Format::String < ::String
+  # source://ruby-progressbar//lib/ruby-progressbar/format/string.rb#13
+  def bar_molecule_placeholder_length; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/format/string.rb#21
+  def bar_molecules; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/format/string.rb#9
+  def displayable_length; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/format/string.rb#25
+  def molecules; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/format/string.rb#17
+  def non_bar_molecules; end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/format/string.rb#7
+ProgressBar::Format::String::ANSI_SGR_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# source://ruby-progressbar//lib/ruby-progressbar/format/string.rb#6
+ProgressBar::Format::String::MOLECULE_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# source://ruby-progressbar//lib/ruby-progressbar/errors/invalid_progress_error.rb#2
+class ProgressBar::InvalidProgressError < ::RuntimeError; end
+
+# source://ruby-progressbar//lib/ruby-progressbar/output.rb#5
+class ProgressBar::Output
+  # @return [Output] a new instance of Output
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#10
+  def initialize(options = T.unsafe(nil)); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#37
+  def clear_string; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#41
+  def length; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#30
+  def log(string); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#50
+  def refresh(options = T.unsafe(nil)); end
+
+  # Returns the value of attribute stream.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#8
+  def stream; end
+
+  # Sets the attribute stream
+  #
+  # @param value the value to set the attribute stream to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#8
+  def stream=(_arg0); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#45
+  def with_refresh; end
+
+  protected
+
+  # Returns the value of attribute bar.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#60
+  def bar; end
+
+  # Sets the attribute bar
+  #
+  # @param value the value to set the attribute bar to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#60
+  def bar=(_arg0); end
+
+  # Returns the value of attribute length_calculator.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#60
+  def length_calculator; end
+
+  # Sets the attribute length_calculator
+  #
+  # @param value the value to set the attribute length_calculator to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#60
+  def length_calculator=(_arg0); end
+
+  # Returns the value of attribute throttle.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#60
+  def throttle; end
+
+  # Sets the attribute throttle
+  #
+  # @param value the value to set the attribute throttle to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#60
+  def throttle=(_arg0); end
+
+  private
+
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#66
+  def print_and_flush; end
+
+  class << self
+    # source://ruby-progressbar//lib/ruby-progressbar/output.rb#20
+    def detect(options = T.unsafe(nil)); end
+  end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/output.rb#6
+ProgressBar::Output::DEFAULT_OUTPUT_STREAM = T.let(T.unsafe(nil), IO)
+
+# source://ruby-progressbar//lib/ruby-progressbar/outputs/non_tty.rb#4
+module ProgressBar::Outputs; end
+
+# source://ruby-progressbar//lib/ruby-progressbar/outputs/non_tty.rb#5
+class ProgressBar::Outputs::NonTty < ::ProgressBar::Output
+  # source://ruby-progressbar//lib/ruby-progressbar/outputs/non_tty.rb#18
+  def bar_update_string; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/outputs/non_tty.rb#8
+  def clear; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/outputs/non_tty.rb#28
+  def default_format; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/outputs/non_tty.rb#38
+  def eol; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/outputs/non_tty.rb#14
+  def last_update_length; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/outputs/non_tty.rb#36
+  def refresh_with_format_change(*_arg0); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/outputs/non_tty.rb#32
+  def resolve_format(*_arg0); end
+
+  protected
+
+  # Sets the attribute last_update_length
+  #
+  # @param value the value to set the attribute last_update_length to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/outputs/non_tty.rb#44
+  def last_update_length=(_arg0); end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/outputs/non_tty.rb#6
+ProgressBar::Outputs::NonTty::DEFAULT_FORMAT_STRING = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/outputs/tty.rb#5
+class ProgressBar::Outputs::Tty < ::ProgressBar::Output
+  # source://ruby-progressbar//lib/ruby-progressbar/outputs/tty.rb#15
+  def bar_update_string; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/outputs/tty.rb#10
+  def clear; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/outputs/tty.rb#19
+  def default_format; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/outputs/tty.rb#27
+  def eol; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/output.rb#45
+  def refresh_with_format_change; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/outputs/tty.rb#23
+  def resolve_format(other_format); end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/outputs/tty.rb#6
+ProgressBar::Outputs::Tty::DEFAULT_FORMAT_STRING = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/progress.rb#4
+class ProgressBar::Progress
+  # @return [Progress] a new instance of Progress
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#12
+  def initialize(options = T.unsafe(nil)); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#104
+  def absolute; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#41
+  def decrement; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#23
+  def finish; end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#27
+  def finished?; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#31
+  def increment; end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#85
+  def none?; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#73
+  def percentage_completed; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#97
+  def percentage_completed_with_precision; end
+
+  # Returns the value of attribute progress.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#8
+  def progress; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#55
+  def progress=(new_progress); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#51
+  def reset; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#18
+  def start(options = T.unsafe(nil)); end
+
+  # Returns the value of attribute starting_position.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#10
+  def starting_position; end
+
+  # Sets the attribute starting_position
+  #
+  # @param value the value to set the attribute starting_position to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#10
+  def starting_position=(_arg0); end
+
+  # Returns the value of attribute total.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#8
+  def total; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#64
+  def total=(new_total); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#93
+  def total_with_unknown_indicator; end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/progress.rb#89
+  def unknown?; end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/progress.rb#6
+ProgressBar::Progress::DEFAULT_BEGINNING_POSITION = T.let(T.unsafe(nil), Integer)
+
+# source://ruby-progressbar//lib/ruby-progressbar/progress.rb#5
+ProgressBar::Progress::DEFAULT_TOTAL = T.let(T.unsafe(nil), Integer)
+
+# source://ruby-progressbar//lib/ruby-progressbar/projector.rb#4
+class ProgressBar::Projector
+  class << self
+    # source://ruby-progressbar//lib/ruby-progressbar/projector.rb#10
+    def from_type(name); end
+  end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/projector.rb#5
+ProgressBar::Projector::DEFAULT_PROJECTOR = ProgressBar::Projectors::SmoothedAverage
+
+# source://ruby-progressbar//lib/ruby-progressbar/projector.rb#6
+ProgressBar::Projector::NAME_TO_PROJECTOR_MAP = T.let(T.unsafe(nil), Hash)
+
+# source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#2
+module ProgressBar::Projectors; end
+
+# source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#3
+class ProgressBar::Projectors::SmoothedAverage
+  # @return [SmoothedAverage] a new instance of SmoothedAverage
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#11
+  def initialize(options = T.unsafe(nil)); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#24
+  def decrement; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#28
+  def increment; end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#52
+  def none?; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#32
+  def progress; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#42
+  def progress=(new_progress); end
+
+  # Returns the value of attribute projection.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#9
+  def projection; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#38
+  def reset; end
+
+  # Returns the value of attribute samples.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#7
+  def samples; end
+
+  # Sets the attribute samples
+  #
+  # @param value the value to set the attribute samples to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#7
+  def samples=(_arg0); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#19
+  def start(options = T.unsafe(nil)); end
+
+  # Returns the value of attribute strength.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#7
+  def strength; end
+
+  # Sets the attribute strength
+  #
+  # @param value the value to set the attribute strength to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#7
+  def strength=(_arg0); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#36
+  def total=(_new_total); end
+
+  protected
+
+  # Sets the attribute projection
+  #
+  # @param value the value to set the attribute projection to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#62
+  def projection=(_arg0); end
+
+  private
+
+  # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#66
+  def absolute; end
+
+  class << self
+    # source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#56
+    def calculate(current_projection, new_value, rate); end
+  end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#5
+ProgressBar::Projectors::SmoothedAverage::DEFAULT_BEGINNING_POSITION = T.let(T.unsafe(nil), Integer)
+
+# source://ruby-progressbar//lib/ruby-progressbar/projectors/smoothed_average.rb#4
+ProgressBar::Projectors::SmoothedAverage::DEFAULT_STRENGTH = T.let(T.unsafe(nil), Float)
+
+# source://ruby-progressbar//lib/ruby-progressbar/refinements/progress_enumerator.rb#2
+module ProgressBar::Refinements; end
+
+# source://ruby-progressbar//lib/ruby-progressbar/refinements/progress_enumerator.rb#3
+module ProgressBar::Refinements::Enumerator; end
+
+# source://ruby-progressbar//lib/ruby-progressbar/refinements/progress_enumerator.rb#4
+ProgressBar::Refinements::Enumerator::ARITY_ERROR_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://ruby-progressbar//lib/ruby-progressbar/throttle.rb#2
+class ProgressBar::Throttle
+  # @return [Throttle] a new instance of Throttle
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/throttle.rb#8
+  def initialize(options = T.unsafe(nil)); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/throttle.rb#15
+  def choke(options = T.unsafe(nil)); end
+
+  # Returns the value of attribute rate.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/throttle.rb#3
+  def rate; end
+
+  # Sets the attribute rate
+  #
+  # @param value the value to set the attribute rate to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/throttle.rb#3
+  def rate=(_arg0); end
+
+  # Returns the value of attribute started_at.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/throttle.rb#3
+  def started_at; end
+
+  # Sets the attribute started_at
+  #
+  # @param value the value to set the attribute started_at to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/throttle.rb#3
+  def started_at=(_arg0); end
+
+  # Returns the value of attribute stopped_at.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/throttle.rb#3
+  def stopped_at; end
+
+  # Sets the attribute stopped_at
+  #
+  # @param value the value to set the attribute stopped_at to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/throttle.rb#3
+  def stopped_at=(_arg0); end
+
+  # Returns the value of attribute timer.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/throttle.rb#3
+  def timer; end
+
+  # Sets the attribute timer
+  #
+  # @param value the value to set the attribute timer to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/throttle.rb#3
+  def timer=(_arg0); end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/time.rb#3
+class ProgressBar::Time
+  # @return [Time] a new instance of Time
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/time.rb#11
+  def initialize(time = T.unsafe(nil)); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/time.rb#15
+  def now; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/time.rb#19
+  def unmocked_time_method; end
+
+  protected
+
+  # Returns the value of attribute time.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/time.rb#27
+  def time; end
+
+  # Sets the attribute time
+  #
+  # @param value the value to set the attribute time to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/time.rb#27
+  def time=(_arg0); end
+end
+
+# source://ruby-progressbar//lib/ruby-progressbar/time.rb#4
+ProgressBar::Time::TIME_MOCKING_LIBRARY_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://ruby-progressbar//lib/ruby-progressbar/timer.rb#4
+class ProgressBar::Timer
+  # @return [Timer] a new instance of Timer
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#8
+  def initialize(options = T.unsafe(nil)); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#67
+  def divide_seconds(seconds); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#57
+  def elapsed_seconds; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#63
+  def elapsed_whole_seconds; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#31
+  def now; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#23
+  def pause; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#43
+  def reset; end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#48
+  def reset?; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#52
+  def restart; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#27
+  def resume; end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#12
+  def start; end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#35
+  def started?; end
+
+  # Returns the value of attribute started_at.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#5
+  def started_at; end
+
+  # Sets the attribute started_at
+  #
+  # @param value the value to set the attribute started_at to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#5
+  def started_at=(_arg0); end
+
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#17
+  def stop; end
+
+  # @return [Boolean]
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#39
+  def stopped?; end
+
+  # Returns the value of attribute stopped_at.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#5
+  def stopped_at; end
+
+  # Sets the attribute stopped_at
+  #
+  # @param value the value to set the attribute stopped_at to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#5
+  def stopped_at=(_arg0); end
+
+  protected
+
+  # Returns the value of attribute time.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#76
+  def time; end
+
+  # Sets the attribute time
+  #
+  # @param value the value to set the attribute time to.
+  #
+  # source://ruby-progressbar//lib/ruby-progressbar/timer.rb#76
+  def time=(_arg0); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubyntlm@0.6.3.rbi b/Library/Homebrew/sorbet/rbi/gems/rubyntlm@0.6.3.rbi
deleted file mode 100644
index 3d559d3c3f531..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/rubyntlm@0.6.3.rbi
+++ /dev/null
@@ -1,332 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `rubyntlm` gem.
-# Please instead update this file by running `bin/tapioca gem rubyntlm`.
-
-module Net::NTLM
-  class << self
-    def apply_des(plain, keys); end
-    def gen_keys(str); end
-    def is_ntlm_hash?(data); end
-    def lm_hash(password); end
-    def lm_response(arg); end
-    def lmv2_response(arg, opt = T.unsafe(nil)); end
-    def ntlm2_session(arg, opt = T.unsafe(nil)); end
-    def ntlm_hash(password, opt = T.unsafe(nil)); end
-    def ntlm_response(arg); end
-    def ntlmv2_hash(user, password, target, opt = T.unsafe(nil)); end
-    def ntlmv2_response(arg, opt = T.unsafe(nil)); end
-    def pack_int64le(val); end
-    def split7(str); end
-  end
-end
-
-class Net::NTLM::Blob < ::Net::NTLM::FieldSet
-  def blob_signature; end
-  def blob_signature=(val); end
-  def challenge; end
-  def challenge=(val); end
-  def parse(str, offset = T.unsafe(nil)); end
-  def reserved; end
-  def reserved=(val); end
-  def target_info; end
-  def target_info=(val); end
-  def timestamp; end
-  def timestamp=(val); end
-  def unknown1; end
-  def unknown1=(val); end
-  def unknown2; end
-  def unknown2=(val); end
-end
-
-class Net::NTLM::ChannelBinding
-  def initialize(outer_channel); end
-
-  def acceptor_address_length; end
-  def acceptor_addrtype; end
-  def application_data; end
-  def channel; end
-  def channel_binding_token; end
-  def channel_hash; end
-  def gss_channel_bindings_struct; end
-  def initiator_address_length; end
-  def initiator_addtype; end
-  def unique_prefix; end
-
-  class << self
-    def create(outer_channel); end
-  end
-end
-
-class Net::NTLM::Client
-  def initialize(username, password, opts = T.unsafe(nil)); end
-
-  def domain; end
-  def flags; end
-  def init_context(resp = T.unsafe(nil), channel_binding = T.unsafe(nil)); end
-  def password; end
-  def session; end
-  def session_key; end
-  def username; end
-  def workstation; end
-
-  private
-
-  def type1_message; end
-end
-
-class Net::NTLM::Client::Session
-  def initialize(client, challenge_message, channel_binding = T.unsafe(nil)); end
-
-  def authenticate!; end
-  def challenge_message; end
-  def channel_binding; end
-  def client; end
-  def exported_session_key; end
-  def seal_message(message); end
-  def sign_message(message); end
-  def unseal_message(emessage); end
-  def verify_signature(signature, message); end
-
-  private
-
-  def blob; end
-  def calculate_user_session_key!; end
-  def client_challenge; end
-  def client_cipher; end
-  def client_seal_key; end
-  def client_sign_key; end
-  def domain; end
-  def lmv2_resp; end
-  def negotiate_key_exchange?; end
-  def nt_proof_str; end
-  def ntlmv2_hash; end
-  def ntlmv2_resp; end
-  def oem_or_unicode_str(str); end
-  def password; end
-  def raw_sequence; end
-  def sequence; end
-  def server_challenge; end
-  def server_cipher; end
-  def server_seal_key; end
-  def server_sign_key; end
-  def target_info; end
-  def timestamp; end
-  def use_oem_strings?; end
-  def user_session_key; end
-  def username; end
-  def workstation; end
-end
-
-class Net::NTLM::EncodeUtil
-  class << self
-    def decode_utf16le(str); end
-    def encode_utf16le(str); end
-  end
-end
-
-class Net::NTLM::Field
-  def initialize(opts); end
-
-  def active; end
-  def active=(_arg0); end
-  def parse(str, offset = T.unsafe(nil)); end
-  def serialize; end
-  def size; end
-  def value; end
-  def value=(_arg0); end
-end
-
-class Net::NTLM::FieldSet
-  def initialize; end
-
-  def [](name); end
-  def []=(name, val); end
-  def disable(name); end
-  def enable(name); end
-  def has_disabled_fields?; end
-  def parse(str, offset = T.unsafe(nil)); end
-  def serialize; end
-  def size; end
-
-  class << self
-    def int16LE(name, opts); end
-    def int32LE(name, opts); end
-    def int64LE(name, opts); end
-    def names; end
-    def opts; end
-    def prototypes; end
-    def security_buffer(name, opts); end
-    def string(name, opts); end
-    def types; end
-
-    private
-
-    def add_field(name, type, opts); end
-    def define_accessor(name); end
-  end
-end
-
-class Net::NTLM::Int16LE < ::Net::NTLM::Field
-  def initialize(opt); end
-
-  def parse(str, offset = T.unsafe(nil)); end
-  def serialize; end
-end
-
-class Net::NTLM::Int32LE < ::Net::NTLM::Field
-  def initialize(opt); end
-
-  def parse(str, offset = T.unsafe(nil)); end
-  def serialize; end
-end
-
-class Net::NTLM::Int64LE < ::Net::NTLM::Field
-  def initialize(opt); end
-
-  def parse(str, offset = T.unsafe(nil)); end
-  def serialize; end
-end
-
-class Net::NTLM::InvalidTargetDataError < ::Net::NTLM::NtlmError
-  def initialize(msg, data); end
-
-  def data; end
-end
-
-class Net::NTLM::Message < ::Net::NTLM::FieldSet
-  def data_edge; end
-  def data_size; end
-  def decode64(str); end
-  def deflag; end
-  def dump_flags; end
-  def encode64; end
-  def has_flag?(flag); end
-  def head_size; end
-  def parse(str); end
-  def security_buffers; end
-  def serialize; end
-  def set_flag(flag); end
-  def size; end
-
-  class << self
-    def decode64(str); end
-    def parse(str); end
-  end
-end
-
-class Net::NTLM::Message::Type0 < ::Net::NTLM::Message
-  def sign; end
-  def sign=(val); end
-  def type; end
-  def type=(val); end
-end
-
-class Net::NTLM::Message::Type1 < ::Net::NTLM::Message
-  def domain; end
-  def domain=(val); end
-  def flag; end
-  def flag=(val); end
-  def os_version; end
-  def os_version=(val); end
-  def sign; end
-  def sign=(val); end
-  def type; end
-  def type=(val); end
-  def workstation; end
-  def workstation=(val); end
-end
-
-class Net::NTLM::Message::Type2 < ::Net::NTLM::Message
-  def challenge; end
-  def challenge=(val); end
-  def context; end
-  def context=(val); end
-  def flag; end
-  def flag=(val); end
-  def os_version; end
-  def os_version=(val); end
-  def response(arg, opt = T.unsafe(nil)); end
-  def sign; end
-  def sign=(val); end
-  def target_info; end
-  def target_info=(val); end
-  def target_name; end
-  def target_name=(val); end
-  def type; end
-  def type=(val); end
-end
-
-class Net::NTLM::Message::Type3 < ::Net::NTLM::Message
-  def blank_password?(server_challenge); end
-  def domain; end
-  def domain=(val); end
-  def flag; end
-  def flag=(val); end
-  def lm_response; end
-  def lm_response=(val); end
-  def ntlm_response; end
-  def ntlm_response=(val); end
-  def ntlm_version; end
-  def os_version; end
-  def os_version=(val); end
-  def password?(password, server_challenge); end
-  def session_key; end
-  def session_key=(val); end
-  def sign; end
-  def sign=(val); end
-  def type; end
-  def type=(val); end
-  def user; end
-  def user=(val); end
-  def workstation; end
-  def workstation=(val); end
-
-  private
-
-  def ntlm2_session_password?(password, server_challenge); end
-  def ntlmv2_password?(password, server_challenge); end
-
-  class << self
-    def create(arg, opt = T.unsafe(nil)); end
-  end
-end
-
-class Net::NTLM::SecurityBuffer < ::Net::NTLM::FieldSet
-  def initialize(opts = T.unsafe(nil)); end
-
-  def active; end
-  def active=(_arg0); end
-  def allocated; end
-  def allocated=(val); end
-  def data_size; end
-  def length; end
-  def length=(val); end
-  def offset; end
-  def offset=(val); end
-  def parse(str, offset = T.unsafe(nil)); end
-  def serialize; end
-  def value; end
-  def value=(val); end
-end
-
-class Net::NTLM::String < ::Net::NTLM::Field
-  def initialize(opts); end
-
-  def parse(str, offset = T.unsafe(nil)); end
-  def serialize; end
-  def value=(val); end
-end
-
-class Net::NTLM::TargetInfo
-  def initialize(av_pair_sequence); end
-
-  def av_pairs; end
-  def to_s; end
-
-  private
-
-  def read_pairs(av_pair_sequence); end
-  def to_hex(str); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov-cobertura@2.1.0.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov-cobertura@2.1.0.rbi
index 0b7022c3d9a8d..5ce3efbb52bfb 100644
--- a/Library/Homebrew/sorbet/rbi/gems/simplecov-cobertura@2.1.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/simplecov-cobertura@2.1.0.rbi
@@ -4,83 +4,187 @@
 # This is an autogenerated file for types exported from the `simplecov-cobertura` gem.
 # Please instead update this file by running `bin/tapioca gem simplecov-cobertura`.
 
+# source://simplecov-cobertura//lib/simplecov-cobertura/version.rb#1
 module SimpleCov
-  extend ::SimpleCov::Configuration
-
   class << self
+    # source://simplecov/0.22.0/lib/simplecov.rb#174
     def at_exit_behavior; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#170
     def clear_result; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#86
     def collate(result_filenames, profile = T.unsafe(nil), ignore_timeout: T.unsafe(nil), &block); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#223
     def exit_and_report_previous_error(exit_status); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#200
     def exit_status_from_exception; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#28
     def external_at_exit; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#28
     def external_at_exit=(_arg0); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#28
     def external_at_exit?; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#131
     def filtered(files); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#268
     def final_result_process?; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#142
     def grouped(files); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#162
     def load_adapter(name); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#158
     def load_profile(name); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#24
     def pid; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#24
     def pid=(_arg0); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#213
     def previous_error?(error_exit_status); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#248
     def process_result(result); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#233
     def process_results_and_report_error; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#229
     def ready_to_process_results?; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#101
     def result; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#124
     def result?; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#256
     def result_exit_status(result); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#296
     def round_coverage(coverage); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#186
     def run_exit_tasks!; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#24
     def running; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#24
     def running=(_arg0); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#48
     def start(profile = T.unsafe(nil), &block); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#276
     def wait_for_other_processes; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#285
     def write_last_run(result); end
 
     private
 
+    # source://simplecov/0.22.0/lib/simplecov.rb#399
     def adapt_coverage_result; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#371
     def add_not_loaded_files(result); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#302
     def initial_setup(profile, &block); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#363
     def lookup_corresponding_ruby_coverage_name(criterion); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#425
     def make_parallel_tests_available; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#434
     def probably_running_parallel_tests?; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#388
     def process_coverage_result; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#410
     def remove_useless_results; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#420
     def result_with_not_loaded_files; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#314
     def start_coverage_measurement; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#349
     def start_coverage_with_criteria; end
   end
 end
 
-module SimpleCov::Formatter
-  class << self
-    def from_env(env); end
-  end
-end
+# source://simplecov-cobertura//lib/simplecov-cobertura/version.rb#2
+module SimpleCov::Formatter; end
 
+# source://simplecov-cobertura//lib/simplecov-cobertura/version.rb#3
 class SimpleCov::Formatter::CoberturaFormatter
+  # @return [CoberturaFormatter] a new instance of CoberturaFormatter
+  #
+  # source://simplecov-cobertura//lib/simplecov-cobertura.rb#15
   def initialize(result_file_name: T.unsafe(nil)); end
 
+  # source://simplecov-cobertura//lib/simplecov-cobertura.rb#19
   def format(result); end
 
   private
 
+  # source://simplecov-cobertura//lib/simplecov-cobertura.rb#151
   def coverage_output(result); end
+
+  # source://simplecov-cobertura//lib/simplecov-cobertura.rb#166
   def extract_rate(percent); end
+
+  # source://simplecov-cobertura//lib/simplecov-cobertura.rb#170
   def project_root; end
+
+  # source://simplecov-cobertura//lib/simplecov-cobertura.rb#162
   def resolve_filename(filename); end
+
+  # source://simplecov-cobertura//lib/simplecov-cobertura.rb#36
   def result_to_xml(result); end
+
+  # source://simplecov-cobertura//lib/simplecov-cobertura.rb#134
   def set_branch_attributes(line, file_line, branched_lines, branched_lines_covered); end
+
+  # source://simplecov-cobertura//lib/simplecov-cobertura.rb#115
   def set_class_attributes(class_, file); end
+
+  # source://simplecov-cobertura//lib/simplecov-cobertura.rb#86
   def set_coverage_attributes(coverage, result); end
+
+  # source://simplecov-cobertura//lib/simplecov-cobertura.rb#129
   def set_line_attributes(line, file_line); end
+
+  # source://simplecov-cobertura//lib/simplecov-cobertura.rb#103
   def set_package_attributes(package, name, result); end
+
+  # source://simplecov-cobertura//lib/simplecov-cobertura.rb#144
   def set_xml_head(lines = T.unsafe(nil)); end
 end
 
+# source://simplecov-cobertura//lib/simplecov-cobertura.rb#13
 SimpleCov::Formatter::CoberturaFormatter::DTD_URL = T.let(T.unsafe(nil), String)
+
+# source://simplecov-cobertura//lib/simplecov-cobertura.rb#12
 SimpleCov::Formatter::CoberturaFormatter::RESULT_FILE_NAME = T.let(T.unsafe(nil), String)
+
+# source://simplecov-cobertura//lib/simplecov-cobertura/version.rb#4
 SimpleCov::Formatter::CoberturaFormatter::VERSION = T.let(T.unsafe(nil), String)
-SimpleCov::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.3.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.3.rbi
deleted file mode 100644
index 4053d47423a5e..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.3.rbi
+++ /dev/null
@@ -1,89 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `simplecov-html` gem.
-# Please instead update this file by running `bin/tapioca gem simplecov-html`.
-
-module SimpleCov
-  extend ::SimpleCov::Configuration
-
-  class << self
-    def at_exit_behavior; end
-    def clear_result; end
-    def collate(result_filenames, profile = T.unsafe(nil), ignore_timeout: T.unsafe(nil), &block); end
-    def exit_and_report_previous_error(exit_status); end
-    def exit_status_from_exception; end
-    def external_at_exit; end
-    def external_at_exit=(_arg0); end
-    def external_at_exit?; end
-    def filtered(files); end
-    def final_result_process?; end
-    def grouped(files); end
-    def load_adapter(name); end
-    def load_profile(name); end
-    def pid; end
-    def pid=(_arg0); end
-    def previous_error?(error_exit_status); end
-    def process_result(result); end
-    def process_results_and_report_error; end
-    def ready_to_process_results?; end
-    def result; end
-    def result?; end
-    def result_exit_status(result); end
-    def round_coverage(coverage); end
-    def run_exit_tasks!; end
-    def running; end
-    def running=(_arg0); end
-    def start(profile = T.unsafe(nil), &block); end
-    def wait_for_other_processes; end
-    def write_last_run(result); end
-
-    private
-
-    def adapt_coverage_result; end
-    def add_not_loaded_files(result); end
-    def initial_setup(profile, &block); end
-    def lookup_corresponding_ruby_coverage_name(criterion); end
-    def make_parallel_tests_available; end
-    def probably_running_parallel_tests?; end
-    def process_coverage_result; end
-    def remove_useless_results; end
-    def result_with_not_loaded_files; end
-    def start_coverage_measurement; end
-    def start_coverage_with_criteria; end
-  end
-end
-
-module SimpleCov::Formatter
-  class << self
-    def from_env(env); end
-  end
-end
-
-class SimpleCov::Formatter::HTMLFormatter
-  def initialize; end
-
-  def branchable_result?; end
-  def format(result); end
-  def line_status?(source_file, line); end
-  def output_message(result); end
-
-  private
-
-  def asset_output_path; end
-  def assets_path(name); end
-  def coverage_css_class(covered_percent); end
-  def covered_percent(percent); end
-  def formatted_file_list(title, source_files); end
-  def formatted_source_file(source_file); end
-  def id(source_file); end
-  def link_to_source_file(source_file); end
-  def output_path; end
-  def shortened_filename(source_file); end
-  def strength_css_class(covered_strength); end
-  def template(name); end
-  def timeago(time); end
-end
-
-SimpleCov::Formatter::HTMLFormatter::VERSION = T.let(T.unsafe(nil), String)
-SimpleCov::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.13.1.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.13.1.rbi
new file mode 100644
index 0000000000000..46e3391e67c9b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.13.1.rbi
@@ -0,0 +1,220 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `simplecov-html` gem.
+# Please instead update this file by running `bin/tapioca gem simplecov-html`.
+
+
+# source://simplecov-html//lib/simplecov-html.rb#16
+module SimpleCov
+  class << self
+    # source://simplecov/0.22.0/lib/simplecov.rb#174
+    def at_exit_behavior; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#170
+    def clear_result; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#86
+    def collate(result_filenames, profile = T.unsafe(nil), ignore_timeout: T.unsafe(nil), &block); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#223
+    def exit_and_report_previous_error(exit_status); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#200
+    def exit_status_from_exception; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#28
+    def external_at_exit; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#28
+    def external_at_exit=(_arg0); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#28
+    def external_at_exit?; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#131
+    def filtered(files); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#268
+    def final_result_process?; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#142
+    def grouped(files); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#162
+    def load_adapter(name); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#158
+    def load_profile(name); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#24
+    def pid; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#24
+    def pid=(_arg0); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#213
+    def previous_error?(error_exit_status); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#248
+    def process_result(result); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#233
+    def process_results_and_report_error; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#229
+    def ready_to_process_results?; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#101
+    def result; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#124
+    def result?; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#256
+    def result_exit_status(result); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#296
+    def round_coverage(coverage); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#186
+    def run_exit_tasks!; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#24
+    def running; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#24
+    def running=(_arg0); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#48
+    def start(profile = T.unsafe(nil), &block); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#276
+    def wait_for_other_processes; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#285
+    def write_last_run(result); end
+
+    private
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#399
+    def adapt_coverage_result; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#371
+    def add_not_loaded_files(result); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#302
+    def initial_setup(profile, &block); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#363
+    def lookup_corresponding_ruby_coverage_name(criterion); end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#425
+    def make_parallel_tests_available; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#434
+    def probably_running_parallel_tests?; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#388
+    def process_coverage_result; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#410
+    def remove_useless_results; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#420
+    def result_with_not_loaded_files; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#314
+    def start_coverage_measurement; end
+
+    # source://simplecov/0.22.0/lib/simplecov.rb#349
+    def start_coverage_with_criteria; end
+  end
+end
+
+# source://simplecov-html//lib/simplecov-html.rb#17
+module SimpleCov::Formatter; end
+
+# source://simplecov-html//lib/simplecov-html.rb#18
+class SimpleCov::Formatter::HTMLFormatter
+  # @return [HTMLFormatter] a new instance of HTMLFormatter
+  #
+  # source://simplecov-html//lib/simplecov-html.rb#19
+  def initialize; end
+
+  # source://simplecov-html//lib/simplecov-html.rb#26
+  def format(result); end
+
+  private
+
+  # source://simplecov-html//lib/simplecov-html.rb#94
+  def asset_inline(name); end
+
+  # source://simplecov-html//lib/simplecov-html.rb#72
+  def asset_output_path; end
+
+  # source://simplecov-html//lib/simplecov-html.rb#80
+  def assets_path(name); end
+
+  # @return [Boolean]
+  #
+  # source://simplecov-html//lib/simplecov-html.rb#41
+  def branchable_result?; end
+
+  # source://simplecov-html//lib/simplecov-html.rb#125
+  def coverage_css_class(covered_percent); end
+
+  # source://simplecov-html//lib/simplecov-html.rb#121
+  def covered_percent(percent); end
+
+  # Returns a table containing the given source files
+  #
+  # source://simplecov-html//lib/simplecov-html.rb#112
+  def formatted_file_list(title, source_files); end
+
+  # Returns the html for the given source_file
+  #
+  # source://simplecov-html//lib/simplecov-html.rb#105
+  def formatted_source_file(source_file); end
+
+  # Return a (kind of) unique id for the source file given. Uses SHA1 on path for the id
+  #
+  # source://simplecov-html//lib/simplecov-html.rb#146
+  def id(source_file); end
+
+  # @return [Boolean]
+  #
+  # source://simplecov-html//lib/simplecov-html.rb#48
+  def line_status?(source_file, line); end
+
+  # source://simplecov-html//lib/simplecov-html.rb#158
+  def link_to_source_file(source_file); end
+
+  # source://simplecov-html//lib/simplecov-html.rb#56
+  def output_message(result); end
+
+  # source://simplecov-html//lib/simplecov-html.rb#68
+  def output_path; end
+
+  # source://simplecov-html//lib/simplecov-html.rb#154
+  def shortened_filename(source_file); end
+
+  # source://simplecov-html//lib/simplecov-html.rb#135
+  def strength_css_class(covered_strength); end
+
+  # Returns the an erb instance for the template of given name
+  #
+  # source://simplecov-html//lib/simplecov-html.rb#64
+  def template(name); end
+
+  # source://simplecov-html//lib/simplecov-html.rb#150
+  def timeago(time); end
+end
+
+# Only have a few content types, just hardcode them
+#
+# source://simplecov-html//lib/simplecov-html.rb#87
+SimpleCov::Formatter::HTMLFormatter::CONTENT_TYPES = T.let(T.unsafe(nil), Hash)
+
+# source://simplecov-html//lib/simplecov-html/version.rb#6
+SimpleCov::Formatter::HTMLFormatter::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov@0.21.2.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov@0.21.2.rbi
deleted file mode 100644
index 0e594824e270b..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/simplecov@0.21.2.rbi
+++ /dev/null
@@ -1,577 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `simplecov` gem.
-# Please instead update this file by running `bin/tapioca gem simplecov`.
-
-module SimpleCov
-  extend ::SimpleCov::Configuration
-
-  class << self
-    def at_exit_behavior; end
-    def clear_result; end
-    def collate(result_filenames, profile = T.unsafe(nil), ignore_timeout: T.unsafe(nil), &block); end
-    def exit_and_report_previous_error(exit_status); end
-    def exit_status_from_exception; end
-    def external_at_exit; end
-    def external_at_exit=(_arg0); end
-    def external_at_exit?; end
-    def filtered(files); end
-    def final_result_process?; end
-    def grouped(files); end
-    def load_adapter(name); end
-    def load_profile(name); end
-    def pid; end
-    def pid=(_arg0); end
-    def previous_error?(error_exit_status); end
-    def process_result(result); end
-    def process_results_and_report_error; end
-    def ready_to_process_results?; end
-    def result; end
-    def result?; end
-    def result_exit_status(result); end
-    def round_coverage(coverage); end
-    def run_exit_tasks!; end
-    def running; end
-    def running=(_arg0); end
-    def start(profile = T.unsafe(nil), &block); end
-    def wait_for_other_processes; end
-    def write_last_run(result); end
-
-    private
-
-    def adapt_coverage_result; end
-    def add_not_loaded_files(result); end
-    def initial_setup(profile, &block); end
-    def lookup_corresponding_ruby_coverage_name(criterion); end
-    def make_parallel_tests_available; end
-    def probably_running_parallel_tests?; end
-    def process_coverage_result; end
-    def remove_useless_results; end
-    def result_with_not_loaded_files; end
-    def start_coverage_measurement; end
-    def start_coverage_with_criteria; end
-  end
-end
-
-class SimpleCov::ArrayFilter < ::SimpleCov::Filter
-  def initialize(filter_argument); end
-
-  def matches?(source_files_list); end
-end
-
-class SimpleCov::BlockFilter < ::SimpleCov::Filter
-  def matches?(source_file); end
-end
-
-module SimpleCov::Combine
-  private
-
-  def combine(combiner_module, coverage_a, coverage_b); end
-  def empty_coverage?(coverage_a, coverage_b); end
-  def existing_coverage(coverage_a, coverage_b); end
-
-  class << self
-    def combine(combiner_module, coverage_a, coverage_b); end
-    def empty_coverage?(coverage_a, coverage_b); end
-    def existing_coverage(coverage_a, coverage_b); end
-  end
-end
-
-module SimpleCov::Combine::BranchesCombiner
-  private
-
-  def combine(coverage_a, coverage_b); end
-
-  class << self
-    def combine(coverage_a, coverage_b); end
-  end
-end
-
-module SimpleCov::Combine::FilesCombiner
-  private
-
-  def combine(coverage_a, coverage_b); end
-
-  class << self
-    def combine(coverage_a, coverage_b); end
-  end
-end
-
-module SimpleCov::Combine::LinesCombiner
-  private
-
-  def combine(coverage_a, coverage_b); end
-  def merge_line_coverage(first_val, second_val); end
-
-  class << self
-    def combine(coverage_a, coverage_b); end
-    def merge_line_coverage(first_val, second_val); end
-  end
-end
-
-module SimpleCov::Combine::ResultsCombiner
-  private
-
-  def combine(*results); end
-  def combine_file_coverage(coverage_a, coverage_b); end
-  def combine_result_sets(combined_results, result); end
-
-  class << self
-    def combine(*results); end
-    def combine_file_coverage(coverage_a, coverage_b); end
-    def combine_result_sets(combined_results, result); end
-  end
-end
-
-module SimpleCov::CommandGuesser
-  class << self
-    def guess; end
-    def original_run_command; end
-    def original_run_command=(_arg0); end
-
-    private
-
-    def from_command_line_options; end
-    def from_defined_constants; end
-    def from_env; end
-  end
-end
-
-module SimpleCov::Configuration
-  def adapters; end
-  def add_filter(filter_argument = T.unsafe(nil), &filter_proc); end
-  def add_group(group_name, filter_argument = T.unsafe(nil), &filter_proc); end
-  def at_exit(&block); end
-  def at_fork(&block); end
-  def branch_coverage?; end
-  def branch_coverage_supported?; end
-  def clear_coverage_criteria; end
-  def command_name(name = T.unsafe(nil)); end
-  def configure(&block); end
-  def coverage_criteria; end
-  def coverage_criterion(criterion = T.unsafe(nil)); end
-  def coverage_criterion_enabled?(criterion); end
-  def coverage_dir(dir = T.unsafe(nil)); end
-  def coverage_path; end
-  def coverage_start_arguments_supported?; end
-  def enable_coverage(criterion); end
-  def enable_for_subprocesses(value = T.unsafe(nil)); end
-  def enabled_for_subprocesses?; end
-  def filters; end
-  def filters=(_arg0); end
-  def formatter(formatter = T.unsafe(nil)); end
-  def formatter=(_arg0); end
-  def formatters; end
-  def formatters=(formatters); end
-  def groups; end
-  def groups=(_arg0); end
-  def maximum_coverage_drop(coverage_drop = T.unsafe(nil)); end
-  def merge_timeout(seconds = T.unsafe(nil)); end
-  def minimum_coverage(coverage = T.unsafe(nil)); end
-  def minimum_coverage_by_file(coverage = T.unsafe(nil)); end
-  def nocov_token(nocov_token = T.unsafe(nil)); end
-  def primary_coverage(criterion = T.unsafe(nil)); end
-  def print_error_status; end
-  def print_error_status=(_arg0); end
-  def profiles; end
-  def project_name(new_name = T.unsafe(nil)); end
-  def raise_on_invalid_coverage(coverage, coverage_setting); end
-  def refuse_coverage_drop(*criteria); end
-  def root(root = T.unsafe(nil)); end
-  def skip_token(nocov_token = T.unsafe(nil)); end
-  def track_files(glob); end
-  def tracked_files; end
-  def use_merging(use = T.unsafe(nil)); end
-
-  private
-
-  def minimum_possible_coverage_exceeded(coverage_option); end
-  def parse_filter(filter_argument = T.unsafe(nil), &filter_proc); end
-  def raise_if_criterion_disabled(criterion); end
-  def raise_if_criterion_unsupported(criterion); end
-end
-
-SimpleCov::Configuration::DEFAULT_COVERAGE_CRITERION = T.let(T.unsafe(nil), Symbol)
-SimpleCov::Configuration::SUPPORTED_COVERAGE_CRITERIA = T.let(T.unsafe(nil), Array)
-
-class SimpleCov::CoverageStatistics
-  def initialize(covered:, missed:, total_strength: T.unsafe(nil)); end
-
-  def covered; end
-  def missed; end
-  def percent; end
-  def strength; end
-  def total; end
-
-  private
-
-  def compute_percent(covered, missed, total); end
-  def compute_strength(total_strength, total); end
-
-  class << self
-    def from(coverage_statistics); end
-  end
-end
-
-module SimpleCov::ExitCodes; end
-SimpleCov::ExitCodes::EXCEPTION = T.let(T.unsafe(nil), Integer)
-
-module SimpleCov::ExitCodes::ExitCodeHandling
-  private
-
-  def call(result, coverage_limits:); end
-  def coverage_checks(result, coverage_limits); end
-
-  class << self
-    def call(result, coverage_limits:); end
-    def coverage_checks(result, coverage_limits); end
-  end
-end
-
-SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP = T.let(T.unsafe(nil), Integer)
-SimpleCov::ExitCodes::MINIMUM_COVERAGE = T.let(T.unsafe(nil), Integer)
-
-class SimpleCov::ExitCodes::MaximumCoverageDropCheck
-  def initialize(result, maximum_coverage_drop); end
-
-  def exit_code; end
-  def failing?; end
-  def report; end
-
-  private
-
-  def compute_coverage_drop_data; end
-  def coverage_drop_violations; end
-  def drop_percent(criterion); end
-  def last_coverage(criterion); end
-  def last_run; end
-  def maximum_coverage_drop; end
-  def result; end
-end
-
-SimpleCov::ExitCodes::MaximumCoverageDropCheck::MAX_DROP_ACCURACY = T.let(T.unsafe(nil), Integer)
-
-class SimpleCov::ExitCodes::MinimumCoverageByFileCheck
-  def initialize(result, minimum_coverage_by_file); end
-
-  def exit_code; end
-  def failing?; end
-  def report; end
-
-  private
-
-  def compute_minimum_coverage_data; end
-  def minimum_coverage_by_file; end
-  def minimum_violations; end
-  def result; end
-end
-
-class SimpleCov::ExitCodes::MinimumOverallCoverageCheck
-  def initialize(result, minimum_coverage); end
-
-  def exit_code; end
-  def failing?; end
-  def report; end
-
-  private
-
-  def calculate_minimum_violations; end
-  def minimum_coverage; end
-  def minimum_violations; end
-  def result; end
-end
-
-SimpleCov::ExitCodes::SUCCESS = T.let(T.unsafe(nil), Integer)
-
-class SimpleCov::FileList
-  include ::Enumerable
-  extend ::Forwardable
-
-  def initialize(files); end
-
-  def branch_covered_percent; end
-  def count(*args, &block); end
-  def coverage_statistics; end
-  def coverage_statistics_by_file; end
-  def covered_branches; end
-  def covered_lines; end
-  def covered_percent; end
-  def covered_percentages; end
-  def covered_strength; end
-  def each(*args, &block); end
-  def empty?(*args, &block); end
-  def least_covered_file; end
-  def length(*args, &block); end
-  def lines_of_code; end
-  def map(*args, &block); end
-  def missed_branches; end
-  def missed_lines; end
-  def never_lines; end
-  def size(*args, &block); end
-  def skipped_lines; end
-  def to_a(*args, &block); end
-  def to_ary(*args, &block); end
-  def total_branches; end
-
-  private
-
-  def compute_coverage_statistics; end
-  def compute_coverage_statistics_by_file; end
-end
-
-class SimpleCov::Filter
-  def initialize(filter_argument); end
-
-  def filter_argument; end
-  def matches?(_source_file); end
-  def passes?(source_file); end
-
-  class << self
-    def build_filter(filter_argument); end
-    def class_for_argument(filter_argument); end
-  end
-end
-
-module SimpleCov::Formatter
-  class << self
-    def from_env(env); end
-  end
-end
-
-class SimpleCov::Formatter::MultiFormatter
-  class << self
-    def [](*args); end
-    def new(formatters = T.unsafe(nil)); end
-  end
-end
-
-module SimpleCov::Formatter::MultiFormatter::InstanceMethods
-  def format(result); end
-end
-
-class SimpleCov::Formatter::SimpleFormatter
-  def format(result); end
-end
-
-module SimpleCov::LastRun
-  class << self
-    def last_run_path; end
-    def read; end
-    def write(json); end
-  end
-end
-
-class SimpleCov::LinesClassifier
-  def classify(lines); end
-
-  class << self
-    def no_cov_line; end
-    def no_cov_line?(line); end
-    def whitespace_line?(line); end
-  end
-end
-
-SimpleCov::LinesClassifier::COMMENT_LINE = T.let(T.unsafe(nil), Regexp)
-SimpleCov::LinesClassifier::RELEVANT = T.let(T.unsafe(nil), Integer)
-SimpleCov::LinesClassifier::WHITESPACE_LINE = T.let(T.unsafe(nil), Regexp)
-SimpleCov::LinesClassifier::WHITESPACE_OR_COMMENT_LINE = T.let(T.unsafe(nil), Regexp)
-
-class SimpleCov::Profiles < ::Hash
-  def define(name, &blk); end
-  def load(name); end
-end
-
-class SimpleCov::RegexFilter < ::SimpleCov::Filter
-  def matches?(source_file); end
-end
-
-class SimpleCov::Result
-  extend ::Forwardable
-
-  def initialize(original_result, command_name: T.unsafe(nil), created_at: T.unsafe(nil)); end
-
-  def command_name; end
-  def command_name=(_arg0); end
-  def coverage_statistics(*args, &block); end
-  def coverage_statistics_by_file(*args, &block); end
-  def covered_branches(*args, &block); end
-  def covered_lines(*args, &block); end
-  def covered_percent(*args, &block); end
-  def covered_percentages(*args, &block); end
-  def covered_strength(*args, &block); end
-  def created_at; end
-  def created_at=(_arg0); end
-  def filenames; end
-  def files; end
-  def format!; end
-  def groups; end
-  def least_covered_file(*args, &block); end
-  def missed_branches(*args, &block); end
-  def missed_lines(*args, &block); end
-  def original_result; end
-  def source_files; end
-  def to_hash; end
-  def total_branches(*args, &block); end
-  def total_lines(*args, &block); end
-
-  private
-
-  def coverage; end
-  def filter!; end
-
-  class << self
-    def from_hash(hash); end
-  end
-end
-
-class SimpleCov::ResultAdapter
-  def initialize(result); end
-
-  def adapt; end
-  def result; end
-
-  class << self
-    def call(*args); end
-  end
-end
-
-module SimpleCov::ResultMerger
-  class << self
-    def adapt_pre_simplecov_0_18_result(result); end
-    def adapt_result(result); end
-    def create_result(command_names, coverage); end
-    def merge_and_store(*file_paths, ignore_timeout: T.unsafe(nil)); end
-    def merge_coverage(*results); end
-    def merge_results(*file_paths, ignore_timeout: T.unsafe(nil)); end
-    def merge_valid_results(results, ignore_timeout: T.unsafe(nil)); end
-    def merged_result; end
-    def parse_file(path); end
-    def parse_json(content); end
-    def pre_simplecov_0_18_result?(result); end
-    def read_file(path); end
-    def read_resultset; end
-    def resultset_path; end
-    def resultset_writelock; end
-    def store_result(result); end
-    def synchronize_resultset; end
-    def time_since_result_creation(data); end
-    def valid_results(file_path, ignore_timeout: T.unsafe(nil)); end
-    def within_merge_timeout?(data); end
-  end
-end
-
-module SimpleCov::SimulateCoverage
-  private
-
-  def call(absolute_path); end
-
-  class << self
-    def call(absolute_path); end
-  end
-end
-
-class SimpleCov::SourceFile
-  def initialize(filename, coverage_data); end
-
-  def branches; end
-  def branches_coverage_percent; end
-  def branches_for_line(line_number); end
-  def branches_report; end
-  def coverage_data; end
-  def coverage_statistics; end
-  def covered_branches; end
-  def covered_lines; end
-  def covered_percent; end
-  def covered_strength; end
-  def filename; end
-  def line(number); end
-  def line_with_missed_branch?(line_number); end
-  def lines; end
-  def lines_of_code; end
-  def missed_branches; end
-  def missed_lines; end
-  def never_lines; end
-  def no_branches?; end
-  def no_lines?; end
-  def project_filename; end
-  def relevant_lines; end
-  def skipped_lines; end
-  def source; end
-  def source_lines; end
-  def src; end
-  def total_branches; end
-
-  private
-
-  def branch_coverage_statistics; end
-  def build_branch(branch_data, hit_count, condition_start_line); end
-  def build_branches; end
-  def build_branches_from(condition, branches); end
-  def build_branches_report; end
-  def build_lines; end
-  def build_no_cov_chunks; end
-  def coverage_exceeding_source_warn; end
-  def ensure_remove_undefs(file_lines); end
-  def line_coverage_statistics; end
-  def lines_strength; end
-  def load_source; end
-  def no_cov_chunks; end
-  def process_skipped_branches(branches); end
-  def process_skipped_lines(lines); end
-  def read_lines(file, lines, current_line); end
-  def restore_ruby_data_structure(structure); end
-  def set_encoding_based_on_magic_comment(file, line); end
-  def shebang?(line); end
-end
-
-class SimpleCov::SourceFile::Branch
-  def initialize(start_line:, end_line:, coverage:, inline:, type:); end
-
-  def coverage; end
-  def covered?; end
-  def end_line; end
-  def inline?; end
-  def missed?; end
-  def overlaps_with?(line_range); end
-  def report; end
-  def report_line; end
-  def skipped!; end
-  def skipped?; end
-  def start_line; end
-  def type; end
-end
-
-class SimpleCov::SourceFile::Line
-  def initialize(src, line_number, coverage); end
-
-  def coverage; end
-  def covered?; end
-  def line; end
-  def line_number; end
-  def missed?; end
-  def never?; end
-  def number; end
-  def skipped; end
-  def skipped!; end
-  def skipped?; end
-  def source; end
-  def src; end
-  def status; end
-end
-
-SimpleCov::SourceFile::RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = T.let(T.unsafe(nil), Regexp)
-SimpleCov::SourceFile::SHEBANG_REGEX = T.let(T.unsafe(nil), Regexp)
-
-class SimpleCov::StringFilter < ::SimpleCov::Filter
-  def matches?(source_file); end
-end
-
-module SimpleCov::UselessResultsRemover
-  class << self
-    def call(coverage_result); end
-    def root_regx; end
-  end
-end
-
-SimpleCov::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov@0.22.0.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov@0.22.0.rbi
new file mode 100644
index 0000000000000..75bc2f0b13f02
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/simplecov@0.22.0.rbi
@@ -0,0 +1,2143 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `simplecov` gem.
+# Please instead update this file by running `bin/tapioca gem simplecov`.
+
+# Code coverage for ruby. Please check out README for a full introduction.
+#
+# source://simplecov//lib/simplecov.rb#22
+module SimpleCov
+  extend ::SimpleCov::Configuration
+
+  class << self
+    # source://simplecov//lib/simplecov.rb#174
+    def at_exit_behavior; end
+
+    # Clear out the previously cached .result. Primarily useful in testing
+    #
+    # source://simplecov//lib/simplecov.rb#170
+    def clear_result; end
+
+    # Collate a series of SimpleCov result files into a single SimpleCov output.
+    #
+    # You can optionally specify configuration with a block:
+    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"]
+    #    OR
+    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], 'rails' # using rails profile
+    #    OR
+    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"] do
+    #     add_filter 'test'
+    #   end
+    #    OR
+    #   SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], 'rails' do
+    #     add_filter 'test'
+    #   end
+    #
+    # Please check out the RDoc for SimpleCov::Configuration to find about
+    # available config options, or checkout the README for more in-depth
+    # information about coverage collation
+    #
+    # By default `collate` ignores the merge_timeout so all results of all files specified will be
+    # merged together. If you want to honor the merge_timeout then provide the keyword argument
+    # `ignore_timeout: false`.
+    #
+    # source://simplecov//lib/simplecov.rb#86
+    def collate(result_filenames, profile = T.unsafe(nil), ignore_timeout: T.unsafe(nil), &block); end
+
+    # Thinking: Move this behavior earlier so if there was an error we do nothing?
+    #
+    # @api private
+    #
+    # source://simplecov//lib/simplecov.rb#223
+    def exit_and_report_previous_error(exit_status); end
+
+    # Returns the exit status from the exit exception
+    #
+    # @api private
+    #
+    # source://simplecov//lib/simplecov.rb#200
+    def exit_status_from_exception; end
+
+    # Basically, should we take care of at_exit behavior or something else?
+    # Used by the minitest plugin. See lib/minitest/simplecov_plugin.rb
+    #
+    # source://simplecov//lib/simplecov.rb#28
+    def external_at_exit; end
+
+    # Basically, should we take care of at_exit behavior or something else?
+    # Used by the minitest plugin. See lib/minitest/simplecov_plugin.rb
+    #
+    # source://simplecov//lib/simplecov.rb#28
+    def external_at_exit=(_arg0); end
+
+    # Basically, should we take care of at_exit behavior or something else?
+    # Used by the minitest plugin. See lib/minitest/simplecov_plugin.rb
+    #
+    # source://simplecov//lib/simplecov.rb#28
+    def external_at_exit?; end
+
+    # Applies the configured filters to the given array of SimpleCov::SourceFile items
+    #
+    # source://simplecov//lib/simplecov.rb#131
+    def filtered(files); end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://simplecov//lib/simplecov.rb#268
+    def final_result_process?; end
+
+    # Applies the configured groups to the given array of SimpleCov::SourceFile items
+    #
+    # source://simplecov//lib/simplecov.rb#142
+    def grouped(files); end
+
+    # source://simplecov//lib/simplecov.rb#162
+    def load_adapter(name); end
+
+    # Applies the profile of given name on SimpleCov configuration
+    #
+    # source://simplecov//lib/simplecov.rb#158
+    def load_profile(name); end
+
+    # Returns the value of attribute pid.
+    #
+    # source://simplecov//lib/simplecov.rb#24
+    def pid; end
+
+    # Sets the attribute pid
+    #
+    # @param value the value to set the attribute pid to.
+    #
+    # source://simplecov//lib/simplecov.rb#24
+    def pid=(_arg0); end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://simplecov//lib/simplecov.rb#213
+    def previous_error?(error_exit_status); end
+
+    # Usage:
+    #   exit_status = SimpleCov.process_result(SimpleCov.result, exit_status)
+    #
+    # @api private
+    #
+    # source://simplecov//lib/simplecov.rb#248
+    def process_result(result); end
+
+    # source://simplecov//lib/simplecov.rb#233
+    def process_results_and_report_error; end
+
+    # @api private
+    # @return [Boolean]
+    #
+    # source://simplecov//lib/simplecov.rb#229
+    def ready_to_process_results?; end
+
+    # Returns the result for the current coverage run, merging it across test suites
+    # from cache using SimpleCov::ResultMerger if use_merging is activated (default)
+    #
+    # source://simplecov//lib/simplecov.rb#101
+    def result; end
+
+    # Returns nil if the result has not been computed
+    # Otherwise, returns the result
+    #
+    # @return [Boolean]
+    #
+    # source://simplecov//lib/simplecov.rb#124
+    def result?; end
+
+    # source://simplecov//lib/simplecov.rb#256
+    def result_exit_status(result); end
+
+    # Rounding down to be extra strict, see #679
+    #
+    # @api private
+    #
+    # source://simplecov//lib/simplecov.rb#296
+    def round_coverage(coverage); end
+
+    # Called from at_exit block
+    #
+    # @api private
+    #
+    # source://simplecov//lib/simplecov.rb#186
+    def run_exit_tasks!; end
+
+    # Returns the value of attribute running.
+    #
+    # source://simplecov//lib/simplecov.rb#24
+    def running; end
+
+    # Sets the attribute running
+    #
+    # @param value the value to set the attribute running to.
+    #
+    # source://simplecov//lib/simplecov.rb#24
+    def running=(_arg0); end
+
+    # Sets up SimpleCov to run against your project.
+    # You can optionally specify a profile to use as well as configuration with a block:
+    #   SimpleCov.start
+    #    OR
+    #   SimpleCov.start 'rails' # using rails profile
+    #    OR
+    #   SimpleCov.start do
+    #     add_filter 'test'
+    #   end
+    #     OR
+    #   SimpleCov.start 'rails' do
+    #     add_filter 'test'
+    #   end
+    #
+    # Please check out the RDoc for SimpleCov::Configuration to find about available config options
+    #
+    # source://simplecov//lib/simplecov.rb#48
+    def start(profile = T.unsafe(nil), &block); end
+
+    # @api private
+    #
+    # source://simplecov//lib/simplecov.rb#276
+    def wait_for_other_processes; end
+
+    # @api private
+    #
+    # source://simplecov//lib/simplecov.rb#285
+    def write_last_run(result); end
+
+    private
+
+    # Unite the result so it wouldn't matter what coverage type was called
+    #
+    # @return [Hash]
+    #
+    # source://simplecov//lib/simplecov.rb#399
+    def adapt_coverage_result; end
+
+    # Finds files that were to be tracked but were not loaded and initializes
+    # the line-by-line coverage to zero (if relevant) or nil (comments / whitespace etc).
+    #
+    # source://simplecov//lib/simplecov.rb#371
+    def add_not_loaded_files(result); end
+
+    # source://simplecov//lib/simplecov.rb#302
+    def initial_setup(profile, &block); end
+
+    # source://simplecov//lib/simplecov.rb#363
+    def lookup_corresponding_ruby_coverage_name(criterion); end
+
+    # parallel_tests isn't always available, see: https://github.com/grosser/parallel_tests/issues/772
+    #
+    # source://simplecov//lib/simplecov.rb#425
+    def make_parallel_tests_available; end
+
+    # @return [Boolean]
+    #
+    # source://simplecov//lib/simplecov.rb#434
+    def probably_running_parallel_tests?; end
+
+    # Call steps that handle process coverage result
+    #
+    # @return [Hash]
+    #
+    # source://simplecov//lib/simplecov.rb#388
+    def process_coverage_result; end
+
+    # Filter coverage result
+    # The result before filter also has result of coverage for files
+    # are not related to the project like loaded gems coverage.
+    #
+    # @return [Hash]
+    #
+    # source://simplecov//lib/simplecov.rb#410
+    def remove_useless_results; end
+
+    # Initialize result with files that are not included by coverage
+    # and added inside the config block
+    #
+    # @return [Hash]
+    #
+    # source://simplecov//lib/simplecov.rb#420
+    def result_with_not_loaded_files; end
+
+    # Trigger Coverage.start depends on given config coverage_criterion
+    #
+    # With Positive branch it supports all coverage measurement types
+    # With Negative branch it supports only line coverage measurement type
+    #
+    # source://simplecov//lib/simplecov.rb#314
+    def start_coverage_measurement; end
+
+    # source://simplecov//lib/simplecov.rb#349
+    def start_coverage_with_criteria; end
+  end
+end
+
+# source://simplecov//lib/simplecov/filter.rb#77
+class SimpleCov::ArrayFilter < ::SimpleCov::Filter
+  # @return [ArrayFilter] a new instance of ArrayFilter
+  #
+  # source://simplecov//lib/simplecov/filter.rb#78
+  def initialize(filter_argument); end
+
+  # Returns true if any of the filters in the array match the given source file.
+  # Configure this Filter like StringFilter.new(['some/path', /^some_regex/, Proc.new {|src_file| ... }])
+  #
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/filter.rb#88
+  def matches?(source_files_list); end
+end
+
+# source://simplecov//lib/simplecov/filter.rb#71
+class SimpleCov::BlockFilter < ::SimpleCov::Filter
+  # Returns true if the block given when initializing this filter with BlockFilter.new {|src_file| ... }
+  # returns true for the given source file.
+  #
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/filter.rb#72
+  def matches?(source_file); end
+end
+
+# Functionally for combining coverage results
+#
+# source://simplecov//lib/simplecov/combine.rb#6
+module SimpleCov::Combine
+  private
+
+  # Combine two coverage based on the given combiner_module.
+  #
+  # Combiners should always be called through this interface,
+  # as it takes care of short-circuiting of one of the coverages is nil.
+  #
+  # @return [Hash]
+  #
+  # source://simplecov//lib/simplecov/combine.rb#16
+  def combine(combiner_module, coverage_a, coverage_b); end
+
+  # source://simplecov//lib/simplecov/combine.rb#22
+  def empty_coverage?(coverage_a, coverage_b); end
+
+  # source://simplecov//lib/simplecov/combine.rb#26
+  def existing_coverage(coverage_a, coverage_b); end
+
+  class << self
+    # Combine two coverage based on the given combiner_module.
+    #
+    # Combiners should always be called through this interface,
+    # as it takes care of short-circuiting of one of the coverages is nil.
+    #
+    # @return [Hash]
+    #
+    # source://simplecov//lib/simplecov/combine.rb#16
+    def combine(combiner_module, coverage_a, coverage_b); end
+
+    # @return [Boolean]
+    #
+    # source://simplecov//lib/simplecov/combine.rb#22
+    def empty_coverage?(coverage_a, coverage_b); end
+
+    # source://simplecov//lib/simplecov/combine.rb#26
+    def existing_coverage(coverage_a, coverage_b); end
+  end
+end
+
+# Combine different branch coverage results on single file.
+#
+# Should be called through `SimpleCov.combine`.
+#
+# source://simplecov//lib/simplecov/combine/branches_combiner.rb#9
+module SimpleCov::Combine::BranchesCombiner
+  private
+
+  # Return merged branches or the existed brach if other is missing.
+  #
+  # Branches inside files are always same if they exist, the difference only in coverage count.
+  # Branch coverage report for any conditional case is built from hash, it's key is a condition and
+  # it's body is a hash << keys from condition and value is coverage rate >>.
+  # ex: branches =>{ [:if, 3, 8, 6, 8, 36] => {[:then, 4, 8, 6, 8, 12] => 1, [:else, 5, 8, 6, 8, 36]=>2}, other conditions...}
+  # We create copy of result and update it values depending on the combined branches coverage values.
+  #
+  # @return [Hash]
+  #
+  # source://simplecov//lib/simplecov/combine/branches_combiner.rb#23
+  def combine(coverage_a, coverage_b); end
+
+  class << self
+    # Return merged branches or the existed brach if other is missing.
+    #
+    # Branches inside files are always same if they exist, the difference only in coverage count.
+    # Branch coverage report for any conditional case is built from hash, it's key is a condition and
+    # it's body is a hash << keys from condition and value is coverage rate >>.
+    # ex: branches =>{ [:if, 3, 8, 6, 8, 36] => {[:then, 4, 8, 6, 8, 12] => 1, [:else, 5, 8, 6, 8, 36]=>2}, other conditions...}
+    # We create copy of result and update it values depending on the combined branches coverage values.
+    #
+    # @return [Hash]
+    #
+    # source://simplecov//lib/simplecov/combine/branches_combiner.rb#23
+    def combine(coverage_a, coverage_b); end
+  end
+end
+
+# Handle combining two coverage results for same file
+#
+# Should be called through `SimpleCov.combine`.
+#
+# source://simplecov//lib/simplecov/combine/files_combiner.rb#9
+module SimpleCov::Combine::FilesCombiner
+  private
+
+  # Combines the results for 2 coverages of a file.
+  #
+  # @return [Hash]
+  #
+  # source://simplecov//lib/simplecov/combine/files_combiner.rb#17
+  def combine(coverage_a, coverage_b); end
+
+  class << self
+    # Combines the results for 2 coverages of a file.
+    #
+    # @return [Hash]
+    #
+    # source://simplecov//lib/simplecov/combine/files_combiner.rb#17
+    def combine(coverage_a, coverage_b); end
+  end
+end
+
+# Combine two different lines coverage results on same file
+#
+# Should be called through `SimpleCov.combine`.
+#
+# source://simplecov//lib/simplecov/combine/lines_combiner.rb#9
+module SimpleCov::Combine::LinesCombiner
+  private
+
+  # source://simplecov//lib/simplecov/combine/lines_combiner.rb#12
+  def combine(coverage_a, coverage_b); end
+
+  # Return depends on coverage in a specific line
+  #
+  # Logic:
+  #
+  # => nil + 0 = nil
+  # => nil + nil = nil
+  # => int + int = int
+  #
+  # @param first_val [Integer || nil]
+  # @param second_val [Integer || nil]
+  # @return [Integer || nil]
+  #
+  # source://simplecov//lib/simplecov/combine/lines_combiner.rb#32
+  def merge_line_coverage(first_val, second_val); end
+
+  class << self
+    # source://simplecov//lib/simplecov/combine/lines_combiner.rb#12
+    def combine(coverage_a, coverage_b); end
+
+    # Return depends on coverage in a specific line
+    #
+    # Logic:
+    #
+    # => nil + 0 = nil
+    # => nil + nil = nil
+    # => int + int = int
+    #
+    # @param first_val [Integer || nil]
+    # @param second_val [Integer || nil]
+    # @return [Integer || nil]
+    #
+    # source://simplecov//lib/simplecov/combine/lines_combiner.rb#32
+    def merge_line_coverage(first_val, second_val); end
+  end
+end
+
+# There might be reports from different kinds of tests,
+# e.g. RSpec and Cucumber. We need to combine their results
+# into unified one. This class does that.
+# To unite the results on file basis, it leverages
+# the combine of lines and branches inside each file within given results.
+#
+# source://simplecov//lib/simplecov/combine/results_combiner.rb#10
+module SimpleCov::Combine::ResultsCombiner
+  private
+
+  # Combine process explanation
+  # => ResultCombiner: define all present files between results and start combine on file level.
+  # ==> FileCombiner: collect result of next combine levels lines and branches.
+  # ===> LinesCombiner: combine lines results.
+  # ===> BranchesCombiner: combine branches results.
+  #
+  # @return [Hash]
+  #
+  # source://simplecov//lib/simplecov/combine/results_combiner.rb#22
+  def combine(*results); end
+
+  # Combine two files coverage results
+  #
+  # @param coverage_a [Hash]
+  # @param coverage_b [Hash]
+  # @return [Hash]
+  #
+  # source://simplecov//lib/simplecov/combine/results_combiner.rb#55
+  def combine_file_coverage(coverage_a, coverage_b); end
+
+  # Manage combining results on files level
+  #
+  # @param combined_results [Hash]
+  # @param result [Hash]
+  # @return [Hash]
+  #
+  # source://simplecov//lib/simplecov/combine/results_combiner.rb#36
+  def combine_result_sets(combined_results, result); end
+
+  class << self
+    # Combine process explanation
+    # => ResultCombiner: define all present files between results and start combine on file level.
+    # ==> FileCombiner: collect result of next combine levels lines and branches.
+    # ===> LinesCombiner: combine lines results.
+    # ===> BranchesCombiner: combine branches results.
+    #
+    # @return [Hash]
+    #
+    # source://simplecov//lib/simplecov/combine/results_combiner.rb#22
+    def combine(*results); end
+
+    # Combine two files coverage results
+    #
+    # @param coverage_a [Hash]
+    # @param coverage_b [Hash]
+    # @return [Hash]
+    #
+    # source://simplecov//lib/simplecov/combine/results_combiner.rb#55
+    def combine_file_coverage(coverage_a, coverage_b); end
+
+    # Manage combining results on files level
+    #
+    # @param combined_results [Hash]
+    # @param result [Hash]
+    # @return [Hash]
+    #
+    # source://simplecov//lib/simplecov/combine/results_combiner.rb#36
+    def combine_result_sets(combined_results, result); end
+  end
+end
+
+# Helper that tries to find out what test suite is running (for SimpleCov.command_name)
+#
+# source://simplecov//lib/simplecov/command_guesser.rb#7
+module SimpleCov::CommandGuesser
+  class << self
+    # source://simplecov//lib/simplecov/command_guesser.rb#16
+    def guess; end
+
+    # Storage for the original command line call that invoked the test suite.
+    # This has got to be stored as early as possible because i.e. rake and test/unit 2
+    # have a habit of tampering with ARGV, which makes i.e. the automatic distinction
+    # between rails unit/functional/integration tests impossible without this cached
+    # item.
+    #
+    # source://simplecov//lib/simplecov/command_guesser.rb#14
+    def original_run_command; end
+
+    # Storage for the original command line call that invoked the test suite.
+    # This has got to be stored as early as possible because i.e. rake and test/unit 2
+    # have a habit of tampering with ARGV, which makes i.e. the automatic distinction
+    # between rails unit/functional/integration tests impossible without this cached
+    # item.
+    #
+    # source://simplecov//lib/simplecov/command_guesser.rb#14
+    def original_run_command=(_arg0); end
+
+    private
+
+    # source://simplecov//lib/simplecov/command_guesser.rb#31
+    def from_command_line_options; end
+
+    # source://simplecov//lib/simplecov/command_guesser.rb#46
+    def from_defined_constants; end
+
+    # source://simplecov//lib/simplecov/command_guesser.rb#22
+    def from_env; end
+  end
+end
+
+# Bundles the configuration options used for SimpleCov. All methods
+# defined here are usable from SimpleCov directly. Please check out
+# SimpleCov documentation for further info.
+#
+# source://simplecov//lib/simplecov/configuration.rb#13
+module SimpleCov::Configuration
+  # source://simplecov//lib/simplecov/configuration.rb#161
+  def adapters; end
+
+  # Add a filter to the processing chain.
+  # There are four ways to define a filter:
+  #
+  # * as a String that will then be matched against all source files' file paths,
+  #     SimpleCov.add_filter 'app/models' # will reject all your models
+  # * as a block which will be passed the source file in question and should either
+  #   return a true or false value, depending on whether the file should be removed
+  #     SimpleCov.add_filter do |src_file|
+  #       File.basename(src_file.filename) == 'environment.rb'
+  #     end # Will exclude environment.rb files from the results
+  # * as an array of strings that are matched against all sorce files' file
+  #   paths and then ignored (basically string filter multiple times)
+  #     SimpleCov.add_filter ['app/models', 'app/helpers'] # ignores both dirs
+  # * as an instance of a subclass of SimpleCov::Filter. See the documentation there
+  #   on how to define your own filter classes
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#367
+  def add_filter(filter_argument = T.unsafe(nil), &filter_proc); end
+
+  # Define a group for files. Works similar to add_filter, only that the first
+  # argument is the desired group name and files PASSING the filter end up in the group
+  # (while filters exclude when the filter is applicable).
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#376
+  def add_group(group_name, filter_argument = T.unsafe(nil), &filter_proc); end
+
+  # Gets or sets the behavior to process coverage results.
+  #
+  # By default, it will call SimpleCov.result.format!
+  #
+  # Configure with:
+  #
+  #     SimpleCov.at_exit do
+  #       puts "Coverage done"
+  #       SimpleCov.result.format!
+  #     end
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#193
+  def at_exit(&block); end
+
+  # Gets or sets the behavior to start a new forked Process.
+  #
+  # By default, it will add " (Process #{pid})" to the command_name, and start SimpleCov in quiet mode
+  #
+  # Configure with:
+  #
+  #     SimpleCov.at_fork do |pid|
+  #       SimpleCov.start do
+  #         # This needs a unique name so it won't be ovewritten
+  #         SimpleCov.command_name "#{SimpleCov.command_name} (subprocess: #{pid})"
+  #         # be quiet, the parent process will be in charge of using the regular formatter and checking coverage totals
+  #         SimpleCov.print_error_status = false
+  #         SimpleCov.formatter SimpleCov::Formatter::SimpleFormatter
+  #         SimpleCov.minimum_coverage 0
+  #         # start
+  #         SimpleCov.start
+  #       end
+  #     end
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#233
+  def at_fork(&block); end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#428
+  def branch_coverage?; end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#443
+  def branch_coverage_supported?; end
+
+  # source://simplecov//lib/simplecov/configuration.rb#424
+  def clear_coverage_criteria; end
+
+  # The name of the command (a.k.a. Test Suite) currently running. Used for result
+  # merging and caching. It first tries to make a guess based upon the command line
+  # arguments the current test suite is running on and should automatically detect
+  # unit tests, functional tests, integration tests, rpsec and cucumber and label
+  # them properly. If it fails to recognize the current command, the command name
+  # is set to the shell command that the current suite is running on.
+  #
+  # You can specify it manually with SimpleCov.command_name("test:units") - please
+  # also check out the corresponding section in README.rdoc
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#87
+  def command_name(name = T.unsafe(nil)); end
+
+  # Allows you to configure simplecov in a block instead of prepending SimpleCov to all config methods
+  # you're calling.
+  #
+  #     SimpleCov.configure do
+  #       add_filter 'foobar'
+  #     end
+  #
+  # This is equivalent to SimpleCov.add_filter 'foobar' and thus makes it easier to set a bunch of configure
+  # options at once.
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#177
+  def configure(&block); end
+
+  # source://simplecov//lib/simplecov/configuration.rb#416
+  def coverage_criteria; end
+
+  # Define which coverage criterion should be evaluated.
+  #
+  # Possible coverage criteria:
+  # * :line - coverage based on lines aka has this line been executed?
+  # * :branch - coverage based on branches aka has this branch (think conditions) been executed?
+  #
+  # If not set the default is `:line`
+  #
+  # @param criterion [Symbol]
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#393
+  def coverage_criterion(criterion = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#420
+  def coverage_criterion_enabled?(criterion); end
+
+  # The name of the output and cache directory. Defaults to 'coverage'
+  #
+  # Configure with SimpleCov.coverage_dir('cov')
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#34
+  def coverage_dir(dir = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#452
+  def coverage_for_eval_enabled?; end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#447
+  def coverage_for_eval_supported?; end
+
+  # Returns the full path to the output directory using SimpleCov.root
+  # and SimpleCov.coverage_dir, so you can adjust this by configuring those
+  # values. Will create the directory if it's missing
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#46
+  def coverage_path; end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#432
+  def coverage_start_arguments_supported?; end
+
+  # source://simplecov//lib/simplecov/configuration.rb#401
+  def enable_coverage(criterion); end
+
+  # source://simplecov//lib/simplecov/configuration.rb#456
+  def enable_coverage_for_eval; end
+
+  # gets or sets the enabled_for_subprocess configuration
+  # when true, this will inject SimpleCov code into Process.fork
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#202
+  def enable_for_subprocesses(value = T.unsafe(nil)); end
+
+  # gets the enabled_for_subprocess configuration
+  #
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#209
+  def enabled_for_subprocesses?; end
+
+  # Returns the list of configured filters. Add filters using SimpleCov.add_filter.
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#74
+  def filters; end
+
+  # Sets the attribute filters
+  #
+  # @param value the value to set the attribute filters to.
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#14
+  def filters=(_arg0); end
+
+  # Gets or sets the configured formatter.
+  #
+  # Configure with: SimpleCov.formatter(SimpleCov::Formatter::SimpleFormatter)
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#98
+  def formatter(formatter = T.unsafe(nil)); end
+
+  # Sets the attribute formatter
+  #
+  # @param value the value to set the attribute formatter to.
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#14
+  def formatter=(_arg0); end
+
+  # Gets the configured formatters.
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#117
+  def formatters; end
+
+  # Sets the configured formatters.
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#110
+  def formatters=(formatters); end
+
+  # Returns the configured groups. Add groups using SimpleCov.add_group
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#150
+  def groups; end
+
+  # Sets the attribute groups
+  #
+  # @param value the value to set the attribute groups to.
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#14
+  def groups=(_arg0); end
+
+  # Defines the maximum coverage drop at once allowed for the testsuite to pass.
+  # SimpleCov will return non-zero if the coverage decreases by more than this threshold.
+  #
+  # Default is 100% (disabled)
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#313
+  def maximum_coverage_drop(coverage_drop = T.unsafe(nil)); end
+
+  # Defines the maximum age (in seconds) of a resultset to still be included in merged results.
+  # i.e. If you run cucumber features, then later rake test, if the stored cucumber resultset is
+  # more seconds ago than specified here, it won't be taken into account when merging (and is also
+  # purged from the resultset cache)
+  #
+  # Of course, this only applies when merging is active (e.g. SimpleCov.use_merging is not false!)
+  #
+  # Default is 600 seconds (10 minutes)
+  #
+  # Configure with SimpleCov.merge_timeout(3600) # 1hr
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#279
+  def merge_timeout(seconds = T.unsafe(nil)); end
+
+  # Defines the minimum overall coverage required for the testsuite to pass.
+  # SimpleCov will return non-zero if the current coverage is below this threshold.
+  #
+  # Default is 0% (disabled)
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#290
+  def minimum_coverage(coverage = T.unsafe(nil)); end
+
+  # Defines the minimum coverage per file required for the testsuite to pass.
+  # SimpleCov will return non-zero if the current coverage of the least covered file
+  # is below this threshold.
+  #
+  # Default is 0% (disabled)
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#330
+  def minimum_coverage_by_file(coverage = T.unsafe(nil)); end
+
+  # Certain code blocks (i.e. Ruby-implementation specific code) can be excluded from
+  # the coverage metrics by wrapping it inside # :nocov: comment blocks. The nocov token
+  # can be configured to be any other string using this.
+  #
+  # Configure with SimpleCov.nocov_token('skip') or it's alias SimpleCov.skip_token('skip')
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#140
+  def nocov_token(nocov_token = T.unsafe(nil)); end
+
+  # source://simplecov//lib/simplecov/configuration.rb#407
+  def primary_coverage(criterion = T.unsafe(nil)); end
+
+  # Whether we should print non-success status codes. This can be
+  # configured with the #print_error_status= method.
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#129
+  def print_error_status; end
+
+  # Sets the attribute print_error_status
+  #
+  # @param value the value to set the attribute print_error_status to.
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#14
+  def print_error_status=(_arg0); end
+
+  # Returns the hash of available profiles
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#157
+  def profiles; end
+
+  # Returns the project name - currently assuming the last dirname in
+  # the SimpleCov.root is this.
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#251
+  def project_name(new_name = T.unsafe(nil)); end
+
+  # source://simplecov//lib/simplecov/configuration.rb#300
+  def raise_on_invalid_coverage(coverage, coverage_setting); end
+
+  # Refuses any coverage drop. That is, coverage is only allowed to increase.
+  # SimpleCov will return non-zero if the coverage decreases.
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#344
+  def refuse_coverage_drop(*criteria); end
+
+  # The root for the project. This defaults to the
+  # current working directory.
+  #
+  # Configure with SimpleCov.root('/my/project/path')
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#22
+  def root(root = T.unsafe(nil)); end
+
+  # Certain code blocks (i.e. Ruby-implementation specific code) can be excluded from
+  # the coverage metrics by wrapping it inside # :nocov: comment blocks. The nocov token
+  # can be configured to be any other string using this.
+  #
+  # Configure with SimpleCov.nocov_token('skip') or it's alias SimpleCov.skip_token('skip')
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#140
+  def skip_token(nocov_token = T.unsafe(nil)); end
+
+  # Coverage results will always include files matched by this glob, whether
+  # or not they were explicitly required. Without this, un-required files
+  # will not be present in the final report.
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#59
+  def track_files(glob); end
+
+  # Returns the glob that will be used to include files that were not
+  # explicitly required.
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#67
+  def tracked_files; end
+
+  # Defines whether to use result merging so all your test suites (test:units, test:functionals, cucumber, ...)
+  # are joined and combined into a single coverage report
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#262
+  def use_merging(use = T.unsafe(nil)); end
+
+  private
+
+  # source://simplecov//lib/simplecov/configuration.rb#483
+  def minimum_possible_coverage_exceeded(coverage_option); end
+
+  # The actual filter processor. Not meant for direct use
+  #
+  # source://simplecov//lib/simplecov/configuration.rb#490
+  def parse_filter(filter_argument = T.unsafe(nil), &filter_proc); end
+
+  # source://simplecov//lib/simplecov/configuration.rb#466
+  def raise_if_criterion_disabled(criterion); end
+
+  # source://simplecov//lib/simplecov/configuration.rb#475
+  def raise_if_criterion_unsupported(criterion); end
+end
+
+# source://simplecov//lib/simplecov/configuration.rb#381
+SimpleCov::Configuration::DEFAULT_COVERAGE_CRITERION = T.let(T.unsafe(nil), Symbol)
+
+# source://simplecov//lib/simplecov/configuration.rb#380
+SimpleCov::Configuration::SUPPORTED_COVERAGE_CRITERIA = T.let(T.unsafe(nil), Array)
+
+# Holds the individual data of a coverage result.
+#
+# This is uniform across coverage criteria as they all have:
+#
+# * total - how many things to cover there are (total relevant loc/branches)
+# * covered - how many of the coverables are hit
+# * missed - how many of the coverables are missed
+# * percent - percentage as covered/missed
+# * strength - average hits per/coverable (will not exist for one shot lines format)
+#
+# source://simplecov//lib/simplecov/coverage_statistics.rb#13
+class SimpleCov::CoverageStatistics
+  # Requires only covered, missed and strength to be initialized.
+  #
+  # Other values are computed by this class.
+  #
+  # @return [CoverageStatistics] a new instance of CoverageStatistics
+  #
+  # source://simplecov//lib/simplecov/coverage_statistics.rb#34
+  def initialize(covered:, missed:, total_strength: T.unsafe(nil)); end
+
+  # Returns the value of attribute covered.
+  #
+  # source://simplecov//lib/simplecov/coverage_statistics.rb#14
+  def covered; end
+
+  # Returns the value of attribute missed.
+  #
+  # source://simplecov//lib/simplecov/coverage_statistics.rb#14
+  def missed; end
+
+  # Returns the value of attribute percent.
+  #
+  # source://simplecov//lib/simplecov/coverage_statistics.rb#14
+  def percent; end
+
+  # Returns the value of attribute strength.
+  #
+  # source://simplecov//lib/simplecov/coverage_statistics.rb#14
+  def strength; end
+
+  # Returns the value of attribute total.
+  #
+  # source://simplecov//lib/simplecov/coverage_statistics.rb#14
+  def total; end
+
+  private
+
+  # source://simplecov//lib/simplecov/coverage_statistics.rb#44
+  def compute_percent(covered, missed, total); end
+
+  # source://simplecov//lib/simplecov/coverage_statistics.rb#50
+  def compute_strength(total_strength, total); end
+
+  class << self
+    # source://simplecov//lib/simplecov/coverage_statistics.rb#16
+    def from(coverage_statistics); end
+  end
+end
+
+# source://simplecov//lib/simplecov/exit_codes.rb#4
+module SimpleCov::ExitCodes; end
+
+# source://simplecov//lib/simplecov/exit_codes.rb#6
+SimpleCov::ExitCodes::EXCEPTION = T.let(T.unsafe(nil), Integer)
+
+# source://simplecov//lib/simplecov/exit_codes/exit_code_handling.rb#5
+module SimpleCov::ExitCodes::ExitCodeHandling
+  private
+
+  # source://simplecov//lib/simplecov/exit_codes/exit_code_handling.rb#8
+  def call(result, coverage_limits:); end
+
+  # source://simplecov//lib/simplecov/exit_codes/exit_code_handling.rb#20
+  def coverage_checks(result, coverage_limits); end
+
+  class << self
+    # source://simplecov//lib/simplecov/exit_codes/exit_code_handling.rb#8
+    def call(result, coverage_limits:); end
+
+    # source://simplecov//lib/simplecov/exit_codes/exit_code_handling.rb#20
+    def coverage_checks(result, coverage_limits); end
+  end
+end
+
+# source://simplecov//lib/simplecov/exit_codes.rb#8
+SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP = T.let(T.unsafe(nil), Integer)
+
+# source://simplecov//lib/simplecov/exit_codes.rb#7
+SimpleCov::ExitCodes::MINIMUM_COVERAGE = T.let(T.unsafe(nil), Integer)
+
+# source://simplecov//lib/simplecov/exit_codes/maximum_coverage_drop_check.rb#5
+class SimpleCov::ExitCodes::MaximumCoverageDropCheck
+  # @return [MaximumCoverageDropCheck] a new instance of MaximumCoverageDropCheck
+  #
+  # source://simplecov//lib/simplecov/exit_codes/maximum_coverage_drop_check.rb#6
+  def initialize(result, maximum_coverage_drop); end
+
+  # source://simplecov//lib/simplecov/exit_codes/maximum_coverage_drop_check.rb#28
+  def exit_code; end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/exit_codes/maximum_coverage_drop_check.rb#11
+  def failing?; end
+
+  # source://simplecov//lib/simplecov/exit_codes/maximum_coverage_drop_check.rb#17
+  def report; end
+
+  private
+
+  # source://simplecov//lib/simplecov/exit_codes/maximum_coverage_drop_check.rb#49
+  def compute_coverage_drop_data; end
+
+  # source://simplecov//lib/simplecov/exit_codes/maximum_coverage_drop_check.rb#42
+  def coverage_drop_violations; end
+
+  # source://simplecov//lib/simplecov/exit_codes/maximum_coverage_drop_check.rb#61
+  def drop_percent(criterion); end
+
+  # source://simplecov//lib/simplecov/exit_codes/maximum_coverage_drop_check.rb#73
+  def last_coverage(criterion); end
+
+  # source://simplecov//lib/simplecov/exit_codes/maximum_coverage_drop_check.rb#36
+  def last_run; end
+
+  # Returns the value of attribute maximum_coverage_drop.
+  #
+  # source://simplecov//lib/simplecov/exit_codes/maximum_coverage_drop_check.rb#34
+  def maximum_coverage_drop; end
+
+  # Returns the value of attribute result.
+  #
+  # source://simplecov//lib/simplecov/exit_codes/maximum_coverage_drop_check.rb#34
+  def result; end
+end
+
+# if anyone says "max_coverage_drop 0.000000000000000001" I appologize. Please don't.
+#
+# source://simplecov//lib/simplecov/exit_codes/maximum_coverage_drop_check.rb#60
+SimpleCov::ExitCodes::MaximumCoverageDropCheck::MAX_DROP_ACCURACY = T.let(T.unsafe(nil), Integer)
+
+# source://simplecov//lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb#5
+class SimpleCov::ExitCodes::MinimumCoverageByFileCheck
+  # @return [MinimumCoverageByFileCheck] a new instance of MinimumCoverageByFileCheck
+  #
+  # source://simplecov//lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb#6
+  def initialize(result, minimum_coverage_by_file); end
+
+  # source://simplecov//lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb#26
+  def exit_code; end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb#11
+  def failing?; end
+
+  # source://simplecov//lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb#15
+  def report; end
+
+  private
+
+  # source://simplecov//lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb#41
+  def compute_minimum_coverage_data; end
+
+  # Returns the value of attribute minimum_coverage_by_file.
+  #
+  # source://simplecov//lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb#32
+  def minimum_coverage_by_file; end
+
+  # source://simplecov//lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb#34
+  def minimum_violations; end
+
+  # Returns the value of attribute result.
+  #
+  # source://simplecov//lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb#32
+  def result; end
+end
+
+# source://simplecov//lib/simplecov/exit_codes/minimum_overall_coverage_check.rb#5
+class SimpleCov::ExitCodes::MinimumOverallCoverageCheck
+  # @return [MinimumOverallCoverageCheck] a new instance of MinimumOverallCoverageCheck
+  #
+  # source://simplecov//lib/simplecov/exit_codes/minimum_overall_coverage_check.rb#6
+  def initialize(result, minimum_coverage); end
+
+  # source://simplecov//lib/simplecov/exit_codes/minimum_overall_coverage_check.rb#26
+  def exit_code; end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/exit_codes/minimum_overall_coverage_check.rb#11
+  def failing?; end
+
+  # source://simplecov//lib/simplecov/exit_codes/minimum_overall_coverage_check.rb#15
+  def report; end
+
+  private
+
+  # source://simplecov//lib/simplecov/exit_codes/minimum_overall_coverage_check.rb#38
+  def calculate_minimum_violations; end
+
+  # Returns the value of attribute minimum_coverage.
+  #
+  # source://simplecov//lib/simplecov/exit_codes/minimum_overall_coverage_check.rb#32
+  def minimum_coverage; end
+
+  # source://simplecov//lib/simplecov/exit_codes/minimum_overall_coverage_check.rb#34
+  def minimum_violations; end
+
+  # Returns the value of attribute result.
+  #
+  # source://simplecov//lib/simplecov/exit_codes/minimum_overall_coverage_check.rb#32
+  def result; end
+end
+
+# source://simplecov//lib/simplecov/exit_codes.rb#5
+SimpleCov::ExitCodes::SUCCESS = T.let(T.unsafe(nil), Integer)
+
+# An array of SimpleCov SourceFile instances with additional collection helper
+# methods for calculating coverage across them etc.
+#
+# source://simplecov//lib/simplecov/file_list.rb#6
+class SimpleCov::FileList
+  include ::Enumerable
+  extend ::Forwardable
+
+  # @return [FileList] a new instance of FileList
+  #
+  # source://simplecov//lib/simplecov/file_list.rb#22
+  def initialize(files); end
+
+  # source://simplecov//lib/simplecov/file_list.rb#101
+  def branch_covered_percent; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def count(*args, **_arg1, &block); end
+
+  # source://simplecov//lib/simplecov/file_list.rb#26
+  def coverage_statistics; end
+
+  # source://simplecov//lib/simplecov/file_list.rb#30
+  def coverage_statistics_by_file; end
+
+  # Return total count of covered branches
+  #
+  # source://simplecov//lib/simplecov/file_list.rb#92
+  def covered_branches; end
+
+  # Returns the count of lines that have coverage
+  #
+  # source://simplecov//lib/simplecov/file_list.rb#35
+  def covered_lines; end
+
+  # Computes the coverage based upon lines covered and lines missed
+  #
+  # @return [Float]
+  #
+  # source://simplecov//lib/simplecov/file_list.rb#76
+  def covered_percent; end
+
+  # Computes the coverage based upon lines covered and lines missed for each file
+  # Returns an array with all coverage percentages
+  #
+  # source://simplecov//lib/simplecov/file_list.rb#60
+  def covered_percentages; end
+
+  # Computes the strength (hits / line) based upon lines covered and lines missed
+  #
+  # @return [Float]
+  #
+  # source://simplecov//lib/simplecov/file_list.rb#82
+  def covered_strength; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def each(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def empty?(*args, **_arg1, &block); end
+
+  # Finds the least covered file and returns that file's name
+  #
+  # source://simplecov//lib/simplecov/file_list.rb#65
+  def least_covered_file; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def length(*args, **_arg1, &block); end
+
+  # Returns the overall amount of relevant lines of code across all files in this list
+  #
+  # source://simplecov//lib/simplecov/file_list.rb#70
+  def lines_of_code; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def map(*args, **_arg1, &block); end
+
+  # Return total count of covered branches
+  #
+  # source://simplecov//lib/simplecov/file_list.rb#97
+  def missed_branches; end
+
+  # Returns the count of lines that have been missed
+  #
+  # source://simplecov//lib/simplecov/file_list.rb#40
+  def missed_lines; end
+
+  # Returns the count of lines that are not relevant for coverage
+  #
+  # source://simplecov//lib/simplecov/file_list.rb#45
+  def never_lines; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def size(*args, **_arg1, &block); end
+
+  # Returns the count of skipped lines
+  #
+  # source://simplecov//lib/simplecov/file_list.rb#52
+  def skipped_lines; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def to_a(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def to_ary(*args, **_arg1, &block); end
+
+  # Return total count of branches in all files
+  #
+  # source://simplecov//lib/simplecov/file_list.rb#87
+  def total_branches; end
+
+  private
+
+  # source://simplecov//lib/simplecov/file_list.rb#114
+  def compute_coverage_statistics; end
+
+  # source://simplecov//lib/simplecov/file_list.rb#107
+  def compute_coverage_statistics_by_file; end
+end
+
+# Base filter class. Inherit from this to create custom filters,
+# and overwrite the passes?(source_file) instance method
+#
+# # A sample class that rejects all source files.
+# class StupidFilter < SimpleCov::Filter
+#   def passes?(source_file)
+#     false
+#   end
+# end
+#
+# source://simplecov//lib/simplecov/filter.rb#15
+class SimpleCov::Filter
+  # @return [Filter] a new instance of Filter
+  #
+  # source://simplecov//lib/simplecov/filter.rb#18
+  def initialize(filter_argument); end
+
+  # Returns the value of attribute filter_argument.
+  #
+  # source://simplecov//lib/simplecov/filter.rb#16
+  def filter_argument; end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/filter.rb#22
+  def matches?(_source_file); end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/filter.rb#26
+  def passes?(source_file); end
+
+  class << self
+    # source://simplecov//lib/simplecov/filter.rb#31
+    def build_filter(filter_argument); end
+
+    # source://simplecov//lib/simplecov/filter.rb#37
+    def class_for_argument(filter_argument); end
+  end
+end
+
+# TODO: Documentation on how to build your own formatters
+#
+# source://simplecov//lib/simplecov/formatter/multi_formatter.rb#4
+module SimpleCov::Formatter; end
+
+# source://simplecov//lib/simplecov/formatter/multi_formatter.rb#5
+class SimpleCov::Formatter::MultiFormatter
+  class << self
+    # source://simplecov//lib/simplecov/formatter/multi_formatter.rb#26
+    def [](*args); end
+
+    # source://simplecov//lib/simplecov/formatter/multi_formatter.rb#17
+    def new(formatters = T.unsafe(nil)); end
+  end
+end
+
+# source://simplecov//lib/simplecov/formatter/multi_formatter.rb#6
+module SimpleCov::Formatter::MultiFormatter::InstanceMethods
+  # source://simplecov//lib/simplecov/formatter/multi_formatter.rb#7
+  def format(result); end
+end
+
+# A ridiculously simple formatter for SimpleCov results.
+#
+# source://simplecov//lib/simplecov/formatter/simple_formatter.rb#8
+class SimpleCov::Formatter::SimpleFormatter
+  # Takes a SimpleCov::Result and generates a string out of it
+  #
+  # source://simplecov//lib/simplecov/formatter/simple_formatter.rb#10
+  def format(result); end
+end
+
+# source://simplecov//lib/simplecov/last_run.rb#6
+module SimpleCov::LastRun
+  class << self
+    # source://simplecov//lib/simplecov/last_run.rb#8
+    def last_run_path; end
+
+    # source://simplecov//lib/simplecov/last_run.rb#12
+    def read; end
+
+    # source://simplecov//lib/simplecov/last_run.rb#21
+    def write(json); end
+  end
+end
+
+# Classifies whether lines are relevant for code coverage analysis.
+# Comments & whitespace lines, and :nocov: token blocks, are considered not relevant.
+#
+# source://simplecov//lib/simplecov/lines_classifier.rb#7
+class SimpleCov::LinesClassifier
+  # source://simplecov//lib/simplecov/lines_classifier.rb#33
+  def classify(lines); end
+
+  class << self
+    # source://simplecov//lib/simplecov/lines_classifier.rb#15
+    def no_cov_line; end
+
+    # @return [Boolean]
+    #
+    # source://simplecov//lib/simplecov/lines_classifier.rb#19
+    def no_cov_line?(line); end
+
+    # @return [Boolean]
+    #
+    # source://simplecov//lib/simplecov/lines_classifier.rb#26
+    def whitespace_line?(line); end
+  end
+end
+
+# source://simplecov//lib/simplecov/lines_classifier.rb#12
+SimpleCov::LinesClassifier::COMMENT_LINE = T.let(T.unsafe(nil), Regexp)
+
+# source://simplecov//lib/simplecov/lines_classifier.rb#9
+SimpleCov::LinesClassifier::NOT_RELEVANT = T.let(T.unsafe(nil), T.untyped)
+
+# source://simplecov//lib/simplecov/lines_classifier.rb#8
+SimpleCov::LinesClassifier::RELEVANT = T.let(T.unsafe(nil), Integer)
+
+# source://simplecov//lib/simplecov/lines_classifier.rb#11
+SimpleCov::LinesClassifier::WHITESPACE_LINE = T.let(T.unsafe(nil), Regexp)
+
+# source://simplecov//lib/simplecov/lines_classifier.rb#13
+SimpleCov::LinesClassifier::WHITESPACE_OR_COMMENT_LINE = T.let(T.unsafe(nil), Regexp)
+
+# Profiles are SimpleCov configuration procs that can be easily
+# loaded using SimpleCov.start :rails and defined using
+#   SimpleCov.profiles.define :foo do
+#     # SimpleCov configuration here, same as in  SimpleCov.configure
+#   end
+#
+# source://simplecov//lib/simplecov/profiles.rb#17
+class SimpleCov::Profiles < ::Hash
+  # Define a SimpleCov profile:
+  #   SimpleCov.profiles.define 'rails' do
+  #     # Same as SimpleCov.configure do .. here
+  #   end
+  #
+  # source://simplecov//lib/simplecov/profiles.rb#18
+  def define(name, &blk); end
+
+  # Applies the profile of given name on SimpleCov.configure
+  #
+  # source://simplecov//lib/simplecov/profiles.rb#28
+  def load(name); end
+end
+
+# source://simplecov//lib/simplecov/filter.rb#63
+class SimpleCov::RegexFilter < ::SimpleCov::Filter
+  # Returns true when the given source file's filename matches the
+  # regex configured when initializing this Filter with RegexFilter.new(/someregex/)
+  #
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/filter.rb#64
+  def matches?(source_file); end
+end
+
+# A simplecov code coverage result, initialized from the Hash Ruby's built-in coverage
+# library generates (Coverage.result).
+#
+# source://simplecov//lib/simplecov/result.rb#11
+class SimpleCov::Result
+  extend ::Forwardable
+
+  # Initialize a new SimpleCov::Result from given Coverage.result (a Hash of filenames each containing an array of
+  # coverage data)
+  #
+  # @return [Result] a new instance of Result
+  #
+  # source://simplecov//lib/simplecov/result.rb#28
+  def initialize(original_result, command_name: T.unsafe(nil), created_at: T.unsafe(nil)); end
+
+  # The command name that launched this result.
+  # Delegated to SimpleCov.command_name if not set manually
+  #
+  # source://simplecov//lib/simplecov/result.rb#61
+  def command_name; end
+
+  # Explicitly set the command name that was used for this coverage result. Defaults to SimpleCov.command_name
+  #
+  # source://simplecov//lib/simplecov/result.rb#21
+  def command_name=(_arg0); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def coverage_statistics(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def coverage_statistics_by_file(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def covered_branches(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def covered_lines(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def covered_percent(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def covered_percentages(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def covered_strength(*args, **_arg1, &block); end
+
+  # Defines when this result has been created. Defaults to Time.now
+  #
+  # source://simplecov//lib/simplecov/result.rb#55
+  def created_at; end
+
+  # Explicitly set the Time this result has been created
+  #
+  # source://simplecov//lib/simplecov/result.rb#19
+  def created_at=(_arg0); end
+
+  # Returns all filenames for source files contained in this result
+  #
+  # source://simplecov//lib/simplecov/result.rb#40
+  def filenames; end
+
+  # Returns all files that are applicable to this result (sans filters!) as instances of SimpleCov::SourceFile. Aliased as :source_files
+  #
+  # source://simplecov//lib/simplecov/result.rb#16
+  def files; end
+
+  # Applies the configured SimpleCov.formatter on this result
+  #
+  # source://simplecov//lib/simplecov/result.rb#50
+  def format!; end
+
+  # Returns a Hash of groups for this result. Define groups using SimpleCov.add_group 'Models', 'app/models'
+  #
+  # source://simplecov//lib/simplecov/result.rb#45
+  def groups; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def least_covered_file(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def missed_branches(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def missed_lines(*args, **_arg1, &block); end
+
+  # Returns the original Coverage.result used for this instance of SimpleCov::Result
+  #
+  # source://simplecov//lib/simplecov/result.rb#14
+  def original_result; end
+
+  # Returns all files that are applicable to this result (sans filters!) as instances of SimpleCov::SourceFile. Aliased as :source_files
+  #
+  # source://simplecov//lib/simplecov/result.rb#16
+  def source_files; end
+
+  # Returns a hash representation of this Result that can be used for marshalling it into JSON
+  #
+  # source://simplecov//lib/simplecov/result.rb#66
+  def to_hash; end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def total_branches(*args, **_arg1, &block); end
+
+  # source://forwardable/1.3.2/forwardable.rb#229
+  def total_lines(*args, **_arg1, &block); end
+
+  private
+
+  # source://simplecov//lib/simplecov/result.rb#84
+  def coverage; end
+
+  # Applies all configured SimpleCov filters on this result's source files
+  #
+  # source://simplecov//lib/simplecov/result.rb#90
+  def filter!; end
+
+  class << self
+    # Loads a SimpleCov::Result#to_hash dump
+    #
+    # source://simplecov//lib/simplecov/result.rb#76
+    def from_hash(hash); end
+  end
+end
+
+# Responsible for adapting the format of the coverage result whether it's default or with statistics
+#
+# source://simplecov//lib/simplecov/result_adapter.rb#7
+class SimpleCov::ResultAdapter
+  # @return [ResultAdapter] a new instance of ResultAdapter
+  #
+  # source://simplecov//lib/simplecov/result_adapter.rb#10
+  def initialize(result); end
+
+  # source://simplecov//lib/simplecov/result_adapter.rb#18
+  def adapt; end
+
+  # Returns the value of attribute result.
+  #
+  # source://simplecov//lib/simplecov/result_adapter.rb#8
+  def result; end
+
+  class << self
+    # source://simplecov//lib/simplecov/result_adapter.rb#14
+    def call(*args); end
+  end
+end
+
+# Singleton that is responsible for caching, loading and merging
+# SimpleCov::Results into a single result for coverage analysis based
+# upon multiple test suites.
+#
+# source://simplecov//lib/simplecov/result_merger.rb#11
+module SimpleCov::ResultMerger
+  class << self
+    # source://simplecov//lib/simplecov/result_merger.rb#187
+    def adapt_pre_simplecov_0_18_result(result); end
+
+    # We changed the format of the raw result data in simplecov, as people are likely
+    # to have "old" resultsets lying around (but not too old so that they're still
+    # considered we can adapt them).
+    # See https://github.com/simplecov-ruby/simplecov/pull/824#issuecomment-576049747
+    #
+    # source://simplecov//lib/simplecov/result_merger.rb#172
+    def adapt_result(result); end
+
+    # source://simplecov//lib/simplecov/result_merger.rb#93
+    def create_result(command_names, coverage); end
+
+    # source://simplecov//lib/simplecov/result_merger.rb#22
+    def merge_and_store(*file_paths, ignore_timeout: T.unsafe(nil)); end
+
+    # source://simplecov//lib/simplecov/result_merger.rb#100
+    def merge_coverage(*results); end
+
+    # source://simplecov//lib/simplecov/result_merger.rb#28
+    def merge_results(*file_paths, ignore_timeout: T.unsafe(nil)); end
+
+    # source://simplecov//lib/simplecov/result_merger.rb#74
+    def merge_valid_results(results, ignore_timeout: T.unsafe(nil)); end
+
+    # Gets all SimpleCov::Results stored in resultset, merges them and produces a new
+    # SimpleCov::Result with merged coverage data and the command_name
+    # for the result consisting of a join on all source result's names
+    #
+    # source://simplecov//lib/simplecov/result_merger.rb#117
+    def merged_result; end
+
+    # source://simplecov//lib/simplecov/result_merger.rb#51
+    def parse_file(path); end
+
+    # source://simplecov//lib/simplecov/result_merger.rb#65
+    def parse_json(content); end
+
+    # pre 0.18 coverage data pointed from file directly to an array of line coverage
+    #
+    # @return [Boolean]
+    #
+    # source://simplecov//lib/simplecov/result_merger.rb#181
+    def pre_simplecov_0_18_result?(result); end
+
+    # source://simplecov//lib/simplecov/result_merger.rb#56
+    def read_file(path); end
+
+    # source://simplecov//lib/simplecov/result_merger.rb#126
+    def read_resultset; end
+
+    # The path to the .resultset.json cache file
+    #
+    # source://simplecov//lib/simplecov/result_merger.rb#14
+    def resultset_path; end
+
+    # source://simplecov//lib/simplecov/result_merger.rb#18
+    def resultset_writelock; end
+
+    # Saves the given SimpleCov::Result in the resultset cache
+    #
+    # source://simplecov//lib/simplecov/result_merger.rb#136
+    def store_result(result); end
+
+    # Ensure only one process is reading or writing the resultset at any
+    # given time
+    #
+    # source://simplecov//lib/simplecov/result_merger.rb#153
+    def synchronize_resultset; end
+
+    # source://simplecov//lib/simplecov/result_merger.rb#89
+    def time_since_result_creation(data); end
+
+    # source://simplecov//lib/simplecov/result_merger.rb#46
+    def valid_results(file_path, ignore_timeout: T.unsafe(nil)); end
+
+    # @return [Boolean]
+    #
+    # source://simplecov//lib/simplecov/result_merger.rb#85
+    def within_merge_timeout?(data); end
+  end
+end
+
+# Responsible for producing file coverage metrics.
+#
+# source://simplecov//lib/simplecov/simulate_coverage.rb#7
+module SimpleCov::SimulateCoverage
+  private
+
+  # Simulate normal file coverage report on
+  # ruby 2.5 and return similar hash with lines and branches keys
+  #
+  # Happens when a file wasn't required but still tracked.
+  #
+  # @return [Hash]
+  #
+  # source://simplecov//lib/simplecov/simulate_coverage.rb#18
+  def call(absolute_path); end
+
+  class << self
+    # Simulate normal file coverage report on
+    # ruby 2.5 and return similar hash with lines and branches keys
+    #
+    # Happens when a file wasn't required but still tracked.
+    #
+    # @return [Hash]
+    #
+    # source://simplecov//lib/simplecov/simulate_coverage.rb#18
+    def call(absolute_path); end
+  end
+end
+
+# Representation of a source file including it's coverage data, source code,
+# source lines and featuring helpers to interpret that data.
+#
+# source://simplecov//lib/simplecov/source_file/line.rb#4
+class SimpleCov::SourceFile
+  # @return [SourceFile] a new instance of SourceFile
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#14
+  def initialize(filename, coverage_data); end
+
+  # Return all the branches inside current source file
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#98
+  def branches; end
+
+  # source://simplecov//lib/simplecov/source_file.rb#106
+  def branches_coverage_percent; end
+
+  # source://simplecov//lib/simplecov/source_file.rb#142
+  def branches_for_line(line_number); end
+
+  # Return hash with key of line number and branch coverage count as value
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#118
+  def branches_report; end
+
+  # The array of coverage data received from the Coverage.result
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#12
+  def coverage_data; end
+
+  # source://simplecov//lib/simplecov/source_file.rb#32
+  def coverage_statistics; end
+
+  # Select the covered branches
+  # Here we user tree schema because some conditions like case may have additional
+  # else that is not in declared inside the code but given by default by coverage report
+  #
+  # @return [Array]
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#129
+  def covered_branches; end
+
+  # Returns all covered lines as SimpleCov::SourceFile::Line
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#48
+  def covered_lines; end
+
+  # The coverage for this file in percent. 0 if the file has no coverage lines
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#80
+  def covered_percent; end
+
+  # source://simplecov//lib/simplecov/source_file.rb#84
+  def covered_strength; end
+
+  # The full path to this source file (e.g. /User/colszowka/projects/simplecov/lib/simplecov/source_file.rb)
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#10
+  def filename; end
+
+  # Access SimpleCov::SourceFile::Line source lines by line number
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#75
+  def line(number); end
+
+  # Check if any branches missing on given line number
+  #
+  # @param line_number [Integer]
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#153
+  def line_with_missed_branch?(line_number); end
+
+  # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line,
+  # and thus including coverage data. Aliased as :source_lines
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#42
+  def lines; end
+
+  # Returns the number of relevant lines (covered + missed)
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#70
+  def lines_of_code; end
+
+  # Select the missed branches with coverage equal to zero
+  #
+  # @return [Array]
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#138
+  def missed_branches; end
+
+  # Returns all lines that should have been, but were not covered
+  # as instances of SimpleCov::SourceFile::Line
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#54
+  def missed_lines; end
+
+  # Returns all lines that are not relevant for coverage as
+  # SimpleCov::SourceFile::Line instances
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#60
+  def never_lines; end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#102
+  def no_branches?; end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#88
+  def no_lines?; end
+
+  # The path to this source file relative to the projects directory
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#20
+  def project_filename; end
+
+  # source://simplecov//lib/simplecov/source_file.rb#92
+  def relevant_lines; end
+
+  # Returns all lines that were skipped as SimpleCov::SourceFile::Line instances
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#65
+  def skipped_lines; end
+
+  # The source code for this file. Aliased as :source
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#25
+  def source; end
+
+  # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line,
+  # and thus including coverage data. Aliased as :source_lines
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#42
+  def source_lines; end
+
+  # The source code for this file. Aliased as :source
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#25
+  def src; end
+
+  # Return the relevant branches to source file
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#112
+  def total_branches; end
+
+  private
+
+  # source://simplecov//lib/simplecov/source_file.rb#346
+  def branch_coverage_statistics; end
+
+  # source://simplecov//lib/simplecov/source_file.rb#324
+  def build_branch(branch_data, hit_count, condition_start_line); end
+
+  # Call recursive method that transform our static hash to array of objects
+  #
+  # @return [Array]
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#273
+  def build_branches; end
+
+  # source://simplecov//lib/simplecov/source_file.rb#310
+  def build_branches_from(condition, branches); end
+
+  # Build full branches report
+  # Root branches represent the wrapper of all condition state that
+  # have inside the branches
+  #
+  # @return [Hash]
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#262
+  def build_branches_report; end
+
+  # source://simplecov//lib/simplecov/source_file.rb#229
+  def build_lines; end
+
+  # source://simplecov//lib/simplecov/source_file.rb#164
+  def build_no_cov_chunks; end
+
+  # Warning to identify condition from Issue #56
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#251
+  def coverage_exceeding_source_warn; end
+
+  # source://simplecov//lib/simplecov/source_file.rb#214
+  def ensure_remove_undefs(file_lines); end
+
+  # source://simplecov//lib/simplecov/source_file.rb#336
+  def line_coverage_statistics; end
+
+  # source://simplecov//lib/simplecov/source_file.rb#246
+  def lines_strength; end
+
+  # source://simplecov//lib/simplecov/source_file.rb#178
+  def load_source; end
+
+  # no_cov_chunks is zero indexed to work directly with the array holding the lines
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#160
+  def no_cov_chunks; end
+
+  # source://simplecov//lib/simplecov/source_file.rb#282
+  def process_skipped_branches(branches); end
+
+  # source://simplecov//lib/simplecov/source_file.rb#237
+  def process_skipped_lines(lines); end
+
+  # source://simplecov//lib/simplecov/source_file.rb#198
+  def read_lines(file, lines, current_line); end
+
+  # Since we are dumping to and loading from JSON, and we have arrays as keys those
+  # don't make their way back to us intact e.g. just as a string
+  #
+  # We should probably do something different here, but as it stands these are
+  # our data structures that we write so eval isn't _too_ bad.
+  #
+  # See #801
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#300
+  def restore_ruby_data_structure(structure); end
+
+  # source://simplecov//lib/simplecov/source_file.rb#206
+  def set_encoding_based_on_magic_comment(file, line); end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/source_file.rb#194
+  def shebang?(line); end
+end
+
+# Representing single branch that has been detected in coverage report.
+# Give us support methods that handle needed calculations.
+#
+# source://simplecov//lib/simplecov/source_file/branch.rb#8
+class SimpleCov::SourceFile::Branch
+  # @return [Branch] a new instance of Branch
+  #
+  # source://simplecov//lib/simplecov/source_file/branch.rb#12
+  def initialize(start_line:, end_line:, coverage:, inline:, type:); end
+
+  # Returns the value of attribute coverage.
+  #
+  # source://simplecov//lib/simplecov/source_file/branch.rb#9
+  def coverage; end
+
+  # Return true if there is relevant count defined > 0
+  #
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/source_file/branch.rb#31
+  def covered?; end
+
+  # Returns the value of attribute end_line.
+  #
+  # source://simplecov//lib/simplecov/source_file/branch.rb#9
+  def end_line; end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/source_file/branch.rb#22
+  def inline?; end
+
+  # Check if branche missed or not
+  #
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/source_file/branch.rb#40
+  def missed?; end
+
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/source_file/branch.rb#70
+  def overlaps_with?(line_range); end
+
+  # Return array with coverage count and badge
+  #
+  # @return [Array]
+  #
+  # source://simplecov//lib/simplecov/source_file/branch.rb#79
+  def report; end
+
+  # The line on which we want to report the coverage
+  #
+  # Usually we choose the line above the start of the branch (so that it shows up
+  # at if/else) because that
+  # * highlights the condition
+  # * makes it distinguishable if the first line of the branch is an inline branch
+  #   (see the nested_branches fixture)
+  #
+  # source://simplecov//lib/simplecov/source_file/branch.rb#52
+  def report_line; end
+
+  # Flags the branch as skipped
+  #
+  # source://simplecov//lib/simplecov/source_file/branch.rb#61
+  def skipped!; end
+
+  # Returns true if the branch was marked skipped by virtue of nocov comments.
+  #
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/source_file/branch.rb#66
+  def skipped?; end
+
+  # Returns the value of attribute start_line.
+  #
+  # source://simplecov//lib/simplecov/source_file/branch.rb#9
+  def start_line; end
+
+  # Returns the value of attribute type.
+  #
+  # source://simplecov//lib/simplecov/source_file/branch.rb#9
+  def type; end
+end
+
+# Representation of a single line in a source file including
+# this specific line's source code, line_number and code coverage,
+# with the coverage being either nil (coverage not applicable, e.g. comment
+# line), 0 (line not covered) or >1 (the amount of times the line was
+# executed)
+#
+# source://simplecov//lib/simplecov/source_file/line.rb#10
+class SimpleCov::SourceFile::Line
+  # @raise [ArgumentError]
+  # @return [Line] a new instance of Line
+  #
+  # source://simplecov//lib/simplecov/source_file/line.rb#25
+  def initialize(src, line_number, coverage); end
+
+  # The coverage data for this line: either nil (never), 0 (missed) or >=1 (times covered)
+  #
+  # source://simplecov//lib/simplecov/source_file/line.rb#16
+  def coverage; end
+
+  # Returns true if this is a line that has been covered
+  #
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/source_file/line.rb#42
+  def covered?; end
+
+  # The line number in the source file. Aliased as :line, :number
+  #
+  # source://simplecov//lib/simplecov/source_file/line.rb#14
+  def line; end
+
+  # The line number in the source file. Aliased as :line, :number
+  #
+  # source://simplecov//lib/simplecov/source_file/line.rb#14
+  def line_number; end
+
+  # Returns true if this is a line that should have been covered, but was not
+  #
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/source_file/line.rb#37
+  def missed?; end
+
+  # Returns true if this line is not relevant for coverage
+  #
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/source_file/line.rb#47
+  def never?; end
+
+  # The line number in the source file. Aliased as :line, :number
+  #
+  # source://simplecov//lib/simplecov/source_file/line.rb#14
+  def number; end
+
+  # Whether this line was skipped
+  #
+  # source://simplecov//lib/simplecov/source_file/line.rb#18
+  def skipped; end
+
+  # Flags this line as skipped
+  #
+  # source://simplecov//lib/simplecov/source_file/line.rb#52
+  def skipped!; end
+
+  # Returns true if this line was skipped, false otherwise. Lines are skipped if they are wrapped with
+  # # :nocov: comment lines.
+  #
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/source_file/line.rb#58
+  def skipped?; end
+
+  # The source code for this line. Aliased as :source
+  # Lets grab some fancy aliases, shall we?
+  #
+  # source://simplecov//lib/simplecov/source_file/line.rb#12
+  def source; end
+
+  # The source code for this line. Aliased as :source
+  #
+  # source://simplecov//lib/simplecov/source_file/line.rb#12
+  def src; end
+
+  # The status of this line - either covered, missed, skipped or never. Useful i.e. for direct use
+  # as a css class in report generation
+  #
+  # source://simplecov//lib/simplecov/source_file/line.rb#64
+  def status; end
+end
+
+# source://simplecov//lib/simplecov/source_file.rb#205
+SimpleCov::SourceFile::RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://simplecov//lib/simplecov/source_file.rb#193
+SimpleCov::SourceFile::SHEBANG_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# source://simplecov//lib/simplecov/filter.rb#55
+class SimpleCov::StringFilter < ::SimpleCov::Filter
+  # Returns true when the given source file's filename matches the
+  # string configured when initializing this Filter with StringFilter.new('somestring')
+  #
+  # @return [Boolean]
+  #
+  # source://simplecov//lib/simplecov/filter.rb#56
+  def matches?(source_file); end
+end
+
+# Select the files that related to working scope directory of SimpleCov
+#
+# source://simplecov//lib/simplecov/useless_results_remover.rb#7
+module SimpleCov::UselessResultsRemover
+  class << self
+    # source://simplecov//lib/simplecov/useless_results_remover.rb#8
+    def call(coverage_result); end
+
+    # source://simplecov//lib/simplecov/useless_results_remover.rb#14
+    def root_regx; end
+  end
+end
+
+# source://simplecov//lib/simplecov/version.rb#4
+SimpleCov::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov_json_formatter@0.1.4.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov_json_formatter@0.1.4.rbi
deleted file mode 100644
index 502be3d4f9fda..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/simplecov_json_formatter@0.1.4.rbi
+++ /dev/null
@@ -1,115 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `simplecov_json_formatter` gem.
-# Please instead update this file by running `bin/tapioca gem simplecov_json_formatter`.
-
-module SimpleCov
-  extend ::SimpleCov::Configuration
-
-  class << self
-    def at_exit_behavior; end
-    def clear_result; end
-    def collate(result_filenames, profile = T.unsafe(nil), ignore_timeout: T.unsafe(nil), &block); end
-    def exit_and_report_previous_error(exit_status); end
-    def exit_status_from_exception; end
-    def external_at_exit; end
-    def external_at_exit=(_arg0); end
-    def external_at_exit?; end
-    def filtered(files); end
-    def final_result_process?; end
-    def grouped(files); end
-    def load_adapter(name); end
-    def load_profile(name); end
-    def pid; end
-    def pid=(_arg0); end
-    def previous_error?(error_exit_status); end
-    def process_result(result); end
-    def process_results_and_report_error; end
-    def ready_to_process_results?; end
-    def result; end
-    def result?; end
-    def result_exit_status(result); end
-    def round_coverage(coverage); end
-    def run_exit_tasks!; end
-    def running; end
-    def running=(_arg0); end
-    def start(profile = T.unsafe(nil), &block); end
-    def wait_for_other_processes; end
-    def write_last_run(result); end
-
-    private
-
-    def adapt_coverage_result; end
-    def add_not_loaded_files(result); end
-    def initial_setup(profile, &block); end
-    def lookup_corresponding_ruby_coverage_name(criterion); end
-    def make_parallel_tests_available; end
-    def probably_running_parallel_tests?; end
-    def process_coverage_result; end
-    def remove_useless_results; end
-    def result_with_not_loaded_files; end
-    def start_coverage_measurement; end
-    def start_coverage_with_criteria; end
-  end
-end
-
-module SimpleCov::Formatter
-  class << self
-    def from_env(env); end
-  end
-end
-
-class SimpleCov::Formatter::JSONFormatter
-  def format(result); end
-
-  private
-
-  def export_formatted_result(result_hash); end
-  def format_result(result); end
-  def output_message(result); end
-end
-
-SimpleCov::VERSION = T.let(T.unsafe(nil), String)
-module SimpleCovJSONFormatter; end
-
-class SimpleCovJSONFormatter::ResultExporter
-  def initialize(result_hash); end
-
-  def export; end
-
-  private
-
-  def export_path; end
-  def json_result; end
-end
-
-SimpleCovJSONFormatter::ResultExporter::FILENAME = T.let(T.unsafe(nil), String)
-
-class SimpleCovJSONFormatter::ResultHashFormatter
-  def initialize(result); end
-
-  def format; end
-
-  private
-
-  def format_files; end
-  def format_groups; end
-  def format_source_file(source_file); end
-  def formatted_result; end
-end
-
-class SimpleCovJSONFormatter::SourceFileFormatter
-  def initialize(source_file); end
-
-  def format; end
-
-  private
-
-  def branch_coverage; end
-  def branches; end
-  def line_coverage; end
-  def lines; end
-  def parse_branch(branch); end
-  def parse_line(line); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/sorbet-runtime-stub@0.2.0.rbi b/Library/Homebrew/sorbet/rbi/gems/sorbet-runtime-stub@0.2.0.rbi
deleted file mode 100644
index 6f0613cfb3606..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/sorbet-runtime-stub@0.2.0.rbi
+++ /dev/null
@@ -1,8 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `sorbet-runtime-stub` gem.
-# Please instead update this file by running `bin/tapioca gem sorbet-runtime-stub`.
-
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/Library/Homebrew/sorbet/rbi/gems/spoom@1.1.11.rbi b/Library/Homebrew/sorbet/rbi/gems/spoom@1.1.11.rbi
deleted file mode 100644
index fa9aebf8fd995..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/spoom@1.1.11.rbi
+++ /dev/null
@@ -1,1445 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `spoom` gem.
-# Please instead update this file by running `bin/tapioca gem spoom`.
-
-module Spoom
-  class << self
-    sig { params(cmd: ::String, arg: ::String, path: ::String, capture_err: T::Boolean).returns(::Spoom::ExecResult) }
-    def exec(cmd, *arg, path: T.unsafe(nil), capture_err: T.unsafe(nil)); end
-  end
-end
-
-module Spoom::Cli; end
-
-class Spoom::Cli::Bump < ::Thor
-  include ::Spoom::Colorize
-  include ::Spoom::Cli::Helper
-
-  sig { params(directory: ::String).void }
-  def bump(directory = T.unsafe(nil)); end
-
-  def config_files(path: T.unsafe(nil)); end
-  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
-  def print_changes(files, command:, from: T.unsafe(nil), to: T.unsafe(nil), dry: T.unsafe(nil), path: T.unsafe(nil)); end
-  def undo_changes(files, from_strictness); end
-end
-
-class Spoom::Cli::Config < ::Thor
-  include ::Spoom::Colorize
-  include ::Spoom::Cli::Helper
-
-  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
-  def show; end
-end
-
-class Spoom::Cli::Coverage < ::Thor
-  include ::Spoom::Colorize
-  include ::Spoom::Cli::Helper
-
-  def bundle_install(path, sha); end
-  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
-  def message_no_data(file); end
-  def open(file = T.unsafe(nil)); end
-  def parse_time(string, option); end
-  def report; end
-  def snapshot; end
-  def timeline; end
-end
-
-Spoom::Cli::Coverage::DATA_DIR = T.let(T.unsafe(nil), String)
-
-module Spoom::Cli::Helper
-  include ::Spoom::Colorize
-
-  requires_ancestor { Thor }
-
-  sig { params(string: ::String).returns(::String) }
-  def blue(string); end
-
-  sig { params(exit_code: ::Integer, block: T.nilable(T.proc.void)).void }
-  def check_sorbet_segfault(exit_code, &block); end
-
-  sig { returns(T::Boolean) }
-  def color?; end
-
-  sig { params(string: ::String, color: ::Spoom::Color).returns(::String) }
-  def colorize(string, *color); end
-
-  sig { params(string: ::String).returns(::String) }
-  def cyan(string); end
-
-  sig { returns(::String) }
-  def exec_path; end
-
-  sig { params(string: ::String).returns(::String) }
-  def gray(string); end
-
-  sig { params(string: ::String).returns(::String) }
-  def green(string); end
-
-  sig { params(string: ::String).returns(::String) }
-  def highlight(string); end
-
-  sig { void }
-  def in_sorbet_project!; end
-
-  sig { returns(T::Boolean) }
-  def in_sorbet_project?; end
-
-  sig { params(string: ::String).returns(::String) }
-  def red(string); end
-
-  sig { params(message: ::String).void }
-  def say(message); end
-
-  sig { params(message: ::String, status: T.nilable(::String), nl: T::Boolean).void }
-  def say_error(message, status: T.unsafe(nil), nl: T.unsafe(nil)); end
-
-  sig { returns(::Spoom::Sorbet::Config) }
-  def sorbet_config; end
-
-  sig { returns(::String) }
-  def sorbet_config_file; end
-
-  sig { params(string: ::String).returns(::String) }
-  def yellow(string); end
-end
-
-class Spoom::Cli::LSP < ::Thor
-  include ::Spoom::Colorize
-  include ::Spoom::Cli::Helper
-
-  def defs(file, line, col); end
-  def find(query); end
-  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
-  def hover(file, line, col); end
-  def list; end
-  def lsp_client; end
-  def refs(file, line, col); end
-  def run(&block); end
-  def show; end
-  def sigs(file, line, col); end
-  def symbol_printer; end
-  def symbols(file); end
-  def to_uri(path); end
-  def types(file, line, col); end
-end
-
-class Spoom::Cli::Main < ::Thor
-  include ::Spoom::Colorize
-  include ::Spoom::Cli::Helper
-
-  def __print_version; end
-  def bump(*args); end
-  def config(*args); end
-  def coverage(*args); end
-  def files; end
-  def lsp(*args); end
-  def tc(*args); end
-
-  class << self
-    def exit_on_failure?; end
-  end
-end
-
-class Spoom::Cli::Run < ::Thor
-  include ::Spoom::Colorize
-  include ::Spoom::Cli::Helper
-
-  def colorize_message(message); end
-  def format_error(error, format); end
-  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
-  def tc(*arg); end
-end
-
-Spoom::Cli::Run::DEFAULT_FORMAT = T.let(T.unsafe(nil), String)
-Spoom::Cli::Run::SORT_CODE = T.let(T.unsafe(nil), String)
-Spoom::Cli::Run::SORT_ENUM = T.let(T.unsafe(nil), Array)
-Spoom::Cli::Run::SORT_LOC = T.let(T.unsafe(nil), String)
-
-class Spoom::Color < ::T::Enum
-  enums do
-    CLEAR = new
-    BOLD = new
-    BLACK = new
-    RED = new
-    GREEN = new
-    YELLOW = new
-    BLUE = new
-    MAGENTA = new
-    CYAN = new
-    WHITE = new
-    LIGHT_BLACK = new
-    LIGHT_RED = new
-    LIGHT_GREEN = new
-    LIGHT_YELLOW = new
-    LIGHT_BLUE = new
-    LIGHT_MAGENTA = new
-    LIGHT_CYAN = new
-    LIGHT_WHITE = new
-  end
-
-  sig { returns(::String) }
-  def ansi_code; end
-end
-
-module Spoom::Colorize
-  sig { params(string: ::String, color: ::Spoom::Color).returns(::String) }
-  def set_color(string, *color); end
-end
-
-module Spoom::Coverage
-  class << self
-    sig do
-      params(
-        snapshots: T::Array[::Spoom::Coverage::Snapshot],
-        palette: ::Spoom::Coverage::D3::ColorPalette,
-        path: ::String
-      ).returns(::Spoom::Coverage::Report)
-    end
-    def report(snapshots, palette:, path: T.unsafe(nil)); end
-
-    sig { params(path: ::String).returns(::Spoom::FileTree) }
-    def sigils_tree(path: T.unsafe(nil)); end
-
-    sig do
-      params(
-        path: ::String,
-        rbi: T::Boolean,
-        sorbet_bin: T.nilable(::String)
-      ).returns(::Spoom::Coverage::Snapshot)
-    end
-    def snapshot(path: T.unsafe(nil), rbi: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end
-
-    sig { params(path: ::String).returns(::Spoom::Sorbet::Config) }
-    def sorbet_config(path: T.unsafe(nil)); end
-  end
-end
-
-module Spoom::Coverage::Cards; end
-
-class Spoom::Coverage::Cards::Card < ::Spoom::Coverage::Template
-  sig { params(template: ::String, title: T.nilable(::String), body: T.nilable(::String)).void }
-  def initialize(template: T.unsafe(nil), title: T.unsafe(nil), body: T.unsafe(nil)); end
-
-  def body; end
-
-  sig { returns(T.nilable(::String)) }
-  def title; end
-end
-
-Spoom::Coverage::Cards::Card::TEMPLATE = T.let(T.unsafe(nil), String)
-
-class Spoom::Coverage::Cards::Erb < ::Spoom::Coverage::Cards::Card
-  abstract!
-
-  sig { void }
-  def initialize; end
-
-  sig { abstract.returns(::String) }
-  def erb; end
-
-  sig { override.returns(::String) }
-  def html; end
-end
-
-class Spoom::Coverage::Cards::Map < ::Spoom::Coverage::Cards::Card
-  sig { params(sigils_tree: ::Spoom::FileTree, title: ::String).void }
-  def initialize(sigils_tree:, title: T.unsafe(nil)); end
-end
-
-class Spoom::Coverage::Cards::Snapshot < ::Spoom::Coverage::Cards::Card
-  sig { params(snapshot: ::Spoom::Coverage::Snapshot, title: ::String).void }
-  def initialize(snapshot:, title: T.unsafe(nil)); end
-
-  sig { returns(::Spoom::Coverage::D3::Pie::Calls) }
-  def pie_calls; end
-
-  sig { returns(::Spoom::Coverage::D3::Pie::Sigils) }
-  def pie_sigils; end
-
-  sig { returns(::Spoom::Coverage::D3::Pie::Sigs) }
-  def pie_sigs; end
-
-  sig { returns(::Spoom::Coverage::Snapshot) }
-  def snapshot; end
-end
-
-Spoom::Coverage::Cards::Snapshot::TEMPLATE = T.let(T.unsafe(nil), String)
-
-class Spoom::Coverage::Cards::SorbetIntro < ::Spoom::Coverage::Cards::Erb
-  sig { params(sorbet_intro_commit: T.nilable(::String), sorbet_intro_date: T.nilable(::Time)).void }
-  def initialize(sorbet_intro_commit: T.unsafe(nil), sorbet_intro_date: T.unsafe(nil)); end
-
-  sig { override.returns(::String) }
-  def erb; end
-end
-
-class Spoom::Coverage::Cards::Timeline < ::Spoom::Coverage::Cards::Card
-  sig { params(title: ::String, timeline: ::Spoom::Coverage::D3::Timeline).void }
-  def initialize(title:, timeline:); end
-end
-
-class Spoom::Coverage::Cards::Timeline::Calls < ::Spoom::Coverage::Cards::Timeline
-  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
-  def initialize(snapshots:, title: T.unsafe(nil)); end
-end
-
-class Spoom::Coverage::Cards::Timeline::RBIs < ::Spoom::Coverage::Cards::Timeline
-  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
-  def initialize(snapshots:, title: T.unsafe(nil)); end
-end
-
-class Spoom::Coverage::Cards::Timeline::Runtimes < ::Spoom::Coverage::Cards::Timeline
-  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
-  def initialize(snapshots:, title: T.unsafe(nil)); end
-end
-
-class Spoom::Coverage::Cards::Timeline::Sigils < ::Spoom::Coverage::Cards::Timeline
-  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
-  def initialize(snapshots:, title: T.unsafe(nil)); end
-end
-
-class Spoom::Coverage::Cards::Timeline::Sigs < ::Spoom::Coverage::Cards::Timeline
-  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
-  def initialize(snapshots:, title: T.unsafe(nil)); end
-end
-
-class Spoom::Coverage::Cards::Timeline::Versions < ::Spoom::Coverage::Cards::Timeline
-  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
-  def initialize(snapshots:, title: T.unsafe(nil)); end
-end
-
-module Spoom::Coverage::D3
-  class << self
-    sig { params(palette: ::Spoom::Coverage::D3::ColorPalette).returns(::String) }
-    def header_script(palette); end
-
-    sig { returns(::String) }
-    def header_style; end
-  end
-end
-
-class Spoom::Coverage::D3::Base
-  abstract!
-
-  sig { params(id: ::String, data: T.untyped).void }
-  def initialize(id, data); end
-
-  sig { returns(::String) }
-  def html; end
-
-  sig { returns(::String) }
-  def id; end
-
-  sig { abstract.returns(::String) }
-  def script; end
-
-  sig { returns(::String) }
-  def tooltip; end
-
-  class << self
-    sig { returns(::String) }
-    def header_script; end
-
-    sig { returns(::String) }
-    def header_style; end
-  end
-end
-
-Spoom::Coverage::D3::COLOR_FALSE = T.let(T.unsafe(nil), String)
-Spoom::Coverage::D3::COLOR_IGNORE = T.let(T.unsafe(nil), String)
-Spoom::Coverage::D3::COLOR_STRICT = T.let(T.unsafe(nil), String)
-Spoom::Coverage::D3::COLOR_STRONG = T.let(T.unsafe(nil), String)
-Spoom::Coverage::D3::COLOR_TRUE = T.let(T.unsafe(nil), String)
-
-class Spoom::Coverage::D3::CircleMap < ::Spoom::Coverage::D3::Base
-  sig { override.returns(::String) }
-  def script; end
-
-  class << self
-    sig { returns(::String) }
-    def header_script; end
-
-    sig { returns(::String) }
-    def header_style; end
-  end
-end
-
-class Spoom::Coverage::D3::CircleMap::Sigils < ::Spoom::Coverage::D3::CircleMap
-  sig { params(id: ::String, sigils_tree: ::Spoom::FileTree).void }
-  def initialize(id, sigils_tree); end
-
-  sig { params(node: ::Spoom::FileTree::Node).returns(::Float) }
-  def tree_node_score(node); end
-
-  sig { params(node: ::Spoom::FileTree::Node).returns(T.nilable(::String)) }
-  def tree_node_strictness(node); end
-
-  sig { params(node: ::Spoom::FileTree::Node).returns(T::Hash[::Symbol, T.untyped]) }
-  def tree_node_to_json(node); end
-end
-
-class Spoom::Coverage::D3::ColorPalette < ::T::Struct
-  prop :false, ::String
-  prop :ignore, ::String
-  prop :strict, ::String
-  prop :strong, ::String
-  prop :true, ::String
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-class Spoom::Coverage::D3::Pie < ::Spoom::Coverage::D3::Base
-  abstract!
-
-  sig { params(id: ::String, title: ::String, data: T.untyped).void }
-  def initialize(id, title, data); end
-
-  sig { override.returns(::String) }
-  def script; end
-
-  class << self
-    sig { returns(::String) }
-    def header_script; end
-
-    sig { returns(::String) }
-    def header_style; end
-  end
-end
-
-class Spoom::Coverage::D3::Pie::Calls < ::Spoom::Coverage::D3::Pie
-  sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void }
-  def initialize(id, title, snapshot); end
-
-  sig { override.returns(::String) }
-  def tooltip; end
-end
-
-class Spoom::Coverage::D3::Pie::Sigils < ::Spoom::Coverage::D3::Pie
-  sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void }
-  def initialize(id, title, snapshot); end
-
-  sig { override.returns(::String) }
-  def tooltip; end
-end
-
-class Spoom::Coverage::D3::Pie::Sigs < ::Spoom::Coverage::D3::Pie
-  sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void }
-  def initialize(id, title, snapshot); end
-
-  sig { override.returns(::String) }
-  def tooltip; end
-end
-
-class Spoom::Coverage::D3::Timeline < ::Spoom::Coverage::D3::Base
-  abstract!
-
-  sig { params(id: ::String, data: T.untyped, keys: T::Array[::String]).void }
-  def initialize(id, data, keys); end
-
-  sig { params(y: ::String, color: ::String, curve: ::String).returns(::String) }
-  def area(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
-
-  sig { params(y: ::String, color: ::String, curve: ::String).returns(::String) }
-  def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
-
-  sig { abstract.returns(::String) }
-  def plot; end
-
-  sig { params(y: ::String).returns(::String) }
-  def points(y:); end
-
-  sig { override.returns(::String) }
-  def script; end
-
-  sig { returns(::String) }
-  def x_scale; end
-
-  sig { returns(::String) }
-  def x_ticks; end
-
-  sig { params(min: ::String, max: ::String, ticks: ::String).returns(::String) }
-  def y_scale(min:, max:, ticks:); end
-
-  sig { params(ticks: ::String, format: ::String, padding: ::Integer).returns(::String) }
-  def y_ticks(ticks:, format:, padding:); end
-
-  class << self
-    sig { returns(::String) }
-    def header_script; end
-
-    sig { returns(::String) }
-    def header_style; end
-  end
-end
-
-class Spoom::Coverage::D3::Timeline::Calls < ::Spoom::Coverage::D3::Timeline::Stacked
-  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
-  def initialize(id, snapshots); end
-
-  sig { override.returns(::String) }
-  def tooltip; end
-end
-
-class Spoom::Coverage::D3::Timeline::RBIs < ::Spoom::Coverage::D3::Timeline::Stacked
-  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
-  def initialize(id, snapshots); end
-
-  sig { override.params(y: ::String, color: ::String, curve: ::String).returns(::String) }
-  def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
-
-  sig { override.returns(::String) }
-  def plot; end
-
-  sig { override.returns(::String) }
-  def script; end
-
-  sig { override.returns(::String) }
-  def tooltip; end
-end
-
-class Spoom::Coverage::D3::Timeline::Runtimes < ::Spoom::Coverage::D3::Timeline
-  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
-  def initialize(id, snapshots); end
-
-  sig { override.returns(::String) }
-  def plot; end
-
-  sig { override.returns(::String) }
-  def tooltip; end
-end
-
-class Spoom::Coverage::D3::Timeline::Sigils < ::Spoom::Coverage::D3::Timeline::Stacked
-  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
-  def initialize(id, snapshots); end
-
-  sig { override.returns(::String) }
-  def tooltip; end
-end
-
-class Spoom::Coverage::D3::Timeline::Sigs < ::Spoom::Coverage::D3::Timeline::Stacked
-  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
-  def initialize(id, snapshots); end
-
-  sig { override.returns(::String) }
-  def tooltip; end
-end
-
-class Spoom::Coverage::D3::Timeline::Stacked < ::Spoom::Coverage::D3::Timeline
-  abstract!
-
-  def initialize(*args, &blk); end
-
-  sig { override.params(y: ::String, color: ::String, curve: ::String).returns(::String) }
-  def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
-
-  sig { override.returns(::String) }
-  def plot; end
-
-  sig { override.returns(::String) }
-  def script; end
-end
-
-class Spoom::Coverage::D3::Timeline::Versions < ::Spoom::Coverage::D3::Timeline
-  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
-  def initialize(id, snapshots); end
-
-  sig { override.returns(::String) }
-  def plot; end
-
-  sig { override.returns(::String) }
-  def tooltip; end
-end
-
-class Spoom::Coverage::Page < ::Spoom::Coverage::Template
-  abstract!
-
-  sig { params(title: ::String, palette: ::Spoom::Coverage::D3::ColorPalette, template: ::String).void }
-  def initialize(title:, palette:, template: T.unsafe(nil)); end
-
-  sig { returns(::String) }
-  def body_html; end
-
-  sig { abstract.returns(T::Array[::Spoom::Coverage::Cards::Card]) }
-  def cards; end
-
-  sig { returns(::String) }
-  def footer_html; end
-
-  sig { returns(::String) }
-  def header_html; end
-
-  sig { returns(::String) }
-  def header_script; end
-
-  sig { returns(::String) }
-  def header_style; end
-
-  sig { returns(::Spoom::Coverage::D3::ColorPalette) }
-  def palette; end
-
-  sig { returns(::String) }
-  def title; end
-end
-
-Spoom::Coverage::Page::TEMPLATE = T.let(T.unsafe(nil), String)
-
-class Spoom::Coverage::Report < ::Spoom::Coverage::Page
-  sig do
-    params(
-      project_name: ::String,
-      palette: ::Spoom::Coverage::D3::ColorPalette,
-      snapshots: T::Array[::Spoom::Coverage::Snapshot],
-      sigils_tree: ::Spoom::FileTree,
-      sorbet_intro_commit: T.nilable(::String),
-      sorbet_intro_date: T.nilable(::Time)
-    ).void
-  end
-  def initialize(project_name:, palette:, snapshots:, sigils_tree:, sorbet_intro_commit: T.unsafe(nil), sorbet_intro_date: T.unsafe(nil)); end
-
-  sig { override.returns(T::Array[::Spoom::Coverage::Cards::Card]) }
-  def cards; end
-
-  sig { override.returns(::String) }
-  def header_html; end
-
-  sig { returns(::String) }
-  def project_name; end
-
-  sig { returns(::Spoom::FileTree) }
-  def sigils_tree; end
-
-  sig { returns(T::Array[::Spoom::Coverage::Snapshot]) }
-  def snapshots; end
-
-  sig { returns(T.nilable(::String)) }
-  def sorbet_intro_commit; end
-
-  sig { returns(T.nilable(::Time)) }
-  def sorbet_intro_date; end
-end
-
-class Spoom::Coverage::Snapshot < ::T::Struct
-  prop :calls_typed, ::Integer, default: T.unsafe(nil)
-  prop :calls_untyped, ::Integer, default: T.unsafe(nil)
-  prop :classes, ::Integer, default: T.unsafe(nil)
-  prop :commit_sha, T.nilable(::String), default: T.unsafe(nil)
-  prop :commit_timestamp, T.nilable(::Integer), default: T.unsafe(nil)
-  prop :duration, ::Integer, default: T.unsafe(nil)
-  prop :files, ::Integer, default: T.unsafe(nil)
-  prop :methods_with_sig, ::Integer, default: T.unsafe(nil)
-  prop :methods_without_sig, ::Integer, default: T.unsafe(nil)
-  prop :modules, ::Integer, default: T.unsafe(nil)
-  prop :rbi_files, ::Integer, default: T.unsafe(nil)
-  prop :sigils, T::Hash[::String, ::Integer], default: T.unsafe(nil)
-  prop :singleton_classes, ::Integer, default: T.unsafe(nil)
-  prop :timestamp, ::Integer, default: T.unsafe(nil)
-  prop :version_runtime, T.nilable(::String), default: T.unsafe(nil)
-  prop :version_static, T.nilable(::String), default: T.unsafe(nil)
-
-  sig { params(out: T.any(::IO, ::StringIO), colors: T::Boolean, indent_level: ::Integer).void }
-  def print(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end
-
-  sig { params(arg: T.untyped).returns(::String) }
-  def to_json(*arg); end
-
-  class << self
-    sig { params(json: ::String).returns(::Spoom::Coverage::Snapshot) }
-    def from_json(json); end
-
-    sig { params(obj: T::Hash[::String, T.untyped]).returns(::Spoom::Coverage::Snapshot) }
-    def from_obj(obj); end
-
-    def inherited(s); end
-  end
-end
-
-Spoom::Coverage::Snapshot::STRICTNESSES = T.let(T.unsafe(nil), Array)
-
-class Spoom::Coverage::SnapshotPrinter < ::Spoom::Printer
-  sig { params(snapshot: ::Spoom::Coverage::Snapshot).void }
-  def print_snapshot(snapshot); end
-
-  private
-
-  sig { params(value: T.nilable(::Integer), total: T.nilable(::Integer)).returns(::String) }
-  def percent(value, total); end
-
-  sig { params(hash: T::Hash[::String, ::Integer], total: ::Integer).void }
-  def print_map(hash, total); end
-end
-
-class Spoom::Coverage::Template
-  abstract!
-
-  sig { params(template: ::String).void }
-  def initialize(template:); end
-
-  sig { returns(::String) }
-  def erb; end
-
-  sig { returns(::Binding) }
-  def get_binding; end
-
-  sig { returns(::String) }
-  def html; end
-end
-
-class Spoom::Error < ::StandardError; end
-
-class Spoom::ExecResult < ::T::Struct
-  const :err, ::String
-  const :exit_code, ::Integer
-  const :out, ::String
-  const :status, T::Boolean
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-class Spoom::FileTree
-  sig { params(paths: T::Enumerable[::String], strip_prefix: T.nilable(::String)).void }
-  def initialize(paths = T.unsafe(nil), strip_prefix: T.unsafe(nil)); end
-
-  sig { params(path: ::String).returns(::Spoom::FileTree::Node) }
-  def add_path(path); end
-
-  sig { params(paths: T::Enumerable[::String]).void }
-  def add_paths(paths); end
-
-  sig { returns(T::Array[::Spoom::FileTree::Node]) }
-  def nodes; end
-
-  sig { returns(T::Array[::String]) }
-  def paths; end
-
-  sig do
-    params(
-      out: T.any(::IO, ::StringIO),
-      show_strictness: T::Boolean,
-      colors: T::Boolean,
-      indent_level: ::Integer
-    ).void
-  end
-  def print(out: T.unsafe(nil), show_strictness: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end
-
-  sig { returns(T::Array[::Spoom::FileTree::Node]) }
-  def roots; end
-
-  sig { returns(T.nilable(::String)) }
-  def strip_prefix; end
-
-  private
-
-  sig do
-    params(
-      node: ::Spoom::FileTree::Node,
-      collected_nodes: T::Array[::Spoom::FileTree::Node]
-    ).returns(T::Array[::Spoom::FileTree::Node])
-  end
-  def collect_nodes(node, collected_nodes = T.unsafe(nil)); end
-end
-
-class Spoom::FileTree::Node < ::T::Struct
-  const :children, T::Hash[::String, ::Spoom::FileTree::Node], default: T.unsafe(nil)
-  const :name, ::String
-  const :parent, T.nilable(::Spoom::FileTree::Node)
-
-  sig { returns(::String) }
-  def path; end
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-class Spoom::FileTree::TreePrinter < ::Spoom::Printer
-  sig do
-    params(
-      tree: ::Spoom::FileTree,
-      out: T.any(::IO, ::StringIO),
-      show_strictness: T::Boolean,
-      colors: T::Boolean,
-      indent_level: ::Integer
-    ).void
-  end
-  def initialize(tree:, out: T.unsafe(nil), show_strictness: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end
-
-  sig { params(node: ::Spoom::FileTree::Node).void }
-  def print_node(node); end
-
-  sig { params(nodes: T::Array[::Spoom::FileTree::Node]).void }
-  def print_nodes(nodes); end
-
-  sig { void }
-  def print_tree; end
-
-  sig { returns(::Spoom::FileTree) }
-  def tree; end
-
-  private
-
-  sig { params(node: ::Spoom::FileTree::Node).returns(T.nilable(::String)) }
-  def node_strictness(node); end
-
-  sig { params(strictness: T.nilable(::String)).returns(::Spoom::Color) }
-  def strictness_color(strictness); end
-end
-
-module Spoom::Git
-  class << self
-    sig { params(arg: ::String, path: ::String).returns(::Spoom::ExecResult) }
-    def checkout(*arg, path: T.unsafe(nil)); end
-
-    sig { params(sha: ::String, path: ::String).returns(T.nilable(::Time)) }
-    def commit_time(sha, path: T.unsafe(nil)); end
-
-    sig { params(sha: ::String, path: ::String).returns(T.nilable(::Integer)) }
-    def commit_timestamp(sha, path: T.unsafe(nil)); end
-
-    sig { params(path: ::String).returns(T.nilable(::String)) }
-    def current_branch(path: T.unsafe(nil)); end
-
-    sig { params(arg: ::String, path: ::String).returns(::Spoom::ExecResult) }
-    def diff(*arg, path: T.unsafe(nil)); end
-
-    sig { params(timestamp: ::String).returns(::Time) }
-    def epoch_to_time(timestamp); end
-
-    sig { params(command: ::String, arg: ::String, path: ::String).returns(::Spoom::ExecResult) }
-    def exec(command, *arg, path: T.unsafe(nil)); end
-
-    sig { params(path: ::String).returns(T.nilable(::String)) }
-    def last_commit(path: T.unsafe(nil)); end
-
-    sig { params(arg: ::String, path: ::String).returns(::Spoom::ExecResult) }
-    def log(*arg, path: T.unsafe(nil)); end
-
-    sig { params(arg: ::String, path: ::String).returns(::Spoom::ExecResult) }
-    def rev_parse(*arg, path: T.unsafe(nil)); end
-
-    sig { params(arg: ::String, path: ::String).returns(::Spoom::ExecResult) }
-    def show(*arg, path: T.unsafe(nil)); end
-
-    sig { params(path: ::String).returns(T.nilable(::String)) }
-    def sorbet_intro_commit(path: T.unsafe(nil)); end
-
-    sig { params(path: ::String).returns(T.nilable(::String)) }
-    def sorbet_removal_commit(path: T.unsafe(nil)); end
-
-    sig { params(path: ::String).returns(T::Boolean) }
-    def workdir_clean?(path: T.unsafe(nil)); end
-  end
-end
-
-module Spoom::LSP; end
-
-class Spoom::LSP::Client
-  sig { params(sorbet_bin: ::String, sorbet_args: ::String, path: ::String).void }
-  def initialize(sorbet_bin, *sorbet_args, path: T.unsafe(nil)); end
-
-  sig { void }
-  def close; end
-
-  sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::Location]) }
-  def definitions(uri, line, column); end
-
-  sig { params(uri: ::String).returns(T::Array[::Spoom::LSP::DocumentSymbol]) }
-  def document_symbols(uri); end
-
-  sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T.nilable(::Spoom::LSP::Hover)) }
-  def hover(uri, line, column); end
-
-  sig { returns(::Integer) }
-  def next_id; end
-
-  sig { params(workspace_path: ::String).void }
-  def open(workspace_path); end
-
-  sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
-  def read; end
-
-  sig { returns(T.nilable(::String)) }
-  def read_raw; end
-
-  sig do
-    params(
-      uri: ::String,
-      line: ::Integer,
-      column: ::Integer,
-      include_decl: T::Boolean
-    ).returns(T::Array[::Spoom::LSP::Location])
-  end
-  def references(uri, line, column, include_decl = T.unsafe(nil)); end
-
-  sig { params(message: ::Spoom::LSP::Message).returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
-  def send(message); end
-
-  sig { params(json_string: ::String).void }
-  def send_raw(json_string); end
-
-  sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::SignatureHelp]) }
-  def signatures(uri, line, column); end
-
-  sig { params(query: ::String).returns(T::Array[::Spoom::LSP::DocumentSymbol]) }
-  def symbols(query); end
-
-  sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::Location]) }
-  def type_definitions(uri, line, column); end
-end
-
-class Spoom::LSP::Diagnostic < ::T::Struct
-  include ::Spoom::LSP::PrintableSymbol
-
-  const :code, ::Integer
-  const :informations, ::Object
-  const :message, ::String
-  const :range, ::Spoom::LSP::Range
-
-  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
-  def accept_printer(printer); end
-
-  sig { returns(::String) }
-  def to_s; end
-
-  class << self
-    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Diagnostic) }
-    def from_json(json); end
-
-    def inherited(s); end
-  end
-end
-
-class Spoom::LSP::DocumentSymbol < ::T::Struct
-  include ::Spoom::LSP::PrintableSymbol
-
-  const :children, T::Array[::Spoom::LSP::DocumentSymbol]
-  const :detail, T.nilable(::String)
-  const :kind, ::Integer
-  const :location, T.nilable(::Spoom::LSP::Location)
-  const :name, ::String
-  const :range, T.nilable(::Spoom::LSP::Range)
-
-  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
-  def accept_printer(printer); end
-
-  sig { returns(::String) }
-  def kind_string; end
-
-  sig { returns(::String) }
-  def to_s; end
-
-  class << self
-    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::DocumentSymbol) }
-    def from_json(json); end
-
-    def inherited(s); end
-  end
-end
-
-Spoom::LSP::DocumentSymbol::SYMBOL_KINDS = T.let(T.unsafe(nil), Hash)
-class Spoom::LSP::Error < ::StandardError; end
-class Spoom::LSP::Error::AlreadyOpen < ::Spoom::LSP::Error; end
-class Spoom::LSP::Error::BadHeaders < ::Spoom::LSP::Error; end
-
-class Spoom::LSP::Error::Diagnostics < ::Spoom::LSP::Error
-  sig { params(uri: ::String, diagnostics: T::Array[::Spoom::LSP::Diagnostic]).void }
-  def initialize(uri, diagnostics); end
-
-  sig { returns(T::Array[::Spoom::LSP::Diagnostic]) }
-  def diagnostics; end
-
-  sig { returns(::String) }
-  def uri; end
-
-  class << self
-    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Error::Diagnostics) }
-    def from_json(json); end
-  end
-end
-
-class Spoom::LSP::Hover < ::T::Struct
-  include ::Spoom::LSP::PrintableSymbol
-
-  const :contents, ::String
-  const :range, T.nilable(T::Range[T.untyped])
-
-  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
-  def accept_printer(printer); end
-
-  sig { returns(::String) }
-  def to_s; end
-
-  class << self
-    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Hover) }
-    def from_json(json); end
-
-    def inherited(s); end
-  end
-end
-
-class Spoom::LSP::Location < ::T::Struct
-  include ::Spoom::LSP::PrintableSymbol
-
-  const :range, ::Spoom::LSP::Range
-  const :uri, ::String
-
-  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
-  def accept_printer(printer); end
-
-  sig { returns(::String) }
-  def to_s; end
-
-  class << self
-    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Location) }
-    def from_json(json); end
-
-    def inherited(s); end
-  end
-end
-
-class Spoom::LSP::Message
-  sig { void }
-  def initialize; end
-
-  sig { returns(T::Hash[T.untyped, T.untyped]) }
-  def as_json; end
-
-  sig { returns(::String) }
-  def jsonrpc; end
-
-  sig { params(args: T.untyped).returns(::String) }
-  def to_json(*args); end
-end
-
-class Spoom::LSP::Notification < ::Spoom::LSP::Message
-  sig { params(method: ::String, params: T::Hash[T.untyped, T.untyped]).void }
-  def initialize(method, params); end
-
-  sig { returns(::String) }
-  def method; end
-
-  sig { returns(T::Hash[T.untyped, T.untyped]) }
-  def params; end
-end
-
-class Spoom::LSP::Position < ::T::Struct
-  include ::Spoom::LSP::PrintableSymbol
-
-  const :char, ::Integer
-  const :line, ::Integer
-
-  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
-  def accept_printer(printer); end
-
-  sig { returns(::String) }
-  def to_s; end
-
-  class << self
-    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Position) }
-    def from_json(json); end
-
-    def inherited(s); end
-  end
-end
-
-module Spoom::LSP::PrintableSymbol
-  interface!
-
-  sig { abstract.params(printer: ::Spoom::LSP::SymbolPrinter).void }
-  def accept_printer(printer); end
-end
-
-class Spoom::LSP::Range < ::T::Struct
-  include ::Spoom::LSP::PrintableSymbol
-
-  const :end, ::Spoom::LSP::Position
-  const :start, ::Spoom::LSP::Position
-
-  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
-  def accept_printer(printer); end
-
-  sig { returns(::String) }
-  def to_s; end
-
-  class << self
-    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Range) }
-    def from_json(json); end
-
-    def inherited(s); end
-  end
-end
-
-class Spoom::LSP::Request < ::Spoom::LSP::Message
-  sig { params(id: ::Integer, method: ::String, params: T::Hash[T.untyped, T.untyped]).void }
-  def initialize(id, method, params); end
-
-  sig { returns(::Integer) }
-  def id; end
-
-  sig { returns(::String) }
-  def method; end
-
-  sig { returns(T::Hash[T.untyped, T.untyped]) }
-  def params; end
-end
-
-class Spoom::LSP::ResponseError < ::Spoom::LSP::Error
-  sig { params(code: ::Integer, message: ::String, data: T::Hash[T.untyped, T.untyped]).void }
-  def initialize(code, message, data); end
-
-  sig { returns(::Integer) }
-  def code; end
-
-  sig { returns(T::Hash[T.untyped, T.untyped]) }
-  def data; end
-
-  sig { returns(::String) }
-  def message; end
-
-  class << self
-    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::ResponseError) }
-    def from_json(json); end
-  end
-end
-
-class Spoom::LSP::SignatureHelp < ::T::Struct
-  include ::Spoom::LSP::PrintableSymbol
-
-  const :doc, ::Object
-  const :label, T.nilable(::String)
-  const :params, T::Array[T.untyped]
-
-  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
-  def accept_printer(printer); end
-
-  sig { returns(::String) }
-  def to_s; end
-
-  class << self
-    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::SignatureHelp) }
-    def from_json(json); end
-
-    def inherited(s); end
-  end
-end
-
-class Spoom::LSP::SymbolPrinter < ::Spoom::Printer
-  sig do
-    params(
-      out: T.any(::IO, ::StringIO),
-      colors: T::Boolean,
-      indent_level: ::Integer,
-      prefix: T.nilable(::String)
-    ).void
-  end
-  def initialize(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil), prefix: T.unsafe(nil)); end
-
-  sig { params(uri: ::String).returns(::String) }
-  def clean_uri(uri); end
-
-  sig { returns(T.nilable(::String)) }
-  def prefix; end
-
-  def prefix=(_arg0); end
-
-  sig { params(objects: T::Array[::Spoom::LSP::PrintableSymbol]).void }
-  def print_list(objects); end
-
-  sig { params(object: T.nilable(::Spoom::LSP::PrintableSymbol)).void }
-  def print_object(object); end
-
-  sig { params(objects: T::Array[::Spoom::LSP::PrintableSymbol]).void }
-  def print_objects(objects); end
-
-  sig { returns(T::Set[::Integer]) }
-  def seen; end
-
-  def seen=(_arg0); end
-end
-
-class Spoom::Printer
-  include ::Spoom::Colorize
-
-  abstract!
-
-  sig { params(out: T.any(::IO, ::StringIO), colors: T::Boolean, indent_level: ::Integer).void }
-  def initialize(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end
-
-  sig { params(string: ::String, color: ::Spoom::Color).returns(::String) }
-  def colorize(string, *color); end
-
-  sig { void }
-  def dedent; end
-
-  sig { void }
-  def indent; end
-
-  sig { returns(T.any(::IO, ::StringIO)) }
-  def out; end
-
-  def out=(_arg0); end
-
-  sig { params(string: T.nilable(::String)).void }
-  def print(string); end
-
-  sig { params(string: T.nilable(::String), color: ::Spoom::Color).void }
-  def print_colored(string, *color); end
-
-  sig { params(string: T.nilable(::String)).void }
-  def printl(string); end
-
-  sig { void }
-  def printn; end
-
-  sig { void }
-  def printt; end
-end
-
-Spoom::SPOOM_PATH = T.let(T.unsafe(nil), String)
-
-module Spoom::Sorbet
-  class << self
-    sig do
-      params(
-        arg: ::String,
-        path: ::String,
-        capture_err: T::Boolean,
-        sorbet_bin: T.nilable(::String)
-      ).returns(::Spoom::ExecResult)
-    end
-    def srb(*arg, path: T.unsafe(nil), capture_err: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end
-
-    sig { params(config: ::Spoom::Sorbet::Config, path: ::String).returns(T::Array[::String]) }
-    def srb_files(config, path: T.unsafe(nil)); end
-
-    sig do
-      params(
-        arg: ::String,
-        path: ::String,
-        capture_err: T::Boolean,
-        sorbet_bin: T.nilable(::String)
-      ).returns(T.nilable(T::Hash[::String, ::Integer]))
-    end
-    def srb_metrics(*arg, path: T.unsafe(nil), capture_err: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end
-
-    sig do
-      params(
-        arg: ::String,
-        path: ::String,
-        capture_err: T::Boolean,
-        sorbet_bin: T.nilable(::String)
-      ).returns(::Spoom::ExecResult)
-    end
-    def srb_tc(*arg, path: T.unsafe(nil), capture_err: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end
-
-    sig do
-      params(
-        arg: ::String,
-        path: ::String,
-        capture_err: T::Boolean,
-        sorbet_bin: T.nilable(::String)
-      ).returns(T.nilable(::String))
-    end
-    def srb_version(*arg, path: T.unsafe(nil), capture_err: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end
-
-    sig { params(gem: ::String, path: ::String).returns(T.nilable(::String)) }
-    def version_from_gemfile_lock(gem: T.unsafe(nil), path: T.unsafe(nil)); end
-  end
-end
-
-Spoom::Sorbet::BIN_PATH = T.let(T.unsafe(nil), String)
-Spoom::Sorbet::CONFIG_PATH = T.let(T.unsafe(nil), String)
-
-class Spoom::Sorbet::Config
-  sig { void }
-  def initialize; end
-
-  def allowed_extensions; end
-
-  sig { returns(::Spoom::Sorbet::Config) }
-  def copy; end
-
-  def ignore; end
-
-  sig { returns(T::Boolean) }
-  def no_stdlib; end
-
-  def no_stdlib=(_arg0); end
-
-  sig { returns(::String) }
-  def options_string; end
-
-  sig { returns(T::Array[::String]) }
-  def paths; end
-
-  class << self
-    sig { params(sorbet_config_path: ::String).returns(::Spoom::Sorbet::Config) }
-    def parse_file(sorbet_config_path); end
-
-    sig { params(sorbet_config: ::String).returns(::Spoom::Sorbet::Config) }
-    def parse_string(sorbet_config); end
-
-    private
-
-    sig { params(line: ::String).returns(::String) }
-    def parse_option(line); end
-  end
-end
-
-module Spoom::Sorbet::Errors
-  class << self
-    sig { params(errors: T::Array[::Spoom::Sorbet::Errors::Error]).returns(T::Array[::Spoom::Sorbet::Errors::Error]) }
-    def sort_errors_by_code(errors); end
-  end
-end
-
-Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE = T.let(T.unsafe(nil), String)
-
-class Spoom::Sorbet::Errors::Error
-  include ::Comparable
-
-  sig do
-    params(
-      file: T.nilable(::String),
-      line: T.nilable(::Integer),
-      message: T.nilable(::String),
-      code: T.nilable(::Integer),
-      more: T::Array[::String]
-    ).void
-  end
-  def initialize(file, line, message, code, more = T.unsafe(nil)); end
-
-  sig { params(other: T.untyped).returns(::Integer) }
-  def <=>(other); end
-
-  def code; end
-
-  sig { returns(T.nilable(::String)) }
-  def file; end
-
-  sig { returns(T.nilable(::Integer)) }
-  def line; end
-
-  def message; end
-
-  sig { returns(T::Array[::String]) }
-  def more; end
-
-  sig { returns(::String) }
-  def to_s; end
-end
-
-class Spoom::Sorbet::Errors::Parser
-  sig { params(error_url_base: ::String).void }
-  def initialize(error_url_base: T.unsafe(nil)); end
-
-  sig { params(output: ::String).returns(T::Array[::Spoom::Sorbet::Errors::Error]) }
-  def parse(output); end
-
-  private
-
-  sig { params(line: ::String).void }
-  def append_error(line); end
-
-  sig { void }
-  def close_error; end
-
-  sig { params(error_url_base: ::String).returns(::Regexp) }
-  def error_line_match_regexp(error_url_base); end
-
-  sig { params(line: ::String).returns(T.nilable(::Spoom::Sorbet::Errors::Error)) }
-  def match_error_line(line); end
-
-  sig { params(error: ::Spoom::Sorbet::Errors::Error).void }
-  def open_error(error); end
-
-  class << self
-    sig { params(output: ::String, error_url_base: ::String).returns(T::Array[::Spoom::Sorbet::Errors::Error]) }
-    def parse_string(output, error_url_base: T.unsafe(nil)); end
-  end
-end
-
-Spoom::Sorbet::Errors::Parser::HEADER = T.let(T.unsafe(nil), Array)
-Spoom::Sorbet::GEM_PATH = T.let(T.unsafe(nil), String)
-
-module Spoom::Sorbet::MetricsParser
-  class << self
-    sig { params(path: ::String, prefix: ::String).returns(T::Hash[::String, ::Integer]) }
-    def parse_file(path, prefix = T.unsafe(nil)); end
-
-    sig { params(obj: T::Hash[::String, T.untyped], prefix: ::String).returns(T::Hash[::String, ::Integer]) }
-    def parse_hash(obj, prefix = T.unsafe(nil)); end
-
-    sig { params(string: ::String, prefix: ::String).returns(T::Hash[::String, ::Integer]) }
-    def parse_string(string, prefix = T.unsafe(nil)); end
-  end
-end
-
-Spoom::Sorbet::MetricsParser::DEFAULT_PREFIX = T.let(T.unsafe(nil), String)
-Spoom::Sorbet::SEGFAULT_CODE = T.let(T.unsafe(nil), Integer)
-
-module Spoom::Sorbet::Sigils
-  class << self
-    sig { params(path: T.any(::Pathname, ::String), new_strictness: ::String).returns(T::Boolean) }
-    def change_sigil_in_file(path, new_strictness); end
-
-    sig { params(path_list: T::Array[::String], new_strictness: ::String).returns(T::Array[::String]) }
-    def change_sigil_in_files(path_list, new_strictness); end
-
-    sig { params(path: T.any(::Pathname, ::String)).returns(T.nilable(::String)) }
-    def file_strictness(path); end
-
-    sig do
-      params(
-        directory: T.any(::Pathname, ::String),
-        strictness: ::String,
-        extension: ::String
-      ).returns(T::Array[::String])
-    end
-    def files_with_sigil_strictness(directory, strictness, extension: T.unsafe(nil)); end
-
-    sig { params(strictness: ::String).returns(::String) }
-    def sigil_string(strictness); end
-
-    sig { params(content: ::String).returns(T.nilable(::String)) }
-    def strictness_in_content(content); end
-
-    sig { params(content: ::String, new_strictness: ::String).returns(::String) }
-    def update_sigil(content, new_strictness); end
-
-    sig { params(strictness: ::String).returns(T::Boolean) }
-    def valid_strictness?(strictness); end
-  end
-end
-
-Spoom::Sorbet::Sigils::SIGIL_REGEXP = T.let(T.unsafe(nil), Regexp)
-Spoom::Sorbet::Sigils::STRICTNESS_FALSE = T.let(T.unsafe(nil), String)
-Spoom::Sorbet::Sigils::STRICTNESS_IGNORE = T.let(T.unsafe(nil), String)
-Spoom::Sorbet::Sigils::STRICTNESS_INTERNAL = T.let(T.unsafe(nil), String)
-Spoom::Sorbet::Sigils::STRICTNESS_STRICT = T.let(T.unsafe(nil), String)
-Spoom::Sorbet::Sigils::STRICTNESS_STRONG = T.let(T.unsafe(nil), String)
-Spoom::Sorbet::Sigils::STRICTNESS_TRUE = T.let(T.unsafe(nil), String)
-Spoom::Sorbet::Sigils::VALID_STRICTNESS = T.let(T.unsafe(nil), Array)
-
-class Spoom::Timeline
-  sig { params(from: ::Time, to: ::Time, path: ::String).void }
-  def initialize(from, to, path: T.unsafe(nil)); end
-
-  sig { params(dates: T::Array[::Time]).returns(T::Array[::String]) }
-  def commits_for_dates(dates); end
-
-  sig { returns(T::Array[::Time]) }
-  def months; end
-
-  sig { returns(T::Array[::String]) }
-  def ticks; end
-end
-
-Spoom::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/spoom@1.5.0.rbi b/Library/Homebrew/sorbet/rbi/gems/spoom@1.5.0.rbi
new file mode 100644
index 0000000000000..d36d8c43e8aa6
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/spoom@1.5.0.rbi
@@ -0,0 +1,4932 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `spoom` gem.
+# Please instead update this file by running `bin/tapioca gem spoom`.
+
+
+# source://spoom//lib/spoom.rb#7
+module Spoom
+  class << self
+    # source://spoom//lib/spoom/parse.rb#13
+    sig { params(ruby: ::String, file: ::String).returns(::Prism::Node) }
+    def parse_ruby(ruby, file:); end
+  end
+end
+
+# source://spoom//lib/spoom/cli/helper.rb#9
+module Spoom::Cli; end
+
+# source://spoom//lib/spoom/cli/deadcode.rb#8
+class Spoom::Cli::Deadcode < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  # source://spoom//lib/spoom/cli/deadcode.rb#52
+  sig { params(paths: ::String).void }
+  def deadcode(*paths); end
+
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/cli/deadcode.rb#154
+  def remove(location_string); end
+end
+
+# source://spoom//lib/spoom/cli/helper.rb#10
+module Spoom::Cli::Helper
+  include ::Spoom::Colorize
+
+  requires_ancestor { Thor }
+
+  # source://spoom//lib/spoom/cli/helper.rb#139
+  sig { params(string: ::String).returns(::String) }
+  def blue(string); end
+
+  # Is the `--color` option true?
+  #
+  # source://spoom//lib/spoom/cli/helper.rb#103
+  sig { returns(T::Boolean) }
+  def color?; end
+
+  # Colorize a string if `color?`
+  #
+  # source://spoom//lib/spoom/cli/helper.rb#132
+  sig { params(string: ::String, color: ::Spoom::Color).returns(::String) }
+  def colorize(string, *color); end
+
+  # Returns the context at `--path` (by default the current working directory)
+  #
+  # source://spoom//lib/spoom/cli/helper.rb#71
+  sig { returns(::Spoom::Context) }
+  def context; end
+
+  # Raise if `spoom` is not ran inside a context with a `sorbet/config` file
+  #
+  # source://spoom//lib/spoom/cli/helper.rb#77
+  sig { returns(::Spoom::Context) }
+  def context_requiring_sorbet!; end
+
+  # source://spoom//lib/spoom/cli/helper.rb#144
+  sig { params(string: ::String).returns(::String) }
+  def cyan(string); end
+
+  # Return the path specified through `--path`
+  #
+  # source://spoom//lib/spoom/cli/helper.rb#92
+  sig { returns(::String) }
+  def exec_path; end
+
+  # source://spoom//lib/spoom/cli/helper.rb#149
+  sig { params(string: ::String).returns(::String) }
+  def gray(string); end
+
+  # source://spoom//lib/spoom/cli/helper.rb#154
+  sig { params(string: ::String).returns(::String) }
+  def green(string); end
+
+  # source://spoom//lib/spoom/cli/helper.rb#108
+  sig { params(string: ::String).returns(::String) }
+  def highlight(string); end
+
+  # source://spoom//lib/spoom/cli/helper.rb#159
+  sig { params(string: ::String).returns(::String) }
+  def red(string); end
+
+  # Print `message` on `$stdout`
+  #
+  # source://spoom//lib/spoom/cli/helper.rb#20
+  sig { params(message: ::String).void }
+  def say(message); end
+
+  # Print `message` on `$stderr`
+  #
+  # The message is prefixed by a status (default: `Error`).
+  #
+  # source://spoom//lib/spoom/cli/helper.rb#39
+  sig { params(message: ::String, status: T.nilable(::String), nl: T::Boolean).void }
+  def say_error(message, status: T.unsafe(nil), nl: T.unsafe(nil)); end
+
+  # Print `message` on `$stderr`
+  #
+  # The message is prefixed by a status (default: `Warning`).
+  #
+  # source://spoom//lib/spoom/cli/helper.rb#59
+  sig { params(message: ::String, status: T.nilable(::String), nl: T::Boolean).void }
+  def say_warning(message, status: T.unsafe(nil), nl: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/cli/helper.rb#164
+  sig { params(string: ::String).returns(::String) }
+  def yellow(string); end
+end
+
+# source://spoom//lib/spoom/cli.rb#12
+class Spoom::Cli::Main < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  # source://spoom//lib/spoom/cli.rb#101
+  def __print_version; end
+
+  # source://spoom//lib/spoom/cli.rb#58
+  sig { params(directory: ::String).void }
+  def bump(directory = T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/cli.rb#65
+  def coverage(*args); end
+
+  # source://thor/1.3.2/lib/thor.rb#334
+  def deadcode(*args); end
+
+  # source://spoom//lib/spoom/cli.rb#75
+  def lsp(*args); end
+
+  # source://thor/1.3.2/lib/thor.rb#334
+  def srb(*args); end
+
+  # source://spoom//lib/spoom/cli.rb#94
+  def tc(*paths_to_select); end
+
+  class << self
+    # @return [Boolean]
+    #
+    # source://spoom//lib/spoom/cli.rb#108
+    def exit_on_failure?; end
+  end
+end
+
+# source://spoom//lib/spoom/cli.rb#81
+Spoom::Cli::Main::SORT_CODE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/cli.rb#83
+Spoom::Cli::Main::SORT_ENUM = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/cli.rb#82
+Spoom::Cli::Main::SORT_LOC = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/cli/srb/bump.rb#9
+module Spoom::Cli::Srb; end
+
+# source://spoom//lib/spoom/cli/srb/bump.rb#10
+class Spoom::Cli::Srb::Bump < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  # source://spoom//lib/spoom/cli/srb/bump.rb#50
+  sig { params(directory: ::String).void }
+  def bump(directory = T.unsafe(nil)); end
+
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/cli/srb/bump.rb#171
+  def print_changes(files, command:, from: T.unsafe(nil), to: T.unsafe(nil), dry: T.unsafe(nil), path: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/cli/srb/bump.rb#193
+  def undo_changes(files, from_strictness); end
+end
+
+# source://spoom//lib/spoom/cli/srb/coverage.rb#10
+class Spoom::Cli::Srb::Coverage < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  # source://spoom//lib/spoom/cli/srb/coverage.rb#199
+  def bundle_install(path, sha); end
+
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/cli/srb/coverage.rb#211
+  def message_no_data(file); end
+
+  # source://spoom//lib/spoom/cli/srb/coverage.rb#174
+  def open(file = T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/cli/srb/coverage.rb#190
+  def parse_time(string, option); end
+
+  # source://spoom//lib/spoom/cli/srb/coverage.rb#143
+  def report; end
+
+  # source://spoom//lib/spoom/cli/srb/coverage.rb#21
+  def snapshot; end
+
+  # source://spoom//lib/spoom/cli/srb/coverage.rb#43
+  def timeline; end
+end
+
+# source://spoom//lib/spoom/cli/srb/coverage.rb#13
+Spoom::Cli::Srb::Coverage::DATA_DIR = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/cli/srb/lsp.rb#11
+class Spoom::Cli::Srb::LSP < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  # TODO: options, filter, limit, kind etc.. filter rbi
+  #
+  # source://spoom//lib/spoom/cli/srb/lsp.rb#45
+  def defs(file, line, col); end
+
+  # TODO: options, filter, limit, kind etc.. filter rbi
+  #
+  # source://spoom//lib/spoom/cli/srb/lsp.rb#55
+  def find(query); end
+
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+  # TODO: options, filter, limit, kind etc.. filter rbi
+  #
+  # source://spoom//lib/spoom/cli/srb/lsp.rb#31
+  def hover(file, line, col); end
+
+  # TODO: options, filter, limit, kind etc.. filter rbi
+  #
+  # source://spoom//lib/spoom/cli/srb/lsp.rb#16
+  def list; end
+
+  # source://spoom//lib/spoom/cli/srb/lsp.rb#104
+  def lsp_client; end
+
+  # TODO: options, filter, limit, kind etc.. filter rbi
+  #
+  # source://spoom//lib/spoom/cli/srb/lsp.rb#75
+  def refs(file, line, col); end
+
+  # source://spoom//lib/spoom/cli/srb/lsp.rb#127
+  def run(&block); end
+
+  # TODO: options, filter, limit, kind etc.. filter rbi
+  #
+  # source://spoom//lib/spoom/cli/srb/lsp.rb#85
+  def sigs(file, line, col); end
+
+  # source://spoom//lib/spoom/cli/srb/lsp.rb#119
+  def symbol_printer; end
+
+  # TODO: options, filter, limit, kind etc.. filter rbi
+  #
+  # source://spoom//lib/spoom/cli/srb/lsp.rb#65
+  def symbols(file); end
+
+  # source://spoom//lib/spoom/cli/srb/lsp.rb#152
+  def to_uri(path); end
+
+  # TODO: options, filter, limit, kind etc.. filter rbi
+  #
+  # source://spoom//lib/spoom/cli/srb/lsp.rb#95
+  def types(file, line, col); end
+end
+
+# source://spoom//lib/spoom/cli/srb.rb#12
+class Spoom::Cli::Srb::Main < ::Thor
+  # source://thor/1.3.2/lib/thor.rb#334
+  def bump(*args); end
+
+  # source://thor/1.3.2/lib/thor.rb#334
+  def coverage(*args); end
+
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+  # source://thor/1.3.2/lib/thor.rb#334
+  def lsp(*args); end
+
+  # source://thor/1.3.2/lib/thor.rb#334
+  def tc(*args); end
+end
+
+# source://spoom//lib/spoom/cli/srb/tc.rb#7
+class Spoom::Cli::Srb::Tc < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  # source://spoom//lib/spoom/cli/srb/tc.rb#132
+  def colorize_message(message); end
+
+  # source://spoom//lib/spoom/cli/srb/tc.rb#123
+  def format_error(error, format); end
+
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/cli/srb/tc.rb#27
+  def tc(*paths_to_select); end
+end
+
+# source://spoom//lib/spoom/cli/srb/tc.rb#16
+Spoom::Cli::Srb::Tc::DEFAULT_FORMAT = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/cli/srb/tc.rb#12
+Spoom::Cli::Srb::Tc::SORT_CODE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/cli/srb/tc.rb#14
+Spoom::Cli::Srb::Tc::SORT_ENUM = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/cli/srb/tc.rb#13
+Spoom::Cli::Srb::Tc::SORT_LOC = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/colors.rb#5
+class Spoom::Color < ::T::Enum
+  enums do
+    BLACK = new
+    BLUE = new
+    BOLD = new
+    CLEAR = new
+    CYAN = new
+    GREEN = new
+    LIGHT_BLACK = new
+    LIGHT_BLUE = new
+    LIGHT_CYAN = new
+    LIGHT_GREEN = new
+    LIGHT_MAGENTA = new
+    LIGHT_RED = new
+    LIGHT_WHITE = new
+    LIGHT_YELLOW = new
+    MAGENTA = new
+    RED = new
+    WHITE = new
+    YELLOW = new
+  end
+
+  # source://spoom//lib/spoom/colors.rb#32
+  sig { returns(::String) }
+  def ansi_code; end
+end
+
+# source://spoom//lib/spoom/colors.rb#37
+module Spoom::Colorize
+  # source://spoom//lib/spoom/colors.rb#41
+  sig { params(string: ::String, color: ::Spoom::Color).returns(::String) }
+  def set_color(string, *color); end
+end
+
+# An abstraction to a Ruby project context
+#
+# A context maps to a directory in the file system.
+# It is used to manipulate files and run commands in the context of this directory.
+#
+# source://spoom//lib/spoom/context/bundle.rb#5
+class Spoom::Context
+  include ::Spoom::Context::Bundle
+  include ::Spoom::Context::Exec
+  include ::Spoom::Context::FileSystem
+  include ::Spoom::Context::Git
+  include ::Spoom::Context::Sorbet
+
+  # Create a new context about `absolute_path`
+  #
+  # The directory will not be created if it doesn't exist.
+  # Call `#make!` to create it.
+  #
+  # source://spoom//lib/spoom/context.rb#51
+  sig { params(absolute_path: ::String).void }
+  def initialize(absolute_path); end
+
+  # The absolute path to the directory this context is about
+  #
+  # source://spoom//lib/spoom/context.rb#44
+  sig { returns(::String) }
+  def absolute_path; end
+
+  class << self
+    # Create a new context in the system's temporary directory
+    #
+    # `name` is used as prefix to the temporary directory name.
+    # The directory will be created if it doesn't exist.
+    #
+    # source://spoom//lib/spoom/context.rb#37
+    sig { params(name: T.nilable(::String)).returns(T.attached_class) }
+    def mktmp!(name = T.unsafe(nil)); end
+  end
+end
+
+# Bundle features for a context
+#
+# source://spoom//lib/spoom/context/bundle.rb#7
+module Spoom::Context::Bundle
+  requires_ancestor { Spoom::Context }
+
+  # Run a command with `bundle` in this context directory
+  #
+  # source://spoom//lib/spoom/context/bundle.rb#33
+  sig { params(command: ::String, version: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+  def bundle(command, version: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+  # Run a command `bundle exec` in this context directory
+  #
+  # source://spoom//lib/spoom/context/bundle.rb#46
+  sig { params(command: ::String, version: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+  def bundle_exec(command, version: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+  # Run `bundle install` in this context directory
+  #
+  # source://spoom//lib/spoom/context/bundle.rb#40
+  sig { params(version: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+  def bundle_install!(version: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+  # Get `gem` version from the `Gemfile.lock` content
+  #
+  # Returns `nil` if `gem` cannot be found in the Gemfile.
+  #
+  # source://spoom//lib/spoom/context/bundle.rb#62
+  sig { params(gem: ::String).returns(T.nilable(::Gem::Version)) }
+  def gem_version_from_gemfile_lock(gem); end
+
+  # source://spoom//lib/spoom/context/bundle.rb#51
+  sig { returns(T::Hash[::String, ::Bundler::LazySpecification]) }
+  def gemfile_lock_specs; end
+
+  # Read the contents of the Gemfile in this context directory
+  #
+  # source://spoom//lib/spoom/context/bundle.rb#15
+  sig { returns(T.nilable(::String)) }
+  def read_gemfile; end
+
+  # Read the contents of the Gemfile.lock in this context directory
+  #
+  # source://spoom//lib/spoom/context/bundle.rb#21
+  sig { returns(T.nilable(::String)) }
+  def read_gemfile_lock; end
+
+  # Set the `contents` of the Gemfile in this context directory
+  #
+  # source://spoom//lib/spoom/context/bundle.rb#27
+  sig { params(contents: ::String, append: T::Boolean).void }
+  def write_gemfile!(contents, append: T.unsafe(nil)); end
+end
+
+# Execution features for a context
+#
+# source://spoom//lib/spoom/context/exec.rb#27
+module Spoom::Context::Exec
+  requires_ancestor { Spoom::Context }
+
+  # Run a command in this context directory
+  #
+  # source://spoom//lib/spoom/context/exec.rb#35
+  sig { params(command: ::String, capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+  def exec(command, capture_err: T.unsafe(nil)); end
+end
+
+# File System features for a context
+#
+# source://spoom//lib/spoom/context/file_system.rb#7
+module Spoom::Context::FileSystem
+  requires_ancestor { Spoom::Context }
+
+  # Returns the absolute path to `relative_path` in the context's directory
+  #
+  # source://spoom//lib/spoom/context/file_system.rb#15
+  sig { params(relative_path: ::String).returns(::String) }
+  def absolute_path_to(relative_path); end
+
+  # source://spoom//lib/spoom/context/file_system.rb#53
+  sig do
+    params(
+      allow_extensions: T::Array[::String],
+      allow_mime_types: T::Array[::String],
+      exclude_patterns: T::Array[::String]
+    ).returns(T::Array[::String])
+  end
+  def collect_files(allow_extensions: T.unsafe(nil), allow_mime_types: T.unsafe(nil), exclude_patterns: T.unsafe(nil)); end
+
+  # Delete this context and its content
+  #
+  # Warning: it will `rm -rf` the context directory on the file system.
+  #
+  # source://spoom//lib/spoom/context/file_system.rb#105
+  sig { void }
+  def destroy!; end
+
+  # Does the context directory at `absolute_path` exist and is a directory?
+  #
+  # source://spoom//lib/spoom/context/file_system.rb#21
+  sig { returns(T::Boolean) }
+  def exist?; end
+
+  # Does `relative_path` point to an existing file in this context directory?
+  #
+  # source://spoom//lib/spoom/context/file_system.rb#65
+  sig { params(relative_path: ::String).returns(T::Boolean) }
+  def file?(relative_path); end
+
+  # List all files in this context matching `pattern`
+  #
+  # source://spoom//lib/spoom/context/file_system.rb#34
+  sig { params(pattern: ::String).returns(T::Array[::String]) }
+  def glob(pattern = T.unsafe(nil)); end
+
+  # List all files at the top level of this context directory
+  #
+  # source://spoom//lib/spoom/context/file_system.rb#42
+  sig { returns(T::Array[::String]) }
+  def list; end
+
+  # Create the context directory at `absolute_path`
+  #
+  # source://spoom//lib/spoom/context/file_system.rb#27
+  sig { void }
+  def mkdir!; end
+
+  # Move the file or directory from `from_relative_path` to `to_relative_path`
+  #
+  # source://spoom//lib/spoom/context/file_system.rb#95
+  sig { params(from_relative_path: ::String, to_relative_path: ::String).void }
+  def move!(from_relative_path, to_relative_path); end
+
+  # Return the contents of the file at `relative_path` in this context directory
+  #
+  # Will raise if the file doesn't exist.
+  #
+  # source://spoom//lib/spoom/context/file_system.rb#73
+  sig { params(relative_path: ::String).returns(::String) }
+  def read(relative_path); end
+
+  # Remove the path at `relative_path` (recursive + force) in this context directory
+  #
+  # source://spoom//lib/spoom/context/file_system.rb#89
+  sig { params(relative_path: ::String).void }
+  def remove!(relative_path); end
+
+  # Write `contents` in the file at `relative_path` in this context directory
+  #
+  # Append to the file if `append` is true.
+  #
+  # source://spoom//lib/spoom/context/file_system.rb#81
+  sig { params(relative_path: ::String, contents: ::String, append: T::Boolean).void }
+  def write!(relative_path, contents = T.unsafe(nil), append: T.unsafe(nil)); end
+end
+
+# Git features for a context
+#
+# source://spoom//lib/spoom/context/git.rb#35
+module Spoom::Context::Git
+  requires_ancestor { Spoom::Context }
+
+  # Run a command prefixed by `git` in this context directory
+  #
+  # source://spoom//lib/spoom/context/git.rb#43
+  sig { params(command: ::String).returns(::Spoom::ExecResult) }
+  def git(command); end
+
+  # Run `git checkout` in this context directory
+  #
+  # source://spoom//lib/spoom/context/git.rb#62
+  sig { params(ref: ::String).returns(::Spoom::ExecResult) }
+  def git_checkout!(ref: T.unsafe(nil)); end
+
+  # Run `git checkout -b <branch-name> <ref>` in this context directory
+  #
+  # source://spoom//lib/spoom/context/git.rb#68
+  sig { params(branch_name: ::String, ref: T.nilable(::String)).returns(::Spoom::ExecResult) }
+  def git_checkout_new_branch!(branch_name, ref: T.unsafe(nil)); end
+
+  # Run `git add . && git commit` in this context directory
+  #
+  # source://spoom//lib/spoom/context/git.rb#78
+  sig { params(message: ::String, time: ::Time, allow_empty: T::Boolean).returns(::Spoom::ExecResult) }
+  def git_commit!(message: T.unsafe(nil), time: T.unsafe(nil), allow_empty: T.unsafe(nil)); end
+
+  # Get the current git branch in this context directory
+  #
+  # source://spoom//lib/spoom/context/git.rb#89
+  sig { returns(T.nilable(::String)) }
+  def git_current_branch; end
+
+  # Run `git diff` in this context directory
+  #
+  # source://spoom//lib/spoom/context/git.rb#98
+  sig { params(arg: ::String).returns(::Spoom::ExecResult) }
+  def git_diff(*arg); end
+
+  # Run `git init` in this context directory
+  #
+  # Warning: passing a branch will run `git init -b <branch>` which is only available in git 2.28+.
+  # In older versions, use `git_init!` followed by `git("checkout -b <branch>")`.
+  #
+  # source://spoom//lib/spoom/context/git.rb#52
+  sig { params(branch: T.nilable(::String)).returns(::Spoom::ExecResult) }
+  def git_init!(branch: T.unsafe(nil)); end
+
+  # Get the last commit in the currently checked out branch
+  #
+  # source://spoom//lib/spoom/context/git.rb#104
+  sig { params(short_sha: T::Boolean).returns(T.nilable(::Spoom::Git::Commit)) }
+  def git_last_commit(short_sha: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/context/git.rb#115
+  sig { params(arg: ::String).returns(::Spoom::ExecResult) }
+  def git_log(*arg); end
+
+  # Run `git push <remote> <ref>` in this context directory
+  #
+  # source://spoom//lib/spoom/context/git.rb#121
+  sig { params(remote: ::String, ref: ::String, force: T::Boolean).returns(::Spoom::ExecResult) }
+  def git_push!(remote, ref, force: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/context/git.rb#126
+  sig { params(arg: ::String).returns(::Spoom::ExecResult) }
+  def git_show(*arg); end
+
+  # Is there uncommitted changes in this context directory?
+  #
+  # source://spoom//lib/spoom/context/git.rb#132
+  sig { params(path: ::String).returns(T::Boolean) }
+  def git_workdir_clean?(path: T.unsafe(nil)); end
+end
+
+# Sorbet features for a context
+#
+# source://spoom//lib/spoom/context/sorbet.rb#7
+module Spoom::Context::Sorbet
+  requires_ancestor { Spoom::Context }
+
+  # Does this context has a `sorbet/config` file?
+  #
+  # source://spoom//lib/spoom/context/sorbet.rb#119
+  sig { returns(T::Boolean) }
+  def has_sorbet_config?; end
+
+  # Read the strictness sigil from the file at `relative_path` (returns `nil` if no sigil)
+  #
+  # source://spoom//lib/spoom/context/sorbet.rb#142
+  sig { params(relative_path: ::String).returns(T.nilable(::String)) }
+  def read_file_strictness(relative_path); end
+
+  # Read the contents of `sorbet/config` in this context directory
+  #
+  # source://spoom//lib/spoom/context/sorbet.rb#130
+  sig { returns(::String) }
+  def read_sorbet_config; end
+
+  # source://spoom//lib/spoom/context/sorbet.rb#124
+  sig { returns(::Spoom::Sorbet::Config) }
+  def sorbet_config; end
+
+  # Get the commit introducing the `sorbet/config` file
+  #
+  # source://spoom//lib/spoom/context/sorbet.rb#148
+  sig { returns(T.nilable(::Spoom::Git::Commit)) }
+  def sorbet_intro_commit; end
+
+  # Get the commit removing the `sorbet/config` file
+  #
+  # source://spoom//lib/spoom/context/sorbet.rb#160
+  sig { returns(T.nilable(::Spoom::Git::Commit)) }
+  def sorbet_removal_commit; end
+
+  # Run `bundle exec srb` in this context directory
+  #
+  # source://spoom//lib/spoom/context/sorbet.rb#15
+  sig { params(arg: ::String, sorbet_bin: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+  def srb(*arg, sorbet_bin: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+  # List all files typechecked by Sorbet from its `config`
+  #
+  # source://spoom//lib/spoom/context/sorbet.rb#65
+  sig { params(with_config: T.nilable(::Spoom::Sorbet::Config), include_rbis: T::Boolean).returns(T::Array[::String]) }
+  def srb_files(with_config: T.unsafe(nil), include_rbis: T.unsafe(nil)); end
+
+  # List all files typechecked by Sorbet from its `config` that matches `strictness`
+  #
+  # source://spoom//lib/spoom/context/sorbet.rb#104
+  sig do
+    params(
+      strictness: ::String,
+      with_config: T.nilable(::Spoom::Sorbet::Config),
+      include_rbis: T::Boolean
+    ).returns(T::Array[::String])
+  end
+  def srb_files_with_strictness(strictness, with_config: T.unsafe(nil), include_rbis: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/context/sorbet.rb#45
+  sig do
+    params(
+      arg: ::String,
+      sorbet_bin: T.nilable(::String),
+      capture_err: T::Boolean
+    ).returns(T.nilable(T::Hash[::String, ::Integer]))
+  end
+  def srb_metrics(*arg, sorbet_bin: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/context/sorbet.rb#33
+  sig { params(arg: ::String, sorbet_bin: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+  def srb_tc(*arg, sorbet_bin: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/context/sorbet.rb#110
+  sig { params(arg: ::String, sorbet_bin: T.nilable(::String), capture_err: T::Boolean).returns(T.nilable(::String)) }
+  def srb_version(*arg, sorbet_bin: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+  # Set the `contents` of `sorbet/config` in this context directory
+  #
+  # source://spoom//lib/spoom/context/sorbet.rb#136
+  sig { params(contents: ::String, append: T::Boolean).void }
+  def write_sorbet_config!(contents, append: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/snapshot.rb#5
+module Spoom::Coverage
+  class << self
+    # source://spoom//lib/spoom/coverage.rb#103
+    sig { params(context: ::Spoom::Context).returns(::Spoom::FileTree) }
+    def file_tree(context); end
+
+    # source://spoom//lib/spoom/coverage.rb#83
+    sig do
+      params(
+        context: ::Spoom::Context,
+        snapshots: T::Array[::Spoom::Coverage::Snapshot],
+        palette: ::Spoom::Coverage::D3::ColorPalette
+      ).returns(::Spoom::Coverage::Report)
+    end
+    def report(context, snapshots, palette:); end
+
+    # source://spoom//lib/spoom/coverage.rb#16
+    sig do
+      params(
+        context: ::Spoom::Context,
+        rbi: T::Boolean,
+        sorbet_bin: T.nilable(::String)
+      ).returns(::Spoom::Coverage::Snapshot)
+    end
+    def snapshot(context, rbi: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end
+  end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#88
+module Spoom::Coverage::Cards; end
+
+# source://spoom//lib/spoom/coverage/report.rb#89
+class Spoom::Coverage::Cards::Card < ::Spoom::Coverage::Template
+  # source://spoom//lib/spoom/coverage/report.rb#98
+  sig { params(template: ::String, title: T.nilable(::String), body: T.nilable(::String)).void }
+  def initialize(template: T.unsafe(nil), title: T.unsafe(nil), body: T.unsafe(nil)); end
+
+  # @return [String, nil]
+  #
+  # source://spoom//lib/spoom/coverage/report.rb#95
+  def body; end
+
+  # source://spoom//lib/spoom/coverage/report.rb#95
+  sig { returns(T.nilable(::String)) }
+  def title; end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#92
+Spoom::Coverage::Cards::Card::TEMPLATE = T.let(T.unsafe(nil), String)
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/coverage/report.rb#105
+class Spoom::Coverage::Cards::Erb < ::Spoom::Coverage::Cards::Card
+  abstract!
+
+  # source://spoom//lib/spoom/coverage/report.rb#112
+  sig { void }
+  def initialize; end
+
+  # @abstract
+  #
+  # source://spoom//lib/spoom/coverage/report.rb#120
+  sig { abstract.returns(::String) }
+  def erb; end
+
+  # source://spoom//lib/spoom/coverage/report.rb#115
+  sig { override.returns(::String) }
+  def html; end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#153
+class Spoom::Coverage::Cards::Map < ::Spoom::Coverage::Cards::Card
+  # source://spoom//lib/spoom/coverage/report.rb#164
+  sig do
+    params(
+      file_tree: ::Spoom::FileTree,
+      nodes_strictnesses: T::Hash[::Spoom::FileTree::Node, T.nilable(::String)],
+      nodes_strictness_scores: T::Hash[::Spoom::FileTree::Node, ::Float],
+      title: ::String
+    ).void
+  end
+  def initialize(file_tree:, nodes_strictnesses:, nodes_strictness_scores:, title: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#123
+class Spoom::Coverage::Cards::Snapshot < ::Spoom::Coverage::Cards::Card
+  # source://spoom//lib/spoom/coverage/report.rb#132
+  sig { params(snapshot: ::Spoom::Coverage::Snapshot, title: ::String).void }
+  def initialize(snapshot:, title: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/coverage/report.rb#143
+  sig { returns(::Spoom::Coverage::D3::Pie::Calls) }
+  def pie_calls; end
+
+  # source://spoom//lib/spoom/coverage/report.rb#138
+  sig { returns(::Spoom::Coverage::D3::Pie::Sigils) }
+  def pie_sigils; end
+
+  # source://spoom//lib/spoom/coverage/report.rb#148
+  sig { returns(::Spoom::Coverage::D3::Pie::Sigs) }
+  def pie_sigs; end
+
+  # source://spoom//lib/spoom/coverage/report.rb#129
+  sig { returns(::Spoom::Coverage::Snapshot) }
+  def snapshot; end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#126
+Spoom::Coverage::Cards::Snapshot::TEMPLATE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/coverage/report.rb#240
+class Spoom::Coverage::Cards::SorbetIntro < ::Spoom::Coverage::Cards::Erb
+  # source://spoom//lib/spoom/coverage/report.rb#244
+  sig { params(sorbet_intro_commit: T.nilable(::String), sorbet_intro_date: T.nilable(::Time)).void }
+  def initialize(sorbet_intro_commit: T.unsafe(nil), sorbet_intro_date: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/coverage/report.rb#250
+  sig { override.returns(::String) }
+  def erb; end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#177
+class Spoom::Coverage::Cards::Timeline < ::Spoom::Coverage::Cards::Card
+  # source://spoom//lib/spoom/coverage/report.rb#181
+  sig { params(title: ::String, timeline: ::Spoom::Coverage::D3::Timeline).void }
+  def initialize(title:, timeline:); end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#194
+class Spoom::Coverage::Cards::Timeline::Calls < ::Spoom::Coverage::Cards::Timeline
+  # source://spoom//lib/spoom/coverage/report.rb#198
+  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+  def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#212
+class Spoom::Coverage::Cards::Timeline::RBIs < ::Spoom::Coverage::Cards::Timeline
+  # source://spoom//lib/spoom/coverage/report.rb#216
+  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+  def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#230
+class Spoom::Coverage::Cards::Timeline::Runtimes < ::Spoom::Coverage::Cards::Timeline
+  # source://spoom//lib/spoom/coverage/report.rb#234
+  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+  def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#185
+class Spoom::Coverage::Cards::Timeline::Sigils < ::Spoom::Coverage::Cards::Timeline
+  # source://spoom//lib/spoom/coverage/report.rb#189
+  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+  def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#203
+class Spoom::Coverage::Cards::Timeline::Sigs < ::Spoom::Coverage::Cards::Timeline
+  # source://spoom//lib/spoom/coverage/report.rb#207
+  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+  def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#221
+class Spoom::Coverage::Cards::Timeline::Versions < ::Spoom::Coverage::Cards::Timeline
+  # source://spoom//lib/spoom/coverage/report.rb#225
+  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+  def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/d3/base.rb#6
+module Spoom::Coverage::D3
+  class << self
+    # source://spoom//lib/spoom/coverage/d3.rb#61
+    sig { params(palette: ::Spoom::Coverage::D3::ColorPalette).returns(::String) }
+    def header_script(palette); end
+
+    # source://spoom//lib/spoom/coverage/d3.rb#21
+    sig { returns(::String) }
+    def header_style; end
+  end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/coverage/d3/base.rb#7
+class Spoom::Coverage::D3::Base
+  abstract!
+
+  # source://spoom//lib/spoom/coverage/d3/base.rb#17
+  sig { params(id: ::String, data: T.untyped).void }
+  def initialize(id, data); end
+
+  # source://spoom//lib/spoom/coverage/d3/base.rb#37
+  sig { returns(::String) }
+  def html; end
+
+  # source://spoom//lib/spoom/coverage/d3/base.rb#14
+  sig { returns(::String) }
+  def id; end
+
+  # @abstract
+  #
+  # source://spoom//lib/spoom/coverage/d3/base.rb#50
+  sig { abstract.returns(::String) }
+  def script; end
+
+  # source://spoom//lib/spoom/coverage/d3/base.rb#45
+  sig { returns(::String) }
+  def tooltip; end
+
+  class << self
+    # source://spoom//lib/spoom/coverage/d3/base.rb#31
+    sig { returns(::String) }
+    def header_script; end
+
+    # source://spoom//lib/spoom/coverage/d3/base.rb#26
+    sig { returns(::String) }
+    def header_style; end
+  end
+end
+
+# source://spoom//lib/spoom/coverage/d3.rb#12
+Spoom::Coverage::D3::COLOR_FALSE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/coverage/d3.rb#11
+Spoom::Coverage::D3::COLOR_IGNORE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/coverage/d3.rb#14
+Spoom::Coverage::D3::COLOR_STRICT = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/coverage/d3.rb#15
+Spoom::Coverage::D3::COLOR_STRONG = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/coverage/d3.rb#13
+Spoom::Coverage::D3::COLOR_TRUE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/coverage/d3/circle_map.rb#9
+class Spoom::Coverage::D3::CircleMap < ::Spoom::Coverage::D3::Base
+  # source://spoom//lib/spoom/coverage/d3/circle_map.rb#59
+  sig { override.returns(::String) }
+  def script; end
+
+  class << self
+    # source://spoom//lib/spoom/coverage/d3/circle_map.rb#40
+    sig { returns(::String) }
+    def header_script; end
+
+    # source://spoom//lib/spoom/coverage/d3/circle_map.rb#14
+    sig { returns(::String) }
+    def header_style; end
+  end
+end
+
+# source://spoom//lib/spoom/coverage/d3/circle_map.rb#148
+class Spoom::Coverage::D3::CircleMap::Sigils < ::Spoom::Coverage::D3::CircleMap
+  # source://spoom//lib/spoom/coverage/d3/circle_map.rb#159
+  sig do
+    params(
+      id: ::String,
+      file_tree: ::Spoom::FileTree,
+      nodes_strictnesses: T::Hash[::Spoom::FileTree::Node, T.nilable(::String)],
+      nodes_scores: T::Hash[::Spoom::FileTree::Node, ::Float]
+    ).void
+  end
+  def initialize(id, file_tree, nodes_strictnesses, nodes_scores); end
+
+  # source://spoom//lib/spoom/coverage/d3/circle_map.rb#166
+  sig { params(node: ::Spoom::FileTree::Node).returns(T::Hash[::Symbol, T.untyped]) }
+  def tree_node_to_json(node); end
+end
+
+# source://spoom//lib/spoom/coverage/d3.rb#103
+class Spoom::Coverage::D3::ColorPalette < ::T::Struct
+  prop :ignore, ::String
+  prop :false, ::String
+  prop :true, ::String
+  prop :strict, ::String
+  prop :strong, ::String
+
+  class << self
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/coverage/d3/pie.rb#9
+class Spoom::Coverage::D3::Pie < ::Spoom::Coverage::D3::Base
+  abstract!
+
+  # source://spoom//lib/spoom/coverage/d3/pie.rb#16
+  sig { params(id: ::String, title: ::String, data: T.untyped).void }
+  def initialize(id, title, data); end
+
+  # source://spoom//lib/spoom/coverage/d3/pie.rb#56
+  sig { override.returns(::String) }
+  def script; end
+
+  class << self
+    # source://spoom//lib/spoom/coverage/d3/pie.rb#43
+    sig { returns(::String) }
+    def header_script; end
+
+    # source://spoom//lib/spoom/coverage/d3/pie.rb#25
+    sig { returns(::String) }
+    def header_style; end
+  end
+end
+
+# source://spoom//lib/spoom/coverage/d3/pie.rb#141
+class Spoom::Coverage::D3::Pie::Calls < ::Spoom::Coverage::D3::Pie
+  # source://spoom//lib/spoom/coverage/d3/pie.rb#145
+  sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void }
+  def initialize(id, title, snapshot); end
+
+  # source://spoom//lib/spoom/coverage/d3/pie.rb#150
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+# source://spoom//lib/spoom/coverage/d3/pie.rb#123
+class Spoom::Coverage::D3::Pie::Sigils < ::Spoom::Coverage::D3::Pie
+  # source://spoom//lib/spoom/coverage/d3/pie.rb#127
+  sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void }
+  def initialize(id, title, snapshot); end
+
+  # source://spoom//lib/spoom/coverage/d3/pie.rb#132
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+# source://spoom//lib/spoom/coverage/d3/pie.rb#159
+class Spoom::Coverage::D3::Pie::Sigs < ::Spoom::Coverage::D3::Pie
+  # source://spoom//lib/spoom/coverage/d3/pie.rb#163
+  sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void }
+  def initialize(id, title, snapshot); end
+
+  # source://spoom//lib/spoom/coverage/d3/pie.rb#172
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#9
+class Spoom::Coverage::D3::Timeline < ::Spoom::Coverage::D3::Base
+  abstract!
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#16
+  sig { params(id: ::String, data: T.untyped, keys: T::Array[::String]).void }
+  def initialize(id, data, keys); end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#187
+  sig { params(y: ::String, color: ::String, curve: ::String).returns(::String) }
+  def area(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#203
+  sig { params(y: ::String, color: ::String, curve: ::String).returns(::String) }
+  def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
+  # @abstract
+  #
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#126
+  sig { abstract.returns(::String) }
+  def plot; end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#217
+  sig { params(y: ::String).returns(::String) }
+  def points(y:); end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#101
+  sig { override.returns(::String) }
+  def script; end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#129
+  sig { returns(::String) }
+  def x_scale; end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#145
+  sig { returns(::String) }
+  def x_ticks; end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#158
+  sig { params(min: ::String, max: ::String, ticks: ::String).returns(::String) }
+  def y_scale(min:, max:, ticks:); end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#174
+  sig { params(ticks: ::String, format: ::String, padding: ::Integer).returns(::String) }
+  def y_ticks(ticks:, format:, padding:); end
+
+  class << self
+    # source://spoom//lib/spoom/coverage/d3/timeline.rb#79
+    sig { returns(::String) }
+    def header_script; end
+
+    # source://spoom//lib/spoom/coverage/d3/timeline.rb#25
+    sig { returns(::String) }
+    def header_style; end
+  end
+end
+
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#448
+class Spoom::Coverage::D3::Timeline::Calls < ::Spoom::Coverage::D3::Timeline::Stacked
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#452
+  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+  def initialize(id, snapshots); end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#466
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#505
+class Spoom::Coverage::D3::Timeline::RBIs < ::Spoom::Coverage::D3::Timeline::Stacked
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#509
+  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+  def initialize(id, snapshots); end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#577
+  sig { override.params(y: ::String, color: ::String, curve: ::String).returns(::String) }
+  def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#617
+  sig { override.returns(::String) }
+  def plot; end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#537
+  sig { override.returns(::String) }
+  def script; end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#523
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#282
+class Spoom::Coverage::D3::Timeline::Runtimes < ::Spoom::Coverage::D3::Timeline
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#286
+  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+  def initialize(id, snapshots); end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#311
+  sig { override.returns(::String) }
+  def plot; end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#298
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#421
+class Spoom::Coverage::D3::Timeline::Sigils < ::Spoom::Coverage::D3::Timeline::Stacked
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#425
+  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+  def initialize(id, snapshots); end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#439
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#475
+class Spoom::Coverage::D3::Timeline::Sigs < ::Spoom::Coverage::D3::Timeline::Stacked
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#479
+  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+  def initialize(id, snapshots); end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#496
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#329
+class Spoom::Coverage::D3::Timeline::Stacked < ::Spoom::Coverage::D3::Timeline
+  abstract!
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#388
+  sig { override.params(y: ::String, color: ::String, curve: ::String).returns(::String) }
+  def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#377
+  sig { override.returns(::String) }
+  def plot; end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#336
+  sig { override.returns(::String) }
+  def script; end
+end
+
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#232
+class Spoom::Coverage::D3::Timeline::Versions < ::Spoom::Coverage::D3::Timeline
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#236
+  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+  def initialize(id, snapshots); end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#263
+  sig { override.returns(::String) }
+  def plot; end
+
+  # source://spoom//lib/spoom/coverage/d3/timeline.rb#249
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/coverage/report.rb#38
+class Spoom::Coverage::Page < ::Spoom::Coverage::Template
+  abstract!
+
+  # source://spoom//lib/spoom/coverage/report.rb#53
+  sig { params(title: ::String, palette: ::Spoom::Coverage::D3::ColorPalette, template: ::String).void }
+  def initialize(title:, palette:, template: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/coverage/report.rb#75
+  sig { returns(::String) }
+  def body_html; end
+
+  # @abstract
+  #
+  # source://spoom//lib/spoom/coverage/report.rb#80
+  sig { abstract.returns(T::Array[::Spoom::Coverage::Cards::Card]) }
+  def cards; end
+
+  # source://spoom//lib/spoom/coverage/report.rb#83
+  sig { returns(::String) }
+  def footer_html; end
+
+  # source://spoom//lib/spoom/coverage/report.rb#70
+  sig { returns(::String) }
+  def header_html; end
+
+  # source://spoom//lib/spoom/coverage/report.rb#65
+  sig { returns(::String) }
+  def header_script; end
+
+  # source://spoom//lib/spoom/coverage/report.rb#60
+  sig { returns(::String) }
+  def header_style; end
+
+  # source://spoom//lib/spoom/coverage/report.rb#50
+  sig { returns(::Spoom::Coverage::D3::ColorPalette) }
+  def palette; end
+
+  # source://spoom//lib/spoom/coverage/report.rb#47
+  sig { returns(::String) }
+  def title; end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#44
+Spoom::Coverage::Page::TEMPLATE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/coverage/report.rb#261
+class Spoom::Coverage::Report < ::Spoom::Coverage::Page
+  # source://spoom//lib/spoom/coverage/report.rb#276
+  sig do
+    params(
+      project_name: ::String,
+      palette: ::Spoom::Coverage::D3::ColorPalette,
+      snapshots: T::Array[::Spoom::Coverage::Snapshot],
+      file_tree: ::Spoom::FileTree,
+      nodes_strictnesses: T::Hash[::Spoom::FileTree::Node, T.nilable(::String)],
+      nodes_strictness_scores: T::Hash[::Spoom::FileTree::Node, ::Float],
+      sorbet_intro_commit: T.nilable(::String),
+      sorbet_intro_date: T.nilable(::Time)
+    ).void
+  end
+  def initialize(project_name:, palette:, snapshots:, file_tree:, nodes_strictnesses:, nodes_strictness_scores:, sorbet_intro_commit: T.unsafe(nil), sorbet_intro_date: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/coverage/report.rb#308
+  sig { override.returns(T::Array[::Spoom::Coverage::Cards::Card]) }
+  def cards; end
+
+  # source://spoom//lib/spoom/coverage/report.rb#297
+  sig { override.returns(::String) }
+  def header_html; end
+end
+
+# source://spoom//lib/spoom/coverage/snapshot.rb#6
+class Spoom::Coverage::Snapshot < ::T::Struct
+  prop :timestamp, ::Integer, default: T.unsafe(nil)
+  prop :version_static, T.nilable(::String), default: T.unsafe(nil)
+  prop :version_runtime, T.nilable(::String), default: T.unsafe(nil)
+  prop :duration, ::Integer, default: T.unsafe(nil)
+  prop :commit_sha, T.nilable(::String), default: T.unsafe(nil)
+  prop :commit_timestamp, T.nilable(::Integer), default: T.unsafe(nil)
+  prop :files, ::Integer, default: T.unsafe(nil)
+  prop :rbi_files, ::Integer, default: T.unsafe(nil)
+  prop :modules, ::Integer, default: T.unsafe(nil)
+  prop :classes, ::Integer, default: T.unsafe(nil)
+  prop :singleton_classes, ::Integer, default: T.unsafe(nil)
+  prop :methods_without_sig, ::Integer, default: T.unsafe(nil)
+  prop :methods_with_sig, ::Integer, default: T.unsafe(nil)
+  prop :calls_untyped, ::Integer, default: T.unsafe(nil)
+  prop :calls_typed, ::Integer, default: T.unsafe(nil)
+  prop :sigils, T::Hash[::String, ::Integer], default: T.unsafe(nil)
+  prop :methods_with_sig_excluding_rbis, ::Integer, default: T.unsafe(nil)
+  prop :methods_without_sig_excluding_rbis, ::Integer, default: T.unsafe(nil)
+  prop :sigils_excluding_rbis, T::Hash[::String, ::Integer], default: T.unsafe(nil)
+
+  # source://spoom//lib/spoom/coverage/snapshot.rb#33
+  sig { params(out: T.any(::IO, ::StringIO), colors: T::Boolean, indent_level: ::Integer).void }
+  def print(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/coverage/snapshot.rb#39
+  sig { params(arg: T.untyped).returns(::String) }
+  def to_json(*arg); end
+
+  class << self
+    # source://spoom//lib/spoom/coverage/snapshot.rb#47
+    sig { params(json: ::String).returns(::Spoom::Coverage::Snapshot) }
+    def from_json(json); end
+
+    # source://spoom//lib/spoom/coverage/snapshot.rb#52
+    sig { params(obj: T::Hash[::String, T.untyped]).returns(::Spoom::Coverage::Snapshot) }
+    def from_obj(obj); end
+
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# The strictness name as found in the Sorbet metrics file
+#
+# source://spoom//lib/spoom/coverage/snapshot.rb#30
+Spoom::Coverage::Snapshot::STRICTNESSES = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/coverage/snapshot.rb#95
+class Spoom::Coverage::SnapshotPrinter < ::Spoom::Printer
+  # source://spoom//lib/spoom/coverage/snapshot.rb#99
+  sig { params(snapshot: ::Spoom::Coverage::Snapshot).void }
+  def print_snapshot(snapshot); end
+
+  private
+
+  # source://spoom//lib/spoom/coverage/snapshot.rb#158
+  sig { params(value: T.nilable(::Integer), total: T.nilable(::Integer)).returns(::String) }
+  def percent(value, total); end
+
+  # source://spoom//lib/spoom/coverage/snapshot.rb#147
+  sig { params(hash: T::Hash[::String, ::Integer], total: ::Integer).void }
+  def print_map(hash, total); end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/coverage/report.rb#10
+class Spoom::Coverage::Template
+  abstract!
+
+  # Create a new template from an Erb file path
+  #
+  # source://spoom//lib/spoom/coverage/report.rb#18
+  sig { params(template: ::String).void }
+  def initialize(template:); end
+
+  # source://spoom//lib/spoom/coverage/report.rb#23
+  sig { returns(::String) }
+  def erb; end
+
+  # source://spoom//lib/spoom/coverage/report.rb#33
+  sig { returns(::Binding) }
+  def get_binding; end
+
+  # source://spoom//lib/spoom/coverage/report.rb#28
+  sig { returns(::String) }
+  def html; end
+end
+
+# source://spoom//lib/spoom/deadcode/erb.rb#27
+module Spoom::Deadcode
+  class << self
+    # source://spoom//lib/spoom/deadcode/plugins.rb#75
+    sig { params(context: ::Spoom::Context).returns(T::Array[T.class_of(Spoom::Deadcode::Plugins::Base)]) }
+    def load_custom_plugins(context); end
+
+    # source://spoom//lib/spoom/deadcode/plugins.rb#61
+    sig { params(context: ::Spoom::Context).returns(T::Set[T.class_of(Spoom::Deadcode::Plugins::Base)]) }
+    def plugins_from_gemfile_lock(context); end
+  end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins.rb#26
+Spoom::Deadcode::DEFAULT_CUSTOM_PLUGINS_PATH = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/deadcode/plugins.rb#28
+Spoom::Deadcode::DEFAULT_PLUGINS = T.let(T.unsafe(nil), Set)
+
+# A definition is a class, module, method, constant, etc. being defined in the code
+#
+# source://spoom//lib/spoom/deadcode/definition.rb#7
+class Spoom::Deadcode::Definition < ::T::Struct
+  const :kind, ::Spoom::Deadcode::Definition::Kind
+  const :name, ::String
+  const :full_name, ::String
+  const :location, ::Spoom::Location
+  const :status, ::Spoom::Deadcode::Definition::Status, default: T.unsafe(nil)
+
+  # source://spoom//lib/spoom/deadcode/definition.rb#78
+  sig { void }
+  def alive!; end
+
+  # Status
+  #
+  # source://spoom//lib/spoom/deadcode/definition.rb#73
+  sig { returns(T::Boolean) }
+  def alive?; end
+
+  # Kind
+  #
+  # source://spoom//lib/spoom/deadcode/definition.rb#41
+  sig { returns(T::Boolean) }
+  def attr_reader?; end
+
+  # source://spoom//lib/spoom/deadcode/definition.rb#46
+  sig { returns(T::Boolean) }
+  def attr_writer?; end
+
+  # source://spoom//lib/spoom/deadcode/definition.rb#51
+  sig { returns(T::Boolean) }
+  def class?; end
+
+  # source://spoom//lib/spoom/deadcode/definition.rb#56
+  sig { returns(T::Boolean) }
+  def constant?; end
+
+  # source://spoom//lib/spoom/deadcode/definition.rb#83
+  sig { returns(T::Boolean) }
+  def dead?; end
+
+  # source://spoom//lib/spoom/deadcode/definition.rb#93
+  sig { void }
+  def ignored!; end
+
+  # source://spoom//lib/spoom/deadcode/definition.rb#88
+  sig { returns(T::Boolean) }
+  def ignored?; end
+
+  # source://spoom//lib/spoom/deadcode/definition.rb#61
+  sig { returns(T::Boolean) }
+  def method?; end
+
+  # source://spoom//lib/spoom/deadcode/definition.rb#66
+  sig { returns(T::Boolean) }
+  def module?; end
+
+  # Utils
+  #
+  # source://spoom//lib/spoom/deadcode/definition.rb#100
+  sig { params(args: T.untyped).returns(::String) }
+  def to_json(*args); end
+
+  class << self
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# source://spoom//lib/spoom/deadcode/definition.rb#10
+class Spoom::Deadcode::Definition::Kind < ::T::Enum
+  enums do
+    AttrReader = new
+    AttrWriter = new
+    Class = new
+    Constant = new
+    Method = new
+    Module = new
+  end
+end
+
+# source://spoom//lib/spoom/deadcode/definition.rb#21
+class Spoom::Deadcode::Definition::Status < ::T::Enum
+  enums do
+    ALIVE = new
+    DEAD = new
+    IGNORED = new
+  end
+end
+
+# Custom engine to handle ERB templates as used by Rails
+#
+# source://spoom//lib/spoom/deadcode/erb.rb#29
+class Spoom::Deadcode::ERB < ::Erubi::Engine
+  # source://spoom//lib/spoom/deadcode/erb.rb#33
+  sig { params(input: T.untyped, properties: T.untyped).void }
+  def initialize(input, properties = T.unsafe(nil)); end
+
+  private
+
+  # source://spoom//lib/spoom/deadcode/erb.rb#83
+  sig { override.params(code: T.untyped).void }
+  def add_code(code); end
+
+  # source://spoom//lib/spoom/deadcode/erb.rb#66
+  sig { override.params(indicator: T.untyped, code: T.untyped).void }
+  def add_expression(indicator, code); end
+
+  # source://spoom//lib/spoom/deadcode/erb.rb#89
+  sig { override.params(_: T.untyped).void }
+  def add_postamble(_); end
+
+  # source://spoom//lib/spoom/deadcode/erb.rb#48
+  sig { override.params(text: T.untyped).void }
+  def add_text(text); end
+
+  # source://spoom//lib/spoom/deadcode/erb.rb#95
+  sig { params(src: T.untyped).void }
+  def flush_newline_if_pending(src); end
+end
+
+# source://spoom//lib/spoom/deadcode/erb.rb#63
+Spoom::Deadcode::ERB::BLOCK_EXPR = T.let(T.unsafe(nil), Regexp)
+
+# source://spoom//lib/spoom/deadcode/index.rb#6
+class Spoom::Deadcode::Index
+  # source://spoom//lib/spoom/deadcode/index.rb#29
+  sig { params(model: ::Spoom::Model).void }
+  def initialize(model); end
+
+  # source://spoom//lib/spoom/deadcode/index.rb#219
+  sig { returns(T::Array[::Spoom::Deadcode::Definition]) }
+  def all_definitions; end
+
+  # source://spoom//lib/spoom/deadcode/index.rb#224
+  sig { returns(T::Array[::Spoom::Model::Reference]) }
+  def all_references; end
+
+  # source://spoom//lib/spoom/deadcode/index.rb#99
+  sig { params(plugins: T::Array[::Spoom::Deadcode::Plugins::Base]).void }
+  def apply_plugins!(plugins); end
+
+  # source://spoom//lib/spoom/deadcode/index.rb#79
+  sig { params(definition: ::Spoom::Deadcode::Definition).void }
+  def define(definition); end
+
+  # source://spoom//lib/spoom/deadcode/index.rb#23
+  sig { returns(T::Hash[::String, T::Array[::Spoom::Deadcode::Definition]]) }
+  def definitions; end
+
+  # Utils
+  #
+  # source://spoom//lib/spoom/deadcode/index.rb#214
+  sig { params(name: ::String).returns(T::Array[::Spoom::Deadcode::Definition]) }
+  def definitions_for_name(name); end
+
+  # Mark all definitions having a reference of the same name as `alive`
+  #
+  # To be called once all the files have been indexed and all the definitions and references discovered.
+  #
+  # source://spoom//lib/spoom/deadcode/index.rb#122
+  sig { void }
+  def finalize!; end
+
+  # source://spoom//lib/spoom/deadcode/index.rb#94
+  sig { params(symbol_def: ::Spoom::Model::SymbolDef).void }
+  def ignore(symbol_def); end
+
+  # source://spoom//lib/spoom/deadcode/index.rb#50
+  sig { params(erb: ::String, file: ::String, plugins: T::Array[::Spoom::Deadcode::Plugins::Base]).void }
+  def index_erb(erb, file:, plugins: T.unsafe(nil)); end
+
+  # Indexing
+  #
+  # source://spoom//lib/spoom/deadcode/index.rb#39
+  sig { params(file: ::String, plugins: T::Array[::Spoom::Deadcode::Plugins::Base]).void }
+  def index_file(file, plugins: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/deadcode/index.rb#55
+  sig { params(rb: ::String, file: ::String, plugins: T::Array[::Spoom::Deadcode::Plugins::Base]).void }
+  def index_ruby(rb, file:, plugins: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/deadcode/index.rb#20
+  sig { returns(::Spoom::Model) }
+  def model; end
+
+  # source://spoom//lib/spoom/deadcode/index.rb#84
+  sig { params(name: ::String, location: ::Spoom::Location).void }
+  def reference_constant(name, location); end
+
+  # source://spoom//lib/spoom/deadcode/index.rb#89
+  sig { params(name: ::String, location: ::Spoom::Location).void }
+  def reference_method(name, location); end
+
+  # source://spoom//lib/spoom/deadcode/index.rb#26
+  sig { returns(T::Hash[::String, T::Array[::Spoom::Model::Reference]]) }
+  def references; end
+end
+
+# source://spoom//lib/spoom/deadcode/index.rb#9
+class Spoom::Deadcode::Index::Error < ::Spoom::Error
+  # source://spoom//lib/spoom/deadcode/index.rb#13
+  sig { params(message: ::String, parent: ::Exception).void }
+  def initialize(message, parent:); end
+end
+
+# source://spoom//lib/spoom/deadcode/indexer.rb#6
+class Spoom::Deadcode::Indexer < ::Spoom::Visitor
+  # source://spoom//lib/spoom/deadcode/indexer.rb#16
+  sig do
+    params(
+      path: ::String,
+      index: ::Spoom::Deadcode::Index,
+      plugins: T::Array[::Spoom::Deadcode::Plugins::Base]
+    ).void
+  end
+  def initialize(path, index, plugins: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/deadcode/indexer.rb#13
+  sig { returns(::Spoom::Deadcode::Index) }
+  def index; end
+
+  # source://spoom//lib/spoom/deadcode/indexer.rb#10
+  sig { returns(::String) }
+  def path; end
+
+  # Visit
+  #
+  # source://spoom//lib/spoom/deadcode/indexer.rb#27
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins.rb#36
+Spoom::Deadcode::PLUGINS_FOR_GEM = T.let(T.unsafe(nil), Hash)
+
+# source://spoom//lib/spoom/deadcode/plugins/base.rb#8
+module Spoom::Deadcode::Plugins; end
+
+# source://spoom//lib/spoom/deadcode/plugins/action_mailer.rb#7
+class Spoom::Deadcode::Plugins::ActionMailer < ::Spoom::Deadcode::Plugins::Base
+  # source://spoom//lib/spoom/deadcode/plugins/action_mailer.rb#11
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/action_mailer_preview.rb#7
+class Spoom::Deadcode::Plugins::ActionMailerPreview < ::Spoom::Deadcode::Plugins::Base
+  # source://spoom//lib/spoom/deadcode/plugins/action_mailer_preview.rb#13
+  sig { override.params(definition: ::Spoom::Model::Method).void }
+  def on_define_method(definition); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/actionpack.rb#7
+class Spoom::Deadcode::Plugins::ActionPack < ::Spoom::Deadcode::Plugins::Base
+  # source://spoom//lib/spoom/deadcode/plugins/actionpack.rb#31
+  sig { override.params(definition: ::Spoom::Model::Method).void }
+  def on_define_method(definition); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/actionpack.rb#39
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/actionpack.rb#12
+Spoom::Deadcode::Plugins::ActionPack::CALLBACKS = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/deadcode/plugins/active_job.rb#7
+class Spoom::Deadcode::Plugins::ActiveJob < ::Spoom::Deadcode::Plugins::Base; end
+
+# source://spoom//lib/spoom/deadcode/plugins/active_model.rb#7
+class Spoom::Deadcode::Plugins::ActiveModel < ::Spoom::Deadcode::Plugins::Base
+  # source://spoom//lib/spoom/deadcode/plugins/active_model.rb#14
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/active_record.rb#7
+class Spoom::Deadcode::Plugins::ActiveRecord < ::Spoom::Deadcode::Plugins::Base
+  # source://spoom//lib/spoom/deadcode/plugins/active_record.rb#74
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/active_record.rb#64
+Spoom::Deadcode::Plugins::ActiveRecord::ARRAY_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/deadcode/plugins/active_record.rb#20
+Spoom::Deadcode::Plugins::ActiveRecord::CALLBACKS = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/deadcode/plugins/active_record.rb#49
+Spoom::Deadcode::Plugins::ActiveRecord::CRUD_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/deadcode/plugins/active_support.rb#7
+class Spoom::Deadcode::Plugins::ActiveSupport < ::Spoom::Deadcode::Plugins::Base
+  # source://spoom//lib/spoom/deadcode/plugins/active_support.rb#22
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/active_support.rb#19
+Spoom::Deadcode::Plugins::ActiveSupport::SETUP_AND_TEARDOWN_METHODS = T.let(T.unsafe(nil), Array)
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/deadcode/plugins/base.rb#9
+class Spoom::Deadcode::Plugins::Base
+  abstract!
+
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#132
+  sig { params(index: ::Spoom::Deadcode::Index).void }
+  def initialize(index); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#129
+  sig { returns(::Spoom::Deadcode::Index) }
+  def index; end
+
+  # Do not override this method, use `on_define_accessor` instead.
+  #
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#158
+  sig { params(definition: ::Spoom::Model::Attr).void }
+  def internal_on_define_accessor(definition); end
+
+  # Do not override this method, use `on_define_class` instead.
+  #
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#182
+  sig { params(definition: ::Spoom::Model::Class).void }
+  def internal_on_define_class(definition); end
+
+  # Do not override this method, use `on_define_constant` instead.
+  #
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#212
+  sig { params(definition: ::Spoom::Model::Constant).void }
+  def internal_on_define_constant(definition); end
+
+  # Do not override this method, use `on_define_method` instead.
+  #
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#238
+  sig { params(definition: ::Spoom::Model::Method).void }
+  def internal_on_define_method(definition); end
+
+  # Do not override this method, use `on_define_module` instead.
+  #
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#264
+  sig { params(definition: ::Spoom::Model::Module).void }
+  def internal_on_define_module(definition); end
+
+  # Called when an accessor is defined.
+  #
+  # Will be called when the indexer processes a `attr_reader`, `attr_writer` or `attr_accessor` node.
+  # Note that when this method is called, the definition for the node has already been added to the index.
+  # It is still possible to ignore it from the plugin:
+  #
+  # ~~~rb
+  # class MyPlugin < Spoom::Deadcode::Plugins::Base
+  #   def on_define_accessor(definition)
+  #     @index.ignore(definition) if symbol_def.name == "foo"
+  #   end
+  # end
+  # ~~~
+  #
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#152
+  sig { params(definition: ::Spoom::Model::Attr).void }
+  def on_define_accessor(definition); end
+
+  # Called when a class is defined.
+  #
+  # Will be called when the indexer processes a `class` node.
+  # Note that when this method is called, the definition for the node has already been added to the index.
+  # It is still possible to ignore it from the plugin:
+  #
+  # ~~~rb
+  # class MyPlugin < Spoom::Deadcode::Plugins::Base
+  #   def on_define_class(definition)
+  #     @index.ignore(definition) if definition.name == "Foo"
+  #   end
+  # end
+  # ~~~
+  #
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#176
+  sig { params(definition: ::Spoom::Model::Class).void }
+  def on_define_class(definition); end
+
+  # Called when a constant is defined.
+  #
+  # Will be called when the indexer processes a `CONST =` node.
+  # Note that when this method is called, the definition for the node has already been added to the index.
+  # It is still possible to ignore it from the plugin:
+  #
+  # ~~~rb
+  # class MyPlugin < Spoom::Deadcode::Plugins::Base
+  #   def on_define_constant(definition)
+  #     @index.ignore(definition) if definition.name == "FOO"
+  #   end
+  # end
+  # ~~~
+  #
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#206
+  sig { params(definition: ::Spoom::Model::Constant).void }
+  def on_define_constant(definition); end
+
+  # Called when a method is defined.
+  #
+  # Will be called when the indexer processes a `def` or `defs` node.
+  # Note that when this method is called, the definition for the node has already been added to the index.
+  # It is still possible to ignore it from the plugin:
+  #
+  # ~~~rb
+  # class MyPlugin < Spoom::Deadcode::Plugins::Base
+  #   def on_define_method(definition)
+  #     @index.ignore(definition) if definition.name == "foo"
+  #   end
+  # end
+  # ~~~
+  #
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#232
+  sig { params(definition: ::Spoom::Model::Method).void }
+  def on_define_method(definition); end
+
+  # Called when a module is defined.
+  #
+  # Will be called when the indexer processes a `module` node.
+  # Note that when this method is called, the definition for the node has already been added to the index.
+  # It is still possible to ignore it from the plugin:
+  #
+  # ~~~rb
+  # class MyPlugin < Spoom::Deadcode::Plugins::Base
+  #   def on_define_module(definition)
+  #     @index.ignore(definition) if definition.name == "Foo"
+  #   end
+  # end
+  # ~~~
+  #
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#258
+  sig { params(definition: ::Spoom::Model::Module).void }
+  def on_define_module(definition); end
+
+  # Called when a send is being processed
+  #
+  # ~~~rb
+  # class MyPlugin < Spoom::Deadcode::Plugins::Base
+  #   def on_send(send)
+  #     return unless send.name == "dsl_method"
+  #     return if send.args.empty?
+  #
+  #     method_name = send.args.first.slice.delete_prefix(":")
+  #     @index.reference_method(method_name, send.node, send.loc)
+  #   end
+  # end
+  # ~~~
+  #
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#284
+  sig { params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+
+  private
+
+  # Plugin utils
+  #
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#352
+  sig { params(name: ::String).returns(::String) }
+  def camelize(name); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#301
+  sig { params(name: T.nilable(::String)).returns(T::Boolean) }
+  def ignored_class_name?(name); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#320
+  sig { params(name: ::String).returns(T::Boolean) }
+  def ignored_constant_name?(name); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#325
+  sig { params(name: ::String).returns(T::Boolean) }
+  def ignored_method_name?(name); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#330
+  sig { params(name: ::String).returns(T::Boolean) }
+  def ignored_module_name?(name); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#335
+  sig { params(name: ::String, names_variable: ::Symbol, patterns_variable: ::Symbol).returns(T::Boolean) }
+  def ignored_name?(name, names_variable, patterns_variable); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#308
+  sig { params(definition: ::Spoom::Model::Class).returns(T::Boolean) }
+  def ignored_subclass?(definition); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#340
+  sig { params(const: ::Symbol).returns(T::Set[::String]) }
+  def names(const); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#345
+  sig { params(const: ::Symbol).returns(T::Array[::Regexp]) }
+  def patterns(const); end
+
+  # DSL support
+  #
+  # source://spoom//lib/spoom/deadcode/plugins/base.rb#293
+  sig { params(definition: ::Spoom::Model::Namespace, superclass_name: ::String).returns(T::Boolean) }
+  def subclass_of?(definition, superclass_name); end
+
+  class << self
+    # Mark classes directly subclassing a class matching `names` as ignored.
+    #
+    # Names can be either strings or regexps:
+    #
+    # ~~~rb
+    # class MyPlugin < Spoom::Deadcode::Plugins::Base
+    #   ignore_classes_inheriting_from(
+    #     "Foo",
+    #     "Bar",
+    #     /Baz.*/,
+    #   )
+    # end
+    # ~~~
+    #
+    # source://spoom//lib/spoom/deadcode/plugins/base.rb#52
+    sig { params(names: T.any(::Regexp, ::String)).void }
+    def ignore_classes_inheriting_from(*names); end
+
+    # Mark classes matching `names` as ignored.
+    #
+    # Names can be either strings or regexps:
+    #
+    # ~~~rb
+    # class MyPlugin < Spoom::Deadcode::Plugins::Base
+    #   ignore_class_names(
+    #     "Foo",
+    #     "Bar",
+    #     /Baz.*/,
+    #   )
+    # end
+    # ~~~
+    #
+    # source://spoom//lib/spoom/deadcode/plugins/base.rb#34
+    sig { params(names: T.any(::Regexp, ::String)).void }
+    def ignore_classes_named(*names); end
+
+    # Mark constants matching `names` as ignored.
+    #
+    # Names can be either strings or regexps:
+    #
+    # ~~~rb
+    # class MyPlugin < Spoom::Deadcode::Plugins::Base
+    #   ignore_class_names(
+    #     "FOO",
+    #     "BAR",
+    #     /BAZ.*/,
+    #   )
+    # end
+    # ~~~
+    #
+    # source://spoom//lib/spoom/deadcode/plugins/base.rb#70
+    sig { params(names: T.any(::Regexp, ::String)).void }
+    def ignore_constants_named(*names); end
+
+    # Mark methods matching `names` as ignored.
+    #
+    # Names can be either strings or regexps:
+    #
+    # ~~~rb
+    # class MyPlugin < Spoom::Deadcode::Plugins::Base
+    #   ignore_method_names(
+    #     "foo",
+    #     "bar",
+    #     /baz.*/,
+    #   )
+    # end
+    # ~~~
+    #
+    # source://spoom//lib/spoom/deadcode/plugins/base.rb#88
+    sig { params(names: T.any(::Regexp, ::String)).void }
+    def ignore_methods_named(*names); end
+
+    # Mark modules matching `names` as ignored.
+    #
+    # Names can be either strings or regexps:
+    #
+    # ~~~rb
+    # class MyPlugin < Spoom::Deadcode::Plugins::Base
+    #   ignore_class_names(
+    #     "Foo",
+    #     "Bar",
+    #     /Baz.*/,
+    #   )
+    # end
+    # ~~~
+    #
+    # source://spoom//lib/spoom/deadcode/plugins/base.rb#106
+    sig { params(names: T.any(::Regexp, ::String)).void }
+    def ignore_modules_named(*names); end
+
+    private
+
+    # source://spoom//lib/spoom/deadcode/plugins/base.rb#113
+    sig do
+      params(
+        names: T::Array[T.any(::Regexp, ::String)],
+        names_variable: ::Symbol,
+        patterns_variable: ::Symbol
+      ).void
+    end
+    def save_names_and_patterns(names, names_variable, patterns_variable); end
+  end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/graphql.rb#7
+class Spoom::Deadcode::Plugins::GraphQL < ::Spoom::Deadcode::Plugins::Base
+  # source://spoom//lib/spoom/deadcode/plugins/graphql.rb#28
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/minitest.rb#7
+class Spoom::Deadcode::Plugins::Minitest < ::Spoom::Deadcode::Plugins::Base
+  # source://spoom//lib/spoom/deadcode/plugins/minitest.rb#22
+  sig { override.params(definition: ::Spoom::Model::Method).void }
+  def on_define_method(definition); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/minitest.rb#28
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/namespaces.rb#7
+class Spoom::Deadcode::Plugins::Namespaces < ::Spoom::Deadcode::Plugins::Base
+  # source://spoom//lib/spoom/deadcode/plugins/namespaces.rb#11
+  sig { override.params(definition: ::Spoom::Model::Class).void }
+  def on_define_class(definition); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/namespaces.rb#16
+  sig { override.params(definition: ::Spoom::Model::Module).void }
+  def on_define_module(definition); end
+
+  private
+
+  # source://spoom//lib/spoom/deadcode/plugins/namespaces.rb#23
+  sig { params(symbol_def: ::Spoom::Model::Namespace).returns(T::Boolean) }
+  def used_as_namespace?(symbol_def); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/rspec.rb#7
+class Spoom::Deadcode::Plugins::RSpec < ::Spoom::Deadcode::Plugins::Base; end
+
+# source://spoom//lib/spoom/deadcode/plugins/rails.rb#7
+class Spoom::Deadcode::Plugins::Rails < ::Spoom::Deadcode::Plugins::Base
+  # source://spoom//lib/spoom/deadcode/plugins/rails.rb#13
+  sig { override.params(definition: ::Spoom::Model::Class).void }
+  def on_define_class(definition); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/rails.rb#18
+  sig { override.params(definition: ::Spoom::Model::Module).void }
+  def on_define_module(definition); end
+
+  private
+
+  # source://spoom//lib/spoom/deadcode/plugins/rails.rb#25
+  sig { params(symbol_def: ::Spoom::Model::Namespace).returns(T::Boolean) }
+  def file_is_helper?(symbol_def); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/rake.rb#7
+class Spoom::Deadcode::Plugins::Rake < ::Spoom::Deadcode::Plugins::Base; end
+
+# source://spoom//lib/spoom/deadcode/plugins/rubocop.rb#7
+class Spoom::Deadcode::Plugins::Rubocop < ::Spoom::Deadcode::Plugins::Base
+  # source://spoom//lib/spoom/deadcode/plugins/rubocop.rb#18
+  sig { override.params(definition: ::Spoom::Model::Constant).void }
+  def on_define_constant(definition); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/rubocop.rb#26
+  sig { override.params(definition: ::Spoom::Model::Method).void }
+  def on_define_method(definition); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/rubocop.rb#10
+Spoom::Deadcode::Plugins::Rubocop::RUBOCOP_CONSTANTS = T.let(T.unsafe(nil), Set)
+
+# source://spoom//lib/spoom/deadcode/plugins/ruby.rb#7
+class Spoom::Deadcode::Plugins::Ruby < ::Spoom::Deadcode::Plugins::Base
+  # source://spoom//lib/spoom/deadcode/plugins/ruby.rb#24
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+
+  private
+
+  # source://spoom//lib/spoom/deadcode/plugins/ruby.rb#46
+  sig { params(send: ::Spoom::Deadcode::Send, node: ::Prism::Node).void }
+  def reference_symbol_as_constant(send, node); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/sorbet.rb#7
+class Spoom::Deadcode::Plugins::Sorbet < ::Spoom::Deadcode::Plugins::Base
+  # source://spoom//lib/spoom/deadcode/plugins/sorbet.rb#11
+  sig { override.params(definition: ::Spoom::Model::Constant).void }
+  def on_define_constant(definition); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/sorbet.rb#16
+  sig { override.params(definition: ::Spoom::Model::Method).void }
+  def on_define_method(definition); end
+
+  private
+
+  # source://spoom//lib/spoom/deadcode/plugins/sorbet.rb#28
+  sig { params(definition: ::Spoom::Model::Constant).returns(T::Boolean) }
+  def sorbet_enum_constant?(definition); end
+
+  # source://spoom//lib/spoom/deadcode/plugins/sorbet.rb#23
+  sig { params(definition: ::Spoom::Model::Constant).returns(T::Boolean) }
+  def sorbet_type_member?(definition); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/thor.rb#7
+class Spoom::Deadcode::Plugins::Thor < ::Spoom::Deadcode::Plugins::Base
+  # source://spoom//lib/spoom/deadcode/plugins/thor.rb#13
+  sig { override.params(definition: ::Spoom::Model::Method).void }
+  def on_define_method(definition); end
+end
+
+# source://spoom//lib/spoom/deadcode/remover.rb#6
+class Spoom::Deadcode::Remover
+  # source://spoom//lib/spoom/deadcode/remover.rb#12
+  sig { params(context: ::Spoom::Context).void }
+  def initialize(context); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#17
+  sig { params(kind: T.nilable(::Spoom::Deadcode::Definition::Kind), location: ::Spoom::Location).returns(::String) }
+  def remove_location(kind, location); end
+end
+
+# source://spoom//lib/spoom/deadcode/remover.rb#9
+class Spoom::Deadcode::Remover::Error < ::Spoom::Error; end
+
+# source://spoom//lib/spoom/deadcode/remover.rb#372
+class Spoom::Deadcode::Remover::NodeContext
+  # source://spoom//lib/spoom/deadcode/remover.rb#392
+  sig do
+    params(
+      source: ::String,
+      comments: T::Hash[::Integer, ::Prism::Comment],
+      node: ::Prism::Node,
+      nesting: T::Array[::Prism::Node]
+    ).void
+  end
+  def initialize(source, comments, node, nesting); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#506
+  sig { params(node: ::Prism::Node).returns(T::Array[::Prism::Comment]) }
+  def attached_comments(node); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#534
+  sig { returns(T.nilable(::Prism::CallNode)) }
+  def attached_sig; end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#521
+  sig { returns(T::Array[::Prism::Node]) }
+  def attached_sigs; end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#376
+  sig { returns(T::Hash[::Integer, ::Prism::Comment]) }
+  def comments; end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#494
+  sig { params(start_line: ::Integer, end_line: ::Integer).returns(T::Array[::Prism::Comment]) }
+  def comments_between_lines(start_line, end_line); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#382
+  sig { returns(T::Array[::Prism::Node]) }
+  def nesting; end
+
+  # @return [Array<Prism::Node>]
+  #
+  # source://spoom//lib/spoom/deadcode/remover.rb#382
+  def nesting=(_arg0); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#444
+  sig { returns(T.nilable(::Prism::Node)) }
+  def next_node; end
+
+  # @raise [Error]
+  #
+  # source://spoom//lib/spoom/deadcode/remover.rb#433
+  sig { returns(T::Array[::Prism::Node]) }
+  def next_nodes; end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#379
+  sig { returns(::Prism::Node) }
+  def node; end
+
+  # @raise [Error]
+  #
+  # source://spoom//lib/spoom/deadcode/remover.rb#408
+  sig { returns(::Spoom::Deadcode::Remover::NodeContext) }
+  def parent_context; end
+
+  # @raise [Error]
+  #
+  # source://spoom//lib/spoom/deadcode/remover.rb#400
+  sig { returns(::Prism::Node) }
+  def parent_node; end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#428
+  sig { returns(T.nilable(::Prism::Node)) }
+  def previous_node; end
+
+  # @raise [Error]
+  #
+  # source://spoom//lib/spoom/deadcode/remover.rb#417
+  sig { returns(T::Array[::Prism::Node]) }
+  def previous_nodes; end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#449
+  sig { returns(T.nilable(::Spoom::Deadcode::Remover::NodeContext)) }
+  def sclass_context; end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#482
+  sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+  def sorbet_extend_sig?(node); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#477
+  sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+  def sorbet_signature?(node); end
+end
+
+# source://spoom//lib/spoom/deadcode/remover.rb#549
+class Spoom::Deadcode::Remover::NodeFinder < ::Spoom::Visitor
+  # source://spoom//lib/spoom/deadcode/remover.rb#621
+  sig { params(location: ::Spoom::Location, kind: T.nilable(::Spoom::Deadcode::Definition::Kind)).void }
+  def initialize(location, kind); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#615
+  sig { returns(T.nilable(::Prism::Node)) }
+  def node; end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#618
+  sig { returns(T::Array[::Prism::Node]) }
+  def nodes_nesting; end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#630
+  sig { override.params(node: T.nilable(::Prism::Node)).void }
+  def visit(node); end
+
+  class << self
+    # source://spoom//lib/spoom/deadcode/remover.rb#556
+    sig do
+      params(
+        source: ::String,
+        location: ::Spoom::Location,
+        kind: T.nilable(::Spoom::Deadcode::Definition::Kind)
+      ).returns(::Spoom::Deadcode::Remover::NodeContext)
+    end
+    def find(source, location, kind); end
+
+    # source://spoom//lib/spoom/deadcode/remover.rb#590
+    sig { params(node: ::Prism::Node, kind: ::Spoom::Deadcode::Definition::Kind).returns(T::Boolean) }
+    def node_match_kind?(node, kind); end
+  end
+end
+
+# source://spoom//lib/spoom/deadcode/remover.rb#29
+class Spoom::Deadcode::Remover::NodeRemover
+  # source://spoom//lib/spoom/deadcode/remover.rb#36
+  sig do
+    params(
+      source: ::String,
+      kind: T.nilable(::Spoom::Deadcode::Definition::Kind),
+      location: ::Spoom::Location
+    ).void
+  end
+  def initialize(source, kind, location); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#46
+  sig { void }
+  def apply_edit; end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#33
+  sig { returns(::String) }
+  def new_source; end
+
+  private
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#153
+  sig { params(context: ::Spoom::Deadcode::Remover::NodeContext).void }
+  def delete_attr_accessor(context); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#331
+  sig { params(start_char: ::Integer, end_char: ::Integer).void }
+  def delete_chars(start_char, end_char); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#73
+  sig { params(context: ::Spoom::Deadcode::Remover::NodeContext).void }
+  def delete_constant_assignment(context); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#324
+  sig { params(start_line: ::Integer, end_line: ::Integer).void }
+  def delete_lines(start_line, end_line); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#261
+  sig { params(context: ::Spoom::Deadcode::Remover::NodeContext).void }
+  def delete_node_and_comments_and_sigs(context); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#218
+  sig do
+    params(
+      node: ::Prism::Node,
+      send_context: ::Spoom::Deadcode::Remover::NodeContext,
+      was_removed: T::Boolean
+    ).void
+  end
+  def insert_accessor(node, send_context, was_removed:); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#336
+  sig { params(start_char: ::Integer, end_char: ::Integer, replacement: ::String).void }
+  def replace_chars(start_char, end_char, replacement); end
+
+  # source://spoom//lib/spoom/deadcode/remover.rb#341
+  sig do
+    params(
+      node: ::Prism::CallNode,
+      name: ::String,
+      kind: T.nilable(::Spoom::Deadcode::Definition::Kind)
+    ).returns(::String)
+  end
+  def transform_sig(node, name:, kind:); end
+end
+
+# An abstraction to simplify handling of Prism::CallNode nodes.
+#
+# source://spoom//lib/spoom/deadcode/send.rb#7
+class Spoom::Deadcode::Send < ::T::Struct
+  const :node, ::Prism::CallNode
+  const :name, ::String
+  const :recv, T.nilable(::Prism::Node), default: T.unsafe(nil)
+  const :args, T::Array[::Prism::Node], default: T.unsafe(nil)
+  const :block, T.nilable(::Prism::Node), default: T.unsafe(nil)
+  const :location, ::Spoom::Location
+
+  # source://spoom//lib/spoom/deadcode/send.rb#22
+  sig do
+    type_parameters(:T)
+      .params(
+        arg_type: T::Class[T.type_parameter(:T)],
+        block: T.proc.params(arg: T.type_parameter(:T)).void
+      ).void
+  end
+  def each_arg(arg_type, &block); end
+
+  # source://spoom//lib/spoom/deadcode/send.rb#29
+  sig { params(block: T.proc.params(key: ::Prism::Node, value: T.nilable(::Prism::Node)).void).void }
+  def each_arg_assoc(&block); end
+
+  class << self
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# source://spoom//lib/spoom.rb#12
+class Spoom::Error < ::StandardError; end
+
+# source://spoom//lib/spoom/context/exec.rb#5
+class Spoom::ExecResult < ::T::Struct
+  const :out, ::String
+  const :err, T.nilable(::String)
+  const :status, T::Boolean
+  const :exit_code, ::Integer
+
+  # source://spoom//lib/spoom/context/exec.rb#14
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# source://spoom//lib/spoom/file_collector.rb#5
+class Spoom::FileCollector
+  # Initialize a new file collector
+  #
+  # If `allow_extensions` is empty, all files are collected.
+  # If `allow_extensions` is an array of extensions, only files with one of these extensions are collected.
+  #
+  # If `allow_mime_types` is empty, all files are collected.
+  # If `allow_mime_types` is an array of mimetypes, files without an extension are collected if their mimetype is in
+  # the list.
+  #
+  # source://spoom//lib/spoom/file_collector.rb#26
+  sig do
+    params(
+      allow_extensions: T::Array[::String],
+      allow_mime_types: T::Array[::String],
+      exclude_patterns: T::Array[::String]
+    ).void
+  end
+  def initialize(allow_extensions: T.unsafe(nil), allow_mime_types: T.unsafe(nil), exclude_patterns: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/file_collector.rb#9
+  sig { returns(T::Array[::String]) }
+  def files; end
+
+  # source://spoom//lib/spoom/file_collector.rb#39
+  sig { params(path: ::String).void }
+  def visit_path(path); end
+
+  # source://spoom//lib/spoom/file_collector.rb#34
+  sig { params(paths: T::Array[::String]).void }
+  def visit_paths(paths); end
+
+  private
+
+  # source://spoom//lib/spoom/file_collector.rb#56
+  sig { params(path: ::String).returns(::String) }
+  def clean_path(path); end
+
+  # source://spoom//lib/spoom/file_collector.rb#73
+  sig { params(path: ::String).returns(T::Boolean) }
+  def excluded_file?(path); end
+
+  # source://spoom//lib/spoom/file_collector.rb#88
+  sig { params(path: ::String).returns(T::Boolean) }
+  def excluded_path?(path); end
+
+  # source://spoom//lib/spoom/file_collector.rb#97
+  sig { params(path: ::String).returns(T.nilable(::String)) }
+  def mime_type_for(path); end
+
+  # source://spoom//lib/spoom/file_collector.rb#68
+  sig { params(path: ::String).void }
+  def visit_directory(path); end
+
+  # source://spoom//lib/spoom/file_collector.rb#61
+  sig { params(path: ::String).void }
+  def visit_file(path); end
+end
+
+# Build a file hierarchy from a set of file paths.
+#
+# source://spoom//lib/spoom/file_tree.rb#6
+class Spoom::FileTree
+  # source://spoom//lib/spoom/file_tree.rb#10
+  sig { params(paths: T::Enumerable[::String]).void }
+  def initialize(paths = T.unsafe(nil)); end
+
+  # Add a `path` to the tree
+  #
+  # This will create all nodes until the root of `path`.
+  #
+  # source://spoom//lib/spoom/file_tree.rb#25
+  sig { params(path: ::String).returns(::Spoom::FileTree::Node) }
+  def add_path(path); end
+
+  # Add all `paths` to the tree
+  #
+  # source://spoom//lib/spoom/file_tree.rb#17
+  sig { params(paths: T::Enumerable[::String]).void }
+  def add_paths(paths); end
+
+  # All the nodes in this tree
+  #
+  # source://spoom//lib/spoom/file_tree.rb#45
+  sig { returns(T::Array[::Spoom::FileTree::Node]) }
+  def nodes; end
+
+  # Return a map of typing scores for each node in the tree
+  #
+  # source://spoom//lib/spoom/file_tree.rb#59
+  sig { params(context: ::Spoom::Context).returns(T::Hash[::Spoom::FileTree::Node, ::Float]) }
+  def nodes_strictness_scores(context); end
+
+  # All the paths in this tree
+  #
+  # source://spoom//lib/spoom/file_tree.rb#53
+  sig { returns(T::Array[::String]) }
+  def paths; end
+
+  # Return a map of typing scores for each path in the tree
+  #
+  # source://spoom//lib/spoom/file_tree.rb#67
+  sig { params(context: ::Spoom::Context).returns(T::Hash[::String, ::Float]) }
+  def paths_strictness_scores(context); end
+
+  # source://spoom//lib/spoom/file_tree.rb#72
+  sig { params(out: T.any(::IO, ::StringIO), colors: T::Boolean).void }
+  def print(out: T.unsafe(nil), colors: T.unsafe(nil)); end
+
+  # All root nodes
+  #
+  # source://spoom//lib/spoom/file_tree.rb#39
+  sig { returns(T::Array[::Spoom::FileTree::Node]) }
+  def roots; end
+end
+
+# A visitor that collects all the nodes in a tree
+#
+# source://spoom//lib/spoom/file_tree.rb#124
+class Spoom::FileTree::CollectNodes < ::Spoom::FileTree::Visitor
+  # source://spoom//lib/spoom/file_tree.rb#131
+  sig { void }
+  def initialize; end
+
+  # source://spoom//lib/spoom/file_tree.rb#128
+  sig { returns(T::Array[::Spoom::FileTree::Node]) }
+  def nodes; end
+
+  # source://spoom//lib/spoom/file_tree.rb#137
+  sig { override.params(node: ::Spoom::FileTree::Node).void }
+  def visit_node(node); end
+end
+
+# A visitor that collects the typing score of each node in a tree
+#
+# source://spoom//lib/spoom/file_tree.rb#167
+class Spoom::FileTree::CollectScores < ::Spoom::FileTree::CollectStrictnesses
+  # source://spoom//lib/spoom/file_tree.rb#174
+  sig { params(context: ::Spoom::Context).void }
+  def initialize(context); end
+
+  # source://spoom//lib/spoom/file_tree.rb#171
+  sig { returns(T::Hash[::Spoom::FileTree::Node, ::Float]) }
+  def scores; end
+
+  # source://spoom//lib/spoom/file_tree.rb#181
+  sig { override.params(node: ::Spoom::FileTree::Node).void }
+  def visit_node(node); end
+
+  private
+
+  # source://spoom//lib/spoom/file_tree.rb#190
+  sig { params(node: ::Spoom::FileTree::Node).returns(::Float) }
+  def node_score(node); end
+
+  # source://spoom//lib/spoom/file_tree.rb#199
+  sig { params(strictness: T.nilable(::String)).returns(::Float) }
+  def strictness_score(strictness); end
+end
+
+# A visitor that collects the strictness of each node in a tree
+#
+# source://spoom//lib/spoom/file_tree.rb#144
+class Spoom::FileTree::CollectStrictnesses < ::Spoom::FileTree::Visitor
+  # source://spoom//lib/spoom/file_tree.rb#151
+  sig { params(context: ::Spoom::Context).void }
+  def initialize(context); end
+
+  # source://spoom//lib/spoom/file_tree.rb#148
+  sig { returns(T::Hash[::Spoom::FileTree::Node, T.nilable(::String)]) }
+  def strictnesses; end
+
+  # source://spoom//lib/spoom/file_tree.rb#158
+  sig { override.params(node: ::Spoom::FileTree::Node).void }
+  def visit_node(node); end
+end
+
+# A node representing either a file or a directory inside a FileTree
+#
+# source://spoom//lib/spoom/file_tree.rb#78
+class Spoom::FileTree::Node < ::T::Struct
+  const :parent, T.nilable(::Spoom::FileTree::Node)
+  const :name, ::String
+  const :children, T::Hash[::String, ::Spoom::FileTree::Node], default: T.unsafe(nil)
+
+  # Full path to this node from root
+  #
+  # source://spoom//lib/spoom/file_tree.rb#92
+  sig { returns(::String) }
+  def path; end
+
+  class << self
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# An internal class used to print a FileTree
+#
+# See `FileTree#print`
+#
+# source://spoom//lib/spoom/file_tree.rb#212
+class Spoom::FileTree::Printer < ::Spoom::FileTree::Visitor
+  # source://spoom//lib/spoom/file_tree.rb#222
+  sig do
+    params(
+      strictnesses: T::Hash[::Spoom::FileTree::Node, T.nilable(::String)],
+      out: T.any(::IO, ::StringIO),
+      colors: T::Boolean
+    ).void
+  end
+  def initialize(strictnesses, out: T.unsafe(nil), colors: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/file_tree.rb#230
+  sig { override.params(node: ::Spoom::FileTree::Node).void }
+  def visit_node(node); end
+
+  private
+
+  # source://spoom//lib/spoom/file_tree.rb#255
+  sig { params(strictness: T.nilable(::String)).returns(::Spoom::Color) }
+  def strictness_color(strictness); end
+end
+
+# An abstract visitor for FileTree
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/file_tree.rb#101
+class Spoom::FileTree::Visitor
+  abstract!
+
+  # source://spoom//lib/spoom/file_tree.rb#113
+  sig { params(node: ::Spoom::FileTree::Node).void }
+  def visit_node(node); end
+
+  # source://spoom//lib/spoom/file_tree.rb#118
+  sig { params(nodes: T::Array[::Spoom::FileTree::Node]).void }
+  def visit_nodes(nodes); end
+
+  # source://spoom//lib/spoom/file_tree.rb#108
+  sig { params(tree: ::Spoom::FileTree).void }
+  def visit_tree(tree); end
+end
+
+# source://spoom//lib/spoom/context/git.rb#5
+module Spoom::Git; end
+
+# source://spoom//lib/spoom/context/git.rb#6
+class Spoom::Git::Commit < ::T::Struct
+  const :sha, ::String
+  const :time, ::Time
+
+  # source://spoom//lib/spoom/context/git.rb#27
+  sig { returns(::Integer) }
+  def timestamp; end
+
+  class << self
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+
+    # Parse a line formatted as `%h %at` into a `Commit`
+    #
+    # source://spoom//lib/spoom/context/git.rb#14
+    sig { params(string: ::String).returns(T.nilable(::Spoom::Git::Commit)) }
+    def parse_line(string); end
+  end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/base.rb#5
+module Spoom::LSP; end
+
+# source://spoom//lib/spoom/sorbet/lsp.rb#13
+class Spoom::LSP::Client
+  # source://spoom//lib/spoom/sorbet/lsp.rb#17
+  sig { params(sorbet_bin: ::String, sorbet_args: ::String, path: ::String).void }
+  def initialize(sorbet_bin, *sorbet_args, path: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/sorbet/lsp.rb#229
+  sig { void }
+  def close; end
+
+  # source://spoom//lib/spoom/sorbet/lsp.rb#131
+  sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::Location]) }
+  def definitions(uri, line, column); end
+
+  # source://spoom//lib/spoom/sorbet/lsp.rb#212
+  sig { params(uri: ::String).returns(T::Array[::Spoom::LSP::DocumentSymbol]) }
+  def document_symbols(uri); end
+
+  # source://spoom//lib/spoom/sorbet/lsp.rb#89
+  sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T.nilable(::Spoom::LSP::Hover)) }
+  def hover(uri, line, column); end
+
+  # source://spoom//lib/spoom/sorbet/lsp.rb#27
+  sig { returns(::Integer) }
+  def next_id; end
+
+  # LSP requests
+  #
+  # @raise [Error::AlreadyOpen]
+  #
+  # source://spoom//lib/spoom/sorbet/lsp.rb#72
+  sig { params(workspace_path: ::String).void }
+  def open(workspace_path); end
+
+  # source://spoom//lib/spoom/sorbet/lsp.rb#54
+  sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+  def read; end
+
+  # @raise [Error::BadHeaders]
+  #
+  # source://spoom//lib/spoom/sorbet/lsp.rb#43
+  sig { returns(T.nilable(::String)) }
+  def read_raw; end
+
+  # source://spoom//lib/spoom/sorbet/lsp.rb#173
+  sig do
+    params(
+      uri: ::String,
+      line: ::Integer,
+      column: ::Integer,
+      include_decl: T::Boolean
+    ).returns(T::Array[::Spoom::LSP::Location])
+  end
+  def references(uri, line, column, include_decl = T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/sorbet/lsp.rb#37
+  sig { params(message: ::Spoom::LSP::Message).returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+  def send(message); end
+
+  # source://spoom//lib/spoom/sorbet/lsp.rb#32
+  sig { params(json_string: ::String).void }
+  def send_raw(json_string); end
+
+  # source://spoom//lib/spoom/sorbet/lsp.rb#110
+  sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::SignatureHelp]) }
+  def signatures(uri, line, column); end
+
+  # source://spoom//lib/spoom/sorbet/lsp.rb#197
+  sig { params(query: ::String).returns(T::Array[::Spoom::LSP::DocumentSymbol]) }
+  def symbols(query); end
+
+  # source://spoom//lib/spoom/sorbet/lsp.rb#152
+  sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::Location]) }
+  def type_definitions(uri, line, column); end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#178
+class Spoom::LSP::Diagnostic < ::T::Struct
+  include ::Spoom::LSP::PrintableSymbol
+
+  const :range, ::Spoom::LSP::Range
+  const :code, ::Integer
+  const :message, ::String
+  const :information, ::Object
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#202
+  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#207
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    # source://spoom//lib/spoom/sorbet/lsp/structures.rb#191
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Diagnostic) }
+    def from_json(json); end
+
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#212
+class Spoom::LSP::DocumentSymbol < ::T::Struct
+  include ::Spoom::LSP::PrintableSymbol
+
+  const :name, ::String
+  const :detail, T.nilable(::String)
+  const :kind, ::Integer
+  const :location, T.nilable(::Spoom::LSP::Location)
+  const :range, T.nilable(::Spoom::LSP::Range)
+  const :children, T::Array[::Spoom::LSP::DocumentSymbol]
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#240
+  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#272
+  sig { returns(::String) }
+  def kind_string; end
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#267
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    # source://spoom//lib/spoom/sorbet/lsp/structures.rb#227
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::DocumentSymbol) }
+    def from_json(json); end
+
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#276
+Spoom::LSP::DocumentSymbol::SYMBOL_KINDS = T.let(T.unsafe(nil), Hash)
+
+# source://spoom//lib/spoom/sorbet/lsp/errors.rb#6
+class Spoom::LSP::Error < ::Spoom::Error; end
+
+# source://spoom//lib/spoom/sorbet/lsp/errors.rb#7
+class Spoom::LSP::Error::AlreadyOpen < ::Spoom::LSP::Error; end
+
+# source://spoom//lib/spoom/sorbet/lsp/errors.rb#8
+class Spoom::LSP::Error::BadHeaders < ::Spoom::LSP::Error; end
+
+# source://spoom//lib/spoom/sorbet/lsp/errors.rb#10
+class Spoom::LSP::Error::Diagnostics < ::Spoom::LSP::Error
+  # source://spoom//lib/spoom/sorbet/lsp/errors.rb#32
+  sig { params(uri: ::String, diagnostics: T::Array[::Spoom::LSP::Diagnostic]).void }
+  def initialize(uri, diagnostics); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/errors.rb#17
+  sig { returns(T::Array[::Spoom::LSP::Diagnostic]) }
+  def diagnostics; end
+
+  # source://spoom//lib/spoom/sorbet/lsp/errors.rb#14
+  sig { returns(::String) }
+  def uri; end
+
+  class << self
+    # source://spoom//lib/spoom/sorbet/lsp/errors.rb#23
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Error::Diagnostics) }
+    def from_json(json); end
+  end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#19
+class Spoom::LSP::Hover < ::T::Struct
+  include ::Spoom::LSP::PrintableSymbol
+
+  const :contents, ::String
+  const :range, T.nilable(T::Range[T.untyped])
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#39
+  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#45
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    # source://spoom//lib/spoom/sorbet/lsp/structures.rb#30
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Hover) }
+    def from_json(json); end
+
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#112
+class Spoom::LSP::Location < ::T::Struct
+  include ::Spoom::LSP::PrintableSymbol
+
+  const :uri, ::String
+  const :range, ::Spoom::LSP::Range
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#132
+  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#138
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    # source://spoom//lib/spoom/sorbet/lsp/structures.rb#123
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Location) }
+    def from_json(json); end
+
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# A general message as defined by JSON-RPC.
+#
+# The language server protocol always uses `"2.0"` as the `jsonrpc` version.
+#
+# source://spoom//lib/spoom/sorbet/lsp/base.rb#12
+class Spoom::LSP::Message
+  # source://spoom//lib/spoom/sorbet/lsp/base.rb#16
+  sig { void }
+  def initialize; end
+
+  # source://spoom//lib/spoom/sorbet/lsp/base.rb#21
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def as_json; end
+
+  # source://spoom//lib/spoom/sorbet/lsp/base.rb#29
+  sig { params(args: T.untyped).returns(::String) }
+  def to_json(*args); end
+end
+
+# A notification message.
+#
+# A processed notification message must not send a response back. They work like events.
+#
+# source://spoom//lib/spoom/sorbet/lsp/base.rb#58
+class Spoom::LSP::Notification < ::Spoom::LSP::Message
+  # source://spoom//lib/spoom/sorbet/lsp/base.rb#68
+  sig { params(method: ::String, params: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(method, params); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/base.rb#62
+  sig { returns(::String) }
+  def method; end
+
+  # source://spoom//lib/spoom/sorbet/lsp/base.rb#65
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def params; end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#50
+class Spoom::LSP::Position < ::T::Struct
+  include ::Spoom::LSP::PrintableSymbol
+
+  const :line, ::Integer
+  const :char, ::Integer
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#70
+  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#75
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    # source://spoom//lib/spoom/sorbet/lsp/structures.rb#61
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Position) }
+    def from_json(json); end
+
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# @abstract Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#9
+module Spoom::LSP::PrintableSymbol
+  interface!
+
+  # @abstract
+  #
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#16
+  sig { abstract.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#80
+class Spoom::LSP::Range < ::T::Struct
+  include ::Spoom::LSP::PrintableSymbol
+
+  const :start, ::Spoom::LSP::Position
+  const :end, ::Spoom::LSP::Position
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#100
+  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#107
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    # source://spoom//lib/spoom/sorbet/lsp/structures.rb#91
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Range) }
+    def from_json(json); end
+
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# A request message to describe a request between the client and the server.
+#
+# Every processed request must send a response back to the sender of the request.
+#
+# source://spoom//lib/spoom/sorbet/lsp/base.rb#37
+class Spoom::LSP::Request < ::Spoom::LSP::Message
+  # source://spoom//lib/spoom/sorbet/lsp/base.rb#47
+  sig { params(id: ::Integer, method: ::String, params: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(id, method, params); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/base.rb#41
+  sig { returns(::Integer) }
+  def id; end
+
+  # source://spoom//lib/spoom/sorbet/lsp/base.rb#44
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def params; end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/errors.rb#40
+class Spoom::LSP::ResponseError < ::Spoom::LSP::Error
+  # source://spoom//lib/spoom/sorbet/lsp/errors.rb#63
+  sig { params(code: ::Integer, message: ::String, data: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(code, message, data); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/errors.rb#44
+  sig { returns(::Integer) }
+  def code; end
+
+  # source://spoom//lib/spoom/sorbet/lsp/errors.rb#47
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def data; end
+
+  class << self
+    # source://spoom//lib/spoom/sorbet/lsp/errors.rb#53
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::ResponseError) }
+    def from_json(json); end
+  end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#143
+class Spoom::LSP::SignatureHelp < ::T::Struct
+  include ::Spoom::LSP::PrintableSymbol
+
+  const :label, T.nilable(::String)
+  const :doc, ::Object
+  const :params, T::Array[T.untyped]
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#165
+  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#173
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    # source://spoom//lib/spoom/sorbet/lsp/structures.rb#155
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::SignatureHelp) }
+    def from_json(json); end
+
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#309
+class Spoom::LSP::SymbolPrinter < ::Spoom::Printer
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#326
+  sig do
+    params(
+      out: T.any(::IO, ::StringIO),
+      colors: T::Boolean,
+      indent_level: ::Integer,
+      prefix: T.nilable(::String)
+    ).void
+  end
+  def initialize(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil), prefix: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#348
+  sig { params(uri: ::String).returns(::String) }
+  def clean_uri(uri); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#316
+  sig { returns(T.nilable(::String)) }
+  def prefix; end
+
+  # @return [String, nil]
+  #
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#316
+  def prefix=(_arg0); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#356
+  sig { params(objects: T::Array[::Spoom::LSP::PrintableSymbol]).void }
+  def print_list(objects); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#336
+  sig { params(object: T.nilable(::Spoom::LSP::PrintableSymbol)).void }
+  def print_object(object); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#343
+  sig { params(objects: T::Array[::Spoom::LSP::PrintableSymbol]).void }
+  def print_objects(objects); end
+
+  # source://spoom//lib/spoom/sorbet/lsp/structures.rb#313
+  sig { returns(T::Set[::Integer]) }
+  def seen; end
+end
+
+# source://spoom//lib/spoom/location.rb#5
+class Spoom::Location
+  include ::Comparable
+
+  # @raise [LocationError]
+  #
+  # source://spoom//lib/spoom/location.rb#73
+  sig do
+    params(
+      file: ::String,
+      start_line: T.nilable(::Integer),
+      start_column: T.nilable(::Integer),
+      end_line: T.nilable(::Integer),
+      end_column: T.nilable(::Integer)
+    ).void
+  end
+  def initialize(file, start_line: T.unsafe(nil), start_column: T.unsafe(nil), end_line: T.unsafe(nil), end_column: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/location.rb#106
+  sig { override.params(other: ::BasicObject).returns(T.nilable(::Integer)) }
+  def <=>(other); end
+
+  # @return [Integer, nil]
+  #
+  # source://spoom//lib/spoom/location.rb#62
+  def end_column; end
+
+  # @return [Integer, nil]
+  #
+  # source://spoom//lib/spoom/location.rb#62
+  def end_line; end
+
+  # source://spoom//lib/spoom/location.rb#59
+  sig { returns(::String) }
+  def file; end
+
+  # source://spoom//lib/spoom/location.rb#93
+  sig { params(other: ::Spoom::Location).returns(T::Boolean) }
+  def include?(other); end
+
+  # @return [Integer, nil]
+  #
+  # source://spoom//lib/spoom/location.rb#62
+  def start_column; end
+
+  # source://spoom//lib/spoom/location.rb#62
+  sig { returns(T.nilable(::Integer)) }
+  def start_line; end
+
+  # source://spoom//lib/spoom/location.rb#129
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    # source://spoom//lib/spoom/location.rb#47
+    sig { params(file: ::String, location: ::Prism::Location).returns(::Spoom::Location) }
+    def from_prism(file, location); end
+
+    # @raise [LocationError]
+    #
+    # source://spoom//lib/spoom/location.rb#16
+    sig { params(location_string: ::String).returns(::Spoom::Location) }
+    def from_string(location_string); end
+  end
+end
+
+# source://spoom//lib/spoom/location.rb#10
+class Spoom::Location::LocationError < ::Spoom::Error; end
+
+# source://spoom//lib/spoom/model/model.rb#5
+class Spoom::Model
+  # source://spoom//lib/spoom/model/model.rb#238
+  sig { void }
+  def initialize; end
+
+  # Get a symbol by it's full name
+  #
+  # Raises an error if the symbol is not found
+  #
+  # @raise [Error]
+  #
+  # source://spoom//lib/spoom/model/model.rb#247
+  sig { params(full_name: ::String).returns(::Spoom::Model::Symbol) }
+  def [](full_name); end
+
+  # source://spoom//lib/spoom/model/model.rb#296
+  sig { void }
+  def finalize!; end
+
+  # Register a new symbol by it's full name
+  #
+  # If the symbol already exists, it will be returned.
+  #
+  # source://spoom//lib/spoom/model/model.rb#258
+  sig { params(full_name: ::String).returns(::Spoom::Model::Symbol) }
+  def register_symbol(full_name); end
+
+  # source://spoom//lib/spoom/model/model.rb#263
+  sig { params(full_name: ::String, context: ::Spoom::Model::Symbol).returns(::Spoom::Model::Symbol) }
+  def resolve_symbol(full_name, context:); end
+
+  # source://spoom//lib/spoom/model/model.rb#290
+  sig { params(symbol: ::Spoom::Model::Symbol).returns(T::Array[::Spoom::Model::Symbol]) }
+  def subtypes(symbol); end
+
+  # source://spoom//lib/spoom/model/model.rb#284
+  sig { params(symbol: ::Spoom::Model::Symbol).returns(T::Array[::Spoom::Model::Symbol]) }
+  def supertypes(symbol); end
+
+  # All the symbols registered in this model
+  #
+  # source://spoom//lib/spoom/model/model.rb#232
+  sig { returns(T::Hash[::String, ::Spoom::Model::Symbol]) }
+  def symbols; end
+
+  # source://spoom//lib/spoom/model/model.rb#235
+  sig { returns(Spoom::Poset[::Spoom::Model::Symbol]) }
+  def symbols_hierarchy; end
+
+  private
+
+  # source://spoom//lib/spoom/model/model.rb#303
+  sig { void }
+  def compute_symbols_hierarchy!; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/model/model.rb#179
+class Spoom::Model::Attr < ::Spoom::Model::Property
+  abstract!
+end
+
+# source://spoom//lib/spoom/model/model.rb#185
+class Spoom::Model::AttrAccessor < ::Spoom::Model::Attr; end
+
+# source://spoom//lib/spoom/model/model.rb#183
+class Spoom::Model::AttrReader < ::Spoom::Model::Attr; end
+
+# source://spoom//lib/spoom/model/model.rb#184
+class Spoom::Model::AttrWriter < ::Spoom::Model::Attr; end
+
+# Populate a Model by visiting the nodes from a Ruby file
+#
+# source://spoom//lib/spoom/model/builder.rb#7
+class Spoom::Model::Builder < ::Spoom::Model::NamespaceVisitor
+  # source://spoom//lib/spoom/model/builder.rb#11
+  sig { params(model: ::Spoom::Model, file: ::String).void }
+  def initialize(model, file); end
+
+  # Accessors
+  #
+  # source://spoom//lib/spoom/model/builder.rb#146
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  # Classes
+  #
+  # source://spoom//lib/spoom/model/builder.rb#24
+  sig { override.params(node: ::Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  # Constants
+  #
+  # source://spoom//lib/spoom/model/builder.rb#71
+  sig { override.params(node: ::Prism::ConstantPathWriteNode).void }
+  def visit_constant_path_write_node(node); end
+
+  # source://spoom//lib/spoom/model/builder.rb#92
+  sig { override.params(node: ::Prism::ConstantWriteNode).void }
+  def visit_constant_write_node(node); end
+
+  # Methods
+  #
+  # source://spoom//lib/spoom/model/builder.rb#127
+  sig { override.params(node: ::Prism::DefNode).void }
+  def visit_def_node(node); end
+
+  # Modules
+  #
+  # source://spoom//lib/spoom/model/builder.rb#55
+  sig { override.params(node: ::Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  # source://spoom//lib/spoom/model/builder.rb#106
+  sig { override.params(node: ::Prism::MultiWriteNode).void }
+  def visit_multi_write_node(node); end
+
+  # source://spoom//lib/spoom/model/builder.rb#39
+  sig { override.params(node: ::Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  private
+
+  # source://spoom//lib/spoom/model/builder.rb#234
+  sig { returns(T::Array[::Spoom::Model::Sig]) }
+  def collect_sigs; end
+
+  # source://spoom//lib/spoom/model/builder.rb#229
+  sig { returns(::Spoom::Model::Visibility) }
+  def current_visibility; end
+
+  # source://spoom//lib/spoom/model/builder.rb#241
+  sig { params(node: ::Prism::Node).returns(::Spoom::Location) }
+  def node_location(node); end
+end
+
+# source://spoom//lib/spoom/model/model.rb#117
+class Spoom::Model::Class < ::Spoom::Model::Namespace
+  # source://spoom//lib/spoom/model/model.rb#129
+  sig do
+    params(
+      symbol: ::Spoom::Model::Symbol,
+      owner: T.nilable(::Spoom::Model::Namespace),
+      location: ::Spoom::Location,
+      superclass_name: T.nilable(::String)
+    ).void
+  end
+  def initialize(symbol, owner:, location:, superclass_name: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/model/model.rb#119
+  sig { returns(T.nilable(::String)) }
+  def superclass_name; end
+
+  # @return [String, nil]
+  #
+  # source://spoom//lib/spoom/model/model.rb#119
+  def superclass_name=(_arg0); end
+end
+
+# source://spoom//lib/spoom/model/model.rb#138
+class Spoom::Model::Constant < ::Spoom::Model::SymbolDef
+  # source://spoom//lib/spoom/model/model.rb#143
+  sig do
+    params(
+      symbol: ::Spoom::Model::Symbol,
+      owner: T.nilable(::Spoom::Model::Namespace),
+      location: ::Spoom::Location,
+      value: ::String
+    ).void
+  end
+  def initialize(symbol, owner:, location:, value:); end
+
+  # source://spoom//lib/spoom/model/model.rb#140
+  sig { returns(::String) }
+  def value; end
+end
+
+# source://spoom//lib/spoom/model/model.rb#8
+class Spoom::Model::Error < ::Spoom::Error; end
+
+# source://spoom//lib/spoom/model/model.rb#213
+class Spoom::Model::Extend < ::Spoom::Model::Mixin; end
+
+# source://spoom//lib/spoom/model/model.rb#211
+class Spoom::Model::Include < ::Spoom::Model::Mixin; end
+
+# source://spoom//lib/spoom/model/model.rb#177
+class Spoom::Model::Method < ::Spoom::Model::Property; end
+
+# A mixin (include, prepend, extend) to a namespace
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/model/model.rb#196
+class Spoom::Model::Mixin
+  abstract!
+
+  # source://spoom//lib/spoom/model/model.rb#206
+  sig { params(name: ::String).void }
+  def initialize(name); end
+
+  # source://spoom//lib/spoom/model/model.rb#203
+  sig { returns(::String) }
+  def name; end
+end
+
+# source://spoom//lib/spoom/model/model.rb#136
+class Spoom::Model::Module < ::Spoom::Model::Namespace; end
+
+# A class or module
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/model/model.rb#97
+class Spoom::Model::Namespace < ::Spoom::Model::SymbolDef
+  abstract!
+
+  # source://spoom//lib/spoom/model/model.rb#107
+  sig do
+    params(
+      symbol: ::Spoom::Model::Symbol,
+      owner: T.nilable(::Spoom::Model::Namespace),
+      location: ::Spoom::Location
+    ).void
+  end
+  def initialize(symbol, owner:, location:); end
+
+  # source://spoom//lib/spoom/model/model.rb#101
+  sig { returns(T::Array[::Spoom::Model::SymbolDef]) }
+  def children; end
+
+  # source://spoom//lib/spoom/model/model.rb#104
+  sig { returns(T::Array[::Spoom::Model::Mixin]) }
+  def mixins; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/model/namespace_visitor.rb#6
+class Spoom::Model::NamespaceVisitor < ::Spoom::Visitor
+  abstract!
+
+  # source://spoom//lib/spoom/model/namespace_visitor.rb#12
+  sig { void }
+  def initialize; end
+
+  # source://spoom//lib/spoom/model/namespace_visitor.rb#19
+  sig { override.params(node: T.nilable(::Prism::Node)).void }
+  def visit(node); end
+end
+
+# source://spoom//lib/spoom/model/model.rb#212
+class Spoom::Model::Prepend < ::Spoom::Model::Mixin; end
+
+# A method or an attribute accessor
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/model/model.rb#151
+class Spoom::Model::Property < ::Spoom::Model::SymbolDef
+  abstract!
+
+  # source://spoom//lib/spoom/model/model.rb#169
+  sig do
+    params(
+      symbol: ::Spoom::Model::Symbol,
+      owner: T.nilable(::Spoom::Model::Namespace),
+      location: ::Spoom::Location,
+      visibility: ::Spoom::Model::Visibility,
+      sigs: T::Array[::Spoom::Model::Sig]
+    ).void
+  end
+  def initialize(symbol, owner:, location:, visibility:, sigs: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/model/model.rb#158
+  sig { returns(T::Array[::Spoom::Model::Sig]) }
+  def sigs; end
+
+  # source://spoom//lib/spoom/model/model.rb#155
+  sig { returns(::Spoom::Model::Visibility) }
+  def visibility; end
+end
+
+# A reference to something that looks like a constant or a method
+#
+# Constants could be classes, modules, or actual constants.
+# Methods could be accessors, instance or class methods, aliases, etc.
+#
+# source://spoom//lib/spoom/model/reference.rb#10
+class Spoom::Model::Reference < ::T::Struct
+  const :kind, ::Spoom::Model::Reference::Kind
+  const :name, ::String
+  const :location, ::Spoom::Location
+
+  # source://spoom//lib/spoom/model/reference.rb#39
+  sig { returns(T::Boolean) }
+  def constant?; end
+
+  # source://spoom//lib/spoom/model/reference.rb#44
+  sig { returns(T::Boolean) }
+  def method?; end
+
+  class << self
+    # source://spoom//lib/spoom/model/reference.rb#24
+    sig { params(name: ::String, location: ::Spoom::Location).returns(::Spoom::Model::Reference) }
+    def constant(name, location); end
+
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+
+    # source://spoom//lib/spoom/model/reference.rb#29
+    sig { params(name: ::String, location: ::Spoom::Location).returns(::Spoom::Model::Reference) }
+    def method(name, location); end
+  end
+end
+
+# source://spoom//lib/spoom/model/reference.rb#13
+class Spoom::Model::Reference::Kind < ::T::Enum
+  enums do
+    Constant = new
+    Method = new
+  end
+end
+
+# Visit a file to collect all the references to constants and methods
+#
+# source://spoom//lib/spoom/model/references_visitor.rb#7
+class Spoom::Model::ReferencesVisitor < ::Spoom::Visitor
+  # source://spoom//lib/spoom/model/references_visitor.rb#14
+  sig { params(file: ::String).void }
+  def initialize(file); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#11
+  sig { returns(T::Array[::Spoom::Model::Reference]) }
+  def references; end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#22
+  sig { override.params(node: ::Prism::AliasMethodNode).void }
+  def visit_alias_method_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#27
+  sig { override.params(node: ::Prism::AndNode).void }
+  def visit_and_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#33
+  sig { override.params(node: ::Prism::BlockArgumentNode).void }
+  def visit_block_argument_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#44
+  sig { override.params(node: ::Prism::CallAndWriteNode).void }
+  def visit_call_and_write_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#68
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#52
+  sig { override.params(node: ::Prism::CallOperatorWriteNode).void }
+  def visit_call_operator_write_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#60
+  sig { override.params(node: ::Prism::CallOrWriteNode).void }
+  def visit_call_or_write_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#85
+  sig { override.params(node: ::Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#91
+  sig { override.params(node: ::Prism::ConstantAndWriteNode).void }
+  def visit_constant_and_write_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#97
+  sig { override.params(node: ::Prism::ConstantOperatorWriteNode).void }
+  def visit_constant_operator_write_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#103
+  sig { override.params(node: ::Prism::ConstantOrWriteNode).void }
+  def visit_constant_or_write_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#109
+  sig { override.params(node: ::Prism::ConstantPathNode).void }
+  def visit_constant_path_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#115
+  sig { override.params(node: ::Prism::ConstantPathWriteNode).void }
+  def visit_constant_path_write_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#121
+  sig { override.params(node: ::Prism::ConstantReadNode).void }
+  def visit_constant_read_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#126
+  sig { override.params(node: ::Prism::ConstantWriteNode).void }
+  def visit_constant_write_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#131
+  sig { override.params(node: ::Prism::LocalVariableAndWriteNode).void }
+  def visit_local_variable_and_write_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#139
+  sig { override.params(node: ::Prism::LocalVariableOperatorWriteNode).void }
+  def visit_local_variable_operator_write_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#147
+  sig { override.params(node: ::Prism::LocalVariableOrWriteNode).void }
+  def visit_local_variable_or_write_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#155
+  sig { override.params(node: ::Prism::LocalVariableWriteNode).void }
+  def visit_local_variable_write_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#161
+  sig { override.params(node: ::Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#166
+  sig { override.params(node: ::Prism::MultiWriteNode).void }
+  def visit_multi_write_node(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#177
+  sig { override.params(node: ::Prism::OrNode).void }
+  def visit_or_node(node); end
+
+  private
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#195
+  sig { params(node: ::Prism::Node).returns(::Spoom::Location) }
+  def node_location(node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#185
+  sig { params(name: ::String, node: ::Prism::Node).void }
+  def reference_constant(name, node); end
+
+  # source://spoom//lib/spoom/model/references_visitor.rb#190
+  sig { params(name: ::String, node: ::Prism::Node).void }
+  def reference_method(name, node); end
+end
+
+# A Sorbet signature (sig block)
+#
+# source://spoom//lib/spoom/model/model.rb#216
+class Spoom::Model::Sig
+  # source://spoom//lib/spoom/model/model.rb#223
+  sig { params(string: ::String).void }
+  def initialize(string); end
+
+  # source://spoom//lib/spoom/model/model.rb#220
+  sig { returns(::String) }
+  def string; end
+end
+
+# source://spoom//lib/spoom/model/model.rb#115
+class Spoom::Model::SingletonClass < ::Spoom::Model::Namespace; end
+
+# A Symbol is a uniquely named entity in the Ruby codebase
+#
+# A symbol can have multiple definitions, e.g. a class can be reopened.
+# Sometimes a symbol can have multiple definitions of different types,
+# e.g. `foo` method can be defined both as a method and as an attribute accessor.
+#
+# source://spoom//lib/spoom/model/model.rb#15
+class Spoom::Model::Symbol
+  # source://spoom//lib/spoom/model/model.rb#27
+  sig { params(full_name: ::String).void }
+  def initialize(full_name); end
+
+  # The definitions of this symbol (where it exists in the code)
+  #
+  # source://spoom//lib/spoom/model/model.rb#24
+  sig { returns(T::Array[::Spoom::Model::SymbolDef]) }
+  def definitions; end
+
+  # The full, unique name of this symbol
+  #
+  # source://spoom//lib/spoom/model/model.rb#20
+  sig { returns(::String) }
+  def full_name; end
+
+  # The short name of this symbol
+  #
+  # source://spoom//lib/spoom/model/model.rb#34
+  sig { returns(::String) }
+  def name; end
+
+  # source://spoom//lib/spoom/model/model.rb#39
+  sig { returns(::String) }
+  def to_s; end
+end
+
+# A SymbolDef is a definition of a Symbol
+#
+# It can be a class, module, constant, method, etc.
+# A SymbolDef has a location pointing to the actual code that defines the symbol.
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/model/model.rb#55
+class Spoom::Model::SymbolDef
+  abstract!
+
+  # source://spoom//lib/spoom/model/model.rb#74
+  sig do
+    params(
+      symbol: ::Spoom::Model::Symbol,
+      owner: T.nilable(::Spoom::Model::Namespace),
+      location: ::Spoom::Location
+    ).void
+  end
+  def initialize(symbol, owner:, location:); end
+
+  # The full name of the symbol this definition belongs to
+  #
+  # source://spoom//lib/spoom/model/model.rb#85
+  sig { returns(::String) }
+  def full_name; end
+
+  # The actual code location of this definition
+  #
+  # source://spoom//lib/spoom/model/model.rb#71
+  sig { returns(::Spoom::Location) }
+  def location; end
+
+  # The short name of the symbol this definition belongs to
+  #
+  # source://spoom//lib/spoom/model/model.rb#91
+  sig { returns(::String) }
+  def name; end
+
+  # The enclosing namespace this definition belongs to
+  #
+  # source://spoom//lib/spoom/model/model.rb#67
+  sig { returns(T.nilable(::Spoom::Model::Namespace)) }
+  def owner; end
+
+  # The symbol this definition belongs to
+  #
+  # source://spoom//lib/spoom/model/model.rb#63
+  sig { returns(::Spoom::Model::Symbol) }
+  def symbol; end
+end
+
+# source://spoom//lib/spoom/model/model.rb#44
+class Spoom::Model::UnresolvedSymbol < ::Spoom::Model::Symbol
+  # source://spoom//lib/spoom/model/model.rb#46
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+# source://spoom//lib/spoom/model/model.rb#187
+class Spoom::Model::Visibility < ::T::Enum
+  enums do
+    Private = new
+    Protected = new
+    Public = new
+  end
+end
+
+# source://spoom//lib/spoom/parse.rb#7
+class Spoom::ParseError < ::Spoom::Error; end
+
+# A Poset is a set of elements with a partial order relation.
+#
+# The partial order relation is a binary relation that is reflexive, antisymmetric, and transitive.
+# It can be used to represent a hierarchy of classes or modules, the dependencies between gems, etc.
+#
+# source://spoom//lib/spoom/poset.rb#9
+class Spoom::Poset
+  extend T::Generic
+
+  E = type_member { { upper: Object } }
+
+  # source://spoom//lib/spoom/poset.rb#18
+  sig { void }
+  def initialize; end
+
+  # Get the POSet element for a given value
+  #
+  # Raises if the element is not found
+  #
+  # @raise [Error]
+  #
+  # source://spoom//lib/spoom/poset.rb#26
+  sig { params(value: E).returns(Spoom::Poset::Element[E]) }
+  def [](value); end
+
+  # Add a direct edge from one element to another
+  #
+  # Transitive edges (transitive closure) are automatically computed.
+  # Adds the elements if they don't exist.
+  # If the direct edge already exists, nothing is done.
+  #
+  # source://spoom//lib/spoom/poset.rb#54
+  sig { params(from: E, to: E).void }
+  def add_direct_edge(from, to); end
+
+  # Add an element to the POSet
+  #
+  # source://spoom//lib/spoom/poset.rb#35
+  sig { params(value: E).returns(Spoom::Poset::Element[E]) }
+  def add_element(value); end
+
+  # Is there a direct edge from `from` to `to`?
+  #
+  # source://spoom//lib/spoom/poset.rb#101
+  sig { params(from: E, to: E).returns(T::Boolean) }
+  def direct_edge?(from, to); end
+
+  # Is there an edge (direct or indirect) from `from` to `to`?
+  #
+  # source://spoom//lib/spoom/poset.rb#92
+  sig { params(from: E, to: E).returns(T::Boolean) }
+  def edge?(from, to); end
+
+  # Is the given value a element in the POSet?
+  #
+  # source://spoom//lib/spoom/poset.rb#44
+  sig { params(value: E).returns(T::Boolean) }
+  def element?(value); end
+
+  # Show the POSet as a DOT graph using xdot (used for debugging)
+  #
+  # source://spoom//lib/spoom/poset.rb#107
+  sig { params(direct: T::Boolean, transitive: T::Boolean).void }
+  def show_dot(direct: T.unsafe(nil), transitive: T.unsafe(nil)); end
+
+  # Return the POSet as a DOT graph
+  #
+  # source://spoom//lib/spoom/poset.rb#116
+  sig { params(direct: T::Boolean, transitive: T::Boolean).returns(::String) }
+  def to_dot(direct: T.unsafe(nil), transitive: T.unsafe(nil)); end
+end
+
+# An element in a POSet
+#
+# source://spoom//lib/spoom/poset.rb#136
+class Spoom::Poset::Element
+  extend T::Generic
+  include ::Comparable
+
+  E = type_member { { upper: Object } }
+
+  # source://spoom//lib/spoom/poset.rb#152
+  sig { params(value: E).void }
+  def initialize(value); end
+
+  # source://spoom//lib/spoom/poset.rb#161
+  sig { params(other: T.untyped).returns(T.nilable(::Integer)) }
+  def <=>(other); end
+
+  # Direct and indirect ancestors of this element
+  #
+  # source://spoom//lib/spoom/poset.rb#180
+  sig { returns(T::Array[E]) }
+  def ancestors; end
+
+  # Direct children of this element
+  #
+  # source://spoom//lib/spoom/poset.rb#186
+  sig { returns(T::Array[E]) }
+  def children; end
+
+  # Direct and indirect descendants of this element
+  #
+  # source://spoom//lib/spoom/poset.rb#192
+  sig { returns(T::Array[E]) }
+  def descendants; end
+
+  # Edges (direct and indirect) from this element to other elements in the same POSet
+  #
+  # @return [Set<Element[E]>]
+  #
+  # source://spoom//lib/spoom/poset.rb#149
+  def dfroms; end
+
+  # Edges (direct and indirect) from this element to other elements in the same POSet
+  #
+  # source://spoom//lib/spoom/poset.rb#149
+  sig { returns(T::Set[Spoom::Poset::Element[E]]) }
+  def dtos; end
+
+  # Edges (direct and indirect) from this element to other elements in the same POSet
+  #
+  # @return [Set<Element[E]>]
+  #
+  # source://spoom//lib/spoom/poset.rb#149
+  def froms; end
+
+  # Direct parents of this element
+  #
+  # source://spoom//lib/spoom/poset.rb#174
+  sig { returns(T::Array[E]) }
+  def parents; end
+
+  # Edges (direct and indirect) from this element to other elements in the same POSet
+  #
+  # @return [Set<Element[E]>]
+  #
+  # source://spoom//lib/spoom/poset.rb#149
+  def tos; end
+
+  # The value held by this element
+  #
+  # source://spoom//lib/spoom/poset.rb#145
+  sig { returns(E) }
+  def value; end
+end
+
+# source://spoom//lib/spoom/poset.rb#13
+class Spoom::Poset::Error < ::Spoom::Error; end
+
+# source://spoom//lib/spoom/printer.rb#7
+class Spoom::Printer
+  include ::Spoom::Colorize
+
+  # source://spoom//lib/spoom/printer.rb#17
+  sig { params(out: T.any(::IO, ::StringIO), colors: T::Boolean, indent_level: ::Integer).void }
+  def initialize(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end
+
+  # Colorize `string` with color if `@colors`
+  #
+  # source://spoom//lib/spoom/printer.rb#78
+  sig { params(string: ::String, color: ::Spoom::Color).returns(::String) }
+  def colorize(string, *color); end
+
+  # Decrease indent level
+  #
+  # source://spoom//lib/spoom/printer.rb#31
+  sig { void }
+  def dedent; end
+
+  # Increase indent level
+  #
+  # source://spoom//lib/spoom/printer.rb#25
+  sig { void }
+  def indent; end
+
+  # source://spoom//lib/spoom/printer.rb#14
+  sig { returns(T.any(::IO, ::StringIO)) }
+  def out; end
+
+  # @return [IO, StringIO]
+  #
+  # source://spoom//lib/spoom/printer.rb#14
+  def out=(_arg0); end
+
+  # Print `string` into `out`
+  #
+  # source://spoom//lib/spoom/printer.rb#37
+  sig { params(string: T.nilable(::String)).void }
+  def print(string); end
+
+  # Print `string` colored with `color` into `out`
+  #
+  # Does not use colors unless `@colors`.
+  #
+  # source://spoom//lib/spoom/printer.rb#47
+  sig { params(string: T.nilable(::String), color: ::Spoom::Color).void }
+  def print_colored(string, *color); end
+
+  # Print `string` with indent and newline
+  #
+  # source://spoom//lib/spoom/printer.rb#62
+  sig { params(string: T.nilable(::String)).void }
+  def printl(string); end
+
+  # Print a new line into `out`
+  #
+  # source://spoom//lib/spoom/printer.rb#56
+  sig { void }
+  def printn; end
+
+  # Print an indent space into `out`
+  #
+  # source://spoom//lib/spoom/printer.rb#72
+  sig { void }
+  def printt; end
+end
+
+# source://spoom//lib/spoom.rb#10
+Spoom::SPOOM_PATH = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/config.rb#5
+module Spoom::Sorbet; end
+
+# source://spoom//lib/spoom/sorbet.rb#39
+Spoom::Sorbet::BIN_PATH = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet.rb#36
+Spoom::Sorbet::CONFIG_PATH = T.let(T.unsafe(nil), String)
+
+# Parse Sorbet config files
+#
+# Parses a Sorbet config file:
+#
+# ```ruby
+# config = Spoom::Sorbet::Config.parse_file("sorbet/config")
+# puts config.paths   # "."
+# ```
+#
+# Parses a Sorbet config string:
+#
+# ```ruby
+# config = Spoom::Sorbet::Config.parse_string(<<~CONFIG)
+#   a
+#   --file=b
+#   --ignore=c
+# CONFIG
+# puts config.paths   # "a", "b"
+# puts config.ignore  # "c"
+# ```
+#
+# source://spoom//lib/spoom/sorbet/config.rb#26
+class Spoom::Sorbet::Config
+  # source://spoom//lib/spoom/sorbet/config.rb#38
+  sig { void }
+  def initialize; end
+
+  # @return [Array<String>]
+  #
+  # source://spoom//lib/spoom/sorbet/config.rb#32
+  def allowed_extensions; end
+
+  # @return [Array<String>]
+  #
+  # source://spoom//lib/spoom/sorbet/config.rb#32
+  def allowed_extensions=(_arg0); end
+
+  # source://spoom//lib/spoom/sorbet/config.rb#46
+  sig { returns(::Spoom::Sorbet::Config) }
+  def copy; end
+
+  # @return [Array<String>]
+  #
+  # source://spoom//lib/spoom/sorbet/config.rb#32
+  def ignore; end
+
+  # @return [Array<String>]
+  #
+  # source://spoom//lib/spoom/sorbet/config.rb#32
+  def ignore=(_arg0); end
+
+  # source://spoom//lib/spoom/sorbet/config.rb#35
+  sig { returns(T::Boolean) }
+  def no_stdlib; end
+
+  # @return [Boolean]
+  #
+  # source://spoom//lib/spoom/sorbet/config.rb#35
+  def no_stdlib=(_arg0); end
+
+  # Returns self as a string of options that can be passed to Sorbet
+  #
+  # Example:
+  # ~~~rb
+  # config = Sorbet::Config.new
+  # config.paths << "/foo"
+  # config.paths << "/bar"
+  # config.ignore << "/baz"
+  # config.allowed_extensions << ".rb"
+  #
+  # puts config.options_string # "/foo /bar --ignore /baz --allowed-extension .rb"
+  # ~~~
+  #
+  # source://spoom//lib/spoom/sorbet/config.rb#68
+  sig { returns(::String) }
+  def options_string; end
+
+  # source://spoom//lib/spoom/sorbet/config.rb#32
+  sig { returns(T::Array[::String]) }
+  def paths; end
+
+  # @return [Array<String>]
+  #
+  # source://spoom//lib/spoom/sorbet/config.rb#32
+  def paths=(_arg0); end
+
+  class << self
+    # source://spoom//lib/spoom/sorbet/config.rb#81
+    sig { params(sorbet_config_path: ::String).returns(::Spoom::Sorbet::Config) }
+    def parse_file(sorbet_config_path); end
+
+    # source://spoom//lib/spoom/sorbet/config.rb#86
+    sig { params(sorbet_config: ::String).returns(::Spoom::Sorbet::Config) }
+    def parse_string(sorbet_config); end
+
+    private
+
+    # source://spoom//lib/spoom/sorbet/config.rb#150
+    sig { params(line: ::String).returns(::String) }
+    def parse_option(line); end
+  end
+end
+
+# source://spoom//lib/spoom/sorbet/config.rb#29
+Spoom::Sorbet::Config::DEFAULT_ALLOWED_EXTENSIONS = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/sorbet.rb#14
+class Spoom::Sorbet::Error < ::Spoom::Error
+  # source://spoom//lib/spoom/sorbet.rb#29
+  sig { params(message: ::String, result: ::Spoom::ExecResult).void }
+  def initialize(message, result); end
+
+  # source://spoom//lib/spoom/sorbet.rb#21
+  sig { returns(::Spoom::ExecResult) }
+  def result; end
+end
+
+# source://spoom//lib/spoom/sorbet.rb#17
+class Spoom::Sorbet::Error::Killed < ::Spoom::Sorbet::Error; end
+
+# source://spoom//lib/spoom/sorbet.rb#18
+class Spoom::Sorbet::Error::Segfault < ::Spoom::Sorbet::Error; end
+
+# source://spoom//lib/spoom/sorbet/errors.rb#6
+module Spoom::Sorbet::Errors
+  class << self
+    # source://spoom//lib/spoom/sorbet/errors.rb#13
+    sig { params(errors: T::Array[::Spoom::Sorbet::Errors::Error]).returns(T::Array[::Spoom::Sorbet::Errors::Error]) }
+    def sort_errors_by_code(errors); end
+  end
+end
+
+# source://spoom//lib/spoom/sorbet/errors.rb#7
+Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/errors.rb#127
+class Spoom::Sorbet::Errors::Error
+  include ::Comparable
+
+  # source://spoom//lib/spoom/sorbet/errors.rb#153
+  sig do
+    params(
+      file: T.nilable(::String),
+      line: T.nilable(::Integer),
+      message: T.nilable(::String),
+      code: T.nilable(::Integer),
+      more: T::Array[::String]
+    ).void
+  end
+  def initialize(file, line, message, code, more = T.unsafe(nil)); end
+
+  # By default errors are sorted by location
+  #
+  # source://spoom//lib/spoom/sorbet/errors.rb#164
+  sig { params(other: T.untyped).returns(::Integer) }
+  def <=>(other); end
+
+  # @return [Integer, nil]
+  #
+  # source://spoom//lib/spoom/sorbet/errors.rb#135
+  def code; end
+
+  # source://spoom//lib/spoom/sorbet/errors.rb#132
+  sig { returns(T.nilable(::String)) }
+  def file; end
+
+  # Other files associated with the error
+  #
+  # source://spoom//lib/spoom/sorbet/errors.rb#142
+  sig { returns(T::Set[::String]) }
+  def files_from_error_sections; end
+
+  # source://spoom//lib/spoom/sorbet/errors.rb#135
+  sig { returns(T.nilable(::Integer)) }
+  def line; end
+
+  # @return [String, nil]
+  #
+  # source://spoom//lib/spoom/sorbet/errors.rb#132
+  def message; end
+
+  # source://spoom//lib/spoom/sorbet/errors.rb#138
+  sig { returns(T::Array[::String]) }
+  def more; end
+
+  # source://spoom//lib/spoom/sorbet/errors.rb#171
+  sig { returns(::String) }
+  def to_s; end
+end
+
+# Parse errors from Sorbet output
+#
+# source://spoom//lib/spoom/sorbet/errors.rb#18
+class Spoom::Sorbet::Errors::Parser
+  # source://spoom//lib/spoom/sorbet/errors.rb#45
+  sig { params(error_url_base: ::String).void }
+  def initialize(error_url_base: T.unsafe(nil)); end
+
+  # source://spoom//lib/spoom/sorbet/errors.rb#52
+  sig { params(output: ::String).returns(T::Array[::Spoom::Sorbet::Errors::Error]) }
+  def parse(output); end
+
+  private
+
+  # @raise [ParseError]
+  #
+  # source://spoom//lib/spoom/sorbet/errors.rb#116
+  sig { params(line: ::String).void }
+  def append_error(line); end
+
+  # @raise [ParseError]
+  #
+  # source://spoom//lib/spoom/sorbet/errors.rb#108
+  sig { void }
+  def close_error; end
+
+  # source://spoom//lib/spoom/sorbet/errors.rb#75
+  sig { params(error_url_base: ::String).returns(::Regexp) }
+  def error_line_match_regexp(error_url_base); end
+
+  # source://spoom//lib/spoom/sorbet/errors.rb#92
+  sig { params(line: ::String).returns(T.nilable(::Spoom::Sorbet::Errors::Error)) }
+  def match_error_line(line); end
+
+  # @raise [ParseError]
+  #
+  # source://spoom//lib/spoom/sorbet/errors.rb#101
+  sig { params(error: ::Spoom::Sorbet::Errors::Error).void }
+  def open_error(error); end
+
+  class << self
+    # source://spoom//lib/spoom/sorbet/errors.rb#38
+    sig { params(output: ::String, error_url_base: ::String).returns(T::Array[::Spoom::Sorbet::Errors::Error]) }
+    def parse_string(output, error_url_base: T.unsafe(nil)); end
+  end
+end
+
+# source://spoom//lib/spoom/sorbet/errors.rb#23
+Spoom::Sorbet::Errors::Parser::HEADER = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/sorbet/errors.rb#21
+class Spoom::Sorbet::Errors::Parser::ParseError < ::Spoom::Error; end
+
+# source://spoom//lib/spoom/sorbet.rb#37
+Spoom::Sorbet::GEM_PATH = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet.rb#38
+Spoom::Sorbet::GEM_VERSION = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet.rb#41
+Spoom::Sorbet::KILLED_CODE = T.let(T.unsafe(nil), Integer)
+
+# source://spoom//lib/spoom/sorbet/metrics.rb#8
+module Spoom::Sorbet::MetricsParser
+  class << self
+    # source://spoom//lib/spoom/sorbet/metrics.rb#15
+    sig { params(path: ::String, prefix: ::String).returns(T::Hash[::String, ::Integer]) }
+    def parse_file(path, prefix = T.unsafe(nil)); end
+
+    # source://spoom//lib/spoom/sorbet/metrics.rb#25
+    sig { params(obj: T::Hash[::String, T.untyped], prefix: ::String).returns(T::Hash[::String, ::Integer]) }
+    def parse_hash(obj, prefix = T.unsafe(nil)); end
+
+    # source://spoom//lib/spoom/sorbet/metrics.rb#20
+    sig { params(string: ::String, prefix: ::String).returns(T::Hash[::String, ::Integer]) }
+    def parse_string(string, prefix = T.unsafe(nil)); end
+  end
+end
+
+# source://spoom//lib/spoom/sorbet/metrics.rb#9
+Spoom::Sorbet::MetricsParser::DEFAULT_PREFIX = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet.rb#42
+Spoom::Sorbet::SEGFAULT_CODE = T.let(T.unsafe(nil), Integer)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#9
+module Spoom::Sorbet::Sigils
+  class << self
+    # changes the sigil in the file at the passed path to the specified new strictness
+    #
+    # source://spoom//lib/spoom/sorbet/sigils.rb#72
+    sig { params(path: T.any(::Pathname, ::String), new_strictness: ::String).returns(T::Boolean) }
+    def change_sigil_in_file(path, new_strictness); end
+
+    # changes the sigil to have a new strictness in a list of files
+    #
+    # source://spoom//lib/spoom/sorbet/sigils.rb#83
+    sig { params(path_list: T::Array[::String], new_strictness: ::String).returns(T::Array[::String]) }
+    def change_sigil_in_files(path_list, new_strictness); end
+
+    # returns a string containing the strictness of a sigil in a file at the passed path
+    # * returns nil if no sigil
+    #
+    # source://spoom//lib/spoom/sorbet/sigils.rb#63
+    sig { params(path: T.any(::Pathname, ::String)).returns(T.nilable(::String)) }
+    def file_strictness(path); end
+
+    # returns the full sigil comment string for the passed strictness
+    #
+    # source://spoom//lib/spoom/sorbet/sigils.rb#38
+    sig { params(strictness: ::String).returns(::String) }
+    def sigil_string(strictness); end
+
+    # returns the strictness of a sigil in the passed file content string (nil if no sigil)
+    #
+    # source://spoom//lib/spoom/sorbet/sigils.rb#50
+    sig { params(content: ::String).returns(T.nilable(::String)) }
+    def strictness_in_content(content); end
+
+    # returns a string which is the passed content but with the sigil updated to a new strictness
+    #
+    # source://spoom//lib/spoom/sorbet/sigils.rb#56
+    sig { params(content: ::String, new_strictness: ::String).returns(::String) }
+    def update_sigil(content, new_strictness); end
+
+    # returns true if the passed string is a valid strictness (else false)
+    #
+    # source://spoom//lib/spoom/sorbet/sigils.rb#44
+    sig { params(strictness: ::String).returns(T::Boolean) }
+    def valid_strictness?(strictness); end
+  end
+end
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#31
+Spoom::Sorbet::Sigils::SIGIL_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#13
+Spoom::Sorbet::Sigils::STRICTNESS_FALSE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#12
+Spoom::Sorbet::Sigils::STRICTNESS_IGNORE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#17
+Spoom::Sorbet::Sigils::STRICTNESS_INTERNAL = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#15
+Spoom::Sorbet::Sigils::STRICTNESS_STRICT = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#16
+Spoom::Sorbet::Sigils::STRICTNESS_STRONG = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#14
+Spoom::Sorbet::Sigils::STRICTNESS_TRUE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#19
+Spoom::Sorbet::Sigils::VALID_STRICTNESS = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/timeline.rb#5
+class Spoom::Timeline
+  # source://spoom//lib/spoom/timeline.rb#9
+  sig { params(context: ::Spoom::Context, from: ::Time, to: ::Time).void }
+  def initialize(context, from, to); end
+
+  # Return one commit for each date in `dates`
+  #
+  # source://spoom//lib/spoom/timeline.rb#36
+  sig { params(dates: T::Array[::Time]).returns(T::Array[::Spoom::Git::Commit]) }
+  def commits_for_dates(dates); end
+
+  # Return all months between `from` and `to`
+  #
+  # source://spoom//lib/spoom/timeline.rb#23
+  sig { returns(T::Array[::Time]) }
+  def months; end
+
+  # Return one commit for each month between `from` and `to`
+  #
+  # source://spoom//lib/spoom/timeline.rb#17
+  sig { returns(T::Array[::Spoom::Git::Commit]) }
+  def ticks; end
+end
+
+# source://spoom//lib/spoom/version.rb#5
+Spoom::VERSION = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/visitor.rb#7
+class Spoom::Visitor < ::Prism::Visitor
+  # source://spoom//lib/spoom/visitor.rb#16
+  sig { override.params(node: ::Prism::AliasGlobalVariableNode).void }
+  def visit_alias_global_variable_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#21
+  sig { override.params(node: ::Prism::AliasMethodNode).void }
+  def visit_alias_method_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#26
+  sig { override.params(node: ::Prism::AlternationPatternNode).void }
+  def visit_alternation_pattern_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#31
+  sig { override.params(node: ::Prism::AndNode).void }
+  def visit_and_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#36
+  sig { override.params(node: ::Prism::ArgumentsNode).void }
+  def visit_arguments_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#41
+  sig { override.params(node: ::Prism::ArrayNode).void }
+  def visit_array_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#46
+  sig { override.params(node: ::Prism::ArrayPatternNode).void }
+  def visit_array_pattern_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#51
+  sig { override.params(node: ::Prism::AssocNode).void }
+  def visit_assoc_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#56
+  sig { override.params(node: ::Prism::AssocSplatNode).void }
+  def visit_assoc_splat_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#61
+  sig { override.params(node: ::Prism::BackReferenceReadNode).void }
+  def visit_back_reference_read_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#66
+  sig { override.params(node: ::Prism::BeginNode).void }
+  def visit_begin_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#71
+  sig { override.params(node: ::Prism::BlockArgumentNode).void }
+  def visit_block_argument_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#76
+  sig { override.params(node: ::Prism::BlockLocalVariableNode).void }
+  def visit_block_local_variable_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#81
+  sig { override.params(node: ::Prism::BlockNode).void }
+  def visit_block_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#86
+  sig { override.params(node: ::Prism::BlockParameterNode).void }
+  def visit_block_parameter_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#91
+  sig { override.params(node: ::Prism::BlockParametersNode).void }
+  def visit_block_parameters_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#96
+  sig { override.params(node: ::Prism::BreakNode).void }
+  def visit_break_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#101
+  sig { override.params(node: ::Prism::CallAndWriteNode).void }
+  def visit_call_and_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#106
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#111
+  sig { override.params(node: ::Prism::CallOperatorWriteNode).void }
+  def visit_call_operator_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#116
+  sig { override.params(node: ::Prism::CallOrWriteNode).void }
+  def visit_call_or_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#121
+  sig { override.params(node: ::Prism::CallTargetNode).void }
+  def visit_call_target_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#126
+  sig { override.params(node: ::Prism::CapturePatternNode).void }
+  def visit_capture_pattern_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#131
+  sig { override.params(node: ::Prism::CaseMatchNode).void }
+  def visit_case_match_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#136
+  sig { override.params(node: ::Prism::CaseNode).void }
+  def visit_case_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#11
+  sig { override.params(node: ::Prism::Node).void }
+  def visit_child_nodes(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#141
+  sig { override.params(node: ::Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#146
+  sig { override.params(node: ::Prism::ClassVariableAndWriteNode).void }
+  def visit_class_variable_and_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#151
+  sig { override.params(node: ::Prism::ClassVariableOperatorWriteNode).void }
+  def visit_class_variable_operator_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#156
+  sig { override.params(node: ::Prism::ClassVariableOrWriteNode).void }
+  def visit_class_variable_or_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#161
+  sig { override.params(node: ::Prism::ClassVariableReadNode).void }
+  def visit_class_variable_read_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#166
+  sig { override.params(node: ::Prism::ClassVariableTargetNode).void }
+  def visit_class_variable_target_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#171
+  sig { override.params(node: ::Prism::ClassVariableWriteNode).void }
+  def visit_class_variable_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#176
+  sig { override.params(node: ::Prism::ConstantAndWriteNode).void }
+  def visit_constant_and_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#181
+  sig { override.params(node: ::Prism::ConstantOperatorWriteNode).void }
+  def visit_constant_operator_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#186
+  sig { override.params(node: ::Prism::ConstantOrWriteNode).void }
+  def visit_constant_or_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#191
+  sig { override.params(node: ::Prism::ConstantPathAndWriteNode).void }
+  def visit_constant_path_and_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#196
+  sig { override.params(node: ::Prism::ConstantPathNode).void }
+  def visit_constant_path_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#201
+  sig { override.params(node: ::Prism::ConstantPathOperatorWriteNode).void }
+  def visit_constant_path_operator_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#206
+  sig { override.params(node: ::Prism::ConstantPathOrWriteNode).void }
+  def visit_constant_path_or_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#211
+  sig { override.params(node: ::Prism::ConstantPathTargetNode).void }
+  def visit_constant_path_target_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#216
+  sig { override.params(node: ::Prism::ConstantPathWriteNode).void }
+  def visit_constant_path_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#221
+  sig { override.params(node: ::Prism::ConstantReadNode).void }
+  def visit_constant_read_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#226
+  sig { override.params(node: ::Prism::ConstantTargetNode).void }
+  def visit_constant_target_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#231
+  sig { override.params(node: ::Prism::ConstantWriteNode).void }
+  def visit_constant_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#236
+  sig { override.params(node: ::Prism::DefNode).void }
+  def visit_def_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#241
+  sig { override.params(node: ::Prism::DefinedNode).void }
+  def visit_defined_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#246
+  sig { override.params(node: ::Prism::ElseNode).void }
+  def visit_else_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#251
+  sig { override.params(node: ::Prism::EmbeddedStatementsNode).void }
+  def visit_embedded_statements_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#256
+  sig { override.params(node: ::Prism::EmbeddedVariableNode).void }
+  def visit_embedded_variable_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#261
+  sig { override.params(node: ::Prism::EnsureNode).void }
+  def visit_ensure_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#266
+  sig { override.params(node: ::Prism::FalseNode).void }
+  def visit_false_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#271
+  sig { override.params(node: ::Prism::FindPatternNode).void }
+  def visit_find_pattern_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#276
+  sig { override.params(node: ::Prism::FlipFlopNode).void }
+  def visit_flip_flop_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#281
+  sig { override.params(node: ::Prism::FloatNode).void }
+  def visit_float_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#286
+  sig { override.params(node: ::Prism::ForNode).void }
+  def visit_for_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#291
+  sig { override.params(node: ::Prism::ForwardingArgumentsNode).void }
+  def visit_forwarding_arguments_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#296
+  sig { override.params(node: ::Prism::ForwardingParameterNode).void }
+  def visit_forwarding_parameter_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#301
+  sig { override.params(node: ::Prism::ForwardingSuperNode).void }
+  def visit_forwarding_super_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#306
+  sig { override.params(node: ::Prism::GlobalVariableAndWriteNode).void }
+  def visit_global_variable_and_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#311
+  sig { override.params(node: ::Prism::GlobalVariableOperatorWriteNode).void }
+  def visit_global_variable_operator_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#316
+  sig { override.params(node: ::Prism::GlobalVariableOrWriteNode).void }
+  def visit_global_variable_or_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#321
+  sig { override.params(node: ::Prism::GlobalVariableReadNode).void }
+  def visit_global_variable_read_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#326
+  sig { override.params(node: ::Prism::GlobalVariableTargetNode).void }
+  def visit_global_variable_target_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#331
+  sig { override.params(node: ::Prism::GlobalVariableWriteNode).void }
+  def visit_global_variable_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#336
+  sig { override.params(node: ::Prism::HashNode).void }
+  def visit_hash_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#341
+  sig { override.params(node: ::Prism::HashPatternNode).void }
+  def visit_hash_pattern_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#346
+  sig { override.params(node: ::Prism::IfNode).void }
+  def visit_if_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#351
+  sig { override.params(node: ::Prism::ImaginaryNode).void }
+  def visit_imaginary_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#356
+  sig { override.params(node: ::Prism::ImplicitNode).void }
+  def visit_implicit_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#361
+  sig { override.params(node: ::Prism::ImplicitRestNode).void }
+  def visit_implicit_rest_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#366
+  sig { override.params(node: ::Prism::InNode).void }
+  def visit_in_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#371
+  sig { override.params(node: ::Prism::IndexAndWriteNode).void }
+  def visit_index_and_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#376
+  sig { override.params(node: ::Prism::IndexOperatorWriteNode).void }
+  def visit_index_operator_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#381
+  sig { override.params(node: ::Prism::IndexOrWriteNode).void }
+  def visit_index_or_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#386
+  sig { override.params(node: ::Prism::IndexTargetNode).void }
+  def visit_index_target_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#391
+  sig { override.params(node: ::Prism::InstanceVariableAndWriteNode).void }
+  def visit_instance_variable_and_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#396
+  sig { override.params(node: ::Prism::InstanceVariableOperatorWriteNode).void }
+  def visit_instance_variable_operator_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#401
+  sig { override.params(node: ::Prism::InstanceVariableOrWriteNode).void }
+  def visit_instance_variable_or_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#406
+  sig { override.params(node: ::Prism::InstanceVariableReadNode).void }
+  def visit_instance_variable_read_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#411
+  sig { override.params(node: ::Prism::InstanceVariableTargetNode).void }
+  def visit_instance_variable_target_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#416
+  sig { override.params(node: ::Prism::InstanceVariableWriteNode).void }
+  def visit_instance_variable_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#421
+  sig { override.params(node: ::Prism::IntegerNode).void }
+  def visit_integer_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#426
+  sig { override.params(node: ::Prism::InterpolatedMatchLastLineNode).void }
+  def visit_interpolated_match_last_line_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#431
+  sig { override.params(node: ::Prism::InterpolatedRegularExpressionNode).void }
+  def visit_interpolated_regular_expression_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#436
+  sig { override.params(node: ::Prism::InterpolatedStringNode).void }
+  def visit_interpolated_string_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#441
+  sig { override.params(node: ::Prism::InterpolatedSymbolNode).void }
+  def visit_interpolated_symbol_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#446
+  sig { override.params(node: ::Prism::InterpolatedXStringNode).void }
+  def visit_interpolated_x_string_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#451
+  sig { override.params(node: ::Prism::KeywordHashNode).void }
+  def visit_keyword_hash_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#456
+  sig { override.params(node: ::Prism::KeywordRestParameterNode).void }
+  def visit_keyword_rest_parameter_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#461
+  sig { override.params(node: ::Prism::LambdaNode).void }
+  def visit_lambda_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#466
+  sig { override.params(node: ::Prism::LocalVariableAndWriteNode).void }
+  def visit_local_variable_and_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#471
+  sig { override.params(node: ::Prism::LocalVariableOperatorWriteNode).void }
+  def visit_local_variable_operator_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#476
+  sig { override.params(node: ::Prism::LocalVariableOrWriteNode).void }
+  def visit_local_variable_or_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#481
+  sig { override.params(node: ::Prism::LocalVariableReadNode).void }
+  def visit_local_variable_read_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#486
+  sig { override.params(node: ::Prism::LocalVariableTargetNode).void }
+  def visit_local_variable_target_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#491
+  sig { override.params(node: ::Prism::LocalVariableWriteNode).void }
+  def visit_local_variable_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#496
+  sig { override.params(node: ::Prism::MatchLastLineNode).void }
+  def visit_match_last_line_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#501
+  sig { override.params(node: ::Prism::MatchPredicateNode).void }
+  def visit_match_predicate_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#506
+  sig { override.params(node: ::Prism::MatchRequiredNode).void }
+  def visit_match_required_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#511
+  sig { override.params(node: ::Prism::MatchWriteNode).void }
+  def visit_match_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#516
+  sig { override.params(node: ::Prism::MissingNode).void }
+  def visit_missing_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#521
+  sig { override.params(node: ::Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#526
+  sig { override.params(node: ::Prism::MultiTargetNode).void }
+  def visit_multi_target_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#531
+  sig { override.params(node: ::Prism::MultiWriteNode).void }
+  def visit_multi_write_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#536
+  sig { override.params(node: ::Prism::NextNode).void }
+  def visit_next_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#541
+  sig { override.params(node: ::Prism::NilNode).void }
+  def visit_nil_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#546
+  sig { override.params(node: ::Prism::NoKeywordsParameterNode).void }
+  def visit_no_keywords_parameter_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#551
+  sig { override.params(node: ::Prism::NumberedParametersNode).void }
+  def visit_numbered_parameters_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#556
+  sig { override.params(node: ::Prism::NumberedReferenceReadNode).void }
+  def visit_numbered_reference_read_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#561
+  sig { override.params(node: ::Prism::OptionalKeywordParameterNode).void }
+  def visit_optional_keyword_parameter_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#566
+  sig { override.params(node: ::Prism::OptionalParameterNode).void }
+  def visit_optional_parameter_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#571
+  sig { override.params(node: ::Prism::OrNode).void }
+  def visit_or_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#576
+  sig { override.params(node: ::Prism::ParametersNode).void }
+  def visit_parameters_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#581
+  sig { override.params(node: ::Prism::ParenthesesNode).void }
+  def visit_parentheses_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#586
+  sig { override.params(node: ::Prism::PinnedExpressionNode).void }
+  def visit_pinned_expression_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#591
+  sig { override.params(node: ::Prism::PinnedVariableNode).void }
+  def visit_pinned_variable_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#596
+  sig { override.params(node: ::Prism::PostExecutionNode).void }
+  def visit_post_execution_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#601
+  sig { override.params(node: ::Prism::PreExecutionNode).void }
+  def visit_pre_execution_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#606
+  sig { override.params(node: ::Prism::ProgramNode).void }
+  def visit_program_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#611
+  sig { override.params(node: ::Prism::RangeNode).void }
+  def visit_range_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#616
+  sig { override.params(node: ::Prism::RationalNode).void }
+  def visit_rational_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#621
+  sig { override.params(node: ::Prism::RedoNode).void }
+  def visit_redo_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#626
+  sig { override.params(node: ::Prism::RegularExpressionNode).void }
+  def visit_regular_expression_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#631
+  sig { override.params(node: ::Prism::RequiredKeywordParameterNode).void }
+  def visit_required_keyword_parameter_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#636
+  sig { override.params(node: ::Prism::RequiredParameterNode).void }
+  def visit_required_parameter_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#641
+  sig { override.params(node: ::Prism::RescueModifierNode).void }
+  def visit_rescue_modifier_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#646
+  sig { override.params(node: ::Prism::RescueNode).void }
+  def visit_rescue_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#651
+  sig { override.params(node: ::Prism::RestParameterNode).void }
+  def visit_rest_parameter_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#656
+  sig { override.params(node: ::Prism::RetryNode).void }
+  def visit_retry_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#661
+  sig { override.params(node: ::Prism::ReturnNode).void }
+  def visit_return_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#666
+  sig { override.params(node: ::Prism::SelfNode).void }
+  def visit_self_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#671
+  sig { override.params(node: ::Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#676
+  sig { override.params(node: ::Prism::SourceEncodingNode).void }
+  def visit_source_encoding_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#681
+  sig { override.params(node: ::Prism::SourceFileNode).void }
+  def visit_source_file_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#686
+  sig { override.params(node: ::Prism::SourceLineNode).void }
+  def visit_source_line_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#691
+  sig { override.params(node: ::Prism::SplatNode).void }
+  def visit_splat_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#696
+  sig { override.params(node: ::Prism::StatementsNode).void }
+  def visit_statements_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#701
+  sig { override.params(node: ::Prism::StringNode).void }
+  def visit_string_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#706
+  sig { override.params(node: ::Prism::SuperNode).void }
+  def visit_super_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#711
+  sig { override.params(node: ::Prism::SymbolNode).void }
+  def visit_symbol_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#716
+  sig { override.params(node: ::Prism::TrueNode).void }
+  def visit_true_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#721
+  sig { override.params(node: ::Prism::UndefNode).void }
+  def visit_undef_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#726
+  sig { override.params(node: ::Prism::UnlessNode).void }
+  def visit_unless_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#731
+  sig { override.params(node: ::Prism::UntilNode).void }
+  def visit_until_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#736
+  sig { override.params(node: ::Prism::WhenNode).void }
+  def visit_when_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#741
+  sig { override.params(node: ::Prism::WhileNode).void }
+  def visit_while_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#746
+  sig { override.params(node: ::Prism::XStringNode).void }
+  def visit_x_string_node(node); end
+
+  # source://spoom//lib/spoom/visitor.rb#751
+  sig { override.params(node: ::Prism::YieldNode).void }
+  def visit_yield_node(node); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/stackprof@0.2.26.rbi b/Library/Homebrew/sorbet/rbi/gems/stackprof@0.2.26.rbi
new file mode 100644
index 0000000000000..84c1017717a06
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/stackprof@0.2.26.rbi
@@ -0,0 +1,241 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `stackprof` gem.
+# Please instead update this file by running `bin/tapioca gem stackprof`.
+
+# source://stackprof//lib/stackprof.rb#20
+module StackProf
+  class << self
+    def results(*_arg0); end
+    def run(*_arg0); end
+
+    # @return [Boolean]
+    def running?; end
+
+    def sample; end
+    def start(*_arg0); end
+    def stop; end
+    def use_postponed_job!; end
+  end
+end
+
+# source://stackprof//lib/stackprof/middleware.rb#4
+class StackProf::Middleware
+  # @return [Middleware] a new instance of Middleware
+  #
+  # source://stackprof//lib/stackprof/middleware.rb#5
+  def initialize(app, options = T.unsafe(nil)); end
+
+  # source://stackprof//lib/stackprof/middleware.rb#20
+  def call(env); end
+
+  class << self
+    # Returns the value of attribute enabled.
+    #
+    # source://stackprof//lib/stackprof/middleware.rb#40
+    def enabled; end
+
+    # Sets the attribute enabled
+    #
+    # @param value the value to set the attribute enabled to.
+    #
+    # source://stackprof//lib/stackprof/middleware.rb#40
+    def enabled=(_arg0); end
+
+    # @return [Boolean]
+    #
+    # source://stackprof//lib/stackprof/middleware.rb#42
+    def enabled?(env); end
+
+    # Returns the value of attribute interval.
+    #
+    # source://stackprof//lib/stackprof/middleware.rb#40
+    def interval; end
+
+    # Sets the attribute interval
+    #
+    # @param value the value to set the attribute interval to.
+    #
+    # source://stackprof//lib/stackprof/middleware.rb#40
+    def interval=(_arg0); end
+
+    # Returns the value of attribute metadata.
+    #
+    # source://stackprof//lib/stackprof/middleware.rb#40
+    def metadata; end
+
+    # Sets the attribute metadata
+    #
+    # @param value the value to set the attribute metadata to.
+    #
+    # source://stackprof//lib/stackprof/middleware.rb#40
+    def metadata=(_arg0); end
+
+    # Returns the value of attribute mode.
+    #
+    # source://stackprof//lib/stackprof/middleware.rb#40
+    def mode; end
+
+    # Sets the attribute mode
+    #
+    # @param value the value to set the attribute mode to.
+    #
+    # source://stackprof//lib/stackprof/middleware.rb#40
+    def mode=(_arg0); end
+
+    # Returns the value of attribute path.
+    #
+    # source://stackprof//lib/stackprof/middleware.rb#40
+    def path; end
+
+    # Sets the attribute path
+    #
+    # @param value the value to set the attribute path to.
+    #
+    # source://stackprof//lib/stackprof/middleware.rb#40
+    def path=(_arg0); end
+
+    # Returns the value of attribute raw.
+    #
+    # source://stackprof//lib/stackprof/middleware.rb#40
+    def raw; end
+
+    # Sets the attribute raw
+    #
+    # @param value the value to set the attribute raw to.
+    #
+    # source://stackprof//lib/stackprof/middleware.rb#40
+    def raw=(_arg0); end
+
+    # source://stackprof//lib/stackprof/middleware.rb#50
+    def save; end
+  end
+end
+
+# source://stackprof//lib/stackprof/report.rb#8
+class StackProf::Report
+  # @return [Report] a new instance of Report
+  #
+  # source://stackprof//lib/stackprof/report.rb#42
+  def initialize(data); end
+
+  # @raise [ArgumentError]
+  #
+  # source://stackprof//lib/stackprof/report.rb#618
+  def +(other); end
+
+  # source://stackprof//lib/stackprof/report.rb#92
+  def add_lines(a, b); end
+
+  # source://stackprof//lib/stackprof/report.rb#212
+  def convert_to_d3_flame_graph_format(name, stacks, depth); end
+
+  # Returns the value of attribute data.
+  #
+  # source://stackprof//lib/stackprof/report.rb#45
+  def data; end
+
+  # source://stackprof//lib/stackprof/report.rb#80
+  def files; end
+
+  # source://stackprof//lib/stackprof/report.rb#205
+  def flamegraph_row(f, x, y, weight, addr); end
+
+  # source://stackprof//lib/stackprof/report.rb#187
+  def flamegraph_stacks(raw); end
+
+  # source://stackprof//lib/stackprof/report.rb#47
+  def frames(sort_by_total = T.unsafe(nil)); end
+
+  # source://stackprof//lib/stackprof/report.rb#76
+  def max_samples; end
+
+  # source://stackprof//lib/stackprof/report.rb#68
+  def modeline; end
+
+  # source://stackprof//lib/stackprof/report.rb#52
+  def normalized_frames; end
+
+  # source://stackprof//lib/stackprof/report.rb#72
+  def overall_samples; end
+
+  # source://stackprof//lib/stackprof/report.rb#128
+  def print_alphabetical_flamegraph(f = T.unsafe(nil), skip_common = T.unsafe(nil)); end
+
+  # source://stackprof//lib/stackprof/report.rb#495
+  def print_callgrind(f = T.unsafe(nil)); end
+
+  # source://stackprof//lib/stackprof/report.rb#242
+  def print_d3_flamegraph(f = T.unsafe(nil), skip_common = T.unsafe(nil)); end
+
+  # source://stackprof//lib/stackprof/report.rb#99
+  def print_debug; end
+
+  # source://stackprof//lib/stackprof/report.rb#103
+  def print_dump(f = T.unsafe(nil)); end
+
+  # source://stackprof//lib/stackprof/report.rb#610
+  def print_file(filter, f = T.unsafe(nil)); end
+
+  # source://stackprof//lib/stackprof/report.rb#600
+  def print_files(sort_by_total = T.unsafe(nil), limit = T.unsafe(nil), f = T.unsafe(nil)); end
+
+  # source://stackprof//lib/stackprof/report.rb#132
+  def print_flamegraph(f, skip_common, alphabetical = T.unsafe(nil)); end
+
+  # source://stackprof//lib/stackprof/report.rb#414
+  def print_graphviz(options = T.unsafe(nil), f = T.unsafe(nil)); end
+
+  # source://stackprof//lib/stackprof/report.rb#107
+  def print_json(f = T.unsafe(nil)); end
+
+  # source://stackprof//lib/stackprof/report.rb#526
+  def print_method(name, f = T.unsafe(nil)); end
+
+  # source://stackprof//lib/stackprof/report.rb#112
+  def print_stackcollapse; end
+
+  # source://stackprof//lib/stackprof/report.rb#476
+  def print_text(sort_by_total = T.unsafe(nil), limit = T.unsafe(nil), select_files = T.unsafe(nil), reject_files = T.unsafe(nil), select_names = T.unsafe(nil), reject_names = T.unsafe(nil), f = T.unsafe(nil)); end
+
+  # source://stackprof//lib/stackprof/report.rb#124
+  def print_timeline_flamegraph(f = T.unsafe(nil), skip_common = T.unsafe(nil)); end
+
+  # source://stackprof//lib/stackprof/report.rb#64
+  def version; end
+
+  # Walk up and down the stack from a given starting point (name).  Loops
+  # until `:exit` is selected
+  #
+  # source://stackprof//lib/stackprof/report.rb#561
+  def walk_method(name); end
+
+  private
+
+  # source://stackprof//lib/stackprof/report.rb#669
+  def callers_for(addr); end
+
+  # source://stackprof//lib/stackprof/report.rb#665
+  def root_frames; end
+
+  # source://stackprof//lib/stackprof/report.rb#674
+  def source_display(f, file, lines, range = T.unsafe(nil)); end
+
+  class << self
+    # source://stackprof//lib/stackprof/report.rb#12
+    def from_file(file); end
+
+    # source://stackprof//lib/stackprof/report.rb#20
+    def from_json(json); end
+
+    # source://stackprof//lib/stackprof/report.rb#24
+    def parse_json(json); end
+  end
+end
+
+# source://stackprof//lib/stackprof/report.rb#9
+StackProf::Report::MARSHAL_SIGNATURE = T.let(T.unsafe(nil), String)
+
+# source://stackprof//lib/stackprof.rb#21
+StackProf::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.16.3.rbi b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.16.3.rbi
new file mode 100644
index 0000000000000..2bc79c5b9f69b
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.16.3.rbi
@@ -0,0 +1,3596 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `tapioca` gem.
+# Please instead update this file by running `bin/tapioca gem tapioca`.
+
+
+class Bundler::Dependency < ::Gem::Dependency
+  include ::Tapioca::BundlerExt::AutoRequireHook
+end
+
+# source://tapioca//lib/tapioca/helpers/git_attributes.rb#4
+class GitAttributes
+  class << self
+    # source://tapioca//lib/tapioca/helpers/git_attributes.rb#9
+    sig { params(path: ::Pathname).void }
+    def create_generated_attribute_file(path); end
+
+    # source://tapioca//lib/tapioca/helpers/git_attributes.rb#16
+    sig { params(path: ::Pathname).void }
+    def create_vendored_attribute_file(path); end
+
+    private
+
+    # source://tapioca//lib/tapioca/helpers/git_attributes.rb#25
+    sig { params(path: ::Pathname, content: ::String).void }
+    def create_gitattributes_file(path, content); end
+  end
+end
+
+# We need to do the alias-method-chain dance since Bootsnap does the same,
+# and prepended modules and alias-method-chain don't play well together.
+#
+# So, why does Bootsnap do alias-method-chain and not prepend? Glad you asked!
+# That's because RubyGems does alias-method-chain for Kernel#require and such,
+# so, if Bootsnap were to do prepend, it might end up breaking RubyGems.
+#
+# source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#68
+class Module
+  # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#101
+  def append_features(constant); end
+
+  # source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#71
+  def autoload(const_name, path); end
+
+  # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#111
+  def extend_object(obj); end
+
+  # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#91
+  def prepend_features(constant); end
+end
+
+# source://tapioca//lib/tapioca/rbi_ext/model.rb#4
+module RBI; end
+
+# source://tapioca//lib/tapioca/rbi_ext/model.rb#5
+class RBI::Tree < ::RBI::NodeWithComments
+  # source://rbi/0.2.0/lib/rbi/model.rb#121
+  sig do
+    params(
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Tree).void)
+    ).void
+  end
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi/0.2.0/lib/rbi/model.rb#128
+  sig { params(node: ::RBI::Node).void }
+  def <<(node); end
+
+  # source://rbi/0.2.0/lib/rbi/rewriters/add_sig_templates.rb#66
+  sig { params(with_todo_comment: T::Boolean).void }
+  def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end
+
+  # source://rbi/0.2.0/lib/rbi/rewriters/annotate.rb#49
+  sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
+  def annotate!(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/rbi_ext/model.rb#38
+  sig do
+    params(
+      name: ::String,
+      superclass_name: T.nilable(::String),
+      block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)
+    ).returns(::RBI::Scope)
+  end
+  def create_class(name, superclass_name: T.unsafe(nil), &block); end
+
+  # source://tapioca//lib/tapioca/rbi_ext/model.rb#45
+  sig { params(name: ::String, value: ::String).void }
+  def create_constant(name, value:); end
+
+  # source://tapioca//lib/tapioca/rbi_ext/model.rb#55
+  sig { params(name: ::String).void }
+  def create_extend(name); end
+
+  # source://tapioca//lib/tapioca/rbi_ext/model.rb#50
+  sig { params(name: ::String).void }
+  def create_include(name); end
+
+  # source://tapioca//lib/tapioca/rbi_ext/model.rb#90
+  sig do
+    params(
+      name: ::String,
+      parameters: T::Array[::RBI::TypedParam],
+      return_type: T.nilable(::String),
+      class_method: T::Boolean,
+      visibility: ::RBI::Visibility,
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Method).void)
+    ).void
+  end
+  def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil), visibility: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://tapioca//lib/tapioca/rbi_ext/model.rb#60
+  sig { params(name: ::String).void }
+  def create_mixes_in_class_methods(name); end
+
+  # source://tapioca//lib/tapioca/rbi_ext/model.rb#25
+  sig { params(name: ::String, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
+  def create_module(name, &block); end
+
+  # source://tapioca//lib/tapioca/rbi_ext/model.rb#9
+  sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
+  def create_path(constant, &block); end
+
+  # source://tapioca//lib/tapioca/rbi_ext/model.rb#74
+  sig do
+    params(
+      name: ::String,
+      type: ::String,
+      variance: ::Symbol,
+      fixed: T.nilable(::String),
+      upper: T.nilable(::String),
+      lower: T.nilable(::String)
+    ).void
+  end
+  def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end
+
+  # source://rbi/0.2.0/lib/rbi/rewriters/deannotate.rb#41
+  sig { params(annotation: ::String).void }
+  def deannotate!(annotation); end
+
+  # source://rbi/0.2.0/lib/rbi/model.rb#134
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  # source://rbi/0.2.0/lib/rbi/rewriters/filter_versions.rb#118
+  sig { params(version: ::Gem::Version).void }
+  def filter_versions!(version); end
+
+  # source://rbi/0.2.0/lib/rbi/rewriters/flatten_singleton_methods.rb#60
+  sig { void }
+  def flatten_singleton_methods!; end
+
+  # source://rbi/0.2.0/lib/rbi/rewriters/flatten_visibilities.rb#60
+  sig { void }
+  def flatten_visibilities!; end
+
+  # source://rbi/0.2.0/lib/rbi/rewriters/group_nodes.rb#81
+  sig { void }
+  def group_nodes!; end
+
+  # source://rbi/0.2.0/lib/rbi/index.rb#68
+  sig { returns(::RBI::Index) }
+  def index; end
+
+  # source://rbi/0.2.0/lib/rbi/rewriters/merge_trees.rb#324
+  sig do
+    params(
+      other: ::RBI::Tree,
+      left_name: ::String,
+      right_name: ::String,
+      keep: ::RBI::Rewriters::Merge::Keep
+    ).returns(::RBI::MergeTree)
+  end
+  def merge(other, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
+
+  # source://rbi/0.2.0/lib/rbi/rewriters/nest_non_public_members.rb#46
+  sig { void }
+  def nest_non_public_members!; end
+
+  # source://rbi/0.2.0/lib/rbi/rewriters/nest_singleton_methods.rb#36
+  sig { void }
+  def nest_singleton_methods!; end
+
+  # source://rbi/0.2.0/lib/rbi/rewriters/nest_top_level_members.rb#63
+  sig { void }
+  def nest_top_level_members!; end
+
+  # source://rbi/0.2.0/lib/rbi/model.rb#112
+  sig { returns(T::Array[::RBI::Node]) }
+  def nodes; end
+
+  # source://rbi/0.2.0/lib/rbi/rewriters/attr_to_methods.rb#53
+  sig { void }
+  def replace_attributes_with_methods!; end
+
+  # source://rbi/0.2.0/lib/rbi/rewriters/sort_nodes.rb#119
+  sig { void }
+  def sort_nodes!; end
+
+  private
+
+  # source://tapioca//lib/tapioca/rbi_ext/model.rb#123
+  sig { params(node: ::RBI::Node).returns(::RBI::Node) }
+  def create_node(node); end
+
+  # source://tapioca//lib/tapioca/rbi_ext/model.rb#118
+  sig { returns(T::Hash[::String, ::RBI::Node]) }
+  def nodes_cache; end
+end
+
+# source://tapioca//lib/tapioca/rbi_ext/model.rb#133
+class RBI::TypedParam < ::T::Struct
+  const :param, ::RBI::Param
+  const :type, ::String
+
+  class << self
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#5
+module T::Generic
+  include ::Kernel
+
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#13
+  def [](*types); end
+
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#47
+  def has_attached_class!(variance = T.unsafe(nil), &bounds_proc); end
+
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#21
+  def type_member(variance = T.unsafe(nil), &bounds_proc); end
+
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#34
+  def type_template(variance = T.unsafe(nil), &bounds_proc); end
+end
+
+# This module intercepts calls to generic type instantiations and type variable definitions.
+# Tapioca stores the data from those calls in a `GenericTypeRegistry` which can then be used
+# to look up the original call details when we are trying to do code generation.
+#
+# We are interested in the data of the `[]`, `type_member` and `type_template` calls which
+# are all needed to generate good generic information at runtime.
+#
+# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#12
+module T::Generic::TypeStoragePatch
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#13
+  def [](*types); end
+
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#47
+  def has_attached_class!(variance = T.unsafe(nil), &bounds_proc); end
+
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#21
+  def type_member(variance = T.unsafe(nil), &bounds_proc); end
+
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#34
+  def type_template(variance = T.unsafe(nil), &bounds_proc); end
+end
+
+# source://tapioca//lib/tapioca/sorbet_ext/proc_bind_patch.rb#28
+module T::Private::Methods
+  class << self
+    # source://tapioca//lib/tapioca/sorbet_ext/proc_bind_patch.rb#30
+    def finalize_proc(decl); end
+  end
+end
+
+class T::Private::Methods::Declaration < ::Struct
+  def bind; end
+  def bind=(_); end
+  def checked; end
+  def checked=(_); end
+  def finalized; end
+  def finalized=(_); end
+  def mod; end
+  def mod=(_); end
+  def mode; end
+  def mode=(_); end
+  def on_failure; end
+  def on_failure=(_); end
+  def override_allow_incompatible; end
+  def override_allow_incompatible=(_); end
+  def params; end
+  def params=(_); end
+  def raw; end
+  def raw=(_); end
+  def returns; end
+  def returns=(_); end
+  def type_parameters; end
+  def type_parameters=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class T::Private::Methods::DeclarationBlock < ::Struct
+  def blk; end
+  def blk=(_); end
+  def final; end
+  def final=(_); end
+  def loc; end
+  def loc=(_); end
+  def mod; end
+  def mod=(_); end
+  def raw; end
+  def raw=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://tapioca//lib/tapioca/sorbet_ext/proc_bind_patch.rb#29
+module T::Private::Methods::ProcBindPatch
+  # source://tapioca//lib/tapioca/sorbet_ext/proc_bind_patch.rb#30
+  def finalize_proc(decl); end
+end
+
+class T::Types::Proc < ::T::Types::Base; end
+
+# source://tapioca//lib/tapioca/sorbet_ext/proc_bind_patch.rb#6
+module T::Types::ProcBindPatch
+  # source://tapioca//lib/tapioca/sorbet_ext/proc_bind_patch.rb#7
+  def initialize(arg_types, returns, bind = T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/sorbet_ext/proc_bind_patch.rb#15
+  def name; end
+end
+
+# source://tapioca//lib/tapioca/sorbet_ext/name_patch.rb#6
+class T::Types::Simple < ::T::Types::Base
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#70
+  def name; end
+end
+
+# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#65
+module T::Types::Simple::GenericPatch
+  # This method intercepts calls to the `name` method for simple types, so that
+  # it can ask the name to the type if the type is generic, since, by this point,
+  # we've created a clone of that type with the `name` method returning the
+  # appropriate name for that specific concrete type.
+  #
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#70
+  def name; end
+end
+
+# source://tapioca//lib/tapioca/sorbet_ext/name_patch.rb#7
+module T::Types::Simple::NamePatch
+  # source://tapioca//lib/tapioca/sorbet_ext/name_patch.rb#10
+  def name; end
+
+  # source://tapioca//lib/tapioca/sorbet_ext/name_patch.rb#16
+  def qualified_name_of(constant); end
+end
+
+# source://tapioca//lib/tapioca/sorbet_ext/name_patch.rb#8
+T::Types::Simple::NamePatch::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#87
+module T::Utils::Private
+  class << self
+    # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#89
+    def coerce_and_check_module_types(val, check_val, check_module_type); end
+  end
+end
+
+# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#88
+module T::Utils::Private::PrivateCoercePatch
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#89
+  def coerce_and_check_module_types(val, check_val, check_module_type); end
+end
+
+# source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#4
+module Tapioca
+  class << self
+    # source://tapioca//lib/tapioca.rb#20
+    sig do
+      type_parameters(:Result)
+        .params(
+          blk: T.proc.returns(T.type_parameter(:Result))
+        ).returns(T.type_parameter(:Result))
+    end
+    def silence_warnings(&blk); end
+  end
+end
+
+# source://tapioca//lib/tapioca.rb#39
+Tapioca::BINARY_FILE = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#5
+module Tapioca::BundlerExt; end
+
+# This is a module that gets prepended to `Bundler::Dependency` and
+# makes sure even gems marked as `require: false` are required during
+# `Bundler.require`.
+#
+# source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#9
+module Tapioca::BundlerExt::AutoRequireHook
+  requires_ancestor { Bundler::Dependency }
+
+  # source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#46
+  sig { returns(T.untyped) }
+  def autorequire; end
+
+  class << self
+    # @return [Boolean]
+    #
+    # source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#26
+    def enabled?; end
+
+    # source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#22
+    sig { params(name: T.untyped).returns(T::Boolean) }
+    def excluded?(name); end
+
+    # source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#36
+    sig do
+      type_parameters(:Result)
+        .params(
+          exclude: T::Array[::String],
+          blk: T.proc.returns(T.type_parameter(:Result))
+        ).returns(T.type_parameter(:Result))
+    end
+    def override_require_false(exclude:, &blk); end
+  end
+end
+
+# source://tapioca//lib/tapioca.rb#62
+Tapioca::CENTRAL_REPO_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#61
+Tapioca::CENTRAL_REPO_INDEX_PATH = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#60
+Tapioca::CENTRAL_REPO_ROOT_URI = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca/cli.rb#5
+class Tapioca::Cli < ::Thor
+  include ::Tapioca::CliHelper
+  include ::Tapioca::ConfigHelper
+  include ::Tapioca::EnvHelper
+
+  # source://tapioca//lib/tapioca/cli.rb#366
+  def __print_version; end
+
+  # source://tapioca//lib/tapioca/cli.rb#348
+  def annotations; end
+
+  # source://tapioca//lib/tapioca/cli.rb#320
+  def check_shims; end
+
+  # source://tapioca//lib/tapioca/cli.rb#46
+  def configure; end
+
+  # source://tapioca//lib/tapioca/cli.rb#147
+  def dsl(*constant_or_paths); end
+
+  # @raise [MalformattedArgumentError]
+  #
+  # source://tapioca//lib/tapioca/cli.rb#264
+  def gem(*gems); end
+
+  # source://tapioca//lib/tapioca/cli.rb#27
+  def init; end
+
+  # source://tapioca//lib/tapioca/cli.rb#57
+  def require; end
+
+  # source://tapioca//lib/tapioca/cli.rb#74
+  def todo; end
+
+  private
+
+  # source://tapioca//lib/tapioca/cli.rb#380
+  def print_init_next_steps; end
+
+  class << self
+    # source://tapioca//lib/tapioca/cli.rb#372
+    def exit_on_failure?; end
+  end
+end
+
+# source://tapioca//lib/tapioca/cli.rb#10
+Tapioca::Cli::FILE_HEADER_OPTION_DESC = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca/helpers/cli_helper.rb#5
+module Tapioca::CliHelper
+  requires_ancestor { Thor::Shell }
+
+  # source://tapioca//lib/tapioca/helpers/cli_helper.rb#33
+  sig { params(options: T::Hash[::Symbol, T.untyped]).returns(T.nilable(::String)) }
+  def netrc_file(options); end
+
+  # source://tapioca//lib/tapioca/helpers/cli_helper.rb#26
+  sig { params(options: T::Hash[::Symbol, T.untyped]).returns(::Tapioca::RBIFormatter) }
+  def rbi_formatter(options); end
+
+  # source://tapioca//lib/tapioca/helpers/cli_helper.rb#12
+  sig { params(message: ::String, color: T.any(::Symbol, T::Array[::Symbol])).void }
+  def say_error(message = T.unsafe(nil), *color); end
+end
+
+# source://tapioca//lib/tapioca/commands.rb#5
+module Tapioca::Commands; end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca//lib/tapioca/commands/abstract_dsl.rb#6
+class Tapioca::Commands::AbstractDsl < ::Tapioca::Commands::CommandWithoutTracker
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIFilesHelper
+
+  abstract!
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#33
+  sig do
+    params(
+      requested_constants: T::Array[::String],
+      requested_paths: T::Array[::Pathname],
+      outpath: ::Pathname,
+      only: T::Array[::String],
+      exclude: T::Array[::String],
+      file_header: T::Boolean,
+      tapioca_path: ::String,
+      skip_constant: T::Array[::String],
+      quiet: T::Boolean,
+      verbose: T::Boolean,
+      number_of_workers: T.nilable(::Integer),
+      auto_strictness: T::Boolean,
+      gem_dir: ::String,
+      rbi_formatter: ::Tapioca::RBIFormatter,
+      app_root: ::String,
+      halt_upon_load_error: T::Boolean,
+      compiler_options: T::Hash[::String, T.untyped]
+    ).void
+  end
+  def initialize(requested_constants:, requested_paths:, outpath:, only:, exclude:, file_header:, tapioca_path:, skip_constant: T.unsafe(nil), quiet: T.unsafe(nil), verbose: T.unsafe(nil), number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), gem_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil), compiler_options: T.unsafe(nil)); end
+
+  private
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#100
+  sig { returns(T::Array[::String]) }
+  def all_requested_constants; end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#293
+  sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) }
+  def build_error_for_files(cause, files); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#217
+  sig do
+    params(
+      constant_name: ::String,
+      rbi: ::RBI::File,
+      outpath: ::Pathname,
+      quiet: T::Boolean
+    ).returns(T.nilable(::Pathname))
+  end
+  def compile_dsl_rbi(constant_name, rbi, outpath: T.unsafe(nil), quiet: T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#154
+  sig { params(constant_names: T::Array[::String], ignore_missing: T::Boolean).returns(T::Array[::Module]) }
+  def constantize(constant_names, ignore_missing: T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#177
+  sig { params(compiler_names: T::Array[::String]).returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
+  def constantize_compilers(compiler_names); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#353
+  sig { returns(T::Array[::String]) }
+  def constants_from_requested_paths; end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#123
+  sig { returns(::Tapioca::Dsl::Pipeline) }
+  def create_pipeline; end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#256
+  sig { params(constant_name: ::String).returns(::Pathname) }
+  def dsl_rbi_filename(constant_name); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#140
+  sig { params(requested_constants: T::Array[::String], path: ::Pathname).returns(T::Set[::Pathname]) }
+  def existing_rbi_filenames(requested_constants, path: T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#348
+  sig { params(constant: ::String).returns(::String) }
+  def generate_command_for(constant); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#76
+  sig { params(outpath: ::Pathname, quiet: T::Boolean).returns(T::Set[::Pathname]) }
+  def generate_dsl_rbi_files(outpath, quiet:); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#113
+  sig { void }
+  def load_application; end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#235
+  sig { params(dir: ::Pathname).void }
+  def perform_dsl_verification(dir); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#108
+  sig { returns(::Tapioca::Dsl::Pipeline) }
+  def pipeline; end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#244
+  sig { params(files: T::Set[::Pathname]).void }
+  def purge_stale_dsl_rbi_files(files); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#343
+  sig { params(constant: ::String).returns(::String) }
+  def rbi_filename_for(constant); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#324
+  sig { params(path: ::Pathname).returns(T::Array[::Pathname]) }
+  def rbi_files_in(path); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#302
+  sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void }
+  def report_diff_and_exit_if_out_of_date(diff, command); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#197
+  sig { params(name: ::String).returns(T.nilable(T.class_of(Tapioca::Dsl::Compiler))) }
+  def resolve(name); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#331
+  sig { params(class_name: ::String).returns(::String) }
+  def underscore(class_name); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#261
+  sig { params(tmp_dir: ::Pathname).returns(T::Hash[::String, ::Symbol]) }
+  def verify_dsl_rbi(tmp_dir:); end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca//lib/tapioca/commands/abstract_gem.rb#6
+class Tapioca::Commands::AbstractGem < ::Tapioca::Commands::Command
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIFilesHelper
+
+  abstract!
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#32
+  sig do
+    params(
+      gem_names: T::Array[::String],
+      exclude: T::Array[::String],
+      include_dependencies: T::Boolean,
+      prerequire: T.nilable(::String),
+      postrequire: ::String,
+      typed_overrides: T::Hash[::String, ::String],
+      outpath: ::Pathname,
+      file_header: T::Boolean,
+      include_doc: T::Boolean,
+      include_loc: T::Boolean,
+      include_exported_rbis: T::Boolean,
+      number_of_workers: T.nilable(::Integer),
+      auto_strictness: T::Boolean,
+      dsl_dir: ::String,
+      rbi_formatter: ::Tapioca::RBIFormatter,
+      halt_upon_load_error: T::Boolean
+    ).void
+  end
+  def initialize(gem_names:, exclude:, include_dependencies:, prerequire:, postrequire:, typed_overrides:, outpath:, file_header:, include_doc:, include_loc:, include_exported_rbis:, number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), dsl_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
+
+  private
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#230
+  sig { returns(T::Array[::String]) }
+  def added_rbis; end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#291
+  sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) }
+  def build_error_for_files(cause, files); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#110
+  sig { params(gem: ::Tapioca::Gemfile::GemSpec).void }
+  def compile_gem_rbi(gem); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#225
+  sig { params(gem_name: ::String).returns(::Pathname) }
+  def existing_rbi(gem_name); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#273
+  sig { returns(T::Hash[::String, ::String]) }
+  def existing_rbis; end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#237
+  sig { params(gem_name: ::String).returns(::Pathname) }
+  def expected_rbi(gem_name); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#279
+  sig { returns(T::Hash[::String, ::String]) }
+  def expected_rbis; end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#98
+  sig do
+    params(
+      gem: ::Tapioca::Gemfile::GemSpec,
+      dependencies: T::Array[::Tapioca::Gemfile::GemSpec]
+    ).returns(T::Array[::Tapioca::Gemfile::GemSpec])
+  end
+  def gem_dependencies(gem, dependencies = T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#242
+  sig { params(gem_name: ::String).returns(T::Boolean) }
+  def gem_rbi_exists?(gem_name); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#286
+  sig { params(gem_name: ::String, version: ::String).returns(::Pathname) }
+  def gem_rbi_filename(gem_name, version); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#77
+  sig { params(gem_names: T::Array[::String]).returns(T::Array[::Tapioca::Gemfile::GemSpec]) }
+  def gems_to_generate(gem_names); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#296
+  sig { params(gem: ::Tapioca::Gemfile::GemSpec, file: ::RBI::File).void }
+  def merge_with_exported_rbi(gem, file); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#267
+  sig { params(old_filename: ::Pathname, new_filename: ::Pathname).void }
+  def move(old_filename, new_filename); end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#177
+  sig { void }
+  def perform_additions; end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#150
+  sig { void }
+  def perform_removals; end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#220
+  sig { returns(T::Array[::String]) }
+  def removed_rbis; end
+
+  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#247
+  sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void }
+  def report_diff_and_exit_if_out_of_date(diff, command); end
+end
+
+# source://tapioca//lib/tapioca/commands/annotations.rb#6
+class Tapioca::Commands::Annotations < ::Tapioca::Commands::CommandWithoutTracker
+  # source://tapioca//lib/tapioca/commands/annotations.rb#18
+  sig do
+    params(
+      central_repo_root_uris: T::Array[::String],
+      auth: T.nilable(::String),
+      netrc_file: T.nilable(::String),
+      central_repo_index_path: ::String,
+      typed_overrides: T::Hash[::String, ::String]
+    ).void
+  end
+  def initialize(central_repo_root_uris:, auth: T.unsafe(nil), netrc_file: T.unsafe(nil), central_repo_index_path: T.unsafe(nil), typed_overrides: T.unsafe(nil)); end
+
+  private
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#197
+  sig { params(name: ::String, content: ::String).returns(::String) }
+  def add_header(name, content); end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#217
+  sig { params(name: ::String, content: ::String).returns(::String) }
+  def apply_typed_override(name, content); end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#39
+  sig { override.void }
+  def execute; end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#136
+  sig { params(repo_uris: T::Array[::String], gem_info: ::Tapioca::GemInfo).void }
+  def fetch_annotation(repo_uris, gem_info); end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#113
+  sig { params(project_gems: T::Array[::Tapioca::GemInfo]).returns(T::Array[::String]) }
+  def fetch_annotations(project_gems); end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#156
+  sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
+  def fetch_file(repo_uri, path); end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#173
+  sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
+  def fetch_http_file(repo_uri, path); end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#102
+  sig { params(repo_uri: ::String, repo_number: T.nilable(::Integer)).returns(T.nilable(Tapioca::RepoIndex)) }
+  def fetch_index(repo_uri, repo_number:); end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#81
+  sig { returns(T::Hash[::String, Tapioca::RepoIndex]) }
+  def fetch_indexes; end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#165
+  sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
+  def fetch_local_file(repo_uri, path); end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#229
+  sig { params(gem_version: ::Gem::Version, content: ::String).returns(::String) }
+  def filter_versions(gem_version, content); end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#50
+  sig { returns(T::Array[::Tapioca::GemInfo]) }
+  def list_gemfile_gems; end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#237
+  sig { params(gem_name: ::String, contents: T::Array[::String]).returns(T.nilable(::String)) }
+  def merge_files(gem_name, contents); end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#60
+  sig { params(project_gems: T::Array[::Tapioca::GemInfo]).void }
+  def remove_expired_annotations(project_gems); end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#264
+  sig { returns(T::Hash[::String, T.nilable(::String)]) }
+  def repo_tokens; end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#292
+  sig { params(path: ::String, repo_uri: ::String, message: ::String).void }
+  def say_http_error(path, repo_uri, message:); end
+
+  # source://tapioca//lib/tapioca/commands/annotations.rb#276
+  sig { params(repo_uri: ::String).returns(T.nilable(::String)) }
+  def token_for(repo_uri); end
+end
+
+# source://tapioca//lib/tapioca/commands/check_shims.rb#6
+class Tapioca::Commands::CheckShims < ::Tapioca::Commands::CommandWithoutTracker
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIFilesHelper
+
+  # source://tapioca//lib/tapioca/commands/check_shims.rb#22
+  sig do
+    params(
+      gem_rbi_dir: ::String,
+      dsl_rbi_dir: ::String,
+      annotations_rbi_dir: ::String,
+      shim_rbi_dir: ::String,
+      todo_rbi_file: ::String,
+      payload: T::Boolean,
+      number_of_workers: T.nilable(::Integer)
+    ).void
+  end
+  def initialize(gem_rbi_dir:, dsl_rbi_dir:, annotations_rbi_dir:, shim_rbi_dir:, todo_rbi_file:, payload:, number_of_workers:); end
+
+  private
+
+  # source://tapioca//lib/tapioca/commands/check_shims.rb#44
+  sig { override.void }
+  def execute; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca//lib/tapioca/commands/command.rb#6
+class Tapioca::Commands::Command
+  include ::Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+  include ::Tapioca::CliHelper
+  extend ::Thor::Base::ClassMethods
+  extend ::Thor::Invocation::ClassMethods
+
+  abstract!
+
+  # source://tapioca//lib/tapioca/commands/command.rb#20
+  sig { void }
+  def initialize; end
+
+  # source://thor/1.3.2/lib/thor/base.rb#155
+  sig { returns(::Thor::Actions) }
+  def file_writer; end
+
+  # source://tapioca//lib/tapioca/commands/command.rb#25
+  sig(:final) { void }
+  def run; end
+
+  private
+
+  # source://tapioca//lib/tapioca/commands/command.rb#53
+  sig do
+    params(
+      path: T.any(::Pathname, ::String),
+      content: ::String,
+      force: T::Boolean,
+      skip: T::Boolean,
+      verbose: T::Boolean
+    ).void
+  end
+  def create_file(path, content, force: T.unsafe(nil), skip: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/commands/command.rb#37
+  sig { params(command: ::Symbol, args: ::String).returns(::String) }
+  def default_command(command, *args); end
+
+  # @abstract
+  #
+  # source://tapioca//lib/tapioca/commands/command.rb#34
+  sig { abstract.void }
+  def execute; end
+
+  # source://tapioca//lib/tapioca/commands/command.rb#63
+  sig { params(path: T.any(::Pathname, ::String), verbose: T::Boolean).void }
+  def remove_file(path, verbose: T.unsafe(nil)); end
+end
+
+# source://tapioca//lib/tapioca/commands/command.rb#10
+class Tapioca::Commands::Command::FileWriter < ::Thor
+  include ::Thor::Actions
+  extend ::Thor::Actions::ClassMethods
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca//lib/tapioca/commands/command_without_tracker.rb#6
+class Tapioca::Commands::CommandWithoutTracker < ::Tapioca::Commands::Command
+  abstract!
+
+  # source://tapioca//lib/tapioca/commands/command_without_tracker.rb#12
+  sig { void }
+  def initialize; end
+end
+
+# source://tapioca//lib/tapioca/commands/configure.rb#6
+class Tapioca::Commands::Configure < ::Tapioca::Commands::CommandWithoutTracker
+  # source://tapioca//lib/tapioca/commands/configure.rb#14
+  sig { params(sorbet_config: ::String, tapioca_config: ::String, default_postrequire: ::String).void }
+  def initialize(sorbet_config:, tapioca_config:, default_postrequire:); end
+
+  private
+
+  # source://tapioca//lib/tapioca/commands/configure.rb#79
+  sig { void }
+  def create_binstub; end
+
+  # source://tapioca//lib/tapioca/commands/configure.rb#69
+  sig { void }
+  def create_post_require; end
+
+  # source://tapioca//lib/tapioca/commands/configure.rb#40
+  sig { void }
+  def create_sorbet_config; end
+
+  # source://tapioca//lib/tapioca/commands/configure.rb#50
+  sig { void }
+  def create_tapioca_config; end
+
+  # source://tapioca//lib/tapioca/commands/configure.rb#32
+  sig { override.void }
+  def execute; end
+
+  # source://tapioca//lib/tapioca/commands/configure.rb#92
+  sig { returns(::Bundler::Installer) }
+  def installer; end
+
+  # source://tapioca//lib/tapioca/commands/configure.rb#97
+  sig { returns(T.any(::Bundler::StubSpecification, ::Gem::Specification)) }
+  def spec; end
+end
+
+# source://tapioca//lib/tapioca/commands/dsl_compiler_list.rb#6
+class Tapioca::Commands::DslCompilerList < ::Tapioca::Commands::AbstractDsl
+  private
+
+  # source://tapioca//lib/tapioca/commands/dsl_compiler_list.rb#10
+  sig { override.void }
+  def execute; end
+end
+
+# source://tapioca//lib/tapioca/commands/dsl_generate.rb#6
+class Tapioca::Commands::DslGenerate < ::Tapioca::Commands::AbstractDsl
+  private
+
+  # source://tapioca//lib/tapioca/commands/dsl_generate.rb#10
+  sig { override.void }
+  def execute; end
+end
+
+# source://tapioca//lib/tapioca/commands/dsl_verify.rb#6
+class Tapioca::Commands::DslVerify < ::Tapioca::Commands::AbstractDsl
+  private
+
+  # source://tapioca//lib/tapioca/commands/dsl_verify.rb#10
+  sig { override.void }
+  def execute; end
+end
+
+# source://tapioca//lib/tapioca/commands/gem_generate.rb#6
+class Tapioca::Commands::GemGenerate < ::Tapioca::Commands::AbstractGem
+  private
+
+  # source://tapioca//lib/tapioca/commands/gem_generate.rb#10
+  sig { override.void }
+  def execute; end
+end
+
+# source://tapioca//lib/tapioca/commands/gem_sync.rb#6
+class Tapioca::Commands::GemSync < ::Tapioca::Commands::AbstractGem
+  private
+
+  # source://tapioca//lib/tapioca/commands/gem_sync.rb#10
+  sig { override.void }
+  def execute; end
+end
+
+# source://tapioca//lib/tapioca/commands/gem_verify.rb#6
+class Tapioca::Commands::GemVerify < ::Tapioca::Commands::AbstractGem
+  private
+
+  # source://tapioca//lib/tapioca/commands/gem_verify.rb#10
+  sig { override.void }
+  def execute; end
+
+  # source://tapioca//lib/tapioca/commands/gem_verify.rb#17
+  sig { void }
+  def perform_sync_verification; end
+end
+
+# source://tapioca//lib/tapioca/commands/require.rb#6
+class Tapioca::Commands::Require < ::Tapioca::Commands::CommandWithoutTracker
+  # source://tapioca//lib/tapioca/commands/require.rb#13
+  sig { params(requires_path: ::String, sorbet_config_path: ::String).void }
+  def initialize(requires_path:, sorbet_config_path:); end
+
+  private
+
+  # source://tapioca//lib/tapioca/commands/require.rb#23
+  sig { override.void }
+  def execute; end
+end
+
+# source://tapioca//lib/tapioca/commands/todo.rb#6
+class Tapioca::Commands::Todo < ::Tapioca::Commands::CommandWithoutTracker
+  include ::Tapioca::SorbetHelper
+
+  # source://tapioca//lib/tapioca/commands/todo.rb#26
+  sig { params(todo_file: ::String, file_header: T::Boolean).void }
+  def initialize(todo_file:, file_header:); end
+
+  # source://tapioca//lib/tapioca/commands/todo.rb#34
+  sig { void }
+  def run_with_deprecation; end
+
+  private
+
+  # source://tapioca//lib/tapioca/commands/todo.rb#44
+  sig { override.void }
+  def execute; end
+
+  # source://tapioca//lib/tapioca/commands/todo.rb#68
+  sig { params(constants: T::Array[::String], command: ::String).returns(::RBI::File) }
+  def rbi(constants, command:); end
+
+  # source://tapioca//lib/tapioca/commands/todo.rb#88
+  sig { returns(T::Array[::String]) }
+  def unresolved_constants; end
+end
+
+# source://tapioca//lib/tapioca/commands/todo.rb#9
+Tapioca::Commands::Todo::DEPRECATION_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca/helpers/config_helper.rb#5
+module Tapioca::ConfigHelper
+  requires_ancestor { Thor }
+
+  # source://tapioca//lib/tapioca/helpers/config_helper.rb#18
+  sig { params(args: T.untyped, local_options: T.untyped, config: T.untyped).void }
+  def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/helpers/config_helper.rb#12
+  sig { returns(::String) }
+  def command_name; end
+
+  # source://tapioca//lib/tapioca/helpers/config_helper.rb#15
+  sig { returns(::Thor::CoreExt::HashWithIndifferentAccess) }
+  def defaults; end
+
+  # source://tapioca//lib/tapioca/helpers/config_helper.rb#34
+  sig { returns(::Thor::CoreExt::HashWithIndifferentAccess) }
+  def options; end
+
+  private
+
+  # source://tapioca//lib/tapioca/helpers/config_helper.rb#153
+  sig { params(msg: ::String).returns(::Tapioca::ConfigHelper::ConfigError) }
+  def build_error(msg); end
+
+  # source://tapioca//lib/tapioca/helpers/config_helper.rb#178
+  sig { params(config_file: ::String, errors: T::Array[::Tapioca::ConfigHelper::ConfigError]).returns(::String) }
+  def build_error_message(config_file, errors); end
+
+  # source://tapioca//lib/tapioca/helpers/config_helper.rb#56
+  sig do
+    params(
+      options: ::Thor::CoreExt::HashWithIndifferentAccess
+    ).returns(::Thor::CoreExt::HashWithIndifferentAccess)
+  end
+  def config_options(options); end
+
+  # source://tapioca//lib/tapioca/helpers/config_helper.rb#46
+  sig { params(options: T::Hash[::Symbol, ::Thor::Option]).void }
+  def filter_defaults(options); end
+
+  # source://tapioca//lib/tapioca/helpers/config_helper.rb#196
+  sig do
+    params(
+      options: T.nilable(::Thor::CoreExt::HashWithIndifferentAccess)
+    ).returns(::Thor::CoreExt::HashWithIndifferentAccess)
+  end
+  def merge_options(*options); end
+
+  # source://tapioca//lib/tapioca/helpers/config_helper.rb#70
+  sig { params(config_file: ::String, config: T::Hash[T.untyped, T.untyped]).void }
+  def validate_config!(config_file, config); end
+
+  # source://tapioca//lib/tapioca/helpers/config_helper.rb#102
+  sig do
+    params(
+      command_options: T::Hash[::Symbol, ::Thor::Option],
+      config_key: ::String,
+      config_options: T::Hash[T.untyped, T.untyped]
+    ).returns(T::Array[::Tapioca::ConfigHelper::ConfigError])
+  end
+  def validate_config_options(command_options, config_key, config_options); end
+end
+
+# source://tapioca//lib/tapioca/helpers/config_helper.rb#148
+class Tapioca::ConfigHelper::ConfigError < ::T::Struct
+  const :message_parts, T::Array[::Tapioca::ConfigHelper::ConfigErrorMessagePart]
+
+  class << self
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# source://tapioca//lib/tapioca/helpers/config_helper.rb#143
+class Tapioca::ConfigHelper::ConfigErrorMessagePart < ::T::Struct
+  const :message, ::String
+  const :colors, T::Array[::Symbol]
+
+  class << self
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# source://tapioca//lib/tapioca.rb#46
+Tapioca::DEFAULT_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#42
+Tapioca::DEFAULT_DSL_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#58
+Tapioca::DEFAULT_ENVIRONMENT = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#43
+Tapioca::DEFAULT_GEM_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#48
+Tapioca::DEFAULT_OVERRIDES = T.let(T.unsafe(nil), Hash)
+
+# source://tapioca//lib/tapioca.rb#40
+Tapioca::DEFAULT_POSTREQUIRE_FILE = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#41
+Tapioca::DEFAULT_RBI_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca/rbi_formatter.rb#31
+Tapioca::DEFAULT_RBI_FORMATTER = T.let(T.unsafe(nil), Tapioca::RBIFormatter)
+
+# source://tapioca//lib/tapioca.rb#57
+Tapioca::DEFAULT_RBI_MAX_LINE_LENGTH = T.let(T.unsafe(nil), Integer)
+
+# source://tapioca//lib/tapioca.rb#44
+Tapioca::DEFAULT_SHIM_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#45
+Tapioca::DEFAULT_TODO_FILE = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca/dsl/compilers.rb#5
+module Tapioca::Dsl; end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca//lib/tapioca/dsl/compiler.rb#6
+class Tapioca::Dsl::Compiler
+  extend T::Generic
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIHelper
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+  extend ::Tapioca::Runtime::AttachedClassOf
+  extend ::Tapioca::Runtime::Reflection
+
+  abstract!
+
+  ConstantType = type_member { { upper: Module } }
+
+  # source://tapioca//lib/tapioca/dsl/compiler.rb#107
+  sig do
+    params(
+      pipeline: ::Tapioca::Dsl::Pipeline,
+      root: ::RBI::Tree,
+      constant: ConstantType,
+      options: T::Hash[::String, T.untyped]
+    ).void
+  end
+  def initialize(pipeline, root, constant, options = T.unsafe(nil)); end
+
+  # NOTE: This should eventually accept an `Error` object or `Exception` rather than simply a `String`.
+  #
+  # source://tapioca//lib/tapioca/dsl/compiler.rb#125
+  sig { params(error: ::String).void }
+  def add_error(error); end
+
+  # source://tapioca//lib/tapioca/dsl/compiler.rb#116
+  sig { params(compiler_name: ::String).returns(T::Boolean) }
+  def compiler_enabled?(compiler_name); end
+
+  # source://tapioca//lib/tapioca/dsl/compiler.rb#20
+  sig { returns(ConstantType) }
+  def constant; end
+
+  # @abstract
+  #
+  # source://tapioca//lib/tapioca/dsl/compiler.rb#121
+  sig { abstract.void }
+  def decorate; end
+
+  # source://tapioca//lib/tapioca/dsl/compiler.rb#26
+  sig { returns(T::Hash[::String, T.untyped]) }
+  def options; end
+
+  # source://tapioca//lib/tapioca/dsl/compiler.rb#23
+  sig { returns(::RBI::Tree) }
+  def root; end
+
+  private
+
+  # source://tapioca//lib/tapioca/dsl/compiler.rb#174
+  sig { params(method_def: T.any(::Method, ::UnboundMethod)).returns(T::Array[::RBI::TypedParam]) }
+  def compile_method_parameters_to_rbi(method_def); end
+
+  # source://tapioca//lib/tapioca/dsl/compiler.rb#210
+  sig { params(method_def: T.any(::Method, ::UnboundMethod)).returns(::String) }
+  def compile_method_return_type_to_rbi(method_def); end
+
+  # source://tapioca//lib/tapioca/dsl/compiler.rb#164
+  sig { params(scope: ::RBI::Scope, method_def: T.any(::Method, ::UnboundMethod), class_method: T::Boolean).void }
+  def create_method_from_def(scope, method_def, class_method: T.unsafe(nil)); end
+
+  # Get the types of each parameter from a method signature
+  #
+  # source://tapioca//lib/tapioca/dsl/compiler.rb#138
+  sig { params(method_def: T.any(::Method, ::UnboundMethod), signature: T.untyped).returns(T::Array[::String]) }
+  def parameters_types_from_signature(method_def, signature); end
+
+  class << self
+    # @abstract
+    #
+    # source://tapioca//lib/tapioca/dsl/compiler.rb#39
+    sig { abstract.returns(T::Enumerable[::Module]) }
+    def gather_constants; end
+
+    # source://tapioca//lib/tapioca/dsl/compiler.rb#34
+    sig { params(constant: ::Module).returns(T::Boolean) }
+    def handles?(constant); end
+
+    # source://tapioca//lib/tapioca/dsl/compiler.rb#42
+    sig { returns(T::Set[::Module]) }
+    def processable_constants; end
+
+    # source://tapioca//lib/tapioca/dsl/compiler.rb#50
+    sig { params(constants: T::Array[::Module]).void }
+    def requested_constants=(constants); end
+
+    private
+
+    # source://tapioca//lib/tapioca/dsl/compiler.rb#75
+    sig { returns(T::Enumerable[T::Class[T.anything]]) }
+    def all_classes; end
+
+    # source://tapioca//lib/tapioca/dsl/compiler.rb#87
+    sig { returns(T::Enumerable[::Module]) }
+    def all_modules; end
+
+    # source://tapioca//lib/tapioca/dsl/compiler.rb#61
+    sig do
+      type_parameters(:U)
+        .params(
+          klass: T.all(T.type_parameter(:U), T::Class[T.anything])
+        ).returns(T::Array[T.type_parameter(:U)])
+    end
+    def descendants_of(klass); end
+  end
+end
+
+# source://tapioca//lib/tapioca/dsl/compilers.rb#6
+module Tapioca::Dsl::Compilers; end
+
+# DSL compilers are either built-in to Tapioca and live under the
+# `Tapioca::Dsl::Compilers` namespace (i.e. this namespace), and
+# can be referred to by just using the class name, or they live in
+# a different namespace and can only be referred to using their fully
+# qualified name. This constant encapsulates that dual lookup when
+# a compiler needs to be resolved by name.
+#
+# source://tapioca//lib/tapioca/dsl/compilers.rb#13
+Tapioca::Dsl::Compilers::NAMESPACES = T.let(T.unsafe(nil), Array)
+
+# source://tapioca//lib/tapioca/dsl/pipeline.rb#6
+class Tapioca::Dsl::Pipeline
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#39
+  sig do
+    params(
+      requested_constants: T::Array[::Module],
+      requested_paths: T::Array[::Pathname],
+      requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
+      excluded_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
+      error_handler: T.proc.params(error: ::String).void,
+      skipped_constants: T::Array[::Module],
+      number_of_workers: T.nilable(::Integer),
+      compiler_options: T::Hash[::String, T.untyped]
+    ).void
+  end
+  def initialize(requested_constants:, requested_paths: T.unsafe(nil), requested_compilers: T.unsafe(nil), excluded_compilers: T.unsafe(nil), error_handler: T.unsafe(nil), skipped_constants: T.unsafe(nil), number_of_workers: T.unsafe(nil), compiler_options: T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#10
+  sig { returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)]) }
+  def active_compilers; end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#102
+  sig { params(error: ::String).void }
+  def add_error(error); end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#107
+  sig { params(compiler_name: ::String).returns(T::Boolean) }
+  def compiler_enabled?(compiler_name); end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#116
+  sig { returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
+  def compilers; end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#22
+  sig { returns(T.proc.params(error: ::String).void) }
+  def error_handler; end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#25
+  sig { returns(T::Array[::String]) }
+  def errors; end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#13
+  sig { returns(T::Array[::Module]) }
+  def requested_constants; end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#16
+  sig { returns(T::Array[::Pathname]) }
+  def requested_paths; end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#67
+  sig do
+    type_parameters(:T)
+      .params(
+        blk: T.proc.params(constant: ::Module, rbi: ::RBI::File).returns(T.type_parameter(:T))
+      ).returns(T::Array[T.type_parameter(:T)])
+  end
+  def run(&blk); end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#19
+  sig { returns(T::Array[::Module]) }
+  def skipped_constants; end
+
+  private
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#224
+  sig { void }
+  def abort_if_pending_migrations!; end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#169
+  sig { params(constants: T::Set[::Module]).returns(T::Set[::Module]) }
+  def filter_anonymous_and_reloaded_constants(constants); end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#133
+  sig do
+    params(
+      requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
+      excluded_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)]
+    ).returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)])
+  end
+  def gather_active_compilers(requested_compilers, excluded_compilers); end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#147
+  sig do
+    params(
+      requested_constants: T::Array[::Module],
+      requested_paths: T::Array[::Pathname],
+      skipped_constants: T::Array[::Module]
+    ).returns(T::Set[::Module])
+  end
+  def gather_constants(requested_constants, requested_paths, skipped_constants); end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#198
+  sig { params(constant: ::Module).returns(T.nilable(::RBI::File)) }
+  def rbi_for_constant(constant); end
+
+  # source://tapioca//lib/tapioca/dsl/pipeline.rb#217
+  sig { params(error: ::String).returns(T.noreturn) }
+  def report_error(error); end
+end
+
+# source://tapioca//lib/tapioca/helpers/env_helper.rb#5
+module Tapioca::EnvHelper
+  requires_ancestor { Thor }
+
+  # source://tapioca//lib/tapioca/helpers/env_helper.rb#12
+  sig { params(options: T::Hash[::Symbol, T.untyped]).void }
+  def set_environment(options); end
+end
+
+class Tapioca::Error < ::StandardError; end
+
+# source://tapioca//lib/tapioca/executor.rb#5
+class Tapioca::Executor
+  # source://tapioca//lib/tapioca/executor.rb#11
+  sig { params(queue: T::Array[T.untyped], number_of_workers: T.nilable(::Integer)).void }
+  def initialize(queue, number_of_workers: T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/executor.rb#28
+  sig do
+    type_parameters(:T)
+      .params(
+        block: T.proc.params(item: T.untyped).returns(T.type_parameter(:T))
+      ).returns(T::Array[T.type_parameter(:T)])
+  end
+  def run_in_parallel(&block); end
+
+  private
+
+  # source://tapioca//lib/tapioca/executor.rb#37
+  sig { returns(::Integer) }
+  def max_processors; end
+end
+
+# source://tapioca//lib/tapioca/executor.rb#8
+Tapioca::Executor::MINIMUM_ITEMS_PER_WORKER = T.let(T.unsafe(nil), Integer)
+
+# source://tapioca//lib/tapioca/gem/events.rb#5
+module Tapioca::Gem; end
+
+# source://tapioca//lib/tapioca/gem/events.rb#77
+class Tapioca::Gem::ConstNodeAdded < ::Tapioca::Gem::NodeAdded
+  # source://tapioca//lib/tapioca/gem/events.rb#84
+  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Const).void }
+  def initialize(symbol, constant, node); end
+
+  # source://tapioca//lib/tapioca/gem/events.rb#81
+  sig { returns(::RBI::Const) }
+  def node; end
+end
+
+# source://tapioca//lib/tapioca/gem/events.rb#26
+class Tapioca::Gem::ConstantFound < ::Tapioca::Gem::Event
+  # source://tapioca//lib/tapioca/gem/events.rb#36
+  sig { params(symbol: ::String, constant: ::BasicObject).void }
+  def initialize(symbol, constant); end
+
+  # source://tapioca//lib/tapioca/gem/events.rb#33
+  sig { returns(::BasicObject) }
+  def constant; end
+
+  # source://tapioca//lib/tapioca/gem/events.rb#30
+  sig { returns(::String) }
+  def symbol; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca//lib/tapioca/gem/events.rb#6
+class Tapioca::Gem::Event
+  abstract!
+end
+
+# source://tapioca//lib/tapioca/gem/events.rb#43
+class Tapioca::Gem::ForeignConstantFound < ::Tapioca::Gem::ConstantFound
+  # source://tapioca//lib/tapioca/gem/events.rb#52
+  sig { params(symbol: ::String, constant: ::Module).void }
+  def initialize(symbol, constant); end
+
+  # source://tapioca//lib/tapioca/gem/events.rb#47
+  sig { override.returns(::Module) }
+  def constant; end
+end
+
+# source://tapioca//lib/tapioca/gem/events.rb#103
+class Tapioca::Gem::ForeignScopeNodeAdded < ::Tapioca::Gem::ScopeNodeAdded; end
+
+# source://tapioca//lib/tapioca/gem/listeners/base.rb#6
+module Tapioca::Gem::Listeners; end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca//lib/tapioca/gem/listeners/base.rb#7
+class Tapioca::Gem::Listeners::Base
+  abstract!
+
+  # source://tapioca//lib/tapioca/gem/listeners/base.rb#14
+  sig { params(pipeline: ::Tapioca::Gem::Pipeline).void }
+  def initialize(pipeline); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/base.rb#19
+  sig { params(event: ::Tapioca::Gem::NodeAdded).void }
+  def dispatch(event); end
+
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/base.rb#49
+  sig { params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/base.rb#37
+  sig { params(event: ::Tapioca::Gem::ConstNodeAdded).void }
+  def on_const(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/base.rb#45
+  sig { params(event: ::Tapioca::Gem::MethodNodeAdded).void }
+  def on_method(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/base.rb#41
+  sig { params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/dynamic_mixins.rb#7
+class Tapioca::Gem::Listeners::DynamicMixins < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/dynamic_mixins.rb#31
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/dynamic_mixins.rb#15
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/foreign_constants.rb#7
+class Tapioca::Gem::Listeners::ForeignConstants < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/foreign_constants.rb#60
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/foreign_constants.rb#55
+  sig { params(location: ::String).returns(T::Boolean) }
+  def mixed_in_by_gem?(location); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/foreign_constants.rb#15
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/methods.rb#7
+class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIHelper
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#35
+  sig do
+    params(
+      tree: ::RBI::Tree,
+      module_name: ::String,
+      mod: ::Module,
+      for_visibility: T::Array[::Symbol],
+      attached_class: T.nilable(::Module)
+    ).void
+  end
+  def compile_directly_owned_methods(tree, module_name, mod, for_visibility = T.unsafe(nil), attached_class: T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#71
+  sig do
+    params(
+      tree: ::RBI::Tree,
+      symbol_name: ::String,
+      constant: ::Module,
+      method: T.nilable(::UnboundMethod),
+      visibility: ::RBI::Visibility
+    ).void
+  end
+  def compile_method(tree, symbol_name, constant, method, visibility = T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#211
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#204
+  sig { params(constant: ::Module).returns(T.nilable(::UnboundMethod)) }
+  def initialize_method_for(constant); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#216
+  sig { params(method: ::UnboundMethod).returns(T.untyped) }
+  def lookup_signature_of(method); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#172
+  sig { params(mod: ::Module).returns(T::Hash[::Symbol, T::Array[::Symbol]]) }
+  def method_names_by_visibility(mod); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#196
+  sig { params(attached_class: T.nilable(::Module), method_name: ::Symbol).returns(T.nilable(T::Boolean)) }
+  def method_new_in_abstract_class?(attached_class, method_name); end
+
+  # Check whether the method is defined by the constant.
+  #
+  # In most cases, it works to check that the constant is the method owner. However,
+  # in the case that a method is also defined in a module prepended to the constant, it
+  # will be owned by the prepended module, not the constant.
+  #
+  # This method implements a better way of checking whether a constant defines a method.
+  # It walks up the ancestor tree via the `super_method` method; if any of the super
+  # methods are owned by the constant, it means that the constant declares the method.
+  #
+  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#158
+  sig { params(method: ::UnboundMethod, constant: ::Module).returns(T::Boolean) }
+  def method_owned_by_constant?(method, constant); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#16
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#181
+  sig { params(constant: ::Module, method_name: ::String).returns(T::Boolean) }
+  def struct_method?(constant, method_name); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/mixins.rb#7
+class Tapioca::Gem::Listeners::Mixins < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/mixins.rb#42
+  sig do
+    params(
+      tree: ::RBI::Tree,
+      constant: ::Module,
+      mods: T::Array[::Module],
+      mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type
+    ).void
+  end
+  def add_mixins(tree, constant, mods, mixin_type); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/mixins.rb#84
+  sig { params(mixin_name: ::String).returns(T::Boolean) }
+  def filtered_mixin?(mixin_name); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/mixins.rb#91
+  sig { params(constant: ::Module).returns(T::Array[::Module]) }
+  def interesting_ancestors_of(constant); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/mixins.rb#75
+  sig do
+    params(
+      constant: ::Module,
+      mixin: ::Module,
+      mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type
+    ).returns(T::Boolean)
+  end
+  def mixed_in_by_gem?(constant, mixin, mixin_type); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/mixins.rb#15
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb#7
+class Tapioca::Gem::Listeners::RemoveEmptyPayloadScopes < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb#20
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb#15
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/sorbet_enums.rb#7
+class Tapioca::Gem::Listeners::SorbetEnums < ::Tapioca::Gem::Listeners::Base
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_enums.rb#28
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_enums.rb#13
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/sorbet_helpers.rb#7
+class Tapioca::Gem::Listeners::SorbetHelpers < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_helpers.rb#27
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_helpers.rb#15
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/sorbet_props.rb#7
+class Tapioca::Gem::Listeners::SorbetProps < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIHelper
+
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_props.rb#33
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_props.rb#14
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/sorbet_required_ancestors.rb#7
+class Tapioca::Gem::Listeners::SorbetRequiredAncestors < ::Tapioca::Gem::Listeners::Base
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_required_ancestors.rb#23
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_required_ancestors.rb#13
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/sorbet_signatures.rb#7
+class Tapioca::Gem::Listeners::SorbetSignatures < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIHelper
+
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_signatures.rb#26
+  sig { params(signature: T.untyped, parameters: T::Array[[::Symbol, ::String]]).returns(::RBI::Sig) }
+  def compile_signature(signature, parameters); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_signatures.rb#79
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_signatures.rb#18
+  sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
+  def on_method(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_signatures.rb#68
+  sig { params(signature: T.untyped).returns(T::Boolean) }
+  def signature_final?(signature); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/sorbet_signatures.rb#13
+Tapioca::Gem::Listeners::SorbetSignatures::TYPE_PARAMETER_MATCHER = T.let(T.unsafe(nil), Regexp)
+
+# source://tapioca//lib/tapioca/gem/listeners/sorbet_type_variables.rb#7
+class Tapioca::Gem::Listeners::SorbetTypeVariables < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_type_variables.rb#27
+  sig { params(tree: ::RBI::Tree, constant: ::Module).void }
+  def compile_type_variable_declarations(tree, constant); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_type_variables.rb#63
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_type_variables.rb#50
+  sig { params(type_variable: ::Tapioca::TypeVariableModule).returns(T.nilable(::RBI::Node)) }
+  def node_from_type_variable(type_variable); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/sorbet_type_variables.rb#15
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/source_location.rb#7
+class Tapioca::Gem::Listeners::SourceLocation < ::Tapioca::Gem::Listeners::Base
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/source_location.rb#41
+  sig { params(node: ::RBI::NodeWithComments, file: T.nilable(::String), line: T.nilable(::Integer)).void }
+  def add_source_location_comment(node, file, line); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/source_location.rb#13
+  sig { override.params(event: ::Tapioca::Gem::ConstNodeAdded).void }
+  def on_const(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/source_location.rb#35
+  sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
+  def on_method(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/source_location.rb#19
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/subconstants.rb#7
+class Tapioca::Gem::Listeners::Subconstants < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/subconstants.rb#36
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/subconstants.rb#15
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#7
+class Tapioca::Gem::Listeners::YardDoc < ::Tapioca::Gem::Listeners::Base
+  # source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#27
+  sig { params(pipeline: ::Tapioca::Gem::Pipeline).void }
+  def initialize(pipeline); end
+
+  private
+
+  # source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#55
+  sig { params(name: ::String, sigs: T::Array[::RBI::Sig]).returns(T::Array[::RBI::Comment]) }
+  def documentation_comments(name, sigs: T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#99
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#36
+  sig { override.params(event: ::Tapioca::Gem::ConstNodeAdded).void }
+  def on_const(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#46
+  sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
+  def on_method(event); end
+
+  # source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#41
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#10
+Tapioca::Gem::Listeners::YardDoc::IGNORED_COMMENTS = T.let(T.unsafe(nil), Array)
+
+# source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#24
+Tapioca::Gem::Listeners::YardDoc::IGNORED_SIG_TAGS = T.let(T.unsafe(nil), Array)
+
+# source://tapioca//lib/tapioca/gem/events.rb#105
+class Tapioca::Gem::MethodNodeAdded < ::Tapioca::Gem::NodeAdded
+  # source://tapioca//lib/tapioca/gem/events.rb#130
+  sig do
+    params(
+      symbol: ::String,
+      constant: ::Module,
+      method: ::UnboundMethod,
+      node: ::RBI::Method,
+      signature: T.untyped,
+      parameters: T::Array[[::Symbol, ::String]]
+    ).void
+  end
+  def initialize(symbol, constant, method, node, signature, parameters); end
+
+  # source://tapioca//lib/tapioca/gem/events.rb#109
+  sig { returns(::UnboundMethod) }
+  def method; end
+
+  # source://tapioca//lib/tapioca/gem/events.rb#112
+  sig { returns(::RBI::Method) }
+  def node; end
+
+  # source://tapioca//lib/tapioca/gem/events.rb#118
+  sig { returns(T::Array[[::Symbol, ::String]]) }
+  def parameters; end
+
+  # source://tapioca//lib/tapioca/gem/events.rb#115
+  sig { returns(T.untyped) }
+  def signature; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca//lib/tapioca/gem/events.rb#57
+class Tapioca::Gem::NodeAdded < ::Tapioca::Gem::Event
+  abstract!
+
+  # source://tapioca//lib/tapioca/gem/events.rb#70
+  sig { params(symbol: ::String, constant: ::Module).void }
+  def initialize(symbol, constant); end
+
+  # source://tapioca//lib/tapioca/gem/events.rb#67
+  sig { returns(::Module) }
+  def constant; end
+
+  # source://tapioca//lib/tapioca/gem/events.rb#64
+  sig { returns(::String) }
+  def symbol; end
+end
+
+# source://tapioca//lib/tapioca/gem/pipeline.rb#6
+class Tapioca::Gem::Pipeline
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIHelper
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#27
+  sig do
+    params(
+      gem: ::Tapioca::Gemfile::GemSpec,
+      error_handler: T.proc.params(error: ::String).void,
+      include_doc: T::Boolean,
+      include_loc: T::Boolean
+    ).void
+  end
+  def initialize(gem, error_handler:, include_doc: T.unsafe(nil), include_loc: T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#64
+  sig { returns(::RBI::Tree) }
+  def compile; end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#135
+  sig { params(name: T.any(::String, ::Symbol)).returns(T::Boolean) }
+  def constant_in_gem?(name); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#17
+  sig { returns(T.proc.params(error: ::String).void) }
+  def error_handler; end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#14
+  sig { returns(::Tapioca::Gemfile::GemSpec) }
+  def gem; end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#153
+  sig { params(method: ::UnboundMethod).returns(T::Boolean) }
+  def method_in_gem?(method); end
+
+  # Helpers
+  #
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#163
+  sig { params(constant: ::Module).returns(T.nilable(::String)) }
+  def name_of(constant); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#87
+  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Const).void }
+  def push_const(symbol, constant, node); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#77
+  sig { params(symbol: ::String, constant: ::BasicObject).void }
+  def push_constant(symbol, constant); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#82
+  sig { params(symbol: ::String, constant: ::Module).void }
+  def push_foreign_constant(symbol, constant); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#101
+  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void }
+  def push_foreign_scope(symbol, constant, node); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#115
+  sig do
+    params(
+      symbol: ::String,
+      constant: ::Module,
+      method: ::UnboundMethod,
+      node: ::RBI::Method,
+      signature: T.untyped,
+      parameters: T::Array[[::Symbol, ::String]]
+    ).void
+  end
+  def push_method(symbol, constant, method, node, signature, parameters); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#94
+  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void }
+  def push_scope(symbol, constant, node); end
+
+  # Events handling
+  #
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#72
+  sig { params(symbol: ::String).void }
+  def push_symbol(symbol); end
+
+  # Constants and properties filtering
+  #
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#122
+  sig { params(symbol_name: ::String).returns(T::Boolean) }
+  def symbol_in_payload?(symbol_name); end
+
+  private
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#456
+  sig { params(name: ::String).void }
+  def add_to_alias_namespace(name); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#461
+  sig { params(name: ::String).returns(T::Boolean) }
+  def alias_namespaced?(name); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#260
+  sig { params(name: ::String, constant: ::Module).void }
+  def compile_alias(name, constant); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#246
+  sig { params(symbol: ::String, constant: ::BasicObject).void }
+  def compile_constant(symbol, constant); end
+
+  # Compiling
+  #
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#235
+  sig { params(symbol: ::String, constant: ::Module).void }
+  def compile_foreign_constant(symbol, constant); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#314
+  sig { params(name: ::String, constant: ::Module).void }
+  def compile_module(name, constant); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#281
+  sig { params(name: ::String, value: ::BasicObject).void }
+  def compile_object(name, value); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#325
+  sig { params(name: ::String, constant: ::Module).returns(::RBI::Scope) }
+  def compile_scope(name, constant); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#339
+  sig { params(constant: T::Class[T.anything]).returns(T.nilable(::String)) }
+  def compile_superclass(constant); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#437
+  sig { params(constant: ::Module, strict: T::Boolean).returns(T::Boolean) }
+  def defined_in_gem?(constant, strict: T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#193
+  sig { params(event: ::Tapioca::Gem::Event).void }
+  def dispatch(event); end
+
+  # Helpers
+  #
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#480
+  sig { params(constant: T.all(::Module, ::T::Generic)).returns(::String) }
+  def generic_name_of(constant); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#449
+  sig { params(constant: ::Module).returns(T::Set[::String]) }
+  def get_file_candidates(constant); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#178
+  sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
+  def load_bootstrap_symbols(gem); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#496
+  sig { params(constant: ::Module, class_name: T.nilable(::String)).returns(T.nilable(::String)) }
+  def name_of_proxy_target(constant, class_name); end
+
+  # Events handling
+  #
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#188
+  sig { returns(::Tapioca::Gem::Event) }
+  def next_event; end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#216
+  sig { params(event: ::Tapioca::Gem::ConstantFound).void }
+  def on_constant(event); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#228
+  sig { params(event: ::Tapioca::Gem::NodeAdded).void }
+  def on_node(event); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#207
+  sig { params(event: ::Tapioca::Gem::SymbolFound).void }
+  def on_symbol(event); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#468
+  sig { params(name: ::String).void }
+  def seen!(name); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#473
+  sig { params(name: ::String).returns(T::Boolean) }
+  def seen?(name); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#407
+  sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
+  def skip_alias?(name, constant); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#395
+  sig { params(name: ::String, constant: T.anything).returns(T::Boolean) }
+  def skip_constant?(name, constant); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#424
+  sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
+  def skip_foreign_constant?(name, constant); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#429
+  sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
+  def skip_module?(name, constant); end
+
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#416
+  sig { params(name: ::String, constant: ::BasicObject).returns(T::Boolean) }
+  def skip_object?(name, constant); end
+
+  # Constants and properties filtering
+  #
+  # source://tapioca//lib/tapioca/gem/pipeline.rb#390
+  sig { params(name: ::String).returns(T::Boolean) }
+  def skip_symbol?(name); end
+end
+
+# this looks something like:
+# "(eval at /path/to/file.rb:123)"
+# and we are just interested in the "/path/to/file.rb" part
+#
+# source://tapioca//lib/tapioca/gem/pipeline.rb#132
+Tapioca::Gem::Pipeline::EVAL_SOURCE_FILE_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# source://tapioca//lib/tapioca/gem/pipeline.rb#11
+Tapioca::Gem::Pipeline::IGNORED_SYMBOLS = T.let(T.unsafe(nil), Array)
+
+# source://tapioca//lib/tapioca/gem/events.rb#90
+class Tapioca::Gem::ScopeNodeAdded < ::Tapioca::Gem::NodeAdded
+  # source://tapioca//lib/tapioca/gem/events.rb#97
+  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void }
+  def initialize(symbol, constant, node); end
+
+  # source://tapioca//lib/tapioca/gem/events.rb#94
+  sig { returns(::RBI::Scope) }
+  def node; end
+end
+
+# source://tapioca//lib/tapioca/gem/events.rb#13
+class Tapioca::Gem::SymbolFound < ::Tapioca::Gem::Event
+  # source://tapioca//lib/tapioca/gem/events.rb#20
+  sig { params(symbol: ::String).void }
+  def initialize(symbol); end
+
+  # source://tapioca//lib/tapioca/gem/events.rb#17
+  sig { returns(::String) }
+  def symbol; end
+end
+
+# source://tapioca//lib/tapioca/helpers/gem_helper.rb#5
+module Tapioca::GemHelper
+  # source://tapioca//lib/tapioca/helpers/gem_helper.rb#9
+  sig { params(app_dir: T.any(::Pathname, ::String), full_gem_path: ::String).returns(T::Boolean) }
+  def gem_in_app_dir?(app_dir, full_gem_path); end
+
+  # source://tapioca//lib/tapioca/helpers/gem_helper.rb#17
+  sig { params(full_gem_path: ::String).returns(T::Boolean) }
+  def gem_in_bundle_path?(full_gem_path); end
+
+  # source://tapioca//lib/tapioca/helpers/gem_helper.rb#22
+  sig { params(full_gem_path: ::String).returns(T::Boolean) }
+  def gem_in_ruby_path?(full_gem_path); end
+
+  # source://tapioca//lib/tapioca/helpers/gem_helper.rb#27
+  sig { params(path: T.any(::Pathname, ::String)).returns(::String) }
+  def to_realpath(path); end
+
+  private
+
+  # source://tapioca//lib/tapioca/helpers/gem_helper.rb#36
+  sig { params(path: T.any(::Pathname, ::String), dir: T.any(::Pathname, ::String)).returns(T::Boolean) }
+  def path_in_dir?(path, dir); end
+end
+
+# source://tapioca//lib/tapioca/gem_info.rb#5
+class Tapioca::GemInfo < ::T::Struct
+  const :name, ::String
+  const :version, ::Gem::Version
+
+  class << self
+    # source://tapioca//lib/tapioca/gem_info.rb#13
+    sig { params(spec: ::Bundler::LazySpecification).returns(::Tapioca::GemInfo) }
+    def from_spec(spec); end
+
+    # source://sorbet-runtime/0.5.11589/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# source://tapioca//lib/tapioca/gemfile.rb#7
+class Tapioca::Gemfile
+  # source://tapioca//lib/tapioca/gemfile.rb#27
+  sig { params(excluded_gems: T::Array[::String]).void }
+  def initialize(excluded_gems); end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#18
+  sig { returns(::Bundler::Definition) }
+  def definition; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#21
+  sig { returns(T::Array[::Tapioca::Gemfile::GemSpec]) }
+  def dependencies; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#40
+  sig { params(gem_name: ::String).returns(T.nilable(::Tapioca::Gemfile::GemSpec)) }
+  def gem(gem_name); end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#24
+  sig { returns(T::Array[::String]) }
+  def missing_specs; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#45
+  sig { void }
+  def require_bundle; end
+
+  private
+
+  # source://tapioca//lib/tapioca/gemfile.rb#92
+  sig { returns(::String) }
+  def dir; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#54
+  sig { returns(::File) }
+  def gemfile; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#87
+  sig { returns(T::Array[::Symbol]) }
+  def groups; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#57
+  sig { returns([T::Array[::Tapioca::Gemfile::GemSpec], T::Array[::String]]) }
+  def load_dependencies; end
+
+  # @return [File]
+  #
+  # source://tapioca//lib/tapioca/gemfile.rb#54
+  def lockfile; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#68
+  sig { returns([T::Enumerable[T.any(::Bundler::StubSpecification, ::Gem::Specification)], T::Array[::String]]) }
+  def materialize_deps; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#82
+  sig { returns(::Bundler::Runtime) }
+  def runtime; end
+end
+
+# source://tapioca//lib/tapioca/gemfile.rb#96
+class Tapioca::Gemfile::GemSpec
+  include ::Tapioca::GemHelper
+
+  # source://tapioca//lib/tapioca/gemfile.rb#136
+  sig { params(spec: T.any(::Bundler::StubSpecification, ::Gem::Specification)).void }
+  def initialize(spec); end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#146
+  sig { params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#171
+  sig { params(path: ::String).returns(T::Boolean) }
+  def contains_path?(path); end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#161
+  sig { returns(T::Array[::Gem::Dependency]) }
+  def dependencies; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#201
+  sig { returns(T::Boolean) }
+  def export_rbi_files?; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#196
+  sig { returns(T::Array[::String]) }
+  def exported_rbi_files; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#206
+  sig { returns(::RBI::MergeTree) }
+  def exported_rbi_tree; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#133
+  sig { returns(T::Array[::Pathname]) }
+  def files; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#130
+  sig { returns(::String) }
+  def full_gem_path; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#151
+  sig { params(gemfile_dir: ::String).returns(T::Boolean) }
+  def ignore?(gemfile_dir); end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#156
+  sig { returns(::String) }
+  def name; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#180
+  sig { void }
+  def parse_yard_docs; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#166
+  sig { returns(::String) }
+  def rbi_file_name; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#218
+  sig { params(file: ::Pathname).returns(::Pathname) }
+  def relative_path_for(file); end
+
+  # @return [String]
+  #
+  # source://tapioca//lib/tapioca/gemfile.rb#130
+  def version; end
+
+  private
+
+  # source://tapioca//lib/tapioca/gemfile.rb#229
+  sig { returns(T::Array[::Pathname]) }
+  def collect_files; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#244
+  sig { returns(T.nilable(T::Boolean)) }
+  def default_gem?; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#303
+  sig { returns(T::Boolean) }
+  def gem_ignored?; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#282
+  sig { params(path: ::String).returns(T::Boolean) }
+  def has_parent_gemspec?(path); end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#249
+  sig { returns(::Regexp) }
+  def require_paths_prefix_matcher; end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#261
+  sig { params(file: ::String).returns(::Pathname) }
+  def resolve_to_ruby_lib_dir(file); end
+
+  # source://tapioca//lib/tapioca/gemfile.rb#275
+  sig { returns(::String) }
+  def version_string; end
+
+  class << self
+    # source://tapioca//lib/tapioca/gemfile.rb#104
+    sig { returns(T::Hash[::String, ::Tapioca::Gemfile::GemSpec]) }
+    def spec_lookup_by_file_path; end
+  end
+end
+
+# source://tapioca//lib/tapioca/gemfile.rb#116
+Tapioca::Gemfile::GemSpec::IGNORED_GEMS = T.let(T.unsafe(nil), Array)
+
+# source://tapioca//lib/tapioca/gemfile.rb#10
+Tapioca::Gemfile::Spec = T.type_alias { T.any(::Bundler::StubSpecification, ::Gem::Specification) }
+
+# source://tapioca//lib/tapioca.rb#33
+Tapioca::LIB_ROOT_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca/loaders/loader.rb#5
+module Tapioca::Loaders; end
+
+# source://tapioca//lib/tapioca/loaders/dsl.rb#6
+class Tapioca::Loaders::Dsl < ::Tapioca::Loaders::Loader
+  # source://tapioca//lib/tapioca/loaders/dsl.rb#38
+  sig do
+    params(
+      tapioca_path: ::String,
+      eager_load: T::Boolean,
+      app_root: ::String,
+      halt_upon_load_error: T::Boolean
+    ).void
+  end
+  def initialize(tapioca_path:, eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/loaders/dsl.rb#27
+  sig { override.void }
+  def load; end
+
+  protected
+
+  # source://tapioca//lib/tapioca/loaders/dsl.rb#88
+  sig { void }
+  def load_application; end
+
+  # source://tapioca//lib/tapioca/loaders/dsl.rb#63
+  sig { void }
+  def load_dsl_compilers; end
+
+  # source://tapioca//lib/tapioca/loaders/dsl.rb#48
+  sig { void }
+  def load_dsl_extensions; end
+
+  class << self
+    # source://tapioca//lib/tapioca/loaders/dsl.rb#15
+    sig do
+      params(
+        tapioca_path: ::String,
+        eager_load: T::Boolean,
+        app_root: ::String,
+        halt_upon_load_error: T::Boolean
+      ).void
+    end
+    def load_application(tapioca_path:, eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
+  end
+end
+
+# source://tapioca//lib/tapioca/loaders/gem.rb#6
+class Tapioca::Loaders::Gem < ::Tapioca::Loaders::Loader
+  # source://tapioca//lib/tapioca/loaders/gem.rb#49
+  sig do
+    params(
+      bundle: ::Tapioca::Gemfile,
+      prerequire: T.nilable(::String),
+      postrequire: ::String,
+      default_command: ::String,
+      halt_upon_load_error: T::Boolean
+    ).void
+  end
+  def initialize(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:); end
+
+  # source://tapioca//lib/tapioca/loaders/gem.rb#34
+  sig { override.void }
+  def load; end
+
+  protected
+
+  # source://tapioca//lib/tapioca/loaders/gem.rb#80
+  sig { params(file: ::String, error: ::LoadError).void }
+  def explain_failed_require(file, error); end
+
+  # source://tapioca//lib/tapioca/loaders/gem.rb#60
+  sig { void }
+  def require_gem_file; end
+
+  class << self
+    # source://tapioca//lib/tapioca/loaders/gem.rb#21
+    sig do
+      params(
+        bundle: ::Tapioca::Gemfile,
+        prerequire: T.nilable(::String),
+        postrequire: ::String,
+        default_command: ::String,
+        halt_upon_load_error: T::Boolean
+      ).void
+    end
+    def load_application(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:); end
+  end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca//lib/tapioca/loaders/loader.rb#6
+class Tapioca::Loaders::Loader
+  include ::Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+  include ::Tapioca::CliHelper
+  include ::Tapioca::GemHelper
+  extend ::Thor::Base::ClassMethods
+  extend ::Thor::Invocation::ClassMethods
+
+  abstract!
+
+  # @abstract
+  #
+  # source://tapioca//lib/tapioca/loaders/loader.rb#17
+  sig { abstract.void }
+  def load; end
+
+  private
+
+  # Rails 7.2 renamed `eager_load_paths` to `all_eager_load_paths`, which maintains the same original functionality.
+  # The `eager_load_paths` method still exists, but doesn't return all paths anymore and causes Tapioca to miss some
+  # engine paths. The following commit is the change:
+  # https://github.com/rails/rails/commit/ebfca905db14020589c22e6937382e6f8f687664
+  #
+  # @param engine [T.class_of(Rails::Engine)]
+  # @return [Array<String>]
+  #
+  # source://tapioca//lib/tapioca/loaders/loader.rb#234
+  def eager_load_paths(engine); end
+
+  # source://tapioca//lib/tapioca/loaders/loader.rb#199
+  sig { void }
+  def eager_load_rails_app; end
+
+  # @return [Array<T.class_of(Rails::Engine)>]
+  #
+  # source://tapioca//lib/tapioca/loaders/loader.rb#178
+  def engines; end
+
+  # source://tapioca//lib/tapioca/loaders/loader.rb#29
+  sig do
+    params(
+      gemfile: ::Tapioca::Gemfile,
+      initialize_file: T.nilable(::String),
+      require_file: T.nilable(::String),
+      halt_upon_load_error: T::Boolean
+    ).void
+  end
+  def load_bundle(gemfile, initialize_file, require_file, halt_upon_load_error); end
+
+  # source://tapioca//lib/tapioca/loaders/loader.rb#136
+  sig { void }
+  def load_engines_in_classic_mode; end
+
+  # source://tapioca//lib/tapioca/loaders/loader.rb#114
+  sig { void }
+  def load_engines_in_zeitwerk_mode; end
+
+  # source://tapioca//lib/tapioca/loaders/loader.rb#49
+  sig do
+    params(
+      environment_load: T::Boolean,
+      eager_load: T::Boolean,
+      app_root: ::String,
+      halt_upon_load_error: T::Boolean
+    ).void
+  end
+  def load_rails_application(environment_load: T.unsafe(nil), eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/loaders/loader.rb#89
+  sig { void }
+  def load_rails_engines; end
+
+  # source://tapioca//lib/tapioca/loaders/loader.rb#220
+  sig { params(file: T.nilable(::String)).void }
+  def require_helper(file); end
+
+  # source://tapioca//lib/tapioca/loaders/loader.rb#103
+  def run_initializers; end
+
+  # source://tapioca//lib/tapioca/loaders/loader.rb#192
+  sig { params(path: ::String).void }
+  def safe_require(path); end
+
+  # source://tapioca//lib/tapioca/loaders/loader.rb#161
+  sig { params(blk: T.proc.void).void }
+  def with_rails_application(&blk); end
+
+  # source://tapioca//lib/tapioca/loaders/loader.rb#154
+  sig { returns(T::Boolean) }
+  def zeitwerk_mode?; end
+end
+
+# source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#5
+module Tapioca::RBIFilesHelper
+  requires_ancestor { Tapioca::SorbetHelper }
+  requires_ancestor { Thor::Shell }
+
+  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#48
+  sig do
+    params(
+      index: ::RBI::Index,
+      shim_rbi_dir: ::String,
+      todo_rbi_file: ::String
+    ).returns(T::Hash[::String, T::Array[::RBI::Node]])
+  end
+  def duplicated_nodes_from_index(index, shim_rbi_dir:, todo_rbi_file:); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#13
+  sig { params(index: ::RBI::Index, kind: ::String, file: ::String).void }
+  def index_rbi(index, kind, file); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#25
+  sig { params(index: ::RBI::Index, kind: ::String, dir: ::String, number_of_workers: T.nilable(::Integer)).void }
+  def index_rbis(index, kind, dir, number_of_workers:); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#65
+  sig { params(loc: ::RBI::Loc, path_prefix: T.nilable(::String)).returns(::String) }
+  def location_to_payload_url(loc, path_prefix:); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#86
+  sig do
+    params(
+      command: ::String,
+      gem_dir: ::String,
+      dsl_dir: ::String,
+      auto_strictness: T::Boolean,
+      gems: T::Array[::Tapioca::Gemfile::GemSpec],
+      compilers: T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)]
+    ).void
+  end
+  def validate_rbi_files(command:, gem_dir:, dsl_dir:, auto_strictness:, gems: T.unsafe(nil), compilers: T.unsafe(nil)); end
+
+  private
+
+  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#223
+  sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[::RBI::Scope]) }
+  def extract_empty_scopes(nodes); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#228
+  sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[T.any(::RBI::Attr, ::RBI::Method)]) }
+  def extract_methods_and_attrs(nodes); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#238
+  sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[T.any(::RBI::Mixin, ::RBI::RequiresAncestor)]) }
+  def extract_mixins(nodes); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#248
+  sig do
+    params(
+      nodes: T::Array[T.any(::RBI::Attr, ::RBI::Method)]
+    ).returns(T::Array[T.any(::RBI::Attr, ::RBI::Method)])
+  end
+  def extract_nodes_with_sigs(nodes); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#216
+  sig do
+    params(
+      nodes: T::Array[::RBI::Node],
+      shim_rbi_dir: ::String,
+      todo_rbi_file: ::String
+    ).returns(T::Array[::RBI::Node])
+  end
+  def extract_shims_and_todos(nodes, shim_rbi_dir:, todo_rbi_file:); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#280
+  sig { params(path: ::String).returns(::String) }
+  def gem_name_from_rbi_path(path); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#155
+  sig { params(index: ::RBI::Index, files: T::Array[::String], number_of_workers: T.nilable(::Integer)).void }
+  def parse_and_index_files(index, files, number_of_workers:); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#171
+  sig { params(nodes: T::Array[::RBI::Node], shim_rbi_dir: ::String, todo_rbi_file: ::String).returns(T::Boolean) }
+  def shims_or_todos_have_duplicates?(nodes, shim_rbi_dir:, todo_rbi_file:); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#253
+  sig { params(errors: T::Array[::Spoom::Sorbet::Errors::Error], gem_dir: ::String).void }
+  def update_gem_rbis_strictnesses(errors, gem_dir); end
+end
+
+# source://tapioca//lib/tapioca/rbi_formatter.rb#5
+class Tapioca::RBIFormatter < ::RBI::Formatter
+  # source://tapioca//lib/tapioca/rbi_formatter.rb#24
+  sig { params(file: ::RBI::File).void }
+  def write_empty_body_comment!(file); end
+
+  # source://tapioca//lib/tapioca/rbi_formatter.rb#15
+  sig { params(file: ::RBI::File, command: ::String, reason: T.nilable(::String)).void }
+  def write_header!(file, command, reason: T.unsafe(nil)); end
+end
+
+# source://tapioca//lib/tapioca/helpers/rbi_helper.rb#5
+module Tapioca::RBIHelper
+  include ::Tapioca::SorbetHelper
+  extend ::Tapioca::SorbetHelper
+  extend ::Tapioca::RBIHelper
+
+  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#91
+  sig { params(type: ::String).returns(::String) }
+  def as_nilable_type(type); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#100
+  sig { params(type: ::String).returns(::String) }
+  def as_non_nilable_type(type); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#72
+  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
+  def create_block_param(name, type:); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#62
+  sig { params(name: ::String, type: ::String, default: ::String).returns(::RBI::TypedParam) }
+  def create_kw_opt_param(name, type:, default:); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#57
+  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
+  def create_kw_param(name, type:); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#67
+  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
+  def create_kw_rest_param(name, type:); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#47
+  sig { params(name: ::String, type: ::String, default: ::String).returns(::RBI::TypedParam) }
+  def create_opt_param(name, type:, default:); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#42
+  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
+  def create_param(name, type:); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#52
+  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
+  def create_rest_param(name, type:); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#77
+  sig { params(param: ::RBI::Param, type: ::String).returns(::RBI::TypedParam) }
+  def create_typed_param(param, type); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#82
+  sig { params(sig_string: ::String).returns(::String) }
+  def sanitize_signature_types(sig_string); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#109
+  sig { params(name: ::String).returns(T::Boolean) }
+  def valid_method_name?(name); end
+
+  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#123
+  sig { params(name: ::String).returns(T::Boolean) }
+  def valid_parameter_name?(name); end
+
+  class << self
+    # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#23
+    sig do
+      params(
+        type: ::String,
+        variance: ::Symbol,
+        fixed: T.nilable(::String),
+        upper: T.nilable(::String),
+        lower: T.nilable(::String)
+      ).returns(::String)
+    end
+    def serialize_type_variable(type, variance, fixed, upper, lower); end
+  end
+end
+
+# source://tapioca//lib/tapioca/repo_index.rb#5
+class Tapioca::RepoIndex
+  # source://tapioca//lib/tapioca/repo_index.rb#26
+  sig { void }
+  def initialize; end
+
+  # source://tapioca//lib/tapioca/repo_index.rb#31
+  sig { params(gem_name: ::String).void }
+  def <<(gem_name); end
+
+  # source://tapioca//lib/tapioca/repo_index.rb#36
+  sig { returns(T::Enumerable[::String]) }
+  def gems; end
+
+  # source://tapioca//lib/tapioca/repo_index.rb#41
+  sig { params(gem_name: ::String).returns(T::Boolean) }
+  def has_gem?(gem_name); end
+
+  class << self
+    # source://tapioca//lib/tapioca/repo_index.rb#18
+    sig { params(hash: T::Hash[::String, T::Hash[T.untyped, T.untyped]]).returns(Tapioca::RepoIndex) }
+    def from_hash(hash); end
+
+    # source://tapioca//lib/tapioca/repo_index.rb#13
+    sig { params(json: ::String).returns(Tapioca::RepoIndex) }
+    def from_json(json); end
+  end
+end
+
+# source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#5
+module Tapioca::Runtime; end
+
+# This module should only be included when running versions of Ruby
+# older than 3.2. Because the Class#attached_object method is not
+# available, it implements finding the attached class of a singleton
+# class by iterating through ObjectSpace.
+module Tapioca::Runtime::AttachedClassOf
+  # source://tapioca//lib/tapioca/runtime/attached_class_of_32.rb#14
+  sig { params(singleton_class: ::Class).returns(T.nilable(::Module)) }
+  def attached_class_of(singleton_class); end
+end
+
+# source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#6
+class Tapioca::Runtime::DynamicMixinCompiler
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#20
+  sig { params(constant: ::Module).void }
+  def initialize(constant); end
+
+  # @return [Array<Symbol>]
+  #
+  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#14
+  def class_attribute_predicates; end
+
+  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#14
+  sig { returns(T::Array[::Symbol]) }
+  def class_attribute_readers; end
+
+  # @return [Array<Symbol>]
+  #
+  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#14
+  def class_attribute_writers; end
+
+  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#137
+  sig { params(tree: ::RBI::Tree).void }
+  def compile_class_attributes(tree); end
+
+  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#180
+  sig { params(tree: ::RBI::Tree).returns([T::Array[::Module], T::Array[::Module]]) }
+  def compile_mixes_in_class_methods(tree); end
+
+  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#11
+  sig { returns(T::Array[::Module]) }
+  def dynamic_extends; end
+
+  # @return [Array<Module>]
+  #
+  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#11
+  def dynamic_includes; end
+
+  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#132
+  sig { returns(T::Boolean) }
+  def empty_attributes?; end
+
+  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#222
+  sig { params(qualified_mixin_name: ::String).returns(T::Boolean) }
+  def filtered_mixin?(qualified_mixin_name); end
+
+  # @return [Array<Symbol>]
+  #
+  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#17
+  def instance_attribute_predicates; end
+
+  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#17
+  sig { returns(T::Array[::Symbol]) }
+  def instance_attribute_readers; end
+
+  # @return [Array<Symbol>]
+  #
+  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#17
+  def instance_attribute_writers; end
+
+  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#215
+  sig { params(mod: ::Module, dynamic_extends: T::Array[::Module]).returns(T::Boolean) }
+  def module_included_by_another_dynamic_extend?(mod, dynamic_extends); end
+end
+
+# This class is responsible for storing and looking up information related to generic types.
+#
+# The class stores 2 different kinds of data, in two separate lookup tables:
+#   1. a lookup of generic type instances by name: `@generic_instances`
+#   2. a lookup of type variable serializer by constant and type variable
+#      instance: `@type_variables`
+#
+# By storing the above data, we can cheaply query each constant against this registry
+# to see if it declares any generic type variables. This becomes a simple lookup in the
+# `@type_variables` hash table with the given constant.
+#
+# If there is no entry, then we can cheaply know that we can skip generic type
+# information generation for this type.
+#
+# On the other hand, if we get a result, then the result will be a hash of type
+# variable to type variable serializers. This allows us to associate type variables
+# to the constant names that represent them, easily.
+#
+# source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#23
+module Tapioca::Runtime::GenericTypeRegistry
+  class << self
+    # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#80
+    sig { params(instance: ::Object).returns(T::Boolean) }
+    def generic_type_instance?(instance); end
+
+    # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#85
+    sig { params(constant: ::Module).returns(T.nilable(T::Array[::Tapioca::TypeVariableModule])) }
+    def lookup_type_variables(constant); end
+
+    # This method is responsible for building the name of the instantiated concrete type
+    # and cloning the given constant so that we can return a type that is the same
+    # as the current type but is a different instance and has a different name method.
+    #
+    # We cache those cloned instances by their name in `@generic_instances`, so that
+    # we don't keep instantiating a new type every single time it is referenced.
+    # For example, `[Foo[Integer], Foo[Integer], Foo[Integer], Foo[String]]` will only
+    # result in 2 clones (1 for `Foo[Integer]` and another for `Foo[String]`) and
+    # 2 hash lookups (for the other two `Foo[Integer]`s).
+    #
+    # This method returns the created or cached clone of the constant.
+    #
+    # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#65
+    sig { params(constant: T.untyped, types: T.untyped).returns(::Module) }
+    def register_type(constant, types); end
+
+    # This method is called from intercepted calls to `type_member` and `type_template`.
+    # We get passed all the arguments to those methods, as well as the `T::Types::TypeVariable`
+    # instance generated by the Sorbet defined `type_member`/`type_template` call on `T::Generic`.
+    #
+    # This method creates a `String` with that data and stores it in the
+    # `@type_variables` lookup table, keyed by the `constant` and `type_variable`.
+    #
+    # Finally, the original `type_variable` is returned from this method, so that the caller
+    # can return it from the original methods as well.
+    #
+    # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#104
+    sig { params(constant: T.untyped, type_variable: ::Tapioca::TypeVariableModule).void }
+    def register_type_variable(constant, type_variable); end
+
+    private
+
+    # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#113
+    sig { params(constant: ::Module, name: ::String).returns(::Module) }
+    def create_generic_type(constant, name); end
+
+    # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#155
+    sig { params(constant: T::Class[T.anything]).returns(T::Class[T.anything]) }
+    def create_safe_subclass(constant); end
+
+    # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#182
+    sig { params(constant: ::Module).returns(T::Array[::Tapioca::TypeVariableModule]) }
+    def lookup_or_initialize_type_variables(constant); end
+  end
+end
+
+# source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#34
+class Tapioca::Runtime::GenericTypeRegistry::GenericType < ::T::Types::Simple
+  # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#38
+  sig { params(raw_type: ::Module, underlying_type: ::Module).void }
+  def initialize(raw_type, underlying_type); end
+
+  # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#45
+  sig { override.params(obj: T.untyped).returns(T::Boolean) }
+  def valid?(obj); end
+end
+
+module Tapioca::Runtime::Reflection
+  include ::Tapioca::Runtime::AttachedClassOf
+  extend ::Tapioca::Runtime::AttachedClassOf
+  extend ::Tapioca::Runtime::Reflection
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#201
+  sig { params(constant: ::Module).returns(T.untyped) }
+  def abstract_type_of(constant); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#77
+  sig { params(constant: ::Module).returns(T::Array[::Module]) }
+  def ancestors_of(constant); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#92
+  sig { params(object: ::BasicObject, other: ::BasicObject).returns(T::Boolean) }
+  def are_equal?(object, other); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#56
+  sig { params(object: ::BasicObject).returns(T::Class[T.anything]) }
+  def class_of(object); end
+
+  # @param constant [BasicObject]
+  # @return [Boolean]
+  #
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#38
+  def constant_defined?(constant); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#49
+  sig { params(symbol: ::String, inherit: T::Boolean, namespace: ::Module).returns(::BasicObject) }
+  def constantize(symbol, inherit: T.unsafe(nil), namespace: T.unsafe(nil)); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#61
+  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
+  def constants_of(constant); end
+
+  # Returns an array with all classes that are < than the supplied class.
+  #
+  #   class C; end
+  #   descendants_of(C) # => []
+  #
+  #   class B < C; end
+  #   descendants_of(C) # => [B]
+  #
+  #   class A < B; end
+  #   descendants_of(C) # => [B, A]
+  #
+  #   class D < C; end
+  #   descendants_of(C) # => [B, A, D]
+  #
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#172
+  sig do
+    type_parameters(:U)
+      .params(
+        klass: T.all(T.type_parameter(:U), T::Class[T.anything])
+      ).returns(T::Array[T.type_parameter(:U)])
+  end
+  def descendants_of(klass); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#194
+  sig { params(constant: ::Module).returns(T::Set[::String]) }
+  def file_candidates_for(constant); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#207
+  sig { params(constant: ::Module).returns(T::Boolean) }
+  def final_module?(constant); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#112
+  sig { params(constant: ::Module).returns(T::Array[::Module]) }
+  def inherited_ancestors_of(constant); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#150
+  sig { params(constant: ::Module, method: ::Symbol).returns(::Method) }
+  def method_of(constant, method); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#66
+  sig { params(constant: ::Module).returns(T.nilable(::String)) }
+  def name_of(constant); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#145
+  sig { params(type: ::T::Types::Base).returns(::String) }
+  def name_of_type(type); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#87
+  sig { params(object: ::BasicObject).returns(::Integer) }
+  def object_id_of(object); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#107
+  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
+  def private_instance_methods_of(constant); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#102
+  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
+  def protected_instance_methods_of(constant); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#97
+  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
+  def public_instance_methods_of(constant); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#121
+  sig { params(constant: ::Module).returns(T.nilable(::String)) }
+  def qualified_name_of(constant); end
+
+  # Examines the call stack to identify the closest location where a "require" is performed
+  # by searching for the label "<top (required)>". If none is found, it returns the location
+  # labeled "<main>", which is the original call site.
+  #
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#184
+  sig { params(locations: T.nilable(T::Array[::Thread::Backtrace::Location])).returns(::String) }
+  def resolve_loc(locations); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#212
+  sig { params(constant: ::Module).returns(T::Boolean) }
+  def sealed_module?(constant); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#138
+  sig { params(method: T.any(::Method, ::UnboundMethod)).returns(T.untyped) }
+  def signature_of(method); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#133
+  sig { params(method: T.any(::Method, ::UnboundMethod)).returns(T.untyped) }
+  def signature_of!(method); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#72
+  sig { params(constant: ::Module).returns(T::Class[T.anything]) }
+  def singleton_class_of(constant); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#82
+  sig { params(constant: T::Class[T.anything]).returns(T.nilable(T::Class[T.anything])) }
+  def superclass_of(constant); end
+
+  private
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#249
+  sig { params(parent: ::Module, name: ::String).returns(T.nilable(::Module)) }
+  def child_module_for_parent_with_name(parent, name); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#265
+  sig { params(name: ::String).returns(T::Boolean) }
+  def has_aliased_namespace?(name); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#260
+  sig { params(method: ::UnboundMethod).returns(T::Boolean) }
+  def method_defined_by_forwardable_module?(method); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#235
+  sig { params(constant: ::Module).returns(T::Array[::UnboundMethod]) }
+  def methods_for(constant); end
+
+  # source://tapioca//lib/tapioca/runtime/reflection.rb#219
+  sig { params(constant: ::Module).returns(T::Array[::UnboundMethod]) }
+  def relevant_methods_for(constant); end
+end
+
+# source://tapioca//lib/tapioca/runtime/reflection.rb#25
+Tapioca::Runtime::Reflection::ANCESTORS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca//lib/tapioca/runtime/reflection.rb#21
+Tapioca::Runtime::Reflection::CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca//lib/tapioca/runtime/reflection.rb#22
+Tapioca::Runtime::Reflection::CONSTANTS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca//lib/tapioca/runtime/reflection.rb#28
+Tapioca::Runtime::Reflection::EQUAL_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca//lib/tapioca/runtime/reflection.rb#32
+Tapioca::Runtime::Reflection::METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca//lib/tapioca/runtime/reflection.rb#23
+Tapioca::Runtime::Reflection::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca//lib/tapioca/runtime/reflection.rb#27
+Tapioca::Runtime::Reflection::OBJECT_ID_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca//lib/tapioca/runtime/reflection.rb#31
+Tapioca::Runtime::Reflection::PRIVATE_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca//lib/tapioca/runtime/reflection.rb#30
+Tapioca::Runtime::Reflection::PROTECTED_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca//lib/tapioca/runtime/reflection.rb#29
+Tapioca::Runtime::Reflection::PUBLIC_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca//lib/tapioca/runtime/reflection.rb#35
+Tapioca::Runtime::Reflection::REQUIRED_FROM_LABELS = T.let(T.unsafe(nil), Array)
+
+# source://tapioca//lib/tapioca/runtime/reflection.rb#24
+Tapioca::Runtime::Reflection::SINGLETON_CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca//lib/tapioca/runtime/reflection.rb#26
+Tapioca::Runtime::Reflection::SUPERCLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#6
+module Tapioca::Runtime::Trackers
+  class << self
+    # source://tapioca//lib/tapioca/runtime/trackers.rb#34
+    sig { void }
+    def disable_all!; end
+
+    # source://tapioca//lib/tapioca/runtime/trackers.rb#39
+    sig { params(tracker: ::Tapioca::Runtime::Trackers::Tracker).void }
+    def register_tracker(tracker); end
+
+    # source://tapioca//lib/tapioca/runtime/trackers.rb#21
+    sig do
+      type_parameters(:Return)
+        .params(
+          blk: T.proc.returns(T.type_parameter(:Return))
+        ).returns(T.type_parameter(:Return))
+    end
+    def with_trackers_enabled(&blk); end
+  end
+end
+
+# source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#7
+module Tapioca::Runtime::Trackers::Autoload
+  extend ::Tapioca::Runtime::Trackers::Tracker
+
+  class << self
+    # source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#19
+    sig { void }
+    def eager_load_all!; end
+
+    # source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#31
+    sig { params(constant_name: ::String).void }
+    def register(constant_name); end
+
+    # source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#42
+    sig do
+      type_parameters(:Result)
+        .params(
+          block: T.proc.returns(T.type_parameter(:Result))
+        ).returns(T.type_parameter(:Result))
+    end
+    def with_disabled_exits(&block); end
+  end
+end
+
+# source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#11
+Tapioca::Runtime::Trackers::Autoload::NOOP_METHOD = T.let(T.unsafe(nil), Proc)
+
+# Registers a TracePoint immediately upon load to track points at which
+# classes and modules are opened for definition. This is used to track
+# correspondence between classes/modules and files, as this information isn't
+# available in the ruby runtime without extra accounting.
+module Tapioca::Runtime::Trackers::ConstantDefinition
+  extend ::Tapioca::Runtime::Trackers::Tracker
+  extend ::Tapioca::Runtime::AttachedClassOf
+  extend ::Tapioca::Runtime::Reflection
+
+  class << self
+    # source://tapioca//lib/tapioca/runtime/trackers/constant_definition.rb#61
+    def build_constant_location(tp, locations); end
+
+    # source://tapioca//lib/tapioca/runtime/trackers/constant_definition.rb#55
+    def disable!; end
+
+    # Returns the files in which this class or module was opened. Doesn't know
+    # about situations where the class was opened prior to +require+ing,
+    # or where metaprogramming was used via +eval+, etc.
+    #
+    # source://tapioca//lib/tapioca/runtime/trackers/constant_definition.rb#71
+    def files_for(klass); end
+
+    # source://tapioca//lib/tapioca/runtime/trackers/constant_definition.rb#75
+    def locations_for(klass); end
+  end
+end
+
+module Tapioca::Runtime::Trackers::Mixin
+  extend ::Tapioca::Runtime::Trackers::Tracker
+
+  class << self
+    # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#56
+    sig do
+      params(
+        mixin: ::Module
+      ).returns(T::Hash[::Tapioca::Runtime::Trackers::Mixin::Type, T::Hash[::Module, ::String]])
+    end
+    def constants_with_mixin(mixin); end
+
+    # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#61
+    sig do
+      params(
+        mixin: ::Module,
+        mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type,
+        constant: ::Module
+      ).returns(T.nilable(::String))
+    end
+    def mixin_location(mixin, mixin_type, constant); end
+
+    # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#35
+    sig { params(constant: ::Module, mixin: ::Module, mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type).void }
+    def register(constant, mixin, mixin_type); end
+
+    # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#43
+    def resolve_to_attached_class(constant, mixin, mixin_type); end
+
+    # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#30
+    sig do
+      type_parameters(:Result)
+        .params(
+          block: T.proc.returns(T.type_parameter(:Result))
+        ).returns(T.type_parameter(:Result))
+    end
+    def with_disabled_registration(&block); end
+
+    private
+
+    # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#76
+    sig do
+      params(
+        mixin: ::Module
+      ).returns(T::Hash[::Tapioca::Runtime::Trackers::Mixin::Type, T::Hash[::Module, ::String]])
+    end
+    def find_or_initialize_mixin_lookup(mixin); end
+
+    # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#68
+    sig do
+      params(
+        constant: ::Module,
+        mixin: ::Module,
+        mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type,
+        location: ::String
+      ).void
+    end
+    def register_with_location(constant, mixin, mixin_type, location); end
+  end
+end
+
+class Tapioca::Runtime::Trackers::Mixin::Type < ::T::Enum
+  enums do
+    Extend = new
+    Include = new
+    Prepend = new
+  end
+end
+
+# source://tapioca//lib/tapioca/runtime/trackers/required_ancestor.rb#7
+module Tapioca::Runtime::Trackers::RequiredAncestor
+  extend ::Tapioca::Runtime::Trackers::Tracker
+
+  class << self
+    # source://tapioca//lib/tapioca/runtime/trackers/required_ancestor.rb#15
+    sig { params(requiring: ::T::Helpers, block: T.proc.void).void }
+    def register(requiring, block); end
+
+    # source://tapioca//lib/tapioca/runtime/trackers/required_ancestor.rb#23
+    sig { params(mod: ::Module).returns(T::Array[T.proc.void]) }
+    def required_ancestors_blocks_by(mod); end
+
+    # source://tapioca//lib/tapioca/runtime/trackers/required_ancestor.rb#28
+    sig { params(mod: ::Module).returns(T::Array[T.untyped]) }
+    def required_ancestors_by(mod); end
+  end
+end
+
+# @abstract Subclasses must implement the `abstract` methods below.
+module Tapioca::Runtime::Trackers::Tracker
+  abstract!
+
+  # source://tapioca//lib/tapioca/runtime/trackers/tracker.rb#26
+  sig { void }
+  def disable!; end
+
+  # @return [Boolean]
+  #
+  # source://tapioca//lib/tapioca/runtime/trackers/tracker.rb#30
+  def enabled?; end
+
+  # source://tapioca//lib/tapioca/runtime/trackers/tracker.rb#34
+  def with_disabled_tracker(&block); end
+
+  class << self
+    # source://tapioca//lib/tapioca/runtime/trackers/tracker.rb#17
+    sig { params(base: T.all(::Module, ::Tapioca::Runtime::Trackers::Tracker)).void }
+    def extended(base); end
+  end
+end
+
+# source://tapioca//lib/tapioca.rb#35
+Tapioca::SORBET_CONFIG_FILE = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#34
+Tapioca::SORBET_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#5
+module Tapioca::SorbetHelper
+  # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#32
+  sig { params(sorbet_args: ::String).returns(::Spoom::ExecResult) }
+  def sorbet(*sorbet_args); end
+
+  # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#37
+  sig { returns(::String) }
+  def sorbet_path; end
+
+  # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#44
+  sig { params(feature: ::Symbol, version: T.nilable(::Gem::Version)).returns(T::Boolean) }
+  def sorbet_supports?(feature, version: T.unsafe(nil)); end
+end
+
+# source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#24
+Tapioca::SorbetHelper::FEATURE_REQUIREMENTS = T.let(T.unsafe(nil), Hash)
+
+# source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#13
+Tapioca::SorbetHelper::SORBET_BIN = T.let(T.unsafe(nil), Pathname)
+
+# source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#18
+Tapioca::SorbetHelper::SORBET_EXE_PATH_ENV_VAR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#8
+Tapioca::SorbetHelper::SORBET_GEM_SPEC = T.let(T.unsafe(nil), Gem::Specification)
+
+# source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#20
+Tapioca::SorbetHelper::SORBET_PAYLOAD_URL = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#22
+Tapioca::SorbetHelper::SPOOM_CONTEXT = T.let(T.unsafe(nil), Spoom::Context)
+
+# source://tapioca//lib/tapioca/static/symbol_table_parser.rb#5
+module Tapioca::Static; end
+
+# source://tapioca//lib/tapioca/static/requires_compiler.rb#6
+class Tapioca::Static::RequiresCompiler
+  # source://tapioca//lib/tapioca/static/requires_compiler.rb#10
+  sig { params(sorbet_path: ::String).void }
+  def initialize(sorbet_path); end
+
+  # source://tapioca//lib/tapioca/static/requires_compiler.rb#15
+  sig { returns(::String) }
+  def compile; end
+
+  private
+
+  # source://tapioca//lib/tapioca/static/requires_compiler.rb#29
+  sig { params(config: ::Spoom::Sorbet::Config).returns(T::Array[::String]) }
+  def collect_files(config); end
+
+  # source://tapioca//lib/tapioca/static/requires_compiler.rb#44
+  sig { params(file_path: ::String).returns(T::Enumerable[::String]) }
+  def collect_requires(file_path); end
+
+  # source://tapioca//lib/tapioca/static/requires_compiler.rb#51
+  sig { params(config: ::Spoom::Sorbet::Config, file_path: ::Pathname).returns(T::Boolean) }
+  def file_ignored_by_sorbet?(config, file_path); end
+
+  # source://tapioca//lib/tapioca/static/requires_compiler.rb#80
+  sig { params(path: ::Pathname).returns(T::Array[::String]) }
+  def path_parts(path); end
+end
+
+# source://tapioca//lib/tapioca/static/symbol_loader.rb#6
+module Tapioca::Static::SymbolLoader
+  extend ::Tapioca::SorbetHelper
+  extend ::Tapioca::Runtime::AttachedClassOf
+  extend ::Tapioca::Runtime::Reflection
+
+  class << self
+    # source://tapioca//lib/tapioca/static/symbol_loader.rb#23
+    sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
+    def engine_symbols(gem); end
+
+    # source://tapioca//lib/tapioca/static/symbol_loader.rb#48
+    sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
+    def gem_symbols(gem); end
+
+    # source://tapioca//lib/tapioca/static/symbol_loader.rb#13
+    sig { returns(T::Set[::String]) }
+    def payload_symbols; end
+
+    # source://tapioca//lib/tapioca/static/symbol_loader.rb#53
+    sig { params(paths: T::Array[::Pathname]).returns(T::Set[::String]) }
+    def symbols_from_paths(paths); end
+
+    private
+
+    # @return [Array<T.class_of(Rails::Engine)>]
+    #
+    # source://tapioca//lib/tapioca/static/symbol_loader.rb#69
+    def engines; end
+
+    # source://tapioca//lib/tapioca/static/symbol_loader.rb#82
+    sig { params(input: ::String, table_type: ::String).returns(::String) }
+    def symbol_table_json_from(input, table_type: T.unsafe(nil)); end
+  end
+end
+
+# source://tapioca//lib/tapioca/static/symbol_table_parser.rb#6
+class Tapioca::Static::SymbolTableParser
+  # source://tapioca//lib/tapioca/static/symbol_table_parser.rb#30
+  sig { void }
+  def initialize; end
+
+  # source://tapioca//lib/tapioca/static/symbol_table_parser.rb#65
+  sig { params(name: ::String).returns(::String) }
+  def fully_qualified_name(name); end
+
+  # source://tapioca//lib/tapioca/static/symbol_table_parser.rb#36
+  sig { params(object: T::Hash[::String, T.untyped]).void }
+  def parse_object(object); end
+
+  # source://tapioca//lib/tapioca/static/symbol_table_parser.rb#27
+  sig { returns(T::Set[::String]) }
+  def symbols; end
+
+  class << self
+    # source://tapioca//lib/tapioca/static/symbol_table_parser.rb#15
+    sig { params(json_string: ::String).returns(T::Set[::String]) }
+    def parse_json(json_string); end
+  end
+end
+
+# source://tapioca//lib/tapioca/static/symbol_table_parser.rb#9
+Tapioca::Static::SymbolTableParser::SKIP_PARSE_KINDS = T.let(T.unsafe(nil), Array)
+
+# source://tapioca//lib/tapioca.rb#37
+Tapioca::TAPIOCA_CONFIG_FILE = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#36
+Tapioca::TAPIOCA_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#108
+class Tapioca::TypeVariable < ::T::Types::TypeVariable
+  # @return [TypeVariable] a new instance of TypeVariable
+  #
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#109
+  def initialize(name, variance); end
+
+  # Returns the value of attribute name.
+  #
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#114
+  def name; end
+end
+
+# This is subclassing from `Module` so that instances of this type will be modules.
+# The reason why we want that is because that means those instances will automatically
+# get bound to the constant names they are assigned to by Ruby. As a result, we don't
+# need to do any matching of constants to type variables to bind their names, Ruby will
+# do that automatically for us and we get the `name` method for free from `Module`.
+#
+# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#122
+class Tapioca::TypeVariableModule < ::Module
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#146
+  sig do
+    params(
+      context: ::Module,
+      type: ::Tapioca::TypeVariableModule::Type,
+      variance: ::Symbol,
+      bounds_proc: T.nilable(T.proc.returns(T::Hash[::Symbol, T.untyped]))
+    ).void
+  end
+  def initialize(context, type, variance, bounds_proc); end
+
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#181
+  sig { returns(::Tapioca::TypeVariable) }
+  def coerce_to_type_variable; end
+
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#161
+  sig { returns(T::Boolean) }
+  def fixed?; end
+
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#155
+  sig { returns(T.nilable(::String)) }
+  def name; end
+
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#166
+  sig { returns(::String) }
+  def serialize; end
+
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#136
+  sig { returns(::Tapioca::TypeVariableModule::Type) }
+  def type; end
+
+  private
+
+  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#188
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def bounds; end
+end
+
+# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#133
+Tapioca::TypeVariableModule::DEFAULT_BOUNDS_PROC = T.let(T.unsafe(nil), Proc)
+
+# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#125
+class Tapioca::TypeVariableModule::Type < ::T::Enum
+  enums do
+    HasAttachedClass = new
+    Member = new
+    Template = new
+  end
+end
+
+# source://tapioca//lib/tapioca/version.rb#5
+Tapioca::VERSION = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca/helpers/source_uri.rb#7
+class URI::Source < ::URI::File
+  # source://tapioca//lib/tapioca/helpers/source_uri.rb#65
+  sig { params(v: T.nilable(::String)).returns(T::Boolean) }
+  def check_host(v); end
+
+  # source://uri/0.13.1/uri/generic.rb#243
+  def gem_name; end
+
+  # source://tapioca//lib/tapioca/helpers/source_uri.rb#32
+  sig { returns(T.nilable(::String)) }
+  def gem_version; end
+
+  # source://uri/0.13.1/uri/generic.rb#283
+  def line_number; end
+
+  # source://tapioca//lib/tapioca/helpers/source_uri.rb#58
+  sig { params(v: T.nilable(::String)).void }
+  def set_path(v); end
+
+  # source://tapioca//lib/tapioca/helpers/source_uri.rb#77
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    # source://tapioca//lib/tapioca/helpers/source_uri.rb#45
+    sig do
+      params(
+        gem_name: ::String,
+        gem_version: T.nilable(::String),
+        path: ::String,
+        line_number: T.nilable(::String)
+      ).returns(::URI::Source)
+    end
+    def build(gem_name:, gem_version:, path:, line_number:); end
+  end
+end
+
+# source://tapioca//lib/tapioca/helpers/source_uri.rb#10
+URI::Source::COMPONENT = T.let(T.unsafe(nil), Array)
+
+# `uri` for Ruby 3.4 switched the default parser from RFC2396 to RFC3986. The new parser emits a deprecation
+# warning on a few methods and delegates them to RFC2396, namely `extract`/`make_regexp`/`escape`/`unescape`.
+# On earlier versions of the uri gem, the RFC2396_PARSER constant doesn't exist, so it needs some special
+# handling to select a parser that doesn't emit deprecations. While it was backported to Ruby 3.1, users may
+# have the uri gem in their own bundle and thus not use a compatible version.
+#
+# source://tapioca//lib/tapioca/helpers/source_uri.rb#26
+URI::Source::PARSER = T.let(T.unsafe(nil), URI::RFC2396_Parser)
diff --git a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.7.2.rbi b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.7.2.rbi
deleted file mode 100644
index 5ac4bf25cd59f..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.7.2.rbi
+++ /dev/null
@@ -1,1713 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `tapioca` gem.
-# Please instead update this file by running `bin/tapioca gem tapioca`.
-
-class Module
-  include ::ActiveSupport::Dependencies::ModuleConstMissing
-
-  def autoload(const_name, path); end
-end
-
-Module::DELEGATION_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
-Module::DELEGATION_RESERVED_METHOD_NAMES = T.let(T.unsafe(nil), Set)
-Module::RUBY_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
-module RBI; end
-
-class RBI::Tree < ::RBI::NodeWithComments
-  sig do
-    params(
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Tree).void)
-    ).void
-  end
-  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  sig { params(node: ::RBI::Node).void }
-  def <<(node); end
-
-  sig { override.params(v: ::RBI::Printer).void }
-  def accept_printer(v); end
-
-  sig { params(with_todo_comment: T::Boolean).void }
-  def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end
-
-  sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
-  def annotate!(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end
-
-  sig do
-    params(
-      name: ::String,
-      superclass_name: T.nilable(::String),
-      block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)
-    ).returns(::RBI::Scope)
-  end
-  def create_class(name, superclass_name: T.unsafe(nil), &block); end
-
-  sig { params(name: ::String, value: ::String).void }
-  def create_constant(name, value:); end
-
-  sig { params(name: ::String).void }
-  def create_extend(name); end
-
-  sig { params(name: ::String).void }
-  def create_include(name); end
-
-  sig do
-    params(
-      name: ::String,
-      parameters: T::Array[::RBI::TypedParam],
-      return_type: ::String,
-      class_method: T::Boolean,
-      visibility: ::RBI::Visibility
-    ).void
-  end
-  def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil), visibility: T.unsafe(nil)); end
-
-  sig { params(name: ::String).void }
-  def create_mixes_in_class_methods(name); end
-
-  sig { params(name: ::String, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
-  def create_module(name, &block); end
-
-  sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).void }
-  def create_path(constant, &block); end
-
-  sig do
-    params(
-      name: ::String,
-      type: ::String,
-      variance: ::Symbol,
-      fixed: T.nilable(::String),
-      upper: T.nilable(::String),
-      lower: T.nilable(::String)
-    ).void
-  end
-  def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end
-
-  sig { params(annotation: ::String).void }
-  def deannotate!(annotation); end
-
-  sig { returns(T::Boolean) }
-  def empty?; end
-
-  sig { void }
-  def group_nodes!; end
-
-  sig { returns(::RBI::Index) }
-  def index; end
-
-  sig do
-    params(
-      other: ::RBI::Tree,
-      left_name: ::String,
-      right_name: ::String,
-      keep: ::RBI::Rewriters::Merge::Keep
-    ).returns(::RBI::MergeTree)
-  end
-  def merge(other, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
-
-  sig { void }
-  def nest_non_public_methods!; end
-
-  sig { void }
-  def nest_singleton_methods!; end
-
-  sig { returns(T::Array[::RBI::Node]) }
-  def nodes; end
-
-  sig { override.returns(T::Boolean) }
-  def oneline?; end
-
-  sig { void }
-  def sort_nodes!; end
-
-  private
-
-  sig { params(node: ::RBI::Node).returns(::RBI::Node) }
-  def create_node(node); end
-
-  sig { returns(T::Hash[::String, ::RBI::Node]) }
-  def nodes_cache; end
-
-  sig { params(name: ::String).returns(T::Boolean) }
-  def valid_method_name?(name); end
-end
-
-RBI::Tree::SPECIAL_METHOD_NAMES = T.let(T.unsafe(nil), Array)
-
-class RBI::TypedParam < ::T::Struct
-  const :param, ::RBI::Param
-  const :type, ::String
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-RBI::VERSION = T.let(T.unsafe(nil), String)
-
-module T::Generic::TypeStoragePatch
-  def [](*types); end
-  def type_member(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil), &blk); end
-  def type_template(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil), &blk); end
-end
-
-module T::Types::Simple::GenericPatch
-  def name; end
-end
-
-module T::Types::Simple::NamePatch
-  def name; end
-end
-
-module T::Utils::CoercePatch
-  def coerce(val); end
-end
-
-module Tapioca
-  class << self
-    sig do
-      type_parameters(:Result)
-        .params(
-          blk: T.proc.returns(T.type_parameter(:Result))
-        ).returns(T.type_parameter(:Result))
-    end
-    def silence_warnings(&blk); end
-  end
-end
-
-Tapioca::BINARY_FILE = T.let(T.unsafe(nil), String)
-
-class Tapioca::Cli < ::Thor
-  include ::Tapioca::CliHelper
-  include ::Tapioca::ConfigHelper
-  include ::Tapioca::ShimsHelper
-
-  def __print_version; end
-  def check_shims; end
-  def dsl(*constants); end
-  def gem(*gems); end
-  def init; end
-  def require; end
-  def todo; end
-
-  class << self
-    def exit_on_failure?; end
-  end
-end
-
-Tapioca::Cli::FILE_HEADER_OPTION_DESC = T.let(T.unsafe(nil), String)
-
-module Tapioca::CliHelper
-  requires_ancestor { Thor::Shell }
-
-  sig { params(options: T::Hash[::Symbol, T.untyped]).returns(::Tapioca::RBIFormatter) }
-  def rbi_formatter(options); end
-
-  sig { params(message: ::String, color: T.any(::Symbol, T::Array[::Symbol])).void }
-  def say_error(message = T.unsafe(nil), *color); end
-end
-
-module Tapioca::Commands; end
-
-class Tapioca::Commands::Command
-  include ::Thor::Base
-  include ::Thor::Invocation
-  include ::Thor::Shell
-  include ::Tapioca::CliHelper
-  extend ::Thor::Base::ClassMethods
-  extend ::Thor::Invocation::ClassMethods
-
-  abstract!
-
-  sig { void }
-  def initialize; end
-
-  sig { abstract.void }
-  def execute; end
-
-  sig { returns(::Thor::Actions) }
-  def file_writer; end
-
-  private
-
-  sig do
-    params(
-      path: T.any(::Pathname, ::String),
-      content: ::String,
-      force: T::Boolean,
-      skip: T::Boolean,
-      verbose: T::Boolean
-    ).void
-  end
-  def create_file(path, content, force: T.unsafe(nil), skip: T.unsafe(nil), verbose: T.unsafe(nil)); end
-
-  sig { params(command: ::Symbol, args: ::String).returns(::String) }
-  def default_command(command, *args); end
-
-  sig { params(path: T.any(::Pathname, ::String), verbose: T::Boolean).void }
-  def remove_file(path, verbose: T.unsafe(nil)); end
-end
-
-class Tapioca::Commands::Command::FileWriter < ::Thor
-  include ::Thor::Actions
-  extend ::Thor::Actions::ClassMethods
-end
-
-class Tapioca::Commands::Dsl < ::Tapioca::Commands::Command
-  sig do
-    params(
-      requested_constants: T::Array[::String],
-      outpath: ::Pathname,
-      only: T::Array[::String],
-      exclude: T::Array[::String],
-      file_header: T::Boolean,
-      compiler_path: ::String,
-      tapioca_path: ::String,
-      should_verify: T::Boolean,
-      quiet: T::Boolean,
-      verbose: T::Boolean,
-      number_of_workers: T.nilable(::Integer),
-      rbi_formatter: ::Tapioca::RBIFormatter
-    ).void
-  end
-  def initialize(requested_constants:, outpath:, only:, exclude:, file_header:, compiler_path:, tapioca_path:, should_verify: T.unsafe(nil), quiet: T.unsafe(nil), verbose: T.unsafe(nil), number_of_workers: T.unsafe(nil), rbi_formatter: T.unsafe(nil)); end
-
-  sig { override.void }
-  def execute; end
-
-  private
-
-  sig { void }
-  def abort_if_pending_migrations!; end
-
-  sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) }
-  def build_error_for_files(cause, files); end
-
-  sig do
-    params(
-      constant_name: ::String,
-      rbi: ::RBI::File,
-      outpath: ::Pathname,
-      quiet: T::Boolean
-    ).returns(T.nilable(::Pathname))
-  end
-  def compile_dsl_rbi(constant_name, rbi, outpath: T.unsafe(nil), quiet: T.unsafe(nil)); end
-
-  sig { params(constant_names: T::Array[::String]).returns(T::Array[::Module]) }
-  def constantize(constant_names); end
-
-  sig { params(compiler_names: T::Array[::String]).returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
-  def constantize_compilers(compiler_names); end
-
-  sig { params(constant_name: ::String).returns(::Pathname) }
-  def dsl_rbi_filename(constant_name); end
-
-  sig { params(requested_constants: T::Array[::String], path: ::Pathname).returns(T::Set[::Pathname]) }
-  def existing_rbi_filenames(requested_constants, path: T.unsafe(nil)); end
-
-  sig { params(constant: ::String).returns(::String) }
-  def generate_command_for(constant); end
-
-  sig { params(eager_load: T::Boolean).void }
-  def load_application(eager_load:); end
-
-  sig { void }
-  def load_dsl_compilers; end
-
-  sig { void }
-  def load_dsl_extensions; end
-
-  sig { returns(::Tapioca::Runtime::Loader) }
-  def loader; end
-
-  sig { params(dir: ::Pathname).void }
-  def perform_dsl_verification(dir); end
-
-  sig { params(files: T::Set[::Pathname]).void }
-  def purge_stale_dsl_rbi_files(files); end
-
-  sig { params(constant: ::String).returns(::String) }
-  def rbi_filename_for(constant); end
-
-  sig { params(path: ::Pathname).returns(T::Array[::Pathname]) }
-  def rbi_files_in(path); end
-
-  sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void }
-  def report_diff_and_exit_if_out_of_date(diff, command); end
-
-  sig { params(name: ::String).returns(T.nilable(T.class_of(Tapioca::Dsl::Compiler))) }
-  def resolve(name); end
-
-  sig { params(class_name: ::String).returns(::String) }
-  def underscore(class_name); end
-
-  sig { params(tmp_dir: ::Pathname).returns(T::Hash[::String, ::Symbol]) }
-  def verify_dsl_rbi(tmp_dir:); end
-end
-
-class Tapioca::Commands::Gem < ::Tapioca::Commands::Command
-  include ::Tapioca::SorbetHelper
-
-  sig do
-    params(
-      gem_names: T::Array[::String],
-      exclude: T::Array[::String],
-      prerequire: T.nilable(::String),
-      postrequire: ::String,
-      typed_overrides: T::Hash[::String, ::String],
-      outpath: ::Pathname,
-      file_header: T::Boolean,
-      doc: T::Boolean,
-      include_exported_rbis: T::Boolean,
-      number_of_workers: T.nilable(::Integer),
-      auto_strictness: T::Boolean,
-      dsl_dir: ::String,
-      rbi_formatter: ::Tapioca::RBIFormatter
-    ).void
-  end
-  def initialize(gem_names:, exclude:, prerequire:, postrequire:, typed_overrides:, outpath:, file_header:, doc:, include_exported_rbis:, number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), dsl_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil)); end
-
-  sig { override.void }
-  def execute; end
-
-  sig { params(should_verify: T::Boolean).void }
-  def sync(should_verify: T.unsafe(nil)); end
-
-  private
-
-  sig { returns(T::Array[::String]) }
-  def added_rbis; end
-
-  sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) }
-  def build_error_for_files(cause, files); end
-
-  sig { returns(::Tapioca::Gemfile) }
-  def bundle; end
-
-  sig { params(gem: ::Tapioca::Gemfile::GemSpec).void }
-  def compile_gem_rbi(gem); end
-
-  sig { params(gem_name: ::String).returns(::Pathname) }
-  def existing_rbi(gem_name); end
-
-  sig { returns(T::Hash[::String, ::String]) }
-  def existing_rbis; end
-
-  sig { params(gem_name: ::String).returns(::Pathname) }
-  def expected_rbi(gem_name); end
-
-  sig { returns(T::Hash[::String, ::String]) }
-  def expected_rbis; end
-
-  sig { params(file: ::String, error: ::LoadError).void }
-  def explain_failed_require(file, error); end
-
-  sig { params(path: ::String).returns(::String) }
-  def gem_name_from_rbi_path(path); end
-
-  sig { params(gem_name: ::String).returns(T::Boolean) }
-  def gem_rbi_exists?(gem_name); end
-
-  sig { params(gem_name: ::String, version: ::String).returns(::Pathname) }
-  def gem_rbi_filename(gem_name, version); end
-
-  sig { params(gem_names: T::Array[::String]).returns(T::Array[::Tapioca::Gemfile::GemSpec]) }
-  def gems_to_generate(gem_names); end
-
-  sig { returns(::Tapioca::Runtime::Loader) }
-  def loader; end
-
-  sig { params(gem: ::Tapioca::Gemfile::GemSpec, file: ::RBI::File).void }
-  def merge_with_exported_rbi(gem, file); end
-
-  sig { params(old_filename: ::Pathname, new_filename: ::Pathname).void }
-  def move(old_filename, new_filename); end
-
-  sig { void }
-  def perform_additions; end
-
-  sig { void }
-  def perform_removals; end
-
-  sig { void }
-  def perform_sync_verification; end
-
-  sig { returns(T::Array[::String]) }
-  def removed_rbis; end
-
-  sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void }
-  def report_diff_and_exit_if_out_of_date(diff, command); end
-
-  sig { void }
-  def require_gem_file; end
-
-  sig { params(gem_names: T::Array[::String], gem_dir: ::String, dsl_dir: ::String).void }
-  def update_strictnesses(gem_names, gem_dir: T.unsafe(nil), dsl_dir: T.unsafe(nil)); end
-end
-
-class Tapioca::Commands::Init < ::Tapioca::Commands::Command
-  sig { params(sorbet_config: ::String, tapioca_config: ::String, default_postrequire: ::String).void }
-  def initialize(sorbet_config:, tapioca_config:, default_postrequire:); end
-
-  sig { override.void }
-  def execute; end
-
-  private
-
-  sig { void }
-  def create_binstub; end
-
-  sig { void }
-  def create_post_require; end
-
-  sig { void }
-  def create_sorbet_config; end
-
-  sig { void }
-  def create_tapioca_config; end
-
-  sig { returns(::Bundler::Installer) }
-  def installer; end
-
-  sig { returns(::Bundler::StubSpecification) }
-  def spec; end
-end
-
-class Tapioca::Commands::Require < ::Tapioca::Commands::Command
-  sig { params(requires_path: ::String, sorbet_config_path: ::String).void }
-  def initialize(requires_path:, sorbet_config_path:); end
-
-  sig { override.void }
-  def execute; end
-end
-
-class Tapioca::Commands::Todo < ::Tapioca::Commands::Command
-  include ::Tapioca::SorbetHelper
-
-  sig { params(todo_file: ::String, file_header: T::Boolean).void }
-  def initialize(todo_file:, file_header:); end
-
-  sig { override.void }
-  def execute; end
-
-  private
-
-  sig { params(constants: T::Array[::String], command: ::String).returns(::RBI::File) }
-  def rbi(constants, command:); end
-
-  sig { returns(T::Array[::String]) }
-  def unresolved_constants; end
-end
-
-module Tapioca::ConfigHelper
-  requires_ancestor { Thor }
-
-  sig { params(args: T.untyped, local_options: T.untyped, config: T.untyped).void }
-  def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end
-
-  sig { returns(::String) }
-  def command_name; end
-
-  sig { returns(::Thor::CoreExt::HashWithIndifferentAccess) }
-  def defaults; end
-
-  sig { returns(::Thor::CoreExt::HashWithIndifferentAccess) }
-  def options; end
-
-  private
-
-  sig { params(msg: ::String).returns(::Tapioca::ConfigHelper::ConfigError) }
-  def build_error(msg); end
-
-  sig do
-    params(
-      options: ::Thor::CoreExt::HashWithIndifferentAccess
-    ).returns(::Thor::CoreExt::HashWithIndifferentAccess)
-  end
-  def config_options(options); end
-
-  sig { params(options: T::Hash[::Symbol, ::Thor::Option]).void }
-  def filter_defaults(options); end
-
-  sig do
-    params(
-      options: T.nilable(::Thor::CoreExt::HashWithIndifferentAccess)
-    ).returns(::Thor::CoreExt::HashWithIndifferentAccess)
-  end
-  def merge_options(*options); end
-
-  sig { params(config_file: ::String, errors: T::Array[::Tapioca::ConfigHelper::ConfigError]).void }
-  def print_errors(config_file, errors); end
-
-  sig { params(config_file: ::String, config: T::Hash[T.untyped, T.untyped]).void }
-  def validate_config!(config_file, config); end
-
-  sig do
-    params(
-      command_options: T::Hash[::Symbol, ::Thor::Option],
-      config_key: ::String,
-      config_options: T::Hash[T.untyped, T.untyped]
-    ).returns(T::Array[::Tapioca::ConfigHelper::ConfigError])
-  end
-  def validate_config_options(command_options, config_key, config_options); end
-end
-
-class Tapioca::ConfigHelper::ConfigError < ::T::Struct
-  const :message_parts, T::Array[::Tapioca::ConfigHelper::ConfigErrorMessagePart]
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-class Tapioca::ConfigHelper::ConfigErrorMessagePart < ::T::Struct
-  const :colors, T::Array[::Symbol]
-  const :message, ::String
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-Tapioca::DEFAULT_DSL_DIR = T.let(T.unsafe(nil), String)
-Tapioca::DEFAULT_GEM_DIR = T.let(T.unsafe(nil), String)
-Tapioca::DEFAULT_OVERRIDES = T.let(T.unsafe(nil), Hash)
-Tapioca::DEFAULT_POSTREQUIRE_FILE = T.let(T.unsafe(nil), String)
-Tapioca::DEFAULT_RBI_DIR = T.let(T.unsafe(nil), String)
-Tapioca::DEFAULT_RBI_FORMATTER = T.let(T.unsafe(nil), Tapioca::RBIFormatter)
-Tapioca::DEFAULT_SHIM_DIR = T.let(T.unsafe(nil), String)
-Tapioca::DEFAULT_TODO_FILE = T.let(T.unsafe(nil), String)
-module Tapioca::Dsl; end
-
-class Tapioca::Dsl::Compiler
-  extend T::Generic
-  include ::Tapioca::Runtime::Reflection
-  include ::Tapioca::SignaturesHelper
-  include ::Tapioca::Dsl::Helpers::ParamHelper
-  extend ::Tapioca::Runtime::Reflection
-
-  abstract!
-
-  ConstantType = type_member { { upper: Module } }
-
-  sig { params(pipeline: ::Tapioca::Dsl::Pipeline, root: ::RBI::Tree, constant: ConstantType).void }
-  def initialize(pipeline, root, constant); end
-
-  sig { params(error: ::String).void }
-  def add_error(error); end
-
-  sig { params(compiler_name: ::String).returns(T::Boolean) }
-  def compiler_enabled?(compiler_name); end
-
-  sig { returns(ConstantType) }
-  def constant; end
-
-  sig { abstract.void }
-  def decorate; end
-
-  sig { returns(::RBI::Tree) }
-  def root; end
-
-  private
-
-  sig { params(type: ::String).returns(::String) }
-  def as_nilable_type(type); end
-
-  sig { params(method_def: T.any(::Method, ::UnboundMethod)).returns(T::Array[::RBI::TypedParam]) }
-  def compile_method_parameters_to_rbi(method_def); end
-
-  sig { params(method_def: T.any(::Method, ::UnboundMethod)).returns(::String) }
-  def compile_method_return_type_to_rbi(method_def); end
-
-  sig { params(scope: ::RBI::Scope, method_def: T.any(::Method, ::UnboundMethod), class_method: T::Boolean).void }
-  def create_method_from_def(scope, method_def, class_method: T.unsafe(nil)); end
-
-  sig { params(method_def: T.any(::Method, ::UnboundMethod), signature: T.untyped).returns(T::Array[::String]) }
-  def parameters_types_from_signature(method_def, signature); end
-
-  sig { params(name: ::String).returns(T::Boolean) }
-  def valid_parameter_name?(name); end
-
-  class << self
-    sig { abstract.returns(T::Enumerable[::Module]) }
-    def gather_constants; end
-
-    sig { params(constant: ::Module).returns(T::Boolean) }
-    def handles?(constant); end
-
-    sig { returns(T::Set[::Module]) }
-    def processable_constants; end
-
-    private
-
-    sig { returns(T::Enumerable[::Class]) }
-    def all_classes; end
-
-    sig { returns(T::Enumerable[::Module]) }
-    def all_modules; end
-  end
-end
-
-module Tapioca::Dsl::Compilers; end
-Tapioca::Dsl::Compilers::DIRECTORY = T.let(T.unsafe(nil), String)
-Tapioca::Dsl::Compilers::NAMESPACES = T.let(T.unsafe(nil), Array)
-module Tapioca::Dsl::Helpers; end
-
-module Tapioca::Dsl::Helpers::ParamHelper
-  include ::Tapioca::SignaturesHelper
-
-  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
-  def create_block_param(name, type:); end
-
-  sig { params(name: ::String, type: ::String, default: ::String).returns(::RBI::TypedParam) }
-  def create_kw_opt_param(name, type:, default:); end
-
-  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
-  def create_kw_param(name, type:); end
-
-  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
-  def create_kw_rest_param(name, type:); end
-
-  sig { params(name: ::String, type: ::String, default: ::String).returns(::RBI::TypedParam) }
-  def create_opt_param(name, type:, default:); end
-
-  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
-  def create_param(name, type:); end
-
-  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
-  def create_rest_param(name, type:); end
-
-  sig { params(param: ::RBI::Param, type: ::String).returns(::RBI::TypedParam) }
-  def create_typed_param(param, type); end
-end
-
-class Tapioca::Dsl::Pipeline
-  sig do
-    params(
-      requested_constants: T::Array[::Module],
-      requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
-      excluded_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
-      error_handler: T.proc.params(error: ::String).void,
-      number_of_workers: T.nilable(::Integer)
-    ).void
-  end
-  def initialize(requested_constants:, requested_compilers: T.unsafe(nil), excluded_compilers: T.unsafe(nil), error_handler: T.unsafe(nil), number_of_workers: T.unsafe(nil)); end
-
-  sig { params(error: ::String).void }
-  def add_error(error); end
-
-  sig { params(compiler_name: ::String).returns(T::Boolean) }
-  def compiler_enabled?(compiler_name); end
-
-  sig { returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)]) }
-  def compilers; end
-
-  sig { returns(T.proc.params(error: ::String).void) }
-  def error_handler; end
-
-  sig { returns(T::Array[::String]) }
-  def errors; end
-
-  sig { returns(T::Array[::Module]) }
-  def requested_constants; end
-
-  sig do
-    type_parameters(:T)
-      .params(
-        blk: T.proc.params(constant: ::Module, rbi: ::RBI::File).returns(T.type_parameter(:T))
-      ).returns(T::Array[T.type_parameter(:T)])
-  end
-  def run(&blk); end
-
-  private
-
-  sig { params(constants: T::Set[::Module]).returns(T::Set[::Module]) }
-  def filter_anonymous_and_reloaded_constants(constants); end
-
-  sig do
-    params(
-      requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
-      excluded_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)]
-    ).returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)])
-  end
-  def gather_compilers(requested_compilers, excluded_compilers); end
-
-  sig { params(requested_constants: T::Array[::Module]).returns(T::Set[::Module]) }
-  def gather_constants(requested_constants); end
-
-  sig { params(constant: ::Module).returns(T.nilable(::RBI::File)) }
-  def rbi_for_constant(constant); end
-
-  sig { params(error: ::String).returns(T.noreturn) }
-  def report_error(error); end
-end
-
-class Tapioca::Error < ::StandardError; end
-
-class Tapioca::Executor
-  sig { params(queue: T::Array[T.untyped], number_of_workers: T.nilable(::Integer)).void }
-  def initialize(queue, number_of_workers: T.unsafe(nil)); end
-
-  sig do
-    type_parameters(:T)
-      .params(
-        block: T.proc.params(item: T.untyped).returns(T.type_parameter(:T))
-      ).returns(T::Array[T.type_parameter(:T)])
-  end
-  def run_in_parallel(&block); end
-end
-
-Tapioca::Executor::MINIMUM_ITEMS_PER_WORKER = T.let(T.unsafe(nil), Integer)
-module Tapioca::Gem; end
-
-class Tapioca::Gem::ConstNodeAdded < ::Tapioca::Gem::NodeAdded
-  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Const).void }
-  def initialize(symbol, constant, node); end
-
-  sig { returns(::RBI::Const) }
-  def node; end
-end
-
-class Tapioca::Gem::ConstantFound < ::Tapioca::Gem::Event
-  sig { params(symbol: ::String, constant: ::BasicObject).void }
-  def initialize(symbol, constant); end
-
-  sig { returns(::BasicObject) }
-  def constant; end
-
-  sig { returns(::String) }
-  def symbol; end
-end
-
-class Tapioca::Gem::Event
-  abstract!
-
-  def initialize(*args, &blk); end
-end
-
-module Tapioca::Gem::Listeners; end
-
-class Tapioca::Gem::Listeners::Base
-  abstract!
-
-  sig { params(pipeline: ::Tapioca::Gem::Pipeline).void }
-  def initialize(pipeline); end
-
-  sig { params(event: ::Tapioca::Gem::NodeAdded).void }
-  def dispatch(event); end
-
-  private
-
-  sig { params(event: ::Tapioca::Gem::ConstNodeAdded).void }
-  def on_const(event); end
-
-  sig { params(event: ::Tapioca::Gem::MethodNodeAdded).void }
-  def on_method(event); end
-
-  sig { params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-class Tapioca::Gem::Listeners::DynamicMixins < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  sig { params(tree: ::RBI::Tree, module_name: ::String, mod: ::Module, for_visibility: T::Array[::Symbol]).void }
-  def compile_directly_owned_methods(tree, module_name, mod, for_visibility = T.unsafe(nil)); end
-
-  sig do
-    params(
-      tree: ::RBI::Tree,
-      symbol_name: ::String,
-      constant: ::Module,
-      method: T.nilable(::UnboundMethod),
-      visibility: ::RBI::Visibility
-    ).void
-  end
-  def compile_method(tree, symbol_name, constant, method, visibility = T.unsafe(nil)); end
-
-  sig { params(constant: ::Module).returns(T.nilable(::UnboundMethod)) }
-  def initialize_method_for(constant); end
-
-  sig { params(mod: ::Module).returns(T::Hash[::Symbol, T::Array[::Symbol]]) }
-  def method_names_by_visibility(mod); end
-
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-
-  sig { params(constant: ::Module, method_name: ::String).returns(T::Boolean) }
-  def struct_method?(constant, method_name); end
-
-  sig { params(name: ::String).returns(T::Boolean) }
-  def valid_method_name?(name); end
-
-  sig { params(name: ::String).returns(T::Boolean) }
-  def valid_parameter_name?(name); end
-end
-
-Tapioca::Gem::Listeners::Methods::SPECIAL_METHOD_NAMES = T.let(T.unsafe(nil), Array)
-
-class Tapioca::Gem::Listeners::Mixins < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  sig do
-    params(
-      tree: ::RBI::Tree,
-      mods: T::Array[::Module],
-      mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type
-    ).void
-  end
-  def add_mixins(tree, mods, mixin_type); end
-
-  sig { params(mixin_name: ::String).returns(T::Boolean) }
-  def filtered_mixin?(mixin_name); end
-
-  sig { params(constant: ::Module).returns(T::Array[::Module]) }
-  def interesting_ancestors_of(constant); end
-
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-class Tapioca::Gem::Listeners::RemoveEmptyPayloadScopes < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-class Tapioca::Gem::Listeners::SorbetEnums < ::Tapioca::Gem::Listeners::Base
-  private
-
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-class Tapioca::Gem::Listeners::SorbetHelpers < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-class Tapioca::Gem::Listeners::SorbetProps < ::Tapioca::Gem::Listeners::Base
-  private
-
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-class Tapioca::Gem::Listeners::SorbetRequiredAncestors < ::Tapioca::Gem::Listeners::Base
-  private
-
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-class Tapioca::Gem::Listeners::SorbetSignatures < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::Reflection
-  include ::Tapioca::SignaturesHelper
-
-  private
-
-  sig { params(signature: T.untyped, parameters: T::Array[[::Symbol, ::String]]).returns(::RBI::Sig) }
-  def compile_signature(signature, parameters); end
-
-  sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
-  def on_method(event); end
-
-  sig { params(signature: T.untyped).returns(T::Boolean) }
-  def signature_final?(signature); end
-end
-
-Tapioca::Gem::Listeners::SorbetSignatures::TYPE_PARAMETER_MATCHER = T.let(T.unsafe(nil), Regexp)
-
-class Tapioca::Gem::Listeners::SorbetTypeVariables < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  sig { params(tree: ::RBI::Tree, constant: ::Module).void }
-  def compile_type_variable_declarations(tree, constant); end
-
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-class Tapioca::Gem::Listeners::Subconstants < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-class Tapioca::Gem::Listeners::YardDoc < ::Tapioca::Gem::Listeners::Base
-  sig { params(pipeline: ::Tapioca::Gem::Pipeline).void }
-  def initialize(pipeline); end
-
-  private
-
-  sig { params(name: ::String, sigs: T::Array[::RBI::Sig]).returns(T::Array[::RBI::Comment]) }
-  def documentation_comments(name, sigs: T.unsafe(nil)); end
-
-  sig { override.params(event: ::Tapioca::Gem::ConstNodeAdded).void }
-  def on_const(event); end
-
-  sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
-  def on_method(event); end
-
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-Tapioca::Gem::Listeners::YardDoc::IGNORED_COMMENTS = T.let(T.unsafe(nil), Array)
-Tapioca::Gem::Listeners::YardDoc::IGNORED_SIG_TAGS = T.let(T.unsafe(nil), Array)
-
-class Tapioca::Gem::MethodNodeAdded < ::Tapioca::Gem::NodeAdded
-  sig do
-    params(
-      symbol: ::String,
-      constant: ::Module,
-      node: ::RBI::Method,
-      signature: T.untyped,
-      parameters: T::Array[[::Symbol, ::String]]
-    ).void
-  end
-  def initialize(symbol, constant, node, signature, parameters); end
-
-  sig { returns(::RBI::Method) }
-  def node; end
-
-  sig { returns(T::Array[[::Symbol, ::String]]) }
-  def parameters; end
-
-  sig { returns(T.untyped) }
-  def signature; end
-end
-
-class Tapioca::Gem::NodeAdded < ::Tapioca::Gem::Event
-  abstract!
-
-  sig { params(symbol: ::String, constant: ::Module).void }
-  def initialize(symbol, constant); end
-
-  sig { returns(::Module) }
-  def constant; end
-
-  sig { returns(::String) }
-  def symbol; end
-end
-
-class Tapioca::Gem::Pipeline
-  include ::Tapioca::Runtime::Reflection
-  include ::Tapioca::SignaturesHelper
-
-  sig { params(gem: ::Tapioca::Gemfile::GemSpec, include_doc: T::Boolean).void }
-  def initialize(gem, include_doc: T.unsafe(nil)); end
-
-  sig { returns(::RBI::Tree) }
-  def compile; end
-
-  sig { returns(::Tapioca::Gemfile::GemSpec) }
-  def gem; end
-
-  sig { params(method: ::UnboundMethod).returns(T::Boolean) }
-  def method_in_gem?(method); end
-
-  sig { params(constant: ::Module).returns(T.nilable(::String)) }
-  def name_of(constant); end
-
-  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Const).void }
-  def push_const(symbol, constant, node); end
-
-  sig { params(symbol: ::String, constant: ::BasicObject).void }
-  def push_constant(symbol, constant); end
-
-  sig do
-    params(
-      symbol: ::String,
-      constant: ::Module,
-      node: ::RBI::Method,
-      signature: T.untyped,
-      parameters: T::Array[[::Symbol, ::String]]
-    ).void
-  end
-  def push_method(symbol, constant, node, signature, parameters); end
-
-  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void }
-  def push_scope(symbol, constant, node); end
-
-  sig { params(symbol: ::String).void }
-  def push_symbol(symbol); end
-
-  sig { params(symbol_name: ::String).returns(T::Boolean) }
-  def symbol_in_payload?(symbol_name); end
-
-  private
-
-  sig { params(name: ::String).void }
-  def add_to_alias_namespace(name); end
-
-  sig { params(name: ::String).returns(T::Boolean) }
-  def alias_namespaced?(name); end
-
-  sig { params(name: ::String, constant: ::Module).void }
-  def compile_alias(name, constant); end
-
-  sig { params(symbol: ::String, constant: ::BasicObject).void }
-  def compile_constant(symbol, constant); end
-
-  sig { params(name: ::String, constant: ::Module).void }
-  def compile_module(name, constant); end
-
-  sig { params(name: ::String, value: ::BasicObject).void }
-  def compile_object(name, value); end
-
-  sig { params(constant: ::Class).returns(T.nilable(::String)) }
-  def compile_superclass(constant); end
-
-  sig { params(constant: ::Module, strict: T::Boolean).returns(T::Boolean) }
-  def defined_in_gem?(constant, strict: T.unsafe(nil)); end
-
-  sig { params(event: ::Tapioca::Gem::Event).void }
-  def dispatch(event); end
-
-  sig { params(constant: T.all(::Module, ::T::Generic)).returns(::String) }
-  def generic_name_of(constant); end
-
-  sig { params(constant: ::Module).returns(T::Array[::String]) }
-  def get_file_candidates(constant); end
-
-  sig { params(name: ::String).void }
-  def mark_seen(name); end
-
-  sig { params(constant: ::Module, class_name: T.nilable(::String)).returns(T.nilable(::String)) }
-  def name_of_proxy_target(constant, class_name); end
-
-  sig { returns(::Tapioca::Gem::Event) }
-  def next_event; end
-
-  sig { params(event: ::Tapioca::Gem::ConstantFound).void }
-  def on_constant(event); end
-
-  sig { params(event: ::Tapioca::Gem::NodeAdded).void }
-  def on_node(event); end
-
-  sig { params(event: ::Tapioca::Gem::SymbolFound).void }
-  def on_symbol(event); end
-
-  sig { params(name: ::String).returns(T::Boolean) }
-  def seen?(name); end
-end
-
-Tapioca::Gem::Pipeline::IGNORED_SYMBOLS = T.let(T.unsafe(nil), Array)
-
-class Tapioca::Gem::ScopeNodeAdded < ::Tapioca::Gem::NodeAdded
-  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void }
-  def initialize(symbol, constant, node); end
-
-  sig { returns(::RBI::Scope) }
-  def node; end
-end
-
-class Tapioca::Gem::SymbolFound < ::Tapioca::Gem::Event
-  sig { params(symbol: ::String).void }
-  def initialize(symbol); end
-
-  sig { returns(::String) }
-  def symbol; end
-end
-
-class Tapioca::Gemfile
-  sig { void }
-  def initialize; end
-
-  sig { returns(::Bundler::Definition) }
-  def definition; end
-
-  sig { returns(T::Array[::Tapioca::Gemfile::GemSpec]) }
-  def dependencies; end
-
-  sig { params(gem_name: ::String).returns(T.nilable(::Tapioca::Gemfile::GemSpec)) }
-  def gem(gem_name); end
-
-  sig { returns(T::Array[::String]) }
-  def missing_specs; end
-
-  sig { void }
-  def require_bundle; end
-
-  private
-
-  sig { returns(::String) }
-  def dir; end
-
-  sig { returns(::File) }
-  def gemfile; end
-
-  sig { returns(T::Array[::Symbol]) }
-  def groups; end
-
-  sig { returns([T::Array[::Tapioca::Gemfile::GemSpec], T::Array[::String]]) }
-  def load_dependencies; end
-
-  def lockfile; end
-
-  sig { returns([T::Enumerable[T.any(::Bundler::StubSpecification, ::Gem::Specification)], T::Array[::String]]) }
-  def materialize_deps; end
-
-  sig { returns(::Bundler::Runtime) }
-  def runtime; end
-end
-
-class Tapioca::Gemfile::GemSpec
-  sig { params(spec: T.any(::Bundler::StubSpecification, ::Gem::Specification)).void }
-  def initialize(spec); end
-
-  sig { params(path: ::String).returns(T::Boolean) }
-  def contains_path?(path); end
-
-  sig { returns(T::Boolean) }
-  def export_rbi_files?; end
-
-  sig { returns(T::Array[::String]) }
-  def exported_rbi_files; end
-
-  sig { returns(::RBI::MergeTree) }
-  def exported_rbi_tree; end
-
-  sig { returns(T::Array[::Pathname]) }
-  def files; end
-
-  sig { returns(::String) }
-  def full_gem_path; end
-
-  sig { params(gemfile_dir: ::String).returns(T::Boolean) }
-  def ignore?(gemfile_dir); end
-
-  sig { returns(::String) }
-  def name; end
-
-  sig { void }
-  def parse_yard_docs; end
-
-  sig { returns(::String) }
-  def rbi_file_name; end
-
-  def version; end
-
-  private
-
-  sig { returns(T::Array[::Pathname]) }
-  def collect_files; end
-
-  sig { returns(T.nilable(T::Boolean)) }
-  def default_gem?; end
-
-  sig { returns(T::Boolean) }
-  def gem_ignored?; end
-
-  sig { params(gemfile_dir: ::String).returns(T::Boolean) }
-  def gem_in_app_dir?(gemfile_dir); end
-
-  sig { returns(T::Boolean) }
-  def gem_in_bundle_path?; end
-
-  sig { params(path: ::String).returns(T::Boolean) }
-  def has_parent_gemspec?(path); end
-
-  sig { returns(::Regexp) }
-  def require_paths_prefix_matcher; end
-
-  sig { params(file: ::String).returns(::Pathname) }
-  def resolve_to_ruby_lib_dir(file); end
-
-  sig { params(path: T.any(::Pathname, ::String)).returns(::String) }
-  def to_realpath(path); end
-
-  sig { returns(::String) }
-  def version_string; end
-end
-
-Tapioca::Gemfile::GemSpec::IGNORED_GEMS = T.let(T.unsafe(nil), Array)
-Tapioca::Gemfile::Spec = T.type_alias { T.any(::Bundler::StubSpecification, ::Gem::Specification) }
-
-class Tapioca::RBIFormatter < ::RBI::Formatter
-  sig { params(file: ::RBI::File).void }
-  def write_empty_body_comment!(file); end
-
-  sig { params(file: ::RBI::File, command: ::String, reason: T.nilable(::String)).void }
-  def write_header!(file, command, reason: T.unsafe(nil)); end
-end
-
-module Tapioca::Runtime; end
-
-class Tapioca::Runtime::DynamicMixinCompiler
-  include ::Tapioca::Runtime::Reflection
-
-  sig { params(constant: ::Module).void }
-  def initialize(constant); end
-
-  def class_attribute_predicates; end
-
-  sig { returns(T::Array[::Symbol]) }
-  def class_attribute_readers; end
-
-  def class_attribute_writers; end
-
-  sig { params(tree: ::RBI::Tree).void }
-  def compile_class_attributes(tree); end
-
-  sig { params(tree: ::RBI::Tree).returns([T::Array[::Module], T::Array[::Module]]) }
-  def compile_mixes_in_class_methods(tree); end
-
-  sig { returns(T::Array[::Module]) }
-  def dynamic_extends; end
-
-  def dynamic_includes; end
-
-  sig { returns(T::Boolean) }
-  def empty_attributes?; end
-
-  sig { params(qualified_mixin_name: ::String).returns(T::Boolean) }
-  def filtered_mixin?(qualified_mixin_name); end
-
-  def instance_attribute_predicates; end
-
-  sig { returns(T::Array[::Symbol]) }
-  def instance_attribute_readers; end
-
-  def instance_attribute_writers; end
-
-  sig { params(mod: ::Module, dynamic_extends: T::Array[::Module]).returns(T::Boolean) }
-  def module_included_by_another_dynamic_extend?(mod, dynamic_extends); end
-end
-
-module Tapioca::Runtime::GenericTypeRegistry
-  class << self
-    sig { params(instance: ::Object).returns(T::Boolean) }
-    def generic_type_instance?(instance); end
-
-    sig { params(constant: ::Module).returns(T.nilable(T::Array[::Tapioca::TypeVariableModule])) }
-    def lookup_type_variables(constant); end
-
-    sig { params(constant: T.untyped, types: T.untyped).returns(::Module) }
-    def register_type(constant, types); end
-
-    sig { params(constant: T.untyped, type_variable: ::Tapioca::TypeVariableModule).void }
-    def register_type_variable(constant, type_variable); end
-
-    private
-
-    sig { params(constant: ::Module, name: ::String).returns(::Module) }
-    def create_generic_type(constant, name); end
-
-    sig { params(constant: ::Class).returns(::Class) }
-    def create_safe_subclass(constant); end
-
-    sig { params(constant: ::Module).returns(T::Array[::Tapioca::TypeVariableModule]) }
-    def lookup_or_initialize_type_variables(constant); end
-  end
-end
-
-class Tapioca::Runtime::Loader
-  sig do
-    params(
-      gemfile: ::Tapioca::Gemfile,
-      initialize_file: T.nilable(::String),
-      require_file: T.nilable(::String)
-    ).void
-  end
-  def load_bundle(gemfile, initialize_file, require_file); end
-
-  sig { params(environment_load: T::Boolean, eager_load: T::Boolean).void }
-  def load_rails_application(environment_load: T.unsafe(nil), eager_load: T.unsafe(nil)); end
-
-  private
-
-  sig { void }
-  def eager_load_rails_app; end
-
-  sig { void }
-  def load_rails_engines; end
-
-  sig { returns(T::Array[T.untyped]) }
-  def rails_engines; end
-
-  sig { params(file: T.nilable(::String)).void }
-  def require_helper(file); end
-
-  sig { params(path: ::String).void }
-  def safe_require(path); end
-
-  sig { void }
-  def silence_deprecations; end
-end
-
-module Tapioca::Runtime::Reflection
-  extend ::Tapioca::Runtime::Reflection
-
-  sig { params(constant: ::Module).returns(T::Array[::Module]) }
-  def ancestors_of(constant); end
-
-  sig { params(object: ::BasicObject, other: ::BasicObject).returns(T::Boolean) }
-  def are_equal?(object, other); end
-
-  sig { params(object: ::BasicObject).returns(::Class) }
-  def class_of(object); end
-
-  sig { params(symbol: ::String, inherit: T::Boolean, namespace: ::Module).returns(::BasicObject) }
-  def constantize(symbol, inherit: T.unsafe(nil), namespace: T.unsafe(nil)); end
-
-  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
-  def constants_of(constant); end
-
-  sig do
-    type_parameters(:U)
-      .params(
-        klass: T.all(::Class, T.type_parameter(:U))
-      ).returns(T::Array[T.type_parameter(:U)])
-  end
-  def descendants_of(klass); end
-
-  sig { params(constant: ::Module).returns(T::Array[::Module]) }
-  def inherited_ancestors_of(constant); end
-
-  sig { params(constant: ::Module, method: ::Symbol).returns(::Method) }
-  def method_of(constant, method); end
-
-  sig { params(constant: ::Module).returns(T.nilable(::String)) }
-  def name_of(constant); end
-
-  sig { params(type: ::T::Types::Base).returns(::String) }
-  def name_of_type(type); end
-
-  sig { params(object: ::BasicObject).returns(::Integer) }
-  def object_id_of(object); end
-
-  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
-  def private_instance_methods_of(constant); end
-
-  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
-  def protected_instance_methods_of(constant); end
-
-  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
-  def public_instance_methods_of(constant); end
-
-  sig { params(constant: ::Module).returns(T.nilable(::String)) }
-  def qualified_name_of(constant); end
-
-  sig { params(method: T.any(::Method, ::UnboundMethod)).returns(T.untyped) }
-  def signature_of(method); end
-
-  sig { params(constant: ::Module).returns(::Class) }
-  def singleton_class_of(constant); end
-
-  sig { params(constant: ::Class).returns(T.nilable(::Class)) }
-  def superclass_of(constant); end
-end
-
-Tapioca::Runtime::Reflection::ANCESTORS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-Tapioca::Runtime::Reflection::CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-Tapioca::Runtime::Reflection::CONSTANTS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-Tapioca::Runtime::Reflection::EQUAL_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-Tapioca::Runtime::Reflection::METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-Tapioca::Runtime::Reflection::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-Tapioca::Runtime::Reflection::OBJECT_ID_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-Tapioca::Runtime::Reflection::PRIVATE_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-Tapioca::Runtime::Reflection::PROTECTED_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-Tapioca::Runtime::Reflection::PUBLIC_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-Tapioca::Runtime::Reflection::SINGLETON_CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-Tapioca::Runtime::Reflection::SUPERCLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-module Tapioca::Runtime::Trackers; end
-
-module Tapioca::Runtime::Trackers::Autoload
-  class << self
-    sig { void }
-    def eager_load_all!; end
-
-    sig { params(constant_name: ::String).void }
-    def register(constant_name); end
-
-    sig do
-      type_parameters(:Result)
-        .params(
-          block: T.proc.returns(T.type_parameter(:Result))
-        ).returns(T.type_parameter(:Result))
-    end
-    def with_disabled_exits(&block); end
-  end
-end
-
-Tapioca::Runtime::Trackers::Autoload::NOOP_METHOD = T.let(T.unsafe(nil), Proc)
-
-module Tapioca::Runtime::Trackers::ConstantDefinition
-  extend ::Tapioca::Runtime::Reflection
-
-  class << self
-    def files_for(klass); end
-  end
-end
-
-module Tapioca::Runtime::Trackers::Mixin
-  class << self
-    sig do
-      params(
-        constant: ::Module
-      ).returns(T::Hash[::Tapioca::Runtime::Trackers::Mixin::Type, T::Hash[::Module, T::Array[::String]]])
-    end
-    def mixin_locations_for(constant); end
-
-    sig do
-      params(
-        constant: ::Module,
-        mod: ::Module,
-        mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type,
-        locations: T.nilable(T::Array[::Thread::Backtrace::Location])
-      ).void
-    end
-    def register(constant, mod, mixin_type, locations); end
-  end
-end
-
-class Tapioca::Runtime::Trackers::Mixin::Type < ::T::Enum
-  enums do
-    Prepend = new
-    Include = new
-    Extend = new
-  end
-end
-
-module Tapioca::Runtime::Trackers::RequiredAncestor
-  class << self
-    sig { params(requiring: ::T::Helpers, block: T.proc.returns(::Module)).void }
-    def register(requiring, block); end
-
-    sig { params(mod: ::Module).returns(T::Array[T.proc.returns(::Module)]) }
-    def required_ancestors_blocks_by(mod); end
-
-    sig { params(mod: ::Module).returns(T::Array[T.nilable(::Module)]) }
-    def required_ancestors_by(mod); end
-  end
-end
-
-Tapioca::SORBET_CONFIG_FILE = T.let(T.unsafe(nil), String)
-Tapioca::SORBET_DIR = T.let(T.unsafe(nil), String)
-
-module Tapioca::ShimsHelper
-  requires_ancestor { Thor::Shell }
-
-  sig { params(index: ::RBI::Index, shim_rbi_dir: ::String).returns(T::Hash[::String, T::Array[::RBI::Node]]) }
-  def duplicated_nodes_from_index(index, shim_rbi_dir); end
-
-  sig { params(index: ::RBI::Index, kind: ::String, dir: ::String).void }
-  def index_rbis(index, kind, dir); end
-
-  private
-
-  sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[T.any(::RBI::Attr, ::RBI::Method)]) }
-  def extract_methods_and_attrs(nodes); end
-
-  sig do
-    params(
-      nodes: T::Array[T.any(::RBI::Attr, ::RBI::Method)]
-    ).returns(T::Array[T.any(::RBI::Attr, ::RBI::Method)])
-  end
-  def extract_nodes_with_sigs(nodes); end
-
-  sig { params(nodes: T::Array[::RBI::Node], shim_rbi_dir: ::String).returns(T::Array[::RBI::Node]) }
-  def extract_shims(nodes, shim_rbi_dir); end
-
-  sig { params(nodes: T::Array[::RBI::Node], shim_rbi_dir: ::String).returns(T::Boolean) }
-  def shims_have_duplicates?(nodes, shim_rbi_dir); end
-end
-
-module Tapioca::SignaturesHelper
-  sig { params(sig_string: ::String).returns(::String) }
-  def sanitize_signature_types(sig_string); end
-end
-
-module Tapioca::SorbetHelper
-  sig { params(sorbet_args: ::String).returns(::Tapioca::SorbetHelper::CmdResult) }
-  def sorbet(*sorbet_args); end
-
-  sig { returns(::String) }
-  def sorbet_path; end
-
-  sig { params(feature: ::Symbol, version: T.nilable(::Gem::Version)).returns(T::Boolean) }
-  def sorbet_supports?(feature, version: T.unsafe(nil)); end
-end
-
-class Tapioca::SorbetHelper::CmdResult < ::T::Struct
-  const :err, ::String
-  const :out, ::String
-  const :status, T::Boolean
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-Tapioca::SorbetHelper::FEATURE_REQUIREMENTS = T.let(T.unsafe(nil), Hash)
-Tapioca::SorbetHelper::SORBET_BIN = T.let(T.unsafe(nil), Pathname)
-Tapioca::SorbetHelper::SORBET_EXE_PATH_ENV_VAR = T.let(T.unsafe(nil), String)
-Tapioca::SorbetHelper::SORBET_GEM_SPEC = T.let(T.unsafe(nil), Gem::Specification)
-module Tapioca::Static; end
-
-class Tapioca::Static::RequiresCompiler
-  sig { params(sorbet_path: ::String).void }
-  def initialize(sorbet_path); end
-
-  sig { returns(::String) }
-  def compile; end
-
-  private
-
-  sig { params(config: ::Spoom::Sorbet::Config).returns(T::Array[::String]) }
-  def collect_files(config); end
-
-  sig { params(file_path: ::String).returns(T::Enumerable[::String]) }
-  def collect_requires(file_path); end
-
-  sig { params(config: ::Spoom::Sorbet::Config, file_path: ::Pathname).returns(T::Boolean) }
-  def file_ignored_by_sorbet?(config, file_path); end
-
-  sig { params(path: ::Pathname).returns(T::Array[::String]) }
-  def path_parts(path); end
-end
-
-module Tapioca::Static::SymbolLoader
-  extend ::Tapioca::SorbetHelper
-  extend ::Tapioca::Runtime::Reflection
-
-  class << self
-    sig { returns(T::Set[::String]) }
-    def engine_symbols; end
-
-    sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
-    def gem_symbols(gem); end
-
-    sig { returns(T::Set[::String]) }
-    def payload_symbols; end
-
-    private
-
-    sig { returns(T::Set[::String]) }
-    def load_engine_symbols; end
-
-    sig { params(input: ::String, table_type: ::String).returns(::String) }
-    def symbol_table_json_from(input, table_type: T.unsafe(nil)); end
-
-    sig { params(paths: T::Array[::Pathname]).returns(T::Set[::String]) }
-    def symbols_from_paths(paths); end
-  end
-end
-
-class Tapioca::Static::SymbolTableParser
-  sig { void }
-  def initialize; end
-
-  sig { params(name: ::String).returns(::String) }
-  def fully_qualified_name(name); end
-
-  sig { params(object: T::Hash[::String, T.untyped]).void }
-  def parse_object(object); end
-
-  sig { returns(T::Set[::String]) }
-  def symbols; end
-
-  class << self
-    sig { params(json_string: ::String).returns(T::Set[::String]) }
-    def parse_json(json_string); end
-  end
-end
-
-Tapioca::TAPIOCA_CONFIG_FILE = T.let(T.unsafe(nil), String)
-Tapioca::TAPIOCA_DIR = T.let(T.unsafe(nil), String)
-
-class Tapioca::TypeVariable < ::T::Types::TypeVariable
-  def initialize(name, variance); end
-
-  def name; end
-end
-
-module Tapioca::TypeVariableHelper
-  extend ::Tapioca::SorbetHelper
-
-  class << self
-    sig do
-      params(
-        type: ::String,
-        variance: ::Symbol,
-        fixed: T.nilable(::String),
-        upper: T.nilable(::String),
-        lower: T.nilable(::String)
-      ).returns(::String)
-    end
-    def serialize_type_variable(type, variance, fixed, upper, lower); end
-  end
-end
-
-class Tapioca::TypeVariableModule < ::Module
-  sig do
-    params(
-      context: ::Module,
-      type: ::Tapioca::TypeVariableModule::Type,
-      variance: ::Symbol,
-      fixed: T.untyped,
-      lower: T.untyped,
-      upper: T.untyped
-    ).void
-  end
-  def initialize(context, type, variance, fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil)); end
-
-  sig { returns(::Tapioca::TypeVariable) }
-  def coerce_to_type_variable; end
-
-  sig { returns(T.nilable(::String)) }
-  def name; end
-
-  sig { returns(::String) }
-  def serialize; end
-
-  private
-
-  sig do
-    type_parameters(:Result)
-      .params(
-        block: T.proc.returns(T.type_parameter(:Result))
-      ).returns(T.type_parameter(:Result))
-  end
-  def with_bound_name_pre_3_0(&block); end
-end
-
-class Tapioca::TypeVariableModule::Type < ::T::Enum
-  enums do
-    Member = new
-    Template = new
-  end
-end
-
-Tapioca::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/thor@1.2.1.rbi b/Library/Homebrew/sorbet/rbi/gems/thor@1.2.1.rbi
deleted file mode 100644
index ea083d4079a25..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/thor@1.2.1.rbi
+++ /dev/null
@@ -1,831 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `thor` gem.
-# Please instead update this file by running `bin/tapioca gem thor`.
-
-class Thor
-  include ::Thor::Base
-  include ::Thor::Invocation
-  include ::Thor::Shell
-  extend ::Thor::Base::ClassMethods
-  extend ::Thor::Invocation::ClassMethods
-
-  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
-
-  class << self
-    def check_unknown_options!(options = T.unsafe(nil)); end
-    def check_unknown_options?(config); end
-    def command_help(shell, command_name); end
-    def default_command(meth = T.unsafe(nil)); end
-    def default_task(meth = T.unsafe(nil)); end
-    def deprecation_warning(message); end
-    def desc(usage, description, options = T.unsafe(nil)); end
-    def disable_required_check!(*command_names); end
-    def disable_required_check?(command); end
-    def help(shell, subcommand = T.unsafe(nil)); end
-    def long_desc(long_description, options = T.unsafe(nil)); end
-    def map(mappings = T.unsafe(nil), **kw); end
-    def method_option(name, options = T.unsafe(nil)); end
-    def method_options(options = T.unsafe(nil)); end
-    def option(name, options = T.unsafe(nil)); end
-    def options(options = T.unsafe(nil)); end
-    def package_name(name, _ = T.unsafe(nil)); end
-    def printable_commands(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
-    def printable_tasks(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
-    def register(klass, subcommand_name, usage, description, options = T.unsafe(nil)); end
-    def stop_on_unknown_option!(*command_names); end
-    def stop_on_unknown_option?(command); end
-    def subcommand(subcommand, subcommand_class); end
-    def subcommand_classes; end
-    def subcommands; end
-    def subtask(subcommand, subcommand_class); end
-    def subtasks; end
-    def task_help(shell, command_name); end
-
-    protected
-
-    def banner(command, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
-    def baseclass; end
-    def create_command(meth); end
-    def create_task(meth); end
-    def disable_required_check; end
-    def dispatch(meth, given_args, given_opts, config); end
-    def dynamic_command_class; end
-    def find_command_possibilities(meth); end
-    def find_task_possibilities(meth); end
-    def initialize_added; end
-    def normalize_command_name(meth); end
-    def normalize_task_name(meth); end
-    def retrieve_command_name(args); end
-    def retrieve_task_name(args); end
-    def stop_on_unknown_option; end
-    def subcommand_help(cmd); end
-    def subtask_help(cmd); end
-  end
-end
-
-module Thor::Actions
-  mixes_in_class_methods ::Thor::Actions::ClassMethods
-
-  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
-
-  def action(instance); end
-  def add_file(destination, *args, &block); end
-  def add_link(destination, *args); end
-  def append_file(path, *args, &block); end
-  def append_to_file(path, *args, &block); end
-  def apply(path, config = T.unsafe(nil)); end
-  def behavior; end
-  def behavior=(_arg0); end
-  def chmod(path, mode, config = T.unsafe(nil)); end
-  def comment_lines(path, flag, *args); end
-  def copy_file(source, *args, &block); end
-  def create_file(destination, *args, &block); end
-  def create_link(destination, *args); end
-  def destination_root; end
-  def destination_root=(root); end
-  def directory(source, *args, &block); end
-  def empty_directory(destination, config = T.unsafe(nil)); end
-  def find_in_source_paths(file); end
-  def get(source, *args, &block); end
-  def gsub_file(path, flag, *args, &block); end
-  def in_root; end
-  def inject_into_class(path, klass, *args, &block); end
-  def inject_into_file(destination, *args, &block); end
-  def inject_into_module(path, module_name, *args, &block); end
-  def insert_into_file(destination, *args, &block); end
-  def inside(dir = T.unsafe(nil), config = T.unsafe(nil), &block); end
-  def link_file(source, *args); end
-  def prepend_file(path, *args, &block); end
-  def prepend_to_file(path, *args, &block); end
-  def relative_to_original_destination_root(path, remove_dot = T.unsafe(nil)); end
-  def remove_dir(path, config = T.unsafe(nil)); end
-  def remove_file(path, config = T.unsafe(nil)); end
-  def run(command, config = T.unsafe(nil)); end
-  def run_ruby_script(command, config = T.unsafe(nil)); end
-  def source_paths; end
-  def template(source, *args, &block); end
-  def thor(command, *args); end
-  def uncomment_lines(path, flag, *args); end
-
-  protected
-
-  def _cleanup_options_and_set(options, key); end
-  def _shared_configuration; end
-
-  private
-
-  def capture(*args); end
-  def concat(string); end
-  def output_buffer; end
-  def output_buffer=(_arg0); end
-  def with_output_buffer(buf = T.unsafe(nil)); end
-
-  class << self
-    def included(base); end
-  end
-end
-
-class Thor::Actions::CapturableERB < ::ERB
-  def set_eoutvar(compiler, eoutvar = T.unsafe(nil)); end
-end
-
-module Thor::Actions::ClassMethods
-  def add_runtime_options!; end
-  def source_paths; end
-  def source_paths_for_search; end
-  def source_root(path = T.unsafe(nil)); end
-end
-
-class Thor::Actions::CreateFile < ::Thor::Actions::EmptyDirectory
-  def initialize(base, destination, data, config = T.unsafe(nil)); end
-
-  def data; end
-  def identical?; end
-  def invoke!; end
-  def render; end
-
-  protected
-
-  def force_on_collision?; end
-  def force_or_skip_or_conflict(force, skip, &block); end
-  def on_conflict_behavior(&block); end
-end
-
-class Thor::Actions::CreateLink < ::Thor::Actions::CreateFile
-  def data; end
-  def exists?; end
-  def identical?; end
-  def invoke!; end
-end
-
-class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory
-  def initialize(base, source, destination = T.unsafe(nil), config = T.unsafe(nil), &block); end
-
-  def invoke!; end
-  def revoke!; end
-  def source; end
-
-  protected
-
-  def execute!; end
-  def file_level_lookup(previous_lookup); end
-  def files(lookup); end
-end
-
-class Thor::Actions::EmptyDirectory
-  def initialize(base, destination, config = T.unsafe(nil)); end
-
-  def base; end
-  def config; end
-  def destination; end
-  def exists?; end
-  def given_destination; end
-  def invoke!; end
-  def relative_destination; end
-  def revoke!; end
-
-  protected
-
-  def convert_encoded_instructions(filename); end
-  def destination=(destination); end
-  def invoke_with_conflict_check(&block); end
-  def on_conflict_behavior; end
-  def on_file_clash_behavior; end
-  def pretend?; end
-  def say_status(status, color); end
-end
-
-class Thor::Actions::InjectIntoFile < ::Thor::Actions::EmptyDirectory
-  def initialize(base, destination, data, config); end
-
-  def behavior; end
-  def flag; end
-  def invoke!; end
-  def replacement; end
-  def revoke!; end
-
-  protected
-
-  def replace!(regexp, string, force); end
-  def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end
-end
-
-Thor::Actions::WARNINGS = T.let(T.unsafe(nil), Hash)
-class Thor::AmbiguousCommandError < ::Thor::Error; end
-Thor::AmbiguousTaskError = Thor::AmbiguousCommandError
-
-class Thor::Argument
-  def initialize(name, options = T.unsafe(nil)); end
-
-  def banner; end
-  def default; end
-  def description; end
-  def enum; end
-  def human_name; end
-  def name; end
-  def required; end
-  def required?; end
-  def show_default?; end
-  def type; end
-  def usage; end
-
-  protected
-
-  def default_banner; end
-  def valid_type?(type); end
-  def validate!; end
-end
-
-Thor::Argument::VALID_TYPES = T.let(T.unsafe(nil), Array)
-
-class Thor::Arguments
-  def initialize(arguments = T.unsafe(nil)); end
-
-  def parse(args); end
-  def remaining; end
-
-  private
-
-  def check_requirement!; end
-  def current_is_value?; end
-  def last?; end
-  def no_or_skip?(arg); end
-  def parse_array(name); end
-  def parse_hash(name); end
-  def parse_numeric(name); end
-  def parse_string(name); end
-  def peek; end
-  def shift; end
-  def unshift(arg); end
-
-  class << self
-    def parse(*args); end
-    def split(args); end
-  end
-end
-
-Thor::Arguments::NUMERIC = T.let(T.unsafe(nil), Regexp)
-
-module Thor::Base
-  include ::Thor::Invocation
-  include ::Thor::Shell
-
-  mixes_in_class_methods ::Thor::Base::ClassMethods
-  mixes_in_class_methods ::Thor::Invocation::ClassMethods
-
-  def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end
-
-  def args; end
-  def args=(_arg0); end
-  def options; end
-  def options=(_arg0); end
-  def parent_options; end
-  def parent_options=(_arg0); end
-
-  class << self
-    def included(base); end
-    def register_klass_file(klass); end
-    def shell; end
-    def shell=(_arg0); end
-    def subclass_files; end
-    def subclasses; end
-  end
-end
-
-module Thor::Base::ClassMethods
-  def all_commands; end
-  def all_tasks; end
-  def allow_incompatible_default_type!; end
-  def argument(name, options = T.unsafe(nil)); end
-  def arguments; end
-  def attr_accessor(*_arg0); end
-  def attr_reader(*_arg0); end
-  def attr_writer(*_arg0); end
-  def check_default_type; end
-  def check_default_type!; end
-  def check_unknown_options; end
-  def check_unknown_options!; end
-  def check_unknown_options?(config); end
-  def class_option(name, options = T.unsafe(nil)); end
-  def class_options(options = T.unsafe(nil)); end
-  def commands; end
-  def disable_required_check?(command_name); end
-  def exit_on_failure?; end
-  def group(name = T.unsafe(nil)); end
-  def handle_argument_error(command, error, args, arity); end
-  def handle_no_command_error(command, has_namespace = T.unsafe(nil)); end
-  def handle_no_task_error(command, has_namespace = T.unsafe(nil)); end
-  def namespace(name = T.unsafe(nil)); end
-  def no_commands(&block); end
-  def no_commands?; end
-  def no_commands_context; end
-  def no_tasks(&block); end
-  def public_command(*names); end
-  def public_task(*names); end
-  def remove_argument(*names); end
-  def remove_class_option(*names); end
-  def remove_command(*names); end
-  def remove_task(*names); end
-  def start(given_args = T.unsafe(nil), config = T.unsafe(nil)); end
-  def stop_on_unknown_option?(command_name); end
-  def strict_args_position; end
-  def strict_args_position!; end
-  def strict_args_position?(config); end
-  def tasks; end
-
-  protected
-
-  def baseclass; end
-  def basename; end
-  def build_option(name, options, scope); end
-  def build_options(options, scope); end
-  def class_options_help(shell, groups = T.unsafe(nil)); end
-  def create_command(meth); end
-  def create_task(meth); end
-  def dispatch(command, given_args, given_opts, config); end
-  def find_and_refresh_command(name); end
-  def find_and_refresh_task(name); end
-  def from_superclass(method, default = T.unsafe(nil)); end
-  def inherited(klass); end
-  def initialize_added; end
-  def is_thor_reserved_word?(word, type); end
-  def method_added(meth); end
-  def print_options(shell, options, group_name = T.unsafe(nil)); end
-end
-
-class Thor::Command < ::Struct
-  def initialize(name, description, long_description, usage, options = T.unsafe(nil)); end
-
-  def formatted_usage(klass, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
-  def hidden?; end
-  def run(instance, args = T.unsafe(nil)); end
-
-  protected
-
-  def handle_argument_error?(instance, error, caller); end
-  def handle_no_method_error?(instance, error, caller); end
-  def local_method?(instance, name); end
-  def not_debugging?(instance); end
-  def private_method?(instance); end
-  def public_method?(instance); end
-  def required_arguments_for(klass, usage); end
-  def required_options; end
-  def sans_backtrace(backtrace, caller); end
-
-  private
-
-  def initialize_copy(other); end
-end
-
-Thor::Command::FILE_REGEXP = T.let(T.unsafe(nil), Regexp)
-module Thor::CoreExt; end
-
-class Thor::CoreExt::HashWithIndifferentAccess < ::Hash
-  def initialize(hash = T.unsafe(nil)); end
-
-  def [](key); end
-  def []=(key, value); end
-  def delete(key); end
-  def except(*keys); end
-  def fetch(key, *args); end
-  def key?(key); end
-  def merge(other); end
-  def merge!(other); end
-  def replace(other_hash); end
-  def reverse_merge(other); end
-  def reverse_merge!(other_hash); end
-  def to_hash; end
-  def values_at(*indices); end
-
-  protected
-
-  def convert_key(key); end
-  def method_missing(method, *args); end
-end
-
-Thor::Correctable = DidYouMean::Correctable
-
-class Thor::DynamicCommand < ::Thor::Command
-  def initialize(name, options = T.unsafe(nil)); end
-
-  def run(instance, args = T.unsafe(nil)); end
-end
-
-Thor::DynamicTask = Thor::DynamicCommand
-class Thor::Error < ::StandardError; end
-
-class Thor::Group
-  include ::Thor::Base
-  include ::Thor::Invocation
-  include ::Thor::Shell
-  extend ::Thor::Base::ClassMethods
-  extend ::Thor::Invocation::ClassMethods
-
-  protected
-
-  def _invoke_for_class_method(klass, command = T.unsafe(nil), *args, &block); end
-
-  class << self
-    def class_options_help(shell, groups = T.unsafe(nil)); end
-    def desc(description = T.unsafe(nil)); end
-    def get_options_from_invocations(group_options, base_options); end
-    def handle_argument_error(command, error, _args, arity); end
-    def help(shell); end
-    def invocation_blocks; end
-    def invocations; end
-    def invoke(*names, &block); end
-    def invoke_from_option(*names, &block); end
-    def printable_commands(*_arg0); end
-    def printable_tasks(*_arg0); end
-    def remove_invocation(*names); end
-
-    protected
-
-    def banner; end
-    def baseclass; end
-    def create_command(meth); end
-    def create_task(meth); end
-    def dispatch(command, given_args, given_opts, config); end
-    def self_command; end
-    def self_task; end
-  end
-end
-
-Thor::HELP_MAPPINGS = T.let(T.unsafe(nil), Array)
-
-class Thor::HiddenCommand < ::Thor::Command
-  def hidden?; end
-end
-
-Thor::HiddenTask = Thor::HiddenCommand
-
-module Thor::Invocation
-  mixes_in_class_methods ::Thor::Invocation::ClassMethods
-
-  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil), &block); end
-
-  def current_command_chain; end
-  def invoke(name = T.unsafe(nil), *args); end
-  def invoke_all; end
-  def invoke_command(command, *args); end
-  def invoke_task(command, *args); end
-  def invoke_with_padding(*args); end
-
-  protected
-
-  def _parse_initialization_options(args, opts, config); end
-  def _retrieve_class_and_command(name, sent_command = T.unsafe(nil)); end
-  def _retrieve_class_and_task(name, sent_command = T.unsafe(nil)); end
-  def _shared_configuration; end
-
-  class << self
-    def included(base); end
-  end
-end
-
-module Thor::Invocation::ClassMethods
-  def prepare_for_invocation(key, name); end
-end
-
-class Thor::InvocationError < ::Thor::Error; end
-
-module Thor::LineEditor
-  class << self
-    def best_available; end
-    def readline(prompt, options = T.unsafe(nil)); end
-  end
-end
-
-class Thor::LineEditor::Basic
-  def initialize(prompt, options); end
-
-  def options; end
-  def prompt; end
-  def readline; end
-
-  private
-
-  def echo?; end
-  def get_input; end
-
-  class << self
-    def available?; end
-  end
-end
-
-class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic
-  def readline; end
-
-  private
-
-  def add_to_history?; end
-  def completion_options; end
-  def completion_proc; end
-  def use_path_completion?; end
-
-  class << self
-    def available?; end
-  end
-end
-
-class Thor::LineEditor::Readline::PathCompletion
-  def initialize(text); end
-
-  def matches; end
-
-  private
-
-  def absolute_matches; end
-  def base_path; end
-  def glob_pattern; end
-  def relative_matches; end
-  def text; end
-end
-
-class Thor::MalformattedArgumentError < ::Thor::InvocationError; end
-
-class Thor::NestedContext
-  def initialize; end
-
-  def enter; end
-  def entered?; end
-
-  private
-
-  def pop; end
-  def push; end
-end
-
-class Thor::NoKwargSpellChecker < ::DidYouMean::SpellChecker
-  def initialize(dictionary); end
-end
-
-class Thor::Option < ::Thor::Argument
-  def initialize(name, options = T.unsafe(nil)); end
-
-  def aliases; end
-  def array?; end
-  def boolean?; end
-  def group; end
-  def hash?; end
-  def hide; end
-  def human_name; end
-  def lazy_default; end
-  def numeric?; end
-  def repeatable; end
-  def string?; end
-  def switch_name; end
-  def usage(padding = T.unsafe(nil)); end
-
-  protected
-
-  def dasherize(str); end
-  def dasherized?; end
-  def undasherize(str); end
-  def validate!; end
-  def validate_default_type!; end
-
-  class << self
-    def parse(key, value); end
-  end
-end
-
-Thor::Option::VALID_TYPES = T.let(T.unsafe(nil), Array)
-
-class Thor::Options < ::Thor::Arguments
-  def initialize(hash_options = T.unsafe(nil), defaults = T.unsafe(nil), stop_on_unknown = T.unsafe(nil), disable_required_check = T.unsafe(nil)); end
-
-  def check_unknown!; end
-  def parse(args); end
-  def peek; end
-  def remaining; end
-  def shift; end
-  def unshift(arg, is_value: T.unsafe(nil)); end
-
-  protected
-
-  def assign_result!(option, result); end
-  def current_is_switch?; end
-  def current_is_switch_formatted?; end
-  def current_is_value?; end
-  def normalize_switch(arg); end
-  def parse_boolean(switch); end
-  def parse_peek(switch, option); end
-  def parsing_options?; end
-  def switch?(arg); end
-  def switch_option(arg); end
-
-  class << self
-    def to_switches(options); end
-  end
-end
-
-Thor::Options::EQ_RE = T.let(T.unsafe(nil), Regexp)
-Thor::Options::LONG_RE = T.let(T.unsafe(nil), Regexp)
-Thor::Options::OPTS_END = T.let(T.unsafe(nil), String)
-Thor::Options::SHORT_NUM = T.let(T.unsafe(nil), Regexp)
-Thor::Options::SHORT_RE = T.let(T.unsafe(nil), Regexp)
-Thor::Options::SHORT_SQ_RE = T.let(T.unsafe(nil), Regexp)
-class Thor::RequiredArgumentMissingError < ::Thor::InvocationError; end
-module Thor::Sandbox; end
-
-module Thor::Shell
-  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
-
-  def ask(*args, &block); end
-  def error(*args, &block); end
-  def file_collision(*args, &block); end
-  def no?(*args, &block); end
-  def print_in_columns(*args, &block); end
-  def print_table(*args, &block); end
-  def print_wrapped(*args, &block); end
-  def say(*args, &block); end
-  def say_error(*args, &block); end
-  def say_status(*args, &block); end
-  def set_color(*args, &block); end
-  def shell; end
-  def shell=(_arg0); end
-  def terminal_width(*args, &block); end
-  def with_padding; end
-  def yes?(*args, &block); end
-
-  protected
-
-  def _shared_configuration; end
-end
-
-class Thor::Shell::Basic
-  def initialize; end
-
-  def ask(statement, *args); end
-  def base; end
-  def base=(_arg0); end
-  def error(statement); end
-  def file_collision(destination); end
-  def indent(count = T.unsafe(nil)); end
-  def mute; end
-  def mute?; end
-  def no?(statement, color = T.unsafe(nil)); end
-  def padding; end
-  def padding=(value); end
-  def print_in_columns(array); end
-  def print_table(array, options = T.unsafe(nil)); end
-  def print_wrapped(message, options = T.unsafe(nil)); end
-  def say(message = T.unsafe(nil), color = T.unsafe(nil), force_new_line = T.unsafe(nil)); end
-  def say_error(message = T.unsafe(nil), color = T.unsafe(nil), force_new_line = T.unsafe(nil)); end
-  def say_status(status, message, log_status = T.unsafe(nil)); end
-  def set_color(string, *_arg1); end
-  def terminal_width; end
-  def yes?(statement, color = T.unsafe(nil)); end
-
-  protected
-
-  def answer_match(possibilities, answer, case_insensitive); end
-  def as_unicode; end
-  def ask_filtered(statement, color, options); end
-  def ask_simply(statement, color, options); end
-  def can_display_colors?; end
-  def dynamic_width; end
-  def dynamic_width_stty; end
-  def dynamic_width_tput; end
-  def file_collision_help; end
-  def git_merge_tool; end
-  def is?(value); end
-  def lookup_color(color); end
-  def merge(destination, content); end
-  def merge_tool; end
-  def prepare_message(message, *color); end
-  def quiet?; end
-  def show_diff(destination, content); end
-  def stderr; end
-  def stdout; end
-  def truncate(string, width); end
-  def unix?; end
-end
-
-Thor::Shell::Basic::DEFAULT_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer)
-
-class Thor::Shell::Color < ::Thor::Shell::Basic
-  def set_color(string, *colors); end
-
-  protected
-
-  def are_colors_disabled?; end
-  def are_colors_supported?; end
-  def can_display_colors?; end
-  def diff_lcs_loaded?; end
-  def output_diff_line(diff); end
-  def show_diff(destination, content); end
-end
-
-Thor::Shell::Color::BLACK = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::BLUE = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::BOLD = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::CLEAR = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::CYAN = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::GREEN = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::MAGENTA = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::ON_BLACK = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::ON_BLUE = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::ON_CYAN = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::ON_GREEN = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::ON_MAGENTA = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::ON_RED = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::ON_WHITE = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::ON_YELLOW = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::RED = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::WHITE = T.let(T.unsafe(nil), String)
-Thor::Shell::Color::YELLOW = T.let(T.unsafe(nil), String)
-
-class Thor::Shell::HTML < ::Thor::Shell::Basic
-  def ask(statement, color = T.unsafe(nil)); end
-  def set_color(string, *colors); end
-
-  protected
-
-  def can_display_colors?; end
-  def diff_lcs_loaded?; end
-  def output_diff_line(diff); end
-  def show_diff(destination, content); end
-end
-
-Thor::Shell::HTML::BLACK = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::BLUE = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::BOLD = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::CYAN = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::GREEN = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::MAGENTA = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::ON_BLACK = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::ON_BLUE = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::ON_CYAN = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::ON_GREEN = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::ON_MAGENTA = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::ON_RED = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::ON_WHITE = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::ON_YELLOW = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::RED = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::WHITE = T.let(T.unsafe(nil), String)
-Thor::Shell::HTML::YELLOW = T.let(T.unsafe(nil), String)
-Thor::Shell::SHELL_DELEGATED_METHODS = T.let(T.unsafe(nil), Array)
-Thor::TEMPLATE_EXTNAME = T.let(T.unsafe(nil), String)
-Thor::THOR_RESERVED_WORDS = T.let(T.unsafe(nil), Array)
-Thor::Task = Thor::Command
-
-class Thor::UndefinedCommandError < ::Thor::Error
-  include ::DidYouMean::Correctable
-
-  def initialize(command, all_commands, namespace); end
-
-  def all_commands; end
-  def command; end
-end
-
-class Thor::UndefinedCommandError::SpellChecker
-  def initialize(error); end
-
-  def corrections; end
-  def error; end
-  def spell_checker; end
-end
-
-Thor::UndefinedTaskError = Thor::UndefinedCommandError
-
-class Thor::UnknownArgumentError < ::Thor::Error
-  include ::DidYouMean::Correctable
-
-  def initialize(switches, unknown); end
-
-  def switches; end
-  def unknown; end
-end
-
-class Thor::UnknownArgumentError::SpellChecker
-  def initialize(error); end
-
-  def corrections; end
-  def error; end
-  def spell_checker; end
-end
-
-module Thor::Util
-  class << self
-    def camel_case(str); end
-    def escape_globs(path); end
-    def escape_html(string); end
-    def find_by_namespace(namespace); end
-    def find_class_and_command_by_namespace(namespace, fallback = T.unsafe(nil)); end
-    def find_class_and_task_by_namespace(namespace, fallback = T.unsafe(nil)); end
-    def globs_for(path); end
-    def load_thorfile(path, content = T.unsafe(nil), debug = T.unsafe(nil)); end
-    def namespace_from_thor_class(constant); end
-    def namespaces_in_content(contents, file = T.unsafe(nil)); end
-    def ruby_command; end
-    def snake_case(str); end
-    def thor_classes_in(klass); end
-    def thor_root; end
-    def thor_root_glob; end
-    def user_home; end
-  end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/thor@1.3.2.rbi b/Library/Homebrew/sorbet/rbi/gems/thor@1.3.2.rbi
new file mode 100644
index 0000000000000..06a6a7c745455
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/thor@1.3.2.rbi
@@ -0,0 +1,4345 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `thor` gem.
+# Please instead update this file by running `bin/tapioca gem thor`.
+
+
+# source://thor//lib/thor/shell/lcs_diff.rb#1
+module LCSDiff
+  protected
+
+  # Overwrite show_diff to show diff with colors if Diff::LCS is
+  # available.
+  #
+  # source://thor//lib/thor/shell/lcs_diff.rb#6
+  def show_diff(destination, content); end
+
+  private
+
+  # Check if Diff::LCS is loaded. If it is, use it to create pretty output
+  # for diff.
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/shell/lcs_diff.rb#37
+  def diff_lcs_loaded?; end
+
+  # source://thor//lib/thor/shell/lcs_diff.rb#21
+  def output_diff_line(diff); end
+end
+
+# source://thor//lib/thor/command.rb#1
+class Thor
+  include ::Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+  extend ::Thor::Base::ClassMethods
+  extend ::Thor::Invocation::ClassMethods
+
+  # source://thor//lib/thor.rb#663
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+  class << self
+    # Adds and declares option group for required at least one of options in the
+    # block of arguments. You can declare options as the outside of the block.
+    #
+    # If :for is given as option, it allows you to change the options from
+    # a previous defined command.
+    #
+    # ==== Parameters
+    # Array[Thor::Option.name]
+    # options<Hash>:: :for is applied for previous defined command.
+    #
+    # ==== Examples
+    #
+    #   at_least_one do
+    #     option :one
+    #     option :two
+    #   end
+    #
+    # Or
+    #
+    #   option :one
+    #   option :two
+    #   at_least_one :one, :two
+    #
+    # If you do not give "--one" and "--two" AtLeastOneRequiredArgumentError
+    # will be raised.
+    #
+    # You can use at_least_one and exclusive at the same time.
+    #
+    #    exclusive do
+    #      at_least_one do
+    #        option :one
+    #        option :two
+    #      end
+    #    end
+    #
+    # Then it is required either only one of "--one" or "--two".
+    #
+    # source://thor//lib/thor.rb#246
+    def at_least_one(*args, &block); end
+
+    # Extend check unknown options to accept a hash of conditions.
+    #
+    # === Parameters
+    # options<Hash>: A hash containing :only and/or :except keys
+    #
+    # source://thor//lib/thor.rb#350
+    def check_unknown_options!(options = T.unsafe(nil)); end
+
+    # Overwrite check_unknown_options? to take subcommands and options into account.
+    #
+    # @return [Boolean]
+    #
+    # source://thor//lib/thor.rb#363
+    def check_unknown_options?(config); end
+
+    # Checks if a specified command exists.
+    #
+    # ==== Parameters
+    # command_name<String>:: The name of the command to check for existence.
+    #
+    # ==== Returns
+    # Boolean:: +true+ if the command exists, +false+ otherwise.
+    #
+    # @return [Boolean]
+    #
+    # source://thor//lib/thor.rb#449
+    def command_exists?(command_name); end
+
+    # Prints help information for the given command.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    # command_name<String>
+    #
+    # source://thor//lib/thor.rb#258
+    def command_help(shell, command_name); end
+
+    # Sets the default command when thor is executed without an explicit command to be called.
+    #
+    # ==== Parameters
+    # meth<Symbol>:: name of the default command
+    #
+    # source://thor//lib/thor.rb#21
+    def default_command(meth = T.unsafe(nil)); end
+
+    # Sets the default command when thor is executed without an explicit command to be called.
+    #
+    # ==== Parameters
+    # meth<Symbol>:: name of the default command
+    #
+    # source://thor//lib/thor.rb#21
+    def default_task(meth = T.unsafe(nil)); end
+
+    # source://thor//lib/thor/base.rb#26
+    def deprecation_warning(message); end
+
+    # Defines the usage and the description of the next command.
+    #
+    # ==== Parameters
+    # usage<String>
+    # description<String>
+    # options<String>
+    #
+    # source://thor//lib/thor.rb#54
+    def desc(usage, description, options = T.unsafe(nil)); end
+
+    # Disable the check for required options for the given commands.
+    # This is useful if you have a command that does not need the required options
+    # to work, like help.
+    #
+    # ==== Parameters
+    # Symbol ...:: A list of commands that should be affected.
+    #
+    # source://thor//lib/thor.rb#434
+    def disable_required_check!(*command_names); end
+
+    # @return [Boolean]
+    #
+    # source://thor//lib/thor.rb#438
+    def disable_required_check?(command); end
+
+    # Adds and declares option group for exclusive options in the
+    # block and arguments. You can declare options as the outside of the block.
+    #
+    # If :for is given as option, it allows you to change the options from
+    # a previous defined command.
+    #
+    # ==== Parameters
+    # Array[Thor::Option.name]
+    # options<Hash>:: :for is applied for previous defined command.
+    #
+    # ==== Examples
+    #
+    #   exclusive do
+    #     option :one
+    #     option :two
+    #   end
+    #
+    # Or
+    #
+    #   option :one
+    #   option :two
+    #   exclusive :one, :two
+    #
+    # If you give "--one" and "--two" at the same time ExclusiveArgumentsError
+    # will be raised.
+    #
+    # source://thor//lib/thor.rb#203
+    def exclusive(*args, &block); end
+
+    # Prints help information for this class.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    #
+    # source://thor//lib/thor.rb#288
+    def help(shell, subcommand = T.unsafe(nil)); end
+
+    # Defines the long description of the next command.
+    #
+    # Long description is by default indented, line-wrapped and repeated whitespace merged.
+    # In order to print long description verbatim, with indentation and spacing exactly
+    # as found in the code, use the +wrap+ option
+    #
+    #   long_desc 'your very long description', wrap: false
+    #
+    # ==== Parameters
+    # long description<String>
+    # options<Hash>
+    #
+    # source://thor//lib/thor.rb#78
+    def long_desc(long_description, options = T.unsafe(nil)); end
+
+    # Maps an input to a command. If you define:
+    #
+    #   map "-T" => "list"
+    #
+    # Running:
+    #
+    #   thor -T
+    #
+    # Will invoke the list command.
+    #
+    # ==== Parameters
+    # Hash[String|Array => Symbol]:: Maps the string or the strings in the array to the given command.
+    #
+    # source://thor//lib/thor.rb#101
+    def map(mappings = T.unsafe(nil), **kw); end
+
+    # Adds and declares option group for required at least one of options in the
+    # block of arguments. You can declare options as the outside of the block.
+    #
+    # If :for is given as option, it allows you to change the options from
+    # a previous defined command.
+    #
+    # ==== Parameters
+    # Array[Thor::Option.name]
+    # options<Hash>:: :for is applied for previous defined command.
+    #
+    # ==== Examples
+    #
+    #   at_least_one do
+    #     option :one
+    #     option :two
+    #   end
+    #
+    # Or
+    #
+    #   option :one
+    #   option :two
+    #   at_least_one :one, :two
+    #
+    # If you do not give "--one" and "--two" AtLeastOneRequiredArgumentError
+    # will be raised.
+    #
+    # You can use at_least_one and exclusive at the same time.
+    #
+    #    exclusive do
+    #      at_least_one do
+    #        option :one
+    #        option :two
+    #      end
+    #    end
+    #
+    # Then it is required either only one of "--one" or "--two".
+    #
+    # source://thor//lib/thor.rb#246
+    def method_at_least_one(*args, &block); end
+
+    # Adds and declares option group for exclusive options in the
+    # block and arguments. You can declare options as the outside of the block.
+    #
+    # If :for is given as option, it allows you to change the options from
+    # a previous defined command.
+    #
+    # ==== Parameters
+    # Array[Thor::Option.name]
+    # options<Hash>:: :for is applied for previous defined command.
+    #
+    # ==== Examples
+    #
+    #   exclusive do
+    #     option :one
+    #     option :two
+    #   end
+    #
+    # Or
+    #
+    #   option :one
+    #   option :two
+    #   exclusive :one, :two
+    #
+    # If you give "--one" and "--two" at the same time ExclusiveArgumentsError
+    # will be raised.
+    #
+    # source://thor//lib/thor.rb#203
+    def method_exclusive(*args, &block); end
+
+    # Adds an option to the set of method options. If :for is given as option,
+    # it allows you to change the options from a previous defined command.
+    #
+    #   def previous_command
+    #     # magic
+    #   end
+    #
+    #   method_option :foo, :for => :previous_command
+    #
+    #   def next_command
+    #     # magic
+    #   end
+    #
+    # ==== Parameters
+    # name<Symbol>:: The name of the argument.
+    # options<Hash>:: Described below.
+    #
+    # ==== Options
+    # :desc     - Description for the argument.
+    # :required - If the argument is required or not.
+    # :default  - Default value for this argument. It cannot be required and have default values.
+    # :aliases  - Aliases for this option.
+    # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+    # :banner   - String to show on usage notes.
+    # :hide     - If you want to hide this option from the help.
+    #
+    # source://thor//lib/thor.rb#163
+    def method_option(name, options = T.unsafe(nil)); end
+
+    # Declares the options for the next command to be declared.
+    #
+    # ==== Parameters
+    # Hash[Symbol => Object]:: The hash key is the name of the option and the value
+    # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
+    # or :required (string). If you give a value, the type of the value is used.
+    #
+    # source://thor//lib/thor.rb#129
+    def method_options(options = T.unsafe(nil)); end
+
+    # Adds an option to the set of method options. If :for is given as option,
+    # it allows you to change the options from a previous defined command.
+    #
+    #   def previous_command
+    #     # magic
+    #   end
+    #
+    #   method_option :foo, :for => :previous_command
+    #
+    #   def next_command
+    #     # magic
+    #   end
+    #
+    # ==== Parameters
+    # name<Symbol>:: The name of the argument.
+    # options<Hash>:: Described below.
+    #
+    # ==== Options
+    # :desc     - Description for the argument.
+    # :required - If the argument is required or not.
+    # :default  - Default value for this argument. It cannot be required and have default values.
+    # :aliases  - Aliases for this option.
+    # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+    # :banner   - String to show on usage notes.
+    # :hide     - If you want to hide this option from the help.
+    #
+    # source://thor//lib/thor.rb#163
+    def option(name, options = T.unsafe(nil)); end
+
+    # Declares the options for the next command to be declared.
+    #
+    # ==== Parameters
+    # Hash[Symbol => Object]:: The hash key is the name of the option and the value
+    # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
+    # or :required (string). If you give a value, the type of the value is used.
+    #
+    # source://thor//lib/thor.rb#129
+    def options(options = T.unsafe(nil)); end
+
+    # Allows for custom "Command" package naming.
+    #
+    # === Parameters
+    # name<String>
+    # options<Hash>
+    #
+    # source://thor//lib/thor.rb#12
+    def package_name(name, _ = T.unsafe(nil)); end
+
+    # Returns commands ready to be printed.
+    #
+    # source://thor//lib/thor.rb#309
+    def printable_commands(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+    # Returns commands ready to be printed.
+    #
+    # source://thor//lib/thor.rb#309
+    def printable_tasks(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+    # Registers another Thor subclass as a command.
+    #
+    # ==== Parameters
+    # klass<Class>:: Thor subclass to register
+    # command<String>:: Subcommand name to use
+    # usage<String>:: Short usage for the subcommand
+    # description<String>:: Description for the subcommand
+    #
+    # source://thor//lib/thor.rb#37
+    def register(klass, subcommand_name, usage, description, options = T.unsafe(nil)); end
+
+    # Stop parsing of options as soon as an unknown option or a regular
+    # argument is encountered.  All remaining arguments are passed to the command.
+    # This is useful if you have a command that can receive arbitrary additional
+    # options, and where those additional options should not be handled by
+    # Thor.
+    #
+    # ==== Example
+    #
+    # To better understand how this is useful, let's consider a command that calls
+    # an external command.  A user may want to pass arbitrary options and
+    # arguments to that command.  The command itself also accepts some options,
+    # which should be handled by Thor.
+    #
+    #   class_option "verbose",  :type => :boolean
+    #   stop_on_unknown_option! :exec
+    #   check_unknown_options!  :except => :exec
+    #
+    #   desc "exec", "Run a shell command"
+    #   def exec(*args)
+    #     puts "diagnostic output" if options[:verbose]
+    #     Kernel.exec(*args)
+    #   end
+    #
+    # Here +exec+ can be called with +--verbose+ to get diagnostic output,
+    # e.g.:
+    #
+    #   $ thor exec --verbose echo foo
+    #   diagnostic output
+    #   foo
+    #
+    # But if +--verbose+ is given after +echo+, it is passed to +echo+ instead:
+    #
+    #   $ thor exec echo --verbose foo
+    #   --verbose foo
+    #
+    # ==== Parameters
+    # Symbol ...:: A list of commands that should be affected.
+    #
+    # source://thor//lib/thor.rb#420
+    def stop_on_unknown_option!(*command_names); end
+
+    # @return [Boolean]
+    #
+    # source://thor//lib/thor.rb#424
+    def stop_on_unknown_option?(command); end
+
+    # source://thor//lib/thor.rb#329
+    def subcommand(subcommand, subcommand_class); end
+
+    # source://thor//lib/thor.rb#325
+    def subcommand_classes; end
+
+    # source://thor//lib/thor.rb#320
+    def subcommands; end
+
+    # source://thor//lib/thor.rb#329
+    def subtask(subcommand, subcommand_class); end
+
+    # source://thor//lib/thor.rb#320
+    def subtasks; end
+
+    # Prints help information for the given command.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    # command_name<String>
+    #
+    # source://thor//lib/thor.rb#258
+    def task_help(shell, command_name); end
+
+    protected
+
+    # The banner for this class. You can customize it if you are invoking the
+    # thor class by another ways which is not the Thor::Runner. It receives
+    # the command that is going to be invoked and a boolean which indicates if
+    # the namespace should be displayed as arguments.
+    #
+    # source://thor//lib/thor.rb#546
+    def banner(command, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+    # source://thor//lib/thor.rb#552
+    def baseclass; end
+
+    # source://thor//lib/thor.rb#560
+    def create_command(meth); end
+
+    # source://thor//lib/thor.rb#560
+    def create_task(meth); end
+
+    # help command has the required check disabled by default.
+    #
+    # source://thor//lib/thor.rb#478
+    def disable_required_check; end
+
+    # The method responsible for dispatching given the args.
+    #
+    # @yield [instance]
+    #
+    # source://thor//lib/thor.rb#505
+    def dispatch(meth, given_args, given_opts, config); end
+
+    # source://thor//lib/thor.rb#556
+    def dynamic_command_class; end
+
+    # this is the logic that takes the command name passed in by the user
+    # and determines whether it is an unambiguous substrings of a command or
+    # alias name.
+    #
+    # source://thor//lib/thor.rb#626
+    def find_command_possibilities(meth); end
+
+    # this is the logic that takes the command name passed in by the user
+    # and determines whether it is an unambiguous substrings of a command or
+    # alias name.
+    #
+    # source://thor//lib/thor.rb#626
+    def find_task_possibilities(meth); end
+
+    # source://thor//lib/thor.rb#586
+    def initialize_added; end
+
+    # Returns this class at least one of required options array set.
+    #
+    # ==== Returns
+    # Array[Array[Thor::Option.name]]
+    #
+    # source://thor//lib/thor.rb#469
+    def method_at_least_one_option_names; end
+
+    # Returns this class exclusive options array set.
+    #
+    # ==== Returns
+    # Array[Array[Thor::Option.name]]
+    #
+    # source://thor//lib/thor.rb#460
+    def method_exclusive_option_names; end
+
+    # receives a (possibly nil) command name and returns a name that is in
+    # the commands hash. In addition to normalizing aliases, this logic
+    # will determine if a shortened command is an unambiguous substring of
+    # a command or alias.
+    #
+    # +normalize_command_name+ also converts names like +animal-prison+
+    # into +animal_prison+.
+    #
+    # @raise [AmbiguousTaskError]
+    #
+    # source://thor//lib/thor.rb#605
+    def normalize_command_name(meth); end
+
+    # receives a (possibly nil) command name and returns a name that is in
+    # the commands hash. In addition to normalizing aliases, this logic
+    # will determine if a shortened command is an unambiguous substring of
+    # a command or alias.
+    #
+    # +normalize_command_name+ also converts names like +animal-prison+
+    # into +animal_prison+.
+    #
+    # @raise [AmbiguousTaskError]
+    #
+    # source://thor//lib/thor.rb#605
+    def normalize_task_name(meth); end
+
+    # source://thor//lib/thor.rb#493
+    def print_at_least_one_required_options(shell, command = T.unsafe(nil)); end
+
+    # source://thor//lib/thor.rb#482
+    def print_exclusive_options(shell, command = T.unsafe(nil)); end
+
+    # Retrieve the command name from given args.
+    #
+    # source://thor//lib/thor.rb#592
+    def retrieve_command_name(args); end
+
+    # Retrieve the command name from given args.
+    #
+    # source://thor//lib/thor.rb#592
+    def retrieve_task_name(args); end
+
+    # Sort the commands, lexicographically by default.
+    #
+    # Can be overridden in the subclass to change the display order of the
+    # commands.
+    #
+    # source://thor//lib/thor.rb#653
+    def sort_commands!(list); end
+
+    # source://thor//lib/thor.rb#473
+    def stop_on_unknown_option; end
+
+    # source://thor//lib/thor.rb#641
+    def subcommand_help(cmd); end
+
+    # source://thor//lib/thor.rb#641
+    def subtask_help(cmd); end
+  end
+end
+
+# source://thor//lib/thor/actions/empty_directory.rb#2
+module Thor::Actions
+  mixes_in_class_methods ::Thor::Actions::ClassMethods
+
+  # Extends initializer to add more configuration options.
+  #
+  # ==== Configuration
+  # behavior<Symbol>:: The actions default behavior. Can be :invoke or :revoke.
+  #                    It also accepts :force, :skip and :pretend to set the behavior
+  #                    and the respective option.
+  #
+  # destination_root<String>:: The root directory needed for some actions.
+  #
+  # source://thor//lib/thor/actions.rb#72
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
+
+  # Wraps an action object and call it accordingly to the thor class behavior.
+  #
+  # source://thor//lib/thor/actions.rb#89
+  def action(instance); end
+
+  # Create a new file relative to the destination root with the given data,
+  # which is the return value of a block or a data string.
+  #
+  # ==== Parameters
+  # destination<String>:: the relative path to the destination root.
+  # data<String|NilClass>:: the data to append to the file.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   create_file "lib/fun_party.rb" do
+  #     hostname = ask("What is the virtual hostname I should use?")
+  #     "vhost.name = #{hostname}"
+  #   end
+  #
+  #   create_file "config/apache.conf", "your apache config"
+  #
+  # source://thor//lib/thor/actions/create_file.rb#22
+  def add_file(destination, *args, &block); end
+
+  # Create a new file relative to the destination root from the given source.
+  #
+  # ==== Parameters
+  # destination<String>:: the relative path to the destination root.
+  # source<String|NilClass>:: the relative path to the source root.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #   :: give :symbolic => false for hard link.
+  #
+  # ==== Examples
+  #
+  #   create_link "config/apache.conf", "/etc/apache.conf"
+  #
+  # source://thor//lib/thor/actions/create_link.rb#17
+  def add_link(destination, *args); end
+
+  # Append text to a file. Since it depends on insert_into_file, it's reversible.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # data<String>:: the data to append to the file, can be also given as a block.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   append_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+  #
+  #   append_to_file 'config/environments/test.rb' do
+  #     'config.gem "rspec"'
+  #   end
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#192
+  def append_file(path, *args, &block); end
+
+  # Append text to a file. Since it depends on insert_into_file, it's reversible.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # data<String>:: the data to append to the file, can be also given as a block.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   append_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+  #
+  #   append_to_file 'config/environments/test.rb' do
+  #     'config.gem "rspec"'
+  #   end
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#192
+  def append_to_file(path, *args, &block); end
+
+  # Loads an external file and execute it in the instance binding.
+  #
+  # ==== Parameters
+  # path<String>:: The path to the file to execute. Can be a web address or
+  #                a relative path from the source root.
+  #
+  # ==== Examples
+  #
+  #   apply "http://gist.github.com/103208"
+  #
+  #   apply "recipes/jquery.rb"
+  #
+  # source://thor//lib/thor/actions.rb#216
+  def apply(path, config = T.unsafe(nil)); end
+
+  # Returns the value of attribute behavior.
+  #
+  # source://thor//lib/thor/actions.rb#10
+  def behavior; end
+
+  # Sets the attribute behavior
+  #
+  # @param value the value to set the attribute behavior to.
+  #
+  # source://thor//lib/thor/actions.rb#10
+  def behavior=(_arg0); end
+
+  # Changes the mode of the given file or directory.
+  #
+  # ==== Parameters
+  # mode<Integer>:: the file mode
+  # path<String>:: the name of the file to change mode
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   chmod "script/server", 0755
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#145
+  def chmod(path, mode, config = T.unsafe(nil)); end
+
+  # Comment all lines matching a given regex.  It will leave the space
+  # which existed before the beginning of the line in tact and will insert
+  # a single space after the comment hash.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # flag<Regexp|String>:: the regexp or string used to decide which lines to comment
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   comment_lines 'config/initializers/session_store.rb', /cookie_store/
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#308
+  def comment_lines(path, flag, *args); end
+
+  # Copies the file from the relative source to the relative destination. If
+  # the destination is not given it's assumed to be equal to the source.
+  #
+  # ==== Parameters
+  # source<String>:: the relative path to the source root.
+  # destination<String>:: the relative path to the destination root.
+  # config<Hash>:: give :verbose => false to not log the status, and
+  #                :mode => :preserve, to preserve the file mode from the source.
+  #
+  # ==== Examples
+  #
+  #   copy_file "README", "doc/README"
+  #
+  #   copy_file "doc/README"
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#20
+  def copy_file(source, *args, &block); end
+
+  # Create a new file relative to the destination root with the given data,
+  # which is the return value of a block or a data string.
+  #
+  # ==== Parameters
+  # destination<String>:: the relative path to the destination root.
+  # data<String|NilClass>:: the data to append to the file.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   create_file "lib/fun_party.rb" do
+  #     hostname = ask("What is the virtual hostname I should use?")
+  #     "vhost.name = #{hostname}"
+  #   end
+  #
+  #   create_file "config/apache.conf", "your apache config"
+  #
+  # source://thor//lib/thor/actions/create_file.rb#22
+  def create_file(destination, *args, &block); end
+
+  # Create a new file relative to the destination root from the given source.
+  #
+  # ==== Parameters
+  # destination<String>:: the relative path to the destination root.
+  # source<String|NilClass>:: the relative path to the source root.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #   :: give :symbolic => false for hard link.
+  #
+  # ==== Examples
+  #
+  #   create_link "config/apache.conf", "/etc/apache.conf"
+  #
+  # source://thor//lib/thor/actions/create_link.rb#17
+  def create_link(destination, *args); end
+
+  # Returns the root for this thor class (also aliased as destination root).
+  #
+  # source://thor//lib/thor/actions.rb#99
+  def destination_root; end
+
+  # Sets the root for this thor class. Relatives path are added to the
+  # directory where the script was invoked and expanded.
+  #
+  # source://thor//lib/thor/actions.rb#106
+  def destination_root=(root); end
+
+  # Copies recursively the files from source directory to root directory.
+  # If any of the files finishes with .tt, it's considered to be a template
+  # and is placed in the destination without the extension .tt. If any
+  # empty directory is found, it's copied and all .empty_directory files are
+  # ignored. If any file name is wrapped within % signs, the text within
+  # the % signs will be executed as a method and replaced with the returned
+  # value. Let's suppose a doc directory with the following files:
+  #
+  #   doc/
+  #     components/.empty_directory
+  #     README
+  #     rdoc.rb.tt
+  #     %app_name%.rb
+  #
+  # When invoked as:
+  #
+  #   directory "doc"
+  #
+  # It will create a doc directory in the destination with the following
+  # files (assuming that the `app_name` method returns the value "blog"):
+  #
+  #   doc/
+  #     components/
+  #     README
+  #     rdoc.rb
+  #     blog.rb
+  #
+  # <b>Encoded path note:</b> Since Thor internals use Object#respond_to? to check if it can
+  # expand %something%, this `something` should be a public method in the class calling
+  # #directory. If a method is private, Thor stack raises PrivateMethodEncodedError.
+  #
+  # ==== Parameters
+  # source<String>:: the relative path to the source root.
+  # destination<String>:: the relative path to the destination root.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #                If :recursive => false, does not look for paths recursively.
+  #                If :mode => :preserve, preserve the file mode from the source.
+  #                If :exclude_pattern => /regexp/, prevents copying files that match that regexp.
+  #
+  # ==== Examples
+  #
+  #   directory "doc"
+  #   directory "doc", "docs", :recursive => false
+  #
+  # source://thor//lib/thor/actions/directory.rb#49
+  def directory(source, *args, &block); end
+
+  # Creates an empty directory.
+  #
+  # ==== Parameters
+  # destination<String>:: the relative path to the destination root.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   empty_directory "doc"
+  #
+  # source://thor//lib/thor/actions/empty_directory.rb#13
+  def empty_directory(destination, config = T.unsafe(nil)); end
+
+  # Receives a file or directory and search for it in the source paths.
+  #
+  # @raise [Error]
+  #
+  # source://thor//lib/thor/actions.rb#133
+  def find_in_source_paths(file); end
+
+  # Gets the content at the given address and places it at the given relative
+  # destination. If a block is given instead of destination, the content of
+  # the url is yielded and used as location.
+  #
+  # +get+ relies on open-uri, so passing application user input would provide
+  # a command injection attack vector.
+  #
+  # ==== Parameters
+  # source<String>:: the address of the given content.
+  # destination<String>:: the relative path to the destination root.
+  # config<Hash>:: give :verbose => false to not log the status, and
+  #                :http_headers => <Hash> to add headers to an http request.
+  #
+  # ==== Examples
+  #
+  #   get "http://gist.github.com/103208", "doc/README"
+  #
+  #   get "http://gist.github.com/103208", "doc/README", :http_headers => {"Content-Type" => "application/json"}
+  #
+  #   get "http://gist.github.com/103208" do |content|
+  #     content.split("\n").first
+  #   end
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#81
+  def get(source, *args, &block); end
+
+  # Run a regular expression replacement on a file.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # flag<Regexp|String>:: the regexp or string to be replaced
+  # replacement<String>:: the replacement, can be also given as a block
+  # config<Hash>:: give :verbose => false to not log the status, and
+  #                :force => true, to force the replacement regardless of runner behavior.
+  #
+  # ==== Example
+  #
+  #   gsub_file 'app/controllers/application_controller.rb', /#\s*(filter_parameter_logging :password)/, '\1'
+  #
+  #   gsub_file 'README', /rake/, :green do |match|
+  #     match << " no more. Use thor!"
+  #   end
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#262
+  def gsub_file(path, flag, *args, &block); end
+
+  # Goes to the root and execute the given block.
+  #
+  # source://thor//lib/thor/actions.rb#200
+  def in_root; end
+
+  # Injects text right after the class definition. Since it depends on
+  # insert_into_file, it's reversible.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # klass<String|Class>:: the class to be manipulated
+  # data<String>:: the data to append to the class, can be also given as a block.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   inject_into_class "app/controllers/application_controller.rb", "ApplicationController", "  filter_parameter :password\n"
+  #
+  #   inject_into_class "app/controllers/application_controller.rb", "ApplicationController" do
+  #     "  filter_parameter :password\n"
+  #   end
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#216
+  def inject_into_class(path, klass, *args, &block); end
+
+  # source://thor//lib/thor/actions/inject_into_file.rb#26
+  def inject_into_file(destination, *args, &block); end
+
+  # Injects text right after the module definition. Since it depends on
+  # insert_into_file, it's reversible.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # module_name<String|Class>:: the module to be manipulated
+  # data<String>:: the data to append to the class, can be also given as a block.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   inject_into_module "app/helpers/application_helper.rb", "ApplicationHelper", "  def help; 'help'; end\n"
+  #
+  #   inject_into_module "app/helpers/application_helper.rb", "ApplicationHelper" do
+  #     "  def help; 'help'; end\n"
+  #   end
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#239
+  def inject_into_module(path, module_name, *args, &block); end
+
+  # source://thor//lib/thor/actions/inject_into_file.rb#26
+  def insert_into_file(destination, *args, &block); end
+
+  # Do something in the root or on a provided subfolder. If a relative path
+  # is given it's referenced from the current root. The full path is yielded
+  # to the block you provide. The path is set back to the previous path when
+  # the method exits.
+  #
+  # Returns the value yielded by the block.
+  #
+  # ==== Parameters
+  # dir<String>:: the directory to move to.
+  # config<Hash>:: give :verbose => true to log and use padding.
+  #
+  # source://thor//lib/thor/actions.rb#170
+  def inside(dir = T.unsafe(nil), config = T.unsafe(nil), &block); end
+
+  # Links the file from the relative source to the relative destination. If
+  # the destination is not given it's assumed to be equal to the source.
+  #
+  # ==== Parameters
+  # source<String>:: the relative path to the source root.
+  # destination<String>:: the relative path to the destination root.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   link_file "README", "doc/README"
+  #
+  #   link_file "doc/README"
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#50
+  def link_file(source, *args); end
+
+  # Prepend text to a file. Since it depends on insert_into_file, it's reversible.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # data<String>:: the data to prepend to the file, can be also given as a block.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   prepend_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+  #
+  #   prepend_to_file 'config/environments/test.rb' do
+  #     'config.gem "rspec"'
+  #   end
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#170
+  def prepend_file(path, *args, &block); end
+
+  # Prepend text to a file. Since it depends on insert_into_file, it's reversible.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # data<String>:: the data to prepend to the file, can be also given as a block.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   prepend_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+  #
+  #   prepend_to_file 'config/environments/test.rb' do
+  #     'config.gem "rspec"'
+  #   end
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#170
+  def prepend_to_file(path, *args, &block); end
+
+  # Returns the given path relative to the absolute root (ie, root where
+  # the script started).
+  #
+  # source://thor//lib/thor/actions.rb#114
+  def relative_to_original_destination_root(path, remove_dot = T.unsafe(nil)); end
+
+  # Removes a file at the given location.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   remove_file 'README'
+  #   remove_file 'app/controllers/application_controller.rb'
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#325
+  def remove_dir(path, config = T.unsafe(nil)); end
+
+  # Removes a file at the given location.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   remove_file 'README'
+  #   remove_file 'app/controllers/application_controller.rb'
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#325
+  def remove_file(path, config = T.unsafe(nil)); end
+
+  # Executes a command returning the contents of the command.
+  #
+  # ==== Parameters
+  # command<String>:: the command to be executed.
+  # config<Hash>:: give :verbose => false to not log the status, :capture => true to hide to output. Specify :with
+  #                to append an executable to command execution.
+  #
+  # ==== Example
+  #
+  #   inside('vendor') do
+  #     run('ln -s ~/edge rails')
+  #   end
+  #
+  # source://thor//lib/thor/actions.rb#248
+  def run(command, config = T.unsafe(nil)); end
+
+  # Executes a ruby script (taking into account WIN32 platform quirks).
+  #
+  # ==== Parameters
+  # command<String>:: the command to be executed.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # source://thor//lib/thor/actions.rb#285
+  def run_ruby_script(command, config = T.unsafe(nil)); end
+
+  # Holds source paths in instance so they can be manipulated.
+  #
+  # source://thor//lib/thor/actions.rb#127
+  def source_paths; end
+
+  # Gets an ERB template at the relative source, executes it and makes a copy
+  # at the relative destination. If the destination is not given it's assumed
+  # to be equal to the source removing .tt from the filename.
+  #
+  # ==== Parameters
+  # source<String>:: the relative path to the source root.
+  # destination<String>:: the relative path to the destination root.
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Examples
+  #
+  #   template "README", "doc/README"
+  #
+  #   template "doc/README"
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#117
+  def template(source, *args, &block); end
+
+  # Run a thor command. A hash of options can be given and it's converted to
+  # switches.
+  #
+  # ==== Parameters
+  # command<String>:: the command to be invoked
+  # args<Array>:: arguments to the command
+  # config<Hash>:: give :verbose => false to not log the status, :capture => true to hide to output.
+  #                Other options are given as parameter to Thor.
+  #
+  #
+  # ==== Examples
+  #
+  #   thor :install, "http://gist.github.com/103208"
+  #   #=> thor install http://gist.github.com/103208
+  #
+  #   thor :list, :all => true, :substring => 'rails'
+  #   #=> thor list --all --substring=rails
+  #
+  # source://thor//lib/thor/actions.rb#308
+  def thor(command, *args); end
+
+  # Uncomment all lines matching a given regex. Preserves indentation before
+  # the comment hash and removes the hash and any immediate following space.
+  #
+  # ==== Parameters
+  # path<String>:: path of the file to be changed
+  # flag<Regexp|String>:: the regexp or string used to decide which lines to uncomment
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # ==== Example
+  #
+  #   uncomment_lines 'config/initializers/session_store.rb', /active_record/
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#289
+  def uncomment_lines(path, flag, *args); end
+
+  protected
+
+  # source://thor//lib/thor/actions.rb#329
+  def _cleanup_options_and_set(options, key); end
+
+  # Allow current root to be shared between invocations.
+  #
+  # source://thor//lib/thor/actions.rb#325
+  def _shared_configuration; end
+
+  private
+
+  # source://thor//lib/thor/actions/file_manipulation.rb#346
+  def capture(*args); end
+
+  # source://thor//lib/thor/actions/file_manipulation.rb#342
+  def concat(string); end
+
+  # Returns the value of attribute output_buffer.
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#337
+  def output_buffer; end
+
+  # Sets the attribute output_buffer
+  #
+  # @param value the value to set the attribute output_buffer to.
+  #
+  # source://thor//lib/thor/actions/file_manipulation.rb#337
+  def output_buffer=(_arg0); end
+
+  # source://thor//lib/thor/actions/file_manipulation.rb#350
+  def with_output_buffer(buf = T.unsafe(nil)); end
+
+  class << self
+    # source://thor//lib/thor/actions.rb#12
+    def included(base); end
+  end
+end
+
+# Thor::Actions#capture depends on what kind of buffer is used in ERB.
+# Thus CapturableERB fixes ERB to use String buffer.
+#
+# source://thor//lib/thor/actions/file_manipulation.rb#362
+class Thor::Actions::CapturableERB < ::ERB
+  # source://thor//lib/thor/actions/file_manipulation.rb#363
+  def set_eoutvar(compiler, eoutvar = T.unsafe(nil)); end
+end
+
+# source://thor//lib/thor/actions.rb#17
+module Thor::Actions::ClassMethods
+  # Add runtime options that help actions execution.
+  #
+  # source://thor//lib/thor/actions.rb#48
+  def add_runtime_options!; end
+
+  # Hold source paths for one Thor instance. source_paths_for_search is the
+  # method responsible to gather source_paths from this current class,
+  # inherited paths and the source root.
+  #
+  # source://thor//lib/thor/actions.rb#22
+  def source_paths; end
+
+  # Returns the source paths in the following order:
+  #
+  #   1) This class source paths
+  #   2) Source root
+  #   3) Parents source paths
+  #
+  # source://thor//lib/thor/actions.rb#38
+  def source_paths_for_search; end
+
+  # Stores and return the source root for this class
+  #
+  # source://thor//lib/thor/actions.rb#27
+  def source_root(path = T.unsafe(nil)); end
+end
+
+# CreateFile is a subset of Template, which instead of rendering a file with
+# ERB, it gets the content from the user.
+#
+# source://thor//lib/thor/actions/create_file.rb#32
+class Thor::Actions::CreateFile < ::Thor::Actions::EmptyDirectory
+  # @return [CreateFile] a new instance of CreateFile
+  #
+  # source://thor//lib/thor/actions/create_file.rb#35
+  def initialize(base, destination, data, config = T.unsafe(nil)); end
+
+  # source://thor//lib/thor/actions/create_file.rb#33
+  def data; end
+
+  # Checks if the content of the file at the destination is identical to the rendered result.
+  #
+  # ==== Returns
+  # Boolean:: true if it is identical, false otherwise.
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/actions/create_file.rb#45
+  def identical?; end
+
+  # source://thor//lib/thor/actions/create_file.rb#60
+  def invoke!; end
+
+  # Holds the content to be added to the file.
+  #
+  # source://thor//lib/thor/actions/create_file.rb#52
+  def render; end
+
+  protected
+
+  # Shows the file collision menu to the user and gets the result.
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/actions/create_file.rb#100
+  def force_on_collision?; end
+
+  # If force is true, run the action, otherwise check if it's not being
+  # skipped. If both are false, show the file_collision menu, if the menu
+  # returns true, force it, otherwise skip.
+  #
+  # source://thor//lib/thor/actions/create_file.rb#86
+  def force_or_skip_or_conflict(force, skip, &block); end
+
+  # Now on conflict we check if the file is identical or not.
+  #
+  # source://thor//lib/thor/actions/create_file.rb#73
+  def on_conflict_behavior(&block); end
+end
+
+# CreateLink is a subset of CreateFile, which instead of taking a block of
+# data, just takes a source string from the user.
+#
+# source://thor//lib/thor/actions/create_link.rb#27
+class Thor::Actions::CreateLink < ::Thor::Actions::CreateFile
+  # source://thor//lib/thor/actions/create_link.rb#28
+  def data; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/actions/create_link.rb#56
+  def exists?; end
+
+  # Checks if the content of the file at the destination is identical to the rendered result.
+  #
+  # ==== Returns
+  # Boolean:: true if it is identical, false otherwise.
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/actions/create_link.rb#35
+  def identical?; end
+
+  # source://thor//lib/thor/actions/create_link.rb#40
+  def invoke!; end
+end
+
+# source://thor//lib/thor/actions/directory.rb#55
+class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory
+  # @return [Directory] a new instance of Directory
+  #
+  # source://thor//lib/thor/actions/directory.rb#58
+  def initialize(base, source, destination = T.unsafe(nil), config = T.unsafe(nil), &block); end
+
+  # source://thor//lib/thor/actions/directory.rb#64
+  def invoke!; end
+
+  # source://thor//lib/thor/actions/directory.rb#69
+  def revoke!; end
+
+  # Returns the value of attribute source.
+  #
+  # source://thor//lib/thor/actions/directory.rb#56
+  def source; end
+
+  protected
+
+  # source://thor//lib/thor/actions/directory.rb#75
+  def execute!; end
+
+  # source://thor//lib/thor/actions/directory.rb#99
+  def file_level_lookup(previous_lookup); end
+
+  # source://thor//lib/thor/actions/directory.rb#103
+  def files(lookup); end
+end
+
+# source://thor//lib/thor/actions/empty_directory.rb#23
+class Thor::Actions::EmptyDirectory
+  # Initializes given the source and destination.
+  #
+  # ==== Parameters
+  # base<Thor::Base>:: A Thor::Base instance
+  # source<String>:: Relative path to the source of this file
+  # destination<String>:: Relative path to the destination of this file
+  # config<Hash>:: give :verbose => false to not log the status.
+  #
+  # @return [EmptyDirectory] a new instance of EmptyDirectory
+  #
+  # source://thor//lib/thor/actions/empty_directory.rb#34
+  def initialize(base, destination, config = T.unsafe(nil)); end
+
+  # source://thor//lib/thor/actions/empty_directory.rb#24
+  def base; end
+
+  # source://thor//lib/thor/actions/empty_directory.rb#24
+  def config; end
+
+  # source://thor//lib/thor/actions/empty_directory.rb#24
+  def destination; end
+
+  # Checks if the destination file already exists.
+  #
+  # ==== Returns
+  # Boolean:: true if the file exists, false otherwise.
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/actions/empty_directory.rb#45
+  def exists?; end
+
+  # source://thor//lib/thor/actions/empty_directory.rb#24
+  def given_destination; end
+
+  # source://thor//lib/thor/actions/empty_directory.rb#49
+  def invoke!; end
+
+  # source://thor//lib/thor/actions/empty_directory.rb#24
+  def relative_destination; end
+
+  # source://thor//lib/thor/actions/empty_directory.rb#56
+  def revoke!; end
+
+  protected
+
+  # Filenames in the encoded form are converted. If you have a file:
+  #
+  #   %file_name%.rb
+  #
+  # It calls #file_name from the base and replaces %-string with the
+  # return value (should be String) of #file_name:
+  #
+  #   user.rb
+  #
+  # The method referenced can be either public or private.
+  #
+  # source://thor//lib/thor/actions/empty_directory.rb#103
+  def convert_encoded_instructions(filename); end
+
+  # Sets the absolute destination value from a relative destination value.
+  # It also stores the given and relative destination. Let's suppose our
+  # script is being executed on "dest", it sets the destination root to
+  # "dest". The destination, given_destination and relative_destination
+  # are related in the following way:
+  #
+  #   inside "bar" do
+  #     empty_directory "baz"
+  #   end
+  #
+  #   destination          #=> dest/bar/baz
+  #   relative_destination #=> bar/baz
+  #   given_destination    #=> baz
+  #
+  # source://thor//lib/thor/actions/empty_directory.rb#85
+  def destination=(destination); end
+
+  # Receives a hash of options and just execute the block if some
+  # conditions are met.
+  #
+  # source://thor//lib/thor/actions/empty_directory.rb#113
+  def invoke_with_conflict_check(&block); end
+
+  # What to do when the destination file already exists.
+  #
+  # source://thor//lib/thor/actions/empty_directory.rb#132
+  def on_conflict_behavior; end
+
+  # source://thor//lib/thor/actions/empty_directory.rb#126
+  def on_file_clash_behavior; end
+
+  # Shortcut for pretend.
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/actions/empty_directory.rb#67
+  def pretend?; end
+
+  # Shortcut to say_status shell method.
+  #
+  # source://thor//lib/thor/actions/empty_directory.rb#138
+  def say_status(status, color); end
+end
+
+# source://thor//lib/thor/actions/inject_into_file.rb#36
+class Thor::Actions::InjectIntoFile < ::Thor::Actions::EmptyDirectory
+  # @return [InjectIntoFile] a new instance of InjectIntoFile
+  #
+  # source://thor//lib/thor/actions/inject_into_file.rb#39
+  def initialize(base, destination, data, config); end
+
+  # Returns the value of attribute behavior.
+  #
+  # source://thor//lib/thor/actions/inject_into_file.rb#37
+  def behavior; end
+
+  # Returns the value of attribute flag.
+  #
+  # source://thor//lib/thor/actions/inject_into_file.rb#37
+  def flag; end
+
+  # source://thor//lib/thor/actions/inject_into_file.rb#52
+  def invoke!; end
+
+  # Returns the value of attribute replacement.
+  #
+  # source://thor//lib/thor/actions/inject_into_file.rb#37
+  def replacement; end
+
+  # source://thor//lib/thor/actions/inject_into_file.rb#74
+  def revoke!; end
+
+  protected
+
+  # source://thor//lib/thor/actions/inject_into_file.rb#110
+  def content; end
+
+  # Adds the content to the file.
+  #
+  # source://thor//lib/thor/actions/inject_into_file.rb#120
+  def replace!(regexp, string, force); end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/actions/inject_into_file.rb#114
+  def replacement_present?; end
+
+  # source://thor//lib/thor/actions/inject_into_file.rb#90
+  def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end
+end
+
+# Injects the given content into a file. Different from gsub_file, this
+# method is reversible.
+#
+# ==== Parameters
+# destination<String>:: Relative path to the destination root
+# data<String>:: Data to add to the file. Can be given as a block.
+# config<Hash>:: give :verbose => false to not log the status and the flag
+#                for injection (:after or :before) or :force => true for
+#                insert two or more times the same content.
+#
+# ==== Examples
+#
+#   insert_into_file "config/environment.rb", "config.gem :thor", :after => "Rails::Initializer.run do |config|\n"
+#
+#   insert_into_file "config/environment.rb", :after => "Rails::Initializer.run do |config|\n" do
+#     gems = ask "Which gems would you like to add?"
+#     gems.split(" ").map{ |gem| "  config.gem :#{gem}" }.join("\n")
+#   end
+#
+# source://thor//lib/thor/actions/inject_into_file.rb#24
+Thor::Actions::WARNINGS = T.let(T.unsafe(nil), Hash)
+
+# source://thor//lib/thor/error.rb#57
+class Thor::AmbiguousCommandError < ::Thor::Error; end
+
+# source://thor//lib/thor/error.rb#59
+Thor::AmbiguousTaskError = Thor::AmbiguousCommandError
+
+# source://thor//lib/thor/parser/argument.rb#2
+class Thor::Argument
+  # @raise [ArgumentError]
+  # @return [Argument] a new instance of Argument
+  #
+  # source://thor//lib/thor/parser/argument.rb#8
+  def initialize(name, options = T.unsafe(nil)); end
+
+  # Returns the value of attribute banner.
+  #
+  # source://thor//lib/thor/parser/argument.rb#5
+  def banner; end
+
+  # Returns the value of attribute default.
+  #
+  # source://thor//lib/thor/parser/argument.rb#5
+  def default; end
+
+  # Returns the value of attribute description.
+  #
+  # source://thor//lib/thor/parser/argument.rb#5
+  def description; end
+
+  # Returns the value of attribute enum.
+  #
+  # source://thor//lib/thor/parser/argument.rb#5
+  def enum; end
+
+  # source://thor//lib/thor/parser/argument.rb#52
+  def enum_to_s; end
+
+  # Returns the value of attribute name.
+  #
+  # source://thor//lib/thor/parser/argument.rb#5
+  def human_name; end
+
+  # Returns the value of attribute name.
+  #
+  # source://thor//lib/thor/parser/argument.rb#5
+  def name; end
+
+  # source://thor//lib/thor/parser/argument.rb#27
+  def print_default; end
+
+  # Returns the value of attribute required.
+  #
+  # source://thor//lib/thor/parser/argument.rb#5
+  def required; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/parser/argument.rb#39
+  def required?; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/parser/argument.rb#43
+  def show_default?; end
+
+  # Returns the value of attribute type.
+  #
+  # source://thor//lib/thor/parser/argument.rb#5
+  def type; end
+
+  # source://thor//lib/thor/parser/argument.rb#35
+  def usage; end
+
+  protected
+
+  # source://thor//lib/thor/parser/argument.rb#71
+  def default_banner; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/parser/argument.rb#67
+  def valid_type?(type); end
+
+  # @raise [ArgumentError]
+  #
+  # source://thor//lib/thor/parser/argument.rb#62
+  def validate!; end
+end
+
+# source://thor//lib/thor/parser/argument.rb#3
+Thor::Argument::VALID_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://thor//lib/thor/parser/arguments.rb#2
+class Thor::Arguments
+  # Takes an array of Thor::Argument objects.
+  #
+  # @return [Arguments] a new instance of Arguments
+  #
+  # source://thor//lib/thor/parser/arguments.rb#26
+  def initialize(arguments = T.unsafe(nil)); end
+
+  # source://thor//lib/thor/parser/arguments.rb#40
+  def parse(args); end
+
+  # source://thor//lib/thor/parser/arguments.rb#53
+  def remaining; end
+
+  private
+
+  # Raises an error if @non_assigned_required array is not empty.
+  #
+  # @raise [RequiredArgumentMissingError]
+  #
+  # source://thor//lib/thor/parser/arguments.rb#186
+  def check_requirement!; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/parser/arguments.rb#84
+  def current_is_value?; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/parser/arguments.rb#64
+  def last?; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/parser/arguments.rb#59
+  def no_or_skip?(arg); end
+
+  # Runs through the argument array getting all strings until no string is
+  # found or a switch is found.
+  #
+  #   ["a", "b", "c"]
+  #
+  # And returns it as an array:
+  #
+  #   ["a", "b", "c"]
+  #
+  # source://thor//lib/thor/parser/arguments.rb#118
+  def parse_array(name); end
+
+  # Runs through the argument array getting strings that contains ":" and
+  # mark it as a hash:
+  #
+  #   [ "name:string", "age:integer" ]
+  #
+  # Becomes:
+  #
+  #   { "name" => "string", "age" => "integer" }
+  #
+  # source://thor//lib/thor/parser/arguments.rb#97
+  def parse_hash(name); end
+
+  # Check if the peek is numeric format and return a Float or Integer.
+  # Check if the peek is included in enum if enum is provided.
+  # Otherwise raises an error.
+  #
+  # source://thor//lib/thor/parser/arguments.rb#139
+  def parse_numeric(name); end
+
+  # Parse string:
+  # for --string-arg, just return the current value in the pile
+  # for --no-string-arg, nil
+  # Check if the peek is included in enum if enum is provided. Otherwise raises an error.
+  #
+  # source://thor//lib/thor/parser/arguments.rb#158
+  def parse_string(name); end
+
+  # source://thor//lib/thor/parser/arguments.rb#68
+  def peek; end
+
+  # source://thor//lib/thor/parser/arguments.rb#72
+  def shift; end
+
+  # source://thor//lib/thor/parser/arguments.rb#76
+  def unshift(arg); end
+
+  # Raises an error if the switch is an enum and the values aren't included on it.
+  #
+  # source://thor//lib/thor/parser/arguments.rb#172
+  def validate_enum_value!(name, value, message); end
+
+  class << self
+    # source://thor//lib/thor/parser/arguments.rb#19
+    def parse(*args); end
+
+    # Receives an array of args and returns two arrays, one with arguments
+    # and one with switches.
+    #
+    # source://thor//lib/thor/parser/arguments.rb#8
+    def split(args); end
+  end
+end
+
+# source://thor//lib/thor/parser/arguments.rb#3
+Thor::Arguments::NUMERIC = T.let(T.unsafe(nil), Regexp)
+
+# source://thor//lib/thor/error.rb#104
+class Thor::AtLeastOneRequiredArgumentError < ::Thor::InvocationError; end
+
+# source://thor//lib/thor/shell.rb#4
+module Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+
+  mixes_in_class_methods ::Thor::Base::ClassMethods
+  mixes_in_class_methods ::Thor::Invocation::ClassMethods
+
+  # It receives arguments in an Array and two hashes, one for options and
+  # other for configuration.
+  #
+  # Notice that it does not check if all required arguments were supplied.
+  # It should be done by the parser.
+  #
+  # ==== Parameters
+  # args<Array[Object]>:: An array of objects. The objects are applied to their
+  #                       respective accessors declared with <tt>argument</tt>.
+  #
+  # options<Hash>:: An options hash that will be available as self.options.
+  #                 The hash given is converted to a hash with indifferent
+  #                 access, magic predicates (options.skip?) and then frozen.
+  #
+  # config<Hash>:: Configuration for this Thor class.
+  #
+  # source://thor//lib/thor/base.rb#53
+  def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end
+
+  # Returns the value of attribute args.
+  #
+  # source://thor//lib/thor/base.rb#35
+  def args; end
+
+  # Sets the attribute args
+  #
+  # @param value the value to set the attribute args to.
+  #
+  # source://thor//lib/thor/base.rb#35
+  def args=(_arg0); end
+
+  # Returns the value of attribute options.
+  #
+  # source://thor//lib/thor/base.rb#35
+  def options; end
+
+  # Sets the attribute options
+  #
+  # @param value the value to set the attribute options to.
+  #
+  # source://thor//lib/thor/base.rb#35
+  def options=(_arg0); end
+
+  # Returns the value of attribute parent_options.
+  #
+  # source://thor//lib/thor/base.rb#35
+  def parent_options; end
+
+  # Sets the attribute parent_options
+  #
+  # @param value the value to set the attribute parent_options to.
+  #
+  # source://thor//lib/thor/base.rb#35
+  def parent_options=(_arg0); end
+
+  class << self
+    # source://thor//lib/thor/base.rb#116
+    def included(base); end
+
+    # Whenever a class inherits from Thor or Thor::Group, we should track the
+    # class and the file on Thor::Base. This is the method responsible for it.
+    #
+    # source://thor//lib/thor/base.rb#144
+    def register_klass_file(klass); end
+
+    # Returns the shell used in all Thor classes. If you are in a Unix platform
+    # it will use a colored log, otherwise it will use a basic one without color.
+    #
+    # source://thor//lib/thor/shell.rb#11
+    def shell; end
+
+    # Sets the attribute shell
+    #
+    # @param value the value to set the attribute shell to.
+    #
+    # source://thor//lib/thor/shell.rb#6
+    def shell=(_arg0); end
+
+    # Returns the files where the subclasses are kept.
+    #
+    # ==== Returns
+    # Hash[path<String> => Class]
+    #
+    # source://thor//lib/thor/base.rb#137
+    def subclass_files; end
+
+    # Returns the classes that inherits from Thor or Thor::Group.
+    #
+    # ==== Returns
+    # Array[Class]
+    #
+    # source://thor//lib/thor/base.rb#128
+    def subclasses; end
+  end
+end
+
+# source://thor//lib/thor/base.rb#153
+module Thor::Base::ClassMethods
+  # Returns the commands for this Thor class and all subclasses.
+  #
+  # ==== Returns
+  # Hash:: An ordered hash with commands names as keys and Thor::Command
+  #        objects as values.
+  #
+  # source://thor//lib/thor/base.rb#482
+  def all_commands; end
+
+  # Returns the commands for this Thor class and all subclasses.
+  #
+  # ==== Returns
+  # Hash:: An ordered hash with commands names as keys and Thor::Command
+  #        objects as values.
+  #
+  # source://thor//lib/thor/base.rb#482
+  def all_tasks; end
+
+  # If you want to use defaults that don't match the type of an option,
+  # either specify `check_default_type: false` or call `allow_incompatible_default_type!`
+  #
+  # source://thor//lib/thor/base.rb#189
+  def allow_incompatible_default_type!; end
+
+  # Adds an argument to the class and creates an attr_accessor for it.
+  #
+  # Arguments are different from options in several aspects. The first one
+  # is how they are parsed from the command line, arguments are retrieved
+  # from position:
+  #
+  #   thor command NAME
+  #
+  # Instead of:
+  #
+  #   thor command --name=NAME
+  #
+  # Besides, arguments are used inside your code as an accessor (self.argument),
+  # while options are all kept in a hash (self.options).
+  #
+  # Finally, arguments cannot have type :default or :boolean but can be
+  # optional (supplying :optional => :true or :required => false), although
+  # you cannot have a required argument after a non-required argument. If you
+  # try it, an error is raised.
+  #
+  # ==== Parameters
+  # name<Symbol>:: The name of the argument.
+  # options<Hash>:: Described below.
+  #
+  # ==== Options
+  # :desc     - Description for the argument.
+  # :required - If the argument is required or not.
+  # :optional - If the argument is optional or not.
+  # :type     - The type of the argument, can be :string, :hash, :array, :numeric.
+  # :default  - Default value for this argument. It cannot be required and have default values.
+  # :banner   - String to show on usage notes.
+  #
+  # ==== Errors
+  # ArgumentError:: Raised if you supply a required argument after a non required one.
+  #
+  # source://thor//lib/thor/base.rb#261
+  def argument(name, options = T.unsafe(nil)); end
+
+  # Returns this class arguments, looking up in the ancestors chain.
+  #
+  # ==== Returns
+  # Array[Thor::Argument]
+  #
+  # source://thor//lib/thor/base.rb#293
+  def arguments; end
+
+  # source://thor//lib/thor/base.rb#162
+  def attr_accessor(*_arg0); end
+
+  # source://thor//lib/thor/base.rb#154
+  def attr_reader(*_arg0); end
+
+  # source://thor//lib/thor/base.rb#158
+  def attr_writer(*_arg0); end
+
+  # source://thor//lib/thor/base.rb#193
+  def check_default_type; end
+
+  # If you want to raise an error when the default value of an option does not match
+  # the type call check_default_type!
+  # This will be the default; for compatibility a deprecation warning is issued if necessary.
+  #
+  # source://thor//lib/thor/base.rb#183
+  def check_default_type!; end
+
+  # source://thor//lib/thor/base.rb#172
+  def check_unknown_options; end
+
+  # If you want to raise an error for unknown options, call check_unknown_options!
+  # This is disabled by default to allow dynamic invocations.
+  #
+  # source://thor//lib/thor/base.rb#168
+  def check_unknown_options!; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/base.rb#176
+  def check_unknown_options?(config); end
+
+  # Adds and declares option group for required at least one of options in the
+  # block and arguments. You can declare options as the outside of the block.
+  #
+  # ==== Examples
+  #
+  #   class_at_least_one do
+  #     class_option :one
+  #     class_option :two
+  #    end
+  #
+  # Or
+  #
+  #   class_option :one
+  #   class_option :two
+  #   class_at_least_one :one, :two
+  #
+  # If you do not give "--one" and "--two" AtLeastOneRequiredArgumentError
+  # will be raised.
+  #
+  # You can use class_at_least_one and class_exclusive at the same time.
+  #
+  #    class_exclusive do
+  #      class_at_least_one do
+  #        class_option :one
+  #        class_option :two
+  #      end
+  #    end
+  #
+  # Then it is required either only one of "--one" or "--two".
+  #
+  # source://thor//lib/thor/base.rb#392
+  def class_at_least_one(*args, &block); end
+
+  # Returns this class at least one of required options array set, looking up in the ancestors chain.
+  #
+  # ==== Returns
+  # Array[Array[Thor::Option.name]]
+  #
+  # source://thor//lib/thor/base.rb#411
+  def class_at_least_one_option_names; end
+
+  # Adds and declares option group for exclusive options in the
+  # block and arguments. You can declare options as the outside of the block.
+  #
+  # ==== Parameters
+  # Array[Thor::Option.name]
+  #
+  # ==== Examples
+  #
+  #   class_exclusive do
+  #     class_option :one
+  #     class_option :two
+  #    end
+  #
+  # Or
+  #
+  #   class_option :one
+  #   class_option :two
+  #   class_exclusive :one, :two
+  #
+  # If you give "--one" and "--two" at the same time ExclusiveArgumentsError
+  # will be raised.
+  #
+  # source://thor//lib/thor/base.rb#357
+  def class_exclusive(*args, &block); end
+
+  # Returns this class exclusive options array set, looking up in the ancestors chain.
+  #
+  # ==== Returns
+  # Array[Array[Thor::Option.name]]
+  #
+  # source://thor//lib/thor/base.rb#402
+  def class_exclusive_option_names; end
+
+  # Adds an option to the set of class options
+  #
+  # ==== Parameters
+  # name<Symbol>:: The name of the argument.
+  # options<Hash>:: Described below.
+  #
+  # ==== Options
+  # :desc::     -- Description for the argument.
+  # :required:: -- If the argument is required or not.
+  # :default::  -- Default value for this argument.
+  # :group::    -- The group for this options. Use by class options to output options in different levels.
+  # :aliases::  -- Aliases for this option. <b>Note:</b> Thor follows a convention of one-dash-one-letter options. Thus aliases like "-something" wouldn't be parsed; use either "\--something" or "-s" instead.
+  # :type::     -- The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+  # :banner::   -- String to show on usage notes.
+  # :hide::     -- If you want to hide this option from the help.
+  #
+  # source://thor//lib/thor/base.rb#328
+  def class_option(name, options = T.unsafe(nil)); end
+
+  # Adds a bunch of options to the set of class options.
+  #
+  #   class_options :foo => false, :bar => :required, :baz => :string
+  #
+  # If you prefer more detailed declaration, check class_option.
+  #
+  # ==== Parameters
+  # Hash[Symbol => Object]
+  #
+  # source://thor//lib/thor/base.rb#306
+  def class_options(options = T.unsafe(nil)); end
+
+  # Returns the commands for this Thor class.
+  #
+  # ==== Returns
+  # Hash:: An ordered hash with commands names as keys and Thor::Command
+  #        objects as values.
+  #
+  # source://thor//lib/thor/base.rb#471
+  def commands; end
+
+  # If true, option set will not suspend the execution of the command when
+  # a required option is not provided.
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/base.rb#207
+  def disable_required_check?(command_name); end
+
+  # A flag that makes the process exit with status 1 if any error happens.
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/base.rb#628
+  def exit_on_failure?; end
+
+  # Defines the group. This is used when thor list is invoked so you can specify
+  # that only commands from a pre-defined group will be shown. Defaults to standard.
+  #
+  # ==== Parameters
+  # name<String|Symbol>
+  #
+  # source://thor//lib/thor/base.rb#457
+  def group(name = T.unsafe(nil)); end
+
+  # @raise [InvocationError]
+  #
+  # source://thor//lib/thor/base.rb#618
+  def handle_argument_error(command, error, args, arity); end
+
+  # @raise [UndefinedCommandError]
+  #
+  # source://thor//lib/thor/base.rb#613
+  def handle_no_command_error(command, has_namespace = T.unsafe(nil)); end
+
+  # @raise [UndefinedCommandError]
+  #
+  # source://thor//lib/thor/base.rb#613
+  def handle_no_task_error(command, has_namespace = T.unsafe(nil)); end
+
+  # Sets the namespace for the Thor or Thor::Group class. By default the
+  # namespace is retrieved from the class name. If your Thor class is named
+  # Scripts::MyScript, the help method, for example, will be called as:
+  #
+  #   thor scripts:my_script -h
+  #
+  # If you change the namespace:
+  #
+  #   namespace :my_scripts
+  #
+  # You change how your commands are invoked:
+  #
+  #   thor my_scripts -h
+  #
+  # Finally, if you change your namespace to default:
+  #
+  #   namespace :default
+  #
+  # Your commands can be invoked with a shortcut. Instead of:
+  #
+  #   thor :my_command
+  #
+  # source://thor//lib/thor/base.rb#566
+  def namespace(name = T.unsafe(nil)); end
+
+  # All methods defined inside the given block are not added as commands.
+  #
+  # So you can do:
+  #
+  #   class MyScript < Thor
+  #     no_commands do
+  #       def this_is_not_a_command
+  #       end
+  #     end
+  #   end
+  #
+  # You can also add the method and remove it from the command list:
+  #
+  #   class MyScript < Thor
+  #     def this_is_not_a_command
+  #     end
+  #     remove_command :this_is_not_a_command
+  #   end
+  #
+  # source://thor//lib/thor/base.rb#530
+  def no_commands(&block); end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/base.rb#540
+  def no_commands?; end
+
+  # source://thor//lib/thor/base.rb#536
+  def no_commands_context; end
+
+  # All methods defined inside the given block are not added as commands.
+  #
+  # So you can do:
+  #
+  #   class MyScript < Thor
+  #     no_commands do
+  #       def this_is_not_a_command
+  #       end
+  #     end
+  #   end
+  #
+  # You can also add the method and remove it from the command list:
+  #
+  #   class MyScript < Thor
+  #     def this_is_not_a_command
+  #     end
+  #     remove_command :this_is_not_a_command
+  #   end
+  #
+  # source://thor//lib/thor/base.rb#530
+  def no_tasks(&block); end
+
+  # Allows to use private methods from parent in child classes as commands.
+  #
+  # ==== Parameters
+  #   names<Array>:: Method names to be used as commands
+  #
+  # ==== Examples
+  #
+  #   public_command :foo
+  #   public_command :foo, :bar, :baz
+  #
+  # source://thor//lib/thor/base.rb#606
+  def public_command(*names); end
+
+  # Allows to use private methods from parent in child classes as commands.
+  #
+  # ==== Parameters
+  #   names<Array>:: Method names to be used as commands
+  #
+  # ==== Examples
+  #
+  #   public_command :foo
+  #   public_command :foo, :bar, :baz
+  #
+  # source://thor//lib/thor/base.rb#606
+  def public_task(*names); end
+
+  # Removes a previous defined argument. If :undefine is given, undefine
+  # accessors as well.
+  #
+  # ==== Parameters
+  # names<Array>:: Arguments to be removed
+  #
+  # ==== Examples
+  #
+  #   remove_argument :foo
+  #   remove_argument :foo, :bar, :baz, :undefine => true
+  #
+  # source://thor//lib/thor/base.rb#426
+  def remove_argument(*names); end
+
+  # Removes a previous defined class option.
+  #
+  # ==== Parameters
+  # names<Array>:: Class options to be removed
+  #
+  # ==== Examples
+  #
+  #   remove_class_option :foo
+  #   remove_class_option :foo, :bar, :baz
+  #
+  # source://thor//lib/thor/base.rb#445
+  def remove_class_option(*names); end
+
+  # Removes a given command from this Thor class. This is usually done if you
+  # are inheriting from another class and don't want it to be available
+  # anymore.
+  #
+  # By default it only remove the mapping to the command. But you can supply
+  # :undefine => true to undefine the method from the class as well.
+  #
+  # ==== Parameters
+  # name<Symbol|String>:: The name of the command to be removed
+  # options<Hash>:: You can give :undefine => true if you want commands the method
+  #                 to be undefined from the class as well.
+  #
+  # source://thor//lib/thor/base.rb#500
+  def remove_command(*names); end
+
+  # Removes a given command from this Thor class. This is usually done if you
+  # are inheriting from another class and don't want it to be available
+  # anymore.
+  #
+  # By default it only remove the mapping to the command. But you can supply
+  # :undefine => true to undefine the method from the class as well.
+  #
+  # ==== Parameters
+  # name<Symbol|String>:: The name of the command to be removed
+  # options<Hash>:: You can give :undefine => true if you want commands the method
+  #                 to be undefined from the class as well.
+  #
+  # source://thor//lib/thor/base.rb#500
+  def remove_task(*names); end
+
+  # Parses the command and options from the given args, instantiate the class
+  # and invoke the command. This method is used when the arguments must be parsed
+  # from an array. If you are inside Ruby and want to use a Thor class, you
+  # can simply initialize it:
+  #
+  #   script = MyScript.new(args, options, config)
+  #   script.invoke(:command, first_arg, second_arg, third_arg)
+  #
+  # source://thor//lib/thor/base.rb#582
+  def start(given_args = T.unsafe(nil), config = T.unsafe(nil)); end
+
+  # If true, option parsing is suspended as soon as an unknown option or a
+  # regular argument is encountered.  All remaining arguments are passed to
+  # the command as regular arguments.
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/base.rb#201
+  def stop_on_unknown_option?(command_name); end
+
+  # source://thor//lib/thor/base.rb#218
+  def strict_args_position; end
+
+  # If you want only strict string args (useful when cascading thor classes),
+  # call strict_args_position! This is disabled by default to allow dynamic
+  # invocations.
+  #
+  # source://thor//lib/thor/base.rb#214
+  def strict_args_position!; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/base.rb#222
+  def strict_args_position?(config); end
+
+  # Returns the commands for this Thor class.
+  #
+  # ==== Returns
+  # Hash:: An ordered hash with commands names as keys and Thor::Command
+  #        objects as values.
+  #
+  # source://thor//lib/thor/base.rb#471
+  def tasks; end
+
+  protected
+
+  # SIGNATURE: Sets the baseclass. This is where the superclass lookup
+  # finishes.
+  #
+  # source://thor//lib/thor/base.rb#777
+  def baseclass; end
+
+  # The basename of the program invoking the thor class.
+  #
+  # source://thor//lib/thor/base.rb#771
+  def basename; end
+
+  # Build an option and adds it to the given scope.
+  #
+  # ==== Parameters
+  # name<Symbol>:: The name of the argument.
+  # options<Hash>:: Described in both class_option and method_option.
+  # scope<Hash>:: Options hash that is being built up
+  #
+  # source://thor//lib/thor/base.rb#688
+  def build_option(name, options, scope); end
+
+  # Receives a hash of options, parse them and add to the scope. This is a
+  # fast way to set a bunch of options:
+  #
+  #   build_options :foo => true, :bar => :required, :baz => :string
+  #
+  # ==== Parameters
+  # Hash[Symbol => Object]
+  #
+  # source://thor//lib/thor/base.rb#699
+  def build_options(options, scope); end
+
+  # Get target(method_options or class_options) options
+  # of before and after by block evaluation.
+  #
+  # source://thor//lib/thor/base.rb#808
+  def built_option_names(target, opt = T.unsafe(nil), &block); end
+
+  # Prints the class options per group. If an option does not belong to
+  # any group, it's printed as Class option.
+  #
+  # source://thor//lib/thor/base.rb#638
+  def class_options_help(shell, groups = T.unsafe(nil)); end
+
+  # Get command scope member by name.
+  #
+  # source://thor//lib/thor/base.rb#816
+  def command_scope_member(name, options = T.unsafe(nil)); end
+
+  # SIGNATURE: Creates a new command if valid_command? is true. This method is
+  # called when a new method is added to the class.
+  #
+  # source://thor//lib/thor/base.rb#782
+  def create_command(meth); end
+
+  # SIGNATURE: Creates a new command if valid_command? is true. This method is
+  # called when a new method is added to the class.
+  #
+  # source://thor//lib/thor/base.rb#782
+  def create_task(meth); end
+
+  # SIGNATURE: The hook invoked by start.
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://thor//lib/thor/base.rb#792
+  def dispatch(command, given_args, given_opts, config); end
+
+  # Finds a command with the given name. If the command belongs to the current
+  # class, just return it, otherwise dup it and add the fresh copy to the
+  # current command hash.
+  #
+  # source://thor//lib/thor/base.rb#708
+  def find_and_refresh_command(name); end
+
+  # Finds a command with the given name. If the command belongs to the current
+  # class, just return it, otherwise dup it and add the fresh copy to the
+  # current command hash.
+  #
+  # source://thor//lib/thor/base.rb#708
+  def find_and_refresh_task(name); end
+
+  # Retrieves a value from superclass. If it reaches the baseclass,
+  # returns default.
+  #
+  # source://thor//lib/thor/base.rb#749
+  def from_superclass(method, default = T.unsafe(nil)); end
+
+  # Every time someone inherits from a Thor class, register the klass
+  # and file into baseclass.
+  #
+  # source://thor//lib/thor/base.rb#721
+  def inherited(klass); end
+
+  # SIGNATURE: Defines behavior when the initialize method is added to the
+  # class.
+  #
+  # source://thor//lib/thor/base.rb#788
+  def initialize_added; end
+
+  # Raises an error if the word given is a Thor reserved word.
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/base.rb#677
+  def is_thor_reserved_word?(word, type); end
+
+  # Fire this callback whenever a method is added. Added methods are
+  # tracked as commands by invoking the create_command method.
+  #
+  # source://thor//lib/thor/base.rb#729
+  def method_added(meth); end
+
+  # Receives a set of options and print them.
+  #
+  # source://thor//lib/thor/base.rb#656
+  def print_options(shell, options, group_name = T.unsafe(nil)); end
+
+  # Register a relation of options for target(method_option/class_option)
+  # by args and block.
+  #
+  # source://thor//lib/thor/base.rb#798
+  def register_options_relation_for(target, relation, *args, &block); end
+end
+
+# source://thor//lib/thor/command.rb#2
+class Thor::Command < ::Struct
+  # @return [Command] a new instance of Command
+  #
+  # source://thor//lib/thor/command.rb#5
+  def initialize(name, description, long_description, wrap_long_description, usage, options = T.unsafe(nil), options_relation = T.unsafe(nil)); end
+
+  # Returns the formatted usage by injecting given required arguments
+  # and required options into the given usage.
+  #
+  # source://thor//lib/thor/command.rb#42
+  def formatted_usage(klass, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/command.rb#15
+  def hidden?; end
+
+  # source://thor//lib/thor/command.rb#70
+  def method_at_least_one_option_names; end
+
+  # source://thor//lib/thor/command.rb#66
+  def method_exclusive_option_names; end
+
+  # By default, a command invokes a method in the thor class. You can change this
+  # implementation to create custom commands.
+  #
+  # source://thor//lib/thor/command.rb#21
+  def run(instance, args = T.unsafe(nil)); end
+
+  protected
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/command.rb#114
+  def handle_argument_error?(instance, error, caller); end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/command.rb#121
+  def handle_no_method_error?(instance, error, caller); end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/command.rb#104
+  def local_method?(instance, name); end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/command.rb#87
+  def not_debugging?(instance); end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/command.rb#100
+  def private_method?(instance); end
+
+  # Given a target, checks if this class name is a public method.
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/command.rb#96
+  def public_method?(instance); end
+
+  # Add usage with required arguments
+  #
+  # source://thor//lib/thor/command.rb#77
+  def required_arguments_for(klass, usage); end
+
+  # source://thor//lib/thor/command.rb#91
+  def required_options; end
+
+  # source://thor//lib/thor/command.rb#109
+  def sans_backtrace(backtrace, caller); end
+
+  private
+
+  # source://thor//lib/thor/command.rb#9
+  def initialize_copy(other); end
+end
+
+# source://thor//lib/thor/command.rb#3
+Thor::Command::FILE_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#2
+module Thor::CoreExt; end
+
+# A hash with indifferent access and magic predicates.
+#
+#   hash = Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
+#
+#   hash[:foo]  #=> 'bar'
+#   hash['foo'] #=> 'bar'
+#   hash.foo?   #=> true
+#
+# source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#11
+class Thor::CoreExt::HashWithIndifferentAccess < ::Hash
+  # @return [HashWithIndifferentAccess] a new instance of HashWithIndifferentAccess
+  #
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#12
+  def initialize(hash = T.unsafe(nil)); end
+
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#19
+  def [](key); end
+
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#23
+  def []=(key, value); end
+
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#27
+  def delete(key); end
+
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#31
+  def except(*keys); end
+
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#37
+  def fetch(key, *args); end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#45
+  def key?(key); end
+
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#53
+  def merge(other); end
+
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#57
+  def merge!(other); end
+
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#72
+  def replace(other_hash); end
+
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#64
+  def reverse_merge(other); end
+
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#68
+  def reverse_merge!(other_hash); end
+
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#41
+  def slice(*keys); end
+
+  # Convert to a Hash with String keys.
+  #
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#77
+  def to_hash; end
+
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#49
+  def values_at(*indices); end
+
+  protected
+
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#83
+  def convert_key(key); end
+
+  # Magic predicates. For instance:
+  #
+  #   options.force?                  # => !!options['force']
+  #   options.shebang                 # => "/usr/lib/local/ruby"
+  #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
+  #
+  # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#93
+  def method_missing(method, *args); end
+end
+
+# source://thor//lib/thor/error.rb#3
+module Thor::Correctable
+  # source://thor//lib/thor/error.rb#8
+  def corrections; end
+
+  # source://thor//lib/thor/error.rb#4
+  def to_s; end
+end
+
+# A dynamic command that handles method missing scenarios.
+#
+# source://thor//lib/thor/command.rb#137
+class Thor::DynamicCommand < ::Thor::Command
+  # @return [DynamicCommand] a new instance of DynamicCommand
+  #
+  # source://thor//lib/thor/command.rb#138
+  def initialize(name, options = T.unsafe(nil)); end
+
+  # source://thor//lib/thor/command.rb#142
+  def run(instance, args = T.unsafe(nil)); end
+end
+
+# source://thor//lib/thor/command.rb#150
+Thor::DynamicTask = Thor::DynamicCommand
+
+# Thor::Error is raised when it's caused by wrong usage of thor classes. Those
+# errors have their backtrace suppressed and are nicely shown to the user.
+#
+# Errors that are caused by the developer, like declaring a method which
+# overwrites a thor keyword, SHOULD NOT raise a Thor::Error. This way, we
+# ensure that developer errors are shown with full backtrace.
+#
+# source://thor//lib/thor/error.rb#20
+class Thor::Error < ::StandardError; end
+
+# source://thor//lib/thor/error.rb#101
+class Thor::ExclusiveArgumentError < ::Thor::InvocationError; end
+
+# Thor has a special class called Thor::Group. The main difference to Thor class
+# is that it invokes all commands at once. It also include some methods that allows
+# invocations to be done at the class method, which are not available to Thor
+# commands.
+#
+# source://thor//lib/thor/group.rb#7
+class Thor::Group
+  include ::Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+  extend ::Thor::Base::ClassMethods
+  extend ::Thor::Invocation::ClassMethods
+
+  protected
+
+  # Shortcut to invoke with padding and block handling. Use internally by
+  # invoke and invoke_from_option class methods.
+  #
+  # source://thor//lib/thor/group.rb#276
+  def _invoke_for_class_method(klass, command = T.unsafe(nil), *args, &block); end
+
+  class << self
+    # Overwrite class options help to allow invoked generators options to be
+    # shown recursively when invoking a generator.
+    #
+    # source://thor//lib/thor/group.rb#161
+    def class_options_help(shell, groups = T.unsafe(nil)); end
+
+    # Checks if a specified command exists.
+    #
+    # ==== Parameters
+    # command_name<String>:: The name of the command to check for existence.
+    #
+    # ==== Returns
+    # Boolean:: +true+ if the command exists, +false+ otherwise.
+    #
+    # @return [Boolean]
+    #
+    # source://thor//lib/thor/group.rb#221
+    def command_exists?(command_name); end
+
+    # The description for this Thor::Group. If none is provided, but a source root
+    # exists, tries to find the USAGE one folder above it, otherwise searches
+    # in the superclass.
+    #
+    # ==== Parameters
+    # description<String>:: The description for this Thor::Group.
+    #
+    # source://thor//lib/thor/group.rb#16
+    def desc(description = T.unsafe(nil)); end
+
+    # Get invocations array and merge options from invocations. Those
+    # options are added to group_options hash. Options that already exists
+    # in base_options are not added twice.
+    #
+    # source://thor//lib/thor/group.rb#172
+    def get_options_from_invocations(group_options, base_options); end
+
+    # @raise [error]
+    #
+    # source://thor//lib/thor/group.rb#207
+    def handle_argument_error(command, error, _args, arity); end
+
+    # Prints help information.
+    #
+    # ==== Options
+    # short:: When true, shows only usage.
+    #
+    # source://thor//lib/thor/group.rb#29
+    def help(shell); end
+
+    # Stores invocation blocks used on invoke_from_option.
+    #
+    # source://thor//lib/thor/group.rb#45
+    def invocation_blocks; end
+
+    # Stores invocations for this class merging with superclass values.
+    #
+    # source://thor//lib/thor/group.rb#39
+    def invocations; end
+
+    # Invoke the given namespace or class given. It adds an instance
+    # method that will invoke the klass and command. You can give a block to
+    # configure how it will be invoked.
+    #
+    # The namespace/class given will have its options showed on the help
+    # usage. Check invoke_from_option for more information.
+    #
+    # source://thor//lib/thor/group.rb#56
+    def invoke(*names, &block); end
+
+    # Invoke a thor class based on the value supplied by the user to the
+    # given option named "name". A class option must be created before this
+    # method is invoked for each name given.
+    #
+    # ==== Examples
+    #
+    #   class GemGenerator < Thor::Group
+    #     class_option :test_framework, :type => :string
+    #     invoke_from_option :test_framework
+    #   end
+    #
+    # ==== Boolean options
+    #
+    # In some cases, you want to invoke a thor class if some option is true or
+    # false. This is automatically handled by invoke_from_option. Then the
+    # option name is used to invoke the generator.
+    #
+    # ==== Preparing for invocation
+    #
+    # In some cases you want to customize how a specified hook is going to be
+    # invoked. You can do that by overwriting the class method
+    # prepare_for_invocation. The class method must necessarily return a klass
+    # and an optional command.
+    #
+    # ==== Custom invocations
+    #
+    # You can also supply a block to customize how the option is going to be
+    # invoked. The block receives two parameters, an instance of the current
+    # class and the klass to be invoked.
+    #
+    # source://thor//lib/thor/group.rb#110
+    def invoke_from_option(*names, &block); end
+
+    # Returns commands ready to be printed.
+    #
+    # source://thor//lib/thor/group.rb#199
+    def printable_commands(*_arg0); end
+
+    # Returns commands ready to be printed.
+    #
+    # source://thor//lib/thor/group.rb#199
+    def printable_tasks(*_arg0); end
+
+    # Remove a previously added invocation.
+    #
+    # ==== Examples
+    #
+    #   remove_invocation :test_framework
+    #
+    # source://thor//lib/thor/group.rb#149
+    def remove_invocation(*names); end
+
+    protected
+
+    # The banner for this class. You can customize it if you are invoking the
+    # thor class by another ways which is not the Thor::Runner.
+    #
+    # source://thor//lib/thor/group.rb#249
+    def banner; end
+
+    # source://thor//lib/thor/group.rb#259
+    def baseclass; end
+
+    # source://thor//lib/thor/group.rb#263
+    def create_command(meth); end
+
+    # source://thor//lib/thor/group.rb#263
+    def create_task(meth); end
+
+    # The method responsible for dispatching given the args.
+    #
+    # @yield [instance]
+    #
+    # source://thor//lib/thor/group.rb#228
+    def dispatch(command, given_args, given_opts, config); end
+
+    # Represents the whole class as a command.
+    #
+    # source://thor//lib/thor/group.rb#254
+    def self_command; end
+
+    # Represents the whole class as a command.
+    #
+    # source://thor//lib/thor/group.rb#254
+    def self_task; end
+  end
+end
+
+# Shortcuts for help.
+#
+# source://thor//lib/thor/base.rb#17
+Thor::HELP_MAPPINGS = T.let(T.unsafe(nil), Array)
+
+# A command that is hidden in help messages but still invocable.
+#
+# source://thor//lib/thor/command.rb#129
+class Thor::HiddenCommand < ::Thor::Command
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/command.rb#130
+  def hidden?; end
+end
+
+# source://thor//lib/thor/command.rb#134
+Thor::HiddenTask = Thor::HiddenCommand
+
+# source://thor//lib/thor/invocation.rb#2
+module Thor::Invocation
+  mixes_in_class_methods ::Thor::Invocation::ClassMethods
+
+  # Make initializer aware of invocations and the initialization args.
+  #
+  # source://thor//lib/thor/invocation.rb#23
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil), &block); end
+
+  # Make the current command chain accessible with in a Thor-(sub)command
+  #
+  # source://thor//lib/thor/invocation.rb#30
+  def current_command_chain; end
+
+  # Receives a name and invokes it. The name can be a string (either "command" or
+  # "namespace:command"), a Thor::Command, a Class or a Thor instance. If the
+  # command cannot be guessed by name, it can also be supplied as second argument.
+  #
+  # You can also supply the arguments, options and configuration values for
+  # the command to be invoked, if none is given, the same values used to
+  # initialize the invoker are used to initialize the invoked.
+  #
+  # When no name is given, it will invoke the default command of the current class.
+  #
+  # ==== Examples
+  #
+  #   class A < Thor
+  #     def foo
+  #       invoke :bar
+  #       invoke "b:hello", ["Erik"]
+  #     end
+  #
+  #     def bar
+  #       invoke "b:hello", ["Erik"]
+  #     end
+  #   end
+  #
+  #   class B < Thor
+  #     def hello(name)
+  #       puts "hello #{name}"
+  #     end
+  #   end
+  #
+  # You can notice that the method "foo" above invokes two commands: "bar",
+  # which belongs to the same class and "hello" which belongs to the class B.
+  #
+  # By using an invocation system you ensure that a command is invoked only once.
+  # In the example above, invoking "foo" will invoke "b:hello" just once, even
+  # if it's invoked later by "bar" method.
+  #
+  # When class A invokes class B, all arguments used on A initialization are
+  # supplied to B. This allows lazy parse of options. Let's suppose you have
+  # some rspec commands:
+  #
+  #   class Rspec < Thor::Group
+  #     class_option :mock_framework, :type => :string, :default => :rr
+  #
+  #     def invoke_mock_framework
+  #       invoke "rspec:#{options[:mock_framework]}"
+  #     end
+  #   end
+  #
+  # As you noticed, it invokes the given mock framework, which might have its
+  # own options:
+  #
+  #   class Rspec::RR < Thor::Group
+  #     class_option :style, :type => :string, :default => :mock
+  #   end
+  #
+  # Since it's not rspec concern to parse mock framework options, when RR
+  # is invoked all options are parsed again, so RR can extract only the options
+  # that it's going to use.
+  #
+  # If you want Rspec::RR to be initialized with its own set of options, you
+  # have to do that explicitly:
+  #
+  #   invoke "rspec:rr", [], :style => :foo
+  #
+  # Besides giving an instance, you can also give a class to invoke:
+  #
+  #   invoke Rspec::RR, [], :style => :foo
+  #
+  # source://thor//lib/thor/invocation.rb#102
+  def invoke(name = T.unsafe(nil), *args); end
+
+  # Invoke all commands for the current instance.
+  #
+  # source://thor//lib/thor/invocation.rb#133
+  def invoke_all; end
+
+  # Invoke the given command if the given args.
+  #
+  # source://thor//lib/thor/invocation.rb#122
+  def invoke_command(command, *args); end
+
+  # Invoke the given command if the given args.
+  #
+  # source://thor//lib/thor/invocation.rb#122
+  def invoke_task(command, *args); end
+
+  # Invokes using shell padding.
+  #
+  # source://thor//lib/thor/invocation.rb#138
+  def invoke_with_padding(*args); end
+
+  protected
+
+  # Initialize klass using values stored in the @_initializer.
+  #
+  # source://thor//lib/thor/invocation.rb#166
+  def _parse_initialization_options(args, opts, config); end
+
+  # This method simply retrieves the class and command to be invoked.
+  # If the name is nil or the given name is a command in the current class,
+  # use the given name and return self as class. Otherwise, call
+  # prepare_for_invocation in the current class.
+  #
+  # source://thor//lib/thor/invocation.rb#153
+  def _retrieve_class_and_command(name, sent_command = T.unsafe(nil)); end
+
+  # This method simply retrieves the class and command to be invoked.
+  # If the name is nil or the given name is a command in the current class,
+  # use the given name and return self as class. Otherwise, call
+  # prepare_for_invocation in the current class.
+  #
+  # source://thor//lib/thor/invocation.rb#153
+  def _retrieve_class_and_task(name, sent_command = T.unsafe(nil)); end
+
+  # Configuration values that are shared between invocations.
+  #
+  # source://thor//lib/thor/invocation.rb#145
+  def _shared_configuration; end
+
+  class << self
+    # source://thor//lib/thor/invocation.rb#3
+    def included(base); end
+  end
+end
+
+# source://thor//lib/thor/invocation.rb#8
+module Thor::Invocation::ClassMethods
+  # This method is responsible for receiving a name and find the proper
+  # class and command for it. The key is an optional parameter which is
+  # available only in class methods invocations (i.e. in Thor::Group).
+  #
+  # source://thor//lib/thor/invocation.rb#12
+  def prepare_for_invocation(key, name); end
+end
+
+# Raised when a command was found, but not invoked properly.
+#
+# source://thor//lib/thor/error.rb#62
+class Thor::InvocationError < ::Thor::Error; end
+
+# source://thor//lib/thor/line_editor/basic.rb#2
+module Thor::LineEditor
+  class << self
+    # source://thor//lib/thor/line_editor.rb#10
+    def best_available; end
+
+    # source://thor//lib/thor/line_editor.rb#6
+    def readline(prompt, options = T.unsafe(nil)); end
+  end
+end
+
+# source://thor//lib/thor/line_editor/basic.rb#3
+class Thor::LineEditor::Basic
+  # @return [Basic] a new instance of Basic
+  #
+  # source://thor//lib/thor/line_editor/basic.rb#10
+  def initialize(prompt, options); end
+
+  # Returns the value of attribute options.
+  #
+  # source://thor//lib/thor/line_editor/basic.rb#4
+  def options; end
+
+  # Returns the value of attribute prompt.
+  #
+  # source://thor//lib/thor/line_editor/basic.rb#4
+  def prompt; end
+
+  # source://thor//lib/thor/line_editor/basic.rb#15
+  def readline; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/line_editor/basic.rb#32
+  def echo?; end
+
+  # source://thor//lib/thor/line_editor/basic.rb#22
+  def get_input; end
+
+  class << self
+    # @return [Boolean]
+    #
+    # source://thor//lib/thor/line_editor/basic.rb#6
+    def available?; end
+  end
+end
+
+# source://thor//lib/thor/line_editor/readline.rb#3
+class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic
+  # source://thor//lib/thor/line_editor/readline.rb#13
+  def readline; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/line_editor/readline.rb#28
+  def add_to_history?; end
+
+  # source://thor//lib/thor/line_editor/readline.rb#42
+  def completion_options; end
+
+  # source://thor//lib/thor/line_editor/readline.rb#32
+  def completion_proc; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/line_editor/readline.rb#46
+  def use_path_completion?; end
+
+  class << self
+    # @return [Boolean]
+    #
+    # source://thor//lib/thor/line_editor/readline.rb#4
+    def available?; end
+  end
+end
+
+# source://thor//lib/thor/line_editor/readline.rb#50
+class Thor::LineEditor::Readline::PathCompletion
+  # @return [PathCompletion] a new instance of PathCompletion
+  #
+  # source://thor//lib/thor/line_editor/readline.rb#54
+  def initialize(text); end
+
+  # source://thor//lib/thor/line_editor/readline.rb#58
+  def matches; end
+
+  private
+
+  # source://thor//lib/thor/line_editor/readline.rb#68
+  def absolute_matches; end
+
+  # source://thor//lib/thor/line_editor/readline.rb#82
+  def base_path; end
+
+  # source://thor//lib/thor/line_editor/readline.rb#78
+  def glob_pattern; end
+
+  # source://thor//lib/thor/line_editor/readline.rb#64
+  def relative_matches; end
+
+  # Returns the value of attribute text.
+  #
+  # source://thor//lib/thor/line_editor/readline.rb#51
+  def text; end
+end
+
+# source://thor//lib/thor/error.rb#98
+class Thor::MalformattedArgumentError < ::Thor::InvocationError; end
+
+# source://thor//lib/thor/nested_context.rb#2
+class Thor::NestedContext
+  # @return [NestedContext] a new instance of NestedContext
+  #
+  # source://thor//lib/thor/nested_context.rb#3
+  def initialize; end
+
+  # source://thor//lib/thor/nested_context.rb#7
+  def enter; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/nested_context.rb#15
+  def entered?; end
+
+  private
+
+  # source://thor//lib/thor/nested_context.rb#25
+  def pop; end
+
+  # source://thor//lib/thor/nested_context.rb#21
+  def push; end
+end
+
+# source://thor//lib/thor/parser/option.rb#2
+class Thor::Option < ::Thor::Argument
+  # @return [Option] a new instance of Option
+  #
+  # source://thor//lib/thor/parser/option.rb#7
+  def initialize(name, options = T.unsafe(nil)); end
+
+  # Returns the value of attribute aliases.
+  #
+  # source://thor//lib/thor/parser/option.rb#3
+  def aliases; end
+
+  # source://thor//lib/thor/parser/option.rb#99
+  def aliases_for_usage; end
+
+  # source://thor//lib/thor/parser/option.rb#118
+  def array?; end
+
+  # source://thor//lib/thor/parser/option.rb#118
+  def boolean?; end
+
+  # Returns the value of attribute group.
+  #
+  # source://thor//lib/thor/parser/option.rb#3
+  def group; end
+
+  # source://thor//lib/thor/parser/option.rb#118
+  def hash?; end
+
+  # Returns the value of attribute hide.
+  #
+  # source://thor//lib/thor/parser/option.rb#3
+  def hide; end
+
+  # source://thor//lib/thor/parser/option.rb#79
+  def human_name; end
+
+  # Returns the value of attribute lazy_default.
+  #
+  # source://thor//lib/thor/parser/option.rb#3
+  def lazy_default; end
+
+  # source://thor//lib/thor/parser/option.rb#118
+  def numeric?; end
+
+  # Returns the value of attribute repeatable.
+  #
+  # source://thor//lib/thor/parser/option.rb#3
+  def repeatable; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/parser/option.rb#107
+  def show_default?; end
+
+  # source://thor//lib/thor/parser/option.rb#118
+  def string?; end
+
+  # source://thor//lib/thor/parser/option.rb#75
+  def switch_name; end
+
+  # source://thor//lib/thor/parser/option.rb#83
+  def usage(padding = T.unsafe(nil)); end
+
+  protected
+
+  # source://thor//lib/thor/parser/option.rb#168
+  def dasherize(str); end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/parser/option.rb#160
+  def dasherized?; end
+
+  # source://thor//lib/thor/parser/option.rb#164
+  def undasherize(str); end
+
+  # @raise [ArgumentError]
+  #
+  # source://thor//lib/thor/parser/option.rb#126
+  def validate!; end
+
+  # source://thor//lib/thor/parser/option.rb#131
+  def validate_default_type!; end
+
+  private
+
+  # source://thor//lib/thor/parser/option.rb#174
+  def normalize_aliases(aliases); end
+
+  class << self
+    # This parse quick options given as method_options. It makes several
+    # assumptions, but you can be more specific using the option method.
+    #
+    #   parse :foo => "bar"
+    #   #=> Option foo with default value bar
+    #
+    #   parse [:foo, :baz] => "bar"
+    #   #=> Option foo with default value bar and alias :baz
+    #
+    #   parse :foo => :required
+    #   #=> Required option foo without default value
+    #
+    #   parse :foo => 2
+    #   #=> Option foo with default value 2 and type numeric
+    #
+    #   parse :foo => :numeric
+    #   #=> Option foo without default value and type numeric
+    #
+    #   parse :foo => true
+    #   #=> Option foo with default value true and type boolean
+    #
+    # The valid types are :boolean, :numeric, :hash, :array and :string. If none
+    # is given a default type is assumed. This default type accepts arguments as
+    # string (--foo=value) or booleans (just --foo).
+    #
+    # By default all options are optional, unless :required is given.
+    #
+    # source://thor//lib/thor/parser/option.rb#45
+    def parse(key, value); end
+  end
+end
+
+# source://thor//lib/thor/parser/option.rb#5
+Thor::Option::VALID_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://thor//lib/thor/parser/options.rb#2
+class Thor::Options < ::Thor::Arguments
+  # Takes a hash of Thor::Option and a hash with defaults.
+  #
+  # If +stop_on_unknown+ is true, #parse will stop as soon as it encounters
+  # an unknown option or a regular argument.
+  #
+  # @return [Options] a new instance of Options
+  #
+  # source://thor//lib/thor/parser/options.rb#32
+  def initialize(hash_options = T.unsafe(nil), defaults = T.unsafe(nil), stop_on_unknown = T.unsafe(nil), disable_required_check = T.unsafe(nil), relations = T.unsafe(nil)); end
+
+  # source://thor//lib/thor/parser/options.rb#156
+  def check_at_least_one!; end
+
+  # source://thor//lib/thor/parser/options.rb#144
+  def check_exclusive!; end
+
+  # @raise [UnknownArgumentError]
+  #
+  # source://thor//lib/thor/parser/options.rb#168
+  def check_unknown!; end
+
+  # source://thor//lib/thor/parser/options.rb#89
+  def parse(args); end
+
+  # source://thor//lib/thor/parser/options.rb#65
+  def peek; end
+
+  # source://thor//lib/thor/parser/options.rb#61
+  def remaining; end
+
+  # source://thor//lib/thor/parser/options.rb#79
+  def shift; end
+
+  # source://thor//lib/thor/parser/options.rb#84
+  def unshift(arg, is_value: T.unsafe(nil)); end
+
+  protected
+
+  # source://thor//lib/thor/parser/options.rb#189
+  def assign_result!(option, result); end
+
+  # Check if the current value in peek is a registered switch.
+  #
+  # Two booleans are returned.  The first is true if the current value
+  # starts with a hyphen; the second is true if it is a registered switch.
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/parser/options.rb#203
+  def current_is_switch?; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/parser/options.rb#215
+  def current_is_switch_formatted?; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/parser/options.rb#225
+  def current_is_value?; end
+
+  # Option names changes to swith name or human name
+  #
+  # source://thor//lib/thor/parser/options.rb#179
+  def names_to_switch_names(names = T.unsafe(nil)); end
+
+  # Check if the given argument is actually a shortcut.
+  #
+  # source://thor//lib/thor/parser/options.rb#244
+  def normalize_switch(arg); end
+
+  # Parse boolean values which can be given as --foo=true or --foo for true values, or
+  # --foo=false, --no-foo or --skip-foo for false values.
+  #
+  # source://thor//lib/thor/parser/options.rb#256
+  def parse_boolean(switch); end
+
+  # Parse the value at the peek analyzing if it requires an input or not.
+  #
+  # source://thor//lib/thor/parser/options.rb#274
+  def parse_peek(switch, option); end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/parser/options.rb#248
+  def parsing_options?; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/parser/options.rb#230
+  def switch?(arg); end
+
+  # source://thor//lib/thor/parser/options.rb#234
+  def switch_option(arg); end
+
+  class << self
+    # Receives a hash and makes it switches.
+    #
+    # source://thor//lib/thor/parser/options.rb#11
+    def to_switches(options); end
+  end
+end
+
+# source://thor//lib/thor/parser/options.rb#5
+Thor::Options::EQ_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://thor//lib/thor/parser/options.rb#3
+Thor::Options::LONG_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://thor//lib/thor/parser/options.rb#8
+Thor::Options::OPTS_END = T.let(T.unsafe(nil), String)
+
+# source://thor//lib/thor/parser/options.rb#7
+Thor::Options::SHORT_NUM = T.let(T.unsafe(nil), Regexp)
+
+# source://thor//lib/thor/parser/options.rb#4
+Thor::Options::SHORT_RE = T.let(T.unsafe(nil), Regexp)
+
+# Allow either -x -v or -xv style for single char args
+#
+# source://thor//lib/thor/parser/options.rb#6
+Thor::Options::SHORT_SQ_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://thor//lib/thor/error.rb#95
+class Thor::RequiredArgumentMissingError < ::Thor::InvocationError; end
+
+# source://thor//lib/thor/util.rb#4
+module Thor::Sandbox; end
+
+# source://thor//lib/thor/shell.rb#23
+module Thor::Shell
+  # Add shell to initialize config values.
+  #
+  # ==== Configuration
+  # shell<Object>:: An instance of the shell to be used.
+  #
+  # ==== Examples
+  #
+  #   class MyScript < Thor
+  #     argument :first, :type => :numeric
+  #   end
+  #
+  #   MyScript.new [1.0], { :foo => :bar }, :shell => Thor::Shell::Basic.new
+  #
+  # source://thor//lib/thor/shell.rb#44
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
+
+  # source://thor//lib/thor/shell.rb#59
+  def ask(*args, &block); end
+
+  # source://thor//lib/thor/shell.rb#59
+  def error(*args, &block); end
+
+  # source://thor//lib/thor/shell.rb#59
+  def file_collision(*args, &block); end
+
+  # source://thor//lib/thor/shell.rb#59
+  def no?(*args, &block); end
+
+  # source://thor//lib/thor/shell.rb#59
+  def print_in_columns(*args, &block); end
+
+  # source://thor//lib/thor/shell.rb#59
+  def print_table(*args, &block); end
+
+  # source://thor//lib/thor/shell.rb#59
+  def print_wrapped(*args, &block); end
+
+  # source://thor//lib/thor/shell.rb#59
+  def say(*args, &block); end
+
+  # source://thor//lib/thor/shell.rb#59
+  def say_error(*args, &block); end
+
+  # source://thor//lib/thor/shell.rb#59
+  def say_status(*args, &block); end
+
+  # source://thor//lib/thor/shell.rb#59
+  def set_color(*args, &block); end
+
+  # Holds the shell for the given Thor instance. If no shell is given,
+  # it gets a default shell from Thor::Base.shell.
+  #
+  # source://thor//lib/thor/shell.rb#52
+  def shell; end
+
+  # Sets the attribute shell
+  #
+  # @param value the value to set the attribute shell to.
+  #
+  # source://thor//lib/thor/shell.rb#25
+  def shell=(_arg0); end
+
+  # source://thor//lib/thor/shell.rb#59
+  def terminal_width(*args, &block); end
+
+  # Yields the given block with padding.
+  #
+  # source://thor//lib/thor/shell.rb#66
+  def with_padding; end
+
+  # source://thor//lib/thor/shell.rb#59
+  def yes?(*args, &block); end
+
+  protected
+
+  # Allow shell to be shared between invocations.
+  #
+  # source://thor//lib/thor/shell.rb#77
+  def _shared_configuration; end
+end
+
+# source://thor//lib/thor/shell/basic.rb#7
+class Thor::Shell::Basic
+  # Initialize base, mute and padding to nil.
+  #
+  # @return [Basic] a new instance of Basic
+  #
+  # source://thor//lib/thor/shell/basic.rb#13
+  def initialize; end
+
+  # Asks something to the user and receives a response.
+  #
+  # If a default value is specified it will be presented to the user
+  # and allows them to select that value with an empty response. This
+  # option is ignored when limited answers are supplied.
+  #
+  # If asked to limit the correct responses, you can pass in an
+  # array of acceptable answers.  If one of those is not supplied,
+  # they will be shown a message stating that one of those answers
+  # must be given and re-asked the question.
+  #
+  # If asking for sensitive information, the :echo option can be set
+  # to false to mask user input from $stdin.
+  #
+  # If the required input is a path, then set the path option to
+  # true. This will enable tab completion for file paths relative
+  # to the current working directory on systems that support
+  # Readline.
+  #
+  # ==== Example
+  #   ask("What is your name?")
+  #
+  #   ask("What is the planet furthest from the sun?", :default => "Neptune")
+  #
+  #   ask("What is your favorite Neopolitan flavor?", :limited_to => ["strawberry", "chocolate", "vanilla"])
+  #
+  #   ask("What is your password?", :echo => false)
+  #
+  #   ask("Where should the file be saved?", :path => true)
+  #
+  # source://thor//lib/thor/shell/basic.rb#80
+  def ask(statement, *args); end
+
+  # Returns the value of attribute base.
+  #
+  # source://thor//lib/thor/shell/basic.rb#8
+  def base; end
+
+  # Sets the attribute base
+  #
+  # @param value the value to set the attribute base to.
+  #
+  # source://thor//lib/thor/shell/basic.rb#8
+  def base=(_arg0); end
+
+  # Called if something goes wrong during the execution. This is used by Thor
+  # internally and should not be used inside your scripts. If something went
+  # wrong, you can always raise an exception. If you raise a Thor::Error, it
+  # will be rescued and wrapped in the method below.
+  #
+  # source://thor//lib/thor/shell/basic.rb#251
+  def error(statement); end
+
+  # Deals with file collision and returns true if the file should be
+  # overwritten and false otherwise. If a block is given, it uses the block
+  # response as the content for the diff.
+  #
+  # ==== Parameters
+  # destination<String>:: the destination file to solve conflicts
+  # block<Proc>:: an optional block that returns the value to be used in diff and merge
+  #
+  # source://thor//lib/thor/shell/basic.rb#207
+  def file_collision(destination); end
+
+  # Sets the output padding while executing a block and resets it.
+  #
+  # source://thor//lib/thor/shell/basic.rb#43
+  def indent(count = T.unsafe(nil)); end
+
+  # Mute everything that's inside given block
+  #
+  # source://thor//lib/thor/shell/basic.rb#22
+  def mute; end
+
+  # Check if base is muted
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/shell/basic.rb#31
+  def mute?; end
+
+  # Asks the user a question and returns true if the user replies "n" or
+  # "no".
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/shell/basic.rb#156
+  def no?(statement, color = T.unsafe(nil)); end
+
+  # Returns the value of attribute padding.
+  #
+  # source://thor//lib/thor/shell/basic.rb#9
+  def padding; end
+
+  # Sets the output padding, not allowing less than zero values.
+  #
+  # source://thor//lib/thor/shell/basic.rb#37
+  def padding=(value); end
+
+  # Prints values in columns
+  #
+  # ==== Parameters
+  # Array[String, String, ...]
+  #
+  # source://thor//lib/thor/shell/basic.rb#165
+  def print_in_columns(array); end
+
+  # Prints a table.
+  #
+  # ==== Parameters
+  # Array[Array[String, String, ...]]
+  #
+  # ==== Options
+  # indent<Integer>:: Indent the first column by indent value.
+  # colwidth<Integer>:: Force the first column to colwidth spaces wide.
+  # borders<Boolean>:: Adds ascii borders.
+  #
+  # source://thor//lib/thor/shell/basic.rb#180
+  def print_table(array, options = T.unsafe(nil)); end
+
+  # Prints a long string, word-wrapping the text to the current width of the
+  # terminal display. Ideal for printing heredocs.
+  #
+  # ==== Parameters
+  # String
+  #
+  # ==== Options
+  # indent<Integer>:: Indent each line of the printed paragraph by indent value.
+  #
+  # source://thor//lib/thor/shell/basic.rb#194
+  def print_wrapped(message, options = T.unsafe(nil)); end
+
+  # Say (print) something to the user. If the sentence ends with a whitespace
+  # or tab character, a new line is not appended (print + flush). Otherwise
+  # are passed straight to puts (behavior got from Highline).
+  #
+  # ==== Example
+  #   say("I know you knew that.")
+  #
+  # source://thor//lib/thor/shell/basic.rb#98
+  def say(message = T.unsafe(nil), color = T.unsafe(nil), force_new_line = T.unsafe(nil)); end
+
+  # Say (print) an error to the user. If the sentence ends with a whitespace
+  # or tab character, a new line is not appended (print + flush). Otherwise
+  # are passed straight to puts (behavior got from Highline).
+  #
+  # ==== Example
+  #   say_error("error: something went wrong")
+  #
+  # source://thor//lib/thor/shell/basic.rb#115
+  def say_error(message = T.unsafe(nil), color = T.unsafe(nil), force_new_line = T.unsafe(nil)); end
+
+  # Say a status with the given color and appends the message. Since this
+  # method is used frequently by actions, it allows nil or false to be given
+  # in log_status, avoiding the message from being shown. If a Symbol is
+  # given in log_status, it's used as the color.
+  #
+  # source://thor//lib/thor/shell/basic.rb#130
+  def say_status(status, message, log_status = T.unsafe(nil)); end
+
+  # Apply color to the given string with optional bold. Disabled in the
+  # Thor::Shell::Basic class.
+  #
+  # source://thor//lib/thor/shell/basic.rb#258
+  def set_color(string, *_arg1); end
+
+  # Asks the user a question and returns true if the user replies "y" or
+  # "yes".
+  #
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/shell/basic.rb#149
+  def yes?(statement, color = T.unsafe(nil)); end
+
+  protected
+
+  # source://thor//lib/thor/shell/basic.rb#362
+  def answer_match(possibilities, answer, case_insensitive); end
+
+  # source://thor//lib/thor/shell/basic.rb#349
+  def ask_filtered(statement, color, options); end
+
+  # source://thor//lib/thor/shell/basic.rb#332
+  def ask_simply(statement, color, options); end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/shell/basic.rb#269
+  def can_display_colors?; end
+
+  # source://thor//lib/thor/shell/basic.rb#296
+  def file_collision_help(block_given); end
+
+  # source://thor//lib/thor/shell/basic.rb#383
+  def git_merge_tool; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/shell/basic.rb#286
+  def is?(value); end
+
+  # source://thor//lib/thor/shell/basic.rb#273
+  def lookup_color(color); end
+
+  # source://thor//lib/thor/shell/basic.rb#370
+  def merge(destination, content); end
+
+  # source://thor//lib/thor/shell/basic.rb#379
+  def merge_tool; end
+
+  # source://thor//lib/thor/shell/basic.rb#264
+  def prepare_message(message, *color); end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/shell/basic.rb#324
+  def quiet?; end
+
+  # source://thor//lib/thor/shell/basic.rb#313
+  def show_diff(destination, content); end
+
+  # source://thor//lib/thor/shell/basic.rb#282
+  def stderr; end
+
+  # source://thor//lib/thor/shell/basic.rb#278
+  def stdout; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/shell/basic.rb#328
+  def unix?; end
+end
+
+# Inherit from Thor::Shell::Basic and add set_color behavior. Check
+# Thor::Shell::Basic to see all available methods.
+#
+# source://thor//lib/thor/shell/color.rb#9
+class Thor::Shell::Color < ::Thor::Shell::Basic
+  include ::LCSDiff
+
+  # Set color by using a string or one of the defined constants. If a third
+  # option is set to true, it also adds bold to the string. This is based
+  # on Highline implementation and it automatically appends CLEAR to the end
+  # of the returned String.
+  #
+  # Pass foreground, background and bold options to this method as
+  # symbols.
+  #
+  # Example:
+  #
+  #   set_color "Hi!", :red, :on_white, :bold
+  #
+  # The available colors are:
+  #
+  #   :bold
+  #   :black
+  #   :red
+  #   :green
+  #   :yellow
+  #   :blue
+  #   :magenta
+  #   :cyan
+  #   :white
+  #   :on_black
+  #   :on_red
+  #   :on_green
+  #   :on_yellow
+  #   :on_blue
+  #   :on_magenta
+  #   :on_cyan
+  #   :on_white
+  #
+  # source://thor//lib/thor/shell/color.rb#82
+  def set_color(string, *colors); end
+
+  protected
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/shell/color.rb#110
+  def are_colors_disabled?; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/shell/color.rb#106
+  def are_colors_supported?; end
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/shell/color.rb#102
+  def can_display_colors?; end
+end
+
+# Set the terminal's foreground ANSI color to black.
+#
+# source://thor//lib/thor/shell/color.rb#18
+Thor::Shell::Color::BLACK = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground ANSI color to blue.
+#
+# source://thor//lib/thor/shell/color.rb#26
+Thor::Shell::Color::BLUE = T.let(T.unsafe(nil), String)
+
+# The start of an ANSI bold sequence.
+#
+# source://thor//lib/thor/shell/color.rb#15
+Thor::Shell::Color::BOLD = T.let(T.unsafe(nil), String)
+
+# Embed in a String to clear all previous ANSI sequences.
+#
+# source://thor//lib/thor/shell/color.rb#13
+Thor::Shell::Color::CLEAR = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground ANSI color to cyan.
+#
+# source://thor//lib/thor/shell/color.rb#30
+Thor::Shell::Color::CYAN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground ANSI color to green.
+#
+# source://thor//lib/thor/shell/color.rb#22
+Thor::Shell::Color::GREEN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground ANSI color to magenta.
+#
+# source://thor//lib/thor/shell/color.rb#28
+Thor::Shell::Color::MAGENTA = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to black.
+#
+# source://thor//lib/thor/shell/color.rb#35
+Thor::Shell::Color::ON_BLACK = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to blue.
+#
+# source://thor//lib/thor/shell/color.rb#43
+Thor::Shell::Color::ON_BLUE = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to cyan.
+#
+# source://thor//lib/thor/shell/color.rb#47
+Thor::Shell::Color::ON_CYAN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to green.
+#
+# source://thor//lib/thor/shell/color.rb#39
+Thor::Shell::Color::ON_GREEN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to magenta.
+#
+# source://thor//lib/thor/shell/color.rb#45
+Thor::Shell::Color::ON_MAGENTA = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to red.
+#
+# source://thor//lib/thor/shell/color.rb#37
+Thor::Shell::Color::ON_RED = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to white.
+#
+# source://thor//lib/thor/shell/color.rb#49
+Thor::Shell::Color::ON_WHITE = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background ANSI color to yellow.
+#
+# source://thor//lib/thor/shell/color.rb#41
+Thor::Shell::Color::ON_YELLOW = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground ANSI color to red.
+#
+# source://thor//lib/thor/shell/color.rb#20
+Thor::Shell::Color::RED = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground ANSI color to white.
+#
+# source://thor//lib/thor/shell/color.rb#32
+Thor::Shell::Color::WHITE = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground ANSI color to yellow.
+#
+# source://thor//lib/thor/shell/color.rb#24
+Thor::Shell::Color::YELLOW = T.let(T.unsafe(nil), String)
+
+# source://thor//lib/thor/shell/column_printer.rb#5
+class Thor::Shell::ColumnPrinter
+  # @return [ColumnPrinter] a new instance of ColumnPrinter
+  #
+  # source://thor//lib/thor/shell/column_printer.rb#8
+  def initialize(stdout, options = T.unsafe(nil)); end
+
+  # Returns the value of attribute options.
+  #
+  # source://thor//lib/thor/shell/column_printer.rb#6
+  def options; end
+
+  # source://thor//lib/thor/shell/column_printer.rb#14
+  def print(array); end
+
+  # Returns the value of attribute stdout.
+  #
+  # source://thor//lib/thor/shell/column_printer.rb#6
+  def stdout; end
+end
+
+# Inherit from Thor::Shell::Basic and add set_color behavior. Check
+# Thor::Shell::Basic to see all available methods.
+#
+# source://thor//lib/thor/shell/html.rb#9
+class Thor::Shell::HTML < ::Thor::Shell::Basic
+  include ::LCSDiff
+
+  # Ask something to the user and receives a response.
+  #
+  # ==== Example
+  #   ask("What is your name?")
+  #
+  # TODO: Implement #ask for Thor::Shell::HTML
+  #
+  # @raise [NotImplementedError]
+  #
+  # source://thor//lib/thor/shell/html.rb#73
+  def ask(statement, color = T.unsafe(nil)); end
+
+  # Set color by using a string or one of the defined constants. If a third
+  # option is set to true, it also adds bold to the string. This is based
+  # on Highline implementation and it automatically appends CLEAR to the end
+  # of the returned String.
+  #
+  # source://thor//lib/thor/shell/html.rb#54
+  def set_color(string, *colors); end
+
+  protected
+
+  # @return [Boolean]
+  #
+  # source://thor//lib/thor/shell/html.rb#79
+  def can_display_colors?; end
+end
+
+# Set the terminal's foreground HTML color to black.
+#
+# source://thor//lib/thor/shell/html.rb#16
+Thor::Shell::HTML::BLACK = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground HTML color to blue.
+#
+# source://thor//lib/thor/shell/html.rb#24
+Thor::Shell::HTML::BLUE = T.let(T.unsafe(nil), String)
+
+# The start of an HTML bold sequence.
+#
+# source://thor//lib/thor/shell/html.rb#13
+Thor::Shell::HTML::BOLD = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground HTML color to cyan.
+#
+# source://thor//lib/thor/shell/html.rb#28
+Thor::Shell::HTML::CYAN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground HTML color to green.
+#
+# source://thor//lib/thor/shell/html.rb#20
+Thor::Shell::HTML::GREEN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground HTML color to magenta.
+#
+# source://thor//lib/thor/shell/html.rb#26
+Thor::Shell::HTML::MAGENTA = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to black.
+#
+# source://thor//lib/thor/shell/html.rb#33
+Thor::Shell::HTML::ON_BLACK = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to blue.
+#
+# source://thor//lib/thor/shell/html.rb#41
+Thor::Shell::HTML::ON_BLUE = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to cyan.
+#
+# source://thor//lib/thor/shell/html.rb#45
+Thor::Shell::HTML::ON_CYAN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to green.
+#
+# source://thor//lib/thor/shell/html.rb#37
+Thor::Shell::HTML::ON_GREEN = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to magenta.
+#
+# source://thor//lib/thor/shell/html.rb#43
+Thor::Shell::HTML::ON_MAGENTA = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to red.
+#
+# source://thor//lib/thor/shell/html.rb#35
+Thor::Shell::HTML::ON_RED = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to white.
+#
+# source://thor//lib/thor/shell/html.rb#47
+Thor::Shell::HTML::ON_WHITE = T.let(T.unsafe(nil), String)
+
+# Set the terminal's background HTML color to yellow.
+#
+# source://thor//lib/thor/shell/html.rb#39
+Thor::Shell::HTML::ON_YELLOW = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground HTML color to red.
+#
+# source://thor//lib/thor/shell/html.rb#18
+Thor::Shell::HTML::RED = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground HTML color to white.
+#
+# source://thor//lib/thor/shell/html.rb#30
+Thor::Shell::HTML::WHITE = T.let(T.unsafe(nil), String)
+
+# Set the terminal's foreground HTML color to yellow.
+#
+# source://thor//lib/thor/shell/html.rb#22
+Thor::Shell::HTML::YELLOW = T.let(T.unsafe(nil), String)
+
+# source://thor//lib/thor/shell.rb#24
+Thor::Shell::SHELL_DELEGATED_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://thor//lib/thor/shell/table_printer.rb#6
+class Thor::Shell::TablePrinter < ::Thor::Shell::ColumnPrinter
+  # @return [TablePrinter] a new instance of TablePrinter
+  #
+  # source://thor//lib/thor/shell/table_printer.rb#9
+  def initialize(stdout, options = T.unsafe(nil)); end
+
+  # source://thor//lib/thor/shell/table_printer.rb#18
+  def print(array); end
+
+  private
+
+  # source://thor//lib/thor/shell/table_printer.rb#72
+  def format_cell(column, row_size, index); end
+
+  # source://thor//lib/thor/shell/table_printer.rb#113
+  def indentation; end
+
+  # source://thor//lib/thor/shell/table_printer.rb#47
+  def prepare(array); end
+
+  # source://thor//lib/thor/shell/table_printer.rb#96
+  def print_border_separator; end
+
+  # source://thor//lib/thor/shell/table_printer.rb#103
+  def truncate(string); end
+end
+
+# source://thor//lib/thor/shell/table_printer.rb#7
+Thor::Shell::TablePrinter::BORDER_SEPARATOR = T.let(T.unsafe(nil), Symbol)
+
+# source://thor//lib/thor/shell/terminal.rb#3
+module Thor::Shell::Terminal
+  class << self
+    # source://thor//lib/thor/shell/terminal.rb#9
+    def terminal_width; end
+
+    # @return [Boolean]
+    #
+    # source://thor//lib/thor/shell/terminal.rb#20
+    def unix?; end
+
+    private
+
+    # Calculate the dynamic width of the terminal
+    #
+    # source://thor//lib/thor/shell/terminal.rb#27
+    def dynamic_width; end
+
+    # source://thor//lib/thor/shell/terminal.rb#31
+    def dynamic_width_stty; end
+
+    # source://thor//lib/thor/shell/terminal.rb#35
+    def dynamic_width_tput; end
+  end
+end
+
+# source://thor//lib/thor/shell/terminal.rb#4
+Thor::Shell::Terminal::DEFAULT_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer)
+
+# source://thor//lib/thor/shell/wrapped_printer.rb#6
+class Thor::Shell::WrappedPrinter < ::Thor::Shell::ColumnPrinter
+  # source://thor//lib/thor/shell/wrapped_printer.rb#7
+  def print(message); end
+end
+
+# source://thor//lib/thor/base.rb#23
+Thor::TEMPLATE_EXTNAME = T.let(T.unsafe(nil), String)
+
+# Thor methods that should not be overwritten by the user.
+#
+# source://thor//lib/thor/base.rb#20
+Thor::THOR_RESERVED_WORDS = T.let(T.unsafe(nil), Array)
+
+# source://thor//lib/thor/command.rb#126
+Thor::Task = Thor::Command
+
+# Raised when a command was not found.
+#
+# source://thor//lib/thor/error.rb#24
+class Thor::UndefinedCommandError < ::Thor::Error
+  include ::Thor::Correctable
+
+  # @return [UndefinedCommandError] a new instance of UndefinedCommandError
+  #
+  # source://thor//lib/thor/error.rb#43
+  def initialize(command, all_commands, namespace); end
+
+  # Returns the value of attribute all_commands.
+  #
+  # source://thor//lib/thor/error.rb#41
+  def all_commands; end
+
+  # Returns the value of attribute command.
+  #
+  # source://thor//lib/thor/error.rb#41
+  def command; end
+end
+
+# source://thor//lib/thor/error.rb#25
+class Thor::UndefinedCommandError::SpellChecker
+  # @return [SpellChecker] a new instance of SpellChecker
+  #
+  # source://thor//lib/thor/error.rb#28
+  def initialize(error); end
+
+  # source://thor//lib/thor/error.rb#32
+  def corrections; end
+
+  # Returns the value of attribute error.
+  #
+  # source://thor//lib/thor/error.rb#26
+  def error; end
+
+  # source://thor//lib/thor/error.rb#36
+  def spell_checker; end
+end
+
+# source://thor//lib/thor/error.rb#55
+Thor::UndefinedTaskError = Thor::UndefinedCommandError
+
+# source://thor//lib/thor/error.rb#65
+class Thor::UnknownArgumentError < ::Thor::Error
+  include ::Thor::Correctable
+
+  # @return [UnknownArgumentError] a new instance of UnknownArgumentError
+  #
+  # source://thor//lib/thor/error.rb#85
+  def initialize(switches, unknown); end
+
+  # Returns the value of attribute switches.
+  #
+  # source://thor//lib/thor/error.rb#83
+  def switches; end
+
+  # Returns the value of attribute unknown.
+  #
+  # source://thor//lib/thor/error.rb#83
+  def unknown; end
+end
+
+# source://thor//lib/thor/error.rb#66
+class Thor::UnknownArgumentError::SpellChecker
+  # @return [SpellChecker] a new instance of SpellChecker
+  #
+  # source://thor//lib/thor/error.rb#69
+  def initialize(error); end
+
+  # source://thor//lib/thor/error.rb#73
+  def corrections; end
+
+  # Returns the value of attribute error.
+  #
+  # source://thor//lib/thor/error.rb#67
+  def error; end
+
+  # source://thor//lib/thor/error.rb#78
+  def spell_checker; end
+end
+
+# This module holds several utilities:
+#
+# 1) Methods to convert thor namespaces to constants and vice-versa.
+#
+#   Thor::Util.namespace_from_thor_class(Foo::Bar::Baz) #=> "foo:bar:baz"
+#
+# 2) Loading thor files and sandboxing:
+#
+#   Thor::Util.load_thorfile("~/.thor/foo")
+#
+# source://thor//lib/thor/util.rb#17
+module Thor::Util
+  class << self
+    # Receives a string and convert it to camel case. camel_case returns CamelCase.
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    #
+    # source://thor//lib/thor/util.rb#104
+    def camel_case(str); end
+
+    # Returns a string that has had any glob characters escaped.
+    # The glob characters are `* ? { } [ ]`.
+    #
+    # ==== Examples
+    #
+    #   Thor::Util.escape_globs('[apps]')   # => '\[apps\]'
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    #
+    # source://thor//lib/thor/util.rb#264
+    def escape_globs(path); end
+
+    # Returns a string that has had any HTML characters escaped.
+    #
+    # ==== Examples
+    #
+    #   Thor::Util.escape_html('<div>')   # => "&lt;div&gt;"
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    #
+    # source://thor//lib/thor/util.rb#280
+    def escape_html(string); end
+
+    # Receives a namespace and search for it in the Thor::Base subclasses.
+    #
+    # ==== Parameters
+    # namespace<String>:: The namespace to search for.
+    #
+    # source://thor//lib/thor/util.rb#24
+    def find_by_namespace(namespace); end
+
+    # Receives a namespace and tries to retrieve a Thor or Thor::Group class
+    # from it. It first searches for a class using the all the given namespace,
+    # if it's not found, removes the highest entry and searches for the class
+    # again. If found, returns the highest entry as the class name.
+    #
+    # ==== Examples
+    #
+    #   class Foo::Bar < Thor
+    #     def baz
+    #     end
+    #   end
+    #
+    #   class Baz::Foo < Thor::Group
+    #   end
+    #
+    #   Thor::Util.namespace_to_thor_class("foo:bar")     #=> Foo::Bar, nil # will invoke default command
+    #   Thor::Util.namespace_to_thor_class("baz:foo")     #=> Baz::Foo, nil
+    #   Thor::Util.namespace_to_thor_class("foo:bar:baz") #=> Foo::Bar, "baz"
+    #
+    # ==== Parameters
+    # namespace<String>
+    #
+    # source://thor//lib/thor/util.rb#131
+    def find_class_and_command_by_namespace(namespace, fallback = T.unsafe(nil)); end
+
+    # Receives a namespace and tries to retrieve a Thor or Thor::Group class
+    # from it. It first searches for a class using the all the given namespace,
+    # if it's not found, removes the highest entry and searches for the class
+    # again. If found, returns the highest entry as the class name.
+    #
+    # ==== Examples
+    #
+    #   class Foo::Bar < Thor
+    #     def baz
+    #     end
+    #   end
+    #
+    #   class Baz::Foo < Thor::Group
+    #   end
+    #
+    #   Thor::Util.namespace_to_thor_class("foo:bar")     #=> Foo::Bar, nil # will invoke default command
+    #   Thor::Util.namespace_to_thor_class("baz:foo")     #=> Baz::Foo, nil
+    #   Thor::Util.namespace_to_thor_class("foo:bar:baz") #=> Foo::Bar, "baz"
+    #
+    # ==== Parameters
+    # namespace<String>
+    #
+    # source://thor//lib/thor/util.rb#131
+    def find_class_and_task_by_namespace(namespace, fallback = T.unsafe(nil)); end
+
+    # Where to look for Thor files.
+    #
+    # source://thor//lib/thor/util.rb#213
+    def globs_for(path); end
+
+    # Receives a path and load the thor file in the path. The file is evaluated
+    # inside the sandbox to avoid namespacing conflicts.
+    #
+    # source://thor//lib/thor/util.rb#153
+    def load_thorfile(path, content = T.unsafe(nil), debug = T.unsafe(nil)); end
+
+    # Receives a constant and converts it to a Thor namespace. Since Thor
+    # commands can be added to a sandbox, this method is also responsible for
+    # removing the sandbox namespace.
+    #
+    # This method should not be used in general because it's used to deal with
+    # older versions of Thor. On current versions, if you need to get the
+    # namespace from a class, just call namespace on it.
+    #
+    # ==== Parameters
+    # constant<Object>:: The constant to be converted to the thor path.
+    #
+    # ==== Returns
+    # String:: If we receive Foo::Bar::Baz it returns "foo:bar:baz"
+    #
+    # source://thor//lib/thor/util.rb#43
+    def namespace_from_thor_class(constant); end
+
+    # Given the contents, evaluate it inside the sandbox and returns the
+    # namespaces defined in the sandbox.
+    #
+    # ==== Parameters
+    # contents<String>
+    #
+    # ==== Returns
+    # Array[Object]
+    #
+    # source://thor//lib/thor/util.rb#58
+    def namespaces_in_content(contents, file = T.unsafe(nil)); end
+
+    # Return the path to the ruby interpreter taking into account multiple
+    # installations and windows extensions.
+    #
+    # source://thor//lib/thor/util.rb#221
+    def ruby_command; end
+
+    # Receives a string and convert it to snake case. SnakeCase returns snake_case.
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    #
+    # source://thor//lib/thor/util.rb#90
+    def snake_case(str); end
+
+    # Returns the thor classes declared inside the given class.
+    #
+    # source://thor//lib/thor/util.rb#74
+    def thor_classes_in(klass); end
+
+    # Returns the root where thor files are located, depending on the OS.
+    #
+    # source://thor//lib/thor/util.rb#192
+    def thor_root; end
+
+    # Returns the files in the thor root. On Windows thor_root will be something
+    # like this:
+    #
+    #   C:\Documents and Settings\james\.thor
+    #
+    # If we don't #gsub the \ character, Dir.glob will fail.
+    #
+    # source://thor//lib/thor/util.rb#203
+    def thor_root_glob; end
+
+    # source://thor//lib/thor/util.rb#168
+    def user_home; end
+  end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/tzinfo@2.0.5.rbi b/Library/Homebrew/sorbet/rbi/gems/tzinfo@2.0.5.rbi
deleted file mode 100644
index 144492478e337..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/tzinfo@2.0.5.rbi
+++ /dev/null
@@ -1,863 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `tzinfo` gem.
-# Please instead update this file by running `bin/tapioca gem tzinfo`.
-
-module TZInfo
-  class << self
-    def eager_load!; end
-  end
-end
-
-class TZInfo::AbsoluteDayOfYearTransitionRule < ::TZInfo::DayOfYearTransitionRule
-  def initialize(day, transition_at = T.unsafe(nil)); end
-
-  def ==(r); end
-  def eql?(r); end
-  def is_always_first_day_of_year?; end
-  def is_always_last_day_of_year?; end
-
-  protected
-
-  def get_day(offset, year); end
-  def hash_args; end
-end
-
-class TZInfo::AmbiguousTime < ::StandardError; end
-
-class TZInfo::AnnualRules
-  def initialize(std_offset, dst_offset, dst_start_rule, dst_end_rule); end
-
-  def dst_end_rule; end
-  def dst_offset; end
-  def dst_start_rule; end
-  def std_offset; end
-  def transitions(year); end
-
-  private
-
-  def apply_rule(rule, from_offset, to_offset, year); end
-end
-
-class TZInfo::ConcurrentStringDeduper < ::TZInfo::StringDeduper
-  protected
-
-  def create_hash(&block); end
-end
-
-class TZInfo::Country
-  include ::Comparable
-
-  def initialize(info); end
-
-  def <=>(c); end
-  def =~(regexp); end
-  def _dump(limit); end
-  def code; end
-  def eql?(c); end
-  def hash; end
-  def inspect; end
-  def name; end
-  def to_s; end
-  def zone_identifiers; end
-  def zone_info; end
-  def zone_names; end
-  def zones; end
-
-  class << self
-    def _load(data); end
-    def all; end
-    def all_codes; end
-    def get(code); end
-
-    private
-
-    def data_source; end
-  end
-end
-
-TZInfo::CountryIndexDefinition = TZInfo::Format1::CountryIndexDefinition
-
-class TZInfo::CountryTimezone
-  def initialize(identifier, latitude, longitude, description = T.unsafe(nil)); end
-
-  def ==(ct); end
-  def description; end
-  def description_or_friendly_identifier; end
-  def eql?(ct); end
-  def hash; end
-  def identifier; end
-  def latitude; end
-  def longitude; end
-  def timezone; end
-end
-
-class TZInfo::DataSource
-  def initialize; end
-
-  def country_codes; end
-  def data_timezone_identifiers; end
-  def eager_load!; end
-  def get_country_info(code); end
-  def get_timezone_info(identifier); end
-  def inspect; end
-  def linked_timezone_identifiers; end
-  def timezone_identifiers; end
-  def to_s; end
-
-  protected
-
-  def load_country_info(code); end
-  def load_timezone_info(identifier); end
-  def lookup_country_info(hash, code, encoding = T.unsafe(nil)); end
-  def timezone_identifier_encoding; end
-  def validate_timezone_identifier(identifier); end
-
-  private
-
-  def build_timezone_identifiers; end
-  def find_timezone_identifier(identifier); end
-  def raise_invalid_data_source(method_name); end
-  def try_with_encoding(string, encoding); end
-
-  class << self
-    def get; end
-    def set(data_source_or_type, *args); end
-
-    private
-
-    def create_default_data_source; end
-  end
-end
-
-class TZInfo::DataSourceNotFound < ::StandardError; end
-module TZInfo::DataSources; end
-
-class TZInfo::DataSources::ConstantOffsetDataTimezoneInfo < ::TZInfo::DataSources::DataTimezoneInfo
-  def initialize(identifier, constant_offset); end
-
-  def constant_offset; end
-  def period_for(timestamp); end
-  def periods_for_local(local_timestamp); end
-  def transitions_up_to(to_timestamp, from_timestamp = T.unsafe(nil)); end
-
-  private
-
-  def constant_period; end
-end
-
-class TZInfo::DataSources::CountryInfo
-  def initialize(code, name, zones); end
-
-  def code; end
-  def inspect; end
-  def name; end
-  def zones; end
-end
-
-class TZInfo::DataSources::DataTimezoneInfo < ::TZInfo::DataSources::TimezoneInfo
-  def create_timezone; end
-  def period_for(timestamp); end
-  def periods_for_local(local_timestamp); end
-  def transitions_up_to(to_timestamp, from_timestamp = T.unsafe(nil)); end
-
-  private
-
-  def raise_not_implemented(method_name); end
-end
-
-class TZInfo::DataSources::InvalidPosixTimeZone < ::StandardError; end
-class TZInfo::DataSources::InvalidZoneinfoDirectory < ::StandardError; end
-class TZInfo::DataSources::InvalidZoneinfoFile < ::StandardError; end
-
-class TZInfo::DataSources::LinkedTimezoneInfo < ::TZInfo::DataSources::TimezoneInfo
-  def initialize(identifier, link_to_identifier); end
-
-  def create_timezone; end
-  def link_to_identifier; end
-end
-
-class TZInfo::DataSources::PosixTimeZoneParser
-  def initialize(string_deduper); end
-
-  def parse(tz_string); end
-
-  private
-
-  def check_scan(s, pattern); end
-  def get_offset_from_hms(h, m, s); end
-  def get_seconds_after_midnight_from_hms(h, m, s); end
-  def parse_rule(s, type); end
-end
-
-class TZInfo::DataSources::RubyDataSource < ::TZInfo::DataSource
-  def initialize; end
-
-  def country_codes; end
-  def data_timezone_identifiers; end
-  def inspect; end
-  def linked_timezone_identifiers; end
-  def to_s; end
-
-  protected
-
-  def load_country_info(code); end
-  def load_timezone_info(identifier); end
-
-  private
-
-  def require_data(*file); end
-  def require_definition(identifier); end
-  def require_index(name); end
-  def version_info; end
-end
-
-class TZInfo::DataSources::TZInfoDataNotFound < ::StandardError; end
-
-class TZInfo::DataSources::TimezoneInfo
-  def initialize(identifier); end
-
-  def create_timezone; end
-  def identifier; end
-  def inspect; end
-
-  private
-
-  def raise_not_implemented(method_name); end
-end
-
-class TZInfo::DataSources::TransitionsDataTimezoneInfo < ::TZInfo::DataSources::DataTimezoneInfo
-  def initialize(identifier, transitions); end
-
-  def period_for(timestamp); end
-  def periods_for_local(local_timestamp); end
-  def transitions; end
-  def transitions_up_to(to_timestamp, from_timestamp = T.unsafe(nil)); end
-
-  private
-
-  def find_minimum_transition(&block); end
-  def transition_on_or_after_timestamp?(transition, timestamp); end
-end
-
-class TZInfo::DataSources::ZoneinfoDataSource < ::TZInfo::DataSource
-  def initialize(zoneinfo_dir = T.unsafe(nil), alternate_iso3166_tab_path = T.unsafe(nil)); end
-
-  def country_codes; end
-  def data_timezone_identifiers; end
-  def inspect; end
-  def linked_timezone_identifiers; end
-  def to_s; end
-  def zoneinfo_dir; end
-
-  protected
-
-  def load_country_info(code); end
-  def load_timezone_info(identifier); end
-
-  private
-
-  def dms_to_rational(sign, degrees, minutes, seconds = T.unsafe(nil)); end
-  def enum_timezones(dir, exclude = T.unsafe(nil), &block); end
-  def find_zoneinfo_dir; end
-  def load_countries(iso3166_tab_path, zone_tab_path); end
-  def load_timezone_identifiers; end
-  def resolve_tab_path(zoneinfo_path, standard_names, tab_name); end
-  def validate_zoneinfo_dir(path, iso3166_tab_path = T.unsafe(nil)); end
-
-  class << self
-    def alternate_iso3166_tab_search_path; end
-    def alternate_iso3166_tab_search_path=(alternate_iso3166_tab_search_path); end
-    def search_path; end
-    def search_path=(search_path); end
-
-    private
-
-    def process_search_path(path, default); end
-  end
-end
-
-TZInfo::DataSources::ZoneinfoDataSource::DEFAULT_ALTERNATE_ISO3166_TAB_SEARCH_PATH = T.let(T.unsafe(nil), Array)
-TZInfo::DataSources::ZoneinfoDataSource::DEFAULT_SEARCH_PATH = T.let(T.unsafe(nil), Array)
-TZInfo::DataSources::ZoneinfoDataSource::EXCLUDED_FILENAMES = T.let(T.unsafe(nil), Array)
-class TZInfo::DataSources::ZoneinfoDirectoryNotFound < ::StandardError; end
-
-class TZInfo::DataSources::ZoneinfoReader
-  def initialize(posix_tz_parser, string_deduper); end
-
-  def read(file_path); end
-
-  private
-
-  def apply_rules_with_transitions(file, transitions, offsets, rules); end
-  def apply_rules_without_transitions(file, first_offset, rules); end
-  def check_read(file, bytes); end
-  def derive_offsets(transitions, offsets); end
-  def find_existing_offset(offsets, offset); end
-  def make_signed_int32(long); end
-  def make_signed_int64(high, low); end
-  def offset_matches_rule?(offset, rule_offset); end
-  def parse(file); end
-  def replace_with_existing_offsets(offsets, annual_rules); end
-  def validate_and_fix_last_defined_transition_offset(file, last_defined, first_rule_offset); end
-end
-
-TZInfo::DataSources::ZoneinfoReader::GENERATE_UP_TO = T.let(T.unsafe(nil), Integer)
-
-class TZInfo::DataTimezone < ::TZInfo::InfoTimezone
-  def canonical_zone; end
-  def period_for(time); end
-  def periods_for_local(local_time); end
-  def transitions_up_to(to, from = T.unsafe(nil)); end
-end
-
-class TZInfo::DateTimeWithOffset < ::DateTime
-  include ::TZInfo::WithOffset
-
-  def downto(min); end
-  def england; end
-  def gregorian; end
-  def italy; end
-  def julian; end
-  def new_start(start = T.unsafe(nil)); end
-  def set_timezone_offset(timezone_offset); end
-  def step(limit, step = T.unsafe(nil)); end
-  def timezone_offset; end
-  def to_time; end
-  def upto(max); end
-
-  protected
-
-  def clear_timezone_offset; end
-end
-
-class TZInfo::DayOfMonthTransitionRule < ::TZInfo::DayOfWeekTransitionRule
-  def initialize(month, week, day_of_week, transition_at = T.unsafe(nil)); end
-
-  def ==(r); end
-  def eql?(r); end
-
-  protected
-
-  def get_day(offset, year); end
-  def hash_args; end
-  def offset_start; end
-end
-
-class TZInfo::DayOfWeekTransitionRule < ::TZInfo::TransitionRule
-  def initialize(month, day_of_week, transition_at); end
-
-  def ==(r); end
-  def eql?(r); end
-  def is_always_first_day_of_year?; end
-  def is_always_last_day_of_year?; end
-
-  protected
-
-  def day_of_week; end
-  def hash_args; end
-  def month; end
-end
-
-class TZInfo::DayOfYearTransitionRule < ::TZInfo::TransitionRule
-  def initialize(day, transition_at); end
-
-  def ==(r); end
-  def eql?(r); end
-
-  protected
-
-  def hash_args; end
-  def seconds; end
-end
-
-module TZInfo::Format1; end
-
-class TZInfo::Format1::CountryDefiner < ::TZInfo::Format2::CountryDefiner
-  def initialize(identifier_deduper, description_deduper); end
-end
-
-module TZInfo::Format1::CountryIndexDefinition
-  mixes_in_class_methods ::TZInfo::Format1::CountryIndexDefinition::ClassMethods
-
-  class << self
-    def append_features(base); end
-  end
-end
-
-module TZInfo::Format1::CountryIndexDefinition::ClassMethods
-  def countries; end
-
-  private
-
-  def country(code, name); end
-end
-
-class TZInfo::Format1::TimezoneDefiner < ::TZInfo::Format2::TimezoneDefiner
-  def offset(id, utc_offset, std_offset, abbreviation); end
-  def transition(year, month, offset_id, timestamp_value, datetime_numerator = T.unsafe(nil), datetime_denominator = T.unsafe(nil)); end
-end
-
-module TZInfo::Format1::TimezoneDefinition
-  mixes_in_class_methods ::TZInfo::Format2::TimezoneDefinition::ClassMethods
-  mixes_in_class_methods ::TZInfo::Format1::TimezoneDefinition::ClassMethods
-
-  class << self
-    def append_features(base); end
-  end
-end
-
-module TZInfo::Format1::TimezoneDefinition::ClassMethods
-  private
-
-  def timezone_definer_class; end
-end
-
-module TZInfo::Format1::TimezoneIndexDefinition
-  mixes_in_class_methods ::TZInfo::Format1::TimezoneIndexDefinition::ClassMethods
-
-  class << self
-    def append_features(base); end
-  end
-end
-
-module TZInfo::Format1::TimezoneIndexDefinition::ClassMethods
-  def data_timezones; end
-  def linked_timezones; end
-
-  private
-
-  def linked_timezone(identifier); end
-  def timezone(identifier); end
-end
-
-module TZInfo::Format2; end
-
-class TZInfo::Format2::CountryDefiner
-  def initialize(shared_timezones, identifier_deduper, description_deduper); end
-
-  def timezone(identifier_or_reference, latitude_numerator = T.unsafe(nil), latitude_denominator = T.unsafe(nil), longitude_numerator = T.unsafe(nil), longitude_denominator = T.unsafe(nil), description = T.unsafe(nil)); end
-  def timezones; end
-end
-
-class TZInfo::Format2::CountryIndexDefiner
-  def initialize(identifier_deduper, description_deduper); end
-
-  def countries; end
-  def country(code, name); end
-  def timezone(reference, identifier, latitude_numerator, latitude_denominator, longitude_numerator, longitude_denominator, description = T.unsafe(nil)); end
-end
-
-module TZInfo::Format2::CountryIndexDefinition
-  mixes_in_class_methods ::TZInfo::Format2::CountryIndexDefinition::ClassMethods
-
-  class << self
-    def append_features(base); end
-  end
-end
-
-module TZInfo::Format2::CountryIndexDefinition::ClassMethods
-  def countries; end
-
-  private
-
-  def country_index; end
-end
-
-class TZInfo::Format2::TimezoneDefiner
-  def initialize(string_deduper); end
-
-  def first_offset; end
-  def offset(id, base_utc_offset, std_offset, abbreviation); end
-  def subsequent_rules(*args); end
-  def transition(offset_id, timestamp_value); end
-  def transitions; end
-end
-
-module TZInfo::Format2::TimezoneDefinition
-  mixes_in_class_methods ::TZInfo::Format2::TimezoneDefinition::ClassMethods
-
-  class << self
-    def append_features(base); end
-  end
-end
-
-module TZInfo::Format2::TimezoneDefinition::ClassMethods
-  def get; end
-
-  private
-
-  def linked_timezone(identifier, link_to_identifier); end
-  def timezone(identifier); end
-  def timezone_definer_class; end
-end
-
-class TZInfo::Format2::TimezoneIndexDefiner
-  def initialize(string_deduper); end
-
-  def data_timezone(identifier); end
-  def data_timezones; end
-  def linked_timezone(identifier); end
-  def linked_timezones; end
-end
-
-module TZInfo::Format2::TimezoneIndexDefinition
-  mixes_in_class_methods ::TZInfo::Format2::TimezoneIndexDefinition::ClassMethods
-
-  class << self
-    def append_features(base); end
-  end
-end
-
-module TZInfo::Format2::TimezoneIndexDefinition::ClassMethods
-  def data_timezones; end
-  def linked_timezones; end
-  def timezone_index; end
-end
-
-class TZInfo::InfoTimezone < ::TZInfo::Timezone
-  def initialize(info); end
-
-  def identifier; end
-
-  protected
-
-  def info; end
-end
-
-class TZInfo::InvalidCountryCode < ::StandardError; end
-class TZInfo::InvalidDataSource < ::StandardError; end
-class TZInfo::InvalidTimezoneIdentifier < ::StandardError; end
-
-class TZInfo::JulianDayOfYearTransitionRule < ::TZInfo::DayOfYearTransitionRule
-  def initialize(day, transition_at = T.unsafe(nil)); end
-
-  def ==(r); end
-  def eql?(r); end
-  def is_always_first_day_of_year?; end
-  def is_always_last_day_of_year?; end
-
-  protected
-
-  def get_day(offset, year); end
-  def hash_args; end
-end
-
-TZInfo::JulianDayOfYearTransitionRule::LEAP = T.let(T.unsafe(nil), Integer)
-TZInfo::JulianDayOfYearTransitionRule::YEAR = T.let(T.unsafe(nil), Integer)
-
-class TZInfo::LastDayOfMonthTransitionRule < ::TZInfo::DayOfWeekTransitionRule
-  def initialize(month, day_of_week, transition_at = T.unsafe(nil)); end
-
-  def ==(r); end
-  def eql?(r); end
-
-  protected
-
-  def get_day(offset, year); end
-end
-
-class TZInfo::LinkedTimezone < ::TZInfo::InfoTimezone
-  def initialize(info); end
-
-  def canonical_zone; end
-  def period_for(time); end
-  def periods_for_local(local_time); end
-  def transitions_up_to(to, from = T.unsafe(nil)); end
-end
-
-class TZInfo::OffsetTimezonePeriod < ::TZInfo::TimezonePeriod
-  def initialize(offset); end
-
-  def ==(p); end
-  def end_transition; end
-  def eql?(p); end
-  def hash; end
-  def start_transition; end
-end
-
-class TZInfo::PeriodNotFound < ::StandardError; end
-
-class TZInfo::StringDeduper
-  def initialize; end
-
-  def dedupe(string); end
-
-  protected
-
-  def create_hash(&block); end
-
-  class << self
-    def global; end
-  end
-end
-
-class TZInfo::TimeWithOffset < ::Time
-  include ::TZInfo::WithOffset
-
-  def dst?; end
-  def getlocal(*args); end
-  def gmtime; end
-  def isdst; end
-  def localtime(*args); end
-  def round(ndigits = T.unsafe(nil)); end
-  def set_timezone_offset(timezone_offset); end
-  def timezone_offset; end
-  def to_a; end
-  def to_datetime; end
-  def utc; end
-  def zone; end
-
-  protected
-
-  def clear_timezone_offset; end
-end
-
-class TZInfo::Timestamp
-  include ::Comparable
-
-  def initialize(value, sub_second = T.unsafe(nil), utc_offset = T.unsafe(nil)); end
-
-  def <=>(t); end
-  def add_and_set_utc_offset(seconds, utc_offset); end
-  def eql?(_arg0); end
-  def hash; end
-  def inspect; end
-  def strftime(format); end
-  def sub_second; end
-  def to_datetime; end
-  def to_i; end
-  def to_s; end
-  def to_time; end
-  def utc; end
-  def utc?; end
-  def utc_offset; end
-  def value; end
-
-  protected
-
-  def new_datetime(klass = T.unsafe(nil)); end
-  def new_time(klass = T.unsafe(nil)); end
-
-  private
-
-  def initialize!(value, sub_second = T.unsafe(nil), utc_offset = T.unsafe(nil)); end
-  def sub_second_to_s; end
-  def value_and_sub_second_to_s(offset = T.unsafe(nil)); end
-
-  class << self
-    def create(year, month = T.unsafe(nil), day = T.unsafe(nil), hour = T.unsafe(nil), minute = T.unsafe(nil), second = T.unsafe(nil), sub_second = T.unsafe(nil), utc_offset = T.unsafe(nil)); end
-    def for(value, offset = T.unsafe(nil)); end
-    def utc(value, sub_second = T.unsafe(nil)); end
-
-    private
-
-    def for_datetime(datetime, ignore_offset, target_utc_offset); end
-    def for_time(time, ignore_offset, target_utc_offset); end
-    def for_time_like(time_like, ignore_offset, target_utc_offset); end
-    def for_timestamp(timestamp, ignore_offset, target_utc_offset); end
-    def is_time_like?(value); end
-    def new!(value, sub_second = T.unsafe(nil), utc_offset = T.unsafe(nil)); end
-  end
-end
-
-TZInfo::Timestamp::JD_EPOCH = T.let(T.unsafe(nil), Integer)
-
-class TZInfo::TimestampWithOffset < ::TZInfo::Timestamp
-  include ::TZInfo::WithOffset
-
-  def set_timezone_offset(timezone_offset); end
-  def timezone_offset; end
-  def to_datetime; end
-  def to_time; end
-
-  class << self
-    def set_timezone_offset(timestamp, timezone_offset); end
-  end
-end
-
-class TZInfo::Timezone
-  include ::Comparable
-
-  def <=>(tz); end
-  def =~(regexp); end
-  def _dump(limit); end
-  def abbr(time = T.unsafe(nil)); end
-  def abbreviation(time = T.unsafe(nil)); end
-  def base_utc_offset(time = T.unsafe(nil)); end
-  def canonical_identifier; end
-  def canonical_zone; end
-  def current_period; end
-  def current_period_and_time; end
-  def current_time_and_period; end
-  def dst?(time = T.unsafe(nil)); end
-  def eql?(tz); end
-  def friendly_identifier(skip_first_part = T.unsafe(nil)); end
-  def hash; end
-  def identifier; end
-  def inspect; end
-  def local_datetime(year, month = T.unsafe(nil), day = T.unsafe(nil), hour = T.unsafe(nil), minute = T.unsafe(nil), second = T.unsafe(nil), sub_second = T.unsafe(nil), dst = T.unsafe(nil), &block); end
-  def local_time(year, month = T.unsafe(nil), day = T.unsafe(nil), hour = T.unsafe(nil), minute = T.unsafe(nil), second = T.unsafe(nil), sub_second = T.unsafe(nil), dst = T.unsafe(nil), &block); end
-  def local_timestamp(year, month = T.unsafe(nil), day = T.unsafe(nil), hour = T.unsafe(nil), minute = T.unsafe(nil), second = T.unsafe(nil), sub_second = T.unsafe(nil), dst = T.unsafe(nil), &block); end
-  def local_to_utc(local_time, dst = T.unsafe(nil)); end
-  def name; end
-  def now; end
-  def observed_utc_offset(time = T.unsafe(nil)); end
-  def offsets_up_to(to, from = T.unsafe(nil)); end
-  def period_for(time); end
-  def period_for_local(local_time, dst = T.unsafe(nil)); end
-  def period_for_utc(utc_time); end
-  def periods_for_local(local_time); end
-  def strftime(format, time = T.unsafe(nil)); end
-  def to_local(time); end
-  def to_s; end
-  def transitions_up_to(to, from = T.unsafe(nil)); end
-  def utc_offset(time = T.unsafe(nil)); end
-  def utc_to_local(utc_time); end
-
-  private
-
-  def raise_unknown_timezone; end
-
-  class << self
-    def _load(data); end
-    def all; end
-    def all_country_zone_identifiers; end
-    def all_country_zones; end
-    def all_data_zone_identifiers; end
-    def all_data_zones; end
-    def all_identifiers; end
-    def all_linked_zone_identifiers; end
-    def all_linked_zones; end
-    def default_dst; end
-    def default_dst=(value); end
-    def get(identifier); end
-    def get_proxy(identifier); end
-
-    private
-
-    def data_source; end
-    def get_proxies(identifiers); end
-  end
-end
-
-TZInfo::TimezoneDefinition = TZInfo::Format1::TimezoneDefinition
-TZInfo::TimezoneIndexDefinition = TZInfo::Format1::TimezoneIndexDefinition
-
-class TZInfo::TimezoneOffset
-  def initialize(base_utc_offset, std_offset, abbreviation); end
-
-  def ==(toi); end
-  def abbr; end
-  def abbreviation; end
-  def base_utc_offset; end
-  def dst?; end
-  def eql?(toi); end
-  def hash; end
-  def inspect; end
-  def observed_utc_offset; end
-  def std_offset; end
-  def utc_offset; end
-  def utc_total_offset; end
-end
-
-class TZInfo::TimezonePeriod
-  def initialize(offset); end
-
-  def abbr; end
-  def abbreviation; end
-  def base_utc_offset; end
-  def dst?; end
-  def end_transition; end
-  def ends_at; end
-  def local_ends_at; end
-  def local_starts_at; end
-  def observed_utc_offset; end
-  def offset; end
-  def start_transition; end
-  def starts_at; end
-  def std_offset; end
-  def utc_offset; end
-  def utc_total_offset; end
-  def zone_identifier; end
-
-  private
-
-  def raise_not_implemented(method_name); end
-  def timestamp(transition); end
-  def timestamp_with_offset(transition); end
-end
-
-class TZInfo::TimezoneProxy < ::TZInfo::Timezone
-  def initialize(identifier); end
-
-  def _dump(limit); end
-  def canonical_zone; end
-  def identifier; end
-  def period_for(time); end
-  def periods_for_local(local_time); end
-  def transitions_up_to(to, from = T.unsafe(nil)); end
-
-  private
-
-  def real_timezone; end
-
-  class << self
-    def _load(data); end
-  end
-end
-
-class TZInfo::TimezoneTransition
-  def initialize(offset, previous_offset, timestamp_value); end
-
-  def ==(tti); end
-  def at; end
-  def eql?(tti); end
-  def hash; end
-  def local_end_at; end
-  def local_start_at; end
-  def offset; end
-  def previous_offset; end
-  def timestamp_value; end
-end
-
-class TZInfo::TransitionRule
-  def initialize(transition_at); end
-
-  def ==(r); end
-  def at(offset, year); end
-  def eql?(r); end
-  def hash; end
-  def transition_at; end
-
-  protected
-
-  def hash_args; end
-end
-
-class TZInfo::TransitionsTimezonePeriod < ::TZInfo::TimezonePeriod
-  def initialize(start_transition, end_transition); end
-
-  def ==(p); end
-  def end_transition; end
-  def eql?(p); end
-  def hash; end
-  def inspect; end
-  def start_transition; end
-end
-
-class TZInfo::UnaryMinusGlobalStringDeduper
-  def dedupe(string); end
-end
-
-class TZInfo::UnknownTimezone < ::StandardError; end
-TZInfo::VERSION = T.let(T.unsafe(nil), String)
-
-module TZInfo::WithOffset
-  def strftime(format); end
-
-  protected
-
-  def if_timezone_offset(result = T.unsafe(nil)); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi b/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi
deleted file mode 100644
index 4ae42ce42e824..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi
+++ /dev/null
@@ -1,23 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `unf` gem.
-# Please instead update this file by running `bin/tapioca gem unf`.
-
-module UNF; end
-
-class UNF::Normalizer
-  include ::Singleton
-  extend ::Singleton::SingletonClassMethods
-
-  def initialize; end
-
-  def normalize(_arg0, _arg1); end
-
-  class << self
-    def instance; end
-    def normalize(string, form); end
-  end
-end
-
-UNF::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.8.2.rbi b/Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.8.2.rbi
deleted file mode 100644
index bebb1d3938ecf..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.8.2.rbi
+++ /dev/null
@@ -1,8 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `unf_ext` gem.
-# Please instead update this file by running `bin/tapioca gem unf_ext`.
-
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@2.2.0.rbi b/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@2.2.0.rbi
deleted file mode 100644
index 1974cb0f8c4bb..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@2.2.0.rbi
+++ /dev/null
@@ -1,26 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `unicode-display_width` gem.
-# Please instead update this file by running `bin/tapioca gem unicode-display_width`.
-
-module Unicode; end
-
-class Unicode::DisplayWidth
-  def initialize(ambiguous: T.unsafe(nil), overwrite: T.unsafe(nil), emoji: T.unsafe(nil)); end
-
-  def get_config(**kwargs); end
-  def of(string, **kwargs); end
-
-  class << self
-    def emoji_extra_width_of(string, ambiguous = T.unsafe(nil), overwrite = T.unsafe(nil), _ = T.unsafe(nil)); end
-    def of(string, ambiguous = T.unsafe(nil), overwrite = T.unsafe(nil), options = T.unsafe(nil)); end
-  end
-end
-
-Unicode::DisplayWidth::DATA_DIRECTORY = T.let(T.unsafe(nil), String)
-Unicode::DisplayWidth::DEPTHS = T.let(T.unsafe(nil), Array)
-Unicode::DisplayWidth::INDEX = T.let(T.unsafe(nil), Array)
-Unicode::DisplayWidth::INDEX_FILENAME = T.let(T.unsafe(nil), String)
-Unicode::DisplayWidth::UNICODE_VERSION = T.let(T.unsafe(nil), String)
-Unicode::DisplayWidth::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/unparser@0.6.4.rbi b/Library/Homebrew/sorbet/rbi/gems/unparser@0.6.4.rbi
deleted file mode 100644
index 32c6252a24345..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/unparser@0.6.4.rbi
+++ /dev/null
@@ -1,1834 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `unparser` gem.
-# Please instead update this file by running `bin/tapioca gem unparser`.
-
-module Unparser
-  class << self
-    def buffer(source, identification = T.unsafe(nil)); end
-    def parse(source); end
-    def parse_either(source); end
-    def parse_with_comments(source); end
-    def parser; end
-    def unparse(node, comment_array = T.unsafe(nil)); end
-    def unparse_either(node); end
-    def unparse_validate(node, comment_array = T.unsafe(nil)); end
-  end
-end
-
-module Unparser::AST
-  class << self
-    def local_variable_assignments(node); end
-    def local_variable_reads(node); end
-    def not_close_scope?(node); end
-    def not_reset_scope?(node); end
-  end
-end
-
-Unparser::AST::ASSIGN_NODES = T.let(T.unsafe(nil), Set)
-Unparser::AST::CLOSE_NODES = T.let(T.unsafe(nil), Array)
-
-class Unparser::AST::Enumerator
-  include ::Enumerable
-  include ::Unparser::Equalizer::Methods
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-
-  def each(&block); end
-  def type(type); end
-  def types(types); end
-
-  class << self
-    def new(node, controller = T.unsafe(nil)); end
-
-    private
-
-    def set(enumerable); end
-    def type(node, type); end
-  end
-end
-
-Unparser::AST::FIRST_CHILD = T.let(T.unsafe(nil), Proc)
-Unparser::AST::INHERIT_NODES = T.let(T.unsafe(nil), Array)
-
-class Unparser::AST::LocalVariableScope
-  include ::Unparser::Equalizer::Methods
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  include ::Enumerable
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-
-  def initialize(node); end
-
-  def first_assignment?(node); end
-  def first_assignment_in?(left, right); end
-  def local_variable_defined_for_node?(node, name); end
-
-  private
-
-  def match(needle); end
-end
-
-class Unparser::AST::LocalVariableScopeEnumerator
-  include ::Enumerable
-
-  def initialize; end
-
-  def each(node, &block); end
-
-  private
-
-  def current; end
-  def define(name); end
-  def enter(node); end
-  def leave(node); end
-  def pop; end
-  def push_inherit; end
-  def push_reset; end
-  def visit(node, &block); end
-
-  class << self
-    def each(node, &block); end
-  end
-end
-
-Unparser::AST::RESET_NODES = T.let(T.unsafe(nil), Array)
-Unparser::AST::TAUTOLOGY = T.let(T.unsafe(nil), Proc)
-
-class Unparser::AST::Walker
-  include ::Unparser::Equalizer::Methods
-
-  def call(node); end
-
-  class << self
-    def call(node, controller = T.unsafe(nil), &block); end
-  end
-end
-
-module Unparser::AbstractType
-  mixes_in_class_methods ::Unparser::AbstractType::AbstractMethodDeclarations
-
-  class << self
-    private
-
-    def create_new_method(abstract_class); end
-    def included(descendant); end
-  end
-end
-
-module Unparser::AbstractType::AbstractMethodDeclarations
-  def abstract_method(*names); end
-  def abstract_singleton_method(*names); end
-
-  private
-
-  def create_abstract_instance_method(name); end
-  def create_abstract_singleton_method(name); end
-end
-
-module Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-
-  mixes_in_class_methods ::Unparser::Adamantium::ModuleMethods
-  mixes_in_class_methods ::Unparser::Adamantium::ClassMethods
-
-  class << self
-    private
-
-    def included(descendant); end
-  end
-end
-
-module Unparser::Adamantium::ClassMethods
-  def new(*_arg0); end
-end
-
-module Unparser::Adamantium::InstanceMethods
-  def dup; end
-  def freeze; end
-
-  private
-
-  def memoized_method_cache; end
-end
-
-class Unparser::Adamantium::Memory
-  def initialize(values); end
-
-  def fetch(name); end
-end
-
-class Unparser::Adamantium::MethodBuilder
-  def initialize(descendant, method_name); end
-
-  def call; end
-
-  private
-
-  def assert_arity(arity); end
-  def create_memoized_method; end
-  def remove_original_method; end
-  def set_method_visibility; end
-  def visibility; end
-end
-
-class Unparser::Adamantium::MethodBuilder::BlockNotAllowedError < ::ArgumentError
-  def initialize(descendant, method); end
-end
-
-class Unparser::Adamantium::MethodBuilder::InvalidArityError < ::ArgumentError
-  def initialize(descendant, method, arity); end
-end
-
-module Unparser::Adamantium::ModuleMethods
-  def memoize(*methods); end
-  def memoized?(method_name); end
-  def unmemoized_instance_method(method_name); end
-
-  private
-
-  def memoize_method(method_name); end
-  def memoized_methods; end
-end
-
-class Unparser::Anima < ::Module
-  include ::Unparser::Equalizer::Methods
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-
-  def initialize(*names); end
-
-  def add(*names); end
-  def attribute_names(&block); end
-  def attributes; end
-  def attributes_hash(object); end
-  def initialize_instance(object, attribute_hash); end
-  def remove(*names); end
-
-  private
-
-  def assert_known_attributes(klass, attribute_hash); end
-  def included(descendant); end
-  def new(attributes); end
-end
-
-class Unparser::Anima::Attribute
-  include ::Unparser::Equalizer::Methods
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-
-  def initialize(name); end
-
-  def get(object); end
-  def instance_variable_name; end
-  def load(object, attributes); end
-  def name; end
-  def set(object, value); end
-end
-
-class Unparser::Anima::Error < ::RuntimeError
-  def initialize(klass, missing, unknown); end
-end
-
-Unparser::Anima::Error::FORMAT = T.let(T.unsafe(nil), String)
-
-module Unparser::Anima::InstanceMethods
-  def initialize(attributes); end
-
-  def to_h; end
-  def with(attributes); end
-end
-
-class Unparser::Buffer
-  def initialize; end
-
-  def append(string); end
-  def append_without_prefix(string); end
-  def capture_content; end
-  def content; end
-  def fresh_line?; end
-  def indent; end
-  def nl; end
-  def root_indent; end
-  def unindent; end
-  def write(fragment); end
-
-  private
-
-  def prefix; end
-end
-
-Unparser::Buffer::INDENT_SPACE = T.let(T.unsafe(nil), String)
-Unparser::Buffer::NL = T.let(T.unsafe(nil), String)
-
-class Unparser::Builder < ::Parser::Builders::Default
-  def initialize; end
-end
-
-class Unparser::CLI
-  def initialize(arguments); end
-
-  def add_options(builder); end
-  def exit_status; end
-
-  private
-
-  def effective_targets; end
-  def process_target(target); end
-  def targets(file_name); end
-
-  class << self
-    def run(*arguments); end
-  end
-end
-
-Unparser::CLI::EXIT_FAILURE = T.let(T.unsafe(nil), Integer)
-Unparser::CLI::EXIT_SUCCESS = T.let(T.unsafe(nil), Integer)
-
-class Unparser::CLI::Target
-  include ::Unparser::AbstractType
-  extend ::Unparser::AbstractType::AbstractMethodDeclarations
-
-  class << self
-    def new(*args, &block); end
-  end
-end
-
-class Unparser::CLI::Target::Path < ::Unparser::CLI::Target
-  include ::Unparser::Equalizer::Methods
-
-  def literal_validation; end
-  def validation; end
-end
-
-class Unparser::CLI::Target::String
-  include ::Unparser::Equalizer::Methods
-
-  def literal_validation; end
-  def validation; end
-end
-
-class Unparser::Color
-  include ::Unparser::Equalizer::Methods
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-
-  def format(text); end
-end
-
-Unparser::Color::GREEN = T.let(T.unsafe(nil), Unparser::Color)
-Unparser::Color::NONE = T.let(T.unsafe(nil), T.untyped)
-Unparser::Color::RED = T.let(T.unsafe(nil), Unparser::Color)
-
-class Unparser::Comments
-  def initialize(comments); end
-
-  def consume(node, source_part = T.unsafe(nil)); end
-  def source_range(*arguments); end
-  def take_all; end
-  def take_before(node, source_part); end
-  def take_eol_comments; end
-
-  private
-
-  def take_up_to_line(line); end
-  def take_while; end
-  def unshift_documents(comments); end
-
-  class << self
-    def source_range(node, part); end
-  end
-end
-
-class Unparser::Concord < ::Module
-  include ::Unparser::Equalizer::Methods
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-
-  def initialize(*names); end
-
-  def names; end
-
-  private
-
-  def define_equalizer; end
-  def define_initialize; end
-  def define_readers; end
-  def instance_variable_names; end
-end
-
-Unparser::Concord::MAX_NR_OF_OBJECTS = T.let(T.unsafe(nil), Integer)
-
-class Unparser::Concord::Public < ::Unparser::Concord
-  def included(descendant); end
-end
-
-module Unparser::Constants; end
-Unparser::Constants::BINARY_OPERATORS = T.let(T.unsafe(nil), Set)
-Unparser::Constants::KEYWORDS = T.let(T.unsafe(nil), Set)
-Unparser::Constants::K_ALIAS = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_AND = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_BEGIN = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_BREAK = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_CASE = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_CLASS = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_DEF = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_DEFINE = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_DEFINED = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_DO = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_EEND = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_ELSE = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_ELSIF = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_ENCODING = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_END = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_ENSURE = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_FALSE = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_FILE = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_FOR = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_IF = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_IN = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_MODULE = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_NEXT = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_NIL = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_NOT = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_OR = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_POSTEXE = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_PREEXE = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_REDO = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_RESCUE = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_RETRY = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_RETURN = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_SELF = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_SUPER = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_THEN = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_TRUE = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_UNDEF = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_UNLESS = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_UNTIL = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_WHEN = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_WHILE = T.let(T.unsafe(nil), String)
-Unparser::Constants::K_YIELD = T.let(T.unsafe(nil), String)
-Unparser::Constants::UNARY_OPERATORS = T.let(T.unsafe(nil), Set)
-
-module Unparser::DSL
-  private
-
-  def children(*names); end
-  def define_child(name, index); end
-  def define_group(name, range); end
-  def define_remaining_children(names); end
-end
-
-class Unparser::Diff
-  include ::Unparser::Equalizer::Methods
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-
-  def colorized_diff(&block); end
-  def diff(&block); end
-
-  private
-
-  def diffs; end
-  def hunks; end
-  def max_length; end
-  def minimized_hunk; end
-
-  class << self
-    def build(old, new); end
-
-    private
-
-    def colorize_line(line); end
-    def lines(source); end
-  end
-end
-
-Unparser::Diff::ADDITION = T.let(T.unsafe(nil), String)
-Unparser::Diff::DELETION = T.let(T.unsafe(nil), String)
-Unparser::Diff::NEWLINE = T.let(T.unsafe(nil), String)
-Unparser::EMPTY_ARRAY = T.let(T.unsafe(nil), Array)
-Unparser::EMPTY_STRING = T.let(T.unsafe(nil), String)
-
-class Unparser::Either
-  include ::Unparser::RequireBlock
-  include ::Unparser::Equalizer::Methods
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-
-  def left?; end
-  def right?; end
-
-  class << self
-    def wrap_error(*exceptions); end
-  end
-end
-
-class Unparser::Either::Left < ::Unparser::Either
-  def bind(&block); end
-  def either(left, _right); end
-  def fmap(&block); end
-  def from_left; end
-  def from_right; end
-  def lmap; end
-end
-
-class Unparser::Either::Right < ::Unparser::Either
-  def bind; end
-  def either(_left, right); end
-  def fmap; end
-  def from_left; end
-  def from_right; end
-  def lmap(&block); end
-end
-
-class Unparser::Emitter
-  include ::Unparser::NodeHelpers
-  include ::Unparser::Generation
-  include ::Unparser::Constants
-  include ::Unparser::AbstractType
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  include ::Unparser::Anima::InstanceMethods
-  include ::Unparser::Equalizer::Methods
-  extend ::Unparser::AbstractType::AbstractMethodDeclarations
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-  extend ::Unparser::DSL
-
-  def buffer; end
-  def comments; end
-  def dispatch(*_arg0); end
-  def emit_mlhs; end
-  def local_variable_scope; end
-  def node; end
-  def node_type; end
-
-  class << self
-    def anima; end
-    def emitter(buffer:, comments:, node:, local_variable_scope:); end
-    def new(*args, &block); end
-
-    private
-
-    def handle(*types); end
-  end
-end
-
-class Unparser::Emitter::Alias < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def remaining_children; end
-  def source; end
-  def target; end
-end
-
-class Unparser::Emitter::Args < ::Unparser::Emitter
-  def emit_block_arguments; end
-  def emit_def_arguments; end
-  def emit_lambda_arguments; end
-
-  private
-
-  def emit_shadowargs; end
-  def normal_arguments(&block); end
-  def shadowargs(&block); end
-end
-
-class Unparser::Emitter::Argument < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def name; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::Array < ::Unparser::Emitter
-  def emit_heredoc_reminders; end
-
-  private
-
-  def dispatch; end
-  def emitters(&block); end
-end
-
-class Unparser::Emitter::ArrayPattern < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def emit_member(node); end
-end
-
-class Unparser::Emitter::Assignment < ::Unparser::Emitter
-  def emit_heredoc_reminders; end
-  def emit_left(*_arg0); end
-  def symbol_name; end
-
-  private
-
-  def dispatch; end
-  def emit_right; end
-end
-
-Unparser::Emitter::Assignment::BINARY_OPERATOR = T.let(T.unsafe(nil), Array)
-
-class Unparser::Emitter::Assignment::Constant < ::Unparser::Emitter::Assignment
-  private
-
-  def base; end
-  def emit_left; end
-  def name; end
-  def remaining_children; end
-  def right; end
-end
-
-class Unparser::Emitter::Assignment::Variable < ::Unparser::Emitter::Assignment
-  private
-
-  def emit_left; end
-  def name; end
-  def remaining_children; end
-  def right; end
-end
-
-class Unparser::Emitter::Begin < ::Unparser::Emitter
-  def emit_heredoc_reminders; end
-
-  private
-
-  def body; end
-  def dispatch; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::Binary < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def writer(&block); end
-end
-
-class Unparser::Emitter::BinaryAssign < ::Unparser::Emitter
-  def emit_heredoc_reminders; end
-
-  private
-
-  def dispatch; end
-  def expression; end
-  def remaining_children; end
-  def target; end
-end
-
-Unparser::Emitter::BinaryAssign::MAP = T.let(T.unsafe(nil), Hash)
-
-class Unparser::Emitter::Block < ::Unparser::Emitter
-  private
-
-  def arguments; end
-  def body; end
-  def dispatch; end
-  def emit_block_arguments; end
-  def emit_lambda_arguments; end
-  def emit_send_target; end
-  def emit_target; end
-  def need_do?; end
-  def numblock?; end
-  def remaining_children; end
-  def target; end
-  def target_writer(&block); end
-  def write_close; end
-  def write_open; end
-end
-
-class Unparser::Emitter::BlockPass < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def name; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::CBase < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-end
-
-class Unparser::Emitter::Case < ::Unparser::Emitter
-  private
-
-  def condition; end
-  def dispatch; end
-  def emit_condition; end
-  def emit_else; end
-  def emit_whens; end
-  def remaining_children; end
-  def whens(&block); end
-end
-
-class Unparser::Emitter::CaseGuard < ::Unparser::Emitter
-  private
-
-  def condition; end
-  def dispatch; end
-  def remaining_children; end
-end
-
-Unparser::Emitter::CaseGuard::MAP = T.let(T.unsafe(nil), Hash)
-
-class Unparser::Emitter::CaseMatch < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def else_branch; end
-  def emit_else_branch; end
-  def patterns(&block); end
-  def remaining_children; end
-  def target; end
-end
-
-class Unparser::Emitter::Class < ::Unparser::Emitter
-  include ::Unparser::Emitter::LocalVariableRoot
-
-  def local_variable_scope(&block); end
-
-  private
-
-  def body; end
-  def dispatch; end
-  def emit_superclass; end
-  def name; end
-  def remaining_children; end
-  def superclass; end
-end
-
-class Unparser::Emitter::Const < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def emit_scope; end
-  def name; end
-  def remaining_children; end
-  def scope; end
-end
-
-class Unparser::Emitter::ConstPattern < ::Unparser::Emitter
-  private
-
-  def const; end
-  def dispatch; end
-  def pattern; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::DStr < ::Unparser::Emitter
-  def emit_heredoc_reminders; end
-
-  private
-
-  def dispatch; end
-end
-
-class Unparser::Emitter::DSym < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def emit_begin_child(component); end
-  def emit_str_child(value); end
-end
-
-class Unparser::Emitter::Def < ::Unparser::Emitter
-  include ::Unparser::Emitter::LocalVariableRoot
-
-  def local_variable_scope(&block); end
-
-  private
-
-  def body(*_arg0); end
-  def dispatch; end
-  def emit_arguments; end
-  def emit_name(*_arg0); end
-end
-
-class Unparser::Emitter::Def::Instance < ::Unparser::Emitter::Def
-  private
-
-  def arguments; end
-  def body; end
-  def emit_name; end
-  def name; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::Def::Singleton < ::Unparser::Emitter::Def
-  private
-
-  def arguments; end
-  def body; end
-  def emit_name; end
-  def name; end
-  def remaining_children; end
-  def subject; end
-  def subject_without_parens?; end
-end
-
-class Unparser::Emitter::Defined < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def remaining_children; end
-  def subject; end
-end
-
-class Unparser::Emitter::FindPattern < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-end
-
-class Unparser::Emitter::FlipFlop < ::Unparser::Emitter
-  def symbol_name; end
-
-  private
-
-  def dispatch; end
-  def left; end
-  def remaining_children; end
-  def right; end
-end
-
-Unparser::Emitter::FlipFlop::MAP = T.let(T.unsafe(nil), Hash)
-Unparser::Emitter::FlipFlop::SYMBOLS = T.let(T.unsafe(nil), Hash)
-
-class Unparser::Emitter::Float < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def remaining_children; end
-  def value; end
-end
-
-Unparser::Emitter::Float::INFINITY = T.let(T.unsafe(nil), Float)
-Unparser::Emitter::Float::NEG_INFINITY = T.let(T.unsafe(nil), Float)
-
-class Unparser::Emitter::FlowModifier < ::Unparser::Emitter
-  def emit_heredoc_reminders; end
-
-  private
-
-  def dispatch; end
-  def emit_arguments; end
-end
-
-Unparser::Emitter::FlowModifier::MAP = T.let(T.unsafe(nil), Hash)
-
-class Unparser::Emitter::For < ::Unparser::Emitter
-  private
-
-  def assignment; end
-  def body; end
-  def condition; end
-  def dispatch; end
-  def emit_condition; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::Hash < ::Unparser::Emitter
-  def emit_heredoc_reminders; end
-  def emit_last_argument_hash; end
-
-  private
-
-  def dispatch; end
-  def emit_hash_body; end
-  def emit_heredoc_reminder_member(node); end
-end
-
-class Unparser::Emitter::HashPattern < ::Unparser::Emitter
-  def emit_const_pattern; end
-
-  private
-
-  def dispatch; end
-  def emit_hash_body; end
-  def emit_match_var(node); end
-  def emit_member(node); end
-  def emit_pair(node); end
-  def write_symbol_body(symbol); end
-end
-
-class Unparser::Emitter::Hookexe < ::Unparser::Emitter
-  private
-
-  def body; end
-  def dispatch; end
-  def remaining_children; end
-end
-
-Unparser::Emitter::Hookexe::MAP = T.let(T.unsafe(nil), Hash)
-
-class Unparser::Emitter::If < ::Unparser::Emitter
-  def emit_ternary; end
-
-  private
-
-  def condition; end
-  def dispatch; end
-  def else_branch; end
-  def emit_condition; end
-  def emit_else_branch; end
-  def emit_if_branch; end
-  def emit_normal; end
-  def emit_postcondition; end
-  def if_branch; end
-  def keyword; end
-  def postcondition?; end
-  def remaining_children; end
-  def unless?; end
-end
-
-class Unparser::Emitter::InMatch < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def pattern; end
-  def remaining_children; end
-  def target; end
-end
-
-class Unparser::Emitter::InPattern < ::Unparser::Emitter
-  private
-
-  def branch; end
-  def dispatch; end
-  def else_branch; end
-  def remaining_children; end
-  def target; end
-  def unless_guard; end
-end
-
-class Unparser::Emitter::Index < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def emit_receiver; end
-end
-
-class Unparser::Emitter::Index::Assign < ::Unparser::Emitter::Index
-  def dispatch; end
-  def emit_heredoc_reminders; end
-  def emit_mlhs; end
-
-  private
-
-  def emit_operation(indices); end
-end
-
-Unparser::Emitter::Index::Assign::NO_VALUE_PARENT = T.let(T.unsafe(nil), Set)
-Unparser::Emitter::Index::Assign::VALUE_RANGE = T.let(T.unsafe(nil), Range)
-
-class Unparser::Emitter::Index::Reference < ::Unparser::Emitter::Index
-  private
-
-  def emit_operation; end
-  def indices(&block); end
-end
-
-class Unparser::Emitter::KWBegin < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def emit_multiple_body; end
-end
-
-class Unparser::Emitter::KeywordOptional < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def name; end
-  def remaining_children; end
-  def value; end
-end
-
-class Unparser::Emitter::KwSplat < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def remaining_children; end
-  def subject; end
-end
-
-class Unparser::Emitter::Kwarg < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def name; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::Kwargs < ::Unparser::Emitter
-  def dispatch; end
-end
-
-class Unparser::Emitter::Lambda < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-end
-
-module Unparser::Emitter::LocalVariableRoot
-  def local_variable_scope; end
-
-  class << self
-    def included(descendant); end
-  end
-end
-
-class Unparser::Emitter::MASGN < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def remaining_children; end
-  def source; end
-  def target; end
-end
-
-class Unparser::Emitter::MLHS < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def emit_many; end
-  def emit_one_child_mlhs; end
-end
-
-Unparser::Emitter::MLHS::NO_COMMA = T.let(T.unsafe(nil), Array)
-class Unparser::Emitter::Match < ::Unparser::Emitter; end
-
-class Unparser::Emitter::Match::CurrentLine < ::Unparser::Emitter::Match
-  private
-
-  def dispatch; end
-  def regexp; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::Match::Lvasgn < ::Unparser::Emitter::Match
-  private
-
-  def dispatch; end
-  def lvasgn; end
-  def regexp; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::MatchAlt < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def left; end
-  def remaining_children; end
-  def right; end
-end
-
-class Unparser::Emitter::MatchAs < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def left; end
-  def remaining_children; end
-  def right; end
-end
-
-class Unparser::Emitter::MatchPattern < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def pattern; end
-  def remaining_children; end
-  def target; end
-end
-
-Unparser::Emitter::MatchPattern::SYMBOL = T.let(T.unsafe(nil), String)
-
-class Unparser::Emitter::MatchPatternP < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def pattern; end
-  def remaining_children; end
-  def target; end
-end
-
-class Unparser::Emitter::MatchRest < ::Unparser::Emitter
-  def dispatch; end
-  def emit_array_pattern; end
-  def emit_hash_pattern; end
-
-  private
-
-  def emit_match_var; end
-  def match_var; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::MatchVar < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def name; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::Module < ::Unparser::Emitter
-  include ::Unparser::Emitter::LocalVariableRoot
-
-  def local_variable_scope(&block); end
-
-  private
-
-  def body; end
-  def dispatch; end
-  def name; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::Morearg < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def name; end
-  def remaining_children; end
-end
-
-Unparser::Emitter::Morearg::MAP = T.let(T.unsafe(nil), Hash)
-Unparser::Emitter::NO_INDENT = T.let(T.unsafe(nil), Array)
-
-class Unparser::Emitter::NthRef < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def name; end
-  def remaining_children; end
-end
-
-Unparser::Emitter::NthRef::PREFIX = T.let(T.unsafe(nil), String)
-
-class Unparser::Emitter::OpAssign < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def emit_operator; end
-  def operator; end
-  def remaining_children; end
-  def target; end
-  def value; end
-end
-
-class Unparser::Emitter::Optarg < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def name; end
-  def remaining_children; end
-  def value; end
-end
-
-class Unparser::Emitter::Pair < ::Unparser::Emitter
-  private
-
-  def colon?(key); end
-  def dispatch; end
-  def key; end
-  def remaining_children; end
-  def value; end
-end
-
-Unparser::Emitter::Pair::BAREWORD = T.let(T.unsafe(nil), Regexp)
-
-class Unparser::Emitter::Pin < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def remaining_children; end
-  def target; end
-end
-
-class Unparser::Emitter::Post < ::Unparser::Emitter
-  private
-
-  def body; end
-  def condition; end
-  def dispatch; end
-  def remaining_children; end
-end
-
-Unparser::Emitter::Post::MAP = T.let(T.unsafe(nil), Hash)
-
-class Unparser::Emitter::Primitive < ::Unparser::Emitter
-  private
-
-  def remaining_children; end
-  def value; end
-end
-
-class Unparser::Emitter::Primitive::Complex < ::Unparser::Emitter::Primitive
-  private
-
-  def dispatch; end
-  def emit_imaginary; end
-  def imaginary_node; end
-end
-
-Unparser::Emitter::Primitive::Complex::MAP = T.let(T.unsafe(nil), Hash)
-Unparser::Emitter::Primitive::Complex::RATIONAL_FORMAT = T.let(T.unsafe(nil), String)
-
-class Unparser::Emitter::Primitive::Inspect < ::Unparser::Emitter::Primitive
-  private
-
-  def dispatch; end
-end
-
-class Unparser::Emitter::Primitive::Numeric < ::Unparser::Emitter::Primitive
-  private
-
-  def dispatch; end
-end
-
-class Unparser::Emitter::Primitive::Rational < ::Unparser::Emitter::Primitive
-  private
-
-  def dispatch; end
-  def write_rational(value); end
-end
-
-Unparser::Emitter::Primitive::Rational::RATIONAL_FORMAT = T.let(T.unsafe(nil), String)
-
-class Unparser::Emitter::Procarg < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def needs_parens?; end
-end
-
-Unparser::Emitter::Procarg::PARENS = T.let(T.unsafe(nil), Array)
-Unparser::Emitter::REGISTRY = T.let(T.unsafe(nil), Hash)
-
-class Unparser::Emitter::Range < ::Unparser::Emitter
-  def symbol_name; end
-
-  private
-
-  def begin_node; end
-  def dispatch; end
-  def end_node; end
-  def remaining_children; end
-end
-
-Unparser::Emitter::Range::SYMBOLS = T.let(T.unsafe(nil), Hash)
-Unparser::Emitter::Range::TOKENS = T.let(T.unsafe(nil), Hash)
-
-class Unparser::Emitter::Regexp < ::Unparser::Emitter
-  private
-
-  def body(&block); end
-  def dispatch; end
-  def emit_body(node); end
-  def emit_options; end
-end
-
-class Unparser::Emitter::Repetition < ::Unparser::Emitter
-  private
-
-  def body; end
-  def condition; end
-  def dispatch; end
-  def emit_keyword; end
-  def emit_normal; end
-  def emit_postcontrol; end
-  def postcontrol?; end
-  def remaining_children; end
-end
-
-Unparser::Emitter::Repetition::MAP = T.let(T.unsafe(nil), Hash)
-
-class Unparser::Emitter::Rescue < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-end
-
-class Unparser::Emitter::Restarg < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def name; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::Root < ::Unparser::Emitter
-  include ::Unparser::Emitter::LocalVariableRoot
-
-  def dispatch; end
-  def local_variable_scope(&block); end
-end
-
-Unparser::Emitter::Root::END_NL = T.let(T.unsafe(nil), Array)
-
-class Unparser::Emitter::SClass < ::Unparser::Emitter
-  private
-
-  def body; end
-  def dispatch; end
-  def object; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::Send < ::Unparser::Emitter
-  def emit_heredoc_reminders; end
-  def emit_mlhs; end
-
-  private
-
-  def dispatch; end
-  def writer(&block); end
-end
-
-class Unparser::Emitter::Simple < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-end
-
-Unparser::Emitter::Simple::MAP = T.let(T.unsafe(nil), Hash)
-
-class Unparser::Emitter::Splat < ::Unparser::Emitter
-  def emit_mlhs; end
-
-  private
-
-  def dispatch; end
-  def remaining_children; end
-  def subject; end
-  def subject_emitter(&block); end
-end
-
-class Unparser::Emitter::Super < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-end
-
-class Unparser::Emitter::Undef < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-end
-
-class Unparser::Emitter::Variable < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def name; end
-  def remaining_children; end
-end
-
-class Unparser::Emitter::When < ::Unparser::Emitter
-  private
-
-  def captures(&block); end
-  def dispatch; end
-  def emit_captures; end
-end
-
-class Unparser::Emitter::XStr < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-  def emit_begin(component); end
-  def emit_heredoc; end
-  def emit_string(value); end
-  def emit_xstr; end
-  def escape_xstr(input); end
-  def heredoc?; end
-end
-
-class Unparser::Emitter::Yield < ::Unparser::Emitter
-  private
-
-  def dispatch; end
-end
-
-class Unparser::Equalizer < ::Module
-  def initialize(*keys); end
-
-  private
-
-  def define_cmp_method; end
-  def define_hash_method; end
-  def define_inspect_method; end
-  def define_methods; end
-  def included(descendant); end
-end
-
-module Unparser::Equalizer::Methods
-  def ==(other); end
-  def eql?(other); end
-end
-
-module Unparser::Generation
-  def emit_heredoc_reminders; end
-  def symbol_name; end
-  def write_to_buffer; end
-
-  private
-
-  def children; end
-  def conditional_parentheses(flag, &block); end
-  def delimited(nodes, delimiter = T.unsafe(nil), &block); end
-  def emit_body(node, indent: T.unsafe(nil)); end
-  def emit_body_ensure_rescue(node); end
-  def emit_body_inner(node); end
-  def emit_body_member(node); end
-  def emit_body_rescue(node); end
-  def emit_comments(comments); end
-  def emit_comments_before(source_part = T.unsafe(nil)); end
-  def emit_ensure(node); end
-  def emit_eof_comments; end
-  def emit_eol_comments; end
-  def emit_join(nodes, emit_node, emit_delimiter); end
-  def emit_optional_body(node, indent: T.unsafe(nil)); end
-  def emit_optional_body_ensure_rescue(node); end
-  def emit_rescue_postcontrol(node); end
-  def emit_rescue_regular(node); end
-  def emitter(node); end
-  def first_child; end
-  def indented; end
-  def k_end; end
-  def nl; end
-  def parentheses(open = T.unsafe(nil), close = T.unsafe(nil)); end
-  def visit(node); end
-  def visit_deep(node); end
-  def with_comments; end
-  def write(*strings); end
-  def writer_with(klass, node); end
-  def ws; end
-end
-
-Unparser::Generation::EXTRA_NL = T.let(T.unsafe(nil), Array)
-
-class Unparser::InvalidNodeError < ::RuntimeError
-  def initialize(message, node); end
-
-  def node; end
-end
-
-module Unparser::NodeDetails
-  include ::Unparser::NodeHelpers
-  include ::Unparser::Constants
-
-  private
-
-  def children; end
-
-  class << self
-    def included(descendant); end
-  end
-end
-
-class Unparser::NodeDetails::Send
-  include ::Unparser::NodeHelpers
-  include ::Unparser::Constants
-  include ::Unparser::NodeDetails
-  include ::Unparser::Equalizer::Methods
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-  extend ::Unparser::DSL
-
-  def arguments(&block); end
-  def arguments?; end
-  def assignment?(&block); end
-  def assignment_operator?; end
-  def binary_syntax_allowed?; end
-  def non_assignment_selector; end
-  def receiver; end
-  def selector; end
-  def selector_binary_operator?; end
-  def selector_unary_operator?; end
-  def string_selector(&block); end
-
-  private
-
-  def remaining_children; end
-end
-
-Unparser::NodeDetails::Send::ASSIGN_SUFFIX = T.let(T.unsafe(nil), String)
-Unparser::NodeDetails::Send::NON_ASSIGN_RANGE = T.let(T.unsafe(nil), Range)
-
-module Unparser::NodeHelpers
-  def n(type, children = T.unsafe(nil)); end
-  def n?(type, node); end
-  def s(type, *children); end
-  def unwrap_single_begin(node); end
-
-  private
-
-  def n_arg?(node); end
-  def n_args?(node); end
-  def n_array?(node); end
-  def n_array_pattern?(node); end
-  def n_begin?(node); end
-  def n_block?(node); end
-  def n_cbase?(node); end
-  def n_const?(node); end
-  def n_dstr?(node); end
-  def n_empty_else?(node); end
-  def n_ensure?(node); end
-  def n_hash?(node); end
-  def n_hash_pattern?(node); end
-  def n_if?(node); end
-  def n_in_pattern?(node); end
-  def n_int?(node); end
-  def n_kwarg?(node); end
-  def n_kwargs?(node); end
-  def n_kwsplat?(node); end
-  def n_lambda?(node); end
-  def n_match_rest?(node); end
-  def n_pair?(node); end
-  def n_rescue?(node); end
-  def n_send?(node); end
-  def n_shadowarg?(node); end
-  def n_splat?(node); end
-  def n_str?(node); end
-  def n_sym?(node); end
-end
-
-module Unparser::RequireBlock
-  private
-
-  def require_block; end
-end
-
-class Unparser::UnknownNodeError < ::ArgumentError; end
-
-class Unparser::Validation
-  include ::Unparser::Anima::InstanceMethods
-  include ::Unparser::Equalizer::Methods
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-
-  def generated_node; end
-  def generated_source; end
-  def identification; end
-  def original_node; end
-  def original_source; end
-  def report(&block); end
-  def success?; end
-
-  private
-
-  def make_report(label, attribute_name); end
-  def node_diff_report; end
-  def report_exception(exception); end
-
-  class << self
-    def anima; end
-    def from_node(original_node); end
-    def from_path(path); end
-    def from_string(original_source); end
-
-    private
-
-    def const_unit(_value); end
-  end
-end
-
-class Unparser::Validation::Literal < ::Unparser::Validation
-  def report; end
-  def success?; end
-
-  private
-
-  def source_diff_report; end
-end
-
-module Unparser::Writer
-  include ::Unparser::NodeHelpers
-  include ::Unparser::Generation
-  include ::Unparser::Anima::InstanceMethods
-  include ::Unparser::Equalizer::Methods
-
-  mixes_in_class_methods ::Unparser::DSL
-
-  class << self
-    def included(descendant); end
-  end
-end
-
-class Unparser::Writer::Binary
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  include ::Unparser::NodeHelpers
-  include ::Unparser::Generation
-  include ::Unparser::Writer
-  include ::Unparser::Anima::InstanceMethods
-  include ::Unparser::Equalizer::Methods
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-  extend ::Unparser::DSL
-
-  def buffer; end
-  def comments; end
-  def dispatch; end
-  def emit_operator; end
-  def local_variable_scope; end
-  def node; end
-  def symbol_name; end
-
-  private
-
-  def effective_symbol; end
-  def emit_with(map); end
-  def keyword_symbol; end
-  def left; end
-  def left_emitter(&block); end
-  def operator_symbol; end
-  def remaining_children; end
-  def right; end
-  def right_emitter(&block); end
-
-  class << self
-    def anima; end
-  end
-end
-
-Unparser::Writer::Binary::KEYWORD_SYMBOLS = T.let(T.unsafe(nil), Hash)
-Unparser::Writer::Binary::KEYWORD_TOKENS = T.let(T.unsafe(nil), Hash)
-Unparser::Writer::Binary::MAP = T.let(T.unsafe(nil), Hash)
-Unparser::Writer::Binary::NEED_KEYWORD = T.let(T.unsafe(nil), Array)
-Unparser::Writer::Binary::OPERATOR_SYMBOLS = T.let(T.unsafe(nil), Hash)
-Unparser::Writer::Binary::OPERATOR_TOKENS = T.let(T.unsafe(nil), Hash)
-
-class Unparser::Writer::DynamicString
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  include ::Unparser::NodeHelpers
-  include ::Unparser::Generation
-  include ::Unparser::Writer
-  include ::Unparser::Anima::InstanceMethods
-  include ::Unparser::Equalizer::Methods
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-  extend ::Unparser::DSL
-
-  def buffer; end
-  def comments; end
-  def dispatch; end
-  def emit_heredoc_reminder; end
-  def local_variable_scope; end
-  def node; end
-
-  private
-
-  def breakpoint?(child, current); end
-  def classify(node); end
-  def classify_str(node); end
-  def emit_body(children); end
-  def emit_dstr; end
-  def emit_dynamic(child); end
-  def emit_dynamic_component(node); end
-  def emit_heredoc_body; end
-  def emit_heredoc_footer; end
-  def emit_heredoc_header; end
-  def emit_normal_heredoc_body; end
-  def emit_segment(children, index); end
-  def emit_squiggly_heredoc_body; end
-  def escape_dynamic(string); end
-  def heredoc?; end
-  def heredoc_header; end
-  def heredoc_pattern?; end
-  def heredoc_pattern_2?; end
-  def heredoc_pattern_3?; end
-  def nl_last_child?; end
-  def segments; end
-  def str_empty?(node); end
-  def str_nl?(node); end
-  def str_ws?(node); end
-
-  class << self
-    def anima; end
-  end
-end
-
-Unparser::Writer::DynamicString::FLAT_INTERPOLATION = T.let(T.unsafe(nil), Set)
-Unparser::Writer::DynamicString::PATTERNS_2 = T.let(T.unsafe(nil), Array)
-Unparser::Writer::DynamicString::PATTERNS_3 = T.let(T.unsafe(nil), Array)
-
-class Unparser::Writer::Resbody
-  include ::Unparser::NodeHelpers
-  include ::Unparser::Generation
-  include ::Unparser::Writer
-  include ::Unparser::Anima::InstanceMethods
-  include ::Unparser::Equalizer::Methods
-  extend ::Unparser::DSL
-
-  def buffer; end
-  def comments; end
-  def emit_postcontrol; end
-  def emit_regular; end
-  def local_variable_scope; end
-  def node; end
-
-  private
-
-  def assignment; end
-  def body; end
-  def emit_assignment; end
-  def emit_exception; end
-  def exception; end
-  def remaining_children; end
-
-  class << self
-    def anima; end
-  end
-end
-
-class Unparser::Writer::Rescue
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  include ::Unparser::NodeHelpers
-  include ::Unparser::Generation
-  include ::Unparser::Writer
-  include ::Unparser::Anima::InstanceMethods
-  include ::Unparser::Equalizer::Methods
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-  extend ::Unparser::DSL
-
-  def buffer; end
-  def comments; end
-  def emit_heredoc_reminders; end
-  def emit_postcontrol; end
-  def emit_regular; end
-  def local_variable_scope; end
-  def node; end
-
-  private
-
-  def body; end
-  def else_node; end
-  def emit_rescue_body(node); end
-  def remaining_children; end
-  def rescue_bodies(&block); end
-  def rescue_body; end
-
-  class << self
-    def anima; end
-  end
-end
-
-class Unparser::Writer::Send
-  include ::Unparser::NodeHelpers
-  include ::Unparser::Generation
-  include ::Unparser::Constants
-  include ::Unparser::Adamantium
-  include ::Unparser::Adamantium::InstanceMethods
-  include ::Unparser::Writer
-  include ::Unparser::Anima::InstanceMethods
-  include ::Unparser::Equalizer::Methods
-  extend ::Unparser::Adamantium::ModuleMethods
-  extend ::Unparser::Adamantium::ClassMethods
-  extend ::Unparser::DSL
-
-  def buffer; end
-  def comments; end
-  def dispatch; end
-  def emit_heredoc_reminders; end
-  def emit_mlhs; end
-  def emit_selector; end
-  def local_variable_scope; end
-  def node; end
-
-  private
-
-  def arguments; end
-  def avoid_clash?; end
-  def details(&block); end
-  def effective_writer(&block); end
-  def effective_writer_class; end
-  def emit_arguments; end
-  def emit_heredoc_reminder(argument); end
-  def emit_normal_arguments; end
-  def emit_operator; end
-  def emit_send_regular(node); end
-  def local_variable_clash?; end
-  def parses_as_constant?; end
-  def receiver; end
-  def remaining_children; end
-  def selector; end
-  def write_as_attribute_assignment?; end
-
-  class << self
-    def anima; end
-  end
-end
-
-class Unparser::Writer::Send::AttributeAssignment < ::Unparser::Writer::Send
-  def dispatch; end
-  def emit_send_mlhs; end
-
-  private
-
-  def emit_attribute; end
-  def emit_receiver; end
-  def first_argument; end
-  def receiver; end
-  def remaining_children; end
-  def selector; end
-end
-
-class Unparser::Writer::Send::Binary < ::Unparser::Writer::Send
-  def dispatch; end
-
-  private
-
-  def emit_operator; end
-  def emit_right; end
-end
-
-Unparser::Writer::Send::INDEX_ASSIGN = T.let(T.unsafe(nil), Symbol)
-Unparser::Writer::Send::INDEX_REFERENCE = T.let(T.unsafe(nil), Symbol)
-Unparser::Writer::Send::OPERATORS = T.let(T.unsafe(nil), Hash)
-
-class Unparser::Writer::Send::Regular < ::Unparser::Writer::Send
-  def dispatch; end
-  def emit_arguments_without_heredoc_body; end
-  def emit_receiver; end
-  def emit_send_mlhs; end
-end
-
-class Unparser::Writer::Send::Unary < ::Unparser::Writer::Send
-  def dispatch; end
-end
-
-Unparser::Writer::Send::Unary::MAP = T.let(T.unsafe(nil), Hash)
diff --git a/Library/Homebrew/sorbet/rbi/gems/uri_template@0.7.0.rbi b/Library/Homebrew/sorbet/rbi/gems/uri_template@0.7.0.rbi
deleted file mode 100644
index 527645fd84a23..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/uri_template@0.7.0.rbi
+++ /dev/null
@@ -1,495 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `uri_template` gem.
-# Please instead update this file by running `bin/tapioca gem uri_template`.
-
-module URITemplate
-  extend ::URITemplate::ClassMethods
-
-  mixes_in_class_methods ::URITemplate::ClassMethods
-
-  def +(other, *args, &block); end
-  def /(other, *args, &block); end
-  def ==(other, *args, &block); end
-  def >>(other, *args, &block); end
-  def absolute?; end
-  def concat(other, *args, &block); end
-  def concat_without_coercion(other); end
-  def eq(other, *args, &block); end
-  def eq_without_coercion(other); end
-  def expand(variables = T.unsafe(nil)); end
-  def expand_partial(variables = T.unsafe(nil)); end
-  def host?; end
-  def path_concat(other, *args, &block); end
-  def path_concat_without_coercion(other); end
-  def pattern; end
-  def relative?; end
-  def scheme?; end
-  def static_characters; end
-  def to_s; end
-  def tokens; end
-  def type; end
-  def variables; end
-
-  private
-
-  def normalize_variables(variables); end
-  def remove_double_slash(first_tokens, second_tokens); end
-  def scheme_and_host; end
-
-  class << self
-    def apply(a, method, b, *args); end
-    def coerce(a, b); end
-    def coerce_first_arg(meth); end
-    def new(*args); end
-    def resolve_class(*args); end
-  end
-end
-
-module URITemplate::ClassMethods
-  def convert(x); end
-  def included(base); end
-  def try_convert(x); end
-end
-
-class URITemplate::Colon
-  include ::URITemplate
-  extend ::URITemplate::ClassMethods
-
-  def initialize(pattern); end
-
-  def extract(uri); end
-  def pattern; end
-  def to_r; end
-  def tokens; end
-  def type; end
-
-  protected
-
-  def tokenize!; end
-
-  class << self
-    def try_convert(x); end
-  end
-end
-
-class URITemplate::Colon::InvalidValue < ::StandardError
-  include ::URITemplate::InvalidValue
-
-  def initialize(variable, value); end
-
-  def value; end
-  def variable; end
-
-  protected
-
-  def generate_message; end
-end
-
-class URITemplate::Colon::InvalidValue::SplatIsNotAnArray < ::URITemplate::Colon::InvalidValue; end
-class URITemplate::Colon::Token; end
-
-class URITemplate::Colon::Token::Splat < ::URITemplate::Colon::Token::Variable
-  def initialize(index); end
-
-  def expand(vars); end
-  def index; end
-  def to_r; end
-end
-
-URITemplate::Colon::Token::Splat::SPLAT = T.let(T.unsafe(nil), String)
-
-class URITemplate::Colon::Token::Static < ::URITemplate::Colon::Token
-  include ::URITemplate::Token
-  include ::URITemplate::Literal
-
-  def initialize(str); end
-
-  def expand(_); end
-  def to_r; end
-end
-
-class URITemplate::Colon::Token::Variable < ::URITemplate::Colon::Token
-  include ::URITemplate::Token
-  include ::URITemplate::Expression
-
-  def initialize(name); end
-
-  def expand(vars); end
-  def name; end
-  def to_r; end
-  def to_s; end
-end
-
-URITemplate::Colon::VAR = T.let(T.unsafe(nil), Regexp)
-
-module URITemplate::Expression
-  include ::URITemplate::Token
-
-  def expression?; end
-  def literal?; end
-  def variables; end
-end
-
-URITemplate::HOST_REGEX = T.let(T.unsafe(nil), Regexp)
-module URITemplate::Invalid; end
-module URITemplate::InvalidValue; end
-
-module URITemplate::Literal
-  include ::URITemplate::Token
-
-  def ends_with_slash?; end
-  def expand(_); end
-  def expand_partial(_); end
-  def expression?; end
-  def literal?; end
-  def size; end
-  def starts_with_slash?; end
-  def string; end
-  def to_s; end
-end
-
-URITemplate::Literal::SLASH = T.let(T.unsafe(nil), String)
-
-class URITemplate::RFC6570
-  include ::URITemplate
-  extend ::URITemplate::ClassMethods
-  extend ::Forwardable
-  extend ::URITemplate::RFC6570::ClassMethods
-
-  def initialize(pattern_or_tokens, options = T.unsafe(nil)); end
-
-  def ===(*args, &block); end
-  def extract(uri_or_match, post_processing = T.unsafe(nil)); end
-  def extract_simple(uri_or_match); end
-  def level; end
-  def match(*args, &block); end
-  def options; end
-  def to_r; end
-  def tokens; end
-  def type; end
-
-  protected
-
-  def extract_matchdata(matchdata, post_processing); end
-  def tokenize!; end
-end
-
-URITemplate::RFC6570::CHARACTER_CLASSES = T.let(T.unsafe(nil), Hash)
-URITemplate::RFC6570::CONVERT_RESULT = T.let(T.unsafe(nil), Array)
-URITemplate::RFC6570::CONVERT_VALUES = T.let(T.unsafe(nil), Array)
-
-module URITemplate::RFC6570::ClassMethods
-  def try_convert(x); end
-  def valid?(pattern); end
-end
-
-URITemplate::RFC6570::DEFAULT_PROCESSING = T.let(T.unsafe(nil), Array)
-URITemplate::RFC6570::EXPRESSION = T.let(T.unsafe(nil), Regexp)
-
-class URITemplate::RFC6570::Expression < ::URITemplate::RFC6570::Token
-  include ::URITemplate::Token
-  include ::URITemplate::Expression
-  extend ::URITemplate::RFC6570::Expression::ClassMethods
-
-  def initialize(vars); end
-
-  def arity; end
-  def expand(vars); end
-  def expand_partial(vars); end
-  def extract(position, matched); end
-  def level; end
-  def to_s; end
-  def variables; end
-
-  protected
-
-  def cut(str, chars); end
-  def decode(x, split = T.unsafe(nil)); end
-  def empty_literals?(list); end
-  def escape(x); end
-  def pair(key, value, max_length = T.unsafe(nil), &block); end
-  def regex_builder; end
-  def transform_array(name, ary, expand, max_length); end
-  def transform_hash(name, hsh, expand, max_length); end
-  def unescape(x); end
-
-  private
-
-  def expand_one(name, value, expand, max_length); end
-  def extracted_nil; end
-  def length_limited?(max_length); end
-end
-
-URITemplate::RFC6570::Expression::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
-class URITemplate::RFC6570::Expression::Basic < ::URITemplate::RFC6570::Expression::Unnamed; end
-URITemplate::RFC6570::Expression::Basic::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Basic
-URITemplate::RFC6570::Expression::Basic::FOLLOW_UP = URITemplate::RFC6570::Expression::Basic
-URITemplate::RFC6570::Expression::CHARACTER_CLASS = T.let(T.unsafe(nil), Hash)
-URITemplate::RFC6570::Expression::COMMA = T.let(T.unsafe(nil), String)
-
-module URITemplate::RFC6570::Expression::ClassMethods
-  def generate_hash_extractor(max_length); end
-  def hash_extractor(max_length); end
-  def hash_extractors; end
-  def regex_builder; end
-end
-
-class URITemplate::RFC6570::Expression::FormQuery < ::URITemplate::RFC6570::Expression::Named; end
-URITemplate::RFC6570::Expression::FormQuery::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
-URITemplate::RFC6570::Expression::FormQuery::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::FormQueryContinuation
-URITemplate::RFC6570::Expression::FormQuery::FOLLOW_UP = URITemplate::RFC6570::Expression::Basic
-URITemplate::RFC6570::Expression::FormQuery::OPERATOR = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::FormQuery::PREFIX = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::FormQuery::SEPARATOR = T.let(T.unsafe(nil), String)
-class URITemplate::RFC6570::Expression::FormQueryContinuation < ::URITemplate::RFC6570::Expression::Named; end
-URITemplate::RFC6570::Expression::FormQueryContinuation::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
-URITemplate::RFC6570::Expression::FormQueryContinuation::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::FormQueryContinuation
-URITemplate::RFC6570::Expression::FormQueryContinuation::FOLLOW_UP = URITemplate::RFC6570::Expression::Basic
-URITemplate::RFC6570::Expression::FormQueryContinuation::OPERATOR = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::FormQueryContinuation::PREFIX = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::FormQueryContinuation::SEPARATOR = T.let(T.unsafe(nil), String)
-
-class URITemplate::RFC6570::Expression::Fragment < ::URITemplate::RFC6570::Expression::Unnamed
-  def escape(x); end
-  def unescape(x); end
-end
-
-URITemplate::RFC6570::Expression::Fragment::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
-URITemplate::RFC6570::Expression::Fragment::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Reserved
-URITemplate::RFC6570::Expression::Fragment::CHARACTER_CLASS = T.let(T.unsafe(nil), Hash)
-URITemplate::RFC6570::Expression::Fragment::FOLLOW_UP = URITemplate::RFC6570::Expression::Reserved
-URITemplate::RFC6570::Expression::Fragment::OPERATOR = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::Fragment::PREFIX = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::LIST_CONNECTOR = T.let(T.unsafe(nil), String)
-class URITemplate::RFC6570::Expression::Label < ::URITemplate::RFC6570::Expression::Unnamed; end
-URITemplate::RFC6570::Expression::Label::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
-URITemplate::RFC6570::Expression::Label::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Label
-URITemplate::RFC6570::Expression::Label::FOLLOW_UP = URITemplate::RFC6570::Expression::Label
-URITemplate::RFC6570::Expression::Label::OPERATOR = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::Label::PREFIX = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::Label::SEPARATOR = T.let(T.unsafe(nil), String)
-
-class URITemplate::RFC6570::Expression::Named < ::URITemplate::RFC6570::Expression
-  def expand_partial(vars); end
-  def to_r_source; end
-
-  protected
-
-  def self_pair(key, value, max_length = T.unsafe(nil), &block); end
-
-  private
-
-  def after_expand(name, splitted); end
-  def extracted_nil; end
-end
-
-URITemplate::RFC6570::Expression::OPERATOR = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::PAIR_CONNECTOR = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::PAIR_IF_EMPTY = T.let(T.unsafe(nil), TrueClass)
-URITemplate::RFC6570::Expression::PREFIX = T.let(T.unsafe(nil), String)
-
-class URITemplate::RFC6570::Expression::Path < ::URITemplate::RFC6570::Expression::Unnamed
-  def starts_with_slash?; end
-end
-
-URITemplate::RFC6570::Expression::Path::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
-URITemplate::RFC6570::Expression::Path::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Path
-URITemplate::RFC6570::Expression::Path::FOLLOW_UP = URITemplate::RFC6570::Expression::Path
-URITemplate::RFC6570::Expression::Path::OPERATOR = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::Path::PREFIX = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::Path::SEPARATOR = T.let(T.unsafe(nil), String)
-class URITemplate::RFC6570::Expression::PathParameters < ::URITemplate::RFC6570::Expression::Named; end
-URITemplate::RFC6570::Expression::PathParameters::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
-URITemplate::RFC6570::Expression::PathParameters::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::PathParameters
-URITemplate::RFC6570::Expression::PathParameters::FOLLOW_UP = URITemplate::RFC6570::Expression::PathParameters
-URITemplate::RFC6570::Expression::PathParameters::OPERATOR = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::PathParameters::PREFIX = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::PathParameters::SEPARATOR = T.let(T.unsafe(nil), String)
-
-class URITemplate::RFC6570::Expression::Reserved < ::URITemplate::RFC6570::Expression::Unnamed
-  def escape(x); end
-  def host?; end
-  def scheme?; end
-  def unescape(x); end
-end
-
-URITemplate::RFC6570::Expression::Reserved::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
-URITemplate::RFC6570::Expression::Reserved::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Reserved
-URITemplate::RFC6570::Expression::Reserved::CHARACTER_CLASS = T.let(T.unsafe(nil), Hash)
-URITemplate::RFC6570::Expression::Reserved::FOLLOW_UP = URITemplate::RFC6570::Expression::Reserved
-URITemplate::RFC6570::Expression::Reserved::OPERATOR = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::SEPARATOR = T.let(T.unsafe(nil), String)
-URITemplate::RFC6570::Expression::SPLITTER = T.let(T.unsafe(nil), Regexp)
-
-class URITemplate::RFC6570::Expression::Unnamed < ::URITemplate::RFC6570::Expression
-  def self_pair(_, value, max_length = T.unsafe(nil), &block); end
-  def to_r_source; end
-
-  private
-
-  def after_expand(name, splitted); end
-  def transform_array(name, ary, expand, max_length); end
-  def transform_hash(name, hsh, expand, max_length); end
-end
-
-class URITemplate::RFC6570::Invalid < ::StandardError
-  include ::URITemplate::Invalid
-
-  def initialize(source, position); end
-
-  def pattern; end
-  def position; end
-end
-
-URITemplate::RFC6570::LITERAL = T.let(T.unsafe(nil), Regexp)
-
-class URITemplate::RFC6570::Literal < ::URITemplate::RFC6570::Token
-  include ::URITemplate::Token
-  include ::URITemplate::Literal
-
-  def initialize(string); end
-
-  def level; end
-  def to_r_source(*_); end
-  def to_s; end
-end
-
-URITemplate::RFC6570::NO_PROCESSING = T.let(T.unsafe(nil), Array)
-URITemplate::RFC6570::OPERATORS = T.let(T.unsafe(nil), Hash)
-
-class URITemplate::RFC6570::RegexBuilder
-  def initialize(expression_class); end
-
-  def <<(arg); end
-  def capture(&block); end
-  def character_class(max_length = T.unsafe(nil), min = T.unsafe(nil)); end
-  def character_class_with_comma(max_length = T.unsafe(nil), min = T.unsafe(nil)); end
-  def escaped_pair_connector; end
-  def escaped_prefix; end
-  def escaped_separator; end
-  def group(capture = T.unsafe(nil)); end
-  def join; end
-  def length(*args); end
-  def lookahead; end
-  def negative_lookahead; end
-  def push(*args); end
-  def reluctant; end
-  def separated_list(first = T.unsafe(nil), length = T.unsafe(nil), min = T.unsafe(nil), &block); end
-
-  private
-
-  def format_length(len, min = T.unsafe(nil)); end
-end
-
-URITemplate::RFC6570::TYPE = T.let(T.unsafe(nil), Symbol)
-class URITemplate::RFC6570::Token; end
-
-class URITemplate::RFC6570::Tokenizer
-  include ::Enumerable
-
-  def initialize(source, ops); end
-
-  def each; end
-  def source; end
-end
-
-URITemplate::RFC6570::URI = T.let(T.unsafe(nil), Regexp)
-
-module URITemplate::RFC6570::Utils
-  include ::URITemplate::Utils::StringEncoding::Encode
-  include ::URITemplate::Utils::StringEncoding
-  include ::URITemplate::Utils::Escaping::Pure
-  include ::URITemplate::Utils
-  extend ::URITemplate::Utils::StringEncoding::Encode
-  extend ::URITemplate::Utils::StringEncoding
-  extend ::URITemplate::Utils::Escaping::Pure
-  extend ::URITemplate::Utils
-  extend ::URITemplate::RFC6570::Utils
-
-  def def?(value); end
-end
-
-URITemplate::RFC6570::VAR = T.let(T.unsafe(nil), Regexp)
-
-class URITemplate::RegexpEnumerator
-  include ::Enumerable
-
-  def initialize(regexp, options = T.unsafe(nil)); end
-
-  def each(str); end
-end
-
-URITemplate::SCHEME_REGEX = T.let(T.unsafe(nil), Regexp)
-
-module URITemplate::Token
-  def ends_with_slash?; end
-  def expand(variables); end
-  def expand_partial(variables); end
-  def host?; end
-  def scheme?; end
-  def size; end
-  def starts_with_slash?; end
-  def to_s; end
-  def variables; end
-end
-
-URITemplate::Token::EMPTY_ARRAY = T.let(T.unsafe(nil), Array)
-URITemplate::URI_SPLIT = T.let(T.unsafe(nil), Regexp)
-
-class URITemplate::Unconvertable < ::StandardError
-  def initialize(object); end
-
-  def object; end
-end
-
-module URITemplate::Utils
-  include ::URITemplate::Utils::StringEncoding::Encode
-  include ::URITemplate::Utils::StringEncoding
-  include ::URITemplate::Utils::Escaping::Pure
-  extend ::URITemplate::Utils::StringEncoding::Encode
-  extend ::URITemplate::Utils::StringEncoding
-  extend ::URITemplate::Utils::Escaping::Pure
-  extend ::URITemplate::Utils
-
-  def compact_regexp(rx); end
-  def object_to_param(object); end
-  def pair_array?(a); end
-  def pair_array_to_hash(x, careful = T.unsafe(nil)); end
-  def pair_array_to_hash2(x); end
-  def use_unicode?; end
-end
-
-module URITemplate::Utils::Escaping; end
-
-module URITemplate::Utils::Escaping::Pure
-  def escape_uri(s); end
-  def escape_url(s); end
-  def unescape_uri(s); end
-  def unescape_url(s); end
-  def using_escape_utils?; end
-end
-
-URITemplate::Utils::Escaping::Pure::PCT = T.let(T.unsafe(nil), Regexp)
-URITemplate::Utils::Escaping::Pure::URI_ESCAPED = T.let(T.unsafe(nil), Regexp)
-URITemplate::Utils::Escaping::Pure::URL_ESCAPED = T.let(T.unsafe(nil), Regexp)
-URITemplate::Utils::KCODE_UTF8 = T.let(T.unsafe(nil), Integer)
-
-module URITemplate::Utils::StringEncoding
-  include ::URITemplate::Utils::StringEncoding::Encode
-end
-
-module URITemplate::Utils::StringEncoding::Encode
-  def force_utf8(str); end
-  def to_ascii(str); end
-  def to_utf8(str); end
-end
-
-module URITemplate::Utils::StringEncoding::Fallback
-  def force_utf8(str); end
-  def to_ascii(str); end
-  def to_utf8(str); end
-end
-
-URITemplate::VERSIONS = T.let(T.unsafe(nil), Hash)
diff --git a/Library/Homebrew/sorbet/rbi/gems/vernier@1.2.1.rbi b/Library/Homebrew/sorbet/rbi/gems/vernier@1.2.1.rbi
new file mode 100644
index 0000000000000..06002869a4ba0
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/vernier@1.2.1.rbi
@@ -0,0 +1,585 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `vernier` gem.
+# Please instead update this file by running `bin/tapioca gem vernier`.
+
+
+# source://vernier//lib/vernier/version.rb#3
+module Vernier
+  class << self
+    # source://vernier//lib/vernier.rb#17
+    def profile(mode: T.unsafe(nil), **collector_options); end
+
+    # source://vernier//lib/vernier.rb#17
+    def run(mode: T.unsafe(nil), **collector_options); end
+
+    # source://vernier//lib/vernier.rb#38
+    def start_profile(mode: T.unsafe(nil), **collector_options); end
+
+    # source://vernier//lib/vernier.rb#50
+    def stop_profile; end
+
+    # source://vernier//lib/vernier.rb#17
+    def trace(mode: T.unsafe(nil), **collector_options); end
+
+    # source://vernier//lib/vernier.rb#59
+    def trace_retained(**profile_options, &block); end
+  end
+end
+
+# source://vernier//lib/vernier/collector.rb#7
+class Vernier::Collector
+  # @return [Collector] a new instance of Collector
+  #
+  # source://vernier//lib/vernier/collector.rb#8
+  def initialize(mode, options = T.unsafe(nil)); end
+
+  # source://vernier//lib/vernier/collector.rb#49
+  def add_marker(name:, start:, finish:, thread: T.unsafe(nil), phase: T.unsafe(nil), data: T.unsafe(nil)); end
+
+  # Get the current time.
+  #
+  # This method returns the current time from Process.clock_gettime in
+  # integer nanoseconds.  It's the same time used by Vernier internals and
+  # can be used to generate timestamps for custom markers.
+  #
+  # source://vernier//lib/vernier/collector.rb#45
+  def current_time; end
+
+  # Record an interval with a category and name.  Yields to a block and
+  # records the amount of time spent in the block as an interval marker.
+  #
+  # source://vernier//lib/vernier/collector.rb#61
+  def record_interval(category, name = T.unsafe(nil)); end
+
+  def sample; end
+  def stack_table; end
+  def start; end
+
+  # source://vernier//lib/vernier/collector.rb#74
+  def stop; end
+
+  private
+
+  # source://vernier//lib/vernier/collector.rb#30
+  def add_hook(hook); end
+
+  def finish; end
+  def markers; end
+
+  class << self
+    def _new(_arg0, _arg1); end
+
+    # source://vernier//lib/vernier.rb#64
+    def new(mode, options = T.unsafe(nil)); end
+  end
+end
+
+# source://vernier//lib/vernier.rb#13
+class Vernier::Error < ::StandardError; end
+
+# source://vernier//lib/vernier/hooks.rb#4
+module Vernier::Hooks; end
+
+# source://vernier//lib/vernier/hooks/active_support.rb#5
+class Vernier::Hooks::ActiveSupport
+  # @return [ActiveSupport] a new instance of ActiveSupport
+  #
+  # source://vernier//lib/vernier/hooks/active_support.rb#155
+  def initialize(collector); end
+
+  # source://vernier//lib/vernier/hooks/active_support.rb#182
+  def disable; end
+
+  # source://vernier//lib/vernier/hooks/active_support.rb#159
+  def enable; end
+
+  # source://vernier//lib/vernier/hooks/active_support.rb#187
+  def firefox_marker_schema; end
+end
+
+# source://vernier//lib/vernier/hooks/active_support.rb#6
+Vernier::Hooks::ActiveSupport::FIREFOX_MARKER_SCHEMA = T.let(T.unsafe(nil), Array)
+
+# source://vernier//lib/vernier/hooks/active_support.rb#148
+Vernier::Hooks::ActiveSupport::SERIALIZED_KEYS = T.let(T.unsafe(nil), Hash)
+
+# source://vernier//lib/vernier/marker.rb#6
+module Vernier::Marker
+  class << self
+    # Return an array of marker names.  The index of the string maps to the
+    # value of the corresponding constant
+    #
+    # source://vernier//lib/vernier/marker.rb#34
+    def name_table; end
+  end
+end
+
+# source://vernier//lib/vernier/marker.rb#13
+Vernier::Marker::MARKER_STRINGS = T.let(T.unsafe(nil), Array)
+
+# source://vernier//lib/vernier/marker.rb#7
+Vernier::Marker::MARKER_SYMBOLS = T.let(T.unsafe(nil), Array)
+
+module Vernier::Marker::Phase; end
+Vernier::Marker::Phase::INSTANT = T.let(T.unsafe(nil), Integer)
+Vernier::Marker::Phase::INTERVAL = T.let(T.unsafe(nil), Integer)
+Vernier::Marker::Phase::INTERVAL_END = T.let(T.unsafe(nil), Integer)
+Vernier::Marker::Phase::INTERVAL_START = T.let(T.unsafe(nil), Integer)
+module Vernier::Marker::Type; end
+Vernier::Marker::Type::GC_END_MARK = T.let(T.unsafe(nil), Integer)
+Vernier::Marker::Type::GC_END_SWEEP = T.let(T.unsafe(nil), Integer)
+Vernier::Marker::Type::GC_ENTER = T.let(T.unsafe(nil), Integer)
+Vernier::Marker::Type::GC_EXIT = T.let(T.unsafe(nil), Integer)
+Vernier::Marker::Type::GC_PAUSE = T.let(T.unsafe(nil), Integer)
+Vernier::Marker::Type::GC_START = T.let(T.unsafe(nil), Integer)
+Vernier::Marker::Type::GVL_THREAD_EXITED = T.let(T.unsafe(nil), Integer)
+Vernier::Marker::Type::GVL_THREAD_STARTED = T.let(T.unsafe(nil), Integer)
+Vernier::Marker::Type::THREAD_RUNNING = T.let(T.unsafe(nil), Integer)
+Vernier::Marker::Type::THREAD_STALLED = T.let(T.unsafe(nil), Integer)
+Vernier::Marker::Type::THREAD_SUSPENDED = T.let(T.unsafe(nil), Integer)
+
+# source://vernier//lib/vernier/middleware.rb#2
+class Vernier::Middleware
+  # @return [Middleware] a new instance of Middleware
+  #
+  # source://vernier//lib/vernier/middleware.rb#3
+  def initialize(app, permit: T.unsafe(nil)); end
+
+  # source://vernier//lib/vernier/middleware.rb#8
+  def call(env); end
+end
+
+# source://vernier//lib/vernier/output/firefox.rb#7
+module Vernier::Output; end
+
+# https://profiler.firefox.com/
+# https://github.com/firefox-devtools/profiler/blob/main/src/types/profile.js
+#
+# source://vernier//lib/vernier/output/firefox.rb#10
+class Vernier::Output::Firefox
+  # @return [Firefox] a new instance of Firefox
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#88
+  def initialize(profile); end
+
+  # source://vernier//lib/vernier/output/firefox.rb#93
+  def output(gzip: T.unsafe(nil)); end
+
+  private
+
+  # source://vernier//lib/vernier/output/firefox.rb#106
+  def data; end
+
+  # source://vernier//lib/vernier/output/firefox.rb#153
+  def marker_schema; end
+
+  # Returns the value of attribute profile.
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#104
+  def profile; end
+end
+
+# source://vernier//lib/vernier/output/firefox.rb#11
+class Vernier::Output::Firefox::Categorizer
+  # @return [Categorizer] a new instance of Categorizer
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#13
+  def initialize; end
+
+  # @yield [category]
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#43
+  def add_category(name:, **kw); end
+
+  # Returns the value of attribute categories.
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#12
+  def categories; end
+
+  # source://vernier//lib/vernier/output/firefox.rb#64
+  def categorize(path); end
+
+  # source://vernier//lib/vernier/output/firefox.rb#60
+  def gem_path(*names); end
+
+  # source://vernier//lib/vernier/output/firefox.rb#52
+  def get_category(name); end
+
+  # source://vernier//lib/vernier/output/firefox.rb#56
+  def starts_with(*paths); end
+end
+
+# source://vernier//lib/vernier/output/firefox.rb#68
+class Vernier::Output::Firefox::Categorizer::Category
+  # @return [Category] a new instance of Category
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#70
+  def initialize(idx, name:, color:, matcher: T.unsafe(nil)); end
+
+  # source://vernier//lib/vernier/output/firefox.rb#78
+  def add_subcategory(**args); end
+
+  # Returns the value of attribute color.
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#69
+  def color; end
+
+  # Returns the value of attribute idx.
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#69
+  def idx; end
+
+  # Returns the value of attribute matcher.
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#69
+  def matcher; end
+
+  # @return [Boolean]
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#82
+  def matches?(path); end
+
+  # Returns the value of attribute name.
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#69
+  def name; end
+
+  # Returns the value of attribute subcategories.
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#69
+  def subcategories; end
+end
+
+# source://vernier//lib/vernier/output/firefox.rb#208
+class Vernier::Output::Firefox::Thread
+  # @return [Thread] a new instance of Thread
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#211
+  def initialize(ruby_thread_id, profile, categorizer, name:, tid:, samples:, weights:, markers:, started_at:, timestamps: T.unsafe(nil), sample_categories: T.unsafe(nil), stopped_at: T.unsafe(nil), allocations: T.unsafe(nil), is_main: T.unsafe(nil), is_start: T.unsafe(nil)); end
+
+  # source://vernier//lib/vernier/output/firefox.rb#398
+  def allocations_table; end
+
+  # source://vernier//lib/vernier/output/firefox.rb#326
+  def data; end
+
+  # source://vernier//lib/vernier/output/firefox.rb#305
+  def filter_filenames(filenames); end
+
+  # source://vernier//lib/vernier/output/firefox.rb#478
+  def frame_table; end
+
+  # source://vernier//lib/vernier/output/firefox.rb#502
+  def func_table; end
+
+  # Returns the value of attribute is_start.
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#209
+  def is_start; end
+
+  # source://vernier//lib/vernier/output/firefox.rb#358
+  def markers_table; end
+
+  # Returns the value of attribute profile.
+  #
+  # source://vernier//lib/vernier/output/firefox.rb#209
+  def profile; end
+
+  # source://vernier//lib/vernier/output/firefox.rb#417
+  def samples_table; end
+
+  # source://vernier//lib/vernier/output/firefox.rb#453
+  def stack_table; end
+
+  # source://vernier//lib/vernier/output/firefox.rb#527
+  def string_table; end
+
+  private
+
+  # source://vernier//lib/vernier/output/firefox.rb#533
+  def gc_category; end
+
+  # source://vernier//lib/vernier/output/firefox.rb#537
+  def thread_category; end
+end
+
+# source://vernier//lib/vernier/output/top.rb#5
+class Vernier::Output::Top
+  # @return [Top] a new instance of Top
+  #
+  # source://vernier//lib/vernier/output/top.rb#6
+  def initialize(profile); end
+
+  # source://vernier//lib/vernier/output/top.rb#10
+  def output; end
+end
+
+# source://vernier//lib/vernier/result.rb#2
+class Vernier::Result
+  # source://vernier//lib/vernier/result.rb#7
+  def _stack_table; end
+
+  # source://vernier//lib/vernier/result.rb#54
+  def each_sample; end
+
+  # source://vernier//lib/vernier/result.rb#46
+  def elapsed_seconds; end
+
+  # Returns the value of attribute end_time.
+  #
+  # source://vernier//lib/vernier/result.rb#15
+  def end_time; end
+
+  # Sets the attribute end_time
+  #
+  # @param value the value to set the attribute end_time to.
+  #
+  # source://vernier//lib/vernier/result.rb#15
+  def end_time=(_arg0); end
+
+  # Returns the value of attribute hooks.
+  #
+  # source://vernier//lib/vernier/result.rb#13
+  def hooks; end
+
+  # Sets the attribute hooks
+  #
+  # @param value the value to set the attribute hooks to.
+  #
+  # source://vernier//lib/vernier/result.rb#13
+  def hooks=(_arg0); end
+
+  # source://vernier//lib/vernier/result.rb#50
+  def inspect; end
+
+  # source://vernier//lib/vernier/result.rb#20
+  def main_thread; end
+
+  # Returns the value of attribute markers.
+  #
+  # source://vernier//lib/vernier/result.rb#11
+  def markers; end
+
+  # Returns the value of attribute meta.
+  #
+  # source://vernier//lib/vernier/result.rb#17
+  def meta; end
+
+  # Sets the attribute meta
+  #
+  # @param value the value to set the attribute meta to.
+  #
+  # source://vernier//lib/vernier/result.rb#17
+  def meta=(_arg0); end
+
+  # Returns the value of attribute mode.
+  #
+  # source://vernier//lib/vernier/result.rb#18
+  def mode; end
+
+  # Sets the attribute mode
+  #
+  # @param value the value to set the attribute mode to.
+  #
+  # source://vernier//lib/vernier/result.rb#18
+  def mode=(_arg0); end
+
+  # Returns the value of attribute pid.
+  #
+  # source://vernier//lib/vernier/result.rb#15
+  def pid; end
+
+  # Sets the attribute pid
+  #
+  # @param value the value to set the attribute pid to.
+  #
+  # source://vernier//lib/vernier/result.rb#15
+  def pid=(_arg0); end
+
+  # source://vernier//lib/vernier/result.rb#27
+  def sample_categories; end
+
+  # source://vernier//lib/vernier/result.rb#26
+  def samples; end
+
+  # source://vernier//lib/vernier/result.rb#146
+  def stack(idx); end
+
+  # source://vernier//lib/vernier/result.rb#3
+  def stack_table=(stack_table); end
+
+  # Realtime in nanoseconds since the unix epoch
+  #
+  # source://vernier//lib/vernier/result.rb#30
+  def started_at; end
+
+  # Returns the value of attribute threads.
+  #
+  # source://vernier//lib/vernier/result.rb#16
+  def threads; end
+
+  # Sets the attribute threads
+  #
+  # @param value the value to set the attribute threads to.
+  #
+  # source://vernier//lib/vernier/result.rb#16
+  def threads=(_arg0); end
+
+  # source://vernier//lib/vernier/result.rb#37
+  def to_gecko(gzip: T.unsafe(nil)); end
+
+  # source://vernier//lib/vernier/result.rb#150
+  def total_bytes; end
+
+  # TODO: remove these
+  #
+  # source://vernier//lib/vernier/result.rb#25
+  def weights; end
+
+  # source://vernier//lib/vernier/result.rb#41
+  def write(out:); end
+end
+
+# source://vernier//lib/vernier/result.rb#63
+class Vernier::Result::BaseType
+  # @return [BaseType] a new instance of BaseType
+  #
+  # source://vernier//lib/vernier/result.rb#65
+  def initialize(result, idx); end
+
+  # Returns the value of attribute idx.
+  #
+  # source://vernier//lib/vernier/result.rb#64
+  def idx; end
+
+  # source://vernier//lib/vernier/result.rb#74
+  def inspect; end
+
+  # Returns the value of attribute result.
+  #
+  # source://vernier//lib/vernier/result.rb#64
+  def result; end
+
+  # source://vernier//lib/vernier/result.rb#70
+  def to_s; end
+end
+
+# source://vernier//lib/vernier/result.rb#94
+class Vernier::Result::Frame < ::Vernier::Result::BaseType
+  # source://vernier//lib/vernier/result.rb#96
+  def filename; end
+
+  # source://vernier//lib/vernier/result.rb#99
+  def func; end
+
+  # source://vernier//lib/vernier/result.rb#95
+  def label; end
+
+  # source://vernier//lib/vernier/result.rb#104
+  def line; end
+
+  # source://vernier//lib/vernier/result.rb#95
+  def name; end
+
+  # source://vernier//lib/vernier/result.rb#108
+  def to_s; end
+end
+
+# source://vernier//lib/vernier/result.rb#79
+class Vernier::Result::Func < ::Vernier::Result::BaseType
+  # source://vernier//lib/vernier/result.rb#85
+  def filename; end
+
+  # source://vernier//lib/vernier/result.rb#80
+  def label; end
+
+  # source://vernier//lib/vernier/result.rb#80
+  def name; end
+
+  # source://vernier//lib/vernier/result.rb#89
+  def to_s; end
+end
+
+# source://vernier//lib/vernier/result.rb#113
+class Vernier::Result::Stack < ::Vernier::Result::BaseType
+  # source://vernier//lib/vernier/result.rb#114
+  def each_frame; end
+
+  # source://vernier//lib/vernier/result.rb#133
+  def frames; end
+
+  # source://vernier//lib/vernier/result.rb#129
+  def leaf_frame; end
+
+  # source://vernier//lib/vernier/result.rb#125
+  def leaf_frame_idx; end
+
+  # source://vernier//lib/vernier/result.rb#137
+  def to_s; end
+end
+
+# source://vernier//lib/vernier/stack_table.rb#2
+class Vernier::StackTable
+  # source://vernier//lib/vernier/stack_table.rb#25
+  def backtrace(stack_idx); end
+
+  def convert(_arg0, _arg1); end
+  def current_stack(*_arg0); end
+  def frame_count; end
+  def frame_func_idx(_arg0); end
+  def frame_line_no(_arg0); end
+
+  # source://vernier//lib/vernier/stack_table.rb#37
+  def full_stack(stack_idx); end
+
+  def func_count; end
+  def func_filename(_arg0); end
+  def func_first_lineno(_arg0); end
+  def func_name(_arg0); end
+
+  # source://vernier//lib/vernier/stack_table.rb#3
+  def inspect; end
+
+  def stack_count; end
+  def stack_frame_idx(_arg0); end
+  def stack_parent_idx(_arg0); end
+
+  # source://vernier//lib/vernier/stack_table.rb#7
+  def to_h; end
+
+  class << self
+    def new; end
+  end
+end
+
+# Collects names of all seen threads
+#
+# source://vernier//lib/vernier/thread_names.rb#3
+class Vernier::ThreadNames
+  # @return [ThreadNames] a new instance of ThreadNames
+  #
+  # source://vernier//lib/vernier/thread_names.rb#4
+  def initialize; end
+
+  # source://vernier//lib/vernier/thread_names.rb#12
+  def [](object_id); end
+
+  # source://vernier//lib/vernier/thread_names.rb#16
+  def finish; end
+
+  private
+
+  # source://vernier//lib/vernier/thread_names.rb#23
+  def collect_running; end
+
+  # source://vernier//lib/vernier/thread_names.rb#29
+  def collect_thread(th); end
+
+  # source://vernier//lib/vernier/thread_names.rb#33
+  def pretty_name(thread); end
+end
+
+# source://vernier//lib/vernier/version.rb#4
+Vernier::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/warning@1.3.0.rbi b/Library/Homebrew/sorbet/rbi/gems/warning@1.3.0.rbi
deleted file mode 100644
index d27162412d23e..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/warning@1.3.0.rbi
+++ /dev/null
@@ -1,27 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `warning` gem.
-# Please instead update this file by running `bin/tapioca gem warning`.
-
-module Warning
-  extend ::Warning
-  extend ::Warning::Processor
-end
-
-module Warning::Processor
-  def clear; end
-  def dedup; end
-  def freeze; end
-  def ignore(regexp, path = T.unsafe(nil)); end
-  def process(path = T.unsafe(nil), actions = T.unsafe(nil), &block); end
-  def warn(str); end
-
-  private
-
-  def convert_regexp(regexp); end
-  def synchronize(&block); end
-end
-
-Warning::Processor::ACTION_PROC_MAP = T.let(T.unsafe(nil), Hash)
-Warning::Processor::IGNORE_MAP = T.let(T.unsafe(nil), Hash)
diff --git a/Library/Homebrew/sorbet/rbi/gems/warning@1.4.0.rbi b/Library/Homebrew/sorbet/rbi/gems/warning@1.4.0.rbi
new file mode 100644
index 0000000000000..cc47d5eff23ad
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/warning@1.4.0.rbi
@@ -0,0 +1,154 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `warning` gem.
+# Please instead update this file by running `bin/tapioca gem warning`.
+
+
+# source://warning//lib/warning.rb#3
+module Warning
+  extend ::Warning
+  extend ::Warning::Processor
+end
+
+# source://warning//lib/warning.rb#4
+module Warning::Processor
+  # Clear all current ignored warnings, warning processors, and duplicate check cache.
+  # Also disables deduplicating warnings if that is currently enabled.
+  #
+  # If a block is passed, the previous values are restored after the block exits.
+  #
+  # Examples:
+  #
+  #   # Clear warning state
+  #   Warning.clear
+  #
+  #   Warning.clear do
+  #     # Clear warning state inside the block
+  #     ...
+  #   end
+  #   # Previous warning state restored when block exists
+  #
+  # source://warning//lib/warning.rb#49
+  def clear; end
+
+  # Deduplicate warnings, suppress warning messages if the same warning message
+  # has already occurred.  Note that this can lead to unbounded memory use
+  # if unique warnings are generated.
+  #
+  # source://warning//lib/warning.rb#80
+  def dedup; end
+
+  # source://warning//lib/warning.rb#84
+  def freeze; end
+
+  # Ignore any warning messages matching the given regexp, if they
+  # start with the given path.
+  # The regexp can also be one of the following symbols (or an array including them), which will
+  # use an appropriate regexp for the given warning:
+  #
+  # :arg_prefix :: Ignore warnings when using * or & as an argument prefix
+  # :ambiguous_slash :: Ignore warnings for things like <tt>method /regexp/</tt>
+  # :bignum :: Ignore warnings when referencing the ::Bignum constant.
+  # :fixnum :: Ignore warnings when referencing the ::Fixnum constant.
+  # :keyword_separation :: Ignore warnings related to keyword argument separation.
+  # :method_redefined :: Ignore warnings when defining a method in a class/module where a
+  #                      method of the same name was already defined in that class/module.
+  # :missing_gvar :: Ignore warnings for accesses to global variables
+  #                  that have not yet been initialized
+  # :missing_ivar :: Ignore warnings for accesses to instance variables
+  #                  that have not yet been initialized
+  # :not_reached :: Ignore statement not reached warnings.
+  # :safe :: Ignore warnings related to $SAFE and related C-API functions.
+  # :shadow :: Ignore warnings related to shadowing outer local variables.
+  # :taint :: Ignore warnings related to taint and related methods and C-API functions.
+  # :unused_var :: Ignore warnings for unused variables.
+  # :useless_operator :: Ignore warnings when using operators such as == and > when the
+  #                      result is not used.
+  # :void_context :: Ignore warnings for :: to reference constants when the result is not
+  #                  used (often used to trigger autoload).
+  #
+  # Examples:
+  #
+  #   # Ignore all uninitialized instance variable warnings
+  #   Warning.ignore(/instance variable @\w+ not initialized/)
+  #
+  #   # Ignore all uninitialized instance variable warnings in current file
+  #   Warning.ignore(/instance variable @\w+ not initialized/, __FILE__)
+  #
+  #   # Ignore all uninitialized instance variable warnings in current file
+  #   Warning.ignore(:missing_ivar, __FILE__)
+  #
+  #   # Ignore all uninitialized instance variable and method redefined warnings in current file
+  #   Warning.ignore([:missing_ivar, :method_redefined],  __FILE__)
+  #
+  # source://warning//lib/warning.rb#129
+  def ignore(regexp, path = T.unsafe(nil)); end
+
+  # Handle all warnings starting with the given path, instead of
+  # the default behavior of printing them to $stderr. Examples:
+  #
+  #   # Write warning to LOGGER at level warning
+  #   Warning.process do |warning|
+  #     LOGGER.warning(warning)
+  #   end
+  #
+  #   # Write warnings in the current file to LOGGER at level error level
+  #   Warning.process(__FILE__) do |warning|
+  #     LOGGER.error(warning)
+  #   end
+  #
+  # The block can return one of the following symbols:
+  #
+  # :default :: Take the default action (call super, printing to $stderr).
+  # :backtrace :: Take the default action (call super, printing to $stderr),
+  #               and also print the backtrace.
+  # :raise :: Raise a RuntimeError with the warning as the message.
+  #
+  # If the block returns anything else, it is assumed the block completely handled
+  # the warning and takes no other action.
+  #
+  # Instead of passing a block, you can pass a hash of actions to take for specific
+  # warnings, using regexp as keys and a callable objects as values:
+  #
+  #   Warning.process(__FILE__,
+  #     /instance variable @\w+ not initialized/ => proc do |warning|
+  #       LOGGER.warning(warning)
+  #     end,
+  #     /global variable [`']\$\w+' not initialized/ => proc do |warning|
+  #       LOGGER.error(warning)
+  #     end
+  #   )
+  #
+  # Instead of passing a regexp as a key, you can pass a symbol that is recognized
+  # by Warning.ignore.  Instead of passing a callable object as a value, you can
+  # pass a symbol, which will be treated as a callable object that returns that symbol:
+  #
+  #   Warning.process(__FILE__, :missing_ivar=>:backtrace, :keyword_separation=>:raise)
+  #
+  # source://warning//lib/warning.rb#180
+  def process(path = T.unsafe(nil), actions = T.unsafe(nil), &block); end
+
+  # source://warning//lib/warning.rb#221
+  def warn(str, category: T.unsafe(nil)); end
+
+  private
+
+  # Convert the given Regexp, Symbol, or Array of Symbols into a Regexp.
+  #
+  # source://warning//lib/warning.rb#273
+  def convert_regexp(regexp); end
+
+  # source://warning//lib/warning.rb#286
+  def synchronize(&block); end
+end
+
+# Map of action symbols to procs that return the symbol
+#
+# source://warning//lib/warning.rb#27
+Warning::Processor::ACTION_PROC_MAP = T.let(T.unsafe(nil), Hash)
+
+# Map of symbols to regexps for warning messages to ignore.
+#
+# source://warning//lib/warning.rb#6
+Warning::Processor::IGNORE_MAP = T.let(T.unsafe(nil), Hash)
diff --git a/Library/Homebrew/sorbet/rbi/gems/webrick@1.7.0.rbi b/Library/Homebrew/sorbet/rbi/gems/webrick@1.7.0.rbi
deleted file mode 100644
index 63755aa3aa139..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/webrick@1.7.0.rbi
+++ /dev/null
@@ -1,601 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `webrick` gem.
-# Please instead update this file by running `bin/tapioca gem webrick`.
-
-module WEBrick::AccessLog
-  private
-
-  def escape(data); end
-  def format(format_string, params); end
-  def setup_params(config, req, res); end
-
-  class << self
-    def escape(data); end
-    def format(format_string, params); end
-    def setup_params(config, req, res); end
-  end
-end
-
-class WEBrick::BasicLog
-  def initialize(log_file = T.unsafe(nil), level = T.unsafe(nil)); end
-
-  def <<(obj); end
-  def close; end
-  def debug(msg); end
-  def debug?; end
-  def error(msg); end
-  def error?; end
-  def fatal(msg); end
-  def fatal?; end
-  def info(msg); end
-  def info?; end
-  def level; end
-  def level=(_arg0); end
-  def log(level, data); end
-  def warn(msg); end
-  def warn?; end
-
-  private
-
-  def format(arg); end
-end
-
-class WEBrick::GenericServer
-  def initialize(config = T.unsafe(nil), default = T.unsafe(nil)); end
-
-  def [](key); end
-  def config; end
-  def listen(address, port); end
-  def listeners; end
-  def logger; end
-  def run(sock); end
-  def shutdown; end
-  def start(&block); end
-  def status; end
-  def stop; end
-  def tokens; end
-
-  private
-
-  def accept_client(svr); end
-  def alarm_shutdown_pipe; end
-  def call_callback(callback_name, *args); end
-  def cleanup_listener; end
-  def cleanup_shutdown_pipe(shutdown_pipe); end
-  def setup_shutdown_pipe; end
-  def start_thread(sock, &block); end
-end
-
-module WEBrick::HTMLUtils
-  private
-
-  def escape(string); end
-
-  class << self
-    def escape(string); end
-  end
-end
-
-module WEBrick::HTTPAuth
-  private
-
-  def _basic_auth(req, res, realm, req_field, res_field, err_type, block); end
-  def basic_auth(req, res, realm, &block); end
-  def proxy_basic_auth(req, res, realm, &block); end
-
-  class << self
-    def _basic_auth(req, res, realm, req_field, res_field, err_type, block); end
-    def basic_auth(req, res, realm, &block); end
-    def proxy_basic_auth(req, res, realm, &block); end
-  end
-end
-
-module WEBrick::HTTPAuth::Authenticator
-  def logger; end
-  def realm; end
-  def userdb; end
-
-  private
-
-  def check_init(config); end
-  def check_scheme(req); end
-  def error(fmt, *args); end
-  def info(fmt, *args); end
-  def log(meth, fmt, *args); end
-end
-
-WEBrick::HTTPAuth::Authenticator::AuthException = WEBrick::HTTPStatus::Unauthorized
-
-class WEBrick::HTTPAuth::BasicAuth
-  include ::WEBrick::HTTPAuth::Authenticator
-
-  def initialize(config, default = T.unsafe(nil)); end
-
-  def authenticate(req, res); end
-  def challenge(req, res); end
-  def logger; end
-  def realm; end
-  def userdb; end
-
-  class << self
-    def make_passwd(realm, user, pass); end
-  end
-end
-
-class WEBrick::HTTPAuth::DigestAuth
-  include ::WEBrick::HTTPAuth::Authenticator
-
-  def initialize(config, default = T.unsafe(nil)); end
-
-  def algorithm; end
-  def authenticate(req, res); end
-  def challenge(req, res, stale = T.unsafe(nil)); end
-  def qop; end
-
-  private
-
-  def _authenticate(req, res); end
-  def check_nonce(req, auth_req); end
-  def check_opaque(opaque_struct, req, auth_req); end
-  def check_uri(req, auth_req); end
-  def generate_next_nonce(req); end
-  def generate_opaque(req); end
-  def hexdigest(*args); end
-  def split_param_value(string); end
-
-  class << self
-    def make_passwd(realm, user, pass); end
-  end
-end
-
-class WEBrick::HTTPAuth::DigestAuth::OpaqueInfo < ::Struct
-  def nc=(_); end
-  def nonce=(_); end
-  def time=(_); end
-end
-
-class WEBrick::HTTPAuth::Htdigest
-  include ::WEBrick::HTTPAuth::UserDB
-
-  def initialize(path); end
-
-  def delete_passwd(realm, user); end
-  def each; end
-  def flush(output = T.unsafe(nil)); end
-  def get_passwd(realm, user, reload_db); end
-  def reload; end
-  def set_passwd(realm, user, pass); end
-end
-
-class WEBrick::HTTPAuth::Htgroup
-  def initialize(path); end
-
-  def add(group, members); end
-  def flush(output = T.unsafe(nil)); end
-  def members(group); end
-  def reload; end
-end
-
-class WEBrick::HTTPAuth::Htpasswd
-  include ::WEBrick::HTTPAuth::UserDB
-
-  def initialize(path, password_hash: T.unsafe(nil)); end
-
-  def delete_passwd(realm, user); end
-  def each; end
-  def flush(output = T.unsafe(nil)); end
-  def get_passwd(realm, user, reload_db); end
-  def reload; end
-  def set_passwd(realm, user, pass); end
-end
-
-WEBrick::HTTPAuth::ProxyAuthenticator::AuthException = WEBrick::HTTPStatus::ProxyAuthenticationRequired
-
-class WEBrick::HTTPAuth::ProxyBasicAuth < ::WEBrick::HTTPAuth::BasicAuth
-  include ::WEBrick::HTTPAuth::ProxyAuthenticator
-end
-
-class WEBrick::HTTPAuth::ProxyDigestAuth < ::WEBrick::HTTPAuth::DigestAuth
-  include ::WEBrick::HTTPAuth::ProxyAuthenticator
-
-  private
-
-  def check_uri(req, auth_req); end
-end
-
-module WEBrick::HTTPAuth::UserDB
-  def auth_type; end
-  def auth_type=(_arg0); end
-  def get_passwd(realm, user, reload_db = T.unsafe(nil)); end
-  def make_passwd(realm, user, pass); end
-  def set_passwd(realm, user, pass); end
-end
-
-class WEBrick::HTTPRequest
-  def initialize(config); end
-
-  def [](header_name); end
-  def accept; end
-  def accept_charset; end
-  def accept_encoding; end
-  def accept_language; end
-  def addr; end
-  def attributes; end
-  def body(&block); end
-  def body_reader; end
-  def content_length; end
-  def content_type; end
-  def continue; end
-  def cookies; end
-  def each; end
-  def fixup; end
-  def header; end
-  def host; end
-  def http_version; end
-  def keep_alive; end
-  def keep_alive?; end
-  def meta_vars; end
-  def parse(socket = T.unsafe(nil)); end
-  def path; end
-  def path_info; end
-  def path_info=(_arg0); end
-  def peeraddr; end
-  def port; end
-  def query; end
-  def query_string; end
-  def query_string=(_arg0); end
-  def raw_header; end
-  def readpartial(size, buf = T.unsafe(nil)); end
-  def remote_ip; end
-  def request_line; end
-  def request_method; end
-  def request_time; end
-  def request_uri; end
-  def script_name; end
-  def script_name=(_arg0); end
-  def server_name; end
-  def ssl?; end
-  def to_s; end
-  def unparsed_uri; end
-  def user; end
-  def user=(_arg0); end
-
-  private
-
-  def _read_data(io, method, *arg); end
-  def parse_query; end
-  def parse_uri(str, scheme = T.unsafe(nil)); end
-  def read_body(socket, block); end
-  def read_chunk_size(socket); end
-  def read_chunked(socket, block); end
-  def read_data(io, size); end
-  def read_header(socket); end
-  def read_line(io, size = T.unsafe(nil)); end
-  def read_request_line(socket); end
-  def setup_forwarded_info; end
-end
-
-WEBrick::HTTPRequest::MAX_HEADER_LENGTH = T.let(T.unsafe(nil), Integer)
-
-class WEBrick::HTTPResponse
-  def initialize(config); end
-
-  def [](field); end
-  def []=(field, value); end
-  def _rack_setup_header; end
-  def body; end
-  def body=(_arg0); end
-  def chunked=(val); end
-  def chunked?; end
-  def config; end
-  def content_length; end
-  def content_length=(len); end
-  def content_type; end
-  def content_type=(type); end
-  def cookies; end
-  def each; end
-  def filename; end
-  def filename=(_arg0); end
-  def header; end
-  def http_version; end
-  def keep_alive; end
-  def keep_alive=(_arg0); end
-  def keep_alive?; end
-  def make_body_tempfile; end
-  def reason_phrase; end
-  def reason_phrase=(_arg0); end
-  def remove_body_tempfile; end
-  def request_http_version; end
-  def request_http_version=(_arg0); end
-  def request_method; end
-  def request_method=(_arg0); end
-  def request_uri; end
-  def request_uri=(_arg0); end
-  def send_body(socket); end
-  def send_header(socket); end
-  def send_response(socket); end
-  def sent_size; end
-  def set_error(ex, backtrace = T.unsafe(nil)); end
-  def set_redirect(status, url); end
-  def status; end
-  def status=(status); end
-  def status_line; end
-
-  private
-
-  def _write_data(socket, data); end
-  def check_header(header_value); end
-  def error_body(backtrace, ex, host, port); end
-  def send_body_io(socket); end
-  def send_body_proc(socket); end
-  def send_body_string(socket); end
-end
-
-class WEBrick::HTTPResponse::ChunkedWrapper
-  def initialize(socket, resp); end
-
-  def <<(*buf); end
-  def write(buf); end
-end
-
-class WEBrick::HTTPServer < ::WEBrick::GenericServer
-  def initialize(config = T.unsafe(nil), default = T.unsafe(nil)); end
-
-  def access_log(config, req, res); end
-  def create_request(with_webrick_config); end
-  def create_response(with_webrick_config); end
-  def do_OPTIONS(req, res); end
-  def lookup_server(req); end
-  def mount(dir, servlet, *options); end
-  def mount_proc(dir, proc = T.unsafe(nil), &block); end
-  def run(sock); end
-  def search_servlet(path); end
-  def service(req, res); end
-  def umount(dir); end
-  def unmount(dir); end
-  def virtual_host(server); end
-end
-
-class WEBrick::HTTPServer::MountTable
-  def initialize; end
-
-  def [](dir); end
-  def []=(dir, val); end
-  def delete(dir); end
-  def scan(path); end
-
-  private
-
-  def compile; end
-  def normalize(dir); end
-end
-
-class WEBrick::HTTPServlet::AbstractServlet
-  def initialize(server, *options); end
-
-  def do_GET(req, res); end
-  def do_HEAD(req, res); end
-  def do_OPTIONS(req, res); end
-  def service(req, res); end
-
-  private
-
-  def redirect_to_directory_uri(req, res); end
-
-  class << self
-    def get_instance(server, *options); end
-  end
-end
-
-class WEBrick::HTTPServlet::CGIHandler < ::WEBrick::HTTPServlet::AbstractServlet
-  def initialize(server, name); end
-
-  def do_GET(req, res); end
-  def do_POST(req, res); end
-end
-
-WEBrick::HTTPServlet::CGIHandler::CGIRunnerArray = T.let(T.unsafe(nil), Array)
-
-class WEBrick::HTTPServlet::DefaultFileHandler < ::WEBrick::HTTPServlet::AbstractServlet
-  def initialize(server, local_path); end
-
-  def do_GET(req, res); end
-  def make_partial_content(req, res, filename, filesize); end
-  def multipart_body(body, parts, boundary, mtype, filesize); end
-  def not_modified?(req, res, mtime, etag); end
-  def prepare_range(range, filesize); end
-end
-
-class WEBrick::HTTPServlet::ERBHandler < ::WEBrick::HTTPServlet::AbstractServlet
-  def initialize(server, name); end
-
-  def do_GET(req, res); end
-  def do_POST(req, res); end
-
-  private
-
-  def evaluate(erb, servlet_request, servlet_response); end
-end
-
-class WEBrick::HTTPServlet::FileHandler < ::WEBrick::HTTPServlet::AbstractServlet
-  def initialize(server, root, options = T.unsafe(nil), default = T.unsafe(nil)); end
-
-  def do_GET(req, res); end
-  def do_OPTIONS(req, res); end
-  def do_POST(req, res); end
-  def service(req, res); end
-  def set_filesystem_encoding(str); end
-
-  private
-
-  def call_callback(callback_name, req, res); end
-  def check_filename(req, res, name); end
-  def exec_handler(req, res); end
-  def get_handler(req, res); end
-  def nondisclosure_name?(name); end
-  def prevent_directory_traversal(req, res); end
-  def search_file(req, res, basename); end
-  def search_index_file(req, res); end
-  def set_dir_list(req, res); end
-  def set_filename(req, res); end
-  def shift_path_info(req, res, path_info, base = T.unsafe(nil)); end
-  def trailing_pathsep?(path); end
-  def windows_ambiguous_name?(name); end
-
-  class << self
-    def add_handler(suffix, handler); end
-    def remove_handler(suffix); end
-  end
-end
-
-module WEBrick::HTTPStatus
-  private
-
-  def client_error?(code); end
-  def error?(code); end
-  def info?(code); end
-  def reason_phrase(code); end
-  def redirect?(code); end
-  def server_error?(code); end
-  def success?(code); end
-
-  class << self
-    def [](code); end
-    def client_error?(code); end
-    def error?(code); end
-    def info?(code); end
-    def reason_phrase(code); end
-    def redirect?(code); end
-    def server_error?(code); end
-    def success?(code); end
-  end
-end
-
-class WEBrick::HTTPStatus::Status < ::StandardError
-  def code; end
-  def reason_phrase; end
-  def to_i; end
-
-  class << self
-    def code; end
-    def reason_phrase; end
-  end
-end
-
-module WEBrick::HTTPUtils
-  private
-
-  def _escape(str, regex); end
-  def _make_regex(str); end
-  def _make_regex!(str); end
-  def _unescape(str, regex); end
-  def dequote(str); end
-  def escape(str); end
-  def escape8bit(str); end
-  def escape_form(str); end
-  def escape_path(str); end
-  def load_mime_types(file); end
-  def mime_type(filename, mime_tab); end
-  def normalize_path(path); end
-  def parse_form_data(io, boundary); end
-  def parse_header(raw); end
-  def parse_query(str); end
-  def parse_qvalues(value); end
-  def parse_range_header(ranges_specifier); end
-  def quote(str); end
-  def split_header_value(str); end
-  def unescape(str); end
-  def unescape_form(str); end
-
-  class << self
-    def _escape(str, regex); end
-    def _make_regex(str); end
-    def _make_regex!(str); end
-    def _unescape(str, regex); end
-    def dequote(str); end
-    def escape(str); end
-    def escape8bit(str); end
-    def escape_form(str); end
-    def escape_path(str); end
-    def load_mime_types(file); end
-    def mime_type(filename, mime_tab); end
-    def normalize_path(path); end
-    def parse_form_data(io, boundary); end
-    def parse_header(raw); end
-    def parse_query(str); end
-    def parse_qvalues(value); end
-    def parse_range_header(ranges_specifier); end
-    def quote(str); end
-    def split_header_value(str); end
-    def unescape(str); end
-    def unescape_form(str); end
-  end
-end
-
-class WEBrick::HTTPUtils::FormData < ::String
-  def initialize(*args); end
-
-  def <<(str); end
-  def [](*key); end
-  def append_data(data); end
-  def each_data; end
-  def filename; end
-  def filename=(_arg0); end
-  def list; end
-  def name; end
-  def name=(_arg0); end
-  def next_data=(_arg0); end
-  def to_ary; end
-  def to_s; end
-
-  protected
-
-  def next_data; end
-end
-
-module WEBrick::Utils
-  private
-
-  def create_listeners(address, port); end
-  def getservername; end
-  def random_string(len); end
-  def set_close_on_exec(io); end
-  def set_non_blocking(io); end
-  def su(user); end
-  def timeout(seconds, exception = T.unsafe(nil)); end
-
-  class << self
-    def create_listeners(address, port); end
-    def getservername; end
-    def random_string(len); end
-    def set_close_on_exec(io); end
-    def set_non_blocking(io); end
-    def su(user); end
-    def timeout(seconds, exception = T.unsafe(nil)); end
-  end
-end
-
-class WEBrick::Utils::TimeoutHandler
-  include ::Singleton
-  extend ::Singleton::SingletonClassMethods
-
-  def initialize; end
-
-  def cancel(thread, id); end
-  def interrupt(thread, id, exception); end
-  def register(thread, time, exception); end
-  def terminate; end
-
-  private
-
-  def watch; end
-  def watcher; end
-
-  class << self
-    def cancel(id); end
-    def register(seconds, exception); end
-    def terminate; end
-  end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.6.1.rbi b/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.6.1.rbi
deleted file mode 100644
index ca4ab82082657..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.6.1.rbi
+++ /dev/null
@@ -1,235 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `yard-sorbet` gem.
-# Please instead update this file by running `bin/tapioca gem yard-sorbet`.
-
-module YARDSorbet; end
-
-module YARDSorbet::Directives
-  class << self
-    sig { params(docstring: ::String, directives: T::Array[::String]).void }
-    def add_directives(docstring, directives); end
-
-    sig { params(docstring: T.nilable(::String)).returns([::YARD::Docstring, T::Array[::String]]) }
-    def extract_directives(docstring); end
-  end
-end
-
-module YARDSorbet::Handlers; end
-
-class YARDSorbet::Handlers::AbstractDSLHandler < ::YARD::Handlers::Ruby::Base
-  sig { void }
-  def process; end
-end
-
-YARDSorbet::Handlers::AbstractDSLHandler::CLASS_TAG_TEXT = T.let(T.unsafe(nil), String)
-YARDSorbet::Handlers::AbstractDSLHandler::TAG_TEXT = T.let(T.unsafe(nil), String)
-
-class YARDSorbet::Handlers::EnumsHandler < ::YARD::Handlers::Ruby::Base
-  sig { void }
-  def process; end
-
-  private
-
-  sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Boolean) }
-  def const_assign_node?(node); end
-end
-
-class YARDSorbet::Handlers::IncludeHandler < ::YARD::Handlers::Ruby::Base
-  sig { void }
-  def process; end
-
-  private
-
-  sig { returns(::YARD::CodeObjects::NamespaceObject) }
-  def included_in; end
-end
-
-class YARDSorbet::Handlers::MixesInClassMethodsHandler < ::YARD::Handlers::Ruby::Base
-  sig { void }
-  def process; end
-
-  class << self
-    sig { params(code_obj: ::String).returns(T.nilable(::String)) }
-    def mixed_in_class_methods(code_obj); end
-  end
-end
-
-class YARDSorbet::Handlers::SigHandler < ::YARD::Handlers::Ruby::Base
-  sig { void }
-  def process; end
-
-  private
-
-  sig do
-    params(
-      method_node: ::YARD::Parser::Ruby::AstNode,
-      node: ::YARD::Parser::Ruby::AstNode,
-      docstring: ::YARD::Docstring
-    ).void
-  end
-  def parse_params(method_node, node, docstring); end
-
-  sig { params(node: ::YARD::Parser::Ruby::AstNode, docstring: ::YARD::Docstring).void }
-  def parse_return(node, docstring); end
-
-  sig { params(method_node: ::YARD::Parser::Ruby::AstNode, docstring: ::YARD::Docstring).void }
-  def parse_sig(method_node, docstring); end
-end
-
-YARDSorbet::Handlers::SigHandler::ATTR_NODE_TYPES = T.let(T.unsafe(nil), Array)
-
-module YARDSorbet::Handlers::StructClassHandler
-  sig { void }
-  def process; end
-
-  private
-
-  sig do
-    params(
-      object: ::YARD::CodeObjects::MethodObject,
-      props: T::Array[::YARDSorbet::TStructProp],
-      docstring: ::YARD::Docstring,
-      directives: T::Array[::String]
-    ).void
-  end
-  def decorate_t_struct_init(object, props, docstring, directives); end
-
-  sig { params(props: T::Array[::YARDSorbet::TStructProp], class_ns: ::YARD::CodeObjects::ClassObject).void }
-  def process_t_struct_props(props, class_ns); end
-
-  sig { params(props: T::Array[::YARDSorbet::TStructProp]).returns(T::Array[[::String, T.nilable(::String)]]) }
-  def to_object_parameters(props); end
-end
-
-class YARDSorbet::Handlers::StructPropHandler < ::YARD::Handlers::Ruby::Base
-  sig { void }
-  def process; end
-
-  private
-
-  sig { params(object: ::YARD::CodeObjects::MethodObject, prop: ::YARDSorbet::TStructProp).void }
-  def decorate_object(object, prop); end
-
-  sig { returns(T.nilable(::String)) }
-  def default_value; end
-
-  sig { params(name: ::String).returns(::YARDSorbet::TStructProp) }
-  def make_prop(name); end
-
-  sig { params(object: ::YARD::CodeObjects::MethodObject, name: ::String).void }
-  def register_attrs(object, name); end
-
-  sig { params(prop: ::YARDSorbet::TStructProp).void }
-  def update_state(prop); end
-end
-
-module YARDSorbet::NodeUtils
-  class << self
-    sig do
-      params(
-        node: ::YARD::Parser::Ruby::AstNode,
-        _blk: T.proc.params(n: ::YARD::Parser::Ruby::AstNode).void
-      ).void
-    end
-    def bfs_traverse(node, &_blk); end
-
-    sig do
-      params(
-        node: ::YARD::Parser::Ruby::AstNode
-      ).returns(T.any(::YARD::Parser::Ruby::MethodCallNode, ::YARD::Parser::Ruby::MethodDefinitionNode))
-    end
-    def get_method_node(node); end
-
-    sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(::YARD::Parser::Ruby::AstNode) }
-    def sibling_node(node); end
-  end
-end
-
-YARDSorbet::NodeUtils::ATTRIBUTE_METHODS = T.let(T.unsafe(nil), Array)
-YARDSorbet::NodeUtils::SIGABLE_NODE = T.type_alias { T.any(::YARD::Parser::Ruby::MethodCallNode, ::YARD::Parser::Ruby::MethodDefinitionNode) }
-YARDSorbet::NodeUtils::SKIP_METHOD_CONTENTS = T.let(T.unsafe(nil), Array)
-
-module YARDSorbet::SigToYARD
-  class << self
-    sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
-    def convert(node); end
-
-    private
-
-    sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(::String) }
-    def build_generic_type(node); end
-
-    sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
-    def convert_aref(node); end
-
-    sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
-    def convert_array(node); end
-
-    sig { params(node: ::YARD::Parser::Ruby::MethodCallNode).returns(T::Array[::String]) }
-    def convert_call(node); end
-
-    sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
-    def convert_collection(node); end
-
-    sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
-    def convert_hash(node); end
-
-    sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
-    def convert_list(node); end
-
-    sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
-    def convert_node(node); end
-
-    sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
-    def convert_node_type(node); end
-
-    sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
-    def convert_ref(node); end
-
-    sig { params(node: ::YARD::Parser::Ruby::MethodCallNode).returns(T::Array[::String]) }
-    def convert_t_method(node); end
-
-    sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
-    def convert_unknown(node); end
-  end
-end
-
-class YARDSorbet::TStructProp < ::T::Struct
-  const :default, T.nilable(::String)
-  const :doc, ::String
-  const :prop_name, ::String
-  const :source, ::String
-  const :types, T::Array[::String]
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-module YARDSorbet::TagUtils
-  class << self
-    sig do
-      params(
-        docstring: ::YARD::Docstring,
-        tag_name: ::String,
-        name: T.nilable(::String)
-      ).returns(T.nilable(::YARD::Tags::Tag))
-    end
-    def find_tag(docstring, tag_name, name); end
-
-    sig do
-      params(
-        docstring: ::YARD::Docstring,
-        tag_name: ::String,
-        types: T.nilable(T::Array[::String]),
-        name: T.nilable(::String),
-        text: ::String
-      ).void
-    end
-    def upsert_tag(docstring, tag_name, types = T.unsafe(nil), name = T.unsafe(nil), text = T.unsafe(nil)); end
-  end
-end
-
-YARDSorbet::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/yard@0.9.28.rbi b/Library/Homebrew/sorbet/rbi/gems/yard@0.9.28.rbi
deleted file mode 100644
index 0a9df757b5403..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/yard@0.9.28.rbi
+++ /dev/null
@@ -1,3952 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `yard` gem.
-# Please instead update this file by running `bin/tapioca gem yard`.
-
-class Array
-  include ::Enumerable
-  include ::JSON::Ext::Generator::GeneratorMethods::Array
-  include ::Plist::Emit
-  include ::MessagePack::CoreExt
-
-  def place(*values); end
-end
-
-class File < ::IO
-  class << self
-    def cleanpath(path, rel_root = T.unsafe(nil)); end
-    def open!(file, *args, &block); end
-    def read_binary(file); end
-    def relative_path(from, to); end
-  end
-end
-
-File::RELATIVE_PARENTDIR = T.let(T.unsafe(nil), String)
-File::RELATIVE_SAMEDIR = T.let(T.unsafe(nil), String)
-
-module Gem
-  class << self
-    def source_index; end
-  end
-end
-
-Gem::Cache = Gem::SourceIndex
-Gem::ConfigMap = T.let(T.unsafe(nil), Hash)
-Gem::RbConfigPriorities = T.let(T.unsafe(nil), Array)
-Gem::RubyGemsPackageVersion = T.let(T.unsafe(nil), String)
-Gem::RubyGemsVersion = T.let(T.unsafe(nil), String)
-
-class Gem::SourceIndex
-  include ::Enumerable
-
-  def initialize(specifications = T.unsafe(nil)); end
-
-  def ==(other); end
-  def add_spec(gem_spec, name = T.unsafe(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 = T.unsafe(nil)); end
-  def gem_signature(gem_full_name); end
-  def gems; end
-  def index_signature; end
-  def latest_specs(include_prerelease = T.unsafe(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 = T.unsafe(nil)); end
-  def size; end
-  def spec_dirs; end
-  def spec_dirs=(_arg0); end
-  def specification(full_name); end
-
-  class << self
-    def from_gems_in(*spec_dirs); end
-    def from_installed_gems(*deprecated); end
-    def installed_spec_directories; end
-    def load_specification(file_name); end
-  end
-end
-
-Gem::USE_BUNDLER_FOR_GEMDEPS = T.let(T.unsafe(nil), TrueClass)
-Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError
-
-class IRB::SLex
-  def initialize; end
-
-  def create(token, preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end
-  def def_rule(token, preproc = T.unsafe(nil), postproc = T.unsafe(nil), &block); end
-  def def_rules(*tokens, &block); end
-  def inspect; end
-  def match(token); end
-  def postproc(token); end
-  def preproc(token, proc); end
-  def search(token); end
-end
-
-IRB::SLex::DOUT = T.let(T.unsafe(nil), IRB::Notifier::CompositeNotifier)
-IRB::SLex::D_DEBUG = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier)
-IRB::SLex::D_DETAIL = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier)
-IRB::SLex::D_WARN = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier)
-
-class IRB::SLex::Node
-  def initialize(preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end
-
-  def create_subnode(chrs, preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end
-  def match(chrs, op = T.unsafe(nil)); end
-  def match_io(io, op = T.unsafe(nil)); end
-  def postproc; end
-  def postproc=(_arg0); end
-  def preproc; end
-  def preproc=(_arg0); end
-  def search(chrs, opt = T.unsafe(nil)); end
-end
-
-class Insertion
-  def initialize(list, value); end
-
-  def after(val, recursive = T.unsafe(nil)); end
-  def after_any(val); end
-  def before(val, recursive = T.unsafe(nil)); end
-  def before_any(val); end
-
-  private
-
-  def insertion(val, rel, recursive = T.unsafe(nil), list = T.unsafe(nil)); end
-end
-
-class Module
-  include ::ActiveSupport::Dependencies::ModuleConstMissing
-
-  def class_name; end
-end
-
-Module::DELEGATION_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
-Module::DELEGATION_RESERVED_METHOD_NAMES = T.let(T.unsafe(nil), Set)
-Module::RUBY_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
-RUBY19 = T.let(T.unsafe(nil), TrueClass)
-
-class Rack::Request
-  include ::Rack::Request::Env
-  include ::Rack::Request::Helpers
-
-  def initialize(env); end
-
-  def delete_param(k); end
-  def params; end
-  def query; end
-  def update_param(k, v); end
-  def version_supplied; end
-  def version_supplied=(_arg0); end
-  def xhr?; end
-
-  class << self
-    def ip_filter; end
-    def ip_filter=(_arg0); end
-  end
-end
-
-Rack::Request::ALLOWED_SCHEMES = T.let(T.unsafe(nil), Array)
-Rack::Request::SCHEME_WHITELIST = T.let(T.unsafe(nil), Array)
-
-class String
-  include ::Comparable
-  include ::JSON::Ext::Generator::GeneratorMethods::String
-  include ::MessagePack::CoreExt
-  extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
-
-  def shell_split; end
-end
-
-String::BLANK_RE = T.let(T.unsafe(nil), Regexp)
-String::ENCODED_BLANKS = T.let(T.unsafe(nil), Concurrent::Map)
-
-class SymbolHash < ::Hash
-  def initialize(symbolize_value = T.unsafe(nil)); end
-
-  def [](key); end
-  def []=(key, value); end
-  def delete(key); end
-  def has_key?(key); end
-  def key?(key); end
-  def merge(hash); end
-  def merge!(hash); end
-  def update(hash); end
-
-  class << self
-    def [](*hsh); end
-  end
-end
-
-class WEBrick::HTTPRequest
-  def version_supplied; end
-  def version_supplied=(_arg0); end
-  def xhr?; end
-end
-
-WEBrick::HTTPRequest::MAX_HEADER_LENGTH = T.let(T.unsafe(nil), Integer)
-
-module YARD
-  class << self
-    def load_plugins; end
-    def parse(*args); end
-    def parse_string(*args); end
-    def ruby18?; end
-    def ruby19?; end
-    def ruby2?; end
-    def ruby31?; end
-    def ruby3?; end
-    def windows?; end
-  end
-end
-
-module YARD::CLI; end
-
-class YARD::CLI::Command
-  def description; end
-
-  protected
-
-  def common_options(opts); end
-  def load_script(file); end
-  def parse_options(opts, args); end
-  def unrecognized_option(err); end
-
-  class << self
-    def run(*args); end
-  end
-end
-
-class YARD::CLI::CommandParser
-  def initialize; end
-
-  def run(*args); end
-
-  private
-
-  def commands; end
-  def list_commands; end
-
-  class << self
-    def commands; end
-    def commands=(_arg0); end
-    def default_command; end
-    def default_command=(_arg0); end
-    def run(*args); end
-  end
-end
-
-class YARD::CLI::Config < ::YARD::CLI::Command
-  def initialize; end
-
-  def append; end
-  def append=(_arg0); end
-  def as_list; end
-  def as_list=(_arg0); end
-  def description; end
-  def gem_install_cmd; end
-  def gem_install_cmd=(_arg0); end
-  def key; end
-  def key=(_arg0); end
-  def reset; end
-  def reset=(_arg0); end
-  def run(*args); end
-  def values; end
-  def values=(_arg0); end
-
-  private
-
-  def configure_gemrc; end
-  def encode_value(value); end
-  def encode_values; end
-  def list_configuration; end
-  def modify_item; end
-  def optparse(*args); end
-  def view_item; end
-end
-
-class YARD::CLI::Diff < ::YARD::CLI::Command
-  def initialize; end
-
-  def description; end
-  def run(*args); end
-
-  private
-
-  def added_objects(registry1, registry2); end
-  def all_objects; end
-  def cleanup(gemfile); end
-  def expand_and_parse(gemfile, io); end
-  def expand_gem(gemfile, io); end
-  def generate_yardoc(dir); end
-  def load_gem_data(gemfile); end
-  def load_git_commit(commit); end
-  def modified_objects(registry1, registry2); end
-  def optparse(*args); end
-  def removed_objects(registry1, registry2); end
-  def require_rubygems; end
-end
-
-class YARD::CLI::Display < ::YARD::CLI::Yardoc
-  def initialize(*args); end
-
-  def description; end
-  def format_objects; end
-  def output_options(opts); end
-  def parse_arguments(*args); end
-  def run(*args); end
-  def wrap_layout(contents); end
-end
-
-class YARD::CLI::Gems < ::YARD::CLI::Command
-  def initialize; end
-
-  def description; end
-  def run(*args); end
-
-  private
-
-  def add_gems(gems); end
-  def build_gems; end
-  def optparse(*args); end
-end
-
-class YARD::CLI::Graph < ::YARD::CLI::YardoptsCommand
-  def initialize; end
-
-  def description; end
-  def objects; end
-  def options; end
-  def run(*args); end
-
-  private
-
-  def optparse(*args); end
-  def unrecognized_option(err); end
-end
-
-class YARD::CLI::GraphOptions < ::YARD::Templates::TemplateOptions
-  def contents; end
-  def contents=(_arg0); end
-  def dependencies; end
-  def dependencies=(_arg0); end
-  def format; end
-  def format=(_arg0); end
-  def full; end
-  def full=(_arg0); end
-end
-
-class YARD::CLI::Help < ::YARD::CLI::Command
-  def description; end
-  def run(*args); end
-end
-
-class YARD::CLI::I18n < ::YARD::CLI::Yardoc
-  def initialize; end
-
-  def description; end
-  def run(*args); end
-
-  private
-
-  def general_options(opts); end
-  def generate_pot(relative_base_path); end
-end
-
-class YARD::CLI::List < ::YARD::CLI::Command
-  def description; end
-  def run(*args); end
-end
-
-class YARD::CLI::MarkupTypes < ::YARD::CLI::Command
-  def description; end
-  def run(*args); end
-end
-
-class YARD::CLI::Server < ::YARD::CLI::Command
-  def initialize; end
-
-  def adapter; end
-  def adapter=(_arg0); end
-  def description; end
-  def libraries; end
-  def libraries=(_arg0); end
-  def options; end
-  def options=(_arg0); end
-  def run(*args); end
-  def scripts; end
-  def scripts=(_arg0); end
-  def server_options; end
-  def server_options=(_arg0); end
-  def template_paths; end
-  def template_paths=(_arg0); end
-
-  private
-
-  def add_gems; end
-  def add_gems_from_gemfile(gemfile = T.unsafe(nil)); end
-  def add_libraries(args); end
-  def create_library_version_if_yardopts_exist(library, dir); end
-  def extract_db_from_options_file(options_file); end
-  def generate_doc_for_first_time(libver); end
-  def load_scripts; end
-  def load_template_paths; end
-  def optparse(*args); end
-  def select_adapter; end
-end
-
-class YARD::CLI::Stats < ::YARD::CLI::Yardoc
-  include ::YARD::Templates::Helpers::BaseHelper
-
-  def initialize(parse = T.unsafe(nil)); end
-
-  def all_objects; end
-  def description; end
-  def output(name, data, undoc = T.unsafe(nil)); end
-  def parse; end
-  def parse=(_arg0); end
-  def print_statistics; end
-  def print_undocumented_objects; end
-  def run(*args); end
-  def stats_for_attributes; end
-  def stats_for_classes; end
-  def stats_for_constants; end
-  def stats_for_files; end
-  def stats_for_methods; end
-  def stats_for_modules; end
-
-  private
-
-  def general_options(opts); end
-  def optparse(*args); end
-  def type_statistics(type); end
-end
-
-YARD::CLI::Stats::STATS_ORDER = T.let(T.unsafe(nil), Array)
-
-class YARD::CLI::YRI < ::YARD::CLI::Command
-  def initialize; end
-
-  def description; end
-  def run(*args); end
-
-  protected
-
-  def cache_object(name, path); end
-  def find_object(name); end
-  def print_object(object); end
-  def print_usage; end
-
-  private
-
-  def add_default_paths; end
-  def add_gem_paths; end
-  def load_cache; end
-  def optparse(*args); end
-  def try_load_object(name, cache_path); end
-
-  class << self
-    def run(*args); end
-  end
-end
-
-YARD::CLI::YRI::CACHE_FILE = T.let(T.unsafe(nil), String)
-YARD::CLI::YRI::DEFAULT_SEARCH_PATHS = T.let(T.unsafe(nil), Array)
-YARD::CLI::YRI::SEARCH_PATHS_FILE = T.let(T.unsafe(nil), String)
-
-class YARD::CLI::Yardoc < ::YARD::CLI::YardoptsCommand
-  def initialize; end
-
-  def all_objects; end
-  def apis; end
-  def apis=(_arg0); end
-  def assets; end
-  def assets=(_arg0); end
-  def description; end
-  def excluded; end
-  def excluded=(_arg0); end
-  def fail_on_warning; end
-  def fail_on_warning=(_arg0); end
-  def files; end
-  def files=(_arg0); 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 list; end
-  def list=(_arg0); end
-  def options; end
-  def parse_arguments(*args); end
-  def run(*args); end
-  def save_yardoc; end
-  def save_yardoc=(_arg0); end
-  def statistics; end
-  def statistics=(_arg0); end
-  def use_cache; end
-  def use_cache=(_arg0); end
-  def visibilities; end
-  def visibilities=(_arg0); end
-
-  private
-
-  def add_api_verifier; end
-  def add_extra_files(*files); end
-  def add_tag(tag_data, factory_method = T.unsafe(nil)); end
-  def add_visibility_verifier; end
-  def apply_locale; end
-  def copy_assets; end
-  def extra_file_valid?(file, check_exists = T.unsafe(nil)); end
-  def general_options(opts); end
-  def optparse(*args); end
-  def output_options(opts); end
-  def parse_files(*files); end
-  def print_list; end
-  def run_generate(checksums); end
-  def run_verifier(list); end
-  def tag_options(opts); end
-  def verify_markup_options; 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::YardoptsCommand < ::YARD::CLI::Command
-  def initialize; end
-
-  def options_file; end
-  def options_file=(_arg0); end
-  def parse_arguments(*args); end
-  def use_document_file; end
-  def use_document_file=(_arg0); end
-  def use_yardopts_file; end
-  def use_yardopts_file=(_arg0); end
-
-  protected
-
-  def yardopts_options(opts); end
-
-  private
-
-  def parse_rdoc_document_file(file = T.unsafe(nil)); end
-  def parse_yardopts(file = T.unsafe(nil)); end
-  def parse_yardopts_options(*args); end
-  def support_rdoc_document_file!(file = T.unsafe(nil)); end
-  def yardopts(file = T.unsafe(nil)); end
-end
-
-YARD::CLI::YardoptsCommand::DEFAULT_YARDOPTS_FILE = T.let(T.unsafe(nil), String)
-YARD::CONFIG_DIR = T.let(T.unsafe(nil), String)
-
-module YARD::CodeObjects
-  extend ::YARD::CodeObjects::NamespaceMapper
-end
-
-YARD::CodeObjects::BUILTIN_ALL = T.let(T.unsafe(nil), Array)
-YARD::CodeObjects::BUILTIN_CLASSES = T.let(T.unsafe(nil), Array)
-YARD::CodeObjects::BUILTIN_EXCEPTIONS = T.let(T.unsafe(nil), Array)
-YARD::CodeObjects::BUILTIN_EXCEPTIONS_HASH = T.let(T.unsafe(nil), Hash)
-YARD::CodeObjects::BUILTIN_MODULES = T.let(T.unsafe(nil), Array)
-
-class YARD::CodeObjects::Base
-  def initialize(namespace, name, *_arg2); end
-
-  def ==(other); end
-  def [](key); end
-  def []=(key, value); end
-  def add_file(file, line = T.unsafe(nil), has_comments = T.unsafe(nil)); end
-  def add_tag(*tags); end
-  def base_docstring; end
-  def copy_to(other); end
-  def docstring(locale = T.unsafe(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 = T.unsafe(nil)); end
-  def group; end
-  def group=(_arg0); end
-  def has_tag?(name); end
-  def hash; end
-  def inspect; end
-  def line; end
-  def method_missing(meth, *args, &block); end
-  def name(prefix = T.unsafe(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 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 = T.unsafe(nil)); end
-  def title; end
-  def to_ary; end
-  def to_s; end
-  def type; end
-  def visibility; end
-  def visibility=(v); end
-
-  protected
-
-  def copyable_attributes; end
-
-  private
-
-  def format_source(source); end
-  def translate_docstring(locale); end
-
-  class << self
-    def ===(other); end
-    def new(namespace, name, *args, &block); end
-  end
-end
-
-YARD::CodeObjects::CONSTANTMATCH = T.let(T.unsafe(nil), Regexp)
-YARD::CodeObjects::CONSTANTSTART = T.let(T.unsafe(nil), Regexp)
-YARD::CodeObjects::CSEP = T.let(T.unsafe(nil), String)
-YARD::CodeObjects::CSEPQ = T.let(T.unsafe(nil), String)
-
-class YARD::CodeObjects::ClassObject < ::YARD::CodeObjects::NamespaceObject
-  def initialize(namespace, name, *args, &block); end
-
-  def constants(opts = T.unsafe(nil)); end
-  def inheritance_tree(include_mods = T.unsafe(nil)); end
-  def inherited_constants; end
-  def inherited_meths(opts = T.unsafe(nil)); end
-  def is_exception?; end
-  def meths(opts = T.unsafe(nil)); end
-  def superclass; end
-  def superclass=(object); end
-end
-
-class YARD::CodeObjects::ClassVariableObject < ::YARD::CodeObjects::Base
-  def value; end
-  def value=(_arg0); end
-end
-
-class YARD::CodeObjects::CodeObjectList < ::Array
-  def initialize(owner = T.unsafe(nil)); end
-
-  def <<(value); end
-  def push(value); end
-end
-
-class YARD::CodeObjects::ConstantObject < ::YARD::CodeObjects::Base
-  def value; end
-  def value=(value); end
-end
-
-class YARD::CodeObjects::ExtendedMethodObject
-  def initialize(obj); end
-
-  def method_missing(sym, *args, &block); end
-  def scope; end
-end
-
-class YARD::CodeObjects::ExtraFileObject
-  def initialize(filename, contents = T.unsafe(nil)); end
-
-  def ==(other); end
-  def attributes; end
-  def attributes=(_arg0); end
-  def contents; end
-  def contents=(contents); end
-  def eql?(other); end
-  def equal?(other); end
-  def filename; end
-  def filename=(_arg0); end
-  def hash; end
-  def inspect; end
-  def locale; end
-  def locale=(locale); end
-  def name; end
-  def name=(_arg0); end
-  def path; end
-  def title; end
-  def to_s; end
-  def type; end
-
-  private
-
-  def ensure_parsed; end
-  def parse_contents(data); end
-  def translate(data); end
-end
-
-YARD::CodeObjects::ISEP = T.let(T.unsafe(nil), String)
-YARD::CodeObjects::ISEPQ = T.let(T.unsafe(nil), String)
-YARD::CodeObjects::METHODMATCH = T.let(T.unsafe(nil), Regexp)
-YARD::CodeObjects::METHODNAMEMATCH = T.let(T.unsafe(nil), Regexp)
-
-class YARD::CodeObjects::MacroObject < ::YARD::CodeObjects::Base
-  def attached?; end
-  def expand(call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil)); end
-  def macro_data; end
-  def macro_data=(_arg0); end
-  def method_object; end
-  def method_object=(_arg0); end
-  def path; end
-  def sep; end
-
-  class << self
-    def apply(docstring, call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil), _method_object = T.unsafe(nil)); end
-    def apply_macro(macro, docstring, call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil)); end
-    def create(macro_name, data, method_object = T.unsafe(nil)); end
-    def create_docstring(macro_name, data, method_object = T.unsafe(nil)); end
-    def expand(macro_data, call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil)); end
-    def find(macro_name); end
-    def find_or_create(macro_name, data, method_object = T.unsafe(nil)); end
-  end
-end
-
-YARD::CodeObjects::MacroObject::MACRO_MATCH = T.let(T.unsafe(nil), Regexp)
-
-class YARD::CodeObjects::MethodObject < ::YARD::CodeObjects::Base
-  def initialize(namespace, name, scope = T.unsafe(nil), &block); end
-
-  def aliases; end
-  def attr_info; end
-  def constructor?; end
-  def explicit; end
-  def explicit=(_arg0); end
-  def is_alias?; end
-  def is_attribute?; end
-  def is_explicit?; end
-  def module_function?; end
-  def name(prefix = T.unsafe(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
-
-  protected
-
-  def copyable_attributes; end
-end
-
-class YARD::CodeObjects::ModuleObject < ::YARD::CodeObjects::NamespaceObject
-  def inheritance_tree(include_mods = T.unsafe(nil)); end
-end
-
-YARD::CodeObjects::NAMESPACEMATCH = T.let(T.unsafe(nil), Regexp)
-YARD::CodeObjects::NSEP = T.let(T.unsafe(nil), String)
-YARD::CodeObjects::NSEPQ = T.let(T.unsafe(nil), String)
-
-module YARD::CodeObjects::NamespaceMapper
-  def clear_separators; end
-  def default_separator(value = T.unsafe(nil)); end
-  def register_separator(sep, *valid_types); end
-  def separators; end
-  def separators_for_type(type); end
-  def separators_match; end
-  def types_for_separator(sep); end
-  def unregister_separator_by_type(type); end
-
-  class << self
-    def default_separator; end
-    def default_separator=(_arg0); end
-    def invalidate; end
-    def map; end
-    def map_match; end
-    def on_invalidate(&block); end
-    def rev_map; end
-  end
-end
-
-class YARD::CodeObjects::NamespaceObject < ::YARD::CodeObjects::Base
-  def initialize(namespace, name, *args, &block); end
-
-  def aliases; end
-  def attributes; end
-  def child(opts = T.unsafe(nil)); end
-  def children; end
-  def class_attributes; end
-  def class_mixins; end
-  def constants(opts = T.unsafe(nil)); end
-  def cvars; end
-  def groups; end
-  def groups=(_arg0); end
-  def included_constants; end
-  def included_meths(opts = T.unsafe(nil)); end
-  def instance_attributes; end
-  def instance_mixins; end
-  def meths(opts = T.unsafe(nil)); end
-  def mixins(*scopes); end
-end
-
-YARD::CodeObjects::PROXY_MATCH = T.let(T.unsafe(nil), Regexp)
-
-class YARD::CodeObjects::Proxy
-  def initialize(namespace, name, type = T.unsafe(nil)); end
-
-  def <=>(other); end
-  def ==(other); end
-  def ===(other); end
-  def class; end
-  def equal?(other); end
-  def hash; 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 = T.unsafe(nil)); end
-  def namespace; end
-  def parent; end
-  def path; end
-  def respond_to?(meth, include_private = T.unsafe(nil)); end
-  def root?; end
-  def title; end
-  def to_s; end
-  def to_str; end
-  def type; end
-  def type=(type); end
-
-  private
-
-  def proxy_path; end
-  def to_ary; end
-  def to_obj; end
-
-  class << self
-    def ===(other); end
-  end
-end
-
-class YARD::CodeObjects::ProxyMethodError < ::NoMethodError; 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::Config
-  class << self
-    def add_ignored_plugins_file; end
-    def arguments; end
-    def load; end
-    def load_autoload_plugins; end
-    def load_commandline_plugins; end
-    def load_commandline_safemode; end
-    def load_gem_plugins; end
-    def load_plugin(name); end
-    def load_plugin_failed(name, exception); end
-    def load_plugins; end
-    def options; end
-    def options=(_arg0); end
-    def read_config_file; end
-    def save; end
-    def translate_plugin_name(name); end
-    def translate_plugin_names; end
-    def with_yardopts; end
-  end
-end
-
-YARD::Config::CONFIG_DIR = T.let(T.unsafe(nil), String)
-YARD::Config::CONFIG_FILE = T.let(T.unsafe(nil), String)
-YARD::Config::DEFAULT_CONFIG_OPTIONS = T.let(T.unsafe(nil), Hash)
-YARD::Config::IGNORED_PLUGINS = T.let(T.unsafe(nil), String)
-YARD::Config::YARD_PLUGIN_PREFIX = T.let(T.unsafe(nil), Regexp)
-
-class YARD::Docstring < ::String
-  def initialize(content = T.unsafe(nil), object = T.unsafe(nil)); end
-
-  def +(other); end
-  def add_tag(*tags); end
-  def all; end
-  def all=(content, parse = T.unsafe(nil)); end
-  def blank?(only_visible_tags = T.unsafe(nil)); 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 line; end
-  def line_range; end
-  def line_range=(_arg0); end
-  def object; end
-  def object=(_arg0); end
-  def ref_tags; end
-  def replace(content, parse = T.unsafe(nil)); end
-  def resolve_reference; end
-  def summary; end
-  def tag(name); end
-  def tags(name = T.unsafe(nil)); end
-  def to_raw; end
-  def to_s; end
-
-  private
-
-  def convert_ref_tags; end
-  def parse_comments(comments); end
-  def stable_sort_by(list); end
-
-  class << self
-    def default_parser; end
-    def default_parser=(_arg0); end
-    def new!(text, tags = T.unsafe(nil), object = T.unsafe(nil), raw_data = T.unsafe(nil), ref_object = T.unsafe(nil)); end
-    def parser(*args); end
-  end
-end
-
-YARD::Docstring::META_MATCH = T.let(T.unsafe(nil), Regexp)
-
-class YARD::DocstringParser
-  def initialize(library = T.unsafe(nil)); 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 = T.unsafe(nil)); end
-  def directives; end
-  def directives=(_arg0); end
-  def handler; end
-  def handler=(_arg0); end
-  def library; end
-  def library=(_arg0); end
-  def object; end
-  def object=(_arg0); end
-  def parse(content, object = T.unsafe(nil), handler = T.unsafe(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 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
-
-  private
-
-  def call_after_parse_callbacks; end
-  def call_directives_after_parse; end
-  def detect_reference(content); end
-  def namespace; end
-
-  class << self
-    def after_parse(&block); end
-    def after_parse_callbacks; end
-  end
-end
-
-YARD::DocstringParser::META_MATCH = T.let(T.unsafe(nil), Regexp)
-
-module YARD::GemIndex
-  private
-
-  def all; end
-  def each(&block); end
-  def find_all_by_name(*args); end
-
-  class << self
-    def all; end
-    def each(&block); end
-    def find_all_by_name(*args); end
-  end
-end
-
-module YARD::Handlers; end
-
-class YARD::Handlers::Base
-  include ::YARD::CodeObjects
-  include ::YARD::Parser
-
-  def initialize(source_parser, stmt); end
-
-  def abort!; end
-  def call_params; end
-  def caller_method; end
-  def ensure_loaded!(object, max_retries = T.unsafe(nil)); end
-  def extra_state; end
-  def globals; end
-  def namespace; end
-  def namespace=(v); end
-  def owner; end
-  def owner=(v); end
-  def parse_block(*_arg0); end
-  def parser; end
-  def process; end
-  def push_state(opts = T.unsafe(nil)); end
-  def register(*objects); end
-  def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end
-  def register_dynamic(object); end
-  def register_ensure_loaded(object); end
-  def register_file_info(object, file = T.unsafe(nil), line = T.unsafe(nil), comments = T.unsafe(nil)); end
-  def register_group(object, group = T.unsafe(nil)); end
-  def register_module_function(object); end
-  def register_source(object, source = T.unsafe(nil), type = T.unsafe(nil)); end
-  def register_transitive_tags(object); end
-  def register_visibility(object, visibility = T.unsafe(nil)); end
-  def scope; end
-  def scope=(v); end
-  def statement; end
-  def visibility; end
-  def visibility=(v); end
-
-  class << self
-    def clear_subclasses; end
-    def handlers; end
-    def handles(*matches); end
-    def handles?(statement); end
-    def in_file(filename); end
-    def inherited(subclass); end
-    def matches_file?(filename); end
-    def namespace_only; end
-    def namespace_only?; end
-    def process(&block); end
-    def subclasses; end
-  end
-end
-
-module YARD::Handlers::C; end
-class YARD::Handlers::C::AliasHandler < ::YARD::Handlers::C::Base; end
-YARD::Handlers::C::AliasHandler::MATCH = T.let(T.unsafe(nil), Regexp)
-class YARD::Handlers::C::AttributeHandler < ::YARD::Handlers::C::Base; end
-YARD::Handlers::C::AttributeHandler::MATCH = T.let(T.unsafe(nil), Regexp)
-
-class YARD::Handlers::C::Base < ::YARD::Handlers::Base
-  include ::YARD::Parser::C
-  include ::YARD::Handlers::Common::MethodHandler
-  include ::YARD::Handlers::C::HandlerMethods
-
-  def ensure_variable_defined!(var, max_retries = T.unsafe(nil)); end
-  def namespace_for_variable(var); end
-  def namespaces; end
-  def override_comments; end
-  def parse_block(opts = T.unsafe(nil)); end
-  def process_file(file, object); end
-  def processed_files; end
-  def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end
-  def register_file_info(object, file = T.unsafe(nil), line = T.unsafe(nil), comments = T.unsafe(nil)); end
-  def register_source(object, source = T.unsafe(nil), type = T.unsafe(nil)); end
-  def register_visibility(object, visibility = T.unsafe(nil)); end
-  def symbols; end
-
-  private
-
-  def remove_var_prefix(var); end
-
-  class << self
-    def handles?(statement, processor); end
-    def statement_class(type = T.unsafe(nil)); end
-  end
-end
-
-YARD::Handlers::C::Base::ERROR_CLASS_NAMES = T.let(T.unsafe(nil), Hash)
-class YARD::Handlers::C::ClassHandler < ::YARD::Handlers::C::Base; end
-YARD::Handlers::C::ClassHandler::MATCH1 = T.let(T.unsafe(nil), Regexp)
-YARD::Handlers::C::ClassHandler::MATCH2 = T.let(T.unsafe(nil), Regexp)
-class YARD::Handlers::C::ConstantHandler < ::YARD::Handlers::C::Base; end
-YARD::Handlers::C::ConstantHandler::MATCH = T.let(T.unsafe(nil), Regexp)
-
-module YARD::Handlers::C::HandlerMethods
-  include ::YARD::Parser::C
-  include ::YARD::CodeObjects
-  include ::YARD::Handlers::Common::MethodHandler
-
-  def handle_alias(var_name, new_name, old_name); end
-  def handle_attribute(var_name, name, read, write); end
-  def handle_class(var_name, class_name, parent, in_module = T.unsafe(nil)); end
-  def handle_constants(type, var_name, const_name, value); end
-  def handle_method(scope, var_name, name, func_name, _source_file = T.unsafe(nil)); end
-  def handle_module(var_name, module_name, in_module = T.unsafe(nil)); end
-
-  private
-
-  def find_constant_docstring(object); end
-  def find_method_body(object, symbol); end
-  def record_parameters(object, symbol, src); end
-end
-
-class YARD::Handlers::C::InitHandler < ::YARD::Handlers::C::Base; end
-YARD::Handlers::C::InitHandler::MATCH = T.let(T.unsafe(nil), Regexp)
-class YARD::Handlers::C::MethodHandler < ::YARD::Handlers::C::Base; end
-YARD::Handlers::C::MethodHandler::MATCH1 = T.let(T.unsafe(nil), Regexp)
-YARD::Handlers::C::MethodHandler::MATCH2 = T.let(T.unsafe(nil), Regexp)
-YARD::Handlers::C::MethodHandler::MATCH3 = T.let(T.unsafe(nil), Regexp)
-class YARD::Handlers::C::MixinHandler < ::YARD::Handlers::C::Base; end
-YARD::Handlers::C::MixinHandler::MATCH = T.let(T.unsafe(nil), Regexp)
-class YARD::Handlers::C::ModuleHandler < ::YARD::Handlers::C::Base; end
-YARD::Handlers::C::ModuleHandler::MATCH1 = T.let(T.unsafe(nil), Regexp)
-YARD::Handlers::C::ModuleHandler::MATCH2 = T.let(T.unsafe(nil), Regexp)
-
-class YARD::Handlers::C::OverrideCommentHandler < ::YARD::Handlers::C::Base
-  def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end
-  def register_file_info(object, file = T.unsafe(nil), line = T.unsafe(nil), comments = T.unsafe(nil)); end
-end
-
-class YARD::Handlers::C::PathHandler < ::YARD::Handlers::C::Base; end
-YARD::Handlers::C::PathHandler::MATCH = T.let(T.unsafe(nil), Regexp)
-class YARD::Handlers::C::StructHandler < ::YARD::Handlers::C::Base; end
-YARD::Handlers::C::StructHandler::MATCH = T.let(T.unsafe(nil), Regexp)
-class YARD::Handlers::C::SymbolHandler < ::YARD::Handlers::C::Base; end
-YARD::Handlers::C::SymbolHandler::MATCH = T.let(T.unsafe(nil), Regexp)
-module YARD::Handlers::Common; end
-
-module YARD::Handlers::Common::MethodHandler
-  def add_predicate_return_tag(obj); end
-end
-
-class YARD::Handlers::HandlerAborted < ::RuntimeError; end
-
-class YARD::Handlers::NamespaceMissingError < ::YARD::Parser::UndocumentableError
-  def initialize(object); end
-
-  def object; end
-  def object=(_arg0); end
-end
-
-class YARD::Handlers::Processor
-  def initialize(parser); end
-
-  def extra_state; end
-  def extra_state=(_arg0); end
-  def file; end
-  def file=(_arg0); end
-  def find_handlers(statement); end
-  def globals; end
-  def globals=(_arg0); end
-  def namespace; end
-  def namespace=(_arg0); end
-  def owner; end
-  def owner=(_arg0); end
-  def parse_remaining_files; end
-  def parser_type; end
-  def parser_type=(_arg0); end
-  def process(statements); end
-  def scope; end
-  def scope=(_arg0); end
-  def visibility; end
-  def visibility=(_arg0); end
-
-  private
-
-  def handler_base_class; end
-  def handler_base_namespace; end
-  def handles?(handler, statement); end
-  def load_handlers; end
-
-  class << self
-    def namespace_for_handler; end
-    def register_handler_namespace(type, ns); end
-  end
-end
-
-module YARD::Handlers::Ruby; end
-class YARD::Handlers::Ruby::AliasHandler < ::YARD::Handlers::Ruby::Base; end
-
-class YARD::Handlers::Ruby::AttributeHandler < ::YARD::Handlers::Ruby::Base
-  protected
-
-  def validated_attribute_names(params); end
-end
-
-class YARD::Handlers::Ruby::Base < ::YARD::Handlers::Base
-  include ::YARD::Parser::Ruby
-  extend ::YARD::Parser::Ruby
-
-  def call_params; end
-  def caller_method; end
-  def parse_block(inner_node, opts = T.unsafe(nil)); end
-
-  class << self
-    def handles?(node); end
-    def meta_type(type); end
-    def method_call(name = T.unsafe(nil)); end
-  end
-end
-
-class YARD::Handlers::Ruby::ClassConditionHandler < ::YARD::Handlers::Ruby::Base
-  protected
-
-  def parse_condition; end
-  def parse_else_block; end
-  def parse_then_block; end
-end
-
-class YARD::Handlers::Ruby::ClassHandler < ::YARD::Handlers::Ruby::Base
-  include ::YARD::Handlers::Ruby::StructHandlerMethods
-  include ::YARDSorbet::Handlers::StructClassHandler
-
-  private
-
-  def create_struct_superclass(superclass, superclass_def); end
-  def extract_parameters(superclass); end
-  def parse_struct_superclass(klass, superclass); end
-  def parse_superclass(superclass); end
-  def struct_superclass_name(superclass); end
-end
-
-class YARD::Handlers::Ruby::ClassVariableHandler < ::YARD::Handlers::Ruby::Base; end
-class YARD::Handlers::Ruby::CommentHandler < ::YARD::Handlers::Ruby::Base; end
-
-class YARD::Handlers::Ruby::ConstantHandler < ::YARD::Handlers::Ruby::Base
-  include ::YARD::Handlers::Ruby::StructHandlerMethods
-
-  private
-
-  def extract_parameters(superclass); end
-  def process_constant(statement); end
-  def process_structclass(statement); end
-end
-
-class YARD::Handlers::Ruby::DSLHandler < ::YARD::Handlers::Ruby::Base
-  include ::YARD::Handlers::Ruby::DSLHandlerMethods
-end
-
-module YARD::Handlers::Ruby::DSLHandlerMethods
-  include ::YARD::CodeObjects
-  include ::YARD::Parser
-
-  def handle_comments; end
-  def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end
-
-  private
-
-  def find_attached_macro; end
-  def implicit_docstring?; end
-  def macro_name_matches(macro); end
-  def method_name; end
-  def method_signature; end
-end
-
-YARD::Handlers::Ruby::DSLHandlerMethods::IGNORE_METHODS = T.let(T.unsafe(nil), Hash)
-
-module YARD::Handlers::Ruby::DecoratorHandlerMethods
-  def process_decorator(*nodes, &block); end
-
-  private
-
-  def process_decorator_parameter(node, opts = T.unsafe(nil), &block); end
-end
-
-class YARD::Handlers::Ruby::ExceptionHandler < ::YARD::Handlers::Ruby::Base; end
-
-class YARD::Handlers::Ruby::ExtendHandler < ::YARD::Handlers::Ruby::MixinHandler
-  def scope; end
-
-  private
-
-  def process_mixin(mixin); end
-end
-
-class YARD::Handlers::Ruby::HandlesExtension
-  def initialize(name); end
-
-  def matches?(node); end
-
-  protected
-
-  def name; end
-end
-
-module YARD::Handlers::Ruby::Legacy; end
-class YARD::Handlers::Ruby::Legacy::AliasHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
-class YARD::Handlers::Ruby::Legacy::AttributeHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
-
-class YARD::Handlers::Ruby::Legacy::Base < ::YARD::Handlers::Base
-  include ::YARD::Parser::Ruby::Legacy::RubyToken
-
-  def call_params; end
-  def caller_method; end
-  def parse_block(opts = T.unsafe(nil)); end
-
-  private
-
-  def extract_method_details; end
-  def tokval(token, *accepted_types); end
-  def tokval_list(tokenlist, *accepted_types); end
-
-  class << self
-    def handles?(stmt); end
-  end
-end
-
-class YARD::Handlers::Ruby::Legacy::ClassConditionHandler < ::YARD::Handlers::Ruby::Legacy::Base
-  protected
-
-  def parse_condition; end
-  def parse_else_block; end
-  def parse_then_block; end
-end
-
-class YARD::Handlers::Ruby::Legacy::ClassHandler < ::YARD::Handlers::Ruby::Legacy::Base
-  include ::YARD::Handlers::Ruby::StructHandlerMethods
-
-  private
-
-  def create_struct_superclass(superclass, superclass_def); end
-  def extract_parameters(superstring); end
-  def parse_struct_subclass(klass, superclass_def); end
-  def parse_superclass(superclass); end
-  def struct_superclass_name(superclass); end
-end
-
-class YARD::Handlers::Ruby::Legacy::ClassVariableHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
-YARD::Handlers::Ruby::Legacy::ClassVariableHandler::HANDLER_MATCH = T.let(T.unsafe(nil), Regexp)
-class YARD::Handlers::Ruby::Legacy::CommentHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
-
-class YARD::Handlers::Ruby::Legacy::ConstantHandler < ::YARD::Handlers::Ruby::Legacy::Base
-  include ::YARD::Handlers::Ruby::StructHandlerMethods
-
-  private
-
-  def extract_parameters(parameters); end
-  def process_structclass(classname, parameters); end
-end
-
-YARD::Handlers::Ruby::Legacy::ConstantHandler::HANDLER_MATCH = T.let(T.unsafe(nil), Regexp)
-
-class YARD::Handlers::Ruby::Legacy::DSLHandler < ::YARD::Handlers::Ruby::Legacy::Base
-  include ::YARD::Handlers::Ruby::DSLHandlerMethods
-end
-
-class YARD::Handlers::Ruby::Legacy::ExceptionHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
-
-class YARD::Handlers::Ruby::Legacy::ExtendHandler < ::YARD::Handlers::Ruby::Legacy::MixinHandler
-  def scope; end
-
-  private
-
-  def process_mixin(mixin); end
-end
-
-class YARD::Handlers::Ruby::Legacy::MethodHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
-
-class YARD::Handlers::Ruby::Legacy::MixinHandler < ::YARD::Handlers::Ruby::Legacy::Base
-  private
-
-  def process_mixin(mixin); end
-end
-
-class YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
-class YARD::Handlers::Ruby::Legacy::ModuleHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
-
-class YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler < ::YARD::Handlers::Ruby::Legacy::Base
-  private
-
-  def privatize_class_method(name); end
-end
-
-class YARD::Handlers::Ruby::Legacy::PrivateConstantHandler < ::YARD::Handlers::Ruby::Legacy::Base
-  private
-
-  def privatize_constant(name); end
-end
-
-class YARD::Handlers::Ruby::Legacy::VisibilityHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
-class YARD::Handlers::Ruby::Legacy::YieldHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
-
-class YARD::Handlers::Ruby::MethodCallWrapper < ::YARD::Handlers::Ruby::HandlesExtension
-  def matches?(node); end
-end
-
-class YARD::Handlers::Ruby::MethodConditionHandler < ::YARD::Handlers::Ruby::Base; end
-
-class YARD::Handlers::Ruby::MethodHandler < ::YARD::Handlers::Ruby::Base
-  include ::YARD::Handlers::Common::MethodHandler
-
-  def format_args; end
-end
-
-class YARD::Handlers::Ruby::MixinHandler < ::YARD::Handlers::Ruby::Base
-  protected
-
-  def process_mixin(mixin); end
-  def recipient(mixin); end
-end
-
-class YARD::Handlers::Ruby::ModuleFunctionHandler < ::YARD::Handlers::Ruby::Base
-  include ::YARD::Handlers::Ruby::DecoratorHandlerMethods
-
-  def make_module_function(instance_method, namespace); end
-end
-
-class YARD::Handlers::Ruby::ModuleHandler < ::YARD::Handlers::Ruby::Base; end
-
-class YARD::Handlers::Ruby::PrivateClassMethodHandler < ::YARD::Handlers::Ruby::Base
-  include ::YARD::Handlers::Ruby::DecoratorHandlerMethods
-end
-
-class YARD::Handlers::Ruby::PrivateConstantHandler < ::YARD::Handlers::Ruby::Base
-  private
-
-  def privatize_constant(node); end
-end
-
-class YARD::Handlers::Ruby::PublicClassMethodHandler < ::YARD::Handlers::Ruby::Base
-  include ::YARD::Handlers::Ruby::DecoratorHandlerMethods
-end
-
-module YARD::Handlers::Ruby::StructHandlerMethods
-  include ::YARD::CodeObjects
-
-  def add_reader_tags(klass, new_method, member); end
-  def add_writer_tags(klass, new_method, member); end
-  def create_attributes(klass, members); end
-  def create_class(classname, superclass); end
-  def create_member_method?(klass, member, type = T.unsafe(nil)); end
-  def create_reader(klass, member); end
-  def create_writer(klass, member); end
-  def member_tag_for_member(klass, member, type = T.unsafe(nil)); end
-  def members_from_tags(klass); end
-  def return_type_from_tag(member_tag); end
-end
-
-class YARD::Handlers::Ruby::TestNodeWrapper < ::YARD::Handlers::Ruby::HandlesExtension
-  def matches?(node); end
-end
-
-class YARD::Handlers::Ruby::VisibilityHandler < ::YARD::Handlers::Ruby::Base
-  include ::YARD::Handlers::Ruby::DecoratorHandlerMethods
-end
-
-class YARD::Handlers::Ruby::YieldHandler < ::YARD::Handlers::Ruby::Base; end
-module YARD::I18n; end
-
-class YARD::I18n::Locale
-  def initialize(name); end
-
-  def load(locale_directory); end
-  def name; end
-  def translate(message); end
-
-  class << self
-    def default; end
-    def default=(locale); end
-  end
-end
-
-class YARD::I18n::Message
-  def initialize(id); end
-
-  def ==(other); end
-  def add_comment(comment); end
-  def add_location(path, line); end
-  def comments; end
-  def id; end
-  def locations; end
-end
-
-class YARD::I18n::Messages
-  include ::Enumerable
-
-  def initialize; end
-
-  def ==(other); end
-  def [](id); end
-  def each(&block); end
-  def register(id); end
-
-  protected
-
-  def messages; end
-end
-
-class YARD::I18n::PotGenerator
-  def initialize(relative_base_path); end
-
-  def generate; end
-  def messages; end
-  def parse_files(files); end
-  def parse_objects(objects); end
-
-  private
-
-  def current_time; end
-  def escape_message_id(message_id); end
-  def extract_documents(object); end
-  def extract_paragraphs(file); end
-  def extract_tag_documents(tag); end
-  def extract_tag_name(tag); end
-  def extract_tag_text(tag); end
-  def generate_message(pot, message); end
-  def generate_pot_creation_date_value; end
-  def header; end
-  def register_message(id); end
-end
-
-class YARD::I18n::Text
-  def initialize(input, options = T.unsafe(nil)); end
-
-  def extract_messages; end
-  def translate(locale); end
-
-  private
-
-  def emit_attribute_event(match_data, line_no); end
-  def emit_empty_line_event(line, line_no); end
-  def emit_markup_event(line, line_no); end
-  def emit_paragraph_event(paragraph, paragraph_start_line, line_no, &block); end
-  def parse(&block); end
-end
-
-class YARD::Logger < ::Logger
-  def initialize(pipe, *args); end
-
-  def <<(msg = T.unsafe(nil)); end
-  def backtrace(exc, level_meth = T.unsafe(nil)); end
-  def capture(msg, nontty_log = T.unsafe(nil)); end
-  def clear_progress; end
-  def debug(*args); end
-  def enter_level(new_level = T.unsafe(nil)); end
-  def io; end
-  def io=(pipe); end
-  def print(msg = T.unsafe(nil)); end
-  def progress(msg, nontty_log = T.unsafe(nil)); end
-  def puts(msg = T.unsafe(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
-
-  private
-
-  def add(*args); end
-  def clear_line; end
-  def format_log(sev, _time, _prog, msg); end
-  def print_no_newline(msg); end
-
-  class << self
-    def instance(pipe = T.unsafe(nil)); end
-  end
-end
-
-YARD::Logger::PROGRESS_INDICATORS = T.let(T.unsafe(nil), Array)
-
-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 to_hash; end
-  def update(opts); end
-
-  class << self
-    def default_attr(key, default); end
-  end
-end
-
-module YARD::Parser; end
-
-class YARD::Parser::Base
-  def initialize(source, filename); end
-
-  def enumerator; end
-  def parse; end
-  def tokenize; end
-
-  class << self
-    def parse(source, filename = T.unsafe(nil)); end
-  end
-end
-
-module YARD::Parser::C; end
-
-class YARD::Parser::C::BodyStatement < ::YARD::Parser::C::Statement
-  def comments; end
-  def comments=(_arg0); end
-end
-
-class YARD::Parser::C::CParser < ::YARD::Parser::Base
-  def initialize(source, file = T.unsafe(nil)); end
-
-  def enumerator; end
-  def parse; end
-  def tokenize; end
-
-  private
-
-  def advance(num = T.unsafe(nil)); end
-  def advance_loop; end
-  def attach_comment(statement); end
-  def back(num = T.unsafe(nil)); end
-  def char(num = T.unsafe(nil)); end
-  def consume_body_statements; end
-  def consume_comment(add_comment = T.unsafe(nil)); end
-  def consume_directive; end
-  def consume_quote(type = T.unsafe(nil)); end
-  def consume_toplevel_statement; end
-  def consume_until(end_char, bracket_level = T.unsafe(nil), brace_level = T.unsafe(nil), add_comment = T.unsafe(nil)); end
-  def consume_whitespace; end
-  def nextchar(num = T.unsafe(nil)); end
-  def nextline; end
-  def parse_toplevel; end
-  def prevchar(num = T.unsafe(nil)); end
-  def strip_non_statement_data; end
-  def struct; end
-end
-
-class YARD::Parser::C::Comment < ::YARD::Parser::C::Statement
-  include ::YARD::Parser::C::CommentParser
-
-  def initialize(source, file = T.unsafe(nil), line = T.unsafe(nil)); end
-
-  def comments; end
-  def overrides; end
-  def overrides=(_arg0); end
-  def statement; end
-  def statement=(_arg0); end
-  def type; end
-  def type=(_arg0); end
-end
-
-module YARD::Parser::C::CommentParser
-  protected
-
-  def parse_comments(comments); end
-
-  private
-
-  def parse_callseq(comments); end
-  def parse_overrides(comments); end
-  def parse_types(types); end
-  def remove_private_comments(comment); end
-end
-
-class YARD::Parser::C::Statement
-  def initialize(source, file = T.unsafe(nil), line = T.unsafe(nil)); end
-
-  def comments_hash_flag; end
-  def comments_hash_flag=(_arg0); end
-  def comments_range; end
-  def file; end
-  def file=(_arg0); end
-  def first_line; end
-  def group; end
-  def group=(_arg0); end
-  def line; end
-  def line=(_arg0); end
-  def line_range; end
-  def show; end
-  def signature; end
-  def source; end
-  def source=(_arg0); end
-end
-
-class YARD::Parser::C::ToplevelStatement < ::YARD::Parser::C::Statement
-  def block; end
-  def block=(_arg0); end
-  def comments; end
-  def comments=(_arg0); end
-  def declaration; end
-  def declaration=(_arg0); end
-end
-
-class YARD::Parser::OrderedParser
-  def initialize(global_state, files); end
-
-  def files; end
-  def files=(_arg0); end
-  def parse; end
-end
-
-class YARD::Parser::ParserSyntaxError < ::YARD::Parser::UndocumentableError; end
-
-module YARD::Parser::Ruby
-  def s(*args); end
-end
-
-class YARD::Parser::Ruby::AstNode < ::Array
-  def initialize(type, arr, opts = T.unsafe(nil)); end
-
-  def ==(other); end
-  def block?; end
-  def call?; end
-  def children; end
-  def comments; end
-  def comments_hash_flag; end
-  def comments_range; end
-  def condition?; end
-  def def?; end
-  def docstring; end
-  def docstring=(_arg0); end
-  def docstring_hash_flag; end
-  def docstring_hash_flag=(_arg0); end
-  def docstring_range; end
-  def docstring_range=(_arg0); end
-  def file; end
-  def file=(_arg0); end
-  def first_line; end
-  def full_source; end
-  def full_source=(_arg0); end
-  def group; end
-  def group=(_arg0); end
-  def has_line?; end
-  def inspect; end
-  def jump(*node_types); end
-  def kw?; end
-  def line; end
-  def line_range; end
-  def line_range=(_arg0); end
-  def literal?; end
-  def loop?; end
-  def parent; end
-  def parent=(_arg0); end
-  def pretty_print(q); end
-  def ref?; end
-  def show; end
-  def source; end
-  def source=(_arg0); end
-  def source_range; end
-  def source_range=(_arg0); end
-  def to_s; end
-  def token?; end
-  def traverse; end
-  def type; end
-  def type=(_arg0); end
-  def unfreeze; end
-
-  private
-
-  def reset_line_info; end
-
-  class << self
-    def node_class_for(type); end
-  end
-end
-
-YARD::Parser::Ruby::AstNode::KEYWORDS = T.let(T.unsafe(nil), Hash)
-
-class YARD::Parser::Ruby::ClassNode < ::YARD::Parser::Ruby::KeywordNode
-  def block; end
-  def class_name; end
-  def superclass; end
-end
-
-class YARD::Parser::Ruby::CommentNode < ::YARD::Parser::Ruby::AstNode
-  def comments; end
-  def docstring; end
-  def docstring=(value); end
-  def first_line; end
-  def source; end
-end
-
-class YARD::Parser::Ruby::ConditionalNode < ::YARD::Parser::Ruby::KeywordNode
-  def condition; end
-  def condition?; end
-  def else_block; end
-  def then_block; end
-
-  private
-
-  def cmod?; end
-end
-
-class YARD::Parser::Ruby::KeywordNode < ::YARD::Parser::Ruby::AstNode
-  def kw?; end
-end
-
-module YARD::Parser::Ruby::Legacy; end
-
-class YARD::Parser::Ruby::Legacy::RubyLex
-  include ::YARD::Parser::Ruby::Legacy::RubyToken
-  include ::IRB
-
-  def initialize(content); end
-
-  def char_no; end
-  def continue; end
-  def exception_on_syntax_error; end
-  def exception_on_syntax_error=(_arg0); end
-  def get_read; end
-  def getc; end
-  def getc_of_rests; end
-  def gets; end
-  def identify_comment; end
-  def identify_gvar; end
-  def identify_here_document; end
-  def identify_identifier; end
-  def identify_number(start); end
-  def identify_quotation(initial_char); end
-  def identify_string(ltype, quoted = T.unsafe(nil), opener = T.unsafe(nil), initial_char = T.unsafe(nil)); end
-  def indent; end
-  def lex; end
-  def lex_init; end
-  def lex_int2; end
-  def lex_state; end
-  def line_no; end
-  def peek(i = T.unsafe(nil)); end
-  def peek_equal?(str); end
-  def read_auto_clean_up; end
-  def read_auto_clean_up=(_arg0); end
-  def read_escape; end
-  def skip_inner_expression; end
-  def skip_space; end
-  def skip_space=(_arg0); end
-  def token; end
-  def ungetc(c = T.unsafe(nil)); end
-
-  class << self
-    def debug?; end
-  end
-end
-
-YARD::Parser::Ruby::Legacy::RubyLex::ACCEPTS_COLON = T.let(T.unsafe(nil), Array)
-
-class YARD::Parser::Ruby::Legacy::RubyLex::BufferedReader
-  def initialize(content); end
-
-  def column; end
-  def divert_read_from(reserve); end
-  def get_read; end
-  def getc; end
-  def getc_already_read; end
-  def line_num; end
-  def peek(at); end
-  def peek_equal(str); end
-  def ungetc(_ch); end
-end
-
-YARD::Parser::Ruby::Legacy::RubyLex::DEINDENT_CLAUSE = T.let(T.unsafe(nil), Array)
-YARD::Parser::Ruby::Legacy::RubyLex::DLtype2Token = T.let(T.unsafe(nil), Hash)
-YARD::Parser::Ruby::Legacy::RubyLex::ENINDENT_CLAUSE = T.let(T.unsafe(nil), Array)
-YARD::Parser::Ruby::Legacy::RubyLex::Ltype2Token = T.let(T.unsafe(nil), Hash)
-YARD::Parser::Ruby::Legacy::RubyLex::PERCENT_LTYPE = T.let(T.unsafe(nil), Hash)
-YARD::Parser::Ruby::Legacy::RubyLex::PERCENT_PAREN = T.let(T.unsafe(nil), Hash)
-
-class YARD::Parser::Ruby::Legacy::RubyParser < ::YARD::Parser::Base
-  def initialize(source, _filename); end
-
-  def encoding_line; end
-  def enumerator; end
-  def parse; end
-  def shebang_line; end
-  def tokenize; end
-end
-
-module YARD::Parser::Ruby::Legacy::RubyToken
-  def Token(token, value = T.unsafe(nil)); end
-  def set_token_position(line, char); end
-
-  class << self
-    def def_token(token_n, super_token = T.unsafe(nil), reading = T.unsafe(nil), *opts); end
-  end
-end
-
-YARD::Parser::Ruby::Legacy::RubyToken::EXPR_ARG = T.let(T.unsafe(nil), Symbol)
-YARD::Parser::Ruby::Legacy::RubyToken::EXPR_BEG = T.let(T.unsafe(nil), Symbol)
-YARD::Parser::Ruby::Legacy::RubyToken::EXPR_CLASS = T.let(T.unsafe(nil), Symbol)
-YARD::Parser::Ruby::Legacy::RubyToken::EXPR_DOT = T.let(T.unsafe(nil), Symbol)
-YARD::Parser::Ruby::Legacy::RubyToken::EXPR_END = T.let(T.unsafe(nil), Symbol)
-YARD::Parser::Ruby::Legacy::RubyToken::EXPR_FNAME = T.let(T.unsafe(nil), Symbol)
-YARD::Parser::Ruby::Legacy::RubyToken::EXPR_MID = T.let(T.unsafe(nil), Symbol)
-YARD::Parser::Ruby::Legacy::RubyToken::NEWLINE_TOKEN = T.let(T.unsafe(nil), YARD::Parser::Ruby::Legacy::RubyToken::TkNL)
-
-class YARD::Parser::Ruby::Legacy::RubyToken::OPASGN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkALIAS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkAMPER < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkAND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkANDOP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkAREF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkASET < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkASSIGN < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkASSOC < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkAT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkBACKQUOTE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkBACKSLASH < ::YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkBACK_REF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkBEGIN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkBITAND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkBITNOT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkBITOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkBITXOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkBREAK < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkBlockContents < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
-  def text; end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkCASE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkCLASS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkCMP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkCOLON < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkCOLON2 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkCOLON3 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkCOMMA < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkCOMMENT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkCONSTANT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkDEF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkDEFINED < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkDIV < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkDO < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkDOLLAR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkDOT < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkDOT2 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkDOT3 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkDREGEXP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkNode; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkDSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkNode; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkDXSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkNode; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkELSE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkELSIF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkEND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkEND_OF_SCRIPT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkENSURE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkEQQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkError < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkFALSE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkFID < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkFLOAT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkFOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkGEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkGT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkGVAR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkIDENTIFIER < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkIF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkIF_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkIN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkINTEGER < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkIVAR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkId < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
-  def initialize(line_no, char_no, name); end
-
-  def name; end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkKW < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkLABEL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkLBRACE < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkLBRACK < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkLEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkLPAREN < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkLSHFT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkLT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkMATCH < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkMINUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkMOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkMODULE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkMULT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkNEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkNEXT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkNIL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkNL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkNMATCH < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkNOT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkNOTOP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkNTH_REF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkNode < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
-  def node; end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkOPASGN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  def initialize(line_no, char_no, op); end
-
-  def op; end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkOROP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkOp < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
-  def name; end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkPLUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkPOW < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkQUESTION < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkRBRACE < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkRBRACK < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkREDO < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkREGEXP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkRESCUE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkRETRY < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkRETURN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkRPAREN < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkRSHFT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-YARD::Parser::Ruby::Legacy::RubyToken::TkReading2Token = T.let(T.unsafe(nil), Hash)
-class YARD::Parser::Ruby::Legacy::RubyToken::TkSELF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkSEMICOLON < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkSPACE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkSTAR < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkSUPER < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkSYMBEG < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkSYMBOL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkStatementEnd < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
-  def text; end
-end
-
-YARD::Parser::Ruby::Legacy::RubyToken::TkSymbol2Token = T.let(T.unsafe(nil), Hash)
-class YARD::Parser::Ruby::Legacy::RubyToken::TkTHEN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkTRUE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkUMINUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkUNDEF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkUNLESS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkUNLESS_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkUNTIL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkUNTIL_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkUPLUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
-  class << self
-    def op_name; end
-  end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
-  def initialize(line_no, char_no, _id); end
-
-  def name; end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkVal < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
-  def initialize(line_no, char_no, value = T.unsafe(nil)); end
-end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::TkWHEN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkWHILE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkWHILE_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkXSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TkYIELD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::Tk__FILE__ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::Tk__LINE__ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TklBEGIN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-class YARD::Parser::Ruby::Legacy::RubyToken::TklEND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
-
-class YARD::Parser::Ruby::Legacy::RubyToken::Token
-  def initialize(line_no, char_no); end
-
-  def char_no; end
-  def lex_state; end
-  def lex_state=(_arg0); end
-  def line_no; end
-  def set_text(text); end
-  def text; end
-end
-
-YARD::Parser::Ruby::Legacy::RubyToken::Token::NO_TEXT = T.let(T.unsafe(nil), String)
-YARD::Parser::Ruby::Legacy::RubyToken::TokenDefinitions = T.let(T.unsafe(nil), Array)
-
-class YARD::Parser::Ruby::Legacy::Statement
-  def initialize(tokens, block = T.unsafe(nil), comments = T.unsafe(nil)); end
-
-  def block; end
-  def comments; end
-  def comments_hash_flag; end
-  def comments_hash_flag=(_arg0); end
-  def comments_range; end
-  def comments_range=(_arg0); end
-  def first_line; end
-  def group; end
-  def group=(_arg0); end
-  def inspect; end
-  def line; end
-  def line_range; end
-  def show; end
-  def signature; end
-  def source(include_block = T.unsafe(nil)); end
-  def to_s(include_block = T.unsafe(nil)); end
-  def tokens; end
-
-  private
-
-  def clean_tokens(tokens); end
-end
-
-class YARD::Parser::Ruby::Legacy::StatementList < ::Array
-  include ::YARD::Parser::Ruby::Legacy::RubyToken
-
-  def initialize(content); end
-
-  def encoding_line; end
-  def encoding_line=(_arg0); end
-  def shebang_line; end
-  def shebang_line=(_arg0); end
-
-  private
-
-  def balances?(tk); end
-  def next_statement; end
-  def parse_statements; end
-  def peek_no_space; end
-  def process_block_token(tk); end
-  def process_complex_block_opener(tk); end
-  def process_initial_comment(tk); end
-  def process_simple_block_opener(tk); end
-  def process_statement_end(tk); end
-  def process_token(tk); end
-  def push_token(tk); end
-  def sanitize_block; end
-  def sanitize_statement_end; end
-end
-
-YARD::Parser::Ruby::Legacy::StatementList::OPEN_BLOCK_TOKENS = T.let(T.unsafe(nil), Array)
-
-class YARD::Parser::Ruby::Legacy::TokenList < ::Array
-  include ::YARD::Parser::Ruby::Legacy::RubyToken
-
-  def initialize(content = T.unsafe(nil)); end
-
-  def <<(*tokens); end
-  def push(*tokens); end
-  def squeeze(type = T.unsafe(nil)); end
-  def to_s(full_statement = T.unsafe(nil), show_block = T.unsafe(nil)); end
-
-  private
-
-  def convert_token(lex, tk); end
-  def parse_content(content); end
-end
-
-class YARD::Parser::Ruby::LiteralNode < ::YARD::Parser::Ruby::AstNode
-  def literal?; end
-end
-
-class YARD::Parser::Ruby::LoopNode < ::YARD::Parser::Ruby::KeywordNode
-  def block; end
-  def condition; end
-  def loop?; end
-end
-
-class YARD::Parser::Ruby::MethodCallNode < ::YARD::Parser::Ruby::AstNode
-  def block; end
-  def block_param; end
-  def call?; end
-  def method_name(name_only = T.unsafe(nil)); end
-  def namespace; end
-  def parameters(include_block_param = T.unsafe(nil)); end
-
-  private
-
-  def call_has_paren?; end
-  def index_adjust; end
-end
-
-class YARD::Parser::Ruby::MethodDefinitionNode < ::YARD::Parser::Ruby::AstNode
-  def block(*_arg0); end
-  def def?; end
-  def kw?; end
-  def method_name(name_only = T.unsafe(nil)); end
-  def namespace; end
-  def parameters(include_block_param = T.unsafe(nil)); end
-  def signature; end
-
-  private
-
-  def index_adjust; end
-end
-
-class YARD::Parser::Ruby::ModuleNode < ::YARD::Parser::Ruby::KeywordNode
-  def block; end
-  def module_name; end
-end
-
-class YARD::Parser::Ruby::ParameterNode < ::YARD::Parser::Ruby::AstNode
-  def args_forward; end
-  def block_param; end
-  def double_splat_param; end
-  def named_params; end
-  def splat_param; end
-  def unnamed_end_params; end
-  def unnamed_optional_params; end
-  def unnamed_required_params; end
-end
-
-class YARD::Parser::Ruby::ReferenceNode < ::YARD::Parser::Ruby::AstNode
-  def namespace; end
-  def path; end
-  def ref?; end
-end
-
-class YARD::Parser::Ruby::RipperParser < ::Ripper
-  def initialize(source, filename, *args); end
-
-  def ast; end
-  def charno; end
-  def comments; end
-  def encoding_line; end
-  def enumerator; end
-  def file; end
-  def file_encoding; end
-  def frozen_string_line; end
-  def on_BEGIN(*args); end
-  def on_CHAR(tok); end
-  def on_END(*args); end
-  def on___end__(tok); end
-  def on_alias(*args); end
-  def on_alias_error(*args); end
-  def on_arg_ambiguous(*args); end
-  def on_arg_paren(*args); end
-  def on_args_add(list, item); end
-  def on_args_add_block(list, item); end
-  def on_args_add_star(list, item); end
-  def on_args_new(*args); end
-  def on_assign(*args); end
-  def on_assign_error(*args); end
-  def on_assoc_splat(*args); end
-  def on_backref(tok); end
-  def on_backtick(tok); end
-  def on_begin(*args); end
-  def on_binary(*args); end
-  def on_block_var(*args); end
-  def on_blockarg(*args); end
-  def on_brace_block(*args); end
-  def on_break(*args); end
-  def on_call(*args); end
-  def on_case(*args); end
-  def on_class(*args); end
-  def on_class_name_error(*args); end
-  def on_comma(tok); end
-  def on_command(*args); end
-  def on_command_call(*args); end
-  def on_const(tok); end
-  def on_const_path_field(*args); end
-  def on_const_ref(*args); end
-  def on_cvar(tok); end
-  def on_def(*args); end
-  def on_defined(*args); end
-  def on_defs(*args); end
-  def on_do_block(*args); end
-  def on_dot2(*args); end
-  def on_dot3(*args); end
-  def on_else(*args); end
-  def on_elsif(*args); end
-  def on_embexpr_beg(tok); end
-  def on_embexpr_end(tok); end
-  def on_embvar(tok); end
-  def on_ensure(*args); end
-  def on_excessed_comma(*args); end
-  def on_fcall(*args); end
-  def on_field(*args); end
-  def on_float(tok); end
-  def on_for(*args); end
-  def on_gvar(tok); end
-  def on_heredoc_beg(tok); end
-  def on_heredoc_dedent(*args); end
-  def on_heredoc_end(tok); end
-  def on_ident(tok); end
-  def on_if(*args); end
-  def on_if_mod(*args); end
-  def on_ifop(*args); end
-  def on_ignored_nl(tok); end
-  def on_ignored_sp(tok); end
-  def on_imaginary(tok); end
-  def on_int(tok); end
-  def on_ivar(tok); end
-  def on_kw(tok); end
-  def on_kwrest_param(*args); end
-  def on_label_end(tok); end
-  def on_lbrace(tok); end
-  def on_lparen(tok); end
-  def on_magic_comment(*args); end
-  def on_massign(*args); end
-  def on_method_add_arg(list, item); end
-  def on_method_add_block(list, item); end
-  def on_mlhs_add(list, item); end
-  def on_mlhs_add_post(list, item); end
-  def on_mlhs_add_star(list, item); end
-  def on_mlhs_new(*args); end
-  def on_mlhs_paren(*args); end
-  def on_module(*args); end
-  def on_mrhs_add(list, item); end
-  def on_mrhs_add_star(list, item); end
-  def on_mrhs_new(*args); end
-  def on_mrhs_new_from_args(*args); end
-  def on_next(*args); end
-  def on_nl(tok); end
-  def on_op(tok); end
-  def on_opassign(*args); end
-  def on_operator_ambiguous(*args); end
-  def on_param_error(*args); end
-  def on_paren(*args); end
-  def on_period(tok); end
-  def on_qsymbols_add(list, item); end
-  def on_qsymbols_beg(tok); end
-  def on_qsymbols_new(*args); end
-  def on_qwords_add(list, item); end
-  def on_qwords_beg(tok); end
-  def on_qwords_new(*args); end
-  def on_rational(tok); end
-  def on_rbrace(tok); end
-  def on_redo(*args); end
-  def on_regexp_add(list, item); end
-  def on_regexp_beg(tok); end
-  def on_regexp_end(tok); end
-  def on_regexp_literal(*args); end
-  def on_regexp_new(*args); end
-  def on_rescue_mod(*args); end
-  def on_rest_param(*args); end
-  def on_retry(*args); end
-  def on_return(*args); end
-  def on_return0(*args); end
-  def on_rparen(tok); end
-  def on_sclass(*args); end
-  def on_semicolon(tok); end
-  def on_stmts_add(list, item); end
-  def on_stmts_new(*args); end
-  def on_string_add(list, item); end
-  def on_string_concat(*args); end
-  def on_string_dvar(*args); end
-  def on_string_embexpr(*args); end
-  def on_super(*args); end
-  def on_symbeg(tok); end
-  def on_symbol(*args); end
-  def on_symbol_literal(*args); end
-  def on_symbols_add(list, item); end
-  def on_symbols_beg(tok); end
-  def on_symbols_new(*args); end
-  def on_tlambda(tok); end
-  def on_tlambeg(tok); end
-  def on_top_const_field(*args); end
-  def on_tstring_beg(tok); end
-  def on_tstring_content(tok); end
-  def on_tstring_end(tok); end
-  def on_undef(*args); end
-  def on_unless(*args); end
-  def on_unless_mod(*args); end
-  def on_until(*args); end
-  def on_until_mod(*args); end
-  def on_var_alias(*args); end
-  def on_var_field(*args); end
-  def on_var_ref(*args); end
-  def on_vcall(*args); end
-  def on_when(*args); end
-  def on_while(*args); end
-  def on_while_mod(*args); end
-  def on_word_add(list, item); end
-  def on_word_new(*args); end
-  def on_words_add(list, item); end
-  def on_words_beg(tok); end
-  def on_words_new(*args); end
-  def on_words_sep(tok); end
-  def on_xstring_add(list, item); end
-  def on_xstring_literal(*args); end
-  def on_xstring_new(*args); end
-  def on_yield(*args); end
-  def on_yield0(*args); end
-  def on_zsuper(*args); end
-  def parse; end
-  def root; end
-  def shebang_line; end
-  def tokens; end
-
-  private
-
-  def add_comment(line, node = T.unsafe(nil), before_node = T.unsafe(nil), into = T.unsafe(nil)); end
-  def add_token(token, data); end
-  def comment_starts_line?(charno); end
-  def compile_error(msg); end
-  def freeze_tree(node = T.unsafe(nil)); end
-  def insert_comments; end
-  def on_aref(*args); end
-  def on_aref_field(*args); end
-  def on_array(other); end
-  def on_assoc_new(*args); end
-  def on_assoclist_from_args(*args); end
-  def on_bare_assoc_hash(*args); end
-  def on_body_stmt(*args); end
-  def on_bodystmt(*args); end
-  def on_comment(comment); end
-  def on_const_path_ref(*args); end
-  def on_dyna_symbol(sym); end
-  def on_embdoc(text); end
-  def on_embdoc_beg(text); end
-  def on_embdoc_end(text); end
-  def on_hash(*args); end
-  def on_label(data); end
-  def on_lambda(*args); end
-  def on_lbracket(tok); end
-  def on_params(*args); end
-  def on_parse_error(msg); end
-  def on_program(*args); end
-  def on_rbracket(tok); end
-  def on_rescue(exc, *args); end
-  def on_sp(tok); end
-  def on_string_content(*args); end
-  def on_string_literal(*args); end
-  def on_top_const_ref(*args); end
-  def on_unary(op, val); end
-  def on_void_stmt; end
-  def visit_event(node); end
-  def visit_event_arr(node); end
-  def visit_ns_token(token, data, ast_token = T.unsafe(nil)); end
-end
-
-YARD::Parser::Ruby::RipperParser::AST_TOKENS = T.let(T.unsafe(nil), Array)
-YARD::Parser::Ruby::RipperParser::MAPPINGS = T.let(T.unsafe(nil), Hash)
-YARD::Parser::Ruby::RipperParser::REV_MAPPINGS = T.let(T.unsafe(nil), Hash)
-
-class YARD::Parser::Ruby::RubyParser < ::YARD::Parser::Base
-  def initialize(source, filename); end
-
-  def encoding_line; end
-  def enumerator; end
-  def frozen_string_line; end
-  def parse; end
-  def shebang_line; end
-  def tokenize; end
-end
-
-class YARD::Parser::Ruby::TokenResolver
-  include ::Enumerable
-  include ::YARD::CodeObjects::NamespaceMapper
-
-  def initialize(source, namespace = T.unsafe(nil)); end
-
-  def each; end
-
-  protected
-
-  def last_sep; end
-  def last_sep=(v); end
-  def next_object; end
-  def next_object=(v); end
-  def object; end
-  def object=(v); end
-  def skip_group; end
-  def skip_group=(v); end
-
-  private
-
-  def lookup(toktype, name); end
-  def object_resolved_types(obj = T.unsafe(nil)); end
-  def pop_state; end
-  def push_state; end
-
-  class << self
-    def state_attr(*attrs); end
-  end
-end
-
-class YARD::Parser::SourceParser
-  def initialize(parser_type = T.unsafe(nil), globals1 = T.unsafe(nil), globals2 = T.unsafe(nil)); end
-
-  def contents; end
-  def file; end
-  def file=(_arg0); end
-  def globals; end
-  def parse(content = T.unsafe(nil)); end
-  def parser_type; end
-  def tokenize(content); end
-
-  private
-
-  def convert_encoding(content); end
-  def parser_class; end
-  def parser_type=(value); end
-  def parser_type_for_filename(filename); end
-  def post_process; end
-
-  class << self
-    def after_parse_file(&block); end
-    def after_parse_file_callbacks; end
-    def after_parse_list(&block); end
-    def after_parse_list_callbacks; end
-    def before_parse_file(&block); end
-    def before_parse_file_callbacks; end
-    def before_parse_list(&block); end
-    def before_parse_list_callbacks; end
-    def parse(paths = T.unsafe(nil), excluded = T.unsafe(nil), level = T.unsafe(nil)); end
-    def parse_string(content, ptype = T.unsafe(nil)); end
-    def parser_type; end
-    def parser_type=(value); end
-    def parser_type_extensions; end
-    def parser_type_extensions=(value); end
-    def parser_type_for_extension(extension); end
-    def parser_types; end
-    def parser_types=(value); end
-    def register_parser_type(type, parser_klass, extensions = T.unsafe(nil)); end
-    def tokenize(content, ptype = T.unsafe(nil)); end
-    def validated_parser_type(type); end
-
-    private
-
-    def parse_in_order(*files); end
-  end
-end
-
-YARD::Parser::SourceParser::DEFAULT_PATH_GLOB = T.let(T.unsafe(nil), Array)
-YARD::Parser::SourceParser::ENCODING_BYTE_ORDER_MARKS = T.let(T.unsafe(nil), Hash)
-YARD::Parser::SourceParser::ENCODING_LINE = T.let(T.unsafe(nil), Regexp)
-YARD::Parser::SourceParser::FROZEN_STRING_LINE = T.let(T.unsafe(nil), Regexp)
-YARD::Parser::SourceParser::SHEBANG_LINE = T.let(T.unsafe(nil), Regexp)
-class YARD::Parser::UndocumentableError < ::RuntimeError; end
-YARD::ROOT = T.let(T.unsafe(nil), String)
-module YARD::Rake; end
-
-module YARD::Registry
-  extend ::Enumerable
-
-  class << self
-    def [](path); end
-    def all(*types); end
-    def at(path); end
-    def checksum_for(data); end
-    def checksums; end
-    def clear; end
-    def delete(object); end
-    def delete_from_disk; end
-    def each(&block); end
-    def instance; end
-    def load(files = T.unsafe(nil), reparse = T.unsafe(nil)); end
-    def load!(file = T.unsafe(nil)); end
-    def load_all; end
-    def load_yardoc(file = T.unsafe(nil)); end
-    def locale(name); end
-    def lock_for_writing(file = T.unsafe(nil), &block); end
-    def locked_for_writing?(file = T.unsafe(nil)); end
-    def paths(reload = T.unsafe(nil)); end
-    def po_dir; end
-    def po_dir=(dir); end
-    def proxy_types; end
-    def register(object); end
-    def resolve(namespace, name, inheritance = T.unsafe(nil), proxy_fallback = T.unsafe(nil), type = T.unsafe(nil)); end
-    def root; end
-    def save(merge = T.unsafe(nil), file = T.unsafe(nil)); end
-    def single_object_db; end
-    def single_object_db=(v); end
-    def yardoc_file; end
-    def yardoc_file=(v); end
-    def yardoc_file_for_gem(gem, ver_require = T.unsafe(nil), for_writing = T.unsafe(nil)); end
-
-    private
-
-    def global_yardoc_file(spec, for_writing = T.unsafe(nil)); end
-    def local_yardoc_file(spec, for_writing = T.unsafe(nil)); end
-    def old_global_yardoc_file(spec, for_writing = T.unsafe(nil)); end
-    def partial_resolve(namespace, name, type = T.unsafe(nil)); end
-    def thread_local_resolver; end
-    def thread_local_store; end
-    def thread_local_store=(value); end
-  end
-end
-
-YARD::Registry::DEFAULT_PO_DIR = T.let(T.unsafe(nil), String)
-YARD::Registry::DEFAULT_YARDOC_FILE = T.let(T.unsafe(nil), String)
-YARD::Registry::LOCAL_YARDOC_INDEX = T.let(T.unsafe(nil), String)
-
-class YARD::RegistryResolver
-  include ::YARD::CodeObjects::NamespaceMapper
-
-  def initialize(registry = T.unsafe(nil)); end
-
-  def lookup_by_path(path, opts = T.unsafe(nil)); end
-
-  private
-
-  def collect_namespaces(object); end
-  def lookup_path_direct(namespace, path, type); end
-  def lookup_path_inherited(namespace, path, type); end
-  def split_on_separators_match; end
-  def starts_with_default_separator_match; end
-  def starts_with_separator_match; end
-  def validate(obj, type); end
-end
-
-class YARD::RegistryStore
-  def initialize; end
-
-  def [](key); end
-  def []=(key, value); end
-  def checksums; end
-  def delete(key); end
-  def destroy(force = T.unsafe(nil)); end
-  def file; end
-  def get(key); end
-  def keys(reload = T.unsafe(nil)); end
-  def load(file = T.unsafe(nil)); end
-  def load!(file = T.unsafe(nil)); end
-  def load_all; end
-  def locale(name); end
-  def lock_for_writing(file = T.unsafe(nil), &block); end
-  def locked_for_writing?(file = T.unsafe(nil)); end
-  def paths_for_type(type, reload = T.unsafe(nil)); end
-  def proxy_types; end
-  def put(key, value); end
-  def root; end
-  def save(merge = T.unsafe(nil), file = T.unsafe(nil)); end
-  def values(reload = T.unsafe(nil)); end
-  def values_for_type(type, reload = T.unsafe(nil)); end
-
-  protected
-
-  def checksums_path; end
-  def load_yardoc; end
-  def object_types_path; end
-  def objects_path; end
-  def proxy_types_path; end
-
-  private
-
-  def all_disk_objects; 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_old; end
-  def write_checksums; end
-  def write_complete_lock; end
-  def write_object_types; end
-  def write_proxy_types; end
-end
-
-module YARD::Serializers; end
-
-class YARD::Serializers::Base
-  def initialize(opts = T.unsafe(nil)); end
-
-  def after_serialize(data); end
-  def before_serialize; end
-  def exists?(object); end
-  def options; end
-  def serialize(object, data); end
-  def serialized_path(object); end
-end
-
-class YARD::Serializers::FileSystemSerializer < ::YARD::Serializers::Base
-  def initialize(opts = T.unsafe(nil)); end
-
-  def basepath; end
-  def basepath=(value); end
-  def exists?(object); end
-  def extension; end
-  def extension=(value); end
-  def serialize(object, data); end
-  def serialized_path(object); end
-
-  private
-
-  def build_filename_map; end
-  def encode_path_components(*components); end
-  def mapped_name(object); end
-end
-
-class YARD::Serializers::ProcessSerializer < ::YARD::Serializers::Base
-  def initialize(cmd); end
-
-  def serialize(_object, data); end
-end
-
-class YARD::Serializers::StdoutSerializer < ::YARD::Serializers::Base
-  def initialize(wrap = T.unsafe(nil)); end
-
-  def serialize(_object, data); end
-
-  private
-
-  def word_wrap(text, _length = T.unsafe(nil)); end
-end
-
-class YARD::Serializers::YardocSerializer < ::YARD::Serializers::FileSystemSerializer
-  def initialize(yfile); end
-
-  def checksums_path; end
-  def complete?; end
-  def complete_lock_path; end
-  def deserialize(path, is_path = T.unsafe(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
-
-  private
-
-  def dump(object); end
-  def internal_dump(object, first_object = T.unsafe(nil)); end
-end
-
-module YARD::Server
-  class << self
-    def register_static_path(path); end
-  end
-end
-
-class YARD::Server::Adapter
-  def initialize(libs, opts = T.unsafe(nil), server_opts = T.unsafe(nil)); end
-
-  def add_library(library); end
-  def document_root; end
-  def document_root=(_arg0); end
-  def libraries; end
-  def libraries=(_arg0); end
-  def options; end
-  def options=(_arg0); end
-  def router; end
-  def router=(_arg0); end
-  def server_options; end
-  def server_options=(_arg0); end
-  def start; end
-
-  class << self
-    def setup; end
-    def shutdown; end
-  end
-end
-
-module YARD::Server::Commands; end
-
-class YARD::Server::Commands::Base
-  def initialize(opts = T.unsafe(nil)); end
-
-  def adapter; end
-  def adapter=(_arg0); end
-  def body; end
-  def body=(_arg0); end
-  def caching; end
-  def caching=(_arg0); end
-  def call(request); end
-  def command_options; end
-  def command_options=(_arg0); end
-  def headers; end
-  def headers=(_arg0); end
-  def path; end
-  def path=(_arg0); end
-  def request; end
-  def request=(_arg0); end
-  def run; end
-  def status; end
-  def status=(_arg0); end
-
-  protected
-
-  def cache(data); end
-  def not_found; end
-  def redirect(url); end
-  def render(object = T.unsafe(nil)); end
-
-  private
-
-  def add_cache_control; end
-end
-
-class YARD::Server::Commands::DisplayFileCommand < ::YARD::Server::Commands::LibraryCommand
-  def index; end
-  def index=(_arg0); end
-  def run; end
-end
-
-class YARD::Server::Commands::DisplayObjectCommand < ::YARD::Server::Commands::LibraryCommand
-  include ::YARD::Server::DocServerHelper
-
-  def index; end
-  def not_found; end
-  def run; end
-
-  private
-
-  def object_path; end
-end
-
-class YARD::Server::Commands::FramesCommand < ::YARD::Server::Commands::DisplayObjectCommand
-  def run; end
-end
-
-class YARD::Server::Commands::LibraryCommand < ::YARD::Server::Commands::Base
-  def initialize(opts = T.unsafe(nil)); end
-
-  def call(request); end
-  def incremental; end
-  def incremental=(_arg0); end
-  def library; end
-  def library=(_arg0); end
-  def options; end
-  def options=(_arg0); end
-  def serializer; end
-  def serializer=(_arg0); end
-  def single_library; end
-  def single_library=(_arg0); end
-  def use_fork; end
-  def use_fork=(_arg0); end
-
-  private
-
-  def call_with_fork(request, &block); end
-  def call_without_fork(request); end
-  def can_fork?; end
-  def fulldoc_template; end
-  def load_yardoc; end
-  def not_prepared; end
-  def restore_template_info; end
-  def save_default_template_info; end
-  def setup_library; end
-  def setup_yardopts; end
-end
-
-YARD::Server::Commands::LibraryCommand::CAN_FORK = T.let(T.unsafe(nil), TrueClass)
-
-class YARD::Server::Commands::LibraryIndexCommand < ::YARD::Server::Commands::Base
-  def options; end
-  def options=(_arg0); end
-  def run; end
-end
-
-class YARD::Server::Commands::LibraryIndexOptions < ::YARD::CLI::YardocOptions
-  def adapter; end
-  def adapter=(_arg0); end
-  def libraries; end
-  def libraries=(_arg0); end
-  def serialize; end
-  def serialize=(_arg0); end
-  def template; end
-  def template=(_arg0); end
-  def type; end
-  def type=(_arg0); end
-end
-
-class YARD::Server::Commands::LibraryOptions < ::YARD::CLI::YardocOptions
-  def adapter; end
-  def command; end
-  def command=(_arg0); end
-  def each(&block); end
-  def frames; end
-  def frames=(_arg0); end
-  def library; end
-  def serialize; end
-  def serializer; end
-  def single_library; end
-end
-
-class YARD::Server::Commands::ListCommand < ::YARD::Server::Commands::LibraryCommand
-  include ::YARD::Templates::Helpers::BaseHelper
-
-  def run; end
-end
-
-class YARD::Server::Commands::RootRequestCommand < ::YARD::Server::Commands::Base
-  include ::WEBrick::HTTPUtils
-  include ::YARD::Server::Commands::StaticFileHelpers
-
-  def run; end
-end
-
-class YARD::Server::Commands::SearchCommand < ::YARD::Server::Commands::LibraryCommand
-  include ::YARD::Templates::Helpers::BaseHelper
-  include ::YARD::Templates::Helpers::ModuleHelper
-  include ::YARD::Server::DocServerHelper
-
-  def query; end
-  def query=(_arg0); end
-  def results; end
-  def results=(_arg0); end
-  def run; end
-  def visible_results; end
-
-  private
-
-  def search_for_object; end
-  def serve_normal; end
-  def serve_xhr; end
-  def url_for(object); end
-end
-
-class YARD::Server::Commands::StaticFileCommand < ::YARD::Server::Commands::LibraryCommand
-  include ::WEBrick::HTTPUtils
-  include ::YARD::Server::Commands::StaticFileHelpers
-
-  def run; end
-end
-
-YARD::Server::Commands::StaticFileCommand::STATIC_PATHS = T.let(T.unsafe(nil), Array)
-
-module YARD::Server::Commands::StaticFileHelpers
-  include ::WEBrick::HTTPUtils
-
-  def favicon?; end
-  def static_template_file?; end
-
-  private
-
-  def find_file(adapter, url); end
-
-  class << self
-    def find_file(adapter, url); end
-  end
-end
-
-module YARD::Server::DocServerHelper
-  def abs_url(*path_components); end
-  def base_path(path); end
-  def mtime(file); end
-  def mtime_url(file); end
-  def router; end
-  def url_for(obj, anchor = T.unsafe(nil), relative = T.unsafe(nil)); end
-  def url_for_file(filename, anchor = T.unsafe(nil)); end
-  def url_for_frameset; end
-  def url_for_index; end
-  def url_for_list(type); end
-  def url_for_main; end
-end
-
-class YARD::Server::DocServerSerializer < ::YARD::Serializers::FileSystemSerializer
-  def initialize(_command = T.unsafe(nil)); end
-
-  def serialized_path(object); end
-
-  private
-
-  def urlencode(name); end
-end
-
-class YARD::Server::FinishRequest < ::RuntimeError; end
-class YARD::Server::LibraryNotPreparedError < ::RuntimeError; end
-
-class YARD::Server::LibraryVersion
-  def initialize(name, version = T.unsafe(nil), yardoc = T.unsafe(nil), source = T.unsafe(nil)); end
-
-  def ==(other); end
-  def eql?(other); end
-  def equal?(other); end
-  def gemspec; end
-  def hash; end
-  def name; end
-  def name=(_arg0); end
-  def prepare!; end
-  def ready?; end
-  def source; end
-  def source=(_arg0); end
-  def source_path; end
-  def source_path=(_arg0); end
-  def to_s(url_format = T.unsafe(nil)); end
-  def version; end
-  def version=(_arg0); end
-  def yardoc_file; end
-  def yardoc_file=(_arg0); end
-
-  protected
-
-  def load_yardoc_from_disk; end
-  def load_yardoc_from_gem; end
-  def source_path_for_disk; end
-  def source_path_for_gem; end
-  def yardoc_file_for_gem; end
-
-  private
-
-  def load_source_path; end
-  def load_yardoc_file; end
-  def serializer; end
-end
-
-class YARD::Server::NotFoundError < ::RuntimeError; end
-
-class YARD::Server::RackAdapter < ::YARD::Server::Adapter
-  include ::WEBrick::HTTPUtils
-
-  def call(env); end
-  def start; end
-
-  private
-
-  def print_start_message(server); end
-end
-
-class YARD::Server::RackMiddleware
-  def initialize(app, opts = T.unsafe(nil)); end
-
-  def call(env); end
-end
-
-class YARD::Server::Router
-  include ::YARD::Server::StaticCaching
-  include ::YARD::Server::Commands
-
-  def initialize(adapter); end
-
-  def adapter; end
-  def adapter=(_arg0); end
-  def call(request); end
-  def docs_prefix; end
-  def list_prefix; end
-  def parse_library_from_path(paths); end
-  def request; end
-  def request=(_arg0); end
-  def search_prefix; end
-  def static_prefix; end
-
-  protected
-
-  def final_options(library, paths); end
-  def route(path = T.unsafe(nil)); end
-  def route_docs(library, paths); end
-  def route_index; end
-  def route_list(library, paths); end
-  def route_search(library, paths); end
-  def route_static(library, paths); end
-end
-
-module YARD::Server::StaticCaching
-  def check_static_cache; end
-end
-
-class YARD::Server::WebrickAdapter < ::YARD::Server::Adapter
-  def start; end
-end
-
-class YARD::Server::WebrickServlet < ::WEBrick::HTTPServlet::AbstractServlet
-  def initialize(server, adapter); end
-
-  def adapter; end
-  def adapter=(_arg0); end
-  def do_GET(request, response); end
-end
-
-class YARD::StubProxy
-  def initialize(path, transient = T.unsafe(nil)); end
-
-  def _dump(_depth); end
-  def hash; end
-  def method_missing(meth, *args, &block); end
-
-  class << self
-    def _load(str); end
-  end
-end
-
-YARD::StubProxy::FILELEN = T.let(T.unsafe(nil), Integer)
-YARD::TEMPLATE_ROOT = T.let(T.unsafe(nil), String)
-module YARD::Tags; end
-
-class YARD::Tags::AttributeDirective < ::YARD::Tags::MethodDirective
-  def after_parse; end
-
-  protected
-
-  def method_name; end
-  def method_signature; end
-
-  private
-
-  def create_attribute_data(object); end
-  def readable?; end
-  def writable?; end
-end
-
-class YARD::Tags::DefaultFactory
-  def parse_tag(tag_name, text); end
-  def parse_tag_with_name(tag_name, text); end
-  def parse_tag_with_options(tag_name, text); end
-  def parse_tag_with_title_and_text(tag_name, text); end
-  def parse_tag_with_types(tag_name, text); end
-  def parse_tag_with_types_and_name(tag_name, text); end
-  def parse_tag_with_types_and_title(tag_name, text); end
-  def parse_tag_with_types_name_and_default(tag_name, text); end
-
-  private
-
-  def extract_name_from_text(text); end
-  def extract_title_and_desc_from_text(text); end
-  def extract_types_and_name_from_text(text, opening_types = T.unsafe(nil), closing_types = T.unsafe(nil)); end
-  def extract_types_and_name_from_text_unstripped(text, opening_types = T.unsafe(nil), closing_types = T.unsafe(nil)); end
-end
-
-YARD::Tags::DefaultFactory::TYPELIST_CLOSING_CHARS = T.let(T.unsafe(nil), String)
-YARD::Tags::DefaultFactory::TYPELIST_OPENING_CHARS = T.let(T.unsafe(nil), String)
-
-class YARD::Tags::DefaultTag < ::YARD::Tags::Tag
-  def initialize(tag_name, text, types = T.unsafe(nil), name = T.unsafe(nil), defaults = T.unsafe(nil)); end
-
-  def defaults; end
-end
-
-class YARD::Tags::Directive
-  def initialize(tag, parser); end
-
-  def after_parse; end
-  def call; end
-  def expanded_text; end
-  def expanded_text=(_arg0); end
-  def handler; end
-  def object; end
-  def parser=(_arg0); end
-  def tag; end
-  def tag=(_arg0); end
-
-  protected
-
-  def inside_directive?; end
-  def parser; end
-end
-
-class YARD::Tags::EndGroupDirective < ::YARD::Tags::Directive
-  def call; end
-end
-
-class YARD::Tags::GroupDirective < ::YARD::Tags::Directive
-  def call; end
-end
-
-class YARD::Tags::Library
-  def initialize(factory = T.unsafe(nil)); end
-
-  def abstract_tag(text); end
-  def api_tag(text); end
-  def attr_reader_tag(text); end
-  def attr_tag(text); end
-  def attr_writer_tag(text); end
-  def attribute_directive(tag, parser); end
-  def author_tag(text); end
-  def deprecated_tag(text); end
-  def directive_create(tag_name, tag_buf, parser); end
-  def endgroup_directive(tag, parser); end
-  def example_tag(text); end
-  def factory; end
-  def factory=(_arg0); end
-  def group_directive(tag, parser); end
-  def has_directive?(tag_name); end
-  def has_tag?(tag_name); end
-  def macro_directive(tag, parser); end
-  def method_directive(tag, parser); end
-  def note_tag(text); end
-  def option_tag(text); end
-  def overload_tag(text); end
-  def param_tag(text); end
-  def parse_directive(tag, parser); end
-  def private_tag(text); end
-  def raise_tag(text); end
-  def return_tag(text); end
-  def scope_directive(tag, parser); end
-  def see_tag(text); end
-  def since_tag(text); end
-  def tag_create(tag_name, tag_buf); end
-  def todo_tag(text); end
-  def version_tag(text); end
-  def visibility_directive(tag, parser); end
-  def yield_tag(text); end
-  def yieldparam_tag(text); end
-  def yieldreturn_tag(text); end
-
-  private
-
-  def directive_call(tag, parser); end
-  def send_to_factory(tag_name, meth, text); end
-
-  class << self
-    def default_factory; end
-    def default_factory=(factory); end
-    def define_directive(tag, tag_meth = T.unsafe(nil), directive_class = T.unsafe(nil)); end
-    def define_tag(label, tag, meth = T.unsafe(nil)); end
-    def directive_method_name(tag_name); end
-    def factory_method_for(tag); end
-    def factory_method_for_directive(directive); end
-    def instance; end
-    def labels; end
-    def sorted_labels; end
-    def tag_method_name(tag_name); end
-    def transitive_tags; end
-    def transitive_tags=(_arg0); end
-    def visible_tags; end
-    def visible_tags=(_arg0); end
-
-    private
-
-    def tag_or_directive_method_name(tag_name, type = T.unsafe(nil)); end
-  end
-end
-
-class YARD::Tags::MacroDirective < ::YARD::Tags::Directive
-  def call; end
-
-  private
-
-  def anonymous?; end
-  def attach?; end
-  def class_method?; end
-  def expand(macro_data); end
-  def find_or_create; end
-  def new?; end
-  def warn; end
-end
-
-class YARD::Tags::MethodDirective < ::YARD::Tags::Directive
-  def after_parse; end
-  def call; end
-
-  protected
-
-  def create_object; end
-  def method_name; end
-  def method_signature; end
-  def sanitized_tag_signature; end
-  def use_indented_text; end
-end
-
-YARD::Tags::MethodDirective::SCOPE_MATCH = T.let(T.unsafe(nil), Regexp)
-
-class YARD::Tags::OptionTag < ::YARD::Tags::Tag
-  def initialize(tag_name, name, pair); end
-
-  def pair; end
-  def pair=(_arg0); end
-end
-
-class YARD::Tags::OverloadTag < ::YARD::Tags::Tag
-  def initialize(tag_name, text); end
-
-  def docstring; end
-  def has_tag?(name); end
-  def is_a?(other); end
-  def kind_of?(other); end
-  def method_missing(*args, &block); end
-  def name(prefix = T.unsafe(nil)); end
-  def object=(value); end
-  def parameters; end
-  def signature; end
-  def tag(name); end
-  def tags(name = T.unsafe(nil)); end
-  def type; end
-
-  private
-
-  def parse_signature; end
-  def parse_tag(text); end
-end
-
-class YARD::Tags::ParseDirective < ::YARD::Tags::Directive
-  def call; end
-end
-
-module YARD::Tags::RefTag
-  def owner; end
-  def owner=(_arg0); end
-end
-
-class YARD::Tags::RefTagList
-  def initialize(tag_name, owner, name = T.unsafe(nil)); end
-
-  def name; end
-  def name=(_arg0); end
-  def owner; end
-  def owner=(_arg0); end
-  def tag_name; end
-  def tag_name=(_arg0); end
-  def tags; end
-end
-
-class YARD::Tags::ScopeDirective < ::YARD::Tags::Directive
-  def call; end
-end
-
-class YARD::Tags::Tag
-  def initialize(tag_name, text, types = T.unsafe(nil), name = T.unsafe(nil)); end
-
-  def explain_types; 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::TagFormatError < ::RuntimeError; end
-
-class YARD::Tags::TypesExplainer
-  class << self
-    def explain(*types); end
-    def explain!(*types); end
-  end
-end
-
-class YARD::Tags::TypesExplainer::CollectionType < ::YARD::Tags::TypesExplainer::Type
-  def initialize(name, types); end
-
-  def to_s(_singular = T.unsafe(nil)); end
-  def types; end
-  def types=(_arg0); end
-end
-
-class YARD::Tags::TypesExplainer::FixedCollectionType < ::YARD::Tags::TypesExplainer::CollectionType
-  def to_s(_singular = T.unsafe(nil)); end
-end
-
-class YARD::Tags::TypesExplainer::HashCollectionType < ::YARD::Tags::TypesExplainer::Type
-  def initialize(name, key_types, value_types); end
-
-  def key_types; end
-  def key_types=(_arg0); end
-  def to_s(_singular = T.unsafe(nil)); end
-  def value_types; end
-  def value_types=(_arg0); end
-end
-
-class YARD::Tags::TypesExplainer::Parser
-  include ::YARD::CodeObjects
-
-  def initialize(string); end
-
-  def parse; end
-
-  class << self
-    def parse(string); end
-  end
-end
-
-YARD::Tags::TypesExplainer::Parser::TOKENS = T.let(T.unsafe(nil), Hash)
-
-class YARD::Tags::TypesExplainer::Type
-  def initialize(name); end
-
-  def name; end
-  def name=(_arg0); end
-  def to_s(singular = T.unsafe(nil)); end
-
-  private
-
-  def list_join(list); end
-end
-
-class YARD::Tags::VisibilityDirective < ::YARD::Tags::Directive
-  def call; end
-end
-
-module YARD::Templates; end
-
-module YARD::Templates::Engine
-  class << self
-    def generate(objects, options = T.unsafe(nil)); end
-    def register_template_path(path); end
-    def render(options = T.unsafe(nil)); end
-    def template(*path); end
-    def template!(path, full_paths = T.unsafe(nil)); end
-    def template_paths; end
-    def template_paths=(_arg0); end
-    def with_serializer(object, serializer); end
-
-    private
-
-    def find_template_paths(from_template, path); end
-    def set_default_options(options = T.unsafe(nil)); end
-    def template_module_name(path); end
-  end
-end
-
-module YARD::Templates::ErbCache
-  class << self
-    def clear!; end
-    def method_for(filename); end
-  end
-end
-
-module YARD::Templates::Helpers; end
-
-module YARD::Templates::Helpers::BaseHelper
-  def format_object_title(object); end
-  def format_object_type(object); end
-  def format_source(value); end
-  def format_types(list, brackets = T.unsafe(nil)); end
-  def globals; end
-  def h(text); end
-  def link_file(filename, title = T.unsafe(nil), anchor = T.unsafe(nil)); end
-  def link_include_file(file); end
-  def link_include_object(obj); end
-  def link_object(obj, title = T.unsafe(nil)); end
-  def link_url(url, title = T.unsafe(nil), params = T.unsafe(nil)); end
-  def linkify(*args); end
-  def object; end
-  def object=(_arg0); end
-  def owner; end
-  def run_verifier(list); end
-  def serializer; end
-  def serializer=(_arg0); end
-end
-
-module YARD::Templates::Helpers::FilterHelper
-  def is_class?(object); end
-  def is_method?(object); end
-  def is_module?(object); end
-  def is_namespace?(object); end
-end
-
-module YARD::Templates::Helpers::HtmlHelper
-  include ::YARD::Templates::Helpers::MarkupHelper
-  include ::YARD::Templates::Helpers::ModuleHelper
-  include ::YARD::Templates::Helpers::HtmlSyntaxHighlightHelper
-
-  def anchor_for(object); end
-  def charset; end
-  def format_object_name_list(objects); end
-  def format_types(typelist, brackets = T.unsafe(nil)); end
-  def h(text); end
-  def html_markup_asciidoc(text); end
-  def html_markup_html(text); end
-  def html_markup_markdown(text); end
-  def html_markup_none(text); end
-  def html_markup_org(text); end
-  def html_markup_pre(text); end
-  def html_markup_rdoc(text); end
-  def html_markup_ruby(source); end
-  def html_markup_text(text); end
-  def html_markup_textile(text); end
-  def html_markup_textile_strict(text); end
-  def html_syntax_highlight(source, type = T.unsafe(nil)); end
-  def html_syntax_highlight_plain(source); end
-  def htmlify(text, markup = T.unsafe(nil)); end
-  def htmlify_line(*args); end
-  def insert_include(text, markup = T.unsafe(nil)); end
-  def link_file(filename, title = T.unsafe(nil), anchor = T.unsafe(nil)); end
-  def link_include_file(file); end
-  def link_include_object(obj); end
-  def link_object(obj, title = T.unsafe(nil), anchor = T.unsafe(nil), relative = T.unsafe(nil)); end
-  def link_url(url, title = T.unsafe(nil), params = T.unsafe(nil)); end
-  def mtime(_file); end
-  def mtime_url(obj, anchor = T.unsafe(nil), relative = T.unsafe(nil)); end
-  def resolve_links(text); end
-  def signature(meth, link = T.unsafe(nil), show_extras = T.unsafe(nil), full_attr_name = T.unsafe(nil)); end
-  def signature_types(meth, link = T.unsafe(nil)); end
-  def url_for(obj, anchor = T.unsafe(nil), relative = T.unsafe(nil)); end
-  def url_for_file(filename, anchor = T.unsafe(nil)); end
-  def url_for_frameset; end
-  def url_for_index; end
-  def url_for_list(type); end
-  def url_for_main; end
-
-  private
-
-  def convert_method_to_overload(meth); end
-  def detect_lang_in_codeblock_attributes(pre_html_attrs, code_html_attrs); end
-  def parse_codeblocks(html); end
-  def parse_lang_for_codeblock(source); end
-  def tag_attrs(opts = T.unsafe(nil)); end
-  def urlencode(text); end
-
-  class << self
-    def urlencode(text); end
-  end
-end
-
-YARD::Templates::Helpers::HtmlHelper::ASCIIDOC_ATTRIBUTES = T.let(T.unsafe(nil), Hash)
-YARD::Templates::Helpers::HtmlHelper::URLMATCH = T.let(T.unsafe(nil), Regexp)
-
-module YARD::Templates::Helpers::HtmlSyntaxHighlightHelper
-  include ::YARD::Templates::Helpers::ModuleHelper
-
-  def html_syntax_highlight_ruby(source); end
-
-  private
-
-  def clean_token_object(token_obj); end
-  def html_syntax_highlight_ruby_legacy(source); end
-  def html_syntax_highlight_ruby_ripper(source); end
-end
-
-module YARD::Templates::Helpers::Markup; end
-
-class YARD::Templates::Helpers::Markup::RDocMarkdown < ::YARD::Templates::Helpers::Markup::RDocMarkup
-  def initialize(text); end
-
-  def fix_typewriter(html); end
-end
-
-class YARD::Templates::Helpers::Markup::RDocMarkup
-  def initialize(text); end
-
-  def from_path; end
-  def from_path=(_arg0); end
-  def to_html; end
-
-  private
-
-  def fix_dash_dash(text); end
-  def fix_typewriter(text); end
-end
-
-YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP = RDoc::Markup
-
-class YARD::Templates::Helpers::Markup::RDocMarkupToHtml < ::RDoc::Markup::ToHtml
-  def initialize; end
-
-  def accept_paragraph(*args); end
-  def from_path; end
-  def from_path=(_arg0); end
-  def handle_special_HYPERLINK(special); end
-end
-
-module YARD::Templates::Helpers::MarkupHelper
-  def load_markup_provider(type = T.unsafe(nil)); end
-  def markup_class(type = T.unsafe(nil)); end
-  def markup_file_contents(contents); end
-  def markup_for_file(contents, filename); end
-  def markup_provider(type = T.unsafe(nil)); end
-
-  class << self
-    def clear_markup_cache; end
-    def markup_cache; end
-    def markup_cache=(_arg0); end
-  end
-end
-
-YARD::Templates::Helpers::MarkupHelper::MARKUP_EXTENSIONS = T.let(T.unsafe(nil), Hash)
-YARD::Templates::Helpers::MarkupHelper::MARKUP_FILE_SHEBANG = T.let(T.unsafe(nil), Regexp)
-YARD::Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS = T.let(T.unsafe(nil), Hash)
-
-module YARD::Templates::Helpers::MethodHelper
-  def format_args(object); end
-  def format_block(object); end
-  def format_code(object, _show_lines = T.unsafe(nil)); end
-  def format_constant(value); end
-  def format_lines(object); end
-  def format_return_types(object); end
-end
-
-module YARD::Templates::Helpers::ModuleHelper
-  def prune_method_listing(list, hide_attributes = T.unsafe(nil)); end
-end
-
-module YARD::Templates::Helpers::TextHelper
-  def align_right(text, spacer = T.unsafe(nil), col = T.unsafe(nil)); end
-  def h(text); end
-  def hr(col = T.unsafe(nil), sep = T.unsafe(nil)); end
-  def indent(text, len = T.unsafe(nil)); end
-  def signature(meth); end
-  def title_align_right(text, col = T.unsafe(nil)); end
-  def wrap(text, col = T.unsafe(nil)); end
-
-  private
-
-  def resolve_links(text); end
-end
-
-module YARD::Templates::Helpers::UMLHelper
-  def format_path(object); end
-  def h(text); end
-  def tidy(data); end
-  def uml_visibility(object); end
-end
-
-class YARD::Templates::Section < ::Array
-  def initialize(name, *args); end
-
-  def <<(*args); end
-  def ==(other); end
-  def [](*args); end
-  def any(item); end
-  def dup; end
-  def eql?(other); end
-  def inspect; end
-  def name; end
-  def name=(_arg0); end
-  def place(*args); end
-  def push(*args); end
-  def to_a; end
-  def unshift(*args); end
-
-  private
-
-  def parse_sections(args); end
-end
-
-module YARD::Templates::Template
-  include ::YARD::Templates::ErbCache
-  include ::YARD::Templates::Helpers::BaseHelper
-  include ::YARD::Templates::Helpers::MethodHelper
-
-  mixes_in_class_methods ::YARD::Templates::Template::ClassMethods
-
-  def initialize(opts = T.unsafe(nil)); end
-
-  def T(*path); end
-  def class; end
-  def class=(_arg0); end
-  def erb(section, &block); end
-  def file(basename, allow_inherited = T.unsafe(nil)); end
-  def init; end
-  def inspect; end
-  def options; end
-  def options=(value); end
-  def run(opts = T.unsafe(nil), sects = T.unsafe(nil), start_at = T.unsafe(nil), break_first = T.unsafe(nil), &block); end
-  def section; end
-  def section=(_arg0); end
-  def sections(*args); end
-  def superb(sect = T.unsafe(nil), &block); end
-  def yieldall(opts = T.unsafe(nil), &block); end
-
-  protected
-
-  def erb_file_for(section); end
-  def erb_with(content, filename = T.unsafe(nil)); end
-
-  private
-
-  def add_options(opts = T.unsafe(nil)); end
-  def cache(section); end
-  def cache_filename(section); end
-  def render_section(section, &block); end
-  def set_ivars; end
-  def with_section; end
-
-  class << self
-    def extra_includes; end
-    def extra_includes=(_arg0); end
-    def include_extra(template, options); end
-    def included(klass); end
-  end
-end
-
-module YARD::Templates::Template::ClassMethods
-  def initialize(path, full_paths); end
-
-  def S(*args); end
-  def T(*path); end
-  def find_file(basename); end
-  def find_nth_file(basename, index = T.unsafe(nil)); end
-  def full_path; end
-  def full_path=(_arg0); end
-  def full_paths; end
-  def is_a?(klass); end
-  def new(*args); end
-  def path; end
-  def path=(_arg0); end
-  def reset_full_paths; end
-  def run(*args); end
-
-  private
-
-  def include_inherited(full_paths); end
-  def include_parent; end
-  def load_setup_rb; 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
-
-YARD::VERSION = T.let(T.unsafe(nil), String)
-
-class YARD::Verifier
-  def initialize(*expressions); end
-
-  def add_expressions(*expressions); end
-  def call(object); end
-  def expressions; end
-  def expressions=(value); end
-  def method_missing(sym, *args, &block); end
-  def run(list); end
-
-  protected
-
-  def o; end
-  def object; end
-
-  private
-
-  def create_method_from_expressions; end
-  def modify_nilclass; end
-  def parse_expression(expr); end
-  def unmodify_nilclass; end
-end
-
-YARD::Verifier::NILCLASS_METHODS = T.let(T.unsafe(nil), Array)
diff --git a/Library/Homebrew/sorbet/rbi/gems/yard@0.9.37.rbi b/Library/Homebrew/sorbet/rbi/gems/yard@0.9.37.rbi
new file mode 100644
index 0000000000000..f908a9ad76243
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/yard@0.9.37.rbi
@@ -0,0 +1,18244 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `yard` gem.
+# Please instead update this file by running `bin/tapioca gem yard`.
+
+
+# source://yard//lib/yard.rb#61
+::RUBY18 = T.let(T.unsafe(nil), FalseClass)
+
+# source://yard//lib/yard.rb#62
+::RUBY19 = T.let(T.unsafe(nil), TrueClass)
+
+# source://yard//lib/yard/core_ext/array.rb#2
+class Array
+  include ::Enumerable
+
+  # Places values before or after another object (by value) in
+  # an array. This is used in tandem with the before and after
+  # methods of the {Insertion} class.
+  #
+  # @example Places an item before another
+  #   [1, 2, 3].place(4).before(3) # => [1, 2, 4, 3]
+  # @example Places an item after another
+  #   [:a, :b, :c].place(:x).after(:a) # => [:a, :x, :b, :c]
+  # @param values [Array] value to insert
+  # @return [Insertion] an insertion object to
+  # @see Insertion#before
+  # @see Insertion#after
+  #
+  # source://yard//lib/yard/core_ext/array.rb#15
+  def place(*values); end
+end
+
+# source://yard//lib/yard/core_ext/file.rb#4
+class File < ::IO
+  class << self
+    # Cleans a path by removing extraneous '..', '.' and '/' characters
+    #
+    # @example Clean a path
+    #   File.cleanpath('a/b//./c/../e') # => "a/b/e"
+    # @param path [String] the path to clean
+    # @param rel_root [Boolean] allows relative path above root value
+    # @return [String] the sanitized path
+    #
+    # source://yard//lib/yard/core_ext/file.rb#37
+    def cleanpath(path, rel_root = T.unsafe(nil)); end
+
+    # Forces opening a file (for writing) by first creating the file's directory
+    #
+    # @param file [String] the filename to open
+    # @since 0.5.2
+    #
+    # source://yard//lib/yard/core_ext/file.rb#57
+    def open!(file, *args, &block); end
+
+    # Reads a file with binary encoding
+    #
+    # @return [String] the ascii-8bit encoded data
+    # @since 0.5.3
+    #
+    # source://yard//lib/yard/core_ext/file.rb#66
+    def read_binary(file); end
+
+    # Turns a path +to+ into a relative path from starting
+    # point +from+. The argument +from+ is assumed to be
+    # a filename. To treat it as a directory, make sure it
+    # ends in +File::SEPARATOR+ ('/' on UNIX filesystems).
+    #
+    # @param from [String] the starting filename
+    #   (or directory with +from_isdir+ set to +true+).
+    # @param to [String] the final path that should be made relative.
+    # @return [String] the relative path from +from+ to +to+.
+    #
+    # source://yard//lib/yard/core_ext/file.rb#19
+    def relative_path(from, to); end
+  end
+end
+
+# source://yard//lib/yard/core_ext/file.rb#5
+File::RELATIVE_PARENTDIR = T.let(T.unsafe(nil), String)
+
+# source://yard//lib/yard/core_ext/file.rb#6
+File::RELATIVE_SAMEDIR = T.let(T.unsafe(nil), String)
+
+# :stopdoc:
+#
+# source://yard//lib/yard/rubygems/backports/gem.rb#2
+module Gem
+  class << self
+    # Returns the Gem::SourceIndex of specifications that are in the Gem.path
+    #
+    # source://yard//lib/yard/rubygems/backports/gem.rb#6
+    def source_index; end
+  end
+end
+
+# Cache is an alias for SourceIndex to allow older YAMLized source index
+# objects to load properly.
+#
+# source://yard//lib/yard/rubygems/backports/source_index.rb#363
+Gem::Cache = Gem::SourceIndex
+
+# The SourceIndex object indexes all the gems available from a
+# particular source (e.g. a list of gem directories, or a remote
+# source).  A SourceIndex maps a gem full name to a gem
+# specification.
+#
+# NOTE:: The class used to be named Cache, but that became
+#        confusing when cached source fetchers where introduced. The
+#        constant Gem::Cache is an alias for this class to allow old
+#        YAMLized source index objects to load properly.
+#
+# source://yard//lib/yard/rubygems/backports/source_index.rb#21
+class Gem::SourceIndex
+  include ::Enumerable
+
+  # Constructs a source index instance from the provided specifications, which
+  # is a Hash of gem full names and Gem::Specifications.
+  # --
+  # TODO merge @gems and @prerelease_gems and provide a separate method
+  # #prerelease_gems
+  #
+  # @return [SourceIndex] a new instance of SourceIndex
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#102
+  def initialize(specifications = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#348
+  def ==(other); end
+
+  # Add a gem specification to the source index.
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#193
+  def add_spec(gem_spec, name = T.unsafe(nil)); end
+
+  # Add gem specifications to the source index.
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#202
+  def add_specs(*gem_specs); end
+
+  # TODO: remove method
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#109
+  def all_gems; end
+
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#352
+  def dump; end
+
+  # Iterate over the specifications in the source index.
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#218
+  def each(&block); end
+
+  # Find a gem by an exact match on the short name.
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#256
+  def find_name(gem_name, requirement = T.unsafe(nil)); end
+
+  # The signature for the given gem specification.
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#242
+  def gem_signature(gem_full_name); end
+
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#34
+  def gems; end
+
+  # The signature for the source index.  Changes in the signature indicate a
+  # change in the index.
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#233
+  def index_signature; end
+
+  # Returns an Array specifications for the latest released versions
+  # of each gem in this index.
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#143
+  def latest_specs(include_prerelease = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#248
+  def length; end
+
+  # Reconstruct the source index from the specifications in +spec_dirs+.
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#124
+  def load_gems_in(*spec_dirs); end
+
+  # Returns an Array of Gem::Specifications that are not up to date.
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#330
+  def outdated; end
+
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#113
+  def prerelease_gems; end
+
+  # An array including only the prerelease gemspecs
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#179
+  def prerelease_specs; end
+
+  # Replaces the gems in the source index from specifications in the
+  # directories this source index was created from.  Raises an exception if
+  # this source index wasn't created from a directory (via from_gems_in or
+  # from_installed_gems, or having spec_dirs set).
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#322
+  def refresh!; end
+
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#117
+  def released_gems; end
+
+  # An array including only the released gemspecs
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#186
+  def released_specs; end
+
+  # Remove a gem specification named +full_name+.
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#211
+  def remove_spec(full_name); end
+
+  # Search for a gem by Gem::Dependency +gem_pattern+.  If +only_platform+
+  # is true, only gems matching Gem::Platform.local will be returned.  An
+  # Array of matching Gem::Specification objects is returned.
+  #
+  # For backwards compatibility, a String or Regexp pattern may be passed as
+  # +gem_pattern+, and a Gem::Requirement for +platform_only+.  This
+  # behavior is deprecated and will be removed.
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#270
+  def search(gem_pattern, platform_only = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#248
+  def size; end
+
+  # Directories to use to refresh this SourceIndex when calling refresh!
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#39
+  def spec_dirs; end
+
+  # Directories to use to refresh this SourceIndex when calling refresh!
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#39
+  def spec_dirs=(_arg0); end
+
+  # The gem specification given a full gem spec name.
+  #
+  # source://yard//lib/yard/rubygems/backports/source_index.rb#225
+  def specification(full_name); end
+
+  class << self
+    # Creates a new SourceIndex from the ruby format gem specifications in
+    # +spec_dirs+.
+    #
+    # source://yard//lib/yard/rubygems/backports/source_index.rb#80
+    def from_gems_in(*spec_dirs); end
+
+    # Factory method to construct a source index instance for a given
+    # path.
+    #
+    # deprecated::
+    #   If supplied, from_installed_gems will act just like
+    #   +from_gems_in+.  This argument is deprecated and is provided
+    #   just for backwards compatibility, and should not generally
+    #   be used.
+    #
+    # return::
+    #   SourceIndex instance
+    #
+    # source://yard//lib/yard/rubygems/backports/source_index.rb#61
+    def from_installed_gems(*deprecated); end
+
+    # Returns a list of directories from Gem.path that contain specifications.
+    #
+    # source://yard//lib/yard/rubygems/backports/source_index.rb#72
+    def installed_spec_directories; end
+
+    # Loads a ruby-format specification from +file_name+ and returns the
+    # loaded spec.
+    #
+    # source://yard//lib/yard/rubygems/backports/source_index.rb#90
+    def load_specification(file_name); end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#17
+class IRB::SLex
+  # @return [SLex] a new instance of SLex
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#25
+  def initialize; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#60
+  def create(token, preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#29
+  def def_rule(token, preproc = T.unsafe(nil), postproc = T.unsafe(nil), &block); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#36
+  def def_rules(*tokens, &block); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#77
+  def inspect; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#64
+  def match(token); end
+
+  # need a check?
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#51
+  def postproc(token); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#45
+  def preproc(token, proc); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#56
+  def search(token); end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#18
+IRB::SLex::DOUT = T.let(T.unsafe(nil), IRB::Notifier::CompositeNotifier)
+
+# source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#20
+IRB::SLex::D_DEBUG = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier)
+
+# source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#21
+IRB::SLex::D_DETAIL = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier)
+
+# source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#19
+IRB::SLex::D_WARN = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier)
+
+# ----------------------------------------------------------------------
+#
+#   class Node -
+#
+# ----------------------------------------------------------------------
+#
+# source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#86
+class IRB::SLex::Node
+  # if postproc is nil, this node is an abstract node.
+  # if postproc is non-nil, this node is a real node.
+  #
+  # @return [Node] a new instance of Node
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#89
+  def initialize(preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#113
+  def create_subnode(chrs, preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end
+
+  # chrs: String
+  #       character array
+  #       io must have getc()/ungetc(); and ungetc() must be
+  #       able to be called arbitrary number of times.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#161
+  def match(chrs, op = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#198
+  def match_io(io, op = T.unsafe(nil)); end
+
+  # Returns the value of attribute postproc.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#96
+  def postproc; end
+
+  # Sets the attribute postproc
+  #
+  # @param value the value to set the attribute postproc to.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#96
+  def postproc=(_arg0); end
+
+  # Returns the value of attribute preproc.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#95
+  def preproc; end
+
+  # Sets the attribute preproc
+  #
+  # @param value the value to set the attribute preproc to.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#95
+  def preproc=(_arg0); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/irb/slex.rb#98
+  def search(chrs, opt = T.unsafe(nil)); end
+end
+
+# The Insertion class inserts a value before or after another
+# value in a list.
+#
+# @example
+#   Insertion.new([1, 2, 3], 4).before(3) # => [1, 2, 4, 3]
+#
+# source://yard//lib/yard/core_ext/insertion.rb#7
+class Insertion
+  # Creates an insertion object on a list with a value to be
+  # inserted. To finalize the insertion, call {#before} or
+  # {#after} on the object.
+  #
+  # @param list [Array] the list to perform the insertion on
+  # @param value [Object] the value to insert
+  # @return [Insertion] a new instance of Insertion
+  #
+  # source://yard//lib/yard/core_ext/insertion.rb#14
+  def initialize(list, value); end
+
+  # Inserts the value after +val+.
+  #
+  # @example If subsections are ignored
+  #   Insertion.new([1, [2], 3], :X).after(1) # => [1, [2], :X, 3]
+  # @param val [Object] the object the value will be inserted after
+  # @param recursive [Boolean] look inside sublists
+  #
+  # source://yard//lib/yard/core_ext/insertion.rb#30
+  def after(val, recursive = T.unsafe(nil)); end
+
+  # Alias for {#after} with +recursive+ set to true
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/core_ext/insertion.rb#38
+  def after_any(val); end
+
+  # Inserts the value before +val+
+  #
+  # @param val [Object] the object the value will be inserted before
+  # @param recursive [Boolean] look inside sublists
+  #
+  # source://yard//lib/yard/core_ext/insertion.rb#22
+  def before(val, recursive = T.unsafe(nil)); end
+
+  # Alias for {#before} with +recursive+ set to true
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/core_ext/insertion.rb#34
+  def before_any(val); end
+
+  private
+
+  # This method performs the actual insertion
+  #
+  # @param val [Object] the value to insert
+  # @param rel [Fixnum] the relative index (0 or 1) of where the object
+  #   should be placed
+  # @param recursive [Boolean] look inside sublists
+  # @param list [Array] the list to place objects into
+  #
+  # source://yard//lib/yard/core_ext/insertion.rb#49
+  def insertion(val, rel, recursive = T.unsafe(nil), list = T.unsafe(nil)); end
+end
+
+# source://yard//lib/yard/core_ext/module.rb#2
+class Module
+  # Returns the class name of a full module namespace path
+  #
+  # @example
+  #   module A::B::C; class_name end # => "C"
+  # @return [String] the last part of a module path
+  #
+  # source://yard//lib/yard/core_ext/module.rb#8
+  def class_name; end
+end
+
+class Object < ::BasicObject
+  include ::Kernel
+  include ::PP::ObjectMixin
+
+  private
+
+  # source://yard//lib/yard/globals.rb#8
+  def P(namespace, name = T.unsafe(nil), type = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/globals.rb#20
+  def log; end
+end
+
+# Keep track of Ruby version for compatibility code
+#
+# @deprecated Use {YARD.ruby18?} or {YARD.ruby19?} instead.
+#
+# source://yard//lib/yard.rb#61
+RUBY18 = T.let(T.unsafe(nil), FalseClass)
+
+# source://yard//lib/yard.rb#62
+RUBY19 = T.let(T.unsafe(nil), TrueClass)
+
+# source://yard//lib/yard/core_ext/string.rb#2
+class String
+  include ::Comparable
+
+  # Splits text into tokens the way a shell would, handling quoted
+  # text as a single token. Use '\"' and "\'" to escape quotes and
+  # '\\' to escape a backslash.
+  #
+  # @return [Array] an array representing the tokens
+  #
+  # source://yard//lib/yard/core_ext/string.rb#8
+  def shell_split; end
+end
+
+# A subclass of Hash where all keys are converted into Symbols, and
+# optionally, all String values are converted into Symbols.
+#
+# source://yard//lib/yard/core_ext/symbol_hash.rb#4
+class SymbolHash < ::Hash
+  # Creates a new SymbolHash object
+  #
+  # @param symbolize_value [Boolean] converts any String values into Symbols
+  #   if this is set to +true+.
+  # @return [SymbolHash] a new instance of SymbolHash
+  #
+  # source://yard//lib/yard/core_ext/symbol_hash.rb#9
+  def initialize(symbolize_value = T.unsafe(nil)); end
+
+  # Accessed a symbolized key
+  #
+  # @param key [#to_sym] the key to access
+  # @return [Object] the value associated with the key
+  #
+  # source://yard//lib/yard/core_ext/symbol_hash.rb#49
+  def [](key); end
+
+  # Assigns a value to a symbolized key
+  #
+  # @param key [#to_sym] the key
+  # @param value [Object] the value to be assigned. If this is a String and
+  #   values are set to be symbolized, it will be converted into a Symbol.
+  #
+  # source://yard//lib/yard/core_ext/symbol_hash.rb#42
+  def []=(key, value); end
+
+  # Deleted a key and value associated with it
+  #
+  # @param key [#to_sym] the key to delete
+  # @return [void]
+  #
+  # source://yard//lib/yard/core_ext/symbol_hash.rb#54
+  def delete(key); end
+
+  # Tests if a symbolized key exists
+  #
+  # @param key [#to_sym] the key to test
+  # @return [Boolean] whether the key exists
+  #
+  # source://yard//lib/yard/core_ext/symbol_hash.rb#59
+  def has_key?(key); end
+
+  # Tests if a symbolized key exists
+  #
+  # @param key [#to_sym] the key to test
+  # @return [Boolean] whether the key exists
+  #
+  # source://yard//lib/yard/core_ext/symbol_hash.rb#59
+  def key?(key); end
+
+  # Merges the contents of another hash into a new SymbolHash object
+  #
+  # @param hash [Hash] the hash of objects to copy
+  # @return [SymbolHash] a new SymbolHash containing the merged data
+  #
+  # source://yard//lib/yard/core_ext/symbol_hash.rb#74
+  def merge(hash); end
+
+  # Updates the object with the contents of another Hash object.
+  # This method modifies the original SymbolHash object
+  #
+  # @param hash [Hash] the hash object to copy the values from
+  # @return [SymbolHash] self
+  #
+  # source://yard//lib/yard/core_ext/symbol_hash.rb#67
+  def merge!(hash); end
+
+  # Updates the object with the contents of another Hash object.
+  # This method modifies the original SymbolHash object
+  #
+  # @param hash [Hash] the hash object to copy the values from
+  # @return [SymbolHash] self
+  #
+  # source://yard//lib/yard/core_ext/symbol_hash.rb#67
+  def update(hash); end
+
+  class << self
+    # @overload []
+    # @overload []
+    #
+    # source://yard//lib/yard/core_ext/symbol_hash.rb#28
+    def [](*hsh); end
+  end
+end
+
+# Gem::YARDoc provides methods to generate YARDoc and yri data for installed gems
+# upon gem installation.
+#
+# This file is automatically required by RubyGems 1.9 and newer.
+#
+# source://yard//lib/yard.rb#2
+module YARD
+  class << self
+    # Loads gems that match the name 'yard-*' (recommended) or 'yard_*' except
+    # those listed in +~/.yard/ignored_plugins+. This is called immediately
+    # after YARD is loaded to allow plugin support.
+    #
+    # @deprecated Use {Config.load_plugins}
+    # @return [Boolean] true if all plugins loaded successfully, false otherwise.
+    #
+    # source://yard//lib/yard.rb#31
+    def load_plugins; end
+
+    # An alias to {Parser::SourceParser}'s parsing method
+    #
+    # @example Parse a glob of files
+    #   YARD.parse('lib/**/*.rb')
+    # @see Parser::SourceParser.parse
+    #
+    # source://yard//lib/yard.rb#20
+    def parse(*args); end
+
+    # An alias to {Parser::SourceParser}'s parsing method
+    #
+    # @example Parse a string of input
+    #   YARD.parse_string('class Foo; end')
+    # @see Parser::SourceParser.parse_string
+    #
+    # source://yard//lib/yard.rb#27
+    def parse_string(*args); end
+
+    # @return [Boolean] whether YARD is being run in Ruby 1.8 mode
+    #
+    # source://yard//lib/yard.rb#44
+    def ruby18?; end
+
+    # @return [Boolean] whether YARD is being run in Ruby 1.9 mode
+    #
+    # source://yard//lib/yard.rb#47
+    def ruby19?; end
+
+    # @return [Boolean] whether YARD is being run in Ruby 2.0
+    #
+    # source://yard//lib/yard.rb#50
+    def ruby2?; end
+
+    # @return [Boolean] whether YARD is being run in Ruby 3.1
+    #
+    # source://yard//lib/yard.rb#56
+    def ruby31?; end
+
+    # @return [Boolean] whether YARD is being run in Ruby 3.0
+    #
+    # source://yard//lib/yard.rb#53
+    def ruby3?; end
+
+    # @return [Boolean] whether YARD is being run inside of Windows
+    #
+    # source://yard//lib/yard.rb#34
+    def windows?; end
+  end
+end
+
+# Namespace for command-line interface components
+#
+# source://yard//lib/yard/autoload.rb#6
+module YARD::CLI; end
+
+# Abstract base class for CLI utilities. Provides some helper methods for
+# the option parser
+#
+# @abstract
+# @since 0.6.0
+#
+# source://yard//lib/yard/cli/command.rb#11
+class YARD::CLI::Command
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/command.rb#16
+  def description; end
+
+  protected
+
+  # Adds a set of common options to the tail of the OptionParser
+  #
+  # @param opts [OptionParser] the option parser object
+  # @return [void]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/command.rb#24
+  def common_options(opts); end
+
+  # Loads a Ruby script. If <tt>Config.options[:safe_mode]</tt> is enabled,
+  # this method will do nothing.
+  #
+  # @param file [String] the path to the script to load
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/command.rb#68
+  def load_script(file); end
+
+  # Parses the option and gracefully handles invalid switches
+  #
+  # @param opts [OptionParser] the option parser object
+  # @param args [Array<String>] the arguments passed from input. This
+  #   array will be modified.
+  # @return [void]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/command.rb#55
+  def parse_options(opts, args); end
+
+  # Callback when an unrecognize option is parsed
+  #
+  # @param err [OptionParser::ParseError] the exception raised by the
+  #   option parser
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/command.rb#80
+  def unrecognized_option(err); end
+
+  class << self
+    # Helper method to run the utility on an instance.
+    #
+    # @see #run
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/cli/command.rb#14
+    def run(*args); end
+  end
+end
+
+# This class parses a command name out of the +yard+ CLI command and calls
+# that command in the form:
+#
+#   $ yard command_name [options]
+#
+# If no command or arguments are specified, or if the arguments immediately
+# begin with a +--opt+ (not +--help+), the {default_command} will be used
+# (which itself defaults to +:doc+).
+#
+# == Adding a Command
+#
+# To add a custom command via plugin, create a mapping in {commands} from
+# the Symbolic command name to the {Command} class that implements the
+# command. To implement a command, see the documentation for the {Command}
+# class.
+#
+# @see Command
+# @see commands
+# @see default_command
+#
+# source://yard//lib/yard/cli/command_parser.rb#23
+class YARD::CLI::CommandParser
+  # @return [CommandParser] a new instance of CommandParser
+  #
+  # source://yard//lib/yard/cli/command_parser.rb#56
+  def initialize; end
+
+  # Runs the {Command} object matching the command name of the first
+  # argument.
+  #
+  # @return [void]
+  #
+  # source://yard//lib/yard/cli/command_parser.rb#63
+  def run(*args); end
+
+  private
+
+  # source://yard//lib/yard/cli/command_parser.rb#80
+  def commands; end
+
+  # source://yard//lib/yard/cli/command_parser.rb#82
+  def list_commands; end
+
+  class << self
+    # @return [Hash{Symbol => Command}] the mapping of command names to
+    #   command classes to parse the user command.
+    #
+    # source://yard//lib/yard/cli/command_parser.rb#27
+    def commands; end
+
+    # @return [Hash{Symbol => Command}] the mapping of command names to
+    #   command classes to parse the user command.
+    #
+    # source://yard//lib/yard/cli/command_parser.rb#27
+    def commands=(_arg0); end
+
+    # @return [Symbol] the default command name to use when no options
+    #   are specified or
+    #
+    # source://yard//lib/yard/cli/command_parser.rb#31
+    def default_command; end
+
+    # @return [Symbol] the default command name to use when no options
+    #   are specified or
+    #
+    # source://yard//lib/yard/cli/command_parser.rb#31
+    def default_command=(_arg0); end
+
+    # Convenience method to create a new CommandParser and call {#run}
+    #
+    # @return [void]
+    #
+    # source://yard//lib/yard/cli/command_parser.rb#54
+    def run(*args); end
+  end
+end
+
+# CLI command to view or edit configuration options
+#
+# @since 0.6.2
+#
+# source://yard//lib/yard/cli/config.rb#6
+class YARD::CLI::Config < ::YARD::CLI::Command
+  # @return [Config] a new instance of Config
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#26
+  def initialize; end
+
+  # @return [Boolean] whether to append values to existing key
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#20
+  def append; end
+
+  # @return [Boolean] whether to append values to existing key
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#20
+  def append=(_arg0); end
+
+  # @return [Boolean] whether the value being set should be inside a list
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#17
+  def as_list; end
+
+  # @return [Boolean] whether the value being set should be inside a list
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#17
+  def as_list=(_arg0); end
+
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#36
+  def description; end
+
+  # @return [String, nil] command to use when configuring ~/.gemrc file.
+  #   If the string is nil, configuration should not occur.
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#24
+  def gem_install_cmd; end
+
+  # @return [String, nil] command to use when configuring ~/.gemrc file.
+  #   If the string is nil, configuration should not occur.
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#24
+  def gem_install_cmd=(_arg0); end
+
+  # @return [Symbol, nil] the key to view/edit, if any
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#8
+  def key; end
+
+  # @return [Symbol, nil] the key to view/edit, if any
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#8
+  def key=(_arg0); end
+
+  # @return [Boolean] whether to reset the {#key}
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#14
+  def reset; end
+
+  # @return [Boolean] whether to reset the {#key}
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#14
+  def reset=(_arg0); end
+
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#40
+  def run(*args); end
+
+  # @return [Array, nil] the list of values to set (or single value), if modifying
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#11
+  def values; end
+
+  # @return [Array, nil] the list of values to set (or single value), if modifying
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#11
+  def values=(_arg0); end
+
+  private
+
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#57
+  def configure_gemrc; end
+
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#111
+  def encode_value(value); end
+
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#103
+  def encode_values; end
+
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#97
+  def list_configuration; end
+
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#78
+  def modify_item; end
+
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#120
+  def optparse(*args); end
+
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/config.rb#92
+  def view_item; end
+end
+
+# CLI command to return the objects that were added/removed from 2 versions
+# of a project (library, gem, working copy).
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/cli/diff.rb#11
+class YARD::CLI::Diff < ::YARD::CLI::Command
+  # @return [Diff] a new instance of Diff
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#12
+  def initialize; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#24
+  def description; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#28
+  def run(*args); end
+
+  private
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#83
+  def added_objects(registry1, registry2); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#78
+  def all_objects; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#233
+  def cleanup(gemfile); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#175
+  def expand_and_parse(gemfile, io); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#187
+  def expand_gem(gemfile, io); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#181
+  def generate_yardoc(dir); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#118
+  def load_gem_data(gemfile); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#102
+  def load_git_commit(commit); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#87
+  def modified_objects(registry1, registry2); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#239
+  def optparse(*args); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#98
+  def removed_objects(registry1, registry2); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/diff.rb#225
+  def require_rubygems; end
+end
+
+# Display one object
+#
+# @since 0.8.6
+#
+# source://yard//lib/yard/cli/display.rb#6
+class YARD::CLI::Display < ::YARD::CLI::Yardoc
+  # @return [Display] a new instance of Display
+  # @since 0.8.6
+  #
+  # source://yard//lib/yard/cli/display.rb#9
+  def initialize(*args); end
+
+  # @since 0.8.6
+  #
+  # source://yard//lib/yard/cli/display.rb#7
+  def description; end
+
+  # @return [String] the output data for all formatted objects
+  # @since 0.8.6
+  #
+  # source://yard//lib/yard/cli/display.rb#27
+  def format_objects; end
+
+  # @since 0.8.6
+  #
+  # source://yard//lib/yard/cli/display.rb#61
+  def output_options(opts); end
+
+  # Parses commandline options.
+  #
+  # @param args [Array<String>] each tokenized argument
+  # @since 0.8.6
+  #
+  # source://yard//lib/yard/cli/display.rb#46
+  def parse_arguments(*args); end
+
+  # Runs the commandline utility, parsing arguments and displaying an object
+  # from the {Registry}.
+  #
+  # @param args [Array<String>] the list of arguments.
+  # @return [void]
+  # @since 0.8.6
+  #
+  # source://yard//lib/yard/cli/display.rb#21
+  def run(*args); end
+
+  # @since 0.8.6
+  #
+  # source://yard//lib/yard/cli/display.rb#33
+  def wrap_layout(contents); end
+end
+
+# @since 0.6.0
+#
+# source://yard//lib/yard/cli/gems.rb#5
+class YARD::CLI::Gems < ::YARD::CLI::Command
+  # @return [Gems] a new instance of Gems
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/gems.rb#6
+  def initialize; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/gems.rb#11
+  def description; end
+
+  # Runs the commandline utility, parsing arguments and generating
+  # YARD indexes for gems.
+  #
+  # @param args [Array<String>] the list of arguments
+  # @return [void]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/gems.rb#18
+  def run(*args); end
+
+  private
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/gems.rb#47
+  def add_gems(gems); end
+
+  # Builds .yardoc files for all non-existing gems
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/gems.rb#27
+  def build_gems; end
+
+  # Parses options
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/gems.rb#61
+  def optparse(*args); end
+end
+
+# A command-line utility to generate Graphviz graphs from
+# a set of objects
+#
+# @see Graph#run
+# @since 0.6.0
+#
+# source://yard//lib/yard/cli/graph.rb#24
+class YARD::CLI::Graph < ::YARD::CLI::YardoptsCommand
+  # Creates a new instance of the command-line utility
+  #
+  # @return [Graph] a new instance of Graph
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/graph.rb#34
+  def initialize; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/graph.rb#42
+  def description; end
+
+  # The set of objects to include in the graph.
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/graph.rb#31
+  def objects; end
+
+  # The options parsed out of the commandline.
+  # Default options are:
+  #   :format => :dot
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/graph.rb#28
+  def options; end
+
+  # Runs the command-line utility.
+  #
+  # @example
+  #   grapher = Graph.new
+  #   grapher.run('--private')
+  # @param args [Array<String>] each tokenized argument
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/graph.rb#52
+  def run(*args); end
+
+  private
+
+  # Parses commandline options.
+  #
+  # @param args [Array<String>] each tokenized argument
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/graph.rb#69
+  def optparse(*args); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/graph.rb#65
+  def unrecognized_option(err); end
+end
+
+# Options to pass to the {Graph} CLI.
+#
+# source://yard//lib/yard/cli/graph.rb#5
+class YARD::CLI::GraphOptions < ::YARD::Templates::TemplateOptions
+  # @return [String] any contents to pass to the digraph
+  #
+  # source://yard//lib/yard/cli/graph.rb#16
+  def contents; end
+
+  # @return [String] any contents to pass to the digraph
+  #
+  # source://yard//lib/yard/cli/graph.rb#16
+  def contents=(_arg0); end
+
+  # @return [Boolean] whether to show the object dependencies
+  #
+  # source://yard//lib/yard/cli/graph.rb#13
+  def dependencies; end
+
+  # @return [Boolean] whether to show the object dependencies
+  #
+  # source://yard//lib/yard/cli/graph.rb#13
+  def dependencies=(_arg0); end
+
+  # @return [:dot] the default output format
+  #
+  # source://yard//lib/yard/options.rb#82
+  def format; end
+
+  # source://yard//lib/yard/options.rb#82
+  def format=(_arg0); end
+
+  # @return [Boolean] whether to list the full class diagram
+  #
+  # source://yard//lib/yard/cli/graph.rb#10
+  def full; end
+
+  # @return [Boolean] whether to list the full class diagram
+  #
+  # source://yard//lib/yard/cli/graph.rb#10
+  def full=(_arg0); end
+end
+
+# Handles help for commands
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/cli/help.rb#6
+class YARD::CLI::Help < ::YARD::CLI::Command
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/help.rb#7
+  def description; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/help.rb#9
+  def run(*args); end
+end
+
+# CLI command to support internationalization (a.k.a. i18n).
+# I18n feature is based on gettext technology.
+# This command generates .pot file from docstring and extra
+# documentation.
+#
+# @since 0.8.0
+# @todo Support msgminit and msgmerge features?
+#
+# source://yard//lib/yard/cli/i18n.rb#13
+class YARD::CLI::I18n < ::YARD::CLI::Yardoc
+  # @return [I18n] a new instance of I18n
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/cli/i18n.rb#14
+  def initialize; end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/cli/i18n.rb#19
+  def description; end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/cli/i18n.rb#23
+  def run(*args); end
+
+  private
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/cli/i18n.rb#44
+  def general_options(opts); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/cli/i18n.rb#61
+  def generate_pot(relative_base_path); end
+end
+
+# Lists all constant and method names in the codebase. Uses {Yardoc} --list.
+#
+# source://yard//lib/yard/cli/list.rb#5
+class YARD::CLI::List < ::YARD::CLI::Command
+  # source://yard//lib/yard/cli/list.rb#6
+  def description; end
+
+  # Runs the commandline utility, parsing arguments and displaying a
+  # list of objects
+  #
+  # @param args [Array<String>] the list of arguments.
+  # @return [void]
+  #
+  # source://yard//lib/yard/cli/list.rb#13
+  def run(*args); end
+end
+
+# Lists all markup types
+#
+# @since 0.8.6
+#
+# source://yard//lib/yard/cli/markup_types.rb#6
+class YARD::CLI::MarkupTypes < ::YARD::CLI::Command
+  # @since 0.8.6
+  #
+  # source://yard//lib/yard/cli/markup_types.rb#7
+  def description; end
+
+  # Runs the commandline utility, parsing arguments and displaying a
+  # list of markup types
+  #
+  # @param args [Array<String>] the list of arguments.
+  # @return [void]
+  # @since 0.8.6
+  #
+  # source://yard//lib/yard/cli/markup_types.rb#14
+  def run(*args); end
+end
+
+# A local documentation server
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/cli/server.rb#7
+class YARD::CLI::Server < ::YARD::CLI::Command
+  # Creates a new instance of the Server command line utility
+  #
+  # @return [Server] a new instance of Server
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#29
+  def initialize; end
+
+  # @return [YARD::Server::Adapter] the adapter to use for loading the web server
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#18
+  def adapter; end
+
+  # @return [YARD::Server::Adapter] the adapter to use for loading the web server
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#18
+  def adapter=(_arg0); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#41
+  def description; end
+
+  # @return [Hash] a list of library names and yardoc files to serve
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#15
+  def libraries; end
+
+  # @return [Hash] a list of library names and yardoc files to serve
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#15
+  def libraries=(_arg0); end
+
+  # @return [Hash] a list of options to pass to the doc server
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#9
+  def options; end
+
+  # @return [Hash] a list of options to pass to the doc server
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#9
+  def options=(_arg0); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#45
+  def run(*args); end
+
+  # @return [Array<String>] a list of scripts to load
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/server.rb#22
+  def scripts; end
+
+  # @return [Array<String>] a list of scripts to load
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/server.rb#22
+  def scripts=(_arg0); end
+
+  # @return [Hash] a list of options to pass to the web server
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#12
+  def server_options; end
+
+  # @return [Hash] a list of options to pass to the web server
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#12
+  def server_options=(_arg0); end
+
+  # @return [Array<String>] a list of template paths to register
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/server.rb#26
+  def template_paths; end
+
+  # @return [Array<String>] a list of template paths to register
+  # @since 0.6.2
+  #
+  # source://yard//lib/yard/cli/server.rb#26
+  def template_paths=(_arg0); end
+
+  private
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#131
+  def add_gems; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#140
+  def add_gems_from_gemfile(gemfile = T.unsafe(nil)); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#76
+  def add_libraries(args); end
+
+  # @param library [String] The library name.
+  # @param dir [String, nil] The argument provided on the CLI after the
+  #   library name. Is supposed to point to either a project directory
+  #   with a Yard options file, or a yardoc db.
+  # @return [LibraryVersion, nil]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#115
+  def create_library_version_if_yardopts_exist(library, dir); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#249
+  def extract_db_from_options_file(options_file); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#239
+  def generate_doc_for_first_time(libver); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#56
+  def load_scripts; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#60
+  def load_template_paths; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#156
+  def optparse(*args); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/server.rb#66
+  def select_adapter; end
+end
+
+# @since 0.6.0
+#
+# source://yard//lib/yard/cli/stats.rb#5
+class YARD::CLI::Stats < ::YARD::CLI::Yardoc
+  include ::YARD::Templates::Helpers::BaseHelper
+
+  # @param parse [Boolean] whether to parse and load registry (see {#parse})
+  # @return [Stats] a new instance of Stats
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#18
+  def initialize(parse = T.unsafe(nil)); end
+
+  # @return [Array<CodeObjects::Base>] all the parsed objects in the registry,
+  #   removing any objects that are not visible (private, protected) depending
+  #   on the arguments passed to the command.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#108
+  def all_objects; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#25
+  def description; end
+
+  # Prints a statistic to standard out. This method is optimized for
+  # getting Integer values, though it allows any data to be printed.
+  #
+  # @param name [String] the statistic name
+  # @param data [Integer, String] the numeric (or any) data representing
+  #   the statistic. If +data+ is an Integer, it should represent the
+  #   total objects of a type.
+  # @param undoc [Integer, nil] number of undocumented objects for the type
+  # @return [void]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#162
+  def output(name, data, undoc = T.unsafe(nil)); end
+
+  # @return [Boolean] whether to parse and load registry
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#15
+  def parse; end
+
+  # @return [Boolean] whether to parse and load registry
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#15
+  def parse=(_arg0); end
+
+  # Prints statistics for different object types
+  #
+  # To add statistics for a specific type, add a method +#stats_for_TYPE+
+  # to this class that calls {#output}.
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#54
+  def print_statistics; end
+
+  # Prints list of undocumented objects
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#79
+  def print_undocumented_objects; end
+
+  # Runs the commandline utility, parsing arguments and generating
+  # output if set.
+  #
+  # @param args [Array<String>] the list of arguments
+  # @return [void]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#34
+  def run(*args); end
+
+  # Statistics for attributes
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#135
+  def stats_for_attributes; end
+
+  # Statistics for classes
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#125
+  def stats_for_classes; end
+
+  # Statistics for constants
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#130
+  def stats_for_constants; end
+
+  # Statistics for files
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#113
+  def stats_for_files; end
+
+  # Statistics for methods
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#144
+  def stats_for_methods; end
+
+  # Statistics for modules
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#120
+  def stats_for_modules; end
+
+  private
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#199
+  def general_options(opts); end
+
+  # Parses commandline options.
+  #
+  # @param args [Array<String>] each tokenized argument
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#185
+  def optparse(*args); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/stats.rb#176
+  def type_statistics(type); end
+end
+
+# Maintains the order in which +stats_for_+ statistics methods should be
+# printed.
+#
+# @see #print_statistics
+# @since 0.6.0
+#
+# source://yard//lib/yard/cli/stats.rb#12
+YARD::CLI::Stats::STATS_ORDER = T.let(T.unsafe(nil), Array)
+
+# A tool to view documentation in the console like `ri`
+#
+# source://yard//lib/yard/cli/yri.rb#7
+class YARD::CLI::YRI < ::YARD::CLI::Command
+  # @return [YRI] a new instance of YRI
+  #
+  # source://yard//lib/yard/cli/yri.rb#31
+  def initialize; end
+
+  # source://yard//lib/yard/cli/yri.rb#41
+  def description; end
+
+  # Runs the command-line utility.
+  #
+  # @example
+  #   YRI.new.run('String#reverse')
+  # @param args [Array<String>] each tokenized argument
+  #
+  # source://yard//lib/yard/cli/yri.rb#50
+  def run(*args); end
+
+  protected
+
+  # Caches the .yardoc file where an object can be found in the {CACHE_FILE}
+  #
+  # @return [void]
+  #
+  # source://yard//lib/yard/cli/yri.rb#85
+  def cache_object(name, path); end
+
+  # Locates an object by name starting in the cached paths and then
+  # searching through any search paths.
+  #
+  # @param name [String] the full name of the object
+  # @return [CodeObjects::Base] an object if found
+  # @return [nil] if no object is found
+  #
+  # source://yard//lib/yard/cli/yri.rb#113
+  def find_object(name); end
+
+  # @param object [CodeObjects::Base] the object to print.
+  # @return [String] the formatted output for an object.
+  #
+  # source://yard//lib/yard/cli/yri.rb#98
+  def print_object(object); end
+
+  # Prints the command usage
+  #
+  # @return [void]
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/cli/yri.rb#78
+  def print_usage; end
+
+  private
+
+  # Adds paths in {SEARCH_PATHS_FILE}
+  #
+  # @since 0.5.1
+  #
+  # source://yard//lib/yard/cli/yri.rb#181
+  def add_default_paths; end
+
+  # Adds all RubyGems yardoc files to search paths
+  #
+  # @return [void]
+  #
+  # source://yard//lib/yard/cli/yri.rb#161
+  def add_gem_paths; end
+
+  # Loads {CACHE_FILE}
+  #
+  # @return [void]
+  #
+  # source://yard//lib/yard/cli/yri.rb#151
+  def load_cache; end
+
+  # Parses commandline options.
+  #
+  # @param args [Array<String>] each tokenized argument
+  #
+  # source://yard//lib/yard/cli/yri.rb#190
+  def optparse(*args); end
+
+  # Tries to load the object with name. If successful, caches the object
+  # with the cache_path
+  #
+  # @param name [String] the object path
+  # @param cache_path [String] the location of the yardoc
+  #   db containing the object to cache for future lookups.
+  #   No caching is done if this is nil.
+  # @return [void]
+  #
+  # source://yard//lib/yard/cli/yri.rb#143
+  def try_load_object(name, cache_path); end
+
+  class << self
+    # Helper method to run the utility on an instance.
+    #
+    # @see #run
+    #
+    # source://yard//lib/yard/cli/yri.rb#29
+    def run(*args); end
+  end
+end
+
+# The location in {YARD::CONFIG_DIR} where the YRI cache file is loaded
+# from.
+#
+# source://yard//lib/yard/cli/yri.rb#10
+YARD::CLI::YRI::CACHE_FILE = T.let(T.unsafe(nil), String)
+
+# Default search paths that should be loaded dynamically into YRI. These paths
+# take precedence over all other paths ({SEARCH_PATHS_FILE} and RubyGems
+# paths). To add a path, call:
+#
+#   DEFAULT_SEARCH_PATHS.push("/path/to/.yardoc")
+#
+# @return [Array<String>] a list of extra search paths
+# @since 0.6.0
+#
+# source://yard//lib/yard/cli/yri.rb#25
+YARD::CLI::YRI::DEFAULT_SEARCH_PATHS = T.let(T.unsafe(nil), Array)
+
+# A file containing all paths, delimited by newlines, to search for
+# yardoc databases.
+#
+# @since 0.5.1
+#
+# source://yard//lib/yard/cli/yri.rb#15
+YARD::CLI::YRI::SEARCH_PATHS_FILE = T.let(T.unsafe(nil), String)
+
+# source://yard//lib/yard/cli/yardoc.rb#145
+class YARD::CLI::Yardoc < ::YARD::CLI::YardoptsCommand
+  # Creates a new instance of the commandline utility
+  #
+  # @return [Yardoc] a new instance of Yardoc
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#207
+  def initialize; end
+
+  # The list of all objects to process. Override this method to change
+  # which objects YARD should generate documentation for.
+  #
+  # @deprecated To hide methods use the +@private+ tag instead.
+  # @return [Array<CodeObjects::Base>] a list of code objects to process
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#330
+  def all_objects; end
+
+  # Keep track of which APIs are to be shown
+  #
+  # @return [Array<String>] a list of APIs
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#180
+  def apis; end
+
+  # Keep track of which APIs are to be shown
+  #
+  # @return [Array<String>] a list of APIs
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#180
+  def apis=(_arg0); end
+
+  # @return [Array<String>] a list of assets to copy after generation
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#197
+  def assets; end
+
+  # @return [Array<String>] a list of assets to copy after generation
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#197
+  def assets=(_arg0); end
+
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#234
+  def description; end
+
+  # @return [Array<String>] list of excluded paths (regexp matches)
+  # @since 0.5.3
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#155
+  def excluded; end
+
+  # @return [Array<String>] list of excluded paths (regexp matches)
+  # @since 0.5.3
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#155
+  def excluded=(_arg0); end
+
+  # @return [Boolean] whether yard exits with error status code if a warning occurs
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#204
+  def fail_on_warning; end
+
+  # @return [Boolean] whether yard exits with error status code if a warning occurs
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#204
+  def fail_on_warning=(_arg0); end
+
+  # @return [Array<String>] list of Ruby source files to process
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#151
+  def files; end
+
+  # @return [Array<String>] list of Ruby source files to process
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#151
+  def files=(_arg0); end
+
+  # @return [Boolean] whether to generate output
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#166
+  def generate; end
+
+  # @return [Boolean] whether to generate output
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#166
+  def generate=(_arg0); end
+
+  # @return [Boolean] whether markup option was specified
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#201
+  def has_markup; end
+
+  # @return [Boolean] whether markup option was specified
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#201
+  def has_markup=(_arg0); end
+
+  # Keep track of which APIs are to be hidden
+  #
+  # @return [Array<String>] a list of APIs to be hidden
+  # @since 0.8.7
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#185
+  def hidden_apis; end
+
+  # Keep track of which APIs are to be hidden
+  #
+  # @return [Array<String>] a list of APIs to be hidden
+  # @since 0.8.7
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#185
+  def hidden_apis=(_arg0); end
+
+  # @return [Array<Symbol>] a list of tags to hide from templates
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#189
+  def hidden_tags; end
+
+  # @return [Array<Symbol>] a list of tags to hide from templates
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#189
+  def hidden_tags=(_arg0); end
+
+  # @return [Boolean] whether to print a list of objects
+  # @since 0.5.5
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#170
+  def list; end
+
+  # @return [Boolean] whether to print a list of objects
+  # @since 0.5.5
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#170
+  def list=(_arg0); end
+
+  # @return [Hash] the hash of options passed to the template.
+  # @see Templates::Engine#render
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#148
+  def options; end
+
+  # Parses commandline arguments
+  #
+  # @param args [Array<String>] the list of arguments
+  # @return [Boolean] whether or not arguments are valid
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#291
+  def parse_arguments(*args); end
+
+  # Runs the commandline utility, parsing arguments and generating
+  # output if set.
+  #
+  # @param args [Array<String>] the list of arguments. If the list only
+  #   contains a single nil value, skip calling of {#parse_arguments}
+  # @return [void]
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#244
+  def run(*args); end
+
+  # @return [Boolean] whether objects should be serialized to .yardoc db
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#163
+  def save_yardoc; end
+
+  # @return [Boolean] whether objects should be serialized to .yardoc db
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#163
+  def save_yardoc=(_arg0); end
+
+  # @return [Boolean] whether to print statistics after parsing
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#193
+  def statistics; end
+
+  # @return [Boolean] whether to print statistics after parsing
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#193
+  def statistics=(_arg0); end
+
+  # @return [Boolean] whether to use the existing yardoc db if the
+  #   .yardoc already exists. Also makes use of file checksums to
+  #   parse only changed files.
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#160
+  def use_cache; end
+
+  # @return [Boolean] whether to use the existing yardoc db if the
+  #   .yardoc already exists. Also makes use of file checksums to
+  #   parse only changed files.
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#160
+  def use_cache=(_arg0); end
+
+  # Keep track of which visibilities are to be shown
+  #
+  # @return [Array<Symbol>] a list of visibilities
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#175
+  def visibilities; end
+
+  # Keep track of which visibilities are to be shown
+  #
+  # @return [Array<Symbol>] a list of visibilities
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#175
+  def visibilities=(_arg0); end
+
+  private
+
+  # Adds verifier rule for APIs
+  #
+  # @return [void]
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#474
+  def add_api_verifier; end
+
+  # Adds a set of extra documentation files to be processed
+  #
+  # @param files [Array<String>] the set of documentation files
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#413
+  def add_extra_files(*files); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#507
+  def add_tag(tag_data, factory_method = T.unsafe(nil)); end
+
+  # Adds verifier rule for visibilities
+  #
+  # @return [void]
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#466
+  def add_visibility_verifier; end
+
+  # Applies the specified locale to collected objects
+  #
+  # @return [void]
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#494
+  def apply_locale; end
+
+  # Copies any assets to the output directory
+  #
+  # @return [void]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#389
+  def copy_assets; end
+
+  # @param file [String] the filename to validate
+  # @param check_exists [Boolean] whether the file should exist on disk
+  # @return [Boolean] whether the file is allowed to be used
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#425
+  def extra_file_valid?(file, check_exists = T.unsafe(nil)); end
+
+  # Adds general options
+  #
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#541
+  def general_options(opts); end
+
+  # Parses commandline options.
+  #
+  # @param args [Array<String>] each tokenized argument
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#516
+  def optparse(*args); end
+
+  # Adds output options
+  #
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#586
+  def output_options(opts); end
+
+  # Parses the file arguments into Ruby files and extra files, which are
+  # separated by a '-' element.
+  #
+  # @example Parses a set of Ruby source files
+  #   parse_files %w(file1 file2 file3)
+  # @example Parses a set of Ruby files with a separator and extra files
+  #   parse_files %w(file1 file2 - extrafile1 extrafile2)
+  # @param files [Array<String>] the list of files to parse
+  # @return [void]
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#446
+  def parse_files(*files); end
+
+  # Prints a list of all objects
+  #
+  # @return [void]
+  # @since 0.5.5
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#403
+  def print_list; end
+
+  # Generates output for objects
+  #
+  # @param checksums [Hash, nil] if supplied, a list of checksums for files.
+  # @return [void]
+  # @since 0.5.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#340
+  def run_generate(checksums); end
+
+  # Runs a list of objects against the {Verifier} object passed into the
+  # template and returns the subset of verified objects.
+  #
+  # @param list [Array<CodeObjects::Base>] a list of code objects
+  # @return [Array<CodeObjects::Base>] a list of code objects that match
+  #   the verifier. If no verifier is supplied, all objects are returned.
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#502
+  def run_verifier(list); end
+
+  # Adds tag options
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#753
+  def tag_options(opts); end
+
+  # Verifies that the markup options are valid before parsing any code.
+  # Failing early is better than failing late.
+  #
+  # @return [Boolean] whether the markup provider was successfully loaded.
+  # @since 0.2.1
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#364
+  def verify_markup_options; end
+end
+
+# Default options used in +yard doc+ command.
+#
+# source://yard//lib/yard/cli/yardoc.rb#8
+class YARD::CLI::YardocOptions < ::YARD::Templates::TemplateOptions
+  # @return [CodeObjects::ExtraFileObject] the file object being rendered.
+  #   The +object+ key is not used so that a file may be rendered in the context
+  #   of an object's namespace (for generating links).
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#48
+  def file; end
+
+  # @return [CodeObjects::ExtraFileObject] the file object being rendered.
+  #   The +object+ key is not used so that a file may be rendered in the context
+  #   of an object's namespace (for generating links).
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#48
+  def file=(_arg0); end
+
+  # @return [Array<CodeObjects::ExtraFileObject>] the list of extra files rendered along with objects
+  #
+  # source://yard//lib/yard/options.rb#82
+  def files; end
+
+  # source://yard//lib/yard/options.rb#82
+  def files=(_arg0); end
+
+  # @return [Symbol] the default output format (:html).
+  #
+  # source://yard//lib/yard/options.rb#82
+  def format; end
+
+  # source://yard//lib/yard/options.rb#82
+  def format=(_arg0); end
+
+  # @return [Numeric] An index value for rendering sequentially related templates
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#39
+  def index; end
+
+  # @return [Numeric] An index value for rendering sequentially related templates
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#39
+  def index=(_arg0); end
+
+  # @return [CodeObjects::Base] an extra item to send to a template that is not
+  #   the main rendered object
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#43
+  def item; end
+
+  # @return [CodeObjects::Base] an extra item to send to a template that is not
+  #   the main rendered object
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#43
+  def item=(_arg0); end
+
+  # @return [String] the current locale
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#51
+  def locale; end
+
+  # @return [String] the current locale
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#51
+  def locale=(_arg0); end
+
+  # @return [Array<CodeObjects::Base>] the list of code objects to render
+  #   the templates with.
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#36
+  def objects; end
+
+  # @return [Array<CodeObjects::Base>] the list of code objects to render
+  #   the templates with.
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#36
+  def objects=(_arg0); end
+
+  # @return [Boolean] whether the data should be rendered in a single page,
+  #   if the template supports it.
+  #
+  # source://yard//lib/yard/options.rb#82
+  def onefile; end
+
+  # source://yard//lib/yard/options.rb#82
+  def onefile=(_arg0); end
+
+  # @return [CodeObjects::ExtraFileObject] the README file object rendered
+  #   along with objects
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#32
+  def readme; end
+
+  # @return [CodeObjects::ExtraFileObject] the README file object rendered
+  #   along with objects
+  #
+  # source://yard//lib/yard/cli/yardoc.rb#32
+  def readme=(_arg0); end
+
+  # @return [Serializers::Base] the default serializer for generating output
+  #   to disk.
+  #
+  # source://yard//lib/yard/options.rb#82
+  def serializer; end
+
+  # source://yard//lib/yard/options.rb#82
+  def serializer=(_arg0); end
+
+  # @return [String] the default title appended to each generated page
+  #
+  # source://yard//lib/yard/options.rb#82
+  def title; end
+
+  # source://yard//lib/yard/options.rb#82
+  def title=(_arg0); end
+
+  # @return [Verifier] the default verifier object to filter queries
+  #
+  # source://yard//lib/yard/options.rb#82
+  def verifier; end
+
+  # source://yard//lib/yard/options.rb#82
+  def verifier=(_arg0); end
+end
+
+# Abstract base class for command that reads .yardopts file
+#
+# @abstract
+# @since 0.8.3
+#
+# source://yard//lib/yard/cli/yardopts_command.rb#10
+class YARD::CLI::YardoptsCommand < ::YARD::CLI::Command
+  # Creates a new command that reads .yardopts
+  #
+  # @return [YardoptsCommand] a new instance of YardoptsCommand
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/cli/yardopts_command.rb#25
+  def initialize; end
+
+  # The options file name (defaults to {DEFAULT_YARDOPTS_FILE})
+  #
+  # @return [String] the filename to load extra options from
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/cli/yardopts_command.rb#22
+  def options_file; end
+
+  # The options file name (defaults to {DEFAULT_YARDOPTS_FILE})
+  #
+  # @return [String] the filename to load extra options from
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/cli/yardopts_command.rb#22
+  def options_file=(_arg0); end
+
+  # Parses commandline arguments
+  #
+  # @param args [Array<String>] the list of arguments
+  # @return [Boolean] whether or not arguments are valid
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/cli/yardopts_command.rb#36
+  def parse_arguments(*args); end
+
+  # @return [Boolean] whether to parse options from .document
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/cli/yardopts_command.rb#18
+  def use_document_file; end
+
+  # @return [Boolean] whether to parse options from .document
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/cli/yardopts_command.rb#18
+  def use_document_file=(_arg0); end
+
+  # @return [Boolean] whether to parse options from .yardopts
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/cli/yardopts_command.rb#15
+  def use_yardopts_file; end
+
+  # @return [Boolean] whether to parse options from .yardopts
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/cli/yardopts_command.rb#15
+  def use_yardopts_file=(_arg0); end
+
+  protected
+
+  # Adds --[no-]yardopts / --[no-]document
+  #
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/cli/yardopts_command.rb#48
+  def yardopts_options(opts); end
+
+  private
+
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/cli/yardopts_command.rb#92
+  def parse_rdoc_document_file(file = T.unsafe(nil)); end
+
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/cli/yardopts_command.rb#96
+  def parse_yardopts(file = T.unsafe(nil)); end
+
+  # Parses out the yardopts/document options
+  #
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/cli/yardopts_command.rb#78
+  def parse_yardopts_options(*args); end
+
+  # Reads a .document file in the directory to get source file globs
+  #
+  # @return [Array<String>] an array of files parsed from .document
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/cli/yardopts_command.rb#102
+  def support_rdoc_document_file!(file = T.unsafe(nil)); end
+
+  # Parses the .yardopts file for default yard options
+  #
+  # @return [Array<String>] an array of options parsed from .yardopts
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/cli/yardopts_command.rb#70
+  def yardopts(file = T.unsafe(nil)); end
+end
+
+# The configuration filename to load extra options from
+#
+# @since 0.8.3
+#
+# source://yard//lib/yard/cli/yardopts_command.rb#12
+YARD::CLI::YardoptsCommand::DEFAULT_YARDOPTS_FILE = T.let(T.unsafe(nil), String)
+
+# @deprecated Use {Config::CONFIG_DIR}
+#
+# source://yard//lib/yard.rb#13
+YARD::CONFIG_DIR = T.let(T.unsafe(nil), String)
+
+# A "code object" is defined as any entity in the Ruby language.
+# Classes, modules, methods, class variables and constants are the
+# major objects, but DSL languages can create their own by inheriting
+# from {CodeObjects::Base}.
+#
+# source://yard//lib/yard/autoload.rb#29
+module YARD::CodeObjects
+  extend ::YARD::CodeObjects::NamespaceMapper
+end
+
+# All builtin Ruby classes and modules.
+#
+# source://yard//lib/yard/code_objects/base.rb#91
+YARD::CodeObjects::BUILTIN_ALL = T.let(T.unsafe(nil), Array)
+
+# All builtin Ruby classes for inheritance tree.
+#
+# @note MatchingData is a 1.8.x legacy class
+#
+# source://yard//lib/yard/code_objects/base.rb#78
+YARD::CodeObjects::BUILTIN_CLASSES = T.let(T.unsafe(nil), Array)
+
+# All builtin Ruby exception classes for inheritance tree.
+#
+# source://yard//lib/yard/code_objects/base.rb#67
+YARD::CodeObjects::BUILTIN_EXCEPTIONS = T.let(T.unsafe(nil), Array)
+
+# Hash of {BUILTIN_EXCEPTIONS} as keys and true as value (for O(1) lookups)
+#
+# source://yard//lib/yard/code_objects/base.rb#94
+YARD::CodeObjects::BUILTIN_EXCEPTIONS_HASH = T.let(T.unsafe(nil), Hash)
+
+# All builtin Ruby modules for mixin handling.
+#
+# source://yard//lib/yard/code_objects/base.rb#87
+YARD::CodeObjects::BUILTIN_MODULES = T.let(T.unsafe(nil), Array)
+
+# +Base+ is the superclass of all code objects recognized by YARD. A code
+# object is any entity in the Ruby language (class, method, module). A
+# DSL might subclass +Base+ to create a new custom object representing
+# a new entity type.
+#
+# == Registry Integration
+# Any created object associated with a namespace is immediately registered
+# with the registry. This allows the Registry to act as an identity map
+# to ensure that no object is represented by more than one Ruby object
+# in memory. A unique {#path} is essential for this identity map to work
+# correctly.
+#
+# == Custom Attributes
+# Code objects allow arbitrary custom attributes to be set using the
+# {#[]=} assignment method.
+#
+# == Namespaces
+# There is a special type of object called a "namespace". These are subclasses
+# of the {NamespaceObject} and represent Ruby entities that can have
+# objects defined within them. Classically these are modules and classes,
+# though a DSL might create a custom {NamespaceObject} to describe a
+# specific set of objects.
+#
+# == Separators
+# Custom classes with different separator tokens should define their own
+# separators using the {NamespaceMapper.register_separator} method. The
+# standard Ruby separators have already been defined ('::', '#', '.', etc).
+#
+# @abstract This class should not be used directly. Instead, create a
+#   subclass that implements {#path}, {#sep} or {#type}. You might also
+#   need to register custom separators if {#sep} uses alternate separator
+#   tokens.
+# @see Registry
+# @see #path
+# @see #[]=
+# @see NamespaceObject
+# @see NamespaceMapper.register_separator
+#
+# source://yard//lib/yard/code_objects/base.rb#133
+class YARD::CodeObjects::Base
+  # Creates a new code object
+  #
+  # @example Create a method in the root namespace
+  #   CodeObjects::Base.new(:root, '#method') # => #<yardoc method #method>
+  # @example Create class Z inside namespace X::Y
+  #   CodeObjects::Base.new(P("X::Y"), :Z) # or
+  #   CodeObjects::Base.new(Registry.root, "X::Y")
+  # @param namespace [NamespaceObject] the namespace the object belongs in,
+  #   {Registry.root} or :root should be provided if it is associated with
+  #   the top level namespace.
+  # @param name [Symbol, String] the name (or complex path) of the object.
+  # @return [Base] the newly created object
+  # @yield [self] a block to perform any extra initialization on the object
+  # @yieldparam self [Base] the newly initialized code object
+  #
+  # source://yard//lib/yard/code_objects/base.rb#238
+  def initialize(namespace, name, *_arg2); end
+
+  # Tests if another object is equal to this, including a proxy
+  #
+  # @param other [Base, Proxy] if other is a {Proxy}, tests if
+  #   the paths are equal
+  # @return [Boolean] whether or not the objects are considered the same
+  #
+  # source://yard//lib/yard/code_objects/base.rb#323
+  def ==(other); end
+
+  # Accesses a custom attribute on the object
+  #
+  # @param key [#to_s] the name of the custom attribute
+  # @return [Object, nil] the custom attribute or nil if not found.
+  # @see #[]=
+  #
+  # source://yard//lib/yard/code_objects/base.rb#343
+  def [](key); end
+
+  # Sets a custom attribute on the object
+  #
+  # @param key [#to_s] the name of the custom attribute
+  # @param value [Object] the value to associate
+  # @return [void]
+  # @see #[]
+  #
+  # source://yard//lib/yard/code_objects/base.rb#356
+  def []=(key, value); end
+
+  # Associates a file with a code object, optionally adding the line where it was defined.
+  # By convention, '<stdin>' should be used to associate code that comes form standard input.
+  #
+  # @param file [String] the filename ('<stdin>' for standard input)
+  # @param line [Fixnum, nil] the line number where the object lies in the file
+  # @param has_comments [Boolean] whether or not the definition has comments associated. This
+  #   will allow {#file} to return the definition where the comments were made instead
+  #   of any empty definitions that might have been parsed before (module namespaces for instance).
+  # @raise [ArgumentError]
+  #
+  # source://yard//lib/yard/code_objects/base.rb#290
+  def add_file(file, line = T.unsafe(nil), has_comments = T.unsafe(nil)); end
+
+  # Add tags to the {#docstring}
+  #
+  # @see Docstring#add_tag
+  # @since 0.8.4
+  #
+  # source://yard//lib/yard/code_objects/base.rb#561
+  def add_tag(*tags); end
+
+  # The non-localized documentation string associated with the object
+  #
+  # @return [Docstring] the documentation string
+  # @since 0.8.4
+  #
+  # source://yard//lib/yard/code_objects/base.rb#166
+  def base_docstring; end
+
+  # Copies all data in this object to another code object, except for
+  # uniquely identifying information (path, namespace, name, scope).
+  #
+  # @param other [Base] the object to copy data to
+  # @return [Base] the other object
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/code_objects/base.rb#263
+  def copy_to(other); end
+
+  # The documentation string associated with the object
+  #
+  # @param locale [String, I18n::Locale] (I18n::Locale.default)
+  #   the locale of the documentation string.
+  # @return [Docstring] the documentation string
+  #
+  # source://yard//lib/yard/code_objects/base.rb#405
+  def docstring(locale = T.unsafe(nil)); end
+
+  # Attaches a docstring to a code object by parsing the comments attached to the statement
+  # and filling the {#tags} and {#docstring} methods with the parsed information.
+  #
+  # @param comments [String, Array<String>, Docstring] the comments attached to the code object to be parsed
+  #   into a docstring and meta tags.
+  #
+  # source://yard//lib/yard/code_objects/base.rb#427
+  def docstring=(comments); end
+
+  # Marks whether or not the method is conditionally defined at runtime
+  #
+  # @return [Boolean] true if the method is conditionally defined at runtime
+  #
+  # source://yard//lib/yard/code_objects/base.rb#170
+  def dynamic; end
+
+  # Marks whether or not the method is conditionally defined at runtime
+  #
+  # @return [Boolean] true if the method is conditionally defined at runtime
+  #
+  # source://yard//lib/yard/code_objects/base.rb#170
+  def dynamic=(_arg0); end
+
+  # Is the object defined conditionally at runtime?
+  #
+  # @return [Boolean]
+  # @see #dynamic
+  #
+  # source://yard//lib/yard/code_objects/base.rb#178
+  def dynamic?; end
+
+  # Tests if another object is equal to this, including a proxy
+  #
+  # @param other [Base, Proxy] if other is a {Proxy}, tests if
+  #   the paths are equal
+  # @return [Boolean] whether or not the objects are considered the same
+  #
+  # source://yard//lib/yard/code_objects/base.rb#323
+  def eql?(other); end
+
+  # Tests if another object is equal to this, including a proxy
+  #
+  # @param other [Base, Proxy] if other is a {Proxy}, tests if
+  #   the paths are equal
+  # @return [Boolean] whether or not the objects are considered the same
+  #
+  # source://yard//lib/yard/code_objects/base.rb#323
+  def equal?(other); end
+
+  # Returns the filename the object was first parsed at, taking
+  # definitions with docstrings first.
+  #
+  # @return [String] a filename
+  # @return [nil] if there is no file associated with the object
+  #
+  # source://yard//lib/yard/code_objects/base.rb#307
+  def file; end
+
+  # The files the object was defined in. To add a file, use {#add_file}.
+  #
+  # @return [Array<Array(String, Integer)>] a list of files
+  # @see #add_file
+  #
+  # source://yard//lib/yard/code_objects/base.rb#137
+  def files; end
+
+  # Renders the object using the {Templates::Engine templating system}.
+  #
+  # @example Formats a class in plaintext
+  #   puts P('MyClass').format
+  # @example Formats a method in html with rdoc markup
+  #   puts P('MyClass#meth').format(:format => :html, :markup => :rdoc)
+  # @option options
+  # @option options
+  # @option options
+  # @option options
+  # @param options [Hash] a set of options to pass to the template
+  # @return [String] the rendered template
+  # @see Templates::Engine#render
+  #
+  # source://yard//lib/yard/code_objects/base.rb#505
+  def format(options = T.unsafe(nil)); end
+
+  # @return [String] the group this object is associated with
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/code_objects/base.rb#174
+  def group; end
+
+  # @return [String] the group this object is associated with
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/code_objects/base.rb#174
+  def group=(_arg0); end
+
+  # Tests if the {#docstring} has a tag
+  #
+  # @return [Boolean]
+  # @see Docstring#has_tag?
+  #
+  # source://yard//lib/yard/code_objects/base.rb#556
+  def has_tag?(name); end
+
+  # @return [Integer] the object's hash value (for equality checking)
+  #
+  # source://yard//lib/yard/code_objects/base.rb#334
+  def hash; end
+
+  # Inspects the object, returning the type and path
+  #
+  # @return [String] a string describing the object
+  #
+  # source://yard//lib/yard/code_objects/base.rb#513
+  def inspect; end
+
+  # Returns the line the object was first parsed at (or nil)
+  #
+  # @return [Fixnum] the line where the object was first defined.
+  # @return [nil] if there is no line associated with the object
+  #
+  # source://yard//lib/yard/code_objects/base.rb#315
+  def line; end
+
+  # @overload dynamic_attr_name
+  # @overload dynamic_attr_name=
+  #
+  # source://yard//lib/yard/code_objects/base.rb#373
+  def method_missing(meth, *args, &block); end
+
+  # The name of the object
+  #
+  # @param prefix [Boolean] whether to show a prefix. Implement
+  #   this in a subclass to define how the prefix is showed.
+  # @return [Symbol] if prefix is false, the symbolized name
+  # @return [String] if prefix is true, prefix + the name as a String.
+  #   This must be implemented by the subclass.
+  #
+  # source://yard//lib/yard/code_objects/base.rb#278
+  def name(prefix = T.unsafe(nil)); end
+
+  # The namespace the object is defined in. If the object is in the
+  # top level namespace, this is {Registry.root}
+  #
+  # @return [NamespaceObject] the namespace object
+  #
+  # source://yard//lib/yard/code_objects/base.rb#142
+  def namespace; end
+
+  # Sets the namespace the object is defined in.
+  #
+  # @param obj [NamespaceObject, :root, nil] the new namespace (:root
+  #   for {Registry.root}). If obj is nil, the object is unregistered
+  #   from the Registry.
+  #
+  # source://yard//lib/yard/code_objects/base.rb#522
+  def namespace=(obj); end
+
+  # The namespace the object is defined in. If the object is in the
+  # top level namespace, this is {Registry.root}
+  #
+  # @return [NamespaceObject] the namespace object
+  #
+  # source://yard//lib/yard/code_objects/base.rb#142
+  def parent; end
+
+  # Sets the namespace the object is defined in.
+  #
+  # @param obj [NamespaceObject, :root, nil] the new namespace (:root
+  #   for {Registry.root}). If obj is nil, the object is unregistered
+  #   from the Registry.
+  #
+  # source://yard//lib/yard/code_objects/base.rb#522
+  def parent=(obj); end
+
+  # Represents the unique path of the object. The default implementation
+  # joins the path of {#namespace} with {#name} via the value of {#sep}.
+  # Custom code objects should ensure that the path is unique to the code
+  # object by either overriding {#sep} or this method.
+  #
+  # @example The path of an instance method
+  #   MethodObject.new(P("A::B"), :c).path # => "A::B#c"
+  # @return [String] the unique path of the object
+  # @see #sep
+  #
+  # source://yard//lib/yard/code_objects/base.rb#453
+  def path; end
+
+  # @param other [Base, String] another code object (or object path)
+  # @return [String] the shortest relative path from this object to +other+
+  # @since 0.5.3
+  #
+  # source://yard//lib/yard/code_objects/base.rb#475
+  def relative_path(other); end
+
+  # @return [Boolean] whether or not this object is a RootObject
+  #
+  # source://yard//lib/yard/code_objects/base.rb#567
+  def root?; end
+
+  # Override this method with a custom component separator. For instance,
+  # {MethodObject} implements sep as '#' or '.' (depending on if the
+  # method is instance or class respectively). {#path} depends on this
+  # value to generate the full path in the form: namespace.path + sep + name
+  #
+  # @return [String] the component that separates the namespace path
+  #   and the name (default is {NSEP})
+  #
+  # source://yard//lib/yard/code_objects/base.rb#576
+  def sep; end
+
+  # The one line signature representing an object. For a method, this will
+  # be of the form "def meth(arguments...)". This is usually the first
+  # source line.
+  #
+  # @return [String] a line of source
+  #
+  # source://yard//lib/yard/code_objects/base.rb#159
+  def signature; end
+
+  # The one line signature representing an object. For a method, this will
+  # be of the form "def meth(arguments...)". This is usually the first
+  # source line.
+  #
+  # @return [String] a line of source
+  #
+  # source://yard//lib/yard/code_objects/base.rb#159
+  def signature=(_arg0); end
+
+  # The source code associated with the object
+  #
+  # @return [String, nil] source, if present, or nil
+  #
+  # source://yard//lib/yard/code_objects/base.rb#146
+  def source; end
+
+  # Attaches source code to a code object with an optional file location
+  #
+  # @param statement [#source, String] the +Parser::Statement+ holding the source code or the raw source
+  #   as a +String+ for the definition of the code object only (not the block)
+  #
+  # source://yard//lib/yard/code_objects/base.rb#388
+  def source=(statement); end
+
+  # Language of the source code associated with the object. Defaults to
+  # +:ruby+.
+  #
+  # @return [Symbol] the language type
+  #
+  # source://yard//lib/yard/code_objects/base.rb#152
+  def source_type; end
+
+  # Language of the source code associated with the object. Defaults to
+  # +:ruby+.
+  #
+  # @return [Symbol] the language type
+  #
+  # source://yard//lib/yard/code_objects/base.rb#152
+  def source_type=(_arg0); end
+
+  # Gets a tag from the {#docstring}
+  #
+  # @see Docstring#tag
+  #
+  # source://yard//lib/yard/code_objects/base.rb#548
+  def tag(name); end
+
+  # Gets a list of tags from the {#docstring}
+  #
+  # @see Docstring#tags
+  #
+  # source://yard//lib/yard/code_objects/base.rb#552
+  def tags(name = T.unsafe(nil)); end
+
+  # @note Override this method if your object has a special title that does
+  #   not match the {#path} attribute value. This title will be used
+  #   when linking or displaying the object.
+  # @return [String] the display title for an object
+  # @see 0.8.4
+  #
+  # source://yard//lib/yard/code_objects/base.rb#468
+  def title; end
+
+  # @return [nil] this object does not turn into an array
+  #
+  # source://yard//lib/yard/code_objects/base.rb#337
+  def to_ary; end
+
+  # Represents the unique path of the object. The default implementation
+  # joins the path of {#namespace} with {#name} via the value of {#sep}.
+  # Custom code objects should ensure that the path is unique to the code
+  # object by either overriding {#sep} or this method.
+  #
+  # @example The path of an instance method
+  #   MethodObject.new(P("A::B"), :c).path # => "A::B#c"
+  # @return [String] the unique path of the object
+  # @see #sep
+  #
+  # source://yard//lib/yard/code_objects/base.rb#453
+  def to_s; end
+
+  # Default type is the lowercase class name without the "Object" suffix.
+  # Override this method to provide a custom object type
+  #
+  # @return [Symbol] the type of code object this represents
+  #
+  # source://yard//lib/yard/code_objects/base.rb#437
+  def type; end
+
+  # @return [Symbol] the visibility of an object (:public, :private, :protected)
+  #
+  # source://yard//lib/yard/code_objects/base.rb#181
+  def visibility; end
+
+  # @return [Symbol] the visibility of an object (:public, :private, :protected)
+  #
+  # source://yard//lib/yard/code_objects/base.rb#183
+  def visibility=(v); end
+
+  protected
+
+  # Override this method if your code object subclass does not allow
+  # copying of certain attributes.
+  #
+  # @return [Array<String>] the list of instance variable names (without
+  #   "@" prefix) that should be copied when {#copy_to} is called
+  # @see #copy_to
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/code_objects/base.rb#587
+  def copyable_attributes; end
+
+  private
+
+  # Formats source code by removing leading indentation
+  #
+  # @param source [String] the source code to format
+  # @return [String] formatted source
+  #
+  # source://yard//lib/yard/code_objects/base.rb#599
+  def format_source(source); end
+
+  # source://yard//lib/yard/code_objects/base.rb#606
+  def translate_docstring(locale); end
+
+  class << self
+    # Compares the class with subclasses
+    #
+    # @param other [Object] the other object to compare classes with
+    # @return [Boolean] true if other is a subclass of self
+    #
+    # source://yard//lib/yard/code_objects/base.rb#219
+    def ===(other); end
+
+    # Allocates a new code object
+    #
+    # @raise [ArgumentError]
+    # @return [Base]
+    # @see #initialize
+    # @yield [obj]
+    #
+    # source://yard//lib/yard/code_objects/base.rb#189
+    def new(namespace, name, *args, &block); end
+  end
+end
+
+# Regular expression to match constant name
+#
+# source://yard//lib/yard/code_objects/base.rb#52
+YARD::CodeObjects::CONSTANTMATCH = T.let(T.unsafe(nil), Regexp)
+
+# Regular expression to match the beginning of a constant
+#
+# source://yard//lib/yard/code_objects/base.rb#55
+YARD::CodeObjects::CONSTANTSTART = T.let(T.unsafe(nil), Regexp)
+
+# Class method separator
+#
+# source://yard//lib/yard/code_objects/base.rb#46
+YARD::CodeObjects::CSEP = T.let(T.unsafe(nil), String)
+
+# Regex-quoted class method separator
+#
+# source://yard//lib/yard/code_objects/base.rb#49
+YARD::CodeObjects::CSEPQ = T.let(T.unsafe(nil), String)
+
+# A ClassObject represents a Ruby class in source code. It is a {ModuleObject}
+# with extra inheritance semantics through the superclass.
+#
+# source://yard//lib/yard/code_objects/class_object.rb#7
+class YARD::CodeObjects::ClassObject < ::YARD::CodeObjects::NamespaceObject
+  # Creates a new class object in +namespace+ with +name+
+  #
+  # @return [ClassObject] a new instance of ClassObject
+  # @see Base.new
+  #
+  # source://yard//lib/yard/code_objects/class_object.rb#15
+  def initialize(namespace, name, *args, &block); end
+
+  # Returns the list of constants matching the options hash.
+  #
+  # @option opts
+  # @option opts
+  # @param opts [Hash] the options hash to match
+  # @return [Array<ConstantObject>] the list of constant that matched
+  #
+  # source://yard//lib/yard/code_objects/class_object.rb#101
+  def constants(opts = T.unsafe(nil)); end
+
+  # Returns the inheritance tree of the object including self.
+  #
+  # @param include_mods [Boolean] whether or not to include mixins in the
+  #   inheritance tree.
+  # @return [Array<NamespaceObject>] the list of code objects that make up
+  #   the inheritance tree.
+  #
+  # source://yard//lib/yard/code_objects/class_object.rb#45
+  def inheritance_tree(include_mods = T.unsafe(nil)); end
+
+  # Returns only the constants that were inherited.
+  #
+  # @return [Array<ConstantObject>] the list of inherited constant objects
+  #
+  # source://yard//lib/yard/code_objects/class_object.rb#109
+  def inherited_constants; end
+
+  # Returns only the methods that were inherited.
+  #
+  # @return [Array<MethodObject>] the list of inherited method objects
+  #
+  # source://yard//lib/yard/code_objects/class_object.rb#79
+  def inherited_meths(opts = T.unsafe(nil)); end
+
+  # Whether or not the class is a Ruby Exception
+  #
+  # @return [Boolean] whether the object represents a Ruby exception
+  #
+  # source://yard//lib/yard/code_objects/class_object.rb#35
+  def is_exception?; end
+
+  # Returns the list of methods matching the options hash. Returns
+  # all methods if hash is empty.
+  #
+  # @option opts
+  # @option opts
+  # @param opts [Hash] the options hash to match
+  # @return [Array<MethodObject>] the list of methods that matched
+  #
+  # source://yard//lib/yard/code_objects/class_object.rb#66
+  def meths(opts = T.unsafe(nil)); end
+
+  # The {ClassObject} that this class object inherits from in Ruby source.
+  #
+  # @return [ClassObject] a class object that is the superclass of this one
+  #
+  # source://yard//lib/yard/code_objects/class_object.rb#10
+  def superclass; end
+
+  # Sets the superclass of the object
+  #
+  # @param object [Base, Proxy, String, Symbol, nil] the superclass value
+  # @return [void]
+  #
+  # source://yard//lib/yard/code_objects/class_object.rb#125
+  def superclass=(object); end
+end
+
+# Represents a class variable inside a namespace. The path is expressed
+# in the form "A::B::@@classvariable"
+#
+# source://yard//lib/yard/code_objects/class_variable_object.rb#7
+class YARD::CodeObjects::ClassVariableObject < ::YARD::CodeObjects::Base
+  # @return [String] the class variable's value
+  #
+  # source://yard//lib/yard/code_objects/class_variable_object.rb#9
+  def value; end
+
+  # @return [String] the class variable's value
+  #
+  # source://yard//lib/yard/code_objects/class_variable_object.rb#9
+  def value=(_arg0); end
+end
+
+# A list of code objects. This array acts like a set (no unique items)
+# but also disallows any {Proxy} objects from being added.
+#
+# source://yard//lib/yard/code_objects/base.rb#6
+class YARD::CodeObjects::CodeObjectList < ::Array
+  # Creates a new object list associated with a namespace
+  #
+  # @param owner [NamespaceObject] the namespace the list should be associated with
+  # @return [CodeObjectList]
+  #
+  # source://yard//lib/yard/code_objects/base.rb#11
+  def initialize(owner = T.unsafe(nil)); end
+
+  # Adds a new value to the list
+  #
+  # @param value [Base] a code object to add
+  # @return [CodeObjectList] self
+  #
+  # source://yard//lib/yard/code_objects/base.rb#19
+  def <<(value); end
+
+  # Adds a new value to the list
+  #
+  # @param value [Base] a code object to add
+  # @return [CodeObjectList] self
+  #
+  # source://yard//lib/yard/code_objects/base.rb#19
+  def push(value); end
+end
+
+# A +ConstantObject+ represents a Ruby constant (not a module or class).
+# To access the constant's (source code) value, use {#value}.
+#
+# source://yard//lib/yard/code_objects/constant_object.rb#7
+class YARD::CodeObjects::ConstantObject < ::YARD::CodeObjects::Base
+  # The source code representing the constant's value
+  #
+  # @return [String] the value the constant is set to
+  #
+  # source://yard//lib/yard/code_objects/constant_object.rb#10
+  def value; end
+
+  # source://yard//lib/yard/code_objects/constant_object.rb#12
+  def value=(value); end
+end
+
+# Represents an instance method of a module that was mixed into the class
+# scope of another namespace.
+#
+# @see MethodObject
+#
+# source://yard//lib/yard/code_objects/extended_method_object.rb#7
+class YARD::CodeObjects::ExtendedMethodObject
+  # Sets up a delegate for {MethodObject} obj.
+  #
+  # @param obj [MethodObject] the instance method to treat as a mixed in
+  #   class method on another namespace.
+  # @return [ExtendedMethodObject] a new instance of ExtendedMethodObject
+  #
+  # source://yard//lib/yard/code_objects/extended_method_object.rb#17
+  def initialize(obj); end
+
+  # Sends all methods to the {MethodObject} assigned in {#initialize}
+  #
+  # @see #initialize
+  # @see MethodObject
+  #
+  # source://yard//lib/yard/code_objects/extended_method_object.rb#22
+  def method_missing(sym, *args, &block); end
+
+  # @return [Symbol] always +:class+
+  #
+  # source://yard//lib/yard/code_objects/extended_method_object.rb#11
+  def scope; end
+end
+
+# An ExtraFileObject represents an extra documentation file (README or other
+# file). It is not strictly a CodeObject (does not inherit from `Base`) although
+# it implements `path`, `name` and `type`, and therefore should be structurally
+# compatible with most CodeObject interfaces.
+#
+# source://yard//lib/yard/code_objects/extra_file_object.rb#7
+class YARD::CodeObjects::ExtraFileObject
+  # Creates a new extra file object.
+  #
+  # @param filename [String] the location on disk of the file
+  # @param contents [String] the file contents. If not set, the contents
+  #   will be read from disk using the +filename+.
+  # @return [ExtraFileObject] a new instance of ExtraFileObject
+  #
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#18
+  def initialize(filename, contents = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#64
+  def ==(other); end
+
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#30
+  def attributes; end
+
+  # Sets the attribute attributes
+  #
+  # @param value the value to set the attribute attributes to.
+  #
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#9
+  def attributes=(_arg0); end
+
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#39
+  def contents; end
+
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#44
+  def contents=(contents); end
+
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#64
+  def eql?(other); end
+
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#64
+  def equal?(other); end
+
+  # Returns the value of attribute filename.
+  #
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#8
+  def filename; end
+
+  # Sets the attribute filename
+  #
+  # @param value the value to set the attribute filename to.
+  #
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#8
+  def filename=(_arg0); end
+
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#70
+  def hash; end
+
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#57
+  def inspect; end
+
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#12
+  def locale; end
+
+  # @param locale [String] the locale name to be translated.
+  # @return [void]
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#52
+  def locale=(locale); end
+
+  # Returns the value of attribute name.
+  #
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#10
+  def name; end
+
+  # Sets the attribute name
+  #
+  # @param value the value to set the attribute name to.
+  #
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#10
+  def name=(_arg0); end
+
+  # Returns the value of attribute name.
+  #
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#10
+  def path; end
+
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#35
+  def title; end
+
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#57
+  def to_s; end
+
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#62
+  def type; end
+
+  private
+
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#74
+  def ensure_parsed; end
+
+  # @param data [String] the file contents
+  #
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#81
+  def parse_contents(data); end
+
+  # source://yard//lib/yard/code_objects/extra_file_object.rb#129
+  def translate(data); end
+end
+
+# Instance method separator
+#
+# source://yard//lib/yard/code_objects/base.rb#40
+YARD::CodeObjects::ISEP = T.let(T.unsafe(nil), String)
+
+# Regex-quoted instance method separator
+#
+# source://yard//lib/yard/code_objects/base.rb#43
+YARD::CodeObjects::ISEPQ = T.let(T.unsafe(nil), String)
+
+# Regular expression to match a fully qualified method def (self.foo, Class.foo).
+#
+# source://yard//lib/yard/code_objects/base.rb#64
+YARD::CodeObjects::METHODMATCH = T.let(T.unsafe(nil), Regexp)
+
+# Regular expression to match a method name
+#
+# source://yard//lib/yard/code_objects/base.rb#61
+YARD::CodeObjects::METHODNAMEMATCH = T.let(T.unsafe(nil), Regexp)
+
+# A MacroObject represents a docstring defined through +@!macro NAME+ and can be
+# reused by specifying the tag +@!macro NAME+. You can also provide the
+# +attached+ type flag to the macro definition to have it attached to the
+# specific DSL method so it will be implicitly reused.
+#
+# Macros are fully described in the {file:docs/Tags.md#macro Tags Overview}
+# document.
+#
+# @example Creating a basic named macro
+#   # @!macro prop
+#   #   @!method $1(${3-})
+#   #   @return [$2] the value of the $0
+#   property :foo, String, :a, :b
+#
+#   # @!macro prop
+#   property :bar, Numeric, :value
+# @example Creating a macro that is attached to the method call
+#   # @!macro [attach] prop2
+#   #   @!method $1(value)
+#   property :foo
+#
+#   # Extra data added to docstring
+#   property :bar
+#
+# source://yard//lib/yard/code_objects/macro_object.rb#29
+class YARD::CodeObjects::MacroObject < ::YARD::CodeObjects::Base
+  # @return [Boolean] whether this macro is attached to a method
+  #
+  # source://yard//lib/yard/code_objects/macro_object.rb#148
+  def attached?; end
+
+  # Expands the macro using
+  #
+  # @example Expanding a Macro
+  #   macro.expand(%w(property foo bar), 'property :foo, :bar', '') #=>
+  #   "...macro data interpolating this line of code..."
+  # @param call_params [Array<String>] a list of tokens that are passed
+  #   to the method call
+  # @param full_source [String] the full method call (not including the block)
+  # @param block_source [String] the source passed in the block of the method
+  #   call, if there is a block.
+  # @see expand
+  #
+  # source://yard//lib/yard/code_objects/macro_object.rb#166
+  def expand(call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil)); end
+
+  # @return [String] the macro data stored on the object
+  #
+  # source://yard//lib/yard/code_objects/macro_object.rb#141
+  def macro_data; end
+
+  # @return [String] the macro data stored on the object
+  #
+  # source://yard//lib/yard/code_objects/macro_object.rb#141
+  def macro_data=(_arg0); end
+
+  # @return [CodeObjects::Base] the method object that this macro is
+  #   attached to.
+  #
+  # source://yard//lib/yard/code_objects/macro_object.rb#145
+  def method_object; end
+
+  # @return [CodeObjects::Base] the method object that this macro is
+  #   attached to.
+  #
+  # source://yard//lib/yard/code_objects/macro_object.rb#145
+  def method_object=(_arg0); end
+
+  # Overrides {Base#path} so the macro path is ".macro.MACRONAME"
+  #
+  # source://yard//lib/yard/code_objects/macro_object.rb#151
+  def path; end
+
+  # Overrides the separator to be '.'
+  #
+  # source://yard//lib/yard/code_objects/macro_object.rb#154
+  def sep; end
+
+  class << self
+    # Applies a macro on a docstring by creating any macro data inside of
+    # the docstring first. Equivalent to calling {find_or_create} and {apply_macro}
+    # on the new macro object.
+    #
+    # @param docstring [Docstring] the docstring to create a macro out of
+    # @param call_params [Array<String>] the method name and parameters
+    #   to the method call. These arguments will fill $0-N
+    # @param full_source [String] the full source line (excluding block)
+    #   interpolated as $*
+    # @param block_source [String] Currently unused. Will support
+    #   interpolating the block data as a variable.
+    # @return [String] the expanded macro data
+    # @see find_or_create
+    #
+    # source://yard//lib/yard/code_objects/macro_object.rb#119
+    def apply(docstring, call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil), _method_object = T.unsafe(nil)); end
+
+    # Applies a macro to a docstring, interpolating the macro's data on the
+    # docstring and appending any extra local docstring data that was in
+    # the original +docstring+ object.
+    #
+    # @param macro [MacroObject] the macro object
+    # @param call_params [Array<String>] the method name and parameters
+    #   to the method call. These arguments will fill $0-N
+    # @param full_source [String] the full source line (excluding block)
+    #   interpolated as $*
+    # @param block_source [String] Currently unused. Will support
+    #   interpolating the block data as a variable.
+    # @return [String] the expanded macro data
+    #
+    # source://yard//lib/yard/code_objects/macro_object.rb#135
+    def apply_macro(macro, docstring, call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil)); end
+
+    # Creates a new macro and fills in the relevant properties.
+    #
+    # @param macro_name [String] the name of the macro, must be unique.
+    # @param data [String] the data the macro should expand when re-used
+    # @param method_object [CodeObjects::Base] an object to attach this
+    #   macro to. If supplied, {#attached?} will be true
+    # @return [MacroObject] the newly created object
+    #
+    # source://yard//lib/yard/code_objects/macro_object.rb#39
+    def create(macro_name, data, method_object = T.unsafe(nil)); end
+
+    # Parses a given docstring and determines if the macro is "new" or
+    # not. If the macro has $variable names or if it has a @!macro tag
+    # with the [new] or [attached] flag, it is considered new.
+    #
+    # If a new macro is found, the macro is created and registered. Otherwise
+    # the macro name is searched and returned. If a macro is not found,
+    # nil is returned.
+    #
+    # @param macro_name [#to_s] the name of the macro
+    # @param method_object [CodeObjects::Base] an optional method to attach
+    #   the macro to. Only used if the macro is being created, otherwise
+    #   this argument is ignored.
+    # @return [MacroObject] the newly created or existing macro, depending
+    #   on whether the @!macro tag was a new tag or not.
+    # @return [nil] if the +data+ has no macro tag or if the macro is
+    #   not new and no macro by the macro name is found.
+    #
+    # source://yard//lib/yard/code_objects/macro_object.rb#70
+    def create_docstring(macro_name, data, method_object = T.unsafe(nil)); end
+
+    # Expands +macro_data+ using the interpolation parameters.
+    #
+    # Interpolation rules:
+    # * $0, $1, $2, ... = the Nth parameter in +call_params+
+    # * $* = the full statement source (excluding block)
+    # * Also supports $!{N-M} ranges, as well as negative indexes on N or M
+    # * Use \$ to escape the variable name in a macro.
+    #
+    # @param macro_data [String] the macro data to expand (taken from {#macro_data})
+    #
+    # source://yard//lib/yard/code_objects/macro_object.rb#92
+    def expand(macro_data, call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil)); end
+
+    # Finds a macro using +macro_name+
+    #
+    # @param macro_name [#to_s] the name of the macro
+    # @return [MacroObject] if a macro is found
+    # @return [nil] if there is no registered macro by that name
+    #
+    # source://yard//lib/yard/code_objects/macro_object.rb#50
+    def find(macro_name); end
+
+    # Parses a given docstring and determines if the macro is "new" or
+    # not. If the macro has $variable names or if it has a @!macro tag
+    # with the [new] or [attached] flag, it is considered new.
+    #
+    # If a new macro is found, the macro is created and registered. Otherwise
+    # the macro name is searched and returned. If a macro is not found,
+    # nil is returned.
+    #
+    # @param macro_name [#to_s] the name of the macro
+    # @param method_object [CodeObjects::Base] an optional method to attach
+    #   the macro to. Only used if the macro is being created, otherwise
+    #   this argument is ignored.
+    # @return [MacroObject] the newly created or existing macro, depending
+    #   on whether the @!macro tag was a new tag or not.
+    # @return [nil] if the +data+ has no macro tag or if the macro is
+    #   not new and no macro by the macro name is found.
+    #
+    # source://yard//lib/yard/code_objects/macro_object.rb#70
+    def find_or_create(macro_name, data, method_object = T.unsafe(nil)); end
+  end
+end
+
+# source://yard//lib/yard/code_objects/macro_object.rb#30
+YARD::CodeObjects::MacroObject::MACRO_MATCH = T.let(T.unsafe(nil), Regexp)
+
+# Represents a Ruby method in source
+#
+# source://yard//lib/yard/code_objects/method_object.rb#7
+class YARD::CodeObjects::MethodObject < ::YARD::CodeObjects::Base
+  # Creates a new method object in +namespace+ with +name+ and an instance
+  # or class +scope+
+  #
+  # If scope is +:module+, this object is instantiated as a public
+  # method in +:class+ scope, but also creates a new (empty) method
+  # as a private +:instance+ method on the same class or module.
+  #
+  # @param namespace [NamespaceObject] the namespace
+  # @param name [String, Symbol] the method name
+  # @param scope [Symbol] +:instance+, +:class+, or +:module+
+  # @return [MethodObject] a new instance of MethodObject
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#37
+  def initialize(namespace, name, scope = T.unsafe(nil), &block); end
+
+  # Returns all alias names of the object
+  #
+  # @return [Array<MethodObject>] the alias names
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#149
+  def aliases; end
+
+  # Returns the read/writer info for the attribute if it is one
+  #
+  # @return [SymbolHash] if there is information about the attribute
+  # @return [nil] if the method is not an attribute
+  # @since 0.5.3
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#93
+  def attr_info; end
+
+  # @return [Boolean] whether or not the method is the #initialize constructor method
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#78
+  def constructor?; end
+
+  # Whether the object is explicitly defined in source or whether it was
+  # inferred by a handler. For instance, attribute methods are generally
+  # inferred and therefore not explicitly defined in source.
+  #
+  # @return [Boolean] whether the object is explicitly defined in source.
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#18
+  def explicit; end
+
+  # Whether the object is explicitly defined in source or whether it was
+  # inferred by a handler. For instance, attribute methods are generally
+  # inferred and therefore not explicitly defined in source.
+  #
+  # @return [Boolean] whether the object is explicitly defined in source.
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#18
+  def explicit=(_arg0); end
+
+  # Tests if the object is defined as an alias of another method
+  #
+  # @return [Boolean] whether the object is an alias
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#126
+  def is_alias?; end
+
+  # Tests if the object is defined as an attribute in the namespace
+  #
+  # @return [Boolean] whether the object is an attribute
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#114
+  def is_attribute?; end
+
+  # Tests boolean {#explicit} value.
+  #
+  # @return [Boolean] whether the method is explicitly defined in source
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#134
+  def is_explicit?; end
+
+  # @return [Boolean] whether or not this method was created as a module
+  #   function
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#85
+  def module_function?; end
+
+  # Returns the name of the object.
+  #
+  # @example The name of an instance method (with prefix)
+  #   an_instance_method.name(true) # => "#mymethod"
+  # @example The name of a class method (with prefix)
+  #   a_class_method.name(true) # => "mymethod"
+  # @param prefix [Boolean] whether or not to show the prefix
+  # @return [String] returns {#sep} + +name+ for an instance method if
+  #   prefix is true
+  # @return [Symbol] the name without {#sep} if prefix is set to false
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#175
+  def name(prefix = T.unsafe(nil)); end
+
+  # @return [MethodObject] the object that this method overrides
+  # @return [nil] if it does not override a method
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#141
+  def overridden_method; end
+
+  # Returns the list of parameters parsed out of the method signature
+  # with their default values.
+  #
+  # @return [Array<Array(String, String)>] a list of parameter names followed
+  #   by their default values (or nil)
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#25
+  def parameters; end
+
+  # Returns the list of parameters parsed out of the method signature
+  # with their default values.
+  #
+  # @return [Array<Array(String, String)>] a list of parameter names followed
+  #   by their default values (or nil)
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#25
+  def parameters=(_arg0); end
+
+  # Override path handling for instance methods in the root namespace
+  # (they should still have a separator as a prefix).
+  #
+  # @return [String] the path of a method
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#161
+  def path; end
+
+  # @return [Boolean] whether the method is a reader attribute
+  # @since 0.5.3
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#107
+  def reader?; end
+
+  # The scope of the method (+:class+ or +:instance+)
+  #
+  # @return [Symbol] the scope
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#11
+  def scope; end
+
+  # Changes the scope of an object from :instance or :class
+  #
+  # @param v [Symbol] the new scope
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#58
+  def scope=(v); end
+
+  # Override separator to differentiate between class and instance
+  # methods.
+  #
+  # @return [String] "#" for an instance method, "." for class
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#182
+  def sep; end
+
+  # @return [Boolean] whether the method is a writer attribute
+  # @since 0.5.3
+  #
+  # source://yard//lib/yard/code_objects/method_object.rb#100
+  def writer?; end
+
+  protected
+
+  # source://yard//lib/yard/code_objects/method_object.rb#192
+  def copyable_attributes; end
+end
+
+# Represents a Ruby module.
+#
+# source://yard//lib/yard/code_objects/module_object.rb#6
+class YARD::CodeObjects::ModuleObject < ::YARD::CodeObjects::NamespaceObject
+  # Returns the inheritance tree of mixins.
+  #
+  # @param include_mods [Boolean] if true, will include mixed in
+  #   modules (which is likely what is wanted).
+  # @return [Array<NamespaceObject>] a list of namespace objects
+  #
+  # source://yard//lib/yard/code_objects/module_object.rb#12
+  def inheritance_tree(include_mods = T.unsafe(nil)); end
+end
+
+# Regular expression to match namespaces (const A or complex path A::B)
+#
+# source://yard//lib/yard/code_objects/base.rb#58
+YARD::CodeObjects::NAMESPACEMATCH = T.let(T.unsafe(nil), Regexp)
+
+# Namespace separator
+#
+# source://yard//lib/yard/code_objects/base.rb#34
+YARD::CodeObjects::NSEP = T.let(T.unsafe(nil), String)
+
+# Regex-quoted namespace separator
+#
+# source://yard//lib/yard/code_objects/base.rb#37
+YARD::CodeObjects::NSEPQ = T.let(T.unsafe(nil), String)
+
+# This module controls registration and accessing of namespace separators
+# for {Registry} lookup.
+#
+# @since 0.9.1
+#
+# source://yard//lib/yard/code_objects/namespace_mapper.rb#8
+module YARD::CodeObjects::NamespaceMapper
+  # Clears the map of separators.
+  #
+  # @return [void]
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/code_objects/namespace_mapper.rb#55
+  def clear_separators; end
+
+  # Gets or sets the default separator value to use when no
+  # separator for the namespace can be determined.
+  #
+  # @example
+  #   default_separator "::"
+  # @param value [String, nil] the default separator, or nil to return the
+  #   value
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/code_objects/namespace_mapper.rb#68
+  def default_separator(value = T.unsafe(nil)); end
+
+  # Registers a separator with an optional set of valid types that
+  # must follow the separator lexically.
+  #
+  # Calls all callbacks defined by {NamespaceMapper.on_invalidate} after
+  # the separator is registered.
+  #
+  # @example Registering separators for a method object
+  #   # Anything after a "#" denotes a method object
+  #   register_separator "#", :method
+  #   # Anything after a "." denotes a method object
+  #   register_separator ".", :method
+  # @param sep [String] the separator string for the namespace
+  # @param valid_types [Array<Symbol>] a list of object types that
+  #   must follow the separator. If the list is empty, any type can
+  #   follow the separator.
+  # @see .on_invalidate
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/code_objects/namespace_mapper.rb#27
+  def register_separator(sep, *valid_types); end
+
+  # @return [Array<String>] all of the registered separators
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/code_objects/namespace_mapper.rb#80
+  def separators; end
+
+  # @param type [String] the type to return separators for
+  # @return [Array<Symbol>] a list of separators registered to a type
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/code_objects/namespace_mapper.rb#97
+  def separators_for_type(type); end
+
+  # @return [Regexp] the regexp match of all separators
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/code_objects/namespace_mapper.rb#85
+  def separators_match; end
+
+  # @param sep [String] the separator to return types for
+  # @return [Array<Symbol>] a list of types registered to a separator
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/code_objects/namespace_mapper.rb#91
+  def types_for_separator(sep); end
+
+  # Unregisters a separator by a type.
+  #
+  # @param type [Symbol] the type to unregister
+  # @see #register_separator
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/code_objects/namespace_mapper.rb#43
+  def unregister_separator_by_type(type); end
+
+  class << self
+    # @return [String] the default separator when no separator can begin
+    #   determined.
+    # @since 0.9.1
+    #
+    # source://yard//lib/yard/code_objects/namespace_mapper.rb#137
+    def default_separator; end
+
+    # @return [String] the default separator when no separator can begin
+    #   determined.
+    # @since 0.9.1
+    #
+    # source://yard//lib/yard/code_objects/namespace_mapper.rb#137
+    def default_separator=(_arg0); end
+
+    # Invalidates all separators
+    #
+    # @return [void]
+    # @since 0.9.1
+    #
+    # source://yard//lib/yard/code_objects/namespace_mapper.rb#125
+    def invalidate; end
+
+    # @return [Hash] a mapping of types to separators
+    # @since 0.9.1
+    #
+    # source://yard//lib/yard/code_objects/namespace_mapper.rb#114
+    def map; end
+
+    # @return [Regexp] the full list of separators as a regexp match
+    # @since 0.9.1
+    #
+    # source://yard//lib/yard/code_objects/namespace_mapper.rb#131
+    def map_match; end
+
+    # Adds a callback that triggers when a new separator is registered or
+    # the cache is cleared by invalidation.
+    #
+    # @since 0.9.1
+    #
+    # source://yard//lib/yard/code_objects/namespace_mapper.rb#107
+    def on_invalidate(&block); end
+
+    # @return [Hash] a reverse mapping of separators to types
+    # @since 0.9.1
+    #
+    # source://yard//lib/yard/code_objects/namespace_mapper.rb#119
+    def rev_map; end
+  end
+end
+
+# A "namespace" is any object that can store other objects within itself.
+# The two main Ruby objects that can act as namespaces are modules
+# ({ModuleObject}) and classes ({ClassObject}).
+#
+# source://yard//lib/yard/code_objects/namespace_object.rb#9
+class YARD::CodeObjects::NamespaceObject < ::YARD::CodeObjects::Base
+  # Creates a new namespace object inside +namespace+ with +name+.
+  #
+  # @return [NamespaceObject] a new instance of NamespaceObject
+  # @see Base#initialize
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#56
+  def initialize(namespace, name, *args, &block); end
+
+  # A hash containing two keys, :class and :instance, each containing
+  # a hash of objects and their alias names.
+  #
+  # @return [Hash] a list of methods
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#44
+  def aliases; end
+
+  # A hash containing two keys, class and instance, each containing
+  # the attribute name with a { :read, :write } hash for the read and
+  # write objects respectively.
+  #
+  # @example The attributes of an object
+  #   >> Registry.at('YARD::Docstring').attributes
+  #   => {
+  #   :class => { },
+  #   :instance => {
+  #   :ref_tags => {
+  #   :read => #<yardoc method YARD::Docstring#ref_tags>,
+  #   :write => nil
+  #   },
+  #   :object => {
+  #   :read => #<yardoc method YARD::Docstring#object>,
+  #   :write => #<yardoc method YARD::Docstring#object=>
+  #   },
+  #   ...
+  #   }
+  #   }
+  # @return [Hash] a list of methods
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#39
+  def attributes; end
+
+  # Looks for a child that matches the attributes specified by +opts+.
+  #
+  # @example Finds a child by name and scope
+  #   namespace.child(:name => :to_s, :scope => :instance)
+  #   # => #<yardoc method MyClass#to_s>
+  # @return [Base, nil] the first matched child object, or nil
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#86
+  def child(opts = T.unsafe(nil)); end
+
+  # The list of objects defined in this namespace
+  #
+  # @return [Array<Base>] a list of objects
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#16
+  def children; end
+
+  # Only the class attributes
+  #
+  # @return [Hash] a list of method names and their read/write objects
+  # @see #attributes
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#69
+  def class_attributes; end
+
+  # Class mixins
+  #
+  # @return [Array<ModuleObject>] a list of mixins
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#48
+  def class_mixins; end
+
+  # Returns all constants in the namespace
+  #
+  # @option opts
+  # @param opts [Hash] a customizable set of options
+  # @return [Array<ConstantObject>] a list of constant objects
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#164
+  def constants(opts = T.unsafe(nil)); end
+
+  # Returns class variables defined in this namespace.
+  #
+  # @return [Array<ClassVariableObject>] a list of class variable objects
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#186
+  def cvars; end
+
+  # @return [Array<String>] a list of ordered group names inside the namespace
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#12
+  def groups; end
+
+  # @return [Array<String>] a list of ordered group names inside the namespace
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#12
+  def groups=(_arg0); end
+
+  # Returns constants included from any mixins
+  #
+  # @return [Array<ConstantObject>] a list of constant objects
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#172
+  def included_constants; end
+
+  # Returns methods included from any mixins that match the attributes
+  # specified by +opts+. If no options are specified, returns all included
+  # methods.
+  #
+  # @option opts
+  # @option opts
+  # @option opts
+  # @param opts [Hash] a customizable set of options
+  # @see #meths
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#144
+  def included_meths(opts = T.unsafe(nil)); end
+
+  # Only the instance attributes
+  #
+  # @return [Hash] a list of method names and their read/write objects
+  # @see #attributes
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#76
+  def instance_attributes; end
+
+  # Instance mixins
+  #
+  # @return [Array<ModuleObject>] a list of mixins
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#52
+  def instance_mixins; end
+
+  # Returns all methods that match the attributes specified by +opts+. If
+  # no options are provided, returns all methods.
+  #
+  # @example Finds all private and protected class methods
+  #   namespace.meths(:visibility => [:private, :protected], :scope => :class)
+  #   # => [#<yardoc method MyClass.privmeth>, #<yardoc method MyClass.protmeth>]
+  # @option opts
+  # @option opts
+  # @option opts
+  # @param opts [Hash] a customizable set of options
+  # @return [Array<MethodObject>] a list of method objects
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#113
+  def meths(opts = T.unsafe(nil)); end
+
+  # Returns for specific scopes. If no scopes are provided, returns all mixins.
+  #
+  # @param scopes [Array<Symbol>] a list of scopes (:class, :instance) to
+  #   return mixins for. If this is empty, all scopes will be returned.
+  # @return [Array<ModuleObject>] a list of mixins
+  #
+  # source://yard//lib/yard/code_objects/namespace_object.rb#194
+  def mixins(*scopes); end
+end
+
+# @private
+#
+# source://yard//lib/yard/code_objects/proxy.rb#8
+YARD::CodeObjects::PROXY_MATCH = T.let(T.unsafe(nil), Regexp)
+
+# The Proxy class is a way to lazily resolve code objects in
+# cases where the object may not yet exist. A proxy simply stores
+# an unresolved path until a method is called on the object, at which
+# point it does a lookup using {Registry.resolve}. If the object is
+# not found, a warning is raised and {ProxyMethodError} might be raised.
+#
+# @example Creates a Proxy to the String class from a module
+#   # When the String class is parsed this method will
+#   # begin to act like the String ClassObject.
+#   Proxy.new(mymoduleobj, "String")
+# @see Registry.resolve
+# @see ProxyMethodError
+#
+# source://yard//lib/yard/code_objects/proxy.rb#24
+class YARD::CodeObjects::Proxy
+  # Creates a new Proxy
+  #
+  # @raise [ArgumentError] if namespace is not a NamespaceObject
+  # @return [Proxy] self
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#34
+  def initialize(namespace, name, type = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#118
+  def <=>(other); end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#127
+  def ==(other); end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#113
+  def ===(other); end
+
+  # Returns the class name of the object the proxy is mimicking, if
+  # resolved. Otherwise returns +Proxy+.
+  #
+  # @return [Class] the resolved object's class or +Proxy+
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#142
+  def class; end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#127
+  def equal?(other); end
+
+  # @return [Integer] the object's hash value (for equality checking)
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#137
+  def hash; end
+
+  # Returns a text representation of the Proxy
+  #
+  # @return [String] the object's #inspect method or P(OBJECTPATH)
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#91
+  def inspect; end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#161
+  def instance_of?(klass); end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#108
+  def is_a?(klass); end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#166
+  def kind_of?(klass); end
+
+  # Dispatches the method to the resolved object.
+  #
+  # @raise [ProxyMethodError] if the proxy cannot find the real object
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#178
+  def method_missing(meth, *args, &block); end
+
+  # The name of the object
+  #
+  # @param prefix [Boolean] whether to show a prefix. Implement
+  #   this in a subclass to define how the prefix is showed.
+  # @return [Symbol] if prefix is false, the symbolized name
+  # @return [String] if prefix is true, prefix + the name as a String.
+  #   This must be implemented by the subclass.
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#85
+  def name(prefix = T.unsafe(nil)); end
+
+  # Returns the value of attribute namespace.
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#27
+  def namespace; end
+
+  # Returns the value of attribute namespace.
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#27
+  def parent; end
+
+  # If the proxy resolves to an object, returns its path, otherwise
+  # guesses at the correct path using the original namespace and name.
+  #
+  # @return [String] the assumed path of the proxy (or the real path
+  #   of the resolved object)
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#100
+  def path; end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#171
+  def respond_to?(meth, include_private = T.unsafe(nil)); end
+
+  # This class is never a root object
+  #
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#200
+  def root?; end
+
+  # If the proxy resolves to an object, returns its path, otherwise
+  # guesses at the correct path using the original namespace and name.
+  #
+  # @return [String] the assumed path of the proxy (or the real path
+  #   of the resolved object)
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#100
+  def title; end
+
+  # If the proxy resolves to an object, returns its path, otherwise
+  # guesses at the correct path using the original namespace and name.
+  #
+  # @return [String] the assumed path of the proxy (or the real path
+  #   of the resolved object)
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#100
+  def to_s; end
+
+  # If the proxy resolves to an object, returns its path, otherwise
+  # guesses at the correct path using the original namespace and name.
+  #
+  # @return [String] the assumed path of the proxy (or the real path
+  #   of the resolved object)
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#100
+  def to_str; end
+
+  # Returns the type of the proxy. If it cannot be resolved at the
+  # time of the call, it will either return the inferred proxy type
+  # (see {#type=}) or +:proxy+
+  #
+  # @return [Symbol] the Proxy's type
+  # @see #type=
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#151
+  def type; end
+
+  # Allows a parser to infer the type of the proxy by its path.
+  #
+  # @param type [#to_sym] the proxy's inferred type
+  # @return [void]
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#158
+  def type=(type); end
+
+  private
+
+  # source://yard//lib/yard/code_objects/proxy.rb#228
+  def proxy_path; end
+
+  # @note this method fixes a bug in 1.9.2: http://gist.github.com/437136
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#205
+  def to_ary; end
+
+  # Attempts to find the object that this unresolved object
+  # references by checking if any objects by this name are
+  # registered all the way up the namespace tree.
+  #
+  # @return [Base, nil] the registered code object or nil
+  #
+  # source://yard//lib/yard/code_objects/proxy.rb#212
+  def to_obj; end
+
+  class << self
+    # source://yard//lib/yard/code_objects/proxy.rb#25
+    def ===(other); end
+  end
+end
+
+# A special type of +NoMethodError+ when raised from a {Proxy}
+#
+# source://yard//lib/yard/code_objects/proxy.rb#5
+class YARD::CodeObjects::ProxyMethodError < ::NoMethodError; end
+
+# Represents the root namespace object (the invisible Ruby module that
+# holds all top level modules, class and other objects).
+#
+# source://yard//lib/yard/code_objects/root_object.rb#6
+class YARD::CodeObjects::RootObject < ::YARD::CodeObjects::ModuleObject
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/code_objects/root_object.rb#12
+  def equal?(other); end
+
+  # source://yard//lib/yard/code_objects/root_object.rb#16
+  def hash; end
+
+  # source://yard//lib/yard/code_objects/root_object.rb#8
+  def inspect; end
+
+  # source://yard//lib/yard/code_objects/root_object.rb#7
+  def path; end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/code_objects/root_object.rb#9
+  def root?; end
+
+  # source://yard//lib/yard/code_objects/root_object.rb#10
+  def title; end
+end
+
+# This class maintains all system-wide configuration for YARD and handles
+# the loading of plugins. To access options call {options}, and to load
+# a plugin use {load_plugin}. All other public methods are used by YARD
+# during load time.
+#
+# == User Configuration Files
+#
+# Persistent user configuration files can be stored in the file
+# +~/.yard/config+, which is read when YARD first loads. The file should
+# be formatted as YAML, and should contain a map of keys and values.
+#
+# Although you can specify any key-value mapping in the configuration file,
+# YARD defines special keys specified in {DEFAULT_CONFIG_OPTIONS}.
+#
+# An example of a configuration file is listed below:
+#
+#     !!!yaml
+#     load_plugins: true # Auto-load plugins when YARD starts
+#     ignored_plugins:
+#       - yard-broken
+#       - broken2 # yard- prefix not necessary
+#     autoload_plugins:
+#       - yard-rspec
+#
+# == Automatic Loading of Plugins
+#
+# YARD 0.6.2 will no longer automatically load all plugins by default. This
+# option can be reset by setting 'load_plugins' to true in the configuration
+# file. In addition, you can specify a set of specific plugins to load on
+# load through the 'autoload_plugins' list setting. This setting is
+# independent of the 'load_plugins' value and will always be processed.
+#
+# == Ignored Plugins File
+#
+# YARD 0.5 and below used a +~/.yard/ignored_plugins+ file to specify
+# plugins to be ignored at load time. Ignored plugins in 0.6.2 and above
+# should now be specified in the main configuration file, though YARD
+# will support the +ignored_plugins+ file until 0.7.x.
+#
+# == Safe Mode
+#
+# YARD supports running in safe-mode. By doing this, it will avoid executing
+# any user code such as require files or queries. Plugins will still be
+# loaded with safe mode on, because plugins are properly namespaced with
+# a 'yard-' prefix, must be installed as a gem, and therefore cannot be
+# touched by the user. To specify safe mode, use the +safe_mode+ key.
+#
+# == Plugin Specific Configuration
+#
+# Additional settings can be defined within the configuration file
+# specifically to provide configuration for a plugin. A plugin that utilizes
+# the YARD configuration is strongly encouraged to utilize namespacing of
+# their configuration content.
+#
+#     !!!yaml
+#     load_plugins: true # Auto-load plugins when YARD starts
+#     ignored_plugins:
+#       - yard-broken
+#       - broken2 # yard- prefix not necessary
+#     autoload_plugins:
+#       - yard-rspec
+#     # Plugin Specific Configuration
+#     yard-sample-plugin:
+#       show-results-inline: true
+#
+# As the configuration is available system wide, it can be
+# accessed within the plugin code.
+#
+#
+#     if YARD::Config.options['yard-sample-plugin'] and
+#       YARD::Config.options['yard-sample-plugin']['show-results-inline']
+#       # ... perform the action that places the results inline ...
+#     else
+#       # ... do the default behavior of not showing the results inline ...
+#     end
+#
+# When accessing the configuration, be aware that this file is user managed
+# so configuration keys and values may not be present. Make no assumptions and
+# instead ensure that you check for the existence of keys before proceeding to
+# retrieve values.
+#
+# @see options
+# @since 0.6.2
+#
+# source://yard//lib/yard/config.rb#86
+class YARD::Config
+  class << self
+    # Legacy support for {IGNORED_PLUGINS}
+    #
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#221
+    def add_ignored_plugins_file; end
+
+    # @return [Array<String>] arguments from commandline and yardopts file
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#268
+    def arguments; end
+
+    # Loads settings from {CONFIG_FILE}. This method is called by YARD at
+    # load time and should not be called by the user.
+    #
+    # @return [void]
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#119
+    def load; end
+
+    # Load plugins set in :autoload_plugins
+    #
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#189
+    def load_autoload_plugins; end
+
+    # Load plugins from {arguments}
+    #
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#194
+    def load_commandline_plugins; end
+
+    # Check for command-line safe_mode switch in {arguments}
+    #
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#204
+    def load_commandline_safemode; end
+
+    # Load gem plugins if :load_plugins is true
+    #
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#169
+    def load_gem_plugins; end
+
+    # Loads an individual plugin by name. It is not necessary to include the
+    # +yard-+ plugin prefix here.
+    #
+    # @param name [String] the name of the plugin (with or without +yard-+ prefix)
+    # @return [Boolean] whether the plugin was successfully loaded
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#157
+    def load_plugin(name); end
+
+    # Print a warning if the plugin failed to load
+    #
+    # @return [false]
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#214
+    def load_plugin_failed(name, exception); end
+
+    # Loads gems that match the name 'yard-*' (recommended) or 'yard_*' except
+    # those listed in +~/.yard/ignored_plugins+. This is called immediately
+    # after YARD is loaded to allow plugin support.
+    #
+    # @return [Boolean] true if all plugins loaded successfully, false otherwise.
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#146
+    def load_plugins; end
+
+    # The system-wide configuration options for YARD
+    #
+    # @return [SymbolHash] a map a key-value pair settings.
+    # @see DEFAULT_CONFIG_OPTIONS
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#91
+    def options; end
+
+    # The system-wide configuration options for YARD
+    #
+    # @return [SymbolHash] a map a key-value pair settings.
+    # @see DEFAULT_CONFIG_OPTIONS
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#91
+    def options=(_arg0); end
+
+    # Loads the YAML configuration file into memory
+    #
+    # @return [Hash] the contents of the YAML file from disk
+    # @see CONFIG_FILE
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#236
+    def read_config_file; end
+
+    # Saves settings to {CONFIG_FILE}.
+    #
+    # @return [void]
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#135
+    def save; end
+
+    # Sanitizes and normalizes a plugin name to include the 'yard-' prefix.
+    #
+    # @param name [String] the plugin name
+    # @return [String] the sanitized and normalized plugin name.
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#252
+    def translate_plugin_name(name); end
+
+    # Translates plugin names to add yard- prefix.
+    #
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#228
+    def translate_plugin_names; end
+
+    # Temporarily loads .yardopts file into @yardopts
+    #
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/config.rb#259
+    def with_yardopts; end
+  end
+end
+
+# The location where YARD stores user-specific settings
+#
+# @since 0.6.2
+#
+# source://yard//lib/yard/config.rb#95
+YARD::Config::CONFIG_DIR = T.let(T.unsafe(nil), String)
+
+# The main configuration YAML file.
+#
+# @since 0.6.2
+#
+# source://yard//lib/yard/config.rb#98
+YARD::Config::CONFIG_FILE = T.let(T.unsafe(nil), String)
+
+# Default configuration options
+#
+# @since 0.6.2
+#
+# source://yard//lib/yard/config.rb#105
+YARD::Config::DEFAULT_CONFIG_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+# File listing all ignored plugins
+#
+# @deprecated Set `ignored_plugins` in the {CONFIG_FILE} instead.
+# @since 0.6.2
+#
+# source://yard//lib/yard/config.rb#102
+YARD::Config::IGNORED_PLUGINS = T.let(T.unsafe(nil), String)
+
+# The prefix used for YARD plugins. Name your gem with this prefix
+# to allow it to be used as a plugin.
+#
+# @since 0.6.2
+#
+# source://yard//lib/yard/config.rb#114
+YARD::Config::YARD_PLUGIN_PREFIX = T.let(T.unsafe(nil), Regexp)
+
+# A documentation string, or "docstring" for short, encapsulates the
+# comments and metadata, or "tags", of an object. Meta-data is expressed
+# in the form +@tag VALUE+, where VALUE can span over multiple lines as
+# long as they are indented. The following +@example+ tag shows how tags
+# can be indented:
+#
+#   # @example My example
+#   #   a = "hello world"
+#   #   a.reverse
+#   # @version 1.0
+#
+# Tags can be nested in a documentation string, though the {Tags::Tag}
+# itself is responsible for parsing the inner tags.
+#
+# source://yard//lib/yard/docstring.rb#16
+class YARD::Docstring < ::String
+  # Creates a new docstring with the raw contents attached to an optional
+  # object. Parsing will be done by the {DocstringParser} class.
+  #
+  # @example
+  #   Docstring.new("hello world\n@return Object return", someobj)
+  # @note To properly parse directives with proper parser context within
+  #   handlers, you should not use this method to create a Docstring.
+  #   Instead, use the {parser}, which takes a handler object that
+  #   can pass parser state onto directives. If a Docstring is created
+  #   with this method, directives do not have access to any parser
+  #   state, and may not function as expected.
+  # @param content [String] the raw comments to be parsed into a docstring
+  #   and associated meta-data.
+  # @param object [CodeObjects::Base] an object to associate the docstring
+  #   with.
+  # @return [Docstring] a new instance of Docstring
+  #
+  # source://yard//lib/yard/docstring.rb#103
+  def initialize(content = T.unsafe(nil), object = T.unsafe(nil)); end
+
+  # Adds another {Docstring}, copying over tags.
+  #
+  # @param other [Docstring, String] the other docstring (or string) to
+  #   add.
+  # @return [Docstring] a new docstring with both docstrings combines
+  #
+  # source://yard//lib/yard/docstring.rb#116
+  def +(other); end
+
+  # Adds a tag or reftag object to the tag list. If you want to parse
+  # tag data based on the {Tags::DefaultFactory} tag factory, use
+  # {DocstringParser} instead.
+  #
+  # @param tags [Tags::Tag, Tags::RefTag] list of tag objects to add
+  # @return [void]
+  #
+  # source://yard//lib/yard/docstring.rb#242
+  def add_tag(*tags); end
+
+  # @return [String] the raw documentation (including raw tag text)
+  #
+  # source://yard//lib/yard/docstring.rb#53
+  def all; end
+
+  # Replaces the docstring with new raw content. Called by {#all=}.
+  #
+  # @param content [String] the raw comments to be parsed
+  #
+  # source://yard//lib/yard/docstring.rb#132
+  def all=(content, parse = T.unsafe(nil)); end
+
+  # Returns true if the docstring has no content that is visible to a template.
+  #
+  # @param only_visible_tags [Boolean] whether only {Tags::Library.visible_tags}
+  #   should be checked, or if all tags should be considered.
+  # @return [Boolean] whether or not the docstring has content
+  #
+  # source://yard//lib/yard/docstring.rb#310
+  def blank?(only_visible_tags = T.unsafe(nil)); end
+
+  # Deletes all tags where the block returns true
+  #
+  # @return [void]
+  # @since 0.7.0
+  # @yieldparam tag [Tags::Tag] the tag that is being tested
+  # @yieldreturn [Boolean] true if the tag should be deleted
+  #
+  # source://yard//lib/yard/docstring.rb#300
+  def delete_tag_if(&block); end
+
+  # Delete all tags with +name+
+  #
+  # @param name [String] the tag name
+  # @return [void]
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/docstring.rb#291
+  def delete_tags(name); end
+
+  # Deep-copies a docstring
+  #
+  # @note This method creates a new docstring with new tag lists, but does
+  #   not create new individual tags. Modifying the tag objects will still
+  #   affect the original tags.
+  # @return [Docstring] a new copied docstring
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/docstring.rb#153
+  def dup; end
+
+  # Returns true if at least one tag by the name +name+ was declared
+  #
+  # @param name [String] the tag name to search for
+  # @return [Boolean] whether or not the tag +name+ was declared
+  #
+  # source://yard//lib/yard/docstring.rb#283
+  def has_tag?(name); end
+
+  # @return [Boolean] whether the docstring was started with "##"
+  #
+  # source://yard//lib/yard/docstring.rb#56
+  def hash_flag; end
+
+  # source://yard//lib/yard/docstring.rb#57
+  def hash_flag=(v); end
+
+  # @return [Fixnum] the first line of the {#line_range}
+  # @return [nil] if there is no associated {#line_range}
+  #
+  # source://yard//lib/yard/docstring.rb#167
+  def line; end
+
+  # @return [Range] line range in the {#object}'s file where the docstring was parsed from
+  #
+  # source://yard//lib/yard/docstring.rb#50
+  def line_range; end
+
+  # @return [Range] line range in the {#object}'s file where the docstring was parsed from
+  #
+  # source://yard//lib/yard/docstring.rb#50
+  def line_range=(_arg0); end
+
+  # @return [CodeObjects::Base] the object that owns the docstring.
+  #
+  # source://yard//lib/yard/docstring.rb#47
+  def object; end
+
+  # @return [CodeObjects::Base] the object that owns the docstring.
+  #
+  # source://yard//lib/yard/docstring.rb#47
+  def object=(_arg0); end
+
+  # @return [Array<Tags::RefTag>] the list of reference tags
+  #
+  # source://yard//lib/yard/docstring.rb#44
+  def ref_tags; end
+
+  # Replaces the docstring with new raw content. Called by {#all=}.
+  #
+  # @param content [String] the raw comments to be parsed
+  #
+  # source://yard//lib/yard/docstring.rb#132
+  def replace(content, parse = T.unsafe(nil)); end
+
+  # Resolves unresolved other docstring reference if there is
+  # unresolved reference. Does nothing if there is no unresolved
+  # reference.
+  #
+  # Normally, you don't need to call this method
+  # explicitly. Resolving unresolved reference is done implicitly.
+  #
+  # @return [void]
+  #
+  # source://yard//lib/yard/docstring.rb#328
+  def resolve_reference; end
+
+  # Gets the first line of a docstring to the period or the first paragraph.
+  #
+  # @return [String] The first line or paragraph of the docstring; always ends with a period.
+  #
+  # source://yard//lib/yard/docstring.rb#173
+  def summary; end
+
+  # Convenience method to return the first tag
+  # object in the list of tag objects of that name
+  #
+  # @example
+  #   doc = Docstring.new("@return zero when nil")
+  #   doc.tag(:return).text  # => "zero when nil"
+  # @param name [#to_s] the tag name to return data for
+  # @return [Tags::Tag] the first tag in the list of {#tags}
+  #
+  # source://yard//lib/yard/docstring.rb#265
+  def tag(name); end
+
+  # Returns a list of tags specified by +name+ or all tags if +name+ is not specified.
+  #
+  # @param name [#to_s] the tag name to return data for, or nil for all tags
+  # @return [Array<Tags::Tag>] the list of tags by the specified tag name
+  #
+  # source://yard//lib/yard/docstring.rb#273
+  def tags(name = T.unsafe(nil)); end
+
+  # Reformats and returns a raw representation of the tag data using the
+  # current tag and docstring data, not the original text.
+  #
+  # @return [String] the updated raw formatted docstring data
+  # @since 0.7.0
+  # @todo Add Tags::Tag#to_raw and refactor
+  #
+  # source://yard//lib/yard/docstring.rb#207
+  def to_raw; end
+
+  # source://yard//lib/yard/docstring.rb#125
+  def to_s; end
+
+  private
+
+  # Maps valid reference tags
+  #
+  # @return [Array<Tags::RefTag>] the list of valid reference tags
+  #
+  # source://yard//lib/yard/docstring.rb#344
+  def convert_ref_tags; end
+
+  # Parses out comments split by newlines into a new code object
+  #
+  # @param comments [String] the newline delimited array of comments. If the comments
+  #   are passed as a String, they will be split by newlines.
+  # @return [String] the non-metadata portion of the comments to
+  #   be used as a docstring
+  #
+  # source://yard//lib/yard/docstring.rb#369
+  def parse_comments(comments); end
+
+  # A stable sort_by method.
+  #
+  # @param list [Enumerable] the list to sort.
+  # @return [Array] a stable sorted list.
+  #
+  # source://yard//lib/yard/docstring.rb#382
+  def stable_sort_by(list); end
+
+  class << self
+    # @note Plugin developers should make sure to reset this value
+    #   after parsing finishes. This can be done via the
+    #   {Parser::SourceParser.after_parse_list} callback. This will
+    #   ensure that YARD can properly parse multiple projects in
+    #   the same process.
+    # @return [Class<DocstringParser>] the parser class used to parse
+    #   text and optional meta-data from docstrings. Defaults to
+    #   {DocstringParser}.
+    # @see DocstringParser
+    # @see Parser::SourceParser.after_parse_list
+    #
+    # source://yard//lib/yard/docstring.rb#28
+    def default_parser; end
+
+    # @note Plugin developers should make sure to reset this value
+    #   after parsing finishes. This can be done via the
+    #   {Parser::SourceParser.after_parse_list} callback. This will
+    #   ensure that YARD can properly parse multiple projects in
+    #   the same process.
+    # @return [Class<DocstringParser>] the parser class used to parse
+    #   text and optional meta-data from docstrings. Defaults to
+    #   {DocstringParser}.
+    # @see DocstringParser
+    # @see Parser::SourceParser.after_parse_list
+    #
+    # source://yard//lib/yard/docstring.rb#28
+    def default_parser=(_arg0); end
+
+    # Creates a new docstring without performing any parsing through
+    # a {DocstringParser}. This method is called by +DocstringParser+
+    # when creating the new docstring object.
+    #
+    # @param text [String] the textual portion of the docstring
+    # @param tags [Array<Tags::Tag>] the list of tag objects in the docstring
+    # @param object [CodeObjects::Base, nil] the object associated with the
+    #   docstring. May be nil.
+    # @param raw_data [String] the complete docstring, including all
+    #   original formatting and any unparsed tags/directives.
+    # @param ref_object [CodeObjects::Base, nil] a reference object used for
+    #   the base set of documentation / tag information.
+    #
+    # source://yard//lib/yard/docstring.rb#77
+    def new!(text, tags = T.unsafe(nil), object = T.unsafe(nil), raw_data = T.unsafe(nil), ref_object = T.unsafe(nil)); end
+
+    # Creates a parser object using the current {default_parser}.
+    # Equivalent to:
+    #   Docstring.default_parser.new(*args)
+    #
+    # @param args arguments are passed to the {DocstringParser}
+    #   class. See {DocstringParser#initialize} for details on
+    #   arguments.
+    # @return [DocstringParser] the parser object used to parse a
+    #   docstring.
+    #
+    # source://yard//lib/yard/docstring.rb#38
+    def parser(*args); end
+  end
+end
+
+# Matches a tag at the start of a comment line
+#
+# @deprecated Use {DocstringParser::META_MATCH}
+#
+# source://yard//lib/yard/docstring.rb#61
+YARD::Docstring::META_MATCH = T.let(T.unsafe(nil), Regexp)
+
+# Parses text and creates a {Docstring} object to represent documentation
+# for a {CodeObjects::Base}. To create a new docstring, you should initialize
+# the parser and call {#parse} followed by {#to_docstring}.
+#
+# == Subclassing Notes
+#
+# The DocstringParser can be subclassed and substituted during parsing by
+# setting the {Docstring.default_parser} attribute with the name of the
+# subclass. This allows developers to change the way docstrings are
+# parsed, allowing for completely different docstring syntaxes.
+#
+# @example Creating a Docstring with a DocstringParser
+#   DocstringParser.new.parse("text here").to_docstring
+# @example Creating a Custom DocstringParser
+#   # Parses docstrings backwards!
+#   class ReverseDocstringParser
+#   def parse_content(content)
+#   super(content.reverse)
+#   end
+#   end
+#
+#   # Set the parser as default when parsing
+#   YARD::Docstring.default_parser = ReverseDocstringParser
+# @see #parse_content
+# @since 0.8.0
+#
+# source://yard//lib/yard/docstring_parser.rb#29
+class YARD::DocstringParser
+  # Creates a new parser to parse docstring data
+  #
+  # @param library [Tags::Library] a tag library for recognizing
+  #   tags.
+  # @return [DocstringParser] a new instance of DocstringParser
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#80
+  def initialize(library = T.unsafe(nil)); end
+
+  # Creates a new directive using the registered {#library}
+  #
+  # @return [Tags::Directive] the directive object that is created
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#231
+  def create_directive(tag_name, tag_buf); end
+
+  # Creates a {Tags::RefTag}
+  #
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#225
+  def create_ref_tag(tag_name, name, object_name); end
+
+  # Creates a tag from the {Tags::DefaultFactory tag factory}.
+  #
+  # To add an already created tag object, append it to {#tags}.
+  #
+  # @param tag_name [String] the tag name
+  # @param tag_buf [String] the text attached to the tag with newlines removed.
+  # @return [Tags::Tag, Tags::RefTag] a tag
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#208
+  def create_tag(tag_name, tag_buf = T.unsafe(nil)); end
+
+  # @return [Array<Tags::Directive>] a list of directives identified
+  #   by the parser. This list will not be passed on to the
+  #   Docstring object.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#44
+  def directives; end
+
+  # @return [Array<Tags::Directive>] a list of directives identified
+  #   by the parser. This list will not be passed on to the
+  #   Docstring object.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#44
+  def directives=(_arg0); end
+
+  # @return [Handlers::Base, nil] the handler parsing this
+  #   docstring. May be nil if this docstring parser is not
+  #   initialized through
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#65
+  def handler; end
+
+  # @return [Handlers::Base, nil] the handler parsing this
+  #   docstring. May be nil if this docstring parser is not
+  #   initialized through
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#65
+  def handler=(_arg0); end
+
+  # @return [Tags::Library] the tag library being used to
+  #   identify registered tags in the docstring.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#69
+  def library; end
+
+  # @return [Tags::Library] the tag library being used to
+  #   identify registered tags in the docstring.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#69
+  def library=(_arg0); end
+
+  # @return [CodeObjects::Base, nil] the object associated with
+  #   the docstring being parsed. May be nil if the docstring is
+  #   not attached to any object.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#55
+  def object; end
+
+  # @return [CodeObjects::Base, nil] the object associated with
+  #   the docstring being parsed. May be nil if the docstring is
+  #   not attached to any object.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#55
+  def object=(_arg0); end
+
+  # Parses all content and returns itself.
+  #
+  # @param content [String] the docstring text to parse
+  # @param object [CodeObjects::Base] the object that the docstring
+  #   is attached to. Will be passed to directives to act on
+  #   this object.
+  # @param handler [Handlers::Base, nil] the handler object that is
+  #   parsing this object. May be nil if this parser is not being
+  #   called from a {Parser::SourceParser} context.
+  # @return [self] the parser object. To get the docstring,
+  #   call {#to_docstring}.
+  # @see #to_docstring
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#112
+  def parse(content, object = T.unsafe(nil), handler = T.unsafe(nil)); end
+
+  # Parses a given block of text.
+  #
+  # @note Subclasses can override this method to perform custom
+  #   parsing of content data.
+  # @param content [String] the content to parse
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#128
+  def parse_content(content); end
+
+  # Call post processing callbacks on parser.
+  # This is called implicitly by parser. Use this when
+  # manually configuring a {Docstring} object.
+  #
+  # @return [void]
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#195
+  def post_process; end
+
+  # @return [String] the complete input string to the parser.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#35
+  def raw_text; end
+
+  # @return [String] the complete input string to the parser.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#35
+  def raw_text=(_arg0); end
+
+  # @return [CodeObjects::Base, nil] the object referenced by
+  #   the docstring being parsed. May be nil if the docstring doesn't
+  #   refer to any object.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#60
+  def reference; end
+
+  # @return [CodeObjects::Base, nil] the object referenced by
+  #   the docstring being parsed. May be nil if the docstring doesn't
+  #   refer to any object.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#60
+  def reference=(_arg0); end
+
+  # @return [OpenStruct] any arbitrary state to be passed between
+  #   tags during parsing. Mainly used by directives to coordinate
+  #   behaviour (so that directives can be aware of other directives
+  #   used in a docstring).
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#50
+  def state; end
+
+  # @return [OpenStruct] any arbitrary state to be passed between
+  #   tags during parsing. Mainly used by directives to coordinate
+  #   behaviour (so that directives can be aware of other directives
+  #   used in a docstring).
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#50
+  def state=(_arg0); end
+
+  # Backward compatibility to detect old tags that should be specified
+  # as directives in 0.8 and onward.
+  #
+  # @return [Boolean]
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#251
+  def tag_is_directive?(tag_name); end
+
+  # @return [Array<Tags::Tag>] the list of meta-data tags identified
+  #   by the parser
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#39
+  def tags; end
+
+  # @return [Array<Tags::Tag>] the list of meta-data tags identified
+  #   by the parser
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#39
+  def tags=(_arg0); end
+
+  # @return [String] the parsed text portion of the docstring,
+  #   with tags removed.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#32
+  def text; end
+
+  # @return [String] the parsed text portion of the docstring,
+  #   with tags removed.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#32
+  def text=(_arg0); end
+
+  # @return [Docstring] translates parsed text into
+  #   a Docstring object.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#94
+  def to_docstring; end
+
+  private
+
+  # Calls all {after_parse} callbacks
+  #
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#323
+  def call_after_parse_callbacks; end
+
+  # Calls the {Tags::Directive#after_parse} callback on all the
+  # created directives.
+  #
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#318
+  def call_directives_after_parse; end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#304
+  def detect_reference(content); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/docstring_parser.rb#300
+  def namespace; end
+
+  class << self
+    # Creates a callback that is called after a docstring is successfully
+    # parsed. Use this method to perform sanity checks on a docstring's
+    # tag data, or add any extra tags automatically to a docstring.
+    #
+    # @return [void]
+    # @since 0.8.0
+    # @yield [parser] a block to be called after a docstring is parsed
+    # @yieldparam parser [DocstringParser] the docstring parser object
+    #   with all directives and tags created.
+    # @yieldreturn [void]
+    #
+    # source://yard//lib/yard/docstring_parser.rb#265
+    def after_parse(&block); end
+
+    # @return [Array<Proc>] the {after_parse} callback proc objects
+    # @since 0.8.0
+    #
+    # source://yard//lib/yard/docstring_parser.rb#270
+    def after_parse_callbacks; end
+  end
+end
+
+# The regular expression to match the tag syntax
+#
+# @since 0.8.0
+#
+# source://yard//lib/yard/docstring_parser.rb#72
+YARD::DocstringParser::META_MATCH = T.let(T.unsafe(nil), Regexp)
+
+# source://yard//lib/yard/gem_index.rb#6
+module YARD::GemIndex
+  private
+
+  # source://yard//lib/yard/gem_index.rb#25
+  def all; end
+
+  # source://yard//lib/yard/gem_index.rb#17
+  def each(&block); end
+
+  # source://yard//lib/yard/gem_index.rb#9
+  def find_all_by_name(*args); end
+
+  class << self
+    # source://yard//lib/yard/gem_index.rb#25
+    def all; end
+
+    # source://yard//lib/yard/gem_index.rb#17
+    def each(&block); end
+
+    # source://yard//lib/yard/gem_index.rb#9
+    def find_all_by_name(*args); end
+  end
+end
+
+# Handlers are called during the data processing part of YARD's
+# parsing phase. This allows YARD as well as any custom extension to
+# analyze source and generate {CodeObjects} to be stored for later use.
+#
+# source://yard//lib/yard/autoload.rb#66
+module YARD::Handlers; end
+
+# Handlers are pluggable semantic parsers for YARD's code generation
+# phase. They allow developers to control what information gets
+# generated by YARD, giving them the ability to, for instance, document
+# any Ruby DSLs that a customized framework may use. A good example
+# of this would be the ability to document and generate meta data for
+# the 'describe' declaration of the RSpec testing framework by simply
+# adding a handler for such a keyword. Similarly, any Ruby API that
+# takes advantage of class level declarations could add these to the
+# documentation in a very explicit format by treating them as first-
+# class objects in any outputted documentation.
+#
+# == Overview of a Typical Handler Scenario
+#
+# Generally, a handler class will declare a set of statements which
+# it will handle using the {handles} class declaration. It will then
+# implement the {#process} method to do the work. The processing would
+# usually involve the manipulation of the {#namespace}, {#owner}
+# {CodeObjects::Base code objects} or the creation of new ones, in
+# which case they should be registered by {#register}, a method that
+# sets some basic attributes for the new objects.
+#
+# Handlers are usually simple and take up to a page of code to process
+# and register a new object or add new attributes to the current +namespace+.
+#
+# == Setting up a Handler for Use
+#
+# A Handler is automatically registered when it is subclassed from the
+# base class. The only other thing that needs to be done is to specify
+# which statement the handler will process. This is done with the +handles+
+# declaration, taking either a {Parser::Ruby::Legacy::RubyToken}, {String} or `Regexp`.
+# Here is a simple example which processes module statements.
+#
+#   class MyModuleHandler < YARD::Handlers::Base
+#     handles TkMODULE
+#
+#     def process
+#       # do something
+#     end
+#   end
+#
+# == Processing Handler Data
+#
+# The goal of a specific handler is really up to the developer, and as
+# such there is no real guideline on how to process the data. However,
+# it is important to know where the data is coming from to be able to use
+# it.
+#
+# === +statement+ Attribute
+#
+# The +statement+ attribute pertains to the {Parser::Ruby::Legacy::Statement} object
+# containing a set of tokens parsed in by the parser. This is the main set
+# of data to be analyzed and processed. The comments attached to the statement
+# can be accessed by the {Parser::Ruby::Legacy::Statement#comments} method, but generally
+# the data to be processed will live in the +tokens+ attribute. This list
+# can be converted to a +String+ using +#to_s+ to parse the data with
+# regular expressions (or other text processing mechanisms), if needed.
+#
+# === +namespace+ Attribute
+#
+# The +namespace+ attribute is a {CodeObjects::NamespaceObject namespace object}
+# which represents the current namespace that the parser is in. For instance:
+#
+#   module SomeModule
+#     class MyClass
+#       def mymethod; end
+#     end
+#   end
+#
+# If a handler was to parse the 'class MyClass' statement, it would
+# be necessary to know that it belonged inside the SomeModule module.
+# This is the value that +namespace+ would return when processing such
+# a statement. If the class was then entered and another handler was
+# called on the method, the +namespace+ would be set to the 'MyClass'
+# code object.
+#
+# === +owner+ Attribute
+#
+# The +owner+ attribute is similar to the +namespace+ attribute in that
+# it also follows the scope of the code during parsing. However, a namespace
+# object is loosely defined as a module or class and YARD has the ability
+# to parse beyond module and class blocks (inside methods, for instance),
+# so the +owner+ attribute would not be limited to modules and classes.
+#
+# To put this into context, the example from above will be used. If a method
+# handler was added to the mix and decided to parse inside the method body,
+# the +owner+ would be set to the method object but the namespace would remain
+# set to the class. This would allow the developer to process any method
+# definitions set inside a method (def x; def y; 2 end end) by adding them
+# to the correct namespace (the class, not the method).
+#
+# In summary, the distinction between +namespace+ and +owner+ can be thought
+# of as the difference between first-class Ruby objects (namespaces) and
+# second-class Ruby objects (methods).
+#
+# === +visibility+ and +scope+ Attributes
+#
+# Mainly needed for parsing methods, the +visibility+ and +scope+ attributes
+# refer to the public/protected/private and class/instance values (respectively)
+# of the current parsing position.
+#
+# == Parsing Blocks in Statements
+#
+# In addition to parsing a statement and creating new objects, some
+# handlers may wish to continue parsing the code inside the statement's
+# block (if there is one). In this context, a block means the inside
+# of any statement, be it class definition, module definition, if
+# statement or classic 'Ruby block'.
+#
+# For example, a class statement would be "class MyClass" and the block
+# would be a list of statements including the method definitions inside
+# the class. For a class handler, the programmer would execute the
+# {#parse_block} method to continue parsing code inside the block, with
+# the +namespace+ now pointing to the class object the handler created.
+#
+# YARD has the ability to continue into any block: class, module, method,
+# even if statements. For this reason, the block parsing method must be
+# invoked explicitly out of efficiency sake.
+#
+# @abstract Subclass this class to provide a handler for YARD to use
+#   during the processing phase.
+# @see CodeObjects::Base
+# @see CodeObjects::NamespaceObject
+# @see handles
+# @see #namespace
+# @see #owner
+# @see #register
+# @see #parse_block
+#
+# source://yard//lib/yard/handlers/base.rb#149
+class YARD::Handlers::Base
+  include ::YARD::CodeObjects
+  include ::YARD::Parser
+
+  # @return [Base] a new instance of Base
+  #
+  # source://yard//lib/yard/handlers/base.rb#276
+  def initialize(source_parser, stmt); end
+
+  # Aborts a handler by raising {Handlers::HandlerAborted}.
+  # An exception will only be logged in debugging mode for
+  # this kind of handler exit.
+  #
+  # @raise [Handlers::HandlerAborted]
+  # @since 0.8.4
+  #
+  # source://yard//lib/yard/handlers/base.rb#355
+  def abort!; end
+
+  # @abstract Implement this method to return the parameters in a method call
+  #   statement. It should return an empty list if the statement is not a
+  #   method call.
+  # @raise [NotImplementedError]
+  # @return [Array<String>] a list of argument names
+  #
+  # source://yard//lib/yard/handlers/base.rb#581
+  def call_params; end
+
+  # @abstract Implement this method to return the method being called in
+  #   a method call. It should return nil if the statement is not a method
+  #   call.
+  # @raise [NotImplementedError]
+  # @return [String] the method name being called
+  # @return [nil] if the statement is not a method call
+  #
+  # source://yard//lib/yard/handlers/base.rb#590
+  def caller_method; end
+
+  # Ensures that a specific +object+ has been parsed and loaded into the
+  # registry. This is necessary when adding data to a namespace, for instance,
+  # since the namespace may not have been processed yet (it can be located
+  # in a file that has not been handled).
+  #
+  # Calling this method defers the handler until all other files have been
+  # processed. If the object gets resolved, the rest of the handler continues,
+  # otherwise an exception is raised.
+  #
+  # @example Adding a mixin to the String class programmatically
+  #   ensure_loaded! P('String')
+  #   # "String" is now guaranteed to be loaded
+  #   P('String').mixins << P('MyMixin')
+  # @param object [Proxy, CodeObjects::Base] the object to resolve.
+  # @param max_retries [Integer] the number of times to defer the handler
+  #   before raising a +NamespaceMissingError+.
+  # @raise [NamespaceMissingError] if the object is not resolved within
+  #   +max_retries+ attempts, this exception is raised and the handler
+  #   finishes processing.
+  #
+  # source://yard//lib/yard/handlers/base.rb#561
+  def ensure_loaded!(object, max_retries = T.unsafe(nil)); end
+
+  # Returns the value of attribute extra_state.
+  #
+  # source://yard//lib/yard/handlers/base.rb#348
+  def extra_state; end
+
+  # Returns the value of attribute globals.
+  #
+  # source://yard//lib/yard/handlers/base.rb#347
+  def globals; end
+
+  # Returns the value of attribute namespace.
+  #
+  # source://yard//lib/yard/handlers/base.rb#341
+  def namespace; end
+
+  # Sets the attribute namespace
+  #
+  # @param value the value to set the attribute namespace to.
+  #
+  # source://yard//lib/yard/handlers/base.rb#342
+  def namespace=(v); end
+
+  # Returns the value of attribute owner.
+  #
+  # source://yard//lib/yard/handlers/base.rb#339
+  def owner; end
+
+  # Sets the attribute owner
+  #
+  # @param value the value to set the attribute owner to.
+  #
+  # source://yard//lib/yard/handlers/base.rb#340
+  def owner=(v); end
+
+  # Parses the semantic "block" contained in the statement node.
+  #
+  # @abstract Subclasses should call {Processor#process parser.process}
+  # @raise [NotImplementedError]
+  #
+  # source://yard//lib/yard/handlers/base.rb#304
+  def parse_block(*_arg0); end
+
+  # @return [Processor] the processor object that manages all global state
+  #   during handling.
+  #
+  # source://yard//lib/yard/handlers/base.rb#310
+  def parser; end
+
+  # The main handler method called by the parser on a statement
+  # that matches the {handles} declaration.
+  #
+  # Subclasses should override this method to provide the handling
+  # functionality for the class.
+  #
+  # @raise [NotImplementedError]
+  # @return [Array<CodeObjects::Base>, CodeObjects::Base, Object] If this method returns a code object (or a list of them),
+  #   they are passed to the +#register+ method which adds basic
+  #   attributes. It is not necessary to return any objects and in
+  #   some cases you may want to explicitly avoid the returning of
+  #   any objects for post-processing by the register method.
+  # @see handles
+  # @see #register
+  #
+  # source://yard//lib/yard/handlers/base.rb#297
+  def process; end
+
+  # Executes a given block with specific state values for {#owner},
+  # {#namespace} and {#scope}.
+  #
+  # @option opts
+  # @option opts
+  # @option opts
+  # @param opts [Hash] a customizable set of options
+  # @yield a block to execute with the given state values.
+  #
+  # source://yard//lib/yard/handlers/base.rb#370
+  def push_state(opts = T.unsafe(nil)); end
+
+  # Do some post processing on a list of code objects.
+  # Adds basic attributes to the list of objects like
+  # the filename, line number, {CodeObjects::Base#dynamic},
+  # source code and {CodeObjects::Base#docstring},
+  # but only if they don't exist.
+  #
+  # @param objects [Array<CodeObjects::Base>] the list of objects to post-process.
+  # @return [CodeObjects::Base, Array<CodeObjects::Base>] returns whatever is passed in, for chainability.
+  #
+  # source://yard//lib/yard/handlers/base.rb#407
+  def register(*objects); end
+
+  # Registers any docstring found for the object and expands macros
+  #
+  # @param object [CodeObjects::Base] the object to register
+  # @return [void]
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/base.rb#450
+  def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end
+
+  # Registers the object as dynamic if the object is defined inside
+  # a method or block (owner != namespace)
+  #
+  # @param object [CodeObjects::Base] the object to register
+  # @return [void]
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/base.rb#537
+  def register_dynamic(object); end
+
+  # Ensures that the object's namespace is loaded before attaching it
+  # to the namespace.
+  #
+  # @param object [CodeObjects::Base] the object to register
+  # @return [void]
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/base.rb#429
+  def register_ensure_loaded(object); end
+
+  # Registers the file/line of the declaration with the object
+  #
+  # @param object [CodeObjects::Base] the object to register
+  # @return [void]
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/base.rb#441
+  def register_file_info(object, file = T.unsafe(nil), line = T.unsafe(nil), comments = T.unsafe(nil)); end
+
+  # Registers the object as being inside a specific group
+  #
+  # @param object [CodeObjects::Base] the object to register
+  # @return [void]
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/base.rb#473
+  def register_group(object, group = T.unsafe(nil)); end
+
+  # Registers the same method information on the module function, if
+  # the object was defined as a module function.
+  #
+  # @param object [CodeObjects::Base] the possible module function object
+  #   to copy data for
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/base.rb#523
+  def register_module_function(object); end
+
+  # @param object [CodeObjects::Base] the object to register
+  # @return [void]
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/base.rb#499
+  def register_source(object, source = T.unsafe(nil), type = T.unsafe(nil)); end
+
+  # Registers any transitive tags from the namespace on the object
+  #
+  # @param object [CodeObjects::Base, nil] the object to register
+  # @return [void]
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/base.rb#487
+  def register_transitive_tags(object); end
+
+  # Registers visibility on a method object. If the object does not
+  # respond to setting visibility, nothing is done.
+  #
+  # @param object [#visibility=] the object to register
+  # @param visibility [Symbol] the visibility to set on the object
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/base.rb#511
+  def register_visibility(object, visibility = T.unsafe(nil)); end
+
+  # Returns the value of attribute scope.
+  #
+  # source://yard//lib/yard/handlers/base.rb#345
+  def scope; end
+
+  # Sets the attribute scope
+  #
+  # @param value the value to set the attribute scope to.
+  #
+  # source://yard//lib/yard/handlers/base.rb#346
+  def scope=(v); end
+
+  # @return [Object] the statement object currently being processed. Usually
+  #   refers to one semantic language statement, though the strict definition
+  #   depends on the parser used.
+  #
+  # source://yard//lib/yard/handlers/base.rb#315
+  def statement; end
+
+  # Returns the value of attribute visibility.
+  #
+  # source://yard//lib/yard/handlers/base.rb#343
+  def visibility; end
+
+  # Sets the attribute visibility
+  #
+  # @param value the value to set the attribute visibility to.
+  #
+  # source://yard//lib/yard/handlers/base.rb#344
+  def visibility=(v); end
+
+  class << self
+    # Clear all registered subclasses. Testing purposes only
+    #
+    # @return [void]
+    #
+    # source://yard//lib/yard/handlers/base.rb#159
+    def clear_subclasses; end
+
+    # @return [Array] a list of matchers for the handler object.
+    # @see handles?
+    #
+    # source://yard//lib/yard/handlers/base.rb#211
+    def handlers; end
+
+    # Declares the statement type which will be processed
+    # by this handler.
+    #
+    # A match need not be unique to a handler. Multiple
+    # handlers can process the same statement. However,
+    # in this case, care should be taken to make sure that
+    # {#parse_block} would only be executed by one of
+    # the handlers, otherwise the same code will be parsed
+    # multiple times and slow YARD down.
+    #
+    # @param matches [Parser::Ruby::Legacy::RubyToken, Symbol, String, Regexp] statements that match the declaration will be
+    #   processed by this handler. A {String} match is
+    #   equivalent to a +/\Astring/+ regular expression
+    #   (match from the beginning of the line), and all
+    #   token matches match only the first token of the
+    #   statement.
+    #
+    # source://yard//lib/yard/handlers/base.rb#192
+    def handles(*matches); end
+
+    # This class is implemented by {Ruby::Base} and {Ruby::Legacy::Base}.
+    # To implement a base handler class for another language, implement
+    # this method to return true if the handler should process the given
+    # statement object. Use {handlers} to enumerate the matchers declared
+    # for the handler class.
+    #
+    # @param statement a statement object or node (depends on language type)
+    # @raise [NotImplementedError]
+    # @return [Boolean] whether or not this handler object should process
+    #   the given statement
+    #
+    # source://yard//lib/yard/handlers/base.rb#205
+    def handles?(statement); end
+
+    # Declares that a handler should only be called when inside a filename
+    # by its basename or a regex match for the full path.
+    #
+    # @param filename [String, Regexp] a matching filename or regex
+    # @return [void]
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/handlers/base.rb#235
+    def in_file(filename); end
+
+    # @private
+    #
+    # source://yard//lib/yard/handlers/base.rb#169
+    def inherited(subclass); end
+
+    # @return [Boolean] whether the filename matches the declared file
+    #   match for a handler. If no file match is specified, returns true.
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/handlers/base.rb#242
+    def matches_file?(filename); end
+
+    # Declares that the handler should only be called when inside a
+    # {CodeObjects::NamespaceObject}, not a method body.
+    #
+    # @return [void]
+    #
+    # source://yard//lib/yard/handlers/base.rb#219
+    def namespace_only; end
+
+    # @return [Boolean] whether the handler should only be processed inside
+    #   a namespace.
+    #
+    # source://yard//lib/yard/handlers/base.rb#225
+    def namespace_only?; end
+
+    # Generates a +process+ method, equivalent to +def process; ... end+.
+    # Blocks defined with this syntax will be wrapped inside an anonymous
+    # module so that the handler class can be extended with mixins that
+    # override the +process+ method without alias chaining.
+    #
+    # @return [void]
+    # @see #process
+    # @since 0.5.4
+    #
+    # source://yard//lib/yard/handlers/base.rb#269
+    def process(&block); end
+
+    # Returns all registered handler subclasses.
+    #
+    # @return [Array<Base>] a list of handlers
+    #
+    # source://yard//lib/yard/handlers/base.rb#165
+    def subclasses; end
+  end
+end
+
+# CRuby Handlers
+#
+# @since 0.8.0
+#
+# source://yard//lib/yard/autoload.rb#74
+module YARD::Handlers::C; end
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/alias_handler.rb#2
+class YARD::Handlers::C::AliasHandler < ::YARD::Handlers::C::Base; end
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/alias_handler.rb#3
+YARD::Handlers::C::AliasHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/attribute_handler.rb#2
+class YARD::Handlers::C::AttributeHandler < ::YARD::Handlers::C::Base; end
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/attribute_handler.rb#3
+YARD::Handlers::C::AttributeHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/base.rb#5
+class YARD::Handlers::C::Base < ::YARD::Handlers::Base
+  include ::YARD::Parser::C
+  include ::YARD::Handlers::Common::MethodHandler
+  include ::YARD::Handlers::C::HandlerMethods
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/base.rb#77
+  def ensure_variable_defined!(var, max_retries = T.unsafe(nil)); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/base.rb#64
+  def namespace_for_variable(var); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/base.rb#94
+  def namespaces; end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/base.rb#60
+  def override_comments; end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/base.rb#104
+  def parse_block(opts = T.unsafe(nil)); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/base.rb#113
+  def process_file(file, object); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/base.rb#98
+  def processed_files; end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/base.rb#38
+  def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/base.rb#42
+  def register_file_info(object, file = T.unsafe(nil), line = T.unsafe(nil), comments = T.unsafe(nil)); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/base.rb#46
+  def register_source(object, source = T.unsafe(nil), type = T.unsafe(nil)); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/base.rb#50
+  def register_visibility(object, visibility = T.unsafe(nil)); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/base.rb#56
+  def symbols; end
+
+  private
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/base.rb#158
+  def remove_var_prefix(var); end
+
+  class << self
+    # @return [Boolean] whether the handler handles this statement
+    # @since 0.8.0
+    #
+    # source://yard//lib/yard/handlers/c/base.rb#10
+    def handles?(statement, processor); end
+
+    # @since 0.8.0
+    #
+    # source://yard//lib/yard/handlers/c/base.rb#28
+    def statement_class(type = T.unsafe(nil)); end
+  end
+end
+
+# Generated by update_error_map.rb (Copy+past results)
+#
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/base.rb#131
+YARD::Handlers::C::Base::ERROR_CLASS_NAMES = T.let(T.unsafe(nil), Hash)
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/class_handler.rb#2
+class YARD::Handlers::C::ClassHandler < ::YARD::Handlers::C::Base; end
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/class_handler.rb#3
+YARD::Handlers::C::ClassHandler::MATCH1 = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/class_handler.rb#9
+YARD::Handlers::C::ClassHandler::MATCH2 = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/constant_handler.rb#2
+class YARD::Handlers::C::ConstantHandler < ::YARD::Handlers::C::Base; end
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/constant_handler.rb#3
+YARD::Handlers::C::ConstantHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/handler_methods.rb#5
+module YARD::Handlers::C::HandlerMethods
+  include ::YARD::Parser::C
+  include ::YARD::CodeObjects
+  include ::YARD::Handlers::Common::MethodHandler
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/handler_methods.rb#86
+  def handle_alias(var_name, new_name, old_name); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/handler_methods.rb#75
+  def handle_attribute(var_name, name, read, write); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/handler_methods.rb#10
+  def handle_class(var_name, class_name, parent, in_module = T.unsafe(nil)); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/handler_methods.rb#109
+  def handle_constants(type, var_name, const_name, value); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/handler_methods.rb#46
+  def handle_method(scope, var_name, name, func_name, _source_file = T.unsafe(nil)); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/handler_methods.rb#33
+  def handle_module(var_name, module_name, in_module = T.unsafe(nil)); end
+
+  private
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/handler_methods.rb#123
+  def find_constant_docstring(object); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/handler_methods.rb#154
+  def find_method_body(object, symbol); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/handler_methods.rb#196
+  def record_parameters(object, symbol, src); end
+end
+
+# Handles the Init_Libname() method
+#
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/init_handler.rb#3
+class YARD::Handlers::C::InitHandler < ::YARD::Handlers::C::Base; end
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/init_handler.rb#4
+YARD::Handlers::C::InitHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/method_handler.rb#2
+class YARD::Handlers::C::MethodHandler < ::YARD::Handlers::C::Base; end
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/method_handler.rb#3
+YARD::Handlers::C::MethodHandler::MATCH1 = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/method_handler.rb#14
+YARD::Handlers::C::MethodHandler::MATCH2 = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/method_handler.rb#18
+YARD::Handlers::C::MethodHandler::MATCH3 = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/mixin_handler.rb#2
+class YARD::Handlers::C::MixinHandler < ::YARD::Handlers::C::Base; end
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/mixin_handler.rb#3
+YARD::Handlers::C::MixinHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/module_handler.rb#2
+class YARD::Handlers::C::ModuleHandler < ::YARD::Handlers::C::Base; end
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/module_handler.rb#3
+YARD::Handlers::C::ModuleHandler::MATCH1 = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/module_handler.rb#4
+YARD::Handlers::C::ModuleHandler::MATCH2 = T.let(T.unsafe(nil), Regexp)
+
+# Parses comments
+#
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/override_comment_handler.rb#3
+class YARD::Handlers::C::OverrideCommentHandler < ::YARD::Handlers::C::Base
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/override_comment_handler.rb#24
+  def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/handlers/c/override_comment_handler.rb#28
+  def register_file_info(object, file = T.unsafe(nil), line = T.unsafe(nil), comments = T.unsafe(nil)); end
+end
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/path_handler.rb#2
+class YARD::Handlers::C::PathHandler < ::YARD::Handlers::C::Base; end
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/path_handler.rb#3
+YARD::Handlers::C::PathHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/struct_handler.rb#2
+class YARD::Handlers::C::StructHandler < ::YARD::Handlers::C::Base; end
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/struct_handler.rb#3
+YARD::Handlers::C::StructHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+
+# Keeps track of function bodies for symbol lookup during Ruby method declarations
+#
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/symbol_handler.rb#3
+class YARD::Handlers::C::SymbolHandler < ::YARD::Handlers::C::Base; end
+
+# @since 0.8.0
+#
+# source://yard//lib/yard/handlers/c/symbol_handler.rb#4
+YARD::Handlers::C::SymbolHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+
+# Shared logic between C and Ruby handlers.
+#
+# source://yard//lib/yard/autoload.rb#68
+module YARD::Handlers::Common; end
+
+# Shared functionality between Ruby and C method handlers.
+#
+# source://yard//lib/yard/handlers/common/method_handler.rb#6
+module YARD::Handlers::Common::MethodHandler
+  # @param obj [MethodObject]
+  #
+  # source://yard//lib/yard/handlers/common/method_handler.rb#8
+  def add_predicate_return_tag(obj); end
+end
+
+# Raise this error when a handler should exit before completing.
+# The exception will be silenced, allowing the next handler(s) in the
+# queue to be executed.
+#
+# @since 0.8.4
+#
+# source://yard//lib/yard/handlers/base.rb#8
+class YARD::Handlers::HandlerAborted < ::RuntimeError; end
+
+# Raised during processing phase when a handler needs to perform
+# an operation on an object's namespace but the namespace could
+# not be resolved.
+#
+# source://yard//lib/yard/handlers/base.rb#13
+class YARD::Handlers::NamespaceMissingError < ::YARD::Parser::UndocumentableError
+  # @return [NamespaceMissingError] a new instance of NamespaceMissingError
+  #
+  # source://yard//lib/yard/handlers/base.rb#18
+  def initialize(object); end
+
+  # The object the error occurred on
+  #
+  # @return [CodeObjects::Base] a code object
+  #
+  # source://yard//lib/yard/handlers/base.rb#16
+  def object; end
+
+  # The object the error occurred on
+  #
+  # @return [CodeObjects::Base] a code object
+  #
+  # source://yard//lib/yard/handlers/base.rb#16
+  def object=(_arg0); end
+end
+
+# Iterates over all statements in a file and delegates them to the
+# {Handlers::Base} objects that are registered to handle the statement.
+#
+# This class is passed to each handler and keeps overall processing state.
+# For example, if the {#visibility} is set in a handler, all following
+# statements will have access to this state. This allows "public",
+# "protected" and "private" statements to be handled in classes and modules.
+# In addition, the {#namespace} can be set during parsing to control
+# where objects are being created from. You can also access extra stateful
+# properties that any handler can set during the duration of the post
+# processing of a file from {#extra_state}. If you need to access state
+# across different files, look at {#globals}.
+#
+# @see Handlers::Base
+#
+# source://yard//lib/yard/handlers/processor.rb#19
+class YARD::Handlers::Processor
+  # Creates a new Processor for a +file+.
+  #
+  # @param parser [Parser::SourceParser] the parser used to initialize the processor
+  # @return [Processor] a new instance of Processor
+  #
+  # source://yard//lib/yard/handlers/processor.rb#91
+  def initialize(parser); end
+
+  # Share state across different handlers inside of a file.
+  # This attribute is similar to {#visibility}, {#scope}, {#namespace}
+  # and {#owner}, in that they all maintain state across all handlers
+  # for the entire source file. Use this attribute to store any data
+  # your handler might need to save during the parsing of a file. If
+  # you need to save state across files, see {#globals}.
+  #
+  # @return [OpenStruct] an open structure that can store arbitrary data
+  # @see #globals
+  #
+  # source://yard//lib/yard/handlers/processor.rb#87
+  def extra_state; end
+
+  # Share state across different handlers inside of a file.
+  # This attribute is similar to {#visibility}, {#scope}, {#namespace}
+  # and {#owner}, in that they all maintain state across all handlers
+  # for the entire source file. Use this attribute to store any data
+  # your handler might need to save during the parsing of a file. If
+  # you need to save state across files, see {#globals}.
+  #
+  # @return [OpenStruct] an open structure that can store arbitrary data
+  # @see #globals
+  #
+  # source://yard//lib/yard/handlers/processor.rb#87
+  def extra_state=(_arg0); end
+
+  # @return [String] the filename
+  #
+  # source://yard//lib/yard/handlers/processor.rb#40
+  def file; end
+
+  # @return [String] the filename
+  #
+  # source://yard//lib/yard/handlers/processor.rb#40
+  def file=(_arg0); end
+
+  # Searches for all handlers in {Base.subclasses} that match the +statement+
+  #
+  # @param statement the statement object to match.
+  # @return [Array<Base>] a list of handlers to process the statement with.
+  #
+  # source://yard//lib/yard/handlers/processor.rb#150
+  def find_handlers(statement); end
+
+  # Handlers can share state for the entire post processing stage through
+  # this attribute. Note that post processing stage spans multiple files.
+  # To share state only within a single file, use {#extra_state}
+  #
+  # @example Sharing state among two handlers
+  #   class Handler1 < YARD::Handlers::Ruby::Base
+  #   handles :class
+  #   process { globals.foo = :bar }
+  #   end
+  #
+  #   class Handler2 < YARD::Handlers::Ruby::Base
+  #   handles :method
+  #   process { puts globals.foo }
+  #   end
+  # @return [OpenStruct] global shared state for post-processing stage
+  # @see #extra_state
+  #
+  # source://yard//lib/yard/handlers/processor.rb#76
+  def globals; end
+
+  # Handlers can share state for the entire post processing stage through
+  # this attribute. Note that post processing stage spans multiple files.
+  # To share state only within a single file, use {#extra_state}
+  #
+  # @example Sharing state among two handlers
+  #   class Handler1 < YARD::Handlers::Ruby::Base
+  #   handles :class
+  #   process { globals.foo = :bar }
+  #   end
+  #
+  #   class Handler2 < YARD::Handlers::Ruby::Base
+  #   handles :method
+  #   process { puts globals.foo }
+  #   end
+  # @return [OpenStruct] global shared state for post-processing stage
+  # @see #extra_state
+  #
+  # source://yard//lib/yard/handlers/processor.rb#76
+  def globals=(_arg0); end
+
+  # @return [CodeObjects::NamespaceObject] the current namespace
+  #
+  # source://yard//lib/yard/handlers/processor.rb#43
+  def namespace; end
+
+  # @return [CodeObjects::NamespaceObject] the current namespace
+  #
+  # source://yard//lib/yard/handlers/processor.rb#43
+  def namespace=(_arg0); end
+
+  # @return [CodeObjects::Base, nil] unlike the namespace, the owner
+  #   is a non-namespace object that should be stored between statements.
+  #   For instance, when parsing a method body, the {CodeObjects::MethodObject}
+  #   is set as the owner, in case any extra method information is processed.
+  #
+  # source://yard//lib/yard/handlers/processor.rb#55
+  def owner; end
+
+  # @return [CodeObjects::Base, nil] unlike the namespace, the owner
+  #   is a non-namespace object that should be stored between statements.
+  #   For instance, when parsing a method body, the {CodeObjects::MethodObject}
+  #   is set as the owner, in case any extra method information is processed.
+  #
+  # source://yard//lib/yard/handlers/processor.rb#55
+  def owner=(_arg0); end
+
+  # Continue parsing the remainder of the files in the +globals.ordered_parser+
+  # object. After the remainder of files are parsed, processing will continue
+  # on the current file.
+  #
+  # @return [void]
+  # @see Parser::OrderedParser
+  #
+  # source://yard//lib/yard/handlers/processor.rb#139
+  def parse_remaining_files; end
+
+  # @return [Symbol] the parser type (:ruby, :ruby18, :c)
+  #
+  # source://yard//lib/yard/handlers/processor.rb#58
+  def parser_type; end
+
+  # @return [Symbol] the parser type (:ruby, :ruby18, :c)
+  #
+  # source://yard//lib/yard/handlers/processor.rb#58
+  def parser_type=(_arg0); end
+
+  # Processes a list of statements by finding handlers to process each
+  # one.
+  #
+  # @param statements [Array] a list of statements
+  # @return [void]
+  #
+  # source://yard//lib/yard/handlers/processor.rb#109
+  def process(statements); end
+
+  # @return [Symbol] the current scope (class, instance)
+  #
+  # source://yard//lib/yard/handlers/processor.rb#49
+  def scope; end
+
+  # @return [Symbol] the current scope (class, instance)
+  #
+  # source://yard//lib/yard/handlers/processor.rb#49
+  def scope=(_arg0); end
+
+  # @return [Symbol] the current visibility (public, private, protected)
+  #
+  # source://yard//lib/yard/handlers/processor.rb#46
+  def visibility; end
+
+  # @return [Symbol] the current visibility (public, private, protected)
+  #
+  # source://yard//lib/yard/handlers/processor.rb#46
+  def visibility=(_arg0); end
+
+  private
+
+  # Returns the handler base class
+  #
+  # @return [Base] the base class
+  #
+  # source://yard//lib/yard/handlers/processor.rb#171
+  def handler_base_class; end
+
+  # The module holding the handlers to be loaded
+  #
+  # @return [Module] the module containing the handlers depending on
+  #   {#parser_type}.
+  #
+  # source://yard//lib/yard/handlers/processor.rb#179
+  def handler_base_namespace; end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/handlers/processor.rb#160
+  def handles?(handler, statement); end
+
+  # Loads handlers from {#handler_base_namespace}. This ensures that
+  # Ruby1.9 handlers are never loaded into 1.8; also lowers the amount
+  # of modules that are loaded
+  #
+  # @return [void]
+  #
+  # source://yard//lib/yard/handlers/processor.rb#187
+  def load_handlers; end
+
+  class << self
+    # @private
+    # @return [Hash] a list of registered parser type extensions
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/handlers/processor.rb#32
+    def namespace_for_handler; end
+
+    # Registers a new namespace for handlers of the given type.
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/handlers/processor.rb#23
+    def register_handler_namespace(type, ns); end
+  end
+end
+
+# All Ruby handlers
+#
+# source://yard//lib/yard/autoload.rb#92
+module YARD::Handlers::Ruby; end
+
+# Handles alias and alias_method calls
+#
+# source://yard//lib/yard/handlers/ruby/alias_handler.rb#3
+class YARD::Handlers::Ruby::AliasHandler < ::YARD::Handlers::Ruby::Base; end
+
+# Handles +attr_*+ statements in modules/classes
+#
+# source://yard//lib/yard/handlers/ruby/attribute_handler.rb#3
+class YARD::Handlers::Ruby::AttributeHandler < ::YARD::Handlers::Ruby::Base
+  protected
+
+  # Strips out any non-essential arguments from the attr statement.
+  #
+  # @param params [Array<Parser::Ruby::AstNode>] a list of the parameters
+  #   in the attr call.
+  # @raise [Parser::UndocumentableError] if the arguments are not valid.
+  # @return [Array<String>] the validated attribute names
+  #
+  # source://yard//lib/yard/handlers/ruby/attribute_handler.rb#75
+  def validated_attribute_names(params); end
+end
+
+# This is the base handler class for the new-style (1.9) Ruby parser.
+# All handlers that subclass this base class will be used when the
+# new-style parser is used. For implementing legacy handlers, see
+# {Legacy::Base}.
+#
+# @abstract See {Handlers::Base} for subclassing information.
+# @see Handlers::Base
+# @see Legacy::Base
+#
+# source://yard//lib/yard/handlers/ruby/base.rb#65
+class YARD::Handlers::Ruby::Base < ::YARD::Handlers::Base
+  include ::YARD::Parser::Ruby
+  extend ::YARD::Parser::Ruby
+
+  # source://yard//lib/yard/handlers/ruby/base.rb#144
+  def call_params; end
+
+  # source://yard//lib/yard/handlers/ruby/base.rb#155
+  def caller_method; end
+
+  # source://yard//lib/yard/handlers/ruby/base.rb#135
+  def parse_block(inner_node, opts = T.unsafe(nil)); end
+
+  class << self
+    # @return [Boolean] whether or not an {AstNode} object should be
+    #   handled by this handler
+    #
+    # source://yard//lib/yard/handlers/ruby/base.rb#113
+    def handles?(node); end
+
+    # Matcher for handling a node with a specific meta-type. An {AstNode}
+    # has a {AstNode#type} to define its type but can also be associated
+    # with a set of types. For instance, +:if+ and +:unless+ are both
+    # of the meta-type +:condition+.
+    #
+    # A meta-type is any method on the {AstNode} class ending in "?",
+    # though you should not include the "?" suffix in your declaration.
+    # Some examples are: "condition", "call", "literal", "kw", "token",
+    # "ref".
+    #
+    # @example Handling any conditional statement (if, unless)
+    #   handles meta_type(:condition)
+    # @param type [Symbol] the meta-type to match. A meta-type can be
+    #   any method name + "?" that {AstNode} responds to.
+    # @return [void]
+    #
+    # source://yard//lib/yard/handlers/ruby/base.rb#105
+    def meta_type(type); end
+
+    # Matcher for handling any type of method call. Method calls can
+    # be expressed by many {AstNode} types depending on the syntax
+    # with which it is called, so YARD allows you to use this matcher
+    # to simplify matching a method call.
+    #
+    # @example Match the "describe" method call
+    #   handles method_call(:describe)
+    #
+    #   # The following will be matched:
+    #   # describe(...)
+    #   # object.describe(...)
+    #   # describe "argument" do ... end
+    # @param name [#to_s] matches the method call of this name
+    # @return [void]
+    #
+    # source://yard//lib/yard/handlers/ruby/base.rb#86
+    def method_call(name = T.unsafe(nil)); end
+  end
+end
+
+# Matches if/unless conditions inside classes and attempts to process only
+# one branch (by evaluating the condition if possible).
+#
+# @example A simple class conditional
+#   class Foo
+#   if 0
+#   # This method is ignored
+#   def xyz; end
+#   end
+#   end
+#
+# source://yard//lib/yard/handlers/ruby/class_condition_handler.rb#12
+class YARD::Handlers::Ruby::ClassConditionHandler < ::YARD::Handlers::Ruby::Base
+  protected
+
+  # Parses the condition part of the if/unless statement
+  #
+  # @return [true, false, nil] true if the condition can be definitely
+  #   parsed to true, false if not, and nil if the condition cannot be
+  #   parsed with certainty (it's dynamic)
+  #
+  # source://yard//lib/yard/handlers/ruby/class_condition_handler.rb#36
+  def parse_condition; end
+
+  # source://yard//lib/yard/handlers/ruby/class_condition_handler.rb#87
+  def parse_else_block; end
+
+  # source://yard//lib/yard/handlers/ruby/class_condition_handler.rb#83
+  def parse_then_block; end
+end
+
+# Handles class declarations
+#
+# source://yard//lib/yard/handlers/ruby/class_handler.rb#3
+class YARD::Handlers::Ruby::ClassHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Ruby::StructHandlerMethods
+
+  private
+
+  # source://yard//lib/yard/handlers/ruby/class_handler.rb#73
+  def create_struct_superclass(superclass, superclass_def); end
+
+  # Extract the parameters from the Struct.new AST node, returning them as a list
+  # of strings
+  #
+  # @param superclass [MethodCallNode] the AST node for the Struct.new call
+  # @return [Array<String>] the member names to generate methods for
+  #
+  # source://yard//lib/yard/handlers/ruby/class_handler.rb#67
+  def extract_parameters(superclass); end
+
+  # source://yard//lib/yard/handlers/ruby/class_handler.rb#92
+  def parse_struct_superclass(klass, superclass); end
+
+  # source://yard//lib/yard/handlers/ruby/class_handler.rb#98
+  def parse_superclass(superclass); end
+
+  # source://yard//lib/yard/handlers/ruby/class_handler.rb#82
+  def struct_superclass_name(superclass); end
+end
+
+# Handles a class variable (@@variable)
+#
+# source://yard//lib/yard/handlers/ruby/class_variable_handler.rb#3
+class YARD::Handlers::Ruby::ClassVariableHandler < ::YARD::Handlers::Ruby::Base; end
+
+# Handles any lone comment statement in a Ruby file
+#
+# source://yard//lib/yard/handlers/ruby/comment_handler.rb#3
+class YARD::Handlers::Ruby::CommentHandler < ::YARD::Handlers::Ruby::Base; end
+
+# Handles any constant assignment
+#
+# source://yard//lib/yard/handlers/ruby/constant_handler.rb#3
+class YARD::Handlers::Ruby::ConstantHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Ruby::StructHandlerMethods
+
+  private
+
+  # Extract the parameters from the Struct.new AST node, returning them as a list
+  # of strings
+  #
+  # @param superclass [MethodCallNode] the AST node for the Struct.new call
+  # @return [Array<String>] the member names to generate methods for
+  #
+  # source://yard//lib/yard/handlers/ruby/constant_handler.rb#49
+  def extract_parameters(superclass); end
+
+  # source://yard//lib/yard/handlers/ruby/constant_handler.rb#21
+  def process_constant(statement); end
+
+  # source://yard//lib/yard/handlers/ruby/constant_handler.rb#33
+  def process_structclass(statement); end
+end
+
+# Handles automatic detection of dsl-style methods
+#
+# source://yard//lib/yard/handlers/ruby/dsl_handler.rb#6
+class YARD::Handlers::Ruby::DSLHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Ruby::DSLHandlerMethods
+end
+
+# source://yard//lib/yard/handlers/ruby/dsl_handler_methods.rb#5
+module YARD::Handlers::Ruby::DSLHandlerMethods
+  include ::YARD::CodeObjects
+  include ::YARD::Parser
+
+  # source://yard//lib/yard/handlers/ruby/dsl_handler_methods.rb#14
+  def handle_comments; end
+
+  # source://yard//lib/yard/handlers/ruby/dsl_handler_methods.rb#48
+  def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end
+
+  private
+
+  # source://yard//lib/yard/handlers/ruby/dsl_handler_methods.rb#72
+  def find_attached_macro; end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/handlers/ruby/dsl_handler_methods.rb#54
+  def implicit_docstring?; end
+
+  # @return [Boolean] whether caller method matches a macro or
+  #   its alias names.
+  #
+  # source://yard//lib/yard/handlers/ruby/dsl_handler_methods.rb#85
+  def macro_name_matches(macro); end
+
+  # source://yard//lib/yard/handlers/ruby/dsl_handler_methods.rb#59
+  def method_name; end
+
+  # source://yard//lib/yard/handlers/ruby/dsl_handler_methods.rb#68
+  def method_signature; end
+end
+
+# source://yard//lib/yard/handlers/ruby/dsl_handler_methods.rb#9
+YARD::Handlers::Ruby::DSLHandlerMethods::IGNORE_METHODS = T.let(T.unsafe(nil), Hash)
+
+# Helper methods to assist with processing decorators.
+#
+# source://yard//lib/yard/handlers/ruby/decorator_handler_methods.rb#3
+module YARD::Handlers::Ruby::DecoratorHandlerMethods
+  # @overload process_decorator
+  #
+  # source://yard//lib/yard/handlers/ruby/decorator_handler_methods.rb#43
+  def process_decorator(*nodes, &block); end
+
+  private
+
+  # @yield [method, node, name.to_sym]
+  #
+  # source://yard//lib/yard/handlers/ruby/decorator_handler_methods.rb#78
+  def process_decorator_parameter(node, opts = T.unsafe(nil), &block); end
+end
+
+# Handles 'raise' calls inside methods
+#
+# source://yard//lib/yard/handlers/ruby/exception_handler.rb#3
+class YARD::Handlers::Ruby::ExceptionHandler < ::YARD::Handlers::Ruby::Base; end
+
+# Handles 'extend' call to include modules into the class scope of another
+#
+# @see MixinHandler
+#
+# source://yard//lib/yard/handlers/ruby/extend_handler.rb#4
+class YARD::Handlers::Ruby::ExtendHandler < ::YARD::Handlers::Ruby::MixinHandler
+  # source://yard//lib/yard/handlers/ruby/extend_handler.rb#8
+  def scope; end
+
+  private
+
+  # source://yard//lib/yard/handlers/ruby/extend_handler.rb#12
+  def process_mixin(mixin); end
+end
+
+# To implement a custom handler matcher, subclass this class and implement
+# {#matches?} to return whether a node matches the handler.
+#
+# @example A Custom Handler Matcher Extension
+#   # Implements a handler that checks for a specific string
+#   # in the node's source.
+#   class MyExtension < HandlesExtension
+#   def matches?(node) node.source.include?(name) end
+#   end
+#
+#   # This handler will handle any node where the source includes 'foo'
+#   class MyHandler < Handlers::Ruby::Base
+#   handles MyExtension.new('foo')
+#   end
+#
+# source://yard//lib/yard/handlers/ruby/base.rb#19
+class YARD::Handlers::Ruby::HandlesExtension
+  # Creates a new extension with a specific matcher value +name+
+  #
+  # @param name [Object] the matcher value to check against {#matches?}
+  # @return [HandlesExtension] a new instance of HandlesExtension
+  #
+  # source://yard//lib/yard/handlers/ruby/base.rb#22
+  def initialize(name); end
+
+  # Tests if the node matches the handler
+  #
+  # @param node [Parser::Ruby::AstNode] a Ruby node
+  # @raise [NotImplementedError]
+  # @return [Boolean] whether the +node+ matches the handler
+  #
+  # source://yard//lib/yard/handlers/ruby/base.rb#27
+  def matches?(node); end
+
+  protected
+
+  # @return [String] the extension matcher value
+  #
+  # source://yard//lib/yard/handlers/ruby/base.rb#34
+  def name; end
+end
+
+# Handlers for old Ruby 1.8 parser
+#
+# source://yard//lib/yard/autoload.rb#93
+module YARD::Handlers::Ruby::Legacy; end
+
+# Handles alias and alias_method calls
+#
+# source://yard//lib/yard/handlers/ruby/legacy/alias_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::AliasHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+# Handles +attr_*+ statements in modules/classes
+#
+# source://yard//lib/yard/handlers/ruby/legacy/attribute_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::AttributeHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+# This is the base handler for the legacy parser. To implement a legacy
+# handler, subclass this class.
+#
+# @abstract See {Handlers::Base} for subclassing information.
+#
+# source://yard//lib/yard/handlers/ruby/legacy/base.rb#9
+class YARD::Handlers::Ruby::Legacy::Base < ::YARD::Handlers::Base
+  include ::YARD::Parser::Ruby::Legacy::RubyToken
+
+  # source://yard//lib/yard/handlers/ruby/legacy/base.rb#44
+  def call_params; end
+
+  # source://yard//lib/yard/handlers/ruby/legacy/base.rb#53
+  def caller_method; end
+
+  # Parses a statement's block with a set of state values. If the
+  # statement has no block, nothing happens. A description of state
+  # values can be found at {Handlers::Base#push_state}
+  #
+  # @option opts
+  # @option opts
+  # @option opts
+  # @param opts [Hash] State options
+  # @see Handlers::Base#push_state #push_state
+  #
+  # source://yard//lib/yard/handlers/ruby/legacy/base.rb#35
+  def parse_block(opts = T.unsafe(nil)); end
+
+  private
+
+  # Extracts method information for macro expansion only
+  #
+  # @return [Array<String,Array<Array<String>>>] the method name followed by method
+  #   arguments (name and optional value)
+  # @todo This is a duplicate implementation of {MethodHandler}. Refactor.
+  #
+  # source://yard//lib/yard/handlers/ruby/legacy/base.rb#68
+  def extract_method_details; end
+
+  # The string value of a token. For example, the return value for the symbol :sym
+  # would be :sym. The return value for a string +"foo #{ bar}"+ would be the literal
+  # +"foo #{ bar}"+ without any interpolation. The return value of the identifier
+  # 'test' would be the same value: 'test'. Here is a list of common types and
+  # their return values:
+  #
+  # @example
+  #   tokval(TokenList.new('"foo"').first) => "foo"
+  #   tokval(TokenList.new(':foo').first) => :foo
+  #   tokval(TokenList.new('CONSTANT').first, RubyToken::TkId) => "CONSTANT"
+  #   tokval(TokenList.new('identifier').first, RubyToken::TkId) => "identifier"
+  #   tokval(TokenList.new('3.25').first) => 3.25
+  #   tokval(TokenList.new('/xyz/i').first) => /xyz/i
+  # @param token [Token] The token of the class
+  # @param accepted_types [Array<Class<Token>>, Symbol] The allowed token types that this token can be. Defaults to [{TkVal}].
+  #   A list of types would be, for example, [+TkSTRING+, +TkSYMBOL+], to return
+  #   the token's value if it is either of those types. If +TkVal+ is accepted,
+  #   +TkNode+ is also accepted.
+  #
+  #   Certain symbol keys are allowed to specify multiple types in one fell swoop.
+  #   These symbols are:
+  #   :string       => +TkSTRING+, +TkDSTRING+, +TkDXSTRING+ and +TkXSTRING+
+  #   :attr         => +TkSYMBOL+ and +TkSTRING+
+  #   :identifier   => +TkIDENTIFIER, +TkFID+ and +TkGVAR+.
+  #   :number       => +TkFLOAT+, +TkINTEGER+
+  # @return [Object] if the token is one of the accepted types, in its real value form.
+  #   It should be noted that identifiers and constants are kept in String form.
+  # @return [nil] if the token is not any of the specified accepted types
+  #
+  # source://yard//lib/yard/handlers/ruby/legacy/base.rb#112
+  def tokval(token, *accepted_types); end
+
+  # Returns a list of symbols or string values from a statement.
+  # The list must be a valid comma delimited list, and values
+  # will only be returned to the end of the list only.
+  #
+  # Example:
+  #   attr_accessor :a, 'b', :c, :d => ['a', 'b', 'c', 'd']
+  #   attr_accessor 'a', UNACCEPTED_TYPE, 'c' => ['a', 'c']
+  #
+  # The tokval list of a {Parser::Ruby::Legacy::TokenList} of the above
+  # code would be the {#tokval} value of :a, 'b',
+  # :c and :d.
+  #
+  # It should also be noted that this function stops immediately at
+  # any ruby keyword encountered:
+  #   "attr_accessor :a, :b, :c if x == 5"  => ['a', 'b', 'c']
+  #
+  # @param tokenlist [TokenList] The list of tokens to process.
+  # @param accepted_types [Array<Class<Token>>] passed to {#tokval}
+  # @return [Array<String>] the list of tokvalues in the list.
+  # @return [Array<EMPTY>] if there are no symbols or Strings in the list
+  # @see #tokval
+  #
+  # source://yard//lib/yard/handlers/ruby/legacy/base.rb#178
+  def tokval_list(tokenlist, *accepted_types); end
+
+  class << self
+    # @return [Boolean] whether or not a {Parser::Ruby::Legacy::Statement} object should be handled
+    #   by this handler.
+    #
+    # source://yard//lib/yard/handlers/ruby/legacy/base.rb#15
+    def handles?(stmt); end
+  end
+end
+
+# Matches if/unless conditions inside classes and attempts to process only
+# one branch (by evaluating the condition if possible).
+#
+# @example A simple class conditional
+#   class Foo
+#   if 0
+#   # This method is ignored
+#   def xyz; end
+#   end
+#   end
+# @since 0.5.4
+#
+# source://yard//lib/yard/handlers/ruby/legacy/class_condition_handler.rb#4
+class YARD::Handlers::Ruby::Legacy::ClassConditionHandler < ::YARD::Handlers::Ruby::Legacy::Base
+  protected
+
+  # Parses the condition part of the if/unless statement
+  #
+  # @return [true, false, nil] true if the condition can be definitely
+  #   parsed to true, false if not, and nil if the condition cannot be
+  #   parsed with certainty (it's dynamic)
+  # @since 0.5.5
+  #
+  # source://yard//lib/yard/handlers/ruby/legacy/class_condition_handler.rb#29
+  def parse_condition; end
+
+  # @since 0.5.5
+  #
+  # source://yard//lib/yard/handlers/ruby/legacy/class_condition_handler.rb#73
+  def parse_else_block; end
+
+  # @since 0.5.5
+  #
+  # source://yard//lib/yard/handlers/ruby/legacy/class_condition_handler.rb#68
+  def parse_then_block; end
+end
+
+# Handles class declarations
+#
+# source://yard//lib/yard/handlers/ruby/legacy/class_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::ClassHandler < ::YARD::Handlers::Ruby::Legacy::Base
+  include ::YARD::Handlers::Ruby::StructHandlerMethods
+
+  private
+
+  # source://yard//lib/yard/handlers/ruby/legacy/class_handler.rb#74
+  def create_struct_superclass(superclass, superclass_def); end
+
+  # Extracts the parameter list from the Struct.new declaration and returns it
+  # formatted as a list of member names. Expects the user will have used symbols
+  # to define the struct member names
+  #
+  # @param superstring [String] the string declaring the superclass
+  # @return [Array<String>] a list of member names
+  #
+  # source://yard//lib/yard/handlers/ruby/legacy/class_handler.rb#69
+  def extract_parameters(superstring); end
+
+  # source://yard//lib/yard/handlers/ruby/legacy/class_handler.rb#95
+  def parse_struct_subclass(klass, superclass_def); end
+
+  # source://yard//lib/yard/handlers/ruby/legacy/class_handler.rb#102
+  def parse_superclass(superclass); end
+
+  # source://yard//lib/yard/handlers/ruby/legacy/class_handler.rb#83
+  def struct_superclass_name(superclass); end
+end
+
+# Handles a class variable (@@variable)
+#
+# source://yard//lib/yard/handlers/ruby/legacy/class_variable_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::ClassVariableHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+# source://yard//lib/yard/handlers/ruby/legacy/class_variable_handler.rb#4
+YARD::Handlers::Ruby::Legacy::ClassVariableHandler::HANDLER_MATCH = T.let(T.unsafe(nil), Regexp)
+
+# Handles any lone comment statement in a Ruby file
+#
+# source://yard//lib/yard/handlers/ruby/legacy/comment_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::CommentHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+# Handles any constant assignment
+#
+# source://yard//lib/yard/handlers/ruby/legacy/constant_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::ConstantHandler < ::YARD::Handlers::Ruby::Legacy::Base
+  include ::YARD::Handlers::Ruby::StructHandlerMethods
+
+  private
+
+  # source://yard//lib/yard/handlers/ruby/legacy/constant_handler.rb#25
+  def extract_parameters(parameters); end
+
+  # source://yard//lib/yard/handlers/ruby/legacy/constant_handler.rb#20
+  def process_structclass(classname, parameters); end
+end
+
+# source://yard//lib/yard/handlers/ruby/legacy/constant_handler.rb#5
+YARD::Handlers::Ruby::Legacy::ConstantHandler::HANDLER_MATCH = T.let(T.unsafe(nil), Regexp)
+
+# Handles automatic detection of dsl-style methods
+#
+# source://yard//lib/yard/handlers/ruby/legacy/dsl_handler.rb#7
+class YARD::Handlers::Ruby::Legacy::DSLHandler < ::YARD::Handlers::Ruby::Legacy::Base
+  include ::YARD::Handlers::Ruby::DSLHandlerMethods
+end
+
+# Handles 'raise' calls inside methods
+#
+# source://yard//lib/yard/handlers/ruby/legacy/exception_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::ExceptionHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+# Handles 'extend' call to include modules into the class scope of another
+#
+# @see MixinHandler
+#
+# source://yard//lib/yard/handlers/ruby/legacy/extend_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::ExtendHandler < ::YARD::Handlers::Ruby::Legacy::MixinHandler
+  # source://yard//lib/yard/handlers/ruby/legacy/extend_handler.rb#7
+  def scope; end
+
+  private
+
+  # source://yard//lib/yard/handlers/ruby/legacy/extend_handler.rb#11
+  def process_mixin(mixin); end
+end
+
+# Handles a method definition
+#
+# source://yard//lib/yard/handlers/ruby/legacy/method_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::MethodHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+# Handles the 'include' statement to mixin a module in the instance scope
+#
+# source://yard//lib/yard/handlers/ruby/legacy/mixin_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::MixinHandler < ::YARD::Handlers::Ruby::Legacy::Base
+  private
+
+  # @raise [YARD::Parser::UndocumentableError]
+  #
+  # source://yard//lib/yard/handlers/ruby/legacy/mixin_handler.rb#26
+  def process_mixin(mixin); end
+end
+
+# Handles module_function calls to turn methods into public class methods.
+# Also creates a private instance copy of the method.
+#
+# source://yard//lib/yard/handlers/ruby/legacy/module_function_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+# Handles the declaration of a module
+#
+# source://yard//lib/yard/handlers/ruby/legacy/module_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::ModuleHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+# Sets visibility of a class method to private.
+#
+# source://yard//lib/yard/handlers/ruby/legacy/private_class_method_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler < ::YARD::Handlers::Ruby::Legacy::Base
+  private
+
+  # source://yard//lib/yard/handlers/ruby/legacy/private_class_method_handler.rb#15
+  def privatize_class_method(name); end
+end
+
+# Sets visibility of a constant (class, module, const)
+#
+# source://yard//lib/yard/handlers/ruby/legacy/private_constant_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::PrivateConstantHandler < ::YARD::Handlers::Ruby::Legacy::Base
+  private
+
+  # source://yard//lib/yard/handlers/ruby/legacy/private_constant_handler.rb#15
+  def privatize_constant(name); end
+end
+
+# Handles 'private', 'protected', and 'public' calls.
+#
+# source://yard//lib/yard/handlers/ruby/legacy/visibility_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::VisibilityHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+# Handles 'yield' calls
+#
+# source://yard//lib/yard/handlers/ruby/legacy/yield_handler.rb#3
+class YARD::Handlers::Ruby::Legacy::YieldHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+# source://yard//lib/yard/handlers/ruby/base.rb#37
+class YARD::Handlers::Ruby::MethodCallWrapper < ::YARD::Handlers::Ruby::HandlesExtension
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/handlers/ruby/base.rb#38
+  def matches?(node); end
+end
+
+# Handles a conditional inside a method
+#
+# source://yard//lib/yard/handlers/ruby/method_condition_handler.rb#3
+class YARD::Handlers::Ruby::MethodConditionHandler < ::YARD::Handlers::Ruby::Base; end
+
+# Handles a method definition
+#
+# source://yard//lib/yard/handlers/ruby/method_handler.rb#3
+class YARD::Handlers::Ruby::MethodHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Common::MethodHandler
+
+  # source://yard//lib/yard/handlers/ruby/method_handler.rb#69
+  def format_args; end
+end
+
+# Handles the 'include' statement to mixin a module in the instance scope
+#
+# source://yard//lib/yard/handlers/ruby/mixin_handler.rb#3
+class YARD::Handlers::Ruby::MixinHandler < ::YARD::Handlers::Ruby::Base
+  protected
+
+  # @raise [YARD::Parser::UndocumentableError]
+  #
+  # source://yard//lib/yard/handlers/ruby/mixin_handler.rb#25
+  def process_mixin(mixin); end
+
+  # source://yard//lib/yard/handlers/ruby/mixin_handler.rb#50
+  def recipient(mixin); end
+end
+
+# Handles module_function calls to turn methods into public class methods.
+# Also creates a private instance copy of the method.
+#
+# source://yard//lib/yard/handlers/ruby/module_function_handler.rb#4
+class YARD::Handlers::Ruby::ModuleFunctionHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Ruby::DecoratorHandlerMethods
+
+  # source://yard//lib/yard/handlers/ruby/module_function_handler.rb#34
+  def make_module_function(instance_method, namespace); end
+end
+
+# Handles the declaration of a module
+#
+# source://yard//lib/yard/handlers/ruby/module_handler.rb#3
+class YARD::Handlers::Ruby::ModuleHandler < ::YARD::Handlers::Ruby::Base; end
+
+# Sets visibility of a class method to private.
+#
+# source://yard//lib/yard/handlers/ruby/private_class_method_handler.rb#3
+class YARD::Handlers::Ruby::PrivateClassMethodHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Ruby::DecoratorHandlerMethods
+end
+
+# Sets visibility of a constant (class, module, const)
+#
+# source://yard//lib/yard/handlers/ruby/private_constant_handler.rb#6
+class YARD::Handlers::Ruby::PrivateConstantHandler < ::YARD::Handlers::Ruby::Base
+  private
+
+  # source://yard//lib/yard/handlers/ruby/private_constant_handler.rb#28
+  def privatize_constant(node); end
+end
+
+# Sets visibility of a class method to public.
+#
+# source://yard//lib/yard/handlers/ruby/public_class_method_handler.rb#3
+class YARD::Handlers::Ruby::PublicClassMethodHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Ruby::DecoratorHandlerMethods
+end
+
+# Helper methods to parse @attr_* tags on a class.
+#
+# @deprecated The use of +@attr+ tags are deprecated since 0.8.0 in favour of
+#   the +@!attribute+ directive. This module should not be relied on.
+# @since 0.5.6
+#
+# source://yard//lib/yard/handlers/ruby/struct_handler_methods.rb#7
+module YARD::Handlers::Ruby::StructHandlerMethods
+  include ::YARD::CodeObjects
+
+  # Creates the auto-generated docstring for the getter method of a struct's
+  # member. This is used so the generated documentation will look just like that
+  # of an attribute defined using attr_accessor.
+  #
+  # @param klass [ClassObject] the class whose members we're working with
+  # @param member [String] the name of the member we're generating documentation for
+  # @return [String] a docstring to be attached to the getter method for this member
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/handlers/ruby/struct_handler_methods.rb#62
+  def add_reader_tags(klass, new_method, member); end
+
+  # Creates the auto-generated docstring for the setter method of a struct's
+  # member. This is used so the generated documentation will look just like that
+  # of an attribute defined using attr_accessor.
+  #
+  # @param klass [ClassObject] the class whose members we're working with
+  # @param member [String] the name of the member we're generating documentation for
+  # @return [String] a docstring to be attached to the setter method for this member
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/handlers/ruby/struct_handler_methods.rb#77
+  def add_writer_tags(klass, new_method, member); end
+
+  # Creates the given member methods and attaches them to the given ClassObject.
+  #
+  # @param klass [ClassObject] the class to generate attributes for
+  # @param members [Array<String>] a list of member names
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/handlers/ruby/struct_handler_methods.rb#134
+  def create_attributes(klass, members); end
+
+  # Creates and registers a class object with the given name and superclass name.
+  # Returns it for further use.
+  #
+  # @param classname [String] the name of the class
+  # @param superclass [String] the name of the superclass
+  # @return [ClassObject] the class object for further processing/method attaching
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/handlers/ruby/struct_handler_methods.rb#92
+  def create_class(classname, superclass); end
+
+  # Determines whether to create an attribute method based on the class's
+  # tags.
+  #
+  # @param klass [ClassObject] the class whose tags we're searching
+  # @param member [String] the name of the struct member we need
+  # @param type [Symbol] (:read) reader method, or writer method?
+  # @return [Boolean] should the attribute be created?
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/handlers/ruby/struct_handler_methods.rb#38
+  def create_member_method?(klass, member, type = T.unsafe(nil)); end
+
+  # Creates the getter (reader) method and attaches it to the class as an attribute.
+  # Also sets up the docstring to prettify the documentation output.
+  #
+  # @param klass [ClassObject] the class to attach the method to
+  # @param member [String] the name of the member we're generating a method for
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/handlers/ruby/struct_handler_methods.rb#121
+  def create_reader(klass, member); end
+
+  # Creates the setter (writer) method and attaches it to the class as an attribute.
+  # Also sets up the docstring to prettify the documentation output.
+  #
+  # @param klass [ClassObject] the class to attach the method to
+  # @param member [String] the name of the member we're generating a method for
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/handlers/ruby/struct_handler_methods.rb#104
+  def create_writer(klass, member); end
+
+  # Extracts the user's defined @member tag for a given class and its member. Returns
+  # nil if the user did not define a @member tag for this struct entry.
+  #
+  # @param klass [ClassObject] the class whose tags we're searching
+  # @param member [String] the name of the struct member we need
+  # @param type [Symbol] reader method, or writer method?
+  # @return [Tags::Tag, nil] the tag matching the request, or nil if not found
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/handlers/ruby/struct_handler_methods.rb#17
+  def member_tag_for_member(klass, member, type = T.unsafe(nil)); end
+
+  # Retrieves all members defined in @attr* tags
+  #
+  # @param klass [ClassObject] the class with the attributes
+  # @return [Array<String>] the list of members defined as attributes on the class
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/handlers/ruby/struct_handler_methods.rb#26
+  def members_from_tags(klass); end
+
+  # Gets the return type for the member in a nicely formatted string. Used
+  # to be injected into auto-generated docstrings.
+  #
+  # @param member_tag [Tags::Tag] the tag object to check for types
+  # @return [String] the user-declared type of the struct member, or [Object] if
+  #   the user did not define a type for this member.
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/handlers/ruby/struct_handler_methods.rb#51
+  def return_type_from_tag(member_tag); end
+end
+
+# source://yard//lib/yard/handlers/ruby/base.rb#53
+class YARD::Handlers::Ruby::TestNodeWrapper < ::YARD::Handlers::Ruby::HandlesExtension
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/handlers/ruby/base.rb#54
+  def matches?(node); end
+end
+
+# Handles 'private', 'protected', and 'public' calls.
+#
+# source://yard//lib/yard/handlers/ruby/visibility_handler.rb#3
+class YARD::Handlers::Ruby::VisibilityHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Ruby::DecoratorHandlerMethods
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/handlers/ruby/visibility_handler.rb#31
+  def is_attribute_method?(node); end
+end
+
+# Handles 'yield' calls
+#
+# source://yard//lib/yard/handlers/ruby/yield_handler.rb#3
+class YARD::Handlers::Ruby::YieldHandler < ::YARD::Handlers::Ruby::Base; end
+
+# Namespace for internationalization (i18n)
+#
+# @since 0.8.0
+#
+# source://yard//lib/yard/autoload.rb#151
+module YARD::I18n; end
+
+# +Locale+ is a unit of translation. It has {#name} and a set of
+# messages.
+#
+# @since 0.8.2
+#
+# source://yard//lib/yard/i18n/locale.rb#8
+class YARD::I18n::Locale
+  # Creates a locale for +name+ locale.
+  #
+  # @param name [String] the locale name.
+  # @return [Locale] a new instance of Locale
+  # @since 0.8.2
+  #
+  # source://yard//lib/yard/i18n/locale.rb#34
+  def initialize(name); end
+
+  # Loads translation messages from +locale_directory+/{#name}.po.
+  #
+  # @param locale_directory [String] the directory path that has
+  #   {#name}.po.
+  # @return [Boolean] +true+ if PO file exists, +false+ otherwise.
+  # @since 0.8.2
+  #
+  # source://yard//lib/yard/i18n/locale.rb#44
+  def load(locale_directory); end
+
+  # @return [String] the name of the locale. It used IETF language
+  #   tag format +[language[_territory][.codeset][@modifier]]+.
+  # @see http://tools.ietf.org/rfc/bcp/bcp47.txt BCP 47 - Tags for Identifying Languages
+  # @since 0.8.2
+  #
+  # source://yard//lib/yard/i18n/locale.rb#29
+  def name; end
+
+  # @param message [String] the translation target message.
+  # @return [String] translated message. If translation isn't
+  #   registered, the +message+ is returned.
+  # @since 0.8.2
+  #
+  # source://yard//lib/yard/i18n/locale.rb#62
+  def translate(message); end
+
+  class << self
+    # @return [String, nil] the default locale name.
+    # @since 0.8.4
+    #
+    # source://yard//lib/yard/i18n/locale.rb#15
+    def default; end
+
+    # @return [String, nil] the default locale name.
+    # @since 0.8.4
+    #
+    # source://yard//lib/yard/i18n/locale.rb#20
+    def default=(locale); end
+  end
+end
+
+# +Message+ is a translation target message. It has message ID as
+# {#id} and some properties {#locations} and {#comments}.
+#
+# @since 0.8.1
+#
+# source://yard//lib/yard/i18n/message.rb#10
+class YARD::I18n::Message
+  # Creates a translate target message for message ID +id+.
+  #
+  # @param id [String] the message ID of the translate target message.
+  # @return [Message] a new instance of Message
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/i18n/message.rb#24
+  def initialize(id); end
+
+  # @param other [Message] the +Message+ to be compared.
+  # @return [Boolean] checks whether this message is equal to another.
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/i18n/message.rb#49
+  def ==(other); end
+
+  # Adds a comment for the message.
+  #
+  # @param comment [String] the comment for the message to be added.
+  # @return [void]
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/i18n/message.rb#43
+  def add_comment(comment); end
+
+  # Adds location information for the message.
+  #
+  # @param path [String] the path where the message appears.
+  # @param line [Integer] the line number where the message appears.
+  # @return [void]
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/i18n/message.rb#35
+  def add_location(path, line); end
+
+  # @return [Set] the set of comments for the messages.
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/i18n/message.rb#19
+  def comments; end
+
+  # @return [String] the message ID of the translation target message.
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/i18n/message.rb#12
+  def id; end
+
+  # path and line number where the message is appeared.
+  #
+  # @return [Set] the set of locations. Location is an array of
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/i18n/message.rb#16
+  def locations; end
+end
+
+# Acts as a container for {Message} objects.
+#
+# @since 0.8.1
+#
+# source://yard//lib/yard/i18n/messages.rb#7
+class YARD::I18n::Messages
+  include ::Enumerable
+
+  # Creates a new container.
+  #
+  # @return [Messages] a new instance of Messages
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/i18n/messages.rb#11
+  def initialize; end
+
+  # Checks if this messages list is equal to another messages list.
+  #
+  # @param other [Messages] the container to compare.
+  # @return [Boolean] whether +self+ and +other+ is equivalence or not.
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/i18n/messages.rb#45
+  def ==(other); end
+
+  # @param id [String] the message ID to perform a lookup on.
+  # @return [Message, nil] a registered message for the given +id+,
+  #   or nil if no message for the ID is found.
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/i18n/messages.rb#27
+  def [](id); end
+
+  # Enumerates each {Message} in the container.
+  #
+  # @return [void]
+  # @since 0.8.1
+  # @yieldparam message [Message] the next message object in
+  #   the enumeration.
+  #
+  # source://yard//lib/yard/i18n/messages.rb#20
+  def each(&block); end
+
+  # Registers a {Message}, the message ID of which is +id+. If
+  # corresponding +Message+ is already registered, the previously
+  # registered object is returned.
+  #
+  # @param id [String] the ID of the message to be registered.
+  # @return [Message] the registered +Message+.
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/i18n/messages.rb#37
+  def register(id); end
+
+  protected
+
+  # @return [Hash{String=>Message}] the set of message objects
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/i18n/messages.rb#53
+  def messages; end
+end
+
+# The +PotGenerator+ generates POT format string from
+# {CodeObjects::Base} and {CodeObjects::ExtraFileObject}.
+#
+# == POT and PO
+#
+# POT is an acronym for "Portable Object Template". POT is a
+# template file to create PO file. The extension for POT is
+# ".pot". PO file is an acronym for "Portable Object". PO file has
+# many parts of message ID (msgid) that is translation target
+# message and message string (msgstr) that is translated message
+# of message ID. If you want to translate "Hello" in English into
+# "Bonjour" in French, "Hello" is the msgid ID and "Bonjour" is
+# msgstr. The extension for PO is ".po".
+#
+# == How to extract msgids
+#
+# The +PotGenerator+ has two parse methods:
+#
+# * {#parse_objects} for {CodeObjects::Base}
+# * {#parse_files} for {CodeObjects::ExtraFileObject}
+#
+# {#parse_objects} extracts msgids from docstring and tags of
+# {CodeObjects::Base} objects. The docstring of
+# {CodeObjects::Base} object is parsed and a paragraph is
+# extracted as a msgid. Tag name and tag text are extracted as
+# msgids from a tag.
+#
+# {#parse_files} extracts msgids from
+# {CodeObjects::ExtraFileObject} objects. The file content of
+# {CodeObjects::ExtraFileObject} object is parsed and a paragraph
+# is extracted as a msgid.
+#
+# == Usage
+#
+# To create a .pot file by +PotGenerator+, instantiate a
+# +PotGenerator+ with a relative working directory path from a
+# directory path that has created .pot file, parse
+# {CodeObjects::Base} objects and {CodeObjects::ExtraFileObject}
+# objects, generate a POT and write the generated POT to a .pot
+# file. The relative working directory path is ".." when the
+# working directory path is "."  and the POT is wrote into
+# "po/yard.pot".
+#
+# @example Generate a .pot file
+#   po_file_path = "po/yard.pot"
+#   po_file_directory_pathname = Pathname.new(po_file_path).directory)
+#   working_directory_pathname = Pathname.new(".")
+#   relative_base_path = working_directory_pathname.relative_path_from(po_file_directory_pathname).to_s
+#   # relative_base_path -> ".."
+#   generator = YARD::I18n::PotGenerator.new(relative_base_path)
+#   generator.parse_objects(objects)
+#   generator.parse_files(files)
+#   pot = generator.generate
+#   po_file_directory_pathname.mkpath
+#   File.open(po_file_path, "w") do |pot_file|
+#   pot_file.print(pot)
+#   end
+# @see http://www.gnu.org/software/gettext/manual/html_node/PO-Files.html GNU gettext manual about details of PO file
+# @since 0.8.0
+#
+# source://yard//lib/yard/i18n/pot_generator.rb#65
+class YARD::I18n::PotGenerator
+  # Creates a POT generator that uses +relative_base_path+ to
+  # generate locations for a msgid. +relative_base_path+ is
+  # prepended to all locations.
+  #
+  # @param relative_base_path [String] a relative working
+  #   directory path from a directory path that has created .pot
+  #   file.
+  # @return [PotGenerator] a new instance of PotGenerator
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#79
+  def initialize(relative_base_path); end
+
+  # Generates POT from +@messages+.
+  #
+  # One PO file entry is generated from a +Message+ in
+  # +@messages+.
+  #
+  # Locations of the +Message+ are used to generate the reference
+  # line that is started with "#: ". +relative_base_path+ passed
+  # when the generator is created is prepended to each path in location.
+  #
+  # Comments of the +Message+ are used to generate the
+  # translator-comment line that is started with "# ".
+  #
+  # @return [String] POT format string
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#122
+  def generate; end
+
+  # Extracted messages.
+  #
+  # @return [Messages]
+  # @since 0.8.1
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#70
+  def messages; end
+
+  # Parses {CodeObjects::ExtraFileObject} objects and stores
+  # extracted msgids into {#messages}.
+  #
+  # @param files [Array<CodeObjects::ExtraFileObject>] a list
+  #   of {CodeObjects::ExtraFileObject} objects to be parsed.
+  # @return [void]
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#103
+  def parse_files(files); end
+
+  # Parses {CodeObjects::Base} objects and stores extracted msgids
+  # into {#messages}
+  #
+  # @param objects [Array<CodeObjects::Base>] a list of
+  #   {CodeObjects::Base} to be parsed.
+  # @return [void]
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#91
+  def parse_objects(objects); end
+
+  private
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#160
+  def current_time; end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#183
+  def escape_message_id(message_id); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#194
+  def extract_documents(object); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#268
+  def extract_paragraphs(file); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#235
+  def extract_tag_documents(tag); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#242
+  def extract_tag_name(tag); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#255
+  def extract_tag_text(tag); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#168
+  def generate_message(pot, message); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#164
+  def generate_pot_creation_date_value; end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#136
+  def header; end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/pot_generator.rb#190
+  def register_message(id); end
+end
+
+# Provides some convenient features for translating a text.
+#
+# @since 0.8.0
+#
+# source://yard//lib/yard/i18n/text.rb#5
+class YARD::I18n::Text
+  # Creates a text object that has translation related features for
+  # the input text.
+  #
+  # @option options
+  # @param input [#each_line] a text to be translated.
+  # @param options [Hash] a customizable set of options
+  # @return [Text] a new instance of Text
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/text.rb#12
+  def initialize(input, options = T.unsafe(nil)); end
+
+  # Extracts translation target messages from +@input+.
+  #
+  # @return [void]
+  # @since 0.8.0
+  # @yield [:attribute, name, value, line_no] the block that
+  #   receives extracted an attribute in header. It may called many
+  #   times.
+  # @yield [:paragraph, text, start_line_no] the block that
+  #   receives extracted a paragraph in body. Paragraph is a text
+  #   block separated by one or more empty lines. Empty line is a
+  #   line that contains only zero or more whitespaces. It may
+  #   called many times.
+  # @yieldparam text [String] the text of extracted paragraph.
+  # @yieldparam start_line_no [Integer] the start line number of
+  #   extracted paragraph.
+  # @yieldparam name [String] the name of extracted attribute.
+  # @yieldparam value [String] the value of extracted attribute.
+  # @yieldparam line_no [Integer] the defined line number of extracted
+  #   attribute.
+  #
+  # source://yard//lib/yard/i18n/text.rb#35
+  def extract_messages; end
+
+  # Translates into +locale+.
+  #
+  # @param locale [Locale] the translation target locale.
+  # @return [String] translated text.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/text.rb#52
+  def translate(locale); end
+
+  private
+
+  # @since 0.8.0
+  # @yield [part]
+  #
+  # source://yard//lib/yard/i18n/text.rb#134
+  def emit_attribute_event(match_data, line_no); end
+
+  # @since 0.8.0
+  # @yield [part]
+  #
+  # source://yard//lib/yard/i18n/text.rb#147
+  def emit_empty_line_event(line, line_no); end
+
+  # @since 0.8.0
+  # @yield [part]
+  #
+  # source://yard//lib/yard/i18n/text.rb#125
+  def emit_markup_event(line, line_no); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/text.rb#156
+  def emit_paragraph_event(paragraph, paragraph_start_line, line_no, &block); end
+
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/i18n/text.rb#76
+  def parse(&block); end
+end
+
+# Handles console logging for info, warnings and errors.
+# Uses the stdlib Logger class in Ruby for all the backend logic.
+#
+# source://yard//lib/yard/logging.rb#8
+class YARD::Logger
+  include ::YARD::Logger::Severity
+
+  # Creates a new logger
+  #
+  # @private
+  # @return [Logger] a new instance of Logger
+  #
+  # source://yard//lib/yard/logging.rb#82
+  def initialize(pipe, *args); end
+
+  # Displays an unformatted line to the logger output stream.
+  #
+  # @param msg [String] the message to display
+  # @return [void]
+  # @since 0.8.2
+  #
+  # source://yard//lib/yard/logging.rb#205
+  def <<(msg = T.unsafe(nil)); end
+
+  # Prints the backtrace +exc+ to the logger as error data.
+  #
+  # @param exc [Array<String>] the backtrace list
+  # @param level_meth [Symbol] the level to log backtrace at
+  # @return [void]
+  #
+  # source://yard//lib/yard/logging.rb#216
+  def backtrace(exc, level_meth = T.unsafe(nil)); end
+
+  # Captures the duration of a block of code for benchmark analysis. Also
+  # calls {#progress} on the message to display it to the user.
+  #
+  # @param msg [String] the message to display
+  # @param nontty_log [Symbol, nil] the level to log as if the output
+  #   stream is not a TTY. Use +nil+ for no alternate logging.
+  # @return [void]
+  # @todo Implement capture storage for reporting of benchmarks
+  # @yield a block of arbitrary code to benchmark
+  #
+  # source://yard//lib/yard/logging.rb#234
+  def capture(msg, nontty_log = T.unsafe(nil)); end
+
+  # Clears the progress indicator in the TTY display.
+  #
+  # @return [void]
+  # @since 0.8.2
+  #
+  # source://yard//lib/yard/logging.rb#186
+  def clear_progress; end
+
+  # Changes the debug level to DEBUG if $DEBUG is set and writes a debugging message.
+  # Logs a message with the debug severity level.
+  #
+  # @param message [String] the message to log
+  # @return [void]
+  # @see #log
+  #
+  # source://yard//lib/yard/logging.rb#103
+  def debug(message); end
+
+  # Sets the logger level for the duration of the block
+  #
+  # @example
+  #   log.enter_level(Logger::ERROR) do
+  #   YARD.parse_string "def x; end"
+  #   end
+  # @param new_level [Fixnum] the logger level for the duration of the block.
+  #   values can be found in Ruby's Logger class.
+  # @yield the block with the logger temporarily set to +new_level+
+  #
+  # source://yard//lib/yard/logging.rb#142
+  def enter_level(new_level = T.unsafe(nil)); end
+
+  # Logs a message with the error severity level.
+  #
+  # @param message [String] the message to log
+  # @return [void]
+  # @see #log
+  #
+  # source://yard//lib/yard/logging.rb#103
+  def error(message); end
+
+  # Logs a message with the fatal severity level.
+  #
+  # @param message [String] the message to log
+  # @return [void]
+  # @see #log
+  #
+  # source://yard//lib/yard/logging.rb#103
+  def fatal(message); end
+
+  # Logs a message with the info severity level.
+  #
+  # @param message [String] the message to log
+  # @return [void]
+  # @see #log
+  #
+  # source://yard//lib/yard/logging.rb#103
+  def info(message); end
+
+  # @return [IO] the IO object being logged to
+  # @since 0.8.2
+  #
+  # source://yard//lib/yard/logging.rb#49
+  def io; end
+
+  # @return [IO] the IO object being logged to
+  # @since 0.8.2
+  #
+  # source://yard//lib/yard/logging.rb#49
+  def io=(_arg0); end
+
+  # @return [DEBUG, INFO, WARN, ERROR, FATAL, UNKNOWN] the logging level
+  #
+  # source://yard//lib/yard/logging.rb#57
+  def level; end
+
+  # @return [DEBUG, INFO, WARN, ERROR, FATAL, UNKNOWN] the logging level
+  #
+  # source://yard//lib/yard/logging.rb#57
+  def level=(_arg0); end
+
+  # Logs a message with a given severity
+  #
+  # @param severity [DEBUG, INFO, WARN, ERROR, FATAL, UNKNOWN] the severity level
+  # @param message [String] the message to log
+  #
+  # source://yard//lib/yard/logging.rb#122
+  def log(severity, message); end
+
+  # Displays an unformatted line to the logger output stream.
+  #
+  # @param msg [String] the message to display
+  # @return [void]
+  # @since 0.8.2
+  #
+  # source://yard//lib/yard/logging.rb#205
+  def print(msg = T.unsafe(nil)); end
+
+  # Displays a progress indicator for a given message. This progress report
+  # is only displayed on TTY displays, otherwise the message is passed to
+  # the +nontty_log+ level.
+  #
+  # @param msg [String] the message to log
+  # @param nontty_log [Symbol, nil] the level to log as if the output
+  #   stream is not a TTY. Use +nil+ for no alternate logging.
+  # @return [void]
+  # @since 0.8.2
+  #
+  # source://yard//lib/yard/logging.rb#161
+  def progress(msg, nontty_log = T.unsafe(nil)); end
+
+  # Displays an unformatted line to the logger output stream, adding
+  # a newline.
+  #
+  # @param msg [String] the message to display
+  # @return [void]
+  # @since 0.8.2
+  #
+  # source://yard//lib/yard/logging.rb#197
+  def puts(msg = T.unsafe(nil)); end
+
+  # @return [Boolean] whether backtraces should be shown (by default
+  #   this is on).
+  #
+  # source://yard//lib/yard/logging.rb#53
+  def show_backtraces; end
+
+  # Sets the attribute show_backtraces
+  #
+  # @param value the value to set the attribute show_backtraces to.
+  #
+  # source://yard//lib/yard/logging.rb#54
+  def show_backtraces=(_arg0); end
+
+  # @return [Boolean] whether progress indicators should be shown when
+  #   logging CLIs (by default this is off).
+  #
+  # source://yard//lib/yard/logging.rb#64
+  def show_progress; end
+
+  # Sets the attribute show_progress
+  #
+  # @param value the value to set the attribute show_progress to.
+  #
+  # source://yard//lib/yard/logging.rb#70
+  def show_progress=(_arg0); end
+
+  # Logs a message with the unknown severity level.
+  #
+  # @param message [String] the message to log
+  # @return [void]
+  # @see #log
+  #
+  # source://yard//lib/yard/logging.rb#103
+  def unknown(message); end
+
+  # Remembers when a warning occurs and writes a warning message.
+  # Logs a message with the warn severity level.
+  #
+  # @param message [String] the message to log
+  # @return [void]
+  # @see #log
+  #
+  # source://yard//lib/yard/logging.rb#103
+  def warn(message); end
+
+  # Warns that the Ruby environment does not support continuations. Applies
+  # to JRuby, Rubinius and MacRuby. This warning will only display once
+  # per Ruby process.
+  #
+  # @deprecated Continuations are no longer needed by YARD 0.8.0+.
+  # @private
+  # @return [void]
+  #
+  # source://yard//lib/yard/logging.rb#250
+  def warn_no_continuations; end
+
+  # @return [Boolean] whether a warn message has been emitted. Used for status tracking.
+  #
+  # source://yard//lib/yard/logging.rb#60
+  def warned; end
+
+  # @return [Boolean] whether a warn message has been emitted. Used for status tracking.
+  #
+  # source://yard//lib/yard/logging.rb#60
+  def warned=(_arg0); end
+
+  private
+
+  # source://yard//lib/yard/logging.rb#255
+  def clear_line; end
+
+  class << self
+    # @private
+    #
+    # source://yard//lib/yard/logging.rb#101
+    def create_log_method(name); end
+
+    # The logger instance
+    #
+    # @return [Logger] the logger instance
+    #
+    # source://yard//lib/yard/logging.rb#76
+    def instance(pipe = T.unsafe(nil)); end
+  end
+end
+
+# The list of characters displayed beside the progress bar to indicate
+# "movement".
+#
+# @since 0.8.2
+#
+# source://yard//lib/yard/logging.rb#45
+YARD::Logger::PROGRESS_INDICATORS = T.let(T.unsafe(nil), Array)
+
+# Log severity levels
+#
+# source://yard//lib/yard/logging.rb#10
+module YARD::Logger::Severity; end
+
+# Debugging log level
+#
+# source://yard//lib/yard/logging.rb#12
+YARD::Logger::Severity::DEBUG = T.let(T.unsafe(nil), Integer)
+
+# Error log level
+#
+# source://yard//lib/yard/logging.rb#21
+YARD::Logger::Severity::ERROR = T.let(T.unsafe(nil), Integer)
+
+# Fatal log level
+#
+# source://yard//lib/yard/logging.rb#24
+YARD::Logger::Severity::FATAL = T.let(T.unsafe(nil), Integer)
+
+# Information log level
+#
+# source://yard//lib/yard/logging.rb#15
+YARD::Logger::Severity::INFO = T.let(T.unsafe(nil), Integer)
+
+# @private
+#
+# source://yard//lib/yard/logging.rb#30
+YARD::Logger::Severity::SEVERITIES = T.let(T.unsafe(nil), Hash)
+
+# Unknown log level
+#
+# source://yard//lib/yard/logging.rb#27
+YARD::Logger::Severity::UNKNOWN = T.let(T.unsafe(nil), Integer)
+
+# Warning log level
+#
+# source://yard//lib/yard/logging.rb#18
+YARD::Logger::Severity::WARN = T.let(T.unsafe(nil), Integer)
+
+# An OpenStruct compatible struct class that allows for basic access of attributes
+# via +struct.attr_name+ and +struct.attr_name = value+.
+#
+# source://yard//lib/yard/open_struct.rb#4
+class YARD::OpenStruct
+  # @return [OpenStruct] a new instance of OpenStruct
+  #
+  # source://yard//lib/yard/open_struct.rb#5
+  def initialize(hash = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/open_struct.rb#25
+  def ==(other); end
+
+  # source://yard//lib/yard/open_struct.rb#41
+  def [](key); end
+
+  # source://yard//lib/yard/open_struct.rb#37
+  def []=(key, value); end
+
+  # source://yard//lib/yard/open_struct.rb#33
+  def dig(*keys); end
+
+  # source://yard//lib/yard/open_struct.rb#45
+  def each_pair(&block); end
+
+  # source://yard//lib/yard/open_struct.rb#29
+  def hash; end
+
+  # source://yard//lib/yard/open_struct.rb#49
+  def marshal_dump; end
+
+  # source://yard//lib/yard/open_struct.rb#53
+  def marshal_load(data); end
+
+  # @private
+  #
+  # source://yard//lib/yard/open_struct.rb#10
+  def method_missing(name, *args); end
+
+  # source://yard//lib/yard/open_struct.rb#21
+  def to_h; end
+
+  private
+
+  # source://yard//lib/yard/open_struct.rb#59
+  def __cache_lookup__(name); end
+end
+
+# Generalized options class for passing around large amounts of options between objects.
+#
+# The options class exists for better visibility and documentability of options being
+# passed through to other objects. Because YARD has parser and template architectures
+# that are heavily reliant on options, it is necessary to make these option keys easily
+# visible and understood by developers. Since the options class is more than just a
+# basic Hash, the subclass can provide aliasing and convenience methods to simplify
+# option property access, and, if needed, support backward-compatibility for deprecated
+# key names.
+#
+# == Hash and OpenStruct-like Access
+#
+# Although the options class allows for Hash-like access (<tt>opts[:key]</tt>), the recommended
+# mechanism for accessing an option key will be via standard method calls on attributes
+#
+# The options class can also act as an open ended key value storage structure (like a
+# Hash or OpenStruct), and allows for setting and getting of unregistered option keys.
+# This methodology is not recommended, however, and is only supported for backward
+# compatibility inside YARD. Whenever possible, developers should define all keys used
+# by an options class.
+#
+# == Declaring Default Values
+#
+# Note that the options class can contain default value definitions for certain options,
+# but to initialize these defaults, {#reset_defaults} must be called manually after
+# initialization; the options object is always created empty until defaults are applied.
+#
+# @abstract Subclasses should define (and document) custom attributes that are expected
+#   to be made available as option keys.
+# @example Defining an Options class with custom option keys
+#   class TemplateOptions < YARD::Options
+#   # @return [Symbol] the output format to generate templates in
+#   attr_accessor :format
+#
+#   # @return [Symbol] the template to use when generating output
+#   attr_accessor :template
+#   end
+# @example Initializing default option values
+#   class TemplateOptions < YARD::Options
+#   def reset_defaults
+#   super
+#   self.format = :html
+#   self.template = :default
+#   self.highlight = true
+#   # ...
+#   end
+#   end
+# @example Using +default_attr+ to create default attributes
+#   class TemplateOptions < YARD::Options
+#   default_attr :format, :html
+#   default_attr :template, :default
+#   default_attr :highlight, true
+#   end
+# @example Deprecating an option while still supporting it
+#   class TemplateOptions < YARD::Options
+#   # @return [Boolean] if syntax highlighting should be performed on code blocks.
+#   #   Defaults to true.
+#   attr_accessor :highlight
+#
+#   # @deprecated Use {#highlight} instead.
+#   # @return [Boolean] if no syntax highlighting should be performs on code blocks.
+#   #   Defaults to false.
+#   attr_accessor :no_highlight
+#   def no_highlight=(value) @highlight = !value end
+#   def no_highlight; !highlight end
+#   end
+#
+# source://yard//lib/yard/options.rb#69
+class YARD::Options
+  # @return [Boolean] whether another Options object equals the
+  #   keys and values of this options object
+  #
+  # source://yard//lib/yard/options.rb#157
+  def ==(other); end
+
+  # Delegates calls with Hash syntax to actual method with key name
+  #
+  # @example Calling on an option key with Hash syntax
+  #   options[:format] # equivalent to: options.format
+  # @param key [Symbol, String] the option name to access
+  # @return the value of the option named +key+
+  #
+  # source://yard//lib/yard/options.rb#91
+  def [](key); end
+
+  # Delegates setter calls with Hash syntax to the attribute setter with the key name
+  #
+  # @example Setting an option with Hash syntax
+  #   options[:format] = :html # equivalent to: options.format = :html
+  # @param key [Symbol, String] the option to set
+  # @param value [Object] the value to set for the option
+  # @return [Object] the value being set
+  #
+  # source://yard//lib/yard/options.rb#100
+  def []=(key, value); end
+
+  # Deletes an option value for +key+
+  #
+  # @param key [Symbol, String] the key to delete a value for
+  # @return [Object] the value that was deleted
+  #
+  # source://yard//lib/yard/options.rb#207
+  def delete(key); end
+
+  # Yields over every option key and value
+  #
+  # @return [void]
+  # @yield [key, value] every option key and value
+  # @yieldparam key [Symbol] the option key
+  # @yieldparam value [Object] the option value
+  #
+  # source://yard//lib/yard/options.rb#143
+  def each; end
+
+  # Inspects the object
+  #
+  # source://yard//lib/yard/options.rb#151
+  def inspect; end
+
+  # Creates a new options object and sets options hash or object value
+  # onto that object.
+  #
+  # @param opts [Options, Hash]
+  # @return [Options] the newly created options object
+  # @see #update
+  #
+  # source://yard//lib/yard/options.rb#123
+  def merge(opts); end
+
+  # Handles setting and accessing of unregistered keys similar
+  # to an OpenStruct object.
+  #
+  # @note It is not recommended to set and access unregistered keys on
+  #   an Options object. Instead, register the attribute before using it.
+  #
+  # source://yard//lib/yard/options.rb#170
+  def method_missing(meth, *args, &block); end
+
+  # Resets all values to their defaults.
+  #
+  # @abstract Subclasses should override this method to perform custom
+  #   value initialization if not using {default_attr}. Be sure to call
+  #   +super+ so that default initialization can take place.
+  # @return [void]
+  #
+  # source://yard//lib/yard/options.rb#188
+  def reset_defaults; end
+
+  # @return [Hash] Converts options object to an options hash. All keys
+  #   will be symbolized.
+  #
+  # source://yard//lib/yard/options.rb#129
+  def to_hash; end
+
+  # Updates values from an options hash or options object on this object.
+  # All keys passed should be key names defined by attributes on the class.
+  #
+  # @example Updating a set of options on an Options object
+  #   opts.update(:template => :guide, :type => :fulldoc)
+  # @param opts [Hash, Options]
+  # @return [self]
+  #
+  # source://yard//lib/yard/options.rb#109
+  def update(opts); end
+
+  class << self
+    # Defines an attribute named +key+ and sets a default value for it
+    #
+    # @example Defining a default option key
+    #   default_attr :name, 'Default Name'
+    #   default_attr :time, lambda { Time.now }
+    # @param key [Symbol] the option key name
+    # @param default [Object, Proc] the default object value. If the default
+    #   value is a proc, it is executed upon initialization.
+    #
+    # source://yard//lib/yard/options.rb#80
+    def default_attr(key, default); end
+  end
+end
+
+# The parser namespace holds all parsing engines used by YARD.
+# Currently only Ruby and C (Ruby) parsers are implemented.
+#
+# source://yard//lib/yard/autoload.rb#161
+module YARD::Parser; end
+
+# Represents the abstract base parser class that parses source code in
+# a specific way. A parser should implement {#parse}, {#tokenize} and
+# {#enumerator}.
+#
+# == Registering a Custom Parser
+# To register a parser, see {SourceParser.register_parser_type}
+#
+# @abstract
+# @see #parse
+# @see #tokenize
+# @see #enumerator
+# @since 0.5.6
+#
+# source://yard//lib/yard/parser/base.rb#16
+class YARD::Parser::Base
+  # This default constructor does nothing. The subclass is responsible for
+  # storing the source contents and filename if they are required.
+  #
+  # @param source [String] the source contents
+  # @param filename [String] the name of the file if from disk
+  # @raise [NotImplementedError]
+  # @return [Base] a new instance of Base
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/base.rb#26
+  def initialize(source, filename); end
+
+  # This method should be implemented to return a list of semantic tokens
+  # representing the source code to be post-processed. Otherwise the method
+  # should return nil.
+  #
+  # @abstract
+  # @return [Array] a list of semantic tokens representing the source code
+  #   to be post-processed
+  # @return [nil] if no post-processing should be done
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/base.rb#52
+  def enumerator; end
+
+  # This method should be implemented to parse the source and return itself.
+  #
+  # @abstract
+  # @raise [NotImplementedError]
+  # @return [Base] this method should return itself
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/base.rb#33
+  def parse; end
+
+  # This method should be implemented to tokenize given source
+  #
+  # @abstract
+  # @raise [NotImplementedError]
+  # @return [Array] a list/tree of lexical tokens
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/base.rb#40
+  def tokenize; end
+
+  class << self
+    # Convenience method to create a new parser and {#parse}
+    #
+    # @since 0.5.6
+    #
+    # source://yard//lib/yard/parser/base.rb#18
+    def parse(source, filename = T.unsafe(nil)); end
+  end
+end
+
+# CRuby Parsing components
+#
+# source://yard//lib/yard/autoload.rb#162
+module YARD::Parser::C; end
+
+# source://yard//lib/yard/parser/c/statement.rb#41
+class YARD::Parser::C::BodyStatement < ::YARD::Parser::C::Statement
+  # Returns the value of attribute comments.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#42
+  def comments; end
+
+  # Sets the attribute comments
+  #
+  # @param value the value to set the attribute comments to.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#42
+  def comments=(_arg0); end
+end
+
+# source://yard//lib/yard/parser/c/c_parser.rb#5
+class YARD::Parser::C::CParser < ::YARD::Parser::Base
+  # @return [CParser] a new instance of CParser
+  #
+  # source://yard//lib/yard/parser/c/c_parser.rb#6
+  def initialize(source, file = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#24
+  def enumerator; end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#19
+  def parse; end
+
+  # @raise [NotImplementedError]
+  #
+  # source://yard//lib/yard/parser/c/c_parser.rb#28
+  def tokenize; end
+
+  private
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#213
+  def advance(num = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#216
+  def advance_loop; end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#195
+  def attach_comment(statement); end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#214
+  def back(num = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#225
+  def char(num = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#96
+  def consume_body_statements; end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#136
+  def consume_comment(add_comment = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#59
+  def consume_directive; end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#47
+  def consume_quote(type = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#73
+  def consume_toplevel_statement; end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#169
+  def consume_until(end_char, bracket_level = T.unsafe(nil), brace_level = T.unsafe(nil), add_comment = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#132
+  def consume_whitespace; end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#227
+  def nextchar(num = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#220
+  def nextline; end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#34
+  def parse_toplevel; end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#226
+  def prevchar(num = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#118
+  def strip_non_statement_data; end
+
+  # source://yard//lib/yard/parser/c/c_parser.rb#229
+  def struct; end
+end
+
+# source://yard//lib/yard/parser/c/statement.rb#51
+class YARD::Parser::C::Comment < ::YARD::Parser::C::Statement
+  include ::YARD::Parser::C::CommentParser
+
+  # @return [Comment] a new instance of Comment
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#58
+  def initialize(source, file = T.unsafe(nil), line = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/c/statement.rb#62
+  def comments; end
+
+  # Returns the value of attribute overrides.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#55
+  def overrides; end
+
+  # Sets the attribute overrides
+  #
+  # @param value the value to set the attribute overrides to.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#55
+  def overrides=(_arg0); end
+
+  # Returns the value of attribute statement.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#56
+  def statement; end
+
+  # Sets the attribute statement
+  #
+  # @param value the value to set the attribute statement to.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#56
+  def statement=(_arg0); end
+
+  # Returns the value of attribute type.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#54
+  def type; end
+
+  # Sets the attribute type
+  #
+  # @param value the value to set the attribute type to.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#54
+  def type=(_arg0); end
+end
+
+# source://yard//lib/yard/parser/c/comment_parser.rb#5
+module YARD::Parser::C::CommentParser
+  protected
+
+  # source://yard//lib/yard/parser/c/comment_parser.rb#8
+  def parse_comments(comments); end
+
+  private
+
+  # source://yard//lib/yard/parser/c/comment_parser.rb#42
+  def parse_callseq(comments); end
+
+  # source://yard//lib/yard/parser/c/comment_parser.rb#30
+  def parse_overrides(comments); end
+
+  # source://yard//lib/yard/parser/c/comment_parser.rb#87
+  def parse_types(types); end
+
+  # source://yard//lib/yard/parser/c/comment_parser.rb#126
+  def remove_private_comments(comment); end
+end
+
+# source://yard//lib/yard/parser/c/statement.rb#5
+class YARD::Parser::C::Statement
+  # @return [Statement] a new instance of Statement
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#16
+  def initialize(source, file = T.unsafe(nil), line = T.unsafe(nil)); end
+
+  # Returns the value of attribute comments_hash_flag.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#14
+  def comments_hash_flag; end
+
+  # Sets the attribute comments_hash_flag
+  #
+  # @param value the value to set the attribute comments_hash_flag to.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#14
+  def comments_hash_flag=(_arg0); end
+
+  # source://yard//lib/yard/parser/c/statement.rb#26
+  def comments_range; end
+
+  # Returns the value of attribute file.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#8
+  def file; end
+
+  # Sets the attribute file
+  #
+  # @param value the value to set the attribute file to.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#8
+  def file=(_arg0); end
+
+  # source://yard//lib/yard/parser/c/statement.rb#30
+  def first_line; end
+
+  # @deprecated Groups are now defined by directives
+  # @see Tags::GroupDirective
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#12
+  def group; end
+
+  # @deprecated Groups are now defined by directives
+  # @see Tags::GroupDirective
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#12
+  def group=(_arg0); end
+
+  # Returns the value of attribute line.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#7
+  def line; end
+
+  # Sets the attribute line
+  #
+  # @param value the value to set the attribute line to.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#7
+  def line=(_arg0); end
+
+  # source://yard//lib/yard/parser/c/statement.rb#22
+  def line_range; end
+
+  # source://yard//lib/yard/parser/c/statement.rb#36
+  def show; end
+
+  # source://yard//lib/yard/parser/c/statement.rb#30
+  def signature; end
+
+  # Returns the value of attribute source.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#6
+  def source; end
+
+  # Sets the attribute source
+  #
+  # @param value the value to set the attribute source to.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#6
+  def source=(_arg0); end
+end
+
+# source://yard//lib/yard/parser/c/statement.rb#45
+class YARD::Parser::C::ToplevelStatement < ::YARD::Parser::C::Statement
+  # Returns the value of attribute block.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#46
+  def block; end
+
+  # Sets the attribute block
+  #
+  # @param value the value to set the attribute block to.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#46
+  def block=(_arg0); end
+
+  # Returns the value of attribute comments.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#48
+  def comments; end
+
+  # Sets the attribute comments
+  #
+  # @param value the value to set the attribute comments to.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#48
+  def comments=(_arg0); end
+
+  # Returns the value of attribute declaration.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#47
+  def declaration; end
+
+  # Sets the attribute declaration
+  #
+  # @param value the value to set the attribute declaration to.
+  #
+  # source://yard//lib/yard/parser/c/statement.rb#47
+  def declaration=(_arg0); end
+end
+
+# Responsible for parsing a list of files in order. The
+# {#parse} method of this class can be called from the
+# {SourceParser#globals} globals state list to re-enter
+# parsing for the remainder of files in the list recursively.
+#
+# @see Processor#parse_remaining_files
+#
+# source://yard//lib/yard/parser/source_parser.rb#20
+class YARD::Parser::OrderedParser
+  # Creates a new OrderedParser with the global state and a list
+  # of files to parse.
+  #
+  # @note OrderedParser sets itself as the +ordered_parser+ key on
+  #   global_state for later use in {Handlers::Processor}.
+  # @param global_state [OpenStruct] a structure containing all global
+  #   state during parsing
+  # @param files [Array<String>] the list of files to parse
+  # @return [OrderedParser] a new instance of OrderedParser
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#32
+  def initialize(global_state, files); end
+
+  # @return [Array<String>] the list of remaining files to parse
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#22
+  def files; end
+
+  # @return [Array<String>] the list of remaining files to parse
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#22
+  def files=(_arg0); end
+
+  # Parses the remainder of the {#files} list.
+  #
+  # @see Processor#parse_remaining_files
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#41
+  def parse; end
+end
+
+# Raised when the parser sees a Ruby syntax error
+#
+# source://yard//lib/yard/parser/source_parser.rb#12
+class YARD::Parser::ParserSyntaxError < ::YARD::Parser::UndocumentableError; end
+
+# Ruby parsing components.
+#
+# source://yard//lib/yard/autoload.rb#171
+module YARD::Parser::Ruby
+  # Builds and s-expression by creating {AstNode} objects with
+  # the type provided by the first argument.
+  #
+  # @example An implicit list of keywords
+  #   ast = s(s(:kw, "if"), s(:kw, "else"))
+  #   ast.type # => :list
+  # @example A method call
+  #   s(:command, s(:var_ref, "mymethod"))
+  # @overload s
+  # @overload s
+  # @see AstNode#initialize
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#25
+  def s(*args); end
+end
+
+# An AST node is characterized by a type and a list of children. It
+# is most easily represented by the s-expression {#s} such as:
+#   # AST for "if true; 5 end":
+#   s(s(:if, s(:var_ref, s(:kw, "true")), s(s(:int, "5")), nil))
+#
+# The node type is not considered part of the list, only its children.
+# So +ast[0]+ does not refer to the type, but rather the first child
+# (or object). Items that are not +AstNode+ objects can be part of the
+# list, like Strings or Symbols representing names. To return only
+# the AstNode children of the node, use {#children}.
+#
+# source://yard//lib/yard/parser/ruby/ast_node.rb#41
+class YARD::Parser::Ruby::AstNode < ::Array
+  # Creates a new AST node
+  #
+  # @option opts
+  # @option opts
+  # @option opts
+  # @option opts
+  # @option opts
+  # @param type [Symbol] the type of node being created
+  # @param arr [Array<AstNode>] the child nodes
+  # @param opts [Hash] any extra line options
+  # @return [AstNode] a new instance of AstNode
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#153
+  def initialize(type, arr, opts = T.unsafe(nil)); end
+
+  # @private
+  # @return [Boolean] whether the node is equal to another by checking
+  #   the list and type
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#167
+  def ==(other); end
+
+  # @return [Boolean] whether the node has a block
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#261
+  def block?; end
+
+  # @return [Boolean] whether the node is a method call
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#241
+  def call?; end
+
+  # @return [Array<AstNode>] the {AstNode} children inside the node
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#199
+  def children; end
+
+  # Returns the value of attribute docstring.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#43
+  def comments; end
+
+  # Returns the value of attribute docstring_hash_flag.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#42
+  def comments_hash_flag; end
+
+  # Returns the value of attribute docstring_range.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#43
+  def comments_range; end
+
+  # @return [Boolean] whether the node is a if/elsif/else condition
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#251
+  def condition?; end
+
+  # @return [Boolean] whether the node is a method definition
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#246
+  def def?; end
+
+  # Returns the value of attribute docstring.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#43
+  def docstring; end
+
+  # Sets the attribute docstring
+  #
+  # @param value the value to set the attribute docstring to.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#43
+  def docstring=(_arg0); end
+
+  # Returns the value of attribute docstring_hash_flag.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#42
+  def docstring_hash_flag; end
+
+  # Sets the attribute docstring_hash_flag
+  #
+  # @param value the value to set the attribute docstring_hash_flag to.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#42
+  def docstring_hash_flag=(_arg0); end
+
+  # Returns the value of attribute docstring_range.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#43
+  def docstring_range; end
+
+  # Sets the attribute docstring_range
+  #
+  # @param value the value to set the attribute docstring_range to.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#43
+  def docstring_range=(_arg0); end
+
+  # @return [String] the filename the node was parsed from
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#76
+  def file; end
+
+  # Sets the attribute file
+  #
+  # @param value the value to set the attribute file to.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#49
+  def file=(_arg0); end
+
+  # @return [String] the first line of source represented by the node.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#278
+  def first_line; end
+
+  # @return [String] the full source that the node was parsed from
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#82
+  def full_source; end
+
+  # Sets the attribute full_source
+  #
+  # @param value the value to set the attribute full_source to.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#49
+  def full_source=(_arg0); end
+
+  # @deprecated Groups are now defined by directives
+  # @see Tags::GroupDirective
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#47
+  def group; end
+
+  # @deprecated Groups are now defined by directives
+  # @see Tags::GroupDirective
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#47
+  def group=(_arg0); end
+
+  # @return [Boolean] whether the node has a {#line_range} set
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#268
+  def has_line?; end
+
+  # @return [String] inspects the object
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#323
+  def inspect; end
+
+  # Searches through the node and all descendants and returns the
+  # first node with a type matching any of +node_types+, otherwise
+  # returns the original node (self).
+  #
+  # @example Returns the first method definition in a block of code
+  #   ast = YARD.parse_string("if true; def x; end end").ast
+  #   ast.jump(:def)
+  #   # => s(:def, s(:ident, "x"), s(:params, nil, nil, nil, nil,
+  #   #      nil), s(s(:void_stmt, )))
+  # @example Returns first 'def' or 'class' statement
+  #   ast = YARD.parse_string("class X; def y; end end")
+  #   ast.jump(:def, :class).first
+  #   # =>
+  # @example If the node types are not present in the AST
+  #   ast = YARD.parse("def x; end")
+  #   ast.jump(:def)
+  # @param node_types [Array<Symbol>] a set of node types to match
+  # @return [AstNode] the matching node, if one was found
+  # @return [self] if no node was found
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#193
+  def jump(*node_types); end
+
+  # @return [Boolean] whether the node is a keyword
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#236
+  def kw?; end
+
+  # @return [Fixnum] the starting line number of the node
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#273
+  def line; end
+
+  # @return [Range] the line range in {#full_source} represented
+  #   by the node
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#70
+  def line_range; end
+
+  # Sets the attribute line_range
+  #
+  # @param value the value to set the attribute line_range to.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#49
+  def line_range=(_arg0); end
+
+  # @return [Boolean] whether the node is a literal value
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#231
+  def literal?; end
+
+  # @return [Boolean] whether the node is a loop
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#256
+  def loop?; end
+
+  # @return [AstNode, nil] the node's parent or nil if it is a root node.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#59
+  def parent; end
+
+  # @return [AstNode, nil] the node's parent or nil if it is a root node.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#59
+  def parent=(_arg0); end
+
+  # @return [nil] pretty prints the node
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#290
+  def pretty_print(q); end
+
+  # @return [Boolean] whether the node is a reference (variable,
+  #   constant name)
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#226
+  def ref?; end
+
+  # @return [String] the first line of source the node represents
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#285
+  def show; end
+
+  # @return [String] the parse of {#full_source} that the node represents
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#89
+  def source; end
+
+  # Sets the attribute source
+  #
+  # @param value the value to set the attribute source to.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#43
+  def source=(_arg0); end
+
+  # @return [Range] the character range in {#full_source} represented
+  #   by the node
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#63
+  def source_range; end
+
+  # Sets the attribute source_range
+  #
+  # @param value the value to set the attribute source_range to.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#49
+  def source_range=(_arg0); end
+
+  # Returns the value of attribute source.
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#43
+  def to_s; end
+
+  # @return [Boolean] whether the node is a token
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#220
+  def token?; end
+
+  # Traverses the object and yields each node (including descendants) in order.
+  #
+  # @return [void]
+  # @yield each descendant node in order
+  # @yieldparam self, [AstNode] or a child/descendant node
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#208
+  def traverse; end
+
+  # @return [Symbol] the node's unique symbolic type
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#56
+  def type; end
+
+  # @return [Symbol] the node's unique symbolic type
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#56
+  def type=(_arg0); end
+
+  # Resets node state in tree
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#331
+  def unfreeze; end
+
+  private
+
+  # Resets line information
+  #
+  # @return [void]
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#341
+  def reset_line_info; end
+
+  class << self
+    # Finds the node subclass that should be instantiated for a specific
+    # node type
+    #
+    # @param type [Symbol] the node type to find a subclass for
+    # @return [Class] a subclass of AstNode to instantiate the node with.
+    #
+    # source://yard//lib/yard/parser/ruby/ast_node.rb#111
+    def node_class_for(type); end
+  end
+end
+
+# List of all known keywords
+#
+# @return [Hash]
+#
+# source://yard//lib/yard/parser/ruby/ast_node.rb#96
+YARD::Parser::Ruby::AstNode::KEYWORDS = T.let(T.unsafe(nil), Hash)
+
+# source://yard//lib/yard/parser/ruby/ast_node.rb#530
+class YARD::Parser::Ruby::ClassNode < ::YARD::Parser::Ruby::KeywordNode
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#533
+  def block; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#531
+  def class_name; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#532
+  def superclass; end
+end
+
+# Represents a lone comment block in source
+#
+# source://yard//lib/yard/parser/ruby/ast_node.rb#548
+class YARD::Parser::Ruby::CommentNode < ::YARD::Parser::Ruby::AstNode
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#549
+  def comments; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#549
+  def docstring; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#550
+  def docstring=(value); end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#554
+  def first_line; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#553
+  def source; end
+end
+
+# source://yard//lib/yard/parser/ruby/ast_node.rb#515
+class YARD::Parser::Ruby::ConditionalNode < ::YARD::Parser::Ruby::KeywordNode
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#517
+  def condition; end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#516
+  def condition?; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#520
+  def else_block; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#518
+  def then_block; end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#527
+  def cmod?; end
+end
+
+# source://yard//lib/yard/parser/ruby/ast_node.rb#376
+class YARD::Parser::Ruby::KeywordNode < ::YARD::Parser::Ruby::AstNode
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#377
+  def kw?; end
+end
+
+# Handles Ruby parsing in Ruby 1.8.
+#
+# source://yard//lib/yard/autoload.rb#172
+module YARD::Parser::Ruby::Legacy; end
+
+# Lexical analyzer for Ruby source
+#
+# @private
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#314
+class YARD::Parser::Ruby::Legacy::RubyLex
+  include ::YARD::Parser::Ruby::Legacy::RubyToken
+  include ::IRB
+
+  # @return [RubyLex] a new instance of RubyLex
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#437
+  def initialize(content); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#472
+  def char_no; end
+
+  # Returns the value of attribute continue.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#430
+  def continue; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#1116
+  def dedent(str); end
+
+  # Returns the value of attribute exception_on_syntax_error.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#463
+  def exception_on_syntax_error; end
+
+  # Sets the attribute exception_on_syntax_error
+  #
+  # @param value the value to set the attribute exception_on_syntax_error to.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#463
+  def exception_on_syntax_error=(_arg0); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#476
+  def get_read; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#480
+  def getc; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#484
+  def getc_of_rests; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#488
+  def gets; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#1272
+  def identify_comment; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#945
+  def identify_gvar; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#1062
+  def identify_here_document; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#980
+  def identify_identifier; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#1145
+  def identify_number(start); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#1126
+  def identify_quotation(initial_char); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#1207
+  def identify_string(ltype, quoted = T.unsafe(nil), opener = T.unsafe(nil), initial_char = T.unsafe(nil)); end
+
+  # Returns the value of attribute indent.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#465
+  def indent; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#510
+  def lex; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#586
+  def lex_init; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#759
+  def lex_int2; end
+
+  # Returns the value of attribute lex_state.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#431
+  def lex_state; end
+
+  # io functions
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#468
+  def line_no; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#506
+  def peek(i = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#502
+  def peek_equal?(str); end
+
+  # Returns the value of attribute read_auto_clean_up.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#462
+  def read_auto_clean_up; end
+
+  # Sets the attribute read_auto_clean_up
+  #
+  # @param value the value to set the attribute read_auto_clean_up to.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#462
+  def read_auto_clean_up=(_arg0); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#1295
+  def read_escape; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#1257
+  def skip_inner_expression; end
+
+  # Returns the value of attribute skip_space.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#461
+  def skip_space; end
+
+  # Sets the attribute skip_space
+  #
+  # @param value the value to set the attribute skip_space to.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#461
+  def skip_space=(_arg0); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#526
+  def token; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#498
+  def ungetc(c = T.unsafe(nil)); end
+
+  class << self
+    # @return [Boolean]
+    #
+    # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#433
+    def debug?; end
+  end
+end
+
+# , "when"
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#552
+YARD::Parser::Ruby::Legacy::RubyLex::ACCEPTS_COLON = T.let(T.unsafe(nil), Array)
+
+# Read an input stream character by character. We allow for unlimited
+# ungetting of characters just read.
+#
+# We simplify the implementation greatly by reading the entire input
+# into a buffer initially, and then simply traversing it using
+# pointers.
+#
+# We also have to allow for the <i>here document diversion</i>. This
+# little gem comes about when the lexer encounters a here
+# document. At this point we effectively need to split the input
+# stream into two parts: one to read the body of the here document,
+# the other to read the rest of the input line where the here
+# document was initially encountered. For example, we might have
+#
+#   do_something(<<-A, <<-B)
+#     stuff
+#     for
+#   A
+#     stuff
+#     for
+#   B
+#
+# When the lexer encounters the <<A, it reads until the end of the
+# line, and keeps it around for later. It then reads the body of the
+# here document.  Once complete, it needs to read the rest of the
+# original line, but then skip the here document body.
+#
+# @private
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#343
+class YARD::Parser::Ruby::Legacy::RubyLex::BufferedReader
+  # @return [BufferedReader] a new instance of BufferedReader
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#346
+  def initialize(content); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#365
+  def column; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#419
+  def divert_read_from(reserve); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#400
+  def get_read; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#369
+  def getc; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#388
+  def getc_already_read; end
+
+  # Returns the value of attribute line_num.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#344
+  def line_num; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#406
+  def peek(at); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#415
+  def peek_equal(str); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#392
+  def ungetc(_ch); end
+end
+
+# , "when"
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#553
+YARD::Parser::Ruby::Legacy::RubyLex::DEINDENT_CLAUSE = T.let(T.unsafe(nil), Array)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#580
+YARD::Parser::Ruby::Legacy::RubyLex::DLtype2Token = T.let(T.unsafe(nil), Hash)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#548
+YARD::Parser::Ruby::Legacy::RubyLex::ENINDENT_CLAUSE = T.let(T.unsafe(nil), Array)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#571
+YARD::Parser::Ruby::Legacy::RubyLex::Ltype2Token = T.let(T.unsafe(nil), Hash)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#555
+YARD::Parser::Ruby::Legacy::RubyLex::PERCENT_LTYPE = T.let(T.unsafe(nil), Hash)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#564
+YARD::Parser::Ruby::Legacy::RubyLex::PERCENT_PAREN = T.let(T.unsafe(nil), Hash)
+
+# Legacy Ruby parser
+#
+# @since 0.5.6
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_parser.rb#8
+class YARD::Parser::Ruby::Legacy::RubyParser < ::YARD::Parser::Base
+  # @return [RubyParser] a new instance of RubyParser
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_parser.rb#9
+  def initialize(source, _filename); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_parser.rb#26
+  def encoding_line; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_parser.rb#22
+  def enumerator; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_parser.rb#13
+  def parse; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_parser.rb#27
+  def shebang_line; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_parser.rb#18
+  def tokenize; end
+end
+
+# Legacy lexical tokenizer module.
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#6
+module YARD::Parser::Ruby::Legacy::RubyToken
+  # @private
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#125
+  def Token(token, value = T.unsafe(nil)); end
+
+  # @private
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#119
+  def set_token_position(line, char); end
+
+  class << self
+    # @private
+    #
+    # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#275
+    def def_token(token_n, super_token = T.unsafe(nil), reading = T.unsafe(nil), *opts); end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#10
+YARD::Parser::Ruby::Legacy::RubyToken::EXPR_ARG = T.let(T.unsafe(nil), Symbol)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#7
+YARD::Parser::Ruby::Legacy::RubyToken::EXPR_BEG = T.let(T.unsafe(nil), Symbol)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#13
+YARD::Parser::Ruby::Legacy::RubyToken::EXPR_CLASS = T.let(T.unsafe(nil), Symbol)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#12
+YARD::Parser::Ruby::Legacy::RubyToken::EXPR_DOT = T.let(T.unsafe(nil), Symbol)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#9
+YARD::Parser::Ruby::Legacy::RubyToken::EXPR_END = T.let(T.unsafe(nil), Symbol)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#11
+YARD::Parser::Ruby::Legacy::RubyToken::EXPR_FNAME = T.let(T.unsafe(nil), Symbol)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#8
+YARD::Parser::Ruby::Legacy::RubyToken::EXPR_MID = T.let(T.unsafe(nil), Symbol)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#308
+YARD::Parser::Ruby::Legacy::RubyToken::NEWLINE_TOKEN = T.let(T.unsafe(nil), YARD::Parser::Ruby::Legacy::RubyToken::TkNL)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::OPASGN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkALIAS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkAMPER < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkAND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkANDOP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkAREF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkASET < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkASSIGN < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkASSOC < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkAT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBACKQUOTE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBACKSLASH < ::YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBACK_REF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBEGIN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBITAND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBITNOT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBITOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBITXOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBREAK < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# Represents a block
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#54
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBlockContents < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#55
+  def text; end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCASE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCLASS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCMP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCOLON < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCOLON2 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCOLON3 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCOMMA < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCOMMENT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCONSTANT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDEF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDEFINED < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDIV < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDO < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDOLLAR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDOT < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDOT2 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDOT3 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDREGEXP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkNode; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkNode; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDXSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkNode; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkELSE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkELSIF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkEND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkEND_OF_SCRIPT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkENSURE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkEQQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#115
+class YARD::Parser::Ruby::Legacy::RubyToken::TkError < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkFALSE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkFID < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkFLOAT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkFOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkGEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkGT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkGVAR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkIDENTIFIER < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkIF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkIF_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkIN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkINTEGER < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkIVAR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+
+# Represents a Ruby identifier
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#72
+class YARD::Parser::Ruby::Legacy::RubyToken::TkId < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
+  # @return [TkId] a new instance of TkId
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#73
+  def initialize(line_no, char_no, name); end
+
+  # Returns the value of attribute name.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#77
+  def name; end
+end
+
+# Represents a Ruby keyword
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#81
+class YARD::Parser::Ruby::Legacy::RubyToken::TkKW < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkLABEL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkLBRACE < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkLBRACK < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkLEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkLPAREN < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkLSHFT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkLT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkMATCH < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkMINUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkMOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkMODULE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkMULT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNEXT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNIL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNMATCH < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNOT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNOTOP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNTH_REF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#63
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNode < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
+  # Returns the value of attribute node.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#64
+  def node; end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#98
+class YARD::Parser::Ruby::Legacy::RubyToken::TkOPASGN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  # @return [TkOPASGN] a new instance of TkOPASGN
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#99
+  def initialize(line_no, char_no, op); end
+
+  # Returns the value of attribute op.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#104
+  def op; end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkOROP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#92
+class YARD::Parser::Ruby::Legacy::RubyToken::TkOp < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#93
+  def name; end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkPLUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkPOW < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkQUESTION < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkRBRACE < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkRBRACK < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkREDO < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkREGEXP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkRESCUE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkRETRY < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkRETURN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkRPAREN < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkRSHFT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# { reading => token_class }
+# { reading => [token_class, *opt] }
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#271
+YARD::Parser::Ruby::Legacy::RubyToken::TkReading2Token = T.let(T.unsafe(nil), Hash)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSELF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSEMICOLON < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSPACE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSTAR < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSUPER < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSYMBEG < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSYMBOL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+
+# Represents an end statement
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#59
+class YARD::Parser::Ruby::Legacy::RubyToken::TkStatementEnd < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#60
+  def text; end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#272
+YARD::Parser::Ruby::Legacy::RubyToken::TkSymbol2Token = T.let(T.unsafe(nil), Hash)
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkTHEN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkTRUE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUMINUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUNDEF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUNLESS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUNLESS_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUNTIL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUNTIL_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUPLUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#107
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
+  # @return [TkUnknownChar] a new instance of TkUnknownChar
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#108
+  def initialize(line_no, char_no, _id); end
+
+  # Returns the value of attribute name.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#112
+  def name; end
+end
+
+# Represents a Ruby value
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#85
+class YARD::Parser::Ruby::Legacy::RubyToken::TkVal < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
+  # @return [TkVal] a new instance of TkVal
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#86
+  def initialize(line_no, char_no, value = T.unsafe(nil)); end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkWHEN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkWHILE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkWHILE_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# Represents whitespace
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#68
+class YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkXSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TkYIELD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::Tk__FILE__ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::Tk__LINE__ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TklBEGIN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#281
+class YARD::Parser::Ruby::Legacy::RubyToken::TklEND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+# Represents a token in the Ruby lexer
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#16
+class YARD::Parser::Ruby::Legacy::RubyToken::Token
+  # Creates a new Token object
+  #
+  # @param line_no [Integer] the line number to initialize the token to
+  # @param char_no [Integer] the char number to initialize the token to
+  # @return [Token] a new instance of Token
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#37
+  def initialize(line_no, char_no); end
+
+  # @return [Integer] the character number in the file/stream the token
+  #   is located.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#23
+  def char_no; end
+
+  # @return [Symbol] the lexical state at the token
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#29
+  def lex_state; end
+
+  # @return [Symbol] the lexical state at the token
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#29
+  def lex_state=(_arg0); end
+
+  # @return [Integer] the line number in the file/stream the token is
+  #   located.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#19
+  def line_no; end
+
+  # Chainable way to sets the text attribute
+  #
+  # @param text [String] the new text
+  # @return [Token] this token object
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#47
+  def set_text(text); end
+
+  # @return [String] the token text value
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#26
+  def text; end
+end
+
+# @private
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#32
+YARD::Parser::Ruby::Legacy::RubyToken::Token::NO_TEXT = T.let(T.unsafe(nil), String)
+
+# @private
+#
+# source://yard//lib/yard/parser/ruby/legacy/ruby_lex.rb#147
+YARD::Parser::Ruby::Legacy::RubyToken::TokenDefinitions = T.let(T.unsafe(nil), Array)
+
+# source://yard//lib/yard/parser/ruby/legacy/statement.rb#4
+class YARD::Parser::Ruby::Legacy::Statement
+  # @return [Statement] a new instance of Statement
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#14
+  def initialize(tokens, block = T.unsafe(nil), comments = T.unsafe(nil)); end
+
+  # Returns the value of attribute block.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#5
+  def block; end
+
+  # Returns the value of attribute comments.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#5
+  def comments; end
+
+  # Returns the value of attribute comments_hash_flag.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#12
+  def comments_hash_flag; end
+
+  # Sets the attribute comments_hash_flag
+  #
+  # @param value the value to set the attribute comments_hash_flag to.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#12
+  def comments_hash_flag=(_arg0); end
+
+  # Returns the value of attribute comments_range.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#6
+  def comments_range; end
+
+  # Sets the attribute comments_range
+  #
+  # @param value the value to set the attribute comments_range to.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#6
+  def comments_range=(_arg0); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#21
+  def first_line; end
+
+  # @deprecated Groups are now defined by directives
+  # @see Tags::GroupDirective
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#10
+  def group; end
+
+  # @deprecated Groups are now defined by directives
+  # @see Tags::GroupDirective
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#10
+  def group=(_arg0); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#34
+  def inspect; end
+
+  # @return [Fixnum] the first line of Ruby source
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#46
+  def line; end
+
+  # @return [Range<Fixnum>] the first to last lines of Ruby source
+  # @since 0.5.4
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#52
+  def line_range; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#41
+  def show; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#21
+  def signature; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#27
+  def source(include_block = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#27
+  def to_s(include_block = T.unsafe(nil)); end
+
+  # Returns the value of attribute tokens.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#5
+  def tokens; end
+
+  private
+
+  # source://yard//lib/yard/parser/ruby/legacy/statement.rb#58
+  def clean_tokens(tokens); end
+end
+
+# source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#4
+class YARD::Parser::Ruby::Legacy::StatementList < ::Array
+  include ::YARD::Parser::Ruby::Legacy::RubyToken
+
+  # Creates a new statement list
+  #
+  # @param content [TokenList, String] the tokens to create the list from
+  # @return [StatementList] a new instance of StatementList
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#17
+  def initialize(content); end
+
+  # Returns the value of attribute encoding_line.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#7
+  def encoding_line; end
+
+  # Sets the attribute encoding_line
+  #
+  # @param value the value to set the attribute encoding_line to.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#7
+  def encoding_line=(_arg0); end
+
+  # Returns the value of attribute shebang_line.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#7
+  def shebang_line; end
+
+  # Sets the attribute shebang_line
+  #
+  # @param value the value to set the attribute shebang_line to.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#7
+  def shebang_line=(_arg0); end
+
+  private
+
+  # Handles the balancing of parentheses and blocks
+  #
+  # @param tk [RubyToken::Token] the token to process
+  # @return [Boolean] whether or not the current statement's parentheses and blocks
+  #   are balanced after +tk+
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#362
+  def balances?(tk); end
+
+  # Returns the next statement in the token stream
+  #
+  # @return [Statement] the next statement
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#45
+  def next_statement; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#34
+  def parse_statements; end
+
+  # Returns the next token in the stream that's not a space
+  #
+  # @return [RubyToken::Token] the next non-space token
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#388
+  def peek_no_space; end
+
+  # Processes a token in a block
+  #
+  # @param tk [RubyToken::Token] the token to process
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#194
+  def process_block_token(tk); end
+
+  # Processes a complex block-opening token;
+  # that is, a block opener such as +while+ or +for+
+  # that is followed by an expression
+  #
+  # @param tk [RubyToken::Token] the token to process
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#293
+  def process_complex_block_opener(tk); end
+
+  # Processes a comment token that comes before a statement
+  #
+  # @param tk [RubyToken::Token] the token to process
+  # @return [Boolean] whether or not +tk+ was processed as an initial comment
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#213
+  def process_initial_comment(tk); end
+
+  # Processes a simple block-opening token;
+  # that is, a block opener such as +begin+ or +do+
+  # that isn't followed by an expression
+  #
+  # @param tk [RubyToken::Token] the token to process
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#268
+  def process_simple_block_opener(tk); end
+
+  # Processes a token that closes a statement
+  #
+  # @param tk [RubyToken::Token] the token to process
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#305
+  def process_statement_end(tk); end
+
+  # Processes a single token
+  #
+  # @param tk [RubyToken::Token] the token to process
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#130
+  def process_token(tk); end
+
+  # Adds a token to the current statement,
+  # unless it's a newline, semicolon, or comment
+  #
+  # @param tk [RubyToken::Token] the token to process
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#380
+  def push_token(tk); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#111
+  def sanitize_block; end
+
+  # source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#96
+  def sanitize_statement_end; end
+end
+
+# The following list of tokens will require a block to be opened
+# if used at the beginning of a statement.
+#
+# source://yard//lib/yard/parser/ruby/legacy/statement_list.rb#11
+YARD::Parser::Ruby::Legacy::StatementList::OPEN_BLOCK_TOKENS = T.let(T.unsafe(nil), Array)
+
+# source://yard//lib/yard/parser/ruby/legacy/token_list.rb#4
+class YARD::Parser::Ruby::Legacy::TokenList < ::Array
+  include ::YARD::Parser::Ruby::Legacy::RubyToken
+
+  # @return [TokenList] a new instance of TokenList
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/token_list.rb#7
+  def initialize(content = T.unsafe(nil)); end
+
+  # @param tokens [TokenList, Token, String] A list of tokens. If the token is a string, it
+  #   is parsed with {RubyLex}.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/token_list.rb#21
+  def <<(*tokens); end
+
+  # @param tokens [TokenList, Token, String] A list of tokens. If the token is a string, it
+  #   is parsed with {RubyLex}.
+  #
+  # source://yard//lib/yard/parser/ruby/legacy/token_list.rb#21
+  def push(*tokens); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/token_list.rb#37
+  def squeeze(type = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/token_list.rb#11
+  def to_s(full_statement = T.unsafe(nil), show_block = T.unsafe(nil)); end
+
+  private
+
+  # source://yard//lib/yard/parser/ruby/legacy/token_list.rb#53
+  def convert_token(lex, tk); end
+
+  # source://yard//lib/yard/parser/ruby/legacy/token_list.rb#44
+  def parse_content(content); end
+end
+
+# source://yard//lib/yard/parser/ruby/ast_node.rb#372
+class YARD::Parser::Ruby::LiteralNode < ::YARD::Parser::Ruby::AstNode
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#373
+  def literal?; end
+end
+
+# source://yard//lib/yard/parser/ruby/ast_node.rb#541
+class YARD::Parser::Ruby::LoopNode < ::YARD::Parser::Ruby::KeywordNode
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#544
+  def block; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#543
+  def condition; end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#542
+  def loop?; end
+end
+
+# source://yard//lib/yard/parser/ruby/ast_node.rb#438
+class YARD::Parser::Ruby::MethodCallNode < ::YARD::Parser::Ruby::AstNode
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#464
+  def block; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#462
+  def block_param; end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#439
+  def call?; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#442
+  def method_name(name_only = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#440
+  def namespace; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#453
+  def parameters(include_block_param = T.unsafe(nil)); end
+
+  private
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#474
+  def call_has_paren?; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#470
+  def index_adjust; end
+end
+
+# source://yard//lib/yard/parser/ruby/ast_node.rb#479
+class YARD::Parser::Ruby::MethodDefinitionNode < ::YARD::Parser::Ruby::AstNode
+  def block(n = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#481
+  def def?; end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#480
+  def kw?; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#484
+  def method_name(name_only = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#482
+  def namespace; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#489
+  def parameters(include_block_param = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#495
+  def signature; end
+
+  private
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#510
+  def index_adjust; end
+end
+
+# source://yard//lib/yard/parser/ruby/ast_node.rb#536
+class YARD::Parser::Ruby::ModuleNode < ::YARD::Parser::Ruby::KeywordNode
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#538
+  def block; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#537
+  def module_name; end
+end
+
+# source://yard//lib/yard/parser/ruby/ast_node.rb#380
+class YARD::Parser::Ruby::ParameterNode < ::YARD::Parser::Ruby::AstNode
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#430
+  def args_forward; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#426
+  def block_param; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#414
+  def double_splat_param; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#396
+  def named_params; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#406
+  def splat_param; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#410
+  def unnamed_end_params; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#385
+  def unnamed_optional_params; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#381
+  def unnamed_required_params; end
+end
+
+# source://yard//lib/yard/parser/ruby/ast_node.rb#360
+class YARD::Parser::Ruby::ReferenceNode < ::YARD::Parser::Ruby::AstNode
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#367
+  def namespace; end
+
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#363
+  def path; end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/parser/ruby/ast_node.rb#361
+  def ref?; end
+end
+
+# Internal parser class
+#
+# @since 0.5.6
+#
+# source://yard//lib/yard/parser/ruby/ruby_parser.rb#27
+class YARD::Parser::Ruby::RipperParser < ::Ripper
+  # @return [RipperParser] a new instance of RipperParser
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#32
+  def initialize(source, filename, *args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#28
+  def ast; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#28
+  def charno; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#28
+  def comments; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#29
+  def encoding_line; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#64
+  def enumerator; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#28
+  def file; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#68
+  def file_encoding; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#29
+  def frozen_string_line; end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_BEGIN(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_CHAR(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_END(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on___end__(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_alias(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_alias_error(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_arg_ambiguous(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_arg_paren(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_args_add(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_args_add_block(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_args_add_star(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_args_forward(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#155
+  def on_args_new(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_aryptn(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_assign(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_assign_error(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_assoc_splat(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_backref(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199
+  def on_backtick(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_begin(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_binary(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_block_var(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_blockarg(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_brace_block(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_break(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_call(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_case(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_class(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_class_name_error(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_comma(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_command(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_command_call(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_const(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_const_path_field(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_const_ref(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_cvar(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_def(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_defined(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_defs(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_do_block(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_dot2(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_dot3(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_else(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_elsif(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199
+  def on_embexpr_beg(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_embexpr_end(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_embvar(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_ensure(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_excessed_comma(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_fcall(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_field(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_float(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_fndptn(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_for(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_gvar(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199
+  def on_heredoc_beg(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_heredoc_dedent(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_heredoc_end(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_hshptn(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_ident(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_if(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#449
+  def on_if_mod(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_ifop(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#222
+  def on_ignored_nl(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_ignored_sp(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_imaginary(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_in(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_int(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_ivar(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#209
+  def on_kw(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_kwrest_param(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_label_end(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199
+  def on_lbrace(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199
+  def on_lparen(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_magic_comment(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_massign(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_method_add_arg(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_method_add_block(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_mlhs_add(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_mlhs_add_post(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_mlhs_add_star(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#155
+  def on_mlhs_new(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_mlhs_paren(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_module(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_mrhs_add(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_mrhs_add_star(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#155
+  def on_mrhs_new(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_mrhs_new_from_args(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_next(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#222
+  def on_nl(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_nokw_param(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#209
+  def on_op(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_opassign(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_operator_ambiguous(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_param_error(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_paren(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_period(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#474
+  def on_qsymbols_add(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199
+  def on_qsymbols_beg(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#462
+  def on_qsymbols_new(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#474
+  def on_qwords_add(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199
+  def on_qwords_beg(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#462
+  def on_qwords_new(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_rational(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_rbrace(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_redo(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_regexp_add(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199
+  def on_regexp_beg(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_regexp_end(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_regexp_literal(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#155
+  def on_regexp_new(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_rescue_mod(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_rest_param(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_retry(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_return(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_return0(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_rparen(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_sclass(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_semicolon(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_stmts_add(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#155
+  def on_stmts_new(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_string_add(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_string_concat(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_string_dvar(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_string_embexpr(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_super(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199
+  def on_symbeg(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_symbol(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_symbol_literal(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#474
+  def on_symbols_add(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199
+  def on_symbols_beg(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#462
+  def on_symbols_new(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199
+  def on_tlambda(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_tlambeg(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_top_const_field(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199
+  def on_tstring_beg(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_tstring_content(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_tstring_end(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_undef(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_unless(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#449
+  def on_unless_mod(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_until(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#449
+  def on_until_mod(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_var_alias(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_var_field(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_var_ref(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#177
+  def on_vcall(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_when(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_while(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#449
+  def on_while_mod(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_word_add(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#155
+  def on_word_new(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#474
+  def on_words_add(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#199
+  def on_words_beg(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#462
+  def on_words_new(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#188
+  def on_words_sep(tok); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#162
+  def on_xstring_add(list, item); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_xstring_literal(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#155
+  def on_xstring_new(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_yield(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_yield0(*args); end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#170
+  def on_zsuper(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#55
+  def parse; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#28
+  def root; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#29
+  def shebang_line; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#28
+  def tokens; end
+
+  private
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#667
+  def add_comment(line, node = T.unsafe(nil), before_node = T.unsafe(nil), into = T.unsafe(nil)); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#271
+  def add_token(token, data); end
+
+  # @return [Boolean]
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#611
+  def comment_starts_line?(charno); end
+
+  # @raise [ParserSyntaxError]
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#606
+  def compile_error(msg); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#693
+  def freeze_tree(node = T.unsafe(nil)); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#620
+  def insert_comments; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#377
+  def on_aref(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#385
+  def on_aref_field(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#391
+  def on_array(other); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#352
+  def on_assoc_new(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#364
+  def on_assoclist_from_args(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#360
+  def on_bare_assoc_hash(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#347
+  def on_body_stmt(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#347
+  def on_bodystmt(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#542
+  def on_comment(comment); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#441
+  def on_const_path_ref(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#419
+  def on_dyna_symbol(sym); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#592
+  def on_embdoc(text); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#586
+  def on_embdoc_beg(text); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#597
+  def on_embdoc_end(text); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#356
+  def on_hash(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#534
+  def on_label(data); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#497
+  def on_lambda(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#409
+  def on_lbracket(tok); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#515
+  def on_params(*args); end
+
+  # @raise [ParserSyntaxError]
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#606
+  def on_parse_error(msg); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#343
+  def on_program(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#414
+  def on_rbracket(tok); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#506
+  def on_rescue(exc, *args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#232
+  def on_sp(tok); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#501
+  def on_string_content(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#484
+  def on_string_literal(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#429
+  def on_top_const_ref(*args); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#368
+  def on_unary(op, val); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#511
+  def on_void_stmt; end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#237
+  def visit_event(node); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#251
+  def visit_event_arr(node); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#259
+  def visit_ns_token(token, data, ast_token = T.unsafe(nil)); end
+end
+
+# @since 0.5.6
+#
+# source://yard//lib/yard/parser/ruby/ruby_parser.rb#133
+YARD::Parser::Ruby::RipperParser::AST_TOKENS = T.let(T.unsafe(nil), Array)
+
+# @since 0.5.6
+#
+# source://yard//lib/yard/parser/ruby/ruby_parser.rb#136
+YARD::Parser::Ruby::RipperParser::COMMENT_SKIP_NODE_TYPES = T.let(T.unsafe(nil), Array)
+
+# @since 0.5.6
+#
+# source://yard//lib/yard/parser/ruby/ruby_parser.rb#78
+YARD::Parser::Ruby::RipperParser::MAPPINGS = T.let(T.unsafe(nil), Hash)
+
+# @since 0.5.6
+#
+# source://yard//lib/yard/parser/ruby/ruby_parser.rb#131
+YARD::Parser::Ruby::RipperParser::REV_MAPPINGS = T.let(T.unsafe(nil), Hash)
+
+# Ruby 1.9 parser
+#
+# source://yard//lib/yard/parser/ruby/ruby_parser.rb#12
+class YARD::Parser::Ruby::RubyParser < ::YARD::Parser::Base
+  # @return [RubyParser] a new instance of RubyParser
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#13
+  def initialize(source, filename); end
+
+  # Ruby 1.9 parser
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#21
+  def encoding_line; end
+
+  # Ruby 1.9 parser
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#19
+  def enumerator; end
+
+  # Ruby 1.9 parser
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#22
+  def frozen_string_line; end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#17
+  def parse; end
+
+  # Ruby 1.9 parser
+  #
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#20
+  def shebang_line; end
+
+  # source://yard//lib/yard/parser/ruby/ruby_parser.rb#18
+  def tokenize; end
+end
+
+# Supports {#each} enumeration over a source's tokens, yielding
+# the token and a possible {CodeObjects::Base} associated with the
+# constant or identifier token.
+#
+# source://yard//lib/yard/parser/ruby/token_resolver.rb#8
+class YARD::Parser::Ruby::TokenResolver
+  include ::Enumerable
+  include ::YARD::CodeObjects::NamespaceMapper
+
+  # Creates a token resolver for given source.
+  #
+  # @param source [String] the source code to tokenize
+  # @param namespace [CodeObjects::Base] the object/namespace to resolve from
+  # @raise [ParserSyntaxError]
+  # @return [TokenResolver] a new instance of TokenResolver
+  #
+  # source://yard//lib/yard/parser/ruby/token_resolver.rb#16
+  def initialize(source, namespace = T.unsafe(nil)); end
+
+  # Iterates over each token, yielding the token and a possible code
+  # object that is associated with the token.
+  #
+  # @example Yielding code objects
+  #   r = TokenResolver.new("A::B::C")
+  #   r.each do |tok, obj|
+  #   if obj
+  #   puts "#{tok[0]} -> #{obj.path.inspect}"
+  #   else
+  #   puts "No object: #{tok.inspect}"
+  #   end
+  #   end
+  #
+  #   # Prints:
+  #   # :const -> "A"
+  #   # No object: [:op, "::"]
+  #   # :const -> "A::B"
+  #   # No object: [:op, "::"]
+  #   # :const -> "A::B::C"
+  # @yieldparam token [Array(Symbol,String,Array(Integer,Integer))] the
+  #   current token object being iterated
+  # @yieldparam object [CodeObjects::Base, nil] the fully qualified code
+  #   object associated with the current token, or nil if there is no object
+  #   for the yielded token.
+  #
+  # source://yard//lib/yard/parser/ruby/token_resolver.rb#46
+  def each; end
+
+  protected
+
+  # source://yard//lib/yard/parser/ruby/token_resolver.rb#94
+  def last_sep; end
+
+  # source://yard//lib/yard/parser/ruby/token_resolver.rb#95
+  def last_sep=(v); end
+
+  # source://yard//lib/yard/parser/ruby/token_resolver.rb#94
+  def next_object; end
+
+  # source://yard//lib/yard/parser/ruby/token_resolver.rb#95
+  def next_object=(v); end
+
+  # source://yard//lib/yard/parser/ruby/token_resolver.rb#94
+  def object; end
+
+  # source://yard//lib/yard/parser/ruby/token_resolver.rb#95
+  def object=(v); end
+
+  # source://yard//lib/yard/parser/ruby/token_resolver.rb#94
+  def skip_group; end
+
+  # source://yard//lib/yard/parser/ruby/token_resolver.rb#95
+  def skip_group=(v); end
+
+  private
+
+  # source://yard//lib/yard/parser/ruby/token_resolver.rb#112
+  def lookup(toktype, name); end
+
+  # source://yard//lib/yard/parser/ruby/token_resolver.rb#134
+  def object_resolved_types(obj = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/parser/ruby/token_resolver.rb#106
+  def pop_state; end
+
+  # source://yard//lib/yard/parser/ruby/token_resolver.rb#102
+  def push_state; end
+
+  class << self
+    # source://yard//lib/yard/parser/ruby/token_resolver.rb#92
+    def state_attr(*attrs); end
+  end
+end
+
+# Responsible for parsing a source file into the namespace. Parsing
+# also invokes handlers to process the parsed statements and generate
+# any code objects that may be recognized.
+#
+# == Custom Parsers
+# SourceParser allows custom parsers to be registered and called when
+# a certain filetype is recognized. To register a parser and hook it
+# up to a set of file extensions, call {register_parser_type}
+#
+# @see register_parser_type
+# @see Handlers::Base
+# @see CodeObjects::Base
+#
+# source://yard//lib/yard/parser/source_parser.rb#63
+class YARD::Parser::SourceParser
+  # @overload initialize
+  # @return [SourceParser] a new instance of SourceParser
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#406
+  def initialize(parser_type = T.unsafe(nil), globals1 = T.unsafe(nil), globals2 = T.unsafe(nil)); end
+
+  # @return [String] the contents of the file to be parsed
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#399
+  def contents; end
+
+  # @return [String] the filename being parsed by the parser.
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#386
+  def file; end
+
+  # @return [String] the filename being parsed by the parser.
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#386
+  def file=(_arg0); end
+
+  # @return [OpenStruct] an open struct containing arbitrary global state
+  #   shared between files and handlers.
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#395
+  def globals; end
+
+  # The main parser method. This should not be called directly. Instead,
+  # use the class methods {parse} and {parse_string}.
+  #
+  # @param content [String, #read, Object] the source file to parse
+  # @return [Object, nil] the parser object used to parse the source
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#418
+  def parse(content = T.unsafe(nil)); end
+
+  # @return [Symbol] the parser type associated with the parser instance.
+  #   This should be set by the {#initialize constructor}.
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#390
+  def parser_type; end
+
+  # Tokenizes but does not parse the block of code using the current {#parser_type}
+  #
+  # @param content [String] the block of code to tokenize
+  # @return [Array] a list of tokens
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#462
+  def tokenize(content); end
+
+  private
+
+  # Searches for encoding line and forces encoding
+  #
+  # @since 0.5.3
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#471
+  def convert_encoding(content); end
+
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#515
+  def parser_class; end
+
+  # source://yard//lib/yard/parser/source_parser.rb#500
+  def parser_type=(value); end
+
+  # Guesses the parser type to use depending on the file extension.
+  #
+  # @param filename [String] the filename to use to guess the parser type
+  # @return [Symbol] a parser type that matches the filename
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#508
+  def parser_type_for_filename(filename); end
+
+  # Runs a {Handlers::Processor} object to post process the parsed statements.
+  #
+  # @return [void]
+  #
+  # source://yard//lib/yard/parser/source_parser.rb#490
+  def post_process; end
+
+  class << self
+    # Registers a callback to be called after an individual file is parsed.
+    # The block passed to this method will be called on subsequent parse
+    # calls.
+    #
+    # To register a callback that is called after the entire list of files
+    # is processed, see {after_parse_list}.
+    #
+    # @example Printing the length of each file after it is parsed
+    #   SourceParser.after_parse_file do |parser|
+    #   puts "#{parser.file} is #{parser.contents.size} characters"
+    #   end
+    #   YARD.parse('lib/**/*.rb')
+    #   # prints:
+    #   "lib/foo.rb is 1240 characters"
+    #   "lib/foo_bar.rb is 248 characters"
+    # @return [Proc] the yielded block
+    # @see before_parse_file
+    # @see after_parse_list
+    # @since 0.7.0
+    # @yield [parser] the yielded block is called once after each file
+    #   that is parsed. This might happen many times for a single codebase.
+    # @yieldparam parser [SourceParser] the parser object that parsed
+    #   the file.
+    # @yieldreturn [void] the return value for the block is ignored.
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#324
+    def after_parse_file(&block); end
+
+    # @return [Array<Proc>] the list of callbacks to be called after
+    #   parsing a file. Should only be used for testing.
+    # @since 0.7.0
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#352
+    def after_parse_file_callbacks; end
+
+    # Registers a callback to be called after a list of files is parsed
+    # via {parse}. The block passed to this method will be called on
+    # subsequent parse calls.
+    #
+    # @example Printing results after parsing occurs
+    #   SourceParser.after_parse_list do
+    #   puts "Finished parsing!"
+    #   end
+    #   YARD.parse
+    #   # Prints "Finished parsing!" after parsing files
+    # @return [Proc] the yielded block
+    # @see before_parse_list
+    # @see before_parse_file
+    # @since 0.7.0
+    # @yield [files, globals] the yielded block is called once before
+    #   parsing all files
+    # @yieldparam files [Array<String>] the list of files that will be parsed.
+    # @yieldparam globals [OpenStruct] a global structure to store arbitrary
+    #   state for post processing (see {Handlers::Processor#globals})
+    # @yieldreturn [void] the return value for the block is ignored.
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#258
+    def after_parse_list(&block); end
+
+    # @return [Array<Proc>] the list of callbacks to be called after
+    #   parsing a list of files. Should only be used for testing.
+    # @since 0.7.0
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#338
+    def after_parse_list_callbacks; end
+
+    # Registers a callback to be called before an individual file is parsed.
+    # The block passed to this method will be called on subsequent parse
+    # calls.
+    #
+    # To register a callback that is called before the entire list of files
+    # is processed, see {before_parse_list}.
+    #
+    # @example Cancel parsing of any test_*.rb files
+    #   SourceParser.before_parse_file do |parser|
+    #   return false if parser.file =~ /^test_.+\.rb$/
+    #   end
+    # @example Installing a simple callback
+    #   SourceParser.before_parse_file do |parser|
+    #   puts "I'm parsing #{parser.file}"
+    #   end
+    #   YARD.parse('lib/**/*.rb')
+    #   # prints:
+    #   "I'm parsing lib/foo.rb"
+    #   "I'm parsing lib/foo_bar.rb"
+    #   "I'm parsing lib/last_file.rb"
+    # @return [Proc] the yielded block
+    # @see before_parse_list
+    # @see after_parse_file
+    # @since 0.7.0
+    # @yield [parser] the yielded block is called once before each
+    #   file that is parsed. This might happen many times for a single
+    #   codebase.
+    # @yieldparam parser [SourceParser] the parser object that will {#parse}
+    #   the file.
+    # @yieldreturn [Boolean] if the block returns +false+, parsing for
+    #   the file is cancelled.
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#295
+    def before_parse_file(&block); end
+
+    # @return [Array<Proc>] the list of callbacks to be called before
+    #   parsing a file. Should only be used for testing.
+    # @since 0.7.0
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#345
+    def before_parse_file_callbacks; end
+
+    # Registers a callback to be called before a list of files is parsed
+    # via {parse}. The block passed to this method will be called on
+    # subsequent parse calls.
+    #
+    # @example Setting global state
+    #   SourceParser.before_parse_list do |files, globals|
+    #   globals.method_count = 0
+    #   end
+    #   SourceParser.after_parse_list do |files, globals|
+    #   puts "Found #{globals.method_count} methods"
+    #   end
+    #   class MyCountHandler < Handlers::Ruby::Base
+    #   handles :def, :defs
+    #   process { globals.method_count += 1 }
+    #   end
+    #   YARD.parse
+    #   # Prints: "Found 37 methods"
+    # @example Installing a simple callback
+    #   SourceParser.before_parse_list do |files, globals|
+    #   puts "Starting to parse..."
+    #   end
+    #   YARD.parse('lib/**/*.rb')
+    #   # prints "Starting to parse..."
+    # @example Using a global callback to cancel parsing
+    #   SourceParser.before_parse_list do |files, globals|
+    #   return false if files.include?('foo.rb')
+    #   end
+    #
+    #   YARD.parse(['foo.rb', 'bar.rb']) # callback cancels this method
+    #   YARD.parse('bar.rb') # parses normally
+    # @return [Proc] the yielded block
+    # @see before_parse_file
+    # @see after_parse_list
+    # @since 0.7.0
+    # @yield [files, globals] the yielded block is called once before
+    #   parsing all files
+    # @yieldparam files [Array<String>] the list of files that will be parsed.
+    # @yieldparam globals [OpenStruct] a global structure to store arbitrary
+    #   state for post processing (see {Handlers::Processor#globals})
+    # @yieldreturn [Boolean] if the block returns +false+, parsing is
+    #   cancelled.
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#234
+    def before_parse_list(&block); end
+
+    # @return [Array<Proc>] the list of callbacks to be called before
+    #   parsing a list of files. Should only be used for testing.
+    # @since 0.7.0
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#331
+    def before_parse_list_callbacks; end
+
+    # Parses a path or set of paths
+    #
+    # @param paths [String, Array<String>] a path, glob, or list of paths to
+    #   parse
+    # @param excluded [Array<String, Regexp>] a list of excluded path matchers
+    # @param level [Fixnum] the logger level to use during parsing. See
+    #   {YARD::Logger}
+    # @return [void]
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#99
+    def parse(paths = T.unsafe(nil), excluded = T.unsafe(nil), level = T.unsafe(nil)); end
+
+    # Parses a string +content+
+    #
+    # @param content [String] the block of code to parse
+    # @param ptype [Symbol] the parser type to use. See {parser_type}.
+    # @return the parser object that was used to parse +content+
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#123
+    def parse_string(content, ptype = T.unsafe(nil)); end
+
+    # @return [Symbol] the default parser type (defaults to :ruby)
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#85
+    def parser_type; end
+
+    # source://yard//lib/yard/parser/source_parser.rb#87
+    def parser_type=(value); end
+
+    # @private
+    # @return [Hash] a list of registered parser type extensions
+    # @since 0.5.6
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#163
+    def parser_type_extensions; end
+
+    # source://yard//lib/yard/parser/source_parser.rb#164
+    def parser_type_extensions=(value); end
+
+    # Finds a parser type that is registered for the extension. If no
+    # type is found, the default Ruby type is returned.
+    #
+    # @return [Symbol] the parser type to be used for the extension
+    # @since 0.5.6
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#171
+    def parser_type_for_extension(extension); end
+
+    # @private
+    # @return [Hash{Symbol=>Object}] a list of registered parser types
+    # @since 0.5.6
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#157
+    def parser_types; end
+
+    # source://yard//lib/yard/parser/source_parser.rb#158
+    def parser_types=(value); end
+
+    # Registers a new parser type.
+    #
+    # @example Registering a parser for "java" files
+    #   SourceParser.register_parser_type :java, JavaParser, 'java'
+    # @param type [Symbol] a symbolic name for the parser type
+    # @param parser_klass [Base] a class that implements parsing and tokenization
+    # @param extensions [Array<String>, String, Regexp] a list of extensions or a
+    #   regex to match against the file extension
+    # @return [void]
+    # @see Parser::Base
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#146
+    def register_parser_type(type, parser_klass, extensions = T.unsafe(nil)); end
+
+    # Tokenizes but does not parse the block of code
+    #
+    # @param content [String] the block of code to tokenize
+    # @param ptype [Symbol] the parser type to use. See {parser_type}.
+    # @return [Array] a list of tokens
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#132
+    def tokenize(content, ptype = T.unsafe(nil)); end
+
+    # Returns the validated parser type. Basically, enforces that :ruby
+    # type is never set if the Ripper library is not available
+    #
+    # @param type [Symbol] the parser type to set
+    # @private
+    # @return [Symbol] the validated parser type
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#184
+    def validated_parser_type(type); end
+
+    private
+
+    # Parses a list of files in a queue.
+    #
+    # @param files [Array<String>] a list of files to queue for parsing
+    # @return [void]
+    #
+    # source://yard//lib/yard/parser/source_parser.rb#364
+    def parse_in_order(*files); end
+  end
+end
+
+# The default glob of files to be parsed.
+#
+# @since 0.9.0
+#
+# source://yard//lib/yard/parser/source_parser.rb#70
+YARD::Parser::SourceParser::DEFAULT_PATH_GLOB = T.let(T.unsafe(nil), Array)
+
+# Byte order marks for various encodings
+#
+# @since 0.7.0
+#
+# source://yard//lib/yard/parser/source_parser.rb#74
+YARD::Parser::SourceParser::ENCODING_BYTE_ORDER_MARKS = T.let(T.unsafe(nil), Hash)
+
+# source://yard//lib/yard/parser/source_parser.rb#65
+YARD::Parser::SourceParser::ENCODING_LINE = T.let(T.unsafe(nil), Regexp)
+
+# source://yard//lib/yard/parser/source_parser.rb#66
+YARD::Parser::SourceParser::FROZEN_STRING_LINE = T.let(T.unsafe(nil), Regexp)
+
+# source://yard//lib/yard/parser/source_parser.rb#64
+YARD::Parser::SourceParser::SHEBANG_LINE = T.let(T.unsafe(nil), Regexp)
+
+# Raised when an object is recognized but cannot be documented. This
+# generally occurs when the Ruby syntax used to declare an object is
+# too dynamic in nature.
+#
+# source://yard//lib/yard/parser/source_parser.rb#9
+class YARD::Parser::UndocumentableError < ::RuntimeError; end
+
+# The root path for YARD source libraries
+#
+# source://yard//lib/yard.rb#4
+YARD::ROOT = T.let(T.unsafe(nil), String)
+
+# Holds Rake tasks used by YARD
+#
+# source://yard//lib/yard/autoload.rb#192
+module YARD::Rake; end
+
+# The +Registry+ is the centralized data store for all {CodeObjects} created
+# during parsing. The storage is a key value store with the object's path
+# (see {CodeObjects::Base#path}) as the key and the object itself as the value.
+# Object paths must be unique to be stored in the Registry. All lookups for
+# objects are done on the singleton Registry instance using the {Registry.at}
+# or {Registry.resolve} methods.
+#
+# == Saving / Loading a Registry
+# The registry is saved to a "yardoc file" (actually a directory), which can
+# be loaded back to perform any lookups. See {Registry.load!} and
+# {Registry.save} for information on saving and loading of a yardoc file.
+#
+# == Threading Notes
+# The registry class is a singleton class that is accessed directly in many
+# places across YARD. To mitigate threading issues, YARD (0.6.5+) makes
+# the Registry thread local. This means all access to a registry for a specific
+# object set must occur in the originating thread.
+#
+# @example Loading the Registry
+#   Registry.load!('/path/to/yardocfile') # loads all objects into memory
+#   Registry.at('YARD::CodeObjects::Base').docstring
+#   # => "+Base+ is the superclass of all code objects ..."
+# @example Getting an object by a specific path
+#   Registry.at('YARD::CodeObjects::Base#docstring')
+# @example Performing a lookup on a method anywhere in the inheritance tree
+#   Registry.resolve(P('YARD::CodeObjects::Base'), '#docstring', true)
+#
+# source://yard//lib/yard/registry.rb#32
+module YARD::Registry
+  extend ::Enumerable
+
+  class << self
+    # Returns the object at a specific path.
+    #
+    # @param path [String, :root] the pathname to look for. If +path+ is +root+,
+    #   returns the {root} object.
+    # @return [CodeObjects::Base] the object at path
+    # @return [nil] if no object is found
+    #
+    # source://yard//lib/yard/registry.rb#261
+    def [](path); end
+
+    # Returns all objects in the registry that match one of the types provided
+    # in the +types+ list (if +types+ is provided).
+    #
+    # @example Returns all objects
+    #   Registry.all
+    # @example Returns all classes and modules
+    #   Registry.all(:class, :module)
+    # @param types [Array<Symbol>] an optional list of types to narrow the
+    #   objects down by. Equivalent to performing a select:
+    #   +Registry.all.select {|o| types.include(o.type) }+
+    # @return [Array<CodeObjects::Base>] the list of objects found
+    # @see CodeObjects::Base#type
+    #
+    # source://yard//lib/yard/registry.rb#237
+    def all(*types); end
+
+    # Returns the object at a specific path.
+    #
+    # @param path [String, :root] the pathname to look for. If +path+ is +root+,
+    #   returns the {root} object.
+    # @return [CodeObjects::Base] the object at path
+    # @return [nil] if no object is found
+    #
+    # source://yard//lib/yard/registry.rb#261
+    def at(path); end
+
+    # @param data [String] data to checksum
+    # @return [String] the SHA1 checksum for data
+    #
+    # source://yard//lib/yard/registry.rb#318
+    def checksum_for(data); end
+
+    # @return [Hash{String => String}] a set of checksums for files
+    #
+    # source://yard//lib/yard/registry.rb#312
+    def checksums; end
+
+    # Clears the registry
+    #
+    # @return [void]
+    #
+    # source://yard//lib/yard/registry.rb#200
+    def clear; end
+
+    # Deletes an object from the registry
+    #
+    # @param object [CodeObjects::Base] the object to remove
+    # @return [void]
+    #
+    # source://yard//lib/yard/registry.rb#194
+    def delete(object); end
+
+    # Deletes the yardoc file from disk
+    #
+    # @return [void]
+    #
+    # source://yard//lib/yard/registry.rb#176
+    def delete_from_disk; end
+
+    # Iterates over {all} with no arguments
+    #
+    # source://yard//lib/yard/registry.rb#221
+    def each(&block); end
+
+    # The registry singleton instance.
+    #
+    # @deprecated use Registry.methodname directly.
+    # @return [Registry] returns the registry instance
+    #
+    # source://yard//lib/yard/registry.rb#363
+    def instance; end
+
+    # Loads the registry and/or parses a list of files
+    #
+    # @example Loads the yardoc file or parses files 'a', 'b' and 'c' (but not both)
+    #   Registry.load(['a', 'b', 'c'])
+    # @example Reparses files 'a' and 'b' regardless of whether yardoc file exists
+    #   Registry.load(['a', 'b'], true)
+    # @param files [String, Array] if +files+ is an Array, it should represent
+    #   a list of files that YARD should parse into the registry. If reload is
+    #   set to false and the yardoc file already exists, these files are skipped.
+    #   If files is a String, it should represent the yardoc file to load
+    #   into the registry.
+    # @param reparse [Boolean] if reparse is false and a yardoc file already
+    #   exists, any files passed in will be ignored.
+    # @raise [ArgumentError] if files is not a String or Array
+    # @return [Registry] the registry object (for chaining)
+    #
+    # source://yard//lib/yard/registry.rb#109
+    def load(files = T.unsafe(nil), reparse = T.unsafe(nil)); end
+
+    # Loads a yardoc file and forces all objects cached on disk into
+    # memory. Equivalent to calling {load_yardoc} followed by {load_all}
+    #
+    # @param file [String] the yardoc file to load
+    # @return [Registry] the registry object (for chaining)
+    # @see #load_yardoc
+    # @see #load_all
+    # @since 0.5.1
+    #
+    # source://yard//lib/yard/registry.rb#144
+    def load!(file = T.unsafe(nil)); end
+
+    # Forces all objects cached on disk into memory
+    #
+    # @example Loads all objects from disk
+    #   Registry.load
+    #   Registry.all.count #=> 0
+    #   Registry.load_all
+    #   Registry.all.count #=> 17
+    # @return [Registry] the registry object (for chaining)
+    # @since 0.5.1
+    #
+    # source://yard//lib/yard/registry.rb#159
+    def load_all; end
+
+    # Loads a yardoc file directly
+    #
+    # @param file [String] the yardoc file to load.
+    # @return [Registry] the registry object (for chaining)
+    #
+    # source://yard//lib/yard/registry.rb#130
+    def load_yardoc(file = T.unsafe(nil)); end
+
+    # @param name [String] the locale name.
+    # @return [I18n::Locale] the locale object for +name+.
+    # @since 0.8.3
+    #
+    # source://yard//lib/yard/registry.rb#271
+    def locale(name); end
+
+    # Creates a pessmistic transactional lock on the database for writing.
+    # Use with {YARD.parse} to ensure the database is not written multiple
+    # times.
+    #
+    # @see locked_for_writing?
+    #
+    # source://yard//lib/yard/registry.rb#209
+    def lock_for_writing(file = T.unsafe(nil), &block); end
+
+    # @return [Boolean] whether the database is currently locked for writing
+    #
+    # source://yard//lib/yard/registry.rb#214
+    def locked_for_writing?(file = T.unsafe(nil)); end
+
+    # Returns the paths of all of the objects in the registry.
+    #
+    # @param reload [Boolean] whether to load entire database
+    # @return [Array<String>] all of the paths in the registry.
+    #
+    # source://yard//lib/yard/registry.rb#252
+    def paths(reload = T.unsafe(nil)); end
+
+    # Gets/sets the directory that has LANG.po files
+    #
+    # @return [String] the directory that has .po files
+    #
+    # source://yard//lib/yard/registry.rb#353
+    def po_dir; end
+
+    # Gets/sets the directory that has LANG.po files
+    #
+    # @return [String] the directory that has .po files
+    #
+    # source://yard//lib/yard/registry.rb#351
+    def po_dir=(dir); end
+
+    # The assumed types of a list of paths. This method is used by CodeObjects::Base
+    #
+    # @deprecated The registry no longer globally tracks proxy types.
+    # @private
+    # @return [{String => Symbol}] a set of unresolved paths and their assumed type
+    #
+    # source://yard//lib/yard/registry.rb#341
+    def proxy_types; end
+
+    # Registers a new object with the registry
+    #
+    # @param object [CodeObjects::Base] the object to register
+    # @return [CodeObjects::Base] the registered object
+    #
+    # source://yard//lib/yard/registry.rb#186
+    def register(object); end
+
+    # Attempts to find an object by name starting at +namespace+, performing
+    # a lookup similar to Ruby's method of resolving a constant in a namespace.
+    #
+    # @example Looks for a constant in the root namespace
+    #   Registry.resolve(nil, 'CONSTANT')
+    # @example Looks for a class method respecting the inheritance tree
+    #   Registry.resolve(myclass, 'mymethod', true)
+    # @example Looks for instance method #reverse starting from A::B::C
+    #   Registry.resolve(P("A::B::C"), "#reverse")
+    # @example Looks for a constant but returns a proxy if not found
+    #   Registry.resolve(P('A::B::C'), 'D', false, true) # => #<yardoc proxy A::B::C::D>
+    # @example Looks for a complex path from a namespace
+    #   Registry.resolve(P('A::B'), 'B::D') # => #<yardoc class A::B::D>
+    # @param inheritance [Boolean] Follows inheritance chain (mixins, superclass)
+    #   when performing name resolution if set to +true+.
+    # @param namespace [CodeObjects::NamespaceObject, nil] the starting namespace
+    #   (module or class). If +nil+ or +:root+, starts from the {root} object.
+    # @param name [String, Symbol] the name (or complex path) to look for from
+    #   +namespace+.
+    # @param proxy_fallback [Boolean] If +true+, returns a proxy representing
+    #   the unresolved path (namespace + name) if no object is found.
+    # @param type [Symbol, nil] the {CodeObjects::Base#type} that the resolved
+    #   object must be equal to. No type checking if nil.
+    # @return [CodeObjects::Base] the object if it is found
+    # @return [CodeObjects::Proxy] a Proxy representing the object if
+    #   +proxy_fallback+ is +true+.
+    # @return [nil] if +proxy_fallback+ is +false+ and no object was found.
+    # @see P
+    #
+    # source://yard//lib/yard/registry.rb#303
+    def resolve(namespace, name, inheritance = T.unsafe(nil), proxy_fallback = T.unsafe(nil), type = T.unsafe(nil)); end
+
+    # The root namespace object.
+    #
+    # @return [CodeObjects::RootObject] the root object in the namespace
+    #
+    # source://yard//lib/yard/registry.rb#266
+    def root; end
+
+    # Saves the registry to +file+
+    #
+    # @param file [String] the yardoc file to save to
+    # @return [Boolean] true if the file was saved
+    #
+    # source://yard//lib/yard/registry.rb#170
+    def save(merge = T.unsafe(nil), file = T.unsafe(nil)); end
+
+    # Whether or not the Registry storage should load everything into a
+    # single object database (for disk efficiency), or spread them out
+    # (for load time efficiency).
+    #
+    # @note Setting this attribute to nil will offload the decision to
+    #   the {RegistryStore storage adapter}.
+    # @return [Boolean, nil] if this value is set to nil, the storage
+    #   adapter will decide how to store the data.
+    #
+    # source://yard//lib/yard/registry.rb#335
+    def single_object_db; end
+
+    # Whether or not the Registry storage should load everything into a
+    # single object database (for disk efficiency), or spread them out
+    # (for load time efficiency).
+    #
+    # @note Setting this attribute to nil will offload the decision to
+    #   the {RegistryStore storage adapter}.
+    # @return [Boolean, nil] if this value is set to nil, the storage
+    #   adapter will decide how to store the data.
+    #
+    # source://yard//lib/yard/registry.rb#334
+    def single_object_db=(v); end
+
+    # Gets/sets the yardoc filename
+    #
+    # @return [String] the yardoc filename
+    # @see DEFAULT_YARDOC_FILE
+    #
+    # source://yard//lib/yard/registry.rb#88
+    def yardoc_file; end
+
+    # Gets/sets the yardoc filename
+    #
+    # @return [String] the yardoc filename
+    # @see DEFAULT_YARDOC_FILE
+    #
+    # source://yard//lib/yard/registry.rb#86
+    def yardoc_file=(v); end
+
+    # Returns the .yardoc file associated with a gem.
+    #
+    # @param gem [String] the name of the gem to search for
+    # @param ver_require [String] an optional Gem version requirement
+    # @param for_writing [Boolean] whether or not the method should search
+    #   for writable locations
+    # @return [String] if +for_writing+ is set to +true+, returns the best
+    #   location suitable to write the .yardoc file. Otherwise, the first
+    #   existing location associated with the gem's .yardoc file.
+    # @return [nil] if +for_writing+ is set to false and no yardoc file
+    #   is found, returns nil.
+    #
+    # source://yard//lib/yard/registry.rb#53
+    def yardoc_file_for_gem(gem, ver_require = T.unsafe(nil), for_writing = T.unsafe(nil)); end
+
+    private
+
+    # source://yard//lib/yard/registry.rb#390
+    def global_yardoc_file(spec, for_writing = T.unsafe(nil)); end
+
+    # source://yard//lib/yard/registry.rb#410
+    def local_yardoc_file(spec, for_writing = T.unsafe(nil)); end
+
+    # source://yard//lib/yard/registry.rb#403
+    def old_global_yardoc_file(spec, for_writing = T.unsafe(nil)); end
+
+    # Attempts to resolve a name in a namespace
+    #
+    # @param namespace [CodeObjects::NamespaceObject] the starting namespace
+    # @param name [String] the name to look for
+    # @param type [Symbol, nil] the {CodeObjects::Base#type} that the resolved
+    #   object must be equal to
+    #
+    # source://yard//lib/yard/registry.rb#375
+    def partial_resolve(namespace, name, type = T.unsafe(nil)); end
+
+    # @since 0.9.1
+    #
+    # source://yard//lib/yard/registry.rb#434
+    def thread_local_resolver; end
+
+    # @since 0.6.5
+    #
+    # source://yard//lib/yard/registry.rb#424
+    def thread_local_store; end
+
+    # @since 0.6.5
+    #
+    # source://yard//lib/yard/registry.rb#429
+    def thread_local_store=(value); end
+  end
+end
+
+# source://yard//lib/yard/registry.rb#35
+YARD::Registry::DEFAULT_PO_DIR = T.let(T.unsafe(nil), String)
+
+# source://yard//lib/yard/registry.rb#33
+YARD::Registry::DEFAULT_YARDOC_FILE = T.let(T.unsafe(nil), String)
+
+# source://yard//lib/yard/registry.rb#34
+YARD::Registry::LOCAL_YARDOC_INDEX = T.let(T.unsafe(nil), String)
+
+# Handles all logic for complex lexical and inherited object resolution.
+# Used by {Registry.resolve}, so there is no need to use this class
+# directly.
+#
+# @see Registry.resolve
+# @since 0.9.1
+#
+# source://yard//lib/yard/registry_resolver.rb#9
+class YARD::RegistryResolver
+  include ::YARD::CodeObjects::NamespaceMapper
+
+  # Creates a new resolver object for a registry.
+  #
+  # @param registry [Registry] only set this if customizing the registry
+  #   object
+  # @return [RegistryResolver] a new instance of RegistryResolver
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/registry_resolver.rb#16
+  def initialize(registry = T.unsafe(nil)); end
+
+  # Performs a lookup on a given path in the registry. Resolution will occur
+  # in a similar way to standard Ruby identifier resolution, doing lexical
+  # lookup, as well as (optionally) through the inheritance chain. A proxy
+  # object can be returned if the lookup fails for future resolution. The
+  # proxy will be type hinted with the +type+ used in the original lookup.
+  #
+  # @example A lookup on a method through the inheritance tree
+  #   resolver.lookup_by_math("A::B#foo", inheritance: true)
+  # @example A lookup from root
+  #   resolver.lookup_by_path("A::B::C")
+  # @example A lookup from the A::B namespace
+  #   resolver.lookup_by_path("C", namespace: P("A::B"))
+  # @option opts
+  # @option opts
+  # @option opts
+  # @option opts
+  # @param opts [Hash] a customizable set of options
+  # @return [CodeObjects::Base, CodeObjects::Proxy, nil] the first object
+  #   that matches the path lookup. If proxy_fallback is provided, a proxy
+  #   object will be returned in the event of no match, otherwise nil will
+  #   be returned.
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/registry_resolver.rb#50
+  def lookup_by_path(path, opts = T.unsafe(nil)); end
+
+  private
+
+  # Collects and returns all inherited namespaces for a given object
+  #
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/registry_resolver.rb#181
+  def collect_namespaces(object); end
+
+  # Performs a lexical lookup from a namespace for a path and a type hint.
+  #
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/registry_resolver.rb#104
+  def lookup_path_direct(namespace, path, type); end
+
+  # Performs a lookup through the inheritance chain on a path with a type hint.
+  #
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/registry_resolver.rb#121
+  def lookup_path_inherited(namespace, path, type); end
+
+  # @return [Regexp] the regexp that can be used to split a string on all
+  #   occurrences of separator tokens
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/registry_resolver.rb#206
+  def split_on_separators_match; end
+
+  # @return [Regexp] the regexp match of the default separator
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/registry_resolver.rb#194
+  def starts_with_default_separator_match; end
+
+  # @return [Regexp] the regexp that matches strings starting with
+  #   a separator
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/registry_resolver.rb#200
+  def starts_with_separator_match; end
+
+  # return [Boolean] if the obj's type matches the provided type.
+  #
+  # @since 0.9.1
+  #
+  # source://yard//lib/yard/registry_resolver.rb#99
+  def validate(obj, type); end
+end
+
+# The data store for the {Registry}.
+#
+# @see Registry
+# @see Serializers::YardocSerializer
+#
+# source://yard//lib/yard/registry_store.rb#9
+class YARD::RegistryStore
+  # @return [RegistryStore] a new instance of RegistryStore
+  #
+  # source://yard//lib/yard/registry_store.rb#14
+  def initialize; end
+
+  # Gets a {CodeObjects::Base} from the store
+  #
+  # @param key [String, Symbol] the path name of the object to look for.
+  #   If it is empty or :root, returns the {#root} object.
+  # @return [CodeObjects::Base, nil] a code object or nil if none is found
+  #
+  # source://yard//lib/yard/registry_store.rb#33
+  def [](key); end
+
+  # Associates an object with a path
+  #
+  # @param key [String, Symbol] the path name (:root or '' for root object)
+  # @param value [CodeObjects::Base] the object to store
+  # @return [CodeObjects::Base] returns +value+
+  #
+  # source://yard//lib/yard/registry_store.rb#55
+  def []=(key, value); end
+
+  # Returns the value of attribute checksums.
+  #
+  # source://yard//lib/yard/registry_store.rb#12
+  def checksums; end
+
+  # Deletes an object at a given path
+  #
+  # @param key [#to_sym] the key to delete
+  # @return [void]
+  #
+  # source://yard//lib/yard/registry_store.rb#75
+  def delete(key); end
+
+  # Deletes the .yardoc database on disk
+  #
+  # @param force [Boolean] if force is not set to true, the file/directory
+  #   will only be removed if it ends with .yardoc. This helps with
+  #   cases where the directory might have been named incorrectly.
+  # @return [Boolean] true if the .yardoc database was deleted, false
+  #   otherwise.
+  #
+  # source://yard//lib/yard/registry_store.rb#218
+  def destroy(force = T.unsafe(nil)); end
+
+  # Returns the value of attribute file.
+  #
+  # source://yard//lib/yard/registry_store.rb#12
+  def file; end
+
+  # Gets a {CodeObjects::Base} from the store
+  #
+  # @param key [String, Symbol] the path name of the object to look for.
+  #   If it is empty or :root, returns the {#root} object.
+  # @return [CodeObjects::Base, nil] a code object or nil if none is found
+  #
+  # source://yard//lib/yard/registry_store.rb#33
+  def get(key); end
+
+  # Gets all path names from the store. Loads the entire database
+  # if +reload+ is +true+
+  #
+  # @param reload [Boolean] if false, does not load the entire database
+  #   before a lookup.
+  # @return [Array<Symbol>] the path names of all the code objects
+  #
+  # source://yard//lib/yard/registry_store.rb#88
+  def keys(reload = T.unsafe(nil)); end
+
+  # @param file [String, nil] the name of the yardoc db to load
+  # @return [Boolean] whether the database was loaded
+  #
+  # source://yard//lib/yard/registry_store.rb#128
+  def load(file = T.unsafe(nil)); end
+
+  # Loads the .yardoc file and loads all cached objects into memory
+  # automatically.
+  #
+  # @param file [String, nil] the name of the yardoc db to load
+  # @return [Boolean] whether the database was loaded
+  # @see #load_all
+  # @since 0.5.1
+  #
+  # source://yard//lib/yard/registry_store.rb#142
+  def load!(file = T.unsafe(nil)); end
+
+  # Loads all cached objects into memory
+  #
+  # @return [void]
+  #
+  # source://yard//lib/yard/registry_store.rb#153
+  def load_all; end
+
+  # @param name [String] the locale name.
+  # @return [I18n::Locale] the locale object for +name+.
+  # @since 0.8.3
+  #
+  # source://yard//lib/yard/registry_store.rb#122
+  def locale(name); end
+
+  # Creates a pessmistic transactional lock on the database for writing.
+  # Use with {YARD.parse} to ensure the database is not written multiple
+  # times.
+  #
+  # @param file [String] if supplied, the path to the database
+  # @see #locked_for_writing?
+  #
+  # source://yard//lib/yard/registry_store.rb#201
+  def lock_for_writing(file = T.unsafe(nil), &block); end
+
+  # @param file [String] if supplied, the path to the database
+  # @return [Boolean] whether the database is currently locked for writing
+  #
+  # source://yard//lib/yard/registry_store.rb#207
+  def locked_for_writing?(file = T.unsafe(nil)); end
+
+  # @param type [Symbol] the type to look for
+  # @return [Array<String>] a list of object paths with a given
+  #   {CodeObjects::Base#type}
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/registry_store.rb#102
+  def paths_for_type(type, reload = T.unsafe(nil)); end
+
+  # @deprecated The registry no longer tracks proxy types
+  #
+  # source://yard//lib/yard/registry_store.rb#11
+  def proxy_types; end
+
+  # Associates an object with a path
+  #
+  # @param key [String, Symbol] the path name (:root or '' for root object)
+  # @param value [CodeObjects::Base] the object to store
+  # @return [CodeObjects::Base] returns +value+
+  #
+  # source://yard//lib/yard/registry_store.rb#55
+  def put(key, value); end
+
+  # @return [CodeObjects::RootObject] the root object
+  #
+  # source://yard//lib/yard/registry_store.rb#117
+  def root; end
+
+  # Saves the database to disk
+  #
+  # @param merge [Boolean] if true, merges the data in memory with the
+  #   data on disk, otherwise the data on disk is deleted.
+  # @param file [String, nil] if supplied, the name of the file to save to
+  # @return [Boolean] whether the database was saved
+  #
+  # source://yard//lib/yard/registry_store.rb#177
+  def save(merge = T.unsafe(nil), file = T.unsafe(nil)); end
+
+  # Gets all code objects from the store. Loads the entire database
+  # if +reload+ is +true+
+  #
+  # @param reload [Boolean] if false, does not load the entire database
+  #   before a lookup.
+  # @return [Array<CodeObjects::Base>] all the code objects
+  #
+  # source://yard//lib/yard/registry_store.rb#96
+  def values(reload = T.unsafe(nil)); end
+
+  # @param type [Symbol] the type to look for
+  # @return [Array<CodeObjects::Base>] a list of objects with a given
+  #   {CodeObjects::Base#type}
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/registry_store.rb#111
+  def values_for_type(type, reload = T.unsafe(nil)); end
+
+  protected
+
+  # source://yard//lib/yard/registry_store.rb#243
+  def checksums_path; end
+
+  # source://yard//lib/yard/registry_store.rb#251
+  def load_yardoc; end
+
+  # source://yard//lib/yard/registry_store.rb#247
+  def object_types_path; end
+
+  # source://yard//lib/yard/registry_store.rb#234
+  def objects_path; end
+
+  # @deprecated The registry no longer tracks proxy types
+  #
+  # source://yard//lib/yard/registry_store.rb#239
+  def proxy_types_path; end
+
+  private
+
+  # source://yard//lib/yard/registry_store.rb#319
+  def all_disk_objects; end
+
+  # source://yard//lib/yard/registry_store.rb#291
+  def load_checksums; end
+
+  # source://yard//lib/yard/registry_store.rb#313
+  def load_locale(name); end
+
+  # source://yard//lib/yard/registry_store.rb#281
+  def load_object_types; end
+
+  # @deprecated The registry no longer tracks proxy types
+  #
+  # source://yard//lib/yard/registry_store.rb#276
+  def load_proxy_types; end
+
+  # source://yard//lib/yard/registry_store.rb#299
+  def load_root; end
+
+  # source://yard//lib/yard/registry_store.rb#271
+  def load_yardoc_old; end
+
+  # source://yard//lib/yard/registry_store.rb#332
+  def write_checksums; end
+
+  # source://yard//lib/yard/registry_store.rb#338
+  def write_complete_lock; end
+
+  # source://yard//lib/yard/registry_store.rb#328
+  def write_object_types; end
+
+  # @deprecated The registry no longer tracks proxy types
+  #
+  # source://yard//lib/yard/registry_store.rb#324
+  def write_proxy_types; end
+end
+
+# Namespace for components that serialize to various endpoints
+#
+# source://yard//lib/yard/autoload.rb#196
+module YARD::Serializers; end
+
+# The abstract base serializer. Serializers allow templates to be
+# rendered to various endpoints. For instance, a {FileSystemSerializer}
+# would allow template contents to be written to the filesystem
+#
+# To implement a custom serializer, override the following methods:
+# * {#serialize}
+# * {#serialized_path}
+#
+# Optionally, a serializer can implement before and after filters:
+# * {#before_serialize}
+# * {#after_serialize}
+#
+# @abstract Override this class to implement a custom serializer.
+#
+# source://yard//lib/yard/serializers/base.rb#17
+class YARD::Serializers::Base
+  # Creates a new serializer with options
+  #
+  # @param opts [Hash] the options to assign to {#options}
+  # @return [Base] a new instance of Base
+  #
+  # source://yard//lib/yard/serializers/base.rb#28
+  def initialize(opts = T.unsafe(nil)); end
+
+  # Called after serialization.
+  #
+  # @abstract Should run code after serialization.
+  # @param data [String] the data that was serialized.
+  # @return [void]
+  #
+  # source://yard//lib/yard/serializers/base.rb#80
+  def after_serialize(data); end
+
+  # Called before serialization.
+  #
+  # @abstract Should run code before serialization. Should return false
+  #   if serialization should not occur.
+  # @return [Boolean] whether or not serialization should occur
+  #
+  # source://yard//lib/yard/serializers/base.rb#73
+  def before_serialize; end
+
+  # Returns whether an object has been serialized
+  #
+  # @abstract This method should return whether the endpoint already exists.
+  #   For instance, a file system serializer would check if the file exists
+  #   on disk. You will most likely use +#basepath+ and {#serialized_path} to
+  #   get the endpoint's location.
+  # @param object [CodeObjects::Base] the object to check existence of
+  # @return [Boolean] whether the endpoint exists.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/serializers/base.rb#62
+  def exists?(object); end
+
+  # All serializer options are saved so they can be passed to other serializers.
+  #
+  # @return [SymbolHash] the serializer options
+  #
+  # source://yard//lib/yard/serializers/base.rb#21
+  def options; end
+
+  # Serializes an object.
+  #
+  # @abstract This method should implement the logic that serializes
+  #   +data+ to the respective endpoint. This method should also call
+  #   the before and after callbacks {#before_serialize} and {#after_serialize}
+  # @param object [CodeObjects::Base, String] the object to serialize the
+  #   data for. The object can also be a string (for non-object serialization)
+  # @param data [String] the contents that should be serialized
+  #
+  # source://yard//lib/yard/serializers/base.rb#42
+  def serialize(object, data); end
+
+  # The serialized path of an object
+  #
+  # @abstract This method should return the path of the object on the
+  #   endpoint. For instance, for a file serializer, this should return
+  #   the filename that represents the object on disk.
+  # @param object [CodeObjects::Base] the object to return a path for
+  # @return [String] the serialized path of an object
+  #
+  # source://yard//lib/yard/serializers/base.rb#51
+  def serialized_path(object); end
+end
+
+# Implements a serializer that reads from and writes to the filesystem.
+#
+# source://yard//lib/yard/serializers/file_system_serializer.rb#5
+class YARD::Serializers::FileSystemSerializer < ::YARD::Serializers::Base
+  # Creates a new FileSystemSerializer with options
+  #
+  # @option opts
+  # @option opts
+  # @param opts [Hash] a customizable set of options
+  # @return [FileSystemSerializer] a new instance of FileSystemSerializer
+  #
+  # source://yard//lib/yard/serializers/file_system_serializer.rb#28
+  def initialize(opts = T.unsafe(nil)); end
+
+  # The base path to write data to.
+  #
+  # @return [String] a base path
+  #
+  # source://yard//lib/yard/serializers/file_system_serializer.rb#8
+  def basepath; end
+
+  # source://yard//lib/yard/serializers/file_system_serializer.rb#10
+  def basepath=(value); end
+
+  # Checks the disk for an object and returns whether it was serialized.
+  #
+  # @param object [CodeObjects::Base] the object to check
+  # @return [Boolean] whether an object has been serialized to disk
+  #
+  # source://yard//lib/yard/serializers/file_system_serializer.rb#71
+  def exists?(object); end
+
+  # The extension of the filename (defaults to +html+)
+  #
+  # @return [String] the extension of the file. Empty string for no extension.
+  #
+  # source://yard//lib/yard/serializers/file_system_serializer.rb#17
+  def extension; end
+
+  # source://yard//lib/yard/serializers/file_system_serializer.rb#19
+  def extension=(value); end
+
+  # Serializes object with data to its serialized path (prefixed by the +#basepath+).
+  #
+  # @return [String] the written data (for chaining)
+  #
+  # source://yard//lib/yard/serializers/file_system_serializer.rb#38
+  def serialize(object, data); end
+
+  # Implements the serialized path of a code object.
+  #
+  # @param object [CodeObjects::Base, CodeObjects::ExtraFileObject, String] the object to get a path for. The path of a string is the string itself.
+  # @return [String] if object is a String, returns
+  #   object, otherwise the path on disk (without the basepath).
+  #
+  # source://yard//lib/yard/serializers/file_system_serializer.rb#50
+  def serialized_path(object); end
+
+  private
+
+  # Builds a filename mapping from object paths to filesystem path names.
+  # Needed to handle case sensitive YARD objects mapped into a case
+  # insensitive filesystem. Uses with {#mapped_name} to determine the
+  # mapping name for a given object.
+  #
+  # @note In order to use filesystem name mapping, you must initialize
+  #   the serializer object after preparing the {YARD::Registry}.
+  #
+  # source://yard//lib/yard/serializers/file_system_serializer.rb#84
+  def build_filename_map; end
+
+  # Remove special chars from filenames.
+  # Windows disallows \ / : * ? " < > | but we will just remove any
+  # non alphanumeric (plus period, underscore and dash).
+  #
+  # source://yard//lib/yard/serializers/file_system_serializer.rb#111
+  def encode_path_components(*components); end
+
+  # @return [String] the filesystem mapped name of a given object.
+  #
+  # source://yard//lib/yard/serializers/file_system_serializer.rb#102
+  def mapped_name(object); end
+end
+
+# Serializes an object to a process (like less)
+#
+# @example Serializing to a pager (less)
+#   serializer = ProcessSerializer.new('less')
+#   serializer.serialize(object, "data!")
+#
+# source://yard//lib/yard/serializers/process_serializer.rb#9
+class YARD::Serializers::ProcessSerializer < ::YARD::Serializers::Base
+  # Creates a new ProcessSerializer for the shell command +cmd+
+  #
+  # @param cmd [String] the command that will accept data on stdin
+  # @return [ProcessSerializer] a new instance of ProcessSerializer
+  #
+  # source://yard//lib/yard/serializers/process_serializer.rb#13
+  def initialize(cmd); end
+
+  # Overrides serialize behaviour and writes data to standard input
+  # of the associated command
+  #
+  # source://yard//lib/yard/serializers/process_serializer.rb#19
+  def serialize(_object, data); end
+end
+
+# A serializer that writes data to standard output.
+#
+# source://yard//lib/yard/serializers/stdout_serializer.rb#5
+class YARD::Serializers::StdoutSerializer < ::YARD::Serializers::Base
+  # Creates a serializer to print text to stdout
+  #
+  # @param wrap [Fixnum, nil] if wrap is a number, wraps text to +wrap+
+  #   columns, otherwise no wrapping is done.
+  # @return [StdoutSerializer] a new instance of StdoutSerializer
+  #
+  # source://yard//lib/yard/serializers/stdout_serializer.rb#10
+  def initialize(wrap = T.unsafe(nil)); end
+
+  # Overrides serialize behaviour to write data to standard output
+  #
+  # source://yard//lib/yard/serializers/stdout_serializer.rb#15
+  def serialize(_object, data); end
+
+  private
+
+  # Wraps text to a specific column length
+  #
+  # @param text [String] the text to wrap
+  # @param _length [Fixnum] the column length to wrap to
+  # @return [String] the wrapped text
+  #
+  # source://yard//lib/yard/serializers/stdout_serializer.rb#26
+  def word_wrap(text, _length = T.unsafe(nil)); end
+end
+
+# source://yard//lib/yard/serializers/yardoc_serializer.rb#32
+class YARD::Serializers::YardocSerializer < ::YARD::Serializers::FileSystemSerializer
+  # @return [YardocSerializer] a new instance of YardocSerializer
+  #
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#33
+  def initialize(yfile); end
+
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#40
+  def checksums_path; end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#45
+  def complete?; end
+
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#42
+  def complete_lock_path; end
+
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#101
+  def deserialize(path, is_path = T.unsafe(nil)); end
+
+  # Creates a pessmistic transactional lock on the database for writing.
+  # Use with {YARD.parse} to ensure the database is not written multiple
+  # times.
+  #
+  # @see #locked_for_writing?
+  #
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#54
+  def lock_for_writing; end
+
+  # @return [Boolean] whether the database is currently locked for writing
+  #
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#62
+  def locked_for_writing?; end
+
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#41
+  def object_types_path; end
+
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#37
+  def objects_path; end
+
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#43
+  def processing_path; end
+
+  # @deprecated The registry no longer tracks proxy types
+  #
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#39
+  def proxy_types_path; end
+
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#93
+  def serialize(object); end
+
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#66
+  def serialized_path(object); end
+
+  private
+
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#114
+  def dump(object); end
+
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#119
+  def internal_dump(object, first_object = T.unsafe(nil)); end
+end
+
+# Namespace for classes and modules that handle serving documentation over HTTP
+#
+# == Implementing a Custom Server
+# To customize the YARD server, see the {Adapter} and {Router} classes.
+#
+# == Rack Middleware
+# If you want to use the YARD server as a Rack middleware, see the documentation
+# in {RackMiddleware}.
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/autoload.rb#214
+module YARD::Server
+  class << self
+    # Registers a static path to be used in static asset lookup.
+    #
+    # @param path [String] the pathname to register
+    # @return [void]
+    # @since 0.6.2
+    #
+    # source://yard//lib/yard/server.rb#8
+    def register_static_path(path); end
+  end
+end
+
+# This class implements the bridge between the {Router} and the server
+# backend for a specific server type. YARD implements concrete adapters
+# for WEBrick and Rack respectively, though other adapters can be made
+# for other server architectures.
+#
+# == Subclassing Notes
+# To create a concrete adapter class, implement the {#start} method to
+# initiate the server backend.
+#
+# @abstract
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/adapter.rb#23
+class YARD::Server::Adapter
+  # Creates a new adapter object
+  #
+  # @option opts
+  # @option opts
+  # @option opts
+  # @param libs [Hash{String=>Array<LibraryVersion>}] a list of libraries,
+  #   see {#libraries} for formulating this list.
+  # @param opts [Hash] extra options to pass to the adapter
+  # @return [Adapter] a new instance of Adapter
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/adapter.rb#71
+  def initialize(libs, opts = T.unsafe(nil), server_opts = T.unsafe(nil)); end
+
+  # Adds a library to the {#libraries} mapping for a given library object.
+  #
+  # @example Adding a new library to an adapter
+  #   adapter.add_library LibraryVersion.new('mylib', '1.0', '/path/to/.yardoc')
+  # @param library [LibraryVersion] a library to add
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/adapter.rb#88
+  def add_library(library); end
+
+  # @return [String] the location where static files are located, if any.
+  #   To set this field on initialization, pass +:DocumentRoot+ to the
+  #   +server_opts+ argument in {#initialize}
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/adapter.rb#27
+  def document_root; end
+
+  # @return [String] the location where static files are located, if any.
+  #   To set this field on initialization, pass +:DocumentRoot+ to the
+  #   +server_opts+ argument in {#initialize}
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/adapter.rb#27
+  def document_root=(_arg0); end
+
+  # @return [Hash{String=>Array<LibraryVersion>}] a map of libraries.
+  # @see LibraryVersion LibraryVersion for information on building a list of libraries
+  # @see #add_library
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/adapter.rb#32
+  def libraries; end
+
+  # @return [Hash{String=>Array<LibraryVersion>}] a map of libraries.
+  # @see LibraryVersion LibraryVersion for information on building a list of libraries
+  # @see #add_library
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/adapter.rb#32
+  def libraries=(_arg0); end
+
+  # @return [Hash] options passed and processed by adapters. The actual
+  #   options mostly depend on the adapters themselves.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/adapter.rb#36
+  def options; end
+
+  # @return [Hash] options passed and processed by adapters. The actual
+  #   options mostly depend on the adapters themselves.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/adapter.rb#36
+  def options=(_arg0); end
+
+  # @return [Router] the router object used to route URLs to commands
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/adapter.rb#43
+  def router; end
+
+  # @return [Router] the router object used to route URLs to commands
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/adapter.rb#43
+  def router=(_arg0); end
+
+  # @return [Hash] a set of options to pass to the server backend. Note
+  #   that +:DocumentRoot+ also sets the {#document_root}.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/adapter.rb#40
+  def server_options; end
+
+  # @return [Hash] a set of options to pass to the server backend. Note
+  #   that +:DocumentRoot+ also sets the {#document_root}.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/adapter.rb#40
+  def server_options=(_arg0); end
+
+  # Implement this method to connect your adapter to your server.
+  #
+  # @abstract
+  # @raise [NotImplementedError]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/adapter.rb#95
+  def start; end
+
+  class << self
+    # Performs any global initialization for the adapter.
+    #
+    # @note If you subclass this method, make sure to call +super+.
+    # @return [void]
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/adapter.rb#48
+    def setup; end
+
+    # Performs any global shutdown procedures for the adapter.
+    #
+    # @note If you subclass this method, make sure to call +super+.
+    # @return [void]
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/adapter.rb#56
+    def shutdown; end
+  end
+end
+
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/http_utils.rb#16
+YARD::Server::CR = T.let(T.unsafe(nil), String)
+
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/http_utils.rb#18
+YARD::Server::CRLF = T.let(T.unsafe(nil), String)
+
+# Commands implement specific kinds of server responses which are routed
+# to by the {Router} class. To implement a custom command, subclass {Commands::Base}.
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/autoload.rb#219
+module YARD::Server::Commands; end
+
+# This is the base command class used to implement custom commands for
+# a server. A command will be routed to by the {Router} class and return
+# a Rack-style response.
+#
+# == Attribute Initializers
+# All attributes can be initialized via options passed into the {#initialize}
+# method. When creating a custom command, the {Adapter#options} will
+# automatically be mapped to attributes by the same name on your class.
+#
+#   class MyCommand < Base
+#     attr_accessor :myattr
+#   end
+#
+#   Adapter.new(libs, {:myattr => 'foo'}).start
+#
+#   # when a request comes in, cmd.myattr == 'foo'
+#
+# == Subclassing Notes
+# To implement a custom command, override the {#run} method, not {#call}.
+# In your implementation, you should set the body and status for requests.
+# See details in the +#run+ method documentation.
+#
+# Note that if your command deals directly with libraries, you should
+# consider subclassing the more specific {LibraryCommand} class instead.
+#
+# @abstract
+# @see #run
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/commands/base.rb#34
+class YARD::Server::Commands::Base
+  # Creates a new command object, setting attributes named by keys
+  # in the options hash. After initialization, the options hash
+  # is saved in {#command_options} for further inspection.
+  #
+  # @example Creating a Command
+  #   cmd = DisplayObjectCommand.new(:caching => true, :library => mylib)
+  #   cmd.library # => mylib
+  #   cmd.command_options # => {:caching => true, :library => mylib}
+  # @param opts [Hash] the options hash, saved to {#command_options}
+  #   after initialization.
+  # @return [Base] a new instance of Base
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#75
+  def initialize(opts = T.unsafe(nil)); end
+
+  # @return [Adapter] the server adapter
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#41
+  def adapter; end
+
+  # @return [Adapter] the server adapter
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#41
+  def adapter=(_arg0); end
+
+  # @return [String] the response body. Defaults to empty string.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#61
+  def body; end
+
+  # @return [String] the response body. Defaults to empty string.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#61
+  def body=(_arg0); end
+
+  # @return [Boolean] whether to cache
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#44
+  def caching; end
+
+  # @return [Boolean] whether to cache
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#44
+  def caching=(_arg0); end
+
+  # The main method called by a router with a request object.
+  #
+  # @note This command should not be overridden by subclasses. Implement
+  #   the callback method {#run} instead.
+  # @param request [Adapter Dependent] the request object
+  # @return [Array(Numeric,Hash,Array<String>)] a Rack-style response
+  #   of status, headers, and body wrapped in an array.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#89
+  def call(request); end
+
+  # @return [Hash] the options passed to the command's constructor
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#38
+  def command_options; end
+
+  # @return [Hash] the options passed to the command's constructor
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#38
+  def command_options=(_arg0); end
+
+  # @return [Hash{String => String}] response headers
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#55
+  def headers; end
+
+  # @return [Hash{String => String}] response headers
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#55
+  def headers=(_arg0); end
+
+  # @return [String] the path after the command base URI
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#52
+  def path; end
+
+  # @return [String] the path after the command base URI
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#52
+  def path=(_arg0); end
+
+  # @return [Rack::Request] request object
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#49
+  def request; end
+
+  # @return [Rack::Request] request object
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#49
+  def request=(_arg0); end
+
+  # Subclass this method to implement a custom command. This method
+  # should set the {#status} and {#body}, and optionally modify the
+  # {#headers}. Note that +#status+ defaults to 200.
+  #
+  # @abstract
+  # @example A custom command
+  #   class ErrorCommand < Base
+  #   def run
+  #   self.body = 'ERROR! The System is down!'
+  #   self.status = 500
+  #   self.headers['Content-Type'] = 'text/plain'
+  #   end
+  #   end
+  # @raise [NotImplementedError]
+  # @return [void]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#128
+  def run; end
+
+  # @return [Numeric] status code. Defaults to 200 per request
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#58
+  def status; end
+
+  # @return [Numeric] status code. Defaults to 200 per request
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#58
+  def status=(_arg0); end
+
+  protected
+
+  # Override this method to implement custom caching mechanisms for
+  #
+  # @example Caching to memory
+  #   $memory_cache = {}
+  #   def cache(data)
+  #   $memory_cache[path] = data
+  #   end
+  # @param data [String] the data to cache
+  # @return [String] the same cached data (for chaining)
+  # @see StaticCaching
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#165
+  def cache(data); end
+
+  # Sets the body and headers for a 404 response. Does not modify the
+  # body if already set.
+  #
+  # @return [void]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#180
+  def not_found; end
+
+  # Sets the headers and status code for a redirection to a given URL
+  #
+  # @param url [String] the URL to redirect to
+  # @raise [FinishRequest] causes the request to terminate.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#192
+  def redirect(url); end
+
+  # Renders a specific object if provided, or a regular template rendering
+  # if object is not provided.
+  #
+  # @param object [CodeObjects::Base, nil] calls {CodeObjects::Base#format} if
+  #   an object is provided, or {Templates::Engine.render} if object is nil. Both
+  #   receive +#options+ as an argument.
+  # @return [String] the resulting output to display
+  # @since 0.6.0
+  # @todo This method is dependent on +#options+, it should be in {LibraryCommand}.
+  #
+  # source://yard//lib/yard/server/commands/base.rb#144
+  def render(object = T.unsafe(nil)); end
+
+  private
+
+  # Add a conservative cache control policy to reduce load on
+  # requests served with "?1234567890" style timestamp query strings.
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/base.rb#202
+  def add_cache_control; end
+end
+
+# Displays a README or extra file.
+#
+# @since 0.6.0
+# @todo Implement better support for detecting binary (image) filetypes
+#
+# source://yard//lib/yard/server/commands/display_file_command.rb#8
+class YARD::Server::Commands::DisplayFileCommand < ::YARD::Server::Commands::LibraryCommand
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/display_file_command.rb#9
+  def index; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/display_file_command.rb#9
+  def index=(_arg0); end
+
+  # @raise [NotFoundError]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/display_file_command.rb#11
+  def run; end
+end
+
+# Displays documentation for a specific object identified by the path
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/commands/display_object_command.rb#6
+class YARD::Server::Commands::DisplayObjectCommand < ::YARD::Server::Commands::LibraryCommand
+  include ::YARD::Server::DocServerHelper
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/display_object_command.rb#36
+  def index; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/display_object_command.rb#47
+  def not_found; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/display_object_command.rb#9
+  def run; end
+
+  private
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/display_object_command.rb#54
+  def object_path; end
+end
+
+# Displays an object wrapped in frames
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/commands/frames_command.rb#6
+class YARD::Server::Commands::FramesCommand < ::YARD::Server::Commands::DisplayObjectCommand
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/frames_command.rb#7
+  def run; end
+end
+
+# This is the base command for all commands that deal directly with libraries.
+# Some commands do not, but most (like {DisplayObjectCommand}) do. If your
+# command deals with libraries directly, subclass this class instead.
+# See {Base} for notes on how to subclass a command.
+#
+# @abstract
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/commands/library_command.rb#32
+class YARD::Server::Commands::LibraryCommand < ::YARD::Server::Commands::Base
+  # @return [LibraryCommand] a new instance of LibraryCommand
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#63
+  def initialize(opts = T.unsafe(nil)); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#68
+  def call(request); end
+
+  # @return [Boolean] whether to reparse data
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#53
+  def incremental; end
+
+  # @return [Boolean] whether to reparse data
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#53
+  def incremental=(_arg0); end
+
+  # @return [LibraryVersion] the object containing library information
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#41
+  def library; end
+
+  # @return [LibraryVersion] the object containing library information
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#41
+  def library=(_arg0); end
+
+  # @return [LibraryOptions] default options for the library
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#44
+  def options; end
+
+  # @return [LibraryOptions] default options for the library
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#44
+  def options=(_arg0); end
+
+  # @return [Serializers::Base] the serializer used to perform file linking
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#47
+  def serializer; end
+
+  # @return [Serializers::Base] the serializer used to perform file linking
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#47
+  def serializer=(_arg0); end
+
+  # @return [Boolean] whether router should route for multiple libraries
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#50
+  def single_library; end
+
+  # @return [Boolean] whether router should route for multiple libraries
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#50
+  def single_library=(_arg0); end
+
+  # @return [Boolean] whether or not this adapter calls +fork+ when serving
+  #   library requests. Defaults to false.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#57
+  def use_fork; end
+
+  # @return [Boolean] whether or not this adapter calls +fork+ when serving
+  #   library requests. Defaults to false.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#57
+  def use_fork=(_arg0); end
+
+  private
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#96
+  def call_with_fork(request, &block); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#83
+  def call_without_fork(request); end
+
+  # @return [Boolean]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#109
+  def can_fork?; end
+
+  # Hack to load a custom fulldoc template object that does
+  # not do any rendering/generation. We need this to access the
+  # generate_*_list methods.
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#171
+  def fulldoc_template; end
+
+  # @raise [LibraryNotPreparedError]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#147
+  def load_yardoc; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#159
+  def not_prepared; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#118
+  def restore_template_info; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#113
+  def save_default_template_info; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#123
+  def setup_library; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#130
+  def setup_yardopts; end
+end
+
+# source://yard//lib/yard/server/commands/library_command.rb#35
+YARD::Server::Commands::LibraryCommand::CAN_FORK = T.let(T.unsafe(nil), TrueClass)
+
+# Returns the index of libraries served by the server.
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/commands/library_index_command.rb#13
+class YARD::Server::Commands::LibraryIndexCommand < ::YARD::Server::Commands::Base
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_index_command.rb#14
+  def options; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_index_command.rb#14
+  def options=(_arg0); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_index_command.rb#16
+  def run; end
+end
+
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/commands/library_index_command.rb#5
+class YARD::Server::Commands::LibraryIndexOptions < ::YARD::CLI::YardocOptions
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_index_command.rb#6
+  def adapter; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_index_command.rb#6
+  def adapter=(_arg0); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_index_command.rb#6
+  def libraries; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_index_command.rb#6
+  def libraries=(_arg0); end
+
+  # source://yard//lib/yard/options.rb#82
+  def serialize; end
+
+  # source://yard//lib/yard/options.rb#82
+  def serialize=(_arg0); end
+
+  # source://yard//lib/yard/options.rb#82
+  def template; end
+
+  # source://yard//lib/yard/options.rb#82
+  def template=(_arg0); end
+
+  # source://yard//lib/yard/options.rb#82
+  def type; end
+
+  # source://yard//lib/yard/options.rb#82
+  def type=(_arg0); end
+end
+
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/commands/library_command.rb#7
+class YARD::Server::Commands::LibraryOptions < ::YARD::CLI::YardocOptions
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#8
+  def adapter; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#14
+  def command; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#14
+  def command=(_arg0); end
+
+  # @since 0.6.0
+  # @yield [:adapter, adapter]
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#17
+  def each(&block); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#15
+  def frames; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#15
+  def frames=(_arg0); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#9
+  def library; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#12
+  def serialize; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#11
+  def serializer; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/library_command.rb#10
+  def single_library; end
+end
+
+# Returns a list of objects of a specific type
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/commands/list_command.rb#6
+class YARD::Server::Commands::ListCommand < ::YARD::Server::Commands::LibraryCommand
+  include ::YARD::Templates::Helpers::BaseHelper
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/list_command.rb#9
+  def run; end
+end
+
+# Serves requests from the root of the server
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/commands/root_request_command.rb#6
+class YARD::Server::Commands::RootRequestCommand < ::YARD::Server::Commands::Base
+  include ::YARD::Server::HTTPUtils
+  include ::YARD::Server::Commands::StaticFileHelpers
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/root_request_command.rb#9
+  def run; end
+end
+
+# Performs a search over the objects inside of a library and returns
+# the results as HTML or plaintext
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/commands/search_command.rb#7
+class YARD::Server::Commands::SearchCommand < ::YARD::Server::Commands::LibraryCommand
+  include ::YARD::Templates::Helpers::BaseHelper
+  include ::YARD::Templates::Helpers::ModuleHelper
+  include ::YARD::Server::DocServerHelper
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/search_command.rb#12
+  def query; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/search_command.rb#12
+  def query=(_arg0); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/search_command.rb#12
+  def results; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/search_command.rb#12
+  def results=(_arg0); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/search_command.rb#14
+  def run; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/search_command.rb#26
+  def visible_results; end
+
+  private
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/search_command.rb#58
+  def search_for_object; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/search_command.rb#47
+  def serve_normal; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/search_command.rb#37
+  def serve_xhr; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/search_command.rb#32
+  def url_for(object); end
+end
+
+# Serves static content when no other router matches a request
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/commands/static_file_command.rb#6
+class YARD::Server::Commands::StaticFileCommand < ::YARD::Server::Commands::LibraryCommand
+  include ::YARD::Server::HTTPUtils
+  include ::YARD::Server::Commands::StaticFileHelpers
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/static_file_command.rb#17
+  def run; end
+end
+
+# Defines the paths used to search for static assets. To define an
+# extra path, use {YARD::Server.register_static_path} rather than
+# modifying this constant directly. Also note that files in the
+# document root will always take precedence over these paths.
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/commands/static_file_command.rb#15
+YARD::Server::Commands::StaticFileCommand::STATIC_PATHS = T.let(T.unsafe(nil), Array)
+
+# Include this module to get access to {#static_template_file?}
+# and {favicon?} helpers.
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/commands/static_file_helpers.rb#8
+module YARD::Server::Commands::StaticFileHelpers
+  include ::YARD::Server::HTTPUtils
+
+  # Serves an empty favicon.
+  #
+  # @raise [FinishRequest] finalizes an empty body if the path matches
+  #   /favicon.ico so browsers don't complain.
+  # @return [Boolean]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/static_file_helpers.rb#14
+  def favicon?; end
+
+  # Attempts to route a path to a static template file.
+  #
+  # @raise [FinishRequest] if a file was found and served
+  # @return [void]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/static_file_helpers.rb#26
+  def static_template_file?; end
+
+  private
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/commands/static_file_helpers.rb#42
+  def find_file(adapter, url); end
+
+  class << self
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/commands/static_file_helpers.rb#42
+    def find_file(adapter, url); end
+  end
+end
+
+# A module that is mixed into {Templates::Template} in order to customize
+# certain template methods.
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/doc_server_helper.rb#6
+module YARD::Server::DocServerHelper
+  # @param path_components [Array<String>] components of a URL
+  # @return [String] the absolute path from any mounted base URI.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/doc_server_helper.rb#61
+  def abs_url(*path_components); end
+
+  # @example The base path for a library 'foo'
+  #   base_path('docs') # => 'docs/foo'
+  # @param path [String] the path prefix for a base path URI
+  # @return [String] the base URI for a library with an extra +path+ prefix
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/doc_server_helper.rb#69
+  def base_path(path); end
+
+  # @return [String] a timestamp for a given file
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/doc_server_helper.rb#78
+  def mtime(file); end
+
+  # @return [String] a URL for a file with a timestamp
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/doc_server_helper.rb#84
+  def mtime_url(file); end
+
+  # @return [Router] convenience method for accessing the router
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/doc_server_helper.rb#75
+  def router; end
+
+  # Modifies {Templates::Helpers::HtmlHelper#url_for} to return a URL instead
+  # of a disk location.
+  #
+  # @param obj [String, CodeObjects::Base] the object (or object path) to link to
+  # @param anchor [String] the anchor to link to
+  # @param relative [Boolean] use a relative or absolute link
+  # @return [String] the URL location of the object
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/doc_server_helper.rb#11
+  def url_for(obj, anchor = T.unsafe(nil), relative = T.unsafe(nil)); end
+
+  # Modifies {Templates::Helpers::HtmlHelper#url_for_file} to return a URL instead
+  # of a disk location.
+  #
+  # @param filename [String, CodeObjects::ExtraFileObject] the filename to link to
+  # @param anchor [String] optional anchor
+  # @return [String] the URL pointing to the file
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/doc_server_helper.rb#24
+  def url_for_file(filename, anchor = T.unsafe(nil)); end
+
+  # Returns the frames URL for the page
+  #
+  # @return [String] the URL pointing to the frames page
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/doc_server_helper.rb#43
+  def url_for_frameset; end
+
+  # Returns the URL for the alphabetic index page
+  #
+  # @return [String] the URL pointing to the first main page the
+  #   user should see.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/doc_server_helper.rb#55
+  def url_for_index; end
+
+  # Modifies {Templates::Helpers::HtmlHelper#url_for_list} to return a URL
+  # based on the list prefix instead of a HTML filename.
+  #
+  # @param type [String, Symbol] the list type to generate a URL for
+  # @return [String] the URL pointing to the list
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/doc_server_helper.rb#37
+  def url_for_list(type); end
+
+  # Returns the main URL, first checking a readme and then linking to the index
+  #
+  # @return [String] the URL pointing to the first main page the
+  #   user should see.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/doc_server_helper.rb#49
+  def url_for_main; end
+end
+
+# A custom {Serializers::Base serializer} which returns resource URLs instead of
+# static relative paths to files on disk.
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/doc_server_serializer.rb#6
+class YARD::Server::DocServerSerializer < ::YARD::Serializers::FileSystemSerializer
+  # @return [DocServerSerializer] a new instance of DocServerSerializer
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/doc_server_serializer.rb#7
+  def initialize(_command = T.unsafe(nil)); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/doc_server_serializer.rb#11
+  def serialized_path(object); end
+
+  private
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/doc_server_serializer.rb#31
+  def urlencode(name); end
+end
+
+# Short circuits a request by raising an error. This exception is caught
+# by {Commands::Base#call} to immediately end a request and return a response.
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/adapter.rb#6
+class YARD::Server::FinishRequest < ::RuntimeError; end
+
+# HTTPUtils provides utility methods for working with the HTTP protocol.
+#
+# This module is generally used internally by WEBrick
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/http_utils.rb#25
+module YARD::Server::HTTPUtils
+  private
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#443
+  def _escape(str, regex); end
+
+  # :stopdoc:
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#441
+  def _make_regex(str); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#442
+  def _make_regex!(str); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#449
+  def _unescape(str, regex); end
+
+  # Removes quotes and escapes from +str+
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#223
+  def dequote(str); end
+
+  # Escapes HTTP reserved and unwise characters in +str+
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#467
+  def escape(str); end
+
+  # Escapes 8 bit characters in +str+
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#508
+  def escape8bit(str); end
+
+  # Escapes form reserved characters in +str+
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#481
+  def escape_form(str); end
+
+  # Escapes path +str+
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#497
+  def escape_path(str); end
+
+  # Loads Apache-compatible mime.types in +file+.
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#112
+  def load_mime_types(file); end
+
+  # Returns the mime type of +filename+ from the list in +mime_tab+.  If no
+  # mime type was found application/octet-stream is returned.
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#134
+  def mime_type(filename, mime_tab); end
+
+  # Normalizes a request path.  Raises an exception if the path cannot be
+  # normalized.
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#31
+  def normalize_path(path); end
+
+  # Parses form data in +io+ with the given +boundary+
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#395
+  def parse_form_data(io, boundary); end
+
+  # Parses an HTTP header +raw+ into a hash of header fields with an Array
+  # of values.
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#145
+  def parse_header(raw); end
+
+  # Parses the query component of a URI in +str+
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#371
+  def parse_query(str); end
+
+  # Parses q values in +value+ as used in Accept headers.
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#202
+  def parse_qvalues(value); end
+
+  # Parses a Range header value +ranges_specifier+
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#184
+  def parse_range_header(ranges_specifier); end
+
+  # Quotes and escapes quotes in +str+
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#233
+  def quote(str); end
+
+  # Splits a header value +str+ according to HTTP specification.
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#175
+  def split_header_value(str); end
+
+  # Unescapes HTTP reserved and unwise characters in +str+
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#474
+  def unescape(str); end
+
+  # Unescapes form reserved characters in +str+
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#490
+  def unescape_form(str); end
+
+  class << self
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#443
+    def _escape(str, regex); end
+
+    # :stopdoc:
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#441
+    def _make_regex(str); end
+
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#442
+    def _make_regex!(str); end
+
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#449
+    def _unescape(str, regex); end
+
+    # Removes quotes and escapes from +str+
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#223
+    def dequote(str); end
+
+    # Escapes HTTP reserved and unwise characters in +str+
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#467
+    def escape(str); end
+
+    # Escapes 8 bit characters in +str+
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#508
+    def escape8bit(str); end
+
+    # Escapes form reserved characters in +str+
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#481
+    def escape_form(str); end
+
+    # Escapes path +str+
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#497
+    def escape_path(str); end
+
+    # Loads Apache-compatible mime.types in +file+.
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#112
+    def load_mime_types(file); end
+
+    # Returns the mime type of +filename+ from the list in +mime_tab+.  If no
+    # mime type was found application/octet-stream is returned.
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#134
+    def mime_type(filename, mime_tab); end
+
+    # Normalizes a request path.  Raises an exception if the path cannot be
+    # normalized.
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#31
+    def normalize_path(path); end
+
+    # Parses form data in +io+ with the given +boundary+
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#395
+    def parse_form_data(io, boundary); end
+
+    # Parses an HTTP header +raw+ into a hash of header fields with an Array
+    # of values.
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#145
+    def parse_header(raw); end
+
+    # Parses the query component of a URI in +str+
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#371
+    def parse_query(str); end
+
+    # Parses q values in +value+ as used in Accept headers.
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#202
+    def parse_qvalues(value); end
+
+    # Parses a Range header value +ranges_specifier+
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#184
+    def parse_range_header(ranges_specifier); end
+
+    # Quotes and escapes quotes in +str+
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#233
+    def quote(str); end
+
+    # Splits a header value +str+ according to HTTP specification.
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#175
+    def split_header_value(str); end
+
+    # Unescapes HTTP reserved and unwise characters in +str+
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#474
+    def unescape(str); end
+
+    # Unescapes form reserved characters in +str+
+    #
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/server/http_utils.rb#490
+    def unescape_form(str); end
+  end
+end
+
+# Default mime types
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/http_utils.rb#47
+YARD::Server::HTTPUtils::DefaultMimeTypes = T.let(T.unsafe(nil), Hash)
+
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/http_utils.rb#459
+YARD::Server::HTTPUtils::ESCAPED = T.let(T.unsafe(nil), Regexp)
+
+# Stores multipart form data.  FormData objects are created when
+# WEBrick::HTTPUtils.parse_form_data is called.
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/http_utils.rb#242
+class YARD::Server::HTTPUtils::FormData < ::String
+  # Creates a new FormData object.
+  #
+  # +args+ is an Array of form data entries.  One FormData will be created
+  # for each entry.
+  #
+  # This is called by WEBrick::HTTPUtils.parse_form_data for you
+  #
+  # @return [FormData] a new instance of FormData
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#267
+  def initialize(*args); end
+
+  # Adds +str+ to this FormData which may be the body, a header or a
+  # header entry.
+  #
+  # This is called by WEBrick::HTTPUtils.parse_form_data for you
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#300
+  def <<(str); end
+
+  # Retrieves the header at the first entry in +key+
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#286
+  def [](*key); end
+
+  # Adds +data+ at the end of the chain of entries
+  #
+  # This is called by WEBrick::HTTPUtils.parse_form_data for you.
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#320
+  def append_data(data); end
+
+  # Yields each entry in this FormData
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#335
+  def each_data; end
+
+  # The filename of the form data part
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#254
+  def filename; end
+
+  # The filename of the form data part
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#254
+  def filename=(_arg0); end
+
+  # Returns all the FormData as an Array
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#347
+  def list; end
+
+  # The name of the form data part
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#249
+  def name; end
+
+  # The name of the form data part
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#249
+  def name=(_arg0); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#256
+  def next_data=(_arg0); end
+
+  # Returns all the FormData as an Array
+  # A FormData will behave like an Array
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#347
+  def to_ary; end
+
+  # This FormData's body
+  #
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#363
+  def to_s; end
+
+  protected
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/http_utils.rb#256
+  def next_data; end
+end
+
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/http_utils.rb#244
+YARD::Server::HTTPUtils::FormData::EmptyHeader = T.let(T.unsafe(nil), Hash)
+
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/http_utils.rb#243
+YARD::Server::HTTPUtils::FormData::EmptyRawHeader = T.let(T.unsafe(nil), Array)
+
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/http_utils.rb#458
+YARD::Server::HTTPUtils::NONASCII = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/http_utils.rb#456
+YARD::Server::HTTPUtils::UNESCAPED = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/http_utils.rb#457
+YARD::Server::HTTPUtils::UNESCAPED_FORM = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/http_utils.rb#460
+YARD::Server::HTTPUtils::UNESCAPED_PCHAR = T.let(T.unsafe(nil), Regexp)
+
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/http_utils.rb#17
+YARD::Server::LF = T.let(T.unsafe(nil), String)
+
+# This exception is raised when {LibraryVersion#prepare!} fails, or discovers
+# that the library is not "prepared" to be served by
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/library_version.rb#9
+class YARD::Server::LibraryNotPreparedError < ::RuntimeError; end
+
+# A library version encapsulates a library's documentation at a specific version.
+# Although the version is optional, this allows for creating multiple documentation
+# points for a specific library, each representing a unique version. The term
+# "library" used in other parts of the YARD::Server documentation refers to
+# objects of this class unless otherwise noted.
+#
+# A library points to a location where a {#yardoc_file} is located so that
+# its documentation may be loaded and served. Optionally, a {#source_path} is
+# given to point to a location where any extra files (and {YARD::CLI::Yardoc .yardopts})
+# should be loaded from. Both of these methods may not be known immediately,
+# since the yardoc file may not be built until later. Resolving the yardoc
+# file and source path are dependent on the specific library "source type" used.
+# Source types (known as "library source") are discussed in detail below.
+#
+# == Using with Adapters
+# A list of libraries need to be passed into adapters upon creation. In
+# most cases, you will never do this manually, but if you use a {RackMiddleware},
+# you will need to pass in this list yourself. To build this list of libraries,
+# you should create a hash of library names mapped to an *Array* of LibraryVersion
+# objects. For example:
+#
+#   {'mylib' => [LibraryVersion.new('mylib', '1.0', ...),
+#                LibraryVersion.new('mylib', '2.0', ...)]}
+#
+# Note that you can also use {Adapter#add_library} for convenience.
+#
+# The "array" part is required, even for just one library version.
+#
+# == Library Sources
+# The {#source} method represents the library source type, ie. where the
+# library "comes from". It might come from "disk", or it might come from a
+# "gem" (technically the disk, but a separate type nonetheless). In these
+# two cases, the yardoc file sits somewhere on your filesystem, though
+# it may also be built dynamically if it does not yet exist. This behaviour
+# is controlled through the {#prepare!} method, which prepares the yardoc file
+# given a specific library source. We will see how this works in detail in
+# the following section.
+#
+# == Implementing a Custom Library Source
+# YARD can be extended to support custom library sources in order to
+# build or retrieve a yardoc file at runtime from many different locations.
+#
+# To implement this behaviour, 3 methods can be added to the +LibraryVersion+
+# class, +#load_yardoc_from_SOURCE+, +#yardoc_file_for_SOURCE+, and
+# +#source_path_for_SOURCE+. In all cases, "SOURCE" represents the source
+# type used in {#source} when creating the library object. The
+# +#yardoc_file_for_SOURCE+ and +#source_path_for_SOURCE+ methods are called upon
+# creation and should return the location where the source code for the library
+# lives. The load method is called from {#prepare!} if there is no yardoc file
+# and should set {#yardoc_file}. Below is a full example for
+# implementing a custom library source, +:http+, which reads packaged .yardoc
+# databases from zipped archives off of an HTTP server.
+#
+# Note that only +#load_yardoc_from_SOURCE+ is required. The other two
+# methods are optional and can be set manually (via {#source_path=} and
+# {#yardoc_file=}) on the object at any time.
+#
+# @example Implementing a Custom Library Source
+#   # Adds the source type "http" for .yardoc files zipped on HTTP servers
+#   class LibraryVersion
+#   def load_yardoc_from_http
+#   Thread.new do
+#   # zip/unzip method implementations are not shown
+#   download_zip_file("http://mysite.com/yardocs/#{self}.zip")
+#   unzip_file_to("/path/to/yardocs/#{self}")
+#   end
+#
+#   # tell the server it's not ready yet (but it might be next time)
+#   raise LibraryNotPreparedError
+#   end
+#
+#   def yardoc_file_for_http
+#   "/path/to/yardocs/#{self}/.yardoc"
+#   end
+#
+#   def source_path_for_http
+#   File.dirname(yardoc_file)
+#   end
+#   end
+#
+#   # Creating a library of this source type:
+#   LibraryVersion.new('name', '1.0', nil, :http)
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/library_version.rb#94
+class YARD::Server::LibraryVersion
+  # @param name [String] the name of the library
+  # @param version [String] the specific (usually, but not always, numeric) library
+  #   version
+  # @param yardoc [String] the location of the yardoc file, or nil if it is
+  #   generated later
+  # @param source [Symbol] the location of the files used to build the yardoc.
+  #   Builtin source types are +:disk+ or +:gem+.
+  # @return [LibraryVersion] a new instance of LibraryVersion
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#134
+  def initialize(name, version = T.unsafe(nil), yardoc = T.unsafe(nil), source = T.unsafe(nil)); end
+
+  # @return [Boolean] whether another LibraryVersion is equal to this one
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#153
+  def ==(other); end
+
+  # @return [Boolean] whether another LibraryVersion is equal to this one
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#153
+  def eql?(other); end
+
+  # @return [Boolean] whether another LibraryVersion is equal to this one
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#153
+  def equal?(other); end
+
+  # @return [Gem::Specification] a gemspec object for a given library. Used
+  #   for :gem source types.
+  # @return [nil] if there is no installed gem for the library
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#191
+  def gemspec; end
+
+  # @return [Fixnum] used for Hash mapping.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#150
+  def hash; end
+
+  # @return [String] the name of the library
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#96
+  def name; end
+
+  # @return [String] the name of the library
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#96
+  def name=(_arg0); end
+
+  # Prepares a library to be displayed by the server. This callback is
+  # performed before each request on a library to ensure that it is loaded
+  # and ready to be viewed. If any steps need to be performed prior to loading,
+  # they are performed through this method (though they should be implemented
+  # through the +load_yardoc_from_SOURCE+ method).
+  #
+  # @note You should not directly override this method. Instead, implement
+  #   +load_yardoc_from_SOURCENAME+ when implementing loading for a specific
+  #   source type. See the {LibraryVersion} documentation for "Implementing
+  #   a Custom Library Source"
+  # @raise [LibraryNotPreparedError] if the library is not ready to be
+  #   displayed. Usually when raising this error, you would simultaneously
+  #   begin preparing the library for subsequent requests, although this
+  #   is not necessary.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#182
+  def prepare!; end
+
+  # @return [Boolean] whether the library has been completely processed
+  #   and is ready to be served
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#162
+  def ready?; end
+
+  # @return [Symbol] the source type representing where the yardoc should be
+  #   loaded from. Defaults are +:disk+ and +:gem+, though custom sources
+  #   may be implemented. This value is used to inform {#prepare!} about how
+  #   to load the necessary data in order to display documentation for an object.
+  # @see LibraryVersion LibraryVersion documentation for "Implementing a Custom Library Source"
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#116
+  def source; end
+
+  # @return [Symbol] the source type representing where the yardoc should be
+  #   loaded from. Defaults are +:disk+ and +:gem+, though custom sources
+  #   may be implemented. This value is used to inform {#prepare!} about how
+  #   to load the necessary data in order to display documentation for an object.
+  # @see LibraryVersion LibraryVersion documentation for "Implementing a Custom Library Source"
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#116
+  def source=(_arg0); end
+
+  # @return [String] the location of the source code for a library. This
+  #   value is filled by calling +#source_path_for_SOURCE+ on this class.
+  # @return [nil] if there is no source code
+  # @see LibraryVersion LibraryVersion documentation for "Implementing a Custom Library Source"
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#122
+  def source_path; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#125
+  def source_path=(_arg0); end
+
+  # @param url_format [Boolean] if true, returns the string in a URI-compatible
+  #   format (for appending to a URL). Otherwise, it is given in a more human
+  #   readable format.
+  # @return [String] the string representation of the library.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#145
+  def to_s(url_format = T.unsafe(nil)); end
+
+  # @return [String] the version of the specific library
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#99
+  def version; end
+
+  # @return [String] the version of the specific library
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#99
+  def version=(_arg0); end
+
+  # @note To implement a custom yardoc file getter, implement
+  # @return [String] the location of the yardoc file used to load the object
+  #   information from.
+  # @return [nil] if no yardoc file exists yet. In this case, {#prepare!} will
+  #   be called on this library to build the yardoc file.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#106
+  def yardoc_file; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#109
+  def yardoc_file=(_arg0); end
+
+  protected
+
+  # Called when a library of source type "disk" is to be prepared. In this
+  # case, the {#yardoc_file} should already be set, but the library may not
+  # be prepared. Run preparation if not done.
+  #
+  # @raise [LibraryNotPreparedError] if the yardoc file has not been
+  #   prepared.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#206
+  def load_yardoc_from_disk; end
+
+  # Called when a library of source type "gem" is to be prepared. In this
+  # case, the {#yardoc_file} needs to point to the correct location for
+  # the installed gem. The yardoc file is built if it has not been done.
+  #
+  # @raise [LibraryNotPreparedError] if the gem does not have an existing
+  #   yardoc file.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#226
+  def load_yardoc_from_gem; end
+
+  # @return [String] the source path for a disk source
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#243
+  def source_path_for_disk; end
+
+  # @return [String] the source path for a gem source
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#248
+  def source_path_for_gem; end
+
+  # @return [String] the yardoc file for a gem source
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#253
+  def yardoc_file_for_gem; end
+
+  private
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#261
+  def load_source_path; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#266
+  def load_yardoc_file; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/library_version.rb#271
+  def serializer; end
+end
+
+# Raises an error if a resource is not found. This exception is caught by
+# {Commands::Base#call} to immediately end a request and return a 404 response
+# code. If a message is provided, the body is set to the exception message.
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/adapter.rb#11
+class YARD::Server::NotFoundError < ::RuntimeError; end
+
+# A router class implements the logic used to recognize a request for a specific
+# URL and run specific {Commands::Base commands}.
+#
+# == Subclassing Notes
+# To create a custom router, subclass this class and pass it into the adapter
+# options through {Adapter#initialize} or by directly modifying {Adapter#router}.
+#
+# The most general customization is to change the URL prefixes recognized by
+# routing, which can be done by overriding {#docs_prefix}, {#list_prefix},
+# {#static_prefix}, and {#search_prefix}.
+#
+# == Implementing Custom Caching
+# By default, the Router class performs static disk-based caching on all
+# requests through the +#check_static_cache+. To override this behaviour,
+# or create your own caching mechanism, mixin your own custom module with
+# this method implemented as per {StaticCaching#check_static_cache}.
+#
+# @example Creating a subclassed router
+#   # Adds 'my' to all routing prefixes
+#   class MyRouter < YARD::Server::Router
+#   def docs_prefix; 'mydocs' end
+#   def list_prefix; 'mylist' end
+#   def static_prefix; 'mystatic' end
+#   def search_prefix; 'mysearch' end
+#   end
+#
+#   # Using it:
+#   WebrickAdapter.new(libraries, :router => MyRouter).start
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/router.rb#32
+class YARD::Server::Router
+  include ::YARD::Server::StaticCaching
+  include ::YARD::Server::Commands
+
+  # Creates a new router for a specific adapter
+  #
+  # @param adapter [Adapter] the adapter to route requests to
+  # @return [Router] a new instance of Router
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#45
+  def initialize(adapter); end
+
+  # @return [Adapter] the adapter used by the router
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#40
+  def adapter; end
+
+  # @return [Adapter] the adapter used by the router
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#40
+  def adapter=(_arg0); end
+
+  # Perform routing on a specific request, serving the request as a static
+  # file through {Commands::RootRequestCommand} if no route is found.
+  #
+  # @param request [Adapter Dependent] the request object
+  # @return [Array(Numeric,Hash,Array)] the Rack-style server response data
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#54
+  def call(request); end
+
+  # @return [String] the URI prefix for all object documentation requests
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#63
+  def docs_prefix; end
+
+  # @return [String] the URI prefix for all class/method/file list requests
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#66
+  def list_prefix; end
+
+  # @return [Array(LibraryVersion, Array<String>)] the library followed
+  #   by the rest of the path components in the request path. LibraryVersion
+  #   will be nil if no matching library was found.
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#79
+  def parse_library_from_path(paths); end
+
+  # @return [Adapter Dependent] the request data coming in with the routing
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#37
+  def request; end
+
+  # @return [Adapter Dependent] the request data coming in with the routing
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#37
+  def request=(_arg0); end
+
+  # @return [String] the URI prefix for all search requests
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#69
+  def search_prefix; end
+
+  # @return [String] the URI prefix for all static assets (templates)
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#72
+  def static_prefix; end
+
+  protected
+
+  # Adds extra :library/:path option keys to the adapter options.
+  # Use this method when passing options to a command.
+  #
+  # @param library [LibraryVersion] the library to route for
+  # @param paths [Array<String>] path components (split by '/')
+  # @return [Hash] finalized options
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#181
+  def final_options(library, paths); end
+
+  # Performs routing algorithm to find which prefix is called, first
+  # parsing out library name/version information.
+  #
+  # @return [Array(Numeric,Hash,Array<String>)] the Rack-style response
+  # @return [nil] if no route is matched
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#105
+  def route(path = T.unsafe(nil)); end
+
+  # Routes requests from {#docs_prefix} and calls the appropriate command
+  #
+  # @param library [LibraryVersion] the library to route for
+  # @param paths [Array<String>] path components (split by '/')
+  # @return [Array(Numeric,Hash,Array<String>)] the Rack-style response
+  # @return [nil] if no route is matched
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#128
+  def route_docs(library, paths); end
+
+  # Routes for the index of a library / multiple libraries
+  #
+  # @return [Array(Numeric,Hash,Array<String>)] the Rack-style response
+  # @return [nil] if no route is matched
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#146
+  def route_index; end
+
+  # Routes requests from {#list_prefix} and calls the appropriate command
+  #
+  # @param library [LibraryVersion] the library to route for
+  # @param paths [Array<String>] path components (split by '/')
+  # @return [Array(Numeric,Hash,Array<String>)] the Rack-style response
+  # @return [nil] if no route is matched
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#157
+  def route_list(library, paths); end
+
+  # Routes requests from {#search_prefix} and calls the appropriate command
+  #
+  # @param library [LibraryVersion] the library to route for
+  # @param paths [Array<String>] path components (split by '/')
+  # @return [Array(Numeric,Hash,Array<String>)] the Rack-style response
+  # @return [nil] if no route is matched
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#165
+  def route_search(library, paths); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/router.rb#170
+  def route_static(library, paths); end
+end
+
+# Implements static caching for requests.
+#
+# @see Router Router documentation for "Caching"
+# @since 0.6.0
+#
+# source://yard//lib/yard/server/static_caching.rb#7
+module YARD::Server::StaticCaching
+  # Called by a router to return the cached object. By default, this
+  # method performs disk-based caching. To perform other forms of caching,
+  # implement your own +#check_static_cache+ method and mix the module into
+  # the Router class.
+  #
+  # Note that caching does not occur here. This method simply checks for
+  # the existence of cached data. To actually cache a response, see
+  # {Commands::Base#cache}.
+  #
+  # @example Implementing In-Memory Cache Checking
+  #   module MemoryCaching
+  #   def check_static_cache
+  #   # $memory_cache is filled by {Commands::Base#cache}
+  #   cached_data = $memory_cache[request.path]
+  #   if cached_data
+  #   [200, {'Content-Type' => 'text/html'}, [cached_data]]
+  #   else
+  #   nil
+  #   end
+  #   end
+  #   end
+  #
+  #   class YARD::Server::Router; include MemoryCaching; end
+  # @return [Array(Numeric,Hash,Array)] the Rack-style response
+  # @return [nil] if no cache is available and routing should continue
+  # @see Commands::Base#cache
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/server/static_caching.rb#34
+  def check_static_cache; end
+end
+
+# Stubs marshal dumps and acts a delegate class for an object by path
+#
+# @private
+#
+# source://yard//lib/yard/serializers/yardoc_serializer.rb#6
+class YARD::StubProxy
+  # @return [StubProxy] a new instance of StubProxy
+  #
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#13
+  def initialize(path, transient = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#9
+  def _dump(_depth); end
+
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#11
+  def hash; end
+
+  # source://yard//lib/yard/serializers/yardoc_serializer.rb#18
+  def method_missing(meth, *args, &block); end
+
+  class << self
+    # source://yard//lib/yard/serializers/yardoc_serializer.rb#10
+    def _load(str); end
+  end
+end
+
+# source://yard//lib/yard/serializers/yardoc_serializer.rb#28
+YARD::StubProxy::FILELEN = T.let(T.unsafe(nil), Integer)
+
+# The root path for YARD builtin templates
+#
+# source://yard//lib/yard.rb#10
+YARD::TEMPLATE_ROOT = T.let(T.unsafe(nil), String)
+
+# Namespace for Tag components
+#
+# source://yard//lib/yard/autoload.rb#248
+module YARD::Tags; end
+
+# Defines an attribute with a given name, using indented block data as the
+# attribute's docstring. If the type specifier is supplied with "r", "w", or
+# "rw", the attribute is made readonly, writeonly or readwrite respectively.
+# A readwrite attribute is the default, if no type is specified. The comment
+# containing this directive does not need to be attached to any source, but
+# if it is, that source code will be used as the method's source.
+#
+# To define a regular method, see {tag:!method}
+#
+# @example Defining a simple readonly attribute
+#   # @!attribute [r] count
+#   #   @return [Fixnum] the size of the list
+# @example Defining a simple readwrite attribute
+#   # @!attribute name
+#   #   @return [String] the name of the user
+# @note This directive should only be used if there is no explicit +attr_*+
+#   declaration for the attribute in any source files (i.e., the attribute
+#   is declared dynamically via meta-programming). In all other cases, add
+#   documentation to the attribute declaration itself.
+# @note For backwards compatibility support, you do not need to indent
+#   the attribute's docstring text. If an +@!attribute+ directive is seen with
+#   no indented block, the entire docstring is used as the new attribute's
+#   docstring text.
+# @see tag:!method
+# @since 0.7.0
+#
+# source://yard//lib/yard/tags/directives.rb#460
+class YARD::Tags::AttributeDirective < ::YARD::Tags::MethodDirective
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#461
+  def after_parse; end
+
+  protected
+
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#469
+  def method_name; end
+
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#475
+  def method_signature; end
+
+  private
+
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#485
+  def create_attribute_data(object); end
+
+  # @return [Boolean]
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#515
+  def readable?; end
+
+  # @return [Boolean]
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#511
+  def writable?; end
+end
+
+# source://yard//lib/yard/tags/default_factory.rb#4
+class YARD::Tags::DefaultFactory
+  # Parses tag text and creates a new tag with descriptive text
+  #
+  # @param tag_name the name of the tag to parse
+  # @param text [String] the raw tag text
+  # @return [Tag] a tag object with the tag_name and text values filled
+  #
+  # source://yard//lib/yard/tags/default_factory.rb#13
+  def parse_tag(tag_name, text); end
+
+  # Parses tag text and creates a new tag with a key name and descriptive text
+  #
+  # @param tag_name the name of the tag to parse
+  # @param text [String] the raw tag text
+  # @return [Tag] a tag object with the tag_name, name and text values filled
+  #
+  # source://yard//lib/yard/tags/default_factory.rb#22
+  def parse_tag_with_name(tag_name, text); end
+
+  # source://yard//lib/yard/tags/default_factory.rb#89
+  def parse_tag_with_options(tag_name, text); end
+
+  # source://yard//lib/yard/tags/default_factory.rb#70
+  def parse_tag_with_title_and_text(tag_name, text); end
+
+  # Parses tag text and creates a new tag with formally declared types and
+  # descriptive text
+  #
+  # @param tag_name the name of the tag to parse
+  # @param text [String] the raw tag text
+  # @raise [TagFormatError]
+  # @return [Tag] a tag object with the tag_name, types and text values filled
+  #
+  # source://yard//lib/yard/tags/default_factory.rb#33
+  def parse_tag_with_types(tag_name, text); end
+
+  # Parses tag text and creates a new tag with formally declared types, a key
+  # name and descriptive text
+  #
+  # @param tag_name the name of the tag to parse
+  # @param text [String] the raw tag text
+  # @return [Tag] a tag object with the tag_name, name, types and text values filled
+  #
+  # source://yard//lib/yard/tags/default_factory.rb#45
+  def parse_tag_with_types_and_name(tag_name, text); end
+
+  # Parses tag text and creates a new tag with formally declared types, a title
+  # on the first line and descriptive text
+  #
+  # @param tag_name the name of the tag to parse
+  # @param text [String] the raw tag text
+  # @return [Tag] a tag object with the tag_name, name, types and text values filled
+  #
+  # source://yard//lib/yard/tags/default_factory.rb#57
+  def parse_tag_with_types_and_title(tag_name, text); end
+
+  # source://yard//lib/yard/tags/default_factory.rb#75
+  def parse_tag_with_types_name_and_default(tag_name, text); end
+
+  private
+
+  # Extracts the name from raw tag text returning the name and remaining value
+  #
+  # @param text [String] the raw tag text
+  # @return [Array] an array holding the name as the first element and the
+  #   value as the second element
+  #
+  # source://yard//lib/yard/tags/default_factory.rb#101
+  def extract_name_from_text(text); end
+
+  # @raise [TagFormatError]
+  #
+  # source://yard//lib/yard/tags/default_factory.rb#105
+  def extract_title_and_desc_from_text(text); end
+
+  # Parses a [], <>, {} or () block at the beginning of a line of text
+  # into a list of comma delimited values.
+  #
+  # @example
+  #   obj.parse_types('[String, Array<Hash, String>, nil]') # => [nil, ['String', 'Array<Hash, String>', 'nil'], ""]
+  #   obj.parse_types('b<String> A string') # => ['b', ['String'], 'A string']
+  # @return [Array(String, Array<String>, String)] the text before the type
+  #   list (or nil), followed by the type list parsed into an array of
+  #   strings, followed by the text following the type list.
+  #
+  # source://yard//lib/yard/tags/default_factory.rb#129
+  def extract_types_and_name_from_text(text, opening_types = T.unsafe(nil), closing_types = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/tags/default_factory.rb#138
+  def extract_types_and_name_from_text_unstripped(text, opening_types = T.unsafe(nil), closing_types = T.unsafe(nil)); end
+end
+
+# source://yard//lib/yard/tags/default_factory.rb#6
+YARD::Tags::DefaultFactory::TYPELIST_CLOSING_CHARS = T.let(T.unsafe(nil), String)
+
+# source://yard//lib/yard/tags/default_factory.rb#5
+YARD::Tags::DefaultFactory::TYPELIST_OPENING_CHARS = T.let(T.unsafe(nil), String)
+
+# source://yard//lib/yard/tags/default_tag.rb#4
+class YARD::Tags::DefaultTag < ::YARD::Tags::Tag
+  # @return [DefaultTag] a new instance of DefaultTag
+  #
+  # source://yard//lib/yard/tags/default_tag.rb#7
+  def initialize(tag_name, text, types = T.unsafe(nil), name = T.unsafe(nil), defaults = T.unsafe(nil)); end
+
+  # Returns the value of attribute defaults.
+  #
+  # source://yard//lib/yard/tags/default_tag.rb#5
+  def defaults; end
+end
+
+# The base directive class. Subclass this class to create a custom
+# directive, registering it with {Library.define_directive}. Directive
+# classes are executed via the {#call} method, which perform all directive
+# processing on the object.
+#
+# If processing occurs within a handler, the {#handler} attribute is
+# available to access more information about parsing context and state.
+# Handlers are only available when parsing from {Parser::SourceParser},
+# not when parsing directly from {DocstringParser}. If the docstring is
+# attached to an object declaration, {#object} will be set and available
+# to modify the generated code object directly. Note that both of these
+# attributes may be nil, and directives should test their existence
+# before attempting to use them.
+#
+# @abstract Subclasses should implement {#call}.
+# @see Library.define_directive
+# @since 0.8.0
+#
+# source://yard//lib/yard/tags/directives.rb#22
+class YARD::Tags::Directive
+  # @param tag [Tag] the meta-data tag containing all input to the docstring
+  # @param parser [DocstringParser] the docstring parser object
+  # @return [Directive] a new instance of Directive
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#54
+  def initialize(tag, parser); end
+
+  # Called after parsing all directives and tags in the docstring. Used
+  # to perform any cleanup after all directives perform their main task.
+  #
+  # @return [void]
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#73
+  def after_parse; end
+
+  # Called when processing the directive. Subclasses should implement
+  # this method to perform all functionality of the directive.
+  #
+  # @abstract implement this method to perform all data processing for
+  #   the directive.
+  # @raise [NotImplementedError]
+  # @return [void]
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#68
+  def call; end
+
+  # Set this field to replace the directive definition inside of a docstring
+  # with arbitrary text. For instance, the {MacroDirective} uses this field
+  # to expand its macro data in place of the call to a +@!macro+.
+  #
+  # @return [String] the text to expand in the original docstring in place
+  #   of this directive definition.
+  # @return [nil] if no expansion should take place for this directive
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#33
+  def expanded_text; end
+
+  # Set this field to replace the directive definition inside of a docstring
+  # with arbitrary text. For instance, the {MacroDirective} uses this field
+  # to expand its macro data in place of the call to a +@!macro+.
+  #
+  # @return [String] the text to expand in the original docstring in place
+  #   of this directive definition.
+  # @return [nil] if no expansion should take place for this directive
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#33
+  def expanded_text=(_arg0); end
+
+  # @return [Handlers::Base, nil] the handler object the docstring parser
+  #   might be attached to. May be nil. Only available when parsing
+  #   through {Parser::SourceParser}.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#48
+  def handler; end
+
+  # @return [CodeObjects::Base, nil] the object the parent docstring is
+  #   attached to. May be nil.
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#42
+  def object; end
+
+  # @return [DocstringParser] the parser that is parsing all tag
+  #   information out of the docstring
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#37
+  def parser=(_arg0); end
+
+  # @return [Tag] the meta-data tag containing data input to the directive
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#24
+  def tag; end
+
+  # @return [Tag] the meta-data tag containing data input to the directive
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#24
+  def tag=(_arg0); end
+
+  protected
+
+  # @return [Boolean]
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#79
+  def inside_directive?; end
+
+  # @return [DocstringParser] the parser that is parsing all tag
+  #   information out of the docstring
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#37
+  def parser; end
+end
+
+# Ends a group listing definition. Group definition automatically end
+# when class or module blocks are closed, and defining a new group overrides
+# the last group definition, but occasionally you need to end the current
+# group to return to the default listing. Use {tag:!group} to begin a
+# group listing.
+#
+# @example
+#   class Controller
+#   # @!group Callbacks
+#
+#   def before_filter; end
+#   def after_filter; end
+#
+#   # @!endgroup
+#
+#   def index; end
+#   end
+# @see tag:!group
+# @since 0.6.0
+#
+# source://yard//lib/yard/tags/directives.rb#104
+class YARD::Tags::EndGroupDirective < ::YARD::Tags::Directive
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#105
+  def call; end
+end
+
+# Defines a group listing. All methods (and attributes) seen after this
+# directive are placed into a group with the given description as the
+# group name. The group listing is used by templates to organize methods
+# and attributes into respective logical groups. To end a group listing
+# use {tag:!endgroup}.
+#
+# @example
+#   # @!group Callbacks
+#
+#   def before_filter; end
+#   def after_filter; end
+# @note A group definition only applies to the scope it is defined in.
+#   If a new class or module is opened after the directive, this directive
+#   will not apply to methods in that class or module.
+# @see tag:!endgroup
+# @since 0.6.0
+#
+# source://yard//lib/yard/tags/directives.rb#127
+class YARD::Tags::GroupDirective < ::YARD::Tags::Directive
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#128
+  def call; end
+end
+
+# Keeps track of all the registered meta-data tags and directives.
+# Also allows for defining of custom tags and customizing the tag parsing
+# syntax.
+#
+# == Defining Custom Meta-Data Tags
+#
+# To define a custom tag, use {define_tag}. You should pass the tag
+# name and the factory method to use when creating the tag. If you do not
+# provide a factory method to use, it will default to {DefaultFactory#parse_tag}
+#
+# You can also define tag objects manually by simply implementing a "tagname_tag"
+# method that returns a {Tag} object, but they will not take advantage of tag factory
+# parsing:
+#
+#   def mytag_tag(text)
+#     Tag.new(:mytag, text)
+#   end
+#
+# == Defining Custom Directives
+#
+# Directives can be defined by calling the {define_directive} method, taking
+# the directive name, an optional tag factory parser method (to parse the
+# data in the directive into a temporary {Tag} object) and a {Directive} subclass
+# that performs the directive processing. For more information on creating a
+# Directive subclass, see the {Directive} class documentation.
+#
+# Similar to tags, Directives can also be defined manually, in this case using
+# the method name "mydirective_directive" and returning a new {Directive} object:
+#
+#   def mydirective_directive(tag, parser)
+#     MyDirective.new(tag, parser)
+#   end
+#
+# == Namespaced Tags
+#
+# In YARD 0.8.0+, tags can be namespaced using the '.' character. It is recommended
+# to namespace project specific tags, like +@yard.tag_name+, so that tags do not
+# collide with other plugins or new built-in tags.
+#
+# == Adding/Changing the Tag Syntax
+#
+# If you have specialized tag parsing needs you can substitute the {#factory}
+# object with your own by setting {Library.default_factory= Library.default_factory}
+# to a new class with its own parsing methods before running YARD. This is useful
+# if you want to change the syntax of existing tags (@see, @since, etc.)
+#
+# @example Defining a custom tag
+#   define_tag "Parameter", :param, :with_types_and_name
+#   define_tag "Author", :author
+# @example Defining a custom directive
+#   define_directive :method, :with_title_and_text, MethodDirective
+# @see DefaultFactory
+# @see define_tag
+# @see define_directive
+# @see Directive
+#
+# source://yard//lib/yard/tags/library.rb#59
+class YARD::Tags::Library
+  # @return [Library] a new instance of Library
+  #
+  # source://yard//lib/yard/tags/library.rb#260
+  def initialize(factory = T.unsafe(nil)); end
+
+  # Marks a class/module/method as abstract with optional
+  # implementor information.
+  #
+  # @example
+  #   # @abstract Subclass and override {#run} to implement
+  #   #   a custom Threadable class.
+  #   class Runnable
+  #   def run; raise NotImplementedError end
+  #   end
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def abstract_tag(text); end
+
+  # Declares the API that the object belongs to. Does not display in
+  # output, but useful for performing queries (+yardoc --query+). Any text is
+  # allowable in this tag, and there are no predefined values.
+  #
+  # @example
+  #   class Post
+  #   # @api private
+  #   def reset_table!; table.flush end
+  #   end
+  # @note This tag is *transitive*. If it is applied on a
+  #   namespace (module or class), it will immediately be
+  #   applied to all children objects of that namespace unless
+  #   it is redefined on the child object.
+  # @note The special name +@api private+ does display a notice in
+  #   documentation if it is listed, letting users know that the
+  #   method is not to be used by external components.
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def api_tag(text); end
+
+  # Declares a readonly attribute on a Struct or class.
+  #
+  # @deprecated Use the more powerful {tag:!attribute} directive instead.
+  # @example
+  #   # @attr_reader [String] name the name of the structure
+  #   # @attr_reader [Fixnum] size the size of the structure
+  #   class MyStruct < Struct; end
+  # @note This attribute is only applicable on class docstrings
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def attr_reader_tag(text); end
+
+  # Declares a readwrite attribute on a Struct or class.
+  #
+  # @deprecated Use the more powerful {tag:!attribute} directive instead.
+  # @example
+  #   # @attr [String] name the name of the structure
+  #   # @attr [Fixnum] size the size of the structure
+  #   class MyStruct < Struct; end
+  # @note This attribute is only applicable on class docstrings
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def attr_tag(text); end
+
+  # Declares a writeonly attribute on a Struct or class.
+  #
+  # @deprecated Use the more powerful {tag:!attribute} directive instead.
+  # @example
+  #   # @attr_reader [String] name the name of the structure
+  #   # @attr_reader [Fixnum] size the size of the structure
+  #   class MyStruct < Struct; end
+  # @note This attribute is only applicable on class docstrings
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def attr_writer_tag(text); end
+
+  # source://yard//lib/yard/tags/library.rb#202
+  def attribute_directive(tag, parser); end
+
+  # List the author or authors of a class, module, or method.
+  #
+  # @example
+  #   # @author Foo Bar <foo@bar.com>
+  #   class MyClass; end
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def author_tag(text); end
+
+  # Marks a method/class as deprecated with an optional description.
+  # The description should be used to inform users of the recommended
+  # migration path, and/or any useful information about why the object
+  # was marked as deprecated.
+  #
+  # @example Deprecate a method with a replacement API
+  #   # @deprecated Use {#bar} instead.
+  #   def foo; end
+  # @example Deprecate a method with no replacement
+  #   class Thread
+  #   # @deprecated Exiting a thread in this way is not reliable and
+  #   #   can cause a program crash.
+  #   def kill; end
+  #   end
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def deprecated_tag(text); end
+
+  # Creates a new directive with tag information and a docstring parser
+  # object.
+  #
+  # @param tag_name [String] the name of the tag
+  # @param tag_buf [String] the tag data
+  # @param parser [DocstringParser] the parser object parsing the docstring
+  # @return [Directive] the newly created directive
+  #
+  # source://yard//lib/yard/tags/library.rb#290
+  def directive_create(tag_name, tag_buf, parser); end
+
+  # source://yard//lib/yard/tags/library.rb#202
+  def endgroup_directive(tag, parser); end
+
+  # Show an example snippet of code for an object. The first line
+  # is an optional title.
+  #
+  # @example
+  #   # @example Reverse a String
+  #   #   "mystring".reverse #=> "gnirtsym"
+  #   def reverse; end
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def example_tag(text); end
+
+  # A factory class to handle parsing of tags, defaults to {default_factory}
+  #
+  # source://yard//lib/yard/tags/library.rb#258
+  def factory; end
+
+  # A factory class to handle parsing of tags, defaults to {default_factory}
+  #
+  # source://yard//lib/yard/tags/library.rb#258
+  def factory=(_arg0); end
+
+  # source://yard//lib/yard/tags/library.rb#202
+  def group_directive(tag, parser); end
+
+  # @param tag_name [#to_s] the name of the tag to look for
+  # @return [Boolean] whether a directive by the given name is registered in
+  #   the library.
+  #
+  # source://yard//lib/yard/tags/library.rb#280
+  def has_directive?(tag_name); end
+
+  # @param tag_name [#to_s] the name of the tag to look for
+  # @return [Boolean] whether a tag by the given name is registered in
+  #   the library.
+  #
+  # source://yard//lib/yard/tags/library.rb#267
+  def has_tag?(tag_name); end
+
+  # source://yard//lib/yard/tags/library.rb#202
+  def macro_directive(tag, parser); end
+
+  # source://yard//lib/yard/tags/library.rb#202
+  def method_directive(tag, parser); end
+
+  # Adds an emphasized note at the top of the docstring for the object
+  #
+  # @example
+  #   # @note This method should only be used in outer space.
+  #   def eject; end
+  # @see tag:todo
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def note_tag(text); end
+
+  # Describe an options hash in a method. The tag takes the
+  # name of the options parameter first, followed by optional types,
+  # the option key name, a default value for the key and a
+  # description of the option. The default value should be placed within
+  # parentheses and is optional (can be omitted).
+  #
+  # Note that a +@param+ tag need not be defined for the options
+  # hash itself, though it is useful to do so for completeness.
+  #
+  # @example
+  #   # @param [Hash] opts the options to create a message with.
+  #   # @option opts [String] :subject The subject
+  #   # @option opts [String] :from ('nobody') From address
+  #   # @option opts [String] :to Recipient email
+  #   # @option opts [String] :body ('') The email's body
+  #   def send_email(opts = {}) end
+  # @note For keyword parameters, use +@param+, not +@option+.
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def option_tag(text); end
+
+  # Describe that your method can be used in various
+  # contexts with various parameters or return types. The first
+  # line should declare the new method signature, and the following
+  # indented tag data will be a new documentation string with its
+  # own tags adding metadata for such an overload.
+  #
+  # @example
+  #   # @overload set(key, value)
+  #   #   Sets a value on key
+  #   #   @param key [Symbol] describe key param
+  #   #   @param value [Object] describe value param
+  #   # @overload set(value)
+  #   #   Sets a value on the default key +:foo+
+  #   #   @param value [Object] describe value param
+  #   def set(*args) end
+  #
+  # source://yard//lib/yard/tags/library.rb#161
+  def overload_tag(text); end
+
+  # Documents a single method parameter (either regular or keyword) with a given name, type
+  # and optional description.
+  #
+  # @example
+  #   # @param url [String] the URL of the page to download
+  #   # @param directory [String] the name of the directory to save to
+  #   def load_page(url, directory: 'pages') end
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def param_tag(text); end
+
+  # source://yard//lib/yard/tags/library.rb#202
+  def parse_directive(tag, parser); end
+
+  # Declares that the _logical_ visibility of an object is private.
+  # In other words, it specifies that this method should be marked
+  # private but cannot due to Ruby's visibility restrictions. This
+  # exists for classes, modules and constants that do not obey Ruby's
+  # visibility rules. For instance, an inner class might be considered
+  # "private", though Ruby would make no such distinction.
+  #
+  # This tag is meant to be used in conjunction with the +--no-private+
+  # command-line option, and is required to actually remove these objects
+  # from documentation output. See {file:README.md} for more information on
+  # switches.
+  #
+  # If you simply want to set the API visibility of a method, you should
+  # look at the {tag:api} tag instead.
+  #
+  # @example
+  #   # @private
+  #   class InteralImplementation; end
+  # @note This method is not recommended for hiding undocumented or
+  #   "unimportant" methods. This tag should only be used to mark objects
+  #   private when Ruby visibility rules cannot do so. In Ruby 1.9.3, you
+  #   can use +private_constant+ to declare constants (like classes or
+  #   modules) as private, and should be used instead of +@private+.
+  # @note This tag is *transitive*. If it is applied on a
+  #   namespace (module or class), it will immediately be
+  #   applied to all children objects of that namespace unless
+  #   it is redefined on the child object.
+  # @see tag:api
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def private_tag(text); end
+
+  # Describes that a method may raise a given exception, with
+  # an optional description of what it may mean.
+  #
+  # @example
+  #   # @raise [AccountBalanceError] if the account does not have
+  #   #   sufficient funds to perform the transaction
+  #   def withdraw(amount) end
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def raise_tag(text); end
+
+  # Describes the return value (and type or types) of a method.
+  # You can list multiple return tags for a method in the case
+  # where a method has distinct return cases. In this case, each
+  # case should begin with "if ...".
+  #
+  # @example A regular return value
+  #   # @return [Fixnum] the size of the file
+  #   def size; @file.size end
+  # @example A method returns an Array or a single object
+  #   # @return [String] if a single object was returned
+  #   #   from the database.
+  #   # @return [Array<String>] if multiple objects were
+  #   #   returned.
+  #   def find(query) end
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def return_tag(text); end
+
+  # Sets the scope of a DSL method. Only applicable to DSL method
+  # calls. Acceptable values are 'class' or 'instance'
+  #
+  # source://yard//lib/yard/tags/library.rb#202
+  def scope_directive(tag, parser); end
+
+  # "See Also" references for an object. Accepts URLs or
+  # other code objects with an optional description at the end.
+  # Note that the URL or object will be automatically linked by
+  # YARD and does not need to be formatted with markup.
+  #
+  # @example
+  #   # Synchronizes system time using NTP.
+  #   # @see http://ntp.org/documentation.html NTP Documentation
+  #   # @see NTPHelperMethods
+  #   class NTPUpdater; end
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def see_tag(text); end
+
+  # Lists the version that the object was first added.
+  #
+  # @example
+  #   # @since 1.2.4
+  #   def clear_routes; end
+  # @note This tag is *transitive*. If it is applied on a
+  #   namespace (module or class), it will immediately be
+  #   applied to all children objects of that namespace unless
+  #   it is redefined on the child object.
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def since_tag(text); end
+
+  # Creates a new {Tag} object with a given tag name and data
+  #
+  # @return [Tag] the newly created tag object
+  #
+  # source://yard//lib/yard/tags/library.rb#273
+  def tag_create(tag_name, tag_buf); end
+
+  # Marks a TODO note in the object being documented.
+  # For reference, objects with TODO items can be enumerated
+  # from the command line with a simple command:
+  #
+  #   !!!sh
+  #   mocker$ yard list --query '@todo'
+  #   lib/mocker/mocker.rb:15: Mocker
+  #   lib/mocker/report/html.rb:5: Mocker::Report::Html
+  #
+  # YARD can also be used to enumerate the TODO items from
+  # a short script:
+  #
+  #   !!!ruby
+  #   require 'yard'
+  #   YARD::Registry.load!.all.each do |o|
+  #     puts o.tag(:todo).text if o.tag(:todo)
+  #   end
+  #
+  # @example
+  #   # @todo Add support for Jabberwocky service.
+  #   #   There is an open source Jabberwocky library available
+  #   #   at http://jbrwcky.org that can be easily integrated.
+  #   class Wonderlander; end
+  # @see tag:note
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def todo_tag(text); end
+
+  # Lists the version of a class, module or method. This is
+  # similar to a library version, but at finer granularity.
+  # In some cases, version of specific modules, classes, methods
+  # or generalized components might change independently between
+  # releases. A version tag is used to infer the API compatibility
+  # of a specific object.
+  #
+  # @example
+  #   # The public REST API for http://jbrwcky.org
+  #   # @version 2.0
+  #   class JabberwockyAPI; end
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def version_tag(text); end
+
+  # Sets the visibility of a DSL method. Only applicable to
+  # DSL method calls. Acceptable values are public, protected, or private.
+  #
+  # source://yard//lib/yard/tags/library.rb#202
+  def visibility_directive(tag, parser); end
+
+  # Describes what a method might yield to a given block.
+  # The types specifier list should not list types, but names
+  # of the parameters yielded to the block. If you define
+  # parameters with +@yieldparam+, you do not need to define
+  # the parameters in the type specification of +@yield+ as
+  # well.
+  #
+  # @example
+  #   # For a block {|a,b,c| ... }
+  #   # @yield [a, b, c] Gives 3 random numbers to the block
+  #   def provide3values(&block) yield(42, 42, 42) end
+  # @see tag:yieldparam
+  # @see tag:yieldreturn
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def yield_tag(text); end
+
+  # Defines a parameter yielded by a block. If you define the
+  # parameters with +@yieldparam+, you do not need to define
+  # them via +@yield+ as well.
+  #
+  # @example
+  #   # @yieldparam [String] name the name that is yielded
+  #   def with_name(name) yield(name) end
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def yieldparam_tag(text); end
+
+  # Documents the value and type that the block is expected
+  # to return to the method.
+  #
+  # @example
+  #   # @yieldreturn [Fixnum] the number to add 5 to.
+  #   def add5_block(&block) 5 + yield end
+  # @see tag:return
+  #
+  # source://yard//lib/yard/tags/library.rb#168
+  def yieldreturn_tag(text); end
+
+  private
+
+  # @return [Directive]
+  #
+  # source://yard//lib/yard/tags/library.rb#244
+  def directive_call(tag, parser); end
+
+  # source://yard//lib/yard/tags/library.rb#233
+  def send_to_factory(tag_name, meth, text); end
+
+  class << self
+    # Replace the factory object responsible for parsing tags by setting
+    # this to an object (or class) that responds to +parse_TAGNAME+ methods
+    # where +TAGNAME+ is the name of the tag.
+    #
+    # You should set this value before performing any source parsing with
+    # YARD, otherwise your factory class will not be used.
+    #
+    # @example
+    #   YARD::Tags::Library.default_factory = MyFactory
+    # @see DefaultFactory
+    #
+    # source://yard//lib/yard/tags/library.rb#83
+    def default_factory; end
+
+    # Replace the factory object responsible for parsing tags by setting
+    # this to an object (or class) that responds to +parse_TAGNAME+ methods
+    # where +TAGNAME+ is the name of the tag.
+    #
+    # You should set this value before performing any source parsing with
+    # YARD, otherwise your factory class will not be used.
+    #
+    # @example
+    #   YARD::Tags::Library.default_factory = MyFactory
+    # @see DefaultFactory
+    #
+    # source://yard//lib/yard/tags/library.rb#87
+    def default_factory=(factory); end
+
+    # @overload define_directive
+    #
+    # source://yard//lib/yard/tags/library.rb#196
+    def define_directive(tag, tag_meth = T.unsafe(nil), directive_class = T.unsafe(nil)); end
+
+    # Convenience method to define a new tag using one of {Tag}'s factory methods, or the
+    # regular {DefaultFactory#parse_tag} factory method if none is supplied.
+    #
+    # @param label [#to_s] the label used when displaying the tag in templates
+    # @param tag [#to_s] the tag name to create
+    # @param meth [#to_s, Class<Tag>] the {Tag} factory method to call when
+    #   creating the tag or the name of the class to directly create a tag for
+    #
+    # source://yard//lib/yard/tags/library.rb#157
+    def define_tag(label, tag, meth = T.unsafe(nil)); end
+
+    # source://yard//lib/yard/tags/library.rb#220
+    def directive_method_name(tag_name); end
+
+    # Returns the factory method used to parse the tag text for a specific tag
+    #
+    # @param tag [Symbol] the tag name
+    # @return [Symbol] the factory method name for the tag
+    # @return [Class<Tag>, Symbol] the Tag class to use to parse the tag
+    #   or the method to call on the factory class
+    # @return [nil] if the tag is freeform text
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/tags/library.rb#99
+    def factory_method_for(tag); end
+
+    # Returns the factory method used to parse the tag text for a specific
+    # directive
+    #
+    # @param directive [Symbol] the directive name
+    # @return [Symbol] the factory method name for the tag
+    # @return [Class<Tag>, Symbol] the Tag class to use to parse the tag or
+    #   the methods to call on the factory class
+    # @return [nil] if the tag is freeform text
+    # @since 0.8.0
+    #
+    # source://yard//lib/yard/tags/library.rb#112
+    def factory_method_for_directive(directive); end
+
+    # @return [Library] the main Library instance object.
+    #
+    # source://yard//lib/yard/tags/library.rb#67
+    def instance; end
+
+    # @return [SymbolHash{Symbol=>String}] the map of tag names and their
+    #   respective display labels.
+    #
+    # source://yard//lib/yard/tags/library.rb#63
+    def labels; end
+
+    # Sorts the labels lexically by their label name, often used when displaying
+    # the tags.
+    #
+    # @return [Array<Symbol>, String] the sorted labels as an array of the tag name and label
+    #
+    # source://yard//lib/yard/tags/library.rb#142
+    def sorted_labels; end
+
+    # source://yard//lib/yard/tags/library.rb#216
+    def tag_method_name(tag_name); end
+
+    # Sets the list of tags that should apply to any children inside the
+    # namespace they are defined in. For instance, a "@since" tag should
+    # apply to all methods inside a module it is defined in. Transitive
+    # tags can be overridden by directly defining a tag on the child object.
+    #
+    # @return [Array<Symbol>] a list of transitive tags
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/tags/library.rb#136
+    def transitive_tags; end
+
+    # Sets the list of tags that should apply to any children inside the
+    # namespace they are defined in. For instance, a "@since" tag should
+    # apply to all methods inside a module it is defined in. Transitive
+    # tags can be overridden by directly defining a tag on the child object.
+    #
+    # @return [Array<Symbol>] a list of transitive tags
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/tags/library.rb#136
+    def transitive_tags=(_arg0); end
+
+    # Sets the list of tags to display when rendering templates. The order of
+    # tags in the list is also significant, as it represents the order that
+    # tags are displayed in templates.
+    #
+    # You can use the {Array#place} to insert new tags to be displayed in
+    # the templates at specific positions:
+    #
+    #   Library.visible_tags.place(:mytag).before(:return)
+    #
+    # @return [Array<Symbol>] a list of ordered tags
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/tags/library.rb#127
+    def visible_tags; end
+
+    # Sets the list of tags to display when rendering templates. The order of
+    # tags in the list is also significant, as it represents the order that
+    # tags are displayed in templates.
+    #
+    # You can use the {Array#place} to insert new tags to be displayed in
+    # the templates at specific positions:
+    #
+    #   Library.visible_tags.place(:mytag).before(:return)
+    #
+    # @return [Array<Symbol>] a list of ordered tags
+    # @since 0.6.0
+    #
+    # source://yard//lib/yard/tags/library.rb#127
+    def visible_tags=(_arg0); end
+
+    private
+
+    # source://yard//lib/yard/tags/library.rb#226
+    def tag_or_directive_method_name(tag_name, type = T.unsafe(nil)); end
+  end
+end
+
+# Defines a block of text to be expanded whenever the macro is called by name
+# in subsequent docstrings. The macro data can be any arbitrary text data, be
+# it regular documentation, meta-data tags or directives.
+#
+# == Defining a Macro
+#
+# A macro must first be defined in order to be used. Note that a macro is also
+# expanded upon definition if it defined on an object (the docstring of a
+# method, class, module or constant object as opposed to a free standing
+# comment). To define a macro, use the "new" or "attach" identifier in the
+# types specifier list. A macro will also automatically be created if an
+# indented macro data block is given, so the keywords are not strictly needed.
+#
+# === Anonymous Macros
+#
+# In addition to standard named macros, macros can be defined anonymously if
+# no name is given. In this case, they can not be re-used in future docstrings,
+# but they will expand in the first definition. This is useful when needing
+# to take advantage of the macro expansion variables (described below).
+#
+# == Using a Macro
+#
+# To re-use a macro in another docstring after it is defined, simply use
+# <tt>@!macro the_name</tt> with no indented block of macro data. The resulting
+# data will be expanded in place.
+#
+# == Attaching a Macro to a DSL Method
+#
+# Macros can be defined to auto-expand on DSL-style class method calls. To
+# define a macro to be auto expanded in this way, use the "attach" keyword
+# in the type specifier list ("new" is implied).
+#
+# Attached macros can also be attached directly on the class method declaration
+# that provides the DSL method to its subclasses. The syntax in either case
+# is the same.
+#
+# == Macro Expansion Variables
+#
+# In the case of using macros on DSL-style method calls, a number of expansion
+# variables can be used for interpolation inside of the macro data. The variables,
+# similar in syntax to Ruby's global variables, are as follows:
+#
+# * $0 - the method name being called
+# * $1, $2, $3, ... - the Nth argument in the method call
+# * $& - the full source line
+#
+# The following example shows what the expansion variables might hold for a given
+# DSL method call:
+#
+#   property :foo, :a, :b, :c, String
+#   # $0 => "property"
+#   # $1 => "foo"
+#   # $2 => "a"
+#   # $& => "property :foo, :a, :b, :c, String"
+#
+# === Ranges
+#
+# Ranges are also acceptable with the syntax <tt>${N-M}</tt>. Negative values
+# on either N or M are valid, and refer to indexes from the end of the list.
+# Consider a DSL method that creates a method using the first argument with
+# argument names following, ending with the return type of the method. This
+# could be documented as:
+#
+#     # @!macro dsl_method
+#     #   @!method $1(${2--2})
+#     #   @return [${-1}] the return value of $0
+#     create_method_with_args :foo, :a, :b, :c, String
+#
+# As described, the method is using the signature <tt>foo(a, b, c)</tt> and the return
+# type from the last argument, +String+. When using ranges, tokens are joined
+# with commas. Note that this includes using $0:
+#
+#     !!!plain
+#     $0-1 # => Interpolates to "create_method_with_args, foo"
+#
+# If you want to separate them with spaces, use <tt>$1 $2 $3 $4 ...</tt>. Note that
+# if the token cannot be expanded, it will return the empty string (not an error),
+# so it would be safe to list <tt>$1 $2 ... $10</tt>, for example.
+#
+# === Escaping Interpolation
+#
+# Interpolation can be escaped by prefixing the +$+ with +\\\+, like so:
+#
+#     # @!macro foo
+#     #   I have \$2.00 USD.
+#
+# @example Defining a simple macro
+#   # @!macro [new] returnself
+#   #   @return [self] returns itself
+# @example Using a simple macro in multiple docstrings
+#   # Documentation for map
+#   # ...
+#   # @macro returnself
+#   def map; end
+#
+#   # Documentation for filter
+#   # ...
+#   # @macro returnself
+#   def filter; end
+# @example Attaching a macro to a class method (for DSL usage)
+#   class Resource
+#   # Defines a new property
+#   # @param [String] name the property name
+#   # @param [Class] type the property's type
+#   # @!macro [attach] property
+#   #   @return [$2] the $1 property
+#   def self.property(name, type) end
+#   end
+#
+#   class Post < Resource
+#   property :title, String
+#   property :view_count, Integer
+#   end
+# @example Attaching a macro directly to a DSL method
+#   class Post < Resource
+#   # @!macro [attach] property
+#   #   @return [$2] the $1 property
+#   property :title, String
+#
+#   # Macro will expand on this definition too
+#   property :view_count, Integer
+#   end
+# @since 0.7.0
+#
+# source://yard//lib/yard/tags/directives.rb#257
+class YARD::Tags::MacroDirective < ::YARD::Tags::Directive
+  # @raise [TagFormatError]
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#258
+  def call; end
+
+  private
+
+  # @return [Boolean]
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#287
+  def anonymous?; end
+
+  # @return [Boolean]
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#276
+  def attach?; end
+
+  # @return [Boolean]
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#282
+  def class_method?; end
+
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#291
+  def expand(macro_data); end
+
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#307
+  def find_or_create; end
+
+  # @return [Boolean]
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#271
+  def new?; end
+
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#331
+  def warn; end
+end
+
+# Defines a method object with a given method signature, using indented
+# block data as the method's docstring. The signature is similar to the
+# {tag:overload} tag. The comment containing this directive does not need
+# to be attached to any source, but if it is, that source code will be
+# used as the method's source.
+#
+# To define an attribute method, see {tag:!attribute}
+#
+# @example Defining a simple method
+#   # @!method quit(username, message = "Quit")
+#   #   Sends a quit message to the server for a +username+.
+#   #   @param [String] username the username to quit
+#   #   @param [String] message the quit message
+#   quit_message_method
+# @example Attaching multiple methods to the same source
+#   # @!method method1
+#   # @!method method2
+#   create_methods :method1, :method2
+# @note This directive should only be used if there is no explicit
+#   declaration for the method in any source files (i.e., the method
+#   is declared dynamically via meta-programming). In all other cases, add
+#   documentation to the method definition itself.
+# @note For backwards compatibility support, you do not need to indent
+#   the method's docstring text. If a +@!method+ directive is seen with
+#   no indented block, the entire docstring is used as the new method's
+#   docstring text.
+# @see tag:!attribute
+# @since 0.7.0
+#
+# source://yard//lib/yard/tags/directives.rb#367
+class YARD::Tags::MethodDirective < ::YARD::Tags::Directive
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#372
+  def after_parse; end
+
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#370
+  def call; end
+
+  protected
+
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#412
+  def create_object; end
+
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#380
+  def method_name; end
+
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#389
+  def method_signature; end
+
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#393
+  def sanitized_tag_signature; end
+
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#402
+  def use_indented_text; end
+end
+
+# @since 0.7.0
+#
+# source://yard//lib/yard/tags/directives.rb#368
+YARD::Tags::MethodDirective::SCOPE_MATCH = T.let(T.unsafe(nil), Regexp)
+
+# source://yard//lib/yard/tags/option_tag.rb#4
+class YARD::Tags::OptionTag < ::YARD::Tags::Tag
+  # @return [OptionTag] a new instance of OptionTag
+  #
+  # source://yard//lib/yard/tags/option_tag.rb#7
+  def initialize(tag_name, name, pair); end
+
+  # Returns the value of attribute pair.
+  #
+  # source://yard//lib/yard/tags/option_tag.rb#5
+  def pair; end
+
+  # Sets the attribute pair
+  #
+  # @param value the value to set the attribute pair to.
+  #
+  # source://yard//lib/yard/tags/option_tag.rb#5
+  def pair=(_arg0); end
+end
+
+# source://yard//lib/yard/tags/overload_tag.rb#4
+class YARD::Tags::OverloadTag < ::YARD::Tags::Tag
+  # @return [OverloadTag] a new instance of OverloadTag
+  #
+  # source://yard//lib/yard/tags/overload_tag.rb#7
+  def initialize(tag_name, text); end
+
+  # Returns the value of attribute docstring.
+  #
+  # source://yard//lib/yard/tags/overload_tag.rb#5
+  def docstring; end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/tags/overload_tag.rb#15
+  def has_tag?(name); end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/tags/overload_tag.rb#36
+  def is_a?(other); end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/tags/overload_tag.rb#36
+  def kind_of?(other); end
+
+  # source://yard//lib/yard/tags/overload_tag.rb#28
+  def method_missing(*args, &block); end
+
+  # source://yard//lib/yard/tags/overload_tag.rb#23
+  def name(prefix = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/tags/overload_tag.rb#17
+  def object=(value); end
+
+  # Returns the value of attribute parameters.
+  #
+  # source://yard//lib/yard/tags/overload_tag.rb#5
+  def parameters; end
+
+  # Returns the value of attribute signature.
+  #
+  # source://yard//lib/yard/tags/overload_tag.rb#5
+  def signature; end
+
+  # source://yard//lib/yard/tags/overload_tag.rb#13
+  def tag(name); end
+
+  # source://yard//lib/yard/tags/overload_tag.rb#14
+  def tags(name = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/tags/overload_tag.rb#32
+  def type; end
+
+  private
+
+  # source://yard//lib/yard/tags/overload_tag.rb#53
+  def parse_signature; end
+
+  # source://yard//lib/yard/tags/overload_tag.rb#43
+  def parse_tag(text); end
+end
+
+# Parses a block of code as if it were present in the source file at that
+# location. This directive is useful if a class has dynamic meta-programmed
+# behaviour that cannot be recognized by YARD.
+#
+# You can specify the language of the code block using the types
+# specification list. By default, the code language is "ruby".
+#
+# @example Documenting dynamic module inclusion
+#   class User
+#   # includes "UserMixin" and extends "UserMixin::ClassMethods"
+#   # using the UserMixin.included callback.
+#   # @!parse include UserMixin
+#   # @!parse extend UserMixin::ClassMethods
+#   end
+# @example Declaring a method as an attribute
+#   # This should really be an attribute
+#   # @!parse attr_reader :foo
+#   def object; @parent.object end
+# @example Parsing C code
+#   # @!parse [c]
+#   #   void Init_Foo() {
+#   #     rb_define_method(rb_cFoo, "method", method, 0);
+#   #   }
+# @since 0.8.0
+#
+# source://yard//lib/yard/tags/directives.rb#544
+class YARD::Tags::ParseDirective < ::YARD::Tags::Directive
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#545
+  def call; end
+end
+
+# source://yard//lib/yard/tags/ref_tag.rb#4
+module YARD::Tags::RefTag
+  # Returns the value of attribute owner.
+  #
+  # source://yard//lib/yard/tags/ref_tag.rb#5
+  def owner; end
+
+  # Sets the attribute owner
+  #
+  # @param value the value to set the attribute owner to.
+  #
+  # source://yard//lib/yard/tags/ref_tag.rb#5
+  def owner=(_arg0); end
+end
+
+# source://yard//lib/yard/tags/ref_tag_list.rb#4
+class YARD::Tags::RefTagList
+  # @return [RefTagList] a new instance of RefTagList
+  #
+  # source://yard//lib/yard/tags/ref_tag_list.rb#7
+  def initialize(tag_name, owner, name = T.unsafe(nil)); end
+
+  # Returns the value of attribute name.
+  #
+  # source://yard//lib/yard/tags/ref_tag_list.rb#5
+  def name; end
+
+  # Sets the attribute name
+  #
+  # @param value the value to set the attribute name to.
+  #
+  # source://yard//lib/yard/tags/ref_tag_list.rb#5
+  def name=(_arg0); end
+
+  # Returns the value of attribute owner.
+  #
+  # source://yard//lib/yard/tags/ref_tag_list.rb#5
+  def owner; end
+
+  # Sets the attribute owner
+  #
+  # @param value the value to set the attribute owner to.
+  #
+  # source://yard//lib/yard/tags/ref_tag_list.rb#5
+  def owner=(_arg0); end
+
+  # Returns the value of attribute tag_name.
+  #
+  # source://yard//lib/yard/tags/ref_tag_list.rb#5
+  def tag_name; end
+
+  # Sets the attribute tag_name
+  #
+  # @param value the value to set the attribute tag_name to.
+  #
+  # source://yard//lib/yard/tags/ref_tag_list.rb#5
+  def tag_name=(_arg0); end
+
+  # source://yard//lib/yard/tags/ref_tag_list.rb#13
+  def tags; end
+end
+
+# Modifies the current parsing scope (class or instance). If this
+# directive is defined on a docstring attached to an object definition,
+# it is applied only to that object. Otherwise, it applies the scope
+# to all future objects in the namespace.
+#
+# @example Modifying the scope of a DSL method
+#   # @!scope class
+#   cattr_accessor :subclasses
+# @example Modifying the scope of a set of methods
+#   # @!scope class
+#
+#   # Documentation for method1
+#   def method1; end
+#
+#   # Documentation for method2
+#   def method2; end
+# @since 0.7.0
+#
+# source://yard//lib/yard/tags/directives.rb#578
+class YARD::Tags::ScopeDirective < ::YARD::Tags::Directive
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#579
+  def call; end
+end
+
+# Represents a metadata tag value (+@tag+). Tags can have any combination of
+# {#types}, {#name} and {#text}, or none of the above.
+#
+# @example Programmatic tag creation
+#   # The following docstring syntax:
+#   #   @param [String, nil] arg an argument
+#   #
+#   # is equivalent to:
+#   Tag.new(:param, 'an argument', ['String', 'nil'], 'arg')
+#
+# source://yard//lib/yard/tags/tag.rb#13
+class YARD::Tags::Tag
+  # Creates a new tag object with a tag name and text. Optionally, formally declared types
+  # and a key name can be specified.
+  #
+  # Types are mainly for meta tags that rely on type information, such as +param+, +return+, etc.
+  #
+  # Key names are for tags that declare meta data for a specific key or name, such as +param+,
+  # +raise+, etc.
+  #
+  # @param tag_name [#to_s] the tag name to create the tag for
+  # @param text [String] the descriptive text for this tag
+  # @param types [Array<String>] optional type list of formally declared types
+  #   for the tag
+  # @param name [String] optional key name which the tag refers to
+  # @return [Tag] a new instance of Tag
+  #
+  # source://yard//lib/yard/tags/tag.rb#45
+  def initialize(tag_name, text, types = T.unsafe(nil), name = T.unsafe(nil)); end
+
+  # Provides a plain English summary of the type specification, or nil
+  # if no types are provided or parsable.
+  #
+  # @return [String] a plain English description of the associated types
+  # @return [nil] if no types are provided or not parsable
+  #
+  # source://yard//lib/yard/tags/tag.rb#66
+  def explain_types; end
+
+  # @return [String] a name associated with the tag
+  # @return [nil] if no tag name is supplied
+  #
+  # source://yard//lib/yard/tags/tag.rb#27
+  def name; end
+
+  # @return [String] a name associated with the tag
+  # @return [nil] if no tag name is supplied
+  #
+  # source://yard//lib/yard/tags/tag.rb#27
+  def name=(_arg0); end
+
+  # @return [CodeObjects::Base] the associated object
+  #
+  # source://yard//lib/yard/tags/tag.rb#30
+  def object; end
+
+  # @return [CodeObjects::Base] the associated object
+  #
+  # source://yard//lib/yard/tags/tag.rb#30
+  def object=(_arg0); end
+
+  # @return [String] the name of the tag
+  #
+  # source://yard//lib/yard/tags/tag.rb#15
+  def tag_name; end
+
+  # @return [String] the name of the tag
+  #
+  # source://yard//lib/yard/tags/tag.rb#15
+  def tag_name=(_arg0); end
+
+  # @return [String] the tag text associated with the tag
+  # @return [nil] if no tag text is supplied
+  #
+  # source://yard//lib/yard/tags/tag.rb#19
+  def text; end
+
+  # @return [String] the tag text associated with the tag
+  # @return [nil] if no tag text is supplied
+  #
+  # source://yard//lib/yard/tags/tag.rb#19
+  def text=(_arg0); end
+
+  # Convenience method to access the first type specified. This should mainly
+  # be used for tags that only specify one type.
+  #
+  # @return [String] the first of the list of specified types
+  # @see #types
+  #
+  # source://yard//lib/yard/tags/tag.rb#57
+  def type; end
+
+  # @return [Array<String>] a list of types associated with the tag
+  # @return [nil] if no types are associated with the tag
+  #
+  # source://yard//lib/yard/tags/tag.rb#23
+  def types; end
+
+  # @return [Array<String>] a list of types associated with the tag
+  # @return [nil] if no types are associated with the tag
+  #
+  # source://yard//lib/yard/tags/tag.rb#23
+  def types=(_arg0); end
+end
+
+# source://yard//lib/yard/tags/tag_format_error.rb#4
+class YARD::Tags::TagFormatError < ::RuntimeError; end
+
+# source://yard//lib/yard/tags/types_explainer.rb#6
+class YARD::Tags::TypesExplainer
+  class << self
+    # Provides a plain English summary of the type specification, or nil
+    # if no types are provided or parsable.
+    #
+    # @param types [Array<String>] a list of types to parse and summarize
+    # @return [String] a plain English description of the associated types
+    # @return [nil] if no types are provided or not parsable
+    #
+    # source://yard//lib/yard/tags/types_explainer.rb#9
+    def explain(*types); end
+
+    # Provides a plain English summary of the type specification, or nil
+    # if no types are provided or parsable.
+    #
+    # @param types [Array<String>] a list of types to parse and summarize
+    # @raise [SyntaxError] if the types are not parsable
+    # @return [String] a plain English description of the associated types
+    # @return [nil] if no types are provided or not parsable
+    #
+    # source://yard//lib/yard/tags/types_explainer.rb#17
+    def explain!(*types); end
+
+    private
+
+    def new(*_arg0); end
+  end
+end
+
+# @private
+#
+# source://yard//lib/yard/tags/types_explainer.rb#58
+class YARD::Tags::TypesExplainer::CollectionType < ::YARD::Tags::TypesExplainer::Type
+  # @return [CollectionType] a new instance of CollectionType
+  #
+  # source://yard//lib/yard/tags/types_explainer.rb#61
+  def initialize(name, types); end
+
+  # source://yard//lib/yard/tags/types_explainer.rb#66
+  def to_s(_singular = T.unsafe(nil)); end
+
+  # Returns the value of attribute types.
+  #
+  # source://yard//lib/yard/tags/types_explainer.rb#59
+  def types; end
+
+  # Sets the attribute types
+  #
+  # @param value the value to set the attribute types to.
+  #
+  # source://yard//lib/yard/tags/types_explainer.rb#59
+  def types=(_arg0); end
+end
+
+# @private
+#
+# source://yard//lib/yard/tags/types_explainer.rb#72
+class YARD::Tags::TypesExplainer::FixedCollectionType < ::YARD::Tags::TypesExplainer::CollectionType
+  # source://yard//lib/yard/tags/types_explainer.rb#73
+  def to_s(_singular = T.unsafe(nil)); end
+end
+
+# @private
+#
+# source://yard//lib/yard/tags/types_explainer.rb#79
+class YARD::Tags::TypesExplainer::HashCollectionType < ::YARD::Tags::TypesExplainer::Type
+  # @return [HashCollectionType] a new instance of HashCollectionType
+  #
+  # source://yard//lib/yard/tags/types_explainer.rb#82
+  def initialize(name, key_types, value_types); end
+
+  # Returns the value of attribute key_types.
+  #
+  # source://yard//lib/yard/tags/types_explainer.rb#80
+  def key_types; end
+
+  # Sets the attribute key_types
+  #
+  # @param value the value to set the attribute key_types to.
+  #
+  # source://yard//lib/yard/tags/types_explainer.rb#80
+  def key_types=(_arg0); end
+
+  # source://yard//lib/yard/tags/types_explainer.rb#88
+  def to_s(_singular = T.unsafe(nil)); end
+
+  # Returns the value of attribute value_types.
+  #
+  # source://yard//lib/yard/tags/types_explainer.rb#80
+  def value_types; end
+
+  # Sets the attribute value_types
+  #
+  # @param value the value to set the attribute value_types to.
+  #
+  # source://yard//lib/yard/tags/types_explainer.rb#80
+  def value_types=(_arg0); end
+end
+
+# @private
+#
+# source://yard//lib/yard/tags/types_explainer.rb#96
+class YARD::Tags::TypesExplainer::Parser
+  include ::YARD::CodeObjects
+
+  # @return [Parser] a new instance of Parser
+  #
+  # source://yard//lib/yard/tags/types_explainer.rb#117
+  def initialize(string); end
+
+  # source://yard//lib/yard/tags/types_explainer.rb#121
+  def parse; end
+
+  class << self
+    # source://yard//lib/yard/tags/types_explainer.rb#113
+    def parse(string); end
+  end
+end
+
+# source://yard//lib/yard/tags/types_explainer.rb#99
+YARD::Tags::TypesExplainer::Parser::TOKENS = T.let(T.unsafe(nil), Hash)
+
+# @private
+#
+# source://yard//lib/yard/tags/types_explainer.rb#26
+class YARD::Tags::TypesExplainer::Type
+  # @return [Type] a new instance of Type
+  #
+  # source://yard//lib/yard/tags/types_explainer.rb#29
+  def initialize(name); end
+
+  # Returns the value of attribute name.
+  #
+  # source://yard//lib/yard/tags/types_explainer.rb#27
+  def name; end
+
+  # Sets the attribute name
+  #
+  # @param value the value to set the attribute name to.
+  #
+  # source://yard//lib/yard/tags/types_explainer.rb#27
+  def name=(_arg0); end
+
+  # source://yard//lib/yard/tags/types_explainer.rb#33
+  def to_s(singular = T.unsafe(nil)); end
+
+  private
+
+  # source://yard//lib/yard/tags/types_explainer.rb#45
+  def list_join(list); end
+end
+
+# Modifies the current parsing visibility (public, protected, or private).
+# If this directive is defined on a docstring attached to an object
+# definition, it is applied only to that object. Otherwise, it applies
+# the visibility to all future objects in the namespace.
+#
+# @example Modifying the visibility of a DSL method
+#   # @!visibility private
+#   cattr_accessor :subclasses
+# @example Modifying the visibility of a set of methods
+#   # Note that Ruby's "protected" is recommended over this directive
+#   # @!visibility protected
+#
+#   # Documentation for method1
+#   def method1; end
+#
+#   # Documentation for method2
+#   def method2; end
+# @since 0.7.0
+#
+# source://yard//lib/yard/tags/directives.rb#610
+class YARD::Tags::VisibilityDirective < ::YARD::Tags::Directive
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/tags/directives.rb#611
+  def call; end
+end
+
+# Namespace for templating system
+#
+# source://yard//lib/yard/autoload.rb#271
+module YARD::Templates; end
+
+# This module manages all creation, handling and rendering of {Template}
+# objects.
+#
+# * To create a template object at a path, use {template}.
+# * To render a template, call {render}.
+# * To register a template path in the lookup paths, call {register_template_path}.
+#
+# source://yard//lib/yard/templates/engine.rb#11
+module YARD::Templates::Engine
+  class << self
+    # Passes a set of objects to the +:fulldoc+ template for full documentation generation.
+    # This is called by {CLI::Yardoc} to most commonly perform HTML
+    # documentation generation.
+    #
+    # @param objects [Array<CodeObjects::Base>] a list of {CodeObjects::Base}
+    #   objects to pass to the template
+    # @param options [Hash] (see {render})
+    # @return [void]
+    #
+    # source://yard//lib/yard/templates/engine.rb#100
+    def generate(objects, options = T.unsafe(nil)); end
+
+    # Registers a new template path in {template_paths}
+    #
+    # @param path [String] a new template path
+    # @return [void]
+    #
+    # source://yard//lib/yard/templates/engine.rb#20
+    def register_template_path(path); end
+
+    # Renders a template on a {CodeObjects::Base code object} using
+    # a set of default (overridable) options. Either the +:object+
+    # or +:type+ keys must be provided.
+    #
+    # If a +:serializer+ key is provided and +:serialize+ is not set to
+    # false, the rendered contents will be serialized through the {Serializers::Base}
+    # object. See {with_serializer}.
+    #
+    # @example Renders an object with html formatting
+    #   Engine.render(:format => :html, :object => obj)
+    # @example Renders without an object
+    #   Engine.render(:type => :fulldoc, :otheropts => somevalue)
+    # @option options
+    # @option options
+    # @option options
+    # @param options [Hash] the options hash
+    # @return [String] the rendered template
+    #
+    # source://yard//lib/yard/templates/engine.rb#81
+    def render(options = T.unsafe(nil)); end
+
+    # Creates a template module representing the path. Searches on disk
+    # for the first directory named +path+ (joined by '/') within the
+    # template paths and builds a template module for. All other matching
+    # directories in other template paths will be included in the
+    # generated module as mixins (for overriding).
+    #
+    # @param path [Array<String, Symbol>] a list of path components
+    # @raise [ArgumentError] if the path does not exist within one of the
+    #   {template_paths} on disk.
+    # @return [Template] the module representing the template
+    #
+    # source://yard//lib/yard/templates/engine.rb#34
+    def template(*path); end
+
+    # Forces creation of a template at +path+ within a +full_path+.
+    #
+    # @param path [String] the path name of the template
+    # @param full_paths [Array<String>] the full path on disk of the template
+    # @return [Template] the template module representing the +path+
+    #
+    # source://yard//lib/yard/templates/engine.rb#52
+    def template!(path, full_paths = T.unsafe(nil)); end
+
+    # @return [Array<String>] the list of registered template paths
+    #
+    # source://yard//lib/yard/templates/engine.rb#14
+    def template_paths; end
+
+    # @return [Array<String>] the list of registered template paths
+    #
+    # source://yard//lib/yard/templates/engine.rb#14
+    def template_paths=(_arg0); end
+
+    # Serializes the results of a block with a +serializer+ object.
+    #
+    # @param object [CodeObjects::Base] the code object to serialize
+    # @param serializer [Serializers::Base] the serializer object
+    # @see Serializers::Base
+    # @yield a block whose result will be serialize
+    # @yieldreturn [String] the contents to serialize
+    #
+    # source://yard//lib/yard/templates/engine.rb#114
+    def with_serializer(object, serializer); end
+
+    private
+
+    # Searches through the registered {template_paths} and returns
+    # all full directories that have the +path+ within them on disk.
+    #
+    # @param from_template [Template] if provided, allows a relative
+    #   path to be specified from this template's full path.
+    # @param path [String] the path component to search for in the
+    #   {template_paths}
+    # @return [Array<String>] a list of full paths that are existing
+    #   candidates for a template module
+    #
+    # source://yard//lib/yard/templates/engine.rb#160
+    def find_template_paths(from_template, path); end
+
+    # Sets default options on the options hash
+    #
+    # @option options
+    # @option options
+    # @option options
+    # @param options [Hash] the options hash
+    # @return [void]
+    #
+    # source://yard//lib/yard/templates/engine.rb#140
+    def set_default_options(options = T.unsafe(nil)); end
+
+    # The name of the module that represents a +path+
+    #
+    # @param path [String] the path to generate a module name for
+    # @return [String] the module name
+    #
+    # source://yard//lib/yard/templates/engine.rb#175
+    def template_module_name(path); end
+  end
+end
+
+# @since 0.5.4
+#
+# source://yard//lib/yard/templates/erb_cache.rb#5
+module YARD::Templates::ErbCache
+  class << self
+    # @since 0.5.4
+    #
+    # source://yard//lib/yard/templates/erb_cache.rb#17
+    def clear!; end
+
+    # @since 0.5.4
+    #
+    # source://yard//lib/yard/templates/erb_cache.rb#6
+    def method_for(filename); end
+  end
+end
+
+# Namespace for template helpers
+#
+# source://yard//lib/yard/autoload.rb#272
+module YARD::Templates::Helpers; end
+
+# The base helper module included in all templates.
+#
+# source://yard//lib/yard/templates/helpers/base_helper.rb#4
+module YARD::Templates::Helpers::BaseHelper
+  # @example
+  #   s = format_object_title ModuleObject.new(:root, :MyModuleName)
+  #   s # => "Module: MyModuleName"
+  # @param object [CodeObjects::Base] the object to retrieve a title for
+  # @return [String] the page title name for a given object
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#196
+  def format_object_title(object); end
+
+  # @example Formatted type of an exception class
+  #   o = ClassObject.new(:root, :MyError)
+  #   o.superclass = P('RuntimeError')
+  #   format_object_type(o) # => "Exception"
+  # @example Formatted type of a method
+  #   o = MethodObject.new(:root, :to_s)
+  #   format_object_type(o) # => "Method"
+  # @param object [CodeObjects::Base] the object to retrieve the type for
+  # @return [String] the human-readable formatted {CodeObjects::Base#type #type}
+  #   for the object
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#182
+  def format_object_type(object); end
+
+  # Indents and formats source code
+  #
+  # @param value [String] the input source code
+  # @return [String] formatted source code
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#209
+  def format_source(value); end
+
+  # Formats a list of return types for output and links each type.
+  #
+  # @example Formatting types
+  #   format_types(['String', 'Array']) #=> "(String, Array)"
+  # @example Formatting types without surrounding brackets
+  #   format_types(['String', 'Array'], false) #=> "String, Array"
+  # @param list [Array<String>] a list of types
+  # @param brackets [Boolean] whether to surround the types in brackets
+  # @return [String] the formatted list of Ruby types
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#168
+  def format_types(list, brackets = T.unsafe(nil)); end
+
+  # An object that keeps track of global state throughout the entire template
+  # rendering process (including any sub-templates).
+  #
+  # @return [OpenStruct] a struct object that stores state
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#20
+  def globals; end
+
+  # Escapes text. This is used a lot by the HtmlHelper and there should
+  # be some helper to "clean up" text for whatever, this is it.
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#38
+  def h(text); end
+
+  # Links to an extra file
+  #
+  # @param filename [String] the filename to link to
+  # @param title [String] the title of the link
+  # @param anchor [String] optional anchor
+  # @return [String] the link to the file
+  # @since 0.5.5
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#152
+  def link_file(filename, title = T.unsafe(nil), anchor = T.unsafe(nil)); end
+
+  # Include a file as a docstring in output
+  #
+  # @param file [String] the filename to include
+  # @return [String] the file's contents
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#113
+  def link_include_file(file); end
+
+  # Includes an object's docstring into output.
+  #
+  # @param obj [CodeObjects::Base] the object to include
+  # @return [String] the object's docstring (no tags)
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#105
+  def link_include_object(obj); end
+
+  # Links to an object with an optional title
+  #
+  # @param obj [CodeObjects::Base] the object to link to
+  # @param title [String] the title to use for the link
+  # @return [String] the linked object
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#122
+  def link_object(obj, title = T.unsafe(nil)); end
+
+  # Links to a URL
+  #
+  # @param url [String] the URL to link to
+  # @param title [String] the optional title to display the link as
+  # @param params [Hash] optional parameters for the link
+  # @return [String] the linked URL
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#141
+  def link_url(url, title = T.unsafe(nil), params = T.unsafe(nil)); end
+
+  # Links objects or URLs. This method will delegate to the correct +link_+
+  # method depending on the arguments passed in.
+  #
+  # @example Linking a URL
+  #   linkify('http://example.com')
+  # @example Including docstring contents of an object
+  #   linkify('include:YARD::Docstring')
+  # @example Linking to an extra file
+  #   linkify('file:README')
+  # @example Linking an object by path
+  #   linkify('YARD::Docstring')
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#55
+  def linkify(*args); end
+
+  # Returns the value of attribute object.
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#5
+  def object; end
+
+  # Sets the attribute object
+  #
+  # @param value the value to set the attribute object to.
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#5
+  def object=(_arg0); end
+
+  # @return [CodeObjects::Base] the object representing the current generated
+  #   page. Might not be the current {#object} when inside sub-templates.
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#11
+  def owner; end
+
+  # Runs a list of objects against the {Verifier} object passed into the
+  # template and returns the subset of verified objects.
+  #
+  # @param list [Array<CodeObjects::Base>] a list of code objects
+  # @return [Array<CodeObjects::Base>] a list of code objects that match
+  #   the verifier. If no verifier is supplied, all objects are returned.
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#30
+  def run_verifier(list); end
+
+  # Returns the value of attribute serializer.
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#5
+  def serializer; end
+
+  # Sets the attribute serializer
+  #
+  # @param value the value to set the attribute serializer to.
+  #
+  # source://yard//lib/yard/templates/helpers/base_helper.rb#5
+  def serializer=(_arg0); end
+end
+
+# Helpers for various object types
+#
+# source://yard//lib/yard/templates/helpers/filter_helper.rb#5
+module YARD::Templates::Helpers::FilterHelper
+  # @return [Boolean] whether an object is a class
+  #
+  # source://yard//lib/yard/templates/helpers/filter_helper.rb#17
+  def is_class?(object); end
+
+  # @return [Boolean] whether an object is a method
+  #
+  # source://yard//lib/yard/templates/helpers/filter_helper.rb#7
+  def is_method?(object); end
+
+  # @return [Boolean] whether an object is a module
+  #
+  # source://yard//lib/yard/templates/helpers/filter_helper.rb#22
+  def is_module?(object); end
+
+  # @return [Boolean] whether an object is a namespace
+  #
+  # source://yard//lib/yard/templates/helpers/filter_helper.rb#12
+  def is_namespace?(object); end
+end
+
+# The helper module for HTML templates.
+#
+# source://yard//lib/yard/templates/helpers/html_helper.rb#7
+module YARD::Templates::Helpers::HtmlHelper
+  include ::YARD::Templates::Helpers::MarkupHelper
+  include ::YARD::Templates::Helpers::ModuleHelper
+  include ::YARD::Templates::Helpers::HtmlSyntaxHighlightHelper
+
+  # @param object [CodeObjects::Base] the object to get an anchor for
+  # @return [String] the anchor for a specific object
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#347
+  def anchor_for(object); end
+
+  # Returns the current character set. The default value can be overridden
+  # by setting the +LANG+ environment variable or by overriding this
+  # method. In Ruby 1.9 you can also modify this value by setting
+  # +Encoding.default_external+.
+  #
+  # @return [String] the current character set
+  # @since 0.5.4
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#574
+  def charset; end
+
+  # Formats a list of objects and links them
+  #
+  # @return [String] a formatted list of objects
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#458
+  def format_object_name_list(objects); end
+
+  # Formats a list of types from a tag.
+  #
+  # @param typelist [Array<String>, FalseClass] the list of types to be formatted.
+  # @param brackets [Boolean] omits the surrounding
+  #   brackets if +brackets+ is set to +false+.
+  # @return [String] the list of types formatted
+  #   as [Type1, Type2, ...] with the types linked
+  #   to their respective descriptions.
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#476
+  def format_types(typelist, brackets = T.unsafe(nil)); end
+
+  # Escapes HTML entities
+  #
+  # @param text [String] the text to escape
+  # @return [String] the HTML with escaped entities
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#23
+  def h(text); end
+
+  # Converts Asciidoc to HTML
+  #
+  # @param text [String] input Asciidoc text
+  # @return [String] output HTML
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#109
+  def html_markup_asciidoc(text); end
+
+  # Converts HTML to HTML
+  #
+  # @param text [String] input html
+  # @return [String] output HTML
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#168
+  def html_markup_html(text); end
+
+  # Converts Markdown to HTML
+  #
+  # @param text [String] input Markdown text
+  # @return [String] output HTML
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#78
+  def html_markup_markdown(text); end
+
+  # @return [String] the same text with no markup
+  # @since 0.6.6
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#160
+  def html_markup_none(text); end
+
+  # Converts org-mode to HTML
+  #
+  # @param text [String] input org-mode text
+  # @return [String] output HTML
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#102
+  def html_markup_org(text); end
+
+  # Converts plaintext to pre-formatted HTML
+  #
+  # @param text [String] the input text
+  # @return [String] the output HTML
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#146
+  def html_markup_pre(text); end
+
+  # Converts RDoc formatting (SimpleMarkup) to HTML
+  #
+  # @param text [String] the input RDoc formatted text
+  # @return [String] output HTML
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#136
+  def html_markup_rdoc(text); end
+
+  # Highlights Ruby source. Similar to {#html_syntax_highlight}, but
+  # this method is meant to be called from {#htmlify} when markup is
+  # set to "ruby".
+  #
+  # @param source [String] the Ruby source
+  # @return [String] the highlighted HTML
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#179
+  def html_markup_ruby(source); end
+
+  # Converts plaintext to regular HTML
+  #
+  # @param text [String] the input text
+  # @return [String] the output HTML
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#154
+  def html_markup_text(text); end
+
+  # Converts Textile to HTML
+  #
+  # @param text [String] the input Textile text
+  # @return [String] output HTML
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#118
+  def html_markup_textile(text); end
+
+  # Converts plaintext to strict Textile (hard breaks)
+  #
+  # @param text [String] the input textile data
+  # @return [String] the output HTML
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#128
+  def html_markup_textile_strict(text); end
+
+  # Syntax highlights +source+ in language +type+.
+  #
+  # @note To support a specific language +type+, implement the method
+  #   +html_syntax_highlight_TYPE+ in this class.
+  # @param source [String] the source code to highlight
+  # @param type [Symbol, String] the language type (:ruby, :plain, etc). Use
+  #   :plain for no syntax highlighting.
+  # @return [String] the highlighted source
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#199
+  def html_syntax_highlight(source, type = T.unsafe(nil)); end
+
+  # @return [String] unhighlighted source
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#210
+  def html_syntax_highlight_plain(source); end
+
+  # Turns text into HTML using +markup+ style formatting.
+  #
+  # @param text [String] the text to format
+  # @param markup [Symbol] examples are +:markdown+, +:textile+, +:rdoc+.
+  #   To add a custom markup type, see {MarkupHelper}
+  # @return [String] the HTML
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#57
+  def htmlify(text, markup = T.unsafe(nil)); end
+
+  # @return [String] HTMLified text as a single line (paragraphs removed)
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#184
+  def htmlify_line(*args); end
+
+  # Inserts an include link while respecting inlining
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#296
+  def insert_include(text, markup = T.unsafe(nil)); end
+
+  # Links to an extra file
+  #
+  # @param filename [String] the filename to link to
+  # @param title [String] the title of the link
+  # @param anchor [String] optional anchor
+  # @return [String] the link to the file
+  # @since 0.5.5
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#270
+  def link_file(filename, title = T.unsafe(nil), anchor = T.unsafe(nil)); end
+
+  # Include a file as a docstring in output
+  #
+  # @param file [String] the filename to include
+  # @return [String] the file's contents
+  # @since 0.7.0
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#282
+  def link_include_file(file); end
+
+  # Includes an object's docstring into output.
+  #
+  # @param obj [CodeObjects::Base] the object to include
+  # @return [String] the object's docstring (no tags)
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#291
+  def link_include_object(obj); end
+
+  # Links to an object with an optional title
+  #
+  # @param obj [CodeObjects::Base] the object to link to
+  # @param title [String] the title to use for the link
+  # @return [String] the linked object
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#301
+  def link_object(obj, title = T.unsafe(nil), anchor = T.unsafe(nil), relative = T.unsafe(nil)); end
+
+  # Links to a URL
+  #
+  # @param url [String] the URL to link to
+  # @param title [String] the optional title to display the link as
+  # @param params [Hash] optional parameters for the link
+  # @return [String] the linked URL
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#332
+  def link_url(url, title = T.unsafe(nil), params = T.unsafe(nil)); end
+
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#400
+  def mtime(_file); end
+
+  # Returns the URL for an object.
+  #
+  # @param obj [String, CodeObjects::Base] the object (or object path) to link to
+  # @param anchor [String] the anchor to link to
+  # @param relative [Boolean] use a relative or absolute link
+  # @return [String] the URL location of the object
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#368
+  def mtime_url(obj, anchor = T.unsafe(nil), relative = T.unsafe(nil)); end
+
+  # Resolves any text in the form of +{Name}+ to the object specified by
+  # Name. Also supports link titles in the form +{Name title}+.
+  #
+  # @example Linking to an instance method
+  #   resolve_links("{MyClass#method}") # => "<a href='...'>MyClass#method</a>"
+  # @example Linking to a class with a title
+  #   resolve_links("{A::B::C the C class}") # => "<a href='...'>the c class</a>"
+  # @param text [String] the text to resolve links in
+  # @return [String] HTML with linkified references
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#225
+  def resolve_links(text); end
+
+  # Formats the signature of method +meth+.
+  #
+  # @param meth [CodeObjects::MethodObject] the method object to list
+  #   the signature of
+  # @param link [Boolean] whether to link the method signature to the details view
+  # @param show_extras [Boolean] whether to show extra meta-data (visibility, attribute info)
+  # @param full_attr_name [Boolean] whether to show the full attribute name
+  #   ("name=" instead of "name")
+  # @return [String] the formatted method signature
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#529
+  def signature(meth, link = T.unsafe(nil), show_extras = T.unsafe(nil), full_attr_name = T.unsafe(nil)); end
+
+  # Get the return types for a method signature.
+  #
+  # @param meth [CodeObjects::MethodObject] the method object
+  # @param link [Boolean] whether to link the types
+  # @return [String] the signature types
+  # @since 0.5.3
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#492
+  def signature_types(meth, link = T.unsafe(nil)); end
+
+  # Returns the URL for an object.
+  #
+  # @param obj [String, CodeObjects::Base] the object (or object path) to link to
+  # @param anchor [String] the anchor to link to
+  # @param relative [Boolean] use a relative or absolute link
+  # @return [String] the URL location of the object
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#368
+  def url_for(obj, anchor = T.unsafe(nil), relative = T.unsafe(nil)); end
+
+  # Returns the URL for a specific file
+  #
+  # @param filename [String, CodeObjects::ExtraFileObject] the filename to link to
+  # @param anchor [String] optional anchor
+  # @return [String] the URL pointing to the file
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#407
+  def url_for_file(filename, anchor = T.unsafe(nil)); end
+
+  # Returns the URL for the frameset page
+  #
+  # @return [String] the URL pointing to the frames page
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#434
+  def url_for_frameset; end
+
+  # Returns the URL for the alphabetic index page
+  #
+  # @return [String] the URL pointing to the first main page the
+  #   user should see.
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#450
+  def url_for_index; end
+
+  # Returns the URL for a list type
+  #
+  # @param type [String, Symbol] the list type to generate a URL for
+  # @return [String] the URL pointing to the list
+  # @since 0.8.0
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#426
+  def url_for_list(type); end
+
+  # Returns the URL for the main page (README or alphabetic index)
+  #
+  # @return [String] the URL pointing to the first main page the
+  #   user should see.
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#442
+  def url_for_main; end
+
+  private
+
+  # Converts a {CodeObjects::MethodObject} into an overload object
+  #
+  # @since 0.5.3
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#609
+  def convert_method_to_overload(meth); end
+
+  # Parses code block's HTML attributes in order to detect the programming
+  # language of what's enclosed in that code block.
+  #
+  # @param pre_html_attrs [String, nil] HTML attribute list of +pre+ element
+  # @param code_html_attrs [String, nil] HTML attribute list of +code+
+  #   element
+  # @return [String, nil] detected programming language
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#664
+  def detect_lang_in_codeblock_attributes(pre_html_attrs, code_html_attrs); end
+
+  # Parses code blocks out of html and performs syntax highlighting
+  # on code inside of the blocks.
+  #
+  # @param html [String] the html to search for code in
+  # @return [String] highlighted html
+  # @see #html_syntax_highlight
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#640
+  def parse_codeblocks(html); end
+
+  # Parses !!!lang out of codeblock, returning the codeblock language
+  # followed by the source code.
+  #
+  # @param source [String] the source code whose language to determine
+  # @return [Array(String, String)] the language, if any, and the
+  #   remaining source
+  # @since 0.7.5
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#624
+  def parse_lang_for_codeblock(source); end
+
+  # Converts a set of hash options into HTML attributes for a tag
+  #
+  # @param opts [Hash{String => String}] the tag options
+  # @return [String] the tag attributes of an HTML tag
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#603
+  def tag_attrs(opts = T.unsafe(nil)); end
+
+  # Escapes a URL
+  #
+  # @param text [String] the URL
+  # @return [String] the escaped URL
+  #
+  # source://yard//lib/yard/templates/helpers/html_helper.rb#31
+  def urlencode(text); end
+
+  class << self
+    # Escapes a URL
+    #
+    # @param text [String] the URL
+    # @return [String] the escaped URL
+    #
+    # source://yard//lib/yard/templates/helpers/html_helper.rb#31
+    def urlencode(text); end
+  end
+end
+
+# @private
+#
+# source://yard//lib/yard/templates/helpers/html_helper.rb#15
+YARD::Templates::Helpers::HtmlHelper::ASCIIDOC_ATTRIBUTES = T.let(T.unsafe(nil), Hash)
+
+# @private
+#
+# source://yard//lib/yard/templates/helpers/html_helper.rb#12
+YARD::Templates::Helpers::HtmlHelper::URLMATCH = T.let(T.unsafe(nil), Regexp)
+
+# Helper methods for syntax highlighting.
+#
+# source://yard//lib/yard/templates/helpers/html_syntax_highlight_helper.rb#6
+module YARD::Templates::Helpers::HtmlSyntaxHighlightHelper
+  include ::YARD::Templates::Helpers::ModuleHelper
+
+  # Highlights Ruby source
+  #
+  # @param source [String] the Ruby source code
+  # @return [String] the highlighted Ruby source
+  #
+  # source://yard//lib/yard/templates/helpers/html_syntax_highlight_helper.rb#12
+  def html_syntax_highlight_ruby(source); end
+
+  private
+
+  # source://yard//lib/yard/templates/helpers/html_syntax_highlight_helper.rb#63
+  def clean_token_object(token_obj); end
+
+  # source://yard//lib/yard/templates/helpers/html_syntax_highlight_helper.rb#45
+  def html_syntax_highlight_ruby_legacy(source); end
+
+  # source://yard//lib/yard/templates/helpers/html_syntax_highlight_helper.rb#22
+  def html_syntax_highlight_ruby_ripper(source); end
+end
+
+# Namespace for markup providers
+#
+# source://yard//lib/yard/autoload.rb#273
+module YARD::Templates::Helpers::Markup; end
+
+# source://yard//lib/yard/templates/helpers/markup/rdoc_markdown.rb#13
+class YARD::Templates::Helpers::Markup::RDocMarkdown < ::YARD::Templates::Helpers::Markup::RDocMarkup
+  # @return [RDocMarkdown] a new instance of RDocMarkdown
+  #
+  # source://yard//lib/yard/templates/helpers/markup/rdoc_markdown.rb#14
+  def initialize(text); end
+
+  # source://yard//lib/yard/templates/helpers/markup/rdoc_markdown.rb#18
+  def fix_typewriter(html); end
+end
+
+# source://yard//lib/yard/templates/helpers/markup/rdoc_markup.rb#12
+class YARD::Templates::Helpers::Markup::RDocMarkup
+  # @return [RDocMarkup] a new instance of RDocMarkup
+  #
+  # source://yard//lib/yard/templates/helpers/markup/rdoc_markup.rb#41
+  def initialize(text); end
+
+  # Returns the value of attribute from_path.
+  #
+  # source://yard//lib/yard/templates/helpers/markup/rdoc_markup.rb#35
+  def from_path; end
+
+  # Sets the attribute from_path
+  #
+  # @param value the value to set the attribute from_path to.
+  #
+  # source://yard//lib/yard/templates/helpers/markup/rdoc_markup.rb#35
+  def from_path=(_arg0); end
+
+  # source://yard//lib/yard/templates/helpers/markup/rdoc_markup.rb#50
+  def to_html; end
+
+  private
+
+  # Don't allow -- to turn into &#8212; element. The chances of this being
+  # some --option is far more likely than the typographical meaning.
+  #
+  # @todo Refactor into own SimpleMarkup subclass
+  #
+  # source://yard//lib/yard/templates/helpers/markup/rdoc_markup.rb#87
+  def fix_dash_dash(text); end
+
+  # Fixes RDoc behaviour with ++ only supporting alphanumeric text.
+  #
+  # @todo Refactor into own SimpleMarkup subclass
+  #
+  # source://yard//lib/yard/templates/helpers/markup/rdoc_markup.rb#66
+  def fix_typewriter(text); end
+end
+
+# source://yard//lib/yard/templates/helpers/markup/rdoc_markup.rb#12
+YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP = RDoc::Markup
+
+# source://yard//lib/yard/templates/helpers/markup/rdoc_markup.rb#13
+class YARD::Templates::Helpers::Markup::RDocMarkupToHtml < ::RDoc::Markup::ToHtml
+  # source://yard//lib/yard/templates/helpers/markup/rdoc_markup.rb#16
+  def initialize; end
+
+  # source://yard//lib/yard/templates/helpers/markup/rdoc_markup.rb#100
+  def accept_paragraph(*args); end
+
+  # Returns the value of attribute from_path.
+  #
+  # source://yard//lib/yard/templates/helpers/markup/rdoc_markup.rb#93
+  def from_path; end
+
+  # Sets the attribute from_path
+  #
+  # @param value the value to set the attribute from_path to.
+  #
+  # source://yard//lib/yard/templates/helpers/markup/rdoc_markup.rb#93
+  def from_path=(_arg0); end
+
+  # Disable auto-link of URLs
+  #
+  # source://yard//lib/yard/templates/helpers/markup/rdoc_markup.rb#96
+  def handle_special_HYPERLINK(special); end
+end
+
+# Helper methods for loading and managing markup types.
+#
+# source://yard//lib/yard/templates/helpers/markup_helper.rb#7
+module YARD::Templates::Helpers::MarkupHelper
+  # Attempts to load the first valid markup provider in {MARKUP_PROVIDERS}.
+  # If a provider is specified, immediately try to load it.
+  #
+  # On success this sets `@markup_provider` and `@markup_class` to
+  # the provider name and library constant class/module respectively for
+  # the loaded provider.
+  #
+  # On failure this method will inform the user that no provider could be
+  # found and exit the program.
+  #
+  # @return [Boolean] whether the markup provider was successfully loaded.
+  #
+  # source://yard//lib/yard/templates/helpers/markup_helper.rb#87
+  def load_markup_provider(type = T.unsafe(nil)); end
+
+  # Gets the markup provider class/module constant for a markup type
+  # Call {#load_markup_provider} before using this method.
+  #
+  # @param type [Symbol] the markup type (:rdoc, :markdown, etc.)
+  # @return [Class] the markup class
+  #
+  # source://yard//lib/yard/templates/helpers/markup_helper.rb#158
+  def markup_class(type = T.unsafe(nil)); end
+
+  # Strips any shebang lines on the file contents that pertain to
+  # markup or preprocessing data.
+  #
+  # @deprecated Use {CodeObjects::ExtraFileObject#contents} instead
+  # @return [String] the file contents minus any preprocessing tags
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/helpers/markup_helper.rb#149
+  def markup_file_contents(contents); end
+
+  # Checks for a shebang or looks at the file extension to determine
+  # the markup type for the file contents. File extensions are registered
+  # for a markup type in {MARKUP_EXTENSIONS}.
+  #
+  # A shebang should be on the first line of a file and be in the form:
+  #
+  #   #!markup_type
+  #
+  # Standard markup types are text, html, rdoc, markdown, textile
+  #
+  # @param contents [String] Unused. Was necessary prior to 0.7.0.
+  #   Newer versions of YARD use {CodeObjects::ExtraFileObject#contents}
+  # @return [Symbol] the markup type recognized for the file
+  # @see MARKUP_EXTENSIONS
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/helpers/markup_helper.rb#133
+  def markup_for_file(contents, filename); end
+
+  # Gets the markup provider name for a markup type
+  # Call {#load_markup_provider} before using this method.
+  #
+  # @param type [Symbol] the markup type (:rdoc, :markdown, etc.)
+  # @return [Symbol] the markup provider name (usually the gem name of the library)
+  #
+  # source://yard//lib/yard/templates/helpers/markup_helper.rb#168
+  def markup_provider(type = T.unsafe(nil)); end
+
+  class << self
+    # Clears the markup provider cache information. Mainly used for testing.
+    #
+    # @return [void]
+    #
+    # source://yard//lib/yard/templates/helpers/markup_helper.rb#11
+    def clear_markup_cache; end
+
+    # @private
+    # @return [Hash{Symbol=>{(:provider,:class)=>Object}}] the cached markup providers
+    # @since 0.6.4
+    #
+    # source://yard//lib/yard/templates/helpers/markup_helper.rb#18
+    def markup_cache; end
+
+    # @private
+    # @return [Hash{Symbol=>{(:provider,:class)=>Object}}] the cached markup providers
+    # @since 0.6.4
+    #
+    # source://yard//lib/yard/templates/helpers/markup_helper.rb#18
+    def markup_cache=(_arg0); end
+  end
+end
+
+# Returns a list of extensions for various markup types. To register
+# extensions for a type, add them to the array of extensions for the
+# type.
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/templates/helpers/markup_helper.rb#61
+YARD::Templates::Helpers::MarkupHelper::MARKUP_EXTENSIONS = T.let(T.unsafe(nil), Hash)
+
+# Contains the Regexp object that matches the shebang line of extra
+# files to detect the markup type.
+#
+# source://yard//lib/yard/templates/helpers/markup_helper.rb#74
+YARD::Templates::Helpers::MarkupHelper::MARKUP_FILE_SHEBANG = T.let(T.unsafe(nil), Regexp)
+
+# The default list of markup providers for each markup type
+#
+# source://yard//lib/yard/templates/helpers/markup_helper.rb#24
+YARD::Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS = T.let(T.unsafe(nil), Hash)
+
+# Helper methods for method objects.
+#
+# source://yard//lib/yard/templates/helpers/method_helper.rb#5
+module YARD::Templates::Helpers::MethodHelper
+  # @return [String] formatted arguments for a method
+  #
+  # source://yard//lib/yard/templates/helpers/method_helper.rb#7
+  def format_args(object); end
+
+  # @return [String] formatted block if one exists
+  #
+  # source://yard//lib/yard/templates/helpers/method_helper.rb#35
+  def format_block(object); end
+
+  # @return [String] formats source of an object
+  #
+  # source://yard//lib/yard/templates/helpers/method_helper.rb#57
+  def format_code(object, _show_lines = T.unsafe(nil)); end
+
+  # @return [String] formats source code of a constant value
+  #
+  # source://yard//lib/yard/templates/helpers/method_helper.rb#68
+  def format_constant(value); end
+
+  # @return [String] formats line numbers for source code of an object
+  #
+  # source://yard//lib/yard/templates/helpers/method_helper.rb#50
+  def format_lines(object); end
+
+  # @return [String] formatted and linked return types for a method
+  #
+  # source://yard//lib/yard/templates/helpers/method_helper.rb#28
+  def format_return_types(object); end
+end
+
+# Helper methods for managing module objects.
+#
+# source://yard//lib/yard/templates/helpers/module_helper.rb#6
+module YARD::Templates::Helpers::ModuleHelper
+  # Prunes the method listing by running the verifier and removing attributes/aliases
+  #
+  # @param list [Array<CodeObjects::Base>] a list of methods
+  # @param hide_attributes [Boolean] whether to prune attribute methods from the list
+  # @return [Array<CodeObjects::Base>] a pruned list of methods
+  #
+  # source://yard//lib/yard/templates/helpers/module_helper.rb#11
+  def prune_method_listing(list, hide_attributes = T.unsafe(nil)); end
+end
+
+# Helper methods for text template formats.
+#
+# source://yard//lib/yard/templates/helpers/text_helper.rb#6
+module YARD::Templates::Helpers::TextHelper
+  # @return [String] aligns text to the right
+  #
+  # source://yard//lib/yard/templates/helpers/text_helper.rb#39
+  def align_right(text, spacer = T.unsafe(nil), col = T.unsafe(nil)); end
+
+  # @return [String] escapes text
+  #
+  # source://yard//lib/yard/templates/helpers/text_helper.rb#8
+  def h(text); end
+
+  # @return [String] returns a horizontal rule for output
+  #
+  # source://yard//lib/yard/templates/helpers/text_helper.rb#45
+  def hr(col = T.unsafe(nil), sep = T.unsafe(nil)); end
+
+  # @return [String] indents +text+ by +len+ characters.
+  #
+  # source://yard//lib/yard/templates/helpers/text_helper.rb#29
+  def indent(text, len = T.unsafe(nil)); end
+
+  # @return [String] the formatted signature for a method
+  #
+  # source://yard//lib/yard/templates/helpers/text_helper.rb#50
+  def signature(meth); end
+
+  # @return [String] aligns a title to the right
+  #
+  # source://yard//lib/yard/templates/helpers/text_helper.rb#34
+  def title_align_right(text, col = T.unsafe(nil)); end
+
+  # @return [String] wraps text at +col+ columns.
+  #
+  # source://yard//lib/yard/templates/helpers/text_helper.rb#24
+  def wrap(text, col = T.unsafe(nil)); end
+
+  private
+
+  # source://yard//lib/yard/templates/helpers/text_helper.rb#98
+  def resolve_links(text); end
+end
+
+# Helpers for UML template format
+#
+# source://yard//lib/yard/templates/helpers/uml_helper.rb#5
+module YARD::Templates::Helpers::UMLHelper
+  # Formats the path of an object for Graphviz syntax
+  #
+  # @param object [CodeObjects::Base] an object to format the path of
+  # @return [String] the encoded path
+  #
+  # source://yard//lib/yard/templates/helpers/uml_helper.rb#20
+  def format_path(object); end
+
+  # Encodes text in escaped Graphviz syntax
+  #
+  # @param text [String] text to encode
+  # @return [String] the encoded text
+  #
+  # source://yard//lib/yard/templates/helpers/uml_helper.rb#27
+  def h(text); end
+
+  # Tidies data by formatting and indenting text
+  #
+  # @param data [String] pre-formatted text
+  # @return [String] tidied text.
+  #
+  # source://yard//lib/yard/templates/helpers/uml_helper.rb#34
+  def tidy(data); end
+
+  # Official UML visibility prefix syntax for an object given its visibility
+  #
+  # @param object [CodeObjects::Base] the object to retrieve visibility for
+  # @return [String] the UML visibility prefix
+  #
+  # source://yard//lib/yard/templates/helpers/uml_helper.rb#9
+  def uml_visibility(object); end
+end
+
+# Abstracts the structure for a section and its subsections into an ordered
+# list of sections and subsections.
+#
+# @since 0.6.0
+#
+# source://yard//lib/yard/templates/section.rb#7
+class YARD::Templates::Section < ::Array
+  # @return [Section] a new instance of Section
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#10
+  def initialize(name, *args); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#45
+  def <<(*args); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#34
+  def ==(other); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#21
+  def [](*args); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#74
+  def any(item); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#15
+  def dup; end
+
+  # @return [Boolean]
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#30
+  def eql?(other); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#54
+  def inspect; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#8
+  def name; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#8
+  def name=(_arg0); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#60
+  def place(*args); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#45
+  def push(*args); end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#64
+  def to_a; end
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#50
+  def unshift(*args); end
+
+  private
+
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/section.rb#84
+  def parse_sections(args); end
+end
+
+# source://yard//lib/yard/templates/template.rb#6
+module YARD::Templates::Template
+  include ::YARD::Templates::ErbCache
+  include ::YARD::Templates::Helpers::BaseHelper
+  include ::YARD::Templates::Helpers::MethodHelper
+
+  mixes_in_class_methods ::YARD::Templates::Template::ClassMethods
+
+  # source://yard//lib/yard/templates/template.rb#186
+  def initialize(opts = T.unsafe(nil)); end
+
+  # Loads a template specified by path. If +:template+ or +:format+ is
+  # specified in the {#options} hash, they are prepended and appended
+  # to the path respectively.
+  #
+  # @param path [Array<String, Symbol>] the path of the template
+  # @return [Template] the loaded template module
+  #
+  # source://yard//lib/yard/templates/template.rb#204
+  def T(*path); end
+
+  # Returns the value of attribute class.
+  #
+  # source://yard//lib/yard/templates/template.rb#7
+  def class; end
+
+  # Sets the attribute class
+  #
+  # @param value the value to set the attribute class to.
+  #
+  # source://yard//lib/yard/templates/template.rb#7
+  def class=(_arg0); end
+
+  # @param section [String, Symbol] the section name
+  # @return [String] the contents of the ERB rendered section
+  # @yield calls subsections to be rendered
+  #
+  # source://yard//lib/yard/templates/template.rb#285
+  def erb(section, &block); end
+
+  # Returns the contents of a file. If +allow_inherited+ is set to +true+,
+  # use +{{{__super__}}}+ inside the file contents to insert the contents
+  # of the file from an inherited template. For instance, if +templates/b+
+  # inherits from +templates/a+ and file "test.css" exists in both directories,
+  # both file contents can be retrieved by having +templates/b/test.css+ look
+  # like:
+  #
+  #   {{{__super__}}}
+  #   ...
+  #   body { css styles here }
+  #   p.class { other styles }
+  #
+  # @param basename [String] the name of the file
+  # @param allow_inherited [Boolean] whether inherited templates can
+  #   be inserted with +{{{__super__}}}+
+  # @raise [ArgumentError]
+  # @return [String] the contents of a file identified by +basename+. All
+  #   template paths (including any mixed in templates) are searched for
+  #   the file
+  # @see ClassMethods#find_file
+  # @see ClassMethods#find_nth_file
+  #
+  # source://yard//lib/yard/templates/template.rb#312
+  def file(basename, allow_inherited = T.unsafe(nil)); end
+
+  # Initialization called on the template. Override this in a 'setup.rb'
+  # file in the template's path to implement a template
+  #
+  # @example A default set of sections
+  #   def init
+  #   sections :section1, :section2, [:subsection1, :etc]
+  #   end
+  # @see #sections
+  #
+  # source://yard//lib/yard/templates/template.rb#239
+  def init; end
+
+  # source://yard//lib/yard/templates/template.rb#342
+  def inspect; end
+
+  # Returns the value of attribute options.
+  #
+  # source://yard//lib/yard/templates/template.rb#8
+  def options; end
+
+  # source://yard//lib/yard/templates/template.rb#337
+  def options=(value); end
+
+  # Runs a template on +sects+ using extra options. This method should
+  # not be called directly. Instead, call the class method {ClassMethods#run}
+  #
+  # @param opts [Hash, nil] any extra options to apply to sections
+  # @param sects [Section, Array] a section list of sections to render
+  # @param start_at [Fixnum] the index in the section list to start from
+  # @param break_first [Boolean] if true, renders only the first section
+  # @return [String] the rendered sections joined together
+  # @yield [opts] calls for the subsections to be rendered
+  # @yieldparam opts [Hash] any extra options to yield
+  #
+  # source://yard//lib/yard/templates/template.rb#252
+  def run(opts = T.unsafe(nil), sects = T.unsafe(nil), start_at = T.unsafe(nil), break_first = T.unsafe(nil), &block); end
+
+  # Returns the value of attribute section.
+  #
+  # source://yard//lib/yard/templates/template.rb#7
+  def section; end
+
+  # Sets the attribute section
+  #
+  # @param value the value to set the attribute section to.
+  #
+  # source://yard//lib/yard/templates/template.rb#7
+  def section=(_arg0); end
+
+  # Sets the sections (and subsections) to be rendered for the template
+  #
+  # @example Sets a set of erb sections
+  #   sections :a, :b, :c # searches for a.erb, b.erb, c.erb
+  # @example Sets a set of method and erb sections
+  #   sections :a, :b, :c # a is a method, the rest are erb files
+  # @example Sections with subsections
+  #   sections :header, [:name, :children]
+  #   # the above will call header.erb and only renders the subsections
+  #   # if they are yielded by the template (see #yieldall)
+  # @param args [Array<Symbol, String, Template, Array>] the sections
+  #   to use to render the template. For symbols and strings, the
+  #   section will be executed as a method (if one exists), or rendered
+  #   from the file "name.erb" where name is the section name. For
+  #   templates, they will have {Template::ClassMethods#run} called on them.
+  #   Any subsections can be yielded to using yield or {#yieldall}
+  #
+  # source://yard//lib/yard/templates/template.rb#226
+  def sections(*args); end
+
+  # Calls the ERB file from the last inherited template with {#section}.erb
+  #
+  # @param sect [Symbol, String] if provided, uses a specific section name
+  # @return [String] the rendered ERB file in any of the inherited template
+  #   paths.
+  #
+  # source://yard//lib/yard/templates/template.rb#330
+  def superb(sect = T.unsafe(nil), &block); end
+
+  # Yields all subsections with any extra options
+  #
+  # @param opts [Hash] extra options to be applied to subsections
+  #
+  # source://yard//lib/yard/templates/template.rb#278
+  def yieldall(opts = T.unsafe(nil), &block); end
+
+  protected
+
+  # source://yard//lib/yard/templates/template.rb#348
+  def erb_file_for(section); end
+
+  # source://yard//lib/yard/templates/template.rb#352
+  def erb_with(content, filename = T.unsafe(nil)); end
+
+  private
+
+  # source://yard//lib/yard/templates/template.rb#399
+  def add_options(opts = T.unsafe(nil)); end
+
+  # @raise [ArgumentError]
+  #
+  # source://yard//lib/yard/templates/template.rb#378
+  def cache(section); end
+
+  # source://yard//lib/yard/templates/template.rb#388
+  def cache_filename(section); end
+
+  # source://yard//lib/yard/templates/template.rb#364
+  def render_section(section, &block); end
+
+  # source://yard//lib/yard/templates/template.rb#393
+  def set_ivars; end
+
+  # source://yard//lib/yard/templates/template.rb#412
+  def with_section; end
+
+  class << self
+    # Extra includes are mixins that are included after a template is created. These
+    # mixins can be registered by plugins to operate on templates and override behaviour.
+    #
+    # Note that this array can be filled with modules or proc objects. If a proc object
+    # is given, the proc will be called with the {Template#options} hash containing
+    # relevant template information like the object, format, and more. The proc should
+    # return a module or nil if there is none.
+    #
+    # @example Adding in extra mixins to include on a template
+    #   Template.extra_includes << MyHelper
+    # @example Conditionally including a mixin if the format is html
+    #   Template.extra_includes << proc {|opts| MyHelper if opts.format == :html }
+    # @return [Array<Module, Proc>] a list of modules to be automatically included
+    #   into any new template module
+    #
+    # source://yard//lib/yard/templates/template.rb#25
+    def extra_includes; end
+
+    # Extra includes are mixins that are included after a template is created. These
+    # mixins can be registered by plugins to operate on templates and override behaviour.
+    #
+    # Note that this array can be filled with modules or proc objects. If a proc object
+    # is given, the proc will be called with the {Template#options} hash containing
+    # relevant template information like the object, format, and more. The proc should
+    # return a module or nil if there is none.
+    #
+    # @example Adding in extra mixins to include on a template
+    #   Template.extra_includes << MyHelper
+    # @example Conditionally including a mixin if the format is html
+    #   Template.extra_includes << proc {|opts| MyHelper if opts.format == :html }
+    # @return [Array<Module, Proc>] a list of modules to be automatically included
+    #   into any new template module
+    #
+    # source://yard//lib/yard/templates/template.rb#25
+    def extra_includes=(_arg0); end
+
+    # Includes the {extra_includes} modules into the template object.
+    #
+    # @param template [Template] the template object to mixin the extra includes.
+    # @param options [SymbolHash] the options hash containing all template information
+    # @return [void]
+    #
+    # source://yard//lib/yard/templates/template.rb#38
+    def include_extra(template, options); end
+
+    # @private
+    # @private
+    #
+    # source://yard//lib/yard/templates/template.rb#29
+    def included(klass); end
+  end
+end
+
+# source://yard//lib/yard/templates/template.rb#59
+module YARD::Templates::Template::ClassMethods
+  # source://yard//lib/yard/templates/template.rb#81
+  def initialize(path, full_paths); end
+
+  # Alias for creating a {Section} with arguments
+  #
+  # @see Section#initialize
+  # @since 0.6.0
+  #
+  # source://yard//lib/yard/templates/template.rb#149
+  def S(*args); end
+
+  # Alias for creating {Engine.template}.
+  #
+  # source://yard//lib/yard/templates/template.rb#142
+  def T(*path); end
+
+  # Searches for a file identified by +basename+ in the template's
+  # path as well as any mixed in template paths. Equivalent to calling
+  # {ClassMethods#find_nth_file} with index of 1.
+  #
+  # @param basename [String] the filename to search for
+  # @return [String] the full path of a file on disk with filename
+  #   +basename+ in one of the template's paths.
+  # @see find_nth_file
+  #
+  # source://yard//lib/yard/templates/template.rb#98
+  def find_file(basename); end
+
+  # Searches for the nth file (where n = +index+) identified
+  # by basename in the template's path and any mixed in template paths.
+  #
+  # @param basename [String] the filename to search for
+  # @param index [Fixnum] the nth existing file to return
+  # @return [String] the full path of the nth file on disk with
+  #   filename +basename+ in one of the template paths
+  #
+  # source://yard//lib/yard/templates/template.rb#109
+  def find_nth_file(basename, index = T.unsafe(nil)); end
+
+  # Returns the value of attribute full_path.
+  #
+  # source://yard//lib/yard/templates/template.rb#60
+  def full_path; end
+
+  # Sets the attribute full_path
+  #
+  # @param value the value to set the attribute full_path to.
+  #
+  # source://yard//lib/yard/templates/template.rb#60
+  def full_path=(_arg0); end
+
+  # @note This method caches path results. Paths should not be modified
+  #   after this method is called; call {#reset_full_paths} to reset cache.
+  # @return [Array<String>] a list of full paths
+  #
+  # source://yard//lib/yard/templates/template.rb#65
+  def full_paths; end
+
+  # @return [Boolean]
+  #
+  # source://yard//lib/yard/templates/template.rb#122
+  def is_a?(klass); end
+
+  # Creates a new template object to be rendered with {Template#run}
+  #
+  # source://yard//lib/yard/templates/template.rb#128
+  def new(*args); end
+
+  # Returns the value of attribute path.
+  #
+  # source://yard//lib/yard/templates/template.rb#60
+  def path; end
+
+  # Sets the attribute path
+  #
+  # @param value the value to set the attribute path to.
+  #
+  # source://yard//lib/yard/templates/template.rb#60
+  def path=(_arg0); end
+
+  # Resets cache for {#full_paths}
+  #
+  # source://yard//lib/yard/templates/template.rb#77
+  def reset_full_paths; end
+
+  # source://yard//lib/yard/templates/template.rb#135
+  def run(*args); end
+
+  private
+
+  # source://yard//lib/yard/templates/template.rb#170
+  def include_inherited(full_paths); end
+
+  # source://yard//lib/yard/templates/template.rb#157
+  def include_parent; end
+
+  # source://yard//lib/yard/templates/template.rb#176
+  def load_setup_rb; end
+end
+
+# An Options class containing default options for base template rendering. For
+# options specific to generation of HTML output, see {CLI::YardocOptions}.
+#
+# @see CLI::YardocOptions
+#
+# source://yard//lib/yard/templates/template_options.rb#9
+class YARD::Templates::TemplateOptions < ::YARD::Options
+  # @return [OpenStruct] an open struct containing any global state across all
+  #   generated objects in a template.
+  #
+  # source://yard//lib/yard/options.rb#82
+  def __globals; end
+
+  # @return [String] the default return type for a method with no return tags
+  #
+  # source://yard//lib/yard/options.rb#82
+  def default_return; end
+
+  # @return [String] the default return type for a method with no return tags
+  #
+  # source://yard//lib/yard/options.rb#82
+  def default_return=(_arg0); end
+
+  # @example A list of mixin path names (including wildcards)
+  #   opts.embed_mixins #=> ['ClassMethods', '*Helper', 'YARD::*']
+  # @return [Array<String>] an array of module name wildcards to embed into
+  #   class documentation as if their methods were defined directly in the class.
+  #   Useful for modules like ClassMethods. If the name contains '::', the module
+  #   is matched against the full mixin path, otherwise only the module name is used.
+  #
+  # source://yard//lib/yard/options.rb#82
+  def embed_mixins; end
+
+  # @example A list of mixin path names (including wildcards)
+  #   opts.embed_mixins #=> ['ClassMethods', '*Helper', 'YARD::*']
+  # @return [Array<String>] an array of module name wildcards to embed into
+  #   class documentation as if their methods were defined directly in the class.
+  #   Useful for modules like ClassMethods. If the name contains '::', the module
+  #   is matched against the full mixin path, otherwise only the module name is used.
+  #
+  # source://yard//lib/yard/options.rb#82
+  def embed_mixins=(_arg0); end
+
+  # @param mixin [CodeObjects::Base] accepts any code object, but returns
+  #   nil unless the object is a module.
+  # @return [Boolean] whether a mixin matches the embed_mixins list
+  # @return [nil] if the mixin is not a module object
+  #
+  # source://yard//lib/yard/templates/template_options.rb#77
+  def embed_mixins_match?(mixin); end
+
+  # @return [Symbol] the template output format
+  #
+  # source://yard//lib/yard/options.rb#82
+  def format; end
+
+  # @return [Symbol] the template output format
+  #
+  # source://yard//lib/yard/options.rb#82
+  def format=(_arg0); end
+
+  # @return [OpenStruct] an open struct containing any global state across all
+  #   generated objects in a template.
+  #
+  # source://yard//lib/yard/options.rb#82
+  def globals; end
+
+  # @return [OpenStruct] an open struct containing any global state across all
+  #   generated objects in a template.
+  #
+  # source://yard//lib/yard/options.rb#82
+  def globals=(_arg0); end
+
+  # @return [Boolean] whether void methods should show "void" in their signature
+  #
+  # source://yard//lib/yard/options.rb#82
+  def hide_void_return; end
+
+  # @return [Boolean] whether void methods should show "void" in their signature
+  #
+  # source://yard//lib/yard/options.rb#82
+  def hide_void_return=(_arg0); end
+
+  # @return [Boolean] whether code blocks should be syntax highlighted
+  #
+  # source://yard//lib/yard/options.rb#82
+  def highlight; end
+
+  # @return [Boolean] whether code blocks should be syntax highlighted
+  #
+  # source://yard//lib/yard/options.rb#82
+  def highlight=(_arg0); end
+
+  # @return [Boolean] whether the page is the "index"
+  #
+  # source://yard//lib/yard/templates/template_options.rb#63
+  def index; end
+
+  # @return [Boolean] whether the page is the "index"
+  #
+  # source://yard//lib/yard/templates/template_options.rb#63
+  def index=(_arg0); end
+
+  # @return [Symbol] the markup format to use when parsing docstrings
+  #
+  # source://yard//lib/yard/options.rb#82
+  def markup; end
+
+  # @return [Symbol] the markup format to use when parsing docstrings
+  #
+  # source://yard//lib/yard/options.rb#82
+  def markup=(_arg0); end
+
+  # @return [Class] the markup provider class for the markup format
+  #
+  # source://yard//lib/yard/templates/template_options.rb#29
+  def markup_provider; end
+
+  # @return [Class] the markup provider class for the markup format
+  #
+  # source://yard//lib/yard/templates/template_options.rb#29
+  def markup_provider=(_arg0); end
+
+  # @deprecated use {#highlight} instead.
+  # @return [Boolean] whether highlighting should be ignored
+  #
+  # source://yard//lib/yard/templates/template_options.rb#56
+  def no_highlight; end
+
+  # source://yard//lib/yard/templates/template_options.rb#57
+  def no_highlight=(value); end
+
+  # @return [CodeObjects::Base] the main object being generated in the template
+  #
+  # source://yard//lib/yard/templates/template_options.rb#37
+  def object; end
+
+  # @return [CodeObjects::Base] the main object being generated in the template
+  #
+  # source://yard//lib/yard/templates/template_options.rb#37
+  def object=(_arg0); end
+
+  # @return [CodeObjects::Base] the owner of the generated object
+  #
+  # source://yard//lib/yard/templates/template_options.rb#40
+  def owner; end
+
+  # @return [CodeObjects::Base] the owner of the generated object
+  #
+  # source://yard//lib/yard/templates/template_options.rb#40
+  def owner=(_arg0); end
+
+  # @return [String] the title of a given page
+  #
+  # source://yard//lib/yard/templates/template_options.rb#60
+  def page_title; end
+
+  # @return [String] the title of a given page
+  #
+  # source://yard//lib/yard/templates/template_options.rb#60
+  def page_title=(_arg0); end
+
+  # @return [Boolean] whether serialization should be performed
+  #
+  # source://yard//lib/yard/options.rb#82
+  def serialize; end
+
+  # @return [Boolean] whether serialization should be performed
+  #
+  # source://yard//lib/yard/options.rb#82
+  def serialize=(_arg0); end
+
+  # @return [Serializers::Base] the serializer used to generate links and serialize
+  #   output. Serialization output only occurs if {#serialize} is +true+.
+  #
+  # source://yard//lib/yard/templates/template_options.rb#50
+  def serializer; end
+
+  # @return [Serializers::Base] the serializer used to generate links and serialize
+  #   output. Serialization output only occurs if {#serialize} is +true+.
+  #
+  # source://yard//lib/yard/templates/template_options.rb#50
+  def serializer=(_arg0); end
+
+  # @return [Symbol] the template name used to render output
+  #
+  # source://yard//lib/yard/options.rb#82
+  def template; end
+
+  # @return [Symbol] the template name used to render output
+  #
+  # source://yard//lib/yard/options.rb#82
+  def template=(_arg0); end
+
+  # @return [Symbol] the template type used to generate output
+  #
+  # source://yard//lib/yard/templates/template_options.rb#43
+  def type; end
+
+  # @return [Symbol] the template type used to generate output
+  #
+  # source://yard//lib/yard/templates/template_options.rb#43
+  def type=(_arg0); end
+
+  # @return [Verifier] the verifier object
+  #
+  # source://yard//lib/yard/templates/template_options.rb#88
+  def verifier; end
+
+  # @return [Verifier] the verifier object
+  #
+  # source://yard//lib/yard/templates/template_options.rb#88
+  def verifier=(_arg0); end
+end
+
+# source://yard//lib/yard/version.rb#5
+YARD::VERSION = T.let(T.unsafe(nil), String)
+
+# Similar to a Proc, but runs a set of Ruby expressions using a small
+# DSL to make tag lookups easier.
+#
+# The syntax is as follows:
+# * All syntax is Ruby compatible
+# * +object+ (+o+ for short) exist to access the object being verified
+# * +@TAGNAME+ is translated into +object.tag('TAGNAME')+
+# * +@@TAGNAME+ is translated into +object.tags('TAGNAME')+
+# * +object+ can be omitted as target for method calls (it is implied)
+#
+# @example Create a verifier to check for objects that don't have @private tags
+#   verifier = Verifier.new('!@private')
+#   verifier.call(object) # => true (no @private tag)
+# @example Create a verifier to find any return tag with an empty description
+#   Verifier.new('@return.text.empty?')
+#   # Equivalent to:
+#   Verifier.new('object.tag(:return).text.empty?')
+# @example Check if there are any @param tags
+#   Verifier.new('@@param.empty?')
+#   # Equivalent to:
+#   Verifier.new('object.tags(:param).empty?')
+# @example Using +object+ or +o+ to look up object attributes directly
+#   Verifier.new('object.docstring == "hello world"')
+#   # Equivalent to:
+#   Verifier.new('o.docstring == "hello world"')
+# @example Without using +object+ or +o+
+#   Verifier.new('tag(:return).size == 1 || has_tag?(:author)')
+# @example Specifying multiple expressions
+#   Verifier.new('@return', '@param', '@yield')
+#   # Equivalent to:
+#   Verifier.new('@return && @param && @yield')
+#
+# source://yard//lib/yard/verifier.rb#34
+class YARD::Verifier
+  # Creates a verifier from a set of expressions
+  #
+  # @param expressions [Array<String>] a list of Ruby expressions to
+  #   parse.
+  # @return [Verifier] a new instance of Verifier
+  #
+  # source://yard//lib/yard/verifier.rb#48
+  def initialize(*expressions); end
+
+  # Adds a set of expressions and recompiles the verifier
+  #
+  # @param expressions [Array<String>] a list of expressions
+  # @return [void]
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/verifier.rb#58
+  def add_expressions(*expressions); end
+
+  # Tests the expressions on the object.
+  #
+  # @note If the object is a {CodeObjects::Proxy} the result will always be true.
+  # @param object [CodeObjects::Base] the object to verify
+  # @return [Boolean] the result of the expressions
+  #
+  # source://yard//lib/yard/verifier.rb#76
+  def call(object); end
+
+  # @return [Array<String>] a list of all expressions the verifier checks for
+  # @since 0.5.6
+  #
+  # source://yard//lib/yard/verifier.rb#37
+  def expressions; end
+
+  # source://yard//lib/yard/verifier.rb#39
+  def expressions=(value); end
+
+  # Passes any method calls to the object from the {#call}
+  #
+  # source://yard//lib/yard/verifier.rb#63
+  def method_missing(sym, *args, &block); end
+
+  # Runs a list of objects against the verifier and returns the subset
+  # of verified objects.
+  #
+  # @param list [Array<CodeObjects::Base>] a list of code objects
+  # @return [Array<CodeObjects::Base>] a list of code objects that match
+  #   the verifier.
+  #
+  # source://yard//lib/yard/verifier.rb#91
+  def run(list); end
+
+  protected
+
+  # @return [CodeObjects::Base] the current object being tested
+  #
+  # source://yard//lib/yard/verifier.rb#98
+  def o; end
+
+  # @return [CodeObjects::Base] the current object being tested
+  #
+  # source://yard//lib/yard/verifier.rb#98
+  def object; end
+
+  private
+
+  # Creates the +__execute+ method by evaluating the expressions
+  # as Ruby code
+  #
+  # @return [void]
+  #
+  # source://yard//lib/yard/verifier.rb#130
+  def create_method_from_expressions; end
+
+  # Modifies nil to not throw NoMethodErrors. This allows
+  # syntax like object.tag(:return).text to work if the #tag
+  # call returns nil, which means users don't need to perform
+  # stringent nil checking
+  #
+  # @return [void]
+  #
+  # source://yard//lib/yard/verifier.rb#112
+  def modify_nilclass; end
+
+  # Parses a single expression, handling some of the DSL syntax.
+  #
+  # The syntax "@tag" should be turned into object.tag(:tag),
+  # and "@@tag" should be turned into object.tags(:tag)
+  #
+  # @return [String] the parsed expression
+  #
+  # source://yard//lib/yard/verifier.rb#145
+  def parse_expression(expr); end
+
+  # Returns the state of NilClass back to normal
+  #
+  # @return [void]
+  #
+  # source://yard//lib/yard/verifier.rb#120
+  def unmodify_nilclass; end
+end
+
+# @private
+#
+# source://yard//lib/yard/verifier.rb#104
+YARD::Verifier::NILCLASS_METHODS = T.let(T.unsafe(nil), Array)
diff --git a/Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.6.0.rbi b/Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.6.0.rbi
deleted file mode 100644
index 7281babe8cc7a..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.6.0.rbi
+++ /dev/null
@@ -1,219 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `zeitwerk` gem.
-# Please instead update this file by running `bin/tapioca gem zeitwerk`.
-
-module Kernel
-  extend ::Forwardable
-
-  private
-
-  def require(path); end
-
-  class << self
-    def require(path); end
-  end
-end
-
-module Zeitwerk
-  class << self
-    def with_loader; end
-  end
-end
-
-class Zeitwerk::Error < ::StandardError; end
-
-module Zeitwerk::ExplicitNamespace
-  extend ::Zeitwerk::RealModName
-
-  class << self
-    def cpaths; end
-    def mutex; end
-    def register(cpath, loader); end
-    def tracer; end
-    def unregister_loader(loader); end
-
-    private
-
-    def disable_tracer_if_unneeded; end
-    def tracepoint_class_callback(event); end
-  end
-end
-
-class Zeitwerk::GemInflector < ::Zeitwerk::Inflector
-  def initialize(root_file); end
-
-  def camelize(basename, abspath); end
-end
-
-class Zeitwerk::GemLoader < ::Zeitwerk::Loader
-  def initialize(root_file, warn_on_extra_files:); end
-
-  def setup; end
-
-  private
-
-  def warn_on_extra_files; end
-
-  class << self
-    def _new(root_file, warn_on_extra_files:); end
-  end
-end
-
-class Zeitwerk::Inflector
-  def camelize(basename, _abspath); end
-  def inflect(inflections); end
-
-  private
-
-  def overrides; end
-end
-
-class Zeitwerk::Loader
-  include ::Zeitwerk::RealModName
-  include ::Zeitwerk::Loader::Callbacks
-  include ::Zeitwerk::Loader::Helpers
-  include ::Zeitwerk::Loader::Config
-
-  def initialize; end
-
-  def autoloaded_dirs; end
-  def autoloads; end
-  def eager_load(force: T.unsafe(nil)); end
-  def lazy_subdirs; end
-  def mutex; end
-  def mutex2; end
-  def reload; end
-  def setup; end
-  def to_unload; end
-  def unload; end
-  def unloadable_cpath?(cpath); end
-  def unloadable_cpaths; end
-  def unregister; end
-
-  private
-
-  def autoload_file(parent, cname, file); end
-  def autoload_path_set_by_me_for?(parent, cname); end
-  def autoload_subdir(parent, cname, subdir); end
-  def promote_namespace_from_implicit_to_explicit(dir:, file:, parent:, cname:); end
-  def raise_if_conflicting_directory(dir); end
-  def register_explicit_namespace(cpath); end
-  def run_on_unload_callbacks(cpath, value, abspath); end
-  def set_autoload(parent, cname, abspath); end
-  def set_autoloads_in_dir(dir, parent); end
-  def unload_autoload(parent, cname); end
-  def unload_cref(parent, cname); end
-
-  class << self
-    def all_dirs; end
-    def default_logger; end
-    def default_logger=(_arg0); end
-    def eager_load_all; end
-    def for_gem(warn_on_extra_files: T.unsafe(nil)); end
-  end
-end
-
-module Zeitwerk::Loader::Callbacks
-  include ::Zeitwerk::RealModName
-
-  def on_dir_autoloaded(dir); end
-  def on_file_autoloaded(file); end
-  def on_namespace_loaded(namespace); end
-
-  private
-
-  def run_on_load_callbacks(cpath, value, abspath); end
-end
-
-module Zeitwerk::Loader::Config
-  def initialize; end
-
-  def collapse(*glob_patterns); end
-  def collapse_dirs; end
-  def collapse_glob_patterns; end
-  def dirs; end
-  def do_not_eager_load(*paths); end
-  def eager_load_exclusions; end
-  def enable_reloading; end
-  def ignore(*glob_patterns); end
-  def ignored_glob_patterns; end
-  def ignored_paths; end
-  def ignores?(abspath); end
-  def inflector; end
-  def inflector=(_arg0); end
-  def log!; end
-  def logger; end
-  def logger=(_arg0); end
-  def on_load(cpath = T.unsafe(nil), &block); end
-  def on_load_callbacks; end
-  def on_setup(&block); end
-  def on_setup_callbacks; end
-  def on_unload(cpath = T.unsafe(nil), &block); end
-  def on_unload_callbacks; end
-  def push_dir(path, namespace: T.unsafe(nil)); end
-  def reloading_enabled?; end
-  def root_dirs; end
-  def tag; end
-  def tag=(tag); end
-
-  private
-
-  def actual_root_dirs; end
-  def collapse?(dir); end
-  def excluded_from_eager_load?(abspath); end
-  def expand_glob_patterns(glob_patterns); end
-  def expand_paths(paths); end
-  def recompute_collapse_dirs; end
-  def recompute_ignored_paths; end
-  def root_dir?(dir); end
-end
-
-module Zeitwerk::Loader::Helpers
-  private
-
-  def cdef?(parent, cname); end
-  def cget(parent, cname); end
-  def cpath(parent, cname); end
-  def dir?(path); end
-  def has_at_least_one_ruby_file?(dir); end
-  def hidden?(basename); end
-  def log(message); end
-  def ls(dir); end
-  def ruby?(path); end
-  def strict_autoload_path(parent, cname); end
-end
-
-Zeitwerk::Loader::MUTEX = T.let(T.unsafe(nil), Thread::Mutex)
-class Zeitwerk::NameError < ::NameError; end
-
-module Zeitwerk::RealModName
-  def real_mod_name(mod); end
-end
-
-Zeitwerk::RealModName::UNBOUND_METHOD_MODULE_NAME = T.let(T.unsafe(nil), UnboundMethod)
-
-module Zeitwerk::Registry
-  class << self
-    def autoloads; end
-    def gem_loaders_by_root_file; end
-    def inception?(cpath); end
-    def inceptions; end
-    def loader_for(path); end
-    def loader_for_gem(root_file, warn_on_extra_files:); end
-    def loaders; end
-    def on_unload(loader); end
-    def register_autoload(loader, abspath); end
-    def register_inception(cpath, abspath, loader); end
-    def register_loader(loader); end
-    def unregister_autoload(abspath); end
-    def unregister_loader(loader); end
-  end
-end
-
-class Zeitwerk::ReloadingDisabledError < ::Zeitwerk::Error
-  def initialize; end
-end
-
-Zeitwerk::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
deleted file mode 100644
index ba6af6ace7c56..0000000000000
--- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
+++ /dev/null
@@ -1,7414 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi hidden-definitions
-
-# typed: autogenerated
-
-class AbstractDownloadStrategy
-  include ::FileUtils::StreamUtils_
-end
-
-class AbstractDownloadStrategy
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class ActiveSupport::Deprecation
-  def self.deprecation_warning(*args, &block); end
-
-  def self.initialize(*args, &block); end
-
-  def self.warn(*args, &block); end
-end
-
-module ActiveSupport::ForkTracker::CoreExtPrivate
-  include ::ActiveSupport::ForkTracker::CoreExt
-end
-
-class Addrinfo
-  def connect_internal(local_addrinfo, timeout=T.unsafe(nil)); end
-end
-
-class Array
-  def abbrev(pattern=T.unsafe(nil)); end
-
-  def fifth(); end
-
-  def forty_two(); end
-
-  def fourth(); end
-
-  def from(position); end
-
-  def second(); end
-
-  def second_to_last(); end
-
-  def shelljoin(); end
-
-  def third(); end
-
-  def third_to_last(); end
-
-  def to(position); end
-
-  def to_default_s(); end
-
-  def to_h(); end
-end
-
-class Array
-  def self.parse(string); end
-
-  def self.try_convert(arg); end
-end
-
-class BasicObject
-  def as_null_object(); end
-
-  def null_object?(); end
-
-  def received_message?(message, *args, &block); end
-
-  def should(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end
-
-  def should_not(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end
-
-  def should_not_receive(message, &block); end
-
-  def should_receive(message, opts=T.unsafe(nil), &block); end
-
-  def stub(message_or_hash, opts=T.unsafe(nil), &block); end
-
-  def stub_chain(*chain, &blk); end
-
-  def unstub(message); end
-end
-
-BasicObject::BasicObject = BasicObject
-
-class Benchmark::Job
-  def initialize(width); end
-end
-
-class Benchmark::Report
-  def initialize(width=T.unsafe(nil), format=T.unsafe(nil)); end
-end
-
-class Benchmark::Tms
-  def to_a(); end
-end
-
-module Benchmark
-  def self.ms(&block); end
-end
-
-class BigDecimal
-  def clone(); end
-
-  def to_digits(); end
-end
-
-class BigDecimal
-  def self.new(*args, **kwargs); end
-end
-
-class Binding
-  def clone(); end
-
-  def irb(); end
-end
-
-module Bootsnap::LoadPathCache
-  DLEXT2 = ::T.let(nil, ::T.untyped)
-end
-
-module BuildEnvironment::DSL
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class BuildEnvironment
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-Bundler::Deprecate = Gem::Deprecate
-
-class Bundler::Env
-end
-
-class Bundler::Env
-  def self.environment(); end
-
-  def self.report(options=T.unsafe(nil)); end
-
-  def self.write(io); end
-end
-
-class Bundler::FeatureFlag
-  def github_https?(); end
-
-  def global_path_appends_ruby_scope?(); end
-end
-
-class Bundler::Fetcher
-  def fetch_spec(spec); end
-
-  def fetchers(); end
-
-  def http_proxy(); end
-
-  def initialize(remote); end
-
-  def specs(gem_names, source); end
-
-  def specs_with_retry(gem_names, source); end
-
-  def uri(); end
-
-  def use_api(); end
-
-  def user_agent(); end
-  FAIL_ERRORS = ::T.let(nil, ::T.untyped)
-  FETCHERS = ::T.let(nil, ::T.untyped)
-  HTTP_ERRORS = ::T.let(nil, ::T.untyped)
-  NET_ERRORS = ::T.let(nil, ::T.untyped)
-end
-
-class Bundler::Fetcher::AuthenticationRequiredError
-  def initialize(remote_uri); end
-end
-
-class Bundler::Fetcher::BadAuthenticationError
-  def initialize(remote_uri); end
-end
-
-class Bundler::Fetcher::Base
-  def api_fetcher?(); end
-
-  def available?(); end
-
-  def display_uri(); end
-
-  def downloader(); end
-
-  def fetch_uri(); end
-
-  def initialize(downloader, remote, display_uri); end
-
-  def remote(); end
-
-  def remote_uri(); end
-end
-
-class Bundler::Fetcher::Base
-end
-
-class Bundler::Fetcher::CertificateFailureError
-  def initialize(remote_uri); end
-end
-
-class Bundler::Fetcher::CompactIndex
-  def available?(*args, &blk); end
-
-  def fetch_spec(*args, &blk); end
-
-  def specs(*args, &blk); end
-
-  def specs_for_names(gem_names); end
-end
-
-class Bundler::Fetcher::CompactIndex::ClientFetcher
-  def call(path, headers); end
-
-  def fetcher(); end
-
-  def fetcher=(_); end
-
-  def ui(); end
-
-  def ui=(_); end
-end
-
-class Bundler::Fetcher::CompactIndex::ClientFetcher
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class Bundler::Fetcher::CompactIndex
-  def self.compact_index_request(method_name); end
-end
-
-class Bundler::Fetcher::Dependency
-  def dependency_api_uri(gem_names=T.unsafe(nil)); end
-
-  def dependency_specs(gem_names); end
-
-  def get_formatted_specs_and_deps(gem_list); end
-
-  def specs(gem_names, full_dependency_list=T.unsafe(nil), last_spec_list=T.unsafe(nil)); end
-
-  def unmarshalled_dep_gems(gem_names); end
-end
-
-class Bundler::Fetcher::Dependency
-end
-
-class Bundler::Fetcher::Downloader
-  def connection(); end
-
-  def fetch(uri, headers=T.unsafe(nil), counter=T.unsafe(nil)); end
-
-  def initialize(connection, redirect_limit); end
-
-  def redirect_limit(); end
-
-  def request(uri, headers); end
-end
-
-class Bundler::Fetcher::Downloader
-end
-
-class Bundler::Fetcher::Index
-  def fetch_spec(spec); end
-
-  def specs(_gem_names); end
-end
-
-class Bundler::Fetcher::Index
-end
-
-class Bundler::Fetcher::SSLError
-  def initialize(msg=T.unsafe(nil)); end
-end
-
-class Bundler::Fetcher
-  def self.api_timeout(); end
-
-  def self.api_timeout=(api_timeout); end
-
-  def self.disable_endpoint(); end
-
-  def self.disable_endpoint=(disable_endpoint); end
-
-  def self.max_retries(); end
-
-  def self.max_retries=(max_retries); end
-
-  def self.redirect_limit(); end
-
-  def self.redirect_limit=(redirect_limit); end
-end
-
-class Bundler::GemHelper
-  def allowed_push_host(); end
-
-  def already_tagged?(); end
-
-  def base(); end
-
-  def build_gem(); end
-
-  def built_gem_path(); end
-
-  def clean?(); end
-
-  def committed?(); end
-
-  def gem_key(); end
-
-  def gem_push?(); end
-
-  def gem_push_host(); end
-
-  def gemspec(); end
-
-  def git_push(remote=T.unsafe(nil)); end
-
-  def guard_clean(); end
-
-  def initialize(base=T.unsafe(nil), name=T.unsafe(nil)); end
-
-  def install(); end
-
-  def install_gem(built_gem_path=T.unsafe(nil), local=T.unsafe(nil)); end
-
-  def name(); end
-
-  def perform_git_push(options=T.unsafe(nil)); end
-
-  def rubygem_push(path); end
-
-  def sh(cmd, &block); end
-
-  def sh_with_code(cmd, &block); end
-
-  def spec_path(); end
-
-  def tag_version(); end
-
-  def version(); end
-
-  def version_tag(); end
-end
-
-class Bundler::GemHelper
-  def self.gemspec(&block); end
-
-  def self.install_tasks(opts=T.unsafe(nil)); end
-
-  def self.instance(); end
-
-  def self.instance=(instance); end
-end
-
-class Bundler::GemRemoteFetcher
-end
-
-class Bundler::GemRemoteFetcher
-end
-
-class Bundler::GemVersionPromoter
-  def initialize(locked_specs=T.unsafe(nil), unlock_gems=T.unsafe(nil)); end
-
-  def level(); end
-
-  def level=(value); end
-
-  def locked_specs(); end
-
-  def major?(); end
-
-  def minor?(); end
-
-  def prerelease_specified(); end
-
-  def prerelease_specified=(prerelease_specified); end
-
-  def sort_versions(dep, spec_groups); end
-
-  def strict(); end
-
-  def strict=(strict); end
-
-  def unlock_gems(); end
-  DEBUG = ::T.let(nil, ::T.untyped)
-end
-
-class Bundler::GemVersionPromoter
-end
-
-class Bundler::Graph
-  def edge_options(); end
-
-  def groups(); end
-
-  def initialize(env, output_file, show_version=T.unsafe(nil), show_requirements=T.unsafe(nil), output_format=T.unsafe(nil), without=T.unsafe(nil)); end
-
-  def node_options(); end
-
-  def output_file(); end
-
-  def output_format(); end
-
-  def relations(); end
-
-  def viz(); end
-  GRAPH_NAME = ::T.let(nil, ::T.untyped)
-end
-
-class Bundler::Graph::GraphVizClient
-  def g(); end
-
-  def initialize(graph_instance); end
-
-  def run(); end
-end
-
-class Bundler::Graph::GraphVizClient
-end
-
-class Bundler::Graph
-end
-
-class Bundler::Index
-  include ::Enumerable
-end
-
-class Bundler::Injector
-  def initialize(deps, options=T.unsafe(nil)); end
-
-  def inject(gemfile_path, lockfile_path); end
-
-  def remove(gemfile_path, lockfile_path); end
-  INJECTED_GEMS = ::T.let(nil, ::T.untyped)
-end
-
-class Bundler::Injector
-  def self.inject(new_deps, options=T.unsafe(nil)); end
-
-  def self.remove(gems, options=T.unsafe(nil)); end
-end
-
-class Bundler::Molinillo::DependencyGraph
-  include ::Enumerable
-end
-
-class Bundler::Molinillo::DependencyGraph::Log
-  extend ::Enumerable
-end
-
-module Bundler::Plugin::API::Source
-  def ==(other); end
-
-  def app_cache_dirname(); end
-
-  def app_cache_path(custom_path=T.unsafe(nil)); end
-
-  def bundler_plugin_api_source?(); end
-
-  def cache(spec, custom_path=T.unsafe(nil)); end
-
-  def cached!(); end
-
-  def can_lock?(spec); end
-
-  def dependency_names(); end
-
-  def dependency_names=(dependency_names); end
-
-  def double_check_for(*arg); end
-
-  def eql?(other); end
-
-  def fetch_gemspec_files(); end
-
-  def gem_install_dir(); end
-
-  def hash(); end
-
-  def include?(other); end
-
-  def initialize(opts); end
-
-  def install(spec, opts); end
-
-  def install_path(); end
-
-  def installed?(); end
-
-  def name(); end
-
-  def options(); end
-
-  def options_to_lock(); end
-
-  def post_install(spec, disable_exts=T.unsafe(nil)); end
-
-  def remote!(); end
-
-  def root(); end
-
-  def specs(); end
-
-  def to_lock(); end
-
-  def to_s(); end
-
-  def unlock!(); end
-
-  def unmet_deps(); end
-
-  def uri(); end
-
-  def uri_hash(); end
-end
-
-module Bundler::Plugin::API::Source
-end
-
-module Bundler::Plugin::Events
-  GEM_AFTER_INSTALL = ::T.let(nil, ::T.untyped)
-  GEM_AFTER_INSTALL_ALL = ::T.let(nil, ::T.untyped)
-  GEM_BEFORE_INSTALL = ::T.let(nil, ::T.untyped)
-  GEM_BEFORE_INSTALL_ALL = ::T.let(nil, ::T.untyped)
-end
-
-class Bundler::Plugin::Index::CommandConflict
-  def initialize(plugin, commands); end
-end
-
-class Bundler::Plugin::Index::CommandConflict
-end
-
-class Bundler::Plugin::Index::SourceConflict
-  def initialize(plugin, sources); end
-end
-
-class Bundler::Plugin::Index::SourceConflict
-end
-
-class Bundler::Plugin::Installer
-  def install(names, options); end
-
-  def install_definition(definition); end
-end
-
-class Bundler::Plugin::Installer::Git
-  def generate_bin(spec, disable_extensions=T.unsafe(nil)); end
-end
-
-class Bundler::Plugin::Installer::Git
-end
-
-class Bundler::Plugin::Installer::Rubygems
-end
-
-class Bundler::Plugin::Installer::Rubygems
-end
-
-class Bundler::Plugin::Installer
-end
-
-class Bundler::Plugin::SourceList
-end
-
-class Bundler::Plugin::SourceList
-end
-
-class Bundler::ProcessLock
-end
-
-class Bundler::ProcessLock
-  def self.lock(bundle_path=T.unsafe(nil)); end
-end
-
-class Bundler::Retry
-  def attempt(&block); end
-
-  def attempts(&block); end
-
-  def current_run(); end
-
-  def current_run=(current_run); end
-
-  def initialize(name, exceptions=T.unsafe(nil), retries=T.unsafe(nil)); end
-
-  def name(); end
-
-  def name=(name); end
-
-  def total_runs(); end
-
-  def total_runs=(total_runs); end
-end
-
-class Bundler::Retry
-  def self.attempts(); end
-
-  def self.default_attempts(); end
-
-  def self.default_retries(); end
-end
-
-class Bundler::RubyGemsGemInstaller
-end
-
-class Bundler::RubyGemsGemInstaller
-end
-
-class Bundler::RubygemsIntegration::MoreFuture
-  def backport_ext_builder_monitor(); end
-end
-
-class Bundler::Settings::Mirror
-  def ==(other); end
-
-  def fallback_timeout(); end
-
-  def fallback_timeout=(timeout); end
-
-  def initialize(uri=T.unsafe(nil), fallback_timeout=T.unsafe(nil)); end
-
-  def uri(); end
-
-  def uri=(uri); end
-
-  def valid?(); end
-
-  def validate!(probe=T.unsafe(nil)); end
-  DEFAULT_FALLBACK_TIMEOUT = ::T.let(nil, ::T.untyped)
-end
-
-class Bundler::Settings::Mirror
-end
-
-class Bundler::Settings::Mirrors
-  def each(&blk); end
-
-  def for(uri); end
-
-  def initialize(prober=T.unsafe(nil)); end
-
-  def parse(key, value); end
-end
-
-class Bundler::Settings::Mirrors
-end
-
-class Bundler::Settings::Validator
-end
-
-class Bundler::Settings::Validator::Rule
-  def description(); end
-
-  def fail!(key, value, *reasons); end
-
-  def initialize(keys, description, &validate); end
-
-  def k(key); end
-
-  def set(settings, key, value, *reasons); end
-
-  def validate!(key, value, settings); end
-end
-
-class Bundler::Settings::Validator::Rule
-end
-
-class Bundler::Settings::Validator
-  def self.validate!(key, value, settings); end
-end
-
-class Bundler::SpecSet
-  include ::Enumerable
-end
-
-class Bundler::UI::Shell
-  def add_color(string, *color); end
-
-  def ask(msg); end
-
-  def confirm(msg, newline=T.unsafe(nil)); end
-
-  def debug(msg, newline=T.unsafe(nil)); end
-
-  def debug?(); end
-
-  def error(msg, newline=T.unsafe(nil)); end
-
-  def info(msg, newline=T.unsafe(nil)); end
-
-  def initialize(options=T.unsafe(nil)); end
-
-  def level(name=T.unsafe(nil)); end
-
-  def level=(level); end
-
-  def no?(); end
-
-  def quiet?(); end
-
-  def shell=(shell); end
-
-  def silence(&blk); end
-
-  def trace(e, newline=T.unsafe(nil), force=T.unsafe(nil)); end
-
-  def unprinted_warnings(); end
-
-  def warn(msg, newline=T.unsafe(nil)); end
-
-  def yes?(msg); end
-  LEVELS = ::T.let(nil, ::T.untyped)
-end
-
-class Bundler::UI::Shell
-end
-
-module Bundler::VersionRanges
-end
-
-class Bundler::VersionRanges::NEq
-  def version(); end
-
-  def version=(_); end
-end
-
-class Bundler::VersionRanges::NEq
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class Bundler::VersionRanges::ReqR
-  def cover?(v); end
-
-  def empty?(); end
-
-  def left(); end
-
-  def left=(_); end
-
-  def right(); end
-
-  def right=(_); end
-
-  def single?(); end
-  INFINITY = ::T.let(nil, ::T.untyped)
-  UNIVERSAL = ::T.let(nil, ::T.untyped)
-  ZERO = ::T.let(nil, ::T.untyped)
-end
-
-class Bundler::VersionRanges::ReqR::Endpoint
-  def inclusive(); end
-
-  def inclusive=(_); end
-
-  def version(); end
-
-  def version=(_); end
-end
-
-class Bundler::VersionRanges::ReqR::Endpoint
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class Bundler::VersionRanges::ReqR
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-module Bundler::VersionRanges
-  def self.empty?(ranges, neqs); end
-
-  def self.for(requirement); end
-
-  def self.for_many(requirements); end
-end
-
-module CGI::HtmlExtension
-  def a(href=T.unsafe(nil)); end
-
-  def base(href=T.unsafe(nil)); end
-
-  def blockquote(cite=T.unsafe(nil)); end
-
-  def caption(align=T.unsafe(nil)); end
-
-  def checkbox(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end
-
-  def checkbox_group(name=T.unsafe(nil), *values); end
-
-  def file_field(name=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end
-
-  def form(method=T.unsafe(nil), action=T.unsafe(nil), enctype=T.unsafe(nil)); end
-
-  def hidden(name=T.unsafe(nil), value=T.unsafe(nil)); end
-
-  def html(attributes=T.unsafe(nil)); end
-
-  def image_button(src=T.unsafe(nil), name=T.unsafe(nil), alt=T.unsafe(nil)); end
-
-  def img(src=T.unsafe(nil), alt=T.unsafe(nil), width=T.unsafe(nil), height=T.unsafe(nil)); end
-
-  def multipart_form(action=T.unsafe(nil), enctype=T.unsafe(nil)); end
-
-  def password_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end
-
-  def popup_menu(name=T.unsafe(nil), *values); end
-
-  def radio_button(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end
-
-  def radio_group(name=T.unsafe(nil), *values); end
-
-  def reset(value=T.unsafe(nil), name=T.unsafe(nil)); end
-
-  def scrolling_list(name=T.unsafe(nil), *values); end
-
-  def submit(value=T.unsafe(nil), name=T.unsafe(nil)); end
-
-  def text_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end
-
-  def textarea(name=T.unsafe(nil), cols=T.unsafe(nil), rows=T.unsafe(nil)); end
-end
-
-module CGI::HtmlExtension
-end
-
-class Cask::AbstractCaskErrorWithToken
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Cask::Artifact::AbstractArtifact
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Cask::Cache
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Cask::CaskLoader::FromURILoader
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Cask::CaskLoader::NullLoader
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Cask::CaskQuarantineError
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Cask::CaskUnspecifiedError
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Cask::Caskroom
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Cask::Config
-  def appdir(); end
-
-  def appdir=(path); end
-
-  def audio_unit_plugindir(); end
-
-  def audio_unit_plugindir=(path); end
-
-  def colorpickerdir(); end
-
-  def colorpickerdir=(path); end
-
-  def dictionarydir(); end
-
-  def dictionarydir=(path); end
-
-  def fontdir(); end
-
-  def fontdir=(path); end
-
-  def input_methoddir(); end
-
-  def input_methoddir=(path); end
-
-  def internet_plugindir(); end
-
-  def internet_plugindir=(path); end
-
-  def mdimporterdir(); end
-
-  def mdimporterdir=(path); end
-
-  def prefpanedir(); end
-
-  def prefpanedir=(path); end
-
-  def qlplugindir(); end
-
-  def qlplugindir=(path); end
-
-  def screen_saverdir(); end
-
-  def screen_saverdir=(path); end
-
-  def servicedir(); end
-
-  def servicedir=(path); end
-
-  def vst3_plugindir(); end
-
-  def vst3_plugindir=(path); end
-
-  def vst_plugindir(); end
-
-  def vst_plugindir=(path); end
-end
-
-class Cask::Config
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Cask::DSL::Caveats
-  def depends_on_java(*args); end
-
-  def discontinued(*args); end
-
-  def files_in_usr_local(*args); end
-
-  def free_license(*args); end
-
-  def kext(*args); end
-
-  def license(*args); end
-
-  def logout(*args); end
-
-  def path_environment_variable(*args); end
-
-  def reboot(*args); end
-
-  def requires_rosetta(*args); end
-
-  def unsigned_accessibility(*args); end
-
-  def zsh_path_helper(*args); end
-end
-
-class Cask::DSL::Container
-  def nested(); end
-
-  def nested=(nested); end
-
-  def pairs(); end
-
-  def pairs=(pairs); end
-
-  def type(); end
-
-  def type=(type); end
-end
-
-class Cask::DSL::Version
-  def dots_to_hyphens(); end
-
-  def dots_to_underscores(); end
-
-  def hyphens_to_dots(); end
-
-  def hyphens_to_underscores(); end
-
-  def no_dots(); end
-
-  def no_hyphens(); end
-
-  def no_underscores(); end
-
-  def underscores_to_dots(); end
-
-  def underscores_to_hyphens(); end
-end
-
-module Cask::Denylist
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Cask::MultipleCaskErrors
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Cask::Quarantine
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Cask::Staged
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Cask::Utils
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Checksum
-  def [](*args, &block); end
-
-  def empty?(*args, &block); end
-
-  def length(*args, &block); end
-
-  def to_s(*args, &block); end
-end
-
-class Class
-  def any_instance(); end
-end
-
-class CompilerSelector::Compiler
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class CompilerSelector
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Concurrent::RubyThreadPoolExecutor
-  DEFAULT_SYNCHRONOUS = ::T.let(nil, ::T.untyped)
-end
-
-module CopHelper
-  def _investigate(cop, processed_source); end
-
-  def autocorrect_source(source, file=T.unsafe(nil)); end
-
-  def autocorrect_source_file(source); end
-
-  def inspect_source(source, file=T.unsafe(nil)); end
-
-  def parse_source(source, file=T.unsafe(nil)); end
-end
-
-module CopHelper
-  extend ::RSpec::Core::SharedContext
-  extend ::RSpec::Its
-end
-
-class CxxStdlib
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Date
-  def compare_without_coercion(arg); end
-
-  def default_inspect(); end
-
-  def minus_without_duration(arg); end
-
-  def plus_without_duration(arg); end
-
-  def to_default_s(); end
-end
-
-class Date::Infinity
-  def initialize(d=T.unsafe(nil)); end
-end
-
-class Debrew::Menu::Entry
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-module Debrew
-  def self.lock(); end
-
-  def self.locked?(); end
-
-  def self.synchronize(&block); end
-
-  def self.try_lock(); end
-
-  def self.unlock(); end
-end
-
-class Delegator
-  include ::ActiveSupport::Tryable
-end
-
-class Dependencies
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Dependency
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class DependencyCollector
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class DeprecatedOption
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class DevelopmentTools
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class DidYouMean::ClassNameChecker
-  def class_name(); end
-
-  def class_names(); end
-
-  def corrections(); end
-
-  def initialize(exception); end
-
-  def scopes(); end
-end
-
-module DidYouMean::Correctable
-  def corrections(); end
-
-  def original_message(); end
-
-  def spell_checker(); end
-
-  def to_s(); end
-end
-
-class DidYouMean::Formatter
-  def message_for(corrections); end
-end
-
-class DidYouMean::Formatter
-  def self.message_for(corrections); end
-end
-
-module DidYouMean::Jaro
-  def self.distance(str1, str2); end
-end
-
-module DidYouMean::JaroWinkler
-  def self.distance(str1, str2); end
-end
-
-class DidYouMean::KeyErrorChecker
-  def corrections(); end
-
-  def initialize(key_error); end
-end
-
-class DidYouMean::KeyErrorChecker
-end
-
-module DidYouMean::Levenshtein
-  def self.distance(str1, str2); end
-
-  def self.min3(a, b, c); end
-end
-
-class DidYouMean::MethodNameChecker
-  def corrections(); end
-
-  def initialize(exception); end
-
-  def method_name(); end
-
-  def method_names(); end
-
-  def names_to_exclude(); end
-
-  def receiver(); end
-  RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
-end
-
-class DidYouMean::NullChecker
-  def corrections(); end
-
-  def initialize(*arg); end
-end
-
-class DidYouMean::PatternKeyNameChecker
-  def corrections(); end
-
-  def initialize(no_matching_pattern_key_error); end
-end
-
-class DidYouMean::PatternKeyNameChecker
-end
-
-DidYouMean::PlainFormatter = DidYouMean::Formatter
-
-class DidYouMean::RequirePathChecker
-  def corrections(); end
-
-  def initialize(exception); end
-
-  def path(); end
-end
-
-class DidYouMean::RequirePathChecker
-  def self.requireables(); end
-end
-
-class DidYouMean::TreeSpellChecker
-  def augment(); end
-
-  def correct(input); end
-
-  def dictionary(); end
-
-  def dictionary_without_leaves(); end
-
-  def dimensions(); end
-
-  def find_leaves(path); end
-
-  def initialize(dictionary:, separator: T.unsafe(nil), augment: T.unsafe(nil)); end
-
-  def plausible_dimensions(input); end
-
-  def possible_paths(states); end
-
-  def separator(); end
-
-  def tree_depth(); end
-end
-
-class DidYouMean::TreeSpellChecker
-end
-
-class DidYouMean::VariableNameChecker
-  def corrections(); end
-
-  def cvar_names(); end
-
-  def initialize(exception); end
-
-  def ivar_names(); end
-
-  def lvar_names(); end
-
-  def method_names(); end
-
-  def name(); end
-  RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
-end
-
-module DidYouMean
-  def self.correct_error(error_class, spell_checker); end
-
-  def self.formatter(); end
-
-  def self.formatter=(formatter); end
-
-  def self.spell_checkers(); end
-end
-
-class Dir
-  def children(); end
-
-  def each_child(); end
-end
-
-class Dir
-  def self.exists?(arg); end
-end
-
-module DiskUsageExtension
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class ELFTools::Structs::ELF32_PhdrBe
-end
-
-class ELFTools::Structs::ELF32_PhdrBe
-end
-
-class ELFTools::Structs::ELF32_PhdrLe
-end
-
-class ELFTools::Structs::ELF32_PhdrLe
-end
-
-class ELFTools::Structs::ELF32_symBe
-end
-
-class ELFTools::Structs::ELF32_symBe
-end
-
-class ELFTools::Structs::ELF32_symLe
-end
-
-class ELFTools::Structs::ELF32_symLe
-end
-
-class ELFTools::Structs::ELF64_PhdrBe
-end
-
-class ELFTools::Structs::ELF64_PhdrBe
-end
-
-class ELFTools::Structs::ELF64_PhdrLe
-end
-
-class ELFTools::Structs::ELF64_PhdrLe
-end
-
-class ELFTools::Structs::ELF64_symBe
-end
-
-class ELFTools::Structs::ELF64_symBe
-end
-
-class ELFTools::Structs::ELF64_symLe
-end
-
-class ELFTools::Structs::ELF64_symLe
-end
-
-class ELFTools::Structs::ELF_DynBe
-end
-
-class ELFTools::Structs::ELF_DynBe
-end
-
-class ELFTools::Structs::ELF_DynLe
-end
-
-class ELFTools::Structs::ELF_DynLe
-end
-
-class ELFTools::Structs::ELF_EhdrBe
-end
-
-class ELFTools::Structs::ELF_EhdrBe
-end
-
-class ELFTools::Structs::ELF_EhdrLe
-end
-
-class ELFTools::Structs::ELF_EhdrLe
-end
-
-class ELFTools::Structs::ELF_NhdrBe
-end
-
-class ELFTools::Structs::ELF_NhdrBe
-end
-
-class ELFTools::Structs::ELF_NhdrLe
-end
-
-class ELFTools::Structs::ELF_NhdrLe
-end
-
-class ELFTools::Structs::ELF_RelBe
-end
-
-class ELFTools::Structs::ELF_RelBe
-end
-
-class ELFTools::Structs::ELF_RelLe
-end
-
-class ELFTools::Structs::ELF_RelLe
-end
-
-class ELFTools::Structs::ELF_RelaBe
-end
-
-class ELFTools::Structs::ELF_RelaBe
-end
-
-class ELFTools::Structs::ELF_RelaLe
-end
-
-class ELFTools::Structs::ELF_RelaLe
-end
-
-class ELFTools::Structs::ELF_ShdrBe
-end
-
-class ELFTools::Structs::ELF_ShdrBe
-end
-
-class ELFTools::Structs::ELF_ShdrLe
-end
-
-class ELFTools::Structs::ELF_ShdrLe
-end
-
-class ERB
-  def def_method(mod, methodname, fname=T.unsafe(nil)); end
-
-  def def_module(methodname=T.unsafe(nil)); end
-end
-
-class ERB::Compiler::Scanner
-  DEFAULT_ETAGS = ::T.let(nil, ::T.untyped)
-  DEFAULT_STAGS = ::T.let(nil, ::T.untyped)
-end
-
-class EmbeddedPatch
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Encoding
-  def _dump(*arg); end
-end
-
-class Encoding::Converter
-  def initialize(*arg); end
-end
-
-class Encoding
-  def self._load(arg); end
-end
-
-module Enumerable
-  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
-end
-
-class Enumerator
-  def +(arg); end
-
-  def each_with_index(); end
-end
-
-class Enumerator::ArithmeticSequence
-  def begin(); end
-
-  def each(&blk); end
-
-  def end(); end
-
-  def exclude_end?(); end
-
-  def last(*arg); end
-
-  def step(); end
-end
-
-class Enumerator::ArithmeticSequence
-end
-
-class Enumerator::Chain
-end
-
-class Enumerator::Chain
-end
-
-class Enumerator::Generator
-  def each(*arg, &blk); end
-
-  def initialize(*arg); end
-end
-
-class Errno::EAUTH
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::EAUTH
-end
-
-class Errno::EBADARCH
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::EBADARCH
-end
-
-class Errno::EBADEXEC
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::EBADEXEC
-end
-
-class Errno::EBADMACHO
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::EBADMACHO
-end
-
-class Errno::EBADRPC
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::EBADRPC
-end
-
-Errno::ECAPMODE = Errno::NOERROR
-
-Errno::EDEADLOCK = Errno::NOERROR
-
-class Errno::EDEVERR
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::EDEVERR
-end
-
-Errno::EDOOFUS = Errno::NOERROR
-
-class Errno::EFTYPE
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::EFTYPE
-end
-
-Errno::EIPSEC = Errno::NOERROR
-
-class Errno::ELAST
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::ELAST
-end
-
-class Errno::ENEEDAUTH
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::ENEEDAUTH
-end
-
-class Errno::ENOATTR
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::ENOATTR
-end
-
-class Errno::ENOPOLICY
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::ENOPOLICY
-end
-
-Errno::ENOTCAPABLE = Errno::NOERROR
-
-class Errno::ENOTSUP
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::ENOTSUP
-end
-
-class Errno::EPROCLIM
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::EPROCLIM
-end
-
-class Errno::EPROCUNAVAIL
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::EPROCUNAVAIL
-end
-
-class Errno::EPROGMISMATCH
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::EPROGMISMATCH
-end
-
-class Errno::EPROGUNAVAIL
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::EPROGUNAVAIL
-end
-
-class Errno::EPWROFF
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::EPWROFF
-end
-
-Errno::EQFULL = Errno::ELAST
-
-class Errno::ERPCMISMATCH
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::ERPCMISMATCH
-end
-
-class Errno::ESHLIBVERS
-  Errno = ::T.let(nil, ::T.untyped)
-end
-
-class Errno::ESHLIBVERS
-end
-
-class Etc::Group
-  def gid(); end
-
-  def gid=(_); end
-
-  def mem(); end
-
-  def mem=(_); end
-
-  def name(); end
-
-  def name=(_); end
-
-  def passwd(); end
-
-  def passwd=(_); end
-end
-
-class Etc::Group
-  extend ::Enumerable
-  def self.[](*arg); end
-
-  def self.each(&blk); end
-
-  def self.members(); end
-end
-
-class Etc::Passwd
-  def change(); end
-
-  def change=(_); end
-
-  def dir=(_); end
-
-  def expire(); end
-
-  def expire=(_); end
-
-  def gecos(); end
-
-  def gecos=(_); end
-
-  def gid=(_); end
-
-  def name=(_); end
-
-  def passwd=(_); end
-
-  def shell=(_); end
-
-  def uclass(); end
-
-  def uclass=(_); end
-
-  def uid=(_); end
-end
-
-class Etc::Passwd
-  extend ::Enumerable
-  def self.[](*arg); end
-
-  def self.each(&blk); end
-
-  def self.members(); end
-end
-
-class Exception
-  def to_json(*args); end
-end
-
-class Exception
-  def self.json_create(object); end
-end
-
-module Exception2MessageMapper
-  def bind(cl); end
-end
-
-Exception2MessageMapper::E2MM = Exception2MessageMapper
-
-class Exception2MessageMapper::ErrNotRegisteredException
-end
-
-class Exception2MessageMapper::ErrNotRegisteredException
-end
-
-module Exception2MessageMapper
-  def self.Fail(klass=T.unsafe(nil), err=T.unsafe(nil), *rest); end
-
-  def self.Raise(klass=T.unsafe(nil), err=T.unsafe(nil), *rest); end
-
-  def self.def_e2message(k, c, m); end
-
-  def self.def_exception(k, n, m, s=T.unsafe(nil)); end
-
-  def self.e2mm_message(klass, exp); end
-
-  def self.extend_object(cl); end
-
-  def self.message(klass, exp); end
-end
-
-class ExitCalledError
-end
-
-class ExitCalledError
-end
-
-class ExternalPatch
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Fiber
-  def transfer(*arg); end
-end
-
-class Fiber
-  def self.current(); end
-end
-
-class File
-  def self.atomic_write(file_name, temp_dir=T.unsafe(nil)); end
-
-  def self.exists?(arg); end
-
-  def self.probe_stat_in(dir); end
-end
-
-module FileUtils
-  include ::FileUtils::StreamUtils_
-end
-
-module FileUtils::DryRun
-  include ::FileUtils
-  include ::FileUtils::StreamUtils_
-  include ::FileUtils::LowMethods
-end
-
-module FileUtils::DryRun
-  extend ::FileUtils::DryRun
-  extend ::FileUtils
-  extend ::FileUtils::StreamUtils_
-  extend ::FileUtils::LowMethods
-end
-
-module FileUtils::NoWrite
-  include ::FileUtils
-  include ::FileUtils::StreamUtils_
-  include ::FileUtils::LowMethods
-end
-
-module FileUtils::NoWrite
-  extend ::FileUtils::NoWrite
-  extend ::FileUtils
-  extend ::FileUtils::StreamUtils_
-  extend ::FileUtils::LowMethods
-end
-
-module FileUtils::Verbose
-  include ::FileUtils
-  include ::FileUtils::StreamUtils_
-end
-
-module FileUtils::Verbose
-  extend ::FileUtils::Verbose
-  extend ::FileUtils
-  extend ::FileUtils::StreamUtils_
-end
-
-module FileUtils
-  extend ::FileUtils::StreamUtils_
-end
-
-class FormulaConflict
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class Formulary::FromUrlLoader
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Formulary
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Forwardable
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-module Forwardable
-  def self._compile_method(src, file, line); end
-
-  def self._delegator_method(obj, accessor, method, ali); end
-
-  def self._valid_method?(method); end
-
-  def self.debug(); end
-
-  def self.debug=(debug); end
-end
-
-module GC
-  def garbage_collect(*arg); end
-end
-
-module GC
-  def self.verify_transient_heap_internal_consistency(); end
-end
-
-class Gem::DependencyInstaller
-  def _deprecated_add_found_dependencies(to_do, dependency_list); end
-
-  def _deprecated_gather_dependencies(); end
-
-  def add_found_dependencies(*args, &block); end
-
-  def gather_dependencies(*args, &block); end
-end
-
-class Gem::Exception
-  extend ::Gem::Deprecate
-end
-
-class Gem::Ext::BuildError
-end
-
-class Gem::Ext::BuildError
-end
-
-class Gem::Ext::Builder
-  def self.redirector(); end
-end
-
-class Gem::Ext::ExtConfBuilder
-end
-
-Gem::Ext::ExtConfBuilder::FileEntry = FileUtils::Entry_
-
-class Gem::Ext::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 Gem::Package::DigestIO
-  def digests(); end
-
-  def initialize(io, digests); end
-
-  def write(data); end
-end
-
-class Gem::Package::DigestIO
-  def self.wrap(io, digests); end
-end
-
-class Gem::Package::FileSource
-  def initialize(path); end
-
-  def path(); end
-
-  def start(); end
-
-  def with_read_io(&block); end
-
-  def with_write_io(&block); end
-end
-
-class Gem::Package::FileSource
-end
-
-class Gem::Package::IOSource
-  def initialize(io); end
-
-  def io(); end
-
-  def path(); end
-
-  def start(); end
-
-  def with_read_io(); end
-
-  def with_write_io(); end
-end
-
-class Gem::Package::IOSource
-end
-
-class Gem::Package::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 Gem::Package::Old
-end
-
-class Gem::Package::Source
-end
-
-class Gem::Package::Source
-end
-
-class Gem::Package::TarHeader
-  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
-  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)
-end
-
-class Gem::Package::TarHeader
-  def self.from(stream); end
-
-  def self.strict_oct(str); end
-end
-
-class Gem::Package::TarReader::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 Gem::Package::TarReader::Entry
-end
-
-class Gem::Package::TarReader
-  def self.new(io); end
-end
-
-class Gem::Package::TarWriter
-  def self.new(io); end
-end
-
-class Gem::Package
-  def self.new(gem, security_policy=T.unsafe(nil)); end
-end
-
-class Gem::PathSupport
-  def home(); end
-
-  def initialize(env); end
-
-  def path(); end
-
-  def spec_cache_dir(); end
-end
-
-class Gem::RemoteFetcher
-  def correct_for_windows_path(path); end
-
-  def s3_expiration(); end
-
-  def sign_s3_url(uri, expiration=T.unsafe(nil)); end
-  BASE64_URI_TRANSLATE = ::T.let(nil, ::T.untyped)
-end
-
-class Gem::Request
-  extend ::Gem::UserInteraction
-  extend ::Gem::DefaultUserInteraction
-  extend ::Gem::Text
-end
-
-class Gem::Resolver::ActivationRequest
-  def others_possible?(); end
-end
-
-class Gem::Resolver::CurrentSet
-end
-
-class Gem::Resolver::CurrentSet
-end
-
-Gem::Resolver::DependencyConflict = Gem::Resolver::Conflict
-
-class Gem::Resolver::LocalSpecification
-end
-
-class Gem::Resolver::LocalSpecification
-end
-
-class Gem::Resolver::Molinillo::DependencyGraph::Log
-  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 Gem::Resolver::Molinillo::DependencyGraph::Log
-  extend ::Enumerable
-end
-
-class Gem::RuntimeRequirementNotMetError
-  def suggestion(); end
-
-  def suggestion=(suggestion); end
-end
-
-class Gem::RuntimeRequirementNotMetError
-end
-
-class Gem::Security::Exception
-end
-
-class Gem::Security::Exception
-end
-
-Gem::Security::KEY_ALGORITHM = OpenSSL::PKey::RSA
-
-class Gem::Security::Signer
-  include ::Gem::UserInteraction
-  include ::Gem::DefaultUserInteraction
-  include ::Gem::Text
-  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
-end
-
-class Gem::Security::Signer
-  def self.re_sign_cert(expired_cert, expired_cert_path, private_key); end
-end
-
-class Gem::Security::TrustDir
-  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
-
-module Gem::Security
-  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
-end
-
-class Gem::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
-end
-
-class Gem::SpecFetcher
-  def self.fetcher(); end
-
-  def self.fetcher=(fetcher); end
-end
-
-class Gem::Specification
-  include ::Bundler::MatchPlatform
-  include ::Bundler::GemHelpers
-  def to_ruby(); end
-end
-
-class Gem::Specification
-  extend ::Gem::Deprecate
-  extend ::Enumerable
-  def self.add_spec(spec); end
-
-  def self.add_specs(*specs); end
-
-  def self.remove_spec(spec); end
-end
-
-class Gem::SpecificationPolicy
-  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
-  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)
-end
-
-class Gem::SpecificationPolicy
-end
-
-class Gem::StreamUI
-  def _deprecated_debug(statement); end
-end
-
-class Gem::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
-end
-
-class Gem::StubSpecification::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
-
-class Gem::StubSpecification
-  def self.default_gemspec_stub(filename, base_dir, gems_dir); end
-
-  def self.gemspec_stub(filename, base_dir, gems_dir); end
-end
-
-class Gem::UninstallError
-  def spec(); end
-
-  def spec=(spec); end
-end
-
-class Gem::UninstallError
-end
-
-Gem::Version::Requirement = Gem::Requirement
-
-module Gem
-  def self.default_gems_use_full_paths?(); end
-
-  def self.remove_unresolved_default_spec(spec); end
-end
-
-module GitHub::API
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class GitHub::Actions::Annotation
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module GitHub::Actions
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class GitHubPackages
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class HTTP::Cookie
-  def self.parse(set_cookie, origin, options=T.unsafe(nil), &block); end
-end
-
-class Hardware::CPU
-  extend ::T::Private::Methods::SingletonMethodHooks
-  def self.lm?(); end
-end
-
-module Hardware
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Hash
-  def deep_transform_values(&block); end
-
-  def deep_transform_values!(&block); end
-end
-
-module Homebrew
-  MAX_PORT = ::T.let(nil, ::T.untyped)
-  MIN_PORT = ::T.let(nil, ::T.untyped)
-end
-
-module Homebrew::API::Analytics
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Homebrew::API::Cask
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Homebrew::API::CaskSource
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Homebrew::API::Formula
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Homebrew::API::Versions
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Homebrew::API
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::BundleVersion
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Homebrew::Completions
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Homebrew::EnvConfig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-  def self.additional_google_analytics_id(); end
-
-  def self.all_proxy(); end
-
-  def self.arch(); end
-
-  def self.artifact_domain(); end
-
-  def self.auto_update_secs(); end
-
-  def self.bat?(); end
-
-  def self.bat_config_path(); end
-
-  def self.bat_theme(); end
-
-  def self.bootsnap?(); end
-
-  def self.bottle_domain(); end
-
-  def self.brew_git_remote(); end
-
-  def self.browser(); end
-
-  def self.cache(); end
-
-  def self.cleanup_max_age_days(); end
-
-  def self.cleanup_periodic_full_days(); end
-
-  def self.color?(); end
-
-  def self.core_git_remote(); end
-
-  def self.curl_retries(); end
-
-  def self.curl_verbose?(); end
-
-  def self.curlrc?(); end
-
-  def self.debug?(); end
-
-  def self.developer?(); end
-
-  def self.disable_load_formula?(); end
-
-  def self.display(); end
-
-  def self.display_install_times?(); end
-
-  def self.docker_registry_basic_auth_token(); end
-
-  def self.docker_registry_token(); end
-
-  def self.editor(); end
-
-  def self.fail_log_lines(); end
-
-  def self.forbidden_licenses(); end
-
-  def self.force_brewed_ca_certificates?(); end
-
-  def self.force_brewed_curl?(); end
-
-  def self.force_brewed_git?(); end
-
-  def self.force_vendor_ruby?(); end
-
-  def self.ftp_proxy(); end
-
-  def self.git_email(); end
-
-  def self.git_name(); end
-
-  def self.git_path(); end
-
-  def self.github_api_token(); end
-
-  def self.github_packages_token(); end
-
-  def self.github_packages_user(); end
-
-  def self.http_proxy(); end
-
-  def self.https_proxy(); end
-
-  def self.install_badge(); end
-
-  def self.install_from_api?(); end
-
-  def self.livecheck_watchlist(); end
-
-  def self.logs(); end
-
-  def self.no_analytics?(); end
-
-  def self.no_auto_update?(); end
-
-  def self.no_bootsnap?(); end
-
-  def self.no_cleanup_formulae(); end
-
-  def self.no_color?(); end
-
-  def self.no_compat?(); end
-
-  def self.no_emoji?(); end
-
-  def self.no_env_hints?(); end
-
-  def self.no_github_api?(); end
-
-  def self.no_insecure_redirect?(); end
-
-  def self.no_install_cleanup?(); end
-
-  def self.no_install_upgrade?(); end
-
-  def self.no_installed_dependents_check?(); end
-
-  def self.no_proxy(); end
-
-  def self.pry?(); end
-
-  def self.simulate_macos_on_linux?(); end
-
-  def self.skip_or_later_bottles?(); end
-
-  def self.sorbet_runtime?(); end
-
-  def self.ssh_config_path(); end
-
-  def self.sudo_askpass(); end
-
-  def self.svn(); end
-
-  def self.temp(); end
-
-  def self.update_report_all_formulae?(); end
-
-  def self.update_to_tag?(); end
-
-  def self.verbose?(); end
-
-  def self.verbose_using_dots?(); end
-end
-
-class Homebrew::Livecheck::LivecheckVersion
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Homebrew::Livecheck::SkipConditions
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::Livecheck::Strategy::Apache
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::Livecheck::Strategy::Bitbucket
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::Livecheck::Strategy::Cpan
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::Livecheck::Strategy::ElectronBuilder
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::Livecheck::Strategy::GithubLatest
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::Livecheck::Strategy::Gnome
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::Livecheck::Strategy::Gnu
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::Livecheck::Strategy::Hackage
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::Livecheck::Strategy::Launchpad
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::Livecheck::Strategy::Npm
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::Livecheck::Strategy::Sourceforge
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::Livecheck::Strategy::Xorg
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Homebrew::Livecheck::Strategy
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::SimulateSystem
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::Style::LineLocation
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Homebrew::TapAuditor
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module HostEnvironmentSimulatorHelper
-  def in_its_own_process_with(*files); end
-end
-
-module HostEnvironmentSimulatorHelper
-end
-
-class IO
-  def beep(); end
-
-  def cooked(); end
-
-  def cooked!(); end
-
-  def cursor(); end
-
-  def cursor=(); end
-
-  def echo=(echo); end
-
-  def echo?(); end
-
-  def getch(*arg); end
-
-  def getpass(*arg); end
-
-  def goto(); end
-
-  def iflush(); end
-
-  def ioflush(); end
-
-  def noecho(); end
-
-  def nonblock(*arg); end
-
-  def nonblock=(nonblock); end
-
-  def nonblock?(); end
-
-  def nread(); end
-
-  def oflush(); end
-
-  def pathconf(arg); end
-
-  def pressed?(); end
-
-  def raw(*arg); end
-
-  def raw!(*arg); end
-
-  def ready?(); end
-
-  def wait(*arg); end
-
-  def wait_readable(*arg); end
-
-  def wait_writable(*arg); end
-
-  def winsize(); end
-
-  def winsize=(winsize); end
-end
-
-class IO
-  def self.console(*arg); end
-end
-
-class IPAddr
-  def ==(other); end
-
-  def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end
-end
-
-module IRB
-  IRBRC_EXT = ::T.let(nil, ::T.untyped)
-  MagicFile = ::T.let(nil, ::T.untyped)
-  STDIN_FILE_NAME = ::T.let(nil, ::T.untyped)
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class IRB::Context
-  def __exit__(*arg); end
-
-  def __inspect__(); end
-
-  def __to_s__(); end
-
-  def evaluate(line, line_no, exception: T.unsafe(nil)); end
-
-  def initialize(irb, workspace=T.unsafe(nil), input_method=T.unsafe(nil), output_method=T.unsafe(nil)); end
-
-  def inspect_last_value(); end
-  IDNAME_IVARS = ::T.let(nil, ::T.untyped)
-  NOPRINTING_IVARS = ::T.let(nil, ::T.untyped)
-  NO_INSPECTING_IVARS = ::T.let(nil, ::T.untyped)
-end
-
-class IRB::DefaultEncodings
-  def external(); end
-
-  def external=(_); end
-
-  def internal=(_); end
-end
-
-class IRB::DefaultEncodings
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-module IRB::ExtendCommandBundle
-  def irb(*opts, &b); end
-
-  def irb_change_workspace(*opts, &b); end
-
-  def irb_current_working_workspace(*opts, &b); end
-
-  def irb_fg(*opts, &b); end
-
-  def irb_help(*opts, &b); end
-
-  def irb_jobs(*opts, &b); end
-
-  def irb_kill(*opts, &b); end
-
-  def irb_pop_workspace(*opts, &b); end
-
-  def irb_push_workspace(*opts, &b); end
-
-  def irb_source(*opts, &b); end
-
-  def irb_workspaces(*opts, &b); end
-end
-
-IRB::ExtendCommandBundle::EXCB = IRB::ExtendCommandBundle
-
-module IRB::ExtendCommandBundle
-  def self.irb_original_method_name(method_name); end
-end
-
-class IRB::FileInputMethod
-  def initialize(file); end
-end
-
-class IRB::InputMethod
-  def initialize(file=T.unsafe(nil)); end
-end
-
-class IRB::Inspector
-  def initialize(inspect_proc, init_proc=T.unsafe(nil)); end
-end
-
-class IRB::Irb
-  def handle_exception(exc); end
-
-  def initialize(workspace=T.unsafe(nil), input_method=T.unsafe(nil), output_method=T.unsafe(nil)); end
-
-  def output_value(); end
-
-  def prompt(prompt, ltype, indent, line_no); end
-end
-
-class IRB::Locale
-  def String(mes); end
-
-  def encoding(); end
-
-  def find(file, paths=T.unsafe(nil)); end
-
-  def format(*opts); end
-
-  def gets(*rs); end
-
-  def initialize(locale=T.unsafe(nil)); end
-
-  def lang(); end
-
-  def load(file, priv=T.unsafe(nil)); end
-
-  def modifier(); end
-
-  def print(*opts); end
-
-  def printf(*opts); end
-
-  def puts(*opts); end
-
-  def readline(*rs); end
-
-  def require(file, priv=T.unsafe(nil)); end
-
-  def territory(); end
-  LOCALE_DIR = ::T.let(nil, ::T.untyped)
-  LOCALE_NAME_RE = ::T.let(nil, ::T.untyped)
-end
-
-class IRB::Locale
-end
-
-class IRB::Notifier::AbstractNotifier
-  def initialize(prefix, base_notifier); end
-end
-
-class IRB::Notifier::LeveledNotifier
-  def initialize(base, level, prefix); end
-end
-
-class IRB::Notifier::NoMsgNotifier
-  def initialize(); end
-end
-
-class IRB::ReadlineInputMethod
-  def initialize(); end
-end
-
-class IRB::SLex
-  def Fail(err=T.unsafe(nil), *rest); end
-
-  def Raise(err=T.unsafe(nil), *rest); end
-end
-
-class IRB::SLex::ErrNodeAlreadyExists
-end
-
-class IRB::SLex::ErrNodeAlreadyExists
-end
-
-class IRB::SLex::ErrNodeNothing
-end
-
-class IRB::SLex::ErrNodeNothing
-end
-
-class IRB::SLex
-  extend ::Exception2MessageMapper
-  def self.included(mod); end
-end
-
-class IRB::StdioInputMethod
-  def initialize(); end
-end
-
-class IRB::WorkSpace
-  def initialize(*main); end
-
-  def local_variable_get(name); end
-
-  def local_variable_set(name, value); end
-end
-
-module IRB
-  def self.Inspector(inspect, init=T.unsafe(nil)); end
-
-  def self.delete_caller(); end
-
-  def self.init_config(ap_path); end
-
-  def self.init_error(); end
-
-  def self.load_modules(); end
-
-  def self.parse_opts(argv: T.unsafe(nil)); end
-
-  def self.rc_file(ext=T.unsafe(nil)); end
-
-  def self.rc_file_generators(); end
-
-  def self.run_config(); end
-
-  def self.setup(ap_path, argv: T.unsafe(nil)); end
-end
-
-class Integer
-  def to_bn(); end
-end
-
-class JSON::Ext::Generator::State
-  def self.from_state(arg); end
-end
-
-class JSON::Ext::Parser
-  def initialize(*arg); end
-end
-
-class Keg::ConflictError
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Keg::DirectoryNotWritableError
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Keg::Relocation
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Keg
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class KegOnlyReason
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Kernel
-  include ::ActiveSupport::ForkTracker::CoreExtPrivate
-  include ::ActiveSupport::ForkTracker::CoreExt
-  def agree(*args, &block); end
-
-  def ask(*args, &block); end
-
-  def choose(*args, &block); end
-
-  def pretty_inspect(); end
-
-  def say(*args, &block); end
-end
-
-module Kernel
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-  def self.at_exit(); end
-
-  def self.fork(); end
-
-  def self.gem(dep, *reqs); end
-
-  def self.load(*arg); end
-end
-
-class KeyError
-  include ::DidYouMean::Correctable
-end
-
-module Language::Java
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Language::Node
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Language::Python::Virtualenv
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Locale
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Logger
-  SEV_LABEL = ::T.let(nil, ::T.untyped)
-end
-
-class Logger::Formatter
-  Format = ::T.let(nil, ::T.untyped)
-end
-
-class Logger::LogDevice
-  include ::MonitorMixin
-end
-
-module Logger::Period
-  SiD = ::T.let(nil, ::T.untyped)
-end
-
-module MachOShim
-  def dylib_id(*args, &block); end
-
-  def rpaths(*args, &block); end
-end
-
-class MessagePack::Packer
-  def reset(); end
-
-  def write_bin(arg); end
-
-  def write_bin_header(arg); end
-end
-
-class MessagePack::Unpacker
-  def feed_reference(arg); end
-
-  def freeze?(); end
-end
-
-class Messages
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Method
-  include ::MethodSource::SourceLocation::MethodExtensions
-  include ::MethodSource::MethodExtensions
-end
-
-MiniTest = Minitest
-
-module Minitest::Assertions
-  def assert_mock(mock); end
-end
-
-class Minitest::Expectation
-  def ctx(); end
-
-  def ctx=(_); end
-
-  def target(); end
-
-  def target=(_); end
-end
-
-class Minitest::Expectation
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-module Minitest::Expectations
-  def must_be(*args); end
-
-  def must_be_close_to(*args); end
-
-  def must_be_empty(*args); end
-
-  def must_be_instance_of(*args); end
-
-  def must_be_kind_of(*args); end
-
-  def must_be_nil(*args); end
-
-  def must_be_same_as(*args); end
-
-  def must_be_silent(*args); end
-
-  def must_be_within_delta(*args); end
-
-  def must_be_within_epsilon(*args); end
-
-  def must_equal(*args); end
-
-  def must_include(*args); end
-
-  def must_match(*args); end
-
-  def must_output(*args); end
-
-  def must_raise(*args); end
-
-  def must_respond_to(*args); end
-
-  def must_throw(*args); end
-
-  def path_must_exist(*args); end
-
-  def path_wont_exist(*args); end
-
-  def wont_be(*args); end
-
-  def wont_be_close_to(*args); end
-
-  def wont_be_empty(*args); end
-
-  def wont_be_instance_of(*args); end
-
-  def wont_be_kind_of(*args); end
-
-  def wont_be_nil(*args); end
-
-  def wont_be_same_as(*args); end
-
-  def wont_be_within_delta(*args); end
-
-  def wont_be_within_epsilon(*args); end
-
-  def wont_equal(*args); end
-
-  def wont_include(*args); end
-
-  def wont_match(*args); end
-
-  def wont_respond_to(*args); end
-end
-
-module Minitest::Expectations
-end
-
-class Minitest::Mock
-  def ===(*args, **kwargs, &b); end
-
-  def __call(name, data); end
-
-  def __respond_to?(*arg); end
-
-  def class(*args, **kwargs, &b); end
-
-  def expect(name, retval, args=T.unsafe(nil), **kwargs, &blk); end
-
-  def initialize(delegator=T.unsafe(nil)); end
-
-  def inspect(*args, **kwargs, &b); end
-
-  def instance_eval(*args, **kwargs, &b); end
-
-  def instance_variables(*args, **kwargs, &b); end
-
-  def method_missing(sym, *args, **kwargs, &block); end
-
-  def object_id(*args, **kwargs, &b); end
-
-  def public_send(*args, **kwargs, &b); end
-
-  def respond_to?(sym, include_private=T.unsafe(nil)); end
-
-  def send(*args, **kwargs, &b); end
-
-  def to_s(*args, **kwargs, &b); end
-
-  def verify(); end
-end
-
-class Minitest::Mock
-end
-
-class Minitest::Spec
-  include ::Minitest::Spec::DSL::InstanceMethods
-  TYPES = ::T.let(nil, ::T.untyped)
-end
-
-module Minitest::Spec::DSL
-  def after(_type=T.unsafe(nil), &block); end
-
-  def before(_type=T.unsafe(nil), &block); end
-
-  def children(); end
-
-  def create(name, desc); end
-
-  def desc(); end
-
-  def describe_stack(); end
-
-  def it(desc=T.unsafe(nil), &block); end
-
-  def let(name, &block); end
-
-  def name(); end
-
-  def nuke_test_methods!(); end
-
-  def register_spec_type(*args, &block); end
-
-  def spec_type(desc, *additional); end
-
-  def specify(desc=T.unsafe(nil), &block); end
-
-  def subject(&block); end
-
-  def to_s(); end
-  TYPES = ::T.let(nil, ::T.untyped)
-end
-
-module Minitest::Spec::DSL::InstanceMethods
-  def _(value=T.unsafe(nil), &block); end
-
-  def before_setup(); end
-
-  def expect(value=T.unsafe(nil), &block); end
-
-  def value(value=T.unsafe(nil), &block); end
-end
-
-module Minitest::Spec::DSL::InstanceMethods
-end
-
-module Minitest::Spec::DSL
-  def self.extended(obj); end
-end
-
-class Minitest::Spec
-  extend ::Minitest::Spec::DSL
-  def self.current(); end
-end
-
-class Mktemp
-  include ::FileUtils::StreamUtils_
-end
-
-class Mktemp
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class MockExpectationError
-end
-
-class MockExpectationError
-end
-
-class Module
-  def context(*a, &b); end
-
-  def describe(*a, &b); end
-
-  def example_group(*a, &b); end
-
-  def fcontext(*a, &b); end
-
-  def fdescribe(*a, &b); end
-
-  def infect_an_assertion(meth, new_name, dont_flip=T.unsafe(nil)); end
-
-  def shared_context(name, *args, &block); end
-
-  def shared_examples(name, *args, &block); end
-
-  def shared_examples_for(name, *args, &block); end
-
-  def xcontext(*a, &b); end
-
-  def xdescribe(*a, &b); end
-end
-
-class Monitor
-  def enter(); end
-
-  def exit(); end
-
-  def try_enter(); end
-end
-
-module MonitorMixin
-  def initialize(*args); end
-  EXCEPTION_IMMEDIATE = ::T.let(nil, ::T.untyped)
-  EXCEPTION_NEVER = ::T.let(nil, ::T.untyped)
-end
-
-class MonitorMixin::ConditionVariable
-  def initialize(monitor); end
-end
-
-module Mutex_m
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-module NKF
-  AUTO = ::T.let(nil, ::T.untyped)
-  NOCONV = ::T.let(nil, ::T.untyped)
-  UNKNOWN = ::T.let(nil, ::T.untyped)
-end
-
-class Net::BufferedIO
-  def write_timeout(); end
-
-  def write_timeout=(write_timeout); end
-end
-
-class Net::HTTP
-  def max_retries(); end
-
-  def max_retries=(retries); end
-
-  def max_version(); end
-
-  def max_version=(max_version); end
-
-  def min_version(); end
-
-  def min_version=(min_version); end
-
-  def write_timeout(); end
-
-  def write_timeout=(sec); end
-end
-
-class Net::HTTP::Persistent
-  HAVE_OPENSSL = ::T.let(nil, ::T.untyped)
-end
-
-class Net::HTTPAlreadyReported
-  HAS_BODY = ::T.let(nil, ::T.untyped)
-end
-
-class Net::HTTPAlreadyReported
-end
-
-Net::HTTPClientErrorCode = Net::HTTPClientError
-
-class Net::HTTPEarlyHints
-  HAS_BODY = ::T.let(nil, ::T.untyped)
-end
-
-class Net::HTTPEarlyHints
-end
-
-Net::HTTPFatalErrorCode = Net::HTTPClientError
-
-Net::HTTPInformationCode = Net::HTTPInformation
-
-class Net::HTTPLoopDetected
-  HAS_BODY = ::T.let(nil, ::T.untyped)
-end
-
-class Net::HTTPLoopDetected
-end
-
-class Net::HTTPMisdirectedRequest
-  HAS_BODY = ::T.let(nil, ::T.untyped)
-end
-
-class Net::HTTPMisdirectedRequest
-end
-
-Net::HTTPMovedTemporarily = Net::HTTPFound
-
-Net::HTTPMultipleChoice = Net::HTTPMultipleChoices
-
-class Net::HTTPNotExtended
-  HAS_BODY = ::T.let(nil, ::T.untyped)
-end
-
-class Net::HTTPNotExtended
-end
-
-class Net::HTTPPayloadTooLarge
-  HAS_BODY = ::T.let(nil, ::T.untyped)
-end
-
-class Net::HTTPPayloadTooLarge
-end
-
-class Net::HTTPProcessing
-  HAS_BODY = ::T.let(nil, ::T.untyped)
-end
-
-class Net::HTTPProcessing
-end
-
-class Net::HTTPRangeNotSatisfiable
-  HAS_BODY = ::T.let(nil, ::T.untyped)
-end
-
-class Net::HTTPRangeNotSatisfiable
-end
-
-Net::HTTPRedirectionCode = Net::HTTPRedirection
-
-Net::HTTPRequestURITooLarge = Net::HTTPURITooLong
-
-Net::HTTPResponceReceiver = Net::HTTPResponse
-
-Net::HTTPRetriableCode = Net::HTTPRedirection
-
-Net::HTTPServerErrorCode = Net::HTTPServerError
-
-Net::HTTPSession = Net::HTTP
-
-Net::HTTPSuccessCode = Net::HTTPSuccess
-
-class Net::HTTPURITooLong
-  HAS_BODY = ::T.let(nil, ::T.untyped)
-end
-
-class Net::HTTPURITooLong
-end
-
-Net::HTTPUnknownResponse::EXCEPTION_TYPE = Net::HTTPError
-
-class Net::HTTPVariantAlsoNegotiates
-  HAS_BODY = ::T.let(nil, ::T.untyped)
-end
-
-class Net::HTTPVariantAlsoNegotiates
-end
-
-Net::NetPrivate::HTTPRequest = Net::HTTPRequest
-
-Net::NetPrivate::Socket = Net::InternetMessageIO
-
-Net::ProtocRetryError = Net::ProtoRetriableError
-
-class Net::ReadTimeout
-  def initialize(io=T.unsafe(nil)); end
-
-  def io(); end
-end
-
-class Net::WriteTimeout
-  def initialize(io=T.unsafe(nil)); end
-
-  def io(); end
-end
-
-class NilClass
-  def to_d(); end
-end
-
-class Nokogiri::CSS::Parser
-  Racc_debug_parser = ::T.let(nil, ::T.untyped)
-end
-
-module OS::Mac::CLT
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module OS::Mac::Xcode
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module OS
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Object
-  include ::Minitest::Expectations
-  include ::SystemCommand::Mixin
-  include ::Utils::Curl
-  def __send(*arg); end
-
-  def __send!(*arg); end
-
-  def stub(name, val_or_callable, *block_args, **block_kwargs, &block); end
-
-  def to_yaml(options=T.unsafe(nil)); end
-  ARGF = ::T.let(nil, ::T.untyped)
-  ARGV = ::T.let(nil, ::T.untyped)
-  BUG_REPORTS_URL = ::T.let(nil, ::T.untyped)
-  CROSS_COMPILING = ::T.let(nil, ::T.untyped)
-  DEPRECATED_OFFICIAL_TAPS = ::T.let(nil, ::T.untyped)
-  ENV = ::T.let(nil, ::T.untyped)
-  FORMULA_COMPONENT_PRECEDENCE_LIST = ::T.let(nil, ::T.untyped)
-  HOMEBREW_BOTTLES_EXTNAME_REGEX = ::T.let(nil, ::T.untyped)
-  HOMEBREW_BOTTLE_DEFAULT_DOMAIN = ::T.let(nil, ::T.untyped)
-  HOMEBREW_BREWED_CURL_PATH = ::T.let(nil, ::T.untyped)
-  HOMEBREW_BREW_DEFAULT_GIT_REMOTE = ::T.let(nil, ::T.untyped)
-  HOMEBREW_BREW_FILE = ::T.let(nil, ::T.untyped)
-  HOMEBREW_CACHE = ::T.let(nil, ::T.untyped)
-  HOMEBREW_CACHE_FORMULA = ::T.let(nil, ::T.untyped)
-  HOMEBREW_CASK_TAP_CASK_REGEX = ::T.let(nil, ::T.untyped)
-  HOMEBREW_CELLAR = ::T.let(nil, ::T.untyped)
-  HOMEBREW_CORE_DEFAULT_GIT_REMOTE = ::T.let(nil, ::T.untyped)
-  HOMEBREW_DATA_PATH = ::T.let(nil, ::T.untyped)
-  HOMEBREW_DEFAULT_CACHE = ::T.let(nil, ::T.untyped)
-  HOMEBREW_DEFAULT_LOGS = ::T.let(nil, ::T.untyped)
-  HOMEBREW_DEFAULT_PREFIX = ::T.let(nil, ::T.untyped)
-  HOMEBREW_DEFAULT_REPOSITORY = ::T.let(nil, ::T.untyped)
-  HOMEBREW_DEFAULT_TEMP = ::T.let(nil, ::T.untyped)
-  HOMEBREW_GITHUB_PACKAGES_AUTH = ::T.let(nil, ::T.untyped)
-  HOMEBREW_LIBRARY = ::T.let(nil, ::T.untyped)
-  HOMEBREW_LIBRARY_PATH = ::T.let(nil, ::T.untyped)
-  HOMEBREW_LINKED_KEGS = ::T.let(nil, ::T.untyped)
-  HOMEBREW_LINUX_DEFAULT_PREFIX = ::T.let(nil, ::T.untyped)
-  HOMEBREW_LINUX_DEFAULT_REPOSITORY = ::T.let(nil, ::T.untyped)
-  HOMEBREW_LOCKS = ::T.let(nil, ::T.untyped)
-  HOMEBREW_LOGS = ::T.let(nil, ::T.untyped)
-  HOMEBREW_MACOS_ARM_DEFAULT_PREFIX = ::T.let(nil, ::T.untyped)
-  HOMEBREW_MACOS_ARM_DEFAULT_REPOSITORY = ::T.let(nil, ::T.untyped)
-  HOMEBREW_OFFICIAL_REPO_PREFIXES_REGEX = ::T.let(nil, ::T.untyped)
-  HOMEBREW_PINNED_KEGS = ::T.let(nil, ::T.untyped)
-  HOMEBREW_PREFIX = ::T.let(nil, ::T.untyped)
-  HOMEBREW_PROCESSOR = ::T.let(nil, ::T.untyped)
-  HOMEBREW_PRODUCT = ::T.let(nil, ::T.untyped)
-  HOMEBREW_PULL_API_REGEX = ::T.let(nil, ::T.untyped)
-  HOMEBREW_PULL_OR_COMMIT_URL_REGEX = ::T.let(nil, ::T.untyped)
-  HOMEBREW_REPOSITORY = ::T.let(nil, ::T.untyped)
-  HOMEBREW_REQUIRED_RUBY_VERSION = ::T.let(nil, ::T.untyped)
-  HOMEBREW_RUBY_EXEC_ARGS = ::T.let(nil, ::T.untyped)
-  HOMEBREW_SHIMS_PATH = ::T.let(nil, ::T.untyped)
-  HOMEBREW_SYSTEM = ::T.let(nil, ::T.untyped)
-  HOMEBREW_TAP_CASK_REGEX = ::T.let(nil, ::T.untyped)
-  HOMEBREW_TAP_DIR_REGEX = ::T.let(nil, ::T.untyped)
-  HOMEBREW_TAP_FORMULA_REGEX = ::T.let(nil, ::T.untyped)
-  HOMEBREW_TAP_PATH_REGEX = ::T.let(nil, ::T.untyped)
-  HOMEBREW_TEMP = ::T.let(nil, ::T.untyped)
-  HOMEBREW_USER_AGENT_CURL = ::T.let(nil, ::T.untyped)
-  HOMEBREW_USER_AGENT_FAKE_SAFARI = ::T.let(nil, ::T.untyped)
-  HOMEBREW_USER_AGENT_RUBY = ::T.let(nil, ::T.untyped)
-  HOMEBREW_VERSION = ::T.let(nil, ::T.untyped)
-  HOMEBREW_WWW = ::T.let(nil, ::T.untyped)
-  LINUXBREW_CORE_MIGRATION_LIST = ::T.let(nil, ::T.untyped)
-  OFFICIAL_CASK_TAPS = ::T.let(nil, ::T.untyped)
-  OFFICIAL_CMD_TAPS = ::T.let(nil, ::T.untyped)
-  OS_VERSION = ::T.let(nil, ::T.untyped)
-  PATCH_A_SHA256 = ::T.let(nil, ::T.untyped)
-  PATCH_B_SHA256 = ::T.let(nil, ::T.untyped)
-  REQUIRED_RUBY_X = ::T.let(nil, ::T.untyped)
-  REQUIRED_RUBY_Y = ::T.let(nil, ::T.untyped)
-  RUBY18 = ::T.let(nil, ::T.untyped)
-  RUBY19 = ::T.let(nil, ::T.untyped)
-  RUBY_BIN = ::T.let(nil, ::T.untyped)
-  RUBY_COPYRIGHT = ::T.let(nil, ::T.untyped)
-  RUBY_DESCRIPTION = ::T.let(nil, ::T.untyped)
-  RUBY_ENGINE = ::T.let(nil, ::T.untyped)
-  RUBY_ENGINE_VERSION = ::T.let(nil, ::T.untyped)
-  RUBY_PATCHLEVEL = ::T.let(nil, ::T.untyped)
-  RUBY_PATH = ::T.let(nil, ::T.untyped)
-  RUBY_PLATFORM = ::T.let(nil, ::T.untyped)
-  RUBY_RELEASE_DATE = ::T.let(nil, ::T.untyped)
-  RUBY_REVISION = ::T.let(nil, ::T.untyped)
-  RUBY_VERSION = ::T.let(nil, ::T.untyped)
-  RUBY_X = ::T.let(nil, ::T.untyped)
-  RUBY_Y = ::T.let(nil, ::T.untyped)
-  STDERR = ::T.let(nil, ::T.untyped)
-  STDIN = ::T.let(nil, ::T.untyped)
-  STDOUT = ::T.let(nil, ::T.untyped)
-  TESTBALL_PATCHES_SHA256 = ::T.let(nil, ::T.untyped)
-  TESTBALL_SHA256 = ::T.let(nil, ::T.untyped)
-  TEST_FIXTURE_DIR = ::T.let(nil, ::T.untyped)
-  TEST_SHA1 = ::T.let(nil, ::T.untyped)
-  TEST_SHA256 = ::T.let(nil, ::T.untyped)
-  TEST_TMPDIR = ::T.let(nil, ::T.untyped)
-  TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped)
-end
-
-class Object
-  def self.yaml_tag(url); end
-end
-
-module OnSystem::MacOSAndLinux
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module OnSystem::MacOSOnly
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module OnSystem
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class OpenSSL::ASN1::ASN1Data
-  def indefinite_length(); end
-
-  def indefinite_length=(indefinite_length); end
-end
-
-class OpenSSL::BN
-  def +@(); end
-
-  def -@(); end
-
-  def /(arg); end
-
-  def negative?(); end
-end
-
-module OpenSSL::KDF
-end
-
-class OpenSSL::KDF::KDFError
-end
-
-class OpenSSL::KDF::KDFError
-end
-
-module OpenSSL::KDF
-  def self.hkdf(*arg); end
-
-  def self.pbkdf2_hmac(*arg); end
-
-  def self.scrypt(*arg); end
-end
-
-class OpenSSL::OCSP::Request
-  def signed?(); end
-end
-
-OpenSSL::PKCS7::Signer = OpenSSL::PKCS7::SignerInfo
-
-class OpenSSL::PKey::EC
-  EXPLICIT_CURVE = ::T.let(nil, ::T.untyped)
-end
-
-class OpenSSL::PKey::EC::Point
-  def to_octet_string(arg); end
-end
-
-module OpenSSL::SSL
-  OP_ALLOW_NO_DHE_KEX = ::T.let(nil, ::T.untyped)
-  OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION = ::T.let(nil, ::T.untyped)
-  OP_CRYPTOPRO_TLSEXT_BUG = ::T.let(nil, ::T.untyped)
-  OP_LEGACY_SERVER_CONNECT = ::T.let(nil, ::T.untyped)
-  OP_NO_ENCRYPT_THEN_MAC = ::T.let(nil, ::T.untyped)
-  OP_NO_RENEGOTIATION = ::T.let(nil, ::T.untyped)
-  OP_NO_TLSv1_3 = ::T.let(nil, ::T.untyped)
-  OP_SAFARI_ECDHE_ECDSA_BUG = ::T.let(nil, ::T.untyped)
-  OP_TLSEXT_PADDING = ::T.let(nil, ::T.untyped)
-  SSL2_VERSION = ::T.let(nil, ::T.untyped)
-  SSL3_VERSION = ::T.let(nil, ::T.untyped)
-  TLS1_1_VERSION = ::T.let(nil, ::T.untyped)
-  TLS1_2_VERSION = ::T.let(nil, ::T.untyped)
-  TLS1_3_VERSION = ::T.let(nil, ::T.untyped)
-  TLS1_VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class OpenSSL::SSL::SSLContext
-  def alpn_protocols(); end
-
-  def alpn_protocols=(alpn_protocols); end
-
-  def alpn_select_cb(); end
-
-  def alpn_select_cb=(alpn_select_cb); end
-
-  def enable_fallback_scsv(); end
-
-  def max_version=(version); end
-
-  def min_version=(version); end
-  DEFAULT_TMP_DH_CALLBACK = ::T.let(nil, ::T.untyped)
-end
-
-class OpenSSL::SSL::SSLSocket
-  def alpn_protocol(); end
-
-  def tmp_key(); end
-end
-
-module OpenSSL::X509
-  V_FLAG_NO_CHECK_TIME = ::T.let(nil, ::T.untyped)
-  V_FLAG_TRUSTED_FIRST = ::T.let(nil, ::T.untyped)
-end
-
-class OpenSSL::X509::Attribute
-  def ==(other); end
-end
-
-class OpenSSL::X509::CRL
-  def ==(other); end
-end
-
-class OpenSSL::X509::Extension
-  def ==(other); end
-end
-
-class OpenSSL::X509::Name
-  def to_utf8(); end
-end
-
-class OpenSSL::X509::Request
-  def ==(other); end
-end
-
-class OpenSSL::X509::Revoked
-  def ==(other); end
-
-  def to_der(); end
-end
-
-module OpenSSL
-  def self.fips_mode(); end
-end
-
-class OpenURI::Buffer
-  def <<(str); end
-
-  def io(); end
-
-  def size(); end
-  StringMax = ::T.let(nil, ::T.untyped)
-end
-
-class OpenURI::Buffer
-end
-
-class OpenURI::HTTPError
-  def initialize(message, io); end
-end
-
-class OpenURI::HTTPRedirect
-  def initialize(message, io, uri); end
-end
-
-module OpenURI::Meta
-  def content_type_parse(); end
-
-  def meta_add_field(name, value); end
-
-  def meta_add_field2(name, values); end
-
-  def meta_setup_encoding(); end
-  RE_LWS = ::T.let(nil, ::T.untyped)
-  RE_PARAMETERS = ::T.let(nil, ::T.untyped)
-  RE_QUOTED_STRING = ::T.let(nil, ::T.untyped)
-  RE_TOKEN = ::T.let(nil, ::T.untyped)
-end
-
-module OpenURI::Meta
-  def self.init(obj, src=T.unsafe(nil)); end
-end
-
-module OpenURI
-  def self.check_options(options); end
-
-  def self.open_http(buf, target, proxy, options); end
-
-  def self.open_loop(uri, options); end
-
-  def self.open_uri(name, *rest); end
-
-  def self.redirectable?(uri1, uri2); end
-
-  def self.scan_open_optional_arguments(*rest); end
-end
-
-class Option
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Options
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class PATH
-  def each(*args, &block); end
-end
-
-class PATH
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module ParallelTests
-  WINDOWS = ::T.let(nil, ::T.untyped)
-end
-
-class Parlour::ConflictResolver
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::Conversion::Converter
-  extend ::T::Sig
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::Debugging::Tree
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Parlour::Debugging
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::Generator
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Parlour::Mixin::Searchable
-  extend ::T::Sig
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::Options
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::ParseError
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::Plugin
-  extend ::T::Sig
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::RbiGenerator::Parameter
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::RbiGenerator::StructProp
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::RbsGenerator::Block
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::RbsGenerator::MethodSignature
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::RbsGenerator::Parameter
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Parlour::TypeLoader
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::TypeParser::NodePath
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::TypeParser
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::TypedObject
-  extend ::T::Sig
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::Types::Proc::Parameter
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parlour::Types::Type
-  extend ::T::Sig
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Parser::Ruby26
-  Racc_debug_parser = ::T.let(nil, ::T.untyped)
-end
-
-class Pathname
-  include ::ELFShim
-  include ::MachOShim
-end
-
-class Pathname
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class PkgVersion
-  def major(*args, &block); end
-
-  def major_minor(*args, &block); end
-
-  def major_minor_patch(*args, &block); end
-
-  def minor(*args, &block); end
-
-  def patch(*args, &block); end
-end
-
-class Proc
-  include ::MethodSource::SourceLocation::ProcExtensions
-  include ::MethodSource::MethodExtensions
-  def <<(arg); end
-
-  def >>(arg); end
-
-  def clone(); end
-end
-
-module Process
-  def self.fork(); end
-end
-
-class Pry::BasicObject
-  include ::ActiveSupport::ForkTracker::CoreExtPrivate
-  include ::ActiveSupport::ForkTracker::CoreExt
-end
-
-module Psych
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-module Psych
-  def self.add_builtin_type(type_tag, &block); end
-
-  def self.add_domain_type(domain, type_tag, &block); end
-
-  def self.add_tag(tag, klass); end
-
-  def self.domain_types(); end
-
-  def self.domain_types=(domain_types); end
-
-  def self.dump_tags(); end
-
-  def self.dump_tags=(dump_tags); end
-
-  def self.libyaml_version(); end
-
-  def self.load_tags(); end
-
-  def self.load_tags=(load_tags); end
-
-  def self.remove_type(type_tag); end
-end
-
-class PyPI::Package
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module PyPI
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RBI::ASTVisitor
-  extend ::T::Helpers
-  extend ::T::Sig
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RBI::File
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RBI::Formatter
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RBI::Index
-  include ::T::Enumerable
-end
-
-module RBI::Indexable
-  extend ::T::Sig
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RBI::Loc
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RBI::Node
-  extend ::T::Sig
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RBI::ParseError
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RBI::Parser
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RBI::Rewriters::Merge::Conflict
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RBI::Rewriters::Merge
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RBI::Rewriters::RemoveKnownDefinitions::Operation
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RBI::UnexpectedParserError
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RBI::Visitor
-  extend ::T::Helpers
-  extend ::T::Sig
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class REXML::XPathParser
-  DEBUG = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::ExampleGroup
-  include ::RSpec::Core::MockingAdapters::RSpec
-  include ::RSpec::Mocks::ExampleMethods
-  include ::RSpec::Mocks::ArgumentMatchers
-  include ::RSpec::Mocks::ExampleMethods::ExpectHost
-  include ::RSpec::Matchers
-end
-
-module RSpec::Core::HashImitatable
-  def assert_valid_keys(*args, &block); end
-
-  def compact_blank(*args, &block); end
-
-  def compact_blank!(*args, &block); end
-
-  def deep_stringify_keys(*args, &block); end
-
-  def deep_stringify_keys!(*args, &block); end
-
-  def deep_symbolize_keys(*args, &block); end
-
-  def deep_symbolize_keys!(*args, &block); end
-
-  def deep_transform_keys(*args, &block); end
-
-  def deep_transform_keys!(*args, &block); end
-
-  def exclude?(*args, &block); end
-
-  def excluding(*args, &block); end
-
-  def extractable_options?(*args, &block); end
-
-  def including(*args, &block); end
-
-  def index_by(*args, &block); end
-
-  def index_with(*args, &block); end
-
-  def many?(*args, &block); end
-
-  def pick(*args, &block); end
-
-  def pluck(*args, &block); end
-
-  def stringify_keys(*args, &block); end
-
-  def stringify_keys!(*args, &block); end
-
-  def symbolize_keys(*args, &block); end
-
-  def symbolize_keys!(*args, &block); end
-
-  def to_options(*args, &block); end
-
-  def to_options!(*args, &block); end
-
-  def without(*args, &block); end
-end
-
-module RSpec::Core::MockingAdapters
-end
-
-module RSpec::Core::MockingAdapters::RSpec
-  include ::RSpec::Mocks::ExampleMethods
-  include ::RSpec::Mocks::ArgumentMatchers
-  include ::RSpec::Mocks::ExampleMethods::ExpectHost
-  def setup_mocks_for_rspec(); end
-
-  def teardown_mocks_for_rspec(); end
-
-  def verify_mocks_for_rspec(); end
-end
-
-module RSpec::Core::MockingAdapters::RSpec
-  def self.configuration(); end
-
-  def self.framework_name(); end
-end
-
-module RSpec::Core::MockingAdapters
-end
-
-class RSpec::Core::OutputWrapper
-  def as_json(*args, &block); end
-
-  def readline_nonblock(*args, &block); end
-end
-
-class RSpec::Expectations::MultipleExpectationsNotMetError
-  include ::RSpec::Core::MultipleExceptionError::InterfaceTag
-end
-
-module Racc
-  Racc_No_Extensions = ::T.let(nil, ::T.untyped)
-end
-
-class Racc::CparseParams
-end
-
-class Racc::CparseParams
-end
-
-class Random
-  def self.bytes(arg); end
-end
-
-class Range
-  def %(arg); end
-
-  def entries(); end
-
-  def to_a(); end
-end
-
-module RbConfig
-  def self.expand(val, config=T.unsafe(nil)); end
-
-  def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end
-
-  def self.ruby(); end
-end
-
-module Readline
-  def self.completion_quote_character(); end
-end
-
-class Requirement
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Requirements
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Resolv::DNS
-  def extract_resources(msg, name, typeclass); end
-  RequestID = ::T.let(nil, ::T.untyped)
-  RequestIDMutex = ::T.let(nil, ::T.untyped)
-end
-
-class Resolv::DNS::Config
-  def initialize(config_info=T.unsafe(nil)); end
-end
-
-class Resolv::DNS::Label::Str
-  def initialize(string); end
-end
-
-class Resolv::DNS::Message
-  def initialize(id=T.unsafe(nil)); end
-end
-
-class Resolv::DNS::Message::MessageDecoder
-  def initialize(data); end
-end
-
-class Resolv::DNS::Requester::ConnectedUDP
-  def initialize(host, port=T.unsafe(nil)); end
-
-  def lazy_initialize(); end
-end
-
-class Resolv::DNS::Requester::Sender
-  def initialize(msg, data, sock); end
-end
-
-class Resolv::DNS::Requester::TCP
-  def initialize(host, port=T.unsafe(nil)); end
-end
-
-class Resolv::DNS::Requester::UnconnectedUDP
-  def initialize(*nameserver_port); end
-
-  def lazy_initialize(); end
-end
-
-class Resolv::DNS::Requester::UnconnectedUDP::Sender
-  def initialize(msg, data, sock, host, port); end
-end
-
-class Resolv::DNS::Resource
-  ClassValue = ::T.let(nil, ::T.untyped)
-end
-
-class Resolv::DNS::Resource::LOC
-  def initialize(version, ssize, hprecision, vprecision, latitude, longitude, altitude); end
-end
-
-class Resolv::DNS
-  def self.allocate_request_id(host, port); end
-
-  def self.bind_random_port(udpsock, bind_host=T.unsafe(nil)); end
-
-  def self.free_request_id(host, port, id); end
-
-  def self.random(arg); end
-end
-
-class Resource
-  include ::FileUtils::StreamUtils_
-  def on_arm(&block); end
-
-  def on_big_sur(or_condition=T.unsafe(nil), &block); end
-
-  def on_catalina(or_condition=T.unsafe(nil), &block); end
-
-  def on_el_capitan(or_condition=T.unsafe(nil), &block); end
-
-  def on_high_sierra(or_condition=T.unsafe(nil), &block); end
-
-  def on_intel(&block); end
-
-  def on_linux(&block); end
-
-  def on_macos(&block); end
-
-  def on_mojave(or_condition=T.unsafe(nil), &block); end
-
-  def on_monterey(or_condition=T.unsafe(nil), &block); end
-
-  def on_sierra(or_condition=T.unsafe(nil), &block); end
-
-  def on_system(linux, macos:, &block); end
-
-  def on_ventura(or_condition=T.unsafe(nil), &block); end
-end
-
-class Resource::Partial
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class ResourceStageContext
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Ripper
-  def column(); end
-
-  def encoding(); end
-
-  def end_seen?(); end
-
-  def error?(); end
-
-  def filename(); end
-
-  def initialize(*arg); end
-
-  def lineno(); end
-
-  def parse(); end
-
-  def state(); end
-
-  def yydebug(); end
-
-  def yydebug=(yydebug); end
-  EXPR_ARG = ::T.let(nil, ::T.untyped)
-  EXPR_ARG_ANY = ::T.let(nil, ::T.untyped)
-  EXPR_BEG = ::T.let(nil, ::T.untyped)
-  EXPR_BEG_ANY = ::T.let(nil, ::T.untyped)
-  EXPR_CLASS = ::T.let(nil, ::T.untyped)
-  EXPR_CMDARG = ::T.let(nil, ::T.untyped)
-  EXPR_DOT = ::T.let(nil, ::T.untyped)
-  EXPR_END = ::T.let(nil, ::T.untyped)
-  EXPR_ENDARG = ::T.let(nil, ::T.untyped)
-  EXPR_ENDFN = ::T.let(nil, ::T.untyped)
-  EXPR_END_ANY = ::T.let(nil, ::T.untyped)
-  EXPR_FITEM = ::T.let(nil, ::T.untyped)
-  EXPR_FNAME = ::T.let(nil, ::T.untyped)
-  EXPR_LABEL = ::T.let(nil, ::T.untyped)
-  EXPR_LABELED = ::T.let(nil, ::T.untyped)
-  EXPR_MID = ::T.let(nil, ::T.untyped)
-  EXPR_NONE = ::T.let(nil, ::T.untyped)
-  EXPR_VALUE = ::T.let(nil, ::T.untyped)
-  PARSER_EVENT_TABLE = ::T.let(nil, ::T.untyped)
-  SCANNER_EVENT_TABLE = ::T.let(nil, ::T.untyped)
-  Version = ::T.let(nil, ::T.untyped)
-end
-
-class Ripper::Filter
-  def initialize(src, filename=T.unsafe(nil), lineno=T.unsafe(nil)); end
-end
-
-class Ripper::Lexer
-  def lex(); end
-
-  def tokenize(); end
-end
-
-class Ripper::Lexer::Elem
-  def event(); end
-
-  def event=(_); end
-
-  def initialize(pos, event, tok, state); end
-
-  def pos(); end
-
-  def pos=(_); end
-
-  def state(); end
-
-  def state=(_); end
-
-  def tok(); end
-
-  def tok=(_); end
-end
-
-class Ripper::Lexer::Elem
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class Ripper::Lexer::State
-  def &(i); end
-
-  def ==(i); end
-
-  def allbits?(i); end
-
-  def anybits?(i); end
-
-  def initialize(i); end
-
-  def nobits?(i); end
-
-  def to_i(); end
-
-  def to_int(); end
-
-  def to_int=(_); end
-
-  def to_s=(_); end
-
-  def |(i); end
-end
-
-class Ripper::Lexer::State
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class Ripper::Lexer
-end
-
-class Ripper::SexpBuilder
-  def on_BEGIN(*args); end
-
-  def on_CHAR(tok); end
-
-  def on_END(*args); end
-
-  def on___end__(tok); end
-
-  def on_alias(*args); end
-
-  def on_alias_error(*args); end
-
-  def on_aref(*args); end
-
-  def on_aref_field(*args); end
-
-  def on_arg_ambiguous(*args); end
-
-  def on_arg_paren(*args); end
-
-  def on_args_add(*args); end
-
-  def on_args_add_block(*args); end
-
-  def on_args_add_star(*args); end
-
-  def on_args_new(*args); end
-
-  def on_array(*args); end
-
-  def on_assign(*args); end
-
-  def on_assign_error(*args); end
-
-  def on_assoc_new(*args); end
-
-  def on_assoc_splat(*args); end
-
-  def on_assoclist_from_args(*args); end
-
-  def on_backref(tok); end
-
-  def on_backtick(tok); end
-
-  def on_bare_assoc_hash(*args); end
-
-  def on_begin(*args); end
-
-  def on_binary(*args); end
-
-  def on_block_var(*args); end
-
-  def on_blockarg(*args); end
-
-  def on_bodystmt(*args); end
-
-  def on_brace_block(*args); end
-
-  def on_break(*args); end
-
-  def on_call(*args); end
-
-  def on_case(*args); end
-
-  def on_class(*args); end
-
-  def on_class_name_error(*args); end
-
-  def on_comma(tok); end
-
-  def on_command(*args); end
-
-  def on_command_call(*args); end
-
-  def on_comment(tok); end
-
-  def on_const(tok); end
-
-  def on_const_path_field(*args); end
-
-  def on_const_path_ref(*args); end
-
-  def on_const_ref(*args); end
-
-  def on_cvar(tok); end
-
-  def on_def(*args); end
-
-  def on_defined(*args); end
-
-  def on_defs(*args); end
-
-  def on_do_block(*args); end
-
-  def on_dot2(*args); end
-
-  def on_dot3(*args); end
-
-  def on_dyna_symbol(*args); end
-
-  def on_else(*args); end
-
-  def on_elsif(*args); end
-
-  def on_embdoc(tok); end
-
-  def on_embdoc_beg(tok); end
-
-  def on_embdoc_end(tok); end
-
-  def on_embexpr_beg(tok); end
-
-  def on_embexpr_end(tok); end
-
-  def on_embvar(tok); end
-
-  def on_ensure(*args); end
-
-  def on_excessed_comma(*args); end
-
-  def on_fcall(*args); end
-
-  def on_field(*args); end
-
-  def on_float(tok); end
-
-  def on_for(*args); end
-
-  def on_gvar(tok); end
-
-  def on_hash(*args); end
-
-  def on_heredoc_beg(tok); end
-
-  def on_heredoc_end(tok); end
-
-  def on_ident(tok); end
-
-  def on_if(*args); end
-
-  def on_if_mod(*args); end
-
-  def on_ifop(*args); end
-
-  def on_ignored_nl(tok); end
-
-  def on_ignored_sp(tok); end
-
-  def on_imaginary(tok); end
-
-  def on_int(tok); end
-
-  def on_ivar(tok); end
-
-  def on_kw(tok); end
-
-  def on_kwrest_param(*args); end
-
-  def on_label(tok); end
-
-  def on_label_end(tok); end
-
-  def on_lambda(*args); end
-
-  def on_lbrace(tok); end
-
-  def on_lbracket(tok); end
-
-  def on_lparen(tok); end
-
-  def on_magic_comment(*args); end
-
-  def on_massign(*args); end
-
-  def on_method_add_arg(*args); end
-
-  def on_method_add_block(*args); end
-
-  def on_mlhs_add(*args); end
-
-  def on_mlhs_add_post(*args); end
-
-  def on_mlhs_add_star(*args); end
-
-  def on_mlhs_new(*args); end
-
-  def on_mlhs_paren(*args); end
-
-  def on_module(*args); end
-
-  def on_mrhs_add(*args); end
-
-  def on_mrhs_add_star(*args); end
-
-  def on_mrhs_new(*args); end
-
-  def on_mrhs_new_from_args(*args); end
-
-  def on_next(*args); end
-
-  def on_nl(tok); end
-
-  def on_op(tok); end
-
-  def on_opassign(*args); end
-
-  def on_operator_ambiguous(*args); end
-
-  def on_param_error(*args); end
-
-  def on_params(*args); end
-
-  def on_paren(*args); end
-
-  def on_parse_error(*args); end
-
-  def on_period(tok); end
-
-  def on_program(*args); end
-
-  def on_qsymbols_add(*args); end
-
-  def on_qsymbols_beg(tok); end
-
-  def on_qsymbols_new(*args); end
-
-  def on_qwords_add(*args); end
-
-  def on_qwords_beg(tok); end
-
-  def on_qwords_new(*args); end
-
-  def on_rational(tok); end
-
-  def on_rbrace(tok); end
-
-  def on_rbracket(tok); end
-
-  def on_redo(*args); end
-
-  def on_regexp_add(*args); end
-
-  def on_regexp_beg(tok); end
-
-  def on_regexp_end(tok); end
-
-  def on_regexp_literal(*args); end
-
-  def on_regexp_new(*args); end
-
-  def on_rescue(*args); end
-
-  def on_rescue_mod(*args); end
-
-  def on_rest_param(*args); end
-
-  def on_retry(*args); end
-
-  def on_return(*args); end
-
-  def on_return0(*args); end
-
-  def on_rparen(tok); end
-
-  def on_sclass(*args); end
-
-  def on_semicolon(tok); end
-
-  def on_sp(tok); end
-
-  def on_stmts_add(*args); end
-
-  def on_stmts_new(*args); end
-
-  def on_string_add(*args); end
-
-  def on_string_concat(*args); end
-
-  def on_string_content(*args); end
-
-  def on_string_dvar(*args); end
-
-  def on_string_embexpr(*args); end
-
-  def on_string_literal(*args); end
-
-  def on_super(*args); end
-
-  def on_symbeg(tok); end
-
-  def on_symbol(*args); end
-
-  def on_symbol_literal(*args); end
-
-  def on_symbols_add(*args); end
-
-  def on_symbols_beg(tok); end
-
-  def on_symbols_new(*args); end
-
-  def on_tlambda(tok); end
-
-  def on_tlambeg(tok); end
-
-  def on_top_const_field(*args); end
-
-  def on_top_const_ref(*args); end
-
-  def on_tstring_beg(tok); end
-
-  def on_tstring_content(tok); end
-
-  def on_tstring_end(tok); end
-
-  def on_unary(*args); end
-
-  def on_undef(*args); end
-
-  def on_unless(*args); end
-
-  def on_unless_mod(*args); end
-
-  def on_until(*args); end
-
-  def on_until_mod(*args); end
-
-  def on_var_alias(*args); end
-
-  def on_var_field(*args); end
-
-  def on_var_ref(*args); end
-
-  def on_vcall(*args); end
-
-  def on_void_stmt(*args); end
-
-  def on_when(*args); end
-
-  def on_while(*args); end
-
-  def on_while_mod(*args); end
-
-  def on_word_add(*args); end
-
-  def on_word_new(*args); end
-
-  def on_words_add(*args); end
-
-  def on_words_beg(tok); end
-
-  def on_words_new(*args); end
-
-  def on_words_sep(tok); end
-
-  def on_xstring_add(*args); end
-
-  def on_xstring_literal(*args); end
-
-  def on_xstring_new(*args); end
-
-  def on_yield(*args); end
-
-  def on_yield0(*args); end
-
-  def on_zsuper(*args); end
-end
-
-class Ripper::TokenPattern
-  def initialize(pattern); end
-
-  def match(str); end
-
-  def match_list(tokens); end
-  MAP = ::T.let(nil, ::T.untyped)
-end
-
-class Ripper::TokenPattern::CompileError
-end
-
-class Ripper::TokenPattern::CompileError
-end
-
-class Ripper::TokenPattern::Error
-end
-
-class Ripper::TokenPattern::Error
-end
-
-class Ripper::TokenPattern::MatchData
-  def initialize(tokens, match); end
-
-  def string(n=T.unsafe(nil)); end
-end
-
-class Ripper::TokenPattern::MatchData
-end
-
-class Ripper::TokenPattern::MatchError
-end
-
-class Ripper::TokenPattern::MatchError
-end
-
-class Ripper::TokenPattern
-  def self.compile(*arg); end
-end
-
-class Ripper
-  def self.dedent_string(arg, arg1); end
-
-  def self.lex_state_name(arg); end
-
-  def self.token_match(src, pattern); end
-end
-
-module RuboCop::AST::CollectionNode
-  def compact_blank(*args, &block); end
-
-  def compact_blank!(*args, &block); end
-
-  def exclude?(*args, &block); end
-
-  def excluding(*args, &block); end
-
-  def extract_options!(*args, &block); end
-
-  def including(*args, &block); end
-
-  def index_by(*args, &block); end
-
-  def index_with(*args, &block); end
-
-  def many?(*args, &block); end
-
-  def pick(*args, &block); end
-
-  def pluck(*args, &block); end
-
-  def to_default_s(*args, &block); end
-
-  def to_formatted_s(*args, &block); end
-
-  def to_sentence(*args, &block); end
-
-  def to_xml(*args, &block); end
-
-  def without(*args, &block); end
-end
-
-class RuboCop::AST::Node
-  def block_args(param0=T.unsafe(nil)); end
-
-  def block_body(param0=T.unsafe(nil)); end
-
-  def cask_block?(param0=T.unsafe(nil)); end
-
-  def key_node(param0=T.unsafe(nil)); end
-
-  def method_node(param0=T.unsafe(nil)); end
-
-  def val_node(param0=T.unsafe(nil)); end
-end
-
-class RuboCop::AST::NodePattern::Parser
-  Racc_debug_parser = ::T.let(nil, ::T.untyped)
-end
-
-module RuboCop::AST::NodePattern::Sets
-  SET_BUILD_RECOMMENDED_TEST_OPTIONAL = ::T.let(nil, ::T.untyped)
-  SET_DEPENDS_ON_USES_FROM_MACOS = ::T.let(nil, ::T.untyped)
-  SET_INCLUDE_WITH_WITHOUT = ::T.let(nil, ::T.untyped)
-  SET_SYSTEM_SHELL_OUTPUT_PIPE_OUTPUT = ::T.let(nil, ::T.untyped)
-  SET_WITH_WITHOUT = ::T.let(nil, ::T.untyped)
-end
-
-class RuboCop::Cask::AST::CaskHeader
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RuboCop::Cask::AST::Stanza
-  def app?(); end
-
-  def appcast?(); end
-
-  def artifact?(); end
-
-  def audio_unit_plugin?(); end
-
-  def auto_updates?(); end
-
-  def binary?(); end
-
-  def caveats?(); end
-
-  def colorpicker?(); end
-
-  def conflicts_with?(); end
-
-  def container?(); end
-
-  def depends_on?(); end
-
-  def desc?(); end
-
-  def dictionary?(); end
-
-  def font?(); end
-
-  def homepage?(); end
-
-  def input_method?(); end
-
-  def installer?(); end
-
-  def internet_plugin?(); end
-
-  def language?(); end
-
-  def livecheck?(); end
-
-  def manpage?(); end
-
-  def mdimporter?(); end
-
-  def name?(); end
-
-  def pkg?(); end
-
-  def postflight?(); end
-
-  def preflight?(); end
-
-  def prefpane?(); end
-
-  def qlplugin?(); end
-
-  def screen_saver?(); end
-
-  def service?(); end
-
-  def sha256?(); end
-
-  def stage_only?(); end
-
-  def suite?(); end
-
-  def uninstall?(); end
-
-  def uninstall_postflight?(); end
-
-  def uninstall_preflight?(); end
-
-  def url?(); end
-
-  def version?(); end
-
-  def vst3_plugin?(); end
-
-  def vst_plugin?(); end
-
-  def zap?(); end
-end
-
-class RuboCop::Cop::Cask::NoDslVersion
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RuboCop::Cop::Cop
-  def highlights(); end
-
-  def messages(); end
-end
-
-class RuboCop::Cop::FormulaAudit::ComponentsOrder
-  def depends_on_node?(param0=T.unsafe(nil)); end
-end
-
-class RuboCop::Cop::FormulaAudit::DependencyOrder
-  def build_with_dependency_node(param0); end
-
-  def buildtime_dependency?(param0); end
-
-  def dependency_name_node(param0); end
-
-  def depends_on_node?(param0=T.unsafe(nil)); end
-
-  def negate_normal_dependency?(param0); end
-
-  def optional_dependency?(param0); end
-
-  def recommended_dependency?(param0); end
-
-  def test_dependency?(param0); end
-
-  def uses_from_macos_node?(param0=T.unsafe(nil)); end
-end
-
-class RuboCop::Cop::FormulaAudit::DeprecateDisableDate
-  def date(param0); end
-end
-
-class RuboCop::Cop::FormulaAudit::DeprecateDisableReason
-  def reason(param0); end
-end
-
-class RuboCop::Cop::FormulaAudit::GitUrls
-  def url_has_revision?(param0=T.unsafe(nil)); end
-end
-
-class RuboCop::Cop::FormulaAudit::Licenses
-  def license_exception?(param0=T.unsafe(nil)); end
-end
-
-class RuboCop::Cop::FormulaAudit::Miscellaneous
-  def conditional_dependencies(param0); end
-
-  def destructure_hash(param0=T.unsafe(nil)); end
-
-  def formula_path_strings(param0, param1); end
-
-  def hash_dep(param0=T.unsafe(nil)); end
-
-  def languageNodeModule?(param0); end
-end
-
-class RuboCop::Cop::FormulaAudit::OptionDeclarations
-  def depends_on_build_with(param0); end
-end
-
-class RuboCop::Cop::FormulaAudit::Patches
-  def patch_data?(param0); end
-end
-
-class RuboCop::Cop::FormulaAudit::Patches
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RuboCop::Cop::FormulaAudit::PyPiUrls
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class RuboCop::Cop::FormulaAudit::Test
-  def test_calls(param0); end
-end
-
-class RuboCop::Cop::FormulaAudit::Text
-  def prefix_path(param0); end
-end
-
-class RuboCop::Cop::FormulaAuditStrict::GitUrls
-  def url_has_tag?(param0=T.unsafe(nil)); end
-end
-
-class RuboCop::Cop::FormulaAuditStrict::Text
-  def interpolated_share_path_starts_with(param0, param1); end
-
-  def share_path_starts_with(param0, param1); end
-end
-
-class RuboCop::Cop::FormulaCop
-  def dependency_name_hash_match?(param0, param1); end
-
-  def dependency_type_hash_match?(param0, param1); end
-
-  def required_dependency?(param0); end
-
-  def required_dependency_name?(param0, param1); end
-end
-
-module RuboCop::RSpec::ExpectOffense
-  def expect_correction(correction, loop: T.unsafe(nil), source: T.unsafe(nil)); end
-
-  def expect_no_corrections(); end
-
-  def expect_no_offenses(source, file=T.unsafe(nil)); end
-
-  def expect_offense(source, file=T.unsafe(nil), severity: T.unsafe(nil), chomp: T.unsafe(nil), **replacements); end
-
-  def format_offense(source, **replacements); end
-
-  def parse_annotations(source, raise_error: T.unsafe(nil), **replacements); end
-
-  def parse_processed_source(source, file=T.unsafe(nil)); end
-
-  def set_formatter_options(); end
-end
-
-class RuboCop::RSpec::ExpectOffense::AnnotatedSource
-  def ==(other); end
-
-  def annotations(); end
-
-  def initialize(lines, annotations); end
-
-  def lines(); end
-
-  def match_annotations?(other); end
-
-  def plain_source(); end
-
-  def with_offense_annotations(offenses); end
-  ABBREV = ::T.let(nil, ::T.untyped)
-  ANNOTATION_PATTERN = ::T.let(nil, ::T.untyped)
-end
-
-class RuboCop::RSpec::ExpectOffense::AnnotatedSource
-  def self.parse(annotated_source); end
-end
-
-module RuboCop::RSpec::ExpectOffense
-end
-
-class RuboCop::RSpec::ParallelFormatter
-  def dump_pending(*arg); end
-end
-
-class RuboCop::RSpec::ParallelFormatter
-end
-
-class RubyLex
-  include ::RubyToken
-  def Fail(err=T.unsafe(nil), *rest); end
-
-  def Raise(err=T.unsafe(nil), *rest); end
-
-  def char_no(); end
-
-  def each_top_level_statement(); end
-
-  def eof?(); end
-
-  def exception_on_syntax_error(); end
-
-  def exception_on_syntax_error=(exception_on_syntax_error); end
-
-  def get_readed(); end
-
-  def getc(); end
-
-  def getc_of_rests(); end
-
-  def gets(); end
-
-  def identify_comment(); end
-
-  def identify_gvar(); end
-
-  def identify_here_document(); end
-
-  def identify_identifier(); end
-
-  def identify_number(); end
-
-  def identify_quotation(); end
-
-  def identify_string(ltype, quoted=T.unsafe(nil)); end
-
-  def identify_string_dvar(); end
-
-  def indent(); end
-
-  def initialize_input(); end
-
-  def lex(); end
-
-  def lex_init(); end
-
-  def lex_int2(); end
-
-  def line_no(); end
-
-  def peek(i=T.unsafe(nil)); end
-
-  def peek_equal?(str); end
-
-  def peek_match?(regexp); end
-
-  def prompt(); end
-
-  def read_escape(); end
-
-  def readed_auto_clean_up(); end
-
-  def readed_auto_clean_up=(readed_auto_clean_up); end
-
-  def seek(); end
-
-  def set_input(io, p=T.unsafe(nil), &block); end
-
-  def set_prompt(p=T.unsafe(nil), &block); end
-
-  def skip_space(); end
-
-  def skip_space=(skip_space); end
-
-  def token(); end
-
-  def ungetc(c=T.unsafe(nil)); end
-  DEINDENT_CLAUSE = ::T.let(nil, ::T.untyped)
-  DLtype2Token = ::T.let(nil, ::T.untyped)
-  ENINDENT_CLAUSE = ::T.let(nil, ::T.untyped)
-  Ltype2Token = ::T.let(nil, ::T.untyped)
-  PERCENT_LTYPE = ::T.let(nil, ::T.untyped)
-  PERCENT_PAREN = ::T.let(nil, ::T.untyped)
-end
-
-class RubyLex::AlreadyDefinedToken
-end
-
-class RubyLex::AlreadyDefinedToken
-end
-
-class RubyLex::SyntaxError
-end
-
-class RubyLex::SyntaxError
-end
-
-class RubyLex::TerminateLineInput
-end
-
-class RubyLex::TerminateLineInput
-end
-
-class RubyLex::TkReading2TokenDuplicateError
-end
-
-class RubyLex::TkReading2TokenDuplicateError
-end
-
-class RubyLex::TkReading2TokenNoKey
-end
-
-class RubyLex::TkReading2TokenNoKey
-end
-
-class RubyLex::TkSymbol2TokenNoKey
-end
-
-class RubyLex::TkSymbol2TokenNoKey
-end
-
-class RubyLex
-  extend ::Exception2MessageMapper
-  def self.debug?(); end
-
-  def self.debug_level(); end
-
-  def self.debug_level=(debug_level); end
-
-  def self.included(mod); end
-end
-
-module RubyToken
-  def Token(token, value=T.unsafe(nil)); end
-  EXPR_ARG = ::T.let(nil, ::T.untyped)
-  EXPR_BEG = ::T.let(nil, ::T.untyped)
-  EXPR_CLASS = ::T.let(nil, ::T.untyped)
-  EXPR_DOT = ::T.let(nil, ::T.untyped)
-  EXPR_END = ::T.let(nil, ::T.untyped)
-  EXPR_FNAME = ::T.let(nil, ::T.untyped)
-  EXPR_MID = ::T.let(nil, ::T.untyped)
-  TkReading2Token = ::T.let(nil, ::T.untyped)
-  TkSymbol2Token = ::T.let(nil, ::T.untyped)
-  TokenDefinitions = ::T.let(nil, ::T.untyped)
-end
-
-class RubyToken::TkALIAS
-end
-
-class RubyToken::TkALIAS
-end
-
-class RubyToken::TkAMPER
-end
-
-class RubyToken::TkAMPER
-end
-
-class RubyToken::TkAND
-end
-
-class RubyToken::TkAND
-end
-
-class RubyToken::TkANDOP
-end
-
-class RubyToken::TkANDOP
-end
-
-class RubyToken::TkAREF
-end
-
-class RubyToken::TkAREF
-end
-
-class RubyToken::TkASET
-end
-
-class RubyToken::TkASET
-end
-
-class RubyToken::TkASSIGN
-end
-
-class RubyToken::TkASSIGN
-end
-
-class RubyToken::TkASSOC
-end
-
-class RubyToken::TkASSOC
-end
-
-class RubyToken::TkAT
-end
-
-class RubyToken::TkAT
-end
-
-class RubyToken::TkBACKQUOTE
-end
-
-class RubyToken::TkBACKQUOTE
-end
-
-class RubyToken::TkBACKSLASH
-end
-
-class RubyToken::TkBACKSLASH
-end
-
-class RubyToken::TkBACK_REF
-end
-
-class RubyToken::TkBACK_REF
-end
-
-class RubyToken::TkBEGIN
-end
-
-class RubyToken::TkBEGIN
-end
-
-class RubyToken::TkBITAND
-end
-
-class RubyToken::TkBITAND
-end
-
-class RubyToken::TkBITNOT
-end
-
-class RubyToken::TkBITNOT
-end
-
-class RubyToken::TkBITOR
-end
-
-class RubyToken::TkBITOR
-end
-
-class RubyToken::TkBITXOR
-end
-
-class RubyToken::TkBITXOR
-end
-
-class RubyToken::TkBREAK
-end
-
-class RubyToken::TkBREAK
-end
-
-class RubyToken::TkCASE
-end
-
-class RubyToken::TkCASE
-end
-
-class RubyToken::TkCLASS
-end
-
-class RubyToken::TkCLASS
-end
-
-class RubyToken::TkCMP
-end
-
-class RubyToken::TkCMP
-end
-
-class RubyToken::TkCOLON
-end
-
-class RubyToken::TkCOLON
-end
-
-class RubyToken::TkCOLON2
-end
-
-class RubyToken::TkCOLON2
-end
-
-class RubyToken::TkCOLON3
-end
-
-class RubyToken::TkCOLON3
-end
-
-class RubyToken::TkCOMMA
-end
-
-class RubyToken::TkCOMMA
-end
-
-class RubyToken::TkCOMMENT
-end
-
-class RubyToken::TkCOMMENT
-end
-
-class RubyToken::TkCONSTANT
-end
-
-class RubyToken::TkCONSTANT
-end
-
-class RubyToken::TkCVAR
-end
-
-class RubyToken::TkCVAR
-end
-
-class RubyToken::TkDEF
-end
-
-class RubyToken::TkDEF
-end
-
-class RubyToken::TkDEFINED
-end
-
-class RubyToken::TkDEFINED
-end
-
-class RubyToken::TkDIV
-end
-
-class RubyToken::TkDIV
-end
-
-class RubyToken::TkDO
-end
-
-class RubyToken::TkDO
-end
-
-class RubyToken::TkDOLLAR
-end
-
-class RubyToken::TkDOLLAR
-end
-
-class RubyToken::TkDOT
-end
-
-class RubyToken::TkDOT
-end
-
-class RubyToken::TkDOT2
-end
-
-class RubyToken::TkDOT2
-end
-
-class RubyToken::TkDOT3
-end
-
-class RubyToken::TkDOT3
-end
-
-class RubyToken::TkDREGEXP
-end
-
-class RubyToken::TkDREGEXP
-end
-
-class RubyToken::TkDSTRING
-end
-
-class RubyToken::TkDSTRING
-end
-
-class RubyToken::TkDXSTRING
-end
-
-class RubyToken::TkDXSTRING
-end
-
-class RubyToken::TkELSE
-end
-
-class RubyToken::TkELSE
-end
-
-class RubyToken::TkELSIF
-end
-
-class RubyToken::TkELSIF
-end
-
-class RubyToken::TkEND
-end
-
-class RubyToken::TkEND
-end
-
-class RubyToken::TkEND_OF_SCRIPT
-end
-
-class RubyToken::TkEND_OF_SCRIPT
-end
-
-class RubyToken::TkENSURE
-end
-
-class RubyToken::TkENSURE
-end
-
-class RubyToken::TkEQ
-end
-
-class RubyToken::TkEQ
-end
-
-class RubyToken::TkEQQ
-end
-
-class RubyToken::TkEQQ
-end
-
-class RubyToken::TkError
-end
-
-class RubyToken::TkError
-end
-
-class RubyToken::TkFALSE
-end
-
-class RubyToken::TkFALSE
-end
-
-class RubyToken::TkFID
-end
-
-class RubyToken::TkFID
-end
-
-class RubyToken::TkFLOAT
-end
-
-class RubyToken::TkFLOAT
-end
-
-class RubyToken::TkFOR
-end
-
-class RubyToken::TkFOR
-end
-
-class RubyToken::TkGEQ
-end
-
-class RubyToken::TkGEQ
-end
-
-class RubyToken::TkGT
-end
-
-class RubyToken::TkGT
-end
-
-class RubyToken::TkGVAR
-end
-
-class RubyToken::TkGVAR
-end
-
-class RubyToken::TkIDENTIFIER
-end
-
-class RubyToken::TkIDENTIFIER
-end
-
-class RubyToken::TkIF
-end
-
-class RubyToken::TkIF
-end
-
-class RubyToken::TkIF_MOD
-end
-
-class RubyToken::TkIF_MOD
-end
-
-class RubyToken::TkIN
-end
-
-class RubyToken::TkIN
-end
-
-class RubyToken::TkINTEGER
-end
-
-class RubyToken::TkINTEGER
-end
-
-class RubyToken::TkIVAR
-end
-
-class RubyToken::TkIVAR
-end
-
-class RubyToken::TkId
-  def initialize(seek, line_no, char_no, name); end
-
-  def name(); end
-end
-
-class RubyToken::TkId
-end
-
-class RubyToken::TkLBRACE
-end
-
-class RubyToken::TkLBRACE
-end
-
-class RubyToken::TkLBRACK
-end
-
-class RubyToken::TkLBRACK
-end
-
-class RubyToken::TkLEQ
-end
-
-class RubyToken::TkLEQ
-end
-
-class RubyToken::TkLPAREN
-end
-
-class RubyToken::TkLPAREN
-end
-
-class RubyToken::TkLSHFT
-end
-
-class RubyToken::TkLSHFT
-end
-
-class RubyToken::TkLT
-end
-
-class RubyToken::TkLT
-end
-
-class RubyToken::TkMATCH
-end
-
-class RubyToken::TkMATCH
-end
-
-class RubyToken::TkMINUS
-end
-
-class RubyToken::TkMINUS
-end
-
-class RubyToken::TkMOD
-end
-
-class RubyToken::TkMOD
-end
-
-class RubyToken::TkMODULE
-end
-
-class RubyToken::TkMODULE
-end
-
-class RubyToken::TkMULT
-end
-
-class RubyToken::TkMULT
-end
-
-class RubyToken::TkNEQ
-end
-
-class RubyToken::TkNEQ
-end
-
-class RubyToken::TkNEXT
-end
-
-class RubyToken::TkNEXT
-end
-
-class RubyToken::TkNIL
-end
-
-class RubyToken::TkNIL
-end
-
-class RubyToken::TkNL
-end
-
-class RubyToken::TkNL
-end
-
-class RubyToken::TkNMATCH
-end
-
-class RubyToken::TkNMATCH
-end
-
-class RubyToken::TkNOT
-end
-
-class RubyToken::TkNOT
-end
-
-class RubyToken::TkNOTOP
-end
-
-class RubyToken::TkNOTOP
-end
-
-class RubyToken::TkNTH_REF
-end
-
-class RubyToken::TkNTH_REF
-end
-
-class RubyToken::TkNode
-  def node(); end
-end
-
-class RubyToken::TkNode
-end
-
-class RubyToken::TkOPASGN
-  def initialize(seek, line_no, char_no, op); end
-
-  def op(); end
-end
-
-class RubyToken::TkOPASGN
-end
-
-class RubyToken::TkOR
-end
-
-class RubyToken::TkOR
-end
-
-class RubyToken::TkOROP
-end
-
-class RubyToken::TkOROP
-end
-
-class RubyToken::TkOp
-  def name(); end
-
-  def name=(name); end
-end
-
-class RubyToken::TkOp
-end
-
-class RubyToken::TkPLUS
-end
-
-class RubyToken::TkPLUS
-end
-
-class RubyToken::TkPOW
-end
-
-class RubyToken::TkPOW
-end
-
-class RubyToken::TkQUESTION
-end
-
-class RubyToken::TkQUESTION
-end
-
-class RubyToken::TkRBRACE
-end
-
-class RubyToken::TkRBRACE
-end
-
-class RubyToken::TkRBRACK
-end
-
-class RubyToken::TkRBRACK
-end
-
-class RubyToken::TkRD_COMMENT
-end
-
-class RubyToken::TkRD_COMMENT
-end
-
-class RubyToken::TkREDO
-end
-
-class RubyToken::TkREDO
-end
-
-class RubyToken::TkREGEXP
-end
-
-class RubyToken::TkREGEXP
-end
-
-class RubyToken::TkRESCUE
-end
-
-class RubyToken::TkRESCUE
-end
-
-class RubyToken::TkRETRY
-end
-
-class RubyToken::TkRETRY
-end
-
-class RubyToken::TkRETURN
-end
-
-class RubyToken::TkRETURN
-end
-
-class RubyToken::TkRPAREN
-end
-
-class RubyToken::TkRPAREN
-end
-
-class RubyToken::TkRSHFT
-end
-
-class RubyToken::TkRSHFT
-end
-
-class RubyToken::TkSELF
-end
-
-class RubyToken::TkSELF
-end
-
-class RubyToken::TkSEMICOLON
-end
-
-class RubyToken::TkSEMICOLON
-end
-
-class RubyToken::TkSPACE
-end
-
-class RubyToken::TkSPACE
-end
-
-class RubyToken::TkSTAR
-end
-
-class RubyToken::TkSTAR
-end
-
-class RubyToken::TkSTRING
-end
-
-class RubyToken::TkSTRING
-end
-
-class RubyToken::TkSUPER
-end
-
-class RubyToken::TkSUPER
-end
-
-class RubyToken::TkSYMBEG
-end
-
-class RubyToken::TkSYMBEG
-end
-
-class RubyToken::TkSYMBOL
-end
-
-class RubyToken::TkSYMBOL
-end
-
-class RubyToken::TkTHEN
-end
-
-class RubyToken::TkTHEN
-end
-
-class RubyToken::TkTRUE
-end
-
-class RubyToken::TkTRUE
-end
-
-class RubyToken::TkUMINUS
-end
-
-class RubyToken::TkUMINUS
-end
-
-class RubyToken::TkUNDEF
-end
-
-class RubyToken::TkUNDEF
-end
-
-class RubyToken::TkUNLESS
-end
-
-class RubyToken::TkUNLESS
-end
-
-class RubyToken::TkUNLESS_MOD
-end
-
-class RubyToken::TkUNLESS_MOD
-end
-
-class RubyToken::TkUNTIL
-end
-
-class RubyToken::TkUNTIL
-end
-
-class RubyToken::TkUNTIL_MOD
-end
-
-class RubyToken::TkUNTIL_MOD
-end
-
-class RubyToken::TkUPLUS
-end
-
-class RubyToken::TkUPLUS
-end
-
-class RubyToken::TkUnknownChar
-  def initialize(seek, line_no, char_no, id); end
-
-  def name(); end
-end
-
-class RubyToken::TkUnknownChar
-end
-
-class RubyToken::TkVal
-  def initialize(seek, line_no, char_no, value=T.unsafe(nil)); end
-
-  def value(); end
-end
-
-class RubyToken::TkVal
-end
-
-class RubyToken::TkWHEN
-end
-
-class RubyToken::TkWHEN
-end
-
-class RubyToken::TkWHILE
-end
-
-class RubyToken::TkWHILE
-end
-
-class RubyToken::TkWHILE_MOD
-end
-
-class RubyToken::TkWHILE_MOD
-end
-
-class RubyToken::TkXSTRING
-end
-
-class RubyToken::TkXSTRING
-end
-
-class RubyToken::TkYIELD
-end
-
-class RubyToken::TkYIELD
-end
-
-class RubyToken::Tk__FILE__
-end
-
-class RubyToken::Tk__FILE__
-end
-
-class RubyToken::Tk__LINE__
-end
-
-class RubyToken::Tk__LINE__
-end
-
-class RubyToken::TkfLBRACE
-end
-
-class RubyToken::TkfLBRACE
-end
-
-class RubyToken::TkfLBRACK
-end
-
-class RubyToken::TkfLBRACK
-end
-
-class RubyToken::TkfLPAREN
-end
-
-class RubyToken::TkfLPAREN
-end
-
-class RubyToken::TklBEGIN
-end
-
-class RubyToken::TklBEGIN
-end
-
-class RubyToken::TklEND
-end
-
-class RubyToken::TklEND
-end
-
-class RubyToken::Token
-  def char_no(); end
-
-  def initialize(seek, line_no, char_no); end
-
-  def line_no(); end
-
-  def seek(); end
-end
-
-class RubyToken::Token
-end
-
-module RubyToken
-  def self.def_token(token_n, super_token=T.unsafe(nil), reading=T.unsafe(nil), *opts); end
-end
-
-class RubyVM::AbstractSyntaxTree::Node
-  def pretty_print_children(q, names=T.unsafe(nil)); end
-end
-
-module RubyVM::MJIT
-end
-
-module RubyVM::MJIT
-  def self.enabled?(); end
-
-  def self.pause(*arg); end
-
-  def self.resume(); end
-end
-
-class RubyVM
-  def self.resolve_feature_path(arg); end
-end
-
-class Sandbox
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-ScanError = StringScanner::Error
-
-class Set
-  def ==(other); end
-
-  def ===(o); end
-
-  def divide(&func); end
-
-  def eql?(o); end
-
-  def flatten_merge(set, seen=T.unsafe(nil)); end
-
-  def pretty_print(pp); end
-
-  def pretty_print_cycle(pp); end
-
-  def reset(); end
-  InspectKey = ::T.let(nil, ::T.untyped)
-end
-
-module SharedEnvExtension
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class SimpleCov::LinesClassifier
-  NOT_RELEVANT = ::T.let(nil, ::T.untyped)
-end
-
-module Singleton
-  def _dump(depth=T.unsafe(nil)); end
-
-  def clone(); end
-
-  def dup(); end
-end
-
-module Singleton::SingletonClassMethods
-  def _load(str); end
-
-  def clone(); end
-end
-
-module Singleton
-  def self.__init__(klass); end
-end
-
-class Socket
-  AF_CCITT = ::T.let(nil, ::T.untyped)
-  AF_CHAOS = ::T.let(nil, ::T.untyped)
-  AF_CNT = ::T.let(nil, ::T.untyped)
-  AF_COIP = ::T.let(nil, ::T.untyped)
-  AF_DATAKIT = ::T.let(nil, ::T.untyped)
-  AF_DLI = ::T.let(nil, ::T.untyped)
-  AF_E164 = ::T.let(nil, ::T.untyped)
-  AF_ECMA = ::T.let(nil, ::T.untyped)
-  AF_HYLINK = ::T.let(nil, ::T.untyped)
-  AF_IMPLINK = ::T.let(nil, ::T.untyped)
-  AF_ISO = ::T.let(nil, ::T.untyped)
-  AF_LAT = ::T.let(nil, ::T.untyped)
-  AF_LINK = ::T.let(nil, ::T.untyped)
-  AF_NATM = ::T.let(nil, ::T.untyped)
-  AF_NDRV = ::T.let(nil, ::T.untyped)
-  AF_NETBIOS = ::T.let(nil, ::T.untyped)
-  AF_NS = ::T.let(nil, ::T.untyped)
-  AF_OSI = ::T.let(nil, ::T.untyped)
-  AF_PPP = ::T.let(nil, ::T.untyped)
-  AF_PUP = ::T.let(nil, ::T.untyped)
-  AF_SIP = ::T.let(nil, ::T.untyped)
-  AF_SYSTEM = ::T.let(nil, ::T.untyped)
-  AI_DEFAULT = ::T.let(nil, ::T.untyped)
-  AI_MASK = ::T.let(nil, ::T.untyped)
-  AI_V4MAPPED_CFG = ::T.let(nil, ::T.untyped)
-  EAI_BADHINTS = ::T.let(nil, ::T.untyped)
-  EAI_MAX = ::T.let(nil, ::T.untyped)
-  EAI_PROTOCOL = ::T.let(nil, ::T.untyped)
-  IFF_ALTPHYS = ::T.let(nil, ::T.untyped)
-  IFF_LINK0 = ::T.let(nil, ::T.untyped)
-  IFF_LINK1 = ::T.let(nil, ::T.untyped)
-  IFF_LINK2 = ::T.let(nil, ::T.untyped)
-  IFF_OACTIVE = ::T.let(nil, ::T.untyped)
-  IFF_SIMPLEX = ::T.let(nil, ::T.untyped)
-  IPPROTO_EON = ::T.let(nil, ::T.untyped)
-  IPPROTO_GGP = ::T.let(nil, ::T.untyped)
-  IPPROTO_HELLO = ::T.let(nil, ::T.untyped)
-  IPPROTO_MAX = ::T.let(nil, ::T.untyped)
-  IPPROTO_ND = ::T.let(nil, ::T.untyped)
-  IPPROTO_XTP = ::T.let(nil, ::T.untyped)
-  IPV6_DONTFRAG = ::T.let(nil, ::T.untyped)
-  IPV6_PATHMTU = ::T.let(nil, ::T.untyped)
-  IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped)
-  IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped)
-  IP_PORTRANGE = ::T.let(nil, ::T.untyped)
-  IP_RECVDSTADDR = ::T.let(nil, ::T.untyped)
-  IP_RECVIF = ::T.let(nil, ::T.untyped)
-  LOCAL_PEERCRED = ::T.let(nil, ::T.untyped)
-  MSG_EOF = ::T.let(nil, ::T.untyped)
-  MSG_FLUSH = ::T.let(nil, ::T.untyped)
-  MSG_HAVEMORE = ::T.let(nil, ::T.untyped)
-  MSG_HOLD = ::T.let(nil, ::T.untyped)
-  MSG_RCVMORE = ::T.let(nil, ::T.untyped)
-  MSG_SEND = ::T.let(nil, ::T.untyped)
-  PF_CCITT = ::T.let(nil, ::T.untyped)
-  PF_CHAOS = ::T.let(nil, ::T.untyped)
-  PF_CNT = ::T.let(nil, ::T.untyped)
-  PF_COIP = ::T.let(nil, ::T.untyped)
-  PF_DATAKIT = ::T.let(nil, ::T.untyped)
-  PF_DLI = ::T.let(nil, ::T.untyped)
-  PF_ECMA = ::T.let(nil, ::T.untyped)
-  PF_HYLINK = ::T.let(nil, ::T.untyped)
-  PF_IMPLINK = ::T.let(nil, ::T.untyped)
-  PF_ISO = ::T.let(nil, ::T.untyped)
-  PF_LAT = ::T.let(nil, ::T.untyped)
-  PF_LINK = ::T.let(nil, ::T.untyped)
-  PF_NATM = ::T.let(nil, ::T.untyped)
-  PF_NDRV = ::T.let(nil, ::T.untyped)
-  PF_NETBIOS = ::T.let(nil, ::T.untyped)
-  PF_NS = ::T.let(nil, ::T.untyped)
-  PF_OSI = ::T.let(nil, ::T.untyped)
-  PF_PIP = ::T.let(nil, ::T.untyped)
-  PF_PPP = ::T.let(nil, ::T.untyped)
-  PF_PUP = ::T.let(nil, ::T.untyped)
-  PF_RTIP = ::T.let(nil, ::T.untyped)
-  PF_SIP = ::T.let(nil, ::T.untyped)
-  PF_SYSTEM = ::T.let(nil, ::T.untyped)
-  PF_XTP = ::T.let(nil, ::T.untyped)
-  SCM_CREDS = ::T.let(nil, ::T.untyped)
-  SO_DONTTRUNC = ::T.let(nil, ::T.untyped)
-  SO_NKE = ::T.let(nil, ::T.untyped)
-  SO_NOSIGPIPE = ::T.let(nil, ::T.untyped)
-  SO_NREAD = ::T.let(nil, ::T.untyped)
-  SO_USELOOPBACK = ::T.let(nil, ::T.untyped)
-  SO_WANTMORE = ::T.let(nil, ::T.untyped)
-  SO_WANTOOBFLAG = ::T.let(nil, ::T.untyped)
-  TCP_NOOPT = ::T.let(nil, ::T.untyped)
-  TCP_NOPUSH = ::T.let(nil, ::T.untyped)
-end
-
-module Socket::Constants
-  AF_CCITT = ::T.let(nil, ::T.untyped)
-  AF_CHAOS = ::T.let(nil, ::T.untyped)
-  AF_CNT = ::T.let(nil, ::T.untyped)
-  AF_COIP = ::T.let(nil, ::T.untyped)
-  AF_DATAKIT = ::T.let(nil, ::T.untyped)
-  AF_DLI = ::T.let(nil, ::T.untyped)
-  AF_E164 = ::T.let(nil, ::T.untyped)
-  AF_ECMA = ::T.let(nil, ::T.untyped)
-  AF_HYLINK = ::T.let(nil, ::T.untyped)
-  AF_IMPLINK = ::T.let(nil, ::T.untyped)
-  AF_ISO = ::T.let(nil, ::T.untyped)
-  AF_LAT = ::T.let(nil, ::T.untyped)
-  AF_LINK = ::T.let(nil, ::T.untyped)
-  AF_NATM = ::T.let(nil, ::T.untyped)
-  AF_NDRV = ::T.let(nil, ::T.untyped)
-  AF_NETBIOS = ::T.let(nil, ::T.untyped)
-  AF_NS = ::T.let(nil, ::T.untyped)
-  AF_OSI = ::T.let(nil, ::T.untyped)
-  AF_PPP = ::T.let(nil, ::T.untyped)
-  AF_PUP = ::T.let(nil, ::T.untyped)
-  AF_SIP = ::T.let(nil, ::T.untyped)
-  AF_SYSTEM = ::T.let(nil, ::T.untyped)
-  AI_DEFAULT = ::T.let(nil, ::T.untyped)
-  AI_MASK = ::T.let(nil, ::T.untyped)
-  AI_V4MAPPED_CFG = ::T.let(nil, ::T.untyped)
-  EAI_BADHINTS = ::T.let(nil, ::T.untyped)
-  EAI_MAX = ::T.let(nil, ::T.untyped)
-  EAI_PROTOCOL = ::T.let(nil, ::T.untyped)
-  IFF_ALTPHYS = ::T.let(nil, ::T.untyped)
-  IFF_LINK0 = ::T.let(nil, ::T.untyped)
-  IFF_LINK1 = ::T.let(nil, ::T.untyped)
-  IFF_LINK2 = ::T.let(nil, ::T.untyped)
-  IFF_OACTIVE = ::T.let(nil, ::T.untyped)
-  IFF_SIMPLEX = ::T.let(nil, ::T.untyped)
-  IPPROTO_EON = ::T.let(nil, ::T.untyped)
-  IPPROTO_GGP = ::T.let(nil, ::T.untyped)
-  IPPROTO_HELLO = ::T.let(nil, ::T.untyped)
-  IPPROTO_MAX = ::T.let(nil, ::T.untyped)
-  IPPROTO_ND = ::T.let(nil, ::T.untyped)
-  IPPROTO_XTP = ::T.let(nil, ::T.untyped)
-  IPV6_DONTFRAG = ::T.let(nil, ::T.untyped)
-  IPV6_PATHMTU = ::T.let(nil, ::T.untyped)
-  IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped)
-  IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped)
-  IP_PORTRANGE = ::T.let(nil, ::T.untyped)
-  IP_RECVDSTADDR = ::T.let(nil, ::T.untyped)
-  IP_RECVIF = ::T.let(nil, ::T.untyped)
-  LOCAL_PEERCRED = ::T.let(nil, ::T.untyped)
-  MSG_EOF = ::T.let(nil, ::T.untyped)
-  MSG_FLUSH = ::T.let(nil, ::T.untyped)
-  MSG_HAVEMORE = ::T.let(nil, ::T.untyped)
-  MSG_HOLD = ::T.let(nil, ::T.untyped)
-  MSG_RCVMORE = ::T.let(nil, ::T.untyped)
-  MSG_SEND = ::T.let(nil, ::T.untyped)
-  PF_CCITT = ::T.let(nil, ::T.untyped)
-  PF_CHAOS = ::T.let(nil, ::T.untyped)
-  PF_CNT = ::T.let(nil, ::T.untyped)
-  PF_COIP = ::T.let(nil, ::T.untyped)
-  PF_DATAKIT = ::T.let(nil, ::T.untyped)
-  PF_DLI = ::T.let(nil, ::T.untyped)
-  PF_ECMA = ::T.let(nil, ::T.untyped)
-  PF_HYLINK = ::T.let(nil, ::T.untyped)
-  PF_IMPLINK = ::T.let(nil, ::T.untyped)
-  PF_ISO = ::T.let(nil, ::T.untyped)
-  PF_LAT = ::T.let(nil, ::T.untyped)
-  PF_LINK = ::T.let(nil, ::T.untyped)
-  PF_NATM = ::T.let(nil, ::T.untyped)
-  PF_NDRV = ::T.let(nil, ::T.untyped)
-  PF_NETBIOS = ::T.let(nil, ::T.untyped)
-  PF_NS = ::T.let(nil, ::T.untyped)
-  PF_OSI = ::T.let(nil, ::T.untyped)
-  PF_PIP = ::T.let(nil, ::T.untyped)
-  PF_PPP = ::T.let(nil, ::T.untyped)
-  PF_PUP = ::T.let(nil, ::T.untyped)
-  PF_RTIP = ::T.let(nil, ::T.untyped)
-  PF_SIP = ::T.let(nil, ::T.untyped)
-  PF_SYSTEM = ::T.let(nil, ::T.untyped)
-  PF_XTP = ::T.let(nil, ::T.untyped)
-  SCM_CREDS = ::T.let(nil, ::T.untyped)
-  SO_DONTTRUNC = ::T.let(nil, ::T.untyped)
-  SO_NKE = ::T.let(nil, ::T.untyped)
-  SO_NOSIGPIPE = ::T.let(nil, ::T.untyped)
-  SO_NREAD = ::T.let(nil, ::T.untyped)
-  SO_USELOOPBACK = ::T.let(nil, ::T.untyped)
-  SO_WANTMORE = ::T.let(nil, ::T.untyped)
-  SO_WANTOOBFLAG = ::T.let(nil, ::T.untyped)
-  TCP_NOOPT = ::T.let(nil, ::T.untyped)
-  TCP_NOPUSH = ::T.let(nil, ::T.untyped)
-end
-
-class Spoom::Cli::Bump
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Cli::Helper
-  HIGHLIGHT_COLOR = ::T.let(nil, ::T.untyped)
-end
-
-module Spoom::Cli::Helper
-  extend ::T::Sig
-  extend ::T::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Cli::Main
-  extend ::T::Sig
-end
-
-module Spoom::Colorize
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Coverage::D3::Base
-  extend ::T::Sig
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Coverage::D3
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Coverage::Snapshot
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Coverage::Template
-  extend ::T::Sig
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Coverage
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::FileTree::Node
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::FileTree
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Git
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Client
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Diagnostic
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::DocumentSymbol
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Error::Diagnostics
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Hover
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Location
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Message
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Position
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::LSP::PrintableSymbol
-  extend ::T::Sig
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Range
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::ResponseError
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::SignatureHelp
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Printer
-  extend ::T::Sig
-  extend ::T::Helpers
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Sorbet::Config
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Sorbet::Errors::Error
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Sorbet::Errors::Parser
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Sorbet::Errors
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Sorbet::MetricsParser
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Sorbet::Sigils
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Sorbet
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Timeline
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class String
-  def exclude?(string); end
-
-  def fast_xs(); end
-
-  def indent(amount, indent_string=T.unsafe(nil), indent_empty_lines=T.unsafe(nil)); end
-
-  def indent!(amount, indent_string=T.unsafe(nil), indent_empty_lines=T.unsafe(nil)); end
-
-  def shellescape(); end
-
-  def shellsplit(); end
-
-  def to_nfc(); end
-
-  def to_nfd(); end
-
-  def to_nfkc(); end
-
-  def to_nfkd(); end
-end
-
-class String
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class StringInreplaceExtension
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class StringScanner
-  def bol?(); end
-
-  def initialize(*arg); end
-  Id = ::T.let(nil, ::T.untyped)
-  Version = ::T.let(nil, ::T.untyped)
-end
-
-class Struct
-  def filter(*arg); end
-end
-
-class Symbol
-  def to_msgpack_ext(); end
-end
-
-class SystemCommand::Result
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class SystemCommand
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Tab
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Tap
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Tapioca
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Tempfile
-  def _close(); end
-end
-
-class Tempfile::Remover
-  def call(*args); end
-
-  def initialize(tmpfile); end
-end
-
-class Tempfile::Remover
-end
-
-class Time
-  def compare_without_coercion(arg); end
-
-  def eql_without_coercion(arg); end
-
-  def minus_without_duration(arg); end
-
-  def plus_without_duration(arg); end
-
-  def rfc3339(fraction_digits=T.unsafe(nil)); end
-
-  def to_default_s(); end
-end
-
-class Time
-  def self.at_without_coercion(*arg); end
-end
-
-class TracePoint
-  def __enable(arg, arg1); end
-
-  def eval_script(); end
-
-  def instruction_sequence(); end
-
-  def parameters(); end
-end
-
-module Tty
-  extend ::T::Private::Methods::SingletonMethodHooks
-  def self.blue(); end
-
-  def self.bold(); end
-
-  def self.cyan(); end
-
-  def self.default(); end
-
-  def self.down(); end
-
-  def self.erase_char(); end
-
-  def self.erase_line(); end
-
-  def self.green(); end
-
-  def self.italic(); end
-
-  def self.left(); end
-
-  def self.magenta(); end
-
-  def self.no_underline(); end
-
-  def self.red(); end
-
-  def self.reset(); end
-
-  def self.right(); end
-
-  def self.strikethrough(); end
-
-  def self.underline(); end
-
-  def self.up(); end
-
-  def self.yellow(); end
-end
-
-module URI
-  include ::URI::RFC2396_REGEXP
-end
-
-class URI::FTP
-  def buffer_open(buf, proxy, options); end
-end
-
-class URI::FTP
-  def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end
-end
-
-class URI::File
-  def check_password(user); end
-
-  def check_user(user); end
-
-  def check_userinfo(user); end
-
-  def set_userinfo(v); end
-  COMPONENT = ::T.let(nil, ::T.untyped)
-  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
-end
-
-class URI::File
-end
-
-class URI::HTTP
-  def buffer_open(buf, proxy, options); end
-end
-
-class URI::LDAP
-  def attributes(); end
-
-  def attributes=(val); end
-
-  def dn(); end
-
-  def dn=(val); end
-
-  def extensions(); end
-
-  def extensions=(val); end
-
-  def filter(); end
-
-  def filter=(val); end
-
-  def initialize(*arg); end
-
-  def scope(); end
-
-  def scope=(val); end
-
-  def set_attributes(val); end
-
-  def set_dn(val); end
-
-  def set_extensions(val); end
-
-  def set_filter(val); end
-
-  def set_scope(val); end
-end
-
-class URI::MailTo
-  def initialize(*arg); end
-end
-
-URI::Parser = URI::RFC2396_Parser
-
-URI::REGEXP = URI::RFC2396_REGEXP
-
-class URI::RFC2396_Parser
-  def initialize(opts=T.unsafe(nil)); end
-end
-
-class URI::RFC3986_Parser
-  def join(*uris); end
-
-  def parse(uri); end
-
-  def regexp(); end
-
-  def split(uri); end
-  RFC3986_relative_ref = ::T.let(nil, ::T.untyped)
-end
-
-module URI::Util
-  def self.make_components_hash(klass, array_hash); end
-end
-
-module URI
-  extend ::URI::Escape
-  def self.get_encoding(label); end
-end
-
-class URITemplate::RFC6570::Expression::PathParameters
-  PAIR_IF_EMPTY = ::T.let(nil, ::T.untyped)
-end
-
-class UnboundMethod
-  include ::MethodSource::SourceLocation::UnboundMethodExtensions
-  include ::MethodSource::MethodExtensions
-end
-
-module UnicodeNormalize
-end
-
-module UnicodeNormalize
-end
-
-class UnpackStrategy::Air
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Bzip2
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Cab
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Directory
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Dmg
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Fossil
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::GenericUnar
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Gzip
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Lha
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Lzip
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Lzma
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::P7Zip
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Pax
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Rar
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Tar
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Uncompressed
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Xar
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Xz
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Zip
-  include ::UnpackStrategy::Zip::MacOSZipExtension
-end
-
-module UnpackStrategy::Zip::MacOSZipExtension
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Zip
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class UnpackStrategy::Zstd
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module UnpackStrategy
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class User
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Utils::AST::FormulaAST
-  def process(*args, &block); end
-end
-
-class Utils::AST::FormulaAST
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Utils::AST
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Utils::Analytics
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Utils::Bottles::Collector
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Utils::Bottles::Tag
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Utils::Bottles::TagSpecification
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Utils::Curl
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Utils::Inreplace
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Utils::Shebang::RewriteInfo
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Utils::Shebang
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Utils::Shell
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Utils::Svn
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Utils::TopologicalHash
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Utils
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Version::Parser
-  def initialize(*args, &blk); end
-end
-
-class Version::Parser
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Version::Token
-  extend ::T::Private::Abstract::Hooks
-  extend ::T::InterfaceWrapper::Helpers
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Version
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class WeakRef
-  def initialize(orig); end
-end
-
-class WebRobots
-  def allowed?(url); end
-
-  def crawl_delay(url); end
-
-  def create_cache(); end
-
-  def disallowed?(url); end
-
-  def error(url); end
-
-  def error!(url); end
-
-  def flush_cache(); end
-
-  def initialize(user_agent, options=T.unsafe(nil)); end
-
-  def option(url, token); end
-
-  def options(url); end
-
-  def reset(url); end
-
-  def sitemaps(url); end
-
-  def user_agent(); end
-end
-
-class WebRobots::Error
-end
-
-class WebRobots::Error
-end
-
-class WebRobots::ParseError
-  def initialize(message, site); end
-
-  def site(); end
-end
-
-class WebRobots::ParseError
-end
-
-class WebRobots::RobotsTxt
-  def allow?(request_uri, user_agent=T.unsafe(nil)); end
-
-  def crawl_delay(user_agent=T.unsafe(nil)); end
-
-  def error(); end
-
-  def error!(); end
-
-  def error=(error); end
-
-  def initialize(site, records, options=T.unsafe(nil)); end
-
-  def options(user_agent=T.unsafe(nil)); end
-
-  def site(); end
-
-  def sitemaps(); end
-
-  def timestamp(); end
-  DISALLOW_ALL = ::T.let(nil, ::T.untyped)
-end
-
-class WebRobots::RobotsTxt::AccessControlLine
-  def match?(request_uri); end
-end
-
-class WebRobots::RobotsTxt::AccessControlLine
-end
-
-class WebRobots::RobotsTxt::AgentLine
-  def pattern(); end
-end
-
-class WebRobots::RobotsTxt::AgentLine
-end
-
-class WebRobots::RobotsTxt::AllowLine
-  def allow?(); end
-end
-
-class WebRobots::RobotsTxt::AllowLine
-end
-
-class WebRobots::RobotsTxt::CrawlDelayLine
-  def delay(); end
-end
-
-class WebRobots::RobotsTxt::CrawlDelayLine
-end
-
-class WebRobots::RobotsTxt::DisallowLine
-  def allow?(); end
-end
-
-class WebRobots::RobotsTxt::DisallowLine
-end
-
-class WebRobots::RobotsTxt::ExtentionLine
-end
-
-class WebRobots::RobotsTxt::ExtentionLine
-end
-
-class WebRobots::RobotsTxt::Line
-  def compile(); end
-
-  def initialize(token, value); end
-
-  def token(); end
-
-  def value(); end
-end
-
-class WebRobots::RobotsTxt::Line
-end
-
-class WebRobots::RobotsTxt::Parser
-  def _reduce_1(val, _values, result); end
-
-  def _reduce_17(val, _values, result); end
-
-  def _reduce_18(val, _values, result); end
-
-  def _reduce_19(val, _values, result); end
-
-  def _reduce_2(val, _values, result); end
-
-  def _reduce_20(val, _values, result); end
-
-  def _reduce_21(val, _values, result); end
-
-  def _reduce_24(val, _values, result); end
-
-  def _reduce_25(val, _values, result); end
-
-  def _reduce_26(val, _values, result); end
-
-  def _reduce_28(val, _values, result); end
-
-  def _reduce_31(val, _values, result); end
-
-  def _reduce_32(val, _values, result); end
-
-  def _reduce_38(val, _values, result); end
-
-  def _reduce_39(val, _values, result); end
-
-  def _reduce_40(val, _values, result); end
-
-  def _reduce_41(val, _values, result); end
-
-  def _reduce_none(val, _values, result); end
-
-  def initialize(target, crawl_delay_handler=T.unsafe(nil)); end
-
-  def on_error(token_id, value, stack); end
-
-  def parse(input, site); end
-
-  def parse!(input, site); end
-
-  def parse_error(message); end
-  KNOWN_TOKENS = ::T.let(nil, ::T.untyped)
-  RE_KNOWN_TOKENS = ::T.let(nil, ::T.untyped)
-  Racc_arg = ::T.let(nil, ::T.untyped)
-  Racc_debug_parser = ::T.let(nil, ::T.untyped)
-  Racc_token_to_s_table = ::T.let(nil, ::T.untyped)
-end
-
-class WebRobots::RobotsTxt::Parser
-end
-
-class WebRobots::RobotsTxt::Record
-  def allow?(request_uri); end
-
-  def default?(); end
-
-  def delay(); end
-
-  def initialize(agentlines, rulelines); end
-
-  def match?(user_agent); end
-
-  def options(); end
-end
-
-class WebRobots::RobotsTxt::Record
-end
-
-class WebRobots::RobotsTxt
-  def self.unfetchable(site, reason, target=T.unsafe(nil)); end
-end
-
-class WebRobots
-end
-
-module Webrobots
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-module Webrobots
-end
-
-module YARDSorbet::Directives
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class YARDSorbet::Handlers::AbstractDSLHandler
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class YARDSorbet::Handlers::EnumsHandler
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class YARDSorbet::Handlers::IncludeHandler
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class YARDSorbet::Handlers::MixesInClassMethodsHandler
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class YARDSorbet::Handlers::SigHandler
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module YARDSorbet::Handlers::StructClassHandler
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class YARDSorbet::Handlers::StructPropHandler
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module YARDSorbet::NodeUtils
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module YARDSorbet::SigToYARD
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module YARDSorbet::TagUtils
-  extend ::T::Sig
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Zlib::Deflate
-  def initialize(*arg); end
-end
-
-class Zlib::GzipReader
-  def initialize(*arg); end
-end
-
-class Zlib::GzipWriter
-  def initialize(*arg); end
-end
-
-class Zlib::Inflate
-  def initialize(*arg); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/parlour.rbi b/Library/Homebrew/sorbet/rbi/parlour.rbi
deleted file mode 100644
index df1375eeee1df..0000000000000
--- a/Library/Homebrew/sorbet/rbi/parlour.rbi
+++ /dev/null
@@ -1,176 +0,0 @@
-# typed: strict
-module Homebrew
-  class Cleanup
-    sig { returns(T::Boolean) }
-    def dry_run?; end
-
-    sig { returns(T::Boolean) }
-    def scrub?; end
-
-    sig { returns(T::Boolean) }
-    def prune?; end
-  end
-end
-
-module Debrew
-  sig { returns(T::Boolean) }
-  def self.active?; end
-end
-
-class Formula
-  sig { params(arg: T.untyped).returns(T.untyped) }
-  def self.desc(arg = T.unsafe(nil)); end
-
-  sig { params(arg: T.untyped).returns(T.untyped) }
-  def self.homepage(arg = T.unsafe(nil)); end
-
-  sig { params(arg: T.untyped).returns(T.untyped) }
-  def self.revision(arg = T.unsafe(nil)); end
-
-  sig { params(arg: T.untyped).returns(T.untyped) }
-  def self.version_scheme(arg = T.unsafe(nil)); end
-end
-
-class FormulaInstaller
-  sig { returns(T::Boolean) }
-  def installed_as_dependency?; end
-
-  sig { returns(T::Boolean) }
-  def installed_on_request?; end
-
-  sig { returns(T::Boolean) }
-  def show_summary_heading?; end
-
-  sig { returns(T::Boolean) }
-  def show_header?; end
-
-  sig { returns(T::Boolean) }
-  def force_bottle?; end
-
-  sig { returns(T::Boolean) }
-  def ignore_deps?; end
-
-  sig { returns(T::Boolean) }
-  def only_deps?; end
-
-  sig { returns(T::Boolean) }
-  def interactive?; end
-
-  sig { returns(T::Boolean) }
-  def git?; end
-
-  sig { returns(T::Boolean) }
-  def force?; end
-
-  sig { returns(T::Boolean) }
-  def overwrite?; end
-
-  sig { returns(T::Boolean) }
-  def keep_tmp?; end
-
-  sig { returns(T::Boolean) }
-  def verbose?; end
-
-  sig { returns(T::Boolean) }
-  def debug?; end
-
-  sig { returns(T::Boolean) }
-  def quiet?; end
-
-  sig { returns(T::Boolean) }
-  def hold_locks?; end
-end
-
-class Requirement
-  sig { params(arg: T.untyped).returns(T.untyped) }
-  def self.fatal(arg = T.unsafe(nil)); end
-
-  sig { params(arg: T.untyped).returns(T.untyped) }
-  def self.cask(arg = T.unsafe(nil)); end
-
-  sig { params(arg: T.untyped).returns(T.untyped) }
-  def self.download(arg = T.unsafe(nil)); end
-end
-
-class BottleSpecification
-  sig { params(arg: T.untyped).returns(T.untyped) }
-  def rebuild(arg = T.unsafe(nil)); end
-end
-
-class SystemCommand
-  sig { returns(T::Boolean) }
-  def sudo?; end
-
-  sig { returns(T::Boolean) }
-  def print_stdout?; end
-
-  sig { returns(T::Boolean) }
-  def print_stderr?; end
-
-  sig { returns(T::Boolean) }
-  def must_succeed?; end
-end
-
-module Cask
-  class Audit
-    sig { returns(T::Boolean) }
-    def appcast?; end
-
-    sig { returns(T::Boolean) }
-    def new_cask?; end
-
-    sig { returns(T::Boolean) }
-    def strict?; end
-
-    sig { returns(T::Boolean) }
-    def online?; end
-
-    sig { returns(T::Boolean) }
-    def token_conflicts?; end
-  end
-
-  class Installer
-    sig { returns(T::Boolean) }
-    def binaries?; end
-
-    sig { returns(T::Boolean) }
-    def force?; end
-
-    sig { returns(T::Boolean) }
-    def skip_cask_deps?; end
-
-    sig { returns(T::Boolean) }
-    def require_sha?; end
-
-    sig { returns(T::Boolean) }
-    def reinstall?; end
-
-    sig { returns(T::Boolean) }
-    def upgrade?; end
-
-    sig { returns(T::Boolean) }
-    def verbose?; end
-
-    sig { returns(T::Boolean) }
-    def zap?; end
-
-    sig { returns(T::Boolean) }
-    def installed_as_dependency?; end
-
-    sig { returns(T::Boolean) }
-    def quarantine?; end
-
-    sig { returns(T::Boolean) }
-    def quiet?; end
-  end
-
-  class DSL
-    class Caveats < Base
-      sig { returns(T::Boolean) }
-      def discontinued?; end
-    end
-
-    sig { returns(T::Boolean) }
-    def on_system_blocks_exist?; end
-  end
-end
diff --git a/Library/Homebrew/sorbet/rbi/todo.rbi b/Library/Homebrew/sorbet/rbi/todo.rbi
deleted file mode 100644
index 405a1f33e4f61..0000000000000
--- a/Library/Homebrew/sorbet/rbi/todo.rbi
+++ /dev/null
@@ -1,9 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi todo
-
-# typed: strong
-module ::StackProf; end
-module T::InterfaceWrapper::Helpers; end
-module T::Private::Abstract::Hooks; end
-module T::Private::Methods::MethodHooks; end
-module T::Private::Methods::SingletonMethodHooks; end
diff --git a/Library/Homebrew/sorbet/rbi/upstream.rbi b/Library/Homebrew/sorbet/rbi/upstream.rbi
index dbade1d0dc1fe..a00487f95aced 100644
--- a/Library/Homebrew/sorbet/rbi/upstream.rbi
+++ b/Library/Homebrew/sorbet/rbi/upstream.rbi
@@ -2,22 +2,3 @@
 
 # This file contains temporary definitions for fixes that have
 # been submitted upstream to https://github.com/sorbet/sorbet.
-
-class Module
-  # https://github.com/sorbet/sorbet/pull/3732
-  sig do
-    params(
-        arg0: T.any(Symbol, String),
-        arg1: T.any(Proc, Method, UnboundMethod)
-    )
-    .returns(Symbol)
-  end
-  sig do
-    params(
-        arg0: T.any(Symbol, String),
-        blk: T.proc.bind(T.untyped).returns(T.untyped),
-    )
-    .returns(Symbol)
-  end
-  def define_method(arg0, arg1=T.unsafe(nil), &blk); end
-end
diff --git a/Library/Homebrew/sorbet/tapioca/compilers/args.rb b/Library/Homebrew/sorbet/tapioca/compilers/args.rb
new file mode 100644
index 0000000000000..b3ad828b483d2
--- /dev/null
+++ b/Library/Homebrew/sorbet/tapioca/compilers/args.rb
@@ -0,0 +1,80 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../../../global"
+require "cli/parser"
+
+module Tapioca
+  module Compilers
+    class Args < Tapioca::Dsl::Compiler
+      GLOBAL_OPTIONS = T.let(
+        Homebrew::CLI::Parser.global_options.map do |short_option, long_option, _|
+          [short_option, long_option].map { "#{Homebrew::CLI::Parser.option_to_name(_1)}?" }
+        end.flatten.freeze, T::Array[String]
+      )
+
+      Parsable = T.type_alias { T.any(T.class_of(Homebrew::CLI::Args), T.class_of(Homebrew::AbstractCommand)) }
+      ConstantType = type_member { { fixed: Parsable } }
+      sig { override.returns(T::Enumerable[Parsable]) }
+      def self.gather_constants
+        # require all the commands to ensure the command subclasses are defined
+        ["cmd", "dev-cmd"].each do |dir|
+          Dir[File.join(__dir__, "../../../#{dir}", "*.rb")].each { require(_1) }
+        end
+        Homebrew::AbstractCommand.subclasses
+      end
+
+      sig { override.void }
+      def decorate
+        cmd = T.cast(constant, T.class_of(Homebrew::AbstractCommand))
+        # This is a dummy class to make the `brew` command parsable
+        return if cmd == Homebrew::Cmd::Brew
+
+        args_class_name = T.must(T.must(cmd.args_class).name)
+        root.create_class(args_class_name, superclass_name: "Homebrew::CLI::Args") do |klass|
+          create_args_methods(klass, cmd.parser)
+        end
+        root.create_path(constant) do |klass|
+          klass.create_method("args", return_type: args_class_name)
+        end
+      end
+
+      sig { params(parser: Homebrew::CLI::Parser).returns(T::Hash[Symbol, T.untyped]) }
+      def args_table(parser)
+        # we exclude non-args from the table, such as :named and :remaining
+        parser.instance_variable_get(:@args).instance_variable_get(:@table).except(:named, :remaining)
+      end
+
+      sig { params(parser: Homebrew::CLI::Parser).returns(T::Array[Symbol]) }
+      def comma_arrays(parser)
+        parser.instance_variable_get(:@non_global_processed_options)
+              .filter_map { |k, v| parser.option_to_name(k).to_sym if v == :comma_array }
+      end
+
+      sig { params(method_name: Symbol, value: T.untyped, comma_array_methods: T::Array[Symbol]).returns(String) }
+      def get_return_type(method_name, value, comma_array_methods)
+        if comma_array_methods.include?(method_name)
+          "T.nilable(T::Array[String])"
+        elsif [true, false].include?(value)
+          "T::Boolean"
+        else
+          "T.nilable(String)"
+        end
+      end
+
+      private
+
+      sig { params(klass: RBI::Scope, parser: Homebrew::CLI::Parser).void }
+      def create_args_methods(klass, parser)
+        comma_array_methods = comma_arrays(parser)
+        args_table(parser).each do |method_name, value|
+          method_name_str = method_name.to_s
+          next if GLOBAL_OPTIONS.include?(method_name_str)
+
+          return_type = get_return_type(method_name, value, comma_array_methods)
+          klass.create_method(method_name_str, return_type:)
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/sorbet/tapioca/compilers/attrables.rb b/Library/Homebrew/sorbet/tapioca/compilers/attrables.rb
new file mode 100644
index 0000000000000..a1ae0740f7eaa
--- /dev/null
+++ b/Library/Homebrew/sorbet/tapioca/compilers/attrables.rb
@@ -0,0 +1,53 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../../../global"
+require "sorbet/tapioca/utils"
+require "debrew"
+
+module Tapioca
+  module Compilers
+    class Attrables < Tapioca::Dsl::Compiler
+      ATTRABLE_FILENAME = "attrable.rb"
+      ConstantType = type_member { { fixed: Module } }
+
+      sig { override.returns(T::Enumerable[Module]) }
+      def self.gather_constants = Homebrew::Tapioca::Utils.named_objects_with_module(Attrable)
+
+      sig { override.void }
+      def decorate
+        root.create_path(constant) do |klass|
+          Homebrew::Tapioca::Utils.methods_from_file(constant, ATTRABLE_FILENAME)
+                                  .each { |method| compile_attrable_method(klass, method) }
+          Homebrew::Tapioca::Utils.methods_from_file(constant, ATTRABLE_FILENAME, class_methods: true)
+                                  .each { |method| compile_attrable_method(klass, method, class_method: true) }
+        end
+      end
+
+      private
+
+      sig { params(klass: RBI::Scope, method: T.any(Method, UnboundMethod), class_method: T::Boolean).void }
+      def compile_attrable_method(klass, method, class_method: false)
+        case method.arity
+        when -1
+          # attr_rw
+          klass.create_method(
+            method.name.to_s,
+            parameters:   [create_opt_param("arg", type: "T.untyped", default: "nil")],
+            return_type:  "T.untyped",
+            class_method:,
+          )
+        when 0
+          # attr_predicate
+          klass.create_method(
+            method.name.to_s,
+            return_type:  "T::Boolean",
+            class_method:,
+          )
+        else
+          raise "Unsupported arity for method #{method.name} - did `Attrable` change?"
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/sorbet/tapioca/compilers/delegators.rb b/Library/Homebrew/sorbet/tapioca/compilers/delegators.rb
new file mode 100644
index 0000000000000..681d7fcc3d5d8
--- /dev/null
+++ b/Library/Homebrew/sorbet/tapioca/compilers/delegators.rb
@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../../../global"
+require "cask/url"
+
+module Tapioca
+  module Compilers
+    # A compiler for subclasses of Delegator.
+    # To add a new delegator: require it above add add it to the DELEGATIONS hash below.
+    class Delegators < Tapioca::Dsl::Compiler
+      # Mapping of delegator classes to the classes they delegate to (as defined in `__getobj__`).
+      DELEGATIONS = T.let({
+        Cask::URL => Cask::URL::DSL,
+      }.freeze, T::Hash[Module, Module])
+      ConstantType = type_member { { fixed: Module } }
+
+      sig { override.returns(T::Enumerable[Module]) }
+      def self.gather_constants = DELEGATIONS.keys
+
+      sig { override.void }
+      def decorate
+        root.create_path(constant) do |klass|
+          # Note that `Delegtor` does not subclass `Object`:
+          #   https://github.com/ruby/ruby/blob/a6383fb/lib/delegate.rb#L41
+          # but we assume that we are delegating to a class that does.
+          klass.create_include("Kernel")
+          delegated = DELEGATIONS.fetch(constant)
+
+          delegated.instance_methods(false).each do |method|
+            signature = T::Utils.signature_for_method(delegated.instance_method(method))
+            # TODO: handle methods with parameters
+            return_type = signature&.return_type&.to_s || "T.untyped"
+            klass.create_method(method.to_s, return_type:)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/sorbet/tapioca/compilers/env_config.rb b/Library/Homebrew/sorbet/tapioca/compilers/env_config.rb
new file mode 100644
index 0000000000000..4012ca9928df7
--- /dev/null
+++ b/Library/Homebrew/sorbet/tapioca/compilers/env_config.rb
@@ -0,0 +1,41 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../../../global"
+require "env_config"
+
+module Tapioca
+  module Compilers
+    class EnvConfig < Tapioca::Dsl::Compiler
+      ConstantType = type_member { { fixed: Module } }
+
+      sig { override.returns(T::Enumerable[Module]) }
+      def self.gather_constants = [Homebrew::EnvConfig]
+
+      sig { override.void }
+      def decorate
+        root.create_module(T.must(constant.name)) do |mod|
+          dynamic_methods = {}
+          Homebrew::EnvConfig::ENVS.each do |env, hash|
+            next if Homebrew::EnvConfig::CUSTOM_IMPLEMENTATIONS.include?(env)
+
+            name = Homebrew::EnvConfig.env_method_name(env, hash)
+            dynamic_methods[name] = hash[:default]
+          end
+
+          dynamic_methods.each do |method, default|
+            return_type = if method.end_with?("?")
+              T::Boolean
+            elsif default
+              default.class
+            else
+              T.nilable(String)
+            end
+
+            mod.create_method(method, return_type:, class_method: true)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/sorbet/tapioca/compilers/forwardables.rb b/Library/Homebrew/sorbet/tapioca/compilers/forwardables.rb
new file mode 100644
index 0000000000000..6898beef6e428
--- /dev/null
+++ b/Library/Homebrew/sorbet/tapioca/compilers/forwardables.rb
@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../../../global"
+require "sorbet/tapioca/utils"
+require "utils/ast"
+
+module Tapioca
+  module Compilers
+    class Forwardables < Tapioca::Dsl::Compiler
+      FORWARDABLE_FILENAME = "forwardable.rb"
+      ARRAY_METHODS = T.let(["to_a", "to_ary"].freeze, T::Array[String])
+      HASH_METHODS = T.let(["to_h", "to_hash"].freeze, T::Array[String])
+      STRING_METHODS = T.let(["to_s", "to_str", "to_json"].freeze, T::Array[String])
+
+      ConstantType = type_member { { fixed: Module } }
+
+      sig { override.returns(T::Enumerable[Module]) }
+      def self.gather_constants
+        Homebrew::Tapioca::Utils.named_objects_with_module(Forwardable).reject do |obj|
+          # Avoid duplicate stubs for forwardables that are defined in vendored gems
+          Object.const_source_location(T.must(obj.name))&.first&.include?("vendor/bundle/ruby")
+        end
+      end
+
+      sig { override.void }
+      def decorate
+        root.create_path(constant) do |klass|
+          Homebrew::Tapioca::Utils.methods_from_file(constant, FORWARDABLE_FILENAME)
+                                  .each { |method| compile_forwardable_method(klass, method) }
+          Homebrew::Tapioca::Utils.methods_from_file(constant, FORWARDABLE_FILENAME, class_methods: true)
+                                  .each { |method| compile_forwardable_method(klass, method, class_method: true) }
+        end
+      end
+
+      private
+
+      sig { params(klass: RBI::Scope, method: T.any(Method, UnboundMethod), class_method: T::Boolean).void }
+      def compile_forwardable_method(klass, method, class_method: false)
+        name = method.name.to_s
+        return_type = return_type(name)
+        klass.create_method(
+          name,
+          parameters:   [
+            create_rest_param("args", type: "T.untyped"),
+            create_block_param("block", type: "T.untyped"),
+          ],
+          return_type:,
+          class_method:,
+        )
+      end
+
+      sig { params(name: String).returns(String) }
+      def return_type(name)
+        if name.end_with?("?")
+          "T::Boolean"
+        elsif ARRAY_METHODS.include?(name)
+          "Array"
+        elsif HASH_METHODS.include?(name)
+          "Hash"
+        elsif STRING_METHODS.include?(name)
+          "String"
+        else
+          "T.untyped"
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb b/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb
new file mode 100644
index 0000000000000..86760ca5021c7
--- /dev/null
+++ b/Library/Homebrew/sorbet/tapioca/compilers/rubocop.rb
@@ -0,0 +1,68 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "method_source"
+require "rubocop"
+require_relative "../../../rubocops"
+
+module Tapioca
+  module Compilers
+    class RuboCop < Tapioca::Dsl::Compiler
+      # This should be a module whose singleton class contains RuboCop::AST::NodePattern::Macros,
+      #   but I don't know how to express that in Sorbet.
+      ConstantType = type_member { { fixed: Module } }
+      sig { override.returns(T::Enumerable[Module]) }
+      def self.gather_constants
+        all_modules.select do |klass|
+          next unless klass.singleton_class < ::RuboCop::AST::NodePattern::Macros
+
+          path = T.must(Object.const_source_location(klass.to_s)).fetch(0).to_s
+          # exclude vendored code, to avoid contradicting their RBI files
+          !path.include?("/vendor/bundle/ruby/") &&
+            # exclude source code that already has an RBI file
+            !File.exist?("#{path}i") &&
+            # exclude source code that doesn't use the DSLs
+            File.readlines(path).any?(/def_node_/)
+        end
+      end
+
+      sig { override.void }
+      def decorate
+        root.create_path(constant) do |klass|
+          constant.instance_methods(false).each do |method_name|
+            source = constant.instance_method(method_name).source.lstrip
+            # For more info on these DSLs:
+            #   https://www.rubydoc.info/gems/rubocop-ast/RuboCop/AST/NodePattern/Macros
+            #   https://github.com/rubocop/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern.rb
+            #   https://github.com/rubocop/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern/method_definer.rb
+            # The type signatures below could maybe be stronger, but I only wanted to avoid errors:
+            case source
+            when /\Adef_node_matcher/
+              # https://github.com/Shopify/tapioca/blob/3341a9b/lib/tapioca/rbi_ext/model.rb#L89
+              klass.create_method(
+                method_name.to_s,
+                parameters:  [
+                  create_param("node", type: "RuboCop::AST::Node"),
+                  create_kw_rest_param("kwargs", type: "T.untyped"),
+                  create_block_param("block", type: "T.untyped"),
+                ],
+                return_type: "T.untyped",
+              )
+            when /\Adef_node_search/
+              klass.create_method(
+                method_name.to_s,
+                parameters:  [
+                  create_param("node", type: "RuboCop::AST::Node"),
+                  create_rest_param("pattern", type: "T.any(String, Symbol)"),
+                  create_kw_rest_param("kwargs", type: "T.untyped"),
+                  create_block_param("block", type: "T.untyped"),
+                ],
+                return_type: method_name.to_s.end_with?("?") ? "T::Boolean" : "T.untyped",
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/sorbet/tapioca/compilers/tty.rb b/Library/Homebrew/sorbet/tapioca/compilers/tty.rb
new file mode 100644
index 0000000000000..22a20f0aa219a
--- /dev/null
+++ b/Library/Homebrew/sorbet/tapioca/compilers/tty.rb
@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../../../global"
+require "utils/tty"
+
+module Tapioca
+  module Compilers
+    class Tty < Tapioca::Dsl::Compiler
+      ConstantType = type_member { { fixed: Module } }
+
+      sig { override.returns(T::Enumerable[Module]) }
+      def self.gather_constants = [::Tty]
+
+      sig { override.void }
+      def decorate
+        root.create_module(T.must(constant.name)) do |mod|
+          dynamic_methods = ::Tty::COLOR_CODES.keys + ::Tty::STYLE_CODES.keys + ::Tty::SPECIAL_CODES.keys
+
+          dynamic_methods.each do |method|
+            mod.create_method(method.to_s, return_type: "String", class_method: true)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/sorbet/tapioca/config.yml b/Library/Homebrew/sorbet/tapioca/config.yml
new file mode 100644
index 0000000000000..22b4224b1e610
--- /dev/null
+++ b/Library/Homebrew/sorbet/tapioca/config.yml
@@ -0,0 +1,31 @@
+---
+# see https://github.com/Shopify/tapioca?tab=readme-ov-file#configuration
+gem:
+  exclude:
+    # These conflict with the rbi files provided by sorbet:
+    - json
+    # These aren't needed:
+    - coderay
+    - diff-lcs
+    - docile
+    - hana
+    - language_server-protocol
+    - netrc
+    - parallel
+    - public_suffix
+    - racc
+    - rexml
+    - rspec-github
+    - rspec-mocks
+    - rspec-retry
+    - rspec
+    - rspec_junit_formatter
+    - rubocop-md
+    - rubocop-performance
+    - rubocop-sorbet
+    - ruby-prof
+    - simplecov_json_formatter
+    - simpleidn
+    - unicode-display_width
+    - yard-sorbet
+  prerequire: sorbet/tapioca/prerequire.rb
diff --git a/Library/Homebrew/sorbet/tapioca/prerequire.rb b/Library/Homebrew/sorbet/tapioca/prerequire.rb
new file mode 100644
index 0000000000000..643b472c99713
--- /dev/null
+++ b/Library/Homebrew/sorbet/tapioca/prerequire.rb
@@ -0,0 +1,5 @@
+# typed: strict
+# frozen_string_literal: true
+
+# Don't start coverage tracking automatically
+ENV["SIMPLECOV_NO_DEFAULTS"] = "1"
diff --git a/Library/Homebrew/sorbet/tapioca/require.rb b/Library/Homebrew/sorbet/tapioca/require.rb
index d567d43466c39..cde9e03894574 100644
--- a/Library/Homebrew/sorbet/tapioca/require.rb
+++ b/Library/Homebrew/sorbet/tapioca/require.rb
@@ -1,16 +1,21 @@
 # typed: strict
 # frozen_string_literal: true
 
-# This should not be made a constant or Tapioca will think it is part of a gem.
+# These should not be made constants or Tapioca will think they are part of a gem.
 dependency_require_map = {
-  "activesupport" => "active_support",
-  "ruby-macho"    => "macho",
+  "ruby-macho" => "macho",
 }.freeze
 
-# Don't start coverage tracking automatically
-ENV["SIMPLECOV_NO_DEFAULTS"] = "1"
+additional_requires_map = {
+  "parser"        => ["parser/current"],
+  "rubocop-rspec" => ["rubocop/rspec/expect_offense"],
+}.freeze
+
+# Freeze lockfile
+Bundler.settings.set_command_option(:frozen, "1")
 
-Bundler.definition.locked_gems.specs.each do |spec|
+definition = Bundler.definition
+definition.resolve.for(definition.current_dependencies).each do |spec|
   name = spec.name
 
   # These sorbet gems do not contain any library files
@@ -19,8 +24,8 @@
   next if name == "sorbet-static-and-runtime"
 
   name = dependency_require_map[name] if dependency_require_map.key?(name)
-
   require name
+  additional_requires_map[name]&.each { require(_1) }
 rescue LoadError
   raise unless name.include?("-")
 
diff --git a/Library/Homebrew/sorbet/tapioca/utils.rb b/Library/Homebrew/sorbet/tapioca/utils.rb
new file mode 100644
index 0000000000000..23369c1019355
--- /dev/null
+++ b/Library/Homebrew/sorbet/tapioca/utils.rb
@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  module Tapioca
+    module Utils
+      sig { params(klass: T::Class[T.anything]).returns(Module) }
+      def self.named_object_for(klass)
+        return klass if klass.name
+
+        attached_object = klass.attached_object
+        case attached_object
+        when Module then attached_object
+        else raise "Unsupported attached object for: #{klass}"
+        end
+      end
+
+      # @param class_methods [Boolean] whether to get class methods or instance methods
+      # @return the `module` methods that are defined in the given file
+      sig {
+        params(mod: Module, file_name: String,
+               class_methods: T::Boolean).returns(T::Array[T.any(Method, UnboundMethod)])
+      }
+      def self.methods_from_file(mod, file_name, class_methods: false)
+        methods = if class_methods
+          mod.methods(false).map { mod.method(_1) }
+        else
+          mod.instance_methods(false).map { mod.instance_method(_1) }
+        end
+        methods.select { _1.source_location&.first&.end_with?(file_name) }
+      end
+
+      sig { params(mod: Module).returns(T::Array[Module]) }
+      def self.named_objects_with_module(mod)
+        ObjectSpace.each_object(mod).map do |obj|
+          case obj
+          when Class then named_object_for(obj)
+          when Module then obj
+          else raise "Unsupported object: #{obj}"
+          end
+        end.uniq
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/source_location.rb b/Library/Homebrew/source_location.rb
new file mode 100644
index 0000000000000..545d35ae0c48c
--- /dev/null
+++ b/Library/Homebrew/source_location.rb
@@ -0,0 +1,24 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Homebrew
+  # A location in source code.
+  class SourceLocation
+    sig { returns(Integer) }
+    attr_reader :line
+
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :column
+
+    sig { params(line: Integer, column: T.nilable(Integer)).void }
+    def initialize(line, column = nil)
+      @line = line
+      @column = column
+    end
+
+    sig { returns(String) }
+    def to_s
+      "#{line}#{column&.to_s&.prepend(":")}"
+    end
+  end
+end
diff --git a/Library/Homebrew/standalone.rb b/Library/Homebrew/standalone.rb
index 865191d96b9c6..0212c00d8c1e3 100644
--- a/Library/Homebrew/standalone.rb
+++ b/Library/Homebrew/standalone.rb
@@ -3,5 +3,5 @@
 
 # This file should be the first `require` in all entrypoints outside the `brew` environment.
 
-require_relative "standalone/load_path"
+require_relative "standalone/init"
 require_relative "standalone/sorbet"
diff --git a/Library/Homebrew/standalone/init.rb b/Library/Homebrew/standalone/init.rb
new file mode 100644
index 0000000000000..3cdaad743644f
--- /dev/null
+++ b/Library/Homebrew/standalone/init.rb
@@ -0,0 +1,66 @@
+# typed: true
+# frozen_string_literal: true
+
+# This file is included before any other files. It intentionally has typing disabled and has minimal use of `require`.
+
+required_ruby_major, required_ruby_minor, = ENV.fetch("HOMEBREW_REQUIRED_RUBY_VERSION", "").split(".").map(&:to_i)
+gems_vendored = if required_ruby_minor.nil?
+  # We're likely here if running RuboCop etc, so just assume we don't need to install gems as we likely already have
+  true
+else
+  ruby_major, ruby_minor, = RUBY_VERSION.split(".").map(&:to_i)
+  raise "Could not parse Ruby requirements" if !ruby_major || !ruby_minor || !required_ruby_major
+
+  if ruby_major < required_ruby_major || (ruby_major == required_ruby_major && ruby_minor < required_ruby_minor)
+    raise "Homebrew must be run under Ruby #{required_ruby_major}.#{required_ruby_minor}! " \
+          "You're running #{RUBY_VERSION}."
+  end
+
+  # This list should match .gitignore
+  vendored_versions = ["3.3"].freeze
+  vendored_versions.include?("#{ruby_major}.#{ruby_minor}")
+end.freeze
+
+# We trust base Ruby to provide what we need.
+# Don't look into the user-installed sitedir, which may contain older versions of RubyGems.
+require "rbconfig"
+$LOAD_PATH.reject! { |path| path.start_with?(RbConfig::CONFIG["sitedir"]) }
+
+require "pathname"
+dir = __dir__ || raise("__dir__ is not defined")
+HOMEBREW_LIBRARY_PATH = Pathname(dir).parent.realpath.freeze
+HOMEBREW_USING_PORTABLE_RUBY = RbConfig.ruby.include?("/vendor/portable-ruby/").freeze
+
+require_relative "../utils/gems"
+Homebrew.setup_gem_environment!(setup_path: false)
+
+# Install gems for Rubies we don't vendor for.
+if !gems_vendored && !ENV["HOMEBREW_SKIP_INITIAL_GEM_INSTALL"]
+  Homebrew.install_bundler_gems!(setup_path: false)
+  ENV["HOMEBREW_SKIP_INITIAL_GEM_INSTALL"] = "1"
+end
+
+unless $LOAD_PATH.include?(HOMEBREW_LIBRARY_PATH.to_s)
+  # Insert the path after any existing Homebrew paths (e.g. those inserted by tests and parent processes)
+  last_homebrew_path_idx = $LOAD_PATH.rindex do |path|
+    path.start_with?(HOMEBREW_LIBRARY_PATH.to_s) && !path.include?("vendor/portable-ruby")
+  end || -1
+  $LOAD_PATH.insert(last_homebrew_path_idx + 1, HOMEBREW_LIBRARY_PATH.to_s)
+end
+require_relative "../vendor/bundle/bundler/setup"
+require "portable_ruby_gems" if HOMEBREW_USING_PORTABLE_RUBY
+$LOAD_PATH.unshift "#{HOMEBREW_LIBRARY_PATH}/vendor/bundle/#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/" \
+                   "bundler-#{Homebrew::HOMEBREW_BUNDLER_VERSION}/lib"
+$LOAD_PATH.uniq!
+
+# These warnings are nice but often flag problems that are not even our responsibly,
+# including in some cases from other Ruby standard library gems.
+# We strictly only allow one version of Ruby at a time so future compatibility
+# doesn't need to be handled ahead of time.
+if defined?(Gem::BUNDLED_GEMS)
+  [Kernel.singleton_class, Kernel].each do |kernel_class|
+    next unless kernel_class.respond_to?(:no_warning_require, true)
+
+    kernel_class.alias_method :require, :no_warning_require
+  end
+end
diff --git a/Library/Homebrew/standalone/load_path.rb b/Library/Homebrew/standalone/load_path.rb
deleted file mode 100644
index ff7daed613d06..0000000000000
--- a/Library/Homebrew/standalone/load_path.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "pathname"
-
-HOMEBREW_LIBRARY_PATH = Pathname(__dir__).parent.realpath.freeze
-
-require_relative "../utils/gems"
-Homebrew.setup_gem_environment!(setup_path: false)
-
-$LOAD_PATH.push HOMEBREW_LIBRARY_PATH.to_s unless $LOAD_PATH.include?(HOMEBREW_LIBRARY_PATH.to_s)
-require_relative "../vendor/bundle/bundler/setup"
-$LOAD_PATH.uniq!
-
-# Block any gem loading by bypassing rubygem's `require`.
-# Helps make sure we don't accidentally use things not in bundler's load path.
-# Bundler 2.2.7+ and non-standalone mode both do this automatically.
-# https://github.com/rubygems/rubygems/blob/5841761974bef324a33ef1cb650bbf8a2457805b/bundler/lib/bundler/installer/standalone.rb#L55-L63
-if Kernel.private_method_defined?(:gem_original_require)
-  Kernel.send(:remove_method, :require)
-  Kernel.send(:define_method, :require, Kernel.instance_method(:gem_original_require))
-  Kernel.send(:private, :require)
-end
diff --git a/Library/Homebrew/standalone/sorbet.rb b/Library/Homebrew/standalone/sorbet.rb
index 8170e0049f134..9cd7fa24a8df6 100644
--- a/Library/Homebrew/standalone/sorbet.rb
+++ b/Library/Homebrew/standalone/sorbet.rb
@@ -2,29 +2,30 @@
 # frozen_string_literal: true
 
 require "sorbet-runtime"
+require "extend/module"
 
 # Disable runtime checking unless enabled.
 # In the future we should consider not doing this monkey patch,
 # if assured that there is no performance hit from removing this.
 # There are mechanisms to achieve a middle ground (`default_checked_level`).
 unless ENV["HOMEBREW_SORBET_RUNTIME"]
-  # Redefine T.let etc to make the `checked` parameter default to false rather than true.
+  # Redefine `T.let`, etc. to make the `checked` parameter default to `false` rather than `true`.
   # @private
   module TNoChecks
     def cast(value, type, checked: false)
-      super(value, type, checked: checked)
+      super
     end
 
     def let(value, type, checked: false)
-      super(value, type, checked: checked)
+      super
     end
 
     def bind(value, type, checked: false)
-      super(value, type, checked: checked)
+      super
     end
 
     def assert_type!(value, type, checked: false)
-      super(value, type, checked: checked)
+      super
     end
   end
 
@@ -34,14 +35,13 @@ class << self
       prepend TNoChecks
     end
 
-    # Redefine T.sig to be noop.
-    # @private
+    # Redefine `T.sig` to be a no-op.
     module Sig
       def sig(arg0 = nil, &blk); end
     end
   end
 
   # For any cases the above doesn't handle: make sure we don't let TypeError slip through.
-  T::Configuration.call_validation_error_handler = ->(signature, opts) do end
-  T::Configuration.inline_type_error_handler = ->(error, opts) do end
+  T::Configuration.call_validation_error_handler = ->(signature, opts) {}
+  T::Configuration.inline_type_error_handler = ->(error, opts) {}
 end
diff --git a/Library/Homebrew/startup.rb b/Library/Homebrew/startup.rb
index c47ca3749b123..1eff1ae226284 100644
--- a/Library/Homebrew/startup.rb
+++ b/Library/Homebrew/startup.rb
@@ -3,7 +3,7 @@
 
 # This file should be the first `require` in all entrypoints of `brew`.
 
-require_relative "standalone/load_path"
+require_relative "standalone/init"
 require_relative "startup/ruby_path"
 require "startup/config"
 require_relative "startup/bootsnap"
diff --git a/Library/Homebrew/startup/bootsnap.rb b/Library/Homebrew/startup/bootsnap.rb
index ddecf639ef461..01a9a662ea995 100644
--- a/Library/Homebrew/startup/bootsnap.rb
+++ b/Library/Homebrew/startup/bootsnap.rb
@@ -1,47 +1,46 @@
-# typed: false
+# typed: true
 # frozen_string_literal: true
 
-homebrew_bootsnap_enabled = ENV["HOMEBREW_NO_BOOTSNAP"].nil? && !ENV["HOMEBREW_BOOTSNAP"].nil?
+homebrew_bootsnap_enabled = HOMEBREW_USING_PORTABLE_RUBY &&
+                            ENV["HOMEBREW_NO_BOOTSNAP"].nil? &&
+                            !ENV["HOMEBREW_BOOTSNAP"].nil?
 
-# portable ruby doesn't play nice with bootsnap
-# Can't use .exclude? here because we haven't required active_support yet.
-homebrew_bootsnap_enabled &&= !RUBY_PATH.to_s.include?("/vendor/portable-ruby/") # rubocop:disable Rails/NegateInclude
+module Homebrew
+  def self.bootsnap_key
+    @bootsnap_key ||= begin
+      require "digest/sha2"
 
-homebrew_bootsnap_enabled &&= if ENV["HOMEBREW_MACOS_VERSION"]
-  # Apple Silicon doesn't play nice with bootsnap
-  ENV["HOMEBREW_PROCESSOR"] == "Intel" &&
-    # we need some development tools to build bootsnap native code
-    (File.directory?("/Applications/Xcode.app") || File.directory?("/Library/Developer/CommandLineTools"))
-else
-  File.executable?("/usr/bin/clang") || File.executable?("/usr/bin/gcc")
-end
+      checksum = Digest::SHA256.new
+      checksum << RUBY_VERSION
+      checksum << RUBY_PLATFORM
+      checksum << Dir.children(File.join(Gem.paths.path, "gems")).join(",")
 
-if homebrew_bootsnap_enabled
-  begin
-    require "bootsnap"
-  rescue LoadError
-    unless ENV["HOMEBREW_BOOTSNAP_RETRY"]
-      Homebrew.install_bundler_gems!(only_warn_on_failure: true)
-
-      ENV["HOMEBREW_BOOTSNAP_RETRY"] = "1"
-      exec ENV.fetch("HOMEBREW_BREW_FILE"), *ARGV
+      checksum.hexdigest
     end
   end
+end
 
-  ENV.delete("HOMEBREW_BOOTSNAP_RETRY")
-
-  if defined?(Bootsnap)
-    cache = ENV.fetch("HOMEBREW_CACHE", nil) || ENV.fetch("HOMEBREW_DEFAULT_CACHE", nil)
-    # Can't use .blank? here because we haven't required active_support yet.
-    raise "Needs HOMEBREW_CACHE or HOMEBREW_DEFAULT_CACHE!" if cache.nil? || cache.empty? # rubocop:disable Rails/Blank
-
-    Bootsnap.setup(
-      cache_dir:          cache,
-      load_path_cache:    true,
-      compile_cache_iseq: true,
-      compile_cache_yaml: true,
-    )
-  else
-    $stderr.puts "Error: HOMEBREW_BOOTSNAP could not `require \"bootsnap\"`!\n\n"
-  end
+if homebrew_bootsnap_enabled
+  require "bootsnap"
+
+  cache = ENV.fetch("HOMEBREW_CACHE", nil) || ENV.fetch("HOMEBREW_DEFAULT_CACHE", nil)
+  raise "Needs HOMEBREW_CACHE or HOMEBREW_DEFAULT_CACHE!" if cache.nil? || cache.empty?
+
+  cache = File.join(cache, "bootsnap", Homebrew.bootsnap_key)
+
+  # We never do `require "vendor/bundle/ruby/..."` or `require "vendor/portable-ruby/..."`,
+  # so let's slim the cache a bit by excluding them.
+  # Note that gems within `bundle/ruby` will still be cached - these are when directory walking down from above.
+  ignore_directories = [
+    (HOMEBREW_LIBRARY_PATH/"vendor/bundle/ruby").to_s,
+    (HOMEBREW_LIBRARY_PATH/"vendor/portable-ruby").to_s,
+  ]
+
+  Bootsnap.setup(
+    cache_dir:          cache,
+    ignore_directories:,
+    load_path_cache:    true,
+    compile_cache_iseq: true,
+    compile_cache_yaml: true,
+  )
 end
diff --git a/Library/Homebrew/startup/bootsnap.rbi b/Library/Homebrew/startup/bootsnap.rbi
new file mode 100644
index 0000000000000..3f42e1837d165
--- /dev/null
+++ b/Library/Homebrew/startup/bootsnap.rbi
@@ -0,0 +1,33 @@
+# typed: strict
+
+module Homebrew
+  sig { returns(String) }
+  def self.bootsnap_key; end
+end
+
+module Bootsnap
+  sig {
+    params(
+      cache_dir:          String,
+      development_mode:   T::Boolean,
+      load_path_cache:    T::Boolean,
+      ignore_directories: T.nilable(T::Array[String]),
+      readonly:           T::Boolean,
+      revalidation:       T::Boolean,
+      compile_cache_iseq: T::Boolean,
+      compile_cache_yaml: T::Boolean,
+      compile_cache_json: T::Boolean,
+    ).void
+  }
+  def self.setup(
+    cache_dir:,
+    development_mode: true,
+    load_path_cache: true,
+    ignore_directories: nil,
+    readonly: false,
+    revalidation: false,
+    compile_cache_iseq: true,
+    compile_cache_yaml: true,
+    compile_cache_json: true
+  ); end
+end
diff --git a/Library/Homebrew/startup/config.rb b/Library/Homebrew/startup/config.rb
index 52c6836accd93..7ef65a1eaae05 100644
--- a/Library/Homebrew/startup/config.rb
+++ b/Library/Homebrew/startup/config.rb
@@ -12,7 +12,7 @@
 # Where `.git` is found
 HOMEBREW_REPOSITORY = Pathname(ENV.fetch("HOMEBREW_REPOSITORY")).freeze
 
-# Where we store most of Homebrew, taps, and various metadata
+# Where we store most of Homebrew, taps and various metadata
 HOMEBREW_LIBRARY = Pathname(ENV.fetch("HOMEBREW_LIBRARY")).freeze
 
 # Where shim scripts for various build and SCM tools are stored
@@ -33,13 +33,16 @@
 # Where we store built products
 HOMEBREW_CELLAR = Pathname(ENV.fetch("HOMEBREW_CELLAR")).freeze
 
+# Where we store Casks
+HOMEBREW_CASKROOM = Pathname(ENV.fetch("HOMEBREW_CASKROOM")).freeze
+
 # Where downloads (bottles, source tarballs, etc.) are cached
 HOMEBREW_CACHE = Pathname(ENV.fetch("HOMEBREW_CACHE")).freeze
 
 # Where formulae installed via URL are cached
 HOMEBREW_CACHE_FORMULA = (HOMEBREW_CACHE/"Formula").freeze
 
-# Where build, postinstall, and test logs of formulae are written to
+# Where build, postinstall and test logs of formulae are written to
 HOMEBREW_LOGS = Pathname(ENV.fetch("HOMEBREW_LOGS")).expand_path.freeze
 
 # Must use `/tmp` instead of `TMPDIR` because long paths break Unix domain sockets
@@ -48,8 +51,12 @@
   tmp.realpath
 end.freeze
 
+# Where installed taps live
+HOMEBREW_TAP_DIRECTORY = (HOMEBREW_LIBRARY/"Taps").freeze
+
 # The Ruby path and args to use for forked Ruby calls
 HOMEBREW_RUBY_EXEC_ARGS = [
   RUBY_PATH,
   ENV.fetch("HOMEBREW_RUBY_WARNINGS"),
+  ENV.fetch("HOMEBREW_RUBY_DISABLE_OPTIONS"),
 ].freeze
diff --git a/Library/Homebrew/startup/ruby_path.rb b/Library/Homebrew/startup/ruby_path.rb
index e9a7a634fbda2..35de5267a4b96 100644
--- a/Library/Homebrew/startup/ruby_path.rb
+++ b/Library/Homebrew/startup/ruby_path.rb
@@ -1,7 +1,5 @@
 # typed: true
 # frozen_string_literal: true
 
-require "rbconfig"
-
 RUBY_PATH = Pathname.new(RbConfig.ruby).freeze
 RUBY_BIN = RUBY_PATH.dirname.freeze
diff --git a/Library/Homebrew/style.rb b/Library/Homebrew/style.rb
index 8b253c0f5f3ac..493d4fc37d4fb 100644
--- a/Library/Homebrew/style.rb
+++ b/Library/Homebrew/style.rb
@@ -1,27 +1,27 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "shellwords"
+require "source_location"
+require "system_command"
 
 module Homebrew
   # Helper module for running RuboCop.
-  #
-  # @api private
   module Style
-    module_function
+    extend SystemCommand::Mixin
 
     # Checks style for a list of files, printing simple RuboCop output.
     # Returns true if violations were found, false otherwise.
-    def check_style_and_print(files, **options)
+    def self.check_style_and_print(files, **options)
       success = check_style_impl(files, :print, **options)
 
-      if ENV["GITHUB_ACTIONS"] && !success
+      if GitHub::Actions.env_set? && !success
         check_style_json(files, **options).each do |path, offenses|
           offenses.each do |o|
             line = o.location.line
             column = o.location.line
 
-            annotation = GitHub::Actions::Annotation.new(:error, o.message, file: path, line: line, column: column)
+            annotation = GitHub::Actions::Annotation.new(:error, o.message, file: path, line:, column:)
             puts annotation if annotation.relevant?
           end
         end
@@ -32,59 +32,87 @@ def check_style_and_print(files, **options)
 
     # Checks style for a list of files, returning results as an {Offenses}
     # object parsed from its JSON output.
-    def check_style_json(files, **options)
+    def self.check_style_json(files, **options)
       check_style_impl(files, :json, **options)
     end
 
-    def check_style_impl(files, output_type,
-                         fix: false,
-                         except_cops: nil, only_cops: nil,
-                         display_cop_names: false,
-                         reset_cache: false,
-                         debug: false, verbose: false)
+    def self.check_style_impl(files, output_type,
+                              fix: false,
+                              except_cops: nil, only_cops: nil,
+                              display_cop_names: false,
+                              reset_cache: false,
+                              debug: false, verbose: false)
       raise ArgumentError, "Invalid output type: #{output_type.inspect}" if [:print, :json].exclude?(output_type)
 
-      shell_files, ruby_files =
-        Array(files).map(&method(:Pathname))
-                    .partition { |f| f.realpath == HOMEBREW_BREW_FILE.realpath || f.extname == ".sh" }
+      ruby_files = T.let([], T::Array[Pathname])
+      shell_files = T.let([], T::Array[Pathname])
+      actionlint_files = T.let([], T::Array[Pathname])
+      Array(files).map(&method(:Pathname))
+                  .each do |path|
+        case path.extname
+        when ".rb"
+          ruby_files << path
+        when ".sh"
+          shell_files << path
+        when ".yml"
+          actionlint_files << path if path.realpath.to_s.include?("/.github/workflows/")
+        else
+          ruby_files << path
+          shell_files += if [HOMEBREW_PREFIX, HOMEBREW_REPOSITORY].include?(path)
+            shell_scripts
+          else
+            path.glob("**/*.sh")
+                .reject { |path| path.to_s.include?("/vendor/") || path.directory? }
+          end
+          actionlint_files += (path/".github/workflows").glob("*.y{,a}ml")
+        end
+      end
 
-      rubocop_result = if shell_files.any? && ruby_files.none?
-        output_type == :json ? [] : true
+      rubocop_result = if files.present? && ruby_files.empty?
+        (output_type == :json) ? [] : true
       else
         run_rubocop(ruby_files, output_type,
-                    fix: fix,
-                    except_cops: except_cops, only_cops: only_cops,
-                    display_cop_names: display_cop_names,
-                    reset_cache: reset_cache,
-                    debug: debug, verbose: verbose)
+                    fix:,
+                    except_cops:, only_cops:,
+                    display_cop_names:,
+                    reset_cache:,
+                    debug:, verbose:)
       end
 
-      shellcheck_result = if ruby_files.any? && shell_files.none?
-        output_type == :json ? [] : true
+      shellcheck_result = if files.present? && shell_files.empty?
+        (output_type == :json) ? [] : true
       else
-        run_shellcheck(shell_files, output_type, fix: fix)
+        run_shellcheck(shell_files, output_type, fix:)
       end
 
-      shfmt_result = if ruby_files.any? && shell_files.none?
+      shfmt_result = if files.present? && shell_files.empty?
         true
       else
-        run_shfmt(shell_files, fix: fix)
+        run_shfmt(shell_files, fix:)
+      end
+
+      has_actionlint_workflow = actionlint_files.any? do |path|
+        path.to_s.end_with?("/.github/workflows/actionlint.yml")
+      end
+      odebug "actionlint workflow detected. Skipping actionlint checks." if has_actionlint_workflow
+      actionlint_result = if files.present? && (has_actionlint_workflow || actionlint_files.empty?)
+        true
+      else
+        run_actionlint(actionlint_files)
       end
 
       if output_type == :json
         Offenses.new(rubocop_result + shellcheck_result)
       else
-        rubocop_result && shellcheck_result && shfmt_result
+        rubocop_result && shellcheck_result && shfmt_result && actionlint_result
       end
     end
 
     RUBOCOP = (HOMEBREW_LIBRARY_PATH/"utils/rubocop.rb").freeze
 
-    def run_rubocop(files, output_type,
-                    fix: false, except_cops: nil, only_cops: nil, display_cop_names: false, reset_cache: false,
-                    debug: false, verbose: false)
-      Homebrew.install_bundler_gems!
-
+    def self.run_rubocop(files, output_type,
+                         fix: false, except_cops: nil, only_cops: nil, display_cop_names: false, reset_cache: false,
+                         debug: false, verbose: false)
       require "warnings"
 
       Warnings.ignore :parser_syntax do
@@ -103,21 +131,20 @@ def run_rubocop(files, output_type,
       end
 
       args += ["--extra-details"] if verbose
-      args += ["--display-cop-names"] if display_cop_names || verbose
 
       if except_cops
-        except_cops.map! { |cop| RuboCop::Cop::Cop.registry.qualified_cop_name(cop.to_s, "") }
+        except_cops.map! { |cop| RuboCop::Cop::Registry.global.qualified_cop_name(cop.to_s, "") }
         cops_to_exclude = except_cops.select do |cop|
-          RuboCop::Cop::Cop.registry.names.include?(cop) ||
-            RuboCop::Cop::Cop.registry.departments.include?(cop.to_sym)
+          RuboCop::Cop::Registry.global.names.include?(cop) ||
+            RuboCop::Cop::Registry.global.departments.include?(cop.to_sym)
         end
 
         args << "--except" << cops_to_exclude.join(",") unless cops_to_exclude.empty?
       elsif only_cops
-        only_cops.map! { |cop| RuboCop::Cop::Cop.registry.qualified_cop_name(cop.to_s, "") }
+        only_cops.map! { |cop| RuboCop::Cop::Registry.global.qualified_cop_name(cop.to_s, "") }
         cops_to_include = only_cops.select do |cop|
-          RuboCop::Cop::Cop.registry.names.include?(cop) ||
-            RuboCop::Cop::Cop.registry.departments.include?(cop.to_sym)
+          RuboCop::Cop::Registry.global.names.include?(cop) ||
+            RuboCop::Cop::Registry.global.departments.include?(cop.to_sym)
         end
 
         odie "RuboCops #{only_cops.join(",")} were not found" if cops_to_include.empty?
@@ -126,23 +153,28 @@ def run_rubocop(files, output_type,
       end
 
       files&.map!(&:expand_path)
+      base_dir = Dir.pwd
       if files.blank? || files == [HOMEBREW_REPOSITORY]
         files = [HOMEBREW_LIBRARY_PATH]
-      elsif files.none? { |f| f.to_s.start_with? HOMEBREW_LIBRARY_PATH }
-        config = if files.any? { |f| (f/"spec").exist? }
-          HOMEBREW_LIBRARY/".rubocop_rspec.yml"
-        else
-          HOMEBREW_LIBRARY/".rubocop.yml"
-        end
-        args << "--config" << config
+        base_dir = HOMEBREW_LIBRARY_PATH
+      elsif files.any? { |f| f.to_s.start_with?(HOMEBREW_REPOSITORY/"docs") || (f.basename.to_s == "docs") }
+        args << "--config" << (HOMEBREW_REPOSITORY/"docs/docs_rubocop_style.yml")
+      elsif files.any? { |f| f.to_s.start_with? HOMEBREW_LIBRARY_PATH }
+        base_dir = HOMEBREW_LIBRARY_PATH
+      else
+        args << "--config" << (HOMEBREW_LIBRARY/".rubocop.yml")
+        base_dir = HOMEBREW_LIBRARY if files.any? { |f| f.to_s.start_with? HOMEBREW_LIBRARY }
       end
 
       args += files
 
-      cache_env = { "XDG_CACHE_HOME" => "#{HOMEBREW_CACHE}/style" }
+      HOMEBREW_CACHE.mkpath
+      cache_dir = HOMEBREW_CACHE.realpath
+      cache_env = { "XDG_CACHE_HOME" => "#{cache_dir}/style" }
 
       FileUtils.rm_rf cache_env["XDG_CACHE_HOME"] if reset_cache
 
+      ruby_args = HOMEBREW_RUBY_EXEC_ARGS.dup
       case output_type
       when :print
         args << "--debug" if debug
@@ -153,18 +185,21 @@ def run_rubocop(files, output_type,
 
         args << "--color" if Tty.color?
 
-        system cache_env, RUBY_PATH, RUBOCOP, *args
+        system cache_env, *ruby_args, "--", RUBOCOP, *args, chdir: base_dir
         $CHILD_STATUS.success?
       when :json
-        result = system_command RUBY_PATH,
-                                args: [RUBOCOP, "--format", "json", *args],
-                                env:  cache_env
+        result = system_command ruby_args.shift,
+                                args:  [*ruby_args, "--", RUBOCOP, "--format", "json", *args],
+                                env:   cache_env,
+                                chdir: base_dir
         json = json_result!(result)
-        json["files"]
+        json["files"].each do |file|
+          file["path"] = File.absolute_path(file["path"], base_dir)
+        end
       end
     end
 
-    def run_shellcheck(files, output_type, fix: false)
+    def self.run_shellcheck(files, output_type, fix: false)
       files = shell_scripts if files.blank?
 
       files = files.map(&:realpath) # use absolute file paths
@@ -184,7 +219,7 @@ def run_shellcheck(files, output_type, fix: false)
         #   -f   (--force)       : we know what we are doing, force apply patches
         #   -d / (--directory=/) : change to root directory, since we use absolute file paths
         #   -p0  (--strip=0)     : do not strip path prefixes, since we are at root directory
-        # NOTE: we use short flags where for compatibility
+        # NOTE: We use short flags for compatibility.
         patch_command = %w[patch -g 0 -f -d / -p0]
         patches = system_command(shellcheck, args: ["--format=diff", *args]).stdout
         Utils.safe_popen_write(*patch_command) { |p| p.write(patches) } if patches.present?
@@ -234,7 +269,7 @@ def run_shellcheck(files, output_type, fix: false)
       end
     end
 
-    def run_shfmt(files, fix: false)
+    def self.run_shfmt(files, fix: false)
       files = shell_scripts if files.blank?
       # Do not format completions and Dockerfile
       files.delete(HOMEBREW_REPOSITORY/"completions/bash/brew")
@@ -247,7 +282,18 @@ def run_shfmt(files, fix: false)
       $CHILD_STATUS.success?
     end
 
-    def json_result!(result)
+    def self.run_actionlint(files)
+      files = github_workflow_files if files.blank?
+      # the ignore is to avoid false positives in e.g. actions, homebrew-test-bot
+      system actionlint, "-shellcheck", shellcheck,
+             "-config-file", HOMEBREW_REPOSITORY/".github/actionlint.yaml",
+             "-ignore", "image: string; options: string",
+             "-ignore", "label .* is unknown",
+             *files
+      $CHILD_STATUS.success?
+    end
+
+    def self.json_result!(result)
       # An exit status of 1 just means violations were found; other numbers mean
       # execution errors.
       # JSON needs to be at least 2 characters.
@@ -256,30 +302,50 @@ def json_result!(result)
       JSON.parse(result.stdout)
     end
 
-    def shell_scripts
+    def self.shell_scripts
       [
         HOMEBREW_BREW_FILE,
         HOMEBREW_REPOSITORY/"completions/bash/brew",
         HOMEBREW_REPOSITORY/"Dockerfile",
-        *HOMEBREW_LIBRARY.glob("Homebrew/*.sh"),
+        *HOMEBREW_REPOSITORY.glob(".devcontainer/**/*.sh"),
+        *HOMEBREW_REPOSITORY.glob("package/scripts/*"),
+        *HOMEBREW_LIBRARY.glob("Homebrew/**/*.sh").reject { |path| path.to_s.include?("/vendor/") },
         *HOMEBREW_LIBRARY.glob("Homebrew/shims/**/*").map(&:realpath).uniq
-                         .reject { |path| path.directory? || path.basename.to_s == "cc" },
+                         .reject(&:directory?)
+                         .reject { |path| path.basename.to_s == "cc" }
+                         .select do |path|
+                           %r{^#! ?/bin/(?:ba)?sh( |$)}.match?(path.read(13))
+                         end,
         *HOMEBREW_LIBRARY.glob("Homebrew/{dev-,}cmd/*.sh"),
         *HOMEBREW_LIBRARY.glob("Homebrew/{cask/,}utils/*.sh"),
       ]
     end
 
-    def shellcheck
+    def self.github_workflow_files
+      HOMEBREW_REPOSITORY.glob(".github/workflows/*.yml")
+    end
+
+    def self.rubocop
+      ensure_formula_installed!("rubocop", latest: true,
+                                           reason: "Ruby style checks").opt_bin/"rubocop"
+    end
+
+    def self.shellcheck
       ensure_formula_installed!("shellcheck", latest: true,
                                               reason: "shell style checks").opt_bin/"shellcheck"
     end
 
-    def shfmt
+    def self.shfmt
       ensure_formula_installed!("shfmt", latest: true,
                                          reason: "formatting shell scripts")
       HOMEBREW_LIBRARY/"Homebrew/utils/shfmt.sh"
     end
 
+    def self.actionlint
+      ensure_formula_installed!("actionlint", latest: true,
+                                              reason: "GitHub Actions checks").opt_bin/"actionlint"
+    end
+
     # Collection of style offenses.
     class Offenses
       include Enumerable
@@ -312,7 +378,8 @@ def initialize(json)
         @message = json["message"]
         @cop_name = json["cop_name"]
         @corrected = json["corrected"]
-        @location = LineLocation.new(json["location"])
+        location = json["location"]
+        @location = SourceLocation.new(location.fetch("line"), location["column"])
       end
 
       def severity_code
@@ -323,22 +390,5 @@ def corrected?
         @corrected
       end
     end
-
-    # Source location of a style offense.
-    class LineLocation
-      extend T::Sig
-
-      attr_reader :line, :column
-
-      def initialize(json)
-        @line = json["line"]
-        @column = json["column"]
-      end
-
-      sig { returns(String) }
-      def to_s
-        "#{line}: col #{column}"
-      end
-    end
   end
 end
diff --git a/Library/Homebrew/system_command.rb b/Library/Homebrew/system_command.rb
index 17ff585d10c3d..94601fb4dad9b 100644
--- a/Library/Homebrew/system_command.rb
+++ b/Library/Homebrew/system_command.rb
@@ -1,47 +1,47 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "open3"
-require "ostruct"
+require "attrable"
 require "plist"
 require "shellwords"
+require "uri"
 
+require "context"
 require "extend/io"
-require "extend/predicable"
-require "extend/hash_validator"
-
-require "extend/time"
+require "utils/timer"
 
 # Class for running sub-processes and capturing their output and exit status.
 #
-# @api private
+# @api internal
 class SystemCommand
-  extend T::Sig
-
-  using TimeRemaining
-
   # Helper functions for calling {SystemCommand.run}.
+  #
+  # @api internal
   module Mixin
-    extend T::Sig
-
-    def system_command(*args)
-      T.unsafe(SystemCommand).run(*args)
+    # Run a fallible system command.
+    #
+    # @api internal
+    def system_command(executable, **options)
+      SystemCommand.run(executable, **options)
     end
 
-    def system_command!(*args)
-      T.unsafe(SystemCommand).run!(*args)
+    # Run an infallible system command.
+    #
+    # @api internal
+    def system_command!(command, **options)
+      SystemCommand.run!(command, **options)
     end
   end
 
   include Context
-  extend Predicable
+  extend Attrable
 
   def self.run(executable, **options)
-    T.unsafe(self).new(executable, **options).run!
+    new(executable, **options).run!
   end
 
   def self.run!(command, **options)
-    T.unsafe(self).run(command, **options, must_succeed: true)
+    run(command, **options, must_succeed: true)
   end
 
   sig { returns(SystemCommand::Result) }
@@ -53,10 +53,20 @@ def run!
     each_output_line do |type, line|
       case type
       when :stdout
-        $stdout << redact_secrets(line, @secrets) if print_stdout?
+        case @print_stdout
+        when true
+          $stdout << redact_secrets(line, @secrets)
+        when :debug
+          $stderr << redact_secrets(line, @secrets) if debug?
+        end
         @output << [:stdout, line]
       when :stderr
-        $stderr << redact_secrets(line, @secrets) if print_stderr?
+        case @print_stderr
+        when true
+          $stderr << redact_secrets(line, @secrets)
+        when :debug
+          $stderr << redact_secrets(line, @secrets) if debug?
+        end
         @output << [:stderr, line]
       end
     end
@@ -71,15 +81,17 @@ def run!
       executable:   T.any(String, Pathname),
       args:         T::Array[T.any(String, Integer, Float, URI::Generic)],
       sudo:         T::Boolean,
+      sudo_as_root: T::Boolean,
       env:          T::Hash[String, String],
       input:        T.any(String, T::Array[String]),
       must_succeed: T::Boolean,
-      print_stdout: T::Boolean,
-      print_stderr: T::Boolean,
+      print_stdout: T.any(T::Boolean, Symbol),
+      print_stderr: T.any(T::Boolean, Symbol),
       debug:        T.nilable(T::Boolean),
       verbose:      T.nilable(T::Boolean),
       secrets:      T.any(String, T::Array[String]),
       chdir:        T.any(String, Pathname),
+      reset_uid:    T::Boolean,
       timeout:      T.nilable(T.any(Integer, Float)),
     ).void
   }
@@ -87,6 +99,7 @@ def initialize(
     executable,
     args: [],
     sudo: false,
+    sudo_as_root: false,
     env: {},
     input: [],
     must_succeed: false,
@@ -96,12 +109,24 @@ def initialize(
     verbose: false,
     secrets: [],
     chdir: T.unsafe(nil),
+    reset_uid: false,
     timeout: nil
   )
     require "extend/ENV"
     @executable = executable
     @args = args
+
+    raise ArgumentError, "`sudo_as_root` cannot be set if sudo is false" if !sudo && sudo_as_root
+
+    if print_stdout.is_a?(Symbol) && print_stdout != :debug
+      raise ArgumentError, "`print_stdout` is not a valid symbol"
+    end
+    if print_stderr.is_a?(Symbol) && print_stderr != :debug
+      raise ArgumentError, "`print_stderr` is not a valid symbol"
+    end
+
     @sudo = sudo
+    @sudo_as_root = sudo_as_root
     env.each_key do |name|
       next if /^[\w&&\D]\w*$/.match?(name)
 
@@ -116,19 +141,20 @@ def initialize(
     @verbose = verbose
     @secrets = (Array(secrets) + ENV.sensitive_environment.values).uniq
     @chdir = chdir
+    @reset_uid = reset_uid
     @timeout = timeout
   end
 
   sig { returns(T::Array[String]) }
   def command
-    [*sudo_prefix, *env_args, executable.to_s, *expanded_args]
+    [*command_prefix, executable.to_s, *expanded_args]
   end
 
   private
 
   attr_reader :executable, :args, :input, :chdir, :env
 
-  attr_predicate :sudo?, :print_stdout?, :print_stderr?, :must_succeed?
+  attr_predicate :sudo?, :sudo_as_root?, :must_succeed?, :reset_uid?
 
   sig { returns(T::Boolean) }
   def debug?
@@ -154,15 +180,38 @@ def env_args
 
     return [] if set_variables.empty?
 
-    ["/usr/bin/env", *set_variables]
+    set_variables
+  end
+
+  sig { returns(T.nilable(String)) }
+  def homebrew_sudo_user
+    ENV.fetch("HOMEBREW_SUDO_USER", nil)
   end
 
   sig { returns(T::Array[String]) }
   def sudo_prefix
-    return [] unless sudo?
-
     askpass_flags = ENV.key?("SUDO_ASKPASS") ? ["-A"] : []
-    ["/usr/bin/sudo", *askpass_flags, "-E", "--"]
+    user_flags = []
+    if Homebrew::EnvConfig.sudo_through_sudo_user?
+      raise ArgumentError, "HOMEBREW_SUDO_THROUGH_SUDO_USER set but SUDO_USER unset!" if homebrew_sudo_user.blank?
+
+      user_flags += ["--prompt", "Password for %p:", "-u", homebrew_sudo_user,
+                     *askpass_flags,
+                     "-E", *env_args,
+                     "--", "/usr/bin/sudo"]
+    end
+    user_flags += ["-u", "root"] if sudo_as_root?
+    ["/usr/bin/sudo", *user_flags, *askpass_flags, "-E", *env_args, "--"]
+  end
+
+  sig { returns(T::Array[String]) }
+  def env_prefix
+    ["/usr/bin/env", *env_args]
+  end
+
+  sig { returns(T::Array[String]) }
+  def command_prefix
+    sudo? ? sudo_prefix : env_prefix
   end
 
   sig { returns(T::Array[String]) }
@@ -191,18 +240,18 @@ def each_output_line(&block)
     }
     options[:chdir] = chdir if chdir
 
-    pid = T.let(nil, T.nilable(Integer))
-    raw_stdin, raw_stdout, raw_stderr, raw_wait_thr = ignore_interrupts do
-      T.unsafe(Open3).popen3(env, [executable, executable], *args, **options)
-       .tap { |*, wait_thr| pid = wait_thr.pid }
-    end
+    raw_stdin, raw_stdout, raw_stderr, raw_wait_thr = exec3(env, executable, *args, **options)
 
     write_input_to(raw_stdin)
     raw_stdin.close_write
 
+    thread_context = Context.current
     thread_ready_queue = Queue.new
     thread_done_queue = Queue.new
     line_thread = Thread.new do
+      # Ensure the new thread inherits the current context.
+      Context.current = thread_context
+
       Thread.handle_interrupt(ProcessTerminatedInterrupt => :never) do
         thread_ready_queue << true
         each_line_from [raw_stdout, raw_stderr], &block
@@ -213,25 +262,73 @@ def each_output_line(&block)
     end
 
     end_time = Time.now + @timeout if @timeout
-    raise Timeout::Error if raw_wait_thr.join(end_time&.remaining).nil?
+    raise Timeout::Error if raw_wait_thr.join(Utils::Timer.remaining(end_time)).nil?
 
     @status = raw_wait_thr.value
-
-    thread_ready_queue.pop
-    line_thread.raise ProcessTerminatedInterrupt.new
-    thread_done_queue << true
-    line_thread.join
   rescue Interrupt
-    Process.kill("INT", pid) if pid && !sudo?
+    Process.kill("INT", raw_wait_thr.pid) if raw_wait_thr && !sudo?
     raise Interrupt
-  rescue SystemCallError => e
-    @status = $CHILD_STATUS
-    @output << [:stderr, e.message]
+  ensure
+    if line_thread
+      thread_ready_queue.pop
+      line_thread.raise ProcessTerminatedInterrupt.new
+      thread_done_queue << true
+      line_thread.join
+    end
+    raw_stdin&.close
+    raw_stdout&.close
+    raw_stderr&.close
+  end
+
+  sig {
+    params(
+      env:        T::Hash[String, String],
+      executable: String,
+      args:       String,
+      options:    T.untyped,
+    ).returns([IO, IO, IO, Thread])
+  }
+  def exec3(env, executable, *args, **options)
+    in_r, in_w = IO.pipe
+    options[:in] = in_r
+    in_w.sync = true
+
+    out_r, out_w = IO.pipe
+    options[:out] = out_w
+
+    err_r, err_w = IO.pipe
+    options[:err] = err_w
+
+    pid = fork do
+      Process::UID.change_privilege(Process.euid) if reset_uid? && Process.euid != Process.uid
+
+      exec(
+        env.merge({ "COLUMNS" => Tty.width.to_s }),
+        [executable, executable],
+        *args,
+        **options,
+      )
+    rescue SystemCallError => e
+      $stderr.puts(e.message)
+      exit!(127)
+    end
+    wait_thr = Process.detach(pid)
+
+    [in_w, out_r, err_r, wait_thr]
+  rescue
+    in_w&.close
+    out_r&.close
+    err_r&.close
+    raise
+  ensure
+    in_r&.close
+    out_w&.close
+    err_w&.close
   end
 
   sig { params(raw_stdin: IO).void }
   def write_input_to(raw_stdin)
-    input.each(&raw_stdin.method(:write))
+    input.each { raw_stdin.write(_1) }
   end
 
   sig { params(sources: T::Array[IO], _block: T.proc.params(type: Symbol, line: String).void).void }
@@ -243,7 +340,7 @@ def each_line_from(sources, &_block)
 
     pending_interrupt = T.let(false, T::Boolean)
 
-    until pending_interrupt
+    until pending_interrupt || sources.empty?
       readable_sources = T.let([], T::Array[IO])
       begin
         Thread.handle_interrupt(ProcessTerminatedInterrupt => :on_blocking) do
@@ -254,7 +351,7 @@ def each_line_from(sources, &_block)
         pending_interrupt = true
       end
 
-      break if readable_sources.none? do |source|
+      readable_sources.each do |source|
         loop do
           line = source.readline_nonblock || ""
           yield(sources.fetch(source), line)
@@ -262,9 +359,8 @@ def each_line_from(sources, &_block)
       rescue EOFError
         source.close_read
         sources.delete(source)
-        sources.any?
       rescue IO::WaitReadable
-        true
+        # We've got all the data that was ready, but the other end of the stream isn't finished yet
       end
     end
 
@@ -273,8 +369,6 @@ def each_line_from(sources, &_block)
 
   # Result containing the output and exit status of a finished sub-process.
   class Result
-    extend T::Sig
-
     include Context
 
     attr_accessor :command, :status, :exit_status
@@ -349,7 +443,7 @@ def plist
           Regexp.last_match(1)
         end
 
-        Plist.parse_xml(output)
+        Plist.parse_xml(output, marshal: false)
       end
     end
 
@@ -364,7 +458,3 @@ def warn_plist_garbage(garbage)
     private :warn_plist_garbage
   end
 end
-
-# Make `system_command` available everywhere.
-# FIXME: Include this explicitly only where it is needed.
-include SystemCommand::Mixin # rubocop:disable Style/MixinUsage
diff --git a/Library/Homebrew/system_config.rb b/Library/Homebrew/system_config.rb
index a019aa4de0333..fe0556b50466d 100644
--- a/Library/Homebrew/system_config.rb
+++ b/Library/Homebrew/system_config.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "hardware"
@@ -6,14 +6,11 @@
 require "development_tools"
 require "extend/ENV"
 require "system_command"
+require "git_repository"
 
 # Helper module for querying information about the system configuration.
-#
-# @api private
 module SystemConfig
   class << self
-    extend T::Sig
-
     include SystemCommand::Mixin
 
     def clang
@@ -32,44 +29,24 @@ def clang_build
       end
     end
 
-    sig { returns(Pathname) }
+    sig { returns(GitRepository) }
     def homebrew_repo
-      HOMEBREW_REPOSITORY.dup.extend(GitRepositoryExtension)
+      GitRepository.new(HOMEBREW_REPOSITORY)
     end
 
     sig { returns(String) }
     def head
-      homebrew_repo.git_head || "(none)"
+      homebrew_repo.head_ref || "(none)"
     end
 
     sig { returns(String) }
     def last_commit
-      homebrew_repo.git_last_commit || "never"
+      homebrew_repo.last_committed || "never"
     end
 
     sig { returns(String) }
     def origin
-      homebrew_repo.git_origin || "(none)"
-    end
-
-    sig { returns(String) }
-    def core_tap_head
-      CoreTap.instance.git_head || "(none)"
-    end
-
-    sig { returns(String) }
-    def core_tap_last_commit
-      CoreTap.instance.git_last_commit || "never"
-    end
-
-    sig { returns(String) }
-    def core_tap_branch
-      CoreTap.instance.git_branch || "(none)"
-    end
-
-    sig { returns(String) }
-    def core_tap_origin
-      CoreTap.instance.remote || "(none)"
+      homebrew_repo.origin_url || "(none)"
     end
 
     sig { returns(String) }
@@ -94,19 +71,9 @@ def describe_path(path)
       end
     end
 
-    sig { returns(String) }
-    def describe_homebrew_ruby_version
-      case RUBY_VERSION
-      when /^1\.[89]/, /^2\.0/
-        "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
-      else
-        RUBY_VERSION
-      end
-    end
-
     sig { returns(String) }
     def describe_homebrew_ruby
-      "#{describe_homebrew_ruby_version} => #{RUBY_PATH}"
+      "#{RUBY_VERSION} => #{RUBY_PATH}"
     end
 
     sig { returns(T.nilable(String)) }
@@ -130,48 +97,68 @@ def describe_git
 
     sig { returns(String) }
     def describe_curl
-      out, = system_command(curl_executable, args: ["--version"], verbose: false)
+      out, = system_command(Utils::Curl.curl_executable, args: ["--version"], verbose: false)
 
-      if /^curl (?<curl_version>[\d.]+)/ =~ out
-        "#{curl_version} => #{curl_path}"
+      match_data = /^curl (?<curl_version>[\d.]+)/.match(out)
+      if match_data
+        "#{match_data[:curl_version]} => #{Utils::Curl.curl_path}"
       else
         "N/A"
       end
     end
 
-    def core_tap_config(f = $stdout)
-      if CoreTap.instance.installed?
-        f.puts "Core tap ORIGIN: #{core_tap_origin}"
-        f.puts "Core tap HEAD: #{core_tap_head}"
-        f.puts "Core tap last commit: #{core_tap_last_commit}"
-        f.puts "Core tap branch: #{core_tap_branch}"
+    def dump_tap_config(tap, out = $stdout)
+      case tap
+      when CoreTap
+        tap_name = "Core tap"
+        json_file_name = "formula.jws.json"
+      when CoreCaskTap
+        tap_name = "Core cask tap"
+        json_file_name = "cask.jws.json"
       else
-        f.puts "Core tap: N/A"
+        raise ArgumentError, "Unknown tap: #{tap}"
       end
+
+      if tap.installed?
+        out.puts "#{tap_name} origin: #{tap.remote}" if tap.remote != tap.default_remote
+        out.puts "#{tap_name} HEAD: #{tap.git_head || "(none)"}"
+        out.puts "#{tap_name} last commit: #{tap.git_last_commit || "never"}"
+        out.puts "#{tap_name} branch: #{tap.git_branch || "(none)"}" if tap.git_branch != "master"
+      end
+
+      if (json_file = Homebrew::API::HOMEBREW_CACHE_API/json_file_name) && json_file.exist?
+        out.puts "#{tap_name} JSON: #{json_file.mtime.utc.strftime("%d %b %H:%M UTC")}"
+      elsif !tap.installed?
+        out.puts "#{tap_name}: N/A"
+      end
+    end
+
+    def core_tap_config(out = $stdout)
+      dump_tap_config(CoreTap.instance, out)
     end
 
-    def homebrew_config(f = $stdout)
-      f.puts "HOMEBREW_VERSION: #{HOMEBREW_VERSION}"
-      f.puts "ORIGIN: #{origin}"
-      f.puts "HEAD: #{head}"
-      f.puts "Last commit: #{last_commit}"
+    def homebrew_config(out = $stdout)
+      out.puts "HOMEBREW_VERSION: #{HOMEBREW_VERSION}"
+      out.puts "ORIGIN: #{origin}"
+      out.puts "HEAD: #{head}"
+      out.puts "Last commit: #{last_commit}"
     end
 
-    def homebrew_env_config(f = $stdout)
-      f.puts "HOMEBREW_PREFIX: #{HOMEBREW_PREFIX}"
+    def homebrew_env_config(out = $stdout)
+      out.puts "HOMEBREW_PREFIX: #{HOMEBREW_PREFIX}"
       {
         HOMEBREW_REPOSITORY: Homebrew::DEFAULT_REPOSITORY,
         HOMEBREW_CELLAR:     Homebrew::DEFAULT_CELLAR,
       }.freeze.each do |key, default|
         value = Object.const_get(key)
-        f.puts "#{key}: #{value}" if value.to_s != default.to_s
+        out.puts "#{key}: #{value}" if value.to_s != default.to_s
       end
 
       Homebrew::EnvConfig::ENVS.each do |env, hash|
         method_name = Homebrew::EnvConfig.env_method_name(env, hash)
 
         if hash[:boolean]
-          f.puts "#{env}: set" if Homebrew::EnvConfig.send(method_name)
+          out.puts "#{env}: set" if Homebrew::EnvConfig.send(method_name)
           next
         end
 
@@ -180,26 +167,26 @@ def homebrew_env_config(f = $stdout)
         next if (default = hash[:default].presence) && value.to_s == default.to_s
 
         if ENV.sensitive?(env)
-          f.puts "#{env}: set"
+          out.puts "#{env}: set"
         else
-          f.puts "#{env}: #{value}"
+          out.puts "#{env}: #{value}"
         end
       end
-      f.puts "Homebrew Ruby: #{describe_homebrew_ruby}"
+      out.puts "Homebrew Ruby: #{describe_homebrew_ruby}"
     end
 
-    def host_software_config(f = $stdout)
-      f.puts "Clang: #{describe_clang}"
-      f.puts "Git: #{describe_git}"
-      f.puts "Curl: #{describe_curl}"
+    def host_software_config(out = $stdout)
+      out.puts "Clang: #{describe_clang}"
+      out.puts "Git: #{describe_git}"
+      out.puts "Curl: #{describe_curl}"
     end
 
-    def dump_verbose_config(f = $stdout)
-      homebrew_config(f)
-      core_tap_config(f)
-      homebrew_env_config(f)
-      f.puts hardware if hardware
-      host_software_config(f)
+    def dump_verbose_config(out = $stdout)
+      homebrew_config(out)
+      core_tap_config(out)
+      homebrew_env_config(out)
+      out.puts hardware if hardware
+      host_software_config(out)
     end
     alias dump_generic_verbose_config dump_verbose_config
   end
diff --git a/Library/Homebrew/tab.rb b/Library/Homebrew/tab.rb
index 8dba8022f6ebf..ac04c6880aae0 100644
--- a/Library/Homebrew/tab.rb
+++ b/Library/Homebrew/tab.rb
@@ -1,65 +1,57 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "cxxstdlib"
-require "ostruct"
 require "options"
 require "json"
 require "development_tools"
 require "extend/cachable"
 
-# Inherit from OpenStruct to gain a generic initialization method that takes a
-# hash and creates an attribute for each key and value. Rather than calling
-# `new` directly, use one of the class methods like {Tab.create}.
-class Tab < OpenStruct
-  extend T::Sig
-
+# Rather than calling `new` directly, use one of the class methods like {Tab.create}.
+class AbstractTab
   extend Cachable
 
   FILENAME = "INSTALL_RECEIPT.json"
 
-  # Instantiates a Tab for a new installation of a formula.
-  def self.create(formula, compiler, stdlib)
-    build = formula.build
-    runtime_deps = formula.runtime_dependencies(undeclared: false)
+  # Check whether the formula or cask was installed as a dependency.
+  #
+  # @api internal
+  attr_accessor :installed_as_dependency
+
+  # Check whether the formula or cask was installed on request.
+  #
+  # @api internal
+  attr_accessor :installed_on_request
+
+  attr_accessor :homebrew_version, :tabfile, :loaded_from_api, :time, :arch, :source, :built_on
+
+  # Returns the formula or cask runtime dependencies.
+  #
+  # @api internal
+  attr_accessor :runtime_dependencies
+
+  # Instantiates a {Tab} for a new installation of a formula or cask.
+  def self.create(formula_or_cask)
     attributes = {
       "homebrew_version"        => HOMEBREW_VERSION,
-      "used_options"            => build.used_options.as_flags,
-      "unused_options"          => build.unused_options.as_flags,
-      "tabfile"                 => formula.prefix/FILENAME,
-      "built_as_bottle"         => build.bottle?,
       "installed_as_dependency" => false,
       "installed_on_request"    => false,
-      "poured_from_bottle"      => false,
+      "loaded_from_api"         => formula_or_cask.loaded_from_api?,
       "time"                    => Time.now.to_i,
-      "source_modified_time"    => formula.source_modified_time.to_i,
-      "compiler"                => compiler,
-      "stdlib"                  => stdlib,
-      "aliases"                 => formula.aliases,
-      "runtime_dependencies"    => Tab.runtime_deps_hash(formula, runtime_deps),
       "arch"                    => Hardware::CPU.arch,
       "source"                  => {
-        "path"         => formula.specified_path.to_s,
-        "tap"          => formula.tap&.name,
-        "tap_git_head" => nil, # Filled in later if possible
-        "spec"         => formula.active_spec_sym.to_s,
-        "versions"     => {
-          "stable"         => formula.stable&.version.to_s,
-          "head"           => formula.head&.version.to_s,
-          "version_scheme" => formula.version_scheme,
-        },
+        "tap"          => formula_or_cask.tap&.name,
+        "tap_git_head" => formula_or_cask.tap_git_head,
       },
       "built_on"                => DevelopmentTools.build_system_info,
     }
 
-    # We can only get `tap_git_head` if the tap is installed locally
-    attributes["source"]["tap_git_head"] = formula.tap.git_head if formula.tap&.installed?
-
     new(attributes)
   end
 
-  # Returns the {Tab} for an install receipt at `path`.
-  # Results are cached.
+  # Returns the {Tab} for a formula or cask install receipt at `path`.
+  #
+  # NOTE: Results are cached.
   def self.from_file(path)
     cache.fetch(path) do |p|
       content = File.read(p)
@@ -77,39 +69,139 @@ def self.from_file_content(content, path)
       raise e, "Cannot parse #{path}: #{e}", e.backtrace
     end
     attributes["tabfile"] = path
-    attributes["source_modified_time"] ||= 0
-    attributes["source"] ||= {}
 
-    tapped_from = attributes["tapped_from"]
-    if !tapped_from.nil? && tapped_from != "path or URL"
-      attributes["source"]["tap"] = attributes.delete("tapped_from")
-    end
+    new(attributes)
+  end
 
-    if attributes["source"]["tap"] == "mxcl/master" ||
-       attributes["source"]["tap"] == "Homebrew/homebrew"
-      attributes["source"]["tap"] = "homebrew/core"
-    end
+  def self.empty
+    attributes = {
+      "homebrew_version"        => HOMEBREW_VERSION,
+      "installed_as_dependency" => false,
+      "installed_on_request"    => false,
+      "loaded_from_api"         => false,
+      "time"                    => nil,
+      "runtime_dependencies"    => nil,
+      "arch"                    => nil,
+      "source"                  => {
+        "path"         => nil,
+        "tap"          => nil,
+        "tap_git_head" => nil,
+      },
+      "built_on"                => DevelopmentTools.build_system_info,
+    }
+
+    new(attributes)
+  end
+
+  def self.formula_to_dep_hash(formula, declared_deps)
+    {
+      "full_name"         => formula.full_name,
+      "version"           => formula.version.to_s,
+      "revision"          => formula.revision,
+      "pkg_version"       => formula.pkg_version.to_s,
+      "declared_directly" => declared_deps.include?(formula.full_name),
+    }
+  end
+  private_class_method :formula_to_dep_hash
+
+  def initialize(attributes = {})
+    attributes.each { |key, value| instance_variable_set(:"@#{key}", value) }
+  end
+
+  def parsed_homebrew_version
+    return Version::NULL if homebrew_version.nil?
+
+    Version.new(homebrew_version)
+  end
+
+  sig { returns(T.nilable(Tap)) }
+  def tap
+    tap_name = source["tap"]
+    Tap.fetch(tap_name) if tap_name
+  end
+
+  def tap=(tap)
+    tap_name = tap.respond_to?(:name) ? tap.name : tap
+    source["tap"] = tap_name
+  end
+
+  def write
+    self.class.cache[tabfile] = self
+    tabfile.atomic_write(to_json)
+  end
+end
+
+class Tab < AbstractTab
+  # Check whether the formula was poured from a bottle.
+  #
+  # @api internal
+  attr_accessor :poured_from_bottle
 
-    if attributes["source"]["spec"].nil?
-      version = PkgVersion.parse path.to_s.split("/").second_to_last
-      attributes["source"]["spec"] = if version.head?
+  attr_accessor :built_as_bottle, :changed_files, :stdlib, :aliases
+  attr_writer :used_options, :unused_options, :compiler, :source_modified_time
+  attr_reader :tapped_from
+
+  # Instantiates a {Tab} for a new installation of a formula.
+  def self.create(formula, compiler, stdlib)
+    tab = super(formula)
+    build = formula.build
+    runtime_deps = formula.runtime_dependencies(undeclared: false)
+
+    tab.used_options = build.used_options.as_flags
+    tab.unused_options = build.unused_options.as_flags
+    tab.tabfile = formula.prefix/FILENAME
+    tab.built_as_bottle = build.bottle?
+    tab.poured_from_bottle = false
+    tab.source_modified_time = formula.source_modified_time.to_i
+    tab.compiler = compiler
+    tab.stdlib = stdlib
+    tab.aliases = formula.aliases
+    tab.runtime_dependencies = Tab.runtime_deps_hash(formula, runtime_deps)
+    tab.source["spec"] = formula.active_spec_sym.to_s
+    tab.source["path"] = formula.specified_path.to_s
+    tab.source["versions"] = {
+      "stable"         => formula.stable&.version&.to_s,
+      "head"           => formula.head&.version&.to_s,
+      "version_scheme" => formula.version_scheme,
+    }
+
+    tab
+  end
+
+  # Like {from_file}, but bypass the cache.
+  def self.from_file_content(content, path)
+    tab = super
+
+    tab.source_modified_time ||= 0
+    tab.source ||= {}
+
+    tab.tap = tab.tapped_from if !tab.tapped_from.nil? && tab.tapped_from != "path or URL"
+    tab.tap = "homebrew/core" if tab.tap == "mxcl/master" || tab.tap == "Homebrew/homebrew"
+
+    if tab.source["spec"].nil?
+      version = PkgVersion.parse(File.basename(File.dirname(path)))
+      tab.source["spec"] = if version.head?
         "head"
       else
         "stable"
       end
     end
 
-    if attributes["source"]["versions"].nil?
-      attributes["source"]["versions"] = {
-        "stable"         => nil,
-        "head"           => nil,
-        "version_scheme" => 0,
-      }
+    tab.source["versions"] ||= empty_source_versions
+
+    # Tabs created with Homebrew 1.5.13 through 4.0.17 inclusive created empty string versions in some cases.
+    ["stable", "head"].each do |spec|
+      tab.source["versions"][spec] = tab.source["versions"][spec].presence
     end
 
-    new(attributes)
+    tab
   end
 
+  # Get the {Tab} for the given {Keg},
+  # or a fake one if the formula is not installed.
+  #
+  # @api internal
+  sig { params(keg: T.any(Keg, Pathname)).returns(T.attached_class) }
   def self.for_keg(keg)
     path = keg/FILENAME
 
@@ -119,7 +211,7 @@ def self.for_keg(keg)
       empty
     end
 
-    tab["tabfile"] = path
+    tab.tabfile = path
     tab
   end
 
@@ -142,37 +234,38 @@ def self.remap_deprecated_options(deprecated_options, options)
 
   # Returns a {Tab} for an already installed formula,
   # or a fake one if the formula is not installed.
-  def self.for_formula(f)
+  def self.for_formula(formula)
     paths = []
 
-    paths << f.opt_prefix.resolved_path if f.opt_prefix.symlink? && f.opt_prefix.directory?
+    paths << formula.opt_prefix.resolved_path if formula.opt_prefix.symlink? && formula.opt_prefix.directory?
 
-    paths << f.linked_keg.resolved_path if f.linked_keg.symlink? && f.linked_keg.directory?
+    paths << formula.linked_keg.resolved_path if formula.linked_keg.symlink? && formula.linked_keg.directory?
 
-    if (dirs = f.installed_prefixes).length == 1
+    if (dirs = formula.installed_prefixes).length == 1
       paths << dirs.first
     end
 
-    paths << f.latest_installed_prefix
+    paths << formula.latest_installed_prefix
 
-    path = paths.map { |pn| pn/FILENAME }.find(&:file?)
+    path = paths.map { |pathname| pathname/FILENAME }.find(&:file?)
 
     if path
       tab = from_file(path)
-      used_options = remap_deprecated_options(f.deprecated_options, tab.used_options)
+      used_options = remap_deprecated_options(formula.deprecated_options, tab.used_options)
       tab.used_options = used_options.as_flags
     else
       # Formula is not installed. Return a fake tab.
       tab = empty
-      tab.unused_options = f.options.as_flags
+      tab.unused_options = formula.options.as_flags
       tab.source = {
-        "path"     => f.specified_path.to_s,
-        "tap"      => f.tap&.name,
-        "spec"     => f.active_spec_sym.to_s,
-        "versions" => {
-          "stable"         => f.stable&.version.to_s,
-          "head"           => f.head&.version.to_s,
-          "version_scheme" => f.version_scheme,
+        "path"         => formula.specified_path.to_s,
+        "tap"          => formula.tap&.name,
+        "tap_git_head" => formula.tap_git_head,
+        "spec"         => formula.active_spec_sym.to_s,
+        "versions"     => {
+          "stable"         => formula.stable&.version&.to_s,
+          "head"           => formula.head&.version&.to_s,
+          "version_scheme" => formula.version_scheme,
         },
       }
     end
@@ -181,46 +274,34 @@ def self.for_formula(f)
   end
 
   def self.empty
-    attributes = {
-      "homebrew_version"        => HOMEBREW_VERSION,
-      "used_options"            => [],
-      "unused_options"          => [],
-      "built_as_bottle"         => false,
-      "installed_as_dependency" => false,
-      "installed_on_request"    => false,
-      "poured_from_bottle"      => false,
-      "time"                    => nil,
-      "source_modified_time"    => 0,
-      "stdlib"                  => nil,
-      "compiler"                => DevelopmentTools.default_compiler,
-      "aliases"                 => [],
-      "runtime_dependencies"    => nil,
-      "arch"                    => nil,
-      "source"                  => {
-        "path"         => nil,
-        "tap"          => nil,
-        "tap_git_head" => nil,
-        "spec"         => "stable",
-        "versions"     => {
-          "stable"         => nil,
-          "head"           => nil,
-          "version_scheme" => 0,
-        },
-      },
-      "built_on"                => DevelopmentTools.generic_build_system_info,
-    }
+    tab = super
+
+    tab.used_options = []
+    tab.unused_options = []
+    tab.built_as_bottle = false
+    tab.poured_from_bottle = false
+    tab.source_modified_time = 0
+    tab.stdlib = nil
+    tab.compiler = DevelopmentTools.default_compiler
+    tab.aliases = []
+    tab.source["spec"] = "stable"
+    tab.source["versions"] = empty_source_versions
 
-    new(attributes)
+    tab
+  end
+
+  def self.empty_source_versions
+    {
+      "stable"         => nil,
+      "head"           => nil,
+      "version_scheme" => 0,
+    }
   end
+  private_class_method :empty_source_versions
 
   def self.runtime_deps_hash(formula, deps)
     deps.map do |dep|
-      f = dep.to_formula
-      {
-        "full_name"         => f.full_name,
-        "version"           => f.version.to_s,
-        "declared_directly" => formula.deps.include?(dep),
-      }
+      formula_to_dep_hash(dep.to_formula, formula.deps.map(&:name))
     end
   end
 
@@ -252,28 +333,26 @@ def stable?
     spec == :stable
   end
 
+  # The options used to install the formula.
+  #
+  # @api internal
+  sig { returns(Options) }
   def used_options
-    Options.create(super)
+    Options.create(@used_options)
   end
 
   def unused_options
-    Options.create(super)
+    Options.create(@unused_options)
   end
 
   def compiler
-    super || DevelopmentTools.default_compiler
-  end
-
-  def parsed_homebrew_version
-    return Version::NULL if homebrew_version.nil?
-
-    Version.new(homebrew_version)
+    @compiler || DevelopmentTools.default_compiler
   end
 
   def runtime_dependencies
     # Homebrew versions prior to 1.1.6 generated incorrect runtime dependency
     # lists.
-    super unless parsed_homebrew_version < "1.1.6"
+    @runtime_dependencies if parsed_homebrew_version >= "1.1.6"
   end
 
   def cxxstdlib
@@ -290,16 +369,6 @@ def bottle?
     built_as_bottle
   end
 
-  def tap
-    tap_name = source["tap"]
-    Tap.fetch(tap_name) if tap_name
-  end
-
-  def tap=(tap)
-    tap_name = tap.respond_to?(:name) ? tap.name : tap
-    source["tap"] = tap_name
-  end
-
   def spec
     source["spec"].to_sym
   end
@@ -309,11 +378,11 @@ def versions
   end
 
   def stable_version
-    Version.create(versions["stable"]) if versions["stable"]
+    versions["stable"]&.then { Version.new(_1) }
   end
 
   def head_version
-    Version.create(versions["head"]) if versions["head"]
+    versions["head"]&.then { Version.new(_1) }
   end
 
   def version_scheme
@@ -322,7 +391,7 @@ def version_scheme
 
   sig { returns(Time) }
   def source_modified_time
-    Time.at(super || 0)
+    Time.at(@source_modified_time || 0)
   end
 
   def to_json(options = nil)
@@ -332,6 +401,7 @@ def to_json(options = nil)
       "unused_options"          => unused_options.as_flags,
       "built_as_bottle"         => built_as_bottle,
       "poured_from_bottle"      => poured_from_bottle,
+      "loaded_from_api"         => loaded_from_api,
       "installed_as_dependency" => installed_as_dependency,
       "installed_on_request"    => installed_on_request,
       "changed_files"           => changed_files&.map(&:to_s),
@@ -350,7 +420,7 @@ def to_json(options = nil)
     JSON.pretty_generate(attributes, options)
   end
 
-  # a subset of to_json that we care about for bottles
+  # A subset of to_json that we care about for bottles.
   def to_bottle_hash
     attributes = {
       "homebrew_version"     => homebrew_version,
@@ -371,8 +441,7 @@ def write
     # will no longer be valid.
     Formula.clear_cache unless tabfile.exist?
 
-    self.class.cache[tabfile] = self
-    tabfile.atomic_write(to_json)
+    super
   end
 
   sig { returns(String) }
@@ -384,6 +453,7 @@ def to_s
       "Built from source"
     end
 
+    s << "using the formulae.brew.sh API" if loaded_from_api
     s << Time.at(time).strftime("on %Y-%m-%d at %H:%M:%S") if time
 
     unless used_options.empty?
diff --git a/Library/Homebrew/tap.rb b/Library/Homebrew/tap.rb
index 7a2fba9256bbd..9aeaa6f8b4279 100644
--- a/Library/Homebrew/tap.rb
+++ b/Library/Homebrew/tap.rb
@@ -1,152 +1,291 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "api"
 require "commands"
-require "completions"
-require "extend/cachable"
-require "description_cache_store"
 require "settings"
 
 # A {Tap} is used to extend the formulae provided by Homebrew core.
 # Usually, it's synced with a remote Git repository. And it's likely
-# a GitHub repository with the name of `user/homebrew-repo`. In such
-# cases, `user/repo` will be used as the {#name} of this {Tap}, where
-# {#user} represents the GitHub username and {#repo} represents the repository
-# name without the leading `homebrew-`.
+# a GitHub repository with the name of `user/homebrew-repository`. In such
+# cases, `user/repository` will be used as the {#name} of this {Tap}, where
+# {#user} represents the GitHub username and {#repository} represents the
+# repository name without the leading `homebrew-`.
 class Tap
-  extend T::Sig
-
   extend Cachable
 
-  TAP_DIRECTORY = (HOMEBREW_LIBRARY/"Taps").freeze
-
+  HOMEBREW_TAP_CASK_RENAMES_FILE = "cask_renames.json"
+  private_constant :HOMEBREW_TAP_CASK_RENAMES_FILE
   HOMEBREW_TAP_FORMULA_RENAMES_FILE = "formula_renames.json"
+  private_constant :HOMEBREW_TAP_FORMULA_RENAMES_FILE
   HOMEBREW_TAP_MIGRATIONS_FILE = "tap_migrations.json"
+  private_constant :HOMEBREW_TAP_MIGRATIONS_FILE
+  HOMEBREW_TAP_AUTOBUMP_FILE = ".github/autobump.txt"
+  private_constant :HOMEBREW_TAP_AUTOBUMP_FILE
+  HOMEBREW_TAP_PYPI_FORMULA_MAPPINGS_FILE = "pypi_formula_mappings.json"
+  private_constant :HOMEBREW_TAP_PYPI_FORMULA_MAPPINGS_FILE
+  HOMEBREW_TAP_SYNCED_VERSIONS_FORMULAE_FILE = "synced_versions_formulae.json"
+  private_constant :HOMEBREW_TAP_SYNCED_VERSIONS_FORMULAE_FILE
   HOMEBREW_TAP_AUDIT_EXCEPTIONS_DIR = "audit_exceptions"
+  private_constant :HOMEBREW_TAP_AUDIT_EXCEPTIONS_DIR
   HOMEBREW_TAP_STYLE_EXCEPTIONS_DIR = "style_exceptions"
-  HOMEBREW_TAP_PYPI_FORMULA_MAPPINGS = "pypi_formula_mappings.json"
+  private_constant :HOMEBREW_TAP_STYLE_EXCEPTIONS_DIR
+
+  TAP_MIGRATIONS_STALE_SECONDS = 86400 # 1 day
+  private_constant :TAP_MIGRATIONS_STALE_SECONDS
 
   HOMEBREW_TAP_JSON_FILES = %W[
     #{HOMEBREW_TAP_FORMULA_RENAMES_FILE}
+    #{HOMEBREW_TAP_CASK_RENAMES_FILE}
     #{HOMEBREW_TAP_MIGRATIONS_FILE}
+    #{HOMEBREW_TAP_PYPI_FORMULA_MAPPINGS_FILE}
+    #{HOMEBREW_TAP_SYNCED_VERSIONS_FORMULAE_FILE}
     #{HOMEBREW_TAP_AUDIT_EXCEPTIONS_DIR}/*.json
     #{HOMEBREW_TAP_STYLE_EXCEPTIONS_DIR}/*.json
-    #{HOMEBREW_TAP_PYPI_FORMULA_MAPPINGS}
   ].freeze
 
-  def self.fetch(*args)
-    case args.length
-    when 1
-      user, repo = args.first.split("/", 2)
-    when 2
-      user = args.first
-      repo = args.second
+  class InvalidNameError < ArgumentError; end
+
+  # Fetch a {Tap} by name.
+  #
+  # @api public
+  sig { params(user: String, repository: String).returns(Tap) }
+  def self.fetch(user, repository = T.unsafe(nil))
+    user, repository = user.split("/", 2) if repository.nil?
+
+    if [user, repository].any? { |part| part.nil? || part.include?("/") }
+      raise InvalidNameError, "Invalid tap name: '#{[*user, *repository].join("/")}'"
     end
 
-    raise "Invalid tap name '#{args.join("/")}'" if [user, repo].any? { |part| part.nil? || part.include?("/") }
+    user = T.must(user)
+    repository = T.must(repository)
 
     # We special case homebrew and linuxbrew so that users don't have to shift in a terminal.
-    user = user.capitalize if ["homebrew", "linuxbrew"].include? user
-    repo = repo.sub(HOMEBREW_OFFICIAL_REPO_PREFIXES_REGEX, "")
+    user = user.capitalize if ["homebrew", "linuxbrew"].include?(user)
+    repository = repository.sub(HOMEBREW_OFFICIAL_REPO_PREFIXES_REGEX, "")
 
-    return CoreTap.instance if ["Homebrew", "Linuxbrew"].include?(user) && ["core", "homebrew"].include?(repo)
+    return CoreTap.instance if ["Homebrew", "Linuxbrew"].include?(user) && ["core", "homebrew"].include?(repository)
+    return CoreCaskTap.instance if user == "Homebrew" && repository == "cask"
 
-    cache_key = "#{user}/#{repo}".downcase
-    cache.fetch(cache_key) { |key| cache[key] = Tap.new(user, repo) }
+    cache_key = "#{user}/#{repository}".downcase
+    cache.fetch(cache_key) { |key| cache[key] = new(user, repository) }
   end
 
+  # Get a {Tap} from its path or a path inside of it.
+  #
+  # @api public
   def self.from_path(path)
     match = File.expand_path(path).match(HOMEBREW_TAP_PATH_REGEX)
-    return if match.blank? || match[:user].blank? || match[:repo].blank?
 
-    fetch(match[:user], match[:repo])
+    return unless match
+    return unless (user = match[:user])
+    return unless (repository = match[:repository])
+
+    fetch(user, repository)
   end
 
-  sig { returns(T.attached_class) }
-  def self.default_cask_tap
-    @default_cask_tap ||= fetch("Homebrew", "cask")
+  sig { params(name: String).returns(T.nilable([Tap, String])) }
+  def self.with_formula_name(name)
+    return unless (match = name.match(HOMEBREW_TAP_FORMULA_REGEX))
+
+    user = T.must(match[:user])
+    repository = T.must(match[:repository])
+    name = T.must(match[:name])
+
+    # Relative paths are not taps.
+    return if [user, repository].intersect?([".", ".."])
+
+    tap = fetch(user, repository)
+    [tap, name.downcase]
   end
 
-  sig { params(force: T::Boolean).returns(T::Boolean) }
-  def self.install_default_cask_tap_if_necessary(force: false)
-    false
+  sig { params(token: String).returns(T.nilable([Tap, String])) }
+  def self.with_cask_token(token)
+    return unless (match = token.match(HOMEBREW_TAP_CASK_REGEX))
+
+    user = T.must(match[:user])
+    repository = T.must(match[:repository])
+    token = T.must(match[:token])
+
+    # Relative paths are not taps.
+    return if [user, repository].intersect?([".", ".."])
+
+    tap = fetch(user, repository)
+    [tap, token.downcase]
+  end
+
+  sig { returns(T::Set[Tap]) }
+  def self.allowed_taps
+    cache_key = :"allowed_taps_#{Homebrew::EnvConfig.allowed_taps.to_s.tr(" ", "_")}"
+    cache[cache_key] ||= begin
+      allowed_tap_list = Homebrew::EnvConfig.allowed_taps.to_s.split
+
+      Set.new(allowed_tap_list.filter_map do |tap|
+        Tap.fetch(tap)
+      rescue Tap::InvalidNameError
+        opoo "Invalid tap name in `HOMEBREW_ALLOWED_TAPS`: #{tap}"
+        nil
+      end).freeze
+    end
+  end
+
+  sig { returns(T::Set[Tap]) }
+  def self.forbidden_taps
+    cache_key = :"forbidden_taps_#{Homebrew::EnvConfig.forbidden_taps.to_s.tr(" ", "_")}"
+    cache[cache_key] ||= begin
+      forbidden_tap_list = Homebrew::EnvConfig.forbidden_taps.to_s.split
+
+      Set.new(forbidden_tap_list.filter_map do |tap|
+        Tap.fetch(tap)
+      rescue Tap::InvalidNameError
+        opoo "Invalid tap name in `HOMEBREW_FORBIDDEN_TAPS`: #{tap}"
+        nil
+      end).freeze
+    end
   end
 
+  # @api public
   extend Enumerable
 
   # The user name of this {Tap}. Usually, it's the GitHub username of
   # this {Tap}'s remote repository.
+  #
+  # @api public
   attr_reader :user
 
   # The repository name of this {Tap} without the leading `homebrew-`.
-  attr_reader :repo
+  #
+  # @api public
+  attr_reader :repository
+
+  # @deprecated
+  sig { returns(T::Boolean) }
+  def repo
+    # delete this whole function when removing odisabled
+    odeprecated "Tap#repo", "Tap#repository"
+    repository
+  end
 
-  # The name of this {Tap}. It combines {#user} and {#repo} with a slash.
+  # The name of this {Tap}. It combines {#user} and {#repository} with a slash.
   # {#name} is always in lowercase.
-  # e.g. `user/repo`
+  # e.g. `user/repository`
+  #
+  # @api public
   attr_reader :name
 
+  # @api public
+  sig { returns(String) }
+  def to_s = name
+
   # The full name of this {Tap}, including the `homebrew-` prefix.
-  # It combines {#user} and 'homebrew-'-prefixed {#repo} with a slash.
-  # e.g. `user/homebrew-repo`
+  # It combines {#user} and 'homebrew-'-prefixed {#repository} with a slash.
+  # e.g. `user/homebrew-repository`
+  #
+  # @api public
   attr_reader :full_name
 
   # The local path to this {Tap}.
-  # e.g. `/usr/local/Library/Taps/user/homebrew-repo`
+  # e.g. `/usr/local/Library/Taps/user/homebrew-repository`
+  #
+  # @api public
+  sig { returns(Pathname) }
   attr_reader :path
 
-  # @private
-  def initialize(user, repo)
+  # The git repository of this {Tap}.
+  sig { returns(GitRepository) }
+  attr_reader :git_repository
+
+  # Always use `Tap.fetch` instead of `Tap.new`.
+  private_class_method :new
+
+  def initialize(user, repository)
+    require "git_repository"
+
     @user = user
-    @repo = repo
-    @name = "#{@user}/#{@repo}".downcase
-    @full_name = "#{@user}/homebrew-#{@repo}"
-    @path = TAP_DIRECTORY/@full_name.downcase
-    @path.extend(GitRepositoryExtension)
-    @alias_table = nil
-    @alias_reverse_table = nil
+    @repository = repository
+    @name = "#{@user}/#{@repository}".downcase
+    @full_name = "#{@user}/homebrew-#{@repository}"
+    @path = HOMEBREW_TAP_DIRECTORY/@full_name.downcase
+    @git_repository = GitRepository.new(@path)
   end
 
   # Clear internal cache.
   def clear_cache
     @remote = nil
-    @repo_var = nil
+    @repository_var_suffix = nil
+    remove_instance_variable(:@private) if instance_variable_defined?(:@private)
+
     @formula_dir = nil
-    @cask_dir = nil
-    @command_dir = nil
     @formula_files = nil
+    @formula_files_by_name = nil
+    @formula_names = nil
+    @prefix_to_versioned_formulae_names = nil
+    @formula_renames = nil
+    @formula_reverse_renames = nil
+
+    @cask_dir = nil
+    @cask_files = nil
+    @cask_files_by_name = nil
+    @cask_tokens = nil
+    @cask_renames = nil
+    @cask_reverse_renames = nil
+
     @alias_dir = nil
     @alias_files = nil
     @aliases = nil
     @alias_table = nil
     @alias_reverse_table = nil
+
+    @command_dir = nil
     @command_files = nil
-    @formula_renames = nil
+
     @tap_migrations = nil
+    @reverse_tap_migrations_renames = nil
+
     @audit_exceptions = nil
     @style_exceptions = nil
     @pypi_formula_mappings = nil
+    @synced_versions_formulae = nil
+
     @config = nil
     @spell_checker = nil
-    remove_instance_variable(:@private) if instance_variable_defined?(:@private)
+  end
+
+  sig { void }
+  def ensure_installed!
+    return if installed?
+
+    install
   end
 
   # The remote path to this {Tap}.
-  # e.g. `https://github.com/user/homebrew-repo`
+  # e.g. `https://github.com/user/homebrew-repository`
+  #
+  # @api public
   def remote
-    raise TapUnavailableError, name unless installed?
+    return default_remote unless installed?
 
-    @remote ||= path.git_origin
+    @remote ||= git_repository.origin_url
   end
 
   # The remote repository name of this {Tap}.
-  # e.g. `user/homebrew-repo`
-  def remote_repo
-    return unless remote
+  # e.g. `user/homebrew-repository`
+  #
+  # @api public
+  sig { returns(T.nilable(String)) }
+  def remote_repository
+    return unless (remote = self.remote)
+    return unless (match = remote.match(HOMEBREW_TAP_REPOSITORY_REGEX))
 
-    @remote_repo ||= remote.delete_prefix("https://github.com/")
-                           .delete_prefix("git@github.com:")
-                           .delete_suffix(".git")
+    @remote_repository ||= T.must(match[:remote_repository])
+  end
+
+  # @deprecated
+  sig { returns(T.nilable(String)) }
+  def remote_repo
+    # delete this whole function when removing odisabled
+    odeprecated "Tap#remote_repo", "Tap#remote_repository"
+    remote_repository
   end
 
   # The default remote path to this {Tap}.
@@ -155,41 +294,60 @@ def default_remote
     "https://github.com/#{full_name}"
   end
 
-  def repo_var
-    @repo_var ||= path.to_s
-                      .delete_prefix(TAP_DIRECTORY.to_s)
-                      .tr("^A-Za-z0-9", "_")
-                      .upcase
+  sig { returns(String) }
+  def repository_var_suffix
+    @repository_var_suffix ||= path.to_s
+                                   .delete_prefix(HOMEBREW_TAP_DIRECTORY.to_s)
+                                   .tr("^A-Za-z0-9", "_")
+                                   .upcase
+  end
+
+  # @deprecated
+  sig { returns(String) }
+  def repo_var_suffix
+    # delete this whole function when removing odisabled
+    odeprecated "Tap#repo_var_suffix", "Tap#repository_var_suffix"
+    repository_var_suffix
   end
 
-  # True if this {Tap} is a Git repository.
+  # Check whether this {Tap} is a Git repository.
+  #
+  # @api public
   def git?
-    path.git?
+    git_repository.git_repository?
   end
 
-  # git branch for this {Tap}.
+  # Git branch for this {Tap}.
+  #
+  # @api public
   def git_branch
     raise TapUnavailableError, name unless installed?
 
-    path.git_branch
+    git_repository.branch_name
   end
 
-  # git HEAD for this {Tap}.
+  # Git HEAD for this {Tap}.
+  #
+  # @api public
   def git_head
     raise TapUnavailableError, name unless installed?
 
-    path.git_head
+    @git_head ||= git_repository.head_ref
   end
 
   # Time since last git commit for this {Tap}.
+  #
+  # @api public
   def git_last_commit
     raise TapUnavailableError, name unless installed?
 
-    path.git_last_commit
+    git_repository.last_committed
   end
 
   # The issues URL of this {Tap}.
-  # e.g. `https://github.com/user/homebrew-repo/issues`
+  # e.g. `https://github.com/user/homebrew-repository/issues`
+  #
+  # @api public
   sig { returns(T.nilable(String)) }
   def issues_url
     return if !official? && custom_remote?
@@ -197,23 +355,42 @@ def issues_url
     "#{default_remote}/issues"
   end
 
-  def to_s
-    name
-  end
-
-  # True if this {Tap} is an official Homebrew tap.
+  # Check whether this {Tap} is an official Homebrew tap.
+  #
+  # @api public
   def official?
     user == "Homebrew"
   end
 
-  # True if the remote of this {Tap} is a private repository.
+  # Check whether the remote of this {Tap} is a private repository.
+  #
+  # @api public
+  sig { returns(T::Boolean) }
   def private?
-    return @private if instance_variable_defined?(:@private)
+    return @private if defined?(@private)
+
+    @private = if (value = config[:private]).nil?
+      config[:private] = begin
+        if custom_remote?
+          true
+        else
+          # Don't store config if we don't know for sure.
+          return false if (value = GitHub.private_repo?(full_name)).nil?
 
-    @private = read_or_set_private_config
+          value
+        end
+      rescue GitHub::API::HTTPNotFoundError
+        true
+      rescue GitHub::API::Error
+        false
+      end
+    else
+      value
+    end
   end
 
   # {TapConfig} of this {Tap}.
+  sig { returns(TapConfig) }
   def config
     @config ||= begin
       raise TapUnavailableError, name unless installed?
@@ -222,38 +399,48 @@ def config
     end
   end
 
-  # True if this {Tap} has been installed.
+  # Check whether this {Tap} is installed.
+  #
+  # @api public
+  sig { returns(T::Boolean) }
   def installed?
     path.directory?
   end
 
-  # True if this {Tap} is not a full clone.
+  # Check whether this {Tap} is a shallow clone.
   def shallow?
     (path/".git/shallow").exist?
   end
 
-  # @private
   sig { returns(T::Boolean) }
   def core_tap?
     false
   end
 
+  sig { returns(T::Boolean) }
+  def core_cask_tap?
+    false
+  end
+
   # Install this {Tap}.
   #
   # @param clone_target [String] If passed, it will be used as the clone remote.
-  # @param force_auto_update [Boolean, nil] If present, whether to override the
-  #   logic that skips non-GitHub repositories during auto-updates.
   # @param quiet [Boolean] If set, suppress all output.
   # @param custom_remote [Boolean] If set, change the tap's remote if already installed.
-  def install(quiet: false, clone_target: nil, force_auto_update: nil, custom_remote: false)
+  # @param verify [Boolean] If set, verify all the formula, casks and aliases in the tap are valid.
+  # @param force [Boolean] If set, force core and cask taps to install even under API mode.
+  #
+  # @api public
+  def install(quiet: false, clone_target: nil,
+              custom_remote: false, verify: false, force: false)
     require "descriptions"
     require "readall"
 
-    if official? && DEPRECATED_OFFICIAL_TAPS.include?(repo)
+    if official? && DEPRECATED_OFFICIAL_TAPS.include?(repository)
       odie "#{name} was deprecated. This tap is now empty and all its contents were either deleted or migrated."
     elsif user == "caskroom" || name == "phinze/cask"
-      new_repo = repo == "cask" ? "cask" : "cask-#{repo}"
-      odie "#{name} was moved. Tap homebrew/#{new_repo} instead."
+      new_repository = (repository == "cask") ? "cask" : "cask-#{repository}"
+      odie "#{name} was moved. Tap homebrew/#{new_repository} instead."
     end
 
     raise TapNoCustomRemoteError, name if custom_remote && clone_target.nil?
@@ -262,7 +449,22 @@ def install(quiet: false, clone_target: nil, force_auto_update: nil, custom_remo
 
     if installed? && !custom_remote
       raise TapRemoteMismatchError.new(name, @remote, requested_remote) if clone_target && requested_remote != remote
-      raise TapAlreadyTappedError, name if force_auto_update.nil? && !shallow?
+      raise TapAlreadyTappedError, name unless shallow?
+    end
+
+    if !allowed_by_env? || forbidden_by_env?
+      owner = Homebrew::EnvConfig.forbidden_owner
+      owner_contact = if (contact = Homebrew::EnvConfig.forbidden_owner_contact.presence)
+        "\n#{contact}"
+      end
+
+      error_message = "The installation of the #{full_name} was requested but #{owner}\n"
+      error_message << "has not allowed this tap in `HOMEBREW_ALLOWED_TAPS`" unless allowed_by_env?
+      error_message << " and\n" if !allowed_by_env? && forbidden_by_env?
+      error_message << "has forbidden this tap in `HOMEBREW_FORBIDDEN_TAPS`" if forbidden_by_env?
+      error_message << ".#{owner_contact}"
+
+      odie error_message
     end
 
     # ensure git is installed
@@ -270,17 +472,10 @@ def install(quiet: false, clone_target: nil, force_auto_update: nil, custom_remo
 
     if installed?
       if requested_remote != remote # we are sure that clone_target is not nil and custom_remote is true here
-        fix_remote_configuration(requested_remote: requested_remote, quiet: quiet)
+        fix_remote_configuration(requested_remote:, quiet:)
       end
 
-      unless force_auto_update.nil?
-        if force_auto_update
-          config["forceautoupdate"] = force_auto_update
-        elsif config["forceautoupdate"] == "true"
-          config.delete("forceautoupdate")
-        end
-        return
-      end
+      config.delete(:forceautoupdate)
 
       $stderr.ohai "Unshallowing #{name}" if shallow? && !quiet
       args = %w[fetch]
@@ -289,9 +484,13 @@ def install(quiet: false, clone_target: nil, force_auto_update: nil, custom_remo
       args << "-q" if quiet
       path.cd { safe_system "git", *args }
       return
+    elsif (core_tap? || core_cask_tap?) && !Homebrew::EnvConfig.no_install_from_api? && !force
+      odie "Tapping #{name} is no longer typically necessary.\n" \
+           "Add #{Formatter.option("--force")} if you are sure you need it for contributing to Homebrew."
     end
 
     clear_cache
+    Tap.clear_cache
 
     $stderr.ohai "Tapping #{name}" unless quiet
     args =  %W[clone #{requested_remote} #{path}]
@@ -301,14 +500,15 @@ def install(quiet: false, clone_target: nil, force_auto_update: nil, custom_remo
     args << "--origin=origin"
     args << "-q" if quiet
 
-    # Override user-set default template
+    # Override user-set default template.
     args << "--template="
+    # Prevent `fsmonitor` from watching this repository.
+    args << "--config" << "core.fsmonitor=false"
 
     begin
       safe_system "git", *args
-      # TODO: 3.6.0: consider if we want to actually read all contents of tap or odeprecate.
 
-      if !Readall.valid_tap?(self, aliases: true) && !Homebrew::EnvConfig.developer?
+      if verify && !Homebrew::EnvConfig.developer? && !Readall.valid_tap?(self, aliases: true)
         raise "Cannot tap #{name}: invalid syntax in tap!"
       end
     rescue Interrupt, RuntimeError
@@ -321,13 +521,13 @@ def install(quiet: false, clone_target: nil, force_auto_update: nil, custom_remo
       raise
     end
 
-    config["forceautoupdate"] = force_auto_update unless force_auto_update.nil?
-
     Commands.rebuild_commands_completion_list
     link_completions_and_manpages
 
     formatted_contents = contents.presence&.to_sentence&.dup&.prepend(" ")
     $stderr.puts "Tapped#{formatted_contents} (#{path.abv})." unless quiet
+
+    require "description_cache_store"
     CacheStoreDatabase.use(:descriptions) do |db|
       DescriptionCacheStore.new(db)
                            .update_from_formula_names!(formula_names)
@@ -366,9 +566,12 @@ def install(quiet: false, clone_target: nil, force_auto_update: nil, custom_remo
   end
 
   def link_completions_and_manpages
+    require "utils/link"
+
     command = "brew tap --repair"
     Utils::Link.link_manpages(path, command)
 
+    require "completions"
     Homebrew::Completions.show_completions_message_if_needed
     if official? || Homebrew::Completions.link_completions?
       Utils::Link.link_completions(path, command)
@@ -385,21 +588,24 @@ def fix_remote_configuration(requested_remote: nil, quiet: false)
       end
       $stderr.ohai "#{name}: changed remote from #{remote} to #{requested_remote}" unless quiet
     end
+    return unless remote
 
-    current_upstream_head = path.git_origin_branch
-    return if requested_remote.blank? && path.git_origin_has_branch?(current_upstream_head)
+    current_upstream_head = T.must(git_repository.origin_branch_name)
+    return if requested_remote.blank? && git_repository.origin_has_branch?(current_upstream_head)
 
     args = %w[fetch]
     args << "--quiet" if quiet
     args << "origin"
+    args << "+refs/heads/*:refs/remotes/origin/*"
     safe_system "git", "-C", path, *args
-    path.git_origin_set_head_auto
+    git_repository.set_head_origin_auto
 
-    new_upstream_head = path.git_origin_branch
+    new_upstream_head = T.must(git_repository.origin_branch_name)
     return if new_upstream_head == current_upstream_head
 
-    path.git_rename_branch old: current_upstream_head, new: new_upstream_head
-    path.git_branch_set_upstream local: new_upstream_head, origin: new_upstream_head
+    safe_system "git", "-C", path, "config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"
+    git_repository.rename_branch old: current_upstream_head, new: new_upstream_head
+    git_repository.set_upstream_branch local: new_upstream_head, origin: new_upstream_head
 
     return if quiet
 
@@ -407,6 +613,8 @@ def fix_remote_configuration(requested_remote: nil, quiet: false)
   end
 
   # Uninstall this {Tap}.
+  #
+  # @api public
   def uninstall(manual: false)
     require "descriptions"
     raise TapUnavailableError, name unless installed?
@@ -416,7 +624,7 @@ def uninstall(manual: false)
     abv = path.abv
     formatted_contents = contents.presence&.to_sentence&.dup&.prepend(" ")
 
-    unpin if pinned?
+    require "description_cache_store"
     CacheStoreDatabase.use(:descriptions) do |db|
       DescriptionCacheStore.new(db)
                            .delete_from_formula_names!(formula_names)
@@ -425,14 +633,17 @@ def uninstall(manual: false)
       CaskDescriptionCacheStore.new(db)
                                .delete_from_cask_tokens!(cask_tokens)
     end
+
+    require "utils/link"
     Utils::Link.unlink_manpages(path)
     Utils::Link.unlink_completions(path)
-    path.rmtree
+    FileUtils.rm_r(path)
     path.parent.rmdir_if_possible
     $stderr.puts "Untapped#{formatted_contents} (#{abv})."
 
     Commands.rebuild_commands_completion_list
     clear_cache
+    Tap.clear_cache
 
     return if !manual || !official?
 
@@ -443,145 +654,224 @@ def uninstall(manual: false)
     Homebrew::Settings.write :untapped, untapped.join(";")
   end
 
-  # True if the {#remote} of {Tap} is customized.
+  # Check whether the {#remote} of {Tap} is customized.
+  #
+  # @api public
+  sig { returns(T::Boolean) }
   def custom_remote?
-    return true unless remote
+    return true unless (remote = self.remote)
 
-    remote.casecmp(default_remote).nonzero?
+    !remote.casecmp(default_remote).zero?
   end
 
   # Path to the directory of all {Formula} files for this {Tap}.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def formula_dir
-    @formula_dir ||= potential_formula_dirs.find(&:directory?) || (path/"Formula")
+    # Official formulae taps always use this directory, saves time to hardcode.
+    @formula_dir ||= if official?
+      path/"Formula"
+    else
+      potential_formula_dirs.find(&:directory?) || (path/"Formula")
+    end
   end
 
+  sig { returns(T::Array[Pathname]) }
   def potential_formula_dirs
     @potential_formula_dirs ||= [path/"Formula", path/"HomebrewFormula", path].freeze
   end
 
+  sig { params(name: String).returns(Pathname) }
+  def new_formula_path(name)
+    formula_dir/"#{name.downcase}.rb"
+  end
+
   # Path to the directory of all {Cask} files for this {Tap}.
+  #
+  # @api public
+  sig { returns(Pathname) }
   def cask_dir
     @cask_dir ||= path/"Casks"
   end
 
+  sig { params(token: String).returns(Pathname) }
+  def new_cask_path(token)
+    cask_dir/"#{token.downcase}.rb"
+  end
+
+  sig { params(token: String).returns(String) }
+  def relative_cask_path(token)
+    new_cask_path(token).to_s
+                        .delete_prefix("#{path}/")
+  end
+
   def contents
     contents = []
 
     if (command_count = command_files.count).positive?
-      contents << "#{command_count} #{"command".pluralize(command_count)}"
+      contents << Utils.pluralize("command", command_count, include_count: true)
     end
 
     if (cask_count = cask_files.count).positive?
-      contents << "#{cask_count} #{"cask".pluralize(cask_count)}"
+      contents << Utils.pluralize("cask", cask_count, include_count: true)
     end
 
     if (formula_count = formula_files.count).positive?
-      contents << "#{formula_count} #{"formula".pluralize(formula_count)}"
+      contents << Utils.pluralize("formula", formula_count, plural: "e", include_count: true)
     end
 
     contents
   end
 
   # An array of all {Formula} files of this {Tap}.
+  sig { returns(T::Array[Pathname]) }
   def formula_files
     @formula_files ||= if formula_dir.directory?
-      formula_dir.children.select(&method(:ruby_file?))
+      if formula_dir == path
+        # We only want the top level here so we don't treat commands & casks as formulae.
+        # Sharding is only supported in Formula/ and HomebrewFormula/.
+        Pathname.glob(formula_dir/"*.rb")
+      else
+        Pathname.glob(formula_dir/"**/*.rb")
+      end
     else
       []
     end
   end
 
+  # A mapping of {Formula} names to {Formula} file paths.
+  sig { returns(T::Hash[String, Pathname]) }
+  def formula_files_by_name
+    @formula_files_by_name ||= formula_files.each_with_object({}) do |file, hash|
+      # If there's more than one file with the same basename: use the longer one to prioritise more specific results.
+      basename = file.basename(".rb").to_s
+      existing_file = hash[basename]
+      hash[basename] = file if existing_file.nil? || existing_file.to_s.length < file.to_s.length
+    end
+  end
+
   # An array of all {Cask} files of this {Tap}.
+  sig { returns(T::Array[Pathname]) }
   def cask_files
     @cask_files ||= if cask_dir.directory?
-      cask_dir.children.select(&method(:ruby_file?))
+      Pathname.glob(cask_dir/"**/*.rb")
     else
       []
     end
   end
 
-  # returns true if the file has a Ruby extension
-  # @private
-  def ruby_file?(file)
-    file.extname == ".rb"
+  # A mapping of {Cask} tokens to {Cask} file paths.
+  sig { returns(T::Hash[String, Pathname]) }
+  def cask_files_by_name
+    @cask_files_by_name ||= cask_files.each_with_object({}) do |file, hash|
+      # If there's more than one file with the same basename: use the longer one to prioritise more specific results.
+      basename = file.basename(".rb").to_s
+      existing_file = hash[basename]
+      hash[basename] = file if existing_file.nil? || existing_file.to_s.length < file.to_s.length
+    end
+  end
+
+  RUBY_FILE_NAME_REGEX = %r{[^/]+\.rb}
+  private_constant :RUBY_FILE_NAME_REGEX
+
+  ZERO_OR_MORE_SUBDIRECTORIES_REGEX = %r{(?:[^/]+/)*}
+  private_constant :ZERO_OR_MORE_SUBDIRECTORIES_REGEX
+
+  sig { returns(Regexp) }
+  def formula_file_regex
+    @formula_file_regex ||= case formula_dir
+    when path/"Formula"
+      %r{^Formula/#{ZERO_OR_MORE_SUBDIRECTORIES_REGEX.source}#{RUBY_FILE_NAME_REGEX.source}$}o
+    when path/"HomebrewFormula"
+      %r{^HomebrewFormula/#{ZERO_OR_MORE_SUBDIRECTORIES_REGEX.source}#{RUBY_FILE_NAME_REGEX.source}$}o
+    when path
+      /^#{RUBY_FILE_NAME_REGEX.source}$/o
+    else
+      raise ArgumentError, "Unexpected formula_dir: #{formula_dir}"
+    end
   end
+  private :formula_file_regex
 
-  # return true if given path would present a {Formula} file in this {Tap}.
-  # accepts both absolute path and relative path (relative to this {Tap}'s path)
-  # @private
+  # accepts the relative path of a file from {Tap}'s path
+  sig { params(file: String).returns(T::Boolean) }
   def formula_file?(file)
-    file = Pathname.new(file) unless file.is_a? Pathname
-    file = file.expand_path(path)
-    ruby_file?(file) && file.parent == formula_dir
+    file.match?(formula_file_regex)
   end
 
-  # return true if given path would present a {Cask} file in this {Tap}.
-  # accepts both absolute path and relative path (relative to this {Tap}'s path)
-  # @private
+  CASK_FILE_REGEX = %r{^Casks/#{ZERO_OR_MORE_SUBDIRECTORIES_REGEX.source}#{RUBY_FILE_NAME_REGEX.source}$}
+  private_constant :CASK_FILE_REGEX
+
+  # accepts the relative path of a file from {Tap}'s path
+  sig { params(file: String).returns(T::Boolean) }
   def cask_file?(file)
-    file = Pathname.new(file) unless file.is_a? Pathname
-    file = file.expand_path(path)
-    ruby_file?(file) && file.parent == cask_dir
+    file.match?(CASK_FILE_REGEX)
   end
 
   # An array of all {Formula} names of this {Tap}.
+  sig { returns(T::Array[String]) }
   def formula_names
-    @formula_names ||= formula_files.map(&method(:formula_file_to_name))
+    @formula_names ||= formula_files.map { formula_file_to_name(_1) }
+  end
+
+  # A hash of all {Formula} name prefixes to versioned {Formula} in this {Tap}.
+  sig { returns(T::Hash[String, T::Array[String]]) }
+  def prefix_to_versioned_formulae_names
+    @prefix_to_versioned_formulae_names ||= formula_names
+                                            .select { |name| name.include?("@") }
+                                            .group_by { |name| name.gsub(/(@[\d.]+)?$/, "") }
+                                            .transform_values(&:sort)
+                                            .freeze
   end
 
   # An array of all {Cask} tokens of this {Tap}.
+  sig { returns(T::Array[String]) }
   def cask_tokens
-    @cask_tokens ||= cask_files.map(&method(:formula_file_to_name))
+    @cask_tokens ||= cask_files.map { formula_file_to_name(_1) }
   end
 
-  # path to the directory of all alias files for this {Tap}.
-  # @private
+  # Path to the directory of all alias files for this {Tap}.
+  sig { returns(Pathname) }
   def alias_dir
     @alias_dir ||= path/"Aliases"
   end
 
-  # an array of all alias files of this {Tap}.
-  # @private
+  # An array of all alias files of this {Tap}.
+  sig { returns(T::Array[Pathname]) }
   def alias_files
     @alias_files ||= Pathname.glob("#{alias_dir}/*").select(&:file?)
   end
 
-  # an array of all aliases of this {Tap}.
-  # @private
+  # An array of all aliases of this {Tap}.
+  sig { returns(T::Array[String]) }
   def aliases
-    @aliases ||= alias_files.map { |f| alias_file_to_name(f) }
+    @aliases ||= alias_table.keys
   end
 
-  # a table mapping alias to formula name
-  # @private
+  # Mapping from aliases to formula names.
+  sig { returns(T::Hash[String, String]) }
   def alias_table
-    return @alias_table if @alias_table
-
-    @alias_table = {}
-    alias_files.each do |alias_file|
-      @alias_table[alias_file_to_name(alias_file)] = formula_file_to_name(alias_file.resolved_path)
+    @alias_table ||= alias_files.each_with_object({}) do |alias_file, alias_table|
+      alias_table[alias_file_to_name(alias_file)] = formula_file_to_name(alias_file.resolved_path)
     end
-    @alias_table
   end
 
-  # a table mapping formula name to aliases
-  # @private
+  # Mapping from formula names to aliases.
+  sig { returns(T::Hash[String, T::Array[String]]) }
   def alias_reverse_table
-    return @alias_reverse_table if @alias_reverse_table
-
-    @alias_reverse_table = {}
-    alias_table.each do |alias_name, formula_name|
-      @alias_reverse_table[formula_name] ||= []
-      @alias_reverse_table[formula_name] << alias_name
+    @alias_reverse_table ||= alias_table.each_with_object({}) do |(alias_name, formula_name), alias_reverse_table|
+      alias_reverse_table[formula_name] ||= []
+      alias_reverse_table[formula_name] << alias_name
     end
-    @alias_reverse_table
   end
 
+  sig { returns(Pathname) }
   def command_dir
     @command_dir ||= path/"cmd"
   end
 
   # An array of all commands files of this {Tap}.
+  sig { returns(T::Array[Pathname]) }
   def command_files
     @command_files ||= if command_dir.directory?
       Commands.find_commands(command_dir)
@@ -590,44 +880,56 @@ def command_files
     end
   end
 
-  # path to the pin record for this {Tap}.
-  # @private
-  def pinned_symlink_path
-    HOMEBREW_LIBRARY/"PinnedTaps/#{name}"
-  end
-
-  # True if this {Tap} has been pinned.
-  def pinned?
-    return @pinned if instance_variable_defined?(:@pinned)
-
-    @pinned = pinned_symlink_path.directory?
-  end
-
+  sig { returns(Hash) }
   def to_hash
     hash = {
       "name"          => name,
       "user"          => user,
-      "repo"          => repo,
+      "repo"          => repository,
+      "repository"    => repository,
       "path"          => path.to_s,
       "installed"     => installed?,
       "official"      => official?,
       "formula_names" => formula_names,
-      "formula_files" => formula_files.map(&:to_s),
       "cask_tokens"   => cask_tokens,
-      "cask_files"    => cask_files.map(&:to_s),
-      "command_files" => command_files.map(&:to_s),
     }
 
     if installed?
+      hash["formula_files"] = formula_files.map(&:to_s)
+      hash["cask_files"] = cask_files.map(&:to_s)
+      hash["command_files"] = command_files.map(&:to_s)
       hash["remote"] = remote
       hash["custom_remote"] = custom_remote?
       hash["private"] = private?
+      hash["HEAD"] = git_head || "(none)"
+      hash["last_commit"] = git_last_commit || "never"
+      hash["branch"] = git_branch || "(none)"
     end
 
     hash
   end
 
+  # Hash with tap cask renames.
+  sig { returns(T::Hash[String, String]) }
+  def cask_renames
+    @cask_renames ||= if (rename_file = path/HOMEBREW_TAP_CASK_RENAMES_FILE).file?
+      JSON.parse(rename_file.read)
+    else
+      {}
+    end
+  end
+
+  # Mapping from new to old cask tokens. Reverse of {#cask_renames}.
+  sig { returns(T::Hash[String, T::Array[String]]) }
+  def cask_reverse_renames
+    @cask_reverse_renames ||= cask_renames.each_with_object({}) do |(old_name, new_name), hash|
+      hash[new_name] ||= []
+      hash[new_name] << old_name
+    end
+  end
+
   # Hash with tap formula renames.
+  sig { returns(T::Hash[String, String]) }
   def formula_renames
     @formula_renames ||= if (rename_file = path/HOMEBREW_TAP_FORMULA_RENAMES_FILE).file?
       JSON.parse(rename_file.read)
@@ -636,7 +938,17 @@ def formula_renames
     end
   end
 
+  # Mapping from new to old formula names. Reverse of {#formula_renames}.
+  sig { returns(T::Hash[String, T::Array[String]]) }
+  def formula_reverse_renames
+    @formula_reverse_renames ||= formula_renames.each_with_object({}) do |(old_name, new_name), hash|
+      hash[new_name] ||= []
+      hash[new_name] << old_name
+    end
+  end
+
   # Hash with tap migrations.
+  sig { returns(T::Hash[String, String]) }
   def tap_migrations
     @tap_migrations ||= if (migration_file = path/HOMEBREW_TAP_MIGRATIONS_FILE).file?
       JSON.parse(migration_file.read)
@@ -645,50 +957,134 @@ def tap_migrations
     end
   end
 
+  sig { returns(T::Hash[String, T::Array[String]]) }
+  def reverse_tap_migrations_renames
+    @reverse_tap_migrations_renames ||= tap_migrations.each_with_object({}) do |(old_name, new_name), hash|
+      # Only include renames:
+      # + `homebrew/cask/water-buffalo`
+      # - `homebrew/cask`
+      next if new_name.count("/") != 2
+
+      hash[new_name] ||= []
+      hash[new_name] << old_name
+    end
+  end
+
+  # The old names a formula or cask had before getting migrated to the current tap.
+  sig { params(current_tap: Tap, name_or_token: String).returns(T::Array[String]) }
+  def self.tap_migration_oldnames(current_tap, name_or_token)
+    key = "#{current_tap}/#{name_or_token}"
+
+    Tap.each_with_object([]) do |tap, array|
+      next unless (renames = tap.reverse_tap_migrations_renames[key])
+
+      array.concat(renames)
+    end
+  end
+
+  # Array with autobump names
+  sig { returns(T::Array[String]) }
+  def autobump
+    @autobump ||= if (autobump_file = path/HOMEBREW_TAP_AUTOBUMP_FILE).file?
+      autobump_file.readlines(chomp: true)
+    else
+      []
+    end
+  end
+
+  # Whether this {Tap} allows running bump commands on the given {Formula} or {Cask}.
+  sig { params(formula_or_cask_name: String).returns(T::Boolean) }
+  def allow_bump?(formula_or_cask_name)
+    ENV["HOMEBREW_TEST_BOT_AUTOBUMP"].present? || !official? || autobump.exclude?(formula_or_cask_name)
+  end
+
   # Hash with audit exceptions
   sig { returns(Hash) }
   def audit_exceptions
-    @audit_exceptions = read_formula_list_directory "#{HOMEBREW_TAP_AUDIT_EXCEPTIONS_DIR}/*"
+    @audit_exceptions ||= read_formula_list_directory("#{HOMEBREW_TAP_AUDIT_EXCEPTIONS_DIR}/*")
   end
 
   # Hash with style exceptions
   sig { returns(Hash) }
   def style_exceptions
-    @style_exceptions = read_formula_list_directory "#{HOMEBREW_TAP_STYLE_EXCEPTIONS_DIR}/*"
+    @style_exceptions ||= read_formula_list_directory("#{HOMEBREW_TAP_STYLE_EXCEPTIONS_DIR}/*")
   end
 
   # Hash with pypi formula mappings
   sig { returns(Hash) }
   def pypi_formula_mappings
-    @pypi_formula_mappings = read_formula_list path/HOMEBREW_TAP_PYPI_FORMULA_MAPPINGS
+    @pypi_formula_mappings ||= read_formula_list(path/HOMEBREW_TAP_PYPI_FORMULA_MAPPINGS_FILE)
+  end
+
+  # Array with synced versions formulae
+  sig { returns(T::Array[T::Array[String]]) }
+  def synced_versions_formulae
+    @synced_versions_formulae ||= if (synced_file = path/HOMEBREW_TAP_SYNCED_VERSIONS_FORMULAE_FILE).file?
+      JSON.parse(synced_file.read)
+    else
+      []
+    end
+  end
+
+  sig { returns(T::Boolean) }
+  def should_report_analytics?
+    installed? && !private?
   end
 
+  sig { params(other: T.nilable(T.any(String, Tap))).returns(T::Boolean) }
   def ==(other)
     other = Tap.fetch(other) if other.is_a?(String)
-    self.class == other.class && name == other.name
+    other.is_a?(self.class) && name == other.name
   end
+  alias eql? ==
 
-  def self.each(&block)
-    return unless TAP_DIRECTORY.directory?
+  sig { returns(Integer) }
+  def hash
+    [self.class, name].hash
+  end
 
-    return to_enum unless block
+  # All locally installed taps.
+  #
+  # @api public
+  sig { returns(T::Array[Tap]) }
+  def self.installed
+    cache[:installed] ||= if HOMEBREW_TAP_DIRECTORY.directory?
+      HOMEBREW_TAP_DIRECTORY.subdirs.flat_map(&:subdirs).map { from_path(_1) }
+    else
+      []
+    end
+  end
 
-    TAP_DIRECTORY.subdirs.each do |user|
-      user.subdirs.each do |repo|
-        yield fetch(user.basename.to_s, repo.basename.to_s)
-      end
+  # All locally installed and core taps. Core taps might not be installed locally when using the API.
+  sig { returns(T::Array[Tap]) }
+  def self.all
+    cache[:all] ||= begin
+      core_taps = [
+        CoreTap.instance,
+        (CoreCaskTap.instance if OS.mac?), # rubocop:disable Homebrew/MoveToExtendOS
+      ].compact
+
+      installed | core_taps
+    end
+  end
+
+  # Enumerate all available {Tap}s.
+  #
+  # @api public
+  def self.each(&block)
+    if Homebrew::EnvConfig.no_install_from_api?
+      installed.each(&block)
+    else
+      all.each(&block)
     end
   end
 
   # An array of all installed {Tap} names.
+  sig { returns(T::Array[String]) }
   def self.names
-    map(&:name).sort
-  end
+    odisabled "`#{self}.names`"
 
-  # An array of all tap cmd directory {Pathname}s.
-  sig { returns(T::Array[Pathname]) }
-  def self.cmd_directories
-    Pathname.glob TAP_DIRECTORY/"*/*/cmd"
+    map(&:name).sort
   end
 
   # An array of official taps that have been manually untapped
@@ -697,12 +1093,12 @@ def self.untapped_official_taps
     Homebrew::Settings.read(:untapped)&.split(";") || []
   end
 
-  # @private
+  sig { params(file: Pathname).returns(String) }
   def formula_file_to_name(file)
     "#{name}/#{file.basename(".rb")}"
   end
 
-  # @private
+  sig { params(file: Pathname).returns(String) }
   def alias_file_to_name(file)
     "#{name}/#{file.basename}"
   end
@@ -724,27 +1120,22 @@ def audit_exception(list, formula_or_cask, value = nil)
     end
   end
 
-  private
+  sig { returns(T::Boolean) }
+  def allowed_by_env?
+    @allowed_by_env ||= begin
+      allowed_taps = self.class.allowed_taps
 
-  def read_or_set_private_config
-    case config["private"]
-    when "true" then true
-    when "false" then false
-    else
-      config["private"] = begin
-        if custom_remote?
-          true
-        else
-          GitHub.private_repo?(full_name)
-        end
-      rescue GitHub::API::HTTPNotFoundError
-        true
-      rescue GitHub::API::Error
-        false
-      end
+      official? || allowed_taps.blank? || allowed_taps.include?(self)
     end
   end
 
+  sig { returns(T::Boolean) }
+  def forbidden_by_env?
+    @forbidden_by_env ||= self.class.forbidden_taps.include?(self)
+  end
+
+  private
+
   sig { params(file: Pathname).returns(T.any(T::Array[String], Hash)) }
   def read_formula_list(file)
     JSON.parse file.read
@@ -772,168 +1163,371 @@ def read_formula_list_directory(directory)
   end
 end
 
-# A specialized {Tap} class for the core formulae.
-class CoreTap < Tap
-  extend T::Sig
+class AbstractCoreTap < Tap
+  extend T::Helpers
 
-  # @private
-  sig { void }
-  def initialize
-    super "Homebrew", "core"
-  end
+  abstract!
+
+  private_class_method :fetch
 
+  # Get the singleton instance for this {Tap}.
+  #
+  # @api internal
+  sig { returns(T.attached_class) }
   def self.instance
-    @instance ||= new
+    @instance ||= T.unsafe(self).new
   end
 
+  sig { override.void }
+  def ensure_installed!
+    return unless Homebrew::EnvConfig.no_install_from_api?
+    return if Homebrew::EnvConfig.automatically_set_no_install_from_api?
+
+    super
+  end
+
+  sig { void }
   def self.ensure_installed!
-    return if instance.installed?
-    return if Homebrew::EnvConfig.install_from_api?
+    odisabled "`#{self}.ensure_installed!`", "`#{self}.instance.ensure_installed!`"
+
+    instance.ensure_installed!
+  end
+
+  sig { params(file: Pathname).returns(String) }
+  def formula_file_to_name(file)
+    file.basename(".rb").to_s
+  end
+
+  sig { override.returns(T::Boolean) }
+  def should_report_analytics?
+    return super if Homebrew::EnvConfig.no_install_from_api?
 
-    safe_system HOMEBREW_BREW_FILE, "tap", instance.name
+    true
+  end
+end
+
+# A specialized {Tap} class for the core formulae.
+class CoreTap < AbstractCoreTap
+  sig { void }
+  def initialize
+    super "Homebrew", "core"
+  end
+
+  sig { override.void }
+  def ensure_installed!
+    return if ENV["HOMEBREW_TESTS"]
+
+    super
   end
 
+  sig { returns(T.nilable(String)) }
   def remote
-    super if installed? || !Homebrew::EnvConfig.install_from_api?
+    return super if Homebrew::EnvConfig.no_install_from_api?
 
     Homebrew::EnvConfig.core_git_remote
   end
 
   # CoreTap never allows shallow clones (on request from GitHub).
-  def install(quiet: false, clone_target: nil, force_auto_update: nil, custom_remote: false)
+  def install(quiet: false, clone_target: nil,
+              custom_remote: false, verify: false, force: false)
     remote = Homebrew::EnvConfig.core_git_remote # set by HOMEBREW_CORE_GIT_REMOTE
     requested_remote = clone_target || remote
 
-    # The remote will changed again on `brew update` since remotes for Homebrew/core are mismatched
+    # The remote will changed again on `brew update` since remotes for homebrew/core are mismatched
     raise TapCoreRemoteMismatchError.new(name, remote, requested_remote) if requested_remote != remote
 
     if remote != default_remote
-      $stderr.puts "HOMEBREW_CORE_GIT_REMOTE set: using #{remote} for Homebrew/core Git remote."
+      $stderr.puts "HOMEBREW_CORE_GIT_REMOTE set: using #{remote} as the Homebrew/homebrew-core Git remote."
     end
 
-    super(quiet: quiet, clone_target: remote, force_auto_update: force_auto_update, custom_remote: custom_remote)
+    super(quiet:, clone_target: remote, custom_remote:, force:)
   end
 
-  # @private
   sig { params(manual: T::Boolean).void }
   def uninstall(manual: false)
-    raise "Tap#uninstall is not available for CoreTap" unless Homebrew::EnvConfig.install_from_api?
+    raise "Tap#uninstall is not available for CoreTap" if Homebrew::EnvConfig.no_install_from_api?
 
     super
   end
 
-  # @private
-  sig { void }
-  def pin
-    raise "Tap#pin is not available for CoreTap"
-  end
-
-  # @private
-  sig { void }
-  def unpin
-    raise "Tap#unpin is not available for CoreTap"
-  end
-
-  # @private
-  sig { returns(T::Boolean) }
-  def pinned?
-    false
-  end
-
-  # @private
   sig { returns(T::Boolean) }
   def core_tap?
     true
   end
 
-  # @private
   sig { returns(T::Boolean) }
   def linuxbrew_core?
-    remote_repo.to_s.end_with?("/linuxbrew-core") || remote_repo == "Linuxbrew/homebrew-core"
+    remote_repository.to_s.end_with?("/linuxbrew-core") || remote_repository == "Linuxbrew/homebrew-core"
   end
 
-  # @private
+  sig { returns(Pathname) }
   def formula_dir
     @formula_dir ||= begin
-      self.class.ensure_installed!
+      ensure_installed!
       super
     end
   end
 
-  # @private
+  sig { params(name: String).returns(Pathname) }
+  def new_formula_path(name)
+    formula_subdir = if name.start_with?("lib")
+      "lib"
+    else
+      name[0].to_s
+    end
+
+    return super unless (formula_dir/formula_subdir).directory?
+
+    formula_dir/formula_subdir/"#{name.downcase}.rb"
+  end
+
+  sig { returns(Pathname) }
   def alias_dir
     @alias_dir ||= begin
-      self.class.ensure_installed!
+      ensure_installed!
       super
     end
   end
 
-  # @private
+  sig { returns(T::Hash[String, String]) }
   def formula_renames
-    @formula_renames ||= begin
-      self.class.ensure_installed!
+    @formula_renames ||= if Homebrew::EnvConfig.no_install_from_api?
+      ensure_installed!
       super
+    else
+      Homebrew::API::Formula.all_renames
     end
   end
 
-  # @private
+  sig { returns(Hash) }
   def tap_migrations
-    @tap_migrations ||= begin
-      self.class.ensure_installed!
+    @tap_migrations ||= if Homebrew::EnvConfig.no_install_from_api?
+      ensure_installed!
       super
+    elsif Homebrew::API.internal_json_v3?
+      Homebrew::API::Formula.tap_migrations
+    else
+      migrations, = Homebrew::API.fetch_json_api_file "formula_tap_migrations.jws.json",
+                                                      stale_seconds: TAP_MIGRATIONS_STALE_SECONDS
+      migrations
     end
   end
 
-  # @private
+  sig { returns(T::Array[String]) }
+  def autobump
+    @autobump ||= begin
+      ensure_installed!
+      super
+    end
+  end
+
+  sig { returns(Hash) }
   def audit_exceptions
     @audit_exceptions ||= begin
-      self.class.ensure_installed!
+      ensure_installed!
       super
     end
   end
 
-  # @private
+  sig { returns(Hash) }
   def style_exceptions
     @style_exceptions ||= begin
-      self.class.ensure_installed!
+      ensure_installed!
       super
     end
   end
 
-  # @private
+  sig { returns(Hash) }
   def pypi_formula_mappings
     @pypi_formula_mappings ||= begin
-      self.class.ensure_installed!
+      ensure_installed!
       super
     end
   end
 
-  # @private
-  def formula_file_to_name(file)
-    file.basename(".rb").to_s
+  sig { returns(T::Array[T::Array[String]]) }
+  def synced_versions_formulae
+    @synced_versions_formulae ||= begin
+      ensure_installed!
+      super
+    end
   end
 
-  # @private
+  sig { params(file: Pathname).returns(String) }
   def alias_file_to_name(file)
     file.basename.to_s
   end
+
+  sig { returns(T::Hash[String, String]) }
+  def alias_table
+    @alias_table ||= if Homebrew::EnvConfig.no_install_from_api?
+      super
+    else
+      Homebrew::API::Formula.all_aliases
+    end
+  end
+
+  sig { returns(T::Array[Pathname]) }
+  def formula_files
+    return super if Homebrew::EnvConfig.no_install_from_api?
+
+    formula_files_by_name.values
+  end
+
+  sig { returns(T::Array[String]) }
+  def formula_names
+    return super if Homebrew::EnvConfig.no_install_from_api?
+
+    Homebrew::API::Formula.all_formulae.keys
+  end
+
+  sig { returns(T::Hash[String, Pathname]) }
+  def formula_files_by_name
+    return super if Homebrew::EnvConfig.no_install_from_api?
+
+    @formula_files_by_name ||= begin
+      tap_path = path.to_s
+      Homebrew::API::Formula.all_formulae.each_with_object({}) do |item, hash|
+        name, formula_hash = item
+        # If there's more than one item with the same path: use the longer one to prioritise more specific results.
+        existing_path = hash[name]
+        # Pathname equivalent is slow in a tight loop
+        new_path = File.join(tap_path, formula_hash.fetch("ruby_source_path"))
+        hash[name] = Pathname(new_path) if existing_path.nil? || existing_path.to_s.length < new_path.length
+      end
+    end
+  end
+
+  sig { returns(T::Hash[String, T.untyped]) }
+  def to_internal_api_hash
+    formulae_api_hash = formula_names.to_h do |name|
+      formula = Formulary.factory(name)
+      formula_hash = formula.to_hash_with_variations(hash_method: :to_internal_api_hash)
+      [name, formula_hash]
+    end
+
+    {
+      "tap_git_head"   => git_head,
+      "aliases"        => alias_table,
+      "renames"        => formula_renames,
+      "tap_migrations" => tap_migrations,
+      "formulae"       => formulae_api_hash,
+    }
+  end
+end
+
+# A specialized {Tap} class for homebrew-cask.
+class CoreCaskTap < AbstractCoreTap
+  sig { void }
+  def initialize
+    super "Homebrew", "cask"
+  end
+
+  sig { override.returns(T::Boolean) }
+  def core_cask_tap?
+    true
+  end
+
+  sig { params(token: String).returns(Pathname) }
+  def new_cask_path(token)
+    cask_subdir = if token.start_with?("font-")
+      "font/font-#{token.delete_prefix("font-")[0]}"
+    else
+      token[0].to_s
+    end
+    cask_dir/cask_subdir/"#{token.downcase}.rb"
+  end
+
+  sig { override.returns(T::Array[Pathname]) }
+  def cask_files
+    return super if Homebrew::EnvConfig.no_install_from_api?
+
+    cask_files_by_name.values
+  end
+
+  sig { override.returns(T::Array[String]) }
+  def cask_tokens
+    return super if Homebrew::EnvConfig.no_install_from_api?
+
+    Homebrew::API::Cask.all_casks.keys
+  end
+
+  sig { override.returns(T::Hash[String, Pathname]) }
+  def cask_files_by_name
+    return super if Homebrew::EnvConfig.no_install_from_api?
+
+    @cask_files_by_name ||= begin
+      tap_path = path.to_s
+      Homebrew::API::Cask.all_casks.each_with_object({}) do |item, hash|
+        name, cask_hash = item
+        # If there's more than one item with the same path: use the longer one to prioritise more specific results.
+        existing_path = hash[name]
+        # Pathname equivalent is slow in a tight loop
+        new_path = File.join(tap_path, cask_hash.fetch("ruby_source_path"))
+        hash[name] = Pathname(new_path) if existing_path.nil? || existing_path.to_s.length < new_path.length
+      end
+    end
+  end
+
+  sig { override.returns(T::Hash[String, String]) }
+  def cask_renames
+    @cask_renames ||= if Homebrew::EnvConfig.no_install_from_api?
+      super
+    else
+      Homebrew::API::Cask.all_renames
+    end
+  end
+
+  sig { override.returns(Hash) }
+  def tap_migrations
+    @tap_migrations ||= if Homebrew::EnvConfig.no_install_from_api?
+      super
+    else
+      migrations, = Homebrew::API.fetch_json_api_file "cask_tap_migrations.jws.json",
+                                                      stale_seconds: TAP_MIGRATIONS_STALE_SECONDS
+      migrations
+    end
+  end
+
+  sig { returns(T::Hash[String, T.untyped]) }
+  def to_internal_api_hash
+    casks_api_hash = cask_tokens.to_h do |token|
+      cask = Cask::CaskLoader.load(token)
+      cask_hash = cask.to_hash_with_variations(hash_method: :to_internal_api_hash)
+      [token, cask_hash]
+    end
+
+    {
+      "tap_git_head"   => git_head,
+      "renames"        => cask_renames,
+      "tap_migrations" => tap_migrations,
+      "casks"          => casks_api_hash,
+    }
+  end
 end
 
 # Permanent configuration per {Tap} using `git-config(1)`.
 class TapConfig
+  sig { returns(Tap) }
   attr_reader :tap
 
+  sig { params(tap: Tap).void }
   def initialize(tap)
     @tap = tap
   end
 
+  sig { params(key: Symbol).returns(T.nilable(T::Boolean)) }
   def [](key)
     return unless tap.git?
     return unless Utils::Git.available?
 
-    Homebrew::Settings.read key, repo: tap.path
+    case Homebrew::Settings.read(key, repo: tap.path)
+    when "true" then true
+    when "false" then false
+    end
   end
 
+  sig { params(key: Symbol, value: T::Boolean).void }
   def []=(key, value)
     return unless tap.git?
     return unless Utils::Git.available?
@@ -941,6 +1535,7 @@ def []=(key, value)
     Homebrew::Settings.write key, value.to_s, repo: tap.path
   end
 
+  sig { params(key: Symbol).void }
   def delete(key)
     return unless tap.git?
     return unless Utils::Git.available?
@@ -948,5 +1543,3 @@ def delete(key)
     Homebrew::Settings.delete key, repo: tap.path
   end
 end
-
-require "extend/os/tap"
diff --git a/Library/Homebrew/tap.sh b/Library/Homebrew/tap.sh
new file mode 100644
index 0000000000000..2a362a0eb3550
--- /dev/null
+++ b/Library/Homebrew/tap.sh
@@ -0,0 +1,27 @@
+# Does the quickest output of brew tap possible for no arguments.
+# HOMEBREW_LIBRARY is set by bin/brew
+# shellcheck disable=SC2154
+
+normalise_tap_name() {
+  local directory="$1"
+  local user
+  local repository
+
+  user="$(tr '[:upper:]' '[:lower:]' <<<"${directory%%/*}")"
+  repository="$(tr '[:upper:]' '[:lower:]' <<<"${directory#*/}")"
+  repository="${repository#@(home|linux)brew-}"
+  echo "${user}/${repository}"
+}
+
+homebrew-tap() {
+  local taplib="${HOMEBREW_LIBRARY}/Taps"
+  (
+    shopt -s extglob
+
+    for directory in "${taplib}"/*/*
+    do
+      [[ -d "${directory}" ]] || continue
+      normalise_tap_name "${directory#"${taplib}"/}"
+    done | sort
+  )
+}
diff --git a/Library/Homebrew/tap_auditor.rb b/Library/Homebrew/tap_auditor.rb
index d946a12e275ab..06bb454cd123e 100644
--- a/Library/Homebrew/tap_auditor.rb
+++ b/Library/Homebrew/tap_auditor.rb
@@ -1,28 +1,33 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module Homebrew
   # Auditor for checking common violations in {Tap}s.
-  #
-  # @api private
   class TapAuditor
-    extend T::Sig
-
-    attr_reader :name, :path, :formula_names, :cask_tokens, :tap_audit_exceptions, :tap_style_exceptions,
-                :tap_pypi_formula_mappings, :problems
+    attr_reader :name, :path, :formula_names, :formula_aliases, :formula_renames, :cask_tokens,
+                :tap_audit_exceptions, :tap_style_exceptions, :tap_pypi_formula_mappings, :problems
 
     sig { params(tap: Tap, strict: T.nilable(T::Boolean)).void }
     def initialize(tap, strict:)
-      @name                      = tap.name
-      @path                      = tap.path
-      @cask_tokens               = tap.cask_tokens
-      @tap_audit_exceptions      = tap.audit_exceptions
-      @tap_style_exceptions      = tap.style_exceptions
-      @tap_pypi_formula_mappings = tap.pypi_formula_mappings
-      @problems                  = []
+      Homebrew.with_no_api_env do
+        @name                      = tap.name
+        @path                      = tap.path
+        @tap_audit_exceptions      = tap.audit_exceptions
+        @tap_style_exceptions      = tap.style_exceptions
+        @tap_pypi_formula_mappings = tap.pypi_formula_mappings
+        @tap_autobump              = tap.autobump
+        @problems                  = []
 
-      @formula_names = tap.formula_names.map do |formula_name|
-        formula_name.split("/").last
+        @cask_tokens = tap.cask_tokens.map do |cask_token|
+          cask_token.split("/").last
+        end
+        @formula_aliases = tap.aliases.map do |formula_alias|
+          formula_alias.split("/").last
+        end
+        @formula_renames = tap.formula_renames
+        @formula_names = tap.formula_names.map do |formula_name|
+          formula_name.split("/").last
+        end
       end
     end
 
@@ -30,6 +35,7 @@ def initialize(tap, strict:)
     def audit
       audit_json_files
       audit_tap_formula_lists
+      audit_aliases_renames_duplicates
     end
 
     sig { void }
@@ -47,20 +53,30 @@ def audit_tap_formula_lists
       check_formula_list_directory "audit_exceptions", @tap_audit_exceptions
       check_formula_list_directory "style_exceptions", @tap_style_exceptions
       check_formula_list "pypi_formula_mappings", @tap_pypi_formula_mappings
+      check_formula_list ".github/autobump.txt", @tap_autobump
+    end
+
+    sig { void }
+    def audit_aliases_renames_duplicates
+      duplicates = formula_aliases & formula_renames.keys
+      return if duplicates.none?
+
+      problem "The following should either be an alias or a rename, not both: #{duplicates.to_sentence}"
     end
 
     sig { params(message: String).void }
     def problem(message)
-      @problems << ({ message: message, location: nil })
+      @problems << ({ message:, location: nil, corrected: false })
     end
 
     private
 
     sig { params(list_file: String, list: T.untyped).void }
     def check_formula_list(list_file, list)
+      list_file += ".json" if File.extname(list_file).empty?
       unless [Hash, Array].include? list.class
         problem <<~EOS
-          #{list_file}.json should contain a JSON array
+          #{list_file} should contain a JSON array
           of formula names or a JSON object mapping formula names to values
         EOS
         return
@@ -68,13 +84,15 @@ def check_formula_list(list_file, list)
 
       list = list.keys if list.is_a? Hash
       invalid_formulae_casks = list.select do |formula_or_cask_name|
-        @formula_names.exclude?(formula_or_cask_name) && @cask_tokens.exclude?("#{@name}/#{formula_or_cask_name}")
+        formula_names.exclude?(formula_or_cask_name) &&
+          formula_aliases.exclude?(formula_or_cask_name) &&
+          cask_tokens.exclude?(formula_or_cask_name)
       end
 
       return if invalid_formulae_casks.empty?
 
       problem <<~EOS
-        #{list_file}.json references
+        #{list_file} references
         formulae or casks that are not found in the #{@name} tap.
         Invalid formulae or casks: #{invalid_formulae_casks.join(", ")}
       EOS
diff --git a/Library/Homebrew/tap_constants.rb b/Library/Homebrew/tap_constants.rb
index f5943ad124afe..27b30331fa491 100644
--- a/Library/Homebrew/tap_constants.rb
+++ b/Library/Homebrew/tap_constants.rb
@@ -1,14 +1,52 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-# Match taps' formulae, e.g. `someuser/sometap/someformula`
-HOMEBREW_TAP_FORMULA_REGEX = %r{^([\w-]+)/([\w-]+)/([\w+-.@]+)$}.freeze
-# Match taps' casks, e.g. `someuser/sometap/somecask`
-HOMEBREW_TAP_CASK_REGEX = %r{^([\w-]+)/([\w-]+)/([a-z0-9\-_]+)$}.freeze
-# Match taps' directory paths, e.g. `HOMEBREW_LIBRARY/Taps/someuser/sometap`
-HOMEBREW_TAP_DIR_REGEX = %r{#{Regexp.escape(HOMEBREW_LIBRARY.to_s)}/Taps/(?<user>[\w-]+)/(?<repo>[\w-]+)}.freeze
-# Match taps' formula paths, e.g. `HOMEBREW_LIBRARY/Taps/someuser/sometap/someformula`
-HOMEBREW_TAP_PATH_REGEX = Regexp.new(HOMEBREW_TAP_DIR_REGEX.source + %r{(?:/.*)?$}.source).freeze
-# Match official taps' casks, e.g. `homebrew/cask/somecask or homebrew/cask-versions/somecask`
-HOMEBREW_CASK_TAP_CASK_REGEX = %r{^(?:([Cc]askroom)/(cask|versions)|(homebrew)/(cask|cask-[\w-]+))/([\w+-.]+)$}.freeze
-HOMEBREW_OFFICIAL_REPO_PREFIXES_REGEX = /^(home|linux)brew-/.freeze
+# Match a formula name.
+HOMEBREW_TAP_FORMULA_NAME_REGEX = T.let(/(?<name>[\w+\-.@]+)/, Regexp)
+# Match taps' formulae, e.g. `someuser/sometap/someformula`.
+HOMEBREW_TAP_FORMULA_REGEX = T.let(
+  %r{\A(?<user>[^/]+)/(?<repository>[^/]+)/#{HOMEBREW_TAP_FORMULA_NAME_REGEX.source}\Z},
+  Regexp,
+)
+# Match default formula taps' formulae, e.g. `homebrew/core/someformula` or `someformula`.
+HOMEBREW_DEFAULT_TAP_FORMULA_REGEX = T.let(
+  %r{\A(?:[Hh]omebrew/(?:homebrew-)?core/)?(?<name>#{HOMEBREW_TAP_FORMULA_NAME_REGEX.source})\Z},
+  Regexp,
+)
+# Match taps' remote repository, e.g. `someuser/somerepo`.
+HOMEBREW_TAP_REPOSITORY_REGEX = T.let(
+  %r{\A.+[/:](?<remote_repository>[^/:]+/[^/:]+?(?=\.git/*\Z|/*\Z))},
+  Regexp,
+)
+
+# Match a cask token.
+HOMEBREW_TAP_CASK_TOKEN_REGEX = T.let(/(?<token>[\w+\-.@]+)/, Regexp)
+# Match taps' casks, e.g. `someuser/sometap/somecask`.
+HOMEBREW_TAP_CASK_REGEX = T.let(
+  %r{\A(?<user>[^/]+)/(?<repository>[^/]+)/#{HOMEBREW_TAP_CASK_TOKEN_REGEX.source}\Z},
+  Regexp,
+)
+# Match default cask taps' casks, e.g. `homebrew/cask/somecask` or `somecask`.
+HOMEBREW_DEFAULT_TAP_CASK_REGEX = T.let(
+  %r{\A(?:[Hh]omebrew/(?:homebrew-)?cask/)?#{HOMEBREW_TAP_CASK_TOKEN_REGEX.source}\Z},
+  Regexp,
+)
+
+# Match taps' directory paths, e.g. `HOMEBREW_LIBRARY/Taps/someuser/sometap`.
+HOMEBREW_TAP_DIR_REGEX = T.let(
+  %r{#{Regexp.escape(HOMEBREW_LIBRARY.to_s)}/Taps/(?<user>[^/]+)/(?<repository>[^/]+)},
+  Regexp,
+)
+# Match taps' formula paths, e.g. `HOMEBREW_LIBRARY/Taps/someuser/sometap/someformula`.
+HOMEBREW_TAP_PATH_REGEX = T.let(Regexp.new(HOMEBREW_TAP_DIR_REGEX.source + %r{(?:/.*)?\Z}.source).freeze, Regexp)
+# Match official cask taps, e.g `homebrew/cask`.
+HOMEBREW_CASK_TAP_REGEX = T.let(
+  %r{(?:([Cc]askroom)/(cask)|([Hh]omebrew)/(?:homebrew-)?(cask|cask-[\w-]+))},
+  Regexp,
+)
+# Match official taps' casks, e.g. `homebrew/cask/somecask`.
+HOMEBREW_CASK_TAP_CASK_REGEX = T.let(
+  %r{\A#{HOMEBREW_CASK_TAP_REGEX.source}/#{HOMEBREW_TAP_CASK_TOKEN_REGEX.source}\Z},
+  Regexp,
+)
+HOMEBREW_OFFICIAL_REPO_PREFIXES_REGEX = T.let(/\A(home|linux)brew-/, Regexp)
diff --git a/Library/Homebrew/test.rb b/Library/Homebrew/test.rb
index 41a095c41aedc..1ba9396a7923a 100644
--- a/Library/Homebrew/test.rb
+++ b/Library/Homebrew/test.rb
@@ -1,26 +1,29 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+raise "#{__FILE__} must not be loaded via `require`." if $PROGRAM_NAME != __FILE__
+
 old_trap = trap("INT") { exit! 130 }
 
 require_relative "global"
 require "extend/ENV"
 require "timeout"
-require "debrew"
 require "formula_assertions"
 require "formula_free_port"
 require "fcntl"
-require "socket"
+require "utils/socket"
 require "cli/parser"
 require "dev-cmd/test"
+require "json/add/exception"
 
-TEST_TIMEOUT_SECONDS = 5 * 60
+DEFAULT_TEST_TIMEOUT_SECONDS = 5 * 60
 
 begin
-  args = Homebrew.test_args.parse
+  ENV.delete("HOMEBREW_FORBID_PACKAGES_FROM_PATHS")
+  args = Homebrew::DevCmd::Test.new.args
   Context.current = args.context
 
-  error_pipe = UNIXSocket.open(ENV.fetch("HOMEBREW_ERROR_PIPE"), &:recv_io)
+  error_pipe = Utils::UNIXSocketExt.open(ENV.fetch("HOMEBREW_ERROR_PIPE"), &:recv_io)
   error_pipe.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 
   trap("INT", old_trap)
@@ -33,19 +36,22 @@
   formula = T.must(args.named.to_resolved_formulae.first)
   formula.extend(Homebrew::Assertions)
   formula.extend(Homebrew::FreePort)
-  formula.extend(Debrew::Formula) if args.debug?
+  if args.debug? && !Homebrew::EnvConfig.disable_debrew?
+    require "debrew"
+    formula.extend(Debrew::Formula)
+  end
 
   ENV.extend(Stdenv)
-  T.cast(ENV, Stdenv).setup_build_environment(formula: formula, testing_formula: true)
+  ENV.setup_build_environment(formula:, testing_formula: true)
 
   # tests can also return false to indicate failure
-  run_test = proc do
-    raise "test returned false" if formula.run_test(keep_tmp: args.keep_tmp?) == false
-  end
+  run_test = proc { |_ = nil| raise "test returned false" if formula.run_test(keep_tmp: args.keep_tmp?) == false }
   if args.debug? # --debug is interactive
     run_test.call
   else
-    Timeout.timeout(TEST_TIMEOUT_SECONDS, &run_test)
+    # HOMEBREW_TEST_TIMEOUT_SECS is private API and subject to change.
+    timeout = ENV["HOMEBREW_TEST_TIMEOUT_SECS"]&.to_i || DEFAULT_TEST_TIMEOUT_SECONDS
+    Timeout.timeout(timeout, &run_test)
   end
 rescue Exception => e # rubocop:disable Lint/RescueException
   error_pipe.puts e.to_json
diff --git a/Library/Homebrew/test/.rubocop.yml b/Library/Homebrew/test/.rubocop.yml
index 86832e9d273e0..47f0ac2690a4e 100644
--- a/Library/Homebrew/test/.rubocop.yml
+++ b/Library/Homebrew/test/.rubocop.yml
@@ -1,7 +1,17 @@
 inherit_from:
   - ../.rubocop.yml
-  - .rubocop_todo.yml
 
 RSpec:
   Include:
     - ./*
+
+RSpec/ContextWording:
+  Prefixes:
+    - when
+    - with
+    - without
+    - if
+    - unless
+    - for
+    - which
+    - to
diff --git a/Library/Homebrew/test/.rubocop_todo.yml b/Library/Homebrew/test/.rubocop_todo.yml
deleted file mode 100644
index e4671a003cc05..0000000000000
--- a/Library/Homebrew/test/.rubocop_todo.yml
+++ /dev/null
@@ -1,39 +0,0 @@
-# This configuration was generated by
-# `rubocop --auto-gen-config --exclude-limit 100`
-# on 2021-02-01 21:43:02 UTC using RuboCop version 1.9.0.
-# The point is for the user to remove these configuration records
-# one by one as the offenses are removed from the code base.
-# Note that changes in the inspected code, or installation of new
-# versions of RuboCop, may require this file to be generated again.
-
-# Offense count: 7
-# Configuration parameters: AssignmentOnly.
-RSpec/InstanceVariable:
-  Exclude:
-    - "download_strategies/git_spec.rb"
-    - "support/helper/spec/shared_context/integration_test.rb"
-    - "utils/git_spec.rb"
-
-# Offense count: 63
-# Configuration parameters: IgnoreNameless, IgnoreSymbolicNames.
-RSpec/VerifiedDoubles:
-  Exclude:
-    - "cache_store_spec.rb"
-    - "cask/artifact/pkg_spec.rb"
-    - "cask/installer_spec.rb"
-    - "cask/pkg_spec.rb"
-    - "cmd/update-report_spec.rb"
-    - "compiler_failure_spec.rb"
-    - "compiler_selector_spec.rb"
-    - "dependable_spec.rb"
-    - "dependency_expansion_spec.rb"
-    - "description_cache_store_spec.rb"
-    - "exceptions_spec.rb"
-    - "formula_pin_spec.rb"
-    - "formula_spec.rb"
-    - "language/python/virtualenv_spec.rb"
-    - "linkage_cache_store_spec.rb"
-    - "resource_spec.rb"
-    - "software_spec_spec.rb"
-    - "utils/analytics_spec.rb"
-    - "version_spec.rb"
diff --git a/Library/Homebrew/test/ENV_spec.rb b/Library/Homebrew/test/ENV_spec.rb
index c09a50bca6600..1ee1ac45fff1e 100644
--- a/Library/Homebrew/test/ENV_spec.rb
+++ b/Library/Homebrew/test/ENV_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "extend/ENV"
 
-describe "ENV" do
+RSpec.describe "ENV" do
   shared_examples EnvActivation do
     subject(:env) { env_activation.extend(described_class) }
 
@@ -30,12 +29,12 @@
       it "ensures the environment is restored" do
         before = subject.dup
 
-        expect {
+        expect do
           subject.with_build_environment do
             subject["foo"] = "bar"
             raise StandardError
           end
-        }.to raise_error(StandardError)
+        end.to raise_error(StandardError)
 
         expect(subject["foo"]).to be_nil
         expect(subject).to eq(before)
@@ -74,8 +73,8 @@
         expect(subject["foo"]).to eq("1")
       end
 
-      # NOTE: this may be a wrong behavior; we should probably reject objects that
-      # do not respond to #to_str. For now this documents existing behavior.
+      # NOTE: This may be a wrong behavior; we should probably reject objects that
+      #       do not respond to `#to_str`. For now this documents existing behavior.
       it "coerces a value to a string" do
         subject.append "foo", 42
         expect(subject["foo"]).to eq("42")
@@ -130,8 +129,8 @@
 
     describe "#compiler" do
       it "allows switching compilers" do
-        subject.public_send(:"gcc-6")
-        expect(subject.compiler).to eq("gcc-6")
+        subject.public_send(:"gcc-9")
+        expect(subject.compiler).to eq("gcc-9")
       end
     end
 
@@ -165,12 +164,6 @@
         expect(subject["FOO"]).to eq "bar"
       end
     end
-
-    describe "#compiler_any_clang?" do
-      it "returns true for llvm_clang" do
-        expect(subject.compiler_any_clang?(:llvm_clang)).to be true
-      end
-    end
   end
 
   describe Stdenv do
@@ -186,16 +179,11 @@
     end
 
     describe "#cxx11" do
-      it "supports gcc-5" do
-        env["HOMEBREW_CC"] = "gcc-5"
-        env.cxx11
-        expect(env["HOMEBREW_CCCFG"]).to include("x")
-      end
-
-      example "supports gcc-6" do
-        env["HOMEBREW_CC"] = "gcc-6"
+      it "supports gcc-11" do
+        env["HOMEBREW_CC"] = "gcc-11"
         env.cxx11
         expect(env["HOMEBREW_CCCFG"]).to include("x")
+        expect(env["HOMEBREW_CCCFG"]).not_to include("g")
       end
 
       it "supports clang" do
@@ -205,5 +193,12 @@
         expect(env["HOMEBREW_CCCFG"]).to include("g")
       end
     end
+
+    describe "#set_debug_symbols" do
+      it "sets the debug symbols flag" do
+        env.set_debug_symbols
+        expect(env["HOMEBREW_CCCFG"]).to include("D")
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/test/PATH_spec.rb b/Library/Homebrew/test/PATH_spec.rb
index efd7fdfc88350..f21fcac32fbd8 100644
--- a/Library/Homebrew/test/PATH_spec.rb
+++ b/Library/Homebrew/test/PATH_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "PATH"
 
-describe PATH do
+RSpec.describe PATH do
   describe "#initialize" do
     it "can take multiple arguments" do
       expect(described_class.new("/path1", "/path2")).to eq("/path1:/path2")
diff --git a/Library/Homebrew/test/abstract_command_spec.rb b/Library/Homebrew/test/abstract_command_spec.rb
new file mode 100644
index 0000000000000..c6669c842b5da
--- /dev/null
+++ b/Library/Homebrew/test/abstract_command_spec.rb
@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "abstract_command"
+
+RSpec.describe Homebrew::AbstractCommand do
+  describe "subclasses" do
+    before do
+      test_cat = Class.new(described_class) do
+        cmd_args do
+          description "test"
+          switch "--foo"
+          flag "--bar="
+        end
+        def run; end
+      end
+      stub_const("TestCat", test_cat)
+    end
+
+    describe "parsing args" do
+      it "parses valid args" do
+        expect { TestCat.new(["--foo"]).run }.not_to raise_error
+      end
+
+      it "allows access to args" do
+        expect(TestCat.new(["--bar", "baz"]).args[:bar]).to eq("baz")
+      end
+
+      it "raises on invalid args" do
+        expect { TestCat.new(["--bat"]) }.to raise_error(OptionParser::InvalidOption)
+      end
+    end
+
+    describe "command names" do
+      it "has a default command name" do
+        expect(TestCat.command_name).to eq("test-cat")
+      end
+
+      it "can lookup command" do
+        expect(described_class.command("test-cat")).to be(TestCat)
+      end
+
+      it "removes -cmd suffix from command name" do
+        require "dev-cmd/formula"
+        expect(Homebrew::DevCmd::FormulaCmd.command_name).to eq("formula")
+      end
+
+      describe "when command name is overridden" do
+        before do
+          tac = Class.new(described_class) do
+            def self.command_name = "t-a-c"
+            def run; end
+          end
+          stub_const("Tac", tac)
+        end
+
+        it "can be looked up by command name" do
+          expect(described_class.command("t-a-c")).to be(Tac)
+        end
+      end
+    end
+  end
+
+  describe "command paths" do
+    it "match command name" do
+      ["cmd", "dev-cmd"].each do |dir|
+        Dir[File.join(__dir__, "../#{dir}", "*.rb")].each do |file|
+          filename = File.basename(file, ".rb")
+          require(file)
+          command = described_class.command(filename)
+          expect(Pathname(File.join(__dir__, "../#{dir}/#{command.command_name}.rb"))).to exist
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/test/abstract_command_spec.rbi b/Library/Homebrew/test/abstract_command_spec.rbi
new file mode 100644
index 0000000000000..67822934d53fc
--- /dev/null
+++ b/Library/Homebrew/test/abstract_command_spec.rbi
@@ -0,0 +1,4 @@
+# typed: strict
+
+class TestCat < Homebrew::AbstractCommand; end
+class Tac < Homebrew::AbstractCommand; end
diff --git a/Library/Homebrew/test/api/cask_spec.rb b/Library/Homebrew/test/api/cask_spec.rb
new file mode 100644
index 0000000000000..932897dbe810f
--- /dev/null
+++ b/Library/Homebrew/test/api/cask_spec.rb
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "api"
+
+RSpec.describe Homebrew::API::Cask do
+  let(:cache_dir) { mktmpdir }
+
+  before do
+    stub_const("Homebrew::API::HOMEBREW_CACHE_API", cache_dir)
+  end
+
+  def mock_curl_download(stdout:)
+    allow(Utils::Curl).to receive(:curl_download) do |*_args, **kwargs|
+      kwargs[:to].write stdout
+    end
+    allow(Homebrew::API).to receive(:verify_and_parse_jws) do |json_data|
+      [true, json_data]
+    end
+  end
+
+  describe "::all_casks" do
+    let(:casks_json) do
+      <<~EOS
+        [{
+          "token": "foo",
+          "url": "https://brew.sh/foo"
+        }, {
+          "token": "bar",
+          "url": "https://brew.sh/bar"
+        }]
+      EOS
+    end
+    let(:casks_hash) do
+      {
+        "foo" => { "url" => "https://brew.sh/foo" },
+        "bar" => { "url" => "https://brew.sh/bar" },
+      }
+    end
+
+    it "returns the expected cask JSON list" do
+      mock_curl_download stdout: casks_json
+      casks_output = described_class.all_casks
+      expect(casks_output).to eq casks_hash
+    end
+  end
+
+  describe "::source_download", :needs_macos do
+    let(:cask) do
+      cask = Cask::CaskLoader::FromAPILoader.new(
+        "everything",
+        from_json: JSON.parse((TEST_FIXTURE_DIR/"cask/everything.json").read.strip),
+      ).load(config: nil)
+      cask
+    end
+
+    before do
+      allow_any_instance_of(Homebrew::API::Download).to receive(:fetch)
+      allow_any_instance_of(Homebrew::API::Download).to receive(:symlink_location).and_return(
+        TEST_FIXTURE_DIR/"cask/Casks/everything.rb",
+      )
+    end
+
+    it "specifies the correct URL and sha256" do
+      expect(Homebrew::API::Download).to receive(:new).with(
+        "https://raw.githubusercontent.com/Homebrew/homebrew-cask/abcdef1234567890abcdef1234567890abcdef12/Casks/everything.rb",
+        Checksum.new("d8d0d6b2e5ff65388eccb82236fd3aa157b4a29bb043a1f72b97f0e9b70e8320"),
+        any_args,
+      ).and_call_original
+      described_class.source_download(cask)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/api/formula_spec.rb b/Library/Homebrew/test/api/formula_spec.rb
new file mode 100644
index 0000000000000..8b89d1916b99d
--- /dev/null
+++ b/Library/Homebrew/test/api/formula_spec.rb
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "api"
+
+RSpec.describe Homebrew::API::Formula do
+  let(:cache_dir) { mktmpdir }
+
+  before do
+    stub_const("Homebrew::API::HOMEBREW_CACHE_API", cache_dir)
+  end
+
+  def mock_curl_download(stdout:)
+    allow(Utils::Curl).to receive(:curl_download) do |*_args, **kwargs|
+      kwargs[:to].write stdout
+    end
+    allow(Homebrew::API).to receive(:verify_and_parse_jws) do |json_data|
+      [true, json_data]
+    end
+  end
+
+  describe "::all_formulae" do
+    let(:formulae_json) do
+      <<~EOS
+        [{
+          "name": "foo",
+          "url": "https://brew.sh/foo",
+          "aliases": ["foo-alias1", "foo-alias2"]
+        }, {
+          "name": "bar",
+          "url": "https://brew.sh/bar",
+          "aliases": ["bar-alias"]
+        }, {
+          "name": "baz",
+          "url": "https://brew.sh/baz",
+          "aliases": []
+        }]
+      EOS
+    end
+    let(:formulae_hash) do
+      {
+        "foo" => { "url" => "https://brew.sh/foo", "aliases" => ["foo-alias1", "foo-alias2"] },
+        "bar" => { "url" => "https://brew.sh/bar", "aliases" => ["bar-alias"] },
+        "baz" => { "url" => "https://brew.sh/baz", "aliases" => [] },
+      }
+    end
+    let(:formulae_aliases) do
+      {
+        "foo-alias1" => "foo",
+        "foo-alias2" => "foo",
+        "bar-alias"  => "bar",
+      }
+    end
+
+    it "returns the expected formula JSON list" do
+      mock_curl_download stdout: formulae_json
+      formulae_output = described_class.all_formulae
+      expect(formulae_output).to eq formulae_hash
+    end
+
+    it "returns the expected formula alias list" do
+      mock_curl_download stdout: formulae_json
+      aliases_output = described_class.all_aliases
+      expect(aliases_output).to eq formulae_aliases
+    end
+  end
+end
diff --git a/Library/Homebrew/test/api/internal_tap_json/formula_spec.rb b/Library/Homebrew/test/api/internal_tap_json/formula_spec.rb
new file mode 100644
index 0000000000000..6e79402e9934b
--- /dev/null
+++ b/Library/Homebrew/test/api/internal_tap_json/formula_spec.rb
@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+RSpec.describe "Internal Tap JSON -- Formula", type: :system do
+  include FileUtils
+
+  let(:internal_tap_json) { File.read(TEST_FIXTURE_DIR/"internal_tap_json/homebrew-core.json").chomp }
+  let(:tap_git_head) { "9977471165641744a829d3e494fa563407503297" }
+
+  context "when generating JSON", :needs_macos do
+    before do
+      cp_r(TEST_FIXTURE_DIR/"internal_tap_json/homebrew-core", HOMEBREW_TAP_DIRECTORY/"homebrew")
+
+      # NOTE: Symlinks can't be copied recursively so we create them manually here.
+      (HOMEBREW_TAP_DIRECTORY/"homebrew/homebrew-core").tap do |core_tap|
+        mkdir(core_tap/"Aliases")
+        ln_s(core_tap/"Formula/f/fennel.rb", core_tap/"Aliases/fennel-lang")
+        ln_s(core_tap/"Formula/p/ponyc.rb", core_tap/"Aliases/ponyc-lang")
+      end
+    end
+
+    it "creates the expected hash" do
+      api_hash = CoreTap.instance.to_internal_api_hash
+      api_hash["tap_git_head"] = tap_git_head # tricky to mock
+
+      expect(JSON.pretty_generate(api_hash)).to eq(internal_tap_json)
+    end
+  end
+
+  context "when loading JSON" do
+    before do
+      ENV["HOMEBREW_INTERNAL_JSON_V3"] = "1"
+      ENV.delete("HOMEBREW_NO_INSTALL_FROM_API")
+
+      allow(Homebrew::API).to receive(:fetch_json_api_file)
+        .with("internal/v3/homebrew-core.jws.json")
+        .and_return([JSON.parse(internal_tap_json, freeze: true), false])
+
+      # `Tap.tap_migration_oldnames` looks for renames in every
+      # tap so `CoreCaskTap.tap_migrations` gets called and tries to
+      # fetch stuff from the API. This just avoids errors.
+      allow(Homebrew::API).to receive(:fetch_json_api_file)
+        .with("cask_tap_migrations.jws.json", anything)
+        .and_return([{}, false])
+
+      # To allow `formula_names.txt` to be written to the cache.
+      (HOMEBREW_CACHE/"api").mkdir
+    end
+
+    it "loads tap aliases" do
+      expect(CoreTap.instance.alias_table).to eq({
+        "fennel-lang" => "fennel",
+        "ponyc-lang"  => "ponyc",
+      })
+    end
+
+    it "loads formula renames" do
+      expect(CoreTap.instance.formula_renames).to eq({
+        "advancemenu" => "advancemame",
+        "amtk"        => "libgedit-amtk",
+        "annie"       => "lux",
+        "antlr2"      => "antlr@2",
+        "romanesco"   => "fennel",
+      })
+    end
+
+    it "loads tap migrations" do
+      expect(CoreTap.instance.tap_migrations).to eq({
+        "adobe-air-sdk"          => "homebrew/cask",
+        "android-ndk"            => "homebrew/cask",
+        "android-platform-tools" => "homebrew/cask",
+        "android-sdk"            => "homebrew/cask",
+        "app-engine-go-32"       => "homebrew/cask/google-cloud-sdk",
+      })
+    end
+
+    it "loads tap git head" do
+      expect(Homebrew::API::Formula.tap_git_head)
+        .to eq(tap_git_head)
+    end
+
+    context "when loading formulae" do
+      let(:fennel_metadata) do
+        {
+          "dependencies"         => ["lua"],
+          "desc"                 => "Lua Lisp Language",
+          "full_name"            => "fennel",
+          "homepage"             => "https://fennel-lang.org",
+          "license"              => "MIT",
+          "name"                 => "fennel",
+          "ruby_source_path"     => "Formula/f/fennel.rb",
+          "tap"                  => "homebrew/core",
+          "tap_git_head"         => tap_git_head,
+          "versions"             => { "bottle"=>true, "head"=>nil, "stable"=>"1.4.0" },
+          "ruby_source_checksum" => {
+            "sha256" => "5856e655fd1cea11496d67bc27fb14fee5cfbdea63c697c3773c7f247581197d",
+          },
+        }
+      end
+
+      let(:ponyc_metadata) do
+        {
+          "desc"                   => "Object-oriented, actor-model, capabilities-secure programming language",
+          "full_name"              => "ponyc",
+          "homepage"               => "https://www.ponylang.io/",
+          "license"                => "BSD-2-Clause",
+          "name"                   => "ponyc",
+          "ruby_source_path"       => "Formula/p/ponyc.rb",
+          "tap"                    => "homebrew/core",
+          "tap_git_head"           => tap_git_head,
+          "uses_from_macos"        => [{ "llvm"=>[:build, :test] }, "zlib"],
+          "uses_from_macos_bounds" => [{}, {}],
+          "versions"               => { "bottle"=>true, "head"=>nil, "stable"=>"0.58.1" },
+          "ruby_source_checksum"   => {
+            "sha256" => "81d51c25d18710191beb62f9f380bae3d878aad815a65ec1ee2a3b132c1fadb3",
+          },
+        }
+      end
+
+      let(:inko_metadata) do
+        {
+          "desc"                   => "Safe and concurrent object-oriented programming language",
+          "full_name"              => "inko",
+          "homepage"               => "https://inko-lang.org/",
+          "license"                => "MPL-2.0",
+          "name"                   => "inko",
+          "ruby_source_path"       => "Formula/i/inko.rb",
+          "tap"                    => "homebrew/core",
+          "tap_git_head"           => tap_git_head,
+          "dependencies"           => ["llvm@15", "zstd"],
+          "uses_from_macos"        => ["libffi", "ruby"],
+          "uses_from_macos_bounds" => [{ since: :catalina }, { since: :sierra }],
+          "versions"               => { "bottle"=>true, "head"=>"HEAD", "stable"=>"0.14.0" },
+          "ruby_source_checksum"   => {
+            "sha256" => "843f6b5652483b971c83876201d68c95d5f32e67e55a75ac7c95d68c4350aa1c",
+          },
+        }
+      end
+
+      it "loads fennel" do
+        fennel = Formulary.factory("fennel")
+        expect(fennel.to_hash).to include(**fennel_metadata)
+      end
+
+      it "loads fennel from rename" do
+        fennel = Formulary.factory("romanesco")
+        expect(fennel.to_hash).to include(**fennel_metadata)
+      end
+
+      it "loads fennel from alias" do
+        fennel = Formulary.factory("fennel-lang")
+        expect(fennel.to_hash).to include(**fennel_metadata)
+      end
+
+      it "loads ponyc" do
+        ponyc = Formulary.factory("ponyc")
+        expect(ponyc.to_hash).to include(**ponyc_metadata)
+      end
+
+      it "loads ponyc from alias" do
+        ponyc = Formulary.factory("ponyc-lang")
+        expect(ponyc.to_hash).to include(**ponyc_metadata)
+      end
+
+      it "loads ink" do
+        inko = Formulary.factory("inko")
+        expect(inko.to_hash).to include(**inko_metadata)
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/test/api/versions_spec.rb b/Library/Homebrew/test/api/versions_spec.rb
deleted file mode 100644
index c27ec833dd9cf..0000000000000
--- a/Library/Homebrew/test/api/versions_spec.rb
+++ /dev/null
@@ -1,72 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "api"
-
-describe Homebrew::API::Versions do
-  def mock_curl_output(stdout: "", success: true)
-    curl_output = OpenStruct.new(stdout: stdout, success?: success)
-    allow(Utils::Curl).to receive(:curl_output).and_return curl_output
-  end
-
-  describe "::latest_formula_version" do
-    let(:versions_formulae_json) {
-      <<~EOS
-        {
-          "foo":{"version":"1.2.3","revision":0},
-          "bar":{"version":"1.2","revision":4}
-        }
-      EOS
-    }
-
-    it "returns the expected `PkgVersion` when the revision is 0" do
-      mock_curl_output stdout: versions_formulae_json
-      pkg_version = described_class.latest_formula_version("foo")
-      expect(pkg_version.to_s).to eq "1.2.3"
-    end
-
-    it "returns the expected `PkgVersion` when the revision is not 0" do
-      mock_curl_output stdout: versions_formulae_json
-      pkg_version = described_class.latest_formula_version("bar")
-      expect(pkg_version.to_s).to eq "1.2_4"
-    end
-
-    it "returns `nil` when the formula is not in the JSON file" do
-      mock_curl_output stdout: versions_formulae_json
-      pkg_version = described_class.latest_formula_version("baz")
-      expect(pkg_version).to be_nil
-    end
-  end
-
-  describe "::latest_cask_version", :needs_macos do
-    let(:versions_casks_json) {
-      <<~EOS
-        {
-          "foo":{"version":"1.2.3","versions":{}},
-          "bar":{"version":"1.2.3","versions":{"#{MacOS.version.to_sym}":"1.2.0"}},
-          "baz":{"version":"1.2.3","versions":{"test_os":"1.2.0"}}
-        }
-      EOS
-    }
-
-    it "returns the expected `Version`" do
-      mock_curl_output stdout: versions_casks_json
-      version = described_class.latest_cask_version("foo")
-      expect(version.to_s).to eq "1.2.3"
-    end
-
-    it "returns the expected `Version` for an OS with a non-default version" do
-      mock_curl_output stdout: versions_casks_json
-      version = described_class.latest_cask_version("bar")
-      expect(version.to_s).to eq "1.2.0"
-      version = described_class.latest_cask_version("baz")
-      expect(version.to_s).to eq "1.2.3"
-    end
-
-    it "returns `nil` when the cask is not in the JSON file" do
-      mock_curl_output stdout: versions_casks_json
-      version = described_class.latest_cask_version("doesnotexist")
-      expect(version).to be_nil
-    end
-  end
-end
diff --git a/Library/Homebrew/test/api_spec.rb b/Library/Homebrew/test/api_spec.rb
index 6d70ef66269d8..9186fc625cb94 100644
--- a/Library/Homebrew/test/api_spec.rb
+++ b/Library/Homebrew/test/api_spec.rb
@@ -1,25 +1,25 @@
-# typed: false
 # frozen_string_literal: true
 
 require "api"
 
-describe Homebrew::API do
+RSpec.describe Homebrew::API do
   let(:text) { "foo" }
   let(:json) { '{"foo":"bar"}' }
   let(:json_hash) { JSON.parse(json) }
+  let(:json_invalid) { '{"foo":"bar"' }
 
   def mock_curl_output(stdout: "", success: true)
-    curl_output = OpenStruct.new(stdout: stdout, success?: success)
+    curl_output = instance_double(SystemCommand::Result, stdout:, success?: success)
     allow(Utils::Curl).to receive(:curl_output).and_return curl_output
   end
 
-  describe "::fetch" do
-    it "fetches a text file" do
-      mock_curl_output stdout: text
-      fetched_text = described_class.fetch("foo.txt", json: false)
-      expect(fetched_text).to eq text
+  def mock_curl_download(stdout:)
+    allow(Utils::Curl).to receive(:curl_download) do |*_args, **kwargs|
+      kwargs[:to].write stdout
     end
+  end
 
+  describe "::fetch" do
     it "fetches a JSON file" do
       mock_curl_output stdout: json
       fetched_json = described_class.fetch("foo.json")
@@ -36,4 +36,58 @@ def mock_curl_output(stdout: "", success: true)
       expect { described_class.fetch("baz.txt") }.to raise_error(ArgumentError, /Invalid JSON file/)
     end
   end
+
+  describe "::fetch_json_api_file" do
+    let!(:cache_dir) { mktmpdir }
+
+    before do
+      (cache_dir/"bar.json").write "tmp"
+    end
+
+    it "fetches a JSON file" do
+      mock_curl_download stdout: json
+      fetched_json, = described_class.fetch_json_api_file("foo.json", target: cache_dir/"foo.json")
+      expect(fetched_json).to eq json_hash
+    end
+
+    it "updates an existing JSON file" do
+      mock_curl_download stdout: json
+      fetched_json, = described_class.fetch_json_api_file("bar.json", target: cache_dir/"bar.json")
+      expect(fetched_json).to eq json_hash
+    end
+
+    it "raises an error if the JSON file is invalid" do
+      mock_curl_download stdout: json_invalid
+      expect do
+        described_class.fetch_json_api_file("baz.json", target: cache_dir/"baz.json")
+      end.to raise_error(SystemExit)
+    end
+  end
+
+  describe "::tap_from_source_download" do
+    let(:api_cache_root) { Homebrew::API::HOMEBREW_CACHE_API_SOURCE }
+    let(:cache_path) do
+      api_cache_root/"Homebrew"/"homebrew-core"/"cf5c386c1fa2cb54279d78c0990dd7a0fa4bc327"/"Formula"/"foo.rb"
+    end
+
+    context "when given a path inside the API source cache" do
+      it "returns the corresponding tap" do
+        expect(described_class.tap_from_source_download(cache_path)).to eq CoreTap.instance
+      end
+    end
+
+    context "when given a path that is not inside the API source cache" do
+      let(:api_cache_root) { mktmpdir }
+
+      it "returns nil" do
+        expect(described_class.tap_from_source_download(cache_path)).to be_nil
+      end
+    end
+
+    context "when given a relative path that is not inside the API source cache" do
+      it "returns nil" do
+        expect(described_class.tap_from_source_download(Pathname("../foo.rb"))).to be_nil
+      end
+    end
+  end
 end
diff --git a/Library/Homebrew/test/attestation_spec.rb b/Library/Homebrew/test/attestation_spec.rb
new file mode 100644
index 0000000000000..48d85577178a6
--- /dev/null
+++ b/Library/Homebrew/test/attestation_spec.rb
@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require "diagnostic"
+
+RSpec.describe Homebrew::Attestation do
+  let(:fake_gh) { Pathname.new("/extremely/fake/gh") }
+  let(:fake_old_gh) { Pathname.new("/extremely/fake/old/gh") }
+  let(:fake_gh_creds) { "fake-gh-api-token" }
+  let(:fake_error_status) { instance_double(Process::Status, exitstatus: 1, termsig: nil) }
+  let(:fake_auth_status) { instance_double(Process::Status, exitstatus: 4, termsig: nil) }
+  let(:cached_download) { "/fake/cached/download" }
+  let(:fake_bottle_filename) do
+    instance_double(Bottle::Filename, name: "fakebottle", version: "1.0",
+   to_s: "fakebottle--1.0.faketag.bottle.tar.gz")
+  end
+  let(:fake_bottle_url) { "https://example.com/#{fake_bottle_filename}" }
+  let(:fake_bottle_tag) { instance_double(Utils::Bottles::Tag, to_sym: :faketag) }
+  let(:fake_all_bottle_tag) { instance_double(Utils::Bottles::Tag, to_sym: :all) }
+  let(:fake_bottle) do
+    instance_double(Bottle, cached_download:, filename: fake_bottle_filename, url: fake_bottle_url,
+                    tag: fake_bottle_tag)
+  end
+  let(:fake_all_bottle) do
+    instance_double(Bottle, cached_download:, filename: fake_bottle_filename, url: fake_bottle_url,
+                    tag: fake_all_bottle_tag)
+  end
+  let(:fake_result_invalid_json) { instance_double(SystemCommand::Result, stdout: "\"invalid JSON") }
+  let(:fake_result_json_resp) do
+    instance_double(SystemCommand::Result,
+                    stdout: JSON.dump([
+                      { verificationResult: {
+                        verifiedTimestamps: [{ timestamp: "2024-03-13T00:00:00Z" }],
+                        statement:          { subject: [{ name: fake_bottle_filename.to_s }] },
+                      } },
+                    ]))
+  end
+  let(:fake_result_json_resp_backfill) do
+    digest = Digest::SHA256.hexdigest(fake_bottle_url)
+    instance_double(SystemCommand::Result,
+                    stdout: JSON.dump([
+                      { verificationResult: {
+                        verifiedTimestamps: [{ timestamp: "2024-03-13T00:00:00Z" }],
+                        statement:          {
+                          subject: [{ name: "#{digest}--#{fake_bottle_filename}" }],
+                        },
+                      } },
+                    ]))
+  end
+  let(:fake_result_json_resp_too_new) do
+    instance_double(SystemCommand::Result,
+                    stdout: JSON.dump([
+                      { verificationResult: {
+                        verifiedTimestamps: [{ timestamp: "2024-03-15T00:00:00Z" }],
+                        statement:          { subject: [{ name: fake_bottle_filename.to_s }] },
+                      } },
+                    ]))
+  end
+  let(:fake_json_resp_wrong_sub) do
+    instance_double(SystemCommand::Result,
+                    stdout: JSON.dump([
+                      { verificationResult: {
+                        verifiedTimestamps: [{ timestamp: "2024-03-13T00:00:00Z" }],
+                        statement:          { subject: [{ name: "wrong-subject.tar.gz" }] },
+                      } },
+                    ]))
+  end
+
+  describe "::gh_executable" do
+    it "calls ensure_executable" do
+      expect(described_class).to receive(:ensure_executable!)
+        .with("gh", reason: "verifying attestations", latest: true)
+        .and_return(fake_gh)
+
+      described_class.gh_executable
+    end
+  end
+
+  # NOTE: `Homebrew::CLI::NamedArgs` will often return frozen arrays of formulae
+  #       so that's why we test with frozen arrays here.
+  describe "::sort_formulae_for_install", :integration_test do
+    let(:gh) { Formula["gh"] }
+    let(:other) { Formula["other"] }
+
+    before do
+      setup_test_formula("gh")
+      setup_test_formula("other")
+    end
+
+    context "when `gh` is in the formula list" do
+      it "moves `gh` formulae to the front of the list" do
+        expect(described_class).not_to receive(:gh_executable)
+
+        [
+          [[gh], [gh]],
+          [[gh, other], [gh, other]],
+          [[other, gh], [gh, other]],
+        ].each do |input, output|
+          expect(described_class.sort_formulae_for_install(input.freeze)).to eq(output)
+        end
+      end
+    end
+
+    context "when the formula list is empty" do
+      it "checks for the `gh` executable" do
+        expect(described_class).to receive(:gh_executable).once
+        expect(described_class.sort_formulae_for_install([].freeze)).to eq([])
+      end
+    end
+
+    context "when `gh` is not in the formula list" do
+      it "checks for the `gh` executable" do
+        expect(described_class).to receive(:gh_executable).once
+        expect(described_class.sort_formulae_for_install([other].freeze)).to eq([other])
+      end
+    end
+  end
+
+  describe "::check_attestation" do
+    before do
+      allow(described_class).to receive(:gh_executable)
+        .and_return(fake_gh)
+    end
+
+    it "raises without any gh credentials" do
+      expect(GitHub::API).to receive(:credentials)
+        .and_return(nil)
+
+      expect do
+        described_class.check_attestation fake_bottle,
+                                          described_class::HOMEBREW_CORE_REPO
+      end.to raise_error(described_class::GhAuthNeeded)
+    end
+
+    it "raises when gh subprocess fails" do
+      expect(GitHub::API).to receive(:credentials)
+        .and_return(fake_gh_creds)
+
+      expect(described_class).to receive(:system_command!)
+        .with(fake_gh, args: ["attestation", "verify", cached_download, "--repo",
+                              described_class::HOMEBREW_CORE_REPO, "--format", "json"],
+              env: { "GH_TOKEN" => fake_gh_creds, "GH_HOST" => "github.com" }, secrets: [fake_gh_creds],
+              print_stderr: false, chdir: HOMEBREW_TEMP)
+        .and_raise(ErrorDuringExecution.new(["foo"], status: fake_error_status))
+
+      expect do
+        described_class.check_attestation fake_bottle,
+                                          described_class::HOMEBREW_CORE_REPO
+      end.to raise_error(described_class::InvalidAttestationError)
+    end
+
+    it "raises auth error when gh subprocess fails with auth exit code" do
+      expect(GitHub::API).to receive(:credentials)
+        .and_return(fake_gh_creds)
+
+      expect(described_class).to receive(:system_command!)
+        .with(fake_gh, args: ["attestation", "verify", cached_download, "--repo",
+                              described_class::HOMEBREW_CORE_REPO, "--format", "json"],
+              env: { "GH_TOKEN" => fake_gh_creds, "GH_HOST" => "github.com" }, secrets: [fake_gh_creds],
+              print_stderr: false, chdir: HOMEBREW_TEMP)
+        .and_raise(ErrorDuringExecution.new(["foo"], status: fake_auth_status))
+
+      expect do
+        described_class.check_attestation fake_bottle,
+                                          described_class::HOMEBREW_CORE_REPO
+      end.to raise_error(described_class::GhAuthInvalid)
+    end
+
+    it "raises when gh returns invalid JSON" do
+      expect(GitHub::API).to receive(:credentials)
+        .and_return(fake_gh_creds)
+
+      expect(described_class).to receive(:system_command!)
+        .with(fake_gh, args: ["attestation", "verify", cached_download, "--repo",
+                              described_class::HOMEBREW_CORE_REPO, "--format", "json"],
+              env: { "GH_TOKEN" => fake_gh_creds, "GH_HOST" => "github.com" }, secrets: [fake_gh_creds],
+              print_stderr: false, chdir: HOMEBREW_TEMP)
+        .and_return(fake_result_invalid_json)
+
+      expect do
+        described_class.check_attestation fake_bottle,
+                                          described_class::HOMEBREW_CORE_REPO
+      end.to raise_error(described_class::InvalidAttestationError)
+    end
+
+    it "raises when gh returns other subjects" do
+      expect(GitHub::API).to receive(:credentials)
+        .and_return(fake_gh_creds)
+
+      expect(described_class).to receive(:system_command!)
+        .with(fake_gh, args: ["attestation", "verify", cached_download, "--repo",
+                              described_class::HOMEBREW_CORE_REPO, "--format", "json"],
+              env: { "GH_TOKEN" => fake_gh_creds, "GH_HOST" => "github.com" }, secrets: [fake_gh_creds],
+              print_stderr: false, chdir: HOMEBREW_TEMP)
+        .and_return(fake_json_resp_wrong_sub)
+
+      expect do
+        described_class.check_attestation fake_bottle,
+                                          described_class::HOMEBREW_CORE_REPO
+      end.to raise_error(described_class::InvalidAttestationError)
+    end
+
+    it "checks subject prefix when the bottle is an :all bottle" do
+      expect(GitHub::API).to receive(:credentials)
+        .and_return(fake_gh_creds)
+
+      expect(described_class).to receive(:system_command!)
+        .with(fake_gh, args: ["attestation", "verify", cached_download, "--repo",
+                              described_class::HOMEBREW_CORE_REPO, "--format", "json"],
+              env: { "GH_TOKEN" => fake_gh_creds, "GH_HOST" => "github.com" }, secrets: [fake_gh_creds],
+              print_stderr: false, chdir: HOMEBREW_TEMP)
+        .and_return(fake_result_json_resp)
+
+      described_class.check_attestation fake_all_bottle, described_class::HOMEBREW_CORE_REPO
+    end
+  end
+
+  describe "::check_core_attestation" do
+    before do
+      allow(described_class).to receive(:gh_executable)
+        .and_return(fake_gh)
+
+      allow(GitHub::API).to receive(:credentials)
+        .and_return(fake_gh_creds)
+    end
+
+    it "calls gh with args for homebrew-core" do
+      expect(described_class).to receive(:system_command!)
+        .with(fake_gh, args: ["attestation", "verify", cached_download, "--repo",
+                              described_class::HOMEBREW_CORE_REPO, "--format", "json"],
+              env: { "GH_TOKEN" => fake_gh_creds, "GH_HOST" => "github.com" }, secrets: [fake_gh_creds],
+              print_stderr: false, chdir: HOMEBREW_TEMP)
+        .and_return(fake_result_json_resp)
+
+      described_class.check_core_attestation fake_bottle
+    end
+
+    it "calls gh with args for backfill when homebrew-core attestation is missing" do
+      expect(described_class).to receive(:system_command!)
+        .with(fake_gh, args: ["attestation", "verify", cached_download, "--repo",
+                              described_class::HOMEBREW_CORE_REPO, "--format", "json"],
+              env: { "GH_TOKEN" => fake_gh_creds, "GH_HOST" => "github.com" }, secrets: [fake_gh_creds],
+              print_stderr: false, chdir: HOMEBREW_TEMP)
+        .once
+        .and_raise(described_class::MissingAttestationError)
+
+      expect(described_class).to receive(:system_command!)
+        .with(fake_gh, args: ["attestation", "verify", cached_download, "--repo",
+                              described_class::BACKFILL_REPO, "--format", "json"],
+              env: { "GH_TOKEN" => fake_gh_creds, "GH_HOST" => "github.com" }, secrets: [fake_gh_creds],
+              print_stderr: false, chdir: HOMEBREW_TEMP)
+        .and_return(fake_result_json_resp_backfill)
+
+      described_class.check_core_attestation fake_bottle
+    end
+
+    it "raises when the backfilled attestation is too new" do
+      expect(described_class).to receive(:system_command!)
+        .with(fake_gh, args: ["attestation", "verify", cached_download, "--repo",
+                              described_class::HOMEBREW_CORE_REPO, "--format", "json"],
+              env: { "GH_TOKEN" => fake_gh_creds, "GH_HOST" => "github.com" }, secrets: [fake_gh_creds],
+              print_stderr: false, chdir: HOMEBREW_TEMP)
+        .exactly(described_class::ATTESTATION_MAX_RETRIES + 1)
+        .and_raise(described_class::MissingAttestationError)
+
+      expect(described_class).to receive(:system_command!)
+        .with(fake_gh, args: ["attestation", "verify", cached_download, "--repo",
+                              described_class::BACKFILL_REPO, "--format", "json"],
+              env: { "GH_TOKEN" => fake_gh_creds, "GH_HOST" => "github.com" }, secrets: [fake_gh_creds],
+              print_stderr: false, chdir: HOMEBREW_TEMP)
+        .exactly(described_class::ATTESTATION_MAX_RETRIES + 1)
+        .and_return(fake_result_json_resp_too_new)
+
+      expect do
+        described_class.check_core_attestation fake_bottle
+      end.to raise_error(described_class::InvalidAttestationError)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/bash_spec.rb b/Library/Homebrew/test/bash_spec.rb
index 0a3a80fe72031..9a23d1dc298de 100644
--- a/Library/Homebrew/test/bash_spec.rb
+++ b/Library/Homebrew/test/bash_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "open3"
 
-describe "Bash" do
+RSpec.describe "Bash" do
   matcher :have_valid_bash_syntax do
     match do |file|
       stdout, stderr, status = Open3.capture3("/bin/bash", "-n", file)
@@ -49,7 +48,7 @@
         next if path.symlink?
         next unless path.executable?
         next if path.basename.to_s == "cc" # `bash -n` tries to parse the Ruby part
-        next unless path.read(12) == "#!/bin/bash\n"
+        next if path.read(12) != "#!/bin/bash\n"
 
         expect(path).to have_valid_bash_syntax
       end
diff --git a/Library/Homebrew/test/bottle_filename_spec.rb b/Library/Homebrew/test/bottle_filename_spec.rb
index effebff4b4a0d..68b7283afc0fc 100644
--- a/Library/Homebrew/test/bottle_filename_spec.rb
+++ b/Library/Homebrew/test/bottle_filename_spec.rb
@@ -1,62 +1,61 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula"
 require "software_spec"
 
-describe Bottle::Filename do
-  subject { described_class.new(name, version, tag, rebuild) }
+RSpec.describe Bottle::Filename do
+  subject(:filename) { described_class.new(name, version, tag, rebuild) }
 
   let(:name) { "user/repo/foo" }
-  let(:version) { "1.0" }
-  let(:tag) { :tag }
+  let(:version) { PkgVersion.new(Version.new("1.0"), 0) }
+  let(:tag) { Utils::Bottles::Tag.from_symbol(:x86_64_linux) }
   let(:rebuild) { 0 }
 
   describe "#extname" do
-    its(:extname) { is_expected.to eq ".tag.bottle.tar.gz" }
+    it(:extname) { expect(filename.extname).to eq ".x86_64_linux.bottle.tar.gz" }
 
     context "when rebuild is 0" do
-      its(:extname) { is_expected.to eq ".tag.bottle.tar.gz" }
+      it(:extname) { expect(filename.extname).to eq ".x86_64_linux.bottle.tar.gz" }
     end
 
     context "when rebuild is 1" do
       let(:rebuild) { 1 }
 
-      its(:extname) { is_expected.to eq ".tag.bottle.1.tar.gz" }
+      it(:extname) { expect(filename.extname).to eq ".x86_64_linux.bottle.1.tar.gz" }
     end
   end
 
   describe "#to_s and #to_str" do
-    its(:to_s) { is_expected.to eq "foo--1.0.tag.bottle.tar.gz" }
-    its(:to_str) { is_expected.to eq "foo--1.0.tag.bottle.tar.gz" }
+    it(:to_s) { expect(filename.to_s).to eq "foo--1.0.x86_64_linux.bottle.tar.gz" }
+    it(:to_str) { expect(filename.to_str).to eq "foo--1.0.x86_64_linux.bottle.tar.gz" }
   end
 
   describe "#url_encode" do
-    its(:url_encode) { is_expected.to eq "foo-1.0.tag.bottle.tar.gz" }
+    it(:url_encode) { expect(filename.url_encode).to eq "foo-1.0.x86_64_linux.bottle.tar.gz" }
   end
 
   describe "#github_packages" do
-    its(:github_packages) { is_expected.to eq "foo--1.0.tag.bottle.tar.gz" }
+    it(:github_packages) { expect(filename.github_packages).to eq "foo--1.0.x86_64_linux.bottle.tar.gz" }
   end
 
   describe "#json" do
-    its(:json) { is_expected.to eq "foo--1.0.tag.bottle.json" }
+    it(:json) { expect(filename.json).to eq "foo--1.0.x86_64_linux.bottle.json" }
 
     context "when rebuild is 1" do
-      its(:json) { is_expected.to eq "foo--1.0.tag.bottle.json" }
+      it(:json) { expect(filename.json).to eq "foo--1.0.x86_64_linux.bottle.json" }
     end
   end
 
   describe "::create" do
-    subject { described_class.create(f, :tag, 0) }
+    subject(:filename) { described_class.create(f, tag, rebuild) }
 
-    let(:f) {
+    let(:f) do
       formula do
         url "https://brew.sh/foo.tar.gz"
         version "1.0"
       end
-    }
+    end
 
-    its(:to_s) { is_expected.to eq "formula_name--1.0.tag.bottle.tar.gz" }
+    it(:to_s) { expect(filename.to_s).to eq "formula_name--1.0.x86_64_linux.bottle.tar.gz" }
   end
 end
diff --git a/Library/Homebrew/test/build_environment_spec.rb b/Library/Homebrew/test/build_environment_spec.rb
index b073335a7e1e0..7cdba09d73c77 100644
--- a/Library/Homebrew/test/build_environment_spec.rb
+++ b/Library/Homebrew/test/build_environment_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "build_environment"
 
-describe BuildEnvironment do
+RSpec.describe BuildEnvironment do
   let(:env) { described_class.new }
 
   describe "#<<" do
@@ -30,16 +29,21 @@
   end
 
   describe BuildEnvironment::DSL do
-    subject(:build_environment_dsl) { double.extend(described_class) }
+    let(:build_environment_dsl) do
+      klass = described_class
+      Class.new do
+        extend(klass)
+      end
+    end
 
     context "with a single argument" do
-      before do
-        build_environment_dsl.instance_eval do
+      subject(:build_env) do
+        Class.new(build_environment_dsl) do
           env :std
         end
       end
 
-      its(:env) { is_expected.to be_std }
+      it(:env) { expect(build_env.env).to be_std }
     end
   end
 end
diff --git a/Library/Homebrew/test/build_options_spec.rb b/Library/Homebrew/test/build_options_spec.rb
index a36d8314d667f..4ea430450490b 100644
--- a/Library/Homebrew/test/build_options_spec.rb
+++ b/Library/Homebrew/test/build_options_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "build_options"
 require "options"
 
-describe BuildOptions do
+RSpec.describe BuildOptions do
   alias_matcher :be_built_with, :be_with
   alias_matcher :be_built_without, :be_without
 
diff --git a/Library/Homebrew/test/bump_version_parser_spec.rb b/Library/Homebrew/test/bump_version_parser_spec.rb
new file mode 100644
index 0000000000000..2e47b14868f03
--- /dev/null
+++ b/Library/Homebrew/test/bump_version_parser_spec.rb
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "bump_version_parser"
+
+RSpec.describe Homebrew::BumpVersionParser do
+  let(:general_version) { "1.2.3" }
+  let(:intel_version) { "2.3.4" }
+  let(:arm_version) { "3.4.5" }
+
+  context "when initializing with no versions" do
+    it "raises a usage error" do
+      expect do
+        described_class.new
+      end.to raise_error(UsageError, "Invalid usage: `--version` must not be empty.")
+    end
+  end
+
+  context "when initializing with valid versions" do
+    let(:new_version) { described_class.new(general: general_version, arm: arm_version, intel: intel_version) }
+
+    it "correctly parses general version" do
+      expect(new_version.general).to eq(Cask::DSL::Version.new(general_version.to_s))
+    end
+
+    it "correctly parses arm version" do
+      expect(new_version.arm).to eq(Cask::DSL::Version.new(arm_version.to_s))
+    end
+
+    it "correctly parses intel version" do
+      expect(new_version.intel).to eq(Cask::DSL::Version.new(intel_version.to_s))
+    end
+
+    context "when only the intel version is provided" do
+      it "raises a UsageError" do
+        expect do
+          described_class.new(intel: intel_version)
+        end.to raise_error(UsageError,
+                           "Invalid usage: `--version-arm` must not be empty.")
+      end
+    end
+
+    context "when only the arm version is provided" do
+      it "raises a UsageError" do
+        expect do
+          described_class.new(arm: arm_version)
+        end.to raise_error(UsageError,
+                           "Invalid usage: `--version-intel` must not be empty.")
+      end
+    end
+
+    context "when the version is latest" do
+      it "returns a version object for latest" do
+        new_version = described_class.new(general: "latest")
+        expect(new_version.general.to_s).to eq("latest")
+      end
+
+      context "when the version is not latest" do
+        it "returns a version object for the given version" do
+          new_version = described_class.new(general: general_version)
+          expect(new_version.general.to_s).to eq(general_version)
+        end
+      end
+    end
+
+    context "when checking if VersionParser is blank" do
+      it "returns false if any version is present" do
+        new_version = described_class.new(general: general_version.to_s, arm: "", intel: "")
+        expect(new_version.blank?).to be(false)
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/test/bundle_version_spec.rb b/Library/Homebrew/test/bundle_version_spec.rb
index 3836fa1fa3523..646adb63aa5a7 100644
--- a/Library/Homebrew/test/bundle_version_spec.rb
+++ b/Library/Homebrew/test/bundle_version_spec.rb
@@ -1,9 +1,30 @@
-# typed: false
 # frozen_string_literal: true
 
 require "bundle_version"
 
-describe Homebrew::BundleVersion do
+RSpec.describe Homebrew::BundleVersion do
+  describe "#<=>" do
+    it "compares both the `short_version` and `version`" do
+      expect(described_class.new("1.2.3", "3000")).to be < described_class.new("1.2.3", "4000")
+      expect(described_class.new("1.2.3", "4000")).to be <= described_class.new("1.2.3", "4000")
+      expect(described_class.new("1.2.3", "4000")).to be >= described_class.new("1.2.3", "4000")
+      expect(described_class.new("1.2.4", "4000")).to be > described_class.new("1.2.3", "4000")
+    end
+
+    it "compares `version` first" do
+      expect(described_class.new("1.2.4", "3000")).to be < described_class.new("1.2.3", "4000")
+    end
+
+    it "does not fail when `short_version` or `version` is missing" do
+      expect(described_class.new("1.06", nil)).to be < described_class.new("1.12", "1.12")
+      expect(described_class.new("1.06", "471")).to be > described_class.new(nil, "311")
+      expect(described_class.new("1.2.3", nil)).to be < described_class.new("1.2.4", nil)
+      expect(described_class.new(nil, "1.2.3")).to be < described_class.new(nil, "1.2.4")
+      expect(described_class.new("1.2.3", nil)).to be < described_class.new(nil, "1.2.3")
+      expect(described_class.new(nil, "1.2.3")).to be > described_class.new("1.2.3", nil)
+    end
+  end
+
   describe "#nice_version" do
     expected_mappings = {
       ["1.2", nil]            => "1.2",
@@ -26,10 +47,4 @@
       end
     end
   end
-
-  describe "#<=>" do
-    it "does not fail when a `version` is nil" do
-      expect(described_class.new("1.06", nil)).to be < described_class.new("1.12", "1.12")
-    end
-  end
 end
diff --git a/Library/Homebrew/test/cache_store_spec.rb b/Library/Homebrew/test/cache_store_spec.rb
index 9503d8817ab77..ef0cc72bfdc22 100644
--- a/Library/Homebrew/test/cache_store_spec.rb
+++ b/Library/Homebrew/test/cache_store_spec.rb
@@ -1,29 +1,29 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cache_store"
 
-describe CacheStoreDatabase do
+RSpec.describe CacheStoreDatabase do
   subject(:sample_db) { described_class.new(:sample) }
 
   describe "self.use" do
     let(:type) { :test }
 
     it "creates a new `DatabaseCache` instance" do
-      cache_store = double("cache_store", write_if_dirty!: nil)
+      cache_store = instance_double(described_class, "cache_store", write_if_dirty!: nil)
       expect(described_class).to receive(:new).with(type).and_return(cache_store)
       expect(cache_store).to receive(:write_if_dirty!)
-      described_class.use(type) { |_db| }
+      described_class.use(type) do |_db|
+        # do nothing
+      end
     end
   end
 
   describe "#set" do
-    let(:db) { double("db", :[]= => nil) }
+    let(:db) { instance_double(Hash, "db", :[]= => nil) }
 
     it "sets the value in the `CacheStoreDatabase`" do
       allow(File).to receive(:write)
-      allow(sample_db).to receive(:created?).and_return(true)
-      allow(sample_db).to receive(:db).and_return(db)
+      allow(sample_db).to receive_messages(created?: true, db:)
 
       expect(db).to receive(:has_key?).with(:foo).and_return(false)
       expect(db).not_to have_key(:foo)
@@ -33,23 +33,21 @@
 
   describe "#get" do
     context "with a database created" do
-      let(:db) { double("db", :[] => "bar") }
+      let(:db) { instance_double(Hash, "db", :[] => "bar") }
 
       it "gets value in the `CacheStoreDatabase` corresponding to the key" do
-        allow(sample_db).to receive(:created?).and_return(true)
         expect(db).to receive(:has_key?).with(:foo).and_return(true)
-        allow(sample_db).to receive(:db).and_return(db)
+        allow(sample_db).to receive_messages(created?: true, db:)
         expect(db).to have_key(:foo)
         expect(sample_db.get(:foo)).to eq("bar")
       end
     end
 
     context "without a database created" do
-      let(:db) { double("db", :[] => nil) }
+      let(:db) { instance_double(Hash, "db", :[] => nil) }
 
       before do
-        allow(sample_db).to receive(:created?).and_return(false)
-        allow(sample_db).to receive(:db).and_return(db)
+        allow(sample_db).to receive_messages(created?: false, db:)
       end
 
       it "does not get value in the `CacheStoreDatabase` corresponding to key" do
@@ -65,11 +63,10 @@
 
   describe "#delete" do
     context "with a database created" do
-      let(:db) { double("db", :[] => { foo: "bar" }) }
+      let(:db) { instance_double(Hash, "db", :[] => { foo: "bar" }) }
 
       before do
-        allow(sample_db).to receive(:created?).and_return(true)
-        allow(sample_db).to receive(:db).and_return(db)
+        allow(sample_db).to receive_messages(created?: true, db:)
       end
 
       it "deletes value in the `CacheStoreDatabase` corresponding to the key" do
@@ -79,11 +76,10 @@
     end
 
     context "without a database created" do
-      let(:db) { double("db", delete: nil) }
+      let(:db) { instance_double(Hash, "db", delete: nil) }
 
       before do
-        allow(sample_db).to receive(:created?).and_return(false)
-        allow(sample_db).to receive(:db).and_return(db)
+        allow(sample_db).to receive_messages(created?: false, db:)
       end
 
       it "does not call `db.delete` if `CacheStoreDatabase.created?` is `false`" do
diff --git a/Library/Homebrew/test/cask/artifact/abstract_artifact_spec.rb b/Library/Homebrew/test/cask/artifact/abstract_artifact_spec.rb
new file mode 100644
index 0000000000000..1bcde8ed7a17b
--- /dev/null
+++ b/Library/Homebrew/test/cask/artifact/abstract_artifact_spec.rb
@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+RSpec.describe Cask::Artifact::AbstractArtifact, :cask do
+  describe ".read_script_arguments" do
+    let(:stanza) { :installer }
+
+    it "accepts a string and uses it as the executable" do
+      arguments = "something"
+
+      expect(described_class.read_script_arguments(arguments, stanza)).to eq(["something", {}])
+    end
+
+    it "accepts a hash with an executable" do
+      arguments = { executable: "something" }
+
+      expect(described_class.read_script_arguments(arguments, stanza)).to eq(["something", {}])
+    end
+
+    it "does not mutate the original arguments in place" do
+      arguments = { executable: "something" }
+      clone = arguments.dup
+
+      described_class.read_script_arguments(arguments, stanza)
+
+      expect(arguments).to eq(clone)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/cask/artifact/alt_target_spec.rb b/Library/Homebrew/test/cask/artifact/alt_target_spec.rb
index a31554950ac4e..9bd396a9d47e0 100644
--- a/Library/Homebrew/test/cask/artifact/alt_target_spec.rb
+++ b/Library/Homebrew/test/cask/artifact/alt_target_spec.rb
@@ -1,15 +1,14 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Artifact::App, :cask do
+RSpec.describe Cask::Artifact::App, :cask do
   describe "activate to alternate target" do
     let(:cask) { Cask::CaskLoader.load(cask_path("with-alt-target")) }
 
-    let(:install_phase) {
+    let(:install_phase) do
       cask.artifacts.select { |a| a.is_a?(described_class) }.each do |artifact|
         artifact.install_phase(command: NeverSudoSystemCommand, force: false)
       end
-    }
+    end
 
     let(:source_path) { cask.staged_path.join("Caffeine.app") }
     let(:target_path) { cask.config.appdir.join("AnotherName.app") }
@@ -29,7 +28,7 @@
     end
 
     describe "when app is in a subdirectory" do
-      let(:cask) {
+      let(:cask) do
         Cask::Cask.new("subdir") do
           url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
           homepage "https://brew.sh/local-caffeine"
@@ -37,7 +36,7 @@
           sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
           app "subdir/Caffeine.app", target: "AnotherName.app"
         end
-      }
+      end
 
       it "installs the given apps using the proper target directory" do
         appsubdir = cask.staged_path.join("subdir").tap(&:mkpath)
diff --git a/Library/Homebrew/test/cask/artifact/app_spec.rb b/Library/Homebrew/test/cask/artifact/app_spec.rb
index 23a5cd944fe9c..b4f0e800a35d7 100644
--- a/Library/Homebrew/test/cask/artifact/app_spec.rb
+++ b/Library/Homebrew/test/cask/artifact/app_spec.rb
@@ -1,17 +1,18 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Artifact::App, :cask do
+RSpec.describe Cask::Artifact::App, :cask do
   let(:cask) { Cask::CaskLoader.load(cask_path("local-caffeine")) }
-  let(:command) { SystemCommand }
+  let(:command) { NeverSudoSystemCommand }
+  let(:adopt) { false }
   let(:force) { false }
+  let(:auto_updates) { false }
   let(:app) { cask.artifacts.find { |a| a.is_a?(described_class) } }
 
   let(:source_path) { cask.staged_path.join("Caffeine.app") }
   let(:target_path) { cask.config.appdir.join("Caffeine.app") }
 
-  let(:install_phase) { app.install_phase(command: command, force: force) }
-  let(:uninstall_phase) { app.uninstall_phase(command: command, force: force) }
+  let(:install_phase) { app.install_phase(command:, adopt:, force:, auto_updates:) }
+  let(:uninstall_phase) { app.uninstall_phase(command:, force:) }
 
   before do
     InstallHelper.install_without_artifacts(cask)
@@ -26,7 +27,7 @@
     end
 
     describe "when app is in a subdirectory" do
-      let(:cask) {
+      let(:cask) do
         Cask::Cask.new("subdir") do
           url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
           homepage "https://brew.sh/local-caffeine"
@@ -34,7 +35,7 @@
           sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
           app "subdir/Caffeine.app"
         end
-      }
+      end
 
       it "installs the given app using the proper target directory" do
         appsubdir = cask.staged_path.join("subdir").tap(&:mkpath)
@@ -79,6 +80,88 @@
         expect(contents_path).not_to exist
       end
 
+      describe "given the adopt option" do
+        let(:adopt) { true }
+
+        describe "when the target compares different from the source" do
+          describe "when the cask does not auto_updates" do
+            it "avoids clobbering the existing app if brew manages updates" do
+              stdout = <<~EOS
+                ==> Adopting existing App at '#{target_path}'
+              EOS
+
+              expect { install_phase }
+                .to output(stdout).to_stdout
+                .and raise_error(
+                  Cask::CaskError,
+                  "It seems the existing App is different from the one being installed.",
+                )
+
+              expect(source_path).to be_a_directory
+              expect(target_path).to be_a_directory
+              expect(File.identical?(source_path, target_path)).to be false
+
+              contents_path = target_path.join("Contents/Info.plist")
+              expect(contents_path).not_to exist
+            end
+          end
+
+          describe "when the cask auto_updates" do
+            before do
+              target_path.delete
+              FileUtils.cp_r source_path, target_path
+              File.write(target_path.join("Contents/Info.plist"), "different")
+            end
+
+            let(:auto_updates) { true }
+
+            it "adopts the existing app" do
+              stdout = <<~EOS
+                ==> Adopting existing App at '#{target_path}'
+              EOS
+
+              stderr = ""
+
+              expect { install_phase }
+                .to output(stdout).to_stdout
+                .and output(stderr).to_stderr
+
+              expect(source_path).to be_a_symlink
+              expect(target_path).to be_a_directory
+
+              contents_path = target_path.join("Contents/Info.plist")
+              expect(contents_path).to exist
+              expect(File.read(contents_path)).to eq("different")
+            end
+          end
+        end
+
+        describe "when the target compares the same as the source" do
+          before do
+            target_path.delete
+            FileUtils.cp_r source_path, target_path
+          end
+
+          it "adopts the existing app" do
+            stdout = <<~EOS
+              ==> Adopting existing App at '#{target_path}'
+            EOS
+
+            stderr = ""
+
+            expect { install_phase }
+              .to output(stdout).to_stdout
+              .and output(stderr).to_stderr
+
+            expect(source_path).to be_a_symlink
+            expect(target_path).to be_a_directory
+
+            contents_path = target_path.join("Contents/Info.plist")
+            expect(contents_path).to exist
+          end
+        end
+      end
+
       describe "given the force option" do
         let(:force) { true }
 
@@ -120,21 +203,7 @@
           end
 
           it "overwrites the existing app" do
-            expect(command).to receive(:run).with(
-              "/bin/chmod", args: [
-                "-R", "--", "u+rwx", target_path
-              ], must_succeed: false
-            ).and_call_original
-            expect(command).to receive(:run).with(
-              "/bin/chmod", args: [
-                "-R", "-N", target_path
-              ], must_succeed: false
-            ).and_call_original
-            expect(command).to receive(:run).with(
-              "/usr/bin/chflags", args: [
-                "-R", "--", "000", target_path
-              ], must_succeed: false
-            ).and_call_original
+            expect(command).to receive(:run).and_call_original.at_least(:once)
 
             stdout = <<~EOS
               ==> Removing App '#{target_path}'
@@ -202,7 +271,7 @@
     end
 
     it "gives a warning if the source doesn't exist" do
-      source_path.rmtree
+      FileUtils.rm_r(source_path)
 
       message = "It seems the App source '#{source_path}' is not there."
 
@@ -211,6 +280,11 @@
   end
 
   describe "uninstall_phase" do
+    after do
+      FileUtils.chmod 0755, target_path if target_path.exist?
+      FileUtils.chmod 0755, source_path if source_path.exist?
+    end
+
     it "deletes managed apps" do
       install_phase
 
@@ -220,6 +294,16 @@
 
       expect(target_path).not_to exist
     end
+
+    it "backs up read-only managed apps" do
+      install_phase
+
+      FileUtils.chmod 0544, target_path
+
+      uninstall_phase
+
+      expect(source_path).to be_a_directory
+    end
   end
 
   describe "summary" do
@@ -244,4 +328,94 @@
       end
     end
   end
+
+  describe "upgrade" do
+    before do
+      install_phase
+    end
+
+    # Fix for https://github.com/Homebrew/homebrew-cask/issues/102721
+    it "reuses the same directory" do
+      contents_path = target_path.join("Contents/Info.plist")
+
+      expect(target_path).to exist
+      inode = target_path.stat.ino
+      expect(contents_path).to exist
+
+      app.uninstall_phase(command:, force:, successor: cask)
+
+      expect(target_path).to exist
+      expect(target_path.children).to be_empty
+      expect(contents_path).not_to exist
+
+      app.install_phase(command:, adopt:, force:, predecessor: cask)
+      expect(target_path).to exist
+      expect(target_path.stat.ino).to eq(inode)
+
+      expect(contents_path).to exist
+    end
+
+    describe "when the system blocks modifying apps" do
+      it "uninstalls and reinstalls the app" do
+        target_contents_path = target_path.join("Contents")
+
+        expect(File).to receive(:write).with(target_path / ".homebrew-write-test",
+                                             instance_of(String)).and_raise(Errno::EACCES)
+
+        app.uninstall_phase(command:, force:, successor: cask)
+        expect(target_path).not_to exist
+
+        app.install_phase(command:, adopt:, force:, predecessor: cask)
+        expect(target_contents_path).to exist
+      end
+    end
+
+    describe "when the directory is owned by root" do
+      before do
+        allow(app.target).to receive_messages(writable?: false, owned?: false)
+      end
+
+      it "reuses the same directory" do
+        source_contents_path = source_path.join("Contents")
+        target_contents_path = target_path.join("Contents")
+
+        allow(command).to receive(:run!).with(any_args).and_call_original
+
+        expect(command).to receive(:run!)
+          .with("/bin/cp", args: ["-pR", source_contents_path, target_path],
+                           sudo: true)
+          .and_call_original
+        expect(FileUtils).not_to receive(:move).with(source_contents_path, an_instance_of(Pathname))
+
+        app.uninstall_phase(command:, force:, successor: cask)
+        expect(target_contents_path).not_to exist
+        expect(target_path).to exist
+        expect(source_contents_path).to exist
+
+        app.install_phase(command:, adopt:, force:, predecessor: cask)
+        expect(target_contents_path).to exist
+      end
+
+      describe "when the system blocks modifying apps" do
+        it "uninstalls and reinstalls the app" do
+          target_contents_path = target_path.join("Contents")
+
+          allow(command).to receive(:run!).with(any_args).and_call_original
+
+          expect(command).to receive(:run!)
+            .with("touch", args:         [target_path / ".homebrew-write-test"],
+                           print_stderr: false,
+                           sudo:         true)
+            .and_raise(ErrorDuringExecution.new([], status: 1,
+output: [[:stderr, "touch: #{target_path}/.homebrew-write-test: Operation not permitted\n"]], secrets: []))
+
+          app.uninstall_phase(command:, force:, successor: cask)
+          expect(target_path).not_to exist
+
+          app.install_phase(command:, adopt:, force:, predecessor: cask)
+          expect(target_contents_path).to exist
+        end
+      end
+    end
+  end
 end
diff --git a/Library/Homebrew/test/cask/artifact/binary_spec.rb b/Library/Homebrew/test/cask/artifact/binary_spec.rb
index ba54834ab8a82..74afda456a7ca 100644
--- a/Library/Homebrew/test/cask/artifact/binary_spec.rb
+++ b/Library/Homebrew/test/cask/artifact/binary_spec.rb
@@ -1,12 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Artifact::Binary, :cask do
-  let(:cask) {
+RSpec.describe Cask::Artifact::Binary, :cask do
+  let(:cask) do
     Cask::CaskLoader.load(cask_path("with-binary")).tap do |cask|
       InstallHelper.install_without_artifacts(cask)
     end
-  }
+  end
   let(:artifacts) { cask.artifacts.select { |a| a.is_a?(described_class) } }
   let(:binarydir) { cask.config.binarydir }
   let(:expected_path) { binarydir.join("binary") }
@@ -21,9 +20,9 @@
   end
 
   context "when --no-binaries is specified" do
-    let(:cask) {
+    let(:cask) do
       Cask::CaskLoader.load(cask_path("with-binary"))
-    }
+    end
 
     it "doesn't link the binary when --no-binaries is specified" do
       Cask::Installer.new(cask, binaries: false).install
@@ -41,11 +40,11 @@
   end
 
   context "when the binary is not executable" do
-    let(:cask) {
+    let(:cask) do
       Cask::CaskLoader.load(cask_path("with-non-executable-binary")).tap do |cask|
         InstallHelper.install_without_artifacts(cask)
       end
-    }
+    end
 
     let(:expected_path) { cask.config.binarydir.join("naked_non_executable") }
 
@@ -65,11 +64,11 @@
   it "avoids clobbering an existing binary by linking over it" do
     FileUtils.touch expected_path
 
-    expect {
+    expect do
       artifacts.each do |artifact|
         artifact.install_phase(command: NeverSudoSystemCommand, force: false)
       end
-    }.to raise_error(Cask::CaskError)
+    end.to raise_error(Cask::CaskError)
 
     expect(expected_path).not_to be :symlink?
   end
@@ -77,11 +76,11 @@
   it "avoids clobbering an existing symlink" do
     expected_path.make_symlink("/tmp")
 
-    expect {
+    expect do
       artifacts.each do |artifact|
         artifact.install_phase(command: NeverSudoSystemCommand, force: false)
       end
-    }.to raise_error(Cask::CaskError)
+    end.to raise_error(Cask::CaskError)
 
     expect(File.readlink(expected_path)).to eq("/tmp")
   end
@@ -97,11 +96,11 @@
   end
 
   context "when the binary is inside an app package" do
-    let(:cask) {
+    let(:cask) do
       Cask::CaskLoader.load(cask_path("with-embedded-binary")).tap do |cask|
         InstallHelper.install_without_artifacts(cask)
       end
-    }
+    end
 
     it "links the binary to the proper directory" do
       cask.artifacts.select { |a| a.is_a?(Cask::Artifact::App) }.each do |artifact|
diff --git a/Library/Homebrew/test/cask/artifact/generic_artifact_spec.rb b/Library/Homebrew/test/cask/artifact/generic_artifact_spec.rb
index d8069478380aa..7359c29261929 100644
--- a/Library/Homebrew/test/cask/artifact/generic_artifact_spec.rb
+++ b/Library/Homebrew/test/cask/artifact/generic_artifact_spec.rb
@@ -1,16 +1,15 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Artifact::Artifact, :cask do
+RSpec.describe Cask::Artifact::Artifact, :cask do
   let(:cask) { Cask::CaskLoader.load(cask_path("with-generic-artifact")) }
 
-  let(:install_phase) {
+  let(:install_phase) do
     lambda do
       cask.artifacts.select { |a| a.is_a?(described_class) }.each do |artifact|
         artifact.install_phase(command: NeverSudoSystemCommand, force: false)
       end
     end
-  }
+  end
 
   let(:source_path) { cask.staged_path.join("Caffeine.app") }
   let(:target_path) { cask.config.appdir.join("Caffeine.app") }
@@ -21,25 +20,25 @@
 
   context "without target" do
     it "fails to load" do
-      expect {
-        Cask::CaskLoader.load(cask_path("invalid/invalid-generic-artifact-no-target"))
-      }.to raise_error(Cask::CaskInvalidError, /Generic Artifact.*requires.*target/)
+      expect do
+        Cask::CaskLoader.load("invalid-generic-artifact-no-target")
+      end.to raise_error(Cask::CaskInvalidError, /Generic Artifact.*requires.*target/)
     end
   end
 
   context "with relative target" do
     it "does not fail to load" do
-      expect {
-        Cask::CaskLoader.load(cask_path("generic-artifact-relative-target"))
-      }.not_to raise_error
+      expect do
+        Cask::CaskLoader.load("generic-artifact-relative-target")
+      end.not_to raise_error
     end
   end
 
   context "with user-relative target" do
     it "does not fail to load" do
-      expect {
-        Cask::CaskLoader.load(cask_path("generic-artifact-user-relative-target"))
-      }.not_to raise_error
+      expect do
+        Cask::CaskLoader.load("generic-artifact-user-relative-target")
+      end.not_to raise_error
     end
   end
 
@@ -53,9 +52,9 @@
   it "avoids clobbering an existing artifact" do
     target_path.mkpath
 
-    expect {
+    expect do
       install_phase.call
-    }.to raise_error(Cask::CaskError)
+    end.to raise_error(Cask::CaskError)
 
     expect(source_path).to be_a_directory
     expect(target_path).to be_a_directory
diff --git a/Library/Homebrew/test/cask/artifact/installer_spec.rb b/Library/Homebrew/test/cask/artifact/installer_spec.rb
index 8d24d826ef3a6..95f30f748f430 100644
--- a/Library/Homebrew/test/cask/artifact/installer_spec.rb
+++ b/Library/Homebrew/test/cask/artifact/installer_spec.rb
@@ -1,11 +1,10 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Artifact::Installer, :cask do
+RSpec.describe Cask::Artifact::Installer, :cask do
   subject(:installer) { described_class.new(cask, **args) }
 
   let(:staged_path) { mktmpdir }
-  let(:cask) { instance_double(Cask::Cask, staged_path: staged_path) }
+  let(:cask) { instance_double(Cask::Cask, staged_path:) }
 
   let(:command) { SystemCommand }
 
@@ -16,9 +15,9 @@
       let(:args) { { manual: "installer" } }
 
       it "shows a message prompting to run the installer manually" do
-        expect {
-          installer.install_phase(command: command)
-        }.to output(%r{run the installer at:\s+#{staged_path}/installer}).to_stdout
+        expect do
+          installer.install_phase(command:)
+        end.to output(%r{open #{staged_path}/installer}).to_stdout
       end
     end
 
@@ -38,7 +37,7 @@
           ),
         )
 
-        installer.install_phase(command: command)
+        installer.install_phase(command:)
       end
     end
   end
diff --git a/Library/Homebrew/test/cask/artifact/manpage_spec.rb b/Library/Homebrew/test/cask/artifact/manpage_spec.rb
index 9a447b7d0d101..23048504e1cb4 100644
--- a/Library/Homebrew/test/cask/artifact/manpage_spec.rb
+++ b/Library/Homebrew/test/cask/artifact/manpage_spec.rb
@@ -1,11 +1,10 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Artifact::Manpage, :cask do
-  let(:cask) { Cask::CaskLoader.load(cask_path(cask_token)) }
+RSpec.describe Cask::Artifact::Manpage, :cask do
+  let(:cask) { Cask::CaskLoader.load(cask_token) }
 
   context "without section" do
-    let(:cask_token) { "invalid/invalid-manpage-no-section" }
+    let(:cask_token) { "invalid-manpage-no-section" }
 
     it "fails to load a cask without section" do
       expect { cask }.to raise_error(Cask::CaskInvalidError, /is not a valid man page name/)
@@ -13,13 +12,13 @@
   end
 
   context "with install" do
-    let(:install_phase) {
+    let(:install_phase) do
       lambda do
         cask.artifacts.select { |a| a.is_a?(described_class) }.each do |artifact|
           artifact.install_phase(command: NeverSudoSystemCommand, force: false)
         end
       end
-    }
+    end
 
     let(:source_path) { cask.staged_path.join("manpage.1") }
     let(:target_path) { cask.config.manpagedir.join("man1/manpage.1") }
diff --git a/Library/Homebrew/test/cask/artifact/pkg_spec.rb b/Library/Homebrew/test/cask/artifact/pkg_spec.rb
index 85234faf6733e..454e9eade47d3 100644
--- a/Library/Homebrew/test/cask/artifact/pkg_spec.rb
+++ b/Library/Homebrew/test/cask/artifact/pkg_spec.rb
@@ -1,7 +1,6 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Artifact::Pkg, :cask do
+RSpec.describe Cask::Artifact::Pkg, :cask do
   let(:cask) { Cask::CaskLoader.load(cask_path("with-installable")) }
   let(:fake_system_command) { class_double(SystemCommand) }
 
@@ -17,6 +16,7 @@
         "/usr/sbin/installer",
         args:         ["-pkg", cask.staged_path.join("MyFancyPkg", "Fancy.pkg"), "-target", "/"],
         sudo:         true,
+        sudo_as_root: true,
         print_stdout: true,
         env:          {
           "LOGNAME"  => ENV.fetch("USER"),
@@ -35,7 +35,7 @@
     it "passes the choice changes xml to the system installer" do
       pkg = cask.artifacts.find { |a| a.is_a?(described_class) }
 
-      file = double(path: Pathname.new("/tmp/choices.xml"))
+      file = instance_double(Tempfile, path: Pathname.new("/tmp/choices.xml"))
 
       expect(file).to receive(:write).with <<~XML
         <?xml version="1.0" encoding="UTF-8"?>
@@ -66,6 +66,7 @@
           cask.staged_path.join("/tmp/choices.xml")
         ],
         sudo:         true,
+        sudo_as_root: true,
         print_stdout: true,
         env:          {
           "LOGNAME"  => ENV.fetch("USER"),
diff --git a/Library/Homebrew/test/cask/artifact/postflight_block_spec.rb b/Library/Homebrew/test/cask/artifact/postflight_block_spec.rb
index 21957b37dcf83..b47d0cb052c32 100644
--- a/Library/Homebrew/test/cask/artifact/postflight_block_spec.rb
+++ b/Library/Homebrew/test/cask/artifact/postflight_block_spec.rb
@@ -1,7 +1,6 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Artifact::PostflightBlock, :cask do
+RSpec.describe Cask::Artifact::PostflightBlock, :cask do
   describe "install_phase" do
     it "calls the specified block after installing, passing a Cask mini-dsl" do
       called = false
@@ -19,7 +18,7 @@
       end
 
       expect(called).to be true
-      expect(yielded_arg).to be_kind_of(Cask::DSL::Postflight)
+      expect(yielded_arg).to be_a(Cask::DSL::Postflight)
     end
   end
 
@@ -40,7 +39,7 @@
       end
 
       expect(called).to be true
-      expect(yielded_arg).to be_kind_of(Cask::DSL::UninstallPostflight)
+      expect(yielded_arg).to be_a(Cask::DSL::UninstallPostflight)
     end
   end
 end
diff --git a/Library/Homebrew/test/cask/artifact/preflight_block_spec.rb b/Library/Homebrew/test/cask/artifact/preflight_block_spec.rb
index 543ff90b4d443..923f40ac0745f 100644
--- a/Library/Homebrew/test/cask/artifact/preflight_block_spec.rb
+++ b/Library/Homebrew/test/cask/artifact/preflight_block_spec.rb
@@ -1,7 +1,6 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Artifact::PreflightBlock, :cask do
+RSpec.describe Cask::Artifact::PreflightBlock, :cask do
   describe "install_phase" do
     it "calls the specified block before installing, passing a Cask mini-dsl" do
       called = false
@@ -19,7 +18,7 @@
       end
 
       expect(called).to be true
-      expect(yielded_arg).to be_kind_of Cask::DSL::Preflight
+      expect(yielded_arg).to be_a Cask::DSL::Preflight
     end
   end
 
@@ -40,7 +39,7 @@
       end
 
       expect(called).to be true
-      expect(yielded_arg).to be_kind_of Cask::DSL::UninstallPreflight
+      expect(yielded_arg).to be_a Cask::DSL::UninstallPreflight
     end
   end
 end
diff --git a/Library/Homebrew/test/cask/artifact/shared_examples/uninstall_zap.rb b/Library/Homebrew/test/cask/artifact/shared_examples/uninstall_zap.rb
index 3d97672cc423a..b5813809b7de6 100644
--- a/Library/Homebrew/test/cask/artifact/shared_examples/uninstall_zap.rb
+++ b/Library/Homebrew/test/cask/artifact/shared_examples/uninstall_zap.rb
@@ -1,16 +1,15 @@
-# typed: false
 # frozen_string_literal: true
 
 require "benchmark"
 
-shared_examples "#uninstall_phase or #zap_phase" do
+RSpec.shared_examples "#uninstall_phase or #zap_phase" do
   subject { artifact }
 
   let(:artifact_dsl_key) { described_class.dsl_key }
   let(:artifact) { cask.artifacts.find { |a| a.is_a?(described_class) } }
   let(:fake_system_command) { class_double(SystemCommand) }
 
-  context "using :launchctl" do
+  context "when using :launchctl" do
     let(:cask) { Cask::CaskLoader.load(cask_path("with-#{artifact_dsl_key}-launchctl")) }
     let(:launchctl_list_cmd) { %w[/bin/launchctl list my.fancy.package.service] }
     let(:launchctl_remove_cmd) { %w[/bin/launchctl remove my.fancy.package.service] }
@@ -32,14 +31,26 @@
 
     it "works when job is owned by user" do
       allow(fake_system_command).to receive(:run)
-        .with("/bin/launchctl", args: ["list", "my.fancy.package.service"], print_stderr: false, sudo: false)
+        .with(
+          "/bin/launchctl",
+          args:         ["list", "my.fancy.package.service"],
+          print_stderr: false,
+          sudo:         false,
+          sudo_as_root: false,
+        )
         .and_return(instance_double(SystemCommand::Result, stdout: service_info))
       allow(fake_system_command).to receive(:run)
-        .with("/bin/launchctl", args: ["list", "my.fancy.package.service"], print_stderr: false, sudo: true)
+        .with(
+          "/bin/launchctl",
+          args:         ["list", "my.fancy.package.service"],
+          print_stderr: false,
+          sudo:         true,
+          sudo_as_root: true,
+        )
         .and_return(instance_double(SystemCommand::Result, stdout: unknown_response))
 
       expect(fake_system_command).to receive(:run!)
-        .with("/bin/launchctl", args: ["remove", "my.fancy.package.service"], sudo: false)
+        .with("/bin/launchctl", args: ["remove", "my.fancy.package.service"], sudo: false, sudo_as_root: false)
         .and_return(instance_double(SystemCommand::Result))
 
       subject.public_send(:"#{artifact_dsl_key}_phase", command: fake_system_command)
@@ -47,21 +58,103 @@
 
     it "works when job is owned by system" do
       allow(fake_system_command).to receive(:run)
-        .with("/bin/launchctl", args: ["list", "my.fancy.package.service"], print_stderr: false, sudo: false)
+        .with(
+          "/bin/launchctl",
+          args:         ["list", "my.fancy.package.service"],
+          print_stderr: false,
+          sudo:         false,
+          sudo_as_root: false,
+        )
         .and_return(instance_double(SystemCommand::Result, stdout: unknown_response))
       allow(fake_system_command).to receive(:run)
-        .with("/bin/launchctl", args: ["list", "my.fancy.package.service"], print_stderr: false, sudo: true)
+        .with(
+          "/bin/launchctl",
+          args:         ["list", "my.fancy.package.service"],
+          print_stderr: false,
+          sudo:         true,
+          sudo_as_root: true,
+        )
         .and_return(instance_double(SystemCommand::Result, stdout: service_info))
 
       expect(fake_system_command).to receive(:run!)
-        .with("/bin/launchctl", args: ["remove", "my.fancy.package.service"], sudo: true)
+        .with("/bin/launchctl", args: ["remove", "my.fancy.package.service"], sudo: true, sudo_as_root: true)
         .and_return(instance_double(SystemCommand::Result))
 
       subject.public_send(:"#{artifact_dsl_key}_phase", command: fake_system_command)
     end
   end
 
-  context "using :pkgutil" do
+  context "when using :launchctl with regex wildcard" do
+    let(:cask) { Cask::CaskLoader.load(cask_path("with-#{artifact_dsl_key}-launchctl-wildcard")) }
+    let(:launchctl_regex) { "my.fancy.package.service.*" }
+    let(:unknown_response) { "launchctl list returned unknown response\n" }
+    let(:service_info) do
+      <<~EOS
+        {
+                "LimitLoadToSessionType" = "Aqua";
+                "Label" = "my.fancy.package.service.12345";
+                "TimeOut" = 30;
+                "OnDemand" = true;
+                "LastExitStatus" = 0;
+                "ProgramArguments" = (
+                        "argument";
+                );
+        };
+      EOS
+    end
+    let(:launchctl_list) do
+      <<~EOS
+        PID     Status  Label
+        1111    0       my.fancy.package.service.12345
+        -       0       com.apple.SafariHistoryServiceAgent
+        -       0       com.apple.progressd
+        555     0       my.fancy.package.service.test
+      EOS
+    end
+
+    it "searches installed launchctl items" do
+      expect(subject).to receive(:find_launchctl_with_wildcard)
+        .with(launchctl_regex)
+        .and_return(["my.fancy.package.service.12345"])
+
+      allow(fake_system_command).to receive(:run)
+        .with(
+          "/bin/launchctl",
+          args:         ["list", "my.fancy.package.service.12345"],
+          print_stderr: false,
+          sudo:         false,
+          sudo_as_root: false,
+        )
+        .and_return(instance_double(SystemCommand::Result, stdout: unknown_response))
+      allow(fake_system_command).to receive(:run)
+        .with(
+          "/bin/launchctl",
+          args:         ["list", "my.fancy.package.service.12345"],
+          print_stderr: false,
+          sudo:         true,
+          sudo_as_root: true,
+        )
+        .and_return(instance_double(SystemCommand::Result, stdout: service_info))
+
+      expect(fake_system_command).to receive(:run!)
+        .with("/bin/launchctl", args: ["remove", "my.fancy.package.service.12345"], sudo: true, sudo_as_root: true)
+        .and_return(instance_double(SystemCommand::Result))
+
+      subject.public_send(:"#{artifact_dsl_key}_phase", command: fake_system_command)
+    end
+
+    it "returns the matching launchctl services" do
+      expect(subject).to receive(:system_command!)
+        .with("/bin/launchctl", args: ["list"])
+        .and_return(instance_double(SystemCommand::Result, stdout: launchctl_list))
+
+      expect(subject.send(:find_launchctl_with_wildcard,
+                          "my.fancy.package.service.*")).to eq(["my.fancy.package.service.12345",
+                                                                "my.fancy.package.service.test"])
+    end
+  end
+
+  context "when using :pkgutil" do
     let(:cask) { Cask::CaskLoader.load(cask_path("with-#{artifact_dsl_key}-pkgutil")) }
 
     let(:main_pkg_id) { "my.fancy.package.main" }
@@ -85,31 +178,31 @@
     end
   end
 
-  context "using :kext" do
+  context "when using :kext" do
     let(:cask) { Cask::CaskLoader.load(cask_path("with-#{artifact_dsl_key}-kext")) }
     let(:kext_id) { "my.fancy.package.kernelextension" }
 
     it "is supported" do
       allow(subject).to receive(:system_command!)
-        .with("/usr/sbin/kextstat", args: ["-l", "-b", kext_id], sudo: true)
-        .and_return(instance_double("SystemCommand::Result", stdout: "loaded"))
+        .with("/usr/sbin/kextstat", args: ["-l", "-b", kext_id], sudo: true, sudo_as_root: true)
+        .and_return(instance_double(SystemCommand::Result, stdout: "loaded"))
 
       expect(subject).to receive(:system_command!)
-        .with("/sbin/kextunload", args: ["-b", kext_id], sudo: true)
-        .and_return(instance_double("SystemCommand::Result"))
+        .with("/sbin/kextunload", args: ["-b", kext_id], sudo: true, sudo_as_root: true)
+        .and_return(instance_double(SystemCommand::Result))
 
       expect(subject).to receive(:system_command!)
-        .with("/usr/sbin/kextfind", args: ["-b", kext_id], sudo: true)
-        .and_return(instance_double("SystemCommand::Result", stdout: "/Library/Extensions/FancyPackage.kext\n"))
+        .with("/usr/sbin/kextfind", args: ["-b", kext_id], sudo: true, sudo_as_root: true)
+        .and_return(instance_double(SystemCommand::Result, stdout: "/Library/Extensions/FancyPackage.kext\n"))
 
       expect(subject).to receive(:system_command!)
-        .with("/bin/rm", args: ["-rf", "/Library/Extensions/FancyPackage.kext"], sudo: true)
+        .with("/bin/rm", args: ["-rf", "/Library/Extensions/FancyPackage.kext"], sudo: true, sudo_as_root: true)
 
       subject.public_send(:"#{artifact_dsl_key}_phase", command: fake_system_command)
     end
   end
 
-  context "using :quit" do
+  context "when using :quit" do
     let(:cask) { Cask::CaskLoader.load(cask_path("with-#{artifact_dsl_key}-quit")) }
     let(:bundle_id) { "my.fancy.package.app" }
 
@@ -117,9 +210,9 @@
       allow(User.current).to receive(:gui?).and_return false
       allow(subject).to receive(:running?).with(bundle_id).and_return(true)
 
-      expect {
+      expect do
         subject.public_send(:"#{artifact_dsl_key}_phase", command: fake_system_command)
-      }.to output(/Not logged into a GUI; skipping quitting application ID 'my.fancy.package.app'\./).to_stderr
+      end.to output(/Not logged into a GUI; skipping quitting application ID 'my.fancy.package.app'\./).to_stderr
     end
 
     it "quits a running application" do
@@ -127,12 +220,24 @@
 
       expect(subject).to receive(:running?).with(bundle_id).ordered.and_return(true)
       expect(subject).to receive(:quit).with(bundle_id)
-                                       .and_return(instance_double("SystemCommand::Result", success?: true))
+                                       .and_return(instance_double(SystemCommand::Result, success?: true))
       expect(subject).to receive(:running?).with(bundle_id).ordered.and_return(false)
 
-      expect {
+      expect do
         subject.public_send(:"#{artifact_dsl_key}_phase", command: fake_system_command)
-      }.to output(/Application 'my.fancy.package.app' quit successfully\./).to_stdout
+      end.to output(/Application 'my.fancy.package.app' quit successfully\./).to_stdout
+    end
+
+    it "does not attempt to quit when upgrading or reinstalling" do
+      next if artifact_dsl_key == :zap
+
+      allow(User.current).to receive(:gui?).and_return true
+
+      expect(subject).not_to receive(:running?)
+      expect(subject).not_to receive(:quit)
+
+      subject.public_send(:"#{artifact_dsl_key}_phase", upgrade: true, command: fake_system_command)
+      subject.public_send(:"#{artifact_dsl_key}_phase", reinstall: true, command: fake_system_command)
     end
 
     it "tries to quit the application for 10 seconds" do
@@ -140,19 +245,19 @@
 
       allow(subject).to receive(:running?).with(bundle_id).and_return(true)
       allow(subject).to receive(:quit).with(bundle_id)
-                                      .and_return(instance_double("SystemCommand::Result", success?: false))
+                                      .and_return(instance_double(SystemCommand::Result, success?: false))
 
       time = Benchmark.measure do
-        expect {
+        expect do
           subject.public_send(:"#{artifact_dsl_key}_phase", command: fake_system_command)
-        }.to output(/Application 'my.fancy.package.app' did not quit\./).to_stderr
+        end.to output(/Application 'my.fancy.package.app' did not quit\./).to_stderr
       end
 
       expect(time.real).to be_within(3).of(10)
     end
   end
 
-  context "using :signal" do
+  context "when using :signal" do
     let(:cask) { Cask::CaskLoader.load(cask_path("with-#{artifact_dsl_key}-signal")) }
     let(:bundle_id) { "my.fancy.package.app" }
     let(:signals) { %w[TERM KILL] }
@@ -163,23 +268,37 @@
                                                    .and_return(unix_pids.map { |pid| [pid, 0, bundle_id] })
 
       signals.each do |signal|
-        expect(Process).to receive(:kill).with(signal, *unix_pids)
+        expect(Process).to receive(:kill).with(signal, *unix_pids).and_return(1)
       end
 
       subject.public_send(:"#{artifact_dsl_key}_phase", command: fake_system_command)
     end
+
+    it "does not send signal when upgrading or reinstalling" do
+      next if artifact_dsl_key == :zap
+
+      allow(subject).to receive(:running_processes).with(bundle_id)
+                                                   .and_return(unix_pids.map { |pid| [pid, 0, bundle_id] })
+
+      signals.each do |_signal|
+        expect(Process).not_to receive(:kill)
+      end
+
+      subject.public_send(:"#{artifact_dsl_key}_phase", upgrade: true, command: fake_system_command)
+      subject.public_send(:"#{artifact_dsl_key}_phase", reinstall: true, command: fake_system_command)
+    end
   end
 
   [:delete, :trash].each do |directive|
     next if directive == :trash && ENV["HOMEBREW_TESTS_COVERAGE"].nil?
 
-    context "using :#{directive}" do
+    context "when using :#{directive}" do
       let(:dir) { TEST_TMPDIR }
       let(:absolute_path) { Pathname.new("#{dir}/absolute_path") }
       let(:path_with_tilde) { Pathname.new("#{dir}/path_with_tilde") }
-      let(:glob_path1) { Pathname.new("#{dir}/glob_path1") }
-      let(:glob_path2) { Pathname.new("#{dir}/glob_path2") }
-      let(:paths) { [absolute_path, path_with_tilde, glob_path1, glob_path2] }
+      let(:glob_path) { Pathname.new("#{dir}/glob_path") }
+      let(:glob_path_alt) { Pathname.new("#{dir}/glob_path_alt") }
+      let(:paths) { [absolute_path, path_with_tilde, glob_path, glob_path_alt] }
       let(:fake_system_command) { NeverSudoSystemCommand }
       let(:cask) { Cask::CaskLoader.load(cask_path("with-#{artifact_dsl_key}-#{directive}")) }
 
@@ -195,8 +314,8 @@
 
       before do
         allow_any_instance_of(Cask::Artifact::AbstractUninstall).to receive(:trash_paths)
-          .and_wrap_original do |method, *args|
-            method.call(*args).tap do |trashed, _|
+          .and_wrap_original do |method, *args, **kwargs|
+            method.call(*args, **kwargs).tap do |trashed, _|
               FileUtils.rm_r trashed
             end
           end
@@ -215,7 +334,7 @@
   end
 
   [:script, :early_script].each do |script_type|
-    context "using #{script_type.inspect}" do
+    context "when using #{script_type.inspect}" do
       let(:fake_system_command) { NeverSudoSystemCommand }
       let(:token) { "with-#{artifact_dsl_key}-#{script_type}".tr("_", "-") }
       let(:cask) { Cask::CaskLoader.load(cask_path(token.to_s)) }
@@ -224,13 +343,14 @@
       it "is supported" do
         allow(fake_system_command).to receive(:run).with(any_args).and_call_original
 
-        expect(fake_system_command).to receive(:run).with(
-          cask.staged_path.join("MyFancyPkg", "FancyUninstaller.tool"),
-          args:         ["--please"],
-          must_succeed: true,
-          print_stdout: true,
-          sudo:         false,
-        )
+        expect(fake_system_command).to receive(:run)
+          .with(
+            cask.staged_path.join("MyFancyPkg", "FancyUninstaller.tool"),
+            args:         ["--please"],
+            must_succeed: true,
+            print_stdout: true,
+            sudo:         false,
+          )
 
         InstallHelper.install_without_artifacts(cask)
         subject.public_send(:"#{artifact_dsl_key}_phase", command: fake_system_command)
@@ -238,7 +358,7 @@
     end
   end
 
-  context "using :login_item" do
+  context "when using :login_item" do
     let(:cask) { Cask::CaskLoader.load(cask_path("with-#{artifact_dsl_key}-login-item")) }
 
     it "is supported" do
@@ -247,7 +367,7 @@
           "osascript",
           args: ["-e", 'tell application "System Events" to delete every login item whose name is "Fancy"'],
         )
-        .and_return(instance_double("SystemCommand::Result", success?: true))
+        .and_return(instance_double(SystemCommand::Result, success?: true))
 
       subject.public_send(:"#{artifact_dsl_key}_phase", command: fake_system_command)
     end
diff --git a/Library/Homebrew/test/cask/artifact/suite_spec.rb b/Library/Homebrew/test/cask/artifact/suite_spec.rb
index 61144b3679dac..869508d45427e 100644
--- a/Library/Homebrew/test/cask/artifact/suite_spec.rb
+++ b/Library/Homebrew/test/cask/artifact/suite_spec.rb
@@ -1,16 +1,15 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Artifact::Suite, :cask do
+RSpec.describe Cask::Artifact::Suite, :cask do
   let(:cask) { Cask::CaskLoader.load(cask_path("with-suite")) }
 
-  let(:install_phase) {
+  let(:install_phase) do
     lambda do
       cask.artifacts.select { |a| a.is_a?(described_class) }.each do |artifact|
         artifact.install_phase(command: NeverSudoSystemCommand, force: false)
       end
     end
-  }
+  end
 
   let(:target_path) { cask.config.appdir.join("Caffeine") }
   let(:source_path) { cask.staged_path.join("Caffeine") }
@@ -28,9 +27,9 @@
   it "avoids clobbering an existing suite by moving over it" do
     target_path.mkpath
 
-    expect {
+    expect do
       install_phase.call
-    }.to raise_error(Cask::CaskError)
+    end.to raise_error(Cask::CaskError)
 
     expect(source_path).to be_a_directory
     expect(target_path).to be_a_directory
diff --git a/Library/Homebrew/test/cask/artifact/two_apps_correct_spec.rb b/Library/Homebrew/test/cask/artifact/two_apps_correct_spec.rb
index 3a5371e3b2a59..5a1e119bff0f2 100644
--- a/Library/Homebrew/test/cask/artifact/two_apps_correct_spec.rb
+++ b/Library/Homebrew/test/cask/artifact/two_apps_correct_spec.rb
@@ -1,15 +1,14 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Artifact::App, :cask do
+RSpec.describe Cask::Artifact::App, :cask do
   describe "multiple apps" do
     let(:cask) { Cask::CaskLoader.load(cask_path("with-two-apps-correct")) }
 
-    let(:install_phase) {
+    let(:install_phase) do
       cask.artifacts.select { |a| a.is_a?(described_class) }.each do |artifact|
         artifact.install_phase(command: NeverSudoSystemCommand, force: false)
       end
-    }
+    end
 
     let(:source_path_mini) { cask.staged_path.join("Caffeine Mini.app") }
     let(:target_path_mini) { cask.config.appdir.join("Caffeine Mini.app") }
@@ -64,11 +63,11 @@
       it "when the first app of two already exists" do
         target_path_mini.mkpath
 
-        expect {
+        expect do
           expect { install_phase }.to output(<<~EOS).to_stdout
             ==> Moving App 'Caffeine Pro.app' to '#{target_path_pro}'
           EOS
-        }.to raise_error(Cask::CaskError, "It seems there is already an App at '#{target_path_mini}'.")
+        end.to raise_error(Cask::CaskError, "It seems there is already an App at '#{target_path_mini}'.")
 
         expect(source_path_mini).to be_a_directory
         expect(target_path_mini).to be_a_directory
@@ -78,11 +77,11 @@
       it "when the second app of two already exists" do
         target_path_pro.mkpath
 
-        expect {
+        expect do
           expect { install_phase }.to output(<<~EOS).to_stdout
             ==> Moving App 'Caffeine Mini.app' to '#{target_path_mini}'
           EOS
-        }.to raise_error(Cask::CaskError, "It seems there is already an App at '#{target_path_pro}'.")
+        end.to raise_error(Cask::CaskError, "It seems there is already an App at '#{target_path_pro}'.")
 
         expect(source_path_pro).to be_a_directory
         expect(target_path_pro).to be_a_directory
diff --git a/Library/Homebrew/test/cask/artifact/uninstall_no_zap_spec.rb b/Library/Homebrew/test/cask/artifact/uninstall_no_zap_spec.rb
index 31b14aa7f4903..2a42e5a8d3b19 100644
--- a/Library/Homebrew/test/cask/artifact/uninstall_no_zap_spec.rb
+++ b/Library/Homebrew/test/cask/artifact/uninstall_no_zap_spec.rb
@@ -1,12 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Artifact::Zap, :cask do
+RSpec.describe Cask::Artifact::Zap, :cask do
   let(:cask) { Cask::CaskLoader.load(cask_path("with-installable")) }
 
-  let(:zap_artifact) {
+  let(:zap_artifact) do
     cask.artifacts.find { |a| a.is_a?(described_class) }
-  }
+  end
 
   before do
     InstallHelper.install_without_artifacts(cask)
diff --git a/Library/Homebrew/test/cask/artifact/uninstall_spec.rb b/Library/Homebrew/test/cask/artifact/uninstall_spec.rb
index de09f6f850512..d454b2de321ec 100644
--- a/Library/Homebrew/test/cask/artifact/uninstall_spec.rb
+++ b/Library/Homebrew/test/cask/artifact/uninstall_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples/uninstall_zap"
 
-describe Cask::Artifact::Uninstall, :cask do
+RSpec.describe Cask::Artifact::Uninstall, :cask do
   describe "#uninstall_phase" do
     include_examples "#uninstall_phase or #zap_phase"
   end
diff --git a/Library/Homebrew/test/cask/artifact/zap_spec.rb b/Library/Homebrew/test/cask/artifact/zap_spec.rb
index 2d7387727b951..3ae2f40d96d8f 100644
--- a/Library/Homebrew/test/cask/artifact/zap_spec.rb
+++ b/Library/Homebrew/test/cask/artifact/zap_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples/uninstall_zap"
 
-describe Cask::Artifact::Zap, :cask do
+RSpec.describe Cask::Artifact::Zap, :cask do
   describe "#zap_phase" do
     include_examples "#uninstall_phase or #zap_phase"
 
diff --git a/Library/Homebrew/test/cask/audit_spec.rb b/Library/Homebrew/test/cask/audit_spec.rb
index 212cca3405429..800d1fa51d48a 100644
--- a/Library/Homebrew/test/cask/audit_spec.rb
+++ b/Library/Homebrew/test/cask/audit_spec.rb
@@ -1,46 +1,65 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cask/audit"
 
-describe Cask::Audit, :cask do
+RSpec.describe Cask::Audit, :cask do
   def include_msg?(problems, msg)
     if msg.is_a?(Regexp)
-      Array(problems).any? { |problem| problem[:message] =~ msg }
+      Array(problems).any? { |problem| msg.match?(problem[:message]) }
     else
       Array(problems).any? { |problem| problem[:message] == msg }
     end
   end
 
+  def passed?(audit)
+    !audit.errors?
+  end
+
+  def outcome(audit)
+    if passed?(audit)
+      "passed"
+    else
+      "errored with #{audit.errors.map { |e| e.fetch(:message).inspect }.join(",")}"
+    end
+  end
+
   matcher :pass do
     match do |audit|
-      !audit.errors? && !audit.warnings?
+      passed?(audit)
+    end
+
+    failure_message do |audit|
+      "expected to pass, but #{outcome(audit)}"
     end
   end
 
-  matcher :fail_with do |message|
+  matcher :error_with do |message|
     match do |audit|
       include_msg?(audit.errors, message)
     end
-  end
 
-  matcher :warn_with do |message|
-    match do |audit|
-      include_msg?(audit.warnings, message)
+    failure_message do |audit|
+      "expected to error with message #{message.inspect} but #{outcome(audit)}"
     end
   end
 
   let(:cask) { instance_double(Cask::Cask) }
   let(:new_cask) { nil }
   let(:online) { nil }
+  let(:only) { [] }
+  let(:except) { [] }
   let(:strict) { nil }
   let(:token_conflicts) { nil }
-  let(:audit) {
-    described_class.new(cask, online:          online,
-                              strict:          strict,
-                              new_cask:        new_cask,
-                              token_conflicts: token_conflicts)
-  }
+  let(:signing) { nil }
+  let(:audit) do
+    described_class.new(cask, online:,
+                              strict:,
+                              new_cask:,
+                              token_conflicts:,
+                              signing:,
+                              only:,
+                              except:)
+  end
 
   describe "#new" do
     context "when `new_cask` is specified" do
@@ -62,9 +81,13 @@ def include_msg?(problems, msg)
     context "when `online` is specified" do
       let(:online) { true }
 
-      it "implies `appcast`" do
-        expect(audit.appcast?).to be true
+      it "implies `download`" do
+        expect(audit.download).to be_truthy
       end
+    end
+
+    context "when `signing` is specified" do
+      let(:signing) { true }
 
       it "implies `download`" do
         expect(audit.download).to be_truthy
@@ -75,6 +98,14 @@ def include_msg?(problems, msg)
   describe "#result" do
     subject { audit.result }
 
+    context "when there are no errors and `--strict` is not passed so we should not show anything" do
+      before do
+        audit.add_error("eh", strict_only: true)
+      end
+
+      it { is_expected.not_to match(/failed/) }
+    end
+
     context "when there are errors" do
       before do
         audit.add_error "bad"
@@ -83,25 +114,42 @@ def include_msg?(problems, msg)
       it { is_expected.to match(/failed/) }
     end
 
-    context "when there are warnings" do
+    context "when there are errors and warnings" do
       before do
-        audit.add_warning "eh"
+        audit.add_error "bad"
+        audit.add_error("eh", strict_only: true)
       end
 
-      it { is_expected.to match(/warning/) }
+      it { is_expected.to match(/failed/) }
     end
 
-    context "when there are errors and warnings" do
+    context "when there are errors and warnings and `--strict` is passed" do
+      let(:strict) { true }
+
       before do
-        audit.add_error "bad"
-        audit.add_warning "eh"
+        audit.add_error "very bad"
+        audit.add_error("a little bit bad", strict_only: true)
       end
 
       it { is_expected.to match(/failed/) }
     end
 
-    context "when there are no errors or warnings" do
-      it { is_expected.to match(/passed/) }
+    context "when there are warnings and `--strict` is not passed" do
+      before do
+        audit.add_error("a little bit bad", strict_only: true)
+      end
+
+      it { is_expected.not_to match(/failed/) }
+    end
+
+    context "when there are warnings and `--strict` is passed" do
+      let(:strict) { true }
+
+      before do
+        audit.add_error("a little bit bad", strict_only: true)
+      end
+
+      it { is_expected.to match(/failed/) }
     end
   end
 
@@ -121,17 +169,20 @@ def tmp_cask(name, text)
     let(:cask) { Cask::CaskLoader.load(cask_token) }
 
     describe "required stanzas" do
+      let(:only) { ["required_stanzas"] }
+
       %w[version sha256 url name homepage].each do |stanza|
         context "when missing #{stanza}" do
           let(:cask_token) { "missing-#{stanza}" }
 
-          it { is_expected.to fail_with(/#{stanza} stanza is required/) }
+          it { is_expected.to error_with(/#{stanza} stanza is required/) }
         end
       end
     end
 
     describe "token validation" do
       let(:strict) { true }
+      let(:only) { ["token"] }
       let(:cask) do
         tmp_cask cask_token.to_s, <<~RUBY
           cask '#{cask_token}' do
@@ -149,7 +200,7 @@ def tmp_cask(name, text)
         let(:cask_token) { "Upper-Case" }
 
         it "fails" do
-          expect(run).to fail_with(/lowercase/)
+          expect(run).to error_with(/not contain uppercase/)
         end
       end
 
@@ -157,47 +208,55 @@ def tmp_cask(name, text)
         let(:cask_token) { "ascii⌘" }
 
         it "fails" do
-          expect(run).to fail_with(/contains non-ascii characters/)
+          expect(run).to error_with(/not contain non-ASCII characters/)
         end
       end
 
-      context "when cask token has +" do
-        let(:cask_token) { "app++" }
+      context "when cask token is @-versioned with number" do
+        let(:cask_token) { "app@10" }
 
-        it "fails" do
-          expect(run).to fail_with(/\+ should be replaced by -plus-/)
+        it "does not fail" do
+          expect(run).to pass
+        end
+      end
+
+      context "when cask token is @-versioned with word" do
+        let(:cask_token) { "app@beta" }
+
+        it "does not fail" do
+          expect(run).to pass
         end
       end
 
-      context "when cask token has @" do
-        let(:cask_token) { "app@stuff" }
+      context "when cask token has multiple @" do
+        let(:cask_token) { "app@stuff@beta" }
 
         it "fails" do
-          expect(run).to fail_with(/@ should be replaced by -at-/)
+          expect(run).to error_with(/not contain multiple @ symbols/)
         end
       end
 
-      context "when cask token has whitespace" do
-        let(:cask_token) { "app stuff" }
+      context "when cask token has a hyphen followed by @" do
+        let(:cask_token) { "app-@beta" }
 
         it "fails" do
-          expect(run).to fail_with(/whitespace should be replaced by hyphens/)
+          expect(run).to error_with(/not contain a hyphen followed by an @/)
         end
       end
 
-      context "when cask token has underscores" do
-        let(:cask_token) { "app_stuff" }
+      context "when cask token has @ followed by a hyphen" do
+        let(:cask_token) { "app@-beta" }
 
         it "fails" do
-          expect(run).to fail_with(/underscores should be replaced by hyphens/)
+          expect(run).to error_with(/not contain an @ followed by a hyphen/)
         end
       end
 
-      context "when cask token has non-alphanumeric characters" do
-        let(:cask_token) { "app(stuff)" }
+      context "when cask token has whitespace" do
+        let(:cask_token) { "app stuff" }
 
         it "fails" do
-          expect(run).to fail_with(/alphanumeric characters and hyphens/)
+          expect(run).to error_with(/not contain whitespace/)
         end
       end
 
@@ -205,7 +264,7 @@ def tmp_cask(name, text)
         let(:cask_token) { "app--stuff" }
 
         it "fails" do
-          expect(run).to fail_with(/should not contain double hyphens/)
+          expect(run).to error_with(/not contain double hyphens/)
         end
       end
 
@@ -213,7 +272,7 @@ def tmp_cask(name, text)
         let(:cask_token) { "-app" }
 
         it "fails" do
-          expect(run).to fail_with(/should not have leading or trailing hyphens/)
+          expect(run).to error_with(/not contain a leading hyphen/)
         end
       end
 
@@ -221,13 +280,14 @@ def tmp_cask(name, text)
         let(:cask_token) { "app-" }
 
         it "fails" do
-          expect(run).to fail_with(/should not have leading or trailing hyphens/)
+          expect(run).to error_with(/not contain a trailing hyphen/)
         end
       end
     end
 
     describe "token bad words" do
       let(:new_cask) { true }
+      let(:only) { ["token_bad_words", "reverse_migration"] }
       let(:online) { false }
       let(:cask) do
         tmp_cask cask_token.to_s, <<~RUBY
@@ -247,23 +307,7 @@ def tmp_cask(name, text)
         let(:cask_token) { "token.app" }
 
         it "fails" do
-          expect(run).to fail_with(/token contains .app/)
-        end
-      end
-
-      context "when cask token contains version designation" do
-        let(:cask_token) { "token-beta" }
-
-        it "fails if the cask is from an official tap" do
-          allow(cask).to receive(:tap).and_return(Tap.fetch("homebrew/cask"))
-
-          expect(run).to fail_with(/token contains version designation/)
-        end
-
-        it "does not fail if the cask is from the `cask-versions` tap" do
-          allow(cask).to receive(:tap).and_return(Tap.fetch("homebrew/cask-versions"))
-
-          expect(run).to pass
+          expect(run).to error_with(/token contains .app/)
         end
       end
 
@@ -271,7 +315,7 @@ def tmp_cask(name, text)
         let(:cask_token) { "token-launcher" }
 
         it "fails" do
-          expect(run).to fail_with(/token mentions launcher/)
+          expect(run).to error_with(/token mentions launcher/)
         end
       end
 
@@ -279,7 +323,7 @@ def tmp_cask(name, text)
         let(:cask_token) { "token-desktop" }
 
         it "fails" do
-          expect(run).to fail_with(/token mentions desktop/)
+          expect(run).to error_with(/token mentions desktop/)
         end
       end
 
@@ -287,7 +331,7 @@ def tmp_cask(name, text)
         let(:cask_token) { "token-osx" }
 
         it "fails" do
-          expect(run).to fail_with(/token mentions platform/)
+          expect(run).to error_with(/token mentions platform/)
         end
       end
 
@@ -295,7 +339,7 @@ def tmp_cask(name, text)
         let(:cask_token) { "token-x86" }
 
         it "fails" do
-          expect(run).to fail_with(/token mentions architecture/)
+          expect(run).to error_with(/token mentions architecture/)
         end
       end
 
@@ -303,7 +347,7 @@ def tmp_cask(name, text)
         let(:cask_token) { "token-java" }
 
         it "fails" do
-          expect(run).to fail_with(/cask token mentions framework/)
+          expect(run).to error_with(/cask token mentions framework/)
         end
       end
 
@@ -317,7 +361,7 @@ def tmp_cask(name, text)
 
       context "when cask token is in tap_migrations.json and" do
         let(:cask_token) { "token-migrated" }
-        let(:tap) { Tap.fetch("homebrew/cask") }
+        let(:tap) { CoreCaskTap.instance }
 
         before do
           allow(tap).to receive(:tap_migrations).and_return({ cask_token => "homebrew/core" })
@@ -328,7 +372,7 @@ def tmp_cask(name, text)
           let(:new_cask) { true }
 
           it "fails" do
-            expect(run).to fail_with("#{cask_token} is listed in tap_migrations.json")
+            expect(run).to error_with("#{cask_token} is listed in tap_migrations.json")
           end
         end
 
@@ -343,6 +387,7 @@ def tmp_cask(name, text)
     end
 
     describe "locale validation" do
+      let(:only) { ["languages"] }
       let(:cask) do
         tmp_cask "locale-cask-test", <<~RUBY
           cask 'locale-cask-test' do
@@ -382,119 +427,180 @@ def tmp_cask(name, text)
 
       context "when cask locale is invalid" do
         it "error with invalid locale" do
-          expect(run).to fail_with(/Locale 'ZH-CN' is invalid\./)
-          expect(run).to fail_with(/Locale 'zh-' is invalid\./)
-          expect(run).to fail_with(/Locale 'zh-cn' is invalid\./)
+          expect(run).to error_with(/Locale 'ZH-CN' is invalid\./)
+          expect(run).to error_with(/Locale 'zh-' is invalid\./)
+          expect(run).to error_with(/Locale 'zh-cn' is invalid\./)
         end
       end
     end
 
     describe "pkg allow_untrusted checks" do
+      let(:only) { ["untrusted_pkg"] }
       let(:message) { "allow_untrusted is not permitted in official Homebrew Cask taps" }
 
       context "when the Cask has no pkg stanza" do
         let(:cask_token) { "basic-cask" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask does not have allow_untrusted" do
         let(:cask_token) { "with-uninstall-pkgutil" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask has allow_untrusted" do
         let(:cask_token) { "with-allow-untrusted" }
 
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
+      end
+    end
+
+    describe "signing checks" do
+      let(:only) { ["signing"] }
+      let(:download_double) { instance_double(Cask::Download) }
+      let(:unpack_double) { instance_double(UnpackStrategy::Zip) }
+
+      before do
+        allow(audit).to receive_messages(download: download_double, signing?: true)
+      end
+
+      context "when cask is not using a signed artifact" do
+        let(:cask) do
+          tmp_cask "signing-cask-test", <<~RUBY
+            cask 'signing-cask-test' do
+              version '1.0'
+              url "https://brew.sh/index.html"
+              artifact "example.pdf", target: "/Library/Application Support/example"
+            end
+          RUBY
+        end
+
+        it "does not fail" do
+          expect(download_double).not_to receive(:fetch)
+          expect(UnpackStrategy).not_to receive(:detect)
+          expect(run).not_to error_with(/Audit\.app/)
+        end
+      end
+
+      context "when cask is using a signed artifact" do
+        let(:cask) do
+          tmp_cask "signing-cask-test", <<~RUBY
+            cask 'signing-cask-test' do
+              version '1.0'
+              url "https://brew.sh/"
+              pkg 'Audit.app'
+            end
+          RUBY
+        end
+
+        it "does not fail since no extract" do
+          allow(download_double).to receive(:fetch).and_return(Pathname.new("/tmp/test.zip"))
+          allow(UnpackStrategy).to receive(:detect).and_return(nil)
+          expect(run).not_to error_with(/Audit\.app/)
+        end
       end
     end
 
     describe "livecheck should be skipped" do
+      let(:only) { ["livecheck_version"] }
       let(:online) { true }
       let(:message) { /Version '[^']*' differs from '[^']*' retrieved by livecheck\./ }
 
       context "when the Cask has a livecheck block using skip" do
-        let(:cask_token) { "livecheck/livecheck-skip" }
+        let(:cask_token) { "livecheck-skip" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask has a livecheck block referencing a Cask using skip" do
-        let(:cask_token) { "livecheck/livecheck-skip-reference" }
+        let(:cask_token) { "livecheck-skip-reference" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
-      context "when the Cask is discontinued" do
-        let(:cask_token) { "livecheck/discontinued" }
+      context "when the Cask is deprecated" do
+        let(:cask_token) { "livecheck-deprecated" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
-      context "when the Cask has a livecheck block referencing a discontinued Cask" do
-        let(:cask_token) { "livecheck/discontinued-reference" }
+      context "when the Cask has a livecheck block referencing a deprecated Cask" do
+        let(:cask_token) { "livecheck-deprecated-reference" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
+      end
+
+      context "when the Cask is disabled" do
+        let(:cask_token) { "livecheck-disabled" }
+
+        it { is_expected.not_to error_with(message) }
+      end
+
+      context "when the Cask has a livecheck block referencing a disabled Cask" do
+        let(:cask_token) { "livecheck-disabled-reference" }
+
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when version is :latest" do
-        let(:cask_token) { "livecheck/version-latest" }
+        let(:cask_token) { "livecheck-version-latest" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask has a livecheck block referencing a Cask where version is :latest" do
-        let(:cask_token) { "livecheck/version-latest-reference" }
+        let(:cask_token) { "livecheck-version-latest-reference" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when url is unversioned" do
-        let(:cask_token) { "livecheck/url-unversioned" }
+        let(:cask_token) { "livecheck-url-unversioned" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask has a livecheck block referencing a Cask with an unversioned url" do
-        let(:cask_token) { "livecheck/url-unversioned-reference" }
+        let(:cask_token) { "livecheck-url-unversioned-reference" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
     end
 
     describe "when the Cask stanza requires uninstall" do
+      let(:only) { ["stanza_requires_uninstall"] }
       let(:message) { "installer and pkg stanzas require an uninstall stanza" }
 
       context "when the Cask does not require an uninstall" do
         let(:cask_token) { "basic-cask" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the pkg Cask has an uninstall" do
         let(:cask_token) { "with-uninstall-pkgutil" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the installer Cask has an uninstall" do
         let(:cask_token) { "installer-with-uninstall" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the installer Cask does not have an uninstall" do
         let(:cask_token) { "with-installer-manual" }
 
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
 
       context "when the pkg Cask does not have an uninstall" do
         let(:cask_token) { "pkg-without-uninstall" }
 
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
     end
 
@@ -504,19 +610,19 @@ def tmp_cask(name, text)
       context "when the Cask has no preflight stanza" do
         let(:cask_token) { "with-zap-rmdir" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask has only one preflight stanza" do
         let(:cask_token) { "with-preflight" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask has multiple preflight stanzas" do
         let(:cask_token) { "with-preflight-multi" }
 
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
     end
 
@@ -526,41 +632,19 @@ def tmp_cask(name, text)
       context "when the Cask has no postflight stanza" do
         let(:cask_token) { "with-zap-rmdir" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask has only one postflight stanza" do
         let(:cask_token) { "with-postflight" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask has multiple postflight stanzas" do
         let(:cask_token) { "with-postflight-multi" }
 
-        it { is_expected.to fail_with(message) }
-      end
-    end
-
-    describe "uninstall stanza checks" do
-      let(:message) { "only a single uninstall stanza is allowed" }
-
-      context "when the Cask has no uninstall stanza" do
-        let(:cask_token) { "with-zap-rmdir" }
-
-        it { is_expected.not_to fail_with(message) }
-      end
-
-      context "when the Cask has only one uninstall stanza" do
-        let(:cask_token) { "with-uninstall-rmdir" }
-
-        it { is_expected.not_to fail_with(message) }
-      end
-
-      context "when the Cask has multiple uninstall stanzas" do
-        let(:cask_token) { "with-uninstall-multi" }
-
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
     end
 
@@ -570,19 +654,19 @@ def tmp_cask(name, text)
       context "when the Cask has no uninstall_preflight stanza" do
         let(:cask_token) { "with-zap-rmdir" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask has only one uninstall_preflight stanza" do
         let(:cask_token) { "with-uninstall-preflight" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask has multiple uninstall_preflight stanzas" do
         let(:cask_token) { "with-uninstall-preflight-multi" }
 
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
     end
 
@@ -592,19 +676,19 @@ def tmp_cask(name, text)
       context "when the Cask has no uninstall_postflight stanza" do
         let(:cask_token) { "with-zap-rmdir" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask has only one uninstall_postflight stanza" do
         let(:cask_token) { "with-uninstall-postflight" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask has multiple uninstall_postflight stanzas" do
         let(:cask_token) { "with-uninstall-postflight-multi" }
 
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
     end
 
@@ -614,19 +698,19 @@ def tmp_cask(name, text)
       context "when the Cask has no zap stanza" do
         let(:cask_token) { "with-uninstall-rmdir" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask has only one zap stanza" do
         let(:cask_token) { "with-zap-rmdir" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the Cask has multiple zap stanzas" do
         let(:cask_token) { "with-zap-multi" }
 
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
     end
 
@@ -634,108 +718,125 @@ def tmp_cask(name, text)
       let(:message) { "you should use version :latest instead of version 'latest'" }
 
       context "when version is 'latest'" do
+        let(:only) { ["no_string_version_latest"] }
         let(:cask_token) { "version-latest-string" }
 
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
 
       context "when version is :latest" do
+        let(:only) { ["sha256_no_check_if_latest"] }
         let(:cask_token) { "version-latest-with-checksum" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
+      end
+
+      context "when version contains a colon" do
+        let(:only) { ["version_special_characters"] }
+        let(:cask_token) { "version-colon" }
+        let(:message) { "version should not contain colons or slashes" }
+
+        it { is_expected.to error_with(message) }
       end
     end
 
     describe "sha256 checks" do
       context "when version is :latest and sha256 is not :no_check" do
+        let(:only) { ["sha256_no_check_if_latest"] }
         let(:cask_token) { "version-latest-with-checksum" }
 
-        it { is_expected.to fail_with("you should use sha256 :no_check when version is :latest") }
+        it { is_expected.to error_with("you should use sha256 :no_check when version is :latest") }
       end
 
       context "when sha256 is not a legal SHA-256 digest" do
+        let(:only) { ["sha256_actually_256"] }
         let(:cask_token) { "invalid-sha256" }
 
-        it { is_expected.to fail_with("sha256 string must be of 64 hexadecimal characters") }
+        it { is_expected.to error_with("sha256 string must be of 64 hexadecimal characters") }
       end
 
       context "when sha256 is sha256 for empty string" do
+        let(:only) { ["sha256_invalid"] }
         let(:cask_token) { "sha256-for-empty-string" }
 
-        it { is_expected.to fail_with(/cannot use the sha256 for an empty string/) }
+        it { is_expected.to error_with(/cannot use the sha256 for an empty string/) }
       end
     end
 
     describe "hosting with livecheck checks" do
+      let(:only) { ["hosting_with_livecheck"] }
       let(:message) { /please add a livecheck/ }
 
       context "when the download does not use hosting with a livecheck" do
         let(:cask_token) { "basic-cask" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the download is hosted on SourceForge and has a livecheck" do
-        let(:cask_token) { "sourceforge-with-appcast" }
+        let(:cask_token) { "sourceforge-with-livecheck" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the download is hosted on SourceForge and does not have a livecheck" do
         let(:cask_token) { "sourceforge-correct-url-format" }
         let(:online) { true }
 
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
 
       context "when the download is hosted on DevMate and has a livecheck" do
-        let(:cask_token) { "devmate-with-appcast" }
+        let(:cask_token) { "devmate-with-livecheck" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the download is hosted on DevMate and does not have a livecheck" do
-        let(:cask_token) { "devmate-without-appcast" }
+        let(:cask_token) { "devmate-without-livecheck" }
 
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
 
       context "when the download is hosted on HockeyApp and has a livecheck" do
-        let(:cask_token) { "hockeyapp-with-appcast" }
+        let(:cask_token) { "hockeyapp-with-livecheck" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "when the download is hosted on HockeyApp and does not have a livecheck" do
-        let(:cask_token) { "hockeyapp-without-appcast" }
+        let(:cask_token) { "hockeyapp-without-livecheck" }
 
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
     end
 
-    describe "latest with appcast checks" do
-      let(:message) { "Casks with an `appcast` should not use `version :latest`." }
+    describe "latest with livecheck checks" do
+      let(:only) { ["latest_with_livecheck"] }
+      let(:message) { "Casks with a `livecheck` should not use `version :latest`." }
 
-      context "when the Cask is :latest and does not have an appcast" do
+      context "when the Cask is :latest and does not have a livecheck" do
         let(:cask_token) { "version-latest" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
-      context "when the Cask is versioned and has an appcast" do
-        let(:cask_token) { "with-appcast" }
+      context "when the Cask is versioned and has a livecheck with skip information" do
+        let(:cask_token) { "latest-with-livecheck-skip" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.to pass }
       end
 
-      context "when the Cask is :latest and has an appcast" do
-        let(:cask_token) { "latest-with-appcast" }
+      context "when the Cask is versioned and has a livecheck" do
+        let(:cask_token) { "latest-with-livecheck" }
 
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
     end
 
     describe "denylist checks" do
+      let(:only) { ["denylist"] }
+
       context "when the Cask is not on the denylist" do
         let(:cask_token) { "adobe-air" }
 
@@ -746,7 +847,7 @@ def tmp_cask(name, text)
         context "when it's in the official Homebrew tap" do
           let(:cask_token) { "adobe-illustrator" }
 
-          it { is_expected.to fail_with(/#{cask_token} is not allowed: \w+/) }
+          it { is_expected.to error_with(/#{cask_token} is not allowed: \w+/) }
         end
 
         context "when it isn't in the official Homebrew tap" do
@@ -758,6 +859,7 @@ def tmp_cask(name, text)
     end
 
     describe "latest with auto_updates checks" do
+      let(:only) { ["latest_with_auto_updates"] }
       let(:message) { "Casks with `version :latest` should not use `auto_updates`." }
 
       context "when the Cask is :latest and does not have auto_updates" do
@@ -781,102 +883,93 @@ def tmp_cask(name, text)
       context "when the Cask is :latest and has auto_updates" do
         let(:cask_token) { "latest-with-auto-updates" }
 
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
     end
 
     describe "preferred download URL formats" do
+      let(:only) { ["download_url_format"] }
       let(:message) { /URL format incorrect/ }
 
       context "with incorrect SourceForge URL format" do
         let(:cask_token) { "sourceforge-incorrect-url-format" }
 
-        it { is_expected.to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
 
       context "with correct SourceForge URL format" do
         let(:cask_token) { "sourceforge-correct-url-format" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
 
       context "with correct SourceForge URL format for version :latest" do
         let(:cask_token) { "sourceforge-version-latest-correct-url-format" }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.not_to error_with(message) }
       end
+    end
 
-      context "with incorrect OSDN URL format" do
-        let(:cask_token) { "osdn-incorrect-url-format" }
+    describe "disable OSDN download url" do
+      let(:only) { ["download_url_is_osdn"] }
+      let(:message) { /OSDN download urls are disabled./ }
+      let(:cask_token) { "osdn-urls" }
 
-        it { is_expected.to fail_with(message) }
+      context "when --strict is not passed" do
+        it { is_expected.not_to error_with(message) }
       end
 
-      context "with correct OSDN URL format" do
-        let(:cask_token) { "osdn-correct-url-format" }
+      context "when --strict is passed" do
+        let(:strict) { true }
 
-        it { is_expected.not_to fail_with(message) }
+        it { is_expected.to error_with(message) }
       end
     end
 
     describe "generic artifact checks" do
+      let(:only) { ["generic_artifacts"] }
+
       context "with relative target" do
         let(:cask_token) { "generic-artifact-relative-target" }
 
-        it { is_expected.to fail_with(/target must be.*absolute/) }
+        it { is_expected.to error_with(/target must be.*absolute/) }
       end
 
       context "with user-relative target" do
         let(:cask_token) { "generic-artifact-user-relative-target" }
 
-        it { is_expected.not_to fail_with(/target must be.*absolute/) }
+        it { is_expected.not_to error_with(/target must be.*absolute/) }
       end
 
       context "with absolute target" do
         let(:cask_token) { "generic-artifact-absolute-target" }
 
-        it { is_expected.not_to fail_with(/target must be.*absolute/) }
-      end
-    end
-
-    describe "url checks" do
-      context "with a block" do
-        let(:cask_token) { "booby-trap" }
-
-        context "when loading the cask" do
-          it "does not evaluate the block" do
-            expect { cask }.not_to raise_error
-          end
-        end
-
-        context "when doing an offline audit" do
-          let(:online) { false }
-
-          it "does not evaluate the block" do
-            expect(run).not_to pass
-          end
-        end
-
-        context "when doing and online audit" do
-          let(:online) { true }
-
-          it "evaluates the block" do
-            expect(run).to fail_with(/Boom/)
-          end
-        end
+        it { is_expected.not_to error_with(/target must be.*absolute/) }
       end
     end
 
     describe "token conflicts" do
+      let(:only) { ["token_conflicts"] }
       let(:cask_token) { "with-binary" }
       let(:token_conflicts) { true }
 
       context "when cask token conflicts with a core formula" do
         let(:formula_names) { %w[with-binary other-formula] }
 
-        it "warns about duplicates" do
-          expect(audit).to receive(:core_formula_names).and_return(formula_names)
-          expect(run).to warn_with(/possible duplicate/)
+        context "when `--strict` is passed" do
+          let(:strict) { true }
+
+          it "warns about duplicates" do
+            expect(audit).to receive(:core_formula_names).and_return(formula_names)
+            expect(run).to error_with(/possible duplicate/)
+          end
+        end
+
+        context "when `--strict` is not passed" do
+          it "does not warn about duplicates" do
+            expect(audit).to receive(:core_formula_names).and_return(formula_names)
+            expect(run).not_to error_with(/possible duplicate/)
+          end
         end
       end
 
@@ -888,37 +981,40 @@ def tmp_cask(name, text)
     end
 
     describe "audit of downloads" do
-      let(:cask_token) { "with-binary" }
+      let(:only) { ["download"] }
+      let(:cask_token) { "basic-cask" }
       let(:cask) { Cask::CaskLoader.load(cask_token) }
       let(:download_double) { instance_double(Cask::Download) }
       let(:message) { "Download Failed" }
 
       before do
         allow(audit).to receive(:download).and_return(download_double)
-        allow(audit).to receive(:check_https_availability)
+        allow(UnpackStrategy).to receive(:detect).and_return(nil)
       end
 
       it "when download and verification succeed it does not fail" do
-        expect(download_double).to receive(:fetch)
+        expect(download_double).to receive(:fetch).and_return(Pathname.new("/tmp/test.zip"))
         expect(run).to pass
       end
 
       it "when download fails it fails" do
         expect(download_double).to receive(:fetch).and_raise(StandardError.new(message))
-        expect(run).to fail_with(/#{message}/)
+        expect(run).to error_with(/#{message}/)
       end
     end
 
     context "when an exception is raised" do
       let(:cask) { instance_double(Cask::Cask) }
+      let(:only) { ["description"] }
 
       it "fails the audit" do
         expect(cask).to receive(:tap).and_raise(StandardError.new)
-        expect(run).to fail_with(/exception while auditing/)
+        expect(run).to error_with(/exception while auditing/)
       end
     end
 
-    describe "without description" do
+    describe "checking description" do
+      let(:only) { ["description"] }
       let(:cask_token) { "without-description" }
       let(:cask) do
         tmp_cask cask_token.to_s, <<~RUBY
@@ -937,142 +1033,160 @@ def tmp_cask(name, text)
         let(:new_cask) { true }
 
         it "fails" do
-          expect(run).to fail_with(/should have a description/)
+          expect(run).to error_with(/should have a description/)
         end
       end
 
       context "when `new_cask` is false" do
         let(:new_cask) { false }
 
-        it "warns" do
-          expect(run).to warn_with(/should have a description/)
+        it "does not warn" do
+          expect(run).not_to error_with(/should have a description/)
         end
       end
-    end
 
-    context "with description" do
-      let(:cask_token) { "with-description" }
-      let(:cask) do
-        tmp_cask cask_token.to_s, <<~RUBY
-          cask "#{cask_token}" do
-            version "1.0"
-            sha256 "8dd95daa037ac02455435446ec7bc737b34567afe9156af7d20b2a83805c1d8a"
-            url "https://brew.sh/\#{version}.zip"
-            name "Audit"
-            desc "Cask Auditor"
-            homepage "https://brew.sh/"
-            app "Audit.app"
-          end
-        RUBY
-      end
+      context "with description" do
+        let(:cask_token) { "with-description" }
+        let(:cask) do
+          tmp_cask cask_token.to_s, <<~RUBY
+            cask "#{cask_token}" do
+              version "1.0"
+              sha256 "8dd95daa037ac02455435446ec7bc737b34567afe9156af7d20b2a83805c1d8a"
+              url "https://brew.sh/\#{version}.zip"
+              name "Audit"
+              desc "Cask Auditor"
+              homepage "https://brew.sh/"
+              app "Audit.app"
+            end
+          RUBY
+        end
 
-      it "passes" do
-        expect(run).to pass
+        it "passes" do
+          expect(run).to pass
+        end
       end
     end
 
-    context "when the url matches the homepage" do
+    describe "checking verified" do
+      let(:only) { %w[unnecessary_verified missing_verified no_match required_stanzas] }
       let(:cask_token) { "foo" }
-      let(:cask) do
-        tmp_cask cask_token.to_s, <<~RUBY
-          cask '#{cask_token}' do
-            version '1.0'
-            sha256 '8dd95daa037ac02455435446ec7bc737b34567afe9156af7d20b2a83805c1d8a'
-            url 'https://foo.brew.sh/foo.zip'
-            name 'Audit'
-            desc 'Audit Description'
-            homepage 'https://foo.brew.sh'
-            app 'Audit.app'
-          end
-        RUBY
-      end
 
-      it { is_expected.to pass }
-    end
+      context "when the url matches the homepage" do
+        let(:cask) do
+          tmp_cask cask_token.to_s, <<~RUBY
+            cask '#{cask_token}' do
+              version '1.0'
+              sha256 '8dd95daa037ac02455435446ec7bc737b34567afe9156af7d20b2a83805c1d8a'
+              url 'https://foo.brew.sh/foo.zip'
+              name 'Audit'
+              desc 'Audit Description'
+              homepage 'https://foo.brew.sh'
+              app 'Audit.app'
+            end
+          RUBY
+        end
 
-    context "when the url does not match the homepage" do
-      let(:cask_token) { "foo" }
-      let(:cask) do
-        tmp_cask cask_token.to_s, <<~RUBY
-          cask '#{cask_token}' do
-            version "1.8.0_72,8.13.0.5"
-            sha256 "8dd95daa037ac02455435446ec7bc737b34567afe9156af7d20b2a83805c1d8a"
-            url "https://brew.sh/foo-\#{version.after_comma}.zip"
-            name "Audit"
-            desc "Audit Description"
-            homepage "https://foo.example.org"
-            app "Audit.app"
-          end
-        RUBY
+        it { is_expected.to pass }
       end
 
-      it { is_expected.to fail_with(/a 'verified' parameter has to be added/) }
-    end
+      context "when the url does not match the homepage" do
+        let(:cask) do
+          tmp_cask cask_token.to_s, <<~RUBY
+            cask '#{cask_token}' do
+              version "1.8.0_72,8.13.0.5"
+              sha256 "8dd95daa037ac02455435446ec7bc737b34567afe9156af7d20b2a83805c1d8a"
+              url "https://brew.sh/foo-\#{version.after_comma}.zip"
+              name "Audit"
+              desc "Audit Description"
+              homepage "https://foo.example.org"
+              app "Audit.app"
+            end
+          RUBY
+        end
 
-    context "when the url does not match the homepage with verified" do
-      let(:cask_token) { "foo" }
-      let(:cask) do
-        tmp_cask cask_token.to_s, <<~RUBY
-          cask "#{cask_token}" do
-            version "1.8.0_72,8.13.0.5"
-            sha256 "8dd95daa037ac02455435446ec7bc737b34567afe9156af7d20b2a83805c1d8a"
-            url "https://brew.sh/foo-\#{version.after_comma}.zip", verified: "brew.sh"
-            name "Audit"
-            desc "Audit Description"
-            homepage "https://foo.example.org"
-            app "Audit.app"
-          end
-        RUBY
+        it { is_expected.to error_with(/a 'verified' parameter has to be added/) }
       end
 
-      it { is_expected.to pass }
-    end
+      context "when the url does not match the homepage with verified" do
+        let(:cask) do
+          tmp_cask cask_token.to_s, <<~RUBY
+            cask "#{cask_token}" do
+              version "1.8.0_72,8.13.0.5"
+              sha256 "8dd95daa037ac02455435446ec7bc737b34567afe9156af7d20b2a83805c1d8a"
+              url "https://brew.sh/foo-\#{version.after_comma}.zip", verified: "brew.sh"
+              name "Audit"
+              desc "Audit Description"
+              homepage "https://foo.example.org"
+              app "Audit.app"
+            end
+          RUBY
+        end
 
-    context "when there is no homepage" do
-      let(:cask_token) { "foo" }
-      let(:cask) do
-        tmp_cask cask_token.to_s, <<~RUBY
-          cask '#{cask_token}' do
-            version '1.8.0_72,8.13.0.5'
-            sha256 '8dd95daa037ac02455435446ec7bc737b34567afe9156af7d20b2a83805c1d8a'
-            url 'https://brew.sh/foo.zip'
-            name 'Audit'
-            desc 'Audit Description'
-            app 'Audit.app'
-          end
-        RUBY
+        it { is_expected.to pass }
       end
 
-      it { is_expected.to fail_with(/a homepage stanza is required/) }
-    end
-
-    context "when url is lazy" do
-      let(:strict) { true }
-      let(:cask_token) { "with-lazy" }
-      let(:cask) do
-        tmp_cask cask_token.to_s, <<~RUBY
-          cask '#{cask_token}' do
-            version '1.8.0_72,8.13.0.5'
-            sha256 '8dd95daa037ac02455435446ec7bc737b34567afe9156af7d20b2a83805c1d8a'
-            url do
-              ['https://brew.sh/foo.zip', {referer: 'https://example.com', cookies: {'foo' => 'bar'}}]
+      context "when there is no homepage" do
+        let(:cask) do
+          tmp_cask cask_token.to_s, <<~RUBY
+            cask '#{cask_token}' do
+              version '1.8.0_72,8.13.0.5'
+              sha256 '8dd95daa037ac02455435446ec7bc737b34567afe9156af7d20b2a83805c1d8a'
+              url 'https://brew.sh/foo.zip'
+              name 'Audit'
+              desc 'Audit Description'
+              app 'Audit.app'
             end
-            name 'Audit'
-            desc 'Audit Description'
-            homepage 'https://brew.sh'
-            app 'Audit.app'
-          end
-        RUBY
+          RUBY
+        end
+
+        it { is_expected.to error_with(/a homepage stanza is required/) }
       end
+    end
 
-      it { is_expected.to pass }
+    describe "checking deprecate/disable" do
+      let(:only) { ["deprecate_disable"] }
+      let(:cask_token) { "deprecated-cask" }
+
+      context "when deprecate/disable is used with a valid reason" do
+        let(:cask) do
+          tmp_cask cask_token.to_s, <<~RUBY
+            cask '#{cask_token}' do
+              version "1.0"
+                sha256 "8dd95daa037ac02455435446ec7bc737b34567afe9156af7d20b2a83805c1d8a"
+                url "https://brew.sh/foo.zip"
+                name "Audit"
+                desc "Cask Auditor"
+                homepage "https://brew.sh/"
+                app "Audit.app"
+                deprecate! date: "2021-01-01", because: :foobar
+            end
+          RUBY
+        end
 
-      it "receives a referer" do
-        expect(audit.cask.url.referer).to eq "https://example.com"
+        it "fails" do
+          expect(run).to error_with(/foobar is not a valid deprecate! or disable! reason/)
+        end
       end
 
-      it "receives cookies" do
-        expect(audit.cask.url.cookies).to eq "foo" => "bar"
+      context "when deprecate/disable is used with an invalid reason" do
+        let(:cask) do
+          tmp_cask cask_token.to_s, <<~RUBY
+            cask '#{cask_token}' do
+              version "1.0"
+                sha256 "8dd95daa037ac02455435446ec7bc737b34567afe9156af7d20b2a83805c1d8a"
+                url "https://brew.sh/foo.zip"
+                name "Audit"
+                desc "Cask Auditor"
+                homepage "https://brew.sh/"
+                app "Audit.app"
+                disable! date: "2021-01-01", because: :discontinued
+            end
+          RUBY
+        end
+
+        it "passes" do
+          expect(run).to pass
+        end
       end
     end
   end
diff --git a/Library/Homebrew/test/cask/cask_loader/from__path_loader_spec.rb b/Library/Homebrew/test/cask/cask_loader/from__path_loader_spec.rb
deleted file mode 100644
index 92079eb940ab4..0000000000000
--- a/Library/Homebrew/test/cask/cask_loader/from__path_loader_spec.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-describe Cask::CaskLoader::FromPathLoader do
-  describe "#load" do
-    context "when the file does not contain a cask" do
-      let(:path) {
-        (mktmpdir/"cask.rb").tap do |path|
-          path.write <<~RUBY
-            true
-          RUBY
-        end
-      }
-
-      it "raises an error" do
-        expect {
-          described_class.new(path).load(config: nil)
-        }.to raise_error(Cask::CaskUnreadableError, /does not contain a cask/)
-      end
-    end
-
-    context "when the file calls a non-existent method" do
-      let(:path) {
-        (mktmpdir/"cask.rb").tap do |path|
-          path.write <<~RUBY
-            this_method_does_not_exist
-          RUBY
-        end
-      }
-
-      it "raises an error" do
-        expect {
-          described_class.new(path).load(config: nil)
-        }.to raise_error(Cask::CaskUnreadableError, /undefined local variable or method/)
-      end
-    end
-
-    context "when the file contains an outdated cask" do
-      it "raises an error" do
-        expect {
-          described_class.new(cask_path("invalid/invalid-depends-on-macos-bad-release")).load(config: nil)
-        }.to raise_error(Cask::CaskInvalidError,
-                         /invalid 'depends_on macos' value: unknown or unsupported macOS version:/)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/test/cask/cask_loader/from_api_loader_spec.rb b/Library/Homebrew/test/cask/cask_loader/from_api_loader_spec.rb
new file mode 100644
index 0000000000000..f066a098a93ac
--- /dev/null
+++ b/Library/Homebrew/test/cask/cask_loader/from_api_loader_spec.rb
@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+RSpec.describe Cask::CaskLoader::FromAPILoader, :cask do
+  shared_context "with API setup" do |local_token|
+    let(:api_token) { "#{local_token}-api" }
+    let(:cask_from_source) { Cask::CaskLoader.load(local_token) }
+    let(:cask_json) do
+      hash = cask_from_source.to_hash_with_variations
+      json = JSON.pretty_generate(hash)
+      JSON.parse(json)
+    end
+    let(:casks_from_api_hash) { { api_token => cask_json.except("token") } }
+    let(:api_loader) { described_class.new(api_token, from_json: cask_json) }
+
+    before do
+      allow(Homebrew::API::Cask)
+        .to receive_messages(all_casks: casks_from_api_hash, all_renames: {})
+
+      # The call to `Cask::CaskLoader.load` above sets the Tap cache prematurely.
+      Tap.clear_cache
+    end
+  end
+
+  describe ".try_new" do
+    include_context "with API setup", "test-opera"
+
+    context "when not using the API", :no_api do
+      it "returns false" do
+        expect(described_class.try_new(api_token)).to be_nil
+      end
+    end
+
+    context "when using the API" do
+      before do
+        ENV.delete("HOMEBREW_NO_INSTALL_FROM_API")
+      end
+
+      it "returns a loader for valid token" do
+        expect(described_class.try_new(api_token))
+          .to be_a(described_class)
+          .and have_attributes(token: api_token)
+      end
+
+      it "returns a loader for valid full name" do
+        expect(described_class.try_new("homebrew/cask/#{api_token}"))
+          .to be_a(described_class)
+          .and have_attributes(token: api_token)
+      end
+
+      it "returns nil for full name with invalid tap" do
+        expect(described_class.try_new("homebrew/foo/#{api_token}")).to be_nil
+      end
+
+      context "with core tap migration renames" do
+        let(:foo_tap) { Tap.fetch("homebrew", "foo") }
+
+        before do
+          foo_tap.path.mkpath
+        end
+
+        after do
+          FileUtils.rm_rf foo_tap.path
+        end
+
+        it "returns the tap migration rename by old token" do
+          old_token = "#{api_token}-old"
+          (foo_tap.path/"tap_migrations.json").write <<~JSON
+            { "#{old_token}": "homebrew/cask/#{api_token}" }
+          JSON
+
+          loader = Cask::CaskLoader::FromNameLoader.try_new(old_token)
+          expect(loader).to be_a(described_class)
+          expect(loader.token).to eq api_token
+          expect(loader.path).not_to exist
+        end
+
+        it "returns the tap migration rename by old full name" do
+          old_token = "#{api_token}-old"
+          (foo_tap.path/"tap_migrations.json").write <<~JSON
+            { "#{old_token}": "homebrew/cask/#{api_token}" }
+          JSON
+
+          loader = Cask::CaskLoader::FromTapLoader.try_new("#{foo_tap}/#{old_token}")
+          expect(loader).to be_a(described_class)
+          expect(loader.token).to eq api_token
+          expect(loader.path).not_to exist
+        end
+      end
+    end
+  end
+
+  describe "#load" do
+    shared_examples "loads from API" do |cask_token, caskfile_only:|
+      include_context "with API setup", cask_token
+      let(:cask_from_api) { api_loader.load(config: nil) }
+
+      it "loads from JSON API" do
+        expect(cask_from_api).to be_a(Cask::Cask)
+        expect(cask_from_api.token).to eq(api_token)
+        expect(cask_from_api.loaded_from_api?).to be(true)
+        expect(cask_from_api.caskfile_only?).to be(caskfile_only)
+        expect(cask_from_api.sourcefile_path).to eq(Homebrew::API::Cask.cached_json_file_path)
+      end
+    end
+
+    context "with a binary stanza" do
+      include_examples "loads from API", "with-binary", caskfile_only: false
+    end
+
+    context "with cask dependencies" do
+      include_examples "loads from API", "with-depends-on-cask-multiple", caskfile_only: false
+    end
+
+    context "with formula dependencies" do
+      include_examples "loads from API", "with-depends-on-formula-multiple", caskfile_only: false
+    end
+
+    context "with macos dependencies" do
+      include_examples "loads from API", "with-depends-on-macos-array", caskfile_only: false
+    end
+
+    context "with an installer stanza" do
+      include_examples "loads from API", "with-installer-script", caskfile_only: false
+    end
+
+    context "with uninstall stanzas" do
+      include_examples "loads from API", "with-uninstall-multi", caskfile_only: false
+    end
+
+    context "with a zap stanza" do
+      include_examples "loads from API", "with-zap", caskfile_only: false
+    end
+
+    context "with a preflight stanza" do
+      include_examples "loads from API", "with-preflight", caskfile_only: true
+    end
+
+    context "with an uninstall-preflight stanza" do
+      include_examples "loads from API", "with-uninstall-preflight", caskfile_only: true
+    end
+
+    context "with a postflight stanza" do
+      include_examples "loads from API", "with-postflight", caskfile_only: true
+    end
+
+    context "with an uninstall-postflight stanza" do
+      include_examples "loads from API", "with-uninstall-postflight", caskfile_only: true
+    end
+
+    context "with a language stanza" do
+      include_examples "loads from API", "with-languages", caskfile_only: true
+    end
+  end
+end
diff --git a/Library/Homebrew/test/cask/cask_loader/from_content_loader_spec.rb b/Library/Homebrew/test/cask/cask_loader/from_content_loader_spec.rb
index c956d089e0fb0..ca97c8b9259c4 100644
--- a/Library/Homebrew/test/cask/cask_loader/from_content_loader_spec.rb
+++ b/Library/Homebrew/test/cask/cask_loader/from_content_loader_spec.rb
@@ -1,58 +1,55 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::CaskLoader::FromContentLoader do
-  alias_matcher :be_able_to_load, :be_can_load
-
-  describe "::can_load?" do
-    it "returns true for Casks specified with `cask \"token\" do … end`" do
-      expect(described_class).to be_able_to_load <<~RUBY
+RSpec.describe Cask::CaskLoader::FromContentLoader do
+  describe "::try_new" do
+    it "returns a loader for Casks specified with `cask \"token\" do … end`" do
+      expect(described_class.try_new(<<~RUBY)).not_to be_nil
         cask "token" do
         end
       RUBY
     end
 
-    it "returns true for Casks specified with `cask \"token\" do; end`" do
-      expect(described_class).to be_able_to_load <<~RUBY
+    it "returns a loader for Casks specified with `cask \"token\" do; end`" do
+      expect(described_class.try_new(<<~RUBY)).not_to be_nil
         cask "token" do; end
       RUBY
     end
 
-    it "returns true for Casks specified with `cask 'token' do … end`" do
-      expect(described_class).to be_able_to_load <<~RUBY
+    it "returns a loader for Casks specified with `cask 'token' do … end`" do
+      expect(described_class.try_new(<<~RUBY)).not_to be_nil
         cask 'token' do
         end
       RUBY
     end
 
-    it "returns true for Casks specified with `cask 'token' do; end`" do
-      expect(described_class).to be_able_to_load <<~RUBY
+    it "returns a loader for Casks specified with `cask 'token' do; end`" do
+      expect(described_class.try_new(<<~RUBY)).not_to be_nil
         cask 'token' do; end
       RUBY
     end
 
-    it "returns true for Casks specified with `cask(\"token\") { … }`" do
-      expect(described_class).to be_able_to_load <<~RUBY
+    it "returns a loader for Casks specified with `cask(\"token\") { … }`" do
+      expect(described_class.try_new(<<~RUBY)).not_to be_nil
         cask("token") {
         }
       RUBY
     end
 
-    it "returns true for Casks specified with `cask(\"token\") {}`" do
-      expect(described_class).to be_able_to_load <<~RUBY
+    it "returns a loader for Casks specified with `cask(\"token\") {}`" do
+      expect(described_class.try_new(<<~RUBY)).not_to be_nil
         cask("token") {}
       RUBY
     end
 
-    it "returns true for Casks specified with `cask('token') { … }`" do
-      expect(described_class).to be_able_to_load <<~RUBY
+    it "returns a loader for Casks specified with `cask('token') { … }`" do
+      expect(described_class.try_new(<<~RUBY)).not_to be_nil
         cask('token') {
         }
       RUBY
     end
 
-    it "returns true for Casks specified with `cask('token') {}`" do
-      expect(described_class).to be_able_to_load <<~RUBY
+    it "returns a loader for Casks specified with `cask('token') {}`" do
+      expect(described_class.try_new(<<~RUBY)).not_to be_nil
         cask('token') {}
       RUBY
     end
diff --git a/Library/Homebrew/test/cask/cask_loader/from_path_loader_spec.rb b/Library/Homebrew/test/cask/cask_loader/from_path_loader_spec.rb
new file mode 100644
index 0000000000000..0322a42ba3c11
--- /dev/null
+++ b/Library/Homebrew/test/cask/cask_loader/from_path_loader_spec.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.describe Cask::CaskLoader::FromPathLoader do
+  describe "#load" do
+    context "when the file does not contain a cask" do
+      let(:path) do
+        (mktmpdir/"cask.rb").tap do |path|
+          path.write <<~RUBY
+            true
+          RUBY
+        end
+      end
+
+      it "raises an error" do
+        expect do
+          described_class.new(path).load(config: nil)
+        end.to raise_error(Cask::CaskUnreadableError, /does not contain a cask/)
+      end
+    end
+
+    context "when the file calls a non-existent method" do
+      let(:path) do
+        (mktmpdir/"cask.rb").tap do |path|
+          path.write <<~RUBY
+            this_method_does_not_exist
+          RUBY
+        end
+      end
+
+      it "raises an error" do
+        expect do
+          described_class.new(path).load(config: nil)
+        end.to raise_error(Cask::CaskUnreadableError, /undefined local variable or method/)
+      end
+    end
+
+    context "when the file contains an outdated cask" do
+      it "raises an error" do
+        expect do
+          described_class.new(cask_path("invalid/invalid-depends-on-macos-bad-release")).load(config: nil)
+        end.to raise_error(Cask::CaskInvalidError,
+                           /invalid 'depends_on macos' value: unknown or unsupported macOS version:/)
+      end
+    end
+
+    context "with a JSON cask file" do
+      let(:sourcefile_path) { TEST_FIXTURE_DIR/"cask/everything.json" }
+
+      it "loads a cask with a source file path" do
+        cask = described_class.new(sourcefile_path).load(config: nil)
+        expect(cask.sourcefile_path).to eq sourcefile_path
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/test/cask/cask_loader/from_tap_loader_spec.rb b/Library/Homebrew/test/cask/cask_loader/from_tap_loader_spec.rb
new file mode 100644
index 0000000000000..b01ccfa21fcf9
--- /dev/null
+++ b/Library/Homebrew/test/cask/cask_loader/from_tap_loader_spec.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+RSpec.describe Cask::CaskLoader::FromTapLoader do
+  let(:tap) { CoreCaskTap.instance }
+  let(:cask_name) { "testball" }
+  let(:cask_full_name) { "homebrew/cask/#{cask_name}" }
+  let(:cask_path) { tap.cask_dir/"#{cask_name}.rb" }
+
+  describe "#load" do
+    before do
+      cask_path.parent.mkpath
+      cask_path.write <<~RUBY
+        cask '#{cask_name}' do
+          url 'https://brew.sh/'
+        end
+      RUBY
+    end
+
+    it "returns a Cask" do
+      expect(described_class.new(cask_full_name).load(config: nil)).to be_a(Cask::Cask)
+    end
+
+    it "raises an error if the Cask cannot be found" do
+      expect { described_class.new("foo/bar/baz").load(config: nil) }.to raise_error(Cask::CaskUnavailableError)
+    end
+
+    context "with sharded Cask directory" do
+      let(:cask_path) { tap.cask_dir/cask_name[0]/"#{cask_name}.rb" }
+
+      it "returns a Cask" do
+        expect(described_class.new(cask_full_name).load(config: nil)).to be_a(Cask::Cask)
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/test/cask/cask_loader/from_uri_loader_spec.rb b/Library/Homebrew/test/cask/cask_loader/from_uri_loader_spec.rb
index c1708d69467f2..d1777c9f6dcaa 100644
--- a/Library/Homebrew/test/cask/cask_loader/from_uri_loader_spec.rb
+++ b/Library/Homebrew/test/cask/cask_loader/from_uri_loader_spec.rb
@@ -1,24 +1,56 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::CaskLoader::FromURILoader do
-  alias_matcher :be_able_to_load, :be_can_load
+RSpec.describe Cask::CaskLoader::FromURILoader do
+  describe "::try_new" do
+    it "returns a loader when given an URI" do
+      expect(described_class.try_new(URI("https://brew.sh/"))).not_to be_nil
+    end
 
-  describe "::can_load?" do
-    it "returns true when given an URI" do
-      expect(described_class).to be_able_to_load(URI("https://brew.sh/"))
+    it "returns a loader when given a string which can be parsed to a URI" do
+      expect(described_class.try_new("https://brew.sh/")).not_to be_nil
     end
 
-    it "returns true when given a String which can be parsed to a URI" do
-      expect(described_class).to be_able_to_load("https://brew.sh/")
+    it "returns nil when path loading is disabled" do
+      ENV["HOMEBREW_FORBID_PACKAGES_FROM_PATHS"] = "1"
+      expect(described_class.try_new(URI("file://#{TEST_FIXTURE_DIR}/cask/Casks/local-caffeine.rb"))).to be_nil
     end
 
-    it "returns false when given a String with Cask contents containing a URL" do
-      expect(described_class).not_to be_able_to_load <<~RUBY
+    it "returns nil when given a string with Cask contents containing a URL" do
+      expect(described_class.try_new(<<~RUBY)).to be_nil
         cask 'token' do
           url 'https://brew.sh/'
         end
       RUBY
     end
   end
+
+  describe "::load" do
+    it "raises an error when given an https URL" do
+      loader = described_class.new("https://brew.sh/foo.rb")
+      expect do
+        loader.load(config: nil)
+      end.to raise_error(UnsupportedInstallationMethod)
+    end
+
+    it "raises an error when given an ftp URL" do
+      loader = described_class.new("ftp://brew.sh/foo.rb")
+      expect do
+        loader.load(config: nil)
+      end.to raise_error(UnsupportedInstallationMethod)
+    end
+
+    it "raises an error when given an sftp URL" do
+      loader = described_class.new("sftp://brew.sh/foo.rb")
+      expect do
+        loader.load(config: nil)
+      end.to raise_error(UnsupportedInstallationMethod)
+    end
+
+    it "does not raise an error when given a file URL" do
+      loader = described_class.new("file://#{TEST_FIXTURE_DIR}/cask/Casks/local-caffeine.rb")
+      expect do
+        loader.load(config: nil)
+      end.not_to raise_error(UnsupportedInstallationMethod)
+    end
+  end
 end
diff --git a/Library/Homebrew/test/cask/cask_loader_spec.rb b/Library/Homebrew/test/cask/cask_loader_spec.rb
new file mode 100644
index 0000000000000..8d86856f16535
--- /dev/null
+++ b/Library/Homebrew/test/cask/cask_loader_spec.rb
@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+RSpec.describe Cask::CaskLoader, :cask do
+  describe "::for" do
+    let(:tap) { CoreCaskTap.instance }
+
+    context "when a cask is renamed" do
+      let(:old_token) { "version-newest" }
+      let(:new_token) { "version-latest" }
+
+      let(:api_casks) do
+        [old_token, new_token].to_h do |token|
+          hash = described_class.load(new_token).to_hash_with_variations
+          json = JSON.pretty_generate(hash)
+          cask_json = JSON.parse(json)
+
+          [token, cask_json.except("token")]
+        end
+      end
+      let(:cask_renames) do
+        { old_token => new_token }
+      end
+
+      before do
+        allow(Homebrew::API::Cask)
+          .to receive(:all_casks)
+          .and_return(api_casks)
+
+        allow(tap).to receive(:cask_renames)
+          .and_return(cask_renames)
+      end
+
+      context "when not using the API", :no_api do
+        it "warns when using the short token" do
+          expect do
+            expect(described_class.for("version-newest")).to be_a Cask::CaskLoader::FromPathLoader
+          end.to output(/version-newest was renamed to version-latest/).to_stderr
+        end
+
+        it "warns when using the full token" do
+          expect do
+            expect(described_class.for("homebrew/cask/version-newest")).to be_a Cask::CaskLoader::FromPathLoader
+          end.to output(/version-newest was renamed to version-latest/).to_stderr
+        end
+      end
+
+      context "when using the API" do
+        before do
+          ENV.delete("HOMEBREW_NO_INSTALL_FROM_API")
+        end
+
+        it "warns when using the short token" do
+          expect do
+            expect(described_class.for("version-newest")).to be_a Cask::CaskLoader::FromAPILoader
+          end.to output(/version-newest was renamed to version-latest/).to_stderr
+        end
+
+        it "warns when using the full token" do
+          expect do
+            expect(described_class.for("homebrew/cask/version-newest")).to be_a Cask::CaskLoader::FromAPILoader
+          end.to output(/version-newest was renamed to version-latest/).to_stderr
+        end
+      end
+    end
+
+    context "when not using the API", :no_api do
+      context "when a cask is migrated" do
+        let(:token) { "local-caffeine" }
+
+        let(:core_tap) { CoreTap.instance }
+        let(:core_cask_tap) { CoreCaskTap.instance }
+
+        let(:tap_migrations) do
+          {
+            token => new_tap.name,
+          }
+        end
+
+        before do
+          old_tap.path.mkpath
+          new_tap.path.mkpath
+          (old_tap.path/"tap_migrations.json").write tap_migrations.to_json
+        end
+
+        context "to a cask in an other tap" do
+          # Can't use local-caffeine. It is a fixture in the :core_cask_tap and would take precendence over :new_tap.
+          let(:token) { "some-cask" }
+
+          let(:old_tap) { Tap.fetch("homebrew", "foo") }
+          let(:new_tap) { Tap.fetch("homebrew", "bar") }
+
+          let(:cask_file) { new_tap.cask_dir/"#{token}.rb" }
+
+          before do
+            new_tap.cask_dir.mkpath
+            FileUtils.touch cask_file
+          end
+
+          # FIXME
+          # It would be preferable not to print a warning when installing with the short token
+          it "warns when loading the short token" do
+            expect do
+              described_class.for(token)
+            end.to output(%r{Cask #{old_tap}/#{token} was renamed to #{new_tap}/#{token}\.}).to_stderr
+          end
+
+          it "does not warn when loading the full token in the new tap" do
+            expect do
+              described_class.for("#{new_tap}/#{token}")
+            end.not_to output.to_stderr
+          end
+
+          it "warns when loading the full token in the old tap" do
+            expect do
+              described_class.for("#{old_tap}/#{token}")
+            end.to output(%r{Cask #{old_tap}/#{token} was renamed to #{new_tap}/#{token}\.}).to_stderr
+          end
+        end
+
+        context "to a formula in the default tap" do
+          let(:old_tap) { core_cask_tap }
+          let(:new_tap) { core_tap }
+
+          let(:formula_file) { new_tap.formula_dir/"#{token}.rb" }
+
+          before do
+            new_tap.formula_dir.mkpath
+            FileUtils.touch formula_file
+          end
+
+          it "warn only once" do
+            expect do
+              described_class.for(token)
+            end.to output(
+              a_string_including("Warning: Cask #{token} was renamed to #{new_tap}/#{token}.").once,
+            ).to_stderr
+          end
+        end
+
+        context "to the default tap" do
+          let(:old_tap) { core_tap }
+          let(:new_tap) { core_cask_tap }
+
+          let(:cask_file) { new_tap.cask_dir/"#{token}.rb" }
+
+          before do
+            new_tap.cask_dir.mkpath
+            FileUtils.touch cask_file
+          end
+
+          it "does not warn when loading the short token" do
+            expect do
+              described_class.for(token)
+            end.not_to output.to_stderr
+          end
+
+          it "does not warn when loading the full token in the default tap" do
+            expect do
+              described_class.for("#{new_tap}/#{token}")
+            end.not_to output.to_stderr
+          end
+
+          it "warns when loading the full token in the old tap" do
+            expect do
+              described_class.for("#{old_tap}/#{token}")
+            end.to output(%r{Cask #{old_tap}/#{token} was renamed to #{token}\.}).to_stderr
+          end
+
+          # FIXME
+          # context "when there is an infinite tap migration loop" do
+          #   before do
+          #     (new_tap.path/"tap_migrations.json").write({
+          #       token => old_tap.name,
+          #     }.to_json)
+          #   end
+          #
+          #   it "stops recursing" do
+          #     expect do
+          #       described_class.for("#{new_tap}/#{token}")
+          #     end.not_to output.to_stderr
+          #   end
+          # end
+        end
+      end
+    end
+  end
+
+  describe "::load_prefer_installed" do
+    let(:foo_tap) { Tap.fetch("user", "foo") }
+    let(:bar_tap) { Tap.fetch("user", "bar") }
+
+    let(:blank_tab) { instance_double(Cask::Tab, tap: nil) }
+    let(:installed_tab) { instance_double(Cask::Tab, tap: bar_tap) }
+
+    let(:cask_with_foo_tap) { instance_double(Cask::Cask, token: "test-cask", tap: foo_tap) }
+    let(:cask_with_bar_tap) { instance_double(Cask::Cask, token: "test-cask", tap: bar_tap) }
+
+    let(:load_args) { { config: nil, warn: true } }
+
+    before do
+      allow(described_class).to receive(:load).with("test-cask", load_args).and_return(cask_with_foo_tap)
+      allow(described_class).to receive(:load).with("user/foo/test-cask", load_args).and_return(cask_with_foo_tap)
+      allow(described_class).to receive(:load).with("user/bar/test-cask", load_args).and_return(cask_with_bar_tap)
+    end
+
+    it "returns the correct cask when no tap is specified and no tab exists" do
+      allow_any_instance_of(Cask::Cask).to receive(:tab).and_return(blank_tab)
+      expect(described_class).to receive(:load).with("test-cask", load_args)
+
+      expect(described_class.load_prefer_installed("test-cask").tap).to eq(foo_tap)
+    end
+
+    it "returns the correct cask when no tap is specified but a tab exists" do
+      allow_any_instance_of(Cask::Cask).to receive(:tab).and_return(installed_tab)
+      expect(described_class).to receive(:load).with("user/bar/test-cask", load_args)
+
+      expect(described_class.load_prefer_installed("test-cask").tap).to eq(bar_tap)
+    end
+
+    it "returns the correct cask when a tap is specified and no tab exists" do
+      allow_any_instance_of(Cask::Cask).to receive(:tab).and_return(blank_tab)
+      expect(described_class).to receive(:load).with("user/bar/test-cask", load_args)
+
+      expect(described_class.load_prefer_installed("user/bar/test-cask").tap).to eq(bar_tap)
+    end
+
+    it "returns the correct cask when no tap is specified and a tab exists" do
+      allow_any_instance_of(Cask::Cask).to receive(:tab).and_return(installed_tab)
+      expect(described_class).to receive(:load).with("user/foo/test-cask", load_args)
+
+      expect(described_class.load_prefer_installed("user/foo/test-cask").tap).to eq(foo_tap)
+    end
+
+    it "returns the correct cask when no tap is specified and the tab lists an tap that isn't installed" do
+      allow_any_instance_of(Cask::Cask).to receive(:tab).and_return(installed_tab)
+      expect(described_class).to receive(:load).with("user/bar/test-cask", load_args)
+                                               .and_raise(Cask::CaskUnavailableError.new("test-cask", bar_tap))
+      expect(described_class).to receive(:load).with("test-cask", load_args)
+
+      expect(described_class.load_prefer_installed("test-cask").tap).to eq(foo_tap)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/cask/cask_spec.rb b/Library/Homebrew/test/cask/cask_spec.rb
index f52ba3cb664ad..038316a682715 100644
--- a/Library/Homebrew/test/cask/cask_spec.rb
+++ b/Library/Homebrew/test/cask/cask_spec.rb
@@ -1,11 +1,10 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Cask, :cask do
+RSpec.describe Cask::Cask, :cask do
   let(:cask) { described_class.new("versioned-cask") }
 
   context "when multiple versions are installed" do
-    describe "#versions" do
+    describe "#installed_version" do
       context "when there are duplicate versions" do
         it "uses the last unique version" do
           allow(cask).to receive(:timestamped_versions).and_return([
@@ -14,50 +13,54 @@
             ["1.2.2", "1001"],
           ])
 
+          # Installed caskfile must exist to count as installed.
+          allow_any_instance_of(Pathname).to receive(:exist?).and_return(true)
+
           expect(cask).to receive(:timestamped_versions)
-          expect(cask.versions).to eq([
-            "1.2.3",
-            "1.2.2",
-          ])
+          expect(cask.installed_version).to eq("1.2.2")
         end
       end
     end
   end
 
   describe "load" do
-    let(:tap_path) { Tap.default_cask_tap.path }
+    let(:tap_path) { CoreCaskTap.instance.path }
     let(:file_dirname) { Pathname.new(__FILE__).dirname }
     let(:relative_tap_path) { tap_path.relative_path_from(file_dirname) }
 
     it "returns an instance of the Cask for the given token" do
       c = Cask::CaskLoader.load("local-caffeine")
-      expect(c).to be_kind_of(described_class)
+      expect(c).to be_a(described_class)
       expect(c.token).to eq("local-caffeine")
     end
 
     it "returns an instance of the Cask from a specific file location" do
       c = Cask::CaskLoader.load("#{tap_path}/Casks/local-caffeine.rb")
-      expect(c).to be_kind_of(described_class)
+      expect(c).to be_a(described_class)
       expect(c.token).to eq("local-caffeine")
     end
 
-    it "returns an instance of the Cask from a URL" do
+    it "returns an instance of the Cask from a JSON file" do
+      c = Cask::CaskLoader.load("#{TEST_FIXTURE_DIR}/cask/caffeine.json")
+      expect(c).to be_a(described_class)
+      expect(c.token).to eq("caffeine")
+    end
+
+    it "returns an instance of the Cask from a URL", :needs_utils_curl, :no_api do
       c = Cask::CaskLoader.load("file://#{tap_path}/Casks/local-caffeine.rb")
-      expect(c).to be_kind_of(described_class)
+      expect(c).to be_a(described_class)
       expect(c.token).to eq("local-caffeine")
     end
 
-    it "raises an error when failing to download a Cask from a URL" do
-      expect {
-        url = "file://#{tap_path}/Casks/notacask.rb"
-
-        Cask::CaskLoader.load(url)
-      }.to raise_error(Cask::CaskUnavailableError)
+    it "raises an error when failing to download a Cask from a URL", :needs_utils_curl, :no_api do
+      expect do
+        Cask::CaskLoader.load("file://#{tap_path}/Casks/notacask.rb")
+      end.to raise_error(Cask::CaskUnavailableError)
     end
 
     it "returns an instance of the Cask from a relative file location" do
       c = Cask::CaskLoader.load(relative_tap_path/"Casks/local-caffeine.rb")
-      expect(c).to be_kind_of(described_class)
+      expect(c).to be_a(described_class)
       expect(c.token).to eq("local-caffeine")
     end
 
@@ -67,9 +70,9 @@
     end
 
     it "raises an error when attempting to load a Cask that doesn't exist" do
-      expect {
+      expect do
         Cask::CaskLoader.load("notacask")
-      }.to raise_error(Cask::CaskUnavailableError)
+      end.to raise_error(Cask::CaskUnavailableError)
     end
   end
 
@@ -86,27 +89,27 @@
     it "ignores the Casks that have auto_updates true (without --greedy)" do
       c = Cask::CaskLoader.load("auto-updates")
       expect(c).not_to be_outdated
-      expect(c.outdated_versions).to be_empty
+      expect(c.outdated_version).to be_nil
     end
 
     it "ignores the Casks that have version :latest (without --greedy)" do
       c = Cask::CaskLoader.load("version-latest-string")
       expect(c).not_to be_outdated
-      expect(c.outdated_versions).to be_empty
+      expect(c.outdated_version).to be_nil
     end
 
     describe "versioned casks" do
-      subject { cask.outdated_versions }
+      subject { cask.outdated_version }
 
       let(:cask) { described_class.new("basic-cask") }
 
       shared_examples "versioned casks" do |tap_version, expectations|
-        expectations.each do |installed_versions, expected_output|
-          context "when versions #{installed_versions.inspect} are installed and the tap version is #{tap_version}" do
+        expectations.each do |installed_version, expected_output|
+          context "when version #{installed_version.inspect} is installed and the tap version is #{tap_version}" do
             it {
-              allow(cask).to receive(:versions).and_return(installed_versions)
-              allow(cask).to receive(:version).and_return(Cask::DSL::Version.new(tap_version))
-              expect(cask).to receive(:outdated_versions).and_call_original
+              allow(cask).to receive_messages(installed_version:,
+                                              version:           Cask::DSL::Version.new(tap_version))
+              expect(cask).to receive(:outdated_version).and_call_original
               expect(subject).to eq expected_output
             }
           end
@@ -115,16 +118,13 @@
 
       describe "installed version is equal to tap version => not outdated" do
         include_examples "versioned casks", "1.2.3",
-                         ["1.2.3"]          => [],
-                         ["1.2.4", "1.2.3"] => []
+                         "1.2.3" => nil
       end
 
       describe "installed version is different than tap version => outdated" do
         include_examples "versioned casks", "1.2.4",
-                         ["1.2.3"]                   => ["1.2.3"],
-                         ["1.2.4", "1.2.3"]          => ["1.2.3"],
-                         ["1.2.2", "1.2.3"]          => ["1.2.2", "1.2.3"],
-                         ["1.2.2", "1.2.4", "1.2.3"] => ["1.2.2", "1.2.3"]
+                         "1.2.3" => "1.2.3",
+                         "1.2.4" => nil
       end
     end
 
@@ -136,13 +136,13 @@
           context "when versions #{installed_version} are installed and the " \
                   "tap version is #{tap_version}, #{"not " unless greedy}greedy " \
                   "and sha is #{"not " unless outdated_sha}outdated" do
-            subject { cask.outdated_versions(greedy: greedy) }
+            subject { cask.outdated_version(greedy:) }
 
             it {
-              allow(cask).to receive(:versions).and_return(installed_version)
-              allow(cask).to receive(:version).and_return(Cask::DSL::Version.new(tap_version))
-              allow(cask).to receive(:outdated_download_sha?).and_return(outdated_sha)
-              expect(cask).to receive(:outdated_versions).and_call_original
+              allow(cask).to receive_messages(installed_version:,
+                                              version:                Cask::DSL::Version.new(tap_version),
+                                              outdated_download_sha?: outdated_sha)
+              expect(cask).to receive(:outdated_version).and_call_original
               expect(subject).to eq expected_output
             }
           end
@@ -151,29 +151,29 @@
 
       describe ":latest version installed, :latest version in tap" do
         include_examples ":latest cask", false, false, "latest",
-                         ["latest"] => []
+                         "latest" => nil
         include_examples ":latest cask", true, false, "latest",
-                         ["latest"] => []
+                         "latest" => nil
         include_examples ":latest cask", true, true, "latest",
-                         ["latest"] => ["latest"]
+                         "latest" => "latest"
       end
 
       describe "numbered version installed, :latest version in tap" do
         include_examples ":latest cask", false, false, "latest",
-                         ["1.2.3"] => []
+                         "1.2.3" => nil
         include_examples ":latest cask", true, false, "latest",
-                         ["1.2.3"] => []
+                         "1.2.3" => nil
         include_examples ":latest cask", true, true, "latest",
-                         ["1.2.3"] => ["1.2.3"]
+                         "1.2.3" => "1.2.3"
       end
 
       describe "latest version installed, numbered version in tap" do
         include_examples ":latest cask", false, false, "1.2.3",
-                         ["latest"] => ["latest"]
+                         "latest" => "latest"
         include_examples ":latest cask", true, false, "1.2.3",
-                         ["latest"] => ["latest"]
+                         "latest" => "latest"
         include_examples ":latest cask", true, true, "1.2.3",
-                         ["latest"] => ["latest"]
+                         "latest" => "latest"
       end
     end
   end
@@ -212,37 +212,199 @@
     end
   end
 
+  describe "#artifacts_list" do
+    subject(:cask) { Cask::CaskLoader.load("many-artifacts") }
+
+    it "returns all artifacts when no options are given" do
+      expected_artifacts = [
+        { uninstall_preflight: nil },
+        { preflight: nil },
+        { uninstall: [{
+          rmdir: "#{TEST_TMPDIR}/empty_directory_path",
+          trash: ["#{TEST_TMPDIR}/foo", "#{TEST_TMPDIR}/bar"],
+        }] },
+        { pkg: ["ManyArtifacts/ManyArtifacts.pkg"] },
+        { app: ["ManyArtifacts/ManyArtifacts.app"] },
+        { uninstall_postflight: nil },
+        { postflight: nil },
+        { zap: [{
+          rmdir: ["~/Library/Caches/ManyArtifacts", "~/Library/Application Support/ManyArtifacts"],
+          trash: "~/Library/Logs/ManyArtifacts.log",
+        }] },
+      ]
+
+      expect(cask.artifacts_list).to eq(expected_artifacts)
+    end
+
+    it "skips flight blocks when compact is true" do
+      expected_artifacts = [
+        { uninstall: [{
+          rmdir: "#{TEST_TMPDIR}/empty_directory_path",
+          trash: ["#{TEST_TMPDIR}/foo", "#{TEST_TMPDIR}/bar"],
+        }] },
+        { pkg: ["ManyArtifacts/ManyArtifacts.pkg"] },
+        { app: ["ManyArtifacts/ManyArtifacts.app"] },
+        { zap: [{
+          rmdir: ["~/Library/Caches/ManyArtifacts", "~/Library/Application Support/ManyArtifacts"],
+          trash: "~/Library/Logs/ManyArtifacts.log",
+        }] },
+      ]
+
+      expect(cask.artifacts_list(compact: true)).to eq(expected_artifacts)
+    end
+
+    it "returns only uninstall artifacts when uninstall_only is true" do
+      expected_artifacts = [
+        { uninstall_preflight: nil },
+        { uninstall: [{
+          rmdir: "#{TEST_TMPDIR}/empty_directory_path",
+          trash: ["#{TEST_TMPDIR}/foo", "#{TEST_TMPDIR}/bar"],
+        }] },
+        { app: ["ManyArtifacts/ManyArtifacts.app"] },
+        { uninstall_postflight: nil },
+        { zap: [{
+          rmdir: ["~/Library/Caches/ManyArtifacts", "~/Library/Application Support/ManyArtifacts"],
+          trash: "~/Library/Logs/ManyArtifacts.log",
+        }] },
+      ]
+
+      expect(cask.artifacts_list(uninstall_only: true)).to eq(expected_artifacts)
+    end
+
+    it "skips flight blocks and returns only uninstall artifacts when compact and uninstall_only are true" do
+      expected_artifacts = [
+        { uninstall: [{
+          rmdir: "#{TEST_TMPDIR}/empty_directory_path",
+          trash: ["#{TEST_TMPDIR}/foo", "#{TEST_TMPDIR}/bar"],
+        }] },
+        { app: ["ManyArtifacts/ManyArtifacts.app"] },
+        { zap: [{
+          rmdir: ["~/Library/Caches/ManyArtifacts", "~/Library/Application Support/ManyArtifacts"],
+          trash: "~/Library/Logs/ManyArtifacts.log",
+        }] },
+      ]
+
+      expect(cask.artifacts_list(compact: true, uninstall_only: true)).to eq(expected_artifacts)
+    end
+  end
+
+  describe "#uninstall_flight_blocks?" do
+    matcher :have_uninstall_flight_blocks do
+      match do |actual|
+        actual.uninstall_flight_blocks? == true
+      end
+    end
+
+    it "returns true when there are uninstall_preflight blocks" do
+      cask = Cask::CaskLoader.load("with-uninstall-preflight")
+      expect(cask).to have_uninstall_flight_blocks
+    end
+
+    it "returns true when there are uninstall_postflight blocks" do
+      cask = Cask::CaskLoader.load("with-uninstall-postflight")
+      expect(cask).to have_uninstall_flight_blocks
+    end
+
+    it "returns false when there are only preflight blocks" do
+      cask = Cask::CaskLoader.load("with-preflight")
+      expect(cask).not_to have_uninstall_flight_blocks
+    end
+
+    it "returns false when there are only postflight blocks" do
+      cask = Cask::CaskLoader.load("with-postflight")
+      expect(cask).not_to have_uninstall_flight_blocks
+    end
+
+    it "returns false when there are no flight blocks" do
+      cask = Cask::CaskLoader.load("local-caffeine")
+      expect(cask).not_to have_uninstall_flight_blocks
+    end
+  end
+
+  describe "#to_h" do
+    let(:expected_json) { (TEST_FIXTURE_DIR/"cask/everything.json").read.strip }
+
+    context "when loaded from cask file" do
+      it "returns expected hash" do
+        allow(MacOS).to receive(:version).and_return(MacOSVersion.new("13"))
+
+        cask = Cask::CaskLoader.load("everything")
+
+        expect(cask.tap).to receive(:git_head).and_return("abcdef1234567890abcdef1234567890abcdef12")
+
+        hash = cask.to_h
+
+        expect(hash).to be_a(Hash)
+        expect(JSON.pretty_generate(hash)).to eq(expected_json)
+      end
+    end
+
+    context "when loaded from json file" do
+      it "returns expected hash" do
+        expect(Homebrew::API::Cask).not_to receive(:source_download)
+        hash = Cask::CaskLoader::FromAPILoader.new(
+          "everything", from_json: JSON.parse(expected_json)
+        ).load(config: nil).to_h
+
+        expect(hash).to be_a(Hash)
+        expect(JSON.pretty_generate(hash)).to eq(expected_json)
+      end
+    end
+  end
+
   describe "#to_hash_with_variations" do
     let!(:original_macos_version) { MacOS.full_version.to_s }
-    let(:expected_variations) {
+    let(:expected_versions_variations) do
       <<~JSON
         {
-          "arm64_big_sur": {
-            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine/1.2.0/arm.zip",
-            "version": "1.2.0",
-            "sha256": "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
-          },
           "monterey": {
-            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine/1.2.3/intel.zip"
+            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine/darwin/1.2.3/intel.zip"
           },
           "big_sur": {
-            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine/1.2.0/intel.zip",
+            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine/darwin/1.2.0/intel.zip",
+            "version": "1.2.0",
+            "sha256": "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+          },
+          "arm64_big_sur": {
+            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine/darwin-arm64/1.2.0/arm.zip",
             "version": "1.2.0",
             "sha256": "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
           },
           "catalina": {
-            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine/1.0.0/intel.zip",
+            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine/darwin/1.0.0/intel.zip",
             "version": "1.0.0",
             "sha256": "1866dfa833b123bb8fe7fa7185ebf24d28d300d0643d75798bc23730af734216"
           },
           "mojave": {
-            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine/1.0.0/intel.zip",
+            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine/darwin/1.0.0/intel.zip",
             "version": "1.0.0",
             "sha256": "1866dfa833b123bb8fe7fa7185ebf24d28d300d0643d75798bc23730af734216"
           }
         }
       JSON
-    }
+    end
+    let(:expected_sha256_variations) do
+      <<~JSON
+        {
+          "monterey": {
+            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine-intel.zip",
+            "sha256": "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+          },
+          "big_sur": {
+            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine-intel.zip",
+            "sha256": "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+          },
+          "catalina": {
+            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine-intel.zip",
+            "sha256": "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+          },
+          "mojave": {
+            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine-intel.zip",
+            "sha256": "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+          }
+        }
+      JSON
+    end
 
     before do
       # Use a more limited symbols list to shorten the variations hash
@@ -252,7 +414,7 @@
         catalina: "10.15",
         mojave:   "10.14",
       }
-      stub_const("MacOSVersions::SYMBOLS", symbols)
+      stub_const("MacOSVersion::SYMBOLS", symbols)
 
       # For consistency, always run on Monterey and ARM
       MacOS.full_version = "12"
@@ -263,12 +425,35 @@
       MacOS.full_version = original_macos_version
     end
 
-    it "returns the correct variations hash" do
+    it "returns the correct variations hash for a cask with multiple versions" do
       c = Cask::CaskLoader.load("multiple-versions")
       h = c.to_hash_with_variations
 
       expect(h).to be_a(Hash)
-      expect(JSON.pretty_generate(h["variations"])).to eq expected_variations.strip
+      expect(JSON.pretty_generate(h["variations"])).to eq expected_versions_variations.strip
+    end
+
+    it "returns the correct variations hash for a cask different sha256s on each arch" do
+      c = Cask::CaskLoader.load("sha256-arch")
+      h = c.to_hash_with_variations
+
+      expect(h).to be_a(Hash)
+      expect(JSON.pretty_generate(h["variations"])).to eq expected_sha256_variations.strip
+    end
+
+    # NOTE: The calls to `Cask.generating_hash!` and `Cask.generated_hash!`
+    #       are not idempotent so they can only be used in one test.
+    it "returns the correct hash placeholders" do
+      described_class.generating_hash!
+      expect(described_class).to be_generating_hash
+      c = Cask::CaskLoader.load("placeholders")
+      h = c.to_hash_with_variations
+      described_class.generated_hash!
+      expect(described_class).not_to be_generating_hash
+
+      expect(h).to be_a(Hash)
+      expect(h["artifacts"].first[:binary].first).to eq "$APPDIR/some/path"
+      expect(h["caveats"]).to eq "$HOMEBREW_PREFIX and /$HOME\n"
     end
   end
 end
diff --git a/Library/Homebrew/test/cask/cmd/audit_spec.rb b/Library/Homebrew/test/cask/cmd/audit_spec.rb
deleted file mode 100644
index fae56a4d53544..0000000000000
--- a/Library/Homebrew/test/cask/cmd/audit_spec.rb
+++ /dev/null
@@ -1,123 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "cask/auditor"
-
-describe Cask::Cmd::Audit, :cask do
-  let(:cask) { Cask::Cask.new("cask") }
-  let(:result) { { warnings: Set.new, errors: Set.new } }
-
-  describe "selection of Casks to audit" do
-    it "audits all Casks if no tokens are given" do
-      allow(Cask::Cask).to receive(:to_a).and_return([cask, cask])
-
-      expect(Cask::Auditor).to receive(:audit).twice.and_return(result)
-
-      described_class.run
-    end
-
-    it "audits specified Casks if tokens are given" do
-      cask_token = "nice-app"
-      expect(Cask::CaskLoader).to receive(:load).with(cask_token, any_args).and_return(cask)
-
-      expect(Cask::Auditor).to receive(:audit)
-        .with(cask, audit_new_cask: false, quarantine: true, any_named_args: true,
-              display_failures_only: false, display_passes: true)
-        .and_return(result)
-
-      described_class.run(cask_token)
-    end
-  end
-
-  it "does not pass anything if no flags are specified" do
-    allow(Cask::CaskLoader).to receive(:load).and_return(cask)
-    expect(Cask::Auditor).to receive(:audit)
-      .with(cask, audit_new_cask: false, quarantine: true, any_named_args: true,
-            display_failures_only: false, display_passes: true)
-      .and_return(result)
-
-    described_class.run("casktoken")
-  end
-
-  it "passes `audit_download` if the `--download` flag is specified" do
-    allow(Cask::CaskLoader).to receive(:load).and_return(cask)
-    expect(Cask::Auditor).to receive(:audit)
-      .with(cask, audit_download: true, audit_new_cask: false, quarantine: true, any_named_args: true,
-            display_failures_only: false, display_passes: true)
-      .and_return(result)
-
-    described_class.run("casktoken", "--download")
-  end
-
-  it "passes `audit_token_conflicts` if the `--token-conflicts` flag is specified" do
-    allow(Cask::CaskLoader).to receive(:load).and_return(cask)
-    expect(Cask::Auditor).to receive(:audit)
-      .with(cask, audit_token_conflicts: true, audit_new_cask: false, quarantine: true, any_named_args: true,
-            display_failures_only: false, display_passes: true)
-      .and_return(result)
-
-    described_class.run("casktoken", "--token-conflicts")
-  end
-
-  it "passes `audit_strict` if the `--strict` flag is specified" do
-    allow(Cask::CaskLoader).to receive(:load).and_return(cask)
-    expect(Cask::Auditor).to receive(:audit)
-      .with(cask, audit_strict: true, audit_new_cask: false, quarantine: true, any_named_args: true,
-            display_failures_only: false, display_passes: true)
-      .and_return(result)
-
-    described_class.run("casktoken", "--strict")
-  end
-
-  it "passes `audit_online` if the `--online` flag is specified" do
-    allow(Cask::CaskLoader).to receive(:load).and_return(cask)
-    expect(Cask::Auditor).to receive(:audit)
-      .with(cask, audit_online: true, audit_new_cask: false, quarantine: true, any_named_args: true,
-            display_failures_only: false, display_passes: true)
-      .and_return(result)
-
-    described_class.run("casktoken", "--online")
-  end
-
-  it "passes `audit_new_cask` if the `--new-cask` flag is specified" do
-    allow(Cask::CaskLoader).to receive(:load).and_return(cask)
-    expect(Cask::Auditor).to receive(:audit)
-      .with(cask, audit_new_cask: true, quarantine: true, any_named_args: true,
-            display_failures_only: false, display_passes: true)
-      .and_return(result)
-
-    described_class.run("casktoken", "--new-cask")
-  end
-
-  it "passes `language` if the `--language` flag is specified" do
-    allow(Cask::CaskLoader).to receive(:load).and_return(cask)
-    expect(Cask::Auditor).to receive(:audit)
-      .with(cask, audit_new_cask: false, quarantine: true, language: ["de-AT"], any_named_args: true,
-            display_failures_only: false, display_passes: true)
-      .and_return(result)
-
-    described_class.run("casktoken", "--language=de-AT")
-  end
-
-  it "passes `quarantine` if the `--no-quarantine` flag is specified" do
-    allow(Cask::CaskLoader).to receive(:load).and_return(cask)
-    expect(Cask::Auditor).to receive(:audit)
-      .with(cask, audit_new_cask: false, quarantine: false, any_named_args: true,
-            display_failures_only: false, display_passes: true)
-      .and_return(result)
-
-    described_class.run("casktoken", "--no-quarantine")
-  end
-
-  it "passes `quarantine` if the `--no-quarantine` flag is in HOMEBREW_CASK_OPTS" do
-    ENV["HOMEBREW_CASK_OPTS"] = "--no-quarantine"
-
-    allow(Cask::CaskLoader).to receive(:load).and_return(cask)
-    expect(Cask::Auditor).to receive(:audit)
-      .with(cask, audit_new_cask: false, quarantine: false, any_named_args: true,
-            display_failures_only: false, display_passes: true)
-      .and_return(result)
-
-    described_class.run("casktoken")
-  end
-end
diff --git a/Library/Homebrew/test/cask/cmd/fetch_spec.rb b/Library/Homebrew/test/cask/cmd/fetch_spec.rb
deleted file mode 100644
index 385951460677a..0000000000000
--- a/Library/Homebrew/test/cask/cmd/fetch_spec.rb
+++ /dev/null
@@ -1,60 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-describe Cask::Cmd::Fetch, :cask do
-  let(:local_transmission) {
-    Cask::CaskLoader.load(cask_path("local-transmission"))
-  }
-
-  let(:local_caffeine) {
-    Cask::CaskLoader.load(cask_path("local-caffeine"))
-  }
-
-  it "allows downloading the installer of a Cask" do
-    transmission_location = CurlDownloadStrategy.new(
-      local_transmission.url.to_s, local_transmission.token, local_transmission.version,
-      cache: Cask::Cache.path, **local_transmission.url.specs
-    ).cached_location
-    caffeine_location = CurlDownloadStrategy.new(
-      local_caffeine.url.to_s, local_caffeine.token, local_caffeine.version,
-      cache: Cask::Cache.path, **local_caffeine.url.specs
-    ).cached_location
-
-    expect(transmission_location).not_to exist
-    expect(caffeine_location).not_to exist
-
-    described_class.run("local-transmission", "local-caffeine")
-
-    expect(transmission_location).to exist
-    expect(caffeine_location).to exist
-  end
-
-  it "prevents double fetch (without nuking existing installation)" do
-    cached_location = Cask::Download.new(local_transmission).fetch
-
-    old_ctime = File.stat(cached_location).ctime
-
-    described_class.run("local-transmission", "--no-quarantine")
-    new_ctime = File.stat(cached_location).ctime
-
-    expect(old_ctime.to_i).to eq(new_ctime.to_i)
-  end
-
-  it "allows double fetch with --force" do
-    cached_location = Cask::Download.new(local_transmission).fetch
-
-    old_ctime = File.stat(cached_location).ctime
-    sleep(1)
-
-    described_class.run("local-transmission", "--force", "--no-quarantine")
-    new_ctime = File.stat(cached_location).ctime
-
-    expect(new_ctime.to_i).to be > old_ctime.to_i
-  end
-
-  it "properly handles Casks that are not present" do
-    expect {
-      described_class.run("notacask")
-    }.to raise_error(Cask::CaskUnavailableError)
-  end
-end
diff --git a/Library/Homebrew/test/cask/cmd/info_spec.rb b/Library/Homebrew/test/cask/cmd/info_spec.rb
deleted file mode 100644
index c127ff6752b56..0000000000000
--- a/Library/Homebrew/test/cask/cmd/info_spec.rb
+++ /dev/null
@@ -1,154 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "utils"
-
-describe Cask::Cmd::Info, :cask do
-  it "displays some nice info about the specified Cask" do
-    expect {
-      described_class.run("local-transmission")
-    }.to output(<<~EOS).to_stdout
-      local-transmission: 2.61
-      https://transmissionbt.com/
-      Not installed
-      From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/local-transmission.rb
-      ==> Name
-      Transmission
-      ==> Description
-      BitTorrent client
-      ==> Artifacts
-      Transmission.app (App)
-    EOS
-  end
-
-  it "prints auto_updates if the Cask has `auto_updates true`" do
-    expect {
-      described_class.run("with-auto-updates")
-    }.to output(<<~EOS).to_stdout
-      with-auto-updates: 1.0 (auto_updates)
-      https://brew.sh/autoupdates
-      Not installed
-      From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/with-auto-updates.rb
-      ==> Name
-      AutoUpdates
-      ==> Description
-      None
-      ==> Artifacts
-      AutoUpdates.app (App)
-    EOS
-  end
-
-  describe "given multiple Casks" do
-    let(:expected_output) {
-      <<~EOS
-        local-caffeine: 1.2.3
-        https://brew.sh/
-        Not installed
-        From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/local-caffeine.rb
-        ==> Name
-        None
-        ==> Description
-        None
-        ==> Artifacts
-        Caffeine.app (App)
-
-        local-transmission: 2.61
-        https://transmissionbt.com/
-        Not installed
-        From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/local-transmission.rb
-        ==> Name
-        Transmission
-        ==> Description
-        BitTorrent client
-        ==> Artifacts
-        Transmission.app (App)
-      EOS
-    }
-
-    it "displays the info" do
-      expect {
-        described_class.run("local-caffeine", "local-transmission")
-      }.to output(expected_output).to_stdout
-    end
-  end
-
-  it "prints caveats if the Cask provided one" do
-    expect {
-      described_class.run("with-caveats")
-    }.to output(<<~EOS).to_stdout
-      with-caveats: 1.2.3
-      https://brew.sh/
-      Not installed
-      From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/with-caveats.rb
-      ==> Name
-      None
-      ==> Description
-      None
-      ==> Artifacts
-      Caffeine.app (App)
-      ==> Caveats
-      Here are some things you might want to know.
-
-      Cask token: with-caveats
-
-      Custom text via puts followed by DSL-generated text:
-      To use with-caveats, you may need to add the /custom/path/bin directory
-      to your PATH environment variable, e.g. (for Bash shell):
-        export PATH=/custom/path/bin:"$PATH"
-
-    EOS
-  end
-
-  it 'does not print "Caveats" section divider if the caveats block has no output' do
-    expect {
-      described_class.run("with-conditional-caveats")
-    }.to output(<<~EOS).to_stdout
-      with-conditional-caveats: 1.2.3
-      https://brew.sh/
-      Not installed
-      From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/with-conditional-caveats.rb
-      ==> Name
-      None
-      ==> Description
-      None
-      ==> Artifacts
-      Caffeine.app (App)
-    EOS
-  end
-
-  it "prints languages specified in the Cask" do
-    expect {
-      described_class.run("with-languages")
-    }.to output(<<~EOS).to_stdout
-      with-languages: 1.2.3
-      https://brew.sh/
-      Not installed
-      From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/with-languages.rb
-      ==> Name
-      None
-      ==> Description
-      None
-      ==> Languages
-      zh, en-US
-      ==> Artifacts
-      Caffeine.app (App)
-    EOS
-  end
-
-  it 'does not print "Languages" section divider if the languages block has no output' do
-    expect {
-      described_class.run("without-languages")
-    }.to output(<<~EOS).to_stdout
-      without-languages: 1.2.3
-      https://brew.sh/
-      Not installed
-      From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/without-languages.rb
-      ==> Name
-      None
-      ==> Description
-      None
-      ==> Artifacts
-      Caffeine.app (App)
-    EOS
-  end
-end
diff --git a/Library/Homebrew/test/cask/cmd/install_spec.rb b/Library/Homebrew/test/cask/cmd/install_spec.rb
deleted file mode 100644
index 2d9a866dbea33..0000000000000
--- a/Library/Homebrew/test/cask/cmd/install_spec.rb
+++ /dev/null
@@ -1,128 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-describe Cask::Cmd::Install, :cask do
-  it "displays the installation progress" do
-    output = Regexp.new <<~EOS
-      ==> Downloading file:.*caffeine.zip
-      ==> Installing Cask local-caffeine
-      ==> Moving App 'Caffeine.app' to '.*Caffeine.app'
-      .*local-caffeine was successfully installed!
-    EOS
-
-    expect {
-      described_class.run("local-caffeine")
-    }.to output(output).to_stdout
-  end
-
-  it "allows staging and activation of multiple Casks at once" do
-    described_class.run("local-transmission", "local-caffeine")
-    transmission = Cask::CaskLoader.load(cask_path("local-transmission"))
-    caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
-    expect(transmission).to be_installed
-    expect(transmission.config.appdir.join("Transmission.app")).to be_a_directory
-    expect(caffeine).to be_installed
-    expect(caffeine.config.appdir.join("Caffeine.app")).to be_a_directory
-  end
-
-  it "recognizes the --appdir flag" do
-    appdir = mktmpdir
-
-    expect(Cask::CaskLoader).to receive(:load).with("local-caffeine", any_args)
-      .and_wrap_original { |f, *args|
-        caffeine = f.call(*args)
-        expect(caffeine.config.appdir).to eq appdir
-        caffeine
-      }
-
-    described_class.run("local-caffeine", "--appdir=#{appdir}")
-  end
-
-  it "recognizes the --appdir flag from HOMEBREW_CASK_OPTS" do
-    appdir = mktmpdir
-
-    expect(Cask::CaskLoader).to receive(:load).with("local-caffeine", any_args)
-      .and_wrap_original { |f, *args|
-        caffeine = f.call(*args)
-        expect(caffeine.config.appdir).to eq appdir
-        caffeine
-      }
-
-    ENV["HOMEBREW_CASK_OPTS"] = "--appdir=#{appdir}"
-
-    described_class.run("local-caffeine")
-  end
-
-  it "prefers an explicit --appdir flag to one from HOMEBREW_CASK_OPTS" do
-    global_appdir = mktmpdir
-    appdir = mktmpdir
-
-    expect(Cask::CaskLoader).to receive(:load).with("local-caffeine", any_args)
-      .and_wrap_original { |f, *args|
-        caffeine = f.call(*args)
-        expect(caffeine.config.appdir).to eq appdir
-        caffeine
-      }
-
-    ENV["HOMEBREW_CASK_OPTS"] = "--appdir=#{global_appdir}"
-
-    described_class.run("local-caffeine", "--appdir=#{appdir}")
-  end
-
-  it "skips double install (without nuking existing installation)" do
-    described_class.run("local-transmission")
-    described_class.run("local-transmission")
-    expect(Cask::CaskLoader.load(cask_path("local-transmission"))).to be_installed
-  end
-
-  it "prints a warning message on double install" do
-    described_class.run("local-transmission")
-
-    expect {
-      described_class.run("local-transmission")
-    }.to output(/Warning: Cask 'local-transmission' is already installed./).to_stderr
-  end
-
-  it "allows double install with --force" do
-    described_class.run("local-transmission")
-
-    expect {
-      expect {
-        described_class.run("local-transmission", "--force")
-      }.to output(/It seems there is already an App at.*overwriting\./).to_stderr
-    }.to output(/local-transmission was successfully installed!/).to_stdout
-  end
-
-  it "skips dependencies with --skip-cask-deps" do
-    described_class.run("with-depends-on-cask-multiple", "--skip-cask-deps")
-    expect(Cask::CaskLoader.load(cask_path("with-depends-on-cask-multiple"))).to be_installed
-    expect(Cask::CaskLoader.load(cask_path("local-caffeine"))).not_to be_installed
-    expect(Cask::CaskLoader.load(cask_path("local-transmission"))).not_to be_installed
-  end
-
-  it "properly handles Casks that are not present" do
-    expect {
-      described_class.run("notacask")
-    }.to raise_error(Cask::CaskUnavailableError)
-  end
-
-  it "returns a suggestion for a misspelled Cask" do
-    expect {
-      described_class.run("localcaffeine")
-    }.to raise_error(
-      Cask::CaskUnavailableError,
-      "Cask 'localcaffeine' is unavailable: No Cask with this name exists. " \
-      "Did you mean 'local-caffeine'?",
-    )
-  end
-
-  it "returns multiple suggestions for a Cask fragment" do
-    expect {
-      described_class.run("local")
-    }.to raise_error(
-      Cask::CaskUnavailableError,
-      "Cask 'local' is unavailable: No Cask with this name exists. " \
-      "Did you mean one of these?\nlocal-caffeine\nlocal-transmission\n",
-    )
-  end
-end
diff --git a/Library/Homebrew/test/cask/cmd/list_spec.rb b/Library/Homebrew/test/cask/cmd/list_spec.rb
deleted file mode 100644
index 86704bc041e48..0000000000000
--- a/Library/Homebrew/test/cask/cmd/list_spec.rb
+++ /dev/null
@@ -1,277 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-describe Cask::Cmd::List, :cask do
-  it "lists the installed Casks in a pretty fashion" do
-    casks = %w[local-caffeine local-transmission].map { |c| Cask::CaskLoader.load(c) }
-
-    casks.each do |c|
-      InstallHelper.install_with_caskfile(c)
-    end
-
-    expect {
-      described_class.run
-    }.to output(<<~EOS).to_stdout
-      local-caffeine
-      local-transmission
-    EOS
-  end
-
-  it "lists oneline" do
-    casks = %w[
-      local-caffeine
-      third-party/tap/third-party-cask
-      local-transmission
-    ].map { |c| Cask::CaskLoader.load(c) }
-
-    casks.each do |c|
-      InstallHelper.install_with_caskfile(c)
-    end
-
-    expect {
-      described_class.run("-1")
-    }.to output(<<~EOS).to_stdout
-      local-caffeine
-      local-transmission
-      third-party-cask
-    EOS
-  end
-
-  it "lists full names" do
-    casks = %w[
-      local-caffeine
-      third-party/tap/third-party-cask
-      local-transmission
-    ].map { |c| Cask::CaskLoader.load(c) }
-
-    casks.each do |c|
-      InstallHelper.install_with_caskfile(c)
-    end
-
-    expect {
-      described_class.run("--full-name")
-    }.to output(<<~EOS).to_stdout
-      local-caffeine
-      local-transmission
-      third-party/tap/third-party-cask
-    EOS
-  end
-
-  describe "lists versions" do
-    let(:casks) { ["local-caffeine", "local-transmission"] }
-    let(:expected_output) {
-      <<~EOS
-        local-caffeine 1.2.3
-        local-transmission 2.61
-      EOS
-    }
-
-    before do
-      casks.map(&Cask::CaskLoader.method(:load)).each(&InstallHelper.method(:install_with_caskfile))
-    end
-
-    it "of all installed Casks" do
-      expect {
-        described_class.run("--versions")
-      }.to output(expected_output).to_stdout
-    end
-
-    it "of given Casks" do
-      expect {
-        described_class.run("--versions", "local-caffeine", "local-transmission")
-      }.to output(expected_output).to_stdout
-    end
-  end
-
-  describe "lists json" do
-    let(:casks) { ["local-caffeine", "local-transmission", "multiple-versions", "third-party/tap/third-party-cask"] }
-    let(:expected_output) {
-      <<~EOS
-        [
-          {
-            "token": "local-caffeine",
-            "full_token": "local-caffeine",
-            "tap": "homebrew/cask",
-            "name": [
-
-            ],
-            "desc": null,
-            "homepage": "https://brew.sh/",
-            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip",
-            "appcast": null,
-            "version": "1.2.3",
-            "versions": {
-            },
-            "installed": "1.2.3",
-            "outdated": false,
-            "sha256": "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94",
-            "artifacts": [
-              [
-                "Caffeine.app"
-              ],
-              {
-                "trash": "$HOME/support/fixtures/cask/caffeine/org.example.caffeine.plist",
-                "signal": {
-                }
-              }
-            ],
-            "caveats": null,
-            "depends_on": {
-            },
-            "conflicts_with": null,
-            "container": null,
-            "auto_updates": null
-          },
-          {
-            "token": "local-transmission",
-            "full_token": "local-transmission",
-            "tap": "homebrew/cask",
-            "name": [
-              "Transmission"
-            ],
-            "desc": "BitTorrent client",
-            "homepage": "https://transmissionbt.com/",
-            "url": "file://#{TEST_FIXTURE_DIR}/cask/transmission-2.61.dmg",
-            "appcast": null,
-            "version": "2.61",
-            "versions": {
-            },
-            "installed": "2.61",
-            "outdated": false,
-            "sha256": "e44ffa103fbf83f55c8d0b1bea309a43b2880798dae8620b1ee8da5e1095ec68",
-            "artifacts": [
-              [
-                "Transmission.app"
-              ]
-            ],
-            "caveats": null,
-            "depends_on": {
-            },
-            "conflicts_with": null,
-            "container": null,
-            "auto_updates": null
-          },
-          {
-            "token": "multiple-versions",
-            "full_token": "multiple-versions",
-            "tap": "homebrew/cask",
-            "name": [
-
-            ],
-            "desc": null,
-            "homepage": "https://brew.sh/",
-            "url": "file://#{TEST_FIXTURE_DIR}/cask/caffeine/1.2.3/arm.zip",
-            "appcast": null,
-            "version": "1.2.3",
-            "versions": {
-              "big_sur": "1.2.0",
-              "catalina": "1.0.0",
-              "mojave": "1.0.0"
-            },
-            "installed": "1.2.3",
-            "outdated": false,
-            "sha256": "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94",
-            "artifacts": [
-              [
-                "Caffeine.app"
-              ]
-            ],
-            "caveats": null,
-            "depends_on": {
-            },
-            "conflicts_with": null,
-            "container": null,
-            "auto_updates": null
-          },
-          {
-            "token": "third-party-cask",
-            "full_token": "third-party/tap/third-party-cask",
-            "tap": "third-party/tap",
-            "name": [
-
-            ],
-            "desc": null,
-            "homepage": "https://brew.sh/",
-            "url": "https://brew.sh/ThirdParty.dmg",
-            "appcast": null,
-            "version": "1.2.3",
-            "versions": {
-            },
-            "installed": "1.2.3",
-            "outdated": false,
-            "sha256": "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b",
-            "artifacts": [
-              [
-                "ThirdParty.app"
-              ]
-            ],
-            "caveats": null,
-            "depends_on": {
-            },
-            "conflicts_with": null,
-            "container": null,
-            "auto_updates": null
-          }
-        ]
-      EOS
-    }
-    let!(:original_macos_version) { MacOS.full_version.to_s }
-
-    before do
-      # Use a more limited symbols list to shorten the variations hash
-      symbols = {
-        monterey: "12",
-        big_sur:  "11",
-        catalina: "10.15",
-        mojave:   "10.14",
-      }
-      stub_const("MacOSVersions::SYMBOLS", symbols)
-
-      # For consistency, always run on Monterey and ARM
-      MacOS.full_version = "12"
-      allow(Hardware::CPU).to receive(:type).and_return(:arm)
-
-      casks.map(&Cask::CaskLoader.method(:load)).each(&InstallHelper.method(:install_with_caskfile))
-    end
-
-    after do
-      MacOS.full_version = original_macos_version
-    end
-
-    it "of all installed Casks" do
-      expect {
-        described_class.run("--json")
-      }.to output(expected_output).to_stdout
-    end
-
-    it "of given Casks" do
-      expect {
-        described_class.run("--json", "local-caffeine", "local-transmission", "multiple-versions",
-                            "third-party/tap/third-party-cask")
-      }.to output(expected_output).to_stdout
-    end
-  end
-
-  describe "given a set of installed Casks" do
-    let(:caffeine) { Cask::CaskLoader.load(cask_path("local-caffeine")) }
-    let(:transmission) { Cask::CaskLoader.load(cask_path("local-transmission")) }
-    let(:casks) { [caffeine, transmission] }
-
-    it "lists the installed files for those Casks" do
-      casks.each(&InstallHelper.method(:install_without_artifacts_with_caskfile))
-
-      transmission.artifacts.select { |a| a.is_a?(Cask::Artifact::App) }.each do |artifact|
-        artifact.install_phase(command: NeverSudoSystemCommand, force: false)
-      end
-
-      expect {
-        described_class.run("local-transmission", "local-caffeine")
-      }.to output(<<~EOS).to_stdout
-        ==> App
-        #{transmission.config.appdir.join("Transmission.app")} (#{transmission.config.appdir.join("Transmission.app").abv})
-        ==> App
-        Missing App: #{caffeine.config.appdir.join("Caffeine.app")}
-      EOS
-    end
-  end
-end
diff --git a/Library/Homebrew/test/cask/cmd/reinstall_spec.rb b/Library/Homebrew/test/cask/cmd/reinstall_spec.rb
deleted file mode 100644
index 723d767b17f0a..0000000000000
--- a/Library/Homebrew/test/cask/cmd/reinstall_spec.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-describe Cask::Cmd::Reinstall, :cask do
-  it "displays the reinstallation progress" do
-    caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
-
-    Cask::Installer.new(caffeine).install
-
-    output = Regexp.new <<~EOS
-      ==> Downloading file:.*caffeine.zip
-      Already downloaded: .*--caffeine.zip
-      ==> Uninstalling Cask local-caffeine
-      ==> Backing App 'Caffeine.app' up to '.*Caffeine.app'
-      ==> Removing App '.*Caffeine.app'
-      ==> Purging files for version 1.2.3 of Cask local-caffeine
-      ==> Installing Cask local-caffeine
-      ==> Moving App 'Caffeine.app' to '.*Caffeine.app'
-      .*local-caffeine was successfully installed!
-    EOS
-
-    expect {
-      described_class.run("local-caffeine")
-    }.to output(output).to_stdout
-  end
-
-  it "displays the reinstallation progress with zapping" do
-    caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
-
-    Cask::Installer.new(caffeine).install
-
-    output = Regexp.new <<~EOS
-      ==> Downloading file:.*caffeine.zip
-      Already downloaded: .*--caffeine.zip
-      ==> Implied `brew uninstall --cask local-caffeine`
-      ==> Backing App 'Caffeine.app' up to '.*Caffeine.app'
-      ==> Removing App '.*Caffeine.app'
-      ==> Dispatching zap stanza
-      ==> Trashing files:
-      .*org\.example\.caffeine\.plist
-      ==> Removing all staged versions of Cask 'local-caffeine'
-      ==> Installing Cask local-caffeine
-      ==> Moving App 'Caffeine.app' to '.*Caffeine.app'
-      .*local-caffeine was successfully installed!
-    EOS
-
-    expect {
-      described_class.run("local-caffeine", "--zap")
-    }.to output(output).to_stdout
-  end
-
-  it "allows reinstalling a Cask" do
-    Cask::Cmd::Install.run("local-transmission")
-
-    expect(Cask::CaskLoader.load(cask_path("local-transmission"))).to be_installed
-
-    described_class.run("local-transmission")
-    expect(Cask::CaskLoader.load(cask_path("local-transmission"))).to be_installed
-  end
-
-  it "allows reinstalling a non installed Cask" do
-    expect(Cask::CaskLoader.load(cask_path("local-transmission"))).not_to be_installed
-
-    described_class.run("local-transmission")
-    expect(Cask::CaskLoader.load(cask_path("local-transmission"))).to be_installed
-  end
-end
diff --git a/Library/Homebrew/test/cask/cmd/uninstall_spec.rb b/Library/Homebrew/test/cask/cmd/uninstall_spec.rb
deleted file mode 100644
index 527675b6fa6a6..0000000000000
--- a/Library/Homebrew/test/cask/cmd/uninstall_spec.rb
+++ /dev/null
@@ -1,157 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-describe Cask::Cmd::Uninstall, :cask do
-  it "displays the uninstallation progress" do
-    caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
-
-    Cask::Installer.new(caffeine).install
-
-    output = Regexp.new <<~EOS
-      ==> Uninstalling Cask local-caffeine
-      ==> Backing App 'Caffeine.app' up to '.*Caffeine.app'
-      ==> Removing App '.*Caffeine.app'
-      ==> Purging files for version 1.2.3 of Cask local-caffeine
-    EOS
-
-    expect {
-      described_class.run("local-caffeine")
-    }.to output(output).to_stdout
-  end
-
-  it "shows an error when a bad Cask is provided" do
-    expect { described_class.run("notacask") }
-      .to raise_error(Cask::CaskUnavailableError, /is unavailable/)
-  end
-
-  it "shows an error when a Cask is provided that's not installed" do
-    expect { described_class.run("local-caffeine") }
-    .to raise_error(Cask::CaskNotInstalledError, /is not installed/)
-  end
-
-  it "tries anyway on a non-present Cask when --force is given" do
-    expect {
-      described_class.run("local-caffeine", "--force")
-    }.not_to raise_error
-  end
-
-  it "can uninstall and unlink multiple Casks at once" do
-    caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
-    transmission = Cask::CaskLoader.load(cask_path("local-transmission"))
-
-    Cask::Installer.new(caffeine).install
-    Cask::Installer.new(transmission).install
-
-    expect(caffeine).to be_installed
-    expect(transmission).to be_installed
-
-    described_class.run("local-caffeine", "local-transmission")
-
-    expect(caffeine).not_to be_installed
-    expect(caffeine.config.appdir.join("Transmission.app")).not_to exist
-    expect(transmission).not_to be_installed
-    expect(transmission.config.appdir.join("Caffeine.app")).not_to exist
-  end
-
-  it "can uninstall Casks when the uninstall script is missing, but only when using `--force`" do
-    cask = Cask::CaskLoader.load(cask_path("with-uninstall-script-app"))
-
-    Cask::Installer.new(cask).install
-
-    expect(cask).to be_installed
-
-    cask.config.appdir.join("MyFancyApp.app").rmtree
-
-    expect { described_class.run("with-uninstall-script-app") }
-    .to raise_error(Cask::CaskError, /uninstall script .* does not exist/)
-
-    expect(cask).to be_installed
-
-    expect {
-      described_class.run("with-uninstall-script-app", "--force")
-    }.not_to raise_error
-
-    expect(cask).not_to be_installed
-  end
-
-  describe "when multiple versions of a cask are installed" do
-    let(:token) { "versioned-cask" }
-    let(:first_installed_version) { "1.2.3" }
-    let(:last_installed_version) { "4.5.6" }
-    let(:timestamped_versions) {
-      [
-        [first_installed_version, "123000"],
-        [last_installed_version,  "456000"],
-      ]
-    }
-    let(:caskroom_path) { Cask::Caskroom.path.join(token).tap(&:mkpath) }
-
-    before do
-      timestamped_versions.each do |timestamped_version|
-        caskroom_path.join(".metadata", *timestamped_version, "Casks").tap(&:mkpath)
-                     .join("#{token}.rb").open("w") do |caskfile|
-                       caskfile.puts <<~RUBY
-                         cask '#{token}' do
-                           version '#{timestamped_version[0]}'
-                         end
-                       RUBY
-                     end
-        caskroom_path.join(timestamped_version[0]).mkpath
-      end
-    end
-
-    it "uninstalls one version at a time" do
-      described_class.run("versioned-cask")
-
-      expect(caskroom_path.join(first_installed_version)).to exist
-      expect(caskroom_path.join(last_installed_version)).not_to exist
-      expect(caskroom_path).to exist
-
-      described_class.run("versioned-cask")
-
-      expect(caskroom_path.join(first_installed_version)).not_to exist
-      expect(caskroom_path).not_to exist
-    end
-
-    it "displays a message when versions remain installed" do
-      expect {
-        expect {
-          described_class.run("versioned-cask")
-        }.not_to output.to_stderr
-      }.to output(/#{token} #{first_installed_version} is still installed./).to_stdout
-    end
-  end
-
-  context "when Casks in Taps have been renamed or removed" do
-    let(:app) { Cask::Config.new.appdir.join("ive-been-renamed.app") }
-    let(:caskroom_path) { Cask::Caskroom.path.join("ive-been-renamed").tap(&:mkpath) }
-    let(:saved_caskfile) {
-      caskroom_path.join(".metadata", "latest", "timestamp", "Casks").join("ive-been-renamed.rb")
-    }
-
-    before do
-      app.tap(&:mkpath)
-         .join("Contents").tap(&:mkpath)
-         .join("Info.plist").tap(&FileUtils.method(:touch))
-
-      caskroom_path.mkpath
-
-      saved_caskfile.dirname.mkpath
-
-      File.write saved_caskfile, <<~RUBY
-        cask 'ive-been-renamed' do
-          version :latest
-
-          app 'ive-been-renamed.app'
-        end
-      RUBY
-    end
-
-    it "can still uninstall them" do
-      described_class.run("ive-been-renamed")
-
-      expect(app).not_to exist
-      expect(caskroom_path).not_to exist
-    end
-  end
-end
diff --git a/Library/Homebrew/test/cask/cmd/upgrade_spec.rb b/Library/Homebrew/test/cask/cmd/upgrade_spec.rb
deleted file mode 100644
index ec4e0fac2df8f..0000000000000
--- a/Library/Homebrew/test/cask/cmd/upgrade_spec.rb
+++ /dev/null
@@ -1,457 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-describe Cask::Cmd::Upgrade, :cask do
-  let(:version_latest_path_2) { version_latest.config.appdir.join("Caffeine Pro.app") }
-  let(:version_latest_path_1) { version_latest.config.appdir.join("Caffeine Mini.app") }
-  let(:version_latest) { Cask::CaskLoader.load("version-latest") }
-  let(:auto_updates_path) { auto_updates.config.appdir.join("MyFancyApp.app") }
-  let(:auto_updates) { Cask::CaskLoader.load("auto-updates") }
-  let(:local_transmission_path) { local_transmission.config.appdir.join("Transmission.app") }
-  let(:local_transmission) { Cask::CaskLoader.load("local-transmission") }
-  let(:local_caffeine_path) { local_caffeine.config.appdir.join("Caffeine.app") }
-  let(:local_caffeine) { Cask::CaskLoader.load("local-caffeine") }
-
-  context "when the upgrade is successful" do
-    let(:installed) {
-      [
-        "outdated/local-caffeine",
-        "outdated/local-transmission",
-        "outdated/auto-updates",
-        "outdated/version-latest",
-      ]
-    }
-
-    before do
-      installed.each { |cask| Cask::Cmd::Install.run(cask) }
-
-      allow_any_instance_of(described_class).to receive(:verbose?).and_return(true)
-    end
-
-    describe 'without --greedy it ignores the Casks with "version latest" or "auto_updates true"' do
-      it "updates all the installed Casks when no token is provided" do
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.2")
-
-        expect(local_transmission).to be_installed
-        expect(local_transmission_path).to be_a_directory
-        expect(local_transmission.versions).to include("2.60")
-
-        described_class.run
-
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.3")
-
-        expect(local_transmission).to be_installed
-        expect(local_transmission_path).to be_a_directory
-        expect(local_transmission.versions).to include("2.61")
-      end
-
-      it "updates only the Casks specified in the command line" do
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.2")
-
-        expect(local_transmission).to be_installed
-        expect(local_transmission_path).to be_a_directory
-        expect(local_transmission.versions).to include("2.60")
-
-        described_class.run("local-caffeine")
-
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.3")
-
-        expect(local_transmission).to be_installed
-        expect(local_transmission_path).to be_a_directory
-        expect(local_transmission.versions).to include("2.60")
-      end
-
-      it 'updates "auto_updates" and "latest" Casks when their tokens are provided in the command line' do
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.2")
-
-        expect(auto_updates).to be_installed
-        expect(auto_updates_path).to be_a_directory
-        expect(auto_updates.versions).to include("2.57")
-
-        described_class.run("local-caffeine", "auto-updates")
-
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.3")
-
-        expect(auto_updates).to be_installed
-        expect(auto_updates_path).to be_a_directory
-        expect(auto_updates.versions).to include("2.61")
-      end
-    end
-
-    describe "with --greedy it checks additional Casks" do
-      it 'includes the Casks with "auto_updates true" or "version latest"' do
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.2")
-
-        expect(auto_updates).to be_installed
-        expect(auto_updates_path).to be_a_directory
-        expect(auto_updates.versions).to include("2.57")
-
-        expect(local_transmission).to be_installed
-        expect(local_transmission_path).to be_a_directory
-        expect(local_transmission.versions).to include("2.60")
-
-        expect(version_latest).to be_installed
-        expect(version_latest_path_1).to be_a_directory
-        expect(version_latest.versions).to include("latest")
-        # Change download sha so that :latest cask decides to update itself
-        version_latest.download_sha_path.write("fake download sha")
-        expect(version_latest.outdated_download_sha?).to be(true)
-
-        described_class.run("--greedy")
-
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.3")
-
-        expect(auto_updates).to be_installed
-        expect(auto_updates_path).to be_a_directory
-        expect(auto_updates.versions).to include("2.61")
-
-        expect(local_transmission).to be_installed
-        expect(local_transmission_path).to be_a_directory
-        expect(local_transmission.versions).to include("2.61")
-
-        expect(version_latest).to be_installed
-        expect(version_latest_path_2).to be_a_directory
-        expect(version_latest.versions).to include("latest")
-        expect(version_latest.outdated_download_sha?).to be(false)
-      end
-
-      it 'does not include the Casks with "auto_updates true" or "version latest" when the version did not change' do
-        expect(auto_updates).to be_installed
-        expect(auto_updates_path).to be_a_directory
-        expect(auto_updates.versions).to include("2.57")
-
-        described_class.run("auto-updates", "--greedy")
-
-        expect(auto_updates).to be_installed
-        expect(auto_updates_path).to be_a_directory
-        expect(auto_updates.versions).to include("2.61")
-
-        described_class.run("auto-updates", "--greedy")
-
-        expect(auto_updates).to be_installed
-        expect(auto_updates_path).to be_a_directory
-        expect(auto_updates.versions).to include("2.61")
-      end
-
-      it 'does not include the Casks with "version latest" when the version did not change' do
-        expect(version_latest).to be_installed
-        expect(version_latest_path_1).to be_a_directory
-        expect(version_latest_path_2).to be_a_directory
-        expect(version_latest.versions).to include("latest")
-        # Change download sha so that :latest cask decides to update itself
-        version_latest.download_sha_path.write("fake download sha")
-        expect(version_latest.outdated_download_sha?).to be(true)
-
-        described_class.run("version-latest", "--greedy")
-
-        expect(version_latest).to be_installed
-        expect(version_latest_path_1).to be_a_directory
-        expect(version_latest_path_2).to be_a_directory
-        expect(version_latest.versions).to include("latest")
-        expect(version_latest.outdated_download_sha?).to be(false)
-
-        described_class.run("version-latest", "--greedy")
-
-        expect(version_latest).to be_installed
-        expect(version_latest_path_1).to be_a_directory
-        expect(version_latest_path_2).to be_a_directory
-        expect(version_latest.versions).to include("latest")
-        expect(version_latest.outdated_download_sha?).to be(false)
-      end
-    end
-  end
-
-  context "when the upgrade is a dry run" do
-    let(:installed) {
-      [
-        "outdated/local-caffeine",
-        "outdated/local-transmission",
-        "outdated/auto-updates",
-        "outdated/version-latest",
-      ]
-    }
-
-    before do
-      installed.each { |cask| Cask::Cmd::Install.run(cask) }
-
-      allow_any_instance_of(described_class).to receive(:verbose?).and_return(true)
-    end
-
-    describe 'without --greedy it ignores the Casks with "version latest" or "auto_updates true"' do
-      it "would update all the installed Casks when no token is provided" do
-        expect(described_class).not_to receive(:upgrade_cask)
-
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.2")
-
-        expect(local_transmission).to be_installed
-        expect(local_transmission_path).to be_a_directory
-        expect(local_transmission.versions).to include("2.60")
-
-        described_class.run("--dry-run")
-
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.2")
-        expect(local_caffeine.versions).not_to include("1.2.3")
-
-        expect(local_transmission).to be_installed
-        expect(local_transmission_path).to be_a_directory
-        expect(local_transmission.versions).to include("2.60")
-        expect(local_transmission.versions).not_to include("2.61")
-      end
-
-      it "would update only the Casks specified in the command line" do
-        expect(described_class).not_to receive(:upgrade_cask)
-
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.2")
-
-        expect(local_transmission).to be_installed
-        expect(local_transmission_path).to be_a_directory
-        expect(local_transmission.versions).to include("2.60")
-
-        described_class.run("--dry-run", "local-caffeine")
-
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.2")
-        expect(local_caffeine.versions).not_to include("1.2.3")
-
-        expect(local_transmission).to be_installed
-        expect(local_transmission_path).to be_a_directory
-        expect(local_transmission.versions).to include("2.60")
-        expect(local_transmission.versions).not_to include("2.61")
-      end
-
-      it 'would update "auto_updates" and "latest" Casks when their tokens are provided in the command line' do
-        expect(described_class).not_to receive(:upgrade_cask)
-
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.2")
-
-        expect(auto_updates).to be_installed
-        expect(auto_updates_path).to be_a_directory
-        expect(auto_updates.versions).to include("2.57")
-
-        described_class.run("--dry-run", "local-caffeine", "auto-updates")
-
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.2")
-        expect(local_caffeine.versions).not_to include("1.2.3")
-
-        expect(auto_updates).to be_installed
-        expect(auto_updates_path).to be_a_directory
-        expect(auto_updates.versions).to include("2.57")
-        expect(auto_updates.versions).not_to include("2.61")
-      end
-    end
-
-    describe "with --greedy it checks additional Casks" do
-      it 'would include the Casks with "auto_updates true" or "version latest"' do
-        expect(described_class).not_to receive(:upgrade_cask)
-
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.2")
-
-        expect(auto_updates).to be_installed
-        expect(auto_updates_path).to be_a_directory
-        expect(auto_updates.versions).to include("2.57")
-
-        expect(local_transmission).to be_installed
-        expect(local_transmission_path).to be_a_directory
-        expect(local_transmission.versions).to include("2.60")
-
-        expect(version_latest).to be_installed
-        # Change download sha so that :latest cask decides to update itself
-        version_latest.download_sha_path.write("fake download sha")
-        expect(version_latest.outdated_download_sha?).to be(true)
-
-        described_class.run("--greedy", "--dry-run")
-
-        expect(local_caffeine).to be_installed
-        expect(local_caffeine_path).to be_a_directory
-        expect(local_caffeine.versions).to include("1.2.2")
-        expect(local_caffeine.versions).not_to include("1.2.3")
-
-        expect(auto_updates).to be_installed
-        expect(auto_updates_path).to be_a_directory
-        expect(auto_updates.versions).to include("2.57")
-        expect(auto_updates.versions).not_to include("2.61")
-
-        expect(local_transmission).to be_installed
-        expect(local_transmission_path).to be_a_directory
-        expect(local_transmission.versions).to include("2.60")
-        expect(local_transmission.versions).not_to include("2.61")
-
-        expect(version_latest).to be_installed
-        expect(version_latest.outdated_download_sha?).to be(true)
-      end
-
-      it 'would update outdated Casks with "auto_updates true"' do
-        expect(described_class).not_to receive(:upgrade_cask)
-
-        expect(auto_updates).to be_installed
-        expect(auto_updates_path).to be_a_directory
-        expect(auto_updates.versions).to include("2.57")
-
-        described_class.run("--dry-run", "auto-updates", "--greedy")
-
-        expect(auto_updates).to be_installed
-        expect(auto_updates_path).to be_a_directory
-        expect(auto_updates.versions).to include("2.57")
-        expect(auto_updates.versions).not_to include("2.61")
-      end
-
-      it 'would update outdated Casks with "version latest"' do
-        expect(described_class).not_to receive(:upgrade_cask)
-
-        expect(version_latest).to be_installed
-        expect(version_latest_path_1).to be_a_directory
-        expect(version_latest_path_2).to be_a_directory
-        expect(version_latest.versions).to include("latest")
-        # Change download sha so that :latest cask decides to update itself
-        version_latest.download_sha_path.write("fake download sha")
-        expect(version_latest.outdated_download_sha?).to be(true)
-
-        described_class.run("--dry-run", "version-latest", "--greedy")
-
-        expect(version_latest).to be_installed
-        expect(version_latest_path_1).to be_a_directory
-        expect(version_latest_path_2).to be_a_directory
-        expect(version_latest.versions).to include("latest")
-        expect(version_latest.outdated_download_sha?).to be(true)
-      end
-    end
-  end
-
-  context "when an upgrade failed" do
-    let(:installed) {
-      [
-        "outdated/bad-checksum",
-        "outdated/will-fail-if-upgraded",
-      ]
-    }
-
-    before do
-      installed.each { |cask| Cask::Cmd::Install.run(cask) }
-
-      allow_any_instance_of(described_class).to receive(:verbose?).and_return(true)
-    end
-
-    output_reverted = Regexp.new <<~EOS
-      Warning: Reverting upgrade for Cask .*
-    EOS
-
-    it "restores the old Cask if the upgrade failed" do
-      will_fail_if_upgraded = Cask::CaskLoader.load("will-fail-if-upgraded")
-      will_fail_if_upgraded_path = will_fail_if_upgraded.config.appdir.join("container")
-
-      expect(will_fail_if_upgraded).to be_installed
-      expect(will_fail_if_upgraded_path).to be_a_file
-      expect(will_fail_if_upgraded.versions).to include("1.2.2")
-
-      expect {
-        described_class.run("will-fail-if-upgraded")
-      }.to raise_error(Cask::CaskError).and output(output_reverted).to_stderr
-
-      expect(will_fail_if_upgraded).to be_installed
-      expect(will_fail_if_upgraded_path).to be_a_file
-      expect(will_fail_if_upgraded.versions).to include("1.2.2")
-      expect(will_fail_if_upgraded.staged_path).not_to exist
-    end
-
-    it "does not restore the old Cask if the upgrade failed pre-install" do
-      bad_checksum = Cask::CaskLoader.load("bad-checksum")
-      bad_checksum_path = bad_checksum.config.appdir.join("Caffeine.app")
-
-      expect(bad_checksum).to be_installed
-      expect(bad_checksum_path).to be_a_directory
-      expect(bad_checksum.versions).to include("1.2.2")
-
-      expect {
-        described_class.run("bad-checksum")
-      }.to raise_error(ChecksumMismatchError).and(not_to_output(output_reverted).to_stderr)
-
-      expect(bad_checksum).to be_installed
-      expect(bad_checksum_path).to be_a_directory
-      expect(bad_checksum.versions).to include("1.2.2")
-      expect(bad_checksum.staged_path).not_to exist
-    end
-  end
-
-  context "when there were multiple failures" do
-    let(:installed) {
-      [
-        "outdated/bad-checksum",
-        "outdated/local-transmission",
-        "outdated/bad-checksum2",
-      ]
-    }
-
-    before do
-      installed.each { |cask| Cask::Cmd::Install.run(cask) }
-
-      allow_any_instance_of(described_class).to receive(:verbose?).and_return(true)
-    end
-
-    it "will not end the upgrade process" do
-      bad_checksum = Cask::CaskLoader.load("bad-checksum")
-      bad_checksum_path = bad_checksum.config.appdir.join("Caffeine.app")
-
-      bad_checksum_2 = Cask::CaskLoader.load("bad-checksum2")
-      bad_checksum_2_path = bad_checksum_2.config.appdir.join("container")
-
-      expect(bad_checksum).to be_installed
-      expect(bad_checksum_path).to be_a_directory
-      expect(bad_checksum.versions).to include("1.2.2")
-
-      expect(local_transmission).to be_installed
-      expect(local_transmission_path).to be_a_directory
-      expect(local_transmission.versions).to include("2.60")
-
-      expect(bad_checksum_2).to be_installed
-      expect(bad_checksum_2_path).to be_a_file
-      expect(bad_checksum_2.versions).to include("1.2.2")
-
-      expect {
-        described_class.run
-      }.to raise_error(Cask::MultipleCaskErrors)
-
-      expect(bad_checksum).to be_installed
-      expect(bad_checksum_path).to be_a_directory
-      expect(bad_checksum.versions).to include("1.2.2")
-      expect(bad_checksum.staged_path).not_to exist
-
-      expect(local_transmission).to be_installed
-      expect(local_transmission_path).to be_a_directory
-      expect(local_transmission.versions).to include("2.61")
-
-      expect(bad_checksum_2).to be_installed
-      expect(bad_checksum_2_path).to be_a_file
-      expect(bad_checksum_2.versions).to include("1.2.2")
-      expect(bad_checksum_2.staged_path).not_to exist
-    end
-  end
-end
diff --git a/Library/Homebrew/test/cask/cmd/zap_spec.rb b/Library/Homebrew/test/cask/cmd/zap_spec.rb
deleted file mode 100644
index 799efdf982a32..0000000000000
--- a/Library/Homebrew/test/cask/cmd/zap_spec.rb
+++ /dev/null
@@ -1,27 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-describe Cask::Cmd::Zap, :cask do
-  it "shows an error when a bad Cask is provided" do
-    expect { described_class.run("notacask") }
-      .to raise_error(Cask::CaskUnavailableError, /is unavailable/)
-  end
-
-  it "can zap and unlink multiple Casks at once" do
-    caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
-    transmission = Cask::CaskLoader.load(cask_path("local-transmission"))
-
-    Cask::Installer.new(caffeine).install
-    Cask::Installer.new(transmission).install
-
-    expect(caffeine).to be_installed
-    expect(transmission).to be_installed
-
-    described_class.run("local-caffeine", "local-transmission")
-
-    expect(caffeine).not_to be_installed
-    expect(caffeine.config.appdir.join("Caffeine.app")).not_to be_a_symlink
-    expect(transmission).not_to be_installed
-    expect(transmission.config.appdir.join("Transmission.app")).not_to be_a_symlink
-  end
-end
diff --git a/Library/Homebrew/test/cask/config_spec.rb b/Library/Homebrew/test/cask/config_spec.rb
index aad0d27b5ad77..732b0fa2f5a7b 100644
--- a/Library/Homebrew/test/cask/config_spec.rb
+++ b/Library/Homebrew/test/cask/config_spec.rb
@@ -1,7 +1,6 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Config, :cask do
+RSpec.describe Cask::Config, :cask do
   subject(:config) { described_class.new }
 
   describe "::from_json" do
@@ -60,10 +59,10 @@
   end
 
   describe "#explicit" do
-    let(:config) {
+    let(:config) do
       described_class.new(explicit: { appdir:    "/explicit/path/to/apps",
                                       languages: ["zh-TW", "en"] })
-    }
+    end
 
     it "returns directories explicitly given as arguments" do
       expect(config.explicit[:appdir]).to eq(Pathname("/explicit/path/to/apps"))
@@ -72,14 +71,10 @@
     it "returns array of preferred languages" do
       expect(config.explicit[:languages]).to eq(["zh-TW", "en"])
     end
-
-    it "returns string of explicit config keys and values" do
-      expect(config.explicit_s).to eq('appdir: "/explicit/path/to/apps", language: "zh-TW,en"')
-    end
   end
 
   context "when installing a cask and then adding a global default dir" do
-    let(:config) {
+    let(:config) do
       json = <<~EOS
         {
           "default": {
@@ -90,7 +85,7 @@
         }
       EOS
       described_class.from_json(json)
-    }
+    end
 
     describe "#appdir" do
       it "honors metadata of the installed cask" do
diff --git a/Library/Homebrew/test/cask/conflicts_with_spec.rb b/Library/Homebrew/test/cask/conflicts_with_spec.rb
deleted file mode 100644
index 71733db4b2cc0..0000000000000
--- a/Library/Homebrew/test/cask/conflicts_with_spec.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-describe "conflicts_with", :cask do
-  describe "conflicts_with cask" do
-    let(:local_caffeine) {
-      Cask::CaskLoader.load(cask_path("local-caffeine"))
-    }
-
-    let(:with_conflicts_with) {
-      Cask::CaskLoader.load(cask_path("with-conflicts-with"))
-    }
-
-    it "installs the dependency of a Cask and the Cask itself" do
-      Cask::Installer.new(local_caffeine).install
-
-      expect(local_caffeine).to be_installed
-
-      expect {
-        Cask::Installer.new(with_conflicts_with).install
-      }.to raise_error(Cask::CaskConflictError, "Cask 'with-conflicts-with' conflicts with 'local-caffeine'.")
-
-      expect(with_conflicts_with).not_to be_installed
-    end
-  end
-end
diff --git a/Library/Homebrew/test/cask/denylist_spec.rb b/Library/Homebrew/test/cask/denylist_spec.rb
index 6bb3d15218529..69bef66e26e3a 100644
--- a/Library/Homebrew/test/cask/denylist_spec.rb
+++ b/Library/Homebrew/test/cask/denylist_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cask/denylist"
 
-describe Cask::Denylist, :cask do
+RSpec.describe Cask::Denylist, :cask do
   describe "::reason" do
     matcher :disallow do |name|
       match do |expected|
diff --git a/Library/Homebrew/test/cask/depends_on_spec.rb b/Library/Homebrew/test/cask/depends_on_spec.rb
index dc75b885f528d..c2f0373ddbecb 100644
--- a/Library/Homebrew/test/cask/depends_on_spec.rb
+++ b/Library/Homebrew/test/cask/depends_on_spec.rb
@@ -1,12 +1,13 @@
-# typed: false
 # frozen_string_literal: true
 
 # TODO: this test should be named after the corresponding class, once
 #       that class is abstracted from installer.rb
-describe "Satisfy Dependencies and Requirements", :cask do
-  subject(:install) {
+# rubocop:disable RSpec/DescribeClass
+RSpec.describe "Satisfy Dependencies and Requirements", :cask do
+  # rubocop:enable RSpec/DescribeClass
+  subject(:install) do
     Cask::Installer.new(cask).install
-  }
+  end
 
   describe "depends_on cask" do
     let(:dependency) { Cask::CaskLoader.load(cask.depends_on.cask.first) }
diff --git a/Library/Homebrew/test/cask/download_spec.rb b/Library/Homebrew/test/cask/download_spec.rb
index 43ffbd89065d4..bd39587997997 100644
--- a/Library/Homebrew/test/cask/download_spec.rb
+++ b/Library/Homebrew/test/cask/download_spec.rb
@@ -1,59 +1,56 @@
-# typed: false
 # frozen_string_literal: true
 
-module Cask
-  describe Download, :cask do
-    describe "#verify_download_integrity" do
-      subject(:verification) { described_class.new(cask).verify_download_integrity(downloaded_path) }
+RSpec.describe Cask::Download, :cask do
+  describe "#verify_download_integrity" do
+    subject(:verification) { described_class.new(cask).verify_download_integrity(downloaded_path) }
 
-      let(:cask) { instance_double(Cask, token: "cask", sha256: expected_sha256) }
-      let(:cafebabe) { "cafebabecafebabecafebabecafebabecafebabecafebabecafebabecafebabe" }
-      let(:deadbeef) { "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef" }
-      let(:computed_sha256) { cafebabe }
-      let(:downloaded_path) { Pathname.new("cask.zip") }
+    let(:cask) { instance_double(Cask::Cask, token: "cask", sha256: expected_sha256) }
+    let(:cafebabe) { "cafebabecafebabecafebabecafebabecafebabecafebabecafebabecafebabe" }
+    let(:deadbeef) { "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef" }
+    let(:computed_sha256) { cafebabe }
+    let(:downloaded_path) { Pathname.new("cask.zip") }
 
-      before do
-        allow(downloaded_path).to receive(:sha256).and_return(computed_sha256)
-      end
+    before do
+      allow(downloaded_path).to receive_messages(file?: true, sha256: computed_sha256)
+    end
 
-      context "when the expected checksum is :no_check" do
-        let(:expected_sha256) { :no_check }
+    context "when the expected checksum is :no_check" do
+      let(:expected_sha256) { :no_check }
 
-        it "skips the check" do
-          expect { verification }.to output(/skipping verification/).to_stderr
-        end
+      it "skips the check" do
+        expect { verification }.to output(/skipping verification/).to_stderr
       end
+    end
 
-      context "when expected and computed checksums match" do
-        let(:expected_sha256) { Checksum.new(cafebabe) }
+    context "when expected and computed checksums match" do
+      let(:expected_sha256) { Checksum.new(cafebabe) }
 
-        it "does not raise an error" do
-          expect { verification }.not_to raise_error
-        end
+      it "does not raise an error" do
+        expect { verification }.not_to raise_error
       end
+    end
 
-      context "when the expected checksum is nil" do
-        let(:expected_sha256) { nil }
+    context "when the expected checksum is nil" do
+      let(:expected_sha256) { nil }
 
-        it "outputs an error" do
-          expect { verification }.to output(/sha256 "#{computed_sha256}"/).to_stderr
-        end
+      it "outputs an error" do
+        expect { verification }.to output(/sha256 "#{computed_sha256}"/).to_stderr
       end
+    end
 
-      context "when the expected checksum is empty" do
-        let(:expected_sha256) { Checksum.new("") }
+    context "when the expected checksum is empty" do
+      let(:expected_sha256) { Checksum.new("") }
 
-        it "outputs an error" do
-          expect { verification }.to output(/sha256 "#{computed_sha256}"/).to_stderr
-        end
+      it "outputs an error" do
+        expect { verification }.to output(/sha256 "#{computed_sha256}"/).to_stderr
       end
+    end
 
-      context "when expected and computed checksums do not match" do
-        let(:expected_sha256) { Checksum.new(deadbeef) }
+    context "when expected and computed checksums do not match" do
+      let(:expected_sha256) { Checksum.new(deadbeef) }
 
-        it "raises an error" do
-          expect { verification }.to raise_error ChecksumMismatchError
-        end
+      it "raises an error" do
+        expect { verification }.to raise_error ChecksumMismatchError
       end
     end
   end
diff --git a/Library/Homebrew/test/cask/dsl/appcast_spec.rb b/Library/Homebrew/test/cask/dsl/appcast_spec.rb
deleted file mode 100644
index f6ba18aef4e89..0000000000000
--- a/Library/Homebrew/test/cask/dsl/appcast_spec.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-describe Cask::DSL::Appcast do
-  subject(:appcast) { described_class.new(url, params) }
-
-  let(:url) { "https://brew.sh" }
-  let(:uri) { URI(url) }
-  let(:params) { {} }
-
-  describe "#to_s" do
-    it "returns the parsed URI string" do
-      expect(appcast.to_s).to eq("https://brew.sh")
-    end
-  end
-
-  describe "#to_yaml" do
-    let(:yaml) { [uri, params].to_yaml }
-
-    context "with empty parameters" do
-      it "returns an YAML serialized array composed of the URI and parameters" do
-        expect(appcast.to_yaml).to eq(yaml)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/test/cask/dsl/caveats_spec.rb b/Library/Homebrew/test/cask/dsl/caveats_spec.rb
index a9b3919a42fd2..762088517a426 100644
--- a/Library/Homebrew/test/cask/dsl/caveats_spec.rb
+++ b/Library/Homebrew/test/cask/dsl/caveats_spec.rb
@@ -1,13 +1,34 @@
-# typed: false
 # frozen_string_literal: true
 
 require "test/cask/dsl/shared_examples/base"
 
-describe Cask::DSL::Caveats, :cask do
+RSpec.describe Cask::DSL::Caveats, :cask do
+  subject(:caveats) { described_class.new(cask) }
+
   let(:cask) { Cask::CaskLoader.load(cask_path("basic-cask")) }
-  let(:dsl) { described_class.new(cask) }
+  let(:dsl) { caveats }
 
   it_behaves_like Cask::DSL::Base
 
   # TODO: add tests for Caveats DSL methods
+
+  describe "#kext" do
+    let(:cask) { instance_double(Cask::Cask) }
+
+    it "points to System Preferences on macOS Monterey and earlier" do
+      allow(MacOS).to receive(:version).and_return(MacOSVersion.new("12"))
+      caveats.eval_caveats do
+        kext
+      end
+      expect(caveats.to_s).to include("System Preferences → Security & Privacy → General")
+    end
+
+    it "points to System Settings on macOS Ventura and later" do
+      allow(MacOS).to receive(:version).and_return(MacOSVersion.new("13"))
+      caveats.eval_caveats do
+        kext
+      end
+      expect(caveats.to_s).to include("System Settings → Privacy & Security")
+    end
+  end
 end
diff --git a/Library/Homebrew/test/cask/dsl/container_spec.rb b/Library/Homebrew/test/cask/dsl/container_spec.rb
new file mode 100644
index 0000000000000..cd5e1c97130c2
--- /dev/null
+++ b/Library/Homebrew/test/cask/dsl/container_spec.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "test/cask/dsl/shared_examples/base"
+
+RSpec.describe Cask::DSL::Container do
+  subject(:container) { described_class.new(**params) }
+
+  describe "#pairs" do
+    let(:params) { { nested: "NestedApp.dmg" } }
+
+    it "returns the attributes as a hash" do
+      expect(container.pairs).to eq(nested: "NestedApp.dmg")
+    end
+  end
+
+  describe "#to_s" do
+    let(:params) { { nested: "NestedApp.dmg", type: :naked } }
+
+    it "returns the stringified attributes" do
+      expect(container.to_s).to eq('{:nested=>"NestedApp.dmg", :type=>:naked}')
+    end
+  end
+
+  describe "#to_yaml" do
+    let(:params) { { nested: "NestedApp.dmg", type: :naked } }
+
+    it "returns the attributes in YAML format" do
+      expect(container.to_yaml).to eq(<<~YAML)
+        ---
+        :nested: NestedApp.dmg
+        :type: :naked
+      YAML
+    end
+  end
+end
diff --git a/Library/Homebrew/test/cask/dsl/postflight_spec.rb b/Library/Homebrew/test/cask/dsl/postflight_spec.rb
index bc36ff4367a0c..b8ba597746d47 100644
--- a/Library/Homebrew/test/cask/dsl/postflight_spec.rb
+++ b/Library/Homebrew/test/cask/dsl/postflight_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "test/cask/dsl/shared_examples/base"
 require "test/cask/dsl/shared_examples/staged"
 
-describe Cask::DSL::Postflight, :cask do
+RSpec.describe Cask::DSL::Postflight, :cask do
   let(:cask) { Cask::CaskLoader.load(cask_path("basic-cask")) }
   let(:fake_system_command) { class_double(SystemCommand) }
   let(:dsl) { described_class.new(cask, fake_system_command) }
diff --git a/Library/Homebrew/test/cask/dsl/preflight_spec.rb b/Library/Homebrew/test/cask/dsl/preflight_spec.rb
index 12cbf50b17c9e..4ff7aa85596a8 100644
--- a/Library/Homebrew/test/cask/dsl/preflight_spec.rb
+++ b/Library/Homebrew/test/cask/dsl/preflight_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "test/cask/dsl/shared_examples/base"
 require "test/cask/dsl/shared_examples/staged"
 
-describe Cask::DSL::Preflight, :cask do
+RSpec.describe Cask::DSL::Preflight, :cask do
   let(:cask) { Cask::CaskLoader.load(cask_path("basic-cask")) }
   let(:fake_system_command) { class_double(SystemCommand) }
   let(:dsl) { described_class.new(cask, fake_system_command) }
diff --git a/Library/Homebrew/test/cask/dsl/shared_examples/base.rb b/Library/Homebrew/test/cask/dsl/shared_examples/base.rb
index f97d2c29db436..b7871d0215180 100644
--- a/Library/Homebrew/test/cask/dsl/shared_examples/base.rb
+++ b/Library/Homebrew/test/cask/dsl/shared_examples/base.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cask/dsl/base"
 
-shared_examples Cask::DSL::Base do
+RSpec.shared_examples Cask::DSL::Base do
   it "supports the token method" do
     expect(dsl.token).to eq(cask.token)
   end
diff --git a/Library/Homebrew/test/cask/dsl/shared_examples/staged.rb b/Library/Homebrew/test/cask/dsl/shared_examples/staged.rb
index 00367515010ec..f8c2b5b923fc8 100644
--- a/Library/Homebrew/test/cask/dsl/shared_examples/staged.rb
+++ b/Library/Homebrew/test/cask/dsl/shared_examples/staged.rb
@@ -1,19 +1,14 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cask/staged"
 
-shared_examples Cask::Staged do
+RSpec.shared_examples Cask::Staged do
   let(:existing_path) { Pathname("/path/to/file/that/exists") }
   let(:non_existent_path) { Pathname("/path/to/file/that/does/not/exist") }
 
   before do
-    allow(existing_path).to receive(:exist?).and_return(true)
-    allow(existing_path).to receive(:expand_path)
-      .and_return(existing_path)
-    allow(non_existent_path).to receive(:exist?).and_return(false)
-    allow(non_existent_path).to receive(:expand_path)
-      .and_return(non_existent_path)
+    allow(existing_path).to receive_messages(exist?: true, expand_path: existing_path)
+    allow(non_existent_path).to receive_messages(exist?: false, expand_path: non_existent_path)
   end
 
   it "can run system commands with list-form arguments" do
@@ -46,6 +41,7 @@
   it "cannot set the permissions of a file that does not exist" do
     fake_pathname = non_existent_path
     allow(staged).to receive(:Pathname).and_return(fake_pathname)
+    expect(fake_system_command).not_to receive(:run!)
     staged.set_permissions(fake_pathname.to_s, "777")
   end
 
@@ -68,7 +64,11 @@
     allow(staged).to receive(:Pathname).and_return(fake_pathname)
 
     expect(fake_system_command).to receive(:run!)
-      .with("/usr/sbin/chown", args: ["-R", "--", "fake_user:staff", fake_pathname, fake_pathname], sudo: true)
+      .with(
+        "/usr/sbin/chown",
+        args: ["-R", "--", "fake_user:staff", fake_pathname, fake_pathname],
+        sudo: true,
+      )
 
     staged.set_ownership([fake_pathname.to_s, fake_pathname.to_s])
   end
@@ -79,7 +79,11 @@
     allow(staged).to receive(:Pathname).and_return(fake_pathname)
 
     expect(fake_system_command).to receive(:run!)
-      .with("/usr/sbin/chown", args: ["-R", "--", "other_user:other_group", fake_pathname], sudo: true)
+      .with(
+        "/usr/sbin/chown",
+        args: ["-R", "--", "other_user:other_group", fake_pathname],
+        sudo: true,
+      )
 
     staged.set_ownership(fake_pathname.to_s, user: "other_user", group: "other_group")
   end
@@ -88,7 +92,7 @@
     allow(User).to receive(:current).and_return(User.new("fake_user"))
     fake_pathname = non_existent_path
     allow(staged).to receive(:Pathname).and_return(fake_pathname)
-
+    expect(fake_system_command).not_to receive(:run!)
     staged.set_ownership(fake_pathname.to_s)
   end
 end
diff --git a/Library/Homebrew/test/cask/dsl/uninstall_postflight_spec.rb b/Library/Homebrew/test/cask/dsl/uninstall_postflight_spec.rb
index c1881420152ad..bcb0b135f6043 100644
--- a/Library/Homebrew/test/cask/dsl/uninstall_postflight_spec.rb
+++ b/Library/Homebrew/test/cask/dsl/uninstall_postflight_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "test/cask/dsl/shared_examples/base"
 
-describe Cask::DSL::UninstallPostflight, :cask do
+RSpec.describe Cask::DSL::UninstallPostflight, :cask do
   let(:cask) { Cask::CaskLoader.load(cask_path("basic-cask")) }
   let(:dsl) { described_class.new(cask, class_double(SystemCommand)) }
 
diff --git a/Library/Homebrew/test/cask/dsl/uninstall_preflight_spec.rb b/Library/Homebrew/test/cask/dsl/uninstall_preflight_spec.rb
index e8d7d5c4ff920..9c7bec3aec035 100644
--- a/Library/Homebrew/test/cask/dsl/uninstall_preflight_spec.rb
+++ b/Library/Homebrew/test/cask/dsl/uninstall_preflight_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "test/cask/dsl/shared_examples/base"
 require "test/cask/dsl/shared_examples/staged"
 
-describe Cask::DSL::UninstallPreflight, :cask do
+RSpec.describe Cask::DSL::UninstallPreflight, :cask do
   let(:cask) { Cask::CaskLoader.load(cask_path("basic-cask")) }
   let(:fake_system_command) { class_double(SystemCommand) }
   let(:dsl) { described_class.new(cask, fake_system_command) }
diff --git a/Library/Homebrew/test/cask/dsl/version_spec.rb b/Library/Homebrew/test/cask/dsl/version_spec.rb
index 130e757b144c4..311329ce5471b 100644
--- a/Library/Homebrew/test/cask/dsl/version_spec.rb
+++ b/Library/Homebrew/test/cask/dsl/version_spec.rb
@@ -1,7 +1,6 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::DSL::Version, :cask do
+RSpec.describe Cask::DSL::Version, :cask do
   shared_examples "expectations hash" do |input_name, expectations|
     expectations.each do |input_value, expected_output|
       context "when #{input_name} is #{input_value.inspect}" do
@@ -54,9 +53,9 @@
 
   describe "#initialize" do
     it "raises an error when the version contains a slash" do
-      expect {
+      expect do
         described_class.new("0.1,../../directory/traversal")
-      }.to raise_error(TypeError, %r{invalid characters: /})
+      end.to raise_error(TypeError, %r{invalid characters: /})
     end
   end
 
diff --git a/Library/Homebrew/test/cask/dsl_spec.rb b/Library/Homebrew/test/cask/dsl_spec.rb
index f8f3c0ecf7344..b799279c026e3 100644
--- a/Library/Homebrew/test/cask/dsl_spec.rb
+++ b/Library/Homebrew/test/cask/dsl_spec.rb
@@ -1,12 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::DSL, :cask do
-  let(:cask) { Cask::CaskLoader.load(cask_path(token.to_s)) }
+RSpec.describe Cask::DSL, :cask do
+  let(:cask) { Cask::CaskLoader.load(token) }
   let(:token) { "basic-cask" }
 
   describe "stanzas" do
-    it "lets you set url, homepage, and version" do
+    it "lets you set url, homepage and version" do
       expect(cask.url.to_s).to eq("https://brew.sh/TestCask-1.2.3.dmg")
       expect(cask.homepage).to eq("https://brew.sh/")
       expect(cask.version.to_s).to eq("1.2.3")
@@ -14,37 +13,37 @@
   end
 
   describe "when a Cask includes an unknown method" do
-    let(:attempt_unknown_method) {
+    let(:attempt_unknown_method) do
       Cask::Cask.new("unexpected-method-cask") do
         future_feature :not_yet_on_your_machine
       end
-    }
+    end
 
-    it "prints a warning that it has encountered an unexpected method" do
+    it "prints an error that it has encountered an unexpected method" do
       expected = Regexp.compile(<<~EOS.lines.map(&:chomp).join)
         (?m)
-        Warning:
+        Error:
         .*
         Unexpected method 'future_feature' called on Cask unexpected-method-cask\\.
         .*
         https://github.com/Homebrew/homebrew-cask#reporting-bugs
       EOS
 
-      expect {
+      expect do
         expect { attempt_unknown_method }.not_to output.to_stdout
-      }.to output(expected).to_stderr
+      end.to output(expected).to_stderr
     end
 
-    it "will simply warn, not throw an exception" do
-      expect {
+    it "simply warns, instead of throwing an exception" do
+      expect do
         attempt_unknown_method
-      }.not_to raise_error
+      end.not_to raise_error
     end
   end
 
   describe "header line" do
     context "when invalid" do
-      let(:token) { "invalid/invalid-header-format" }
+      let(:token) { "invalid-header-format" }
 
       it "raises an error" do
         expect { cask }.to raise_error(Cask::CaskUnreadableError)
@@ -52,12 +51,12 @@
     end
 
     context "when token does not match the file name" do
-      let(:token) { "invalid/invalid-header-token-mismatch" }
+      let(:token) { "invalid-header-token-mismatch" }
 
       it "raises an error" do
-        expect {
+        expect do
           cask
-        }.to raise_error(Cask::CaskTokenMismatchError, /header line does not match the file name/)
+        end.to raise_error(Cask::CaskTokenMismatchError, /header line does not match the file name/)
       end
     end
 
@@ -126,25 +125,53 @@
 
       expect(cask.sha256).to eq("imasha2")
     end
+
+    context "with a different arm and intel checksum" do
+      let(:cask) do
+        Cask::Cask.new("checksum-cask") do
+          sha256 arm: "imasha2arm", intel: "imasha2intel"
+        end
+      end
+
+      context "when running on arm" do
+        before do
+          allow(Hardware::CPU).to receive(:type).and_return(:arm)
+        end
+
+        it "stores only the arm checksum" do
+          expect(cask.sha256).to eq("imasha2arm")
+        end
+      end
+
+      context "when running on intel" do
+        before do
+          allow(Hardware::CPU).to receive(:type).and_return(:intel)
+        end
+
+        it "stores only the intel checksum" do
+          expect(cask.sha256).to eq("imasha2intel")
+        end
+      end
+    end
   end
 
   describe "language stanza" do
     context "when language is set explicitly" do
-      subject(:cask) {
+      subject(:cask) do
         Cask::Cask.new("cask-with-apps") do
           language "zh" do
             sha256 "abc123"
             "zh-CN"
           end
 
-          language "en-US", default: true do
+          language "en", default: true do
             sha256 "xyz789"
             "en-US"
           end
 
           url "https://example.org/#{language}.zip"
         end
-      }
+      end
 
       matcher :be_the_chinese_version do
         match do |cask|
@@ -282,7 +309,7 @@ def caveats
   end
 
   describe "url stanza" do
-    let(:token) { "invalid/invalid-two-url" }
+    let(:token) { "invalid-two-url" }
 
     it "prevents defining multiple urls" do
       expect { cask }.to raise_error(Cask::CaskInvalidError, /'url' stanza may only appear once/)
@@ -290,7 +317,7 @@ def caveats
   end
 
   describe "homepage stanza" do
-    let(:token) { "invalid/invalid-two-homepage" }
+    let(:token) { "invalid-two-homepage" }
 
     it "prevents defining multiple homepages" do
       expect { cask }.to raise_error(Cask::CaskInvalidError, /'homepage' stanza may only appear once/)
@@ -298,39 +325,47 @@ def caveats
   end
 
   describe "version stanza" do
-    let(:token) { "invalid/invalid-two-version" }
+    let(:token) { "invalid-two-version" }
 
     it "prevents defining multiple versions" do
       expect { cask }.to raise_error(Cask::CaskInvalidError, /'version' stanza may only appear once/)
     end
   end
 
-  describe "appcast stanza" do
-    let(:token) { "with-appcast" }
+  describe "arch stanza" do
+    let(:token) { "invalid-two-arch" }
 
-    it "allows appcasts to be specified" do
-      expect(cask.appcast.to_s).to match(/^http/)
+    it "prevents defining multiple arches" do
+      expect { cask }.to raise_error(Cask::CaskInvalidError, /'arch' stanza may only appear once/)
     end
 
-    context "when multiple appcasts are defined" do
-      let(:token) { "invalid/invalid-appcast-multiple" }
+    context "when no intel value is specified" do
+      let(:token) { "arch-arm-only" }
 
-      it "raises an error" do
-        expect { cask }.to raise_error(Cask::CaskInvalidError, /'appcast' stanza may only appear once/)
+      context "when running on arm" do
+        before do
+          allow(Hardware::CPU).to receive(:type).and_return(:arm)
+        end
+
+        it "returns the value" do
+          expect(cask.url.to_s).to eq "file://#{TEST_FIXTURE_DIR}/cask/caffeine-arm.zip"
+        end
       end
-    end
 
-    context "when appcast URL is invalid" do
-      let(:token) { "invalid/invalid-appcast-url" }
+      context "when running on intel" do
+        before do
+          allow(Hardware::CPU).to receive(:type).and_return(:intel)
+        end
 
-      it "refuses to load" do
-        expect { cask }.to raise_error(Cask::CaskInvalidError)
+        it "defaults to `nil` for the other when no arrays are passed" do
+          expect(cask.url.to_s).to eq "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
+        end
       end
     end
   end
 
   describe "depends_on stanza" do
-    let(:token) { "invalid/invalid-depends-on-key" }
+    let(:token) { "invalid-depends-on-key" }
 
     it "refuses to load with an invalid depends_on key" do
       expect { cask }.to raise_error(Cask::CaskInvalidError)
@@ -375,7 +410,7 @@ def caveats
 
   describe "depends_on macos" do
     context "when the depends_on macos value is invalid" do
-      let(:token) { "invalid/invalid-depends-on-macos-bad-release" }
+      let(:token) { "invalid-depends-on-macos-bad-release" }
 
       it "refuses to load" do
         expect { cask }.to raise_error(Cask::CaskInvalidError)
@@ -383,7 +418,7 @@ def caveats
     end
 
     context "when there are conflicting depends_on macos forms" do
-      let(:token) { "invalid/invalid-depends-on-macos-conflicting-forms" }
+      let(:token) { "invalid-depends-on-macos-conflicting-forms" }
 
       it "refuses to load" do
         expect { cask }.to raise_error(Cask::CaskInvalidError)
@@ -401,7 +436,7 @@ def caveats
     end
 
     context "with invalid depends_on arch value" do
-      let(:token) { "invalid/invalid-depends-on-arch-value" }
+      let(:token) { "invalid-depends-on-arch-value" }
 
       it "refuses to load" do
         expect { cask }.to raise_error(Cask::CaskInvalidError)
@@ -409,6 +444,28 @@ def caveats
     end
   end
 
+  describe "conflicts_with cask" do
+    let(:local_caffeine) do
+      Cask::CaskLoader.load(cask_path("local-caffeine"))
+    end
+
+    let(:with_conflicts_with) do
+      Cask::CaskLoader.load(cask_path("with-conflicts-with"))
+    end
+
+    it "installs the dependency of a Cask and the Cask itself" do
+      Cask::Installer.new(local_caffeine).install
+
+      expect(local_caffeine).to be_installed
+
+      expect do
+        Cask::Installer.new(with_conflicts_with).install
+      end.to raise_error(Cask::CaskConflictError, "Cask 'with-conflicts-with' conflicts with 'local-caffeine'.")
+
+      expect(with_conflicts_with).not_to be_installed
+    end
+  end
+
   describe "conflicts_with stanza" do
     context "when valid" do
       let(:token) { "with-conflicts-with" }
@@ -419,7 +476,7 @@ def caveats
     end
 
     context "with invalid conflicts_with key" do
-      let(:token) { "invalid/invalid-conflicts-with-key" }
+      let(:token) { "invalid-conflicts-with-key" }
 
       it "refuses to load invalid conflicts_with key" do
         expect { cask }.to raise_error(Cask::CaskInvalidError)
@@ -444,7 +501,7 @@ def caveats
 
       it "allows installer manual to be specified" do
         installer = cask.artifacts.first
-        expect(installer).to be_a(Cask::Artifact::Installer::ManualInstaller)
+        expect(installer.instance_variable_get(:@manual_install)).to be true
         expect(installer.path).to eq(Pathname("Caffeine.app"))
       end
     end
@@ -460,7 +517,7 @@ def caveats
     end
 
     context "when there is are activatable artifacts" do
-      let(:token) { "invalid/invalid-stage-only-conflict" }
+      let(:token) { "invalid-stage-only-conflict" }
 
       it "prevents specifying stage_only" do
         expect { cask }.to raise_error(Cask::CaskInvalidError, /'stage_only' must be the only activatable artifact/)
@@ -490,7 +547,7 @@ def caveats
         appdir: "/Applications/",
       })
 
-      cask = Cask::Cask.new("appdir-trailing-slash", config: config) do
+      cask = Cask::Cask.new("appdir-trailing-slash", config:) do
         binary "#{appdir}/some/path"
       end
 
@@ -514,7 +571,7 @@ def caveats
         app "App.app"
       end
 
-      expect(cask.artifacts.map(&:class).map(&:dsl_key)).to eq [
+      expect(cask.artifacts.map { |artifact| artifact.class.dsl_key }).to eq [
         :preflight,
         :app,
         :binary,
diff --git a/Library/Homebrew/test/cask/info_spec.rb b/Library/Homebrew/test/cask/info_spec.rb
new file mode 100644
index 0000000000000..20a5fa214cc6a
--- /dev/null
+++ b/Library/Homebrew/test/cask/info_spec.rb
@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "utils"
+
+RSpec.describe Cask::Info, :cask do
+  before do
+    # Prevent unnecessary network requests in `Utils::Analytics.cask_output`
+    ENV["HOMEBREW_NO_ANALYTICS"] = "1"
+  end
+
+  it "displays some nice info about the specified Cask" do
+    expect do
+      described_class.info(Cask::CaskLoader.load("local-transmission"))
+    end.to output(<<~EOS).to_stdout
+      ==> local-transmission: 2.61
+      https://transmissionbt.com/
+      Not installed
+      From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/l/local-transmission.rb
+      ==> Name
+      Transmission
+      ==> Description
+      BitTorrent client
+      ==> Artifacts
+      Transmission.app (App)
+    EOS
+  end
+
+  it "prints cask dependencies if the Cask has any" do
+    expect do
+      described_class.info(Cask::CaskLoader.load("with-depends-on-cask-multiple"))
+    end.to output(<<~EOS).to_stdout
+      ==> with-depends-on-cask-multiple: 1.2.3
+      https://brew.sh/with-depends-on-cask-multiple
+      Not installed
+      From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/w/with-depends-on-cask-multiple.rb
+      ==> Name
+      None
+      ==> Description
+      None
+      ==> Dependencies
+      local-caffeine (cask), local-transmission (cask)
+      ==> Artifacts
+      Caffeine.app (App)
+    EOS
+  end
+
+  it "prints cask and formulas dependencies if the Cask has both" do
+    expect do
+      described_class.info(Cask::CaskLoader.load("with-depends-on-everything"))
+    end.to output(<<~EOS).to_stdout
+      ==> with-depends-on-everything: 1.2.3
+      https://brew.sh/with-depends-on-everything
+      Not installed
+      From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/w/with-depends-on-everything.rb
+      ==> Name
+      None
+      ==> Description
+      None
+      ==> Dependencies
+      unar, local-caffeine (cask), with-depends-on-cask (cask)
+      ==> Artifacts
+      Caffeine.app (App)
+    EOS
+  end
+
+  it "prints auto_updates if the Cask has `auto_updates true`" do
+    expect do
+      described_class.info(Cask::CaskLoader.load("with-auto-updates"))
+    end.to output(<<~EOS).to_stdout
+      ==> with-auto-updates: 1.0 (auto_updates)
+      https://brew.sh/autoupdates
+      Not installed
+      From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/w/with-auto-updates.rb
+      ==> Name
+      AutoUpdates
+      ==> Description
+      None
+      ==> Artifacts
+      AutoUpdates.app (App)
+    EOS
+  end
+
+  it "prints caveats if the Cask provided one" do
+    expect do
+      described_class.info(Cask::CaskLoader.load("with-caveats"))
+    end.to output(<<~EOS).to_stdout
+      ==> with-caveats: 1.2.3
+      https://brew.sh/
+      Not installed
+      From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/w/with-caveats.rb
+      ==> Name
+      None
+      ==> Description
+      None
+      ==> Artifacts
+      Caffeine.app (App)
+      ==> Caveats
+      Here are some things you might want to know.
+
+      Cask token: with-caveats
+
+      Custom text via puts followed by DSL-generated text:
+      To use with-caveats, you may need to add the /custom/path/bin directory
+      to your PATH environment variable, e.g. (for Bash shell):
+        export PATH=/custom/path/bin:"$PATH"
+
+    EOS
+  end
+
+  it 'does not print "Caveats" section divider if the caveats block has no output' do
+    expect do
+      described_class.info(Cask::CaskLoader.load("with-conditional-caveats"))
+    end.to output(<<~EOS).to_stdout
+      ==> with-conditional-caveats: 1.2.3
+      https://brew.sh/
+      Not installed
+      From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/w/with-conditional-caveats.rb
+      ==> Name
+      None
+      ==> Description
+      None
+      ==> Artifacts
+      Caffeine.app (App)
+    EOS
+  end
+
+  it "prints languages specified in the Cask" do
+    expect do
+      described_class.info(Cask::CaskLoader.load("with-languages"))
+    end.to output(<<~EOS).to_stdout
+      ==> with-languages: 1.2.3
+      https://brew.sh/
+      Not installed
+      From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/w/with-languages.rb
+      ==> Name
+      None
+      ==> Description
+      None
+      ==> Languages
+      zh, en-US
+      ==> Artifacts
+      Caffeine.app (App)
+    EOS
+  end
+
+  it 'does not print "Languages" section divider if the languages block has no output' do
+    expect do
+      described_class.info(Cask::CaskLoader.load("without-languages"))
+    end.to output(<<~EOS).to_stdout
+      ==> without-languages: 1.2.3
+      https://brew.sh/
+      Not installed
+      From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/w/without-languages.rb
+      ==> Name
+      None
+      ==> Description
+      None
+      ==> Artifacts
+      Caffeine.app (App)
+    EOS
+  end
+
+  it "prints install information for an installed Cask" do
+    mktmpdir do |caskroom|
+      FileUtils.mkdir caskroom/"2.61"
+
+      cask = Cask::CaskLoader.load("local-transmission")
+      time = 1_720_189_863
+      tab = Cask::Tab.new(loaded_from_api: true, tabfile: TEST_FIXTURE_DIR/"cask_receipt.json", time:)
+      expect(cask).to receive(:installed?).and_return(true)
+      expect(cask).to receive(:caskroom_path).and_return(caskroom)
+      expect(cask).to receive(:installed_version).and_return("2.61")
+      expect(Cask::Tab).to receive(:for_cask).with(cask).and_return(tab)
+
+      expect do
+        described_class.info(cask)
+      end.to output(<<~EOS).to_stdout
+        ==> local-transmission: 2.61
+        https://transmissionbt.com/
+        Installed
+        #{caskroom}/2.61 (0B)
+          Installed using the formulae.brew.sh API on #{Time.at(time).strftime("%Y-%m-%d at %H:%M:%S")}
+        From: https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/l/local-transmission.rb
+        ==> Name
+        Transmission
+        ==> Description
+        BitTorrent client
+        ==> Artifacts
+        Transmission.app (App)
+      EOS
+    end
+  end
+end
diff --git a/Library/Homebrew/test/cask/installer_spec.rb b/Library/Homebrew/test/cask/installer_spec.rb
index ac65fd7cf09fc..2f407fc79a616 100644
--- a/Library/Homebrew/test/cask/installer_spec.rb
+++ b/Library/Homebrew/test/cask/installer_spec.rb
@@ -1,12 +1,7 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Installer, :cask do
+RSpec.describe Cask::Installer, :cask do
   describe "install" do
-    let(:empty_depends_on_stub) {
-      double(formula: [], cask: [], macos: nil, arch: nil)
-    }
-
     it "downloads and installs a nice fresh Cask" do
       caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
 
@@ -63,16 +58,16 @@
 
     it "blows up on a bad checksum" do
       bad_checksum = Cask::CaskLoader.load(cask_path("bad-checksum"))
-      expect {
+      expect do
         described_class.new(bad_checksum).install
-      }.to raise_error(ChecksumMismatchError)
+      end.to raise_error(ChecksumMismatchError)
     end
 
     it "blows up on a missing checksum" do
       missing_checksum = Cask::CaskLoader.load(cask_path("missing-checksum"))
-      expect {
+      expect do
         described_class.new(missing_checksum).install
-      }.to output(/Cannot verify integrity/).to_stderr
+      end.to output(/Cannot verify integrity/).to_stderr
     end
 
     it "installs fine if sha256 :no_check is used" do
@@ -85,9 +80,9 @@
 
     it "fails to install if sha256 :no_check is used with --require-sha" do
       no_checksum = Cask::CaskLoader.load(cask_path("no-checksum"))
-      expect {
+      expect do
         described_class.new(no_checksum, require_sha: true).install
-      }.to raise_error(/--require-sha/)
+      end.to raise_error(/--require-sha/)
     end
 
     it "installs fine if sha256 :no_check is used with --require-sha and --force" do
@@ -101,9 +96,9 @@
     it "prints caveats if they're present" do
       with_caveats = Cask::CaskLoader.load(cask_path("with-caveats"))
 
-      expect {
+      expect do
         described_class.new(with_caveats).install
-      }.to output(/Here are some things you might want to know/).to_stdout
+      end.to output(/Here are some things you might want to know/).to_stdout
 
       expect(with_caveats).to be_installed
     end
@@ -111,15 +106,14 @@
     it "prints installer :manual instructions when present" do
       with_installer_manual = Cask::CaskLoader.load(cask_path("with-installer-manual"))
 
-      expect {
+      expect do
         described_class.new(with_installer_manual).install
-      }.to output(
+      end.to output(
         <<~EOS,
           ==> Downloading file://#{HOMEBREW_LIBRARY_PATH}/test/support/fixtures/cask/caffeine.zip
           ==> Installing Cask with-installer-manual
-          To complete the installation of Cask with-installer-manual, you must also
-          run the installer at:
-            #{with_installer_manual.staged_path.join("Caffeine.app")}
+          Cask with-installer-manual only provides a manual installer. To run it and complete the installation:
+            open #{with_installer_manual.staged_path.join("Caffeine.app")}
           🍺  with-installer-manual was successfully installed!
         EOS
       ).to_stdout
@@ -142,24 +136,9 @@
 
       described_class.new(with_auto_updates).install
 
-      expect {
+      expect do
         described_class.new(with_auto_updates, force: true).install
-      }.not_to raise_error
-    end
-
-    # unlike the CLI, the internal interface throws exception on double-install
-    it "installer method raises an exception when already-installed Casks are attempted" do
-      transmission = Cask::CaskLoader.load(cask_path("local-transmission"))
-
-      expect(transmission).not_to be_installed
-
-      installer = described_class.new(transmission)
-
-      installer.install
-
-      expect {
-        installer.install
-      }.to raise_error(Cask::CaskAlreadyInstalledError)
+      end.not_to raise_error
     end
 
     it "allows already-installed Casks to be installed if force is provided" do
@@ -169,9 +148,9 @@
 
       described_class.new(transmission).install
 
-      expect {
+      expect do
         described_class.new(transmission, force: true).install
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it "works naked-pkg-based Casks" do
@@ -219,9 +198,9 @@
 
     it "don't print cask installed message with --quiet option" do
       caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
-      expect {
+      expect do
         described_class.new(caffeine, quiet: true).install
-      }.to output(nil).to_stdout
+      end.to output(nil).to_stdout
     end
 
     it "does NOT generate LATEST_DOWNLOAD_SHA256 file for installed Cask without version :latest" do
@@ -239,6 +218,35 @@
 
       expect(latest_cask.download_sha_path).to be_a_file
     end
+
+    context "when loaded from the api and caskfile is required" do
+      let(:path) { cask_path("local-caffeine") }
+      let(:content) { File.read(path) }
+
+      it "installs cask" do
+        source_caffeine = Cask::CaskLoader.load(path)
+        expect(Homebrew::API::Cask).to receive(:source_download).once.and_return(source_caffeine)
+
+        caffeine = Cask::CaskLoader.load(path)
+        expect(caffeine).to receive(:loaded_from_api?).once.and_return(true)
+        expect(caffeine).to receive(:caskfile_only?).once.and_return(true)
+
+        described_class.new(caffeine).install
+        expect(Cask::CaskLoader.load(path)).to be_installed
+      end
+    end
+
+    it "zap method reinstall cask" do
+      caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
+      described_class.new(caffeine).install
+
+      expect(caffeine).to be_installed
+
+      described_class.new(caffeine).zap
+
+      expect(caffeine).not_to be_installed
+      expect(caffeine.config.appdir.join("Caffeine.app")).not_to be_a_symlink
+    end
   end
 
   describe "uninstall" do
@@ -273,6 +281,32 @@
       expect(Cask::Caskroom.path.join("local-caffeine", mutated_version)).not_to be_a_directory
       expect(Cask::Caskroom.path.join("local-caffeine")).not_to be_a_directory
     end
+
+    context "when loaded from the api, caskfile is required and installed caskfile is invalid" do
+      let(:path) { cask_path("local-caffeine") }
+      let(:content) { File.read(path) }
+      let(:invalid_path) { instance_double(Pathname) }
+
+      before do
+        allow(invalid_path).to receive(:exist?).and_return(false)
+      end
+
+      it "uninstalls cask" do
+        source_caffeine = Cask::CaskLoader.load(path)
+        expect(Homebrew::API::Cask).to receive(:source_download).twice.and_return(source_caffeine)
+
+        caffeine = Cask::CaskLoader.load(path)
+        expect(caffeine).to receive(:loaded_from_api?).twice.and_return(true)
+        expect(caffeine).to receive(:caskfile_only?).twice.and_return(true)
+        expect(caffeine).to receive(:installed_caskfile).once.and_return(invalid_path)
+
+        described_class.new(caffeine).install
+        expect(Cask::CaskLoader.load(path)).to be_installed
+
+        described_class.new(caffeine).uninstall
+        expect(Cask::CaskLoader.load(path)).not_to be_installed
+      end
+    end
   end
 
   describe "uninstall_existing_cask" do
@@ -290,4 +324,103 @@
       expect(Cask::CaskLoader.load(cask_path("local-caffeine"))).not_to be_installed
     end
   end
+
+  describe "#forbidden_tap_check" do
+    before do
+      allow(Tap).to receive_messages(allowed_taps: allowed_taps_set, forbidden_taps: forbidden_taps_set)
+    end
+
+    let(:homebrew_forbidden) { Tap.fetch("homebrew/forbidden") }
+    let(:allowed_third_party) { Tap.fetch("nothomebrew/allowed") }
+    let(:disallowed_third_party) { Tap.fetch("nothomebrew/notallowed") }
+    let(:allowed_taps_set) { Set.new([allowed_third_party]) }
+    let(:forbidden_taps_set) { Set.new([homebrew_forbidden]) }
+
+    it "raises on forbidden tap on cask" do
+      cask = Cask::Cask.new("homebrew-forbidden-tap", tap: homebrew_forbidden) do
+        url "file://#{TEST_FIXTURE_DIR}/cask/container.tar.gz"
+      end
+
+      expect do
+        described_class.new(cask).forbidden_tap_check
+      end.to raise_error(Cask::CaskCannotBeInstalledError, /has the tap #{homebrew_forbidden}/)
+    end
+
+    it "raises on not allowed third-party tap on cask" do
+      cask = Cask::Cask.new("homebrew-not-allowed-tap", tap: disallowed_third_party) do
+        url "file://#{TEST_FIXTURE_DIR}/cask/container.tar.gz"
+      end
+
+      expect do
+        described_class.new(cask).forbidden_tap_check
+      end.to raise_error(Cask::CaskCannotBeInstalledError, /has the tap #{disallowed_third_party}/)
+    end
+
+    it "does not raise on allowed tap on cask" do
+      cask = Cask::Cask.new("third-party-allowed-tap", tap: allowed_third_party) do
+        url "file://#{TEST_FIXTURE_DIR}/cask/container.tar.gz"
+      end
+
+      expect { described_class.new(cask).forbidden_tap_check }.not_to raise_error
+    end
+
+    it "raises on forbidden tap on dependency" do
+      dep_tap = homebrew_forbidden
+      dep_name = "homebrew-forbidden-dependency-tap"
+      dep_path = dep_tap.new_formula_path(dep_name)
+      dep_path.parent.mkpath
+      dep_path.write <<~RUBY
+        class #{Formulary.class_s(dep_name)} < Formula
+          url "foo"
+          version "0.1"
+        end
+      RUBY
+      Formulary.cache.delete(dep_path)
+
+      cask = Cask::Cask.new("homebrew-forbidden-dependent-tap") do
+        url "file://#{TEST_FIXTURE_DIR}/cask/container.tar.gz"
+        depends_on formula: dep_name
+      end
+
+      expect do
+        described_class.new(cask).forbidden_tap_check
+      end.to raise_error(Cask::CaskCannotBeInstalledError, /from the #{dep_tap} tap but/)
+    ensure
+      FileUtils.rm_r(dep_path.parent.parent)
+    end
+  end
+
+  describe "#forbidden_cask_and_formula_check" do
+    it "raises on forbidden cask" do
+      ENV["HOMEBREW_FORBIDDEN_CASKS"] = cask_name = "homebrew-forbidden-cask"
+      cask = Cask::Cask.new(cask_name) do
+        url "file://#{TEST_FIXTURE_DIR}/cask/container.tar.gz"
+      end
+
+      expect do
+        described_class.new(cask).forbidden_cask_and_formula_check
+      end.to raise_error(Cask::CaskCannotBeInstalledError, /forbidden for installation/)
+    end
+
+    it "raises on forbidden dependency" do
+      ENV["HOMEBREW_FORBIDDEN_FORMULAE"] = dep_name = "homebrew-forbidden-dependency-formula"
+      dep_path = CoreTap.instance.new_formula_path(dep_name)
+      dep_path.write <<~RUBY
+        class #{Formulary.class_s(dep_name)} < Formula
+          url "foo"
+          version "0.1"
+        end
+      RUBY
+      Formulary.cache.delete(dep_path)
+
+      cask = Cask::Cask.new("homebrew-forbidden-dependent-cask") do
+        url "file://#{TEST_FIXTURE_DIR}/cask/container.tar.gz"
+        depends_on formula: dep_name
+      end
+
+      expect do
+        described_class.new(cask).forbidden_cask_and_formula_check
+      end.to raise_error(Cask::CaskCannotBeInstalledError, /#{dep_name} formula was forbidden/)
+    end
+  end
 end
diff --git a/Library/Homebrew/test/cask/list_spec.rb b/Library/Homebrew/test/cask/list_spec.rb
new file mode 100644
index 0000000000000..6fea3f479806d
--- /dev/null
+++ b/Library/Homebrew/test/cask/list_spec.rb
@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "cask/list"
+
+RSpec.describe Cask::List, :cask do
+  it "lists the installed Casks in a pretty fashion" do
+    casks = %w[local-caffeine local-transmission].map { |c| Cask::CaskLoader.load(c) }
+
+    casks.each do |c|
+      InstallHelper.install_with_caskfile(c)
+    end
+
+    expect do
+      described_class.list_casks
+    end.to output(<<~EOS).to_stdout
+      local-caffeine
+      local-transmission
+    EOS
+  end
+
+  it "lists oneline" do
+    casks = %w[
+      local-caffeine
+      third-party/tap/third-party-cask
+      local-transmission
+    ].map { |c| Cask::CaskLoader.load(c) }
+
+    casks.each do |c|
+      InstallHelper.install_with_caskfile(c)
+    end
+
+    expect do
+      described_class.list_casks(one: true)
+    end.to output(<<~EOS).to_stdout
+      local-caffeine
+      local-transmission
+      third-party-cask
+    EOS
+  end
+
+  it "lists full names" do
+    casks = %w[
+      local-caffeine
+      third-party/tap/third-party-cask
+      local-transmission
+    ].map { |c| Cask::CaskLoader.load(c) }
+
+    casks.each do |c|
+      InstallHelper.install_with_caskfile(c)
+    end
+
+    expect do
+      described_class.list_casks(full_name: true)
+    end.to output(<<~EOS).to_stdout
+      local-caffeine
+      local-transmission
+      third-party/tap/third-party-cask
+    EOS
+  end
+
+  describe "lists versions" do
+    let(:casks) do
+      [
+        "local-caffeine",
+        "local-transmission",
+      ].map { |token| Cask::CaskLoader.load(token) }
+    end
+    let(:expected_output) do
+      <<~EOS
+        local-caffeine 1.2.3
+        local-transmission 2.61
+      EOS
+    end
+
+    before do
+      casks.each do |cask|
+        InstallHelper.install_with_caskfile(cask)
+      end
+    end
+
+    it "of all installed Casks" do
+      expect do
+        described_class.list_casks(versions: true)
+      end.to output(expected_output).to_stdout
+    end
+
+    it "of given Casks" do
+      expect do
+        described_class.list_casks(*casks, versions: true)
+      end.to output(expected_output).to_stdout
+    end
+  end
+
+  describe "given a set of installed Casks" do
+    let(:caffeine) { Cask::CaskLoader.load(cask_path("local-caffeine")) }
+    let(:transmission) { Cask::CaskLoader.load(cask_path("local-transmission")) }
+    let(:casks) { [caffeine, transmission] }
+
+    it "lists the installed files for those Casks" do
+      casks.each { InstallHelper.install_without_artifacts_with_caskfile(_1) }
+
+      transmission.artifacts.select { |a| a.is_a?(Cask::Artifact::App) }.each do |artifact|
+        artifact.install_phase(command: NeverSudoSystemCommand, force: false)
+      end
+
+      expect do
+        described_class.list_casks(transmission, caffeine)
+      end.to output(<<~EOS).to_stdout
+        ==> App
+        #{transmission.config.appdir.join("Transmission.app")} (#{transmission.config.appdir.join("Transmission.app").abv})
+        ==> App
+        Missing App: #{caffeine.config.appdir.join("Caffeine.app")}
+      EOS
+    end
+  end
+end
diff --git a/Library/Homebrew/test/cask/macos_spec.rb b/Library/Homebrew/test/cask/macos_spec.rb
index 92f5c332ef3d5..bb086d6501760 100644
--- a/Library/Homebrew/test/cask/macos_spec.rb
+++ b/Library/Homebrew/test/cask/macos_spec.rb
@@ -1,7 +1,6 @@
-# typed: false
 # frozen_string_literal: true
 
-describe MacOS, :cask do
+RSpec.describe MacOS, :cask do
   it "says '/' is undeletable" do
     expect(described_class).to be_undeletable(
       "/",
diff --git a/Library/Homebrew/test/cask/pkg_spec.rb b/Library/Homebrew/test/cask/pkg_spec.rb
index 2579525675593..a0513c2053c63 100644
--- a/Library/Homebrew/test/cask/pkg_spec.rb
+++ b/Library/Homebrew/test/cask/pkg_spec.rb
@@ -1,24 +1,27 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Cask::Pkg, :cask do
+RSpec.describe Cask::Pkg, :cask do
   describe "#uninstall" do
     let(:fake_system_command) { NeverSudoSystemCommand }
-    let(:empty_response) { double(stdout: "", plist: { "volume" => "/", "install-location" => "", "paths" => {} }) }
+    let(:empty_response) do
+      instance_double(
+        SystemCommand::Result,
+        stdout: "",
+        plist:  { "volume" => "/", "install-location" => "", "paths" => {} },
+      )
+    end
     let(:pkg) { described_class.new("my.fake.pkg", fake_system_command) }
 
     it "removes files and dirs referenced by the pkg" do
       some_files = Array.new(3) { Pathname.new(Tempfile.new("plain_file").path) }
-      allow(pkg).to receive(:pkgutil_bom_files).and_return(some_files)
 
       some_specials = Array.new(3) { Pathname.new(Tempfile.new("special_file").path) }
-      allow(pkg).to receive(:pkgutil_bom_specials).and_return(some_specials)
 
       some_dirs = Array.new(3) { mktmpdir }
-      allow(pkg).to receive(:pkgutil_bom_dirs).and_return(some_dirs)
 
       root_dir = Pathname.new(mktmpdir)
-      allow(pkg).to receive(:root).and_return(root_dir)
+      allow(pkg).to receive_messages(pkgutil_bom_files: some_files, pkgutil_bom_specials: some_specials,
+                                     pkgutil_bom_dirs: some_dirs, root: root_dir)
 
       allow(pkg).to receive(:forget)
 
@@ -28,11 +31,20 @@
         expect(file).not_to exist
       end
 
+      some_specials.each do |file|
+        expect(file).not_to exist
+      end
+
       some_dirs.each do |dir|
         expect(dir).not_to exist
       end
 
       expect(root_dir).not_to exist
+    ensure
+      some_files&.each { |path| FileUtils.rm_rf(path) }
+      some_specials&.each { |path| FileUtils.rm_rf(path) }
+      some_dirs&.each { |path| FileUtils.rm_rf(path) }
+      FileUtils.rm_rf(root_dir) if root_dir
     end
 
     describe "pkgutil" do
@@ -49,8 +61,9 @@
 
         expect(fake_system_command).to receive(:run!).with(
           "/usr/sbin/pkgutil",
-          args: ["--forget", "my.fake.pkg"],
-          sudo: true,
+          args:         ["--forget", "my.fake.pkg"],
+          sudo:         true,
+          sudo_as_root: true,
         )
 
         pkg.uninstall
@@ -67,10 +80,8 @@
       intact_symlink = fake_dir.join("intact_symlink").tap { |path| path.make_symlink(fake_file) }
       broken_symlink = fake_dir.join("broken_symlink").tap { |path| path.make_symlink("im_nota_file") }
 
-      allow(pkg).to receive(:pkgutil_bom_specials).and_return([])
-      allow(pkg).to receive(:pkgutil_bom_files).and_return([])
-      allow(pkg).to receive(:pkgutil_bom_dirs).and_return([fake_dir])
-      allow(pkg).to receive(:root).and_return(fake_root)
+      allow(pkg).to receive_messages(pkgutil_bom_specials: [], pkgutil_bom_files: [], pkgutil_bom_dirs: [fake_dir],
+                                     root: fake_root)
       allow(pkg).to receive(:forget)
 
       pkg.uninstall
@@ -79,6 +90,9 @@
       expect(broken_symlink).not_to exist
       expect(fake_dir).to exist
       expect(fake_root).not_to exist
+    ensure
+      FileUtils.rm_rf(fake_dir) if fake_dir
+      FileUtils.rm_rf(fake_root) if fake_root
     end
 
     it "snags permissions on ornery dirs, but returns them afterwards" do
@@ -87,19 +101,18 @@
       fake_file = fake_dir.join("ima_unrelated_file").tap { |path| FileUtils.touch(path) }
       fake_dir.chmod(0000)
 
-      allow(pkg).to receive(:pkgutil_bom_specials).and_return([])
-      allow(pkg).to receive(:pkgutil_bom_files).and_return([])
-      allow(pkg).to receive(:pkgutil_bom_dirs).and_return([fake_dir])
-      allow(pkg).to receive(:root).and_return(fake_root)
+      allow(pkg).to receive_messages(pkgutil_bom_specials: [], pkgutil_bom_files: [], pkgutil_bom_dirs: [fake_dir],
+                                     root: fake_root)
       allow(pkg).to receive(:forget)
 
       # This is expected to fail in tests since we don't use `sudo`.
       allow(fake_system_command).to receive(:run!).and_call_original
       expect(fake_system_command).to receive(:run!).with(
         "/usr/bin/xargs",
-        args:  ["-0", "--", a_string_including("rmdir")],
-        input: [fake_dir].join("\0"),
-        sudo:  true,
+        args:         ["-0", "--", a_string_including("rmdir")],
+        input:        [fake_dir].join("\0"),
+        sudo:         true,
+        sudo_as_root: true,
       ).and_return(instance_double(SystemCommand::Result, stdout: ""))
 
       pkg.uninstall
@@ -109,8 +122,12 @@
 
       fake_dir.chmod(0777)
       expect(fake_file).to be_a_file
-
-      FileUtils.rm_r fake_dir
+    ensure
+      if fake_dir
+        fake_dir.chmod(0777)
+        FileUtils.rm_rf(fake_dir)
+      end
+      FileUtils.rm_rf(fake_root) if fake_root
     end
   end
 
diff --git a/Library/Homebrew/test/cask/quarantine_spec.rb b/Library/Homebrew/test/cask/quarantine_spec.rb
deleted file mode 100644
index 505ffba173fb8..0000000000000
--- a/Library/Homebrew/test/cask/quarantine_spec.rb
+++ /dev/null
@@ -1,251 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "cask/cmd/audit"
-require "cask/cmd/fetch"
-require "cask/cmd/install"
-require "cask/cask_loader"
-require "cask/download"
-require "cask/quarantine"
-
-describe Cask::Quarantine, :cask do
-  matcher :be_quarantined do
-    match do |path|
-      expect(
-        described_class.detect(path),
-      ).to be true
-    end
-  end
-
-  describe "by default" do
-    it "quarantines a nice fresh Cask" do
-      Cask::Cmd::Install.run("local-transmission")
-
-      cask = Cask::CaskLoader.load(cask_path("local-transmission"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("Transmission.app")).to be_quarantined
-    end
-
-    it "quarantines Cask fetches" do
-      Cask::Cmd::Fetch.run("local-transmission")
-      local_transmission = Cask::CaskLoader.load(cask_path("local-transmission"))
-      cached_location = Cask::Download.new(local_transmission).fetch
-
-      expect(cached_location).to be_quarantined
-    end
-
-    it "quarantines Cask audits" do
-      expect {
-        Cask::Cmd::Audit.run("local-transmission", "--download")
-      }.to not_raise_error
-       .and output(/audit for local-transmission: passed/).to_stdout
-       .and not_to_output.to_stderr
-
-      local_transmission = Cask::CaskLoader.load(cask_path("local-transmission"))
-      cached_location = Cask::Download.new(local_transmission).fetch
-
-      expect(cached_location).to be_quarantined
-    end
-
-    it "quarantines Cask installs even if the fetch was not" do
-      Cask::Cmd::Fetch.run("local-transmission", "--no-quarantine")
-
-      Cask::Cmd::Install.run("local-transmission")
-
-      cask = Cask::CaskLoader.load(cask_path("local-transmission"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("Transmission.app")).to be_quarantined
-    end
-
-    it "quarantines dmg-based Casks" do
-      Cask::Cmd::Install.run("container-dmg")
-
-      cask = Cask::CaskLoader.load(cask_path("container-dmg"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("container")).to be_quarantined
-    end
-
-    it "quarantines tar-gz-based Casks" do
-      Cask::Cmd::Install.run("container-tar-gz")
-
-      cask = Cask::CaskLoader.load(cask_path("container-tar-gz"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("container")).to be_quarantined
-    end
-
-    it "quarantines xar-based Casks" do
-      Cask::Cmd::Install.run("container-xar")
-
-      cask = Cask::CaskLoader.load(cask_path("container-xar"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("container")).to be_quarantined
-    end
-
-    it "quarantines pure bzip2-based Casks" do
-      Cask::Cmd::Install.run("container-bzip2")
-
-      cask = Cask::CaskLoader.load(cask_path("container-bzip2"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("container")).to be_quarantined
-    end
-
-    it "quarantines pure gzip-based Casks" do
-      Cask::Cmd::Install.run("container-gzip")
-
-      cask = Cask::CaskLoader.load(cask_path("container-gzip"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("container")).to be_quarantined
-    end
-
-    it "quarantines the pkg in naked-pkg-based Casks" do
-      Cask::Cmd::Install.run("container-pkg")
-
-      cask = Cask::CaskLoader.load(cask_path("container-pkg"))
-
-      expect(cask).to be_installed
-
-      expect(cask.staged_path/"container.pkg").to be_quarantined
-    end
-
-    it "quarantines a nested container" do
-      Cask::Cmd::Install.run("nested-app")
-
-      cask = Cask::CaskLoader.load(cask_path("nested-app"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("MyNestedApp.app")).to be_quarantined
-    end
-  end
-
-  describe "when disabled" do
-    it "does not quarantine even a nice, fresh Cask" do
-      Cask::Cmd::Install.run("local-transmission", "--no-quarantine")
-
-      cask = Cask::CaskLoader.load(cask_path("local-transmission"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("Transmission.app")).not_to be_quarantined
-    end
-
-    it "does not quarantine Cask fetches" do
-      Cask::Cmd::Fetch.run("local-transmission", "--no-quarantine")
-      local_transmission = Cask::CaskLoader.load(cask_path("local-transmission"))
-      cached_location = Cask::Download.new(local_transmission).fetch
-
-      expect(cached_location).not_to be_quarantined
-    end
-
-    it "does not quarantine Cask audits" do
-      expect {
-        Cask::Cmd::Audit.run("local-transmission", "--download", "--no-quarantine")
-      }.to not_raise_error
-       .and output(/audit for local-transmission: passed/).to_stdout
-       .and not_to_output.to_stderr
-
-      local_transmission = Cask::CaskLoader.load(cask_path("local-transmission"))
-      cached_location = Cask::Download.new(local_transmission).fetch
-
-      expect(cached_location).not_to be_quarantined
-    end
-
-    it "does not quarantine Cask installs even if the fetch was" do
-      Cask::Cmd::Fetch.run("local-transmission")
-
-      Cask::Cmd::Install.run("local-transmission", "--no-quarantine")
-
-      cask = Cask::CaskLoader.load(cask_path("local-transmission"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("Transmission.app")).not_to be_quarantined
-    end
-
-    it "does not quarantine dmg-based Casks" do
-      Cask::Cmd::Install.run("container-dmg", "--no-quarantine")
-
-      cask = Cask::CaskLoader.load(cask_path("container-dmg"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("container")).not_to be_quarantined
-    end
-
-    it "does not quarantine tar-gz-based Casks" do
-      Cask::Cmd::Install.run("container-tar-gz", "--no-quarantine")
-
-      cask = Cask::CaskLoader.load(cask_path("container-tar-gz"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("container")).not_to be_quarantined
-    end
-
-    it "does not quarantine xar-based Casks" do
-      Cask::Cmd::Install.run("container-xar", "--no-quarantine")
-
-      cask = Cask::CaskLoader.load(cask_path("container-xar"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("container")).not_to be_quarantined
-    end
-
-    it "does not quarantine pure bzip2-based Casks" do
-      Cask::Cmd::Install.run("container-bzip2", "--no-quarantine")
-
-      cask = Cask::CaskLoader.load(cask_path("container-bzip2"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("container")).not_to be_quarantined
-    end
-
-    it "does not quarantine pure gzip-based Casks" do
-      Cask::Cmd::Install.run("container-gzip", "--no-quarantine")
-
-      cask = Cask::CaskLoader.load(cask_path("container-gzip"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("container")).not_to be_quarantined
-    end
-
-    it "does not quarantine the pkg in naked-pkg-based Casks" do
-      Cask::Cmd::Install.run("container-pkg", "--no-quarantine")
-
-      naked_pkg = Cask::CaskLoader.load(cask_path("container-pkg"))
-
-      expect(naked_pkg).to be_installed
-
-      expect(
-        Cask::Caskroom.path.join("container-pkg", naked_pkg.version, "container.pkg"),
-      ).not_to be_quarantined
-    end
-
-    it "does not quarantine a nested container" do
-      Cask::Cmd::Install.run("nested-app", "--no-quarantine")
-
-      cask = Cask::CaskLoader.load(cask_path("nested-app"))
-
-      expect(cask).to be_installed
-
-      expect(cask.config.appdir.join("MyNestedApp.app")).not_to be_quarantined
-    end
-  end
-end
diff --git a/Library/Homebrew/test/cask/reinstall_spec.rb b/Library/Homebrew/test/cask/reinstall_spec.rb
new file mode 100644
index 0000000000000..76d8346050849
--- /dev/null
+++ b/Library/Homebrew/test/cask/reinstall_spec.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "cask/installer"
+require "cask/reinstall"
+
+RSpec.describe Cask::Reinstall, :cask do
+  it "displays the reinstallation progress" do
+    caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
+
+    Cask::Installer.new(caffeine).install
+
+    output = Regexp.new <<~EOS
+      ==> Downloading file:.*caffeine.zip
+      Already downloaded: .*--caffeine.zip
+      ==> Uninstalling Cask local-caffeine
+      ==> Backing App 'Caffeine.app' up to '.*Caffeine.app'
+      ==> Removing App '.*Caffeine.app'
+      ==> Purging files for version 1.2.3 of Cask local-caffeine
+      ==> Installing Cask local-caffeine
+      ==> Moving App 'Caffeine.app' to '.*Caffeine.app'
+      .*local-caffeine was successfully installed!
+    EOS
+
+    expect do
+      described_class.reinstall_casks(Cask::CaskLoader.load("local-caffeine"))
+    end.to output(output).to_stdout
+  end
+
+  it "displays the reinstallation progress with zapping" do
+    caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
+
+    Cask::Installer.new(caffeine).install
+
+    output = Regexp.new <<~EOS
+      ==> Downloading file:.*caffeine.zip
+      Already downloaded: .*--caffeine.zip
+      ==> Implied `brew uninstall --cask local-caffeine`
+      ==> Backing App 'Caffeine.app' up to '.*Caffeine.app'
+      ==> Removing App '.*Caffeine.app'
+      ==> Dispatching zap stanza
+      ==> Trashing files:
+      .*org.example.caffeine.plist
+      ==> Removing all staged versions of Cask 'local-caffeine'
+      ==> Installing Cask local-caffeine
+      ==> Moving App 'Caffeine.app' to '.*Caffeine.app'
+      .*local-caffeine was successfully installed!
+    EOS
+
+    expect do
+      described_class.reinstall_casks(Cask::CaskLoader.load("local-caffeine"), zap: true)
+    end.to output(output).to_stdout
+  end
+
+  it "allows reinstalling a Cask" do
+    Cask::Installer.new(Cask::CaskLoader.load(cask_path("local-transmission"))).install
+
+    expect(Cask::CaskLoader.load(cask_path("local-transmission"))).to be_installed
+
+    described_class.reinstall_casks(Cask::CaskLoader.load("local-transmission"))
+    expect(Cask::CaskLoader.load(cask_path("local-transmission"))).to be_installed
+  end
+
+  it "allows reinstalling a non installed Cask" do
+    expect(Cask::CaskLoader.load(cask_path("local-transmission"))).not_to be_installed
+
+    described_class.reinstall_casks(Cask::CaskLoader.load("local-transmission"))
+    expect(Cask::CaskLoader.load(cask_path("local-transmission"))).to be_installed
+  end
+end
diff --git a/Library/Homebrew/test/cask/tab_spec.rb b/Library/Homebrew/test/cask/tab_spec.rb
new file mode 100644
index 0000000000000..9b346e2601389
--- /dev/null
+++ b/Library/Homebrew/test/cask/tab_spec.rb
@@ -0,0 +1,356 @@
+# frozen_string_literal: true
+
+require "cask"
+
+RSpec.describe Cask::Tab, :cask do
+  matcher :be_installed_as_dependency do
+    match do |actual|
+      actual.installed_as_dependency == true
+    end
+  end
+
+  matcher :be_installed_on_request do
+    match do |actual|
+      actual.installed_on_request == true
+    end
+  end
+
+  matcher :be_loaded_from_api do
+    match do |actual|
+      actual.loaded_from_api == true
+    end
+  end
+
+  matcher :have_uninstall_flight_blocks do
+    match do |actual|
+      actual.uninstall_flight_blocks == true
+    end
+  end
+
+  subject(:tab) do
+    described_class.new(
+      "homebrew_version"        => HOMEBREW_VERSION,
+      "loaded_from_api"         => false,
+      "uninstall_flight_blocks" => true,
+      "installed_as_dependency" => false,
+      "installed_on_request"    => true,
+      "time"                    => time,
+      "runtime_dependencies"    => {
+        "cask" => [{ "full_name" => "bar", "version" => "2.0", "declared_directly" => false }],
+      },
+      "source"                  => {
+        "path"         => CoreCaskTap.instance.path.to_s,
+        "tap"          => CoreCaskTap.instance.to_s,
+        "tap_git_head" => "8b79aa759500f0ffdf65a23e12950cbe3bf8fe17",
+        "version"      => "1.2.3",
+      },
+      "arch"                    => Hardware::CPU.arch,
+      "uninstall_artifacts"     => [{ "app" => ["Foo.app"] }],
+      "built_on"                => DevelopmentTools.build_system_info,
+    )
+  end
+
+  let(:time) { Time.now.to_i }
+
+  let(:f) { formula { url "foo-1.0" } }
+  let(:f_tab_path) { f.prefix/"INSTALL_RECEIPT.json" }
+  let(:f_tab_content) { (TEST_FIXTURE_DIR/"receipt.json").read }
+
+  specify "defaults" do
+    stub_const("HOMEBREW_VERSION", "4.3.7")
+
+    tab = described_class.empty
+
+    expect(tab.homebrew_version).to eq(HOMEBREW_VERSION)
+    expect(tab).not_to be_installed_as_dependency
+    expect(tab).not_to be_installed_on_request
+    expect(tab).not_to be_loaded_from_api
+    expect(tab).not_to have_uninstall_flight_blocks
+    expect(tab.tap).to be_nil
+    expect(tab.time).to be_nil
+    expect(tab.runtime_dependencies).to be_nil
+    expect(tab.source["path"]).to be_nil
+  end
+
+  specify "#runtime_dependencies" do
+    tab = described_class.new
+    expect(tab.runtime_dependencies).to be_nil
+
+    tab.runtime_dependencies = {}
+    expect(tab.runtime_dependencies).not_to be_nil
+
+    tab.runtime_dependencies = {
+      "cask" => [{ "full_name" => "bar", "version" => "2.0", "declared_directly" => false }],
+    }
+    expect(tab.runtime_dependencies).not_to be_nil
+  end
+
+  describe "::runtime_deps_hash" do
+    specify "with no dependencies" do
+      cask = Cask::CaskLoader.load("local-transmission")
+
+      expect(described_class.runtime_deps_hash(cask)).to eq({})
+    end
+
+    specify "with cask dependencies" do
+      cask = Cask::CaskLoader.load("with-depends-on-cask")
+
+      expected_hash = {
+        cask: [
+          { "full_name"=>"local-transmission", "version"=>"2.61", "declared_directly"=>true },
+        ],
+      }
+      expect(described_class.runtime_deps_hash(cask)).to eq(expected_hash)
+    end
+
+    it "ignores macos symbol dependencies" do
+      cask = Cask::CaskLoader.load("with-depends-on-macos-symbol")
+
+      expect(described_class.runtime_deps_hash(cask)).to eq({})
+    end
+
+    it "ignores macos array dependencies" do
+      cask = Cask::CaskLoader.load("with-depends-on-macos-array")
+
+      expect(described_class.runtime_deps_hash(cask)).to eq({})
+    end
+
+    it "ignores arch dependencies" do
+      cask = Cask::CaskLoader.load("with-depends-on-arch")
+
+      expect(described_class.runtime_deps_hash(cask)).to eq({})
+    end
+
+    specify "with all types of dependencies" do
+      cask = Cask::CaskLoader.load("with-depends-on-everything")
+
+      unar = instance_double(Formula, full_name: "unar", version: "1.2", revision: 0, pkg_version: "1.2",
+                             deps: [], requirements: [])
+      expect(Formulary).to receive(:factory).with("unar").and_return(unar)
+
+      expected_hash = {
+        cask:    [
+          { "full_name"=>"local-caffeine", "version"=>"1.2.3", "declared_directly"=>true },
+          { "full_name"=>"with-depends-on-cask", "version"=>"1.2.3", "declared_directly"=>true },
+          { "full_name"=>"local-transmission", "version"=>"2.61", "declared_directly"=>false },
+        ],
+        formula: [
+          { "full_name"=>"unar", "version"=>"1.2", "revision"=>0, "pkg_version"=>"1.2", "declared_directly"=>true },
+        ],
+      }
+
+      runtime_deps_hash = described_class.runtime_deps_hash(cask)
+      tab = described_class.new
+      tab.runtime_dependencies = runtime_deps_hash
+      expect(tab.runtime_dependencies).to eql(expected_hash)
+    end
+  end
+
+  specify "other attributes" do
+    expect(tab.tap.name).to eq("homebrew/cask")
+    expect(tab.time).to eq(time)
+    expect(tab).not_to be_loaded_from_api
+    expect(tab).to have_uninstall_flight_blocks
+    expect(tab).not_to be_installed_as_dependency
+    expect(tab).to be_installed_on_request
+    expect(tab).not_to be_loaded_from_api
+  end
+
+  describe "::from_file" do
+    it "parses a cask Tab from a file" do
+      path = Pathname.new("#{TEST_FIXTURE_DIR}/cask_receipt.json")
+      tab = described_class.from_file(path)
+      source_path = "/opt/homebrew/Library/Taps/homebrew/homebrew-cask/Casks/f/foo.rb"
+      runtime_dependencies = {
+        "cask"    => [
+          {
+            "full_name"         => "bar",
+            "version"           => "2.0",
+            "declared_directly" => true,
+          },
+        ],
+        "formula" => [
+          {
+            "full_name"         => "baz",
+            "version"           => "3.0",
+            "revision"          => 0,
+            "pkg_version"       => "3.0",
+            "declared_directly" => true,
+          },
+        ],
+        "macos"   => {
+          ">=" => [
+            "12",
+          ],
+        },
+      }
+
+      expect(tab).not_to be_loaded_from_api
+      expect(tab).to have_uninstall_flight_blocks
+      expect(tab).not_to be_installed_as_dependency
+      expect(tab).to be_installed_on_request
+      expect(tab.time).to eq(Time.at(1_719_289_256).to_i)
+      expect(tab.runtime_dependencies).to eq(runtime_dependencies)
+      expect(tab.source["path"]).to eq(source_path)
+      expect(tab.version).to eq("1.2.3")
+      expect(tab.tap.name).to eq("homebrew/cask")
+    end
+  end
+
+  describe "::from_file_content" do
+    it "parses a cask Tab from a file" do
+      path = Pathname.new("#{TEST_FIXTURE_DIR}/cask_receipt.json")
+      tab = described_class.from_file_content(path.read, path)
+      source_path = "/opt/homebrew/Library/Taps/homebrew/homebrew-cask/Casks/f/foo.rb"
+      runtime_dependencies = {
+        "cask"    => [
+          {
+            "full_name"         => "bar",
+            "version"           => "2.0",
+            "declared_directly" => true,
+          },
+        ],
+        "formula" => [
+          {
+            "full_name"         => "baz",
+            "version"           => "3.0",
+            "revision"          => 0,
+            "pkg_version"       => "3.0",
+            "declared_directly" => true,
+          },
+        ],
+        "macos"   => {
+          ">=" => [
+            "12",
+          ],
+        },
+      }
+
+      expect(tab).not_to be_loaded_from_api
+      expect(tab).to have_uninstall_flight_blocks
+      expect(tab).not_to be_installed_as_dependency
+      expect(tab).to be_installed_on_request
+      expect(tab.tabfile).to eq(path)
+      expect(tab.time).to eq(Time.at(1_719_289_256).to_i)
+      expect(tab.runtime_dependencies).to eq(runtime_dependencies)
+      expect(tab.source["path"]).to eq(source_path)
+      expect(tab.version).to eq("1.2.3")
+      expect(tab.tap.name).to eq("homebrew/cask")
+    end
+
+    it "raises a parse exception message including the Tab filename" do
+      expect { described_class.from_file_content("''", "cask_receipt.json") }.to raise_error(
+        JSON::ParserError,
+        /receipt.json:/,
+      )
+    end
+  end
+
+  describe "::create" do
+    it "creates a cask Tab" do
+      cask = Cask::CaskLoader.load("local-caffeine")
+      expected_artifacts = [
+        { app: ["Caffeine.app"] },
+        { zap: [{ trash: "#{TEST_FIXTURE_DIR}/cask/caffeine/org.example.caffeine.plist" }] },
+      ]
+
+      tab = described_class.create(cask)
+      expect(tab).not_to be_loaded_from_api
+      expect(tab).not_to have_uninstall_flight_blocks
+      expect(tab).not_to be_installed_as_dependency
+      expect(tab).not_to be_installed_on_request
+      expect(tab.source).to eq({
+        "path"         => "#{CoreCaskTap.instance.path}/Casks/local-caffeine.rb",
+        "tap"          => CoreCaskTap.instance.name,
+        "tap_git_head" => nil,
+        "version"      => "1.2.3",
+      })
+      expect(tab.runtime_dependencies).to eq({})
+      expect(tab.uninstall_artifacts).to eq(expected_artifacts)
+    end
+  end
+
+  describe "::for_cask" do
+    let(:cask) { Cask::CaskLoader.load("local-transmission") }
+    let(:cask_tab_path) { cask.metadata_main_container_path/AbstractTab::FILENAME }
+    let(:cask_tab_content) { (TEST_FIXTURE_DIR/"cask_receipt.json").read }
+
+    it "creates a Tab for a given cask" do
+      tab = described_class.for_cask(cask)
+      expect(tab.source["path"]).to eq(cask.sourcefile_path.to_s)
+    end
+
+    it "creates a Tab for a given cask with existing Tab" do
+      cask_tab_path.dirname.mkpath
+      cask_tab_path.write cask_tab_content
+
+      tab = described_class.for_cask(cask)
+      expect(tab.tabfile).to eq(cask_tab_path)
+    end
+
+    it "can create a Tab for a non-existent cask" do
+      cask_tab_path.dirname.mkpath
+
+      tab = described_class.for_cask(cask)
+      expect(tab.tabfile).to be_nil
+    end
+  end
+
+  specify "#to_json" do
+    json_tab = described_class.new(JSON.parse(tab.to_json))
+    expect(json_tab.homebrew_version).to eq(tab.homebrew_version)
+    expect(json_tab.loaded_from_api).to eq(tab.loaded_from_api)
+    expect(json_tab.uninstall_flight_blocks).to eq(tab.uninstall_flight_blocks)
+    expect(json_tab.installed_as_dependency).to eq(tab.installed_as_dependency)
+    expect(json_tab.installed_on_request).to eq(tab.installed_on_request)
+    expect(json_tab.time).to eq(tab.time)
+    expect(json_tab.runtime_dependencies).to eq(tab.runtime_dependencies)
+    expect(json_tab.source["path"]).to eq(tab.source["path"])
+    expect(json_tab.tap).to eq(tab.tap)
+    expect(json_tab.source["tap_git_head"]).to eq(tab.source["tap_git_head"])
+    expect(json_tab.version).to eq(tab.version)
+    expect(json_tab.arch).to eq(tab.arch.to_s)
+    expect(json_tab.uninstall_artifacts).to eq(tab.uninstall_artifacts)
+    expect(json_tab.built_on["os"]).to eq(tab.built_on["os"])
+  end
+
+  describe "#to_s" do
+    let(:time_string) { Time.at(1_720_189_863).strftime("%Y-%m-%d at %H:%M:%S") }
+
+    it "returns install information for a Tab with a time that was loaded from the API" do
+      tab = described_class.new(
+        loaded_from_api: true,
+        time:            1_720_189_863,
+      )
+      output = "Installed using the formulae.brew.sh API on #{time_string}"
+      expect(tab.to_s).to eq(output)
+    end
+
+    it "returns install information for a Tab with a time that was not loaded from the API" do
+      tab = described_class.new(
+        loaded_from_api: false,
+        time:            1_720_189_863,
+      )
+      output = "Installed on #{time_string}"
+      expect(tab.to_s).to eq(output)
+    end
+
+    it "returns install information for a Tab without a time that was loaded from the API" do
+      tab = described_class.new(
+        loaded_from_api: true,
+        time:            nil,
+      )
+      output = "Installed using the formulae.brew.sh API"
+      expect(tab.to_s).to eq(output)
+    end
+
+    it "returns install information for a Tab without a time that was not loaded from the API" do
+      tab = described_class.new(
+        loaded_from_api: false,
+        time:            nil,
+      )
+      output = "Installed"
+      expect(tab.to_s).to eq(output)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/cask/uninstall_spec.rb b/Library/Homebrew/test/cask/uninstall_spec.rb
new file mode 100644
index 0000000000000..0bf718e1f2025
--- /dev/null
+++ b/Library/Homebrew/test/cask/uninstall_spec.rb
@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "cask/uninstall"
+
+RSpec.describe Cask::Uninstall, :cask do
+  it "displays the uninstallation progress" do
+    caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
+
+    Cask::Installer.new(caffeine).install
+
+    output = Regexp.new <<~EOS
+      ==> Uninstalling Cask local-caffeine
+      ==> Backing App 'Caffeine.app' up to '.*Caffeine.app'
+      ==> Removing App '.*Caffeine.app'
+      ==> Purging files for version 1.2.3 of Cask local-caffeine
+    EOS
+
+    expect do
+      described_class.uninstall_casks(caffeine)
+    end.to output(output).to_stdout
+  end
+
+  it "shows an error when a Cask is provided that's not installed" do
+    caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
+
+    expect { described_class.uninstall_casks(caffeine) }
+      .to raise_error(Cask::CaskNotInstalledError, /is not installed/)
+  end
+
+  it "tries anyway on a non-present Cask when --force is given" do
+    caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
+
+    expect do
+      described_class.uninstall_casks(caffeine, force: true)
+    end.not_to raise_error
+  end
+
+  it "can uninstall and unlink multiple Casks at once" do
+    caffeine = Cask::CaskLoader.load(cask_path("local-caffeine"))
+    transmission = Cask::CaskLoader.load(cask_path("local-transmission"))
+
+    Cask::Installer.new(caffeine).install
+    Cask::Installer.new(transmission).install
+
+    expect(caffeine).to be_installed
+    expect(transmission).to be_installed
+
+    described_class.uninstall_casks(caffeine, transmission)
+
+    expect(caffeine).not_to be_installed
+    expect(caffeine.config.appdir.join("Transmission.app")).not_to exist
+    expect(transmission).not_to be_installed
+    expect(transmission.config.appdir.join("Caffeine.app")).not_to exist
+  end
+
+  it "can uninstall Casks when the uninstall script is missing, but only when using `--force`" do
+    cask = Cask::CaskLoader.load(cask_path("with-uninstall-script-app"))
+
+    Cask::Installer.new(cask).install
+
+    expect(cask).to be_installed
+
+    FileUtils.rm_r(cask.config.appdir.join("MyFancyApp.app"))
+
+    expect { described_class.uninstall_casks(cask) }
+      .to raise_error(Cask::CaskError, /uninstall script .* does not exist/)
+
+    expect(cask).to be_installed
+
+    expect do
+      described_class.uninstall_casks(cask, force: true)
+    end.not_to raise_error
+
+    expect(cask).not_to be_installed
+  end
+
+  describe "when multiple versions of a cask are installed" do
+    let(:token) { "versioned-cask" }
+    let(:first_installed_version) { "1.2.3" }
+    let(:last_installed_version) { "4.5.6" }
+    let(:timestamped_versions) do
+      [
+        [first_installed_version, "123000"],
+        [last_installed_version,  "456000"],
+      ]
+    end
+    let(:caskroom_path) { Cask::Caskroom.path.join(token).tap(&:mkpath) }
+
+    before do
+      timestamped_versions.each do |timestamped_version|
+        caskroom_path.join(".metadata", *timestamped_version, "Casks").tap(&:mkpath)
+                     .join("#{token}.rb").open("w") do |caskfile|
+                       caskfile.puts <<~RUBY
+                         cask '#{token}' do
+                           version '#{timestamped_version[0]}'
+                         end
+                       RUBY
+                     end
+        caskroom_path.join(timestamped_version[0]).mkpath
+      end
+    end
+
+    it "uninstalls one version at a time" do
+      described_class.uninstall_casks(Cask::Cask.new("versioned-cask"))
+
+      expect(caskroom_path.join(first_installed_version)).to exist
+      expect(caskroom_path.join(last_installed_version)).not_to exist
+      expect(caskroom_path).to exist
+
+      described_class.uninstall_casks(Cask::Cask.new("versioned-cask"))
+
+      expect(caskroom_path.join(first_installed_version)).not_to exist
+      expect(caskroom_path).not_to exist
+    end
+  end
+
+  context "when Casks in Taps have been renamed or removed" do
+    let(:app) { Cask::Config.new.appdir.join("ive-been-renamed.app") }
+    let(:caskroom_path) { Cask::Caskroom.path.join("ive-been-renamed").tap(&:mkpath) }
+    let(:saved_caskfile) do
+      caskroom_path.join(".metadata", "latest", "timestamp", "Casks").join("ive-been-renamed.rb")
+    end
+
+    before do
+      app.tap(&:mkpath)
+         .join("Contents").tap(&:mkpath)
+         .join("Info.plist").tap { FileUtils.touch(_1) }
+
+      caskroom_path.mkpath
+
+      saved_caskfile.dirname.mkpath
+
+      File.write saved_caskfile, <<~RUBY
+        cask 'ive-been-renamed' do
+          version :latest
+
+          app 'ive-been-renamed.app'
+        end
+      RUBY
+    end
+
+    it "can still uninstall them" do
+      described_class.uninstall_casks(Cask::Cask.new("ive-been-renamed"))
+
+      expect(app).not_to exist
+      expect(caskroom_path).not_to exist
+    end
+  end
+end
diff --git a/Library/Homebrew/test/cask/upgrade_spec.rb b/Library/Homebrew/test/cask/upgrade_spec.rb
new file mode 100644
index 0000000000000..3b5455fcc4485
--- /dev/null
+++ b/Library/Homebrew/test/cask/upgrade_spec.rb
@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require "cask/upgrade"
+
+RSpec.describe Cask::Upgrade, :cask do
+  let(:version_latest_paths) do
+    [
+      version_latest.config.appdir.join("Caffeine Mini.app"),
+      version_latest.config.appdir.join("Caffeine Pro.app"),
+    ]
+  end
+  let(:version_latest) { Cask::CaskLoader.load("version-latest") }
+  let(:auto_updates_path) { auto_updates.config.appdir.join("MyFancyApp.app") }
+  let(:auto_updates) { Cask::CaskLoader.load("auto-updates") }
+  let(:local_transmission_path) { local_transmission.config.appdir.join("Transmission.app") }
+  let(:local_transmission) { Cask::CaskLoader.load("local-transmission") }
+  let(:local_caffeine_path) { local_caffeine.config.appdir.join("Caffeine.app") }
+  let(:local_caffeine) { Cask::CaskLoader.load("local-caffeine") }
+  let(:renamed_app) { Cask::CaskLoader.load("renamed-app") }
+  let(:renamed_app_old_path) { renamed_app.config.appdir.join("OldApp.app") }
+  let(:renamed_app_new_path) { renamed_app.config.appdir.join("NewApp.app") }
+  let(:args) { Homebrew::CLI::Args.new }
+
+  before do
+    installed.each do |cask|
+      Cask::Installer.new(Cask::CaskLoader.load(cask_path(cask))).install
+    end
+  end
+
+  context "when the upgrade is a dry run" do
+    let(:installed) do
+      [
+        "outdated/local-caffeine",
+        "outdated/local-transmission",
+        "outdated/auto-updates",
+        "outdated/version-latest",
+        "outdated/renamed-app",
+      ]
+    end
+
+    describe 'without --greedy it ignores the Casks with "version latest" or "auto_updates true"' do
+      it "would update all the installed Casks when no token is provided" do
+        expect(described_class).not_to receive(:upgrade_cask)
+
+        expect(local_caffeine).to be_installed
+        expect(local_caffeine_path).to be_a_directory
+        expect(local_caffeine.installed_version).to eq "1.2.2"
+
+        expect(local_transmission).to be_installed
+        expect(local_transmission_path).to be_a_directory
+        expect(local_transmission.installed_version).to eq "2.60"
+
+        expect(renamed_app).to be_installed
+        expect(renamed_app_old_path).to be_a_directory
+        expect(renamed_app_new_path).not_to be_a_directory
+        expect(renamed_app.installed_version).to eq "1.0.0"
+
+        described_class.upgrade_casks(dry_run: true, args:)
+
+        expect(local_caffeine).to be_installed
+        expect(local_caffeine_path).to be_a_directory
+        expect(local_caffeine.installed_version).to eq "1.2.2"
+
+        expect(local_transmission).to be_installed
+        expect(local_transmission_path).to be_a_directory
+        expect(local_transmission.installed_version).to eq "2.60"
+
+        expect(renamed_app).to be_installed
+        expect(renamed_app_old_path).to be_a_directory
+        expect(renamed_app_new_path).not_to be_a_directory
+        expect(renamed_app.installed_version).to eq "1.0.0"
+      end
+
+      it "would update only the Casks specified in the command line" do
+        expect(described_class).not_to receive(:upgrade_cask)
+
+        expect(local_caffeine).to be_installed
+        expect(local_caffeine_path).to be_a_directory
+        expect(local_caffeine.installed_version).to eq "1.2.2"
+
+        expect(local_transmission).to be_installed
+        expect(local_transmission_path).to be_a_directory
+        expect(local_transmission.installed_version).to eq "2.60"
+
+        described_class.upgrade_casks(local_caffeine, dry_run: true, args:)
+
+        expect(local_caffeine).to be_installed
+        expect(local_caffeine_path).to be_a_directory
+        expect(local_caffeine.installed_version).to eq "1.2.2"
+
+        expect(local_transmission).to be_installed
+        expect(local_transmission_path).to be_a_directory
+        expect(local_transmission.installed_version).to eq "2.60"
+      end
+
+      it 'would update "auto_updates" and "latest" Casks when their tokens are provided in the command line' do
+        expect(described_class).not_to receive(:upgrade_cask)
+
+        expect(local_caffeine).to be_installed
+        expect(local_caffeine_path).to be_a_directory
+        expect(local_caffeine.installed_version).to eq "1.2.2"
+
+        expect(auto_updates).to be_installed
+        expect(auto_updates_path).to be_a_directory
+        expect(auto_updates.installed_version).to eq "2.57"
+
+        expect(renamed_app).to be_installed
+        expect(renamed_app_old_path).to be_a_directory
+        expect(renamed_app_new_path).not_to be_a_directory
+        expect(renamed_app.installed_version).to eq "1.0.0"
+
+        described_class.upgrade_casks(local_caffeine, auto_updates, dry_run: true, args:)
+
+        expect(local_caffeine).to be_installed
+        expect(local_caffeine_path).to be_a_directory
+        expect(local_caffeine.installed_version).to eq "1.2.2"
+
+        expect(auto_updates).to be_installed
+        expect(auto_updates_path).to be_a_directory
+        expect(auto_updates.installed_version).to eq "2.57"
+
+        expect(renamed_app).to be_installed
+        expect(renamed_app_old_path).to be_a_directory
+        expect(renamed_app_new_path).not_to be_a_directory
+        expect(renamed_app.installed_version).to eq "1.0.0"
+      end
+    end
+
+    describe "with --greedy it checks additional Casks" do
+      it 'would include the Casks with "auto_updates true" or "version latest"' do
+        expect(described_class).not_to receive(:upgrade_cask)
+
+        expect(local_caffeine).to be_installed
+        expect(local_caffeine_path).to be_a_directory
+        expect(local_caffeine.installed_version).to eq "1.2.2"
+
+        expect(auto_updates).to be_installed
+        expect(auto_updates_path).to be_a_directory
+        expect(auto_updates.installed_version).to eq "2.57"
+
+        expect(local_transmission).to be_installed
+        expect(local_transmission_path).to be_a_directory
+        expect(local_transmission.installed_version).to eq "2.60"
+
+        expect(renamed_app).to be_installed
+        expect(renamed_app_old_path).to be_a_directory
+        expect(renamed_app_new_path).not_to be_a_directory
+        expect(renamed_app.installed_version).to eq "1.0.0"
+
+        expect(version_latest).to be_installed
+        # Change download sha so that :latest cask decides to update itself
+        version_latest.download_sha_path.write("fake download sha")
+        expect(version_latest.outdated_download_sha?).to be(true)
+
+        described_class.upgrade_casks(greedy: true, dry_run: true, args:)
+
+        expect(local_caffeine).to be_installed
+        expect(local_caffeine_path).to be_a_directory
+        expect(local_caffeine.installed_version).to eq "1.2.2"
+
+        expect(auto_updates).to be_installed
+        expect(auto_updates_path).to be_a_directory
+        expect(auto_updates.installed_version).to eq "2.57"
+
+        expect(local_transmission).to be_installed
+        expect(local_transmission_path).to be_a_directory
+        expect(local_transmission.installed_version).to eq "2.60"
+
+        expect(renamed_app).to be_installed
+        expect(renamed_app_old_path).to be_a_directory
+        expect(renamed_app_new_path).not_to be_a_directory
+        expect(renamed_app.installed_version).to eq "1.0.0"
+
+        expect(version_latest).to be_installed
+        expect(version_latest.outdated_download_sha?).to be(true)
+      end
+
+      it 'would update outdated Casks with "auto_updates true"' do
+        expect(described_class).not_to receive(:upgrade_cask)
+
+        expect(auto_updates).to be_installed
+        expect(auto_updates_path).to be_a_directory
+        expect(auto_updates.installed_version).to eq "2.57"
+
+        described_class.upgrade_casks(auto_updates, dry_run: true, greedy: true, args:)
+
+        expect(auto_updates).to be_installed
+        expect(auto_updates_path).to be_a_directory
+        expect(auto_updates.installed_version).to eq "2.57"
+      end
+
+      it 'would update outdated Casks with "version latest"' do
+        expect(described_class).not_to receive(:upgrade_cask)
+
+        expect(version_latest).to be_installed
+        expect(version_latest_paths).to all be_a_directory
+        expect(version_latest.installed_version).to eq "latest"
+        # Change download sha so that :latest cask decides to update itself
+        version_latest.download_sha_path.write("fake download sha")
+        expect(version_latest.outdated_download_sha?).to be(true)
+
+        described_class.upgrade_casks(version_latest, dry_run: true, greedy: true, args:)
+
+        expect(version_latest).to be_installed
+        expect(version_latest_paths).to all be_a_directory
+        expect(version_latest.installed_version).to eq "latest"
+        expect(version_latest.outdated_download_sha?).to be(true)
+      end
+    end
+  end
+
+  context "when an upgrade failed" do
+    let(:installed) do
+      [
+        "outdated/bad-checksum",
+        "outdated/will-fail-if-upgraded",
+      ]
+    end
+
+    output_reverted = Regexp.new <<~EOS
+      Warning: Reverting upgrade for Cask .*
+    EOS
+
+    it "restores the old Cask if the upgrade failed" do
+      will_fail_if_upgraded = Cask::CaskLoader.load("will-fail-if-upgraded")
+      will_fail_if_upgraded_path = will_fail_if_upgraded.config.appdir.join("container")
+
+      expect(will_fail_if_upgraded).to be_installed
+      expect(will_fail_if_upgraded_path).to be_a_file
+      expect(will_fail_if_upgraded.installed_version).to eq "1.2.2"
+
+      expect do
+        described_class.upgrade_casks(will_fail_if_upgraded, args:)
+      end.to raise_error(Cask::CaskError).and output(output_reverted).to_stderr
+
+      expect(will_fail_if_upgraded).to be_installed
+      expect(will_fail_if_upgraded_path).to be_a_file
+      expect(will_fail_if_upgraded.installed_version).to eq "1.2.2"
+      expect(will_fail_if_upgraded.staged_path).not_to exist
+    end
+
+    it "does not restore the old Cask if the upgrade failed pre-install" do
+      bad_checksum = Cask::CaskLoader.load("bad-checksum")
+      bad_checksum_path = bad_checksum.config.appdir.join("Caffeine.app")
+
+      expect(bad_checksum).to be_installed
+      expect(bad_checksum_path).to be_a_directory
+      expect(bad_checksum.installed_version).to eq "1.2.2"
+
+      expect do
+        described_class.upgrade_casks(bad_checksum, args:)
+      end.to raise_error(ChecksumMismatchError).and(not_to_output(output_reverted).to_stderr)
+
+      expect(bad_checksum).to be_installed
+      expect(bad_checksum_path).to be_a_directory
+      expect(bad_checksum.installed_version).to eq "1.2.2"
+      expect(bad_checksum.staged_path).not_to exist
+    end
+  end
+
+  context "when there were multiple failures" do
+    let(:installed) do
+      [
+        "outdated/bad-checksum",
+        "outdated/local-transmission",
+        "outdated/bad-checksum2",
+      ]
+    end
+
+    it "does not end the upgrade process" do
+      bad_checksum = Cask::CaskLoader.load("bad-checksum")
+      bad_checksum_path = bad_checksum.config.appdir.join("Caffeine.app")
+
+      bad_checksum_2 = Cask::CaskLoader.load("bad-checksum2")
+      bad_checksum_2_path = bad_checksum_2.config.appdir.join("container")
+
+      expect(bad_checksum).to be_installed
+      expect(bad_checksum_path).to be_a_directory
+      expect(bad_checksum.installed_version).to eq "1.2.2"
+
+      expect(local_transmission).to be_installed
+      expect(local_transmission_path).to be_a_directory
+      expect(local_transmission.installed_version).to eq "2.60"
+
+      expect(bad_checksum_2).to be_installed
+      expect(bad_checksum_2_path).to be_a_file
+      expect(bad_checksum_2.installed_version).to eq "1.2.2"
+
+      expect do
+        described_class.upgrade_casks(args:)
+      end.to raise_error(Cask::MultipleCaskErrors)
+
+      expect(bad_checksum).to be_installed
+      expect(bad_checksum_path).to be_a_directory
+      expect(bad_checksum.installed_version).to eq "1.2.2"
+      expect(bad_checksum.staged_path).not_to exist
+
+      expect(local_transmission).to be_installed
+      expect(local_transmission_path).to be_a_directory
+      expect(local_transmission.installed_version).to eq "2.61"
+
+      expect(bad_checksum_2).to be_installed
+      expect(bad_checksum_2_path).to be_a_file
+      expect(bad_checksum_2.installed_version).to eq "1.2.2"
+      expect(bad_checksum_2.staged_path).not_to exist
+    end
+  end
+end
diff --git a/Library/Homebrew/test/cask/utils_spec.rb b/Library/Homebrew/test/cask/utils_spec.rb
new file mode 100644
index 0000000000000..638fbaad987f4
--- /dev/null
+++ b/Library/Homebrew/test/cask/utils_spec.rb
@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+RSpec.describe Cask::Utils do
+  let(:command) { NeverSudoSystemCommand }
+  let(:dir) { mktmpdir }
+  let(:path) { dir/"a/b/c" }
+  let(:link) { dir/"link" }
+
+  describe "::gain_permissions_mkpath" do
+    it "creates a directory" do
+      expect(path).not_to exist
+      described_class.gain_permissions_mkpath(path, command:)
+      expect(path).to be_a_directory
+      described_class.gain_permissions_mkpath(path, command:)
+      expect(path).to be_a_directory
+    end
+
+    context "when parent directory is not writable" do
+      it "creates a directory with `sudo`" do
+        FileUtils.chmod "-w", dir
+        expect(dir).not_to be_writable
+
+        expect(command).to receive(:run!).exactly(:once).and_wrap_original do |original, *args, **options|
+          FileUtils.chmod "+w", dir
+          original.call(*args, **options)
+          FileUtils.chmod "-w", dir
+        end
+
+        expect(path).not_to exist
+        described_class.gain_permissions_mkpath(path, command:)
+        expect(path).to be_a_directory
+        described_class.gain_permissions_mkpath(path, command:)
+        expect(path).to be_a_directory
+
+        expect(dir).not_to be_writable
+        FileUtils.chmod "+w", dir
+      end
+    end
+  end
+
+  describe "::gain_permissions_remove" do
+    it "removes the symlink, not the file it points to" do
+      path.dirname.mkpath
+      FileUtils.touch path
+      FileUtils.ln_s path, link
+
+      expect(path).to be_a_file
+      expect(link).to be_a_symlink
+      expect(link.readlink).to eq path
+
+      described_class.gain_permissions_remove(link, command:)
+
+      expect(path).to be_a_file
+      expect(link).not_to exist
+
+      described_class.gain_permissions_remove(path, command:)
+
+      expect(path).not_to exist
+    end
+
+    it "removes the symlink, not the directory it points to" do
+      path.mkpath
+      FileUtils.ln_s path, link
+
+      expect(path).to be_a_directory
+      expect(link).to be_a_symlink
+      expect(link.readlink).to eq path
+
+      described_class.gain_permissions_remove(link, command:)
+
+      expect(path).to be_a_directory
+      expect(link).not_to exist
+
+      described_class.gain_permissions_remove(path, command:)
+
+      expect(path).not_to exist
+    end
+  end
+end
diff --git a/Library/Homebrew/test/cask_dependent_spec.rb b/Library/Homebrew/test/cask_dependent_spec.rb
index 9e6d041ae5905..48e09d16fe67b 100644
--- a/Library/Homebrew/test/cask_dependent_spec.rb
+++ b/Library/Homebrew/test/cask_dependent_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cask/cask_loader"
 require "cask_dependent"
 
-describe CaskDependent, :needs_macos do
+RSpec.describe CaskDependent, :needs_macos do
   subject(:dependent) { described_class.new test_cask }
 
   let :test_cask do
diff --git a/Library/Homebrew/test/caveats_spec.rb b/Library/Homebrew/test/caveats_spec.rb
index 59191486912fb..c9231e2615def 100644
--- a/Library/Homebrew/test/caveats_spec.rb
+++ b/Library/Homebrew/test/caveats_spec.rb
@@ -1,16 +1,15 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula"
 require "caveats"
 
-describe Caveats do
+RSpec.describe Caveats do
   subject(:caveats) { described_class.new(f) }
 
   let(:f) { formula { url "foo-1.0" } }
 
   specify "#f" do
-    expect(caveats.f).to eq(f)
+    expect(caveats.formula).to eq(f)
   end
 
   describe "#empty?" do
@@ -32,159 +31,108 @@ def caveats
   end
 
   describe "#caveats" do
-    context "when f.plist is not nil", :needs_macos do
-      it "prints error when no launchd is present" do
-        f = formula do
-          url "foo-1.0"
-          def plist
-            "plist_test.plist"
-          end
-        end
-        allow_any_instance_of(Object).to receive(:which).with("launchctl").and_return(nil)
-        expect(described_class.new(f).caveats).to include("provides a launchd plist which can only be used on macOS!")
-      end
-
-      it "prints plist startup information when f.plist_startup is not nil" do
-        f = formula do
-          url "foo-1.0"
-          def plist
-            "plist_test.plist"
-          end
-          plist_options startup: true
-        end
-        expect(described_class.new(f).caveats).to include("startup")
+    context "when service block is defined" do
+      before do
+        allow(Utils::Service).to receive_messages(launchctl?: true, systemctl?: true)
       end
 
-      it "prints plist login information when f.plist_startup is nil" do
+      it "gives information about service" do
         f = formula do
           url "foo-1.0"
-          def plist
-            "plist_test.plist"
+          service do
+            run [bin/"php", "test"]
           end
         end
-        expect(described_class.new(f).caveats).to include("login")
-      end
+        caveats = described_class.new(f).caveats
 
-      it "gives information about restarting services after upgrade" do
-        f = formula do
-          url "foo-1.0"
-          def plist
-            "plist_test.plist"
-          end
-          plist_options startup: true
-        end
-        f_obj = described_class.new(f)
-        plist_path = mktmpdir/"plist"
-        FileUtils.touch plist_path
-        allow(f_obj).to receive(:plist_path).and_return(plist_path)
-        allow(Homebrew).to receive(:_system).and_return(true)
-        allow(Homebrew).to receive(:_system).with("/bin/launchctl list #{f.plist_name} &>/dev/null").and_return(true)
-        allow(plist_path).to receive(:symlink?).and_return(true)
-        expect(f_obj.caveats).to include("restart #{f.full_name}")
-        expect(f_obj.caveats).to include("sudo")
+        expect(f.service?).to be(true)
+        expect(caveats).to include("#{f.bin}/php test")
+        expect(caveats).to include("background service")
       end
 
-      it "gives information about plist_manual" do
+      it "prints warning when no service daemon is found" do
         f = formula do
           url "foo-1.0"
-          def plist
-            "plist_test.plist"
+          service do
+            run [bin/"cmd"]
           end
-          plist_options manual: "foo"
         end
-        caveats = described_class.new(f).caveats
-
-        expect(caveats).to include("background service")
-        expect(caveats).to include(f.plist_manual)
+        expect(Utils::Service).to receive(:launchctl?).and_return(false)
+        expect(Utils::Service).to receive(:systemctl?).and_return(false)
+        expect(described_class.new(f).caveats).to include("service which can only be used on macOS or systemd!")
       end
 
-      it "gives information about service" do
+      it "prints service startup information when service.require_root is true" do
         f = formula do
           url "foo-1.0"
           service do
-            run [bin/"php", "test"]
+            run [bin/"cmd"]
+            require_root true
           end
         end
-        caveats = described_class.new(f).caveats
-
-        expect(f.service?).to be(true)
-        expect(caveats).to include("#{f.bin}/php test")
-        expect(caveats).to include("background service")
+        expect(Utils::Service).to receive(:running?).with(f).once.and_return(false)
+        expect(described_class.new(f).caveats).to include("startup")
       end
 
-      it "warns about brew failing under tmux" do
+      it "prints service login information" do
         f = formula do
           url "foo-1.0"
-          def plist
-            "plist_test.plist"
+          service do
+            run [bin/"cmd"]
           end
         end
-        ENV["HOMEBREW_TMUX"] = "1"
-        allow(Homebrew).to receive(:_system).and_return(true)
-        allow(Homebrew).to receive(:_system).with("/usr/bin/pbpaste").and_return(false)
-        caveats = described_class.new(f).caveats
-
-        expect(caveats).to include("WARNING:")
-        expect(caveats).to include("tmux")
+        expect(Utils::Service).to receive(:running?).with(f).once.and_return(false)
+        expect(described_class.new(f).caveats).to include("restart at login")
       end
-    end
 
-    context "when f.service is not nil" do
-      it "prints warning when no service deamon is found" do
+      it "gives information about require_root restarting services after upgrade" do
         f = formula do
           url "foo-1.0"
           service do
             run [bin/"cmd"]
+            require_root true
           end
-          plist_options startup: true
         end
-
-        allow_any_instance_of(Object).to receive(:which).with("launchctl").and_return(nil)
-        allow_any_instance_of(Object).to receive(:which).with("systemctl").and_return(nil)
-        expect(described_class.new(f).caveats).to include("service which can only be used on macOS or systemd!")
+        f_obj = described_class.new(f)
+        expect(Utils::Service).to receive(:running?).with(f).once.and_return(true)
+        expect(f_obj.caveats).to include("  sudo brew services restart #{f.full_name}")
       end
 
-      it "prints service startup information when f.plist_startup is not nil" do
+      it "gives information about user restarting services after upgrade" do
         f = formula do
           url "foo-1.0"
           service do
             run [bin/"cmd"]
           end
-          plist_options startup: true
         end
-        cmd = "#{HOMEBREW_CELLAR}/formula_name/1.0/bin/cmd"
-        allow(Homebrew).to receive(:_system).and_return(true)
-        allow(Homebrew).to receive(:_system).with("ps aux | grep #{cmd}").and_return(false)
-        expect(described_class.new(f).caveats).to include("startup")
+        f_obj = described_class.new(f)
+        expect(Utils::Service).to receive(:running?).with(f).once.and_return(true)
+        expect(f_obj.caveats).to include("  brew services restart #{f.full_name}")
       end
 
-      it "prints service login information when f.plist_startup is nil" do
+      it "gives information about require_root starting services after upgrade" do
         f = formula do
           url "foo-1.0"
           service do
             run [bin/"cmd"]
+            require_root true
           end
         end
-        cmd = "#{HOMEBREW_CELLAR}/formula_name/1.0/bin/cmd"
-        allow(Homebrew).to receive(:_system).and_return(true)
-        allow(Homebrew).to receive(:_system).with("ps aux | grep #{cmd}").and_return(false)
-        expect(described_class.new(f).caveats).to include("login")
+        f_obj = described_class.new(f)
+        expect(Utils::Service).to receive(:running?).with(f).once.and_return(false)
+        expect(f_obj.caveats).to include("  sudo brew services start #{f.full_name}")
       end
 
-      it "gives information about restarting services after upgrade" do
+      it "gives information about user starting services after upgrade" do
         f = formula do
           url "foo-1.0"
           service do
             run [bin/"cmd"]
           end
-          plist_options startup: true
         end
-        cmd = "#{HOMEBREW_CELLAR}/formula_name/1.0/bin/cmd"
         f_obj = described_class.new(f)
-        allow(Homebrew).to receive(:_system).and_return(true)
-        allow(Homebrew).to receive(:_system).with("ps aux | grep #{cmd}").and_return(true)
-        expect(f_obj.caveats).to include("restart #{f.full_name}")
-        expect(f_obj.caveats).to include("sudo")
+        expect(Utils::Service).to receive(:running?).with(f).once.and_return(false)
+        expect(f_obj.caveats).to include("  brew services start #{f.full_name}")
       end
 
       it "gives information about service manual command" do
@@ -198,18 +146,30 @@ def plist
         cmd = "#{HOMEBREW_CELLAR}/formula_name/1.0/bin/cmd"
         caveats = described_class.new(f).caveats
 
-        expect(caveats).to include("background service")
+        expect(caveats).to include("if you don't want/need a background service")
         expect(caveats).to include("VAR=\"foo\" #{cmd} start")
       end
+
+      it "prints info when there are custom service files" do
+        f = formula do
+          url "foo-1.0"
+          service do
+            name macos: "custom.mxcl.foo", linux: "custom.foo"
+          end
+        end
+        expect(Utils::Service).to receive(:installed?).with(f).once.and_return(true)
+        expect(Utils::Service).to receive(:running?).with(f).once.and_return(false)
+        expect(described_class.new(f).caveats).to include("restart at login")
+      end
     end
 
     context "when f.keg_only is not nil" do
-      let(:f) {
+      let(:f) do
         formula do
           url "foo-1.0"
           keg_only "some reason"
         end
-      }
+      end
       let(:caveats) { described_class.new(f).caveats }
 
       it "tells formula is keg_only" do
@@ -247,37 +207,72 @@ def plist
           expect(caveats).to include("#{f.opt_share}/pkgconfig")
         end
       end
+
+      context "when joining different caveat types together" do
+        let(:f) do
+          formula do
+            url "foo-1.0"
+            keg_only "some reason"
+
+            def caveats
+              "something else"
+            end
+
+            service do
+              run [bin/"cmd"]
+            end
+          end
+        end
+
+        let(:caveats) { described_class.new(f).caveats }
+
+        it "adds the correct amount of new lines to the output" do
+          expect(Utils::Service).to receive(:launchctl?).at_least(:once).and_return(true)
+          expect(caveats).to include("something else")
+          expect(caveats).to include("keg-only")
+          expect(caveats).to include("if you don't want/need a background service")
+          expect(caveats.count("\n")).to eq(9)
+        end
+      end
     end
 
     describe "shell completions" do
-      let(:f) {
+      let(:f) do
         formula do
           url "foo-1.0"
         end
-      }
+      end
       let(:caveats) { described_class.new(f).caveats }
       let(:path) { f.prefix.resolved_path }
 
+      let(:bash_completion_dir) { path/"etc/bash_completion.d" }
+      let(:fish_vendor_completions) { path/"share/fish/vendor_completions.d" }
+      let(:zsh_site_functions) { path/"share/zsh/site-functions" }
+
       before do
-        allow_any_instance_of(Pathname).to receive(:children).and_return([Pathname.new("child")])
+        # don't try to load/fetch gcc/glibc
+        allow(DevelopmentTools).to receive_messages(needs_libc_formula?: false, needs_compiler_formula?: false)
+
         allow_any_instance_of(Object).to receive(:which).with(any_args).and_return(Pathname.new("shell"))
-        allow(Utils::Shell).to receive(:preferred).and_return(nil)
-        allow(Utils::Shell).to receive(:parent).and_return(nil)
+        allow(Utils::Shell).to receive_messages(preferred: nil, parent: nil)
       end
 
-      it "gives dir where Bash completions have been installed" do
-        (path/"etc/bash_completion.d").mkpath
+      it "includes where Bash completions have been installed to" do
+        bash_completion_dir.mkpath
+        FileUtils.touch bash_completion_dir/f.name
         expect(caveats).to include(HOMEBREW_PREFIX/"etc/bash_completion.d")
       end
 
-      it "gives dir where zsh completions have been installed" do
-        (path/"share/zsh/site-functions").mkpath
-        expect(caveats).to include(HOMEBREW_PREFIX/"share/zsh/site-functions")
+      it "includes where fish completions have been installed to" do
+        fish_vendor_completions.mkpath
+        FileUtils.touch fish_vendor_completions/f.name
+        expect(caveats).to include(HOMEBREW_PREFIX/"share/fish/vendor_completions.d")
       end
 
-      it "gives dir where fish completions have been installed" do
-        (path/"share/fish/vendor_completions.d").mkpath
-        expect(caveats).to include(HOMEBREW_PREFIX/"share/fish/vendor_completions.d")
+      it "includes where zsh completions have been installed to" do
+        zsh_site_functions.mkpath
+        FileUtils.touch zsh_site_functions/f.name
+        expect(caveats).to include(HOMEBREW_PREFIX/"share/zsh/site-functions")
       end
     end
   end
diff --git a/Library/Homebrew/test/checksum_spec.rb b/Library/Homebrew/test/checksum_spec.rb
index 9216126dd029e..e1b7e28c17288 100644
--- a/Library/Homebrew/test/checksum_spec.rb
+++ b/Library/Homebrew/test/checksum_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "checksum"
 
-describe Checksum do
+RSpec.describe Checksum do
   describe "#empty?" do
     subject { described_class.new("") }
 
diff --git a/Library/Homebrew/test/checksum_verification_spec.rb b/Library/Homebrew/test/checksum_verification_spec.rb
index b1a7a7f624d70..3664e419a1236 100644
--- a/Library/Homebrew/test/checksum_verification_spec.rb
+++ b/Library/Homebrew/test/checksum_verification_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula"
 
-describe Formula do
+RSpec.describe Formula do
   def formula(&block)
     super do
       url "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz"
@@ -13,23 +12,27 @@ def formula(&block)
 
   describe "#brew" do
     it "does not raise an error when the checksum matches" do
-      expect {
+      expect do
         f = formula do
           sha256 TESTBALL_SHA256
         end
 
-        f.brew {}
-      }.not_to raise_error
+        f.brew do
+          # do nothing
+        end
+      end.not_to raise_error
     end
 
     it "raises an error when the checksum doesn't match" do
-      expect {
+      expect do
         f = formula do
           sha256 "dcbf5f44743b74add648c7e35e414076632fa3b24463d68d1f6afc5be77024f8"
         end
 
-        f.brew {}
-      }.to raise_error(ChecksumMismatchError)
+        f.brew do
+          # do nothing
+        end
+      end.to raise_error(ChecksumMismatchError)
     end
   end
 end
diff --git a/Library/Homebrew/test/cleaner_spec.rb b/Library/Homebrew/test/cleaner_spec.rb
index a9c3d1f667a0e..f5f51a29418b0 100644
--- a/Library/Homebrew/test/cleaner_spec.rb
+++ b/Library/Homebrew/test/cleaner_spec.rb
@@ -1,21 +1,20 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cleaner"
 require "formula"
 
-describe Cleaner do
+RSpec.describe Cleaner do
   include FileUtils
 
-  subject(:cleaner) { described_class.new(f) }
+  describe "#clean" do
+    subject(:cleaner) { described_class.new(f) }
 
-  let(:f) { formula("cleaner_test") { url "foo-1.0" } }
+    let(:f) { formula("cleaner_test") { url "foo-1.0" } }
 
-  before do
-    f.prefix.mkpath
-  end
+    before do
+      f.prefix.mkpath
+    end
 
-  describe "#clean" do
     it "cleans files" do
       f.bin.mkpath
       f.lib.mkpath
@@ -156,48 +155,103 @@
       expect(arch_file).not_to exist
       expect(name_file).to exist
     end
+
+    it "removes '*.dist-info/direct_url.json' files" do
+      dir = f.lib/"python3.12/site-packages/test.dist-info"
+      file = dir/"direct_url.json"
+      unrelated_file = dir/"METADATA"
+      unrelated_dir_file = f.lib/"direct_url.json"
+
+      dir.mkpath
+      touch file
+      touch unrelated_file
+      touch unrelated_dir_file
+
+      cleaner.clean
+
+      expect(file).not_to exist
+      expect(unrelated_file).to exist
+      expect(unrelated_dir_file).to exist
+    end
+
+    it "removes '*.dist-info/RECORD' files" do
+      dir = f.lib/"python3.12/site-packages/test.dist-info"
+      file = dir/"RECORD"
+      unrelated_file = dir/"METADATA"
+      unrelated_dir_file = f.lib/"RECORD"
+
+      dir.mkpath
+      touch file
+      touch unrelated_file
+      touch unrelated_dir_file
+
+      cleaner.clean
+
+      expect(file).not_to exist
+      expect(unrelated_file).to exist
+      expect(unrelated_dir_file).to exist
+    end
+
+    it "modifies '*.dist-info/INSTALLER' files" do
+      file = f.lib/"python3.12/site-packages/test.dist-info/INSTALLER"
+      file.dirname.mkpath
+      file.write "pip\n"
+
+      cleaner.clean
+
+      expect(file.read).to eq "brew\n"
+    end
   end
 
   describe "::skip_clean" do
+    def stub_formula_skip_clean(skip_paths)
+      formula("cleaner_test") do
+        url "foo-1.0"
+
+        skip_clean skip_paths
+      end
+    end
+
     it "adds paths that should be skipped" do
-      f.class.skip_clean "bin"
+      f = stub_formula_skip_clean("bin")
       f.bin.mkpath
 
-      cleaner.clean
+      described_class.new(f).clean
 
       expect(f.bin).to be_a_directory
     end
 
     it "also skips empty sub-directories under the added paths" do
-      f.class.skip_clean "bin"
+      f = stub_formula_skip_clean("bin")
       subdir = f.bin/"subdir"
       subdir.mkpath
 
-      cleaner.clean
+      described_class.new(f).clean
 
       expect(f.bin).to be_a_directory
       expect(subdir).to be_a_directory
     end
 
     it "allows skipping broken symlinks" do
-      f.class.skip_clean "symlink"
+      f = stub_formula_skip_clean("symlink")
+      f.prefix.mkpath
       symlink = f.prefix/"symlink"
       ln_s "target", symlink
 
-      cleaner.clean
+      described_class.new(f).clean
 
       expect(symlink).to be_a_symlink
     end
 
     it "allows skipping symlinks pointing to an empty directory" do
-      f.class.skip_clean "c"
+      f = stub_formula_skip_clean("c")
       dir = f.prefix/"b"
       symlink = f.prefix/"c"
 
       dir.mkpath
       ln_s dir.basename, symlink
 
-      cleaner.clean
+      described_class.new(f).clean
 
       expect(dir).not_to exist
       expect(symlink).to be_a_symlink
@@ -205,14 +259,14 @@
     end
 
     it "allows skipping symlinks whose target was pruned before" do
-      f.class.skip_clean "a"
+      f = stub_formula_skip_clean("a")
       dir = f.prefix/"b"
       symlink = f.prefix/"a"
 
       dir.mkpath
       ln_s dir.basename, symlink
 
-      cleaner.clean
+      described_class.new(f).clean
 
       expect(dir).not_to exist
       expect(symlink).to be_a_symlink
@@ -220,37 +274,40 @@
     end
 
     it "allows skipping '.la' files" do
+      f = stub_formula_skip_clean(:la)
+
       file = f.lib/"foo.la"
 
-      f.class.skip_clean :la
       f.lib.mkpath
       touch file
 
-      cleaner.clean
+      described_class.new(f).clean
 
       expect(file).to exist
     end
 
     it "allows skipping sub-directories" do
+      f = stub_formula_skip_clean("lib/subdir")
+
       dir = f.lib/"subdir"
-      f.class.skip_clean "lib/subdir"
 
       dir.mkpath
 
-      cleaner.clean
+      described_class.new(f).clean
 
       expect(dir).to be_a_directory
     end
 
     it "allows skipping paths relative to prefix" do
+      f = stub_formula_skip_clean("bin/a")
+
       dir1 = f.bin/"a"
       dir2 = f.lib/"bin/a"
 
-      f.class.skip_clean "bin/a"
       dir1.mkpath
       dir2.mkpath
 
-      cleaner.clean
+      described_class.new(f).clean
 
       expect(dir1).to exist
       expect(dir2).not_to exist
diff --git a/Library/Homebrew/test/cleanup_spec.rb b/Library/Homebrew/test/cleanup_spec.rb
index 477de25fcd408..e622a1d8be1c3 100644
--- a/Library/Homebrew/test/cleanup_spec.rb
+++ b/Library/Homebrew/test/cleanup_spec.rb
@@ -1,4 +1,3 @@
-# typed: false
 # frozen_string_literal: true
 
 require "test/support/fixtures/testball"
@@ -6,9 +5,7 @@
 require "cask/cache"
 require "fileutils"
 
-using Homebrew::Cleanup::CleanupRefinement
-
-describe Homebrew::Cleanup do
+RSpec.describe Homebrew::Cleanup do
   subject(:cleanup) { described_class.new }
 
   let(:ds_store) { Pathname.new("#{HOMEBREW_CELLAR}/.DS_Store") }
@@ -27,9 +24,7 @@
     FileUtils.rm_rf HOMEBREW_LIBRARY/"Homebrew"
   end
 
-  describe "::CleanupRefinement::prune?" do
-    alias_matcher :be_pruned, :be_prune
-
+  describe "::prune?" do
     subject(:path) { HOMEBREW_CACHE/"foo" }
 
     before do
@@ -37,13 +32,13 @@
     end
 
     it "returns true when ctime and mtime < days_default" do
-      allow_any_instance_of(Pathname).to receive(:ctime).and_return(2.days.ago)
-      allow_any_instance_of(Pathname).to receive(:mtime).and_return(2.days.ago)
-      expect(path.prune?(1)).to be true
+      allow_any_instance_of(Pathname).to receive(:ctime).and_return((DateTime.now - 2).to_time)
+      allow_any_instance_of(Pathname).to receive(:mtime).and_return((DateTime.now - 2).to_time)
+      expect(described_class.prune?(path, 1)).to be true
     end
 
     it "returns false when ctime and mtime >= days_default" do
-      expect(path.prune?(2)).to be false
+      expect(described_class.prune?(path, 2)).to be false
     end
   end
 
@@ -71,11 +66,11 @@
     end
 
     context "when it can't remove a keg" do
-      let(:f1) { Class.new(Testball) { version "0.1" }.new }
-      let(:f2) { Class.new(Testball) { version "0.2" }.new }
+      let(:formula_zero_dot_one) { Class.new(Testball) { version "0.1" }.new }
+      let(:formula_zero_dot_two) { Class.new(Testball) { version "0.2" }.new }
 
       before do
-        [f1, f2].each do |f|
+        [formula_zero_dot_one, formula_zero_dot_two].each do |f|
           f.brew do
             f.install
           end
@@ -89,15 +84,99 @@
       end
 
       it "doesn't remove any kegs" do
-        cleanup.cleanup_formula f2
-        expect(f1.installed_kegs.size).to eq(2)
+        cleanup.cleanup_formula formula_zero_dot_one
+        expect(formula_zero_dot_one.installed_kegs.size).to eq(2)
       end
 
       it "lists the unremovable kegs" do
-        cleanup.cleanup_formula f2
-        expect(cleanup.unremovable_kegs).to contain_exactly(f1.installed_kegs[0])
+        cleanup.cleanup_formula formula_zero_dot_two
+        expect(cleanup.unremovable_kegs).to contain_exactly(formula_zero_dot_one.installed_kegs[0])
+      end
+    end
+  end
+
+  describe "::prune_prefix_symlinks_and_directories" do
+    let(:lib) { HOMEBREW_PREFIX/"lib" }
+
+    before do
+      lib.mkpath
+    end
+
+    it "keeps required empty directories" do
+      cleanup.prune_prefix_symlinks_and_directories
+      expect(lib).to exist
+      expect(lib.children).to be_empty
+    end
+
+    it "removes broken symlinks" do
+      FileUtils.ln_s lib/"foo", lib/"bar"
+      FileUtils.touch lib/"baz"
+
+      cleanup.prune_prefix_symlinks_and_directories
+      expect(lib).to exist
+      expect(lib.children).to eq([lib/"baz"])
+    end
+
+    it "removes empty directories" do
+      dir = lib/"test"
+      dir.mkpath
+      file = lib/"keep/file"
+      file.dirname.mkpath
+      FileUtils.touch file
+
+      cleanup.prune_prefix_symlinks_and_directories
+      expect(dir).not_to exist
+      expect(file).to exist
+    end
+
+    context "when nested directories exist with only broken symlinks" do
+      let(:dir) { HOMEBREW_PREFIX/"lib/foo" }
+      let(:child_dir) { dir/"bar" }
+      let(:grandchild_dir) { child_dir/"baz" }
+      let(:broken_link) { dir/"broken" }
+      let(:link_to_broken_link) { child_dir/"another-broken" }
+
+      before do
+        grandchild_dir.mkpath
+        FileUtils.ln_s dir/"missing", broken_link
+        FileUtils.ln_s broken_link, link_to_broken_link
+      end
+
+      it "removes broken symlinks and resulting empty directories" do
+        cleanup.prune_prefix_symlinks_and_directories
+        expect(dir).not_to exist
+      end
+
+      it "doesn't remove anything and only prints removal steps if `dry_run` is true" do
+        expect do
+          described_class.new(dry_run: true).prune_prefix_symlinks_and_directories
+        end.to output(<<~EOS).to_stdout
+          Would remove (broken link): #{link_to_broken_link}
+          Would remove (broken link): #{broken_link}
+          Would remove (empty directory): #{grandchild_dir}
+          Would remove (empty directory): #{child_dir}
+          Would remove (empty directory): #{dir}
+        EOS
+
+        expect(broken_link).to be_a_symlink
+        expect(link_to_broken_link).to be_a_symlink
+        expect(grandchild_dir).to exist
       end
     end
+
+    it "removes broken symlinks for uninstalled migrated Casks" do
+      caskroom = Cask::Caskroom.path
+      old_cask_dir = caskroom/"old"
+      new_cask_dir = caskroom/"new"
+      unrelated_cask_dir = caskroom/"other"
+      unrelated_cask_dir.mkpath
+      FileUtils.ln_s new_cask_dir, old_cask_dir
+
+      cleanup.prune_prefix_symlinks_and_directories
+      expect(unrelated_cask_dir).to exist
+      expect(old_cask_dir).not_to be_a_symlink
+      expect(old_cask_dir).not_to exist
+    end
   end
 
   specify "::cleanup_formula" do
@@ -171,7 +250,7 @@
     end
 
     context "when given a `:latest` cask" do
-      let(:cask) { Cask::CaskLoader.load("latest-with-appcast") }
+      let(:cask) { Cask::CaskLoader.load("latest") }
 
       it "does not remove the download for the latest version" do
         download = Cask::Cache.path/"#{cask.token}--#{cask.version}"
@@ -186,8 +265,8 @@
       it "removes the download for the latest version after 30 days" do
         download = Cask::Cache.path/"#{cask.token}--#{cask.version}"
 
-        allow(download).to receive(:ctime).and_return(30.days.ago - 1.hour)
-        allow(download).to receive(:mtime).and_return(30.days.ago - 1.hour)
+        allow(download).to receive_messages(ctime: (DateTime.now - 30).to_time - (60 * 60),
+                                            mtime: (DateTime.now - 30).to_time - (60 * 60))
 
         cleanup.cleanup_cask(cask)
 
@@ -209,15 +288,15 @@
     end
 
     it "cleans up logs if older than 30 days" do
-      allow_any_instance_of(Pathname).to receive(:ctime).and_return(31.days.ago)
-      allow_any_instance_of(Pathname).to receive(:mtime).and_return(31.days.ago)
+      allow_any_instance_of(Pathname).to receive(:ctime).and_return((DateTime.now - 31).to_time)
+      allow_any_instance_of(Pathname).to receive(:mtime).and_return((DateTime.now - 31).to_time)
       cleanup.cleanup_logs
       expect(path).not_to exist
     end
 
     it "does not clean up logs less than 30 days old" do
-      allow_any_instance_of(Pathname).to receive(:ctime).and_return(15.days.ago)
-      allow_any_instance_of(Pathname).to receive(:mtime).and_return(15.days.ago)
+      allow_any_instance_of(Pathname).to receive(:ctime).and_return((DateTime.now - 15).to_time)
+      allow_any_instance_of(Pathname).to receive(:mtime).and_return((DateTime.now - 15).to_time)
       cleanup.cleanup_logs
       expect(path).to exist
     end
@@ -338,7 +417,7 @@
         FileUtils.touch testball
         FileUtils.touch testball_resource
         (HOMEBREW_CELLAR/"testball"/"0.0.1").mkpath
-        FileUtils.touch(CoreTap.instance.formula_dir/"testball.rb")
+        FileUtils.touch(CoreTap.instance.new_formula_path("testball"))
       end
 
       it "cleans up file if outdated" do
@@ -364,4 +443,41 @@
       end
     end
   end
+
+  describe "::cleanup_python_site_packages" do
+    context "when cleaning up Python modules" do
+      let(:foo_module) { (HOMEBREW_PREFIX/"lib/python3.99/site-packages/foo") }
+      let(:foo_pycache) { (foo_module/"__pycache__") }
+      let(:foo_pyc) { (foo_pycache/"foo.cypthon-399.pyc") }
+
+      before do
+        foo_pycache.mkpath
+        FileUtils.touch foo_pyc
+      end
+
+      it "cleans up stray `*.pyc` files" do
+        cleanup.cleanup_python_site_packages
+        expect(foo_pyc).not_to exist
+      end
+
+      it "retains `*.pyc` files of installed modules" do
+        FileUtils.touch foo_module/"__init__.py"
+
+        cleanup.cleanup_python_site_packages
+        expect(foo_pyc).to exist
+      end
+    end
+
+    it "cleans up stale `*.pyc` files in the top-level `__pycache__`" do
+      pycache = HOMEBREW_PREFIX/"lib/python3.99/site-packages/__pycache__"
+      foo_pyc = pycache/"foo.cypthon-3.99.pyc"
+      pycache.mkpath
+      FileUtils.touch foo_pyc
+
+      allow_any_instance_of(Pathname).to receive(:ctime).and_return(Time.now - (2 * 60 * 60 * 24))
+      allow_any_instance_of(Pathname).to receive(:mtime).and_return(Time.now - (2 * 60 * 60 * 24))
+      described_class.new(days: 1).cleanup_python_site_packages
+      expect(foo_pyc).not_to exist
+    end
+  end
 end
diff --git a/Library/Homebrew/test/cli/named_args_spec.rb b/Library/Homebrew/test/cli/named_args_spec.rb
index 06e85a734413a..30bf1e890ced6 100644
--- a/Library/Homebrew/test/cli/named_args_spec.rb
+++ b/Library/Homebrew/test/cli/named_args_spec.rb
@@ -1,24 +1,21 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cli/named_args"
 
-def setup_unredable_formula(name)
-  error = FormulaUnreadableError.new(name, RuntimeError.new("testing"))
-  allow(Formulary).to receive(:factory).with(name, force_bottle: false, flags: []).and_raise(error)
-end
+RSpec.describe Homebrew::CLI::NamedArgs do
+  def setup_unredable_formula(name)
+    error = FormulaUnreadableError.new(name, RuntimeError.new("testing"))
+    allow(Formulary).to receive(:factory).with(name, any_args).and_raise(error)
+  end
 
-def setup_unredable_cask(name)
-  error = Cask::CaskUnreadableError.new(name, "testing")
-  allow(Cask::CaskLoader).to receive(:load).with(name).and_raise(error)
-  allow(Cask::CaskLoader).to receive(:load).with(name, config: nil).and_raise(error)
+  def setup_unredable_cask(name)
+    error = Cask::CaskUnreadableError.new(name, "testing")
+    allow(Cask::CaskLoader).to receive(:load).with(name, any_args).and_raise(error)
 
-  config = instance_double(Cask::Config)
-  allow(Cask::Config).to receive(:from_args).and_return(config)
-  allow(Cask::CaskLoader).to receive(:load).with(name, config: config).and_raise(error)
-end
+    config = instance_double(Cask::Config)
+    allow(Cask::Config).to receive(:from_args).and_return(config)
+  end
 
-describe Homebrew::CLI::NamedArgs do
   let(:foo) do
     formula "foo" do
       url "https://brew.sh"
@@ -34,7 +31,7 @@ def setup_unredable_cask(name)
   end
 
   let(:baz) do
-    Cask::CaskLoader.load(+<<~RUBY)
+    Cask::CaskLoader::FromContentLoader.new(+<<~RUBY, tap: CoreCaskTap.instance).load(config: nil)
       cask "baz" do
         version "1.0"
       end
@@ -42,7 +39,7 @@ def setup_unredable_cask(name)
   end
 
   let(:foo_cask) do
-    Cask::CaskLoader.load(+<<~RUBY)
+    Cask::CaskLoader::FromContentLoader.new(+<<~RUBY, tap: CoreCaskTap.instance).load(config: nil)
       cask "foo" do
         version "1.0"
       end
@@ -67,7 +64,7 @@ def setup_unredable_cask(name)
   end
 
   describe "#to_formulae_and_casks" do
-    it "returns formulae and casks" do
+    it "returns formulae and casks", :needs_macos do
       stub_formula_loader foo, call_original: true
       stub_cask_loader baz, call_original: true
 
@@ -93,6 +90,32 @@ def setup_unredable_cask(name)
       end
     end
 
+    context "when a non-core formula and a core cask are present" do
+      let(:non_core_formula) do
+        formula "foo", tap: Tap.fetch("some/tap") do
+          url "https://brew.sh"
+          version "1.0"
+        end
+      end
+
+      before do
+        stub_formula_loader non_core_formula, "foo"
+        stub_cask_loader foo_cask
+      end
+
+      it "returns the cask by default" do
+        expect(described_class.new("foo").to_formulae_and_casks).to eq [foo_cask]
+      end
+
+      it "returns formula if loading formula only" do
+        expect(described_class.new("foo").to_formulae_and_casks(only: :formula)).to eq [non_core_formula]
+      end
+
+      it "returns cask if loading cask only" do
+        expect(described_class.new("foo").to_formulae_and_casks(only: :cask)).to eq [foo_cask]
+      end
+    end
+
     context "when both formula and cask are unreadable" do
       before do
         setup_unredable_formula "foo"
@@ -118,7 +141,7 @@ def setup_unredable_cask(name)
       expect { described_class.new("foo").to_formulae_and_casks }.to raise_error(FormulaOrCaskUnavailableError)
     end
 
-    it "returns formula when formula is present and cask is unreadable" do
+    it "returns formula when formula is present and cask is unreadable", :needs_macos do
       stub_formula_loader foo
       setup_unredable_cask "foo"
 
@@ -126,7 +149,7 @@ def setup_unredable_cask(name)
       expect { described_class.new("foo").to_formulae_and_casks }.to output(/Failed to load cask: foo/).to_stderr
     end
 
-    it "returns cask when formula is unreadable and cask is present" do
+    it "returns cask when formula is unreadable and cask is present", :needs_macos do
       setup_unredable_formula "foo"
       stub_cask_loader foo_cask
 
@@ -134,7 +157,7 @@ def setup_unredable_cask(name)
       expect { described_class.new("foo").to_formulae_and_casks }.to output(/Failed to load formula: foo/).to_stderr
     end
 
-    it "raises an error when formula is absent and cask is unreadable" do
+    it "raises an error when formula is absent and cask is unreadable", :needs_macos do
       setup_unredable_cask "foo"
 
       expect { described_class.new("foo").to_formulae_and_casks }.to raise_error(Cask::CaskUnreadableError)
@@ -156,7 +179,7 @@ def setup_unredable_cask(name)
   end
 
   describe "#to_resolved_formulae_to_casks" do
-    it "returns resolved formulae, as well as casks" do
+    it "returns resolved formulae, as well as casks", :needs_macos do
       allow(Formulary).to receive(:resolve).and_call_original
       allow(Formulary).to receive(:resolve).with("foo", any_args).and_return foo
       stub_cask_loader baz, call_original: true
@@ -194,6 +217,36 @@ def setup_unredable_cask(name)
     it "when there are no matching kegs returns an empty array" do
       expect(described_class.new.to_kegs).to be_empty
     end
+
+    it "raises an error when a Keg is unavailable" do
+      expect { described_class.new("baz").to_kegs }.to raise_error NoSuchKegError
+    end
+
+    context "when a keg specifies a tap" do
+      let(:tab) { instance_double(Tab, tap: Tap.fetch("user", "repo")) }
+
+      before do
+        allow_any_instance_of(Keg).to receive(:tab).and_return(tab)
+      end
+
+      it "returns kegs if no tap is specified" do
+        stub_formula_loader bar, "user/repo/bar"
+
+        expect(described_class.new("bar").to_kegs.map(&:name)).to eq ["bar"]
+      end
+
+      it "returns kegs if the tap is specified" do
+        stub_formula_loader bar, "user/repo/bar"
+
+        expect(described_class.new("user/repo/bar").to_kegs.map(&:name)).to eq ["bar"]
+      end
+
+      it "raises an error if there is no tap match" do
+        stub_formula_loader bar, "other/tap/bar"
+
+        expect { described_class.new("other/tap/bar").to_kegs }.to raise_error(NoSuchKegError, %r{from tap other/tap})
+      end
+    end
   end
 
   describe "#to_default_kegs" do
@@ -245,7 +298,7 @@ def setup_unredable_cask(name)
       (HOMEBREW_CELLAR/"foo/1.0").mkpath
     end
 
-    it "returns kegs, as well as casks" do
+    it "returns kegs, as well as casks", :needs_macos do
       stub_cask_loader baz, call_original: true
 
       kegs, casks = described_class.new("foo", "baz").to_kegs_to_casks
@@ -279,7 +332,7 @@ def setup_unredable_cask(name)
       allow(Cask::CaskLoader).to receive(:path).and_call_original
     end
 
-    it "returns taps, cask formula and existing paths" do
+    it "returns taps, cask formula and existing paths", :needs_macos do
       expect(Formulary).to receive(:path).with("foo").and_return(formula_path)
       expect(Cask::CaskLoader).to receive(:path).with("baz").and_return(cask_path)
 
@@ -287,7 +340,7 @@ def setup_unredable_cask(name)
         .to eq [Tap.fetch("homebrew/core").path, formula_path, cask_path, existing_path]
     end
 
-    it "returns both cask and formula paths if they exist" do
+    it "returns both cask and formula paths if they exist", :needs_macos do
       expect(Formulary).to receive(:path).with("foo").and_return(formula_path)
       expect(Cask::CaskLoader).to receive(:path).with("baz").and_return(cask_path)
 
@@ -315,7 +368,7 @@ def setup_unredable_cask(name)
 
     it "raises an error for invalid tap" do
       taps = described_class.new("homebrew/foo", "barbaz")
-      expect { taps.to_taps }.to raise_error(RuntimeError, /Invalid tap name/)
+      expect { taps.to_taps }.to raise_error(Tap::InvalidNameError, /Invalid tap name/)
     end
   end
 
@@ -336,7 +389,7 @@ def setup_unredable_cask(name)
 
     it "raises an error for invalid tap" do
       taps = described_class.new("homebrew/foo", "barbaz")
-      expect { taps.to_installed_taps }.to raise_error(RuntimeError, /Invalid tap name/)
+      expect { taps.to_installed_taps }.to raise_error(Tap::InvalidNameError, /Invalid tap name/)
     end
   end
 end
diff --git a/Library/Homebrew/test/cli/parser_spec.rb b/Library/Homebrew/test/cli/parser_spec.rb
index 5aaab4683a1ad..fec9fa061def3 100644
--- a/Library/Homebrew/test/cli/parser_spec.rb
+++ b/Library/Homebrew/test/cli/parser_spec.rb
@@ -1,56 +1,57 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "../../cli/parser"
 
-describe Homebrew::CLI::Parser do
+RSpec.describe Homebrew::CLI::Parser do
+  before { stub_const("Cmd", Class.new(Homebrew::AbstractCommand)) }
+
   describe "test switch options" do
-    subject(:parser) {
-      described_class.new do
+    subject(:parser) do
+      described_class.new(Cmd) do
         switch "--more-verbose", description: "Flag for higher verbosity"
         switch "--pry", env: :pry
         switch "--hidden", hidden: true
       end
-    }
+    end
 
     before do
       allow(Homebrew::EnvConfig).to receive(:pry?).and_return(true)
     end
 
     context "when using binary options" do
-      subject(:parser) {
-        described_class.new do
+      subject(:parser) do
+        described_class.new(Cmd) do
           switch "--[no-]positive"
         end
-      }
+      end
 
       it "does not create no_positive?" do
         args = parser.parse(["--no-positive"])
         expect { args.no_positive? }.to raise_error(NoMethodError)
       end
 
-      it "sets the positive name to false if the negative flag is passed" do
+      it "sets the positive name to false if the negative switch is passed" do
         args = parser.parse(["--no-positive"])
         expect(args).not_to be_positive
       end
 
-      it "sets the positive name to true if the positive flag is passed" do
+      it "sets the positive name to true if the positive switch is passed" do
         args = parser.parse(["--positive"])
         expect(args).to be_positive
       end
 
-      it "does not set the positive name if the positive flag is not passed" do
+      it "does not set the positive name if the positive switch is not passed" do
         args = parser.parse([])
         expect(args.positive?).to be_nil
       end
     end
 
     context "when using negative options" do
-      subject(:parser) {
-        described_class.new do
+      subject(:parser) do
+        described_class.new(Cmd) do
           switch "--no-positive"
         end
-      }
+      end
 
       it "does not set the positive name" do
         args = parser.parse(["--no-positive"])
@@ -58,12 +59,12 @@
       end
 
       it "fails when using the positive name" do
-        expect {
+        expect do
           parser.parse(["--positive"])
-        }.to raise_error(/invalid option/)
+        end.to raise_error(/invalid option/)
       end
 
-      it "sets the negative name to true if the negative flag is passed" do
+      it "sets the negative name to true if the negative switch is passed" do
         args = parser.parse(["--no-positive"])
         expect(args.no_positive?).to be true
       end
@@ -116,14 +117,14 @@
   end
 
   describe "test long flag options" do
-    subject(:parser) {
-      described_class.new do
+    subject(:parser) do
+      described_class.new(Cmd) do
         flag        "--filename=", description: "Name of the file"
-        comma_array "--files",     description: "Comma separated filenames"
+        comma_array "--files",     description: "Comma-separated filenames"
         flag        "--hidden=",      hidden: true
         comma_array "--hidden-array", hidden: true
       end
-    }
+    end
 
     it "parses a long flag option with its argument" do
       args = parser.parse(["--filename=random.txt"])
@@ -147,11 +148,11 @@
   end
 
   describe "test short flag options" do
-    subject(:parser) {
-      described_class.new do
+    subject(:parser) do
+      described_class.new(Cmd) do
         flag "-f", "--filename=", description: "Name of the file"
       end
-    }
+    end
 
     it "parses a short flag option with its argument" do
       args = parser.parse(["--filename=random.txt"])
@@ -161,15 +162,15 @@
   end
 
   describe "test constraints for flag options" do
-    subject(:parser) {
-      described_class.new do
+    subject(:parser) do
+      described_class.new(Cmd) do
         flag      "--flag1="
         flag      "--flag2=", depends_on: "--flag1="
         flag      "--flag3="
 
         conflicts "--flag1=", "--flag3="
       end
-    }
+    end
 
     it "raises exception on depends_on constraint violation" do
       expect { parser.parse(["--flag2=flag2"]) }.to raise_error(Homebrew::CLI::OptionConstraintError)
@@ -192,13 +193,13 @@
   end
 
   describe "test invalid constraints" do
-    subject(:parser) {
-      described_class.new do
+    subject(:parser) do
+      described_class.new(Cmd) do
         flag      "--flag1="
         flag      "--flag2=", depends_on: "--flag1="
         conflicts "--flag1=", "--flag2="
       end
-    }
+    end
 
     it "raises exception due to invalid constraints" do
       expect { parser.parse([]) }.to raise_error(Homebrew::CLI::InvalidConstraintError)
@@ -206,15 +207,15 @@
   end
 
   describe "test constraints for switch options" do
-    subject(:parser) {
-      described_class.new do
+    subject(:parser) do
+      described_class.new(Cmd) do
         switch      "-a", "--switch-a", env: "switch_a"
         switch      "-b", "--switch-b", env: "switch_b"
         switch      "--switch-c", depends_on: "--switch-a"
 
         conflicts "--switch-a", "--switch-b"
       end
-    }
+    end
 
     it "raises exception on depends_on constraint violation" do
       expect { parser.parse(["--switch-c"]) }.to raise_error(Homebrew::CLI::OptionConstraintError)
@@ -236,27 +237,29 @@
     end
 
     it "prioritizes cli arguments over env vars when they conflict" do
-      allow(Homebrew::EnvConfig).to receive(:switch_a?).and_return(true)
-      allow(Homebrew::EnvConfig).to receive(:switch_b?).and_return(false)
+      without_partial_double_verification do
+        allow(Homebrew::EnvConfig).to receive_messages(switch_a?: true, switch_b?: false)
+      end
       args = parser.parse(["--switch-b"])
       expect(args.switch_a?).to be false
       expect(args).to be_switch_b
     end
 
     it "raises an exception on constraint violation when both are env vars" do
-      allow(Homebrew::EnvConfig).to receive(:switch_a?).and_return(true)
-      allow(Homebrew::EnvConfig).to receive(:switch_b?).and_return(true)
+      without_partial_double_verification do
+        allow(Homebrew::EnvConfig).to receive_messages(switch_a?: true, switch_b?: true)
+      end
       expect { parser.parse([]) }.to raise_error(Homebrew::CLI::OptionConflictError)
     end
   end
 
   describe "test immutability of args" do
-    subject(:parser) {
-      described_class.new do
+    subject(:parser) do
+      described_class.new(Cmd) do
         switch "-a", "--switch-a"
         switch "-b", "--switch-b"
       end
-    }
+    end
 
     it "raises exception when arguments were already parsed" do
       parser.parse(["--switch-a"])
@@ -265,15 +268,15 @@
   end
 
   describe "test inferrability of args" do
-    subject(:parser) {
-      described_class.new do
+    subject(:parser) do
+      described_class.new(Cmd) do
         switch "--switch-a"
         switch "--switch-b"
         switch "--foo-switch"
         flag "--flag-foo="
         comma_array "--comma-array-foo"
       end
-    }
+    end
 
     it "parses a valid switch that uses `_` instead of `-`" do
       args = parser.parse(["--switch_a"])
@@ -301,13 +304,13 @@
   end
 
   describe "test argv extensions" do
-    subject(:parser) {
-      described_class.new do
+    subject(:parser) do
+      described_class.new(Cmd) do
         switch "--foo"
         flag   "--bar"
         switch "-s"
       end
-    }
+    end
 
     it "#options_only" do
       args = parser.parse(["--foo", "--bar=value", "-v", "-s", "a", "b", "cdefg"])
@@ -332,7 +335,7 @@
 
   describe "usage banner generation" do
     it "includes `[options]` if more than two non-global options are available" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         switch "--foo"
         switch "--baz"
         switch "--bar"
@@ -341,7 +344,7 @@
     end
 
     it "includes individual options if less than two non-global options are available" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         switch "--foo"
         switch "--bar"
       end
@@ -349,7 +352,7 @@
     end
 
     it "formats flags correctly when less than two non-global options are available" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         flag "--foo"
         flag "--bar="
       end
@@ -357,26 +360,26 @@
     end
 
     it "formats comma arrays correctly when less than two non-global options are available" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         comma_array "--foo"
       end
       expect(parser.generate_help_text).to match(/\[--foo=\]/)
     end
 
     it "does not include hidden options" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         switch "--foo", hidden: true
       end
       expect(parser.generate_help_text).not_to match(/\[--foo\]/)
     end
 
     it "doesn't include `[options]` if non non-global options are available" do
-      parser = described_class.new
+      parser = described_class.new(Cmd)
       expect(parser.generate_help_text).not_to match(/\[options\]/)
     end
 
     it "includes a description" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         description <<~EOS
           This command does something
         EOS
@@ -385,14 +388,14 @@
     end
 
     it "allows the usage banner to be overridden" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         usage_banner "`test` [foo] <bar>"
       end
       expect(parser.generate_help_text).to match(/test \[foo\] bar/)
     end
 
     it "allows a usage banner and a description to be overridden" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         usage_banner "`test` [foo] <bar>"
         description <<~EOS
           This command does something
@@ -403,42 +406,42 @@
     end
 
     it "shows the correct usage for no named argument" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         named_args :none
       end
       expect(parser.generate_help_text).to match(/^Usage: [^\[]+$/s)
     end
 
     it "shows the correct usage for a single typed argument" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         named_args :formula, number: 1
       end
       expect(parser.generate_help_text).to match(/^Usage: .* formula$/s)
     end
 
     it "shows the correct usage for a subcommand argument with a maximum" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         named_args %w[off on], max: 1
       end
       expect(parser.generate_help_text).to match(/^Usage: .* \[subcommand\]$/s)
     end
 
     it "shows the correct usage for multiple typed argument with no maximum or minimum" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         named_args [:tap, :command]
       end
       expect(parser.generate_help_text).to match(/^Usage: .* \[tap|command ...\]$/s)
     end
 
     it "shows the correct usage for a subcommand argument with a minimum of 1" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         named_args :installed_formula, min: 1
       end
       expect(parser.generate_help_text).to match(/^Usage: .* installed_formula \[...\]$/s)
     end
 
     it "shows the correct usage for a subcommand argument with a minimum greater than 1" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         named_args :installed_formula, min: 2
       end
       expect(parser.generate_help_text).to match(/^Usage: .* installed_formula ...$/s)
@@ -446,20 +449,20 @@
   end
 
   describe "named_args" do
-    let(:parser_none) {
-      described_class.new do
+    let(:parser_none) do
+      described_class.new(Cmd) do
         named_args :none
       end
-    }
-    let(:parser_number) {
-      described_class.new do
+    end
+    let(:parser_number) do
+      described_class.new(Cmd) do
         named_args number: 1
       end
-    }
+    end
 
     it "doesn't allow :none passed with a number" do
       expect do
-        described_class.new do
+        described_class.new(Cmd) do
           named_args :none, number: 1
         end
       end.to raise_error(ArgumentError, /Do not specify both `number`, `min` or `max` with `named_args :none`/)
@@ -467,7 +470,7 @@
 
     it "doesn't allow number and min" do
       expect do
-        described_class.new do
+        described_class.new(Cmd) do
           named_args number: 1, min: 1
         end
       end.to raise_error(ArgumentError, /Do not specify both `number` and `min` or `max`/)
@@ -495,7 +498,7 @@
     end
 
     it "displays the correct error message with no arg types and min" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         named_args min: 2
       end
       expect { parser.parse([]) }.to raise_error(
@@ -504,7 +507,7 @@
     end
 
     it "displays the correct error message with no arg types and number" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         named_args number: 2
       end
       expect { parser.parse([]) }.to raise_error(
@@ -513,7 +516,7 @@
     end
 
     it "displays the correct error message with no arg types and max" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         named_args max: 1
       end
       expect { parser.parse(%w[foo bar]) }.to raise_error(
@@ -522,7 +525,7 @@
     end
 
     it "displays the correct error message with an array of strings" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         named_args %w[on off], number: 1
       end
       expect { parser.parse([]) }.to raise_error(
@@ -531,7 +534,7 @@
     end
 
     it "displays the correct error message with an array of symbols" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         named_args [:formula, :cask], min: 1
       end
       expect { parser.parse([]) }.to raise_error(
@@ -540,7 +543,7 @@
     end
 
     it "displays the correct error message with an array of symbols and max" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         named_args [:formula, :cask], max: 1
       end
       expect { parser.parse(%w[foo bar]) }.to raise_error(
@@ -549,17 +552,82 @@
     end
 
     it "accepts commands with :command" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         named_args :command
       end
       expect { parser.parse(["--prefix", "--version"]) }.not_to raise_error
     end
 
     it "doesn't accept invalid options with :command" do
-      parser = described_class.new do
+      parser = described_class.new(Cmd) do
         named_args :command
       end
       expect { parser.parse(["--not-a-command"]) }.to raise_error(OptionParser::InvalidOption, /--not-a-command/)
     end
   end
+
+  describe "--cask on linux", :needs_linux do
+    context "without --formula switch" do
+      subject(:parser) do
+        described_class.new(Cmd) do
+          switch "--cask"
+        end
+      end
+
+      it "throws an error when defined" do
+        expect { parser.parse(["--cask"]) }
+          .to output("Error: Invalid `--cask` usage: Casks do not work on Linux\n").to_stderr
+          .and not_to_output.to_stdout
+          .and raise_exception SystemExit
+      end
+
+      # Developers want to be able to use `audit` and `bump`
+      # commands for formulae and casks on Linux.
+      it "succeeds for developer commands" do
+        require "dev-cmd/cat"
+        args = Homebrew::DevCmd::Cat.new(["--cask", "cask_name"]).args
+        expect(args.cask?).to be(true)
+      end
+    end
+
+    context "with conflicting --formula switch" do
+      subject(:parser) do
+        described_class.new(Cmd) do
+          switch "--cask"
+          switch "--formula"
+          conflicts "--cask", "--formula"
+        end
+      end
+
+      it "throws an error when --cask defined" do
+        expect { parser.parse(["--cask"]) }
+          .to output("Error: Invalid `--cask` usage: Casks do not work on Linux\n").to_stderr
+          .and not_to_output.to_stdout
+          .and raise_exception SystemExit
+      end
+
+      it "throws an error when both defined" do
+        expect { parser.parse(["--cask", "--formula"]) }
+          .to output("Error: Invalid `--cask` usage: Casks do not work on Linux\n").to_stderr
+          .and not_to_output.to_stdout
+          .and raise_exception SystemExit
+      end
+    end
+  end
+
+  describe "--formula on linux", :needs_linux do
+    it "doesn't set --formula when not defined" do
+      parser = described_class.new(Cmd)
+      args = parser.parse([])
+      expect(args.respond_to?(:formula?)).to be(false)
+    end
+
+    it "sets --formula to true when defined" do
+      parser = described_class.new(Cmd) do
+        switch "--formula"
+      end
+      args = parser.parse([])
+      expect(args.formula?).to be(true)
+    end
+  end
 end
diff --git a/Library/Homebrew/test/cli/parser_spec.rbi b/Library/Homebrew/test/cli/parser_spec.rbi
new file mode 100644
index 0000000000000..9b961afdb0d36
--- /dev/null
+++ b/Library/Homebrew/test/cli/parser_spec.rbi
@@ -0,0 +1,3 @@
+# typed: strict
+
+class Cmd < Homebrew::AbstractCommand; end
diff --git a/Library/Homebrew/test/cmd/--cache_spec.rb b/Library/Homebrew/test/cmd/--cache_spec.rb
index 410ca72f183db..d973d2ed8a49f 100644
--- a/Library/Homebrew/test/cmd/--cache_spec.rb
+++ b/Library/Homebrew/test/cmd/--cache_spec.rb
@@ -1,15 +1,14 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/--cache"
 require "cmd/shared_examples/args_parse"
 
-describe "brew --cache" do
+RSpec.describe Homebrew::Cmd::Cache do
   it_behaves_like "parseable arguments"
 
   it "prints all cache files for a given Formula", :integration_test do
     expect { brew "--cache", testball }
       .to output(%r{#{HOMEBREW_CACHE}/downloads/[\da-f]{64}--testball-}o).to_stdout
-      .and output(/Treating #{Regexp.escape(testball)} as a formula/).to_stderr
       .and be_a_success
     expect { brew "--cache", "--formula", testball }
       .to output(%r{#{HOMEBREW_CACHE}/downloads/[\da-f]{64}--testball-}o).to_stdout
@@ -17,7 +16,7 @@
       .and be_a_success
   end
 
-  it "prints the cache files for a given Cask", :integration_test do
+  it "prints the cache files for a given Cask", :integration_test, :needs_macos do
     expect { brew "--cache", cask_path("local-caffeine") }
       .to output(%r{#{HOMEBREW_CACHE}/downloads/[\da-f]{64}--caffeine\.zip}o).to_stdout
       .and output(/Treating #{Regexp.escape(cask_path("local-caffeine"))} as a cask/).to_stderr
@@ -28,7 +27,7 @@
       .and be_a_success
   end
 
-  it "prints the cache files for a given Formula and Cask", :integration_test do
+  it "prints the cache files for a given Formula and Cask", :integration_test, :needs_macos do
     expect { brew "--cache", testball, cask_path("local-caffeine") }
       .to output(
         %r{
diff --git a/Library/Homebrew/test/cmd/--caskroom_spec.rb b/Library/Homebrew/test/cmd/--caskroom_spec.rb
index c69005b758fa5..4002f17e2dfb6 100644
--- a/Library/Homebrew/test/cmd/--caskroom_spec.rb
+++ b/Library/Homebrew/test/cmd/--caskroom_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/--caskroom"
 require "cmd/shared_examples/args_parse"
 
-describe "brew --caskroom" do
+RSpec.describe Homebrew::Cmd::Caskroom do
   it_behaves_like "parseable arguments"
 
   it "prints Homebrew's Caskroom", :integration_test do
diff --git a/Library/Homebrew/test/cmd/--cellar_spec.rb b/Library/Homebrew/test/cmd/--cellar_spec.rb
index 63c78854a03b1..82eb47958c04b 100644
--- a/Library/Homebrew/test/cmd/--cellar_spec.rb
+++ b/Library/Homebrew/test/cmd/--cellar_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/--cellar"
 require "cmd/shared_examples/args_parse"
 
-describe "brew --cellar" do
+RSpec.describe Homebrew::Cmd::Cellar do
   it_behaves_like "parseable arguments"
 
   it "prints Homebrew's Cellar", :integration_test do
diff --git a/Library/Homebrew/test/cmd/--env_spec.rb b/Library/Homebrew/test/cmd/--env_spec.rb
index fd8a94fb5f70e..9df3625a70208 100644
--- a/Library/Homebrew/test/cmd/--env_spec.rb
+++ b/Library/Homebrew/test/cmd/--env_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/--env"
 require "cmd/shared_examples/args_parse"
 
-describe "brew --env" do
+RSpec.describe Homebrew::Cmd::Env do
   it_behaves_like "parseable arguments"
 
   describe "--shell=bash", :integration_test do
diff --git a/Library/Homebrew/test/cmd/--prefix_spec.rb b/Library/Homebrew/test/cmd/--prefix_spec.rb
index d16163b1326bd..48efc0f51b070 100644
--- a/Library/Homebrew/test/cmd/--prefix_spec.rb
+++ b/Library/Homebrew/test/cmd/--prefix_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/--prefix"
 require "cmd/shared_examples/args_parse"
 
-describe "brew --prefix" do
+RSpec.describe Homebrew::Cmd::Prefix do
   it_behaves_like "parseable arguments"
 
   it "prints Homebrew's prefix", :integration_test do
@@ -13,7 +13,7 @@
       .and be_a_success
   end
 
-  it "prints the prefix for a Formula", :integration_test do
+  it "prints the prefix for a Formula", :integration_test, :needs_homebrew_core do
     expect { brew_sh "--prefix", "wget" }
       .to output("#{ENV.fetch("HOMEBREW_PREFIX")}/opt/wget\n").to_stdout
       .and not_to_output.to_stderr
@@ -27,7 +27,7 @@
       .and be_a_failure
   end
 
-  it "prints a warning with `--installed` if the given Formula is not installed", :integration_test do
+  it "prints a warning when `--installed` is used and the given Formula is not installed", :integration_test do
     expect { brew "--prefix", "--installed", testball }
       .to not_to_output.to_stdout
       .and output(/testball/).to_stderr
diff --git a/Library/Homebrew/test/cmd/--repository_spec.rb b/Library/Homebrew/test/cmd/--repository_spec.rb
index 33547f7575f71..d26dd4342bf2f 100644
--- a/Library/Homebrew/test/cmd/--repository_spec.rb
+++ b/Library/Homebrew/test/cmd/--repository_spec.rb
@@ -1,11 +1,6 @@
-# typed: false
 # frozen_string_literal: true
 
-require "cmd/shared_examples/args_parse"
-
-describe "brew --repository" do
-  it_behaves_like "parseable arguments"
-
+RSpec.describe "brew --repository", type: :system do
   it "prints Homebrew's repository", :integration_test do
     expect { brew_sh "--repository" }
       .to output("#{ENV.fetch("HOMEBREW_REPOSITORY")}\n").to_stdout
@@ -14,8 +9,15 @@
   end
 
   it "prints a Tap's repository", :integration_test do
-    expect { brew "--repository", "foo/bar" }
-      .to output("#{HOMEBREW_LIBRARY}/Taps/foo/homebrew-bar\n").to_stdout
+    expect { brew_sh "--repository", "foo/bar" }
+      .to output("#{ENV.fetch("HOMEBREW_LIBRARY")}/Taps/foo/homebrew-bar\n").to_stdout
+      .and not_to_output.to_stderr
+      .and be_a_success
+  end
+
+  it "prints a Tap's repository correctly when homebrew- prefix is supplied", :integration_test do
+    expect { brew_sh "--repository", "foo/homebrew-bar" }
+      .to output("#{ENV.fetch("HOMEBREW_LIBRARY")}/Taps/foo/homebrew-bar\n").to_stdout
       .and not_to_output.to_stderr
       .and be_a_success
   end
diff --git a/Library/Homebrew/test/cmd/--version_spec.rb b/Library/Homebrew/test/cmd/--version_spec.rb
index 944ff2981f5d3..772fd5348cac2 100644
--- a/Library/Homebrew/test/cmd/--version_spec.rb
+++ b/Library/Homebrew/test/cmd/--version_spec.rb
@@ -1,9 +1,6 @@
-# typed: false
 # frozen_string_literal: true
 
-require "cmd/shared_examples/args_parse"
-
-describe "brew --version" do
+RSpec.describe "brew --version", type: :system do
   it "prints the Homebrew's version", :integration_test do
     expect { brew_sh "--version" }
       .to output(/^Homebrew #{Regexp.escape(HOMEBREW_VERSION)}\n/o).to_stdout
diff --git a/Library/Homebrew/test/cmd/analytics_spec.rb b/Library/Homebrew/test/cmd/analytics_spec.rb
index dc4605bec78a1..bd354451e93ea 100644
--- a/Library/Homebrew/test/cmd/analytics_spec.rb
+++ b/Library/Homebrew/test/cmd/analytics_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/analytics"
 require "cmd/shared_examples/args_parse"
 
-describe "brew analytics" do
+RSpec.describe Homebrew::Cmd::Analytics do
   it_behaves_like "parseable arguments"
 
   it "when HOMEBREW_NO_ANALYTICS is unset is disabled after running `brew analytics off`", :integration_test do
@@ -13,7 +13,7 @@
 
     brew "analytics", "off"
     expect { brew "analytics", "HOMEBREW_NO_ANALYTICS" => nil }
-      .to output(/Analytics are disabled/).to_stdout
+      .to output(/analytics are disabled/i).to_stdout
       .and not_to_output.to_stderr
       .and be_a_success
   end
diff --git a/Library/Homebrew/test/cmd/autoremove_spec.rb b/Library/Homebrew/test/cmd/autoremove_spec.rb
index 24069e0bb79cf..07b29812107b3 100644
--- a/Library/Homebrew/test/cmd/autoremove_spec.rb
+++ b/Library/Homebrew/test/cmd/autoremove_spec.rb
@@ -1,8 +1,43 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/autoremove"
 require "cmd/shared_examples/args_parse"
 
-describe "brew autoremove" do
+RSpec.describe Homebrew::Cmd::Autoremove do
   it_behaves_like "parseable arguments"
+
+  describe "integration test" do
+    let(:requested_formula) { Formula["testball1"] }
+    let(:unused_formula) { Formula["testball2"] }
+
+    before do
+      # Make testball1 poured from a bottle
+      install_test_formula "testball1"
+      tab = Tab.for_name("testball1")
+      tab.poured_from_bottle = true
+      tab.write
+
+      # Make testball2 poured from a bottle and an unused dependency
+      install_test_formula "testball2"
+      tab = Tab.for_name("testball2")
+      tab.installed_on_request = false
+      tab.installed_as_dependency = true
+      tab.poured_from_bottle = true
+      tab.write
+    end
+
+    it "only removes unused dependencies", :integration_test do
+      expect(requested_formula.any_version_installed?).to be true
+      expect(unused_formula.any_version_installed?).to be true
+
+      # When there are unused dependencies
+      expect { brew "autoremove" }
+        .to be_a_success
+        .and output(/Autoremoving/).to_stdout
+        .and not_to_output.to_stderr
+
+      expect(requested_formula.any_version_installed?).to be true
+      expect(unused_formula.any_version_installed?).to be false
+    end
+  end
 end
diff --git a/Library/Homebrew/test/cmd/bundle_spec.rb b/Library/Homebrew/test/cmd/bundle_spec.rb
index 7021ea70eb58e..90f040273de97 100644
--- a/Library/Homebrew/test/cmd/bundle_spec.rb
+++ b/Library/Homebrew/test/cmd/bundle_spec.rb
@@ -1,24 +1,25 @@
-# typed: false
 # frozen_string_literal: true
 
-describe "brew bundle", :integration_test do
-  describe "check" do
-    it "checks if a Brewfile's dependencies are satisfied", :needs_network do
-      setup_remote_tap "homebrew/bundle"
+require "cmd/shared_examples/args_parse"
 
-      HOMEBREW_REPOSITORY.cd do
-        system "git", "init"
-        system "git", "commit", "--allow-empty", "-m", "This is a test commit"
-      end
+RSpec.describe "Homebrew::Cmd::BundleCmd", :integration_test, :needs_network do
+  before { setup_remote_tap "homebrew/bundle" }
+
+  it_behaves_like "parseable arguments", command_name: "bundle"
+
+  it "checks if a Brewfile's dependencies are satisfied" do
+    HOMEBREW_REPOSITORY.cd do
+      system "git", "init"
+      system "git", "commit", "--allow-empty", "-m", "This is a test commit"
+    end
 
-      mktmpdir do |path|
-        FileUtils.touch "#{path}/Brewfile"
-        path.cd do
-          expect { brew "bundle", "check" }
-            .to output("The Brewfile's dependencies are satisfied.\n").to_stdout
-            .and not_to_output.to_stderr
-            .and be_a_success
-        end
+    mktmpdir do |path|
+      FileUtils.touch "#{path}/Brewfile"
+      path.cd do
+        expect { brew "bundle", "check" }
+          .to output("The Brewfile's dependencies are satisfied.\n").to_stdout
+          .and not_to_output.to_stderr
+          .and be_a_success
       end
     end
   end
diff --git a/Library/Homebrew/test/cmd/cleanup_spec.rb b/Library/Homebrew/test/cmd/cleanup_spec.rb
index d9b8752e3b6b1..098dc356d7131 100644
--- a/Library/Homebrew/test/cmd/cleanup_spec.rb
+++ b/Library/Homebrew/test/cmd/cleanup_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/cleanup"
 require "cmd/shared_examples/args_parse"
 
-describe "brew cleanup" do
+RSpec.describe Homebrew::Cmd::CleanupCmd do
   before do
     FileUtils.mkdir_p HOMEBREW_LIBRARY/"Homebrew/vendor/"
     FileUtils.touch HOMEBREW_LIBRARY/"Homebrew/vendor/portable-ruby-version"
diff --git a/Library/Homebrew/test/dev-cmd/command_spec.rb b/Library/Homebrew/test/cmd/command_spec.rb
similarity index 84%
rename from Library/Homebrew/test/dev-cmd/command_spec.rb
rename to Library/Homebrew/test/cmd/command_spec.rb
index 7608269e1bbc1..c756c3792a103 100644
--- a/Library/Homebrew/test/dev-cmd/command_spec.rb
+++ b/Library/Homebrew/test/cmd/command_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "cmd/command"
 
-describe "brew command" do
+RSpec.describe Homebrew::Cmd::Command do
   it_behaves_like "parseable arguments"
 
   it "returns the file for a given command", :integration_test do
diff --git a/Library/Homebrew/test/cmd/commands_spec.rb b/Library/Homebrew/test/cmd/commands_spec.rb
index 55742996f98f5..9f7de67f11467 100644
--- a/Library/Homebrew/test/cmd/commands_spec.rb
+++ b/Library/Homebrew/test/cmd/commands_spec.rb
@@ -1,12 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/commands"
-require "fileutils"
-
 require "cmd/shared_examples/args_parse"
 
-describe "brew commands" do
+RSpec.describe Homebrew::Cmd::CommandsCmd do
   it_behaves_like "parseable arguments"
 
   it "prints a list of all available commands", :integration_test do
diff --git a/Library/Homebrew/test/cmd/completions_spec.rb b/Library/Homebrew/test/cmd/completions_spec.rb
index a1ab341d5047a..6cc7cc2496765 100644
--- a/Library/Homebrew/test/cmd/completions_spec.rb
+++ b/Library/Homebrew/test/cmd/completions_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/completions"
 require "cmd/shared_examples/args_parse"
 
-describe "brew completions" do
+RSpec.describe Homebrew::Cmd::CompletionsCmd do
   it_behaves_like "parseable arguments"
 
   it "runs the status subcommand correctly", :integration_test do
diff --git a/Library/Homebrew/test/cmd/config_spec.rb b/Library/Homebrew/test/cmd/config_spec.rb
index e4afba0353121..9abdc634054de 100644
--- a/Library/Homebrew/test/cmd/config_spec.rb
+++ b/Library/Homebrew/test/cmd/config_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/config"
 require "cmd/shared_examples/args_parse"
 
-describe "brew config" do
+RSpec.describe Homebrew::Cmd::Config do
   it_behaves_like "parseable arguments"
 
   it "prints information about the current Homebrew configuration", :integration_test do
diff --git a/Library/Homebrew/test/cmd/custom-external-command_spec.rb b/Library/Homebrew/test/cmd/custom-external-command_spec.rb
index c4bec250ac215..cabfc5efd16fb 100644
--- a/Library/Homebrew/test/cmd/custom-external-command_spec.rb
+++ b/Library/Homebrew/test/cmd/custom-external-command_spec.rb
@@ -1,7 +1,6 @@
-# typed: false
 # frozen_string_literal: true
 
-describe "brew custom-external-command", :integration_test do
+RSpec.describe "brew custom-external-command", :integration_test, type: :system do
   it "is supported" do
     mktmpdir do |path|
       cmd = "custom-external-command-#{rand}"
diff --git a/Library/Homebrew/test/cmd/deps_spec.rb b/Library/Homebrew/test/cmd/deps_spec.rb
index e04e698479de8..80edb9433737b 100644
--- a/Library/Homebrew/test/cmd/deps_spec.rb
+++ b/Library/Homebrew/test/cmd/deps_spec.rb
@@ -1,22 +1,42 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/deps"
 require "cmd/shared_examples/args_parse"
 
-describe "brew deps" do
+RSpec.describe Homebrew::Cmd::Deps do
+  include FileUtils
+
   it_behaves_like "parseable arguments"
 
   it "outputs all of a Formula's dependencies and their dependencies on separate lines", :integration_test do
-    setup_test_formula "foo"
+    # Included in output
     setup_test_formula "bar"
+    setup_test_formula "foo"
+    setup_test_formula "test"
+
+    # Excluded from output
     setup_test_formula "baz", <<~RUBY
       url "https://brew.sh/baz-1.0"
       depends_on "bar"
+      depends_on "build" => :build
+      depends_on "test" => :test
+      depends_on "optional" => :optional
+      depends_on "recommended_test" => [:recommended, :test]
+      depends_on "installed"
     RUBY
+    setup_test_formula "build"
+    setup_test_formula "optional"
+    setup_test_formula "recommended_test"
+    setup_test_formula "installed"
+
+    # Mock `Formula#any_version_installed?` by creating the tab in a plausible keg directory
+    keg_dir = HOMEBREW_CELLAR/"installed"/"1.0"
+    keg_dir.mkpath
+    touch keg_dir/AbstractTab::FILENAME
 
-    expect { brew "deps", "baz" }
+    expect { brew "deps", "baz", "--include-test", "--missing", "--skip-recommended" }
       .to be_a_success
-      .and output("bar\nfoo\n").to_stdout
+      .and output("bar\nfoo\ntest\n").to_stdout
       .and not_to_output.to_stderr
   end
 end
diff --git a/Library/Homebrew/test/cmd/desc_spec.rb b/Library/Homebrew/test/cmd/desc_spec.rb
index efb364b17b1b5..512f35fbb12ce 100644
--- a/Library/Homebrew/test/cmd/desc_spec.rb
+++ b/Library/Homebrew/test/cmd/desc_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/desc"
 require "cmd/shared_examples/args_parse"
 
-describe "brew desc" do
+RSpec.describe Homebrew::Cmd::Desc do
   it_behaves_like "parseable arguments"
 
   it "shows a given Formula's description", :integration_test do
@@ -14,4 +14,27 @@
       .and not_to_output.to_stderr
       .and be_a_success
   end
+
+  it "errors when searching without --eval-all", :integration_test do
+    setup_test_formula "testball"
+
+    expect { brew "desc", "--search", "testball" }
+      .to output(/`brew desc --search` needs `--eval-all` passed or `HOMEBREW_EVAL_ALL` set!/).to_stderr
+      .and be_a_failure
+  end
+
+  it "successfully searches with --search --eval-all", :integration_test do
+    setup_test_formula "testball"
+
+    expect { brew "desc", "--search", "--eval-all", "ball" }
+      .to output(/testball: Some test/).to_stdout
+      .and not_to_output.to_stderr
+  end
+
+  it "successfully searches without --eval-all, with API", :integration_test do
+    setup_test_formula "testball"
+
+    expect { brew "desc", "--search", "testball", "HOMEBREW_NO_INSTALL_FROM_API" => nil }
+      .to be_a_success
+  end
 end
diff --git a/Library/Homebrew/test/cmd/developer_spec.rb b/Library/Homebrew/test/cmd/developer_spec.rb
index 00ca2f573986a..fcaefacdf8ae7 100644
--- a/Library/Homebrew/test/cmd/developer_spec.rb
+++ b/Library/Homebrew/test/cmd/developer_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/developer"
 require "cmd/shared_examples/args_parse"
 
-describe "brew developer" do
+RSpec.describe Homebrew::Cmd::Developer do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/cmd/docs_spec.rb b/Library/Homebrew/test/cmd/docs_spec.rb
new file mode 100644
index 0000000000000..6262e54cf4f27
--- /dev/null
+++ b/Library/Homebrew/test/cmd/docs_spec.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "cmd/docs"
+require "cmd/shared_examples/args_parse"
+
+RSpec.describe Homebrew::Cmd::Docs do
+  it_behaves_like "parseable arguments"
+
+  it "opens the docs page", :integration_test do
+    expect { brew "docs", "HOMEBREW_BROWSER" => "echo" }
+      .to output("https://docs.brew.sh\n").to_stdout
+      .and not_to_output.to_stderr
+      .and be_a_success
+  end
+end
diff --git a/Library/Homebrew/test/cmd/doctor_spec.rb b/Library/Homebrew/test/cmd/doctor_spec.rb
index 000cd79072a01..ca20e4a470a08 100644
--- a/Library/Homebrew/test/cmd/doctor_spec.rb
+++ b/Library/Homebrew/test/cmd/doctor_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/doctor"
 require "cmd/shared_examples/args_parse"
 
-describe "brew doctor" do
+RSpec.describe Homebrew::Cmd::Doctor do
   it_behaves_like "parseable arguments"
 
   specify "check_integration_test", :integration_test do
diff --git a/Library/Homebrew/test/cmd/fetch_spec.rb b/Library/Homebrew/test/cmd/fetch_spec.rb
index cdc4b870fb980..7b0cc3de7a50b 100644
--- a/Library/Homebrew/test/cmd/fetch_spec.rb
+++ b/Library/Homebrew/test/cmd/fetch_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/fetch"
 require "cmd/shared_examples/args_parse"
 
-describe "brew fetch" do
+RSpec.describe Homebrew::Cmd::FetchCmd do
   it_behaves_like "parseable arguments"
 
   it "downloads the Formula's URL", :integration_test do
diff --git a/Library/Homebrew/test/cmd/gist-logs_spec.rb b/Library/Homebrew/test/cmd/gist-logs_spec.rb
index f1d628f9e199c..98a272251bc51 100644
--- a/Library/Homebrew/test/cmd/gist-logs_spec.rb
+++ b/Library/Homebrew/test/cmd/gist-logs_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/gist-logs"
 require "cmd/shared_examples/args_parse"
 
-describe "brew gist-logs" do
+RSpec.describe Homebrew::Cmd::GistLogs do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/cmd/help_spec.rb b/Library/Homebrew/test/cmd/help_spec.rb
index 6694b4b4b22b7..1301b5909da73 100644
--- a/Library/Homebrew/test/cmd/help_spec.rb
+++ b/Library/Homebrew/test/cmd/help_spec.rb
@@ -1,7 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
-describe "brew", :integration_test do
+require "cmd/help"
+require "cmd/shared_examples/args_parse"
+
+RSpec.describe Homebrew::Cmd::HelpCmd, :integration_test do
+  it_behaves_like "parseable arguments"
+
   describe "help" do
     it "prints help for a documented Ruby command" do
       expect { brew "help", "cat" }
diff --git a/Library/Homebrew/test/cmd/home_spec.rb b/Library/Homebrew/test/cmd/home_spec.rb
index 063846c3346f3..5dfe5dde997b7 100644
--- a/Library/Homebrew/test/cmd/home_spec.rb
+++ b/Library/Homebrew/test/cmd/home_spec.rb
@@ -1,20 +1,20 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/home"
 require "cmd/shared_examples/args_parse"
 
-describe "brew home" do
-  let(:testballhome_homepage) {
+RSpec.describe Homebrew::Cmd::Home do
+  let(:testballhome_homepage) do
     Formula["testballhome"].homepage
-  }
+  end
 
-  let(:local_caffeine_path) {
+  let(:local_caffeine_path) do
     cask_path("local-caffeine")
-  }
+  end
 
-  let(:local_caffeine_homepage) {
+  let(:local_caffeine_homepage) do
     Cask::CaskLoader.load(local_caffeine_path).homepage
-  }
+  end
 
   it_behaves_like "parseable arguments"
 
@@ -34,7 +34,7 @@
       .and be_a_success
   end
 
-  it "opens the homepage for a given Cask", :integration_test do
+  it "opens the homepage for a given Cask", :integration_test, :needs_macos do
     expect { brew "home", local_caffeine_path, "HOMEBREW_BROWSER" => "echo" }
       .to output(/#{local_caffeine_homepage}/).to_stdout
       .and output(/Treating #{Regexp.escape(local_caffeine_path)} as a cask/).to_stderr
@@ -45,7 +45,7 @@
       .and be_a_success
   end
 
-  it "opens the homepages for a given formula and Cask", :integration_test do
+  it "opens the homepages for a given formula and Cask", :integration_test, :needs_macos do
     setup_test_formula "testballhome"
 
     expect { brew "home", "testballhome", local_caffeine_path, "HOMEBREW_BROWSER" => "echo" }
diff --git a/Library/Homebrew/test/cmd/info_spec.rb b/Library/Homebrew/test/cmd/info_spec.rb
index 9189b106d949d..3ea10c010bc09 100644
--- a/Library/Homebrew/test/cmd/info_spec.rb
+++ b/Library/Homebrew/test/cmd/info_spec.rb
@@ -1,11 +1,18 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/info"
-
 require "cmd/shared_examples/args_parse"
 
-describe "brew info" do
+RSpec.describe Homebrew::Cmd::Info do
+  RSpec::Matchers.define :a_json_string do
+    match do |actual|
+      JSON.parse(actual)
+      true
+    rescue JSON::ParserError
+      false
+    end
+  end
+
   it_behaves_like "parseable arguments"
 
   it "prints as json with the --json=v1 flag", :integration_test do
@@ -26,23 +33,21 @@
       .and be_a_success
   end
 
-  describe Homebrew do
-    describe "::github_remote_path" do
-      let(:remote) { "https://github.com/Homebrew/homebrew-core" }
+  describe "::github_remote_path" do
+    let(:remote) { "https://github.com/Homebrew/homebrew-core" }
 
-      specify "returns correct URLs" do
-        expect(described_class.github_remote_path(remote, "Formula/git.rb"))
-          .to eq("https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/git.rb")
+    specify "returns correct URLs" do
+      expect(described_class.new([]).github_remote_path(remote, "Formula/git.rb"))
+        .to eq("https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/git.rb")
 
-        expect(described_class.github_remote_path("#{remote}.git", "Formula/git.rb"))
-          .to eq("https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/git.rb")
+      expect(described_class.new([]).github_remote_path("#{remote}.git", "Formula/git.rb"))
+        .to eq("https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/git.rb")
 
-        expect(described_class.github_remote_path("git@github.com:user/repo", "foo.rb"))
-          .to eq("https://github.com/user/repo/blob/HEAD/foo.rb")
+      expect(described_class.new([]).github_remote_path("git@github.com:user/repo", "foo.rb"))
+        .to eq("https://github.com/user/repo/blob/HEAD/foo.rb")
 
-        expect(described_class.github_remote_path("https://mywebsite.com", "foo/bar.rb"))
-          .to eq("https://mywebsite.com/foo/bar.rb")
-      end
+      expect(described_class.new([]).github_remote_path("https://mywebsite.com", "foo/bar.rb"))
+        .to eq("https://mywebsite.com/foo/bar.rb")
     end
   end
 end
diff --git a/Library/Homebrew/test/cmd/install_spec.rb b/Library/Homebrew/test/cmd/install_spec.rb
index 560bc3393c094..4772947bf021f 100644
--- a/Library/Homebrew/test/cmd/install_spec.rb
+++ b/Library/Homebrew/test/cmd/install_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/install"
 require "cmd/shared_examples/args_parse"
 
-describe "brew install" do
+RSpec.describe Homebrew::Cmd::InstallCmd do
   it_behaves_like "parseable arguments"
 
   it "installs formulae", :integration_test do
@@ -45,7 +45,7 @@
     repo_path.join("bin").mkpath
 
     repo_path.cd do
-      system "git", "init"
+      system "git", "-c", "init.defaultBranch=master", "init"
       system "git", "remote", "add", "origin", "https://github.com/Homebrew/homebrew-foo"
       FileUtils.touch "bin/something.bin"
       FileUtils.touch "README"
@@ -72,4 +72,16 @@ def install
       .and be_a_success
     expect(HOMEBREW_CELLAR/"testball1/HEAD-d5eb689/foo/test").not_to be_a_file
   end
+
+  it "installs formulae with debug symbols", :integration_test do
+    setup_test_formula "testball1"
+
+    expect { brew "install", "testball1", "--debug-symbols", "--build-from-source" }
+      .to output(%r{#{HOMEBREW_CELLAR}/testball1/0\.1}o).to_stdout
+      .and not_to_output.to_stderr
+      .and be_a_success
+    expect(HOMEBREW_CELLAR/"testball1/0.1/bin/test").to be_a_file
+    expect(HOMEBREW_CELLAR/"testball1/0.1/bin/test.dSYM/Contents/Resources/DWARF/test").to be_a_file if OS.mac?
+    expect(HOMEBREW_CACHE/"Sources/testball1").to be_a_directory
+  end
 end
diff --git a/Library/Homebrew/test/cmd/leaves_spec.rb b/Library/Homebrew/test/cmd/leaves_spec.rb
index e8afbabed6196..9e00a21ca1a4d 100644
--- a/Library/Homebrew/test/cmd/leaves_spec.rb
+++ b/Library/Homebrew/test/cmd/leaves_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/leaves"
 require "cmd/shared_examples/args_parse"
 
-describe "brew leaves" do
+RSpec.describe Homebrew::Cmd::Leaves do
   it_behaves_like "parseable arguments"
 
   context "when there are no installed Formulae", :integration_test do
diff --git a/Library/Homebrew/test/cmd/link_spec.rb b/Library/Homebrew/test/cmd/link_spec.rb
index 021294dd4d4ee..0c4039364e933 100644
--- a/Library/Homebrew/test/cmd/link_spec.rb
+++ b/Library/Homebrew/test/cmd/link_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/link"
 require "cmd/shared_examples/args_parse"
 
-describe "brew link" do
+RSpec.describe Homebrew::Cmd::Link do
   it_behaves_like "parseable arguments"
 
   it "links a given Formula", :integration_test do
diff --git a/Library/Homebrew/test/cmd/list_spec.rb b/Library/Homebrew/test/cmd/list_spec.rb
index 7c8d55610fa6b..97a6f1466a1db 100644
--- a/Library/Homebrew/test/cmd/list_spec.rb
+++ b/Library/Homebrew/test/cmd/list_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/list"
 require "cmd/shared_examples/args_parse"
 
-describe "brew list" do
+RSpec.describe Homebrew::Cmd::List do
   let(:formulae) { %w[bar foo qux] }
 
   it_behaves_like "parseable arguments"
@@ -18,4 +18,6 @@
       .and not_to_output.to_stderr
       .and be_a_success
   end
+
+  # TODO: add a test for the shell fast-path (`brew_sh`)
 end
diff --git a/Library/Homebrew/test/cmd/log_spec.rb b/Library/Homebrew/test/cmd/log_spec.rb
index 909109bd8a1d1..4f91f9aeb2ed0 100644
--- a/Library/Homebrew/test/cmd/log_spec.rb
+++ b/Library/Homebrew/test/cmd/log_spec.rb
@@ -1,15 +1,15 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/log"
 require "cmd/shared_examples/args_parse"
 
-describe "brew log" do
+RSpec.describe Homebrew::Cmd::Log do
   it_behaves_like "parseable arguments"
 
   it "shows the Git log for a given Formula", :integration_test do
     setup_test_formula "testball"
 
-    core_tap = CoreTap.new
+    core_tap = CoreTap.instance
     core_tap.path.cd do
       system "git", "init"
       system "git", "add", "--all"
diff --git a/Library/Homebrew/test/cmd/migrate_spec.rb b/Library/Homebrew/test/cmd/migrate_spec.rb
index a562f4b9fcc13..0e592a3f037cd 100644
--- a/Library/Homebrew/test/cmd/migrate_spec.rb
+++ b/Library/Homebrew/test/cmd/migrate_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/migrate"
 require "cmd/shared_examples/args_parse"
 
-describe "brew migrate" do
+RSpec.describe Homebrew::Cmd::Migrate do
   it_behaves_like "parseable arguments"
 
   it "migrates a renamed Formula", :integration_test do
@@ -12,7 +12,7 @@
     install_and_rename_coretap_formula "testball1", "testball2"
 
     expect { brew "migrate", "testball1" }
-      .to output(/Processing testball1 formula rename to testball2/).to_stdout
+      .to output(/Migrating formula testball1 to testball2/).to_stdout
       .and not_to_output.to_stderr
       .and be_a_success
   end
diff --git a/Library/Homebrew/test/cmd/missing_spec.rb b/Library/Homebrew/test/cmd/missing_spec.rb
index ab93d64ea20a5..d1cbb37d8b85f 100644
--- a/Library/Homebrew/test/cmd/missing_spec.rb
+++ b/Library/Homebrew/test/cmd/missing_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/missing"
 require "cmd/shared_examples/args_parse"
 
-describe "brew missing" do
+RSpec.describe Homebrew::Cmd::Missing do
   it_behaves_like "parseable arguments"
 
   it "prints missing dependencies", :integration_test do
diff --git a/Library/Homebrew/test/cmd/nodenv-sync_spec.rb b/Library/Homebrew/test/cmd/nodenv-sync_spec.rb
new file mode 100644
index 0000000000000..3f85ff760fd0d
--- /dev/null
+++ b/Library/Homebrew/test/cmd/nodenv-sync_spec.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "cmd/nodenv-sync"
+require "cmd/shared_examples/args_parse"
+
+RSpec.describe Homebrew::Cmd::NodenvSync do
+  it_behaves_like "parseable arguments"
+end
diff --git a/Library/Homebrew/test/cmd/options_spec.rb b/Library/Homebrew/test/cmd/options_spec.rb
index 7205437d85221..53848baaf80bd 100644
--- a/Library/Homebrew/test/cmd/options_spec.rb
+++ b/Library/Homebrew/test/cmd/options_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/options"
 require "cmd/shared_examples/args_parse"
 
-describe "brew options" do
+RSpec.describe Homebrew::Cmd::OptionsCmd do
   it_behaves_like "parseable arguments"
 
   it "prints a given Formula's options", :integration_test do
diff --git a/Library/Homebrew/test/cmd/outdated_spec.rb b/Library/Homebrew/test/cmd/outdated_spec.rb
index 4f90fa2d581fa..c2af5d43b9aa2 100644
--- a/Library/Homebrew/test/cmd/outdated_spec.rb
+++ b/Library/Homebrew/test/cmd/outdated_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/outdated"
 require "cmd/shared_examples/args_parse"
 
-describe "brew outdated" do
+RSpec.describe Homebrew::Cmd::Outdated do
   it_behaves_like "parseable arguments"
 
   it "outputs JSON", :integration_test do
diff --git a/Library/Homebrew/test/cmd/pin_spec.rb b/Library/Homebrew/test/cmd/pin_spec.rb
index efaf4755ffce1..15c978f032933 100644
--- a/Library/Homebrew/test/cmd/pin_spec.rb
+++ b/Library/Homebrew/test/cmd/pin_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/pin"
 require "cmd/shared_examples/args_parse"
 
-describe "brew pin" do
+RSpec.describe Homebrew::Cmd::Pin do
   it_behaves_like "parseable arguments"
 
   it "pins a Formula's version", :integration_test do
diff --git a/Library/Homebrew/test/cmd/postinstall_spec.rb b/Library/Homebrew/test/cmd/postinstall_spec.rb
index a705e44db8cf3..4acab78340787 100644
--- a/Library/Homebrew/test/cmd/postinstall_spec.rb
+++ b/Library/Homebrew/test/cmd/postinstall_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/postinstall"
 require "cmd/shared_examples/args_parse"
 
-describe "brew postinstall" do
+RSpec.describe Homebrew::Cmd::Postinstall do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/cmd/pyenv-sync_spec.rb b/Library/Homebrew/test/cmd/pyenv-sync_spec.rb
new file mode 100644
index 0000000000000..a462c2d917f80
--- /dev/null
+++ b/Library/Homebrew/test/cmd/pyenv-sync_spec.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "cmd/pyenv-sync"
+require "cmd/shared_examples/args_parse"
+
+RSpec.describe Homebrew::Cmd::PyenvSync do
+  it_behaves_like "parseable arguments"
+end
diff --git a/Library/Homebrew/test/cmd/rbenv-sync_spec.rb b/Library/Homebrew/test/cmd/rbenv-sync_spec.rb
new file mode 100644
index 0000000000000..7196f77e25c3e
--- /dev/null
+++ b/Library/Homebrew/test/cmd/rbenv-sync_spec.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "cmd/rbenv-sync"
+require "cmd/shared_examples/args_parse"
+
+RSpec.describe Homebrew::Cmd::RbenvSync do
+  it_behaves_like "parseable arguments"
+end
diff --git a/Library/Homebrew/test/cmd/readall_spec.rb b/Library/Homebrew/test/cmd/readall_spec.rb
index 845acd1058aac..00e2b78875b4c 100644
--- a/Library/Homebrew/test/cmd/readall_spec.rb
+++ b/Library/Homebrew/test/cmd/readall_spec.rb
@@ -1,15 +1,15 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/readall"
 require "cmd/shared_examples/args_parse"
 
-describe "brew readall" do
+RSpec.describe Homebrew::Cmd::ReadallCmd do
   it_behaves_like "parseable arguments"
 
   it "imports all Formulae for a given Tap", :integration_test do
     formula_file = setup_test_formula "testball"
 
-    alias_file = CoreTap.new.alias_dir/"foobar"
+    alias_file = CoreTap.instance.alias_dir/"foobar"
     alias_file.parent.mkpath
 
     FileUtils.ln_s formula_file, alias_file
diff --git a/Library/Homebrew/test/cmd/reinstall_spec.rb b/Library/Homebrew/test/cmd/reinstall_spec.rb
index 764f9db9bb57a..fd5690de263fa 100644
--- a/Library/Homebrew/test/cmd/reinstall_spec.rb
+++ b/Library/Homebrew/test/cmd/reinstall_spec.rb
@@ -1,17 +1,17 @@
-# typed: false
 # frozen_string_literal: true
 
 require "extend/ENV"
+require "cmd/reinstall"
 require "cmd/shared_examples/args_parse"
 
-describe "brew reinstall" do
+RSpec.describe Homebrew::Cmd::Reinstall do
   it_behaves_like "parseable arguments"
 
   it "reinstalls a Formula", :integration_test do
     install_test_formula "testball"
     foo_dir = HOMEBREW_CELLAR/"testball/0.1/bin"
     expect(foo_dir).to exist
-    foo_dir.rmtree
+    FileUtils.rm_r(foo_dir)
 
     expect { brew "reinstall", "testball" }
       .to output(/Reinstalling testball/).to_stdout
diff --git a/Library/Homebrew/test/cmd/search_spec.rb b/Library/Homebrew/test/cmd/search_spec.rb
index 01b33a088bf55..78adf8855cabc 100644
--- a/Library/Homebrew/test/cmd/search_spec.rb
+++ b/Library/Homebrew/test/cmd/search_spec.rb
@@ -1,23 +1,12 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/search"
 require "cmd/shared_examples/args_parse"
 
-describe "brew search" do
+RSpec.describe Homebrew::Cmd::SearchCmd do
   it_behaves_like "parseable arguments"
 
-  it "falls back to a GitHub tap search when no formula is found", :integration_test, :needs_macos, :needs_network do
-    setup_test_formula "testball"
-    setup_remote_tap "homebrew/cask"
-
-    expect { brew "search", "homebrew/cask/firefox" }
-      .to output(/firefox/).to_stdout
-      .and be_a_success
-  end
-
-  # doesn't actually need Linux but only want one integration test per-OS.
-  it "finds formula in search", :integration_test, :need_linux do
+  it "finds formula in search", :integration_test do
     setup_test_formula "testball"
 
     expect { brew "search", "testball" }
diff --git a/Library/Homebrew/test/cmd/services_spec.rb b/Library/Homebrew/test/cmd/services_spec.rb
index c9c84e04ff851..09f2564687583 100644
--- a/Library/Homebrew/test/cmd/services_spec.rb
+++ b/Library/Homebrew/test/cmd/services_spec.rb
@@ -1,10 +1,13 @@
-# typed: false
 # frozen_string_literal: true
 
-describe "brew services", :integration_test, :needs_macos, :needs_network do
-  it "allows controlling services" do
-    setup_remote_tap "homebrew/services"
+require "cmd/shared_examples/args_parse"
+
+RSpec.describe "Homebrew::Cmd::Services", :integration_test, :needs_network do
+  before { setup_remote_tap "homebrew/services" }
 
+  it_behaves_like "parseable arguments", command_name: "services"
+
+  it "allows controlling services" do
     expect { brew "services", "list" }
       .to not_to_output.to_stderr
       .and not_to_output.to_stdout
diff --git a/Library/Homebrew/test/cmd/shared_examples/args_parse.rb b/Library/Homebrew/test/cmd/shared_examples/args_parse.rb
index 064e20ea7f369..561cbcbfeb7c0 100644
--- a/Library/Homebrew/test/cmd/shared_examples/args_parse.rb
+++ b/Library/Homebrew/test/cmd/shared_examples/args_parse.rb
@@ -1,18 +1,20 @@
-# typed: false
 # frozen_string_literal: true
 
-shared_examples "parseable arguments" do
-  subject(:method_name) { "#{command_name.tr("-", "_")}_args" }
-
-  let(:command_name) do |example|
-    example.metadata[:example_group][:parent_example_group][:description].delete_prefix("brew ")
+RSpec.shared_examples "parseable arguments" do |command_name: nil|
+  let(:command) do |example|
+    example.metadata.dig(:example_group, :parent_example_group, :description)
   end
 
   it "can parse arguments" do
-    require "dev-cmd/#{command_name}" unless require? "cmd/#{command_name}"
-
-    parser = Homebrew.public_send(method_name)
-
-    expect(parser).to respond_to(:parse)
+    if described_class
+      klass = described_class
+    else
+      # for tests of remote taps, we need to load the command class
+      require(Commands.external_ruby_v2_cmd_path(command_name))
+      klass = Object.const_get(command)
+    end
+    argv = klass.parser.instance_variable_get(:@min_named_args)&.times&.map { "argument" } || []
+    cmd = klass.new(argv)
+    expect(cmd.args).to be_a Homebrew::CLI::Args
   end
 end
diff --git a/Library/Homebrew/test/cmd/tab_spec.rb b/Library/Homebrew/test/cmd/tab_spec.rb
new file mode 100644
index 0000000000000..db67e2ed9b43d
--- /dev/null
+++ b/Library/Homebrew/test/cmd/tab_spec.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "cmd/tab"
+require "cmd/shared_examples/args_parse"
+require "tab"
+
+RSpec.describe Homebrew::Cmd::TabCmd do
+  def installed_on_request?(formula)
+    # `brew` subprocesses can change the tab, invalidating the cached values.
+    Tab.clear_cache
+    Tab.for_formula(formula).installed_on_request
+  end
+
+  it_behaves_like "parseable arguments"
+
+  it "marks or unmarks a formula as installed on request", :integration_test do
+    setup_test_formula "foo",
+                       tab_attributes: { "installed_on_request" => false }
+    foo = Formula["foo"]
+
+    expect { brew "tab", "--installed-on-request", "foo" }
+      .to be_a_success
+      .and output(/foo is now marked as installed on request/).to_stdout
+      .and not_to_output.to_stderr
+    expect(installed_on_request?(foo)).to be true
+
+    expect { brew "tab", "--no-installed-on-request", "foo" }
+      .to be_a_success
+      .and output(/foo is now marked as not installed on request/).to_stdout
+      .and not_to_output.to_stderr
+    expect(installed_on_request?(foo)).to be false
+  end
+end
diff --git a/Library/Homebrew/test/cmd/tap-info_spec.rb b/Library/Homebrew/test/cmd/tap-info_spec.rb
index bc1a68a4a639a..ada71038cdd53 100644
--- a/Library/Homebrew/test/cmd/tap-info_spec.rb
+++ b/Library/Homebrew/test/cmd/tap-info_spec.rb
@@ -1,12 +1,12 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "cmd/tap-info"
 
-describe "brew tap-info" do
+RSpec.describe Homebrew::Cmd::TapInfo do
   it_behaves_like "parseable arguments"
 
-  it "gets information for a given Tap", :integration_test do
+  it "gets information for a given Tap", :integration_test, :needs_network do
     setup_test_tap
 
     expect { brew "tap-info", "--json=v1", "--installed" }
@@ -14,4 +14,11 @@
       .and not_to_output.to_stderr
       .and be_a_success
   end
+
+  it "display brief statistics for all installed taps", :integration_test, :needs_network do
+    expect { brew "tap-info", "HOMEBREW_NO_INSTALL_FROM_API" => nil }
+      .to output(/\d+ taps?, \d+ private/).to_stdout
+      .and not_to_output.to_stderr
+      .and be_a_success
+  end
 end
diff --git a/Library/Homebrew/test/cmd/tap_spec.rb b/Library/Homebrew/test/cmd/tap_spec.rb
index 021dd6677f6a7..5d36439bfb59e 100644
--- a/Library/Homebrew/test/cmd/tap_spec.rb
+++ b/Library/Homebrew/test/cmd/tap_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "cmd/tap"
 
-describe "brew tap" do
+RSpec.describe Homebrew::Cmd::TapCmd do
   it_behaves_like "parseable arguments"
 
   it "taps a given Tap", :integration_test do
diff --git a/Library/Homebrew/test/cmd/uninstall_spec.rb b/Library/Homebrew/test/cmd/uninstall_spec.rb
index c7947d5058047..69c3516c0054f 100644
--- a/Library/Homebrew/test/cmd/uninstall_spec.rb
+++ b/Library/Homebrew/test/cmd/uninstall_spec.rb
@@ -1,11 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/uninstall"
-
 require "cmd/shared_examples/args_parse"
 
-describe "brew uninstall" do
+RSpec.describe Homebrew::Cmd::UninstallCmd do
   it_behaves_like "parseable arguments"
 
   it "uninstalls a given Formula", :integration_test do
diff --git a/Library/Homebrew/test/cmd/unlink_spec.rb b/Library/Homebrew/test/cmd/unlink_spec.rb
index 7c6248d1034d5..e00fd8311dfdf 100644
--- a/Library/Homebrew/test/cmd/unlink_spec.rb
+++ b/Library/Homebrew/test/cmd/unlink_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "cmd/unlink"
 
-describe "brew unlink" do
+RSpec.describe Homebrew::Cmd::UnlinkCmd do
   it_behaves_like "parseable arguments"
 
   it "unlinks a Formula", :integration_test do
diff --git a/Library/Homebrew/test/cmd/unpin_spec.rb b/Library/Homebrew/test/cmd/unpin_spec.rb
index 4bf0de0419575..33912c65fbe50 100644
--- a/Library/Homebrew/test/cmd/unpin_spec.rb
+++ b/Library/Homebrew/test/cmd/unpin_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "cmd/unpin"
 
-describe "brew unpin" do
+RSpec.describe Homebrew::Cmd::Unpin do
   it_behaves_like "parseable arguments"
 
   it "unpins a Formula's version", :integration_test do
diff --git a/Library/Homebrew/test/cmd/untap_spec.rb b/Library/Homebrew/test/cmd/untap_spec.rb
index 2762d110d35e2..fb1d3a77b0e5c 100644
--- a/Library/Homebrew/test/cmd/untap_spec.rb
+++ b/Library/Homebrew/test/cmd/untap_spec.rb
@@ -1,9 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "cmd/untap"
+
+RSpec.describe Homebrew::Cmd::Untap do
+  let(:class_instance) { described_class.new(%w[arg1]) }
 
-describe "brew untap" do
   it_behaves_like "parseable arguments"
 
   it "untaps a given Tap", :integration_test do
@@ -14,4 +16,125 @@
       .and not_to_output.to_stdout
       .and be_a_success
   end
+
+  describe "#installed_formulae_for", :integration_test do
+    shared_examples "finds installed formulae in tap" do
+      def load_formula(name:, with_formula_file: false, mock_install: false)
+        formula = if with_formula_file
+          path = setup_test_formula(name, tap:)
+          Formulary.factory(path)
+        else
+          formula(name, tap:) do
+            url "https://brew.sh/#{name}-1.0.tgz"
+          end
+        end
+
+        if mock_install
+          keg_path = HOMEBREW_CELLAR/name/"1.2.3"
+          keg_path.mkpath
+
+          tab_path = keg_path/AbstractTab::FILENAME
+          tab_path.write <<~JSON
+            {
+              "source": {
+                "tap": "#{tap}"
+              }
+            }
+          JSON
+        end
+
+        formula
+      end
+
+      let!(:currently_installed_formula) do
+        load_formula(name: "current_install", with_formula_file: true, mock_install: true)
+      end
+
+      before do
+        # Formula that is available from a tap but not installed.
+        load_formula(name: "no_install", with_formula_file: true)
+
+        # Formula that was installed from a tap but is no longer available from that tap.
+        load_formula(name: "legacy_install", mock_install: true)
+
+        tap.clear_cache
+      end
+
+      it "returns the expected formulae" do
+        expect(class_instance.installed_formulae_for(tap:).map(&:full_name))
+          .to eq([currently_installed_formula.full_name])
+      end
+    end
+
+    context "with core tap" do
+      let(:tap) { CoreTap.instance }
+
+      include_examples "finds installed formulae in tap"
+    end
+
+    context "with non-core tap" do
+      let(:tap) { Tap.fetch("homebrew", "foo") }
+
+      before do
+        tap.formula_dir.mkpath
+      end
+
+      include_examples "finds installed formulae in tap"
+    end
+  end
+
+  describe "#installed_casks_for", :cask do
+    shared_examples "finds installed casks in tap" do
+      def load_cask(token:, with_cask_file: false, mock_install: false)
+        cask_loader = Cask::CaskLoader::FromContentLoader.new(<<~RUBY, tap:)
+          cask '#{token}' do
+            version "1.2.3"
+            sha256 :no_check
+
+            url 'https://brew.sh/'
+          end
+        RUBY
+
+        cask = cask_loader.load(config: nil)
+
+        if with_cask_file
+          cask_path = tap.cask_dir/"#{token}.rb"
+          cask_path.parent.mkpath
+          cask_path.write cask.source
+        end
+
+        InstallHelper.install_with_caskfile(cask) if mock_install
+
+        cask
+      end
+
+      let!(:currently_installed_cask) do
+        load_cask(token: "current_install", with_cask_file: true, mock_install: true)
+      end
+
+      before do
+        # Cask that is available from a tap but not installed.
+        load_cask(token: "no_install", with_cask_file: true)
+
+        # Cask that was installed from a tap but is no longer available from that tap.
+        load_cask(token: "legacy_install", mock_install: true)
+      end
+
+      it "returns the expected casks" do
+        expect(class_instance.installed_casks_for(tap:)).to eq([currently_installed_cask])
+      end
+    end
+
+    context "with core cask tap" do
+      let(:tap) { CoreCaskTap.instance }
+
+      include_examples "finds installed casks in tap"
+    end
+
+    context "with non-core cask tap" do
+      let(:tap) { Tap.fetch("homebrew", "foo") }
+
+      include_examples "finds installed casks in tap"
+    end
+  end
 end
diff --git a/Library/Homebrew/test/cmd/update-report_spec.rb b/Library/Homebrew/test/cmd/update-report_spec.rb
index 8637764653421..7f36c0d0e5b6f 100644
--- a/Library/Homebrew/test/cmd/update-report_spec.rb
+++ b/Library/Homebrew/test/cmd/update-report_spec.rb
@@ -1,4 +1,3 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/update-report"
@@ -6,20 +5,20 @@
 require "yaml"
 require "cmd/shared_examples/args_parse"
 
-describe "brew update-report" do
+RSpec.describe Homebrew::Cmd::UpdateReport do
   it_behaves_like "parseable arguments"
 
   describe Reporter do
-    let(:tap) { CoreTap.new }
+    let(:tap) { CoreTap.instance }
     let(:reporter_class) do
       Class.new(described_class) do
         def initialize(tap)
           @tap = tap
 
-          ENV["HOMEBREW_UPDATE_BEFORE#{tap.repo_var}"] = "12345678"
-          ENV["HOMEBREW_UPDATE_AFTER#{tap.repo_var}"] = "abcdef00"
+          ENV["HOMEBREW_UPDATE_BEFORE#{tap.repository_var_suffix}"] = "12345678"
+          ENV["HOMEBREW_UPDATE_AFTER#{tap.repository_var_suffix}"] = "abcdef00"
 
-          super(tap)
+          super
         end
       end
     end
@@ -27,8 +26,8 @@ def initialize(tap)
     let(:hub) { ReporterHub.new }
 
     def perform_update(fixture_name = "")
-      allow(Formulary).to receive(:factory).and_return(double(pkg_version: "1.0"))
-      allow(FormulaVersions).to receive(:new).and_return(double(formula_at_revision: "2.0"))
+      allow(Formulary).to receive(:factory).and_return(instance_double(Formula, pkg_version: "1.0"))
+      allow(FormulaVersions).to receive(:new).and_return(instance_double(FormulaVersions, formula_at_revision: "2.0"))
 
       diff = YAML.load_file("#{TEST_FIXTURE_DIR}/updater_fixture.yaml")[fixture_name]
       allow(reporter).to receive(:diff).and_return(diff || "")
@@ -39,9 +38,9 @@ def perform_update(fixture_name = "")
     specify "without revision variable" do
       ENV.delete_if { |k, _v| k.start_with? "HOMEBREW_UPDATE" }
 
-      expect {
+      expect do
         described_class.new(tap)
-      }.to raise_error(Reporter::ReporterRevisionUnsetError)
+      end.to raise_error(Reporter::ReporterRevisionUnsetError)
     end
 
     specify "without any changes" do
@@ -88,14 +87,14 @@ def perform_update(fixture_name = "")
     end
 
     context "when updating a Tap other than the core Tap" do
-      let(:tap) { Tap.new("foo", "bar") }
+      let(:tap) { Tap.fetch("foo", "bar") }
 
       before do
         (tap.path/"Formula").mkpath
       end
 
       after do
-        tap.path.parent.rmtree
+        FileUtils.rm_r(tap.path.parent)
       end
 
       specify "with restructured Tap" do
diff --git a/Library/Homebrew/test/cmd/upgrade_spec.rb b/Library/Homebrew/test/cmd/upgrade_spec.rb
index b87dc988d48b9..4e7953ee74cde 100644
--- a/Library/Homebrew/test/cmd/upgrade_spec.rb
+++ b/Library/Homebrew/test/cmd/upgrade_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "cmd/upgrade"
 
-describe "brew upgrade" do
+RSpec.describe Homebrew::Cmd::UpgradeCmd do
   it_behaves_like "parseable arguments"
 
   it "upgrades a Formula and cleans up old versions", :integration_test do
diff --git a/Library/Homebrew/test/cmd/uses_spec.rb b/Library/Homebrew/test/cmd/uses_spec.rb
index c0526538a9a1e..92d27df77812b 100644
--- a/Library/Homebrew/test/cmd/uses_spec.rb
+++ b/Library/Homebrew/test/cmd/uses_spec.rb
@@ -1,21 +1,46 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "cmd/uses"
+require "fileutils"
+
+RSpec.describe Homebrew::Cmd::Uses do
+  include FileUtils
 
-describe "brew uses" do
   it_behaves_like "parseable arguments"
 
   it "prints the Formulae a given Formula is used by", :integration_test do
-    setup_test_formula "foo"
+    # Included in output
     setup_test_formula "bar"
-    setup_test_formula "baz", <<~RUBY
-      url "https://brew.sh/baz-1.0"
-      depends_on "bar"
+    setup_test_formula "optional", <<~RUBY
+      url "https://brew.sh/optional-1.0"
+      depends_on "bar" => :optional
+    RUBY
+
+    # Excluded from output
+    setup_test_formula "foo"
+    setup_test_formula "test", <<~RUBY
+      url "https://brew.sh/test-1.0"
+      depends_on "foo" => :test
+    RUBY
+    setup_test_formula "build", <<~RUBY
+      url "https://brew.sh/build-1.0"
+      depends_on "foo" => :build
     RUBY
+    setup_test_formula "installed", <<~RUBY
+      url "https://brew.sh/installed-1.0"
+      depends_on "foo"
+    RUBY
+
+    # Mock `Formula#any_version_installed?` by creating the tab in a plausible keg directory
+    %w[foo installed].each do |formula_name|
+      keg_dir = HOMEBREW_CELLAR/formula_name/"1.0"
+      keg_dir.mkpath
+      touch keg_dir/AbstractTab::FILENAME
+    end
 
-    expect { brew "uses", "--recursive", "foo" }
-      .to output(/(bar\nbaz|baz\nbar)/).to_stdout
+    expect { brew "uses", "foo", "--eval-all", "--include-optional", "--missing", "--recursive" }
+      .to output(/^(bar\noptional|optional\nbar)$/).to_stdout
       .and not_to_output.to_stderr
       .and be_a_success
   end
diff --git a/Library/Homebrew/test/commands_spec.rb b/Library/Homebrew/test/commands_spec.rb
index be8f748a6a70b..32c2293e5bfdb 100644
--- a/Library/Homebrew/test/commands_spec.rb
+++ b/Library/Homebrew/test/commands_spec.rb
@@ -1,4 +1,3 @@
-# typed: false
 # frozen_string_literal: true
 
 require "commands"
@@ -27,7 +26,7 @@
   end
 end
 
-describe Commands do
+RSpec.describe Commands do
   include_context "custom internal commands"
 
   specify "::internal_commands" do
@@ -54,7 +53,7 @@
 
       FileUtils.touch "#{dir}/brew-t4"
 
-      allow(Tap).to receive(:cmd_directories).and_return([dir])
+      allow(described_class).to receive(:tap_cmd_directories).and_return([dir])
 
       cmds = described_class.external_commands
 
diff --git a/Library/Homebrew/test/compiler_failure_spec.rb b/Library/Homebrew/test/compiler_failure_spec.rb
index 2be605f4b92ab..a30870c4f9e2c 100644
--- a/Library/Homebrew/test/compiler_failure_spec.rb
+++ b/Library/Homebrew/test/compiler_failure_spec.rb
@@ -1,39 +1,66 @@
-# typed: false
 # frozen_string_literal: true
 
 require "compilers"
 
-describe CompilerFailure do
+RSpec.describe CompilerFailure do
   alias_matcher :fail_with, :be_fails_with
 
   describe "::create" do
     it "creates a failure when given a symbol" do
       failure = described_class.create(:clang)
-      expect(failure).to fail_with(double("Compiler", type: :clang, name: :clang, version: 600))
+      expect(failure).to fail_with(
+        instance_double(CompilerSelector::Compiler, "Compiler", type: :clang, name: :clang, version: 600),
+      )
     end
 
     it "can be given a build number in a block" do
       failure = described_class.create(:clang) { build 700 }
-      expect(failure).to fail_with(double("Compiler", type: :clang, name: :clang, version: 700))
+      expect(failure).to fail_with(
+        instance_double(CompilerSelector::Compiler, "Compiler", type: :clang, name: :clang, version: 700),
+      )
     end
 
     it "can be given an empty block" do
-      failure = described_class.create(:clang) {}
-      expect(failure).to fail_with(double("Compiler", type: :clang, name: :clang, version: 600))
+      failure = described_class.create(:clang) do
+        # do nothing
+      end
+      expect(failure).to fail_with(
+        instance_double(CompilerSelector::Compiler, "Compiler", type: :clang, name: :clang, version: 600),
+      )
     end
 
     it "creates a failure when given a hash" do
       failure = described_class.create(gcc: "7")
-      expect(failure).to fail_with(double("Compiler", type: :gcc, name: "gcc-7", version: Version.new("7")))
-      expect(failure).to fail_with(double("Compiler", type: :gcc, name: "gcc-7", version: Version.new("7.1")))
-      expect(failure).not_to fail_with(double("Compiler", type: :gcc, name: "gcc-6", version: Version.new("6.0")))
+      expect(failure).to fail_with(
+        instance_double(CompilerSelector::Compiler, "Compiler", type: :gcc, name: "gcc-7", version: Version.new("7")),
+      )
+      expect(failure).to fail_with(
+        instance_double(
+          CompilerSelector::Compiler, "Compiler", type: :gcc, name: "gcc-7", version: Version.new("7.1")
+        ),
+      )
+      expect(failure).not_to fail_with(
+        instance_double(
+          CompilerSelector::Compiler, "Compiler", type: :gcc, name: "gcc-6", version: Version.new("6.0")
+        ),
+      )
     end
 
     it "creates a failure when given a hash and a block with aversion" do
       failure = described_class.create(gcc: "7") { version "7.1" }
-      expect(failure).to fail_with(double("Compiler", type: :gcc, name: "gcc-7", version: Version.new("7")))
-      expect(failure).to fail_with(double("Compiler", type: :gcc, name: "gcc-7", version: Version.new("7.1")))
-      expect(failure).not_to fail_with(double("Compiler", type: :gcc, name: "gcc-7", version: Version.new("7.2")))
+      expect(failure).to fail_with(
+        instance_double(CompilerSelector::Compiler, "Compiler", type: :gcc, name: "gcc-7", version: Version.new("7")),
+      )
+      expect(failure).to fail_with(
+        instance_double(
+          CompilerSelector::Compiler, "Compiler", type: :gcc, name: "gcc-7", version: Version.new("7.1")
+        ),
+      )
+      expect(failure).not_to fail_with(
+        instance_double(
+          CompilerSelector::Compiler, "Compiler", type: :gcc, name: "gcc-7", version: Version.new("7.2")
+        ),
+      )
     end
   end
 end
diff --git a/Library/Homebrew/test/compiler_selector_spec.rb b/Library/Homebrew/test/compiler_selector_spec.rb
index 2f421a20bdfbc..e95e4c2e72f31 100644
--- a/Library/Homebrew/test/compiler_selector_spec.rb
+++ b/Library/Homebrew/test/compiler_selector_spec.rb
@@ -1,29 +1,23 @@
-# typed: false
 # frozen_string_literal: true
 
 require "compilers"
 require "software_spec"
 
-describe CompilerSelector do
+RSpec.describe CompilerSelector do
   subject(:selector) { described_class.new(software_spec, versions, compilers) }
 
   let(:compilers) { [:clang, :gnu] }
   let(:software_spec) { SoftwareSpec.new }
   let(:cc) { :clang }
-  let(:versions) do
-    double(
-      llvm_build_version:  Version::NULL,
-      clang_build_version: Version.create("600"),
-    )
-  end
+  let(:versions) { class_double(DevelopmentTools, clang_build_version: Version.new("600")) }
 
   before do
-    allow(versions).to receive(:non_apple_gcc_version) do |name|
+    allow(versions).to receive(:gcc_version) do |name|
       case name
-      when "gcc-7" then Version.create("7.1")
-      when "gcc-6" then Version.create("6.1")
-      when "gcc-5" then Version.create("5.1")
-      when "gcc-4.9" then Version.create("4.9.1")
+      when "gcc-12" then Version.new("12.1")
+      when "gcc-11" then Version.new("11.1")
+      when "gcc-10" then Version.new("10.1")
+      when "gcc-9" then Version.new("9.1")
       else Version::NULL
       end
     end
@@ -35,60 +29,68 @@
     end
 
     it "returns clang if it fails with non-Apple gcc" do
-      software_spec.fails_with(gcc: "7")
+      software_spec.fails_with(gcc: "12")
       expect(selector.compiler).to eq(:clang)
     end
 
-    it "still returns gcc-7 if it fails with gcc without a specific version" do
+    it "still returns gcc-12 if it fails with gcc without a specific version" do
       software_spec.fails_with(:clang)
-      expect(selector.compiler).to eq("gcc-7")
+      expect(selector.compiler).to eq("gcc-12")
     end
 
-    it "returns gcc-6 if gcc formula offers gcc-6 on mac", :needs_macos do
+    it "returns gcc-11 if gcc formula offers gcc-11 on mac", :needs_macos do
       software_spec.fails_with(:clang)
-      allow(Formulary).to receive(:factory).with("gcc").and_return(double(version: Version.new("6.0")))
-      expect(selector.compiler).to eq("gcc-6")
+      allow(Formulary).to receive(:factory)
+        .with("gcc")
+        .and_return(instance_double(Formula, version: Version.new("11.0")))
+      expect(selector.compiler).to eq("gcc-11")
     end
 
-    it "returns gcc-5 if gcc formula offers gcc-5 on linux", :needs_linux do
+    it "returns gcc-10 if gcc formula offers gcc-10 on linux", :needs_linux do
       software_spec.fails_with(:clang)
-      allow(Formulary).to receive(:factory).with("gcc@5").and_return(double(version: Version.new("5.0")))
-      expect(selector.compiler).to eq("gcc-5")
+      allow(Formulary).to receive(:factory)
+        .with("gcc@11")
+        .and_return(instance_double(Formula, version: Version.new("10.0")))
+      expect(selector.compiler).to eq("gcc-10")
     end
 
-    it "returns gcc-6 if gcc formula offers gcc-5 and fails with gcc-5 and gcc-7 on linux", :needs_linux do
+    it "returns gcc-11 if gcc formula offers gcc-10 and fails with gcc-10 and gcc-12 on linux", :needs_linux do
       software_spec.fails_with(:clang)
-      software_spec.fails_with(gcc: "5")
-      software_spec.fails_with(gcc: "7")
-      allow(Formulary).to receive(:factory).with("gcc@5").and_return(double(version: Version.new("5.0")))
-      expect(selector.compiler).to eq("gcc-6")
+      software_spec.fails_with(gcc: "10")
+      software_spec.fails_with(gcc: "12")
+      allow(Formulary).to receive(:factory)
+        .with("gcc@11")
+        .and_return(instance_double(Formula, version: Version.new("10.0")))
+      expect(selector.compiler).to eq("gcc-11")
     end
 
-    it "returns gcc-7 if gcc formula offers gcc-5 and fails with gcc <= 6 on linux", :needs_linux do
+    it "returns gcc-12 if gcc formula offers gcc-11 and fails with gcc <= 11 on linux", :needs_linux do
       software_spec.fails_with(:clang)
-      software_spec.fails_with(:gcc) { version "6" }
-      allow(Formulary).to receive(:factory).with("gcc@5").and_return(double(version: Version.new("5.0")))
-      expect(selector.compiler).to eq("gcc-7")
+      software_spec.fails_with(:gcc) { version "11" }
+      allow(Formulary).to receive(:factory)
+        .with("gcc@11")
+        .and_return(instance_double(Formula, version: Version.new("11.0")))
+      expect(selector.compiler).to eq("gcc-12")
     end
 
-    it "returns gcc-7 if gcc-7 is version 7.1 but spec fails with gcc-7 <= 7.0" do
+    it "returns gcc-12 if gcc-12 is version 12.1 but spec fails with gcc-12 <= 12.0" do
       software_spec.fails_with(:clang)
-      software_spec.fails_with(gcc: "7") { version "7.0" }
-      expect(selector.compiler).to eq("gcc-7")
+      software_spec.fails_with(gcc: "12") { version "12.0" }
+      expect(selector.compiler).to eq("gcc-12")
     end
 
-    it "returns gcc-6 if gcc-7 is version 7.1 but spec fails with gcc-7 <= 7.1" do
+    it "returns gcc-11 if gcc-12 is version 12.1 but spec fails with gcc-12 <= 12.1" do
       software_spec.fails_with(:clang)
-      software_spec.fails_with(gcc: "7") { version "7.1" }
-      expect(selector.compiler).to eq("gcc-6")
+      software_spec.fails_with(gcc: "12") { version "12.1" }
+      expect(selector.compiler).to eq("gcc-11")
     end
 
     it "raises an error when gcc or llvm is missing (hash syntax)" do
       software_spec.fails_with(:clang)
-      software_spec.fails_with(gcc: "7")
-      software_spec.fails_with(gcc: "6")
-      software_spec.fails_with(gcc: "5")
-      software_spec.fails_with(gcc: "4.9")
+      software_spec.fails_with(gcc: "12")
+      software_spec.fails_with(gcc: "11")
+      software_spec.fails_with(gcc: "10")
+      software_spec.fails_with(gcc: "9")
 
       expect { selector.compiler }.to raise_error(CompilerSelectionError)
     end
diff --git a/Library/Homebrew/test/completions_spec.rb b/Library/Homebrew/test/completions_spec.rb
index 10998ef8876bf..5180762217eff 100644
--- a/Library/Homebrew/test/completions_spec.rb
+++ b/Library/Homebrew/test/completions_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "completions"
 
-describe Homebrew::Completions do
+RSpec.describe Homebrew::Completions do
   let(:completions_dir) { HOMEBREW_REPOSITORY/"completions" }
   let(:internal_path) { HOMEBREW_REPOSITORY/"Library/Taps/homebrew/homebrew-bar" }
   let(:external_path) { HOMEBREW_REPOSITORY/"Library/Taps/foo/homebrew-bar" }
@@ -151,12 +150,14 @@ def delete_completions_setting(setting: "linkcompletions")
   end
 
   context "when generating completions" do
-    describe ".update_shell_completions!" do
-      it "generates shell completions" do
-        described_class.update_shell_completions!
-        expect(completions_dir/"bash/brew").to be_a_file
-      end
-    end
+    # TODO: re-enable this test if it can be made to take ~ 1 second or there's
+    #       an actual regression.
+    # describe ".update_shell_completions!" do
+    #   it "generates shell completions" do
+    #     described_class.update_shell_completions!
+    #     expect(completions_dir/"bash/brew").to be_a_file
+    #   end
+    # end
 
     describe ".format_description" do
       it "escapes single quotes" do
@@ -200,7 +201,7 @@ def delete_completions_setting(setting: "linkcompletions")
           "--force"       => "Always do a slower, full update check (even if unnecessary).",
           "--help"        => "Show this message.",
           "--merge"       => "Use `git merge` to apply updates (rather than `git rebase`).",
-          "--quiet"       => "Make some output more quiet",
+          "--quiet"       => "Make some output more quiet.",
           "--verbose"     => "Print the directories checked and `git` operations performed.",
         }
         expect(described_class.command_options("update")).to eq expected_options
@@ -208,9 +209,9 @@ def delete_completions_setting(setting: "linkcompletions")
 
       it "handles --[no]- options correctly" do
         options = described_class.command_options("audit")
-        expect(options.key?("--appcast")).to be true
-        expect(options.key?("--no-appcast")).to be true
-        expect(options["--appcast"] == options["--no-appcast"]).to be true
+        expect(options.key?("--signing")).to be true
+        expect(options.key?("--no-signing")).to be true
+        expect(options["--signing"] == options["--no-signing"]).to be true
       end
 
       it "return an empty array if command is not found" do
@@ -221,9 +222,9 @@ def delete_completions_setting(setting: "linkcompletions")
         expect(described_class.command_options("help")).to eq({})
       end
 
-      it "will override global options with local descriptions" do
+      it "overrides global options with local descriptions" do
         options = described_class.command_options("upgrade")
-        expect(options["--verbose"]).to eq "Print the verification and postinstall steps."
+        expect(options["--verbose"]).to eq "Print the verification and post-install steps."
       end
     end
 
@@ -262,7 +263,7 @@ def delete_completions_setting(setting: "linkcompletions")
                 "
                 return
                 ;;
-              *)
+              *) ;;
             esac
             __brew_complete_formulae
           }
@@ -287,7 +288,7 @@ def delete_completions_setting(setting: "linkcompletions")
                 "
                 return
                 ;;
-              *)
+              *) ;;
             esac
           }
         COMPLETION
@@ -295,7 +296,7 @@ def delete_completions_setting(setting: "linkcompletions")
 
       it "returns appropriate completion for a command with multiple named arg types" do
         completion = described_class.generate_bash_subcommand_completion("upgrade")
-        expect(completion).to match(/__brew_complete_outdated_formulae\n  __brew_complete_outdated_casks\n}$/)
+        expect(completion).to match(/__brew_complete_installed_formulae\n  __brew_complete_installed_casks\n}$/)
       end
     end
 
@@ -416,10 +417,10 @@ def delete_completions_setting(setting: "linkcompletions")
         completion = described_class.generate_fish_subcommand_completion("upgrade")
         expected_line_start = "__fish_brew_complete_arg 'upgrade; and not __fish_seen_argument"
         expect(completion).to match(
-          /#{expected_line_start} -l cask -l casks' -a '\(__fish_brew_suggest_formulae_outdated\)'/,
+          /#{expected_line_start} -l cask -l casks' -a '\(__fish_brew_suggest_formulae_installed\)'/,
         )
         expect(completion).to match(
-          /#{expected_line_start} -l formula -l formulae' -a '\(__fish_brew_suggest_casks_outdated\)'/,
+          /#{expected_line_start} -l formula -l formulae' -a '\(__fish_brew_suggest_casks_installed\)'/,
         )
       end
     end
diff --git a/Library/Homebrew/test/cxxstdlib_spec.rb b/Library/Homebrew/test/cxxstdlib_spec.rb
index 9da0a32b29e6a..b5bb1e780ccaa 100644
--- a/Library/Homebrew/test/cxxstdlib_spec.rb
+++ b/Library/Homebrew/test/cxxstdlib_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula"
 require "cxxstdlib"
 
-describe CxxStdlib do
+RSpec.describe CxxStdlib do
   let(:clang) { described_class.create(:libstdcxx, :clang) }
   let(:lcxx) { described_class.create(:libcxx, :clang) }
 
diff --git a/Library/Homebrew/test/dependable_spec.rb b/Library/Homebrew/test/dependable_spec.rb
index 12fabd6f3e887..f9f38d078c37e 100644
--- a/Library/Homebrew/test/dependable_spec.rb
+++ b/Library/Homebrew/test/dependable_spec.rb
@@ -1,14 +1,18 @@
-# typed: false
 # frozen_string_literal: true
 
 require "dependable"
 
-describe Dependable do
+RSpec.describe Dependable do
   alias_matcher :be_a_build_dependency, :be_build
 
-  subject(:dependable) { double(tags: tags).extend(described_class) }
-
-  let(:tags) { ["foo", "bar", :build] }
+  subject(:dependable) do
+    Class.new do
+      include Dependable
+      def initialize
+        @tags = ["foo", "bar", :build]
+      end
+    end.new
+  end
 
   specify "#options" do
     expect(dependable.options.as_flags.sort).to eq(%w[--foo --bar].sort)
diff --git a/Library/Homebrew/test/dependencies_helpers_spec.rb b/Library/Homebrew/test/dependencies_helpers_spec.rb
index 4f3ab714dbb72..bae4998fe1d99 100644
--- a/Library/Homebrew/test/dependencies_helpers_spec.rb
+++ b/Library/Homebrew/test/dependencies_helpers_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "dependencies_helpers"
 
-describe DependenciesHelpers do
+RSpec.describe DependenciesHelpers do
   specify "#dependents" do
     foo = formula "foo" do
       url "foo"
diff --git a/Library/Homebrew/test/dependencies_spec.rb b/Library/Homebrew/test/dependencies_spec.rb
index 23119824fabf9..6f2c2e80a4d00 100644
--- a/Library/Homebrew/test/dependencies_spec.rb
+++ b/Library/Homebrew/test/dependencies_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "dependencies"
 require "dependency"
 
-describe Dependencies do
+RSpec.describe Dependencies do
   subject(:dependencies) { described_class.new }
 
   describe "#<<" do
diff --git a/Library/Homebrew/test/dependency_collector_spec.rb b/Library/Homebrew/test/dependency_collector_spec.rb
index a12c3c61278f6..5d7b84906d61a 100644
--- a/Library/Homebrew/test/dependency_collector_spec.rb
+++ b/Library/Homebrew/test/dependency_collector_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "dependency_collector"
 
-describe DependencyCollector do
+RSpec.describe DependencyCollector do
   alias_matcher :be_a_build_requirement, :be_build
 
   subject(:collector) { described_class.new }
@@ -53,13 +52,13 @@ def find_requirement(klass)
     it "creates a resource dependency from a CVS URL" do
       resource = Resource.new
       resource.url(":pserver:anonymous:@brew.sh:/cvsroot/foo/bar", using: :cvs)
-      expect(collector.add(resource)).to eq(Dependency.new("cvs", [:build, :test]))
+      expect(collector.add(resource)).to eq(Dependency.new("cvs", [:build, :test, :implicit]))
     end
 
     it "creates a resource dependency from a '.7z' URL" do
       resource = Resource.new
       resource.url("https://brew.sh/foo.7z")
-      expect(collector.add(resource)).to eq(Dependency.new("p7zip", [:build, :test]))
+      expect(collector.add(resource)).to eq(Dependency.new("p7zip", [:build, :test, :implicit]))
     end
 
     it "creates a resource dependency from a '.gz' URL" do
@@ -71,25 +70,25 @@ def find_requirement(klass)
     it "creates a resource dependency from a '.lz' URL" do
       resource = Resource.new
       resource.url("https://brew.sh/foo.lz")
-      expect(collector.add(resource)).to eq(Dependency.new("lzip", [:build, :test]))
+      expect(collector.add(resource)).to eq(Dependency.new("lzip", [:build, :test, :implicit]))
     end
 
     it "creates a resource dependency from a '.lha' URL" do
       resource = Resource.new
       resource.url("https://brew.sh/foo.lha")
-      expect(collector.add(resource)).to eq(Dependency.new("lha", [:build, :test]))
+      expect(collector.add(resource)).to eq(Dependency.new("lha", [:build, :test, :implicit]))
     end
 
     it "creates a resource dependency from a '.lzh' URL" do
       resource = Resource.new
       resource.url("https://brew.sh/foo.lzh")
-      expect(collector.add(resource)).to eq(Dependency.new("lha", [:build, :test]))
+      expect(collector.add(resource)).to eq(Dependency.new("lha", [:build, :test, :implicit]))
     end
 
     it "creates a resource dependency from a '.rar' URL" do
       resource = Resource.new
       resource.url("https://brew.sh/foo.rar")
-      expect(collector.add(resource)).to eq(Dependency.new("unrar", [:build, :test]))
+      expect(collector.add(resource)).to eq(Dependency.new("libarchive", [:build, :test, :implicit]))
     end
 
     it "raises a TypeError for unknown classes" do
diff --git a/Library/Homebrew/test/dependency_expansion_spec.rb b/Library/Homebrew/test/dependency_expansion_spec.rb
index b0e5b8a6c8c42..7876ecc50ec8d 100644
--- a/Library/Homebrew/test/dependency_expansion_spec.rb
+++ b/Library/Homebrew/test/dependency_expansion_spec.rb
@@ -1,12 +1,12 @@
-# typed: false
 # frozen_string_literal: true
 
 require "dependency"
 
-describe Dependency do
+RSpec.describe Dependency do
   def build_dep(name, tags = [], deps = [])
     dep = described_class.new(name.to_s, tags)
-    allow(dep).to receive(:to_formula).and_return(double(deps: deps, name: name))
+    allow(dep).to receive(:to_formula).and_return \
+      instance_double(Formula, deps:, name:, full_name: name)
     dep
   end
 
@@ -15,7 +15,7 @@ def build_dep(name, tags = [], deps = [])
   let(:baz) { build_dep(:baz) }
   let(:qux) { build_dep(:qux) }
   let(:deps) { [foo, bar, baz, qux] }
-  let(:formula) { double(deps: deps, name: "f") }
+  let(:formula) { instance_double(Formula, deps:, name: "f") }
 
   describe "::expand" do
     it "yields dependent and dependency pairs" do
@@ -44,20 +44,21 @@ def build_dep(name, tags = [], deps = [])
     end
 
     it "preserves dependency order" do
-      allow(foo).to receive(:to_formula).and_return(double(name: "f", deps: [qux, baz]))
+      allow(foo).to receive(:to_formula).and_return \
+        instance_double(Formula, name: "foo", full_name: "foo", deps: [qux, baz])
       expect(described_class.expand(formula)).to eq([qux, baz, foo, bar])
     end
   end
 
   it "skips optionals by default" do
     deps = [build_dep(:foo, [:optional]), bar, baz, qux]
-    f = double(deps: deps, build: double(with?: false), name: "f")
+    f = instance_double(Formula, deps:, build: instance_double(BuildOptions, with?: false), name: "f")
     expect(described_class.expand(f)).to eq([bar, baz, qux])
   end
 
   it "keeps recommended dependencies by default" do
     deps = [build_dep(:foo, [:recommended]), bar, baz, qux]
-    f = double(deps: deps, build: double(with?: true), name: "f")
+    f = instance_double(Formula, deps:, build: instance_double(BuildOptions, with?: true), name: "f")
     expect(described_class.expand(f)).to eq(deps)
   end
 
@@ -72,14 +73,6 @@ def build_dep(name, tags = [], deps = [])
     end
   end
 
-  it "merges dependencies and preserves env_proc" do
-    env_proc = double
-    dep = described_class.new("foo", [], env_proc)
-    allow(dep).to receive(:to_formula).and_return(double(deps: [], name: "foo"))
-    deps.replace([dep])
-    expect(described_class.expand(formula).first.env_proc).to eq(env_proc)
-  end
-
   it "merges tags without duplicating them" do
     foo2 = build_dep(:foo, ["option"])
     foo3 = build_dep(:foo, ["option"])
@@ -89,7 +82,8 @@ def build_dep(name, tags = [], deps = [])
   end
 
   it "skips parent but yields children with ::skip" do
-    f = double(
+    f = instance_double(
+      Formula,
       name: "f",
       deps: [
         build_dep(:foo, [], [bar, baz]),
@@ -107,7 +101,7 @@ def build_dep(name, tags = [], deps = [])
   it "keeps dependency but prunes recursive dependencies with ::keep_but_prune_recursive_deps" do
     foo = build_dep(:foo, [:test], bar)
     baz = build_dep(:baz, [:test])
-    f = double(name: "f", deps: [foo, baz])
+    f = instance_double(Formula, name: "f", deps: [foo, baz])
 
     deps = described_class.expand(f) do |_dependent, dep|
       described_class.keep_but_prune_recursive_deps if dep.test?
@@ -124,15 +118,16 @@ def build_dep(name, tags = [], deps = [])
   it "doesn't raise an error when a dependency is cyclic" do
     foo = build_dep(:foo)
     bar = build_dep(:bar, [], [foo])
-    allow(foo).to receive(:to_formula).and_return(double(deps: [bar], name: foo.name))
-    f = double(name: "f", deps: [foo, bar])
+    allow(foo).to receive(:to_formula).and_return \
+      instance_double(Formula, deps: [bar], name: foo.name, full_name: foo.name)
+    f = instance_double(Formula, name: "f", full_name: "f", deps: [foo, bar])
     expect { described_class.expand(f) }.not_to raise_error
   end
 
   it "cleans the expand stack" do
     foo = build_dep(:foo)
     allow(foo).to receive(:to_formula).and_raise(FormulaUnavailableError, foo.name)
-    f = double(name: "f", deps: [foo])
+    f = instance_double(Formula, name: "f", deps: [foo])
     expect { described_class.expand(f) }.to raise_error(FormulaUnavailableError)
     expect(described_class.instance_variable_get(:@expand_stack)).to be_empty
   end
diff --git a/Library/Homebrew/test/dependency_spec.rb b/Library/Homebrew/test/dependency_spec.rb
index b20c1ef6a769f..7472335310709 100644
--- a/Library/Homebrew/test/dependency_spec.rb
+++ b/Library/Homebrew/test/dependency_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "dependency"
 
-describe Dependency do
+RSpec.describe Dependency do
   alias_matcher :be_a_build_dependency, :be_build
 
   describe "::new" do
@@ -34,22 +33,18 @@
 
   describe "::merge_repeats" do
     it "merges duplicate dependencies" do
-      dep = described_class.new("foo", [:build], nil, "foo")
-      dep2 = described_class.new("foo", ["bar"], nil, "foo2")
-      dep3 = described_class.new("xyz", ["abc"], nil, "foo")
+      dep = described_class.new("foo", [:build])
+      dep2 = described_class.new("foo", ["bar"])
+      dep3 = described_class.new("xyz", ["abc"])
       merged = described_class.merge_repeats([dep, dep2, dep3])
       expect(merged.count).to eq(2)
       expect(merged.first).to be_a described_class
 
       foo_named_dep = merged.find { |d| d.name == "foo" }
       expect(foo_named_dep.tags).to eq(["bar"])
-      expect(foo_named_dep.option_names).to include("foo")
-      expect(foo_named_dep.option_names).to include("foo2")
 
       xyz_named_dep = merged.find { |d| d.name == "xyz" }
       expect(xyz_named_dep.tags).to eq(["abc"])
-      expect(xyz_named_dep.option_names).to include("foo")
-      expect(xyz_named_dep.option_names).not_to include("foo2")
     end
 
     it "merges necessity tags" do
@@ -101,15 +96,20 @@
     expect(foo1).not_to eql(foo3)
   end
 
-  describe TapDependency do
-    subject(:dependency) { described_class.new("foo/bar/dog") }
-
-    specify "#tap" do
-      expect(dependency.tap).to eq(Tap.new("foo", "bar"))
+  describe "#tap" do
+    it "returns a tap passed a fully-qualified name" do
+      dependency = described_class.new("foo/bar/dog")
+      expect(dependency.tap).to eq(Tap.fetch("foo", "bar"))
     end
 
-    specify "#option_names" do
-      expect(dependency.option_names).to eq(%w[dog])
+    it "returns no tap passed a simple name" do
+      dependency = described_class.new("dog")
+      expect(dependency.tap).to be_nil
     end
   end
+
+  specify "#option_names" do
+    dependency = described_class.new("foo/bar/dog")
+    expect(dependency.option_names).to eq(%w[dog])
+  end
 end
diff --git a/Library/Homebrew/test/deprecate_disable_spec.rb b/Library/Homebrew/test/deprecate_disable_spec.rb
new file mode 100644
index 0000000000000..9f20602391630
--- /dev/null
+++ b/Library/Homebrew/test/deprecate_disable_spec.rb
@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "deprecate_disable"
+
+RSpec.describe DeprecateDisable do
+  let(:deprecated_formula) do
+    instance_double(Formula, deprecated?: true, disabled?: false, deprecation_reason: :does_not_build,
+                    deprecation_date: nil, disable_date: nil)
+  end
+  let(:disabled_formula) do
+    instance_double(Formula, deprecated?: false, disabled?: true, disable_reason: "is broken",
+                    deprecation_date: nil, disable_date: nil)
+  end
+  let(:deprecated_cask) do
+    instance_double(Cask::Cask, deprecated?: true, disabled?: false, deprecation_reason: :discontinued,
+                   deprecation_date: nil, disable_date: nil)
+  end
+  let(:disabled_cask) do
+    instance_double(Cask::Cask, deprecated?: false, disabled?: true, disable_reason: nil,
+                    deprecation_date: nil, disable_date: nil)
+  end
+
+  before do
+    allow(deprecated_formula).to receive(:is_a?).with(Formula).and_return(true)
+    allow(deprecated_formula).to receive(:is_a?).with(Cask::Cask).and_return(false)
+    allow(disabled_formula).to receive(:is_a?).with(Formula).and_return(true)
+    allow(disabled_formula).to receive(:is_a?).with(Cask::Cask).and_return(false)
+    allow(deprecated_cask).to receive(:is_a?).with(Formula).and_return(false)
+    allow(deprecated_cask).to receive(:is_a?).with(Cask::Cask).and_return(true)
+    allow(disabled_cask).to receive(:is_a?).with(Formula).and_return(false)
+    allow(disabled_cask).to receive(:is_a?).with(Cask::Cask).and_return(true)
+  end
+
+  describe "::type" do
+    it "returns :deprecated if the formula is deprecated" do
+      expect(described_class.type(deprecated_formula)).to eq :deprecated
+    end
+
+    it "returns :disabled if the formula is disabled" do
+      expect(described_class.type(disabled_formula)).to eq :disabled
+    end
+
+    it "returns :deprecated if the cask is deprecated" do
+      expect(described_class.type(deprecated_cask)).to eq :deprecated
+    end
+
+    it "returns :disabled if the cask is disabled" do
+      expect(described_class.type(disabled_cask)).to eq :disabled
+    end
+  end
+
+  describe "::message" do
+    it "returns a deprecation message with a preset formula reason" do
+      expect(described_class.message(deprecated_formula))
+        .to eq "deprecated because it does not build!"
+    end
+
+    it "returns a disable message with a custom reason" do
+      expect(described_class.message(disabled_formula))
+        .to eq "disabled because it is broken!"
+    end
+
+    it "returns a deprecation message with a preset cask reason" do
+      expect(described_class.message(deprecated_cask))
+        .to eq "deprecated because it is discontinued upstream!"
+    end
+
+    it "returns a deprecation message with no reason" do
+      expect(described_class.message(disabled_cask))
+        .to eq "disabled!"
+    end
+  end
+
+  describe "::to_reason_string_or_symbol" do
+    it "returns the original string if it isn't a formula preset reason" do
+      expect(described_class.to_reason_string_or_symbol("discontinued", type: :formula)).to eq "discontinued"
+    end
+
+    it "returns the original string if it isn't a cask preset reason" do
+      expect(described_class.to_reason_string_or_symbol("does_not_build", type: :cask)).to eq "does_not_build"
+    end
+
+    it "returns a symbol if the original string is a formula preset reason" do
+      expect(described_class.to_reason_string_or_symbol("does_not_build", type: :formula))
+        .to eq :does_not_build
+    end
+
+    it "returns a symbol if the original string is a cask preset reason" do
+      expect(described_class.to_reason_string_or_symbol("discontinued", type: :cask))
+        .to eq :discontinued
+    end
+  end
+end
diff --git a/Library/Homebrew/test/description_cache_store_spec.rb b/Library/Homebrew/test/description_cache_store_spec.rb
index bff74dfa29038..f5a3ccff17cae 100644
--- a/Library/Homebrew/test/description_cache_store_spec.rb
+++ b/Library/Homebrew/test/description_cache_store_spec.rb
@@ -1,15 +1,17 @@
-# typed: false
 # frozen_string_literal: true
 
+require "cmd/update-report"
 require "description_cache_store"
 
-describe DescriptionCacheStore do
+RSpec.describe DescriptionCacheStore do
   subject(:cache_store) { described_class.new(database) }
 
-  let(:database) { double("database") }
+  let(:database) { instance_double(CacheStoreDatabase, "database") }
   let(:formula_name) { "test_name" }
   let(:description) { "test_description" }
 
+  before { allow(Homebrew::EnvConfig).to receive(:eval_all?).and_return(true) }
+
   describe "#update!" do
     it "sets the formula description" do
       expect(database).to receive(:set).with(formula_name, description)
@@ -25,7 +27,7 @@
   end
 
   describe "#update_from_report!" do
-    let(:report) { double(select_formula_or_cask: [], empty?: false) }
+    let(:report) { instance_double(ReporterHub, select_formula_or_cask: [], empty?: false) }
 
     it "reads from the report" do
       expect(database).to receive(:empty?).at_least(:once).and_return(false)
@@ -57,10 +59,10 @@
   describe CaskDescriptionCacheStore do
     subject(:cache_store) { described_class.new(database) }
 
-    let(:database) { double("database") }
+    let(:database) { instance_double(CacheStoreDatabase, "database") }
 
     describe "#update_from_report!" do
-      let(:report) { double(select_formula_or_cask: [], empty?: false) }
+      let(:report) { instance_double(ReporterHub, select_formula_or_cask: [], empty?: false) }
 
       it "reads from the report" do
         expect(database).to receive(:empty?).at_least(:once).and_return(false)
diff --git a/Library/Homebrew/test/descriptions_spec.rb b/Library/Homebrew/test/descriptions_spec.rb
index 0ea978c455f13..1bbfcf0ed12c8 100644
--- a/Library/Homebrew/test/descriptions_spec.rb
+++ b/Library/Homebrew/test/descriptions_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "descriptions"
 
-describe Descriptions do
+RSpec.describe Descriptions do
   subject(:descriptions) { described_class.new(descriptions_hash) }
 
   let(:descriptions_hash) { {} }
diff --git a/Library/Homebrew/test/dev-cmd/audit_spec.rb b/Library/Homebrew/test/dev-cmd/audit_spec.rb
index 4d401712c0d72..a27ca9e2e12a5 100644
--- a/Library/Homebrew/test/dev-cmd/audit_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/audit_spec.rb
@@ -1,1224 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "dev-cmd/audit"
-require "formulary"
 require "cmd/shared_examples/args_parse"
-require "utils/spdx"
 
-describe "brew audit" do
+RSpec.describe Homebrew::DevCmd::Audit do
   it_behaves_like "parseable arguments"
 end
-
-module Count
-  def self.increment
-    @count ||= 0
-    @count += 1
-  end
-end
-
-module Homebrew
-  describe FormulaTextAuditor do
-    alias_matcher :have_data, :be_data
-    alias_matcher :have_end, :be_end
-    alias_matcher :have_trailing_newline, :be_trailing_newline
-
-    let(:dir) { mktmpdir }
-
-    def formula_text(name, body = nil, options = {})
-      path = dir/"#{name}.rb"
-
-      path.write <<~RUBY
-        class #{Formulary.class_s(name)} < Formula
-          #{body}
-        end
-        #{options[:patch]}
-      RUBY
-
-      described_class.new(path)
-    end
-
-    specify "simple valid Formula" do
-      ft = formula_text "valid", <<~RUBY
-        url "https://www.brew.sh/valid-1.0.tar.gz"
-      RUBY
-
-      expect(ft).to have_trailing_newline
-
-      expect(ft =~ /\burl\b/).to be_truthy
-      expect(ft.line_number(/desc/)).to be_nil
-      expect(ft.line_number(/\burl\b/)).to eq(2)
-      expect(ft).to include("Valid")
-    end
-
-    specify "#trailing_newline?" do
-      ft = formula_text "newline"
-      expect(ft).to have_trailing_newline
-    end
-  end
-
-  describe FormulaAuditor do
-    def formula_auditor(name, text, options = {})
-      path = Pathname.new "#{dir}/#{name}.rb"
-      path.open("w") do |f|
-        f.write text
-      end
-
-      formula = Formulary.factory(path)
-
-      if options.key? :tap_audit_exceptions
-        tap = Tap.fetch("test/tap")
-        allow(tap).to receive(:audit_exceptions).and_return(options[:tap_audit_exceptions])
-        allow(formula).to receive(:tap).and_return(tap)
-        options.delete :tap_audit_exceptions
-      end
-
-      described_class.new(formula, options)
-    end
-
-    let(:dir) { mktmpdir }
-
-    describe "#problems" do
-      it "is empty by default" do
-        fa = formula_auditor "foo", <<~RUBY
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-          end
-        RUBY
-
-        expect(fa.problems).to be_empty
-      end
-    end
-
-    describe "#audit_license" do
-      let(:spdx_license_data) { SPDX.license_data }
-      let(:spdx_exception_data) { SPDX.exception_data }
-
-      let(:deprecated_spdx_id) { "GPL-1.0" }
-      let(:license_all_custom_id) { 'all_of: ["MIT", "zzz"]' }
-      let(:deprecated_spdx_exception) { "Nokia-Qt-exception-1.1" }
-      let(:license_any) { 'any_of: ["0BSD", "GPL-3.0-only"]' }
-      let(:license_any_with_plus) { 'any_of: ["0BSD+", "GPL-3.0-only"]' }
-      let(:license_nested_conditions) { 'any_of: ["0BSD", { all_of: ["GPL-3.0-only", "MIT"] }]' }
-      let(:license_any_mismatch) { 'any_of: ["0BSD", "MIT"]' }
-      let(:license_any_nonstandard) { 'any_of: ["0BSD", "zzz", "MIT"]' }
-      let(:license_any_deprecated) { 'any_of: ["0BSD", "GPL-1.0", "MIT"]' }
-
-      it "does not check if the formula is not a new formula" do
-        fa = formula_auditor "foo", <<~RUBY, new_formula: false
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "detects no license info" do
-        fa = formula_auditor "foo", <<~RUBY, spdx_license_data: spdx_license_data, new_formula: true, core_tap: true
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems.first[:message]).to match "Formulae in homebrew/core must specify a license."
-      end
-
-      it "detects if license is not a standard spdx-id" do
-        fa = formula_auditor "foo", <<~RUBY, spdx_license_data: spdx_license_data, new_formula: true
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            license "zzz"
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems.first[:message]).to match <<~EOS
-          Formula foo contains non-standard SPDX licenses: ["zzz"].
-          For a list of valid licenses check: https://spdx.org/licenses/
-        EOS
-      end
-
-      it "detects if license is a deprecated spdx-id" do
-        fa = formula_auditor "foo", <<~RUBY, spdx_license_data: spdx_license_data, new_formula: true, strict: true
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            license "#{deprecated_spdx_id}"
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems.first[:message]).to match <<~EOS
-          Formula foo contains deprecated SPDX licenses: ["GPL-1.0"].
-          You may need to add `-only` or `-or-later` for GNU licenses (e.g. `GPL`, `LGPL`, `AGPL`, `GFDL`).
-          For a list of valid licenses check: https://spdx.org/licenses/
-        EOS
-      end
-
-      it "detects if license with AND contains a non-standard spdx-id" do
-        fa = formula_auditor "foo", <<~RUBY, spdx_license_data: spdx_license_data, new_formula: true
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            license #{license_all_custom_id}
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems.first[:message]).to match <<~EOS
-          Formula foo contains non-standard SPDX licenses: ["zzz"].
-          For a list of valid licenses check: https://spdx.org/licenses/
-        EOS
-      end
-
-      it "detects if license array contains a non-standard spdx-id" do
-        fa = formula_auditor "foo", <<~RUBY, spdx_license_data: spdx_license_data, new_formula: true
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            license #{license_any_nonstandard}
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems.first[:message]).to match <<~EOS
-          Formula foo contains non-standard SPDX licenses: ["zzz"].
-          For a list of valid licenses check: https://spdx.org/licenses/
-        EOS
-      end
-
-      it "detects if license array contains a deprecated spdx-id" do
-        fa = formula_auditor "foo", <<~RUBY, spdx_license_data: spdx_license_data, new_formula: true, strict: true
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            license #{license_any_deprecated}
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems.first[:message]).to match <<~EOS
-          Formula foo contains deprecated SPDX licenses: ["GPL-1.0"].
-          You may need to add `-only` or `-or-later` for GNU licenses (e.g. `GPL`, `LGPL`, `AGPL`, `GFDL`).
-          For a list of valid licenses check: https://spdx.org/licenses/
-        EOS
-      end
-
-      it "verifies that a license info is a standard spdx id" do
-        fa = formula_auditor "foo", <<~RUBY, spdx_license_data: spdx_license_data, new_formula: true
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            license "0BSD"
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "verifies that a license info with plus is a standard spdx id" do
-        fa = formula_auditor "foo", <<~RUBY, spdx_license_data: spdx_license_data, new_formula: true
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            license "0BSD+"
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "allows :public_domain license" do
-        fa = formula_auditor "foo", <<~RUBY, spdx_license_data: spdx_license_data, new_formula: true
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            license :public_domain
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "verifies that a license info with multiple licenses are standard spdx ids" do
-        fa = formula_auditor "foo", <<~RUBY, spdx_license_data: spdx_license_data, new_formula: true
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            license any_of: ["0BSD", "MIT"]
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "verifies that a license info with exceptions are standard spdx ids" do
-        formula_text = <<~RUBY
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            license "Apache-2.0" => { with: "LLVM-exception" }
-          end
-        RUBY
-        fa = formula_auditor "foo", formula_text, new_formula: true,
-                             spdx_license_data: spdx_license_data, spdx_exception_data: spdx_exception_data
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "verifies that a license array contains only standard spdx id" do
-        fa = formula_auditor "foo", <<~RUBY, spdx_license_data: spdx_license_data, new_formula: true
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            license #{license_any}
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "verifies that a license array contains only standard spdx id with plus" do
-        fa = formula_auditor "foo", <<~RUBY, spdx_license_data: spdx_license_data, new_formula: true
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            license #{license_any_with_plus}
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "verifies that a license array with AND contains only standard spdx ids" do
-        fa = formula_auditor "foo", <<~RUBY, spdx_license_data: spdx_license_data, new_formula: true
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            license #{license_nested_conditions}
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "checks online and verifies that a standard license id is the same " \
-         "as what is indicated on its Github repo", :needs_network do
-        formula_text = <<~RUBY
-          class Cask < Formula
-            url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
-            head "https://github.com/cask/cask.git"
-            license "GPL-3.0"
-          end
-        RUBY
-        fa = formula_auditor "cask", formula_text, spdx_license_data: spdx_license_data,
-                             online: true, core_tap: true, new_formula: true
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "checks online and verifies that a standard license id with AND is the same " \
-         "as what is indicated on its Github repo", :needs_network do
-        formula_text = <<~RUBY
-          class Cask < Formula
-            url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
-            head "https://github.com/cask/cask.git"
-            license all_of: ["GPL-3.0-or-later", "MIT"]
-          end
-        RUBY
-        fa = formula_auditor "cask", formula_text, spdx_license_data: spdx_license_data,
-                             online: true, core_tap: true, new_formula: true
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "checks online and verifies that a standard license id with WITH is the same " \
-         "as what is indicated on its Github repo", :needs_network do
-        formula_text = <<~RUBY
-          class Cask < Formula
-            url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
-            head "https://github.com/cask/cask.git"
-            license "GPL-3.0-or-later" => { with: "LLVM-exception" }
-          end
-        RUBY
-        fa = formula_auditor "cask", formula_text, online: true, core_tap: true, new_formula: true,
-                             spdx_license_data: spdx_license_data, spdx_exception_data: spdx_exception_data
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "verifies that a license exception has standard spdx ids", :needs_network do
-        formula_text = <<~RUBY
-          class Cask < Formula
-            url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
-            head "https://github.com/cask/cask.git"
-            license "GPL-3.0-or-later" => { with: "zzz" }
-          end
-        RUBY
-        fa = formula_auditor "cask", formula_text, core_tap: true, new_formula: true,
-                             spdx_license_data: spdx_license_data, spdx_exception_data: spdx_exception_data
-
-        fa.audit_license
-        expect(fa.problems.first[:message]).to match <<~EOS
-          Formula cask contains invalid or deprecated SPDX license exceptions: ["zzz"].
-          For a list of valid license exceptions check:
-            https://spdx.org/licenses/exceptions-index.html
-        EOS
-      end
-
-      it "verifies that a license exception has non-deprecated spdx ids", :needs_network do
-        formula_text = <<~RUBY
-          class Cask < Formula
-            url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
-            head "https://github.com/cask/cask.git"
-            license "GPL-3.0-or-later" => { with: "#{deprecated_spdx_exception}" }
-          end
-        RUBY
-        fa = formula_auditor "cask", formula_text, core_tap: true, new_formula: true,
-                             spdx_license_data: spdx_license_data, spdx_exception_data: spdx_exception_data
-
-        fa.audit_license
-        expect(fa.problems.first[:message]).to match <<~EOS
-          Formula cask contains invalid or deprecated SPDX license exceptions: ["#{deprecated_spdx_exception}"].
-          For a list of valid license exceptions check:
-            https://spdx.org/licenses/exceptions-index.html
-        EOS
-      end
-
-      it "checks online and verifies that a standard license id is in the same exempted license group" \
-         "as what is indicated on its GitHub repo", :needs_network do
-        fa = formula_auditor "cask", <<~RUBY, spdx_license_data: spdx_license_data, online: true, new_formula: true
-          class Cask < Formula
-            url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
-            head "https://github.com/cask/cask.git"
-            license "GPL-3.0-or-later"
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "checks online and verifies that a standard license array is in the same exempted license group" \
-         "as what is indicated on its GitHub repo", :needs_network do
-        fa = formula_auditor "cask", <<~RUBY, spdx_license_data: spdx_license_data, online: true, new_formula: true
-          class Cask < Formula
-            url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
-            head "https://github.com/cask/cask.git"
-            license any_of: ["GPL-3.0-or-later", "MIT"]
-          end
-        RUBY
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "checks online and detects that a formula-specified license is not " \
-         "the same as what is indicated on its Github repository", :needs_network do
-        formula_text = <<~RUBY
-          class Cask < Formula
-            url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
-            head "https://github.com/cask/cask.git"
-            license "0BSD"
-          end
-        RUBY
-        fa = formula_auditor "cask", formula_text, spdx_license_data: spdx_license_data,
-                             online: true, core_tap: true, new_formula: true
-
-        fa.audit_license
-        expect(fa.problems.first[:message])
-          .to eq 'Formula license ["0BSD"] does not match GitHub license ["GPL-3.0"].'
-      end
-
-      it "allows a formula-specified license that differs from its GitHub " \
-         "repository for formulae on the mismatched license allowlist", :needs_network do
-        formula_text = <<~RUBY
-          class Cask < Formula
-            url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
-            head "https://github.com/cask/cask.git"
-            license "0BSD"
-          end
-        RUBY
-        fa = formula_auditor "cask", formula_text, spdx_license_data: spdx_license_data,
-                             online: true, core_tap: true, new_formula: true,
-                             tap_audit_exceptions: { permitted_formula_license_mismatches: ["cask"] }
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-
-      it "checks online and detects that an array of license does not contain " \
-         "what is indicated on its Github repository", :needs_network do
-        formula_text = <<~RUBY
-          class Cask < Formula
-            url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
-            head "https://github.com/cask/cask.git"
-            license #{license_any_mismatch}
-          end
-        RUBY
-        fa = formula_auditor "cask", formula_text, spdx_license_data: spdx_license_data,
-                             online: true, core_tap: true, new_formula: true
-
-        fa.audit_license
-        expect(fa.problems.first[:message]).to match "Formula license [\"0BSD\", \"MIT\"] " \
-                                                     "does not match GitHub license [\"GPL-3.0\"]."
-      end
-
-      it "checks online and verifies that an array of license contains " \
-         "what is indicated on its Github repository", :needs_network do
-        formula_text = <<~RUBY
-          class Cask < Formula
-            url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
-            head "https://github.com/cask/cask.git"
-            license #{license_any}
-          end
-        RUBY
-        fa = formula_auditor "cask", formula_text, spdx_license_data: spdx_license_data,
-                             online: true, core_tap: true, new_formula: true
-
-        fa.audit_license
-        expect(fa.problems).to be_empty
-      end
-    end
-
-    describe "#audit_file" do
-      specify "no issue" do
-        fa = formula_auditor "foo", <<~RUBY
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            homepage "https://brew.sh"
-          end
-        RUBY
-
-        fa.audit_file
-        expect(fa.problems).to be_empty
-      end
-    end
-
-    describe "#audit_formula_name" do
-      specify "no issue" do
-        fa = formula_auditor "foo", <<~RUBY, core_tap: true, strict: true
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            homepage "https://brew.sh"
-          end
-        RUBY
-
-        fa.audit_formula_name
-        expect(fa.problems).to be_empty
-      end
-
-      specify "uppercase formula name" do
-        fa = formula_auditor "Foo", <<~RUBY
-          class Foo < Formula
-            url "https://brew.sh/Foo-1.0.tgz"
-            homepage "https://brew.sh"
-          end
-        RUBY
-
-        fa.audit_formula_name
-        expect(fa.problems.first[:message]).to match "must not contain uppercase letters"
-      end
-    end
-
-    describe "#check_service_command" do
-      specify "Not installed" do
-        fa = formula_auditor "foo", <<~RUBY
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            homepage "https://brew.sh"
-
-            service do
-              run []
-            end
-          end
-        RUBY
-
-        expect(fa.check_service_command(fa.formula)).to match nil
-      end
-
-      specify "No service" do
-        fa = formula_auditor "foo", <<~RUBY
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            homepage "https://brew.sh"
-          end
-        RUBY
-
-        mkdir_p fa.formula.prefix
-        expect(fa.check_service_command(fa.formula)).to match nil
-      end
-
-      specify "No command" do
-        fa = formula_auditor "foo", <<~RUBY
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            homepage "https://brew.sh"
-
-            service do
-              run []
-            end
-          end
-        RUBY
-
-        mkdir_p fa.formula.prefix
-        expect(fa.check_service_command(fa.formula)).to match "Service command blank"
-      end
-
-      specify "Invalid command" do
-        fa = formula_auditor "foo", <<~RUBY
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            homepage "https://brew.sh"
-
-            service do
-              run [HOMEBREW_PREFIX/"bin/something"]
-            end
-          end
-        RUBY
-
-        mkdir_p fa.formula.prefix
-        expect(fa.check_service_command(fa.formula)).to match "Service command does not exist"
-      end
-    end
-
-    describe "#audit_github_repository" do
-      specify "#audit_github_repository when HOMEBREW_NO_GITHUB_API is set" do
-        ENV["HOMEBREW_NO_GITHUB_API"] = "1"
-
-        fa = formula_auditor "foo", <<~RUBY, strict: true, online: true
-          class Foo < Formula
-            homepage "https://github.com/example/example"
-            url "https://brew.sh/foo-1.0.tgz"
-          end
-        RUBY
-
-        fa.audit_github_repository
-        expect(fa.problems).to be_empty
-      end
-    end
-
-    describe "#audit_github_repository_archived" do
-      specify "#audit_github_repository_archived when HOMEBREW_NO_GITHUB_API is set" do
-        fa = formula_auditor "foo", <<~RUBY, strict: true, online: true
-          class Foo < Formula
-            homepage "https://github.com/example/example"
-            url "https://brew.sh/foo-1.0.tgz"
-          end
-        RUBY
-
-        fa.audit_github_repository_archived
-        expect(fa.problems).to be_empty
-      end
-    end
-
-    describe "#audit_gitlab_repository" do
-      specify "#audit_gitlab_repository for stars, forks and creation date" do
-        fa = formula_auditor "foo", <<~RUBY, strict: true, online: true
-          class Foo < Formula
-            homepage "https://gitlab.com/libtiff/libtiff"
-            url "https://brew.sh/foo-1.0.tgz"
-          end
-        RUBY
-
-        fa.audit_gitlab_repository
-        expect(fa.problems).to be_empty
-      end
-    end
-
-    describe "#audit_gitlab_repository_archived" do
-      specify "#audit gitlab repository for archived status" do
-        fa = formula_auditor "foo", <<~RUBY, strict: true, online: true
-          class Foo < Formula
-            homepage "https://gitlab.com/libtiff/libtiff"
-            url "https://brew.sh/foo-1.0.tgz"
-          end
-        RUBY
-
-        fa.audit_gitlab_repository_archived
-        expect(fa.problems).to be_empty
-      end
-    end
-
-    describe "#audit_bitbucket_repository" do
-      specify "#audit_bitbucket_repository for stars, forks and creation date" do
-        fa = formula_auditor "foo", <<~RUBY, strict: true, online: true
-          class Foo < Formula
-            homepage "https://bitbucket.com/libtiff/libtiff"
-            url "https://brew.sh/foo-1.0.tgz"
-          end
-        RUBY
-
-        fa.audit_bitbucket_repository
-        expect(fa.problems).to be_empty
-      end
-    end
-
-    describe "#audit_specs" do
-      let(:throttle_list) { { throttled_formulae: { "foo" => 10 } } }
-      let(:versioned_head_spec_list) { { versioned_head_spec_allowlist: ["foo"] } }
-
-      it "doesn't allow to miss a checksum" do
-        fa = formula_auditor "foo", <<~RUBY
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-          end
-        RUBY
-
-        fa.audit_specs
-        expect(fa.problems.first[:message]).to match "Checksum is missing"
-      end
-
-      it "allows to miss a checksum for git strategy" do
-        fa = formula_auditor "foo", <<~RUBY
-          class Foo < Formula
-            url "https://brew.sh/foo.git", tag: "1.0", revision: "f5e00e485e7aa4c5baa20355b27e3b84a6912790"
-          end
-        RUBY
-
-        fa.audit_specs
-        expect(fa.problems).to be_empty
-      end
-
-      it "allows to miss a checksum for HEAD" do
-        fa = formula_auditor "foo", <<~RUBY
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
-            head "https://brew.sh/foo.tgz"
-          end
-        RUBY
-
-        fa.audit_specs
-        expect(fa.problems).to be_empty
-      end
-
-      it "allows versions with no throttle rate" do
-        fa = formula_auditor "bar", <<~RUBY, core_tap: true, tap_audit_exceptions: throttle_list
-          class Bar < Formula
-            url "https://brew.sh/foo-1.0.1.tgz"
-            sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
-          end
-        RUBY
-
-        fa.audit_specs
-        expect(fa.problems).to be_empty
-      end
-
-      it "allows major/minor versions with throttle rate" do
-        fa = formula_auditor "foo", <<~RUBY, core_tap: true, tap_audit_exceptions: throttle_list
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.0.tgz"
-            sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
-          end
-        RUBY
-
-        fa.audit_specs
-        expect(fa.problems).to be_empty
-      end
-
-      it "allows patch versions to be multiples of the throttle rate" do
-        fa = formula_auditor "foo", <<~RUBY, core_tap: true, tap_audit_exceptions: throttle_list
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.10.tgz"
-            sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
-          end
-        RUBY
-
-        fa.audit_specs
-        expect(fa.problems).to be_empty
-      end
-
-      it "doesn't allow patch versions that aren't multiples of the throttle rate" do
-        fa = formula_auditor "foo", <<~RUBY, core_tap: true, tap_audit_exceptions: throttle_list
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.1.tgz"
-            sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
-          end
-        RUBY
-
-        fa.audit_specs
-        expect(fa.problems.first[:message]).to match "should only be updated every 10 releases on multiples of 10"
-      end
-
-      it "allows non-versioned formulae to have a `HEAD` spec" do
-        fa = formula_auditor "bar", <<~RUBY, core_tap: true, tap_audit_exceptions: versioned_head_spec_list
-          class Bar < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
-            head "https://brew.sh/foo.git"
-          end
-        RUBY
-
-        fa.audit_specs
-        expect(fa.problems).to be_empty
-      end
-
-      it "doesn't allow versioned formulae to have a `HEAD` spec" do
-        fa = formula_auditor "bar@1", <<~RUBY, core_tap: true, tap_audit_exceptions: versioned_head_spec_list
-          class BarAT1 < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
-            head "https://brew.sh/foo.git"
-          end
-        RUBY
-
-        fa.audit_specs
-        expect(fa.problems.first[:message]).to match "Versioned formulae should not have a `HEAD` spec"
-      end
-
-      it "allows versioned formulae on the allowlist to have a `HEAD` spec" do
-        fa = formula_auditor "foo", <<~RUBY, core_tap: true, tap_audit_exceptions: versioned_head_spec_list
-          class Foo < Formula
-            url "https://brew.sh/foo-1.0.tgz"
-            sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
-            head "https://brew.sh/foo.git"
-          end
-        RUBY
-
-        fa.audit_specs
-        expect(fa.problems).to be_empty
-      end
-    end
-
-    describe "#audit_deps" do
-      describe "a dependency on a macOS-provided keg-only formula" do
-        describe "which is allowlisted" do
-          subject { fa }
-
-          let(:fa) do
-            formula_auditor "foo", <<~RUBY, new_formula: true
-              class Foo < Formula
-                url "https://brew.sh/foo-1.0.tgz"
-                homepage "https://brew.sh"
-
-                depends_on "openssl"
-              end
-            RUBY
-          end
-
-          let(:f_openssl) do
-            formula do
-              url "https://brew.sh/openssl-1.0.tgz"
-              homepage "https://brew.sh"
-
-              keg_only :provided_by_macos
-            end
-          end
-
-          before do
-            allow(fa.formula.deps.first)
-              .to receive(:to_formula).and_return(f_openssl)
-            fa.audit_deps
-          end
-
-          its(:problems) { are_expected.to be_empty }
-        end
-
-        describe "which is not allowlisted", :needs_macos do
-          subject { fa }
-
-          let(:fa) do
-            formula_auditor "foo", <<~RUBY, new_formula: true, core_tap: true
-              class Foo < Formula
-                url "https://brew.sh/foo-1.0.tgz"
-                homepage "https://brew.sh"
-
-                depends_on "bc"
-              end
-            RUBY
-          end
-
-          let(:f_bc) do
-            formula do
-              url "https://brew.sh/bc-1.0.tgz"
-              homepage "https://brew.sh"
-
-              keg_only :provided_by_macos
-            end
-          end
-
-          before do
-            allow(fa.formula.deps.first)
-              .to receive(:to_formula).and_return(f_bc)
-            fa.audit_deps
-          end
-
-          its(:new_formula_problems) {
-            are_expected.to include(a_hash_including(message: a_string_matching(/is provided by macOS/)))
-          }
-        end
-      end
-    end
-
-    describe "#audit_revision_and_version_scheme" do
-      subject {
-        fa = described_class.new(Formulary.factory(formula_path), git: true)
-        fa.audit_revision_and_version_scheme
-        fa.problems.first&.fetch(:message)
-      }
-
-      let(:origin_tap_path) { Tap::TAP_DIRECTORY/"homebrew/homebrew-foo" }
-      let(:foo_version) { Count.increment }
-      let(:formula_subpath) { "Formula/foo#{foo_version}.rb" }
-      let(:origin_formula_path) { origin_tap_path/formula_subpath }
-      let(:tap_path) { Tap::TAP_DIRECTORY/"homebrew/homebrew-bar" }
-      let(:formula_path) { tap_path/formula_subpath }
-
-      before do
-        origin_formula_path.dirname.mkpath
-        origin_formula_path.write <<~RUBY
-          class Foo#{foo_version} < Formula
-            url "https://brew.sh/foo-1.0.tar.gz"
-            sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
-            revision 2
-            version_scheme 1
-          end
-        RUBY
-
-        origin_tap_path.mkpath
-        origin_tap_path.cd do
-          system "git", "init"
-          system "git", "add", "--all"
-          system "git", "commit", "-m", "init"
-        end
-
-        tap_path.mkpath
-        tap_path.cd do
-          system "git", "clone", origin_tap_path, "."
-        end
-      end
-
-      describe "new formulae should not have a revision" do
-        it "doesn't allow new formulae to have a revision" do
-          fa = formula_auditor "foo", <<~RUBY, new_formula: true
-            class Foo < Formula
-              url "https://brew.sh/foo-1.0.tgz"
-              revision 1
-            end
-          RUBY
-
-          fa.audit_revision_and_version_scheme
-
-          expect(fa.new_formula_problems).to include(
-            a_hash_including(message: a_string_matching(/should not define a revision/)),
-          )
-        end
-      end
-
-      def formula_gsub(before, after = "")
-        text = formula_path.read
-        text.gsub! before, after
-        formula_path.unlink
-        formula_path.write text
-      end
-
-      def formula_gsub_origin_commit(before, after = "")
-        text = origin_formula_path.read
-        text.gsub!(before, after)
-        origin_formula_path.unlink
-        origin_formula_path.write text
-
-        origin_tap_path.cd do
-          system "git", "commit", "-am", "commit"
-        end
-
-        tap_path.cd do
-          system "git", "fetch"
-          system "git", "reset", "--hard", "origin/master"
-        end
-      end
-
-      describe "checksums" do
-        describe "should not change with the same version" do
-          before do
-            formula_gsub(
-              'sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"',
-              'sha256 "3622d2a53236ed9ca62de0616a7e80fd477a9a3f862ba09d503da188f53ca523"',
-            )
-          end
-
-          it { is_expected.to match("stable sha256 changed without the url/version also changing") }
-        end
-
-        describe "should not change with the same version when not the first commit" do
-          before do
-            formula_gsub_origin_commit(
-              'sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"',
-              'sha256 "3622d2a53236ed9ca62de0616a7e80fd477a9a3f862ba09d503da188f53ca523"',
-            )
-            formula_gsub_origin_commit "revision 2"
-            formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-1.1.tar.gz"
-            formula_gsub(
-              'sha256 "3622d2a53236ed9ca62de0616a7e80fd477a9a3f862ba09d503da188f53ca523"',
-              'sha256 "e048c5e6144f5932d8672c2fade81d9073d5b3ca1517b84df006de3d25414fc1"',
-            )
-          end
-
-          it { is_expected.to match("stable sha256 changed without the url/version also changing") }
-        end
-
-        describe "can change with the different version" do
-          before do
-            formula_gsub_origin_commit(
-              'sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"',
-              'sha256 "3622d2a53236ed9ca62de0616a7e80fd477a9a3f862ba09d503da188f53ca523"',
-            )
-            formula_gsub "foo-1.0.tar.gz", "foo-1.1.tar.gz"
-            formula_gsub_origin_commit(
-              'sha256 "3622d2a53236ed9ca62de0616a7e80fd477a9a3f862ba09d503da188f53ca523"',
-              'sha256 "e048c5e6144f5932d8672c2fade81d9073d5b3ca1517b84df006de3d25414fc1"',
-            )
-          end
-
-          it { is_expected.to be_nil }
-        end
-
-        describe "can be removed when switching schemes" do
-          before do
-            formula_gsub_origin_commit(
-              'url "https://brew.sh/foo-1.0.tar.gz"',
-              'url "https://foo.com/brew/bar.git", tag: "1.0", revision: "f5e00e485e7aa4c5baa20355b27e3b84a6912790"',
-            )
-            formula_gsub_origin_commit('sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"',
-                                       "")
-          end
-
-          it { is_expected.to be_nil }
-        end
-      end
-
-      describe "revisions" do
-        describe "should not be removed when first committed above 0" do
-          it { is_expected.to be_nil }
-        end
-
-        describe "with the same version, should not decrease" do
-          before { formula_gsub_origin_commit "revision 2", "revision 1" }
-
-          it { is_expected.to match("revision should not decrease (from 2 to 1)") }
-        end
-
-        describe "should not be removed with the same version" do
-          before { formula_gsub_origin_commit "revision 2" }
-
-          it { is_expected.to match("revision should not decrease (from 2 to 0)") }
-        end
-
-        describe "should not decrease with the same, uncommitted version" do
-          before { formula_gsub "revision 2", "revision 1" }
-
-          it { is_expected.to match("revision should not decrease (from 2 to 1)") }
-        end
-
-        describe "should be removed with a newer version" do
-          before { formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-1.1.tar.gz" }
-
-          it { is_expected.to match("'revision 2' should be removed") }
-        end
-
-        describe "should be removed with a newer local version" do
-          before { formula_gsub "foo-1.0.tar.gz", "foo-1.1.tar.gz" }
-
-          it { is_expected.to match("'revision 2' should be removed") }
-        end
-
-        describe "should not warn on an newer version revision removal" do
-          before do
-            formula_gsub_origin_commit "revision 2", ""
-            formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-1.1.tar.gz"
-          end
-
-          it { is_expected.to be_nil }
-        end
-
-        describe "should not warn when revision from previous version matches current revision" do
-          before do
-            formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-1.1.tar.gz"
-            formula_gsub_origin_commit "revision 2", "# no revision"
-            formula_gsub_origin_commit "# no revision", "revision 1"
-            formula_gsub_origin_commit "revision 1", "revision 2"
-          end
-
-          it { is_expected.to be_nil }
-        end
-
-        describe "should only increment by 1 with an uncommitted version" do
-          before do
-            formula_gsub "foo-1.0.tar.gz", "foo-1.1.tar.gz"
-            formula_gsub "revision 2", "revision 4"
-          end
-
-          it { is_expected.to match("revisions should only increment by 1") }
-        end
-
-        describe "should not warn on past increment by more than 1" do
-          before do
-            formula_gsub_origin_commit "revision 2", "# no revision"
-            formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-1.1.tar.gz"
-            formula_gsub_origin_commit "# no revision", "revision 3"
-          end
-
-          it { is_expected.to be_nil }
-        end
-      end
-
-      describe "version_schemes" do
-        describe "should not decrease with the same version" do
-          before { formula_gsub_origin_commit "version_scheme 1" }
-
-          it { is_expected.to match("version_scheme should not decrease (from 1 to 0)") }
-        end
-
-        describe "should not decrease with a new version" do
-          before do
-            formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-1.1.tar.gz"
-            formula_gsub_origin_commit "revision 2", ""
-            formula_gsub_origin_commit "version_scheme 1", ""
-          end
-
-          it { is_expected.to match("version_scheme should not decrease (from 1 to 0)") }
-        end
-
-        describe "should only increment by 1" do
-          before do
-            formula_gsub_origin_commit "version_scheme 1", "# no version_scheme"
-            formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-1.1.tar.gz"
-            formula_gsub_origin_commit "revision 2", ""
-            formula_gsub_origin_commit "# no version_scheme", "version_scheme 3"
-          end
-
-          it { is_expected.to match("version_schemes should only increment by 1") }
-        end
-      end
-
-      describe "versions" do
-        context "when uncommitted should not decrease" do
-          before { formula_gsub "foo-1.0.tar.gz", "foo-0.9.tar.gz" }
-
-          it { is_expected.to match("stable version should not decrease (from 1.0 to 0.9)") }
-        end
-
-        context "when committed can decrease" do
-          before do
-            formula_gsub_origin_commit "revision 2"
-            formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-0.9.tar.gz"
-          end
-
-          it { is_expected.to be_nil }
-        end
-
-        describe "can decrease with version_scheme increased" do
-          before do
-            formula_gsub "revision 2"
-            formula_gsub "foo-1.0.tar.gz", "foo-0.9.tar.gz"
-            formula_gsub "version_scheme 1", "version_scheme 2"
-          end
-
-          it { is_expected.to be_nil }
-        end
-      end
-    end
-
-    describe "#audit_versioned_keg_only" do
-      specify "it warns when a versioned formula is not `keg_only`" do
-        fa = formula_auditor "foo@1.1", <<~RUBY, core_tap: true
-          class FooAT11 < Formula
-            url "https://brew.sh/foo-1.1.tgz"
-          end
-        RUBY
-
-        fa.audit_versioned_keg_only
-
-        expect(fa.problems.first[:message])
-          .to match("Versioned formulae in homebrew/core should use `keg_only :versioned_formula`")
-      end
-
-      specify "it warns when a versioned formula has an incorrect `keg_only` reason" do
-        fa = formula_auditor "foo@1.1", <<~RUBY, core_tap: true
-          class FooAT11 < Formula
-            url "https://brew.sh/foo-1.1.tgz"
-
-            keg_only :provided_by_macos
-          end
-        RUBY
-
-        fa.audit_versioned_keg_only
-
-        expect(fa.problems.first[:message])
-          .to match("Versioned formulae in homebrew/core should use `keg_only :versioned_formula`")
-      end
-
-      specify "it does not warn when a versioned formula has `keg_only :versioned_formula`" do
-        fa = formula_auditor "foo@1.1", <<~RUBY, core_tap: true
-          class FooAT11 < Formula
-            url "https://brew.sh/foo-1.1.tgz"
-
-            keg_only :versioned_formula
-          end
-        RUBY
-
-        fa.audit_versioned_keg_only
-
-        expect(fa.problems).to be_empty
-      end
-    end
-
-    describe "#audit_conflicts" do
-      before do
-        # We don't really test FormulaTextAuditor here
-        allow(File).to receive(:open).and_return("")
-      end
-
-      specify "it warns when conflicting with non-existing formula" do
-        foo = formula("foo") do
-          url "https://brew.sh/bar-1.0.tgz"
-
-          conflicts_with "bar"
-        end
-
-        fa = described_class.new foo
-        fa.audit_conflicts
-
-        expect(fa.problems.first[:message])
-          .to match("Can't find conflicting formula \"bar\"")
-      end
-
-      specify "it warns when conflicting with itself" do
-        foo = formula("foo") do
-          url "https://brew.sh/bar-1.0.tgz"
-
-          conflicts_with "foo"
-        end
-        stub_formula_loader foo
-
-        fa = described_class.new foo
-        fa.audit_conflicts
-
-        expect(fa.problems.first[:message])
-          .to match("Formula should not conflict with itself")
-      end
-
-      specify "it warns when another formula does not have a symmetric conflict" do
-        foo = formula("foo") do
-          url "https://brew.sh/foo-1.0.tgz"
-        end
-        stub_formula_loader foo
-
-        bar = formula("bar") do
-          url "https://brew.sh/bar-1.0.tgz"
-
-          conflicts_with "foo"
-        end
-
-        fa = described_class.new bar
-        fa.audit_conflicts
-
-        expect(fa.problems.first[:message])
-          .to match("Formula foo should also have a conflict declared with bar")
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/test/dev-cmd/bottle_spec.rb b/Library/Homebrew/test/dev-cmd/bottle_spec.rb
index 476cd816da88e..2faf9b36abb0e 100644
--- a/Library/Homebrew/test/dev-cmd/bottle_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/bottle_spec.rb
@@ -1,13 +1,38 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
 require "dev-cmd/bottle"
 
-describe "brew bottle" do
+RSpec.describe Homebrew::DevCmd::Bottle do
+  def stub_hash(parameters)
+    <<~EOS
+      {
+        "#{parameters[:name]}":{
+           "formula":{
+              "pkg_version":"#{parameters[:version]}",
+              "path":"#{parameters[:path]}"
+           },
+           "bottle":{
+              "root_url":"#{parameters[:root_url] || HOMEBREW_BOTTLE_DEFAULT_DOMAIN}",
+              "prefix":"/usr/local",
+              "cellar":"#{parameters[:cellar]}",
+              "rebuild":0,
+              "tags":{
+                 "#{parameters[:os]}":{
+                    "filename":"#{parameters[:filename]}",
+                    "local_filename":"#{parameters[:local_filename]}",
+                    "sha256":"#{parameters[:sha256]}"
+                 }
+              }
+           }
+        }
+      }
+    EOS
+  end
+
   it_behaves_like "parseable arguments"
 
-  it "builds a bottle for the given Formula", :integration_test do
+  it "builds a bottle for the given Formula", :integration_test, :needs_network do
     install_test_formula "testball", build_bottle: true
 
     # `brew bottle` should not fail with dead symlink
@@ -28,7 +53,7 @@
   end
 
   describe "--merge", :integration_test do
-    let(:core_tap) { CoreTap.new }
+    let(:core_tap) { CoreTap.instance }
     let(:tarball) do
       if OS.linux?
         TEST_FIXTURE_DIR/"tarballs/testball-0.1-linux.tbz"
@@ -80,20 +105,22 @@
 
     it "adds the bottle block to a formula that has none" do
       core_tap.path.cd do
-        system "git", "init"
+        system "git", "-c", "init.defaultBranch=master", "init"
         setup_test_formula "testball"
         system "git", "add", "--all"
         system "git", "commit", "-m", "testball 0.1"
       end
 
-      expect {
+      # RuboCop would align the `.and` with `.to_stdout` which is too floaty.
+      # rubocop:disable Layout/MultilineMethodCallIndentation
+      expect do
         brew "bottle",
              "--merge",
              "--write",
              "#{TEST_TMPDIR}/testball-1.0.arm64_big_sur.bottle.json",
              "#{TEST_TMPDIR}/testball-1.0.big_sur.bottle.json",
              "#{TEST_TMPDIR}/testball-1.0.catalina.bottle.json"
-      }.to output(Regexp.new(<<~'EOS')).to_stdout
+      end.to output(Regexp.new(<<~'EOS')).to_stdout
         ==> testball
           bottle do
             sha256 cellar: :any_skip_relocation, arm64_big_sur: "8f9aecd233463da6a4ea55f5f88fc5841718c013f3e2a7941350d6130f1dc149"
@@ -105,6 +132,7 @@
       EOS
       .and not_to_output.to_stderr
       .and be_a_success
+      # rubocop:enable Layout/MultilineMethodCallIndentation
 
       expect((core_tap.path/"Formula/testball.rb").read).to eq <<~EOS
         class Testball < Formula
@@ -140,7 +168,7 @@ def install
 
     it "replaces the bottle block in a formula that already has a bottle block" do
       core_tap.path.cd do
-        system "git", "init"
+        system "git", "-c", "init.defaultBranch=master", "init"
         setup_test_formula "testball", bottle_block: <<~EOS
 
           bottle do
@@ -153,14 +181,16 @@ def install
         system "git", "commit", "-m", "testball 0.1"
       end
 
-      expect {
+      # RuboCop would align the `.and` with `.to_stdout` which is too floaty.
+      # rubocop:disable Layout/MultilineMethodCallIndentation
+      expect do
         brew "bottle",
              "--merge",
              "--write",
              "#{TEST_TMPDIR}/testball-1.0.arm64_big_sur.bottle.json",
              "#{TEST_TMPDIR}/testball-1.0.big_sur.bottle.json",
              "#{TEST_TMPDIR}/testball-1.0.catalina.bottle.json"
-      }.to output(Regexp.new(<<~'EOS')).to_stdout
+      end.to output(Regexp.new(<<~'EOS')).to_stdout
         ==> testball
           bottle do
             sha256 cellar: :any_skip_relocation, arm64_big_sur: "8f9aecd233463da6a4ea55f5f88fc5841718c013f3e2a7941350d6130f1dc149"
@@ -172,6 +202,7 @@ def install
       EOS
       .and not_to_output.to_stderr
       .and be_a_success
+      # rubocop:enable Layout/MultilineMethodCallIndentation
 
       expect((core_tap.path/"Formula/testball.rb").read).to eq <<~EOS
         class Testball < Formula
@@ -207,7 +238,7 @@ def install
 
     it "updates the bottle block in a formula that already has a bottle block when using --keep-old" do
       core_tap.path.cd do
-        system "git", "init"
+        system "git", "-c", "init.defaultBranch=master", "init"
         setup_test_formula "testball", bottle_block: <<~EOS
 
           bottle do
@@ -218,7 +249,9 @@ def install
         system "git", "commit", "-m", "testball 0.1"
       end
 
-      expect {
+      # RuboCop would align the `.and` with `.to_stdout` which is too floaty.
+      # rubocop:disable Layout/MultilineMethodCallIndentation
+      expect do
         brew "bottle",
              "--merge",
              "--write",
@@ -226,7 +259,7 @@ def install
              "#{TEST_TMPDIR}/testball-1.0.arm64_big_sur.bottle.json",
              "#{TEST_TMPDIR}/testball-1.0.big_sur.bottle.json",
              "#{TEST_TMPDIR}/testball-1.0.catalina.bottle.json"
-      }.to output(Regexp.new(<<~'EOS')).to_stdout
+      end.to output(Regexp.new(<<~'EOS')).to_stdout
         ==> testball
           bottle do
             sha256 cellar: :any_skip_relocation, arm64_big_sur: "8f9aecd233463da6a4ea55f5f88fc5841718c013f3e2a7941350d6130f1dc149"
@@ -239,6 +272,7 @@ def install
       EOS
       .and not_to_output.to_stderr
       .and be_a_success
+      # rubocop:enable Layout/MultilineMethodCallIndentation
 
       expect((core_tap.path/"Formula/testball.rb").read).to eq <<~EOS
         class Testball < Formula
@@ -274,10 +308,10 @@ def install
     end
   end
 
-  describe Homebrew do
-    subject(:homebrew) { described_class }
+  describe "bottle_cmd" do
+    subject(:homebrew) { described_class.new(["foo"]) }
 
-    let(:hello_hash_big_sur) {
+    let(:hello_hash_big_sur) do
       JSON.parse stub_hash(
         name:           "hello",
         version:        "1.0",
@@ -288,8 +322,8 @@ def install
         local_filename: "hello--1.0.big_sur.bottle.tar.gz",
         sha256:         "a0af7dcbb5c83f6f3f7ecd507c2d352c1a018f894d51ad241ce8492fa598010f",
       )
-    }
-    let(:hello_hash_catalina) {
+    end
+    let(:hello_hash_catalina) do
       JSON.parse stub_hash(
         name:           "hello",
         version:        "1.0",
@@ -300,8 +334,8 @@ def install
         local_filename: "hello--1.0.catalina.bottle.tar.gz",
         sha256:         "5334dd344986e46b2aa4f0471cac7b0914bd7de7cb890a34415771788d03f2ac",
       )
-    }
-    let(:unzip_hash_big_sur) {
+    end
+    let(:unzip_hash_big_sur) do
       JSON.parse stub_hash(
         name:           "unzip",
         version:        "2.0",
@@ -312,8 +346,8 @@ def install
         local_filename: "unzip--2.0.big_sur.bottle.tar.gz",
         sha256:         "16cf230afdfcb6306c208d169549cf8773c831c8653d2c852315a048960d7e72",
       )
-    }
-    let(:unzip_hash_catalina) {
+    end
+    let(:unzip_hash_catalina) do
       JSON.parse stub_hash(
         name:           "unzip",
         version:        "2.0",
@@ -324,7 +358,7 @@ def install
         local_filename: "unzip--2.0.catalina.bottle.tar.gz",
         sha256:         "d9cc50eec8ac243148a121049c236cba06af4a0b1156ab397d0a2850aa79c137",
       )
-    }
+    end
 
     specify "::parse_json_files" do
       Tempfile.open("hello--1.0.big_sur.bottle.json") do |f|
@@ -503,11 +537,11 @@ def install
         bottle.sha256(catalina: "109c0cb581a7b5d84da36d84b221fb9dd0f8a927b3044d82611791c9907e202e")
 
         expect(homebrew.bottle_output(bottle, nil)).to eq(
-          <<~RUBY.indent(2),
-            bottle do
-              root_url "https://example.com"
-              sha256 catalina: "109c0cb581a7b5d84da36d84b221fb9dd0f8a927b3044d82611791c9907e202e"
-            end
+          <<-RUBY,
+  bottle do
+    root_url "https://example.com"
+    sha256 catalina: "109c0cb581a7b5d84da36d84b221fb9dd0f8a927b3044d82611791c9907e202e"
+  end
           RUBY
         )
       end
@@ -518,41 +552,15 @@ def install
         bottle.sha256(catalina: "109c0cb581a7b5d84da36d84b221fb9dd0f8a927b3044d82611791c9907e202e")
 
         expect(homebrew.bottle_output(bottle, "ExampleStrategy")).to eq(
-          <<~RUBY.indent(2),
-            bottle do
-              root_url "https://example.com",
-                using: ExampleStrategy
-              sha256 catalina: "109c0cb581a7b5d84da36d84b221fb9dd0f8a927b3044d82611791c9907e202e"
-            end
+          <<-RUBY,
+  bottle do
+    root_url "https://example.com",
+      using: ExampleStrategy
+    sha256 catalina: "109c0cb581a7b5d84da36d84b221fb9dd0f8a927b3044d82611791c9907e202e"
+  end
           RUBY
         )
       end
     end
   end
 end
-
-def stub_hash(parameters)
-  <<~EOS
-    {
-      "#{parameters[:name]}":{
-         "formula":{
-            "pkg_version":"#{parameters[:version]}",
-            "path":"#{parameters[:path]}"
-         },
-         "bottle":{
-            "root_url":"#{parameters[:root_url] || HOMEBREW_BOTTLE_DEFAULT_DOMAIN}",
-            "prefix":"/usr/local",
-            "cellar":"#{parameters[:cellar]}",
-            "rebuild":0,
-            "tags":{
-               "#{parameters[:os]}":{
-                  "filename":"#{parameters[:filename]}",
-                  "local_filename":"#{parameters[:local_filename]}",
-                  "sha256":"#{parameters[:sha256]}"
-               }
-            }
-         }
-      }
-    }
-  EOS
-end
diff --git a/Library/Homebrew/test/dev-cmd/bump-cask-pr_spec.rb b/Library/Homebrew/test/dev-cmd/bump-cask-pr_spec.rb
index 1843f20d8925f..7c0a5afa97c7d 100644
--- a/Library/Homebrew/test/dev-cmd/bump-cask-pr_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/bump-cask-pr_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/bump-cask-pr"
 
-describe "brew bump-cask-pr" do
+RSpec.describe Homebrew::DevCmd::BumpCaskPr do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/bump-formula-pr_spec.rb b/Library/Homebrew/test/dev-cmd/bump-formula-pr_spec.rb
index d785384142d96..2bde7a8d2e4b9 100644
--- a/Library/Homebrew/test/dev-cmd/bump-formula-pr_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/bump-formula-pr_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/bump-formula-pr"
 
-describe "brew bump-formula-pr" do
+RSpec.describe Homebrew::DevCmd::BumpFormulaPr do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/bump-revision_spec.rb b/Library/Homebrew/test/dev-cmd/bump-revision_spec.rb
index 13f8cbe136fee..e6d8d516cc3cb 100644
--- a/Library/Homebrew/test/dev-cmd/bump-revision_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/bump-revision_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/bump-revision"
 
-describe "brew bump-revision" do
+RSpec.describe Homebrew::DevCmd::BumpRevision do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/bump-unversioned-casks_spec.rb b/Library/Homebrew/test/dev-cmd/bump-unversioned-casks_spec.rb
index 50b45159a7389..48250d51d4a8d 100644
--- a/Library/Homebrew/test/dev-cmd/bump-unversioned-casks_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/bump-unversioned-casks_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/bump-unversioned-casks"
 
-describe "brew bump-unversioned-casks" do
+RSpec.describe Homebrew::DevCmd::BumpUnversionedCasks do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/bump_spec.rb b/Library/Homebrew/test/dev-cmd/bump_spec.rb
index 5bd5645f0eb38..31e7447e2345c 100644
--- a/Library/Homebrew/test/dev-cmd/bump_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/bump_spec.rb
@@ -1,31 +1,12 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/bump"
 
-describe "brew bump" do
+RSpec.describe Homebrew::DevCmd::Bump do
   it_behaves_like "parseable arguments"
 
-  describe "formula", :integration_test, :needs_network, :needs_homebrew_curl do
-    it "returns data for single valid specified formula" do
-      install_test_formula "testball"
-
-      expect { brew "bump", "testball" }
-        .to output.to_stdout
-        .and not_to_output.to_stderr
-        .and be_a_success
-    end
-
-    it "returns data for multiple valid specified formula" do
-      install_test_formula "testball"
-      install_test_formula "testball2"
-
-      expect { brew "bump", "testball", "testball2" }
-        .to output.to_stdout
-        .and not_to_output.to_stderr
-        .and be_a_success
-    end
-
+  describe "formula", :integration_test, :needs_homebrew_curl, :needs_network do
     it "returns no data and prints a message for HEAD-only formulae" do
       content = <<~RUBY
         desc "HEAD-only test formula"
@@ -40,4 +21,11 @@
         .and be_a_success
     end
   end
+
+  it "gives an error for `--tap` with official taps", :integration_test do
+    expect { brew "bump", "--tap", "Homebrew/core" }
+      .to output(/Invalid usage/).to_stderr
+      .and not_to_output.to_stdout
+      .and be_a_failure
+  end
 end
diff --git a/Library/Homebrew/test/dev-cmd/cat_spec.rb b/Library/Homebrew/test/dev-cmd/cat_spec.rb
index 6a5d6a6d79351..b3789b8856002 100644
--- a/Library/Homebrew/test/dev-cmd/cat_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/cat_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/cat"
 
-describe "brew cat" do
+RSpec.describe Homebrew::DevCmd::Cat do
   it_behaves_like "parseable arguments"
 
   it "prints the content of a given Formula", :integration_test do
diff --git a/Library/Homebrew/test/dev-cmd/contributions_spec.rb b/Library/Homebrew/test/dev-cmd/contributions_spec.rb
new file mode 100644
index 0000000000000..e49fc847d9e24
--- /dev/null
+++ b/Library/Homebrew/test/dev-cmd/contributions_spec.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "cmd/shared_examples/args_parse"
+require "dev-cmd/contributions"
+
+RSpec.describe Homebrew::DevCmd::Contributions do
+  it_behaves_like "parseable arguments"
+end
diff --git a/Library/Homebrew/test/dev-cmd/create_spec.rb b/Library/Homebrew/test/dev-cmd/create_spec.rb
index f2cda56d107f7..f1cd4b526a1e2 100644
--- a/Library/Homebrew/test/dev-cmd/create_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/create_spec.rb
@@ -1,16 +1,16 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/create"
 
-describe "brew create" do
+RSpec.describe Homebrew::DevCmd::Create do
   let(:url) { "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz" }
-  let(:formula_file) { CoreTap.new.formula_dir/"testball.rb" }
+  let(:formula_file) { CoreTap.instance.new_formula_path("testball") }
 
   it_behaves_like "parseable arguments"
 
   it "creates a new Formula file for a given URL", :integration_test do
-    brew "create", url, "HOMEBREW_EDITOR" => "/bin/cat"
+    brew "create", "--set-name=Testball", url, "HOMEBREW_EDITOR" => "/bin/cat"
 
     expect(formula_file).to exist
     expect(formula_file.read).to match(%Q(sha256 "#{TESTBALL_SHA256}"))
diff --git a/Library/Homebrew/test/dev-cmd/determine-test-runners_spec.rb b/Library/Homebrew/test/dev-cmd/determine-test-runners_spec.rb
new file mode 100644
index 0000000000000..0d46e31002d89
--- /dev/null
+++ b/Library/Homebrew/test/dev-cmd/determine-test-runners_spec.rb
@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "dev-cmd/determine-test-runners"
+require "cmd/shared_examples/args_parse"
+
+RSpec.describe Homebrew::DevCmd::DetermineTestRunners do
+  def get_runners(file)
+    runner_line = File.open(file).first
+    json_text = runner_line[/runners=(.*)/, 1]
+    runner_hash = JSON.parse(json_text)
+    runner_hash.map { |item| item["runner"].delete_suffix(ephemeral_suffix) }
+               .sort
+  end
+
+  after do
+    FileUtils.rm_f github_output
+  end
+
+  let(:linux_runner) { "ubuntu-22.04" }
+  # We need to make sure we write to a different path for each example.
+  let(:github_output) { "#{TEST_TMPDIR}/github_output#{DetermineRunnerTestHelper.new.number}" }
+  let(:ephemeral_suffix) { "-12345" }
+  let(:runner_env) do
+    {
+      "HOMEBREW_LINUX_RUNNER"       => linux_runner,
+      "HOMEBREW_MACOS_LONG_TIMEOUT" => "false",
+      "GITHUB_RUN_ID"               => ephemeral_suffix.split("-").second,
+    }.freeze
+  end
+  let(:all_runners) do
+    out = []
+    MacOSVersion::SYMBOLS.each_value do |v|
+      macos_version = MacOSVersion.new(v)
+      next if macos_version < GitHubRunnerMatrix::OLDEST_HOMEBREW_CORE_MACOS_RUNNER
+      next if macos_version > GitHubRunnerMatrix::NEWEST_HOMEBREW_CORE_MACOS_RUNNER
+
+      out << "#{v}-arm64"
+      next if macos_version > GitHubRunnerMatrix::NEWEST_HOMEBREW_CORE_INTEL_MACOS_RUNNER
+
+      out << "#{v}-x86_64"
+    end
+
+    out << linux_runner
+
+    out
+  end
+
+  it_behaves_like "parseable arguments"
+
+  it "assigns all runners for formulae without any requirements", :integration_test do
+    setup_test_formula "testball"
+
+    expect { brew "determine-test-runners", "testball", runner_env.merge({ "GITHUB_OUTPUT" => github_output }) }
+      .to not_to_output.to_stderr
+      .and be_a_success
+
+    expect(File.read(github_output)).not_to be_empty
+    expect(get_runners(github_output).sort).to eq(all_runners.sort)
+  end
+end
+
+class DetermineRunnerTestHelper
+  @instances = 0
+
+  class << self
+    attr_accessor :instances
+  end
+
+  attr_reader :number
+
+  def initialize
+    self.class.instances += 1
+    @number = self.class.instances
+  end
+end
diff --git a/Library/Homebrew/test/dev-cmd/dispatch-build-bottle_spec.rb b/Library/Homebrew/test/dev-cmd/dispatch-build-bottle_spec.rb
index 18363e67770e5..84c329bc3bdfb 100644
--- a/Library/Homebrew/test/dev-cmd/dispatch-build-bottle_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/dispatch-build-bottle_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/dispatch-build-bottle"
 
-describe "brew dispatch-build-bottle" do
+RSpec.describe Homebrew::DevCmd::DispatchBuildBottle do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/edit_spec.rb b/Library/Homebrew/test/dev-cmd/edit_spec.rb
index 59e1eebea6c90..265eb731130f3 100644
--- a/Library/Homebrew/test/dev-cmd/edit_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/edit_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/edit"
 
-describe "brew edit" do
+RSpec.describe Homebrew::DevCmd::Edit do
   it_behaves_like "parseable arguments"
 
   it "opens a given Formula in an editor", :integration_test do
@@ -13,7 +13,7 @@
 
     setup_test_formula "testball"
 
-    expect { brew "edit", "testball", "HOMEBREW_EDITOR" => "/bin/cat" }
+    expect { brew "edit", "testball", "HOMEBREW_EDITOR" => "/bin/cat", "HOMEBREW_NO_ENV_HINTS" => "1" }
       .to output(/# something here/).to_stdout
       .and not_to_output.to_stderr
       .and be_a_success
diff --git a/Library/Homebrew/test/dev-cmd/extract_spec.rb b/Library/Homebrew/test/dev-cmd/extract_spec.rb
index 20f745e49a8e9..3a7ad97ff4d72 100644
--- a/Library/Homebrew/test/dev-cmd/extract_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/extract_spec.rb
@@ -1,17 +1,17 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/extract"
 
-describe "brew extract" do
+RSpec.describe Homebrew::DevCmd::Extract do
   it_behaves_like "parseable arguments"
 
   context "when extracting a formula" do
     let!(:target) do
-      path = Tap::TAP_DIRECTORY/"homebrew/homebrew-foo"
+      path = HOMEBREW_TAP_DIRECTORY/"homebrew/homebrew-foo"
       (path/"Formula").mkpath
       target = Tap.from_path(path)
-      core_tap = CoreTap.new
+      core_tap = CoreTap.instance
       core_tap.path.cd do
         system "git", "init"
         # Start with deprecated bottle syntax
@@ -31,7 +31,7 @@
         system "git", "add", "--all"
         system "git", "commit", "-m", "testball 0.2"
       end
-      { name: target.name, path: path }
+      { name: target.name, path: }
     end
 
     it "retrieves the most recent version of formula", :integration_test do
@@ -41,7 +41,7 @@
         .and not_to_output.to_stderr
         .and be_a_success
       expect(path).to exist
-      expect(Formulary.factory(path).version).to be == "0.2"
+      expect(Formulary.factory(path).version).to eq "0.2"
     end
 
     it "retrieves the specified version of formula", :integration_test do
@@ -51,7 +51,7 @@
         .and not_to_output.to_stderr
         .and be_a_success
       expect(path).to exist
-      expect(Formulary.factory(path).version).to be == "0.1"
+      expect(Formulary.factory(path).version).to eq "0.1"
     end
 
     it "retrieves the compatible version of formula", :integration_test do
@@ -61,7 +61,7 @@
         .and not_to_output.to_stderr
         .and be_a_success
       expect(path).to exist
-      expect(Formulary.factory(path).version).to be == "0.2"
+      expect(Formulary.factory(path).version).to eq "0.2"
     end
   end
 end
diff --git a/Library/Homebrew/test/dev-cmd/formula_spec.rb b/Library/Homebrew/test/dev-cmd/formula_spec.rb
index 90af8e18be2b6..59acf64bfa243 100644
--- a/Library/Homebrew/test/dev-cmd/formula_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/formula_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/formula"
 
-describe "brew formula" do
+RSpec.describe Homebrew::DevCmd::FormulaCmd do
   it_behaves_like "parseable arguments"
 
   it "prints a given Formula's path", :integration_test do
diff --git a/Library/Homebrew/test/dev-cmd/generate-cask-api_spec.rb b/Library/Homebrew/test/dev-cmd/generate-cask-api_spec.rb
new file mode 100644
index 0000000000000..426c4b9cb113e
--- /dev/null
+++ b/Library/Homebrew/test/dev-cmd/generate-cask-api_spec.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "cmd/shared_examples/args_parse"
+require "dev-cmd/generate-cask-api"
+
+RSpec.describe Homebrew::DevCmd::GenerateCaskApi do
+  it_behaves_like "parseable arguments"
+end
diff --git a/Library/Homebrew/test/dev-cmd/generate-formula-api_spec.rb b/Library/Homebrew/test/dev-cmd/generate-formula-api_spec.rb
new file mode 100644
index 0000000000000..74136d6645a55
--- /dev/null
+++ b/Library/Homebrew/test/dev-cmd/generate-formula-api_spec.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "cmd/shared_examples/args_parse"
+require "dev-cmd/generate-formula-api"
+
+RSpec.describe Homebrew::DevCmd::GenerateFormulaApi do
+  it_behaves_like "parseable arguments"
+end
diff --git a/Library/Homebrew/test/dev-cmd/generate-man-completions_spec.rb b/Library/Homebrew/test/dev-cmd/generate-man-completions_spec.rb
index 91dc0f473a64e..6ac40d1af1572 100644
--- a/Library/Homebrew/test/dev-cmd/generate-man-completions_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/generate-man-completions_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/generate-man-completions"
 
-describe "brew generate-man-completions" do
+RSpec.describe Homebrew::DevCmd::GenerateManCompletions do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/install-bundler-gems_spec.rb b/Library/Homebrew/test/dev-cmd/install-bundler-gems_spec.rb
new file mode 100644
index 0000000000000..d7d33e739efeb
--- /dev/null
+++ b/Library/Homebrew/test/dev-cmd/install-bundler-gems_spec.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "cmd/shared_examples/args_parse"
+require "dev-cmd/install-bundler-gems"
+
+RSpec.describe Homebrew::DevCmd::InstallBundlerGems do
+  it_behaves_like "parseable arguments"
+end
diff --git a/Library/Homebrew/test/dev-cmd/irb_spec.rb b/Library/Homebrew/test/dev-cmd/irb_spec.rb
index 9025117d54859..4ba95bc1236e6 100644
--- a/Library/Homebrew/test/dev-cmd/irb_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/irb_spec.rb
@@ -1,24 +1,37 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/irb"
 
-describe "brew irb" do
+RSpec.describe Homebrew::DevCmd::Irb do
   it_behaves_like "parseable arguments"
 
-  it "starts an interactive Homebrew shell session", :integration_test do
-    setup_test_formula "testball"
+  describe "integration test" do
+    let(:history_file) { Pathname("#{Dir.home}/.brew_irb_history") }
 
-    irb_test = HOMEBREW_TEMP/"irb-test.rb"
-    irb_test.write <<~RUBY
-      "testball".f
-      :testball.f
-      exit
-    RUBY
+    after do
+      history_file.delete if history_file.exist?
+    end
 
-    expect { brew "irb", irb_test }
-      .to output(/Interactive Homebrew Shell/).to_stdout
-      .and not_to_output.to_stderr
-      .and be_a_success
+    it "starts an interactive Homebrew shell session", :integration_test do
+      setup_test_formula "testball"
+
+      irb_test = HOMEBREW_TEMP/"irb-test.rb"
+      irb_test.write <<~RUBY
+        "testball".f
+        :testball.f
+        exit
+      RUBY
+
+      expect { brew "irb", irb_test }
+        .to output(/Interactive Homebrew Shell/).to_stdout
+        .and not_to_output.to_stderr
+        .and be_a_success
+
+      # TODO: newer Ruby only supports history saving in interactive sessions
+      # and not if you feed in data from a file or stdin like we are doing here.
+      # The test will need to be adjusted for this to work.
+      # expect(history_file).to exist
+    end
   end
 end
diff --git a/Library/Homebrew/test/dev-cmd/linkage_spec.rb b/Library/Homebrew/test/dev-cmd/linkage_spec.rb
index 544042408b991..bd859fd94f846 100644
--- a/Library/Homebrew/test/dev-cmd/linkage_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/linkage_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/linkage"
 
-describe "brew linkage" do
+RSpec.describe Homebrew::DevCmd::Linkage do
   it_behaves_like "parseable arguments"
 
   it "works when no arguments are provided", :integration_test do
diff --git a/Library/Homebrew/test/dev-cmd/livecheck_spec.rb b/Library/Homebrew/test/dev-cmd/livecheck_spec.rb
index 5166add57760e..413e6287d20f4 100644
--- a/Library/Homebrew/test/dev-cmd/livecheck_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/livecheck_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/livecheck"
 
-describe "brew livecheck" do
+RSpec.describe Homebrew::DevCmd::LivecheckCmd do
   it_behaves_like "parseable arguments"
 
   it "reports the latest version of a Formula", :integration_test, :needs_network do
@@ -21,7 +21,7 @@
   end
 
   it "gives an error when no arguments are given and there's no watchlist", :integration_test do
-    expect { brew "livecheck" }
+    expect { brew "livecheck", "HOMEBREW_LIVECHECK_WATCHLIST" => ".this_should_not_exist" }
       .to output(/Invalid usage: A watchlist file is required when no arguments are given\./).to_stderr
       .and not_to_output.to_stdout
       .and be_a_failure
diff --git a/Library/Homebrew/test/dev-cmd/pr-automerge_spec.rb b/Library/Homebrew/test/dev-cmd/pr-automerge_spec.rb
index 251f08c6aeb21..8fda0193f3ad1 100644
--- a/Library/Homebrew/test/dev-cmd/pr-automerge_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/pr-automerge_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/pr-automerge"
 
-describe "brew pr-automerge" do
+RSpec.describe Homebrew::DevCmd::PrAutomerge do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/pr-publish_spec.rb b/Library/Homebrew/test/dev-cmd/pr-publish_spec.rb
index 0d4c288f687a3..66384ab898937 100644
--- a/Library/Homebrew/test/dev-cmd/pr-publish_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/pr-publish_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/pr-publish"
 
-describe "brew pr-publish" do
+RSpec.describe Homebrew::DevCmd::PrPublish do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/pr-pull_spec.rb b/Library/Homebrew/test/dev-cmd/pr-pull_spec.rb
index 9366befe345af..a79ed7eb360d4 100644
--- a/Library/Homebrew/test/dev-cmd/pr-pull_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/pr-pull_spec.rb
@@ -1,4 +1,3 @@
-# typed: false
 # frozen_string_literal: true
 
 require "dev-cmd/pr-pull"
@@ -6,198 +5,200 @@
 require "tap"
 require "cmd/shared_examples/args_parse"
 
-describe "brew pr-pull" do
+RSpec.describe Homebrew::DevCmd::PrPull do
+  include FileUtils
+
+  let(:pr_pull) { described_class.new(["foo"]) }
+  let(:formula_rebuild) do
+    <<~EOS
+      class Foo < Formula
+        desc "Helpful description"
+        url "https://brew.sh/foo-1.0.tgz"
+      end
+    EOS
+  end
+  let(:formula_revision) do
+    <<~EOS
+      class Foo < Formula
+        url "https://brew.sh/foo-1.0.tgz"
+        revision 1
+      end
+    EOS
+  end
+  let(:formula_version) do
+    <<~EOS
+      class Foo < Formula
+        url "https://brew.sh/foo-2.0.tgz"
+      end
+    EOS
+  end
+  let(:formula) do
+    <<~EOS
+      class Foo < Formula
+        url "https://brew.sh/foo-1.0.tgz"
+      end
+    EOS
+  end
+  let(:cask_rebuild) do
+    <<~EOS
+      cask "food" do
+        desc "Helpful description"
+        version "1.0"
+        sha256 "a"
+        url "https://brew.sh/food-\#{version}.tgz"
+      end
+    EOS
+  end
+  let(:cask_checksum) do
+    <<~EOS
+      cask "food" do
+        desc "Helpful description"
+        version "1.0"
+        sha256 "b"
+        url "https://brew.sh/food-\#{version}.tgz"
+      end
+    EOS
+  end
+  let(:cask_version) do
+    <<~EOS
+      cask "food" do
+        version "2.0"
+        sha256 "a"
+        url "https://brew.sh/food-\#{version}.tgz"
+      end
+    EOS
+  end
+  let(:cask) do
+    <<~EOS
+      cask "food" do
+        version "1.0"
+        sha256 "a"
+        url "https://brew.sh/food-\#{version}.tgz"
+      end
+    EOS
+  end
+  let(:tap) { Tap.fetch("Homebrew", "foo") }
+  let(:formula_file) { tap.path/"Formula/foo.rb" }
+  let(:cask_file) { tap.cask_dir/"food.rb" }
+  let(:path) { Pathname(HOMEBREW_TAP_DIRECTORY/"homebrew/homebrew-foo") }
+
   it_behaves_like "parseable arguments"
 
-  describe Homebrew do
-    let(:formula_rebuild) do
-      <<~EOS
-        class Foo < Formula
-          desc "Helpful description"
-          url "https://brew.sh/foo-1.0.tgz"
-        end
-      EOS
-    end
-    let(:formula_revision) do
-      <<~EOS
-        class Foo < Formula
-          url "https://brew.sh/foo-1.0.tgz"
-          revision 1
-        end
-      EOS
-    end
-    let(:formula_version) do
-      <<~EOS
-        class Foo < Formula
-          url "https://brew.sh/foo-2.0.tgz"
-        end
-      EOS
-    end
-    let(:formula) do
-      <<~EOS
-        class Foo < Formula
-          url "https://brew.sh/foo-1.0.tgz"
-        end
-      EOS
-    end
-    let(:cask_rebuild) do
-      <<~EOS
-        cask "food" do
-          desc "Helpful description"
-          version "1.0"
-          sha256 "a"
-          url "https://brew.sh/food-\#{version}.tgz"
-        end
-      EOS
-    end
-    let(:cask_checksum) do
-      <<~EOS
-        cask "food" do
-          desc "Helpful description"
-          version "1.0"
-          sha256 "b"
-          url "https://brew.sh/food-\#{version}.tgz"
-        end
-      EOS
-    end
-    let(:cask_version) do
-      <<~EOS
-        cask "food" do
-          version "2.0"
-          sha256 "a"
-          url "https://brew.sh/food-\#{version}.tgz"
-        end
-      EOS
-    end
-    let(:cask) do
-      <<~EOS
-        cask "food" do
-          version "1.0"
-          sha256 "a"
-          url "https://brew.sh/food-\#{version}.tgz"
-        end
-      EOS
-    end
-    let(:tap) { Tap.fetch("Homebrew", "foo") }
-    let(:formula_file) { tap.path/"Formula/foo.rb" }
-    let(:cask_file) { tap.cask_dir/"food.rb" }
-    let(:path) { (Tap::TAP_DIRECTORY/"homebrew/homebrew-foo").extend(GitRepositoryExtension) }
-
-    describe "#autosquash!" do
-      it "squashes a formula or cask correctly" do
-        secondary_author = "Someone Else <me@example.com>"
-        (tap.path/"Formula").mkpath
-        formula_file.write(formula)
-        cd tap.path do
-          safe_system Utils::Git.git, "init"
-          safe_system Utils::Git.git, "add", formula_file
-          safe_system Utils::Git.git, "commit", "-m", "foo 1.0 (new formula)"
-          original_hash = `git rev-parse HEAD`.chomp
-          File.write(formula_file, formula_revision)
-          safe_system Utils::Git.git, "commit", formula_file, "-m", "revision"
-          File.write(formula_file, formula_version)
-          safe_system Utils::Git.git, "commit", formula_file, "-m", "version", "--author=#{secondary_author}"
-          described_class.autosquash!(original_hash, tap: tap)
-          expect(tap.path.git_commit_message).to include("foo 2.0")
-          expect(tap.path.git_commit_message).to include("Co-authored-by: #{secondary_author}")
-        end
-
-        (path/"Casks").mkpath
-        cask_file.write(cask)
-        cd path do
-          safe_system Utils::Git.git, "add", cask_file
-          safe_system Utils::Git.git, "commit", "-m", "food 1.0 (new cask)"
-          original_hash = `git rev-parse HEAD`.chomp
-          File.write(cask_file, cask_rebuild)
-          safe_system Utils::Git.git, "commit", cask_file, "-m", "rebuild"
-          File.write(cask_file, cask_version)
-          safe_system Utils::Git.git, "commit", cask_file, "-m", "version", "--author=#{secondary_author}"
-          described_class.autosquash!(original_hash, tap: tap)
-          expect(path.git_commit_message).to include("food 2.0")
-          expect(path.git_commit_message).to include("Co-authored-by: #{secondary_author}")
-        end
+  describe "#autosquash!" do
+    it "squashes a formula or cask correctly" do
+      secondary_author = "Someone Else <me@example.com>"
+      (tap.path/"Formula").mkpath
+      formula_file.write(formula)
+      cd tap.path do
+        safe_system Utils::Git.git, "init"
+        safe_system Utils::Git.git, "add", formula_file
+        safe_system Utils::Git.git, "commit", "-m", "foo 1.0 (new formula)"
+        original_hash = `git rev-parse HEAD`.chomp
+        File.write(formula_file, formula_revision)
+        safe_system Utils::Git.git, "commit", formula_file, "-m", "revision"
+        File.write(formula_file, formula_version)
+        safe_system Utils::Git.git, "commit", formula_file, "-m", "version", "--author=#{secondary_author}"
+        pr_pull.autosquash!(original_hash, tap:)
+        expect(tap.git_repository.commit_message).to include("foo 2.0")
+        expect(tap.git_repository.commit_message).to include("Co-authored-by: #{secondary_author}")
       end
-    end
 
-    describe "#signoff!" do
-      it "signs off a formula or cask" do
-        (tap.path/"Formula").mkpath
-        formula_file.write(formula)
-        cd tap.path do
-          safe_system Utils::Git.git, "init"
-          safe_system Utils::Git.git, "add", formula_file
-          safe_system Utils::Git.git, "commit", "-m", "foo 1.0 (new formula)"
-        end
-        described_class.signoff!(tap.path)
-        expect(tap.path.git_commit_message).to include("Signed-off-by:")
-
-        (path/"Casks").mkpath
-        cask_file.write(cask)
-        cd path do
-          safe_system Utils::Git.git, "add", cask_file
-          safe_system Utils::Git.git, "commit", "-m", "food 1.0 (new cask)"
-        end
-        described_class.signoff!(tap.path)
-        expect(tap.path.git_commit_message).to include("Signed-off-by:")
+      (path/"Casks").mkpath
+      cask_file.write(cask)
+      cd path do
+        safe_system Utils::Git.git, "add", cask_file
+        safe_system Utils::Git.git, "commit", "-m", "food 1.0 (new cask)"
+        original_hash = `git rev-parse HEAD`.chomp
+        File.write(cask_file, cask_rebuild)
+        safe_system Utils::Git.git, "commit", cask_file, "-m", "rebuild"
+        File.write(cask_file, cask_version)
+        safe_system Utils::Git.git, "commit", cask_file, "-m", "version", "--author=#{secondary_author}"
+        pr_pull.autosquash!(original_hash, tap:)
+        git_repo = GitRepository.new(path)
+        expect(git_repo.commit_message).to include("food 2.0")
+        expect(git_repo.commit_message).to include("Co-authored-by: #{secondary_author}")
       end
     end
+  end
 
-    describe "#get_package" do
-      it "returns a formula" do
-        expect(described_class.get_package(tap, "foo", formula_file, formula)).to be_a(Formula)
+  describe "#signoff!" do
+    it "signs off a formula or cask" do
+      (tap.path/"Formula").mkpath
+      formula_file.write(formula)
+      cd tap.path do
+        safe_system Utils::Git.git, "init"
+        safe_system Utils::Git.git, "add", formula_file
+        safe_system Utils::Git.git, "commit", "-m", "foo 1.0 (new formula)"
       end
-
-      it "returns nil for an unknown formula" do
-        expect(described_class.get_package(tap, "foo", formula_file, "")).to be_nil
+      pr_pull.signoff!(tap.git_repository)
+      expect(tap.git_repository.commit_message).to include("Signed-off-by:")
+
+      (path/"Casks").mkpath
+      cask_file.write(cask)
+      cd path do
+        safe_system Utils::Git.git, "add", cask_file
+        safe_system Utils::Git.git, "commit", "-m", "food 1.0 (new cask)"
       end
+      pr_pull.signoff!(tap.git_repository)
+      expect(tap.git_repository.commit_message).to include("Signed-off-by:")
+    end
+  end
 
-      it "returns a cask" do
-        expect(described_class.get_package(tap, "foo", cask_file, cask)).to be_a(Cask::Cask)
-      end
+  describe "#get_package" do
+    it "returns a formula" do
+      expect(pr_pull.get_package(tap, "foo", formula_file, formula)).to be_a(Formula)
+    end
 
-      it "returns nil for an unknown cask" do
-        expect(described_class.get_package(tap, "foo", cask_file, "")).to be_nil
-      end
+    it "returns nil for an unknown formula" do
+      expect(pr_pull.get_package(tap, "foo", formula_file, "")).to be_nil
     end
 
-    describe "#determine_bump_subject" do
-      it "correctly bumps a new formula" do
-        expect(described_class.determine_bump_subject("", formula, formula_file)).to eq("foo 1.0 (new formula)")
-      end
+    it "returns a cask" do
+      expect(pr_pull.get_package(tap, "foo", cask_file, cask)).to be_a(Cask::Cask)
+    end
 
-      it "correctly bumps a new cask" do
-        expect(described_class.determine_bump_subject("", cask, cask_file)).to eq("food 1.0 (new cask)")
-      end
+    it "returns nil for an unknown cask" do
+      expect(pr_pull.get_package(tap, "foo", cask_file, "")).to be_nil
+    end
+  end
 
-      it "correctly bumps a formula version" do
-        expect(described_class.determine_bump_subject(formula, formula_version, formula_file)).to eq("foo 2.0")
-      end
+  describe "#determine_bump_subject" do
+    it "correctly bumps a new formula" do
+      expect(pr_pull.determine_bump_subject("", formula, formula_file)).to eq("foo 1.0 (new formula)")
+    end
 
-      it "correctly bumps a cask version" do
-        expect(described_class.determine_bump_subject(cask, cask_version, cask_file)).to eq("food 2.0")
-      end
+    it "correctly bumps a new cask" do
+      expect(pr_pull.determine_bump_subject("", cask, cask_file)).to eq("food 1.0 (new cask)")
+    end
 
-      it "correctly bumps a cask checksum" do
-        expect(described_class.determine_bump_subject(cask, cask_checksum, cask_file)).to eq("food: checksum update")
-      end
+    it "correctly bumps a formula version" do
+      expect(pr_pull.determine_bump_subject(formula, formula_version, formula_file)).to eq("foo 2.0")
+    end
 
-      it "correctly bumps a formula revision with reason" do
-        expect(described_class.determine_bump_subject(
-                 formula, formula_revision, formula_file, reason: "for fun"
-               )).to eq("foo: revision for fun")
-      end
+    it "correctly bumps a cask version" do
+      expect(pr_pull.determine_bump_subject(cask, cask_version, cask_file)).to eq("food 2.0")
+    end
 
-      it "correctly bumps a formula rebuild" do
-        expect(described_class.determine_bump_subject(formula, formula_rebuild, formula_file)).to eq("foo: rebuild")
-      end
+    it "correctly bumps a cask checksum" do
+      expect(pr_pull.determine_bump_subject(cask, cask_checksum, cask_file)).to eq("food: checksum update")
+    end
 
-      it "correctly bumps a formula deletion" do
-        expect(described_class.determine_bump_subject(formula, "", formula_file)).to eq("foo: delete")
-      end
+    it "correctly bumps a formula revision with reason" do
+      expect(pr_pull.determine_bump_subject(
+               formula, formula_revision, formula_file, reason: "for fun"
+             )).to eq("foo: revision for fun")
+    end
 
-      it "correctly bumps a cask deletion" do
-        expect(described_class.determine_bump_subject(cask, "", cask_file)).to eq("food: delete")
-      end
+    it "correctly bumps a formula rebuild" do
+      expect(pr_pull.determine_bump_subject(formula, formula_rebuild, formula_file)).to eq("foo: rebuild")
+    end
+
+    it "correctly bumps a formula deletion" do
+      expect(pr_pull.determine_bump_subject(formula, "", formula_file)).to eq("foo: delete")
+    end
+
+    it "correctly bumps a cask deletion" do
+      expect(pr_pull.determine_bump_subject(cask, "", cask_file)).to eq("food: delete")
     end
   end
 end
diff --git a/Library/Homebrew/test/dev-cmd/pr-upload_spec.rb b/Library/Homebrew/test/dev-cmd/pr-upload_spec.rb
index 62dc5e7164398..2f4774f4d19a9 100644
--- a/Library/Homebrew/test/dev-cmd/pr-upload_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/pr-upload_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/pr-upload"
 
-describe "brew pr-upload" do
+RSpec.describe Homebrew::DevCmd::PrUpload do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/prof_spec.rb b/Library/Homebrew/test/dev-cmd/prof_spec.rb
index c8a62801ae358..4956f971ece2a 100644
--- a/Library/Homebrew/test/dev-cmd/prof_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/prof_spec.rb
@@ -1,8 +1,28 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/prof"
 
-describe "brew prof" do
+RSpec.describe Homebrew::DevCmd::Prof do
   it_behaves_like "parseable arguments"
+
+  describe "integration tests", :integration_test, :needs_network do
+    after do
+      FileUtils.rm_rf HOMEBREW_LIBRARY_PATH/"prof"
+    end
+
+    it "works using ruby-prof (the default)" do
+      expect { brew "prof", "help", "HOMEBREW_BROWSER" => "echo" }
+        .to output(/^Example usage:/).to_stdout
+        .and not_to_output.to_stderr
+        .and be_a_success
+    end
+
+    it "works using stackprof" do
+      expect { brew "prof", "--stackprof", "help", "HOMEBREW_BROWSER" => "echo" }
+        .to output(/^Example usage:/).to_stdout
+        .and not_to_output.to_stderr
+        .and be_a_success
+    end
+  end
 end
diff --git a/Library/Homebrew/test/dev-cmd/release_spec.rb b/Library/Homebrew/test/dev-cmd/release_spec.rb
index 613f48f1505cd..d8f93b7ee0edb 100644
--- a/Library/Homebrew/test/dev-cmd/release_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/release_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/release"
 
-describe "brew release" do
+RSpec.describe Homebrew::DevCmd::Release do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/ruby_spec.rb b/Library/Homebrew/test/dev-cmd/ruby_spec.rb
index 582c35dd7d417..02833b4ad6510 100644
--- a/Library/Homebrew/test/dev-cmd/ruby_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/ruby_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/ruby"
 
-describe "brew ruby" do
+RSpec.describe Homebrew::DevCmd::Ruby do
   it_behaves_like "parseable arguments"
 
   it "executes ruby code with Homebrew's libraries loaded", :integration_test do
diff --git a/Library/Homebrew/test/dev-cmd/sh_spec.rb b/Library/Homebrew/test/dev-cmd/sh_spec.rb
index 682114d07bd6e..60c4c206f238f 100644
--- a/Library/Homebrew/test/dev-cmd/sh_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/sh_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/sh"
 
-describe "brew sh" do
+RSpec.describe Homebrew::DevCmd::Sh do
   it_behaves_like "parseable arguments"
 
   it "runs a shell with the Homebrew environment", :integration_test do
diff --git a/Library/Homebrew/test/dev-cmd/sponsors_spec.rb b/Library/Homebrew/test/dev-cmd/sponsors_spec.rb
deleted file mode 100644
index cc50843f3e444..0000000000000
--- a/Library/Homebrew/test/dev-cmd/sponsors_spec.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "cmd/shared_examples/args_parse"
-
-describe "brew sponsors" do
-  it_behaves_like "parseable arguments"
-end
diff --git a/Library/Homebrew/test/dev-cmd/style_spec.rb b/Library/Homebrew/test/dev-cmd/style_spec.rb
index 4cc0a879e7526..0b8f2edaf3573 100644
--- a/Library/Homebrew/test/dev-cmd/style_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/style_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/style"
 
-describe "brew style" do
+RSpec.describe Homebrew::DevCmd::StyleCmd do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/tap-new_spec.rb b/Library/Homebrew/test/dev-cmd/tap-new_spec.rb
index a1a24af6ed109..fe2d1f5827acd 100644
--- a/Library/Homebrew/test/dev-cmd/tap-new_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/tap-new_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/tap-new"
 
-describe "brew tap-new" do
+RSpec.describe Homebrew::DevCmd::TapNew do
   it_behaves_like "parseable arguments"
 
   it "initializes a new tap with a README file and GitHub Actions CI", :integration_test do
diff --git a/Library/Homebrew/test/dev-cmd/test_spec.rb b/Library/Homebrew/test/dev-cmd/test_spec.rb
index 44662625014b9..0eb0dc8b2151f 100644
--- a/Library/Homebrew/test/dev-cmd/test_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/test_spec.rb
@@ -1,9 +1,10 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/test"
+require "sandbox"
 
-describe "brew test" do
+RSpec.describe Homebrew::DevCmd::Test do
   it_behaves_like "parseable arguments"
 
   it "tests a given Formula", :integration_test do
@@ -18,4 +19,19 @@
       .and not_to_output.to_stderr
       .and be_a_success
   end
+
+  it "blocks network access when test phase is offline", :integration_test do
+    if Sandbox.available?
+      install_test_formula "testball_offline_test", <<~RUBY
+        deny_network_access! :test
+        test do
+          system "curl", "example.org"
+        end
+      RUBY
+
+      expect { brew "test", "--verbose", "testball_offline_test" }
+        .to output(/curl: \(6\) Could not resolve host: example\.org/).to_stdout
+        .and be_a_failure
+    end
+  end
 end
diff --git a/Library/Homebrew/test/dev-cmd/tests_spec.rb b/Library/Homebrew/test/dev-cmd/tests_spec.rb
new file mode 100644
index 0000000000000..eef6e0aec1811
--- /dev/null
+++ b/Library/Homebrew/test/dev-cmd/tests_spec.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "cmd/shared_examples/args_parse"
+require "dev-cmd/tests"
+
+RSpec.describe Homebrew::DevCmd::Tests do
+  it_behaves_like "parseable arguments"
+end
diff --git a/Library/Homebrew/test/dev-cmd/typecheck_spec.rb b/Library/Homebrew/test/dev-cmd/typecheck_spec.rb
index 8f886bf81df26..dec2de42d22ea 100644
--- a/Library/Homebrew/test/dev-cmd/typecheck_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/typecheck_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/typecheck"
 
-describe "brew typecheck" do
+RSpec.describe Homebrew::DevCmd::Typecheck do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/unbottled_spec.rb b/Library/Homebrew/test/dev-cmd/unbottled_spec.rb
index d4b973cbd5274..f209b17ca6a11 100644
--- a/Library/Homebrew/test/dev-cmd/unbottled_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/unbottled_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/unbottled"
 
-describe "brew unbottled" do
+RSpec.describe Homebrew::DevCmd::Unbottled do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/unpack_spec.rb b/Library/Homebrew/test/dev-cmd/unpack_spec.rb
index 5ead154d5df59..10251c7dda98b 100644
--- a/Library/Homebrew/test/dev-cmd/unpack_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/unpack_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/unpack"
 
-describe "brew unpack" do
+RSpec.describe Homebrew::DevCmd::Unpack do
   it_behaves_like "parseable arguments"
 
   it "unpacks a given Formula's archive", :integration_test do
diff --git a/Library/Homebrew/test/dev-cmd/update-license-data_spec.rb b/Library/Homebrew/test/dev-cmd/update-license-data_spec.rb
index e6ff0edb199d5..e4505c604f4b1 100644
--- a/Library/Homebrew/test/dev-cmd/update-license-data_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/update-license-data_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/update-license-data"
 
-describe "brew update-license-data" do
+RSpec.describe Homebrew::DevCmd::UpdateLicenseData do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/update-maintainers_spec.rb b/Library/Homebrew/test/dev-cmd/update-maintainers_spec.rb
index 8e8ad57369afb..2b953c399fe34 100644
--- a/Library/Homebrew/test/dev-cmd/update-maintainers_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/update-maintainers_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/update-maintainers"
 
-describe "brew update-maintainers" do
+RSpec.describe Homebrew::DevCmd::UpdateMaintainers do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/update-python-resources_spec.rb b/Library/Homebrew/test/dev-cmd/update-python-resources_spec.rb
index 4cf8610971e67..2487d8eced3f8 100644
--- a/Library/Homebrew/test/dev-cmd/update-python-resources_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/update-python-resources_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/update-python-resources"
 
-describe "brew update-python-resources" do
+RSpec.describe Homebrew::DevCmd::UpdatePythonResources do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/dev-cmd/update-sponsors_spec.rb b/Library/Homebrew/test/dev-cmd/update-sponsors_spec.rb
new file mode 100644
index 0000000000000..a9354f7ee8aa1
--- /dev/null
+++ b/Library/Homebrew/test/dev-cmd/update-sponsors_spec.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "cmd/shared_examples/args_parse"
+require "dev-cmd/update-sponsors"
+
+RSpec.describe Homebrew::DevCmd::UpdateSponsors do
+  it_behaves_like "parseable arguments"
+end
diff --git a/Library/Homebrew/test/dev-cmd/update-test_spec.rb b/Library/Homebrew/test/dev-cmd/update-test_spec.rb
new file mode 100644
index 0000000000000..2ac5b8fd603e6
--- /dev/null
+++ b/Library/Homebrew/test/dev-cmd/update-test_spec.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "cmd/shared_examples/args_parse"
+require "dev-cmd/update-test"
+
+RSpec.describe Homebrew::DevCmd::UpdateTest do
+  it_behaves_like "parseable arguments"
+end
diff --git a/Library/Homebrew/test/dev-cmd/vendor-gems_spec.rb b/Library/Homebrew/test/dev-cmd/vendor-gems_spec.rb
index 276026d4c499b..f2183c524e52c 100644
--- a/Library/Homebrew/test/dev-cmd/vendor-gems_spec.rb
+++ b/Library/Homebrew/test/dev-cmd/vendor-gems_spec.rb
@@ -1,8 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cmd/shared_examples/args_parse"
+require "dev-cmd/vendor-gems"
 
-describe "brew vendor-gems" do
+RSpec.describe Homebrew::DevCmd::VendorGems do
   it_behaves_like "parseable arguments"
 end
diff --git a/Library/Homebrew/test/diagnostic_checks_spec.rb b/Library/Homebrew/test/diagnostic_checks_spec.rb
index 0821fbb4f2265..3e1d9c05639b3 100644
--- a/Library/Homebrew/test/diagnostic_checks_spec.rb
+++ b/Library/Homebrew/test/diagnostic_checks_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "diagnostic"
 
-describe Homebrew::Diagnostic::Checks do
+RSpec.describe Homebrew::Diagnostic::Checks do
   subject(:checks) { described_class.new }
 
   specify "#inject_file_list" do
@@ -11,21 +10,6 @@
     expect(checks.inject_file_list(%w[/a /b], "foo:\n")).to eq("foo:\n  /a\n  /b\n")
   end
 
-  specify "#check_for_anaconda" do
-    mktmpdir do |path|
-      anaconda = "#{path}/anaconda"
-      python = "#{path}/python"
-      FileUtils.touch anaconda
-      File.write(python, "#! #{`which bash`}\necho -n '#{python}'\n")
-      FileUtils.chmod 0755, anaconda
-      FileUtils.chmod 0755, python
-
-      ENV["PATH"] = "#{path}#{File::PATH_SEPARATOR}#{ENV.fetch("PATH")}"
-
-      expect(checks.check_for_anaconda).to match("Anaconda")
-    end
-  end
-
   specify "#check_access_directories" do
     skip "User is root so everything is writable." if Process.euid.zero?
     begin
@@ -80,30 +64,18 @@
     homebrew_path =
       "#{HOMEBREW_PREFIX}/bin#{File::PATH_SEPARATOR}" +
       ENV["HOMEBREW_PATH"].gsub(/(?:^|#{Regexp.escape(File::PATH_SEPARATOR)})#{Regexp.escape(sbin)}/, "")
-    stub_const("ORIGINAL_PATHS", PATH.new(homebrew_path).map { |path| Pathname.new(path).expand_path }.compact)
+    stub_const("ORIGINAL_PATHS", PATH.new(homebrew_path).filter_map { |path| Pathname.new(path).expand_path })
 
     expect(checks.check_user_path_1).to be_nil
     expect(checks.check_user_path_2).to be_nil
     expect(checks.check_user_path_3)
       .to match("Homebrew's \"sbin\" was not found in your PATH")
   ensure
-    sbin.rmtree
-  end
-
-  specify "#check_for_config_scripts" do
-    mktmpdir do |path|
-      file = "#{path}/foo-config"
-      FileUtils.touch file
-      FileUtils.chmod 0755, file
-      ENV["PATH"] = "#{path}#{File::PATH_SEPARATOR}#{ENV.fetch("PATH")}"
-
-      expect(checks.check_for_config_scripts)
-        .to match('"config" scripts exist')
-    end
+    FileUtils.rm_rf(sbin)
   end
 
   specify "#check_for_symlinked_cellar" do
-    HOMEBREW_CELLAR.rmtree
+    FileUtils.rm_r(HOMEBREW_CELLAR)
 
     mktmpdir do |path|
       FileUtils.ln_s path, HOMEBREW_CELLAR
@@ -129,7 +101,7 @@
           FileUtils.chmod 0755, cmd
         end
 
-        allow(Tap).to receive(:cmd_directories).and_return([path1, path2])
+        allow(Commands).to receive(:tap_cmd_directories).and_return([path1, path2])
 
         expect(checks.check_for_external_cmd_name_conflict)
           .to match("brew-foo")
@@ -142,4 +114,22 @@
     expect(checks.check_homebrew_prefix)
       .to match("Your Homebrew's prefix is not #{Homebrew::DEFAULT_PREFIX}")
   end
+
+  specify "#check_for_unnecessary_core_tap" do
+    ENV.delete("HOMEBREW_DEVELOPER")
+    ENV.delete("HOMEBREW_NO_INSTALL_FROM_API")
+
+    expect_any_instance_of(CoreTap).to receive(:installed?).and_return(true)
+
+    expect(checks.check_for_unnecessary_core_tap).to match("You have an unnecessary local Core tap")
+  end
+
+  specify "#check_for_unnecessary_cask_tap" do
+    ENV.delete("HOMEBREW_DEVELOPER")
+    ENV.delete("HOMEBREW_NO_INSTALL_FROM_API")
+
+    expect_any_instance_of(CoreCaskTap).to receive(:installed?).and_return(true)
+
+    expect(checks.check_for_unnecessary_cask_tap).to match("unnecessary local Cask tap")
+  end
 end
diff --git a/Library/Homebrew/test/download_strategies/abstract_spec.rb b/Library/Homebrew/test/download_strategies/abstract_spec.rb
index 00fe1a146fb61..e58b15b49fd15 100644
--- a/Library/Homebrew/test/download_strategies/abstract_spec.rb
+++ b/Library/Homebrew/test/download_strategies/abstract_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "download_strategy"
 
-describe AbstractDownloadStrategy do
+RSpec.describe AbstractDownloadStrategy do
   subject(:strategy) { described_class.new(url, name, version, **specs) }
 
   let(:specs) { {} }
@@ -25,13 +24,13 @@
     let(:specs) { { bottle: true } }
 
     it "extends Pourable" do
-      expect(strategy).to be_a_kind_of(AbstractDownloadStrategy::Pourable)
+      expect(strategy).to be_a(AbstractDownloadStrategy::Pourable)
     end
   end
 
   context "without specs[:bottle]" do
     it "is does not extend Pourable" do
-      expect(strategy).not_to be_a_kind_of(AbstractDownloadStrategy::Pourable)
+      expect(strategy).not_to be_a(AbstractDownloadStrategy::Pourable)
     end
   end
 end
diff --git a/Library/Homebrew/test/download_strategies/curl_github_packages_spec.rb b/Library/Homebrew/test/download_strategies/curl_github_packages_spec.rb
index 7a729bd1bb795..0868a77aa121c 100644
--- a/Library/Homebrew/test/download_strategies/curl_github_packages_spec.rb
+++ b/Library/Homebrew/test/download_strategies/curl_github_packages_spec.rb
@@ -1,45 +1,74 @@
-# typed: false
 # frozen_string_literal: true
 
 require "download_strategy"
 
-describe CurlGitHubPackagesDownloadStrategy do
+RSpec.describe CurlGitHubPackagesDownloadStrategy do
   subject(:strategy) { described_class.new(url, name, version, **specs) }
 
   let(:name) { "foo" }
   let(:url) { "https://#{GitHubPackages::URL_DOMAIN}/v2/homebrew/core/spec_test/manifests/1.2.3" }
   let(:version) { "1.2.3" }
-  let(:specs) { {} }
+  let(:specs) { { headers: ["Accept: application/vnd.oci.image.index.v1+json"] } }
   let(:authorization) { nil }
+  let(:head_response) do
+    <<~HTTP
+      HTTP/2 200\r
+      content-length: 12671\r
+      content-type: application/vnd.oci.image.index.v1+json\r
+      docker-content-digest: sha256:7d752ee92d9120e3884b452dce15328536a60d468023ea8e9f4b09839a5442e5\r
+      docker-distribution-api-version: registry/2.0\r
+      etag: "sha256:7d752ee92d9120e3884b452dce15328536a60d468023ea8e9f4b09839a5442e5"\r
+      date: Sun, 02 Apr 2023 22:45:08 GMT\r
+      x-github-request-id: 8814:FA5A:14DAFB5:158D7A2:642A0574\r
+    HTTP
+  end
 
   describe "#fetch" do
     before do
       stub_const("HOMEBREW_GITHUB_PACKAGES_AUTH", authorization) if authorization.present?
+
+      allow(strategy).to receive(:curl_version).and_return(Version.new("8.7.1"))
+
+      allow(strategy).to receive(:system_command)
+        .with(
+          /curl/,
+          hash_including(args: array_including("--head")),
+        )
+        .twice
+        .and_return(instance_double(
+                      SystemCommand::Result,
+                      success?:    true,
+                      exit_status: instance_double(Process::Status, exitstatus: 0),
+                      stdout:      head_response,
+                    ))
+
       strategy.temporary_path.dirname.mkpath
       FileUtils.touch strategy.temporary_path
     end
 
     it "calls curl with anonymous authentication headers" do
-      expect(strategy).to receive(:system_command).with(
-        /curl/,
-        hash_including(args: array_including_cons("--header", "Authorization: Bearer QQ==")),
-      )
-      .at_least(:once)
-      .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
+      expect(strategy).to receive(:system_command)
+        .with(
+          /curl/,
+          hash_including(args: array_including_cons("--header", "Authorization: Bearer QQ==")),
+        )
+        .at_least(:once)
+        .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
 
       strategy.fetch
     end
 
-    context "with Github Packages authentication defined" do
+    context "with GitHub Packages authentication defined" do
       let(:authorization) { "Bearer dead-beef-cafe" }
 
       it "calls curl with the provided header value" do
-        expect(strategy).to receive(:system_command).with(
-          /curl/,
-          hash_including(args: array_including_cons("--header", "Authorization: #{authorization}")),
-        )
-        .at_least(:once)
-        .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
+        expect(strategy).to receive(:system_command)
+          .with(
+            /curl/,
+            hash_including(args: array_including_cons("--header", "Authorization: #{authorization}")),
+          )
+          .at_least(:once)
+          .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
 
         strategy.fetch
       end
diff --git a/Library/Homebrew/test/download_strategies/curl_post_spec.rb b/Library/Homebrew/test/download_strategies/curl_post_spec.rb
index 0d47b8c6f0d3e..121334fbcaf09 100644
--- a/Library/Homebrew/test/download_strategies/curl_post_spec.rb
+++ b/Library/Homebrew/test/download_strategies/curl_post_spec.rb
@@ -1,24 +1,44 @@
-# typed: false
 # frozen_string_literal: true
 
 require "download_strategy"
 
-describe CurlPostDownloadStrategy do
+RSpec.describe CurlPostDownloadStrategy do
   subject(:strategy) { described_class.new(url, name, version, **specs) }
 
   let(:name) { "foo" }
   let(:url) { "https://example.com/foo.tar.gz" }
   let(:version) { "1.2.3" }
   let(:specs) { {} }
+  let(:head_response) do
+    <<~HTTP
+      HTTP/1.1 200\r
+      Content-Disposition: attachment; filename="foo.tar.gz"
+    HTTP
+  end
 
   describe "#fetch" do
     before do
+      allow(strategy).to receive(:curl_version).and_return(Version.new("8.6.0"))
+
+      allow(strategy).to receive(:system_command)
+        .with(
+          /curl/,
+          hash_including(args: array_including("--head")),
+        )
+        .twice
+        .and_return(instance_double(
+                      SystemCommand::Result,
+                      success?:    true,
+                      exit_status: instance_double(Process::Status, exitstatus: 0),
+                      stdout:      head_response,
+                    ))
+
       strategy.temporary_path.dirname.mkpath
       FileUtils.touch strategy.temporary_path
     end
 
     context "with :using and :data specified" do
-      let(:specs) {
+      let(:specs) do
         {
           using: :post,
           data:  {
@@ -26,15 +46,16 @@
             is:   "good",
           },
         }
-      }
+      end
 
       it "adds the appropriate curl args" do
-        expect(strategy).to receive(:system_command).with(
-          /curl/,
-          hash_including(args: array_including_cons("-d", "form=data").and(array_including_cons("-d", "is=good"))),
-        )
-        .at_least(:once)
-        .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
+        expect(strategy).to receive(:system_command)
+          .with(
+            /curl/,
+            hash_including(args: array_including_cons("-d", "form=data").and(array_including_cons("-d", "is=good"))),
+          )
+          .at_least(:once)
+          .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
 
         strategy.fetch
       end
@@ -44,12 +65,13 @@
       let(:specs) { { using: :post } }
 
       it "adds the appropriate curl args" do
-        expect(strategy).to receive(:system_command).with(
-          /curl/,
-          hash_including(args: array_including_cons("-X", "POST")),
-        )
-        .at_least(:once)
-        .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
+        expect(strategy).to receive(:system_command)
+          .with(
+            /curl/,
+            hash_including(args: array_including_cons("-X", "POST")),
+          )
+          .at_least(:once)
+          .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
 
         strategy.fetch
       end
diff --git a/Library/Homebrew/test/download_strategies/curl_spec.rb b/Library/Homebrew/test/download_strategies/curl_spec.rb
index 8cd3480d7a02b..a71caf5ef1cf7 100644
--- a/Library/Homebrew/test/download_strategies/curl_spec.rb
+++ b/Library/Homebrew/test/download_strategies/curl_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "download_strategy"
 
-describe CurlDownloadStrategy do
+RSpec.describe CurlDownloadStrategy do
   subject(:strategy) { described_class.new(url, name, version, **specs) }
 
   let(:name) { "foo" }
@@ -11,6 +10,17 @@
   let(:version) { "1.2.3" }
   let(:specs) { { user: "download:123456" } }
   let(:artifact_domain) { nil }
+  let(:headers) do
+    {
+      "accept-ranges"  => "bytes",
+      "content-length" => "37182",
+    }
+  end
+
+  before do
+    allow(strategy).to receive(:curl_headers).with(any_args)
+                                             .and_return({ responses: [{ headers: }] })
+  end
 
   it "parses the opts and sets the corresponding args" do
     expect(strategy.send(:_curl_args)).to eq(["--user", "download:123456"])
@@ -26,11 +36,11 @@
 
     it "calls curl with default arguments" do
       expect(strategy).to receive(:curl).with(
+        "--remote-time",
+        "--output", an_instance_of(Pathname),
         # example.com supports partial requests.
         "--continue-at", "-",
         "--location",
-        "--remote-time",
-        "--output", an_instance_of(Pathname),
         url,
         an_instance_of(Hash)
       )
@@ -42,12 +52,13 @@
       let(:specs) { { user_agent: "Mozilla/25.0.1" } }
 
       it "adds the appropriate curl args" do
-        expect(strategy).to receive(:system_command).with(
-          /curl/,
-          hash_including(args: array_including_cons("--user-agent", "Mozilla/25.0.1")),
-        )
-        .at_least(:once)
-        .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
+        expect(strategy).to receive(:system_command)
+          .with(
+            /curl/,
+            hash_including(args: array_including_cons("--user-agent", "Mozilla/25.0.1")),
+          )
+          .at_least(:once)
+          .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
 
         strategy.fetch
       end
@@ -59,37 +70,39 @@
       let(:specs) { { user_agent: :fake } }
 
       it "adds the appropriate curl args" do
-        expect(strategy).to receive(:system_command).with(
-          /curl/,
-          hash_including(args: array_including_cons(
-            "--user-agent",
-            a_string_matching(/Mozilla.*Mac OS X 10.*AppleWebKit/),
-          )),
-        )
-        .at_least(:once)
-        .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
+        expect(strategy).to receive(:system_command)
+          .with(
+            /curl/,
+            hash_including(args: array_including_cons(
+              "--user-agent",
+              a_string_matching(/Mozilla.*Mac OS X 10_15_7.*AppleWebKit/),
+            )),
+          )
+          .at_least(:once)
+          .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
 
         strategy.fetch
       end
     end
 
     context "with cookies set" do
-      let(:specs) {
+      let(:specs) do
         {
           cookies: {
             coo: "k/e",
             mon: "ster",
           },
         }
-      }
+      end
 
       it "adds the appropriate curl args and does not URL-encode the cookies" do
-        expect(strategy).to receive(:system_command).with(
-          /curl/,
-          hash_including(args: array_including_cons("-b", "coo=k/e;mon=ster")),
-        )
-        .at_least(:once)
-        .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
+        expect(strategy).to receive(:system_command)
+          .with(
+            /curl/,
+            hash_including(args: array_including_cons("-b", "coo=k/e;mon=ster")),
+          )
+          .at_least(:once)
+          .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
 
         strategy.fetch
       end
@@ -99,12 +112,13 @@
       let(:specs) { { referer: "https://somehost/also" } }
 
       it "adds the appropriate curl args" do
-        expect(strategy).to receive(:system_command).with(
-          /curl/,
-          hash_including(args: array_including_cons("-e", "https://somehost/also")),
-        )
-        .at_least(:once)
-        .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
+        expect(strategy).to receive(:system_command)
+          .with(
+            /curl/,
+            hash_including(args: array_including_cons("-e", "https://somehost/also")),
+          )
+          .at_least(:once)
+          .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
 
         strategy.fetch
       end
@@ -116,12 +130,15 @@
       let(:specs) { { headers: ["foo", "bar"] } }
 
       it "adds the appropriate curl args" do
-        expect(strategy).to receive(:system_command).with(
-          /curl/,
-          hash_including(args: array_including_cons("--header", "foo").and(array_including_cons("--header", "bar"))),
-        )
-        .at_least(:once)
-        .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
+        expect(strategy).to receive(:system_command)
+          .with(
+            /curl/,
+            hash_including(
+              args: array_including_cons("--header", "foo").and(array_including_cons("--header", "bar")),
+            ),
+          )
+          .at_least(:once)
+          .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
 
         strategy.fetch
       end
@@ -132,12 +149,13 @@
 
       context "with an asset hosted under example.com" do
         it "leaves the URL unchanged" do
-          expect(strategy).to receive(:system_command).with(
-            /curl/,
-            hash_including(args: array_including_cons(url)),
-          )
-          .at_least(:once)
-          .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
+          expect(strategy).to receive(:system_command)
+            .with(
+              /curl/,
+              hash_including(args: array_including_cons(url)),
+            )
+            .at_least(:once)
+            .and_return(instance_double(SystemCommand::Result, success?: true, stdout: "", assert_success!: nil))
 
           strategy.fetch
         end
@@ -149,12 +167,13 @@
         let(:status) { instance_double(Process::Status, success?: true, exitstatus: 0) }
 
         it "rewrites the URL correctly" do
-          expect(strategy).to receive(:system_command).with(
-            /curl/,
-            hash_including(args: array_including_cons("#{artifact_domain}/#{resource_path}")),
-          )
-          .at_least(:once)
-          .and_return(SystemCommand::Result.new(["curl"], [""], status, secrets: []))
+          expect(strategy).to receive(:system_command)
+            .with(
+              /curl/,
+              hash_including(args: array_including_cons("#{artifact_domain}/#{resource_path}")),
+            )
+            .at_least(:once)
+            .and_return(SystemCommand::Result.new(["curl"], [""], status, secrets: []))
 
           strategy.fetch
         end
@@ -166,12 +185,13 @@
         let(:status) { instance_double(Process::Status, success?: true, exitstatus: 0) }
 
         it "rewrites the URL correctly" do
-          expect(strategy).to receive(:system_command).with(
-            /curl/,
-            hash_including(args: array_including_cons("#{artifact_domain}/#{resource_path}")),
-          )
-          .at_least(:once)
-          .and_return(SystemCommand::Result.new(["curl"], [""], status, secrets: []))
+          expect(strategy).to receive(:system_command)
+            .with(
+              /curl/,
+              hash_including(args: array_including_cons("#{artifact_domain}/#{resource_path}")),
+            )
+            .at_least(:once)
+            .and_return(SystemCommand::Result.new(["curl"], [""], status, secrets: []))
 
           strategy.fetch
         end
@@ -180,48 +200,48 @@
   end
 
   describe "#cached_location" do
-    subject(:cached_location) { described_class.new(url, name, version, **specs).cached_location }
+    subject(:cached_location) { strategy.cached_location }
 
     context "when URL ends with file" do
-      it {
+      it "falls back to the file name in the URL" do
         expect(cached_location).to eq(
           HOMEBREW_CACHE/"downloads/3d1c0ae7da22be9d83fb1eb774df96b7c4da71d3cf07e1cb28555cf9a5e5af70--foo.tar.gz",
         )
-      }
+      end
     end
 
     context "when URL file is in middle" do
       let(:url) { "https://example.com/foo.tar.gz/from/this/mirror" }
 
-      it {
+      it "falls back to the file name in the URL" do
         expect(cached_location).to eq(
           HOMEBREW_CACHE/"downloads/1ab61269ba52c83994510b1e28dd04167a2f2e8393a35a9c50c1f7d33fd8f619--foo.tar.gz",
         )
-      }
+      end
     end
 
     context "with a file name trailing the URL path" do
       let(:url) { "https://example.com/cask.dmg" }
 
-      it {
+      it "falls back to the file extension in the URL" do
         expect(cached_location.extname).to eq(".dmg")
-      }
+      end
     end
 
     context "with a file name trailing the first query parameter" do
       let(:url) { "https://example.com/download?file=cask.zip&a=1" }
 
-      it {
+      it "falls back to the file extension in the URL" do
         expect(cached_location.extname).to eq(".zip")
-      }
+      end
     end
 
     context "with a file name trailing the second query parameter" do
       let(:url) { "https://example.com/dl?a=1&file=cask.zip&b=2" }
 
-      it {
+      it "falls back to the file extension in the URL" do
         expect(cached_location.extname).to eq(".zip")
-      }
+      end
     end
 
     context "with an unusually long query string" do
@@ -243,10 +263,10 @@
         ].join
       end
 
-      it {
+      it "falls back to the file extension in the URL" do
         expect(cached_location.extname).to eq(".zip")
         expect(cached_location.to_path.length).to be_between(0, 255)
-      }
+      end
     end
   end
 end
diff --git a/Library/Homebrew/test/download_strategies/detector_spec.rb b/Library/Homebrew/test/download_strategies/detector_spec.rb
index ecbb13cbc2f2c..aaf84f2784701 100644
--- a/Library/Homebrew/test/download_strategies/detector_spec.rb
+++ b/Library/Homebrew/test/download_strategies/detector_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "download_strategy"
 
-describe DownloadStrategyDetector do
+RSpec.describe DownloadStrategyDetector do
   describe "::detect" do
     subject(:strategy_detector) { described_class.detect(url, strategy) }
 
@@ -16,6 +15,12 @@
       it { is_expected.to eq(GitDownloadStrategy) }
     end
 
+    context "when given SSH Git URL" do
+      let(:url) { "ssh://git@example.com/foo.git" }
+
+      it { is_expected.to eq(GitDownloadStrategy) }
+    end
+
     context "when given a GitHub Git URL" do
       let(:url) { "https://github.com/homebrew/brew.git" }
 
@@ -27,9 +32,9 @@
     end
 
     it "raises an error when passed an unrecognized strategy" do
-      expect {
+      expect do
         described_class.detect("foo", Class.new)
-      }.to raise_error(TypeError)
+      end.to raise_error(TypeError)
     end
   end
 end
diff --git a/Library/Homebrew/test/download_strategies/git_spec.rb b/Library/Homebrew/test/download_strategies/git_spec.rb
index a9d8e6215bd1f..42f1fdaeb4847 100644
--- a/Library/Homebrew/test/download_strategies/git_spec.rb
+++ b/Library/Homebrew/test/download_strategies/git_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "download_strategy"
 
-describe GitDownloadStrategy do
+RSpec.describe GitDownloadStrategy do
   subject(:strategy) { described_class.new(url, name, version) }
 
   let(:name) { "baz" }
@@ -18,12 +17,15 @@
 
   def git_commit_all
     system "git", "add", "--all"
+    # Allow instance variables here to have nice commit messages.
+    # rubocop:disable RSpec/InstanceVariable
     system "git", "commit", "-m", "commit number #{@commit_id}"
     @commit_id += 1
+    # rubocop:enable RSpec/InstanceVariable
   end
 
   def setup_git_repo
-    system "git", "init"
+    system "git", "-c", "init.defaultBranch=master", "init"
     system "git", "remote", "add", "origin", "https://github.com/Homebrew/homebrew-foo"
     FileUtils.touch "README"
     git_commit_all
@@ -49,7 +51,7 @@ def setup_git_repo
 
   describe "#fetch_last_commit" do
     let(:url) { "file://#{remote_repo}" }
-    let(:version) { Version.create("HEAD") }
+    let(:version) { Version.new("HEAD") }
     let(:remote_repo) { HOMEBREW_PREFIX/"remote_repo" }
 
     before { remote_repo.mkpath }
diff --git a/Library/Homebrew/test/download_strategies/github_git_spec.rb b/Library/Homebrew/test/download_strategies/github_git_spec.rb
index 26948c5b1f350..27ef115257093 100644
--- a/Library/Homebrew/test/download_strategies/github_git_spec.rb
+++ b/Library/Homebrew/test/download_strategies/github_git_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "download_strategy"
 
-describe GitHubGitDownloadStrategy do
+RSpec.describe GitHubGitDownloadStrategy do
   subject(:strategy) { described_class.new(url, name, version) }
 
   let(:name) { "brew" }
diff --git a/Library/Homebrew/test/download_strategies/subversion_spec.rb b/Library/Homebrew/test/download_strategies/subversion_spec.rb
index 04eed96b85e9c..c1f08caf16c62 100644
--- a/Library/Homebrew/test/download_strategies/subversion_spec.rb
+++ b/Library/Homebrew/test/download_strategies/subversion_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "download_strategy"
 
-describe SubversionDownloadStrategy do
+RSpec.describe SubversionDownloadStrategy do
   subject(:strategy) { described_class.new(url, name, version, **specs) }
 
   let(:name) { "foo" }
diff --git a/Library/Homebrew/test/download_strategies/vcs_spec.rb b/Library/Homebrew/test/download_strategies/vcs_spec.rb
index d4406088b798c..4f564a6133e21 100644
--- a/Library/Homebrew/test/download_strategies/vcs_spec.rb
+++ b/Library/Homebrew/test/download_strategies/vcs_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "download_strategy"
 
-describe VCSDownloadStrategy do
+RSpec.describe VCSDownloadStrategy do
   let(:url) { "https://example.com/bar" }
   let(:version) { nil }
 
diff --git a/Library/Homebrew/test/env_config_spec.rb b/Library/Homebrew/test/env_config_spec.rb
index 47713b155dc59..39a2613fbf204 100644
--- a/Library/Homebrew/test/env_config_spec.rb
+++ b/Library/Homebrew/test/env_config_spec.rb
@@ -1,11 +1,16 @@
-# typed: false
 # frozen_string_literal: true
 
 require "diagnostic"
 
-describe Homebrew::EnvConfig do
+RSpec.describe Homebrew::EnvConfig do
   subject(:env_config) { described_class }
 
+  describe "ENVS" do
+    it "sorts alphabetically" do
+      expect(env_config::ENVS.keys).to eql(env_config::ENVS.keys.sort)
+    end
+  end
+
   describe ".env_method_name" do
     it "generates method names" do
       expect(env_config.env_method_name("HOMEBREW_FOO", {})).to eql("foo")
@@ -28,15 +33,15 @@
     end
   end
 
-  describe ".auto_update_secs" do
+  describe ".cleanup_periodic_full_days" do
     it "returns value if set" do
-      ENV["HOMEBREW_AUTO_UPDATE_SECS"] = "360"
-      expect(env_config.auto_update_secs).to eql("360")
+      ENV["HOMEBREW_CLEANUP_PERIODIC_FULL_DAYS"] = "360"
+      expect(env_config.cleanup_periodic_full_days).to eql("360")
     end
 
     it "returns default if unset" do
-      ENV["HOMEBREW_AUTO_UPDATE_SECS"] = nil
-      expect(env_config.auto_update_secs).to eql("300")
+      ENV["HOMEBREW_CLEANUP_PERIODIC_FULL_DAYS"] = nil
+      expect(env_config.cleanup_periodic_full_days).to eql("30")
     end
   end
 
diff --git a/Library/Homebrew/test/error_during_execution_spec.rb b/Library/Homebrew/test/error_during_execution_spec.rb
index a2fdcc3a9d441..5309667105c85 100644
--- a/Library/Homebrew/test/error_during_execution_spec.rb
+++ b/Library/Homebrew/test/error_during_execution_spec.rb
@@ -1,67 +1,66 @@
-# typed: false
 # frozen_string_literal: true
 
-describe ErrorDuringExecution do
-  subject(:error) { described_class.new(command, status: status, output: output) }
+RSpec.describe ErrorDuringExecution do
+  subject(:error) { described_class.new(command, status:, output:) }
 
   let(:command) { ["false"] }
-  let(:status) { instance_double(Process::Status, exitstatus: exitstatus, termsig: nil) }
+  let(:status) { instance_double(Process::Status, exitstatus:, termsig: nil) }
   let(:exitstatus) { 1 }
   let(:output) { nil }
 
   describe "#initialize" do
     it "fails when only given a command" do
-      expect {
+      expect do
         described_class.new(command)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "fails when only given a status" do
-      expect {
-        described_class.new(status: status)
-      }.to raise_error(ArgumentError)
+      expect do
+        described_class.new(status:)
+      end.to raise_error(ArgumentError)
     end
 
     it "does not raise an error when given both a command and a status" do
-      expect {
-        described_class.new(command, status: status)
-      }.not_to raise_error
+      expect do
+        described_class.new(command, status:)
+      end.not_to raise_error
     end
   end
 
   describe "#to_s" do
     context "when only given a command and a status" do
-      its(:to_s) { is_expected.to eq "Failure while executing; `false` exited with 1." }
+      it(:to_s) { expect(error.to_s).to eq "Failure while executing; `false` exited with 1." }
     end
 
     context "when additionally given the output" do
-      let(:output) {
+      let(:output) do
         [
           [:stdout, "This still worked.\n"],
           [:stderr, "Here something went wrong.\n"],
         ]
-      }
+      end
 
       before do
         allow($stdout).to receive(:tty?).and_return(true)
       end
 
-      its(:to_s) {
+      it(:to_s) do
         expect(error.to_s).to eq <<~EOS
           Failure while executing; `false` exited with 1. Here's the output:
           This still worked.
           #{Formatter.error("Here something went wrong.\n")}
         EOS
-      }
+      end
     end
 
     context "when command arguments contain special characters" do
       let(:command) { ["env", "PATH=/bin", "cat", "with spaces"] }
 
-      its(:to_s) {
+      it(:to_s) do
         expect(error.to_s)
           .to eq 'Failure while executing; `env PATH=/bin cat with\ spaces` exited with 1.'
-      }
+      end
     end
   end
 end
diff --git a/Library/Homebrew/test/exceptions_spec.rb b/Library/Homebrew/test/exceptions_spec.rb
index 054efd2db1366..27d03c3239035 100644
--- a/Library/Homebrew/test/exceptions_spec.rb
+++ b/Library/Homebrew/test/exceptions_spec.rb
@@ -1,45 +1,54 @@
-# typed: false
 # frozen_string_literal: true
 
 require "exceptions"
 
-describe "Exception" do
+RSpec.describe "Exception" do
   describe MultipleVersionsInstalledError do
-    subject {
+    subject(:error) do
       described_class.new <<~EOS
         foo has multiple installed versions
         Run `brew uninstall --force foo` to remove all versions.
       EOS
-    }
+    end
 
-    its(:to_s) {
-      is_expected.to eq <<~EOS
+    it(:to_s) do
+      expect(error.to_s).to eq <<~EOS
         foo has multiple installed versions
         Run `brew uninstall --force foo` to remove all versions.
       EOS
-    }
+    end
   end
 
   describe NoSuchKegError do
-    subject { described_class.new("foo") }
+    context "without a tap" do
+      subject(:error) { described_class.new("foo") }
+
+      it(:to_s) { expect(error.to_s).to eq("No such keg: #{HOMEBREW_CELLAR}/foo") }
+    end
 
-    its(:to_s) { is_expected.to eq("No such keg: #{HOMEBREW_CELLAR}/foo") }
+    context "with a tap" do
+      subject(:error) { described_class.new("foo", tap:) }
+
+      let(:tap) { instance_double(Tap, to_s: "u/r") }
+
+      it(:to_s) { expect(error.to_s).to eq("No such keg: #{HOMEBREW_CELLAR}/foo from tap u/r") }
+    end
   end
 
   describe FormulaValidationError do
     subject(:error) { described_class.new("foo", "sha257", "magic") }
 
-    its(:to_s) {
+    it(:to_s) do
       expect(error.to_s).to eq(%q(invalid attribute for formula 'foo': sha257 ("magic")))
-    }
+    end
   end
 
   describe TapFormulaOrCaskUnavailableError do
     subject(:error) { described_class.new(tap, "foo") }
 
-    let(:tap) { double(Tap, user: "u", repo: "r", to_s: "u/r", installed?: false) }
+    let(:tap) { instance_double(Tap, user: "u", repository: "r", to_s: "u/r", installed?: false) }
 
-    its(:to_s) { is_expected.to match(%r{Please tap it and then try again: brew tap u/r}) }
+    it(:to_s) { expect(error.to_s).to match(%r{Please tap it and then try again: brew tap u/r}) }
   end
 
   describe FormulaUnavailableError do
@@ -62,7 +71,7 @@
     end
 
     context "without a dependent" do
-      its(:to_s) { is_expected.to eq('No available formula with the name "foo".') }
+      it(:to_s) { expect(error.to_s).to eq('No available formula with the name "foo".') }
     end
 
     context "with a dependent" do
@@ -70,18 +79,18 @@
         error.dependent = "foobar"
       end
 
-      its(:to_s) {
+      it(:to_s) do
         expect(error.to_s).to eq('No available formula with the name "foo" (dependency of foobar).')
-      }
+      end
     end
   end
 
   describe TapFormulaUnavailableError do
-    subject { described_class.new(tap, "foo") }
+    subject(:error) { described_class.new(tap, "foo") }
 
-    let(:tap) { double(Tap, user: "u", repo: "r", to_s: "u/r", installed?: false) }
+    let(:tap) { instance_double(Tap, user: "u", repository: "r", to_s: "u/r", installed?: false) }
 
-    its(:to_s) { is_expected.to match(%r{Please tap it and then try again: brew tap u/r}) }
+    it(:to_s) { expect(error.to_s).to match(%r{Please tap it and then try again: brew tap u/r}) }
   end
 
   describe FormulaClassUnavailableError do
@@ -89,153 +98,156 @@
 
     let(:mod) do
       Module.new do
+        # These are defined within an anonymous module to avoid polluting the global namespace.
+        # rubocop:disable RSpec/LeakyConstantDeclaration,Lint/ConstantDefinitionInBlock
         class Bar < Requirement; end
 
         class Baz < Formula; end
+        # rubocop:enable RSpec/LeakyConstantDeclaration,Lint/ConstantDefinitionInBlock
       end
     end
 
     context "when there are no classes" do
       let(:list) { [] }
 
-      its(:to_s) {
+      it(:to_s) do
         expect(error.to_s).to match(/Expected to find class Foo, but found no classes\./)
-      }
+      end
     end
 
     context "when the class is not derived from Formula" do
       let(:list) { [mod.const_get(:Bar)] }
 
-      its(:to_s) {
+      it(:to_s) do
         expect(error.to_s).to match(/Expected to find class Foo, but only found: Bar \(not derived from Formula!\)\./)
-      }
+      end
     end
 
     context "when the class is derived from Formula" do
       let(:list) { [mod.const_get(:Baz)] }
 
-      its(:to_s) { is_expected.to match(/Expected to find class Foo, but only found: Baz\./) }
+      it(:to_s) { expect(error.to_s).to match(/Expected to find class Foo, but only found: Baz\./) }
     end
   end
 
   describe FormulaUnreadableError do
-    subject { described_class.new("foo", formula_error) }
+    subject(:error) { described_class.new("foo", formula_error) }
 
     let(:formula_error) { LoadError.new("bar") }
 
-    its(:to_s) { is_expected.to eq("foo: bar") }
+    it(:to_s) { expect(error.to_s).to eq("foo: bar") }
   end
 
   describe TapUnavailableError do
-    subject { described_class.new("foo") }
+    subject(:error) { described_class.new("foo") }
 
-    its(:to_s) { is_expected.to eq("No available tap foo.\n") }
+    it(:to_s) { expect(error.to_s).to eq("No available tap foo.\nRun brew tap-new foo to create a new foo tap!\n") }
   end
 
   describe TapAlreadyTappedError do
-    subject { described_class.new("foo") }
+    subject(:error) { described_class.new("foo") }
 
-    its(:to_s) { is_expected.to eq("Tap foo already tapped.\n") }
+    it(:to_s) { expect(error.to_s).to eq("Tap foo already tapped.\n") }
   end
 
   describe BuildError do
-    subject { described_class.new(formula, "badprg", %w[arg1 arg2], {}) }
+    subject(:error) { described_class.new(formula, "badprg", ["arg1", 2, Pathname.new("arg3"), :arg4], {}) }
 
-    let(:formula) { double(Formula, name: "foo") }
+    let(:formula) { instance_double(Formula, name: "foo") }
 
-    its(:to_s) { is_expected.to eq("Failed executing: badprg arg1 arg2") }
+    it(:to_s) { expect(error.to_s).to eq("Failed executing: badprg arg1 2 arg3 arg4") }
   end
 
   describe OperationInProgressError do
-    subject { described_class.new("foo") }
+    subject(:error) { described_class.new(Pathname("foo")) }
 
-    its(:to_s) { is_expected.to match(/Operation already in progress for foo/) }
+    it(:to_s) { expect(error.to_s).to match(/has already locked foo/) }
   end
 
   describe FormulaInstallationAlreadyAttemptedError do
-    subject { described_class.new(formula) }
+    subject(:error) { described_class.new(formula) }
 
-    let(:formula) { double(Formula, full_name: "foo/bar") }
+    let(:formula) { instance_double(Formula, full_name: "foo/bar") }
 
-    its(:to_s) { is_expected.to eq("Formula installation already attempted: foo/bar") }
+    it(:to_s) { expect(error.to_s).to eq("Formula installation already attempted: foo/bar") }
   end
 
   describe FormulaConflictError do
-    subject { described_class.new(formula, [conflict]) }
+    subject(:error) { described_class.new(formula, [conflict]) }
 
-    let(:formula) { double(Formula, full_name: "foo/qux") }
-    let(:conflict) { double(name: "bar", reason: "I decided to") }
+    let(:formula) { instance_double(Formula, full_name: "foo/qux") }
+    let(:conflict) { instance_double(FormulaConflict, name: "bar", reason: "I decided to") }
 
-    its(:to_s) { is_expected.to match(/Please `brew unlink bar` before continuing\./) }
+    it(:to_s) { expect(error.to_s).to match(/Please `brew unlink bar` before continuing\./) }
   end
 
   describe CompilerSelectionError do
-    subject { described_class.new(formula) }
+    subject(:error) { described_class.new(formula) }
 
-    let(:formula) { double(Formula, full_name: "foo") }
+    let(:formula) { instance_double(Formula, full_name: "foo") }
 
-    its(:to_s) { is_expected.to match(/foo cannot be built with any available compilers\./) }
+    it(:to_s) { expect(error.to_s).to match(/foo cannot be built with any available compilers\./) }
   end
 
   describe CurlDownloadStrategyError do
     context "when the file does not exist" do
-      subject { described_class.new("file:///tmp/foo") }
+      subject(:error) { described_class.new("file:///tmp/foo") }
 
-      its(:to_s) { is_expected.to eq("File does not exist: /tmp/foo") }
+      it(:to_s) { expect(error.to_s).to eq("File does not exist: /tmp/foo") }
     end
 
     context "when the download failed" do
-      subject { described_class.new("https://brew.sh") }
+      subject(:error) { described_class.new("https://brew.sh") }
 
-      its(:to_s) { is_expected.to eq("Download failed: https://brew.sh") }
+      it(:to_s) { expect(error.to_s).to eq("Download failed: https://brew.sh") }
     end
   end
 
   describe ErrorDuringExecution do
-    subject { described_class.new(["badprg", "arg1", "arg2"], status: status) }
+    subject(:error) { described_class.new(["badprg", "arg1", "arg2"], status:) }
 
     let(:status) { instance_double(Process::Status, exitstatus: 17, termsig: nil) }
 
-    its(:to_s) { is_expected.to eq("Failure while executing; `badprg arg1 arg2` exited with 17.") }
+    it(:to_s) { expect(error.to_s).to eq("Failure while executing; `badprg arg1 arg2` exited with 17.") }
   end
 
   describe ChecksumMismatchError do
-    subject { described_class.new("/file.tar.gz", hash1, hash2) }
+    subject(:error) { described_class.new("/file.tar.gz", expected_checksum, actual_checksum) }
 
-    let(:hash1) { double(hash_type: "sha256", to_s: "deadbeef") }
-    let(:hash2) { double(hash_type: "sha256", to_s: "deadcafe") }
+    let(:expected_checksum) { instance_double(Checksum, to_s: "deadbeef") }
+    let(:actual_checksum) { instance_double(Checksum, to_s: "deadcafe") }
 
-    its(:to_s) { is_expected.to match(/SHA256 mismatch/) }
+    it(:to_s) { expect(error.to_s).to match(/SHA256 mismatch/) }
   end
 
   describe ResourceMissingError do
-    subject { described_class.new(formula, resource) }
+    subject(:error) { described_class.new(formula, resource) }
 
-    let(:formula) { double(Formula, full_name: "bar") }
-    let(:resource) { double(inspect: "<resource foo>") }
+    let(:formula) { instance_double(Formula, full_name: "bar") }
+    let(:resource) { instance_double(Resource, inspect: "<resource foo>") }
 
-    its(:to_s) { is_expected.to eq("bar does not define resource <resource foo>") }
+    it(:to_s) { expect(error.to_s).to eq("bar does not define resource <resource foo>") }
   end
 
   describe DuplicateResourceError do
-    subject { described_class.new(resource) }
+    subject(:error) { described_class.new(resource) }
 
-    let(:resource) { double(inspect: "<resource foo>") }
+    let(:resource) { instance_double(Resource, inspect: "<resource foo>") }
 
-    its(:to_s) { is_expected.to eq("Resource <resource foo> is defined more than once") }
+    it(:to_s) { expect(error.to_s).to eq("Resource <resource foo> is defined more than once") }
   end
 
   describe BottleFormulaUnavailableError do
-    subject { described_class.new("/foo.bottle.tar.gz", "foo/1.0/.brew/foo.rb") }
+    subject(:error) { described_class.new("/foo.bottle.tar.gz", "foo/1.0/.brew/foo.rb") }
 
-    let(:formula) { double(Formula, full_name: "foo") }
+    let(:formula) { instance_double(Formula, full_name: "foo") }
 
-    its(:to_s) { is_expected.to match(/This bottle does not contain the formula file/) }
+    it(:to_s) { expect(error.to_s).to match(/This bottle does not contain the formula file/) }
   end
 
   describe BuildFlagsError do
-    subject { described_class.new(["-s"]) }
+    subject(:error) { described_class.new(["-s"]) }
 
-    its(:to_s) { is_expected.to match(/flag:\s+-s\nrequires building tools/) }
+    it(:to_s) { expect(error.to_s).to match(/flag:\s+-s\nrequires building tools/) }
   end
 end
diff --git a/Library/Homebrew/test/extend/array_spec.rb b/Library/Homebrew/test/extend/array_spec.rb
new file mode 100644
index 0000000000000..deac14ec6ac31
--- /dev/null
+++ b/Library/Homebrew/test/extend/array_spec.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "extend/array"
+
+RSpec.describe Array do
+  describe ".to_sentence" do
+    it "converts a plain array to a sentence" do
+      expect([].to_sentence).to eq("")
+      expect(["one"].to_sentence).to eq("one")
+      expect(["one", "two"].to_sentence).to eq("one and two")
+      expect(["one", "two", "three"].to_sentence).to eq("one, two and three")
+    end
+
+    it "converts an array to a sentence with a custom connector" do
+      expect(["one", "two", "three"].to_sentence(words_connector: " ")).to eq("one two and three")
+      expect(["one", "two", "three"].to_sentence(words_connector: " & ")).to eq("one & two and three")
+    end
+
+    it "converts an array to a sentence with a custom last word connector" do
+      expect(["one", "two", "three"].to_sentence(last_word_connector: ", and also "))
+        .to eq("one, two, and also three")
+      expect(["one", "two", "three"].to_sentence(last_word_connector: " ")).to eq("one, two three")
+      expect(["one", "two", "three"].to_sentence(last_word_connector: " and ")).to eq("one, two and three")
+    end
+
+    it "converts an array to a sentence with a custom two word connector" do
+      expect(["one", "two"].to_sentence(two_words_connector: " ")).to eq("one two")
+    end
+
+    it "creates a new string" do
+      elements = ["one"]
+      expect(elements.to_sentence.object_id).not_to eq(elements[0].object_id)
+    end
+
+    it "converts a non-String to a sentence" do
+      expect([1].to_sentence).to eq("1")
+    end
+
+    it "converts an array with blank elements to a sentence" do
+      expect([nil, "one", "", "two", "three"].to_sentence).to eq(", one, , two and three")
+    end
+
+    it "does not return a frozen string" do
+      expect([""].to_sentence).not_to be_frozen
+      expect(["one"].to_sentence).not_to be_frozen
+      expect(["one", "two"].to_sentence).not_to be_frozen
+      expect(["one", "two", "three"].to_sentence).not_to be_frozen
+    end
+  end
+end
diff --git a/Library/Homebrew/test/extend/blank_spec.rb b/Library/Homebrew/test/extend/blank_spec.rb
new file mode 100644
index 0000000000000..6c5d466692e8d
--- /dev/null
+++ b/Library/Homebrew/test/extend/blank_spec.rb
@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "extend/blank"
+
+RSpec.describe Object do
+  let(:empty_true) do
+    Class.new(described_class) do
+      def empty?
+        0
+      end
+    end
+  end
+  let(:empty_false) do
+    Class.new(described_class) do
+      def empty?
+        false
+      end
+    end
+  end
+  let(:blank) { [empty_true.new, nil, false, "", "   ", "  \n\t  \r ", "　", "\u00a0", [], {}] }
+  let(:present) { [empty_false.new, described_class.new, true, 0, 1, "a", [nil], { nil => 0 }, Time.now] }
+
+  describe ".blank?" do
+    it "checks if an object is blank" do
+      blank.each { |v| expect(v.blank?).to be true }
+      present.each { |v| expect(v.blank?).to be false }
+    end
+
+    it "checks if an object is blank with bundled string encodings" do
+      Encoding.list.reject(&:dummy?).each do |encoding|
+        expect(" ".encode(encoding).blank?).to be true
+        expect("a".encode(encoding).blank?).to be false
+      end
+    end
+  end
+
+  describe ".present?" do
+    it "checks if an object is present" do
+      blank.each { |v| expect(v.present?).to be false }
+      present.each { |v| expect(v.present?).to be true }
+    end
+  end
+
+  describe ".presence" do
+    it "returns the object if present, or nil" do
+      blank.each { |v| expect(v.presence).to be_nil }
+      present.each { |v| expect(v.presence).to be v }
+    end
+  end
+end
diff --git a/Library/Homebrew/test/extend/kernel_spec.rb b/Library/Homebrew/test/extend/kernel_spec.rb
new file mode 100644
index 0000000000000..238f4573e33a5
--- /dev/null
+++ b/Library/Homebrew/test/extend/kernel_spec.rb
@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+RSpec.describe Kernel do
+  let(:dir) { mktmpdir }
+
+  def esc(code)
+    /(\e\[\d+m)*\e\[#{code}m/
+  end
+
+  describe "#ofail" do
+    it "sets Homebrew.failed to true" do
+      expect do
+        ofail "foo"
+      end.to output("Error: foo\n").to_stderr
+
+      expect(Homebrew).to have_failed
+    end
+  end
+
+  describe "#odie" do
+    it "exits with 1" do
+      expect do
+        odie "foo"
+      end.to output("Error: foo\n").to_stderr.and raise_error SystemExit
+    end
+  end
+
+  describe "#pretty_installed" do
+    subject(:pretty_installed_output) { pretty_installed("foo") }
+
+    context "when $stdout is a TTY" do
+      before { allow($stdout).to receive(:tty?).and_return(true) }
+
+      context "with HOMEBREW_NO_EMOJI unset" do
+        it "returns a string with a colored checkmark" do
+          expect(pretty_installed_output)
+            .to match(/#{esc 1}foo #{esc 32}✔#{esc 0}/)
+        end
+      end
+
+      context "with HOMEBREW_NO_EMOJI set" do
+        before { ENV["HOMEBREW_NO_EMOJI"] = "1" }
+
+        it "returns a string with colored info" do
+          expect(pretty_installed_output)
+            .to match(/#{esc 1}foo \(installed\)#{esc 0}/)
+        end
+      end
+    end
+
+    context "when $stdout is not a TTY" do
+      before { allow($stdout).to receive(:tty?).and_return(false) }
+
+      it "returns plain text" do
+        expect(pretty_installed_output).to eq("foo")
+      end
+    end
+  end
+
+  describe "#pretty_uninstalled" do
+    subject(:pretty_uninstalled_output) { pretty_uninstalled("foo") }
+
+    context "when $stdout is a TTY" do
+      before { allow($stdout).to receive(:tty?).and_return(true) }
+
+      context "with HOMEBREW_NO_EMOJI unset" do
+        it "returns a string with a colored checkmark" do
+          expect(pretty_uninstalled_output)
+            .to match(/#{esc 1}foo #{esc 31}✘#{esc 0}/)
+        end
+      end
+
+      context "with HOMEBREW_NO_EMOJI set" do
+        before { ENV["HOMEBREW_NO_EMOJI"] = "1" }
+
+        it "returns a string with colored info" do
+          expect(pretty_uninstalled_output)
+            .to match(/#{esc 1}foo \(uninstalled\)#{esc 0}/)
+        end
+      end
+    end
+
+    context "when $stdout is not a TTY" do
+      before { allow($stdout).to receive(:tty?).and_return(false) }
+
+      it "returns plain text" do
+        expect(pretty_uninstalled_output).to eq("foo")
+      end
+    end
+  end
+
+  describe "#interactive_shell" do
+    let(:shell) { dir/"myshell" }
+
+    it "starts an interactive shell session" do
+      File.write shell, <<~SH
+        #!/bin/sh
+        echo called > "#{dir}/called"
+      SH
+
+      FileUtils.chmod 0755, shell
+
+      ENV["SHELL"] = shell
+
+      expect { interactive_shell }.not_to raise_error
+      expect(dir/"called").to exist
+    end
+  end
+
+  describe "#with_custom_locale" do
+    it "temporarily overrides the system locale" do
+      ENV["LC_ALL"] = "en_US.UTF-8"
+
+      with_custom_locale("C") do
+        expect(ENV.fetch("LC_ALL")).to eq("C")
+      end
+
+      expect(ENV.fetch("LC_ALL")).to eq("en_US.UTF-8")
+    end
+  end
+
+  describe "#which" do
+    let(:cmd) { dir/"foo" }
+
+    before { FileUtils.touch cmd }
+
+    it "returns the first executable that is found" do
+      cmd.chmod 0744
+      expect(which(File.basename(cmd), File.dirname(cmd))).to eq(cmd)
+    end
+
+    it "skips non-executables" do
+      expect(which(File.basename(cmd), File.dirname(cmd))).to be_nil
+    end
+
+    it "skips malformed path and doesn't fail" do
+      # 'which' should not fail if a path is malformed
+      # see https://github.com/Homebrew/legacy-homebrew/issues/32789 for an example
+      cmd.chmod 0744
+
+      # ~~ will fail because ~foo resolves to foo's home and there is no '~' user
+      path = ["~~", File.dirname(cmd)].join(File::PATH_SEPARATOR)
+      expect(which(File.basename(cmd), path)).to eq(cmd)
+    end
+  end
+
+  describe "#which_all" do
+    let(:cmd_foo) { dir/"foo" }
+    let(:cmd_foo_bar) { dir/"bar/foo" }
+    let(:cmd_bar_baz_foo) { dir/"bar/baz/foo" }
+
+    before do
+      (dir/"bar/baz").mkpath
+
+      FileUtils.touch cmd_foo_bar
+
+      [cmd_foo, cmd_bar_baz_foo].each do |cmd|
+        FileUtils.touch cmd
+        cmd.chmod 0744
+      end
+    end
+
+    it "returns an array of all executables that are found" do
+      path = [
+        "#{dir}/bar/baz",
+        "#{dir}/baz:#{dir}",
+        "~baduserpath",
+      ].join(File::PATH_SEPARATOR)
+      expect(which_all("foo", path)).to eq([cmd_bar_baz_foo, cmd_foo])
+    end
+  end
+
+  specify "#which_editor" do
+    ENV["HOMEBREW_EDITOR"] = "vemate -w"
+    ENV["HOMEBREW_PATH"] = dir
+
+    editor = "#{dir}/vemate"
+    FileUtils.touch editor
+    FileUtils.chmod 0755, editor
+
+    expect(which_editor).to eq("vemate -w")
+  end
+
+  describe "#pretty_duration" do
+    it "converts seconds to a human-readable string" do
+      expect(pretty_duration(1)).to eq("1 second")
+      expect(pretty_duration(2.5)).to eq("2 seconds")
+      expect(pretty_duration(42)).to eq("42 seconds")
+      expect(pretty_duration(240)).to eq("4 minutes")
+      expect(pretty_duration(252.45)).to eq("4 minutes 12 seconds")
+    end
+  end
+
+  specify "#disk_usage_readable" do
+    expect(disk_usage_readable(1)).to eq("1B")
+    expect(disk_usage_readable(1000)).to eq("1000B")
+    expect(disk_usage_readable(1024)).to eq("1KB")
+    expect(disk_usage_readable(1025)).to eq("1KB")
+    expect(disk_usage_readable(4_404_020)).to eq("4.2MB")
+    expect(disk_usage_readable(4_509_715_660)).to eq("4.2GB")
+  end
+
+  describe "#number_readable" do
+    it "returns a string with thousands separators" do
+      expect(number_readable(1)).to eq("1")
+      expect(number_readable(1_000)).to eq("1,000")
+      expect(number_readable(1_000_000)).to eq("1,000,000")
+    end
+  end
+
+  specify "#truncate_text_to_approximate_size" do
+    glue = "\n[...snip...]\n" # hard-coded copy from truncate_text_to_approximate_size
+    n = 20
+    long_s = "x" * 40
+
+    s = truncate_text_to_approximate_size(long_s, n)
+    expect(s.length).to eq(n)
+    expect(s).to match(/^x+#{Regexp.escape(glue)}x+$/)
+
+    s = truncate_text_to_approximate_size(long_s, n, front_weight: 0.0)
+    expect(s).to eq(glue + ("x" * (n - glue.length)))
+
+    s = truncate_text_to_approximate_size(long_s, n, front_weight: 1.0)
+    expect(s).to eq(("x" * (n - glue.length)) + glue)
+  end
+
+  describe "#odeprecated" do
+    it "raises a MethodDeprecatedError when `disable` is true" do
+      ENV.delete("HOMEBREW_DEVELOPER")
+      expect do
+        odeprecated(
+          "method", "replacement",
+          caller:  ["#{HOMEBREW_LIBRARY}/Taps/playbrew/homebrew-play/"],
+          disable: true
+        )
+      end.to raise_error(
+        MethodDeprecatedError,
+        %r{method.*replacement.*playbrew/homebrew-play.*/Taps/playbrew/homebrew-play/}m,
+      )
+    end
+  end
+
+  describe "#with_env" do
+    it "sets environment variables within the block" do
+      expect(ENV.fetch("PATH")).not_to eq("/bin")
+      with_env(PATH: "/bin") do
+        expect(ENV.fetch("PATH", nil)).to eq("/bin")
+      end
+    end
+
+    it "restores ENV after the block" do
+      with_env(PATH: "/bin") do
+        expect(ENV.fetch("PATH", nil)).to eq("/bin")
+      end
+      path = ENV.fetch("PATH", nil)
+      expect(path).not_to be_nil
+      expect(path).not_to eq("/bin")
+    end
+
+    it "restores ENV if an exception is raised" do
+      expect do
+        with_env(PATH: "/bin") do
+          raise StandardError, "boom"
+        end
+      end.to raise_error(StandardError)
+
+      path = ENV.fetch("PATH", nil)
+      expect(path).not_to be_nil
+      expect(path).not_to eq("/bin")
+    end
+  end
+
+  describe "#tap_and_name_comparison" do
+    describe "both strings are only names" do
+      it "alphabetizes the strings" do
+        expect(%w[a b].sort(&tap_and_name_comparison)).to eq(%w[a b])
+        expect(%w[b a].sort(&tap_and_name_comparison)).to eq(%w[a b])
+      end
+    end
+
+    describe "both strings include tap" do
+      it "alphabetizes the strings" do
+        expect(%w[a/z/z b/z/z].sort(&tap_and_name_comparison)).to eq(%w[a/z/z b/z/z])
+        expect(%w[b/z/z a/z/z].sort(&tap_and_name_comparison)).to eq(%w[a/z/z b/z/z])
+
+        expect(%w[z/a/z z/b/z].sort(&tap_and_name_comparison)).to eq(%w[z/a/z z/b/z])
+        expect(%w[z/b/z z/a/z].sort(&tap_and_name_comparison)).to eq(%w[z/a/z z/b/z])
+
+        expect(%w[z/z/a z/z/b].sort(&tap_and_name_comparison)).to eq(%w[z/z/a z/z/b])
+        expect(%w[z/z/b z/z/a].sort(&tap_and_name_comparison)).to eq(%w[z/z/a z/z/b])
+      end
+    end
+
+    describe "only one string includes tap" do
+      it "prefers the string without tap" do
+        expect(%w[a/z/z z].sort(&tap_and_name_comparison)).to eq(%w[z a/z/z])
+        expect(%w[z a/z/z].sort(&tap_and_name_comparison)).to eq(%w[z a/z/z])
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/test/formatter_spec.rb b/Library/Homebrew/test/formatter_spec.rb
index ddb8804e163b0..e02451a5945ab 100644
--- a/Library/Homebrew/test/formatter_spec.rb
+++ b/Library/Homebrew/test/formatter_spec.rb
@@ -1,21 +1,20 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/formatter"
 require "utils/tty"
 
-describe Formatter do
+RSpec.describe Formatter do
   describe "::columns" do
     subject(:columns) { described_class.columns(input) }
 
-    let(:input) {
+    let(:input) do
       %w[
         aa
         bbb
         ccc
         dd
       ]
-    }
+    end
 
     it "doesn't output columns if $stdout is not a TTY." do
       allow_any_instance_of(IO).to receive(:tty?).and_return(false)
diff --git a/Library/Homebrew/test/formula_auditor_spec.rb b/Library/Homebrew/test/formula_auditor_spec.rb
new file mode 100644
index 0000000000000..8b363aebd24e1
--- /dev/null
+++ b/Library/Homebrew/test/formula_auditor_spec.rb
@@ -0,0 +1,1346 @@
+# frozen_string_literal: true
+
+require "formula_auditor"
+
+RSpec.describe Homebrew::FormulaAuditor do
+  include FileUtils
+
+  let(:dir) { mktmpdir }
+  let(:foo_version) do
+    @count ||= 0
+    @count += 1
+  end
+  let(:formula_subpath) { "Formula/foo#{foo_version}.rb" }
+  let(:origin_tap_path) { HOMEBREW_TAP_DIRECTORY/"homebrew/homebrew-foo" }
+  let(:origin_formula_path) { origin_tap_path/formula_subpath }
+  let(:tap_path) { HOMEBREW_TAP_DIRECTORY/"homebrew/homebrew-bar" }
+  let(:formula_path) { tap_path/formula_subpath }
+
+  def formula_auditor(name, text, options = {})
+    path = Pathname.new "#{dir}/#{name}.rb"
+    path.open("w") do |f|
+      f.write text
+    end
+
+    formula = Formulary.factory(path)
+
+    if options.key? :tap_audit_exceptions
+      tap = Tap.fetch("test/tap")
+      allow(tap).to receive(:audit_exceptions).and_return(options[:tap_audit_exceptions])
+      allow(formula).to receive(:tap).and_return(tap)
+      options.delete :tap_audit_exceptions
+    end
+
+    described_class.new(formula, options)
+  end
+
+  def formula_gsub(before, after = "")
+    text = formula_path.read
+    text.gsub! before, after
+    formula_path.unlink
+    formula_path.write text
+  end
+
+  def formula_gsub_origin_commit(before, after = "")
+    text = origin_formula_path.read
+    text.gsub!(before, after)
+    origin_formula_path.unlink
+    origin_formula_path.write text
+
+    origin_tap_path.cd do
+      system "git", "commit", "-am", "commit"
+    end
+
+    tap_path.cd do
+      system "git", "fetch"
+      system "git", "reset", "--hard", "origin/HEAD"
+    end
+  end
+
+  describe "#problems" do
+    it "is empty by default" do
+      fa = formula_auditor "foo", <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+        end
+      RUBY
+
+      expect(fa.problems).to be_empty
+    end
+  end
+
+  describe "#audit_license" do
+    let(:spdx_license_data) { SPDX.license_data }
+    let(:spdx_exception_data) { SPDX.exception_data }
+
+    let(:deprecated_spdx_id) { "GPL-1.0" }
+    let(:license_all_custom_id) { 'all_of: ["MIT", "zzz"]' }
+    let(:deprecated_spdx_exception) { "Nokia-Qt-exception-1.1" }
+    let(:license_any) { 'any_of: ["0BSD", "GPL-3.0-only"]' }
+    let(:license_any_with_plus) { 'any_of: ["0BSD+", "GPL-3.0-only"]' }
+    let(:license_nested_conditions) { 'any_of: ["0BSD", { all_of: ["GPL-3.0-only", "MIT"] }]' }
+    let(:license_any_mismatch) { 'any_of: ["0BSD", "MIT"]' }
+    let(:license_any_nonstandard) { 'any_of: ["0BSD", "zzz", "MIT"]' }
+    let(:license_any_deprecated) { 'any_of: ["0BSD", "GPL-1.0", "MIT"]' }
+
+    it "does not check if the formula is not a new formula" do
+      fa = formula_auditor "foo", <<~RUBY, new_formula: false
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "detects no license info" do
+      fa = formula_auditor "foo", <<~RUBY, spdx_license_data:, new_formula: true, core_tap: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems.first[:message]).to match "Formulae in homebrew/core must specify a license."
+    end
+
+    it "detects if license is not a standard spdx-id" do
+      fa = formula_auditor "foo", <<~RUBY, spdx_license_data:, new_formula: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          license "zzz"
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems.first[:message]).to match <<~EOS
+        Formula foo contains non-standard SPDX licenses: ["zzz"].
+        For a list of valid licenses check: https://spdx.org/licenses/
+      EOS
+    end
+
+    it "detects if license is a deprecated spdx-id" do
+      fa = formula_auditor "foo", <<~RUBY, spdx_license_data:, new_formula: true, strict: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          license "#{deprecated_spdx_id}"
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems.first[:message]).to eq <<~EOS
+        Formula foo contains deprecated SPDX licenses: ["GPL-1.0"].
+        You may need to add `-only` or `-or-later` for GNU licenses (e.g. `GPL`, `LGPL`, `AGPL`, `GFDL`).
+        For a list of valid licenses check: https://spdx.org/licenses/
+      EOS
+    end
+
+    it "detects if license with AND contains a non-standard spdx-id" do
+      fa = formula_auditor "foo", <<~RUBY, spdx_license_data:, new_formula: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          license #{license_all_custom_id}
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems.first[:message]).to match <<~EOS
+        Formula foo contains non-standard SPDX licenses: ["zzz"].
+        For a list of valid licenses check: https://spdx.org/licenses/
+      EOS
+    end
+
+    it "detects if license array contains a non-standard spdx-id" do
+      fa = formula_auditor "foo", <<~RUBY, spdx_license_data:, new_formula: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          license #{license_any_nonstandard}
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems.first[:message]).to match <<~EOS
+        Formula foo contains non-standard SPDX licenses: ["zzz"].
+        For a list of valid licenses check: https://spdx.org/licenses/
+      EOS
+    end
+
+    it "detects if license array contains a deprecated spdx-id" do
+      fa = formula_auditor "foo", <<~RUBY, spdx_license_data:, new_formula: true, strict: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          license #{license_any_deprecated}
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems.first[:message]).to eq <<~EOS
+        Formula foo contains deprecated SPDX licenses: ["GPL-1.0"].
+        You may need to add `-only` or `-or-later` for GNU licenses (e.g. `GPL`, `LGPL`, `AGPL`, `GFDL`).
+        For a list of valid licenses check: https://spdx.org/licenses/
+      EOS
+    end
+
+    it "verifies that a license info is a standard spdx id" do
+      fa = formula_auditor "foo", <<~RUBY, spdx_license_data:, new_formula: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          license "0BSD"
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "verifies that a license info with plus is a standard spdx id" do
+      fa = formula_auditor "foo", <<~RUBY, spdx_license_data:, new_formula: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          license "0BSD+"
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "allows :public_domain license" do
+      fa = formula_auditor "foo", <<~RUBY, spdx_license_data:, new_formula: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          license :public_domain
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "verifies that a license info with multiple licenses are standard spdx ids" do
+      fa = formula_auditor "foo", <<~RUBY, spdx_license_data:, new_formula: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          license any_of: ["0BSD", "MIT"]
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "verifies that a license info with exceptions are standard spdx ids" do
+      formula_text = <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          license "Apache-2.0" => { with: "LLVM-exception" }
+        end
+      RUBY
+      fa = formula_auditor("foo", formula_text, new_formula: true,
+                           spdx_license_data:, spdx_exception_data:)
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "verifies that a license array contains only standard spdx id" do
+      fa = formula_auditor "foo", <<~RUBY, spdx_license_data:, new_formula: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          license #{license_any}
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "verifies that a license array contains only standard spdx id with plus" do
+      fa = formula_auditor "foo", <<~RUBY, spdx_license_data:, new_formula: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          license #{license_any_with_plus}
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "verifies that a license array with AND contains only standard spdx ids" do
+      fa = formula_auditor "foo", <<~RUBY, spdx_license_data:, new_formula: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          license #{license_nested_conditions}
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "checks online and verifies that a standard license id is the same " \
+       "as what is indicated on its GitHub repo", :needs_network do
+      formula_text = <<~RUBY
+        class Cask < Formula
+          url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
+          head "https://github.com/cask/cask.git"
+          license "GPL-3.0-or-later"
+        end
+      RUBY
+      fa = formula_auditor "cask", formula_text, spdx_license_data:,
+                           online: true, core_tap: true, new_formula: true
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "checks online and verifies that a standard license id with AND is the same " \
+       "as what is indicated on its GitHub repo", :needs_network do
+      formula_text = <<~RUBY
+        class Cask < Formula
+          url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
+          head "https://github.com/cask/cask.git"
+          license all_of: ["GPL-3.0-or-later", "MIT"]
+        end
+      RUBY
+      fa = formula_auditor "cask", formula_text, spdx_license_data:,
+                           online: true, core_tap: true, new_formula: true
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "checks online and verifies that a standard license id with WITH is the same " \
+       "as what is indicated on its GitHub repo", :needs_network do
+      formula_text = <<~RUBY
+        class Cask < Formula
+          url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
+          head "https://github.com/cask/cask.git"
+          license "GPL-3.0-or-later" => { with: "LLVM-exception" }
+        end
+      RUBY
+      fa = formula_auditor("cask", formula_text, online: true, core_tap: true, new_formula: true,
+                           spdx_license_data:, spdx_exception_data:)
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "verifies that a license exception has standard spdx ids", :needs_network do
+      formula_text = <<~RUBY
+        class Cask < Formula
+          url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
+          head "https://github.com/cask/cask.git"
+          license "GPL-3.0-or-later" => { with: "zzz" }
+        end
+      RUBY
+      fa = formula_auditor("cask", formula_text, core_tap: true, new_formula: true,
+                           spdx_license_data:, spdx_exception_data:)
+
+      fa.audit_license
+      expect(fa.problems.first[:message]).to match <<~EOS
+        Formula cask contains invalid or deprecated SPDX license exceptions: ["zzz"].
+        For a list of valid license exceptions check:
+          https://spdx.org/licenses/exceptions-index.html
+      EOS
+    end
+
+    it "verifies that a license exception has non-deprecated spdx ids", :needs_network do
+      formula_text = <<~RUBY
+        class Cask < Formula
+          url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
+          head "https://github.com/cask/cask.git"
+          license "GPL-3.0-or-later" => { with: "#{deprecated_spdx_exception}" }
+        end
+      RUBY
+      fa = formula_auditor("cask", formula_text, core_tap: true, new_formula: true,
+                           spdx_license_data:, spdx_exception_data:)
+
+      fa.audit_license
+      expect(fa.problems.first[:message]).to match <<~EOS
+        Formula cask contains invalid or deprecated SPDX license exceptions: ["#{deprecated_spdx_exception}"].
+        For a list of valid license exceptions check:
+          https://spdx.org/licenses/exceptions-index.html
+      EOS
+    end
+
+    it "checks online and verifies that a standard license id is in the same exempted license group " \
+       "as what is indicated on its GitHub repo", :needs_network do
+      fa = formula_auditor "cask", <<~RUBY, spdx_license_data:, online: true, new_formula: true
+        class Cask < Formula
+          url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
+          head "https://github.com/cask/cask.git"
+          license "GPL-3.0-or-later"
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "checks online and verifies that a standard license array is in the same exempted license group " \
+       "as what is indicated on its GitHub repo", :needs_network do
+      fa = formula_auditor "cask", <<~RUBY, spdx_license_data:, online: true, new_formula: true
+        class Cask < Formula
+          url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
+          head "https://github.com/cask/cask.git"
+          license any_of: ["GPL-3.0-or-later", "MIT"]
+        end
+      RUBY
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "checks online and detects that a formula-specified license is not " \
+       "the same as what is indicated on its GitHub repository", :needs_network do
+      formula_text = <<~RUBY
+        class Cask < Formula
+          url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
+          head "https://github.com/cask/cask.git"
+          license "0BSD"
+        end
+      RUBY
+      fa = formula_auditor "cask", formula_text, spdx_license_data:,
+                           online: true, core_tap: true, new_formula: true
+
+      fa.audit_license
+      expect(fa.problems.first[:message])
+        .to eq 'Formula license ["0BSD"] does not match GitHub license ["GPL-3.0"].'
+    end
+
+    it "allows a formula-specified license that differs from its GitHub " \
+       "repository for formulae on the mismatched license allowlist", :needs_network do
+      formula_text = <<~RUBY
+        class Cask < Formula
+          url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
+          head "https://github.com/cask/cask.git"
+          license "0BSD"
+        end
+      RUBY
+      fa = formula_auditor "cask", formula_text, spdx_license_data:,
+                           online: true, core_tap: true, new_formula: true,
+                           tap_audit_exceptions: { permitted_formula_license_mismatches: ["cask"] }
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+
+    it "checks online and detects that an array of license does not contain " \
+       "what is indicated on its GitHub repository", :needs_network do
+      formula_text = <<~RUBY
+        class Cask < Formula
+          url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
+          head "https://github.com/cask/cask.git"
+          license #{license_any_mismatch}
+        end
+      RUBY
+      fa = formula_auditor "cask", formula_text, spdx_license_data:,
+                           online: true, core_tap: true, new_formula: true
+
+      fa.audit_license
+      expect(fa.problems.first[:message]).to match "Formula license [\"0BSD\", \"MIT\"] " \
+                                                   "does not match GitHub license [\"GPL-3.0\"]."
+    end
+
+    it "checks online and verifies that an array of license contains " \
+       "what is indicated on its GitHub repository", :needs_network do
+      formula_text = <<~RUBY
+        class Cask < Formula
+          url "https://github.com/cask/cask/archive/v0.8.4.tar.gz"
+          head "https://github.com/cask/cask.git"
+          license #{license_any}
+        end
+      RUBY
+      fa = formula_auditor "cask", formula_text, spdx_license_data:,
+                           online: true, core_tap: true, new_formula: true
+
+      fa.audit_license
+      expect(fa.problems).to be_empty
+    end
+  end
+
+  describe "#audit_file" do
+    specify "no issue" do
+      fa = formula_auditor "foo", <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+        end
+      RUBY
+
+      fa.audit_file
+      expect(fa.problems).to be_empty
+    end
+  end
+
+  describe "#audit_name" do
+    specify "no issue" do
+      fa = formula_auditor "foo", <<~RUBY, core_tap: true, strict: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+        end
+      RUBY
+
+      fa.audit_name
+      expect(fa.problems).to be_empty
+    end
+
+    specify "uppercase formula name" do
+      fa = formula_auditor "Foo", <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/Foo-1.0.tgz"
+          homepage "https://brew.sh"
+        end
+      RUBY
+
+      fa.audit_name
+      expect(fa.problems.first[:message]).to match "must not contain uppercase letters"
+    end
+  end
+
+  describe "#audit_resource_name_matches_pypi_package_name_in_url" do
+    it "reports a problem if the resource name does not match the python sdist name" do
+      fa = formula_auditor "foo", <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          sha256 "abc123"
+          homepage "https://brew.sh"
+
+          resource "Something" do
+            url "https://files.pythonhosted.org/packages/FooSomething-1.0.0.tar.gz"
+            sha256 "def456"
+          end
+        end
+      RUBY
+
+      fa.audit_specs
+      expect(fa.problems.first[:message])
+        .to match("resource name should be `FooSomething` to match the PyPI package name")
+    end
+
+    it "reports a problem if the resource name does not match the python wheel name" do
+      fa = formula_auditor "foo", <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          sha256 "abc123"
+          homepage "https://brew.sh"
+
+          resource "Something" do
+            url "https://files.pythonhosted.org/packages/FooSomething-1.0.0-py3-none-any.whl"
+            sha256 "def456"
+          end
+        end
+      RUBY
+
+      fa.audit_specs
+      expect(fa.problems.first[:message])
+        .to match("resource name should be `FooSomething` to match the PyPI package name")
+    end
+  end
+
+  describe "#check_service_command" do
+    specify "Not installed" do
+      fa = formula_auditor "foo", <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+
+          service do
+            run []
+          end
+        end
+      RUBY
+
+      expect(fa.check_service_command(fa.formula)).to match nil
+    end
+
+    specify "No service" do
+      fa = formula_auditor "foo", <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+        end
+      RUBY
+
+      mkdir_p fa.formula.prefix
+      expect(fa.check_service_command(fa.formula)).to match nil
+    end
+
+    specify "No command" do
+      fa = formula_auditor "foo", <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+
+          service do
+            run []
+          end
+        end
+      RUBY
+
+      mkdir_p fa.formula.prefix
+      expect(fa.check_service_command(fa.formula)).to match nil
+    end
+
+    specify "Invalid command" do
+      fa = formula_auditor "foo", <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+
+          service do
+            run [HOMEBREW_PREFIX/"bin/something"]
+          end
+        end
+      RUBY
+
+      mkdir_p fa.formula.prefix
+      expect(fa.check_service_command(fa.formula)).to match "Service command does not exist"
+    end
+  end
+
+  describe "#audit_github_repository" do
+    specify "#audit_github_repository when HOMEBREW_NO_GITHUB_API is set" do
+      ENV["HOMEBREW_NO_GITHUB_API"] = "1"
+
+      fa = formula_auditor "foo", <<~RUBY, strict: true, online: true
+        class Foo < Formula
+          homepage "https://github.com/example/example"
+          url "https://brew.sh/foo-1.0.tgz"
+        end
+      RUBY
+
+      fa.audit_github_repository
+      expect(fa.problems).to be_empty
+    end
+  end
+
+  describe "#audit_github_repository_archived" do
+    specify "#audit_github_repository_archived when HOMEBREW_NO_GITHUB_API is set" do
+      fa = formula_auditor "foo", <<~RUBY, strict: true, online: true
+        class Foo < Formula
+          homepage "https://github.com/example/example"
+          url "https://brew.sh/foo-1.0.tgz"
+        end
+      RUBY
+
+      fa.audit_github_repository_archived
+      expect(fa.problems).to be_empty
+    end
+  end
+
+  describe "#audit_gitlab_repository" do
+    specify "#audit_gitlab_repository for stars, forks and creation date" do
+      fa = formula_auditor "foo", <<~RUBY, strict: true, online: true
+        class Foo < Formula
+          homepage "https://gitlab.com/libtiff/libtiff"
+          url "https://brew.sh/foo-1.0.tgz"
+        end
+      RUBY
+
+      fa.audit_gitlab_repository
+      expect(fa.problems).to be_empty
+    end
+  end
+
+  describe "#audit_gitlab_repository_archived" do
+    specify "#audit gitlab repository for archived status" do
+      fa = formula_auditor "foo", <<~RUBY, strict: true, online: true
+        class Foo < Formula
+          homepage "https://gitlab.com/libtiff/libtiff"
+          url "https://brew.sh/foo-1.0.tgz"
+        end
+      RUBY
+
+      fa.audit_gitlab_repository_archived
+      expect(fa.problems).to be_empty
+    end
+  end
+
+  describe "#audit_bitbucket_repository" do
+    specify "#audit_bitbucket_repository for stars, forks and creation date" do
+      fa = formula_auditor "foo", <<~RUBY, strict: true, online: true
+        class Foo < Formula
+          homepage "https://bitbucket.com/libtiff/libtiff"
+          url "https://brew.sh/foo-1.0.tgz"
+        end
+      RUBY
+
+      fa.audit_bitbucket_repository
+      expect(fa.problems).to be_empty
+    end
+  end
+
+  describe "#audit_specs" do
+    let(:livecheck_throttle) { "livecheck do\n    throttle 10\n  end" }
+    let(:versioned_head_spec_list) { { versioned_head_spec_allowlist: ["foo"] } }
+
+    it "doesn't allow to miss a checksum" do
+      fa = formula_auditor "foo", <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+        end
+      RUBY
+
+      fa.audit_specs
+      expect(fa.problems.first[:message]).to match "Checksum is missing"
+    end
+
+    it "allows to miss a checksum for git strategy" do
+      fa = formula_auditor "foo", <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/foo.git", tag: "1.0", revision: "f5e00e485e7aa4c5baa20355b27e3b84a6912790"
+        end
+      RUBY
+
+      fa.audit_specs
+      expect(fa.problems).to be_empty
+    end
+
+    it "allows to miss a checksum for HEAD" do
+      fa = formula_auditor "foo", <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
+          head "https://brew.sh/foo.tgz"
+        end
+      RUBY
+
+      fa.audit_specs
+      expect(fa.problems).to be_empty
+    end
+
+    it "allows versions with no throttle rate" do
+      fa = formula_auditor "bar", <<~RUBY, core_tap: true
+        class Bar < Formula
+          url "https://brew.sh/foo-1.0.1.tgz"
+          sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
+        end
+      RUBY
+
+      fa.audit_specs
+      expect(fa.problems).to be_empty
+    end
+
+    it "allows major/minor versions with throttle rate" do
+      fa = formula_auditor "foo", <<~RUBY, core_tap: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.0.tgz"
+          sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
+          #{livecheck_throttle}
+        end
+      RUBY
+
+      fa.audit_specs
+      expect(fa.problems).to be_empty
+    end
+
+    it "allows patch versions to be multiples of the throttle rate" do
+      fa = formula_auditor "foo", <<~RUBY, core_tap: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.10.tgz"
+          sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
+          #{livecheck_throttle}
+        end
+      RUBY
+
+      fa.audit_specs
+      expect(fa.problems).to be_empty
+    end
+
+    it "doesn't allow patch versions that aren't multiples of the throttle rate" do
+      fa = formula_auditor "foo", <<~RUBY, core_tap: true
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.1.tgz"
+          sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
+          #{livecheck_throttle}
+        end
+      RUBY
+
+      fa.audit_specs
+      expect(fa.problems.first[:message]).to match "should only be updated every 10 releases on multiples of 10"
+    end
+
+    it "allows non-versioned formulae to have a `HEAD` spec" do
+      fa = formula_auditor "bar", <<~RUBY, core_tap: true, tap_audit_exceptions: versioned_head_spec_list
+        class Bar < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
+          head "https://brew.sh/foo.git"
+        end
+      RUBY
+
+      fa.audit_specs
+      expect(fa.problems).to be_empty
+    end
+
+    it "doesn't allow versioned formulae to have a `HEAD` spec" do
+      fa = formula_auditor "bar@1", <<~RUBY, core_tap: true, tap_audit_exceptions: versioned_head_spec_list
+        class BarAT1 < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
+          head "https://brew.sh/foo.git"
+        end
+      RUBY
+
+      fa.audit_specs
+      expect(fa.problems.first[:message]).to match "Versioned formulae should not have a `HEAD` spec"
+    end
+
+    it "allows versioned formulae on the allowlist to have a `HEAD` spec" do
+      fa = formula_auditor "foo", <<~RUBY, core_tap: true, tap_audit_exceptions: versioned_head_spec_list
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
+          head "https://brew.sh/foo.git"
+        end
+      RUBY
+
+      fa.audit_specs
+      expect(fa.problems).to be_empty
+    end
+  end
+
+  describe "#audit_deps" do
+    describe "a dependency on a macOS-provided keg-only formula" do
+      describe "which is allowlisted" do
+        subject(:f_a) { fa }
+
+        let(:fa) do
+          formula_auditor "foo", <<~RUBY, new_formula: true
+            class Foo < Formula
+              url "https://brew.sh/foo-1.0.tgz"
+              homepage "https://brew.sh"
+
+              depends_on "openssl"
+            end
+          RUBY
+        end
+
+        let(:f_openssl) do
+          formula do
+            url "https://brew.sh/openssl-1.0.tgz"
+            homepage "https://brew.sh"
+
+            keg_only :provided_by_macos
+          end
+        end
+
+        before do
+          allow(fa.formula.deps.first)
+            .to receive(:to_formula).and_return(f_openssl)
+          fa.audit_deps
+        end
+
+        it(:problems) { expect(f_a.problems).to be_empty }
+      end
+
+      describe "which is not allowlisted", :needs_macos do
+        subject(:f_a) { fa }
+
+        let(:fa) do
+          formula_auditor "foo", <<~RUBY, new_formula: true, core_tap: true
+            class Foo < Formula
+              url "https://brew.sh/foo-1.0.tgz"
+              homepage "https://brew.sh"
+
+              depends_on "bc"
+            end
+          RUBY
+        end
+
+        let(:f_bc) do
+          formula do
+            url "https://brew.sh/bc-1.0.tgz"
+            homepage "https://brew.sh"
+
+            keg_only :provided_by_macos
+          end
+        end
+
+        before do
+          allow(fa.formula.deps.first)
+            .to receive(:to_formula).and_return(f_bc)
+          fa.audit_deps
+        end
+
+        it(:new_formula_problems) do
+          expect(f_a.new_formula_problems)
+            .to include(a_hash_including(message: a_string_matching(/is provided by macOS/)))
+        end
+      end
+    end
+  end
+
+  describe "#audit_stable_version" do
+    subject do
+      fa = described_class.new(Formulary.factory(formula_path), git: true)
+      fa.audit_stable_version
+      fa.problems.first&.fetch(:message)
+    end
+
+    before do
+      origin_formula_path.dirname.mkpath
+      origin_formula_path.write <<~RUBY
+        class Foo#{foo_version} < Formula
+          url "https://brew.sh/foo-1.0.tar.gz"
+          sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
+          revision 2
+          version_scheme 1
+        end
+      RUBY
+
+      origin_tap_path.mkpath
+      origin_tap_path.cd do
+        system "git", "init"
+        system "git", "add", "--all"
+        system "git", "commit", "-m", "init"
+      end
+
+      tap_path.mkpath
+      tap_path.cd do
+        system "git", "clone", origin_tap_path, "."
+      end
+    end
+
+    describe "versions" do
+      context "when uncommitted should not decrease" do
+        before { formula_gsub "foo-1.0.tar.gz", "foo-0.9.tar.gz" }
+
+        it { is_expected.to match("stable version should not decrease (from 1.0 to 0.9)") }
+      end
+
+      context "when committed can decrease" do
+        before do
+          formula_gsub_origin_commit "revision 2"
+          formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-0.9.tar.gz"
+        end
+
+        it { is_expected.to be_nil }
+      end
+
+      describe "can decrease with version_scheme increased" do
+        before do
+          formula_gsub "revision 2"
+          formula_gsub "foo-1.0.tar.gz", "foo-0.9.tar.gz"
+          formula_gsub "version_scheme 1", "version_scheme 2"
+        end
+
+        it { is_expected.to be_nil }
+      end
+    end
+  end
+
+  describe "#audit_revision" do
+    subject do
+      fa = described_class.new(Formulary.factory(formula_path), git: true)
+      fa.audit_revision
+      fa.problems.first&.fetch(:message)
+    end
+
+    before do
+      origin_formula_path.dirname.mkpath
+      origin_formula_path.write <<~RUBY
+        class Foo#{foo_version} < Formula
+          url "https://brew.sh/foo-1.0.tar.gz"
+          sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
+          revision 2
+          version_scheme 1
+        end
+      RUBY
+
+      origin_tap_path.mkpath
+      origin_tap_path.cd do
+        system "git", "init"
+        system "git", "add", "--all"
+        system "git", "commit", "-m", "init"
+      end
+
+      tap_path.mkpath
+      tap_path.cd do
+        system "git", "clone", origin_tap_path, "."
+      end
+    end
+
+    describe "new formulae should not have a revision" do
+      it "doesn't allow new formulae to have a revision" do
+        fa = formula_auditor "foo", <<~RUBY, new_formula: true
+          class Foo < Formula
+            url "https://brew.sh/foo-1.0.tgz"
+            revision 1
+          end
+        RUBY
+
+        fa.audit_revision
+
+        expect(fa.new_formula_problems).to include(
+          a_hash_including(message: a_string_matching(/should not define a revision/)),
+        )
+      end
+    end
+
+    describe "revisions" do
+      describe "should not be removed when first committed above 0" do
+        it { is_expected.to be_nil }
+      end
+
+      describe "with the same version, should not decrease" do
+        before { formula_gsub_origin_commit "revision 2", "revision 1" }
+
+        it { is_expected.to match("revision should not decrease (from 2 to 1)") }
+      end
+
+      describe "should not be removed with the same version" do
+        before { formula_gsub_origin_commit "revision 2" }
+
+        it { is_expected.to match("revision should not decrease (from 2 to 0)") }
+      end
+
+      describe "should not decrease with the same, uncommitted version" do
+        before { formula_gsub "revision 2", "revision 1" }
+
+        it { is_expected.to match("revision should not decrease (from 2 to 1)") }
+      end
+
+      describe "should be removed with a newer version" do
+        before { formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-1.1.tar.gz" }
+
+        it { is_expected.to match("'revision 2' should be removed") }
+      end
+
+      describe "should be removed with a newer local version" do
+        before { formula_gsub "foo-1.0.tar.gz", "foo-1.1.tar.gz" }
+
+        it { is_expected.to match("'revision 2' should be removed") }
+      end
+
+      describe "should not warn on an newer version revision removal" do
+        before do
+          formula_gsub_origin_commit "revision 2", ""
+          formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-1.1.tar.gz"
+        end
+
+        it { is_expected.to be_nil }
+      end
+
+      describe "should not warn when revision from previous version matches current revision" do
+        before do
+          formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-1.1.tar.gz"
+          formula_gsub_origin_commit "revision 2", "# no revision"
+          formula_gsub_origin_commit "# no revision", "revision 1"
+          formula_gsub_origin_commit "revision 1", "revision 2"
+        end
+
+        it { is_expected.to be_nil }
+      end
+
+      describe "should only increment by 1 with an uncommitted version" do
+        before do
+          formula_gsub "foo-1.0.tar.gz", "foo-1.1.tar.gz"
+          formula_gsub "revision 2", "revision 4"
+        end
+
+        it { is_expected.to match("revisions should only increment by 1") }
+      end
+
+      describe "should not warn on past increment by more than 1" do
+        before do
+          formula_gsub_origin_commit "revision 2", "# no revision"
+          formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-1.1.tar.gz"
+          formula_gsub_origin_commit "# no revision", "revision 3"
+        end
+
+        it { is_expected.to be_nil }
+      end
+    end
+  end
+
+  describe "#audit_version_scheme" do
+    subject do
+      fa = described_class.new(Formulary.factory(formula_path), git: true)
+      fa.audit_version_scheme
+      fa.problems.first&.fetch(:message)
+    end
+
+    before do
+      origin_formula_path.dirname.mkpath
+      origin_formula_path.write <<~RUBY
+        class Foo#{foo_version} < Formula
+          url "https://brew.sh/foo-1.0.tar.gz"
+          sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
+          revision 2
+          version_scheme 1
+        end
+      RUBY
+
+      origin_tap_path.mkpath
+      origin_tap_path.cd do
+        system "git", "init"
+        system "git", "add", "--all"
+        system "git", "commit", "-m", "init"
+      end
+
+      tap_path.mkpath
+      tap_path.cd do
+        system "git", "clone", origin_tap_path, "."
+      end
+    end
+
+    describe "version_schemes" do
+      describe "should not decrease with the same version" do
+        before { formula_gsub_origin_commit "version_scheme 1" }
+
+        it { is_expected.to match("version_scheme should not decrease (from 1 to 0)") }
+      end
+
+      describe "should not decrease with a new version" do
+        before do
+          formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-1.1.tar.gz"
+          formula_gsub_origin_commit "revision 2", ""
+          formula_gsub_origin_commit "version_scheme 1", ""
+        end
+
+        it { is_expected.to match("version_scheme should not decrease (from 1 to 0)") }
+      end
+
+      describe "should only increment by 1" do
+        before do
+          formula_gsub_origin_commit "version_scheme 1", "# no version_scheme"
+          formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-1.1.tar.gz"
+          formula_gsub_origin_commit "revision 2", ""
+          formula_gsub_origin_commit "# no version_scheme", "version_scheme 3"
+        end
+
+        it { is_expected.to match("version_schemes should only increment by 1") }
+      end
+    end
+  end
+
+  describe "#audit_unconfirmed_checksum_change" do
+    subject do
+      fa = described_class.new(Formulary.factory(formula_path), git: true)
+      fa.audit_unconfirmed_checksum_change
+      fa.problems.first&.fetch(:message)
+    end
+
+    before do
+      origin_formula_path.dirname.mkpath
+      origin_formula_path.write <<~RUBY
+        class Foo#{foo_version} < Formula
+          url "https://brew.sh/foo-1.0.tar.gz"
+          sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"
+          revision 2
+          version_scheme 1
+        end
+      RUBY
+
+      origin_tap_path.mkpath
+      origin_tap_path.cd do
+        system "git", "init"
+        system "git", "add", "--all"
+        system "git", "commit", "-m", "init"
+      end
+
+      tap_path.mkpath
+      tap_path.cd do
+        system "git", "clone", origin_tap_path, "."
+      end
+    end
+
+    describe "checksums" do
+      describe "should not change with the same version" do
+        before do
+          formula_gsub(
+            'sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"',
+            'sha256 "3622d2a53236ed9ca62de0616a7e80fd477a9a3f862ba09d503da188f53ca523"',
+          )
+        end
+
+        it { is_expected.to match("stable sha256 changed without the url/version also changing") }
+      end
+
+      describe "should not change with the same version when not the first commit" do
+        before do
+          formula_gsub_origin_commit(
+            'sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"',
+            'sha256 "3622d2a53236ed9ca62de0616a7e80fd477a9a3f862ba09d503da188f53ca523"',
+          )
+          formula_gsub_origin_commit "revision 2"
+          formula_gsub_origin_commit "foo-1.0.tar.gz", "foo-1.1.tar.gz"
+          formula_gsub(
+            'sha256 "3622d2a53236ed9ca62de0616a7e80fd477a9a3f862ba09d503da188f53ca523"',
+            'sha256 "e048c5e6144f5932d8672c2fade81d9073d5b3ca1517b84df006de3d25414fc1"',
+          )
+        end
+
+        it { is_expected.to match("stable sha256 changed without the url/version also changing") }
+      end
+
+      describe "can change with the different version" do
+        before do
+          formula_gsub_origin_commit(
+            'sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"',
+            'sha256 "3622d2a53236ed9ca62de0616a7e80fd477a9a3f862ba09d503da188f53ca523"',
+          )
+          formula_gsub "foo-1.0.tar.gz", "foo-1.1.tar.gz"
+          formula_gsub_origin_commit(
+            'sha256 "3622d2a53236ed9ca62de0616a7e80fd477a9a3f862ba09d503da188f53ca523"',
+            'sha256 "e048c5e6144f5932d8672c2fade81d9073d5b3ca1517b84df006de3d25414fc1"',
+          )
+        end
+
+        it { is_expected.to be_nil }
+      end
+
+      describe "can be removed when switching schemes" do
+        before do
+          formula_gsub_origin_commit(
+            'url "https://brew.sh/foo-1.0.tar.gz"',
+            'url "https://foo.com/brew/bar.git", tag: "1.0", revision: "f5e00e485e7aa4c5baa20355b27e3b84a6912790"',
+          )
+          formula_gsub_origin_commit('sha256 "31cccfc6630528db1c8e3a06f6decf2a370060b982841cfab2b8677400a5092e"',
+                                     "")
+        end
+
+        it { is_expected.to be_nil }
+      end
+    end
+  end
+
+  describe "#audit_versioned_keg_only" do
+    specify "it warns when a versioned formula is not `keg_only`" do
+      fa = formula_auditor "foo@1.1", <<~RUBY, core_tap: true
+        class FooAT11 < Formula
+          url "https://brew.sh/foo-1.1.tgz"
+        end
+      RUBY
+
+      fa.audit_versioned_keg_only
+
+      expect(fa.problems.first[:message])
+        .to match("Versioned formulae in homebrew/core should use `keg_only :versioned_formula`")
+    end
+
+    specify "it warns when a versioned formula has an incorrect `keg_only` reason" do
+      fa = formula_auditor "foo@1.1", <<~RUBY, core_tap: true
+        class FooAT11 < Formula
+          url "https://brew.sh/foo-1.1.tgz"
+
+          keg_only :provided_by_macos
+        end
+      RUBY
+
+      fa.audit_versioned_keg_only
+
+      expect(fa.problems.first[:message])
+        .to match("Versioned formulae in homebrew/core should use `keg_only :versioned_formula`")
+    end
+
+    specify "it does not warn when a versioned formula has `keg_only :versioned_formula`" do
+      fa = formula_auditor "foo@1.1", <<~RUBY, core_tap: true
+        class FooAT11 < Formula
+          url "https://brew.sh/foo-1.1.tgz"
+
+          keg_only :versioned_formula
+        end
+      RUBY
+
+      fa.audit_versioned_keg_only
+
+      expect(fa.problems).to be_empty
+    end
+  end
+
+  describe "#audit_conflicts" do
+    before do
+      # We don't really test the formula text retrieval here
+      allow(File).to receive(:open).and_return("")
+    end
+
+    specify "it warns when conflicting with non-existing formula" do
+      foo = formula("foo") do
+        url "https://brew.sh/bar-1.0.tgz"
+
+        conflicts_with "bar"
+      end
+
+      fa = described_class.new foo
+      fa.audit_conflicts
+
+      expect(fa.problems.first[:message])
+        .to match("Can't find conflicting formula \"bar\"")
+    end
+
+    specify "it warns when conflicting with itself" do
+      foo = formula("foo") do
+        url "https://brew.sh/bar-1.0.tgz"
+
+        conflicts_with "foo"
+      end
+      stub_formula_loader foo
+
+      fa = described_class.new foo
+      fa.audit_conflicts
+
+      expect(fa.problems.first[:message])
+        .to match("Formula should not conflict with itself")
+    end
+
+    specify "it warns when another formula does not have a symmetric conflict" do
+      stub_formula_loader formula("gcc") { url "gcc-1.0" }
+      stub_formula_loader formula("glibc") { url "glibc-1.0" }
+
+      foo = formula("foo") do
+        url "https://brew.sh/foo-1.0.tgz"
+      end
+      stub_formula_loader foo
+
+      bar = formula("bar") do
+        url "https://brew.sh/bar-1.0.tgz"
+
+        conflicts_with "foo"
+      end
+
+      fa = described_class.new bar
+      fa.audit_conflicts
+
+      expect(fa.problems.first[:message])
+        .to match("Formula foo should also have a conflict declared with bar")
+    end
+  end
+
+  describe "#audit_deprecate_disable" do
+    specify "it warns when deprecate/disable reason is invalid" do
+      fa = formula_auditor "foo", <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+
+        deprecate! date: "2021-01-01", because: :foobar
+        end
+      RUBY
+
+      mkdir_p fa.formula.prefix
+      fa.audit_deprecate_disable
+      expect(fa.problems.first[:message])
+        .to match("foobar is not a valid deprecate! or disable! reason")
+    end
+
+    specify "it does not warn when deprecate/disable reason is valid" do
+      fa = formula_auditor "foo", <<~RUBY
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+
+        deprecate! date: "2021-01-01", because: :repo_archived
+        end
+      RUBY
+
+      mkdir_p fa.formula.prefix
+      fa.audit_deprecate_disable
+      expect(fa.problems).to be_empty
+    end
+  end
+end
diff --git a/Library/Homebrew/test/formula_creator_spec.rb b/Library/Homebrew/test/formula_creator_spec.rb
new file mode 100644
index 0000000000000..a70868640636a
--- /dev/null
+++ b/Library/Homebrew/test/formula_creator_spec.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "formula_creator"
+
+RSpec.describe Homebrew::FormulaCreator do
+  it "gets name from GitHub archive URL" do
+    t = described_class.name_from_url("https://github.com/abitrolly/lapce/archive/v0.3.0.tar.gz")
+    expect(t).to eq("lapce")
+  end
+
+  it "gets name from gitweb URL" do
+    t = described_class.name_from_url("http://www.codesrc.com/gitweb/index.cgi?p=libzipper.git;a=summary")
+    expect(t).to eq("libzipper")
+  end
+
+  it "gets name from GitHub repo URL" do
+    t = described_class.name_from_url("https://github.com/abitrolly/lapce.git")
+    expect(t).to eq("lapce")
+  end
+
+  it "gets name from GitHub download URL" do
+    t = described_class.name_from_url("https://github.com/stella-emu/stella/releases/download/6.7/stella-6.7-src.tar.xz")
+    expect(t).to eq("stella")
+  end
+
+  it "gets name from generic tarball URL" do
+    t = described_class.name_from_url("http://digit-labs.org/files/tools/synscan/releases/synscan-5.02.tar.gz")
+    expect(t).to eq("synscan")
+  end
+end
diff --git a/Library/Homebrew/test/formula_free_port_spec.rb b/Library/Homebrew/test/formula_free_port_spec.rb
deleted file mode 100644
index 84412d61d51cf..0000000000000
--- a/Library/Homebrew/test/formula_free_port_spec.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "socket"
-require "formula_free_port"
-
-module Homebrew
-  describe FreePort do
-    include described_class
-
-    describe "#free_port" do
-      # IANA suggests user port from 1024 to 49151
-      # and dynamic port for 49152 to 65535
-      # http://www.iana.org/assignments/port-numbers
-      MIN_PORT = 1024
-      MAX_PORT = 65535
-
-      it "returns a free TCP/IP port" do
-        port = free_port
-
-        expect(port).to be_between(MIN_PORT, MAX_PORT)
-        expect { TCPServer.new(port).close }.not_to raise_error
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/test/formula_info_spec.rb b/Library/Homebrew/test/formula_info_spec.rb
index c9c1c7a3664bb..e42620b669305 100644
--- a/Library/Homebrew/test/formula_info_spec.rb
+++ b/Library/Homebrew/test/formula_info_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula_info"
 
-describe FormulaInfo, :integration_test do
+RSpec.describe FormulaInfo, :integration_test do
   it "tests the FormulaInfo class" do
     install_test_formula "testball"
 
diff --git a/Library/Homebrew/test/formula_installer_bottle_spec.rb b/Library/Homebrew/test/formula_installer_bottle_spec.rb
index 143fc03dcfc84..0f4e4eee6afb7 100644
--- a/Library/Homebrew/test/formula_installer_bottle_spec.rb
+++ b/Library/Homebrew/test/formula_installer_bottle_spec.rb
@@ -1,4 +1,3 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula"
@@ -10,7 +9,7 @@
 require "test/support/fixtures/testball_bottle"
 require "test/support/fixtures/testball_bottle_cellar"
 
-describe FormulaInstaller do
+RSpec.describe FormulaInstaller do
   alias_matcher :pour_bottle, :be_pour_bottle
 
   matcher :be_poured_from_bottle do
@@ -22,9 +21,9 @@ def temporarily_install_bottle(formula)
     expect(formula).to be_bottled
     expect(formula).to pour_bottle
 
-    stub_formula_loader formula
     stub_formula_loader formula("gcc") { url "gcc-1.0" }
-    stub_formula_loader formula("gcc@5") { url "gcc-5.0" }
+    stub_formula_loader formula("glibc") { url "glibc-1.0" }
+    stub_formula_loader formula
 
     fi = FormulaInstaller.new(formula)
     fi.fetch
@@ -35,7 +34,7 @@ def temporarily_install_bottle(formula)
     expect(formula).to be_latest_version_installed
 
     begin
-      expect(Tab.for_keg(keg)).to be_poured_from_bottle
+      expect(keg.tab).to be_poured_from_bottle
 
       yield formula
     ensure
@@ -49,35 +48,38 @@ def temporarily_install_bottle(formula)
     expect(formula).not_to be_latest_version_installed
   end
 
-  def test_basic_formula_setup(f)
+  def test_basic_formula_setup(formula)
     # Test that things made it into the Keg
-    expect(f.bin).to be_a_directory
+    expect(formula.bin).to be_a_directory
 
-    expect(f.libexec).to be_a_directory
+    expect(formula.libexec).to be_a_directory
 
-    expect(f.prefix/"main.c").not_to exist
+    expect(formula.prefix/"main.c").not_to exist
 
     # Test that things made it into the Cellar
-    keg = Keg.new f.prefix
+    keg = Keg.new formula.prefix
     keg.link
 
     bin = HOMEBREW_PREFIX/"bin"
     expect(bin).to be_a_directory
 
-    expect(f.libexec).to be_a_directory
+    expect(formula.libexec).to be_a_directory
   end
 
+  # This test wraps expect() calls in `test_basic_formula_setup`
+  # rubocop:disable RSpec/NoExpectationExample
   specify "basic bottle install" do
     allow(DevelopmentTools).to receive(:installed?).and_return(false)
-    Homebrew.install_args.parse(["testball_bottle"])
+    Homebrew::Cmd::InstallCmd.new(["testball_bottle"])
     temporarily_install_bottle(TestballBottle.new) do |f|
       test_basic_formula_setup(f)
     end
   end
+  # rubocop:enable RSpec/NoExpectationExample
 
   specify "basic bottle install with cellar information on sha256 line" do
     allow(DevelopmentTools).to receive(:installed?).and_return(false)
-    Homebrew.install_args.parse(["testball_bottle_cellar"])
+    Homebrew::Cmd::InstallCmd.new(["testball_bottle_cellar"])
     temporarily_install_bottle(TestballBottleCellar.new) do |f|
       test_basic_formula_setup(f)
 
@@ -98,9 +100,9 @@ def test_basic_formula_setup(f)
     expect(formula).not_to be_latest_version_installed
     expect(formula).not_to be_bottled
 
-    expect {
+    expect do
       described_class.new(formula).install
-    }.to raise_error(UnbottledError)
+    end.to raise_error(UnbottledError)
 
     expect(formula).not_to be_latest_version_installed
   end
diff --git a/Library/Homebrew/test/formula_installer_spec.rb b/Library/Homebrew/test/formula_installer_spec.rb
index 497f727c9ce23..d0b079efcfa9b 100644
--- a/Library/Homebrew/test/formula_installer_spec.rb
+++ b/Library/Homebrew/test/formula_installer_spec.rb
@@ -1,16 +1,17 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula"
 require "formula_installer"
 require "keg"
+require "sandbox"
 require "tab"
 require "cmd/install"
 require "test/support/fixtures/testball"
 require "test/support/fixtures/testball_bottle"
 require "test/support/fixtures/failball"
+require "test/support/fixtures/failball_offline_install"
 
-describe FormulaInstaller do
+RSpec.describe FormulaInstaller do
   matcher :be_poured_from_bottle do
     match(&:poured_from_bottle)
   end
@@ -29,7 +30,7 @@ def temporary_install(formula, **options)
 
     begin
       Tab.clear_cache
-      expect(Tab.for_keg(keg)).not_to be_poured_from_bottle
+      expect(keg.tab).not_to be_poured_from_bottle
 
       yield formula if block_given?
     ensure
@@ -38,7 +39,7 @@ def temporary_install(formula, **options)
       keg.uninstall
       formula.clear_cache
       # there will be log files when sandbox is enable.
-      formula.logs.rmtree if formula.logs.directory?
+      FileUtils.rm_r(formula.logs) if formula.logs.directory?
     end
 
     expect(keg).not_to exist
@@ -71,6 +72,10 @@ def temporary_install(formula, **options)
     end
   end
 
+  specify "offline installation" do
+    expect { temporary_install(FailballOfflineInstall.new) }.to raise_error(BuildError) if Sandbox.available?
+  end
+
   specify "Formula is not poured from bottle when compiler specified" do
     temporary_install(TestballBottle.new, cc: "clang") do |f|
       tab = Tab.for_formula(f)
@@ -83,7 +88,7 @@ def temporary_install(formula, **options)
       ENV["HOMEBREW_DEVELOPER"] = "1"
 
       dep_name = "homebrew-test-cyclic"
-      dep_path = CoreTap.new.formula_dir/"#{dep_name}.rb"
+      dep_path = CoreTap.instance.new_formula_path(dep_name)
       dep_path.write <<~RUBY
         class #{Formulary.class_s(dep_name)} < Formula
           url "foo"
@@ -96,9 +101,9 @@ class #{Formulary.class_s(dep_name)} < Formula
 
       fi = described_class.new(f)
 
-      expect {
+      expect do
         fi.check_install_sanity
-      }.to raise_error(CannotInstallFormulaError)
+      end.to raise_error(CannotInstallFormulaError)
     end
 
     it "raises on indirect cyclic dependency" do
@@ -106,7 +111,7 @@ class #{Formulary.class_s(dep_name)} < Formula
 
       formula1_name = "homebrew-test-formula1"
       formula2_name = "homebrew-test-formula2"
-      formula1_path = CoreTap.new.formula_dir/"#{formula1_name}.rb"
+      formula1_path = CoreTap.instance.new_formula_path(formula1_name)
       formula1_path.write <<~RUBY
         class #{Formulary.class_s(formula1_name)} < Formula
           url "foo"
@@ -117,7 +122,7 @@ class #{Formulary.class_s(formula1_name)} < Formula
       Formulary.cache.delete(formula1_path)
       formula1 = Formulary.factory(formula1_name)
 
-      formula2_path = CoreTap.new.formula_dir/"#{formula2_name}.rb"
+      formula2_path = CoreTap.instance.new_formula_path(formula2_name)
       formula2_path.write <<~RUBY
         class #{Formulary.class_s(formula2_name)} < Formula
           url "foo"
@@ -129,14 +134,14 @@ class #{Formulary.class_s(formula2_name)} < Formula
 
       fi = described_class.new(formula1)
 
-      expect {
+      expect do
         fi.check_install_sanity
-      }.to raise_error(CannotInstallFormulaError)
+      end.to raise_error(CannotInstallFormulaError)
     end
 
     it "raises on pinned dependency" do
       dep_name = "homebrew-test-dependency"
-      dep_path = CoreTap.new.formula_dir/"#{dep_name}.rb"
+      dep_path = CoreTap.instance.new_formula_path(dep_name)
       dep_path.write <<~RUBY
         class #{Formulary.class_s(dep_name)} < Formula
           url "foo"
@@ -165,9 +170,254 @@ class #{Formulary.class_s(dep_name)} < Formula
 
       fi = described_class.new(dependent)
 
-      expect {
+      expect do
         fi.check_install_sanity
-      }.to raise_error(CannotInstallFormulaError)
+      end.to raise_error(CannotInstallFormulaError)
+    end
+  end
+
+  describe "#forbidden_license_check" do
+    it "raises on forbidden license on formula" do
+      ENV["HOMEBREW_FORBIDDEN_LICENSES"] = "AGPL-3.0"
+
+      f_name = "homebrew-forbidden-license"
+      f_path = CoreTap.instance.new_formula_path(f_name)
+      f_path.write <<~RUBY
+        class #{Formulary.class_s(f_name)} < Formula
+          url "foo"
+          version "0.1"
+          license "AGPL-3.0"
+        end
+      RUBY
+      Formulary.cache.delete(f_path)
+
+      f = Formulary.factory(f_name)
+      fi = described_class.new(f)
+
+      expect do
+        fi.forbidden_license_check
+      end.to raise_error(CannotInstallFormulaError, /#{f_name}'s licenses are all forbidden/)
+    end
+
+    it "raises on forbidden license on formula with contact instructions" do
+      ENV["HOMEBREW_FORBIDDEN_LICENSES"] = "AGPL-3.0"
+      ENV["HOMEBREW_FORBIDDEN_OWNER"] = owner = "your dog"
+      ENV["HOMEBREW_FORBIDDEN_OWNER_CONTACT"] = contact = "Woof loudly to get this unblocked."
+
+      f_name = "homebrew-forbidden-license"
+      f_path = CoreTap.instance.new_formula_path(f_name)
+      f_path.write <<~RUBY
+        class #{Formulary.class_s(f_name)} < Formula
+          url "foo"
+          version "0.1"
+          license "AGPL-3.0"
+        end
+      RUBY
+      Formulary.cache.delete(f_path)
+
+      f = Formulary.factory(f_name)
+      fi = described_class.new(f)
+
+      expect do
+        fi.forbidden_license_check
+      end.to raise_error(CannotInstallFormulaError, /#{owner}.+\n#{contact}/m)
+    end
+
+    it "raises on forbidden license on dependency" do
+      ENV["HOMEBREW_FORBIDDEN_LICENSES"] = "GPL-3.0"
+
+      dep_name = "homebrew-forbidden-dependency-license"
+      dep_path = CoreTap.instance.new_formula_path(dep_name)
+      dep_path.write <<~RUBY
+        class #{Formulary.class_s(dep_name)} < Formula
+          url "foo"
+          version "0.1"
+          license "GPL-3.0"
+        end
+      RUBY
+      Formulary.cache.delete(dep_path)
+
+      f_name = "homebrew-forbidden-dependent-license"
+      f_path = CoreTap.instance.new_formula_path(f_name)
+      f_path.write <<~RUBY
+        class #{Formulary.class_s(f_name)} < Formula
+          url "foo"
+          version "0.1"
+          depends_on "#{dep_name}"
+        end
+      RUBY
+      Formulary.cache.delete(f_path)
+
+      f = Formulary.factory(f_name)
+      fi = described_class.new(f)
+
+      expect do
+        fi.forbidden_license_check
+      end.to raise_error(CannotInstallFormulaError, /dependency on #{dep_name} where all/)
+    end
+  end
+
+  describe "#forbidden_tap_check" do
+    before do
+      allow(Tap).to receive_messages(allowed_taps: allowed_taps_set, forbidden_taps: forbidden_taps_set)
+    end
+
+    let(:homebrew_forbidden) { Tap.fetch("homebrew/forbidden") }
+    let(:allowed_third_party) { Tap.fetch("nothomebrew/allowed") }
+    let(:disallowed_third_party) { Tap.fetch("nothomebrew/notallowed") }
+    let(:allowed_taps_set) { Set.new([allowed_third_party]) }
+    let(:forbidden_taps_set) { Set.new([homebrew_forbidden]) }
+
+    it "raises on forbidden tap on formula" do
+      f_tap = homebrew_forbidden
+      f_name = "homebrew-forbidden-tap"
+      f_path = homebrew_forbidden.new_formula_path(f_name)
+      f_path.parent.mkpath
+      f_path.write <<~RUBY
+        class #{Formulary.class_s(f_name)} < Formula
+          url "foo"
+          version "0.1"
+        end
+      RUBY
+      Formulary.cache.delete(f_path)
+
+      f = Formulary.factory("#{f_tap}/#{f_name}")
+      fi = described_class.new(f)
+
+      expect do
+        fi.forbidden_tap_check
+      end.to raise_error(CannotInstallFormulaError, /has the tap #{f_tap}/)
+    ensure
+      FileUtils.rm_r(f_path.parent.parent)
+    end
+
+    it "raises on not allowed third-party tap on formula" do
+      f_tap = disallowed_third_party
+      f_name = "homebrew-not-allowed-tap"
+      f_path = disallowed_third_party.new_formula_path(f_name)
+      f_path.parent.mkpath
+      f_path.write <<~RUBY
+        class #{Formulary.class_s(f_name)} < Formula
+          url "foo"
+          version "0.1"
+        end
+      RUBY
+      Formulary.cache.delete(f_path)
+
+      f = Formulary.factory("#{f_tap}/#{f_name}")
+      fi = described_class.new(f)
+
+      expect do
+        fi.forbidden_tap_check
+      end.to raise_error(CannotInstallFormulaError, /has the tap #{f_tap}/)
+    ensure
+      FileUtils.rm_r(f_path.parent.parent.parent)
+    end
+
+    it "does not raise on allowed tap on formula" do
+      f_tap = allowed_third_party
+      f_name = "homebrew-allowed-tap"
+      f_path = allowed_third_party.new_formula_path(f_name)
+      f_path.parent.mkpath
+      f_path.write <<~RUBY
+        class #{Formulary.class_s(f_name)} < Formula
+          url "foo"
+          version "0.1"
+        end
+      RUBY
+      Formulary.cache.delete(f_path)
+
+      f = Formulary.factory("#{f_tap}/#{f_name}")
+      fi = described_class.new(f)
+
+      expect { fi.forbidden_tap_check }.not_to raise_error
+    ensure
+      FileUtils.rm_r(f_path.parent.parent.parent)
+    end
+
+    it "raises on forbidden tap on dependency" do
+      dep_tap = homebrew_forbidden
+      dep_name = "homebrew-forbidden-dependency-tap"
+      dep_path = homebrew_forbidden.new_formula_path(dep_name)
+      dep_path.parent.mkpath
+      dep_path.write <<~RUBY
+        class #{Formulary.class_s(dep_name)} < Formula
+          url "foo"
+          version "0.1"
+        end
+      RUBY
+      Formulary.cache.delete(dep_path)
+
+      f_name = "homebrew-forbidden-dependent-tap"
+      f_path = CoreTap.instance.new_formula_path(f_name)
+      f_path.write <<~RUBY
+        class #{Formulary.class_s(f_name)} < Formula
+          url "foo"
+          version "0.1"
+          depends_on "#{dep_name}"
+        end
+      RUBY
+      Formulary.cache.delete(f_path)
+
+      f = Formulary.factory(f_name)
+      fi = described_class.new(f)
+
+      expect do
+        fi.forbidden_tap_check
+      end.to raise_error(CannotInstallFormulaError, /from the #{dep_tap} tap but/)
+    ensure
+      FileUtils.rm_r(dep_path.parent.parent)
+    end
+  end
+
+  describe "#forbidden_formula_check" do
+    it "raises on forbidden formula" do
+      ENV["HOMEBREW_FORBIDDEN_FORMULAE"] = f_name = "homebrew-forbidden-formula"
+      f_path = CoreTap.instance.new_formula_path(f_name)
+      f_path.write <<~RUBY
+        class #{Formulary.class_s(f_name)} < Formula
+          url "foo"
+          version "0.1"
+        end
+      RUBY
+      Formulary.cache.delete(f_path)
+
+      f = Formulary.factory(f_name)
+      fi = described_class.new(f)
+
+      expect do
+        fi.forbidden_formula_check
+      end.to raise_error(CannotInstallFormulaError, /#{f_name} was forbidden/)
+    end
+
+    it "raises on forbidden dependency" do
+      ENV["HOMEBREW_FORBIDDEN_FORMULAE"] = dep_name = "homebrew-forbidden-dependency-formula"
+      dep_path = CoreTap.instance.new_formula_path(dep_name)
+      dep_path.write <<~RUBY
+        class #{Formulary.class_s(dep_name)} < Formula
+          url "foo"
+          version "0.1"
+        end
+      RUBY
+      Formulary.cache.delete(dep_path)
+
+      f_name = "homebrew-forbidden-dependent-formula"
+      f_path = CoreTap.instance.new_formula_path(f_name)
+      f_path.write <<~RUBY
+        class #{Formulary.class_s(f_name)} < Formula
+          url "foo"
+          version "0.1"
+          depends_on "#{dep_name}"
+        end
+      RUBY
+      Formulary.cache.delete(f_path)
+
+      f = Formulary.factory(f_name)
+      fi = described_class.new(f)
+
+      expect do
+        fi.forbidden_formula_check
+      end.to raise_error(CannotInstallFormulaError, /#{dep_name} formula was forbidden/)
     end
   end
 
@@ -175,17 +425,17 @@ class #{Formulary.class_s(dep_name)} < Formula
     ENV["HOMEBREW_TEST_NO_EXIT_CLEANUP"] = "1"
     ENV["FAILBALL_BUILD_ERROR"] = "1"
 
-    expect {
+    expect do
       temporary_install(Failball.new)
-    }.to raise_error(BuildError)
+    end.to raise_error(BuildError)
   end
 
   specify "install fails with a RuntimeError when #install raises" do
     ENV["HOMEBREW_TEST_NO_EXIT_CLEANUP"] = "1"
 
-    expect {
+    expect do
       temporary_install(Failball.new)
-    }.to raise_error(RuntimeError)
+    end.to raise_error(RuntimeError)
   end
 
   describe "#caveats" do
@@ -201,112 +451,75 @@ class #{Formulary.class_s(dep_name)} < Formula
   end
 
   describe "#install_service" do
-    it "works if plist is set" do
-      formula = Testball.new
-      path = formula.plist_path
-      formula.opt_prefix.mkpath
-
-      expect(formula).to receive(:plist).twice.and_return("PLIST")
-      expect(formula).to receive(:plist_path).and_call_original
-
-      installer = described_class.new(formula)
-      expect {
-        installer.install_service
-      }.not_to output(/Error: Failed to install service files/).to_stderr
-
-      expect(path).to exist
-    end
-
     it "works if service is set" do
       formula = Testball.new
-      plist_path = formula.plist_path
-      service_path = formula.systemd_service_path
       service = Homebrew::Service.new(formula)
+      launchd_service_path = formula.launchd_service_path
+      service_path = formula.systemd_service_path
       formula.opt_prefix.mkpath
 
-      expect(formula).to receive(:plist).and_return(nil)
-      expect(formula).to receive(:service?).exactly(3).and_return(true)
-      expect(formula).to receive(:service).exactly(3).and_return(service)
-      expect(formula).to receive(:plist_path).and_call_original
+      expect(formula).to receive(:service?).and_return(true)
+      expect(formula).to receive(:service).at_least(:once).and_return(service)
+      expect(formula).to receive(:launchd_service_path).and_call_original
       expect(formula).to receive(:systemd_service_path).and_call_original
 
       expect(service).to receive(:timed?).and_return(false)
+      expect(service).to receive(:command?).and_return(true)
       expect(service).to receive(:to_plist).and_return("plist")
       expect(service).to receive(:to_systemd_unit).and_return("unit")
 
       installer = described_class.new(formula)
-      expect {
+      expect do
         installer.install_service
-      }.not_to output(/Error: Failed to install service files/).to_stderr
+      end.not_to output(/Error: Failed to install service files/).to_stderr
 
-      expect(plist_path).to exist
+      expect(launchd_service_path).to exist
       expect(service_path).to exist
     end
 
     it "works if timed service is set" do
       formula = Testball.new
-      plist_path = formula.plist_path
+      service = Homebrew::Service.new(formula)
+      launchd_service_path = formula.launchd_service_path
       service_path = formula.systemd_service_path
       timer_path = formula.systemd_timer_path
-      service = Homebrew::Service.new(formula)
       formula.opt_prefix.mkpath
 
-      expect(formula).to receive(:plist).and_return(nil)
-      expect(formula).to receive(:service?).exactly(3).and_return(true)
-      expect(formula).to receive(:service).exactly(4).and_return(service)
-      expect(formula).to receive(:plist_path).and_call_original
+      expect(formula).to receive(:service?).and_return(true)
+      expect(formula).to receive(:service).at_least(:once).and_return(service)
+      expect(formula).to receive(:launchd_service_path).and_call_original
       expect(formula).to receive(:systemd_service_path).and_call_original
       expect(formula).to receive(:systemd_timer_path).and_call_original
 
-      expect(service).to receive(:to_plist).and_return("plist")
       expect(service).to receive(:timed?).and_return(true)
+      expect(service).to receive(:command?).and_return(true)
+      expect(service).to receive(:to_plist).and_return("plist")
       expect(service).to receive(:to_systemd_unit).and_return("unit")
       expect(service).to receive(:to_systemd_timer).and_return("timer")
 
       installer = described_class.new(formula)
-      expect {
+      expect do
         installer.install_service
-      }.not_to output(/Error: Failed to install service files/).to_stderr
+      end.not_to output(/Error: Failed to install service files/).to_stderr
 
-      expect(plist_path).to exist
+      expect(launchd_service_path).to exist
       expect(service_path).to exist
       expect(timer_path).to exist
     end
 
     it "returns without definition" do
       formula = Testball.new
-      path = formula.plist_path
-      formula.opt_prefix.mkpath
-
-      expect(formula).to receive(:plist).and_return(nil)
-      expect(formula).to receive(:service?).exactly(3).and_return(nil)
-      expect(formula).not_to receive(:plist_path)
-      expect(formula).not_to receive(:to_systemd_unit)
-
-      installer = described_class.new(formula)
-      expect {
-        installer.install_service
-      }.not_to output(/Error: Failed to install service files/).to_stderr
-
-      expect(path).not_to exist
-    end
-
-    it "errors with duplicate definition" do
-      formula = Testball.new
-      path = formula.plist_path
+      path = formula.launchd_service_path
       formula.opt_prefix.mkpath
 
-      expect(formula).to receive(:plist).and_return("plist")
-      expect(formula).to receive(:service?).and_return(true)
-      expect(formula).not_to receive(:service)
-      expect(formula).not_to receive(:plist_path)
+      expect(formula).to receive(:service?).and_return(nil)
+      expect(formula).not_to receive(:launchd_service_path)
 
       installer = described_class.new(formula)
-      expect {
+      expect do
         installer.install_service
-      }.to output("Error: Formula specified both service and plist\n").to_stderr
+      end.not_to output(/Error: Failed to install service files/).to_stderr
 
-      expect(Homebrew).to have_failed
       expect(path).not_to exist
     end
   end
diff --git a/Library/Homebrew/test/formula_pin_spec.rb b/Library/Homebrew/test/formula_pin_spec.rb
index e694ac875cbce..900f663896ba2 100644
--- a/Library/Homebrew/test/formula_pin_spec.rb
+++ b/Library/Homebrew/test/formula_pin_spec.rb
@@ -1,13 +1,12 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula_pin"
 
-describe FormulaPin do
+RSpec.describe FormulaPin do
   subject(:formula_pin) { described_class.new(formula) }
 
   let(:name) { "double" }
-  let(:formula) { double(Formula, name: name, rack: HOMEBREW_CELLAR/name) }
+  let(:formula) { instance_double(Formula, name:, rack: HOMEBREW_CELLAR/name) }
 
   before do
     formula.rack.mkpath
diff --git a/Library/Homebrew/test/formula_spec.rb b/Library/Homebrew/test/formula_spec.rb
index d4680abd7f252..7346b11226d40 100644
--- a/Library/Homebrew/test/formula_spec.rb
+++ b/Library/Homebrew/test/formula_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "test/support/fixtures/testball"
 require "formula"
 
-describe Formula do
+RSpec.describe Formula do
   alias_matcher :follow_installed_alias, :be_follow_installed_alias
   alias_matcher :have_any_version_installed, :be_any_version_installed
   alias_matcher :need_migration, :be_migration_needed
@@ -14,6 +13,7 @@
   alias_matcher :have_changed_alias, :be_alias_changed
 
   alias_matcher :have_option_defined, :be_option_defined
+  alias_matcher :have_post_install_defined, :be_post_install_defined
   alias_matcher :have_test_defined, :be_test_defined
   alias_matcher :pour_bottle, :be_pour_bottle
 
@@ -28,9 +28,9 @@
     let(:path) { Formulary.core_path(name) }
     let(:spec) { :stable }
     let(:alias_name) { "baz@1" }
-    let(:alias_path) { (CoreTap.instance.alias_dir/alias_name).to_s }
+    let(:alias_path) { CoreTap.instance.alias_dir/alias_name }
     let(:f) { klass.new(name, path, spec) }
-    let(:f_alias) { klass.new(name, path, spec, alias_path: alias_path) }
+    let(:f_alias) { klass.new(name, path, spec, alias_path:) }
 
     specify "formula instantiation" do
       expect(f.name).to eq(name)
@@ -42,6 +42,7 @@
       expect(f.alias_name).to be_nil
       expect(f.full_alias_name).to be_nil
       expect(f.specified_path).to eq(path)
+      [:build, :test, :postinstall].each { |phase| expect(f.network_access_allowed?(phase)).to be(true) }
       expect { klass.new }.to raise_error(ArgumentError)
     end
 
@@ -55,14 +56,15 @@
       expect(f_alias.specified_path).to eq(Pathname(alias_path))
       expect(f_alias.full_alias_name).to eq(alias_name)
       expect(f_alias.full_specified_name).to eq(alias_name)
+      [:build, :test, :postinstall].each { |phase| expect(f_alias.network_access_allowed?(phase)).to be(true) }
       expect { klass.new }.to raise_error(ArgumentError)
     end
 
     context "when in a Tap" do
-      let(:tap) { Tap.new("foo", "bar") }
+      let(:tap) { Tap.fetch("foo", "bar") }
       let(:path) { (tap.path/"Formula/#{name}.rb") }
-      let(:full_name) { "#{tap.user}/#{tap.repo}/#{name}" }
-      let(:full_alias_name) { "#{tap.user}/#{tap.repo}/#{alias_name}" }
+      let(:full_name) { "#{tap.user}/#{tap.repository}/#{name}" }
+      let(:full_alias_name) { "#{tap.user}/#{tap.repository}/#{alias_name}" }
 
       specify "formula instantiation" do
         expect(f.name).to eq(name)
@@ -149,11 +151,18 @@
       end
     end
 
-    it "returns true by default" do
-      FileUtils.touch f.path
-      FileUtils.touch f2.path
+    before do
+      # don't try to load/fetch gcc/glibc
+      allow(DevelopmentTools).to receive_messages(needs_libc_formula?: false, needs_compiler_formula?: false)
+
       allow(Formulary).to receive(:load_formula_from_path).with(f2.name, f2.path).and_return(f2)
       allow(Formulary).to receive(:factory).with(f2.name).and_return(f2)
+      allow(f).to receive(:versioned_formulae_names).and_return([f2.name])
+    end
+
+    it "returns array with versioned formulae" do
+      FileUtils.touch f.path
+      FileUtils.touch f2.path
       expect(f.versioned_formulae).to eq [f2]
     end
 
@@ -183,11 +192,11 @@
     end
 
     alias_name = "bar"
-    alias_path = "#{CoreTap.instance.alias_dir}/#{alias_name}"
+    alias_path = CoreTap.instance.alias_dir/alias_name
     CoreTap.instance.alias_dir.mkpath
     FileUtils.ln_sf f.path, alias_path
 
-    f.build = Tab.new(source: { "path" => alias_path })
+    f.build = Tab.new(source: { "path" => alias_path.to_s })
 
     expect(f.installed_alias_path).to eq(alias_path)
     expect(f.installed_alias_name).to eq(alias_name)
@@ -197,16 +206,16 @@
   end
 
   example "installed alias with tap" do
-    tap = Tap.new("user", "repo")
+    tap = Tap.fetch("user", "repo")
     name = "foo"
-    path = "#{tap.path}/Formula/#{name}.rb"
-    f = formula name, path: path do
+    path = tap.path/"Formula/#{name}.rb"
+    f = formula(name, path:) do
       url "foo-1.0"
     end
 
     build_values_with_no_installed_alias = [
       BuildOptions.new(Options.new, f.options),
-      Tab.new(source: { "path" => f.path }),
+      Tab.new(source: { "path" => f.path.to_s }),
     ]
     build_values_with_no_installed_alias.each do |build|
       f.build = build
@@ -218,12 +227,12 @@
     end
 
     alias_name = "bar"
-    full_alias_name = "#{tap.user}/#{tap.repo}/#{alias_name}"
-    alias_path = "#{tap.alias_dir}/#{alias_name}"
+    alias_path = tap.alias_dir/alias_name
+    full_alias_name = "#{tap.user}/#{tap.repository}/#{alias_name}"
     tap.alias_dir.mkpath
     FileUtils.ln_sf f.path, alias_path
 
-    f.build = Tab.new(source: { "path" => alias_path })
+    f.build = Tab.new(source: { "path" => alias_path.to_s })
 
     expect(f.installed_alias_path).to eq(alias_path)
     expect(f.installed_alias_name).to eq(alias_name)
@@ -237,7 +246,7 @@
   specify "#prefix" do
     f = Testball.new
     expect(f.prefix).to eq(HOMEBREW_CELLAR/f.name/"0.1")
-    expect(f.prefix).to be_kind_of(Pathname)
+    expect(f.prefix).to be_a(Pathname)
   end
 
   example "revised prefix" do
@@ -255,14 +264,14 @@
 
     prefix = HOMEBREW_CELLAR/f.name/"0.1"
     prefix.mkpath
-    FileUtils.touch prefix/Tab::FILENAME
+    FileUtils.touch prefix/AbstractTab::FILENAME
 
     expect(f).to have_any_version_installed
   end
 
   specify "#migration_needed" do
     f = Testball.new("newname")
-    f.instance_variable_set(:@oldname, "oldname")
+    f.instance_variable_set(:@oldnames, ["oldname"])
     f.instance_variable_set(:@tap, CoreTap.instance)
 
     oldname_prefix = (HOMEBREW_CELLAR/"oldname/2.20")
@@ -270,7 +279,7 @@
 
     oldname_prefix.mkpath
     oldname_tab = Tab.empty
-    oldname_tab.tabfile = oldname_prefix/Tab::FILENAME
+    oldname_tab.tabfile = oldname_prefix/AbstractTab::FILENAME
     oldname_tab.write
 
     expect(f).not_to need_migration
@@ -290,17 +299,19 @@
     let(:f) { Testball.new }
 
     it "returns false if the #latest_installed_prefix is not a directory" do
-      allow(f).to receive(:latest_installed_prefix).and_return(double(directory?: false))
+      allow(f).to receive(:latest_installed_prefix).and_return(instance_double(Pathname, directory?: false))
       expect(f).not_to be_latest_version_installed
     end
 
     it "returns false if the #latest_installed_prefix does not have children" do
-      allow(f).to receive(:latest_installed_prefix).and_return(double(directory?: true, children: []))
+      allow(f).to receive(:latest_installed_prefix)
+        .and_return(instance_double(Pathname, directory?: true, children: []))
       expect(f).not_to be_latest_version_installed
     end
 
     it "returns true if the #latest_installed_prefix has children" do
-      allow(f).to receive(:latest_installed_prefix).and_return(double(directory?: true, children: [double]))
+      allow(f).to receive(:latest_installed_prefix)
+        .and_return(instance_double(Pathname, directory?: true, children: [double]))
       expect(f).to be_latest_version_installed
     end
   end
@@ -335,7 +346,7 @@
       head_prefix.mkpath
 
       tab = Tab.empty
-      tab.tabfile = head_prefix/Tab::FILENAME
+      tab.tabfile = head_prefix/AbstractTab::FILENAME
       tab.source["versions"] = { "stable" => "1.0" }
       tab.write
 
@@ -367,7 +378,7 @@
         prefix.mkpath
 
         tab = Tab.empty
-        tab.tabfile = prefix/Tab::FILENAME
+        tab.tabfile = prefix/AbstractTab::FILENAME
         tab.source_modified_time = stamp
         tab.write
       end
@@ -408,7 +419,7 @@
     example "alias paths with build options" do
       alias_path = (CoreTap.instance.alias_dir/"another_name")
 
-      f = formula alias_path: alias_path do
+      f = formula(alias_path:) do
         url "foo-1.0"
       end
       f.build = BuildOptions.new(Options.new, f.options)
@@ -419,9 +430,9 @@
 
     example "alias paths with tab with non alias source path" do
       alias_path = (CoreTap.instance.alias_dir/"another_name")
-      source_path = (CoreTap.instance.formula_dir/"another_other_name")
+      source_path = CoreTap.instance.new_formula_path("another_other_name")
 
-      f = formula alias_path: alias_path do
+      f = formula(alias_path:) do
         url "foo-1.0"
       end
       f.build = Tab.new(source: { "path" => source_path.to_s })
@@ -434,7 +445,7 @@
       alias_path = (CoreTap.instance.alias_dir/"another_name")
       source_path = (CoreTap.instance.alias_dir/"another_other_name")
 
-      f = formula alias_path: alias_path do
+      f = formula(alias_path:) do
         url "foo-1.0"
       end
       f.build = Tab.new(source: { "path" => source_path.to_s })
@@ -442,44 +453,37 @@
       FileUtils.ln_sf f.path, source_path
 
       expect(f.alias_path).to eq(alias_path)
-      expect(f.installed_alias_path).to eq(source_path.to_s)
+      expect(f.installed_alias_path).to eq(source_path)
     end
   end
 
-  describe "::installed_formulae_with_no_dependents" do
-    let(:formula_is_dep) do
-      formula "foo" do
-        url "foo-1.1"
-      end
-    end
-
-    let(:formula_with_deps) do
-      formula "bar" do
-        url "bar-1.0"
+  describe "::inreplace" do
+    specify "raises build error on failure" do
+      f = formula do
+        url "https://brew.sh/test-1.0.tbz"
       end
-    end
-
-    let(:formulae) do
-      [
-        formula_with_deps,
-        formula_is_dep,
-      ]
-    end
 
-    before do
-      allow(formula_with_deps).to receive(:runtime_formula_dependencies).and_return([formula_is_dep])
-    end
-
-    specify "without formulae parameter" do
-      allow(described_class).to receive(:installed).and_return(formulae)
-
-      expect(described_class.installed_formulae_with_no_dependents)
-          .to eq([formula_with_deps])
+      expect { f.inreplace([]) }.to raise_error(BuildError)
     end
 
-    specify "with formulae parameter" do
-      expect(described_class.installed_formulae_with_no_dependents(formulae))
-          .to eq([formula_with_deps])
+    specify "replaces text in file" do
+      file = Tempfile.new("test")
+      File.binwrite(file, <<~EOS)
+        ab
+        bc
+        cd
+      EOS
+      f = formula do
+        url "https://brew.sh/test-1.0.tbz"
+      end
+      f.inreplace(file.path) do |s|
+        s.gsub!("bc", "yz")
+      end
+      expect(File.binread(file)).to eq <<~EOS
+        ab
+        yz
+        cd
+      EOS
     end
   end
 
@@ -489,14 +493,14 @@
     end
 
     specify "with alias path with a path" do
-      alias_path = "#{CoreTap.instance.alias_dir}/alias"
-      different_alias_path = "#{CoreTap.instance.alias_dir}/another_alias"
+      alias_path = CoreTap.instance.alias_dir/"alias"
+      different_alias_path = CoreTap.instance.alias_dir/"another_alias"
 
       formula_with_alias = formula "foo" do
         url "foo-1.0"
       end
       formula_with_alias.build = Tab.empty
-      formula_with_alias.build.source["path"] = alias_path
+      formula_with_alias.build.source["path"] = alias_path.to_s
 
       formula_without_alias = formula "bar" do
         url "bar-1.0"
@@ -508,7 +512,7 @@
         url "baz-1.0"
       end
       formula_with_different_alias.build = Tab.empty
-      formula_with_different_alias.build.source["path"] = different_alias_path
+      formula_with_different_alias.build.source["path"] = different_alias_path.to_s
 
       formulae = [
         formula_with_alias,
@@ -538,10 +542,10 @@
     end
 
     expect(f.homepage).to eq("https://brew.sh")
-    expect(f.version).to eq(Version.create("0.1"))
+    expect(f.version).to eq(Version.new("0.1"))
     expect(f).to be_stable
-    expect(f.stable.version).to eq(Version.create("0.1"))
-    expect(f.head.version).to eq(Version.create("HEAD"))
+    expect(f.stable.version).to eq(Version.new("0.1"))
+    expect(f.head.version).to eq(Version.new("HEAD"))
   end
 
   specify "#active_spec=" do
@@ -563,8 +567,8 @@
       url "foo-1.0"
     end
 
-    expect(f.class.stable).to be_kind_of(SoftwareSpec)
-    expect(f.class.head).to be_kind_of(SoftwareSpec)
+    expect(f.class.stable).to be_a(SoftwareSpec)
+    expect(f.class.head).to be_a(SoftwareSpec)
   end
 
   specify "instance specs have different references" do
@@ -641,7 +645,7 @@
 
     f.update_head_version
 
-    expect(f.head.version).to eq(Version.create("HEAD-5658946"))
+    expect(f.head.version).to eq(Version.new("HEAD-5658946"))
   end
 
   specify "#desc" do
@@ -654,6 +658,23 @@
     expect(f.desc).to eq("a formula")
   end
 
+  specify "#post_install_defined?" do
+    f1 = formula do
+      url "foo-1.0"
+
+      def post_install
+        # do nothing
+      end
+    end
+
+    f2 = formula do
+      url "foo-1.0"
+    end
+
+    expect(f1).to have_post_install_defined
+    expect(f2).not_to have_post_install_defined
+  end
+
   specify "test fixtures" do
     f1 = formula do
       url "foo-1.0"
@@ -719,23 +740,24 @@
         url "https://brew.sh/test-1.0.tbz"
       end
 
-      expect(f.service).to be_nil
+      expect(f.service.to_hash).to eq({})
     end
 
     specify "service complicated" do
       f = formula do
         url "https://brew.sh/test-1.0.tbz"
-      end
 
-      f.class.service do
-        run [opt_bin/"beanstalkd"]
-        run_type :immediate
-        error_log_path var/"log/beanstalkd.error.log"
-        log_path var/"log/beanstalkd.log"
-        working_dir var
-        keep_alive true
+        service do
+          run [opt_bin/"beanstalkd"]
+          run_type :immediate
+          error_log_path var/"log/beanstalkd.error.log"
+          log_path var/"log/beanstalkd.log"
+          working_dir var
+          keep_alive true
+        end
       end
-      expect(f.service).not_to be_nil
+      expect(f.service.to_hash.keys)
+        .to contain_exactly(:run, :run_type, :error_log_path, :log_path, :working_dir, :keep_alive)
     end
 
     specify "service uses simple run" do
@@ -746,7 +768,20 @@
         end
       end
 
-      expect(f.service).not_to be_nil
+      expect(f.service.to_hash.keys).to contain_exactly(:run, :run_type)
+    end
+
+    specify "service with only custom names" do
+      f = formula do
+        url "https://brew.sh/test-1.0.tbz"
+        service do
+          name macos: "custom.macos.beanstalkd", linux: "custom.linux.beanstalkd"
+        end
+      end
+
+      expect(f.plist_name).to eq("custom.macos.beanstalkd")
+      expect(f.service_name).to eq("custom.linux.beanstalkd")
+      expect(f.service.to_hash.keys).to contain_exactly(:name)
     end
 
     specify "service helpers return data" do
@@ -756,13 +791,16 @@
 
       expect(f.plist_name).to eq("homebrew.mxcl.formula_name")
       expect(f.service_name).to eq("homebrew.formula_name")
-      expect(f.plist_path).to eq(HOMEBREW_PREFIX/"opt/formula_name/homebrew.mxcl.formula_name.plist")
+      expect(f.launchd_service_path).to eq(HOMEBREW_PREFIX/"opt/formula_name/homebrew.mxcl.formula_name.plist")
       expect(f.systemd_service_path).to eq(HOMEBREW_PREFIX/"opt/formula_name/homebrew.formula_name.service")
       expect(f.systemd_timer_path).to eq(HOMEBREW_PREFIX/"opt/formula_name/homebrew.formula_name.timer")
     end
   end
 
   specify "dependencies" do
+    # don't try to load/fetch gcc/glibc
+    allow(DevelopmentTools).to receive_messages(needs_libc_formula?: false, needs_compiler_formula?: false)
+
     f1 = formula "f1" do
       url "f1-1.0"
     end
@@ -805,9 +843,14 @@
     specify "runtime dependencies with optional deps from tap" do
       tap_loader = double
 
+      # don't try to load/fetch gcc/glibc
+      allow(DevelopmentTools).to receive_messages(needs_libc_formula?: false, needs_compiler_formula?: false)
+
       allow(tap_loader).to receive(:get_formula).and_raise(RuntimeError, "tried resolving tap formula")
       allow(Formulary).to receive(:loader_for).with("foo/bar/f1", from: nil).and_return(tap_loader)
-      stub_formula_loader(formula("f2") { url("f2-1.0") }, "baz/qux/f2")
+
+      f2_path = Tap.fetch("baz", "qux").path/"Formula/f2.rb"
+      stub_formula_loader(formula("f2", path: f2_path) { url("f2-1.0") }, "baz/qux/f2")
 
       f3 = formula "f3" do
         url "f3-1.0"
@@ -818,7 +861,9 @@
 
       expect(f3.runtime_dependencies.map(&:name)).to eq(["baz/qux/f2"])
 
-      stub_formula_loader(formula("f1") { url("f1-1.0") }, "foo/bar/f1")
+      f1_path = Tap.fetch("foo", "bar").path/"Formula/f1.rb"
+      stub_formula_loader(formula("f1", path: f1_path) { url("f1-1.0") }, "foo/bar/f1")
+
       f3.build = BuildOptions.new(Options.create(["--with-f1"]), f3.options)
 
       expect(f3.runtime_dependencies.map(&:name)).to eq(["foo/bar/f1", "baz/qux/f2"])
@@ -832,7 +877,7 @@
       keg = Keg.for(formula.latest_installed_prefix)
       keg.link
 
-      linkage_checker = double("linkage checker", undeclared_deps: [dependency.name])
+      linkage_checker = instance_double(LinkageChecker, "linkage checker", undeclared_deps: [dependency.name])
       allow(LinkageChecker).to receive(:new).and_return(linkage_checker)
 
       expect(formula.runtime_dependencies.map(&:name)).to eq [dependency.name]
@@ -854,6 +899,9 @@
   end
 
   specify "requirements" do
+    # don't try to load/fetch gcc/glibc
+    allow(DevelopmentTools).to receive_messages(needs_libc_formula?: false, needs_compiler_formula?: false)
+
     f1 = formula "f1" do
       url "f1-1"
 
@@ -877,7 +925,11 @@
     end
 
     expect(Set.new(f2.recursive_requirements)).to eq(Set[])
-    expect(Set.new(f2.recursive_requirements {})).to eq(Set[xcode])
+    expect(
+      f2.recursive_requirements do
+        # do nothing
+      end.to_set,
+    ).to eq(Set[xcode])
 
     requirements = f2.recursive_requirements do |_dependent, requirement|
       Requirement.prune if requirement.is_a?(XcodeRequirement)
@@ -906,7 +958,7 @@
   end
 
   describe "#to_hash_with_variations", :needs_macos do
-    let(:formula_path) { CoreTap.new.formula_dir/"foo-variations.rb" }
+    let(:formula_path) { CoreTap.instance.new_formula_path("foo-variations") }
     let(:formula_content) do
       <<~RUBY
         class FooVariations < Formula
@@ -931,14 +983,9 @@ class FooVariations < Formula
         end
       RUBY
     end
-    let(:expected_variations) {
+    let(:expected_variations) do
       <<~JSON
         {
-          "arm64_big_sur": {
-            "dependencies": [
-              "big-sur-formula"
-            ]
-          },
           "monterey": {
             "dependencies": [
               "intel-formula"
@@ -950,6 +997,11 @@ class FooVariations < Formula
               "big-sur-formula"
             ]
           },
+          "arm64_big_sur": {
+            "dependencies": [
+              "big-sur-formula"
+            ]
+          },
           "catalina": {
             "dependencies": [
               "intel-formula",
@@ -970,20 +1022,15 @@ class FooVariations < Formula
           }
         }
       JSON
-    }
+    end
 
     before do
-      # Use a more limited symbols list to shorten the variations hash
-      symbols = {
-        monterey: "12",
-        big_sur:  "11",
-        catalina: "10.15",
-        mojave:   "10.14",
-      }
-      stub_const("MacOSVersions::SYMBOLS", symbols)
+      # Use a more limited os list to shorten the variations hash
+      os_list = [:monterey, :big_sur, :catalina, :mojave, :linux]
+      stub_const("OnSystem::ALL_OS_ARCH_COMBINATIONS", os_list.product(OnSystem::ARCH_OPTIONS))
 
       # For consistency, always run on Monterey and ARM
-      allow(MacOS).to receive(:version).and_return(MacOS::Version.new("12"))
+      allow(MacOS).to receive(:version).and_return(MacOSVersion.new("12"))
       allow(Hardware::CPU).to receive(:type).and_return(:arm)
 
       formula_path.dirname.mkpath
@@ -998,25 +1045,6 @@ class FooVariations < Formula
     end
   end
 
-  specify "#to_recursive_bottle_hash" do
-    f1 = formula "foo" do
-      url "foo-1.0"
-
-      bottle do
-        sha256 cellar: :any, Utils::Bottles.tag.to_sym => TEST_SHA256
-        sha256 cellar: :any, foo:                         TEST_SHA256
-      end
-    end
-
-    h = f1.to_recursive_bottle_hash
-
-    expect(h).to be_a(Hash)
-    expect(h["name"]).to eq "foo"
-    expect(h["bottles"].keys).to eq [Utils::Bottles.tag.to_s, "x86_64_foo"]
-    expect(h["bottles"][Utils::Bottles.tag.to_s].keys).to eq ["url"]
-    expect(h["dependencies"]).to eq []
-  end
-
   describe "#eligible_kegs_for_cleanup" do
     it "returns Kegs eligible for cleanup" do
       f1 = Class.new(Testball) do
@@ -1078,7 +1106,7 @@ class FooVariations < Formula
         prefix = f.prefix(version)
         prefix.mkpath
         tab = Tab.empty
-        tab.tabfile = prefix/Tab::FILENAME
+        tab.tabfile = prefix/AbstractTab::FILENAME
         tab.source_modified_time = 1
         tab.write
       end
@@ -1201,19 +1229,20 @@ def pour_bottle?
 
   describe "alias changes" do
     let(:f) do
-      formula "formula_name", alias_path: alias_path do
+      formula("formula_name", alias_path:) do
         url "foo-1.0"
       end
     end
 
     let(:new_formula) do
-      formula "new_formula_name", alias_path: alias_path do
+      formula("new_formula_name", alias_path:) do
         url "foo-1.1"
       end
     end
 
     let(:tab) { Tab.empty }
-    let(:alias_path) { "#{CoreTap.instance.alias_dir}/bar" }
+    let(:alias_name) { "bar" }
+    let(:alias_path) { CoreTap.instance.alias_dir/alias_name }
 
     before do
       allow(described_class).to receive(:installed).and_return([f])
@@ -1234,8 +1263,8 @@ def pour_bottle?
     end
 
     specify "alias changes when not changed" do
-      tab.source["path"] = alias_path
-      stub_formula_loader(f, alias_path)
+      tab.source["path"] = alias_path.to_s
+      stub_formula_loader(f, alias_name)
 
       CoreTap.instance.alias_dir.mkpath
       FileUtils.ln_sf f.path, alias_path
@@ -1249,8 +1278,8 @@ def pour_bottle?
     end
 
     specify "alias changes when new alias target" do
-      tab.source["path"] = alias_path
-      stub_formula_loader(new_formula, alias_path)
+      tab.source["path"] = alias_path.to_s
+      stub_formula_loader(new_formula, alias_name)
 
       CoreTap.instance.alias_dir.mkpath
       FileUtils.ln_sf new_formula.path, alias_path
@@ -1264,8 +1293,8 @@ def pour_bottle?
     end
 
     specify "alias changes when old formulae installed" do
-      tab.source["path"] = alias_path
-      stub_formula_loader(new_formula, alias_path)
+      tab.source["path"] = alias_path.to_s
+      stub_formula_loader(new_formula, alias_name)
 
       CoreTap.instance.alias_dir.mkpath
       FileUtils.ln_sf new_formula.path, alias_path
@@ -1305,12 +1334,13 @@ def pour_bottle?
       end
     end
 
-    let(:alias_path) { "#{f.tap.alias_dir}/bar" }
+    let(:alias_name) { "bar" }
+    let(:alias_path) { f.tap.alias_dir/alias_name }
 
     def setup_tab_for_prefix(prefix, options = {})
       prefix.mkpath
       tab = Tab.empty
-      tab.tabfile = prefix/Tab::FILENAME
+      tab.tabfile = prefix/AbstractTab::FILENAME
       tab.source["path"] = options[:path].to_s if options[:path]
       tab.source["tap"] = options[:tap] if options[:tap]
       tab.source["versions"] = options[:versions] if options[:versions]
@@ -1344,14 +1374,14 @@ def setup_tab_for_prefix(prefix, options = {})
     example "outdated follow alias and alias unchanged" do
       f.follow_installed_alias = true
       f.build = setup_tab_for_prefix(same_prefix, path: alias_path)
-      stub_formula_loader(f, alias_path)
+      stub_formula_loader(f, alias_name)
       expect(f.outdated_kegs).to be_empty
     end
 
     example "outdated follow alias and alias changed and new target not installed" do
       f.follow_installed_alias = true
       f.build = setup_tab_for_prefix(same_prefix, path: alias_path)
-      stub_formula_loader(new_formula, alias_path)
+      stub_formula_loader(new_formula, alias_name)
 
       CoreTap.instance.alias_dir.mkpath
       FileUtils.ln_sf new_formula.path, alias_path
@@ -1362,7 +1392,7 @@ def setup_tab_for_prefix(prefix, options = {})
     example "outdated follow alias and alias changed and new target installed" do
       f.follow_installed_alias = true
       f.build = setup_tab_for_prefix(same_prefix, path: alias_path)
-      stub_formula_loader(new_formula, alias_path)
+      stub_formula_loader(new_formula, alias_name)
       setup_tab_for_prefix(new_formula.prefix)
       expect(f.outdated_kegs).to be_empty
     end
@@ -1370,7 +1400,7 @@ def setup_tab_for_prefix(prefix, options = {})
     example "outdated no follow alias and alias unchanged" do
       f.follow_installed_alias = false
       f.build = setup_tab_for_prefix(same_prefix, path: alias_path)
-      stub_formula_loader(f, alias_path)
+      stub_formula_loader(f, alias_name)
       expect(f.outdated_kegs).to be_empty
     end
 
@@ -1387,7 +1417,7 @@ def setup_tab_for_prefix(prefix, options = {})
     end
 
     example "outdated old alias targets installed" do
-      f = formula alias_path: alias_path do
+      f = formula(alias_path:) do
         url "foo-1.0"
       end
 
@@ -1402,7 +1432,7 @@ def setup_tab_for_prefix(prefix, options = {})
     end
 
     example "outdated old alias targets not installed" do
-      f = formula alias_path: alias_path do
+      f = formula(alias_path:) do
         url "foo-1.0"
       end
 
@@ -1503,7 +1533,7 @@ def setup_tab_for_prefix(prefix, options = {})
         testball_repo.cd do
           FileUtils.touch "LICENSE"
 
-          system("git", "init")
+          system("git", "-c", "init.defaultBranch=master", "init")
           system("git", "add", "--all")
           system("git", "commit", "-m", "Initial commit")
         end
@@ -1515,7 +1545,7 @@ def setup_tab_for_prefix(prefix, options = {})
         described_class.clear_cache
         expect(f.outdated_kegs(fetch_head: true)).not_to be_empty
 
-        head_prefix_a.rmtree
+        FileUtils.rm_r(head_prefix_a)
         described_class.clear_cache
         expect(f.outdated_kegs(fetch_head: true)).not_to be_empty
 
@@ -1523,7 +1553,7 @@ def setup_tab_for_prefix(prefix, options = {})
         described_class.clear_cache
         expect(f.outdated_kegs(fetch_head: true)).to be_empty
       ensure
-        testball_repo.rmtree if testball_repo.exist?
+        FileUtils.rm_r(testball_repo) if testball_repo.exist?
       end
     end
 
@@ -1602,7 +1632,7 @@ def setup_tab_for_prefix(prefix, options = {})
         expect(f.outdated_kegs).not_to be_empty
 
         described_class.clear_cache
-        head_prefix.rmtree
+        FileUtils.rm_r(head_prefix)
 
         setup_tab_for_prefix(head_prefix, versions: { "stable" => "1.0", "version_scheme" => 2 })
         expect(f.outdated_kegs).to be_empty
@@ -1675,10 +1705,6 @@ def install
   end
 
   describe "#on_system" do
-    after do
-      Homebrew::SimulateSystem.clear
-    end
-
     let(:f) do
       Class.new(Testball) do
         attr_reader :foo
@@ -1698,50 +1724,47 @@ def install
     end
 
     it "doesn't call code on Ventura", :needs_macos do
-      Homebrew::SimulateSystem.os = :ventura
-      f.brew { f.install }
-      expect(f.foo).to eq(0)
-      expect(f.bar).to eq(0)
+      Homebrew::SimulateSystem.with os: :ventura do
+        f.brew { f.install }
+        expect(f.foo).to eq(0)
+        expect(f.bar).to eq(0)
+      end
     end
 
     it "calls code on Linux", :needs_linux do
-      Homebrew::SimulateSystem.os = :linux
-      f.brew { f.install }
-      expect(f.foo).to eq(1)
-      expect(f.bar).to eq(1)
+      Homebrew::SimulateSystem.with os: :linux do
+        f.brew { f.install }
+        expect(f.foo).to eq(1)
+        expect(f.bar).to eq(1)
+      end
     end
 
     it "calls code within `on_system :linux, macos: :monterey` on Monterey", :needs_macos do
-      Homebrew::SimulateSystem.os = :monterey
-      f.brew { f.install }
-      expect(f.foo).to eq(1)
-      expect(f.bar).to eq(0)
+      Homebrew::SimulateSystem.with os: :monterey do
+        f.brew { f.install }
+        expect(f.foo).to eq(1)
+        expect(f.bar).to eq(0)
+      end
     end
 
     it "calls code within `on_system :linux, macos: :big_sur_or_older` on Big Sur", :needs_macos do
-      Homebrew::SimulateSystem.os = :big_sur
-      f.brew { f.install }
-      expect(f.foo).to eq(0)
-      expect(f.bar).to eq(1)
+      Homebrew::SimulateSystem.with os: :big_sur do
+        f.brew { f.install }
+        expect(f.foo).to eq(0)
+        expect(f.bar).to eq(1)
+      end
     end
 
     it "calls code within `on_system :linux, macos: :big_sur_or_older` on Catalina", :needs_macos do
-      Homebrew::SimulateSystem.os = :catalina
-      f.brew { f.install }
-      expect(f.foo).to eq(0)
-      expect(f.bar).to eq(1)
+      Homebrew::SimulateSystem.with os: :catalina do
+        f.brew { f.install }
+        expect(f.foo).to eq(0)
+        expect(f.bar).to eq(1)
+      end
     end
   end
 
   describe "on_{os_version} blocks", :needs_macos do
-    before do
-      Homebrew::SimulateSystem.os = :monterey
-    end
-
-    after do
-      Homebrew::SimulateSystem.clear
-    end
-
     let(:f) do
       Class.new(Testball) do
         attr_reader :test
@@ -1762,33 +1785,38 @@ def install
     end
 
     it "only calls code within `on_monterey`" do
-      Homebrew::SimulateSystem.os = :monterey
-      f.brew { f.install }
-      expect(f.test).to eq(1)
+      Homebrew::SimulateSystem.with os: :monterey do
+        f.brew { f.install }
+        expect(f.test).to eq(1)
+      end
     end
 
     it "only calls code within `on_monterey :or_newer`" do
-      Homebrew::SimulateSystem.os = :ventura
-      f.brew { f.install }
-      expect(f.test).to eq(1)
+      Homebrew::SimulateSystem.with os: :ventura do
+        f.brew { f.install }
+        expect(f.test).to eq(1)
+      end
     end
 
     it "only calls code within `on_big_sur`" do
-      Homebrew::SimulateSystem.os = :big_sur
-      f.brew { f.install }
-      expect(f.test).to eq(2)
+      Homebrew::SimulateSystem.with os: :big_sur do
+        f.brew { f.install }
+        expect(f.test).to eq(2)
+      end
     end
 
     it "only calls code within `on_catalina`" do
-      Homebrew::SimulateSystem.os = :catalina
-      f.brew { f.install }
-      expect(f.test).to eq(3)
+      Homebrew::SimulateSystem.with os: :catalina do
+        f.brew { f.install }
+        expect(f.test).to eq(3)
+      end
     end
 
     it "only calls code within `on_catalina :or_older`" do
-      Homebrew::SimulateSystem.os = :mojave
-      f.brew { f.install }
-      expect(f.test).to eq(3)
+      Homebrew::SimulateSystem.with os: :mojave do
+        f.brew { f.install }
+        expect(f.test).to eq(3)
+      end
     end
   end
 
@@ -1845,4 +1873,101 @@ def install
       expect(f.test).to eq(2)
     end
   end
+
+  describe "#generate_completions_from_executable" do
+    let(:f) do
+      Class.new(Testball) do
+        def install
+          bin.mkpath
+          (bin/"foo").write <<-EOF
+            echo completion
+          EOF
+
+          FileUtils.chmod "+x", bin/"foo"
+
+          generate_completions_from_executable(bin/"foo", "test")
+        end
+      end.new
+    end
+
+    it "generates completion scripts" do
+      f.brew { f.install }
+      expect(f.bash_completion/"testball").to be_a_file
+      expect(f.zsh_completion/"_testball").to be_a_file
+      expect(f.fish_completion/"testball.fish").to be_a_file
+    end
+  end
+
+  describe "{allow,deny}_network_access" do
+    phases = [:build, :postinstall, :test].freeze
+    actions = %w[allow deny].freeze
+    phases.each do |phase|
+      actions.each do |action|
+        it "can #{action} network access for #{phase}" do
+          f = Class.new(Testball) do
+            send(:"#{action}_network_access!", phase)
+          end
+
+          expect(f.network_access_allowed?(phase)).to be(action == "allow")
+        end
+      end
+    end
+
+    actions.each do |action|
+      it "can #{action} network access for all phases" do
+        f = Class.new(Testball) do
+          send(:"#{action}_network_access!")
+        end
+
+        phases.each do |phase|
+          expect(f.network_access_allowed?(phase)).to be(action == "allow")
+        end
+      end
+    end
+  end
+
+  describe "#network_access_allowed?" do
+    it "throws an error when passed an invalid symbol" do
+      f = Testball.new
+      expect { f.network_access_allowed?(:foo) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#specified_path" do
+    let(:klass) do
+      Class.new(described_class) do
+        url "https://brew.sh/foo-1.0.tar.gz"
+      end
+    end
+
+    let(:name) { "formula_name" }
+    let(:path) { Formulary.core_path(name) }
+    let(:spec) { :stable }
+    let(:alias_name) { "baz@1" }
+    let(:alias_path) { CoreTap.instance.alias_dir/alias_name }
+    let(:f) { klass.new(name, path, spec) }
+    let(:f_alias) { klass.new(name, path, spec, alias_path:) }
+
+    context "when loading from a formula file" do
+      it "returns the formula file path" do
+        expect(f.specified_path).to eq(path)
+      end
+    end
+
+    context "when loaded from an alias" do
+      it "returns the alias path" do
+        expect(f_alias.specified_path).to eq(alias_path)
+      end
+    end
+
+    context "when loaded from the API" do
+      before do
+        allow(f).to receive(:loaded_from_api?).and_return(true)
+      end
+
+      it "returns the API path" do
+        expect(f.specified_path).to eq(Homebrew::API::Formula.cached_json_file_path)
+      end
+    end
+  end
 end
diff --git a/Library/Homebrew/test/formula_spec_selection_spec.rb b/Library/Homebrew/test/formula_spec_selection_spec.rb
index 587d0d1ff6a9a..72f565a48ac11 100644
--- a/Library/Homebrew/test/formula_spec_selection_spec.rb
+++ b/Library/Homebrew/test/formula_spec_selection_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula"
 
-describe Formula do
+RSpec.describe Formula do
   describe "::new" do
     it "selects stable by default" do
       f = formula do
diff --git a/Library/Homebrew/test/formula_support/keg_only_reason_spec.rb b/Library/Homebrew/test/formula_support/keg_only_reason_spec.rb
index 1186e5851f842..ca669b53658ee 100644
--- a/Library/Homebrew/test/formula_support/keg_only_reason_spec.rb
+++ b/Library/Homebrew/test/formula_support/keg_only_reason_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula_support"
 
-describe KegOnlyReason do
+RSpec.describe KegOnlyReason do
   describe "#to_s" do
     it "returns the reason provided" do
       r = described_class.new :provided_by_macos, "test"
diff --git a/Library/Homebrew/test/formula_validation_spec.rb b/Library/Homebrew/test/formula_validation_spec.rb
index 30077967f049a..e6388fc25f48d 100644
--- a/Library/Homebrew/test/formula_validation_spec.rb
+++ b/Library/Homebrew/test/formula_validation_spec.rb
@@ -1,20 +1,17 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula"
 
-describe Formula do
+RSpec.describe Formula do
   describe "::new" do
     matcher :fail_with_invalid do |attr|
       match do |actual|
-        expect {
-          begin
-            actual.call
-          rescue => e
-            expect(e.attr).to eq(attr)
-            raise e
-          end
-        }.to raise_error(FormulaValidationError)
+        expect do
+          actual.call
+        rescue => e
+          expect(e.attr).to eq(attr)
+          raise e
+        end.to raise_error(FormulaValidationError)
       end
 
       def supports_block_expectations?
@@ -23,52 +20,52 @@ def supports_block_expectations?
     end
 
     it "can't override the `brew` method" do
-      expect {
+      expect do
         formula do
           def brew; end
         end
-      }.to raise_error(RuntimeError, /You cannot override Formula#brew/)
+      end.to raise_error(RuntimeError, /You cannot override Formula#brew/)
     end
 
     it "validates the `name`" do
-      expect {
+      expect do
         formula "name with spaces" do
           url "foo"
           version "1.0"
         end
-      }.to fail_with_invalid :name
+      end.to fail_with_invalid :name
     end
 
     it "validates the `url`" do
-      expect {
+      expect do
         formula do
           url ""
           version "1"
         end
-      }.to fail_with_invalid :url
+      end.to fail_with_invalid :url
     end
 
     it "validates the `version`" do
-      expect {
+      expect do
         formula do
           url "foo"
           version "version with spaces"
         end
-      }.to fail_with_invalid :version
+      end.to fail_with_invalid :version
 
-      expect {
+      expect do
         formula do
           url "foo"
           version ""
         end
-      }.to fail_with_invalid :version
+      end.to fail_with_invalid :version
 
-      expect {
+      expect do
         formula do
           url "foo"
           version nil
         end
-      }.to fail_with_invalid :version
+      end.to fail_with_invalid :version
     end
 
     specify "head-only is valid" do
@@ -80,7 +77,11 @@ def brew; end
     end
 
     it "fails when Formula is empty" do
-      expect { formula {} }.to raise_error(FormulaSpecificationError)
+      expect do
+        formula do
+          # do nothing
+        end
+      end.to raise_error(FormulaSpecificationError)
     end
   end
 end
diff --git a/Library/Homebrew/test/formulary_spec.rb b/Library/Homebrew/test/formulary_spec.rb
index 6276ecf876346..3e344cad5c30f 100644
--- a/Library/Homebrew/test/formulary_spec.rb
+++ b/Library/Homebrew/test/formulary_spec.rb
@@ -1,13 +1,12 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula"
 require "formula_installer"
 require "utils/bottles"
 
-describe Formulary do
+RSpec.describe Formulary do
   let(:formula_name) { "testball_bottle" }
-  let(:formula_path) { CoreTap.new.formula_dir/"#{formula_name}.rb" }
+  let(:formula_path) { CoreTap.instance.new_formula_path(formula_name) }
   let(:formula_content) do
     <<~RUBY
       class #{described_class.class_s(formula_name)} < Formula
@@ -16,7 +15,7 @@ class #{described_class.class_s(formula_name)} < Formula
 
         bottle do
           root_url "file://#{bottle_dir}"
-          sha256 cellar: :any_skip_relocation, #{Utils::Bottles.tag}: "8f9aecd233463da6a4ea55f5f88fc5841718c013f3e2a7941350d6130f1dc149"
+          sha256 cellar: :any_skip_relocation, #{Utils::Bottles.tag}: "d7b9f4e8bf83608b71fe958a99f19f2e5e68bb2582965d32e41759c24f1aef97"
         end
 
         def install
@@ -56,153 +55,240 @@ def install
   end
 
   describe "::factory" do
-    before do
-      formula_path.dirname.mkpath
-      formula_path.write formula_content
-    end
-
-    it "returns a Formula" do
-      expect(described_class.factory(formula_name)).to be_kind_of(Formula)
-    end
-
-    it "returns a Formula when given a fully qualified name" do
-      expect(described_class.factory("homebrew/core/#{formula_name}")).to be_kind_of(Formula)
-    end
-
-    it "raises an error if the Formula cannot be found" do
-      expect {
-        described_class.factory("not_existed_formula")
-      }.to raise_error(FormulaUnavailableError)
-    end
-
-    it "raises an error if ref is nil" do
-      expect {
-        described_class.factory(nil)
-      }.to raise_error(ArgumentError)
-    end
+    context "without the API" do
+      before do
+        formula_path.dirname.mkpath
+        formula_path.write formula_content
+      end
 
-    context "when the Formula has the wrong class" do
-      let(:formula_name) { "giraffe" }
-      let(:formula_content) do
-        <<~RUBY
-          class Wrong#{described_class.class_s(formula_name)} < Formula
-          end
-        RUBY
+      it "returns a Formula" do
+        expect(described_class.factory(formula_name)).to be_a(Formula)
       end
 
-      it "raises an error" do
-        expect {
-          described_class.factory(formula_name)
-        }.to raise_error(FormulaClassUnavailableError)
+      it "returns a Formula when given a fully qualified name" do
+        expect(described_class.factory("homebrew/core/#{formula_name}")).to be_a(Formula)
       end
-    end
 
-    it "returns a Formula when given a path" do
-      expect(described_class.factory(formula_path)).to be_kind_of(Formula)
-    end
+      it "raises an error if the Formula cannot be found" do
+        expect do
+          described_class.factory("not_existed_formula")
+        end.to raise_error(FormulaUnavailableError)
+      end
 
-    it "returns a Formula when given a URL" do
-      formula = described_class.factory("file://#{formula_path}")
-      expect(formula).to be_kind_of(Formula)
-    end
+      it "raises an error if ref is nil" do
+        expect do
+          described_class.factory(nil)
+        end.to raise_error(TypeError)
+      end
 
-    context "when given a bottle" do
-      subject(:formula) { described_class.factory(bottle) }
+      context "with sharded Formula directory" do
+        let(:formula_name) { "testball_sharded" }
+        let(:formula_path) do
+          core_tap = CoreTap.instance
+          (core_tap.formula_dir/formula_name[0]).mkpath
+          core_tap.new_formula_path(formula_name)
+        end
 
-      it "returns a Formula" do
-        expect(formula).to be_kind_of(Formula)
-      end
+        it "returns a Formula" do
+          expect(described_class.factory(formula_name)).to be_a(Formula)
+        end
 
-      it "calling #local_bottle_path on the returned Formula returns the bottle path" do
-        expect(formula.local_bottle_path).to eq(bottle.realpath)
+        it "returns a Formula when given a fully qualified name" do
+          expect(described_class.factory("homebrew/core/#{formula_name}")).to be_a(Formula)
+        end
       end
-    end
 
-    context "when given an alias" do
-      subject(:formula) { described_class.factory("foo") }
+      context "when the Formula has the wrong class" do
+        let(:formula_name) { "giraffe" }
+        let(:formula_content) do
+          <<~RUBY
+            class Wrong#{described_class.class_s(formula_name)} < Formula
+            end
+          RUBY
+        end
 
-      let(:alias_dir) { CoreTap.instance.alias_dir.tap(&:mkpath) }
-      let(:alias_path) { alias_dir/"foo" }
+        it "raises an error" do
+          expect do
+            described_class.factory(formula_name)
+          end.to raise_error(TapFormulaClassUnavailableError)
+        end
+      end
 
-      before do
-        alias_dir.mkpath
-        FileUtils.ln_s formula_path, alias_path
+      it "returns a Formula when given a path" do
+        expect(described_class.factory(formula_path)).to be_a(Formula)
       end
 
-      it "returns a Formula" do
-        expect(formula).to be_kind_of(Formula)
+      it "errors when given a path but paths are disabled" do
+        ENV["HOMEBREW_FORBID_PACKAGES_FROM_PATHS"] = "1"
+        FileUtils.cp formula_path, HOMEBREW_TEMP
+        temp_formula_path = HOMEBREW_TEMP/formula_path.basename
+        expect do
+          described_class.factory(temp_formula_path)
+        ensure
+          temp_formula_path.unlink
+        end.to raise_error(FormulaUnavailableError)
       end
 
-      it "calling #alias_path on the returned Formula returns the alias path" do
-        expect(formula.alias_path).to eq(alias_path.to_s)
+      it "returns a Formula when given a URL", :needs_utils_curl, :no_api do
+        formula = described_class.factory("file://#{formula_path}")
+        expect(formula).to be_a(Formula)
       end
-    end
 
-    context "with installed Formula" do
-      before do
-        allow(described_class).to receive(:loader_for).and_call_original
-        stub_formula_loader formula("gcc") { url "gcc-1.0" }
-        stub_formula_loader formula("gcc@5") { url "gcc-5.0" }
+      it "errors when given a URL but paths are disabled" do
+        ENV["HOMEBREW_FORBID_PACKAGES_FROM_PATHS"] = "1"
+        expect do
+          described_class.factory("file://#{formula_path}")
+        end.to raise_error(FormulaUnavailableError)
       end
 
-      let(:installed_formula) { described_class.factory(formula_path) }
-      let(:installer) { FormulaInstaller.new(installed_formula) }
+      context "when given a bottle" do
+        subject(:formula) { described_class.factory(bottle) }
 
-      it "returns a Formula when given a rack" do
-        installer.fetch
-        installer.install
+        it "returns a Formula" do
+          expect(formula).to be_a(Formula)
+        end
 
-        f = described_class.from_rack(installed_formula.rack)
-        expect(f).to be_kind_of(Formula)
+        it "calling #local_bottle_path on the returned Formula returns the bottle path" do
+          expect(formula.local_bottle_path).to eq(bottle.realpath)
+        end
       end
 
-      it "returns a Formula when given a Keg" do
-        installer.fetch
-        installer.install
+      context "when given an alias" do
+        subject(:formula) { described_class.factory("foo") }
 
-        keg = Keg.new(installed_formula.prefix)
-        f = described_class.from_keg(keg)
-        expect(f).to be_kind_of(Formula)
-      end
-    end
+        let(:alias_dir) { CoreTap.instance.alias_dir }
+        let(:alias_path) { alias_dir/"foo" }
 
-    context "when loading from Tap" do
-      let(:tap) { Tap.new("homebrew", "foo") }
-      let(:another_tap) { Tap.new("homebrew", "bar") }
-      let(:formula_path) { tap.path/"#{formula_name}.rb" }
+        before do
+          alias_dir.mkpath
+          FileUtils.ln_s formula_path, alias_path
+        end
 
-      it "returns a Formula when given a name" do
-        expect(described_class.factory(formula_name)).to be_kind_of(Formula)
-      end
+        it "returns a Formula" do
+          expect(formula).to be_a(Formula)
+        end
 
-      it "returns a Formula from an Alias path" do
-        alias_dir = tap.path/"Aliases"
-        alias_dir.mkpath
-        FileUtils.ln_s formula_path, alias_dir/"bar"
-        expect(described_class.factory("bar")).to be_kind_of(Formula)
+        it "calling #alias_path on the returned Formula returns the alias path" do
+          expect(formula.alias_path).to eq(alias_path)
+        end
       end
 
-      it "raises an error when the Formula cannot be found" do
-        expect {
-          described_class.factory("#{tap}/not_existed_formula")
-        }.to raise_error(TapFormulaUnavailableError)
+      context "with installed Formula" do
+        before do
+          # don't try to load/fetch gcc/glibc
+          allow(DevelopmentTools).to receive_messages(needs_libc_formula?: false, needs_compiler_formula?: false)
+        end
+
+        let(:installed_formula) { described_class.factory(formula_path) }
+        let(:installer) { FormulaInstaller.new(installed_formula) }
+
+        it "returns a Formula when given a rack" do
+          installer.fetch
+          installer.install
+
+          f = described_class.from_rack(installed_formula.rack)
+          expect(f).to be_a(Formula)
+        end
+
+        it "returns a Formula when given a Keg" do
+          installer.fetch
+          installer.install
+
+          keg = Keg.new(installed_formula.prefix)
+          f = described_class.from_keg(keg)
+          expect(f).to be_a(Formula)
+        end
       end
 
-      it "returns a Formula when given a fully qualified name" do
-        expect(described_class.factory("#{tap}/#{formula_name}")).to be_kind_of(Formula)
+      context "when migrating from a Tap" do
+        let(:tap) { Tap.fetch("homebrew", "foo") }
+        let(:another_tap) { Tap.fetch("homebrew", "bar") }
+        let(:tap_migrations_path) { tap.path/"tap_migrations.json" }
+        let(:another_tap_formula_path) { another_tap.path/"Formula/#{formula_name}.rb" }
+
+        before do
+          tap.path.mkpath
+          another_tap_formula_path.dirname.mkpath
+          another_tap_formula_path.write formula_content
+        end
+
+        after do
+          FileUtils.rm_rf tap.path
+          FileUtils.rm_rf another_tap.path
+        end
+
+        it "returns a Formula that has gone through a tap migration into homebrew/core" do
+          tap_migrations_path.write <<~EOS
+            {
+              "#{formula_name}": "homebrew/core"
+            }
+          EOS
+          formula = described_class.factory("#{tap}/#{formula_name}")
+          expect(formula).to be_a(Formula)
+          expect(formula.tap).to eq(CoreTap.instance)
+          expect(formula.path).to eq(formula_path)
+        end
+
+        it "returns a Formula that has gone through a tap migration into another tap" do
+          tap_migrations_path.write <<~EOS
+            {
+              "#{formula_name}": "#{another_tap}"
+            }
+          EOS
+          formula = described_class.factory("#{tap}/#{formula_name}")
+          expect(formula).to be_a(Formula)
+          expect(formula.tap).to eq(another_tap)
+          expect(formula.path).to eq(another_tap_formula_path)
+        end
       end
 
-      it "raises an error if a Formula is in multiple Taps" do
-        another_tap.path.mkpath
-        (another_tap.path/"#{formula_name}.rb").write formula_content
+      context "when loading from Tap" do
+        let(:tap) { Tap.fetch("homebrew", "foo") }
+        let(:another_tap) { Tap.fetch("homebrew", "bar") }
+        let(:formula_path) { tap.path/"Formula/#{formula_name}.rb" }
+        let(:alias_name) { "bar" }
+        let(:alias_dir) { tap.alias_dir }
+        let(:alias_path) { alias_dir/alias_name }
+
+        before do
+          alias_dir.mkpath
+          FileUtils.ln_s formula_path, alias_path
+        end
+
+        it "returns a Formula when given a name" do
+          expect(described_class.factory(formula_name)).to be_a(Formula)
+        end
+
+        it "returns a Formula from an Alias path" do
+          expect(described_class.factory(alias_name)).to be_a(Formula)
+        end
 
-        expect {
-          described_class.factory(formula_name)
-        }.to raise_error(TapFormulaAmbiguityError)
+        it "returns a Formula from a fully qualified Alias path" do
+          expect(described_class.factory("#{tap.name}/#{alias_name}")).to be_a(Formula)
+        end
+
+        it "raises an error when the Formula cannot be found" do
+          expect do
+            described_class.factory("#{tap}/not_existed_formula")
+          end.to raise_error(TapFormulaUnavailableError)
+        end
+
+        it "returns a Formula when given a fully qualified name" do
+          expect(described_class.factory("#{tap}/#{formula_name}")).to be_a(Formula)
+        end
+
+        it "raises an error if a Formula is in multiple Taps" do
+          (another_tap.path/"Formula").mkpath
+          (another_tap.path/"Formula/#{formula_name}.rb").write formula_content
+
+          expect do
+            described_class.factory(formula_name)
+          end.to raise_error(TapFormulaAmbiguityError)
+        end
       end
     end
 
-    context "when loading from the API" do
+    context "with the API" do
       def formula_json_contents(extra_items = {})
         {
           formula_name => {
@@ -227,7 +313,7 @@ def formula_json_contents(extra_items = {})
                   Utils::Bottles.tag.to_s => {
                     "cellar" => ":any",
                     "url"    => "file://#{bottle_dir}/#{formula_name}",
-                    "sha256" => "8f9aecd233463da6a4ea55f5f88fc5841718c013f3e2a7941350d6130f1dc149",
+                    "sha256" => "d7b9f4e8bf83608b71fe958a99f19f2e5e68bb2582965d32e41759c24f1aef97",
                   },
                 },
               },
@@ -238,10 +324,31 @@ def formula_json_contents(extra_items = {})
             },
             "build_dependencies"       => ["build_dep"],
             "dependencies"             => ["dep"],
+            "test_dependencies"        => ["test_dep"],
             "recommended_dependencies" => ["recommended_dep"],
             "optional_dependencies"    => ["optional_dep"],
             "uses_from_macos"          => ["uses_from_macos_dep"],
-            "caveats"                  => "example caveat string",
+            "requirements"             => [
+              {
+                "name"     => "xcode",
+                "cask"     => nil,
+                "download" => nil,
+                "version"  => "1.0",
+                "contexts" => ["build"],
+              },
+            ],
+            "conflicts_with"           => ["conflicting_formula"],
+            "conflicts_with_reasons"   => ["it does"],
+            "link_overwrite"           => ["bin/abc"],
+            "caveats"                  => "example caveat string\n/$HOME\n$HOMEBREW_PREFIX",
+            "service"                  => {
+              "name"        => { macos: "custom.launchd.name", linux: "custom.systemd.name" },
+              "run"         => ["$HOMEBREW_PREFIX/opt/formula_name/bin/beanstalkd", "test"],
+              "run_type"    => "immediate",
+              "working_dir" => "/$HOME",
+            },
+            "ruby_source_path"         => "Formula/#{formula_name}.rb",
+            "ruby_source_checksum"     => { "sha256" => "ABCDEFGHIJKLMNOPQRSTUVWXYZ" },
           }.merge(extra_items),
         }
       end
@@ -260,54 +367,224 @@ def formula_json_contents(extra_items = {})
         }
       end
 
+      let(:variations_json) do
+        {
+          "variations" => {
+            Utils::Bottles.tag.to_s => {
+              "dependencies" => ["dep", "variations_dep"],
+            },
+          },
+        }
+      end
+
+      let(:older_macos_variations_json) do
+        {
+          "variations" => {
+            Utils::Bottles.tag.to_s => {
+              "dependencies" => ["uses_from_macos_dep"],
+            },
+          },
+        }
+      end
+
+      let(:linux_variations_json) do
+        {
+          "variations" => {
+            "x86_64_linux" => {
+              "dependencies" => ["dep", "uses_from_macos_dep"],
+            },
+          },
+        }
+      end
+
       before do
-        allow(described_class).to receive(:loader_for).and_return(described_class::FormulaAPILoader.new(formula_name))
+        ENV.delete("HOMEBREW_NO_INSTALL_FROM_API")
+
+        # avoid unnecessary network calls
+        allow(Homebrew::API::Formula).to receive_messages(all_aliases: {}, all_renames: {})
+        allow(CoreTap.instance).to receive(:tap_migrations).and_return({})
+        allow(CoreCaskTap.instance).to receive(:tap_migrations).and_return({})
+
+        # don't try to load/fetch gcc/glibc
+        allow(DevelopmentTools).to receive_messages(needs_libc_formula?: false, needs_compiler_formula?: false)
       end
 
       it "returns a Formula when given a name" do
         allow(Homebrew::API::Formula).to receive(:all_formulae).and_return formula_json_contents
 
         formula = described_class.factory(formula_name)
-        expect(formula).to be_kind_of(Formula)
+        expect(formula).to be_a(Formula)
+
         expect(formula.keg_only_reason.reason).to eq :provided_by_macos
+        expect(formula.declared_deps.count).to eq 6
         if OS.mac?
-          expect(formula.deps.count).to eq 4
-        elsif OS.linux?
           expect(formula.deps.count).to eq 5
+        else
+          expect(formula.deps.count).to eq 6
         end
-        expect(formula.uses_from_macos_elements).to eq ["uses_from_macos_dep"]
-        expect(formula.caveats).to eq "example caveat string"
-        expect {
+
+        expect(formula.requirements.count).to eq 1
+        req = formula.requirements.first
+        expect(req).to be_an_instance_of XcodeRequirement
+        expect(req.version).to eq "1.0"
+        expect(req.tags).to eq [:build]
+
+        expect(formula.conflicts.map(&:name)).to include "conflicting_formula"
+        expect(formula.conflicts.map(&:reason)).to include "it does"
+        expect(formula.class.link_overwrite_paths).to include "bin/abc"
+
+        expect(formula.caveats).to eq "example caveat string\n#{Dir.home}\n#{HOMEBREW_PREFIX}"
+
+        expect(formula).to be_a_service
+        expect(formula.service.command).to eq(["#{HOMEBREW_PREFIX}/opt/formula_name/bin/beanstalkd", "test"])
+        expect(formula.service.run_type).to eq(:immediate)
+        expect(formula.service.working_dir).to eq(Dir.home)
+        expect(formula.plist_name).to eq("custom.launchd.name")
+        expect(formula.service_name).to eq("custom.systemd.name")
+
+        expect(formula.ruby_source_checksum.hexdigest).to eq("abcdefghijklmnopqrstuvwxyz")
+
+        expect do
           formula.install
-        }.to raise_error("Cannot build from source from abstract formula.")
+        end.to raise_error("Cannot build from source from abstract formula.")
       end
 
       it "returns a deprecated Formula when given a name" do
         allow(Homebrew::API::Formula).to receive(:all_formulae).and_return formula_json_contents(deprecate_json)
 
         formula = described_class.factory(formula_name)
-        expect(formula).to be_kind_of(Formula)
+        expect(formula).to be_a(Formula)
         expect(formula.deprecated?).to be true
-        expect {
+        expect do
           formula.install
-        }.to raise_error("Cannot build from source from abstract formula.")
+        end.to raise_error("Cannot build from source from abstract formula.")
       end
 
       it "returns a disabled Formula when given a name" do
         allow(Homebrew::API::Formula).to receive(:all_formulae).and_return formula_json_contents(disable_json)
 
         formula = described_class.factory(formula_name)
-        expect(formula).to be_kind_of(Formula)
+        expect(formula).to be_a(Formula)
         expect(formula.disabled?).to be true
-        expect {
+        expect do
           formula.install
-        }.to raise_error("Cannot build from source from abstract formula.")
+        end.to raise_error("Cannot build from source from abstract formula.")
+      end
+
+      it "returns a Formula with variations when given a name", :needs_macos do
+        allow(Homebrew::API::Formula).to receive(:all_formulae).and_return formula_json_contents(variations_json)
+
+        formula = described_class.factory(formula_name)
+        expect(formula).to be_a(Formula)
+        expect(formula.declared_deps.count).to eq 7
+        expect(formula.deps.count).to eq 6
+        expect(formula.deps.map(&:name).include?("variations_dep")).to be true
+        expect(formula.deps.map(&:name).include?("uses_from_macos_dep")).to be false
+      end
+
+      it "returns a Formula without duplicated deps and uses_from_macos with variations on Linux", :needs_linux do
+        allow(Homebrew::API::Formula)
+          .to receive(:all_formulae).and_return formula_json_contents(linux_variations_json)
+
+        formula = described_class.factory(formula_name)
+        expect(formula).to be_a(Formula)
+        expect(formula.declared_deps.count).to eq 6
+        expect(formula.deps.count).to eq 6
+        expect(formula.deps.map(&:name).include?("uses_from_macos_dep")).to be true
+      end
+
+      it "returns a Formula with the correct uses_from_macos dep on older macOS", :needs_macos do
+        allow(Homebrew::API::Formula)
+          .to receive(:all_formulae).and_return formula_json_contents(older_macos_variations_json)
+
+        formula = described_class.factory(formula_name)
+        expect(formula).to be_a(Formula)
+        expect(formula.declared_deps.count).to eq 6
+        expect(formula.deps.count).to eq 5
+        expect(formula.deps.map(&:name).include?("uses_from_macos_dep")).to be true
+      end
+
+      context "with core tap migration renames" do
+        let(:foo_tap) { Tap.fetch("homebrew", "foo") }
+
+        before do
+          allow(Homebrew::API::Formula).to receive(:all_formulae).and_return formula_json_contents
+          foo_tap.path.mkpath
+        end
+
+        after do
+          FileUtils.rm_rf foo_tap.path
+        end
+
+        it "returns the tap migration rename by old formula_name" do
+          old_formula_name = "#{formula_name}-old"
+          (foo_tap.path/"tap_migrations.json").write <<~JSON
+            { "#{old_formula_name}": "homebrew/core/#{formula_name}" }
+          JSON
+
+          loader = described_class::FromNameLoader.try_new(old_formula_name)
+          expect(loader).to be_a(described_class::FromAPILoader)
+          expect(loader.name).to eq formula_name
+          expect(loader.path).not_to exist
+        end
+
+        it "returns the tap migration rename by old full name" do
+          old_formula_name = "#{formula_name}-old"
+          (foo_tap.path/"tap_migrations.json").write <<~JSON
+            { "#{old_formula_name}": "homebrew/core/#{formula_name}" }
+          JSON
+
+          loader = described_class::FromTapLoader.try_new("#{foo_tap}/#{old_formula_name}")
+          expect(loader).to be_a(described_class::FromAPILoader)
+          expect(loader.name).to eq formula_name
+          expect(loader.path).not_to exist
+        end
+      end
+    end
+
+    context "when passed a URL" do
+      it "raises an error when given an https URL" do
+        expect do
+          described_class.factory("https://brew.sh/foo.rb")
+        end.to raise_error(UnsupportedInstallationMethod)
+      end
+
+      it "raises an error when given a bottle URL" do
+        expect do
+          described_class.factory("https://brew.sh/foo-1.0.arm64_catalina.bottle.tar.gz")
+        end.to raise_error(UnsupportedInstallationMethod)
+      end
+
+      it "raises an error when given an ftp URL" do
+        expect do
+          described_class.factory("ftp://brew.sh/foo.rb")
+        end.to raise_error(UnsupportedInstallationMethod)
+      end
+
+      it "raises an error when given an sftp URL" do
+        expect do
+          described_class.factory("sftp://brew.sh/foo.rb")
+        end.to raise_error(UnsupportedInstallationMethod)
+      end
+
+      it "does not raise an error when given a file URL" do
+        expect do
+          described_class.factory("file://#{TEST_FIXTURE_DIR}/testball.rb")
+        end.not_to raise_error(UnsupportedInstallationMethod)
+      end
+    end
+
+    context "when passed ref with spaces" do
+      it "raises a FormulaUnavailableError error" do
+        expect do
+          described_class.factory("foo bar")
+        end.to raise_error(FormulaUnavailableError)
       end
     end
   end
 
   specify "::from_contents" do
-    expect(described_class.from_contents(formula_name, formula_path, formula_content)).to be_kind_of(Formula)
+    expect(described_class.from_contents(formula_name, formula_path, formula_content)).to be_a(Formula)
   end
 
   describe "::to_rack" do
@@ -332,9 +609,9 @@ def formula_json_contents(extra_items = {})
     end
 
     it "raises an error if the Formula is not available" do
-      expect {
+      expect do
         described_class.to_rack("a/b/#{formula_name}")
-      }.to raise_error(TapFormulaUnavailableError)
+      end.to raise_error(TapFormulaUnavailableError)
     end
   end
 
@@ -356,14 +633,152 @@ def formula_json_contents(extra_items = {})
     end
   end
 
-  describe "::convert_to_deprecate_disable_reason_string_or_symbol" do
-    it "returns the original string if it isn't a preset reason" do
-      expect(described_class.convert_to_deprecate_disable_reason_string_or_symbol("foo")).to eq "foo"
+  describe "::loader_for" do
+    context "when given a relative path with two slashes" do
+      it "returns a `FromPathLoader`" do
+        mktmpdir.cd do
+          FileUtils.mkdir "Formula"
+          FileUtils.touch "Formula/gcc.rb"
+          expect(described_class.loader_for("./Formula/gcc.rb")).to be_a Formulary::FromPathLoader
+        end
+      end
+    end
+
+    context "when given a tapped name" do
+      it "returns a `FromTapLoader`" do
+        expect(described_class.loader_for("homebrew/core/gcc")).to be_a Formulary::FromTapLoader
+      end
     end
 
-    it "returns a symbol if the original string is a preset reason" do
-      expect(described_class.convert_to_deprecate_disable_reason_string_or_symbol("does_not_build"))
-        .to eq :does_not_build
+    context "when not using the API" do
+      before do
+        ENV["HOMEBREW_NO_INSTALL_FROM_API"] = "1"
+      end
+
+      context "when a formula is migrated" do
+        let(:token) { "foo" }
+
+        let(:core_tap) { CoreTap.instance }
+        let(:core_cask_tap) { CoreCaskTap.instance }
+
+        let(:tap_migrations) do
+          {
+            token => new_tap.name,
+          }
+        end
+
+        before do
+          old_tap.path.mkpath
+          new_tap.path.mkpath
+          (old_tap.path/"tap_migrations.json").write tap_migrations.to_json
+        end
+
+        context "to a cask in the default tap" do
+          let(:old_tap) { core_tap }
+          let(:new_tap) { core_cask_tap }
+
+          let(:cask_file) { new_tap.cask_dir/"#{token}.rb" }
+
+          before do
+            new_tap.cask_dir.mkpath
+            FileUtils.touch cask_file
+          end
+
+          it "warn only once" do
+            expect do
+              described_class.loader_for(token)
+            end.to output(
+              a_string_including("Warning: Formula #{token} was renamed to #{new_tap}/#{token}.").once,
+            ).to_stderr
+          end
+        end
+
+        context "to the default tap" do
+          let(:old_tap) { core_cask_tap }
+          let(:new_tap) { core_tap }
+
+          let(:formula_file) { new_tap.formula_dir/"#{token}.rb" }
+
+          before do
+            new_tap.formula_dir.mkpath
+            FileUtils.touch formula_file
+          end
+
+          it "does not warn when loading the short token" do
+            expect do
+              described_class.loader_for(token)
+            end.not_to output.to_stderr
+          end
+
+          it "does not warn when loading the full token in the default tap" do
+            expect do
+              described_class.loader_for("#{new_tap}/#{token}")
+            end.not_to output.to_stderr
+          end
+
+          it "warns when loading the full token in the old tap" do
+            expect do
+              described_class.loader_for("#{old_tap}/#{token}")
+            end.to output(
+              a_string_including("Formula #{old_tap}/#{token} was renamed to #{token}.").once,
+            ).to_stderr
+          end
+
+          # FIXME
+          # context "when there is an infinite tap migration loop" do
+          #   before do
+          #     (new_tap.path/"tap_migrations.json").write({
+          #       token => old_tap.name,
+          #     }.to_json)
+          #   end
+          #
+          #   it "stops recursing" do
+          #     expect do
+          #       described_class.loader_for("#{new_tap}/#{token}")
+          #     end.not_to output.to_stderr
+          #   end
+          # end
+        end
+
+        context "to a third-party tap" do
+          let(:old_tap) { Tap.fetch("another", "foo") }
+          let(:new_tap) { Tap.fetch("another", "bar") }
+          let(:formula_file) { new_tap.formula_dir/"#{token}.rb" }
+
+          before do
+            new_tap.formula_dir.mkpath
+            FileUtils.touch formula_file
+          end
+
+          after do
+            FileUtils.rm_rf HOMEBREW_TAP_DIRECTORY/"another"
+          end
+
+          # FIXME
+          # It would be preferable not to print a warning when installing with the short token
+          it "warns when loading the short token" do
+            expect do
+              described_class.loader_for(token)
+            end.to output(
+              a_string_including("Formula #{old_tap}/#{token} was renamed to #{new_tap}/#{token}.").once,
+            ).to_stderr
+          end
+
+          it "does not warn when loading the full token in the new tap" do
+            expect do
+              described_class.loader_for("#{new_tap}/#{token}")
+            end.not_to output.to_stderr
+          end
+
+          it "warns when loading the full token in the old tap" do
+            expect do
+              described_class.loader_for("#{old_tap}/#{token}")
+            end.to output(
+              a_string_including("Formula #{old_tap}/#{token} was renamed to #{new_tap}/#{token}.").once,
+            ).to_stderr
+          end
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/test/free_port_spec.rb b/Library/Homebrew/test/free_port_spec.rb
new file mode 100644
index 0000000000000..94d3059685b54
--- /dev/null
+++ b/Library/Homebrew/test/free_port_spec.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "socket"
+require "formula_free_port"
+
+RSpec.describe Homebrew::FreePort do
+  include described_class
+
+  describe "#free_port" do
+    it "returns a free TCP/IP port" do
+      # IANA suggests user port from 1024 to 49151
+      # and dynamic port for 49152 to 65535
+      # http://www.iana.org/assignments/port-numbers
+      min_port = 1024
+      max_port = 65535
+      port = free_port
+
+      expect(port).to be_between(min_port, max_port)
+      expect { TCPServer.new(port).close }.not_to raise_error
+    end
+  end
+end
diff --git a/Library/Homebrew/test/github_runner_matrix_spec.rb b/Library/Homebrew/test/github_runner_matrix_spec.rb
new file mode 100644
index 0000000000000..d314f3522b78d
--- /dev/null
+++ b/Library/Homebrew/test/github_runner_matrix_spec.rb
@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+require "github_runner_matrix"
+require "test/support/fixtures/testball"
+
+RSpec.describe GitHubRunnerMatrix do
+  before do
+    allow(ENV).to receive(:fetch).with("HOMEBREW_LINUX_RUNNER").and_return("ubuntu-latest")
+    allow(ENV).to receive(:fetch).with("HOMEBREW_MACOS_LONG_TIMEOUT", "false").and_return("false")
+    allow(ENV).to receive(:fetch).with("HOMEBREW_MACOS_BUILD_ON_GITHUB_RUNNER", "false").and_return("false")
+    allow(ENV).to receive(:fetch).with("GITHUB_RUN_ID").and_return("12345")
+    allow(ENV).to receive(:fetch).with("HOMEBREW_NO_INSTALL_FROM_API", nil).and_call_original
+    allow(ENV).to receive(:fetch).with("HOMEBREW_EVAL_ALL", nil).and_call_original
+    allow(ENV).to receive(:fetch).with("HOMEBREW_SIMULATE_MACOS_ON_LINUX", nil).and_call_original
+    allow(ENV).to receive(:fetch).with("HOMEBREW_FORBID_PACKAGES_FROM_PATHS", nil).and_call_original
+  end
+
+  let(:newest_supported_macos) do
+    MacOSVersion::SYMBOLS.find { |k, _| k == described_class::NEWEST_HOMEBREW_CORE_MACOS_RUNNER }
+  end
+
+  let(:testball) { TestRunnerFormula.new(Testball.new) }
+  let(:testball_depender) { setup_test_runner_formula("testball-depender", ["testball"]) }
+  let(:testball_depender_linux) { setup_test_runner_formula("testball-depender-linux", ["testball", :linux]) }
+  let(:testball_depender_macos) { setup_test_runner_formula("testball-depender-macos", ["testball", :macos]) }
+  let(:testball_depender_intel) do
+    setup_test_runner_formula("testball-depender-intel", ["testball", { arch: :x86_64 }])
+  end
+  let(:testball_depender_arm) { setup_test_runner_formula("testball-depender-arm", ["testball", { arch: :arm64 }]) }
+  let(:testball_depender_newest) do
+    symbol, = newest_supported_macos
+    setup_test_runner_formula("testball-depender-newest", ["testball", { macos: symbol }])
+  end
+
+  describe "#active_runner_specs_hash" do
+    it "returns an object that responds to `#to_json`" do
+      expect(
+        described_class.new([], ["deleted"], all_supported: false, dependent_matrix: false)
+                       .active_runner_specs_hash
+                       .respond_to?(:to_json),
+      ).to be(true)
+    end
+  end
+
+  describe "#generate_runners!" do
+    it "is idempotent" do
+      matrix = described_class.new([], [], all_supported: false, dependent_matrix: false)
+      runners = matrix.runners.dup
+      matrix.send(:generate_runners!)
+
+      expect(matrix.runners).to eq(runners)
+    end
+  end
+
+  context "when there are no testing formulae and no deleted formulae" do
+    it "activates no test runners" do
+      expect(described_class.new([], [], all_supported: false, dependent_matrix: false).runners.any?(&:active))
+        .to be(false)
+    end
+
+    it "activates no dependent runners" do
+      expect(described_class.new([], [], all_supported: false, dependent_matrix: true).runners.any?(&:active))
+        .to be(false)
+    end
+  end
+
+  context "when passed `--all-supported`" do
+    it "activates all runners" do
+      expect(described_class.new([], [], all_supported: true, dependent_matrix: false).runners.all?(&:active))
+        .to be(true)
+    end
+  end
+
+  context "when there are testing formulae and no deleted formulae" do
+    context "when it is a matrix for the `tests` job" do
+      context "when testing formulae have no requirements" do
+        it "activates all runners" do
+          expect(described_class.new([testball], [], all_supported: false, dependent_matrix: false)
+                                .runners
+                                .all?(&:active))
+            .to be(true)
+        end
+      end
+
+      context "when testing formulae require Linux" do
+        it "activates only the Linux runner" do
+          runner_matrix = described_class.new([testball_depender_linux], [],
+                                              all_supported:    false,
+                                              dependent_matrix: false)
+
+          expect(runner_matrix.runners.all?(&:active)).to be(false)
+          expect(runner_matrix.runners.any?(&:active)).to be(true)
+          expect(get_runner_names(runner_matrix)).to eq(["Linux"])
+        end
+      end
+
+      context "when testing formulae require macOS" do
+        it "activates only the macOS runners" do
+          runner_matrix = described_class.new([testball_depender_macos], [],
+                                              all_supported:    false,
+                                              dependent_matrix: false)
+
+          expect(runner_matrix.runners.all?(&:active)).to be(false)
+          expect(runner_matrix.runners.any?(&:active)).to be(true)
+          expect(get_runner_names(runner_matrix)).to eq(get_runner_names(runner_matrix, :macos?))
+        end
+      end
+
+      context "when testing formulae require Intel" do
+        it "activates only the Intel runners" do
+          runner_matrix = described_class.new([testball_depender_intel], [],
+                                              all_supported:    false,
+                                              dependent_matrix: false)
+
+          expect(runner_matrix.runners.all?(&:active)).to be(false)
+          expect(runner_matrix.runners.any?(&:active)).to be(true)
+          expect(get_runner_names(runner_matrix)).to eq(get_runner_names(runner_matrix, :x86_64?))
+        end
+      end
+
+      context "when testing formulae require ARM" do
+        it "activates only the ARM runners" do
+          runner_matrix = described_class.new([testball_depender_arm], [],
+                                              all_supported:    false,
+                                              dependent_matrix: false)
+
+          expect(runner_matrix.runners.all?(&:active)).to be(false)
+          expect(runner_matrix.runners.any?(&:active)).to be(true)
+          expect(get_runner_names(runner_matrix)).to eq(get_runner_names(runner_matrix, :arm64?))
+        end
+      end
+
+      context "when testing formulae require a macOS version" do
+        it "activates the Linux runner and suitable macOS runners" do
+          _, v = newest_supported_macos
+          runner_matrix = described_class.new([testball_depender_newest], [],
+                                              all_supported:    false,
+                                              dependent_matrix: false)
+
+          expect(runner_matrix.runners.all?(&:active)).to be(false)
+          expect(runner_matrix.runners.any?(&:active)).to be(true)
+          expect(get_runner_names(runner_matrix).sort).to eq(["Linux", "macOS #{v}-arm64"])
+        end
+      end
+    end
+
+    context "when it is a matrix for the `test_deps` job" do
+      context "when testing formulae have no dependents" do
+        it "activates no runners" do
+          allow(Homebrew::EnvConfig).to receive(:eval_all?).and_return(true)
+          allow(Formula).to receive(:all).and_return([testball].map(&:formula))
+
+          expect(described_class.new([testball], [], all_supported: false, dependent_matrix: true)
+                                .runners
+                                .any?(&:active))
+            .to be(false)
+        end
+      end
+
+      context "when testing formulae have dependents" do
+        context "when dependents have no requirements" do
+          it "activates all runners" do
+            allow(Homebrew::EnvConfig).to receive(:eval_all?).and_return(true)
+            allow(Formula).to receive(:all).and_return([testball, testball_depender].map(&:formula))
+
+            expect(described_class.new([testball], [], all_supported: false, dependent_matrix: true)
+                                  .runners
+                                  .all?(&:active))
+              .to be(true)
+          end
+        end
+
+        context "when dependents require Linux" do
+          it "activates only Linux runners" do
+            allow(Homebrew::EnvConfig).to receive(:eval_all?).and_return(true)
+            allow(Formula).to receive(:all).and_return([testball, testball_depender_linux].map(&:formula))
+
+            runner_matrix = described_class.new([testball], [], all_supported: false, dependent_matrix: true)
+            expect(runner_matrix.runners.all?(&:active)).to be(false)
+            expect(runner_matrix.runners.any?(&:active)).to be(true)
+            expect(get_runner_names(runner_matrix)).to eq(get_runner_names(runner_matrix, :linux?))
+          end
+        end
+
+        context "when dependents require macOS" do
+          it "activates only macOS runners" do
+            allow(Homebrew::EnvConfig).to receive(:eval_all?).and_return(true)
+            allow(Formula).to receive(:all).and_return([testball, testball_depender_macos].map(&:formula))
+
+            runner_matrix = described_class.new([testball], [], all_supported: false, dependent_matrix: true)
+            expect(runner_matrix.runners.all?(&:active)).to be(false)
+            expect(runner_matrix.runners.any?(&:active)).to be(true)
+            expect(get_runner_names(runner_matrix)).to eq(get_runner_names(runner_matrix, :macos?))
+          end
+        end
+
+        context "when dependents require an Intel architecture" do
+          it "activates only Intel runners" do
+            allow(Homebrew::EnvConfig).to receive(:eval_all?).and_return(true)
+            allow(Formula).to receive(:all).and_return([testball, testball_depender_intel].map(&:formula))
+
+            runner_matrix = described_class.new([testball], [], all_supported: false, dependent_matrix: true)
+            expect(runner_matrix.runners.all?(&:active)).to be(false)
+            expect(runner_matrix.runners.any?(&:active)).to be(true)
+            expect(get_runner_names(runner_matrix)).to eq(get_runner_names(runner_matrix, :x86_64?))
+          end
+        end
+
+        context "when dependents require an ARM architecture" do
+          it "activates only ARM runners" do
+            allow(Homebrew::EnvConfig).to receive(:eval_all?).and_return(true)
+            allow(Formula).to receive(:all).and_return([testball, testball_depender_arm].map(&:formula))
+
+            runner_matrix = described_class.new([testball], [], all_supported: false, dependent_matrix: true)
+            expect(runner_matrix.runners.all?(&:active)).to be(false)
+            expect(runner_matrix.runners.any?(&:active)).to be(true)
+            expect(get_runner_names(runner_matrix)).to eq(get_runner_names(runner_matrix, :arm64?))
+          end
+        end
+      end
+    end
+  end
+
+  context "when there are deleted formulae" do
+    context "when it is a matrix for the `tests` job" do
+      it "activates all runners" do
+        expect(described_class.new([], ["deleted"], all_supported: false, dependent_matrix: false)
+                              .runners
+                              .all?(&:active))
+          .to be(true)
+      end
+    end
+
+    context "when it is a matrix for the `test_deps` job" do
+      context "when there are no testing formulae" do
+        it "activates no runners" do
+          expect(described_class.new([], ["deleted"], all_supported: false, dependent_matrix: true)
+                                .runners
+                                .any?(&:active))
+            .to be(false)
+        end
+      end
+
+      context "when there are testing formulae with no dependents" do
+        it "activates no runners" do
+          testing_formulae = [testball]
+          runner_matrix = described_class.new(testing_formulae, ["deleted"],
+                                              all_supported:    false,
+                                              dependent_matrix: true)
+
+          allow(Homebrew::EnvConfig).to receive(:eval_all?).and_return(true)
+          allow(Formula).to receive(:all).and_return(testing_formulae.map(&:formula))
+
+          expect(runner_matrix.runners.none?(&:active)).to be(true)
+        end
+      end
+
+      context "when there are testing formulae with dependents" do
+        context "when dependent formulae have no requirements" do
+          it "activates the applicable runners" do
+            allow(Homebrew::EnvConfig).to receive(:eval_all?).and_return(true)
+            allow(Formula).to receive(:all).and_return([testball, testball_depender].map(&:formula))
+
+            testing_formulae = [testball]
+            expect(described_class.new(testing_formulae, ["deleted"], all_supported: false, dependent_matrix: true)
+                                  .runners
+                                  .all?(&:active))
+              .to be(true)
+          end
+        end
+
+        context "when dependent formulae have requirements" do
+          context "when dependent formulae require Linux" do
+            it "activates the applicable runners" do
+              allow(Homebrew::EnvConfig).to receive(:eval_all?).and_return(true)
+              allow(Formula).to receive(:all).and_return([testball, testball_depender_linux].map(&:formula))
+
+              matrix = described_class.new([testball], ["deleted"], all_supported: false, dependent_matrix: true)
+              expect(get_runner_names(matrix)).to eq(["Linux"])
+            end
+          end
+
+          context "when dependent formulae require macOS" do
+            it "activates the applicable runners" do
+              allow(Homebrew::EnvConfig).to receive(:eval_all?).and_return(true)
+              allow(Formula).to receive(:all).and_return([testball, testball_depender_macos].map(&:formula))
+
+              matrix = described_class.new([testball], ["deleted"], all_supported: false, dependent_matrix: true)
+              expect(get_runner_names(matrix)).to eq(get_runner_names(matrix, :macos?))
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def get_runner_names(runner_matrix, predicate = :active)
+    runner_matrix.runners
+                 .select(&predicate)
+                 .map { |runner| runner.spec.name }
+  end
+
+  def setup_test_runner_formula(name, dependencies = [], **kwargs)
+    f = formula name do
+      url "https://brew.sh/#{name}-1.0.tar.gz"
+      dependencies.each { |dependency| depends_on dependency }
+
+      kwargs.each do |k, v|
+        send(:"on_#{k}") do
+          v.each do |dep|
+            depends_on dep
+          end
+        end
+      end
+    end
+
+    TestRunnerFormula.new(f)
+  end
+end
diff --git a/Library/Homebrew/test/github_runner_spec.rb b/Library/Homebrew/test/github_runner_spec.rb
new file mode 100644
index 0000000000000..3e35126ba9594
--- /dev/null
+++ b/Library/Homebrew/test/github_runner_spec.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "github_runner"
+
+RSpec.describe GitHubRunner do
+  let(:runner) do
+    spec = MacOSRunnerSpec.new(name: "macOS 11-arm64", runner: "11-arm64", timeout: 90, cleanup: true)
+    version = MacOSVersion.new("11")
+    described_class.new(platform: :macos, arch: :arm64, spec:, macos_version: version)
+  end
+
+  it "has immutable attributes" do
+    [:platform, :arch, :spec, :macos_version].each do |attribute|
+      expect(runner.respond_to?(:"#{attribute}=")).to be(false)
+    end
+  end
+
+  it "is inactive by default" do
+    expect(runner.active).to be(false)
+  end
+
+  describe "#macos?" do
+    it "returns true if the runner is a macOS runner" do
+      expect(runner.macos?).to be(true)
+    end
+  end
+
+  describe "#linux?" do
+    it "returns false if the runner is a macOS runner" do
+      expect(runner.linux?).to be(false)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/global_spec.rb b/Library/Homebrew/test/global_spec.rb
index 6c34ca88389e4..a28374ef21a46 100644
--- a/Library/Homebrew/test/global_spec.rb
+++ b/Library/Homebrew/test/global_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
-describe "brew", :integration_test do
-  it "does not invoke `require \"formula\"` at startup" do
-    expect { brew "verify-formula-undefined" }
+RSpec.describe Homebrew, :integration_test do
+  it "does not require slow dependencies at startup" do
+    expect { brew "verify-undefined" }
       .to not_to_output.to_stdout
       .and not_to_output.to_stderr
       .and be_a_success
diff --git a/Library/Homebrew/test/hardware/cpu_spec.rb b/Library/Homebrew/test/hardware/cpu_spec.rb
index a0ec80d7ef083..a8c11bb31ebff 100644
--- a/Library/Homebrew/test/hardware/cpu_spec.rb
+++ b/Library/Homebrew/test/hardware/cpu_spec.rb
@@ -1,18 +1,17 @@
-# typed: false
 # frozen_string_literal: true
 
 require "hardware"
 
-describe Hardware::CPU do
+RSpec.describe Hardware::CPU do
   describe "::type" do
-    let(:cpu_types) {
+    let(:cpu_types) do
       [
         :arm,
         :intel,
         :ppc,
         :dunno,
       ]
-    }
+    end
 
     it "returns the current CPU's type as a symbol, or :dunno if it cannot be detected" do
       expect(cpu_types).to include(described_class.type)
@@ -20,7 +19,7 @@
   end
 
   describe "::family" do
-    let(:cpu_families) {
+    let(:cpu_families) do
       [
         :amd_k7,
         :amd_k8,
@@ -31,8 +30,11 @@
         :arm_blizzard_avalanche,
         :arm_firestorm_icestorm,
         :arm_hurricane_zephyr,
+        :arm_ibiza,
         :arm_lightning_thunder,
+        :arm_lobos,
         :arm_monsoon_mistral,
+        :arm_palma,
         :arm_twister,
         :arm_typhoon,
         :arm_vortex_tempest,
@@ -63,7 +65,7 @@
         :zen3,
         :dunno,
       ]
-    }
+    end
 
     it "returns the current CPU's family name as a symbol, or :dunno if it cannot be detected" do
       expect(cpu_families).to include described_class.family
@@ -78,15 +80,13 @@
       end
 
       it "returns :arm_firestorm_icestorm on ARM" do
-        allow(described_class).to receive(:arm?).and_return(true)
-        allow(described_class).to receive(:intel?).and_return(false)
+        allow(described_class).to receive_messages(arm?: true, intel?: false)
 
         expect(described_class.family).to eq(:arm_firestorm_icestorm)
       end
 
       it "returns :westmere on Intel" do
-        allow(described_class).to receive(:arm?).and_return(false)
-        allow(described_class).to receive(:intel?).and_return(true)
+        allow(described_class).to receive_messages(arm?: false, intel?: true)
 
         expect(described_class.family).to eq(:westmere)
       end
diff --git a/Library/Homebrew/test/installed_dependents_spec.rb b/Library/Homebrew/test/installed_dependents_spec.rb
index 6326584b09fe9..f10228c7e5281 100644
--- a/Library/Homebrew/test/installed_dependents_spec.rb
+++ b/Library/Homebrew/test/installed_dependents_spec.rb
@@ -1,12 +1,26 @@
-# typed: false
 # frozen_string_literal: true
 
 require "installed_dependents"
 
-describe InstalledDependents do
+RSpec.describe InstalledDependents do
   include FileUtils
 
-  def setup_test_keg(name, version)
+  def stub_formula(name, version = "1.0", &block)
+    f = formula(name) do
+      url "#{name}-#{version}"
+
+      instance_eval(&block) if block
+    end
+    stub_formula_loader f
+    stub_formula_loader f, "homebrew/core/#{f}"
+    f
+  end
+
+  def setup_test_keg(name, version, &block)
+    stub_formula("gcc")
+    stub_formula("glibc")
+    stub_formula(name, version, &block)
+
     path = HOMEBREW_CELLAR/name/version
     (path/"bin").mkpath
 
@@ -18,52 +32,52 @@ def setup_test_keg(name, version)
   end
 
   let!(:keg) { setup_test_keg("foo", "1.0") }
-
-  describe "::find_some_installed_dependents" do
-    def stub_formula_name(name)
-      f = formula(name) { url "foo-1.0" }
-      stub_formula_loader f
-      stub_formula_loader f, "homebrew/core/#{f}"
-      f
+  let!(:keg_only_keg) do
+    setup_test_keg("foo-keg-only", "1.0") do
+      keg_only "a good reason"
     end
+  end
 
-    def setup_test_keg(name, version)
-      f = stub_formula_name(name)
+  describe "::find_some_installed_dependents" do
+    def setup_test_keg(name, version, &block)
       keg = super
-      Tab.create(f, DevelopmentTools.default_compiler, :libcxx).write
+      Tab.create(keg.to_formula, DevelopmentTools.default_compiler, :libcxx).write
       keg
     end
 
     before do
       keg.link
+      keg_only_keg.optlink
     end
 
-    def alter_tab(keg = dependent)
-      tab = Tab.for_keg(keg)
+    def alter_tab(keg)
+      tab = keg.tab
       yield tab
       tab.write
     end
 
     # 1.1.6 is the earliest version of Homebrew that generates correct runtime
     # dependency lists in {Tab}s.
-    def dependencies(deps, homebrew_version: "1.1.6")
-      alter_tab do |tab|
+    def tab_dependencies(keg, deps, homebrew_version: "1.1.6")
+      alter_tab(keg) do |tab|
         tab.homebrew_version = homebrew_version
-        tab.tabfile = dependent/Tab::FILENAME
+        tab.tabfile = keg/AbstractTab::FILENAME
         tab.runtime_dependencies = deps
       end
     end
 
-    def unreliable_dependencies(deps)
+    def unreliable_tab_dependencies(keg, deps)
       # 1.1.5 is (hopefully!) the last version of Homebrew that generates
       # incorrect runtime dependency lists in {Tab}s.
-      dependencies(deps, homebrew_version: "1.1.5")
+      tab_dependencies(keg, deps, homebrew_version: "1.1.5")
     end
 
-    let(:dependent) { setup_test_keg("bar", "1.0") }
-
     specify "a dependency with no Tap in Tab" do
       tap_dep = setup_test_keg("baz", "1.0")
+      dependent = setup_test_keg("bar", "1.0") do
+        depends_on "foo"
+        depends_on "baz"
+      end
 
       # allow tap_dep to be linked too
       FileUtils.rm_r tap_dep/"bin"
@@ -71,87 +85,97 @@ def unreliable_dependencies(deps)
 
       alter_tab(keg) { |t| t.source["tap"] = nil }
 
-      dependencies nil
-      Formula["bar"].class.depends_on "foo"
-      Formula["bar"].class.depends_on "baz"
+      tab_dependencies dependent, nil
 
       result = described_class.find_some_installed_dependents([keg, tap_dep])
       expect(result).to eq([[keg, tap_dep], ["bar"]])
     end
 
     specify "no dependencies anywhere" do
-      dependencies nil
+      dependent = setup_test_keg("bar", "1.0")
+      tab_dependencies dependent, nil
       expect(described_class.find_some_installed_dependents([keg])).to be_nil
     end
 
     specify "missing Formula dependency" do
-      dependencies nil
-      Formula["bar"].class.depends_on "foo"
+      dependent = setup_test_keg("bar", "1.0") do
+        depends_on "foo"
+      end
+      tab_dependencies dependent, nil
       expect(described_class.find_some_installed_dependents([keg])).to eq([[keg], ["bar"]])
     end
 
     specify "uninstalling dependent and dependency" do
-      dependencies nil
-      Formula["bar"].class.depends_on "foo"
+      dependent = setup_test_keg("bar", "1.0") do
+        depends_on "foo"
+      end
+      tab_dependencies dependent, nil
       expect(described_class.find_some_installed_dependents([keg, dependent])).to be_nil
     end
 
     specify "renamed dependency" do
-      dependencies nil
+      dependent = setup_test_keg("bar", "1.0") do
+        depends_on "foo"
+      end
+      tab_dependencies dependent, nil
 
       stub_formula_loader Formula["foo"], "homebrew/core/foo-old"
       renamed_path = HOMEBREW_CELLAR/"foo-old"
       (HOMEBREW_CELLAR/"foo").rename(renamed_path)
-      renamed_keg = Keg.new(renamed_path/"1.0")
-
-      Formula["bar"].class.depends_on "foo"
+      renamed_keg = Keg.new(renamed_path/keg.version.to_s)
 
       result = described_class.find_some_installed_dependents([renamed_keg])
       expect(result).to eq([[renamed_keg], ["bar"]])
     end
 
     specify "empty dependencies in Tab" do
-      dependencies []
+      dependent = setup_test_keg("bar", "1.0")
+      tab_dependencies dependent, []
       expect(described_class.find_some_installed_dependents([keg])).to be_nil
     end
 
     specify "same name but different version in Tab" do
-      dependencies [{ "full_name" => "foo", "version" => "1.1" }]
+      dependent = setup_test_keg("bar", "1.0")
+      tab_dependencies dependent, [{ "full_name" => keg.name, "version" => "1.1" }]
       expect(described_class.find_some_installed_dependents([keg])).to eq([[keg], ["bar"]])
     end
 
     specify "different name and same version in Tab" do
-      stub_formula_name("baz")
-      dependencies [{ "full_name" => "baz", "version" => keg.version.to_s }]
+      stub_formula("baz")
+      dependent = setup_test_keg("bar", "1.0")
+      tab_dependencies dependent, [{ "full_name" => "baz", "version" => keg.version.to_s }]
       expect(described_class.find_some_installed_dependents([keg])).to be_nil
     end
 
     specify "same name and version in Tab" do
-      dependencies [{ "full_name" => "foo", "version" => "1.0" }]
+      dependent = setup_test_keg("bar", "1.0")
+      tab_dependencies dependent, [{ "full_name" => keg.name, "version" => keg.version.to_s }]
       expect(described_class.find_some_installed_dependents([keg])).to eq([[keg], ["bar"]])
     end
 
     specify "fallback for old versions" do
-      unreliable_dependencies [{ "full_name" => "baz", "version" => "1.0" }]
-      Formula["bar"].class.depends_on "foo"
+      dependent = setup_test_keg("bar", "1.0") do
+        depends_on "foo"
+      end
+      unreliable_tab_dependencies dependent, [{ "full_name" => "baz", "version" => "1.0" }]
       expect(described_class.find_some_installed_dependents([keg])).to eq([[keg], ["bar"]])
     end
 
     specify "non-opt-linked" do
       keg.remove_opt_record
-      dependencies [{ "full_name" => "foo", "version" => "1.0" }]
+      dependent = setup_test_keg("bar", "1.0")
+      tab_dependencies dependent, [{ "full_name" => keg.name, "version" => keg.version.to_s }]
       expect(described_class.find_some_installed_dependents([keg])).to be_nil
     end
 
     specify "keg-only" do
-      keg.unlink
-      Formula["foo"].class.keg_only "a good reason"
-      dependencies [{ "full_name" => "foo", "version" => "1.1" }] # different version
-      expect(described_class.find_some_installed_dependents([keg])).to eq([[keg], ["bar"]])
+      dependent = setup_test_keg("bar", "1.0")
+      tab_dependencies dependent, [{ "full_name" => keg_only_keg.name, "version" => "1.1" }] # different version
+      expect(described_class.find_some_installed_dependents([keg_only_keg])).to eq([[keg_only_keg], ["bar"]])
     end
 
     def stub_cask_name(name, version, dependency)
-      c = Cask::CaskLoader.load(+<<-RUBY)
+      c = Cask::CaskLoader.load(<<-RUBY)
         cask "#{name}" do
           version "#{version}"
 
diff --git a/Library/Homebrew/test/keg_relocate/binary_relocation_spec.rb b/Library/Homebrew/test/keg_relocate/binary_relocation_spec.rb
index 29bf25703a661..652eac1168d79 100644
--- a/Library/Homebrew/test/keg_relocate/binary_relocation_spec.rb
+++ b/Library/Homebrew/test/keg_relocate/binary_relocation_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "keg_relocate"
 
-describe Keg do
+RSpec.describe Keg do
   subject(:keg) { described_class.new(HOMEBREW_CELLAR/"foo/1.0.0") }
 
   let(:dir) { HOMEBREW_CELLAR/"foo/1.0.0" }
diff --git a/Library/Homebrew/test/keg_relocate/grep_spec.rb b/Library/Homebrew/test/keg_relocate/grep_spec.rb
index 889ed7904c2bf..1f834de7ec723 100644
--- a/Library/Homebrew/test/keg_relocate/grep_spec.rb
+++ b/Library/Homebrew/test/keg_relocate/grep_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "keg_relocate"
 
-describe Keg do
+RSpec.describe Keg do
   subject(:keg) { described_class.new(HOMEBREW_CELLAR/"foo/1.0.0") }
 
   let(:dir) { HOMEBREW_CELLAR/"foo/1.0.0" }
diff --git a/Library/Homebrew/test/keg_relocate/relocation_spec.rb b/Library/Homebrew/test/keg_relocate/relocation_spec.rb
index 36cdbdc18afe0..a4e0f15be598e 100644
--- a/Library/Homebrew/test/keg_relocate/relocation_spec.rb
+++ b/Library/Homebrew/test/keg_relocate/relocation_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "keg_relocate"
 
-describe Keg::Relocation do
+RSpec.describe Keg::Relocation do
   let(:prefix) { HOMEBREW_PREFIX.to_s }
   let(:cellar) { HOMEBREW_CELLAR.to_s }
   let(:repository) { HOMEBREW_REPOSITORY.to_s }
@@ -40,7 +39,7 @@ def setup_relocation
     relocation.replace_text(text)
     expect(text).to eq "foo"
 
-    text = +<<~TEXT
+    text = <<~TEXT
       #{prefix}/foo
       #{cellar}/foo
       foo#{prefix}/bar
diff --git a/Library/Homebrew/test/keg_relocate/text_spec.rb b/Library/Homebrew/test/keg_relocate/text_spec.rb
index 71e5ccdd6e2bf..8a53cbbf70240 100644
--- a/Library/Homebrew/test/keg_relocate/text_spec.rb
+++ b/Library/Homebrew/test/keg_relocate/text_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "keg_relocate"
 
-describe Keg do
+RSpec.describe Keg do
   subject(:keg) { described_class.new(HOMEBREW_CELLAR/"foo/1.0.0") }
 
   let(:dir) { mktmpdir }
diff --git a/Library/Homebrew/test/keg_spec.rb b/Library/Homebrew/test/keg_spec.rb
index cbc99ef0b7fad..ffac76b7f0961 100644
--- a/Library/Homebrew/test/keg_spec.rb
+++ b/Library/Homebrew/test/keg_spec.rb
@@ -1,10 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
 require "keg"
 require "stringio"
 
-describe Keg do
+RSpec.describe Keg do
+  include FileUtils
+
   def setup_test_keg(name, version)
     path = HOMEBREW_CELLAR/name/version
     (path/"bin").mkpath
@@ -46,7 +47,7 @@ def setup_test_keg(name, version)
     expect(keg).to be_a_directory
     expect(keg).not_to be_an_empty_installation
 
-    (keg/"bin").rmtree
+    FileUtils.rm_r(keg/"bin")
     expect(keg).to be_an_empty_installation
 
     (keg/"bin").mkpath
@@ -54,21 +55,21 @@ def setup_test_keg(name, version)
     expect(keg).not_to be_an_empty_installation
   end
 
-  specify "#oldname_opt_record" do
-    expect(keg.oldname_opt_record).to be_nil
+  specify "#oldname_opt_records" do
+    expect(keg.oldname_opt_records).to be_empty
     oldname_opt_record = HOMEBREW_PREFIX/"opt/oldfoo"
     oldname_opt_record.make_relative_symlink(HOMEBREW_CELLAR/"foo/1.0")
-    expect(keg.oldname_opt_record).to eq(oldname_opt_record)
+    expect(keg.oldname_opt_records).to eq([oldname_opt_record])
   end
 
-  specify "#remove_oldname_opt_record" do
+  specify "#remove_oldname_opt_records" do
     oldname_opt_record = HOMEBREW_PREFIX/"opt/oldfoo"
     oldname_opt_record.make_relative_symlink(HOMEBREW_CELLAR/"foo/2.0")
-    keg.remove_oldname_opt_record
+    keg.remove_oldname_opt_records
     expect(oldname_opt_record).to be_a_symlink
     oldname_opt_record.unlink
     oldname_opt_record.make_relative_symlink(HOMEBREW_CELLAR/"foo/1.0")
-    keg.remove_oldname_opt_record
+    keg.remove_oldname_opt_records
     expect(oldname_opt_record).not_to be_a_symlink
   end
 
@@ -84,9 +85,9 @@ def setup_test_keg(name, version)
       let(:options) { { dry_run: true } }
 
       it "only prints what would be done" do
-        expect {
+        expect do
           expect(keg.link(**options)).to eq(0)
-        }.to output(<<~EOF).to_stdout
+        end.to output(<<~EOF).to_stdout
           #{HOMEBREW_PREFIX}/bin/goodbye_cruel_world
           #{HOMEBREW_PREFIX}/bin/helloworld
           #{HOMEBREW_PREFIX}/bin/hiworld
@@ -135,9 +136,9 @@ def setup_test_keg(name, version)
 
         options[:dry_run] = true
 
-        expect {
+        expect do
           expect(keg.link(**options)).to eq(0)
-        }.to output(<<~EOF).to_stdout
+        end.to output(<<~EOF).to_stdout
           #{dst}
         EOF
 
@@ -268,6 +269,8 @@ def setup_test_keg(name, version)
       expect(lib.children.length).to eq(2)
     end
 
+    # This is a legacy violation that would benefit from a clear expectation.
+    # rubocop:disable RSpec/NoExpectationExample
     it "removes broken symlinks that conflict with directories" do
       a = HOMEBREW_CELLAR/"a"/"1.0"
       (a/"lib"/"foo").mkpath
@@ -280,6 +283,7 @@ def setup_test_keg(name, version)
 
       keg.link
     end
+    # rubocop:enable RSpec/NoExpectationExample
   end
 
   describe "#optlink" do
diff --git a/Library/Homebrew/test/language/go_spec.rb b/Library/Homebrew/test/language/go_spec.rb
deleted file mode 100644
index b2c3212ad9591..0000000000000
--- a/Library/Homebrew/test/language/go_spec.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "language/go"
-
-describe Language::Go do
-  specify "#stage_deps" do
-    ENV.delete("HOMEBREW_DEVELOPER")
-
-    expect(described_class).to receive(:opoo).once
-
-    mktmpdir do |path|
-      described_class.stage_deps [], path
-    end
-  end
-end
diff --git a/Library/Homebrew/test/language/java_spec.rb b/Library/Homebrew/test/language/java_spec.rb
index 24cd5aa05207e..a61b2c5dd3f7b 100644
--- a/Library/Homebrew/test/language/java_spec.rb
+++ b/Library/Homebrew/test/language/java_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "language/java"
 
-describe Language::Java do
+RSpec.describe Language::Java do
   let(:f) do
     formula("openjdk") do
       url "openjdk"
@@ -21,8 +20,7 @@
 
   before do
     allow(Formula).to receive(:[]).and_return(f)
-    allow(f).to receive(:any_version_installed?).and_return(true)
-    allow(f).to receive(:any_installed_version).and_return(f.version)
+    allow(f).to receive_messages(any_version_installed?: true, any_installed_version: f.version)
   end
 
   describe "::java_home" do
diff --git a/Library/Homebrew/test/language/node/shebang_spec.rb b/Library/Homebrew/test/language/node/shebang_spec.rb
new file mode 100644
index 0000000000000..4c282eab3d358
--- /dev/null
+++ b/Library/Homebrew/test/language/node/shebang_spec.rb
@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "language/node"
+require "utils/shebang"
+
+RSpec.describe Language::Node::Shebang do
+  let(:file) { Tempfile.new("node-shebang") }
+  let(:f) do
+    f = {}
+
+    f[:node18] = formula "node@18" do
+      url "https://brew.sh/node-18.0.0.tgz"
+    end
+
+    f[:versioned_node_dep] = formula "foo" do
+      url "https://brew.sh/foo-1.0.tgz"
+
+      depends_on "node@18"
+    end
+
+    f[:no_deps] = formula "foo" do
+      url "https://brew.sh/foo-1.0.tgz"
+    end
+
+    f[:multiple_deps] = formula "foo" do
+      url "https://brew.sh/foo-1.0.tgz"
+
+      depends_on "node"
+      depends_on "node@18"
+    end
+
+    f
+  end
+
+  before do
+    file.write <<~EOS
+      #!/usr/bin/env node
+      a
+      b
+      c
+    EOS
+    file.flush
+  end
+
+  after { file.unlink }
+
+  describe "#detected_node_shebang" do
+    it "can be used to replace Node shebangs" do
+      allow(Formulary).to receive(:factory)
+      allow(Formulary).to receive(:factory).with(f[:node18].name).and_return(f[:node18])
+      Utils::Shebang.rewrite_shebang described_class.detected_node_shebang(f[:versioned_node_dep]), file.path
+
+      expect(File.read(file)).to eq <<~EOS
+        #!#{HOMEBREW_PREFIX/"opt/node@18/bin/node"}
+        a
+        b
+        c
+      EOS
+    end
+
+    it "errors if formula doesn't depend on node" do
+      expect { Utils::Shebang.rewrite_shebang described_class.detected_node_shebang(f[:no_deps]), file.path }
+        .to raise_error(ShebangDetectionError, "Cannot detect Node shebang: formula does not depend on Node.")
+    end
+
+    it "errors if formula depends on more than one node" do
+      expect { Utils::Shebang.rewrite_shebang described_class.detected_node_shebang(f[:multiple_deps]), file.path }
+        .to raise_error(ShebangDetectionError, "Cannot detect Node shebang: formula has multiple Node dependencies.")
+    end
+  end
+end
diff --git a/Library/Homebrew/test/language/node_spec.rb b/Library/Homebrew/test/language/node_spec.rb
index dc80eed2f8e01..4a94660a1d5e9 100644
--- a/Library/Homebrew/test/language/node_spec.rb
+++ b/Library/Homebrew/test/language/node_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "language/node"
 
-describe Language::Node do
+RSpec.describe Language::Node do
   let(:npm_pack_cmd) { ["npm", "pack", "--ignore-scripts"] }
 
   describe "#setup_npm_environment" do
@@ -12,17 +11,24 @@
         url "node-test-v1.0"
       end
       stub_formula_loader(node)
-      expect(ENV).to receive(:prepend_path)
+      without_partial_double_verification do
+        expect(ENV).to receive(:prepend_path)
+      end
       described_class.instance_variable_set(:@env_set, false)
-      expect(described_class.setup_npm_environment).to be_nil
+      described_class.setup_npm_environment
 
       expect(described_class.instance_variable_get(:@env_set)).to be(true)
-      expect(ENV).not_to receive(:prepend_path)
-      expect(described_class.setup_npm_environment).to be_nil
+      without_partial_double_verification do
+        expect(ENV).not_to receive(:prepend_path)
+      end
+      described_class.setup_npm_environment
     end
 
     it "does not call prepend_path when node formula does not exist" do
-      expect(described_class.setup_npm_environment).to be_nil
+      without_partial_double_verification do
+        expect(ENV).not_to receive(:prepend_path)
+      end
+      described_class.setup_npm_environment
     end
   end
 
@@ -45,14 +51,12 @@
 
     it "raises error with non zero exitstatus" do
       allow(Utils).to receive(:popen_read).with(*npm_pack_cmd).and_return(`false`)
-      expect { described_class.std_npm_install_args(npm_install_arg) }.to \
-        raise_error("npm failed to pack #{Dir.pwd}")
+      expect { described_class.std_npm_install_args(npm_install_arg) }.to raise_error("npm failed to pack #{Dir.pwd}")
     end
 
     it "raises error with empty npm pack output" do
       allow(Utils).to receive(:popen_read).with(*npm_pack_cmd).and_return(`true`)
-      expect { described_class.std_npm_install_args(npm_install_arg) }.to \
-        raise_error("npm failed to pack #{Dir.pwd}")
+      expect { described_class.std_npm_install_args(npm_install_arg) }.to raise_error("npm failed to pack #{Dir.pwd}")
     end
 
     it "does not raise error with a zero exitstatus" do
diff --git a/Library/Homebrew/test/language/perl/shebang_spec.rb b/Library/Homebrew/test/language/perl/shebang_spec.rb
index 38719dd70917b..c08de4321dc64 100644
--- a/Library/Homebrew/test/language/perl/shebang_spec.rb
+++ b/Library/Homebrew/test/language/perl/shebang_spec.rb
@@ -1,22 +1,34 @@
-# typed: false
 # frozen_string_literal: true
 
 require "language/perl"
 require "utils/shebang"
 
-describe Language::Perl::Shebang do
+RSpec.describe Language::Perl::Shebang do
   let(:file) { Tempfile.new("perl-shebang") }
-  let(:perl_f) do
-    formula "perl" do
+  let(:f) do
+    f = {}
+
+    f[:perl] = formula "perl" do
       url "https://brew.sh/perl-1.0.tgz"
     end
-  end
-  let(:f) do
-    formula "foo" do
+
+    f[:depends_on] = formula "foo" do
+      url "https://brew.sh/foo-1.0.tgz"
+
+      depends_on "perl"
+    end
+
+    f[:uses_from_macos] = formula "foo" do
       url "https://brew.sh/foo-1.0.tgz"
 
       uses_from_macos "perl"
     end
+
+    f[:no_deps] = formula "foo" do
+      url "https://brew.sh/foo-1.0.tgz"
+    end
+
+    f
   end
 
   before do
@@ -32,9 +44,23 @@
   after { file.unlink }
 
   describe "#detected_perl_shebang" do
-    it "can be used to replace Perl shebangs" do
-      allow(Formulary).to receive(:factory).with(perl_f.name).and_return(perl_f)
-      Utils::Shebang.rewrite_shebang described_class.detected_perl_shebang(f), file
+    it "can be used to replace Perl shebangs when depends_on \"perl\" is used" do
+      allow(Formulary).to receive(:factory)
+      allow(Formulary).to receive(:factory).with(f[:perl].name).and_return(f[:perl])
+      Utils::Shebang.rewrite_shebang described_class.detected_perl_shebang(f[:depends_on]), file.path
+
+      expect(File.read(file)).to eq <<~EOS
+        #!#{HOMEBREW_PREFIX}/opt/perl/bin/perl
+        a
+        b
+        c
+      EOS
+    end
+
+    it "can be used to replace Perl shebangs when uses_from_macos \"perl\" is used" do
+      allow(Formulary).to receive(:factory)
+      allow(Formulary).to receive(:factory).with(f[:perl].name).and_return(f[:perl])
+      Utils::Shebang.rewrite_shebang described_class.detected_perl_shebang(f[:uses_from_macos]), file.path
 
       expected_shebang = if OS.mac?
         "/usr/bin/perl#{MacOS.preferred_perl_version}"
@@ -49,5 +75,10 @@
         c
       EOS
     end
+
+    it "errors if formula doesn't depend on perl" do
+      expect { Utils::Shebang.rewrite_shebang described_class.detected_perl_shebang(f[:no_deps]), file.path }
+        .to raise_error(ShebangDetectionError, "Cannot detect Perl shebang: formula does not depend on Perl.")
+    end
   end
 end
diff --git a/Library/Homebrew/test/language/python/shebang_spec.rb b/Library/Homebrew/test/language/python/shebang_spec.rb
index b269129cc0e0d..b6d3d22d97a25 100644
--- a/Library/Homebrew/test/language/python/shebang_spec.rb
+++ b/Library/Homebrew/test/language/python/shebang_spec.rb
@@ -1,27 +1,40 @@
-# typed: false
 # frozen_string_literal: true
 
 require "language/python"
 require "utils/shebang"
 
-describe Language::Python::Shebang do
+RSpec.describe Language::Python::Shebang do
   let(:file) { Tempfile.new("python-shebang") }
-  let(:python_f) do
-    formula "python" do
+  let(:f) do
+    f = {}
+
+    f[:python311] = formula "python@3.11" do
       url "https://brew.sh/python-1.0.tgz"
     end
-  end
-  let(:f) do
-    formula "foo" do
+
+    f[:versioned_python_dep] = formula "foo" do
+      url "https://brew.sh/foo-1.0.tgz"
+
+      depends_on "python@3.11"
+    end
+
+    f[:no_deps] = formula "foo" do
+      url "https://brew.sh/foo-1.0.tgz"
+    end
+
+    f[:multiple_deps] = formula "foo" do
       url "https://brew.sh/foo-1.0.tgz"
 
       depends_on "python"
+      depends_on "python@3.11"
     end
+
+    f
   end
 
   before do
     file.write <<~EOS
-      #!/usr/bin/env python3
+      #!/usr/bin/python2
       a
       b
       c
@@ -33,15 +46,52 @@
 
   describe "#detected_python_shebang" do
     it "can be used to replace Python shebangs" do
-      expect(Formulary).to receive(:factory).with(python_f.name).and_return(python_f)
-      Utils::Shebang.rewrite_shebang described_class.detected_python_shebang(f), file
+      allow(Formulary).to receive(:factory)
+      allow(Formulary).to receive(:factory).with(f[:python311].name).and_return(f[:python311])
+      Utils::Shebang.rewrite_shebang(
+        described_class.detected_python_shebang(f[:versioned_python_dep], use_python_from_path: false), file.path
+      )
 
       expect(File.read(file)).to eq <<~EOS
-        #!#{HOMEBREW_PREFIX}/opt/python/bin/python3
+        #!#{HOMEBREW_PREFIX}/opt/python@3.11/bin/python3.11
         a
         b
         c
       EOS
     end
+
+    it "can be pointed to a `python3` in PATH" do
+      Utils::Shebang.rewrite_shebang(
+        described_class.detected_python_shebang(f[:versioned_python_dep], use_python_from_path: true), file.path
+      )
+
+      expect(File.read(file)).to eq <<~EOS
+        #!/usr/bin/env python3
+        a
+        b
+        c
+      EOS
+    end
+
+    it "errors if formula doesn't depend on python" do
+      expect do
+        Utils::Shebang.rewrite_shebang(
+          described_class.detected_python_shebang(f[:no_deps], use_python_from_path: false),
+          file.path,
+        )
+      end.to raise_error(ShebangDetectionError, "Cannot detect Python shebang: formula does not depend on Python.")
+    end
+
+    it "errors if formula depends on more than one python" do
+      expect do
+        Utils::Shebang.rewrite_shebang(
+          described_class.detected_python_shebang(f[:multiple_deps], use_python_from_path: false),
+          file.path,
+        )
+      end.to raise_error(
+        ShebangDetectionError,
+        "Cannot detect Python shebang: formula has multiple Python dependencies.",
+      )
+    end
   end
 end
diff --git a/Library/Homebrew/test/language/python/virtualenv_spec.rb b/Library/Homebrew/test/language/python/virtualenv_spec.rb
index 04a465efa6a6b..27a9934f9fef3 100644
--- a/Library/Homebrew/test/language/python/virtualenv_spec.rb
+++ b/Library/Homebrew/test/language/python/virtualenv_spec.rb
@@ -1,98 +1,301 @@
-# typed: false
 # frozen_string_literal: true
 
 require "language/python"
 require "resource"
 
-describe Language::Python::Virtualenv::Virtualenv, :needs_python do
-  subject(:virtualenv) { described_class.new(formula, dir, "python") }
+RSpec.describe Language::Python::Virtualenv, :needs_python do
+  describe "#virtualenv_install_with_resources" do
+    let(:venv) { instance_double(Language::Python::Virtualenv::Virtualenv) }
+    let(:f) do
+      formula "foo" do
+        # Couldn't find a way to get described_class to work inside formula do
+        # rubocop:disable RSpec/DescribedClass
+        include Language::Python::Virtualenv
+        # rubocop:enable RSpec/DescribedClass
 
-  let(:dir) { mktmpdir }
+        url "https://brew.sh/foo-1.0.tgz"
 
-  let(:resource) { double("resource", stage: true) }
-  let(:formula_bin) { dir/"formula_bin" }
-  let(:formula) { double("formula", resource: resource, bin: formula_bin) }
+        resource "resource-a" do
+          url "https://brew.sh/resource1.tar.gz"
+          sha256 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+        end
 
-  describe "#create" do
-    it "creates a venv" do
-      expect(formula).to receive(:system).with("python", "-m", "venv", "--system-site-packages", dir)
-      virtualenv.create
+        resource "resource-b" do
+          url "https://brew.sh/resource2.tar.gz"
+          sha256 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+        end
+
+        resource "resource-c" do
+          url "https://brew.sh/resource3.tar.gz"
+          sha256 "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+        end
+
+        resource "resource-d" do
+          url "https://brew.sh/resource4.tar.gz"
+          sha256 "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+        end
+      end
+    end
+    let(:r_a) { f.resource("resource-a") }
+    let(:r_b) { f.resource("resource-b") }
+    let(:r_c) { f.resource("resource-c") }
+    let(:r_d) { f.resource("resource-d") }
+    let(:buildpath) { Pathname(TEST_TMPDIR) }
+
+    before { f.instance_variable_set(:@buildpath, buildpath) }
+
+    it "works with `using: \"python\"` and installs resources in order" do
+      expect(f).to receive(:virtualenv_create).with(
+        f.libexec, "python", { system_site_packages: true, without_pip: true }
+      ).and_return(venv)
+      expect(venv).to receive(:pip_install).with([r_a, r_b, r_c, r_d])
+      expect(venv).to receive(:pip_install_and_link).with(buildpath, { link_manpages: false })
+      f.virtualenv_install_with_resources(using: "python")
+    end
+
+    it "works with `using: \"python@3.12\"` and installs resources in order" do
+      expect(f).to receive(:virtualenv_create).with(
+        f.libexec, "python3.12", { system_site_packages: true, without_pip: true }
+      ).and_return(venv)
+      expect(venv).to receive(:pip_install).with([r_a, r_b, r_c, r_d])
+      expect(venv).to receive(:pip_install_and_link).with(buildpath, { link_manpages: false })
+      f.virtualenv_install_with_resources(using: "python@3.12")
+    end
+
+    it "skips a `without` resource string and installs remaining resources in order" do
+      expect(f).to receive(:virtualenv_create).and_return(venv)
+      expect(venv).to receive(:pip_install).with([r_a, r_b, r_d])
+      expect(venv).to receive(:pip_install_and_link).with(buildpath, { link_manpages: false })
+      f.virtualenv_install_with_resources(using: "python", without: r_c.name)
+    end
+
+    it "skips all resources in `without` array and installs remaining resources in order" do
+      expect(f).to receive(:virtualenv_create).and_return(venv)
+      expect(venv).to receive(:pip_install).with([r_b, r_c])
+      expect(venv).to receive(:pip_install_and_link).with(buildpath, { link_manpages: false })
+      f.virtualenv_install_with_resources(using: "python", without: [r_d.name, r_a.name])
     end
-  end
 
-  describe "#pip_install" do
-    it "accepts a string" do
-      expect(formula).to receive(:system)
-        .with(dir/"bin/pip", "install", "-v", "--no-deps",
-              "--no-binary", ":all:", "--ignore-installed", "foo")
-        .and_return(true)
-      virtualenv.pip_install "foo"
+    it "errors if `without` resource string does not exist in formula" do
+      expect do
+        f.virtualenv_install_with_resources(using: "python", without: "unknown")
+      end.to raise_error(ArgumentError)
     end
 
-    it "accepts a multi-line strings" do
-      expect(formula).to receive(:system)
-        .with(dir/"bin/pip", "install", "-v", "--no-deps",
-              "--no-binary", ":all:", "--ignore-installed", "foo", "bar")
-        .and_return(true)
+    it "errors if `without` resource array refers to a resource that does not exist in formula" do
+      expect do
+        f.virtualenv_install_with_resources(using: "python", without: [r_a.name, "unknown"])
+      end.to raise_error(ArgumentError)
+    end
 
-      virtualenv.pip_install <<~EOS
-        foo
-        bar
-      EOS
+    it "installs a `start_with` resource string and then remaining resources in order" do
+      expect(f).to receive(:virtualenv_create).and_return(venv)
+      expect(venv).to receive(:pip_install).with([r_c, r_a, r_b, r_d])
+      expect(venv).to receive(:pip_install_and_link).with(buildpath, { link_manpages: false })
+      f.virtualenv_install_with_resources(using: "python", start_with: r_c.name)
     end
 
-    it "accepts an array" do
-      expect(formula).to receive(:system)
-        .with(dir/"bin/pip", "install", "-v", "--no-deps",
-              "--no-binary", ":all:", "--ignore-installed", "foo")
-        .and_return(true)
+    it "installs all resources in `start_with` array and then remaining resources in order" do
+      expect(f).to receive(:virtualenv_create).and_return(venv)
+      expect(venv).to receive(:pip_install).with([r_d, r_b, r_a, r_c])
+      expect(venv).to receive(:pip_install_and_link).with(buildpath, { link_manpages: false })
+      f.virtualenv_install_with_resources(using: "python", start_with: [r_d.name, r_b.name])
+    end
 
-      expect(formula).to receive(:system)
-        .with(dir/"bin/pip", "install", "-v", "--no-deps",
-              "--no-binary", ":all:", "--ignore-installed", "bar")
-        .and_return(true)
+    it "errors if `start_with` resource string does not exist in formula" do
+      expect do
+        f.virtualenv_install_with_resources(using: "python", start_with: "unknown")
+      end.to raise_error(ArgumentError)
+    end
 
-      virtualenv.pip_install ["foo", "bar"]
+    it "errors if `start_with` resource array refers to a resource that does not exist in formula" do
+      expect do
+        f.virtualenv_install_with_resources(using: "python", start_with: [r_a.name, "unknown"])
+      end.to raise_error(ArgumentError)
     end
 
-    it "accepts a Resource" do
-      res = Resource.new("test")
+    it "installs an `end_with` resource string as last resource" do
+      expect(f).to receive(:virtualenv_create).and_return(venv)
+      expect(venv).to receive(:pip_install).with([r_a, r_c, r_d, r_b])
+      expect(venv).to receive(:pip_install_and_link).with(buildpath, { link_manpages: false })
+      f.virtualenv_install_with_resources(using: "python", end_with: r_b.name)
+    end
 
-      expect(res).to receive(:stage).and_yield
-      expect(formula).to receive(:system)
-        .with(dir/"bin/pip", "install", "-v", "--no-deps",
-              "--no-binary", ":all:", "--ignore-installed", Pathname.pwd)
-        .and_return(true)
+    it "installs all resources in `end_with` array after other resources are installed" do
+      expect(f).to receive(:virtualenv_create).and_return(venv)
+      expect(venv).to receive(:pip_install).with([r_a, r_d, r_c, r_b])
+      expect(venv).to receive(:pip_install_and_link).with(buildpath, { link_manpages: false })
+      f.virtualenv_install_with_resources(using: "python", end_with: [r_c.name, r_b.name])
+    end
 
-      virtualenv.pip_install res
+    it "errors if `end_with` resource string does not exist in formula" do
+      expect do
+        f.virtualenv_install_with_resources(using: "python", end_with: "unknown")
+      end.to raise_error(ArgumentError)
+    end
+
+    it "errors if `end_with` resource array refers to a resource that does not exist in formula" do
+      expect do
+        f.virtualenv_install_with_resources(using: "python", end_with: [r_a.name, "unknown"])
+      end.to raise_error(ArgumentError)
+    end
+
+    it "installs resources in correct order when combining `without`, `start_with` and `end_with" do
+      expect(f).to receive(:virtualenv_create).and_return(venv)
+      expect(venv).to receive(:pip_install).with([r_d, r_c, r_b])
+      expect(venv).to receive(:pip_install_and_link).with(buildpath, { link_manpages: false })
+      f.virtualenv_install_with_resources(using: "python", without: r_a.name,
+                                          start_with: r_d.name, end_with: r_b.name)
     end
   end
 
-  describe "#pip_install_and_link" do
-    let(:src_bin) { dir/"bin" }
-    let(:dest_bin) { formula.bin }
+  describe Language::Python::Virtualenv::Virtualenv do
+    subject(:virtualenv) { described_class.new(formula, dir, "python") }
+
+    let(:dir) { mktmpdir }
+
+    let(:resource) { instance_double(Resource, "resource", stage: true) }
+    let(:formula_bin) { dir/"formula_bin" }
+    let(:formula_man) { dir/"formula_man" }
+    let(:formula) { instance_double(Formula, "formula", resource:, bin: formula_bin, man: formula_man) }
+
+    describe "#create" do
+      it "creates a venv" do
+        expect(formula).to receive(:system)
+          .with("python", "-m", "venv", "--system-site-packages", "--without-pip", dir)
+        virtualenv.create
+      end
+
+      it "creates a venv with pip" do
+        expect(formula).to receive(:system).with("python", "-m", "venv", "--system-site-packages", dir)
+        virtualenv.create(without_pip: false)
+      end
+    end
+
+    describe "#pip_install" do
+      it "accepts a string" do
+        expect(formula).to receive(:std_pip_args).with(prefix:          false,
+                                                       build_isolation: true).and_return(["--std-pip-args"])
+        expect(formula).to receive(:system)
+          .with("python", "-m", "pip", "--python=#{dir}/bin/python", "install", "--std-pip-args", "foo")
+          .and_return(true)
+        virtualenv.pip_install "foo"
+      end
+
+      it "accepts a multi-line strings" do
+        expect(formula).to receive(:std_pip_args).with(prefix:          false,
+                                                       build_isolation: true).and_return(["--std-pip-args"])
+        expect(formula).to receive(:system)
+          .with("python", "-m", "pip", "--python=#{dir}/bin/python", "install", "--std-pip-args", "foo", "bar")
+          .and_return(true)
+
+        virtualenv.pip_install <<~EOS
+          foo
+          bar
+        EOS
+      end
+
+      it "accepts an array" do
+        expect(formula).to receive(:std_pip_args).with(prefix:          false,
+                                                       build_isolation: true).and_return(["--std-pip-args"])
+        expect(formula).to receive(:system)
+          .with("python", "-m", "pip", "--python=#{dir}/bin/python", "install", "--std-pip-args", "foo")
+          .and_return(true)
+
+        expect(formula).to receive(:std_pip_args).with(prefix:          false,
+                                                       build_isolation: true).and_return(["--std-pip-args"])
+        expect(formula).to receive(:system)
+          .with("python", "-m", "pip", "--python=#{dir}/bin/python", "install", "--std-pip-args", "bar")
+          .and_return(true)
+
+        virtualenv.pip_install ["foo", "bar"]
+      end
+
+      it "accepts a Resource" do
+        res = Resource.new("test")
+
+        expect(res).to receive(:stage).and_yield
+        expect(formula).to receive(:std_pip_args).with(prefix:          false,
+                                                       build_isolation: true).and_return(["--std-pip-args"])
+        expect(formula).to receive(:system)
+          .with("python", "-m", "pip", "--python=#{dir}/bin/python", "install", "--std-pip-args", Pathname.pwd)
+          .and_return(true)
+
+        virtualenv.pip_install res
+      end
+
+      it "works without build isolation" do
+        expect(formula).to receive(:std_pip_args).with(prefix:          false,
+                                                       build_isolation: false).and_return(["--std-pip-args"])
+        expect(formula).to receive(:system)
+          .with("python", "-m", "pip", "--python=#{dir}/bin/python", "install", "--std-pip-args", "foo")
+          .and_return(true)
+        virtualenv.pip_install("foo", build_isolation: false)
+      end
+    end
+
+    describe "#pip_install_and_link" do
+      let(:src_bin) { dir/"bin" }
+      let(:src_man) { dir/"share/man" }
+      let(:dest_bin) { formula.bin }
+      let(:dest_man) { formula.man }
+
+      it "can link scripts" do
+        src_bin.mkpath
+
+        expect(src_bin/"kilroy").not_to exist
+        expect(dest_bin/"kilroy").not_to exist
+
+        FileUtils.touch src_bin/"irrelevant"
+        bin_before = Dir.glob(src_bin/"*")
+        FileUtils.touch src_bin/"kilroy"
+        bin_after = Dir.glob(src_bin/"*")
+
+        expect(virtualenv).to receive(:pip_install).with("foo", { build_isolation: true })
+        expect(Dir).to receive(:[]).with(src_bin/"*").twice.and_return(bin_before, bin_after)
+
+        virtualenv.pip_install_and_link "foo"
+
+        expect(src_bin/"kilroy").to exist
+        expect(dest_bin/"kilroy").to exist
+        expect(dest_bin/"kilroy").to be_a_symlink
+        expect((src_bin/"kilroy").realpath).to eq((dest_bin/"kilroy").realpath)
+        expect(dest_bin/"irrelevant").not_to exist
+      end
 
-    it "can link scripts" do
-      src_bin.mkpath
+      it "can link manpages" do
+        (src_man/"man1").mkpath
+        (src_man/"man3").mkpath
 
-      expect(src_bin/"kilroy").not_to exist
-      expect(dest_bin/"kilroy").not_to exist
+        expect(src_man/"man1/kilroy.1").not_to exist
+        expect(dest_man/"man1").not_to exist
+        expect(dest_man/"man3").not_to exist
+        expect(dest_man/"man5").not_to exist
 
-      FileUtils.touch src_bin/"irrelevant"
-      bin_before = Dir.glob(src_bin/"*")
-      FileUtils.touch src_bin/"kilroy"
-      bin_after = Dir.glob(src_bin/"*")
+        FileUtils.touch src_man/"man1/irrelevant.1"
+        FileUtils.touch src_man/"man3/irrelevant.3"
+        man_before = Dir.glob(src_man/"**/*")
+        (src_man/"man5").mkpath
+        FileUtils.touch src_man/"man1/kilroy.1"
+        FileUtils.touch src_man/"man5/kilroy.5"
+        man_after = Dir.glob(src_man/"**/*")
 
-      expect(virtualenv).to receive(:pip_install).with("foo")
-      expect(Dir).to receive(:[]).with(src_bin/"*").twice.and_return(bin_before, bin_after)
+        expect(virtualenv).to receive(:pip_install).with("foo", { build_isolation: true })
+        expect(Dir).to receive(:[]).with(src_bin/"*").and_return([])
+        expect(Dir).to receive(:[]).with(src_man/"man*/*").and_return(man_before)
+        expect(Dir).to receive(:[]).with(src_bin/"*").and_return([])
+        expect(Dir).to receive(:[]).with(src_man/"man*/*").and_return(man_after)
 
-      virtualenv.pip_install_and_link "foo"
+        virtualenv.pip_install_and_link("foo", link_manpages: true)
 
-      expect(src_bin/"kilroy").to exist
-      expect(dest_bin/"kilroy").to exist
-      expect(dest_bin/"kilroy").to be_a_symlink
-      expect((src_bin/"kilroy").realpath).to eq((dest_bin/"kilroy").realpath)
-      expect(dest_bin/"irrelevant").not_to exist
+        expect(src_man/"man1/kilroy.1").to exist
+        expect(dest_man/"man1/kilroy.1").to exist
+        expect(dest_man/"man5/kilroy.5").to exist
+        expect(dest_man/"man1/kilroy.1").to be_a_symlink
+        expect((src_man/"man1/kilroy.1").realpath).to eq((dest_man/"man1/kilroy.1").realpath)
+        expect(dest_man/"man1/irrelevant.1").not_to exist
+        expect(dest_man/"man3").not_to exist
+      end
     end
   end
 end
diff --git a/Library/Homebrew/test/language/python_spec.rb b/Library/Homebrew/test/language/python_spec.rb
index 6446b40d56bc2..d7472a91c1a1f 100644
--- a/Library/Homebrew/test/language/python_spec.rb
+++ b/Library/Homebrew/test/language/python_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "language/python"
 
-describe Language::Python, :needs_python do
+RSpec.describe Language::Python, :needs_python do
   describe "#major_minor_version" do
     it "returns a Version for Python 2" do
       expect(described_class).to receive(:major_minor_version).and_return(Version)
diff --git a/Library/Homebrew/test/lazy_object_spec.rb b/Library/Homebrew/test/lazy_object_spec.rb
index f9520b83c82e2..cd925f68a57e4 100644
--- a/Library/Homebrew/test/lazy_object_spec.rb
+++ b/Library/Homebrew/test/lazy_object_spec.rb
@@ -1,14 +1,13 @@
-# typed: false
 # frozen_string_literal: true
 
 require "lazy_object"
 
-describe LazyObject do
+RSpec.describe LazyObject do
   describe "#initialize" do
     it "does not evaluate the block" do
-      expect { |block|
+      expect do |block|
         described_class.new(&block)
-      }.not_to yield_control
+      end.not_to yield_control
     end
   end
 
diff --git a/Library/Homebrew/test/linkage_cache_store_spec.rb b/Library/Homebrew/test/linkage_cache_store_spec.rb
index f03bf3f1bb5e6..fd3beab76ff60 100644
--- a/Library/Homebrew/test/linkage_cache_store_spec.rb
+++ b/Library/Homebrew/test/linkage_cache_store_spec.rb
@@ -1,13 +1,12 @@
-# typed: false
 # frozen_string_literal: true
 
 require "linkage_cache_store"
 
-describe LinkageCacheStore do
+RSpec.describe LinkageCacheStore do
   subject(:linkage_cache) { described_class.new(keg_name, database) }
 
   let(:keg_name) { "keg_name" }
-  let(:database) { double("database") }
+  let(:database) { instance_double(CacheStoreDatabase, "database") }
 
   describe "#keg_exists?" do
     context "when `keg_name` exists in cache" do
diff --git a/Library/Homebrew/test/linux_runner_spec_spec.rb b/Library/Homebrew/test/linux_runner_spec_spec.rb
new file mode 100644
index 0000000000000..8b986c1dd46d9
--- /dev/null
+++ b/Library/Homebrew/test/linux_runner_spec_spec.rb
@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "linux_runner_spec"
+
+RSpec.describe LinuxRunnerSpec do
+  let(:spec) do
+    described_class.new(
+      name:      "Linux",
+      runner:    "ubuntu-latest",
+      container: { image: "ghcr.io/homebrew/ubuntu22.04:master", options: "--user=linuxbrew" },
+      workdir:   "/github/home",
+      timeout:   360,
+      cleanup:   false,
+    )
+  end
+
+  it "has immutable attributes" do
+    [:name, :runner, :container, :workdir, :timeout, :cleanup].each do |attribute|
+      expect(spec.respond_to?(:"#{attribute}=")).to be(false)
+    end
+  end
+
+  describe "#to_h" do
+    it "returns an object that responds to `#to_json`" do
+      expect(spec.to_h.respond_to?(:to_json)).to be(true)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/livecheck/livecheck_spec.rb b/Library/Homebrew/test/livecheck/livecheck_spec.rb
index 9b68e3f94b13e..ecd5a0902d6bd 100644
--- a/Library/Homebrew/test/livecheck/livecheck_spec.rb
+++ b/Library/Homebrew/test/livecheck/livecheck_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/livecheck"
 
-describe Homebrew::Livecheck do
+RSpec.describe Homebrew::Livecheck do
   subject(:livecheck) { described_class }
 
   let(:cask_url) { "https://brew.sh/test-0.0.1.dmg" }
@@ -11,6 +10,7 @@
   let(:homepage_url) { "https://brew.sh" }
   let(:livecheck_url) { "https://formulae.brew.sh/api/formula/ruby.json" }
   let(:stable_url) { "https://brew.sh/test-0.0.1.tgz" }
+  let(:resource_url) { "https://brew.sh/foo-1.0.tar.gz" }
 
   let(:f) do
     formula("test") do
@@ -23,9 +23,30 @@
         url "https://formulae.brew.sh/api/formula/ruby.json"
         regex(/"stable":"(\d+(?:\.\d+)+)"/i)
       end
+
+      resource "foo" do
+        url "https://brew.sh/foo-1.0.tar.gz"
+        sha256 "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+
+        livecheck do
+          url "https://brew.sh/test/releases"
+          regex(/foo[._-]v?(\d+(?:\.\d+)+)\.t/i)
+        end
+      end
     end
   end
 
+  let(:f_stable_url_only) do
+    stable_url_s = stable_url
+
+    formula("test_stable_url_only") do
+      desc "Test formula with only a stable URL"
+      url stable_url_s
+    end
+  end
+
+  let(:r) { f.resources.first }
+
   let(:c) do
     Cask::CaskLoader.load(+<<-RUBY)
       cask "test" do
@@ -38,19 +59,21 @@
 
         livecheck do
           url "https://formulae.brew.sh/api/formula/ruby.json"
-          regex(/"stable":"(\d+(?:\.\d+)+)"/i)
+          regex(/"stable":"(\d+(?:.\d+)+)"/i)
         end
       end
     RUBY
   end
 
-  let(:f_duplicate_urls) do
-    formula("test_duplicate_urls") do
-      desc "Test formula with a duplicate URL"
-      homepage "https://github.com/Homebrew/brew.git"
-      url "https://brew.sh/test-0.0.1.tgz"
-      head "https://github.com/Homebrew/brew.git"
-    end
+  let(:c_no_checkable_urls) do
+    Cask::CaskLoader.load(+<<-RUBY)
+      cask "test_no_checkable_urls" do
+        version "1.2.3"
+
+        name "Test"
+        desc "Test cask with no checkable URLs"
+      end
+    RUBY
   end
 
   describe "::resolve_livecheck_reference" do
@@ -62,28 +85,26 @@
     end
   end
 
-  describe "::formula_name" do
-    it "returns the name of the formula" do
-      expect(livecheck.formula_name(f)).to eq("test")
+  describe "::package_or_resource_name" do
+    it "returns the name of a formula" do
+      expect(livecheck.package_or_resource_name(f)).to eq("test")
     end
 
-    it "returns the full name" do
-      expect(livecheck.formula_name(f, full_name: true)).to eq("test")
+    it "returns the full name of a formula" do
+      expect(livecheck.package_or_resource_name(f, full_name: true)).to eq("test")
     end
-  end
 
-  describe "::cask_name" do
-    it "returns the token of the cask" do
-      expect(livecheck.cask_name(c)).to eq("test")
+    it "returns the token of a cask" do
+      expect(livecheck.package_or_resource_name(c)).to eq("test")
     end
 
-    it "returns the full name of the cask" do
-      expect(livecheck.cask_name(c, full_name: true)).to eq("test")
+    it "returns the full name of a cask" do
+      expect(livecheck.package_or_resource_name(c, full_name: true)).to eq("test")
     end
   end
 
   describe "::status_hash" do
-    it "returns a hash containing the livecheck status" do
+    it "returns a hash containing the livecheck status for a formula" do
       expect(livecheck.status_hash(f, "error", ["Unable to get versions"]))
         .to eq({
           formula:  "test",
@@ -94,18 +115,47 @@
           },
         })
     end
+
+    it "returns a hash containing the livecheck status for a resource" do
+      expect(livecheck.status_hash(r, "error", ["Unable to get versions"]))
+        .to eq({
+          resource: "foo",
+          status:   "error",
+          messages: ["Unable to get versions"],
+          meta:     {
+            livecheckable: true,
+          },
+        })
+    end
   end
 
   describe "::livecheck_url_to_string" do
     let(:f_livecheck_url) do
+      homepage_url_s = homepage_url
+      stable_url_s = stable_url
+      head_url_s = head_url
+      resource_url_s = resource_url
+
       formula("test_livecheck_url") do
         desc "Test Livecheck URL formula"
-        homepage "https://brew.sh"
-        url "https://brew.sh/test-0.0.1.tgz"
-        head "https://github.com/Homebrew/brew.git"
+        homepage homepage_url_s
+        url stable_url_s
+        head head_url_s
+
+        resource "foo" do
+          url resource_url_s
+          sha256 "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+
+          livecheck do
+            url "https://brew.sh/test/releases"
+            regex(/foo[._-]v?(\d+(?:\.\d+)+)\.t/i)
+          end
+        end
       end
     end
 
+    let(:r_livecheck_url) { f_livecheck_url.resources.first }
+
     let(:c_livecheck_url) do
       Cask::CaskLoader.load(+<<-RUBY)
         cask "test_livecheck_url" do
@@ -119,41 +169,74 @@
       RUBY
     end
 
-    it "returns a URL string when given a livecheck_url string" do
-      f_livecheck_url.livecheck.url(livecheck_url)
+    it "returns a URL string when given a livecheck_url string for a formula" do
       expect(livecheck.livecheck_url_to_string(livecheck_url, f_livecheck_url)).to eq(livecheck_url)
     end
 
-    it "returns a URL symbol when given a valid livecheck_url symbol" do
-      f_livecheck_url.livecheck.url(:head)
-      expect(livecheck.livecheck_url_to_string(head_url, f_livecheck_url)).to eq(head_url)
-
-      f_livecheck_url.livecheck.url(:homepage)
-      expect(livecheck.livecheck_url_to_string(homepage_url, f_livecheck_url)).to eq(homepage_url)
-
-      c_livecheck_url.livecheck.url(:homepage)
-      expect(livecheck.livecheck_url_to_string(homepage_url, c_livecheck_url)).to eq(homepage_url)
-
-      f_livecheck_url.livecheck.url(:stable)
-      expect(livecheck.livecheck_url_to_string(stable_url, f_livecheck_url)).to eq(stable_url)
+    it "returns a URL string when given a livecheck_url string for a resource" do
+      expect(livecheck.livecheck_url_to_string(livecheck_url, r_livecheck_url)).to eq(livecheck_url)
+    end
 
-      c_livecheck_url.livecheck.url(:url)
-      expect(livecheck.livecheck_url_to_string(cask_url, c_livecheck_url)).to eq(cask_url)
+    it "returns a URL symbol when given a valid livecheck_url symbol" do
+      expect(livecheck.livecheck_url_to_string(:head, f_livecheck_url)).to eq(head_url)
+      expect(livecheck.livecheck_url_to_string(:homepage, f_livecheck_url)).to eq(homepage_url)
+      expect(livecheck.livecheck_url_to_string(:homepage, c_livecheck_url)).to eq(homepage_url)
+      expect(livecheck.livecheck_url_to_string(:stable, f_livecheck_url)).to eq(stable_url)
+      expect(livecheck.livecheck_url_to_string(:url, c_livecheck_url)).to eq(cask_url)
+      expect(livecheck.livecheck_url_to_string(:url, r_livecheck_url)).to eq(resource_url)
     end
 
     it "returns nil when not given a string or valid symbol" do
-      expect(livecheck.livecheck_url_to_string(nil, f_livecheck_url)).to be_nil
-      expect(livecheck.livecheck_url_to_string(nil, c_livecheck_url)).to be_nil
-      expect(livecheck.livecheck_url_to_string(:invalid_symbol, f_livecheck_url)).to be_nil
-      expect(livecheck.livecheck_url_to_string(:invalid_symbol, c_livecheck_url)).to be_nil
+      error_text = "`url :%<symbol>s` does not reference a checkable URL"
+
+      # Invalid symbol in any context
+      expect { livecheck.livecheck_url_to_string(:invalid_symbol, f_livecheck_url) }
+        .to raise_error(ArgumentError, format(error_text, symbol: :invalid_symbol))
+      expect { livecheck.livecheck_url_to_string(:invalid_symbol, c_livecheck_url) }
+        .to raise_error(ArgumentError, format(error_text, symbol: :invalid_symbol))
+      expect { livecheck.livecheck_url_to_string(:invalid_symbol, r_livecheck_url) }
+        .to raise_error(ArgumentError, format(error_text, symbol: :invalid_symbol))
+
+      # Valid symbol in provided context but referenced URL is not present
+      expect { livecheck.livecheck_url_to_string(:head, f_stable_url_only) }
+        .to raise_error(ArgumentError, format(error_text, symbol: :head))
+      expect { livecheck.livecheck_url_to_string(:homepage, f_stable_url_only) }
+        .to raise_error(ArgumentError, format(error_text, symbol: :homepage))
+      expect { livecheck.livecheck_url_to_string(:homepage, c_no_checkable_urls) }
+        .to raise_error(ArgumentError, format(error_text, symbol: :homepage))
+      expect { livecheck.livecheck_url_to_string(:url, c_no_checkable_urls) }
+        .to raise_error(ArgumentError, format(error_text, symbol: :url))
+
+      # Valid symbol but not in the provided context
+      expect { livecheck.livecheck_url_to_string(:head, c_livecheck_url) }
+        .to raise_error(ArgumentError, format(error_text, symbol: :head))
+      expect { livecheck.livecheck_url_to_string(:homepage, r_livecheck_url) }
+        .to raise_error(ArgumentError, format(error_text, symbol: :homepage))
+      expect { livecheck.livecheck_url_to_string(:stable, c_livecheck_url) }
+        .to raise_error(ArgumentError, format(error_text, symbol: :stable))
+      expect { livecheck.livecheck_url_to_string(:url, f_livecheck_url) }
+        .to raise_error(ArgumentError, format(error_text, symbol: :url))
     end
   end
 
   describe "::checkable_urls" do
+    let(:resource_url) { "https://brew.sh/foo-1.0.tar.gz" }
+    let(:f_duplicate_urls) do
+      formula("test_duplicate_urls") do
+        desc "Test formula with a duplicate URL"
+        homepage "https://github.com/Homebrew/brew.git"
+        url "https://brew.sh/test-0.0.1.tgz"
+        head "https://github.com/Homebrew/brew.git"
+      end
+    end
+
     it "returns the list of URLs to check" do
       expect(livecheck.checkable_urls(f)).to eq([stable_url, head_url, homepage_url])
       expect(livecheck.checkable_urls(c)).to eq([cask_url, homepage_url])
+      expect(livecheck.checkable_urls(r)).to eq([resource_url])
       expect(livecheck.checkable_urls(f_duplicate_urls)).to eq([stable_url, head_url])
+      expect(livecheck.checkable_urls(f_stable_url_only)).to eq([stable_url])
+      expect(livecheck.checkable_urls(c_no_checkable_urls)).to eq([])
     end
   end
 
@@ -186,7 +269,7 @@
 
           livecheck do
             url "https://formulae.brew.sh/api/formula/ruby.json"
-            regex(/"stable":"(\d+(?:\.\d+)+)"/i)
+            regex(/"stable":"(\d+(?:.\d+)+)"/i)
           end
         end
       RUBY
@@ -221,89 +304,4 @@
       expect(livecheck.use_homebrew_curl?(f_homebrew_curl, "test")).to be(false)
     end
   end
-
-  describe "::preprocess_url" do
-    let(:github_git_url_with_extension) { "https://github.com/Homebrew/brew.git" }
-
-    it "returns the unmodified URL for an unparseable URL" do
-      # Modeled after the `head` URL in the `ncp` formula
-      expect(livecheck.preprocess_url(":something:cvs:@cvs.brew.sh:/cvs"))
-        .to eq(":something:cvs:@cvs.brew.sh:/cvs")
-    end
-
-    it "returns the unmodified URL for a GitHub URL ending in .git" do
-      expect(livecheck.preprocess_url(github_git_url_with_extension))
-        .to eq(github_git_url_with_extension)
-    end
-
-    it "returns the Git repository URL for a GitHub URL not ending in .git" do
-      expect(livecheck.preprocess_url("https://github.com/Homebrew/brew"))
-        .to eq(github_git_url_with_extension)
-    end
-
-    it "returns the unmodified URL for a GitHub /releases/latest URL" do
-      expect(livecheck.preprocess_url("https://github.com/Homebrew/brew/releases/latest"))
-        .to eq("https://github.com/Homebrew/brew/releases/latest")
-    end
-
-    it "returns the Git repository URL for a GitHub AWS URL" do
-      expect(livecheck.preprocess_url("https://github.s3.amazonaws.com/downloads/Homebrew/brew/1.0.0.tar.gz"))
-        .to eq(github_git_url_with_extension)
-    end
-
-    it "returns the Git repository URL for a github.com/downloads/... URL" do
-      expect(livecheck.preprocess_url("https://github.com/downloads/Homebrew/brew/1.0.0.tar.gz"))
-        .to eq(github_git_url_with_extension)
-    end
-
-    it "returns the Git repository URL for a GitHub tag archive URL" do
-      expect(livecheck.preprocess_url("https://github.com/Homebrew/brew/archive/1.0.0.tar.gz"))
-        .to eq(github_git_url_with_extension)
-    end
-
-    it "returns the Git repository URL for a GitHub release archive URL" do
-      expect(livecheck.preprocess_url("https://github.com/Homebrew/brew/releases/download/1.0.0/brew-1.0.0.tar.gz"))
-        .to eq(github_git_url_with_extension)
-    end
-
-    it "returns the Git repository URL for a gitlab.com archive URL" do
-      expect(livecheck.preprocess_url("https://gitlab.com/Homebrew/brew/-/archive/1.0.0/brew-1.0.0.tar.gz"))
-        .to eq("https://gitlab.com/Homebrew/brew.git")
-    end
-
-    it "returns the Git repository URL for a self-hosted GitLab archive URL" do
-      expect(livecheck.preprocess_url("https://brew.sh/Homebrew/brew/-/archive/1.0.0/brew-1.0.0.tar.gz"))
-        .to eq("https://brew.sh/Homebrew/brew.git")
-    end
-
-    it "returns the Git repository URL for a Codeberg archive URL" do
-      expect(livecheck.preprocess_url("https://codeberg.org/Homebrew/brew/archive/brew-1.0.0.tar.gz"))
-        .to eq("https://codeberg.org/Homebrew/brew.git")
-    end
-
-    it "returns the Git repository URL for a Gitea archive URL" do
-      expect(livecheck.preprocess_url("https://gitea.com/Homebrew/brew/archive/brew-1.0.0.tar.gz"))
-        .to eq("https://gitea.com/Homebrew/brew.git")
-    end
-
-    it "returns the Git repository URL for an Opendev archive URL" do
-      expect(livecheck.preprocess_url("https://opendev.org/Homebrew/brew/archive/brew-1.0.0.tar.gz"))
-        .to eq("https://opendev.org/Homebrew/brew.git")
-    end
-
-    it "returns the Git repository URL for a tildegit archive URL" do
-      expect(livecheck.preprocess_url("https://tildegit.org/Homebrew/brew/archive/brew-1.0.0.tar.gz"))
-        .to eq("https://tildegit.org/Homebrew/brew.git")
-    end
-
-    it "returns the Git repository URL for a LOL Git archive URL" do
-      expect(livecheck.preprocess_url("https://lolg.it/Homebrew/brew/archive/brew-1.0.0.tar.gz"))
-        .to eq("https://lolg.it/Homebrew/brew.git")
-    end
-
-    it "returns the Git repository URL for a sourcehut archive URL" do
-      expect(livecheck.preprocess_url("https://git.sr.ht/~Homebrew/brew/archive/1.0.0.tar.gz"))
-        .to eq("https://git.sr.ht/~Homebrew/brew")
-    end
-  end
 end
diff --git a/Library/Homebrew/test/livecheck/livecheck_version_spec.rb b/Library/Homebrew/test/livecheck/livecheck_version_spec.rb
index 95f445cd87a9b..b5c38fd78f665 100644
--- a/Library/Homebrew/test/livecheck/livecheck_version_spec.rb
+++ b/Library/Homebrew/test/livecheck/livecheck_version_spec.rb
@@ -1,11 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/livecheck_version"
 
-describe Homebrew::Livecheck::LivecheckVersion do
+RSpec.describe Homebrew::Livecheck::LivecheckVersion do
   let(:formula) { instance_double(Formula) }
   let(:cask) { instance_double(Cask::Cask) }
+  let(:resource) { instance_double(Resource) }
 
   before do
     # Case statements use #=== for case equality purposes
@@ -13,20 +13,24 @@
     allow(Formula).to receive(:===).with(formula).and_return(true)
     allow(Cask::Cask).to receive(:===).and_call_original
     allow(Cask::Cask).to receive(:===).with(cask).and_return(true)
+    allow(Resource).to receive(:===).and_call_original
+    allow(Resource).to receive(:===).with(resource).and_return(true)
   end
 
   specify "::create" do
     expect(described_class.create(formula, Version.new("1.1.6")).versions).to eq ["1.1.6"]
     expect(described_class.create(formula, Version.new("2.19.0,1.8.0")).versions).to eq ["2.19.0,1.8.0"]
-    expect(described_class.create(formula, Version.new("1.0,100:1426778671")).versions).to eq ["1.0,100:1426778671"]
     expect(described_class.create(formula, Version.new("0.17.0,20210111183933,226")).versions)
       .to eq ["0.17.0,20210111183933,226"]
 
     expect(described_class.create(cask, Version.new("1.1.6")).versions).to eq ["1.1.6"]
     expect(described_class.create(cask, Version.new("2.19.0,1.8.0")).versions).to eq ["2.19.0", "1.8.0"]
-    expect(described_class.create(cask, Version.new("1.0,100:1426778671")).versions)
-      .to eq ["1.0", "100", "1426778671"]
     expect(described_class.create(cask, Version.new("0.17.0,20210111183933,226")).versions)
       .to eq ["0.17.0", "20210111183933", "226"]
+
+    expect(described_class.create(resource, Version.new("1.1.6")).versions).to eq ["1.1.6"]
+    expect(described_class.create(resource, Version.new("2.19.0,1.8.0")).versions).to eq ["2.19.0,1.8.0"]
+    expect(described_class.create(resource, Version.new("0.17.0,20210111183933,226")).versions)
+      .to eq ["0.17.0,20210111183933,226"]
   end
 end
diff --git a/Library/Homebrew/test/livecheck/skip_conditions_spec.rb b/Library/Homebrew/test/livecheck/skip_conditions_spec.rb
index 5b34d12c75f53..7187ef7dada24 100644
--- a/Library/Homebrew/test/livecheck/skip_conditions_spec.rb
+++ b/Library/Homebrew/test/livecheck/skip_conditions_spec.rb
@@ -1,9 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
+require "livecheck/livecheck"
 require "livecheck/skip_conditions"
 
-describe Homebrew::Livecheck::SkipConditions do
+RSpec.describe Homebrew::Livecheck::SkipConditions do
   subject(:skip_conditions) { described_class }
 
   let(:formulae) do
@@ -31,11 +31,6 @@
         url "https://brew.sh/test-0.0.1.tgz"
         disable! date: "2020-06-25", because: :unmaintained
       end,
-      versioned:           formula("test@0.0.1") do
-        desc "Versioned test formula"
-        homepage "https://brew.sh"
-        url "https://brew.sh/test-0.0.1.tgz"
-      end,
       head_only:           formula("test_head_only") do
         desc "HEAD-only test formula"
         homepage "https://brew.sh"
@@ -74,6 +69,11 @@
           skip "Not maintained"
         end
       end,
+      versioned:           formula("test@0.0.1") do
+        desc "Versioned test formula"
+        homepage "https://brew.sh"
+        url "https://brew.sh/test-0.0.1.tgz"
+      end,
     }
   end
 
@@ -92,17 +92,38 @@
           regex(/"stable":"(\d+(?:\.\d+)+)"/i)
         end
       end,
-      discontinued:      Cask::Cask.new("test_discontinued") do
+      deprecated:        Cask::Cask.new("test_deprecated") do
         version "0.0.1"
         sha256 :no_check
 
         url "https://brew.sh/test-0.0.1.tgz"
-        name "Test Discontinued"
-        desc "Discontinued test cask"
+        name "Test Deprecate"
+        desc "Deprecated test cask"
         homepage "https://brew.sh"
 
-        caveats do
-          discontinued
+        deprecate! date: "2020-06-25", because: :discontinued
+      end,
+      disabled:          Cask::Cask.new("test_disabled") do
+        version "0.0.1"
+        sha256 :no_check
+
+        url "https://brew.sh/test-0.0.1.tgz"
+        name "Test Disable"
+        desc "Disabled test cask"
+        homepage "https://brew.sh"
+
+        disable! date: "2020-06-25", because: :discontinued
+      end,
+      extract_plist:     Cask::Cask.new("test_extract_plist_skip") do
+        version "0.0.1"
+
+        url "https://brew.sh/test-0.0.1.tgz"
+        name "Test ExtractPlist Skip"
+        desc "Skipped test cask"
+        homepage "https://brew.sh"
+
+        livecheck do
+          strategy :extract_plist
         end
       end,
       latest:            Cask::Cask.new("test_latest") do
@@ -224,13 +245,28 @@
         },
       },
       cask:    {
-        discontinued:      {
-          cask:   "test_discontinued",
-          status: "discontinued",
+        deprecated:        {
+          cask:   "test_deprecated",
+          status: "deprecated",
           meta:   {
             livecheckable: false,
           },
         },
+        disabled:          {
+          cask:   "test_disabled",
+          status: "disabled",
+          meta:   {
+            livecheckable: false,
+          },
+        },
+        extract_plist:     {
+          cask:     "test_extract_plist_skip",
+          status:   "skipped",
+          messages: ["Use `--extract-plist` to enable checking multiple casks with ExtractPlist strategy"],
+          meta:     {
+            livecheckable: true,
+          },
+        },
         latest:            {
           cask:   "test_latest",
           status: "latest",
@@ -324,10 +360,24 @@
       end
     end
 
-    context "when a cask without a livecheckable is discontinued" do
+    context "when a cask without a livecheckable is deprecated" do
+      it "skips" do
+        expect(skip_conditions.skip_information(casks[:deprecated]))
+          .to eq(status_hashes[:cask][:deprecated])
+      end
+    end
+
+    context "when a cask without a livecheckable is disabled" do
       it "skips" do
-        expect(skip_conditions.skip_information(casks[:discontinued]))
-          .to eq(status_hashes[:cask][:discontinued])
+        expect(skip_conditions.skip_information(casks[:disabled]))
+          .to eq(status_hashes[:cask][:disabled])
+      end
+    end
+
+    context "when a cask has a `livecheck` block using `ExtractPlist` and `--extract-plist` is not used" do
+      it "skips" do
+        expect(skip_conditions.skip_information(casks[:extract_plist], extract_plist: false))
+          .to eq(status_hashes[:cask][:extract_plist])
       end
     end
 
@@ -426,10 +476,26 @@
       end
     end
 
-    context "when a cask without a livecheckable is discontinued" do
+    context "when a cask without a livecheckable is deprecated" do
+      it "errors" do
+        expect { skip_conditions.referenced_skip_information(casks[:deprecated], original_name) }
+          .to raise_error(RuntimeError, "Referenced cask (test_deprecated) is skipped as deprecated")
+      end
+    end
+
+    context "when a cask without a livecheckable is disabled" do
       it "errors" do
-        expect { skip_conditions.referenced_skip_information(casks[:discontinued], original_name) }
-          .to raise_error(RuntimeError, "Referenced cask (test_discontinued) is skipped as discontinued")
+        expect { skip_conditions.referenced_skip_information(casks[:disabled], original_name) }
+          .to raise_error(RuntimeError, "Referenced cask (test_disabled) is skipped as disabled")
+      end
+    end
+
+    context "when a cask has a `livecheck` block using `ExtractPlist` and `--extract-plist` is not used" do
+      it "skips" do
+        expect do
+          skip_conditions.referenced_skip_information(casks[:extract_plist], original_name, extract_plist: false)
+        end
+          .to raise_error(RuntimeError, "Referenced cask (test_extract_plist_skip) is automatically skipped")
       end
     end
 
@@ -535,10 +601,18 @@
       end
     end
 
-    context "when the cask is discontinued without a livecheckable" do
+    context "when the cask is deprecated without a livecheckable" do
       it "prints skip information" do
-        expect { skip_conditions.print_skip_information(status_hashes[:cask][:discontinued]) }
-          .to output("test_discontinued: discontinued\n").to_stdout
+        expect { skip_conditions.print_skip_information(status_hashes[:cask][:deprecated]) }
+          .to output("test_deprecated: deprecated\n").to_stdout
+          .and not_to_output.to_stderr
+      end
+    end
+
+    context "when the cask is disabled without a livecheckable" do
+      it "prints skip information" do
+        expect { skip_conditions.print_skip_information(status_hashes[:cask][:disabled]) }
+          .to output("test_disabled: disabled\n").to_stdout
           .and not_to_output.to_stderr
       end
     end
@@ -576,10 +650,6 @@
         expect { skip_conditions.print_skip_information({}) }
           .to not_to_output.to_stdout
           .and not_to_output.to_stderr
-
-        expect { skip_conditions.print_skip_information(nil) }
-          .to not_to_output.to_stdout
-          .and not_to_output.to_stderr
       end
     end
   end
diff --git a/Library/Homebrew/test/livecheck/strategy/apache_spec.rb b/Library/Homebrew/test/livecheck/strategy/apache_spec.rb
index 4ed79a465c26c..befc0b55cd9b5 100644
--- a/Library/Homebrew/test/livecheck/strategy/apache_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/apache_spec.rb
@@ -1,12 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy"
 
-describe Homebrew::Livecheck::Strategy::Apache do
+RSpec.describe Homebrew::Livecheck::Strategy::Apache do
   subject(:apache) { described_class }
 
-  let(:apache_urls) {
+  let(:apache_urls) do
     {
       version_dir:                    "https://www.apache.org/dyn/closer.lua?path=abc/1.2.3/def-1.2.3.tar.gz",
       version_dir_root:               "https://www.apache.org/dyn/closer.lua?path=/abc/1.2.3/def-1.2.3.tar.gz",
@@ -26,10 +25,10 @@
       mirrors_name_and_version_dir:   "https://www.apache.org/dyn/mirrors/mirrors.cgi?action=download&filename=abc/def-1.2.3/ghi-1.2.3.tar.gz",
       mirrors_name_dir_bin:           "https://www.apache.org/dyn/mirrors/mirrors.cgi?action=download&filename=abc/def/ghi-1.2.3-bin.tar.gz",
     }
-  }
+  end
   let(:non_apache_url) { "https://brew.sh/test" }
 
-  let(:generated) {
+  let(:generated) do
     values = {
       version_dir:          {
         url:   "https://archive.apache.org/dist/abc/",
@@ -60,7 +59,7 @@
     values[:mirrors_name_dir_bin] = values[:name_dir_bin]
 
     values
-  }
+  end
 
   describe "::match?" do
     it "returns true for an Apache URL" do
diff --git a/Library/Homebrew/test/livecheck/strategy/bitbucket_spec.rb b/Library/Homebrew/test/livecheck/strategy/bitbucket_spec.rb
index e816bd267269e..a0a9c3eb4786c 100644
--- a/Library/Homebrew/test/livecheck/strategy/bitbucket_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/bitbucket_spec.rb
@@ -1,31 +1,30 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy"
 
-describe Homebrew::Livecheck::Strategy::Bitbucket do
+RSpec.describe Homebrew::Livecheck::Strategy::Bitbucket do
   subject(:bitbucket) { described_class }
 
-  let(:bitbucket_urls) {
+  let(:bitbucket_urls) do
     {
       get:       "https://bitbucket.org/abc/def/get/1.2.3.tar.gz",
       downloads: "https://bitbucket.org/abc/def/downloads/ghi-1.2.3.tar.gz",
     }
-  }
+  end
   let(:non_bitbucket_url) { "https://brew.sh/test" }
 
-  let(:generated) {
+  let(:generated) do
     {
       get:       {
         url:   "https://bitbucket.org/abc/def/downloads/?tab=tags",
-        regex: /href=.*?v?(\d+(?:\.\d+)+)\.t/i,
+        regex: /<td[^>]*?class="name"[^>]*?>\s*v?(\d+(?:\.\d+)+)\s*?</im,
       },
       downloads: {
         url:   "https://bitbucket.org/abc/def/downloads/",
         regex: /href=.*?ghi-v?(\d+(?:\.\d+)+)\.t/i,
       },
     }
-  }
+  end
 
   describe "::match?" do
     it "returns true for a Bitbucket URL" do
diff --git a/Library/Homebrew/test/livecheck/strategy/cpan_spec.rb b/Library/Homebrew/test/livecheck/strategy/cpan_spec.rb
index 9af1d43aebfc9..b1dafb6fb97ba 100644
--- a/Library/Homebrew/test/livecheck/strategy/cpan_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/cpan_spec.rb
@@ -1,20 +1,19 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy"
 
-describe Homebrew::Livecheck::Strategy::Cpan do
+RSpec.describe Homebrew::Livecheck::Strategy::Cpan do
   subject(:cpan) { described_class }
 
-  let(:cpan_urls) {
+  let(:cpan_urls) do
     {
       no_subdirectory:   "https://cpan.metacpan.org/authors/id/H/HO/HOMEBREW/Brew-v1.2.3.tar.gz",
       with_subdirectory: "https://cpan.metacpan.org/authors/id/H/HO/HOMEBREW/brew/brew-v1.2.3.tar.gz",
     }
-  }
+  end
   let(:non_cpan_url) { "https://brew.sh/test" }
 
-  let(:generated) {
+  let(:generated) do
     {
       no_subdirectory:   {
         url:   "https://cpan.metacpan.org/authors/id/H/HO/HOMEBREW/",
@@ -25,7 +24,7 @@
         regex: /href=.*?brew[._-]v?(\d+(?:\.\d+)*)\.t/i,
       },
     }
-  }
+  end
 
   describe "::match?" do
     it "returns true for a CPAN URL" do
diff --git a/Library/Homebrew/test/livecheck/strategy/crate_spec.rb b/Library/Homebrew/test/livecheck/strategy/crate_spec.rb
new file mode 100644
index 0000000000000..0f914ffb5e706
--- /dev/null
+++ b/Library/Homebrew/test/livecheck/strategy/crate_spec.rb
@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "livecheck/strategy"
+
+RSpec.describe Homebrew::Livecheck::Strategy::Crate do
+  subject(:crate) { described_class }
+
+  let(:crate_url) { "https://static.crates.io/crates/example/example-0.1.0.crate" }
+  let(:non_crate_url) { "https://brew.sh/test" }
+
+  let(:regex) { /^v?(\d+(?:\.\d+)+)$/i }
+
+  let(:generated) do
+    { url: "https://crates.io/api/v1/crates/example/versions" }
+  end
+
+  # This is a limited subset of a `versions` response object, for the sake of
+  # testing.
+  let(:content) do
+    <<~EOS
+      {
+        "versions": [
+          {
+            "crate": "example",
+            "created_at": "2023-01-03T00:00:00.000000+00:00",
+            "num": "1.0.2",
+            "updated_at": "2023-01-03T00:00:00.000000+00:00",
+            "yanked": true
+          },
+          {
+            "crate": "example",
+            "created_at": "2023-01-02T00:00:00.000000+00:00",
+            "num": "1.0.1",
+            "updated_at": "2023-01-02T00:00:00.000000+00:00",
+            "yanked": false
+          },
+          {
+            "crate": "example",
+            "created_at": "2023-01-01T00:00:00.000000+00:00",
+            "num": "1.0.0",
+            "updated_at": "2023-01-01T00:00:00.000000+00:00",
+            "yanked": false
+          }
+        ]
+      }
+    EOS
+  end
+
+  let(:matches) { ["1.0.0", "1.0.1"] }
+
+  let(:find_versions_return_hash) do
+    {
+      matches: {
+        "1.0.1" => Version.new("1.0.1"),
+        "1.0.0" => Version.new("1.0.0"),
+      },
+      regex:,
+      url:     generated[:url],
+    }
+  end
+
+  let(:find_versions_cached_return_hash) do
+    find_versions_return_hash.merge({ cached: true })
+  end
+
+  describe "::match?" do
+    it "returns true for a crate URL" do
+      expect(crate.match?(crate_url)).to be true
+    end
+
+    it "returns false for a non-crate URL" do
+      expect(crate.match?(non_crate_url)).to be false
+    end
+  end
+
+  describe "::generate_input_values" do
+    it "returns a hash containing url for a crate URL" do
+      expect(crate.generate_input_values(crate_url)).to eq(generated)
+    end
+
+    it "returns an empty hash for a non-crate URL" do
+      expect(crate.generate_input_values(non_crate_url)).to eq({})
+    end
+  end
+
+  describe "::find_versions" do
+    let(:match_data) do
+      cached = {
+        matches: matches.to_h { |v| [v, Version.new(v)] },
+        regex:   nil,
+        url:     generated[:url],
+        cached:  true,
+      }
+
+      {
+        cached:,
+        cached_default: cached.merge({ matches: {} }),
+      }
+    end
+
+    it "finds versions in provided content" do
+      expect(crate.find_versions(url: crate_url, regex:, provided_content: content))
+        .to eq(match_data[:cached].merge({ regex: }))
+
+      expect(crate.find_versions(url: crate_url, provided_content: content))
+        .to eq(match_data[:cached])
+    end
+
+    it "finds versions in provided content using a block" do
+      expect(crate.find_versions(url: crate_url, regex:, provided_content: content) do |json, regex|
+        json["versions"]&.map do |version|
+          next if version["yanked"] == true
+          next if (match = version["num"]&.match(regex)).blank?
+
+          match[1]
+        end
+      end).to eq(match_data[:cached].merge({ regex: }))
+
+      expect(crate.find_versions(url: crate_url, provided_content: content) do |json|
+        json["versions"]&.map do |version|
+          next if version["yanked"] == true
+          next if (match = version["num"]&.match(regex)).blank?
+
+          match[1]
+        end
+      end).to eq(match_data[:cached])
+    end
+
+    it "returns default match_data when block doesn't return version information" do
+      no_match_regex = /will_not_match/i
+
+      expect(crate.find_versions(url: crate_url, provided_content: '{"other":true}'))
+        .to eq(match_data[:cached_default])
+      expect(crate.find_versions(url: crate_url, provided_content: '{"versions":[{}]}'))
+        .to eq(match_data[:cached_default])
+      expect(crate.find_versions(url: crate_url, regex: no_match_regex, provided_content: content))
+        .to eq(match_data[:cached_default].merge({ regex: no_match_regex }))
+    end
+
+    it "returns default match_data when url is blank" do
+      expect(crate.find_versions(url: "") { "1.2.3" })
+        .to eq({ matches: {}, regex: nil, url: "" })
+    end
+
+    it "returns default match_data when content is blank" do
+      expect(crate.find_versions(url: crate_url, provided_content: "{}") { "1.2.3" })
+        .to eq(match_data[:cached_default])
+      expect(crate.find_versions(url: crate_url, provided_content: "") { "1.2.3" })
+        .to eq(match_data[:cached_default])
+    end
+  end
+end
diff --git a/Library/Homebrew/test/livecheck/strategy/electron_builder_spec.rb b/Library/Homebrew/test/livecheck/strategy/electron_builder_spec.rb
index 64c7f64720c20..24143c280eb87 100644
--- a/Library/Homebrew/test/livecheck/strategy/electron_builder_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/electron_builder_spec.rb
@@ -1,15 +1,16 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy"
 
-describe Homebrew::Livecheck::Strategy::ElectronBuilder do
+RSpec.describe Homebrew::Livecheck::Strategy::ElectronBuilder do
   subject(:electron_builder) { described_class }
 
-  let(:yaml_url) { "https://www.example.com/example/latest-mac.yml" }
-  let(:non_yaml_url) { "https://brew.sh/test" }
+  let(:http_url) { "https://www.example.com/example/latest-mac.yml" }
+  let(:non_http_url) { "ftp://brew.sh/" }
 
-  let(:electron_builder_yaml) {
+  let(:regex) { /Example[._-]v?(\d+(?:\.\d+)+)[._-]mac\.zip/i }
+
+  let(:content) do
     <<~EOS
       version: 1.2.3
       files:
@@ -24,69 +25,82 @@
       sha512: MDXR0pxozBJjxxbtUQJOnhiaiiQkryLAwtcVjlnNiz30asm/PtSxlxWKFYN3kV/kl+jriInJrGypuzajTF6XIA==
       releaseDate: '2000-01-01T00:00:00.000Z'
     EOS
-  }
-  let(:mac_regex) { /Example[._-]v?(\d+(?:\.\d+)+)[._-]mac\.zip/i }
+  end
+
+  let(:content_timestamp) do
+    # An electron-builder YAML file may use a timestamp instead of an explicit
+    # string value (with quotes) for `releaseDate`, so we need to make sure that
+    # `ElectronBuilder#versions_from_content` won't encounter an error in this
+    # scenario (e.g. `Tried to load unspecified class: Time`).
+    content.sub(/releaseDate:\s*'([^']+)'/, 'releaseDate: \1')
+  end
 
-  let(:versions) { ["1.2.3"] }
+  let(:content_matches) { ["1.2.3"] }
+
+  let(:find_versions_return_hash) do
+    {
+      matches: {
+        "1.2.3" => Version.new("1.2.3"),
+      },
+      regex:   nil,
+      url:     http_url,
+    }
+  end
+
+  let(:find_versions_cached_return_hash) do
+    find_versions_return_hash.merge({ cached: true })
+  end
 
   describe "::match?" do
     it "returns true for a YAML file URL" do
-      expect(electron_builder.match?(yaml_url)).to be true
+      expect(electron_builder.match?(http_url)).to be true
     end
 
     it "returns false for non-YAML URL" do
-      expect(electron_builder.match?(non_yaml_url)).to be false
+      expect(electron_builder.match?(non_http_url)).to be false
     end
   end
 
-  describe "::versions_from_content" do
-    it "returns an empty array if content is blank" do
-      expect(electron_builder.versions_from_content("")).to eq([])
-    end
-
-    it "returns an array of version strings when given YAML text" do
-      expect(electron_builder.versions_from_content(electron_builder_yaml)).to eq(versions)
-    end
-
-    it "returns an array of version strings when given YAML text and a block" do
-      # Returning a string from block
-      expect(
-        electron_builder.versions_from_content(electron_builder_yaml) do |yaml|
-          yaml["version"].sub("3", "4")
-        end,
-      ).to eq(["1.2.4"])
-
-      # Returning an array of strings from block
-      expect(electron_builder.versions_from_content(electron_builder_yaml) { versions }).to eq(versions)
+  describe "::find_versions?" do
+    it "finds versions in provided_content using a block" do
+      expect(electron_builder.find_versions(url: http_url, provided_content: content))
+        .to eq(find_versions_cached_return_hash)
+
+      expect(electron_builder.find_versions(url: http_url, regex:, provided_content: content) do |yaml, regex|
+        yaml["path"][regex, 1]
+      end).to eq(find_versions_cached_return_hash.merge({ regex: }))
+
+      expect(electron_builder.find_versions(
+        url:              http_url,
+        regex:,
+        provided_content: content_timestamp,
+      ) do |yaml, regex|
+        yaml["path"][regex, 1]
+      end).to eq(find_versions_cached_return_hash.merge({ regex: }))
+
+      # NOTE: A regex should be provided using the `#regex` method in a
+      #       `livecheck` block but we're using a regex literal in the `strategy`
+      #       block here simply to ensure this method works as expected when a
+      #       regex isn't provided.
+      expect(electron_builder.find_versions(url: http_url, provided_content: content) do |yaml|
+        regex = /^v?(\d+(?:\.\d+)+)$/i
+        yaml["version"][regex, 1]
+      end).to eq(find_versions_cached_return_hash)
     end
 
-    it "returns an array of version strings when given YAML text, a regex, and a block" do
-      # Returning a string from block
-      expect(
-        electron_builder.versions_from_content(electron_builder_yaml, mac_regex) do |yaml, regex|
-          yaml["path"][regex, 1]
-        end,
-      ).to eq(versions)
-
-      # Returning an array of strings from block
-      expect(
-        electron_builder.versions_from_content(electron_builder_yaml, mac_regex) do |yaml, regex|
-          yaml["files"]&.map do |file|
-            next if file["url"].blank?
-
-            file["url"][regex, 1]
-          end
-        end,
-      ).to eq(versions)
+    it "errors if a block is not provided" do
+      expect { electron_builder.find_versions(url: http_url, regex:, provided_content: content) }
+        .to raise_error(ArgumentError, "ElectronBuilder only supports a regex when using a `strategy` block")
     end
 
-    it "allows a nil return from a block" do
-      expect(electron_builder.versions_from_content(electron_builder_yaml) { next }).to eq([])
+    it "returns default match_data when url is blank" do
+      expect(electron_builder.find_versions(url: "") { "1.2.3" })
+        .to eq({ matches: {}, regex: nil, url: "" })
     end
 
-    it "errors on an invalid return type from a block" do
-      expect { electron_builder.versions_from_content(electron_builder_yaml) { 123 } }
-        .to raise_error(TypeError, Homebrew::Livecheck::Strategy::INVALID_BLOCK_RETURN_VALUE_MSG)
+    it "returns default match_data when content is blank" do
+      expect(electron_builder.find_versions(url: http_url, provided_content: "") { "1.2.3" })
+        .to eq({ matches: {}, regex: nil, url: http_url, cached: true })
     end
   end
 end
diff --git a/Library/Homebrew/test/livecheck/strategy/extract_plist_spec.rb b/Library/Homebrew/test/livecheck/strategy/extract_plist_spec.rb
index 5e7e03f669e1e..6f714b9fe7942 100644
--- a/Library/Homebrew/test/livecheck/strategy/extract_plist_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/extract_plist_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy"
 require "bundle_version"
 
-describe Homebrew::Livecheck::Strategy::ExtractPlist do
+RSpec.describe Homebrew::Livecheck::Strategy::ExtractPlist do
   subject(:extract_plist) { described_class }
 
   let(:http_url) { "https://brew.sh/blog/" }
@@ -73,7 +72,7 @@
       ).to eq(versions)
     end
 
-    it "returns an array of version strings when given Items, a regex, and a block" do
+    it "returns an array of version strings when given `Item`s, a regex and a block" do
       # Returning a string from block
       expect(
         extract_plist.versions_from_items(multipart_items, multipart_regex) do |items, regex|
@@ -106,4 +105,24 @@
         .to raise_error(TypeError, Homebrew::Livecheck::Strategy::INVALID_BLOCK_RETURN_VALUE_MSG)
     end
   end
+
+  describe "::find_versions" do
+    it "returns a for an installer artifact" do
+      cask = Cask::CaskLoader.load(cask_path("livecheck/livecheck-installer-manual"))
+      installer_artifact = cask.artifacts.first
+
+      expect(installer_artifact).to be_a(Cask::Artifact::Installer)
+      expect(installer_artifact.path).to be_a(Pathname)
+    end
+
+    it "uses the provided livecheck url", :needs_macos do
+      cask = Cask::CaskLoader.load(cask_path("livecheck/livecheck-extract-plist"))
+      livecheck_url = "file://#{TEST_FIXTURE_DIR}/cask/caffeine-with-plist.zip"
+
+      expect(Homebrew::UnversionedCaskChecker).to receive(:new).with(cask).and_call_original
+      result = described_class.find_versions(cask:, url: livecheck_url)
+      expect(result)
+        .to eq({ matches: { "1.2.3"=> @version="1.2.3" }, regex: nil, url: livecheck_url })
+    end
+  end
 end
diff --git a/Library/Homebrew/test/livecheck/strategy/git_spec.rb b/Library/Homebrew/test/livecheck/strategy/git_spec.rb
index cb1a0106a198b..506ebb072be40 100644
--- a/Library/Homebrew/test/livecheck/strategy/git_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/git_spec.rb
@@ -1,36 +1,35 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy"
 
-describe Homebrew::Livecheck::Strategy::Git do
+RSpec.describe Homebrew::Livecheck::Strategy::Git do
   subject(:git) { described_class }
 
   let(:git_url) { "https://github.com/Homebrew/brew.git" }
   let(:non_git_url) { "https://brew.sh/test" }
 
-  let(:tags) {
+  let(:tags) do
     {
       normal:  ["brew/1.2", "brew/1.2.1", "brew/1.2.2", "brew/1.2.3", "brew/1.2.4", "1.2.5"],
       hyphens: ["brew/1-2", "brew/1-2-1", "brew/1-2-2", "brew/1-2-3", "brew/1-2-4", "1-2-5"],
     }
-  }
+  end
 
-  let(:regexes) {
+  let(:regexes) do
     {
       standard: /^v?(\d+(?:\.\d+)+)$/i,
       hyphens:  /^v?(\d+(?:[.-]\d+)+)$/i,
       brew:     %r{^brew/v?(\d+(?:\.\d+)+)$}i,
     }
-  }
+  end
 
-  let(:versions) {
+  let(:versions) do
     {
       default:        ["1.2", "1.2.1", "1.2.2", "1.2.3", "1.2.4", "1.2.5"],
       standard_regex: ["1.2.5"],
       brew_regex:     ["1.2", "1.2.1", "1.2.2", "1.2.3", "1.2.4"],
     }
-  }
+  end
 
   describe "::tag_info", :needs_network do
     it "returns the Git tags for the provided remote URL that match the regex provided" do
@@ -38,6 +37,91 @@
     end
   end
 
+  describe "::preprocess_url" do
+    let(:github_git_url_with_extension) { "https://github.com/Homebrew/brew.git" }
+
+    it "returns the unmodified URL for an unparsable URL" do
+      # Modeled after the `head` URL in the `ncp` formula
+      expect(git.preprocess_url(":something:cvs:@cvs.brew.sh:/cvs"))
+        .to eq(":something:cvs:@cvs.brew.sh:/cvs")
+    end
+
+    it "returns the unmodified URL for a GitHub URL ending in .git" do
+      expect(git.preprocess_url(github_git_url_with_extension))
+        .to eq(github_git_url_with_extension)
+    end
+
+    it "returns the Git repository URL for a GitHub URL not ending in .git" do
+      expect(git.preprocess_url("https://github.com/Homebrew/brew"))
+        .to eq(github_git_url_with_extension)
+    end
+
+    it "returns the unmodified URL for a GitHub /releases/latest URL" do
+      expect(git.preprocess_url("https://github.com/Homebrew/brew/releases/latest"))
+        .to eq("https://github.com/Homebrew/brew/releases/latest")
+    end
+
+    it "returns the Git repository URL for a GitHub AWS URL" do
+      expect(git.preprocess_url("https://github.s3.amazonaws.com/downloads/Homebrew/brew/1.0.0.tar.gz"))
+        .to eq(github_git_url_with_extension)
+    end
+
+    it "returns the Git repository URL for a github.com/downloads/... URL" do
+      expect(git.preprocess_url("https://github.com/downloads/Homebrew/brew/1.0.0.tar.gz"))
+        .to eq(github_git_url_with_extension)
+    end
+
+    it "returns the Git repository URL for a GitHub tag archive URL" do
+      expect(git.preprocess_url("https://github.com/Homebrew/brew/archive/1.0.0.tar.gz"))
+        .to eq(github_git_url_with_extension)
+    end
+
+    it "returns the Git repository URL for a GitHub release archive URL" do
+      expect(git.preprocess_url("https://github.com/Homebrew/brew/releases/download/1.0.0/brew-1.0.0.tar.gz"))
+        .to eq(github_git_url_with_extension)
+    end
+
+    it "returns the Git repository URL for a gitlab.com archive URL" do
+      expect(git.preprocess_url("https://gitlab.com/Homebrew/brew/-/archive/1.0.0/brew-1.0.0.tar.gz"))
+        .to eq("https://gitlab.com/Homebrew/brew.git")
+    end
+
+    it "returns the Git repository URL for a self-hosted GitLab archive URL" do
+      expect(git.preprocess_url("https://brew.sh/Homebrew/brew/-/archive/1.0.0/brew-1.0.0.tar.gz"))
+        .to eq("https://brew.sh/Homebrew/brew.git")
+    end
+
+    it "returns the Git repository URL for a Codeberg archive URL" do
+      expect(git.preprocess_url("https://codeberg.org/Homebrew/brew/archive/brew-1.0.0.tar.gz"))
+        .to eq("https://codeberg.org/Homebrew/brew.git")
+    end
+
+    it "returns the Git repository URL for a Gitea archive URL" do
+      expect(git.preprocess_url("https://gitea.com/Homebrew/brew/archive/brew-1.0.0.tar.gz"))
+        .to eq("https://gitea.com/Homebrew/brew.git")
+    end
+
+    it "returns the Git repository URL for an Opendev archive URL" do
+      expect(git.preprocess_url("https://opendev.org/Homebrew/brew/archive/brew-1.0.0.tar.gz"))
+        .to eq("https://opendev.org/Homebrew/brew.git")
+    end
+
+    it "returns the Git repository URL for a tildegit archive URL" do
+      expect(git.preprocess_url("https://tildegit.org/Homebrew/brew/archive/brew-1.0.0.tar.gz"))
+        .to eq("https://tildegit.org/Homebrew/brew.git")
+    end
+
+    it "returns the Git repository URL for a LOL Git archive URL" do
+      expect(git.preprocess_url("https://lolg.it/Homebrew/brew/archive/brew-1.0.0.tar.gz"))
+        .to eq("https://lolg.it/Homebrew/brew.git")
+    end
+
+    it "returns the Git repository URL for a sourcehut archive URL" do
+      expect(git.preprocess_url("https://git.sr.ht/~Homebrew/brew/archive/1.0.0.tar.gz"))
+        .to eq("https://git.sr.ht/~Homebrew/brew")
+    end
+  end
+
   describe "::match?" do
     it "returns true for a Git repository URL" do
       expect(git.match?(git_url)).to be true
diff --git a/Library/Homebrew/test/livecheck/strategy/github_latest_spec.rb b/Library/Homebrew/test/livecheck/strategy/github_latest_spec.rb
index dcd170cadfe7f..f527b96c68a8a 100644
--- a/Library/Homebrew/test/livecheck/strategy/github_latest_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/github_latest_spec.rb
@@ -1,25 +1,27 @@
-# typed: false
 # frozen_string_literal: true
 
+require "livecheck/strategy/github_releases"
 require "livecheck/strategy/github_latest"
 
-describe Homebrew::Livecheck::Strategy::GithubLatest do
+RSpec.describe Homebrew::Livecheck::Strategy::GithubLatest do
   subject(:github_latest) { described_class }
 
-  let(:github_urls) {
+  let(:github_urls) do
     {
       release_artifact:  "https://github.com/abc/def/releases/download/1.2.3/ghi-1.2.3.tar.gz",
       tag_archive:       "https://github.com/abc/def/archive/v1.2.3.tar.gz",
       repository_upload: "https://github.com/downloads/abc/def/ghi-1.2.3.tar.gz",
     }
-  }
+  end
   let(:non_github_url) { "https://brew.sh/test" }
 
-  let(:generated) {
+  let(:generated) do
     {
-      url: "https://github.com/abc/def/releases/latest",
+      url:        "https://api.github.com/repos/abc/def/releases/latest",
+      username:   "abc",
+      repository: "def",
     }
-  }
+  end
 
   describe "::match?" do
     it "returns true for a GitHub release artifact URL" do
@@ -52,7 +54,7 @@
       expect(github_latest.generate_input_values(github_urls[:repository_upload])).to eq(generated)
     end
 
-    it "returns an empty hash for a non-Github URL" do
+    it "returns an empty hash for a non-GitHub URL" do
       expect(github_latest.generate_input_values(non_github_url)).to eq({})
     end
   end
diff --git a/Library/Homebrew/test/livecheck/strategy/github_releases_spec.rb b/Library/Homebrew/test/livecheck/strategy/github_releases_spec.rb
new file mode 100644
index 0000000000000..8b9effa65b222
--- /dev/null
+++ b/Library/Homebrew/test/livecheck/strategy/github_releases_spec.rb
@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "livecheck/strategy"
+
+RSpec.describe Homebrew::Livecheck::Strategy::GithubReleases do
+  subject(:github_releases) { described_class }
+
+  let(:github_urls) do
+    {
+      release_artifact:  "https://github.com/abc/def/releases/download/1.2.3/ghi-1.2.3.tar.gz",
+      tag_archive:       "https://github.com/abc/def/archive/v1.2.3.tar.gz",
+      repository_upload: "https://github.com/downloads/abc/def/ghi-1.2.3.tar.gz",
+    }
+  end
+  let(:non_github_url) { "https://brew.sh/test" }
+
+  let(:regex) { github_releases::DEFAULT_REGEX }
+
+  let(:generated) do
+    {
+      url:        "https://api.github.com/repos/abc/def/releases",
+      username:   "abc",
+      repository: "def",
+    }
+  end
+
+  # For the sake of brevity, this is a limited subset of the information found
+  # in release objects in a response from the GitHub API. Some of these objects
+  # are somewhat representative of real world scenarios but others are
+  # contrived examples for the sake of exercising code paths.
+  let(:content) do
+    <<~EOS
+      [
+        {
+          "tag_name": "v1.2.3",
+          "name": "v1.2.3",
+          "draft": false,
+          "prerelease": false
+        },
+        {
+          "tag_name": "no-version-tag-also",
+          "name": "1.2.2",
+          "draft": false,
+          "prerelease": false
+        },
+        {
+          "tag_name": "1.2.1",
+          "name": "No version title",
+          "draft": false,
+          "prerelease": false
+        },
+        {
+          "tag_name": "no-version-tag",
+          "name": "No version title",
+          "draft": false,
+          "prerelease": false
+        },
+        {
+          "tag_name": "v1.1.2",
+          "name": "v1.1.2",
+          "draft": false,
+          "prerelease": true
+        },
+        {
+          "tag_name": "v1.1.1",
+          "name": "v1.1.1",
+          "draft": true,
+          "prerelease": false
+        },
+        {
+          "tag_name": "v1.1.0",
+          "name": "v1.1.0",
+          "draft": true,
+          "prerelease": true
+        },
+        {
+          "other": "something-else"
+        }
+      ]
+    EOS
+  end
+  let(:json) { JSON.parse(content) }
+
+  let(:matches) { ["1.2.3", "1.2.2", "1.2.1"] }
+
+  describe "::match?" do
+    it "returns true for a GitHub release artifact URL" do
+      expect(github_releases.match?(github_urls[:release_artifact])).to be true
+    end
+
+    it "returns true for a GitHub tag archive URL" do
+      expect(github_releases.match?(github_urls[:tag_archive])).to be true
+    end
+
+    it "returns true for a GitHub repository upload URL" do
+      expect(github_releases.match?(github_urls[:repository_upload])).to be true
+    end
+
+    it "returns false for a non-GitHub URL" do
+      expect(github_releases.match?(non_github_url)).to be false
+    end
+  end
+
+  describe "::generate_input_values" do
+    it "returns a hash containing a url and regex for a GitHub release artifact URL" do
+      expect(github_releases.generate_input_values(github_urls[:release_artifact])).to eq(generated)
+    end
+
+    it "returns a hash containing a url and regex for a GitHub tag archive URL" do
+      expect(github_releases.generate_input_values(github_urls[:tag_archive])).to eq(generated)
+    end
+
+    it "returns a hash containing a url and regex for a GitHub repository upload URL" do
+      expect(github_releases.generate_input_values(github_urls[:repository_upload])).to eq(generated)
+    end
+
+    it "returns an empty hash for a non-GitHub URL" do
+      expect(github_releases.generate_input_values(non_github_url)).to eq({})
+    end
+  end
+
+  describe "::versions_from_content" do
+    it "returns an empty array if content is blank" do
+      expect(github_releases.versions_from_content({}, regex)).to eq([])
+    end
+
+    it "returns an array of version strings when given content" do
+      expect(github_releases.versions_from_content(json, regex)).to eq(matches)
+    end
+
+    it "returns an array of version strings when given content and a block" do
+      # Returning a string from block
+      expect(github_releases.versions_from_content(json, regex) { "1.2.3" }).to eq(["1.2.3"])
+
+      # Returning an array of strings from block
+      expect(github_releases.versions_from_content(json, regex) do |json, regex|
+        json.map do |release|
+          next if release["draft"] || release["prerelease"]
+
+          match = release["tag_name"]&.match(regex)
+          next if match.blank?
+
+          match[1]
+        end
+      end).to eq(["1.2.3", "1.2.1"])
+    end
+
+    it "allows a nil return from a block" do
+      expect(github_releases.versions_from_content(json, regex) { next }).to eq([])
+    end
+
+    it "errors on an invalid return type from a block" do
+      expect { github_releases.versions_from_content(json, regex) { 123 } }
+        .to raise_error(TypeError, Homebrew::Livecheck::Strategy::INVALID_BLOCK_RETURN_VALUE_MSG)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/livecheck/strategy/gnome_spec.rb b/Library/Homebrew/test/livecheck/strategy/gnome_spec.rb
index 6da013d92d862..d88d11fd240ce 100644
--- a/Library/Homebrew/test/livecheck/strategy/gnome_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/gnome_spec.rb
@@ -1,20 +1,19 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy/gnome"
 
-describe Homebrew::Livecheck::Strategy::Gnome do
+RSpec.describe Homebrew::Livecheck::Strategy::Gnome do
   subject(:gnome) { described_class }
 
   let(:gnome_url) { "https://download.gnome.org/sources/abc/1.2/abc-1.2.3.tar.xz" }
   let(:non_gnome_url) { "https://brew.sh/test" }
 
-  let(:generated) {
+  let(:generated) do
     {
       url:   "https://download.gnome.org/sources/abc/cache.json",
       regex: /abc-(\d+(?:\.\d+)*)\.t/i,
     }
-  }
+  end
 
   describe "::match?" do
     it "returns true for a GNOME URL" do
diff --git a/Library/Homebrew/test/livecheck/strategy/gnu_spec.rb b/Library/Homebrew/test/livecheck/strategy/gnu_spec.rb
index e76a878e4a50a..32c80370419f0 100644
--- a/Library/Homebrew/test/livecheck/strategy/gnu_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/gnu_spec.rb
@@ -1,22 +1,21 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy/gnu"
 
-describe Homebrew::Livecheck::Strategy::Gnu do
+RSpec.describe Homebrew::Livecheck::Strategy::Gnu do
   subject(:gnu) { described_class }
 
-  let(:gnu_urls) {
+  let(:gnu_urls) do
     {
       no_version_dir: "https://ftp.gnu.org/gnu/abc/abc-1.2.3.tar.gz",
       software_page:  "https://www.gnu.org/software/abc/",
       subdomain:      "https://abc.gnu.org",
       savannah:       "https://download.savannah.gnu.org/releases/abc/abc-1.2.3.tar.gz",
     }
-  }
+  end
   let(:non_gnu_url) { "https://brew.sh/test" }
 
-  let(:generated) {
+  let(:generated) do
     {
       no_version_dir: {
         url:   "https://ftp.gnu.org/gnu/abc/",
@@ -32,7 +31,7 @@
       },
       savannah:       {},
     }
-  }
+  end
 
   describe "::match?" do
     it "returns true for a [non-Savannah] GNU URL" do
diff --git a/Library/Homebrew/test/livecheck/strategy/hackage_spec.rb b/Library/Homebrew/test/livecheck/strategy/hackage_spec.rb
index 5252985153db8..df859034bda33 100644
--- a/Library/Homebrew/test/livecheck/strategy/hackage_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/hackage_spec.rb
@@ -1,25 +1,24 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy/hackage"
 
-describe Homebrew::Livecheck::Strategy::Hackage do
+RSpec.describe Homebrew::Livecheck::Strategy::Hackage do
   subject(:hackage) { described_class }
 
-  let(:hackage_urls) {
+  let(:hackage_urls) do
     {
       package:   "https://hackage.haskell.org/package/abc-1.2.3/abc-1.2.3.tar.gz",
       downloads: "https://downloads.haskell.org/~abc/1.2.3/abc-1.2.3-src.tar.xz",
     }
-  }
+  end
   let(:non_hackage_url) { "https://brew.sh/test" }
 
-  let(:generated) {
+  let(:generated) do
     {
       url:   "https://hackage.haskell.org/package/abc/src/",
       regex: %r{<h3>abc-(.*?)/?</h3>}i,
     }
-  }
+  end
 
   describe "::match?" do
     it "returns true for a Hackage URL" do
diff --git a/Library/Homebrew/test/livecheck/strategy/header_match_spec.rb b/Library/Homebrew/test/livecheck/strategy/header_match_spec.rb
index 7ce7ccf37db11..39553a28d0abd 100644
--- a/Library/Homebrew/test/livecheck/strategy/header_match_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/header_match_spec.rb
@@ -1,15 +1,14 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy"
 
-describe Homebrew::Livecheck::Strategy::HeaderMatch do
+RSpec.describe Homebrew::Livecheck::Strategy::HeaderMatch do
   subject(:header_match) { described_class }
 
   let(:http_url) { "https://brew.sh/blog/" }
   let(:non_http_url) { "ftp://brew.sh/" }
 
-  let(:versions) {
+  let(:versions) do
     versions = {
       content_disposition: ["1.2.3"],
       location:            ["1.2.4"],
@@ -17,9 +16,9 @@
     versions[:content_disposition_and_location] = versions[:content_disposition] + versions[:location]
 
     versions
-  }
+  end
 
-  let(:headers) {
+  let(:headers) do
     headers = {
       content_disposition: {
         "date"                => "Fri, 01 Jan 2021 01:23:45 GMT",
@@ -37,15 +36,15 @@
     headers[:content_disposition_and_location] = headers[:content_disposition].merge(headers[:location])
 
     headers
-  }
+  end
 
-  let(:regexes) {
+  let(:regexes) do
     {
       archive: /filename=brew[._-]v?(\d+(?:\.\d+)+)\.t/i,
       latest:  %r{.*?/tag/v?(\d+(?:\.\d+)+)$}i,
       loose:   /v?(\d+(?:\.\d+)+)/i,
     }
-  }
+  end
 
   describe "::match?" do
     it "returns true for an HTTP URL" do
@@ -76,7 +75,7 @@
     end
 
     it "returns an array of version strings when given headers and a block" do
-      # Returning a string from block, no regex
+      # Returning a string from block, no regex.
       expect(
         header_match.versions_from_headers(headers[:location]) do |headers|
           v = Version.parse(headers["location"], detected_from_url: true)
@@ -84,16 +83,17 @@
         end,
       ).to eq(versions[:location])
 
-      # Returning a string from block, explicit regex
+      # Returning a string from block, explicit regex.
       expect(
         header_match.versions_from_headers(headers[:location], regexes[:latest]) do |headers, regex|
           headers["location"] ? headers["location"][regex, 1] : nil
         end,
       ).to eq(versions[:location])
 
-      # Returning an array of strings from block
-      # NOTE: Strategies runs `#compact` on an array from a block, so nil
-      # values are filtered out without needing to use `#compact` in the block.
+      # Returning an array of strings from block.
+      #
+      # NOTE: Strategies runs `#compact` on an array from a block, so nil values
+      #       are filtered out without needing to use `#compact` in the block.
       expect(
         header_match.versions_from_headers(
           headers[:content_disposition_and_location],
diff --git a/Library/Homebrew/test/livecheck/strategy/json_spec.rb b/Library/Homebrew/test/livecheck/strategy/json_spec.rb
new file mode 100644
index 0000000000000..dc18a8f074512
--- /dev/null
+++ b/Library/Homebrew/test/livecheck/strategy/json_spec.rb
@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "livecheck/strategy"
+
+RSpec.describe Homebrew::Livecheck::Strategy::Json do
+  subject(:json) { described_class }
+
+  let(:http_url) { "https://brew.sh/blog/" }
+  let(:non_http_url) { "ftp://brew.sh/" }
+
+  let(:regex) { /^v?(\d+(?:\.\d+)+)$/i }
+
+  let(:content) do
+    <<~EOS
+      {
+        "versions": [
+          { "version": "1.1.2" },
+          { "version": "1.1.2b" },
+          { "version": "1.1.2a" },
+          { "version": "1.1.1" },
+          { "version": "1.1.0" },
+          { "version": "1.1.0-rc3" },
+          { "version": "1.1.0-rc2" },
+          { "version": "1.1.0-rc1" },
+          { "version": "1.0.x-last" },
+          { "version": "1.0.3" },
+          { "version": "1.0.3-rc3" },
+          { "version": "1.0.3-rc2" },
+          { "version": "1.0.3-rc1" },
+          { "version": "1.0.2" },
+          { "version": "1.0.2-rc1" },
+          { "version": "1.0.1" },
+          { "version": "1.0.1-rc1" },
+          { "version": "1.0.0" },
+          { "version": "1.0.0-rc1" },
+          { "other": "version is omitted from this object for testing" }
+        ]
+      }
+    EOS
+  end
+  let(:content_simple) { '{"version":"1.2.3"}' }
+
+  let(:content_matches) { ["1.1.2", "1.1.1", "1.1.0", "1.0.3", "1.0.2", "1.0.1", "1.0.0"] }
+  let(:content_simple_matches) { ["1.2.3"] }
+
+  let(:find_versions_return_hash) do
+    {
+      matches: {
+        "1.1.2" => Version.new("1.1.2"),
+        "1.1.1" => Version.new("1.1.1"),
+        "1.1.0" => Version.new("1.1.0"),
+        "1.0.3" => Version.new("1.0.3"),
+        "1.0.2" => Version.new("1.0.2"),
+        "1.0.1" => Version.new("1.0.1"),
+        "1.0.0" => Version.new("1.0.0"),
+      },
+      regex:,
+      url:     http_url,
+    }
+  end
+
+  let(:find_versions_cached_return_hash) do
+    find_versions_return_hash.merge({ cached: true })
+  end
+
+  describe "::match?" do
+    it "returns true for an HTTP URL" do
+      expect(json.match?(http_url)).to be true
+    end
+
+    it "returns false for a non-HTTP URL" do
+      expect(json.match?(non_http_url)).to be false
+    end
+  end
+
+  describe "::parse_json" do
+    it "returns an object when given valid content" do
+      expect(json.parse_json(content_simple)).to be_an_instance_of(Hash)
+    end
+  end
+
+  describe "::versions_from_content" do
+    it "returns an empty array when given a block but content is blank" do
+      expect(json.versions_from_content("", regex) { "1.2.3" }).to eq([])
+    end
+
+    it "errors if provided content is not valid JSON" do
+      expect { json.versions_from_content("not valid JSON") { [] } }
+        .to raise_error(RuntimeError, "Content could not be parsed as JSON.")
+    end
+
+    it "returns an array of version strings when given content and a block" do
+      # Returning a string from block
+      expect(json.versions_from_content(content_simple) { |json| json["version"] }).to eq(content_simple_matches)
+      expect(json.versions_from_content(content_simple, regex) do |json|
+        json["version"][regex, 1]
+      end).to eq(content_simple_matches)
+
+      # Returning an array of strings from block
+      expect(json.versions_from_content(content, regex) do |json, regex|
+        json["versions"].select { |item| item["version"]&.match?(regex) }
+                        .map { |item| item["version"][regex, 1] }
+      end).to eq(content_matches)
+    end
+
+    it "allows a nil return from a block" do
+      expect(json.versions_from_content(content_simple, regex) { next }).to eq([])
+    end
+
+    it "errors if a block uses two arguments but a regex is not given" do
+      expect { json.versions_from_content(content_simple) { |json, regex| json["version"][regex, 1] } }
+        .to raise_error("Two arguments found in `strategy` block but no regex provided.")
+    end
+
+    it "errors on an invalid return type from a block" do
+      expect { json.versions_from_content(content_simple, regex) { 123 } }
+        .to raise_error(TypeError, Homebrew::Livecheck::Strategy::INVALID_BLOCK_RETURN_VALUE_MSG)
+    end
+  end
+
+  describe "::find_versions?" do
+    it "finds versions in provided_content using a block" do
+      expect(json.find_versions(url: http_url, regex:, provided_content: content) do |json, regex|
+        json["versions"].select { |item| item["version"]&.match?(regex) }
+                        .map { |item| item["version"][regex, 1] }
+      end).to eq(find_versions_cached_return_hash)
+
+      # NOTE: A regex should be provided using the `#regex` method in a
+      #       `livecheck` block but we're using a regex literal in the `strategy`
+      #       block here simply to ensure this method works as expected when a
+      #       regex isn't provided.
+      expect(json.find_versions(url: http_url, provided_content: content) do |json|
+        regex = /^v?(\d+(?:\.\d+)+)$/i
+        json["versions"].select { |item| item["version"]&.match?(regex) }
+                        .map { |item| item["version"][regex, 1] }
+      end).to eq(find_versions_cached_return_hash.merge({ regex: nil }))
+    end
+
+    it "errors if a block is not provided" do
+      expect { json.find_versions(url: http_url, provided_content: content) }
+        .to raise_error(ArgumentError, "Json requires a `strategy` block")
+    end
+
+    it "returns default match_data when url is blank" do
+      expect(json.find_versions(url: "") { "1.2.3" })
+        .to eq({ matches: {}, regex: nil, url: "" })
+    end
+
+    it "returns default match_data when content is blank" do
+      expect(json.find_versions(url: http_url, provided_content: "") { "1.2.3" })
+        .to eq({ matches: {}, regex: nil, url: http_url, cached: true })
+    end
+  end
+end
diff --git a/Library/Homebrew/test/livecheck/strategy/launchpad_spec.rb b/Library/Homebrew/test/livecheck/strategy/launchpad_spec.rb
index 1b006979078d7..f1f6121753519 100644
--- a/Library/Homebrew/test/livecheck/strategy/launchpad_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/launchpad_spec.rb
@@ -1,25 +1,24 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy/launchpad"
 
-describe Homebrew::Livecheck::Strategy::Launchpad do
+RSpec.describe Homebrew::Livecheck::Strategy::Launchpad do
   subject(:launchpad) { described_class }
 
-  let(:launchpad_urls) {
+  let(:launchpad_urls) do
     {
       version_dir:    "https://launchpad.net/abc/1.2/1.2.3/+download/abc-1.2.3.tar.gz",
       trunk:          "https://launchpad.net/abc/trunk/1.2.3/+download/abc-1.2.3.tar.gz",
       code_subdomain: "https://code.launchpad.net/abc/1.2/1.2.3/+download/abc-1.2.3.tar.gz",
     }
-  }
+  end
   let(:non_launchpad_url) { "https://brew.sh/test" }
 
-  let(:generated) {
+  let(:generated) do
     {
       url: "https://launchpad.net/abc/",
     }
-  }
+  end
 
   describe "::match?" do
     it "returns true for a Launchpad URL" do
diff --git a/Library/Homebrew/test/livecheck/strategy/npm_spec.rb b/Library/Homebrew/test/livecheck/strategy/npm_spec.rb
index 24db5e4926f12..2757070629166 100644
--- a/Library/Homebrew/test/livecheck/strategy/npm_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/npm_spec.rb
@@ -1,20 +1,19 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy/npm"
 
-describe Homebrew::Livecheck::Strategy::Npm do
+RSpec.describe Homebrew::Livecheck::Strategy::Npm do
   subject(:npm) { described_class }
 
-  let(:npm_urls) {
+  let(:npm_urls) do
     {
       typical:    "https://registry.npmjs.org/abc/-/def-1.2.3.tgz",
       org_scoped: "https://registry.npmjs.org/@example/abc/-/def-1.2.3.tgz",
     }
-  }
+  end
   let(:non_npm_url) { "https://brew.sh/test" }
 
-  let(:generated) {
+  let(:generated) do
     {
       typical:    {
         url:   "https://www.npmjs.com/package/abc?activeTab=versions",
@@ -25,7 +24,7 @@
         regex: %r{href=.*?/package/@example/abc/v/(\d+(?:\.\d+)+)"}i,
       },
     }
-  }
+  end
 
   describe "::match?" do
     it "returns true for an npm URL" do
diff --git a/Library/Homebrew/test/livecheck/strategy/page_match_spec.rb b/Library/Homebrew/test/livecheck/strategy/page_match_spec.rb
index 5a933de23b76a..6c79eaf6464ac 100644
--- a/Library/Homebrew/test/livecheck/strategy/page_match_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/page_match_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy"
 
-describe Homebrew::Livecheck::Strategy::PageMatch do
+RSpec.describe Homebrew::Livecheck::Strategy::PageMatch do
   subject(:page_match) { described_class }
 
   let(:http_url) { "https://brew.sh/blog/" }
@@ -11,7 +10,7 @@
 
   let(:regex) { %r{href=.*?/homebrew[._-]v?(\d+(?:\.\d+)+)/?["' >]}i }
 
-  let(:content) {
+  let(:content) do
     <<~EOS
       <!DOCTYPE html>
       <html>
@@ -35,11 +34,11 @@
         </body>
       </html>
     EOS
-  }
+  end
 
   let(:content_matches) { ["2.6.0", "2.5.0", "2.4.0", "2.3.0", "2.2.0", "2.1.0", "2.0.0", "1.9.0"] }
 
-  let(:find_versions_return_hash) {
+  let(:find_versions_return_hash) do
     {
       matches: {
         "2.6.0" => Version.new("2.6.0"),
@@ -51,16 +50,16 @@
         "2.0.0" => Version.new("2.0.0"),
         "1.9.0" => Version.new("1.9.0"),
       },
-      regex:   regex,
+      regex:,
       url:     http_url,
     }
-  }
+  end
 
-  let(:find_versions_cached_return_hash) {
+  let(:find_versions_cached_return_hash) do
     return_hash = find_versions_return_hash
     return_hash[:cached] = true
     return_hash
-  }
+  end
 
   describe "::match?" do
     it "returns true for an HTTP URL" do
@@ -106,15 +105,15 @@
 
   describe "::find_versions?" do
     it "finds versions in provided_content" do
-      expect(page_match.find_versions(url: http_url, regex: regex, provided_content: content))
+      expect(page_match.find_versions(url: http_url, regex:, provided_content: content))
         .to eq(find_versions_cached_return_hash)
 
       # NOTE: Ideally, a regex should always be provided to `#find_versions`
-      # for `PageMatch` but there are currently some `livecheck` blocks in
-      # casks where `#regex` isn't used and the regex only exists within a
-      # `strategy` block. This isn't ideal but, for the moment, we allow a
-      # `strategy` block to act as a substitution for a regex and we need to
-      # test this scenario to ensure it works.
+      #       for `PageMatch` but there are currently some `livecheck` blocks in
+      #       casks where `#regex` isn't used and the regex only exists within a
+      #       `strategy` block. This isn't ideal but, for the moment, we allow a
+      #       `strategy` block to act as a substitution for a regex and we need to
+      #       test this scenario to ensure it works.
       #
       # Under normal circumstances, a regex should be established in a
       # `livecheck` block using `#regex` and passed into the `strategy` block
diff --git a/Library/Homebrew/test/livecheck/strategy/pypi_spec.rb b/Library/Homebrew/test/livecheck/strategy/pypi_spec.rb
index 8623f172b91ca..2cdd945c11f9a 100644
--- a/Library/Homebrew/test/livecheck/strategy/pypi_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/pypi_spec.rb
@@ -1,20 +1,19 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy"
 
-describe Homebrew::Livecheck::Strategy::Pypi do
+RSpec.describe Homebrew::Livecheck::Strategy::Pypi do
   subject(:pypi) { described_class }
 
-  let(:pypi_url) { "https://files.pythonhosted.org/packages/ab/cd/efg/example-1.2.3.tar.gz" }
+  let(:pypi_url) { "https://files.pythonhosted.org/packages/ab/cd/efg/example-package-1.2.3.tar.gz" }
   let(:non_pypi_url) { "https://brew.sh/test" }
 
-  let(:generated) {
+  let(:generated) do
     {
-      url:   "https://pypi.org/project/example/#files",
-      regex: %r{href=.*?/packages.*?/example[._-]v?(\d+(?:\.\d+)*(?:[._-]post\d+)?)\.t}i,
+      url:   "https://pypi.org/project/example-package/#files",
+      regex: %r{href=.*?/packages.*?/example[_-]package[._-]v?(\d+(?:\.\d+)*(?:[._-]post\d+)?)\.t}i,
     }
-  }
+  end
 
   describe "::match?" do
     it "returns true for a PyPI URL" do
diff --git a/Library/Homebrew/test/livecheck/strategy/sourceforge_spec.rb b/Library/Homebrew/test/livecheck/strategy/sourceforge_spec.rb
index 15fc25a285b4a..43f51df67ef0e 100644
--- a/Library/Homebrew/test/livecheck/strategy/sourceforge_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/sourceforge_spec.rb
@@ -1,21 +1,20 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy/sourceforge"
 
-describe Homebrew::Livecheck::Strategy::Sourceforge do
+RSpec.describe Homebrew::Livecheck::Strategy::Sourceforge do
   subject(:sourceforge) { described_class }
 
-  let(:sourceforge_urls) {
+  let(:sourceforge_urls) do
     {
       typical:       "https://downloads.sourceforge.net/project/abc/def-1.2.3.tar.gz",
       rss:           "https://sourceforge.net/projects/abc/rss",
       rss_with_path: "https://sourceforge.net/projects/abc/rss?path=/def",
     }
-  }
+  end
   let(:non_sourceforge_url) { "https://brew.sh/test" }
 
-  let(:generated) {
+  let(:generated) do
     {
       typical: {
         url:   "https://sourceforge.net/projects/abc/rss",
@@ -25,7 +24,7 @@
         regex: %r{url=.*?/abc/files/.*?[-_/](\d+(?:[-.]\d+)+)[-_/%.]}i,
       },
     }
-  }
+  end
 
   describe "::match?" do
     it "returns true for a SourceForge URL" do
diff --git a/Library/Homebrew/test/livecheck/strategy/sparkle_spec.rb b/Library/Homebrew/test/livecheck/strategy/sparkle_spec.rb
index 74c533af14e2e..c895fb53a7902 100644
--- a/Library/Homebrew/test/livecheck/strategy/sparkle_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/sparkle_spec.rb
@@ -1,141 +1,299 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy"
 require "bundle_version"
 
-describe Homebrew::Livecheck::Strategy::Sparkle do
+RSpec.describe Homebrew::Livecheck::Strategy::Sparkle do
   subject(:sparkle) { described_class }
 
+  def create_appcast_xml(items_str = "")
+    <<~EOS
+      <?xml version="1.0" encoding="utf-8"?>
+      <rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle">
+        <channel>
+          <title>Example Changelog</title>
+          <link>#{appcast_url}</link>
+          <description>Most recent changes with links to updates.</description>
+          <language>en</language>
+          #{items_str}
+        </channel>
+      </rss>
+    EOS
+  end
+
   let(:appcast_url) { "https://www.example.com/example/appcast.xml" }
   let(:non_http_url) { "ftp://brew.sh/" }
 
-  let(:item_hash) {
-    [
-      {
-        title:         "Version 1.2.3",
-        pub_date:      "Fri, 01 Jan 2021 01:23:45 +0000",
-        url:           "https://www.example.com/example/example-1.2.3.tar.gz",
-        short_version: "1.2.3",
-        version:       "123",
+  # The `item_hashes` data is used to create test appcast XML and expected
+  # `Sparkle::Item` objects.
+  let(:item_hashes) do
+    {
+      # The 1.2.4 version is only used in tests as the basis for an item that
+      # should be excluded (after modifications).
+      v124: {
+        title:                  "Version 1.2.4",
+        release_notes_link:     "https://www.example.com/example/1.2.4.html",
+        pub_date:               "Fri, 02 Jan 2021 01:23:45 +0000",
+        url:                    "https://www.example.com/example/example-1.2.4.tar.gz",
+        short_version:          "1.2.4",
+        version:                "124",
+        minimum_system_version: "10.10",
       },
-      {
-        title:         "Version 1.2.2",
-        pub_date:      "Not a parseable date string",
-        url:           "https://www.example.com/example/example-1.2.2.tar.gz",
-        short_version: "1.2.2",
-        version:       "122",
+      v123: {
+        title:                  "Version 1.2.3",
+        release_notes_link:     "https://www.example.com/example/1.2.3.html",
+        pub_date:               "Fri, 01 Jan 2021 01:23:45 +0000",
+        url:                    "https://www.example.com/example/example-1.2.3.tar.gz",
+        short_version:          "1.2.3",
+        version:                "123",
+        minimum_system_version: "10.10",
       },
-    ]
-  }
+      v122: {
+        title:                  "Version 1.2.2",
+        release_notes_link:     "https://www.example.com/example/1.2.2.html",
+        pub_date:               "Not a parseable date string",
+        link:                   "https://www.example.com/example/example-1.2.2.tar.gz",
+        short_version:          "1.2.2",
+        version:                "122",
+        minimum_system_version: "10.10",
+      },
+      v121: {
+        title:                  "Version 1.2.1",
+        release_notes_link:     "https://www.example.com/example/1.2.1.html",
+        pub_date:               "Thu, 31 Dec 2020 01:23:45 +0000",
+        os:                     "osx",
+        url:                    "https://www.example.com/example/example-1.2.1.tar.gz",
+        short_version:          "1.2.1",
+        version:                "121",
+        minimum_system_version: "10.10",
+      },
+      v120: {
+        title:                  "Version 1.2.0",
+        release_notes_link:     "https://www.example.com/example/1.2.0.html",
+        pub_date:               "Wed, 30 Dec 2020 01:23:45 +0000",
+        os:                     "macos",
+        url:                    "https://www.example.com/example/example-1.2.0.tar.gz",
+        short_version:          "1.2.0",
+        version:                "120",
+        minimum_system_version: "10.10",
+      },
+    }
+  end
 
-  let(:xml) {
-    first_item = <<~EOS
+  let(:xml) do
+    v123_item = <<~EOS
       <item>
-        <title>#{item_hash[0][:title]}</title>
-        <sparkle:minimumSystemVersion>10.10</sparkle:minimumSystemVersion>
-        <sparkle:releaseNotesLink>https://www.example.com/example/#{item_hash[0][:short_version]}.html</sparkle:releaseNotesLink>
-        <pubDate>#{item_hash[0][:pub_date]}</pubDate>
-        <enclosure url="#{item_hash[0][:url]}" sparkle:shortVersionString="#{item_hash[0][:short_version]}" sparkle:version="#{item_hash[0][:version]}" length="12345678" type="application/octet-stream" sparkle:dsaSignature="ABCDEF+GHIJKLMNOPQRSTUVWXYZab/cdefghijklmnopqrst/uvwxyz1234567==" />
+        <title>#{item_hashes[:v123][:title]}</title>
+        <sparkle:minimumSystemVersion>#{item_hashes[:v123][:minimum_system_version]}</sparkle:minimumSystemVersion>
+        <sparkle:releaseNotesLink>#{item_hashes[:v123][:release_notes_link]}</sparkle:releaseNotesLink>
+        <pubDate>#{item_hashes[:v123][:pub_date]}</pubDate>
+        <enclosure url="#{item_hashes[:v123][:url]}" sparkle:shortVersionString="#{item_hashes[:v123][:short_version]}" sparkle:version="#{item_hashes[:v123][:version]}" length="12345678" type="application/octet-stream" sparkle:dsaSignature="ABCDEF+GHIJKLMNOPQRSTUVWXYZab/cdefghijklmnopqrst/uvwxyz1234567==" />
       </item>
     EOS
 
-    second_item = <<~EOS
+    v122_item = <<~EOS
       <item>
-        <title>#{item_hash[1][:title]}</title>
-        <sparkle:minimumSystemVersion>10.10</sparkle:minimumSystemVersion>
-        <sparkle:releaseNotesLink>https://www.example.com/example/#{item_hash[1][:short_version]}.html</sparkle:releaseNotesLink>
-        <pubDate>#{item_hash[1][:pub_date]}</pubDate>
-        <sparkle:version>#{item_hash[1][:version]}</sparkle:version>
-        <sparkle:shortVersionString>#{item_hash[1][:short_version]}</sparkle:shortVersionString>
-        <link>#{item_hash[1][:url]}</link>
+        <title>#{item_hashes[:v122][:title]}</title>
+        <link>#{item_hashes[:v122][:link]}</link>
+        <sparkle:minimumSystemVersion>#{item_hashes[:v122][:minimum_system_version]}</sparkle:minimumSystemVersion>
+        <sparkle:releaseNotesLink>#{item_hashes[:v122][:release_notes_link]}</sparkle:releaseNotesLink>
+        <pubDate>#{item_hashes[:v122][:pub_date]}</pubDate>
+        <sparkle:version>#{item_hashes[:v122][:version]}</sparkle:version>
+        <sparkle:shortVersionString>#{item_hashes[:v122][:short_version]}</sparkle:shortVersionString>
       </item>
     EOS
 
-    items_to_omit = <<~EOS
-      #{first_item.sub(%r{<(enclosure[^>]+?)\s*?/>}, '<\1 os="not-osx" />')}
-      #{first_item.sub(/(<sparkle:minimumSystemVersion>)[^<]+?</m, '\1100<')}
-      #{first_item.sub(/(<sparkle:minimumSystemVersion>)[^<]+?</m, '\19000<')}
+    v121_item_with_osx_os = <<~EOS
       <item>
+        <title>#{item_hashes[:v121][:title]}</title>
+        <sparkle:minimumSystemVersion>#{item_hashes[:v121][:minimum_system_version]}</sparkle:minimumSystemVersion>
+        <sparkle:releaseNotesLink>#{item_hashes[:v121][:release_notes_link]}</sparkle:releaseNotesLink>
+        <pubDate>#{item_hashes[:v121][:pub_date]}</pubDate>
+        <enclosure os="#{item_hashes[:v121][:os]}" url="#{item_hashes[:v121][:url]}" sparkle:shortVersionString="#{item_hashes[:v121][:short_version]}" sparkle:version="#{item_hashes[:v121][:version]}" length="12345678" type="application/octet-stream" sparkle:dsaSignature="ABCDEF+GHIJKLMNOPQRSTUVWXYZab/cdefghijklmnopqrst/uvwxyz1234567==" />
       </item>
     EOS
 
-    appcast = <<~EOS
-      <?xml version="1.0" encoding="utf-8"?>
-      <rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle">
-        <channel>
-          <title>Example Changelog</title>
-          <link>#{appcast_url}</link>
-          <description>Most recent changes with links to updates.</description>
-          <language>en</language>
-          #{first_item}
-          #{second_item}
-        </channel>
-      </rss>
+    v120_item_with_macos_os = <<~EOS
+      <item>
+        <title>#{item_hashes[:v120][:title]}</title>
+        <sparkle:minimumSystemVersion>#{item_hashes[:v120][:minimum_system_version]}</sparkle:minimumSystemVersion>
+        <sparkle:releaseNotesLink>#{item_hashes[:v120][:release_notes_link]}</sparkle:releaseNotesLink>
+        <pubDate>#{item_hashes[:v120][:pub_date]}</pubDate>
+        <enclosure os="#{item_hashes[:v120][:os]}" url="#{item_hashes[:v120][:url]}" sparkle:shortVersionString="#{item_hashes[:v120][:short_version]}" sparkle:version="#{item_hashes[:v120][:version]}" length="12345678" type="application/octet-stream" sparkle:dsaSignature="ABCDEF+GHIJKLMNOPQRSTUVWXYZab/cdefghijklmnopqrst/uvwxyz1234567==" />
+      </item>
+    EOS
+
+    # This main `appcast` data is intended as a relatively normal example.
+    # As such, it also serves as a base for some other test data.
+    appcast = create_appcast_xml <<~EOS
+      #{v123_item}
+      #{v122_item}
+      #{v121_item_with_osx_os}
+      #{v120_item_with_macos_os}
     EOS
 
-    omitted_items = appcast.sub("</item>", "</item>\n#{items_to_omit}")
+    omitted_items = create_appcast_xml <<~EOS
+      #{v123_item.sub(%r{<(enclosure[^>]+?)\s*?/>}, '<\1 os="not-osx-or-macos" />')}
+      #{v123_item.sub(/(<sparkle:minimumSystemVersion>)[^<]+?</m, '\1100<')}
+      <item>
+      </item>
+    EOS
+
+    # Set the first item in a copy of `appcast` to a bad `minimumSystemVersion`
+    # value, to test `MacOSVersion::Error` handling.
+    bad_macos_version = appcast.sub(
+      v123_item,
+      v123_item.sub(
+        /(<sparkle:minimumSystemVersion>)[^<]+?</m,
+        '\1Not a macOS version<',
+      ),
+    )
+
+    # Set the first item in a copy of `appcast` to the "beta" channel, to test
+    # filtering items by channel using a `strategy` block.
     beta_channel_item = appcast.sub(
-      first_item,
-      first_item.sub(
-        "</title",
+      v123_item,
+      v123_item.sub(
+        "</title>",
         "</title>\n<sparkle:channel>beta</sparkle:channel>",
       ),
     )
-    no_versions_item =
-      appcast
-        .sub(second_item, "")
-        .gsub(/sparkle:(shortVersionString|version)="[^"]+?"\s*/, "")
-        .sub(
-          "<title>#{item_hash[0][:title]}</title>",
-          "<title>Version</title>",
-        )
-    no_items = appcast.sub(%r{<item>.+</item>}m, "")
-    undefined_namespace = appcast.sub(/\s*xmlns:sparkle="[^"]+?"/, "")
+
+    no_versions_item = create_appcast_xml <<~EOS
+      <item>
+        <title>Version</title>
+        <sparkle:minimumSystemVersion>#{item_hashes[:v123][:minimum_system_version]}</sparkle:minimumSystemVersion>
+        <sparkle:releaseNotesLink>#{item_hashes[:v123][:release_notes_link]}</sparkle:releaseNotesLink>
+        <pubDate>#{item_hashes[:v123][:pub_date]}</pubDate>
+        <enclosure url="#{item_hashes[:v123][:url]}" length="12345678" type="application/octet-stream" sparkle:dsaSignature="ABCDEF+GHIJKLMNOPQRSTUVWXYZab/cdefghijklmnopqrst/uvwxyz1234567==" />
+      </item>
+    EOS
+
+    no_items = create_appcast_xml
+
+    undefined_namespace = appcast.sub(/\s*xmlns:sparkle="[^"]+"/, "")
 
     {
-      appcast:             appcast,
-      omitted_items:       omitted_items,
-      beta_channel_item:   beta_channel_item,
-      no_versions_item:    no_versions_item,
-      no_items:            no_items,
-      undefined_namespace: undefined_namespace,
+      appcast:,
+      omitted_items:,
+      bad_macos_version:,
+      beta_channel_item:,
+      no_versions_item:,
+      no_items:,
+      undefined_namespace:,
     }
-  }
+  end
 
   let(:title_regex) { /Version\s+v?(\d+(?:\.\d+)+)\s*$/i }
 
-  let(:items) {
-    items = {
-      appcast: [
-        Homebrew::Livecheck::Strategy::Sparkle::Item.new(
-          title:          item_hash[0][:title],
-          pub_date:       Time.parse(item_hash[0][:pub_date]),
-          url:            item_hash[0][:url],
-          bundle_version: Homebrew::BundleVersion.new(item_hash[0][:short_version], item_hash[0][:version]),
+  let(:items) do
+    {
+      v124: Homebrew::Livecheck::Strategy::Sparkle::Item.new(
+        title:                  item_hashes[:v124][:title],
+        release_notes_link:     item_hashes[:v124][:release_notes_link],
+        pub_date:               Time.parse(item_hashes[:v124][:pub_date]),
+        url:                    item_hashes[:v124][:url],
+        bundle_version:         Homebrew::BundleVersion.new(
+          item_hashes[:v124][:short_version],
+          item_hashes[:v124][:version],
         ),
-        Homebrew::Livecheck::Strategy::Sparkle::Item.new(
-          title:          item_hash[1][:title],
-          pub_date:       Time.new(0),
-          url:            item_hash[1][:url],
-          bundle_version: Homebrew::BundleVersion.new(item_hash[1][:short_version], item_hash[1][:version]),
+        minimum_system_version: MacOSVersion.new(item_hashes[:v124][:minimum_system_version]),
+      ),
+      v123: Homebrew::Livecheck::Strategy::Sparkle::Item.new(
+        title:                  item_hashes[:v123][:title],
+        release_notes_link:     item_hashes[:v123][:release_notes_link],
+        pub_date:               Time.parse(item_hashes[:v123][:pub_date]),
+        url:                    item_hashes[:v123][:url],
+        bundle_version:         Homebrew::BundleVersion.new(
+          item_hashes[:v123][:short_version],
+          item_hashes[:v123][:version],
         ),
+        minimum_system_version: MacOSVersion.new(item_hashes[:v123][:minimum_system_version]),
+      ),
+      v122: Homebrew::Livecheck::Strategy::Sparkle::Item.new(
+        title:                  item_hashes[:v122][:title],
+        link:                   item_hashes[:v122][:link],
+        release_notes_link:     item_hashes[:v122][:release_notes_link],
+        # `#items_from_content` falls back to a default `pub_date` when
+        # one isn't provided or can't be successfully parsed.
+        pub_date:               Time.new(0),
+        url:                    item_hashes[:v122][:link],
+        bundle_version:         Homebrew::BundleVersion.new(
+          item_hashes[:v122][:short_version],
+          item_hashes[:v122][:version],
+        ),
+        minimum_system_version: MacOSVersion.new(item_hashes[:v122][:minimum_system_version]),
+      ),
+      v121: Homebrew::Livecheck::Strategy::Sparkle::Item.new(
+        title:                  item_hashes[:v121][:title],
+        release_notes_link:     item_hashes[:v121][:release_notes_link],
+        pub_date:               Time.parse(item_hashes[:v121][:pub_date]),
+        os:                     item_hashes[:v121][:os],
+        url:                    item_hashes[:v121][:url],
+        bundle_version:         Homebrew::BundleVersion.new(
+          item_hashes[:v121][:short_version],
+          item_hashes[:v121][:version],
+        ),
+        minimum_system_version: MacOSVersion.new(item_hashes[:v121][:minimum_system_version]),
+      ),
+      v120: Homebrew::Livecheck::Strategy::Sparkle::Item.new(
+        title:                  item_hashes[:v120][:title],
+        release_notes_link:     item_hashes[:v120][:release_notes_link],
+        pub_date:               Time.parse(item_hashes[:v120][:pub_date]),
+        os:                     item_hashes[:v120][:os],
+        url:                    item_hashes[:v120][:url],
+        bundle_version:         Homebrew::BundleVersion.new(
+          item_hashes[:v120][:short_version],
+          item_hashes[:v120][:version],
+        ),
+        minimum_system_version: MacOSVersion.new(item_hashes[:v120][:minimum_system_version]),
+      ),
+    }
+  end
+
+  let(:item_arrays) do
+    item_arrays = {
+      appcast:        [
+        items[:v123],
+        items[:v122],
+        items[:v121],
+        items[:v120],
+      ],
+      appcast_sorted: [
+        items[:v123],
+        items[:v121],
+        items[:v120],
+        items[:v122],
       ],
     }
 
-    beta_channel_item = items[:appcast][0].clone
+    bad_macos_version_item = items[:v123].clone
+    bad_macos_version_item.minimum_system_version = nil
+    item_arrays[:bad_macos_version] = [
+      bad_macos_version_item,
+      items[:v122],
+      items[:v121],
+      items[:v120],
+    ]
+
+    beta_channel_item = items[:v123].clone
     beta_channel_item.channel = "beta"
-    items[:beta_channel_item] = [beta_channel_item, items[:appcast][1].clone]
+    item_arrays[:beta_channel_item] = [
+      beta_channel_item,
+      items[:v122],
+      items[:v121],
+      items[:v120],
+    ]
 
-    no_versions_item = items[:appcast][0].clone
+    no_versions_item = items[:v123].clone
     no_versions_item.title = "Version"
     no_versions_item.bundle_version = nil
-    items[:no_versions_item] = [no_versions_item]
+    item_arrays[:no_versions_item] = [no_versions_item]
 
-    items
-  }
+    item_arrays
+  end
 
-  let(:versions) { [items[:appcast][0].nice_version] }
+  let(:versions) { [items[:v123].nice_version] }
 
   describe "::match?" do
     it "returns true for an HTTP URL" do
@@ -149,31 +307,63 @@
 
   describe "::items_from_content" do
     let(:items_from_appcast) { sparkle.items_from_content(xml[:appcast]) }
-    let(:first_item) { items_from_appcast[0] }
 
     it "returns nil if content is blank" do
       expect(sparkle.items_from_content("")).to eq([])
     end
 
     it "returns an array of Items when given XML data" do
-      expect(items_from_appcast).to eq(items[:appcast])
-      expect(first_item.title).to eq(item_hash[0][:title])
-      expect(first_item.pub_date).to eq(Time.parse(item_hash[0][:pub_date]))
-      expect(first_item.url).to eq(item_hash[0][:url])
-      expect(first_item.short_version).to eq(item_hash[0][:short_version])
-      expect(first_item.version).to eq(item_hash[0][:version])
-
-      expect(sparkle.items_from_content(xml[:beta_channel_item])).to eq(items[:beta_channel_item])
-      expect(sparkle.items_from_content(xml[:no_versions_item])).to eq(items[:no_versions_item])
+      expect(items_from_appcast).to eq(item_arrays[:appcast])
+      expect(items_from_appcast[0].title).to eq(item_hashes[:v123][:title])
+      expect(items_from_appcast[0].pub_date).to eq(Time.parse(item_hashes[:v123][:pub_date]))
+      expect(items_from_appcast[0].url).to eq(item_hashes[:v123][:url])
+      expect(items_from_appcast[0].short_version).to eq(item_hashes[:v123][:short_version])
+      expect(items_from_appcast[0].version).to eq(item_hashes[:v123][:version])
+
+      expect(sparkle.items_from_content(xml[:bad_macos_version])).to eq(item_arrays[:bad_macos_version])
+      expect(sparkle.items_from_content(xml[:beta_channel_item])).to eq(item_arrays[:beta_channel_item])
+      expect(sparkle.items_from_content(xml[:no_versions_item])).to eq(item_arrays[:no_versions_item])
+    end
+  end
+
+  describe "::filter_items" do
+    let(:items_non_mac_os) do
+      item = items[:v124].clone
+      item.os = "not-osx-or-macos"
+      item_arrays[:appcast] + [item]
+    end
+
+    let(:items_prerelease_minimum_system_version) do
+      item = items[:v124].clone
+      item.minimum_system_version = MacOSVersion.new("100")
+      item_arrays[:appcast] + [item]
+    end
+
+    it "removes items with a non-mac OS" do
+      expect(sparkle.filter_items(items_non_mac_os)).to eq(item_arrays[:appcast])
+    end
+
+    it "removes items with a prerelease minimumSystemVersion" do
+      expect(sparkle.filter_items(items_prerelease_minimum_system_version)).to eq(item_arrays[:appcast])
+    end
+  end
+
+  describe "::sort_items" do
+    it "returns a sorted array of items" do
+      expect(sparkle.sort_items(item_arrays[:appcast])).to eq(item_arrays[:appcast_sorted])
     end
   end
 
+  # `#versions_from_content` sorts items by `pub_date` and `bundle_version`, so
+  # these tests have to account for this behavior in the expected output.
+  # For example, the version 122 item doesn't have a parseable `pub_date` and
+  # the substituted default will cause it to be sorted last.
   describe "::versions_from_content" do
-    let(:subbed_items) { items[:appcast].map { |item| item.nice_version.sub("1", "0") } }
+    let(:subbed_items) { item_arrays[:appcast_sorted].map { |item| item.nice_version.sub("1", "0") } }
 
     it "returns an array of version strings when given content" do
       expect(sparkle.versions_from_content(xml[:appcast])).to eq(versions)
-      expect(sparkle.versions_from_content(xml[:omitted_items])).to eq(versions)
+      expect(sparkle.versions_from_content(xml[:omitted_items])).to eq([])
       expect(sparkle.versions_from_content(xml[:beta_channel_item])).to eq(versions)
       expect(sparkle.versions_from_content(xml[:no_versions_item])).to eq([])
       expect(sparkle.versions_from_content(xml[:undefined_namespace])).to eq(versions)
@@ -202,16 +392,16 @@
         sparkle.versions_from_content(xml[:beta_channel_item]) do |items|
           items.find { |item| item.channel.nil? }&.nice_version
         end,
-      ).to eq([items[:appcast][1].nice_version])
+      ).to eq([items[:v121].nice_version])
     end
 
-    it "returns an array of version strings when given content, a regex, and a block" do
+    it "returns an array of version strings when given content, a regex and a block" do
       # Returning a string from the block
       expect(
         sparkle.versions_from_content(xml[:appcast], title_regex) do |item, regex|
           item.title[regex, 1]
         end,
-      ).to eq([item_hash[0][:short_version]])
+      ).to eq([item_hashes[:v123][:short_version]])
 
       expect(
         sparkle.versions_from_content(xml[:appcast], title_regex) do |items, regex|
@@ -222,24 +412,24 @@
 
           "#{match[1]},#{item.version}"
         end,
-      ).to eq(["#{item_hash[0][:short_version]},#{item_hash[0][:version]}"])
+      ).to eq(["#{item_hashes[:v123][:short_version]},#{item_hashes[:v123][:version]}"])
 
       # Returning an array of strings from the block
       expect(
         sparkle.versions_from_content(xml[:appcast], title_regex) do |item, regex|
           [item.title[regex, 1]]
         end,
-      ).to eq([item_hash[0][:short_version]])
+      ).to eq([item_hashes[:v123][:short_version]])
 
       expect(
         sparkle.versions_from_content(xml[:appcast], &:short_version),
-      ).to eq([item_hash[0][:short_version]])
+      ).to eq([item_hashes[:v123][:short_version]])
 
       expect(
         sparkle.versions_from_content(xml[:appcast], title_regex) do |items, regex|
           items.map { |item| item.title[regex, 1] }
         end,
-      ).to eq(items[:appcast].map(&:short_version))
+      ).to eq(item_arrays[:appcast_sorted].map(&:short_version))
     end
 
     it "allows a nil return from a block" do
@@ -252,12 +442,12 @@
     end
 
     it "errors on an invalid return type from a block" do
-      expect {
+      expect do
         sparkle.versions_from_content(xml[:appcast]) do |item|
           _ = item # To appease `brew style` without modifying arg name
           123
         end
-      }.to raise_error(TypeError, Homebrew::Livecheck::Strategy::INVALID_BLOCK_RETURN_VALUE_MSG)
+      end.to raise_error(TypeError, Homebrew::Livecheck::Strategy::INVALID_BLOCK_RETURN_VALUE_MSG)
     end
 
     it "errors if the first block argument uses an unhandled name" do
diff --git a/Library/Homebrew/test/livecheck/strategy/xml_spec.rb b/Library/Homebrew/test/livecheck/strategy/xml_spec.rb
new file mode 100644
index 0000000000000..39c93075cdb86
--- /dev/null
+++ b/Library/Homebrew/test/livecheck/strategy/xml_spec.rb
@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require "livecheck/strategy"
+require "rexml/document"
+
+RSpec.describe Homebrew::Livecheck::Strategy::Xml do
+  subject(:xml) { described_class }
+
+  let(:http_url) { "https://brew.sh/blog/" }
+  let(:non_http_url) { "ftp://brew.sh/" }
+
+  let(:regex) { /^v?(\d+(?:\.\d+)+)$/i }
+
+  let(:content_version_text) do
+    <<~EOS
+      <?xml version="1.0" encoding="utf-8"?>
+      <versions>
+        <version>1.1.2</version>
+        <version>1.1.2b</version>
+        <version>1.1.2a</version>
+        <version>1.1.1</version>
+        <version>1.1.0</version>
+        <version>1.1.0-rc3</version>
+        <version>1.1.0-rc2</version>
+        <version>1.1.0-rc1</version>
+        <version>1.0.x-last</version>
+        <version>1.0.3</version>
+        <version>1.0.3-rc3</version>
+        <version>1.0.3-rc2</version>
+        <version>1.0.3-rc1</version>
+        <version>1.0.2</version>
+        <version>1.0.2-rc1</version>
+        <version>1.0.1</version>
+        <version>1.0.1-rc1</version>
+        <version>1.0.0</version>
+        <version>1.0.0-rc1</version>
+      </versions>
+    EOS
+  end
+
+  let(:content_version_attr) do
+    <<~EOS
+      <?xml version="1.0" encoding="utf-8"?>
+      <items>
+        <item version="1.1.2" />
+        <item version="1.1.2b" />
+        <item version="1.1.2a" />
+        <item version="1.1.1" />
+        <item version="1.1.0" />
+        <item version="1.1.0-rc3" />
+        <item version="1.1.0-rc2" />
+        <item version="1.1.0-rc1" />
+        <item version="1.0.x-last" />
+        <item version="1.0.3" />
+        <item version="1.0.3-rc3" />
+        <item version="1.0.3-rc2" />
+        <item version="1.0.3-rc1" />
+        <item version="1.0.2" />
+        <item version="1.0.2-rc1" />
+        <item version="1.0.1" />
+        <item version="1.0.1-rc1" />
+        <item version="1.0.0" />
+        <item version="1.0.0-rc1" />
+      </items>
+    EOS
+  end
+
+  let(:content_simple) do
+    <<~EOS
+      <?xml version="1.0" encoding="utf-8"?>
+      <version>1.2.3</version>
+    EOS
+  end
+
+  let(:content_undefined_namespace) do
+    <<~EOS
+      <?xml version="1.0" encoding="utf-8"?>
+      <something:version>1.2.3</something:version>
+    EOS
+  end
+
+  let(:parent_child_text) { { parent: "1.2.3", child: "4.5.6" } }
+  let(:content_parent_child) do
+    # This XML deliberately includes unnecessary whitespace, to ensure that
+    # Xml#element_text properly strips the retrieved text.
+    <<~EOS
+      <?xml version="1.0" encoding="utf-8"?>
+      <elements>
+        <parent>
+          #{parent_child_text[:parent]}
+          <child> #{parent_child_text[:child]} </child>
+        </parent>
+        <blank-parent>
+          <blank-child></blank-child>
+        </blank-parent>
+      </elements>
+    EOS
+  end
+
+  let(:content_matches) { ["1.1.2", "1.1.1", "1.1.0", "1.0.3", "1.0.2", "1.0.1", "1.0.0"] }
+  let(:content_simple_matches) { ["1.2.3"] }
+
+  let(:find_versions_return_hash) do
+    {
+      matches: {
+        "1.1.2" => Version.new("1.1.2"),
+        "1.1.1" => Version.new("1.1.1"),
+        "1.1.0" => Version.new("1.1.0"),
+        "1.0.3" => Version.new("1.0.3"),
+        "1.0.2" => Version.new("1.0.2"),
+        "1.0.1" => Version.new("1.0.1"),
+        "1.0.0" => Version.new("1.0.0"),
+      },
+      regex:,
+      url:     http_url,
+    }
+  end
+
+  let(:find_versions_cached_return_hash) do
+    find_versions_return_hash.merge({ cached: true })
+  end
+
+  describe "::match?" do
+    it "returns true for an HTTP URL" do
+      expect(xml.match?(http_url)).to be true
+    end
+
+    it "returns false for a non-HTTP URL" do
+      expect(xml.match?(non_http_url)).to be false
+    end
+  end
+
+  describe "::parse_xml" do
+    # TODO: Should we be comparing against an actual REXML::Document object?
+    it "returns an REXML::Document when given XML content" do
+      expect(xml.parse_xml(content_version_text)).to be_an_instance_of(REXML::Document)
+    end
+
+    it "returns an REXML::Document when given XML content with an undefined namespace" do
+      expect(xml.parse_xml(content_undefined_namespace)).to be_an_instance_of(REXML::Document)
+    end
+  end
+
+  describe "::element_text" do
+    let(:parent_child_doc) { xml.parse_xml(content_parent_child) }
+    let(:parent) { parent_child_doc.get_elements("/elements/parent").first }
+    let(:blank_parent) { parent_child_doc.get_elements("/elements/blank-parent").first }
+
+    it "returns the element text if child_name is not provided" do
+      expect(xml.element_text(parent)).to eq(parent_child_text[:parent])
+    end
+
+    it "returns the child element text if child_name is provided" do
+      expect(xml.element_text(parent, "child")).to eq(parent_child_text[:child])
+    end
+
+    it "returns `nil` if the provided child element does not exist" do
+      expect(xml.element_text(parent, "nonexistent")).to be_nil
+    end
+
+    it "returns `nil` if the retrieved text is blank" do
+      expect(xml.element_text(blank_parent)).to be_nil
+      expect(xml.element_text(blank_parent, "blank-child")).to be_nil
+    end
+  end
+
+  describe "::versions_from_content" do
+    it "returns an empty array when given a block but content is blank" do
+      expect(xml.versions_from_content("", regex) { "1.2.3" }).to eq([])
+    end
+
+    it "returns an array of version strings when given content and a block" do
+      # Returning a string from block
+      expect(xml.versions_from_content(content_simple) do |xml|
+        xml.elements["version"]&.text
+      end).to eq(content_simple_matches)
+      expect(xml.versions_from_content(content_simple, regex) do |xml|
+        version = xml.elements["version"]&.text
+        next if version.blank?
+
+        version[regex, 1]
+      end).to eq(content_simple_matches)
+
+      # Returning an array of strings from block
+      expect(xml.versions_from_content(content_version_text, regex) do |xml, regex|
+        xml.get_elements("/versions/version").map { |item| item.text[regex, 1] }
+      end).to eq(content_matches)
+
+      expect(xml.versions_from_content(content_version_attr, regex) do |xml, regex|
+        xml.get_elements("/items/item").map do |item|
+          version = item["version"]
+          next if version.blank?
+
+          version[regex, 1]
+        end
+      end).to eq(content_matches)
+    end
+
+    it "allows a nil return from a block" do
+      expect(xml.versions_from_content(content_simple, regex) { next }).to eq([])
+    end
+
+    it "errors if a block uses two arguments but a regex is not given" do
+      expect { xml.versions_from_content(content_simple) { |xml, regex| xml["version"][regex, 1] } }
+        .to raise_error("Two arguments found in `strategy` block but no regex provided.")
+    end
+
+    it "errors on an invalid return type from a block" do
+      expect { xml.versions_from_content(content_simple, regex) { 123 } }
+        .to raise_error(TypeError, Homebrew::Livecheck::Strategy::INVALID_BLOCK_RETURN_VALUE_MSG)
+    end
+  end
+
+  describe "::find_versions?" do
+    it "finds versions in provided_content using a block" do
+      expect(xml.find_versions(url: http_url, regex:, provided_content: content_version_text) do |xml, regex|
+        xml.get_elements("/versions/version").map { |item| item.text[regex, 1] }
+      end).to eq(find_versions_cached_return_hash)
+
+      # NOTE: A regex should be provided using the `#regex` method in a
+      #       `livecheck` block but we're using a regex literal in the `strategy`
+      #       block here simply to ensure this method works as expected when a
+      #       regex isn't provided.
+      expect(xml.find_versions(url: http_url, provided_content: content_version_text) do |xml|
+        regex = /^v?(\d+(?:\.\d+)+)$/i
+        xml.get_elements("/versions/version").map { |item| item.text[regex, 1] }
+      end).to eq(find_versions_cached_return_hash.merge({ regex: nil }))
+    end
+
+    it "errors if a block is not provided" do
+      expect { xml.find_versions(url: http_url, provided_content: content_simple) }
+        .to raise_error(ArgumentError, "Xml requires a `strategy` block")
+    end
+
+    it "returns default match_data when url is blank" do
+      expect(xml.find_versions(url: "") { "1.2.3" })
+        .to eq({ matches: {}, regex: nil, url: "" })
+    end
+
+    it "returns default match_data when content is blank" do
+      expect(xml.find_versions(url: http_url, provided_content: "") { "1.2.3" })
+        .to eq({ matches: {}, regex: nil, url: http_url, cached: true })
+    end
+  end
+end
diff --git a/Library/Homebrew/test/livecheck/strategy/xorg_spec.rb b/Library/Homebrew/test/livecheck/strategy/xorg_spec.rb
index a62e6b3f0b16d..230f632938b00 100644
--- a/Library/Homebrew/test/livecheck/strategy/xorg_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy/xorg_spec.rb
@@ -1,12 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy/xorg"
 
-describe Homebrew::Livecheck::Strategy::Xorg do
+RSpec.describe Homebrew::Livecheck::Strategy::Xorg do
   subject(:xorg) { described_class }
 
-  let(:xorg_urls) {
+  let(:xorg_urls) do
     {
       app:     "https://www.x.org/archive/individual/app/abc-1.2.3.tar.bz2",
       font:    "https://www.x.org/archive/individual/font/abc-1.2.3.tar.bz2",
@@ -14,10 +13,10 @@
       ftp_lib: "https://ftp.x.org/archive/individual/lib/libabc-1.2.3.tar.bz2",
       pub_doc: "https://www.x.org/pub/individual/doc/abc-1.2.3.tar.bz2",
     }
-  }
+  end
   let(:non_xorg_url) { "https://brew.sh/test" }
 
-  let(:generated) {
+  let(:generated) do
     {
       app:     {
         url:   "https://www.x.org/archive/individual/app/",
@@ -40,7 +39,7 @@
         regex: /href=.*?abc[._-]v?(\d+(?:\.\d+)+)\.t/i,
       },
     }
-  }
+  end
 
   describe "::match?" do
     it "returns true for an X.Org URL" do
diff --git a/Library/Homebrew/test/livecheck/strategy/yaml_spec.rb b/Library/Homebrew/test/livecheck/strategy/yaml_spec.rb
new file mode 100644
index 0000000000000..8d2f3827f92c9
--- /dev/null
+++ b/Library/Homebrew/test/livecheck/strategy/yaml_spec.rb
@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "livecheck/strategy"
+
+RSpec.describe Homebrew::Livecheck::Strategy::Yaml do
+  subject(:yaml) { described_class }
+
+  let(:http_url) { "https://brew.sh/blog/" }
+  let(:non_http_url) { "ftp://brew.sh/" }
+
+  let(:regex) { /^v?(\d+(?:\.\d+)+)$/i }
+
+  let(:content) do
+    <<~EOS
+      versions:
+        - version: 1.1.2
+        - version: 1.1.2b
+        - version: 1.1.2a
+        - version: 1.1.1
+        - version: 1.1.0
+        - version: 1.1.0-rc3
+        - version: 1.1.0-rc2
+        - version: 1.1.0-rc1
+        - version: 1.0.x-last
+        - version: 1.0.3
+        - version: 1.0.3-rc3
+        - version: 1.0.3-rc2
+        - version: 1.0.3-rc1
+        - version: 1.0.2
+        - version: 1.0.2-rc1
+        - version: 1.0.1
+        - version: 1.0.1-rc1
+        - version: 1.0.0
+        - version: 1.0.0-rc1
+        - other: version is omitted from this object for testing
+    EOS
+  end
+  let(:content_simple) { "version: 1.2.3" }
+
+  # This should produce a `Psych::SyntaxError` (`did not find expected comment
+  # or line break while scanning a block scalar`)
+  let(:content_invalid) { ">~" }
+
+  let(:content_matches) { ["1.1.2", "1.1.1", "1.1.0", "1.0.3", "1.0.2", "1.0.1", "1.0.0"] }
+  let(:content_simple_matches) { ["1.2.3"] }
+
+  let(:find_versions_return_hash) do
+    {
+      matches: {
+        "1.1.2" => Version.new("1.1.2"),
+        "1.1.1" => Version.new("1.1.1"),
+        "1.1.0" => Version.new("1.1.0"),
+        "1.0.3" => Version.new("1.0.3"),
+        "1.0.2" => Version.new("1.0.2"),
+        "1.0.1" => Version.new("1.0.1"),
+        "1.0.0" => Version.new("1.0.0"),
+      },
+      regex:,
+      url:     http_url,
+    }
+  end
+
+  let(:find_versions_cached_return_hash) do
+    find_versions_return_hash.merge({ cached: true })
+  end
+
+  describe "::match?" do
+    it "returns true for an HTTP URL" do
+      expect(yaml.match?(http_url)).to be true
+    end
+
+    it "returns false for a non-HTTP URL" do
+      expect(yaml.match?(non_http_url)).to be false
+    end
+  end
+
+  describe "::parse_yaml" do
+    it "returns an object when given valid content" do
+      expect(yaml.parse_yaml(content_simple)).to be_an_instance_of(Hash)
+    end
+  end
+
+  describe "::versions_from_content" do
+    it "returns an empty array when given a block but content is blank" do
+      expect(yaml.versions_from_content("", regex) { "1.2.3" }).to eq([])
+    end
+
+    it "errors if provided content is not valid YAML" do
+      expect { yaml.versions_from_content(content_invalid) { [] } }
+        .to raise_error(RuntimeError, "Content could not be parsed as YAML.")
+    end
+
+    it "returns an array of version strings when given content and a block" do
+      # Returning a string from block
+      expect(yaml.versions_from_content(content_simple) { |yaml| yaml["version"] }).to eq(content_simple_matches)
+      expect(yaml.versions_from_content(content_simple, regex) do |yaml|
+        yaml["version"][regex, 1]
+      end).to eq(content_simple_matches)
+
+      # Returning an array of strings from block
+      expect(yaml.versions_from_content(content, regex) do |yaml, regex|
+        yaml["versions"].select { |item| item["version"]&.match?(regex) }
+                        .map { |item| item["version"][regex, 1] }
+      end).to eq(content_matches)
+    end
+
+    it "allows a nil return from a block" do
+      expect(yaml.versions_from_content(content_simple, regex) { next }).to eq([])
+    end
+
+    it "errors if a block uses two arguments but a regex is not given" do
+      expect { yaml.versions_from_content(content_simple) { |yaml, regex| yaml["version"][regex, 1] } }
+        .to raise_error("Two arguments found in `strategy` block but no regex provided.")
+    end
+
+    it "errors on an invalid return type from a block" do
+      expect { yaml.versions_from_content(content_simple, regex) { 123 } }
+        .to raise_error(TypeError, Homebrew::Livecheck::Strategy::INVALID_BLOCK_RETURN_VALUE_MSG)
+    end
+  end
+
+  describe "::find_versions?" do
+    it "finds versions in provided_content using a block" do
+      expect(yaml.find_versions(url: http_url, regex:, provided_content: content) do |yaml, regex|
+        yaml["versions"].select { |item| item["version"]&.match?(regex) }
+                        .map { |item| item["version"][regex, 1] }
+      end).to eq(find_versions_cached_return_hash)
+
+      # NOTE: A regex should be provided using the `#regex` method in a
+      #       `livecheck` block but we're using a regex literal in the `strategy`
+      #       block here simply to ensure this method works as expected when a
+      #       regex isn't provided.
+      expect(yaml.find_versions(url: http_url, provided_content: content) do |yaml|
+        regex = /^v?(\d+(?:\.\d+)+)$/i
+        yaml["versions"].select { |item| item["version"]&.match?(regex) }
+                        .map { |item| item["version"][regex, 1] }
+      end).to eq(find_versions_cached_return_hash.merge({ regex: nil }))
+    end
+
+    it "errors if a block is not provided" do
+      expect { yaml.find_versions(url: http_url, provided_content: content) }
+        .to raise_error(ArgumentError, "Yaml requires a `strategy` block")
+    end
+
+    it "returns default match_data when url is blank" do
+      expect(yaml.find_versions(url: "") { "1.2.3" })
+        .to eq({ matches: {}, regex: nil, url: "" })
+    end
+
+    it "returns default match_data when content is blank" do
+      expect(yaml.find_versions(url: http_url, provided_content: "") { "1.2.3" })
+        .to eq({ matches: {}, regex: nil, url: http_url, cached: true })
+    end
+  end
+end
diff --git a/Library/Homebrew/test/livecheck/strategy_spec.rb b/Library/Homebrew/test/livecheck/strategy_spec.rb
index 7dd926fb40503..7ed67125bd9a6 100644
--- a/Library/Homebrew/test/livecheck/strategy_spec.rb
+++ b/Library/Homebrew/test/livecheck/strategy_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "livecheck/strategy"
 
-describe Homebrew::Livecheck::Strategy do
+RSpec.describe Homebrew::Livecheck::Strategy do
   subject(:strategy) { described_class }
 
   describe "::from_symbol" do
diff --git a/Library/Homebrew/test/livecheck_spec.rb b/Library/Homebrew/test/livecheck_spec.rb
index aa5afde7163e6..f0136ca886e1b 100644
--- a/Library/Homebrew/test/livecheck_spec.rb
+++ b/Library/Homebrew/test/livecheck_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula"
 require "livecheck"
 
-describe Livecheck do
+RSpec.describe Livecheck do
   let(:f) do
     formula do
       homepage "https://brew.sh"
@@ -12,7 +11,7 @@
       head "https://github.com/Homebrew/brew.git"
     end
   end
-  let(:livecheckable_f) { described_class.new(f) }
+  let(:livecheckable_f) { described_class.new(f.class) }
 
   let(:c) do
     Cask::CaskLoader.load(+<<-RUBY)
@@ -39,9 +38,9 @@
     end
 
     it "raises a TypeError if the argument isn't a String" do
-      expect {
+      expect do
         livecheckable_f.formula(123)
-      }.to raise_error(TypeError, "Livecheck#formula expects a String")
+      end.to raise_error TypeError
     end
   end
 
@@ -54,12 +53,6 @@
       livecheckable_c.cask("other-cask")
       expect(livecheckable_c.cask).to eq("other-cask")
     end
-
-    it "raises a TypeError if the argument isn't a String" do
-      expect {
-        livecheckable_c.cask(123)
-      }.to raise_error(TypeError, "Livecheck#cask expects a String")
-    end
   end
 
   describe "#regex" do
@@ -71,12 +64,6 @@
       livecheckable_f.regex(/foo/)
       expect(livecheckable_f.regex).to eq(/foo/)
     end
-
-    it "raises a TypeError if the argument isn't a Regexp" do
-      expect {
-        livecheckable_f.regex("foo")
-      }.to raise_error(TypeError, "Livecheck#regex expects a Regexp")
-    end
   end
 
   describe "#skip" do
@@ -91,12 +78,6 @@
       expect(livecheckable_f.instance_variable_get(:@skip)).to be true
       expect(livecheckable_f.instance_variable_get(:@skip_msg)).to eq("foo")
     end
-
-    it "raises a TypeError if the argument isn't a String" do
-      expect {
-        livecheckable_f.skip(/foo/)
-      }.to raise_error(TypeError, "Livecheck#skip expects a String")
-    end
   end
 
   describe "#skip?" do
@@ -117,11 +98,16 @@
       livecheckable_f.strategy(:page_match)
       expect(livecheckable_f.strategy).to eq(:page_match)
     end
+  end
+
+  describe "#throttle" do
+    it "returns nil if not set" do
+      expect(livecheckable_f.throttle).to be_nil
+    end
 
-    it "raises a TypeError if the argument isn't a Symbol" do
-      expect {
-        livecheckable_f.strategy("page_match")
-      }.to raise_error(TypeError, "Livecheck#strategy expects a Symbol")
+    it "returns the Integer if set" do
+      livecheckable_f.throttle(10)
+      expect(livecheckable_f.throttle).to eq(10)
     end
   end
 
@@ -151,10 +137,10 @@
       expect(livecheckable_c.url).to eq(:url)
     end
 
-    it "raises a TypeError if the argument isn't a String or valid Symbol" do
-      expect {
-        livecheckable_f.url(/foo/)
-      }.to raise_error(TypeError, "Livecheck#url expects a String or valid Symbol")
+    it "raises an ArgumentError if the argument isn't a valid Symbol" do
+      expect do
+        livecheckable_f.url(:not_a_valid_symbol)
+      end.to raise_error ArgumentError
     end
   end
 
@@ -168,6 +154,7 @@
           "skip"     => false,
           "skip_msg" => nil,
           "strategy" => nil,
+          "throttle" => nil,
           "url"      => nil,
         },
       )
diff --git a/Library/Homebrew/test/locale_spec.rb b/Library/Homebrew/test/locale_spec.rb
index e704fe87b09d6..c0d3564d7345c 100644
--- a/Library/Homebrew/test/locale_spec.rb
+++ b/Library/Homebrew/test/locale_spec.rb
@@ -1,19 +1,18 @@
-# typed: false
 # frozen_string_literal: true
 
 require "locale"
 
-describe Locale do
+RSpec.describe Locale do
   describe "::parse" do
     it "parses a string in the correct format" do
       expect(described_class.parse("zh")).to eql(described_class.new("zh", nil, nil))
-      expect(described_class.parse("zh-CN")).to eql(described_class.new("zh", "CN", nil))
-      expect(described_class.parse("zh-Hans")).to eql(described_class.new("zh", nil, "Hans"))
-      expect(described_class.parse("zh-CN-Hans")).to eql(described_class.new("zh", "CN", "Hans"))
+      expect(described_class.parse("zh-CN")).to eql(described_class.new("zh", nil, "CN"))
+      expect(described_class.parse("zh-Hans")).to eql(described_class.new("zh", "Hans", nil))
+      expect(described_class.parse("zh-Hans-CN")).to eql(described_class.new("zh", "Hans", "CN"))
     end
 
     it "correctly parses a string with a UN M.49 region code" do
-      expect(described_class.parse("es-419")).to eql(described_class.new("es", "419", nil))
+      expect(described_class.parse("es-419")).to eql(described_class.new("es", nil, "419"))
     end
 
     describe "raises a ParserError when given" do
@@ -22,6 +21,7 @@
       end
 
       it "a string in a wrong format" do
+        expect { described_class.parse("zh-CN-Hans") }.to raise_error(Locale::ParserError)
         expect { described_class.parse("zh_CN_Hans") }.to raise_error(Locale::ParserError)
         expect { described_class.parse("zhCNHans") }.to raise_error(Locale::ParserError)
         expect { described_class.parse("zh-CN_Hans") }.to raise_error(Locale::ParserError)
@@ -41,27 +41,27 @@
 
     it "raises a ParserError when one of the arguments does not match the locale format" do
       expect { described_class.new("ZH", nil, nil) }.to raise_error(Locale::ParserError)
-      expect { described_class.new(nil, "cn", nil) }.to raise_error(Locale::ParserError)
-      expect { described_class.new(nil, nil, "hans") }.to raise_error(Locale::ParserError)
+      expect { described_class.new(nil, "hans", nil) }.to raise_error(Locale::ParserError)
+      expect { described_class.new(nil, nil, "cn") }.to raise_error(Locale::ParserError)
     end
   end
 
   describe "#include?" do
-    subject { described_class.new("zh", "CN", "Hans") }
+    subject { described_class.new("zh", "Hans", "CN") }
 
     it { is_expected.to include("zh") }
     it { is_expected.to include("zh-CN") }
     it { is_expected.to include("CN") }
-    it { is_expected.to include("CN-Hans") }
+    it { is_expected.to include("Hans-CN") }
     it { is_expected.to include("Hans") }
-    it { is_expected.to include("zh-CN-Hans") }
+    it { is_expected.to include("zh-Hans-CN") }
   end
 
   describe "#eql?" do
-    subject(:locale) { described_class.new("zh", "CN", "Hans") }
+    subject(:locale) { described_class.new("zh", "Hans", "CN") }
 
     context "when all parts match" do
-      it { is_expected.to eql("zh-CN-Hans") }
+      it { is_expected.to eql("zh-Hans-CN") }
       it { is_expected.to eql(locale) }
     end
 
@@ -69,7 +69,7 @@
       it { is_expected.not_to eql("zh") }
       it { is_expected.not_to eql("zh-CN") }
       it { is_expected.not_to eql("CN") }
-      it { is_expected.not_to eql("CN-Hans") }
+      it { is_expected.not_to eql("Hans-CN") }
       it { is_expected.not_to eql("Hans") }
     end
 
@@ -83,9 +83,9 @@
     let(:locale_groups) { [["zh"], ["zh-TW"]] }
 
     it "finds best matching language code, independent of order" do
-      expect(described_class.new("zh", "TW", nil).detect(locale_groups)).to eql(["zh-TW"])
-      expect(described_class.new("zh", "TW", nil).detect(locale_groups.reverse)).to eql(["zh-TW"])
-      expect(described_class.new("zh", "CN", "Hans").detect(locale_groups)).to eql(["zh"])
+      expect(described_class.new("zh", nil, "TW").detect(locale_groups)).to eql(["zh-TW"])
+      expect(described_class.new("zh", nil, "TW").detect(locale_groups.reverse)).to eql(["zh-TW"])
+      expect(described_class.new("zh", "Hans", "CN").detect(locale_groups)).to eql(["zh"])
     end
   end
 end
diff --git a/Library/Homebrew/test/lock_file_spec.rb b/Library/Homebrew/test/lock_file_spec.rb
index bd420b75b209c..cb82d3eda2448 100644
--- a/Library/Homebrew/test/lock_file_spec.rb
+++ b/Library/Homebrew/test/lock_file_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "lock_file"
 
-describe LockFile do
-  subject(:lock_file) { described_class.new("foo") }
+RSpec.describe LockFile do
+  subject(:lock_file) { described_class.new(:lock, Pathname("foo")) }
 
   describe "#lock" do
     it "does not raise an error when already locked" do
@@ -16,9 +15,9 @@
     it "raises an error if a lock already exists" do
       lock_file.lock
 
-      expect {
-        described_class.new("foo").lock
-      }.to raise_error(OperationInProgressError)
+      expect do
+        described_class.new(:lock, Pathname("foo")).lock
+      end.to raise_error(OperationInProgressError)
     end
   end
 
@@ -31,7 +30,7 @@
       lock_file.lock
       lock_file.unlock
 
-      expect { described_class.new("foo").lock }.not_to raise_error
+      expect { described_class.new(:lock, Pathname("foo")).lock }.not_to raise_error
     end
   end
 end
diff --git a/Library/Homebrew/test/macos_runner_spec_spec.rb b/Library/Homebrew/test/macos_runner_spec_spec.rb
new file mode 100644
index 0000000000000..9f881787ce217
--- /dev/null
+++ b/Library/Homebrew/test/macos_runner_spec_spec.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "macos_runner_spec"
+
+RSpec.describe MacOSRunnerSpec do
+  let(:spec) { described_class.new(name: "macOS 11-arm64", runner: "11-arm64", timeout: 90, cleanup: true) }
+
+  it "has immutable attributes" do
+    [:name, :runner, :timeout, :cleanup].each do |attribute|
+      expect(spec.respond_to?(:"#{attribute}=")).to be(false)
+    end
+  end
+
+  describe "#to_h" do
+    it "returns an object that responds to `#to_json`" do
+      expect(spec.to_h.respond_to?(:to_json)).to be(true)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/macos_version_spec.rb b/Library/Homebrew/test/macos_version_spec.rb
new file mode 100644
index 0000000000000..6f74bc1fa3ee3
--- /dev/null
+++ b/Library/Homebrew/test/macos_version_spec.rb
@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "macos_version"
+
+RSpec.describe MacOSVersion do
+  let(:version) { described_class.new("10.14") }
+  let(:big_sur_major) { described_class.new("11.0") }
+  let(:big_sur_update) { described_class.new("11.1") }
+
+  describe ".kernel_major_version" do
+    it "returns the kernel major version" do
+      expect(described_class.kernel_major_version(version)).to eq "18"
+      expect(described_class.kernel_major_version(big_sur_major)).to eq "20"
+      expect(described_class.kernel_major_version(big_sur_update)).to eq "20"
+    end
+
+    it "matches the major version returned by OS.kernel_version", :needs_macos do
+      expect(described_class.kernel_major_version(OS::Mac.version)).to eq OS.kernel_version.major
+    end
+  end
+
+  specify "comparison with Symbol" do
+    expect(version).to be > :high_sierra
+    expect(version).to eq :mojave
+    expect(version).to be === :mojave # rubocop:disable Style/CaseEquality
+    expect(version).to be < :catalina
+  end
+
+  specify "comparison with Integer" do
+    expect(version).to be > 10
+    expect(version).to be < 11
+  end
+
+  specify "comparison with String" do
+    expect(version).to be > "10.3"
+    expect(version).to eq "10.14"
+    expect(version).to be === "10.14" # rubocop:disable Style/CaseEquality
+    expect(version).to be < "10.15"
+  end
+
+  specify "comparison with Version" do
+    expect(version).to be > Version.new("10.3")
+    expect(version).to eq Version.new("10.14")
+    expect(version).to be === Version.new("10.14") # rubocop:disable Style/CaseEquality
+    expect(version).to be < Version.new("10.15")
+  end
+
+  describe "after Big Sur" do
+    specify "comparison with :big_sur" do
+      expect(big_sur_major).to eq :big_sur
+      expect(big_sur_major).to be <= :big_sur
+      expect(big_sur_major).to be >= :big_sur
+      expect(big_sur_major).not_to be > :big_sur
+      expect(big_sur_major).not_to be < :big_sur
+
+      expect(big_sur_update).to eq :big_sur
+      expect(big_sur_update).to be <= :big_sur
+      expect(big_sur_update).to be >= :big_sur
+      expect(big_sur_update).not_to be > :big_sur
+      expect(big_sur_update).not_to be < :big_sur
+    end
+  end
+
+  describe "#new" do
+    it "raises an error if the version is not a valid macOS version" do
+      expect do
+        described_class.new("1.2")
+      end.to raise_error(MacOSVersion::Error, 'unknown or unsupported macOS version: "1.2"')
+    end
+
+    it "creates a new version from a valid macOS version" do
+      string_version = described_class.new("11")
+      expect(string_version).to eq(:big_sur)
+    end
+  end
+
+  describe "#from_symbol" do
+    it "raises an error if the symbol is not a valid macOS version" do
+      expect do
+        described_class.from_symbol(:foo)
+      end.to raise_error(MacOSVersion::Error, "unknown or unsupported macOS version: :foo")
+    end
+
+    it "creates a new version from a valid macOS version" do
+      symbol_version = described_class.from_symbol(:mojave)
+      expect(symbol_version).to eq(version)
+    end
+  end
+
+  specify "#pretty_name" do
+    expect(described_class.new("10.11").pretty_name).to eq("El Capitan")
+    expect(described_class.new("10.14").pretty_name).to eq("Mojave")
+  end
+
+  specify "#inspect" do
+    expect(described_class.new("11").inspect).to eq("#<MacOSVersion: \"11\">")
+  end
+
+  specify "#requires_nehalem_cpu?", :needs_macos do
+    expect(Hardware::CPU).to receive(:type).at_least(:twice).and_return(:intel)
+    expect(described_class.new("10.14").requires_nehalem_cpu?).to be true
+    expect(described_class.new("10.12").requires_nehalem_cpu?).to be false
+  end
+end
diff --git a/Library/Homebrew/test/messages_spec.rb b/Library/Homebrew/test/messages_spec.rb
index 6212ced402566..412e5d6764a8b 100644
--- a/Library/Homebrew/test/messages_spec.rb
+++ b/Library/Homebrew/test/messages_spec.rb
@@ -1,41 +1,40 @@
-# typed: false
 # frozen_string_literal: true
 
 require "messages"
 require "spec_helper"
 
-describe Messages do
+RSpec.describe Messages do
   let(:messages) { described_class.new }
   let(:test_formula) { formula("foo") { url("https://brew.sh/foo-0.1.tgz") } }
   let(:elapsed_time) { 1.1 }
 
   describe "#record_caveats" do
     it "adds a caveat" do
-      expect {
-        messages.record_caveats(test_formula, "Zsh completions were installed")
-      }.to change(messages.caveats, :count).by(1)
+      expect do
+        messages.record_caveats(test_formula.name, "Zsh completions were installed")
+      end.to change(messages.caveats, :count).by(1)
     end
   end
 
   describe "#package_installed" do
     it "increases the package count" do
-      expect {
-        messages.package_installed(test_formula, elapsed_time)
-      }.to change(messages, :package_count).by(1)
+      expect do
+        messages.package_installed(test_formula.name, elapsed_time)
+      end.to change(messages, :package_count).by(1)
     end
 
     it "adds to install_times" do
-      expect {
-        messages.package_installed(test_formula, elapsed_time)
-      }.to change(messages.install_times, :count).by(1)
+      expect do
+        messages.package_installed(test_formula.name, elapsed_time)
+      end.to change(messages.install_times, :count).by(1)
     end
   end
 
   describe "#display_messages" do
     context "when package_count is less than two" do
       before do
-        messages.record_caveats(test_formula, "Zsh completions were installed")
-        messages.package_installed(test_formula, elapsed_time)
+        messages.record_caveats(test_formula.name, "Zsh completions were installed")
+        messages.package_installed(test_formula.name, elapsed_time)
       end
 
       it "doesn't print caveat details" do
@@ -45,7 +44,7 @@
 
     context "when caveats is empty" do
       before do
-        messages.package_installed(test_formula, elapsed_time)
+        messages.package_installed(test_formula.name, elapsed_time)
       end
 
       it "doesn't print caveat details" do
@@ -57,9 +56,9 @@
       let(:test_formula2) { formula("bar") { url("https://brew.sh/bar-0.1.tgz") } }
 
       before do
-        messages.record_caveats(test_formula, "Zsh completions were installed")
-        messages.package_installed(test_formula, elapsed_time)
-        messages.package_installed(test_formula2, elapsed_time)
+        messages.record_caveats(test_formula.name, "Zsh completions were installed")
+        messages.package_installed(test_formula.name, elapsed_time)
+        messages.package_installed(test_formula2.name, elapsed_time)
       end
 
       it "prints caveat details" do
@@ -82,7 +81,7 @@
 
       context "when `install_times` is present" do
         before do
-          messages.package_installed(test_formula, elapsed_time)
+          messages.package_installed(test_formula.name, elapsed_time)
         end
 
         it "prints installation times" do
diff --git a/Library/Homebrew/test/migrator_spec.rb b/Library/Homebrew/test/migrator_spec.rb
index 91889853242d0..e84ca5fe7c4a7 100644
--- a/Library/Homebrew/test/migrator_spec.rb
+++ b/Library/Homebrew/test/migrator_spec.rb
@@ -1,4 +1,3 @@
-# typed: false
 # frozen_string_literal: true
 
 require "migrator"
@@ -6,8 +5,8 @@
 require "tab"
 require "keg"
 
-describe Migrator do
-  subject(:migrator) { described_class.new(new_formula) }
+RSpec.describe Migrator do
+  subject(:migrator) { described_class.new(new_formula, old_formula.name) }
 
   let(:new_formula) { Testball.new("newname") }
   let(:old_formula) { Testball.new("oldname") }
@@ -21,7 +20,7 @@
   let(:old_pin) { HOMEBREW_PINNED_KEGS/"oldname" }
 
   before do |example|
-    allow(new_formula).to receive(:oldname).and_return("oldname")
+    allow(new_formula).to receive(:oldnames).and_return(["oldname"])
 
     # do not create directories for error tests
     next if example.metadata[:description].start_with?("raises an error")
@@ -56,16 +55,10 @@
   end
 
   describe "::new" do
-    it "raises an error if there is no old name" do
-      expect {
-        described_class.new(old_formula)
-      }.to raise_error(Migrator::MigratorNoOldnameError)
-    end
-
     it "raises an error if there is no old path" do
-      expect {
-        described_class.new(new_formula)
-      }.to raise_error(Migrator::MigratorNoOldpathError)
+      expect do
+        described_class.new(new_formula, "oldname")
+      end.to raise_error(Migrator::MigratorNoOldpathError)
     end
 
     it "raises an error if the Taps differ" do
@@ -76,9 +69,9 @@
       tab.source["tap"] = "homebrew/core"
       tab.write
 
-      expect {
-        described_class.new(new_formula)
-      }.to raise_error(Migrator::MigratorDifferentTapsError)
+      expect do
+        described_class.new(new_formula, "oldname")
+      end.to raise_error(Migrator::MigratorDifferentTapsError)
     end
   end
 
@@ -94,7 +87,7 @@
   end
 
   specify "#backup_oldname_cellar" do
-    old_keg_record.parent.rmtree
+    FileUtils.rm_r(old_keg_record.parent)
     (new_keg_record/"bin").mkpath
 
     migrator.backup_oldname_cellar
@@ -213,7 +206,7 @@
     tab.tabfile = HOMEBREW_CELLAR/"oldname/0.1/INSTALL_RECEIPT.json"
     tab.source["path"] = "/should/be/the/same"
     tab.write
-    migrator = described_class.new(new_formula)
+    migrator = described_class.new(new_formula, "oldname")
     tab.tabfile.delete
     migrator.backup_old_tabs
     expect(Tab.for_keg(old_keg_record).source["path"]).to eq("/should/be/the/same")
diff --git a/Library/Homebrew/test/missing_formula_spec.rb b/Library/Homebrew/test/missing_formula_spec.rb
index 6ccfd39fc7968..d737379fbb3b5 100644
--- a/Library/Homebrew/test/missing_formula_spec.rb
+++ b/Library/Homebrew/test/missing_formula_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "missing_formula"
 
-describe Homebrew::MissingFormula do
+RSpec.describe Homebrew::MissingFormula do
   describe "::reason" do
     subject { described_class.reason("gem") }
 
@@ -22,7 +21,6 @@
     it { is_expected.to disallow("pil") }
     it { is_expected.to disallow("macruby") }
     it { is_expected.to disallow("lzma") }
-    it { is_expected.to disallow("sshpass") }
     it { is_expected.to disallow("gsutil") }
     it { is_expected.to disallow("gfortran") }
     it { is_expected.to disallow("play") }
@@ -36,7 +34,7 @@
     subject { described_class.tap_migration_reason(formula) }
 
     before do
-      tap_path = Tap::TAP_DIRECTORY/"homebrew/homebrew-foo"
+      tap_path = HOMEBREW_TAP_DIRECTORY/"homebrew/homebrew-foo"
       tap_path.mkpath
       (tap_path/"tap_migrations.json").write <<~JSON
         { "migrated-formula": "homebrew/bar" }
@@ -60,9 +58,9 @@
     subject { described_class.deleted_reason(formula, silent: true) }
 
     before do
-      tap_path = Tap::TAP_DIRECTORY/"homebrew/homebrew-foo"
-      tap_path.mkpath
-      (tap_path/"deleted-formula.rb").write "placeholder"
+      tap_path = HOMEBREW_TAP_DIRECTORY/"homebrew/homebrew-foo"
+      (tap_path/"Formula").mkpath
+      (tap_path/"Formula/deleted-formula.rb").write "placeholder"
       ENV.delete "GIT_AUTHOR_DATE"
       ENV.delete "GIT_COMMITTER_DATE"
 
@@ -70,26 +68,38 @@
         system "git", "init"
         system "git", "add", "--all"
         system "git", "commit", "-m", "initial state"
-        system "git", "rm", "deleted-formula.rb"
+        system "git", "rm", "Formula/deleted-formula.rb"
         system "git", "commit", "-m", "delete formula 'deleted-formula'"
       end
     end
 
-    context "with a deleted formula" do
-      let(:formula) { "homebrew/foo/deleted-formula" }
+    shared_examples "it detects deleted formulae" do
+      context "with a deleted formula" do
+        let(:formula) { "homebrew/foo/deleted-formula" }
 
-      it { is_expected.not_to be_nil }
+        it { is_expected.not_to be_nil }
+      end
+
+      context "with a formula that never existed" do
+        let(:formula) { "homebrew/foo/missing-formula" }
+
+        it { is_expected.to be_nil }
+      end
     end
 
-    context "with a formula that never existed" do
-      let(:formula) { "homebrew/foo/missing-formula" }
+    include_examples "it detects deleted formulae"
 
-      it { is_expected.to be_nil }
+    describe "on the core tap" do
+      before do
+        allow_any_instance_of(Tap).to receive(:core_tap?).and_return(true)
+      end
+
+      include_examples "it detects deleted formulae"
     end
   end
 
   describe "::cask_reason", :cask do
-    subject { described_class.cask_reason(formula, show_info: show_info) }
+    subject { described_class.cask_reason(formula, show_info:) }
 
     context "with a formula name that is a cask and show_info: false" do
       let(:formula) { "local-caffeine" }
@@ -103,7 +113,7 @@
       let(:formula) { "local-caffeine" }
       let(:show_info) { true }
 
-      it { is_expected.to match(/Found a cask named "local-caffeine" instead.\n\nlocal-caffeine: 1.2.3\n/) }
+      it { is_expected.to match(/Found a cask named "local-caffeine" instead.\n\n==> local-caffeine: 1.2.3\n/) }
     end
 
     context "with a formula name that is not a cask" do
diff --git a/Library/Homebrew/test/options/deprecated_option_spec.rb b/Library/Homebrew/test/options/deprecated_option_spec.rb
index 78eaec475f0ae..9ee7c02771a21 100644
--- a/Library/Homebrew/test/options/deprecated_option_spec.rb
+++ b/Library/Homebrew/test/options/deprecated_option_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "options"
 
-describe DeprecatedOption do
+RSpec.describe DeprecatedOption do
   subject(:option) { described_class.new("foo", "bar") }
 
   specify "#old" do
diff --git a/Library/Homebrew/test/options/option_spec.rb b/Library/Homebrew/test/options/option_spec.rb
index 0300763188e6d..692483d526d1c 100644
--- a/Library/Homebrew/test/options/option_spec.rb
+++ b/Library/Homebrew/test/options/option_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "options"
 
-describe Option do
+RSpec.describe Option do
   subject(:option) { described_class.new("foo") }
 
   specify "#to_s" do
diff --git a/Library/Homebrew/test/options_spec.rb b/Library/Homebrew/test/options_spec.rb
index 62e2fb420ff79..8969d6de5ad9a 100644
--- a/Library/Homebrew/test/options_spec.rb
+++ b/Library/Homebrew/test/options_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "options"
 
-describe Options do
+RSpec.describe Options do
   subject(:options) { described_class.new }
 
   it "removes duplicate options" do
@@ -90,6 +89,14 @@
     expect(described_class.create(array).sort).to eq([option1, option2].sort)
   end
 
+  specify "#to_s" do
+    expect(options.to_s).to eq("")
+    options << Option.new("first")
+    expect(options.to_s).to eq("--first")
+    options << Option.new("second")
+    expect(options.to_s).to eq("--first --second")
+  end
+
   specify "#inspect" do
     expect(options.inspect).to eq("#<Options: []>")
     options << Option.new("foo")
diff --git a/Library/Homebrew/test/os/linux/dependency_collector_spec.rb b/Library/Homebrew/test/os/linux/dependency_collector_spec.rb
index 8943f93ac4762..5df6690988a13 100644
--- a/Library/Homebrew/test/os/linux/dependency_collector_spec.rb
+++ b/Library/Homebrew/test/os/linux/dependency_collector_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "dependency_collector"
 
-describe DependencyCollector do
+RSpec.describe DependencyCollector do
   alias_matcher :be_a_build_requirement, :be_build
 
   subject(:collector) { described_class.new }
@@ -11,27 +10,27 @@
   describe "#add" do
     resource = Resource.new
 
-    context "when xz, unzip, and bzip2 are not available" do
+    context "when xz, unzip and bzip2 are not available" do
       it "creates a resource dependency from a '.xz' URL" do
         resource.url("https://brew.sh/foo.xz")
         allow_any_instance_of(Object).to receive(:which).with("xz")
-        expect(collector.add(resource)).to eq(Dependency.new("xz", [:build, :test]))
+        expect(collector.add(resource)).to eq(Dependency.new("xz", [:build, :test, :implicit]))
       end
 
       it "creates a resource dependency from a '.zip' URL" do
         resource.url("https://brew.sh/foo.zip")
         allow_any_instance_of(Object).to receive(:which).with("unzip")
-        expect(collector.add(resource)).to eq(Dependency.new("unzip", [:build, :test]))
+        expect(collector.add(resource)).to eq(Dependency.new("unzip", [:build, :test, :implicit]))
       end
 
       it "creates a resource dependency from a '.bz2' URL" do
         resource.url("https://brew.sh/foo.tar.bz2")
         allow_any_instance_of(Object).to receive(:which).with("bzip2")
-        expect(collector.add(resource)).to eq(Dependency.new("bzip2", [:build, :test]))
+        expect(collector.add(resource)).to eq(Dependency.new("bzip2", [:build, :test, :implicit]))
       end
     end
 
-    context "when xz, zip, and bzip2 are available" do
+    context "when xz, zip and bzip2 are available" do
       it "does not create a resource dependency from a '.xz' URL" do
         resource.url("https://brew.sh/foo.xz")
         allow_any_instance_of(Object).to receive(:which).with("xz").and_return(Pathname.new("foo"))
diff --git a/Library/Homebrew/test/os/linux/diagnostic_spec.rb b/Library/Homebrew/test/os/linux/diagnostic_spec.rb
index b97268677a8ff..4a1d23169c0b5 100644
--- a/Library/Homebrew/test/os/linux/diagnostic_spec.rb
+++ b/Library/Homebrew/test/os/linux/diagnostic_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "diagnostic"
 
-describe Homebrew::Diagnostic::Checks do
+RSpec.describe Homebrew::Diagnostic::Checks do
   subject(:checks) { described_class.new }
 
   specify "#check_supported_architecture" do
diff --git a/Library/Homebrew/test/os/linux/elf_spec.rb b/Library/Homebrew/test/os/linux/elf_spec.rb
new file mode 100644
index 0000000000000..6bcf15f0a97cd
--- /dev/null
+++ b/Library/Homebrew/test/os/linux/elf_spec.rb
@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+RSpec.describe OS::Linux::Elf do
+  describe "::expand_elf_dst" do
+    it "expands tokens that are not wrapped in curly braces" do
+      str = "$ORIGIN/../lib"
+      ref = "ORIGIN"
+      repl = "/opt/homebrew/bin"
+      expected = "/opt/homebrew/bin/../lib"
+      expect(described_class.expand_elf_dst(str, ref, repl)).to eq(expected)
+    end
+
+    it "expands tokens that are wrapped in curly braces" do
+      str = "${ORIGIN}/../lib"
+      ref = "ORIGIN"
+      repl = "/opt/homebrew/bin"
+      expected = "/opt/homebrew/bin/../lib"
+      expect(described_class.expand_elf_dst(str, ref, repl)).to eq(expected)
+
+      str = "${ORIGIN}new/../lib"
+      ref = "ORIGIN"
+      repl = "/opt/homebrew/bin"
+      expected = "/opt/homebrew/binnew/../lib"
+      expect(described_class.expand_elf_dst(str, ref, repl)).to eq(expected)
+    end
+
+    it "expands multiple occurrences of token" do
+      str = "${ORIGIN}/../..$ORIGIN/../lib"
+      ref = "ORIGIN"
+      repl = "/opt/homebrew/bin"
+      expected = "/opt/homebrew/bin/../../opt/homebrew/bin/../lib"
+      expect(described_class.expand_elf_dst(str, ref, repl)).to eq(expected)
+    end
+
+    it "rejects and passes through tokens containing additional characters" do
+      str = "$ORIGINAL/../lib"
+      ref = "ORIGIN"
+      repl = "/opt/homebrew/bin"
+      expected = "$ORIGINAL/../lib"
+      expect(described_class.expand_elf_dst(str, ref, repl)).to eq(expected)
+
+      str = "$ORIGIN_/../lib"
+      ref = "ORIGIN"
+      repl = "/opt/homebrew/bin"
+      expected = "$ORIGIN_/../lib"
+      expect(described_class.expand_elf_dst(str, ref, repl)).to eq(expected)
+
+      str = "$ORIGIN_STORY/../lib"
+      ref = "ORIGIN"
+      repl = "/opt/homebrew/bin"
+      expected = "$ORIGIN_STORY/../lib"
+      expect(described_class.expand_elf_dst(str, ref, repl)).to eq(expected)
+
+      str = "${ORIGINAL}/../lib"
+      ref = "ORIGIN"
+      repl = "/opt/homebrew/bin"
+      expected = "${ORIGINAL}/../lib"
+      expect(described_class.expand_elf_dst(str, ref, repl)).to eq(expected)
+
+      str = "${ORIGIN_}/../lib"
+      ref = "ORIGIN"
+      repl = "/opt/homebrew/bin"
+      expected = "${ORIGIN_}/../lib"
+      expect(described_class.expand_elf_dst(str, ref, repl)).to eq(expected)
+
+      str = "${ORIGIN_STORY}/../lib"
+      ref = "ORIGIN"
+      repl = "/opt/homebrew/bin"
+      expected = "${ORIGIN_STORY}/../lib"
+      expect(described_class.expand_elf_dst(str, ref, repl)).to eq(expected)
+    end
+
+    it "rejects and passes through tokens with mismatched curly braces" do
+      str = "${ORIGIN/../lib"
+      ref = "ORIGIN"
+      repl = "/opt/homebrew/bin"
+      expected = "${ORIGIN/../lib"
+      expect(described_class.expand_elf_dst(str, ref, repl)).to eq(expected)
+
+      str = "$ORIGIN}/../lib"
+      ref = "ORIGIN"
+      repl = "/opt/homebrew/bin"
+      expected = "$ORIGIN}/../lib"
+      expect(described_class.expand_elf_dst(str, ref, repl)).to eq(expected)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/os/linux/formula_installer_spec.rb b/Library/Homebrew/test/os/linux/formula_installer_spec.rb
new file mode 100644
index 0000000000000..f5c47599de1e9
--- /dev/null
+++ b/Library/Homebrew/test/os/linux/formula_installer_spec.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "formula_installer"
+require "test/support/fixtures/testball"
+
+RSpec.describe FormulaInstaller do
+  include FileUtils
+
+  subject(:keg) { described_class.new(keg_path) }
+
+  describe "#fresh_install" do
+    subject(:formula_installer) { described_class.new(Testball.new) }
+
+    it "is true by default" do
+      formula = Testball.new
+      expect(formula_installer.fresh_install?(formula)).to be true
+    end
+
+    it "is false in developer mode" do
+      formula = Testball.new
+      allow(Homebrew::EnvConfig).to receive_messages(developer?: true)
+      expect(formula_installer.fresh_install?(formula)).to be false
+    end
+  end
+end
diff --git a/Library/Homebrew/test/os/linux/formula_spec.rb b/Library/Homebrew/test/os/linux/formula_spec.rb
index 7b585ab2f7249..0149343376bfa 100644
--- a/Library/Homebrew/test/os/linux/formula_spec.rb
+++ b/Library/Homebrew/test/os/linux/formula_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "test/support/fixtures/testball"
 require "formula"
 
-describe Formula do
+RSpec.describe Formula do
   describe "#uses_from_macos" do
     before do
       allow(OS).to receive(:mac?).and_return(false)
diff --git a/Library/Homebrew/test/os/linux/ld_spec.rb b/Library/Homebrew/test/os/linux/ld_spec.rb
new file mode 100644
index 0000000000000..b738bbe2537e6
--- /dev/null
+++ b/Library/Homebrew/test/os/linux/ld_spec.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "os/linux/ld"
+require "tmpdir"
+
+RSpec.describe OS::Linux::Ld do
+  describe "::library_paths" do
+    ld_etc = Pathname("")
+    before do
+      ld_etc = Pathname(Dir.mktmpdir("homebrew-tests-ld-etc-", Dir.tmpdir))
+      FileUtils.mkdir [ld_etc/"subdir1", ld_etc/"subdir2"]
+      (ld_etc/"ld.so.conf").write <<~EOS
+        # This line is a comment
+
+        include #{ld_etc}/subdir1/*.conf # This is an end-of-line comment, should be ignored
+
+        # subdir2 is an empty directory
+        include #{ld_etc}/subdir2/*.conf
+
+        /a/b/c
+          /d/e/f # Indentation on this line should be ignored
+        /a/b/c # Duplicate entry should be ignored
+      EOS
+
+      (ld_etc/"subdir1/1-1.conf").write <<~EOS
+        /foo/bar
+        /baz/qux
+      EOS
+
+      (ld_etc/"subdir1/1-2.conf").write <<~EOS
+        /g/h/i
+      EOS
+
+      # Empty files (or files containing only whitespace) should be ignored
+      (ld_etc/"subdir1/1-3.conf").write "\n\t\n\t\n"
+      (ld_etc/"subdir1/1-4.conf").write ""
+    end
+
+    after do
+      FileUtils.rm_rf ld_etc
+    end
+
+    it "parses library paths successfully" do
+      expect(described_class.library_paths(ld_etc/"ld.so.conf")).to eq(%w[/foo/bar /baz/qux /g/h/i /a/b/c /d/e/f])
+    end
+  end
+end
diff --git a/Library/Homebrew/test/os/linux/pathname_spec.rb b/Library/Homebrew/test/os/linux/pathname_spec.rb
index 45d41849afa18..62d4e96bec968 100644
--- a/Library/Homebrew/test/os/linux/pathname_spec.rb
+++ b/Library/Homebrew/test/os/linux/pathname_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "extend/pathname"
 
-describe Pathname do
+RSpec.describe Pathname do
   let(:elf_dir) { described_class.new "#{TEST_FIXTURE_DIR}/elf" }
   let(:sho) { elf_dir/"libforty.so.0" }
   let(:sho_without_runpath_rpath) { elf_dir/"libhello.so.0" }
@@ -54,7 +53,7 @@ def patch_elfs
       prefixes.each do |new_prefix|
         patch_elfs do |elf|
           interpreter = elf.interpreter.gsub(placeholder_prefix, new_prefix)
-          elf.patch!(interpreter: interpreter)
+          elf.patch!(interpreter:)
 
           modified_elf = elf.dirname/"mod.#{elf.basename}"
           FileUtils.cp(elf, modified_elf)
@@ -68,7 +67,7 @@ def patch_elfs
       prefixes.each do |new_prefix|
         patch_elfs do |elf|
           rpath = elf.rpath.gsub(placeholder_prefix, new_prefix)
-          elf.patch!(rpath: rpath)
+          elf.patch!(rpath:)
 
           modified_elf = elf.dirname/"mod.#{elf.basename}"
           FileUtils.cp(elf, modified_elf)
@@ -83,7 +82,7 @@ def patch_elfs
         patch_elfs do |elf|
           interpreter = elf.interpreter.gsub(placeholder_prefix, new_prefix)
           rpath = elf.rpath.gsub(placeholder_prefix, new_prefix)
-          elf.patch!(interpreter: interpreter, rpath: rpath)
+          elf.patch!(interpreter:, rpath:)
 
           modified_elf = elf.dirname/"mod.#{elf.basename}"
           FileUtils.cp(elf, modified_elf)
diff --git a/Library/Homebrew/test/os/mac/dependency_collector_spec.rb b/Library/Homebrew/test/os/mac/dependency_collector_spec.rb
index e28e5ace58184..d4336395a89b6 100644
--- a/Library/Homebrew/test/os/mac/dependency_collector_spec.rb
+++ b/Library/Homebrew/test/os/mac/dependency_collector_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "dependency_collector"
 
-describe DependencyCollector do
+RSpec.describe DependencyCollector do
   alias_matcher :need_tar_xz_dependency, :be_tar_needs_xz_dependency
 
   subject(:collector) { described_class.new }
@@ -35,6 +34,6 @@
   specify "Resource dependency from a Subversion URL" do
     resource = Resource.new
     resource.url("svn://brew.sh/foo/bar")
-    expect(collector.add(resource)).to eq(Dependency.new("subversion", [:build, :test]))
+    expect(collector.add(resource)).to eq(Dependency.new("subversion", [:build, :test, :implicit]))
   end
 end
diff --git a/Library/Homebrew/test/os/mac/diagnostic_spec.rb b/Library/Homebrew/test/os/mac/diagnostic_spec.rb
index b51ac02193407..c75a2da2a4ef0 100644
--- a/Library/Homebrew/test/os/mac/diagnostic_spec.rb
+++ b/Library/Homebrew/test/os/mac/diagnostic_spec.rb
@@ -1,48 +1,32 @@
-# typed: false
 # frozen_string_literal: true
 
 require "diagnostic"
 
-describe Homebrew::Diagnostic::Checks do
+RSpec.describe Homebrew::Diagnostic::Checks do
   subject(:checks) { described_class.new }
 
   specify "#check_for_unsupported_macos" do
     ENV.delete("HOMEBREW_DEVELOPER")
 
-    macos_version = OS::Mac::Version.new("10.14")
-    allow(OS::Mac).to receive(:version).and_return(macos_version)
-    allow(OS::Mac).to receive(:full_version).and_return(macos_version)
-    allow(OS::Mac.version).to receive(:outdated_release?).and_return(false)
-    allow(OS::Mac.version).to receive(:prerelease?).and_return(true)
+    macos_version = MacOSVersion.new("10.14")
+    allow(OS::Mac).to receive_messages(version: macos_version, full_version: macos_version)
+    allow(OS::Mac.version).to receive_messages(outdated_release?: false, prerelease?: true)
 
     expect(checks.check_for_unsupported_macos)
       .to match("We do not provide support for this pre-release version.")
   end
 
   specify "#check_if_xcode_needs_clt_installed" do
-    macos_version = OS::Mac::Version.new("10.11")
-    allow(OS::Mac).to receive(:version).and_return(macos_version)
-    allow(OS::Mac).to receive(:full_version).and_return(macos_version)
-    allow(OS::Mac::Xcode).to receive(:installed?).and_return(true)
-    allow(OS::Mac::Xcode).to receive(:version).and_return("8.0")
-    allow(OS::Mac::Xcode).to receive(:without_clt?).and_return(true)
+    macos_version = MacOSVersion.new("10.11")
+    allow(OS::Mac).to receive_messages(version: macos_version, full_version: macos_version)
+    allow(OS::Mac::Xcode).to receive_messages(installed?: true, version: "8.0", without_clt?: true)
 
     expect(checks.check_if_xcode_needs_clt_installed)
       .to match("Xcode alone is not sufficient on El Capitan")
   end
 
-  specify "#check_ruby_version" do
-    macos_version = OS::Mac::Version.new("10.12")
-    allow(OS::Mac).to receive(:version).and_return(macos_version)
-    allow(OS::Mac).to receive(:full_version).and_return(macos_version)
-    stub_const("RUBY_VERSION", "1.8.6")
-
-    expect(checks.check_ruby_version)
-      .to match "Ruby version 1.8.6 is unsupported on macOS 10.12"
-  end
-
   describe "#check_if_supported_sdk_available" do
-    let(:macos_version) { OS::Mac::Version.new("11") }
+    let(:macos_version) { MacOSVersion.new("11") }
 
     before do
       allow(DevelopmentTools).to receive(:installed?).and_return(true)
@@ -52,32 +36,29 @@
     end
 
     it "doesn't trigger when SDK root is not needed" do
-      allow(OS::Mac).to receive(:sdk_root_needed?).and_return(false)
-      allow(OS::Mac).to receive(:sdk).and_return(nil)
+      allow(OS::Mac).to receive_messages(sdk_root_needed?: false, sdk: nil)
 
       expect(checks.check_if_supported_sdk_available).to be_nil
     end
 
     it "doesn't trigger when a valid SDK is present" do
-      allow(OS::Mac).to receive(:sdk_root_needed?).and_return(true)
-      allow(OS::Mac).to receive(:sdk).and_return(OS::Mac::SDK.new(macos_version, "/some/path/MacOSX.sdk", :clt))
+      allow(OS::Mac).to receive_messages(sdk_root_needed?: true,
+                                         sdk:              OS::Mac::SDK.new(
+                                           macos_version, "/some/path/MacOSX.sdk", :clt
+                                         ))
 
       expect(checks.check_if_supported_sdk_available).to be_nil
     end
 
     it "triggers when a valid SDK is not present on CLT systems" do
-      allow(OS::Mac).to receive(:sdk_root_needed?).and_return(true)
-      allow(OS::Mac).to receive(:sdk).and_return(nil)
-      allow(OS::Mac).to receive(:sdk_locator).and_return(OS::Mac::CLT.sdk_locator)
+      allow(OS::Mac).to receive_messages(sdk_root_needed?: true, sdk: nil, sdk_locator: OS::Mac::CLT.sdk_locator)
 
       expect(checks.check_if_supported_sdk_available)
         .to include("Your Command Line Tools (CLT) does not support macOS #{macos_version}")
     end
 
     it "triggers when a valid SDK is not present on Xcode systems" do
-      allow(OS::Mac).to receive(:sdk_root_needed?).and_return(true)
-      allow(OS::Mac).to receive(:sdk).and_return(nil)
-      allow(OS::Mac).to receive(:sdk_locator).and_return(OS::Mac::Xcode.sdk_locator)
+      allow(OS::Mac).to receive_messages(sdk_root_needed?: true, sdk: nil, sdk_locator: OS::Mac::Xcode.sdk_locator)
 
       expect(checks.check_if_supported_sdk_available)
         .to include("Your Xcode does not support macOS #{macos_version}")
@@ -88,8 +69,8 @@
     it "doesn't trigger when SDK versions are as expected" do
       allow(OS::Mac).to receive(:sdk_locator).and_return(OS::Mac::CLT.sdk_locator)
       allow_any_instance_of(OS::Mac::CLTSDKLocator).to receive(:all_sdks).and_return([
-        OS::Mac::SDK.new(OS::Mac::Version.new("11"), "/some/path/MacOSX.sdk", :clt),
-        OS::Mac::SDK.new(OS::Mac::Version.new("10.15"), "/some/path/MacOSX10.15.sdk", :clt),
+        OS::Mac::SDK.new(MacOSVersion.new("11"), "/some/path/MacOSX.sdk", :clt),
+        OS::Mac::SDK.new(MacOSVersion.new("10.15"), "/some/path/MacOSX10.15.sdk", :clt),
       ])
 
       expect(checks.check_broken_sdks).to be_nil
@@ -97,7 +78,7 @@
 
     it "triggers when the CLT SDK version doesn't match the folder name" do
       allow_any_instance_of(OS::Mac::CLTSDKLocator).to receive(:all_sdks).and_return([
-        OS::Mac::SDK.new(OS::Mac::Version.new("10.14"), "/some/path/MacOSX10.15.sdk", :clt),
+        OS::Mac::SDK.new(MacOSVersion.new("10.14"), "/some/path/MacOSX10.15.sdk", :clt),
       ])
 
       expect(checks.check_broken_sdks)
@@ -107,7 +88,7 @@
     it "triggers when the Xcode SDK version doesn't match the folder name" do
       allow(OS::Mac).to receive(:sdk_locator).and_return(OS::Mac::Xcode.sdk_locator)
       allow_any_instance_of(OS::Mac::XcodeSDKLocator).to receive(:all_sdks).and_return([
-        OS::Mac::SDK.new(OS::Mac::Version.new("10.14"), "/some/path/MacOSX10.15.sdk", :xcode),
+        OS::Mac::SDK.new(MacOSVersion.new("10.14"), "/some/path/MacOSX10.15.sdk", :xcode),
       ])
 
       expect(checks.check_broken_sdks)
diff --git a/Library/Homebrew/test/os/mac/formula_installer_spec.rb b/Library/Homebrew/test/os/mac/formula_installer_spec.rb
new file mode 100644
index 0000000000000..21b83da6c361d
--- /dev/null
+++ b/Library/Homebrew/test/os/mac/formula_installer_spec.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "formula_installer"
+require "test/support/fixtures/testball"
+
+RSpec.describe FormulaInstaller do
+  include FileUtils
+
+  subject(:keg) { described_class.new(keg_path) }
+
+  describe "#fresh_install" do
+    subject(:formula_installer) { described_class.new(Testball.new) }
+
+    it "is true by default" do
+      formula = Testball.new
+      expect(formula_installer.fresh_install?(formula)).to be true
+    end
+
+    it "is false in developer mode" do
+      formula = Testball.new
+      allow(Homebrew::EnvConfig).to receive_messages(developer?: true)
+      expect(formula_installer.fresh_install?(formula)).to be false
+    end
+
+    it "is false on outdated releases" do
+      formula = Testball.new
+      allow(OS::Mac.version).to receive_messages(outdated_release?: true)
+      expect(formula_installer.fresh_install?(formula)).to be false
+    end
+  end
+end
diff --git a/Library/Homebrew/test/os/mac/formula_spec.rb b/Library/Homebrew/test/os/mac/formula_spec.rb
index 9cb46854938c5..0a242912be347 100644
--- a/Library/Homebrew/test/os/mac/formula_spec.rb
+++ b/Library/Homebrew/test/os/mac/formula_spec.rb
@@ -1,14 +1,13 @@
-# typed: false
 # frozen_string_literal: true
 
 require "test/support/fixtures/testball"
 require "formula"
 
-describe Formula do
+RSpec.describe Formula do
   describe "#uses_from_macos" do
     before do
       allow(OS).to receive(:mac?).and_return(true)
-      allow(OS::Mac).to receive(:version).and_return(OS::Mac::Version.from_symbol(:sierra))
+      allow(OS::Mac).to receive(:version).and_return(MacOSVersion.from_symbol(:sierra))
     end
 
     it "adds a macOS dependency to all specs if the OS version meets requirements" do
@@ -20,21 +19,25 @@
 
       expect(f.class.stable.deps).to be_empty
       expect(f.class.head.deps).to be_empty
-      expect(f.class.stable.uses_from_macos_elements.first).to eq("foo")
-      expect(f.class.head.uses_from_macos_elements.first).to eq("foo")
+      expect(f.class.stable.declared_deps).not_to be_empty
+      expect(f.class.head.declared_deps).not_to be_empty
+      expect(f.class.stable.declared_deps.first.name).to eq("foo")
+      expect(f.class.head.declared_deps.first.name).to eq("foo")
     end
 
-    it "doesn't add a macOS dependency to any spec if the OS version doesn't meet requirements" do
+    it "adds a dependency to any spec if the OS version doesn't meet requirements" do
       f = formula "foo" do
         url "foo-1.0"
 
         uses_from_macos("foo", since: :high_sierra)
       end
 
+      expect(f.class.stable.deps).not_to be_empty
+      expect(f.class.head.deps).not_to be_empty
       expect(f.class.stable.deps.first.name).to eq("foo")
       expect(f.class.head.deps.first.name).to eq("foo")
-      expect(f.class.stable.uses_from_macos_elements).to eq(["foo"])
-      expect(f.class.head.uses_from_macos_elements).to eq(["foo"])
+      expect(f.class.stable.declared_deps).not_to be_empty
+      expect(f.class.head.declared_deps).not_to be_empty
     end
   end
 
diff --git a/Library/Homebrew/test/os/mac/keg_spec.rb b/Library/Homebrew/test/os/mac/keg_spec.rb
index 267d5101357d6..b87beb5d4a0c6 100644
--- a/Library/Homebrew/test/os/mac/keg_spec.rb
+++ b/Library/Homebrew/test/os/mac/keg_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "keg"
 
-describe Keg do
+RSpec.describe Keg do
   include FileUtils
 
   subject(:keg) { described_class.new(keg_path) }
diff --git a/Library/Homebrew/test/os/mac/mach_spec.rb b/Library/Homebrew/test/os/mac/mach_spec.rb
index a5c35eef733d6..28d4f1f8824c0 100644
--- a/Library/Homebrew/test/os/mac/mach_spec.rb
+++ b/Library/Homebrew/test/os/mac/mach_spec.rb
@@ -1,7 +1,6 @@
-# typed: false
 # frozen_string_literal: true
 
-describe "Mach-O" do
+RSpec.describe MachOShim do
   describe "Pathname tests" do
     specify "fat dylib" do
       pn = dylib_path("fat")
diff --git a/Library/Homebrew/test/os/mac/pkgconfig_spec.rb b/Library/Homebrew/test/os/mac/pkgconfig_spec.rb
index 4539b60916e09..2c42559bd6c2c 100644
--- a/Library/Homebrew/test/os/mac/pkgconfig_spec.rb
+++ b/Library/Homebrew/test/os/mac/pkgconfig_spec.rb
@@ -1,4 +1,3 @@
-# typed: false
 # frozen_string_literal: true
 
 # These tests assume the needed SDKs are correctly installed, i.e. `brew doctor` passes.
@@ -13,7 +12,7 @@
 # Additionally, libffi version detection cannot be performed on systems running Mojave or earlier.
 #
 # For indeterminable cases, consult https://opensource.apple.com for the version used.
-describe "pkg-config" do
+RSpec.describe "pkg-config", :needs_ci, type: :system do
   def pc_version(library)
     path = HOMEBREW_LIBRARY_PATH/"os/mac/pkgconfig/#{MacOS.version}/#{library}.pc"
     version = File.foreach(path)
@@ -33,6 +32,15 @@ def pc_version(library)
 
   let(:sdk) { MacOS.sdk_path_if_needed }
 
+  it "returns the correct version for bzip2" do
+    version = File.foreach("#{sdk}/usr/include/bzlib.h")
+                  .lazy
+                  .grep(%r{^\s*bzip2/libbzip2 version (\S+) of }) { Regexp.last_match(1) }
+                  .first
+
+    expect(pc_version("bzip2")).to eq(version)
+  end
+
   it "returns the correct version for expat" do
     version = File.foreach("#{sdk}/usr/include/expat.h")
                   .lazy
diff --git a/Library/Homebrew/test/os/mac/sdk_spec.rb b/Library/Homebrew/test/os/mac/sdk_spec.rb
index 55c18aa2217b1..cc039aa729c9b 100644
--- a/Library/Homebrew/test/os/mac/sdk_spec.rb
+++ b/Library/Homebrew/test/os/mac/sdk_spec.rb
@@ -1,18 +1,17 @@
-# typed: false
 # frozen_string_literal: true
 
-describe OS::Mac::CLTSDKLocator do
+RSpec.describe OS::Mac::CLTSDKLocator do
   subject(:locator) { described_class.new }
 
-  let(:big_sur_sdk) { OS::Mac::SDK.new(OS::Mac::Version.new("11"), "/some/path/MacOSX.sdk", :clt) }
-  let(:catalina_sdk) { OS::Mac::SDK.new(OS::Mac::Version.new("10.15"), "/some/path/MacOSX10.15.sdk", :clt) }
+  let(:big_sur_sdk) { OS::Mac::SDK.new(MacOSVersion.new("11"), "/some/path/MacOSX.sdk", :clt) }
+  let(:catalina_sdk) { OS::Mac::SDK.new(MacOSVersion.new("10.15"), "/some/path/MacOSX10.15.sdk", :clt) }
 
   specify "#sdk_for" do
     allow(locator).to receive(:all_sdks).and_return([big_sur_sdk, catalina_sdk])
 
-    expect(locator.sdk_for(OS::Mac::Version.new("11"))).to eq(big_sur_sdk)
-    expect(locator.sdk_for(OS::Mac::Version.new("10.15"))).to eq(catalina_sdk)
-    expect { locator.sdk_for(OS::Mac::Version.new("10.14")) }.to raise_error(described_class::NoSDKError)
+    expect(locator.sdk_for(MacOSVersion.new("11"))).to eq(big_sur_sdk)
+    expect(locator.sdk_for(MacOSVersion.new("10.15"))).to eq(catalina_sdk)
+    expect { locator.sdk_for(MacOSVersion.new("10.14")) }.to raise_error(described_class::NoSDKError)
   end
 
   describe "#sdk_if_applicable" do
@@ -21,27 +20,27 @@
     end
 
     it "returns the requested SDK" do
-      expect(locator.sdk_if_applicable(OS::Mac::Version.new("11"))).to eq(big_sur_sdk)
-      expect(locator.sdk_if_applicable(OS::Mac::Version.new("10.15"))).to eq(catalina_sdk)
+      expect(locator.sdk_if_applicable(MacOSVersion.new("11"))).to eq(big_sur_sdk)
+      expect(locator.sdk_if_applicable(MacOSVersion.new("10.15"))).to eq(catalina_sdk)
     end
 
     it "returns the latest SDK if the requested version is not found" do
-      expect(locator.sdk_if_applicable(OS::Mac::Version.new("10.14"))).to eq(big_sur_sdk)
-      expect(locator.sdk_if_applicable(OS::Mac::Version.new("12"))).to eq(big_sur_sdk)
+      expect(locator.sdk_if_applicable(MacOSVersion.new("10.14"))).to eq(big_sur_sdk)
+      expect(locator.sdk_if_applicable(MacOSVersion.new("12"))).to eq(big_sur_sdk)
     end
 
     it "returns the SDK matching the OS version if no version is specified" do
-      allow(OS::Mac).to receive(:version).and_return(OS::Mac::Version.new("10.15"))
+      allow(OS::Mac).to receive(:version).and_return(MacOSVersion.new("10.15"))
       expect(locator.sdk_if_applicable).to eq(catalina_sdk)
     end
 
     it "returns the latest SDK on older OS versions when there's no matching SDK" do
-      allow(OS::Mac).to receive(:version).and_return(OS::Mac::Version.new("10.14"))
+      allow(OS::Mac).to receive(:version).and_return(MacOSVersion.new("10.14"))
       expect(locator.sdk_if_applicable).to eq(big_sur_sdk)
     end
 
     it "returns nil if the OS is newer than all SDKs" do
-      allow(OS::Mac).to receive(:version).and_return(OS::Mac::Version.new("12"))
+      allow(OS::Mac).to receive(:version).and_return(MacOSVersion.new("12"))
       expect(locator.sdk_if_applicable).to be_nil
     end
   end
@@ -60,7 +59,7 @@
 
       sdk = sdks.first
       expect(sdk.path).to eq(big_sur_sdk_prefix/"MacOSX.sdk")
-      expect(sdk.version).to eq(OS::Mac::Version.new("11"))
+      expect(sdk.version).to eq(MacOSVersion.new("11"))
       expect(sdk.source).to eq(:clt)
     end
 
@@ -72,7 +71,7 @@
 
       sdk = sdks.first
       expect(sdk.path).to eq(mojave_broken_sdk_prefix/"MacOSX10.14.sdk")
-      expect(sdk.version).to eq(OS::Mac::Version.new("10.15"))
+      expect(sdk.version).to eq(MacOSVersion.new("10.15"))
       expect(sdk.source).to eq(:clt)
     end
 
@@ -84,7 +83,7 @@
 
       sdk = sdks.first
       expect(sdk.path).to eq(high_sierra_sdk_prefix/"MacOSX10.13.sdk")
-      expect(sdk.version).to eq(OS::Mac::Version.new("10.13"))
+      expect(sdk.version).to eq(MacOSVersion.new("10.13"))
       expect(sdk.source).to eq(:clt)
     end
 
diff --git a/Library/Homebrew/test/os/mac/software_spec_spec.rb b/Library/Homebrew/test/os/mac/software_spec_spec.rb
deleted file mode 100644
index c6a72db7350b2..0000000000000
--- a/Library/Homebrew/test/os/mac/software_spec_spec.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "software_spec"
-
-describe SoftwareSpec do
-  subject(:spec) { described_class.new }
-
-  describe "#uses_from_macos" do
-    before do
-      allow(OS).to receive(:mac?).and_return(true)
-      allow(OS::Mac).to receive(:version).and_return(OS::Mac::Version.from_symbol(:sierra))
-    end
-
-    it "adds a macOS dependency if the OS version meets requirements" do
-      spec.uses_from_macos("foo", since: :el_capitan)
-
-      expect(spec.deps).to be_empty
-      expect(spec.uses_from_macos_elements.first).to eq("foo")
-    end
-
-    it "doesn't add a macOS dependency if the OS version doesn't meet requirements" do
-      spec.uses_from_macos("foo", since: :high_sierra)
-
-      expect(spec.deps.first.name).to eq("foo")
-      expect(spec.uses_from_macos_elements).to eq(["foo"])
-    end
-
-    it "works with tags" do
-      spec.uses_from_macos("foo" => :build, :since => :high_sierra)
-
-      dep = spec.deps.first
-
-      expect(dep.name).to eq("foo")
-      expect(dep.tags).to include(:build)
-    end
-
-    it "doesn't add a dependency if no OS version is specified" do
-      spec.uses_from_macos("foo")
-      spec.uses_from_macos("bar" => :build)
-
-      expect(spec.deps).to be_empty
-    end
-
-    it "raises an error if passing invalid OS versions" do
-      expect {
-        spec.uses_from_macos("foo", since: :bar)
-      }.to raise_error(MacOSVersionError, "unknown or unsupported macOS version: :bar")
-    end
-  end
-end
diff --git a/Library/Homebrew/test/os/mac/version_spec.rb b/Library/Homebrew/test/os/mac/version_spec.rb
deleted file mode 100644
index da59eda161ac1..0000000000000
--- a/Library/Homebrew/test/os/mac/version_spec.rb
+++ /dev/null
@@ -1,95 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "version"
-require "os/mac/version"
-
-describe OS::Mac::Version do
-  let(:version) { described_class.new("10.14") }
-  let(:big_sur_major) { described_class.new("11.0") }
-  let(:big_sur_update) { described_class.new("11.1") }
-
-  specify "comparison with Symbol" do
-    expect(version).to be > :high_sierra
-    expect(version).to be == :mojave
-    expect(version).to be === :mojave # rubocop:disable Style/CaseEquality
-    expect(version).to be < :catalina
-  end
-
-  specify "comparison with Fixnum" do
-    expect(version).to be > 10
-    expect(version).to be < 11
-  end
-
-  specify "comparison with Float" do
-    expect(version).to be > 10.13
-    expect(version).to be < 10.15
-  end
-
-  specify "comparison with String" do
-    expect(version).to be > "10.3"
-    expect(version).to be == "10.14"
-    expect(version).to be === "10.14" # rubocop:disable Style/CaseEquality
-    expect(version).to be < "10.15"
-  end
-
-  specify "comparison with Version" do
-    expect(version).to be > Version.create("10.3")
-    expect(version).to be == Version.create("10.14")
-    expect(version).to be === Version.create("10.14") # rubocop:disable Style/CaseEquality
-    expect(version).to be < Version.create("10.15")
-  end
-
-  describe "after Big Sur" do
-    specify "comparison with :big_sur" do
-      expect(big_sur_major).to eq :big_sur
-      expect(big_sur_major).to be <= :big_sur
-      expect(big_sur_major).to be >= :big_sur
-      expect(big_sur_major).not_to be > :big_sur
-      expect(big_sur_major).not_to be < :big_sur
-
-      expect(big_sur_update).to eq :big_sur
-      expect(big_sur_update).to be <= :big_sur
-      expect(big_sur_update).to be >= :big_sur
-      expect(big_sur_update).not_to be > :big_sur
-      expect(big_sur_update).not_to be < :big_sur
-    end
-  end
-
-  describe "#new" do
-    it "raises an error if the version is not a valid macOS version" do
-      expect {
-        described_class.new("1.2")
-      }.to raise_error(MacOSVersionError, 'unknown or unsupported macOS version: "1.2"')
-    end
-
-    it "creates a new version from a valid macOS version" do
-      string_version = described_class.new("11")
-      expect(string_version).to eq(:big_sur)
-    end
-  end
-
-  describe "#from_symbol" do
-    it "raises an error if the symbol is not a valid macOS version" do
-      expect {
-        described_class.from_symbol(:foo)
-      }.to raise_error(MacOSVersionError, "unknown or unsupported macOS version: :foo")
-    end
-
-    it "creates a new version from a valid macOS version" do
-      symbol_version = described_class.from_symbol(:mojave)
-      expect(symbol_version).to eq(version)
-    end
-  end
-
-  specify "#pretty_name" do
-    expect(described_class.new("10.11").pretty_name).to eq("El Capitan")
-    expect(described_class.new("10.14").pretty_name).to eq("Mojave")
-  end
-
-  specify "#requires_nehalem_cpu?" do
-    expect(Hardware::CPU).to receive(:type).at_least(:twice).and_return(:intel)
-    expect(described_class.new("10.14").requires_nehalem_cpu?).to be true
-    expect(described_class.new("10.12").requires_nehalem_cpu?).to be false
-  end
-end
diff --git a/Library/Homebrew/test/os/mac_spec.rb b/Library/Homebrew/test/os/mac_spec.rb
index 1379cc39933ee..e2bc5eab37eb6 100644
--- a/Library/Homebrew/test/os/mac_spec.rb
+++ b/Library/Homebrew/test/os/mac_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "locale"
 require "os/mac"
 
-describe OS::Mac do
+RSpec.describe OS::Mac do
   describe "::languages" do
     it "returns a list of all languages" do
       expect(described_class.languages).not_to be_empty
@@ -27,34 +26,28 @@
 
     it "does not call sdk_path on Xcode-and-CLT systems with system headers" do
       allow(OS::Mac::Xcode).to receive(:installed?).and_return(true)
-      allow(OS::Mac::CLT).to receive(:installed?).and_return(true)
-      allow(OS::Mac::CLT).to receive(:separate_header_package?).and_return(false)
+      allow(OS::Mac::CLT).to receive_messages(installed?: true, separate_header_package?: false)
       expect(described_class).not_to receive(:sdk_path)
       described_class.sdk_path_if_needed
     end
 
     it "does not call sdk_path on CLT-only systems with no CLT SDK" do
       allow(OS::Mac::Xcode).to receive(:installed?).and_return(false)
-      allow(OS::Mac::CLT).to receive(:installed?).and_return(true)
-      allow(OS::Mac::CLT).to receive(:provides_sdk?).and_return(false)
+      allow(OS::Mac::CLT).to receive_messages(installed?: true, provides_sdk?: false)
       expect(described_class).not_to receive(:sdk_path)
       described_class.sdk_path_if_needed
     end
 
     it "does not call sdk_path on CLT-only systems with a CLT SDK if the system provides headers" do
       allow(OS::Mac::Xcode).to receive(:installed?).and_return(false)
-      allow(OS::Mac::CLT).to receive(:installed?).and_return(true)
-      allow(OS::Mac::CLT).to receive(:provides_sdk?).and_return(true)
-      allow(OS::Mac::CLT).to receive(:separate_header_package?).and_return(false)
+      allow(OS::Mac::CLT).to receive_messages(installed?: true, provides_sdk?: true, separate_header_package?: false)
       expect(described_class).not_to receive(:sdk_path)
       described_class.sdk_path_if_needed
     end
 
     it "calls sdk_path on CLT-only systems with a CLT SDK if the system does not provide headers" do
       allow(OS::Mac::Xcode).to receive(:installed?).and_return(false)
-      allow(OS::Mac::CLT).to receive(:installed?).and_return(true)
-      allow(OS::Mac::CLT).to receive(:provides_sdk?).and_return(true)
-      allow(OS::Mac::CLT).to receive(:separate_header_package?).and_return(true)
+      allow(OS::Mac::CLT).to receive_messages(installed?: true, provides_sdk?: true, separate_header_package?: true)
       expect(described_class).to receive(:sdk_path)
       described_class.sdk_path_if_needed
     end
diff --git a/Library/Homebrew/test/os/os_spec.rb b/Library/Homebrew/test/os/os_spec.rb
index 6d605258105f2..0dd0463bf7830 100644
--- a/Library/Homebrew/test/os/os_spec.rb
+++ b/Library/Homebrew/test/os/os_spec.rb
@@ -1,10 +1,19 @@
-# typed: false
 # frozen_string_literal: true
 
-describe OS do
-  describe ".kernel_version" do
-    it "is not empty" do
-      expect(described_class.kernel_version).not_to be_empty
+RSpec.describe OS do
+  describe "::kernel_version" do
+    it "is not NULL" do
+      expect(described_class.kernel_version).not_to be_null
+    end
+  end
+
+  describe "::kernel_name" do
+    it "returns Linux on Linux", :needs_linux do
+      expect(described_class.kernel_name).to eq "Linux"
+    end
+
+    it "returns Darwin on macOS", :needs_macos do
+      expect(described_class.kernel_name).to eq "Darwin"
     end
   end
 end
diff --git a/Library/Homebrew/test/patch_spec.rb b/Library/Homebrew/test/patch_spec.rb
index f39f22553ac4a..c546f520a1e80 100644
--- a/Library/Homebrew/test/patch_spec.rb
+++ b/Library/Homebrew/test/patch_spec.rb
@@ -1,54 +1,53 @@
-# typed: false
 # frozen_string_literal: true
 
 require "patch"
 
-describe Patch do
+RSpec.describe Patch do
   describe "#create" do
     context "with a simple patch" do
-      subject { described_class.create(:p2, nil) }
+      subject(:patch) { described_class.create(:p2, nil) }
 
-      it { is_expected.to be_kind_of ExternalPatch }
+      it { is_expected.to be_a ExternalPatch }
       it { is_expected.to be_external }
-      its(:strip) { is_expected.to eq(:p2) }
+      it(:strip) { expect(patch.strip).to eq(:p2) }
     end
 
     context "with a string patch" do
-      subject { described_class.create(:p0, "foo") }
+      subject(:patch) { described_class.create(:p0, "foo") }
 
-      it { is_expected.to be_kind_of StringPatch }
-      its(:strip) { is_expected.to eq(:p0) }
+      it { is_expected.to be_a StringPatch }
+      it(:strip) { expect(patch.strip).to eq(:p0) }
     end
 
     context "with a string patch without strip" do
-      subject { described_class.create("foo", nil) }
+      subject(:patch) { described_class.create("foo", nil) }
 
-      it { is_expected.to be_kind_of StringPatch }
-      its(:strip) { is_expected.to eq(:p1) }
+      it { is_expected.to be_a StringPatch }
+      it(:strip) { expect(patch.strip).to eq(:p1) }
     end
 
     context "with a data patch" do
-      subject { described_class.create(:p0, :DATA) }
+      subject(:patch) { described_class.create(:p0, :DATA) }
 
-      it { is_expected.to be_kind_of DATAPatch }
-      its(:strip) { is_expected.to eq(:p0) }
+      it { is_expected.to be_a DATAPatch }
+      it(:strip) { expect(patch.strip).to eq(:p0) }
     end
 
     context "with a data patch without strip" do
-      subject { described_class.create(:DATA, nil) }
+      subject(:patch) { described_class.create(:DATA, nil) }
 
-      it { is_expected.to be_kind_of DATAPatch }
-      its(:strip) { is_expected.to eq(:p1) }
+      it { is_expected.to be_a DATAPatch }
+      it(:strip) { expect(patch.strip).to eq(:p1) }
     end
 
     it "raises an error for unknown values" do
-      expect {
+      expect do
         described_class.create(Object.new)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
 
-      expect {
+      expect do
         described_class.create(Object.new, Object.new)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
   end
 
@@ -56,9 +55,9 @@
     subject(:patch) { described_class.create(:p2, nil) }
 
     context "when the patch is empty" do
-      its(:resource) { is_expected.to be_kind_of Resource::PatchResource }
-      its(:patch_files) { is_expected.to eq(patch.resource.patch_files) }
-      its(:patch_files) { is_expected.to eq([]) }
+      it(:resource) { expect(patch.resource).to be_a Resource::Patch }
+      it { expect(patch.patch_files).to eq(patch.resource.patch_files) }
+      it { expect(patch.patch_files).to eq([]) }
     end
 
     it "returns applied patch files" do
@@ -78,9 +77,9 @@
 
   describe EmbeddedPatch do
     describe "#new" do
-      subject { described_class.new(:p1) }
+      subject(:patch) { described_class.new(:p1) }
 
-      its(:inspect) { is_expected.to eq("#<EmbeddedPatch: :p1>") }
+      it(:inspect) { expect(patch.inspect).to eq("#<EmbeddedPatch: :p1>") }
     end
   end
 
@@ -88,11 +87,11 @@
     subject(:patch) { described_class.new(:p1) { url "file:///my.patch" } }
 
     describe "#url" do
-      its(:url) { is_expected.to eq("file:///my.patch") }
+      it(:url) { expect(patch.url).to eq("file:///my.patch") }
     end
 
     describe "#inspect" do
-      its(:inspect) { is_expected.to eq('#<ExternalPatch: :p1 "file:///my.patch">') }
+      it(:inspect) { expect(patch.inspect).to eq('#<ExternalPatch: :p1 "file:///my.patch">') }
     end
 
     describe "#cached_download" do
@@ -100,7 +99,7 @@
         allow(patch.resource).to receive(:cached_download).and_return("/tmp/foo.tar.gz")
       end
 
-      its(:cached_download) { is_expected.to eq("/tmp/foo.tar.gz") }
+      it(:cached_download) { expect(patch.cached_download).to eq("/tmp/foo.tar.gz") }
     end
   end
 end
diff --git a/Library/Homebrew/test/patching_spec.rb b/Library/Homebrew/test/patching_spec.rb
index 1259ac7c4a2b3..c4818cc250928 100644
--- a/Library/Homebrew/test/patching_spec.rb
+++ b/Library/Homebrew/test/patching_spec.rb
@@ -1,25 +1,33 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula"
 
-describe "patching" do
-  TESTBALL_URL = "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz"
-  TESTBALL_PATCHES_URL = "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1-patches.tgz"
-  PATCH_URL_A = "file://#{TEST_FIXTURE_DIR}/patches/noop-a.diff"
-  PATCH_URL_B = "file://#{TEST_FIXTURE_DIR}/patches/noop-b.diff"
-  PATCH_A_CONTENTS = File.read("#{TEST_FIXTURE_DIR}/patches/noop-a.diff").freeze
-  PATCH_B_CONTENTS = File.read("#{TEST_FIXTURE_DIR}/patches/noop-b.diff").freeze
-  APPLY_A = "noop-a.diff"
-  APPLY_B = "noop-b.diff"
-  APPLY_C = "noop-c.diff"
+RSpec.describe "patching", type: :system do
+  let(:formula_subclass) do
+    Class.new(Formula) do
+      # These are defined within an anonymous class to avoid polluting the global namespace.
+      # rubocop:disable RSpec/LeakyConstantDeclaration,Lint/ConstantDefinitionInBlock
+      TESTBALL_URL = "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz".freeze
+      TESTBALL_PATCHES_URL = "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1-patches.tgz".freeze
+      PATCH_URL_A = "file://#{TEST_FIXTURE_DIR}/patches/noop-a.diff".freeze
+      PATCH_URL_B = "file://#{TEST_FIXTURE_DIR}/patches/noop-b.diff".freeze
+      PATCH_URL_D = "file://#{TEST_FIXTURE_DIR}/patches/noop-d.diff".freeze
+      PATCH_A_CONTENTS = File.read("#{TEST_FIXTURE_DIR}/patches/noop-a.diff").freeze
+      PATCH_B_CONTENTS = File.read("#{TEST_FIXTURE_DIR}/patches/noop-b.diff").freeze
+      APPLY_A = "noop-a.diff"
+      APPLY_B = "noop-b.diff"
+      APPLY_C = "noop-c.diff"
+      APPLY_D = "noop-d.diff"
+      # rubocop:enable RSpec/LeakyConstantDeclaration,Lint/ConstantDefinitionInBlock
 
-  def formula(name = "formula_name", path: Formulary.core_path(name), spec: :stable, alias_path: nil, &block)
-    Class.new(Formula) {
       url TESTBALL_URL
       sha256 TESTBALL_SHA256
-      class_eval(&block)
-    }.new(name, path, spec, alias_path: alias_path)
+    end
+  end
+
+  def formula(name = "formula_name", path: Formulary.core_path(name), spec: :stable, alias_path: nil, &block)
+    formula_subclass.class_eval(&block)
+    formula_subclass.new(name, path, spec, alias_path:)
   end
 
   matcher :be_patched do
@@ -33,6 +41,18 @@ def formula(name = "formula_name", path: Formulary.core_path(name), spec: :stabl
     end
   end
 
+  matcher :be_patched_with_homebrew_prefix do
+    match do |formula|
+      formula.brew do
+        formula.patch
+        s = File.read("libexec/NOOP")
+        expect(s).not_to include("NOOP"), "libexec/NOOP was not patched as expected"
+        expect(s).not_to include("@@HOMEBREW_PREFIX@@"), "libexec/NOOP was not patched as expected"
+        expect(s).to include(HOMEBREW_PREFIX.to_s), "libexec/NOOP was not patched as expected"
+      end
+    end
+  end
+
   matcher :have_its_resource_patched do
     match do |formula|
       formula.brew do
@@ -58,11 +78,11 @@ def formula(name = "formula_name", path: Formulary.core_path(name), spec: :stabl
 
   matcher :miss_apply do
     match do |formula|
-      expect {
+      expect do
         formula.brew do
           formula.patch
         end
-      }.to raise_error(MissingApplyError)
+      end.to raise_error(MissingApplyError)
     end
   end
 
@@ -141,7 +161,7 @@ def formula(name = "formula_name", path: Formulary.core_path(name), spec: :stabl
   end
 
   specify "single_patch_dsl_with_incorrect_strip" do
-    expect {
+    expect do
       f = formula do
         patch :p0 do
           url PATCH_URL_A
@@ -150,11 +170,11 @@ def formula(name = "formula_name", path: Formulary.core_path(name), spec: :stabl
       end
 
       f.brew { |formula, _staging| formula.patch }
-    }.to raise_error(BuildError)
+    end.to raise_error(BuildError)
   end
 
   specify "single_patch_dsl_with_incorrect_strip_with_apply" do
-    expect {
+    expect do
       f = formula do
         patch :p0 do
           url TESTBALL_PATCHES_URL
@@ -164,7 +184,7 @@ def formula(name = "formula_name", path: Formulary.core_path(name), spec: :stabl
       end
 
       f.brew { |formula, _staging| formula.patch }
-    }.to raise_error(BuildError)
+    end.to raise_error(BuildError)
   end
 
   specify "patch_p0_dsl" do
@@ -210,7 +230,7 @@ def formula(name = "formula_name", path: Formulary.core_path(name), spec: :stabl
   end
 
   specify "single_patch_dsl_with_apply_enoent_fail" do
-    expect {
+    expect do
       f = formula do
         patch do
           url TESTBALL_PATCHES_URL
@@ -220,18 +240,17 @@ def formula(name = "formula_name", path: Formulary.core_path(name), spec: :stabl
       end
 
       f.brew { |formula, _staging| formula.patch }
-    }.to raise_error(BuildError)
+    end.to raise_error(Errno::ENOENT)
   end
-end
 
-__END__
-diff --git a/libexec/NOOP b/libexec/NOOP
-index bfdda4c..e08d8f4 100755
---- a/libexec/NOOP
-+++ b/libexec/NOOP
-@@ -1,2 +1,2 @@
- #!/bin/bash
--echo NOOP
-\ No newline at end of file
-+echo ABCD
-\ No newline at end of file
+  specify "patch_dsl_with_homebrew_prefix" do
+    expect(
+      formula do
+        patch do
+          url PATCH_URL_D
+          sha256 PATCH_D_SHA256
+        end
+      end,
+    ).to be_patched_with_homebrew_prefix
+  end
+end
diff --git a/Library/Homebrew/test/pathname_spec.rb b/Library/Homebrew/test/pathname_spec.rb
index 4e5e8d4faa9c3..b6e7b64b9fcc7 100644
--- a/Library/Homebrew/test/pathname_spec.rb
+++ b/Library/Homebrew/test/pathname_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "extend/pathname"
 require "install_renamed"
 
-describe Pathname do
+RSpec.describe Pathname do
   include FileUtils
 
   let(:src) { mktmpdir }
@@ -93,9 +92,11 @@
     end
 
     it "preserves permissions" do
-      File.open(file, "w", 0100777) {}
+      File.open(file, "w", 0100777) do
+        # do nothing
+      end
       file.atomic_write("CONTENT")
-      expect(file.stat.mode.to_s(8)).to eq((0100777 & ~File.umask).to_s(8))
+      expect(file.stat.mode.to_s(8)).to eq((~File.umask & 0100777).to_s(8))
     end
 
     it "preserves default permissions" do
diff --git a/Library/Homebrew/test/pkg_version_spec.rb b/Library/Homebrew/test/pkg_version_spec.rb
index 517580c800957..578ae2a14f5fc 100644
--- a/Library/Homebrew/test/pkg_version_spec.rb
+++ b/Library/Homebrew/test/pkg_version_spec.rb
@@ -1,22 +1,21 @@
-# typed: false
 # frozen_string_literal: true
 
 require "pkg_version"
 
-describe PkgVersion do
+RSpec.describe PkgVersion do
   describe "::parse" do
     it "parses versions from a string" do
-      expect(described_class.parse("1.0_1")).to eq(described_class.new(Version.create("1.0"), 1))
-      expect(described_class.parse("1.0_1")).to eq(described_class.new(Version.create("1.0"), 1))
-      expect(described_class.parse("1.0")).to eq(described_class.new(Version.create("1.0"), 0))
-      expect(described_class.parse("1.0_0")).to eq(described_class.new(Version.create("1.0"), 0))
-      expect(described_class.parse("2.1.4_0")).to eq(described_class.new(Version.create("2.1.4"), 0))
-      expect(described_class.parse("1.0.1e_1")).to eq(described_class.new(Version.create("1.0.1e"), 1))
+      expect(described_class.parse("1.0_1")).to eq(described_class.new(Version.new("1.0"), 1))
+      expect(described_class.parse("1.0_1")).to eq(described_class.new(Version.new("1.0"), 1))
+      expect(described_class.parse("1.0")).to eq(described_class.new(Version.new("1.0"), 0))
+      expect(described_class.parse("1.0_0")).to eq(described_class.new(Version.new("1.0"), 0))
+      expect(described_class.parse("2.1.4_0")).to eq(described_class.new(Version.new("2.1.4"), 0))
+      expect(described_class.parse("1.0.1e_1")).to eq(described_class.new(Version.new("1.0.1e"), 1))
     end
   end
 
   specify "#==" do
-    expect(described_class.parse("1.0_0")).to be == described_class.parse("1.0")
+    expect(described_class.parse("1.0_0")).to eq described_class.parse("1.0")
     version_to_compare = described_class.parse("1.0_1")
     expect(version_to_compare == described_class.parse("1.0_1")).to be true
     expect(version_to_compare == described_class.parse("1.0_2")).to be false
@@ -32,15 +31,15 @@
     end
 
     it "raises an error if the other side isn't of the same class" do
-      expect {
-        described_class.new(Version.create("1.0"), 0) > Object.new
-      }.to raise_error(ArgumentError)
+      expect do
+        described_class.new(Version.new("1.0"), 0) > Object.new
+      end.to raise_error(ArgumentError)
     end
 
     it "is not compatible with Version" do
-      expect {
-        described_class.new(Version.create("1.0"), 0) > Version.create("1.0")
-      }.to raise_error(ArgumentError)
+      expect do
+        described_class.new(Version.new("1.0"), 0) > Version.new("1.0")
+      end.to raise_error(ArgumentError)
     end
   end
 
@@ -56,78 +55,77 @@
 
   describe "#<=>" do
     it "returns nil if the comparison fails" do
-      expect(described_class.new(Version.create("1.0"), 0) <=> Object.new).to be_nil
-      expect(Object.new <=> described_class.new(Version.create("1.0"), 0)).to be_nil
-      expect(Object.new <=> described_class.new(Version.create("1.0"), 0)).to be_nil
-      expect(described_class.new(Version.create("1.0"), 0) <=> nil).to be_nil
+      expect(described_class.new(Version.new("1.0"), 0) <=> Object.new).to be_nil
+      expect(Object.new <=> described_class.new(Version.new("1.0"), 0)).to be_nil
+      expect(Object.new <=> described_class.new(Version.new("1.0"), 0)).to be_nil
+      expect(described_class.new(Version.new("1.0"), 0) <=> nil).to be_nil
       # This one used to fail due to dereferencing a null `self`
-      expect(described_class.new(nil, 0) <=> described_class.new(Version.create("1.0"), 0)).to be_nil
+      expect(described_class.new(nil, 0) <=> described_class.new(Version.new("1.0"), 0)).to be_nil
     end
   end
 
   describe "#to_s" do
     it "returns a string of the form 'version_revision'" do
-      expect(described_class.new(Version.create("1.0"), 0).to_s).to eq("1.0")
-      expect(described_class.new(Version.create("1.0"), 1).to_s).to eq("1.0_1")
-      expect(described_class.new(Version.create("1.0"), 0).to_s).to eq("1.0")
-      expect(described_class.new(Version.create("1.0"), 0).to_s).to eq("1.0")
-      expect(described_class.new(Version.create("HEAD"), 1).to_s).to eq("HEAD_1")
-      expect(described_class.new(Version.create("HEAD-ffffff"), 1).to_s).to eq("HEAD-ffffff_1")
+      expect(described_class.new(Version.new("1.0"), 0).to_s).to eq("1.0")
+      expect(described_class.new(Version.new("1.0"), 1).to_s).to eq("1.0_1")
+      expect(described_class.new(Version.new("1.0"), 0).to_s).to eq("1.0")
+      expect(described_class.new(Version.new("1.0"), 0).to_s).to eq("1.0")
+      expect(described_class.new(Version.new("HEAD"), 1).to_s).to eq("HEAD_1")
+      expect(described_class.new(Version.new("HEAD-ffffff"), 1).to_s).to eq("HEAD-ffffff_1")
     end
   end
 
   describe "#hash" do
-    let(:p1) { described_class.new(Version.create("1.0"), 1) }
-    let(:p2) { described_class.new(Version.create("1.0"), 1) }
-    let(:p3) { described_class.new(Version.create("1.1"), 1) }
-    let(:p4) { described_class.new(Version.create("1.0"), 0) }
+    let(:version_one_revision_one) { described_class.new(Version.new("1.0"), 1) }
+    let(:version_one_dot_one_revision_one) { described_class.new(Version.new("1.1"), 1) }
+    let(:version_one_revision_zero) { described_class.new(Version.new("1.0"), 0) }
 
     it "returns a hash based on the version and revision" do
-      expect(p1.hash).to eq(p2.hash)
-      expect(p1.hash).not_to eq(p3.hash)
-      expect(p1.hash).not_to eq(p4.hash)
+      expect(version_one_revision_one.hash).to eq(described_class.new(Version.new("1.0"), 1).hash)
+      expect(version_one_revision_one.hash).not_to eq(version_one_dot_one_revision_one.hash)
+      expect(version_one_revision_one.hash).not_to eq(version_one_revision_zero.hash)
     end
   end
 
   describe "#version" do
     it "returns package version" do
-      expect(described_class.parse("1.2.3_4").version).to be == Version.create("1.2.3")
+      expect(described_class.parse("1.2.3_4").version).to eq Version.new("1.2.3")
     end
   end
 
   describe "#revision" do
     it "returns package revision" do
-      expect(described_class.parse("1.2.3_4").revision).to be == 4
+      expect(described_class.parse("1.2.3_4").revision).to eq 4
     end
   end
 
   describe "#major" do
     it "returns major version token" do
-      expect(described_class.parse("1.2.3_4").major).to be == Version::Token.create("1")
+      expect(described_class.parse("1.2.3_4").major).to eq Version::Token.create("1")
     end
   end
 
   describe "#minor" do
     it "returns minor version token" do
-      expect(described_class.parse("1.2.3_4").minor).to be == Version::Token.create("2")
+      expect(described_class.parse("1.2.3_4").minor).to eq Version::Token.create("2")
     end
   end
 
   describe "#patch" do
     it "returns patch version token" do
-      expect(described_class.parse("1.2.3_4").patch).to be == Version::Token.create("3")
+      expect(described_class.parse("1.2.3_4").patch).to eq Version::Token.create("3")
     end
   end
 
   describe "#major_minor" do
     it "returns major.minor version" do
-      expect(described_class.parse("1.2.3_4").major_minor).to be == Version.create("1.2")
+      expect(described_class.parse("1.2.3_4").major_minor).to eq Version.new("1.2")
     end
   end
 
   describe "#major_minor_patch" do
     it "returns major.minor.patch version" do
-      expect(described_class.parse("1.2.3_4").major_minor_patch).to be == Version.create("1.2.3")
+      expect(described_class.parse("1.2.3_4").major_minor_patch).to eq Version.new("1.2.3")
     end
   end
 end
diff --git a/Library/Homebrew/test/requirement_spec.rb b/Library/Homebrew/test/requirement_spec.rb
index 0cd1c0db19d55..7789e2f5091f1 100644
--- a/Library/Homebrew/test/requirement_spec.rb
+++ b/Library/Homebrew/test/requirement_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "extend/ENV"
 require "requirement"
 
-describe Requirement do
+RSpec.describe Requirement do
   alias_matcher :be_a_build_requirement, :be_a_build
 
   subject(:requirement) { klass.new }
@@ -12,30 +11,30 @@
   let(:klass) { Class.new(described_class) }
 
   describe "#tags" do
-    subject { described_class.new(tags) }
+    subject(:req) { klass.new(tags) }
 
     context "with a single tag" do
       let(:tags) { ["bar"] }
 
-      its(:tags) { are_expected.to eq(tags) }
+      it(:tags) { expect(req.tags).to eq(tags) }
     end
 
     context "with multiple tags" do
       let(:tags) { ["bar", "baz"] }
 
-      its(:tags) { are_expected.to eq(tags) }
+      it(:tags) { expect(req.tags).to eq(tags) }
     end
 
     context "with symbol tags" do
       let(:tags) { [:build] }
 
-      its(:tags) { are_expected.to eq(tags) }
+      it(:tags) { expect(req.tags).to eq(tags) }
     end
 
     context "with symbol and string tags" do
       let(:tags) { [:build, "bar"] }
 
-      its(:tags) { are_expected.to eq(tags) }
+      it(:tags) { expect(req.tags).to eq(tags) }
     end
   end
 
@@ -140,7 +139,9 @@
       end
 
       it "infers path from #satisfy result" do
-        expect(ENV).to receive(:prepend_path).with("PATH", Pathname.new("/foo/bar"))
+        without_partial_double_verification do
+          expect(ENV).to receive(:prepend_path).with("PATH", Pathname.new("/foo/bar"))
+        end
         requirement.satisfied?
         requirement.modify_build_environment
       end
@@ -149,7 +150,7 @@
 
   describe "#build?" do
     context "when the :build tag is specified" do
-      subject { described_class.new([:build]) }
+      subject { klass.new([:build]) }
 
       it { is_expected.to be_a_build_requirement }
     end
@@ -164,15 +165,11 @@
     let(:klass) { self.class.const_get(const) }
 
     before do
-      self.class.const_set(const, Class.new(described_class))
-    end
-
-    after do
-      self.class.send(:remove_const, const)
+      stub_const const.to_s, Class.new(described_class)
     end
 
-    its(:name) { is_expected.to eq("foo") }
-    its(:option_names) { are_expected.to eq(["foo"]) }
+    it(:name) { expect(requirement.name).to eq("foo") }
+    it(:option_names) { expect(requirement.option_names).to eq(["foo"]) }
   end
 
   describe "#modify_build_environment" do
@@ -180,30 +177,30 @@
       let(:klass) { Class.new(described_class) }
 
       it "returns nil" do
-        expect(requirement.modify_build_environment).to be_nil
+        expect { requirement.modify_build_environment }.not_to raise_error
       end
     end
   end
 
   describe "#eql? and #==" do
-    subject(:requirement) { described_class.new }
+    subject(:requirement) { klass.new }
 
     it "returns true if the names and tags are equal" do
-      other = described_class.new
+      other = klass.new
 
       expect(requirement).to eql(other)
       expect(requirement).to eq(other)
     end
 
     it "returns false if names differ" do
-      other = described_class.new
+      other = klass.new
       allow(other).to receive(:name).and_return("foo")
       expect(requirement).not_to eql(other)
       expect(requirement).not_to eq(other)
     end
 
     it "returns false if tags differ" do
-      other = described_class.new([:optional])
+      other = klass.new([:optional])
 
       expect(requirement).not_to eql(other)
       expect(requirement).not_to eq(other)
@@ -211,21 +208,21 @@
   end
 
   describe "#hash" do
-    subject(:requirement) { described_class.new }
+    subject(:requirement) { klass.new }
 
     it "is equal if names and tags are equal" do
-      other = described_class.new
+      other = klass.new
       expect(requirement.hash).to eq(other.hash)
     end
 
     it "differs if names differ" do
-      other = described_class.new
+      other = klass.new
       allow(other).to receive(:name).and_return("foo")
       expect(requirement.hash).not_to eq(other.hash)
     end
 
     it "differs if tags differ" do
-      other = described_class.new([:optional])
+      other = klass.new([:optional])
       expect(requirement.hash).not_to eq(other.hash)
     end
   end
diff --git a/Library/Homebrew/test/requirements/arch_requirement_spec.rb b/Library/Homebrew/test/requirements/arch_requirement_spec.rb
index 0eb369c07cc3c..bb0480a2a3292 100644
--- a/Library/Homebrew/test/requirements/arch_requirement_spec.rb
+++ b/Library/Homebrew/test/requirements/arch_requirement_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "requirements/arch_requirement"
 
-describe ArchRequirement do
+RSpec.describe ArchRequirement do
   subject(:requirement) { described_class.new([Hardware::CPU.type]) }
 
   describe "#satisfied?" do
diff --git a/Library/Homebrew/test/requirements/codesign_requirement_spec.rb b/Library/Homebrew/test/requirements/codesign_requirement_spec.rb
index 0f22b9f67a5a4..00f101310c3eb 100644
--- a/Library/Homebrew/test/requirements/codesign_requirement_spec.rb
+++ b/Library/Homebrew/test/requirements/codesign_requirement_spec.rb
@@ -1,18 +1,17 @@
-# typed: false
 # frozen_string_literal: true
 
 require "requirements/codesign_requirement"
 
-describe CodesignRequirement do
-  subject(:requirement) {
-    described_class.new([{ identity: identity, with: with, url: url }])
-  }
+RSpec.describe CodesignRequirement do
+  subject(:requirement) do
+    described_class.new([{ identity:, with:, url: }])
+  end
 
   let(:identity) { "lldb_codesign" }
   let(:with) { "LLDB" }
-  let(:url) {
+  let(:url) do
     "https://llvm.org/svn/llvm-project/lldb/trunk/docs/code-signing.txt"
-  }
+  end
 
   describe "#message" do
     it "includes all parameters" do
diff --git a/Library/Homebrew/test/requirements/linux_requirement_spec.rb b/Library/Homebrew/test/requirements/linux_requirement_spec.rb
index 9187f5b54297a..ce67fd6e57563 100644
--- a/Library/Homebrew/test/requirements/linux_requirement_spec.rb
+++ b/Library/Homebrew/test/requirements/linux_requirement_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "requirements/linux_requirement"
 
-describe LinuxRequirement do
+RSpec.describe LinuxRequirement do
   subject(:requirement) { described_class.new }
 
   describe "#satisfied?" do
diff --git a/Library/Homebrew/test/requirements/macos_requirement_spec.rb b/Library/Homebrew/test/requirements/macos_requirement_spec.rb
index 28e32b0d8c6cb..ad15adc0c5aad 100644
--- a/Library/Homebrew/test/requirements/macos_requirement_spec.rb
+++ b/Library/Homebrew/test/requirements/macos_requirement_spec.rb
@@ -1,11 +1,13 @@
-# typed: false
 # frozen_string_literal: true
 
 require "requirements/macos_requirement"
 
-describe MacOSRequirement do
+RSpec.describe MacOSRequirement do
   subject(:requirement) { described_class.new }
 
+  let(:macos_oldest_allowed) { MacOSVersion.new(HOMEBREW_MACOS_OLDEST_ALLOWED) }
+  let(:big_sur_major) { MacOSVersion.new("11.0") }
+
   describe "#satisfied?" do
     it "returns true on macOS" do
       expect(requirement.satisfied?).to eq OS.mac?
@@ -21,4 +23,30 @@
       expect(requirement.satisfied?).to eq MacOS.version <= :catalina
     end
   end
+
+  specify "#minimum_version" do
+    no_requirement = described_class.new
+    max_requirement = described_class.new([:big_sur], comparator: "<=")
+    min_requirement = described_class.new([:big_sur], comparator: ">=")
+    exact_requirement = described_class.new([:big_sur], comparator: "==")
+    range_requirement = described_class.new([[:monterey, :big_sur]], comparator: "==")
+    expect(no_requirement.minimum_version).to eq macos_oldest_allowed
+    expect(max_requirement.minimum_version).to eq macos_oldest_allowed
+    expect(min_requirement.minimum_version).to eq big_sur_major
+    expect(exact_requirement.minimum_version).to eq big_sur_major
+    expect(range_requirement.minimum_version).to eq big_sur_major
+  end
+
+  specify "#allows?" do
+    no_requirement = described_class.new
+    max_requirement = described_class.new([:mojave], comparator: "<=")
+    min_requirement = described_class.new([:catalina], comparator: ">=")
+    exact_requirement = described_class.new([:big_sur], comparator: "==")
+    range_requirement = described_class.new([[:monterey, :big_sur]], comparator: "==")
+    expect(no_requirement.allows?(big_sur_major)).to be true
+    expect(max_requirement.allows?(big_sur_major)).to be false
+    expect(min_requirement.allows?(big_sur_major)).to be true
+    expect(exact_requirement.allows?(big_sur_major)).to be true
+    expect(range_requirement.allows?(big_sur_major)).to be true
+  end
 end
diff --git a/Library/Homebrew/test/requirements_spec.rb b/Library/Homebrew/test/requirements_spec.rb
index a915c926cd501..f7c6eca53684b 100644
--- a/Library/Homebrew/test/requirements_spec.rb
+++ b/Library/Homebrew/test/requirements_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "requirements"
 
-describe Requirements do
+RSpec.describe Requirements do
   subject(:requirements) { described_class.new }
 
   describe "#<<" do
@@ -12,7 +11,8 @@
     end
 
     it "merges duplicate requirements" do
-      requirements << Requirement.new << Requirement.new
+      klass = Class.new(Requirement)
+      requirements << klass.new << klass.new
       expect(requirements.count).to eq(1)
     end
   end
diff --git a/Library/Homebrew/test/resource_spec.rb b/Library/Homebrew/test/resource_spec.rb
index 96541c31834a4..e509902bdee30 100644
--- a/Library/Homebrew/test/resource_spec.rb
+++ b/Library/Homebrew/test/resource_spec.rb
@@ -1,13 +1,12 @@
-# typed: false
 # frozen_string_literal: true
 
 require "resource"
 require "livecheck"
 
-describe Resource do
+RSpec.describe Resource do
   subject(:resource) { described_class.new("test") }
 
-  let(:livecheck_resource) {
+  let(:livecheck_resource) do
     described_class.new do
       url "https://brew.sh/foo-1.0.tar.gz"
       sha256 "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
@@ -17,7 +16,7 @@
         regex(/foo[._-]v?(\d+(?:\.\d+)+)\.t/i)
       end
     end
-  }
+  end
 
   describe "#url" do
     it "sets the URL" do
@@ -58,7 +57,7 @@
 
     it "does not mutate the specifications hash" do
       specs = { using: :git, branch: "master" }
-      resource.url("foo", specs)
+      resource.url("foo", **specs)
       expect(resource.specs).to eq(branch: "master")
       expect(resource.using).to eq(:git)
       expect(specs).to eq(using: :git, branch: "master")
@@ -66,10 +65,6 @@
   end
 
   describe "#livecheck" do
-    it "returns nil if livecheck block is not set in resource" do
-      expect(resource.livecheck).to be_nil
-    end
-
     specify "when livecheck block is set" do
       expect(livecheck_resource.livecheck.url).to eq("https://brew.sh/test/releases")
       expect(livecheck_resource.livecheck.regex).to eq(/foo[._-]v?(\d+(?:\.\d+)+)\.t/i)
@@ -148,7 +143,7 @@
 
   describe "#download_strategy" do
     it "returns the download strategy" do
-      strategy = Object.new
+      strategy = Class.new(AbstractDownloadStrategy)
       expect(DownloadStrategyDetector)
         .to receive(:detect).with("foo", nil).and_return(strategy)
       resource.url("foo")
@@ -192,14 +187,15 @@
   end
 
   specify "#verify_download_integrity_mismatch" do
-    fn = double(file?: true, basename: "foo")
+    fn = instance_double(Pathname, file?: true, basename: "foo")
     checksum = resource.sha256(TEST_SHA256)
 
-    expect(fn).to receive(:verify_checksum).with(checksum)
+    expect(fn).to receive(:verify_checksum)
+      .with(checksum)
       .and_raise(ChecksumMismatchError.new(fn, checksum, Object.new))
 
-    expect {
+    expect do
       resource.verify_download_integrity(fn)
-    }.to raise_error(ChecksumMismatchError)
+    end.to raise_error(ChecksumMismatchError)
   end
 end
diff --git a/Library/Homebrew/test/rubocop_spec.rb b/Library/Homebrew/test/rubocop_spec.rb
index 795d91a14a42a..7c49fc9df17c8 100644
--- a/Library/Homebrew/test/rubocop_spec.rb
+++ b/Library/Homebrew/test/rubocop_spec.rb
@@ -1,13 +1,16 @@
-# typed: false
 # frozen_string_literal: true
 
 require "open3"
 
-describe "RuboCop" do
+RSpec.describe "RuboCop" do
   context "when calling `rubocop` outside of the Homebrew environment" do
     before do
       ENV.each_key do |key|
-        ENV.delete(key) if key.start_with?("HOMEBREW_")
+        allowlist = %w[
+          HOMEBREW_TESTS
+          HOMEBREW_USE_RUBY_FROM_PATH
+        ]
+        ENV.delete(key) if key.start_with?("HOMEBREW_") && allowlist.exclude?(key)
       end
 
       ENV["XDG_CACHE_HOME"] = (HOMEBREW_CACHE.realpath/"style").to_s
diff --git a/Library/Homebrew/test/rubocops/blank_spec.rb b/Library/Homebrew/test/rubocops/blank_spec.rb
new file mode 100644
index 0000000000000..ee3fc32a080fd
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/blank_spec.rb
@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "rubocops/blank"
+
+RSpec.describe RuboCop::Cop::Homebrew::Blank, :config do
+  shared_examples "offense" do |source, correction, message|
+    it "registers an offense and corrects" do
+      expect_offense(<<~RUBY, source:, message:)
+        #{source}
+        ^{source} #{message}
+      RUBY
+
+      expect_correction(<<~RUBY)
+        #{correction}
+      RUBY
+    end
+  end
+
+  it "accepts checking nil?" do
+    expect_no_offenses("foo.nil?")
+  end
+
+  it "accepts checking empty?" do
+    expect_no_offenses("foo.empty?")
+  end
+
+  it "accepts checking nil? || empty? on different objects" do
+    expect_no_offenses("foo.nil? || bar.empty?")
+  end
+
+  # Bug: https://github.com/rubocop/rubocop/issues/4171
+  it "does not break when RHS of `or` is a naked falsiness check" do
+    expect_no_offenses("foo.empty? || bar")
+  end
+
+  it "does not break when LHS of `or` is a naked falsiness check" do
+    expect_no_offenses("bar || foo.empty?")
+  end
+
+  # Bug: https://github.com/rubocop/rubocop/issues/4814
+  it "does not break when LHS of `or` is a send node with an argument" do
+    expect_no_offenses("x(1) || something")
+  end
+
+  context "when nil or empty" do
+    it_behaves_like "offense", "foo.nil? || foo.empty?",
+                    "foo.blank?",
+                    "Use `foo.blank?` instead of `foo.nil? || foo.empty?`."
+    it_behaves_like "offense", "nil? || empty?", "blank?", "Use `blank?` instead of `nil? || empty?`."
+    it_behaves_like "offense", "foo == nil || foo.empty?",
+                    "foo.blank?",
+                    "Use `foo.blank?` instead of `foo == nil || foo.empty?`."
+    it_behaves_like "offense", "nil == foo || foo.empty?",
+                    "foo.blank?",
+                    "Use `foo.blank?` instead of `nil == foo || foo.empty?`."
+    it_behaves_like "offense", "!foo || foo.empty?", "foo.blank?",
+                    "Use `foo.blank?` instead of `!foo || foo.empty?`."
+
+    it_behaves_like "offense", "foo.nil? || !!foo.empty?",
+                    "foo.blank?",
+                    "Use `foo.blank?` instead of `foo.nil? || !!foo.empty?`."
+    it_behaves_like "offense", "foo == nil || !!foo.empty?",
+                    "foo.blank?",
+                    "Use `foo.blank?` instead of " \
+                    "`foo == nil || !!foo.empty?`."
+    it_behaves_like "offense", "nil == foo || !!foo.empty?",
+                    "foo.blank?",
+                    "Use `foo.blank?` instead of " \
+                    "`nil == foo || !!foo.empty?`."
+  end
+
+  context "when checking all variable types" do
+    it_behaves_like "offense", "foo.bar.nil? || foo.bar.empty?",
+                    "foo.bar.blank?",
+                    "Use `foo.bar.blank?` instead of " \
+                    "`foo.bar.nil? || foo.bar.empty?`."
+    it_behaves_like "offense", "FOO.nil? || FOO.empty?",
+                    "FOO.blank?",
+                    "Use `FOO.blank?` instead of `FOO.nil? || FOO.empty?`."
+    it_behaves_like "offense", "Foo.nil? || Foo.empty?",
+                    "Foo.blank?",
+                    "Use `Foo.blank?` instead of `Foo.nil? || Foo.empty?`."
+    it_behaves_like "offense", "Foo::Bar.nil? || Foo::Bar.empty?",
+                    "Foo::Bar.blank?",
+                    "Use `Foo::Bar.blank?` instead of " \
+                    "`Foo::Bar.nil? || Foo::Bar.empty?`."
+    it_behaves_like "offense", "@foo.nil? || @foo.empty?",
+                    "@foo.blank?",
+                    "Use `@foo.blank?` instead of `@foo.nil? || @foo.empty?`."
+    it_behaves_like "offense", "$foo.nil? || $foo.empty?",
+                    "$foo.blank?",
+                    "Use `$foo.blank?` instead of `$foo.nil? || $foo.empty?`."
+    it_behaves_like "offense", "@@foo.nil? || @@foo.empty?",
+                    "@@foo.blank?",
+                    "Use `@@foo.blank?` instead of " \
+                    "`@@foo.nil? || @@foo.empty?`."
+    it_behaves_like "offense", "foo[bar].nil? || foo[bar].empty?",
+                    "foo[bar].blank?",
+                    "Use `foo[bar].blank?` instead of " \
+                    "`foo[bar].nil? || foo[bar].empty?`."
+    it_behaves_like "offense", "foo(bar).nil? || foo(bar).empty?",
+                    "foo(bar).blank?",
+                    "Use `foo(bar).blank?` instead of " \
+                    "`foo(bar).nil? || foo(bar).empty?`."
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/bottle/bottle_digest_indentation_spec.rb b/Library/Homebrew/test/rubocops/bottle/bottle_digest_indentation_spec.rb
index 01e5c3e5b312c..ea116ca67033b 100644
--- a/Library/Homebrew/test/rubocops/bottle/bottle_digest_indentation_spec.rb
+++ b/Library/Homebrew/test/rubocops/bottle/bottle_digest_indentation_spec.rb
@@ -1,12 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/bottle"
 
-describe RuboCop::Cop::FormulaAudit::BottleDigestIndentation do
+RSpec.describe RuboCop::Cop::FormulaAudit::BottleDigestIndentation do
   subject(:cop) { described_class.new }
 
-  it "reports no offenses for `bottle :uneeded`" do
+  it "reports no offenses for `bottle :unneeded`" do
     expect_no_offenses(<<~RUBY)
       class Foo < Formula
         url "https://brew.sh/foo-1.0.tgz"
@@ -75,9 +74,9 @@ class Foo < Formula
           rebuild 4
           sha256 arm64_big_sur: "aaaaaaaa"
           sha256 big_sur: "faceb00c"
-                          ^^^^^^^^^^ Align bottle digests
+                          ^^^^^^^^^^ FormulaAudit/BottleDigestIndentation: Align bottle digests
           sha256 catalina: "deadbeef"
-                           ^^^^^^^^^^ Align bottle digests
+                           ^^^^^^^^^^ FormulaAudit/BottleDigestIndentation: Align bottle digests
         end
       end
     RUBY
@@ -105,9 +104,9 @@ class Foo < Formula
           rebuild 4
           sha256 cellar: :any,                arm64_big_sur: "aaaaaaaa"
           sha256 cellar: "/usr/local/Cellar", big_sur: "faceb00c"
-                                                       ^^^^^^^^^^ Align bottle digests
+                                                       ^^^^^^^^^^ FormulaAudit/BottleDigestIndentation: Align bottle digests
           sha256                              catalina: "deadbeef"
-                                                        ^^^^^^^^^^ Align bottle digests
+                                                        ^^^^^^^^^^ FormulaAudit/BottleDigestIndentation: Align bottle digests
         end
       end
     RUBY
diff --git a/Library/Homebrew/test/rubocops/bottle/bottle_format_spec.rb b/Library/Homebrew/test/rubocops/bottle/bottle_format_spec.rb
index 408d08747d72f..3f6b4853d141f 100644
--- a/Library/Homebrew/test/rubocops/bottle/bottle_format_spec.rb
+++ b/Library/Homebrew/test/rubocops/bottle/bottle_format_spec.rb
@@ -1,12 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/bottle"
 
-describe RuboCop::Cop::FormulaAudit::BottleFormat do
+RSpec.describe RuboCop::Cop::FormulaAudit::BottleFormat do
   subject(:cop) { described_class.new }
 
-  it "reports no offenses for `bottle :uneeded`" do
+  it "reports no offenses for `bottle :unneeded`" do
     expect_no_offenses(<<~RUBY)
       class Foo < Formula
         url "https://brew.sh/foo-1.0.tgz"
@@ -23,7 +22,7 @@ class Foo < Formula
 
         bottle do
           sha256 "faceb00c" => :big_sur
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `sha256` should use new syntax
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/BottleFormat: `sha256` should use new syntax
         end
       end
     RUBY
@@ -45,9 +44,9 @@ class Foo < Formula
         bottle do
           rebuild 4
           sha256 "faceb00c" => :big_sur
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `sha256` should use new syntax
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/BottleFormat: `sha256` should use new syntax
           sha256 "deadbeef" => :catalina
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `sha256` should use new syntax
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/BottleFormat: `sha256` should use new syntax
         end
       end
     RUBY
@@ -72,12 +71,12 @@ class Foo < Formula
 
         bottle do
           cellar :any
-          ^^^^^^^^^^^ `cellar` should be a parameter to `sha256`
+          ^^^^^^^^^^^ FormulaAudit/BottleFormat: `cellar` should be a parameter to `sha256`
           rebuild 4
           sha256 "faceb00c" => :big_sur
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `sha256` should use new syntax
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/BottleFormat: `sha256` should use new syntax
           sha256 "deadbeef" => :catalina
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `sha256` should use new syntax
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/BottleFormat: `sha256` should use new syntax
         end
       end
     RUBY
@@ -100,9 +99,9 @@ class Foo < Formula
 
         bottle do
           cellar :any
-          ^^^^^^^^^^^ `cellar` should be a parameter to `sha256`
+          ^^^^^^^^^^^ FormulaAudit/BottleFormat: `cellar` should be a parameter to `sha256`
           sha256 "faceb00c" => :big_sur
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `sha256` should use new syntax
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/BottleFormat: `sha256` should use new syntax
         end
       end
     RUBY
@@ -123,12 +122,12 @@ class Foo < Formula
 
         bottle do
           cellar "/usr/local/Cellar"
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^ `cellar` should be a parameter to `sha256`
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/BottleFormat: `cellar` should be a parameter to `sha256`
           rebuild 4
           sha256 "faceb00c" => :big_sur
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `sha256` should use new syntax
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/BottleFormat: `sha256` should use new syntax
           sha256 "deadbeef" => :catalina
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `sha256` should use new syntax
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/BottleFormat: `sha256` should use new syntax
         end
       end
     RUBY
diff --git a/Library/Homebrew/test/rubocops/bottle/bottle_order_spec.rb b/Library/Homebrew/test/rubocops/bottle/bottle_order_spec.rb
index 356a6ac48ecb3..94209b7ea95fc 100644
--- a/Library/Homebrew/test/rubocops/bottle/bottle_order_spec.rb
+++ b/Library/Homebrew/test/rubocops/bottle/bottle_order_spec.rb
@@ -1,12 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/bottle"
 
-describe RuboCop::Cop::FormulaAudit::BottleOrder do
+RSpec.describe RuboCop::Cop::FormulaAudit::BottleOrder do
   subject(:cop) { described_class.new }
 
-  it "reports no offenses for `bottle :uneeded`" do
+  it "reports no offenses for `bottle :unneeded`" do
     expect_no_offenses(<<~RUBY)
       class Foo < Formula
         url "https://brew.sh/foo-1.0.tgz"
@@ -122,7 +121,7 @@ class Foo < Formula
         url "https://brew.sh/foo-1.0.tgz"
 
         bottle do
-        ^^^^^^^^^ ARM bottles should be listed before Intel bottles
+        ^^^^^^^^^ FormulaAudit/BottleOrder: ARM bottles should be listed before Intel bottles
           rebuild 4
           sha256 big_sur: "faceb00c"
           sha256 catalina: "deadbeef"
@@ -151,7 +150,7 @@ class Foo < Formula
         url "https://brew.sh/foo-1.0.tgz"
 
         bottle do
-        ^^^^^^^^^ ARM bottles should be listed before Intel bottles
+        ^^^^^^^^^ FormulaAudit/BottleOrder: ARM bottles should be listed before Intel bottles
           rebuild 4
           sha256 big_sur: "faceb00c"
           sha256 arm64_catalina: "aaaaaaaa"
@@ -182,7 +181,7 @@ class Foo < Formula
         url "https://brew.sh/foo-1.0.tgz"
 
         bottle do
-        ^^^^^^^^^ ARM bottles should be listed before Intel bottles
+        ^^^^^^^^^ FormulaAudit/BottleOrder: ARM bottles should be listed before Intel bottles
           rebuild 4
           sha256 cellar: "/usr/local/Cellar",  big_sur:        "faceb00c"
           sha256                               catalina:       "deadbeef"
@@ -213,7 +212,7 @@ class Foo < Formula
         url "https://brew.sh/foo-1.0.tgz"
 
         bottle do
-        ^^^^^^^^^ ARM bottles should be listed before Intel bottles
+        ^^^^^^^^^ FormulaAudit/BottleOrder: ARM bottles should be listed before Intel bottles
           cellar :any
           sha256 "faceb00c" => :big_sur
           sha256 "aaaaaaaa" => :arm64_big_sur
diff --git a/Library/Homebrew/test/rubocops/bottle/bottle_tag_indentation_spec.rb b/Library/Homebrew/test/rubocops/bottle/bottle_tag_indentation_spec.rb
index c094c8d48e609..8bc13448aa1de 100644
--- a/Library/Homebrew/test/rubocops/bottle/bottle_tag_indentation_spec.rb
+++ b/Library/Homebrew/test/rubocops/bottle/bottle_tag_indentation_spec.rb
@@ -1,12 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/bottle"
 
-describe RuboCop::Cop::FormulaAudit::BottleTagIndentation do
+RSpec.describe RuboCop::Cop::FormulaAudit::BottleTagIndentation do
   subject(:cop) { described_class.new }
 
-  it "reports no offenses for `bottle :uneeded`" do
+  it "reports no offenses for `bottle :unneeded`" do
     expect_no_offenses(<<~RUBY)
       class Foo < Formula
         url "https://brew.sh/foo-1.0.tgz"
@@ -74,10 +73,10 @@ class Foo < Formula
         bottle do
           rebuild 4
           sha256 cellar: :any, arm64_big_sur: "aaaaaaaa"
-                               ^^^^^^^^^^^^^^^^^^^^^^^^^ Align bottle tags
+                               ^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/BottleTagIndentation: Align bottle tags
           sha256 cellar: "/usr/local/Cellar", big_sur: "faceb00c"
           sha256 catalina: "deadbeef"
-                 ^^^^^^^^^^^^^^^^^^^^ Align bottle tags
+                 ^^^^^^^^^^^^^^^^^^^^ FormulaAudit/BottleTagIndentation: Align bottle tags
         end
       end
     RUBY
diff --git a/Library/Homebrew/test/rubocops/cask/array_alphabetization_spec.rb b/Library/Homebrew/test/rubocops/cask/array_alphabetization_spec.rb
new file mode 100644
index 0000000000000..43d9b9768cc02
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/cask/array_alphabetization_spec.rb
@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "rubocops/rubocop-cask"
+
+RSpec.describe RuboCop::Cop::Cask::ArrayAlphabetization, :config do
+  it "reports an offense when a single `zap trash` path is specified in an array" do
+    expect_offense(<<~CASK)
+      cask "foo" do
+        url "https://example.com/foo.zip"
+
+        zap trash: ["~/Library/Application Support/Foo"]
+                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Avoid single-element arrays by removing the []
+      end
+    CASK
+
+    expect_correction(<<~CASK)
+      cask "foo" do
+        url "https://example.com/foo.zip"
+
+        zap trash: "~/Library/Application Support/Foo"
+      end
+    CASK
+  end
+
+  it "reports an offense when the `zap` stanza paths are not in alphabetical order" do
+    expect_offense(<<~CASK)
+      cask "foo" do
+        url "https://example.com/foo.zip"
+
+        zap trash: [
+                   ^ The array elements should be ordered alphabetically
+          "/Library/Application Support/Foo",
+          "/Library/Application Support/Baz",
+          "~/Library/Application Support/Foo",
+          "~/.dotfiles/thing",
+          "~/Library/Application Support/Bar",
+        ],
+        rmdir: [
+               ^ The array elements should be ordered alphabetically
+          "/Applications/foo/nested/blah",
+          "/Applications/foo/",
+        ]
+      end
+    CASK
+
+    expect_correction(<<~CASK)
+      cask "foo" do
+        url "https://example.com/foo.zip"
+
+        zap trash: [
+          "/Library/Application Support/Baz",
+          "/Library/Application Support/Foo",
+          "~/.dotfiles/thing",
+          "~/Library/Application Support/Bar",
+          "~/Library/Application Support/Foo",
+        ],
+        rmdir: [
+          "/Applications/foo/",
+          "/Applications/foo/nested/blah",
+        ]
+      end
+    CASK
+  end
+
+  it "autocorrects alphabetization in zap trash paths with interpolation" do
+    expect_offense(<<~CASK)
+      cask "foo" do
+        url "https://example.com/foo.zip"
+
+        zap trash: [
+                   ^ The array elements should be ordered alphabetically
+          "~/Library/Application Support/Foo",
+          "~/Library/Application Support/Bar\#{version.major}",
+        ]
+      end
+    CASK
+
+    expect_correction(<<~CASK)
+      cask "foo" do
+        url "https://example.com/foo.zip"
+
+        zap trash: [
+          "~/Library/Application Support/Bar\#{version.major}",
+          "~/Library/Application Support/Foo",
+        ]
+      end
+    CASK
+  end
+
+  it "autocorrects alphabetization in `uninstall` methods" do
+    expect_offense(<<~CASK)
+      cask "foo" do
+        url "https://example.com/foo.zip"
+
+        uninstall pkgutil: [
+                           ^ The array elements should be ordered alphabetically
+          "something",
+          "other",
+        ],
+        script: [
+          "ordered",
+          "differently",
+        ]
+      end
+    CASK
+
+    expect_correction(<<~CASK)
+      cask "foo" do
+        url "https://example.com/foo.zip"
+
+        uninstall pkgutil: [
+          "other",
+          "something",
+        ],
+        script: [
+          "ordered",
+          "differently",
+        ]
+      end
+    CASK
+  end
+
+  it "ignores `uninstall` methods with commands" do
+    expect_no_offenses(<<~CASK)
+      cask "foo" do
+        url "https://example.com/foo.zip"
+
+        uninstall script: {
+          args: ["--mode=something", "--another-mode"],
+          executable: "thing",
+        }
+      end
+    CASK
+  end
+
+  it "moves comments when autocorrecting" do
+    expect_offense(<<~CASK)
+      cask "foo" do
+        url "https://example.com/foo.zip"
+
+        zap trash: [
+                   ^ The array elements should be ordered alphabetically
+          # comment related to foo
+          "~/Library/Application Support/Foo",
+          # a really long comment related to Zoo
+          # and the Zoo comment continues
+          "~/Library/Application Support/Zoo",
+          "~/Library/Application Support/Bar",
+          "~/Library/Application Support/Baz", # in-line comment
+        ]
+      end
+    CASK
+
+    expect_correction(<<~CASK)
+      cask "foo" do
+        url "https://example.com/foo.zip"
+
+        zap trash: [
+          "~/Library/Application Support/Bar",
+          "~/Library/Application Support/Baz", # in-line comment
+          # comment related to foo
+          "~/Library/Application Support/Foo",
+          # a really long comment related to Zoo
+          # and the Zoo comment continues
+          "~/Library/Application Support/Zoo",
+        ]
+      end
+    CASK
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/cask/desc_spec.rb b/Library/Homebrew/test/rubocops/cask/desc_spec.rb
index 633db2e1c1827..dc3fe2629afee 100644
--- a/Library/Homebrew/test/rubocops/cask/desc_spec.rb
+++ b/Library/Homebrew/test/rubocops/cask/desc_spec.rb
@@ -1,12 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/rubocop-cask"
-require "test/rubocops/cask/shared_examples/cask_cop"
-
-describe RuboCop::Cop::Cask::Desc do
-  subject(:cop) { described_class.new }
 
+RSpec.describe RuboCop::Cop::Cask::Desc, :config do
   it "does not start with an article" do
     expect_no_offenses <<~RUBY
       cask "foo" do
@@ -17,14 +13,14 @@
     expect_offense <<~RUBY, "/homebrew-cask/Casks/foo.rb"
       cask 'foo' do
         desc 'A bar program'
-              ^ Description shouldn\'t start with an article.
+              ^ Description shouldn't start with an article.
       end
     RUBY
 
     expect_offense <<~RUBY, "/homebrew-cask/Casks/foo.rb"
       cask 'foo' do
         desc 'The bar program'
-              ^^^ Description shouldn\'t start with an article.
+              ^^^ Description shouldn't start with an article.
       end
     RUBY
 
@@ -46,28 +42,28 @@
     expect_offense <<~RUBY, "/homebrew-cask/Casks/foo.rb"
       cask 'foobar' do
         desc 'Foo-Bar program'
-              ^^^^^^^ Description shouldn\'t start with the cask name.
+              ^^^^^^^ Description shouldn't start with the cask name.
       end
     RUBY
 
     expect_offense <<~RUBY, "/homebrew-cask/Casks/foo.rb"
       cask 'foo-bar' do
         desc 'Foo bar program'
-              ^^^^^^^ Description shouldn\'t start with the cask name.
+              ^^^^^^^ Description shouldn't start with the cask name.
       end
     RUBY
 
     expect_offense <<~RUBY, "/homebrew-cask/Casks/foo.rb"
       cask 'foo-bar' do
         desc 'Foo-Bar program'
-              ^^^^^^^ Description shouldn\'t start with the cask name.
+              ^^^^^^^ Description shouldn't start with the cask name.
       end
     RUBY
 
     expect_offense <<~RUBY, "/homebrew-cask/Casks/foo.rb"
       cask 'foo-bar' do
         desc 'Foo Bar'
-              ^^^^^^^ Description shouldn\'t start with the cask name.
+              ^^^^^^^ Description shouldn't start with the cask name.
       end
     RUBY
   end
@@ -76,28 +72,28 @@
     expect_offense <<~RUBY, "/homebrew-cask/Casks/foo.rb"
       cask 'foo-bar' do
         desc 'macOS status bar monitor'
-              ^^^^^ Description shouldn\'t contain the platform.
+              ^^^^^ Description shouldn't contain the platform.
       end
     RUBY
 
     expect_offense <<~RUBY, "/homebrew-cask/Casks/foo.rb"
       cask 'foo-bar' do
         desc 'Toggles dark mode on Mac OS Mojave'
-                                   ^^^^^^ Description shouldn\'t contain the platform.
+                                   ^^^^^^ Description shouldn't contain the platform.
       end
     RUBY
 
     expect_offense <<~RUBY, "/homebrew-cask/Casks/foo.rb"
       cask 'foo-bar' do
         desc 'Better input source switcher for OS X'
-                                               ^^^^ Description shouldn\'t contain the platform.
+                                               ^^^^ Description shouldn't contain the platform.
       end
     RUBY
 
     expect_offense <<~RUBY, "/homebrew-cask/Casks/foo.rb"
       cask 'foo-bar' do
         desc 'Media Manager for Mac OS X'
-                                ^^^^^^^^ Description shouldn\'t contain the platform.
+                                ^^^^^^^^ Description shouldn't contain the platform.
       end
     RUBY
 
@@ -110,7 +106,14 @@
     expect_offense <<~RUBY
       cask 'foo' do
         desc 'Application for managing macOS virtual machines on macOS'
-                                                                 ^^^^^ Description shouldn\'t contain the platform.
+                                                                 ^^^^^ Description shouldn't contain the platform.
+      end
+    RUBY
+
+    expect_offense <<~RUBY
+      cask 'foo' do
+        desc 'Description with a 🍺 symbol'
+                                 ^ Description shouldn't contain Unicode emojis or symbols.
       end
     RUBY
 
diff --git a/Library/Homebrew/test/rubocops/cask/discontinued_spec.rb b/Library/Homebrew/test/rubocops/cask/discontinued_spec.rb
new file mode 100644
index 0000000000000..a1b3a82afa362
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/cask/discontinued_spec.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "rubocops/rubocop-cask"
+
+RSpec.describe RuboCop::Cop::Cask::Discontinued, :config do
+  it "reports no offenses when there is no `caveats` stanza" do
+    expect_no_offenses <<~CASK
+      cask "foo" do
+        url "https://example.com/download/foo-v1.2.0.dmg",
+            verified: "example.com/download/"
+      end
+    CASK
+  end
+
+  it "reports no offenses when there is a `caveats` stanza without `discontinued`" do
+    expect_no_offenses <<~CASK
+      cask "foo" do
+        url "https://example.com/download/foo-v1.2.0.dmg",
+            verified: "example.com/download/"
+
+        caveats do
+          files_in_usr_local
+        end
+      end
+    CASK
+  end
+
+  it "reports an offense when there is a `caveats` stanza with `discontinued` and other caveats" do
+    expect_offense <<~CASK
+      cask "foo" do
+        url "https://example.com/download/foo-v1.2.0.dmg",
+            verified: "example.com/download/"
+
+        caveats do
+          discontinued
+          ^^^^^^^^^^^^ Use `deprecate!` instead of `caveats { discontinued }`.
+          files_in_usr_local
+        end
+      end
+    CASK
+  end
+
+  it "corrects `caveats { discontinued }` to `deprecate!`" do
+    expect_offense <<~CASK
+      cask "foo" do
+        url "https://example.com/download/foo-v1.2.0.dmg",
+            verified: "example.com/download/"
+
+        caveats do
+        ^^^^^^^^^^ Use `deprecate!` instead of `caveats { discontinued }`.
+          discontinued
+        end
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask "foo" do
+        url "https://example.com/download/foo-v1.2.0.dmg",
+            verified: "example.com/download/"
+
+        deprecate! date: "#{Date.today}", because: :discontinued
+      end
+    CASK
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/cask/homepage_url_styling_spec.rb b/Library/Homebrew/test/rubocops/cask/homepage_url_styling_spec.rb
new file mode 100644
index 0000000000000..28b4978856326
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/cask/homepage_url_styling_spec.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "rubocops/rubocop-cask"
+
+RSpec.describe RuboCop::Cop::Cask::HomepageUrlStyling, :config do
+  it "accepts a homepage URL ending with a slash" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        homepage 'https://foo.brew.sh/'
+      end
+    CASK
+  end
+
+  it "accepts a homepage URL with a path" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        homepage 'https://foo.brew.sh/path'
+      end
+    CASK
+  end
+
+  it "reports an offense when the homepage URL does not end with a slash and has no path" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        homepage 'https://foo.brew.sh'
+                 ^^^^^^^^^^^^^^^^^^^^^ 'https://foo.brew.sh' must have a slash after the domain.
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        homepage 'https://foo.brew.sh/'
+      end
+    CASK
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/cask/homepage_url_trailing_slash_spec.rb b/Library/Homebrew/test/rubocops/cask/homepage_url_trailing_slash_spec.rb
deleted file mode 100644
index 3469dc78bb7ed..0000000000000
--- a/Library/Homebrew/test/rubocops/cask/homepage_url_trailing_slash_spec.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "rubocops/rubocop-cask"
-require "test/rubocops/cask/shared_examples/cask_cop"
-
-describe RuboCop::Cop::Cask::HomepageUrlTrailingSlash do
-  include CaskCop
-
-  subject(:cop) { described_class.new }
-
-  context "when the homepage URL ends with a slash" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          homepage 'https://foo.brew.sh/'
-        end
-      CASK
-    end
-
-    include_examples "does not report any offenses"
-  end
-
-  context "when the homepage URL does not end with a slash but has a path" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          homepage 'https://foo.brew.sh/path'
-        end
-      CASK
-    end
-
-    include_examples "does not report any offenses"
-  end
-
-  context "when the homepage URL does not end with a slash and has no path" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          homepage 'https://foo.brew.sh'
-        end
-      CASK
-    end
-    let(:correct_source) do
-      <<-CASK.undent
-        cask 'foo' do
-          homepage 'https://foo.brew.sh/'
-        end
-      CASK
-    end
-    let(:expected_offenses) do
-      [{
-        message:  "'https://foo.brew.sh' must have a slash " \
-                  "after the domain.",
-        severity: :convention,
-        line:     2,
-        column:   11,
-        source:   "'https://foo.brew.sh'",
-      }]
-    end
-
-    include_examples "reports offenses"
-
-    include_examples "autocorrects source"
-  end
-end
diff --git a/Library/Homebrew/test/rubocops/cask/no_dsl_version_spec.rb b/Library/Homebrew/test/rubocops/cask/no_dsl_version_spec.rb
deleted file mode 100644
index a8f1c574e5b7e..0000000000000
--- a/Library/Homebrew/test/rubocops/cask/no_dsl_version_spec.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "rubocops/rubocop-cask"
-require "test/rubocops/cask/shared_examples/cask_cop"
-
-describe RuboCop::Cop::Cask::NoDslVersion do
-  include CaskCop
-
-  subject(:cop) { described_class.new }
-
-  context "with no dsl version" do
-    let(:source) { "cask 'foo' do; end" }
-
-    include_examples "does not report any offenses"
-  end
-
-  context "with dsl version" do
-    let(:source) { "cask :v1 => 'foo' do; end" }
-    let(:correct_source) { "cask 'foo' do; end" }
-    let(:expected_offenses) do
-      [{
-        message:  "Use `cask 'foo'` instead of `cask :v1 => 'foo'`",
-        severity: :convention,
-        line:     1,
-        column:   0,
-        source:   "cask :v1 => 'foo'",
-      }]
-    end
-
-    include_examples "reports offenses"
-
-    include_examples "autocorrects source"
-  end
-end
diff --git a/Library/Homebrew/test/rubocops/cask/no_overrides_spec.rb b/Library/Homebrew/test/rubocops/cask/no_overrides_spec.rb
new file mode 100644
index 0000000000000..3b68c05a32789
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/cask/no_overrides_spec.rb
@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "rubocops/rubocop-cask"
+
+RSpec.describe RuboCop::Cop::Cask::NoOverrides, :config do
+  it "accepts when there are no `on_*` blocks" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        version '1.2.3'
+        url 'https://brew.sh/foo.pkg'
+
+        name 'Foo'
+      end
+    CASK
+  end
+
+  it "accepts when there are no top-level standalone stanzas" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        on_mojave :or_later do
+          version :latest
+        end
+      end
+    CASK
+  end
+
+  it "accepts non-overridable stanzas in `on_*` blocks" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        version '1.2.3'
+
+        on_arm do
+          binary "foo-\#{version}-arm64"
+        end
+
+        app "foo-\#{version}.app"
+
+        binary "foo-\#{version}"
+      end
+    CASK
+  end
+
+  it "accepts `arch` and `version` interpolations in strings in `on_*` blocks" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        arch arm: "arm64", intel: "x86"
+        version '1.2.3'
+
+        on_mojave :or_later do
+          sha256 "aaa"
+
+          url "https://brew.sh/foo-\#{version}-\#{arch}.pkg"
+        end
+      end
+    CASK
+  end
+
+  it "accepts `version` interpolations with method calls in strings in `on_*` blocks" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        version '0.99,123.3'
+
+        on_mojave :or_later do
+          url "https://brew.sh/foo-\#{version.csv.first}-\#{version.csv.second}.pkg"
+        end
+      end
+    CASK
+  end
+
+  it "accepts `arch` interpolations in regexes in `on_*` blocks" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        arch arm: "arm64", intel: "x86"
+
+        version '0.99,123.3'
+
+        on_mojave :or_later do
+          url "https://brew.sh/foo-\#{arch}-\#{version.csv.first}-\#{version.csv.last}.pkg"
+
+          livecheck do
+            url "https://brew.sh/foo/releases.html"
+            regex(/href=.*?foo[._-]v?(\d+(?:.\d+)+)-\#{arch}.pkg/i)
+          end
+        end
+      end
+    CASK
+  end
+
+  it "ignores contents of single-line `livecheck` blocks in `on_*` blocks" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        on_intel do
+          livecheck do
+            url 'https://brew.sh/foo' # Livecheck should be allowed since it's a different "kind" of URL.
+          end
+          version '1.2.3'
+        end
+        on_arm do
+          version '2.3.4'
+        end
+
+        url 'https://brew.sh/foo.pkg'
+        sha256 "bbb"
+      end
+    CASK
+  end
+
+  it "ignores contents of multi-line `livecheck` blocks in `on_*` blocks" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        on_intel do
+          livecheck do
+            url 'https://brew.sh/foo' # Livecheck should be allowed since it's a different "kind" of URL.
+            strategy :sparkle
+          end
+          version '1.2.3'
+        end
+        on_arm do
+          version '2.3.4'
+        end
+
+        url 'https://brew.sh/foo.pkg'
+        sha256 "bbb"
+      end
+    CASK
+  end
+
+  it "accepts `on_*` blocks that don't override upper-level stanzas" do
+    expect_no_offenses <<~CASK
+      cask "foo" do
+        version "1.2.3"
+
+        on_big_sur :or_older do
+          sha256 "bbb"
+          url "https://brew.sh/legacy/foo-2.3.4.dmg"
+        end
+        on_monterey :or_newer do
+          sha256 "aaa"
+          url "https://brew.sh/foo-2.3.4.dmg"
+        end
+      end
+    CASK
+  end
+
+  it "reports an offense when `on_*` blocks override a single upper-level stanza" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        version '2.3.4'
+        ^^^^^^^^^^^^^^^ Do not use a top-level `version` stanza as the default. Add it to an `on_{system}` block instead. Use `:or_older` or `:or_newer` to specify a range of macOS versions.
+
+        on_mojave :or_older do
+          version '1.2.3'
+        end
+
+        url 'https://brew.sh/foo-2.3.4.dmg'
+      end
+    CASK
+  end
+
+  it "reports an offense when `on_*` blocks override multiple upper-level stanzas" do
+    expect_offense <<~CASK
+      cask "foo" do
+        version "1.2.3"
+        sha256 "aaa"
+        ^^^^^^^^^^^^ Do not use a top-level `sha256` stanza as the default. Add it to an `on_{system}` block instead. Use `:or_older` or `:or_newer` to specify a range of macOS versions.
+        url "https://brew.sh/foo-2.3.4.dmg"
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not use a top-level `url` stanza as the default. Add it to an `on_{system}` block instead. Use `:or_older` or `:or_newer` to specify a range of macOS versions.
+
+        on_big_sur :or_older do
+          sha256 "bbb"
+          url "https://brew.sh/legacy/foo-2.3.4.dmg"
+        end
+      end
+    CASK
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/cask/on_system_conditionals_spec.rb b/Library/Homebrew/test/rubocops/cask/on_system_conditionals_spec.rb
new file mode 100644
index 0000000000000..7777d226af0c6
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/cask/on_system_conditionals_spec.rb
@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require "rubocops/rubocop-cask"
+
+RSpec.describe RuboCop::Cop::Cask::OnSystemConditionals, :config do
+  context "when auditing `postflight` stanzas" do
+    it "accepts when there are no `on_*` blocks" do
+      expect_no_offenses <<~CASK
+        cask 'foo' do
+          postflight do
+            foobar
+          end
+        end
+      CASK
+    end
+
+    it "reports an offense it contains an `on_intel` block" do
+      expect_offense <<~CASK
+        cask 'foo' do
+          postflight do
+            on_intel do
+            ^^^^^^^^ Don't use `on_intel` in `postflight do`, use `if Hardware::CPU.intel?` instead.
+              foobar
+            end
+          end
+        end
+      CASK
+
+      # FIXME: Infinite loop alternating between `if Hardware::CPU.intel?` and `on_intel do`.
+      expect_correction <<~CASK, loop: false
+        cask 'foo' do
+          postflight do
+            if Hardware::CPU.intel?
+              foobar
+            end
+          end
+        end
+      CASK
+    end
+
+    it "reports an offense when it contains an `on_monterey` block" do
+      expect_offense <<~CASK
+        cask 'foo' do
+          postflight do
+            on_monterey do
+            ^^^^^^^^^^^ Don't use `on_monterey` in `postflight do`, use `if MacOS.version == :monterey` instead.
+              foobar
+            end
+          end
+        end
+      CASK
+
+      # FIXME: Infinite loop alternating between `if MacOS.version == :monterey` and `on_monterey do`.
+      expect_correction <<~CASK, loop: false
+        cask 'foo' do
+          postflight do
+            if MacOS.version == :monterey
+              foobar
+            end
+          end
+        end
+      CASK
+    end
+
+    it "reports an offense when it contains an `on_monterey :or_older` block" do
+      expect_offense <<~CASK
+        cask 'foo' do
+          postflight do
+            on_monterey :or_older do
+            ^^^^^^^^^^^^^^^^^^^^^ Don't use `on_monterey :or_older` in `postflight do`, use `if MacOS.version <= :monterey` instead.
+              foobar
+            end
+          end
+        end
+      CASK
+
+      # FIXME: Infinite loop alternating between `if MacOS.version <= :monterey` and `on_monterey :or_older do`.
+      expect_correction <<~CASK, loop: false
+        cask 'foo' do
+          postflight do
+            if MacOS.version <= :monterey
+              foobar
+            end
+          end
+        end
+      CASK
+    end
+  end
+
+  context "when auditing `sha256` stanzas inside `on_arch` blocks" do
+    it "accepts when there are no `on_arch` blocks" do
+      expect_no_offenses <<~CASK
+        cask 'foo' do
+          sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
+        end
+      CASK
+    end
+
+    it "accepts when the `sha256` stanza is used with keyword arguments" do
+      expect_no_offenses <<~CASK
+        cask 'foo' do
+          sha256 arm:   "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94",
+                 intel: "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+        end
+      CASK
+    end
+
+    it "accepts when there is only one `on_arch` block" do
+      expect_no_offenses <<~CASK
+        cask 'foo' do
+          on_intel do
+            sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
+          end
+        end
+      CASK
+    end
+
+    it "reports an offense when `sha256` is specified in all `on_arch` blocks" do
+      expect_offense <<~CASK
+        cask 'foo' do
+          on_intel do
+            sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
+          end
+          on_arm do
+          ^^^^^^^^^ Use `sha256 arm: "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b", intel: "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"` instead of nesting the `sha256` stanzas in `on_intel` and `on_arm` blocks
+            sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+          end
+        end
+      CASK
+
+      expect_correction <<~CASK
+        cask 'foo' do
+        #{"  "}
+          sha256 arm: "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b", intel: "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
+        end
+      CASK
+    end
+
+    it "accepts when there is also a `version` stanza inside the `on_arch` blocks" do
+      expect_no_offenses <<~CASK
+        cask 'foo' do
+          on_intel do
+            version "1.0.0"
+            sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
+          end
+          on_arm do
+            version "2.0.0"
+            sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+          end
+        end
+      CASK
+    end
+
+    it "accepts when there is also a `version` stanza inside only a single `on_arch` block" do
+      expect_no_offenses <<~CASK
+        cask 'foo' do
+          on_intel do
+            version "2.0.0"
+            sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
+          end
+          on_arm do
+            sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+          end
+        end
+      CASK
+    end
+  end
+
+  context "when auditing loose `Hardware::CPU` method calls" do
+    it "reports an offense when `Hardware::CPU.arm?` is used" do
+      expect_offense <<~CASK
+        cask 'foo' do
+          if Hardware::CPU.arm? && other_condition
+             ^^^^^^^^^^^^^^^^^^ Don't use `Hardware::CPU.arm?`, use `on_arm` and `on_intel` blocks instead.
+            sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
+          else
+            sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+          end
+        end
+      CASK
+    end
+
+    it "reports an offense when `Hardware::CPU.intel?` is used" do
+      expect_offense <<~CASK
+        cask 'foo' do
+          if Hardware::CPU.intel? && other_condition
+             ^^^^^^^^^^^^^^^^^^^^ Don't use `Hardware::CPU.intel?`, use `on_arm` and `on_intel` blocks instead.
+            sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
+          else
+            sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+          end
+        end
+      CASK
+    end
+
+    it "reports an offense when `Hardware::CPU.arch` is used" do
+      expect_offense <<~'CASK'
+        cask 'foo' do
+          version "1.2.3"
+          sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
+
+          url "https://example.com/foo-#{version}-#{Hardware::CPU.arch}.zip"
+                                                    ^^^^^^^^^^^^^^^^^^ Don't use `Hardware::CPU.arch`, use `on_arm` and `on_intel` blocks instead.
+        end
+      CASK
+    end
+  end
+
+  context "when auditing loose `MacOS.version` method calls" do
+    it "reports an offense when `MacOS.version ==` is used" do
+      expect_offense <<~CASK
+        cask 'foo' do
+          if MacOS.version == :catalina
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't use `if MacOS.version == :catalina`, use `on_catalina do` instead.
+            version "1.0.0"
+          else
+            version "2.0.0"
+          end
+        end
+      CASK
+    end
+
+    it "reports an offense when `MacOS.version <=` is used" do
+      expect_offense <<~CASK
+        cask 'foo' do
+          if MacOS.version <= :catalina
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't use `if MacOS.version <= :catalina`, use `on_catalina :or_older do` instead.
+            version "1.0.0"
+          else
+            version "2.0.0"
+          end
+        end
+      CASK
+    end
+
+    it "reports an offense when `MacOS.version >=` is used" do
+      expect_offense <<~CASK
+        cask 'foo' do
+          if MacOS.version >= :catalina
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't use `if MacOS.version >= :catalina`, use `on_catalina :or_newer do` instead.
+            version "1.0.0"
+          else
+            version "2.0.0"
+          end
+        end
+      CASK
+    end
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/cask/shared_examples/cask_cop.rb b/Library/Homebrew/test/rubocops/cask/shared_examples/cask_cop.rb
deleted file mode 100644
index 49b09a0d832f6..0000000000000
--- a/Library/Homebrew/test/rubocops/cask/shared_examples/cask_cop.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-module CaskCop
-  shared_examples "does not report any offenses" do
-    it "does not report any offenses" do
-      expect_no_offenses(source)
-    end
-  end
-
-  shared_examples "reports offenses" do
-    it "reports offenses" do
-      expect_reported_offenses(source, expected_offenses)
-    end
-  end
-
-  shared_examples "autocorrects source" do
-    it "autocorrects source" do
-      expect_autocorrected_source(source, correct_source)
-    end
-  end
-
-  def expect_no_offenses(source)
-    expect(inspect_source(source)).to be_empty
-  end
-
-  def expect_reported_offenses(source, expected_offenses)
-    offenses = inspect_source(source)
-    expect(offenses.size).to eq(expected_offenses.size)
-    expected_offenses.zip(offenses).each do |expected, actual|
-      expect_offense(expected, actual)
-    end
-  end
-
-  def expect_offense(expected, actual)
-    expect(actual.message).to eq(expected[:message])
-    expect(actual.severity).to eq(expected[:severity])
-    expect(actual.line).to eq(expected[:line])
-    expect(actual.column).to eq(expected[:column])
-    expect(actual.location.source).to eq(expected[:source])
-  end
-
-  def expect_autocorrected_source(source, correct_source)
-    new_source = autocorrect_source(source)
-    expect(new_source).to eq(Array(correct_source).join("\n"))
-  end
-end
diff --git a/Library/Homebrew/test/rubocops/cask/shared_filelist_glob_spec.rb b/Library/Homebrew/test/rubocops/cask/shared_filelist_glob_spec.rb
new file mode 100644
index 0000000000000..55151c9f6f838
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/cask/shared_filelist_glob_spec.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "rubocops/rubocop-cask"
+
+RSpec.describe RuboCop::Cop::Cask::SharedFilelistGlob, :config do
+  it "reports an offense when a zap trash array includes an .sfl2 or .sfl3 file" do
+    expect_offense(<<~CASK)
+      cask "foo" do
+        url "https://example.com/foo.zip"
+
+        zap trash: ["~/Library/Application Support/com.apple.sharedfilelist/com.apple.LSSharedFileList.ApplicationRecentDocuments/org.mozilla.firefox.sfl2"]
+                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use a glob (*) instead of a specific version (ie. sfl2) for trashing Shared File List paths
+      end
+    CASK
+
+    expect_correction(<<~CASK)
+      cask "foo" do
+        url "https://example.com/foo.zip"
+
+        zap trash: ["~/Library/Application Support/com.apple.sharedfilelist/com.apple.LSSharedFileList.ApplicationRecentDocuments/org.mozilla.firefox.sfl*"]
+      end
+    CASK
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/cask/stanza_grouping_spec.rb b/Library/Homebrew/test/rubocops/cask/stanza_grouping_spec.rb
index 3cce050983a04..9cf48bb240667 100644
--- a/Library/Homebrew/test/rubocops/cask/stanza_grouping_spec.rb
+++ b/Library/Homebrew/test/rubocops/cask/stanza_grouping_spec.rb
@@ -1,162 +1,205 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/rubocop-cask"
-require "test/rubocops/cask/shared_examples/cask_cop"
 
-describe RuboCop::Cop::Cask::StanzaGrouping do
-  include CaskCop
+RSpec.describe RuboCop::Cop::Cask::StanzaGrouping, :config do
+  it "accepts a sole stanza" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        version :latest
+      end
+    CASK
+  end
+
+  it "accepts correctly grouped stanzas" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        version :latest
+        sha256 :no_check
+      end
+    CASK
+  end
 
-  subject(:cop) { described_class.new }
+  it "accepts correctly grouped stanzas and variable assignments" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        arch arm: "arm64", intel: "x86_64"
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
 
-  let(:missing_line_msg) do
-    "stanza groups should be separated by a single empty line"
+        version :latest
+        sha256 :no_check
+      end
+    CASK
   end
-  let(:extra_line_msg) do
-    "stanzas within the same group should have no lines between them"
+
+  it "reports an offense when a stanza is grouped incorrectly" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        version :latest
+
+      ^{} stanzas within the same group should have no lines between them
+        sha256 :no_check
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        version :latest
+        sha256 :no_check
+      end
+    CASK
   end
 
-  context "when there is only one stanza" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-        end
-      CASK
-    end
+  it "reports an offense for an incorrectly grouped `arch` stanza" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        arch arm: "arm64", intel: "x86_64"
+        version :latest
+      ^^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+        sha256 :no_check
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        arch arm: "arm64", intel: "x86_64"
 
-    include_examples "does not report any offenses"
+        version :latest
+        sha256 :no_check
+      end
+    CASK
   end
 
-  context "when no stanzas are incorrectly grouped" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-          sha256 :no_check
-        end
-      CASK
-    end
+  it "reports an offense for an incorrectly grouped variable assignment" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        arch arm: "arm64", intel: "x86_64"
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+        version :latest
+      ^^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+        sha256 :no_check
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        arch arm: "arm64", intel: "x86_64"
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
 
-    include_examples "does not report any offenses"
+        version :latest
+        sha256 :no_check
+      end
+    CASK
   end
 
-  context "when one stanza is incorrectly grouped" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
+  it "reports an offense for multiple incorrectly grouped stanzas" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        version :latest
+        sha256 :no_check
+        url 'https://foo.brew.sh/foo.zip'
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
 
-          sha256 :no_check
-        end
-      CASK
-    end
-    let(:correct_source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-          sha256 :no_check
-        end
-      CASK
-    end
-    let(:expected_offenses) do
-      [{
-        message:  extra_line_msg,
-        severity: :convention,
-        line:     3,
-        column:   0,
-        source:   "\n",
-      }]
-    end
+      ^{} stanzas within the same group should have no lines between them
+        name 'Foo'
+
+      ^{} stanzas within the same group should have no lines between them
+        homepage 'https://foo.brew.sh'
+
+        app 'Foo.app'
+        uninstall :quit => 'com.example.foo',
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+                  :kext => 'com.example.foo.kextextension'
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        version :latest
+        sha256 :no_check
 
-    include_examples "reports offenses"
+        url 'https://foo.brew.sh/foo.zip'
+        name 'Foo'
+        homepage 'https://foo.brew.sh'
 
-    include_examples "autocorrects source"
+        app 'Foo.app'
+
+        uninstall :quit => 'com.example.foo',
+                  :kext => 'com.example.foo.kextextension'
+      end
+    CASK
   end
 
-  context "when many stanzas are incorrectly grouped" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-          sha256 :no_check
-          url 'https://foo.brew.sh/foo.zip'
+  it "reports an offense for multiple incorrectly grouped stanzas and variable assignments" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        arch arm: "arm64", intel: "x86_64"
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
 
-          name 'Foo'
+      ^{} stanzas within the same group should have no lines between them
+        platform = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+        version :latest
+      ^^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+        sha256 :no_check
 
-          homepage 'https://foo.brew.sh'
+        url 'https://foo.brew.sh/foo.zip'
 
-          app 'Foo.app'
-          uninstall :quit => 'com.example.foo',
-                    :kext => 'com.example.foo.kextextension'
-        end
-      CASK
-    end
-    let(:correct_source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-          sha256 :no_check
+      ^{} stanzas within the same group should have no lines between them
+        name 'Foo'
 
-          url 'https://foo.brew.sh/foo.zip'
-          name 'Foo'
-          homepage 'https://foo.brew.sh'
+      ^{} stanzas within the same group should have no lines between them
+        homepage 'https://foo.brew.sh'
 
-          app 'Foo.app'
+        app 'Foo.app'
+        uninstall :quit => 'com.example.foo',
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+                  :kext => 'com.example.foo.kextextension'
+      end
+    CASK
 
-          uninstall :quit => 'com.example.foo',
-                    :kext => 'com.example.foo.kextextension'
-        end
-      CASK
-    end
-    let(:expected_offenses) do
-      [{
-        message:  missing_line_msg,
-        severity: :convention,
-        line:     4,
-        column:   0,
-        source:   "  url 'https://foo.brew.sh/foo.zip'",
-      }, {
-        message:  extra_line_msg,
-        severity: :convention,
-        line:     5,
-        column:   0,
-        source:   "\n",
-      }, {
-        message:  extra_line_msg,
-        severity: :convention,
-        line:     7,
-        column:   0,
-        source:   "\n",
-      }, {
-        message:  missing_line_msg,
-        severity: :convention,
-        line:     11,
-        column:   0,
-        source:   "  uninstall :quit => 'com.example.foo',",
-      }]
-    end
+    expect_correction <<~CASK
+      cask 'foo' do
+        arch arm: "arm64", intel: "x86_64"
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+        platform = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+
+        version :latest
+        sha256 :no_check
 
-    include_examples "reports offenses"
+        url 'https://foo.brew.sh/foo.zip'
+        name 'Foo'
+        homepage 'https://foo.brew.sh'
 
-    include_examples "autocorrects source"
+        app 'Foo.app'
+
+        uninstall :quit => 'com.example.foo',
+                  :kext => 'com.example.foo.kextextension'
+      end
+    CASK
   end
 
-  context "when caveats stanza is incorrectly grouped" do
-    let(:source) do
-      format(<<-CASK.undent, caveats: caveats.strip)
+  shared_examples "caveats" do
+    it "reports an offense for an incorrectly grouped `caveats` stanza" do
+      # Indent all except the first line.
+      interpolated_caveats = caveats.strip
+
+      expect_offense <<~CASK
         cask 'foo' do
           version :latest
           sha256 :no_check
           url 'https://foo.brew.sh/foo.zip'
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
           name 'Foo'
           app 'Foo.app'
-          %<caveats>s
+        ^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+          #{interpolated_caveats}
         end
       CASK
-    end
-    let(:correct_source) do
-      format(<<-CASK.undent, caveats: caveats.strip)
+
+      # Remove offense annotations.
+      corrected_caveats = interpolated_caveats.gsub(/\n\s*\^+\s+.*$/, "")
+
+      expect_correction <<~CASK
         cask 'foo' do
           version :latest
           sha256 :no_check
@@ -166,138 +209,232 @@
 
           app 'Foo.app'
 
-          %<caveats>s
+          #{corrected_caveats}
         end
       CASK
     end
+  end
 
-    context "when caveats is a one-line string" do
-      let(:caveats) { "caveats 'This is a one-line caveat.'" }
-
-      include_examples "autocorrects source"
+  context "when `caveats` is a one-line string" do
+    let(:caveats) do
+      <<~CAVEATS
+          caveats 'This is a one-line caveat.'
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+      CAVEATS
     end
 
-    context "when caveats is a heredoc" do
-      let(:caveats) do
-        <<-CAVEATS.undent
-          caveats <<-EOS.undent
-              This is a multiline caveat.
+    include_examples "caveats"
+  end
 
-              Let's hope it doesn't cause any problems!
-            EOS
-        CAVEATS
-      end
+  context "when `caveats` is a heredoc" do
+    let(:caveats) do
+      <<~CAVEATS
+          caveats <<~EOS
+        ^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+            This is a multiline caveat.
 
-      include_examples "autocorrects source"
+            Let's hope it doesn't cause any problems!
+          EOS
+      CAVEATS
     end
 
-    context "when caveats is a block" do
-      let(:caveats) do
-        <<-CAVEATS.undent
+    include_examples "caveats"
+  end
+
+  context "when `caveats` is a block" do
+    let(:caveats) do
+      <<~CAVEATS
           caveats do
-              puts 'This is a multiline caveat.'
+        ^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+            puts 'This is a multiline caveat.'
+
+            puts "Let's hope it doesn't cause any problems!"
+          end
+      CAVEATS
+    end
+
+    include_examples "caveats"
+  end
 
-              puts "Let's hope it doesn't cause any problems!"
-            end
-        CAVEATS
+  it "reports an offense for an incorrectly grouped `postflight` stanza" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        version :latest
+        sha256 :no_check
+        url 'https://foo.brew.sh/foo.zip'
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+        name 'Foo'
+        app 'Foo.app'
+      ^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+        postflight do
+      ^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+          puts 'We have liftoff!'
+        end
       end
+    CASK
 
-      include_examples "autocorrects source"
-    end
+    expect_correction <<~CASK
+      cask 'foo' do
+        version :latest
+        sha256 :no_check
+
+        url 'https://foo.brew.sh/foo.zip'
+        name 'Foo'
+
+        app 'Foo.app'
+
+        postflight do
+          puts 'We have liftoff!'
+        end
+      end
+    CASK
   end
 
-  context "when the postflight stanza is incorrectly grouped" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-          sha256 :no_check
-          url 'https://foo.brew.sh/foo.zip'
-          name 'Foo'
-          app 'Foo.app'
-          postflight do
-            puts 'We have liftoff!'
-          end
+  it "reports an offense for incorrectly grouped comments" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        version :latest
+        sha256 :no_check
+        # comment with an empty line between
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+
+        # comment directly above
+        postflight do
+          puts 'We have liftoff!'
         end
-      CASK
-    end
-    let(:correct_source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-          sha256 :no_check
+        url 'https://foo.brew.sh/foo.zip'
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+        name 'Foo'
+        app 'Foo.app'
+      ^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+      end
+    CASK
 
-          url 'https://foo.brew.sh/foo.zip'
-          name 'Foo'
+    expect_correction <<~CASK
+      cask 'foo' do
+        version :latest
+        sha256 :no_check
 
-          app 'Foo.app'
+        # comment with an empty line between
 
-          postflight do
-            puts 'We have liftoff!'
-          end
+        # comment directly above
+        postflight do
+          puts 'We have liftoff!'
         end
-      CASK
-    end
 
-    include_examples "autocorrects source"
+        url 'https://foo.brew.sh/foo.zip'
+        name 'Foo'
+
+        app 'Foo.app'
+      end
+    CASK
   end
 
-  context "when a stanza has a comment" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-          sha256 :no_check
-          # comment with an empty line between
+  it "reports an offense for incorrectly grouped comments and variable assignments" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        arch arm: "arm64", intel: "x86_64"
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+        # comment with an empty line between
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+        version :latest
+        sha256 :no_check
+
+        # comment directly above
+        postflight do
+          puts 'We have liftoff!'
+        end
+        url 'https://foo.brew.sh/foo.zip'
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+        name 'Foo'
+        app 'Foo.app'
+      ^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+      end
+    CASK
 
-          # comment directly above
-          postflight do
-            puts 'We have liftoff!'
-          end
-          url 'https://foo.brew.sh/foo.zip'
-          name 'Foo'
-          app 'Foo.app'
+    expect_correction <<~CASK
+      cask 'foo' do
+        arch arm: "arm64", intel: "x86_64"
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+
+        # comment with an empty line between
+        version :latest
+        sha256 :no_check
+
+        # comment directly above
+        postflight do
+          puts 'We have liftoff!'
         end
-      CASK
-    end
-    let(:correct_source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-          sha256 :no_check
 
-          # comment with an empty line between
+        url 'https://foo.brew.sh/foo.zip'
+        name 'Foo'
 
-          # comment directly above
-          postflight do
-            puts 'We have liftoff!'
-          end
+        app 'Foo.app'
+      end
+    CASK
+  end
 
-          url 'https://foo.brew.sh/foo.zip'
-          name 'Foo'
+  it "reports an offense for incorrectly grouped stanzas in `on_*` blocks" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        on_arm do
+          version "1.0.2"
 
-          app 'Foo.app'
+      ^{} stanzas within the same group should have no lines between them
+          sha256 :no_check
         end
-      CASK
-    end
+        on_intel do
+          version "0.9.8"
+          sha256 :no_check
+          url "https://foo.brew.sh/foo-intel.zip"
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ stanza groups should be separated by a single empty line
+        end
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        on_arm do
+          version "1.0.2"
+          sha256 :no_check
+        end
+        on_intel do
+          version "0.9.8"
+          sha256 :no_check
 
-    include_examples "autocorrects source"
+          url "https://foo.brew.sh/foo-intel.zip"
+        end
+      end
+    CASK
   end
 
-  # TODO: detect incorrectly grouped stanzas in nested expressions
-  context "when stanzas are nested in a conditional expression" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          if true
-            version :latest
+  it "reports an offense for incorrectly grouped stanzas with comments in `on_*` blocks" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        on_arm do
+          version "1.0.2"
 
-            sha256 :no_check
-          end
+      ^{} stanzas within the same group should have no lines between them
+          sha256 :no_check # comment on same line
         end
-      CASK
-    end
+        on_intel do
+          version "0.9.8"
+          sha256 :no_check
+        end
+      end
+    CASK
 
-    include_examples "does not report any offenses"
+    expect_correction <<~CASK
+      cask 'foo' do
+        on_arm do
+          version "1.0.2"
+          sha256 :no_check # comment on same line
+        end
+        on_intel do
+          version "0.9.8"
+          sha256 :no_check
+        end
+      end
+    CASK
   end
 end
diff --git a/Library/Homebrew/test/rubocops/cask/stanza_order_spec.rb b/Library/Homebrew/test/rubocops/cask/stanza_order_spec.rb
index c5cc7594a2f07..da7ce77168c75 100644
--- a/Library/Homebrew/test/rubocops/cask/stanza_order_spec.rb
+++ b/Library/Homebrew/test/rubocops/cask/stanza_order_spec.rb
@@ -1,309 +1,447 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/rubocop-cask"
-require "test/rubocops/cask/shared_examples/cask_cop"
 
-describe RuboCop::Cop::Cask::StanzaOrder do
-  include CaskCop
+RSpec.describe RuboCop::Cop::Cask::StanzaOrder, :config do
+  it "accepts a sole stanza" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        version :latest
+      end
+    CASK
+  end
 
-  subject(:cop) { described_class.new }
+  it "accepts when all stanzas are in order" do
+    expect_no_offenses <<~CASK
+      cask 'foo' do
+        arch arm: "arm", intel: "x86_64"
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+        version :latest
+        sha256 :no_check
+        foo = "bar"
+      end
+    CASK
+  end
 
-  context "when there is only one stanza" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-        end
-      CASK
-    end
+  it "reports an offense when stanzas are out of order" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        sha256 :no_check
+        ^^^^^^^^^^^^^^^^ `sha256` stanza out of order
+        version :latest
+        ^^^^^^^^^^^^^^^ `version` stanza out of order
+      end
+    CASK
 
-    include_examples "does not report any offenses"
+    expect_correction <<~CASK
+      cask 'foo' do
+        version :latest
+        sha256 :no_check
+      end
+    CASK
   end
 
-  context "when no stanzas are out of order" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-          sha256 :no_check
-        end
-      CASK
-    end
+  it "reports an offense when an `arch` stanza is out of order" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        version :latest
+        ^^^^^^^^^^^^^^^ `version` stanza out of order
+        sha256 :no_check
+        ^^^^^^^^^^^^^^^^ `sha256` stanza out of order
+        arch arm: "arm", intel: "x86_64"
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `arch` stanza out of order
+      end
+    CASK
 
-    include_examples "does not report any offenses"
+    expect_correction <<~CASK
+      cask 'foo' do
+        arch arm: "arm", intel: "x86_64"
+        version :latest
+        sha256 :no_check
+      end
+    CASK
   end
 
-  context "when one pair of stanzas is out of order" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          sha256 :no_check
-          version :latest
-        end
-      CASK
-    end
-    let(:correct_source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-          sha256 :no_check
-        end
-      CASK
-    end
-    let(:expected_offenses) do
-      [{
-        message:  "`sha256` stanza out of order",
-        severity: :convention,
-        line:     2,
-        column:   2,
-        source:   "sha256 :no_check",
-      }, {
-        message:  "`version` stanza out of order",
-        severity: :convention,
-        line:     3,
-        column:   2,
-        source:   "version :latest",
-      }]
-    end
+  it "reports an offense when an `on_arch_conditional` variable assignment is out of order" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        arch arm: "arm", intel: "x86_64"
+        sha256 :no_check
+        ^^^^^^^^^^^^^^^^ `sha256` stanza out of order
+        version :latest
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `on_arch_conditional` stanza out of order
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        arch arm: "arm", intel: "x86_64"
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+        version :latest
+        sha256 :no_check
+      end
+    CASK
+  end
 
-    include_examples "reports offenses"
+  it "reports an offense when an `on_arch_conditional` variable assignment is above an `arch` stanza" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `on_arch_conditional` stanza out of order
+        arch arm: "arm", intel: "x86_64"
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `arch` stanza out of order
+        version :latest
+        sha256 :no_check
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        arch arm: "arm", intel: "x86_64"
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+        version :latest
+        sha256 :no_check
+      end
+    CASK
+  end
 
-    include_examples "autocorrects source"
+  it "reports an offense when multiple stanzas are out of order" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        url 'https://foo.brew.sh/foo.zip'
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `url` stanza out of order
+        uninstall :quit => 'com.example.foo',
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `uninstall` stanza out of order
+                  :kext => 'com.example.foo.kext'
+        version :latest
+        ^^^^^^^^^^^^^^^ `version` stanza out of order
+        app 'Foo.app'
+        sha256 :no_check
+        ^^^^^^^^^^^^^^^^ `sha256` stanza out of order
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        version :latest
+        sha256 :no_check
+        url 'https://foo.brew.sh/foo.zip'
+        app 'Foo.app'
+        uninstall :quit => 'com.example.foo',
+                  :kext => 'com.example.foo.kext'
+      end
+    CASK
   end
 
-  context "when many stanzas are out of order" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          url 'https://foo.brew.sh/foo.zip'
-          uninstall :quit => 'com.example.foo',
-                    :kext => 'com.example.foo.kext'
-          version :latest
-          app 'Foo.app'
-          sha256 :no_check
-        end
-      CASK
-    end
-    let(:correct_source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-          sha256 :no_check
-          url 'https://foo.brew.sh/foo.zip'
-          app 'Foo.app'
-          uninstall :quit => 'com.example.foo',
-                    :kext => 'com.example.foo.kext'
+  it "does not reorder multiple stanzas of the same type" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        name 'Foo'
+        ^^^^^^^^^^ `name` stanza out of order
+        url 'https://foo.brew.sh/foo.zip'
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `url` stanza out of order
+        name 'FancyFoo'
+        ^^^^^^^^^^^^^^^ `name` stanza out of order
+        version :latest
+        ^^^^^^^^^^^^^^^ `version` stanza out of order
+        app 'Foo.app'
+        ^^^^^^^^^^^^^ `app` stanza out of order
+        sha256 :no_check
+        ^^^^^^^^^^^^^^^^ `sha256` stanza out of order
+        name 'FunkyFoo'
+        ^^^^^^^^^^^^^^^ `name` stanza out of order
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        version :latest
+        sha256 :no_check
+        url 'https://foo.brew.sh/foo.zip'
+        name 'Foo'
+        name 'FancyFoo'
+        name 'FunkyFoo'
+        app 'Foo.app'
+      end
+    CASK
+  end
+
+  it "keeps associated comments when auto-correcting" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        version :latest
+        # comment with an empty line between
+
+        # comment directly above
+        postflight do
+        ^^^^^^^^^^^^^ `postflight` stanza out of order
+          puts 'We have liftoff!'
         end
-      CASK
-    end
-    let(:expected_offenses) do
-      [{
-        message:  "`url` stanza out of order",
-        severity: :convention,
-        line:     2,
-        column:   2,
-        source:   "url 'https://foo.brew.sh/foo.zip'",
-      }, {
-        message:  "`uninstall` stanza out of order",
-        severity: :convention,
-        line:     3,
-        column:   2,
-        source:   "uninstall :quit => 'com.example.foo'," \
-                  "\n            :kext => 'com.example.foo.kext'",
-      }, {
-        message:  "`version` stanza out of order",
-        severity: :convention,
-        line:     5,
-        column:   2,
-        source:   "version :latest",
-      }, {
-        message:  "`sha256` stanza out of order",
-        severity: :convention,
-        line:     7,
-        column:   2,
-        source:   "sha256 :no_check",
-      }]
-    end
+        sha256 :no_check # comment on same line
+        ^^^^^^^^^^^^^^^^ `sha256` stanza out of order
+      end
+    CASK
 
-    include_examples "reports offenses"
+    expect_correction <<~CASK, loop: false
+      cask 'foo' do
+        version :latest
+        sha256 :no_check # comment on same line
+        # comment with an empty line between
+
+        # comment directly above
+        postflight do
+          puts 'We have liftoff!'
+        end
+      end
+    CASK
+  end
 
-    include_examples "autocorrects source"
+  it "reports an offense when an `on_arch_conditional` variable assignment with a comment is out of order" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        version :latest
+        ^^^^^^^^^^^^^^^ `version` stanza out of order
+        sha256 :no_check
+        ^^^^^^^^^^^^^^^^ `sha256` stanza out of order
+        # comment with an empty line between
+
+        # comment directly above
+        postflight do
+        ^^^^^^^^^^^^^ `postflight` stanza out of order
+          puts 'We have liftoff!'
+        end
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin" # comment on same line
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `on_arch_conditional` stanza out of order
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin" # comment on same line
+        version :latest
+        sha256 :no_check
+        # comment with an empty line between
+
+        # comment directly above
+        postflight do
+          puts 'We have liftoff!'
+        end
+      end
+    CASK
   end
 
-  context "when a stanza appears multiple times" do
-    let(:source) do
-      <<-CASK.undent
+  shared_examples "caveats" do
+    it "reports an offense when a `caveats` stanza is out of order" do
+      # Indent all except the first line.
+      interpolated_caveats = caveats.lines.map { |l| "  #{l}" }.join.strip
+
+      expect_offense <<~CASK
         cask 'foo' do
           name 'Foo'
+          ^^^^^^^^^^ `name` stanza out of order
           url 'https://foo.brew.sh/foo.zip'
-          name 'FancyFoo'
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `url` stanza out of order
+          #{interpolated_caveats}
           version :latest
+          ^^^^^^^^^^^^^^^ `version` stanza out of order
           app 'Foo.app'
           sha256 :no_check
-          name 'FunkyFoo'
+          ^^^^^^^^^^^^^^^^ `sha256` stanza out of order
         end
       CASK
-    end
-    let(:correct_source) do
-      <<-CASK.undent
+
+      # Remove offense annotations.
+      corrected_caveats = interpolated_caveats.gsub(/\n\s*\^+\s+.*$/, "")
+
+      expect_correction <<~CASK
         cask 'foo' do
           version :latest
           sha256 :no_check
           url 'https://foo.brew.sh/foo.zip'
           name 'Foo'
-          name 'FancyFoo'
-          name 'FunkyFoo'
           app 'Foo.app'
+          #{corrected_caveats}
         end
       CASK
     end
+  end
 
-    it "preserves the original order" do
-      expect_autocorrected_source(source, correct_source)
+  context "when caveats is a one-line string" do
+    let(:caveats) do
+      <<~CAVEATS
+        caveats 'This is a one-line caveat.'
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `caveats` stanza out of order
+      CAVEATS
     end
+
+    include_examples "caveats"
   end
 
-  context "when a stanza has a comment" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-          # comment with an empty line between
+  context "when caveats is a heredoc" do
+    let(:caveats) do
+      <<~CAVEATS
+        caveats <<~EOS
+        ^^^^^^^^^^^^^^ `caveats` stanza out of order
+          This is a multiline caveat.
 
-          # comment directly above
-          postflight do
-            puts 'We have liftoff!'
-          end
-          sha256 :no_check # comment on same line
-        end
-      CASK
+          Let's hope it doesn't cause any problems!
+        EOS
+      CAVEATS
     end
-    let(:correct_source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version :latest
-          sha256 :no_check # comment on same line
-          # comment with an empty line between
 
-          # comment directly above
-          postflight do
-            puts 'We have liftoff!'
-          end
+    include_examples "caveats"
+  end
+
+  context "when caveats is a block" do
+    let(:caveats) do
+      <<~CAVEATS
+        caveats do
+        ^^^^^^^^^^ `caveats` stanza out of order
+          puts 'This is a multiline caveat.'
+
+          puts "Let's hope it doesn't cause any problems!"
         end
-      CASK
+      CAVEATS
     end
 
-    include_examples "autocorrects source"
+    include_examples "caveats"
   end
 
-  context "when the caveats stanza is out of order" do
-    let(:source) do
-      format(<<-CASK.undent, caveats: caveats.strip)
-        cask 'foo' do
-          name 'Foo'
-          url 'https://foo.brew.sh/foo.zip'
-          %<caveats>s
+  it "reports an offense when the `postflight` stanza is out of order" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        name 'Foo'
+        ^^^^^^^^^^ `name` stanza out of order
+        url 'https://foo.brew.sh/foo.zip'
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `url` stanza out of order
+        postflight do
+        ^^^^^^^^^^^^^ `postflight` stanza out of order
+          puts 'We have liftoff!'
+        end
+        version :latest
+        ^^^^^^^^^^^^^^^ `version` stanza out of order
+        app 'Foo.app'
+        sha256 :no_check
+        ^^^^^^^^^^^^^^^^ `sha256` stanza out of order
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        version :latest
+        sha256 :no_check
+        url 'https://foo.brew.sh/foo.zip'
+        name 'Foo'
+        app 'Foo.app'
+        postflight do
+          puts 'We have liftoff!'
+        end
+      end
+    CASK
+  end
+
+  it "supports `on_arch` blocks and their contents" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        on_intel do
+        ^^^^^^^^^^^ `on_intel` stanza out of order
+          url "https://foo.brew.sh/foo-intel.zip"
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `url` stanza out of order
+
           version :latest
-          app 'Foo.app'
+          ^^^^^^^^^^^^^^^ `version` stanza out of order
           sha256 :no_check
+          ^^^^^^^^^^^^^^^^ `sha256` stanza out of order
         end
-      CASK
-    end
-    let(:correct_source) do
-      format(<<-CASK.undent, caveats: caveats.strip)
-        cask 'foo' do
+        on_arm do
+        ^^^^^^^^^ `on_arm` stanza out of order
           version :latest
           sha256 :no_check
-          url 'https://foo.brew.sh/foo.zip'
-          name 'Foo'
-          app 'Foo.app'
-          %<caveats>s
-        end
-      CASK
-    end
 
-    context "when caveats is a one-line string" do
-      let(:caveats) { "caveats 'This is a one-line caveat.'" }
-
-      include_examples "autocorrects source"
-    end
-
-    context "when caveats is a heredoc" do
-      let(:caveats) do
-        <<-CAVEATS.undent
-          caveats <<-EOS.undent
-              This is a multiline caveat.
-
-              Let's hope it doesn't cause any problems!
-            EOS
-        CAVEATS
+          url "https://foo.brew.sh/foo-arm.zip"
+        end
       end
+    CASK
 
-      include_examples "autocorrects source"
-    end
+    expect_correction <<~CASK
+      cask 'foo' do
+        on_arm do
+          version :latest
+          sha256 :no_check
 
-    context "when caveats is a block" do
-      let(:caveats) do
-        <<-CAVEATS.undent
-          caveats do
-              puts 'This is a multiline caveat.'
+          url "https://foo.brew.sh/foo-arm.zip"
+        end
+        on_intel do
+          version :latest
 
-              puts "Let's hope it doesn't cause any problems!"
-            end
-        CAVEATS
+          sha256 :no_check
+          url "https://foo.brew.sh/foo-intel.zip"
+        end
       end
-
-      include_examples "autocorrects source"
-    end
+    CASK
   end
 
-  context "when the postflight stanza is out of order" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          name 'Foo'
-          url 'https://foo.brew.sh/foo.zip'
-          postflight do
-            puts 'We have liftoff!'
-          end
+  it "registers an offense when `on_os` stanzas and their contents are out of order" do
+    expect_offense <<~CASK
+      cask "foo" do
+        on_ventura do
+        ^^^^^^^^^^^^^ `on_ventura` stanza out of order
+          sha256 "abc123"
+          ^^^^^^^^^^^^^^^ `sha256` stanza out of order
           version :latest
-          app 'Foo.app'
-          sha256 :no_check
+          ^^^^^^^^^^^^^^^ `version` stanza out of order
+          url "https://foo.brew.sh/foo-ventura.zip"
         end
-      CASK
-    end
-    let(:correct_source) do
-      <<-CASK.undent
-        cask 'foo' do
+        on_catalina do
+          sha256 "def456"
+          ^^^^^^^^^^^^^^^ `sha256` stanza out of order
+          version "0.7"
+          ^^^^^^^^^^^^^ `version` stanza out of order
+          url "https://foo.brew.sh/foo-catalina.zip"
+        end
+        on_mojave do
+        ^^^^^^^^^^^^ `on_mojave` stanza out of order
           version :latest
-          sha256 :no_check
-          url 'https://foo.brew.sh/foo.zip'
-          name 'Foo'
-          app 'Foo.app'
-          postflight do
-            puts 'We have liftoff!'
-          end
+          sha256 "ghi789"
+          url "https://foo.brew.sh/foo-mojave.zip"
         end
-      CASK
-    end
+        on_big_sur do
+        ^^^^^^^^^^^^^ `on_big_sur` stanza out of order
+          sha256 "jkl012"
+          ^^^^^^^^^^^^^^^ `sha256` stanza out of order
+          version :latest
+          ^^^^^^^^^^^^^^^ `version` stanza out of order
 
-    include_examples "autocorrects source"
-  end
+          url "https://foo.brew.sh/foo-big-sur.zip"
+        end
+      end
+    CASK
 
-  # TODO: detect out-of-order stanzas in nested expressions
-  context "when stanzas are nested in a conditional expression" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          if true
-            sha256 :no_check
-            version :latest
-          end
+    expect_correction <<~CASK
+      cask "foo" do
+        on_mojave do
+          version :latest
+          sha256 "ghi789"
+          url "https://foo.brew.sh/foo-mojave.zip"
         end
-      CASK
-    end
+        on_catalina do
+          version "0.7"
+          sha256 "def456"
+          url "https://foo.brew.sh/foo-catalina.zip"
+        end
+        on_big_sur do
+          version :latest
+          sha256 "jkl012"
 
-    include_examples "does not report any offenses"
+          url "https://foo.brew.sh/foo-big-sur.zip"
+        end
+        on_ventura do
+          version :latest
+          sha256 "abc123"
+          url "https://foo.brew.sh/foo-ventura.zip"
+        end
+      end
+    CASK
   end
 end
diff --git a/Library/Homebrew/test/rubocops/cask/uninstall_methods_order_spec.rb b/Library/Homebrew/test/rubocops/cask/uninstall_methods_order_spec.rb
new file mode 100644
index 0000000000000..6ebf72c0ef621
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/cask/uninstall_methods_order_spec.rb
@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+require "rubocops/rubocop-cask"
+RSpec.describe RuboCop::Cop::Cask::UninstallMethodsOrder, :config do
+  context "with uninstall blocks" do
+    context "when methods are incorrectly ordered" do
+      it "detects and corrects ordering offenses in the uninstall block when each method contains a single item" do
+        expect_offense(<<~CASK)
+          cask 'foo' do
+            uninstall quit:      "com.example.foo",
+                      ^^^^ `quit` method out of order
+                      launchctl: "com.example.foo"
+                      ^^^^^^^^^ `launchctl` method out of order
+          end
+        CASK
+
+        expect_correction(<<~CASK)
+          cask 'foo' do
+            uninstall launchctl: "com.example.foo",
+                      quit:      "com.example.foo"
+          end
+        CASK
+      end
+
+      it "detects and corrects ordering offenses in the uninstall block when methods contain arrays" do
+        expect_offense(<<~CASK)
+          cask "foo" do
+            url "https://example.com/foo.zip"
+
+          uninstall delete:  [
+                    ^^^^^^ `delete` method out of order
+                      "/usr/local/bin/foo",
+                      "/usr/local/bin/foobar",
+                    ],
+                    script:  {
+                    ^^^^^^ `script` method out of order
+                      executable: "/usr/local/bin/foo",
+                      sudo:       false,
+                    },
+                    pkgutil: "org.foo.bar"
+                    ^^^^^^^ `pkgutil` method out of order
+          end
+        CASK
+
+        expect_correction(<<~CASK)
+          cask "foo" do
+            url "https://example.com/foo.zip"
+
+          uninstall script:  {
+                      executable: "/usr/local/bin/foo",
+                      sudo:       false,
+                    },
+                    pkgutil: "org.foo.bar",
+                    delete:  [
+                      "/usr/local/bin/foo",
+                      "/usr/local/bin/foobar",
+                    ]
+          end
+        CASK
+      end
+    end
+
+    context "when methods are correctly ordered" do
+      it "does not report an offense" do
+        expect_no_offenses(<<~CASK)
+          cask "foo" do
+            url "https://example.com/foo.zip"
+
+            uninstall script:  {
+                        executable: "/usr/local/bin/foo",
+                        sudo:       false,
+                      },
+                      pkgutil: "org.foo.bar",
+                      delete:  [
+                        "/usr/local/bin/foo",
+                        "/usr/local/bin/foobar",
+                      ]
+          end
+        CASK
+      end
+    end
+
+    context "with a single method" do
+      it "does not report an offense when a single item is present in the method" do
+        expect_no_offenses(<<~CASK)
+          cask "foo" do
+            url "https://example.com/foo.zip"
+
+            uninstall delete: "/usr/local/bin/foo"
+          end
+        CASK
+      end
+
+      it "does not report an offense when the method contains an array" do
+        expect_no_offenses(<<~CASK)
+          cask "foo" do
+            url "https://example.com/foo.zip"
+
+            uninstall pkgutil: [
+              "org.foo.bar",
+              "org.foobar.bar",
+            ]
+          end
+        CASK
+      end
+    end
+  end
+
+  context "with zap blocks" do
+    context "when methods are incorrectly ordered" do
+      it "detects and corrects ordering offenses in the zap block when each method contains a single item" do
+        expect_offense(<<~CASK)
+          cask 'foo' do
+            zap rmdir: "/Library/Foo",
+                ^^^^^ `rmdir` method out of order
+                trash: "com.example.foo"
+                ^^^^^ `trash` method out of order
+          end
+        CASK
+
+        expect_correction(<<~CASK)
+          cask 'foo' do
+            zap trash: "com.example.foo",
+                rmdir: "/Library/Foo"
+          end
+        CASK
+      end
+
+      it "detects and corrects ordering offenses in the zap block when methods contain arrays" do
+        expect_offense(<<~CASK)
+          cask "foo" do
+            url "https://example.com/foo.zip"
+
+            zap delete: [
+                  "~/Library/Application Support/Foo",
+                  "~/Library/Application Support/Bar",
+                ],
+                rmdir: "~/Library/Application Support",
+                ^^^^^ `rmdir` method out of order
+                trash: "~/Library/Application Support/FooBar"
+                ^^^^^ `trash` method out of order
+          end
+        CASK
+
+        expect_correction(<<~CASK)
+          cask "foo" do
+            url "https://example.com/foo.zip"
+
+            zap delete: [
+                  "~/Library/Application Support/Foo",
+                  "~/Library/Application Support/Bar",
+                ],
+                trash: "~/Library/Application Support/FooBar",
+                rmdir: "~/Library/Application Support"
+          end
+        CASK
+      end
+    end
+
+    context "when methods are correctly ordered" do
+      it "does not report an offense" do
+        expect_no_offenses(<<~CASK)
+          cask "foo" do
+            url "https://example.com/foo.zip"
+
+            zap delete: [
+                  "~/Library/Application Support/Bar",
+                  "~/Library/Application Support/Foo",
+                ],
+                trash:  "~/Library/Application Support/FooBar",
+                rmdir:  "~/Library/Application Support"
+          end
+        CASK
+      end
+    end
+
+    context "with a single method" do
+      it "does not report an offense when a single item is present in the method" do
+        expect_no_offenses(<<~CASK)
+          cask "foo" do
+            url "https://example.com/foo.zip"
+
+            zap trash:  "~/Library/Application Support/FooBar"
+          end
+        CASK
+      end
+
+      it "does not report an offense when the method contains an array" do
+        expect_no_offenses(<<~CASK)
+          cask "foo" do
+            url "https://example.com/foo.zip"
+
+            zap trash: [
+              "~/Library/Application Support/FooBar",
+              "~/Library/Application Support/FooBarBar",
+            ]
+          end
+        CASK
+      end
+    end
+  end
+
+  context "with both uninstall and zap blocks" do
+    context "when both uninstall and zap methods are incorrectly ordered" do
+      it "detects offenses and auto-corrects to the correct order" do
+        expect_offense(<<~CASK)
+          cask "foo" do
+            url "https://example.com/foo.zip"
+
+            uninstall delete:  [
+                      ^^^^^^ `delete` method out of order
+                        "/usr/local/bin/foo",
+                        "/usr/local/bin/foobar",
+                      ],
+                      script:  {
+                      ^^^^^^ `script` method out of order
+                        executable: "/usr/local/bin/foo",
+                        sudo:       false,
+                      },
+                      pkgutil: "org.foo.bar"
+                      ^^^^^^^ `pkgutil` method out of order
+
+            zap delete: [
+                  "~/Library/Application Support/Bar",
+                  "~/Library/Application Support/Foo",
+                ],
+                rmdir:  "~/Library/Application Support",
+                ^^^^^ `rmdir` method out of order
+                trash:  "~/Library/Application Support/FooBar"
+                ^^^^^ `trash` method out of order
+          end
+        CASK
+
+        expect_correction(<<~CASK)
+          cask "foo" do
+            url "https://example.com/foo.zip"
+
+            uninstall script:  {
+                        executable: "/usr/local/bin/foo",
+                        sudo:       false,
+                      },
+                      pkgutil: "org.foo.bar",
+                      delete:  [
+                        "/usr/local/bin/foo",
+                        "/usr/local/bin/foobar",
+                      ]
+
+            zap delete: [
+                  "~/Library/Application Support/Bar",
+                  "~/Library/Application Support/Foo",
+                ],
+                trash:  "~/Library/Application Support/FooBar",
+                rmdir:  "~/Library/Application Support"
+          end
+        CASK
+      end
+    end
+
+    context "when uninstall and zap methods are correctly ordered" do
+      it "does not report an offense" do
+        expect_no_offenses(<<~CASK)
+          cask 'foo' do
+            uninstall early_script: {
+                        executable: "foo.sh",
+                        args:       ["--unattended"],
+                      },
+                      launchctl:    "com.example.foo",
+                      quit:         "com.example.foo",
+                      signal:       ["TERM", "com.example.foo"],
+                      login_item:   "FooApp",
+                      kext:         "com.example.foo",
+                      script:       {
+                        executable: "foo.sh",
+                        args:       ["--unattended"],
+                      },
+                      pkgutil:      "com.example.foo",
+                      delete:       "~/Library/Preferences/com.example.foo",
+                      trash:        "~/Library/Preferences/com.example.foo",
+                      rmdir:        "~/Library/Foo"
+
+            zap early_script: {
+                  executable: "foo.sh",
+                  args:       ["--unattended"],
+                },
+                launchctl:    "com.example.foo",
+                quit:         "com.example.foo",
+                signal:       ["TERM", "com.example.foo"],
+                login_item:   "FooApp",
+                kext:         "com.example.foo",
+                script:       {
+                  executable: "foo.sh",
+                  args:       ["--unattended"],
+                },
+                pkgutil:      "com.example.foo",
+                delete:       "~/Library/Preferences/com.example.foo",
+                trash:        "~/Library/Preferences/com.example.foo",
+                rmdir:        "~/Library/Foo"
+          end
+        CASK
+      end
+    end
+  end
+
+  context "when in-line comments are present" do
+    it "keeps associated comments when auto-correcting" do
+      expect_offense <<~CASK
+        cask 'foo' do
+          uninstall quit:      "com.example.foo", # comment on same line
+                    ^^^^ `quit` method out of order
+                    launchctl: "com.example.foo"
+                    ^^^^^^^^^ `launchctl` method out of order
+        end
+      CASK
+
+      expect_correction <<~CASK
+        cask 'foo' do
+          uninstall launchctl: "com.example.foo",
+                    quit:      "com.example.foo" # comment on same line
+        end
+      CASK
+    end
+  end
+
+  context "when methods are inside an `on_os` block" do
+    it "detects and corrects offenses within OS-specific blocks" do
+      expect_offense <<~CASK
+        cask "foo" do
+          on_catalina do
+            uninstall trash:     "com.example.foo",
+                      ^^^^^ `trash` method out of order
+                      launchctl: "com.example.foo"
+                      ^^^^^^^^^ `launchctl` method out of order
+          end
+          on_ventura do
+            uninstall quit:      "com.example.foo",
+                      ^^^^ `quit` method out of order
+                      launchctl: "com.example.foo"
+                      ^^^^^^^^^ `launchctl` method out of order
+          end
+        end
+      CASK
+
+      expect_correction <<~CASK
+        cask "foo" do
+          on_catalina do
+            uninstall launchctl: "com.example.foo",
+                      trash:     "com.example.foo"
+          end
+          on_ventura do
+            uninstall launchctl: "com.example.foo",
+                      quit:      "com.example.foo"
+          end
+        end
+      CASK
+    end
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/cask/url_legacy_comma_separators_spec.rb b/Library/Homebrew/test/rubocops/cask/url_legacy_comma_separators_spec.rb
index cd2ecee8e4e87..1fe0e63c3b9a5 100644
--- a/Library/Homebrew/test/rubocops/cask/url_legacy_comma_separators_spec.rb
+++ b/Library/Homebrew/test/rubocops/cask/url_legacy_comma_separators_spec.rb
@@ -1,103 +1,57 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/rubocop-cask"
-require "test/rubocops/cask/shared_examples/cask_cop"
 
-describe RuboCop::Cop::Cask::UrlLegacyCommaSeparators do
-  include CaskCop
-
-  subject(:cop) { described_class.new }
-
-  context "when url version interpolation does not include version.before_comma or version.after_comma" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version '1.1'
-          url 'https://foo.brew.sh/foo-\#{version}.dmg'
-        end
-      CASK
-    end
-
-    include_examples "does not report any offenses"
+RSpec.describe RuboCop::Cop::Cask::UrlLegacyCommaSeparators, :config do
+  it "accepts a simple `version` interpolation" do
+    expect_no_offenses <<~'CASK'
+      cask 'foo' do
+        version '1.1'
+        url 'https://foo.brew.sh/foo-#{version}.dmg'
+      end
+    CASK
   end
 
-  context "when the url uses csv" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version '1.1,111'
-          url 'https://foo.brew.sh/foo-\#{version.csv.first}.dmg'
-        end
-      CASK
-    end
-
-    include_examples "does not report any offenses"
+  it "accepts an interpolation using `version.csv`" do
+    expect_no_offenses <<~'CASK'
+      cask 'foo' do
+        version '1.1,111'
+        url 'https://foo.brew.sh/foo-#{version.csv.first}.dmg'
+      end
+    CASK
   end
 
-  context "when the url uses version.before_comma" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version '1.1,111'
-          url 'https://foo.brew.sh/foo-\#{version.before_comma}.dmg'
-        end
-      CASK
-    end
-    let(:correct_source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version '1.1,111'
-          url 'https://foo.brew.sh/foo-\#{version.csv.first}.dmg'
-        end
-      CASK
-    end
-    let(:expected_offenses) do
-      [{
-        message:  "Use 'version.csv.first' instead of 'version.before_comma' " \
-                  "and 'version.csv.second' instead of 'version.after_comma'",
-        severity: :convention,
-        line:     3,
-        column:   6,
-        source:   "'https://foo.brew.sh/foo-\#{version.before_comma}.dmg'",
-      }]
-    end
-
-    include_examples "reports offenses"
-
-    include_examples "autocorrects source"
+  it "reports an offense for an interpolation using `version.before_comma`" do
+    expect_offense <<~'CASK'
+      cask 'foo' do
+        version '1.1,111'
+        url 'https://foo.brew.sh/foo-#{version.before_comma}.dmg'
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `version.csv.first` instead of `version.before_comma` and `version.csv.second` instead of `version.after_comma`.
+      end
+    CASK
+
+    expect_correction <<~'CASK'
+      cask 'foo' do
+        version '1.1,111'
+        url 'https://foo.brew.sh/foo-#{version.csv.first}.dmg'
+      end
+    CASK
   end
 
-  context "when the url uses version.after_comma" do
-    let(:source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version '1.1,111'
-          url 'https://foo.brew.sh/foo-\#{version.after_comma}.dmg'
-        end
-      CASK
-    end
-    let(:correct_source) do
-      <<-CASK.undent
-        cask 'foo' do
-          version '1.1,111'
-          url 'https://foo.brew.sh/foo-\#{version.csv.second}.dmg'
-        end
-      CASK
-    end
-    let(:expected_offenses) do
-      [{
-        message:  "Use 'version.csv.first' instead of 'version.before_comma' " \
-                  "and 'version.csv.second' instead of 'version.after_comma'",
-        severity: :convention,
-        line:     3,
-        column:   6,
-        source:   "'https://foo.brew.sh/foo-\#{version.after_comma}.dmg'",
-      }]
-    end
-
-    include_examples "reports offenses"
-
-    include_examples "autocorrects source"
+  it "reports an offense for an interpolation using `version.after_comma`" do
+    expect_offense <<~'CASK'
+      cask 'foo' do
+        version '1.1,111'
+        url 'https://foo.brew.sh/foo-#{version.after_comma}.dmg'
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `version.csv.first` instead of `version.before_comma` and `version.csv.second` instead of `version.after_comma`.
+      end
+    CASK
+
+    expect_correction <<~'CASK'
+      cask 'foo' do
+        version '1.1,111'
+        url 'https://foo.brew.sh/foo-#{version.csv.second}.dmg'
+      end
+    CASK
   end
 end
diff --git a/Library/Homebrew/test/rubocops/cask/url_spec.rb b/Library/Homebrew/test/rubocops/cask/url_spec.rb
new file mode 100644
index 0000000000000..e842ad1ea8915
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/cask/url_spec.rb
@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "rubocops/rubocop-cask"
+
+RSpec.describe RuboCop::Cop::Cask::Url, :config do
+  it "allows regular `url` blocks in homebrew-cask" do
+    expect_no_offenses <<~CASK, "/homebrew-cask/Casks/f/foo.rb"
+      cask "foo" do
+        url "https://example.com/download/foo-v1.2.0.dmg",
+            verified: "example.com/download/"
+      end
+    CASK
+  end
+
+  it "does not allow `url do` blocks in homebrew-cask" do
+    expect_offense <<~CASK, "/homebrew-cask/Casks/f/foo.rb"
+      cask "foo" do
+        url "https://example.com/download/foo-v1.2.0.dmg" do |url|
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not use `url "..." do` blocks in Homebrew/homebrew-cask.
+          url
+        end
+      end
+    CASK
+  end
+
+  it "allows regular `url` blocks in a non-homebrew-cask tap" do
+    expect_no_offenses <<~CASK, "/homebrew-tap/Casks/f/foo.rb"
+      cask "foo" do
+        url "https://example.com/download/foo-v1.2.0.dmg",
+            verified: "example.com/download/"
+      end
+    CASK
+  end
+
+  it "allows `url do` blocks in a non-homebrew-cask tap" do
+    expect_no_offenses <<~CASK, "/homebrew-tap/Casks/f/foo.rb"
+      cask "foo" do
+        url "https://example.com/download/foo-v1.2.0.dmg" do |url|
+          url
+        end
+      end
+    CASK
+  end
+
+  it "accepts a `verified` value that does not start with a protocol" do
+    expect_no_offenses <<~CASK
+      cask "foo" do
+        url "https://example.com/download/foo-v1.2.0.dmg",
+            verified: "example.com/download/"
+      end
+    CASK
+  end
+
+  it "reports an offense for a `verified` value that starts with a protocol" do
+    expect_offense <<~CASK
+      cask "foo" do
+        url "https://example.com/download/foo-v1.2.0.dmg",
+            verified: "https://example.com/download/"
+                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Verified URL parameter value should not contain a URL scheme.
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask "foo" do
+        url "https://example.com/download/foo-v1.2.0.dmg",
+            verified: "example.com/download/"
+      end
+    CASK
+  end
+
+  context "when then URL does not have a path and ends with a /" do
+    it "accepts a `verified` value ending with a /" do
+      expect_no_offenses <<~CASK
+        cask "foo" do
+          url "https://example.org/",
+              verified: "example.org/"
+        end
+      CASK
+    end
+
+    it "reports an offense for a `verified` value not ending a /" do
+      expect_offense <<~CASK
+        cask "foo" do
+          url "https://example.org/",
+              verified: "example.org"
+                        ^^^^^^^^^^^^^ Verified URL parameter value should end with a /.
+        end
+      CASK
+
+      expect_correction <<~CASK
+        cask "foo" do
+          url "https://example.org/",
+              verified: "example.org/"
+        end
+      CASK
+    end
+  end
+
+  context "when the URL has a path and does not end with a /" do
+    it "accepts a `verified` value with one path component" do
+      expect_no_offenses <<~CASK
+        cask "foo" do
+          url "https://github.com/Foo",
+              verified: "github.com/Foo"
+        end
+      CASK
+    end
+
+    it "accepts a `verified` value with two path components" do
+      expect_no_offenses <<~CASK
+        cask "foo" do
+          url "https://github.com/foo/foo.git",
+              verified: "github.com/foo/foo"
+        end
+      CASK
+    end
+  end
+
+  context "when the url ends with a /" do
+    it "accepts a `verified` value ending with a /" do
+      expect_no_offenses <<~CASK
+        cask "foo" do
+          url "https://github.com/",
+              verified: "github.com/"
+        end
+      CASK
+    end
+
+    it "reports an offense for a `verified` value not ending with a /" do
+      expect_offense <<~CASK
+        cask "foo" do
+          url "https://github.com/",
+              verified: "github.com"
+                        ^^^^^^^^^^^^ Verified URL parameter value should end with a /.
+        end
+      CASK
+
+      expect_correction <<~CASK
+        cask "foo" do
+          url "https://github.com/",
+              verified: "github.com/"
+        end
+      CASK
+    end
+  end
+
+  it "accepts a `verified` value with a path ending with a /" do
+    expect_no_offenses <<~CASK
+      cask "foo" do
+        url "https://github.com/Foo/foo/releases/download/v1.2.0/foo-v1.2.0.dmg",
+            verified: "github.com/Foo/foo/"
+      end
+    CASK
+  end
+
+  context "when the URL uses interpolation" do
+    it "accepts a `verified` value with a path ending with a /" do
+      expect_no_offenses <<~CASK
+        cask "foo" do
+          version "1.2.3"
+          url "Cask/Url: https://example.com/download/foo-v\#{version}.dmg",
+              verified: "example.com/download/"
+        end
+      CASK
+    end
+  end
+
+  it "reports an offense for a `verified` value with a path component that doesn't end with a /" do
+    expect_offense <<~CASK
+      cask "foo" do
+        url "https://github.com/Foo/foo/releases/download/v1.2.0/foo-v1.2.0.dmg",
+            verified: "github.com/Foo/foo"
+                      ^^^^^^^^^^^^^^^^^^^^ Verified URL parameter value should end with a /.
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask "foo" do
+        url "https://github.com/Foo/foo/releases/download/v1.2.0/foo-v1.2.0.dmg",
+            verified: "github.com/Foo/foo/"
+      end
+    CASK
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/cask/variables_spec.rb b/Library/Homebrew/test/rubocops/cask/variables_spec.rb
new file mode 100644
index 0000000000000..b597a584eee7a
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/cask/variables_spec.rb
@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "rubocops/rubocop-cask"
+
+RSpec.describe RuboCop::Cop::Cask::Variables, :config do
+  it "accepts when there are no variables" do
+    expect_no_offenses <<~CASK
+      cask "foo" do
+        version :latest
+      end
+    CASK
+  end
+
+  it "accepts when there is an `arch` stanza" do
+    expect_no_offenses <<~CASK
+      cask "foo" do
+        arch arm: "darwin-arm64", intel: "darwin"
+      end
+    CASK
+  end
+
+  it "accepts an `on_arch_conditional` variable" do
+    expect_no_offenses <<~CASK
+      cask "foo" do
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+      end
+    CASK
+  end
+
+  it "reports an offense for an `arch` variable using strings" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        arch = Hardware::CPU.intel? ? "darwin" : "darwin-arm64"
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `arch arm: "darwin-arm64", intel: "darwin"` instead of `arch = Hardware::CPU.intel? ? "darwin" : "darwin-arm64"`.
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        arch arm: "darwin-arm64", intel: "darwin"
+      end
+    CASK
+  end
+
+  it "reports an offense for an `arch` variable using symbols" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        arch = Hardware::CPU.intel? ? :darwin : :darwin_arm64
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `arch arm: :darwin_arm64, intel: :darwin` instead of `arch = Hardware::CPU.intel? ? :darwin : :darwin_arm64`.
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        arch arm: :darwin_arm64, intel: :darwin
+      end
+    CASK
+  end
+
+  it "reports an offense for an `arch` variable with an empty string" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        arch = Hardware::CPU.intel? ? "" : "arm64"
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `arch arm: "arm64"` instead of `arch = Hardware::CPU.intel? ? "" : "arm64"`.
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        arch arm: "arm64"
+      end
+    CASK
+  end
+
+  it "reports an offense for a non-`arch` variable using strings" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        folder = Hardware::CPU.intel? ? "darwin" : "darwin-arm64"
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"` instead of `folder = Hardware::CPU.intel? ? "darwin" : "darwin-arm64"`.
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+      end
+    CASK
+  end
+
+  it "reports an offense for a non-`arch` variable with an empty string" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        folder = Hardware::CPU.intel? ? "amd64" : ""
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `folder = on_arch_conditional intel: "amd64"` instead of `folder = Hardware::CPU.intel? ? "amd64" : ""`.
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        folder = on_arch_conditional intel: "amd64"
+      end
+    CASK
+  end
+
+  it "reports an offense for consecutive `arch` and non-`arch` variables" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        arch = Hardware::CPU.arm? ? "darwin-arm64" : "darwin"
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `arch arm: "darwin-arm64", intel: "darwin"` instead of `arch = Hardware::CPU.arm? ? "darwin-arm64" : "darwin"`.
+        folder = Hardware::CPU.arm? ? "darwin-arm64" : "darwin"
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"` instead of `folder = Hardware::CPU.arm? ? "darwin-arm64" : "darwin"`.
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        arch arm: "darwin-arm64", intel: "darwin"
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+      end
+    CASK
+  end
+
+  it "reports an offense for two consecutive non-`arch` variables" do
+    expect_offense <<~CASK
+      cask 'foo' do
+        folder = Hardware::CPU.arm? ? "darwin-arm64" : "darwin"
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"` instead of `folder = Hardware::CPU.arm? ? "darwin-arm64" : "darwin"`.
+        platform = Hardware::CPU.intel? ? "darwin": "darwin-arm64"
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `platform = on_arch_conditional arm: "darwin-arm64", intel: "darwin"` instead of `platform = Hardware::CPU.intel? ? "darwin": "darwin-arm64"`.
+      end
+    CASK
+
+    expect_correction <<~CASK
+      cask 'foo' do
+        folder = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+        platform = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
+      end
+    CASK
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/caveats_spec.rb b/Library/Homebrew/test/rubocops/caveats_spec.rb
index 1d161b6901286..93a80060bec40 100644
--- a/Library/Homebrew/test/rubocops/caveats_spec.rb
+++ b/Library/Homebrew/test/rubocops/caveats_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/caveats"
 
-describe RuboCop::Cop::FormulaAudit::Caveats do
+RSpec.describe RuboCop::Cop::FormulaAudit::Caveats do
   subject(:cop) { described_class.new }
 
   context "when auditing `caveats`" do
@@ -14,7 +13,31 @@ class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
            def caveats
             "setuid"
-            ^^^^^^^^ Don\'t recommend setuid in the caveats, suggest sudo instead.
+            ^^^^^^^^ FormulaAudit/Caveats: Don't recommend `setuid` in the caveats, suggest `sudo` instead.
+          end
+        end
+      RUBY
+    end
+
+    it "reports an offense if an escape character is present" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          homepage "https://brew.sh/foo"
+          url "https://brew.sh/foo-1.0.tgz"
+           def caveats
+            "\\x1B"
+            ^^^^^^ FormulaAudit/Caveats: Don't use ANSI escape codes in the caveats.
+          end
+        end
+      RUBY
+
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          homepage "https://brew.sh/foo"
+          url "https://brew.sh/foo-1.0.tgz"
+           def caveats
+            "\\u001b"
+            ^^^^^^^^ FormulaAudit/Caveats: Don't use ANSI escape codes in the caveats.
           end
         end
       RUBY
diff --git a/Library/Homebrew/test/rubocops/checksum/checksum_case_spec.rb b/Library/Homebrew/test/rubocops/checksum/checksum_case_spec.rb
index b66c2a163d438..c05e29827d638 100644
--- a/Library/Homebrew/test/rubocops/checksum/checksum_case_spec.rb
+++ b/Library/Homebrew/test/rubocops/checksum/checksum_case_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/checksum"
 
-describe RuboCop::Cop::FormulaAudit::ChecksumCase do
+RSpec.describe RuboCop::Cop::FormulaAudit::ChecksumCase do
   subject(:cop) { described_class.new }
 
   context "when auditing spec checksums" do
@@ -14,12 +13,12 @@ class Foo < Formula
           stable do
             url "https://github.com/foo-lang/foo-compiler/archive/0.18.0.tar.gz"
             sha256 "5cf6e1ae0A645b426c0a7cc7cd3f7d1605ffa1ac5756a39a8b2268ddc7ea0e9a"
-                             ^ sha256 should be lowercase
+                             ^ FormulaAudit/ChecksumCase: sha256 should be lowercase
 
             resource "foo-package" do
               url "https://github.com/foo-lang/foo-package/archive/0.18.0.tar.gz"
               sha256 "5cf6e1Ae0a645b426b047aa4cc7cd3f7d1605ffa1ac5756a39a8b2268ddc7ea9"
-                            ^ sha256 should be lowercase
+                            ^ FormulaAudit/ChecksumCase: sha256 should be lowercase
             end
           end
         end
@@ -33,7 +32,7 @@ class Foo < Formula
           resource "foo-outside" do
             url "https://github.com/foo-lang/foo-outside/archive/0.18.0.tar.gz"
             sha256 "A4cc7cd3f7d1605ffa1ac5755cf6e1ae0a645b426b047a6a39a8b2268ddc7ea9"
-                    ^ sha256 should be lowercase
+                    ^ FormulaAudit/ChecksumCase: sha256 should be lowercase
           end
           stable do
             url "https://github.com/foo-lang/foo-compiler/archive/0.18.0.tar.gz"
diff --git a/Library/Homebrew/test/rubocops/checksum/checksum_spec.rb b/Library/Homebrew/test/rubocops/checksum/checksum_spec.rb
index ac8f05bc2869c..a50b7122a782a 100644
--- a/Library/Homebrew/test/rubocops/checksum/checksum_spec.rb
+++ b/Library/Homebrew/test/rubocops/checksum/checksum_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/checksum"
 
-describe RuboCop::Cop::FormulaAudit::Checksum do
+RSpec.describe RuboCop::Cop::FormulaAudit::Checksum do
   subject(:cop) { described_class.new }
 
   context "when auditing spec checksums" do
@@ -14,12 +13,12 @@ class Foo < Formula
           stable do
             url "https://github.com/foo-lang/foo-compiler/archive/0.18.0.tar.gz"
             sha256 ""
-                   ^^ sha256 is empty
+                   ^^ FormulaAudit/Checksum: sha256 is empty
 
             resource "foo-package" do
               url "https://github.com/foo-lang/foo-package/archive/0.18.0.tar.gz"
               sha256 ""
-                     ^^ sha256 is empty
+                     ^^ FormulaAudit/Checksum: sha256 is empty
             end
           end
         end
@@ -33,12 +32,12 @@ class Foo < Formula
           stable do
             url "https://github.com/foo-lang/foo-compiler/archive/0.18.0.tar.gz"
             sha256 "5cf6e1ae0a645b426c0474cc7cd3f7d1605ffa1ac5756a39a8b2268ddc7ea0e9ad"
-                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ sha256 should be 64 characters
+                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Checksum: sha256 should be 64 characters
 
             resource "foo-package" do
               url "https://github.com/foo-lang/foo-package/archive/0.18.0.tar.gz"
               sha256 "5cf6e1ae0a645b426c047aaa4cc7cd3f7d1605ffa1ac5756a39a8b2268ddc7ea0e9"
-                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ sha256 should be 64 characters
+                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Checksum: sha256 should be 64 characters
             end
           end
         end
@@ -52,12 +51,12 @@ class Foo < Formula
           stable do
             url "https://github.com/foo-lang/foo-compiler/archive/0.18.0.tar.gz"
             sha256 "5cf6e1ae0a645b426c0k7cc7cd3f7d1605ffa1ac5756a39a8b2268ddc7ea0e9a"
-                                       ^ sha256 contains invalid characters
+                                       ^ FormulaAudit/Checksum: sha256 contains invalid characters
 
             resource "foo-package" do
               url "https://github.com/foo-lang/foo-package/archive/0.18.0.tar.gz"
               sha256 "5cf6e1ae0a645b426x047aa4cc7cd3f7d1605ffa1ac5756a39a8b2268ddc7ea9"
-                                       ^ sha256 contains invalid characters
+                                       ^ FormulaAudit/Checksum: sha256 contains invalid characters
             end
           end
         end
@@ -71,7 +70,7 @@ class Foo < Formula
 
           bottle do
             sha256 catalina: "5cf6e1ae0a645b426c0474cc7cd3f7d1605ffa1ac5756a39a8b2268ddc7ea0e9ad"
-                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ sha256 should be 64 characters
+                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Checksum: sha256 should be 64 characters
           end
         end
       RUBY
@@ -84,7 +83,7 @@ class Foo < Formula
 
           bottle do
             sha256 cellar: :any, catalina: "5cf6e1ae0a645b426c0474cc7cd3f7d1605ffa1ac5756a39a8b2268ddc7ea0e9ad"
-                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ sha256 should be 64 characters
+                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Checksum: sha256 should be 64 characters
           end
         end
       RUBY
diff --git a/Library/Homebrew/test/rubocops/class/class_name_spec.rb b/Library/Homebrew/test/rubocops/class/class_name_spec.rb
index edee9ce238eb3..78050236a1df7 100644
--- a/Library/Homebrew/test/rubocops/class/class_name_spec.rb
+++ b/Library/Homebrew/test/rubocops/class/class_name_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/class"
 
-describe RuboCop::Cop::FormulaAudit::ClassName do
+RSpec.describe RuboCop::Cop::FormulaAudit::ClassName do
   subject(:cop) { described_class.new }
 
   corrected_source = <<~RUBY
@@ -15,7 +14,7 @@ class Foo < Formula
   it "reports and corrects an offense when using ScriptFileFormula" do
     expect_offense(<<~RUBY)
       class Foo < ScriptFileFormula
-                  ^^^^^^^^^^^^^^^^^ ScriptFileFormula is deprecated, use Formula instead
+                  ^^^^^^^^^^^^^^^^^ FormulaAudit/ClassName: ScriptFileFormula is deprecated, use Formula instead
         url 'https://brew.sh/foo-1.0.tgz'
       end
     RUBY
@@ -25,7 +24,7 @@ class Foo < ScriptFileFormula
   it "reports and corrects an offense when using GithubGistFormula" do
     expect_offense(<<~RUBY)
       class Foo < GithubGistFormula
-                  ^^^^^^^^^^^^^^^^^ GithubGistFormula is deprecated, use Formula instead
+                  ^^^^^^^^^^^^^^^^^ FormulaAudit/ClassName: GithubGistFormula is deprecated, use Formula instead
         url 'https://brew.sh/foo-1.0.tgz'
       end
     RUBY
@@ -35,7 +34,7 @@ class Foo < GithubGistFormula
   it "reports and corrects an offense when using AmazonWebServicesFormula" do
     expect_offense(<<~RUBY)
       class Foo < AmazonWebServicesFormula
-                  ^^^^^^^^^^^^^^^^^^^^^^^^ AmazonWebServicesFormula is deprecated, use Formula instead
+                  ^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ClassName: AmazonWebServicesFormula is deprecated, use Formula instead
         url 'https://brew.sh/foo-1.0.tgz'
       end
     RUBY
diff --git a/Library/Homebrew/test/rubocops/class/test_present.rb b/Library/Homebrew/test/rubocops/class/test_present.rb
index 2728fcc07407f..106863ac88bd5 100644
--- a/Library/Homebrew/test/rubocops/class/test_present.rb
+++ b/Library/Homebrew/test/rubocops/class/test_present.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/class"
 
-describe RuboCop::Cop::FormulaAuditStrict::TestPresent do
+RSpec.describe RuboCop::Cop::FormulaAuditStrict::TestPresent do
   subject(:cop) { described_class.new }
 
   it "reports an offense when there is no test block" do
@@ -14,4 +13,14 @@ class Foo < Formula
       end
     RUBY
   end
+
+  it "reports no offenses when there is no test block and formula is disabled" do
+    expect_no_offenses(<<~RUBY)
+      class Foo < Formula
+        url 'https://brew.sh/foo-1.0.tgz'
+
+        disable! date: "2024-07-03", because: :unsupported
+      end
+    RUBY
+  end
 end
diff --git a/Library/Homebrew/test/rubocops/class/test_spec.rb b/Library/Homebrew/test/rubocops/class/test_spec.rb
index b9b03161b8bf8..cabeddb71ee2a 100644
--- a/Library/Homebrew/test/rubocops/class/test_spec.rb
+++ b/Library/Homebrew/test/rubocops/class/test_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/class"
 
-describe RuboCop::Cop::FormulaAudit::Test do
+RSpec.describe RuboCop::Cop::FormulaAudit::Test do
   subject(:cop) { described_class.new }
 
   it "reports and corrects an offense when /usr/local/bin is found in test calls" do
@@ -13,7 +12,7 @@ class Foo < Formula
 
         test do
           system "/usr/local/bin/test"
-                 ^^^^^^^^^^^^^^^^^^^^^ use \#{bin} instead of /usr/local/bin in system
+                 ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Test: use \#{bin} instead of /usr/local/bin in system
         end
       end
     RUBY
@@ -36,7 +35,7 @@ class Foo < Formula
 
         test do
           shell_output("\#{bin}/test", 0)
-                                      ^ Passing 0 to shell_output() is redundant
+                                      ^ FormulaAudit/Test: Passing 0 to shell_output() is redundant
         end
       end
     RUBY
@@ -58,7 +57,7 @@ class Foo < Formula
         url 'https://brew.sh/foo-1.0.tgz'
 
         test do
-        ^^^^^^^ `test do` should not be empty
+        ^^^^^^^ FormulaAudit/Test: `test do` should not be empty
         end
       end
     RUBY
@@ -70,7 +69,7 @@ class Foo < Formula
         url 'https://brew.sh/foo-1.0.tgz'
 
         test do
-        ^^^^^^^ `test do` should contain a real test
+        ^^^^^^^ FormulaAudit/Test: `test do` should contain a real test
           true
         end
       end
diff --git a/Library/Homebrew/test/rubocops/compact_blank_spec.rb b/Library/Homebrew/test/rubocops/compact_blank_spec.rb
new file mode 100644
index 0000000000000..5e0917f95c91b
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/compact_blank_spec.rb
@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "rubocops/compact_blank"
+
+RSpec.describe RuboCop::Cop::Homebrew::CompactBlank, :config do
+  it "registers and corrects an offense when using `reject { |e| e.blank? }`" do
+    expect_offense(<<~RUBY)
+      collection.reject { |e| e.blank? }
+                 ^^^^^^^^^^^^^^^^^^^^^^^ Use `compact_blank` instead.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      collection.compact_blank
+    RUBY
+  end
+
+  it "registers and corrects an offense when using `reject(&:blank?)`" do
+    expect_offense(<<~RUBY)
+      collection.reject(&:blank?)
+                 ^^^^^^^^^^^^^^^^ Use `compact_blank` instead.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      collection.compact_blank
+    RUBY
+  end
+
+  it "registers and corrects an offense when using `delete_if { |e| e.blank? }`" do
+    expect_offense(<<~RUBY)
+      collection.delete_if { |e| e.blank? }
+                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `compact_blank!` instead.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      collection.compact_blank!
+    RUBY
+  end
+
+  it "registers and corrects an offense when using `delete_if(&:blank?)`" do
+    expect_offense(<<~RUBY)
+      collection.delete_if(&:blank?)
+                 ^^^^^^^^^^^^^^^^^^^ Use `compact_blank!` instead.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      collection.compact_blank!
+    RUBY
+  end
+
+  it "registers and corrects an offense when using `reject! { |e| e.blank? }`" do
+    expect_offense(<<~RUBY)
+      collection.reject! { |e| e.blank? }
+                 ^^^^^^^^^^^^^^^^^^^^^^^^ Use `compact_blank!` instead.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      collection.compact_blank!
+    RUBY
+  end
+
+  it "registers and corrects an offense when using `reject!(&:blank?)`" do
+    expect_offense(<<~RUBY)
+      collection.reject!(&:blank?)
+                 ^^^^^^^^^^^^^^^^^ Use `compact_blank!` instead.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      collection.compact_blank!
+    RUBY
+  end
+
+  it "registers and corrects an offense when using `reject(&:blank?)` in block" do
+    expect_offense(<<~RUBY)
+      hash.transform_values { |value| value.reject(&:blank?) }
+                                            ^^^^^^^^^^^^^^^^ Use `compact_blank` instead.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      hash.transform_values { |value| value.compact_blank }
+    RUBY
+  end
+
+  it "does not register an offense when using `compact_blank`" do
+    expect_no_offenses(<<~RUBY)
+      collection.compact_blank
+    RUBY
+  end
+
+  it "does not register an offense when using `compact_blank!`" do
+    expect_no_offenses(<<~RUBY)
+      collection.compact_blank!
+    RUBY
+  end
+
+  it "does not register an offense when using `reject { |k, v| k.blank? }`" do
+    expect_no_offenses(<<~RUBY)
+      collection.reject { |k, v| k.blank? }
+    RUBY
+  end
+
+  it "does not register an offense when using the receiver of `blank?` is not a block variable" do
+    expect_no_offenses(<<~RUBY)
+      def foo(arg)
+        collection.reject { |_| arg.blank? }
+      end
+    RUBY
+  end
+
+  it "does not register an offense when using `reject { |e| e.empty? }`" do
+    expect_no_offenses(<<~RUBY)
+      collection.reject { |e| e.empty? }
+    RUBY
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/components_order_spec.rb b/Library/Homebrew/test/rubocops/components_order_spec.rb
index 7b8e2a813a6d7..8fce98e57368d 100644
--- a/Library/Homebrew/test/rubocops/components_order_spec.rb
+++ b/Library/Homebrew/test/rubocops/components_order_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/components_order"
 
-describe RuboCop::Cop::FormulaAudit::ComponentsOrder do
+RSpec.describe RuboCop::Cop::FormulaAudit::ComponentsOrder do
   subject(:cop) { described_class.new }
 
   context "when auditing formula components order" do
@@ -15,7 +14,7 @@ class Foo < Formula
 
           uses_from_macos "apple"
           depends_on "foo"
-          ^^^^^^^^^^^^^^^^ `depends_on` (line 6) should be put before `uses_from_macos` (line 5)
+          ^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `depends_on` (line 6) should be put before `uses_from_macos` (line 5)
         end
       RUBY
 
@@ -38,7 +37,7 @@ class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
           license "0BSD"
           sha256 "samplesha256"
-          ^^^^^^^^^^^^^^^^^^^^^ `sha256` (line 5) should be put before `license` (line 4)
+          ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `sha256` (line 5) should be put before `license` (line 4)
         end
       RUBY
 
@@ -61,9 +60,9 @@ class Foo < Formula
           bottle :unneeded
 
           livecheck do
-          ^^^^^^^^^^^^ `livecheck` (line 7) should be put before `bottle` (line 5)
+          ^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `livecheck` (line 7) should be put before `bottle` (line 5)
             url "https://brew.sh/foo/versions/"
-            regex(/href=.+?foo-(\d+(?:\.\d+)+)\.t/)
+            regex(/href=.+?foo-(\d+(?:.\d+)+).t/)
           end
         end
       RUBY
@@ -75,7 +74,7 @@ class Foo < Formula
 
           livecheck do
             url "https://brew.sh/foo/versions/"
-            regex(/href=.+?foo-(\d+(?:\.\d+)+)\.t/)
+            regex(/href=.+?foo-(\d+(?:.\d+)+).t/)
           end
 
           bottle :unneeded
@@ -88,7 +87,7 @@ class Foo < Formula
         class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
           homepage "https://brew.sh"
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^ `homepage` (line 3) should be put before `url` (line 2)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `homepage` (line 3) should be put before `url` (line 2)
         end
       RUBY
 
@@ -110,7 +109,7 @@ class Foo < Formula
           end
 
           depends_on "openssl"
-          ^^^^^^^^^^^^^^^^^^^^ `depends_on` (line 8) should be put before `resource` (line 4)
+          ^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `depends_on` (line 8) should be put before `resource` (line 4)
         end
       RUBY
 
@@ -137,7 +136,7 @@ class Foo < Formula
           end
 
           def plist
-          ^^^^^^^^^ `plist` (line 8) should be put before `test` (line 4)
+          ^^^^^^^^^ FormulaAudit/ComponentsOrder: `plist` (line 8) should be put before `test` (line 4)
           end
         end
       RUBY
@@ -165,7 +164,7 @@ def install
           end
 
           depends_on "openssl"
-          ^^^^^^^^^^^^^^^^^^^^ `depends_on` (line 7) should be put before `install` (line 4)
+          ^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `depends_on` (line 7) should be put before `install` (line 4)
         end
       RUBY
 
@@ -193,7 +192,7 @@ def test
           end
 
           depends_on "openssl"
-          ^^^^^^^^^^^^^^^^^^^^ `depends_on` (line 10) should be put before `install` (line 4)
+          ^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `depends_on` (line 10) should be put before `install` (line 4)
         end
       RUBY
 
@@ -218,7 +217,7 @@ class Foo < Formula
           depends_on "autoconf" => :build
           conflicts_with "visionmedia-watch"
           depends_on "automake" => :build
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `depends_on` (line 4) should be put before `conflicts_with` (line 3)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `depends_on` (line 4) should be put before `conflicts_with` (line 3)
           depends_on "libtool" => :build
           depends_on "pkg-config" => :build
           depends_on "gettext"
@@ -245,7 +244,7 @@ class Foo < Formula
             depends_on "readline"
           end
           uses_from_macos "bar"
-          ^^^^^^^^^^^^^^^^^^^^^ `uses_from_macos` (line 6) should be put before `on_macos` (line 3)
+          ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `uses_from_macos` (line 6) should be put before `on_macos` (line 3)
         end
       RUBY
 
@@ -269,7 +268,7 @@ class Foo < Formula
             depends_on "readline"
           end
           uses_from_macos "bar"
-          ^^^^^^^^^^^^^^^^^^^^^ `uses_from_macos` (line 6) should be put before `on_linux` (line 3)
+          ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `uses_from_macos` (line 6) should be put before `on_linux` (line 3)
         end
       RUBY
 
@@ -293,7 +292,7 @@ class Foo < Formula
             depends_on "vim"
           end
           on_macos do
-          ^^^^^^^^^^^ `on_macos` (line 6) should be put before `on_linux` (line 3)
+          ^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `on_macos` (line 6) should be put before `on_linux` (line 3)
             depends_on "readline"
           end
         end
@@ -322,7 +321,7 @@ class Foo < Formula
         depends_on "openssl"
 
         deprecate! because: "has been replaced by bar"
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `deprecate!` (line 6) should be put before `depends_on` (line 4)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `deprecate!` (line 6) should be put before `depends_on` (line 4)
       end
     RUBY
 
@@ -512,7 +511,7 @@ class Foo < Formula
           end
 
           on_macos do
-          ^^^^^^^^^^^ there can only be one `on_macos` block in a formula.
+          ^^^^^^^^^^^ FormulaAudit/ComponentsOrder: there can only be one `on_macos` block in a formula.
             depends_on "foo"
           end
         end
@@ -528,7 +527,7 @@ class Foo < Formula
           end
 
           on_linux do
-          ^^^^^^^^^^^ there can only be one `on_linux` block in a formula.
+          ^^^^^^^^^^^ FormulaAudit/ComponentsOrder: there can only be one `on_linux` block in a formula.
             depends_on "foo"
           end
         end
@@ -544,7 +543,7 @@ class Foo < Formula
           end
 
           on_intel do
-          ^^^^^^^^^^^ there can only be one `on_intel` block in a formula.
+          ^^^^^^^^^^^ FormulaAudit/ComponentsOrder: there can only be one `on_intel` block in a formula.
             depends_on "foo"
           end
         end
@@ -560,7 +559,7 @@ class Foo < Formula
           end
 
           on_arm do
-          ^^^^^^^^^ there can only be one `on_arm` block in a formula.
+          ^^^^^^^^^ FormulaAudit/ComponentsOrder: there can only be one `on_arm` block in a formula.
             depends_on "foo"
           end
         end
@@ -576,7 +575,7 @@ class Foo < Formula
           end
 
           on_monterey do
-          ^^^^^^^^^^^^^^ there can only be one `on_monterey` block in a formula.
+          ^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: there can only be one `on_monterey` block in a formula.
             depends_on "foo"
           end
         end
@@ -592,7 +591,7 @@ class Foo < Formula
           end
 
           on_monterey :or_older do
-          ^^^^^^^^^^^^^^^^^^^^^^^^ there can only be one `on_monterey` block in a formula.
+          ^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: there can only be one `on_monterey` block in a formula.
             depends_on "foo"
           end
         end
@@ -606,7 +605,7 @@ class Foo < Formula
           on_macos do
             depends_on "readline"
             uses_from_macos "ncurses"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^ `on_macos` cannot include `uses_from_macos`. [...]
+            ^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `on_macos` cannot include `uses_from_macos`. [...]
           end
         end
       RUBY
@@ -619,7 +618,7 @@ class Foo < Formula
           on_linux do
             depends_on "readline"
             uses_from_macos "ncurses"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^ `on_linux` cannot include `uses_from_macos`. [...]
+            ^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `on_linux` cannot include `uses_from_macos`. [...]
           end
         end
       RUBY
@@ -632,7 +631,7 @@ class Foo < Formula
           on_intel do
             depends_on "readline"
             uses_from_macos "ncurses"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^ `on_intel` cannot include `uses_from_macos`. [...]
+            ^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `on_intel` cannot include `uses_from_macos`. [...]
           end
         end
       RUBY
@@ -645,7 +644,7 @@ class Foo < Formula
           on_arm do
             depends_on "readline"
             uses_from_macos "ncurses"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^ `on_arm` cannot include `uses_from_macos`. [...]
+            ^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `on_arm` cannot include `uses_from_macos`. [...]
           end
         end
       RUBY
@@ -659,7 +658,7 @@ class Foo < Formula
           on_monterey do
             depends_on "readline"
             uses_from_macos "ncurses"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^ `on_monterey` cannot include `uses_from_macos`. [...]
+            ^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `on_monterey` cannot include `uses_from_macos`. [...]
           end
         end
       RUBY
@@ -673,13 +672,167 @@ class Foo < Formula
           on_monterey :or_older do
             depends_on "readline"
             uses_from_macos "ncurses"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^ `on_monterey` cannot include `uses_from_macos`. [...]
+            ^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `on_monterey` cannot include `uses_from_macos`. [...]
           end
         end
       RUBY
     end
 
+    it "reports an offense when a single `patch` block is inside the `on_arm` block" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          on_arm do
+          ^^^^^^^^^ FormulaAudit/ComponentsOrder: Nest `on_arm` blocks inside `patch` blocks when there is only one inner block.
+            patch do
+              url "https://brew.sh/patch1.tar.gz"
+              sha256 "2c39089f64d9d4c3e632f120894b36b68dcc8ae8c6f5130c0c2e6f5bb7aebf2f"
+            end
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+              patch do
+        on_arm do
+              url "https://brew.sh/patch1.tar.gz"
+              sha256 "2c39089f64d9d4c3e632f120894b36b68dcc8ae8c6f5130c0c2e6f5bb7aebf2f"
+            end
+          end
+        end
+      RUBY
+    end
+
+    it "reports an offense when a single `resource` block is inside the `on_linux` block" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          on_linux do
+          ^^^^^^^^^^^ FormulaAudit/ComponentsOrder: Nest `on_linux` blocks inside `resource` blocks when there is only one inner block.
+            resource do
+              url "https://brew.sh/resource1.tar.gz"
+              sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
+            end
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+              resource do
+        on_linux do
+              url "https://brew.sh/resource1.tar.gz"
+              sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
+            end
+          end
+        end
+      RUBY
+    end
+
+    it "reports an offense when a single `patch` block is inside the `on_monterey :or_newer` block" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          on_monterey :or_newer do
+          ^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: Nest `on_monterey` blocks inside `patch` blocks when there is only one inner block.
+            patch do
+              url "https://brew.sh/patch1.tar.gz"
+              sha256 "2c39089f64d9d4c3e632f120894b36b68dcc8ae8c6f5130c0c2e6f5bb7aebf2f"
+            end
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+              patch do
+        on_monterey :or_newer do
+              url "https://brew.sh/patch1.tar.gz"
+              sha256 "2c39089f64d9d4c3e632f120894b36b68dcc8ae8c6f5130c0c2e6f5bb7aebf2f"
+            end
+          end
+        end
+      RUBY
+    end
+
+    it "reports an offense when a single `resource` block is inside the `on_system` block" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          on_system :linux, macos: :monterey_or_older do
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: Nest `on_system` blocks inside `resource` blocks when there is only one inner block.
+            resource do
+              url "https://brew.sh/resource1.tar.gz"
+              sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
+            end
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+              resource do
+        on_system :linux, macos: :monterey_or_older do
+              url "https://brew.sh/resource1.tar.gz"
+              sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
+            end
+          end
+        end
+      RUBY
+    end
+
+    it "reports no offenses when a single `on_arm` block is inside the `on_macos` block" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          on_macos do
+            on_arm do
+              resource do
+                url "https://brew.sh/resource1.tar.gz"
+                sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
+              end
+            end
+          end
+        end
+      RUBY
+    end
+
+    context "when in a head block" do
+      it "reports an offense if stanzas inside `head` blocks are out of order" do
+        expect_offense(<<~RUBY)
+          class Foo < Formula
+            homepage "https://brew.sh"
+
+            head do
+              depends_on "bar"
+              url "https://github.com/foo/foo.git", branch: "main"
+              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `url` (line 6) should be put before `depends_on` (line 5)
+            end
+          end
+        RUBY
+      end
+    end
+
     context "when in a resource block" do
+      it "reports an offense if stanzas inside `resource` blocks are out of order" do
+        expect_offense(<<~RUBY)
+          class Foo < Formula
+            homepage "https://brew.sh"
+
+            resource do
+              sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
+              url "https://brew.sh/resource1.tar.gz"
+              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `url` (line 6) should be put before `sha256` (line 5)
+            end
+          end
+        RUBY
+      end
+
       it "reports no offenses for a valid `on_macos` and `on_linux` block" do
         expect_no_offenses(<<~RUBY)
           class Foo < Formula
@@ -728,7 +881,7 @@ class Foo < Formula
             url "https://brew.sh/foo-1.0.tgz"
 
             resource do
-            ^^^^^^^^^^^ there can only be one `on_macos` block in a resource block.
+            ^^^^^^^^^^^ FormulaAudit/ComponentsOrder: there can only be one `on_macos` block in a resource block.
               on_macos do
                 url "https://brew.sh/resource1.tar.gz"
                 sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
@@ -749,7 +902,7 @@ class Foo < Formula
             url "https://brew.sh/foo-1.0.tgz"
 
             resource do
-            ^^^^^^^^^^^ there can only be one `on_linux` block in a resource block.
+            ^^^^^^^^^^^ FormulaAudit/ComponentsOrder: there can only be one `on_linux` block in a resource block.
               on_linux do
                 url "https://brew.sh/resource1.tar.gz"
                 sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
@@ -770,7 +923,7 @@ class Foo < Formula
             url "https://brew.sh/foo-1.0.tgz"
 
             resource do
-            ^^^^^^^^^^^ there can only be one `on_intel` block in a resource block.
+            ^^^^^^^^^^^ FormulaAudit/ComponentsOrder: there can only be one `on_intel` block in a resource block.
               on_intel do
                 url "https://brew.sh/resource1.tar.gz"
                 sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
@@ -791,7 +944,7 @@ class Foo < Formula
             url "https://brew.sh/foo-1.0.tgz"
 
             resource do
-            ^^^^^^^^^^^ there can only be one `on_arm` block in a resource block.
+            ^^^^^^^^^^^ FormulaAudit/ComponentsOrder: there can only be one `on_arm` block in a resource block.
               on_arm do
                 url "https://brew.sh/resource1.tar.gz"
                 sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
@@ -812,7 +965,7 @@ class Foo < Formula
             url "https://brew.sh/foo-1.0.tgz"
 
             resource do
-            ^^^^^^^^^^^ there can only be one `on_monterey` block in a resource block.
+            ^^^^^^^^^^^ FormulaAudit/ComponentsOrder: there can only be one `on_monterey` block in a resource block.
               on_monterey do
                 url "https://brew.sh/resource1.tar.gz"
                 sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
@@ -890,7 +1043,7 @@ class Foo < Formula
 
             resource do
               on_macos do
-              ^^^^^^^^^^^ `on_macos` blocks within `resource` blocks must contain at least `url` and `sha256` and at most `url`, `mirror`, `version` and `sha256` (in order).
+              ^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `on_macos` blocks within `resource` blocks must contain at least `url` and `sha256` and at most `url`, `mirror`, `version` and `sha256` (in order).
                 sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
                 url "https://brew.sh/resource2.tar.gz"
               end
@@ -957,7 +1110,7 @@ class Foo < Formula
 
             resource do
               on_macos do
-              ^^^^^^^^^^^ `on_macos` blocks within `resource` blocks must contain at least `url` and `sha256` and at most `url`, `mirror`, `version` and `sha256` (in order).
+              ^^^^^^^^^^^ FormulaAudit/ComponentsOrder: `on_macos` blocks within `resource` blocks must contain at least `url` and `sha256` and at most `url`, `mirror`, `version` and `sha256` (in order).
                 if foo == :bar
                   url "https://brew.sh/resource2.tar.gz"
                   sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
@@ -982,16 +1135,15 @@ class Foo < Formula
             url "https://brew.sh/foo-1.0.tgz"
 
             resource do
-              on_intel do
-                url "https://brew.sh/resource2.tar.gz"
-                sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
-              end
-
               on_arm do
-              ^^^^^^^^^ `on_arm` blocks within `resource` blocks must contain at least `url` and `sha256` and at most `url`, `mirror`, `version` and `sha256` (in order).
+              ^^^^^^^^^ FormulaAudit/ComponentsOrder: `on_arm` blocks within `resource` blocks must contain at least `url` and `sha256` and at most `url`, `mirror`, `version` and `sha256` (in order).
                 sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
                 url "https://brew.sh/resource2.tar.gz"
               end
+              on_intel do
+                url "https://brew.sh/resource2.tar.gz"
+                sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
+              end
             end
           end
         RUBY
@@ -1003,11 +1155,6 @@ class Foo < Formula
             url "https://brew.sh/foo-1.0.tgz"
 
             resource do
-              on_intel do
-                url "https://brew.sh/resource2.tar.gz"
-                sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
-              end
-
               on_arm do
                 if foo == :bar
                   url "https://brew.sh/resource2.tar.gz"
@@ -1017,6 +1164,10 @@ class Foo < Formula
                   sha256 "686372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
                 end
               end
+              on_intel do
+                url "https://brew.sh/resource2.tar.gz"
+                sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
+              end
             end
           end
         RUBY
@@ -1028,13 +1179,8 @@ class Foo < Formula
             url "https://brew.sh/foo-1.0.tgz"
 
             resource do
-              on_intel do
-                url "https://brew.sh/resource2.tar.gz"
-                sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
-              end
-
               on_arm do
-              ^^^^^^^^^ `on_arm` blocks within `resource` blocks must contain at least `url` and `sha256` and at most `url`, `mirror`, `version` and `sha256` (in order).
+              ^^^^^^^^^ FormulaAudit/ComponentsOrder: `on_arm` blocks within `resource` blocks must contain at least `url` and `sha256` and at most `url`, `mirror`, `version` and `sha256` (in order).
                 if foo == :bar
                   url "https://brew.sh/resource2.tar.gz"
                   sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
@@ -1043,6 +1189,10 @@ class Foo < Formula
                   url "https://brew.sh/resource1.tar.gz"
                 end
               end
+              on_intel do
+                url "https://brew.sh/resource2.tar.gz"
+                sha256 "586372eb92059873e29eba4f9dec8381541b4d3834660707faf8ba59146dfc35"
+              end
             end
           end
         RUBY
diff --git a/Library/Homebrew/test/rubocops/components_redundancy_spec.rb b/Library/Homebrew/test/rubocops/components_redundancy_spec.rb
index f308ee186c727..e65e31ae80be7 100644
--- a/Library/Homebrew/test/rubocops/components_redundancy_spec.rb
+++ b/Library/Homebrew/test/rubocops/components_redundancy_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/components_redundancy"
 
-describe RuboCop::Cop::FormulaAudit::ComponentsRedundancy do
+RSpec.describe RuboCop::Cop::FormulaAudit::ComponentsRedundancy do
   subject(:cop) { described_class.new }
 
   context "when auditing formula components" do
@@ -11,7 +10,7 @@
       expect_offense(<<~RUBY)
         class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `url` should be put inside `stable` block
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ComponentsRedundancy: `url` should be put inside `stable` block
           stable do
             # stuff
           end
@@ -28,7 +27,7 @@ class Foo < Formula
         class Foo < Formula
           head "https://brew.sh/foo.git"
           head do
-          ^^^^^^^ `head` and `head do` should not be simultaneously present
+          ^^^^^^^ FormulaAudit/ComponentsRedundancy: `head` and `head do` should not be simultaneously present
             # stuff
           end
         end
@@ -40,7 +39,7 @@ class Foo < Formula
         class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
           bottle do
-          ^^^^^^^^^ `bottle :modifier` and `bottle do` should not be simultaneously present
+          ^^^^^^^^^ FormulaAudit/ComponentsRedundancy: `bottle :modifier` and `bottle do` should not be simultaneously present
             # bottles go here
           end
           bottle :unneeded
@@ -73,5 +72,47 @@ class Foo < Formula
         end
       RUBY
     end
+
+    it "reports an offense if `stable do` or `head do` is present with only `url`" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          stable do
+          ^^^^^^^^^ FormulaAudit/ComponentsRedundancy: `stable do` should not be present with only url/sha256/mirror/version
+            url "https://brew.sh/foo-1.0.tgz"
+          end
+
+          head do
+          ^^^^^^^ FormulaAudit/ComponentsRedundancy: `head do` should not be present with only `url`
+            url "https://brew.sh/foo.git"
+          end
+        end
+      RUBY
+    end
+
+    it "reports no offenses if `stable do` is present with `url` and `depends_on`" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          head "https://brew.sh/foo.git"
+
+          stable do
+            url "https://brew.sh/foo-1.0.tgz"
+            depends_on "bar"
+          end
+        end
+      RUBY
+    end
+
+    it "reports no offenses if `head do` is present with `url` and `depends_on`" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+
+          head do
+            url "https://brew.sh/foo.git"
+            depends_on "bar"
+          end
+        end
+      RUBY
+    end
   end
 end
diff --git a/Library/Homebrew/test/rubocops/conflicts_spec.rb b/Library/Homebrew/test/rubocops/conflicts_spec.rb
index c772b02642d33..21967136db5e8 100644
--- a/Library/Homebrew/test/rubocops/conflicts_spec.rb
+++ b/Library/Homebrew/test/rubocops/conflicts_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/conflicts"
 
-describe RuboCop::Cop::FormulaAudit::Conflicts do
+RSpec.describe RuboCop::Cop::FormulaAudit::Conflicts do
   subject(:cop) { described_class.new }
 
   context "when auditing `conflicts_with`" do
@@ -12,7 +11,7 @@
         class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
           conflicts_with "bar", :because => "Reason"
-                                            ^^^^^^^^ 'Reason' from the `conflicts_with` reason should be 'reason'.
+                                            ^^^^^^^^ FormulaAudit/Conflicts: 'Reason' from the `conflicts_with` reason should be 'reason'.
           conflicts_with "baz", :because => "Foo is the formula name which does not require downcasing"
         end
       RUBY
@@ -31,7 +30,7 @@ class Foo < Formula
         class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
           conflicts_with "bar", "baz", :because => "reason."
-                                                   ^^^^^^^^^ `conflicts_with` reason should not end with a period.
+                                                   ^^^^^^^^^ FormulaAudit/Conflicts: `conflicts_with` reason should not end with a period.
         end
       RUBY
 
@@ -48,7 +47,7 @@ class Foo < Formula
         class FooAT20 < Formula
           url 'https://brew.sh/foo-2.0.tgz'
           conflicts_with "mysql", "mariadb"
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Versioned formulae should not use `conflicts_with`. Use `keg_only :versioned_formula` instead.
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Conflicts: Versioned formulae should not use `conflicts_with`. Use `keg_only :versioned_formula` instead.
         end
       RUBY
     end
diff --git a/Library/Homebrew/test/rubocops/dependency_order_spec.rb b/Library/Homebrew/test/rubocops/dependency_order_spec.rb
index b080d55ef7f41..bbcfe253e4289 100644
--- a/Library/Homebrew/test/rubocops/dependency_order_spec.rb
+++ b/Library/Homebrew/test/rubocops/dependency_order_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/dependency_order"
 
-describe RuboCop::Cop::FormulaAudit::DependencyOrder do
+RSpec.describe RuboCop::Cop::FormulaAudit::DependencyOrder do
   subject(:cop) { described_class.new }
 
   context "when auditing `uses_from_macos`" do
@@ -14,7 +13,7 @@ class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
           uses_from_macos "apple" if build.with? "foo"
           uses_from_macos "foo" => :optional
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dependency "foo" (line 5) should be put before dependency "apple" (line 4)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "foo" (line 5) should be put before dependency "apple" (line 4)
         end
       RUBY
 
@@ -35,7 +34,7 @@ class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
           uses_from_macos "foo"
           uses_from_macos "bar"
-          ^^^^^^^^^^^^^^^^^^^^^ dependency "bar" (line 5) should be put before dependency "foo" (line 4)
+          ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "bar" (line 5) should be put before dependency "foo" (line 4)
         end
       RUBY
 
@@ -56,7 +55,7 @@ class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
           uses_from_macos FooRequirement
           uses_from_macos "bar"
-          ^^^^^^^^^^^^^^^^^^^^^ dependency "bar" (line 5) should be put before dependency "FooRequirement" (line 4)
+          ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "bar" (line 5) should be put before dependency "FooRequirement" (line 4)
         end
       RUBY
 
@@ -78,13 +77,13 @@ class Foo < Formula
           head do
             uses_from_macos "apple" if build.with? "foo"
             uses_from_macos "bar"
-            ^^^^^^^^^^^^^^^^^^^^^ dependency "bar" (line 6) should be put before dependency "apple" (line 5)
+            ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "bar" (line 6) should be put before dependency "apple" (line 5)
             uses_from_macos "foo" => :optional
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dependency "foo" (line 7) should be put before dependency "apple" (line 5)
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "foo" (line 7) should be put before dependency "apple" (line 5)
           end
           uses_from_macos "apple" if build.with? "foo"
           uses_from_macos "foo" => :optional
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dependency "foo" (line 10) should be put before dependency "apple" (line 9)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "foo" (line 10) should be put before dependency "apple" (line 9)
         end
       RUBY
 
@@ -114,6 +113,34 @@ class Foo < Formula
         end
       RUBY
     end
+
+    it "reports and corrects wrong conditional order within a system block" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          homepage "https://brew.sh"
+          url "https://brew.sh/foo-1.0.tgz"
+          on_arm do
+            uses_from_macos "apple" if build.with? "foo"
+            uses_from_macos "bar"
+            ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "bar" (line 6) should be put before dependency "apple" (line 5)
+            uses_from_macos "foo" => :optional
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "foo" (line 7) should be put before dependency "apple" (line 5)
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          homepage "https://brew.sh"
+          url "https://brew.sh/foo-1.0.tgz"
+          on_arm do
+            uses_from_macos "bar"
+            uses_from_macos "foo" => :optional
+            uses_from_macos "apple" if build.with? "foo"
+          end
+        end
+      RUBY
+    end
   end
 
   context "when auditing `depends_on`" do
@@ -124,7 +151,7 @@ class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
           depends_on "apple" if build.with? "foo"
           depends_on "foo" => :optional
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dependency "foo" (line 5) should be put before dependency "apple" (line 4)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "foo" (line 5) should be put before dependency "apple" (line 4)
         end
       RUBY
 
@@ -145,7 +172,7 @@ class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
           depends_on "foo"
           depends_on "bar"
-          ^^^^^^^^^^^^^^^^ dependency "bar" (line 5) should be put before dependency "foo" (line 4)
+          ^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "bar" (line 5) should be put before dependency "foo" (line 4)
         end
       RUBY
 
@@ -166,7 +193,7 @@ class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
           depends_on FooRequirement
           depends_on "bar"
-          ^^^^^^^^^^^^^^^^ dependency "bar" (line 5) should be put before dependency "FooRequirement" (line 4)
+          ^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "bar" (line 5) should be put before dependency "FooRequirement" (line 4)
         end
       RUBY
 
@@ -188,13 +215,13 @@ class Foo < Formula
           head do
             depends_on "apple" if build.with? "foo"
             depends_on "bar"
-            ^^^^^^^^^^^^^^^^ dependency "bar" (line 6) should be put before dependency "apple" (line 5)
+            ^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "bar" (line 6) should be put before dependency "apple" (line 5)
             depends_on "foo" => :optional
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dependency "foo" (line 7) should be put before dependency "apple" (line 5)
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "foo" (line 7) should be put before dependency "apple" (line 5)
           end
           depends_on "apple" if build.with? "foo"
           depends_on "foo" => :optional
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dependency "foo" (line 10) should be put before dependency "apple" (line 9)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "foo" (line 10) should be put before dependency "apple" (line 9)
         end
       RUBY
 
@@ -224,5 +251,33 @@ class Foo < Formula
         end
       RUBY
     end
+
+    it "reports and corrects wrong conditional order within a system block" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          homepage "https://brew.sh"
+          url "https://brew.sh/foo-1.0.tgz"
+          on_linux do
+            depends_on "apple" if build.with? "foo"
+            depends_on "bar"
+            ^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "bar" (line 6) should be put before dependency "apple" (line 5)
+            depends_on "foo" => :optional
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/DependencyOrder: dependency "foo" (line 7) should be put before dependency "apple" (line 5)
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          homepage "https://brew.sh"
+          url "https://brew.sh/foo-1.0.tgz"
+          on_linux do
+            depends_on "bar"
+            depends_on "foo" => :optional
+            depends_on "apple" if build.with? "foo"
+          end
+        end
+      RUBY
+    end
   end
 end
diff --git a/Library/Homebrew/test/rubocops/deprecate_disable/date_spec.rb b/Library/Homebrew/test/rubocops/deprecate_disable/date_spec.rb
index e46e5ab8d28ad..d613f0a73320c 100644
--- a/Library/Homebrew/test/rubocops/deprecate_disable/date_spec.rb
+++ b/Library/Homebrew/test/rubocops/deprecate_disable/date_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/deprecate_disable"
 
-describe RuboCop::Cop::FormulaAudit::DeprecateDisableDate do
+RSpec.describe RuboCop::Cop::FormulaAudit::DeprecateDisableDate do
   subject(:cop) { described_class.new }
 
   context "when auditing `deprecate!`" do
@@ -12,7 +11,7 @@
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           deprecate! date: "June 25, 2020"
-                           ^^^^^^^^^^^^^^^ Use `2020-06-25` to comply with ISO 8601
+                           ^^^^^^^^^^^^^^^ FormulaAudit/DeprecateDisableDate: Use `2020-06-25` to comply with ISO 8601
         end
       RUBY
 
@@ -29,7 +28,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           deprecate! because: "is broken", date: "June 25, 2020"
-                                                 ^^^^^^^^^^^^^^^ Use `2020-06-25` to comply with ISO 8601
+                                                 ^^^^^^^^^^^^^^^ FormulaAudit/DeprecateDisableDate: Use `2020-06-25` to comply with ISO 8601
         end
       RUBY
 
@@ -84,7 +83,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           disable! date: "June 25, 2020"
-                         ^^^^^^^^^^^^^^^ Use `2020-06-25` to comply with ISO 8601
+                         ^^^^^^^^^^^^^^^ FormulaAudit/DeprecateDisableDate: Use `2020-06-25` to comply with ISO 8601
         end
       RUBY
 
@@ -101,7 +100,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           disable! because: "is broken", date: "June 25, 2020"
-                                               ^^^^^^^^^^^^^^^ Use `2020-06-25` to comply with ISO 8601
+                                               ^^^^^^^^^^^^^^^ FormulaAudit/DeprecateDisableDate: Use `2020-06-25` to comply with ISO 8601
         end
       RUBY
 
diff --git a/Library/Homebrew/test/rubocops/deprecate_disable/reason_spec.rb b/Library/Homebrew/test/rubocops/deprecate_disable/reason_spec.rb
index 0ae834561b2fc..067c8c4bed007 100644
--- a/Library/Homebrew/test/rubocops/deprecate_disable/reason_spec.rb
+++ b/Library/Homebrew/test/rubocops/deprecate_disable/reason_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/deprecate_disable"
 
-describe RuboCop::Cop::FormulaAudit::DeprecateDisableReason do
+RSpec.describe RuboCop::Cop::FormulaAudit::DeprecateDisableReason do
   subject(:cop) { described_class.new }
 
   context "when auditing `deprecate!`" do
@@ -48,7 +47,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           deprecate!
-          ^^^^^^^^^^ Add a reason for deprecation: `deprecate! because: "..."`
+          ^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Add a reason for deprecation: `deprecate! because: "..."`
         end
       RUBY
     end
@@ -58,7 +57,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           deprecate! date: "2020-08-28"
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Add a reason for deprecation: `deprecate! because: "..."`
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Add a reason for deprecation: `deprecate! because: "..."`
         end
       RUBY
     end
@@ -68,7 +67,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           deprecate! because: "it is broken"
-                              ^^^^^^^^^^^^^^ Do not start the reason with `it`
+                              ^^^^^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Do not start the reason with `it`
         end
       RUBY
 
@@ -85,7 +84,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           deprecate! date: "2020-08-28", because: "it is broken"
-                                                  ^^^^^^^^^^^^^^ Do not start the reason with `it`
+                                                  ^^^^^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Do not start the reason with `it`
         end
       RUBY
 
@@ -102,7 +101,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           deprecate! because: "is broken."
-                              ^^^^^^^^^^^^ Do not end the reason with a punctuation mark
+                              ^^^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Do not end the reason with a punctuation mark
         end
       RUBY
 
@@ -119,7 +118,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           deprecate! because: "is broken!"
-                              ^^^^^^^^^^^^ Do not end the reason with a punctuation mark
+                              ^^^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Do not end the reason with a punctuation mark
         end
       RUBY
 
@@ -136,7 +135,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           deprecate! because: "is broken?"
-                              ^^^^^^^^^^^^ Do not end the reason with a punctuation mark
+                              ^^^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Do not end the reason with a punctuation mark
         end
       RUBY
 
@@ -153,7 +152,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           deprecate! date: "2020-08-28", because: "is broken."
-                                                  ^^^^^^^^^^^^ Do not end the reason with a punctuation mark
+                                                  ^^^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Do not end the reason with a punctuation mark
         end
       RUBY
 
@@ -208,7 +207,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           disable!
-          ^^^^^^^^ Add a reason for disabling: `disable! because: "..."`
+          ^^^^^^^^ FormulaAudit/DeprecateDisableReason: Add a reason for disabling: `disable! because: "..."`
         end
       RUBY
     end
@@ -218,7 +217,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           disable! date: "2020-08-28"
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Add a reason for disabling: `disable! because: "..."`
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Add a reason for disabling: `disable! because: "..."`
         end
       RUBY
     end
@@ -228,7 +227,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           disable! because: "it is broken"
-                            ^^^^^^^^^^^^^^ Do not start the reason with `it`
+                            ^^^^^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Do not start the reason with `it`
         end
       RUBY
 
@@ -245,7 +244,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           disable! date: "2020-08-28", because: "it is broken"
-                                                ^^^^^^^^^^^^^^ Do not start the reason with `it`
+                                                ^^^^^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Do not start the reason with `it`
         end
       RUBY
 
@@ -262,7 +261,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           disable! because: "is broken."
-                            ^^^^^^^^^^^^ Do not end the reason with a punctuation mark
+                            ^^^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Do not end the reason with a punctuation mark
         end
       RUBY
 
@@ -279,7 +278,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           disable! because: "is broken!"
-                            ^^^^^^^^^^^^ Do not end the reason with a punctuation mark
+                            ^^^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Do not end the reason with a punctuation mark
         end
       RUBY
 
@@ -296,7 +295,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           disable! because: "is broken?"
-                            ^^^^^^^^^^^^ Do not end the reason with a punctuation mark
+                            ^^^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Do not end the reason with a punctuation mark
         end
       RUBY
 
@@ -313,7 +312,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           disable! date: "2020-08-28", because: "is broken."
-                                                ^^^^^^^^^^^^ Do not end the reason with a punctuation mark
+                                                ^^^^^^^^^^^^ FormulaAudit/DeprecateDisableReason: Do not end the reason with a punctuation mark
         end
       RUBY
 
diff --git a/Library/Homebrew/test/rubocops/desc_spec.rb b/Library/Homebrew/test/rubocops/desc_spec.rb
new file mode 100644
index 0000000000000..29ecf06de7f09
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/desc_spec.rb
@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "rubocops/desc"
+
+RSpec.describe RuboCop::Cop::FormulaAudit::Desc do
+  subject(:cop) { described_class.new }
+
+  context "when auditing formula `desc` methods" do
+    it "reports an offense when there is no `desc`" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+        ^^^^^^^^^^^^^^^^^^^ FormulaAudit/Desc: Formula should have a desc (Description).
+          url 'https://brew.sh/foo-1.0.tgz'
+        end
+      RUBY
+    end
+
+    it "reports an offense when `desc` is an empty string" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc ''
+          ^^^^^^^ FormulaAudit/Desc: The desc (description) should not be an empty string.
+        end
+      RUBY
+    end
+
+    it "reports an offense when `desc` is too long" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc 'Bar#{"bar" * 29}'
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Desc: Description is too long. It should be less than 80 characters. The current length is 90.
+        end
+      RUBY
+    end
+
+    it "reports an offense when `desc` is a multiline string" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc 'Bar#{"bar" * 9}'\
+            '#{"foo" * 21}'
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Desc: Description is too long. It should be less than 80 characters. The current length is 93.
+        end
+      RUBY
+    end
+  end
+
+  context "when auditing formula description texts" do
+    it "reports an offense when the description starts with a leading space" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc ' Description with a leading space'
+                ^ FormulaAudit/Desc: Description shouldn't have leading spaces.
+        end
+      RUBY
+    end
+
+    it "reports an offense when the description ends with a trailing space" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc 'Description with a trailing space '
+                                                 ^ FormulaAudit/Desc: Description shouldn't have trailing spaces.
+        end
+      RUBY
+    end
+
+    it "reports an offense when \"command-line\" is incorrectly spelled in the description" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc 'command line'
+                ^ FormulaAudit/Desc: Description should start with a capital letter.
+                ^^^^^^^^^^^^ FormulaAudit/Desc: Description should use "command-line" instead of "command line".
+        end
+      RUBY
+    end
+
+    it "reports an offense when an article is used in the description" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc 'An aardvark'
+                ^^ FormulaAudit/Desc: Description shouldn't start with an article.
+        end
+      RUBY
+
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc 'The aardvark'
+                ^^^ FormulaAudit/Desc: Description shouldn't start with an article.
+        end
+      RUBY
+    end
+
+    it "reports an offense when the description starts with a lowercase letter" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc 'bar'
+                ^ FormulaAudit/Desc: Description should start with a capital letter.
+        end
+      RUBY
+    end
+
+    it "reports an offense when the description starts with the formula name" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc 'Foo is a foobar'
+                ^^^ FormulaAudit/Desc: Description shouldn't start with the formula name.
+        end
+      RUBY
+    end
+
+    it "report and corrects an offense when the description ends with a full stop" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc 'Description with a full stop at the end.'
+                                                       ^ FormulaAudit/Desc: Description shouldn't end with a full stop.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc 'Description with a full stop at the end'
+        end
+      RUBY
+    end
+
+    it "reports and corrects an offense when the description contains Unicode So characters" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc 'Description with a 🍺 symbol'
+                                   ^ FormulaAudit/Desc: Description shouldn't contain Unicode emojis or symbols.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc 'Description with a symbol'
+        end
+      RUBY
+    end
+
+    it "does not report an offense when the description ends with 'etc.'" do
+      expect_no_offenses(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc 'Description of a thing and some more things and some more etc.'
+        end
+      RUBY
+    end
+
+    it "reports and corrects all rules for description text" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc ' an bar: commandline foo '
+                                        ^ FormulaAudit/Desc: Description shouldn't have trailing spaces.
+                         ^^^^^^^^^^^ FormulaAudit/Desc: Description should use "command-line" instead of "commandline".
+                ^ FormulaAudit/Desc: Description shouldn't have leading spaces.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          url 'https://brew.sh/foo-1.0.tgz'
+          desc 'Bar: command-line'
+        end
+      RUBY
+    end
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/exec_shell_metacharacters_spec.rb b/Library/Homebrew/test/rubocops/exec_shell_metacharacters_spec.rb
new file mode 100644
index 0000000000000..2f5c4ab4f185a
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/exec_shell_metacharacters_spec.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "rubocops/shell_commands"
+
+RSpec.describe RuboCop::Cop::Homebrew::ExecShellMetacharacters do
+  subject(:cop) { described_class.new }
+
+  context "when auditing exec calls" do
+    it "reports aan offense when output piping is used" do
+      expect_offense(<<~RUBY)
+        fork do
+          exec "foo bar > output"
+               ^^^^^^^^^^^^^^^^^^ Homebrew/ExecShellMetacharacters: Don't use shell metacharacters in `exec`. Implement the logic in Ruby instead, using methods like `$stdout.reopen`.
+        end
+      RUBY
+    end
+
+    it "reports no offenses when no metacharacters are used" do
+      expect_no_offenses(<<~RUBY)
+        fork do
+          exec "foo bar"
+        end
+      RUBY
+    end
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/files_spec.rb b/Library/Homebrew/test/rubocops/files_spec.rb
index e59550f6926f2..d6f9505fb5989 100644
--- a/Library/Homebrew/test/rubocops/files_spec.rb
+++ b/Library/Homebrew/test/rubocops/files_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/files"
 
-describe RuboCop::Cop::FormulaAudit::Files do
+RSpec.describe RuboCop::Cop::FormulaAudit::Files do
   subject(:cop) { described_class.new }
 
   context "when auditing files" do
@@ -14,7 +13,7 @@
 
         expect_offense(<<~RUBY, file)
           class Foo < Formula
-          ^^^^^^^^^^^^^^^^^^^ Incorrect file permissions (000): chmod +r #{filename}
+          ^^^^^^^^^^^^^^^^^^^ FormulaAudit/Files: Incorrect file permissions (000): chmod a+r #{filename}
             url "https://brew.sh/foo-1.0.tgz"
           end
         RUBY
diff --git a/Library/Homebrew/test/rubocops/formula_desc_spec.rb b/Library/Homebrew/test/rubocops/formula_desc_spec.rb
deleted file mode 100644
index bef0ca1a18a07..0000000000000
--- a/Library/Homebrew/test/rubocops/formula_desc_spec.rb
+++ /dev/null
@@ -1,150 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "rubocops/formula_desc"
-
-describe RuboCop::Cop::FormulaAudit::Desc do
-  subject(:cop) { described_class.new }
-
-  context "when auditing formula `desc` methods" do
-    it "reports an offense when there is no `desc`" do
-      expect_offense(<<~RUBY)
-        class Foo < Formula
-        ^^^^^^^^^^^^^^^^^^^ Formula should have a desc (Description).
-          url 'https://brew.sh/foo-1.0.tgz'
-        end
-      RUBY
-    end
-
-    it "reports an offense when `desc` is an empty string" do
-      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
-        class Foo < Formula
-          url 'https://brew.sh/foo-1.0.tgz'
-          desc ''
-          ^^^^^^^ The desc (description) should not be an empty string.
-        end
-      RUBY
-    end
-
-    it "reports an offense when `desc` is too long" do
-      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
-        class Foo < Formula
-          url 'https://brew.sh/foo-1.0.tgz'
-          desc 'Bar#{"bar" * 29}'
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Description is too long. It should be less than 80 characters. The current length is 90.
-        end
-      RUBY
-    end
-
-    it "reports an offense when `desc` is a multiline string" do
-      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
-        class Foo < Formula
-          url 'https://brew.sh/foo-1.0.tgz'
-          desc 'Bar#{"bar" * 9}'\
-            '#{"foo" * 21}'
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Description is too long. It should be less than 80 characters. The current length is 93.
-        end
-      RUBY
-    end
-  end
-
-  context "when auditing formula description texts" do
-    it "reports an offense when the description starts with a leading space" do
-      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
-        class Foo < Formula
-          url 'https://brew.sh/foo-1.0.tgz'
-          desc ' Description with a leading space'
-                ^ Description shouldn't have leading spaces.
-        end
-      RUBY
-    end
-
-    it "reports an offense when the description ends with a trailing space" do
-      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
-        class Foo < Formula
-          url 'https://brew.sh/foo-1.0.tgz'
-          desc 'Description with a trailing space '
-                                                 ^ Description shouldn't have trailing spaces.
-        end
-      RUBY
-    end
-
-    it "reports an offense when \"command-line\" is incorrectly spelled in the description" do
-      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
-        class Foo < Formula
-          url 'https://brew.sh/foo-1.0.tgz'
-          desc 'command line'
-                ^ Description should start with a capital letter.
-                ^^^^^^^^^^^^ Description should use "command-line" instead of "command line".
-        end
-      RUBY
-    end
-
-    it "reports an offense when an article is used in the description" do
-      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
-        class Foo < Formula
-          url 'https://brew.sh/foo-1.0.tgz'
-          desc 'An aardvark'
-                ^^ Description shouldn\'t start with an article.
-        end
-      RUBY
-
-      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
-        class Foo < Formula
-          url 'https://brew.sh/foo-1.0.tgz'
-          desc 'The aardvark'
-                ^^^ Description shouldn\'t start with an article.
-        end
-      RUBY
-    end
-
-    it "reports an offense when the description starts with a lowercase letter" do
-      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
-        class Foo < Formula
-          url 'https://brew.sh/foo-1.0.tgz'
-          desc 'bar'
-                ^ Description should start with a capital letter.
-        end
-      RUBY
-    end
-
-    it "reports an offense when the description starts with the formula name" do
-      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
-        class Foo < Formula
-          url 'https://brew.sh/foo-1.0.tgz'
-          desc 'Foo is a foobar'
-                ^^^ Description shouldn\'t start with the formula name.
-        end
-      RUBY
-    end
-
-    it "reports an offense when the description ends with a full stop" do
-      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
-        class Foo < Formula
-          url 'https://brew.sh/foo-1.0.tgz'
-          desc 'Description with a full stop at the end.'
-                                                       ^ Description shouldn\'t end with a full stop.
-        end
-      RUBY
-    end
-
-    it "reports and corrects all rules for description text" do
-      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
-        class Foo < Formula
-          url 'https://brew.sh/foo-1.0.tgz'
-          desc ' an bar: commandline foo '
-                                        ^ Description shouldn't have trailing spaces.
-                         ^^^^^^^^^^^ Description should use "command-line" instead of "commandline".
-                ^ Description shouldn't have leading spaces.
-        end
-      RUBY
-
-      expect_correction(<<~RUBY)
-        class Foo < Formula
-          url 'https://brew.sh/foo-1.0.tgz'
-          desc 'Bar: command-line'
-        end
-      RUBY
-    end
-  end
-end
diff --git a/Library/Homebrew/test/rubocops/homepage_spec.rb b/Library/Homebrew/test/rubocops/homepage_spec.rb
index 99df59c53ecad..6b845603c4829 100644
--- a/Library/Homebrew/test/rubocops/homepage_spec.rb
+++ b/Library/Homebrew/test/rubocops/homepage_spec.rb
@@ -1,16 +1,15 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/homepage"
 
-describe RuboCop::Cop::FormulaAudit::Homepage do
+RSpec.describe RuboCop::Cop::FormulaAudit::Homepage do
   subject(:cop) { described_class.new }
 
   context "when auditing homepage" do
     it "reports an offense when there is no homepage" do
       expect_offense(<<~RUBY)
         class Foo < Formula
-        ^^^^^^^^^^^^^^^^^^^ Formula should have a homepage.
+        ^^^^^^^^^^^^^^^^^^^ FormulaAudit/Homepage: Formula should have a homepage.
           url 'https://brew.sh/foo-1.0.tgz'
         end
       RUBY
@@ -20,7 +19,7 @@ class Foo < Formula
       expect_offense(<<~RUBY)
         class Foo < Formula
           homepage "ftp://brew.sh/foo"
-                   ^^^^^^^^^^^^^^^^^^^ The homepage should start with http or https.
+                   ^^^^^^^^^^^^^^^^^^^ FormulaAudit/Homepage: The homepage should start with http or https.
           url "https://brew.sh/foo-1.0.tgz"
         end
       RUBY
@@ -30,7 +29,7 @@ class Foo < Formula
       expect_offense(<<~RUBY)
         class Foo < Formula
           homepage "http://www.freedesktop.org/wiki/bar"
-                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Freedesktop homepages should be styled `https://wiki.freedesktop.org/project_name`
+                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Homepage: Freedesktop homepages should be styled `https://wiki.freedesktop.org/project_name`
           url "https://brew.sh/foo-1.0.tgz"
         end
       RUBY
@@ -40,7 +39,7 @@ class Foo < Formula
       expect_offense(<<~RUBY)
         class Foo < Formula
           homepage "http://www.freedesktop.org/wiki/Software/baz"
-                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Freedesktop homepages should be styled `https://wiki.freedesktop.org/www/Software/project_name`
+                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Homepage: Freedesktop homepages should be styled `https://wiki.freedesktop.org/www/Software/project_name`
           url "https://brew.sh/foo-1.0.tgz"
         end
       RUBY
@@ -50,7 +49,7 @@ class Foo < Formula
       expect_offense(<<~RUBY)
         class Foo < Formula
           homepage "https://code.google.com/p/qux"
-                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Google Code homepages should end with a slash
+                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Homepage: Google Code homepages should end with a slash
           url "https://brew.sh/foo-1.0.tgz"
         end
       RUBY
@@ -67,7 +66,7 @@ class Foo < Formula
       expect_offense(<<~RUBY)
         class Foo < Formula
           homepage "https://github.com/foo/bar.git"
-                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ GitHub homepages should not end with .git
+                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Homepage: GitHub homepages should not end with .git
           url "https://brew.sh/foo-1.0.tgz"
         end
       RUBY
@@ -92,7 +91,7 @@ class Foo < Formula
         expect_offense(<<~RUBY)
           class Foo < Formula
             homepage "http://foo.sourceforge.net/"
-                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Sourceforge homepages should be `https://foo.sourceforge.io/`
+                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Homepage: Sourceforge homepages should be `https://foo.sourceforge.io/`
             url "https://brew.sh/foo-1.0.tgz"
           end
         RUBY
@@ -104,7 +103,7 @@ class Foo < Formula
         expect_offense(<<~RUBY)
           class Foo < Formula
             homepage "http://foo.sourceforge.net"
-                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Sourceforge homepages should be `https://foo.sourceforge.io/`
+                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Homepage: Sourceforge homepages should be `https://foo.sourceforge.io/`
             url "https://brew.sh/foo-1.0.tgz"
           end
         RUBY
@@ -116,7 +115,7 @@ class Foo < Formula
         expect_offense(<<~RUBY)
           class Foo < Formula
             homepage "http://foo.sf.net/"
-                     ^^^^^^^^^^^^^^^^^^^^ Sourceforge homepages should be `https://foo.sourceforge.io/`
+                     ^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Homepage: Sourceforge homepages should be `https://foo.sourceforge.io/`
             url "https://brew.sh/foo-1.0.tgz"
           end
         RUBY
@@ -129,7 +128,7 @@ class Foo < Formula
       expect_offense(<<~RUBY)
         class Foo < Formula
           homepage "https://foo.readthedocs.org"
-                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Readthedocs homepages should be `https://foo.readthedocs.io`
+                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Homepage: Readthedocs homepages should be `https://foo.readthedocs.io`
           url "https://brew.sh/foo-1.0.tgz"
         end
       RUBY
@@ -160,11 +159,11 @@ class #{name.capitalize} < Formula
           end
         RUBY
 
-        expected_offenses = [{  message:  "Please use https:// for #{homepage}",
+        expected_offenses = [{  message:  "FormulaAudit/Homepage: Please use https:// for #{homepage}",
                                 severity: :convention,
                                 line:     2,
                                 column:   11,
-                                source:   source }]
+                                source: }]
 
         expected_offenses.zip([inspect_source(source).last]).each do |expected, actual|
           expect(actual.message).to eq(expected[:message])
diff --git a/Library/Homebrew/test/rubocops/install_bundler_gems_spec.rb b/Library/Homebrew/test/rubocops/install_bundler_gems_spec.rb
new file mode 100644
index 0000000000000..032ddd5c25d84
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/install_bundler_gems_spec.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "rubocops/install_bundler_gems"
+
+RSpec.describe RuboCop::Cop::Homebrew::InstallBundlerGems, :config do
+  it "registers an offense and corrects when using `Homebrew.install_bundler_gems!`" do
+    expect_offense(<<~RUBY)
+      Homebrew.install_bundler_gems!
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Only use `Homebrew.install_bundler_gems!` in dev-cmd.
+    RUBY
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/io_read_spec.rb b/Library/Homebrew/test/rubocops/io_read_spec.rb
index 7817d34c3198f..e26571a726a68 100644
--- a/Library/Homebrew/test/rubocops/io_read_spec.rb
+++ b/Library/Homebrew/test/rubocops/io_read_spec.rb
@@ -1,15 +1,14 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/io_read"
 
-describe RuboCop::Cop::Homebrew::IORead do
+RSpec.describe RuboCop::Cop::Homebrew::IORead do
   subject(:cop) { described_class.new }
 
   it "reports an offense when `IO.read` is used with a pipe character" do
     expect_offense(<<~RUBY)
       IO.read("|echo test")
-      ^^^^^^^^^^^^^^^^^^^^^ The use of `IO.read` is a security risk.
+      ^^^^^^^^^^^^^^^^^^^^^ Homebrew/IORead: The use of `IO.read` is a security risk.
     RUBY
   end
 
@@ -23,7 +22,7 @@
     expect_offense(<<~RUBY)
       input = "input value from an unknown source"
       IO.read(input)
-      ^^^^^^^^^^^^^^ The use of `IO.read` is a security risk.
+      ^^^^^^^^^^^^^^ Homebrew/IORead: The use of `IO.read` is a security risk.
     RUBY
   end
 
@@ -31,7 +30,7 @@
     expect_offense(<<~'RUBY')
       input = "test"
       IO.read("|echo #{input}")
-      ^^^^^^^^^^^^^^^^^^^^^^^^^ The use of `IO.read` is a security risk.
+      ^^^^^^^^^^^^^^^^^^^^^^^^^ Homebrew/IORead: The use of `IO.read` is a security risk.
     RUBY
   end
 
@@ -39,7 +38,7 @@
     expect_offense(<<~'RUBY')
       input = "|echo test"
       IO.read("#{input}.txt")
-      ^^^^^^^^^^^^^^^^^^^^^^^ The use of `IO.read` is a security risk.
+      ^^^^^^^^^^^^^^^^^^^^^^^ Homebrew/IORead: The use of `IO.read` is a security risk.
     RUBY
   end
 
@@ -51,23 +50,23 @@
   end
 
   it "reports an offense when `IO.read` is used with a concatenated string starting with a pipe character" do
-    expect_offense(<<~'RUBY')
+    expect_offense(<<~RUBY)
       input = "|echo test"
       IO.read("|echo " + input)
-      ^^^^^^^^^^^^^^^^^^^^^^^^^ The use of `IO.read` is a security risk.
+      ^^^^^^^^^^^^^^^^^^^^^^^^^ Homebrew/IORead: The use of `IO.read` is a security risk.
     RUBY
   end
 
   it "reports an offense when `IO.read` is used with a concatenated string starting with untrustworthy input" do
-    expect_offense(<<~'RUBY')
+    expect_offense(<<~RUBY)
       input = "|echo test"
       IO.read(input + ".txt")
-      ^^^^^^^^^^^^^^^^^^^^^^^ The use of `IO.read` is a security risk.
+      ^^^^^^^^^^^^^^^^^^^^^^^ Homebrew/IORead: The use of `IO.read` is a security risk.
     RUBY
   end
 
   it "does not report an offense when `IO.read` is used with a concatenated string safely" do
-    expect_no_offenses(<<~'RUBY')
+    expect_no_offenses(<<~RUBY)
       input = "test"
       IO.read("somefile" + input + ".txt")
     RUBY
diff --git a/Library/Homebrew/test/rubocops/keg_only_spec.rb b/Library/Homebrew/test/rubocops/keg_only_spec.rb
index c98d1ef599c34..98d365b90daa5 100644
--- a/Library/Homebrew/test/rubocops/keg_only_spec.rb
+++ b/Library/Homebrew/test/rubocops/keg_only_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/keg_only"
 
-describe RuboCop::Cop::FormulaAudit::KegOnly do
+RSpec.describe RuboCop::Cop::FormulaAudit::KegOnly do
   subject(:cop) { described_class.new }
 
   it "reports and corrects an offense when the `keg_only` reason is capitalized" do
@@ -14,7 +13,7 @@ class Foo < Formula
         homepage "https://brew.sh"
 
         keg_only "Because why not"
-                 ^^^^^^^^^^^^^^^^^ 'Because' from the `keg_only` reason should be 'because'.
+                 ^^^^^^^^^^^^^^^^^ FormulaAudit/KegOnly: 'Because' from the `keg_only` reason should be 'because'.
       end
     RUBY
 
@@ -36,7 +35,7 @@ class Foo < Formula
         homepage "https://brew.sh"
 
         keg_only "ending with a period."
-                 ^^^^^^^^^^^^^^^^^^^^^^^ `keg_only` reason should not end with a period.
+                 ^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/KegOnly: `keg_only` reason should not end with a period.
       end
     RUBY
 
diff --git a/Library/Homebrew/test/rubocops/lines/class_inheritance_spec.rb b/Library/Homebrew/test/rubocops/lines/class_inheritance_spec.rb
index 72e7153347c97..37903507f046a 100644
--- a/Library/Homebrew/test/rubocops/lines/class_inheritance_spec.rb
+++ b/Library/Homebrew/test/rubocops/lines/class_inheritance_spec.rb
@@ -1,16 +1,15 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/lines"
 
-describe RuboCop::Cop::FormulaAudit::ClassInheritance do
+RSpec.describe RuboCop::Cop::FormulaAudit::ClassInheritance do
   subject(:cop) { described_class.new }
 
   context "when auditing formula class inheritance" do
     it "reports an offense when not using spaces for class inheritance" do
       expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
         class Foo<Formula
-                  ^^^^^^^ Use a space in class inheritance: class Foo < Formula
+                  ^^^^^^^ FormulaAudit/ClassInheritance: Use a space in class inheritance: class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
         end
diff --git a/Library/Homebrew/test/rubocops/lines/generate_completions_spec.rb b/Library/Homebrew/test/rubocops/lines/generate_completions_spec.rb
new file mode 100644
index 0000000000000..244e6665ff1ef
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/lines/generate_completions_spec.rb
@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "rubocops/lines"
+
+RSpec.describe RuboCop::Cop::FormulaAudit do
+  describe RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL do
+    subject(:cop) { described_class.new }
+
+    it "reports an offense when writing to a shell completions file directly" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          name "foo"
+
+          def install
+            (bash_completion/"foo").write Utils.safe_popen_read(bin/"foo", "completions", "bash")
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/GenerateCompletionsDSL: Use `generate_completions_from_executable(bin/"foo", "completions", shells: [:bash])` instead of `(bash_completion/"foo").write Utils.safe_popen_read(bin/"foo", "completions", "bash")`.
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          name "foo"
+
+          def install
+            generate_completions_from_executable(bin/"foo", "completions", shells: [:bash])
+          end
+        end
+      RUBY
+    end
+
+    it "reports an offense when writing to a shell completions file differing from the formula name" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo-cli.rb")
+        class FooCli < Formula
+          name "foo-cli"
+
+          def install
+            (bash_completion/"foo").write Utils.safe_popen_read(bin/"foo", "completions", "bash")
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/GenerateCompletionsDSL: Use `generate_completions_from_executable(bin/"foo", "completions", base_name: "foo", shells: [:bash])` instead of `(bash_completion/"foo").write Utils.safe_popen_read(bin/"foo", "completions", "bash")`.
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class FooCli < Formula
+          name "foo-cli"
+
+          def install
+            generate_completions_from_executable(bin/"foo", "completions", base_name: "foo", shells: [:bash])
+          end
+        end
+      RUBY
+    end
+
+    it "reports an offense when writing to a shell completions file using an arg for the shell parameter" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          name "foo"
+
+          def install
+            (bash_completion/"foo").write Utils.safe_popen_read(bin/"foo", "completions", "--shell=bash")
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/GenerateCompletionsDSL: Use `generate_completions_from_executable(bin/"foo", "completions", shells: [:bash], shell_parameter_format: :arg)` instead of `(bash_completion/"foo").write Utils.safe_popen_read(bin/"foo", "completions", "--shell=bash")`.
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          name "foo"
+
+          def install
+            generate_completions_from_executable(bin/"foo", "completions", shells: [:bash], shell_parameter_format: :arg)
+          end
+        end
+      RUBY
+    end
+
+    it "reports an offense when writing to a shell completions file using a custom flag for the shell parameter" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          name "foo"
+
+          def install
+            (bash_completion/"foo").write Utils.safe_popen_read(bin/"foo", "completions", "--completion-script-bash")
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/GenerateCompletionsDSL: Use `generate_completions_from_executable(bin/"foo", "completions", shells: [:bash], shell_parameter_format: "--completion-script-")` instead of `(bash_completion/"foo").write Utils.safe_popen_read(bin/"foo", "completions", "--completion-script-bash")`.
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          name "foo"
+
+          def install
+            generate_completions_from_executable(bin/"foo", "completions", shells: [:bash], shell_parameter_format: "--completion-script-")
+          end
+        end
+      RUBY
+    end
+
+    it "reports an offense when writing to a completions file indirectly" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          name "foo"
+
+          def install
+            output = Utils.safe_popen_read(bin/"foo", "completions", "bash")
+            (bash_completion/"foo").write output
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/GenerateCompletionsDSL: Use `generate_completions_from_executable` DSL instead of `(bash_completion/"foo").write output`.
+          end
+        end
+      RUBY
+    end
+  end
+
+  describe RuboCop::Cop::FormulaAudit::SingleGenerateCompletionsDSLCall do
+    subject(:cop) { described_class.new }
+
+    it "reports an offense when using multiple #generate_completions_from_executable calls for different shells" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          name "foo"
+
+          def install
+            generate_completions_from_executable(bin/"foo", "completions", shells: [:bash])
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/SingleGenerateCompletionsDSLCall: Use a single `generate_completions_from_executable` call combining all specified shells.
+            generate_completions_from_executable(bin/"foo", "completions", shells: [:zsh])
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/SingleGenerateCompletionsDSLCall: Use a single `generate_completions_from_executable` call combining all specified shells.
+            generate_completions_from_executable(bin/"foo", "completions", shells: [:fish])
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/SingleGenerateCompletionsDSLCall: Use `generate_completions_from_executable(bin/"foo", "completions")` instead of `generate_completions_from_executable(bin/"foo", "completions", shells: [:fish])`.
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          name "foo"
+
+          def install
+            generate_completions_from_executable(bin/"foo", "completions")
+          end
+        end
+      RUBY
+    end
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/lines/quictls_check_spec.rb b/Library/Homebrew/test/rubocops/lines/quictls_check_spec.rb
new file mode 100644
index 0000000000000..3ee173448d2e6
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/lines/quictls_check_spec.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rubocops/lines"
+
+RSpec.describe RuboCop::Cop::FormulaAudit::QuicTLSCheck do
+  subject(:cop) { described_class.new }
+
+  context "when auditing formula dependencies" do
+    it "reports an offense when a formula depends on `quictls`" do
+      expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          desc "foo"
+          url 'https://brew.sh/foo-1.0.tgz'
+
+          depends_on "quictls"
+          ^^^^^^^^^^^^^^^^^^^^ FormulaAudit/QuicTLSCheck: Formulae in homebrew/core should use 'depends_on "openssl@3"' instead of 'depends_on "quictls"'.
+        end
+      RUBY
+    end
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/lines_spec.rb b/Library/Homebrew/test/rubocops/lines_spec.rb
index 10c3c776ea669..d7501035875b8 100644
--- a/Library/Homebrew/test/rubocops/lines_spec.rb
+++ b/Library/Homebrew/test/rubocops/lines_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/lines"
 
-describe RuboCop::Cop::FormulaAudit::Lines do
+RSpec.describe RuboCop::Cop::FormulaAudit::Lines do
   subject(:cop) { described_class.new }
 
   context "when auditing deprecated special dependencies" do
@@ -12,7 +11,7 @@
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           depends_on :automake
-          ^^^^^^^^^^^^^^^^^^^^ :automake is deprecated. Usage should be \"automake\".
+          ^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Lines: :automake is deprecated. Usage should be "automake".
         end
       RUBY
     end
@@ -22,7 +21,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           depends_on :autoconf
-          ^^^^^^^^^^^^^^^^^^^^ :autoconf is deprecated. Usage should be \"autoconf\".
+          ^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Lines: :autoconf is deprecated. Usage should be "autoconf".
         end
       RUBY
     end
@@ -32,7 +31,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           depends_on :libtool
-          ^^^^^^^^^^^^^^^^^^^ :libtool is deprecated. Usage should be \"libtool\".
+          ^^^^^^^^^^^^^^^^^^^ FormulaAudit/Lines: :libtool is deprecated. Usage should be "libtool".
         end
       RUBY
     end
@@ -42,7 +41,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           depends_on :apr
-          ^^^^^^^^^^^^^^^ :apr is deprecated. Usage should be \"apr-util\".
+          ^^^^^^^^^^^^^^^ FormulaAudit/Lines: :apr is deprecated. Usage should be "apr-util".
         end
       RUBY
     end
@@ -52,7 +51,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           depends_on :tex
-          ^^^^^^^^^^^^^^^ :tex is deprecated.
+          ^^^^^^^^^^^^^^^ FormulaAudit/Lines: :tex is deprecated.
         end
       RUBY
     end
diff --git a/Library/Homebrew/test/rubocops/livecheck/regex_case_insensitive_spec.rb b/Library/Homebrew/test/rubocops/livecheck/regex_case_insensitive_spec.rb
index 689ad4f3cdc1e..8ab10c3ed9ecf 100644
--- a/Library/Homebrew/test/rubocops/livecheck/regex_case_insensitive_spec.rb
+++ b/Library/Homebrew/test/rubocops/livecheck/regex_case_insensitive_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/livecheck"
 
-describe RuboCop::Cop::FormulaAudit::LivecheckRegexCaseInsensitive do
+RSpec.describe RuboCop::Cop::FormulaAudit::LivecheckRegexCaseInsensitive do
   subject(:cop) { described_class.new }
 
   it "reports an offense when the `regex` is not case-insensitive" do
@@ -14,7 +13,7 @@ class Foo < Formula
         livecheck do
           url :stable
           regex(%r{href=.*?/formula[._-]v?(\\d+(?:\\.\\d+)+)\\.t})
-                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Regexes should be case-insensitive unless sensitivity is explicitly required for proper matching.
+                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/LivecheckRegexCaseInsensitive: Regexes should be case-insensitive unless sensitivity is explicitly required for proper matching.
         end
       end
     RUBY
diff --git a/Library/Homebrew/test/rubocops/livecheck/regex_extension_spec.rb b/Library/Homebrew/test/rubocops/livecheck/regex_extension_spec.rb
index 88b33c585a221..24d4cc7f1c8ee 100644
--- a/Library/Homebrew/test/rubocops/livecheck/regex_extension_spec.rb
+++ b/Library/Homebrew/test/rubocops/livecheck/regex_extension_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/livecheck"
 
-describe RuboCop::Cop::FormulaAudit::LivecheckRegexExtension do
+RSpec.describe RuboCop::Cop::FormulaAudit::LivecheckRegexExtension do
   subject(:cop) { described_class.new }
 
   it "reports an offense when the `regex` does not use `\\.t` for archive file extensions" do
@@ -14,7 +13,7 @@ class Foo < Formula
         livecheck do
           url :stable
           regex(%r{href=.*?/formula[._-]v?(\\d+(?:\\.\\d+)+)\\.tgz}i)
-                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `\\.t` instead of `\\.tgz`
+                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/LivecheckRegexExtension: Use `\\.t` instead of `\\.tgz`
         end
       end
     RUBY
diff --git a/Library/Homebrew/test/rubocops/livecheck/regex_if_page_match_spec.rb b/Library/Homebrew/test/rubocops/livecheck/regex_if_page_match_spec.rb
index e0ae8ac882269..715d8a0896180 100644
--- a/Library/Homebrew/test/rubocops/livecheck/regex_if_page_match_spec.rb
+++ b/Library/Homebrew/test/rubocops/livecheck/regex_if_page_match_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/livecheck"
 
-describe RuboCop::Cop::FormulaAudit::LivecheckRegexIfPageMatch do
+RSpec.describe RuboCop::Cop::FormulaAudit::LivecheckRegexIfPageMatch do
   subject(:cop) { described_class.new }
 
   it "reports an offense when there is no `regex` for `strategy :page_match`" do
@@ -12,7 +11,7 @@ class Foo < Formula
         url "https://brew.sh/foo-1.0.tgz"
 
         livecheck do
-        ^^^^^^^^^^^^ A `regex` is required if `strategy :page_match` is present.
+        ^^^^^^^^^^^^ FormulaAudit/LivecheckRegexIfPageMatch: A `regex` is required if `strategy :page_match` is present.
           url :stable
           strategy :page_match
         end
diff --git a/Library/Homebrew/test/rubocops/livecheck/regex_parentheses_spec.rb b/Library/Homebrew/test/rubocops/livecheck/regex_parentheses_spec.rb
index f0fbd85901692..ec515a9c4d0a9 100644
--- a/Library/Homebrew/test/rubocops/livecheck/regex_parentheses_spec.rb
+++ b/Library/Homebrew/test/rubocops/livecheck/regex_parentheses_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/livecheck"
 
-describe RuboCop::Cop::FormulaAudit::LivecheckRegexParentheses do
+RSpec.describe RuboCop::Cop::FormulaAudit::LivecheckRegexParentheses do
   subject(:cop) { described_class.new }
 
   it "reports an offense when the `regex` call in the livecheck block does not use parentheses" do
@@ -14,7 +13,7 @@ class Foo < Formula
         livecheck do
           url :stable
           regex %r{href=.*?/formula[._-]v?(\\d+(?:\\.\\d+)+)\\.t}i
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The `regex` call should always use parentheses.
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/LivecheckRegexParentheses: The `regex` call should always use parentheses.
         end
       end
     RUBY
diff --git a/Library/Homebrew/test/rubocops/livecheck/skip_spec.rb b/Library/Homebrew/test/rubocops/livecheck/skip_spec.rb
index 4c5742f1989cc..d802a008ebe63 100644
--- a/Library/Homebrew/test/rubocops/livecheck/skip_spec.rb
+++ b/Library/Homebrew/test/rubocops/livecheck/skip_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/livecheck"
 
-describe RuboCop::Cop::FormulaAudit::LivecheckSkip do
+RSpec.describe RuboCop::Cop::FormulaAudit::LivecheckSkip do
   subject(:cop) { described_class.new }
 
   it "reports an offense when a skipped formula's livecheck block contains other information" do
@@ -12,7 +11,7 @@ class Foo < Formula
         url "https://brew.sh/foo-1.0.tgz"
 
         livecheck do
-        ^^^^^^^^^^^^ Skipped formulae must not contain other livecheck information.
+        ^^^^^^^^^^^^ FormulaAudit/LivecheckSkip: Skipped formulae must not contain other livecheck information.
           skip "Not maintained"
           url :stable
         end
diff --git a/Library/Homebrew/test/rubocops/livecheck/url_provided_spec.rb b/Library/Homebrew/test/rubocops/livecheck/url_provided_spec.rb
index cc40cbc0b57ff..72b41dbb4c41c 100644
--- a/Library/Homebrew/test/rubocops/livecheck/url_provided_spec.rb
+++ b/Library/Homebrew/test/rubocops/livecheck/url_provided_spec.rb
@@ -1,25 +1,35 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/livecheck"
 
-describe RuboCop::Cop::FormulaAudit::LivecheckUrlProvided do
+RSpec.describe RuboCop::Cop::FormulaAudit::LivecheckUrlProvided do
   subject(:cop) { described_class.new }
 
-  it "reports an offense when a `url` is not specified in the livecheck block" do
+  it "reports an offense when a `url` is not specified in a livecheck block" do
     expect_offense(<<~RUBY)
       class Foo < Formula
         url "https://brew.sh/foo-1.0.tgz"
 
         livecheck do
-        ^^^^^^^^^^^^ A `url` must be provided to livecheck.
+        ^^^^^^^^^^^^ FormulaAudit/LivecheckUrlProvided: A `url` should be provided when `regex` or `strategy` are used.
           regex(%r{href=.*?/formula[._-]v?(\\d+(?:\\.\\d+)+)\\.t}i)
         end
       end
     RUBY
+
+    expect_offense(<<~RUBY)
+      class Foo < Formula
+        url "https://brew.sh/foo-1.0.tgz"
+
+        livecheck do
+        ^^^^^^^^^^^^ FormulaAudit/LivecheckUrlProvided: A `url` should be provided when `regex` or `strategy` are used.
+          strategy :page_match
+        end
+      end
+    RUBY
   end
 
-  it "reports no offenses when a `url` is specified in the livecheck block" do
+  it "reports no offenses when a `url` and `regex` are specified in the livecheck block" do
     expect_no_offenses(<<~RUBY)
       class Foo < Formula
         url "https://brew.sh/foo-1.0.tgz"
@@ -31,4 +41,17 @@ class Foo < Formula
       end
     RUBY
   end
+
+  it "reports no offenses when a `url` and `strategy` are specified in the livecheck block" do
+    expect_no_offenses(<<~RUBY)
+      class Foo < Formula
+        url "https://brew.sh/foo-1.0.tgz"
+
+        livecheck do
+          url :stable
+          strategy :page_match
+        end
+      end
+    RUBY
+  end
 end
diff --git a/Library/Homebrew/test/rubocops/livecheck/url_symbol_spec.rb b/Library/Homebrew/test/rubocops/livecheck/url_symbol_spec.rb
index 6ce25c3203860..3d46fa5350767 100644
--- a/Library/Homebrew/test/rubocops/livecheck/url_symbol_spec.rb
+++ b/Library/Homebrew/test/rubocops/livecheck/url_symbol_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/livecheck"
 
-describe RuboCop::Cop::FormulaAudit::LivecheckUrlSymbol do
+RSpec.describe RuboCop::Cop::FormulaAudit::LivecheckUrlSymbol do
   subject(:cop) { described_class.new }
 
   it "reports an offense when the `url` specified in the livecheck block is identical to a formula URL" do
@@ -13,7 +12,7 @@ class Foo < Formula
 
         livecheck do
           url "https://brew.sh/foo-1.0.tgz"
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `url :stable`
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/LivecheckUrlSymbol: Use `url :stable`
         end
       end
     RUBY
diff --git a/Library/Homebrew/test/rubocops/move_to_extend_os_spec.rb b/Library/Homebrew/test/rubocops/move_to_extend_os_spec.rb
new file mode 100644
index 0000000000000..a20b0d949e149
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/move_to_extend_os_spec.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rubocops/move_to_extend_os"
+
+RSpec.describe RuboCop::Cop::Homebrew::MoveToExtendOS do
+  subject(:cop) { described_class.new }
+
+  it "registers an offense when using `OS.linux?`" do
+    expect_offense(<<~RUBY)
+      OS.linux?
+      ^^^^^^^^^ Homebrew/MoveToExtendOS: Move `OS.linux?` and `OS.mac?` calls to `extend/os`.
+    RUBY
+  end
+
+  it "registers an offense when using `OS.mac?`" do
+    expect_offense(<<~RUBY)
+      OS.mac?
+      ^^^^^^^ Homebrew/MoveToExtendOS: Move `OS.linux?` and `OS.mac?` calls to `extend/os`.
+    RUBY
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/negate_include_spec.rb b/Library/Homebrew/test/rubocops/negate_include_spec.rb
new file mode 100644
index 0000000000000..0d3799913f991
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/negate_include_spec.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rubocops/negate_include"
+
+RSpec.describe RuboCop::Cop::Homebrew::NegateInclude, :config do
+  it "registers an offense and corrects when using `!include?`" do
+    expect_offense(<<~RUBY)
+      !array.include?(2)
+      ^^^^^^^^^^^^^^^^^^ Use `.exclude?` and remove the negation part.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      array.exclude?(2)
+    RUBY
+  end
+
+  it "does not register an offense when using `!include?` without receiver" do
+    expect_no_offenses(<<~RUBY)
+      !include?(2)
+    RUBY
+  end
+
+  it "does not register an offense when using `include?` or `exclude?`" do
+    expect_no_offenses(<<~RUBY)
+      array.include?(2)
+      array.exclude?(2)
+    RUBY
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/no_fileutils_rmrf_spec.rb b/Library/Homebrew/test/rubocops/no_fileutils_rmrf_spec.rb
new file mode 100644
index 0000000000000..bc8b4aa99f6fa
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/no_fileutils_rmrf_spec.rb
@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "rubocops/no_fileutils_rmrf"
+
+RSpec.describe RuboCop::Cop::Homebrew::NoFileutilsRmrf do
+  subject(:cop) { described_class.new }
+
+  describe "rm_rf" do
+    it "registers an offense" do
+      expect_offense(<<~RUBY)
+        rm_rf("path/to/directory")
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Homebrew/NoFileutilsRmrf: #{RuboCop::Cop::Homebrew::NoFileutilsRmrf::MSG}
+        FileUtils.rm_rf("path/to/directory")
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Homebrew/NoFileutilsRmrf: #{RuboCop::Cop::Homebrew::NoFileutilsRmrf::MSG}
+      RUBY
+    end
+
+    it "autocorrects" do
+      corrected = autocorrect_source(<<~RUBY)
+        rm_rf("path/to/directory")
+        FileUtils.rm_rf("path/to/other/directory")
+      RUBY
+
+      expect(corrected).to eq(<<~RUBY)
+        rm_r("path/to/directory")
+        FileUtils.rm_r("path/to/other/directory")
+      RUBY
+    end
+  end
+
+  describe "rm_f" do
+    it "registers an offense" do
+      expect_offense(<<~RUBY)
+        rm_f("path/to/directory")
+        ^^^^^^^^^^^^^^^^^^^^^^^^^ Homebrew/NoFileutilsRmrf: #{RuboCop::Cop::Homebrew::NoFileutilsRmrf::MSG}
+        FileUtils.rm_f("path/to/other/directory")
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Homebrew/NoFileutilsRmrf: #{RuboCop::Cop::Homebrew::NoFileutilsRmrf::MSG}
+      RUBY
+    end
+
+    it "autocorrects" do
+      corrected = autocorrect_source(<<~RUBY)
+        rm_f("path/to/directory")
+        FileUtils.rm_f("path/to/other/directory")
+      RUBY
+
+      expect(corrected).to eq(<<~RUBY)
+        rm("path/to/directory")
+        FileUtils.rm("path/to/other/directory")
+      RUBY
+    end
+  end
+
+  describe "rmtree" do
+    it "registers an offense" do
+      expect_offense(<<~RUBY)
+        rmtree("path/to/directory")
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Homebrew/NoFileutilsRmrf: #{RuboCop::Cop::Homebrew::NoFileutilsRmrf::MSG}
+        other_dir = Pathname("path/to/other/directory")
+        other_dir.rmtree
+        ^^^^^^^^^^^^^^^^ Homebrew/NoFileutilsRmrf: #{RuboCop::Cop::Homebrew::NoFileutilsRmrf::MSG}
+        def buildpath
+          Pathname("path/to/yet/another/directory")
+        end
+        buildpath.rmtree
+        ^^^^^^^^^^^^^^^^ Homebrew/NoFileutilsRmrf: #{RuboCop::Cop::Homebrew::NoFileutilsRmrf::MSG}
+        (path/"here").rmtree
+        ^^^^^^^^^^^^^^^^^^^^ Homebrew/NoFileutilsRmrf: #{RuboCop::Cop::Homebrew::NoFileutilsRmrf::MSG}
+      RUBY
+    end
+
+    it "autocorrects" do
+      corrected = autocorrect_source(<<~RUBY)
+        rmtree("path/to/directory")
+        other_dir = Pathname("path/to/other/directory")
+        other_dir.rmtree
+        def buildpath
+          Pathname("path/to/yet/another/directory")
+        end
+        buildpath.rmtree
+        (path/"here").rmtree
+      RUBY
+
+      expect(corrected).to eq(<<~RUBY)
+        rm_r("path/to/directory")
+        other_dir = Pathname("path/to/other/directory")
+        FileUtils.rm_r(other_dir)
+        def buildpath
+          Pathname("path/to/yet/another/directory")
+        end
+        FileUtils.rm_r(buildpath)
+        FileUtils.rm_r(path/"here")
+      RUBY
+    end
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/options_spec.rb b/Library/Homebrew/test/rubocops/options_spec.rb
index 1d08dea021e64..5c1d2d376ef71 100644
--- a/Library/Homebrew/test/rubocops/options_spec.rb
+++ b/Library/Homebrew/test/rubocops/options_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/options"
 
-describe RuboCop::Cop::FormulaAudit::Options do
+RSpec.describe RuboCop::Cop::FormulaAudit::Options do
   subject(:cop) { described_class.new }
 
   context "when auditing options" do
@@ -12,7 +11,7 @@
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           option "with-32-bit"
-                 ^^^^^^^^^^^^^ macOS has been 64-bit only since 10.6 so 32-bit options are deprecated.
+                 ^^^^^^^^^^^^^ FormulaAudit/Options: macOS has been 64-bit only since 10.6 so 32-bit options are deprecated.
         end
       RUBY
     end
@@ -22,7 +21,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           option :universal
-          ^^^^^^^^^^^^^^^^^ macOS has been 64-bit only since 10.6 so universal options are deprecated.
+          ^^^^^^^^^^^^^^^^^ FormulaAudit/Options: macOS has been 64-bit only since 10.6 so universal options are deprecated.
         end
       RUBY
     end
@@ -33,7 +32,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           option :cxx11
           option "examples", "with-examples"
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Options should begin with with/without. Migrate '--examples' with `deprecated_option`.
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Options: Options should begin with with/without. Migrate '--examples' with `deprecated_option`.
         end
       RUBY
     end
@@ -43,7 +42,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           option "without-check"
-          ^^^^^^^^^^^^^^^^^^^^^^ Use '--without-test' instead of '--without-check'. Migrate '--without-check' with `deprecated_option`.
+          ^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Options: Use '--without-test' instead of '--without-check'. Migrate '--without-check' with `deprecated_option`.
         end
       RUBY
     end
@@ -53,7 +52,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           deprecated_option "examples" => "with-examples"
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Formulae in homebrew/core should not use `deprecated_option`.
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Options: Formulae in homebrew/core should not use `deprecated_option`.
         end
       RUBY
     end
@@ -63,7 +62,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           option "with-examples"
-          ^^^^^^^^^^^^^^^^^^^^^^ Formulae in homebrew/core should not use `option`.
+          ^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Options: Formulae in homebrew/core should not use `option`.
         end
       RUBY
     end
diff --git a/Library/Homebrew/test/rubocops/patches_spec.rb b/Library/Homebrew/test/rubocops/patches_spec.rb
index 00163bd9acecd..0c56e3f6f195e 100644
--- a/Library/Homebrew/test/rubocops/patches_spec.rb
+++ b/Library/Homebrew/test/rubocops/patches_spec.rb
@@ -1,13 +1,12 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/patches"
 
-describe RuboCop::Cop::FormulaAudit::Patches do
+RSpec.describe RuboCop::Cop::FormulaAudit::Patches do
   subject(:cop) { described_class.new }
 
   def expect_offense_hash(message:, severity:, line:, column:, source:)
-    [{ message: message, severity: severity, line: line, column: column, source: source }]
+    [{ message:, severity:, line:, column:, source: }]
   end
 
   context "when auditing legacy patches" do
@@ -25,7 +24,7 @@ class Foo < Formula
           homepage "ftp://brew.sh/foo"
           url "https://brew.sh/foo-1.0.tgz"
           def patches
-          ^^^^^^^^^^^ Use the patch DSL instead of defining a 'patches' method
+          ^^^^^^^^^^^ FormulaAudit/Patches: Use the patch DSL instead of defining a 'patches' method
             DATA
           end
         end
@@ -53,29 +52,30 @@ def patches
         EOS
 
         expected_offense = if patch_url.include?("/raw.github.com/")
-          expect_offense_hash message: <<~EOS.chomp, severity: :convention, line: 5, column: 4, source: source
-            GitHub/Gist patches should specify a revision: #{patch_url}
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 4, source:)
+            FormulaAudit/Patches: GitHub/Gist patches should specify a revision: #{patch_url}
           EOS
         elsif patch_url.include?("macports/trunk")
-          expect_offense_hash message: <<~EOS.chomp, severity: :convention, line: 5, column: 4, source: source
-            MacPorts patches should specify a revision instead of trunk: #{patch_url}
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 4, source:)
+            FormulaAudit/Patches: MacPorts patches should specify a revision instead of trunk: #{patch_url}
           EOS
         elsif patch_url.start_with?("http://trac.macports.org/")
-          expect_offense_hash message: <<~EOS.chomp, severity: :convention, line: 5, column: 4, source: source
-            Patches from MacPorts Trac should be https://, not http: #{patch_url}
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 4, source:)
+            FormulaAudit/Patches: Patches from MacPorts Trac should be https://, not http: #{patch_url}
           EOS
         elsif patch_url.start_with?("http://bugs.debian.org/")
-          expect_offense_hash message: <<~EOS.chomp, severity: :convention, line: 5, column: 4, source: source
-            Patches from Debian should be https://, not http: #{patch_url}
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 4, source:)
+            FormulaAudit/Patches: Patches from Debian should be https://, not http: #{patch_url}
           EOS
         # rubocop:disable Layout/LineLength
         elsif patch_url.match?(%r{https?://patch-diff\.githubusercontent\.com/raw/(.+)/(.+)/pull/(.+)\.(?:diff|patch)})
           # rubocop:enable Layout/LineLength
-          expect_offense_hash message: "Use a commit hash URL rather than patch-diff: #{patch_url}",
-                              severity: :convention, line: 5, column: 4, source: source
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 4, source:)
+            FormulaAudit/Patches: Use a commit hash URL rather than patch-diff: #{patch_url}
+          EOS
         elsif patch_url.match?(%r{https?://github\.com/.+/.+/(?:commit|pull)/[a-fA-F0-9]*.(?:patch|diff)})
-          expect_offense_hash message: <<~EOS.chomp, severity: :convention, line: 5, column: 4, source: source
-            GitHub patches should use the full_index parameter: #{patch_url}?full_index=1
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 4, source:)
+            FormulaAudit/Patches: GitHub patches should use the full_index parameter: #{patch_url}?full_index=1
           EOS
         end
         expected_offense.zip([inspect_source(source).last]).each do |expected, actual|
@@ -102,17 +102,22 @@ def patches
         end
       RUBY
 
-      expected_offenses = [{ message:  "Use the patch DSL instead of defining a 'patches' method",
-                             severity: :convention,
-                             line:     4,
-                             column:   2,
-                             source:   source },
-                           { message:  "Patches from MacPorts Trac should be https://, not http: " \
-                                       "http://trac.macports.org/export/68507/trunk/dports/net/trafshow/files/",
-                             severity: :convention,
-                             line:     8,
-                             column:   25,
-                             source:   source }]
+      expected_offenses = [
+        {
+          message:  "FormulaAudit/Patches: Use the patch DSL instead of defining a 'patches' method",
+          severity: :convention,
+          line:     4,
+          column:   2,
+          source:,
+        }, {
+          message:  "FormulaAudit/Patches: Patches from MacPorts Trac should be https://, not http: " \
+                    "http://trac.macports.org/export/68507/trunk/dports/net/trafshow/files/",
+          severity: :convention,
+          line:     8,
+          column:   25,
+          source:,
+        }
+      ]
 
       expected_offenses.zip(inspect_source(source)).each do |expected, actual|
         expect(actual.message).to eq(expected[:message])
@@ -153,7 +158,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           patch :DATA
-          ^^^^^^^^^^^ patch is missing '__END__'
+          ^^^^^^^^^^^ FormulaAudit/Patches: patch is missing '__END__'
         end
       RUBY
     end
@@ -164,7 +169,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
         end
         __END__
-        ^^^^^^^ patch is missing 'DATA'
+        ^^^^^^^ FormulaAudit/Patches: patch is missing 'DATA'
         patch content here
       RUBY
     end
@@ -196,42 +201,43 @@ class Foo < Formula
         RUBY
 
         expected_offense = if patch_url.include?("/raw.github.com/")
-          expect_offense_hash message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source: source
-            GitHub/Gist patches should specify a revision: #{patch_url}
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source:)
+            FormulaAudit/Patches: GitHub/Gist patches should specify a revision: #{patch_url}
           EOS
         elsif patch_url.include?("macports/trunk")
-          expect_offense_hash message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source: source
-            MacPorts patches should specify a revision instead of trunk: #{patch_url}
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source:)
+            FormulaAudit/Patches: MacPorts patches should specify a revision instead of trunk: #{patch_url}
           EOS
         elsif patch_url.start_with?("http://trac.macports.org/")
-          expect_offense_hash message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source: source
-            Patches from MacPorts Trac should be https://, not http: #{patch_url}
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source:)
+            FormulaAudit/Patches: Patches from MacPorts Trac should be https://, not http: #{patch_url}
           EOS
         elsif patch_url.start_with?("http://bugs.debian.org/")
-          expect_offense_hash message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source: source
-            Patches from Debian should be https://, not http: #{patch_url}
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source:)
+            FormulaAudit/Patches: Patches from Debian should be https://, not http: #{patch_url}
           EOS
         elsif patch_url.match?(%r{https://github.com/[^/]*/[^/]*/pull})
-          expect_offense_hash message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source: source
-            Use a commit hash URL rather than an unstable pull request URL: #{patch_url}
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source:)
+            FormulaAudit/Patches: Use a commit hash URL rather than an unstable pull request URL: #{patch_url}
           EOS
         elsif patch_url.match?(%r{.*gitlab.*/merge_request.*})
-          expect_offense_hash message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source: source
-            Use a commit hash URL rather than an unstable merge request URL: #{patch_url}
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source:)
+            FormulaAudit/Patches: Use a commit hash URL rather than an unstable merge request URL: #{patch_url}
           EOS
         elsif patch_url.match?(%r{https://github.com/[^/]*/[^/]*/commit/})
-          expect_offense_hash message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source: source
-            GitHub patches should end with .patch, not .diff: #{patch_url}
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source:)
+            FormulaAudit/Patches: GitHub patches should end with .patch, not .diff: #{patch_url}
           EOS
         elsif patch_url.match?(%r{.*gitlab.*/commit/})
-          expect_offense_hash message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source: source
-            GitLab patches should end with .diff, not .patch: #{patch_url}
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source:)
+            FormulaAudit/Patches: GitLab patches should end with .diff, not .patch: #{patch_url}
           EOS
         # rubocop:disable Layout/LineLength
         elsif patch_url.match?(%r{https?://patch-diff\.githubusercontent\.com/raw/(.+)/(.+)/pull/(.+)\.(?:diff|patch)})
           # rubocop:enable Layout/LineLength
-          expect_offense_hash message:  "Use a commit hash URL rather than patch-diff: #{patch_url}",
-                              severity: :convention, line: 5, column: 8, source: source
+          expect_offense_hash(message: <<~EOS.chomp, severity: :convention, line: 5, column: 8, source:)
+            FormulaAudit/Patches: Use a commit hash URL rather than patch-diff: #{patch_url}
+          EOS
         end
         expected_offense.zip([inspect_source(source).last]).each do |expected, actual|
           expect(actual.message).to eq(expected[:message])
diff --git a/Library/Homebrew/test/rubocops/presence_spec.rb b/Library/Homebrew/test/rubocops/presence_spec.rb
new file mode 100644
index 0000000000000..9d2dd7b4864d1
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/presence_spec.rb
@@ -0,0 +1,446 @@
+# frozen_string_literal: true
+
+require "rubocops/presence"
+
+RSpec.describe RuboCop::Cop::Homebrew::Presence, :config do
+  it "registers an offense and corrects when `a.present? ? a : nil`" do
+    expect_offense(<<~RUBY)
+      a.present? ? a : nil
+      ^^^^^^^^^^^^^^^^^^^^ Use `a.presence` instead of `a.present? ? a : nil`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence
+    RUBY
+  end
+
+  it "registers an offense and corrects when `!a.present? ? nil: a`" do
+    expect_offense(<<~RUBY)
+      !a.present? ? nil: a
+      ^^^^^^^^^^^^^^^^^^^^ Use `a.presence` instead of `!a.present? ? nil: a`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence
+    RUBY
+  end
+
+  it "registers an offense and corrects when `a.blank? ? nil : a`" do
+    expect_offense(<<~RUBY)
+      a.blank? ? nil : a
+      ^^^^^^^^^^^^^^^^^^ Use `a.presence` instead of `a.blank? ? nil : a`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence
+    RUBY
+  end
+
+  it "registers an offense and corrects when `!a.blank? ? a : nil`" do
+    expect_offense(<<~RUBY)
+      !a.blank? ? a : nil
+      ^^^^^^^^^^^^^^^^^^^ Use `a.presence` instead of `!a.blank? ? a : nil`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence
+    RUBY
+  end
+
+  it "registers an offense and corrects when `a.present? ? a : b`" do
+    expect_offense(<<~RUBY)
+      a.present? ? a : b
+      ^^^^^^^^^^^^^^^^^^ Use `a.presence || b` instead of `a.present? ? a : b`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence || b
+    RUBY
+  end
+
+  it "registers an offense and corrects when `!a.present? ? b : a`" do
+    expect_offense(<<~RUBY)
+      !a.present? ? b : a
+      ^^^^^^^^^^^^^^^^^^^ Use `a.presence || b` instead of `!a.present? ? b : a`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence || b
+    RUBY
+  end
+
+  it "registers an offense and corrects when `a.blank? ? b : a`" do
+    expect_offense(<<~RUBY)
+      a.blank? ? b : a
+      ^^^^^^^^^^^^^^^^ Use `a.presence || b` instead of `a.blank? ? b : a`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence || b
+    RUBY
+  end
+
+  it "registers an offense and corrects when `!a.blank? ? a : b`" do
+    expect_offense(<<~RUBY)
+      !a.blank? ? a : b
+      ^^^^^^^^^^^^^^^^^ Use `a.presence || b` instead of `!a.blank? ? a : b`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence || b
+    RUBY
+  end
+
+  it "registers an offense and corrects when `a.present? ? a : 1`" do
+    expect_offense(<<~RUBY)
+      a.present? ? a : 1
+      ^^^^^^^^^^^^^^^^^^ Use `a.presence || 1` instead of `a.present? ? a : 1`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence || 1
+    RUBY
+  end
+
+  it "registers an offense and corrects when `a.blank? ? 1 : a`" do
+    expect_offense(<<~RUBY)
+      a.blank? ? 1 : a
+      ^^^^^^^^^^^^^^^^ Use `a.presence || 1` instead of `a.blank? ? 1 : a`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence || 1
+    RUBY
+  end
+
+  it "registers an offense and corrects when `a(:bar).map(&:baz).present? ? a(:bar).map(&:baz) : nil`" do
+    expect_offense(<<~RUBY)
+      a(:bar).map(&:baz).present? ? a(:bar).map(&:baz) : nil
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `a(:bar).map(&:baz).presence` instead of `a(:bar).map(&:baz).present? ? a(:bar).map(&:baz) : nil`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a(:bar).map(&:baz).presence
+    RUBY
+  end
+
+  it "registers an offense and corrects when `a.present? ? a : b[:c]`" do
+    expect_offense(<<~RUBY)
+      a.present? ? a : b[:c]
+      ^^^^^^^^^^^^^^^^^^^^^^ Use `a.presence || b[:c]` instead of `a.present? ? a : b[:c]`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence || b[:c]
+    RUBY
+  end
+
+  it "registers an offense and corrects when multi-line if node" do
+    expect_offense(<<~RUBY)
+      if a.present?
+      ^^^^^^^^^^^^^ Use `a.presence` instead of `if a.present? ... end`.
+        a
+      else
+        nil
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence
+    RUBY
+  end
+
+  it "registers an offense and corrects when multi-line unless node" do
+    expect_offense(<<~RUBY)
+      unless a.present?
+      ^^^^^^^^^^^^^^^^^ Use `a.presence` instead of `unless a.present? ... end`.
+        nil
+      else
+        a
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence
+    RUBY
+  end
+
+  it "registers an offense and corrects when multi-line if node with `+` operators in the else branch" do
+    expect_offense(<<~RUBY)
+      if a.present?
+      ^^^^^^^^^^^^^ Use `a.presence || b.to_f + 12.0` instead of `if a.present? ... end`.
+        a
+      else
+        b.to_f + 12.0
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence || b.to_f + 12.0
+    RUBY
+  end
+
+  it "registers an offense and corrects when multi-line if `*` operators in the else branch" do
+    expect_offense(<<~RUBY)
+      if a.present?
+      ^^^^^^^^^^^^^ Use `a.presence || b.to_f * 12.0` instead of `if a.present? ... end`.
+        a
+      else
+        b.to_f * 12.0
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence || b.to_f * 12.0
+    RUBY
+  end
+
+  it "registers an offense and corrects when `a if a.present?`" do
+    expect_offense(<<~RUBY)
+      a if a.present?
+      ^^^^^^^^^^^^^^^ Use `a.presence` instead of `a if a.present?`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence
+    RUBY
+  end
+
+  it "registers an offense and corrects when `a unless a.blank?`" do
+    expect_offense(<<~RUBY)
+      a unless a.blank?
+      ^^^^^^^^^^^^^^^^^ Use `a.presence` instead of `a unless a.blank?`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      a.presence
+    RUBY
+  end
+
+  it "registers an offense and corrects when `.present?` with method chain" do
+    expect_offense(<<~RUBY)
+      if [1, 2, 3].map { |num| num + 1 }
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `[1, 2, 3].map { |num| num + 1 }.map { |num| num + 2 }.presence || b` instead of `if [1, 2, 3].map { |num| num + 1 }.map { |num| num + 2 }.present? ... end`.
+                  .map { |num| num + 2 }
+                  .present?
+                  [1, 2, 3].map { |num| num + 1 }.map { |num| num + 2 }
+      else
+        b
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      [1, 2, 3].map { |num| num + 1 }
+                  .map { |num| num + 2 }.presence || b
+    RUBY
+  end
+
+  context "when multiline ternary can be replaced" do
+    it "registers an offense and corrects" do
+      expect_offense(<<~RUBY)
+        a.present? ?
+        ^^^^^^^^^^^^ Use `a.presence` instead of `a.present? ? a : nil`.
+          a :
+          nil
+      RUBY
+
+      expect_correction(<<~RUBY)
+        a.presence
+      RUBY
+    end
+  end
+
+  context "when a method argument of `else` branch is enclosed in parentheses" do
+    it "registers an offense and corrects" do
+      expect_offense(<<~RUBY)
+        if value.present?
+        ^^^^^^^^^^^^^^^^^ Use `value.presence || do_something(value)` instead of `if value.present? ... end`.
+          value
+        else
+          do_something(value)
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        value.presence || do_something(value)
+      RUBY
+    end
+  end
+
+  context "when a method argument of `else` branch is not enclosed in parentheses" do
+    it "registers an offense and corrects" do
+      expect_offense(<<~RUBY)
+        if value.present?
+        ^^^^^^^^^^^^^^^^^ Use `value.presence || do_something(value)` instead of `if value.present? ... end`.
+          value
+        else
+          do_something value
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        value.presence || do_something(value)
+      RUBY
+    end
+  end
+
+  context "when multiple method arguments of `else` branch is not enclosed in parentheses" do
+    it "registers an offense and corrects" do
+      expect_offense(<<~RUBY)
+        if value.present?
+        ^^^^^^^^^^^^^^^^^ Use `value.presence || do_something(arg1, arg2)` instead of `if value.present? ... end`.
+          value
+        else
+          do_something arg1, arg2
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        value.presence || do_something(arg1, arg2)
+      RUBY
+    end
+  end
+
+  context "when a method argument with a receiver of `else` branch is not enclosed in parentheses" do
+    it "registers an offense and corrects" do
+      expect_offense(<<~RUBY)
+        if value.present?
+        ^^^^^^^^^^^^^^^^^ Use `value.presence || foo.do_something(value)` instead of `if value.present? ... end`.
+          value
+        else
+          foo.do_something value
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        value.presence || foo.do_something(value)
+      RUBY
+    end
+  end
+
+  context "when a right-hand side of the relational operator" do
+    %w[< > <= >= == !=].each do |operator|
+      it "registers an offense and corrects when `#{operator}`" do
+        expect_offense(<<~RUBY, operator:)
+          a #{operator} if b.present?
+            _{operator} ^^^^^^^^^^^^^ Use `(b.presence || c)` instead of `if b.present? ... end`.
+            b
+          else
+            c
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          a #{operator} (b.presence || c)
+        RUBY
+      end
+    end
+  end
+
+  it "does not register an offense when using `#presence`" do
+    expect_no_offenses(<<~RUBY)
+      a.presence
+    RUBY
+  end
+
+  it "does not register an offense when the expression does not return the receiver of `#present?`" do
+    expect_no_offenses(<<~RUBY)
+      a.present? ? b : nil
+    RUBY
+
+    expect_no_offenses(<<~RUBY)
+      puts foo if present?
+      puts foo if !present?
+    RUBY
+  end
+
+  it "does not register an offense when the expression does not return the receiver of `#blank?`" do
+    expect_no_offenses(<<~RUBY)
+      a.blank? ? nil : b
+    RUBY
+
+    expect_no_offenses(<<~RUBY)
+      puts foo if blank?
+      puts foo if !blank?
+    RUBY
+  end
+
+  it "does not register an offense when if or unless modifier is used" do
+    [
+      "a if a.blank?",
+      "a unless a.present?",
+    ].each { |source| expect_no_offenses(source) }
+  end
+
+  it "does not register an offense when the else block is multiline" do
+    expect_no_offenses(<<~RUBY)
+      if a.present?
+        a
+      else
+        something
+        something
+        something
+      end
+    RUBY
+  end
+
+  it "does not register an offense when the else block has multiple statements" do
+    expect_no_offenses(<<~RUBY)
+      if a.present?
+        a
+      else
+        something; something; something
+      end
+    RUBY
+  end
+
+  it "does not register an offense when including the elsif block" do
+    expect_no_offenses(<<~RUBY)
+      if a.present?
+        a
+      elsif b
+        b
+      end
+    RUBY
+  end
+
+  it "does not register an offense when the else block has `if` node" do
+    expect_no_offenses(<<~RUBY)
+      if a.present?
+        a
+      else
+        b if c
+      end
+    RUBY
+  end
+
+  it "does not register an offense when the else block has `rescue` node" do
+    expect_no_offenses(<<~RUBY)
+      if something_method.present?
+        something_method
+      else
+        invalid_method rescue StandardError
+      end
+    RUBY
+  end
+
+  it "does not register an offense when the else block has `while` node" do
+    expect_no_offenses(<<~RUBY)
+      if a.present?
+        a
+      else
+        fetch_state while waiting?
+      end
+    RUBY
+  end
+
+  it "does not register an offense when using #present? with elsif block" do
+    expect_no_offenses(<<~RUBY)
+      if something?
+        a
+      elsif b.present?
+        b
+      end
+    RUBY
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/present_spec.rb b/Library/Homebrew/test/rubocops/present_spec.rb
new file mode 100644
index 0000000000000..1c2264583284e
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/present_spec.rb
@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "rubocops/present"
+
+RSpec.describe RuboCop::Cop::Homebrew::Present, :config do
+  shared_examples "offense" do |source, correction, message|
+    it "registers an offense and corrects" do
+      expect_offense(<<~RUBY, source:, message:)
+        #{source}
+        ^{source} #{message}
+      RUBY
+
+      expect_correction(<<~RUBY)
+        #{correction}
+      RUBY
+    end
+  end
+
+  it "accepts checking nil?" do
+    expect_no_offenses("foo.nil?")
+  end
+
+  it "accepts checking empty?" do
+    expect_no_offenses("foo.empty?")
+  end
+
+  it "accepts checking nil? || empty? on different objects" do
+    expect_no_offenses("foo.nil? || bar.empty?")
+  end
+
+  it "accepts checking existence && not empty? on different objects" do
+    expect_no_offenses("foo && !bar.empty?")
+  end
+
+  it_behaves_like "offense", "foo && !foo.empty?",
+                  "foo.present?",
+                  "Use `foo.present?` instead of `foo && !foo.empty?`."
+  it_behaves_like "offense", "!foo.nil? && !foo.empty?",
+                  "foo.present?",
+                  "Use `foo.present?` instead of `!foo.nil? && !foo.empty?`."
+  it_behaves_like "offense", "!nil? && !empty?", "present?",
+                  "Use `present?` instead of `!nil? && !empty?`."
+  it_behaves_like "offense", "foo != nil && !foo.empty?",
+                  "foo.present?",
+                  "Use `foo.present?` instead of `foo != nil && !foo.empty?`."
+  it_behaves_like "offense", "!!foo && !foo.empty?",
+                  "foo.present?",
+                  "Use `foo.present?` instead of `!!foo && !foo.empty?`."
+
+  context "when checking all variable types" do
+    it_behaves_like "offense", "!foo.nil? && !foo.empty?",
+                    "foo.present?",
+                    "Use `foo.present?` instead of " \
+                    "`!foo.nil? && !foo.empty?`."
+    it_behaves_like "offense", "!foo.bar.nil? && !foo.bar.empty?",
+                    "foo.bar.present?",
+                    "Use `foo.bar.present?` instead of " \
+                    "`!foo.bar.nil? && !foo.bar.empty?`."
+    it_behaves_like "offense", "!FOO.nil? && !FOO.empty?",
+                    "FOO.present?",
+                    "Use `FOO.present?` instead of " \
+                    "`!FOO.nil? && !FOO.empty?`."
+    it_behaves_like "offense", "!Foo.nil? && !Foo.empty?",
+                    "Foo.present?",
+                    "Use `Foo.present?` instead of " \
+                    "`!Foo.nil? && !Foo.empty?`."
+    it_behaves_like "offense", "!@foo.nil? && !@foo.empty?",
+                    "@foo.present?",
+                    "Use `@foo.present?` instead of " \
+                    "`!@foo.nil? && !@foo.empty?`."
+    it_behaves_like "offense", "!$foo.nil? && !$foo.empty?",
+                    "$foo.present?",
+                    "Use `$foo.present?` instead of " \
+                    "`!$foo.nil? && !$foo.empty?`."
+    it_behaves_like "offense", "!@@foo.nil? && !@@foo.empty?",
+                    "@@foo.present?",
+                    "Use `@@foo.present?` instead of " \
+                    "`!@@foo.nil? && !@@foo.empty?`."
+    it_behaves_like "offense", "!foo[bar].nil? && !foo[bar].empty?",
+                    "foo[bar].present?",
+                    "Use `foo[bar].present?` instead of " \
+                    "`!foo[bar].nil? && !foo[bar].empty?`."
+    it_behaves_like "offense", "!Foo::Bar.nil? && !Foo::Bar.empty?",
+                    "Foo::Bar.present?",
+                    "Use `Foo::Bar.present?` instead of " \
+                    "`!Foo::Bar.nil? && !Foo::Bar.empty?`."
+    it_behaves_like "offense", "!foo(bar).nil? && !foo(bar).empty?",
+                    "foo(bar).present?",
+                    "Use `foo(bar).present?` instead of " \
+                    "`!foo(bar).nil? && !foo(bar).empty?`."
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/provided_by_macos_spec.rb b/Library/Homebrew/test/rubocops/provided_by_macos_spec.rb
index 64ad615094a93..0fa2145e8c4c9 100644
--- a/Library/Homebrew/test/rubocops/provided_by_macos_spec.rb
+++ b/Library/Homebrew/test/rubocops/provided_by_macos_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/uses_from_macos"
 
-describe RuboCop::Cop::FormulaAudit::ProvidedByMacos do
+RSpec.describe RuboCop::Cop::FormulaAudit::ProvidedByMacos do
   subject(:cop) { described_class.new }
 
   it "fails for formulae not in PROVIDED_BY_MACOS_FORMULAE list" do
@@ -13,7 +12,7 @@ class Baz < Formula
         homepage "https://brew.sh"
 
         keg_only :provided_by_macos
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Formulae that are `keg_only :provided_by_macos` should be added to the `PROVIDED_BY_MACOS_FORMULAE` list (in the Homebrew/brew repo)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ProvidedByMacos: Formulae that are `keg_only :provided_by_macos` should be added to the `PROVIDED_BY_MACOS_FORMULAE` list (in the Homebrew/brew repo)
       end
     RUBY
   end
diff --git a/Library/Homebrew/test/rubocops/resource_requires_dependencies_spec.rb b/Library/Homebrew/test/rubocops/resource_requires_dependencies_spec.rb
new file mode 100644
index 0000000000000..989918c7bd36a
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/resource_requires_dependencies_spec.rb
@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "rubocops/resource_requires_dependencies"
+
+RSpec.describe RuboCop::Cop::FormulaAudit::ResourceRequiresDependencies do
+  subject(:cop) { described_class.new }
+
+  context "when a formula does not have any resources" do
+    it "does not report offenses" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+
+          uses_from_macos "libxml2"
+        end
+      RUBY
+    end
+  end
+
+  context "when a formula does not have the lxml resource" do
+    it "does not report offenses" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+
+          uses_from_macos "libxml2"
+
+          resource "not-lxml" do
+            url "blah"
+            sha256 "blah"
+          end
+        end
+      RUBY
+    end
+  end
+
+  context "when a formula has the lxml resource" do
+    it "does not report offenses if the dependencies are present" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+
+          uses_from_macos "libxml2"
+          uses_from_macos "libxslt"
+
+          resource "lxml" do
+            url "blah"
+            sha256 "blah"
+          end
+        end
+      RUBY
+    end
+
+    it "reports offenses if missing a dependency" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+
+          uses_from_macos "libsomethingelse"
+          uses_from_macos "not_libxml2"
+
+          resource "lxml" do
+          ^^^^^^^^^^^^^^^ FormulaAudit/ResourceRequiresDependencies: Add `uses_from_macos` lines above for `"libxml2"` and `"libxslt"`.
+            url "blah"
+            sha256 "blah"
+          end
+        end
+      RUBY
+    end
+  end
+
+  context "when a formula does not have the pyyaml resource" do
+    it "does not report offenses" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+
+          uses_from_macos "libxml2"
+
+          resource "not-pyyaml" do
+            url "blah"
+            sha256 "blah"
+          end
+        end
+      RUBY
+    end
+  end
+
+  context "when a formula has the pyyaml resource" do
+    it "does not report offenses if the dependencies are present" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+
+          depends_on "libyaml"
+
+          resource "pyyaml" do
+            url "blah"
+            sha256 "blah"
+          end
+        end
+      RUBY
+    end
+
+    it "reports offenses if missing a dependency" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+
+          depends_on "not_libyaml"
+
+          resource "pyyaml" do
+          ^^^^^^^^^^^^^^^^^ FormulaAudit/ResourceRequiresDependencies: Add `depends_on` lines above for `"libyaml"`.
+            url "blah"
+            sha256 "blah"
+          end
+        end
+      RUBY
+    end
+  end
+
+  context "when a formula has multiple resources" do
+    it "reports offenses for each resource that is missing a dependency" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+
+          uses_from_macos "one"
+          uses_from_macos "two"
+          depends_on "three"
+
+          resource "lxml" do
+          ^^^^^^^^^^^^^^^ FormulaAudit/ResourceRequiresDependencies: Add `uses_from_macos` lines above for `"libxml2"` and `"libxslt"`.
+            url "blah"
+            sha256 "blah"
+          end
+
+          resource "pyyaml" do
+          ^^^^^^^^^^^^^^^^^ FormulaAudit/ResourceRequiresDependencies: Add `depends_on` lines above for `"libyaml"`.
+            url "blah"
+            sha256 "blah"
+          end
+        end
+      RUBY
+    end
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/safe_navigation_with_blank_spec.rb b/Library/Homebrew/test/rubocops/safe_navigation_with_blank_spec.rb
new file mode 100644
index 0000000000000..0b057fbeceadf
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/safe_navigation_with_blank_spec.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rubocops/safe_navigation_with_blank"
+
+RSpec.describe RuboCop::Cop::Homebrew::SafeNavigationWithBlank, :config do
+  context "when in a conditional" do
+    it "registers an offense on a single conditional" do
+      expect_offense(<<~RUBY)
+        do_something unless foo&.blank?
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Avoid calling `blank?` with the safe navigation operator in conditionals.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        do_something unless foo.blank?
+      RUBY
+    end
+
+    it "registers an offense on chained conditionals" do
+      expect_offense(<<~RUBY)
+        do_something unless foo&.bar&.blank?
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Avoid calling `blank?` with the safe navigation operator in conditionals.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        do_something unless foo&.bar.blank?
+      RUBY
+    end
+
+    it "does not register an offense on `.blank?`" do
+      expect_no_offenses(<<~RUBY)
+        return if foo.blank?
+      RUBY
+    end
+  end
+
+  context "when outside a conditional" do
+    it "registers no offense" do
+      expect_no_offenses(<<~RUBY)
+        bar = foo&.blank?
+      RUBY
+    end
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/service_spec.rb b/Library/Homebrew/test/rubocops/service_spec.rb
new file mode 100644
index 0000000000000..aa04b7355c19c
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/service_spec.rb
@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "rubocops/service"
+
+RSpec.describe RuboCop::Cop::FormulaAudit::Service do
+  subject(:cop) { described_class.new }
+
+  it "reports offenses when a service block is missing a required command" do
+    expect_offense(<<~RUBY)
+      class Foo < Formula
+        url "https://brew.sh/foo-1.0.tgz"
+
+        service do
+        ^^^^^^^^^^ FormulaAudit/Service: Service blocks require `run` or `name` to be defined.
+          run_type :cron
+          working_dir "/tmp/example"
+        end
+      end
+    RUBY
+  end
+
+  it "reports no offenses when a service block includes custom names and requires root" do
+    expect_no_offenses(<<~RUBY)
+      class Foo < Formula
+        url "https://brew.sh/foo-1.0.tgz"
+
+        service do
+          name macos: "custom.mcxl.foo", linux: "custom.foo"
+          require_root true
+        end
+      end
+    RUBY
+  end
+
+  it "reports offenses when a service block includes more than custom names and no run command" do
+    expect_offense(<<~RUBY)
+      class Foo < Formula
+        url "https://brew.sh/foo-1.0.tgz"
+
+        service do
+        ^^^^^^^^^^ FormulaAudit/Service: `run` must be defined to use methods other than `name` like [:working_dir].
+          name macos: "custom.mcxl.foo", linux: "custom.foo"
+          working_dir "/tmp/example"
+        end
+      end
+    RUBY
+  end
+
+  it "reports offenses when a formula's service block uses cellar paths" do
+    expect_offense(<<~RUBY)
+      class Foo < Formula
+        url "https://brew.sh/foo-1.0.tgz"
+
+        service do
+          run [bin/"foo", "run", "-config", etc/"foo/config.json"]
+               ^^^ FormulaAudit/Service: Use `opt_bin` instead of `bin` in service blocks.
+          working_dir libexec
+                      ^^^^^^^ FormulaAudit/Service: Use `opt_libexec` instead of `libexec` in service blocks.
+        end
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      class Foo < Formula
+        url "https://brew.sh/foo-1.0.tgz"
+
+        service do
+          run [opt_bin/"foo", "run", "-config", etc/"foo/config.json"]
+          working_dir opt_libexec
+        end
+      end
+    RUBY
+  end
+
+  it "reports no offenses when a service block only uses opt paths" do
+    expect_no_offenses(<<~RUBY)
+      class Bin < Formula
+        url "https://brew.sh/foo-1.0.tgz"
+
+        service do
+          run [opt_bin/"bin", "run", "-config", etc/"bin/config.json"]
+          working_dir opt_libexec
+        end
+      end
+    RUBY
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/shell_commands_spec.rb b/Library/Homebrew/test/rubocops/shell_commands_spec.rb
index d13592cf9cde0..bcd8601ea9505 100644
--- a/Library/Homebrew/test/rubocops/shell_commands_spec.rb
+++ b/Library/Homebrew/test/rubocops/shell_commands_spec.rb
@@ -1,241 +1,211 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/shell_commands"
 
-module RuboCop
-  module Cop
-    module Homebrew
-      describe ShellCommands do
-        subject(:cop) { described_class.new }
-
-        context "when auditing shell commands" do
-          it "reports and corrects an offense when `system` arguments should be separated" do
-            expect_offense(<<~RUBY)
-              class Foo < Formula
-                def install
-                  system "foo bar"
-                         ^^^^^^^^^ Separate `system` commands into `\"foo\", \"bar\"`
-                end
-              end
-            RUBY
-
-            expect_correction(<<~RUBY)
-              class Foo < Formula
-                def install
-                  system "foo", "bar"
-                end
-              end
-            RUBY
-          end
-
-          it "reports and corrects an offense when `system` arguments involving interpolation should be separated" do
-            expect_offense(<<~RUBY)
-              class Foo < Formula
-                def install
-                  system "\#{bin}/foo bar"
-                         ^^^^^^^^^^^^^^^^ Separate `system` commands into `\"\#{bin}/foo\", \"bar\"`
-                end
-              end
-            RUBY
-
-            expect_correction(<<~RUBY)
-              class Foo < Formula
-                def install
-                  system "\#{bin}/foo", "bar"
-                end
-              end
-            RUBY
-          end
-
-          it "reports no offenses when `system` with metacharacter arguments are called" do
-            expect_no_offenses(<<~RUBY)
-              class Foo < Formula
-                def install
-                  system "foo bar > baz"
-                end
-              end
-            RUBY
-          end
-
-          it "reports no offenses when trailing arguments to `system` are unseparated" do
-            expect_no_offenses(<<~RUBY)
-              class Foo < Formula
-                def install
-                  system "foo", "bar baz"
-                end
-              end
-            RUBY
-          end
-
-          it "reports no offenses when `Utils.popen` arguments are unseparated" do
-            expect_no_offenses(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.popen("foo bar")
-                end
-              end
-            RUBY
-          end
-
-          it "reports and corrects an offense when `Utils.popen_read` arguments are unseparated" do
-            expect_offense(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.popen_read("foo bar")
-                                   ^^^^^^^^^ Separate `Utils.popen_read` commands into `\"foo\", \"bar\"`
-                end
-              end
-            RUBY
-
-            expect_correction(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.popen_read("foo", "bar")
-                end
-              end
-            RUBY
-          end
-
-          it "reports and corrects an offense when `Utils.safe_popen_read` arguments are unseparated" do
-            expect_offense(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.safe_popen_read("foo bar")
-                                        ^^^^^^^^^ Separate `Utils.safe_popen_read` commands into `\"foo\", \"bar\"`
-                end
-              end
-            RUBY
-
-            expect_correction(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.safe_popen_read("foo", "bar")
-                end
-              end
-            RUBY
-          end
-
-          it "reports and corrects an offense when `Utils.popen_write` arguments are unseparated" do
-            expect_offense(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.popen_write("foo bar")
-                                    ^^^^^^^^^ Separate `Utils.popen_write` commands into `\"foo\", \"bar\"`
-                end
-              end
-            RUBY
-
-            expect_correction(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.popen_write("foo", "bar")
-                end
-              end
-            RUBY
-          end
-
-          it "reports and corrects an offense when `Utils.safe_popen_write` arguments are unseparated" do
-            expect_offense(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.safe_popen_write("foo bar")
-                                         ^^^^^^^^^ Separate `Utils.safe_popen_write` commands into `\"foo\", \"bar\"`
-                end
-              end
-            RUBY
-
-            expect_correction(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.safe_popen_write("foo", "bar")
-                end
-              end
-            RUBY
-          end
-
-          it "reports and corrects an offense when `Utils.popen_read` arguments with interpolation are unseparated" do
-            expect_offense(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.popen_read("\#{bin}/foo bar")
-                                   ^^^^^^^^^^^^^^^^ Separate `Utils.popen_read` commands into `\"\#{bin}/foo\", \"bar\"`
-                end
-              end
-            RUBY
-
-            expect_correction(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.popen_read("\#{bin}/foo", "bar")
-                end
-              end
-            RUBY
-          end
-
-          it "reports no offenses when `Utils.popen_read` arguments with metacharacters are unseparated" do
-            expect_no_offenses(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.popen_read("foo bar > baz")
-                end
-              end
-            RUBY
-          end
-
-          it "reports no offenses when trailing arguments to `Utils.popen_read` are unseparated" do
-            expect_no_offenses(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.popen_read("foo", "bar baz")
-                end
-              end
-            RUBY
-          end
-
-          it "reports and corrects an offense when `Utils.popen_read` arguments are unseparated after a shell env" do
-            expect_offense(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.popen_read({ "SHELL" => "bash"}, "foo bar")
-                                                         ^^^^^^^^^ Separate `Utils.popen_read` commands into `\"foo\", \"bar\"`
-                end
-              end
-            RUBY
-
-            expect_correction(<<~RUBY)
-              class Foo < Formula
-                def install
-                  Utils.popen_read({ "SHELL" => "bash"}, "foo", "bar")
-                end
-              end
-            RUBY
-          end
-        end
-      end
-
-      describe ExecShellMetacharacters do
-        subject(:cop) { described_class.new }
-
-        context "when auditing exec calls" do
-          it "reports aan offense when output piping is used" do
-            expect_offense(<<~RUBY)
-              fork do
-                exec "foo bar > output"
-                     ^^^^^^^^^^^^^^^^^^ Don\'t use shell metacharacters in `exec`. Implement the logic in Ruby instead, using methods like `$stdout.reopen`.
-              end
-            RUBY
-          end
-
-          it "reports no offenses when no metacharacters are used" do
-            expect_no_offenses(<<~RUBY)
-              fork do
-                exec "foo bar"
-              end
-            RUBY
-          end
-        end
-      end
+RSpec.describe RuboCop::Cop::Homebrew::ShellCommands do
+  subject(:cop) { described_class.new }
+
+  context "when auditing shell commands" do
+    it "reports and corrects an offense when `system` arguments should be separated" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          def install
+            system "foo bar"
+                   ^^^^^^^^^ Homebrew/ShellCommands: Separate `system` commands into `"foo", "bar"`
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          def install
+            system "foo", "bar"
+          end
+        end
+      RUBY
+    end
+
+    it "reports and corrects an offense when `system` arguments involving interpolation should be separated" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          def install
+            system "\#{bin}/foo bar"
+                   ^^^^^^^^^^^^^^^^ Homebrew/ShellCommands: Separate `system` commands into `"\#{bin}/foo", "bar"`
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          def install
+            system "\#{bin}/foo", "bar"
+          end
+        end
+      RUBY
+    end
+
+    it "reports no offenses when `system` with metacharacter arguments are called" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          def install
+            system "foo bar > baz"
+          end
+        end
+      RUBY
+    end
+
+    it "reports no offenses when trailing arguments to `system` are unseparated" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          def install
+            system "foo", "bar baz"
+          end
+        end
+      RUBY
+    end
+
+    it "reports no offenses when `Utils.popen` arguments are unseparated" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.popen("foo bar")
+          end
+        end
+      RUBY
+    end
+
+    it "reports and corrects an offense when `Utils.popen_read` arguments are unseparated" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.popen_read("foo bar")
+                             ^^^^^^^^^ Homebrew/ShellCommands: Separate `Utils.popen_read` commands into `"foo", "bar"`
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.popen_read("foo", "bar")
+          end
+        end
+      RUBY
+    end
+
+    it "reports and corrects an offense when `Utils.safe_popen_read` arguments are unseparated" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.safe_popen_read("foo bar")
+                                  ^^^^^^^^^ Homebrew/ShellCommands: Separate `Utils.safe_popen_read` commands into `"foo", "bar"`
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.safe_popen_read("foo", "bar")
+          end
+        end
+      RUBY
+    end
+
+    it "reports and corrects an offense when `Utils.popen_write` arguments are unseparated" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.popen_write("foo bar")
+                              ^^^^^^^^^ Homebrew/ShellCommands: Separate `Utils.popen_write` commands into `"foo", "bar"`
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.popen_write("foo", "bar")
+          end
+        end
+      RUBY
+    end
+
+    it "reports and corrects an offense when `Utils.safe_popen_write` arguments are unseparated" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.safe_popen_write("foo bar")
+                                   ^^^^^^^^^ Homebrew/ShellCommands: Separate `Utils.safe_popen_write` commands into `"foo", "bar"`
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.safe_popen_write("foo", "bar")
+          end
+        end
+      RUBY
+    end
+
+    it "reports and corrects an offense when `Utils.popen_read` arguments with interpolation are unseparated" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.popen_read("\#{bin}/foo bar")
+                             ^^^^^^^^^^^^^^^^ Homebrew/ShellCommands: Separate `Utils.popen_read` commands into `"\#{bin}/foo", "bar"`
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.popen_read("\#{bin}/foo", "bar")
+          end
+        end
+      RUBY
+    end
+
+    it "reports no offenses when `Utils.popen_read` arguments with metacharacters are unseparated" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.popen_read("foo bar > baz")
+          end
+        end
+      RUBY
+    end
+
+    it "reports no offenses when trailing arguments to `Utils.popen_read` are unseparated" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.popen_read("foo", "bar baz")
+          end
+        end
+      RUBY
+    end
+
+    it "reports and corrects an offense when `Utils.popen_read` arguments are unseparated after a shell env" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.popen_read({ "SHELL" => "bash"}, "foo bar")
+                                                   ^^^^^^^^^ Homebrew/ShellCommands: Separate `Utils.popen_read` commands into `"foo", "bar"`
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          def install
+            Utils.popen_read({ "SHELL" => "bash"}, "foo", "bar")
+          end
+        end
+      RUBY
     end
   end
 end
diff --git a/Library/Homebrew/test/rubocops/text/assert_statements_spec.rb b/Library/Homebrew/test/rubocops/text/assert_statements_spec.rb
index 90cce65e23aed..3444a0f525f6a 100644
--- a/Library/Homebrew/test/rubocops/text/assert_statements_spec.rb
+++ b/Library/Homebrew/test/rubocops/text/assert_statements_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/lines"
 
-describe RuboCop::Cop::FormulaAudit::AssertStatements do
+RSpec.describe RuboCop::Cop::FormulaAudit::AssertStatements do
   subject(:cop) { described_class.new }
 
   context "when auditing formula assertions" do
@@ -13,7 +12,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           assert File.read("inbox").include?("Sample message 1")
-                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `assert_match` instead of `assert ...include?`
+                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/AssertStatements: Use `assert_match` instead of `assert ...include?`
         end
       RUBY
     end
@@ -24,7 +23,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           assert File.exist? "default.ini"
-                 ^^^^^^^^^^^^^^^^^^^^^^^^^ Use `assert_predicate <path_to_file>, :exist?` instead of `assert File.exist? "default.ini"`
+                 ^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/AssertStatements: Use `assert_predicate <path_to_file>, :exist?` instead of `assert File.exist? "default.ini"`
         end
       RUBY
     end
@@ -35,7 +34,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           assert !File.exist?("default.ini")
-                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `refute_predicate <path_to_file>, :exist?` instead of `assert !File.exist?("default.ini")`
+                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/AssertStatements: Use `refute_predicate <path_to_file>, :exist?` instead of `assert !File.exist?("default.ini")`
         end
       RUBY
     end
@@ -46,7 +45,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           assert File.executable? f
-                 ^^^^^^^^^^^^^^^^^^ Use `assert_predicate <path_to_file>, :executable?` instead of `assert File.executable? f`
+                 ^^^^^^^^^^^^^^^^^^ FormulaAudit/AssertStatements: Use `assert_predicate <path_to_file>, :executable?` instead of `assert File.executable? f`
         end
       RUBY
     end
diff --git a/Library/Homebrew/test/rubocops/text/comments_spec.rb b/Library/Homebrew/test/rubocops/text/comments_spec.rb
index 0861b7f5434d6..3b1817c473b29 100644
--- a/Library/Homebrew/test/rubocops/text/comments_spec.rb
+++ b/Library/Homebrew/test/rubocops/text/comments_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/lines"
 
-describe RuboCop::Cop::FormulaAudit::Comments do
+RSpec.describe RuboCop::Cop::FormulaAudit::Comments do
   subject(:cop) { described_class.new }
 
   context "when auditing comment text" do
@@ -13,7 +12,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           # system "cmake", ".", *std_cmake_args
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Please remove default template comments
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Comments: Please remove default template comments
         end
       RUBY
     end
@@ -22,7 +21,7 @@ class Foo < Formula
       expect_offense(<<~RUBY)
         class Foo < Formula
           # PLEASE REMOVE
-          ^^^^^^^^^^^^^^^ Please remove default template comments
+          ^^^^^^^^^^^^^^^ FormulaAudit/Comments: Please remove default template comments
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
         end
@@ -35,7 +34,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           # depends_on "foo"
-          ^^^^^^^^^^^^^^^^^^ Commented-out dependency "foo"
+          ^^^^^^^^^^^^^^^^^^ FormulaAudit/Comments: Commented-out dependency "foo"
         end
       RUBY
     end
@@ -46,11 +45,11 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           # cite Howell_2009:
-          ^^^^^^^^^^^^^^^^^^^ Formulae in homebrew/core should not use `cite` comments
+          ^^^^^^^^^^^^^^^^^^^ FormulaAudit/Comments: Formulae in homebrew/core should not use `cite` comments
           # doi "10.111/222.x"
-          ^^^^^^^^^^^^^^^^^^^^ Formulae in homebrew/core should not use `doi` comments
+          ^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Comments: Formulae in homebrew/core should not use `doi` comments
           # tag "software"
-          ^^^^^^^^^^^^^^^^ Formulae in homebrew/core should not use `tag` comments
+          ^^^^^^^^^^^^^^^^ FormulaAudit/Comments: Formulae in homebrew/core should not use `tag` comments
         end
       RUBY
     end
diff --git a/Library/Homebrew/test/rubocops/text/license_arrays_spec.rb b/Library/Homebrew/test/rubocops/text/license_arrays_spec.rb
index 2cbadfaa60930..c009b84c13da5 100644
--- a/Library/Homebrew/test/rubocops/text/license_arrays_spec.rb
+++ b/Library/Homebrew/test/rubocops/text/license_arrays_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/lines"
 
-describe RuboCop::Cop::FormulaAudit::LicenseArrays do
+RSpec.describe RuboCop::Cop::FormulaAudit::LicenseArrays do
   subject(:cop) { described_class.new }
 
   context "when auditing license arrays" do
@@ -43,7 +42,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           license ["MIT", "0BSD"]
-          ^^^^^^^^^^^^^^^^^^^^^^^ Use `license any_of: ["MIT", "0BSD"]` instead of `license ["MIT", "0BSD"]`
+          ^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/LicenseArrays: Use `license any_of: ["MIT", "0BSD"]` instead of `license ["MIT", "0BSD"]`
         end
       RUBY
 
diff --git a/Library/Homebrew/test/rubocops/text/licenses_spec.rb b/Library/Homebrew/test/rubocops/text/licenses_spec.rb
index 5fc3fe1f7408d..d45c2445bbab7 100644
--- a/Library/Homebrew/test/rubocops/text/licenses_spec.rb
+++ b/Library/Homebrew/test/rubocops/text/licenses_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/lines"
 
-describe RuboCop::Cop::FormulaAudit::Licenses do
+RSpec.describe RuboCop::Cop::FormulaAudit::Licenses do
   subject(:cop) { described_class.new }
 
   context "when auditing licenses" do
@@ -80,7 +79,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           license any_of: ["MIT", all_of: ["0BSD", "Zlib"]]
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Split nested license declarations onto multiple lines
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Licenses: Split nested license declarations onto multiple lines
         end
       RUBY
     end
diff --git a/Library/Homebrew/test/rubocops/text/macos_on_linux_spec.rb b/Library/Homebrew/test/rubocops/text/macos_on_linux_spec.rb
new file mode 100644
index 0000000000000..c34022e04d534
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/text/macos_on_linux_spec.rb
@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "rubocops/lines"
+
+RSpec.describe RuboCop::Cop::FormulaAudit::MacOSOnLinux do
+  subject(:cop) { described_class.new }
+
+  it "reports an offense when `MacOS` is used in the `Formula` class" do
+    expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+      class Foo < Formula
+        desc "foo"
+        if MacOS::Xcode.version >= "12.0"
+           ^^^^^ FormulaAudit/MacOSOnLinux: Don't use `MacOS` where it could be called on Linux.
+          url 'https://brew.sh/linux-1.0.tgz'
+        end
+      end
+    RUBY
+  end
+
+  it "reports an offense when `MacOS` is used in a `resource` block" do
+    expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+      class Foo < Formula
+        desc "foo"
+        url 'https://brew.sh/linux-1.0.tgz'
+
+        resource "foo" do
+          url "https://brew.sh/linux-1.0.tgz" if MacOS::full_version >= "12.0"
+                                                 ^^^^^ FormulaAudit/MacOSOnLinux: Don't use `MacOS` where it could be called on Linux.
+        end
+      end
+    RUBY
+  end
+
+  it "reports an offense when `MacOS` is used in an `on_linux` block" do
+    expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+      class Foo < Formula
+        desc "foo"
+        on_linux do
+          if MacOS::Xcode.version >= "12.0"
+             ^^^^^ FormulaAudit/MacOSOnLinux: Don't use `MacOS` where it could be called on Linux.
+            url 'https://brew.sh/linux-1.0.tgz'
+          end
+        end
+      end
+    RUBY
+  end
+
+  it "reports an offense when `MacOS` is used in an `on_arm` block" do
+    expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+      class Foo < Formula
+        desc "foo"
+        on_arm do
+          if MacOS::Xcode.version >= "12.0"
+             ^^^^^ FormulaAudit/MacOSOnLinux: Don't use `MacOS` where it could be called on Linux.
+            url 'https://brew.sh/linux-1.0.tgz'
+          end
+        end
+      end
+    RUBY
+  end
+
+  it "reports an offense when `MacOS` is used in an `on_intel` block" do
+    expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+      class Foo < Formula
+        desc "foo"
+        on_intel do
+          if MacOS::Xcode.version >= "12.0"
+             ^^^^^ FormulaAudit/MacOSOnLinux: Don't use `MacOS` where it could be called on Linux.
+            url 'https://brew.sh/linux-1.0.tgz'
+          end
+        end
+      end
+    RUBY
+  end
+
+  it "reports no offenses when `MacOS` is used in an `on_macos` block" do
+    expect_no_offenses(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+      class Foo < Formula
+        desc "foo"
+        on_macos do
+          if MacOS::Xcode.version >= "12.0"
+            url 'https://brew.sh/linux-1.0.tgz'
+          end
+        end
+      end
+    RUBY
+  end
+
+  it "reports no offenses when `MacOS` is used in an `on_ventura` block" do
+    expect_no_offenses(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+      class Foo < Formula
+        desc "foo"
+        on_ventura :or_older do
+          if MacOS::Xcode.version >= "12.0"
+            url 'https://brew.sh/linux-1.0.tgz'
+          end
+        end
+      end
+    RUBY
+  end
+
+  it "reports no offenses when `MacOS` is used in the `install` method" do
+    expect_no_offenses(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+      class Foo < Formula
+        desc "foo"
+        url 'https://brew.sh/linux-1.0.tgz'
+
+        def install
+          MacOS.version
+        end
+      end
+    RUBY
+  end
+
+  it "reports no offenses when `MacOS` is used in the `test` block" do
+    expect_no_offenses(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+      class Foo < Formula
+        desc "foo"
+        url 'https://brew.sh/linux-1.0.tgz'
+
+        test do
+          MacOS.version
+        end
+      end
+    RUBY
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/text/make_check_spec.rb b/Library/Homebrew/test/rubocops/text/make_check_spec.rb
index da902cdfe0a30..274f4576009b8 100644
--- a/Library/Homebrew/test/rubocops/text/make_check_spec.rb
+++ b/Library/Homebrew/test/rubocops/text/make_check_spec.rb
@@ -1,12 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/lines"
 
-describe RuboCop::Cop::FormulaAuditStrict::MakeCheck do
+RSpec.describe RuboCop::Cop::FormulaAuditStrict::MakeCheck do
   subject(:cop) { described_class.new }
 
-  let(:path) { Tap::TAP_DIRECTORY/"homebrew/homebrew-core" }
+  let(:path) { HOMEBREW_TAP_DIRECTORY/"homebrew/homebrew-core" }
 
   before do
     path.mkpath
@@ -27,7 +26,7 @@ class Foo < Formula
         desc "foo"
         url 'https://brew.sh/foo-1.0.tgz'
         system "make", "-j1", "test"
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Formulae in homebrew/core (except e.g. cryptography, libraries) should not run build-time checks
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAuditStrict/MakeCheck: Formulae in homebrew/core (except e.g. cryptography, libraries) should not run build-time checks
       end
     RUBY
   end
diff --git a/Library/Homebrew/test/rubocops/text/miscellaneous_spec.rb b/Library/Homebrew/test/rubocops/text/miscellaneous_spec.rb
index 7482000c2d819..baa6a32e6d1ca 100644
--- a/Library/Homebrew/test/rubocops/text/miscellaneous_spec.rb
+++ b/Library/Homebrew/test/rubocops/text/miscellaneous_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/lines"
 
-describe RuboCop::Cop::FormulaAudit::Miscellaneous do
+RSpec.describe RuboCop::Cop::FormulaAudit::Miscellaneous do
   subject(:cop) { described_class.new }
 
   context "when auditing formula miscellany" do
@@ -13,7 +12,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           FileUtils.mv "hello"
-          ^^^^^^^^^^^^^^^^^^^^ Don\'t need \'FileUtils.\' before mv
+          ^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: Don't need 'FileUtils.' before mv
         end
       RUBY
     end
@@ -24,7 +23,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           inreplace "foo" do |longvar|
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ \"inreplace <filenames> do |s|\" is preferred over \"|longvar|\".
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: "inreplace <filenames> do |s|" is preferred over "|longvar|".
             somerandomCall(longvar)
           end
         end
@@ -38,7 +37,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           bottle do
             rebuild 0
-            ^^^^^^^^^ 'rebuild 0' should be removed
+            ^^^^^^^^^ FormulaAudit/Miscellaneous: 'rebuild 0' should be removed
             sha256 "fe0679b932dd43a87fd415b609a7fbac7a069d117642ae8ebaac46ae1fb9f0b3" => :sierra
           end
         end
@@ -54,7 +53,7 @@ class Foo < Formula
             sha256 "fe0679b932dd43a87fd415b609a7fbac7a069d117642ae8ebaac46ae1fb9f0b3" => :sierra
           end
           fails_with :llvm do
-          ^^^^^^^^^^^^^^^^ 'fails_with :llvm' is now a no-op so should be removed
+          ^^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: 'fails_with :llvm' is now a no-op so should be removed
             build 2335
             cause "foo"
           end
@@ -69,7 +68,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
 
           def test
-          ^^^^^^^^ Use new-style test definitions (test do)
+          ^^^^^^^^ FormulaAudit/Miscellaneous: Use new-style test definitions (test do)
             assert_equals "1", "1"
           end
         end
@@ -82,7 +81,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           skip_clean :all
-          ^^^^^^^^^^^^^^^ `skip_clean :all` is deprecated; brew no longer strips symbols. Pass explicit paths to prevent Homebrew from removing empty folders.
+          ^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: `skip_clean :all` is deprecated; brew no longer strips symbols. Pass explicit paths to prevent Homebrew from removing empty folders.
         end
       RUBY
     end
@@ -93,7 +92,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           if build.universal?
-             ^^^^^^^^^^^^^^^^ macOS has been 64-bit only since 10.6 so build.universal? is deprecated.
+             ^^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: macOS has been 64-bit only since 10.6 so build.universal? is deprecated.
              "foo"
           end
         end
@@ -119,7 +118,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           if build?
              ENV.universal_binary
-             ^^^^^^^^^^^^^^^^^^^^ macOS has been 64-bit only since 10.6 so ENV.universal_binary is deprecated.
+             ^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: macOS has been 64-bit only since 10.6 so ENV.universal_binary is deprecated.
           end
         end
       RUBY
@@ -143,28 +142,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           system "install_name_tool", "-id"
-                 ^^^^^^^^^^^^^^^^^^^ Use ruby-macho instead of calling "install_name_tool"
-        end
-      RUBY
-    end
-
-    it "reports an offense when `npm install` is called without Language::Node arguments" do
-      expect_offense(<<~RUBY)
-        class Foo < Formula
-          desc "foo"
-          url 'https://brew.sh/foo-1.0.tgz'
-          system "npm", "install"
-          ^^^^^^^^^^^^^^^^^^^^^^^ Use Language::Node for npm install args
-        end
-      RUBY
-    end
-
-    it "reports no offenses when `npm install` is called without Language::Node arguments in an exempt formula" do
-      expect_no_offenses(<<~RUBY, "/homebrew-core/Formula/kibana@4.4.rb")
-        class KibanaAT44 < Formula
-          desc "foo"
-          url 'https://brew.sh/foo-1.0.tgz'
-          system "npm", "install"
+                 ^^^^^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: Use ruby-macho instead of calling "install_name_tool"
         end
       RUBY
     end
@@ -175,7 +153,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           depends_on FOO::BAR.new
-                     ^^^^^^^^^^^^ `depends_on` can take requirement classes instead of instances
+                     ^^^^^^^^^^^^ FormulaAudit/Miscellaneous: `depends_on` can take requirement classes instead of instances
         end
       RUBY
     end
@@ -187,7 +165,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           rm_rf Dir["src/{llvm,test,librustdoc,etc/snapshot.pyc}"]
           rm_rf Dir["src/snapshot.pyc"]
-                    ^^^^^^^^^^^^^^^^^^ Dir(["src/snapshot.pyc"]) is unnecessary; just use "src/snapshot.pyc"
+                    ^^^^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: Dir(["src/snapshot.pyc"]) is unnecessary; just use "src/snapshot.pyc"
         end
       RUBY
     end
@@ -198,7 +176,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           system "mkdir", "foo"
-                 ^^^^^^^ Use the `mkdir` Ruby method instead of `system "mkdir", "foo"`
+                 ^^^^^^^ FormulaAudit/Miscellaneous: Use the `mkdir` Ruby method instead of `system "mkdir", "foo"`
         end
       RUBY
     end
@@ -206,7 +184,7 @@ class Foo < Formula
     it "reports an offense when top-level functions are defined outside of a class body" do
       expect_offense(<<~RUBY)
         def test
-        ^^^^^^^^ Define method test in the class body, not at the top-level
+        ^^^^^^^^ FormulaAudit/Miscellaneous: Define method test in the class body, not at the top-level
            nil
         end
         class Foo < Formula
@@ -223,7 +201,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def install
             man1.install man+"man8" => "faad.1"
-                             ^^^^^^ "man+"man8"" should be "man8"
+                             ^^^^^^ FormulaAudit/Miscellaneous: "man+"man8"" should be "man8"
           end
         end
       RUBY
@@ -236,7 +214,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def install
             system "/usr/bin/gcc", "foo"
-                   ^^^^^^^^^^^^^^ Use "#{ENV.cc}" instead of hard-coding "gcc"
+                   ^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: Use "#{ENV.cc}" instead of hard-coding "gcc"
           end
         end
       RUBY
@@ -249,20 +227,20 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def install
             system "/usr/bin/g++", "-o", "foo", "foo.cc"
-                   ^^^^^^^^^^^^^^ Use "#{ENV.cxx}" instead of hard-coding "g++"
+                   ^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: Use "#{ENV.cxx}" instead of hard-coding "g++"
           end
         end
       RUBY
     end
 
-    it "reports an offense when a hard-coded `llvm-g++` is set as COMPILER_PATH" do
+    it "reports an offense when a hard-coded `c++` is set as COMPILER_PATH" do
       expect_offense(<<~'RUBY')
         class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           def install
-            ENV["COMPILER_PATH"] = "/usr/bin/llvm-g++"
-                                   ^^^^^^^^^^^^^^^^^^^ Use "#{ENV.cxx}" instead of hard-coding "llvm-g++"
+            ENV["COMPILER_PATH"] = "/usr/bin/c++"
+                                   ^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: Use "#{ENV.cxx}" instead of hard-coding "c++"
           end
         end
       RUBY
@@ -275,7 +253,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def install
             ENV["COMPILER_PATH"] = "/usr/bin/gcc"
-                                   ^^^^^^^^^^^^^^ Use \"\#{ENV.cc}\" instead of hard-coding \"gcc\"
+                                   ^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: Use "\#{ENV.cc}" instead of hard-coding "gcc"
           end
         end
       RUBY
@@ -288,7 +266,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def install
             mv "#{share}/man", share
-                        ^^^^ "#{share}/man" should be "#{man}"
+                        ^^^^ FormulaAudit/Miscellaneous: "#{share}/man" should be "#{man}"
           end
         end
       RUBY
@@ -301,7 +279,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def install
             mv "#{prefix}/libexec", share
-                         ^^^^^^^^ "#{prefix}/libexec" should be "#{libexec}"
+                         ^^^^^^^^ FormulaAudit/Miscellaneous: "#{prefix}/libexec" should be "#{libexec}"
           end
         end
       RUBY
@@ -314,7 +292,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def install
             system "./configure", "--INFODIR=#{prefix}/share/info"
-                                                      ^^^^^^^^^^^ "#{prefix}/share/info" should be "#{info}"
+                                                      ^^^^^^^^^^^ FormulaAudit/Miscellaneous: "#{prefix}/share/info" should be "#{info}"
           end
         end
       RUBY
@@ -327,7 +305,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def install
             system "./configure", "--MANDIR=#{prefix}/share/man/man8"
-                                                     ^^^^^^^^^^^^^^^ "#{prefix}/share/man/man8" should be "#{man8}"
+                                                     ^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: "#{prefix}/share/man/man8" should be "#{man8}"
           end
         end
       RUBY
@@ -339,7 +317,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           depends_on "lpeg" => :lua51
-                               ^^^^^^ lua modules should be vendored rather than use deprecated `depends_on \"lpeg\" => :lua51`
+                               ^^^^^^ FormulaAudit/Miscellaneous: lua modules should be vendored rather than use deprecated `depends_on "lpeg" => :lua51`
         end
       RUBY
     end
@@ -350,7 +328,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           system "export", "var=value"
-                 ^^^^^^^^ Use ENV instead of invoking 'export' to modify the environment
+                 ^^^^^^^^ FormulaAudit/Miscellaneous: Use ENV instead of invoking 'export' to modify the environment
         end
       RUBY
     end
@@ -361,7 +339,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           depends_on "foo" => "with-bar"
-                              ^^^^^^^^^^ Dependency foo should not use option with-bar
+                              ^^^^^^^^^^ FormulaAudit/Miscellaneous: Dependency foo should not use option with-bar
         end
       RUBY
     end
@@ -373,9 +351,9 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           depends_on "httpd" => [:build, :test]
           depends_on "foo" => [:optional, "with-bar"]
-                                          ^^^^^^^^^^ Dependency foo should not use option with-bar
+                                          ^^^^^^^^^^ FormulaAudit/Miscellaneous: Dependency foo should not use option with-bar
           depends_on "icu4c" => [:optional, "c++11"]
-                                            ^^^^^^^ Dependency icu4c should not use option c++11
+                                            ^^^^^^^ FormulaAudit/Miscellaneous: Dependency icu4c should not use option c++11
         end
       RUBY
     end
@@ -386,7 +364,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           if version == "HEAD"
-             ^^^^^^^^^^^^^^^^^ Use 'build.head?' instead of inspecting 'version'
+             ^^^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: Use 'build.head?' instead of inspecting 'version'
             foo()
           end
         end
@@ -400,8 +378,8 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           test do
             head = ARGV.include? "--HEAD"
-                   ^^^^ Use build instead of ARGV to check options
-                   ^^^^^^^^^^^^^^^^^^^^^^ Use "if build.head?" instead
+                   ^^^^ FormulaAudit/Miscellaneous: Use build instead of ARGV to check options
+                   ^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: Use "if build.head?" instead
           end
         end
       RUBY
@@ -413,7 +391,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           needs :openmp
-          ^^^^^^^^^^^^^ 'needs :openmp' should be replaced with 'depends_on \"gcc\"'
+          ^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: 'needs :openmp' should be replaced with 'depends_on "gcc"'
         end
       RUBY
     end
@@ -425,7 +403,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           test do
             version = MACOS_VERSION
-                      ^^^^^^^^^^^^^ Use MacOS.version instead of MACOS_VERSION
+                      ^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: Use MacOS.version instead of MACOS_VERSION
           end
         end
       RUBY
@@ -437,7 +415,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           depends_on "foo" if build.with? "foo"
-          ^^^^^^^^^^^^^^^^ Replace depends_on "foo" if build.with? "foo" with depends_on "foo" => :optional
+          ^^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: Replace depends_on "foo" if build.with? "foo" with depends_on "foo" => :optional
         end
       RUBY
     end
@@ -448,7 +426,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           depends_on :foo unless build.without? "foo"
-          ^^^^^^^^^^^^^^^ Replace depends_on :foo unless build.without? "foo" with depends_on :foo => :recommended
+          ^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: Replace depends_on :foo unless build.without? "foo" with depends_on :foo => :recommended
         end
       RUBY
     end
@@ -459,7 +437,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           depends_on :foo unless build.include? "without-foo"
-          ^^^^^^^^^^^^^^^ Replace depends_on :foo unless build.include? "without-foo" with depends_on :foo => :recommended
+          ^^^^^^^^^^^^^^^ FormulaAudit/Miscellaneous: Replace depends_on :foo unless build.include? "without-foo" with depends_on :foo => :recommended
         end
       RUBY
     end
diff --git a/Library/Homebrew/test/rubocops/text/mpi_check_spec.rb b/Library/Homebrew/test/rubocops/text/mpi_check_spec.rb
index 56c944c2d0694..986f689c75915 100644
--- a/Library/Homebrew/test/rubocops/text/mpi_check_spec.rb
+++ b/Library/Homebrew/test/rubocops/text/mpi_check_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/lines"
 
-describe RuboCop::Cop::FormulaAudit::MpiCheck do
+RSpec.describe RuboCop::Cop::FormulaAudit::MpiCheck do
   subject(:cop) { described_class.new }
 
   context "when auditing MPI dependencies" do
@@ -13,7 +12,7 @@ class Foo < Formula
           desc "foo"
           url 'https://brew.sh/foo-1.0.tgz'
           depends_on "mpich"
-          ^^^^^^^^^^^^^^^^^^ Formulae in homebrew/core should use 'depends_on "open-mpi"' instead of 'depends_on "mpich"'.
+          ^^^^^^^^^^^^^^^^^^ FormulaAudit/MpiCheck: Formulae in homebrew/core should use 'depends_on "open-mpi"' instead of 'depends_on "mpich"'.
         end
       RUBY
 
diff --git a/Library/Homebrew/test/rubocops/text/on_system_conditionals_spec.rb b/Library/Homebrew/test/rubocops/text/on_system_conditionals_spec.rb
index 24ed0a1e864c3..9757208197e53 100644
--- a/Library/Homebrew/test/rubocops/text/on_system_conditionals_spec.rb
+++ b/Library/Homebrew/test/rubocops/text/on_system_conditionals_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/lines"
 
-describe RuboCop::Cop::FormulaAudit::OnSystemConditionals do
+RSpec.describe RuboCop::Cop::FormulaAudit::OnSystemConditionals do
   subject(:cop) { described_class.new }
 
   context "when auditing OS conditionals" do
@@ -12,7 +11,7 @@
         class Foo < Formula
           desc "foo"
           if OS.linux?
-          ^^^^^^^^^^^^ Don't use `if OS.linux?`, use `on_linux do` instead.
+          ^^^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `if OS.linux?`, use `on_linux do` instead.
             url 'https://brew.sh/linux-1.0.tgz'
           else
             url 'https://brew.sh/linux-1.0.tgz'
@@ -38,7 +37,7 @@ class Foo < Formula
         class Foo < Formula
           desc "foo"
           if OS.mac?
-          ^^^^^^^^^^ Don't use `if OS.mac?`, use `on_macos do` instead.
+          ^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `if OS.mac?`, use `on_macos do` instead.
             url 'https://brew.sh/mac-1.0.tgz'
           else
             url 'https://brew.sh/linux-1.0.tgz'
@@ -67,7 +66,7 @@ class Foo < Formula
 
           def install
             on_macos do
-            ^^^^^^^^ Don't use `on_macos` in `def install`, use `if OS.mac?` instead.
+            ^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `on_macos` in `def install`, use `if OS.mac?` instead.
               true
             end
           end
@@ -96,7 +95,7 @@ class Foo < Formula
 
           def install
             on_linux do
-            ^^^^^^^^ Don't use `on_linux` in `def install`, use `if OS.linux?` instead.
+            ^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `on_linux` in `def install`, use `if OS.linux?` instead.
               true
             end
           end
@@ -125,7 +124,7 @@ class Foo < Formula
 
           test do
             on_macos do
-            ^^^^^^^^ Don't use `on_macos` in `test do`, use `if OS.mac?` instead.
+            ^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `on_macos` in `test do`, use `if OS.mac?` instead.
               true
             end
           end
@@ -153,7 +152,7 @@ class Foo < Formula
         class Foo < Formula
           desc "foo"
           if Hardware::CPU.arm?
-          ^^^^^^^^^^^^^^^^^^^^^ Don't use `if Hardware::CPU.arm?`, use `on_arm do` instead.
+          ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `if Hardware::CPU.arm?`, use `on_arm do` instead.
             url 'https://brew.sh/linux-1.0.tgz'
           else
             url 'https://brew.sh/linux-1.0.tgz'
@@ -179,7 +178,7 @@ class Foo < Formula
         class Foo < Formula
           desc "foo"
           if Hardware::CPU.intel?
-          ^^^^^^^^^^^^^^^^^^^^^^^ Don't use `if Hardware::CPU.intel?`, use `on_intel do` instead.
+          ^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `if Hardware::CPU.intel?`, use `on_intel do` instead.
             url 'https://brew.sh/mac-1.0.tgz'
           else
             url 'https://brew.sh/linux-1.0.tgz'
@@ -208,7 +207,7 @@ class Foo < Formula
 
           def install
             on_intel do
-            ^^^^^^^^ Don't use `on_intel` in `def install`, use `if Hardware::CPU.intel?` instead.
+            ^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `on_intel` in `def install`, use `if Hardware::CPU.intel?` instead.
               true
             end
           end
@@ -237,7 +236,7 @@ class Foo < Formula
 
           def install
             on_arm do
-            ^^^^^^ Don't use `on_arm` in `def install`, use `if Hardware::CPU.arm?` instead.
+            ^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `on_arm` in `def install`, use `if Hardware::CPU.arm?` instead.
               true
             end
           end
@@ -266,7 +265,7 @@ class Foo < Formula
 
           test do
             on_intel do
-            ^^^^^^^^ Don't use `on_intel` in `test do`, use `if Hardware::CPU.intel?` instead.
+            ^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `on_intel` in `test do`, use `if Hardware::CPU.intel?` instead.
               true
             end
           end
@@ -294,7 +293,7 @@ class Foo < Formula
         class Foo < Formula
           desc "foo"
           if MacOS.version == :monterey
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't use `if MacOS.version == :monterey`, use `on_monterey do` instead.
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `if MacOS.version == :monterey`, use `on_monterey do` instead.
             url 'https://brew.sh/linux-1.0.tgz'
           end
         end
@@ -315,7 +314,7 @@ class Foo < Formula
         class Foo < Formula
           desc "foo"
           if MacOS.version <= :monterey
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't use `if MacOS.version <= :monterey`, use `on_system :linux, macos: :monterey_or_older do` instead.
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `if MacOS.version <= :monterey`, use `on_system :linux, macos: :monterey_or_older do` instead.
             url 'https://brew.sh/mac-1.0.tgz'
           end
         end
@@ -336,7 +335,7 @@ class Foo < Formula
         class Foo < Formula
           desc "foo"
           if MacOS.version < :monterey
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't use `if MacOS.version < :monterey`, use `on_system do` instead.
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `if MacOS.version < :monterey`, use `on_system do` instead.
             url 'https://brew.sh/mac-1.0.tgz'
           end
         end
@@ -348,7 +347,7 @@ class Foo < Formula
         class Foo < Formula
           desc "foo"
           if MacOS.version >= :monterey
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't use `if MacOS.version >= :monterey`, use `on_monterey :or_newer do` instead.
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `if MacOS.version >= :monterey`, use `on_monterey :or_newer do` instead.
             url 'https://brew.sh/mac-1.0.tgz'
           else
             url 'https://brew.sh/linux-1.0.tgz'
@@ -362,7 +361,7 @@ class Foo < Formula
         class Foo < Formula
           desc "foo"
           if MacOS.version > :monterey
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't use `if MacOS.version > :monterey`, use `on_monterey do` instead.
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `if MacOS.version > :monterey`, use `on_monterey do` instead.
             url 'https://brew.sh/mac-1.0.tgz'
           end
         end
@@ -377,7 +376,7 @@ class Foo < Formula
 
           def install
             on_monterey do
-            ^^^^^^^^^^^ Don't use `on_monterey` in `def install`, use `if MacOS.version == :monterey` instead.
+            ^^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `on_monterey` in `def install`, use `if MacOS.version == :monterey` instead.
               true
             end
           end
@@ -406,7 +405,7 @@ class Foo < Formula
 
           def install
             on_monterey :or_older do
-            ^^^^^^^^^^^^^^^^^^^^^ Don't use `on_monterey :or_older` in `def install`, use `if MacOS.version <= :monterey` instead.
+            ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `on_monterey :or_older` in `def install`, use `if MacOS.version <= :monterey` instead.
               true
             end
           end
@@ -435,7 +434,7 @@ class Foo < Formula
 
           def install
             on_monterey :or_newer do
-            ^^^^^^^^^^^^^^^^^^^^^ Don't use `on_monterey :or_newer` in `def install`, use `if MacOS.version >= :monterey` instead.
+            ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `on_monterey :or_newer` in `def install`, use `if MacOS.version >= :monterey` instead.
               true
             end
           end
@@ -464,7 +463,7 @@ class Foo < Formula
 
           def install
             on_system :linux, macos: :monterey_or_newer do
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't use `on_system :linux, macos: :monterey_or_newer` in `def install`, use `if OS.linux? || MacOS.version >= :monterey` instead.
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `on_system :linux, macos: :monterey_or_newer` in `def install`, use `if OS.linux? || MacOS.version >= :monterey` instead.
               true
             end
           end
@@ -493,7 +492,7 @@ class Foo < Formula
 
           test do
             on_monterey do
-            ^^^^^^^^^^^ Don't use `on_monterey` in `test do`, use `if MacOS.version == :monterey` instead.
+            ^^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `on_monterey` in `test do`, use `if MacOS.version == :monterey` instead.
               true
             end
           end
@@ -522,7 +521,7 @@ class Foo < Formula
 
           test do
             on_system :linux, macos: :monterey do
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't use `on_system :linux, macos: :monterey` in `test do`, use `if OS.linux? || MacOS.version == :monterey` instead.
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OnSystemConditionals: Don't use `on_system :linux, macos: :monterey` in `test do`, use `if OS.linux? || MacOS.version == :monterey` instead.
               true
             end
           end
diff --git a/Library/Homebrew/test/rubocops/text/option_declarations_spec.rb b/Library/Homebrew/test/rubocops/text/option_declarations_spec.rb
index 818c894e3c196..b14e6daafdc8f 100644
--- a/Library/Homebrew/test/rubocops/text/option_declarations_spec.rb
+++ b/Library/Homebrew/test/rubocops/text/option_declarations_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/lines"
 
-describe RuboCop::Cop::FormulaAudit::OptionDeclarations do
+RSpec.describe RuboCop::Cop::FormulaAudit::OptionDeclarations do
   subject(:cop) { described_class.new }
 
   context "when auditing options" do
@@ -14,7 +13,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def install
             build.without? "bar"
-            ^^^^^^^^^^^^^^^^^^^^ Formulae in homebrew/core should not use `build.without?`.
+            ^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OptionDeclarations: Formulae in homebrew/core should not use `build.without?`.
           end
         end
       RUBY
@@ -27,7 +26,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def install
             build.with? "bar"
-            ^^^^^^^^^^^^^^^^^ Formulae in homebrew/core should not use `build.with?`.
+            ^^^^^^^^^^^^^^^^^ FormulaAudit/OptionDeclarations: Formulae in homebrew/core should not use `build.with?`.
           end
         end
       RUBY
@@ -37,7 +36,7 @@ def install
       expect_offense(<<~RUBY)
         class Foo < Formula
           depends_on "bar" if build.without?("baz")
-                              ^^^^^^^^^^^^^^^^^^^^^ Use `:optional` or `:recommended` instead of `if build.without?("baz")`
+                              ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OptionDeclarations: Use `:optional` or `:recommended` instead of `if build.without?("baz")`
         end
       RUBY
     end
@@ -46,7 +45,7 @@ class Foo < Formula
       expect_offense(<<~RUBY)
         class Foo < Formula
           depends_on "bar" if build.with?("baz")
-                              ^^^^^^^^^^^^^^^^^^ Use `:optional` or `:recommended` instead of `if build.with?("baz")`
+                              ^^^^^^^^^^^^^^^^^^ FormulaAudit/OptionDeclarations: Use `:optional` or `:recommended` instead of `if build.with?("baz")`
         end
       RUBY
     end
@@ -58,7 +57,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def post_install
             return unless build.without? "bar"
-                          ^^^^^^^^^^^^^^^^^^^^ Use if build.with? "bar" instead of unless build.without? "bar"
+                          ^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OptionDeclarations: Use if build.with? "bar" instead of unless build.without? "bar"
           end
         end
       RUBY
@@ -71,7 +70,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def post_install
             return unless build.with? "bar"
-                          ^^^^^^^^^^^^^^^^^ Use if build.without? "bar" instead of unless build.with? "bar"
+                          ^^^^^^^^^^^^^^^^^ FormulaAudit/OptionDeclarations: Use if build.without? "bar" instead of unless build.with? "bar"
           end
         end
       RUBY
@@ -84,7 +83,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def post_install
             return if !build.with? "bar"
-                      ^^^^^^^^^^^^^^^^^^ Don't negate 'build.with?': use 'build.without?'
+                      ^^^^^^^^^^^^^^^^^^ FormulaAudit/OptionDeclarations: Don't negate 'build.with?': use 'build.without?'
           end
         end
       RUBY
@@ -97,7 +96,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def post_install
             return if !build.without? "bar"
-                      ^^^^^^^^^^^^^^^^^^^^^ Don't negate 'build.without?': use 'build.with?'
+                      ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OptionDeclarations: Don't negate 'build.without?': use 'build.with?'
           end
         end
       RUBY
@@ -110,7 +109,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def post_install
             return if build.without? "--without-bar"
-                                     ^^^^^^^^^^^^^^^ Don't duplicate 'without': Use `build.without? \"bar\"` to check for \"--without-bar\"
+                                     ^^^^^^^^^^^^^^^ FormulaAudit/OptionDeclarations: Don't duplicate 'without': Use `build.without? "bar"` to check for "--without-bar"
           end
         end
       RUBY
@@ -123,7 +122,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def post_install
             return if build.with? "--with-bar"
-                                  ^^^^^^^^^^^^ Don't duplicate 'with': Use `build.with? \"bar\"` to check for \"--with-bar\"
+                                  ^^^^^^^^^^^^ FormulaAudit/OptionDeclarations: Don't duplicate 'with': Use `build.with? "bar"` to check for "--with-bar"
           end
         end
       RUBY
@@ -136,7 +135,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           def post_install
             return if build.include? "foo"
-                      ^^^^^^^^^^^^^^^^^^^^ `build.include?` is deprecated
+                      ^^^^^^^^^^^^^^^^^^^^ FormulaAudit/OptionDeclarations: `build.include?` is deprecated
           end
         end
       RUBY
@@ -149,7 +148,7 @@ class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
 
           def options
-          ^^^^^^^^^^^ Use new-style option definitions
+          ^^^^^^^^^^^ FormulaAudit/OptionDeclarations: Use new-style option definitions
             [["--bar", "desc"]]
           end
         end
diff --git a/Library/Homebrew/test/rubocops/text/python_versions_spec.rb b/Library/Homebrew/test/rubocops/text/python_versions_spec.rb
index 372e4d9598120..0a6fcbe96038b 100644
--- a/Library/Homebrew/test/rubocops/text/python_versions_spec.rb
+++ b/Library/Homebrew/test/rubocops/text/python_versions_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/lines"
 
-describe RuboCop::Cop::FormulaAudit::PythonVersions do
+RSpec.describe RuboCop::Cop::FormulaAudit::PythonVersions do
   subject(:cop) { described_class.new }
 
   context "when auditing Python versions" do
@@ -96,7 +95,7 @@ class Foo < Formula
 
           def install
             puts "python@3.8"
-                 ^^^^^^^^^^^^ References to `python@3.8` should match the specified python dependency (`python@3.9`)
+                 ^^^^^^^^^^^^ FormulaAudit/PythonVersions: References to `python@3.8` should match the specified python dependency (`python@3.9`)
           end
         end
       RUBY
@@ -119,7 +118,7 @@ class Foo < Formula
 
           def install
             puts "python3.8"
-                 ^^^^^^^^^^^ References to `python3.8` should match the specified python dependency (`python3.9`)
+                 ^^^^^^^^^^^ FormulaAudit/PythonVersions: References to `python3.8` should match the specified python dependency (`python3.9`)
           end
         end
       RUBY
@@ -142,7 +141,7 @@ class Foo < Formula
 
           def install
             puts "python@3.10"
-                 ^^^^^^^^^^^^^ References to `python@3.10` should match the specified python dependency (`python@3.11`)
+                 ^^^^^^^^^^^^^ FormulaAudit/PythonVersions: References to `python@3.10` should match the specified python dependency (`python@3.11`)
           end
         end
       RUBY
@@ -165,7 +164,7 @@ class Foo < Formula
 
           def install
             puts "python3.10"
-                 ^^^^^^^^^^^^ References to `python3.10` should match the specified python dependency (`python3.11`)
+                 ^^^^^^^^^^^^ FormulaAudit/PythonVersions: References to `python3.10` should match the specified python dependency (`python3.11`)
           end
         end
       RUBY
@@ -180,5 +179,45 @@ def install
         end
       RUBY
     end
+
+    it "reports no offenses for multiple non-runtime Python dependencies" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          depends_on "python@3.9" => :build
+          depends_on "python@3.10" => :test
+
+          def install
+            puts "python3.9"
+          end
+
+          test do
+            puts "python3.10"
+          end
+        end
+      RUBY
+    end
+
+    it "reports and corrects Python references that mismatch single non-runtime Python dependency" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          depends_on "python@3.9" => :build
+
+          def install
+            puts "python@3.8"
+                 ^^^^^^^^^^^^ FormulaAudit/PythonVersions: References to `python@3.8` should match the specified python dependency (`python@3.9`)
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          depends_on "python@3.9" => :build
+
+          def install
+            puts "python@3.9"
+          end
+        end
+      RUBY
+    end
   end
 end
diff --git a/Library/Homebrew/test/rubocops/text/safe_popen_commands_spec.rb b/Library/Homebrew/test/rubocops/text/safe_popen_commands_spec.rb
index 156c186a06932..f8d8d7b13ac2e 100644
--- a/Library/Homebrew/test/rubocops/text/safe_popen_commands_spec.rb
+++ b/Library/Homebrew/test/rubocops/text/safe_popen_commands_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/lines"
 
-describe RuboCop::Cop::FormulaAudit::SafePopenCommands do
+RSpec.describe RuboCop::Cop::FormulaAudit::SafePopenCommands do
   subject(:cop) { described_class.new }
 
   context "when auditing popen commands" do
@@ -12,7 +11,7 @@
         class Foo < Formula
           def install
             Utils.popen_read "foo"
-            ^^^^^^^^^^^^^^^^^^^^^^ Use `Utils.safe_popen_read` instead of `Utils.popen_read`
+            ^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/SafePopenCommands: Use `Utils.safe_popen_read` instead of `Utils.popen_read`
           end
         end
       RUBY
@@ -31,7 +30,7 @@ def install
         class Foo < Formula
           def install
             Utils.popen_write "foo"
-            ^^^^^^^^^^^^^^^^^^^^^^^ Use `Utils.safe_popen_write` instead of `Utils.popen_write`
+            ^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/SafePopenCommands: Use `Utils.safe_popen_write` instead of `Utils.popen_write`
           end
         end
       RUBY
diff --git a/Library/Homebrew/test/rubocops/text/shell_variables_spec.rb b/Library/Homebrew/test/rubocops/text/shell_variables_spec.rb
index c10bcb26f4754..ddf39dc3cc6b7 100644
--- a/Library/Homebrew/test/rubocops/text/shell_variables_spec.rb
+++ b/Library/Homebrew/test/rubocops/text/shell_variables_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/lines"
 
-describe RuboCop::Cop::FormulaAudit::ShellVariables do
+RSpec.describe RuboCop::Cop::FormulaAudit::ShellVariables do
   subject(:cop) { described_class.new }
 
   context "when auditing shell variables" do
@@ -12,7 +11,7 @@
         class Foo < Formula
           def install
             Utils.popen "SHELL=bash foo"
-                        ^^^^^^^^^^^^^^^^ Use `Utils.popen({ "SHELL" => "bash" }, "foo")` instead of `Utils.popen "SHELL=bash foo"`
+                        ^^^^^^^^^^^^^^^^ FormulaAudit/ShellVariables: Use `Utils.popen({ "SHELL" => "bash" }, "foo")` instead of `Utils.popen "SHELL=bash foo"`
           end
         end
       RUBY
@@ -20,7 +19,7 @@ def install
       expect_correction(<<~RUBY)
         class Foo < Formula
           def install
-            Utils.popen { "SHELL" => "bash" }, "foo"
+            Utils.popen({ "SHELL" => "bash" }, "foo")
           end
         end
       RUBY
@@ -31,7 +30,7 @@ def install
         class Foo < Formula
           def install
             Utils.safe_popen_read "SHELL=bash foo"
-                                  ^^^^^^^^^^^^^^^^ Use `Utils.safe_popen_read({ "SHELL" => "bash" }, "foo")` instead of `Utils.safe_popen_read "SHELL=bash foo"`
+                                  ^^^^^^^^^^^^^^^^ FormulaAudit/ShellVariables: Use `Utils.safe_popen_read({ "SHELL" => "bash" }, "foo")` instead of `Utils.safe_popen_read "SHELL=bash foo"`
           end
         end
       RUBY
@@ -39,7 +38,7 @@ def install
       expect_correction(<<~RUBY)
         class Foo < Formula
           def install
-            Utils.safe_popen_read { "SHELL" => "bash" }, "foo"
+            Utils.safe_popen_read({ "SHELL" => "bash" }, "foo")
           end
         end
       RUBY
@@ -50,7 +49,7 @@ def install
         class Foo < Formula
           def install
             Utils.safe_popen_write "SHELL=bash foo"
-                                   ^^^^^^^^^^^^^^^^ Use `Utils.safe_popen_write({ "SHELL" => "bash" }, "foo")` instead of `Utils.safe_popen_write "SHELL=bash foo"`
+                                   ^^^^^^^^^^^^^^^^ FormulaAudit/ShellVariables: Use `Utils.safe_popen_write({ "SHELL" => "bash" }, "foo")` instead of `Utils.safe_popen_write "SHELL=bash foo"`
           end
         end
       RUBY
@@ -58,7 +57,7 @@ def install
       expect_correction(<<~RUBY)
         class Foo < Formula
           def install
-            Utils.safe_popen_write { "SHELL" => "bash" }, "foo"
+            Utils.safe_popen_write({ "SHELL" => "bash" }, "foo")
           end
         end
       RUBY
@@ -69,7 +68,7 @@ def install
         class Foo < Formula
           def install
             Utils.popen "SHELL=bash \#{bin}/foo"
-                        ^^^^^^^^^^^^^^^^^^^^^^^ Use `Utils.popen({ "SHELL" => "bash" }, "\#{bin}/foo")` instead of `Utils.popen "SHELL=bash \#{bin}/foo"`
+                        ^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/ShellVariables: Use `Utils.popen({ "SHELL" => "bash" }, "\#{bin}/foo")` instead of `Utils.popen "SHELL=bash \#{bin}/foo"`
           end
         end
       RUBY
@@ -77,7 +76,7 @@ def install
       expect_correction(<<~RUBY)
         class Foo < Formula
           def install
-            Utils.popen { "SHELL" => "bash" }, "\#{bin}/foo"
+            Utils.popen({ "SHELL" => "bash" }, "\#{bin}/foo")
           end
         end
       RUBY
diff --git a/Library/Homebrew/test/rubocops/text/std_npm_args_spec.rb b/Library/Homebrew/test/rubocops/text/std_npm_args_spec.rb
new file mode 100644
index 0000000000000..c0bb9e97edaf5
--- /dev/null
+++ b/Library/Homebrew/test/rubocops/text/std_npm_args_spec.rb
@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "rubocops/lines"
+
+RSpec.describe RuboCop::Cop::FormulaAudit::StdNpmArgs do
+  subject(:cop) { described_class.new }
+
+  context "when auditing node formulae" do
+    it "reports an offense when `npm install` is called without std_npm_args arguments" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          def install
+            system "npm", "install"
+            ^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/StdNpmArgs: Use `std_npm_args` for npm install
+          end
+        end
+      RUBY
+    end
+
+    it "reports and corrects an offense when using local_npm_install_args" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          def install
+            system "npm", "install", *Language::Node.local_npm_install_args, "--production"
+                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/StdNpmArgs: Use 'std_npm_args' instead of 'local_npm_install_args'.
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          def install
+            system "npm", "install", *std_npm_args(prefix: false), "--production"
+          end
+        end
+      RUBY
+    end
+
+    it "reports and corrects an offense when using std_npm_install_args with libexec" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          def install
+            system "npm", "install", *Language::Node.std_npm_install_args(libexec), "--production"
+                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/StdNpmArgs: Use 'std_npm_args' instead of 'std_npm_install_args'.
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          def install
+            system "npm", "install", *std_npm_args, "--production"
+          end
+        end
+      RUBY
+    end
+
+    it "reports and corrects an offense when using std_npm_install_args without libexec" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          def install
+            system "npm", "install", *Language::Node.std_npm_install_args(buildpath), "--production"
+                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/StdNpmArgs: Use 'std_npm_args' instead of 'std_npm_install_args'.
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo < Formula
+          def install
+            system "npm", "install", *std_npm_args(prefix: buildpath), "--production"
+          end
+        end
+      RUBY
+    end
+
+    it "does not report an offense when using std_npm_args" do
+      expect_no_offenses(<<~RUBY)
+        class Foo < Formula
+          def install
+            system "npm", "install", *std_npm_args
+          end
+        end
+      RUBY
+    end
+  end
+end
diff --git a/Library/Homebrew/test/rubocops/text/strict_spec.rb b/Library/Homebrew/test/rubocops/text/strict_spec.rb
index f2ebfaedb791c..dde82719670ce 100644
--- a/Library/Homebrew/test/rubocops/text/strict_spec.rb
+++ b/Library/Homebrew/test/rubocops/text/strict_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/text"
 
-describe RuboCop::Cop::FormulaAuditStrict::Text do
+RSpec.describe RuboCop::Cop::FormulaAuditStrict::Text do
   subject(:cop) { described_class.new }
 
   context "when auditing formula text in homebrew/core" do
@@ -13,7 +12,7 @@ class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
 
           env :userpaths
-          ^^^^^^^^^^^^^^ `env :userpaths` in homebrew/core formulae is deprecated
+          ^^^^^^^^^^^^^^ FormulaAuditStrict/Text: `env :userpaths` in homebrew/core formulae is deprecated
         end
       RUBY
     end
@@ -24,7 +23,7 @@ class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
 
           env :std
-          ^^^^^^^^ `env :std` in homebrew/core formulae is deprecated
+          ^^^^^^^^ FormulaAuditStrict/Text: `env :std` in homebrew/core formulae is deprecated
         end
       RUBY
     end
@@ -34,7 +33,7 @@ class Foo < Formula
         class Foo < Formula
           def install
             ohai "\#{share}/foo"
-                 ^^^^^^^^^^^^^^ Use `\#{pkgshare}` instead of `\#{share}/foo`
+                 ^^^^^^^^^^^^^^ FormulaAuditStrict/Text: Use `\#{pkgshare}` instead of `\#{share}/foo`
           end
         end
       RUBY
@@ -43,7 +42,7 @@ def install
         class Foo < Formula
           def install
             ohai "\#{share}/foo/bar"
-                 ^^^^^^^^^^^^^^^^^^ Use `\#{pkgshare}` instead of `\#{share}/foo`
+                 ^^^^^^^^^^^^^^^^^^ FormulaAuditStrict/Text: Use `\#{pkgshare}` instead of `\#{share}/foo`
           end
         end
       RUBY
@@ -52,7 +51,7 @@ def install
         class Foolibcxx < Formula
           def install
             ohai "\#{share}/foolibc++"
-                 ^^^^^^^^^^^^^^^^^^^^ Use `\#{pkgshare}` instead of `\#{share}/foolibc++`
+                 ^^^^^^^^^^^^^^^^^^^^ FormulaAuditStrict/Text: Use `\#{pkgshare}` instead of `\#{share}/foolibc++`
           end
         end
       RUBY
@@ -63,7 +62,7 @@ def install
         class Foo < Formula
           def install
             ohai share/"foo"
-                 ^^^^^^^^^^^ Use `pkgshare` instead of `share/"foo"`
+                 ^^^^^^^^^^^ FormulaAuditStrict/Text: Use `pkgshare` instead of `share/"foo"`
           end
         end
       RUBY
@@ -72,7 +71,7 @@ def install
         class Foo < Formula
           def install
             ohai share/"foo/bar"
-                 ^^^^^^^^^^^^^^^ Use `pkgshare` instead of `share/"foo"`
+                 ^^^^^^^^^^^^^^^ FormulaAuditStrict/Text: Use `pkgshare` instead of `share/"foo"`
           end
         end
       RUBY
@@ -81,7 +80,7 @@ def install
         class Foolibcxx < Formula
           def install
             ohai share/"foolibc++"
-                 ^^^^^^^^^^^^^^^^^ Use `pkgshare` instead of `share/"foolibc++"`
+                 ^^^^^^^^^^^^^^^^^ FormulaAuditStrict/Text: Use `pkgshare` instead of `share/"foolibc++"`
           end
         end
       RUBY
@@ -123,7 +122,7 @@ def install
       RUBY
     end
 
-    it %Q(reports no offenses if formula name appears afer "\#{share}/<directory name>") do
+    it %Q(reports no offenses if formula name appears after "\#{share}/<directory name>") do
       expect_no_offenses(<<~RUBY, "/homebrew-core/Formula/foo.rb")
         class Foo < Formula
           def install
@@ -132,5 +131,55 @@ def install
         end
       RUBY
     end
+
+    context "for interpolated bin paths" do
+      it 'reports an offense & autocorrects if "\#{bin}/<formula_name>" or other dashed binaries too are present' do
+        expect_offense(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+          class Foo < Formula
+            test do
+              system "\#{bin}/foo", "-v"
+                     ^^^^^^^^^^^^ FormulaAuditStrict/Text: Use `bin/"foo"` instead of `"\#{bin}/foo"`
+              system "\#{bin}/foo-bar", "-v"
+                     ^^^^^^^^^^^^^^^^ FormulaAuditStrict/Text: Use `bin/"foo-bar"` instead of `"\#{bin}/foo-bar"`
+            end
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          class Foo < Formula
+            test do
+              system bin/"foo", "-v"
+              system bin/"foo-bar", "-v"
+            end
+          end
+        RUBY
+      end
+
+      it 'does not report an offense if \#{bin}/foo and then a space and more text' do
+        expect_no_offenses(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+          class Foo < Formula
+            test do
+              shell_output("\#{bin}/foo --version")
+              assert_match "help", shell_output("\#{bin}/foo-something --help 2>&1")
+              assert_match "OK", shell_output("\#{bin}/foo-something_else --check 2>&1")
+            end
+          end
+        RUBY
+      end
+    end
+
+    it 'does not report an offense if "\#{bin}/foo" is in a word array' do
+      expect_no_offenses(<<~RUBY, "/homebrew-core/Formula/foo.rb")
+        class Foo < Formula
+          test do
+            cmd = %W[
+              \#{bin}/foo
+              version
+            ]
+            assert_match version.to_s, shell_output(cmd)
+          end
+        end
+      RUBY
+    end
   end
 end
diff --git a/Library/Homebrew/test/rubocops/text_spec.rb b/Library/Homebrew/test/rubocops/text_spec.rb
index 883aadac8832a..c37f49e1e6d1c 100644
--- a/Library/Homebrew/test/rubocops/text_spec.rb
+++ b/Library/Homebrew/test/rubocops/text_spec.rb
@@ -1,16 +1,15 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/text"
 
-describe RuboCop::Cop::FormulaAudit::Text do
+RSpec.describe RuboCop::Cop::FormulaAudit::Text do
   subject(:cop) { described_class.new }
 
   context "when auditing formula text" do
     it 'reports an offense if `require "formula"` is present' do
       expect_offense(<<~RUBY)
         require "formula"
-        ^^^^^^^^^^^^^^^^^ `require "formula"` is now unnecessary
+        ^^^^^^^^^^^^^^^^^ FormulaAudit/Text: `require "formula"` is now unnecessary
         class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
           homepage "https://brew.sh"
@@ -25,6 +24,17 @@ class Foo < Formula
       RUBY
     end
 
+    it "reports an offense if 'revision 0' is present" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+          revision 0
+          ^^^^^^^^^^ FormulaAudit/Text: "revision 0" is unnecessary
+        end
+      RUBY
+    end
+
     it "reports an offense if both openssl and libressl are dependencies" do
       expect_offense(<<~RUBY)
         class Foo < Formula
@@ -33,7 +43,7 @@ class Foo < Formula
 
           depends_on "openssl"
           depends_on "libressl" => :optional
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Formulae should not depend on both OpenSSL and LibreSSL (even optionally).
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Text: Formulae should not depend on both OpenSSL and LibreSSL (even optionally).
         end
       RUBY
 
@@ -44,7 +54,7 @@ class Foo < Formula
 
           depends_on "openssl"
           depends_on "libressl"
-          ^^^^^^^^^^^^^^^^^^^^^ Formulae should not depend on both OpenSSL and LibreSSL (even optionally).
+          ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Text: Formulae should not depend on both OpenSSL and LibreSSL (even optionally).
         end
       RUBY
     end
@@ -55,7 +65,7 @@ class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
           homepage "https://brew.sh"
           depends_on "veclibfort"
-          ^^^^^^^^^^^^^^^^^^^^^^^ Formulae in homebrew/core should use OpenBLAS as the default serial linear algebra library.
+          ^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Text: Formulae in homebrew/core should use OpenBLAS as the default serial linear algebra library.
         end
       RUBY
     end
@@ -66,7 +76,7 @@ class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
           homepage "https://brew.sh"
           depends_on "lapack"
-          ^^^^^^^^^^^^^^^^^^^ Formulae in homebrew/core should use OpenBLAS as the default serial linear algebra library.
+          ^^^^^^^^^^^^^^^^^^^ FormulaAudit/Text: Formulae in homebrew/core should use OpenBLAS as the default serial linear algebra library.
         end
       RUBY
     end
@@ -79,7 +89,7 @@ class Foo < Formula
 
           def install
             system "go", "get", "bar"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^ Do not use `go get`. Please ask upstream to implement Go vendoring
+            ^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Text: Do not use `go get`. Please ask upstream to implement Go vendoring
           end
         end
       RUBY
@@ -93,13 +103,13 @@ class Foo < Formula
 
           def install
             system "xcodebuild", "foo", "bar"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ use \"xcodebuild *args\" instead of \"system 'xcodebuild', *args\"
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Text: use "xcodebuild *args" instead of "system 'xcodebuild', *args"
           end
         end
       RUBY
     end
 
-    it "reports an offense if `plist_options` are not defined when using a formula-defined `plist`", :ruby23 do
+    it "reports an offense if `def plist` is used" do
       expect_offense(<<~RUBY)
         class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
@@ -107,11 +117,11 @@ class Foo < Formula
 
           def install
             system "xcodebuild", "foo", "bar"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ use \"xcodebuild *args\" instead of \"system 'xcodebuild', *args\"
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Text: use "xcodebuild *args" instead of "system 'xcodebuild', *args"
           end
 
           def plist
-          ^^^^^^^^^ Please set plist_options when using a formula-defined plist.
+          ^^^^^^^^^ FormulaAudit/Text: `def plist` is deprecated. Please use services instead: https://docs.brew.sh/Formula-Cookbook#service-files
             <<~XML
               <?xml version="1.0" encoding="UTF-8"?>
               <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -130,7 +140,7 @@ def plist
     it 'reports an offense if `require "language/go"` is present' do
       expect_offense(<<~RUBY)
         require "language/go"
-        ^^^^^^^^^^^^^^^^^^^^^ require "language/go" is unnecessary unless using `go_resource`s
+        ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Text: require "language/go" is unnecessary unless using `go_resource`s
 
         class Foo < Formula
           url "https://brew.sh/foo-1.0.tgz"
@@ -138,7 +148,7 @@ class Foo < Formula
 
           def install
             system "go", "get", "bar"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^ Do not use `go get`. Please ask upstream to implement Go vendoring
+            ^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Text: Do not use `go get`. Please ask upstream to implement Go vendoring
           end
         end
       RUBY
@@ -152,7 +162,7 @@ class Foo < Formula
 
           def install
             Formula.factory(name)
-            ^^^^^^^^^^^^^^^^^^^^^ \"Formula.factory(name)\" is deprecated in favor of \"Formula[name]\"
+            ^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Text: "Formula.factory(name)" is deprecated in favor of "Formula[name]"
           end
         end
       RUBY
@@ -166,7 +176,7 @@ class Foo < Formula
 
           def install
             system "dep", "ensure"
-            ^^^^^^^^^^^^^^^^^^^^^^ use \"dep\", \"ensure\", \"-vendor-only\"
+            ^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Text: use "dep", "ensure", "-vendor-only"
           end
         end
       RUBY
@@ -180,7 +190,7 @@ class Foo < Formula
 
           def install
             system "cargo", "build"
-            ^^^^^^^^^^^^^^^^^^^^^^^ use \"cargo\", \"install\", *std_cargo_args
+            ^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Text: use "cargo", "install", *std_cargo_args
           end
         end
       RUBY
@@ -204,7 +214,7 @@ def install
         class Foo < Formula
           def install
             system "make && make install"
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use separate `make` calls
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Text: Use separate `make` calls
           end
         end
       RUBY
@@ -215,7 +225,7 @@ def install
         class Foo < Formula
           def install
             ohai "foo \#{bar + "baz"}"
-                      ^^^^^^^^^^^^^^ Do not concatenate paths in string interpolation
+                      ^^^^^^^^^^^^^^ FormulaAudit/Text: Do not concatenate paths in string interpolation
           end
         end
       RUBY
@@ -226,7 +236,7 @@ def install
         class Foo < Formula
           def install
             ohai prefix + "bin"
-                 ^^^^^^^^^^^^^^ Use `bin` instead of `prefix + "bin"`
+                 ^^^^^^^^^^^^^^ FormulaAudit/Text: Use `bin` instead of `prefix + "bin"`
           end
         end
       RUBY
@@ -235,7 +245,7 @@ def install
         class Foo < Formula
           def install
             ohai prefix + "bin/foo"
-                 ^^^^^^^^^^^^^^^^^^ Use `bin` instead of `prefix + "bin"`
+                 ^^^^^^^^^^^^^^^^^^ FormulaAudit/Text: Use `bin` instead of `prefix + "bin"`
           end
         end
       RUBY
diff --git a/Library/Homebrew/test/rubocops/urls/git_spec.rb b/Library/Homebrew/test/rubocops/urls/git_spec.rb
index a4f77f45db271..c95deae3e2bbb 100644
--- a/Library/Homebrew/test/rubocops/urls/git_spec.rb
+++ b/Library/Homebrew/test/rubocops/urls/git_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/urls"
 
-describe RuboCop::Cop::FormulaAudit::GitUrls do
+RSpec.describe RuboCop::Cop::FormulaAudit::GitUrls do
   subject(:cop) { described_class.new }
 
   context "when a git URL is used" do
@@ -56,7 +55,7 @@ class Foo < Formula
         class Foo < Formula
           desc "foo"
           url "https://github.com/foo/bar.git",
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Formulae in homebrew/core should specify a revision for git URLs
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/GitUrls: Formulae in homebrew/core should specify a revision for git URLs
               tag: "v1.0.0"
         end
       RUBY
@@ -67,7 +66,7 @@ class Foo < Formula
         class Foo < Formula
           desc "foo"
           url "https://github.com/foo/bar.git",
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Formulae in homebrew/core should specify a revision for git URLs
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/GitUrls: Formulae in homebrew/core should specify a revision for git URLs
               shallow: false,
               tag:     "v1.0.0"
         end
diff --git a/Library/Homebrew/test/rubocops/urls/git_strict_spec.rb b/Library/Homebrew/test/rubocops/urls/git_strict_spec.rb
index d5fc0cc2518f0..1e511173d16ff 100644
--- a/Library/Homebrew/test/rubocops/urls/git_strict_spec.rb
+++ b/Library/Homebrew/test/rubocops/urls/git_strict_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/urls"
 
-describe RuboCop::Cop::FormulaAuditStrict::GitUrls do
+RSpec.describe RuboCop::Cop::FormulaAuditStrict::GitUrls do
   subject(:cop) { described_class.new }
 
   context "when a git URL is used" do
@@ -47,7 +46,7 @@ class Foo < Formula
         class Foo < Formula
           desc "foo"
           url "https://github.com/foo/bar.git",
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Formulae in homebrew/core should specify a tag for git URLs
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAuditStrict/GitUrls: Formulae in homebrew/core should specify a tag for git URLs
               revision: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         end
       RUBY
@@ -58,7 +57,7 @@ class Foo < Formula
         class Foo < Formula
           desc "foo"
           url "https://github.com/foo/bar.git",
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Formulae in homebrew/core should specify a tag for git URLs
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAuditStrict/GitUrls: Formulae in homebrew/core should specify a tag for git URLs
               revision: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
               shallow:  false
         end
diff --git a/Library/Homebrew/test/rubocops/urls/pypi_spec.rb b/Library/Homebrew/test/rubocops/urls/pypi_spec.rb
index 516a616d01d57..f4d1186eadf17 100644
--- a/Library/Homebrew/test/rubocops/urls/pypi_spec.rb
+++ b/Library/Homebrew/test/rubocops/urls/pypi_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/urls"
 
-describe RuboCop::Cop::FormulaAudit::PyPiUrls do
+RSpec.describe RuboCop::Cop::FormulaAudit::PyPiUrls do
   subject(:cop) { described_class.new }
 
   context "when a pypi URL is used" do
@@ -12,7 +11,7 @@
         class Foo < Formula
           desc "foo"
           url "https://pypi.python.org/packages/source/foo/foo-0.1.tar.gz"
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ use the `Source` url found on PyPI downloads page (`https://pypi.org/project/foo/#files`)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/PyPiUrls: use the `Source` url found on PyPI downloads page (`https://pypi.org/project/foo/#files`)
         end
       RUBY
     end
@@ -22,7 +21,7 @@ class Foo < Formula
         class Foo < Formula
           desc "foo"
           url "https://files.pythonhosted.org/packages/source/f/foo/foo-0.1.tar.gz"
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ use the `Source` url found on PyPI downloads page (`https://pypi.org/project/foo/#files`)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/PyPiUrls: use the `Source` url found on PyPI downloads page (`https://pypi.org/project/foo/#files`)
         end
       RUBY
     end
diff --git a/Library/Homebrew/test/rubocops/urls_spec.rb b/Library/Homebrew/test/rubocops/urls_spec.rb
index 77b221bd0e00d..80bf49199a02e 100644
--- a/Library/Homebrew/test/rubocops/urls_spec.rb
+++ b/Library/Homebrew/test/rubocops/urls_spec.rb
@@ -1,12 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/urls"
 
-describe RuboCop::Cop::FormulaAudit::Urls do
+RSpec.describe RuboCop::Cop::FormulaAudit::Urls do
   subject(:cop) { described_class.new }
 
-  let(:offense_list) {
+  let(:offense_list) do
     [{
       "url" => "https://ftpmirror.gnu.org/lightning/lightning-2.1.0.tar.gz",
       "msg" => 'Please use "https://ftp.gnu.org/gnu/lightning/lightning-2.1.0.tar.gz" instead of https://ftpmirror.gnu.org/lightning/lightning-2.1.0.tar.gz.',
@@ -64,10 +63,8 @@
       "col" => 2,
     }, {
       "url" => "http://prdownloads.sourceforge.net/foo/foo-1.tar.gz",
-      "msg" => <<~EOS.chomp,
-        Don't use prdownloads in SourceForge urls (url is http://prdownloads.sourceforge.net/foo/foo-1.tar.gz).
-                See: http://librelist.com/browser/homebrew/2011/1/12/prdownloads-is-bad/
-      EOS
+      "msg" => "Don't use prdownloads in SourceForge urls " \
+               "(url is http://prdownloads.sourceforge.net/foo/foo-1.tar.gz).",
       "col" => 2,
     }, {
       "url" => "http://foo.dl.sourceforge.net/sourceforge/foozip/foozip_1.0.tar.bz2",
@@ -181,7 +178,7 @@
       "msg" => "Use of the svn+http:// scheme is deprecated, pass `:using => :svn` instead",
       "col" => 2,
     }]
-  }
+  end
 
   context "when auditing URLs" do
     it "reports all offenses in `offense_list`" do
@@ -194,11 +191,11 @@ class Foo < Formula
             url "#{offense_info["url"]}"
           end
         RUBY
-        expected_offenses = [{ message:  offense_info["msg"],
+        expected_offenses = [{ message:  "FormulaAudit/Urls: #{offense_info["msg"]}",
                                severity: :convention,
                                line:     3,
                                column:   offense_info["col"],
-                               source:   source }]
+                               source: }]
 
         offenses = inspect_source(source)
 
@@ -219,7 +216,7 @@ class Foo < Formula
 
           stable do
             url "git://github.com/foo.git",
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Please use https:// for git://github.com/foo.git
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Urls: Please use https:// for git://github.com/foo.git
                 :tag => "v1.0.1",
                 :revision => "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
             version "1.0.1"
@@ -234,7 +231,7 @@ class Foo < Formula
           desc "foo"
           url "https://ftpmirror.fnu.org/foo/foo-1.0.tar.gz"
           mirror "https://ftpmirror.fnu.org/foo/foo-1.0.tar.gz"
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ URL should not be duplicated as a mirror: https://ftpmirror.fnu.org/foo/foo-1.0.tar.gz
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/Urls: URL should not be duplicated as a mirror: https://ftpmirror.fnu.org/foo/foo-1.0.tar.gz
         end
       RUBY
     end
diff --git a/Library/Homebrew/test/rubocops/uses_from_macos_spec.rb b/Library/Homebrew/test/rubocops/uses_from_macos_spec.rb
index 6a1280050518b..5d00eb4f7c1ef 100644
--- a/Library/Homebrew/test/rubocops/uses_from_macos_spec.rb
+++ b/Library/Homebrew/test/rubocops/uses_from_macos_spec.rb
@@ -1,21 +1,51 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/uses_from_macos"
 
-describe RuboCop::Cop::FormulaAudit::UsesFromMacos do
+RSpec.describe RuboCop::Cop::FormulaAudit::UsesFromMacos do
   subject(:cop) { described_class.new }
 
-  it "when auditing uses_from_macos dependencies" do
-    expect_offense(<<~RUBY)
-      class Foo < Formula
-        url "https://brew.sh/foo-1.0.tgz"
-        homepage "https://brew.sh"
+  context "when auditing `uses_from_macos` dependencies" do
+    it "reports an offense when used on non-macOS dependency" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
 
-        uses_from_macos "postgresql"
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `uses_from_macos` should only be used for macOS dependencies, not postgresql.
-      end
-    RUBY
+          uses_from_macos "postgresql"
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/UsesFromMacos: `uses_from_macos` should only be used for macOS dependencies, not postgresql.
+        end
+      RUBY
+    end
+
+    it "reports offenses for multiple non-macOS dependencies and none for valid macOS dependencies" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+
+          uses_from_macos "boost"
+          ^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/UsesFromMacos: `uses_from_macos` should only be used for macOS dependencies, not boost.
+          uses_from_macos "bzip2"
+          uses_from_macos "postgresql"
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/UsesFromMacos: `uses_from_macos` should only be used for macOS dependencies, not postgresql.
+          uses_from_macos "zlib"
+        end
+      RUBY
+    end
+
+    it "reports an offense when used in `depends_on :linux` formula" do
+      expect_offense(<<~RUBY)
+        class Foo < Formula
+          url "https://brew.sh/foo-1.0.tgz"
+          homepage "https://brew.sh"
+
+          depends_on :linux
+          uses_from_macos "zlib"
+          ^^^^^^^^^^^^^^^^^^^^^^ FormulaAudit/UsesFromMacos: `uses_from_macos` should not be used when Linux is required.
+        end
+      RUBY
+    end
   end
 
   include_examples "formulae exist", described_class::ALLOWED_USES_FROM_MACOS_DEPS
diff --git a/Library/Homebrew/test/rubocops/version_spec.rb b/Library/Homebrew/test/rubocops/version_spec.rb
index c055fed61ff4f..c4c9dfef1ec14 100644
--- a/Library/Homebrew/test/rubocops/version_spec.rb
+++ b/Library/Homebrew/test/rubocops/version_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "rubocops/version"
 
-describe RuboCop::Cop::FormulaAudit::Version do
+RSpec.describe RuboCop::Cop::FormulaAudit::Version do
   subject(:cop) { described_class.new }
 
   context "when auditing version" do
@@ -12,7 +11,7 @@
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           version ""
-          ^^^^^^^^^^ version is set to an empty string
+          ^^^^^^^^^^ FormulaAudit/Version: version is set to an empty string
         end
       RUBY
     end
@@ -22,7 +21,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           version "v1.0"
-          ^^^^^^^^^^^^^^ version v1.0 should not have a leading 'v'
+          ^^^^^^^^^^^^^^ FormulaAudit/Version: version v1.0 should not have a leading 'v'
         end
       RUBY
     end
@@ -32,7 +31,7 @@ class Foo < Formula
         class Foo < Formula
           url 'https://brew.sh/foo-1.0.tgz'
           version "1_0"
-          ^^^^^^^^^^^^^ version 1_0 should not end with an underline and a number
+          ^^^^^^^^^^^^^ FormulaAudit/Version: version 1_0 should not end with an underline and a number
         end
       RUBY
     end
diff --git a/Library/Homebrew/test/sandbox_spec.rb b/Library/Homebrew/test/sandbox_spec.rb
index 46b3a57df5af4..753f8d9809667 100644
--- a/Library/Homebrew/test/sandbox_spec.rb
+++ b/Library/Homebrew/test/sandbox_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "sandbox"
 
-describe Sandbox, :needs_macos do
+RSpec.describe Sandbox, :needs_macos do
   define_negated_matcher :not_matching, :matching
 
   subject(:sandbox) { described_class.new }
@@ -16,17 +15,61 @@
   end
 
   specify "#allow_write" do
-    sandbox.allow_write file
-    sandbox.exec "touch", file
+    sandbox.allow_write path: file
+    sandbox.run "touch", file
 
     expect(file).to exist
   end
 
-  describe "#exec" do
+  describe "#path_filter" do
+    ["'", '"', "(", ")", "\n", "\\"].each do |char|
+      it "fails if the path contains #{char}" do
+        expect do
+          sandbox.path_filter("foo#{char}bar", :subpath)
+        end.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#allow_write_cellar" do
+    it "fails when the formula has a name including )" do
+      f = formula do
+        url "https://brew.sh/foo-1.0.tar.gz"
+        version "1.0"
+
+        def initialize(*, **)
+          super
+          @name = "foo)bar"
+        end
+      end
+
+      expect do
+        sandbox.allow_write_cellar f
+      end.to raise_error(ArgumentError)
+    end
+
+    it "fails when the formula has a name including \"" do
+      f = formula do
+        url "https://brew.sh/foo-1.0.tar.gz"
+        version "1.0"
+
+        def initialize(*, **)
+          super
+          @name = "foo\"bar"
+        end
+      end
+
+      expect do
+        sandbox.allow_write_cellar f
+      end.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#run" do
     it "fails when writing to file not specified with ##allow_write" do
-      expect {
-        sandbox.exec "touch", file
-      }.to raise_error(ErrorDuringExecution)
+      expect do
+        sandbox.run "touch", file
+      end.to raise_error(ErrorDuringExecution)
 
       expect(file).not_to exist
     end
@@ -37,7 +80,7 @@
       allow(Utils).to receive(:popen_read).and_call_original
       allow(Utils).to receive(:popen_read).with("syslog", any_args).and_return("foo")
 
-      expect { sandbox.exec "false" }
+      expect { sandbox.run "false" }
         .to raise_error(ErrorDuringExecution)
         .and output(/foo/).to_stdout
     end
@@ -53,9 +96,37 @@
       allow(Utils).to receive(:popen_read).and_call_original
       allow(Utils).to receive(:popen_read).with("syslog", any_args).and_return(with_bogus_error)
 
-      expect { sandbox.exec "false" }
+      expect { sandbox.run "false" }
         .to raise_error(ErrorDuringExecution)
         .and output(a_string_matching(/foo/).and(matching(/bar/).and(not_matching(/Python/)))).to_stdout
     end
   end
+
+  describe "#disallow chmod on some directory" do
+    it "formula does a chmod to opt" do
+      expect { sandbox.run "chmod", "ug-w", HOMEBREW_PREFIX }.to raise_error(ErrorDuringExecution)
+    end
+
+    it "allows chmod on a path allowed to write" do
+      mktmpdir do |path|
+        FileUtils.touch path/"foo"
+        sandbox.allow_write_path(path)
+        expect { sandbox.run "chmod", "ug-w", path/"foo" }.not_to raise_error(ErrorDuringExecution)
+      end
+    end
+  end
+
+  describe "#disallow chmod SUID or SGID on some directory" do
+    it "formula does a chmod 4000 to opt" do
+      expect { sandbox.run "chmod", "4000", HOMEBREW_PREFIX }.to raise_error(ErrorDuringExecution)
+    end
+
+    it "allows chmod 4000 on a path allowed to write" do
+      mktmpdir do |path|
+        FileUtils.touch path/"foo"
+        sandbox.allow_write_path(path)
+        expect { sandbox.run "chmod", "4000", path/"foo" }.not_to raise_error(ErrorDuringExecution)
+      end
+    end
+  end
 end
diff --git a/Library/Homebrew/test/sbom_spec.rb b/Library/Homebrew/test/sbom_spec.rb
new file mode 100644
index 0000000000000..adf79fb7d81ef
--- /dev/null
+++ b/Library/Homebrew/test/sbom_spec.rb
@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "sbom"
+
+RSpec.describe SBOM do
+  describe "#schema_validation_errors" do
+    subject(:sbom) { described_class.create(f, tab) }
+
+    before { ENV.delete("HOMEBREW_ENFORCE_SBOM") }
+
+    let(:f) { formula { url "foo-1.0" } }
+    let(:tab) { Tab.new }
+
+    it "returns true if valid" do
+      expect(sbom.schema_validation_errors).to be_empty
+    end
+
+    it "returns true if valid when bottling" do
+      expect(sbom.schema_validation_errors(bottling: true)).to be_empty
+    end
+
+    context "with a maximal SBOM" do
+      let(:f) do
+        formula do
+          homepage "https://brew.sh"
+
+          url "https://brew.sh/test-0.1.tbz"
+          sha256 TEST_SHA256
+
+          patch do
+            url "patch_macos"
+          end
+
+          bottle do
+            sha256 all: "9befdad158e59763fb0622083974a6252878019702d8c961e1bec3a5f5305339"
+          end
+
+          # some random dependencies to test with
+          depends_on "cmake" => :build
+          depends_on "beanstalkd"
+
+          uses_from_macos "python" => :build
+          uses_from_macos "zlib"
+        end
+      end
+      let(:tab) do
+        beanstalkd = formula "beanstalkd" do
+          url "one-1.1"
+
+          bottle do
+            sha256 all: "ac4c0330b70dae06eaa8065bfbea78dda277699d1ae8002478017a1bd9cf1908"
+          end
+        end
+
+        zlib = formula "zlib" do
+          url "two-1.1"
+
+          bottle do
+            sha256 all: "6a4642964fe5c4d1cc8cd3507541736d5b984e34a303a814ef550d4f2f8242f9"
+          end
+        end
+
+        runtime_dependencies = [beanstalkd, zlib]
+        runtime_deps_hash = runtime_dependencies.map do |dep|
+          {
+            "full_name"         => dep.full_name,
+            "version"           => dep.version.to_s,
+            "revision"          => dep.revision,
+            "pkg_version"       => dep.pkg_version.to_s,
+            "declared_directly" => true,
+          }
+        end
+        allow(Tab).to receive(:runtime_deps_hash).and_return(runtime_deps_hash)
+        tab = Tab.create(f, DevelopmentTools.default_compiler, :libcxx)
+
+        allow(Formulary).to receive(:factory).with("beanstalkd").and_return(beanstalkd)
+        allow(Formulary).to receive(:factory).with("zlib").and_return(zlib)
+
+        tab
+      end
+
+      it "returns true if valid" do
+        expect(sbom.schema_validation_errors).to be_empty
+      end
+
+      it "returns true if valid when bottling" do
+        expect(sbom.schema_validation_errors(bottling: true)).to be_empty
+      end
+    end
+
+    context "with an invalid SBOM" do
+      before do
+        allow(sbom).to receive(:to_spdx_sbom).and_return({}) # fake an empty SBOM
+      end
+
+      it "returns false" do
+        expect(sbom.schema_validation_errors).not_to be_empty
+      end
+
+      it "returns false when bottling" do
+        expect(sbom.schema_validation_errors(bottling: true)).not_to be_empty
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/test/search_spec.rb b/Library/Homebrew/test/search_spec.rb
index 56949f23409ab..aa0ba3ec9ee3a 100644
--- a/Library/Homebrew/test/search_spec.rb
+++ b/Library/Homebrew/test/search_spec.rb
@@ -1,68 +1,97 @@
-# typed: false
 # frozen_string_literal: true
 
 require "search"
+require "descriptions"
+require "cmd/desc"
 
-describe Homebrew::Search do
-  subject(:mod) { Object.new }
+RSpec.describe Homebrew::Search do
+  describe "#query_regexp" do
+    it "correctly parses a regex query" do
+      expect(described_class.query_regexp("/^query$/")).to eq(/^query$/)
+    end
+
+    it "returns the original string if it is not a regex query" do
+      expect(described_class.query_regexp("query")).to eq("query")
+    end
 
-  before do
-    mod.extend(described_class)
+    it "raises an error if the query is an invalid regex" do
+      expect { described_class.query_regexp("/+/") }.to raise_error(/not a valid regex/)
+    end
   end
 
-  describe "#search_taps" do
-    before do
-      ENV.delete("HOMEBREW_NO_GITHUB_API")
+  describe "#search" do
+    let(:collection) { ["with-dashes", "with@alpha", "with+plus"] }
+
+    context "when given a block" do
+      let(:collection) { [["with-dashes", "withdashes"]] }
+
+      it "searches by the selected argument" do
+        expect(described_class.search(collection, /withdashes/) { |_, short_name| short_name }).not_to be_empty
+        expect(described_class.search(collection, /withdashes/) { |long_name, _| long_name }).to be_empty
+      end
     end
 
-    it "does not raise if `HOMEBREW_NO_GITHUB_API` is set" do
-      ENV["HOMEBREW_NO_GITHUB_API"] = "1"
-      expect(mod.search_taps("some-formula")).to match(formulae: [], casks: [])
+    context "when given a regex" do
+      it "does not simplify strings" do
+        expect(described_class.search(collection, /with-dashes/)).to eq ["with-dashes"]
+      end
     end
 
-    it "does not raise if the network fails" do
-      allow(GitHub::API).to receive(:open_rest).and_raise(GitHub::API::Error)
+    context "when given a string" do
+      it "simplifies both the query and searched strings" do
+        expect(described_class.search(collection, "with dashes")).to eq ["with-dashes"]
+      end
 
-      expect(mod.search_taps("some-formula"))
-        .to match(formulae: [], casks: [])
+      it "does not simplify strings with @ and + characters" do
+        expect(described_class.search(collection, "with@alpha")).to eq ["with@alpha"]
+        expect(described_class.search(collection, "with+plus")).to eq ["with+plus"]
+      end
     end
 
-    it "returns Formulae and Casks separately" do
-      json_response = {
-        "items" => [
-          {
-            "path"       => "Formula/some-formula.rb",
-            "repository" => {
-              "full_name" => "Homebrew/homebrew-foo",
-            },
-          },
-          {
-            "path"       => "Casks/some-cask.rb",
-            "repository" => {
-              "full_name" => "Homebrew/homebrew-bar",
-            },
-          },
-        ],
-      }
-
-      allow(GitHub::API).to receive(:open_rest).and_yield(json_response)
-
-      expect(mod.search_taps("some-formula"))
-        .to match(formulae: ["homebrew/foo/some-formula"], casks: ["homebrew/bar/some-cask"])
+    context "when searching a Hash" do
+      let(:collection) { { "foo" => "bar" } }
+
+      it "returns a Hash" do
+        expect(described_class.search(collection, "foo")).to eq "foo" => "bar"
+      end
+
+      context "with a nil value" do
+        let(:collection) { { "foo" => nil } }
+
+        it "does not raise an error" do
+          expect(described_class.search(collection, "foo")).to eq "foo" => nil
+        end
+      end
     end
   end
 
-  describe "#query_regexp" do
-    it "correctly parses a regex query" do
-      expect(mod.query_regexp("/^query$/")).to eq(/^query$/)
-    end
+  describe "#search_descriptions" do
+    let(:args) { Homebrew::Cmd::Desc.new(["min_arg_placeholder"]).args }
 
-    it "returns the original string if it is not a regex query" do
-      expect(mod.query_regexp("query")).to eq("query")
-    end
+    context "with api" do
+      let(:api_formulae) do
+        { "testball" => { "desc" => "Some test" } }
+      end
 
-    it "raises an error if the query is an invalid regex" do
-      expect { mod.query_regexp("/+/") }.to raise_error(/not a valid regex/)
+      let(:api_casks) do
+        { "testball" => { "desc" => "Some test", "name" => ["Test Ball"] } }
+      end
+
+      before do
+        allow(Homebrew::API::Formula).to receive(:all_formulae).and_return(api_formulae)
+        allow(Homebrew::API::Cask).to receive(:all_casks).and_return(api_casks)
+      end
+
+      it "searches formula descriptions" do
+        expect { described_class.search_descriptions(described_class.query_regexp("some"), args) }
+          .to output(/testball: Some test/).to_stdout
+      end
+
+      it "searches cask descriptions", :needs_macos do
+        expect { described_class.search_descriptions(described_class.query_regexp("ball"), args) }
+          .to output(/testball: \(Test Ball\) Some test/).to_stdout
+          .and not_to_output(/testball: Some test/).to_stdout
+      end
     end
   end
 end
diff --git a/Library/Homebrew/test/searchable_spec.rb b/Library/Homebrew/test/searchable_spec.rb
deleted file mode 100644
index eee316379fba1..0000000000000
--- a/Library/Homebrew/test/searchable_spec.rb
+++ /dev/null
@@ -1,49 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "searchable"
-
-describe Searchable do
-  subject(:searchable_collection) { collection.extend(described_class) }
-
-  let(:collection) { ["with-dashes"] }
-
-  describe "#search" do
-    context "when given a block" do
-      let(:collection) { [["with-dashes", "withdashes"]] }
-
-      it "searches by the selected argument" do
-        expect(searchable_collection.search(/withdashes/) { |_, short_name| short_name }).not_to be_empty
-        expect(searchable_collection.search(/withdashes/) { |long_name, _| long_name }).to be_empty
-      end
-    end
-
-    context "when given a regex" do
-      it "does not simplify strings" do
-        expect(searchable_collection.search(/with-dashes/)).to eq ["with-dashes"]
-      end
-    end
-
-    context "when given a string" do
-      it "simplifies both the query and searched strings" do
-        expect(searchable_collection.search("with dashes")).to eq ["with-dashes"]
-      end
-    end
-
-    context "when searching a Hash" do
-      let(:collection) { { "foo" => "bar" } }
-
-      it "returns a Hash" do
-        expect(searchable_collection.search("foo")).to eq "foo" => "bar"
-      end
-
-      context "with a nil value" do
-        let(:collection) { { "foo" => nil } }
-
-        it "does not raise an error" do
-          expect(searchable_collection.search("foo")).to eq "foo" => nil
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/test/service_spec.rb b/Library/Homebrew/test/service_spec.rb
index e35f0f4cb947a..a4b7a913a97c0 100644
--- a/Library/Homebrew/test/service_spec.rb
+++ b/Library/Homebrew/test/service_spec.rb
@@ -1,30 +1,40 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formula"
 require "service"
 
-describe Homebrew::Service do
-  let(:klass) do
-    Class.new(Formula) do
+RSpec.describe Homebrew::Service do
+  let(:name) { "formula_name" }
+
+  def stub_formula(&block)
+    formula(name) do
       url "https://brew.sh/test-1.0.tbz"
+
+      instance_eval(&block) if block
+    end
+  end
+
+  def stub_formula_with_service_sockets(sockets_var)
+    stub_formula do
+      service do
+        run opt_bin/"beanstalkd"
+        sockets sockets_var
+      end
     end
   end
-  let(:name) { "formula_name" }
-  let(:path) { Formulary.core_path(name) }
-  let(:spec) { :stable }
-  let(:f) { klass.new(name, path, spec) }
 
   describe "#std_service_path_env" do
     it "returns valid std_service_path_env" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        run_type :immediate
-        environment_variables PATH: std_service_path_env
-        error_log_path var/"log/beanstalkd.error.log"
-        log_path var/"log/beanstalkd.log"
-        working_dir var
-        keep_alive true
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          run_type :immediate
+          environment_variables PATH: std_service_path_env
+          error_log_path var/"log/beanstalkd.error.log"
+          log_path var/"log/beanstalkd.log"
+          working_dir var
+          keep_alive true
+        end
       end
 
       path = f.service.std_service_path_env
@@ -34,88 +44,126 @@
 
   describe "#process_type" do
     it "throws for unexpected type" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        process_type :cow
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          process_type :cow
+        end
       end
 
-      expect {
+      expect do
         f.service.manual_command
-      }.to raise_error TypeError, "Service#process_type allows: 'background'/'standard'/'interactive'/'adaptive'"
+      end.to raise_error TypeError, "Service#process_type allows: 'background'/'standard'/'interactive'/'adaptive'"
     end
   end
 
   describe "#keep_alive" do
     it "throws for unexpected keys" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        keep_alive test: "key"
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          keep_alive test: "key"
+        end
       end
 
-      expect {
+      expect do
         f.service.manual_command
-      }.to raise_error TypeError, "Service#keep_alive allows only [:always, :successful_exit, :crashed, :path]"
+      end.to raise_error TypeError, "Service#keep_alive allows only [:always, :successful_exit, :crashed, :path]"
+    end
+  end
+
+  describe "#requires_root?" do
+    it "returns status when set" do
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          require_root true
+        end
+      end
+
+      expect(f.service.requires_root?).to be(true)
+    end
+
+    it "returns status when not set" do
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+        end
+      end
+
+      expect(f.service.requires_root?).to be(false)
     end
   end
 
   describe "#run_type" do
     it "throws for unexpected type" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        run_type :cow
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          run_type :cow
+        end
       end
 
-      expect {
+      expect do
         f.service.manual_command
-      }.to raise_error TypeError, "Service#run_type allows: 'immediate'/'interval'/'cron'"
+      end.to raise_error TypeError, "Service#run_type allows: 'immediate'/'interval'/'cron'"
     end
   end
 
   describe "#sockets" do
+    let(:sockets_type_error_message) { "Service#sockets a formatted socket definition as <type>://<host>:<port>" }
+
     it "throws for missing type" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        sockets "127.0.0.1:80"
+      [
+        stub_formula_with_service_sockets("127.0.0.1:80"),
+        stub_formula_with_service_sockets({ socket: "127.0.0.1:80" }),
+      ].each do |f|
+        expect { f.service.manual_command }.to raise_error TypeError, sockets_type_error_message
       end
-
-      expect {
-        f.service.manual_command
-      }.to raise_error TypeError, "Service#sockets a formatted socket definition as <type>://<host>:<port>"
     end
 
     it "throws for missing host" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        sockets "tcp://:80"
+      [
+        stub_formula_with_service_sockets("tcp://:80"),
+        stub_formula_with_service_sockets({ socket: "tcp://:80" }),
+      ].each do |f|
+        expect { f.service.manual_command }.to raise_error TypeError, sockets_type_error_message
       end
-
-      expect {
-        f.service.manual_command
-      }.to raise_error TypeError, "Service#sockets a formatted socket definition as <type>://<host>:<port>"
     end
 
     it "throws for missing port" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        sockets "tcp://127.0.0.1"
+      [
+        stub_formula_with_service_sockets("tcp://127.0.0.1"),
+        stub_formula_with_service_sockets({ socket: "tcp://127.0.0.1" }),
+      ].each do |f|
+        expect { f.service.manual_command }.to raise_error TypeError, sockets_type_error_message
       end
+    end
 
-      expect {
-        f.service.manual_command
-      }.to raise_error TypeError, "Service#sockets a formatted socket definition as <type>://<host>:<port>"
+    it "throws for invalid host" do
+      [
+        stub_formula_with_service_sockets("tcp://300.0.0.1:80"),
+        stub_formula_with_service_sockets({ socket: "tcp://300.0.0.1:80" }),
+      ].each do |f|
+        expect do
+          f.service.manual_command
+        end.to raise_error TypeError, "Service#sockets expects a valid ipv4 or ipv6 host address"
+      end
     end
   end
 
   describe "#manual_command" do
     it "returns valid manual_command" do
-      f.class.service do
-        run "#{HOMEBREW_PREFIX}/bin/beanstalkd"
-        run_type :immediate
-        environment_variables PATH: std_service_path_env, ETC_DIR: etc/"beanstalkd"
-        error_log_path var/"log/beanstalkd.error.log"
-        log_path var/"log/beanstalkd.log"
-        working_dir var
-        keep_alive true
+      f = stub_formula do
+        service do
+          run "#{HOMEBREW_PREFIX}/bin/beanstalkd"
+          run_type :immediate
+          environment_variables PATH: std_service_path_env, ETC_DIR: etc/"beanstalkd"
+          error_log_path var/"log/beanstalkd.error.log"
+          log_path var/"log/beanstalkd.log"
+          working_dir var
+          keep_alive true
+        end
       end
 
       path = f.service.manual_command
@@ -123,14 +171,16 @@
     end
 
     it "returns valid manual_command without variables" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        run_type :immediate
-        environment_variables PATH: std_service_path_env
-        error_log_path var/"log/beanstalkd.error.log"
-        log_path var/"log/beanstalkd.log"
-        working_dir var
-        keep_alive true
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          run_type :immediate
+          environment_variables PATH: std_service_path_env
+          error_log_path var/"log/beanstalkd.error.log"
+          log_path var/"log/beanstalkd.log"
+          working_dir var
+          keep_alive true
+        end
       end
 
       path = f.service.manual_command
@@ -140,21 +190,24 @@
 
   describe "#to_plist" do
     it "returns valid plist" do
-      f.class.service do
-        run [opt_bin/"beanstalkd", "test"]
-        run_type :immediate
-        environment_variables PATH: std_service_path_env, FOO: "BAR", ETC_DIR: etc/"beanstalkd"
-        error_log_path var/"log/beanstalkd.error.log"
-        log_path var/"log/beanstalkd.log"
-        input_path var/"in/beanstalkd"
-        root_dir var
-        working_dir var
-        keep_alive true
-        launch_only_once true
-        process_type :interactive
-        restart_delay 30
-        interval 5
-        macos_legacy_timers true
+      f = stub_formula do
+        service do
+          run [opt_bin/"beanstalkd", "test"]
+          run_type :immediate
+          environment_variables PATH: std_service_path_env, FOO: "BAR", ETC_DIR: etc/"beanstalkd"
+          error_log_path var/"log/beanstalkd.error.log"
+          log_path var/"log/beanstalkd.log"
+          input_path var/"in/beanstalkd"
+          require_root true
+          root_dir var
+          working_dir var
+          keep_alive true
+          launch_only_once true
+          process_type :interactive
+          restart_delay 30
+          interval 5
+          macos_legacy_timers true
+        end
       end
 
       plist = f.service.to_plist
@@ -216,9 +269,58 @@
     end
 
     it "returns valid plist with socket" do
-      f.class.service do
-        run [opt_bin/"beanstalkd", "test"]
-        sockets "tcp://127.0.0.1:80"
+      plist_expect = <<~EOS
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+        \t<key>Label</key>
+        \t<string>homebrew.mxcl.formula_name</string>
+        \t<key>LimitLoadToSessionType</key>
+        \t<array>
+        \t\t<string>Aqua</string>
+        \t\t<string>Background</string>
+        \t\t<string>LoginWindow</string>
+        \t\t<string>StandardIO</string>
+        \t\t<string>System</string>
+        \t</array>
+        \t<key>ProgramArguments</key>
+        \t<array>
+        \t\t<string>#{HOMEBREW_PREFIX}/opt/formula_name/bin/beanstalkd</string>
+        \t</array>
+        \t<key>RunAtLoad</key>
+        \t<true/>
+        \t<key>Sockets</key>
+        \t<dict>
+        \t\t<key>listeners</key>
+        \t\t<dict>
+        \t\t\t<key>SockNodeName</key>
+        \t\t\t<string>127.0.0.1</string>
+        \t\t\t<key>SockProtocol</key>
+        \t\t\t<string>TCP</string>
+        \t\t\t<key>SockServiceName</key>
+        \t\t\t<string>80</string>
+        \t\t</dict>
+        \t</dict>
+        </dict>
+        </plist>
+      EOS
+
+      [
+        stub_formula_with_service_sockets("tcp://127.0.0.1:80"),
+        stub_formula_with_service_sockets({ listeners: "tcp://127.0.0.1:80" }),
+      ].each do |f|
+        plist = f.service.to_plist
+        expect(plist).to eq(plist_expect)
+      end
+    end
+
+    it "returns valid plist with multiple sockets" do
+      f = stub_formula do
+        service do
+          run [opt_bin/"beanstalkd", "test"]
+          sockets socket: "tcp://0.0.0.0:80", socket_tls: "tcp://0.0.0.0:443"
+        end
       end
 
       plist = f.service.to_plist
@@ -246,17 +348,24 @@
         \t<true/>
         \t<key>Sockets</key>
         \t<dict>
-        \t\t<key>Listeners</key>
+        \t\t<key>socket</key>
         \t\t<dict>
-        \t\t\t<key>SockFamily</key>
-        \t\t\t<string>IPv4v6</string>
         \t\t\t<key>SockNodeName</key>
-        \t\t\t<string>127.0.0.1</string>
+        \t\t\t<string>0.0.0.0</string>
         \t\t\t<key>SockProtocol</key>
         \t\t\t<string>TCP</string>
         \t\t\t<key>SockServiceName</key>
         \t\t\t<string>80</string>
         \t\t</dict>
+        \t\t<key>socket_tls</key>
+        \t\t<dict>
+        \t\t\t<key>SockNodeName</key>
+        \t\t\t<string>0.0.0.0</string>
+        \t\t\t<key>SockProtocol</key>
+        \t\t\t<string>TCP</string>
+        \t\t\t<key>SockServiceName</key>
+        \t\t\t<string>443</string>
+        \t\t</dict>
         \t</dict>
         </dict>
         </plist>
@@ -265,9 +374,11 @@
     end
 
     it "returns valid partial plist" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        run_type :immediate
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          run_type :immediate
+        end
       end
 
       plist = f.service.to_plist
@@ -298,11 +409,13 @@
       expect(plist).to eq(plist_expect)
     end
 
-    it "returns valid interval plist" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        run_type :interval
-        interval 5
+    it "returns valid partial plist with run_at_load being false" do
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          run_type :immediate
+          run_at_load false
+        end
       end
 
       plist = f.service.to_plist
@@ -327,6 +440,43 @@
         \t</array>
         \t<key>RunAtLoad</key>
         \t<false/>
+        </dict>
+        </plist>
+      EOS
+      expect(plist).to eq(plist_expect)
+    end
+
+    it "returns valid interval plist" do
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          run_type :interval
+          interval 5
+        end
+      end
+
+      plist = f.service.to_plist
+      plist_expect = <<~EOS
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+        \t<key>Label</key>
+        \t<string>homebrew.mxcl.formula_name</string>
+        \t<key>LimitLoadToSessionType</key>
+        \t<array>
+        \t\t<string>Aqua</string>
+        \t\t<string>Background</string>
+        \t\t<string>LoginWindow</string>
+        \t\t<string>StandardIO</string>
+        \t\t<string>System</string>
+        \t</array>
+        \t<key>ProgramArguments</key>
+        \t<array>
+        \t\t<string>#{HOMEBREW_PREFIX}/opt/formula_name/bin/beanstalkd</string>
+        \t</array>
+        \t<key>RunAtLoad</key>
+        \t<true/>
         \t<key>StartInterval</key>
         \t<integer>5</integer>
         </dict>
@@ -336,10 +486,12 @@
     end
 
     it "returns valid cron plist" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        run_type :cron
-        cron "@daily"
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          run_type :cron
+          cron "@daily"
+        end
       end
 
       plist = f.service.to_plist
@@ -363,7 +515,7 @@
         \t\t<string>#{HOMEBREW_PREFIX}/opt/formula_name/bin/beanstalkd</string>
         \t</array>
         \t<key>RunAtLoad</key>
-        \t<false/>
+        \t<true/>
         \t<key>StartCalendarInterval</key>
         \t<dict>
         \t\t<key>Hour</key>
@@ -378,9 +530,11 @@
     end
 
     it "returns valid keepalive-exit plist" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        keep_alive successful_exit: false
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          keep_alive successful_exit: false
+        end
       end
 
       plist = f.service.to_plist
@@ -417,9 +571,11 @@
     end
 
     it "returns valid keepalive-crashed plist" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        keep_alive crashed: true
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          keep_alive crashed: true
+        end
       end
 
       plist = f.service.to_plist
@@ -456,9 +612,11 @@
     end
 
     it "returns valid keepalive-path plist" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        keep_alive path: opt_pkgshare/"test-path"
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          keep_alive path: opt_pkgshare/"test-path"
+        end
       end
 
       plist = f.service.to_plist
@@ -493,23 +651,69 @@
       EOS
       expect(plist).to eq(plist_expect)
     end
+
+    it "expands paths" do
+      f = stub_formula do
+        service do
+          run [opt_sbin/"sleepwatcher", "-V", "-s", "~/.sleep", "-w", "~/.wakeup"]
+          working_dir "~"
+        end
+      end
+
+      plist = f.service.to_plist
+      plist_expect = <<~EOS
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+        \t<key>Label</key>
+        \t<string>homebrew.mxcl.formula_name</string>
+        \t<key>LimitLoadToSessionType</key>
+        \t<array>
+        \t\t<string>Aqua</string>
+        \t\t<string>Background</string>
+        \t\t<string>LoginWindow</string>
+        \t\t<string>StandardIO</string>
+        \t\t<string>System</string>
+        \t</array>
+        \t<key>ProgramArguments</key>
+        \t<array>
+        \t\t<string>#{HOMEBREW_PREFIX}/opt/formula_name/sbin/sleepwatcher</string>
+        \t\t<string>-V</string>
+        \t\t<string>-s</string>
+        \t\t<string>#{Dir.home}/.sleep</string>
+        \t\t<string>-w</string>
+        \t\t<string>#{Dir.home}/.wakeup</string>
+        \t</array>
+        \t<key>RunAtLoad</key>
+        \t<true/>
+        \t<key>WorkingDirectory</key>
+        \t<string>#{Dir.home}</string>
+        </dict>
+        </plist>
+      EOS
+      expect(plist).to eq(plist_expect)
+    end
   end
 
   describe "#to_systemd_unit" do
     it "returns valid unit" do
-      f.class.service do
-        run [opt_bin/"beanstalkd", "test"]
-        run_type :immediate
-        environment_variables PATH: std_service_path_env, FOO: "BAR"
-        error_log_path var/"log/beanstalkd.error.log"
-        log_path var/"log/beanstalkd.log"
-        input_path var/"in/beanstalkd"
-        root_dir var
-        working_dir var
-        keep_alive true
-        process_type :interactive
-        restart_delay 30
-        macos_legacy_timers true
+      f = stub_formula do
+        service do
+          run [opt_bin/"beanstalkd", "test"]
+          run_type :immediate
+          environment_variables PATH: std_service_path_env, FOO: "BAR"
+          error_log_path var/"log/beanstalkd.error.log"
+          log_path var/"log/beanstalkd.log"
+          input_path var/"in/beanstalkd"
+          require_root true
+          root_dir var
+          working_dir var
+          keep_alive true
+          process_type :interactive
+          restart_delay 30
+          macos_legacy_timers true
+        end
       end
 
       unit = f.service.to_systemd_unit
@@ -519,7 +723,7 @@
         Description=Homebrew generated unit for formula_name
 
         [Install]
-        WantedBy=multi-user.target
+        WantedBy=default.target
 
         [Service]
         Type=simple
@@ -531,17 +735,19 @@
         StandardInput=file:#{HOMEBREW_PREFIX}/var/in/beanstalkd
         StandardOutput=append:#{HOMEBREW_PREFIX}/var/log/beanstalkd.log
         StandardError=append:#{HOMEBREW_PREFIX}/var/log/beanstalkd.error.log
-        Environment=\"PATH=#{std_path}\"
-        Environment=\"FOO=BAR\"
+        Environment="PATH=#{std_path}"
+        Environment="FOO=BAR"
       EOS
       expect(unit).to eq(unit_expect.strip)
     end
 
     it "returns valid partial oneshot unit" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        run_type :immediate
-        launch_only_once true
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          run_type :immediate
+          launch_only_once true
+        end
       end
 
       unit = f.service.to_systemd_unit
@@ -550,7 +756,7 @@
         Description=Homebrew generated unit for formula_name
 
         [Install]
-        WantedBy=multi-user.target
+        WantedBy=default.target
 
         [Service]
         Type=oneshot
@@ -558,14 +764,40 @@
       EOS
       expect(unit).to eq(unit_expect.strip)
     end
+
+    it "expands paths" do
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          working_dir "~"
+        end
+      end
+
+      unit = f.service.to_systemd_unit
+      unit_expect = <<~EOS
+        [Unit]
+        Description=Homebrew generated unit for formula_name
+
+        [Install]
+        WantedBy=default.target
+
+        [Service]
+        Type=simple
+        ExecStart=#{HOMEBREW_PREFIX}/opt/#{name}/bin/beanstalkd
+        WorkingDirectory=#{Dir.home}
+      EOS
+      expect(unit).to eq(unit_expect.strip)
+    end
   end
 
   describe "#to_systemd_timer" do
     it "returns valid timer" do
-      f.class.service do
-        run [opt_bin/"beanstalkd", "test"]
-        run_type :interval
-        interval 5
+      f = stub_formula do
+        service do
+          run [opt_bin/"beanstalkd", "test"]
+          run_type :interval
+          interval 5
+        end
       end
 
       unit = f.service.to_systemd_timer
@@ -584,9 +816,11 @@
     end
 
     it "returns valid partial timer" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        run_type :immediate
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          run_type :immediate
+        end
       end
 
       unit = f.service.to_systemd_timer
@@ -604,15 +838,17 @@
     end
 
     it "throws on incomplete cron" do
-      f.class.service do
-        run opt_bin/"beanstalkd"
-        run_type :cron
-        cron "1 2 3 4"
+      f = stub_formula do
+        service do
+          run opt_bin/"beanstalkd"
+          run_type :cron
+          cron "1 2 3 4"
+        end
       end
 
-      expect {
+      expect do
         f.service.to_systemd_timer
-      }.to raise_error TypeError, "Service#parse_cron expects a valid cron syntax"
+      end.to raise_error TypeError, "Service#parse_cron expects a valid cron syntax"
     end
 
     it "returns valid cron timers" do
@@ -627,10 +863,12 @@
       }
 
       styles.each do |cron, calendar|
-        f.class.service do
-          run opt_bin/"beanstalkd"
-          run_type :cron
-          cron cron.to_s
+        f = stub_formula do
+          service do
+            run opt_bin/"beanstalkd"
+            run_type :cron
+            cron cron.to_s
+          end
         end
 
         unit = f.service.to_systemd_timer
@@ -653,18 +891,22 @@
 
   describe "#timed?" do
     it "returns false for immediate" do
-      f.class.service do
-        run [opt_bin/"beanstalkd", "test"]
-        run_type :immediate
+      f = stub_formula do
+        service do
+          run [opt_bin/"beanstalkd", "test"]
+          run_type :immediate
+        end
       end
 
       expect(f.service.timed?).to be(false)
     end
 
     it "returns true for interval" do
-      f.class.service do
-        run [opt_bin/"beanstalkd", "test"]
-        run_type :interval
+      f = stub_formula do
+        service do
+          run [opt_bin/"beanstalkd", "test"]
+          run_type :interval
+        end
       end
 
       expect(f.service.timed?).to be(true)
@@ -673,35 +915,43 @@
 
   describe "#keep_alive?" do
     it "returns true when keep_alive set to hash" do
-      f.class.service do
-        run [opt_bin/"beanstalkd", "test"]
-        keep_alive crashed: true
+      f = stub_formula do
+        service do
+          run [opt_bin/"beanstalkd", "test"]
+          keep_alive crashed: true
+        end
       end
 
       expect(f.service.keep_alive?).to be(true)
     end
 
     it "returns true when keep_alive set to true" do
-      f.class.service do
-        run [opt_bin/"beanstalkd", "test"]
-        keep_alive true
+      f = stub_formula do
+        service do
+          run [opt_bin/"beanstalkd", "test"]
+          keep_alive true
+        end
       end
 
       expect(f.service.keep_alive?).to be(true)
     end
 
     it "returns false when keep_alive not set" do
-      f.class.service do
-        run [opt_bin/"beanstalkd", "test"]
+      f = stub_formula do
+        service do
+          run [opt_bin/"beanstalkd", "test"]
+        end
       end
 
       expect(f.service.keep_alive?).to be(false)
     end
 
     it "returns false when keep_alive set to false" do
-      f.class.service do
-        run [opt_bin/"beanstalkd", "test"]
-        keep_alive false
+      f = stub_formula do
+        service do
+          run [opt_bin/"beanstalkd", "test"]
+          keep_alive false
+        end
       end
 
       expect(f.service.keep_alive?).to be(false)
@@ -710,13 +960,190 @@
 
   describe "#command" do
     it "returns @run data" do
-      f.class.service do
-        run [opt_bin/"beanstalkd", "test"]
-        run_type :immediate
+      f = stub_formula do
+        service do
+          run [opt_bin/"beanstalkd", "test"]
+          run_type :immediate
+        end
+      end
+
+      command = f.service.command
+      expect(command).to eq(["#{HOMEBREW_PREFIX}/opt/#{name}/bin/beanstalkd", "test"])
+    end
+
+    it "returns @run data on Linux", :needs_linux do
+      f = stub_formula do
+        service do
+          run linux: [opt_bin/"beanstalkd", "test"]
+          run_type :immediate
+        end
+      end
+
+      command = f.service.command
+      expect(command).to eq(["#{HOMEBREW_PREFIX}/opt/#{name}/bin/beanstalkd", "test"])
+    end
+
+    it "returns nil on Linux", :needs_linux do
+      f = stub_formula do
+        service do
+          run macos: [opt_bin/"beanstalkd", "test"]
+          run_type :immediate
+        end
+      end
+
+      command = f.service.command
+      expect(command).to be_nil
+    end
+
+    it "returns @run data on macOS", :needs_macos do
+      f = stub_formula do
+        service do
+          run macos: [opt_bin/"beanstalkd", "test"]
+          run_type :immediate
+        end
       end
 
       command = f.service.command
       expect(command).to eq(["#{HOMEBREW_PREFIX}/opt/#{name}/bin/beanstalkd", "test"])
     end
+
+    it "returns nil on macOS", :needs_macos do
+      f = stub_formula do
+        service do
+          run linux: [opt_bin/"beanstalkd", "test"]
+          run_type :immediate
+        end
+      end
+
+      command = f.service.command
+      expect(command).to be_nil
+    end
+
+    it "returns appropriate @run data on Linux", :needs_linux do
+      f = stub_formula do
+        service do
+          run macos: [opt_bin/"beanstalkd", "test", "macos"], linux: [opt_bin/"beanstalkd", "test", "linux"]
+          run_type :immediate
+        end
+      end
+
+      command = f.service.command
+      expect(command).to eq(["#{HOMEBREW_PREFIX}/opt/#{name}/bin/beanstalkd", "test", "linux"])
+    end
+
+    it "returns appropriate @run data on macOS", :needs_macos do
+      f = stub_formula do
+        service do
+          run macos: [opt_bin/"beanstalkd", "test", "macos"], linux: [opt_bin/"beanstalkd", "test", "linux"]
+          run_type :immediate
+        end
+      end
+
+      command = f.service.command
+      expect(command).to eq(["#{HOMEBREW_PREFIX}/opt/#{name}/bin/beanstalkd", "test", "macos"])
+    end
+  end
+
+  describe "#to_hash" do
+    let(:serialized_hash) do
+      {
+        environment_variables: {
+          PATH: "$HOMEBREW_PREFIX/bin:$HOMEBREW_PREFIX/sbin:/usr/bin:/bin:/usr/sbin:/sbin",
+        },
+        run:                   [Pathname("$HOMEBREW_PREFIX/opt/formula_name/bin/beanstalkd"), "test"],
+        run_type:              :immediate,
+        working_dir:           "/$HOME",
+        cron:                  "0 0 * * 0",
+        sockets:               "tcp://0.0.0.0:80",
+      }
+    end
+
+    # NOTE: The calls to `Formula.generating_hash!` and `Formula.generated_hash!`
+    #       are not idempotent so they can only be used in one test.
+    it "replaces local paths with placeholders" do
+      f = stub_formula do
+        service do
+          run [opt_bin/"beanstalkd", "test"]
+          environment_variables PATH: std_service_path_env
+          working_dir Dir.home
+          cron "@weekly"
+          sockets "tcp://0.0.0.0:80"
+        end
+      end
+
+      Formula.generating_hash!
+      expect(f.service.to_hash).to eq(serialized_hash)
+      Formula.generated_hash!
+    end
+  end
+
+  describe ".from_hash" do
+    let(:serialized_hash) do
+      {
+        "name"                  => {
+          "linux" => "custom.systemd.name",
+          "macos" => "custom.launchd.name",
+        },
+        "environment_variables" => {
+          "PATH" => "$HOMEBREW_PREFIX/bin:$HOMEBREW_PREFIX/sbin:/usr/bin:/bin:/usr/sbin:/sbin",
+        },
+        "run"                   => ["$HOMEBREW_PREFIX/opt/formula_name/bin/beanstalkd", "test"],
+        "run_type"              => "immediate",
+        "working_dir"           => HOMEBREW_HOME_PLACEHOLDER,
+        "keep_alive"            => { "successful_exit" => false },
+      }
+    end
+
+    let(:deserialized_hash) do
+      {
+        name:                  {
+          linux: "custom.systemd.name",
+          macos: "custom.launchd.name",
+        },
+        environment_variables: {
+          PATH: "#{HOMEBREW_PREFIX}/bin:#{HOMEBREW_PREFIX}/sbin:/usr/bin:/bin:/usr/sbin:/sbin",
+        },
+        run:                   ["#{HOMEBREW_PREFIX}/opt/formula_name/bin/beanstalkd", "test"],
+        run_type:              :immediate,
+        working_dir:           Dir.home,
+        keep_alive:            { successful_exit: false },
+      }
+    end
+
+    it "replaces placeholders with local paths" do
+      expect(described_class.from_hash(serialized_hash)).to eq(deserialized_hash)
+    end
+
+    describe "run command" do
+      it "handles String argument correctly" do
+        expect(described_class.from_hash({
+          "run" => "$HOMEBREW_PREFIX/opt/formula_name/bin/beanstalkd",
+        })).to eq({
+          run: "#{HOMEBREW_PREFIX}/opt/formula_name/bin/beanstalkd",
+        })
+      end
+
+      it "handles Array argument correctly" do
+        expect(described_class.from_hash({
+          "run" => ["$HOMEBREW_PREFIX/opt/formula_name/bin/beanstalkd", "--option"],
+        })).to eq({
+          run: ["#{HOMEBREW_PREFIX}/opt/formula_name/bin/beanstalkd", "--option"],
+        })
+      end
+
+      it "handles Hash argument correctly" do
+        expect(described_class.from_hash({
+          "run" => {
+            "linux" => "$HOMEBREW_PREFIX/opt/formula_name/bin/beanstalkd",
+            "macos" => ["$HOMEBREW_PREFIX/opt/formula_name/bin/beanstalkd", "--option"],
+          },
+        })).to eq({
+          run: {
+            linux: "#{HOMEBREW_PREFIX}/opt/formula_name/bin/beanstalkd",
+            macos: ["#{HOMEBREW_PREFIX}/opt/formula_name/bin/beanstalkd", "--option"],
+          },
+        })
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/test/settings_spec.rb b/Library/Homebrew/test/settings_spec.rb
index 8df4063fc2096..a1a2a409fac03 100644
--- a/Library/Homebrew/test/settings_spec.rb
+++ b/Library/Homebrew/test/settings_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "settings"
 
-describe Homebrew::Settings do
+RSpec.describe Homebrew::Settings do
   before do
     HOMEBREW_REPOSITORY.cd do
       system "git", "init"
@@ -51,7 +50,7 @@ def setup_setting
     end
 
     it "returns if the repo doesn't have a configuration file" do
-      expect { described_class.write("foo", repo: HOMEBREW_REPOSITORY/"bar") }.not_to raise_error
+      expect { described_class.write("foo", false, repo: HOMEBREW_REPOSITORY/"bar") }.not_to raise_error
     end
   end
 
diff --git a/Library/Homebrew/test/simulate_system_spec.rb b/Library/Homebrew/test/simulate_system_spec.rb
new file mode 100644
index 0000000000000..c0856fe39789f
--- /dev/null
+++ b/Library/Homebrew/test/simulate_system_spec.rb
@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "settings"
+
+RSpec.describe Homebrew::SimulateSystem do
+  after do
+    described_class.clear
+  end
+
+  describe "::simulating_or_running_on_macos?" do
+    it "returns true on macOS", :needs_macos do
+      described_class.clear
+      expect(described_class.simulating_or_running_on_macos?).to be true
+    end
+
+    it "returns false on Linux", :needs_linux do
+      described_class.clear
+      expect(described_class.simulating_or_running_on_macos?).to be false
+    end
+
+    it "returns false on macOS when simulating Linux", :needs_macos do
+      described_class.clear
+      described_class.os = :linux
+      expect(described_class.simulating_or_running_on_macos?).to be false
+    end
+
+    it "returns true on Linux when simulating a generic macOS version", :needs_linux do
+      described_class.clear
+      described_class.os = :macos
+      expect(described_class.simulating_or_running_on_macos?).to be true
+    end
+
+    it "returns true on Linux when simulating a specific macOS version", :needs_linux do
+      described_class.clear
+      described_class.os = :monterey
+      expect(described_class.simulating_or_running_on_macos?).to be true
+    end
+
+    it "returns true on Linux with HOMEBREW_SIMULATE_MACOS_ON_LINUX", :needs_linux do
+      described_class.clear
+      ENV["HOMEBREW_SIMULATE_MACOS_ON_LINUX"] = "1"
+      expect(described_class.simulating_or_running_on_macos?).to be true
+    end
+  end
+
+  describe "::simulating_or_running_on_linux?" do
+    it "returns true on Linux", :needs_linux do
+      described_class.clear
+      expect(described_class.simulating_or_running_on_linux?).to be true
+    end
+
+    it "returns false on macOS", :needs_macos do
+      described_class.clear
+      expect(described_class.simulating_or_running_on_linux?).to be false
+    end
+
+    it "returns true on macOS when simulating Linux", :needs_macos do
+      described_class.clear
+      described_class.os = :linux
+      expect(described_class.simulating_or_running_on_linux?).to be true
+    end
+
+    it "returns false on Linux when simulating a generic macOS version", :needs_linux do
+      described_class.clear
+      described_class.os = :macos
+      expect(described_class.simulating_or_running_on_linux?).to be false
+    end
+
+    it "returns false on Linux when simulating a specific macOS version", :needs_linux do
+      described_class.clear
+      described_class.os = :monterey
+      expect(described_class.simulating_or_running_on_linux?).to be false
+    end
+
+    it "returns false on Linux with HOMEBREW_SIMULATE_MACOS_ON_LINUX", :needs_linux do
+      described_class.clear
+      ENV["HOMEBREW_SIMULATE_MACOS_ON_LINUX"] = "1"
+      expect(described_class.simulating_or_running_on_linux?).to be false
+    end
+  end
+
+  describe "::current_arch" do
+    it "returns the current architecture" do
+      described_class.clear
+      expect(described_class.current_arch).to eq Hardware::CPU.type
+    end
+
+    it "returns the simulated architecture" do
+      described_class.clear
+      simulated_arch = if Hardware::CPU.arm?
+        :intel
+      else
+        :arm
+      end
+      described_class.arch = simulated_arch
+      expect(described_class.current_arch).to eq simulated_arch
+    end
+  end
+
+  describe "::current_os" do
+    it "returns the current macOS version on macOS", :needs_macos do
+      described_class.clear
+      expect(described_class.current_os).to eq MacOS.version.to_sym
+    end
+
+    it "returns `:linux` on Linux", :needs_linux do
+      described_class.clear
+      expect(described_class.current_os).to eq :linux
+    end
+
+    it "returns `:linux` when simulating Linux on macOS", :needs_macos do
+      described_class.clear
+      described_class.os = :linux
+      expect(described_class.current_os).to eq :linux
+    end
+
+    it "returns `:macos` when simulating a generic macOS version on Linux", :needs_linux do
+      described_class.clear
+      described_class.os = :macos
+      expect(described_class.current_os).to eq :macos
+    end
+
+    it "returns `:macos` when simulating a specific macOS version on Linux", :needs_linux do
+      described_class.clear
+      described_class.os = :monterey
+      expect(described_class.current_os).to eq :monterey
+    end
+
+    it "returns the current macOS version on macOS with HOMEBREW_SIMULATE_MACOS_ON_LINUX", :needs_macos do
+      described_class.clear
+      ENV["HOMEBREW_SIMULATE_MACOS_ON_LINUX"] = "1"
+      expect(described_class.current_os).to eq MacOS.version.to_sym
+    end
+
+    it "returns `:macos` on Linux with HOMEBREW_SIMULATE_MACOS_ON_LINUX", :needs_linux do
+      described_class.clear
+      ENV["HOMEBREW_SIMULATE_MACOS_ON_LINUX"] = "1"
+      expect(described_class.current_os).to eq :macos
+    end
+  end
+end
diff --git a/Library/Homebrew/test/software_spec/bottle_spec.rb b/Library/Homebrew/test/software_spec/bottle_spec.rb
index 08910f8a960fa..e6d8d9928a68a 100644
--- a/Library/Homebrew/test/software_spec/bottle_spec.rb
+++ b/Library/Homebrew/test/software_spec/bottle_spec.rb
@@ -1,63 +1,17 @@
-# typed: false
 # frozen_string_literal: true
 
 require "software_spec"
+require "test/support/fixtures/testball_bottle"
 
-describe BottleSpecification do
-  subject(:bottle_spec) { described_class.new }
+RSpec.describe Bottle do
+  describe "#filename" do
+    it "renders the bottle filename" do
+      bottle_spec = BottleSpecification.new
+      bottle_spec.sha256(arm64_big_sur: "deadbeef" * 8)
+      tag = Utils::Bottles::Tag.from_symbol :arm64_big_sur
+      bottle = described_class.new(TestballBottle.new, bottle_spec, tag)
 
-  describe "#sha256" do
-    it "works without cellar" do
-      checksums = {
-        arm64_big_sur: "deadbeef" * 8,
-        big_sur:       "faceb00c" * 8,
-        catalina:      "baadf00d" * 8,
-        mojave:        "8badf00d" * 8,
-      }
-
-      checksums.each_pair do |cat, digest|
-        bottle_spec.sha256(cat => digest)
-        tag_spec = bottle_spec.tag_specification_for(Utils::Bottles::Tag.from_symbol(cat))
-        expect(Checksum.new(digest)).to eq(tag_spec.checksum)
-      end
-    end
-
-    it "works with cellar" do
-      checksums = [
-        { cellar: :any_skip_relocation, tag: :arm64_big_sur,  digest: "deadbeef" * 8 },
-        { cellar: :any, tag: :big_sur, digest: "faceb00c" * 8 },
-        { cellar: "/usr/local/Cellar", tag: :catalina, digest: "baadf00d" * 8 },
-        { cellar: Homebrew::DEFAULT_CELLAR, tag: :mojave, digest: "8badf00d" * 8 },
-      ]
-
-      checksums.each do |checksum|
-        bottle_spec.sha256(cellar: checksum[:cellar], checksum[:tag] => checksum[:digest])
-        tag_spec = bottle_spec.tag_specification_for(Utils::Bottles::Tag.from_symbol(checksum[:tag]))
-        expect(Checksum.new(checksum[:digest])).to eq(tag_spec.checksum)
-        expect(checksum[:tag]).to eq(tag_spec.tag.to_sym)
-        checksum[:cellar] ||= Homebrew::DEFAULT_CELLAR
-        expect(checksum[:cellar]).to eq(tag_spec.cellar)
-      end
-    end
-  end
-
-  describe "#compatible_locations?" do
-    it "checks if the bottle cellar is relocatable" do
-      expect(bottle_spec.compatible_locations?).to be false
-    end
-  end
-
-  describe "#tag_to_cellar" do
-    it "returns the cellar for a tag" do
-      expect(bottle_spec.tag_to_cellar).to eq Utils::Bottles.tag.default_cellar
-    end
-  end
-
-  %w[root_url rebuild].each do |method|
-    specify "##{method}" do
-      object = Object.new
-      bottle_spec.public_send(method, object)
-      expect(bottle_spec.public_send(method)).to eq(object)
+      expect(bottle.filename.to_s).to eq("testball_bottle--0.1.arm64_big_sur.bottle.tar.gz")
     end
   end
 end
diff --git a/Library/Homebrew/test/software_spec/bottle_specification_spec.rb b/Library/Homebrew/test/software_spec/bottle_specification_spec.rb
new file mode 100644
index 0000000000000..98aa029bcd136
--- /dev/null
+++ b/Library/Homebrew/test/software_spec/bottle_specification_spec.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "software_spec"
+
+RSpec.describe BottleSpecification do
+  subject(:bottle_spec) { described_class.new }
+
+  describe "#sha256" do
+    it "works without cellar" do
+      checksums = {
+        arm64_big_sur: "deadbeef" * 8,
+        big_sur:       "faceb00c" * 8,
+        catalina:      "baadf00d" * 8,
+        mojave:        "8badf00d" * 8,
+      }
+
+      checksums.each_pair do |cat, digest|
+        bottle_spec.sha256(cat => digest)
+        tag_spec = bottle_spec.tag_specification_for(Utils::Bottles::Tag.from_symbol(cat))
+        expect(Checksum.new(digest)).to eq(tag_spec.checksum)
+      end
+    end
+
+    it "works with cellar" do
+      checksums = [
+        { cellar: :any_skip_relocation, tag: :arm64_big_sur,  digest: "deadbeef" * 8 },
+        { cellar: :any, tag: :big_sur, digest: "faceb00c" * 8 },
+        { cellar: "/usr/local/Cellar", tag: :catalina, digest: "baadf00d" * 8 },
+        { cellar: Homebrew::DEFAULT_CELLAR, tag: :mojave, digest: "8badf00d" * 8 },
+      ]
+
+      checksums.each do |checksum|
+        bottle_spec.sha256(cellar: checksum[:cellar], checksum[:tag] => checksum[:digest])
+        tag_spec = bottle_spec.tag_specification_for(Utils::Bottles::Tag.from_symbol(checksum[:tag]))
+        expect(Checksum.new(checksum[:digest])).to eq(tag_spec.checksum)
+        expect(checksum[:tag]).to eq(tag_spec.tag.to_sym)
+        checksum[:cellar] ||= Homebrew::DEFAULT_CELLAR
+        expect(checksum[:cellar]).to eq(tag_spec.cellar)
+      end
+    end
+  end
+
+  describe "#compatible_locations?" do
+    it "checks if the bottle cellar is relocatable" do
+      expect(bottle_spec.compatible_locations?).to be false
+    end
+  end
+
+  describe "#tag_to_cellar" do
+    it "returns the cellar for a tag" do
+      expect(bottle_spec.tag_to_cellar).to eq Utils::Bottles.tag.default_cellar
+    end
+  end
+
+  %w[root_url rebuild].each do |method|
+    specify "##{method}" do
+      object = Object.new
+      bottle_spec.public_send(method, object)
+      expect(bottle_spec.public_send(method)).to eq(object)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/software_spec/head_spec.rb b/Library/Homebrew/test/software_spec/head_spec.rb
index 0f92ba4be665e..eee9e59676924 100644
--- a/Library/Homebrew/test/software_spec/head_spec.rb
+++ b/Library/Homebrew/test/software_spec/head_spec.rb
@@ -1,13 +1,12 @@
-# typed: false
 # frozen_string_literal: true
 
 require "software_spec"
 
-describe HeadSoftwareSpec do
+RSpec.describe HeadSoftwareSpec do
   subject(:head_spec) { described_class.new }
 
   specify "#version" do
-    expect(head_spec.version).to eq(Version.create("HEAD"))
+    expect(head_spec.version).to eq(Version.new("HEAD"))
   end
 
   specify "#verify_download_integrity" do
diff --git a/Library/Homebrew/test/software_spec_spec.rb b/Library/Homebrew/test/software_spec_spec.rb
index 284cf2211a7e4..37770dac9eea7 100644
--- a/Library/Homebrew/test/software_spec_spec.rb
+++ b/Library/Homebrew/test/software_spec_spec.rb
@@ -1,15 +1,14 @@
-# typed: false
 # frozen_string_literal: true
 
 require "software_spec"
 
-describe SoftwareSpec do
+RSpec.describe SoftwareSpec do
   alias_matcher :have_defined_resource, :be_resource_defined
   alias_matcher :have_defined_option, :be_option_defined
 
   subject(:spec) { described_class.new }
 
-  let(:owner) { double(name: "some_name", full_name: "some_name", tap: "homebrew/core") }
+  let(:owner) { instance_double(Cask::Cask, name: "some_name", full_name: "some_name", tap: "homebrew/core") }
 
   describe "#resource" do
     it "defines a resource" do
@@ -35,16 +34,16 @@
 
     it "raises an error when duplicate resources are defined" do
       spec.resource("foo") { url "foo-1.0" }
-      expect {
+      expect do
         spec.resource("foo") { url "foo-1.0" }
-      }.to raise_error(DuplicateResourceError)
+      end.to raise_error(DuplicateResourceError)
     end
 
     it "raises an error when accessing missing resources" do
       spec.owner = owner
-      expect {
+      expect do
         spec.resource("foo")
-      }.to raise_error(ResourceMissingError)
+      end.to raise_error(ResourceMissingError)
     end
   end
 
@@ -67,15 +66,15 @@
     end
 
     it "raises an error when it begins with dashes" do
-      expect {
+      expect do
         spec.option("--foo")
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "raises an error when name is empty" do
-      expect {
+      expect do
         spec.option("")
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "special cases the cxx11 option" do
@@ -112,9 +111,9 @@
     end
 
     it "raises an error when empty" do
-      expect {
+      expect do
         spec.deprecated_option({})
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
   end
 
@@ -135,27 +134,130 @@
     end
   end
 
-  describe "#uses_from_macos" do
-    it "allows specifying dependencies", :needs_linux do
-      spec.uses_from_macos("foo")
+  describe "#uses_from_macos", :needs_linux do
+    context "when running on Linux", :needs_linux do
+      it "allows specifying dependencies" do
+        spec.uses_from_macos("foo")
 
-      expect(spec.deps.first.name).to eq("foo")
-    end
+        expect(spec.declared_deps).not_to be_empty
+        expect(spec.deps).not_to be_empty
+        expect(spec.deps.first.name).to eq("foo")
+        expect(spec.deps.first).to be_uses_from_macos
+        expect(spec.deps.first).not_to be_use_macos_install
+      end
 
-    it "works with tags", :needs_linux do
-      spec.uses_from_macos("foo" => :build)
+      it "works with tags" do
+        spec.uses_from_macos("foo" => :build)
 
-      expect(spec.deps.first.name).to eq("foo")
-      expect(spec.deps.first.tags).to include(:build)
+        expect(spec.declared_deps).not_to be_empty
+        expect(spec.deps).not_to be_empty
+        expect(spec.deps.first.name).to eq("foo")
+        expect(spec.deps.first.tags).to include(:build)
+        expect(spec.deps.first).to be_uses_from_macos
+        expect(spec.deps.first).not_to be_use_macos_install
+      end
+
+      it "handles dependencies with HOMEBREW_SIMULATE_MACOS_ON_LINUX" do
+        ENV["HOMEBREW_SIMULATE_MACOS_ON_LINUX"] = "1"
+        spec.uses_from_macos("foo")
+
+        expect(spec.deps).to be_empty
+        expect(spec.declared_deps.first.name).to eq("foo")
+        expect(spec.declared_deps.first.tags).to be_empty
+        expect(spec.declared_deps.first).to be_uses_from_macos
+        expect(spec.declared_deps.first).to be_use_macos_install
+      end
+
+      it "handles dependencies with tags with HOMEBREW_SIMULATE_MACOS_ON_LINUX" do
+        ENV["HOMEBREW_SIMULATE_MACOS_ON_LINUX"] = "1"
+        spec.uses_from_macos("foo" => :build)
+
+        expect(spec.deps).to be_empty
+        expect(spec.declared_deps.first.name).to eq("foo")
+        expect(spec.declared_deps.first.tags).to include(:build)
+        expect(spec.declared_deps.first).to be_uses_from_macos
+        expect(spec.declared_deps.first).to be_use_macos_install
+      end
+
+      it "ignores OS version specifications" do
+        spec.uses_from_macos("foo", since: :mojave)
+        spec.uses_from_macos("bar" => :build, :since => :mojave)
+
+        expect(spec.deps.count).to eq 2
+        expect(spec.deps.first.name).to eq("foo")
+        expect(spec.deps.first).to be_uses_from_macos
+        expect(spec.deps.first).not_to be_use_macos_install
+        expect(spec.deps.last.name).to eq("bar")
+        expect(spec.deps.last.tags).to include(:build)
+        expect(spec.deps.last).to be_uses_from_macos
+        expect(spec.deps.last).not_to be_use_macos_install
+        expect(spec.declared_deps.count).to eq 2
+      end
     end
 
-    it "ignores OS version specifications", :needs_linux do
-      spec.uses_from_macos("foo", since: :mojave)
-      spec.uses_from_macos("bar" => :build, :since => :mojave)
+    context "when running on macOS", :needs_macos do
+      before do
+        allow(OS).to receive(:mac?).and_return(true)
+        allow(OS::Mac).to receive(:version).and_return(MacOSVersion.from_symbol(:sierra))
+      end
+
+      it "adds a macOS dependency if the OS version meets requirements" do
+        spec.uses_from_macos("foo", since: :el_capitan)
 
-      expect(spec.deps.first.name).to eq("foo")
-      expect(spec.deps.last.name).to eq("bar")
-      expect(spec.deps.last.tags).to include(:build)
+        expect(spec.deps).to be_empty
+        expect(spec.declared_deps).not_to be_empty
+        expect(spec.declared_deps.first).to be_uses_from_macos
+        expect(spec.declared_deps.first).to be_use_macos_install
+      end
+
+      it "adds a macOS dependency if the OS version doesn't meet requirements" do
+        spec.uses_from_macos("foo", since: :high_sierra)
+
+        expect(spec.declared_deps).not_to be_empty
+        expect(spec.deps).not_to be_empty
+        expect(spec.deps.first.name).to eq("foo")
+        expect(spec.deps.first).to be_uses_from_macos
+        expect(spec.deps.first).not_to be_use_macos_install
+      end
+
+      it "works with tags" do
+        spec.uses_from_macos("foo" => :build, :since => :high_sierra)
+
+        expect(spec.declared_deps).not_to be_empty
+        expect(spec.deps).not_to be_empty
+
+        dep = spec.deps.first
+
+        expect(dep.name).to eq("foo")
+        expect(dep.tags).to include(:build)
+        expect(dep.first).to be_uses_from_macos
+        expect(dep.first).not_to be_use_macos_install
+      end
+
+      it "doesn't add an effective dependency if no OS version is specified" do
+        spec.uses_from_macos("foo")
+        spec.uses_from_macos("bar" => :build)
+
+        expect(spec.deps).to be_empty
+        expect(spec.declared_deps).not_to be_empty
+
+        dep = spec.declared_deps.first
+        expect(dep.name).to eq("foo")
+        expect(dep.first).to be_uses_from_macos
+        expect(dep.first).to be_use_macos_install
+
+        dep = spec.declared_deps.last
+        expect(dep.name).to eq("bar")
+        expect(dep.tags).to include(:build)
+        expect(dep.first).to be_uses_from_macos
+        expect(dep.first).to be_use_macos_install
+      end
+
+      it "raises an error if passing invalid OS versions" do
+        expect do
+          spec.uses_from_macos("foo", since: :bar)
+        end.to raise_error(MacOSVersion::Error, "unknown or unsupported macOS version: :bar")
+      end
     end
   end
 
diff --git a/Library/Homebrew/test/sorbet/tapioca/compilers/args_spec.rb b/Library/Homebrew/test/sorbet/tapioca/compilers/args_spec.rb
new file mode 100644
index 0000000000000..ee50a912a1950
--- /dev/null
+++ b/Library/Homebrew/test/sorbet/tapioca/compilers/args_spec.rb
@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "tapioca/dsl"
+require "sorbet/tapioca/compilers/args"
+
+RSpec.describe Tapioca::Compilers::Args do
+  let(:compiler) { described_class.new(Tapioca::Dsl::Pipeline.new(requested_constants: []), RBI::Tree.new, Homebrew) }
+  let(:list_parser) do
+    require "cmd/list"
+    Homebrew::Cmd::List.parser
+  end
+
+  # Good testing candidate because it has multiple for each of `switch`, `flag` and `comma_array` args:
+  let(:update_python_resources_parser) do
+    require "dev-cmd/update-python-resources"
+    Homebrew::DevCmd::UpdatePythonResources.parser
+  end
+
+  describe "#args_table" do
+    it "returns a mapping of list args to default values" do
+      expect(compiler.args_table(list_parser).keys).to contain_exactly(
+        :"1?", :built_from_source?, :cask?, :casks?, :d?, :debug?,
+        :formula?, :formulae?, :full_name?, :h?, :help?,
+        :installed_as_dependency?, :installed_on_request?, :l?,
+        :multiple?, :pinned?, :poured_from_bottle?, :q?, :quiet?,
+        :r?, :t?, :v?, :verbose?, :versions?
+      )
+    end
+
+    it "returns a mapping of update-python-resources args to default values" do
+      expect(compiler.args_table(update_python_resources_parser)).to eq({
+        d?:                        false,
+        debug?:                    false,
+        exclude_packages:          nil,
+        extra_packages:            nil,
+        h?:                        false,
+        help?:                     false,
+        ignore_non_pypi_packages?: false,
+        install_dependencies?:     false,
+        p?:                        false,
+        package_name:              nil,
+        print_only?:               false,
+        q?:                        false,
+        quiet?:                    false,
+        s?:                        false,
+        silent?:                   false,
+        v?:                        false,
+        verbose?:                  false,
+        version:                   nil,
+      })
+    end
+  end
+
+  describe "#comma_arrays" do
+    it "returns an empty list when there are no comma_array args" do
+      expect(compiler.comma_arrays(list_parser)).to eq([])
+    end
+
+    it "returns the comma_array args when they exist" do
+      expect(compiler.comma_arrays(update_python_resources_parser)).to eq([:extra_packages, :exclude_packages])
+    end
+  end
+
+  describe "#get_return_type" do
+    let(:comma_arrays) { compiler.comma_arrays(update_python_resources_parser) }
+
+    it "returns the correct type for switches" do
+      expect(compiler.get_return_type(:silent?, false, comma_arrays)).to eq("T::Boolean")
+    end
+
+    it "returns the correct type for flags" do
+      expect(compiler.get_return_type(:package_name, nil, comma_arrays)).to eq("T.nilable(String)")
+    end
+
+    it "returns the correct type for comma_arrays" do
+      expect(compiler.get_return_type(:extra_packages, nil, comma_arrays)).to eq("T.nilable(T::Array[String])")
+    end
+  end
+end
diff --git a/Library/Homebrew/test/sorbet/tapioca/config_spec.rb b/Library/Homebrew/test/sorbet/tapioca/config_spec.rb
new file mode 100644
index 0000000000000..bb37b78ad8b30
--- /dev/null
+++ b/Library/Homebrew/test/sorbet/tapioca/config_spec.rb
@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "bundler"
+require "yaml"
+
+RSpec.describe "Tapioca Config", type: :system do
+  let(:config) { YAML.load_file(File.join(__dir__, "../../../sorbet/tapioca/config.yml")) }
+
+  it "only excludes dependencies" do
+    exclusions = config.dig("gem", "exclude")
+    dependencies = Bundler::Definition.build(
+      HOMEBREW_LIBRARY_PATH/"Gemfile",
+      HOMEBREW_LIBRARY_PATH/"Gemfile.lock",
+      false,
+    ).resolve.names
+    expect(exclusions - dependencies).to be_empty
+  end
+end
diff --git a/Library/Homebrew/test/spec_helper.rb b/Library/Homebrew/test/spec_helper.rb
index 2aef66d976f5e..831d8f7404071 100644
--- a/Library/Homebrew/test/spec_helper.rb
+++ b/Library/Homebrew/test/spec_helper.rb
@@ -1,4 +1,3 @@
-# typed: false
 # frozen_string_literal: true
 
 if ENV["HOMEBREW_TESTS_COVERAGE"]
@@ -11,40 +10,46 @@
   ]
   SimpleCov.formatters = SimpleCov::Formatter::MultiFormatter.new(formatters)
 
-  if RUBY_PLATFORM[/darwin/] && ENV["TEST_ENV_NUMBER"]
+  # Needed for outputting coverage reporting only once for parallel_tests.
+  # Otherwise, "Coverage report generated" will get spammed for each process.
+  if ENV["TEST_ENV_NUMBER"]
     SimpleCov.at_exit do
       result = SimpleCov.result
-      result.format! if ParallelTests.number_of_running_processes <= 1
+      # `SimpleCov.result` calls `ParallelTests.wait_for_other_processes_to_finish`
+      # internally for you on the last process.
+      result.format! if ParallelTests.last_process?
     end
   end
 end
 
+require_relative "../standalone"
 require_relative "../warnings"
 
 Warnings.ignore :parser_syntax do
   require "rubocop"
 end
 
-require "rspec/its"
 require "rspec/github"
-require "rspec/wait"
 require "rspec/retry"
 require "rspec/sorbet"
 require "rubocop/rspec/support"
 require "find"
-require "byebug"
 require "timeout"
 
-$LOAD_PATH.push(File.expand_path("#{ENV.fetch("HOMEBREW_LIBRARY")}/Homebrew/test/support/lib"))
+$LOAD_PATH.unshift(File.expand_path("#{ENV.fetch("HOMEBREW_LIBRARY")}/Homebrew/test/support/lib"))
+
+require_relative "support/extend/cachable"
 
 require_relative "../global"
 
-require "test/support/no_seed_progress_formatter"
+require "debug" if ENV["HOMEBREW_DEBUG"]
+
+require "test/support/quiet_progress_formatter"
 require "test/support/helper/cask"
+require "test/support/helper/files"
 require "test/support/helper/fixtures"
 require "test/support/helper/formula"
 require "test/support/helper/mktmpdir"
-require "test/support/helper/output_as_tty"
 
 require "test/support/helper/spec/shared_context/homebrew_cask" if OS.mac?
 require "test/support/helper/spec/shared_context/integration_test"
@@ -68,11 +73,17 @@
   config.order = :random
 
   config.raise_errors_for_deprecations!
+  config.warnings = true
+  config.disable_monkey_patching!
 
   config.filter_run_when_matching :focus
 
   config.silence_filter_announcements = true if ENV["TEST_ENV_NUMBER"]
 
+  # Improve backtrace formatting
+  config.filter_gems_from_backtrace "rspec-retry", "sorbet-runtime"
+  config.backtrace_exclusion_patterns << %r{test/spec_helper\.rb}
+
   config.expect_with :rspec do |c|
     c.max_formatted_output_length = 200
   end
@@ -80,16 +91,28 @@
   # Use rspec-retry to handle flaky tests.
   config.default_sleep_interval = 1
 
-  # Don't make retries as noisy unless in CI.
-  if ENV["CI"]
-    config.verbose_retry = true
-    config.display_try_failure_messages = true
-  end
-
   # Don't want the nicer default retry behaviour when using BuildPulse to
   # identify flaky tests.
   config.default_retry_count = 2 unless ENV["BUILDPULSE"]
 
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
   # Increase timeouts for integration tests (as we expect them to take longer).
   config.around(:each, :integration_test) do |example|
     example.metadata[:timeout] ||= 120
@@ -111,19 +134,12 @@
   # Never truncate output objects.
   RSpec::Support::ObjectFormatter.default_instance.max_formatted_output_length = nil
 
-  config.include(FileUtils)
-
   config.include(RuboCop::RSpec::ExpectOffense)
 
   config.include(Test::Helper::Cask)
   config.include(Test::Helper::Fixtures)
   config.include(Test::Helper::Formula)
   config.include(Test::Helper::MkTmpDir)
-  config.include(Test::Helper::OutputAsTTY)
-
-  config.before(:each, :needs_compat) do
-    skip "Requires the compatibility layer." if ENV["HOMEBREW_NO_COMPAT"]
-  end
 
   config.before(:each, :needs_linux) do
     skip "Not running on Linux." unless OS.linux?
@@ -133,18 +149,40 @@
     skip "Not running on macOS." unless OS.mac?
   end
 
+  config.before(:each, :needs_ci) do
+    skip "Not running on CI." unless ENV["CI"]
+  end
+
   config.before(:each, :needs_java) do
     skip "Java is not installed." unless which("java")
   end
 
   config.before(:each, :needs_python) do
-    skip "Python is not installed." unless which("python")
+    skip "Python is not installed." if !which("python3") && !which("python")
   end
 
   config.before(:each, :needs_network) do
     skip "Requires network connection." unless ENV["HOMEBREW_TEST_ONLINE"]
   end
 
+  config.before(:each, :needs_homebrew_core) do
+    core_tap_path = "#{ENV.fetch("HOMEBREW_LIBRARY")}/Taps/homebrew/homebrew-core"
+    skip "Requires homebrew/core to be tapped." unless Dir.exist?(core_tap_path)
+  end
+
+  config.before do |example|
+    next if example.metadata.key?(:needs_network)
+    next if example.metadata.key?(:needs_utils_curl)
+
+    allow(Utils::Curl).to receive(:curl_executable).and_raise(<<~ERROR)
+      Unexpected call to Utils::Curl.curl_executable without setting :needs_network or :needs_utils_curl.
+    ERROR
+  end
+
+  config.before(:each, :no_api) do
+    ENV["HOMEBREW_NO_INSTALL_FROM_API"] = "1"
+  end
+
   config.before(:each, :needs_svn) do
     svn_shim = HOMEBREW_SHIMS_PATH/"shared/svn"
     skip "Subversion is not installed." unless quiet_system svn_shim, "--version"
@@ -171,7 +209,7 @@
 
   config.before(:each, :needs_homebrew_curl) do
     ENV["HOMEBREW_CURL"] = HOMEBREW_BREWED_CURL_PATH
-    skip "A `curl` with TLS 1.3 support is required." unless curl_supports_tls13?
+    skip "A `curl` with TLS 1.3 support is required." unless Utils::Curl.curl_supports_tls13?
   rescue FormulaUnavailableError
     skip "No `curl` formula is available."
   end
@@ -181,25 +219,10 @@
   end
 
   config.around do |example|
-    def find_files
-      return [] unless File.exist?(TEST_TMPDIR)
-
-      Find.find(TEST_TMPDIR)
-          .reject { |f| File.basename(f) == ".DS_Store" }
-          .reject { |f| TEST_DIRECTORIES.include?(Pathname(f)) }
-          .map { |f| f.sub(TEST_TMPDIR, "") }
-    end
-
     Homebrew.raise_deprecation_exceptions = true
 
-    Formulary.clear_cache
-    Tap.clear_cache
-    DependencyCollector.clear_cache
-    Formula.clear_cache
-    Keg.clear_cache
-    Tab.clear_cache
-    Dependency.clear_cache
-    Requirement.clear_cache
+    Tap.installed.each(&:clear_cache)
+    Cachable::Registry.clear_all_caches
     FormulaInstaller.clear_attempted
     FormulaInstaller.clear_installed
     FormulaInstaller.clear_fetched
@@ -209,7 +232,7 @@ def find_files
 
     @__homebrew_failed = Homebrew.failed?
 
-    @__files_before_test = find_files
+    @__files_before_test = Test::Helper::Files.find_files
 
     @__env = ENV.to_hash # dup doesn't work on ENV
 
@@ -218,11 +241,14 @@ def find_files
     @__stdin = $stdin.clone
 
     begin
-      if (example.metadata.keys & [:focus, :byebug]).empty? && !ENV.key?("HOMEBREW_VERBOSE_TESTS")
+      if example.metadata.keys.exclude?(:focus) && !ENV.key?("HOMEBREW_VERBOSE_TESTS")
         $stdout.reopen(File::NULL)
         $stderr.reopen(File::NULL)
+        $stdin.reopen(File::NULL)
+      else
+        # don't retry when focusing
+        config.default_retry_count = 0
       end
-      $stdin.reopen(File::NULL)
 
       begin
         timeout = example.metadata.fetch(:timeout, 60)
@@ -236,6 +262,7 @@ def find_files
       example.example.set_exception(e)
     ensure
       ENV.replace(@__env)
+      Context.current = Context::ContextStruct.new
 
       $stdout.reopen(@__stdout)
       $stderr.reopen(@__stderr)
@@ -244,18 +271,12 @@ def find_files
       @__stderr.close
       @__stdin.close
 
-      Formulary.clear_cache
-      Tap.clear_cache
-      DependencyCollector.clear_cache
-      Formula.clear_cache
-      Keg.clear_cache
-      Tab.clear_cache
-      Dependency.clear_cache
-      Requirement.clear_cache
+      Tap.all.each(&:clear_cache)
+      Cachable::Registry.clear_all_caches
 
       FileUtils.rm_rf [
         *TEST_DIRECTORIES,
-        *Keg::MUST_EXIST_SUBDIRECTORIES,
+        *Keg.must_exist_subdirectories,
         HOMEBREW_LINKED_KEGS,
         HOMEBREW_PINNED_KEGS,
         HOMEBREW_PREFIX/"var",
@@ -279,7 +300,7 @@ def find_files
         *Pathname.glob("#{HOMEBREW_CELLAR}/*/"),
       ]
 
-      files_after_test = find_files
+      files_after_test = Test::Helper::Files.find_files
 
       diff = Set.new(@__files_before_test) ^ Set.new(files_after_test)
       expect(diff).to be_empty, <<~EOS
@@ -293,18 +314,7 @@ def find_files
 end
 
 RSpec::Matchers.define_negated_matcher :not_to_output, :output
-RSpec::Matchers.define_negated_matcher :not_raise_error, :raise_error
 RSpec::Matchers.alias_matcher :have_failed, :be_failed
-RSpec::Matchers.alias_matcher :a_string_containing, :include
-
-RSpec::Matchers.define :a_json_string do
-  match do |actual|
-    JSON.parse(actual)
-    true
-  rescue JSON::ParserError
-    false
-  end
-end
 
 # Match consecutive elements in an array.
 RSpec::Matchers.define :array_including_cons do |*cons|
diff --git a/Library/Homebrew/test/style_spec.rb b/Library/Homebrew/test/style_spec.rb
index f536a38cc7def..511f04dcdcffe 100644
--- a/Library/Homebrew/test/style_spec.rb
+++ b/Library/Homebrew/test/style_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "style"
 
-describe Homebrew::Style do
+RSpec.describe Homebrew::Style do
   around do |example|
     FileUtils.ln_s HOMEBREW_LIBRARY_PATH, HOMEBREW_LIBRARY/"Homebrew"
     FileUtils.ln_s HOMEBREW_LIBRARY_PATH.parent/".rubocop.yml", HOMEBREW_LIBRARY/".rubocop.yml"
@@ -24,7 +23,7 @@
     it "returns offenses when RuboCop reports offenses" do
       formula = dir/"my-formula.rb"
 
-      formula.write <<~'EOS'
+      formula.write <<~EOS
         class MyFormula < Formula
 
         end
@@ -40,7 +39,7 @@ class MyFormula < Formula
   describe ".check_style_and_print" do
     let(:dir) { mktmpdir }
 
-    it "returns false for conforming file with only audit-level violations" do
+    it "returns true (success) for conforming file with only audit-level violations" do
       # This file is known to use non-rocket hashes and other things that trigger audit,
       # but not regular, cop violations
       target_file = HOMEBREW_LIBRARY_PATH/"utils.rb"
diff --git a/Library/Homebrew/test/support/extend/cachable.rb b/Library/Homebrew/test/support/extend/cachable.rb
new file mode 100644
index 0000000000000..748b0f7ed4003
--- /dev/null
+++ b/Library/Homebrew/test/support/extend/cachable.rb
@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+raise "This needs to be required before Cachable gets loaded normally." if defined?(Cachable)
+
+# Collect all classes that mix in Cachable so that those caches can be cleared in-between tests.
+module Cachable
+  private_class_method def self.included(klass)
+    # It's difficult to backtrack from a singleton class to find the original class
+    # and you can always just extend this module instead for equivalent behavior.
+    raise ArgumentError, "Don't use Cachable with singleton classes" if klass.singleton_class?
+
+    super if defined?(super)
+  end
+
+  private_class_method def self.extended(klass)
+    Registry.class_list << klass
+    # Ignore the `Formula` class that gets inherited from a lot and
+    # that has caches that we don't need to clear on the class level.
+    klass.extend(Inherited) if klass.name != "Formula"
+    super if defined?(super)
+  end
+
+  module Inherited
+    private
+
+    def inherited(klass)
+      # A class might inherit Cachable at the instance level
+      # and in that case we just want to skip registering it.
+      Registry.class_list << klass if klass.respond_to?(:clear_cache)
+      super if defined?(super)
+    end
+  end
+
+  module Registry
+    # A list of all classes that have been loaded into memory that mixin or
+    # inherit `Cachable` at the class or module level.
+    #
+    # NOTE: Classes that inherit from `Formula` are excluded since it's not
+    #       necessary to track and clear individual formula caches.
+    def self.class_list
+      @class_list ||= []
+    end
+
+    # Clear the cache of every class or module that mixes in or inherits
+    # `Cachable` at the class or module level.
+    #
+    # NOTE: Classes that inherit from `Formula` are excluded since it's not
+    #       necessary to track and clear individual formula caches.
+    def self.clear_all_caches
+      class_list.each(&:clear_cache)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.arm64_sequoia.bottle.tar.gz b/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.arm64_sequoia.bottle.tar.gz
new file mode 120000
index 0000000000000..3e989830ba206
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.arm64_sequoia.bottle.tar.gz
@@ -0,0 +1 @@
+testball_bottle-0.1.yosemite.bottle.tar.gz
\ No newline at end of file
diff --git a/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.arm64_sonoma.bottle.tar.gz b/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.arm64_sonoma.bottle.tar.gz
new file mode 120000
index 0000000000000..3e989830ba206
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.arm64_sonoma.bottle.tar.gz
@@ -0,0 +1 @@
+testball_bottle-0.1.yosemite.bottle.tar.gz
\ No newline at end of file
diff --git a/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.arm64_ventura.bottle.tar.gz b/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.arm64_ventura.bottle.tar.gz
new file mode 120000
index 0000000000000..3e989830ba206
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.arm64_ventura.bottle.tar.gz
@@ -0,0 +1 @@
+testball_bottle-0.1.yosemite.bottle.tar.gz
\ No newline at end of file
diff --git a/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.sequoia.bottle.tar.gz b/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.sequoia.bottle.tar.gz
new file mode 120000
index 0000000000000..3e989830ba206
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.sequoia.bottle.tar.gz
@@ -0,0 +1 @@
+testball_bottle-0.1.yosemite.bottle.tar.gz
\ No newline at end of file
diff --git a/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.sonoma.bottle.tar.gz b/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.sonoma.bottle.tar.gz
new file mode 120000
index 0000000000000..3e989830ba206
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.sonoma.bottle.tar.gz
@@ -0,0 +1 @@
+testball_bottle-0.1.yosemite.bottle.tar.gz
\ No newline at end of file
diff --git a/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.yosemite.bottle.tar.gz b/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.yosemite.bottle.tar.gz
index ee5eb8b4b4d53..20706d5869d28 100644
Binary files a/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.yosemite.bottle.tar.gz and b/Library/Homebrew/test/support/fixtures/bottles/testball_bottle-0.1.yosemite.bottle.tar.gz differ
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/arch-arm-only.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/arch-arm-only.rb
new file mode 100644
index 0000000000000..d6bc73d35ed3b
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/arch-arm-only.rb
@@ -0,0 +1,11 @@
+cask "arch-arm-only" do
+  arch arm: "-arm"
+
+  version "1.2.3"
+  sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine#{arch}.zip"
+  homepage "https://brew.sh/"
+
+  app "Caffeine.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/booby-trap.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/booby-trap.rb
deleted file mode 100644
index a720d5300f3f7..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/booby-trap.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-cask "booby-trap" do
-  version "0.0.7"
-
-  url do
-    # to be lazily evaluated
-    raise "Boom"
-  end
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/devmate-with-appcast.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/devmate-with-appcast.rb
deleted file mode 100644
index 5a83a2b1ef165..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/devmate-with-appcast.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-cask "devmate-with-appcast" do
-  version "1.0"
-  sha256 "a69e7357bea014f4c14ac9699274f559086844ffa46563c4619bf1addfd72ad9"
-
-  # dl.devmate.com/com.my.fancyapp was verified as official when first introduced to the cask
-  url "https://dl.devmate.com/com.my.fancyapp/app_#{version}.zip"
-  appcast "https://updates.devmate.com/com.my.fancyapp.app.xml"
-  name "DevMate"
-  homepage "https://www.brew.sh/"
-
-  app "DevMate.app"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/devmate-with-livecheck.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/devmate-with-livecheck.rb
new file mode 100644
index 0000000000000..d2274ea9b76ea
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/devmate-with-livecheck.rb
@@ -0,0 +1,14 @@
+cask "devmate-with-livecheck" do
+  version "1.0"
+  sha256 "a69e7357bea014f4c14ac9699274f559086844ffa46563c4619bf1addfd72ad9"
+
+  url "https://dl.devmate.com/com.my.fancyapp/app_#{version}.zip"
+  name "DevMate"
+  homepage "https://www.brew.sh/"
+
+  livecheck do
+    url "https://updates.devmate.com/com.my.fancyapp.app.xml"
+  end
+
+  app "DevMate.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/devmate-without-appcast.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/devmate-without-appcast.rb
deleted file mode 100644
index fc3f177721e3c..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/devmate-without-appcast.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-cask "devmate-without-appcast" do
-  version "1.0"
-  sha256 "a69e7357bea014f4c14ac9699274f559086844ffa46563c4619bf1addfd72ad9"
-
-  # dl.devmate.com/com.my.fancyapp was verified as official when first introduced to the cask
-  url "https://dl.devmate.com/com.my.fancyapp/app_#{version}.zip"
-  name "DevMate"
-  homepage "https://www.brew.sh/"
-
-  app "DevMate.app"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/devmate-without-livecheck.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/devmate-without-livecheck.rb
new file mode 100644
index 0000000000000..37c845f1f43c2
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/devmate-without-livecheck.rb
@@ -0,0 +1,10 @@
+cask "devmate-without-livecheck" do
+  version "1.0"
+  sha256 "a69e7357bea014f4c14ac9699274f559086844ffa46563c4619bf1addfd72ad9"
+
+  url "https://dl.devmate.com/com.my.fancyapp/app_#{version}.zip"
+  name "DevMate"
+  homepage "https://www.brew.sh/"
+
+  app "DevMate.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/everything.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/everything.rb
new file mode 100644
index 0000000000000..fd8e30cb54d16
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/everything.rb
@@ -0,0 +1,48 @@
+# Used to test cask hash generation.
+cask "everything" do
+  version "1.2.3"
+
+  language "en", default: true do
+    sha256 "c64c05bdc0be845505d6e55e69e696a7f50d40846e76155f0c85d5ff5e7bbb84"
+    "en-US"
+  end
+  language "eo" do
+    sha256 "e8ffa07370a7fb7e1696b04c269e01d3459725965a32facdd54629a95d148908"
+    "eo"
+  end
+
+  url "https://cachefly.everything.app/releases/Everything_#{version}.zip",
+      user_agent: :fake,
+      cookies:    { "ALL" => "1234" }
+  name "Everything"
+  desc "Little bit of everything"
+  homepage "https://www.everything.app/"
+
+  auto_updates true
+  conflicts_with formula: "nothing"
+  depends_on cask: "something"
+  container type: :naked
+
+  app "Everything.app"
+  installer script: {
+    executable:   "~/just/another/path/install.sh",
+    args:         ["--mode=silent"],
+    sudo:         true,
+    print_stderr: false,
+  }
+
+  uninstall launchctl: "com.every.thing.agent",
+            signal:    [
+              ["TERM", "com.every.thing.controller#{version.major}"],
+              ["TERM", "com.every.thing.bin"],
+            ],
+            kext:      "com.every.thing.driver",
+            delete:    "/Library/EverythingHelperTools"
+
+  zap trash: [
+    "~/.everything",
+    "~/Library/Everything",
+  ]
+
+  caveats "Installing everything might take a while..."
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/hockeyapp-with-appcast.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/hockeyapp-with-appcast.rb
deleted file mode 100644
index 05a6aee83ad10..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/hockeyapp-with-appcast.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-cask "hockeyapp-with-appcast" do
-  version "1.0,123"
-  sha256 "a69e7357bea014f4c14ac9699274f559086844ffa46563c4619bf1addfd72ad9"
-
-  # rink.hockeyapp.net/api/2/apps/67503a7926431872c4b6c1549f5bd6b1 was verified as official when first introduced to the cask
-  url "https://rink.hockeyapp.net/api/2/apps/67503a7926431872c4b6c1549f5bd6b1/app_versions/#{version.csv.second}?format=zip"
-  appcast "https://rink.hockeyapp.net/api/2/apps/67503a7926431872c4b6c1549f5bd6b1"
-  name "HockeyApp"
-  homepage "https://www.brew.sh/"
-
-  app "HockeyApp.app"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/hockeyapp-with-livecheck.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/hockeyapp-with-livecheck.rb
new file mode 100644
index 0000000000000..3d718ce2430bd
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/hockeyapp-with-livecheck.rb
@@ -0,0 +1,14 @@
+cask "hockeyapp-with-livecheck" do
+  version "1.0,123"
+  sha256 "a69e7357bea014f4c14ac9699274f559086844ffa46563c4619bf1addfd72ad9"
+
+  url "https://rink.hockeyapp.net/api/2/apps/67503a7926431872c4b6c1549f5bd6b1/app_versions/#{version.csv.second}?format=zip"
+  name "HockeyApp"
+  homepage "https://www.brew.sh/"
+
+  livecheck do
+    url "https://rink.hockeyapp.net/api/2/apps/67503a7926431872c4b6c1549f5bd6b1"
+  end
+
+  app "HockeyApp.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/hockeyapp-without-appcast.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/hockeyapp-without-appcast.rb
deleted file mode 100644
index 179d530fd5972..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/hockeyapp-without-appcast.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-cask "hockeyapp-without-appcast" do
-  version "1.0,123"
-  sha256 "a69e7357bea014f4c14ac9699274f559086844ffa46563c4619bf1addfd72ad9"
-
-  # rink.hockeyapp.net/api/2/apps/67503a7926431872c4b6c1549f5bd6b1 was verified as official when first introduced to the cask
-  url "https://rink.hockeyapp.net/api/2/apps/67503a7926431872c4b6c1549f5bd6b1/app_versions/#{version.csv.second}?format=zip"
-  name "HockeyApp"
-  homepage "https://www.brew.sh/"
-
-  app "HockeyApp.app"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/hockeyapp-without-livecheck.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/hockeyapp-without-livecheck.rb
new file mode 100644
index 0000000000000..4058156c3cba7
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/hockeyapp-without-livecheck.rb
@@ -0,0 +1,10 @@
+cask "hockeyapp-without-livecheck" do
+  version "1.0,123"
+  sha256 "a69e7357bea014f4c14ac9699274f559086844ffa46563c4619bf1addfd72ad9"
+
+  url "https://rink.hockeyapp.net/api/2/apps/67503a7926431872c4b6c1549f5bd6b1/app_versions/#{version.csv.second}?format=zip"
+  name "HockeyApp"
+  homepage "https://www.brew.sh/"
+
+  app "HockeyApp.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/invalid-appcast-multiple.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/invalid-appcast-multiple.rb
deleted file mode 100644
index 69d7f8f4a5578..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/invalid-appcast-multiple.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-cask "invalid-appcast-multiple" do
-  version "1.2.3"
-  sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
-
-  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
-  appcast "https://brew.sh/appcast1.xml"
-  appcast "https://brew.sh/appcast2.xml"
-  homepage "https://brew.sh/invalid-appcast-multiple"
-
-  app "Caffeine.app"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/invalid-appcast-url.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/invalid-appcast-url.rb
deleted file mode 100644
index b5fa78e0f0356..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/invalid-appcast-url.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-cask "invalid-appcast-url" do
-  version "1.2.3"
-  sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
-
-  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
-  appcast 1
-  homepage "https://brew.sh/invalid-appcast-url"
-
-  app "Caffeine.app"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/invalid-two-arch.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/invalid-two-arch.rb
new file mode 100644
index 0000000000000..117e59c3bc1c4
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/invalid/invalid-two-arch.rb
@@ -0,0 +1,12 @@
+cask "invalid-two-arch" do
+  arch arm: "arm", intel: "intel"
+  arch arm: "amd64", intel: "x86_64"
+
+  version "1.2.3"
+  sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
+  homepage "https://brew.sh/"
+
+  app "Caffeine.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/latest-with-appcast.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/latest-with-appcast.rb
deleted file mode 100644
index ad893cf7a6474..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/latest-with-appcast.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-cask "latest-with-appcast" do
-  version :latest
-  sha256 :no_check
-
-  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
-  appcast "https://brew.sh/appcast.xml"
-  homepage "https://brew.sh/with-appcast"
-
-  app "Caffeine.app"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/latest-with-livecheck-skip.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/latest-with-livecheck-skip.rb
new file mode 100644
index 0000000000000..fdc233aa8e2a4
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/latest-with-livecheck-skip.rb
@@ -0,0 +1,13 @@
+cask "latest-with-livecheck-skip" do
+  version :latest
+  sha256 :no_check
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
+  homepage "https://brew.sh/with-livecheck-skip"
+
+  livecheck do
+    skip "no version information available"
+  end
+
+  app "Caffeine.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/latest-with-livecheck.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/latest-with-livecheck.rb
new file mode 100644
index 0000000000000..f65ef898ce8fd
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/latest-with-livecheck.rb
@@ -0,0 +1,13 @@
+cask "latest-with-livecheck" do
+  version :latest
+  sha256 :no_check
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
+  homepage "https://brew.sh/with-livecheck"
+
+  livecheck do
+    url "https://brew.sh/with-livecheck/changelog"
+  end
+
+  app "Caffeine.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/latest.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/latest.rb
new file mode 100644
index 0000000000000..2f886bc4bac14
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/latest.rb
@@ -0,0 +1,9 @@
+cask "latest" do
+  version :latest
+  sha256 :no_check
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
+  homepage "https://brew.sh/with-appcast"
+
+  app "Caffeine.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/discontinued-reference.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/discontinued-reference.rb
deleted file mode 100644
index ff6fb834f2c2c..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/discontinued-reference.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-cask "discontinued-reference" do
-  version "1.2.3"
-  sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
-
-  # This cask is used in --online tests, so we use fake URLs to avoid impacting
-  # real servers. The URL paths are specific enough that they'll be
-  # understandable if they appear in local server logs.
-  url "http://localhost/homebrew/test/cask/audit/livecheck/discontinued-#{version}.dmg"
-  name "Discontinued Reference"
-  desc "Cask for testing a livecheck reference to a discontinued cask"
-  homepage "http://localhost/homebrew/test/cask/audit/livecheck/discontinued"
-
-  livecheck do
-    cask "livecheck/discontinued"
-  end
-
-  app "TestCask.app"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/discontinued.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/discontinued.rb
deleted file mode 100644
index eb9a50c81615a..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/discontinued.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-cask "discontinued" do
-  version "1.2.3"
-  sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
-
-  # This cask is used in --online tests, so we use fake URLs to avoid impacting
-  # real servers. The URL paths are specific enough that they'll be
-  # understandable if they appear in local server logs.
-  url "http://localhost/homebrew/test/cask/audit/livecheck/discontinued-#{version}.dmg"
-  name "Discontinued"
-  desc "Cask for testing discontinued in livecheck"
-  homepage "http://localhost/homebrew/test/cask/audit/livecheck/discontinued"
-
-  app "TestCask.app"
-
-  caveats do
-    discontinued
-  end
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-deprecated-reference.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-deprecated-reference.rb
new file mode 100644
index 0000000000000..8cc3718465c06
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-deprecated-reference.rb
@@ -0,0 +1,18 @@
+cask "livecheck-deprecated-reference" do
+  version "1.2.3"
+  sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+
+  # This cask is used in --online tests, so we use fake URLs to avoid impacting
+  # real servers. The URL paths are specific enough that they'll be
+  # understandable if they appear in local server logs.
+  url "http://localhost/homebrew/test/cask/audit/livecheck/deprecated-#{version}.dmg"
+  name "Deprecated Reference"
+  desc "Cask for testing a livecheck reference to a deprecated cask"
+  homepage "http://localhost/homebrew/test/cask/audit/livecheck/deprecated"
+
+  livecheck do
+    cask "livecheck-deprecated"
+  end
+
+  app "TestCask.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-deprecated.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-deprecated.rb
new file mode 100644
index 0000000000000..3b74884991268
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-deprecated.rb
@@ -0,0 +1,16 @@
+cask "livecheck-deprecated" do
+  version "1.2.3"
+  sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+
+  # This cask is used in --online tests, so we use fake URLs to avoid impacting
+  # real servers. The URL paths are specific enough that they'll be
+  # understandable if they appear in local server logs.
+  url "http://localhost/homebrew/test/cask/audit/livecheck/deprecated-#{version}.dmg"
+  name "Deprecated"
+  desc "Cask for testing deprecated in livecheck"
+  homepage "http://localhost/homebrew/test/cask/audit/livecheck/deprecated"
+
+  deprecate! date: "2023-01-01", because: :discontinued
+
+  app "TestCask.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-disabled-reference.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-disabled-reference.rb
new file mode 100644
index 0000000000000..6218d47134c4b
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-disabled-reference.rb
@@ -0,0 +1,18 @@
+cask "livecheck-disabled-reference" do
+  version "1.2.3"
+  sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+
+  # This cask is used in --online tests, so we use fake URLs to avoid impacting
+  # real servers. The URL paths are specific enough that they'll be
+  # understandable if they appear in local server logs.
+  url "http://localhost/homebrew/test/cask/audit/livecheck/disabled-#{version}.dmg"
+  name "Disabled Reference"
+  desc "Cask for testing a livecheck reference to a disabled cask"
+  homepage "http://localhost/homebrew/test/cask/audit/livecheck/disabled"
+
+  livecheck do
+    cask "livecheck-disabled"
+  end
+
+  app "TestCask.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-disabled.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-disabled.rb
new file mode 100644
index 0000000000000..57982f3f9f20e
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-disabled.rb
@@ -0,0 +1,16 @@
+cask "livecheck-disabled" do
+  version "1.2.3"
+  sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+
+  # This cask is used in --online tests, so we use fake URLs to avoid impacting
+  # real servers. The URL paths are specific enough that they'll be
+  # understandable if they appear in local server logs.
+  url "http://localhost/homebrew/test/cask/audit/livecheck/disabled-#{version}.dmg"
+  name "Disabled"
+  desc "Cask for testing disabled in livecheck"
+  homepage "http://localhost/homebrew/test/cask/audit/livecheck/disabled"
+
+  disable! date: "2023-01-01", because: :discontinued
+
+  app "TestCask.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-extract-plist.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-extract-plist.rb
new file mode 100644
index 0000000000000..f5cf411aa62cf
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-extract-plist.rb
@@ -0,0 +1,16 @@
+cask "livecheck-extract-plist" do
+  version "1.2.3"
+  sha256 "78c670559a609f5d89a5d75eee49e2a2dab48aa3ea36906d14d5f7104e483bb9"
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine-suite.zip"
+  name "With Extract Plist Livecheck"
+  desc "Cask with a an ExtractPlist livecheck strategy"
+  homepage "https://brew.sh/"
+
+  livecheck do
+    url "file://#{TEST_FIXTURE_DIR}/cask/caffeine-with-plist.zip"
+    strategy :extract_plist
+  end
+
+  app "Caffeine.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-installer-manual.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-installer-manual.rb
new file mode 100644
index 0000000000000..fe38c3ce095a8
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-installer-manual.rb
@@ -0,0 +1,16 @@
+cask "livecheck-installer-manual" do
+  version "1.2.3"
+  sha256 "78c670559a609f5d89a5d75eee49e2a2dab48aa3ea36906d14d5f7104e483bb9"
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine-incl-plist.zip"
+  name "With Installer Manual"
+  desc "Cask with a manual installer"
+  homepage "https://brew.sh/"
+
+  livecheck do
+    url :url
+    strategy :extract_plist
+  end
+
+  installer manual: "Caffeine.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-skip-reference.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-skip-reference.rb
index 4514c358e6ab2..a6e32926c95dc 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-skip-reference.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-skip-reference.rb
@@ -11,7 +11,7 @@
   homepage "http://localhost/homebrew/test/cask/audit/livecheck/livecheck-skip"
 
   livecheck do
-    cask "livecheck/livecheck-skip"
+    cask "livecheck-skip"
   end
 
   app "TestCask.app"
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-url-unversioned-reference.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-url-unversioned-reference.rb
new file mode 100644
index 0000000000000..5531bbfda6149
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-url-unversioned-reference.rb
@@ -0,0 +1,18 @@
+cask "livecheck-url-unversioned-reference" do
+  version "1.2.3"
+  sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+
+  # This cask is used in --online tests, so we use fake URLs to avoid impacting
+  # real servers. The URL paths are specific enough that they'll be
+  # understandable if they appear in local server logs.
+  url "http://localhost/homebrew/test/cask/audit/livecheck/url-unversioned.dmg"
+  name "Unversioned URL Reference"
+  desc "Cask for testing a livecheck reference to a cask with an unversioned URL"
+  homepage "http://localhost/homebrew/test/cask/audit/livecheck/url-unversioned"
+
+  livecheck do
+    cask "livecheck-url-unversioned"
+  end
+
+  app "TestCask.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-url-unversioned.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-url-unversioned.rb
new file mode 100644
index 0000000000000..8208a26590d27
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-url-unversioned.rb
@@ -0,0 +1,14 @@
+cask "livecheck-url-unversioned" do
+  version "1.2.3"
+  sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+
+  # This cask is used in --online tests, so we use fake URLs to avoid impacting
+  # real servers. The URL paths are specific enough that they'll be
+  # understandable if they appear in local server logs.
+  url "http://localhost/homebrew/test/cask/audit/livecheck/url-unversioned.dmg"
+  name "Unversioned URL"
+  desc "Cask for testing an unversioned URL in livecheck"
+  homepage "http://localhost/homebrew/test/cask/audit/livecheck/url-unversioned"
+
+  app "TestCask.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-version-latest-reference.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-version-latest-reference.rb
new file mode 100644
index 0000000000000..15bcf0f3685f9
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-version-latest-reference.rb
@@ -0,0 +1,18 @@
+cask "livecheck-version-latest-reference" do
+  version :latest
+  sha256 :no_check
+
+  # This cask is used in --online tests, so we use fake URLs to avoid impacting
+  # real servers. The URL paths are specific enough that they'll be
+  # understandable if they appear in local server logs.
+  url "http://localhost/homebrew/test/cask/audit/livecheck/version-latest.dmg"
+  name "Version Latest Reference"
+  desc "Cask for testing a livecheck reference to a cask where version is :latest"
+  homepage "http://localhost/homebrew/test/cask/audit/livecheck/version-latest"
+
+  livecheck do
+    cask "livecheck-version-latest"
+  end
+
+  app "TestCask.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-version-latest.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-version-latest.rb
new file mode 100644
index 0000000000000..3e892077e1992
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/livecheck-version-latest.rb
@@ -0,0 +1,14 @@
+cask "livecheck-version-latest" do
+  version :latest
+  sha256 :no_check
+
+  # This cask is used in --online tests, so we use fake URLs to avoid impacting
+  # real servers. The URL paths are specific enough that they'll be
+  # understandable if they appear in local server logs.
+  url "http://localhost/homebrew/test/cask/audit/livecheck/version-latest.dmg"
+  name "Version Latest"
+  desc "Cask for testing a latest version in livecheck"
+  homepage "http://localhost/homebrew/test/cask/audit/livecheck/version-latest"
+
+  app "TestCask.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/url-unversioned-reference.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/url-unversioned-reference.rb
deleted file mode 100644
index 078caa0bde788..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/url-unversioned-reference.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-cask "url-unversioned-reference" do
-  version "1.2.3"
-  sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
-
-  # This cask is used in --online tests, so we use fake URLs to avoid impacting
-  # real servers. The URL paths are specific enough that they'll be
-  # understandable if they appear in local server logs.
-  url "http://localhost/homebrew/test/cask/audit/livecheck/url-unversioned.dmg"
-  name "Unversioned URL Reference"
-  desc "Cask for testing a livecheck reference to a cask with an unversioned URL"
-  homepage "http://localhost/homebrew/test/cask/audit/livecheck/url-unversioned"
-
-  livecheck do
-    cask "livecheck/url-unversioned"
-  end
-
-  app "TestCask.app"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/url-unversioned.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/url-unversioned.rb
deleted file mode 100644
index c696ae0696671..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/url-unversioned.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-cask "url-unversioned" do
-  version "1.2.3"
-  sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
-
-  # This cask is used in --online tests, so we use fake URLs to avoid impacting
-  # real servers. The URL paths are specific enough that they'll be
-  # understandable if they appear in local server logs.
-  url "http://localhost/homebrew/test/cask/audit/livecheck/url-unversioned.dmg"
-  name "Unversioned URL"
-  desc "Cask for testing an unversioned URL in livecheck"
-  homepage "http://localhost/homebrew/test/cask/audit/livecheck/url-unversioned"
-
-  app "TestCask.app"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/version-latest-reference.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/version-latest-reference.rb
deleted file mode 100644
index 11f057e3e1b31..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/version-latest-reference.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-cask "version-latest-reference" do
-  version :latest
-  sha256 :no_check
-
-  # This cask is used in --online tests, so we use fake URLs to avoid impacting
-  # real servers. The URL paths are specific enough that they'll be
-  # understandable if they appear in local server logs.
-  url "http://localhost/homebrew/test/cask/audit/livecheck/version-latest.dmg"
-  name "Version Latest Reference"
-  desc "Cask for testing a livecheck reference to a cask where version is :latest"
-  homepage "http://localhost/homebrew/test/cask/audit/livecheck/version-latest"
-
-  livecheck do
-    cask "livecheck/version-latest"
-  end
-
-  app "TestCask.app"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/version-latest.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/version-latest.rb
deleted file mode 100644
index 37286c09c2378..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/livecheck/version-latest.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-cask "version-latest" do
-  version :latest
-  sha256 :no_check
-
-  # This cask is used in --online tests, so we use fake URLs to avoid impacting
-  # real servers. The URL paths are specific enough that they'll be
-  # understandable if they appear in local server logs.
-  url "http://localhost/homebrew/test/cask/audit/livecheck/version-latest.dmg"
-  name "Version Latest"
-  desc "Cask for testing a latest version in livecheck"
-  homepage "http://localhost/homebrew/test/cask/audit/livecheck/version-latest"
-
-  app "TestCask.app"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/many-artifacts.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/many-artifacts.rb
new file mode 100644
index 0000000000000..a488fd35f1d96
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/many-artifacts.rb
@@ -0,0 +1,32 @@
+cask "many-artifacts" do
+  version "1.2.3"
+  sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/ManyArtifacts.zip"
+  homepage "https://brew.sh/many-artifacts"
+
+  app "ManyArtifacts/ManyArtifacts.app"
+  pkg "ManyArtifacts/ManyArtifacts.pkg"
+
+  preflight do
+    # do nothing
+  end
+
+  postflight do
+    # do nothing
+  end
+
+  uninstall_preflight do
+    # do nothing
+  end
+
+  uninstall_postflight do
+    # do nothing
+  end
+
+  uninstall trash: ["#{TEST_TMPDIR}/foo", "#{TEST_TMPDIR}/bar"],
+            rmdir: "#{TEST_TMPDIR}/empty_directory_path"
+
+  zap trash: "~/Library/Logs/ManyArtifacts.log",
+      rmdir: ["~/Library/Caches/ManyArtifacts", "~/Library/Application Support/ManyArtifacts"]
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/multiple-versions.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/multiple-versions.rb
index ad05491a2d1e4..fea39877d6770 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/multiple-versions.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/multiple-versions.rb
@@ -1,23 +1,21 @@
 cask "multiple-versions" do
-  arch = "arm"
-  version "1.2.3"
-  sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
+  arch arm: "arm", intel: "intel"
+  platform = on_arch_conditional arm: "darwin-arm64", intel: "darwin"
 
-  on_intel do
-    arch = "intel"
+  on_catalina :or_older do
+    version "1.0.0"
+    sha256 "1866dfa833b123bb8fe7fa7185ebf24d28d300d0643d75798bc23730af734216"
   end
-
   on_big_sur do
     version "1.2.0"
     sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
   end
-
-  on_catalina :or_older do
-    version "1.0.0"
-    sha256 "1866dfa833b123bb8fe7fa7185ebf24d28d300d0643d75798bc23730af734216"
+  on_monterey :or_newer do
+    version "1.2.3"
+    sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
   end
 
-  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine/#{version}/#{arch}.zip"
+  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine/#{platform}/#{version}/#{arch}.zip"
   homepage "https://brew.sh/"
 
   app "Caffeine.app"
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/osdn-correct-url-format.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/osdn-correct-url-format.rb
deleted file mode 100644
index c80bdacf6d3eb..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/osdn-correct-url-format.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-cask "osdn-correct-url-format" do
-  version "1.2.3"
-
-  url "https://user.dl.osdn.jp/something/id/Something-1.2.3.dmg"
-  homepage "https://osdn.jp/projects/something/"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/osdn-incorrect-url-format.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/osdn-incorrect-url-format.rb
deleted file mode 100644
index 10a36d10cc58d..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/osdn-incorrect-url-format.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-cask "osdn-incorrect-url-format" do
-  version "1.2.3"
-
-  url "https://osdn.jp/projects/something/files/Something-1.2.3.dmg/download"
-  homepage "https://osdn.jp/projects/something/"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/osdn-urls.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/osdn-urls.rb
new file mode 100644
index 0000000000000..569859db53c50
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/osdn-urls.rb
@@ -0,0 +1,6 @@
+cask "osdn-urls" do
+  version "1.2.3"
+
+  url "https://user.dl.osdn.jp/something/id/Something-1.2.3.dmg"
+  homepage "https://osdn.jp/projects/something/"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/outdated/renamed-app.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/outdated/renamed-app.rb
new file mode 100644
index 0000000000000..e93b90cb8eb3f
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/outdated/renamed-app.rb
@@ -0,0 +1,9 @@
+cask "renamed-app" do
+  version "1.0.0"
+  sha256 "cf001ed6c81820e049dc7a353957dab8936b91f1956ee74ff0b3eb59791f1ad9"
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/old-app.tar.gz"
+  homepage "https://brew.sh/"
+
+  app "OldApp.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/placeholders.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/placeholders.rb
new file mode 100644
index 0000000000000..81b4548b9b5fc
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/placeholders.rb
@@ -0,0 +1,11 @@
+cask "placeholders" do
+  version "2.61"
+  sha256 "e44ffa103fbf83f55c8d0b1bea309a43b2880798dae8620b1ee8da5e1095ec68"
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/transmission-2.61.dmg"
+  homepage "https://brew.sh/placeholders"
+
+  binary "#{appdir}/some/path"
+
+  caveats "#{HOMEBREW_PREFIX} and #{Dir.home}"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/renamed-app.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/renamed-app.rb
new file mode 100644
index 0000000000000..3e1f367fa54d2
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/renamed-app.rb
@@ -0,0 +1,9 @@
+cask "renamed-app" do
+  version "2.0.0"
+  sha256 "9f88a6f3d8a7977cd3c116c56ee7a20a3c69e838a1d4946f815a926a57883299"
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/new-app.tar.gz"
+  homepage "https://brew.sh/"
+
+  app "NewApp.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/sha256-arch.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/sha256-arch.rb
new file mode 100644
index 0000000000000..1e109bf48ee2f
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/sha256-arch.rb
@@ -0,0 +1,12 @@
+cask "sha256-arch" do
+  arch arm: "arm", intel: "intel"
+
+  version "1.2.3"
+  sha256 arm:   "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94",
+         intel: "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine-#{arch}.zip"
+  homepage "https://brew.sh/"
+
+  app "Caffeine.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/sourceforge-with-appcast.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/sourceforge-with-appcast.rb
deleted file mode 100644
index ad813becfa657..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/sourceforge-with-appcast.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-cask "sourceforge-with-appcast" do
-  version "1.2.3"
-
-  url "https://downloads.sourceforge.net/something/Something-1.2.3.dmg"
-  appcast "https://sourceforge.net/projects/something/rss"
-  homepage "https://sourceforge.net/projects/something/"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/sourceforge-with-livecheck.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/sourceforge-with-livecheck.rb
new file mode 100644
index 0000000000000..5c42cec2f2695
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/sourceforge-with-livecheck.rb
@@ -0,0 +1,10 @@
+cask "sourceforge-with-livecheck" do
+  version "1.2.3"
+
+  url "https://downloads.sourceforge.net/something/Something-1.2.3.dmg"
+  homepage "https://sourceforge.net/projects/something/"
+
+  livecheck do
+    url "https://sourceforge.net/projects/something/rss"
+  end
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/version-colon.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/version-colon.rb
new file mode 100644
index 0000000000000..c3285282c5f92
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/version-colon.rb
@@ -0,0 +1,4 @@
+cask "version-colon" do
+  version "1.2.3:1003"
+  sha256 :no_check
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-appcast.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-appcast.rb
deleted file mode 100644
index c26b429354174..0000000000000
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-appcast.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-cask "with-appcast" do
-  version "1.2.3"
-  sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
-
-  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
-  appcast "https://brew.sh/appcast.xml"
-  homepage "https://brew.sh/with-appcast"
-
-  app "Caffeine.app"
-end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-conditional-caveats.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-conditional-caveats.rb
index 3f26d9c19affa..4ca1b07ec5590 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-conditional-caveats.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-conditional-caveats.rb
@@ -9,6 +9,6 @@
 
   # a do block may print and use a DSL
   caveats do
-    puts "This caveat is conditional" unless String("Caffeine") == "Caffeine"
+    puts "This caveat is conditional" if String("Caffeine") != "Caffeine"
   end
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-depends-on-everything.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-depends-on-everything.rb
new file mode 100644
index 0000000000000..fef3374ef79d7
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-depends-on-everything.rb
@@ -0,0 +1,15 @@
+cask "with-depends-on-everything" do
+  version "1.2.3"
+  sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
+  homepage "https://brew.sh/with-depends-on-everything"
+
+  depends_on arch: [:intel, :arm64]
+  depends_on cask: "local-caffeine"
+  depends_on cask: "with-depends-on-cask"
+  depends_on formula: "unar"
+  depends_on macos: ">= :el_capitan"
+
+  app "Caffeine.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-depends-on-macos-failure.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-depends-on-macos-failure.rb
index 652ac08b8efb1..bbde7db9c38e7 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-depends-on-macos-failure.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-depends-on-macos-failure.rb
@@ -2,11 +2,19 @@
   version "1.2.3"
   sha256 "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94"
 
+  # guarantee a mismatched release
+  on_mojave :or_older do
+    depends_on macos: :catalina
+  end
+  on_catalina do
+    depends_on macos: :mojave
+  end
+  on_big_sur :or_newer do
+    depends_on macos: :catalina
+  end
+
   url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
   homepage "https://brew.sh/with-depends-on-macos-failure"
 
-  # guarantee a mismatched release
-  depends_on macos: MacOS.version == :catalina ? :mojave : :catalina
-
   app "Caffeine.app"
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-installable.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-installable.rb
index fe7cd8300887f..67d58c52d24ea 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-installable.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-installable.rb
@@ -7,15 +7,15 @@
 
   pkg "MyFancyPkg/Fancy.pkg"
 
-  uninstall script:     { executable: "MyFancyPkg/FancyUninstaller.tool", args: ["--please"] },
-            quit:       "my.fancy.package.app",
+  uninstall quit:       "my.fancy.package.app",
             login_item: "Fancy",
+            script:     { executable: "MyFancyPkg/FancyUninstaller.tool", args: ["--please"] },
             delete:     [
               "#{TEST_TMPDIR}/absolute_path",
-              "~/path_with_tilde",
               "#{TEST_TMPDIR}/glob_path*",
-              "impermissible/relative/path",
               "/another/impermissible/../relative/path",
+              "impermissible/relative/path",
+              "~/path_with_tilde",
             ],
             rmdir:      "#{TEST_TMPDIR}/empty_directory_path"
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-many-languages.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-many-languages.rb
new file mode 100644
index 0000000000000..401fe113fc39b
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-many-languages.rb
@@ -0,0 +1,55 @@
+cask "with-many-languages" do
+  version "1.2.3"
+
+  language "en", default: true do
+    sha256 :no_check
+    "en"
+  end
+  language "cs" do
+    sha256 :no_check
+    "cs"
+  end
+  language "es-AR" do
+    sha256 :no_check
+    "es-AR"
+  end
+  language "ff" do
+    sha256 :no_check
+    "ff"
+  end
+  language "fi" do
+    sha256 :no_check
+    "fi"
+  end
+  language "gn" do
+    sha256 :no_check
+    "gn"
+  end
+  language "gu" do
+    sha256 :no_check
+    "gu"
+  end
+  language "ko" do
+    sha256 :no_check
+    "ko"
+  end
+  language "ru" do
+    sha256 :no_check
+    "ru"
+  end
+  language "sv" do
+    sha256 :no_check
+    "sv"
+  end
+  language "th" do
+    sha256 :no_check
+    "th"
+  end
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/caffeine.zip"
+  name "Caffeine"
+  desc "Keep your computer awake"
+  homepage "https://brew.sh/"
+
+  app "Caffeine.app"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-pkgutil-zap.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-pkgutil-zap.rb
index b19a54de0425b..560d5cd581e61 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-pkgutil-zap.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-pkgutil-zap.rb
@@ -7,7 +7,7 @@
 
   pkg "Fancy.pkg"
 
-  zap pkgutil:   "my.fancy.package.*",
+  zap launchctl: "my.fancy.package.service",
       kext:      "my.fancy.package.kernelextension",
-      launchctl: "my.fancy.package.service"
+      pkgutil:   "my.fancy.package.*"
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-postflight-multi.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-postflight-multi.rb
index f0b82d4716cce..7fb1bec47668b 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-postflight-multi.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-postflight-multi.rb
@@ -8,7 +8,9 @@
   pkg "MyFancyPkg/Fancy.pkg"
 
   postflight do
+    # do nothing
   end
   postflight do
+    # do nothing
   end
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-postflight.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-postflight.rb
index b14223ccbd810..a4b3bf701c9a8 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-postflight.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-postflight.rb
@@ -8,5 +8,6 @@
   pkg "MyFancyPkg/Fancy.pkg"
 
   postflight do
+    # do nothing
   end
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-preflight-multi.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-preflight-multi.rb
index c62bfdcebcfa2..3732c141bab6a 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-preflight-multi.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-preflight-multi.rb
@@ -8,7 +8,9 @@
   pkg "MyFancyPkg/Fancy.pkg"
 
   preflight do
+    # do nothing
   end
   preflight do
+    # do nothing
   end
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-preflight.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-preflight.rb
index 29bc0b0c16a3b..1da7ed88e6c7d 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-preflight.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-preflight.rb
@@ -8,5 +8,6 @@
   pkg "MyFancyPkg/Fancy.pkg"
 
   preflight do
+    # do nothing
   end
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-delete.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-delete.rb
index f40775872ed0e..d38206c3c1919 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-delete.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-delete.rb
@@ -9,9 +9,9 @@
 
   uninstall delete: [
     "#{TEST_TMPDIR}/absolute_path",
-    "~/path_with_tilde",
     "#{TEST_TMPDIR}/glob_path*",
-    "impermissible/relative/path",
     "/another/impermissible/../relative/path",
+    "impermissible/relative/path",
+    "~/path_with_tilde",
   ]
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-launchctl-wildcard.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-launchctl-wildcard.rb
new file mode 100644
index 0000000000000..89d14231b6893
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-launchctl-wildcard.rb
@@ -0,0 +1,11 @@
+cask "with-uninstall-launchctl-wildcard" do
+  version "1.2.3"
+  sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/MyFancyApp.zip"
+  homepage "https://brew.sh/fancy"
+
+  app "Fancy.app"
+
+  uninstall launchctl: "my.fancy.package.service.*"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-postflight-multi.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-postflight-multi.rb
index 52e5e6420bc09..4da9516966a74 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-postflight-multi.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-postflight-multi.rb
@@ -8,7 +8,9 @@
   pkg "MyFancyPkg/Fancy.pkg"
 
   uninstall_postflight do
+    # do nothing
   end
   uninstall_postflight do
+    # do nothing
   end
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-postflight.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-postflight.rb
index c400a7edd1073..b07760d0995f7 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-postflight.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-postflight.rb
@@ -8,5 +8,6 @@
   pkg "MyFancyPkg/Fancy.pkg"
 
   uninstall_postflight do
+    # do nothing
   end
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-preflight-multi.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-preflight-multi.rb
index d743984fde1ef..7bf6bbf9facb7 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-preflight-multi.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-preflight-multi.rb
@@ -8,7 +8,9 @@
   pkg "MyFancyPkg/Fancy.pkg"
 
   uninstall_preflight do
+    # do nothing
   end
   uninstall_preflight do
+    # do nothing
   end
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-preflight.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-preflight.rb
index b4d73a0e6c227..2af130cca8fab 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-preflight.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-preflight.rb
@@ -8,5 +8,6 @@
   pkg "MyFancyPkg/Fancy.pkg"
 
   uninstall_preflight do
+    # do nothing
   end
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-script-app.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-script-app.rb
index 22735487d2ed3..70ec4b2252dbc 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-script-app.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-script-app.rb
@@ -15,7 +15,8 @@
   end
 
   uninstall script: {
-    executable: "#{appdir}/MyFancyApp.app/uninstall.sh",
-    sudo:       false,
+    executable:   "#{appdir}/MyFancyApp.app/uninstall.sh",
+    sudo:         false,
+    sudo_as_root: false,
   }
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-script-user-relative.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-script-user-relative.rb
index a1f97c310822b..4ad95b53f8a97 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-script-user-relative.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-script-user-relative.rb
@@ -15,7 +15,8 @@
   end
 
   uninstall script: {
-    executable: "~/MyFancyApp.app/uninstall.sh",
-    sudo:       false,
+    executable:   "~/MyFancyApp.app/uninstall.sh",
+    sudo:         false,
+    sudo_as_root: false,
   }
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-trash.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-trash.rb
index 4f3fac0313f6a..9fa108133b041 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-trash.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-uninstall-trash.rb
@@ -9,9 +9,9 @@
 
   uninstall trash: [
     "#{TEST_TMPDIR}/absolute_path",
-    "~/path_with_tilde",
     "#{TEST_TMPDIR}/glob_path*",
-    "impermissible/relative/path",
     "/another/impermissible/../relative/path",
+    "impermissible/relative/path",
+    "~/path_with_tilde",
   ]
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap-delete.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap-delete.rb
index 706ca7a2f1ffb..1e7f57ea1f4b3 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap-delete.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap-delete.rb
@@ -9,9 +9,9 @@
 
   zap delete: [
     "#{TEST_TMPDIR}/absolute_path",
-    "~/path_with_tilde",
     "#{TEST_TMPDIR}/glob_path*",
-    "impermissible/relative/path",
     "/another/impermissible/../relative/path",
+    "impermissible/relative/path",
+    "~/path_with_tilde",
   ]
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap-launchctl-wildcard.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap-launchctl-wildcard.rb
new file mode 100644
index 0000000000000..598dc549a7bf2
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap-launchctl-wildcard.rb
@@ -0,0 +1,11 @@
+cask "with-zap-launchctl-wildcard" do
+  version "1.2.3"
+  sha256 "8c62a2b791cf5f0da6066a0a4b6e85f62949cd60975da062df44adf887f4370b"
+
+  url "file://#{TEST_FIXTURE_DIR}/cask/MyFancyApp.zip"
+  homepage "https://brew.sh/fancy"
+
+  app "Fancy.app"
+
+  zap launchctl: "my.fancy.package.service.*"
+end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap-trash.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap-trash.rb
index 11651a4f2fdb2..4cd1c150117d6 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap-trash.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap-trash.rb
@@ -9,9 +9,9 @@
 
   zap trash: [
     "#{TEST_TMPDIR}/absolute_path",
-    "~/path_with_tilde",
     "#{TEST_TMPDIR}/glob_path*",
-    "impermissible/relative/path",
     "/another/impermissible/../relative/path",
+    "impermissible/relative/path",
+    "~/path_with_tilde",
   ]
 end
diff --git a/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap.rb b/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap.rb
index 9027e38bfa23d..69f49f5dcfb70 100644
--- a/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap.rb
+++ b/Library/Homebrew/test/support/fixtures/cask/Casks/with-zap.rb
@@ -9,11 +9,11 @@
 
   uninstall quit: "my.fancy.package.app.from.uninstall"
 
-  zap script:     {
+  zap quit:       "my.fancy.package.app",
+      login_item: "Fancy",
+      script:     {
         executable: "MyFancyPkg/FancyUninstaller.tool",
         args:       ["--please"],
       },
-      quit:       "my.fancy.package.app",
-      login_item: "Fancy",
       delete:     "~/Library/Preferences/my.fancy.app.plist"
 end
diff --git a/docs/Homebrew-linuxbrew-core-Maintainer-Guide.md b/Library/Homebrew/test/support/fixtures/cask/NewApp.app/Contents/Info.plist
similarity index 100%
rename from docs/Homebrew-linuxbrew-core-Maintainer-Guide.md
rename to Library/Homebrew/test/support/fixtures/cask/NewApp.app/Contents/Info.plist
diff --git a/Library/Homebrew/test/support/fixtures/cask/NewApp.app/Contents/MacOS/NewApp b/Library/Homebrew/test/support/fixtures/cask/NewApp.app/Contents/MacOS/NewApp
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/Library/Homebrew/test/support/fixtures/cask/NewApp.app/Contents/PkgInfo b/Library/Homebrew/test/support/fixtures/cask/NewApp.app/Contents/PkgInfo
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/Library/Homebrew/test/support/fixtures/cask/NewApp.app/Contents/Resources/Caffeine.icns b/Library/Homebrew/test/support/fixtures/cask/NewApp.app/Contents/Resources/Caffeine.icns
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/Library/Homebrew/test/support/fixtures/cask/caffeine-with-plist.zip b/Library/Homebrew/test/support/fixtures/cask/caffeine-with-plist.zip
new file mode 100644
index 0000000000000..646884181a72c
Binary files /dev/null and b/Library/Homebrew/test/support/fixtures/cask/caffeine-with-plist.zip differ
diff --git a/Library/Homebrew/test/support/fixtures/cask/caffeine.json b/Library/Homebrew/test/support/fixtures/cask/caffeine.json
new file mode 100644
index 0000000000000..348aecbc030dc
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/caffeine.json
@@ -0,0 +1,39 @@
+{
+  "token": "caffeine",
+  "full_token": "caffeine",
+  "tap": null,
+  "name": [
+
+  ],
+  "desc": null,
+  "homepage": "https://brew.sh/",
+  "url": "https://www.example.com/cask/caffeine.zip",
+  "version": "1.2.3",
+  "installed": null,
+  "outdated": false,
+  "sha256": "67cdb8a02803ef37fdbf7e0be205863172e41a561ca446cd84f0d7ab35a99d94",
+  "artifacts": [
+    {
+      "app": [
+        "Caffeine.app"
+      ]
+    },
+    {
+      "zap": [
+        {
+          "trash": "/$HOME/support/fixtures/cask/caffeine/org.example.caffeine.plist"
+        }
+      ]
+    }
+  ],
+  "caveats": null,
+  "depends_on": {
+  },
+  "conflicts_with": null,
+  "container": null,
+  "auto_updates": null,
+  "tap_git_head": null,
+  "languages": [
+
+  ]
+}
diff --git a/Library/Homebrew/test/support/fixtures/cask/everything.json b/Library/Homebrew/test/support/fixtures/cask/everything.json
new file mode 100644
index 0000000000000..d290bd45d16ea
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask/everything.json
@@ -0,0 +1,107 @@
+{
+  "token": "everything",
+  "full_token": "everything",
+  "old_tokens": [
+
+  ],
+  "tap": "homebrew/cask",
+  "name": [
+    "Everything"
+  ],
+  "desc": "Little bit of everything",
+  "homepage": "https://www.everything.app/",
+  "url": "https://cachefly.everything.app/releases/Everything_1.2.3.zip",
+  "url_specs": {
+    "cookies": {
+      "ALL": "1234"
+    },
+    "user_agent": ":fake"
+  },
+  "version": "1.2.3",
+  "installed": null,
+  "installed_time": null,
+  "bundle_version": null,
+  "bundle_short_version": null,
+  "outdated": false,
+  "sha256": "c64c05bdc0be845505d6e55e69e696a7f50d40846e76155f0c85d5ff5e7bbb84",
+  "artifacts": [
+    {
+      "uninstall": [
+        {
+          "launchctl": "com.every.thing.agent",
+          "signal": [
+            [
+              "TERM",
+              "com.every.thing.controller1"
+            ],
+            [
+              "TERM",
+              "com.every.thing.bin"
+            ]
+          ],
+          "kext": "com.every.thing.driver",
+          "delete": "/Library/EverythingHelperTools"
+        }
+      ]
+    },
+    {
+      "installer": [
+        {
+          "script": {
+            "executable": "~/just/another/path/install.sh",
+            "args": [
+              "--mode=silent"
+            ],
+            "sudo": true,
+            "print_stderr": false
+          }
+        }
+      ]
+    },
+    {
+      "app": [
+        "Everything.app"
+      ]
+    },
+    {
+      "zap": [
+        {
+          "trash": [
+            "~/.everything",
+            "~/Library/Everything"
+          ]
+        }
+      ]
+    }
+  ],
+  "caveats": "Installing everything might take a while...\n\neverything requires a kernel extension to work.\nIf the installation fails, retry after you enable it in:\n  System Settings → Privacy & Security\n\nFor more information, refer to vendor documentation or this Apple Technical Note:\n  https://developer.apple.com/library/content/technotes/tn2459/_index.html\n",
+  "depends_on": {
+    "cask": [
+      "something"
+    ]
+  },
+  "conflicts_with": {
+    "formula": [
+      "nothing"
+    ]
+  },
+  "container": {
+    "type": "naked"
+  },
+  "auto_updates": true,
+  "deprecated": false,
+  "deprecation_date": null,
+  "deprecation_reason": null,
+  "disabled": false,
+  "disable_date": null,
+  "disable_reason": null,
+  "tap_git_head": "abcdef1234567890abcdef1234567890abcdef12",
+  "languages": [
+    "en",
+    "eo"
+  ],
+  "ruby_source_path": "Casks/everything.rb",
+  "ruby_source_checksum": {
+    "sha256": "d8d0d6b2e5ff65388eccb82236fd3aa157b4a29bb043a1f72b97f0e9b70e8320"
+  }
+}
diff --git a/Library/Homebrew/test/support/fixtures/cask/new-app.tar.gz b/Library/Homebrew/test/support/fixtures/cask/new-app.tar.gz
new file mode 100644
index 0000000000000..a07fc7c8fe5b7
Binary files /dev/null and b/Library/Homebrew/test/support/fixtures/cask/new-app.tar.gz differ
diff --git a/Library/Homebrew/test/support/fixtures/cask/old-app.tar.gz b/Library/Homebrew/test/support/fixtures/cask/old-app.tar.gz
new file mode 100644
index 0000000000000..d02fd7e1119cc
Binary files /dev/null and b/Library/Homebrew/test/support/fixtures/cask/old-app.tar.gz differ
diff --git a/Library/Homebrew/test/support/fixtures/cask_receipt.json b/Library/Homebrew/test/support/fixtures/cask_receipt.json
new file mode 100644
index 0000000000000..e6ca53b9bbbfe
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/cask_receipt.json
@@ -0,0 +1,53 @@
+{
+  "homebrew_version": "4.3.7",
+  "loaded_from_api": false,
+  "uninstall_flight_blocks": true,
+  "installed_as_dependency": false,
+  "installed_on_request": true,
+  "time": 1719289256,
+  "runtime_dependencies": {
+    "cask": [
+      {
+        "full_name": "bar",
+        "version": "2.0",
+        "declared_directly": true
+      }
+    ],
+    "formula": [
+      {
+        "full_name": "baz",
+        "version": "3.0",
+        "revision": 0,
+        "pkg_version": "3.0",
+        "declared_directly": true
+      }
+    ],
+    "macos": {
+      ">=": [
+        "12"
+      ]
+    }
+  },
+  "source": {
+    "path": "/opt/homebrew/Library/Taps/homebrew/homebrew-cask/Casks/f/foo.rb",
+    "tap": "homebrew/cask",
+    "tap_git_head": "8b79aa759500f0ffdf65a23e12950cbe3bf8fe17",
+    "version": "1.2.3"
+  },
+  "arch": "arm64",
+  "uninstall_artifacts": [
+    {
+      "app": [
+        "Foo.app"
+      ]
+    }
+  ],
+  "built_on": {
+    "os": "Macintosh",
+    "os_version": "macOS 14",
+    "cpu_family": "arm_firestorm_icestorm",
+    "xcode": "15.4",
+    "clt": "15.3.0.0.1.1708646388",
+    "preferred_perl": "5.34"
+  }
+}
diff --git a/Library/Homebrew/test/support/fixtures/failball.rb b/Library/Homebrew/test/support/fixtures/failball.rb
index 1b396a721e84d..a675f8b8edf9d 100644
--- a/Library/Homebrew/test/support/fixtures/failball.rb
+++ b/Library/Homebrew/test/support/fixtures/failball.rb
@@ -3,14 +3,23 @@
 
 class Failball < Formula
   def initialize(name = "failball", path = Pathname.new(__FILE__).expand_path, spec = :stable,
-                 alias_path: nil, force_bottle: false)
-    self.class.instance_eval do
-      stable.url "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz"
-      stable.sha256 TESTBALL_SHA256
-    end
+                 alias_path: nil, tap: nil, force_bottle: false)
     super
   end
 
+  DSL_PROC = proc do
+    url "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz"
+    sha256 TESTBALL_SHA256
+  end.freeze
+  private_constant :DSL_PROC
+
+  DSL_PROC.call
+
+  def self.inherited(other)
+    super
+    other.instance_eval(&DSL_PROC)
+  end
+
   def install
     prefix.install "bin"
     prefix.install "libexec"
diff --git a/Library/Homebrew/test/support/fixtures/failball_offline_install.rb b/Library/Homebrew/test/support/fixtures/failball_offline_install.rb
new file mode 100644
index 0000000000000..011b452ae3651
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/failball_offline_install.rb
@@ -0,0 +1,31 @@
+# typed: true
+# frozen_string_literal: true
+
+class FailballOfflineInstall < Formula
+  def initialize(name = "failball_offline_install", path = Pathname.new(__FILE__).expand_path, spec = :stable,
+                 alias_path: nil, tap: nil, force_bottle: false)
+    super
+  end
+
+  DSL_PROC = proc do
+    url "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz"
+    sha256 TESTBALL_SHA256
+    deny_network_access! :build
+  end.freeze
+  private_constant :DSL_PROC
+
+  DSL_PROC.call
+
+  def self.inherited(other)
+    super
+    other.instance_eval(&DSL_PROC)
+  end
+
+  def install
+    system "curl", "example.org"
+
+    prefix.install "bin"
+    prefix.install "libexec"
+    Dir.chdir "doc"
+  end
+end
diff --git a/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core.json b/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core.json
new file mode 100644
index 0000000000000..b704184417375
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core.json
@@ -0,0 +1,218 @@
+{
+  "tap_git_head": "9977471165641744a829d3e494fa563407503297",
+  "aliases": {
+    "fennel-lang": "fennel",
+    "ponyc-lang": "ponyc"
+  },
+  "renames": {
+    "advancemenu": "advancemame",
+    "amtk": "libgedit-amtk",
+    "annie": "lux",
+    "antlr2": "antlr@2",
+    "romanesco": "fennel"
+  },
+  "tap_migrations": {
+    "adobe-air-sdk": "homebrew/cask",
+    "android-ndk": "homebrew/cask",
+    "android-platform-tools": "homebrew/cask",
+    "android-sdk": "homebrew/cask",
+    "app-engine-go-32": "homebrew/cask/google-cloud-sdk"
+  },
+  "formulae": {
+    "fennel": {
+      "desc": "Lua Lisp Language",
+      "license": "MIT",
+      "homepage": "https://fennel-lang.org",
+      "urls": {
+        "stable": {
+          "url": "https://github.com/bakpakin/Fennel/archive/refs/tags/1.4.0.tar.gz",
+          "checksum": "161eb7f17f86e95de09070214d042fb25372f71ad266f451431f3109e87965c7"
+        }
+      },
+      "post_install_defined": false,
+      "ruby_source_path": "Formula/f/fennel.rb",
+      "ruby_source_sha256": "5856e655fd1cea11496d67bc27fb14fee5cfbdea63c697c3773c7f247581197d",
+      "version": "1.4.0",
+      "bottle": {
+        "files": {
+          "all": {
+            "cellar": ":any_skip_relocation",
+            "sha256": "f46028597883cbc38864c61bd3fa402da9cb90ce97415d51a7b5279bc17f7bd0"
+          }
+        }
+      },
+      "dependencies": {
+        "lua": null
+      }
+    },
+    "inko": {
+      "desc": "Safe and concurrent object-oriented programming language",
+      "license": "MPL-2.0",
+      "homepage": "https://inko-lang.org/",
+      "urls": {
+        "stable": {
+          "url": "https://releases.inko-lang.org/0.14.0.tar.gz",
+          "checksum": "4e2c82911d6026f76c42ccc164dc45b1b5e331db2e9557460d9319d682668e65"
+        },
+        "head": {
+          "url": "https://github.com/inko-lang/inko.git",
+          "branch": "main"
+        }
+      },
+      "post_install_defined": false,
+      "ruby_source_path": "Formula/i/inko.rb",
+      "ruby_source_sha256": "843f6b5652483b971c83876201d68c95d5f32e67e55a75ac7c95d68c4350aa1c",
+      "version": "0.14.0",
+      "bottle": {
+        "files": {
+          "arm64_sonoma": {
+            "cellar": ":any",
+            "sha256": "f6ff66fdfb3aac69263c32a8a29d13e9d28a80ae33807f34460e55d8c1b228c6"
+          },
+          "arm64_ventura": {
+            "cellar": ":any",
+            "sha256": "be59d916d29d85bb8bc4474eb1c7d42a56236835c3c21b0e36fb9e9df0a25e6e"
+          },
+          "arm64_monterey": {
+            "cellar": ":any",
+            "sha256": "9522c1f89b997dedaa3167ce4dbfa4a2d8c660acddecd32a99a515922e851b52"
+          },
+          "sonoma": {
+            "cellar": ":any",
+            "sha256": "8e32d823ce9712ae2d5a2b9cbe0c9b727223098b3e66b003da087032be9f6818"
+          },
+          "ventura": {
+            "cellar": ":any",
+            "sha256": "178865db1e2b60b4085a2465e8a3879794030a6d22c99b58c95e4bdf5418ef1b"
+          },
+          "monterey": {
+            "cellar": ":any",
+            "sha256": "6ef924939c42d7bb2ec4e0d65cf293147a593f829619928d2580b419ec19b26c"
+          },
+          "x86_64_linux": {
+            "cellar": ":any_skip_relocation",
+            "sha256": "14a02c119990d6a17062290439ac74e6667b41dcb90b18cd90b36d2a09715e10"
+          }
+        }
+      },
+      "dependencies": {
+        "coreutils": {
+          "tags": [
+            "build"
+          ]
+        },
+        "rust": {
+          "tags": [
+            "build"
+          ]
+        },
+        "llvm@15": null,
+        "zstd": null,
+        "libffi": {
+          "uses_from_macos": {
+            "since": "catalina"
+          }
+        },
+        "ruby": {
+          "uses_from_macos": {
+            "since": "sierra"
+          }
+        }
+      },
+      "head_dependencies": {
+        "coreutils": {
+          "tags": [
+            "build"
+          ]
+        },
+        "rust": {
+          "tags": [
+            "build"
+          ]
+        },
+        "llvm@15": null,
+        "zstd": null,
+        "libffi": {
+          "uses_from_macos": {
+            "since": "catalina"
+          }
+        },
+        "ruby": {
+          "uses_from_macos": {
+            "since": "sierra"
+          }
+        }
+      }
+    },
+    "ponyc": {
+      "desc": "Object-oriented, actor-model, capabilities-secure programming language",
+      "license": "BSD-2-Clause",
+      "homepage": "https://www.ponylang.io/",
+      "urls": {
+        "stable": {
+          "url": "https://github.com/ponylang/ponyc.git",
+          "tag": "0.58.1",
+          "revision": "fe3895eb4af494bf36d7690641bdfb5755db8350"
+        }
+      },
+      "post_install_defined": false,
+      "ruby_source_path": "Formula/p/ponyc.rb",
+      "ruby_source_sha256": "81d51c25d18710191beb62f9f380bae3d878aad815a65ec1ee2a3b132c1fadb3",
+      "version": "0.58.1",
+      "bottle": {
+        "files": {
+          "arm64_sonoma": {
+            "cellar": ":any_skip_relocation",
+            "sha256": "e3aecfcf02aea56d53d82691e2ad7a780f771023d7070271bfce96b17439a34d"
+          },
+          "arm64_ventura": {
+            "cellar": ":any_skip_relocation",
+            "sha256": "6ff83717191e16e4f852fb3be8f838afba312cc39e601bb5cebd2a618a328658"
+          },
+          "arm64_monterey": {
+            "cellar": ":any_skip_relocation",
+            "sha256": "25c91bce200583a96f4cea34f31393c8f10eadcab363cc7d4d864d15f5f97e25"
+          },
+          "sonoma": {
+            "cellar": ":any_skip_relocation",
+            "sha256": "5f4c550ce33e2970e0ada18a409755fa62936181289a21c15582ff80343866b6"
+          },
+          "ventura": {
+            "cellar": ":any_skip_relocation",
+            "sha256": "f26c799f45013685da779bf2008ebe1907f9b3a93d5f260ce271a3f3b628da50"
+          },
+          "monterey": {
+            "cellar": ":any_skip_relocation",
+            "sha256": "1cff10d068b36b18b253d235424c4f5aef71ff9ee44f2522c4b041dd4383ec30"
+          },
+          "x86_64_linux": {
+            "cellar": ":any_skip_relocation",
+            "sha256": "ab49318d75eed3ee932c8e5add22f252ec0c852aad94945022877f926e93899f"
+          }
+        }
+      },
+      "dependencies": {
+        "cmake": {
+          "tags": [
+            "build"
+          ]
+        },
+        "python@3.12": {
+          "tags": [
+            "build"
+          ]
+        },
+        "llvm": {
+          "tags": [
+            "build",
+            "test"
+          ],
+          "uses_from_macos": null
+        },
+        "zlib": {
+          "uses_from_macos": null
+        }
+      }
+    }
+  }
+}
diff --git a/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/Formula/f/fennel.rb b/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/Formula/f/fennel.rb
new file mode 100644
index 0000000000000..c98a3f26c274f
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/Formula/f/fennel.rb
@@ -0,0 +1,25 @@
+class Fennel < Formula
+  desc "Lua Lisp Language"
+  homepage "https://fennel-lang.org"
+  url "https://github.com/bakpakin/Fennel/archive/refs/tags/1.4.0.tar.gz"
+  sha256 "161eb7f17f86e95de09070214d042fb25372f71ad266f451431f3109e87965c7"
+  license "MIT"
+
+  bottle do
+    sha256 cellar: :any_skip_relocation, all: "f46028597883cbc38864c61bd3fa402da9cb90ce97415d51a7b5279bc17f7bd0"
+  end
+
+  depends_on "lua"
+
+  def install
+    system "make"
+    bin.install "fennel"
+
+    lua = Formula["lua"]
+    (share/"lua"/lua.version.major_minor).install "fennel.lua"
+  end
+
+  test do
+    assert_match "hello, world!", shell_output("#{bin}/fennel -e '(print \"hello, world!\")'")
+  end
+end
diff --git a/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/Formula/i/inko.rb b/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/Formula/i/inko.rb
new file mode 100644
index 0000000000000..9f56b2d0f4413
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/Formula/i/inko.rb
@@ -0,0 +1,45 @@
+class Inko < Formula
+  desc "Safe and concurrent object-oriented programming language"
+  homepage "https://inko-lang.org/"
+  url "https://releases.inko-lang.org/0.14.0.tar.gz"
+  sha256 "4e2c82911d6026f76c42ccc164dc45b1b5e331db2e9557460d9319d682668e65"
+  license "MPL-2.0"
+  head "https://github.com/inko-lang/inko.git", branch: "main"
+
+  bottle do
+    sha256 cellar: :any,                 arm64_sonoma:   "f6ff66fdfb3aac69263c32a8a29d13e9d28a80ae33807f34460e55d8c1b228c6"
+    sha256 cellar: :any,                 arm64_ventura:  "be59d916d29d85bb8bc4474eb1c7d42a56236835c3c21b0e36fb9e9df0a25e6e"
+    sha256 cellar: :any,                 arm64_monterey: "9522c1f89b997dedaa3167ce4dbfa4a2d8c660acddecd32a99a515922e851b52"
+    sha256 cellar: :any,                 sonoma:         "8e32d823ce9712ae2d5a2b9cbe0c9b727223098b3e66b003da087032be9f6818"
+    sha256 cellar: :any,                 ventura:        "178865db1e2b60b4085a2465e8a3879794030a6d22c99b58c95e4bdf5418ef1b"
+    sha256 cellar: :any,                 monterey:       "6ef924939c42d7bb2ec4e0d65cf293147a593f829619928d2580b419ec19b26c"
+    sha256 cellar: :any_skip_relocation, x86_64_linux:   "14a02c119990d6a17062290439ac74e6667b41dcb90b18cd90b36d2a09715e10"
+  end
+
+  depends_on "coreutils" => :build
+  depends_on "rust" => :build
+  depends_on "llvm@15"
+  depends_on "zstd"
+
+  uses_from_macos "libffi", since: :catalina
+  uses_from_macos "ruby", since: :sierra
+
+  def install
+    ENV.prepend_path "PATH", Formula["coreutils"].opt_libexec/"gnubin"
+    system "make", "build", "PREFIX=#{prefix}"
+    system "make", "install", "PREFIX=#{prefix}"
+  end
+
+  test do
+    (testpath/"hello.inko").write <<~EOS
+      import std.stdio.STDOUT
+
+      class async Main {
+        fn async main {
+          STDOUT.new.print('Hello, world!')
+        }
+      }
+    EOS
+    assert_equal "Hello, world!\n", shell_output("#{bin}/inko run hello.inko")
+  end
+end
diff --git a/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/Formula/p/ponyc.rb b/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/Formula/p/ponyc.rb
new file mode 100644
index 0000000000000..63ad8bdfab5f4
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/Formula/p/ponyc.rb
@@ -0,0 +1,60 @@
+class Ponyc < Formula
+  desc "Object-oriented, actor-model, capabilities-secure programming language"
+  homepage "https://www.ponylang.io/"
+  url "https://github.com/ponylang/ponyc.git",
+      tag:      "0.58.1",
+      revision: "fe3895eb4af494bf36d7690641bdfb5755db8350"
+  license "BSD-2-Clause"
+
+  bottle do
+    sha256 cellar: :any_skip_relocation, arm64_sonoma:   "e3aecfcf02aea56d53d82691e2ad7a780f771023d7070271bfce96b17439a34d"
+    sha256 cellar: :any_skip_relocation, arm64_ventura:  "6ff83717191e16e4f852fb3be8f838afba312cc39e601bb5cebd2a618a328658"
+    sha256 cellar: :any_skip_relocation, arm64_monterey: "25c91bce200583a96f4cea34f31393c8f10eadcab363cc7d4d864d15f5f97e25"
+    sha256 cellar: :any_skip_relocation, sonoma:         "5f4c550ce33e2970e0ada18a409755fa62936181289a21c15582ff80343866b6"
+    sha256 cellar: :any_skip_relocation, ventura:        "f26c799f45013685da779bf2008ebe1907f9b3a93d5f260ce271a3f3b628da50"
+    sha256 cellar: :any_skip_relocation, monterey:       "1cff10d068b36b18b253d235424c4f5aef71ff9ee44f2522c4b041dd4383ec30"
+    sha256 cellar: :any_skip_relocation, x86_64_linux:   "ab49318d75eed3ee932c8e5add22f252ec0c852aad94945022877f926e93899f"
+  end
+
+  depends_on "cmake" => :build
+  depends_on "python@3.12" => :build
+
+  uses_from_macos "llvm" => [:build, :test]
+  uses_from_macos "zlib"
+
+  # We use LLVM to work around an error while building bundled `google-benchmark` with GCC
+  fails_with :gcc do
+    cause <<-EOS
+      .../src/gbenchmark/src/thread_manager.h:50:31: error: expected ')' before '(' token
+         50 |   GUARDED_BY(GetBenchmarkMutex()) Result results;
+            |                               ^
+    EOS
+  end
+
+  def install
+    inreplace "CMakeLists.txt", "PONY_COMPILER=\"${CMAKE_C_COMPILER}\"", "PONY_COMPILER=\"#{ENV.cc}\"" if OS.linux?
+
+    ENV["CMAKE_FLAGS"] = "-DCMAKE_OSX_SYSROOT=#{MacOS.sdk_path}" if OS.mac?
+    ENV["MAKEFLAGS"] = "build_flags=-j#{ENV.make_jobs}"
+
+    system "make", "libs"
+    system "make", "configure"
+    system "make", "build"
+    system "make", "install", "DESTDIR=#{prefix}"
+  end
+
+  test do
+    # ENV["CC"] returns llvm_clang, which does not work in a test block.
+    ENV.clang
+
+    system "#{bin}/ponyc", "-rexpr", "#{prefix}/packages/stdlib"
+
+    (testpath/"test/main.pony").write <<~EOS
+      actor Main
+        new create(env: Env) =>
+          env.out.print("Hello World!")
+    EOS
+    system "#{bin}/ponyc", "test"
+    assert_equal "Hello World!", shell_output("./test1").strip
+  end
+end
diff --git a/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/formula_renames.json b/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/formula_renames.json
new file mode 100644
index 0000000000000..ff923dc297cd6
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/formula_renames.json
@@ -0,0 +1,7 @@
+{
+  "advancemenu": "advancemame",
+  "amtk": "libgedit-amtk",
+  "annie": "lux",
+  "antlr2": "antlr@2",
+  "romanesco": "fennel"
+}
diff --git a/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/tap_migrations.json b/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/tap_migrations.json
new file mode 100644
index 0000000000000..2bdd3fd5c63b5
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/internal_tap_json/homebrew-core/tap_migrations.json
@@ -0,0 +1,7 @@
+{
+  "adobe-air-sdk": "homebrew/cask",
+  "android-ndk": "homebrew/cask",
+  "android-platform-tools": "homebrew/cask",
+  "android-sdk": "homebrew/cask",
+  "app-engine-go-32": "homebrew/cask/google-cloud-sdk"
+}
diff --git a/Library/Homebrew/test/support/fixtures/patches/noop-d.diff b/Library/Homebrew/test/support/fixtures/patches/noop-d.diff
new file mode 100644
index 0000000000000..5c40b3a7eabd7
--- /dev/null
+++ b/Library/Homebrew/test/support/fixtures/patches/noop-d.diff
@@ -0,0 +1,10 @@
+diff --git a/libexec/NOOP b/libexec/NOOP
+index bfdda4c..e08d8f4 100755
+--- a/libexec/NOOP
++++ b/libexec/NOOP
+@@ -1,2 +1,2 @@
+ #!/bin/bash
+-echo NOOP
+\ No newline at end of file
++echo @@HOMEBREW_PREFIX@@
+\ No newline at end of file
diff --git a/Library/Homebrew/test/support/fixtures/receipt.json b/Library/Homebrew/test/support/fixtures/receipt.json
index 6907ae040c5a2..c51ec4d08f182 100644
--- a/Library/Homebrew/test/support/fixtures/receipt.json
+++ b/Library/Homebrew/test/support/fixtures/receipt.json
@@ -10,6 +10,9 @@
   ],
   "built_as_bottle": false,
   "poured_from_bottle": true,
+  "loaded_from_api": false,
+  "installed_as_dependency": false,
+  "installed_on_request": true,
   "changed_files": [
     "INSTALL_RECEIPT.json",
     "bin/foo"
@@ -27,12 +30,12 @@
     }
   ],
   "source": {
-      "path": "/usr/local/Library/Taps/homebrew/homebrew-core/Formula/foo.rb",
-      "tap": "homebrew/core",
-      "spec": "stable",
-      "versions": {
-        "stable": "2.14",
-        "head": "HEAD-0000000"
-      }
+    "path": "/usr/local/Library/Taps/homebrew/homebrew-core/Formula/foo.rb",
+    "tap": "homebrew/core",
+    "spec": "stable",
+    "versions": {
+      "stable": "2.14",
+      "head": "HEAD-0000000"
+    }
   }
 }
diff --git a/Library/Homebrew/test/support/fixtures/testball.rb b/Library/Homebrew/test/support/fixtures/testball.rb
index 1a99de2914c0c..94988d5692aac 100644
--- a/Library/Homebrew/test/support/fixtures/testball.rb
+++ b/Library/Homebrew/test/support/fixtures/testball.rb
@@ -3,14 +3,23 @@
 
 class Testball < Formula
   def initialize(name = "testball", path = Pathname.new(__FILE__).expand_path, spec = :stable,
-                 alias_path: nil, force_bottle: false)
-    self.class.instance_eval do
-      stable.url "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz"
-      stable.sha256 TESTBALL_SHA256
-    end
+                 alias_path: nil, tap: nil, force_bottle: false)
     super
   end
 
+  DSL_PROC = proc do
+    url "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz"
+    sha256 TESTBALL_SHA256
+  end.freeze
+  private_constant :DSL_PROC
+
+  DSL_PROC.call
+
+  def self.inherited(other)
+    super
+    other.instance_eval(&DSL_PROC)
+  end
+
   def install
     prefix.install "bin"
     prefix.install "libexec"
diff --git a/Library/Homebrew/test/support/fixtures/testball_bottle.rb b/Library/Homebrew/test/support/fixtures/testball_bottle.rb
index d6b777996af73..986b5f02b077e 100644
--- a/Library/Homebrew/test/support/fixtures/testball_bottle.rb
+++ b/Library/Homebrew/test/support/fixtures/testball_bottle.rb
@@ -3,17 +3,28 @@
 
 class TestballBottle < Formula
   def initialize(name = "testball_bottle", path = Pathname.new(__FILE__).expand_path, spec = :stable,
-                 alias_path: nil, force_bottle: false)
-    self.class.instance_eval do
-      stable.url "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz"
-      stable.sha256 TESTBALL_SHA256
-      stable.bottle do
-        root_url "file://#{TEST_FIXTURE_DIR}/bottles"
-        sha256 cellar: :any_skip_relocation, Utils::Bottles.tag.to_sym => "8f9aecd233463da6a4ea55f5f88fc5841718c013f3e2a7941350d6130f1dc149"
-      end
-      cxxstdlib_check :skip
+                 alias_path: nil, tap: nil, force_bottle: false)
+    super
+  end
+
+  DSL_PROC = proc do
+    url "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz"
+    sha256 TESTBALL_SHA256
+
+    bottle do
+      root_url "file://#{TEST_FIXTURE_DIR}/bottles"
+      sha256 cellar: :any_skip_relocation, Utils::Bottles.tag.to_sym => "d7b9f4e8bf83608b71fe958a99f19f2e5e68bb2582965d32e41759c24f1aef97"
     end
+
+    cxxstdlib_check :skip
+  end.freeze
+  private_constant :DSL_PROC
+
+  DSL_PROC.call
+
+  def self.inherited(other)
     super
+    other.instance_eval(&DSL_PROC)
   end
 
   def install
diff --git a/Library/Homebrew/test/support/fixtures/testball_bottle_cellar.rb b/Library/Homebrew/test/support/fixtures/testball_bottle_cellar.rb
index 58bd8edfeb015..b0973b8a51e25 100644
--- a/Library/Homebrew/test/support/fixtures/testball_bottle_cellar.rb
+++ b/Library/Homebrew/test/support/fixtures/testball_bottle_cellar.rb
@@ -3,18 +3,28 @@
 
 class TestballBottleCellar < Formula
   def initialize(name = "testball_bottle", path = Pathname.new(__FILE__).expand_path, spec = :stable,
-                 alias_path: nil, force_bottle: false)
-    self.class.instance_eval do
-      stable.url "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz"
-      stable.sha256 TESTBALL_SHA256
-      hexdigest = "8f9aecd233463da6a4ea55f5f88fc5841718c013f3e2a7941350d6130f1dc149"
-      stable.bottle do
-        root_url "file://#{TEST_FIXTURE_DIR}/bottles"
-        sha256 cellar: :any_skip_relocation, Utils::Bottles.tag.to_sym => hexdigest
-      end
-      cxxstdlib_check :skip
+                 alias_path: nil, tap: nil, force_bottle: false)
+    super
+  end
+
+  DSL_PROC = proc do
+    url "file://#{TEST_FIXTURE_DIR}/tarballs/testball-0.1.tbz"
+    sha256 TESTBALL_SHA256
+
+    bottle do
+      root_url "file://#{TEST_FIXTURE_DIR}/bottles"
+      sha256 cellar: :any_skip_relocation, Utils::Bottles.tag.to_sym => "d7b9f4e8bf83608b71fe958a99f19f2e5e68bb2582965d32e41759c24f1aef97"
     end
+
+    cxxstdlib_check :skip
+  end.freeze
+  private_constant :DSL_PROC
+
+  DSL_PROC.call
+
+  def self.inherited(other)
     super
+    other.instance_eval(&DSL_PROC)
   end
 
   def install
diff --git a/Library/Homebrew/test/support/helper/cask.rb b/Library/Homebrew/test/support/helper/cask.rb
index 6dd863daab29f..fa5ee7a65b7e2 100644
--- a/Library/Homebrew/test/support/helper/cask.rb
+++ b/Library/Homebrew/test/support/helper/cask.rb
@@ -1,4 +1,3 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cask/cask_loader"
@@ -9,8 +8,8 @@ module Cask
       def stub_cask_loader(cask, ref = cask.token, call_original: false)
         allow(::Cask::CaskLoader).to receive(:for).and_call_original if call_original
 
-        loader = ::Cask::CaskLoader::FromInstanceLoader.new cask
-        allow(::Cask::CaskLoader).to receive(:for).with(ref).and_return(loader)
+        loader = ::Cask::CaskLoader::FromInstanceLoader.new(cask)
+        allow(::Cask::CaskLoader).to receive(:for).with(ref, any_args).and_return(loader)
       end
     end
   end
diff --git a/Library/Homebrew/test/support/helper/cask/never_sudo_system_command.rb b/Library/Homebrew/test/support/helper/cask/never_sudo_system_command.rb
index b5859c174eeef..84f3b2035aad2 100644
--- a/Library/Homebrew/test/support/helper/cask/never_sudo_system_command.rb
+++ b/Library/Homebrew/test/support/helper/cask/never_sudo_system_command.rb
@@ -4,7 +4,7 @@
 require "system_command"
 
 class NeverSudoSystemCommand < SystemCommand
-  def self.run(command, options = {})
-    super(command, options.merge(sudo: false))
+  def self.run(command, **options)
+    super(command, **options.merge(sudo: false, sudo_as_root: false))
   end
 end
diff --git a/Library/Homebrew/test/support/helper/cmd/brew-verify-formula-undefined.rb b/Library/Homebrew/test/support/helper/cmd/brew-verify-formula-undefined.rb
deleted file mode 100755
index 3b08180cd1212..0000000000000
--- a/Library/Homebrew/test/support/helper/cmd/brew-verify-formula-undefined.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "cli/parser"
-
-parser = Homebrew::CLI::Parser.new do
-  usage_banner <<~EOS
-    `verify-formula-undefined`
-
-    Verifies that `require "formula"` has not been performed at startup.
-  EOS
-end
-
-parser.parse
-
-Homebrew.failed = defined?(Formula) && Formula.respond_to?(:[])
diff --git a/Library/Homebrew/test/support/helper/cmd/brew-verify-undefined.rb b/Library/Homebrew/test/support/helper/cmd/brew-verify-undefined.rb
new file mode 100755
index 0000000000000..2939e93e02771
--- /dev/null
+++ b/Library/Homebrew/test/support/helper/cmd/brew-verify-undefined.rb
@@ -0,0 +1,80 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "cli/parser"
+
+UNDEFINED_CONSTANTS = %w[
+  AbstractDownloadStrategy
+  Addressable
+  Base64
+  CacheStore
+  Cask::Cask
+  Cask::CaskLoader
+  Completions
+  CSV
+  Formula
+  Formulary
+  GitRepository
+  Homebrew::API
+  Homebrew::Manpages
+  Homebrew::Settings
+  JSONSchemer
+  Kramdown
+  Metafiles
+  MethodSource
+  Minitest
+  Nokogiri
+  OS::Mac::Version
+  PatchELF
+  Pry
+  ProgressBar
+  REXML
+  Red
+  RSpec
+  RuboCop
+  StackProf
+  Spoom
+  Tap
+  Tapioca
+  UnpackStrategy
+  Utils::Analytics
+  Utils::Backtrace
+  Utils::Bottles
+  Utils::Curl
+  Utils::Fork
+  Utils::Git
+  Utils::GitHub
+  Utils::Link
+  Utils::Svn
+  Uri
+  Vernier
+  YARD
+].freeze
+
+module Homebrew
+  module Cmd
+    class VerifyUndefined < AbstractCommand
+    end
+  end
+end
+
+parser = Homebrew::CLI::Parser.new(Homebrew::Cmd::VerifyUndefined) do
+  usage_banner <<~EOS
+    `verify-undefined`
+
+    Verifies that the following constants have not been defined
+    at startup to make sure that startup times stay consistent.
+
+    Contants:
+    #{UNDEFINED_CONSTANTS.join("\n")}
+  EOS
+end
+
+parser.parse
+
+UNDEFINED_CONSTANTS.each do |constant_name|
+  Object.const_get(constant_name)
+  ofail "#{constant_name} should not be defined at startup"
+rescue NameError
+  # We expect this to error as it should not be defined.
+end
diff --git a/Library/Homebrew/test/support/helper/files.rb b/Library/Homebrew/test/support/helper/files.rb
new file mode 100644
index 0000000000000..79dd66199c755
--- /dev/null
+++ b/Library/Homebrew/test/support/helper/files.rb
@@ -0,0 +1,17 @@
+# typed: true
+# frozen_string_literal: true
+
+module Test
+  module Helper
+    module Files
+      def self.find_files
+        return [] unless File.exist?(TEST_TMPDIR)
+
+        Find.find(TEST_TMPDIR)
+            .reject { |f| File.basename(f) == ".DS_Store" }
+            .reject { |f| TEST_DIRECTORIES.include?(Pathname(f)) }
+            .map { |f| f.sub(TEST_TMPDIR, "") }
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/test/support/helper/formula.rb b/Library/Homebrew/test/support/helper/formula.rb
index 256ef05e54e4d..fb24c36b26fd9 100644
--- a/Library/Homebrew/test/support/helper/formula.rb
+++ b/Library/Homebrew/test/support/helper/formula.rb
@@ -1,4 +1,3 @@
-# typed: false
 # frozen_string_literal: true
 
 require "formulary"
@@ -6,8 +5,9 @@
 module Test
   module Helper
     module Formula
-      def formula(name = "formula_name", path: Formulary.core_path(name), spec: :stable, alias_path: nil, &block)
-        Class.new(::Formula, &block).new(name, path, spec, alias_path: alias_path)
+      def formula(name = "formula_name", path: nil, spec: :stable, alias_path: nil, tap: nil, &block)
+        path ||= Formulary.find_formula_in_tap(name, tap || CoreTap.instance)
+        Class.new(::Formula, &block).new(name, path, spec, alias_path:, tap:)
       end
 
       # Use a stubbed {Formulary::FormulaLoader} to make a given formula be found
@@ -15,9 +15,8 @@ def formula(name = "formula_name", path: Formulary.core_path(name), spec: :stabl
       def stub_formula_loader(formula, ref = formula.full_name, call_original: false)
         allow(Formulary).to receive(:loader_for).and_call_original if call_original
 
-        loader = double(get_formula: formula)
-        allow(Formulary).to receive(:loader_for).with(ref, from: :keg).and_return(loader)
-        allow(Formulary).to receive(:loader_for).with(ref, from: nil).and_return(loader)
+        loader = instance_double(Formulary::FormulaLoader, get_formula: formula)
+        allow(Formulary).to receive(:loader_for).with(ref, any_args).and_return(loader)
       end
     end
   end
diff --git a/Library/Homebrew/test/support/helper/integration_mocks.rb b/Library/Homebrew/test/support/helper/integration_mocks.rb
index 245a2aef0eacb..13e19d0116967 100644
--- a/Library/Homebrew/test/support/helper/integration_mocks.rb
+++ b/Library/Homebrew/test/support/helper/integration_mocks.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true
 # frozen_string_literal: true
 
 module Homebrew
diff --git a/Library/Homebrew/test/support/helper/mktmpdir.rb b/Library/Homebrew/test/support/helper/mktmpdir.rb
index f6cc4282c9ee7..6cb369c4142c9 100644
--- a/Library/Homebrew/test/support/helper/mktmpdir.rb
+++ b/Library/Homebrew/test/support/helper/mktmpdir.rb
@@ -1,4 +1,3 @@
-# typed: false
 # frozen_string_literal: true
 
 module Test
diff --git a/Library/Homebrew/test/support/helper/output_as_tty.rb b/Library/Homebrew/test/support/helper/output_as_tty.rb
deleted file mode 100644
index 1e1dea10da31b..0000000000000
--- a/Library/Homebrew/test/support/helper/output_as_tty.rb
+++ /dev/null
@@ -1,89 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "delegate"
-
-module Test
-  module Helper
-    module OutputAsTTY
-      # This is a custom wrapper for the `output` matcher,
-      # used for testing output to a TTY:
-      #
-      #   expect {
-      #     print "test" if $stdout.tty?
-      #   }.to output("test").to_stdout.as_tty
-      #
-      #   expect {
-      #     # command
-      #   }.to output(...).to_stderr.as_tty.with_color
-      #
-      class Output < SimpleDelegator
-        def matches?(block)
-          return super(block) unless @tty
-
-          colored_tty_block = lambda do
-            instance_eval("$#{@output}  # $stdout", __FILE__, __LINE__).extend(Module.new do
-              def tty?
-                true
-              end
-
-              alias_method :isatty, :tty?
-            end)
-            block.call
-          end
-
-          return super(colored_tty_block) if @colors
-
-          uncolored_tty_block = lambda do
-            instance_eval <<-EOS, __FILE__, __LINE__ + 1
-              begin                                                       # begin
-                captured_stream = StringIO.new                            #   captured_stream = StringIO.new
-
-                original_stream = $#{@output}                             #   original_stream = $stdout
-                $#{@output} = captured_stream                             #   $stdout = captured_stream
-
-                colored_tty_block.call                                    #   colored_tty_block.call
-              ensure                                                      # ensure
-                $#{@output} = original_stream                             #   $stdout = original_stream
-                $#{@output}.print Tty.strip_ansi(captured_stream.string)  #   $stdout.print Tty.strip_ansi(captured_stream.string)
-              end                                                         # end
-            EOS
-          end
-
-          super(uncolored_tty_block)
-        end
-
-        def to_stdout
-          @output = :stdout
-          super
-          self
-        end
-
-        def to_stderr
-          @output = :stderr
-          super
-          self
-        end
-
-        def as_tty
-          @tty = true
-          return self if [:stdout, :stderr].include?(@output)
-
-          raise "`as_tty` can only be chained to `stdout` or `stderr`."
-        end
-
-        def with_color
-          @colors = true
-          return self if @tty
-
-          raise "`with_color` can only be chained to `as_tty`."
-        end
-      end
-
-      def output(*args)
-        core_matcher = super(*args)
-        Output.new(core_matcher)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/test/support/helper/spec/shared_context/homebrew_cask.rb b/Library/Homebrew/test/support/helper/spec/shared_context/homebrew_cask.rb
index 4058dd0ac2db0..b62d783305eef 100644
--- a/Library/Homebrew/test/support/helper/spec/shared_context/homebrew_cask.rb
+++ b/Library/Homebrew/test/support/helper/spec/shared_context/homebrew_cask.rb
@@ -1,4 +1,3 @@
-# typed: false
 # frozen_string_literal: true
 
 require "cask/config"
@@ -11,6 +10,7 @@ module Cask
   class Config
     DEFAULT_DIRS_PATHNAMES = {
       appdir:               Pathname(TEST_TMPDIR)/"cask-appdir",
+      keyboard_layoutdir:   Pathname(TEST_TMPDIR)/"cask-keyboard-layoutdir",
       prefpanedir:          Pathname(TEST_TMPDIR)/"cask-prefpanedir",
       qlplugindir:          Pathname(TEST_TMPDIR)/"cask-qlplugindir",
       mdimporterdir:        Pathname(TEST_TMPDIR)/"cask-mdimporter",
@@ -36,24 +36,37 @@ class Config
     third_party_tap = Tap.fetch("third-party", "tap")
 
     begin
-      Cask::Config::DEFAULT_DIRS_PATHNAMES.values.each(&:mkpath)
+      Cask::Config::DEFAULT_DIRS_PATHNAMES.each_value(&:mkpath)
 
-      Tap.default_cask_tap.tap do |tap|
-        FileUtils.mkdir_p tap.path.dirname
-        FileUtils.ln_sf TEST_FIXTURE_DIR.join("cask"), tap.path
+      CoreCaskTap.instance.tap do |tap|
+        fixture_cask_dir = TEST_FIXTURE_DIR/"cask/Casks"
+        fixture_cask_dir.glob("**/*.rb").each do |fixture_cask_path|
+          relative_cask_path = fixture_cask_path.relative_path_from(fixture_cask_dir)
+
+          # These are only used manually in tests since they
+          # would otherwise conflict with other casks.
+          next if relative_cask_path.dirname.basename.to_s == "outdated"
+
+          cask_dir = (tap.cask_dir/relative_cask_path.dirname).tap(&:mkpath)
+          FileUtils.ln_sf fixture_cask_path, cask_dir
+        end
+
+        tap.clear_cache
       end
 
       third_party_tap.tap do |tap|
-        FileUtils.mkdir_p tap.path.dirname
-        FileUtils.ln_sf TEST_FIXTURE_DIR.join("third-party"), tap.path
+        tap.path.parent.mkpath
+        FileUtils.ln_sf TEST_FIXTURE_DIR/"third-party", tap.path
+
+        tap.clear_cache
       end
 
       example.run
     ensure
       FileUtils.rm_rf Cask::Config::DEFAULT_DIRS_PATHNAMES.values
       FileUtils.rm_rf [Cask::Config.new.binarydir, Cask::Caskroom.path, Cask::Cache.path]
-      Tap.default_cask_tap.path.unlink
-      third_party_tap.path.unlink
+      FileUtils.rm_rf CoreCaskTap.instance.path
+      FileUtils.rm_rf third_party_tap.path
       FileUtils.rm_rf third_party_tap.path.parent
     end
   end
diff --git a/Library/Homebrew/test/support/helper/spec/shared_context/integration_test.rb b/Library/Homebrew/test/support/helper/spec/shared_context/integration_test.rb
index b8282283701ec..21d23905f87af 100644
--- a/Library/Homebrew/test/support/helper/spec/shared_context/integration_test.rb
+++ b/Library/Homebrew/test/support/helper/spec/shared_context/integration_test.rb
@@ -1,4 +1,3 @@
-# typed: false
 # frozen_string_literal: true
 
 require "open3"
@@ -43,23 +42,21 @@ def expects_call_stack_jump?
   end
 
   around do |example|
+    ENV["HOMEBREW_INTEGRATION_TEST"] = "1"
     (HOMEBREW_PREFIX/"bin").mkpath
     FileUtils.touch HOMEBREW_PREFIX/"bin/brew"
 
     example.run
   ensure
     FileUtils.rm_rf HOMEBREW_PREFIX/"bin"
+    ENV.delete("HOMEBREW_INTEGRATION_TEST")
   end
 
   # Generate unique ID to be able to
   # properly merge coverage results.
-  def command_id_from_args(args)
-    @command_count ||= 0
-    pretty_args = args.join(" ").gsub(TEST_TMPDIR, "@TMPDIR@")
-    file_and_line = caller.second
-                          .sub(/(.*\d+):.*/, '\1')
-                          .sub("#{HOMEBREW_LIBRARY_PATH}/test/", "")
-    "#{file_and_line}:brew #{pretty_args}:#{@command_count += 1}"
+  def command_id
+    Thread.current[:brew_integration_test_number] ||= 0
+    "#{ENV.fetch("TEST_ENV_NUMBER", "")}:#{Thread.current[:brew_integration_test_number] += 1}"
   end
 
   # Runs a `brew` command with the test configuration
@@ -77,13 +74,14 @@ def brew(*args)
     ].compact.join(File::PATH_SEPARATOR)
 
     env.merge!(
-      "PATH"                      => path,
-      "HOMEBREW_PATH"             => path,
-      "HOMEBREW_BREW_FILE"        => HOMEBREW_PREFIX/"bin/brew",
-      "HOMEBREW_INTEGRATION_TEST" => command_id_from_args(args),
-      "HOMEBREW_TEST_TMPDIR"      => TEST_TMPDIR,
-      "HOMEBREW_DEV_CMD_RUN"      => "true",
-      "GEM_HOME"                  => nil,
+      "PATH"                        => path,
+      "HOMEBREW_PATH"               => path,
+      "HOMEBREW_BREW_FILE"          => HOMEBREW_PREFIX/"bin/brew",
+      "HOMEBREW_INTEGRATION_TEST"   => command_id,
+      "HOMEBREW_TEST_TMPDIR"        => TEST_TMPDIR,
+      "HOMEBREW_DEV_CMD_RUN"        => "true",
+      "HOMEBREW_USE_RUBY_FROM_PATH" => ENV.fetch("HOMEBREW_USE_RUBY_FROM_PATH", nil),
+      "GEM_HOME"                    => nil,
     )
 
     @ruby_args ||= begin
@@ -100,24 +98,19 @@ def brew(*args)
             onoe e
           end
         end
-        libs = specs.flat_map do |spec|
-          full_gem_path = spec.full_gem_path
-          # full_require_paths isn't available in RubyGems < 2.2.
-          spec.require_paths.map do |lib|
-            next lib if lib.include?(full_gem_path)
-
-            "#{full_gem_path}/#{lib}"
-          end
-        end
-        libs.each { |lib| ruby_args << "-I" << lib }
+        specs.flat_map(&:full_require_paths).each { |lib| ruby_args << "-I" << lib }
         ruby_args << "-rsimplecov"
       end
       ruby_args << "-r#{HOMEBREW_LIBRARY_PATH}/test/support/helper/integration_mocks"
+      ruby_args << "-e" << "$0 = ARGV.shift; load($0)"
       ruby_args << (HOMEBREW_LIBRARY_PATH/"brew.rb").resolved_path.to_s
     end
 
-    Bundler.with_clean_env do
+    Bundler.with_unbundled_env do
+      # Allow instance variable here to improve performance through memoization.
+      # rubocop:disable RSpec/InstanceVariable
       stdout, stderr, status = Open3.capture3(env, *@ruby_args, *args)
+      # rubocop:enable RSpec/InstanceVariable
       $stdout.print stdout
       $stderr.print stderr
       status
@@ -125,15 +118,19 @@ def brew(*args)
   end
 
   def brew_sh(*args)
-    Bundler.with_clean_env do
-      stdout, stderr, status = Open3.capture3("#{ENV.fetch("HOMEBREW_PREFIX")}/bin/brew", *args)
+    env = {
+      "HOMEBREW_USE_RUBY_FROM_PATH" => ENV.fetch("HOMEBREW_USE_RUBY_FROM_PATH", nil),
+    }
+    Bundler.with_unbundled_env do
+      stdout, stderr, status = Open3.capture3(env, "#{ENV.fetch("HOMEBREW_PREFIX")}/bin/brew", *args)
       $stdout.print stdout
       $stderr.print stderr
       status
     end
   end
 
-  def setup_test_formula(name, content = nil, bottle_block: nil)
+  def setup_test_formula(name, content = nil, tap: CoreTap.instance,
+                         bottle_block: nil, tab_attributes: nil)
     case name
     when /^testball/
       tarball = if OS.linux?
@@ -162,10 +159,6 @@ def install
 
         # something here
       RUBY
-    when "foo", "gnupg"
-      content = <<~RUBY
-        url "https://brew.sh/#{name}-1.0"
-      RUBY
     when "bar"
       content = <<~RUBY
         url "https://brew.sh/#{name}-1.0"
@@ -176,20 +169,40 @@ def install
         url "https://brew.sh/#patchelf-1.0"
         license "0BSD"
       RUBY
+    else
+      content ||= <<~RUBY
+        url "https://brew.sh/#{name}-1.0"
+      RUBY
     end
 
-    Formulary.core_path(name).tap do |formula_path|
-      formula_path.write <<~RUBY
+    formula_path = Formulary.find_formula_in_tap(name.downcase, tap).tap do |path|
+      path.write <<~RUBY
         class #{Formulary.class_s(name)} < Formula
-        #{content.indent(2)}
+        #{content.gsub(/^(?!$)/, "  ")}
         end
       RUBY
+
+      tap.clear_cache
     end
+
+    return formula_path if tab_attributes.nil?
+
+    keg = Formula[name].prefix
+    keg.mkpath
+
+    tab = Tab.for_name(name)
+    tab.tabfile ||= keg/AbstractTab::FILENAME
+    tab_attributes.each do |key, value|
+      tab.instance_variable_set(:"@#{key}", value)
+    end
+    tab.write
+
+    formula_path
   end
 
   def install_test_formula(name, content = nil, build_bottle: false)
     setup_test_formula(name, content)
-    fi = FormulaInstaller.new(Formula[name], build_bottle: build_bottle)
+    fi = FormulaInstaller.new(Formula[name], build_bottle:)
     fi.prelude
     fi.fetch
     fi.install
@@ -197,7 +210,7 @@ def install_test_formula(name, content = nil, build_bottle: false)
   end
 
   def setup_test_tap
-    path = Tap::TAP_DIRECTORY/"homebrew/homebrew-foo"
+    path = HOMEBREW_TAP_DIRECTORY/"homebrew/homebrew-foo"
     path.mkpath
     path.cd do
       system "git", "init"
diff --git a/Library/Homebrew/test/support/helper/spec/shared_examples/formulae_exist.rb b/Library/Homebrew/test/support/helper/spec/shared_examples/formulae_exist.rb
index e52610016fc31..184c34b541a6e 100644
--- a/Library/Homebrew/test/support/helper/spec/shared_examples/formulae_exist.rb
+++ b/Library/Homebrew/test/support/helper/spec/shared_examples/formulae_exist.rb
@@ -1,13 +1,12 @@
-# typed: false
 # frozen_string_literal: true
 
-shared_examples "formulae exist" do |array|
+RSpec.shared_examples "formulae exist" do |array|
   array.each do |f|
-    it "#{f} formula exists" do
+    it "#{f} formula exists", :needs_homebrew_core do
       core_tap = Pathname("#{HOMEBREW_LIBRARY_PATH}/../Taps/homebrew/homebrew-core")
-      formula_path = core_tap/"Formula/#{f}.rb"
+      formula_paths = core_tap.glob("Formula/**/#{f}.rb")
       alias_path = core_tap/"Aliases/#{f}"
-      expect(formula_path.exist? || alias_path.exist?).to be true
+      expect(formula_paths.any?(&:exist?) || alias_path.exist?).to be true
     end
   end
 end
diff --git a/Library/Homebrew/test/support/lib/default_prefix.rb b/Library/Homebrew/test/support/lib/default_prefix.rb
deleted file mode 100644
index e912bd4831520..0000000000000
--- a/Library/Homebrew/test/support/lib/default_prefix.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module Homebrew
-  # For testing's sake always assume the default prefix
-  DEFAULT_PREFIX = HOMEBREW_PREFIX.to_s.freeze
-  DEFAULT_REPOSITORY = HOMEBREW_REPOSITORY.to_s.freeze
-end
diff --git a/Library/Homebrew/test/support/lib/startup/config.rb b/Library/Homebrew/test/support/lib/startup/config.rb
index b748525955b3e..a5c858723bceb 100644
--- a/Library/Homebrew/test/support/lib/startup/config.rb
+++ b/Library/Homebrew/test/support/lib/startup/config.rb
@@ -9,7 +9,7 @@
   dir = Dir.mktmpdir("homebrew-tests-", ENV.fetch("HOMEBREW_TEMP"))
   at_exit do
     # Child processes inherit this at_exit handler, but we don't want them
-    # to clean TEST_TMPDIR up prematurely (i.e., when they exit early for a test).
+    # to clean TEST_TMPDIR up prematurely (i.e. when they exit early for a test).
     FileUtils.remove_entry(dir) unless ENV["HOMEBREW_TEST_NO_EXIT_CLEANUP"]
   end
   ENV[k] = dir
@@ -33,9 +33,11 @@
 HOMEBREW_CELLAR        = (HOMEBREW_PREFIX.parent/"cellar").freeze
 HOMEBREW_LOGS          = (HOMEBREW_PREFIX.parent/"logs").freeze
 HOMEBREW_TEMP          = (HOMEBREW_PREFIX.parent/"temp").freeze
+HOMEBREW_TAP_DIRECTORY = (HOMEBREW_LIBRARY/"Taps").freeze
 HOMEBREW_RUBY_EXEC_ARGS = [
   RUBY_PATH,
   ENV.fetch("HOMEBREW_RUBY_WARNINGS"),
+  ENV.fetch("HOMEBREW_RUBY_DISABLE_OPTIONS"),
   "-I", HOMEBREW_LIBRARY_PATH/"test/support/lib"
 ].freeze
 
@@ -45,6 +47,6 @@
 TESTBALL_PATCHES_SHA256 = "799c2d551ac5c3a5759bea7796631a7906a6a24435b52261a317133a0bfb34d9"
 PATCH_A_SHA256 = "83404f4936d3257e65f176c4ffb5a5b8d6edd644a21c8d8dcc73e22a6d28fcfa"
 PATCH_B_SHA256 = "57958271bb802a59452d0816e0670d16c8b70bdf6530bcf6f78726489ad89b90"
+PATCH_D_SHA256 = "07c72c4463339e6e2ce235f3b26e316d4940017bf4b5236e27e757a44d67636c"
 
-TEST_SHA1   = "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"
 TEST_SHA256 = "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"
diff --git a/Library/Homebrew/test/support/no_seed_progress_formatter.rb b/Library/Homebrew/test/support/no_seed_progress_formatter.rb
deleted file mode 100644
index 493883e8b9d1e..0000000000000
--- a/Library/Homebrew/test/support/no_seed_progress_formatter.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "rspec/core/formatters/progress_formatter"
-
-class NoSeedProgressFormatter < RSpec::Core::Formatters::ProgressFormatter
-  RSpec::Core::Formatters.register self, :seed
-
-  def seed(notification); end
-end
diff --git a/Library/Homebrew/test/support/quiet_progress_formatter.rb b/Library/Homebrew/test/support/quiet_progress_formatter.rb
new file mode 100644
index 0000000000000..d122fca2b7a9e
--- /dev/null
+++ b/Library/Homebrew/test/support/quiet_progress_formatter.rb
@@ -0,0 +1,12 @@
+# typed: true
+# frozen_string_literal: true
+
+require "rspec/core/formatters/progress_formatter"
+
+class QuietProgressFormatter < RSpec::Core::Formatters::ProgressFormatter
+  RSpec::Core::Formatters.register self, :seed
+
+  def dump_summary(notification); end
+  def seed(notification); end
+  def close(notification); end
+end
diff --git a/Library/Homebrew/test/system_command_result_spec.rb b/Library/Homebrew/test/system_command_result_spec.rb
index fd82a100bf841..d06df27fd8b50 100644
--- a/Library/Homebrew/test/system_command_result_spec.rb
+++ b/Library/Homebrew/test/system_command_result_spec.rb
@@ -1,20 +1,21 @@
-# typed: false
 # frozen_string_literal: true
 
 require "system_command"
 
-describe SystemCommand::Result do
-  subject(:result) {
+RSpec.describe SystemCommand::Result do
+  RSpec::Matchers.alias_matcher :a_string_containing, :include
+
+  subject(:result) do
     described_class.new([], output_array, instance_double(Process::Status, exitstatus: 0, success?: true),
                         secrets: [])
-  }
+  end
 
-  let(:output_array) {
+  let(:output_array) do
     [
       [:stdout, "output\n"],
       [:stderr, "error\n"],
     ]
-  }
+  end
 
   describe "#to_ary" do
     it "can be destructed like `Open3.capture3`" do
@@ -48,7 +49,7 @@
     subject(:result_plist) { result.plist }
 
     let(:output_array) { [[:stdout, stdout]] }
-    let(:garbage) {
+    let(:garbage) do
       <<~EOS
         Hello there! I am in no way XML am I?!?!
 
@@ -58,8 +59,8 @@
 
         Hopefully <not> explode!
       EOS
-    }
-    let(:plist) {
+    end
+    let(:plist) do
       <<~XML
         <?xml version="1.0" encoding="UTF-8"?>
         <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -105,15 +106,15 @@
         </dict>
         </plist>
       XML
-    }
+    end
 
     context "when stdout contains garbage before XML" do
-      let(:stdout) {
+      let(:stdout) do
         <<~EOS
           #{garbage}
           #{plist}
         EOS
-      }
+      end
 
       it "ignores garbage" do
         expect(result_plist["system-entities"].length).to eq(3)
@@ -132,12 +133,12 @@
     end
 
     context "when stdout contains garbage after XML" do
-      let(:stdout) {
+      let(:stdout) do
         <<~EOS
           #{plist}
           #{garbage}
         EOS
-      }
+      end
 
       it "ignores garbage" do
         expect(result_plist["system-entities"].length).to eq(3)
diff --git a/Library/Homebrew/test/system_command_spec.rb b/Library/Homebrew/test/system_command_spec.rb
index 3a3f7b2ce0030..445dd30184df5 100644
--- a/Library/Homebrew/test/system_command_spec.rb
+++ b/Library/Homebrew/test/system_command_spec.rb
@@ -1,31 +1,34 @@
-# typed: false
 # frozen_string_literal: true
 
-describe SystemCommand do
+require "system_command"
+
+RSpec.describe SystemCommand do
   describe "#initialize" do
-    subject(:command) {
+    subject(:command) do
       described_class.new(
         "env",
         args:         env_args,
-        env:          env,
+        env:,
         must_succeed: true,
-        sudo:         sudo,
+        sudo:,
+        sudo_as_root:,
       )
-    }
+    end
 
     let(:env_args) { ["bash", "-c", 'printf "%s" "${A?}" "${B?}" "${C?}"'] }
     let(:env) { { "A" => "1", "B" => "2", "C" => "3" } }
     let(:sudo) { false }
+    let(:sudo_as_root) { false }
 
     context "when given some environment variables" do
-      its("run!.stdout") { is_expected.to eq("123") }
+      it("run!.stdout") { expect(command.run!.stdout).to eq("123") }
 
       describe "the resulting command line" do
         it "includes the given variables explicitly" do
-          expect(Open3)
-            .to receive(:popen3)
+          expect(command)
+            .to receive(:exec3)
             .with(
-              an_instance_of(Hash), ["/usr/bin/env", "/usr/bin/env"], "A=1", "B=2", "C=3",
+              an_instance_of(Hash), "/usr/bin/env", "A=1", "B=2", "C=3",
               "env", *env_args,
               pgroup: true
             )
@@ -40,25 +43,47 @@
       let(:env) { { "A" => "1", "B" => "2", "C" => nil } }
 
       it "unsets them" do
-        expect {
+        expect do
           command.run!
-        }.to raise_error(/C: parameter (null or )?not set/)
+        end.to raise_error(/C: parameter (null or )?not set/)
       end
     end
 
-    context "when given some environment variables and sudo: true" do
+    context "when given some environment variables and sudo: true, sudo_as_root: false" do
       let(:sudo) { true }
+      let(:sudo_as_root) { false }
 
       describe "the resulting command line" do
         it "includes the given variables explicitly" do
-          expect(Open3)
-            .to receive(:popen3)
+          expect(command)
+            .to receive(:exec3)
             .with(
-              an_instance_of(Hash), ["/usr/bin/sudo", "/usr/bin/sudo"], "-E", "--",
-              "/usr/bin/env", "A=1", "B=2", "C=3", "env", *env_args, pgroup: nil
+              an_instance_of(Hash), "/usr/bin/sudo", "-E",
+              "A=1", "B=2", "C=3", "--", "env", *env_args, pgroup: nil
             )
-            .and_wrap_original do |original_popen3, *_, &block|
-              original_popen3.call("true", &block)
+            .and_wrap_original do |original_exec3, *_, &block|
+              original_exec3.call({}, "true", &block)
+            end
+
+          command.run!
+        end
+      end
+    end
+
+    context "when given some environment variables and sudo: true, sudo_as_root: true" do
+      let(:sudo) { true }
+      let(:sudo_as_root) { true }
+
+      describe "the resulting command line" do
+        it "includes the given variables explicitly" do
+          expect(command)
+            .to receive(:exec3)
+            .with(
+              an_instance_of(Hash), "/usr/bin/sudo", "-u", "root",
+              "-E", "A=1", "B=2", "C=3", "--", "env", *env_args, pgroup: nil
+            )
+            .and_wrap_original do |original_exec3, *_, &block|
+              original_exec3.call({}, "true", &block)
             end
 
           command.run!
@@ -69,10 +94,10 @@
 
   context "when the exit code is 0" do
     describe "its result" do
-      subject { described_class.run("true") }
+      subject(:result) { described_class.run("true") }
 
       it { is_expected.to be_a_success }
-      its(:exit_status) { is_expected.to eq(0) }
+      it(:exit_status) { expect(result.exit_status).to eq(0) }
     end
   end
 
@@ -81,18 +106,18 @@
 
     context "with a command that must succeed" do
       it "throws an error" do
-        expect {
+        expect do
           described_class.run!(command)
-        }.to raise_error(ErrorDuringExecution)
+        end.to raise_error(ErrorDuringExecution)
       end
     end
 
     context "with a command that does not have to succeed" do
       describe "its result" do
-        subject { described_class.run(command) }
+        subject(:result) { described_class.run(command) }
 
         it { is_expected.not_to be_a_success }
-        its(:exit_status) { is_expected.to eq(1) }
+        it(:exit_status) { expect(result.exit_status).to eq(1) }
       end
     end
   end
@@ -106,50 +131,50 @@
     end
 
     describe "its result" do
-      subject { described_class.run(command, args: [path]) }
+      subject(:result) { described_class.run(command, args: [path]) }
 
       it { is_expected.to be_a_success }
-      its(:stdout) { is_expected.to eq("somefile\n") }
+      it(:stdout) { expect(result.stdout).to eq("somefile\n") }
     end
   end
 
   context "with both STDOUT and STDERR output from upstream" do
     let(:command) { "/bin/bash" }
-    let(:options) {
+    let(:options) do
       { args: [
         "-c",
         "for i in $(seq 1 2 5); do echo $i; echo $(($i + 1)) >&2; done",
       ] }
-    }
+    end
 
     shared_examples "it returns '1 2 3 4 5 6'" do
       describe "its result" do
-        subject { described_class.run(command, options) }
+        subject(:result) { described_class.run(command, **options) }
 
         it { is_expected.to be_a_success }
-        its(:stdout) { is_expected.to eq([1, 3, 5, nil].join("\n")) }
-        its(:stderr) { is_expected.to eq([2, 4, 6, nil].join("\n")) }
+        it(:stdout) { expect(result.stdout).to eq([1, 3, 5, nil].join("\n")) }
+        it(:stderr) { expect(result.stderr).to eq([2, 4, 6, nil].join("\n")) }
       end
     end
 
     context "with default options" do
       it "echoes only STDERR" do
         expected = [2, 4, 6].map { |i| "#{i}\n" }.join
-        expect {
-          described_class.run(command, options)
-        }.to output(expected).to_stderr
+        expect do
+          described_class.run(command, **options)
+        end.to output(expected).to_stderr
       end
 
       include_examples("it returns '1 2 3 4 5 6'")
     end
 
-    context "with print_stdout" do
+    context "with `print_stdout: true`" do
       before do
         options.merge!(print_stdout: true)
       end
 
       it "echoes both STDOUT and STDERR" do
-        expect { described_class.run(command, options) }
+        expect { described_class.run(command, **options) }
           .to output("1\n3\n5\n").to_stdout
           .and output("2\n4\n6\n").to_stderr
       end
@@ -157,30 +182,63 @@
       include_examples("it returns '1 2 3 4 5 6'")
     end
 
-    context "without print_stderr" do
+    context "with `print_stdout: :debug`" do
+      before do
+        options.merge!(print_stdout: :debug)
+      end
+
+      it "echoes only STDERR output" do
+        expect { described_class.run(command, **options) }
+          .to output("2\n4\n6\n").to_stderr
+          .and not_to_output.to_stdout
+      end
+
+      context "when `debug?` is true" do
+        include Context
+
+        let(:options) do
+          { args: [
+            "-c",
+            "for i in $(seq 1 2 5); do echo $i; sleep 0.1; echo $(($i + 1)) >&2; sleep 0.1; done",
+          ] }
+        end
+
+        it "echoes the command and all output to STDERR when `debug?` is true" do
+          with_context debug: true do
+            expect { described_class.run(command, **options) }
+              .to output(/\A.*#{Regexp.escape(command)}.*\n1\n2\n3\n4\n5\n6\n\Z/).to_stderr
+              .and not_to_output.to_stdout
+          end
+        end
+      end
+
+      include_examples("it returns '1 2 3 4 5 6'")
+    end
+
+    context "with `print_stderr: false`" do
       before do
         options.merge!(print_stderr: false)
       end
 
       it "echoes nothing" do
-        expect {
-          described_class.run(command, options)
-        }.to output("").to_stdout
+        expect do
+          described_class.run(command, **options)
+        end.not_to output.to_stdout
       end
 
       include_examples("it returns '1 2 3 4 5 6'")
     end
 
-    context "with print_stdout but without print_stderr" do
+    context "with `print_stdout: true` and `print_stderr: false`" do
       before do
         options.merge!(print_stdout: true, print_stderr: false)
       end
 
       it "echoes only STDOUT" do
         expected = [1, 3, 5].map { |i| "#{i}\n" }.join
-        expect {
-          described_class.run(command, options)
-        }.to output(expected).to_stdout
+        expect do
+          described_class.run(command, **options)
+        end.to output(expected).to_stdout
       end
 
       include_examples("it returns '1 2 3 4 5 6'")
@@ -189,17 +247,15 @@
 
   context "with a very long STDERR output" do
     let(:command) { "/bin/bash" }
-    let(:options) {
+    let(:options) do
       { args: [
         "-c",
         "for i in $(seq 1 2 100000); do echo $i; echo $(($i + 1)) >&2; done",
       ] }
-    }
+    end
 
-    it "returns without deadlocking" do
-      wait(30).for {
-        described_class.run(command, options)
-      }.to be_a_success
+    it "returns without deadlocking", timeout: 30 do
+      expect(described_class.run(command, **options)).to be_a_success
     end
   end
 
@@ -225,20 +281,20 @@
 
   describe "#run" do
     it "does not raise a `SystemCallError` when the executable does not exist" do
-      expect {
+      expect do
         described_class.run("non_existent_executable")
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it 'does not format `stderr` when it starts with \r' do
-      expect {
-        system_command \
+      expect do
+        Class.new.extend(SystemCommand::Mixin).system_command \
           "bash",
           args: [
             "-c",
             'printf "\r%s" "###################                                                       27.6%" 1>&2',
           ]
-      }.to output( \
+      end.to output(
         "\r###################                                                       27.6%",
       ).to_stderr
     end
@@ -256,53 +312,53 @@
       end
 
       it "does not interpret the executable as a shell line" do
-        expect(system_command(executable)).to be_a_success
+        expect(Class.new.extend(SystemCommand::Mixin).system_command(executable)).to be_a_success
       end
     end
 
     context "when given arguments with secrets" do
       it "does not leak the secrets" do
         redacted_msg = /#{Regexp.escape("username:******")}/
-        expect {
+        expect do
           described_class.run! "curl",
                                args:    %w[--user username:hunter2],
                                verbose: true,
                                secrets: %w[hunter2]
-        }.to raise_error.with_message(redacted_msg).and output(redacted_msg).to_stderr
+        end.to raise_error(ErrorDuringExecution, redacted_msg).and output(redacted_msg).to_stderr
       end
 
       it "does not leak the secrets set by environment" do
         redacted_msg = /#{Regexp.escape("username:******")}/
-        expect {
+        expect do
           ENV["PASSWORD"] = "hunter2"
           described_class.run! "curl",
                                args:    %w[--user username:hunter2],
                                verbose: true
-        }.to raise_error.with_message(redacted_msg).and output(redacted_msg).to_stderr
+        end.to raise_error(ErrorDuringExecution, redacted_msg).and output(redacted_msg).to_stderr
       end
     end
 
     context "when running a process that prints secrets" do
       it "does not leak the secrets" do
         redacted_msg = /#{Regexp.escape("username:******")}/
-        expect {
+        expect do
           described_class.run! "echo",
                                args:         %w[username:hunter2],
                                verbose:      true,
                                print_stdout: true,
                                secrets:      %w[hunter2]
-        }.to output(redacted_msg).to_stdout
+        end.to output(redacted_msg).to_stdout
       end
 
       it "does not leak the secrets set by environment" do
         redacted_msg = /#{Regexp.escape("username:******")}/
-        expect {
+        expect do
           ENV["PASSWORD"] = "hunter2"
           described_class.run! "echo",
                                args:         %w[username:hunter2],
                                print_stdout: true,
                                verbose:      true
-        }.to output(redacted_msg).to_stdout
+        end.to output(redacted_msg).to_stdout
       end
     end
 
diff --git a/Library/Homebrew/test/tab_spec.rb b/Library/Homebrew/test/tab_spec.rb
index 85b6ec12d0266..594e9c7747295 100644
--- a/Library/Homebrew/test/tab_spec.rb
+++ b/Library/Homebrew/test/tab_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require "tab"
 require "formula"
 
-describe Tab do
+RSpec.describe Tab do
   alias_matcher :be_built_with, :be_with
 
   matcher :be_poured_from_bottle do
@@ -19,21 +18,40 @@
     end
   end
 
-  subject(:tab) {
+  matcher :be_installed_as_dependency do
+    match do |actual|
+      actual.installed_as_dependency == true
+    end
+  end
+
+  matcher :be_installed_on_request do
+    match do |actual|
+      actual.installed_on_request == true
+    end
+  end
+
+  matcher :be_loaded_from_api do
+    match do |actual|
+      actual.loaded_from_api == true
+    end
+  end
+
+  subject(:tab) do
     described_class.new(
-      "homebrew_version"     => HOMEBREW_VERSION,
-      "used_options"         => used_options.as_flags,
-      "unused_options"       => unused_options.as_flags,
-      "built_as_bottle"      => false,
-      "poured_from_bottle"   => true,
-      "changed_files"        => [],
-      "time"                 => time,
-      "source_modified_time" => 0,
-      "HEAD"                 => TEST_SHA1,
-      "compiler"             => "clang",
-      "stdlib"               => "libcxx",
-      "runtime_dependencies" => [],
-      "source"               => {
+      "homebrew_version"        => HOMEBREW_VERSION,
+      "used_options"            => used_options.as_flags,
+      "unused_options"          => unused_options.as_flags,
+      "built_as_bottle"         => false,
+      "poured_from_bottle"      => true,
+      "installed_as_dependency" => false,
+      "installed_on_request"    => true,
+      "changed_files"           => [],
+      "time"                    => time,
+      "source_modified_time"    => 0,
+      "compiler"                => "clang",
+      "stdlib"                  => "libcxx",
+      "runtime_dependencies"    => [],
+      "source"                  => {
         "tap"      => CoreTap.instance.to_s,
         "path"     => CoreTap.instance.path.to_s,
         "spec"     => "stable",
@@ -42,10 +60,10 @@
           "head"   => "HEAD-1111111",
         },
       },
-      "arch"                 => Hardware::CPU.arch,
-      "built_on"             => DevelopmentTools.build_system_info,
+      "arch"                    => Hardware::CPU.arch,
+      "built_on"                => DevelopmentTools.build_system_info,
     )
-  }
+  end
 
   let(:time) { Time.now.to_i }
   let(:unused_options) { Options.create(%w[--with-baz --without-qux]) }
@@ -67,11 +85,13 @@
     expect(tab.changed_files).to be_nil
     expect(tab).not_to be_built_as_bottle
     expect(tab).not_to be_poured_from_bottle
+    expect(tab).not_to be_installed_as_dependency
+    expect(tab).not_to be_installed_on_request
+    expect(tab).not_to be_loaded_from_api
     expect(tab).to be_stable
     expect(tab).not_to be_head
     expect(tab.tap).to be_nil
     expect(tab.time).to be_nil
-    expect(tab.HEAD).to be_nil
     expect(tab.runtime_dependencies).to be_nil
     expect(tab.stable_version).to be_nil
     expect(tab.head_version).to be_nil
@@ -99,7 +119,7 @@
     tab = described_class.new(homebrew_version: "1.2.3")
     expect(tab.parsed_homebrew_version).to eq("1.2.3")
     expect(tab.parsed_homebrew_version).to be < "1.2.3-1-g12789abdf"
-    expect(tab.parsed_homebrew_version).to be_kind_of(Version)
+    expect(tab.parsed_homebrew_version).to be_a(Version)
 
     tab.homebrew_version = "1.2.4-567-g12789abdf"
     expect(tab.parsed_homebrew_version).to be > "1.2.4"
@@ -135,17 +155,69 @@
     expect(tab.runtime_dependencies).not_to be_nil
   end
 
-  specify "::runtime_deps_hash" do
-    runtime_deps = [Dependency.new("foo")]
-    foo = formula("foo") { url "foo-1.0" }
-    stub_formula_loader foo
-    runtime_deps_hash = described_class.runtime_deps_hash(foo, runtime_deps)
-    tab = described_class.new
-    tab.homebrew_version = "1.1.6"
-    tab.runtime_dependencies = runtime_deps_hash
-    expect(tab.runtime_dependencies).to eql(
-      [{ "full_name" => "foo", "version" => "1.0", "declared_directly" => false }],
-    )
+  describe "::runtime_deps_hash" do
+    it "handles older Homebrew versions correctly" do
+      runtime_deps = [Dependency.new("foo")]
+      foo = formula("foo") { url "foo-1.0" }
+      stub_formula_loader foo
+      runtime_deps_hash = described_class.runtime_deps_hash(foo, runtime_deps)
+      tab = described_class.new
+      tab.homebrew_version = "1.1.6"
+      tab.runtime_dependencies = runtime_deps_hash
+      expect(tab.runtime_dependencies).to eql(
+        [{ "full_name" => "foo", "version" => "1.0", "revision" => 0, "pkg_version" => "1.0",
+        "declared_directly" => false }],
+      )
+    end
+
+    it "include declared dependencies" do
+      foo = formula("foo") { url "foo-1.0" }
+      stub_formula_loader foo
+
+      runtime_deps = [Dependency.new("foo")]
+      formula = instance_double(Formula, deps: runtime_deps)
+
+      expected_output = [
+        {
+          "full_name"         => "foo",
+          "version"           => "1.0",
+          "revision"          => 0,
+          "pkg_version"       => "1.0",
+          "declared_directly" => true,
+        },
+      ]
+      expect(described_class.runtime_deps_hash(formula, runtime_deps)).to eq(expected_output)
+    end
+
+    it "includes recursive dependencies" do
+      foo = formula("foo") { url "foo-1.0" }
+      bar = formula("bar") { url "bar-2.0" }
+      stub_formula_loader foo
+      stub_formula_loader bar
+
+      # Simulating dependencies formula => foo => bar
+      formula_declared_deps = [Dependency.new("foo")]
+      formula_recursive_deps = [Dependency.new("foo"), Dependency.new("bar")]
+      formula = instance_double(Formula, deps: formula_declared_deps)
+
+      expected_output = [
+        {
+          "full_name"         => "foo",
+          "version"           => "1.0",
+          "revision"          => 0,
+          "pkg_version"       => "1.0",
+          "declared_directly" => true,
+        },
+        {
+          "full_name"         => "bar",
+          "version"           => "2.0",
+          "revision"          => 0,
+          "pkg_version"       => "2.0",
+          "declared_directly" => false,
+        },
+      ]
+      expect(described_class.runtime_deps_hash(formula, formula_recursive_deps)).to eq(expected_output)
+    end
   end
 
   specify "#cxxstdlib" do
@@ -154,15 +226,17 @@
   end
 
   specify "other attributes" do
-    expect(tab.HEAD).to eq(TEST_SHA1)
     expect(tab.tap.name).to eq("homebrew/core")
     expect(tab.time).to eq(time)
     expect(tab).not_to be_built_as_bottle
     expect(tab).to be_poured_from_bottle
+    expect(tab).not_to be_installed_as_dependency
+    expect(tab).to be_installed_on_request
+    expect(tab).not_to be_loaded_from_api
   end
 
   describe "::from_file" do
-    it "parses a Tab from a file" do
+    it "parses a formula Tab from a file" do
       path = Pathname.new("#{TEST_FIXTURE_DIR}/receipt.json")
       tab = described_class.from_file(path)
       source_path = "/usr/local/Library/Taps/homebrew/homebrew-core/Formula/foo.rb"
@@ -174,12 +248,14 @@
       expect(tab.changed_files).to eq(changed_files)
       expect(tab).not_to be_built_as_bottle
       expect(tab).to be_poured_from_bottle
+      expect(tab).not_to be_installed_as_dependency
+      expect(tab).to be_installed_on_request
+      expect(tab).not_to be_loaded_from_api
       expect(tab).to be_stable
       expect(tab).not_to be_head
       expect(tab.tap.name).to eq("homebrew/core")
       expect(tab.spec).to eq(:stable)
       expect(tab.time).to eq(Time.at(1_403_827_774).to_i)
-      expect(tab.HEAD).to eq(TEST_SHA1)
       expect(tab.cxxstdlib.compiler).to eq(:clang)
       expect(tab.cxxstdlib.type).to eq(:libcxx)
       expect(tab.runtime_dependencies).to eq(runtime_dependencies)
@@ -190,7 +266,7 @@
   end
 
   describe "::from_file_content" do
-    it "parses a Tab from a file" do
+    it "parses a formula Tab from a file" do
       path = Pathname.new("#{TEST_FIXTURE_DIR}/receipt.json")
       tab = described_class.from_file_content(path.read, path)
       source_path = "/usr/local/Library/Taps/homebrew/homebrew-core/Formula/foo.rb"
@@ -202,12 +278,14 @@
       expect(tab.changed_files).to eq(changed_files)
       expect(tab).not_to be_built_as_bottle
       expect(tab).to be_poured_from_bottle
+      expect(tab).not_to be_installed_as_dependency
+      expect(tab).to be_installed_on_request
+      expect(tab).not_to be_loaded_from_api
       expect(tab).to be_stable
       expect(tab).not_to be_head
       expect(tab.tap.name).to eq("homebrew/core")
       expect(tab.spec).to eq(:stable)
       expect(tab.time).to eq(Time.at(1_403_827_774).to_i)
-      expect(tab.HEAD).to eq(TEST_SHA1)
       expect(tab.cxxstdlib.compiler).to eq(:clang)
       expect(tab.cxxstdlib.type).to eq(:libcxx)
       expect(tab.runtime_dependencies).to eq(runtime_dependencies)
@@ -216,7 +294,7 @@
       expect(tab.source["path"]).to eq(source_path)
     end
 
-    it "can parse an old Tab file" do
+    it "can parse an old formula Tab file" do
       path = Pathname.new("#{TEST_FIXTURE_DIR}/receipt_old.json")
       tab = described_class.from_file_content(path.read, path)
 
@@ -224,12 +302,14 @@
       expect(tab.unused_options.sort).to eq(unused_options.sort)
       expect(tab).not_to be_built_as_bottle
       expect(tab).to be_poured_from_bottle
+      expect(tab).not_to be_installed_as_dependency
+      expect(tab).not_to be_installed_on_request
+      expect(tab).not_to be_loaded_from_api
       expect(tab).to be_stable
       expect(tab).not_to be_head
       expect(tab.tap.name).to eq("homebrew/core")
       expect(tab.spec).to eq(:stable)
       expect(tab.time).to eq(Time.at(1_403_827_774).to_i)
-      expect(tab.HEAD).to eq(TEST_SHA1)
       expect(tab.cxxstdlib.compiler).to eq(:clang)
       expect(tab.cxxstdlib.type).to eq(:libcxx)
       expect(tab.runtime_dependencies).to be_nil
@@ -244,10 +324,13 @@
   end
 
   describe "::create" do
-    it "creates a Tab" do
+    it "creates a formula Tab" do
       # < 1.1.7 runtime dependencies were wrong so are ignored
       stub_const("HOMEBREW_VERSION", "1.1.7")
 
+      # don't try to load gcc/glibc
+      allow(DevelopmentTools).to receive_messages(needs_libc_formula?: false, needs_compiler_formula?: false)
+
       f = formula do
         url "foo-1.0"
         depends_on "bar"
@@ -255,9 +338,10 @@
         depends_on "baz" => :build
       end
 
-      tap = Tap.new("user", "repo")
+      tap = Tap.fetch("user", "repo")
       from_tap = formula("from_tap", path: tap.path/"Formula/from_tap.rb") do
         url "from_tap-1.0"
+        revision 1
       end
       stub_formula_loader from_tap
 
@@ -269,17 +353,19 @@
       tab = described_class.create(f, compiler, stdlib)
 
       runtime_dependencies = [
-        { "full_name" => "bar", "version" => "2.0", "declared_directly" => true },
-        { "full_name" => "user/repo/from_tap", "version" => "1.0", "declared_directly" => true },
+        { "full_name" => "bar", "version" => "2.0", "revision" => 0, "pkg_version" => "2.0",
+"declared_directly" => true },
+        { "full_name" => "user/repo/from_tap", "version" => "1.0", "revision" => 1, "pkg_version" => "1.0_1",
+"declared_directly" => true },
       ]
       expect(tab.runtime_dependencies).to eq(runtime_dependencies)
 
       expect(tab.source["path"]).to eq(f.path.to_s)
     end
 
-    it "can create a Tab from an alias" do
+    it "can create a formula Tab from an alias" do
       alias_path = CoreTap.instance.alias_dir/"bar"
-      f = formula(alias_path: alias_path) { url "foo-1.0" }
+      f = formula(alias_path:) { url "foo-1.0" }
       compiler = DevelopmentTools.default_compiler
       stdlib = :libcxx
       tab = described_class.create(f, compiler, stdlib)
@@ -313,7 +399,7 @@
 
     it "can create a Tab for for a Formula from an alias" do
       alias_path = CoreTap.instance.alias_dir/"bar"
-      f = formula(alias_path: alias_path) { url "foo-1.0" }
+      f = formula(alias_path:) { url "foo-1.0" }
 
       tab = described_class.for_formula(f)
       expect(tab.source["path"]).to eq(alias_path.to_s)
@@ -395,6 +481,62 @@
     expect(json_tab.built_on["os"]).to eq(tab.built_on["os"])
   end
 
+  describe "#to_s" do
+    let(:time_string) { Time.at(1_720_189_863).strftime("%Y-%m-%d at %H:%M:%S") }
+
+    it "returns install information for the Tab" do
+      tab = described_class.new(
+        poured_from_bottle: true,
+        loaded_from_api:    true,
+        time:               1_720_189_863,
+        used_options:       %w[--with-foo --without-bar],
+      )
+      output = "Poured from bottle using the formulae.brew.sh API on #{time_string} " \
+               "with: --with-foo --without-bar"
+      expect(tab.to_s).to eq(output)
+    end
+
+    it "includes 'Poured from bottle' if the formula was installed from a bottle" do
+      tab = described_class.new(poured_from_bottle: true)
+      expect(tab.to_s).to include("Poured from bottle")
+    end
+
+    it "includes 'Built from source' if the formula was not installed from a bottle" do
+      tab = described_class.new(poured_from_bottle: false)
+      expect(tab.to_s).to include("Built from source")
+    end
+
+    it "includes 'using the formulae.brew.sh API' if the formula was installed from the API" do
+      tab = described_class.new(loaded_from_api: true)
+      expect(tab.to_s).to include("using the formulae.brew.sh API")
+    end
+
+    it "does not include 'using the formulae.brew.sh API' if the formula was not installed from the API" do
+      tab = described_class.new(loaded_from_api: false)
+      expect(tab.to_s).not_to include("using the formulae.brew.sh API")
+    end
+
+    it "includes the time value if specified" do
+      tab = described_class.new(time: 1_720_189_863)
+      expect(tab.to_s).to include("on #{time_string}")
+    end
+
+    it "does not include the time value if not specified" do
+      tab = described_class.new(time: nil)
+      expect(tab.to_s).not_to match(/on %d+-%d+-%d+ at %d+:%d+:%d+/)
+    end
+
+    it "includes options if specified" do
+      tab = described_class.new(used_options: %w[--with-foo --without-bar])
+      expect(tab.to_s).to include("with: --with-foo --without-bar")
+    end
+
+    it "not to include options if not specified" do
+      tab = described_class.new(used_options: [])
+      expect(tab.to_s).not_to include("with: ")
+    end
+  end
+
   specify "::remap_deprecated_options" do
     deprecated_options = [DeprecatedOption.new("with-foo", "with-foo-new")]
     remapped_options = described_class.remap_deprecated_options(deprecated_options, tab.used_options)
diff --git a/Library/Homebrew/test/tap_spec.rb b/Library/Homebrew/test/tap_spec.rb
index 10ba903b50973..9c969e44b7be3 100644
--- a/Library/Homebrew/test/tap_spec.rb
+++ b/Library/Homebrew/test/tap_spec.rb
@@ -1,13 +1,15 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Tap do
+RSpec.describe Tap do
+  include FileUtils
+
+  alias_matcher :have_cask_file, :be_cask_file
   alias_matcher :have_formula_file, :be_formula_file
   alias_matcher :have_custom_remote, :be_custom_remote
 
-  subject(:homebrew_foo_tap) { described_class.new("Homebrew", "foo") }
+  subject(:homebrew_foo_tap) { described_class.fetch("Homebrew", "foo") }
 
-  let(:path) { Tap::TAP_DIRECTORY/"homebrew/homebrew-foo" }
+  let(:path) { HOMEBREW_TAP_DIRECTORY/"homebrew/homebrew-foo" }
   let(:formula_file) { path/"Formula/foo.rb" }
   let(:alias_file) { path/"Aliases/bar" }
   let(:cmd_file) { path/"cmd/brew-tap-cmd.rb" }
@@ -96,23 +98,23 @@ def setup_completion(link:)
   end
 
   specify "::fetch" do
-    expect(described_class.fetch("Homebrew", "core")).to be_kind_of(CoreTap)
-    expect(described_class.fetch("Homebrew", "homebrew")).to be_kind_of(CoreTap)
+    expect(described_class.fetch("Homebrew", "core")).to be_a(CoreTap)
+    expect(described_class.fetch("Homebrew", "homebrew")).to be_a(CoreTap)
     tap = described_class.fetch("Homebrew", "foo")
-    expect(tap).to be_kind_of(described_class)
+    expect(tap).to be_a(described_class)
     expect(tap.name).to eq("homebrew/foo")
 
-    expect {
+    expect do
       described_class.fetch("foo")
-    }.to raise_error(/Invalid tap name/)
+    end.to raise_error(Tap::InvalidNameError, /Invalid tap name/)
 
-    expect {
+    expect do
       described_class.fetch("homebrew/homebrew/bar")
-    }.to raise_error(/Invalid tap name/)
+    end.to raise_error(Tap::InvalidNameError, /Invalid tap name/)
 
-    expect {
+    expect do
       described_class.fetch("homebrew", "homebrew/baz")
-    }.to raise_error(/Invalid tap name/)
+    end.to raise_error(Tap::InvalidNameError, /Invalid tap name/)
   end
 
   describe "::from_path" do
@@ -127,15 +129,41 @@ def setup_completion(link:)
     it "returns the Tap when given its exact path" do
       expect(described_class.from_path(path)).to eq tap
     end
+
+    context "when path contains a dot" do
+      let(:tap) { described_class.fetch("str4d.xyz", "rage") }
+
+      after do
+        tap.uninstall
+      end
+
+      it "returns the Tap when given its exact path" do
+        expect(described_class.from_path(path)).to eq tap
+      end
+    end
   end
 
-  specify "::names" do
-    expect(described_class.names.sort).to eq(["homebrew/core", "homebrew/foo"])
+  describe "::allowed_taps" do
+    before { allow(Homebrew::EnvConfig).to receive(:allowed_taps).and_return("homebrew/allowed") }
+
+    it "returns a set of allowed taps according to the environment" do
+      expect(described_class.allowed_taps)
+        .to contain_exactly(described_class.fetch("homebrew/allowed"))
+    end
+  end
+
+  describe "::forbidden_taps" do
+    before { allow(Homebrew::EnvConfig).to receive(:forbidden_taps).and_return("homebrew/forbidden") }
+
+    it "returns a set of forbidden taps according to the environment" do
+      expect(described_class.forbidden_taps)
+        .to contain_exactly(described_class.fetch("homebrew/forbidden"))
+    end
   end
 
   specify "attributes" do
     expect(homebrew_foo_tap.user).to eq("Homebrew")
-    expect(homebrew_foo_tap.repo).to eq("foo")
+    expect(homebrew_foo_tap.repository).to eq("foo")
     expect(homebrew_foo_tap.name).to eq("homebrew/foo")
     expect(homebrew_foo_tap.path).to eq(path)
     expect(homebrew_foo_tap).to be_installed
@@ -144,8 +172,8 @@ def setup_completion(link:)
   end
 
   specify "#issues_url" do
-    t = described_class.new("someone", "foo")
-    path = Tap::TAP_DIRECTORY/"someone/homebrew-foo"
+    t = described_class.fetch("someone", "foo")
+    path = HOMEBREW_TAP_DIRECTORY/"someone/homebrew-foo"
     path.mkpath
     cd path do
       system "git", "init"
@@ -155,10 +183,10 @@ def setup_completion(link:)
     expect(t.issues_url).to eq("https://github.com/someone/homebrew-foo/issues")
     expect(homebrew_foo_tap.issues_url).to eq("https://github.com/Homebrew/homebrew-foo/issues")
 
-    (Tap::TAP_DIRECTORY/"someone/homebrew-no-git").mkpath
-    expect(described_class.new("someone", "no-git").issues_url).to be_nil
+    (HOMEBREW_TAP_DIRECTORY/"someone/homebrew-no-git").mkpath
+    expect(described_class.fetch("someone", "no-git").issues_url).to be_nil
   ensure
-    path.parent.rmtree
+    FileUtils.rm_rf(path.parent)
   end
 
   specify "files" do
@@ -173,22 +201,20 @@ def setup_completion(link:)
     expect(homebrew_foo_tap.formula_renames).to eq("oldname" => "foo")
     expect(homebrew_foo_tap.tap_migrations).to eq("removed-formula" => "homebrew/foo")
     expect(homebrew_foo_tap.command_files).to eq([cmd_file])
-    expect(homebrew_foo_tap.to_hash).to be_kind_of(Hash)
-    expect(homebrew_foo_tap).to have_formula_file(formula_file)
+    expect(homebrew_foo_tap.to_hash).to be_a(Hash)
     expect(homebrew_foo_tap).to have_formula_file("Formula/foo.rb")
     expect(homebrew_foo_tap).not_to have_formula_file("bar.rb")
     expect(homebrew_foo_tap).not_to have_formula_file("Formula/baz.sh")
   end
 
   describe "#remote" do
-    it "returns the remote URL" do
+    it "returns the remote URL", :needs_network do
       setup_git_repo
 
       expect(homebrew_foo_tap.remote).to eq("https://github.com/Homebrew/homebrew-foo")
-      expect { described_class.new("Homebrew", "bar").remote }.to raise_error(TapUnavailableError)
       expect(homebrew_foo_tap).not_to have_custom_remote
 
-      services_tap = described_class.new("Homebrew", "services")
+      services_tap = described_class.fetch("Homebrew", "services")
       services_tap.path.mkpath
       services_tap.path.cd do
         system "git", "init"
@@ -212,41 +238,70 @@ def setup_completion(link:)
     it "returns the remote https repository" do
       setup_git_repo
 
-      expect(homebrew_foo_tap.remote_repo).to eq("Homebrew/homebrew-foo")
-      expect { described_class.new("Homebrew", "bar").remote_repo }.to raise_error(TapUnavailableError)
+      expect(homebrew_foo_tap.remote_repository).to eq("Homebrew/homebrew-foo")
 
-      services_tap = described_class.new("Homebrew", "services")
+      services_tap = described_class.fetch("Homebrew", "services")
       services_tap.path.mkpath
       services_tap.path.cd do
         system "git", "init"
         system "git", "remote", "add", "origin", "https://github.com/Homebrew/homebrew-bar"
       end
-      expect(services_tap.remote_repo).to eq("Homebrew/homebrew-bar")
+      expect(services_tap.remote_repository).to eq("Homebrew/homebrew-bar")
     end
 
     it "returns the remote ssh repository" do
       setup_git_repo
 
-      expect(homebrew_foo_tap.remote_repo).to eq("Homebrew/homebrew-foo")
-      expect { described_class.new("Homebrew", "bar").remote_repo }.to raise_error(TapUnavailableError)
+      expect(homebrew_foo_tap.remote_repository).to eq("Homebrew/homebrew-foo")
 
-      services_tap = described_class.new("Homebrew", "services")
+      services_tap = described_class.fetch("Homebrew", "services")
       services_tap.path.mkpath
       services_tap.path.cd do
         system "git", "init"
         system "git", "remote", "add", "origin", "git@github.com:Homebrew/homebrew-bar"
       end
-      expect(services_tap.remote_repo).to eq("Homebrew/homebrew-bar")
+      expect(services_tap.remote_repository).to eq("Homebrew/homebrew-bar")
     end
 
     it "returns nil if the Tap is not a Git repository" do
-      expect(homebrew_foo_tap.remote_repo).to be_nil
+      expect(homebrew_foo_tap.remote_repository).to be_nil
     end
 
     it "returns nil if Git is not available" do
       setup_git_repo
       allow(Utils::Git).to receive(:available?).and_return(false)
-      expect(homebrew_foo_tap.remote_repo).to be_nil
+      expect(homebrew_foo_tap.remote_repository).to be_nil
+    end
+  end
+
+  describe "#custom_remote?" do
+    subject(:tap) { described_class.fetch("Homebrew", "services") }
+
+    let(:remote) { nil }
+
+    before do
+      tap.path.mkpath
+      system "git", "-C", tap.path, "init"
+      system "git", "-C", tap.path, "remote", "add", "origin", remote if remote
+    end
+
+    context "if no remote is available" do
+      it "returns true" do
+        expect(tap.remote).to be_nil
+        expect(tap.custom_remote?).to be true
+      end
+    end
+
+    context "when using the default remote" do
+      let(:remote) { "https://github.com/Homebrew/homebrew-services" }
+
+      it(:custom_remote?) { expect(tap.custom_remote?).to be false }
+    end
+
+    context "when using a non-default remote" do
+      let(:remote) { "git@github.com:Homebrew/homebrew-services" }
+
+      it(:custom_remote?) { expect(tap.custom_remote?).to be true }
     end
   end
 
@@ -258,22 +313,21 @@ def setup_completion(link:)
     expect(homebrew_foo_tap.git_last_commit).to match(/\A\d+ .+ ago\Z/)
   end
 
-  specify "#private?" do
-    skip "HOMEBREW_GITHUB_API_TOKEN is required" unless GitHub::API.credentials
+  specify "#private?", :needs_network do
     expect(homebrew_foo_tap).to be_private
   end
 
   describe "#install" do
     it "raises an error when the Tap is already tapped" do
       setup_git_repo
-      already_tapped_tap = described_class.new("Homebrew", "foo")
+      already_tapped_tap = described_class.fetch("Homebrew", "foo")
       expect(already_tapped_tap).to be_installed
       expect { already_tapped_tap.install }.to raise_error(TapAlreadyTappedError)
     end
 
     it "raises an error when the Tap is already tapped with the right remote" do
       setup_git_repo
-      already_tapped_tap = described_class.new("Homebrew", "foo")
+      already_tapped_tap = described_class.fetch("Homebrew", "foo")
       expect(already_tapped_tap).to be_installed
       right_remote = homebrew_foo_tap.remote
       expect { already_tapped_tap.install clone_target: right_remote }.to raise_error(TapAlreadyTappedError)
@@ -281,81 +335,56 @@ def setup_completion(link:)
 
     it "raises an error when the remote doesn't match" do
       setup_git_repo
-      already_tapped_tap = described_class.new("Homebrew", "foo")
+      already_tapped_tap = described_class.fetch("Homebrew", "foo")
       expect(already_tapped_tap).to be_installed
       wrong_remote = "#{homebrew_foo_tap.remote}-oops"
-      expect {
+      expect do
         already_tapped_tap.install clone_target: wrong_remote
-      }.to raise_error(TapRemoteMismatchError)
+      end.to raise_error(TapRemoteMismatchError)
     end
 
     it "raises an error when the remote for Homebrew/core doesn't match HOMEBREW_CORE_GIT_REMOTE" do
       core_tap = described_class.fetch("Homebrew", "core")
       wrong_remote = "#{Homebrew::EnvConfig.core_git_remote}-oops"
-      expect {
+      expect do
         core_tap.install clone_target: wrong_remote
-      }.to raise_error(TapCoreRemoteMismatchError)
+      end.to raise_error(TapCoreRemoteMismatchError)
     end
 
     it "raises an error when run `brew tap --custom-remote` without a custom remote (already installed)" do
       setup_git_repo
-      already_tapped_tap = described_class.new("Homebrew", "foo")
+      already_tapped_tap = described_class.fetch("Homebrew", "foo")
       expect(already_tapped_tap).to be_installed
 
-      expect {
+      expect do
         already_tapped_tap.install clone_target: nil, custom_remote: true
-      }.to raise_error(TapNoCustomRemoteError)
+      end.to raise_error(TapNoCustomRemoteError)
     end
 
     it "raises an error when run `brew tap --custom-remote` without a custom remote (not installed)" do
-      not_tapped_tap = described_class.new("Homebrew", "bar")
+      not_tapped_tap = described_class.fetch("Homebrew", "bar")
       expect(not_tapped_tap).not_to be_installed
 
-      expect {
+      expect do
         not_tapped_tap.install clone_target: nil, custom_remote: true
-      }.to raise_error(TapNoCustomRemoteError)
-    end
-
-    describe "force_auto_update" do
-      before do
-        setup_git_repo
-      end
-
-      let(:already_tapped_tap) { described_class.new("Homebrew", "foo") }
-
-      it "defaults to nil" do
-        expect(already_tapped_tap).to be_installed
-        expect(already_tapped_tap.config["forceautoupdate"]).to be_nil
-      end
-
-      it "enables forced auto-updates when true" do
-        expect(already_tapped_tap).to be_installed
-        already_tapped_tap.install force_auto_update: true
-        expect(already_tapped_tap.config["forceautoupdate"]).to eq("true")
-      end
-
-      it "disables forced auto-updates when false" do
-        expect(already_tapped_tap).to be_installed
-        already_tapped_tap.install force_auto_update: false
-        expect(already_tapped_tap.config["forceautoupdate"]).to be_nil
-      end
+      end.to raise_error(TapNoCustomRemoteError)
     end
 
     specify "Git error" do
-      tap = described_class.new("user", "repo")
+      tap = described_class.fetch("user", "repo")
 
-      expect {
+      expect do
         tap.install clone_target: "file:///not/existed/remote/url"
-      }.to raise_error(ErrorDuringExecution)
+      end.to raise_error(ErrorDuringExecution)
 
       expect(tap).not_to be_installed
-      expect(Tap::TAP_DIRECTORY/"user").not_to exist
+      expect(HOMEBREW_TAP_DIRECTORY/"user").not_to exist
     end
   end
 
   describe "#uninstall" do
     it "raises an error if the Tap is not available" do
-      tap = described_class.new("Homebrew", "bar")
+      tap = described_class.fetch("Homebrew", "bar")
       expect { tap.uninstall }.to raise_error(TapUnavailableError)
     end
   end
@@ -365,7 +394,7 @@ def setup_completion(link:)
     setup_git_repo
     setup_completion link: true
 
-    tap = described_class.new("Homebrew", "bar")
+    tap = described_class.fetch("Homebrew", "bar")
 
     tap.install clone_target: homebrew_foo_tap.path/".git"
 
@@ -383,15 +412,15 @@ def setup_completion(link:)
     expect(HOMEBREW_PREFIX/"share/zsh/site-functions/_brew-tap-cmd").not_to exist
     expect(HOMEBREW_PREFIX/"share/fish/vendor_completions.d/brew-tap-cmd.fish").not_to exist
   ensure
-    (HOMEBREW_PREFIX/"etc").rmtree if (HOMEBREW_PREFIX/"etc").exist?
-    (HOMEBREW_PREFIX/"share").rmtree if (HOMEBREW_PREFIX/"share").exist?
+    FileUtils.rm_r(HOMEBREW_PREFIX/"etc") if (HOMEBREW_PREFIX/"etc").exist?
+    FileUtils.rm_r(HOMEBREW_PREFIX/"share") if (HOMEBREW_PREFIX/"share").exist?
   end
 
   specify "#link_completions_and_manpages when completions are enabled for non-official tap" do
     setup_tap_files
     setup_git_repo
     setup_completion link: true
-    tap = described_class.new("NotHomebrew", "baz")
+    tap = described_class.fetch("NotHomebrew", "baz")
     tap.install clone_target: homebrew_foo_tap.path/".git"
     (HOMEBREW_PREFIX/"share/man/man1/brew-tap-cmd.1").delete
     (HOMEBREW_PREFIX/"etc/bash_completion.d/brew-tap-cmd").delete
@@ -404,15 +433,15 @@ def setup_completion(link:)
     expect(HOMEBREW_PREFIX/"share/fish/vendor_completions.d/brew-tap-cmd.fish").to be_a_file
     tap.uninstall
   ensure
-    (HOMEBREW_PREFIX/"etc").rmtree if (HOMEBREW_PREFIX/"etc").exist?
-    (HOMEBREW_PREFIX/"share").rmtree if (HOMEBREW_PREFIX/"share").exist?
+    FileUtils.rm_r(HOMEBREW_PREFIX/"etc") if (HOMEBREW_PREFIX/"etc").exist?
+    FileUtils.rm_r(HOMEBREW_PREFIX/"share") if (HOMEBREW_PREFIX/"share").exist?
   end
 
   specify "#link_completions_and_manpages when completions are disabled for non-official tap" do
     setup_tap_files
     setup_git_repo
     setup_completion link: false
-    tap = described_class.new("NotHomebrew", "baz")
+    tap = described_class.fetch("NotHomebrew", "baz")
     tap.install clone_target: homebrew_foo_tap.path/".git"
     (HOMEBREW_PREFIX/"share/man/man1/brew-tap-cmd.1").delete
     tap.link_completions_and_manpages
@@ -422,15 +451,15 @@ def setup_completion(link:)
     expect(HOMEBREW_PREFIX/"share/fish/vendor_completions.d/brew-tap-cmd.fish").not_to be_a_file
     tap.uninstall
   ensure
-    (HOMEBREW_PREFIX/"etc").rmtree if (HOMEBREW_PREFIX/"etc").exist?
-    (HOMEBREW_PREFIX/"share").rmtree if (HOMEBREW_PREFIX/"share").exist?
+    FileUtils.rm_r(HOMEBREW_PREFIX/"etc") if (HOMEBREW_PREFIX/"etc").exist?
+    FileUtils.rm_r(HOMEBREW_PREFIX/"share") if (HOMEBREW_PREFIX/"share").exist?
   end
 
   specify "#link_completions_and_manpages when completions are enabled for official tap" do
     setup_tap_files
     setup_git_repo
     setup_completion link: false
-    tap = described_class.new("Homebrew", "baz")
+    tap = described_class.fetch("Homebrew", "baz")
     tap.install clone_target: homebrew_foo_tap.path/".git"
     (HOMEBREW_PREFIX/"share/man/man1/brew-tap-cmd.1").delete
     (HOMEBREW_PREFIX/"etc/bash_completion.d/brew-tap-cmd").delete
@@ -443,24 +472,65 @@ def setup_completion(link:)
     expect(HOMEBREW_PREFIX/"share/fish/vendor_completions.d/brew-tap-cmd.fish").to be_a_file
     tap.uninstall
   ensure
-    (HOMEBREW_PREFIX/"etc").rmtree if (HOMEBREW_PREFIX/"etc").exist?
-    (HOMEBREW_PREFIX/"share").rmtree if (HOMEBREW_PREFIX/"share").exist?
+    FileUtils.rm_r(HOMEBREW_PREFIX/"etc") if (HOMEBREW_PREFIX/"etc").exist?
+    FileUtils.rm_r(HOMEBREW_PREFIX/"share") if (HOMEBREW_PREFIX/"share").exist?
   end
 
   specify "#config" do
     setup_git_repo
 
-    expect(homebrew_foo_tap.config["foo"]).to be_nil
-    homebrew_foo_tap.config["foo"] = "bar"
-    expect(homebrew_foo_tap.config["foo"]).to eq("bar")
-    homebrew_foo_tap.config.delete("foo")
-    expect(homebrew_foo_tap.config["foo"]).to be_nil
+    expect(homebrew_foo_tap.config[:foo]).to be_nil
+    homebrew_foo_tap.config[:foo] = true
+    expect(homebrew_foo_tap.config[:foo]).to be true
+    homebrew_foo_tap.config.delete(:foo)
+    expect(homebrew_foo_tap.config[:foo]).to be_nil
   end
 
-  describe "#each" do
+  describe ".each" do
     it "returns an enumerator if no block is passed" do
       expect(described_class.each).to be_an_instance_of(Enumerator)
     end
+
+    context "when the core tap is not installed" do
+      around do |example|
+        FileUtils.rm_rf CoreTap.instance.path
+        example.run
+      ensure
+        (CoreTap.instance.path/"Formula").mkpath
+      end
+
+      it "includes the core tap with the api" do
+        ENV.delete("HOMEBREW_NO_INSTALL_FROM_API")
+        expect(described_class.to_a).to include(CoreTap.instance)
+      end
+
+      it "omits the core tap without the api", :no_api do
+        expect(described_class.to_a).not_to include(CoreTap.instance)
+      end
+    end
+  end
+
+  describe ".installed" do
+    it "includes only installed taps" do
+      expect(described_class.installed)
+        .to contain_exactly(CoreTap.instance, described_class.fetch("homebrew/foo"))
+    end
+  end
+
+  describe ".all" do
+    it "includes the core and cask taps by default", :needs_macos do
+      expect(described_class.all).to contain_exactly(
+        CoreTap.instance,
+        CoreCaskTap.instance,
+        described_class.fetch("homebrew/foo"),
+        described_class.fetch("third-party/tap"),
+      )
+    end
+
+    it "includes the core tap and excludes the cask tap by default", :needs_linux do
+      expect(described_class.all)
+        .to contain_exactly(CoreTap.instance, described_class.fetch("homebrew/foo"))
+    end
   end
 
   describe "Formula Lists" do
@@ -482,6 +552,47 @@ def setup_completion(link:)
       end
     end
 
+    describe "tap migration renames" do
+      before do
+        (path/"tap_migrations.json").write <<~JSON
+          {
+            "adobe-air-sdk": "homebrew/cask",
+            "app-engine-go-32": "homebrew/cask/google-cloud-sdk",
+            "app-engine-go-64": "homebrew/cask/google-cloud-sdk",
+            "gimp": "homebrew/cask",
+            "horndis": "homebrew/cask",
+            "inkscape": "homebrew/cask",
+            "schismtracker": "homebrew/cask/schism-tracker"
+          }
+        JSON
+      end
+
+      describe "#reverse_tap_migration_renames" do
+        it "returns the expected hash" do
+          expect(homebrew_foo_tap.reverse_tap_migrations_renames).to eq({
+            "homebrew/cask/google-cloud-sdk" => %w[app-engine-go-32 app-engine-go-64],
+            "homebrew/cask/schism-tracker"   => %w[schismtracker],
+          })
+        end
+      end
+
+      describe ".tap_migration_oldnames" do
+        let(:cask_tap) { CoreCaskTap.instance }
+        let(:core_tap) { CoreTap.instance }
+
+        it "returns expected renames" do
+          [
+            [cask_tap, "gimp", []],
+            [core_tap, "schism-tracker", []],
+            [cask_tap, "schism-tracker", %w[schismtracker]],
+            [cask_tap, "google-cloud-sdk", %w[app-engine-go-32 app-engine-go-64]],
+          ].each do |tap, name, result|
+            expect(described_class.tap_migration_oldnames(tap, name)).to eq(result)
+          end
+        end
+      end
+    end
+
     describe "#audit_exceptions" do
       it "returns the audit_exceptions hash" do
         setup_tap_files
@@ -521,30 +632,124 @@ def setup_completion(link:)
         expect(homebrew_foo_tap.pypi_formula_mappings).to eq expected_result
       end
     end
+
+    describe "#formula_file?" do
+      it "matches files from Formula/" do
+        tap = described_class.fetch("hard/core")
+        FileUtils.mkdir_p(tap.path/"Formula")
+
+        %w[
+          kvazaar.rb
+          Casks/kvazaar.rb
+          Casks/k/kvazaar.rb
+          Formula/kvazaar.sh
+          HomebrewFormula/kvazaar.rb
+          HomebrewFormula/k/kvazaar.rb
+        ].each do |relative_path|
+          expect(tap).not_to have_formula_file(relative_path)
+        end
+
+        %w[
+          Formula/kvazaar.rb
+          Formula/k/kvazaar.rb
+        ].each do |relative_path|
+          expect(tap).to have_formula_file(relative_path)
+        end
+      ensure
+        FileUtils.rm_rf(tap.path.parent) if tap
+      end
+
+      it "matches files from HomebrewFormula/" do
+        tap = described_class.fetch("hard/core")
+        FileUtils.mkdir_p(tap.path/"HomebrewFormula")
+
+        %w[
+          kvazaar.rb
+          Casks/kvazaar.rb
+          Casks/k/kvazaar.rb
+          Formula/kvazaar.rb
+          Formula/k/kvazaar.rb
+          HomebrewFormula/kvazaar.sh
+        ].each do |relative_path|
+          expect(tap).not_to have_formula_file(relative_path)
+        end
+
+        %w[
+          HomebrewFormula/kvazaar.rb
+          HomebrewFormula/k/kvazaar.rb
+        ].each do |relative_path|
+          expect(tap).to have_formula_file(relative_path)
+        end
+      ensure
+        FileUtils.rm_rf(tap.path.parent) if tap
+      end
+
+      it "matches files from the top-level directory" do
+        tap = described_class.fetch("hard/core")
+        FileUtils.mkdir_p(tap.path)
+
+        %w[
+          kvazaar.sh
+          Casks/kvazaar.rb
+          Casks/k/kvazaar.rb
+          Formula/kvazaar.rb
+          Formula/k/kvazaar.rb
+          HomebrewFormula/kvazaar.rb
+          HomebrewFormula/k/kvazaar.rb
+        ].each do |relative_path|
+          expect(tap).not_to have_formula_file(relative_path)
+        end
+
+        expect(tap).to have_formula_file("kvazaar.rb")
+      ensure
+        FileUtils.rm_rf(tap.path.parent) if tap
+      end
+    end
+
+    describe "#cask_file?" do
+      it "matches files from Casks/" do
+        tap = described_class.fetch("hard/core")
+
+        %w[
+          kvazaar.rb
+          Casks/kvazaar.sh
+          Formula/kvazaar.rb
+          Formula/k/kvazaar.rb
+          HomebrewFormula/kvazaar.rb
+          HomebrewFormula/k/kvazaar.rb
+        ].each do |relative_path|
+          expect(tap).not_to have_cask_file(relative_path)
+        end
+
+        %w[
+          Casks/kvazaar.rb
+          Casks/k/kvazaar.rb
+        ].each do |relative_path|
+          expect(tap).to have_cask_file(relative_path)
+        end
+      end
+    end
   end
 
   describe CoreTap do
-    subject(:core_tap) { described_class.new }
+    subject(:core_tap) { described_class.instance }
 
     specify "attributes" do
       expect(core_tap.user).to eq("Homebrew")
-      expect(core_tap.repo).to eq("core")
+      expect(core_tap.repository).to eq("core")
       expect(core_tap.name).to eq("homebrew/core")
       expect(core_tap.command_files).to eq([])
       expect(core_tap).to be_installed
-      expect(core_tap).not_to be_pinned
       expect(core_tap).to be_official
       expect(core_tap).to be_a_core_tap
     end
 
     specify "forbidden operations" do
       expect { core_tap.uninstall }.to raise_error(RuntimeError)
-      expect { core_tap.pin }.to raise_error(RuntimeError)
-      expect { core_tap.unpin }.to raise_error(RuntimeError)
     end
 
     specify "files" do
-      path = Tap::TAP_DIRECTORY/"homebrew/homebrew-core"
+      path = HOMEBREW_TAP_DIRECTORY/"homebrew/homebrew-core"
       formula_file = core_tap.formula_dir/"foo.rb"
       core_tap.formula_dir.mkpath
       formula_file.write <<~RUBY
@@ -584,4 +789,37 @@ class Foo < Formula
       expect(core_tap.pypi_formula_mappings).to eq formula_list_file_contents
     end
   end
+
+  describe "#repository_var_suffix" do
+    it "converts the repo directory to an environment variable suffix" do
+      expect(CoreTap.instance.repository_var_suffix).to eq "_HOMEBREW_HOMEBREW_CORE"
+    end
+
+    it "converts non-alphanumeric characters to underscores" do
+      expect(described_class.fetch("my",
+                                   "tap-with-dashes").repository_var_suffix).to eq "_MY_HOMEBREW_TAP_WITH_DASHES"
+      expect(described_class.fetch("my",
+                                   "tap-with-@-symbol").repository_var_suffix).to eq "_MY_HOMEBREW_TAP_WITH___SYMBOL"
+    end
+  end
+
+  describe "::with_formula_name" do
+    it "returns the tap and formula name when given a full name" do
+      expect(described_class.with_formula_name("homebrew/core/gcc")).to eq [CoreTap.instance, "gcc"]
+    end
+
+    it "returns nil when given a relative path" do
+      expect(described_class.with_formula_name("./Formula/gcc.rb")).to be_nil
+    end
+  end
+
+  describe "::with_cask_token" do
+    it "returns the tap and cask token when given a full token" do
+      expect(described_class.with_cask_token("homebrew/cask/alfred")).to eq [CoreCaskTap.instance, "alfred"]
+    end
+
+    it "returns nil when given a relative path" do
+      expect(described_class.with_cask_token("./Casks/alfred.rb")).to be_nil
+    end
+  end
 end
diff --git a/Library/Homebrew/test/test_runner_formula_spec.rb b/Library/Homebrew/test/test_runner_formula_spec.rb
new file mode 100644
index 0000000000000..2f46c3598aea7
--- /dev/null
+++ b/Library/Homebrew/test/test_runner_formula_spec.rb
@@ -0,0 +1,420 @@
+# frozen_string_literal: true
+
+require "test_runner_formula"
+require "test/support/fixtures/testball"
+
+RSpec.describe TestRunnerFormula do
+  let(:testball) { Testball.new }
+  let(:xcode_helper) { setup_test_formula("xcode-helper", [:macos]) }
+  let(:linux_kernel_requirer) { setup_test_formula("linux-kernel-requirer", [:linux]) }
+  let(:old_non_portable_software) { setup_test_formula("old-non-portable-software", [arch: :x86_64]) }
+  let(:fancy_new_software) { setup_test_formula("fancy-new-software", [arch: :arm64]) }
+  let(:needs_modern_compiler) { setup_test_formula("needs-modern-compiler", [macos: :ventura]) }
+
+  describe "#initialize" do
+    it "enables the Formulary factory cache" do
+      described_class.new(testball)
+      expect(Formulary.factory_cached?).to be(true)
+    end
+  end
+
+  describe "#name" do
+    it "returns the wrapped Formula's name" do
+      expect(described_class.new(testball).name).to eq(testball.name)
+    end
+  end
+
+  describe "#eval_all" do
+    it "is false by default" do
+      expect(described_class.new(testball).eval_all).to be(false)
+    end
+
+    it "can be instantiated to be `true`" do
+      expect(described_class.new(testball, eval_all: true).eval_all).to be(true)
+    end
+
+    it "takes the value of `HOMEBREW_EVAL_ALL` at instantiation time if not specified" do
+      allow(Homebrew::EnvConfig).to receive(:eval_all?).and_return(true)
+      expect(described_class.new(testball).eval_all).to be(true)
+
+      allow(Homebrew::EnvConfig).to receive(:eval_all?).and_return(false)
+      expect(described_class.new(testball).eval_all).to be(false)
+    end
+  end
+
+  describe "#formula" do
+    it "returns the wrapped Formula" do
+      expect(described_class.new(testball).formula).to eq(testball)
+    end
+  end
+
+  describe "#macos_only?" do
+    context "when a formula requires macOS" do
+      it "returns true" do
+        expect(described_class.new(xcode_helper).macos_only?).to be(true)
+      end
+    end
+
+    context "when a formula does not require macOS" do
+      it "returns false" do
+        expect(described_class.new(testball).macos_only?).to be(false)
+        expect(described_class.new(linux_kernel_requirer).macos_only?).to be(false)
+        expect(described_class.new(old_non_portable_software).macos_only?).to be(false)
+        expect(described_class.new(fancy_new_software).macos_only?).to be(false)
+      end
+    end
+
+    context "when a formula requires only a minimum version of macOS" do
+      it "returns false" do
+        expect(described_class.new(needs_modern_compiler).macos_only?).to be(false)
+      end
+    end
+  end
+
+  describe "#macos_compatible?" do
+    context "when a formula is compatible with macOS" do
+      it "returns true" do
+        expect(described_class.new(testball).macos_compatible?).to be(true)
+        expect(described_class.new(xcode_helper).macos_compatible?).to be(true)
+        expect(described_class.new(old_non_portable_software).macos_compatible?).to be(true)
+        expect(described_class.new(fancy_new_software).macos_compatible?).to be(true)
+      end
+    end
+
+    context "when a formula requires only a minimum version of macOS" do
+      it "returns false" do
+        expect(described_class.new(needs_modern_compiler).macos_compatible?).to be(true)
+      end
+    end
+
+    context "when a formula is not compatible with macOS" do
+      it "returns false" do
+        expect(described_class.new(linux_kernel_requirer).macos_compatible?).to be(false)
+      end
+    end
+  end
+
+  describe "#linux_only?" do
+    context "when a formula requires Linux" do
+      it "returns true" do
+        expect(described_class.new(linux_kernel_requirer).linux_only?).to be(true)
+      end
+    end
+
+    context "when a formula does not require Linux" do
+      it "returns false" do
+        expect(described_class.new(testball).linux_only?).to be(false)
+        expect(described_class.new(xcode_helper).linux_only?).to be(false)
+        expect(described_class.new(old_non_portable_software).linux_only?).to be(false)
+        expect(described_class.new(fancy_new_software).linux_only?).to be(false)
+        expect(described_class.new(needs_modern_compiler).linux_only?).to be(false)
+      end
+    end
+  end
+
+  describe "#linux_compatible?" do
+    context "when a formula is compatible with Linux" do
+      it "returns true" do
+        expect(described_class.new(testball).linux_compatible?).to be(true)
+        expect(described_class.new(linux_kernel_requirer).linux_compatible?).to be(true)
+        expect(described_class.new(old_non_portable_software).linux_compatible?).to be(true)
+        expect(described_class.new(fancy_new_software).linux_compatible?).to be(true)
+        expect(described_class.new(needs_modern_compiler).linux_compatible?).to be(true)
+      end
+    end
+
+    context "when a formula is not compatible with Linux" do
+      it "returns false" do
+        expect(described_class.new(xcode_helper).linux_compatible?).to be(false)
+      end
+    end
+  end
+
+  describe "#x86_64_only?" do
+    context "when a formula requires an Intel architecture" do
+      it "returns true" do
+        expect(described_class.new(old_non_portable_software).x86_64_only?).to be(true)
+      end
+    end
+
+    context "when a formula requires a non-Intel architecture" do
+      it "returns false" do
+        expect(described_class.new(fancy_new_software).x86_64_only?).to be(false)
+      end
+    end
+
+    context "when a formula does not require a specific architecture" do
+      it "returns false" do
+        expect(described_class.new(testball).x86_64_only?).to be(false)
+        expect(described_class.new(xcode_helper).x86_64_only?).to be(false)
+        expect(described_class.new(linux_kernel_requirer).x86_64_only?).to be(false)
+        expect(described_class.new(needs_modern_compiler).x86_64_only?).to be(false)
+      end
+    end
+  end
+
+  describe "#x86_64_compatible?" do
+    context "when a formula is compatible with the Intel architecture" do
+      it "returns true" do
+        expect(described_class.new(testball).x86_64_compatible?).to be(true)
+        expect(described_class.new(xcode_helper).x86_64_compatible?).to be(true)
+        expect(described_class.new(linux_kernel_requirer).x86_64_compatible?).to be(true)
+        expect(described_class.new(old_non_portable_software).x86_64_compatible?).to be(true)
+        expect(described_class.new(needs_modern_compiler).x86_64_compatible?).to be(true)
+      end
+    end
+
+    context "when a formula is not compatible with the Intel architecture" do
+      it "returns false" do
+        expect(described_class.new(fancy_new_software).x86_64_compatible?).to be(false)
+      end
+    end
+  end
+
+  describe "#arm64_only?" do
+    context "when a formula requires an ARM64 architecture" do
+      it "returns true" do
+        expect(described_class.new(fancy_new_software).arm64_only?).to be(true)
+      end
+    end
+
+    context "when a formula requires a non-ARM64 architecture" do
+      it "returns false" do
+        expect(described_class.new(old_non_portable_software).arm64_only?).to be(false)
+      end
+    end
+
+    context "when a formula does not require a specific architecture" do
+      it "returns false" do
+        expect(described_class.new(testball).arm64_only?).to be(false)
+        expect(described_class.new(xcode_helper).arm64_only?).to be(false)
+        expect(described_class.new(linux_kernel_requirer).arm64_only?).to be(false)
+        expect(described_class.new(needs_modern_compiler).arm64_only?).to be(false)
+      end
+    end
+  end
+
+  describe "#arm64_compatible?" do
+    context "when a formula is compatible with an ARM64 architecture" do
+      it "returns true" do
+        expect(described_class.new(testball).arm64_compatible?).to be(true)
+        expect(described_class.new(xcode_helper).arm64_compatible?).to be(true)
+        expect(described_class.new(linux_kernel_requirer).arm64_compatible?).to be(true)
+        expect(described_class.new(fancy_new_software).arm64_compatible?).to be(true)
+        expect(described_class.new(needs_modern_compiler).arm64_compatible?).to be(true)
+      end
+    end
+
+    context "when a formula is not compatible with an ARM64 architecture" do
+      it "returns false" do
+        expect(described_class.new(old_non_portable_software).arm64_compatible?).to be(false)
+      end
+    end
+  end
+
+  describe "#versioned_macos_requirement" do
+    let(:requirement) { described_class.new(needs_modern_compiler).versioned_macos_requirement }
+
+    it "returns a MacOSRequirement with a specified version" do
+      expect(requirement).to be_a(MacOSRequirement)
+      expect(requirement.version_specified?).to be(true)
+    end
+
+    context "when a formula has an unversioned MacOSRequirement" do
+      it "returns nil" do
+        expect(described_class.new(xcode_helper).versioned_macos_requirement).to be_nil
+      end
+    end
+
+    context "when a formula has no declared MacOSRequirement" do
+      it "returns nil" do
+        expect(described_class.new(testball).versioned_macos_requirement).to be_nil
+        expect(described_class.new(linux_kernel_requirer).versioned_macos_requirement).to be_nil
+        expect(described_class.new(old_non_portable_software).versioned_macos_requirement).to be_nil
+        expect(described_class.new(fancy_new_software).versioned_macos_requirement).to be_nil
+      end
+    end
+  end
+
+  describe "#compatible_with?" do
+    context "when a formula has a versioned MacOSRequirement" do
+      context "when passed a compatible macOS version" do
+        it "returns true" do
+          expect(described_class.new(needs_modern_compiler).compatible_with?(MacOSVersion.new("13")))
+            .to be(true)
+        end
+      end
+
+      context "when passed an incompatible macOS version" do
+        it "returns false" do
+          expect(described_class.new(needs_modern_compiler).compatible_with?(MacOSVersion.new("11")))
+            .to be(false)
+        end
+      end
+    end
+
+    context "when a formula has an unversioned MacOSRequirement" do
+      it "returns true" do
+        MacOSVersion::SYMBOLS.each_value do |v|
+          version = MacOSVersion.new(v)
+          expect(described_class.new(xcode_helper).compatible_with?(version)).to be(true)
+        end
+      end
+    end
+
+    context "when a formula has no declared MacOSRequirement" do
+      it "returns true" do
+        MacOSVersion::SYMBOLS.each_value do |v|
+          version = MacOSVersion.new(v)
+          expect(described_class.new(testball).compatible_with?(version)).to be(true)
+          expect(described_class.new(linux_kernel_requirer).compatible_with?(version)).to be(true)
+          expect(described_class.new(old_non_portable_software).compatible_with?(version)).to be(true)
+          expect(described_class.new(fancy_new_software).compatible_with?(version)).to be(true)
+        end
+      end
+    end
+  end
+
+  describe "#dependents" do
+    let(:current_system) do
+      current_arch = case Homebrew::SimulateSystem.current_arch
+      when :arm then :arm64
+      when :intel then :x86_64
+      end
+
+      current_platform = case Homebrew::SimulateSystem.current_os
+      when :generic then :linux
+      else Homebrew::SimulateSystem.current_os
+      end
+
+      {
+        platform:      current_platform,
+        arch:          current_arch,
+        macos_version: nil,
+      }
+    end
+
+    context "when a formula has no dependents" do
+      it "returns an empty array" do
+        expect(described_class.new(testball).dependents(**current_system)).to eq([])
+        expect(described_class.new(xcode_helper).dependents(**current_system)).to eq([])
+        expect(described_class.new(linux_kernel_requirer).dependents(**current_system)).to eq([])
+        expect(described_class.new(old_non_portable_software).dependents(**current_system)).to eq([])
+        expect(described_class.new(fancy_new_software).dependents(**current_system)).to eq([])
+        expect(described_class.new(needs_modern_compiler).dependents(**current_system)).to eq([])
+      end
+    end
+
+    context "when a formula has dependents" do
+      let(:testball_user) { setup_test_formula("testball_user", ["testball"]) }
+      let(:recursive_testball_dependent) { setup_test_formula("recursive_testball_dependent", ["testball_user"]) }
+
+      it "returns an array of direct dependents" do
+        allow(Formula).to receive(:all).and_return([testball_user, recursive_testball_dependent])
+
+        expect(
+          described_class.new(testball, eval_all: true).dependents(**current_system).map(&:name),
+        ).to eq(["testball_user"])
+
+        expect(
+          described_class.new(testball_user, eval_all: true).dependents(**current_system).map(&:name),
+        ).to eq(["recursive_testball_dependent"])
+      end
+
+      context "when called with arguments" do
+        let(:testball_user_intel) { setup_test_formula("testball_user-intel", intel: ["testball"]) }
+        let(:testball_user_arm) { setup_test_formula("testball_user-arm", arm: ["testball"]) }
+        let(:testball_user_macos) { setup_test_formula("testball_user-macos", macos: ["testball"]) }
+        let(:testball_user_linux) { setup_test_formula("testball_user-linux", linux: ["testball"]) }
+        let(:testball_user_ventura) do
+          setup_test_formula("testball_user-ventura", ventura: ["testball"])
+        end
+        let(:testball_and_dependents) do
+          [
+            testball_user,
+            testball_user_intel,
+            testball_user_arm,
+            testball_user_macos,
+            testball_user_linux,
+            testball_user_ventura,
+          ]
+        end
+
+        context "when given { platform: :linux, arch: :x86_64 }" do
+          it "returns only the dependents for the requested platform and architecture" do
+            allow(Formula).to receive(:all).and_wrap_original { testball_and_dependents }
+
+            expect(
+              described_class.new(testball, eval_all: true).dependents(
+                platform: :linux, arch: :x86_64, macos_version: nil,
+              ).map(&:name).sort,
+            ).to eq(["testball_user", "testball_user-intel", "testball_user-linux"].sort)
+          end
+        end
+
+        context "when given { platform: :macos, arch: :x86_64 }" do
+          it "returns only the dependents for the requested platform and architecture" do
+            allow(Formula).to receive(:all).and_wrap_original { testball_and_dependents }
+
+            expect(
+              described_class.new(testball, eval_all: true).dependents(
+                platform: :macos, arch: :x86_64, macos_version: nil,
+              ).map(&:name).sort,
+            ).to eq(["testball_user", "testball_user-intel", "testball_user-macos"].sort)
+          end
+        end
+
+        context "when given `{ platform: :macos, arch: :arm64 }`" do
+          it "returns only the dependents for the requested platform and architecture" do
+            allow(Formula).to receive(:all).and_wrap_original { testball_and_dependents }
+
+            expect(
+              described_class.new(testball, eval_all: true).dependents(
+                platform: :macos, arch: :arm64, macos_version: nil,
+              ).map(&:name).sort,
+            ).to eq(["testball_user", "testball_user-arm", "testball_user-macos"].sort)
+          end
+        end
+
+        context "when given `{ platform: :macos, arch: :x86_64, macos_version: :mojave }`" do
+          it "returns only the dependents for the requested platform and architecture" do
+            allow(Formula).to receive(:all).and_wrap_original { testball_and_dependents }
+
+            expect(
+              described_class.new(testball, eval_all: true).dependents(
+                platform: :macos, arch: :x86_64, macos_version: :mojave,
+              ).map(&:name).sort,
+            ).to eq(["testball_user", "testball_user-intel", "testball_user-macos"].sort)
+          end
+        end
+
+        context "when given `{ platform: :macos, arch: :arm64, macos_version: :ventura }`" do
+          it "returns only the dependents for the requested platform and architecture" do
+            allow(Formula).to receive(:all).and_wrap_original { testball_and_dependents }
+
+            expect(
+              described_class.new(testball, eval_all: true).dependents(
+                platform: :macos, arch: :arm64, macos_version: :ventura,
+              ).map(&:name).sort,
+            ).to eq(%w[testball_user testball_user-arm testball_user-macos testball_user-ventura].sort)
+          end
+        end
+      end
+    end
+  end
+
+  def setup_test_formula(name, dependencies = [], **kwargs)
+    formula name do
+      url "https://brew.sh/#{name}-1.0.tar.gz"
+      dependencies.each { |dependency| depends_on dependency }
+
+      kwargs.each do |k, v|
+        send(:"on_#{k}") do
+          v.each do |dep|
+            depends_on dep
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/test/uninstall_spec.rb b/Library/Homebrew/test/uninstall_spec.rb
index a7c3288d50a4b..530a687310cb0 100644
--- a/Library/Homebrew/test/uninstall_spec.rb
+++ b/Library/Homebrew/test/uninstall_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "uninstall"
 
-describe Homebrew::Uninstall do
+RSpec.describe Homebrew::Uninstall do
   let(:dependency) { formula("dependency") { url "f-1" } }
 
   let(:dependent_formula) do
@@ -34,7 +33,7 @@
 
     tab = Tab.empty
     tab.homebrew_version = "1.1.6"
-    tab.tabfile = dependent_formula.latest_installed_prefix/Tab::FILENAME
+    tab.tabfile = dependent_formula.latest_installed_prefix/AbstractTab::FILENAME
     tab.runtime_dependencies = [
       { "full_name" => "dependency", "version" => "1" },
     ]
@@ -51,25 +50,25 @@
     specify "when developer" do
       ENV["HOMEBREW_DEVELOPER"] = "1"
 
-      expect {
+      expect do
         described_class.handle_unsatisfied_dependents(kegs_by_rack)
-      }.to output(/Warning/).to_stderr
+      end.to output(/Warning/).to_stderr
 
       expect(Homebrew).not_to have_failed
     end
 
     specify "when not developer" do
-      expect {
+      expect do
         described_class.handle_unsatisfied_dependents(kegs_by_rack)
-      }.to output(/Error/).to_stderr
+      end.to output(/Error/).to_stderr
 
       expect(Homebrew).to have_failed
     end
 
     specify "when not developer and `ignore_dependencies` is true" do
-      expect {
+      expect do
         described_class.handle_unsatisfied_dependents(kegs_by_rack, ignore_dependencies: true)
-      }.not_to output.to_stderr
+      end.not_to output.to_stderr
 
       expect(Homebrew).not_to have_failed
     end
diff --git a/Library/Homebrew/test/unpack_strategy/bazaar_spec.rb b/Library/Homebrew/test/unpack_strategy/bazaar_spec.rb
index 0db95af39a557..22d6470a59fa7 100644
--- a/Library/Homebrew/test/unpack_strategy/bazaar_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/bazaar_spec.rb
@@ -1,15 +1,14 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Bazaar do
-  let(:repo) {
+RSpec.describe UnpackStrategy::Bazaar do
+  let(:repo) do
     mktmpdir.tap do |repo|
       FileUtils.touch repo/"test"
       (repo/".bzr").mkpath
     end
-  }
+  end
   let(:path) { repo }
 
   include_examples "UnpackStrategy::detect"
diff --git a/Library/Homebrew/test/unpack_strategy/bzip2_spec.rb b/Library/Homebrew/test/unpack_strategy/bzip2_spec.rb
index 126985010d43c..1855bc58d96cf 100644
--- a/Library/Homebrew/test/unpack_strategy/bzip2_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/bzip2_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Bzip2 do
+RSpec.describe UnpackStrategy::Bzip2 do
   let(:path) { TEST_FIXTURE_DIR/"cask/container.bz2" }
 
   include_examples "UnpackStrategy::detect"
diff --git a/Library/Homebrew/test/unpack_strategy/cvs_spec.rb b/Library/Homebrew/test/unpack_strategy/cvs_spec.rb
index 2b9ebaa58df35..6234465c1611c 100644
--- a/Library/Homebrew/test/unpack_strategy/cvs_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/cvs_spec.rb
@@ -1,15 +1,14 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Cvs do
-  let(:repo) {
+RSpec.describe UnpackStrategy::Cvs do
+  let(:repo) do
     mktmpdir.tap do |repo|
       FileUtils.touch repo/"test"
       (repo/"CVS").mkpath
     end
-  }
+  end
   let(:path) { repo }
 
   include_examples "UnpackStrategy::detect"
diff --git a/Library/Homebrew/test/unpack_strategy/directory_spec.rb b/Library/Homebrew/test/unpack_strategy/directory_spec.rb
index ae12a37704429..339066900b48b 100644
--- a/Library/Homebrew/test/unpack_strategy/directory_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/directory_spec.rb
@@ -1,44 +1,114 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Directory do
-  subject(:strategy) { described_class.new(path) }
-
-  let(:path) {
+RSpec.describe UnpackStrategy::Directory do
+  let(:path) do
     mktmpdir.tap do |path|
       FileUtils.touch path/"file"
       FileUtils.ln_s "file", path/"symlink"
+      FileUtils.ln path/"file", path/"hardlink"
       FileUtils.mkdir path/"folder"
       FileUtils.ln_s "folder", path/"folderSymlink"
     end
-  }
+  end
 
   let(:unpack_dir) { mktmpdir }
 
-  it "does not follow symlinks" do
-    strategy.extract(to: unpack_dir)
-    expect(unpack_dir/"symlink").to be_a_symlink
-  end
+  shared_examples "extract directory" do |move:|
+    subject(:strategy) { described_class.new(path, move:) }
 
-  it "does not follow top level symlinks to directories" do
-    strategy.extract(to: unpack_dir)
-    expect(unpack_dir/"folderSymlink").to be_a_symlink
-  end
+    it "does not follow symlinks" do
+      strategy.extract(to: unpack_dir)
+      expect(unpack_dir/"symlink").to be_a_symlink
+    end
+
+    it "does not follow top level symlinks to directories" do
+      strategy.extract(to: unpack_dir)
+      expect(unpack_dir/"folderSymlink").to be_a_symlink
+    end
+
+    it "preserves permissions of contained files" do
+      FileUtils.chmod 0644, path/"file"
+
+      strategy.extract(to: unpack_dir)
+      expect((unpack_dir/"file").stat.mode & 0777).to eq 0644
+    end
+
+    it "preserves permissions of contained subdirectories" do
+      FileUtils.mkdir unpack_dir/"folder"
+      FileUtils.chmod 0755, unpack_dir/"folder"
+      FileUtils.chmod 0700, path/"folder"
+
+      strategy.extract(to: unpack_dir)
+      expect((unpack_dir/"folder").stat.mode & 0777).to eq 0700
+    end
+
+    it "preserves permissions of the destination directory" do
+      FileUtils.chmod 0700, path
+      FileUtils.chmod 0755, unpack_dir
+
+      strategy.extract(to: unpack_dir)
+      expect(unpack_dir.stat.mode & 0777).to eq 0755
+    end
 
-  it "preserves permissions of contained files" do
-    FileUtils.chmod 0644, path/"file"
+    it "preserves mtime of contained files and directories" do
+      FileUtils.mkdir unpack_dir/"folder"
+      FileUtils.touch path/"folder", mtime: Time.utc(2000, 1, 2, 3, 4, 5, 678999), nocreate: true
+      mtimes = path.children.to_h { |child| [child.basename, child.lstat.mtime] }
 
-    strategy.extract(to: unpack_dir)
-    expect((unpack_dir/"file").stat.mode & 0777).to eq 0644
+      strategy.extract(to: unpack_dir)
+      expect(unpack_dir.children.to_h { |child| [child.basename, child.lstat.mtime] }).to eq mtimes
+    end
+
+    it "preserves unrelated destination files and subdirectories" do
+      FileUtils.touch unpack_dir/"existing_file"
+      FileUtils.mkdir unpack_dir/"existing_folder"
+
+      strategy.extract(to: unpack_dir)
+      expect(unpack_dir/"existing_file").to be_a_file
+      expect(unpack_dir/"existing_folder").to be_a_directory
+    end
+
+    it "overwrites destination files/symlinks with source files/symlinks" do
+      FileUtils.mkdir unpack_dir/"existing_folder"
+      FileUtils.ln_s unpack_dir/"existing_folder", unpack_dir/"symlink"
+      (unpack_dir/"file").write "existing contents"
+
+      strategy.extract(to: unpack_dir)
+      expect((unpack_dir/"file").read).to be_empty
+      expect((unpack_dir/"symlink").readlink).to eq Pathname("file")
+    end
+
+    it "fails when overwriting a directory with a file" do
+      FileUtils.mkdir unpack_dir/"file"
+      expect { strategy.extract(to: unpack_dir) }.to raise_error(/Is a directory|cannot overwrite directory/i)
+    end
+
+    it "fails when overwriting a nested directory with a file" do
+      FileUtils.touch path/"folder/nested"
+      FileUtils.mkdir_p unpack_dir/"folder/nested"
+      expect { strategy.extract(to: unpack_dir) }.to raise_error(/Is a directory|cannot overwrite directory/i)
+    end
+  end
+
+  context "with `move: false`" do
+    include_examples "extract directory", move: false
   end
 
-  it "preserves the permissions of the destination directory" do
-    FileUtils.chmod 0700, path
-    FileUtils.chmod 0755, unpack_dir
+  context "with `move: true`" do
+    include_examples "extract directory", move: true
+
+    it "preserves hardlinks" do
+      strategy.extract(to: unpack_dir)
+      expect((unpack_dir/"file").stat.ino).to eq (unpack_dir/"hardlink").stat.ino
+    end
 
-    strategy.extract(to: unpack_dir)
-    expect(unpack_dir.stat.mode & 0777).to eq 0755
+    # NOTE: We don't test `move: false` because system cp behaviour is inconsistent,
+    # e.g. Ventura cp does not error but Sequoia and Linux cp will error
+    it "fails when overwriting a file with a directory" do
+      FileUtils.touch unpack_dir/"folder"
+      expect { strategy.extract(to: unpack_dir) }.to raise_error(/cannot overwrite non-directory/i)
+    end
   end
 end
diff --git a/Library/Homebrew/test/unpack_strategy/dmg_spec.rb b/Library/Homebrew/test/unpack_strategy/dmg_spec.rb
index 7b30d119c4f59..5099921249911 100644
--- a/Library/Homebrew/test/unpack_strategy/dmg_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/dmg_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Dmg, :needs_macos do
+RSpec.describe UnpackStrategy::Dmg, :needs_macos do
   describe "#mount" do
     let(:path) { TEST_FIXTURE_DIR/"cask/container.dmg" }
 
diff --git a/Library/Homebrew/test/unpack_strategy/git_spec.rb b/Library/Homebrew/test/unpack_strategy/git_spec.rb
index b3831b731dff6..0d8cd311a927f 100644
--- a/Library/Homebrew/test/unpack_strategy/git_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/git_spec.rb
@@ -1,10 +1,9 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Git do
-  let(:repo) {
+RSpec.describe UnpackStrategy::Git do
+  let(:repo) do
     mktmpdir.tap do |repo|
       system "git", "-C", repo, "init"
 
@@ -12,7 +11,7 @@
       system "git", "-C", repo, "add", "test"
       system "git", "-C", repo, "commit", "-m", "Add `test` file."
     end
-  }
+  end
   let(:path) { repo }
 
   include_examples "UnpackStrategy::detect"
diff --git a/Library/Homebrew/test/unpack_strategy/gzip_spec.rb b/Library/Homebrew/test/unpack_strategy/gzip_spec.rb
index 0f85ad24dbce2..b91668e7264e4 100644
--- a/Library/Homebrew/test/unpack_strategy/gzip_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/gzip_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Gzip do
+RSpec.describe UnpackStrategy::Gzip do
   let(:path) { TEST_FIXTURE_DIR/"cask/container.gz" }
 
   include_examples "UnpackStrategy::detect"
diff --git a/Library/Homebrew/test/unpack_strategy/jar_spec.rb b/Library/Homebrew/test/unpack_strategy/jar_spec.rb
index 042f9bf01a8c0..cd3e3108e4cec 100644
--- a/Library/Homebrew/test/unpack_strategy/jar_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/jar_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Jar, :needs_unzip do
+RSpec.describe UnpackStrategy::Jar, :needs_unzip do
   let(:path) { TEST_FIXTURE_DIR/"test.jar" }
 
   include_examples "UnpackStrategy::detect"
diff --git a/Library/Homebrew/test/unpack_strategy/lha_spec.rb b/Library/Homebrew/test/unpack_strategy/lha_spec.rb
index 18921910b8085..caff62bfcdf03 100644
--- a/Library/Homebrew/test/unpack_strategy/lha_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/lha_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Lha do
+RSpec.describe UnpackStrategy::Lha do
   let(:path) { TEST_FIXTURE_DIR/"test.lha" }
 
   include_examples "UnpackStrategy::detect"
diff --git a/Library/Homebrew/test/unpack_strategy/lzip_spec.rb b/Library/Homebrew/test/unpack_strategy/lzip_spec.rb
index cd4932c915492..eb809f4e608d6 100644
--- a/Library/Homebrew/test/unpack_strategy/lzip_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/lzip_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Lzip do
+RSpec.describe UnpackStrategy::Lzip do
   let(:path) { TEST_FIXTURE_DIR/"test.lz" }
 
   include_examples "UnpackStrategy::detect"
diff --git a/Library/Homebrew/test/unpack_strategy/mercurial_spec.rb b/Library/Homebrew/test/unpack_strategy/mercurial_spec.rb
index c29066ff78885..90ae85a5bd8e3 100644
--- a/Library/Homebrew/test/unpack_strategy/mercurial_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/mercurial_spec.rb
@@ -1,14 +1,13 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Mercurial do
-  let(:repo) {
+RSpec.describe UnpackStrategy::Mercurial do
+  let(:repo) do
     mktmpdir.tap do |repo|
       (repo/".hg").mkpath
     end
-  }
+  end
   let(:path) { repo }
 
   include_examples "UnpackStrategy::detect"
diff --git a/Library/Homebrew/test/unpack_strategy/p7zip_spec.rb b/Library/Homebrew/test/unpack_strategy/p7zip_spec.rb
index 09386a1771954..8785155ec333e 100644
--- a/Library/Homebrew/test/unpack_strategy/p7zip_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/p7zip_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::P7Zip do
+RSpec.describe UnpackStrategy::P7Zip do
   let(:path) { TEST_FIXTURE_DIR/"cask/container.7z" }
 
   include_examples "UnpackStrategy::detect"
diff --git a/Library/Homebrew/test/unpack_strategy/rar_spec.rb b/Library/Homebrew/test/unpack_strategy/rar_spec.rb
index 9ddea401fb6b6..c5f8c406ba1c8 100644
--- a/Library/Homebrew/test/unpack_strategy/rar_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/rar_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Rar do
+RSpec.describe UnpackStrategy::Rar do
   let(:path) { TEST_FIXTURE_DIR/"cask/container.rar" }
 
   include_examples "UnpackStrategy::detect"
diff --git a/Library/Homebrew/test/unpack_strategy/shared_examples.rb b/Library/Homebrew/test/unpack_strategy/shared_examples.rb
index 3c034d0086102..f3790fdd08af5 100644
--- a/Library/Homebrew/test/unpack_strategy/shared_examples.rb
+++ b/Library/Homebrew/test/unpack_strategy/shared_examples.rb
@@ -1,15 +1,14 @@
-# typed: false
 # frozen_string_literal: true
 
 require "unpack_strategy"
 
-shared_examples "UnpackStrategy::detect" do
+RSpec.shared_examples "UnpackStrategy::detect" do
   it "is correctly detected" do
     expect(UnpackStrategy.detect(path)).to be_a described_class
   end
 end
 
-shared_examples "#extract" do |children: []|
+RSpec.shared_examples "#extract" do |children: []|
   specify "#extract" do
     mktmpdir do |unpack_dir|
       described_class.new(path).extract(to: unpack_dir)
diff --git a/Library/Homebrew/test/unpack_strategy/subversion_spec.rb b/Library/Homebrew/test/unpack_strategy/subversion_spec.rb
index d1baca44bb541..fea9fd702f75f 100644
--- a/Library/Homebrew/test/unpack_strategy/subversion_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/subversion_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Subversion, :needs_svn do
+RSpec.describe UnpackStrategy::Subversion, :needs_svn do
   let(:repo) { mktmpdir }
   let(:working_copy) { mktmpdir }
   let(:path) { working_copy }
diff --git a/Library/Homebrew/test/unpack_strategy/tar_spec.rb b/Library/Homebrew/test/unpack_strategy/tar_spec.rb
index 078762a1247d8..0307e4121007a 100644
--- a/Library/Homebrew/test/unpack_strategy/tar_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/tar_spec.rb
@@ -1,20 +1,19 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Tar do
+RSpec.describe UnpackStrategy::Tar do
   let(:path) { TEST_FIXTURE_DIR/"cask/container.tar.gz" }
 
   include_examples "UnpackStrategy::detect"
   include_examples "#extract", children: ["container"]
 
   context "when TAR archive is corrupted" do
-    let(:path) {
+    let(:path) do
       (mktmpdir/"test.tar").tap do |path|
         FileUtils.touch path
       end
-    }
+    end
 
     include_examples "UnpackStrategy::detect"
   end
diff --git a/Library/Homebrew/test/unpack_strategy/uncompressed_spec.rb b/Library/Homebrew/test/unpack_strategy/uncompressed_spec.rb
index 857ac134e6f6d..19341c733f7c7 100644
--- a/Library/Homebrew/test/unpack_strategy/uncompressed_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/uncompressed_spec.rb
@@ -1,14 +1,13 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Uncompressed do
-  let(:path) {
+RSpec.describe UnpackStrategy::Uncompressed do
+  let(:path) do
     (mktmpdir/"test").tap do |path|
       FileUtils.touch path
     end
-  }
+  end
 
   include_examples "UnpackStrategy::detect"
 end
diff --git a/Library/Homebrew/test/unpack_strategy/xar_spec.rb b/Library/Homebrew/test/unpack_strategy/xar_spec.rb
index 28870a2d78d7a..41b7a0b558101 100644
--- a/Library/Homebrew/test/unpack_strategy/xar_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/xar_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Xar, :needs_macos do
+RSpec.describe UnpackStrategy::Xar, :needs_macos do
   let(:path) { TEST_FIXTURE_DIR/"cask/container.xar" }
 
   include_examples "UnpackStrategy::detect"
diff --git a/Library/Homebrew/test/unpack_strategy/xz_spec.rb b/Library/Homebrew/test/unpack_strategy/xz_spec.rb
index f6befa95af293..efdac2253ae2f 100644
--- a/Library/Homebrew/test/unpack_strategy/xz_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/xz_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Xz do
+RSpec.describe UnpackStrategy::Xz do
   let(:path) { TEST_FIXTURE_DIR/"cask/container.xz" }
 
   include_examples "UnpackStrategy::detect"
diff --git a/Library/Homebrew/test/unpack_strategy/zip_spec.rb b/Library/Homebrew/test/unpack_strategy/zip_spec.rb
index dd27c5de48adc..cc2c4c5d163b4 100644
--- a/Library/Homebrew/test/unpack_strategy/zip_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/zip_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Zip do
+RSpec.describe UnpackStrategy::Zip do
   let(:path) { TEST_FIXTURE_DIR/"cask/MyFancyApp.zip" }
 
   include_examples "UnpackStrategy::detect"
@@ -13,11 +12,11 @@
   end
 
   context "when ZIP archive is corrupted" do
-    let(:path) {
+    let(:path) do
       (mktmpdir/"test.zip").tap do |path|
         FileUtils.touch path
       end
-    }
+    end
 
     include_examples "UnpackStrategy::detect"
   end
diff --git a/Library/Homebrew/test/unpack_strategy/zstd_spec.rb b/Library/Homebrew/test/unpack_strategy/zstd_spec.rb
index 6e9198b996b0e..b439ed657f262 100644
--- a/Library/Homebrew/test/unpack_strategy/zstd_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy/zstd_spec.rb
@@ -1,10 +1,16 @@
-# typed: false
 # frozen_string_literal: true
 
 require_relative "shared_examples"
 
-describe UnpackStrategy::Zstd do
+RSpec.describe UnpackStrategy::Zstd do
   let(:path) { TEST_FIXTURE_DIR/"cask/container.tar.zst" }
 
-  include_examples "UnpackStrategy::detect"
+  it "is correctly detected" do
+    # `UnpackStrategy.detect(path)` for a `.tar.XXX` file returns either `UnpackStrategy::Tar` if
+    # the host's `tar` is able to extract that compressed file or `UnpackStrategy::XXX` otherwise,
+    # such as `UnpackStrategy::Zstd`. On macOS `UnpackStrategy.detect("container.tar.zst")`
+    # returns `UnpackStrategy::Zstd` and on Ubuntu 22.04 it returns `UnpackStrategy::Tar`,
+    # because the host's version of `tar` is recent enough and `zstd` is installed.
+    expect(UnpackStrategy.detect(path)).to(be_a(described_class).or(be_a(UnpackStrategy::Tar)))
+  end
 end
diff --git a/Library/Homebrew/test/unpack_strategy_spec.rb b/Library/Homebrew/test/unpack_strategy_spec.rb
index 279bf48f37607..2794f9f488958 100644
--- a/Library/Homebrew/test/unpack_strategy_spec.rb
+++ b/Library/Homebrew/test/unpack_strategy_spec.rb
@@ -1,7 +1,6 @@
-# typed: false
 # frozen_string_literal: true
 
-describe UnpackStrategy do
+RSpec.describe UnpackStrategy do
   describe "#extract_nestedly" do
     subject(:strategy) { described_class.detect(path) }
 
@@ -9,7 +8,7 @@
 
     context "when extracting a GZIP nested in a BZIP2" do
       let(:file_name) { "file" }
-      let(:path) {
+      let(:path) do
         dir = mktmpdir
 
         (dir/"file").write "This file was inside a GZIP inside a BZIP2."
@@ -17,7 +16,7 @@
         system "bzip2", dir.children.first
 
         dir.children.first
-      }
+      end
 
       it "can extract nested archives" do
         strategy.extract_nestedly(to: unpack_dir)
@@ -28,34 +27,63 @@
 
     context "when extracting a directory with nested directories" do
       let(:directories) { "A/B/C" }
-      let(:path) {
+      let(:executable) { "#{directories}/executable" }
+      let(:writable) { true }
+      let(:path) do
         (mktmpdir/"file.tar").tap do |path|
-          mktmpdir do |dir|
+          Dir.mktmpdir do |dir|
+            dir = Pathname(dir)
             (dir/directories).mkpath
-            system "tar", "--create", "--file", path, "--directory", dir, "A/"
+            FileUtils.touch dir/executable
+            FileUtils.chmod 0555, dir/executable
+
+            FileUtils.chmod "-w", dir/directories unless writable
+            begin
+              system "tar", "--create", "--file", path, "--directory", dir, "A/"
+            ensure
+              FileUtils.chmod "+w", dir/directories unless writable
+            end
           end
         end
-      }
+      end
 
       it "does not recurse into nested directories" do
         strategy.extract_nestedly(to: unpack_dir)
         expect(Pathname.glob(unpack_dir/"**/*")).to include unpack_dir/directories
       end
+
+      context "which are not writable" do
+        let(:writable) { false }
+
+        it "makes them writable but not world-writable" do
+          strategy.extract_nestedly(to: unpack_dir)
+
+          expect(unpack_dir/directories).to be_writable
+          expect(unpack_dir/directories).not_to be_world_writable
+        end
+
+        it "does not make other files writable" do
+          strategy.extract_nestedly(to: unpack_dir)
+
+          # We don't check `writable?` here as that's always true as root.
+          expect((unpack_dir/executable).stat.mode & 0222).to be_zero
+        end
+      end
     end
 
     context "when extracting a nested archive" do
       let(:basename) { "file.xyz" }
-      let(:path) {
+      let(:path) do
         (mktmpdir/basename).tap do |path|
           mktmpdir do |dir|
             FileUtils.touch dir/"file.txt"
             system "tar", "--create", "--file", path, "--directory", dir, "file.txt"
           end
         end
-      }
+      end
 
       it "does not pass down the basename of the archive" do
-        strategy.extract_nestedly(to: unpack_dir, basename: basename)
+        strategy.extract_nestedly(to: unpack_dir, basename:)
         expect(unpack_dir/"file.txt").to be_a_file
       end
     end
diff --git a/Library/Homebrew/test/utils/analytics_spec.rb b/Library/Homebrew/test/utils/analytics_spec.rb
index de1e8c5d25b90..4428b1423acab 100644
--- a/Library/Homebrew/test/utils/analytics_spec.rb
+++ b/Library/Homebrew/test/utils/analytics_spec.rb
@@ -1,77 +1,107 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/analytics"
 require "formula_installer"
 
-describe Utils::Analytics do
-  describe "::os_arch_prefix_ci" do
-    context "when os_arch_prefix_ci is not set" do
-      before do
-        described_class.clear_os_arch_prefix_ci
-      end
+RSpec.describe Utils::Analytics do
+  describe "::default_package_tags" do
+    let(:ci) { ", CI" if ENV["CI"] }
 
-      let(:ci) { ", CI" if ENV["CI"] }
+    it "returns OS_VERSION and prefix when HOMEBREW_PREFIX is a custom prefix on intel" do
+      expect(Homebrew).to receive(:default_prefix?).and_return(false).at_least(:once)
+      expect(described_class.default_package_tags).to have_key(:prefix)
+      expect(described_class.default_package_tags[:prefix]).to eq "custom-prefix"
+    end
 
-      it "returns OS_VERSION and prefix when HOMEBREW_PREFIX is a custom prefix on intel" do
-        allow(Hardware::CPU).to receive(:type).and_return(:intel)
-        allow(Hardware::CPU).to receive(:in_rosetta2?).and_return(false)
-        allow(Homebrew).to receive(:default_prefix?).and_return(false)
-        expected = "#{OS_VERSION}, #{described_class.custom_prefix_label}#{ci}"
-        expect(described_class.os_arch_prefix_ci).to eq expected
-      end
+    it "returns OS_VERSION, ARM and prefix when HOMEBREW_PREFIX is a custom prefix on arm" do
+      expect(Homebrew).to receive(:default_prefix?).and_return(false).at_least(:once)
+      expect(described_class.default_package_tags).to have_key(:arch)
+      expect(described_class.default_package_tags[:arch]).to eq HOMEBREW_PHYSICAL_PROCESSOR
+      expect(described_class.default_package_tags).to have_key(:prefix)
+      expect(described_class.default_package_tags[:prefix]).to eq "custom-prefix"
+    end
 
-      it "returns OS_VERSION, ARM and prefix when HOMEBREW_PREFIX is a custom prefix on arm" do
-        allow(Hardware::CPU).to receive(:type).and_return(:arm)
-        allow(Hardware::CPU).to receive(:in_rosetta2?).and_return(false)
-        allow(Homebrew).to receive(:default_prefix?).and_return(false)
-        expected = "#{OS_VERSION}, ARM, #{described_class.custom_prefix_label}#{ci}"
-        expect(described_class.os_arch_prefix_ci).to eq expected
-      end
+    it "returns OS_VERSION, Rosetta and prefix when HOMEBREW_PREFIX is a custom prefix on Rosetta", :needs_macos do
+      expect(Homebrew).to receive(:default_prefix?).and_return(false).at_least(:once)
+      expect(described_class.default_package_tags).to have_key(:prefix)
+      expect(described_class.default_package_tags[:prefix]).to eq "custom-prefix"
+    end
 
-      it "returns OS_VERSION, Rosetta and prefix when HOMEBREW_PREFIX is a custom prefix on Rosetta", :needs_macos do
-        allow(Hardware::CPU).to receive(:type).and_return(:intel)
-        allow(Hardware::CPU).to receive(:in_rosetta2?).and_return(true)
-        allow(Homebrew).to receive(:default_prefix?).and_return(false)
-        expected = "#{OS_VERSION}, Rosetta, #{described_class.custom_prefix_label}#{ci}"
-        expect(described_class.os_arch_prefix_ci).to eq expected
-      end
+    it "does not include prefix when HOMEBREW_PREFIX is the default prefix" do
+      expect(Homebrew).to receive(:default_prefix?).and_return(true).at_least(:once)
+      expect(described_class.default_package_tags).to have_key(:prefix)
+      expect(described_class.default_package_tags[:prefix]).to eq HOMEBREW_PREFIX.to_s
+    end
 
-      it "does not include prefix when HOMEBREW_PREFIX is the default prefix" do
-        allow(Homebrew).to receive(:default_prefix?).and_return(true)
-        expect(described_class.os_arch_prefix_ci).not_to include(described_class.custom_prefix_label)
-      end
+    it "includes CI when ENV['CI'] is set" do
+      ENV["CI"] = "1"
+      expect(described_class.default_package_tags).to have_key(:ci)
+    end
 
-      it "includes CI when ENV['CI'] is set" do
-        ENV["CI"] = "true"
-        expect(described_class.os_arch_prefix_ci).to include("CI")
-      end
+    it "includes developer when ENV['HOMEBREW_DEVELOPER'] is set" do
+      expect(Homebrew::EnvConfig).to receive(:developer?).and_return(true)
+      expect(described_class.default_package_tags).to have_key(:developer)
     end
   end
 
-  describe "::report_event" do
+  describe "::report_package_event" do
     let(:f) { formula { url "foo-1.0" } }
-    let(:options) { FormulaInstaller.new(f).display_options(f) }
-    let(:action)  { "#{f.full_name} #{options}".strip }
+    let(:package_name)  { f.name }
+    let(:tap_name) { f.tap.name }
+    let(:on_request) { false }
+    let(:options) { "--HEAD" }
 
     context "when ENV vars is set" do
       it "returns nil when HOMEBREW_NO_ANALYTICS is true" do
         ENV["HOMEBREW_NO_ANALYTICS"] = "true"
-        expect(described_class.report_event("install", action)).to be_nil
+        expect(described_class).not_to receive(:report_influx)
+        described_class.report_package_event(:install, package_name:, tap_name:,
+          on_request:, options:)
       end
 
       it "returns nil when HOMEBREW_NO_ANALYTICS_THIS_RUN is true" do
         ENV["HOMEBREW_NO_ANALYTICS_THIS_RUN"] = "true"
-        expect(described_class.report_event("install", action)).to be_nil
+        expect(described_class).not_to receive(:report_influx)
+        described_class.report_package_event(:install, package_name:, tap_name:,
+          on_request:, options:)
       end
 
       it "returns nil when HOMEBREW_ANALYTICS_DEBUG is true" do
         ENV.delete("HOMEBREW_NO_ANALYTICS_THIS_RUN")
         ENV.delete("HOMEBREW_NO_ANALYTICS")
         ENV["HOMEBREW_ANALYTICS_DEBUG"] = "true"
-        expect(described_class.report_event("install", action)).to be_nil
+        expect(described_class).to receive(:report_influx)
+
+        described_class.report_package_event(:install, package_name:, tap_name:,
+          on_request:, options:)
       end
     end
+
+    it "passes to the influxdb method" do
+      ENV.delete("HOMEBREW_NO_ANALYTICS_THIS_RUN")
+      ENV.delete("HOMEBREW_NO_ANALYTICS")
+      ENV["HOMEBREW_ANALYTICS_DEBUG"] = "true"
+      expect(described_class).to receive(:report_influx).with(:install, hash_including(on_request:),
+                                                              hash_including(package: package_name)).once
+      described_class.report_package_event(:install, package_name:, tap_name:,
+          on_request:, options:)
+    end
+  end
+
+  describe "::report_influx" do
+    let(:f) { formula { url "foo-1.0" } }
+    let(:package)  { f.name }
+    let(:tap_name) { f.tap.name }
+    let(:on_request) { false }
+    let(:options) { "--HEAD" }
+
+    it "outputs in debug mode" do
+      ENV.delete("HOMEBREW_NO_ANALYTICS_THIS_RUN")
+      ENV.delete("HOMEBREW_NO_ANALYTICS")
+      ENV["HOMEBREW_ANALYTICS_DEBUG"] = "true"
+      expect(described_class).to receive(:deferred_curl).once
+      described_class.report_influx(:install, { on_request: }, { package:, tap_name: })
+    end
   end
 
   describe "::report_build_error" do
@@ -81,35 +111,78 @@
 
       it "reports event if BuildError raised for a formula with a public remote repository" do
         allow_any_instance_of(Tap).to receive(:custom_remote?).and_return(false)
-        expect(described_class).to respond_to(:report_event)
+        expect(described_class).to respond_to(:report_package_event)
         described_class.report_build_error(err)
       end
 
       it "does not report event if BuildError raised for a formula with a private remote repository" do
-        expect(described_class.report_build_error(err)).to be_nil
+        allow_any_instance_of(Tap).to receive(:private?).and_return(true)
+        expect(described_class).not_to receive(:report_package_event)
+        described_class.report_build_error(err)
       end
     end
 
     context "when formula does not have a tap" do
       let(:err) { BuildError.new(f, "badprg", %w[arg1 arg2], {}) }
-      let(:f) { double(Formula, name: "foo", path: "blah", tap: nil) }
+      let(:f) { instance_double(Formula, name: "foo", path: "blah", tap: nil) }
 
       it "does not report event if BuildError is raised" do
-        expect(described_class.report_build_error(err)).to be_nil
+        expect(described_class).not_to receive(:report_package_event)
+        described_class.report_build_error(err)
       end
     end
 
     context "when tap for a formula is not installed" do
       let(:err) { BuildError.new(f, "badprg", %w[arg1 arg2], {}) }
-      let(:f) { double(Formula, name: "foo", path: "blah", tap: CoreTap.instance) }
+      let(:f) { instance_double(Formula, name: "foo", path: "blah", tap: CoreTap.instance) }
 
       it "does not report event if BuildError is raised" do
         allow_any_instance_of(Pathname).to receive(:directory?).and_return(false)
-        expect(described_class.report_build_error(err)).to be_nil
+        expect(described_class).not_to receive(:report_package_event)
+        described_class.report_build_error(err)
       end
     end
   end
 
+  describe "::report_command_run" do
+    let(:command) { "audit" }
+    let(:options) { "--tap=" }
+    let(:command_instance) do
+      require "dev-cmd/audit"
+      Homebrew::DevCmd::Audit.new(["--tap=homebrew/core"])
+    end
+
+    it "passes to the influxdb method" do
+      ENV.delete("HOMEBREW_NO_ANALYTICS_THIS_RUN")
+      ENV.delete("HOMEBREW_NO_ANALYTICS")
+      ENV["HOMEBREW_ANALYTICS_DEBUG"] = "true"
+      expect(described_class).to receive(:report_influx).with(
+        :command_run,
+        hash_including(command:),
+        hash_including(options:),
+      ).once
+      described_class.report_command_run(command_instance)
+    end
+  end
+
+  describe "::report_test_bot_test" do
+    let(:command) { "install wget" }
+    let(:passed) { true }
+
+    it "passes to the influxdb method" do
+      ENV.delete("HOMEBREW_NO_ANALYTICS_THIS_RUN")
+      ENV.delete("HOMEBREW_NO_ANALYTICS")
+      ENV["HOMEBREW_ANALYTICS_DEBUG"] = "true"
+      ENV["HOMEBREW_TEST_BOT_ANALYTICS"] = "true"
+      expect(described_class).to receive(:report_influx).with(
+        :test_bot_test,
+        hash_including(passed:),
+        hash_including(command:),
+      ).once
+      described_class.report_test_bot_test(command, passed)
+    end
+  end
+
   specify "::table_output" do
     results = { ack: 10, wget: 100 }
     expect { described_class.table_output("install", "30", results) }
diff --git a/Library/Homebrew/test/utils/ast/ast_spec.rb b/Library/Homebrew/test/utils/ast/ast_spec.rb
index 1f9dc30ffcad2..cdd35b7854853 100644
--- a/Library/Homebrew/test/utils/ast/ast_spec.rb
+++ b/Library/Homebrew/test/utils/ast/ast_spec.rb
@@ -1,17 +1,16 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/ast"
 
-describe Utils::AST do
+RSpec.describe Utils::AST do
   describe ".stanza_text" do
     let(:compound_license) do
-      <<~RUBY.chomp
-        license all_of: [
-          :public_domain,
-          "MIT",
-          "GPL-3.0-or-later" => { with: "Autoconf-exception-3.0" },
-        ]
+      <<-RUBY
+  license all_of: [
+    :public_domain,
+    "MIT",
+    "GPL-3.0-or-later" => { with: "Autoconf-exception-3.0" },
+  ]
       RUBY
     end
 
@@ -37,14 +36,14 @@
     it "adds indent to stanza text if specified" do
       expect(described_class.stanza_text(:revision, "revision 1", indent: 2)).to eq("  revision 1")
       expect(described_class.stanza_text(:license, 'license "MIT"', indent: 2)).to eq('  license "MIT"')
-      expect(described_class.stanza_text(:license, compound_license, indent: 2)).to eq(compound_license.indent(2))
+      expect(described_class.stanza_text(:license, compound_license, indent: 2)).to eq(compound_license)
     end
 
     it "does not add indent if already indented" do
       expect(described_class.stanza_text(:revision, "  revision 1", indent: 2)).to eq("  revision 1")
       expect(
-        described_class.stanza_text(:license, compound_license.indent(2), indent: 2),
-      ).to eq(compound_license.indent(2))
+        described_class.stanza_text(:license, compound_license, indent: 2),
+      ).to eq(compound_license)
     end
   end
 end
diff --git a/Library/Homebrew/test/utils/ast/formula_ast_spec.rb b/Library/Homebrew/test/utils/ast/formula_ast_spec.rb
index 32fb13bcfe0d3..e97a307364681 100644
--- a/Library/Homebrew/test/utils/ast/formula_ast_spec.rb
+++ b/Library/Homebrew/test/utils/ast/formula_ast_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/ast"
 
-describe Utils::AST::FormulaAST do
+RSpec.describe Utils::AST::FormulaAST do
   subject(:formula_ast) do
     described_class.new <<~RUBY
       class Foo < Formula
@@ -249,10 +248,10 @@ class Foo < Formula
 
   describe "#add_bottle_block" do
     let(:bottle_output) do
-      <<~RUBY.chomp.indent(2)
-        bottle do
-          sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
-        end
+      <<-RUBY
+  bottle do
+    sha256 "f7b1fc772c79c20fddf621ccc791090bc1085fcef4da6cca03399424c66e06ca" => :sierra
+  end
       RUBY
     end
 
diff --git a/Library/Homebrew/test/utils/autoremove_spec.rb b/Library/Homebrew/test/utils/autoremove_spec.rb
new file mode 100644
index 0000000000000..b078d3e7e9e95
--- /dev/null
+++ b/Library/Homebrew/test/utils/autoremove_spec.rb
@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "utils/autoremove"
+
+RSpec.describe Utils::Autoremove do
+  shared_context "with formulae for dependency testing" do
+    let(:formula_with_deps) do
+      formula "zero" do
+        url "zero-1.0"
+
+        depends_on "three" => :build
+      end
+    end
+
+    let(:first_formula_dep) do
+      formula "one" do
+        url "one-1.1"
+      end
+    end
+
+    let(:second_formula_dep) do
+      formula "two" do
+        url "two-1.1"
+      end
+    end
+
+    let(:formula_is_build_dep) do
+      formula "three" do
+        url "three-1.1"
+      end
+    end
+
+    let(:formulae) do
+      [
+        formula_with_deps,
+        first_formula_dep,
+        second_formula_dep,
+        formula_is_build_dep,
+      ]
+    end
+
+    let(:tab_from_keg) { instance_double(Tab) }
+
+    before do
+      allow(formula_with_deps).to receive_messages(
+        runtime_formula_dependencies: [first_formula_dep, second_formula_dep],
+        any_installed_keg:            instance_double(Keg, tab: tab_from_keg),
+      )
+      allow(first_formula_dep).to receive_messages(
+        runtime_formula_dependencies: [second_formula_dep],
+        any_installed_keg:            instance_double(Keg, tab: tab_from_keg),
+      )
+      allow(second_formula_dep).to receive_messages(
+        runtime_formula_dependencies: [],
+        any_installed_keg:            instance_double(Keg, tab: tab_from_keg),
+      )
+      allow(formula_is_build_dep).to receive_messages(
+        runtime_formula_dependencies: [],
+        any_installed_keg:            instance_double(Keg, tab: tab_from_keg),
+      )
+    end
+  end
+
+  describe "::bottled_formulae_with_no_formula_dependents" do
+    include_context "with formulae for dependency testing"
+
+    before do
+      allow(Formulary).to receive(:factory).with("three", { warn: false }).and_return(formula_is_build_dep)
+    end
+
+    context "when formulae are bottles" do
+      it "filters out runtime dependencies" do
+        allow(tab_from_keg).to receive(:poured_from_bottle).and_return(true)
+
+        expect(described_class.send(:bottled_formulae_with_no_formula_dependents, formulae))
+          .to eq([formula_with_deps, formula_is_build_dep])
+      end
+    end
+
+    context "when formulae are built from source" do
+      it "filters out formulae" do
+        allow(tab_from_keg).to receive(:poured_from_bottle).and_return(false)
+
+        expect(described_class.send(:bottled_formulae_with_no_formula_dependents, formulae))
+          .to eq([])
+      end
+    end
+  end
+
+  describe "::unused_formulae_with_no_formula_dependents" do
+    include_context "with formulae for dependency testing"
+
+    before do
+      allow(tab_from_keg).to receive(:poured_from_bottle).and_return(true)
+    end
+
+    specify "installed on request" do
+      allow(tab_from_keg).to receive(:installed_on_request).and_return(true)
+
+      expect(described_class.send(:unused_formulae_with_no_formula_dependents, formulae))
+        .to eq([])
+    end
+
+    specify "not installed on request" do
+      allow(tab_from_keg).to receive(:installed_on_request).and_return(false)
+
+      expect(described_class.send(:unused_formulae_with_no_formula_dependents, formulae))
+        .to match_array(formulae)
+    end
+
+    specify "installed on request is null" do
+      allow(tab_from_keg).to receive(:installed_on_request).and_return(nil)
+
+      expect(described_class.send(:unused_formulae_with_no_formula_dependents, formulae))
+        .to eq([])
+    end
+  end
+
+  shared_context "with formulae and casks for dependency testing" do
+    include_context "with formulae for dependency testing"
+
+    require "cask/cask_loader"
+
+    let(:cask_one_dep) do
+      Cask::CaskLoader.load(+<<-RUBY)
+        cask "red" do
+          depends_on formula: "two"
+        end
+      RUBY
+    end
+
+    let(:cask_multiple_deps) do
+      Cask::CaskLoader.load(+<<-RUBY)
+        cask "blue" do
+          depends_on formula: "zero"
+        end
+      RUBY
+    end
+
+    let(:first_cask_no_deps) do
+      Cask::CaskLoader.load(+<<-RUBY)
+        cask "green" do
+        end
+      RUBY
+    end
+
+    let(:second_cask_no_deps) do
+      Cask::CaskLoader.load(+<<-RUBY)
+        cask "purple" do
+        end
+      RUBY
+    end
+
+    let(:casks_no_deps) { [first_cask_no_deps, second_cask_no_deps] }
+    let(:casks_one_dep) { [first_cask_no_deps, second_cask_no_deps, cask_one_dep] }
+    let(:casks_multiple_deps) { [first_cask_no_deps, second_cask_no_deps, cask_multiple_deps] }
+
+    before do
+      allow(Formula).to receive("[]").with("zero").and_return(formula_with_deps)
+      allow(Formula).to receive("[]").with("one").and_return(first_formula_dep)
+      allow(Formula).to receive("[]").with("two").and_return(second_formula_dep)
+    end
+  end
+
+  describe "::formulae_with_cask_dependents" do
+    include_context "with formulae and casks for dependency testing"
+
+    specify "no dependents" do
+      expect(described_class.send(:formulae_with_cask_dependents, casks_no_deps))
+        .to eq([])
+    end
+
+    specify "one dependent" do
+      expect(described_class.send(:formulae_with_cask_dependents, casks_one_dep))
+        .to eq([second_formula_dep])
+    end
+
+    specify "multiple dependents" do
+      expect(described_class.send(:formulae_with_cask_dependents, casks_multiple_deps))
+        .to contain_exactly(formula_with_deps, first_formula_dep, second_formula_dep)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/utils/backtrace_spec.rb b/Library/Homebrew/test/utils/backtrace_spec.rb
new file mode 100644
index 0000000000000..79166ada287b1
--- /dev/null
+++ b/Library/Homebrew/test/utils/backtrace_spec.rb
@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "utils/backtrace"
+
+RSpec.describe Utils::Backtrace do
+  let(:backtrace_no_sorbet_paths) do
+    [
+      "/Library/Homebrew/downloadable.rb:75:in",
+      "/Library/Homebrew/downloadable.rb:50:in",
+      "/Library/Homebrew/cmd/fetch.rb:236:in",
+      "/Library/Homebrew/cmd/fetch.rb:201:in",
+      "/Library/Homebrew/cmd/fetch.rb:178:in",
+      "/Library/Homebrew/simulate_system.rb:29:in",
+      "/Library/Homebrew/cmd/fetch.rb:166:in",
+      "/Library/Homebrew/cmd/fetch.rb:163:in",
+      "/Library/Homebrew/cmd/fetch.rb:163:in",
+      "/Library/Homebrew/cmd/fetch.rb:94:in",
+      "/Library/Homebrew/cmd/fetch.rb:94:in",
+      "/Library/Homebrew/brew.rb:94:in",
+    ]
+  end
+
+  let(:backtrace_with_sorbet_paths) do
+    [
+      "/Library/Homebrew/downloadable.rb:75:in",
+      "/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10461/lib/call_validation.rb:157:in",
+      "/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10461/lib/call_validation.rb:157:in",
+      "/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10461/lib/_methods.rb:270:in",
+      "/Library/Homebrew/downloadable.rb:50:in",
+      "/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10461/lib/call_validation.rb:157:in",
+      "/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10461/lib/call_validation.rb:157:in",
+      "/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10461/lib/_methods.rb:270:in",
+      "/Library/Homebrew/cmd/fetch.rb:236:in",
+      "/Library/Homebrew/cmd/fetch.rb:201:in",
+      "/Library/Homebrew/cmd/fetch.rb:178:in",
+      "/Library/Homebrew/simulate_system.rb:29:in",
+      "/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10461/lib/call_validation.rb:157:in",
+      "/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10461/lib/call_validation.rb:157:in",
+      "/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10461/lib/_methods.rb:270:in",
+      "/Library/Homebrew/cmd/fetch.rb:166:in",
+      "/Library/Homebrew/cmd/fetch.rb:163:in",
+      "/Library/Homebrew/cmd/fetch.rb:163:in",
+      "/Library/Homebrew/cmd/fetch.rb:94:in",
+      "/Library/Homebrew/cmd/fetch.rb:94:in",
+      "/Library/Homebrew/brew.rb:94:in",
+    ]
+  end
+
+  let(:backtrace_with_sorbet_error) do
+    backtrace_with_sorbet_paths.drop(1)
+  end
+
+  def exception_with(backtrace:)
+    exception = StandardError.new
+    exception.set_backtrace(backtrace) if backtrace
+    exception
+  end
+
+  before do
+    allow(described_class).to receive(:sorbet_runtime_path)
+      .and_return("/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime")
+    allow(Context).to receive(:current).and_return(Context::ContextStruct.new(verbose: false))
+  end
+
+  it "handles nil backtrace" do
+    exception = exception_with backtrace: nil
+    expect(described_class.clean(exception)).to be_nil
+  end
+
+  it "handles empty array backtrace" do
+    exception = exception_with backtrace: []
+    expect(described_class.clean(exception)).to eq []
+  end
+
+  it "removes sorbet paths when top error is not from sorbet" do
+    exception = exception_with backtrace: backtrace_with_sorbet_paths
+    expect(described_class.clean(exception)).to eq backtrace_no_sorbet_paths
+  end
+
+  it "includes sorbet paths when top error is not from sorbet and verbose is set" do
+    allow(Context).to receive(:current).and_return(Context::ContextStruct.new(verbose: true))
+    exception = exception_with backtrace: backtrace_with_sorbet_paths
+    expect(described_class.clean(exception)).to eq backtrace_with_sorbet_paths
+  end
+
+  it "doesn't change backtrace when error is from sorbet" do
+    exception = exception_with backtrace: backtrace_with_sorbet_error
+    expect(described_class.clean(exception)).to eq backtrace_with_sorbet_error
+  end
+end
diff --git a/Library/Homebrew/test/utils/bottles/bottles_spec.rb b/Library/Homebrew/test/utils/bottles/bottles_spec.rb
index c7a0cf9af3335..c2299804980ed 100644
--- a/Library/Homebrew/test/utils/bottles/bottles_spec.rb
+++ b/Library/Homebrew/test/utils/bottles/bottles_spec.rb
@@ -1,12 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/bottles"
 
-describe Utils::Bottles do
+RSpec.describe Utils::Bottles do
   describe "#tag", :needs_macos do
     it "returns :big_sur or :arm64_big_sur on Big Sur" do
-      allow(MacOS).to receive(:version).and_return(MacOS::Version.new("11.0"))
+      allow(MacOS).to receive(:version).and_return(MacOSVersion.new("11.0"))
       if Hardware::CPU.intel?
         expect(described_class.tag).to eq(:big_sur)
       else
@@ -14,4 +13,44 @@
       end
     end
   end
+
+  describe ".load_tab" do
+    context "when tab_attributes and tabfile are missing" do
+      before do
+        # setup a testball1
+        dep_name = "testball1"
+        dep_path = CoreTap.instance.new_formula_path(dep_name)
+        dep_path.write <<~RUBY
+          class #{Formulary.class_s(dep_name)} < Formula
+            url "testball1"
+            version "0.1"
+          end
+        RUBY
+        Formulary.cache.delete(dep_path)
+
+        # setup a testball2, that depends on testball1
+        formula_name = "testball2"
+        formula_path = CoreTap.instance.new_formula_path(formula_name)
+        formula_path.write <<~RUBY
+          class #{Formulary.class_s(formula_name)} < Formula
+            url "testball2"
+            version "0.1"
+            depends_on "testball1"
+          end
+        RUBY
+        Formulary.cache.delete(formula_path)
+      end
+
+      it "includes runtime_dependencies" do
+        formula = Formula["testball2"]
+        formula.prefix.mkpath
+
+        runtime_dependencies = described_class.load_tab(formula).runtime_dependencies
+
+        expect(runtime_dependencies).not_to be_nil
+        expect(runtime_dependencies.size).to eq(1)
+        expect(runtime_dependencies.first).to include("full_name" => "testball1")
+      end
+    end
+  end
 end
diff --git a/Library/Homebrew/test/utils/bottles/collector_spec.rb b/Library/Homebrew/test/utils/bottles/collector_spec.rb
index 79a571fc4b056..de10dbb541b65 100644
--- a/Library/Homebrew/test/utils/bottles/collector_spec.rb
+++ b/Library/Homebrew/test/utils/bottles/collector_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/bottles"
 
-describe Utils::Bottles::Collector do
+RSpec.describe Utils::Bottles::Collector do
   subject(:collector) { described_class.new }
 
   let(:catalina) { Utils::Bottles::Tag.from_symbol(:catalina) }
@@ -36,8 +35,7 @@
     end
 
     it "does not use older tags when requested not to", :needs_macos do
-      allow(Homebrew::EnvConfig).to receive(:developer?).and_return(true)
-      allow(Homebrew::EnvConfig).to receive(:skip_or_later_bottles?).and_return(true)
+      allow(Homebrew::EnvConfig).to receive_messages(developer?: true, skip_or_later_bottles?: true)
       allow(OS::Mac.version).to receive(:prerelease?).and_return(true)
       collector.add(mojave, checksum: Checksum.new("foo_checksum"), cellar: "foo_cellar")
       expect(collector.send(:find_matching_tag, mojave)).to eq(mojave)
diff --git a/Library/Homebrew/test/utils/bottles/tag_spec.rb b/Library/Homebrew/test/utils/bottles/tag_spec.rb
index 256c592635fb4..cddf686c11d4b 100644
--- a/Library/Homebrew/test/utils/bottles/tag_spec.rb
+++ b/Library/Homebrew/test/utils/bottles/tag_spec.rb
@@ -1,15 +1,14 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/bottles"
 
-describe Utils::Bottles::Tag do
+RSpec.describe Utils::Bottles::Tag do
   it "can parse macOS symbols with archs" do
     symbol = :arm64_big_sur
     tag = described_class.from_symbol(symbol)
     expect(tag.system).to eq(:big_sur)
     expect(tag.arch).to eq(:arm64)
-    expect(tag.to_macos_version).to eq(OS::Mac::Version.from_symbol(:big_sur))
+    expect(tag.to_macos_version).to eq(MacOSVersion.from_symbol(:big_sur))
     expect(tag.macos?).to be true
     expect(tag.linux?).to be false
     expect(tag.to_sym).to eq(symbol)
@@ -20,7 +19,7 @@
     tag = described_class.from_symbol(symbol)
     expect(tag.system).to eq(:big_sur)
     expect(tag.arch).to eq(:x86_64)
-    expect(tag.to_macos_version).to eq(OS::Mac::Version.from_symbol(:big_sur))
+    expect(tag.to_macos_version).to eq(MacOSVersion.from_symbol(:big_sur))
     expect(tag.macos?).to be true
     expect(tag.linux?).to be false
     expect(tag.to_sym).to eq(symbol)
@@ -31,12 +30,21 @@
     tag = described_class.from_symbol(symbol)
     expect(tag.system).to eq(:linux)
     expect(tag.arch).to eq(:x86_64)
-    expect { tag.to_macos_version }.to raise_error(MacOSVersionError)
+    expect { tag.to_macos_version }.to raise_error(MacOSVersion::Error)
     expect(tag.macos?).to be false
     expect(tag.linux?).to be true
     expect(tag.to_sym).to eq(symbol)
   end
 
+  describe "#==" do
+    it "compares using the standardized arch" do
+      monterey_intel = described_class.new(system: :monterey, arch: :intel)
+      monterex_x86_64 = described_class.new(system: :monterey, arch: :x86_64)
+
+      expect(monterey_intel).to eq monterex_x86_64
+    end
+  end
+
   describe "#standardized_arch" do
     it "returns :x86_64 for :intel" do
       expect(described_class.new(system: :all, arch: :intel).standardized_arch).to eq(:x86_64)
@@ -48,21 +56,30 @@
   end
 
   describe "#valid_combination?" do
-    it "returns true for intel archs" do
+    it "returns true for Intel" do
       tag = described_class.new(system: :big_sur, arch: :intel)
       expect(tag.valid_combination?).to be true
       tag = described_class.new(system: :linux, arch: :x86_64)
       expect(tag.valid_combination?).to be true
     end
 
-    it "returns false for arm archs and macos versions older than big_sur" do
+    it "returns false for ARM on macOS Catalina or older" do
       tag = described_class.new(system: :catalina, arch: :arm64)
       expect(tag.valid_combination?).to be false
       tag = described_class.new(system: :mojave, arch: :arm)
       expect(tag.valid_combination?).to be false
     end
 
-    it "returns false for arm archs and linux" do
+    it "returns true for ARM on macOS Big Sur or newer" do
+      tag = described_class.new(system: :big_sur, arch: :arm64)
+      expect(tag.valid_combination?).to be true
+      tag = described_class.new(system: :monterey, arch: :arm)
+      expect(tag.valid_combination?).to be true
+      tag = described_class.new(system: :ventura, arch: :arm)
+      expect(tag.valid_combination?).to be true
+    end
+
+    it "returns false for ARM on Linux" do
       tag = described_class.new(system: :linux, arch: :arm64)
       expect(tag.valid_combination?).to be false
       tag = described_class.new(system: :linux, arch: :arm)
diff --git a/Library/Homebrew/test/utils/curl_spec.rb b/Library/Homebrew/test/utils/curl_spec.rb
index 841f29c21ccd2..92eb5b72292af 100644
--- a/Library/Homebrew/test/utils/curl_spec.rb
+++ b/Library/Homebrew/test/utils/curl_spec.rb
@@ -1,10 +1,11 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/curl"
 
-describe "Utils::Curl" do
-  let(:details) {
+RSpec.describe "Utils::Curl" do
+  include Utils::Curl
+
+  let(:details) do
     details = {
       normal:     {},
       cloudflare: {},
@@ -34,19 +35,19 @@
       file_hash:      nil,
     }
 
-    details[:normal][:ok] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+    details[:normal][:ok] = details[:normal][:no_cookie].deep_dup
     details[:normal][:ok][:status_code] = "200"
 
-    details[:normal][:single_cookie] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+    details[:normal][:single_cookie] = details[:normal][:no_cookie].deep_dup
     details[:normal][:single_cookie][:headers]["set-cookie"] = "a_cookie=for_testing"
 
-    details[:normal][:multiple_cookies] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+    details[:normal][:multiple_cookies] = details[:normal][:no_cookie].deep_dup
     details[:normal][:multiple_cookies][:headers]["set-cookie"] = [
       "first_cookie=for_testing",
       "last_cookie=also_for_testing",
     ]
 
-    details[:normal][:blank_headers] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+    details[:normal][:blank_headers] = details[:normal][:no_cookie].deep_dup
     details[:normal][:blank_headers][:headers] = {}
 
     details[:cloudflare][:single_cookie] = {
@@ -74,7 +75,7 @@
       file_hash:      nil,
     }
 
-    details[:cloudflare][:multiple_cookies] = Marshal.load(Marshal.dump(details[:cloudflare][:single_cookie]))
+    details[:cloudflare][:multiple_cookies] = details[:cloudflare][:single_cookie].deep_dup
     details[:cloudflare][:multiple_cookies][:headers]["set-cookie"] = [
       "first_cookie=for_testing",
       "__cf_bm=abcdef0123456789; path=/; expires=Thu, 28-Apr-22 18:38:40 GMT; domain=www.example.com; HttpOnly; " \
@@ -82,28 +83,28 @@
       "last_cookie=also_for_testing",
     ]
 
-    details[:cloudflare][:no_server] = Marshal.load(Marshal.dump(details[:cloudflare][:single_cookie]))
+    details[:cloudflare][:no_server] = details[:cloudflare][:single_cookie].deep_dup
     details[:cloudflare][:no_server][:headers].delete("server")
 
-    details[:cloudflare][:wrong_server] = Marshal.load(Marshal.dump(details[:cloudflare][:single_cookie]))
+    details[:cloudflare][:wrong_server] = details[:cloudflare][:single_cookie].deep_dup
     details[:cloudflare][:wrong_server][:headers]["server"] = "nginx 1.2.3"
 
     # TODO: Make the Incapsula test data more realistic once we can find an
     # example website to reference.
-    details[:incapsula][:single_cookie_visid_incap] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+    details[:incapsula][:single_cookie_visid_incap] = details[:normal][:no_cookie].deep_dup
     details[:incapsula][:single_cookie_visid_incap][:headers]["set-cookie"] = "visid_incap_something=something"
 
-    details[:incapsula][:single_cookie_incap_ses] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+    details[:incapsula][:single_cookie_incap_ses] = details[:normal][:no_cookie].deep_dup
     details[:incapsula][:single_cookie_incap_ses][:headers]["set-cookie"] = "incap_ses_something=something"
 
-    details[:incapsula][:multiple_cookies_visid_incap] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+    details[:incapsula][:multiple_cookies_visid_incap] = details[:normal][:no_cookie].deep_dup
     details[:incapsula][:multiple_cookies_visid_incap][:headers]["set-cookie"] = [
       "first_cookie=for_testing",
       "visid_incap_something=something",
       "last_cookie=also_for_testing",
     ]
 
-    details[:incapsula][:multiple_cookies_incap_ses] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+    details[:incapsula][:multiple_cookies_incap_ses] = details[:normal][:no_cookie].deep_dup
     details[:incapsula][:multiple_cookies_incap_ses][:headers]["set-cookie"] = [
       "first_cookie=for_testing",
       "incap_ses_something=something",
@@ -111,17 +112,17 @@
     ]
 
     details
-  }
+  end
 
-  let(:location_urls) {
+  let(:location_urls) do
     %w[
       https://example.com/example/
       https://example.com/example1/
       https://example.com/example2/
     ]
-  }
+  end
 
-  let(:response_hash) {
+  let(:response_hash) do
     response_hash = {}
 
     response_hash[:ok] = {
@@ -240,9 +241,9 @@
     }
 
     response_hash
-  }
+  end
 
-  let(:response_text) {
+  let(:response_text) do
     response_text = {}
 
     response_text[:ok] = <<~EOS
@@ -279,9 +280,9 @@
     )
 
     response_text
-  }
+  end
 
-  let(:body) {
+  let(:body) do
     body = {}
 
     body[:default] = <<~EOS
@@ -303,7 +304,7 @@
     body[:with_http_status_line] = body[:default].sub("<html>", "HTTP/1.1 200\r\n<html>")
 
     body
-  }
+  end
 
   describe "curl_args" do
     let(:args) { ["foo"] }
@@ -314,11 +315,27 @@
       expect(curl_args(*args).first).to eq("--disable")
     end
 
-    it "doesn't return `--disable` as the first argument when HOMEBREW_CURLRC is set" do
+    it "doesn't return `--disable` as the first argument when HOMEBREW_CURLRC is set but not a path" do
       ENV["HOMEBREW_CURLRC"] = "1"
       expect(curl_args(*args).first).not_to eq("--disable")
     end
 
+    it "doesn't return `--config` when HOMEBREW_CURLRC is unset" do
+      expect(curl_args(*args)).not_to include(a_string_starting_with("--config"))
+    end
+
+    it "returns `--config` when HOMEBREW_CURLRC is a valid path" do
+      Tempfile.create do |tmpfile|
+        path = tmpfile.path
+        ENV["HOMEBREW_CURLRC"] = path
+        # We still expect --disable
+        expect(curl_args(*args).first).to eq("--disable")
+        expect(curl_args(*args).join(" ")).to include("--config #{path}")
+      end
+    ensure
+      ENV["HOMEBREW_CURLRC"] = nil
+    end
+
     it "uses `--connect-timeout` when `:connect_timeout` is Numeric" do
       expect(curl_args(*args, connect_timeout: 123).join(" ")).to include("--connect-timeout 123")
       expect(curl_args(*args, connect_timeout: 123.4).join(" ")).to include("--connect-timeout 123.4")
@@ -371,6 +388,14 @@
       expect { curl_args(*args, retry_max_time: "test") }.to raise_error(TypeError)
     end
 
+    it "uses `--referer` when :referer is present" do
+      expect(curl_args(*args, referer: "https://brew.sh").join(" ")).to include("--referer https://brew.sh")
+    end
+
+    it "doesn't use `--referer` when :referer is nil" do
+      expect(curl_args(*args, referer: nil).join(" ")).not_to include("--referer")
+    end
+
     it "uses HOMEBREW_USER_AGENT_FAKE_SAFARI when `:user_agent` is `:browser` or `:fake`" do
       expect(curl_args(*args, user_agent: :browser).join(" "))
         .to include("--user-agent #{HOMEBREW_USER_AGENT_FAKE_SAFARI}")
@@ -556,4 +581,58 @@
       expect(curl_response_last_location([response_hash[:ok]])).to be_nil
     end
   end
+
+  describe "#curl_response_follow_redirections" do
+    it "returns the original URL when there are no location headers" do
+      expect(
+        curl_response_follow_redirections(
+          [response_hash[:ok]],
+          "https://brew.sh/test1/test2",
+        ),
+      ).to eq("https://brew.sh/test1/test2")
+    end
+
+    it "returns the URL relative to base when locations are relative" do
+      expect(
+        curl_response_follow_redirections(
+          [response_hash[:redirection_root_relative], response_hash[:ok]],
+          "https://brew.sh/test1/test2",
+        ),
+      ).to eq("https://brew.sh/example/")
+
+      expect(
+        curl_response_follow_redirections(
+          [response_hash[:redirection_parent_relative], response_hash[:ok]],
+          "https://brew.sh/test1/test2",
+        ),
+      ).to eq("https://brew.sh/test1/example/")
+
+      expect(
+        curl_response_follow_redirections(
+          [
+            response_hash[:redirection_parent_relative],
+            response_hash[:redirection_parent_relative],
+            response_hash[:ok],
+          ],
+          "https://brew.sh/test1/test2",
+        ),
+      ).to eq("https://brew.sh/test1/example/example/")
+    end
+
+    it "returns new base when there are absolute location(s)" do
+      expect(
+        curl_response_follow_redirections(
+          [response_hash[:redirection], response_hash[:ok]],
+          "https://brew.sh/test1/test2",
+        ),
+      ).to eq(location_urls[0])
+
+      expect(
+        curl_response_follow_redirections(
+          [response_hash[:redirection], response_hash[:redirection_parent_relative], response_hash[:ok]],
+          "https://brew.sh/test1/test2",
+        ),
+      ).to eq("#{location_urls[0]}example/")
+    end
+  end
 end
diff --git a/Library/Homebrew/test/utils/fork_spec.rb b/Library/Homebrew/test/utils/fork_spec.rb
index 330ffbeba8e9d..eba4c6592526e 100644
--- a/Library/Homebrew/test/utils/fork_spec.rb
+++ b/Library/Homebrew/test/utils/fork_spec.rb
@@ -1,24 +1,23 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/fork"
 
-describe Utils do
+RSpec.describe Utils do
   describe "#safe_fork" do
     it "raises a RuntimeError on an error that isn't ErrorDuringExecution" do
-      expect {
+      expect do
         described_class.safe_fork do
           raise "this is an exception in the child"
         end
-      }.to raise_error(RuntimeError)
+      end.to raise_error(RuntimeError)
     end
 
     it "raises an ErrorDuringExecution on one in the child" do
-      expect {
+      expect do
         described_class.safe_fork do
           safe_system "/usr/bin/false"
         end
-      }.to raise_error(ErrorDuringExecution)
+      end.to raise_error(ErrorDuringExecution)
     end
   end
 end
diff --git a/Library/Homebrew/test/utils/git_repository_spec.rb b/Library/Homebrew/test/utils/git_repository_spec.rb
index 2f609295e9d60..19ff66171fed2 100644
--- a/Library/Homebrew/test/utils/git_repository_spec.rb
+++ b/Library/Homebrew/test/utils/git_repository_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/git_repository"
 
-describe Utils do
+RSpec.describe Utils do
   shared_examples "git_repository helper function" do |method_name|
     context "when directory is not a Git repository" do
       it "returns nil if `safe` parameter is `false`" do
diff --git a/Library/Homebrew/test/utils/git_spec.rb b/Library/Homebrew/test/utils/git_spec.rb
index 58ec7c975ff95..2efec2fa07acc 100644
--- a/Library/Homebrew/test/utils/git_spec.rb
+++ b/Library/Homebrew/test/utils/git_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/git"
 
-describe Utils::Git do
+RSpec.describe Utils::Git do
   around do |example|
     described_class.clear_available_cache
     example.run
@@ -45,12 +44,15 @@
   end
 
   let(:file) { "README.md" }
-  let(:file_hash1) { @h1[0..6] }
-  let(:file_hash2) { @h2[0..6] }
+  # Allow instance variables here for a simpler `before do` block.
+  # rubocop:disable RSpec/InstanceVariable
+  let(:file_hash_one) { @h1[0..6] }
+  let(:file_hash_two) { @h2[0..6] }
   let(:files) { ["README.md", "LICENSE.txt"] }
-  let(:files_hash1) { [@h3[0..6], ["LICENSE.txt"]] }
-  let(:files_hash2) { [@h2[0..6], ["README.md"]] }
+  let(:files_hash_one) { [@h3[0..6], ["LICENSE.txt"]] }
+  let(:files_hash_two) { [@h2[0..6], ["README.md"]] }
   let(:cherry_pick_commit) { @cherry_pick_commit[0..6] }
+  # rubocop:enable RSpec/InstanceVariable
 
   describe "#cherry_pick!" do
     it "can cherry pick a commit" do
@@ -59,9 +61,9 @@
 
     it "aborts when cherry picking an existing hash" do
       ENV["GIT_MERGE_VERBOSITY"] = "5" # Consistent output across git versions
-      expect {
-        described_class.cherry_pick!(HOMEBREW_CACHE, file_hash1)
-      }.to raise_error(ErrorDuringExecution, /Merge conflict in README.md/)
+      expect do
+        described_class.cherry_pick!(HOMEBREW_CACHE, file_hash_one)
+      end.to raise_error(ErrorDuringExecution, /Merge conflict in README.md/)
     end
   end
 
@@ -69,26 +71,26 @@
     it "gives last revision commit when before_commit is nil" do
       expect(
         described_class.last_revision_commit_of_file(HOMEBREW_CACHE, file),
-      ).to eq(file_hash1)
+      ).to eq(file_hash_one)
     end
 
     it "gives revision commit based on before_commit when it is not nil" do
       expect(
         described_class.last_revision_commit_of_file(HOMEBREW_CACHE,
                                                      file,
-                                                     before_commit: file_hash2),
-      ).to eq(file_hash2)
+                                                     before_commit: file_hash_two),
+      ).to eq(file_hash_two)
     end
   end
 
   describe "#file_at_commit" do
     it "returns file contents when file exists" do
-      expect(described_class.file_at_commit(HOMEBREW_CACHE, file, file_hash1)).to eq("README")
+      expect(described_class.file_at_commit(HOMEBREW_CACHE, file, file_hash_one)).to eq("README")
     end
 
     it "returns empty when file doesn't exist" do
-      expect(described_class.file_at_commit(HOMEBREW_CACHE, "foo.txt", file_hash1)).to eq("")
-      expect(described_class.file_at_commit(HOMEBREW_CACHE, "LICENSE.txt", file_hash1)).to eq("")
+      expect(described_class.file_at_commit(HOMEBREW_CACHE, "foo.txt", file_hash_one)).to eq("")
+      expect(described_class.file_at_commit(HOMEBREW_CACHE, "LICENSE.txt", file_hash_one)).to eq("")
     end
   end
 
@@ -97,7 +99,7 @@
       it "gives last revision commit" do
         expect(
           described_class.last_revision_commit_of_files(HOMEBREW_CACHE, files),
-        ).to eq(files_hash1)
+        ).to eq(files_hash_one)
       end
     end
 
@@ -106,8 +108,8 @@
         expect(
           described_class.last_revision_commit_of_files(HOMEBREW_CACHE,
                                                         files,
-                                                        before_commit: file_hash2),
-        ).to eq(files_hash2)
+                                                        before_commit: file_hash_two),
+        ).to eq(files_hash_two)
       end
     end
   end
diff --git a/Library/Homebrew/test/utils/github/actions_spec.rb b/Library/Homebrew/test/utils/github/actions_spec.rb
index 3bd0f3f2554f5..9c677d123cea4 100644
--- a/Library/Homebrew/test/utils/github/actions_spec.rb
+++ b/Library/Homebrew/test/utils/github/actions_spec.rb
@@ -1,16 +1,15 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/github/actions"
 
-describe GitHub::Actions::Annotation do
+RSpec.describe GitHub::Actions::Annotation do
   let(:message) { "lorem ipsum" }
 
   describe "#new" do
     it "fails when the type is wrong" do
-      expect {
+      expect do
         described_class.new(:fatal, message, file: "file.txt")
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
   end
 
diff --git a/Library/Homebrew/test/utils/github_spec.rb b/Library/Homebrew/test/utils/github_spec.rb
index 8221b76b2fe3d..e07f093e7c717 100644
--- a/Library/Homebrew/test/utils/github_spec.rb
+++ b/Library/Homebrew/test/utils/github_spec.rb
@@ -1,33 +1,21 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/github"
 
-describe GitHub do
-  describe "::search_code", :needs_network do
-    it "queries GitHub code with the passed parameters" do
-      results = described_class.search_code(repo: "Homebrew/brew", path: "/",
-                                            filename: "readme", extension: "md")
-
-      expect(results.count).to eq(1)
-      expect(results.first["name"]).to eq("README.md")
-      expect(results.first["path"]).to eq("README.md")
-    end
-  end
-
-  describe "::query_string" do
+RSpec.describe GitHub do
+  describe "::search_query_string" do
     it "builds a query with the given hash parameters formatted as key:value" do
-      query = described_class.query_string(user: "Homebrew", repo: "brew")
+      query = described_class.search_query_string(user: "Homebrew", repo: "brew")
       expect(query).to eq("q=user%3AHomebrew+repo%3Abrew&per_page=100")
     end
 
     it "adds a variable number of top-level string parameters to the query when provided" do
-      query = described_class.query_string("value1", "value2", user: "Homebrew")
+      query = described_class.search_query_string("value1", "value2", user: "Homebrew")
       expect(query).to eq("q=value1+value2+user%3AHomebrew&per_page=100")
     end
 
     it "turns array values into multiple key:value parameters" do
-      query = described_class.query_string(user: ["Homebrew", "caskroom"])
+      query = described_class.search_query_string(user: ["Homebrew", "caskroom"])
       expect(query).to eq("q=user%3AHomebrew+user%3Acaskroom&per_page=100")
     end
   end
@@ -37,9 +25,10 @@
       results = described_class.search_issues("brew search",
                                               repo:   "Homebrew/legacy-homebrew",
                                               author: "MikeMcQuaid",
-                                              is:     "closed")
+                                              is:     "issue",
+                                              no:     "milestone")
       expect(results).not_to be_empty
-      expect(results.first["title"]).to eq("Shall we run `brew update` automatically?")
+      expect(results.first["title"]).to eq("Shall we move more things to taps?")
     end
   end
 
@@ -57,36 +46,38 @@
     end
   end
 
-  describe "::sponsors_by_tier", :needs_network do
-    it "errors on an unauthenticated token" do
-      expect {
-        described_class.sponsors_by_tier("Homebrew")
-      }.to raise_error(/INSUFFICIENT_SCOPES|FORBIDDEN|token needs the 'admin:org' scope/)
-    end
-  end
-
-  describe "::get_artifact_url", :needs_network do
+  describe "::get_artifact_urls", :needs_network do
     it "fails to find a nonexistent workflow" do
-      expect {
-        described_class.get_artifact_url(
+      expect do
+        described_class.get_artifact_urls(
           described_class.get_workflow_run("Homebrew", "homebrew-core", "1"),
         )
-      }.to raise_error(/No matching check suite found/)
+      end.to raise_error(/No matching check suite found/)
     end
 
     it "fails to find artifacts that don't exist" do
-      expect {
-        described_class.get_artifact_url(
-          described_class.get_workflow_run("Homebrew", "homebrew-core", "79751", artifact_name: "false_bottles"),
+      expect do
+        described_class.get_artifact_urls(
+          described_class.get_workflow_run("Homebrew", "homebrew-core", "191680",
+                                           workflow_id: "triage.yml", artifact_pattern: "false_artifact"),
         )
-      }.to raise_error(/No artifact .+ was found/)
+      end.to raise_error(/No artifacts with the pattern .+ were found/)
     end
 
-    it "gets an artifact link" do
-      url = described_class.get_artifact_url(
-        described_class.get_workflow_run("Homebrew", "homebrew-core", "79751", artifact_name: "bottles"),
+    it "gets artifact URLs" do
+      urls = described_class.get_artifact_urls(
+        described_class.get_workflow_run("Homebrew", "homebrew-core", "191680",
+                                         workflow_id: "triage.yml", artifact_pattern: "event_payload"),
       )
-      expect(url).to eq("https://api.github.com/repos/Homebrew/homebrew-core/actions/artifacts/70494047/zip")
+      expect(urls).to eq(["https://api.github.com/repos/Homebrew/homebrew-core/actions/artifacts/1969725476/zip"])
+    end
+
+    it "supports pattern matching" do
+      urls = described_class.get_artifact_urls(
+        described_class.get_workflow_run("Homebrew", "brew", "17068",
+                                         workflow_id: "pkg-installer.yml", artifact_pattern: "Homebrew-*.pkg"),
+      )
+      expect(urls).to eq(["https://api.github.com/repos/Homebrew/brew/actions/artifacts/1405050842/zip"])
     end
   end
 
@@ -101,4 +92,55 @@
       expect(described_class.pull_request_commits("Homebrew", "legacy-homebrew", 50678, per_page: 1)).to eq(hashes)
     end
   end
+
+  describe "::count_repo_commits" do
+    let(:five_shas) { %w[abcdef ghjkl mnop qrst uvwxyz] }
+    let(:ten_shas) { %w[abcdef ghjkl mnop qrst uvwxyz fedcba lkjhg ponm tsrq zyxwvu] }
+
+    it "counts commits authored by a user" do
+      allow(described_class).to receive(:repo_commits_for_user)
+        .with("homebrew/cask", "user1", "author", nil, nil, nil).and_return(five_shas)
+      allow(described_class).to receive(:repo_commits_for_user)
+        .with("homebrew/cask", "user1", "committer", nil, nil, nil).and_return([])
+
+      expect(described_class.count_repo_commits("homebrew/cask", "user1")).to eq([5, 0])
+    end
+
+    it "counts commits committed by a user" do
+      allow(described_class).to receive(:repo_commits_for_user)
+        .with("homebrew/core", "user1", "author", nil, nil, nil).and_return([])
+      allow(described_class).to receive(:repo_commits_for_user)
+        .with("homebrew/core", "user1", "committer", nil, nil, nil).and_return(five_shas)
+
+      expect(described_class.count_repo_commits("homebrew/core", "user1")).to eq([0, 5])
+    end
+
+    it "calculates correctly when authored > committed with different shas" do
+      allow(described_class).to receive(:repo_commits_for_user)
+        .with("homebrew/cask", "user1", "author", nil, nil, nil).and_return(ten_shas)
+      allow(described_class).to receive(:repo_commits_for_user)
+        .with("homebrew/cask", "user1", "committer", nil, nil, nil).and_return(%w[1 2 3 4 5])
+
+      expect(described_class.count_repo_commits("homebrew/cask", "user1")).to eq([10, 5])
+    end
+
+    it "calculates correctly when committed > authored" do
+      allow(described_class).to receive(:repo_commits_for_user)
+        .with("homebrew/cask", "user1", "author", nil, nil, nil).and_return(five_shas)
+      allow(described_class).to receive(:repo_commits_for_user)
+        .with("homebrew/cask", "user1", "committer", nil, nil, nil).and_return(ten_shas)
+
+      expect(described_class.count_repo_commits("homebrew/cask", "user1")).to eq([5, 5])
+    end
+
+    it "deduplicates commits authored and committed by the same user" do
+      allow(described_class).to receive(:repo_commits_for_user)
+        .with("homebrew/core", "user1", "author", nil, nil, nil).and_return(five_shas)
+      allow(described_class).to receive(:repo_commits_for_user)
+        .with("homebrew/core", "user1", "committer", nil, nil, nil).and_return(five_shas)
+
+      # Because user1 authored and committed the same 5 commits.
+      expect(described_class.count_repo_commits("homebrew/core", "user1")).to eq([5, 0])
+    end
+  end
 end
diff --git a/Library/Homebrew/test/utils/gzip_spec.rb b/Library/Homebrew/test/utils/gzip_spec.rb
new file mode 100644
index 0000000000000..bb16e3421d6c6
--- /dev/null
+++ b/Library/Homebrew/test/utils/gzip_spec.rb
@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "utils/gzip"
+
+RSpec.describe Utils::Gzip do
+  include FileUtils
+
+  describe "compress_with_options" do
+    it "uses the explicitly specified mtime, orig_name and output path when passed" do
+      mktmpdir do |path|
+        mtime = Time.at(12345).utc
+        orig_name = "someotherfile"
+        output = path/"subdir/anotherfile.gz"
+        file_content = "Hello world"
+        expected_checksum = "df509051b519faa8a1143157d2750d1694dc5fe6373e493c0d5c360be3e61516"
+
+        somefile = path/"somefile"
+        File.write(somefile, file_content)
+        mkdir path/"subdir"
+
+        expect(described_class.compress_with_options(somefile, mtime:, orig_name:,
+output:)).to eq(output)
+        expect(Digest::SHA256.hexdigest(File.read(output))).to eq(expected_checksum)
+      end
+    end
+
+    it "uses SOURCE_DATE_EPOCH as mtime when not explicitly specified" do
+      mktmpdir do |path|
+        ENV["SOURCE_DATE_EPOCH"] = "23456"
+        file_content = "Hello world"
+        expected_checksum = "a579be88ec8073391a5753b1df4d87fbf008aaec6b5a03f8f16412e2e01f119a"
+
+        somefile = path/"somefile"
+        File.write(somefile, file_content)
+
+        expect(described_class.compress_with_options(somefile).to_s).to eq("#{somefile}.gz")
+        expect(Digest::SHA256.hexdigest(File.read("#{somefile}.gz"))).to eq(expected_checksum)
+      end
+    end
+  end
+
+  describe "compress" do
+    it "creates non-reproducible gz files from input files" do
+      mktmpdir do |path|
+        files = (0..2).map { |n| path/"somefile#{n}" }
+        FileUtils.touch files
+
+        results = described_class.compress(*files, reproducible: false)
+        3.times do |n|
+          expect(results[n].to_s).to eq("#{files[n]}.gz")
+          expect(Pathname.new("#{files[n]}.gz")).to exist
+        end
+      end
+    end
+
+    it "creates reproducible gz files from input files with explicit mtime" do
+      mtime = Time.at(12345).utc
+      expected_checksums = %w[
+        5b45cabc7f0192854365aeccd82036e482e35131ba39fbbc6d0684266eb2e88a
+        d422bf4cbede17ae242135d7f32ba5379fbffb288c29cd38b7e5e1a5f89073f8
+        1d93a3808e2bd5d8c6371ea1c9b8b538774d6486af260719400fc3a5b7ac8d6f
+      ]
+
+      mktmpdir do |path|
+        files = (0..2).map { |n| path/"somefile#{n}" }
+        files.each { |f| File.write(f, "Hello world") }
+
+        results = described_class.compress(*files, mtime:)
+        3.times do |n|
+          expect(results[n].to_s).to eq("#{files[n]}.gz")
+          expect(Digest::SHA256.hexdigest(File.read(results[n]))).to eq(expected_checksums[n])
+        end
+      end
+    end
+
+    it "creates reproducible gz files from input files with SOURCE_DATE_EPOCH as mtime" do
+      ENV["SOURCE_DATE_EPOCH"] = "23456"
+      expected_checksums = %w[
+        d5e0cc3259b1eb61d93ee5a30d41aef4a382c1cf2b759719c289f625e27b915c
+        068657725bca5f9c2bc62bc6bf679eb63786e92d16cae575dee2fd9787a338f3
+        e566e9fdaf9aa2a7c9501f9845fed1b70669bfa679b0de609e3b63f99988784d
+      ]
+
+      mktmpdir do |path|
+        files = (0..2).map { |n| path/"somefile#{n}" }
+        files.each { |f| File.write(f, "Hello world") }
+
+        results = described_class.compress(*files)
+        3.times do |n|
+          expect(results[n].to_s).to eq("#{files[n]}.gz")
+          expect(Digest::SHA256.hexdigest(File.read(results[n]))).to eq(expected_checksums[n])
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/test/utils/inreplace_spec.rb b/Library/Homebrew/test/utils/inreplace_spec.rb
index 16c5bedd624c2..bc2fa549cabf1 100644
--- a/Library/Homebrew/test/utils/inreplace_spec.rb
+++ b/Library/Homebrew/test/utils/inreplace_spec.rb
@@ -1,56 +1,129 @@
-# typed: false
 # frozen_string_literal: true
 
 require "tempfile"
 require "utils/inreplace"
 
-describe Utils::Inreplace do
+RSpec.describe Utils::Inreplace do
   let(:file) { Tempfile.new("test") }
 
   before do
-    file.write <<~EOS
+    File.binwrite(file, <<~EOS)
       a
       b
       c
+      aa
     EOS
   end
 
   after { file.unlink }
 
-  it "raises error if there are no files given to replace" do
-    expect {
-      described_class.inreplace [], "d", "f"
-    }.to raise_error(Utils::Inreplace::Error)
-  end
+  describe ".inreplace" do
+    it "raises error if there are no files given to replace" do
+      expect do
+        described_class.inreplace [], "d", "f"
+      end.to raise_error(Utils::Inreplace::Error)
+    end
 
-  it "raises error if there is nothing to replace" do
-    expect {
-      described_class.inreplace file.path, "d", "f"
-    }.to raise_error(Utils::Inreplace::Error)
-  end
+    it "raises error if there is nothing to replace" do
+      expect do
+        described_class.inreplace file.path, "d", "f"
+      end.to raise_error(Utils::Inreplace::Error)
+    end
 
-  it "raises error if there is nothing to replace in block form" do
-    expect {
-      described_class.inreplace(file.path) do |s|
-        s.gsub!("d", "f") # rubocop:disable Performance/StringReplacement
-      end
-    }.to raise_error(Utils::Inreplace::Error)
-  end
+    it "raises error if there is nothing to replace in block form" do
+      expect do
+        described_class.inreplace(file.path) do |s|
+          s.gsub!("d", "f") # rubocop:disable Performance/StringReplacement
+        end
+      end.to raise_error(Utils::Inreplace::Error)
+    end
 
-  it "raises error if there is no make variables to replace" do
-    expect {
+    it "raises error if there is no make variables to replace" do
+      expect do
+        described_class.inreplace(file.path) do |s|
+          s.change_make_var! "VAR", "value"
+          s.remove_make_var! "VAR2"
+        end
+      end.to raise_error(Utils::Inreplace::Error)
+    end
+
+    it "substitutes pathname within file" do
+      # For a specific instance of this, see https://github.com/Homebrew/homebrew-core/blob/a8b0b10/Formula/loki.rb#L48
       described_class.inreplace(file.path) do |s|
-        s.change_make_var! "VAR", "value"
-        s.remove_make_var! "VAR2"
+        s.gsub!(Pathname("b"), Pathname("f"))
       end
-    }.to raise_error(Utils::Inreplace::Error)
+      expect(File.binread(file)).to eq <<~EOS
+        a
+        f
+        c
+        aa
+      EOS
+    end
+
+    it "substitutes all occurrences within file when `global: true`" do
+      described_class.inreplace(file.path, "a", "foo")
+      expect(File.binread(file)).to eq <<~EOS
+        foo
+        b
+        c
+        foofoo
+      EOS
+    end
+
+    it "substitutes only the first occurrence when `global: false`" do
+      described_class.inreplace(file.path, "a", "foo", global: false)
+      expect(File.binread(file)).to eq <<~EOS
+        foo
+        b
+        c
+        aa
+      EOS
+    end
   end
 
-  describe "#inreplace_pairs" do
+  describe ".inreplace_pairs" do
     it "raises error if there is no old value" do
-      expect {
+      expect do
         described_class.inreplace_pairs(file.path, [[nil, "f"]])
-      }.to raise_error(Utils::Inreplace::Error)
+      end.to raise_error(Utils::Inreplace::Error)
+    end
+
+    it "substitutes returned string but not file when `read_only_run: true`" do
+      expect(described_class.inreplace_pairs(file.path, [["a", "foo"]], read_only_run: true)).to eq <<~EOS
+        foo
+        b
+        c
+        foofoo
+      EOS
+      expect(File.binread(file)).to eq <<~EOS
+        a
+        b
+        c
+        aa
+      EOS
+    end
+
+    it "substitutes both returned string and file when `read_only_run: false`" do
+      replace_result = <<~TEXT
+        foo
+        b
+        c
+        foofoo
+      TEXT
+      expect(described_class.inreplace_pairs(file.path, [["a", "foo"]])).to eq replace_result
+      expect(File.binread(file)).to eq replace_result
+    end
+
+    it "substitutes multiple pairs in order" do
+      pairs = [["a", "b"], ["bb", "test"], ["b", "z"]]
+      replace_result = <<~TEXT
+        z
+        z
+        c
+        test
+      TEXT
+      expect(described_class.inreplace_pairs(file.path, pairs)).to eq replace_result
+      expect(File.binread(file)).to eq replace_result
     end
   end
 end
diff --git a/Library/Homebrew/test/utils/path_spec.rb b/Library/Homebrew/test/utils/path_spec.rb
new file mode 100644
index 0000000000000..ba7f27436cd1f
--- /dev/null
+++ b/Library/Homebrew/test/utils/path_spec.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "utils/path"
+
+RSpec.describe Utils::Path do
+  describe "::child_of?" do
+    it "recognizes a path as its own child" do
+      expect(described_class.child_of?("/foo/bar", "/foo/bar")).to be(true)
+    end
+
+    it "recognizes a path that is a child of the parent" do
+      expect(described_class.child_of?("/foo", "/foo/bar")).to be(true)
+    end
+
+    it "recognizes a path that is a grandchild of the parent" do
+      expect(described_class.child_of?("/foo", "/foo/bar/baz")).to be(true)
+    end
+
+    it "does not recognize a path that is not a child" do
+      expect(described_class.child_of?("/foo", "/bar/baz")).to be(false)
+    end
+
+    it "handles . and .. in paths correctly" do
+      expect(described_class.child_of?("/foo", "/foo/./bar")).to be(true)
+      expect(described_class.child_of?("/foo/bar", "/foo/../foo/bar/baz")).to be(true)
+    end
+
+    it "handles relative paths correctly" do
+      expect(described_class.child_of?("foo", "./bar/baz")).to be(false)
+      expect(described_class.child_of?("../foo", "./bar/baz/../../../foo/bar/baz")).to be(true)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/utils/popen_spec.rb b/Library/Homebrew/test/utils/popen_spec.rb
index 9dcac24180667..c4cef2afe6d46 100644
--- a/Library/Homebrew/test/utils/popen_spec.rb
+++ b/Library/Homebrew/test/utils/popen_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/popen"
 
-describe Utils do
+RSpec.describe Utils do
   describe "::popen_read" do
     it "reads the standard output of a given command" do
       expect(described_class.popen_read("sh", "-c", "echo success").chomp).to eq("success")
@@ -94,9 +93,9 @@
     end
 
     it "raises an error if the command fails" do
-      expect {
+      expect do
         described_class.safe_popen_write("grep", "success") { |pipe| pipe.write "failure\n" }
-      }.to raise_error(ErrorDuringExecution)
+      end.to raise_error(ErrorDuringExecution)
       expect($CHILD_STATUS).to be_a_failure
     end
   end
diff --git a/Library/Homebrew/test/utils/pypi_spec.rb b/Library/Homebrew/test/utils/pypi_spec.rb
index 3b857e758c886..e904988e2a375 100644
--- a/Library/Homebrew/test/utils/pypi_spec.rb
+++ b/Library/Homebrew/test/utils/pypi_spec.rb
@@ -1,17 +1,19 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/pypi"
 
-describe PyPI do
-  let(:package_url) do
+RSpec.describe PyPI do
+  let(:pypi_package_url) do
     "https://files.pythonhosted.org/packages/b0/3f/2e1dad67eb172b6443b5eb37eb885a054a55cfd733393071499514140282/" \
       "snakemake-5.29.0.tar.gz"
   end
-  let(:old_package_url) do
+  let(:old_pypi_package_url) do
     "https://files.pythonhosted.org/packages/6f/c4/da52bfdd6168ea46a0fe2b7c983b6c34c377a8733ec177cc00b197a96a9f/" \
       "snakemake-5.28.0.tar.gz"
   end
+  let(:non_pypi_package_url) do
+    "https://github.com/pypa/pip-audit/releases/download/v2.5.6/v2.5.6.tar.gz"
+  end
 
   describe PyPI::Package do
     let(:package_checksum) { "47417307d08ecb0707b3b29effc933bd63d8c8e3ab15509c62b685b7614c6568" }
@@ -23,7 +25,8 @@
     let(:package_with_extra) { described_class.new("snakemake[foo]") }
     let(:package_with_extra_and_version) { described_class.new("snakemake[foo]==5.28.0") }
     let(:package_with_different_capitalization) { described_class.new("SNAKEMAKE") }
-    let(:package_from_url) { described_class.new(package_url, is_url: true) }
+    let(:package_from_pypi_url) { described_class.new(pypi_package_url, is_url: true) }
+    let(:package_from_non_pypi_url) { described_class.new(non_pypi_package_url, is_url: true) }
     let(:other_package) { described_class.new("virtualenv==20.2.0") }
 
     describe "initialize" do
@@ -67,12 +70,50 @@
         expect(described_class.new("foo[bar,baz]==1.2.3").version).to eq "1.2.3"
       end
 
-      it "initializes name from url" do
-        expect(described_class.new(package_url, is_url: true).name).to eq "snakemake"
+      it "initializes name from PyPI url" do
+        expect(described_class.new(pypi_package_url, is_url: true).name).to eq "snakemake"
+      end
+
+      it "initializes version from PyPI url" do
+        expect(described_class.new(pypi_package_url, is_url: true).version).to eq "5.29.0"
+      end
+    end
+
+    describe ".version=" do
+      it "sets for package names" do
+        package = described_class.new("snakemake==5.28.0")
+        expect(package.version).to eq "5.28.0"
+
+        package.version = "5.29.0"
+        expect(package.version).to eq "5.29.0"
+      end
+
+      it "sets for PyPI package URLs" do
+        package = described_class.new(old_pypi_package_url, is_url: true)
+        expect(package.version).to eq "5.28.0"
+
+        package.version = "5.29.0"
+        expect(package.version).to eq "5.29.0"
+      end
+
+      it "fails for non-PYPI package URLs" do
+        package = described_class.new(non_pypi_package_url, is_url: true)
+
+        expect { package.version = "1.2.3" }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe ".valid_pypi_package?" do
+      it "is true for package names" do
+        expect(package.valid_pypi_package?).to be true
+      end
+
+      it "is true for PyPI URLs" do
+        expect(package_from_pypi_url.valid_pypi_package?).to be true
       end
 
-      it "initializes version from url" do
-        expect(described_class.new(package_url, is_url: true).version).to eq "5.29.0"
+      it "is false for non-PyPI URLs" do
+        expect(package_from_non_pypi_url.valid_pypi_package?).to be false
       end
     end
 
@@ -82,7 +123,8 @@
       end
 
       it "gets pypi info from a package name and specified version" do
-        expect(package.pypi_info(version: "5.29.0")).to eq ["snakemake", package_url, package_checksum, "5.29.0"]
+        expect(package.pypi_info(new_version: "5.29.0")).to eq ["snakemake", pypi_package_url, package_checksum,
+                                                                "5.29.0"]
       end
 
       it "gets pypi info from a package name with extra" do
@@ -90,26 +132,27 @@
       end
 
       it "gets pypi info from a package name and version" do
-        expect(package_with_version.pypi_info).to eq ["snakemake", old_package_url, old_package_checksum, "5.28.0"]
+        expect(package_with_version.pypi_info).to eq ["snakemake", old_pypi_package_url, old_package_checksum,
+                                                      "5.28.0"]
       end
 
       it "gets pypi info from a package name with overridden version" do
-        expected_result = ["snakemake", package_url, package_checksum, "5.29.0"]
-        expect(package_with_version.pypi_info(version: "5.29.0")).to eq expected_result
+        expected_result = ["snakemake", pypi_package_url, package_checksum, "5.29.0"]
+        expect(package_with_version.pypi_info(new_version: "5.29.0")).to eq expected_result
       end
 
-      it "gets pypi info from a package name, extras, and version" do
-        expected_result = ["snakemake", old_package_url, old_package_checksum, "5.28.0"]
+      it "gets pypi info from a package name, extras and version" do
+        expected_result = ["snakemake", old_pypi_package_url, old_package_checksum, "5.28.0"]
         expect(package_with_extra_and_version.pypi_info).to eq expected_result
       end
 
       it "gets pypi info from a url" do
-        expect(package_from_url.pypi_info).to eq ["snakemake", package_url, package_checksum, "5.29.0"]
+        expect(package_from_pypi_url.pypi_info).to eq ["snakemake", pypi_package_url, package_checksum, "5.29.0"]
       end
 
       it "gets pypi info from a url with overridden version" do
-        expected_result = ["snakemake", old_package_url, old_package_checksum, "5.28.0"]
-        expect(package_from_url.pypi_info(version: "5.28.0")).to eq expected_result
+        expected_result = ["snakemake", old_pypi_package_url, old_package_checksum, "5.28.0"]
+        expect(package_from_pypi_url.pypi_info(new_version: "5.28.0")).to eq expected_result
       end
     end
 
@@ -131,7 +174,7 @@
       end
 
       it "returns string representation of package from url" do
-        expect(package_from_url.to_s).to eq "snakemake==5.29.0"
+        expect(package_from_pypi_url.to_s).to eq "snakemake==5.29.0"
       end
     end
 
@@ -155,7 +198,7 @@
 
     describe "<=>" do
       it "returns -1" do
-        expect(package <=> other_package).to eq((-1))
+        expect(package <=> other_package).to eq(-1)
       end
 
       it "returns 0" do
@@ -170,15 +213,15 @@
 
   describe "update_pypi_url", :needs_network do
     it "updates url to new version" do
-      expect(described_class.update_pypi_url(old_package_url, "5.29.0")).to eq package_url
+      expect(described_class.update_pypi_url(old_pypi_package_url, "5.29.0")).to eq pypi_package_url
     end
 
     it "returns nil for invalid versions" do
-      expect(described_class.update_pypi_url(old_package_url, "0.0.0")).to be_nil
+      expect(described_class.update_pypi_url(old_pypi_package_url, "0.0.0")).to be_nil
     end
 
     it "returns nil for non-pypi urls" do
-      expect(described_class.update_pypi_url("https://brew.sh/foo-1.0.tgz", "1.1")).to be_nil
+      expect(described_class.update_pypi_url(non_pypi_package_url, "1.1")).to be_nil
     end
   end
 end
diff --git a/Library/Homebrew/test/utils/repology_spec.rb b/Library/Homebrew/test/utils/repology_spec.rb
index 7610f0eb2fa6d..97c22e8864f0a 100644
--- a/Library/Homebrew/test/utils/repology_spec.rb
+++ b/Library/Homebrew/test/utils/repology_spec.rb
@@ -1,32 +1,4 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 require "utils/repology"
-
-describe Repology do
-  describe "single_package_query", :needs_network, :needs_homebrew_curl do
-    it "returns nil for non-existent package" do
-      response = described_class.single_package_query("invalidName", repository: "homebrew")
-
-      expect(response).to be_nil
-    end
-
-    it "returns a hash for existing package" do
-      response = described_class.single_package_query("openclonk", repository: "homebrew")
-
-      expect(response).not_to be_nil
-      expect(response).to be_a(Hash)
-    end
-  end
-
-  describe "parse_api_response", :needs_network, :needs_homebrew_curl do
-    it "returns a hash of data" do
-      limit = 1
-      start_with = "x"
-      response = described_class.parse_api_response(limit, start_with, repository: "homebrew")
-
-      expect(response).not_to be_nil
-      expect(response).to be_a(Hash)
-    end
-  end
-end
diff --git a/Library/Homebrew/test/utils/ruby_check_version_script_spec.rb b/Library/Homebrew/test/utils/ruby_check_version_script_spec.rb
index cb3bb59b5b221..5f6786be09699 100644
--- a/Library/Homebrew/test/utils/ruby_check_version_script_spec.rb
+++ b/Library/Homebrew/test/utils/ruby_check_version_script_spec.rb
@@ -1,10 +1,14 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Utils do
+RSpec.describe Utils do
   describe "ruby_check_version_script" do
     subject do
-      quiet_system "#{HOMEBREW_LIBRARY_PATH}/utils/ruby_check_version_script.rb", required_ruby_version
+      homebrew_env = ENV.select { |key, _| key.start_with?("HOMEBREW_") }
+      Bundler.with_unbundled_env do
+        ENV.delete_if { |key,| key.start_with?("HOMEBREW_") }
+        ENV.update(homebrew_env)
+        quiet_system "#{HOMEBREW_LIBRARY_PATH}/utils/ruby_check_version_script.rb", required_ruby_version
+      end
     end
 
     before do
@@ -12,8 +16,8 @@
       ENV.delete("HOMEBREW_USE_RUBY_FROM_PATH")
     end
 
-    describe "succeeds on Homebrew required Ruby version" do
-      let(:required_ruby_version) { HOMEBREW_REQUIRED_RUBY_VERSION }
+    describe "succeeds on the running Ruby version" do
+      let(:required_ruby_version) { RUBY_VERSION }
 
       it { is_expected.to be true }
     end
diff --git a/Library/Homebrew/test/utils/shared_audits_spec.rb b/Library/Homebrew/test/utils/shared_audits_spec.rb
new file mode 100644
index 0000000000000..995fe9c79a463
--- /dev/null
+++ b/Library/Homebrew/test/utils/shared_audits_spec.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "utils/shared_audits"
+
+RSpec.describe SharedAudits do
+  describe "::github_tag_from_url" do
+    it "finds tags in archive urls" do
+      url = "https://github.com/a/b/archive/refs/tags/v1.2.3.tar.gz"
+      expect(described_class.github_tag_from_url(url)).to eq("v1.2.3")
+    end
+
+    it "finds tags in release urls" do
+      url = "https://github.com/a/b/releases/download/1.2.3/b-1.2.3.tar.bz2"
+      expect(described_class.github_tag_from_url(url)).to eq("1.2.3")
+    end
+
+    it "finds tags with slashes" do
+      url = "https://github.com/a/b/archive/refs/tags/c/d/e/f/g-v1.2.3.tar.gz"
+      expect(described_class.github_tag_from_url(url)).to eq("c/d/e/f/g-v1.2.3")
+    end
+
+    it "finds tags in orgs/repos with special characters" do
+      url = "https://github.com/a-b/c-d_e.f/archive/refs/tags/2.5.tar.gz"
+      expect(described_class.github_tag_from_url(url)).to eq("2.5")
+    end
+  end
+
+  describe "::gitlab_tag_from_url" do
+    it "doesn't find tags in invalid urls" do
+      url = "https://gitlab.com/a/-/archive/v1.2.3/a-v1.2.3.tar.gz"
+      expect(described_class.gitlab_tag_from_url(url)).to be_nil
+    end
+
+    it "finds tags in basic urls" do
+      url = "https://gitlab.com/a/b/-/archive/v1.2.3/b-1.2.3.tar.gz"
+      expect(described_class.gitlab_tag_from_url(url)).to eq("v1.2.3")
+    end
+
+    it "finds tags in urls with subgroups" do
+      url = "https://gitlab.com/a/b/c/d/e/f/g/-/archive/2.5/g-2.5.tar.gz"
+      expect(described_class.gitlab_tag_from_url(url)).to eq("2.5")
+    end
+
+    it "finds tags in urls with special characters" do
+      url = "https://gitlab.com/a.b/c-d_e/-/archive/2.5/c-d_e-2.5.tar.gz"
+      expect(described_class.gitlab_tag_from_url(url)).to eq("2.5")
+    end
+  end
+end
diff --git a/Library/Homebrew/test/utils/shell_spec.rb b/Library/Homebrew/test/utils/shell_spec.rb
index d83372f85c729..16bb3670a3a5b 100644
--- a/Library/Homebrew/test/utils/shell_spec.rb
+++ b/Library/Homebrew/test/utils/shell_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/shell"
 
-describe Utils::Shell do
+RSpec.describe Utils::Shell do
   describe "::profile" do
     it "returns ~/.profile by default" do
       ENV["SHELL"] = "/bin/another_shell"
@@ -22,13 +21,13 @@
 
     it "returns /tmp/.zshrc for Zsh if ZDOTDIR is /tmp" do
       ENV["SHELL"] = "/bin/zsh"
-      ENV["ZDOTDIR"] = "/tmp"
+      ENV["HOMEBREW_ZDOTDIR"] = "/tmp"
       expect(described_class.profile).to eq("/tmp/.zshrc")
     end
 
     it "returns ~/.zshrc for Zsh" do
       ENV["SHELL"] = "/bin/zsh"
-      ENV["ZDOTDIR"] = nil
+      ENV["HOMEBREW_ZDOTDIR"] = nil
       expect(described_class.profile).to eq("~/.zshrc")
     end
 
@@ -73,7 +72,7 @@
   specify "::csh_quote" do
     expect(described_class.send(:csh_quote, "")).to eq("''")
     expect(described_class.send(:csh_quote, "\\")).to eq("\\\\")
-    # NOTE: this test is different than for sh
+    # NOTE: This test is different than for `sh`.
     expect(described_class.send(:csh_quote, "\n")).to eq("'\\\n'")
     expect(described_class.send(:csh_quote, "$")).to eq("\\$")
     expect(described_class.send(:csh_quote, "word")).to eq("word")
@@ -85,13 +84,13 @@
     it "supports tcsh" do
       ENV["SHELL"] = "/bin/tcsh"
       expect(described_class.prepend_path_in_profile(path))
-        .to eq("echo 'setenv PATH #{path}:$PATH' >> #{shell_profile}")
+        .to eq("echo 'setenv PATH #{path}:$PATH' >> #{described_class.profile}")
     end
 
     it "supports Bash" do
       ENV["SHELL"] = "/bin/bash"
       expect(described_class.prepend_path_in_profile(path))
-        .to eq("echo 'export PATH=\"#{path}:$PATH\"' >> #{shell_profile}")
+        .to eq("echo 'export PATH=\"#{path}:$PATH\"' >> #{described_class.profile}")
     end
 
     it "supports fish" do
diff --git a/Library/Homebrew/test/utils/spdx_spec.rb b/Library/Homebrew/test/utils/spdx_spec.rb
index 192098b32d96e..495108f058396 100644
--- a/Library/Homebrew/test/utils/spdx_spec.rb
+++ b/Library/Homebrew/test/utils/spdx_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/spdx"
 
-describe SPDX do
+RSpec.describe SPDX do
   describe ".license_data" do
     it "has the license list version" do
       expect(described_class.license_data["licenseListVersion"]).not_to be_nil
@@ -33,17 +32,12 @@
   end
 
   describe ".download_latest_license_data!", :needs_network do
-    let(:tmp_json_path) { Pathname.new(TEST_TMPDIR) }
-
-    after do
-      FileUtils.rm_f tmp_json_path/"spdx_licenses.json"
-      FileUtils.rm_f tmp_json_path/"spdx_exceptions.json"
-    end
+    let(:download_dir) { mktmpdir }
 
     it "downloads latest license data" do
-      described_class.download_latest_license_data! to: tmp_json_path
-      expect(tmp_json_path/"spdx_licenses.json").to exist
-      expect(tmp_json_path/"spdx_exceptions.json").to exist
+      described_class.download_latest_license_data! to: download_dir
+      expect(download_dir/"spdx_licenses.json").to exist
+      expect(download_dir/"spdx_exceptions.json").to exist
     end
   end
 
@@ -81,7 +75,7 @@
       license_expression = { any_of: [
         "MIT",
         :public_domain,
-        all_of: ["0BSD", "Zlib"],
+        all_of: ["0BSD", "Zlib"], # rubocop:disable Style/HashAsLastArrayItem
         "curl" => { with: "LLVM-exception" },
       ] }
       result = [["MIT", :public_domain, "curl", "0BSD", "Zlib"], ["LLVM-exception"]]
@@ -181,39 +175,87 @@
     end
 
     it "returns multiple licenses with :any" do
-      expect(described_class.license_expression_to_string(any_of: ["MIT", "0BSD"])).to eq "MIT or 0BSD"
+      expect(described_class.license_expression_to_string({ any_of: ["MIT", "0BSD"] })).to eq "MIT OR 0BSD"
     end
 
     it "returns multiple licenses with :all" do
-      expect(described_class.license_expression_to_string(all_of: ["MIT", "0BSD"])).to eq "MIT and 0BSD"
+      expect(described_class.license_expression_to_string({ all_of: ["MIT", "0BSD"] })).to eq "MIT AND 0BSD"
     end
 
     it "returns multiple licenses with plus" do
-      expect(described_class.license_expression_to_string(any_of: ["MIT", "EPL-1.0+"])).to eq "MIT or EPL-1.0+"
+      expect(described_class.license_expression_to_string({ any_of: ["MIT", "EPL-1.0+"] })).to eq "MIT OR EPL-1.0+"
     end
 
     it "returns license and exception" do
       license_expression = { "MIT" => { with: "LLVM-exception" } }
-      expect(described_class.license_expression_to_string(license_expression)).to eq "MIT with LLVM-exception"
+      expect(described_class.license_expression_to_string(license_expression)).to eq "MIT WITH LLVM-exception"
     end
 
     it "returns licenses and exceptions for complex license expressions" do
       license_expression = { any_of: [
         "MIT",
         :public_domain,
-        all_of: ["0BSD", "Zlib"],
+        all_of: ["0BSD", "Zlib"], # rubocop:disable Style/HashAsLastArrayItem
         "curl" => { with: "LLVM-exception" },
       ] }
-      result = "MIT or Public Domain or (0BSD and Zlib) or (curl with LLVM-exception)"
+      result = "MIT OR LicenseRef-Homebrew-public-domain OR (0BSD AND Zlib) OR (curl WITH LLVM-exception)"
       expect(described_class.license_expression_to_string(license_expression)).to eq result
     end
 
     it "returns :public_domain" do
-      expect(described_class.license_expression_to_string(:public_domain)).to eq "Public Domain"
+      expect(described_class.license_expression_to_string(:public_domain)).to eq "LicenseRef-Homebrew-public-domain"
+    end
+
+    it "returns :cannot_represent" do
+      result = "LicenseRef-Homebrew-cannot-represent"
+      expect(described_class.license_expression_to_string(:cannot_represent)).to eq result
+    end
+  end
+
+  describe ".string_to_license_expression" do
+    it "returns the correct result for 'and', 'or' and 'with'" do
+      expr_string = "Apache-2.0 and (Apache-2.0 with LLVM-exception) and (MIT or NCSA)"
+      expect(described_class.string_to_license_expression(expr_string)).to eq({
+        all_of: [
+          "Apache-2.0",
+          { "Apache-2.0" => { with: "LLVM-exception" } },
+          { any_of: ["MIT", "NCSA"] },
+        ],
+      })
+    end
+
+    it "returns the correct result for 'AND', 'OR' and 'WITH'" do
+      expr_string = "Apache-2.0 AND (Apache-2.0 WITH LLVM-exception) AND (MIT OR NCSA)"
+      expect(described_class.string_to_license_expression(expr_string)).to eq({
+        all_of: [
+          "Apache-2.0",
+          { "Apache-2.0" => { with: "LLVM-exception" } },
+          { any_of: ["MIT", "NCSA"] },
+        ],
+      })
+    end
+
+    # rubocop:disable Style/HashAsLastArrayItem
+    it "handles nested brackets" do
+      expect(described_class.string_to_license_expression("A AND (B OR (C AND D))")).to eq({
+        all_of: [
+          "A",
+          any_of: [
+            "B",
+            all_of: ["C", "D"],
+          ],
+        ],
+      })
+    end
+    # rubocop:enable Style/HashAsLastArrayItem
+
+    it "returns :public_domain" do
+      expect(described_class.string_to_license_expression("LicenseRef-Homebrew-public-domain")).to eq :public_domain
     end
 
     it "returns :cannot_represent" do
-      expect(described_class.license_expression_to_string(:cannot_represent)).to eq "Cannot Represent"
+      expr_string = "LicenseRef-Homebrew-cannot-represent"
+      expect(described_class.string_to_license_expression(expr_string)).to eq :cannot_represent
     end
   end
 
@@ -255,15 +297,15 @@
     let(:mit_forbidden) { { "MIT" => described_class.license_version_info("MIT") } }
     let(:epl_1_forbidden) { { "EPL-1.0" => described_class.license_version_info("EPL-1.0") } }
     let(:epl_1_plus_forbidden) { { "EPL-1.0+" => described_class.license_version_info("EPL-1.0+") } }
-    let(:multiple_forbidden) {
+    let(:multiple_forbidden) do
       {
         "MIT"  => described_class.license_version_info("MIT"),
         "0BSD" => described_class.license_version_info("0BSD"),
       }
-    }
+    end
     let(:any_of_license) { { any_of: ["MIT", "0BSD"] } }
     let(:all_of_license) { { all_of: ["MIT", "0BSD"] } }
-    let(:nested_licenses) {
+    let(:nested_licenses) do
       {
         any_of: [
           "MIT",
@@ -271,7 +313,7 @@
           { any_of: ["MIT", "0BSD"] },
         ],
       }
-    }
+    end
     let(:license_exception) { { "MIT" => { with: "LLVM-exception" } } }
 
     it "allows installation with no forbidden licenses" do
diff --git a/Library/Homebrew/test/utils/string_inreplace_extension_spec.rb b/Library/Homebrew/test/utils/string_inreplace_extension_spec.rb
index 999e55c67de1a..c59c4a342a4b6 100644
--- a/Library/Homebrew/test/utils/string_inreplace_extension_spec.rb
+++ b/Library/Homebrew/test/utils/string_inreplace_extension_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/string_inreplace_extension"
 
-describe StringInreplaceExtension do
+RSpec.describe StringInreplaceExtension do
   subject(:string_extension) { described_class.new(string.dup) }
 
   describe "#change_make_var!" do
@@ -250,12 +249,20 @@
     it "replaces the first occurrence" do
       string_extension.sub!("o", "e")
       expect(string_extension.inreplace_string).to eq("feo")
+      expect(string_extension.errors).to be_empty
     end
 
     it "adds an error to #errors when no replacement was made" do
       string_extension.sub! "not here", "test"
+      expect(string_extension.inreplace_string).to eq(string)
       expect(string_extension.errors).to eq(['expected replacement of "not here" with "test"'])
     end
+
+    it "doesn't add an error to #errors when no replace was made and `audit_result: false`" do
+      string_extension.sub! "not here", "test", audit_result: false
+      expect(string_extension.inreplace_string).to eq(string)
+      expect(string_extension.errors).to be_empty
+    end
   end
 
   describe "#gsub!" do
diff --git a/Library/Homebrew/test/utils/svn_spec.rb b/Library/Homebrew/test/utils/svn_spec.rb
index ff1014af3d877..59bd5c05d6922 100644
--- a/Library/Homebrew/test/utils/svn_spec.rb
+++ b/Library/Homebrew/test/utils/svn_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/svn"
 
-describe Utils::Svn do
+RSpec.describe Utils::Svn do
   before do
     described_class.clear_version_cache
   end
@@ -48,7 +47,7 @@
       end
 
       it "returns true when remote exists", :needs_network, :needs_svn do
-        expect(described_class).to be_remote_exists("https://github.com/Homebrew/install")
+        expect(described_class).to be_remote_exists("https://svn.apache.org/repos/asf/openoffice/trunk")
       end
     end
   end
diff --git a/Library/Homebrew/test/utils/tar_spec.rb b/Library/Homebrew/test/utils/tar_spec.rb
index 0b7ff0ee58348..418c95bd4eaeb 100644
--- a/Library/Homebrew/test/utils/tar_spec.rb
+++ b/Library/Homebrew/test/utils/tar_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/tar"
 
-describe Utils::Tar do
+RSpec.describe Utils::Tar do
   before do
     described_class.clear_executable_cache
   end
diff --git a/Library/Homebrew/test/utils/timer_spec.rb b/Library/Homebrew/test/utils/timer_spec.rb
new file mode 100644
index 0000000000000..2140fd28a69a2
--- /dev/null
+++ b/Library/Homebrew/test/utils/timer_spec.rb
@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "utils/timer"
+
+RSpec.describe Utils::Timer do
+  describe "#remaining" do
+    it "returns nil when nil" do
+      expect(described_class.remaining(nil)).to be_nil
+    end
+
+    it "returns time remaining when there is time remaining" do
+      expect(described_class.remaining(Time.now + 10)).to be > 1
+    end
+
+    it "returns 0 when there is no time remaining" do
+      expect(described_class.remaining(Time.now - 10)).to be 0
+    end
+  end
+
+  describe "#remaining!" do
+    it "returns nil when nil" do
+      expect(described_class.remaining!(nil)).to be_nil
+    end
+
+    it "returns time remaining when there is time remaining" do
+      expect(described_class.remaining!(Time.now + 10)).to be > 1
+    end
+
+    it "returns 0 when there is no time remaining" do
+      expect { described_class.remaining!(Time.now - 10) }.to raise_error(Timeout::Error)
+    end
+  end
+end
diff --git a/Library/Homebrew/test/utils/topological_hash_spec.rb b/Library/Homebrew/test/utils/topological_hash_spec.rb
index 8292a9f7cfd10..a1bf8904e5d49 100644
--- a/Library/Homebrew/test/utils/topological_hash_spec.rb
+++ b/Library/Homebrew/test/utils/topological_hash_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/topological_hash"
 
-describe Utils::TopologicalHash do
+RSpec.describe Utils::TopologicalHash do
   describe "#tsort" do
     it "returns a topologically sorted array" do
       hash = described_class.new
diff --git a/Library/Homebrew/test/utils/tty_spec.rb b/Library/Homebrew/test/utils/tty_spec.rb
index 948306a645cbb..41672b1cfd360 100644
--- a/Library/Homebrew/test/utils/tty_spec.rb
+++ b/Library/Homebrew/test/utils/tty_spec.rb
@@ -1,16 +1,15 @@
-# typed: false
 # frozen_string_literal: true
 
-describe Tty do
+RSpec.describe Tty do
   describe "::strip_ansi" do
     it "removes ANSI escape codes from a string" do
-      expect(described_class.strip_ansi("\033\[36;7mhello\033\[0m")).to eq("hello")
+      expect(described_class.strip_ansi("\033[36;7mhello\033[0m")).to eq("hello")
     end
   end
 
   describe "::width" do
     it "returns an Integer" do
-      expect(described_class.width).to be_kind_of(Integer)
+      expect(described_class.width).to be_a(Integer)
     end
 
     it "cannot be negative" do
diff --git a/Library/Homebrew/test/utils/user_spec.rb b/Library/Homebrew/test/utils/user_spec.rb
index b223b30ec67bd..111b8d34ec210 100644
--- a/Library/Homebrew/test/utils/user_spec.rb
+++ b/Library/Homebrew/test/utils/user_spec.rb
@@ -1,39 +1,39 @@
-# typed: false
 # frozen_string_literal: true
 
 require "utils/user"
 
-describe User do
-  subject { described_class.current }
+RSpec.describe User do
+  subject(:user) { described_class.current }
 
   it { is_expected.to eq ENV.fetch("USER") }
 
   describe "#gui?" do
     before do
-      allow(SystemCommand).to receive(:run).with("who")
+      allow(SystemCommand).to receive(:run)
+        .with("who", any_args)
         .and_return([who_output, "", instance_double(Process::Status, success?: true)])
     end
 
     context "when the current user is in a console session" do
-      let(:who_output) {
+      let(:who_output) do
         <<~EOS
           #{ENV.fetch("USER")}   console  Oct  1 11:23
           #{ENV.fetch("USER")}   ttys001  Oct  1 11:25
         EOS
-      }
+      end
 
-      its(:gui?) { is_expected.to be true }
+      it(:gui?) { expect(user.gui?).to be true }
     end
 
     context "when the current user is not in a console session" do
-      let(:who_output) {
+      let(:who_output) do
         <<~EOS
           #{ENV.fetch("USER")}   ttys001  Oct  1 11:25
           fake_user              ttys002  Oct  1 11:27
         EOS
-      }
+      end
 
-      its(:gui?) { is_expected.to be false }
+      it(:gui?) { expect(user.gui?).to be false }
     end
   end
 end
diff --git a/Library/Homebrew/test/utils_spec.rb b/Library/Homebrew/test/utils_spec.rb
index e26ebbacb9c42..b8766fc9aca9a 100644
--- a/Library/Homebrew/test/utils_spec.rb
+++ b/Library/Homebrew/test/utils_spec.rb
@@ -1,332 +1,115 @@
-# typed: false
 # frozen_string_literal: true
 
-describe "globally-scoped helper methods" do
-  let(:dir) { mktmpdir }
+require "utils"
 
-  def esc(code)
-    /(\e\[\d+m)*\e\[#{code}m/
-  end
-
-  describe "#ofail" do
-    it "sets Homebrew.failed to true" do
-      expect {
-        ofail "foo"
-      }.to output("Error: foo\n").to_stderr
-
-      expect(Homebrew).to have_failed
-    end
-  end
-
-  describe "#odie" do
-    it "exits with 1" do
-      expect(self).to receive(:exit).and_return(1)
-      expect {
-        odie "foo"
-      }.to output("Error: foo\n").to_stderr
-    end
-  end
-
-  describe "#pretty_installed" do
-    subject(:pretty_installed_output) { pretty_installed("foo") }
-
-    context "when $stdout is a TTY" do
-      before { allow($stdout).to receive(:tty?).and_return(true) }
-
-      context "with HOMEBREW_NO_EMOJI unset" do
-        it "returns a string with a colored checkmark" do
-          expect(pretty_installed_output)
-            .to match(/#{esc 1}foo #{esc 32}✔#{esc 0}/)
-        end
-      end
-
-      context "with HOMEBREW_NO_EMOJI set" do
-        before { ENV["HOMEBREW_NO_EMOJI"] = "1" }
-
-        it "returns a string with colored info" do
-          expect(pretty_installed_output)
-            .to match(/#{esc 1}foo \(installed\)#{esc 0}/)
-        end
-      end
-    end
-
-    context "when $stdout is not a TTY" do
-      before { allow($stdout).to receive(:tty?).and_return(false) }
-
-      it "returns plain text" do
-        expect(pretty_installed_output).to eq("foo")
-      end
-    end
-  end
-
-  describe "#pretty_uninstalled" do
-    subject(:pretty_uninstalled_output) { pretty_uninstalled("foo") }
-
-    context "when $stdout is a TTY" do
-      before { allow($stdout).to receive(:tty?).and_return(true) }
-
-      context "with HOMEBREW_NO_EMOJI unset" do
-        it "returns a string with a colored checkmark" do
-          expect(pretty_uninstalled_output)
-            .to match(/#{esc 1}foo #{esc 31}✘#{esc 0}/)
-        end
-      end
-
-      context "with HOMEBREW_NO_EMOJI set" do
-        before { ENV["HOMEBREW_NO_EMOJI"] = "1" }
-
-        it "returns a string with colored info" do
-          expect(pretty_uninstalled_output)
-            .to match(/#{esc 1}foo \(uninstalled\)#{esc 0}/)
-        end
-      end
-    end
-
-    context "when $stdout is not a TTY" do
-      before { allow($stdout).to receive(:tty?).and_return(false) }
-
-      it "returns plain text" do
-        expect(pretty_uninstalled_output).to eq("foo")
-      end
-    end
-  end
-
-  describe "#interactive_shell" do
-    let(:shell) { dir/"myshell" }
-
-    it "starts an interactive shell session" do
-      File.write shell, <<~SH
-        #!/bin/sh
-        echo called > "#{dir}/called"
-      SH
-
-      FileUtils.chmod 0755, shell
-
-      ENV["SHELL"] = shell
-
-      expect { interactive_shell }.not_to raise_error
-      expect(dir/"called").to exist
-    end
-  end
-
-  describe "#with_custom_locale" do
-    it "temporarily overrides the system locale" do
-      ENV["LC_ALL"] = "en_US.UTF-8"
-
-      with_custom_locale("C") do
-        expect(ENV.fetch("LC_ALL")).to eq("C")
-      end
-
-      expect(ENV.fetch("LC_ALL")).to eq("en_US.UTF-8")
-    end
-  end
-
-  describe "#which" do
-    let(:cmd) { dir/"foo" }
-
-    before { FileUtils.touch cmd }
-
-    it "returns the first executable that is found" do
-      cmd.chmod 0744
-      expect(which(File.basename(cmd), File.dirname(cmd))).to eq(cmd)
+RSpec.describe Utils do
+  describe ".deconstantize" do
+    it "removes the rightmost segment from the constant expression in the string" do
+      expect(described_class.deconstantize("Net::HTTP")).to eq("Net")
+      expect(described_class.deconstantize("::Net::HTTP")).to eq("::Net")
+      expect(described_class.deconstantize("String")).to eq("")
+      expect(described_class.deconstantize("::String")).to eq("")
     end
 
-    it "skips non-executables" do
-      expect(which(File.basename(cmd), File.dirname(cmd))).to be_nil
-    end
-
-    it "skips malformed path and doesn't fail" do
-      # 'which' should not fail if a path is malformed
-      # see https://github.com/Homebrew/legacy-homebrew/issues/32789 for an example
-      cmd.chmod 0744
-
-      # ~~ will fail because ~foo resolves to foo's home and there is no '~' user
-      path = ["~~", File.dirname(cmd)].join(File::PATH_SEPARATOR)
-      expect(which(File.basename(cmd), path)).to eq(cmd)
+    it "returns an empty string if the namespace is empty" do
+      expect(described_class.deconstantize("")).to eq("")
+      expect(described_class.deconstantize("::")).to eq("")
     end
   end
 
-  describe "#which_all" do
-    let(:cmd1) { dir/"foo" }
-    let(:cmd2) { dir/"bar/foo" }
-    let(:cmd3) { dir/"bar/baz/foo" }
-
-    before do
-      (dir/"bar/baz").mkpath
-
-      FileUtils.touch cmd2
-
-      [cmd1, cmd3].each do |cmd|
-        FileUtils.touch cmd
-        cmd.chmod 0744
-      end
+  describe ".demodulize" do
+    it "removes the module part from the expression in the string" do
+      expect(described_class.demodulize("Foo::Bar")).to eq("Bar")
     end
 
-    it "returns an array of all executables that are found" do
-      path = [
-        "#{dir}/bar/baz",
-        "#{dir}/baz:#{dir}",
-        "~baduserpath",
-      ].join(File::PATH_SEPARATOR)
-      expect(which_all("foo", path)).to eq([cmd3, cmd1])
+    it "returns the string if it does not contain a module expression" do
+      expect(described_class.demodulize("FooBar")).to eq("FooBar")
     end
-  end
-
-  specify "#which_editor" do
-    ENV["HOMEBREW_EDITOR"] = "vemate -w"
-    ENV["HOMEBREW_PATH"] = dir
-
-    editor = "#{dir}/vemate"
-    FileUtils.touch editor
-    FileUtils.chmod 0755, editor
 
-    expect(which_editor).to eq("vemate -w")
-  end
-
-  specify "#gzip" do
-    mktmpdir do |path|
-      somefile = path/"somefile"
-      FileUtils.touch somefile
-      expect(gzip(somefile)[0].to_s).to eq("#{somefile}.gz")
-      expect(Pathname.new("#{somefile}.gz")).to exist
+    it "returns an empty string if the namespace is empty" do
+      expect(described_class.demodulize("")).to eq("")
+      expect(described_class.demodulize("::")).to eq("")
     end
   end
 
-  specify "#capture_stderr" do
-    err = capture_stderr do
-      $stderr.print "test"
-    end
-
-    expect(err).to eq("test")
-  end
-
-  describe "#pretty_duration" do
-    it "converts seconds to a human-readable string" do
-      expect(pretty_duration(1)).to eq("1 second")
-      expect(pretty_duration(2.5)).to eq("2 seconds")
-      expect(pretty_duration(42)).to eq("42 seconds")
-      expect(pretty_duration(240)).to eq("4 minutes")
-      expect(pretty_duration(252.45)).to eq("4 minutes 12 seconds")
-    end
-  end
-
-  specify "#parse_author!" do
+  specify ".parse_author!" do
     parse_error_msg = /Unable to parse name and email/
 
-    expect(parse_author!("John Doe <john.doe@example.com>"))
+    expect(described_class.parse_author!("John Doe <john.doe@example.com>"))
       .to eq({ name: "John Doe", email: "john.doe@example.com" })
-    expect { parse_author!("") }
+    expect { described_class.parse_author!("") }
       .to raise_error(parse_error_msg)
-    expect { parse_author!("John Doe") }
+    expect { described_class.parse_author!("John Doe") }
       .to raise_error(parse_error_msg)
-    expect { parse_author!("<john.doe@example.com>") }
+    expect { described_class.parse_author!("<john.doe@example.com>") }
       .to raise_error(parse_error_msg)
   end
 
-  specify "#disk_usage_readable" do
-    expect(disk_usage_readable(1)).to eq("1B")
-    expect(disk_usage_readable(1000)).to eq("1000B")
-    expect(disk_usage_readable(1024)).to eq("1KB")
-    expect(disk_usage_readable(1025)).to eq("1KB")
-    expect(disk_usage_readable(4_404_020)).to eq("4.2MB")
-    expect(disk_usage_readable(4_509_715_660)).to eq("4.2GB")
-  end
-
-  describe "#number_readable" do
-    it "returns a string with thousands separators" do
-      expect(number_readable(1)).to eq("1")
-      expect(number_readable(1_000)).to eq("1,000")
-      expect(number_readable(1_000_000)).to eq("1,000,000")
-    end
-  end
-
-  specify "#truncate_text_to_approximate_size" do
-    glue = "\n[...snip...]\n" # hard-coded copy from truncate_text_to_approximate_size
-    n = 20
-    long_s = "x" * 40
-
-    s = truncate_text_to_approximate_size(long_s, n)
-    expect(s.length).to eq(n)
-    expect(s).to match(/^x+#{Regexp.escape(glue)}x+$/)
-
-    s = truncate_text_to_approximate_size(long_s, n, front_weight: 0.0)
-    expect(s).to eq(glue + ("x" * (n - glue.length)))
-
-    s = truncate_text_to_approximate_size(long_s, n, front_weight: 1.0)
-    expect(s).to eq(("x" * (n - glue.length)) + glue)
-  end
-
-  describe "#odeprecated" do
-    it "raises a MethodDeprecatedError when `disable` is true" do
-      ENV.delete("HOMEBREW_DEVELOPER")
-      expect {
-        odeprecated(
-          "method", "replacement",
-          caller:  ["#{HOMEBREW_LIBRARY}/Taps/homebrew/homebrew-core/"],
-          disable: true
-        )
-      }.to raise_error(
-        MethodDeprecatedError,
-        %r{method.*replacement.*homebrew/core.*/Taps/homebrew/homebrew-core/}m,
-      )
-    end
-  end
-
-  describe "#with_env" do
-    it "sets environment variables within the block" do
-      expect(ENV.fetch("PATH")).not_to eq("/bin")
-      with_env(PATH: "/bin") do
-        expect(ENV.fetch("PATH", nil)).to eq("/bin")
-      end
-    end
-
-    it "restores ENV after the block" do
-      with_env(PATH: "/bin") do
-        expect(ENV.fetch("PATH", nil)).to eq("/bin")
-      end
-      path = ENV.fetch("PATH", nil)
-      expect(path).not_to be_nil
-      expect(path).not_to eq("/bin")
-    end
-
-    it "restores ENV if an exception is raised" do
-      expect {
-        with_env(PATH: "/bin") do
-          raise StandardError, "boom"
-        end
-      }.to raise_error(StandardError)
-
-      path = ENV.fetch("PATH", nil)
-      expect(path).not_to be_nil
-      expect(path).not_to eq("/bin")
-    end
-  end
-
-  describe "#tap_and_name_comparison" do
-    describe "both strings are only names" do
-      it "alphabetizes the strings" do
-        expect(%w[a b].sort(&tap_and_name_comparison)).to eq(%w[a b])
-        expect(%w[b a].sort(&tap_and_name_comparison)).to eq(%w[a b])
-      end
-    end
-
-    describe "both strings include tap" do
-      it "alphabetizes the strings" do
-        expect(%w[a/z/z b/z/z].sort(&tap_and_name_comparison)).to eq(%w[a/z/z b/z/z])
-        expect(%w[b/z/z a/z/z].sort(&tap_and_name_comparison)).to eq(%w[a/z/z b/z/z])
-
-        expect(%w[z/a/z z/b/z].sort(&tap_and_name_comparison)).to eq(%w[z/a/z z/b/z])
-        expect(%w[z/b/z z/a/z].sort(&tap_and_name_comparison)).to eq(%w[z/a/z z/b/z])
-
-        expect(%w[z/z/a z/z/b].sort(&tap_and_name_comparison)).to eq(%w[z/z/a z/z/b])
-        expect(%w[z/z/b z/z/a].sort(&tap_and_name_comparison)).to eq(%w[z/z/a z/z/b])
-      end
-    end
-
-    describe "only one string includes tap" do
-      it "prefers the string without tap" do
-        expect(%w[a/z/z z].sort(&tap_and_name_comparison)).to eq(%w[z a/z/z])
-        expect(%w[z a/z/z].sort(&tap_and_name_comparison)).to eq(%w[z a/z/z])
+  describe ".pluralize" do
+    it "combines the stem with the default suffix based on the count" do
+      expect(described_class.pluralize("foo", 0)).to eq("foos")
+      expect(described_class.pluralize("foo", 1)).to eq("foo")
+      expect(described_class.pluralize("foo", 2)).to eq("foos")
+    end
+
+    it "combines the stem with the singular suffix based on the count" do
+      expect(described_class.pluralize("foo", 0, singular: "o")).to eq("foos")
+      expect(described_class.pluralize("foo", 1, singular: "o")).to eq("fooo")
+      expect(described_class.pluralize("foo", 2, singular: "o")).to eq("foos")
+    end
+
+    it "combines the stem with the plural suffix based on the count" do
+      expect(described_class.pluralize("foo", 0, plural: "es")).to eq("fooes")
+      expect(described_class.pluralize("foo", 1, plural: "es")).to eq("foo")
+      expect(described_class.pluralize("foo", 2, plural: "es")).to eq("fooes")
+    end
+
+    it "combines the stem with the singular and plural suffix based on the count" do
+      expect(described_class.pluralize("foo", 0, singular: "o", plural: "es")).to eq("fooes")
+      expect(described_class.pluralize("foo", 1, singular: "o", plural: "es")).to eq("fooo")
+      expect(described_class.pluralize("foo", 2, singular: "o", plural: "es")).to eq("fooes")
+    end
+
+    it "includes the count when requested" do
+      expect(described_class.pluralize("foo", 0, include_count: true)).to eq("0 foos")
+      expect(described_class.pluralize("foo", 1, include_count: true)).to eq("1 foo")
+      expect(described_class.pluralize("foo", 2, include_count: true)).to eq("2 foos")
+    end
+  end
+
+  describe ".underscore" do
+    # commented out entries require acronyms inflections
+    let(:words) do
+      [
+        ["API", "api"],
+        ["APIController", "api_controller"],
+        ["Nokogiri::HTML", "nokogiri/html"],
+        # ["HTTPAPI", "http_api"],
+        ["HTTP::Get", "http/get"],
+        ["SSLError", "ssl_error"],
+        # ["RESTful", "restful"],
+        # ["RESTfulController", "restful_controller"],
+        # ["Nested::RESTful", "nested/restful"],
+        # ["IHeartW3C", "i_heart_w3c"],
+        # ["PhDRequired", "phd_required"],
+        # ["IRoRU", "i_ror_u"],
+        # ["RESTfulHTTPAPI", "restful_http_api"],
+        # ["HTTP::RESTful", "http/restful"],
+        # ["HTTP::RESTfulAPI", "http/restful_api"],
+        # ["APIRESTful", "api_restful"],
+        ["Capistrano", "capistrano"],
+        ["CapiController", "capi_controller"],
+        ["HttpsApis", "https_apis"],
+        ["Html5", "html5"],
+        ["Restfully", "restfully"],
+        ["RoRails", "ro_rails"],
+      ]
+    end
+
+    it "converts strings to underscore case" do
+      words.each do |camel, under|
+        expect(described_class.underscore(camel)).to eq(under)
+        expect(described_class.underscore(under)).to eq(under)
       end
     end
   end
diff --git a/Library/Homebrew/test/version/parser_spec.rb b/Library/Homebrew/test/version/parser_spec.rb
index fe2afde9bc094..ce8d2861d9a6e 100644
--- a/Library/Homebrew/test/version/parser_spec.rb
+++ b/Library/Homebrew/test/version/parser_spec.rb
@@ -1,9 +1,8 @@
-# typed: false
 # frozen_string_literal: true
 
 require "version/parser"
 
-describe Version::Parser do
+RSpec.describe Version::Parser do
   specify "::new" do
     expect { described_class.new }
       .to raise_error("Version::Parser is declared as abstract; it cannot be instantiated")
@@ -11,10 +10,8 @@
 
   describe Version::RegexParser do
     specify "::new" do
-      # TODO: see https://github.com/sorbet/sorbet/issues/2374
-      # expect { described_class.new(/[._-](\d+(?:\.\d+)+)/) }
-      #   .to raise_error("Version::RegexParser is declared as abstract; it cannot be instantiated")
-      expect { described_class.new(/[._-](\d+(?:\.\d+)+)/) }.not_to raise_error
+      expect { described_class.new(/[._-](\d+(?:\.\d+)+)/) }
+        .to raise_error("Version::RegexParser is declared as abstract; it cannot be instantiated")
     end
 
     specify "::process_spec" do
diff --git a/Library/Homebrew/test/version_spec.rb b/Library/Homebrew/test/version_spec.rb
index a7b4456d44c32..99c301fb301f0 100644
--- a/Library/Homebrew/test/version_spec.rb
+++ b/Library/Homebrew/test/version_spec.rb
@@ -1,20 +1,21 @@
-# typed: false
 # frozen_string_literal: true
 
 require "version"
 
-describe Version do
+RSpec.describe Version do
+  subject(:version) { described_class.new("1.2.3") }
+
   specify ".formula_optionally_versioned_regex" do
     expect(described_class.formula_optionally_versioned_regex("foo")).to match("foo@1.2")
   end
 
   describe Version::Token do
     specify "#inspect" do
-      expect(described_class.new("foo").inspect).to eq('#<Version::Token "foo">')
+      expect(described_class.create("foo").inspect).to eq('#<Version::StringToken "foo">')
     end
 
     specify "#to_s" do
-      expect(described_class.new("foo").to_s).to eq("foo")
+      expect(described_class.create("foo").to_s).to eq("foo")
     end
 
     it "can be compared against nil" do
@@ -22,15 +23,15 @@
       expect(described_class.create("p194")).to be > nil
     end
 
-    it "can be compared against Version::NULL_TOKEN" do
+    it "can be compared against `Version::NULL_TOKEN`" do
       expect(described_class.create("2")).to be > Version::NULL_TOKEN
       expect(described_class.create("p194")).to be > Version::NULL_TOKEN
     end
 
     it "can be compared against strings" do
-      expect(described_class.create("2")).to be == "2"
-      expect(described_class.create("p194")).to be == "p194"
-      expect(described_class.create("1")).to be == 1
+      expect(described_class.create("2")).to eq "2"
+      expect(described_class.create("p194")).to eq "p194"
+      expect(described_class.create("1")).to eq 1
     end
 
     specify "comparison returns nil for non-token" do
@@ -41,31 +42,86 @@
 
     describe "#to_str" do
       it "implicitly converts token to string" do
-        expect(String.try_convert(described_class.new("foo"))).not_to be_nil
+        expect(String.try_convert(described_class.create("foo"))).not_to be_nil
       end
     end
   end
 
-  describe Version::NULL do
+  describe "#to_s" do
+    it "returns a string" do
+      expect(version.to_s).to eq "1.2.3"
+    end
+  end
+
+  describe "#to_str" do
+    it "returns a string" do
+      expect(version.to_str).to eq "1.2.3"
+    end
+  end
+
+  it "implicitlys converts to a string" do
+    expect(String.try_convert(version)).to eq "1.2.3"
+  end
+
+  describe "#to_f" do
+    it "returns a float" do
+      expect(version.to_f).to eq 1.2
+    end
+  end
+
+  describe "#to_json" do
+    it "returns a JSON string" do
+      expect(version.to_json).to eq "\"1.2.3\""
+    end
+  end
+
+  describe "when the version is `NULL`" do
+    subject(:null_version) { Version::NULL }
+
     it "is always smaller" do
-      expect(described_class).to be < Version.create("1")
+      expect(null_version).to be < described_class.new("1")
     end
 
     it "is never greater" do
-      expect(described_class).not_to be > Version.create("0")
+      expect(null_version).not_to be > described_class.new("0")
     end
 
     it "isn't equal to itself" do
-      expect(described_class).not_to eql(described_class)
+      expect(null_version).not_to eql(null_version)
     end
 
-    it "creates an empty string" do
-      expect(described_class.to_s).to eq("")
+    describe "#to_s" do
+      it "returns an empty string" do
+        expect(null_version.to_s).to eq ""
+      end
     end
 
-    it "produces NaN as a Float" do
-      # Float::NAN is not equal to itself so compare object IDs
-      expect(described_class.to_f.object_id).to eql(Float::NAN.object_id)
+    describe "#to_str" do
+      it "does not respond to it" do
+        expect(null_version).not_to respond_to(:to_str)
+      end
+
+      it "raises an error" do
+        expect do
+          null_version.to_str
+        end.to raise_error NoMethodError, "undefined method `to_str' for Version:NULL"
+      end
+    end
+
+    it "does not implicitly convert to a string" do
+      expect(String.try_convert(null_version)).to be_nil
+    end
+
+    describe "#to_f" do
+      it "returns NaN" do
+        expect(null_version.to_f).to be_nan
+      end
+    end
+
+    describe "#to_json" do
+      it "outputs `null`" do
+        expect(null_version.to_json).to eq "null"
+      end
     end
   end
 
@@ -77,140 +133,160 @@
     end
 
     it "is equal to itself" do
-      expect(null_version).to be == described_class::NULL_TOKEN
+      expect(null_version).to eq described_class::NULL_TOKEN
     end
   end
 
   specify "comparison" do
-    expect(described_class.create("0.1")).to be == described_class.create("0.1.0")
-    expect(described_class.create("0.1")).to be < described_class.create("0.2")
-    expect(described_class.create("1.2.3")).to be > described_class.create("1.2.2")
-    expect(described_class.create("1.2.4")).to be < described_class.create("1.2.4.1")
-
-    expect(described_class.create("1.2.3")).to be > described_class.create("1.2.3alpha4")
-    expect(described_class.create("1.2.3")).to be > described_class.create("1.2.3beta2")
-    expect(described_class.create("1.2.3")).to be > described_class.create("1.2.3rc3")
-    expect(described_class.create("1.2.3")).to be < described_class.create("1.2.3-p34")
+    expect(described_class.new("0.1")).to eq described_class.new("0.1.0")
+    expect(described_class.new("0.1")).to be < described_class.new("0.2")
+    expect(described_class.new("1.2.3")).to be > described_class.new("1.2.2")
+    expect(described_class.new("1.2.4")).to be < described_class.new("1.2.4.1")
+
+    expect(described_class.new("1.2.3")).to be > described_class.new("1.2.3alpha4")
+    expect(described_class.new("1.2.3")).to be > described_class.new("1.2.3beta2")
+    expect(described_class.new("1.2.3")).to be > described_class.new("1.2.3rc3")
+    expect(described_class.new("1.2.3")).to be < described_class.new("1.2.3-p34")
+  end
+
+  specify "compare" do
+    expect(described_class.new("0.1").compare("==", described_class.new("0.1.0"))).to be true
+    expect(described_class.new("0.1").compare("<", described_class.new("0.2"))).to be true
+    expect(described_class.new("1.2.3").compare(">", described_class.new("1.2.2"))).to be true
+    expect(described_class.new("1.2.4").compare("<", described_class.new("1.2.4.1"))).to be true
+    expect(described_class.new("0.1").compare("!=", described_class.new("0.1.0"))).to be false
+    expect(described_class.new("0.1").compare(">=", described_class.new("0.2"))).to be false
+    expect(described_class.new("1.2.3").compare("<=", described_class.new("1.2.2"))).to be false
+    expect(described_class.new("1.2.4").compare(">=", described_class.new("1.2.4.1"))).to be false
+
+    expect(described_class.new("1.2.3").compare(">", described_class.new("1.2.3alpha4"))).to be true
+    expect(described_class.new("1.2.3").compare(">", described_class.new("1.2.3beta2"))).to be true
+    expect(described_class.new("1.2.3").compare(">", described_class.new("1.2.3rc3"))).to be true
+    expect(described_class.new("1.2.3").compare("<", described_class.new("1.2.3-p34"))).to be true
+    expect(described_class.new("1.2.3").compare("<=", described_class.new("1.2.3alpha4"))).to be false
+    expect(described_class.new("1.2.3").compare("<=", described_class.new("1.2.3beta2"))).to be false
+    expect(described_class.new("1.2.3").compare("<=", described_class.new("1.2.3rc3"))).to be false
+    expect(described_class.new("1.2.3").compare(">=", described_class.new("1.2.3-p34"))).to be false
   end
 
   specify "HEAD" do
-    expect(described_class.create("HEAD")).to be > described_class.create("1.2.3")
-    expect(described_class.create("HEAD-abcdef")).to be > described_class.create("1.2.3")
-    expect(described_class.create("1.2.3")).to be < described_class.create("HEAD")
-    expect(described_class.create("1.2.3")).to be < described_class.create("HEAD-fedcba")
-    expect(described_class.create("HEAD-abcdef")).to be == described_class.create("HEAD-fedcba")
-    expect(described_class.create("HEAD")).to be == described_class.create("HEAD-fedcba")
+    expect(described_class.new("HEAD")).to be > described_class.new("1.2.3")
+    expect(described_class.new("HEAD-abcdef")).to be > described_class.new("1.2.3")
+    expect(described_class.new("1.2.3")).to be < described_class.new("HEAD")
+    expect(described_class.new("1.2.3")).to be < described_class.new("HEAD-fedcba")
+    expect(described_class.new("HEAD-abcdef")).to eq described_class.new("HEAD-fedcba")
+    expect(described_class.new("HEAD")).to eq described_class.new("HEAD-fedcba")
   end
 
   specify "comparing alpha versions" do
-    expect(described_class.create("1.2.3alpha")).to be < described_class.create("1.2.3")
-    expect(described_class.create("1.2.3")).to be < described_class.create("1.2.3a")
-    expect(described_class.create("1.2.3alpha4")).to be == described_class.create("1.2.3a4")
-    expect(described_class.create("1.2.3alpha4")).to be == described_class.create("1.2.3A4")
-    expect(described_class.create("1.2.3alpha4")).to be > described_class.create("1.2.3alpha3")
-    expect(described_class.create("1.2.3alpha4")).to be < described_class.create("1.2.3alpha5")
-    expect(described_class.create("1.2.3alpha4")).to be < described_class.create("1.2.3alpha10")
+    expect(described_class.new("1.2.3alpha")).to be < described_class.new("1.2.3")
+    expect(described_class.new("1.2.3")).to be < described_class.new("1.2.3a")
+    expect(described_class.new("1.2.3alpha4")).to eq described_class.new("1.2.3a4")
+    expect(described_class.new("1.2.3alpha4")).to eq described_class.new("1.2.3A4")
+    expect(described_class.new("1.2.3alpha4")).to be > described_class.new("1.2.3alpha3")
+    expect(described_class.new("1.2.3alpha4")).to be < described_class.new("1.2.3alpha5")
+    expect(described_class.new("1.2.3alpha4")).to be < described_class.new("1.2.3alpha10")
 
-    expect(described_class.create("1.2.3alpha4")).to be < described_class.create("1.2.3beta2")
-    expect(described_class.create("1.2.3alpha4")).to be < described_class.create("1.2.3rc3")
-    expect(described_class.create("1.2.3alpha4")).to be < described_class.create("1.2.3")
-    expect(described_class.create("1.2.3alpha4")).to be < described_class.create("1.2.3-p34")
+    expect(described_class.new("1.2.3alpha4")).to be < described_class.new("1.2.3beta2")
+    expect(described_class.new("1.2.3alpha4")).to be < described_class.new("1.2.3rc3")
+    expect(described_class.new("1.2.3alpha4")).to be < described_class.new("1.2.3")
+    expect(described_class.new("1.2.3alpha4")).to be < described_class.new("1.2.3-p34")
   end
 
   specify "comparing beta versions" do
-    expect(described_class.create("1.2.3beta2")).to be == described_class.create("1.2.3b2")
-    expect(described_class.create("1.2.3beta2")).to be == described_class.create("1.2.3B2")
-    expect(described_class.create("1.2.3beta2")).to be > described_class.create("1.2.3beta1")
-    expect(described_class.create("1.2.3beta2")).to be < described_class.create("1.2.3beta3")
-    expect(described_class.create("1.2.3beta2")).to be < described_class.create("1.2.3beta10")
+    expect(described_class.new("1.2.3beta2")).to eq described_class.new("1.2.3b2")
+    expect(described_class.new("1.2.3beta2")).to eq described_class.new("1.2.3B2")
+    expect(described_class.new("1.2.3beta2")).to be > described_class.new("1.2.3beta1")
+    expect(described_class.new("1.2.3beta2")).to be < described_class.new("1.2.3beta3")
+    expect(described_class.new("1.2.3beta2")).to be < described_class.new("1.2.3beta10")
 
-    expect(described_class.create("1.2.3beta2")).to be > described_class.create("1.2.3alpha4")
-    expect(described_class.create("1.2.3beta2")).to be < described_class.create("1.2.3rc3")
-    expect(described_class.create("1.2.3beta2")).to be < described_class.create("1.2.3")
-    expect(described_class.create("1.2.3beta2")).to be < described_class.create("1.2.3-p34")
+    expect(described_class.new("1.2.3beta2")).to be > described_class.new("1.2.3alpha4")
+    expect(described_class.new("1.2.3beta2")).to be < described_class.new("1.2.3rc3")
+    expect(described_class.new("1.2.3beta2")).to be < described_class.new("1.2.3")
+    expect(described_class.new("1.2.3beta2")).to be < described_class.new("1.2.3-p34")
   end
 
   specify "comparing pre versions" do
-    expect(described_class.create("1.2.3pre9")).to be == described_class.create("1.2.3PRE9")
-    expect(described_class.create("1.2.3pre9")).to be > described_class.create("1.2.3pre8")
-    expect(described_class.create("1.2.3pre8")).to be < described_class.create("1.2.3pre9")
-    expect(described_class.create("1.2.3pre9")).to be < described_class.create("1.2.3pre10")
+    expect(described_class.new("1.2.3pre9")).to eq described_class.new("1.2.3PRE9")
+    expect(described_class.new("1.2.3pre9")).to be > described_class.new("1.2.3pre8")
+    expect(described_class.new("1.2.3pre8")).to be < described_class.new("1.2.3pre9")
+    expect(described_class.new("1.2.3pre9")).to be < described_class.new("1.2.3pre10")
 
-    expect(described_class.create("1.2.3pre3")).to be > described_class.create("1.2.3alpha2")
-    expect(described_class.create("1.2.3pre3")).to be > described_class.create("1.2.3alpha4")
-    expect(described_class.create("1.2.3pre3")).to be > described_class.create("1.2.3beta3")
-    expect(described_class.create("1.2.3pre3")).to be > described_class.create("1.2.3beta5")
-    expect(described_class.create("1.2.3pre3")).to be < described_class.create("1.2.3rc2")
-    expect(described_class.create("1.2.3pre3")).to be < described_class.create("1.2.3")
-    expect(described_class.create("1.2.3pre3")).to be < described_class.create("1.2.3-p2")
+    expect(described_class.new("1.2.3pre3")).to be > described_class.new("1.2.3alpha2")
+    expect(described_class.new("1.2.3pre3")).to be > described_class.new("1.2.3alpha4")
+    expect(described_class.new("1.2.3pre3")).to be > described_class.new("1.2.3beta3")
+    expect(described_class.new("1.2.3pre3")).to be > described_class.new("1.2.3beta5")
+    expect(described_class.new("1.2.3pre3")).to be < described_class.new("1.2.3rc2")
+    expect(described_class.new("1.2.3pre3")).to be < described_class.new("1.2.3")
+    expect(described_class.new("1.2.3pre3")).to be < described_class.new("1.2.3-p2")
   end
 
   specify "comparing RC versions" do
-    expect(described_class.create("1.2.3rc3")).to be == described_class.create("1.2.3RC3")
-    expect(described_class.create("1.2.3rc3")).to be > described_class.create("1.2.3rc2")
-    expect(described_class.create("1.2.3rc3")).to be < described_class.create("1.2.3rc4")
-    expect(described_class.create("1.2.3rc3")).to be < described_class.create("1.2.3rc10")
+    expect(described_class.new("1.2.3rc3")).to eq described_class.new("1.2.3RC3")
+    expect(described_class.new("1.2.3rc3")).to be > described_class.new("1.2.3rc2")
+    expect(described_class.new("1.2.3rc3")).to be < described_class.new("1.2.3rc4")
+    expect(described_class.new("1.2.3rc3")).to be < described_class.new("1.2.3rc10")
 
-    expect(described_class.create("1.2.3rc3")).to be > described_class.create("1.2.3alpha4")
-    expect(described_class.create("1.2.3rc3")).to be > described_class.create("1.2.3beta2")
-    expect(described_class.create("1.2.3rc3")).to be < described_class.create("1.2.3")
-    expect(described_class.create("1.2.3rc3")).to be < described_class.create("1.2.3-p34")
+    expect(described_class.new("1.2.3rc3")).to be > described_class.new("1.2.3alpha4")
+    expect(described_class.new("1.2.3rc3")).to be > described_class.new("1.2.3beta2")
+    expect(described_class.new("1.2.3rc3")).to be < described_class.new("1.2.3")
+    expect(described_class.new("1.2.3rc3")).to be < described_class.new("1.2.3-p34")
   end
 
   specify "comparing patch-level versions" do
-    expect(described_class.create("1.2.3-p34")).to be == described_class.create("1.2.3-P34")
-    expect(described_class.create("1.2.3-p34")).to be > described_class.create("1.2.3-p33")
-    expect(described_class.create("1.2.3-p34")).to be < described_class.create("1.2.3-p35")
-    expect(described_class.create("1.2.3-p34")).to be > described_class.create("1.2.3-p9")
+    expect(described_class.new("1.2.3-p34")).to eq described_class.new("1.2.3-P34")
+    expect(described_class.new("1.2.3-p34")).to be > described_class.new("1.2.3-p33")
+    expect(described_class.new("1.2.3-p34")).to be < described_class.new("1.2.3-p35")
+    expect(described_class.new("1.2.3-p34")).to be > described_class.new("1.2.3-p9")
 
-    expect(described_class.create("1.2.3-p34")).to be > described_class.create("1.2.3alpha4")
-    expect(described_class.create("1.2.3-p34")).to be > described_class.create("1.2.3beta2")
-    expect(described_class.create("1.2.3-p34")).to be > described_class.create("1.2.3rc3")
-    expect(described_class.create("1.2.3-p34")).to be > described_class.create("1.2.3")
+    expect(described_class.new("1.2.3-p34")).to be > described_class.new("1.2.3alpha4")
+    expect(described_class.new("1.2.3-p34")).to be > described_class.new("1.2.3beta2")
+    expect(described_class.new("1.2.3-p34")).to be > described_class.new("1.2.3rc3")
+    expect(described_class.new("1.2.3-p34")).to be > described_class.new("1.2.3")
   end
 
   specify "comparing post-level versions" do
-    expect(described_class.create("1.2.3.post34")).to be > described_class.create("1.2.3.post33")
-    expect(described_class.create("1.2.3.post34")).to be < described_class.create("1.2.3.post35")
+    expect(described_class.new("1.2.3.post34")).to be > described_class.new("1.2.3.post33")
+    expect(described_class.new("1.2.3.post34")).to be < described_class.new("1.2.3.post35")
 
-    expect(described_class.create("1.2.3.post34")).to be > described_class.create("1.2.3rc35")
-    expect(described_class.create("1.2.3.post34")).to be > described_class.create("1.2.3alpha35")
-    expect(described_class.create("1.2.3.post34")).to be > described_class.create("1.2.3beta35")
-    expect(described_class.create("1.2.3.post34")).to be > described_class.create("1.2.3")
+    expect(described_class.new("1.2.3.post34")).to be > described_class.new("1.2.3rc35")
+    expect(described_class.new("1.2.3.post34")).to be > described_class.new("1.2.3alpha35")
+    expect(described_class.new("1.2.3.post34")).to be > described_class.new("1.2.3beta35")
+    expect(described_class.new("1.2.3.post34")).to be > described_class.new("1.2.3")
   end
 
   specify "comparing unevenly-padded versions" do
-    expect(described_class.create("2.1.0-p194")).to be < described_class.create("2.1-p195")
-    expect(described_class.create("2.1-p195")).to be > described_class.create("2.1.0-p194")
-    expect(described_class.create("2.1-p194")).to be < described_class.create("2.1.0-p195")
-    expect(described_class.create("2.1.0-p195")).to be > described_class.create("2.1-p194")
-    expect(described_class.create("2-p194")).to be < described_class.create("2.1-p195")
+    expect(described_class.new("2.1.0-p194")).to be < described_class.new("2.1-p195")
+    expect(described_class.new("2.1-p195")).to be > described_class.new("2.1.0-p194")
+    expect(described_class.new("2.1-p194")).to be < described_class.new("2.1.0-p195")
+    expect(described_class.new("2.1.0-p195")).to be > described_class.new("2.1-p194")
+    expect(described_class.new("2-p194")).to be < described_class.new("2.1-p195")
   end
 
   it "can be compared against nil" do
-    expect(described_class.create("2.1.0-p194")).to be > nil
+    expect(described_class.new("2.1.0-p194")).to be > nil
   end
 
   it "can be compared against Version::NULL" do
-    expect(described_class.create("2.1.0-p194")).to be > Version::NULL
+    expect(described_class.new("2.1.0-p194")).to be > Version::NULL
   end
 
   it "can be compared against strings" do
-    expect(described_class.create("2.1.0-p194")).to be == "2.1.0-p194"
-    expect(described_class.create("1")).to be == 1
+    expect(described_class.new("2.1.0-p194")).to eq "2.1.0-p194"
+    expect(described_class.new("1")).to eq 1
   end
 
   it "can be compared against tokens" do
-    expect(described_class.create("2.1.0-p194")).to be > Version::Token.create("2")
-    expect(described_class.create("1")).to be == Version::Token.create("1")
+    expect(described_class.new("2.1.0-p194")).to be > Version::Token.create("2")
+    expect(described_class.new("1")).to eq Version::Token.create("1")
   end
 
   it "can be compared against Version::NULL_TOKEN" do
-    expect(described_class.create("2.1.0-p194")).to be > Version::NULL_TOKEN
+    expect(described_class.new("2.1.0-p194")).to be > Version::NULL_TOKEN
   end
 
   specify "comparison returns nil for non-version" do
-    v = described_class.create("1.0")
+    v = described_class.new("1.0")
     expect(v <=> Object.new).to be_nil
     expect { v > Object.new }.to raise_error(ArgumentError)
   end
@@ -218,23 +294,13 @@
   specify "erlang versions" do
     versions = %w[R16B R15B03-1 R15B03 R15B02 R15B01 R14B04 R14B03
                   R14B02 R14B01 R14B R13B04 R13B03 R13B02-1].reverse
-    expect(versions.sort_by { |v| described_class.create(v) }).to eq(versions)
-  end
-
-  describe "#empty?" do
-    it "returns true if version is empty" do
-      expect(described_class.create("").empty?).to be(true)
-    end
-
-    it "returns false if version is not empty" do
-      expect(described_class.create("1.2.3").empty?).to be(false)
-    end
+    expect(versions.sort_by { |v| described_class.new(v) }).to eq(versions)
   end
 
   specify "hash equality" do
-    v1 = described_class.create("0.1.0")
-    v2 = described_class.create("0.1.0")
-    v3 = described_class.create("0.1.1")
+    v1 = described_class.new("0.1.0")
+    v2 = described_class.new("0.1.0")
+    v3 = described_class.new("0.1.1")
 
     expect(v1).to eql(v2)
     expect(v1).not_to eql(v3)
@@ -245,32 +311,27 @@
     expect(h[v2]).to eq(:foo)
   end
 
-  describe "::create" do
-    it "accepts objects responding to #to_str" do
-      value = double(to_str: "0.1")
-      expect(described_class.create(value).to_s).to eq("0.1")
-    end
-
+  describe "::new" do
     it "raises a TypeError for non-string objects" do
-      expect { described_class.create(1.1) }.to raise_error(TypeError)
-      expect { described_class.create(1) }.to raise_error(TypeError)
-      expect { described_class.create(:symbol) }.to raise_error(TypeError)
+      expect { described_class.new(1.1) }.to raise_error(TypeError)
+      expect { described_class.new(1) }.to raise_error(TypeError)
+      expect { described_class.new(:symbol) }.to raise_error(TypeError)
     end
 
     it "parses a version from a string" do
-      v = described_class.create("1.20")
+      v = described_class.new("1.20")
       expect(v).not_to be_head
       expect(v.to_str).to eq("1.20")
     end
 
     specify "HEAD with commit" do
-      v = described_class.create("HEAD-abcdef")
+      v = described_class.new("HEAD-abcdef")
       expect(v.commit).to eq("abcdef")
       expect(v.to_str).to eq("HEAD-abcdef")
     end
 
     specify "HEAD without commit" do
-      v = described_class.create("HEAD")
+      v = described_class.new("HEAD")
       expect(v.commit).to be_nil
       expect(v.to_str).to eq("HEAD")
     end
@@ -290,16 +351,16 @@
   end
 
   specify "#head?" do
-    v1 = described_class.create("HEAD-abcdef")
-    v2 = described_class.create("HEAD")
+    v1 = described_class.new("HEAD-abcdef")
+    v2 = described_class.new("HEAD")
 
     expect(v1).to be_head
     expect(v2).to be_head
   end
 
   specify "#update_commit" do
-    v1 = described_class.create("HEAD-abcdef")
-    v2 = described_class.create("HEAD")
+    v1 = described_class.new("HEAD-abcdef")
+    v2 = described_class.new("HEAD")
 
     v1.update_commit("ffffff")
     expect(v1.commit).to eq("ffffff")
@@ -312,71 +373,71 @@
 
   describe "#major" do
     it "returns major version token" do
-      expect(described_class.create("1").major).to be == Version::Token.create("1")
-      expect(described_class.create("1.2").major).to be == Version::Token.create("1")
-      expect(described_class.create("1.2.3").major).to be == Version::Token.create("1")
-      expect(described_class.create("1.2.3alpha").major).to be == Version::Token.create("1")
-      expect(described_class.create("1.2.3alpha4").major).to be == Version::Token.create("1")
-      expect(described_class.create("1.2.3beta4").major).to be == Version::Token.create("1")
-      expect(described_class.create("1.2.3pre4").major).to be == Version::Token.create("1")
-      expect(described_class.create("1.2.3rc4").major).to be == Version::Token.create("1")
-      expect(described_class.create("1.2.3-p4").major).to be == Version::Token.create("1")
+      expect(described_class.new("1").major).to eq Version::Token.create("1")
+      expect(described_class.new("1.2").major).to eq Version::Token.create("1")
+      expect(described_class.new("1.2.3").major).to eq Version::Token.create("1")
+      expect(described_class.new("1.2.3alpha").major).to eq Version::Token.create("1")
+      expect(described_class.new("1.2.3alpha4").major).to eq Version::Token.create("1")
+      expect(described_class.new("1.2.3beta4").major).to eq Version::Token.create("1")
+      expect(described_class.new("1.2.3pre4").major).to eq Version::Token.create("1")
+      expect(described_class.new("1.2.3rc4").major).to eq Version::Token.create("1")
+      expect(described_class.new("1.2.3-p4").major).to eq Version::Token.create("1")
     end
   end
 
   describe "#minor" do
     it "returns minor version token" do
-      expect(described_class.create("1").minor).to be_nil
-      expect(described_class.create("1.2").minor).to be == Version::Token.create("2")
-      expect(described_class.create("1.2.3").minor).to be == Version::Token.create("2")
-      expect(described_class.create("1.2.3alpha").minor).to be == Version::Token.create("2")
-      expect(described_class.create("1.2.3alpha4").minor).to be == Version::Token.create("2")
-      expect(described_class.create("1.2.3beta4").minor).to be == Version::Token.create("2")
-      expect(described_class.create("1.2.3pre4").minor).to be == Version::Token.create("2")
-      expect(described_class.create("1.2.3rc4").minor).to be == Version::Token.create("2")
-      expect(described_class.create("1.2.3-p4").minor).to be == Version::Token.create("2")
+      expect(described_class.new("1").minor).to be_nil
+      expect(described_class.new("1.2").minor).to eq Version::Token.create("2")
+      expect(described_class.new("1.2.3").minor).to eq Version::Token.create("2")
+      expect(described_class.new("1.2.3alpha").minor).to eq Version::Token.create("2")
+      expect(described_class.new("1.2.3alpha4").minor).to eq Version::Token.create("2")
+      expect(described_class.new("1.2.3beta4").minor).to eq Version::Token.create("2")
+      expect(described_class.new("1.2.3pre4").minor).to eq Version::Token.create("2")
+      expect(described_class.new("1.2.3rc4").minor).to eq Version::Token.create("2")
+      expect(described_class.new("1.2.3-p4").minor).to eq Version::Token.create("2")
     end
   end
 
   describe "#patch" do
     it "returns patch version token" do
-      expect(described_class.create("1").patch).to be_nil
-      expect(described_class.create("1.2").patch).to be_nil
-      expect(described_class.create("1.2.3").patch).to be == Version::Token.create("3")
-      expect(described_class.create("1.2.3alpha").patch).to be == Version::Token.create("3")
-      expect(described_class.create("1.2.3alpha4").patch).to be == Version::Token.create("3")
-      expect(described_class.create("1.2.3beta4").patch).to be == Version::Token.create("3")
-      expect(described_class.create("1.2.3pre4").patch).to be == Version::Token.create("3")
-      expect(described_class.create("1.2.3rc4").patch).to be == Version::Token.create("3")
-      expect(described_class.create("1.2.3-p4").patch).to be == Version::Token.create("3")
+      expect(described_class.new("1").patch).to be_nil
+      expect(described_class.new("1.2").patch).to be_nil
+      expect(described_class.new("1.2.3").patch).to eq Version::Token.create("3")
+      expect(described_class.new("1.2.3alpha").patch).to eq Version::Token.create("3")
+      expect(described_class.new("1.2.3alpha4").patch).to eq Version::Token.create("3")
+      expect(described_class.new("1.2.3beta4").patch).to eq Version::Token.create("3")
+      expect(described_class.new("1.2.3pre4").patch).to eq Version::Token.create("3")
+      expect(described_class.new("1.2.3rc4").patch).to eq Version::Token.create("3")
+      expect(described_class.new("1.2.3-p4").patch).to eq Version::Token.create("3")
     end
   end
 
   describe "#major_minor" do
     it "returns major.minor version" do
-      expect(described_class.create("1").major_minor).to be == described_class.create("1")
-      expect(described_class.create("1.2").major_minor).to be == described_class.create("1.2")
-      expect(described_class.create("1.2.3").major_minor).to be == described_class.create("1.2")
-      expect(described_class.create("1.2.3alpha").major_minor).to be == described_class.create("1.2")
-      expect(described_class.create("1.2.3alpha4").major_minor).to be == described_class.create("1.2")
-      expect(described_class.create("1.2.3beta4").major_minor).to be == described_class.create("1.2")
-      expect(described_class.create("1.2.3pre4").major_minor).to be == described_class.create("1.2")
-      expect(described_class.create("1.2.3rc4").major_minor).to be == described_class.create("1.2")
-      expect(described_class.create("1.2.3-p4").major_minor).to be == described_class.create("1.2")
+      expect(described_class.new("1").major_minor).to eq described_class.new("1")
+      expect(described_class.new("1.2").major_minor).to eq described_class.new("1.2")
+      expect(described_class.new("1.2.3").major_minor).to eq described_class.new("1.2")
+      expect(described_class.new("1.2.3alpha").major_minor).to eq described_class.new("1.2")
+      expect(described_class.new("1.2.3alpha4").major_minor).to eq described_class.new("1.2")
+      expect(described_class.new("1.2.3beta4").major_minor).to eq described_class.new("1.2")
+      expect(described_class.new("1.2.3pre4").major_minor).to eq described_class.new("1.2")
+      expect(described_class.new("1.2.3rc4").major_minor).to eq described_class.new("1.2")
+      expect(described_class.new("1.2.3-p4").major_minor).to eq described_class.new("1.2")
     end
   end
 
   describe "#major_minor_patch" do
     it "returns major.minor.patch version" do
-      expect(described_class.create("1").major_minor_patch).to be == described_class.create("1")
-      expect(described_class.create("1.2").major_minor_patch).to be == described_class.create("1.2")
-      expect(described_class.create("1.2.3").major_minor_patch).to be == described_class.create("1.2.3")
-      expect(described_class.create("1.2.3alpha").major_minor_patch).to be == described_class.create("1.2.3")
-      expect(described_class.create("1.2.3alpha4").major_minor_patch).to be == described_class.create("1.2.3")
-      expect(described_class.create("1.2.3beta4").major_minor_patch).to be == described_class.create("1.2.3")
-      expect(described_class.create("1.2.3pre4").major_minor_patch).to be == described_class.create("1.2.3")
-      expect(described_class.create("1.2.3rc4").major_minor_patch).to be == described_class.create("1.2.3")
-      expect(described_class.create("1.2.3-p4").major_minor_patch).to be == described_class.create("1.2.3")
+      expect(described_class.new("1").major_minor_patch).to eq described_class.new("1")
+      expect(described_class.new("1.2").major_minor_patch).to eq described_class.new("1.2")
+      expect(described_class.new("1.2.3").major_minor_patch).to eq described_class.new("1.2.3")
+      expect(described_class.new("1.2.3alpha").major_minor_patch).to eq described_class.new("1.2.3")
+      expect(described_class.new("1.2.3alpha4").major_minor_patch).to eq described_class.new("1.2.3")
+      expect(described_class.new("1.2.3beta4").major_minor_patch).to eq described_class.new("1.2.3")
+      expect(described_class.new("1.2.3pre4").major_minor_patch).to eq described_class.new("1.2.3")
+      expect(described_class.new("1.2.3rc4").major_minor_patch).to eq described_class.new("1.2.3")
+      expect(described_class.new("1.2.3-p4").major_minor_patch).to eq described_class.new("1.2.3")
     end
   end
 
@@ -404,52 +465,52 @@
     end
 
     specify "version all dots" do
-      expect(described_class.create("1.14"))
+      expect(described_class.new("1.14"))
         .to be_detected_from("https://brew.sh/foo.bar.la.1.14.zip")
     end
 
     specify "version underscore separator" do
-      expect(described_class.create("1.1"))
+      expect(described_class.new("1.1"))
         .to be_detected_from("https://brew.sh/grc_1.1.tar.gz")
     end
 
     specify "boost version style" do
-      expect(described_class.create("1.39.0"))
+      expect(described_class.new("1.39.0"))
         .to be_detected_from("https://brew.sh/boost_1_39_0.tar.bz2")
     end
 
     specify "erlang version style" do
-      expect(described_class.create("R13B"))
+      expect(described_class.new("R13B"))
         .to be_detected_from("https://erlang.org/download/otp_src_R13B.tar.gz")
     end
 
     specify "another erlang version style" do
-      expect(described_class.create("R15B01"))
+      expect(described_class.new("R15B01"))
         .to be_detected_from("https://github.com/erlang/otp/tarball/OTP_R15B01")
     end
 
     specify "yet another erlang version style" do
-      expect(described_class.create("R15B03-1"))
+      expect(described_class.new("R15B03-1"))
         .to be_detected_from("https://github.com/erlang/otp/tarball/OTP_R15B03-1")
     end
 
     specify "p7zip version style" do
-      expect(described_class.create("9.04"))
+      expect(described_class.new("9.04"))
         .to be_detected_from("https://kent.dl.sourceforge.net/sourceforge/p7zip/p7zip_9.04_src_all.tar.bz2")
     end
 
     specify "new github style" do
-      expect(described_class.create("1.1.4"))
+      expect(described_class.new("1.1.4"))
         .to be_detected_from("https://github.com/sam-github/libnet/tarball/libnet-1.1.4")
     end
 
     specify "codeload style" do
-      expect(described_class.create("0.7.1"))
+      expect(described_class.new("0.7.1"))
         .to be_detected_from("https://codeload.github.com/gsamokovarov/jump/tar.gz/v0.7.1")
     end
 
     specify "elasticsearch alpha style" do
-      expect(described_class.create("5.0.0-alpha5"))
+      expect(described_class.new("5.0.0-alpha5"))
         .to be_detected_from(
           "https://download.elastic.co/elasticsearch/release/org/elasticsearch" \
           "/distribution/tar/elasticsearch/5.0.0-alpha5/elasticsearch-5.0.0-alpha5.tar.gz",
@@ -457,312 +518,319 @@
     end
 
     specify "gloox beta style" do
-      expect(described_class.create("1.0-beta7"))
+      expect(described_class.new("1.0-beta7"))
         .to be_detected_from("https://camaya.net/download/gloox-1.0-beta7.tar.bz2")
     end
 
     specify "sphinx beta style" do
-      expect(described_class.create("1.10-beta"))
+      expect(described_class.new("1.10-beta"))
         .to be_detected_from("http://sphinxsearch.com/downloads/sphinx-1.10-beta.tar.gz")
     end
 
     specify "astyle version style" do
-      expect(described_class.create("1.23"))
+      expect(described_class.new("1.23"))
         .to be_detected_from("https://kent.dl.sourceforge.net/sourceforge/astyle/astyle_1.23_macosx.tar.gz")
     end
 
     specify "version dos2unix" do
-      expect(described_class.create("3.1"))
+      expect(described_class.new("3.1"))
         .to be_detected_from("http://www.sfr-fresh.com/linux/misc/dos2unix-3.1.tar.gz")
     end
 
     specify "version internal dash" do
-      expect(described_class.create("1.1-2"))
+      expect(described_class.new("1.1-2"))
         .to be_detected_from("https://brew.sh/foo-arse-1.1-2.tar.gz")
-      expect(described_class.create("3.3.04-1"))
+      expect(described_class.new("3.3.04-1"))
         .to be_detected_from("https://brew.sh/3.3.04-1.tar.gz")
-      expect(described_class.create("1.2-20200102"))
+      expect(described_class.new("1.2-20200102"))
         .to be_detected_from("https://brew.sh/v1.2-20200102.tar.gz")
-      expect(described_class.create("3.6.6-0.2"))
+      expect(described_class.new("3.6.6-0.2"))
         .to be_detected_from("https://brew.sh/v3.6.6-0.2.tar.gz")
     end
 
     specify "version single digit" do
-      expect(described_class.create("45"))
+      expect(described_class.new("45"))
         .to be_detected_from("https://brew.sh/foo_bar.45.tar.gz")
     end
 
     specify "noseparator single digit" do
-      expect(described_class.create("45"))
+      expect(described_class.new("45"))
         .to be_detected_from("https://brew.sh/foo_bar45.tar.gz")
     end
 
     specify "version developer that hates us format" do
-      expect(described_class.create("1.2.3"))
+      expect(described_class.new("1.2.3"))
         .to be_detected_from("https://brew.sh/foo-bar-la.1.2.3.tar.gz")
     end
 
     specify "version regular" do
-      expect(described_class.create("1.21"))
+      expect(described_class.new("1.21"))
         .to be_detected_from("https://brew.sh/foo_bar-1.21.tar.gz")
     end
 
     specify "version sourceforge download" do
-      expect(described_class.create("1.21"))
+      expect(described_class.new("1.21"))
         .to be_detected_from("https://sourceforge.net/foo_bar-1.21.tar.gz/download")
-      expect(described_class.create("1.21"))
+      expect(described_class.new("1.21"))
         .to be_detected_from("https://sf.net/foo_bar-1.21.tar.gz/download")
     end
 
     specify "version github" do
-      expect(described_class.create("1.0.5"))
+      expect(described_class.new("1.0.5"))
         .to be_detected_from("https://github.com/lloyd/yajl/tarball/1.0.5")
     end
 
     specify "version github with high patch number" do
-      expect(described_class.create("1.2.34"))
+      expect(described_class.new("1.2.34"))
         .to be_detected_from("https://github.com/lloyd/yajl/tarball/v1.2.34")
     end
 
     specify "yet another version" do
-      expect(described_class.create("0.15.1b"))
+      expect(described_class.new("0.15.1b"))
         .to be_detected_from("https://brew.sh/mad-0.15.1b.tar.gz")
     end
 
     specify "lame version style" do
-      expect(described_class.create("398-2"))
+      expect(described_class.new("398-2"))
         .to be_detected_from("https://kent.dl.sourceforge.net/sourceforge/lame/lame-398-2.tar.gz")
     end
 
     specify "ruby version style" do
-      expect(described_class.create("1.9.1-p243"))
+      expect(described_class.new("1.9.1-p243"))
         .to be_detected_from("ftp://ftp.ruby-lang.org/pub/ruby/1.9/ruby-1.9.1-p243.tar.gz")
     end
 
     specify "omega version style" do
-      expect(described_class.create("0.80.2"))
+      expect(described_class.new("0.80.2"))
         .to be_detected_from("http://www.alcyone.com/binaries/omega/omega-0.80.2-src.tar.gz")
     end
 
     specify "rc style" do
-      expect(described_class.create("1.2.2rc1"))
+      expect(described_class.new("1.2.2rc1"))
         .to be_detected_from("https://downloads.xiph.org/releases/vorbis/libvorbis-1.2.2rc1.tar.bz2")
     end
 
     specify "dash rc style" do
-      expect(described_class.create("1.8.0-rc1"))
+      expect(described_class.new("1.8.0-rc1"))
         .to be_detected_from("https://ftp.mozilla.org/pub/mozilla.org/js/js-1.8.0-rc1.tar.gz")
     end
 
     specify "angband version style" do
-      expect(described_class.create("3.0.9b"))
+      expect(described_class.new("3.0.9b"))
         .to be_detected_from("http://rephial.org/downloads/3.0/angband-3.0.9b-src.tar.gz")
     end
 
     specify "stable suffix" do
-      expect(described_class.create("1.4.14b"))
+      expect(described_class.new("1.4.14b"))
         .to be_detected_from("https://www.monkey.org/~provos/libevent-1.4.14b-stable.tar.gz")
     end
 
-    specify "debian style 1" do
-      expect(described_class.create("3.03"))
+    specify "debian style" do
+      expect(described_class.new("3.03"))
         .to be_detected_from("https://ftp.de.debian.org/debian/pool/main/s/sl/sl_3.03.orig.tar.gz")
     end
 
-    specify "debian style 2" do
-      expect(described_class.create("1.01b"))
+    specify "debian style with letter suffix" do
+      expect(described_class.new("1.01b"))
         .to be_detected_from("https://ftp.de.debian.org/debian/pool/main/m/mmv/mmv_1.01b.orig.tar.gz")
     end
 
+    specify "debian style dotless" do
+      expect(described_class.new("1"))
+        .to be_detected_from("https://deb.debian.org/debian/pool/main/e/example/example_1.orig.tar.gz")
+      expect(described_class.new("20040914"))
+        .to be_detected_from("https://deb.debian.org/debian/pool/main/e/example/example_20040914.orig.tar.gz")
+    end
+
     specify "bottle style" do
-      expect(described_class.create("4.8.0"))
+      expect(described_class.new("4.8.0"))
         .to be_detected_from("https://homebrew.bintray.com/bottles/qt-4.8.0.lion.bottle.tar.gz")
     end
 
     specify "versioned bottle style" do
-      expect(described_class.create("4.8.1"))
+      expect(described_class.new("4.8.1"))
         .to be_detected_from("https://homebrew.bintray.com/bottles/qt-4.8.1.lion.bottle.1.tar.gz")
     end
 
     specify "erlang bottle style" do
-      expect(described_class.create("R15B"))
+      expect(described_class.new("R15B"))
         .to be_detected_from("https://homebrew.bintray.com/bottles/erlang-R15B.lion.bottle.tar.gz")
     end
 
     specify "another erlang bottle style" do
-      expect(described_class.create("R15B01"))
+      expect(described_class.new("R15B01"))
         .to be_detected_from("https://homebrew.bintray.com/bottles/erlang-R15B01.mountain_lion.bottle.tar.gz")
     end
 
     specify "yet another erlang bottle style" do
-      expect(described_class.create("R15B03-1"))
+      expect(described_class.new("R15B03-1"))
         .to be_detected_from("https://homebrew.bintray.com/bottles/erlang-R15B03-1.mountainlion.bottle.tar.gz")
     end
 
     specify "imagemagick style" do
-      expect(described_class.create("6.7.5-7"))
+      expect(described_class.new("6.7.5-7"))
         .to be_detected_from("https://downloads.sf.net/project/machomebrew/mirror/ImageMagick-6.7.5-7.tar.bz2")
     end
 
     specify "imagemagick bottle style" do
-      expect(described_class.create("6.7.5-7"))
+      expect(described_class.new("6.7.5-7"))
         .to be_detected_from("https://homebrew.bintray.com/bottles/imagemagick-6.7.5-7.lion.bottle.tar.gz")
     end
 
     specify "imagemagick versioned bottle style" do
-      expect(described_class.create("6.7.5-7"))
+      expect(described_class.new("6.7.5-7"))
         .to be_detected_from("https://homebrew.bintray.com/bottles/imagemagick-6.7.5-7.lion.bottle.1.tar.gz")
     end
 
     specify "date-based version style" do
-      expect(described_class.create("2017-04-17"))
+      expect(described_class.new("2017-04-17"))
         .to be_detected_from("https://brew.sh/dada-v2017-04-17.tar.gz")
     end
 
     specify "unstable version style" do
-      expect(described_class.create("1.3.0-beta.1"))
+      expect(described_class.new("1.3.0-beta.1"))
         .to be_detected_from("https://registry.npmjs.org/@angular/cli/-/cli-1.3.0-beta.1.tgz")
-      expect(described_class.create("2.074.0-beta1"))
+      expect(described_class.new("2.074.0-beta1"))
         .to be_detected_from("https://github.com/dlang/dmd/archive/v2.074.0-beta1.tar.gz")
-      expect(described_class.create("2.074.0-rc1"))
+      expect(described_class.new("2.074.0-rc1"))
         .to be_detected_from("https://github.com/dlang/dmd/archive/v2.074.0-rc1.tar.gz")
-      expect(described_class.create("5.0.0-alpha10"))
+      expect(described_class.new("5.0.0-alpha10"))
         .to be_detected_from(
           "https://github.com/premake/premake-core/releases/download/v5.0.0-alpha10/premake-5.0.0-alpha10-src.zip",
         )
     end
 
     specify "jenkins version style" do
-      expect(described_class.create("1.486"))
+      expect(described_class.new("1.486"))
         .to be_detected_from("https://mirrors.jenkins-ci.org/war/1.486/jenkins.war")
-      expect(described_class.create("0.10.11"))
+      expect(described_class.new("0.10.11"))
         .to be_detected_from("https://github.com/hechoendrupal/DrupalConsole/releases/download/0.10.11/drupal.phar")
     end
 
     specify "char prefixed, url-only version style" do
-      expect(described_class.create("1.9.293"))
+      expect(described_class.new("1.9.293"))
         .to be_detected_from("https://github.com/clojure/clojurescript/releases/download/r1.9.293/cljs.jar")
-      expect(described_class.create("0.6.1"))
+      expect(described_class.new("0.6.1"))
         .to be_detected_from("https://github.com/fibjs/fibjs/releases/download/v0.6.1/fullsrc.zip")
-      expect(described_class.create("1.9"))
+      expect(described_class.new("1.9"))
         .to be_detected_from("https://wwwlehre.dhbw-stuttgart.de/~sschulz/WORK/E_DOWNLOAD/V_1.9/E.tgz")
     end
 
     specify "w.x.y.z url-only version style" do
-      expect(described_class.create("2.3.2.0"))
+      expect(described_class.new("2.3.2.0"))
         .to be_detected_from("https://github.com/JustArchi/ArchiSteamFarm/releases/download/2.3.2.0/ASF.zip")
-      expect(described_class.create("1.7.5.2"))
+      expect(described_class.new("1.7.5.2"))
         .to be_detected_from("https://people.gnome.org/~newren/eg/download/1.7.5.2/eg")
     end
 
     specify "dash version style" do
-      expect(described_class.create("3.4"))
+      expect(described_class.new("3.4"))
         .to be_detected_from("https://www.antlr.org/download/antlr-3.4-complete.jar")
-      expect(described_class.create("9.2"))
+      expect(described_class.new("9.2"))
         .to be_detected_from("https://cdn.nuxeo.com/nuxeo-9.2/nuxeo-server-9.2-tomcat.zip")
-      expect(described_class.create("0.181"))
+      expect(described_class.new("0.181"))
         .to be_detected_from(
           "https://search.maven.org/remotecontent?filepath=" \
           "com/facebook/presto/presto-cli/0.181/presto-cli-0.181-executable.jar",
         )
-      expect(described_class.create("1.2.3"))
+      expect(described_class.new("1.2.3"))
         .to be_detected_from(
           "https://search.maven.org/remotecontent?filepath=org/apache/orc/orc-tools/1.2.3/orc-tools-1.2.3-uber.jar",
         )
     end
 
     specify "apache version style" do
-      expect(described_class.create("1.2.0-rc2"))
+      expect(described_class.new("1.2.0-rc2"))
         .to be_detected_from(
           "https://www.apache.org/dyn/closer.cgi?path=/cassandra/1.2.0/apache-cassandra-1.2.0-rc2-bin.tar.gz",
         )
     end
 
     specify "jpeg version style" do
-      expect(described_class.create("8d"))
+      expect(described_class.new("8d"))
         .to be_detected_from("https://www.ijg.org/files/jpegsrc.v8d.tar.gz")
     end
 
     specify "ghc version style" do
-      expect(described_class.create("7.0.4"))
+      expect(described_class.new("7.0.4"))
         .to be_detected_from("https://www.haskell.org/ghc/dist/7.0.4/ghc-7.0.4-x86_64-apple-darwin.tar.bz2")
-      expect(described_class.create("7.0.4"))
+      expect(described_class.new("7.0.4"))
         .to be_detected_from("https://www.haskell.org/ghc/dist/7.0.4/ghc-7.0.4-i386-apple-darwin.tar.bz2")
     end
 
     specify "pypy version style" do
-      expect(described_class.create("1.4.1"))
+      expect(described_class.new("1.4.1"))
         .to be_detected_from("https://pypy.org/download/pypy-1.4.1-osx.tar.bz2")
     end
 
     specify "openssl version style" do
-      expect(described_class.create("0.9.8s"))
+      expect(described_class.new("0.9.8s"))
         .to be_detected_from("https://www.openssl.org/source/openssl-0.9.8s.tar.gz")
     end
 
     specify "xaw3d version style" do
-      expect(described_class.create("1.5E"))
+      expect(described_class.new("1.5E"))
         .to be_detected_from("ftp://ftp.visi.com/users/hawkeyd/X/Xaw3d-1.5E.tar.gz")
     end
 
     specify "assimp version style" do
-      expect(described_class.create("2.0.863"))
+      expect(described_class.new("2.0.863"))
         .to be_detected_from("https://downloads.sourceforge.net/project/assimp/assimp-2.0/assimp--2.0.863-sdk.zip")
     end
 
     specify "cmucl version style" do
-      expect(described_class.create("20c"))
+      expect(described_class.new("20c"))
         .to be_detected_from(
           "https://common-lisp.net/project/cmucl/downloads/release/20c/cmucl-20c-x86-darwin.tar.bz2",
         )
     end
 
     specify "fann version style" do
-      expect(described_class.create("2.1.0beta"))
+      expect(described_class.new("2.1.0beta"))
         .to be_detected_from("https://downloads.sourceforge.net/project/fann/fann/2.1.0beta/fann-2.1.0beta.zip")
     end
 
     specify "grads version style" do
-      expect(described_class.create("2.0.1"))
+      expect(described_class.new("2.0.1"))
         .to be_detected_from("ftp://iges.org/grads/2.0/grads-2.0.1-bin-darwin9.8-intel.tar.gz")
     end
 
     specify "haxe version style" do
-      expect(described_class.create("2.08"))
+      expect(described_class.new("2.08"))
         .to be_detected_from("https://haxe.org/file/haxe-2.08-osx.tar.gz")
     end
 
     specify "imap version style" do
-      expect(described_class.create("2007f"))
+      expect(described_class.new("2007f"))
         .to be_detected_from("ftp://ftp.cac.washington.edu/imap/imap-2007f.tar.gz")
     end
 
     specify "suite3270 version style" do
-      expect(described_class.create("3.3.12ga7"))
+      expect(described_class.new("3.3.12ga7"))
         .to be_detected_from(
           "https://downloads.sourceforge.net/project/x3270/x3270/3.3.12ga7/suite3270-3.3.12ga7-src.tgz",
         )
     end
 
     specify "wwwoffle version style" do
-      expect(described_class.create("2.9h"))
+      expect(described_class.new("2.9h"))
         .to be_detected_from("http://www.gedanken.demon.co.uk/download-wwwoffle/wwwoffle-2.9h.tgz")
     end
 
     specify "synergy version style" do
-      expect(described_class.create("1.3.6p2"))
+      expect(described_class.new("1.3.6p2"))
         .to be_detected_from("http://synergy.googlecode.com/files/synergy-1.3.6p2-MacOSX-Universal.zip")
     end
 
     specify "fontforge version style" do
-      expect(described_class.create("20120731"))
+      expect(described_class.new("20120731"))
         .to be_detected_from(
           "https://downloads.sourceforge.net/project/fontforge/fontforge-source/fontforge_full-20120731-b.tar.bz2",
         )
     end
 
     specify "ezlupdate version style" do
-      expect(described_class.create("2011.10"))
+      expect(described_class.new("2011.10"))
         .to be_detected_from(
           "https://github.com/downloads/ezsystems" \
           "/ezpublish-legacy/ezpublish_community_project-2011.10-with_ezc.tar.bz2",
@@ -770,19 +838,19 @@
     end
 
     specify "aespipe version style" do
-      expect(described_class.create("2.4c"))
+      expect(described_class.new("2.4c"))
         .to be_detected_from("http://loop-aes.sourceforge.net/aespipe/aespipe-v2.4c.tar.bz2")
     end
 
     specify "win version style" do
-      expect(described_class.create("0.9.17"))
+      expect(described_class.new("0.9.17"))
         .to be_detected_from("https://ftpmirror.gnu.org/libmicrohttpd/libmicrohttpd-0.9.17-w32.zip")
-      expect(described_class.create("1.29"))
+      expect(described_class.new("1.29"))
         .to be_detected_from("https://ftpmirror.gnu.org/libidn/libidn-1.29-win64.zip")
     end
 
     specify "breseq version style" do
-      expect(described_class.create("0.35.1"))
+      expect(described_class.new("0.35.1"))
         .to be_detected_from(
           "https://github.com/barricklab/breseq" \
           "/releases/download/v0.35.1/breseq-0.35.1.Source.tar.gz",
@@ -790,12 +858,12 @@
     end
 
     specify "wildfly version style" do
-      expect(described_class.create("20.0.1"))
+      expect(described_class.new("20.0.1"))
         .to be_detected_from("https://download.jboss.org/wildfly/20.0.1.Final/wildfly-20.0.1.Final.tar.gz")
     end
 
     specify "trinity version style" do
-      expect(described_class.create("2.10.0"))
+      expect(described_class.new("2.10.0"))
         .to be_detected_from(
           "https://github.com/trinityrnaseq/trinityrnaseq" \
           "/releases/download/v2.10.0/trinityrnaseq-v2.10.0.FULL.tar.gz",
@@ -803,57 +871,57 @@
     end
 
     specify "with arch" do
-      expect(described_class.create("4.0.18-1"))
+      expect(described_class.new("4.0.18-1"))
         .to be_detected_from("https://ftpmirror.gnu.org/mtools/mtools-4.0.18-1.i686.rpm")
-      expect(described_class.create("5.5.7-5"))
+      expect(described_class.new("5.5.7-5"))
         .to be_detected_from("https://ftpmirror.gnu.org/autogen/autogen-5.5.7-5.i386.rpm")
-      expect(described_class.create("2.8"))
+      expect(described_class.new("2.8"))
         .to be_detected_from("https://ftpmirror.gnu.org/libtasn1/libtasn1-2.8-x86.zip")
-      expect(described_class.create("2.8"))
+      expect(described_class.new("2.8"))
         .to be_detected_from("https://ftpmirror.gnu.org/libtasn1/libtasn1-2.8-x64.zip")
-      expect(described_class.create("4.0.18"))
+      expect(described_class.new("4.0.18"))
         .to be_detected_from("https://ftpmirror.gnu.org/mtools/mtools_4.0.18_i386.deb")
     end
 
     specify "opam version" do
-      expect(described_class.create("2.18.3"))
+      expect(described_class.new("2.18.3"))
         .to be_detected_from("https://opam.ocaml.org/archives/lablgtk.2.18.3+opam.tar.gz")
-      expect(described_class.create("1.9"))
+      expect(described_class.new("1.9"))
         .to be_detected_from("https://opam.ocaml.org/archives/sha.1.9+opam.tar.gz")
-      expect(described_class.create("0.99.2"))
+      expect(described_class.new("0.99.2"))
         .to be_detected_from("https://opam.ocaml.org/archives/ppx_tools.0.99.2+opam.tar.gz")
-      expect(described_class.create("1.0.2"))
+      expect(described_class.new("1.0.2"))
         .to be_detected_from("https://opam.ocaml.org/archives/easy-format.1.0.2+opam.tar.gz")
     end
 
     specify "no extension version" do
-      expect(described_class.create("1.8.12"))
+      expect(described_class.new("1.8.12"))
         .to be_detected_from("https://waf.io/waf-1.8.12")
-      expect(described_class.create("0.7.1"))
+      expect(described_class.new("0.7.1"))
         .to be_detected_from("https://codeload.github.com/gsamokovarov/jump/tar.gz/v0.7.1")
-      expect(described_class.create("0.9.1234"))
+      expect(described_class.new("0.9.1234"))
         .to be_detected_from("https://my.datomic.com/downloads/free/0.9.1234")
-      expect(described_class.create("1.2.3"))
+      expect(described_class.new("1.2.3"))
         .to be_detected_from("https://my.datomic.com/downloads/free/1.2.3")
     end
 
     specify "dash separated version" do
-      expect(described_class.create("6-20151227"))
+      expect(described_class.new("6-20151227"))
         .to be_detected_from("ftp://gcc.gnu.org/pub/gcc/snapshots/6-20151227/gcc-6-20151227.tar.bz2")
     end
 
     specify "semver in middle of URL" do
-      expect(described_class.create("7.1.10"))
+      expect(described_class.new("7.1.10"))
         .to be_detected_from("https://php.net/get/php-7.1.10.tar.gz/from/this/mirror")
     end
 
     specify "from tag" do
-      expect(described_class.create("1.2.3"))
+      expect(described_class.new("1.2.3"))
         .to be_detected_from("https://github.com/foo/bar.git", tag: "v1.2.3-stable")
     end
 
     specify "beta from tag" do
-      expect(described_class.create("1.2.3-beta1"))
+      expect(described_class.new("1.2.3-beta1"))
         .to be_detected_from("https://github.com/foo/bar.git", tag: "v1.2.3-beta1")
     end
   end
@@ -862,7 +930,7 @@
     specify "#version" do
       d = HOMEBREW_CELLAR/"foo-0.1.9"
       d.mkpath
-      expect(d.version).to eq(Version.create("0.1.9"))
+      expect(d.version).to eq(Version.new("0.1.9"))
     end
   end
 end
diff --git a/Library/Homebrew/test_runner_formula.rb b/Library/Homebrew/test_runner_formula.rb
new file mode 100644
index 0000000000000..e3c3c987d6889
--- /dev/null
+++ b/Library/Homebrew/test_runner_formula.rb
@@ -0,0 +1,114 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "formula"
+
+class TestRunnerFormula
+  sig { returns(String) }
+  attr_reader :name
+
+  sig { returns(Formula) }
+  attr_reader :formula
+
+  sig { returns(T::Boolean) }
+  attr_reader :eval_all
+
+  sig { params(formula: Formula, eval_all: T::Boolean).void }
+  def initialize(formula, eval_all: Homebrew::EnvConfig.eval_all?)
+    Formulary.enable_factory_cache!
+    @formula = T.let(formula, Formula)
+    @name = T.let(formula.name, String)
+    @dependent_hash = T.let({}, T::Hash[Symbol, T::Array[TestRunnerFormula]])
+    @eval_all = T.let(eval_all, T::Boolean)
+    freeze
+  end
+
+  sig { returns(T::Boolean) }
+  def macos_only?
+    formula.requirements.any? { |r| r.is_a?(MacOSRequirement) && !r.version_specified? }
+  end
+
+  sig { returns(T::Boolean) }
+  def macos_compatible?
+    !linux_only?
+  end
+
+  sig { returns(T::Boolean) }
+  def linux_only?
+    formula.requirements.any?(LinuxRequirement)
+  end
+
+  sig { returns(T::Boolean) }
+  def linux_compatible?
+    !macos_only?
+  end
+
+  sig { returns(T::Boolean) }
+  def x86_64_only?
+    formula.requirements.any? { |r| r.is_a?(ArchRequirement) && (r.arch == :x86_64) }
+  end
+
+  sig { returns(T::Boolean) }
+  def x86_64_compatible?
+    !arm64_only?
+  end
+
+  sig { returns(T::Boolean) }
+  def arm64_only?
+    formula.requirements.any? { |r| r.is_a?(ArchRequirement) && (r.arch == :arm64) }
+  end
+
+  sig { returns(T::Boolean) }
+  def arm64_compatible?
+    !x86_64_only?
+  end
+
+  sig { returns(T.nilable(MacOSRequirement)) }
+  def versioned_macos_requirement
+    formula.requirements.find { |r| r.is_a?(MacOSRequirement) && r.version_specified? }
+  end
+
+  sig { params(macos_version: MacOSVersion).returns(T::Boolean) }
+  def compatible_with?(macos_version)
+    # Assign to a variable to assist type-checking.
+    requirement = versioned_macos_requirement
+    return true if requirement.blank?
+
+    macos_version.public_send(requirement.comparator, requirement.version)
+  end
+
+  SIMULATE_SYSTEM_SYMBOLS = T.let({ arm64: :arm, x86_64: :intel }.freeze, T::Hash[Symbol, Symbol])
+
+  sig {
+    params(
+      platform:      Symbol,
+      arch:          Symbol,
+      macos_version: T.nilable(Symbol),
+    ).returns(T::Array[TestRunnerFormula])
+  }
+  def dependents(platform:, arch:, macos_version:)
+    cache_key = :"#{platform}_#{arch}_#{macos_version}"
+
+    @dependent_hash[cache_key] ||= begin
+      formula_selector, eval_all_env = if eval_all
+        [:all, "1"]
+      else
+        [:installed, nil]
+      end
+
+      with_env(HOMEBREW_EVAL_ALL: eval_all_env) do
+        os = macos_version || platform
+        arch = SIMULATE_SYSTEM_SYMBOLS.fetch(arch)
+
+        Homebrew::SimulateSystem.with(os:, arch:) do
+          Formula.public_send(formula_selector)
+                 .select { |candidate_f| candidate_f.deps.map(&:name).include?(name) }
+                 .map { |f| TestRunnerFormula.new(f, eval_all:) }
+                 .freeze
+        end
+      end
+    end
+
+    @dependent_hash.fetch(cache_key)
+  end
+end
diff --git a/Library/Homebrew/uninstall.rb b/Library/Homebrew/uninstall.rb
index 1d9a1585e4d17..fd14e8ce8d08e 100644
--- a/Library/Homebrew/uninstall.rb
+++ b/Library/Homebrew/uninstall.rb
@@ -1,20 +1,16 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "installed_dependents"
 
 module Homebrew
   # Helper module for uninstalling kegs.
-  #
-  # @api private
   module Uninstall
-    module_function
-
-    def uninstall_kegs(kegs_by_rack, casks: [], force: false, ignore_dependencies: false, named_args: [])
+    def self.uninstall_kegs(kegs_by_rack, casks: [], force: false, ignore_dependencies: false, named_args: [])
       handle_unsatisfied_dependents(kegs_by_rack,
-                                    casks:               casks,
-                                    ignore_dependencies: ignore_dependencies,
-                                    named_args:          named_args)
+                                    casks:,
+                                    ignore_dependencies:,
+                                    named_args:)
       return if Homebrew.failed?
 
       kegs_by_rack.each do |rack, kegs|
@@ -52,7 +48,7 @@ def uninstall_kegs(kegs_by_rack, casks: [], force: false, ignore_dependencies: f
               if rack.directory?
                 versions = rack.subdirs.map(&:basename)
                 puts <<~EOS
-                  #{keg.name} #{versions.to_sentence} #{"is".pluralize(versions.count)} still installed.
+                  #{keg.name} #{versions.to_sentence} #{(versions.count == 1) ? "is" : "are"} still installed.
                   To remove all versions, run:
                     brew uninstall --force #{keg.name}
                 EOS
@@ -97,29 +93,28 @@ def uninstall_kegs(kegs_by_rack, casks: [], force: false, ignore_dependencies: f
       end
     end
 
-    def handle_unsatisfied_dependents(kegs_by_rack, casks: [], ignore_dependencies: false, named_args: [])
+    def self.handle_unsatisfied_dependents(kegs_by_rack, casks: [], ignore_dependencies: false, named_args: [])
       return if ignore_dependencies
 
       all_kegs = kegs_by_rack.values.flatten(1)
-      check_for_dependents(all_kegs, casks: casks, named_args: named_args)
+      check_for_dependents(all_kegs, casks:, named_args:)
     rescue MethodDeprecatedError
       # Silently ignore deprecations when uninstalling.
       nil
     end
 
-    def check_for_dependents(kegs, casks: [], named_args: [])
-      return false unless (result = InstalledDependents.find_some_installed_dependents(kegs, casks: casks))
+    def self.check_for_dependents(kegs, casks: [], named_args: [])
+      return false unless (result = InstalledDependents.find_some_installed_dependents(kegs, casks:))
 
       if Homebrew::EnvConfig.developer?
-        DeveloperDependentsMessage.new(*result, named_args: named_args).output
+        DeveloperDependentsMessage.new(*result, named_args:).output
       else
-        NondeveloperDependentsMessage.new(*result, named_args: named_args).output
+        NondeveloperDependentsMessage.new(*result, named_args:).output
       end
 
       true
     end
 
-    # @api private
     class DependentsMessage
       attr_reader :reqs, :deps, :named_args
 
@@ -136,12 +131,11 @@ def sample_command
       end
 
       def are_required_by_deps
-        "#{"is".pluralize(reqs.count)} required by #{deps.to_sentence}, " \
-          "which #{"is".pluralize(deps.count)} currently installed"
+        "#{(reqs.count == 1) ? "is" : "are"} required by #{deps.to_sentence}, " \
+          "which #{(deps.count == 1) ? "is" : "are"} currently installed"
       end
     end
 
-    # @api private
     class DeveloperDependentsMessage < DependentsMessage
       def output
         opoo <<~EOS
@@ -152,19 +146,18 @@ def output
       end
     end
 
-    # @api private
     class NondeveloperDependentsMessage < DependentsMessage
       def output
         ofail <<~EOS
           Refusing to uninstall #{reqs.to_sentence}
-          because #{"it".pluralize(reqs.count)} #{are_required_by_deps}.
+          because #{(reqs.count == 1) ? "it" : "they"} #{are_required_by_deps}.
           You can override this and force removal with:
             #{sample_command}
         EOS
       end
     end
 
-    def rm_pin(rack)
+    def self.rm_pin(rack)
       Formulary.from_rack(rack).unpin
     rescue
       nil
diff --git a/Library/Homebrew/uninstall.rbi b/Library/Homebrew/uninstall.rbi
deleted file mode 100644
index f801c23a87217..0000000000000
--- a/Library/Homebrew/uninstall.rbi
+++ /dev/null
@@ -1,7 +0,0 @@
-# typed: strict
-
-module Homebrew
-  module Uninstall
-    include Kernel
-  end
-end
diff --git a/Library/Homebrew/unlink.rb b/Library/Homebrew/unlink.rb
index ef9ce40722244..228cd8736cc27 100644
--- a/Library/Homebrew/unlink.rb
+++ b/Library/Homebrew/unlink.rb
@@ -1,25 +1,24 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 module Homebrew
   # Provides helper methods for unlinking formulae and kegs with consistent output.
   module Unlink
-    module_function
-
-    def unlink_versioned_formulae(formula, verbose: false)
+    sig { params(formula: Formula, verbose: T::Boolean).void }
+    def self.unlink_versioned_formulae(formula, verbose: false)
       formula.versioned_formulae
              .select(&:keg_only?)
              .select(&:linked?)
-             .map(&:any_installed_keg)
-             .compact
+             .filter_map(&:any_installed_keg)
              .select(&:directory?)
              .each do |keg|
-        unlink(keg, verbose: verbose)
+        unlink(keg, verbose:)
       end
     end
 
-    def unlink(keg, dry_run: false, verbose: false)
-      options = { dry_run: dry_run, verbose: verbose }
+    sig { params(keg: Keg, dry_run: T::Boolean, verbose: T::Boolean).void }
+    def self.unlink(keg, dry_run: false, verbose: false)
+      options = { dry_run:, verbose: }
 
       keg.lock do
         print "Unlinking #{keg}... "
diff --git a/Library/Homebrew/unpack_strategy.rb b/Library/Homebrew/unpack_strategy.rb
index 587b5f32bc403..55c856e24eb7b 100644
--- a/Library/Homebrew/unpack_strategy.rb
+++ b/Library/Homebrew/unpack_strategy.rb
@@ -1,49 +1,35 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
+require "mktemp"
 require "system_command"
 
 # Module containing all available strategies for unpacking archives.
-#
-# @api private
 module UnpackStrategy
-  extend T::Sig
   extend T::Helpers
-
   include SystemCommand::Mixin
+  abstract!
 
-  # Helper module for identifying the file type.
-  module Magic
-    # Length of the longest regex (currently Tar).
-    MAX_MAGIC_NUMBER_LENGTH = 262
-    private_constant :MAX_MAGIC_NUMBER_LENGTH
-
-    refine Pathname do
-      def magic_number
-        @magic_number ||= if directory?
-          ""
-        else
-          binread(MAX_MAGIC_NUMBER_LENGTH) || ""
-        end
-      end
+  requires_ancestor { Kernel }
 
-      def file_type
-        @file_type ||= system_command("file", args: ["-b", self], print_stderr: false)
-                       .stdout.chomp
-      end
+  UnpackStrategyType = T.type_alias { T.all(T::Class[UnpackStrategy], UnpackStrategy::ClassMethods) }
 
-      def zipinfo
-        @zipinfo ||= system_command("zipinfo", args: ["-1", self], print_stderr: false)
-                     .stdout
-                     .encode(Encoding::UTF_8, invalid: :replace)
-                     .split("\n")
-      end
-    end
+  module ClassMethods
+    extend T::Helpers
+    abstract!
+
+    sig { abstract.returns(T::Array[String]) }
+    def extensions; end
+
+    sig { abstract.params(path: Pathname).returns(T::Boolean) }
+    def can_extract?(path); end
   end
-  private_constant :Magic
 
+  mixes_in_class_methods(ClassMethods)
+
+  sig { returns(T.nilable(T::Array[UnpackStrategyType])) }
   def self.strategies
-    @strategies ||= [
+    @strategies ||= T.let([
       Tar, # Needs to be before Bzip2/Gzip/Xz/Lzma/Zstd.
       Pax,
       Gzip,
@@ -76,10 +62,11 @@ def self.strategies
       Sit,
       Rar,
       Lha,
-    ].freeze
+    ].freeze, T.nilable(T::Array[UnpackStrategyType]))
   end
   private_class_method :strategies
 
+  sig { params(type: Symbol).returns(T.nilable(UnpackStrategyType)) }
   def self.from_type(type)
     type = {
       naked:     :uncompressed,
@@ -94,23 +81,31 @@ def self.from_type(type)
     end
   end
 
+  sig { params(extension: String).returns(T.nilable(UnpackStrategyType)) }
   def self.from_extension(extension)
-    strategies.sort_by { |s| s.extensions.map(&:length).max || 0 }
-              .reverse
-              .find { |s| s.extensions.any? { |ext| extension.end_with?(ext) } }
+    return unless strategies
+
+    strategies&.sort_by { |s| s.extensions.map(&:length).max || 0 }
+              &.reverse
+              &.find { |s| s.extensions.any? { |ext| extension.end_with?(ext) } }
   end
 
+  sig { params(path: Pathname).returns(T.nilable(UnpackStrategyType)) }
   def self.from_magic(path)
-    strategies.find { |s| s.can_extract?(path) }
+    strategies&.find { |s| s.can_extract?(path) }
   end
 
-  def self.detect(path, prioritise_extension: false, type: nil, ref_type: nil, ref: nil, merge_xattrs: nil)
+  sig {
+    params(path: Pathname, prioritize_extension: T::Boolean, type: T.nilable(Symbol), ref_type: T.nilable(Symbol),
+           ref: T.nilable(String), merge_xattrs: T::Boolean).returns(T.untyped)
+  }
+  def self.detect(path, prioritize_extension: false, type: nil, ref_type: nil, ref: nil, merge_xattrs: false)
     strategy = from_type(type) if type
 
-    if prioritise_extension && path.extname.present?
+    if prioritize_extension && path.extname.present?
       strategy ||= from_extension(path.extname)
-      strategy ||= strategies.select { |s| s < Directory || s == Fossil }
-                             .find { |s| s.can_extract?(path) }
+
+      strategy ||= strategies&.find { |s| (s < Directory || s == Fossil) && s.can_extract?(path) }
     else
       strategy ||= from_magic(path)
       strategy ||= from_extension(path.extname)
@@ -118,56 +113,97 @@ def self.detect(path, prioritise_extension: false, type: nil, ref_type: nil, ref
 
     strategy ||= Uncompressed
 
-    strategy.new(path, ref_type: ref_type, ref: ref, merge_xattrs: merge_xattrs)
+    strategy.new(path, ref_type:, ref:, merge_xattrs:)
   end
 
-  attr_reader :path, :merge_xattrs
-
-  def initialize(path, ref_type: nil, ref: nil, merge_xattrs: nil)
-    @path = Pathname(path).expand_path
-    @ref_type = ref_type
-    @ref = ref
-    @merge_xattrs = merge_xattrs
+  sig { returns(Pathname) }
+  attr_reader :path
+
+  sig { returns(T::Boolean) }
+  attr_reader :merge_xattrs
+
+  sig {
+    params(path: T.any(String, Pathname), ref_type: T.nilable(Symbol), ref: T.nilable(String),
+           merge_xattrs: T::Boolean).void
+  }
+  def initialize(path, ref_type: nil, ref: nil, merge_xattrs: false)
+    @path = T.let(Pathname(path).expand_path, Pathname)
+    @ref_type = T.let(ref_type, T.nilable(Symbol))
+    @ref = T.let(ref, T.nilable(String))
+    @merge_xattrs = T.let(merge_xattrs, T::Boolean)
   end
 
-  abstract!
-  sig { abstract.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+  sig { abstract.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
   def extract_to_dir(unpack_dir, basename:, verbose:); end
   private :extract_to_dir
 
-  def extract(to: nil, basename: nil, verbose: nil)
+  sig {
+    params(
+      to: T.nilable(Pathname), basename: T.nilable(T.any(String, Pathname)), verbose: T::Boolean,
+    ).void
+  }
+  def extract(to: nil, basename: nil, verbose: false)
     basename ||= path.basename
     unpack_dir = Pathname(to || Dir.pwd).expand_path
     unpack_dir.mkpath
-    extract_to_dir(unpack_dir, basename: Pathname(basename), verbose: verbose || false)
+    extract_to_dir(unpack_dir, basename: Pathname(basename), verbose:)
   end
 
-  def extract_nestedly(to: nil, basename: nil, verbose: false, prioritise_extension: false)
-    Dir.mktmpdir do |tmp_unpack_dir|
-      tmp_unpack_dir = Pathname(tmp_unpack_dir)
+  sig {
+    params(
+      to:                   T.nilable(Pathname),
+      basename:             T.nilable(T.any(String, Pathname)),
+      verbose:              T::Boolean,
+      prioritize_extension: T::Boolean,
+    ).returns(T.untyped)
+  }
+  def extract_nestedly(to: nil, basename: nil, verbose: false, prioritize_extension: false)
+    Mktemp.new("homebrew-unpack").run(chdir: false) do |unpack_dir|
+      tmp_unpack_dir = T.must(unpack_dir.tmpdir)
 
-      extract(to: tmp_unpack_dir, basename: basename, verbose: verbose)
+      extract(to: tmp_unpack_dir, basename:, verbose:)
 
       children = tmp_unpack_dir.children
 
-      if children.count == 1 && !children.first.directory?
-        FileUtils.chmod "+rw", children.first, verbose: verbose
+      if children.size == 1 && !children.fetch(0).directory?
+        first_child = children.first
+        next if first_child.nil?
 
-        s = UnpackStrategy.detect(children.first, prioritise_extension: prioritise_extension)
+        s = UnpackStrategy.detect(first_child, prioritize_extension:)
+
+        s.extract_nestedly(to:, verbose:, prioritize_extension:)
 
-        s.extract_nestedly(to: to, verbose: verbose, prioritise_extension: prioritise_extension)
         next
       end
 
-      Directory.new(tmp_unpack_dir).extract(to: to, verbose: verbose)
+      # Ensure all extracted directories are writable.
+      each_directory(tmp_unpack_dir) do |path|
+        next if path.writable?
 
-      FileUtils.chmod_R "+w", tmp_unpack_dir, force: true, verbose: verbose
+        FileUtils.chmod "u+w", path, verbose:
+      end
+
+      Directory.new(tmp_unpack_dir, move: true).extract(to:, verbose:)
     end
   end
 
+  sig { returns(T.any(T::Array[Cask::Cask], T::Array[Formula])) }
   def dependencies
     []
   end
+
+  # Helper method for iterating over directory trees.
+  sig {
+    params(
+      pathname: Pathname,
+      _block:   T.proc.params(path: Pathname).void,
+    ).returns(T.nilable(Pathname))
+  }
+  def each_directory(pathname, &_block)
+    pathname.find do |path|
+      yield path if path.directory?
+    end
+  end
 end
 
 require "unpack_strategy/air"
diff --git a/Library/Homebrew/unpack_strategy.rbi b/Library/Homebrew/unpack_strategy.rbi
deleted file mode 100644
index 55284f6668d16..0000000000000
--- a/Library/Homebrew/unpack_strategy.rbi
+++ /dev/null
@@ -1,16 +0,0 @@
-# typed: strict
-
-module UnpackStrategy
-  include Kernel
-end
-
-class Pathname
-  sig { returns(String) }
-  def magic_number; end
-
-  sig { returns(String) }
-  def file_type; end
-
-  sig { returns(T::Array[String]) }
-  def zipinfo; end
-end
diff --git a/Library/Homebrew/unpack_strategy/air.rb b/Library/Homebrew/unpack_strategy/air.rb
index 9f8bd8c473cdd..371fc29ae8250 100644
--- a/Library/Homebrew/unpack_strategy/air.rb
+++ b/Library/Homebrew/unpack_strategy/air.rb
@@ -1,27 +1,25 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking Adobe Air archives.
   class Air
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".air"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       mime_type = "application/vnd.adobe.air-application-installer-package+zip"
       path.magic_number.match?(/.{59}#{Regexp.escape(mime_type)}/)
     end
 
+    sig { returns(T::Array[Cask::Cask]) }
     def dependencies
-      @dependencies ||= [Cask::CaskLoader.load("adobe-air")]
+      @dependencies ||= T.let([Cask::CaskLoader.load("adobe-air")], T.nilable(T::Array[Cask::Cask]))
     end
 
     AIR_APPLICATION_INSTALLER =
@@ -31,11 +29,11 @@ def dependencies
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       system_command! AIR_APPLICATION_INSTALLER,
                       args:    ["-silent", "-location", unpack_dir, path],
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/bazaar.rb b/Library/Homebrew/unpack_strategy/bazaar.rb
index 12fbd503d06ed..c237507ad93ce 100644
--- a/Library/Homebrew/unpack_strategy/bazaar.rb
+++ b/Library/Homebrew/unpack_strategy/bazaar.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "directory"
@@ -6,22 +6,19 @@
 module UnpackStrategy
   # Strategy for unpacking Bazaar archives.
   class Bazaar < Directory
-    extend T::Sig
-
-    using Magic
-
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
-      super && (path/".bzr").directory?
+      !!(super && (path/".bzr").directory?)
     end
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       super
 
       # The export command doesn't work on checkouts (see https://bugs.launchpad.net/bzr/+bug/897511).
-      (unpack_dir/".bzr").rmtree
+      FileUtils.rm_r(unpack_dir/".bzr")
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/bzip2.rb b/Library/Homebrew/unpack_strategy/bzip2.rb
index 6b05e4dc15c7a..12190c6a6995d 100644
--- a/Library/Homebrew/unpack_strategy/bzip2.rb
+++ b/Library/Homebrew/unpack_strategy/bzip2.rb
@@ -1,33 +1,30 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking bzip2 archives.
   class Bzip2
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".bz2"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\ABZh/n)
     end
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       FileUtils.cp path, unpack_dir/basename, preserve: true
       quiet_flags = verbose ? [] : ["-q"]
       system_command! "bunzip2",
                       args:    [*quiet_flags, unpack_dir/basename],
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/cab.rb b/Library/Homebrew/unpack_strategy/cab.rb
index 82265231d5234..cb3aa57ee9392 100644
--- a/Library/Homebrew/unpack_strategy/cab.rb
+++ b/Library/Homebrew/unpack_strategy/cab.rb
@@ -1,34 +1,32 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking Cabinet archives.
   class Cab
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".cab"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\AMSCF/n)
     end
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { returns(T::Array[Formula]) }
+    def dependencies
+      @dependencies ||= T.let([Formula["cabextract"]], T.nilable(T::Array[Formula]))
+    end
+
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       system_command! "cabextract",
                       args:    ["-d", unpack_dir, "--", path],
                       env:     { "PATH" => PATH.new(Formula["cabextract"].opt_bin, ENV.fetch("PATH")) },
-                      verbose: verbose
-    end
-
-    def dependencies
-      @dependencies ||= [Formula["cabextract"]]
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/compress.rb b/Library/Homebrew/unpack_strategy/compress.rb
index 65f9ea8728ed3..504f31390bb0c 100644
--- a/Library/Homebrew/unpack_strategy/compress.rb
+++ b/Library/Homebrew/unpack_strategy/compress.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "tar"
@@ -6,15 +6,12 @@
 module UnpackStrategy
   # Strategy for unpacking compress archives.
   class Compress < Tar
-    extend T::Sig
-
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".Z"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\A\037\235/n)
     end
diff --git a/Library/Homebrew/unpack_strategy/cvs.rb b/Library/Homebrew/unpack_strategy/cvs.rb
index 66c2f17f8fb34..7e3c5b018b178 100644
--- a/Library/Homebrew/unpack_strategy/cvs.rb
+++ b/Library/Homebrew/unpack_strategy/cvs.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "directory"
@@ -6,10 +6,9 @@
 module UnpackStrategy
   # Strategy for unpacking CVS repositories.
   class Cvs < Directory
-    using Magic
-
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
-      super && (path/"CVS").directory?
+      !!(super && (path/"CVS").directory?)
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/directory.rb b/Library/Homebrew/unpack_strategy/directory.rb
index 02772dcc68fcf..fc1763a2d20a7 100644
--- a/Library/Homebrew/unpack_strategy/directory.rb
+++ b/Library/Homebrew/unpack_strategy/directory.rb
@@ -1,33 +1,71 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking directories.
   class Directory
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       []
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.directory?
     end
 
+    sig {
+      params(
+        path:         T.any(String, Pathname),
+        ref_type:     T.nilable(Symbol),
+        ref:          T.nilable(String),
+        merge_xattrs: T::Boolean,
+        move:         T::Boolean,
+      ).void
+    }
+    def initialize(path, ref_type: nil, ref: nil, merge_xattrs: false, move: false)
+      super(path, ref_type:, ref:, merge_xattrs:)
+      @move = move
+    end
+
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
-      path.children.each do |child|
-        system_command! "cp",
-                        args:    ["-pR", (child.directory? && !child.symlink?) ? "#{child}/." : child,
-                                  unpack_dir/child.basename],
-                        verbose: verbose
+      move_to_dir(unpack_dir, verbose:) if @move
+      path_children = path.children
+      return if path_children.empty?
+
+      system_command!("cp", args: ["-pR", *path_children, unpack_dir], verbose:)
+    end
+
+    # Move all files from source `path` to target `unpack_dir`. Any existing
+    # subdirectories are not modified and only the contents are moved.
+    #
+    # @raise [RuntimeError] on unsupported `mv` operation, e.g. overwriting a file with a directory
+    sig { params(unpack_dir: Pathname, verbose: T::Boolean).void }
+    def move_to_dir(unpack_dir, verbose:)
+      path.find do |src|
+        next if src == path
+
+        dst = unpack_dir/src.relative_path_from(path)
+        if dst.exist?
+          dst_real_dir = dst.directory? && !dst.symlink?
+          src_real_dir = src.directory? && !src.symlink?
+          # Avoid moving a directory over an existing non-directory and vice versa.
+          # This outputs the same error message as GNU mv which is more readable than macOS mv.
+          raise "mv: cannot overwrite non-directory '#{dst}' with directory '#{src}'" if src_real_dir && !dst_real_dir
+          raise "mv: cannot overwrite directory '#{dst}' with non-directory '#{src}'" if !src_real_dir && dst_real_dir
+          # Defer writing over existing directories. Handle this later on to copy attributes
+          next if dst_real_dir
+
+          FileUtils.rm(dst, verbose:)
+        end
+
+        FileUtils.mv(src, dst, verbose:)
+        Find.prune
       end
     end
   end
diff --git a/Library/Homebrew/unpack_strategy/dmg.rb b/Library/Homebrew/unpack_strategy/dmg.rb
index f758c1a78cd42..f6969fb7cfc17 100644
--- a/Library/Homebrew/unpack_strategy/dmg.rb
+++ b/Library/Homebrew/unpack_strategy/dmg.rb
@@ -1,18 +1,20 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 require "tempfile"
+require "system_command"
 
 module UnpackStrategy
   # Strategy for unpacking disk images.
   class Dmg
-    extend T::Sig
-
+    extend SystemCommand::Mixin
     include UnpackStrategy
 
     # Helper module for listing the contents of a volume mounted from a disk image.
     module Bom
-      DMG_METADATA = Set.new(%w[
+      extend SystemCommand::Mixin
+
+      DMG_METADATA = T.let(Set.new(%w[
         .background
         .com.apple.timemachine.donotpresent
         .com.apple.timemachine.supported
@@ -24,122 +26,141 @@ module Bom
         .TemporaryItems
         .Trashes
         .VolumeIcon.icns
-      ]).freeze
+      ]).freeze, T::Set[String])
       private_constant :DMG_METADATA
 
-      refine Pathname do
-        extend T::Sig
-
-        # Check if path is considered disk image metadata.
-        sig { returns(T::Boolean) }
-        def dmg_metadata?
-          DMG_METADATA.include?(cleanpath.ascend.to_a.last.to_s)
-        end
+      class Error < RuntimeError; end
 
-        # Check if path is a symlink to a system directory (commonly to /Applications).
-        sig { returns(T::Boolean) }
-        def system_dir_symlink?
-          symlink? && MacOS.system_dir?(dirname.join(readlink))
+      class EmptyError < Error
+        sig { params(path: Pathname).void }
+        def initialize(path)
+          super "BOM for path '#{path}' is empty."
         end
+      end
 
-        sig { returns(String) }
-        def bom
-          tries = 0
-          result = loop do
-            # rubocop:disable Style/AsciiComments
-            # We need to use `find` here instead of Ruby in order to properly handle
-            # file names containing special characters, such as “e” + “´” vs. “é”.
-            # rubocop:enable Style/AsciiComments
-            r = system_command("find", args: [".", "-print0"], chdir: self, print_stderr: false)
-            tries += 1
-
-            # Spurious bug on CI, which in most cases can be worked around by retrying.
-            break r unless r.stderr.match?(/Interrupted system call/i)
-
-            raise "Command `#{r.command.shelljoin}` was interrupted." if tries >= 3
-          end
+      # Check if path is considered disk image metadata.
+      sig { params(pathname: Pathname).returns(T::Boolean) }
+      def self.dmg_metadata?(pathname)
+        DMG_METADATA.include?(pathname.cleanpath.ascend.to_a.last.to_s)
+      end
 
-          odebug "Command `#{result.command.shelljoin}` in '#{self}' took #{tries} tries." if tries > 1
+      # Check if path is a symlink to a system directory (commonly to /Applications).
+      sig { params(pathname: Pathname).returns(T::Boolean) }
+      def self.system_dir_symlink?(pathname)
+        pathname.symlink? && MacOS.system_dir?(pathname.dirname.join(pathname.readlink))
+      end
 
-          bom_paths = result.stdout.split("\0")
+      sig { params(pathname: Pathname).returns(String) }
+      def self.bom(pathname)
+        tries = 0
+        result = loop do
+          # We need to use `find` here instead of Ruby in order to properly handle
+          # file names containing special characters, such as “e” + “´” vs. “é”.
+          r = system_command("find", args: [".", "-print0"], chdir: pathname, print_stderr: false, reset_uid: true)
+          tries += 1
 
-          raise "BOM for path '#{self}' is empty." if bom_paths.empty?
+          # Spurious bug on CI, which in most cases can be worked around by retrying.
+          break r unless r.stderr.match?(/Interrupted system call/i)
 
-          bom_paths
-            .reject { |path| Pathname(path).dmg_metadata? }
-            .reject { |path| (self/path).system_dir_symlink? }
-            .join("\n")
+          raise "Command `#{r.command.shelljoin}` was interrupted." if tries >= 3
         end
+
+        odebug "Command `#{result.command.shelljoin}` in '#{pathname}' took #{tries} tries." if tries > 1
+
+        bom_paths = result.stdout.split("\0")
+
+        raise EmptyError, pathname if bom_paths.empty?
+
+        bom_paths
+          .reject { |path| dmg_metadata?(Pathname(path)) }
+          .reject { |path| system_dir_symlink?(pathname/path) }
+          .join("\n")
       end
     end
-    private_constant :Bom
 
     # Strategy for unpacking a volume mounted from a disk image.
     class Mount
-      extend T::Sig
-
-      using Bom
       include UnpackStrategy
 
+      sig { params(verbose: T::Boolean).void }
       def eject(verbose: false)
-        tries ||= 3
-
-        return unless path.exist?
-
-        if tries > 1
-          disk_info = system_command!(
-            "diskutil",
-            args:         ["info", "-plist", path],
-            print_stderr: false,
-            verbose:      verbose,
-          )
-
-          # For HFS, just use <mount-path>
-          # For APFS, find the <physical-store> corresponding to <mount-path>
-          eject_paths = disk_info.plist
-                                 .fetch("APFSPhysicalStores", [])
-                                 .map { |store| store["APFSPhysicalStore"] }
-                                 .compact
-                                 .presence || [path]
-
-          eject_paths.each do |eject_path|
+        tries = 3
+        begin
+          return unless path.exist?
+
+          if tries > 1
+            disk_info = system_command!(
+              "diskutil",
+              args:         ["info", "-plist", path],
+              print_stderr: false,
+              verbose:,
+            )
+
+            # For HFS, just use <mount-path>
+            # For APFS, find the <physical-store> corresponding to <mount-path>
+            eject_paths = disk_info.plist
+                                   .fetch("APFSPhysicalStores", [])
+                                   .filter_map { |store| store["APFSPhysicalStore"] }
+                                   .presence || [path]
+
+            eject_paths.each do |eject_path|
+              system_command! "diskutil",
+                              args:         ["eject", eject_path],
+                              print_stderr: false,
+                              verbose:
+            end
+          else
             system_command! "diskutil",
-                            args:         ["eject", eject_path],
+                            args:         ["unmount", "force", path],
                             print_stderr: false,
-                            verbose:      verbose
+                            verbose:
           end
-        else
-          system_command! "diskutil",
-                          args:         ["unmount", "force", path],
-                          print_stderr: false,
-                          verbose:      verbose
-        end
-      rescue ErrorDuringExecution => e
-        raise e if (tries -= 1).zero?
+        rescue ErrorDuringExecution => e
+          raise e if (tries -= 1).zero?
 
-        sleep 1
-        retry
+          sleep 1
+          retry
+        end
       end
 
+      sig { override.returns(T::Array[String]) }
+      def self.extensions = []
+
+      sig { override.params(_path: Pathname).returns(T::Boolean) }
+      def self.can_extract?(_path) = false
+
       private
 
-      sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+      sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
       def extract_to_dir(unpack_dir, basename:, verbose:)
+        tries = 3
+        bom = begin
+          Bom.bom(path)
+        rescue Bom::EmptyError => e
+          raise e if (tries -= 1).zero?
+
+          sleep 1
+          retry
+        end
+
         Tempfile.open(["", ".bom"]) do |bomfile|
           bomfile.close
 
           Tempfile.open(["", ".list"]) do |filelist|
-            filelist.puts(path.bom)
+            filelist.puts(bom)
             filelist.close
 
             system_command! "mkbom",
                             args:    ["-s", "-i", filelist.path, "--", bomfile.path],
-                            verbose: verbose
+                            verbose:
           end
 
-          system_command! "ditto",
-                          args:    ["--bom", bomfile.path, "--", path, unpack_dir],
-                          verbose: verbose
+          bomfile_path = T.must(bomfile.path)
+
+          system_command!("ditto",
+                          args:      ["--bom", bomfile_path, "--", path, unpack_dir],
+                          verbose:,
+                          reset_uid: true)
 
           FileUtils.chmod "u+w", Pathname.glob(unpack_dir/"**/*", File::FNM_DOTMATCH).reject(&:symlink?)
         end
@@ -147,11 +168,12 @@ def extract_to_dir(unpack_dir, basename:, verbose:)
     end
     private_constant :Mount
 
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".dmg"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       stdout, _, status = system_command("hdiutil", args: ["imageinfo", "-format", path], print_stderr: false)
       status.success? && !stdout.empty?
@@ -159,19 +181,20 @@ def self.can_extract?(path)
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
-      mount(verbose: verbose) do |mounts|
+      mount(verbose:) do |mounts|
         raise "No mounts found in '#{path}'; perhaps this is a bad disk image?" if mounts.empty?
 
         mounts.each do |mount|
-          mount.extract(to: unpack_dir, verbose: verbose)
+          mount.extract(to: unpack_dir, verbose:)
         end
       end
     end
 
-    def mount(verbose: false)
-      Dir.mktmpdir do |mount_dir|
+    sig { params(verbose: T::Boolean, _block: T.proc.params(arg0: T::Array[Mount]).void).void }
+    def mount(verbose: false, &_block)
+      Dir.mktmpdir("homebrew-dmg", HOMEBREW_TEMP) do |mount_dir|
         mount_dir = Pathname(mount_dir)
 
         without_eula = system_command(
@@ -182,7 +205,7 @@ def mount(verbose: false)
           ],
           input:        "qn\n",
           print_stderr: false,
-          verbose:      verbose,
+          verbose:,
         )
 
         # If mounting without agreeing to EULA succeeded, there is none.
@@ -198,7 +221,7 @@ def mount(verbose: false)
             args:    [
               "convert", *quiet_flag, "-format", "UDTO", "-o", cdr_path, path
             ],
-            verbose: verbose,
+            verbose:,
           )
 
           with_eula = system_command!(
@@ -207,7 +230,7 @@ def mount(verbose: false)
               "attach", "-plist", "-nobrowse", "-readonly",
               "-mountrandom", mount_dir, cdr_path
             ],
-            verbose: verbose,
+            verbose:,
           )
 
           if verbose && !(eula_text = without_eula.stdout).empty?
@@ -219,8 +242,7 @@ def mount(verbose: false)
 
         mounts = if plist.respond_to?(:fetch)
           plist.fetch("system-entities", [])
-               .map { |entity| entity["mount-point"] }
-               .compact
+               .filter_map { |entity| entity["mount-point"] }
                .map { |path| Mount.new(path) }
         else
           []
@@ -230,7 +252,7 @@ def mount(verbose: false)
           yield mounts
         ensure
           mounts.each do |mount|
-            mount.eject(verbose: verbose)
+            mount.eject(verbose:)
           end
         end
       end
diff --git a/Library/Homebrew/unpack_strategy/executable.rb b/Library/Homebrew/unpack_strategy/executable.rb
index 1daeb7d0f70f0..51cf812786e55 100644
--- a/Library/Homebrew/unpack_strategy/executable.rb
+++ b/Library/Homebrew/unpack_strategy/executable.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "uncompressed"
@@ -6,15 +6,12 @@
 module UnpackStrategy
   # Strategy for unpacking executables.
   class Executable < Uncompressed
-    extend T::Sig
-
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".sh", ".bash"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\A#!\s*\S+/n) ||
         path.magic_number.match?(/\AMZ/n)
diff --git a/Library/Homebrew/unpack_strategy/fossil.rb b/Library/Homebrew/unpack_strategy/fossil.rb
index ddaf147795078..8914c05aa8a7f 100644
--- a/Library/Homebrew/unpack_strategy/fossil.rb
+++ b/Library/Homebrew/unpack_strategy/fossil.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "system_command"
@@ -6,18 +6,15 @@
 module UnpackStrategy
   # Strategy for unpacking Fossil repositories.
   class Fossil
-    extend T::Sig
-
     include UnpackStrategy
     extend SystemCommand::Mixin
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       []
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       return false unless path.magic_number.match?(/\ASQLite format 3\000/n)
 
@@ -28,7 +25,7 @@ def self.can_extract?(path)
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       args = if @ref_type && @ref
         [@ref]
@@ -40,7 +37,7 @@ def extract_to_dir(unpack_dir, basename:, verbose:)
                       args:    ["open", path, *args],
                       chdir:   unpack_dir,
                       env:     { "PATH" => PATH.new(Formula["fossil"].opt_bin, ENV.fetch("PATH")) },
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/generic_unar.rb b/Library/Homebrew/unpack_strategy/generic_unar.rb
index 0322d5c9ef19a..d5ef55bf61959 100644
--- a/Library/Homebrew/unpack_strategy/generic_unar.rb
+++ b/Library/Homebrew/unpack_strategy/generic_unar.rb
@@ -1,31 +1,29 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking archives with `unar`.
   class GenericUnar
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       []
     end
 
+    sig { override.params(_path: Pathname).returns(T::Boolean) }
     def self.can_extract?(_path)
       false
     end
 
+    sig { returns(T::Array[Formula]) }
     def dependencies
-      @dependencies ||= [Formula["unar"]]
+      @dependencies ||= T.let([Formula["unar"]], T.nilable(T::Array[Formula]))
     end
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       system_command! "unar",
                       args:    [
@@ -33,7 +31,7 @@ def extract_to_dir(unpack_dir, basename:, verbose:)
                         "-output-directory", unpack_dir, "--", path
                       ],
                       env:     { "PATH" => PATH.new(Formula["unar"].opt_bin, ENV.fetch("PATH")) },
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/git.rb b/Library/Homebrew/unpack_strategy/git.rb
index 23257c050273d..42b906f125d6b 100644
--- a/Library/Homebrew/unpack_strategy/git.rb
+++ b/Library/Homebrew/unpack_strategy/git.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "directory"
@@ -6,10 +6,9 @@
 module UnpackStrategy
   # Strategy for unpacking Git repositories.
   class Git < Directory
-    using Magic
-
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
-      super && (path/".git").directory?
+      !!(super && (path/".git").directory?)
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/gzip.rb b/Library/Homebrew/unpack_strategy/gzip.rb
index 983d995a98bbb..b525cc6d0b1f0 100644
--- a/Library/Homebrew/unpack_strategy/gzip.rb
+++ b/Library/Homebrew/unpack_strategy/gzip.rb
@@ -1,33 +1,30 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking gzip archives.
   class Gzip
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".gz"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\A\037\213/n)
     end
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       FileUtils.cp path, unpack_dir/basename, preserve: true
       quiet_flags = verbose ? [] : ["-q"]
       system_command! "gunzip",
                       args:    [*quiet_flags, "-N", "--", unpack_dir/basename],
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/jar.rb b/Library/Homebrew/unpack_strategy/jar.rb
index d4170a8689c15..0be166bbaaebe 100644
--- a/Library/Homebrew/unpack_strategy/jar.rb
+++ b/Library/Homebrew/unpack_strategy/jar.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "uncompressed"
@@ -6,15 +6,12 @@
 module UnpackStrategy
   # Strategy for unpacking Java archives.
   class Jar < Uncompressed
-    extend T::Sig
-
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".apk", ".jar"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       return false unless Zip.can_extract?(path)
 
diff --git a/Library/Homebrew/unpack_strategy/lha.rb b/Library/Homebrew/unpack_strategy/lha.rb
index 543f4e4540f2d..c20f7e6521f66 100644
--- a/Library/Homebrew/unpack_strategy/lha.rb
+++ b/Library/Homebrew/unpack_strategy/lha.rb
@@ -1,36 +1,34 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking LHa archives.
   class Lha
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".lha", ".lzh"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\A..-(lh0|lh1|lz4|lz5|lzs|lh\\40|lhd|lh2|lh3|lh4|lh5)-/n)
     end
 
+    sig { returns(T::Array[Formula]) }
     def dependencies
-      @dependencies ||= [Formula["lha"]]
+      @dependencies ||= T.let([Formula["lha"]], T.nilable(T::Array[Formula]))
     end
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       system_command! "lha",
                       args:    ["xq2w=#{unpack_dir}", path],
                       env:     { "PATH" => PATH.new(Formula["lha"].opt_bin, ENV.fetch("PATH")) },
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/lua_rock.rb b/Library/Homebrew/unpack_strategy/lua_rock.rb
index 6150e2788e179..f806364a0f046 100644
--- a/Library/Homebrew/unpack_strategy/lua_rock.rb
+++ b/Library/Homebrew/unpack_strategy/lua_rock.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "uncompressed"
@@ -6,15 +6,12 @@
 module UnpackStrategy
   # Strategy for unpacking LuaRock archives.
   class LuaRock < Uncompressed
-    extend T::Sig
-
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".rock"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       return false unless Zip.can_extract?(path)
 
diff --git a/Library/Homebrew/unpack_strategy/lzip.rb b/Library/Homebrew/unpack_strategy/lzip.rb
index da8a991b9e32b..732897a9221f2 100644
--- a/Library/Homebrew/unpack_strategy/lzip.rb
+++ b/Library/Homebrew/unpack_strategy/lzip.rb
@@ -1,38 +1,36 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking lzip archives.
   class Lzip
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".lz"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\ALZIP/n)
     end
 
+    sig { returns(T::Array[Formula]) }
     def dependencies
-      @dependencies ||= [Formula["lzip"]]
+      @dependencies ||= T.let([Formula["lzip"]], T.nilable(T::Array[Formula]))
     end
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       FileUtils.cp path, unpack_dir/basename, preserve: true
       quiet_flags = verbose ? [] : ["-q"]
       system_command! "lzip",
                       args:    ["-d", *quiet_flags, unpack_dir/basename],
                       env:     { "PATH" => PATH.new(Formula["lzip"].opt_bin, ENV.fetch("PATH")) },
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/lzma.rb b/Library/Homebrew/unpack_strategy/lzma.rb
index 7ef147b61b57b..a4ff75ac0bcdf 100644
--- a/Library/Homebrew/unpack_strategy/lzma.rb
+++ b/Library/Homebrew/unpack_strategy/lzma.rb
@@ -1,38 +1,36 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking LZMA archives.
   class Lzma
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".lzma"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\A\]\000\000\200\000/n)
     end
 
+    sig { returns(T::Array[Formula]) }
     def dependencies
-      @dependencies ||= [Formula["xz"]]
+      @dependencies ||= T.let([Formula["xz"]], T.nilable(T::Array[Formula]))
     end
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       FileUtils.cp path, unpack_dir/basename, preserve: true
       quiet_flags = verbose ? [] : ["-q"]
       system_command! "unlzma",
                       args:    [*quiet_flags, "--", unpack_dir/basename],
                       env:     { "PATH" => PATH.new(Formula["xz"].opt_bin, ENV.fetch("PATH")) },
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/mercurial.rb b/Library/Homebrew/unpack_strategy/mercurial.rb
index cc27a11395c86..146f686c9c0a6 100644
--- a/Library/Homebrew/unpack_strategy/mercurial.rb
+++ b/Library/Homebrew/unpack_strategy/mercurial.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "directory"
@@ -6,19 +6,19 @@
 module UnpackStrategy
   # Strategy for unpacking Mercurial repositories.
   class Mercurial < Directory
-    using Magic
-
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
-      super && (path/".hg").directory?
+      !!(super && (path/".hg").directory?)
     end
 
     private
 
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       system_command! "hg",
                       args:    ["--cwd", path, "archive", "--subrepos", "-y", "-t", "files", unpack_dir],
                       env:     { "PATH" => PATH.new(Formula["mercurial"].opt_bin, ENV.fetch("PATH")) },
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/microsoft_office_xml.rb b/Library/Homebrew/unpack_strategy/microsoft_office_xml.rb
index 616d78bc061bb..cb54b9b1f7235 100644
--- a/Library/Homebrew/unpack_strategy/microsoft_office_xml.rb
+++ b/Library/Homebrew/unpack_strategy/microsoft_office_xml.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "uncompressed"
@@ -6,11 +6,7 @@
 module UnpackStrategy
   # Strategy for unpacking Microsoft Office documents.
   class MicrosoftOfficeXml < Uncompressed
-    extend T::Sig
-
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [
         ".doc", ".docx",
@@ -19,6 +15,7 @@ def self.extensions
       ]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       return false unless Zip.can_extract?(path)
 
diff --git a/Library/Homebrew/unpack_strategy/otf.rb b/Library/Homebrew/unpack_strategy/otf.rb
index e94eb15029083..da593812a5639 100644
--- a/Library/Homebrew/unpack_strategy/otf.rb
+++ b/Library/Homebrew/unpack_strategy/otf.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "uncompressed"
@@ -6,15 +6,12 @@
 module UnpackStrategy
   # Strategy for unpacking OpenType fonts.
   class Otf < Uncompressed
-    extend T::Sig
-
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".otf"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\AOTTO/n)
     end
diff --git a/Library/Homebrew/unpack_strategy/p7zip.rb b/Library/Homebrew/unpack_strategy/p7zip.rb
index 618ea06f23448..c1e10cfb92328 100644
--- a/Library/Homebrew/unpack_strategy/p7zip.rb
+++ b/Library/Homebrew/unpack_strategy/p7zip.rb
@@ -1,36 +1,34 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking P7ZIP archives.
   class P7Zip
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".7z"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\A7z\xBC\xAF\x27\x1C/n)
     end
 
+    sig { returns(T::Array[Formula]) }
     def dependencies
-      @dependencies ||= [Formula["p7zip"]]
+      @dependencies ||= T.let([Formula["p7zip"]], T.nilable(T::Array[Formula]))
     end
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       system_command! "7zr",
                       args:    ["x", "-y", "-bd", "-bso0", path, "-o#{unpack_dir}"],
                       env:     { "PATH" => PATH.new(Formula["p7zip"].opt_bin, ENV.fetch("PATH")) },
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/pax.rb b/Library/Homebrew/unpack_strategy/pax.rb
index 4067132c80a9b..9cbc799c23f64 100644
--- a/Library/Homebrew/unpack_strategy/pax.rb
+++ b/Library/Homebrew/unpack_strategy/pax.rb
@@ -1,32 +1,29 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking pax archives.
   class Pax
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".pax"]
     end
 
+    sig { override.params(_path: Pathname).returns(T::Boolean) }
     def self.can_extract?(_path)
       false
     end
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       system_command! "pax",
                       args:    ["-rf", path],
                       chdir:   unpack_dir,
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/pkg.rb b/Library/Homebrew/unpack_strategy/pkg.rb
index 220b86a58c9d6..585edfbea95fd 100644
--- a/Library/Homebrew/unpack_strategy/pkg.rb
+++ b/Library/Homebrew/unpack_strategy/pkg.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "uncompressed"
@@ -6,15 +6,12 @@
 module UnpackStrategy
   # Strategy for unpacking macOS package installers.
   class Pkg < Uncompressed
-    extend T::Sig
-
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".pkg", ".mkpg"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.extname.match?(/\A.m?pkg\Z/) &&
         (path.directory? || path.magic_number.match?(/\Axar!/n))
diff --git a/Library/Homebrew/unpack_strategy/rar.rb b/Library/Homebrew/unpack_strategy/rar.rb
index bd2b8042bb3d0..8336d99b08317 100644
--- a/Library/Homebrew/unpack_strategy/rar.rb
+++ b/Library/Homebrew/unpack_strategy/rar.rb
@@ -1,36 +1,34 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking RAR archives.
   class Rar
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".rar"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\ARar!/n)
     end
 
+    sig { returns(T::Array[Formula]) }
     def dependencies
-      @dependencies ||= [Formula["unrar"]]
+      @dependencies ||= T.let([Formula["libarchive"]], T.nilable(T::Array[Formula]))
     end
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
-      system_command! "unrar",
-                      args:    ["x", "-inul", path, unpack_dir],
-                      env:     { "PATH" => PATH.new(Formula["unrar"].opt_bin, ENV.fetch("PATH")) },
-                      verbose: verbose
+      system_command! "bsdtar",
+                      args:    ["x", "-f", path, "-C", unpack_dir],
+                      env:     { "PATH" => PATH.new(Formula["libarchive"].opt_bin, ENV.fetch("PATH")) },
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/self_extracting_executable.rb b/Library/Homebrew/unpack_strategy/self_extracting_executable.rb
index 0e99278711db3..58bad3be74057 100644
--- a/Library/Homebrew/unpack_strategy/self_extracting_executable.rb
+++ b/Library/Homebrew/unpack_strategy/self_extracting_executable.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "generic_unar"
@@ -6,15 +6,12 @@
 module UnpackStrategy
   # Strategy for unpacking self-extracting executables.
   class SelfExtractingExecutable < GenericUnar
-    extend T::Sig
-
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       []
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\AMZ/n) &&
         path.file_type.include?("self-extracting archive")
diff --git a/Library/Homebrew/unpack_strategy/sit.rb b/Library/Homebrew/unpack_strategy/sit.rb
index 687e7d0e64025..82c48e6d19ba2 100644
--- a/Library/Homebrew/unpack_strategy/sit.rb
+++ b/Library/Homebrew/unpack_strategy/sit.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "generic_unar"
@@ -6,15 +6,12 @@
 module UnpackStrategy
   # Strategy for unpacking Stuffit archives.
   class Sit < GenericUnar
-    extend T::Sig
-
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".sit"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\AStuffIt/n)
     end
diff --git a/Library/Homebrew/unpack_strategy/subversion.rb b/Library/Homebrew/unpack_strategy/subversion.rb
index dd3355825b199..81c037d73e81d 100644
--- a/Library/Homebrew/unpack_strategy/subversion.rb
+++ b/Library/Homebrew/unpack_strategy/subversion.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "directory"
@@ -6,19 +6,19 @@
 module UnpackStrategy
   # Strategy for unpacking Subversion repositories.
   class Subversion < Directory
-    using Magic
-
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
-      super && (path/".svn").directory?
+      !!(super && (path/".svn").directory?)
     end
 
     private
 
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       system_command! "svn",
                       args:    ["export", "--force", ".", unpack_dir],
                       chdir:   path.to_s,
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/tar.rb b/Library/Homebrew/unpack_strategy/tar.rb
index 9b0797cfa1cbd..ae3ff08cd233b 100644
--- a/Library/Homebrew/unpack_strategy/tar.rb
+++ b/Library/Homebrew/unpack_strategy/tar.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "system_command"
@@ -6,14 +6,10 @@
 module UnpackStrategy
   # Strategy for unpacking tar archives.
   class Tar
-    extend T::Sig
-
     include UnpackStrategy
     extend SystemCommand::Mixin
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [
         ".tar",
@@ -21,10 +17,12 @@ def self.extensions
         ".tgz", ".tar.gz",
         ".tlzma", ".tar.lzma",
         ".txz", ".tar.xz",
-        ".tar.zst"
+        ".tar.zst",
+        ".crate"
       ]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       return true if path.magic_number.match?(/\A.{257}ustar/n)
 
@@ -37,9 +35,9 @@ def self.can_extract?(path)
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
-      Dir.mktmpdir do |tmpdir|
+      Dir.mktmpdir("homebrew-tar", HOMEBREW_TEMP) do |tmpdir|
         tar_path = if DependencyCollector.tar_needs_xz_dependency? && Xz.can_extract?(path)
           subextract(Xz, Pathname(tmpdir), verbose)
         elsif Zstd.can_extract?(path)
@@ -52,7 +50,7 @@ def extract_to_dir(unpack_dir, basename:, verbose:)
                         args:    ["--extract", "--no-same-owner",
                                   "--file", tar_path,
                                   "--directory", unpack_dir],
-                        verbose: verbose
+                        verbose:
       end
     end
 
@@ -60,7 +58,7 @@ def extract_to_dir(unpack_dir, basename:, verbose:)
       params(extractor: T.any(T.class_of(Xz), T.class_of(Zstd)), dir: Pathname, verbose: T::Boolean).returns(Pathname)
     }
     def subextract(extractor, dir, verbose)
-      extractor.new(path).extract(to: dir, verbose: verbose)
+      extractor.new(path).extract(to: dir, verbose:)
       T.must(dir.children.first)
     end
   end
diff --git a/Library/Homebrew/unpack_strategy/ttf.rb b/Library/Homebrew/unpack_strategy/ttf.rb
index 38b44879de5fb..c240f936792b6 100644
--- a/Library/Homebrew/unpack_strategy/ttf.rb
+++ b/Library/Homebrew/unpack_strategy/ttf.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "uncompressed"
@@ -6,15 +6,12 @@
 module UnpackStrategy
   # Strategy for unpacking TrueType fonts.
   class Ttf < Uncompressed
-    extend T::Sig
-
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".ttc", ".ttf"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       # TrueType Font
       path.magic_number.match?(/\A\000\001\000\000\000/n) ||
diff --git a/Library/Homebrew/unpack_strategy/uncompressed.rb b/Library/Homebrew/unpack_strategy/uncompressed.rb
index 16ced6ca1669f..58e70082e96be 100644
--- a/Library/Homebrew/unpack_strategy/uncompressed.rb
+++ b/Library/Homebrew/unpack_strategy/uncompressed.rb
@@ -1,22 +1,34 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking uncompressed files.
   class Uncompressed
-    extend T::Sig
-
     include UnpackStrategy
 
-    def extract_nestedly(prioritise_extension: false, **options)
-      extract(**options)
+    sig { override.returns(T::Array[String]) }
+    def self.extensions = []
+
+    sig { override.params(_path: Pathname).returns(T::Boolean) }
+    def self.can_extract?(_path) = false
+
+    sig {
+      params(
+        to:                   T.nilable(Pathname),
+        basename:             T.nilable(T.any(String, Pathname)),
+        verbose:              T::Boolean,
+        prioritize_extension: T::Boolean,
+      ).returns(T.untyped)
+    }
+    def extract_nestedly(to: nil, basename: nil, verbose: false, prioritize_extension: false)
+      extract(to:, basename:, verbose:)
     end
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
-    def extract_to_dir(unpack_dir, basename:, verbose:)
-      FileUtils.cp path, unpack_dir/basename, preserve: true, verbose: verbose
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
+    def extract_to_dir(unpack_dir, basename:, verbose: false)
+      FileUtils.cp path, unpack_dir/basename.sub(/^[\da-f]{64}--/, ""), preserve: true, verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/xar.rb b/Library/Homebrew/unpack_strategy/xar.rb
index ce35a0683ab56..d6562f8d22f5f 100644
--- a/Library/Homebrew/unpack_strategy/xar.rb
+++ b/Library/Homebrew/unpack_strategy/xar.rb
@@ -1,31 +1,28 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking xar archives.
   class Xar
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".xar"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\Axar!/n)
     end
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       system_command! "xar",
                       args:    ["-x", "-f", path, "-C", unpack_dir],
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/xz.rb b/Library/Homebrew/unpack_strategy/xz.rb
index 61e1b2c3ab9ce..55b6d289deda2 100644
--- a/Library/Homebrew/unpack_strategy/xz.rb
+++ b/Library/Homebrew/unpack_strategy/xz.rb
@@ -1,38 +1,36 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking xz archives.
   class Xz
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".xz"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\A\xFD7zXZ\x00/n)
     end
 
+    sig { returns(T::Array[Formula]) }
     def dependencies
-      @dependencies ||= [Formula["xz"]]
+      @dependencies ||= T.let([Formula["xz"]], T.nilable(T::Array[Formula]))
     end
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       FileUtils.cp path, unpack_dir/basename, preserve: true
       quiet_flags = verbose ? [] : ["-q"]
       system_command! "unxz",
                       args:    [*quiet_flags, "-T0", "--", unpack_dir/basename],
                       env:     { "PATH" => PATH.new(Formula["xz"].opt_bin, ENV.fetch("PATH")) },
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unpack_strategy/zip.rb b/Library/Homebrew/unpack_strategy/zip.rb
index 6f8e6f74269db..28e413e00adad 100644
--- a/Library/Homebrew/unpack_strategy/zip.rb
+++ b/Library/Homebrew/unpack_strategy/zip.rb
@@ -4,18 +4,14 @@
 module UnpackStrategy
   # Strategy for unpacking ZIP archives.
   class Zip
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".zip"]
     end
 
-    sig { params(path: Pathname).returns(T::Boolean) }
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\APK(\003\004|\005\006)/n)
     end
@@ -27,10 +23,13 @@ def self.can_extract?(path)
               .returns(SystemCommand::Result)
     }
     def extract_to_dir(unpack_dir, basename:, verbose:)
-      unzip = begin
-        Formula["unzip"]
-      rescue FormulaUnavailableError
-        nil
+      odebug "in unpack_strategy, zip, extract_to_dir, verbose: #{verbose.inspect}"
+      unzip = if which("unzip").blank?
+        begin
+          Formula["unzip"]
+        rescue FormulaUnavailableError
+          nil
+        end
       end
 
       with_env(TZ: "UTC") do
@@ -38,7 +37,7 @@ def extract_to_dir(unpack_dir, basename:, verbose:)
         result = system_command! "unzip",
                                  args:         [*quiet_flags, "-o", path, "-d", unpack_dir],
                                  env:          { "PATH" => PATH.new(unzip&.opt_bin, ENV.fetch("PATH")) },
-                                 verbose:      verbose,
+                                 verbose:,
                                  print_stderr: false
 
         FileUtils.rm_rf unpack_dir/"__MACOSX"
@@ -49,4 +48,4 @@ def extract_to_dir(unpack_dir, basename:, verbose:)
   end
 end
 
-require "extend/os/mac/unpack_strategy/zip" if OS.mac?
+require "extend/os/unpack_strategy/zip"
diff --git a/Library/Homebrew/unpack_strategy/zstd.rb b/Library/Homebrew/unpack_strategy/zstd.rb
index 4e77184977242..38a3328f325e3 100644
--- a/Library/Homebrew/unpack_strategy/zstd.rb
+++ b/Library/Homebrew/unpack_strategy/zstd.rb
@@ -1,38 +1,36 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module UnpackStrategy
   # Strategy for unpacking zstd archives.
   class Zstd
-    extend T::Sig
-
     include UnpackStrategy
 
-    using Magic
-
-    sig { returns(T::Array[String]) }
+    sig { override.returns(T::Array[String]) }
     def self.extensions
       [".zst"]
     end
 
+    sig { override.params(path: Pathname).returns(T::Boolean) }
     def self.can_extract?(path)
       path.magic_number.match?(/\x28\xB5\x2F\xFD/n)
     end
 
+    sig { returns(T::Array[Formula]) }
     def dependencies
-      @dependencies ||= [Formula["zstd"]]
+      @dependencies ||= T.let([Formula["zstd"]], T.nilable(T::Array[Formula]))
     end
 
     private
 
-    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).returns(T.untyped) }
+    sig { override.params(unpack_dir: Pathname, basename: Pathname, verbose: T::Boolean).void }
     def extract_to_dir(unpack_dir, basename:, verbose:)
       FileUtils.cp path, unpack_dir/basename, preserve: true
       quiet_flags = verbose ? [] : ["-q"]
       system_command! "unzstd",
                       args:    [*quiet_flags, "-T0", "--rm", "--", unpack_dir/basename],
                       env:     { "PATH" => PATH.new(Formula["zstd"].opt_bin, ENV.fetch("PATH")) },
-                      verbose: verbose
+                      verbose:
     end
   end
 end
diff --git a/Library/Homebrew/unversioned_cask_checker.rb b/Library/Homebrew/unversioned_cask_checker.rb
index af6a659573f6a..657050746983e 100644
--- a/Library/Homebrew/unversioned_cask_checker.rb
+++ b/Library/Homebrew/unversioned_cask_checker.rb
@@ -1,19 +1,18 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "bundle_version"
 require "cask/cask"
 require "cask/installer"
+require "system_command"
 
 module Homebrew
   # Check unversioned casks for updates by extracting their
   # contents and guessing the version from contained files.
-  #
-  # @api private
   class UnversionedCaskChecker
-    extend T::Sig
+    include SystemCommand::Mixin
 
-    sig {  returns(Cask::Cask) }
+    sig { returns(Cask::Cask) }
     attr_reader :cask
 
     sig { params(cask: Cask::Cask).void }
@@ -31,11 +30,41 @@ def apps
       @apps ||= @cask.artifacts.select { |a| a.is_a?(Cask::Artifact::App) }
     end
 
+    sig { returns(T::Array[Cask::Artifact::KeyboardLayout]) }
+    def keyboard_layouts
+      @keyboard_layouts ||= @cask.artifacts.select { |a| a.is_a?(Cask::Artifact::KeyboardLayout) }
+    end
+
     sig { returns(T::Array[Cask::Artifact::Qlplugin]) }
     def qlplugins
       @qlplugins ||= @cask.artifacts.select { |a| a.is_a?(Cask::Artifact::Qlplugin) }
     end
 
+    sig { returns(T::Array[Cask::Artifact::Dictionary]) }
+    def dictionaries
+      @dictionaries ||= @cask.artifacts.select { |a| a.is_a?(Cask::Artifact::Dictionary) }
+    end
+
+    sig { returns(T::Array[Cask::Artifact::ScreenSaver]) }
+    def screen_savers
+      @screen_savers ||= @cask.artifacts.select { |a| a.is_a?(Cask::Artifact::ScreenSaver) }
+    end
+
+    sig { returns(T::Array[Cask::Artifact::Colorpicker]) }
+    def colorpickers
+      @colorpickers ||= @cask.artifacts.select { |a| a.is_a?(Cask::Artifact::Colorpicker) }
+    end
+
+    sig { returns(T::Array[Cask::Artifact::Mdimporter]) }
+    def mdimporters
+      @mdimporters ||= @cask.artifacts.select { |a| a.is_a?(Cask::Artifact::Mdimporter) }
+    end
+
+    sig { returns(T::Array[Cask::Artifact::Installer]) }
+    def installers
+      @installers ||= @cask.artifacts.select { |a| a.is_a?(Cask::Artifact::Installer) }
+    end
+
     sig { returns(T::Array[Cask::Artifact::Pkg]) }
     def pkgs
       @pkgs ||= @cask.artifacts.select { |a| a.is_a?(Cask::Artifact::Pkg) }
@@ -83,23 +112,43 @@ def all_versions
         versions[id] = version if id && version
       end
 
-      Dir.mktmpdir do |dir|
+      Dir.mktmpdir("cask-checker", HOMEBREW_TEMP) do |dir|
         dir = Pathname(dir)
 
         installer.extract_primary_container(to: dir)
 
-        info_plist_paths = apps.concat(qlplugins).flat_map do |artifact|
-          top_level_info_plists(Pathname.glob(dir/"**"/artifact.source.basename/"Contents"/"Info.plist")).sort
+        info_plist_paths = [
+          *apps,
+          *keyboard_layouts,
+          *mdimporters,
+          *colorpickers,
+          *dictionaries,
+          *qlplugins,
+          *installers,
+          *screen_savers,
+        ].flat_map do |artifact|
+          sources = if artifact.is_a?(Cask::Artifact::Installer)
+            # Installers are sometimes contained within an `.app`, so try both.
+            installer_path = artifact.path
+            installer_path.ascend
+                          .select { |path| path == installer_path || path.extname == ".app" }
+                          .sort
+          else
+            [artifact.source.basename]
+          end
+
+          sources.flat_map do |source|
+            top_level_info_plists(Pathname.glob(dir/"**"/source/"Contents"/"Info.plist")).sort
+          end
         end
 
         info_plist_paths.each(&parse_info_plist)
 
-        pkg_paths = pkgs.flat_map do |pkg|
-          Pathname.glob(dir/"**"/pkg.path.basename).sort
-        end
+        pkg_paths = pkgs.flat_map { |pkg| Pathname.glob(dir/"**"/pkg.path.basename).sort }
+        pkg_paths = Pathname.glob(dir/"**"/"*.pkg").sort if pkg_paths.empty?
 
         pkg_paths.each do |pkg_path|
-          Dir.mktmpdir do |extract_dir|
+          Dir.mktmpdir("cask-checker", HOMEBREW_TEMP) do |extract_dir|
             extract_dir = Pathname(extract_dir)
             FileUtils.rmdir extract_dir
 
@@ -110,7 +159,7 @@ def all_versions
             top_level_info_plist_paths.each(&parse_info_plist)
           ensure
             Cask::Utils.gain_permissions_remove(extract_dir)
-            extract_dir.mkpath
+            Pathname(extract_dir).mkpath
           end
         end
 
@@ -127,7 +176,7 @@ def guess_cask_version
         return
       end
 
-      Dir.mktmpdir do |dir|
+      Dir.mktmpdir("cask-checker", HOMEBREW_TEMP) do |dir|
         dir = Pathname(dir)
 
         installer.then do |i|
@@ -157,7 +206,7 @@ def guess_cask_version
             .plist
             .map { |package| package.fetch("Package") }
 
-          Dir.mktmpdir do |extract_dir|
+          Dir.mktmpdir("cask-checker", HOMEBREW_TEMP) do |extract_dir|
             extract_dir = Pathname(extract_dir)
             FileUtils.rmdir extract_dir
 
@@ -171,8 +220,8 @@ def guess_cask_version
             top_level_info_plist_paths = top_level_info_plists(Pathname.glob(extract_dir/"**/Contents/Info.plist"))
 
             unique_info_plist_versions =
-              top_level_info_plist_paths.map { |i| BundleVersion.from_info_plist(i)&.nice_version }
-                                        .compact.uniq
+              top_level_info_plist_paths.filter_map { |i| BundleVersion.from_info_plist(i)&.nice_version }
+                                        .uniq
             return unique_info_plist_versions.first if unique_info_plist_versions.count == 1
 
             package_info_path = extract_dir/"PackageInfo"
@@ -204,7 +253,7 @@ def guess_cask_version
                                  }.uniq
           ensure
             Cask::Utils.gain_permissions_remove(extract_dir)
-            extract_dir.mkpath
+            Pathname(extract_dir).mkpath
           end
         end
 
diff --git a/Library/Homebrew/upgrade.rb b/Library/Homebrew/upgrade.rb
index c9f0acc576d8f..8fa8df49adfaa 100644
--- a/Library/Homebrew/upgrade.rb
+++ b/Library/Homebrew/upgrade.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "reinstall"
@@ -10,21 +10,20 @@
 
 module Homebrew
   # Helper functions for upgrading formulae.
-  #
-  # @api private
   module Upgrade
-    module_function
-
-    def upgrade_formulae(
+    def self.upgrade_formulae(
       formulae_to_install,
       flags:,
       dry_run: false,
       installed_on_request: false,
       force_bottle: false,
       build_from_source_formulae: [],
+      dependents: false,
       interactive: false,
       keep_tmp: false,
+      debug_symbols: false,
       force: false,
+      overwrite: false,
       debug: false,
       quiet: false,
       verbose: false
@@ -50,24 +49,34 @@ def upgrade_formulae(
         raise CyclicDependencyError, dependency_graph.strongly_connected_components if Homebrew::EnvConfig.developer?
       end
 
-      formula_installers = formulae_to_install.map do |formula|
-        Migrator.migrate_if_needed(formula, force: force, dry_run: dry_run)
+      formula_installers = formulae_to_install.filter_map do |formula|
+        Migrator.migrate_if_needed(formula, force:, dry_run:)
         begin
           fi = create_formula_installer(
             formula,
-            flags:                      flags,
-            installed_on_request:       installed_on_request,
-            force_bottle:               force_bottle,
-            build_from_source_formulae: build_from_source_formulae,
-            interactive:                interactive,
-            keep_tmp:                   keep_tmp,
-            force:                      force,
-            debug:                      debug,
-            quiet:                      quiet,
-            verbose:                    verbose,
+            flags:,
+            installed_on_request:,
+            force_bottle:,
+            build_from_source_formulae:,
+            interactive:,
+            keep_tmp:,
+            debug_symbols:,
+            force:,
+            overwrite:,
+            debug:,
+            quiet:,
+            verbose:,
           )
           unless dry_run
             fi.prelude
+
+            # Don't need to install this bottle if all of the runtime
+            # dependencies have the same or newer version already installed.
+            next if dependents && fi.bottle_tab_runtime_dependencies.presence&.all? do |dependency, hash|
+              minimum_version = Version.new(hash["version"]) if hash["version"].present?
+              Dependency.new(dependency).installed?(minimum_version:, minimum_revision: hash["revision"])
+            end
+
             fi.fetch
           end
           fi
@@ -78,49 +87,31 @@ def upgrade_formulae(
           ofail "#{formula}: #{e}"
           nil
         end
-      end.compact
+      end
 
       formula_installers.each do |fi|
-        upgrade_formula(fi, dry_run: dry_run, verbose: verbose)
-        Cleanup.install_formula_clean!(fi.formula, dry_run: dry_run)
+        upgrade_formula(fi, dry_run:, verbose:)
+        Cleanup.install_formula_clean!(fi.formula, dry_run:)
       end
     end
 
-    def outdated_kegs(formula)
+    private_class_method def self.outdated_kegs(formula)
       [formula, *formula.old_installed_formulae].map(&:linked_keg)
                                                 .select(&:directory?)
                                                 .map { |k| Keg.new(k.resolved_path) }
     end
 
-    def print_dry_run_dependencies(formula, fi_deps)
-      return if fi_deps.empty?
-
-      plural = "dependency".pluralize(fi_deps.count)
-      ohai "Would upgrade #{fi_deps.count} #{plural} for #{formula.full_specified_name}:"
-      formulae_upgrades = fi_deps.map(&:first).map(&:to_formula).map do |f|
-        name = f.full_specified_name
-        if f.optlinked?
-          "#{name} #{Keg.new(f.opt_prefix).version} -> #{f.pkg_version}"
-        else
-          "#{name} #{f.pkg_version}"
-        end
-      end
-      puts formulae_upgrades.join(", ")
-    end
-
-    def print_upgrade_message(formula, fi_options)
+    private_class_method def self.print_upgrade_message(formula, fi_options)
       version_upgrade = if formula.optlinked?
         "#{Keg.new(formula.opt_prefix).version} -> #{formula.pkg_version}"
       else
         "-> #{formula.pkg_version}"
       end
-      oh1 <<~EOS
-        Upgrading #{Formatter.identifier(formula.full_specified_name)}
-          #{version_upgrade} #{fi_options.to_a.join(" ")}
-      EOS
+      oh1 "Upgrading #{Formatter.identifier(formula.full_specified_name)}"
+      puts "  #{version_upgrade} #{fi_options.to_a.join(" ")}"
     end
 
-    def create_formula_installer(
+    private_class_method def self.create_formula_installer(
       formula,
       flags:,
       installed_on_request: false,
@@ -128,7 +119,9 @@ def create_formula_installer(
       build_from_source_formulae: [],
       interactive: false,
       keep_tmp: false,
+      debug_symbols: false,
       force: false,
+      overwrite: false,
       debug: false,
       quiet: false,
       verbose: false
@@ -141,7 +134,7 @@ def create_formula_installer(
 
       if formula.opt_prefix.directory?
         keg = Keg.new(formula.opt_prefix.resolved_path)
-        tab = Tab.for_keg(keg)
+        tab = keg.tab
       end
 
       build_options = BuildOptions.new(Options.create(flags), formula.options)
@@ -152,41 +145,48 @@ def create_formula_installer(
       FormulaInstaller.new(
         formula,
         **{
-          options:                    options,
+          options:,
           link_keg:                   keg_had_linked_opt ? keg_was_linked : nil,
           installed_as_dependency:    tab&.installed_as_dependency,
           installed_on_request:       installed_on_request || tab&.installed_on_request,
           build_bottle:               tab&.built_bottle?,
-          force_bottle:               force_bottle,
-          build_from_source_formulae: build_from_source_formulae,
-          interactive:                interactive,
-          keep_tmp:                   keep_tmp,
-          force:                      force,
-          debug:                      debug,
-          quiet:                      quiet,
-          verbose:                    verbose,
+          force_bottle:,
+          build_from_source_formulae:,
+          interactive:,
+          keep_tmp:,
+          debug_symbols:,
+          force:,
+          overwrite:,
+          debug:,
+          quiet:,
+          verbose:,
         }.compact,
       )
     end
-    private_class_method :create_formula_installer
 
-    def upgrade_formula(formula_installer, dry_run: false, verbose: false)
+    def self.upgrade_formula(formula_installer, dry_run: false, verbose: false)
       formula = formula_installer.formula
 
       if dry_run
-        print_dry_run_dependencies(formula, formula_installer.compute_dependencies)
+        Install.print_dry_run_dependencies(formula, formula_installer.compute_dependencies) do |f|
+          name = f.full_specified_name
+          if f.optlinked?
+            "#{name} #{Keg.new(f.opt_prefix).version} -> #{f.pkg_version}"
+          else
+            "#{name} #{f.pkg_version}"
+          end
+        end
         return
       end
 
       install_formula(formula_installer, upgrade: true)
     rescue BuildError => e
-      e.dump(verbose: verbose)
+      e.dump(verbose:)
       puts
       Homebrew.failed = true
     end
-    private_class_method :upgrade_formula
 
-    def install_formula(formula_installer, upgrade:)
+    def self.install_formula(formula_installer, upgrade:)
       formula = formula_installer.formula
 
       formula_installer.check_installation_already_attempted
@@ -214,13 +214,13 @@ def install_formula(formula_installer, upgrade:)
     ensure
       # restore previous installation state if build failed
       begin
-        linked_kegs.each(&:link) if linked_kegs.present? && !f.latest_version_installed?
+        linked_kegs&.each(&:link) unless formula.latest_version_installed?
       rescue
         nil
       end
     end
 
-    def check_broken_dependents(installed_formulae)
+    private_class_method def self.check_broken_dependents(installed_formulae)
       CacheStoreDatabase.use(:linkage) do |db|
         installed_formulae.flat_map(&:runtime_installed_formula_dependents)
                           .uniq
@@ -245,7 +245,7 @@ def self.puts_no_installed_dependents_check_disable_message_if_not_already!
       @puts_no_installed_dependents_check_disable_message_if_not_already = true
     end
 
-    def check_installed_dependents(
+    def self.check_installed_dependents(
       formulae,
       flags:,
       dry_run: false,
@@ -254,16 +254,19 @@ def check_installed_dependents(
       build_from_source_formulae: [],
       interactive: false,
       keep_tmp: false,
+      debug_symbols: false,
       force: false,
       debug: false,
       quiet: false,
       verbose: false
     )
       if Homebrew::EnvConfig.no_installed_dependents_check?
-        opoo <<~EOS
-          HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK is set: not checking for outdated
-          dependents or dependents with broken linkage!
-        EOS
+        unless Homebrew::EnvConfig.no_env_hints?
+          opoo <<~EOS
+            HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK is set: not checking for outdated
+            dependents or dependents with broken linkage!
+          EOS
+        end
         return
       end
 
@@ -273,6 +276,7 @@ def check_installed_dependents(
 
       already_broken_dependents = check_broken_dependents(installed_formulae)
 
+      # TODO: this should be refactored to use FormulaInstaller new logic
       outdated_dependents =
         installed_formulae.flat_map(&:runtime_installed_formula_dependents)
                           .uniq
@@ -303,8 +307,8 @@ def check_installed_dependents(
                            .sort { |a, b| depends_on(a, b) }
 
       if pinned_dependents.present?
-        plural = "dependent".pluralize(pinned_dependents.count)
-        ohai "Not upgrading #{pinned_dependents.count} pinned #{plural}:"
+        plural = Utils.pluralize("dependent", pinned_dependents.count)
+        opoo "Not upgrading #{pinned_dependents.count} pinned #{plural}:"
         puts(pinned_dependents.map do |f|
           "#{f.full_specified_name} #{f.pkg_version}"
         end.join(", "))
@@ -314,10 +318,10 @@ def check_installed_dependents(
       if upgradeable_dependents.blank?
         ohai "No outdated dependents to upgrade!" unless dry_run
       else
-        dependent_plural = "dependent".pluralize(upgradeable_dependents.count)
-        formula_plural = "formula".pluralize(installed_formulae.count)
+        formula_plural = Utils.pluralize("formula", installed_formulae.count, plural: "e")
         upgrade_verb = dry_run ? "Would upgrade" : "Upgrading"
-        ohai "#{upgrade_verb} #{upgradeable_dependents.count} #{dependent_plural} of upgraded #{formula_plural}:"
+        ohai "#{upgrade_verb} #{Utils.pluralize("dependent", upgradeable_dependents.count,
+                                                include_count: true)} of upgraded #{formula_plural}:"
         Upgrade.puts_no_installed_dependents_check_disable_message_if_not_already!
         formulae_upgrades = upgradeable_dependents.map do |f|
           name = f.full_specified_name
@@ -333,16 +337,18 @@ def check_installed_dependents(
       unless dry_run
         upgrade_formulae(
           upgradeable_dependents,
-          flags:                      flags,
-          installed_on_request:       installed_on_request,
-          force_bottle:               force_bottle,
-          build_from_source_formulae: build_from_source_formulae,
-          interactive:                interactive,
-          keep_tmp:                   keep_tmp,
-          force:                      force,
-          debug:                      debug,
-          quiet:                      quiet,
-          verbose:                    verbose,
+          flags:,
+          installed_on_request:,
+          force_bottle:,
+          build_from_source_formulae:,
+          dependents:                 true,
+          interactive:,
+          keep_tmp:,
+          debug_symbols:,
+          force:,
+          debug:,
+          quiet:,
+          verbose:,
         )
       end
 
@@ -378,7 +384,7 @@ def check_installed_dependents(
       # Print the pinned dependents.
       if outdated_pinned_broken_dependents.present?
         count = outdated_pinned_broken_dependents.count
-        plural = "dependent".pluralize(outdated_pinned_broken_dependents.count)
+        plural = Utils.pluralize("dependent", outdated_pinned_broken_dependents.count)
         onoe "Not reinstalling #{count} broken and outdated, but pinned #{plural}:"
         $stderr.puts(outdated_pinned_broken_dependents.map do |f|
           "#{f.full_specified_name} #{f.pkg_version}"
@@ -389,9 +395,8 @@ def check_installed_dependents(
       if reinstallable_broken_dependents.blank?
         ohai "No broken dependents to reinstall!"
       else
-        count = reinstallable_broken_dependents.count
-        plural = "dependent".pluralize(reinstallable_broken_dependents.count)
-        ohai "Reinstalling #{count} #{plural} with broken linkage from source:"
+        ohai "Reinstalling #{Utils.pluralize("dependent", reinstallable_broken_dependents.count,
+                                             include_count: true)} with broken linkage from source:"
         Upgrade.puts_no_installed_dependents_check_disable_message_if_not_already!
         puts reinstallable_broken_dependents.map(&:full_specified_name)
                                             .join(", ")
@@ -400,17 +405,18 @@ def check_installed_dependents(
       return if dry_run
 
       reinstallable_broken_dependents.each do |formula|
-        Homebrew.reinstall_formula(
+        Reinstall.reinstall_formula(
           formula,
-          flags:                      flags,
-          force_bottle:               force_bottle,
+          flags:,
+          force_bottle:,
           build_from_source_formulae: build_from_source_formulae + [formula.full_name],
-          interactive:                interactive,
-          keep_tmp:                   keep_tmp,
-          force:                      force,
-          debug:                      debug,
-          quiet:                      quiet,
-          verbose:                    verbose,
+          interactive:,
+          keep_tmp:,
+          debug_symbols:,
+          force:,
+          debug:,
+          quiet:,
+          verbose:,
         )
       rescue FormulaInstallationAlreadyAttemptedError
         # We already attempted to reinstall f as part of the dependency tree of
@@ -419,21 +425,20 @@ def check_installed_dependents(
       rescue CannotInstallFormulaError, DownloadError => e
         ofail e
       rescue BuildError => e
-        e.dump(verbose: verbose)
+        e.dump(verbose:)
         puts
         Homebrew.failed = true
       end
     end
 
-    def depends_on(a, b)
-      if a.any_installed_keg
-         &.runtime_dependencies
-         &.any? { |d| d["full_name"] == b.full_name }
+    private_class_method def self.depends_on(one, two)
+      if one.any_installed_keg
+            &.runtime_dependencies
+            &.any? { |dependency| dependency["full_name"] == two.full_name }
         1
       else
-        a <=> b
+        one <=> two
       end
     end
-    private_class_method :depends_on
   end
 end
diff --git a/Library/Homebrew/url.rb b/Library/Homebrew/url.rb
new file mode 100644
index 0000000000000..e0ccdb9ee8f54
--- /dev/null
+++ b/Library/Homebrew/url.rb
@@ -0,0 +1,31 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+require "version"
+
+class URL
+  attr_reader :specs, :using
+
+  sig { params(url: String, specs: T::Hash[Symbol, T.untyped]).void }
+  def initialize(url, specs = {})
+    @url = url.freeze
+    @specs = specs.dup
+    @using = @specs.delete(:using)
+    @specs.freeze
+  end
+
+  sig { returns(String) }
+  def to_s
+    @url
+  end
+
+  sig { returns(T.class_of(AbstractDownloadStrategy)) }
+  def download_strategy
+    @download_strategy ||= DownloadStrategyDetector.detect(@url, @using)
+  end
+
+  sig { returns(Version) }
+  def version
+    @version ||= Version.detect(@url, **@specs)
+  end
+end
diff --git a/Library/Homebrew/utils.rb b/Library/Homebrew/utils.rb
index 9104ba1b376f6..aad43bec80604 100644
--- a/Library/Homebrew/utils.rb
+++ b/Library/Homebrew/utils.rb
@@ -1,30 +1,12 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "time"
-
-require "utils/analytics"
-require "utils/curl"
-require "utils/fork"
-require "utils/formatter"
-require "utils/gems"
-require "utils/git"
-require "utils/git_repository"
-require "utils/github"
-require "utils/inreplace"
-require "utils/link"
-require "utils/popen"
-require "utils/repology"
-require "utils/svn"
-require "utils/tty"
-require "tap_constants"
+require "context"
 
 module Homebrew
   extend Context
 
-  module_function
-
-  def _system(cmd, *args, **options)
+  def self._system(cmd, *args, **options)
     pid = fork do
       yield if block_given?
       args.map!(&:to_s)
@@ -39,16 +21,18 @@ def _system(cmd, *args, **options)
     $CHILD_STATUS.success?
   end
 
-  def system(cmd, *args, **options)
+  def self.system(cmd, *args, **options)
     if verbose?
-      puts "#{cmd} #{args * " "}".gsub(RUBY_PATH, "ruby")
-                                 .gsub($LOAD_PATH.join(File::PATH_SEPARATOR).to_s, "$LOAD_PATH")
+      out = (options[:out] == :err) ? $stderr : $stdout
+      out.puts "#{cmd} #{args * " "}".gsub(RUBY_PATH, "ruby")
+                                     .gsub($LOAD_PATH.join(File::PATH_SEPARATOR).to_s, "$LOAD_PATH")
     end
     _system(cmd, *args, **options)
   end
 
   # rubocop:disable Style/GlobalVars
-  def inject_dump_stats!(the_module, pattern)
+  sig { params(the_module: Module, pattern: Regexp).void }
+  def self.inject_dump_stats!(the_module, pattern)
     @injected_dump_stat_modules ||= {}
     @injected_dump_stat_modules[the_module] ||= []
     injected_methods = @injected_dump_stat_modules[the_module]
@@ -58,10 +42,12 @@ def inject_dump_stats!(the_module, pattern)
 
         method = instance_method(name)
         define_method(name) do |*args, &block|
+          require "time"
+
           time = Time.now
 
           begin
-            method.bind(self).call(*args, &block)
+            method.bind_call(self, *args, &block)
           ensure
             $times[name] ||= 0
             $times[name] += Time.now - time
@@ -76,559 +62,105 @@ def inject_dump_stats!(the_module, pattern)
     at_exit do
       col_width = [$times.keys.map(&:size).max.to_i + 2, 15].max
       $times.sort_by { |_k, v| v }.each do |method, time|
-        puts format("%<method>-#{col_width}s %<time>0.4f sec", method: "#{method}:", time: time)
+        puts format("%<method>-#{col_width}s %<time>0.4f sec", method: "#{method}:", time:)
       end
     end
   end
   # rubocop:enable Style/GlobalVars
 end
 
-module Kernel
-  extend T::Sig
-
-  def require?(path)
-    return false if path.nil?
-
-    require path
-    true
-  rescue LoadError => e
-    # we should raise on syntax errors but not if the file doesn't exist.
-    raise unless e.message.include?(path)
-  end
-
-  def ohai_title(title)
-    verbose = if respond_to?(:verbose?)
-      verbose?
-    else
-      Context.current.verbose?
-    end
-
-    title = Tty.truncate(title) if $stdout.tty? && !verbose
-    Formatter.headline(title, color: :blue)
-  end
-
-  def ohai(title, *sput)
-    puts ohai_title(title)
-    puts sput
-  end
-
-  def odebug(title, *sput, always_display: false)
-    debug = if respond_to?(:debug)
-      debug?
-    else
-      Context.current.debug?
-    end
-
-    return if !debug && !always_display
-
-    puts Formatter.headline(title, color: :magenta)
-    puts sput unless sput.empty?
-  end
-
-  def oh1(title, truncate: :auto)
-    verbose = if respond_to?(:verbose?)
-      verbose?
-    else
-      Context.current.verbose?
-    end
-
-    title = Tty.truncate(title) if $stdout.tty? && !verbose && truncate == :auto
-    puts Formatter.headline(title, color: :green)
-  end
-
-  # Print a message prefixed with "Warning" (do this rarely).
-  def opoo(message)
-    Tty.with($stderr) do |stderr|
-      stderr.puts Formatter.warning(message, label: "Warning")
-    end
-  end
-
-  # Print a message prefixed with "Error".
-  def onoe(message)
-    Tty.with($stderr) do |stderr|
-      stderr.puts Formatter.error(message, label: "Error")
-    end
-  end
-
-  def ofail(error)
-    onoe error
-    Homebrew.failed = true
-  end
-
-  def odie(error)
-    onoe error
-    exit 1
-  end
-
-  def odeprecated(method, replacement = nil,
-                  disable:                false,
-                  disable_on:             nil,
-                  disable_for_developers: true,
-                  caller:                 send(:caller))
-    replacement_message = if replacement
-      "Use #{replacement} instead."
-    else
-      "There is no replacement."
-    end
-
-    unless disable_on.nil?
-      if disable_on > Time.now
-        will_be_disabled_message = " and will be disabled on #{disable_on.strftime("%Y-%m-%d")}"
-      else
-        disable = true
-      end
-    end
-
-    verb = if disable
-      "disabled"
-    else
-      "deprecated#{will_be_disabled_message}"
-    end
-
-    # Try to show the most relevant location in message, i.e. (if applicable):
-    # - Location in a formula.
-    # - Location outside of 'compat/'.
-    # - Location of caller of deprecated method (if all else fails).
-    backtrace = caller
-
-    # Don't throw deprecations at all for cached, .brew or .metadata files.
-    return if backtrace.any? do |line|
-      next true if line.include?(HOMEBREW_CACHE.to_s)
-      next true if line.include?("/.brew/")
-      next true if line.include?("/.metadata/")
-
-      next false unless line.match?(HOMEBREW_TAP_PATH_REGEX)
-
-      path = Pathname(line.split(":", 2).first)
-      next false unless path.file?
-      next false unless path.readable?
-
-      formula_contents = path.read
-      formula_contents.include?(" deprecate! ") || formula_contents.include?(" disable! ")
-    end
-
-    tap_message = T.let(nil, T.nilable(String))
-
-    backtrace.each do |line|
-      next unless (match = line.match(HOMEBREW_TAP_PATH_REGEX))
-
-      tap = Tap.fetch(match[:user], match[:repo])
-      tap_message = +"\nPlease report this issue to the #{tap} tap (not Homebrew/brew or Homebrew/core)"
-      tap_message += ", or even better, submit a PR to fix it" if replacement
-      tap_message << ":\n  #{line.sub(/^(.*:\d+):.*$/, '\1')}\n\n"
-      break
-    end
-
-    message = +"Calling #{method} is #{verb}! #{replacement_message}"
-    message << tap_message if tap_message
-    message.freeze
-
-    disable = true if disable_for_developers && Homebrew::EnvConfig.developer?
-    if disable || Homebrew.raise_deprecation_exceptions?
-      exception = MethodDeprecatedError.new(message)
-      exception.set_backtrace(backtrace)
-      raise exception
-    elsif !Homebrew.auditing?
-      opoo message
-    end
-  end
-
-  def odisabled(method, replacement = nil, options = {})
-    options = { disable: true, caller: caller }.merge(options)
-    odeprecated(method, replacement, options)
-  end
-
-  def pretty_installed(f)
-    if !$stdout.tty?
-      f.to_s
-    elsif Homebrew::EnvConfig.no_emoji?
-      Formatter.success("#{Tty.bold}#{f} (installed)#{Tty.reset}")
-    else
-      "#{Tty.bold}#{f} #{Formatter.success("✔")}#{Tty.reset}"
-    end
-  end
-
-  def pretty_outdated(f)
-    if !$stdout.tty?
-      f.to_s
-    elsif Homebrew::EnvConfig.no_emoji?
-      Formatter.error("#{Tty.bold}#{f} (outdated)#{Tty.reset}")
-    else
-      "#{Tty.bold}#{f} #{Formatter.warning("⚠")}#{Tty.reset}"
-    end
-  end
-
-  def pretty_uninstalled(f)
-    if !$stdout.tty?
-      f.to_s
-    elsif Homebrew::EnvConfig.no_emoji?
-      Formatter.error("#{Tty.bold}#{f} (uninstalled)#{Tty.reset}")
-    else
-      "#{Tty.bold}#{f} #{Formatter.error("✘")}#{Tty.reset}"
-    end
-  end
-
-  def pretty_duration(s)
-    s = s.to_i
-    res = +""
-
-    if s > 59
-      m = s / 60
-      s %= 60
-      res = +"#{m} #{"minute".pluralize(m)}"
-      return res.freeze if s.zero?
-
-      res << " "
-    end
-
-    res << "#{s} #{"second".pluralize(s)}"
-    res.freeze
-  end
-
-  def interactive_shell(f = nil)
-    unless f.nil?
-      ENV["HOMEBREW_DEBUG_PREFIX"] = f.prefix
-      ENV["HOMEBREW_DEBUG_INSTALL"] = f.full_name
-    end
-
-    if Utils::Shell.preferred == :zsh && (home = Dir.home).start_with?(HOMEBREW_TEMP.resolved_path.to_s)
-      FileUtils.mkdir_p home
-      FileUtils.touch "#{home}/.zshrc"
-    end
-
-    Process.wait fork { exec preferred_shell }
-
-    return if $CHILD_STATUS.success?
-    raise "Aborted due to non-zero exit status (#{$CHILD_STATUS.exitstatus})" if $CHILD_STATUS.exited?
-
-    raise $CHILD_STATUS.inspect
-  end
-
-  def with_homebrew_path(&block)
-    with_env(PATH: PATH.new(ORIGINAL_PATHS), &block)
-  end
-
-  def with_custom_locale(locale, &block)
-    with_env(LC_ALL: locale, &block)
-  end
-
-  # Kernel.system but with exceptions.
-  def safe_system(cmd, *args, **options)
-    return if Homebrew.system(cmd, *args, **options)
-
-    raise ErrorDuringExecution.new([cmd, *args], status: $CHILD_STATUS)
-  end
-
-  # Prints no output.
-  def quiet_system(cmd, *args)
-    Homebrew._system(cmd, *args) do
-      # Redirect output streams to `/dev/null` instead of closing as some programs
-      # will fail to execute if they can't write to an open stream.
-      $stdout.reopen("/dev/null")
-      $stderr.reopen("/dev/null")
-    end
-  end
-
-  def which(cmd, path = ENV.fetch("PATH"))
-    PATH.new(path).each do |p|
-      begin
-        pcmd = File.expand_path(cmd, p)
-      rescue ArgumentError
-        # File.expand_path will raise an ArgumentError if the path is malformed.
-        # See https://github.com/Homebrew/legacy-homebrew/issues/32789
-        next
-      end
-      return Pathname.new(pcmd) if File.file?(pcmd) && File.executable?(pcmd)
-    end
-    nil
-  end
-
-  def which_all(cmd, path = ENV.fetch("PATH"))
-    PATH.new(path).map do |p|
-      begin
-        pcmd = File.expand_path(cmd, p)
-      rescue ArgumentError
-        # File.expand_path will raise an ArgumentError if the path is malformed.
-        # See https://github.com/Homebrew/legacy-homebrew/issues/32789
-        next
-      end
-      Pathname.new(pcmd) if File.file?(pcmd) && File.executable?(pcmd)
-    end.compact.uniq
-  end
-
-  def which_editor
-    editor = Homebrew::EnvConfig.editor
-    return editor if editor
-
-    # Find Atom, Sublime Text, VS Code, Textmate, BBEdit / TextWrangler, or vim
-    editor = %w[atom subl code mate edit vim].find do |candidate|
-      candidate if which(candidate, ORIGINAL_PATHS)
-    end
-    editor ||= "vim"
-
-    opoo <<~EOS
-      Using #{editor} because no editor was set in the environment.
-      This may change in the future, so we recommend setting EDITOR,
-      or HOMEBREW_EDITOR to your preferred text editor.
-    EOS
-
-    editor
-  end
-
-  def exec_editor(*args)
-    puts "Editing #{args.join "\n"}"
-    with_homebrew_path { safe_system(*which_editor.shellsplit, *args) }
-  end
-
-  def exec_browser(*args)
-    browser = Homebrew::EnvConfig.browser
-    browser ||= OS::PATH_OPEN if defined?(OS::PATH_OPEN)
-    return unless browser
-
-    ENV["DISPLAY"] = Homebrew::EnvConfig.display
-
-    with_env(DBUS_SESSION_BUS_ADDRESS: ENV.fetch("HOMEBREW_DBUS_SESSION_BUS_ADDRESS", nil)) do
-      safe_system(browser, *args)
-    end
-  end
-
-  # GZips the given paths, and returns the gzipped paths.
-  def gzip(*paths)
-    paths.map do |path|
-      safe_system "gzip", path
-      Pathname.new("#{path}.gz")
-    end
-  end
-
-  def ignore_interrupts(_opt = nil)
-    # rubocop:disable Style/GlobalVars
-    $ignore_interrupts_nesting_level = 0 unless defined?($ignore_interrupts_nesting_level)
-    $ignore_interrupts_nesting_level += 1
-
-    $ignore_interrupts_interrupted = false unless defined?($ignore_interrupts_interrupted)
-    old_sigint_handler = trap(:INT) do
-      $ignore_interrupts_interrupted = true
-      $stderr.print "\n"
-      $stderr.puts "One sec, cleaning up..."
-    end
-
-    begin
-      yield
-    ensure
-      trap(:INT, old_sigint_handler)
-
-      $ignore_interrupts_nesting_level -= 1
-      if $ignore_interrupts_nesting_level == 0 && $ignore_interrupts_interrupted
-        $ignore_interrupts_interrupted = false
-        raise Interrupt
-      end
-    end
-    # rubocop:enable Style/GlobalVars
-  end
-
-  sig { returns(String) }
-  def capture_stderr
-    old = $stderr
-    $stderr = StringIO.new
-    yield
-    $stderr.string
-  ensure
-    $stderr = old
+module Utils
+  # Removes the rightmost segment from the constant expression in the string.
+  #
+  #   deconstantize('Net::HTTP')   # => "Net"
+  #   deconstantize('::Net::HTTP') # => "::Net"
+  #   deconstantize('String')      # => ""
+  #   deconstantize('::String')    # => ""
+  #   deconstantize('')            # => ""
+  #
+  # See also #demodulize.
+  # @see https://github.com/rails/rails/blob/b0dd7c7/activesupport/lib/active_support/inflector/methods.rb#L247-L258
+  #   `ActiveSupport::Inflector.deconstantize`
+  sig { params(path: String).returns(String) }
+  def self.deconstantize(path)
+    T.must(path[0, path.rindex("::") || 0]) # implementation based on the one in facets' Module#spacename
   end
 
-  def nostdout(&block)
-    if verbose?
-      yield
+  # Removes the module part from the expression in the string.
+  #
+  #   demodulize('ActiveSupport::Inflector::Inflections') # => "Inflections"
+  #   demodulize('Inflections')                           # => "Inflections"
+  #   demodulize('::Inflections')                         # => "Inflections"
+  #   demodulize('')                                      # => ""
+  #
+  # See also #deconstantize.
+  # @see https://github.com/rails/rails/blob/b0dd7c7/activesupport/lib/active_support/inflector/methods.rb#L230-L245
+  #   `ActiveSupport::Inflector.demodulize`
+  sig { params(path: String).returns(String) }
+  def self.demodulize(path)
+    if (i = path.rindex("::"))
+      T.must(path[(i + 2)..])
     else
-      redirect_stdout(File::NULL, &block)
+      path
     end
   end
 
-  def redirect_stdout(file)
-    out = $stdout.dup
-    $stdout.reopen(file)
-    yield
-  ensure
-    $stdout.reopen(out)
-    out.close
+  # A lightweight alternative to `ActiveSupport::Inflector.pluralize`:
+  # Combines `stem` with the `singular` or `plural` suffix based on `count`.
+  # Adds a prefix of the count value if `include_count` is set to true.
+  sig {
+    params(stem: String, count: Integer, plural: String, singular: String, include_count: T::Boolean).returns(String)
+  }
+  def self.pluralize(stem, count, plural: "s", singular: "", include_count: false)
+    prefix = include_count ? "#{count} " : ""
+    suffix = (count == 1) ? singular : plural
+    "#{prefix}#{stem}#{suffix}"
   end
 
-  # Ensure the given formula is installed
-  # This is useful for installing a utility formula (e.g. `shellcheck` for `brew style`)
-  def ensure_formula_installed!(formula_or_name, reason: "", latest: false,
-                                output_to_stderr: true, quiet: false)
-    if output_to_stderr || quiet
-      file = if quiet
-        File::NULL
-      else
-        $stderr
-      end
-      # Call this method itself with redirected stdout
-      redirect_stdout(file) do
-        return ensure_formula_installed!(formula_or_name, latest: latest,
-                                         reason: reason, output_to_stderr: false)
-      end
-    end
-
-    require "formula"
-
-    formula = if formula_or_name.is_a?(Formula)
-      formula_or_name
-    else
-      Formula[formula_or_name]
-    end
-
-    reason = " for #{reason}" if reason.present?
-
-    unless formula.any_version_installed?
-      ohai "Installing `#{formula.name}`#{reason}..."
-      safe_system HOMEBREW_BREW_FILE, "install", "--formula", formula.full_name
-    end
-
-    if latest && !formula.latest_version_installed?
-      ohai "Upgrading `#{formula.name}`#{reason}..."
-      safe_system HOMEBREW_BREW_FILE, "upgrade", "--formula", formula.full_name
+  sig { params(author: String).returns({ email: String, name: String }) }
+  def self.parse_author!(author)
+    match_data = /^(?<name>[^<]+?)[ \t]*<(?<email>[^>]+?)>$/.match(author)
+    if match_data
+      name = match_data[:name]
+      email = match_data[:email]
     end
-
-    formula
-  end
-
-  # Ensure the given executable is exist otherwise install the brewed version
-  def ensure_executable!(name, formula_name = nil, reason: "")
-    formula_name ||= name
-
-    executable = [
-      which(name),
-      which(name, ORIGINAL_PATHS),
-      HOMEBREW_PREFIX/"bin/#{name}",
-    ].compact.first
-    return executable if executable.exist?
-
-    ensure_formula_installed!(formula_name, reason: reason).opt_bin/name
-  end
-
-  def paths
-    @paths ||= ORIGINAL_PATHS.uniq.map(&:to_s)
-  end
-
-  def parse_author!(author)
-    /^(?<name>[^<]+?)[ \t]*<(?<email>[^>]+?)>$/ =~ author
     raise UsageError, "Unable to parse name and email." if name.blank? && email.blank?
 
-    { name: name, email: email }
-  end
-
-  def disk_usage_readable(size_in_bytes)
-    if size_in_bytes >= 1_073_741_824
-      size = size_in_bytes.to_f / 1_073_741_824
-      unit = "GB"
-    elsif size_in_bytes >= 1_048_576
-      size = size_in_bytes.to_f / 1_048_576
-      unit = "MB"
-    elsif size_in_bytes >= 1_024
-      size = size_in_bytes.to_f / 1_024
-      unit = "KB"
-    else
-      size = size_in_bytes
-      unit = "B"
-    end
-
-    # avoid trailing zero after decimal point
-    if ((size * 10).to_i % 10).zero?
-      "#{size.to_i}#{unit}"
-    else
-      "#{format("%<size>.1f", size: size)}#{unit}"
-    end
-  end
-
-  def number_readable(number)
-    numstr = number.to_i.to_s
-    (numstr.size - 3).step(1, -3) { |i| numstr.insert(i, ",") }
-    numstr
-  end
-
-  # Truncates a text string to fit within a byte size constraint,
-  # preserving character encoding validity. The returned string will
-  # be not much longer than the specified max_bytes, though the exact
-  # shortfall or overrun may vary.
-  def truncate_text_to_approximate_size(s, max_bytes, options = {})
-    front_weight = options.fetch(:front_weight, 0.5)
-    raise "opts[:front_weight] must be between 0.0 and 1.0" if front_weight < 0.0 || front_weight > 1.0
-    return s if s.bytesize <= max_bytes
-
-    glue = "\n[...snip...]\n"
-    max_bytes_in = [max_bytes - glue.bytesize, 1].max
-    bytes = s.dup.force_encoding("BINARY")
-    glue_bytes = glue.encode("BINARY")
-    n_front_bytes = (max_bytes_in * front_weight).floor
-    n_back_bytes = max_bytes_in - n_front_bytes
-    if n_front_bytes.zero?
-      front = bytes[1..0]
-      back = bytes[-max_bytes_in..]
-    elsif n_back_bytes.zero?
-      front = bytes[0..(max_bytes_in - 1)]
-      back = bytes[1..0]
-    else
-      front = bytes[0..(n_front_bytes - 1)]
-      back = bytes[-n_back_bytes..]
-    end
-    out = front + glue_bytes + back
-    out.force_encoding("UTF-8")
-    out.encode!("UTF-16", invalid: :replace)
-    out.encode!("UTF-8")
-    out
+    { name: T.must(name), email: T.must(email) }
   end
 
-  # Calls the given block with the passed environment variables
-  # added to ENV, then restores ENV afterwards.
-  # <pre>with_env(PATH: "/bin") do
-  #   system "echo $PATH"
-  # end</pre>
+  # Makes an underscored, lowercase form from the expression in the string.
   #
-  # @note This method is *not* thread-safe - other threads
-  #   which happen to be scheduled during the block will also
-  #   see these environment variables.
-  # @api public
-  def with_env(hash)
-    old_values = {}
-    begin
-      hash.each do |key, value|
-        key = key.to_s
-        old_values[key] = ENV.delete(key)
-        ENV[key] = value
-      end
+  # Changes '::' to '/' to convert namespaces to paths.
+  #
+  #   underscore('ActiveModel')         # => "active_model"
+  #   underscore('ActiveModel::Errors') # => "active_model/errors"
+  #
+  # @see https://github.com/rails/rails/blob/v6.1.7.2/activesupport/lib/active_support/inflector/methods.rb#L81-L100
+  #   `ActiveSupport::Inflector.underscore`
+  sig { params(camel_cased_word: T.any(String, Symbol)).returns(String) }
+  def self.underscore(camel_cased_word)
+    return camel_cased_word.to_s unless /[A-Z-]|::/.match?(camel_cased_word)
 
-      yield if block_given?
-    ensure
-      ENV.update(old_values)
+    word = camel_cased_word.to_s.gsub("::", "/")
+    word.gsub!(/([A-Z])(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) do
+      T.must(::Regexp.last_match(1) || ::Regexp.last_match(2)) << "_"
     end
+    word.tr!("-", "_")
+    word.downcase!
+    word
   end
 
-  sig { returns(String) }
-  def preferred_shell
-    ENV.fetch("SHELL", "/bin/sh")
-  end
-
-  sig { returns(String) }
-  def shell_profile
-    Utils::Shell.profile
-  end
+  SAFE_FILENAME_REGEX = /[[:cntrl:]#{Regexp.escape("#{File::SEPARATOR}#{File::ALT_SEPARATOR}")}]/o
+  private_constant :SAFE_FILENAME_REGEX
 
-  def tap_and_name_comparison
-    proc do |a, b|
-      if a.include?("/") && b.exclude?("/")
-        1
-      elsif a.exclude?("/") && b.include?("/")
-        -1
-      else
-        a <=> b
-      end
-    end
+  sig { params(basename: String).returns(T::Boolean) }
+  def self.safe_filename?(basename)
+    !SAFE_FILENAME_REGEX.match?(basename)
   end
 
-  def redact_secrets(input, secrets)
-    secrets.compact
-           .reduce(input) { |str, secret| str.gsub secret, "******" }
-           .freeze
+  sig { params(basename: String).returns(String) }
+  def self.safe_filename(basename)
+    basename.gsub(SAFE_FILENAME_REGEX, "")
   end
 end
diff --git a/Library/Homebrew/utils/analytics.rb b/Library/Homebrew/utils/analytics.rb
index 3e14608b11931..b4c8f4ec3ba07 100644
--- a/Library/Homebrew/utils/analytics.rb
+++ b/Library/Homebrew/utils/analytics.rb
@@ -1,96 +1,174 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "context"
 require "erb"
 require "settings"
-require "api"
+require "extend/cachable"
 
 module Utils
   # Helper module for fetching and reporting analytics data.
-  #
-  # @api private
   module Analytics
-    class << self
-      extend T::Sig
+    INFLUX_BUCKET = "analytics"
+    INFLUX_TOKEN = "iVdsgJ_OjvTYGAA79gOfWlA_fX0QCuj4eYUNdb-qVUTrC3tp3JTWCADVNE9HxV0kp2ZjIK9tuthy_teX4szr9A=="
+    INFLUX_HOST = "https://eu-central-1-1.aws.cloud2.influxdata.com"
+    INFLUX_ORG = "d81a3e6d582d485f"
+
+    extend Cachable
 
+    class << self
       include Context
 
-      def report(type, metadata = {})
-        return if not_this_run?
-        return if disabled?
-
-        analytics_ids = ENV.fetch("HOMEBREW_ANALYTICS_IDS", "").split(",")
-        analytics_ids.each do |analytics_id|
-          args = []
-
-          # do not load .curlrc unless requested (must be the first argument)
-          args << "--disable" unless Homebrew::EnvConfig.curlrc?
-
-          args += %W[
-            --max-time 3
-            --user-agent #{HOMEBREW_USER_AGENT_CURL}
-            --data v=1
-            --data aip=1
-            --data t=#{type}
-            --data tid=#{analytics_id}
-            --data cid=#{ENV.fetch("HOMEBREW_ANALYTICS_USER_UUID")}
-            --data an=#{HOMEBREW_PRODUCT}
-            --data av=#{HOMEBREW_VERSION}
-          ]
-          metadata.each do |key, value|
-            next unless key
-            next unless value
-
-            key = ERB::Util.url_encode key
-            value = ERB::Util.url_encode value
-            args << "--data" << "#{key}=#{value}"
-          end
+      sig {
+        params(measurement: Symbol,
+               tags:        T::Hash[Symbol, T.any(T::Boolean, String)],
+               fields:      T::Hash[Symbol, T.any(T::Boolean, String)]).void
+      }
+      def report_influx(measurement, tags, fields)
+        return if not_this_run? || disabled?
+
+        # Tags are always implicitly strings and must have low cardinality.
+        tags_string = tags.map { |k, v| "#{k}=#{v}" }
+                          .join(",")
+
+        # Fields need explicitly wrapped with quotes and can have high cardinality.
+        fields_string = fields.compact
+                              .map { |k, v| %Q(#{k}="#{v}") }
+                              .join(",")
+
+        args = [
+          "--max-time", "3",
+          "--header", "Authorization: Token #{INFLUX_TOKEN}",
+          "--header", "Content-Type: text/plain; charset=utf-8",
+          "--header", "Accept: application/json",
+          "--data-binary", "#{measurement},#{tags_string} #{fields_string} #{Time.now.to_i}"
+        ]
+
+        # Second precision is highest we can do and has the lowest performance cost.
+        url = "#{INFLUX_HOST}/api/v2/write?bucket=#{INFLUX_BUCKET}&precision=s"
+        deferred_curl(url, args)
+      end
 
-          curl = Utils::Curl.curl_executable
+      sig { params(url: String, args: T::Array[String]).void }
+      def deferred_curl(url, args)
+        require "utils/curl"
 
-          # Send analytics. Don't send or store any personally identifiable information.
-          # https://docs.brew.sh/Analytics
-          # https://developers.google.com/analytics/devguides/collection/protocol/v1/devguide
-          # https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters
-          if ENV["HOMEBREW_ANALYTICS_DEBUG"]
-            url = "https://www.google-analytics.com/debug/collect"
-            puts "#{curl} #{args.join(" ")} #{url}"
-            puts Utils.popen_read(curl, *args, url)
-          else
-            pid = fork do
-              exec curl, *args,
-                   "--silent", "--output", "/dev/null",
-                   "https://www.google-analytics.com/collect"
-            end
-            Process.detach T.must(pid)
-          end
+        curl = Utils::Curl.curl_executable
+        args = Utils::Curl.curl_args(*args, "--silent", "--output", "/dev/null", show_error: false)
+        if ENV["HOMEBREW_ANALYTICS_DEBUG"]
+          puts "#{curl} #{args.join(" ")} \"#{url}\""
+          puts Utils.popen_read(curl, *args, url)
+        else
+          pid = spawn curl, *args, url
+          Process.detach T.must(pid)
         end
-        nil
       end
 
-      def report_event(category, action, label = os_arch_prefix_ci, value = nil)
-        report(:event,
-               ec: category,
-               ea: action,
-               el: label,
-               ev: value)
+      sig {
+        params(measurement: Symbol, package_name: String, tap_name: String,
+               on_request: T::Boolean, options: String).void
+      }
+      def report_package_event(measurement, package_name:, tap_name:, on_request: false, options: "")
+        return if not_this_run? || disabled?
+
+        # ensure on_request is a boolean
+        on_request = on_request ? true : false
+
+        # ensure options are removed (by `.compact` below) if empty
+        options = nil if options.blank?
+
+        # Tags must have low cardinality.
+        tags = default_package_tags.merge(on_request:)
+
+        # Fields can have high cardinality.
+        fields = default_package_fields.merge(package: package_name, tap_name:, options:)
+                                       .compact
+
+        report_influx(measurement, tags, fields)
       end
 
+      sig { params(exception: BuildError).void }
       def report_build_error(exception)
-        return unless exception.formula.tap
-        return unless exception.formula.tap.installed?
-        return if exception.formula.tap.private?
+        return if not_this_run? || disabled?
 
-        action = exception.formula.full_name
-        if (options = exception.options.to_a.map(&:to_s).join(" ").presence)
-          action = "#{action} #{options}".strip
-        end
-        report_event("BuildError", action)
+        formula = exception.formula
+        return unless formula
+
+        tap = formula.tap
+        return unless tap
+        return unless tap.should_report_analytics?
+
+        options = exception.options.to_a.compact.map(&:to_s).sort.uniq.join(" ")
+        report_package_event(:build_error, package_name: formula.name, tap_name: tap.name, options:)
+      end
+
+      sig { params(command_instance: Homebrew::AbstractCommand).void }
+      def report_command_run(command_instance)
+        return if not_this_run? || disabled?
+
+        command = command_instance.class.command_name
+
+        options_array = command_instance.args.options_only.to_a.compact
+
+        # Strip out any flag values to reduce cardinality and preserve privacy.
+        options_array.map! { |option| option.sub(/=.*/m, "=") }
+
+        # Strip out --with-* and --without-* options
+        options_array.reject! { |option| option.match(/^--with(out)?-/) }
+
+        options = options_array.sort.uniq.join(" ")
+
+        # Tags must have low cardinality.
+        tags = {
+          command:,
+          ci:        ENV["CI"].present?,
+          devcmdrun: Homebrew::EnvConfig.devcmdrun?,
+          developer: Homebrew::EnvConfig.developer?,
+        }
+
+        # Fields can have high cardinality.
+        fields = { options: }
+
+        report_influx(:command_run, tags, fields)
+      end
+
+      sig { params(step_command_short: String, passed: T::Boolean).void }
+      def report_test_bot_test(step_command_short, passed)
+        return if not_this_run? || disabled?
+        return if ENV["HOMEBREW_TEST_BOT_ANALYTICS"].blank?
+
+        # ensure passed is a boolean
+        passed = passed ? true : false
+
+        # Tags must have low cardinality.
+        tags = {
+          passed:,
+          arch:   HOMEBREW_PHYSICAL_PROCESSOR,
+          os:     HOMEBREW_SYSTEM,
+        }
+
+        # Strip out any flag values to reduce cardinality and preserve privacy.
+        # Sort options to ensure consistent ordering and improve readability.
+        command_and_package, options =
+          step_command_short.split
+                            .map { |arg| arg.sub(/=.*/, "=") }
+                            .partition { |arg| !arg.start_with?("-") }
+        command = (command_and_package + options.sort).join(" ")
+
+        # Fields can have high cardinality.
+        fields = { command: }
+
+        report_influx(:test_bot_test, tags, fields)
+      end
+
+      def influx_message_displayed?
+        config_true?(:influxanalyticsmessage)
       end
 
       def messages_displayed?
-        config_true?(:analyticsmessage) && config_true?(:caskanalyticsmessage)
+        config_true?(:analyticsmessage) &&
+          config_true?(:caskanalyticsmessage) &&
+          influx_message_displayed?
       end
 
       def disabled?
@@ -108,31 +186,30 @@ def no_message_output?
         ENV["HOMEBREW_NO_ANALYTICS_MESSAGE_OUTPUT"].present?
       end
 
-      def uuid
-        Homebrew::Settings.read :analyticsuuid
-      end
-
       def messages_displayed!
         Homebrew::Settings.write :analyticsmessage, true
         Homebrew::Settings.write :caskanalyticsmessage, true
+        Homebrew::Settings.write :influxanalyticsmessage, true
       end
 
       def enable!
         Homebrew::Settings.write :analyticsdisabled, false
+        delete_uuid!
         messages_displayed!
       end
 
       def disable!
         Homebrew::Settings.write :analyticsdisabled, true
-        regenerate_uuid!
+        delete_uuid!
       end
 
-      def regenerate_uuid!
-        # it will be regenerated in next run unless disabled.
+      def delete_uuid!
         Homebrew::Settings.delete :analyticsuuid
       end
 
       def output(args:, filter: nil)
+        require "api"
+
         days = args.days || "30"
         category = args.category || "install"
         begin
@@ -164,10 +241,10 @@ def output(args:, filter: nil)
           return
         end
 
-        table_output(category, days, results, os_version: os_version, cask_install: cask_install)
+        table_output(category, days, results, os_version:, cask_install:)
       end
 
-      def get_analytics(json, args:)
+      def output_analytics(json, args:)
         full_analytics = args.analytics? || verbose?
 
         ohai "Analytics"
@@ -192,13 +269,63 @@ def get_analytics(json, args:)
         end
       end
 
-      def formula_output(f, args:)
+      # This method is undocumented because it is not intended for general use.
+      # It relies on screen scraping some GitHub HTML that's not available as an API.
+      # This seems very likely to break in the future.
+      # That said, it's the only way to get the data we want right now.
+      def output_github_packages_downloads(formula, args:)
+        return unless args.github_packages_downloads?
+        return unless formula.core_formula?
+
+        require "utils/curl"
+
+        escaped_formula_name = GitHubPackages.image_formula_name(formula.name)
+                                             .gsub("/", "%2F")
+        formula_url_suffix = "container/core%2F#{escaped_formula_name}/"
+        formula_url = "https://github.com/Homebrew/homebrew-core/pkgs/#{formula_url_suffix}"
+        output = Utils::Curl.curl_output("--fail", formula_url)
+        return unless output.success?
+
+        formula_version_urls = output.stdout
+                                     .scan(%r{/orgs/Homebrew/packages/#{formula_url_suffix}\d+\?tag=[^"]+})
+                                     .map do |url|
+          url.sub("/orgs/Homebrew/packages/", "/Homebrew/homebrew-core/pkgs/")
+        end
+        return if formula_version_urls.empty?
+
+        thirty_day_download_count = 0
+        formula_version_urls.each do |formula_version_url_suffix|
+          formula_version_url = "https://github.com#{formula_version_url_suffix}"
+          output = Utils::Curl.curl_output("--fail", formula_version_url)
+          next unless output.success?
+
+          last_thirty_days_match = output.stdout.match(
+            %r{<span class="[\s\-a-z]*">Last 30 days</span>\s*<span class="[\s\-a-z]*">([\d.M,]+)</span>}m,
+          )
+          next if last_thirty_days_match.blank?
+
+          last_thirty_days_downloads = last_thirty_days_match.captures.first.tr(",", "")
+          thirty_day_download_count += if (millions_match = last_thirty_days_downloads.match(/(\d+\.\d+)M/).presence)
+            millions_match.captures.first.to_f * 1_000_000
+          else
+            last_thirty_days_downloads.to_i
+          end
+        end
+
+        ohai "GitHub Packages Downloads"
+        puts "#{number_readable(thirty_day_download_count)} (30 days)"
+      end
+
+      def formula_output(formula, args:)
         return if Homebrew::EnvConfig.no_analytics? || Homebrew::EnvConfig.no_github_api?
 
-        json = Homebrew::API::Formula.fetch f.name
+        require "api"
+
+        json = Homebrew::API::Formula.fetch formula.name
         return if json.blank? || json["analytics"].blank?
 
-        get_analytics(json, args: args)
+        output_analytics(json, args:)
+        output_github_packages_downloads(formula, args:)
       rescue ArgumentError
         # Ignore failed API requests
         nil
@@ -207,43 +334,57 @@ def formula_output(f, args:)
       def cask_output(cask, args:)
         return if Homebrew::EnvConfig.no_analytics? || Homebrew::EnvConfig.no_github_api?
 
+        require "api"
+
         json = Homebrew::API::Cask.fetch cask.token
         return if json.blank? || json["analytics"].blank?
 
-        get_analytics(json, args: args)
+        output_analytics(json, args:)
       rescue ArgumentError
         # Ignore failed API requests
         nil
       end
 
-      sig { returns(String) }
-      def custom_prefix_label
-        "custom-prefix"
-      end
-      alias generic_custom_prefix_label custom_prefix_label
-
-      sig { returns(String) }
-      def arch_label
-        if Hardware::CPU.arm?
-          "ARM"
-        else
-          ""
+      sig { returns(T::Hash[Symbol, String]) }
+      def default_package_tags
+        cache[:default_package_tags] ||= begin
+          # Only display default prefixes to reduce cardinality and improve privacy
+          prefix = Homebrew.default_prefix? ? HOMEBREW_PREFIX.to_s : "custom-prefix"
+
+          # Tags are always strings and must have low cardinality.
+          {
+            ci:             ENV["CI"].present?,
+            prefix:,
+            default_prefix: Homebrew.default_prefix?,
+            developer:      Homebrew::EnvConfig.developer?,
+            devcmdrun:      Homebrew::EnvConfig.devcmdrun?,
+            arch:           HOMEBREW_PHYSICAL_PROCESSOR,
+            os:             HOMEBREW_SYSTEM,
+          }
         end
       end
 
-      def clear_os_arch_prefix_ci
-        return unless instance_variable_defined?(:@os_arch_prefix_ci)
+      # remove os_version starting with " or number
+      # remove macOS patch release
+      sig { returns(T::Hash[Symbol, String]) }
+      def default_package_fields
+        cache[:default_package_fields] ||= begin
+          version = if (match_data = HOMEBREW_VERSION.match(/^[\d.]+/))
+            suffix = "-dev" if HOMEBREW_VERSION.include?("-")
+            match_data[0] + suffix.to_s
+          else
+            ">=4.1.22"
+          end
 
-        remove_instance_variable(:@os_arch_prefix_ci)
-      end
+          # Only include OS versions with an actual name.
+          os_name_and_version = if (os_version = OS_VERSION.presence) && os_version.downcase.match?(/^[a-z]/)
+            os_version
+          end
 
-      def os_arch_prefix_ci
-        @os_arch_prefix_ci ||= begin
-          os = OS_VERSION
-          arch = ", #{arch_label}" if arch_label.present?
-          prefix = ", #{custom_prefix_label}" unless Homebrew.default_prefix?
-          ci = ", CI" if ENV["CI"]
-          "#{os}#{arch}#{prefix}#{ci}"
+          {
+            version:,
+            os_name_and_version:,
+          }
         end
       end
 
@@ -320,7 +461,7 @@ def table_output(category, days, results, os_version: false, cask_install: false
                "#{formatted_count} | #{formatted_percent}%"
           next if index > 10
         end
-        return unless results.length > 1
+        return if results.length <= 1
 
         formatted_total_footer =
           format "%-#{index_width}s", total_index_footer
@@ -343,10 +484,8 @@ def format_count(count)
       end
 
       def format_percent(percent)
-        format("%<percent>.2f", percent: percent)
+        format("%<percent>.2f", percent:)
       end
     end
   end
 end
-
-require "extend/os/utils/analytics"
diff --git a/Library/Homebrew/utils/analytics.sh b/Library/Homebrew/utils/analytics.sh
index eb10fe8d1859b..1190dfaaf3323 100644
--- a/Library/Homebrew/utils/analytics.sh
+++ b/Library/Homebrew/utils/analytics.sh
@@ -1,28 +1,23 @@
-# Migrate analytics UUID to its new home in Homebrew repo's git config and
-# remove the legacy UUID file if detected.
+# Setup analytics and delete old analytics UUIDs.
 # HOMEBREW_LINUX, HOMEBREW_REPOSITORY is set by bin/brew
 # HOMEBREW_NO_ANALYTICS is from the user environment.
 # shellcheck disable=SC2154
-migrate-legacy-uuid-file() {
-  local legacy_uuid_file analytics_uuid
 
-  legacy_uuid_file="${HOME}/.homebrew_analytics_user_uuid"
+setup-analytics() {
+  local git_config_file="${HOMEBREW_REPOSITORY}/.git/config"
 
+  local legacy_uuid_file="${HOME}/.homebrew_analytics_user_uuid"
   if [[ -f "${legacy_uuid_file}" ]]
   then
-    analytics_uuid="$(cat "${legacy_uuid_file}")"
-    if [[ -n "${analytics_uuid}" ]]
-    then
-      git config --file="${HOMEBREW_REPOSITORY}/.git/config" --replace-all homebrew.analyticsuuid "${analytics_uuid}" 2>/dev/null
-    fi
     rm -f "${legacy_uuid_file}"
   fi
-}
-
-setup-analytics() {
-  local git_config_file="${HOMEBREW_REPOSITORY}/.git/config"
 
-  migrate-legacy-uuid-file
+  local user_uuid
+  user_uuid="$(git config --file="${git_config_file}" --get homebrew.analyticsuuid 2>/dev/null)"
+  if [[ -n "${user_uuid}" ]]
+  then
+    git config --file="${git_config_file}" --unset-all homebrew.analyticsuuid 2>/dev/null
+  fi
 
   if [[ -n "${HOMEBREW_NO_ANALYTICS}" ]]
   then
@@ -38,43 +33,4 @@ setup-analytics() {
     export HOMEBREW_NO_ANALYTICS_THIS_RUN="1"
     return
   fi
-
-  HOMEBREW_ANALYTICS_USER_UUID="$(git config --file="${git_config_file}" --get homebrew.analyticsuuid 2>/dev/null)"
-  if [[ -z "${HOMEBREW_ANALYTICS_USER_UUID}" ]]
-  then
-    if [[ -x /usr/bin/uuidgen ]]
-    then
-      HOMEBREW_ANALYTICS_USER_UUID="$(/usr/bin/uuidgen)"
-    elif [[ -r /proc/sys/kernel/random/uuid ]]
-    then
-      HOMEBREW_ANALYTICS_USER_UUID="$(tr a-f A-F </proc/sys/kernel/random/uuid)"
-    else
-      HOMEBREW_ANALYTICS_USER_UUID="$(uuidgen)"
-    fi
-
-    if [[ -z "${HOMEBREW_ANALYTICS_USER_UUID}" ]]
-    then
-      # Avoid sending bogus analytics if no UUID could be generated.
-      export HOMEBREW_NO_ANALYTICS_THIS_RUN="1"
-      return
-    fi
-    git config --file="${git_config_file}" --replace-all homebrew.analyticsuuid "${HOMEBREW_ANALYTICS_USER_UUID}" 2>/dev/null
-  fi
-
-  if [[ -n "${HOMEBREW_LINUX}" ]]
-  then
-    # For Homebrew on Linux's analytics.
-    HOMEBREW_ANALYTICS_IDS="UA-76492262-1"
-  else
-    # Otherwise, fall back to Homebrew's analytics.
-    HOMEBREW_ANALYTICS_IDS="UA-76679469-1"
-  fi
-
-  if [[ -n "${HOMEBREW_ADDITIONAL_GOOGLE_ANALYTICS_ID}" ]]
-  then
-    HOMEBREW_ANALYTICS_IDS="${HOMEBREW_ANALYTICS_IDS},${HOMEBREW_ADDITIONAL_GOOGLE_ANALYTICS_ID}"
-  fi
-
-  export HOMEBREW_ANALYTICS_IDS
-  export HOMEBREW_ANALYTICS_USER_UUID
 }
diff --git a/Library/Homebrew/utils/ast.rb b/Library/Homebrew/utils/ast.rb
index 5531fa376e008..7103fb300b8fa 100644
--- a/Library/Homebrew/utils/ast.rb
+++ b/Library/Homebrew/utils/ast.rb
@@ -6,11 +6,7 @@
 
 module Utils
   # Helper functions for editing Ruby files.
-  #
-  # @api private
   module AST
-    extend T::Sig
-
     Node = RuboCop::AST::Node
     SendNode = RuboCop::AST::SendNode
     BlockNode = RuboCop::AST::BlockNode
@@ -37,7 +33,7 @@ def stanza_text(name, value, indent: nil)
         value if (node.is_a?(SendNode) || node.is_a?(BlockNode)) && node.method_name == name
       end
       text ||= "#{name} #{value.inspect}"
-      text = text.indent(indent) if indent && !text.match?(/\A\n* +/)
+      text = text.gsub(/^(?!$)/, " " * indent) if indent && !text.match?(/\A\n* +/)
       text
     end
 
@@ -76,10 +72,7 @@ def call_node_match?(node, name:, type: nil)
     end
 
     # Helper class for editing formulae.
-    #
-    # @api private
     class FormulaAST
-      extend T::Sig
       extend Forwardable
       include AST
 
@@ -101,7 +94,7 @@ def bottle_block
 
       sig { params(name: Symbol, type: T.nilable(Symbol)).returns(T.nilable(Node)) }
       def stanza(name, type: nil)
-        children.find { |child| call_node_match?(child, name: name, type: type) }
+        children.find { |child| call_node_match?(child, name:, type:) }
       end
 
       sig { params(bottle_output: String).void }
@@ -116,7 +109,7 @@ def add_bottle_block(bottle_output)
 
       sig { params(name: Symbol, type: T.nilable(Symbol)).void }
       def remove_stanza(name, type: nil)
-        stanza_node = stanza(name, type: type)
+        stanza_node = stanza(name, type:)
         raise "Could not find '#{name}' stanza!" if stanza_node.blank?
 
         # stanza is probably followed by a newline character
@@ -149,7 +142,7 @@ def remove_stanza(name, type: nil)
 
       sig { params(name: Symbol, replacement: T.any(Numeric, String, Symbol), type: T.nilable(Symbol)).void }
       def replace_stanza(name, replacement, type: nil)
-        stanza_node = stanza(name, type: type)
+        stanza_node = stanza(name, type:)
         raise "Could not find '#{name}' stanza!" if stanza_node.blank?
 
         tree_rewriter.replace(stanza_node.source_range, stanza_text(name, replacement, indent: 2).lstrip)
@@ -232,8 +225,8 @@ def formula_component_before_target?(node, target_name:, target_type: nil)
           return false if components.any? do |component|
             component_match?(component_name: component[:name],
                              component_type: component[:type],
-                             target_name:    target_name,
-                             target_type:    target_type)
+                             target_name:,
+                             target_type:)
           end
           return true if components.any? do |component|
             call_node_match?(node, name: component[:name], type: component[:type])
diff --git a/Library/Homebrew/utils/autoremove.rb b/Library/Homebrew/utils/autoremove.rb
new file mode 100644
index 0000000000000..3e0c136c09a1c
--- /dev/null
+++ b/Library/Homebrew/utils/autoremove.rb
@@ -0,0 +1,76 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Utils
+  # Helper function for finding autoremovable formulae.
+  #
+  # @private
+  module Autoremove
+    class << self
+      # An array of {Formula} without {Formula} or {Cask}
+      # dependents that weren't installed on request and without
+      # build dependencies for {Formula} installed from source.
+      # @private
+      sig { params(formulae: T::Array[Formula], casks: T::Array[Cask::Cask]).returns(T::Array[Formula]) }
+      def removable_formulae(formulae, casks)
+        unused_formulae = unused_formulae_with_no_formula_dependents(formulae)
+        unused_formulae - formulae_with_cask_dependents(casks)
+      end
+
+      private
+
+      # An array of all installed {Formula} with {Cask} dependents.
+      # @private
+      sig { params(casks: T::Array[Cask::Cask]).returns(T::Array[Formula]) }
+      def formulae_with_cask_dependents(casks)
+        casks.flat_map { |cask| cask.depends_on[:formula] }
+             .compact
+             .map { |f| Formula[f] }
+             .flat_map { |f| [f, *f.runtime_formula_dependencies].compact }
+      end
+
+      # An array of all installed bottled {Formula} without runtime {Formula}
+      # dependents for bottles and without build {Formula} dependents
+      # for those built from source.
+      # @private
+      sig { params(formulae: T::Array[Formula]).returns(T::Array[Formula]) }
+      def bottled_formulae_with_no_formula_dependents(formulae)
+        formulae_to_keep = T.let([], T::Array[Formula])
+        formulae.each do |formula|
+          formulae_to_keep += formula.runtime_formula_dependencies
+
+          if (tab = formula.any_installed_keg&.tab)
+            # Ignore build dependencies when the formula is a bottle
+            next if tab.poured_from_bottle
+
+            # Keep the formula if it was built from source
+            formulae_to_keep << formula
+          end
+
+          formula.deps.select(&:build?).each do |dep|
+            formulae_to_keep << dep.to_formula
+          rescue FormulaUnavailableError
+            # do nothing
+          end
+        end
+        formulae - formulae_to_keep
+      end
+
+      # Recursive function that returns an array of {Formula} without
+      # {Formula} dependents that weren't installed on request.
+      # @private
+      sig { params(formulae: T::Array[Formula]).returns(T::Array[Formula]) }
+      def unused_formulae_with_no_formula_dependents(formulae)
+        unused_formulae = bottled_formulae_with_no_formula_dependents(formulae).select do |f|
+          f.any_installed_keg&.tab&.installed_on_request == false
+        end
+
+        unless unused_formulae.empty?
+          unused_formulae += unused_formulae_with_no_formula_dependents(formulae - unused_formulae)
+        end
+
+        unused_formulae
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/utils/backtrace.rb b/Library/Homebrew/utils/backtrace.rb
new file mode 100644
index 0000000000000..b04f3497290fb
--- /dev/null
+++ b/Library/Homebrew/utils/backtrace.rb
@@ -0,0 +1,54 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Utils
+  module Backtrace
+    @print_backtrace_message = T.let(false, T::Boolean)
+
+    # Cleans `sorbet-runtime` gem paths from the backtrace unless...
+    # 1. `verbose` is set
+    # 2. first backtrace line starts with `sorbet-runtime`
+    #   - This implies that the error is related to Sorbet.
+    sig { params(error: Exception).returns(T.nilable(T::Array[String])) }
+    def self.clean(error)
+      backtrace = error.backtrace
+
+      return backtrace if Context.current.verbose?
+      return backtrace if backtrace.blank?
+      return backtrace if backtrace.fetch(0).start_with?(sorbet_runtime_path)
+
+      old_backtrace_length = backtrace.length
+      backtrace.reject { |line| line.start_with?(sorbet_runtime_path) }
+               .tap { |new_backtrace| print_backtrace_message if old_backtrace_length > new_backtrace.length }
+    end
+
+    sig { returns(String) }
+    def self.sorbet_runtime_path
+      @sorbet_runtime_path ||= T.let("#{Gem.paths.home}/gems/sorbet-runtime", T.nilable(String))
+    end
+
+    sig { void }
+    def self.print_backtrace_message
+      return if @print_backtrace_message
+
+      opoo "Removed Sorbet lines from backtrace!"
+      puts "Rerun with `--verbose` to see the original backtrace" unless Homebrew::EnvConfig.no_env_hints?
+
+      @print_backtrace_message = true
+    end
+
+    sig { params(error: Exception).returns(T.nilable(String)) }
+    def self.tap_error_url(error)
+      backtrace = error.backtrace
+      return if backtrace.blank?
+
+      backtrace.each do |line|
+        if (tap = line.match(%r{/Library/Taps/([^/]+/[^/]+)/}))
+          return "https://github.com/#{tap[1]}/issues/new"
+        end
+      end
+
+      nil
+    end
+  end
+end
diff --git a/Library/Homebrew/utils/bottles.rb b/Library/Homebrew/utils/bottles.rb
index 6ffcb815b9815..73c6b014bee52 100644
--- a/Library/Homebrew/utils/bottles.rb
+++ b/Library/Homebrew/utils/bottles.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "tab"
@@ -6,37 +6,44 @@
 module Utils
   # Helper functions for bottles.
   #
-  # @api private
+  # @api internal
   module Bottles
     class << self
-      extend T::Sig
-
       # Gets the tag for the running OS.
-      def tag(symbol = nil)
-        return Tag.from_symbol(symbol) if symbol.present?
-
-        @tag ||= Tag.new(system: HOMEBREW_SYSTEM.downcase.to_sym,
-                         arch:   HOMEBREW_PROCESSOR.downcase.to_sym)
+      #
+      # @api internal
+      sig { params(tag: T.nilable(T.any(Symbol, Tag))).returns(Tag) }
+      def tag(tag = nil)
+        case tag
+        when Symbol
+          Tag.from_symbol(tag)
+        when Tag
+          tag
+        else
+          @tag ||= Tag.new(
+            system: HOMEBREW_SYSTEM.downcase.to_sym,
+            arch:   HOMEBREW_PROCESSOR.downcase.to_sym,
+          )
+        end
       end
 
-      def built_as?(f)
-        return false unless f.latest_version_installed?
+      def built_as?(formula)
+        return false unless formula.latest_version_installed?
 
-        tab = Tab.for_keg(f.latest_installed_prefix)
+        tab = Keg.new(formula.latest_installed_prefix).tab
         tab.built_as_bottle
       end
 
-      def file_outdated?(f, file)
-        filename = file.basename.to_s
-        return false if f.bottle.blank?
+      def file_outdated?(formula, file)
+        file = file.resolved_path
 
-        bottle_ext, bottle_tag, = extname_tag_rebuild(filename)
-        return false if bottle_ext.blank?
-        return false if bottle_tag != tag.to_s
+        filename = file.basename.to_s
+        return false if formula.bottle.blank?
 
-        bottle_url_ext, = extname_tag_rebuild(f.bottle.url)
+        _, bottle_tag, bottle_rebuild = extname_tag_rebuild(filename)
+        return false if bottle_tag.blank?
 
-        bottle_ext && bottle_url_ext && bottle_ext != bottle_url_ext
+        bottle_tag != formula.bottle.tag.to_s || bottle_rebuild.to_i != formula.bottle.rebuild
       end
 
       def extname_tag_rebuild(filename)
@@ -45,7 +52,7 @@ def extname_tag_rebuild(filename)
 
       def receipt_path(bottle_file)
         bottle_file_list(bottle_file).find do |line|
-          line =~ %r{.+/.+/INSTALL_RECEIPT.json}
+          %r{.+/.+/INSTALL_RECEIPT.json}.match?(line)
         end
       end
 
@@ -59,12 +66,14 @@ def resolve_formula_names(bottle_file)
           receipt_file = file_from_bottle(bottle_file, receipt_file_path)
           tap = Tab.from_file_content(receipt_file, "#{bottle_file}/#{receipt_file_path}").tap
           "#{tap}/#{name}" if tap.present? && !tap.core_tap?
-        elsif (bottle_json_path = Pathname(bottle_file.sub(/\.(\d+\.)?tar\.gz$/, ".json"))) &&
-              bottle_json_path.exist? &&
-              (bottle_json_path_contents = bottle_json_path.read.presence) &&
-              (bottle_json = JSON.parse(bottle_json_path_contents).presence) &&
-              bottle_json.is_a?(Hash)
-          bottle_json.keys.first.presence
+        else
+          bottle_json_path = Pathname(bottle_file.sub(/\.(\d+\.)?tar\.gz$/, ".json"))
+          if bottle_json_path.exist? &&
+             (bottle_json_path_contents = bottle_json_path.read.presence) &&
+             (bottle_json = JSON.parse(bottle_json_path_contents).presence) &&
+             bottle_json.is_a?(Hash)
+            bottle_json.keys.first.presence
+          end
         end
         full_name ||= name
 
@@ -97,7 +106,7 @@ def path_resolved_basename(root_url, name, checksum, filename)
 
       def load_tab(formula)
         keg = Keg.new(formula.prefix)
-        tabfile = keg/Tab::FILENAME
+        tabfile = keg/AbstractTab::FILENAME
         bottle_json_path = formula.local_bottle_path&.sub(/\.(\d+\.)?tar\.gz$/, ".json")
 
         if (tab_attributes = formula.bottle_tab_attributes.presence)
@@ -108,7 +117,14 @@ def load_tab(formula)
           tab_json = bottle_hash[formula.full_name]["bottle"]["tags"][tag]["tab"].to_json
           Tab.from_file_content(tab_json, tabfile)
         else
-          Tab.for_keg(keg)
+          tab = keg.tab
+
+          tab.runtime_dependencies = begin
+            f_runtime_deps = formula.runtime_dependencies(read_from_tab: false)
+            Tab.runtime_deps_hash(formula, f_runtime_deps)
+          end
+
+          tab
         end
       end
 
@@ -124,8 +140,6 @@ def bottle_file_list(bottle_file)
 
     # Denotes the arch and OS of a bottle.
     class Tag
-      extend T::Sig
-
       attr_reader :system, :arch
 
       sig { params(value: Symbol).returns(T.attached_class) }
@@ -144,7 +158,7 @@ def self.from_symbol(value)
 
         system = match[:system].to_sym
         arch = match[:arch]&.to_sym || :x86_64
-        new(system: system, arch: arch)
+        new(system:, arch:)
       end
 
       sig { params(system: Symbol, arch: Symbol).void }
@@ -157,7 +171,7 @@ def ==(other)
         if other.is_a?(Symbol)
           to_sym == other
         else
-          self.class == other.class && system == other.system && arch == other.arch
+          self.class == other.class && system == other.system && standardized_arch == other.standardized_arch
         end
       end
 
@@ -166,7 +180,7 @@ def eql?(other)
       end
 
       def hash
-        [system, arch].hash
+        [system, standardized_arch].hash
       end
 
       sig { returns(Symbol) }
@@ -184,7 +198,7 @@ def to_sym
         elsif macos? && [:x86_64, :intel].include?(arch)
           system
         else
-          "#{standardized_arch}_#{system}".to_sym
+          :"#{standardized_arch}_#{system}"
         end
       end
 
@@ -193,9 +207,9 @@ def to_s
         to_sym.to_s
       end
 
-      sig { returns(OS::Mac::Version) }
+      sig { returns(MacOSVersion) }
       def to_macos_version
-        @to_macos_version ||= OS::Mac::Version.from_symbol(system)
+        @to_macos_version ||= MacOSVersion.from_symbol(system)
       end
 
       sig { returns(T::Boolean) }
@@ -205,10 +219,7 @@ def linux?
 
       sig { returns(T::Boolean) }
       def macos?
-        to_macos_version
-        true
-      rescue MacOSVersionError
-        false
+        MacOSVersion::SYMBOLS.key?(system)
       end
 
       sig { returns(T::Boolean) }
@@ -245,8 +256,6 @@ def default_cellar
 
     # The specification for a specific tag
     class TagSpecification
-      extend T::Sig
-
       sig { returns(Utils::Bottles::Tag) }
       attr_reader :tag
 
@@ -261,12 +270,15 @@ def initialize(tag:, checksum:, cellar:)
         @checksum = checksum
         @cellar = cellar
       end
+
+      def ==(other)
+        self.class == other.class && tag == other.tag && checksum == other.checksum && cellar == other.cellar
+      end
+      alias eql? ==
     end
 
     # Collector for bottle specifications.
     class Collector
-      extend T::Sig
-
       sig { void }
       def initialize
         @tag_specs = T.let({}, T::Hash[Utils::Bottles::Tag, Utils::Bottles::TagSpecification])
@@ -277,15 +289,20 @@ def tags
         @tag_specs.keys
       end
 
+      def ==(other)
+        self.class == other.class && @tag_specs == other.instance_variable_get(:@tag_specs)
+      end
+      alias eql? ==
+
       sig { params(tag: Utils::Bottles::Tag, checksum: Checksum, cellar: T.any(Symbol, String)).void }
       def add(tag, checksum:, cellar:)
-        spec = Utils::Bottles::TagSpecification.new(tag: tag, checksum: checksum, cellar: cellar)
+        spec = Utils::Bottles::TagSpecification.new(tag:, checksum:, cellar:)
         @tag_specs[tag] = spec
       end
 
       sig { params(tag: Utils::Bottles::Tag, no_older_versions: T::Boolean).returns(T::Boolean) }
       def tag?(tag, no_older_versions: false)
-        tag = find_matching_tag(tag, no_older_versions: no_older_versions)
+        tag = find_matching_tag(tag, no_older_versions:)
         tag.present?
       end
 
@@ -299,7 +316,7 @@ def each_tag(&block)
           .returns(T.nilable(Utils::Bottles::TagSpecification))
       }
       def specification_for(tag, no_older_versions: false)
-        tag = find_matching_tag(tag, no_older_versions: no_older_versions)
+        tag = find_matching_tag(tag, no_older_versions:)
         @tag_specs[tag] if tag
       end
 
diff --git a/Library/Homebrew/utils/curl.rb b/Library/Homebrew/utils/curl.rb
index 6d49e01abe592..4a5a3abedb2b3 100644
--- a/Library/Homebrew/utils/curl.rb
+++ b/Library/Homebrew/utils/curl.rb
@@ -1,23 +1,35 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "open3"
 
-require "extend/time"
+require "utils/timer"
+require "system_command"
 
 module Utils
   # Helper function for interacting with `curl`.
-  #
-  # @api private
   module Curl
-    extend T::Sig
+    include SystemCommand::Mixin
+    extend SystemCommand::Mixin
+    extend T::Helpers
 
-    using TimeRemaining
+    requires_ancestor { Kernel }
+
+    # Error returned when the server sent data curl could not parse.
+    CURL_WEIRD_SERVER_REPLY_EXIT_CODE = 8
+
+    # Error returned when `--fail` is used and the HTTP server returns an error
+    # code that is >= 400.
+    CURL_HTTP_RETURNED_ERROR_EXIT_CODE = 22
+
+    # Error returned when curl gets an error from the lowest networking layers
+    # that the receiving of data failed.
+    CURL_RECV_ERROR_EXIT_CODE = 56
 
     # This regex is used to extract the part of an ETag within quotation marks,
     # ignoring any leading weak validator indicator (`W/`). This simplifies
     # ETag comparison in `#curl_check_http_content`.
-    ETAG_VALUE_REGEX = %r{^(?:[wW]/)?"((?:[^"]|\\")*)"}.freeze
+    ETAG_VALUE_REGEX = %r{^(?:[wW]/)?"((?:[^"]|\\")*)"}
 
     # HTTP responses and body content are typically separated by a double
     # `CRLF` (whereas HTTP header lines are separated by a single `CRLF`).
@@ -25,10 +37,14 @@ module Curl
     HTTP_RESPONSE_BODY_SEPARATOR = "\r\n\r\n"
 
     # This regex is used to isolate the parts of an HTTP status line, namely
-    # the status code and any following descriptive text (e.g., `Not Found`).
-    HTTP_STATUS_LINE_REGEX = %r{^HTTP/.* (?<code>\d+)(?: (?<text>[^\r\n]+))?}.freeze
+    # the status code and any following descriptive text (e.g. `Not Found`).
+    HTTP_STATUS_LINE_REGEX = %r{^HTTP/.* (?<code>\d+)(?: (?<text>[^\r\n]+))?}
 
-    private_constant :ETAG_VALUE_REGEX, :HTTP_RESPONSE_BODY_SEPARATOR, :HTTP_STATUS_LINE_REGEX
+    private_constant :CURL_WEIRD_SERVER_REPLY_EXIT_CODE,
+                     :CURL_HTTP_RETURNED_ERROR_EXIT_CODE,
+                     :CURL_RECV_ERROR_EXIT_CODE,
+                     :ETAG_VALUE_REGEX, :HTTP_RESPONSE_BODY_SEPARATOR,
+                     :HTTP_STATUS_LINE_REGEX
 
     module_function
 
@@ -54,8 +70,10 @@ def clear_path_cache
         retries:         T.nilable(Integer),
         retry_max_time:  T.any(Integer, Float, NilClass),
         show_output:     T.nilable(T::Boolean),
+        show_error:      T.nilable(T::Boolean),
         user_agent:      T.any(String, Symbol, NilClass),
-      ).returns(T::Array[T.untyped])
+        referer:         T.nilable(String),
+      ).returns(T::Array[String])
     }
     def curl_args(
       *extra_args,
@@ -64,19 +82,30 @@ def curl_args(
       retries: Homebrew::EnvConfig.curl_retries.to_i,
       retry_max_time: nil,
       show_output: false,
-      user_agent: nil
+      show_error: true,
+      user_agent: nil,
+      referer: nil
     )
       args = []
 
       # do not load .curlrc unless requested (must be the first argument)
-      args << "--disable" unless Homebrew::EnvConfig.curlrc?
+      curlrc = Homebrew::EnvConfig.curlrc
+      if curlrc&.start_with?("/")
+        # If the file exists, we still want to disable loading the default curlrc.
+        args << "--disable" << "--config" << curlrc
+      elsif curlrc
+        # This matches legacy behavior: `HOMEBREW_CURLRC` was a bool,
+        # omitting `--disable` when present.
+      else
+        args << "--disable"
+      end
 
       # echo any cookies received on a redirect
       args << "--cookie" << "/dev/null"
 
       args << "--globoff"
 
-      args << "--show-error"
+      args << "--show-error" if show_error
 
       args << "--user-agent" << case user_agent
       when :browser, :fake
@@ -91,22 +120,24 @@ def curl_args(
 
       args << "--header" << "Accept-Language: en"
 
-      unless show_output == true
+      if show_output != true
         args << "--fail"
         args << "--progress-bar" unless Context.current.verbose?
         args << "--verbose" if Homebrew::EnvConfig.curl_verbose?
-        args << "--silent" unless $stdout.tty?
+        args << "--silent" if !$stdout.tty? || Context.current.quiet?
       end
 
       args << "--connect-timeout" << connect_timeout.round(3) if connect_timeout.present?
       args << "--max-time" << max_time.round(3) if max_time.present?
 
-      # A non-positive integer (e.g., 0) or `nil` will omit this argument
+      # A non-positive integer (e.g. 0) or `nil` will omit this argument
       args << "--retry" << retries if retries&.positive?
 
       args << "--retry-max-time" << retry_max_time.round if retry_max_time.present?
 
-      args + extra_args
+      args << "--referer" << referer if referer.present?
+
+      (args + extra_args).map(&:to_s)
     end
 
     def curl_with_workarounds(
@@ -117,33 +148,33 @@ def curl_with_workarounds(
       end_time = Time.now + timeout if timeout
 
       command_options = {
-        secrets:      secrets,
-        print_stdout: print_stdout,
-        print_stderr: print_stderr,
-        debug:        debug,
-        verbose:      verbose,
+        secrets:,
+        print_stdout:,
+        print_stderr:,
+        debug:,
+        verbose:,
       }.compact
 
-      result = system_command curl_executable(use_homebrew_curl: use_homebrew_curl),
+      result = system_command curl_executable(use_homebrew_curl:),
                               args:    curl_args(*args, **options),
-                              env:     env,
-                              timeout: end_time&.remaining,
+                              env:,
+                              timeout: Utils::Timer.remaining(end_time),
                               **command_options
 
-      return result if result.success? || !args.exclude?("--http1.1")
+      return result if result.success? || args.include?("--http1.1")
 
       raise Timeout::Error, result.stderr.lines.last.chomp if timeout && result.status.exitstatus == 28
 
       # Error in the HTTP2 framing layer
-      if result.status.exitstatus == 16
+      if result.exit_status == 16
         return curl_with_workarounds(
           *args, "--http1.1",
-          timeout: end_time&.remaining, **command_options, **options
+          timeout: Utils::Timer.remaining(end_time), **command_options, **options
         )
       end
 
       # This is a workaround for https://github.com/curl/curl/issues/1618.
-      if result.status.exitstatus == 56 # Unexpected EOF
+      if result.exit_status == 56 # Unexpected EOF
         out = curl_output("-V").stdout
 
         # If `curl` doesn't support HTTP2, the exception is unrelated to this bug.
@@ -160,7 +191,7 @@ def curl_with_workarounds(
     end
 
     def curl(*args, print_stdout: true, **options)
-      result = curl_with_workarounds(*args, print_stdout: print_stdout, **options)
+      result = curl_with_workarounds(*args, print_stdout:, **options)
       result.assert_success!
       result
     end
@@ -169,30 +200,31 @@ def curl_download(*args, to: nil, try_partial: false, **options)
       destination = Pathname(to)
       destination.dirname.mkpath
 
-      if try_partial
-        range_stdout = curl_output("--location", "--head", *args, **options).stdout
-        parsed_output = parse_curl_output(range_stdout)
+      args = ["--location", *args]
 
-        headers = if parsed_output[:responses].present?
-          parsed_output[:responses].last[:headers]
-        else
+      if try_partial && destination.exist?
+        headers = begin
+          parsed_output = curl_headers(*args, **options, wanted_headers: ["accept-ranges"])
+          parsed_output.fetch(:responses).last&.fetch(:headers) || {}
+        rescue ErrorDuringExecution
+          # Ignore errors here and let actual download fail instead.
           {}
         end
 
-        # Any value for `accept-ranges` other than none indicates that the server supports partial requests.
-        # Its absence indicates no support.
-        supports_partial = headers.key?("accept-ranges") && headers["accept-ranges"] != "none"
+        # Any value for `Accept-Ranges` other than `none` indicates that the server
+        # supports partial requests. Its absence indicates no support.
+        supports_partial = headers.fetch("accept-ranges", "none") != "none"
+        content_length = headers["content-length"]&.to_i
+
+        if supports_partial
+          # We've already downloaded all bytes.
+          return if destination.size == content_length
 
-        if supports_partial &&
-           destination.exist? &&
-           destination.size == headers["content-length"].to_i
-          return # We've already downloaded all the bytes
+          args = ["--continue-at", "-", *args]
         end
       end
 
-      args = ["--location", "--remote-time", "--output", destination, *args]
-      # continue-at shouldn't be used with servers that don't support partial requests.
-      args = ["--continue-at", "-", *args] if destination.exist? && supports_partial
+      args = ["--remote-time", "--output", destination, *args]
 
       curl(*args, **options)
     end
@@ -201,6 +233,43 @@ def curl_output(*args, **options)
       curl_with_workarounds(*args, print_stderr: false, show_output: true, **options)
     end
 
+    def curl_headers(*args, wanted_headers: [], **options)
+      get_retry_args = ["--request", "GET"]
+      # This is a workaround for https://github.com/Homebrew/brew/issues/18213
+      get_retry_args << "--http1.1" if curl_version >= Version.new("8.7") && curl_version < Version.new("8.10")
+
+      [[], get_retry_args].each do |request_args|
+        result = curl_output(
+          "--fail", "--location", "--silent", "--head", *request_args, *args,
+          **options
+        )
+
+        # We still receive usable headers with certain non-successful exit
+        # statuses, so we special case them below.
+        if result.success? || [
+          CURL_WEIRD_SERVER_REPLY_EXIT_CODE,
+          CURL_HTTP_RETURNED_ERROR_EXIT_CODE,
+          CURL_RECV_ERROR_EXIT_CODE,
+        ].include?(result.exit_status)
+          parsed_output = parse_curl_output(result.stdout)
+
+          if request_args.empty?
+            # If we didn't get any wanted header yet, retry using `GET`.
+            next if wanted_headers.any? &&
+                    parsed_output.fetch(:responses).none? { |r| (r.fetch(:headers).keys & wanted_headers).any? }
+
+            # Some CDNs respond with 400 codes for `HEAD` but resolve with `GET`.
+            next if (400..499).cover?(parsed_output.fetch(:responses).last&.fetch(:status_code).to_i)
+          end
+
+          return parsed_output if result.success? ||
+                                  result.exit_status == CURL_WEIRD_SERVER_REPLY_EXIT_CODE
+        end
+
+        result.assert_success!
+      end
+    end
+
     # Check if a URL is protected by CloudFlare (e.g. badlion.net and jaxx.io).
     # @param response [Hash] A response hash from `#parse_curl_response`.
     # @return [true, false] Whether a response contains headers indicating that
@@ -210,17 +279,7 @@ def url_protected_by_cloudflare?(response)
       return false if response[:headers].blank?
       return false unless [403, 503].include?(response[:status_code].to_i)
 
-      set_cookie_header = Array(response[:headers]["set-cookie"])
-      has_cloudflare_cookie_header = set_cookie_header.compact.any? do |cookie|
-        cookie.match?(/^(__cfduid|__cf_bm)=/i)
-      end
-
-      server_header = Array(response[:headers]["server"])
-      has_cloudflare_server = server_header.compact.any? do |server|
-        server.match?(/^cloudflare/i)
-      end
-
-      has_cloudflare_cookie_header && has_cloudflare_server
+      [*response[:headers]["server"]].any? { |server| server.match?(/^cloudflare/i) }
     end
 
     # Check if a URL is protected by Incapsula (e.g. corsair.com).
@@ -236,22 +295,23 @@ def url_protected_by_incapsula?(response)
       set_cookie_header.compact.any? { |cookie| cookie.match?(/^(visid_incap|incap_ses)_/i) }
     end
 
-    def curl_check_http_content(url, url_type, specs: {}, user_agents: [:default],
+    def curl_check_http_content(url, url_type, specs: {}, user_agents: [:default], referer: nil,
                                 check_content: false, strict: false, use_homebrew_curl: false)
       return unless url.start_with? "http"
 
       secure_url = url.sub(/\Ahttp:/, "https:")
-      secure_details = nil
-      hash_needed = false
+      secure_details = T.let(nil, T.nilable(T::Hash[Symbol, T.untyped]))
+      hash_needed = T.let(false, T::Boolean)
       if url != secure_url
         user_agents.each do |user_agent|
           secure_details = begin
             curl_http_content_headers_and_checksum(
               secure_url,
-              specs:             specs,
+              specs:,
               hash_needed:       true,
-              use_homebrew_curl: use_homebrew_curl,
-              user_agent:        user_agent,
+              use_homebrew_curl:,
+              user_agent:,
+              referer:,
             )
           rescue Timeout::Error
             next
@@ -265,32 +325,55 @@ def curl_check_http_content(url, url_type, specs: {}, user_agents: [:default],
         end
       end
 
-      details = nil
+      details = T.let(nil, T.nilable(T::Hash[Symbol, T.untyped]))
+      attempts = 0
       user_agents.each do |user_agent|
-        details =
-          curl_http_content_headers_and_checksum(
+        loop do
+          details = curl_http_content_headers_and_checksum(
             url,
-            specs:             specs,
-            hash_needed:       hash_needed,
-            use_homebrew_curl: use_homebrew_curl,
-            user_agent:        user_agent,
+            specs:,
+            hash_needed:,
+            use_homebrew_curl:,
+            user_agent:,
+            referer:,
           )
-        break if http_status_ok?(details[:status_code])
-      end
 
-      unless details[:status_code]
-        # Hack around https://github.com/Homebrew/brew/issues/3199
-        return if MacOS.version == :el_capitan
+          # Retry on network issues
+          break if details[:exit_status] != 52 && details[:exit_status] != 56
+
+          attempts += 1
+          break if attempts >= Homebrew::EnvConfig.curl_retries.to_i
+        end
 
-        return "The #{url_type} #{url} is not reachable"
+        break if http_status_ok?(details[:status_code])
       end
 
+      return "The #{url_type} #{url} is not reachable" unless details[:status_code]
+
       unless http_status_ok?(details[:status_code])
         return if details[:responses].any? do |response|
           url_protected_by_cloudflare?(response) || url_protected_by_incapsula?(response)
         end
 
-        return "The #{url_type} #{url} is not reachable (HTTP status code #{details[:status_code]})"
+        # https://github.com/Homebrew/brew/issues/13789
+        # If the `:homepage` of a formula is private, it will fail an `audit`
+        # since there's no way to specify a `strategy` with `using:` and
+        # GitHub does not authorize access to the web UI using token
+        #
+        # Strategy:
+        # If the `:homepage` 404s, it's a GitHub link and we have a token then
+        # check the API (which does use tokens) for the repository
+        repo_details = url.match(%r{https?://github\.com/(?<user>[^/]+)/(?<repo>[^/]+)/?.*})
+        check_github_api = url_type == SharedAudits::URL_TYPE_HOMEPAGE &&
+                           details[:status_code] == "404" &&
+                           repo_details &&
+                           Homebrew::EnvConfig.github_api_token.present?
+
+        unless check_github_api
+          return "The #{url_type} #{url} is not reachable (HTTP status code #{details[:status_code]})"
+        end
+
+        "Unable to find homepage" if SharedAudits.github_repo_data(repo_details[:user], repo_details[:repo]).nil?
       end
 
       if url.start_with?("https://") && Homebrew::EnvConfig.no_insecure_redirect? &&
@@ -336,7 +419,7 @@ def curl_check_http_content(url, url_type, specs: {}, user_agents: [:default],
         return "The #{url_type} #{url} may be able to use HTTPS rather than HTTP. Please verify it in a browser."
       end
 
-      lenratio = (100 * https_content.length / http_content.length).to_i
+      lenratio = (https_content.length * 100 / http_content.length).to_i
       return unless (90..110).cover?(lenratio)
 
       "The #{url_type} #{url} may be able to use HTTPS rather than HTTP. Please verify it in a browser."
@@ -344,7 +427,7 @@ def curl_check_http_content(url, url_type, specs: {}, user_agents: [:default],
 
     def curl_http_content_headers_and_checksum(
       url, specs: {}, hash_needed: false,
-      use_homebrew_curl: false, user_agent: :default
+      use_homebrew_curl: false, user_agent: :default, referer: nil
     )
       file = Tempfile.new.tap(&:close)
 
@@ -354,18 +437,19 @@ def curl_http_content_headers_and_checksum(
         next [] if argument == false # No flag.
 
         args = ["--#{option.to_s.tr("_", "-")}"]
-        args << argument unless argument == true # It's a flag.
+        args << argument if argument != true # It's a flag.
         args
       end
 
       max_time = hash_needed ? 600 : 25
       output, _, status = curl_output(
         *specs, "--dump-header", "-", "--output", file.path, "--location", url,
-        use_homebrew_curl: use_homebrew_curl,
+        use_homebrew_curl:,
         connect_timeout:   15,
-        max_time:          max_time,
+        max_time:,
         retry_max_time:    max_time,
-        user_agent:        user_agent
+        user_agent:,
+        referer:
       )
 
       parsed_output = parse_curl_output(output)
@@ -383,9 +467,15 @@ def curl_http_content_headers_and_checksum(
 
       if status.success?
         open_args = {}
+        content_type = headers["content-type"]
+
+        # Use the last `Content-Type` header if there is more than one instance
+        # in the response
+        content_type = content_type.last if content_type.is_a?(Array)
+
         # Try to get encoding from Content-Type header
         # TODO: add guessing encoding by <meta http-equiv="Content-Type" ...> tag
-        if (content_type = headers["content-type"]) &&
+        if content_type &&
            (match = content_type.match(/;\s*charset\s*=\s*([^\s]+)/)) &&
            (charset = match[1])
           begin
@@ -394,23 +484,36 @@ def curl_http_content_headers_and_checksum(
             # Unknown charset in Content-Type header
           end
         end
-        file_contents = File.read(file.path, open_args)
-        file_hash = Digest::SHA2.hexdigest(file_contents) if hash_needed
+        file_contents = File.read(T.must(file.path), **open_args)
+        file_hash = Digest::SHA256.hexdigest(file_contents) if hash_needed
       end
 
       {
-        url:            url,
-        final_url:      final_url,
-        status_code:    status_code,
-        headers:        headers,
-        etag:           etag,
-        content_length: content_length,
+        url:,
+        final_url:,
+        exit_status:    status.exitstatus,
+        status_code:,
+        headers:,
+        etag:,
+        content_length:,
         file:           file_contents,
-        file_hash:      file_hash,
-        responses:      responses,
+        file_hash:,
+        responses:,
       }
     ensure
-      file.unlink
+      T.must(file).unlink
+    end
+
+    def curl_version
+      @curl_version ||= {}
+      @curl_version[curl_path] ||= Version.new(curl_output("-V").stdout[/curl (\d+(\.\d+)+)/, 1])
+    end
+
+    def curl_supports_fail_with_body?
+      @curl_supports_fail_with_body ||= Hash.new do |h, key|
+        h[key] = curl_version >= Version.new("7.76.0")
+      end
+      @curl_supports_fail_with_body[curl_path]
     end
 
     def curl_supports_tls13?
@@ -426,7 +529,7 @@ def http_status_ok?(status)
 
     # Separates the output text from `curl` into an array of HTTP responses and
     # the final response body (i.e. content). Response hashes contain the
-    # `:status_code`, `:status_text`, and `:headers`.
+    # `:status_code`, `:status_text` and `:headers`.
     # @param output [String] The output text from `curl` containing HTTP
     #   responses, body content, or both.
     # @param max_iterations [Integer] The maximum number of iterations for the
@@ -455,7 +558,7 @@ def parse_curl_output(output, max_iterations: 25)
         responses << response if response.present?
       end
 
-      { responses: responses, body: output }
+      { responses:, body: output }
     end
 
     # Returns the URL from the last location header found in cURL responses,
@@ -488,6 +591,30 @@ def curl_response_last_location(responses, absolutize: false, base_url: nil)
       nil
     end
 
+    # Returns the final URL by following location headers in cURL responses.
+    # @param responses [Array<Hash>] An array of hashes containing response
+    #   status information and headers from `#parse_curl_response`.
+    # @param base_url [String] The URL to use as a base.
+    # @return [String] The final absolute URL after redirections.
+    sig {
+      params(
+        responses: T::Array[T::Hash[Symbol, T.untyped]],
+        base_url:  String,
+      ).returns(String)
+    }
+    def curl_response_follow_redirections(responses, base_url)
+      responses.each do |response|
+        next if response[:headers].blank?
+
+        location = response[:headers]["location"]
+        next if location.blank?
+
+        base_url = URI.join(base_url, location).to_s
+      end
+
+      base_url
+    end
+
     private
 
     # Parses HTTP response text from `curl` output into a hash containing the
@@ -503,7 +630,7 @@ def parse_curl_response(response_text)
       return response unless response_text.match?(HTTP_STATUS_LINE_REGEX)
 
       # Parse the status line and remove it
-      match = response_text.match(HTTP_STATUS_LINE_REGEX)
+      match = T.must(response_text.match(HTTP_STATUS_LINE_REGEX))
       response[:status_code] = match["code"] if match["code"].present?
       response[:status_text] = match["text"] if match["text"].present?
       response_text = response_text.sub(%r{^HTTP/.* (\d+).*$\s*}, "")
@@ -533,6 +660,3 @@ def parse_curl_response(response_text)
     end
   end
 end
-
-# FIXME: Include `Utils::Curl` explicitly everywhere it is used.
-include Utils::Curl # rubocop:disable Style/MixinUsage
diff --git a/Library/Homebrew/utils/fork.rb b/Library/Homebrew/utils/fork.rb
index ac1ff1182ae29..8a095941d4010 100644
--- a/Library/Homebrew/utils/fork.rb
+++ b/Library/Homebrew/utils/fork.rb
@@ -1,48 +1,57 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "fcntl"
-require "socket"
+require "utils/socket"
 
 module Utils
   def self.rewrite_child_error(child_error)
-    error = if child_error.inner["cmd"] &&
-               child_error.inner_class == ErrorDuringExecution
-      ErrorDuringExecution.new(child_error.inner["cmd"],
-                               status: child_error.inner["status"],
-                               output: child_error.inner["output"])
-    elsif child_error.inner["cmd"] &&
-          child_error.inner_class == BuildError
+    inner_class = Object.const_get(child_error["json_class"])
+    error = if child_error["cmd"] && inner_class == ErrorDuringExecution
+      ErrorDuringExecution.new(child_error["cmd"],
+                               status: child_error["status"],
+                               output: child_error["output"])
+    elsif child_error["cmd"] && inner_class == BuildError
       # We fill `BuildError#formula` and `BuildError#options` in later,
       # when we rescue this in `FormulaInstaller#build`.
-      BuildError.new(nil, child_error.inner["cmd"],
-                     child_error.inner["args"], child_error.inner["env"])
-    elsif child_error.inner_class == Interrupt
+      BuildError.new(nil, child_error["cmd"], child_error["args"], child_error["env"])
+    elsif inner_class == Interrupt
       Interrupt.new
     else
       # Everything other error in the child just becomes a RuntimeError.
-      RuntimeError.new(child_error.message)
+      RuntimeError.new <<~EOS
+        An exception occurred within a child process:
+          #{inner_class}: #{child_error["m"]}
+      EOS
     end
 
-    error.set_backtrace child_error.backtrace
+    error.set_backtrace child_error["b"]
 
     error
   end
 
-  def self.safe_fork
-    Dir.mktmpdir("homebrew", HOMEBREW_TEMP) do |tmpdir|
-      UNIXServer.open("#{tmpdir}/socket") do |server|
+  # When using this function, remember to call `exec` as soon as reasonably possible.
+  # This function does not protect against the pitfalls of what you can do pre-exec in a fork.
+  # See `man fork` for more information.
+  def self.safe_fork(directory: nil, yield_parent: false)
+    require "json/add/exception"
+
+    block = proc do |tmpdir|
+      UNIXServerExt.open("#{tmpdir}/socket") do |server|
         read, write = IO.pipe
 
         pid = fork do
           # bootsnap doesn't like these forked processes
           ENV["HOMEBREW_NO_BOOTSNAP"] = "1"
-
-          ENV["HOMEBREW_ERROR_PIPE"] = server.path
+          error_pipe = server.path
+          ENV["HOMEBREW_ERROR_PIPE"] = error_pipe
           server.close
           read.close
           write.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-          yield
+
+          Process::UID.change_privilege(Process.euid) if Process.euid != Process.uid
+
+          yield(error_pipe)
         rescue Exception => e # rubocop:disable Lint/RescueException
           error_hash = JSON.parse e.to_json
 
@@ -70,11 +79,15 @@ def self.safe_fork
           exit!(true)
         end
 
-        ignore_interrupts(:quietly) do # the child will receive the interrupt and marshal it back
+        pid = T.must(pid)
+
+        begin
+          yield(nil) if yield_parent
+
           begin
             socket = server.accept_nonblock
           rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR
-            retry unless Process.waitpid(T.must(pid), Process::WNOHANG)
+            retry unless Process.waitpid(pid, Process::WNOHANG)
           else
             socket.send_io(write)
             socket.close
@@ -82,24 +95,28 @@ def self.safe_fork
           write.close
           data = read.read
           read.close
-          Process.wait(T.must(pid)) unless socket.nil?
-
-          # 130 is the exit status for a process interrupted via Ctrl-C.
-          # We handle it here because of the possibility of an interrupted process terminating
-          # without writing its Interrupt exception to the error pipe.
-          raise Interrupt if $CHILD_STATUS.exitstatus == 130
-
-          if data.present?
-            error_hash = JSON.parse(T.must(data.lines.first))
-
-            e = ChildProcessError.new(error_hash)
+          Process.waitpid(pid) unless socket.nil?
+        rescue Interrupt
+          Process.waitpid(pid)
+        end
 
-            raise rewrite_child_error(e)
-          end
+        # 130 is the exit status for a process interrupted via Ctrl-C.
+        raise Interrupt if $CHILD_STATUS.exitstatus == 130
+        raise Interrupt if $CHILD_STATUS.termsig == Signal.list["INT"]
 
-          raise "Forked child process failed: #{$CHILD_STATUS}" unless $CHILD_STATUS.success?
+        if data.present?
+          error_hash = JSON.parse(T.must(data.lines.first))
+          raise rewrite_child_error(error_hash)
         end
+
+        raise ChildProcessError, $CHILD_STATUS unless $CHILD_STATUS.success?
       end
     end
+
+    if directory
+      block.call(directory)
+    else
+      Dir.mktmpdir("homebrew-fork", HOMEBREW_TEMP, &block)
+    end
   end
 end
diff --git a/Library/Homebrew/utils/formatter.rb b/Library/Homebrew/utils/formatter.rb
index eabd47549a12f..245dd716561fe 100644
--- a/Library/Homebrew/utils/formatter.rb
+++ b/Library/Homebrew/utils/formatter.rb
@@ -1,39 +1,52 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "utils/tty"
 
 # Helper module for formatting output.
 #
-# @api private
+# @api internal
 module Formatter
-  module_function
+  COMMAND_DESC_WIDTH = 80
+  OPTION_DESC_WIDTH = 45
 
-  def arrow(string, color: nil)
+  def self.arrow(string, color: nil)
     prefix("==>", string, color)
   end
 
-  def headline(string, color: nil)
-    arrow("#{Tty.bold}#{string}#{Tty.reset}", color: color)
+  # Format a string as headline.
+  #
+  # @api internal
+  def self.headline(string, color: nil)
+    arrow("#{Tty.bold}#{string}#{Tty.reset}", color:)
   end
 
-  def identifier(string)
+  def self.identifier(string)
     "#{Tty.green}#{string}#{Tty.default}"
   end
 
-  def option(string)
+  def self.option(string)
     "#{Tty.bold}#{string}#{Tty.reset}"
   end
 
-  def success(string, label: nil)
+  # Format a string as success, with an optional label.
+  #
+  # @api internal
+  def self.success(string, label: nil)
     label(label, string, :green)
   end
 
-  def warning(string, label: nil)
+  # Format a string as warning, with an optional label.
+  #
+  # @api internal
+  def self.warning(string, label: nil)
     label(label, string, :yellow)
   end
 
-  def error(string, label: nil)
+  # Format a string as error, with an optional label.
+  #
+  # @api internal
+  def self.error(string, label: nil)
     label(label, string, :red)
   end
 
@@ -50,27 +63,27 @@ def error(string, label: nil)
   # so we always wrap one word before an option.
   # @see https://github.com/Homebrew/brew/pull/12672
   # @see https://macromates.com/blog/2006/wrapping-text-with-regular-expressions/
-  def format_help_text(s, width: 172)
+  def self.format_help_text(string, width: 172)
     desc = OPTION_DESC_WIDTH
     indent = width - desc
-    s.gsub(/(?<=\S) *\n(?=\S)/, " ")
-     .gsub(/([`>)\]]:) /, "\\1\n    ")
-     .gsub(/^( +-.+  +(?=\S.{#{desc}}))(.{1,#{desc}})( +|$)(?!-)\n?/, "\\1\\2\n#{" " * indent}")
-     .gsub(/^( {#{indent}}(?=\S.{#{desc}}))(.{1,#{desc}})( +|$)(?!-)\n?/, "\\1\\2\n#{" " * indent}")
-     .gsub(/(.{1,#{width}})( +|$)(?!-)\n?/, "\\1\n")
+    string.gsub(/(?<=\S) *\n(?=\S)/, " ")
+          .gsub(/([`>)\]]:) /, "\\1\n    ")
+          .gsub(/^( +-.+  +(?=\S.{#{desc}}))(.{1,#{desc}})( +|$)(?!-)\n?/, "\\1\\2\n#{" " * indent}")
+          .gsub(/^( {#{indent}}(?=\S.{#{desc}}))(.{1,#{desc}})( +|$)(?!-)\n?/, "\\1\\2\n#{" " * indent}")
+          .gsub(/(.{1,#{width}})( +|$)(?!-)\n?/, "\\1\n")
   end
 
-  def url(string)
+  def self.url(string)
     "#{Tty.underline}#{string}#{Tty.no_underline}"
   end
 
-  def label(label, string, color)
+  def self.label(label, string, color)
     label = "#{label}:" unless label.nil?
     prefix(label, string, color)
   end
   private_class_method :label
 
-  def prefix(prefix, string, color)
+  def self.prefix(prefix, string, color)
     if prefix.nil? && color.nil?
       string
     elsif prefix.nil?
@@ -83,7 +96,10 @@ def prefix(prefix, string, color)
   end
   private_class_method :prefix
 
-  def columns(*objects, gap_size: 2)
+  # Layout objects in columns that fit the current terminal width.
+  #
+  # @api internal
+  def self.columns(*objects, gap_size: 2)
     objects = objects.flatten.map(&:to_s)
 
     fallback = proc do
@@ -91,11 +107,11 @@ def columns(*objects, gap_size: 2)
     end
 
     fallback.call if objects.empty?
-    fallback.call if respond_to?(:tty?) ? !tty? : !$stdout.tty?
+    fallback.call if respond_to?(:tty?) ? !T.unsafe(self).tty? : !$stdout.tty?
 
     console_width = Tty.width
     object_lengths = objects.map { |obj| Tty.strip_ansi(obj).length }
-    cols = (console_width + gap_size) / (object_lengths.max + gap_size)
+    cols = (console_width + gap_size) / (T.must(object_lengths.max) + gap_size)
 
     fallback.call if cols < 2
 
@@ -109,14 +125,14 @@ def columns(*objects, gap_size: 2)
     output = +""
 
     rows.times do |row_index|
-      item_indices_for_row = row_index.step(objects.size - 1, rows).to_a
+      item_indices_for_row = T.cast(row_index.step(objects.size - 1, rows).to_a, T::Array[Integer])
 
-      first_n = item_indices_for_row[0...-1].map do |index|
-        objects[index] + "".rjust(col_width - object_lengths[index])
+      first_n = T.must(item_indices_for_row[0...-1]).map do |index|
+        objects[index] + "".rjust(col_width - object_lengths.fetch(index))
       end
 
       # don't add trailing whitespace to last column
-      last = objects.values_at(item_indices_for_row.last)
+      last = objects.values_at(item_indices_for_row.fetch(-1))
 
       output.concat((first_n + last)
             .join(gap_string))
diff --git a/Library/Homebrew/utils/gems.rb b/Library/Homebrew/utils/gems.rb
index 24b7c5bd9002c..d4c2fa20dde02 100644
--- a/Library/Homebrew/utils/gems.rb
+++ b/Library/Homebrew/utils/gems.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true  # rubocop:disable Sorbet/StrictSigil
 # frozen_string_literal: true
 
 # Never `require` anything in this file (except English). It needs to be able to
@@ -9,23 +9,54 @@
 
 module Homebrew
   # Keep in sync with the `Gemfile.lock`'s BUNDLED WITH.
-  HOMEBREW_BUNDLER_VERSION = "1.17.3"
+  # After updating this, run `brew vendor-gems --update=--bundler`.
+  HOMEBREW_BUNDLER_VERSION = "2.5.20"
 
-  module_function
+  # Bump this whenever a committed vendored gem is later added to or exclusion removed from gitignore.
+  # This will trigger it to reinstall properly if `brew install-bundler-gems` needs it.
+  VENDOR_VERSION = 7
+  private_constant :VENDOR_VERSION
 
-  def ruby_bindir
-    "#{RbConfig::CONFIG["prefix"]}/bin"
+  RUBY_BUNDLE_VENDOR_DIRECTORY = (HOMEBREW_LIBRARY_PATH/"vendor/bundle/ruby").freeze
+  private_constant :RUBY_BUNDLE_VENDOR_DIRECTORY
+
+  # This is tracked across Ruby versions.
+  GEM_GROUPS_FILE = (RUBY_BUNDLE_VENDOR_DIRECTORY/".homebrew_gem_groups").freeze
+  private_constant :GEM_GROUPS_FILE
+
+  # This is tracked per Ruby version.
+  VENDOR_VERSION_FILE = (
+    RUBY_BUNDLE_VENDOR_DIRECTORY/"#{RbConfig::CONFIG["ruby_version"]}/.homebrew_vendor_version"
+  ).freeze
+  private_constant :VENDOR_VERSION_FILE
+
+  def self.gemfile
+    File.join(ENV.fetch("HOMEBREW_LIBRARY"), "Homebrew", "Gemfile")
+  end
+  private_class_method :gemfile
+
+  def self.bundler_definition
+    @bundler_definition ||= Bundler::Definition.build(Bundler.default_gemfile, Bundler.default_lockfile, false)
   end
+  private_class_method :bundler_definition
 
-  def gem_user_dir
-    ENV.fetch("HOMEBREW_TESTS_GEM_USER_DIR", nil) || Gem.user_dir
+  def self.valid_gem_groups
+    install_bundler!
+    require "bundler"
+
+    Bundler.with_unbundled_env do
+      ENV["BUNDLE_GEMFILE"] = gemfile
+      groups = bundler_definition.groups
+      groups.delete(:default)
+      groups.map(&:to_s)
+    end
   end
 
-  def gem_user_bindir
-    "#{gem_user_dir}/bin"
+  def self.ruby_bindir
+    "#{RbConfig::CONFIG["prefix"]}/bin"
   end
 
-  def ohai_if_defined(message)
+  def self.ohai_if_defined(message)
     if defined?(ohai)
       $stderr.ohai message
     else
@@ -33,7 +64,7 @@ def ohai_if_defined(message)
     end
   end
 
-  def opoo_if_defined(message)
+  def self.opoo_if_defined(message)
     if defined?(opoo)
       $stderr.opoo message
     else
@@ -41,7 +72,7 @@ def opoo_if_defined(message)
     end
   end
 
-  def odie_if_defined(message)
+  def self.odie_if_defined(message)
     if defined?(odie)
       odie message
     else
@@ -50,9 +81,14 @@ def odie_if_defined(message)
     end
   end
 
-  def setup_gem_environment!(gem_home: nil, gem_bindir: nil, setup_path: true)
+  def self.setup_gem_environment!(setup_path: true)
+    require "rubygems"
+    raise "RubyGems too old!" if Gem::Version.new(Gem::VERSION) < Gem::Version.new("2.2.0")
+
+    ENV["BUNDLER_NO_OLD_RUBYGEMS_WARNING"] = "1"
+
     # Match where our bundler gems are.
-    gem_home ||= "#{HOMEBREW_LIBRARY_PATH}/vendor/bundle/ruby/#{RbConfig::CONFIG["ruby_version"]}"
+    gem_home = "#{RUBY_BUNDLE_VENDOR_DIRECTORY}/#{RbConfig::CONFIG["ruby_version"]}"
     Gem.paths = {
       "GEM_HOME" => gem_home,
       "GEM_PATH" => gem_home,
@@ -65,10 +101,9 @@ def setup_gem_environment!(gem_home: nil, gem_bindir: nil, setup_path: true)
     return unless setup_path
 
     # Add necessary Ruby and Gem binary directories to `PATH`.
-    gem_bindir ||= Gem.bindir
     paths = ENV.fetch("PATH").split(":")
-    paths.unshift(gem_bindir) unless paths.include?(gem_bindir)
     paths.unshift(ruby_bindir) unless paths.include?(ruby_bindir)
+    paths.unshift(Gem.bindir) unless paths.include?(Gem.bindir)
     ENV["PATH"] = paths.compact.join(":")
 
     # Set envs so the above binaries can be invoked.
@@ -77,15 +112,17 @@ def setup_gem_environment!(gem_home: nil, gem_bindir: nil, setup_path: true)
     ENV["GEM_PATH"] = gem_home
   end
 
-  def install_gem!(name, version: nil, setup_gem_environment: true)
+  def self.install_gem!(name, version: nil, setup_gem_environment: true)
     setup_gem_environment! if setup_gem_environment
 
     specs = Gem::Specification.find_all_by_name(name, version)
 
     if specs.empty?
       ohai_if_defined "Installing '#{name}' gem"
-      # document: [] , is equivalent to --no-document
-      specs = Gem.install name, version, document: []
+      # `document: []` is equivalent to --no-document
+      # `build_args: []` stops ARGV being used as a default
+      # `env_shebang: true` makes shebangs generic to allow switching between system and Portable Ruby
+      specs = Gem.install name, version, document: [], build_args: [], env_shebang: true
     end
 
     specs += specs.flat_map(&:runtime_dependencies)
@@ -102,8 +139,8 @@ def install_gem!(name, version: nil, setup_gem_environment: true)
     odie_if_defined "failed to install the '#{name}' gem."
   end
 
-  def install_gem_setup_path!(name, version: nil, executable: name, setup_gem_environment: true)
-    install_gem!(name, version: version, setup_gem_environment: setup_gem_environment)
+  def self.install_gem_setup_path!(name, version: nil, executable: name, setup_gem_environment: true)
+    install_gem!(name, version:, setup_gem_environment:)
     return if find_in_path(executable)
 
     odie_if_defined <<~EOS
@@ -112,39 +149,104 @@ def install_gem_setup_path!(name, version: nil, executable: name, setup_gem_envi
     EOS
   end
 
-  def find_in_path(executable)
+  def self.find_in_path(executable)
     ENV.fetch("PATH").split(":").find do |path|
       File.executable?(File.join(path, executable))
     end
   end
+  private_class_method :find_in_path
 
-  def install_bundler!
-    setup_gem_environment!(gem_home: gem_user_dir, gem_bindir: gem_user_bindir)
+  def self.install_bundler!
+    old_bundler_version = ENV.fetch("BUNDLER_VERSION", nil)
+
+    setup_gem_environment!
+
+    ENV["BUNDLER_VERSION"] = HOMEBREW_BUNDLER_VERSION # Set so it correctly finds existing installs
     install_gem_setup_path!(
       "bundler",
       version:               HOMEBREW_BUNDLER_VERSION,
       executable:            "bundle",
       setup_gem_environment: false,
     )
+  ensure
+    ENV["BUNDLER_VERSION"] = old_bundler_version
+  end
+
+  def self.user_gem_groups
+    @user_gem_groups ||= if GEM_GROUPS_FILE.exist?
+      GEM_GROUPS_FILE.readlines(chomp: true)
+    else
+      []
+    end
+  end
+  private_class_method :user_gem_groups
+
+  def self.write_user_gem_groups(groups)
+    return if @user_gem_groups == groups && GEM_GROUPS_FILE.exist?
+
+    # Write the file atomically, in case we're working parallel
+    require "tempfile"
+    tmpfile = Tempfile.new([GEM_GROUPS_FILE.basename.to_s, "~"], GEM_GROUPS_FILE.dirname)
+    path = tmpfile.path
+    return if path.nil?
+
+    require "fileutils"
+    begin
+      FileUtils.chmod("+r", path)
+      tmpfile.write(groups.join("\n"))
+      tmpfile.close
+      File.rename(path, GEM_GROUPS_FILE)
+    ensure
+      tmpfile.unlink
+    end
+
+    @user_gem_groups = groups
   end
+  private_class_method :write_user_gem_groups
 
-  def install_bundler_gems!(only_warn_on_failure: false, setup_path: true, groups: [])
+  def self.forget_user_gem_groups!
+    GEM_GROUPS_FILE.truncate(0) if GEM_GROUPS_FILE.exist?
+    @user_gem_groups = []
+  end
+
+  def self.user_vendor_version
+    @user_vendor_version ||= if VENDOR_VERSION_FILE.exist?
+      VENDOR_VERSION_FILE.read.to_i
+    else
+      0
+    end
+  end
+  private_class_method :user_vendor_version
+
+  def self.install_bundler_gems!(only_warn_on_failure: false, setup_path: true, groups: [])
     old_path = ENV.fetch("PATH", nil)
     old_gem_path = ENV.fetch("GEM_PATH", nil)
     old_gem_home = ENV.fetch("GEM_HOME", nil)
     old_bundle_gemfile = ENV.fetch("BUNDLE_GEMFILE", nil)
     old_bundle_with = ENV.fetch("BUNDLE_WITH", nil)
+    old_bundle_frozen = ENV.fetch("BUNDLE_FROZEN", nil)
 
-    install_bundler!
+    invalid_groups = groups - valid_gem_groups
+    raise ArgumentError, "Invalid gem groups: #{invalid_groups.join(", ")}" unless invalid_groups.empty?
 
-    require "settings"
+    # Tests should not modify the state of the repository.
+    if ENV["HOMEBREW_TESTS"]
+      setup_gem_environment!
+      return
+    end
 
-    # Combine the passed groups with the ones stored in settings
-    groups |= (Homebrew::Settings.read(:gemgroups)&.split(";") || [])
+    install_bundler!
+
+    # Combine the passed groups with the ones stored in settings.
+    groups |= (user_gem_groups & valid_gem_groups)
     groups.sort!
 
-    ENV["BUNDLE_GEMFILE"] = File.join(ENV.fetch("HOMEBREW_LIBRARY"), "Homebrew", "Gemfile")
+    if (homebrew_bundle_user_cache = ENV.fetch("HOMEBREW_BUNDLE_USER_CACHE", nil))
+      ENV["BUNDLE_USER_CACHE"] = homebrew_bundle_user_cache
+    end
+    ENV["BUNDLE_GEMFILE"] = gemfile
     ENV["BUNDLE_WITH"] = groups.join(" ")
+    ENV["BUNDLE_FROZEN"] = "true"
 
     if @bundle_installed_groups != groups
       bundle = File.join(find_in_path("bundle"), "bundle")
@@ -152,8 +254,55 @@ def install_bundler_gems!(only_warn_on_failure: false, setup_path: true, groups:
       bundle_check_failed = !$CHILD_STATUS.success?
 
       # for some reason sometimes the exit code lies so check the output too.
-      bundle_installed = if bundle_check_failed || bundle_check_output.include?("Install missing gems")
-        if system bundle, "install"
+      bundle_install_required = bundle_check_failed || bundle_check_output.include?("Install missing gems")
+
+      if user_vendor_version != VENDOR_VERSION
+        # Check if the install is intact. This is useful if any gems are added to gitignore.
+        # We intentionally map over everything and then call `any?` so that we remove the spec of each bad gem.
+        specs = bundler_definition.resolve.materialize(bundler_definition.locked_dependencies)
+        vendor_reinstall_required = specs.map do |spec|
+          spec_file = "#{Gem.dir}/specifications/#{spec.full_name}.gemspec"
+          next false unless File.exist?(spec_file)
+
+          cache_file = "#{Gem.dir}/cache/#{spec.full_name}.gem"
+          if File.exist?(cache_file)
+            require "rubygems/package"
+            package = Gem::Package.new(cache_file)
+
+            package_install_intact = begin
+              contents = package.contents
+
+              # If the gem has contents, ensure we have every file installed it contains.
+              contents&.all? do |gem_file|
+                File.exist?("#{Gem.dir}/gems/#{spec.full_name}/#{gem_file}")
+              end
+            rescue Gem::Package::Error, Gem::Security::Exception
+              # Malformed, assume broken
+              File.unlink(cache_file)
+              false
+            end
+
+            next false if package_install_intact
+          end
+
+          # Mark gem for reinstallation
+          File.unlink(spec_file)
+          true
+        end.any?
+
+        VENDOR_VERSION_FILE.dirname.mkpath
+        VENDOR_VERSION_FILE.write(VENDOR_VERSION.to_s)
+
+        bundle_install_required ||= vendor_reinstall_required
+      end
+
+      bundle_installed = if bundle_install_required
+        Process.wait(fork do
+          # Native build scripts fail if EUID != UID
+          Process::UID.change_privilege(Process.euid) if Process.euid != Process.uid
+          exec bundle, "install", out: :err
+        end)
+        if $CHILD_STATUS.success?
           true
         else
           message = <<~EOS
@@ -166,12 +315,22 @@ def install_bundler_gems!(only_warn_on_failure: false, setup_path: true, groups:
           end
           false
         end
-      else
+      elsif system bundle, "clean", out: :err # even if we have nothing to install, we may have removed gems
         true
+      else
+        message = <<~EOS
+          failed to run `#{bundle} clean`!
+        EOS
+        if only_warn_on_failure
+          opoo_if_defined message
+        else
+          odie_if_defined message
+        end
+        false
       end
 
       if bundle_installed
-        Homebrew::Settings.write(:gemgroups, groups.join(";"))
+        write_user_gem_groups(groups)
         @bundle_installed_groups = groups
       end
     end
@@ -185,6 +344,7 @@ def install_bundler_gems!(only_warn_on_failure: false, setup_path: true, groups:
       ENV["GEM_HOME"] = old_gem_home
       ENV["BUNDLE_GEMFILE"] = old_bundle_gemfile
       ENV["BUNDLE_WITH"] = old_bundle_with
+      ENV["BUNDLE_FROZEN"] = old_bundle_frozen
     end
   end
 end
diff --git a/Library/Homebrew/utils/git.rb b/Library/Homebrew/utils/git.rb
index c81435a0b1c00..cd7649f7defd1 100644
--- a/Library/Homebrew/utils/git.rb
+++ b/Library/Homebrew/utils/git.rb
@@ -1,51 +1,52 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "system_command"
+
 module Utils
   # Helper functions for querying Git information.
   #
-  # @see GitRepositoryExtension
-  # @api private
+  # @see GitRepository
   module Git
-    module_function
+    extend SystemCommand::Mixin
 
-    def available?
+    def self.available?
       version.present?
     end
 
-    def version
+    def self.version
       return @version if defined?(@version)
 
       stdout, _, status = system_command(git, args: ["--version"], verbose: false, print_stderr: false)
       @version = status.success? ? stdout.chomp[/git version (\d+(?:\.\d+)*)/, 1] : nil
     end
 
-    def path
+    def self.path
       return unless available?
       return @path if defined?(@path)
 
       @path = Utils.popen_read(git, "--homebrew=print-path").chomp.presence
     end
 
-    def git
+    def self.git
       return @git if defined?(@git)
 
       @git = HOMEBREW_SHIMS_PATH/"shared/git"
     end
 
-    def remote_exists?(url)
+    def self.remote_exists?(url)
       return true unless available?
 
       quiet_system "git", "ls-remote", url
     end
 
-    def clear_available_cache
+    def self.clear_available_cache
       remove_instance_variable(:@version) if defined?(@version)
       remove_instance_variable(:@path) if defined?(@path)
       remove_instance_variable(:@git) if defined?(@git)
     end
 
-    def last_revision_commit_of_file(repo, file, before_commit: nil)
+    def self.last_revision_commit_of_file(repo, file, before_commit: nil)
       args = if before_commit.nil?
         ["--skip=1"]
       else
@@ -55,7 +56,7 @@ def last_revision_commit_of_file(repo, file, before_commit: nil)
       Utils.popen_read(git, "-C", repo, "log", "--format=%h", "--abbrev=7", "--max-count=1", *args, "--", file).chomp
     end
 
-    def last_revision_commit_of_files(repo, files, before_commit: nil)
+    def self.last_revision_commit_of_files(repo, files, before_commit: nil)
       args = if before_commit.nil?
         ["--skip=1"]
       else
@@ -76,19 +77,23 @@ def last_revision_commit_of_files(repo, files, before_commit: nil)
       [rev, paths]
     end
 
-    def last_revision_of_file(repo, file, before_commit: nil)
+    sig {
+      params(repo: T.any(Pathname, String), file: T.any(Pathname, String), before_commit: T.nilable(String))
+        .returns(String)
+    }
+    def self.last_revision_of_file(repo, file, before_commit: nil)
       relative_file = Pathname(file).relative_path_from(repo)
-      commit_hash = last_revision_commit_of_file(repo, relative_file, before_commit: before_commit)
+      commit_hash = last_revision_commit_of_file(repo, relative_file, before_commit:)
       file_at_commit(repo, file, commit_hash)
     end
 
-    def file_at_commit(repo, file, commit)
+    def self.file_at_commit(repo, file, commit)
       relative_file = Pathname(file)
       relative_file = relative_file.relative_path_from(repo) if relative_file.absolute?
       Utils.popen_read(git, "-C", repo, "show", "#{commit}:#{relative_file}")
     end
 
-    def ensure_installed!
+    def self.ensure_installed!
       return if available?
 
       # we cannot install brewed git if homebrew/core is unavailable.
@@ -108,7 +113,7 @@ def ensure_installed!
       raise "Git is unavailable" unless available?
     end
 
-    def set_name_email!(author: true, committer: true)
+    def self.set_name_email!(author: true, committer: true)
       if Homebrew::EnvConfig.git_name
         ENV["GIT_AUTHOR_NAME"] = Homebrew::EnvConfig.git_name if author
         ENV["GIT_COMMITTER_NAME"] = Homebrew::EnvConfig.git_name if committer
@@ -120,17 +125,16 @@ def set_name_email!(author: true, committer: true)
       ENV["GIT_COMMITTER_EMAIL"] = Homebrew::EnvConfig.git_email if committer
     end
 
-    def setup_gpg!
+    def self.setup_gpg!
       gnupg_bin = HOMEBREW_PREFIX/"opt/gnupg/bin"
       return unless gnupg_bin.directory?
 
-      ENV["PATH"] = PATH.new(ENV.fetch("PATH"))
-                        .prepend(gnupg_bin)
+      ENV["PATH"] = PATH.new(ENV.fetch("PATH")).prepend(gnupg_bin).to_s
     end
 
     # Special case of `git cherry-pick` that permits non-verbose output and
     # optional resolution on merge conflict.
-    def cherry_pick!(repo, *args, resolve: false, verbose: false)
+    def self.cherry_pick!(repo, *args, resolve: false, verbose: false)
       cmd = [git, "-C", repo, "cherry-pick"] + args
       output = Utils.popen_read(*cmd, err: :out)
       if $CHILD_STATUS.success?
@@ -141,5 +145,11 @@ def cherry_pick!(repo, *args, resolve: false, verbose: false)
         raise ErrorDuringExecution.new(cmd, status: $CHILD_STATUS, output: [[:stdout, output]])
       end
     end
+
+    def self.supports_partial_clone_sparse_checkout?
+      # There is some support for partial clones prior to 2.20, but we avoid using it
+      # due to performance issues
+      Version.new(version) >= Version.new("2.20.0")
+    end
   end
 end
diff --git a/Library/Homebrew/utils/git_repository.rb b/Library/Homebrew/utils/git_repository.rb
index 6c0e983a8921e..df76273bbbbd3 100644
--- a/Library/Homebrew/utils/git_repository.rb
+++ b/Library/Homebrew/utils/git_repository.rb
@@ -2,8 +2,6 @@
 # frozen_string_literal: true
 
 module Utils
-  extend T::Sig
-
   # Gets the full commit hash of the HEAD commit.
   sig {
     params(
@@ -13,10 +11,9 @@ module Utils
     ).returns(T.nilable(String))
   }
   def self.git_head(repo = Pathname.pwd, length: nil, safe: true)
-    return git_short_head(repo, length: length) if length.present?
+    return git_short_head(repo, length:) if length
 
-    repo = Pathname(repo).extend(GitRepositoryExtension)
-    repo.git_head(safe: safe)
+    GitRepository.new(Pathname(repo)).head_ref(safe:)
   end
 
   # Gets a short commit hash of the HEAD commit.
@@ -28,8 +25,7 @@ def self.git_head(repo = Pathname.pwd, length: nil, safe: true)
     ).returns(T.nilable(String))
   }
   def self.git_short_head(repo = Pathname.pwd, length: nil, safe: true)
-    repo = Pathname(repo).extend(GitRepositoryExtension)
-    repo.git_short_head(length: length, safe: safe)
+    GitRepository.new(Pathname(repo)).short_head_ref(length:, safe:)
   end
 
   # Gets the name of the currently checked-out branch, or HEAD if the repository is in a detached HEAD state.
@@ -40,8 +36,7 @@ def self.git_short_head(repo = Pathname.pwd, length: nil, safe: true)
     ).returns(T.nilable(String))
   }
   def self.git_branch(repo = Pathname.pwd, safe: true)
-    repo = Pathname(repo).extend(GitRepositoryExtension)
-    repo.git_branch(safe: safe)
+    GitRepository.new(Pathname(repo)).branch_name(safe:)
   end
 
   # Gets the full commit message of the specified commit, or of the HEAD commit if unspecified.
@@ -53,7 +48,6 @@ def self.git_branch(repo = Pathname.pwd, safe: true)
     ).returns(T.nilable(String))
   }
   def self.git_commit_message(repo = Pathname.pwd, commit: "HEAD", safe: true)
-    repo = Pathname(repo).extend(GitRepositoryExtension)
-    repo.git_commit_message(commit, safe: safe)
+    GitRepository.new(Pathname(repo)).commit_message(commit, safe:)
   end
 end
diff --git a/Library/Homebrew/utils/github.rb b/Library/Homebrew/utils/github.rb
index 072ea202c38cf..903116d46d255 100644
--- a/Library/Homebrew/utils/github.rb
+++ b/Library/Homebrew/utils/github.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "uri"
@@ -7,99 +7,94 @@
 
 require "system_command"
 
-# Wrapper functions for the GitHub API.
+# A module that interfaces with GitHub, code like PAT scopes, credential handling and API errors.
 #
-# @api private
+# @api internal
 module GitHub
-  extend T::Sig
+  extend SystemCommand::Mixin
 
-  include SystemCommand::Mixin
-
-  module_function
-
-  def check_runs(repo: nil, commit: nil, pr: nil)
-    if pr
-      repo = pr.fetch("base").fetch("repo").fetch("full_name")
-      commit = pr.fetch("head").fetch("sha")
+  def self.check_runs(repo: nil, commit: nil, pull_request: nil)
+    if pull_request
+      repo = pull_request.fetch("base").fetch("repo").fetch("full_name")
+      commit = pull_request.fetch("head").fetch("sha")
     end
 
     API.open_rest(url_to("repos", repo, "commits", commit, "check-runs"))
   end
 
-  def create_check_run(repo:, data:)
-    API.open_rest(url_to("repos", repo, "check-runs"), data: data)
+  def self.create_check_run(repo:, data:)
+    API.open_rest(url_to("repos", repo, "check-runs"), data:)
   end
 
-  def search_issues(query, **qualifiers)
-    search("issues", query, **qualifiers)
+  def self.issues(repo:, **filters)
+    uri = url_to("repos", repo, "issues")
+    uri.query = URI.encode_www_form(filters)
+    API.open_rest(uri)
   end
 
-  def create_gist(files, description, private:)
+  def self.search_issues(query, **qualifiers)
+    search_results_items("issues", query, **qualifiers)
+  end
+
+  def self.count_issues(query, **qualifiers)
+    search_results_count("issues", query, **qualifiers)
+  end
+
+  def self.create_gist(files, description, private:)
     url = "#{API_URL}/gists"
     data = { "public" => !private, "files" => files, "description" => description }
-    API.open_rest(url, data: data, scopes: CREATE_GIST_SCOPES)["html_url"]
+    API.open_rest(url, data:, scopes: CREATE_GIST_SCOPES)["html_url"]
   end
 
-  def create_issue(repo, title, body)
+  def self.create_issue(repo, title, body)
     url = "#{API_URL}/repos/#{repo}/issues"
     data = { "title" => title, "body" => body }
-    API.open_rest(url, data: data, scopes: CREATE_ISSUE_FORK_OR_PR_SCOPES)["html_url"]
+    API.open_rest(url, data:, scopes: CREATE_ISSUE_FORK_OR_PR_SCOPES)["html_url"]
   end
 
-  def repository(user, repo)
+  def self.repository(user, repo)
     API.open_rest(url_to("repos", user, repo))
   end
 
-  def search_code(repo: nil, user: "Homebrew", path: ["Formula", "Casks", "."], filename: nil, extension: "rb")
-    matches = search("code", user: user, path: path, filename: filename, extension: extension, repo: repo)
-    return matches if matches.blank?
-
-    matches.map do |match|
-      # .sub workaround for GitHub returning preceding /
-      match["path"] = match["path"].delete_prefix("/")
-      match
-    end
-  end
-
-  def issues_for_formula(name, tap: CoreTap.instance, tap_remote_repo: tap&.full_name, state: nil)
+  def self.issues_for_formula(name, tap: CoreTap.instance, tap_remote_repo: tap&.full_name, state: nil, type: nil)
     return [] unless tap_remote_repo
 
-    search_issues(name, repo: tap_remote_repo, state: state, in: "title")
+    search_issues(name, repo: tap_remote_repo, state:, type:, in: "title")
   end
 
-  def user
+  def self.user
     @user ||= API.open_rest("#{API_URL}/user")
   end
 
-  def permission(repo, user)
+  def self.permission(repo, user)
     API.open_rest("#{API_URL}/repos/#{repo}/collaborators/#{user}/permission")
   end
 
-  def write_access?(repo, user = nil)
+  def self.write_access?(repo, user = nil)
     user ||= self.user["login"]
     ["admin", "write"].include?(permission(repo, user)["permission"])
   end
 
-  def branch_exists?(user, repo, branch)
+  def self.branch_exists?(user, repo, branch)
     API.open_rest("#{API_URL}/repos/#{user}/#{repo}/branches/#{branch}")
     true
   rescue API::HTTPNotFoundError
     false
   end
 
-  def pull_requests(repo, **options)
+  def self.pull_requests(repo, **options)
     url = "#{API_URL}/repos/#{repo}/pulls?#{URI.encode_www_form(options)}"
     API.open_rest(url)
   end
 
-  def merge_pull_request(repo, number:, sha:, merge_method:, commit_message: nil)
+  def self.merge_pull_request(repo, number:, sha:, merge_method:, commit_message: nil)
     url = "#{API_URL}/repos/#{repo}/pulls/#{number}/merge"
-    data = { sha: sha, merge_method: merge_method }
+    data = { sha:, merge_method: }
     data[:commit_message] = commit_message if commit_message
-    API.open_rest(url, data: data, request_method: :PUT, scopes: CREATE_ISSUE_FORK_OR_PR_SCOPES)
+    API.open_rest(url, data:, request_method: :PUT, scopes: CREATE_ISSUE_FORK_OR_PR_SCOPES)
   end
 
-  def print_pull_requests_matching(query, only = nil)
+  def self.print_pull_requests_matching(query, only = nil)
     open_or_closed_prs = search_issues(query, is: only, type: "pr", user: "Homebrew")
 
     open_prs, closed_prs = open_or_closed_prs.partition { |pr| pr["state"] == "open" }
@@ -122,15 +117,15 @@ def print_pull_requests_matching(query, only = nil)
     puts "No pull requests found for #{query.inspect}" if open_prs.blank? && closed_prs.blank?
   end
 
-  def create_fork(repo, org: nil)
+  def self.create_fork(repo, org: nil)
     url = "#{API_URL}/repos/#{repo}/forks"
     data = {}
     data[:organization] = org if org
     scopes = CREATE_ISSUE_FORK_OR_PR_SCOPES
-    API.open_rest(url, data: data, scopes: scopes)
+    API.open_rest(url, data:, scopes:)
   end
 
-  def check_fork_exists(repo, org: nil)
+  def self.fork_exists?(repo, org: nil)
     _, reponame = repo.split("/")
 
     username = org || API.open_rest(url_to("user")) { |json| json["login"] }
@@ -141,42 +136,63 @@ def check_fork_exists(repo, org: nil)
     true
   end
 
-  def create_pull_request(repo, title, head, base, body)
+  def self.create_pull_request(repo, title, head, base, body)
     url = "#{API_URL}/repos/#{repo}/pulls"
-    data = { title: title, head: head, base: base, body: body }
+    data = { title:, head:, base:, body:, maintainer_can_modify: true }
     scopes = CREATE_ISSUE_FORK_OR_PR_SCOPES
-    API.open_rest(url, data: data, scopes: scopes)
+    API.open_rest(url, data:, scopes:)
   end
 
-  def private_repo?(full_name)
+  def self.private_repo?(full_name)
     uri = url_to "repos", full_name
     API.open_rest(uri) { |json| json["private"] }
   end
 
-  def query_string(*main_params, **qualifiers)
+  def self.search_query_string(*main_params, **qualifiers)
     params = main_params
 
-    params += qualifiers.flat_map do |key, value|
-      Array(value).map { |v| "#{key}:#{v}" }
+    from = qualifiers.fetch(:from, nil)
+    to = qualifiers.fetch(:to, nil)
+
+    params << if from && to
+      "created:#{from}..#{to}"
+    elsif from
+      "created:>=#{from}"
+    elsif to
+      "created:<=#{to}"
+    end
+
+    params += qualifiers.except(:args, :from, :to).flat_map do |key, value|
+      Array(value).map { |v| "#{key.to_s.tr("_", "-")}:#{v}" }
     end
 
-    "q=#{URI.encode_www_form_component(params.join(" "))}&per_page=100"
+    "q=#{URI.encode_www_form_component(params.compact.join(" "))}&per_page=100"
   end
 
-  def url_to(*subroutes)
+  def self.url_to(*subroutes)
     URI.parse([API_URL, *subroutes].join("/"))
   end
 
-  def search(entity, *queries, **qualifiers)
+  def self.search(entity, *queries, **qualifiers)
     uri = url_to "search", entity
-    uri.query = query_string(*queries, **qualifiers)
-    API.open_rest(uri) { |json| json.fetch("items", []) }
+    uri.query = search_query_string(*queries, **qualifiers)
+    API.open_rest(uri)
+  end
+
+  def self.search_results_items(entity, *queries, **qualifiers)
+    json = search(entity, *queries, **qualifiers)
+    json.fetch("items", [])
+  end
+
+  def self.search_results_count(entity, *queries, **qualifiers)
+    json = search(entity, *queries, **qualifiers)
+    json.fetch("total_count", 0)
   end
 
-  def approved_reviews(user, repo, pr, commit: nil)
+  def self.approved_reviews(user, repo, pull_request, commit: nil)
     query = <<~EOS
       { repository(name: "#{repo}", owner: "#{user}") {
-          pullRequest(number: #{pr}) {
+          pullRequest(number: #{pull_request}) {
             reviews(states: APPROVED, first: 100) {
               nodes {
                 author {
@@ -196,7 +212,7 @@ def approved_reviews(user, repo, pr, commit: nil)
     reviews = result["repository"]["pullRequest"]["reviews"]["nodes"]
 
     valid_associations = %w[MEMBER OWNER]
-    reviews.map do |r|
+    reviews.filter_map do |r|
       next if commit.present? && commit != r["commit"]["oid"]
       next unless valid_associations.include? r["authorAssociation"]
 
@@ -211,41 +227,41 @@ def approved_reviews(user, repo, pr, commit: nil)
         "name"  => name,
         "login" => r["author"]["login"],
       }
-    end.compact
+    end
   end
 
-  def dispatch_event(user, repo, event, **payload)
+  def self.dispatch_event(user, repo, event, **payload)
     url = "#{API_URL}/repos/#{user}/#{repo}/dispatches"
     API.open_rest(url, data:           { event_type: event, client_payload: payload },
                        request_method: :POST,
                        scopes:         CREATE_ISSUE_FORK_OR_PR_SCOPES)
   end
 
-  def workflow_dispatch_event(user, repo, workflow, ref, **inputs)
+  def self.workflow_dispatch_event(user, repo, workflow, ref, **inputs)
     url = "#{API_URL}/repos/#{user}/#{repo}/actions/workflows/#{workflow}/dispatches"
-    API.open_rest(url, data:           { ref: ref, inputs: inputs },
+    API.open_rest(url, data:           { ref:, inputs: },
                        request_method: :POST,
                        scopes:         CREATE_ISSUE_FORK_OR_PR_SCOPES)
   end
 
-  def get_release(user, repo, tag)
+  def self.get_release(user, repo, tag)
     url = "#{API_URL}/repos/#{user}/#{repo}/releases/tags/#{tag}"
     API.open_rest(url, request_method: :GET)
   end
 
-  def get_latest_release(user, repo)
+  def self.get_latest_release(user, repo)
     url = "#{API_URL}/repos/#{user}/#{repo}/releases/latest"
     API.open_rest(url, request_method: :GET)
   end
 
-  def generate_release_notes(user, repo, tag, previous_tag: nil)
+  def self.generate_release_notes(user, repo, tag, previous_tag: nil)
     url = "#{API_URL}/repos/#{user}/#{repo}/releases/generate-notes"
     data = { tag_name: tag }
     data[:previous_tag_name] = previous_tag if previous_tag.present?
-    API.open_rest(url, data: data, request_method: :POST, scopes: CREATE_ISSUE_FORK_OR_PR_SCOPES)
+    API.open_rest(url, data:, request_method: :POST, scopes: CREATE_ISSUE_FORK_OR_PR_SCOPES)
   end
 
-  def create_or_update_release(user, repo, tag, id: nil, name: nil, body: nil, draft: false)
+  def self.create_or_update_release(user, repo, tag, id: nil, name: nil, body: nil, draft: false)
     url = "#{API_URL}/repos/#{user}/#{repo}/releases"
     method = if id
       url += "/#{id}"
@@ -256,24 +272,24 @@ def create_or_update_release(user, repo, tag, id: nil, name: nil, body: nil, dra
     data = {
       tag_name: tag,
       name:     name || tag,
-      draft:    draft,
+      draft:,
     }
     data[:body] = body if body.present?
-    API.open_rest(url, data: data, request_method: method, scopes: CREATE_ISSUE_FORK_OR_PR_SCOPES)
+    API.open_rest(url, data:, request_method: method, scopes: CREATE_ISSUE_FORK_OR_PR_SCOPES)
   end
 
-  def upload_release_asset(user, repo, id, local_file: nil, remote_file: nil)
+  def self.upload_release_asset(user, repo, id, local_file: nil, remote_file: nil)
     url = "https://uploads.github.com/repos/#{user}/#{repo}/releases/#{id}/assets"
     url += "?name=#{remote_file}" if remote_file
     API.open_rest(url, data_binary_path: local_file, request_method: :POST, scopes: CREATE_ISSUE_FORK_OR_PR_SCOPES)
   end
 
-  def get_workflow_run(user, repo, pr, workflow_id: "tests.yml", artifact_name: "bottles")
+  def self.get_workflow_run(user, repo, pull_request, workflow_id: "tests.yml", artifact_pattern: "bottles{,_*}")
     scopes = CREATE_ISSUE_FORK_OR_PR_SCOPES
 
     # GraphQL unfortunately has no way to get the workflow yml name, so we need an extra REST call.
     workflow_api_url = "#{API_URL}/repos/#{user}/#{repo}/actions/workflows/#{workflow_id}"
-    workflow_payload = API.open_rest(workflow_api_url, scopes: scopes)
+    workflow_payload = API.open_rest(workflow_api_url, scopes:)
     workflow_id_num = workflow_payload["id"]
 
     query = <<~EOS
@@ -303,11 +319,11 @@ def get_workflow_run(user, repo, pr, workflow_id: "tests.yml", artifact_name: "b
       }
     EOS
     variables = {
-      user: user,
-      repo: repo,
-      pr:   pr.to_i,
+      user:,
+      repo:,
+      pr:   pull_request.to_i,
     }
-    result = API.open_graphql(query, variables: variables, scopes: scopes)
+    result = API.open_graphql(query, variables:, scopes:)
 
     commit_node = result["repository"]["pullRequest"]["commits"]["nodes"].first
     check_suite = if commit_node.present?
@@ -318,11 +334,11 @@ def get_workflow_run(user, repo, pr, workflow_id: "tests.yml", artifact_name: "b
       []
     end
 
-    [check_suite, user, repo, pr, workflow_id, scopes, artifact_name]
+    [check_suite, user, repo, pull_request, workflow_id, scopes, artifact_pattern]
   end
 
-  def get_artifact_url(workflow_array)
-    check_suite, user, repo, pr, workflow_id, scopes, artifact_name = *workflow_array
+  def self.get_artifact_urls(workflow_array)
+    check_suite, user, repo, pr, workflow_id, scopes, artifact_pattern = *workflow_array
     if check_suite.empty?
       raise API::Error, <<~EOS
         No matching check suite found for these criteria!
@@ -331,36 +347,45 @@ def get_artifact_url(workflow_array)
       EOS
     end
 
-    status = check_suite.first["status"].sub("_", " ").downcase
+    status = check_suite.last["status"].sub("_", " ").downcase
     if status != "completed"
       raise API::Error, <<~EOS
         The newest workflow run for ##{pr} is still #{status}!
-          #{Formatter.url check_suite.first["workflowRun"]["url"]}
+          #{Formatter.url check_suite.last["workflowRun"]["url"]}
       EOS
     end
 
-    run_id = check_suite.first["workflowRun"]["databaseId"]
-    artifacts = API.open_rest("#{API_URL}/repos/#{user}/#{repo}/actions/runs/#{run_id}/artifacts", scopes: scopes)
-
-    artifact = artifacts["artifacts"].select do |art|
-      art["name"] == artifact_name
+    run_id = check_suite.last["workflowRun"]["databaseId"]
+    artifacts = []
+    per_page = 50
+    API.paginate_rest("#{API_URL}/repos/#{user}/#{repo}/actions/runs/#{run_id}/artifacts",
+                      per_page:, scopes:) do |result|
+      result = result["artifacts"]
+      artifacts.concat(result)
+      break if result.length < per_page
     end
 
-    if artifact.empty?
+    matching_artifacts =
+      artifacts
+      .group_by { |art| art["name"] }
+      .select { |name| File.fnmatch?(artifact_pattern, name, File::FNM_EXTGLOB) }
+      .map { |_, arts| arts.last }
+
+    if matching_artifacts.empty?
       raise API::Error, <<~EOS
-        No artifact with the name `#{artifact_name}` was found!
-          #{Formatter.url check_suite.first["workflowRun"]["url"]}
+        No artifacts with the pattern `#{artifact_pattern}` were found!
+          #{Formatter.url check_suite.last["workflowRun"]["url"]}
       EOS
     end
 
-    artifact.last["archive_download_url"]
+    matching_artifacts.map { |art| art["archive_download_url"] }
   end
 
-  def public_member_usernames(org, per_page: 100)
+  def self.public_member_usernames(org, per_page: 100)
     url = "#{API_URL}/orgs/#{org}/public_members"
     members = []
 
-    API.paginate_rest(url, per_page: per_page) do |result|
+    API.paginate_rest(url, per_page:) do |result|
       result = result.map { |member| member["login"] }
       members.concat(result)
 
@@ -368,7 +393,7 @@ def public_member_usernames(org, per_page: 100)
     end
   end
 
-  def members_by_team(org, team)
+  def self.members_by_team(org, team)
     query = <<~EOS
         { organization(login: "#{org}") {
           teams(first: 100) {
@@ -397,134 +422,289 @@ def members_by_team(org, team)
     result["organization"]["team"]["members"]["nodes"].to_h { |member| [member["login"], member["name"]] }
   end
 
-  def sponsors_by_tier(user)
+  sig {
+    params(user: String)
+      .returns(
+        T::Array[{
+          closest_tier_monthly_amount: Integer,
+          login:                       String,
+          monthly_amount:              Integer,
+          name:                        String,
+        }],
+      )
+  }
+  def self.sponsorships(user)
     query = <<~EOS
-        { organization(login: "#{user}") {
-          sponsorsListing {
-            tiers(first: 10, orderBy: {field: MONTHLY_PRICE_IN_CENTS, direction: DESC}) {
-              nodes {
+        query($user: String!, $after: String) { organization(login: $user) {
+          sponsorshipsAsMaintainer(first: 100, after: $after) {
+            pageInfo {
+              hasNextPage
+              endCursor
+            }
+            nodes {
+              tier {
                 monthlyPriceInDollars
-                adminInfo {
-                  sponsorships(first: 100, includePrivate: true) {
-                    totalCount
-                    nodes {
-                      privacyLevel
-                      sponsorEntity {
-                        __typename
-                        ... on Organization { login name }
-                        ... on User { login name }
-                      }
-                    }
-                  }
+                closestLesserValueTier {
+                  monthlyPriceInDollars
                 }
               }
+              sponsorEntity {
+                ... on Organization { login name }
+                ... on User { login name }
+              }
             }
           }
         }
       }
     EOS
-    result = API.open_graphql(query, scopes: ["admin:org", "user"])
 
-    tiers = result["organization"]["sponsorsListing"]["tiers"]["nodes"]
+    sponsorships = T.let([], T::Array[Hash])
+    errors = T.let([], T::Array[Hash])
 
-    tiers.map do |t|
-      tier = t["monthlyPriceInDollars"]
-      raise API::Error, "Your token needs the 'admin:org' scope to access this API" if t["adminInfo"].nil?
+    API.paginate_graphql(query, variables: { user: }, scopes: ["user"], raise_errors: false) do |result|
+      # Some organisations do not permit themselves to be queried through the
+      # API like this and raise an error so handle these errors later.
+      # This has been reported to GitHub.
+      errors += result["errors"] if result["errors"].present?
 
-      sponsorships = t["adminInfo"]["sponsorships"]
-      count = sponsorships["totalCount"]
-      sponsors = sponsorships["nodes"].map do |sponsor|
-        next unless sponsor["privacyLevel"] == "PUBLIC"
+      current_sponsorships = result.dig("data", "organization", "sponsorshipsAsMaintainer")
+      # if `current_sponsorships` is blank, then there should be errors to report.
+      next { "hasNextPage" => false } if current_sponsorships.blank?
 
-        se = sponsor["sponsorEntity"]
-        {
-          "name"  => se["name"].presence || sponsor["login"],
-          "login" => se["login"],
-          "type"  => se["__typename"].downcase,
-        }
-      end.compact
+      # The organisations mentioned above will show up as nil nodes.
+      if (nodes = current_sponsorships["nodes"].compact.presence)
+        sponsorships += nodes
+      end
+
+      current_sponsorships.fetch("pageInfo")
+    end
+
+    # Only raise errors if we didn't get any sponsorships.
+    if sponsorships.blank? && errors.present?
+      raise API::Error, errors.map { |e| "#{e["type"]}: #{e["message"]}" }.join("\n")
+    end
+
+    sponsorships.map do |sponsorship|
+      sponsor = sponsorship["sponsorEntity"]
+      tier = sponsorship["tier"].presence || {}
+      monthly_amount = tier["monthlyPriceInDollars"].presence || 0
+      closest_tier = tier["closestLesserValueTier"].presence || {}
+      closest_tier_monthly_amount = closest_tier["monthlyPriceInDollars"].presence || 0
 
       {
-        "tier"     => tier,
-        "count"    => count,
-        "sponsors" => sponsors,
+        name:                        sponsor["name"].presence || sponsor["login"],
+        login:                       sponsor["login"],
+        monthly_amount:,
+        closest_tier_monthly_amount:,
       }
-    end.compact
+    end
   end
 
-  def get_repo_license(user, repo)
-    response = API.open_rest("#{API_URL}/repos/#{user}/#{repo}/license")
+  def self.get_repo_license(user, repo, ref: nil)
+    url = "#{API_URL}/repos/#{user}/#{repo}/license"
+    url += "?ref=#{ref}" if ref.present?
+    response = API.open_rest(url)
     return unless response.key?("license")
 
     response["license"]["spdx_id"]
   rescue API::HTTPNotFoundError
     nil
+  rescue API::AuthenticationFailedError => e
+    raise unless e.message.match?(API::GITHUB_IP_ALLOWLIST_ERROR)
   end
 
-  def fetch_pull_requests(name, tap_remote_repo, state: nil, version: nil)
-    if version.present?
-      query = "#{name} #{version}"
-      regex = /(^|\s)#{Regexp.quote(name)}(:|,|\s)(.*\s)?#{Regexp.quote(version)}(:|,|\s|$)/i
-    else
-      query = name
-      regex = /(^|\s)#{Regexp.quote(name)}(:|,|\s|$)/i
+  def self.pull_request_title_regex(name, version = nil)
+    return /(^|\s)#{Regexp.quote(name)}(:|,|\s|$)/i if version.blank?
+
+    /(^|\s)#{Regexp.quote(name)}(:|,|\s)(.*\s)?#{Regexp.quote(version)}(:|,|\s|$)/i
+  end
+
+  sig {
+    params(name: String, tap_remote_repo: String, state: T.nilable(String), version: T.nilable(String))
+      .returns(T::Array[T::Hash[String, T.untyped]])
+  }
+  def self.fetch_pull_requests(name, tap_remote_repo, state: nil, version: nil)
+    return [] if Homebrew::EnvConfig.no_github_api?
+
+    regex = pull_request_title_regex(name, version)
+    query = "is:pr #{name} #{version}".strip
+
+    # Unauthenticated users cannot use GraphQL so use search REST API instead.
+    # Limit for this is 30/minute so is usually OK unless you're spamming bump PRs (e.g. CI).
+    if API.credentials_type == :none
+      return issues_for_formula(query, tap_remote_repo:, state:).select do |pr|
+        pr["html_url"].include?("/pull/") && regex.match?(pr["title"])
+      end
+    elsif state == "open" && ENV["GITHUB_REPOSITORY_OWNER"] == "Homebrew"
+      # Try use PR API, which might be cheaper on rate limits in some cases.
+      # The rate limit of the search API under GraphQL is unclear as it
+      # costs the same as any other query according to /rate_limit.
+      # The PR API is also not very scalable so limit to Homebrew CI.
+      return fetch_open_pull_requests(name, tap_remote_repo, version:)
+    end
+
+    query += " repo:#{tap_remote_repo} in:title"
+    query += " state:#{state}" if state.present?
+    graphql_query = <<~EOS
+      query($query: String!, $after: String) {
+        search(query: $query, type: ISSUE, first: 100, after: $after) {
+          nodes {
+            ... on PullRequest {
+              number
+              title
+              url
+              state
+            }
+          }
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
+        }
+      }
+    EOS
+    variables = { query: }
+
+    pull_requests = []
+    API.paginate_graphql(graphql_query, variables:) do |result|
+      data = result["search"]
+      pull_requests.concat(data["nodes"].select { |pr| regex.match?(pr["title"]) })
+      data["pageInfo"]
     end
-    issues_for_formula(query, tap_remote_repo: tap_remote_repo, state: state).select do |pr|
-      pr["html_url"].include?("/pull/") && regex.match?(pr["title"])
+    pull_requests.map! do |pr|
+      pr.merge({
+        "html_url" => pr.delete("url"),
+        "state"    => pr.fetch("state").downcase,
+      })
     end
   rescue API::RateLimitExceededError => e
     opoo e.message
-    []
+    pull_requests || []
   end
 
-  def check_for_duplicate_pull_requests(name, tap_remote_repo, state:, file:, args:, version: nil)
-    pull_requests = fetch_pull_requests(name, tap_remote_repo, state: state, version: version).select do |pr|
-      pr_files = API.open_rest(url_to("repos", tap_remote_repo, "pulls", pr["number"], "files"))
-      pr_files.any? { |f| f["filename"] == file }
+  def self.fetch_open_pull_requests(name, tap_remote_repo, version: nil)
+    return [] if tap_remote_repo.blank?
+
+    # Bust the cache every three minutes.
+    cache_expiry = 3 * 60
+    cache_epoch = Time.now - (Time.now.to_i % cache_expiry)
+    cache_key = "#{tap_remote_repo}_#{cache_epoch.to_i}"
+
+    @open_pull_requests ||= {}
+    @open_pull_requests[cache_key] ||= begin
+      query = <<~EOS
+        query($owner: String!, $repo: String!, $states: [PullRequestState!], $after: String) {
+          repository(owner: $owner, name: $repo) {
+            pullRequests(states: $states, first: 100, after: $after) {
+              nodes {
+                number
+                title
+                url
+              }
+              pageInfo {
+                hasNextPage
+                endCursor
+              }
+            }
+          }
+        }
+      EOS
+      owner, repo = tap_remote_repo.split("/")
+      variables = { owner:, repo:, states: ["OPEN"] }
+
+      pull_requests = []
+      API.paginate_graphql(query, variables:) do |result|
+        data = result.dig("repository", "pullRequests")
+        pull_requests.concat(data["nodes"])
+        data["pageInfo"]
+      end
+      pull_requests
+    end
+
+    regex = pull_request_title_regex(name, version)
+    @open_pull_requests[cache_key].select { |pr| regex.match?(pr["title"]) }
+                                  .map { |pr| pr.merge("html_url" => pr.delete("url")) }
+  rescue API::RateLimitExceededError => e
+    opoo e.message
+    pull_requests || []
+  end
+
+  sig {
+    params(
+      name:            String,
+      tap_remote_repo: String,
+      file:            String,
+      quiet:           T::Boolean,
+      state:           T.nilable(String),
+      version:         T.nilable(String),
+    ).void
+  }
+  def self.check_for_duplicate_pull_requests(name, tap_remote_repo, file:, quiet: false, state: nil, version: nil)
+    pull_requests = fetch_pull_requests(name, tap_remote_repo, state:, version:)
+
+    pull_requests.select! do |pr|
+      get_pull_request_changed_files(
+        tap_remote_repo, pr["number"]
+      ).any? { |f| f["filename"] == file }
     end
     return if pull_requests.blank?
 
+    confidence = version ? "are" : "might be"
     duplicates_message = <<~EOS
-      These pull requests may be duplicates:
+      These #{state} pull requests #{confidence} duplicates:
       #{pull_requests.map { |pr| "#{pr["title"]} #{pr["html_url"]}" }.join("\n")}
     EOS
-    error_message = "Duplicate PRs should not be opened. Use --force to override this error."
-    if args.force? && !args.quiet?
-      opoo duplicates_message
-    elsif !args.force? && args.quiet?
-      odie error_message
-    elsif !args.force?
+    error_message = <<~EOS
+      Duplicate PRs must not be opened.
+      Manually open these PRs if you are sure that they are not duplicates (and tell us that in the PR).
+    EOS
+
+    if version
       odie <<~EOS
         #{duplicates_message.chomp}
         #{error_message}
       EOS
+    elsif quiet
+      opoo error_message
+    else
+      opoo <<~EOS
+        #{duplicates_message.chomp}
+        #{error_message}
+      EOS
     end
   end
 
-  def forked_repo_info!(tap_remote_repo, org: nil)
-    response = create_fork(tap_remote_repo, org: org)
+  def self.get_pull_request_changed_files(tap_remote_repo, pull_request)
+    API.open_rest(url_to("repos", tap_remote_repo, "pulls", pull_request, "files"))
+  end
+
+  private_class_method def self.add_auth_token_to_url!(url)
+    if API.credentials_type == :env_token
+      url.sub!(%r{^https://github\.com/}, "https://x-access-token:#{API.credentials}@github.com/")
+    end
+    url
+  end
+
+  def self.forked_repo_info!(tap_remote_repo, org: nil)
+    response = create_fork(tap_remote_repo, org:)
     # GitHub API responds immediately but fork takes a few seconds to be ready.
-    sleep 1 until check_fork_exists(tap_remote_repo, org: org)
-    remote_url = if system("git", "config", "--local", "--get-regexp", "remote\..*\.url", "git@github.com:.*")
+    sleep 1 until fork_exists?(tap_remote_repo, org:)
+    remote_url = if system("git", "config", "--local", "--get-regexp", "remote..*.url", "git@github.com:.*")
       response.fetch("ssh_url")
     else
-      url = response.fetch("clone_url")
-      if (api_token = Homebrew::EnvConfig.github_api_token)
-        url.gsub!(%r{^https://github\.com/}, "https://#{api_token}@github.com/")
-      end
-      url
+      add_auth_token_to_url!(response.fetch("clone_url"))
     end
     username = response.fetch("owner").fetch("login")
     [remote_url, username]
   end
 
-  def create_bump_pr(info, args:)
+  def self.create_bump_pr(info, args:)
     tap = info[:tap]
     sourcefile_path = info[:sourcefile_path]
     old_contents = info[:old_contents]
     additional_files = info[:additional_files] || []
     remote = info[:remote] || "origin"
-    remote_branch = info[:remote_branch] || tap.path.git_origin_branch
+    remote_branch = info[:remote_branch] || tap.git_repository.origin_branch_name
     branch = info[:branch_name]
     commit_message = info[:commit_message]
     previous_branch = info[:previous_branch] || "-"
@@ -532,6 +712,7 @@ def create_bump_pr(info, args:)
     pr_message = info[:pr_message]
 
     sourcefile_path.parent.cd do
+      require "utils/popen"
       git_dir = Utils.popen_read("git", "rev-parse", "--git-dir").chomp
       shallow = !git_dir.empty? && File.exist?("#{git_dir}/shallow")
       changed_files = [sourcefile_path]
@@ -559,6 +740,7 @@ def create_bump_pr(info, args:)
         unless args.commit?
           if args.no_fork?
             remote_url = Utils.popen_read("git", "remote", "get-url", "--push", "origin").chomp
+            add_auth_token_to_url!(remote_url)
             username = tap.user
           else
             begin
@@ -611,8 +793,8 @@ def create_bump_pr(info, args:)
     end
   end
 
-  def pull_request_commits(user, repo, pr, per_page: 100)
-    pr_data = API.open_rest(url_to("repos", user, repo, "pulls", pr))
+  def self.pull_request_commits(user, repo, pull_request, per_page: 100)
+    pr_data = API.open_rest(url_to("repos", user, repo, "pulls", pull_request))
     commits_api = pr_data["commits_url"]
     commit_count = pr_data["commits"]
     commits = []
@@ -621,7 +803,7 @@ def pull_request_commits(user, repo, pr, per_page: 100)
       raise API::Error, "Getting #{commit_count} commits would exceed limit of #{API_MAX_ITEMS} API items!"
     end
 
-    API.paginate_rest(commits_api, per_page: per_page) do |result, page|
+    API.paginate_rest(commits_api, per_page:) do |result, page|
       commits.concat(result.map { |c| c["sha"] })
 
       return commits if commits.length == commit_count
@@ -632,8 +814,133 @@ def pull_request_commits(user, repo, pr, per_page: 100)
     end
   end
 
-  def pull_request_labels(user, repo, pr)
-    pr_data = API.open_rest(url_to("repos", user, repo, "pulls", pr))
+  def self.pull_request_labels(user, repo, pull_request)
+    pr_data = API.open_rest(url_to("repos", user, repo, "pulls", pull_request))
     pr_data["labels"].map { |label| label["name"] }
   end
+
+  def self.last_commit(user, repo, ref, version)
+    return if Homebrew::EnvConfig.no_github_api?
+
+    require "utils/curl"
+    output, _, status = Utils::Curl.curl_output(
+      "--silent", "--head", "--location",
+      "--header", "Accept: application/vnd.github.sha",
+      url_to("repos", user, repo, "commits", ref).to_s
+    )
+
+    return unless status.success?
+
+    commit = output[/^ETag: "(\h+)"/, 1]
+    return if commit.blank?
+
+    version.update_commit(commit)
+    commit
+  end
+
+  def self.multiple_short_commits_exist?(user, repo, commit)
+    return false if Homebrew::EnvConfig.no_github_api?
+
+    require "utils/curl"
+    output, _, status = Utils::Curl.curl_output(
+      "--silent", "--head", "--location",
+      "--header", "Accept: application/vnd.github.sha",
+      url_to("repos", user, repo, "commits", commit).to_s
+    )
+
+    return true unless status.success?
+    return true if output.blank?
+
+    output[/^Status: (200)/, 1] != "200"
+  end
+
+  def self.repo_commits_for_user(nwo, user, filter, from, to, max)
+    return if Homebrew::EnvConfig.no_github_api?
+
+    params = ["#{filter}=#{user}"]
+    params << "since=#{DateTime.parse(from).iso8601}" if from.present?
+    params << "until=#{DateTime.parse(to).iso8601}" if to.present?
+
+    commits = []
+    API.paginate_rest("#{API_URL}/repos/#{nwo}/commits", additional_query_params: params.join("&")) do |result|
+      commits.concat(result.map { |c| c["sha"] })
+      if max.present? && commits.length >= max
+        opoo "#{user} exceeded #{max} #{nwo} commits as #{filter}, stopped counting!"
+        break
+      end
+    end
+    commits
+  end
+
+  def self.count_repo_commits(nwo, user, from: nil, to: nil, max: nil)
+    odie "Cannot count commits, HOMEBREW_NO_GITHUB_API set!" if Homebrew::EnvConfig.no_github_api?
+
+    author_shas = repo_commits_for_user(nwo, user, "author", from, to, max)
+    committer_shas = repo_commits_for_user(nwo, user, "committer", from, to, max)
+    return [0, 0] if author_shas.blank? && committer_shas.blank?
+
+    author_count = author_shas.count
+    # Only count commits where the author and committer are different.
+    committer_count = committer_shas.difference(author_shas).count
+
+    [author_count, committer_count]
+  end
+
+  MAXIMUM_OPEN_PRS = 15
+
+  sig { params(tap: T.nilable(Tap)).returns(T::Boolean) }
+  def self.too_many_open_prs?(tap)
+    # We don't enforce unofficial taps.
+    return false if tap.nil? || !tap.official?
+
+    # BrewTestBot can open as many PRs as it wants.
+    return false if ENV["HOMEBREW_TEST_BOT_AUTOBUMP"].present?
+
+    odie "Cannot count PRs, HOMEBREW_NO_GITHUB_API set!" if Homebrew::EnvConfig.no_github_api?
+
+    query = <<~EOS
+      query($after: String) {
+        viewer {
+          login
+          pullRequests(first: 100, states: OPEN, after: $after) {
+            totalCount
+            nodes {
+              baseRepository {
+                owner {
+                  login
+                }
+              }
+            }
+            pageInfo {
+              hasNextPage
+              endCursor
+            }
+          }
+        }
+      }
+    EOS
+    puts
+
+    homebrew_prs_count = 0
+
+    API.paginate_graphql(query) do |result|
+      data = result.fetch("viewer")
+      github_user = data.fetch("login")
+
+      # BrewTestBot can open as many PRs as it wants.
+      return false if github_user.casecmp?("brewtestbot")
+
+      pull_requests = data.fetch("pullRequests")
+      return false if pull_requests.fetch("totalCount") < MAXIMUM_OPEN_PRS
+
+      homebrew_prs_count += pull_requests.fetch("nodes").count do |node|
+        node.dig("baseRepository", "owner", "login").casecmp?("homebrew")
+      end
+      return true if homebrew_prs_count >= MAXIMUM_OPEN_PRS
+
+      pull_requests.fetch("pageInfo")
+    end
+
+    false
+  end
 end
diff --git a/Library/Homebrew/utils/github/actions.rb b/Library/Homebrew/utils/github/actions.rb
index c255dec4a05f4..96d47d5f5e468 100644
--- a/Library/Homebrew/utils/github/actions.rb
+++ b/Library/Homebrew/utils/github/actions.rb
@@ -1,15 +1,11 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "utils/tty"
-
 module GitHub
   # Helper functions for interacting with GitHub Actions.
   #
-  # @api private
+  # @api internal
   module Actions
-    extend T::Sig
-
     sig { params(string: String).returns(String) }
     def self.escape(string)
       # See https://github.community/t/set-output-truncates-multiline-strings/16852/3.
@@ -18,10 +14,50 @@ def self.escape(string)
             .gsub("\r", "%0D")
     end
 
+    sig { params(name: String, value: String).returns(String) }
+    def self.format_multiline_string(name, value)
+      # Format multiline strings for environment files
+      # See https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#multiline-strings
+
+      require "securerandom"
+      delimiter = "ghadelimiter_#{SecureRandom.uuid}"
+
+      if name.include?(delimiter) || value.include?(delimiter)
+        raise "`name` and `value` must not contain the delimiter"
+      end
+
+      <<~EOS
+        #{name}<<#{delimiter}
+        #{value}
+        #{delimiter}
+      EOS
+    end
+
+    sig { returns(T::Boolean) }
+    def self.env_set?
+      ENV.fetch("GITHUB_ACTIONS", false).present?
+    end
+
+    sig {
+      params(
+        type: Symbol, message: String,
+        file: T.nilable(T.any(String, Pathname)),
+        line: T.nilable(Integer)
+      ).returns(T::Boolean)
+    }
+    def self.puts_annotation_if_env_set(type, message, file: nil, line: nil)
+      # Don't print annotations during tests, too messy to handle these.
+      return false if ENV.fetch("HOMEBREW_TESTS", false)
+      return false unless env_set?
+
+      std = (type == :notice) ? $stdout : $stderr
+      std.puts Annotation.new(type, message)
+
+      true
+    end
+
     # Helper class for formatting annotations on GitHub Actions.
     class Annotation
-      extend T::Sig
-
       ANNOTATION_TYPES = [:notice, :warning, :error].freeze
 
       sig { params(path: T.any(String, Pathname)).returns(T.nilable(Pathname)) }
@@ -37,7 +73,7 @@ def self.path_relative_to_workspace(path)
         params(
           type:       Symbol,
           message:    String,
-          file:       T.any(String, Pathname),
+          file:       T.nilable(T.any(String, Pathname)),
           title:      T.nilable(String),
           line:       T.nilable(Integer),
           end_line:   T.nilable(Integer),
@@ -45,35 +81,43 @@ def self.path_relative_to_workspace(path)
           end_column: T.nilable(Integer),
         ).void
       }
-      def initialize(type, message, file:, title: nil, line: nil, end_line: nil, column: nil, end_column: nil)
+      def initialize(type, message, file: nil, title: nil, line: nil, end_line: nil, column: nil, end_column: nil)
         raise ArgumentError, "Unsupported type: #{type.inspect}" if ANNOTATION_TYPES.exclude?(type)
+        raise ArgumentError, "`title` must not contain `::`" if title.present? && title.include?("::")
 
+        require "utils/tty"
         @type = type
-        @message = Tty.strip_ansi(message)
-        @file = self.class.path_relative_to_workspace(file)
-        @title = Tty.strip_ansi(title) if title
-        @line = Integer(line) if line
-        @end_line = Integer(end_line) if end_line
-        @column = Integer(column) if column
-        @end_column = Integer(end_column) if end_column
+        @message = T.let(Tty.strip_ansi(message), String)
+        @file = T.let(self.class.path_relative_to_workspace(file), T.nilable(Pathname)) if file.present?
+        @title = T.let(Tty.strip_ansi(title), String) if title
+        @line = T.let(Integer(line), Integer) if line
+        @end_line = T.let(Integer(end_line), Integer) if end_line
+        @column = T.let(Integer(column), Integer) if column
+        @end_column = T.let(Integer(end_column), Integer) if end_column
       end
 
       sig { returns(String) }
       def to_s
         metadata = @type.to_s
-        metadata << " file=#{Actions.escape(@file.to_s)}"
+        if @file
+          metadata << " file=#{Actions.escape(@file.to_s)}"
 
-        if @line
-          metadata << ",line=#{@line}"
-          metadata << ",endLine=#{@end_line}" if @end_line
+          if @line
+            metadata << ",line=#{@line}"
+            metadata << ",endLine=#{@end_line}" if @end_line
 
-          if @column
-            metadata << ",col=#{@column}"
-            metadata << ",endColumn=#{@end_column}" if @end_column
+            if @column
+              metadata << ",col=#{@column}"
+              metadata << ",endColumn=#{@end_column}" if @end_column
+            end
           end
         end
 
-        metadata << ",title=#{Actions.escape(@title)}" if @title
+        if @title
+          metadata << (@file ? "," : " ")
+          metadata << "title=#{Actions.escape(@title)}"
+        end
+        metadata << " " if metadata.end_with?(":")
 
         "::#{metadata}::#{Actions.escape(@message)}"
       end
@@ -82,6 +126,8 @@ def to_s
       # the `GITHUB_WORKSPACE` directory or if no `file` is specified.
       sig { returns(T::Boolean) }
       def relevant?
+        return true if @file.blank?
+
         @file.descend.next.to_s != ".."
       end
     end
diff --git a/Library/Homebrew/utils/github/api.rb b/Library/Homebrew/utils/github/api.rb
index 8db64eda0c849..bcc2bcbe3b057 100644
--- a/Library/Homebrew/utils/github/api.rb
+++ b/Library/Homebrew/utils/github/api.rb
@@ -1,35 +1,42 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "tempfile"
-require "utils/shell"
+require "system_command"
 
 module GitHub
+  def self.pat_blurb(scopes = ALL_SCOPES)
+    require "utils/formatter"
+    require "utils/shell"
+    <<~EOS
+      Create a GitHub personal access token:
+        #{Formatter.url(
+          "https://github.com/settings/tokens/new?scopes=#{scopes.join(",")}&description=Homebrew",
+        )}
+      #{Utils::Shell.set_variable_in_profile("HOMEBREW_GITHUB_API_TOKEN", "your_token_here")}
+    EOS
+  end
+
   API_URL = "https://api.github.com"
   API_MAX_PAGES = 50
+  private_constant :API_MAX_PAGES
   API_MAX_ITEMS = 5000
+  private_constant :API_MAX_ITEMS
+  PAGINATE_RETRY_COUNT = 3
+  private_constant :PAGINATE_RETRY_COUNT
 
   CREATE_GIST_SCOPES = ["gist"].freeze
   CREATE_ISSUE_FORK_OR_PR_SCOPES = ["repo"].freeze
   CREATE_WORKFLOW_SCOPES = ["workflow"].freeze
   ALL_SCOPES = (CREATE_GIST_SCOPES + CREATE_ISSUE_FORK_OR_PR_SCOPES + CREATE_WORKFLOW_SCOPES).freeze
-  ALL_SCOPES_URL = Formatter.url(
-    "https://github.com/settings/tokens/new?scopes=#{ALL_SCOPES.join(",")}&description=Homebrew",
-  ).freeze
-  CREATE_GITHUB_PAT_MESSAGE = <<~EOS
-    Create a GitHub personal access token:
-        #{ALL_SCOPES_URL}
-      #{Utils::Shell.set_variable_in_profile("HOMEBREW_GITHUB_API_TOKEN", "your_token_here")}
-  EOS
-  GITHUB_PERSONAL_ACCESS_TOKEN_REGEX = /^(?:[a-f0-9]{40}|gh[po]_\w{36,251})$/.freeze
+  private_constant :ALL_SCOPES
+  GITHUB_PERSONAL_ACCESS_TOKEN_REGEX = /^(?:[a-f0-9]{40}|(?:gh[pousr]|github_pat)_\w{36,251})$/
+  private_constant :GITHUB_PERSONAL_ACCESS_TOKEN_REGEX
 
-  # Helper functions to access the GitHub API.
+  # Helper functions for accessing the GitHub API.
   #
-  # @api private
+  # @api internal
   module API
-    extend T::Sig
-
-    module_function
+    extend SystemCommand::Mixin
 
     # Generic API error.
     class Error < RuntimeError
@@ -48,7 +55,7 @@ def initialize(github_message)
     class RateLimitExceededError < Error
       def initialize(reset, github_message)
         @github_message = github_message
-        new_pat_message = ", or:\n#{CREATE_GITHUB_PAT_MESSAGE}" if API.credentials.blank?
+        new_pat_message = ", or:\n#{GitHub.pat_blurb}" if API.credentials.blank?
         super <<~EOS
           GitHub API Error: #{github_message}
           Try again in #{pretty_ratelimit_reset(reset)}#{new_pat_message}
@@ -60,34 +67,50 @@ def pretty_ratelimit_reset(reset)
       end
     end
 
+    GITHUB_IP_ALLOWLIST_ERROR = Regexp.new("Although you appear to have the correct authorization credentials, " \
+                                           "the `(.+)` organization has an IP allow list enabled, " \
+                                           "and your IP address is not permitted to access this resource").freeze
+
+    NO_CREDENTIALS_MESSAGE = <<~MESSAGE.freeze
+      No GitHub credentials found in macOS Keychain, GitHub CLI or the environment.
+      #{GitHub.pat_blurb}
+    MESSAGE
+
     # Error when authentication fails.
     class AuthenticationFailedError < Error
-      def initialize(github_message)
+      def initialize(credentials_type, github_message)
         @github_message = github_message
-        message = +"GitHub API Error: #{github_message}\n"
-        message << if Homebrew::EnvConfig.github_api_token
+        message = "GitHub API Error: #{github_message}\n"
+        message << case credentials_type
+        when :github_cli_token
           <<~EOS
-            HOMEBREW_GITHUB_API_TOKEN may be invalid or expired; check:
-              #{Formatter.url("https://github.com/settings/tokens")}
+            Your GitHub CLI login session may be invalid.
+            Refresh it with:
+              gh auth login --hostname github.com
           EOS
-        else
+        when :keychain_username_password
           <<~EOS
             The GitHub credentials in the macOS keychain may be invalid.
             Clear them with:
               printf "protocol=https\\nhost=github.com\\n" | git credential-osxkeychain erase
-            #{CREATE_GITHUB_PAT_MESSAGE}
           EOS
+        when :env_token
+          require "utils/formatter"
+          <<~EOS
+            HOMEBREW_GITHUB_API_TOKEN may be invalid or expired; check:
+              #{Formatter.url("https://github.com/settings/tokens")}
+          EOS
+        when :none
+          NO_CREDENTIALS_MESSAGE
         end
         super message.freeze
       end
     end
 
-    # Error when the user has no GitHub API credentials set at all (macOS keychain or envvar).
+    # Error when the user has no GitHub API credentials set at all (macOS keychain, GitHub CLI or envvar).
     class MissingAuthenticationError < Error
       def initialize
-        message = +"No GitHub credentials found in macOS Keychain or environment.\n"
-        message << CREATE_GITHUB_PAT_MESSAGE
-        super message
+        super NO_CREDENTIALS_MESSAGE
       end
     end
 
@@ -112,49 +135,90 @@ def initialize(github_message, errors)
       JSON::ParserError,
     ].freeze
 
+    sig { returns(T.nilable(String)) }
+    private_class_method def self.uid_home
+      require "etc"
+      Etc.getpwuid(Process.uid)&.dir
+    rescue ArgumentError
+      # Cover for misconfigured NSS setups
+      nil
+    end
+
+    # Gets the token from the GitHub CLI for github.com.
+    sig { returns(T.nilable(String)) }
+    def self.github_cli_token
+      require "utils/uid"
+      Utils::UID.drop_euid do
+        # Avoid `Formula["gh"].opt_bin` so this method works even with `HOMEBREW_DISABLE_LOAD_FORMULA`.
+        env = {
+          "PATH" => PATH.new(HOMEBREW_PREFIX/"opt/gh/bin", ENV.fetch("PATH")),
+          "HOME" => uid_home,
+        }.compact
+        gh_out, _, result = system_command "gh",
+                                           args:         ["auth", "token", "--hostname", "github.com"],
+                                           env:,
+                                           print_stderr: false
+        return unless result.success?
+
+        gh_out.chomp
+      end
+    end
+
     # Gets the password field from `git-credential-osxkeychain` for github.com,
     # but only if that password looks like a GitHub Personal Access Token.
     sig { returns(T.nilable(String)) }
-    def keychain_username_password
-      github_credentials = Utils.popen_write("git", "credential-osxkeychain", "get") do |pipe|
-        pipe.write "protocol=https\nhost=github.com\n"
+    def self.keychain_username_password
+      require "utils/uid"
+      Utils::UID.drop_euid do
+        git_credential_out, _, result = system_command "git",
+                                                       args:         ["credential-osxkeychain", "get"],
+                                                       input:        ["protocol=https\n", "host=github.com\n"],
+                                                       env:          { "HOME" => uid_home }.compact,
+                                                       print_stderr: false
+        return unless result.success?
+
+        git_credential_out.force_encoding("ASCII-8BIT")
+        github_username = git_credential_out[/^username=(.+)/, 1]
+        github_password = git_credential_out[/^password=(.+)/, 1]
+        return unless github_username
+
+        # Don't use passwords from the keychain unless they look like
+        # GitHub Personal Access Tokens:
+        #   https://github.com/Homebrew/brew/issues/6862#issuecomment-572610344
+        return unless GITHUB_PERSONAL_ACCESS_TOKEN_REGEX.match?(github_password)
+
+        github_password
       end
-      github_username = github_credentials[/username=(.+)/, 1]
-      github_password = github_credentials[/password=(.+)/, 1]
-      return unless github_username
-
-      # Don't use passwords from the keychain unless they look like
-      # GitHub Personal Access Tokens:
-      #   https://github.com/Homebrew/brew/issues/6862#issuecomment-572610344
-      return unless GITHUB_PERSONAL_ACCESS_TOKEN_REGEX.match?(github_password)
-
-      github_password
-    rescue Errno::EPIPE
-      # The above invocation via `Utils.popen` can fail, causing the pipe to be
-      # prematurely closed (before we can write to it) and thus resulting in a
-      # broken pipe error. The root cause is usually a missing or malfunctioning
-      # `git-credential-osxkeychain` helper.
-      nil
     end
 
-    def credentials
-      @credentials ||= Homebrew::EnvConfig.github_api_token || keychain_username_password
+    def self.credentials
+      @credentials ||= Homebrew::EnvConfig.github_api_token.presence
+      @credentials ||= github_cli_token.presence
+      @credentials ||= keychain_username_password.presence
     end
 
     sig { returns(Symbol) }
-    def credentials_type
-      if Homebrew::EnvConfig.github_api_token
+    def self.credentials_type
+      if Homebrew::EnvConfig.github_api_token.present?
         :env_token
-      elsif keychain_username_password
+      elsif github_cli_token.present?
+        :github_cli_token
+      elsif keychain_username_password.present?
         :keychain_username_password
       else
         :none
       end
     end
 
+    CREDENTIAL_NAMES = {
+      env_token:                  "HOMEBREW_GITHUB_API_TOKEN",
+      github_cli_token:           "GitHub CLI login",
+      keychain_username_password: "macOS Keychain GitHub",
+    }.freeze
+
     # Given an API response from GitHub, warn the user if their credentials
     # have insufficient permissions.
-    def credentials_error_message(response_headers, needed_scopes)
+    def self.credentials_error_message(response_headers, needed_scopes)
       return if response_headers.empty?
 
       scopes = response_headers["x-accepted-oauth-scopes"].to_s.split(", ")
@@ -162,34 +226,35 @@ def credentials_error_message(response_headers, needed_scopes)
       credentials_scopes = response_headers["x-oauth-scopes"]
       return if needed_scopes.subset?(Set.new(credentials_scopes.to_s.split(", ")))
 
+      github_permission_link = GitHub.pat_blurb(needed_scopes.to_a)
       needed_scopes = needed_scopes.to_a.join(", ").presence || "none"
       credentials_scopes = "none" if credentials_scopes.blank?
 
-      what = case credentials_type
-      when :keychain_username_password
-        "macOS keychain GitHub"
-      when :env_token
-        "HOMEBREW_GITHUB_API_TOKEN"
-      end
-
+      what = CREDENTIAL_NAMES.fetch(credentials_type)
       @credentials_error_message ||= onoe <<~EOS
         Your #{what} credentials do not have sufficient scope!
         Scopes required: #{needed_scopes}
         Scopes present:  #{credentials_scopes}
-        #{CREATE_GITHUB_PAT_MESSAGE}
+        #{github_permission_link}
       EOS
     end
 
-    def open_rest(url, data: nil, data_binary_path: nil, request_method: nil, scopes: [].freeze, parse_json: true)
+    def self.open_rest(
+      url, data: nil, data_binary_path: nil, request_method: nil, scopes: [].freeze, parse_json: true
+    )
       # This is a no-op if the user is opting out of using the GitHub API.
       return block_given? ? yield({}) : {} if Homebrew::EnvConfig.no_github_api?
 
-      args = ["--header", "Accept: application/vnd.github.v3+json", "--write-out", "\n%\{http_code}"]
-      args += ["--header", "Accept: application/vnd.github.antiope-preview+json"]
+      # This is a Curl format token, not a Ruby one.
+      # rubocop:disable Style/FormatStringToken
+      args = ["--header", "Accept: application/vnd.github+json", "--write-out", "\n%{http_code}"]
+      # rubocop:enable Style/FormatStringToken
 
       token = credentials
-      args += ["--header", "Authorization: token #{token}"] unless credentials_type == :none
+      args += ["--header", "Authorization: token #{token}"] if credentials_type != :none
+      args += ["--header", "X-GitHub-Api-Version:2022-11-28"]
 
+      require "tempfile"
       data_tmpfile = nil
       if data
         begin
@@ -207,7 +272,7 @@ def open_rest(url, data: nil, data_binary_path: nil, request_method: nil, scopes
 
       headers_tmpfile = Tempfile.new("github_api_headers", HOMEBREW_TEMP)
       begin
-        if data
+        if data_tmpfile
           data_tmpfile.write data
           data_tmpfile.close
           args += ["--data", "@#{data_tmpfile.path}"]
@@ -215,9 +280,10 @@ def open_rest(url, data: nil, data_binary_path: nil, request_method: nil, scopes
           args += ["--request", request_method.to_s] if request_method
         end
 
-        args += ["--dump-header", headers_tmpfile.path]
+        args += ["--dump-header", T.must(headers_tmpfile.path)]
 
-        output, errors, status = curl_output("--location", url.to_s, *args, secrets: [token])
+        require "utils/curl"
+        output, errors, status = Utils::Curl.curl_output("--location", url.to_s, *args, secrets: [token])
         output, _, http_code = output.rpartition("\n")
         output, _, http_code = output.rpartition("\n") if http_code == "000"
         headers = headers_tmpfile.read
@@ -246,27 +312,65 @@ def open_rest(url, data: nil, data_binary_path: nil, request_method: nil, scopes
       end
     end
 
-    def paginate_rest(url, per_page: 100)
+    def self.paginate_rest(url, additional_query_params: nil, per_page: 100, scopes: [].freeze)
       (1..API_MAX_PAGES).each do |page|
-        result = API.open_rest("#{url}?per_page=#{per_page}&page=#{page}")
+        retry_count = 1
+        result = begin
+          API.open_rest("#{url}?per_page=#{per_page}&page=#{page}&#{additional_query_params}", scopes:)
+        rescue Error
+          if retry_count < PAGINATE_RETRY_COUNT
+            retry_count += 1
+            retry
+          end
+
+          raise
+        end
+        break if result.blank?
+
         yield(result, page)
       end
     end
 
-    def open_graphql(query, variables: nil, scopes: [].freeze)
-      data = { query: query, variables: variables }
-      result = open_rest("#{API_URL}/graphql", scopes: scopes, data: data, request_method: "POST")
+    def self.open_graphql(query, variables: nil, scopes: [].freeze, raise_errors: true)
+      data = { query:, variables: }
+      result = open_rest("#{API_URL}/graphql", scopes:, data:, request_method: "POST")
+
+      if raise_errors
+        if result["errors"].present?
+          raise Error, result["errors"].map { |e| "#{e["type"]}: #{e["message"]}" }.join("\n")
+        end
 
-      if result["errors"].present?
-        raise Error, result["errors"].map { |e|
-                       "#{e["type"]}: #{e["message"]}"
-                     }.join("\n")
+        result["data"]
+      else
+        result
       end
+    end
 
-      result["data"]
+    sig {
+      params(
+        query:        String,
+        variables:    T.nilable(T::Hash[Symbol, T.untyped]),
+        scopes:       T::Array[String],
+        raise_errors: T::Boolean,
+        _block:       T.proc.params(data: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]),
+      ).void
+    }
+    def self.paginate_graphql(query, variables: nil, scopes: [].freeze, raise_errors: true, &_block)
+      result = API.open_graphql(query, variables:, scopes:, raise_errors:)
+
+      has_next_page = T.let(true, T::Boolean)
+      variables ||= {}
+      while has_next_page
+        page_info = yield result
+        has_next_page = page_info["hasNextPage"]
+        if has_next_page
+          variables[:after] = page_info["endCursor"]
+          result = API.open_graphql(query, variables:, scopes:, raise_errors:)
+        end
+      end
     end
 
-    def raise_error(output, errors, http_code, headers, scopes)
+    def self.raise_error(output, errors, http_code, headers, scopes)
       json = begin
         JSON.parse(output)
       rescue
@@ -287,14 +391,14 @@ def raise_error(output, errors, http_code, headers, scopes)
 
       case http_code
       when "401"
-        raise AuthenticationFailedError, message
+        raise AuthenticationFailedError.new(credentials_type, message)
       when "403"
         if meta.fetch("x-ratelimit-remaining", 1).to_i <= 0
           reset = meta.fetch("x-ratelimit-reset").to_i
           raise RateLimitExceededError.new(reset, message)
         end
 
-        raise AuthenticationFailedError, message
+        raise AuthenticationFailedError.new(credentials_type, message)
       when "404"
         raise MissingAuthenticationError if credentials_type == :none && scopes.present?
 
diff --git a/Library/Homebrew/utils/github/artifacts.rb b/Library/Homebrew/utils/github/artifacts.rb
new file mode 100644
index 0000000000000..607ee521f9bc6
--- /dev/null
+++ b/Library/Homebrew/utils/github/artifacts.rb
@@ -0,0 +1,62 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "download_strategy"
+require "utils/github"
+
+module GitHub
+  # Download an artifact from GitHub Actions and unpack it into the current working directory.
+  #
+  # @param url [String] URL to download from
+  # @param artifact_id [String] a value that uniquely identifies the downloaded artifact
+  sig { params(url: String, artifact_id: String).void }
+  def self.download_artifact(url, artifact_id)
+    raise API::MissingAuthenticationError if API.credentials == :none
+
+    # We use a download strategy here to leverage the Homebrew cache
+    # to avoid repeated downloads of (possibly large) bottles.
+    token = API.credentials
+    downloader = GitHubArtifactDownloadStrategy.new(url, artifact_id, token:)
+    downloader.fetch
+    downloader.stage
+  end
+end
+
+# Strategy for downloading an artifact from GitHub Actions.
+class GitHubArtifactDownloadStrategy < AbstractFileDownloadStrategy
+  sig { params(url: String, artifact_id: String, token: String).void }
+  def initialize(url, artifact_id, token:)
+    super(url, "artifact", artifact_id)
+    @cache = T.let(HOMEBREW_CACHE/"gh-actions-artifact", Pathname)
+    @token = T.let(token, String)
+  end
+
+  sig { params(timeout: T.nilable(Integer)).void }
+  def fetch(timeout: nil)
+    ohai "Downloading #{url}"
+    if cached_location.exist?
+      puts "Already downloaded: #{cached_location}"
+    else
+      begin
+        Utils::Curl.curl("--location", "--create-dirs", "--output", temporary_path, url,
+                         "--header", "Authorization: token #{@token}",
+                         secrets: [@token],
+                         timeout:)
+      rescue ErrorDuringExecution
+        raise CurlDownloadStrategyError, url
+      end
+      cached_location.dirname.mkpath
+      temporary_path.rename(cached_location)
+    end
+
+    symlink_location.dirname.mkpath
+    FileUtils.ln_s cached_location.relative_path_from(symlink_location.dirname), symlink_location, force: true
+  end
+
+  private
+
+  sig { returns(String) }
+  def resolved_basename
+    "artifact.zip"
+  end
+end
diff --git a/Library/Homebrew/utils/gzip.rb b/Library/Homebrew/utils/gzip.rb
new file mode 100644
index 0000000000000..acb70088ecef0
--- /dev/null
+++ b/Library/Homebrew/utils/gzip.rb
@@ -0,0 +1,67 @@
+# typed: strict
+# frozen_string_literal: true
+
+# Apple's gzip also uses zlib so use the same buffer size here.
+# https://github.com/apple-oss-distributions/file_cmds/blob/file_cmds-400/gzip/gzip.c#L147
+GZIP_BUFFER_SIZE = T.let(64 * 1024, Integer)
+
+module Utils
+  # Helper functions for creating gzip files.
+  module Gzip
+    sig {
+      params(
+        path:      T.any(String, Pathname),
+        mtime:     T.any(Integer, Time),
+        orig_name: String,
+        output:    T.any(String, Pathname),
+      ).returns(Pathname)
+    }
+    def self.compress_with_options(path, mtime: ENV["SOURCE_DATE_EPOCH"].to_i, orig_name: File.basename(path),
+                                   output: "#{path}.gz")
+      # Ideally, we would just set mtime = 0 if SOURCE_DATE_EPOCH is absent, but Ruby's
+      # Zlib::GzipWriter does not properly handle the case of setting mtime = 0:
+      # https://bugs.ruby-lang.org/issues/16285
+      #
+      # This was fixed in https://github.com/ruby/zlib/pull/10. Remove workaround
+      # once we are using zlib gem version 1.1.0 or newer.
+      if mtime.to_i.zero?
+        odebug "Setting `mtime = 1` to avoid zlib gem bug when `mtime == 0`."
+        mtime = 1
+      end
+
+      File.open(path, "rb") do |fp|
+        odebug "Creating gzip file at #{output}"
+        gz = Zlib::GzipWriter.open(output)
+        gz.mtime = mtime
+        gz.orig_name = orig_name
+        gz.write(fp.read(GZIP_BUFFER_SIZE)) until fp.eof?
+      ensure
+        # GzipWriter should be closed in case of error as well
+        gz.close
+      end
+
+      FileUtils.rm_f path
+      Pathname.new(output)
+    end
+
+    sig {
+      params(
+        paths:        T.any(String, Pathname),
+        reproducible: T::Boolean,
+        mtime:        T.any(Integer, Time),
+      ).returns(T::Array[Pathname])
+    }
+    def self.compress(*paths, reproducible: true, mtime: ENV["SOURCE_DATE_EPOCH"].to_i)
+      if reproducible
+        paths.map do |path|
+          compress_with_options(path, mtime:)
+        end
+      else
+        paths.map do |path|
+          safe_system "gzip", path
+          Pathname.new("#{path}.gz")
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/utils/helpers.sh b/Library/Homebrew/utils/helpers.sh
new file mode 100644
index 0000000000000..b97fef5d9052a
--- /dev/null
+++ b/Library/Homebrew/utils/helpers.sh
@@ -0,0 +1,106 @@
+# These variables are set from the user environment.
+# shellcheck disable=SC2154
+ohai() {
+  # Check whether stdout is a tty.
+  if [[ -n "${HOMEBREW_COLOR}" || (-t 1 && -z "${HOMEBREW_NO_COLOR}") ]]
+  then
+    echo -e "\\033[34m==>\\033[0m \\033[1m$*\\033[0m" # blue arrow and bold text
+  else
+    echo "==> $*"
+  fi
+}
+
+opoo() {
+  # Check whether stderr is a tty.
+  if [[ -n "${HOMEBREW_COLOR}" || (-t 2 && -z "${HOMEBREW_NO_COLOR}") ]]
+  then
+    echo -ne "\\033[4;33mWarning\\033[0m: " >&2 # highlight Warning with underline and yellow color
+  else
+    echo -n "Warning: " >&2
+  fi
+  if [[ $# -eq 0 ]]
+  then
+    cat >&2
+  else
+    echo "$*" >&2
+  fi
+}
+
+bold() {
+  # Check whether stderr is a tty.
+  if [[ -n "${HOMEBREW_COLOR}" || (-t 2 && -z "${HOMEBREW_NO_COLOR}") ]]
+  then
+    echo -e "\\033[1m""$*""\\033[0m"
+  else
+    echo "$*"
+  fi
+}
+
+onoe() {
+  # Check whether stderr is a tty.
+  if [[ -n "${HOMEBREW_COLOR}" || (-t 2 && -z "${HOMEBREW_NO_COLOR}") ]]
+  then
+    echo -ne "\\033[4;31mError\\033[0m: " >&2 # highlight Error with underline and red color
+  else
+    echo -n "Error: " >&2
+  fi
+  if [[ $# -eq 0 ]]
+  then
+    cat >&2
+  else
+    echo "$*" >&2
+  fi
+}
+
+odie() {
+  onoe "$@"
+  exit 1
+}
+
+safe_cd() {
+  cd "$@" >/dev/null || odie "Failed to cd to $*!"
+}
+
+brew() {
+  # This variable is set by bin/brew
+  # shellcheck disable=SC2154
+  "${HOMEBREW_BREW_FILE}" "$@"
+}
+
+curl() {
+  "${HOMEBREW_LIBRARY}/Homebrew/shims/shared/curl" "$@"
+}
+
+git() {
+  "${HOMEBREW_LIBRARY}/Homebrew/shims/shared/git" "$@"
+}
+
+# Search given executable in PATH (remove dependency for `which` command)
+which() {
+  # Alias to Bash built-in command `type -P`
+  type -P "$@"
+}
+
+numeric() {
+  local -a version_array
+  IFS=".rc" read -r -a version_array <<<"${1}"
+  printf "%01d%02d%02d%03d" "${version_array[@]}" 2>/dev/null
+}
+
+columns() {
+  if [[ -n "${COLUMNS}" ]]
+  then
+    echo "${COLUMNS}"
+    return
+  fi
+
+  local columns
+  read -r _ columns < <(stty size 2>/dev/null)
+
+  if [[ -z "${columns}" ]] && tput cols >/dev/null 2>&1
+  then
+    columns="$(tput cols)"
+  fi
+
+  echo "${columns:-80}"
+}
diff --git a/Library/Homebrew/utils/inreplace.rb b/Library/Homebrew/utils/inreplace.rb
index 35f7b19ae99d8..3d380301d1c83 100644
--- a/Library/Homebrew/utils/inreplace.rb
+++ b/Library/Homebrew/utils/inreplace.rb
@@ -1,16 +1,12 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "utils/string_inreplace_extension"
 
 module Utils
   # Helper functions for replacing text in files in-place.
-  #
-  # @api private
   module Inreplace
-    extend T::Sig
-
-    # Error during replacement.
+    # Error during text replacement.
     class Error < RuntimeError
       def initialize(errors)
         formatted_errors = errors.reduce(+"inreplace failed\n") do |s, (path, errs)|
@@ -20,8 +16,6 @@ def initialize(errors)
       end
     end
 
-    module_function
-
     # Sometimes we have to change a bit before we install. Mostly we
     # prefer a patch, but if you need the {Formula#prefix prefix} of
     # this formula in the patch you have to resort to `inreplace`,
@@ -29,40 +23,55 @@ def initialize(errors)
     # defined by the formula, as only `HOMEBREW_PREFIX` is available
     # in the {DATAPatch embedded patch}.
     #
+    # ### Examples
+    #
     # `inreplace` supports regular expressions:
-    # <pre>inreplace "somefile.cfg", /look[for]what?/, "replace by #{bin}/tool"</pre>
+    #
+    # ```ruby
+    # inreplace "somefile.cfg", /look[for]what?/, "replace by #{bin}/tool"
+    # ```
     #
     # `inreplace` supports blocks:
-    # <pre>inreplace "Makefile" do |s|
+    #
+    # ```ruby
+    # inreplace "Makefile" do |s|
     #   s.gsub! "/usr/local", HOMEBREW_PREFIX.to_s
     # end
-    # </pre>
+    # ```
     #
     # @see StringInreplaceExtension
     # @api public
     sig {
       params(
-        paths:        T.any(T::Array[T.untyped], String, Pathname),
-        before:       T.nilable(T.any(Regexp, String)),
-        after:        T.nilable(T.any(String, Symbol)),
+        paths:        T.any(T::Enumerable[T.any(String, Pathname)], String, Pathname),
+        before:       T.nilable(T.any(Pathname, Regexp, String)),
+        after:        T.nilable(T.any(Pathname, String, Symbol)),
         audit_result: T::Boolean,
+        global:       T::Boolean,
+        block:        T.nilable(T.proc.params(s: StringInreplaceExtension).void),
       ).void
     }
-    def inreplace(paths, before = nil, after = nil, audit_result = true) # rubocop:disable Style/OptionalBooleanParameter
-      after = after.to_s if after.is_a? Symbol
+    def self.inreplace(paths, before = nil, after = nil, audit_result: true, global: true, &block)
+      paths = Array(paths)
+      after &&= after.to_s
+      before = before.to_s if before.is_a?(Pathname)
 
       errors = {}
 
-      errors["`paths` (first) parameter"] = ["`paths` was empty"] if paths.blank?
+      errors["`paths` (first) parameter"] = ["`paths` was empty"] if paths.all?(&:blank?)
 
-      Array(paths).each do |path|
+      paths.each do |path|
         str = File.binread(path)
         s = StringInreplaceExtension.new(str)
 
         if before.nil? && after.nil?
+          raise ArgumentError, "Must supply a block or before/after params" unless block
+
           yield s
+        elsif global
+          s.gsub!(T.must(before), T.must(after), audit_result:)
         else
-          s.gsub!(T.must(before), after, audit_result)
+          s.sub!(T.must(before), T.must(after), audit_result:)
         end
 
         errors[path] = s.errors unless s.errors.empty?
@@ -70,11 +79,10 @@ def inreplace(paths, before = nil, after = nil, audit_result = true) # rubocop:d
         Pathname(path).atomic_write(s.inreplace_string)
       end
 
-      raise Error, errors unless errors.empty?
+      raise Utils::Inreplace::Error, errors if errors.present?
     end
 
-    # @api private
-    def inreplace_pairs(path, replacement_pairs, read_only_run: false, silent: false)
+    def self.inreplace_pairs(path, replacement_pairs, read_only_run: false, silent: false)
       str = File.binread(path)
       contents = StringInreplaceExtension.new(str)
       replacement_pairs.each do |old, new|
@@ -86,7 +94,7 @@ def inreplace_pairs(path, replacement_pairs, read_only_run: false, silent: false
 
         contents.gsub!(old, new)
       end
-      raise Error, path => contents.errors unless contents.errors.empty?
+      raise Utils::Inreplace::Error, path => contents.errors if contents.errors.present?
 
       Pathname(path).atomic_write(contents.inreplace_string) unless read_only_run
       contents.inreplace_string
diff --git a/Library/Homebrew/utils/inreplace.rbi b/Library/Homebrew/utils/inreplace.rbi
deleted file mode 100644
index 02542091d2c68..0000000000000
--- a/Library/Homebrew/utils/inreplace.rbi
+++ /dev/null
@@ -1,7 +0,0 @@
-# typed: strict
-
-module Utils
-  module Inreplace
-    include Kernel
-  end
-end
diff --git a/Library/Homebrew/utils/link.rb b/Library/Homebrew/utils/link.rb
index c33d5ca335527..01a5211b3ec7a 100644
--- a/Library/Homebrew/utils/link.rb
+++ b/Library/Homebrew/utils/link.rb
@@ -1,14 +1,11 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Utils
   # Helper functions for creating symlinks.
-  #
-  # @api private
   module Link
-    module_function
-
-    def link_src_dst_dirs(src_dir, dst_dir, command, link_dir: false)
+    sig { params(src_dir: Pathname, dst_dir: Pathname, command: String, link_dir: T::Boolean).void }
+    def self.link_src_dst_dirs(src_dir, dst_dir, command, link_dir: false)
       return unless src_dir.exist?
 
       conflicts = []
@@ -42,7 +39,8 @@ def link_src_dst_dirs(src_dir, dst_dir, command, link_dir: false)
     end
     private_class_method :link_src_dst_dirs
 
-    def unlink_src_dst_dirs(src_dir, dst_dir, unlink_dir: false)
+    sig { params(src_dir: Pathname, dst_dir: Pathname, unlink_dir: T::Boolean).void }
+    def self.unlink_src_dst_dirs(src_dir, dst_dir, unlink_dir: false)
       return unless src_dir.exist?
 
       src_paths = unlink_dir ? [src_dir] : src_dir.find
@@ -56,27 +54,32 @@ def unlink_src_dst_dirs(src_dir, dst_dir, unlink_dir: false)
     end
     private_class_method :unlink_src_dst_dirs
 
-    def link_manpages(path, command)
+    sig { params(path: Pathname, command: String).void }
+    def self.link_manpages(path, command)
       link_src_dst_dirs(path/"manpages", HOMEBREW_PREFIX/"share/man/man1", command)
     end
 
-    def unlink_manpages(path)
+    sig { params(path: Pathname).void }
+    def self.unlink_manpages(path)
       unlink_src_dst_dirs(path/"manpages", HOMEBREW_PREFIX/"share/man/man1")
     end
 
-    def link_completions(path, command)
+    sig { params(path: Pathname, command: String).void }
+    def self.link_completions(path, command)
       link_src_dst_dirs(path/"completions/bash", HOMEBREW_PREFIX/"etc/bash_completion.d", command)
       link_src_dst_dirs(path/"completions/zsh", HOMEBREW_PREFIX/"share/zsh/site-functions", command)
       link_src_dst_dirs(path/"completions/fish", HOMEBREW_PREFIX/"share/fish/vendor_completions.d", command)
     end
 
-    def unlink_completions(path)
+    sig { params(path: Pathname).void }
+    def self.unlink_completions(path)
       unlink_src_dst_dirs(path/"completions/bash", HOMEBREW_PREFIX/"etc/bash_completion.d")
       unlink_src_dst_dirs(path/"completions/zsh", HOMEBREW_PREFIX/"share/zsh/site-functions")
       unlink_src_dst_dirs(path/"completions/fish", HOMEBREW_PREFIX/"share/fish/vendor_completions.d")
     end
 
-    def link_docs(path, command)
+    sig { params(path: Pathname, command: String).void }
+    def self.link_docs(path, command)
       link_src_dst_dirs(path/"docs", HOMEBREW_PREFIX/"share/doc/homebrew", command, link_dir: true)
     end
   end
diff --git a/Library/Homebrew/utils/link.rbi b/Library/Homebrew/utils/link.rbi
deleted file mode 100644
index 0b88a48d161d5..0000000000000
--- a/Library/Homebrew/utils/link.rbi
+++ /dev/null
@@ -1,7 +0,0 @@
-# typed: strict
-
-module Utils
-  module Link
-    include Kernel
-  end
-end
diff --git a/Library/Homebrew/utils/lock.sh b/Library/Homebrew/utils/lock.sh
index 8cc5f997ce555..8b71ea11491da 100644
--- a/Library/Homebrew/utils/lock.sh
+++ b/Library/Homebrew/utils/lock.sh
@@ -1,22 +1,25 @@
-# create a lock using `flock(2)`. A name is required as first argument.
-# the lock will be automatically unlocked when the shell process quits.
-# Noted due to the fixed FD, a shell process can only create one lock.
+# Create a lock using `flock(2)`. A command name with arguments is required as
+# first argument. The lock will be automatically unlocked when the shell process
+# quits. Note due to the fixed FD, a shell process can only create one lock.
+# HOMEBREW_LIBRARY is by brew.sh
 # HOMEBREW_PREFIX is set by extend/ENV/super.rb
 # shellcheck disable=SC2154
 lock() {
-  local name="$1"
+  local command_name_and_args="$1"
+  # use bash to replace spaces with dashes
+  local lock_filename="${command_name_and_args// /-}"
   local lock_dir="${HOMEBREW_PREFIX}/var/homebrew/locks"
-  local lock_file="${lock_dir}/${name}"
+  local lock_file="${lock_dir}/${lock_filename}"
   [[ -d "${lock_dir}" ]] || mkdir -p "${lock_dir}"
   if [[ ! -w "${lock_dir}" ]]
   then
     odie <<EOS
-Can't create ${name} lock in ${lock_dir}!
+Can't create \`brew ${command_name_and_args}\` lock in ${lock_dir}!
 Fix permissions by running:
-  sudo chown -R \$(whoami) ${HOMEBREW_PREFIX}/var/homebrew
+  sudo chown -R ${USER-\$(whoami)} ${HOMEBREW_PREFIX}/var/homebrew
 EOS
   fi
-  # 200 is the file descriptor used in the lock.
+  # 200 is the file descriptor (FD) used in the lock.
   # This FD should be used exclusively for lock purpose.
   # Any value except 0(stdin), 1(stdout) and 2(stderr) can do the job.
   # Noted, FD is unique per process but it will be shared to subprocess.
@@ -27,33 +30,46 @@ EOS
   exec 200>&-
   # open the lock file to FD, so the shell process can hold the lock.
   exec 200>"${lock_file}"
-  if ! _create_lock 200 "${name}"
+
+  if ! _create_lock 200 "${command_name_and_args}"
   then
+    local lock_context
+    if [[ -n "${HOMEBREW_LOCK_CONTEXT}" ]]
+    then
+      lock_context="\n${HOMEBREW_LOCK_CONTEXT}"
+    fi
+
     odie <<EOS
-Another active Homebrew ${name} process is already in progress.
+Another \`brew ${command_name_and_args}\` process is already running.${lock_context}
 Please wait for it to finish or terminate it to continue.
 EOS
   fi
 }
 
 _create_lock() {
-  local lock_fd="$1"
-  local name="$2"
+  local lock_file_descriptor="$1"
+  local command_name_and_args="$2"
   local ruby="/usr/bin/ruby"
   local python="/usr/bin/python"
   [[ -x "${ruby}" ]] || ruby="$(type -P ruby)"
   [[ -x "${python}" ]] || python="$(type -P python)"
 
-  if [[ -x "${ruby}" ]] && "${ruby}" -e "exit(RUBY_VERSION >= '1.8.7')"
-  then
-    "${ruby}" -e "File.new(${lock_fd}).flock(File::LOCK_EX | File::LOCK_NB) || exit(1)"
-  elif [[ -x "${python}" ]]
+  local utils_lock_sh="${HOMEBREW_LIBRARY}/Homebrew/utils/lock_sh"
+  local oldest_ruby_with_flock="1.8.7"
+
+  if [[ -x "$(type -P lockf)" ]]
   then
-    "${python}" -c "import fcntl; fcntl.flock(${lock_fd}, fcntl.LOCK_EX | fcntl.LOCK_NB)"
+    lockf -t 0 "${lock_file_descriptor}"
   elif [[ -x "$(type -P flock)" ]]
   then
-    flock -n "${lock_fd}"
+    flock -n "${lock_file_descriptor}"
+  elif [[ -x "${ruby}" ]] && "${ruby}" "${utils_lock_sh}/ruby_check_version.rb" "${oldest_ruby_with_flock}"
+  then
+    "${ruby}" "${utils_lock_sh}/ruby_lock_file_descriptor.rb" "${lock_file_descriptor}"
+  elif [[ -x "${python}" ]]
+  then
+    "${python}" -c "import fcntl; fcntl.flock(${lock_file_descriptor}, fcntl.LOCK_EX | fcntl.LOCK_NB)"
   else
-    onoe "Cannot create ${name} lock, please avoid running Homebrew in parallel."
+    onoe "Cannot create \`brew ${command_name_and_args}\` lock due to missing/too old ruby/flock/python, please avoid running Homebrew in parallel."
   fi
 }
diff --git a/Library/Homebrew/utils/lock_sh/ruby_check_version.rb b/Library/Homebrew/utils/lock_sh/ruby_check_version.rb
new file mode 100644
index 0000000000000..c6d11b5a1e27b
--- /dev/null
+++ b/Library/Homebrew/utils/lock_sh/ruby_check_version.rb
@@ -0,0 +1,5 @@
+# typed: strict
+# frozen_string_literal: true
+
+ruby_version_to_check = ARGV.first
+exit(ruby_version_to_check < RUBY_VERSION)
diff --git a/Library/Homebrew/utils/lock_sh/ruby_lock_file_descriptor.rb b/Library/Homebrew/utils/lock_sh/ruby_lock_file_descriptor.rb
new file mode 100644
index 0000000000000..d27116222417a
--- /dev/null
+++ b/Library/Homebrew/utils/lock_sh/ruby_lock_file_descriptor.rb
@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+file_descriptor = ARGV.first.to_i
+file = File.new(file_descriptor)
+file.flock(File::LOCK_EX | File::LOCK_NB) || exit(1)
diff --git a/Library/Homebrew/utils/path.rb b/Library/Homebrew/utils/path.rb
new file mode 100644
index 0000000000000..b2f69504f6fd2
--- /dev/null
+++ b/Library/Homebrew/utils/path.rb
@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Utils
+  module Path
+    sig { params(parent: T.any(Pathname, String), child: T.any(Pathname, String)).returns(T::Boolean) }
+    def self.child_of?(parent, child)
+      parent_pathname = Pathname(parent).expand_path
+      child_pathname = Pathname(child).expand_path
+      child_pathname.ascend { |p| return true if p == parent_pathname }
+      false
+    end
+  end
+end
diff --git a/Library/Homebrew/utils/popen.rb b/Library/Homebrew/utils/popen.rb
index 36c2b65851a0c..fea4d9831a5ca 100644
--- a/Library/Homebrew/utils/popen.rb
+++ b/Library/Homebrew/utils/popen.rb
@@ -1,4 +1,4 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module Utils
@@ -54,10 +54,10 @@ def self.popen(args, mode, options = {})
         begin
           exec(*args, options)
         rescue Errno::ENOENT
-          $stderr.puts "brew: command not found: #{args[0]}" unless options[:err] == :close
+          $stderr.puts "brew: command not found: #{args[0]}" if options[:err] != :close
           exit! 127
         rescue SystemCallError
-          $stderr.puts "brew: exec failed: #{args[0]}" unless options[:err] == :close
+          $stderr.puts "brew: exec failed: #{args[0]}" if options[:err] != :close
           exit! 1
         end
       end
diff --git a/Library/Homebrew/utils/pypi.rb b/Library/Homebrew/utils/pypi.rb
index 1de0d1abaf863..28b5b847aa51d 100644
--- a/Library/Homebrew/utils/pypi.rb
+++ b/Library/Homebrew/utils/pypi.rb
@@ -1,63 +1,71 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "utils/inreplace"
+
 # Helper functions for updating PyPI resources.
-#
-# @api private
 module PyPI
-  extend T::Sig
-
-  module_function
-
   PYTHONHOSTED_URL_PREFIX = "https://files.pythonhosted.org/packages/"
   private_constant :PYTHONHOSTED_URL_PREFIX
 
-  # PyPI Package
-  #
-  # @api private
+  # Represents a Python package.
+  # This package can be a PyPI package (either by name/version or PyPI distribution URL),
+  # or it can be a non-PyPI URL.
   class Package
-    extend T::Sig
-
-    attr_accessor :name
-    attr_accessor :extras
-    attr_accessor :version
-
-    sig { params(package_string: String, is_url: T::Boolean).void }
-    def initialize(package_string, is_url: false)
+    sig { params(package_string: String, is_url: T::Boolean, python_name: String).void }
+    def initialize(package_string, is_url: false, python_name: "python")
       @pypi_info = nil
+      @package_string = package_string
+      @is_url = is_url
+      @is_pypi_url = package_string.start_with? PYTHONHOSTED_URL_PREFIX
+      @python_name = python_name
+    end
 
-      if is_url
-        match = if package_string.start_with?(PYTHONHOSTED_URL_PREFIX)
-          File.basename(package_string).match(/^(.+)-([a-z\d.]+?)(?:.tar.gz|.zip)$/)
-        end
-        raise ArgumentError, "package should be a valid PyPI URL" if match.blank?
+    sig { returns(String) }
+    def name
+      basic_metadata if @name.blank?
+      @name
+    end
 
-        @name = match[1]
-        @version = match[2]
-        return
-      end
+    sig { returns(T::Array[T.nilable(String)]) }
+    def extras
+      basic_metadata if @extras.blank?
+      @extras
+    end
 
-      @name = package_string
-      @name, @version = @name.split("==") if @name.include? "=="
+    sig { returns(T.nilable(String)) }
+    def version
+      basic_metadata if @version.blank?
+      @version
+    end
 
-      return unless (match = @name.match(/^(.*?)\[(.+)\]$/))
+    sig { params(new_version: String).void }
+    def version=(new_version)
+      raise ArgumentError, "can't update version for non-PyPI packages" unless valid_pypi_package?
 
-      @name = match[1]
-      @extras = match[2].split ","
+      @version = new_version
     end
 
-    # Get name, URL, SHA-256 checksum, and latest version for a given PyPI package.
-    sig { params(version: T.nilable(T.any(String, Version))).returns(T.nilable(T::Array[String])) }
-    def pypi_info(version: nil)
-      return @pypi_info if @pypi_info.present? && version.blank?
+    sig { returns(T::Boolean) }
+    def valid_pypi_package?
+      @is_pypi_url || !@is_url
+    end
 
-      version ||= @version
-      metadata_url = if version.present?
-        "https://pypi.org/pypi/#{@name}/#{version}/json"
+    # Get name, URL, SHA-256 checksum and latest version for a given package.
+    # This only works for packages from PyPI or from a PyPI URL; packages
+    # derived from non-PyPI URLs will produce `nil` here.
+    sig { params(new_version: T.nilable(T.any(String, Version))).returns(T.nilable(T::Array[String])) }
+    def pypi_info(new_version: nil)
+      return unless valid_pypi_package?
+      return @pypi_info if @pypi_info.present? && new_version.blank?
+
+      new_version ||= version
+      metadata_url = if new_version.present?
+        "https://pypi.org/pypi/#{name}/#{new_version}/json"
       else
-        "https://pypi.org/pypi/#{@name}/json"
+        "https://pypi.org/pypi/#{name}/json"
       end
-      out, _, status = curl_output metadata_url, "--location", "--fail"
+      out, _, status = Utils::Curl.curl_output metadata_url, "--location", "--fail"
 
       return unless status.success?
 
@@ -67,29 +75,41 @@ def pypi_info(version: nil)
         return
       end
 
-      sdist = json["urls"].find { |url| url["packagetype"] == "sdist" }
-      return json["info"]["name"] if sdist.nil?
+      dist = json["urls"].find do |url|
+        url["packagetype"] == "sdist"
+      end
 
-      @pypi_info = [json["info"]["name"], sdist["url"], sdist["digests"]["sha256"], json["info"]["version"]]
-    end
+      # If there isn't an sdist, we use the first universal wheel.
+      if dist.nil?
+        dist = json["urls"].find do |url|
+          url["filename"].end_with?("-none-any.whl")
+        end
+      end
 
-    sig { returns(T::Boolean) }
-    def valid_pypi_package?
-      info = pypi_info
-      info.present? && info.is_a?(Array)
+      return if dist.nil?
+
+      @pypi_info = [
+        PyPI.normalize_python_package(json["info"]["name"]), dist["url"],
+        dist["digests"]["sha256"], json["info"]["version"]
+      ]
     end
 
     sig { returns(String) }
     def to_s
-      out = @name
-      out += "[#{@extras.join(",")}]" if @extras.present?
-      out += "==#{@version}" if @version.present?
-      out
+      if valid_pypi_package?
+        out = name
+        out += "[#{extras.join(",")}]" if extras.present?
+        out += "==#{version}" if version.present?
+        out
+      else
+        @package_string
+      end
     end
 
     sig { params(other: Package).returns(T::Boolean) }
     def same_package?(other)
-      @name.tr("_", "-").casecmp(other.name.tr("_", "-")).zero?
+      # These names are pre-normalized, so we can compare them directly.
+      name == other.name
     end
 
     # Compare only names so we can use .include? and .uniq on a Package array
@@ -101,22 +121,79 @@ def ==(other)
 
     sig { returns(Integer) }
     def hash
-      @name.tr("_", "-").downcase.hash
+      name.hash
     end
 
     sig { params(other: Package).returns(T.nilable(Integer)) }
     def <=>(other)
-      @name <=> other.name
+      name <=> other.name
+    end
+
+    private
+
+    # Returns [name, [extras], version] for this package.
+    def basic_metadata
+      if @is_pypi_url
+        match = File.basename(@package_string).match(/^(.+)-([a-z\d.]+?)(?:.tar.gz|.zip)$/)
+        raise ArgumentError, "Package should be a valid PyPI URL" if match.blank?
+
+        @name ||= PyPI.normalize_python_package match[1]
+        @extras ||= []
+        @version ||= match[2]
+      elsif @is_url
+        ensure_formula_installed!(@python_name)
+
+        # The URL might be a source distribution hosted somewhere;
+        # try and use `pip install -q --no-deps --dry-run --report ...` to get its
+        # name and version.
+        # Note that this is different from the (similar) `pip install --report` we
+        # do below, in that it uses `--no-deps` because we only care about resolving
+        # this specific URL's project metadata.
+        command =
+          [Formula[@python_name].opt_libexec/"bin/python", "-m", "pip", "install", "-q", "--no-deps",
+           "--dry-run", "--ignore-installed", "--report", "/dev/stdout", @package_string]
+        pip_output = Utils.popen_read({ "PIP_REQUIRE_VIRTUALENV" => "false" }, *command)
+        unless $CHILD_STATUS.success?
+          raise ArgumentError, <<~EOS
+            Unable to determine metadata for "#{@package_string}" because of a failure when running
+            `#{command.join(" ")}`.
+          EOS
+        end
+
+        metadata = JSON.parse(pip_output)["install"].first["metadata"]
+
+        @name ||= PyPI.normalize_python_package metadata["name"]
+        @extras ||= []
+        @version ||= metadata["version"]
+      else
+        if @package_string.include? "=="
+          name, version = @package_string.split("==")
+        else
+          name = @package_string
+          version = nil
+        end
+
+        if (match = T.must(name).match(/^(.*?)\[(.+)\]$/))
+          name = match[1]
+          extras = T.must(match[2]).split ","
+        else
+          extras = []
+        end
+
+        @name ||= PyPI.normalize_python_package name
+        @extras ||= extras
+        @version ||= version
+      end
     end
   end
 
   sig { params(url: String, version: T.any(String, Version)).returns(T.nilable(String)) }
-  def update_pypi_url(url, version)
+  def self.update_pypi_url(url, version)
     package = Package.new url, is_url: true
 
     return unless package.valid_pypi_package?
 
-    _, url = package.pypi_info(version: version)
+    _, url = package.pypi_info(new_version: version)
     url
   rescue ArgumentError
     nil
@@ -130,13 +207,18 @@ def update_pypi_url(url, version)
       package_name:             T.nilable(String),
       extra_packages:           T.nilable(T::Array[String]),
       exclude_packages:         T.nilable(T::Array[String]),
+      dependencies:             T.nilable(T::Array[String]),
+      install_dependencies:     T.nilable(T::Boolean),
       print_only:               T.nilable(T::Boolean),
       silent:                   T.nilable(T::Boolean),
+      verbose:                  T.nilable(T::Boolean),
       ignore_non_pypi_packages: T.nilable(T::Boolean),
     ).returns(T.nilable(T::Boolean))
   }
-  def update_python_resources!(formula, version: nil, package_name: nil, extra_packages: nil, exclude_packages: nil,
-                               print_only: false, silent: false, ignore_non_pypi_packages: false)
+  def self.update_python_resources!(formula, version: nil, package_name: nil, extra_packages: nil,
+                                    exclude_packages: nil, dependencies: nil, install_dependencies: false,
+                                    print_only: false, silent: false, verbose: false,
+                                    ignore_non_pypi_packages: false)
 
     auto_update_list = formula.tap&.pypi_formula_mappings
     if auto_update_list.present? && auto_update_list.key?(formula.full_name) &&
@@ -154,43 +236,72 @@ def update_python_resources!(formula, version: nil, package_name: nil, extra_pac
         package_name = list_entry["package_name"]
         extra_packages = list_entry["extra_packages"]
         exclude_packages = list_entry["exclude_packages"]
+        dependencies = list_entry["dependencies"]
       end
     end
 
-    main_package = if package_name.present?
-      Package.new(package_name)
-    else
-      begin
-        Package.new(formula.stable.url, is_url: true)
-      rescue ArgumentError
-        nil
-      end
+    missing_dependencies = Array(dependencies).reject do |dependency|
+      Formula[dependency].any_version_installed?
+    rescue FormulaUnavailableError
+      odie "Formula \"#{dependency}\" not found but it is a dependency to update \"#{formula.name}\" resources."
+    end
+    if missing_dependencies.present?
+      missing_msg = "formulae required to update \"#{formula.name}\" resources: #{missing_dependencies.join(", ")}"
+      odie "Missing #{missing_msg}" unless install_dependencies
+      ohai "Installing #{missing_msg}"
+      missing_dependencies.each(&method(:ensure_formula_installed!))
     end
 
-    if main_package.blank?
-      return if ignore_non_pypi_packages
+    python_deps = formula.deps
+                         .select { |d| d.name.match?(/^python(@.+)?$/) }
+                         .map(&:to_formula)
+                         .sort_by(&:version)
+                         .reverse
+    python_name = if python_deps.empty?
+      "python"
+    else
+      (python_deps.find(&:any_version_installed?) || python_deps.first).name
+    end
 
-      odie <<~EOS
-        Could not infer PyPI package name from URL:
-          #{Formatter.url(formula.stable.url)}
-      EOS
+    main_package = if package_name.present?
+      package_string = package_name
+      package_string += "==#{formula.version}" if version.blank? && formula.version.present?
+      Package.new(package_string, python_name:)
+    elsif package_name == ""
+      nil
+    else
+      stable = T.must(formula.stable)
+      url = if stable.specs[:tag].present?
+        url = "git+#{stable.url}@#{stable.specs[:tag]}"
+      else
+        stable.url
+      end
+      Package.new(url, is_url: true, python_name:)
     end
 
-    unless main_package.valid_pypi_package?
-      return if ignore_non_pypi_packages
+    if main_package.nil?
+      odie "The main package was skipped but no PyPI `extra_packages` were provided." if extra_packages.blank?
+    elsif version.present?
+      if main_package.valid_pypi_package?
+        main_package.version = version
+      else
+        return if ignore_non_pypi_packages
 
-      odie "\"#{main_package}\" is not available on PyPI."
+        odie "The main package is not a PyPI package, meaning that version-only updates cannot be \
+          performed. Please update its URL manually."
+      end
     end
 
-    main_package.version = version if version.present?
-
     extra_packages = (extra_packages || []).map { |p| Package.new p }
     exclude_packages = (exclude_packages || []).map { |p| Package.new p }
-    exclude_packages += %W[#{main_package.name} argparse pip setuptools wsgiref].map { |p| Package.new p }
+    exclude_packages += %w[argparse pip wsgiref].map { |p| Package.new p }
+    if (newest_python = python_deps.first) && newest_python.version < Version.new("3.12")
+      exclude_packages.append(Package.new("setuptools"))
+    end
     # remove packages from the exclude list if we've explicitly requested them as an extra package
     exclude_packages.delete_if { |package| extra_packages.include?(package) }
 
-    input_packages = [main_package]
+    input_packages = Array(main_package)
     extra_packages.each do |extra_package|
       if !extra_package.valid_pypi_package? && !ignore_non_pypi_packages
         odie "\"#{extra_package}\" is not available on PyPI."
@@ -212,38 +323,35 @@ def update_python_resources!(formula, version: nil, package_name: nil, extra_pac
       end
     end
 
-    ensure_formula_installed!("pipgrip")
-
-    ohai "Retrieving PyPI dependencies for \"#{input_packages.join(" ")}\"..." if !print_only && !silent
-    command =
-      [Formula["pipgrip"].opt_bin/"pipgrip", "--json", "--tree", "--no-cache-dir", *input_packages.map(&:to_s)]
-    pipgrip_output = Utils.popen_read(*command)
-    unless $CHILD_STATUS.success?
-      odie <<~EOS
-        Unable to determine dependencies for \"#{input_packages.join(" ")}\" because of a failure when running
-        `#{command.join(" ")}`.
-        Please update the resources for \"#{formula.name}\" manually.
-      EOS
-    end
+    ensure_formula_installed!(python_name)
 
-    found_packages = json_to_packages(JSON.parse(pipgrip_output), main_package, exclude_packages).uniq
+    # Resolve the dependency tree of all input packages
+    show_info = !print_only && !silent
+    ohai "Retrieving PyPI dependencies for \"#{input_packages.join(" ")}\"..." if show_info
+    found_packages = pip_report(input_packages, python_name:, print_stderr: verbose && show_info)
+    # Resolve the dependency tree of excluded packages to prune the above
+    exclude_packages.delete_if { |package| found_packages.exclude? package }
+    ohai "Retrieving PyPI dependencies for excluded \"#{exclude_packages.join(" ")}\"..." if show_info
+    exclude_packages = pip_report(exclude_packages, python_name:, print_stderr: verbose && show_info)
+    exclude_packages += [Package.new(main_package.name)] unless main_package.nil?
 
     new_resource_blocks = ""
     found_packages.sort.each do |package|
       if exclude_packages.include? package
-        ohai "Excluding \"#{package}\"" if !print_only && !silent
+        ohai "Excluding \"#{package}\"" if show_info
+        exclude_packages.delete package
         next
       end
 
-      ohai "Getting PyPI info for \"#{package}\"" if !print_only && !silent
+      ohai "Getting PyPI info for \"#{package}\"" if show_info
       name, url, checksum = package.pypi_info
       # Fail if unable to find name, url or checksum for any resource
       if name.blank?
         odie "Unable to resolve some dependencies. Please update the resources for \"#{formula.name}\" manually."
       elsif url.blank? || checksum.blank?
         odie <<~EOS
-          Unable to find the URL and/or sha256 for the \"#{name}\" resource.
-          Please update the resources for \"#{formula.name}\" manually.
+          Unable to find the URL and/or sha256 for the "#{name}" resource.
+          Please update the resources for "#{formula.name}" manually.
         EOS
       end
 
@@ -257,6 +365,8 @@ def update_python_resources!(formula, version: nil, package_name: nil, extra_pac
       EOS
     end
 
+    odie "Excluded superfluous packages: #{exclude_packages.join(", ")}" if exclude_packages.any?
+
     if print_only
       puts new_resource_blocks.chomp
       return
@@ -269,13 +379,24 @@ def update_python_resources!(formula, version: nil, package_name: nil, extra_pac
       new_resource_blocks += "  def install"
     else
       # Replace existing resource blocks with new resource blocks
-      inreplace_regex = /  (resource .* do\s+url .*\s+sha256 .*\s+ end\s*)+/
+      inreplace_regex = /
+        \ \ (
+        resource\ .*\ do\s+
+          url\ .*\s+
+          sha256\ .*\s+
+          ((\#.*\s+)*
+          patch\ (.*\ )?do\s+
+            url\ .*\s+
+            sha256\ .*\s+
+          end\s+)*
+        end\s+)+
+      /x
       new_resource_blocks += "  "
     end
 
     ohai "Updating resource blocks" unless silent
     Utils::Inreplace.inreplace formula.path do |s|
-      if s.inreplace_string.scan(inreplace_regex).length > 1
+      if T.must(s.inreplace_string.split(/^  test do\b/, 2).first).scan(inreplace_regex).length > 1
         odie "Unable to update resource blocks for \"#{formula.name}\" automatically. Please update them manually."
       end
       s.sub! inreplace_regex, new_resource_blocks
@@ -284,17 +405,40 @@ def update_python_resources!(formula, version: nil, package_name: nil, extra_pac
     true
   end
 
-  def json_to_packages(json_tree, main_package, exclude_packages)
-    return [] if json_tree.blank?
+  def self.normalize_python_package(name)
+    # This normalization is defined in the PyPA packaging specifications;
+    # https://packaging.python.org/en/latest/specifications/name-normalization/#name-normalization
+    name.gsub(/[-_.]+/, "-").downcase
+  end
 
-    json_tree.flat_map do |package_json|
-      package = Package.new("#{package_json["name"]}==#{package_json["version"]}")
-      dependencies = if package == main_package || exclude_packages.exclude?(package)
-        json_to_packages(package_json["dependencies"], main_package, exclude_packages)
-      else
-        []
-      end
-      [package] + dependencies
+  def self.pip_report(packages, python_name: "python", print_stderr: false)
+    return [] if packages.blank?
+
+    command = [
+      Formula[python_name].opt_libexec/"bin/python", "-m", "pip", "install", "-q", "--disable-pip-version-check",
+      "--dry-run", "--ignore-installed", "--report=/dev/stdout", *packages.map(&:to_s)
+    ]
+    options = {}
+    options[:err] = :err if print_stderr
+    pip_output = Utils.popen_read({ "PIP_REQUIRE_VIRTUALENV" => "false" }, *command, **options)
+    unless $CHILD_STATUS.success?
+      odie <<~EOS
+        Unable to determine dependencies for "#{packages.join(" ")}" because of a failure when running
+        `#{command.join(" ")}`.
+        Please update the resources manually.
+      EOS
+    end
+    pip_report_to_packages(JSON.parse(pip_output)).uniq
+  end
+
+  def self.pip_report_to_packages(report)
+    return [] if report.blank?
+
+    report["install"].filter_map do |package|
+      name = normalize_python_package(package["metadata"]["name"])
+      version = package["metadata"]["version"]
+
+      Package.new "#{name}==#{version}"
     end
   end
 end
diff --git a/Library/Homebrew/utils/repology.rb b/Library/Homebrew/utils/repology.rb
index 0782cd1d49ad3..a382f47f5e408 100644
--- a/Library/Homebrew/utils/repology.rb
+++ b/Library/Homebrew/utils/repology.rb
@@ -1,25 +1,21 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "utils/curl"
 
 # Repology API client.
-#
-# @api private
 module Repology
   HOMEBREW_CORE = "homebrew"
   HOMEBREW_CASK = "homebrew_casks"
-
-  module_function
-
   MAX_PAGINATION = 15
   private_constant :MAX_PAGINATION
 
-  def query_api(last_package_in_response = "", repository:)
+  def self.query_api(last_package_in_response = "", repository:)
     last_package_in_response += "/" if last_package_in_response.present?
     url = "https://repology.org/api/v1/projects/#{last_package_in_response}?inrepo=#{repository}&outdated=1"
 
-    output, errors, = curl_output(url.to_s, "--silent", use_homebrew_curl: !curl_supports_tls13?)
+    output, errors, = Utils::Curl.curl_output(url.to_s, "--silent",
+                                              use_homebrew_curl: !Utils::Curl.curl_supports_tls13?)
     JSON.parse(output)
   rescue
     if Homebrew::EnvConfig.developer?
@@ -31,16 +27,17 @@ def query_api(last_package_in_response = "", repository:)
     raise
   end
 
-  def single_package_query(name, repository:)
-    url = "https://repology.org/tools/project-by?repo=#{repository}&" \
-          "name_type=srcname&target_page=api_v1_project&name=#{name}"
+  def self.single_package_query(name, repository:)
+    url = "https://repology.org/api/v1/project/#{name}"
 
-    output, errors, = curl_output("--location", "--silent", url.to_s, use_homebrew_curl: !curl_supports_tls13?)
+    output, errors, = Utils::Curl.curl_output("--location", "--silent", url.to_s,
+                                              use_homebrew_curl: !Utils::Curl.curl_supports_tls13?)
 
     data = JSON.parse(output)
     { name => data }
   rescue => e
-    error_output = [errors, "#{e.class}: #{e}", e.backtrace].compact
+    require "utils/backtrace"
+    error_output = [errors, "#{e.class}: #{e}", Utils::Backtrace.clean(e)].compact
     if Homebrew::EnvConfig.developer?
       $stderr.puts(*error_output)
     else
@@ -50,17 +47,17 @@ def single_package_query(name, repository:)
     nil
   end
 
-  def parse_api_response(limit = nil, last_package = "", repository:)
+  def self.parse_api_response(limit = nil, last_package = "", repository:)
     package_term = case repository
     when HOMEBREW_CORE
-      "formula"
+      "formulae"
     when HOMEBREW_CASK
-      "cask"
+      "casks"
     else
-      "package"
+      "packages"
     end
 
-    ohai "Querying outdated #{package_term.pluralize} from Repology"
+    ohai "Querying outdated #{package_term} from Repology"
 
     page_no = 1
     outdated_packages = {}
@@ -68,7 +65,7 @@ def parse_api_response(limit = nil, last_package = "", repository:)
     while page_no <= MAX_PAGINATION
       odebug "Paginating Repology API page: #{page_no}"
 
-      response = query_api(last_package, repository: repository)
+      response = query_api(last_package, repository:)
       outdated_packages.merge!(response)
       last_package = response.keys.max
 
@@ -76,13 +73,14 @@ def parse_api_response(limit = nil, last_package = "", repository:)
       break if (limit && outdated_packages.size >= limit) || response.size <= 1
     end
 
-    puts "#{outdated_packages.size} outdated #{package_term.pluralize(outdated_packages.size)} found"
+    package_term = package_term.chop if outdated_packages.size == 1
+    puts "#{outdated_packages.size} outdated #{package_term} found"
     puts
 
     outdated_packages.sort.to_h
   end
 
-  def latest_version(repositories)
+  def self.latest_version(repositories)
     # The status is "unique" when the package is present only in Homebrew, so
     # Repology has no way of knowing if the package is up-to-date.
     is_unique = repositories.find do |repo|
diff --git a/Library/Homebrew/utils/rubocop.rb b/Library/Homebrew/utils/rubocop.rb
index 35db8717bdd47..4e760a601ee27 100755
--- a/Library/Homebrew/utils/rubocop.rb
+++ b/Library/Homebrew/utils/rubocop.rb
@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "../standalone"
diff --git a/Library/Homebrew/utils/ruby.sh b/Library/Homebrew/utils/ruby.sh
index 3293949f533ed..dcf45c9ff30b9 100644
--- a/Library/Homebrew/utils/ruby.sh
+++ b/Library/Homebrew/utils/ruby.sh
@@ -1,6 +1,14 @@
-export HOMEBREW_REQUIRED_RUBY_VERSION=2.6.8
+# When bumping, run `brew vendor-gems --update=--ruby`
+# When bumping to a new major/minor version, also update the bounds in the Gemfile
+# HOMEBREW_LIBRARY set by bin/brew
+# shellcheck disable=SC2154
+export HOMEBREW_REQUIRED_RUBY_VERSION="3.3"
+HOMEBREW_PORTABLE_RUBY_VERSION="$(cat "${HOMEBREW_LIBRARY}/Homebrew/vendor/portable-ruby-version")"
+
+# Disable Ruby options we don't need.
+export HOMEBREW_RUBY_DISABLE_OPTIONS="--disable=gems,rubyopt"
 
-# HOMEBREW_LIBRARY is from the user environment
+# HOMEBREW_LIBRARY set by bin/brew
 # shellcheck disable=SC2154
 test_ruby() {
   if [[ ! -x "$1" ]]
@@ -13,44 +21,62 @@ test_ruby() {
     "${HOMEBREW_REQUIRED_RUBY_VERSION}" 2>/dev/null
 }
 
-# HOMEBREW_MACOS is set by brew.sh
+system_ruby_supported() {
+  ([[ -z "${HOMEBREW_MACOS}" ]] || can_use_ruby_from_path)
+}
+
+can_use_ruby_from_path() {
+  if [[ -n "${HOMEBREW_DEVELOPER}" || -n "${HOMEBREW_TESTS}" ]] && [[ -n "${HOMEBREW_USE_RUBY_FROM_PATH}" ]]
+  then
+    return 0
+  fi
+
+  return 1
+}
+
+find_first_valid_ruby() {
+  local ruby_exec
+  while IFS= read -r ruby_exec
+  do
+    if test_ruby "${ruby_exec}"
+    then
+      echo "${ruby_exec}"
+      break
+    fi
+  done
+}
+
 # HOMEBREW_PATH is set by global.rb
 # shellcheck disable=SC2154
 find_ruby() {
-  if [[ -n "${HOMEBREW_MACOS}" && -z "${HOMEBREW_USE_RUBY_FROM_PATH}" ]]
+  local valid_ruby
+
+  # Prioritise rubies from the filtered path (/usr/bin etc) unless explicitly overridden.
+  if ! can_use_ruby_from_path
   then
-    echo "/System/Library/Frameworks/Ruby.framework/Versions/Current/usr/bin/ruby"
-  else
-    local ruby_exec
-    while read -r ruby_exec
-    do
-      if test_ruby "${ruby_exec}"
-      then
-        echo "${ruby_exec}"
-        break
-      fi
-    done < <(
-      # function which() is set by brew.sh
-      # it is aliased to `type -P`
-      # shellcheck disable=SC2230
-      which -a ruby
-      # shellcheck disable=SC2230
-      PATH="${HOMEBREW_PATH}" which -a ruby
-    )
+    # function which() is set by brew.sh
+    # it is aliased to `type -P`
+    # shellcheck disable=SC2230
+    valid_ruby=$(find_first_valid_ruby < <(which -a ruby))
   fi
+
+  if [[ -z "${valid_ruby}" ]]
+  then
+    # Same as above
+    # shellcheck disable=SC2230
+    valid_ruby=$(find_first_valid_ruby < <(PATH="${HOMEBREW_PATH}" which -a ruby))
+  fi
+
+  echo "${valid_ruby}"
 }
 
 # HOMEBREW_FORCE_VENDOR_RUBY is from the user environment
-# HOMEBREW_MACOS_SYSTEM_RUBY_NEW_ENOUGH are set by brew.sh
 # shellcheck disable=SC2154
 need_vendored_ruby() {
   if [[ -n "${HOMEBREW_FORCE_VENDOR_RUBY}" ]]
   then
     return 0
-  elif [[ -n "${HOMEBREW_MACOS_SYSTEM_RUBY_NEW_ENOUGH}" ]]
-  then
-    return 1
-  elif [[ -z "${HOMEBREW_MACOS}" ]] && test_ruby "${HOMEBREW_RUBY_PATH}"
+  elif system_ruby_supported && test_ruby "${HOMEBREW_RUBY_PATH}"
   then
     return 1
   else
@@ -65,10 +91,7 @@ setup-ruby-path() {
   local vendor_ruby_root
   local vendor_ruby_path
   local vendor_ruby_terminfo
-  local vendor_ruby_latest_version
   local vendor_ruby_current_version
-  # When bumping check if HOMEBREW_MACOS_SYSTEM_RUBY_NEW_ENOUGH (in brew.sh)
-  # also needs to be changed.
   local ruby_exec
   local upgrade_fail
   local install_fail
@@ -92,7 +115,6 @@ If there's no Homebrew Portable Ruby available for your processor:
   vendor_ruby_root="${vendor_dir}/portable-ruby/current"
   vendor_ruby_path="${vendor_ruby_root}/bin/ruby"
   vendor_ruby_terminfo="${vendor_ruby_root}/share/terminfo"
-  vendor_ruby_latest_version="$(cat "${vendor_dir}/portable-ruby-version")"
   vendor_ruby_current_version="$(readlink "${vendor_ruby_root}")"
 
   unset HOMEBREW_RUBY_PATH
@@ -106,12 +128,16 @@ If there's no Homebrew Portable Ruby available for your processor:
   then
     HOMEBREW_RUBY_PATH="${vendor_ruby_path}"
     TERMINFO_DIRS="${vendor_ruby_terminfo}"
-    if [[ "${vendor_ruby_current_version}" != "${vendor_ruby_latest_version}" ]]
+    if [[ "${vendor_ruby_current_version}" != "${HOMEBREW_PORTABLE_RUBY_VERSION}" ]]
     then
       brew vendor-install ruby || odie "${upgrade_fail}"
     fi
   else
-    HOMEBREW_RUBY_PATH="$(find_ruby)"
+    if system_ruby_supported
+    then
+      HOMEBREW_RUBY_PATH="$(find_ruby)"
+    fi
+
     if need_vendored_ruby
     then
       brew vendor-install ruby || odie "${install_fail}"
@@ -123,3 +149,12 @@ If there's no Homebrew Portable Ruby available for your processor:
   export HOMEBREW_RUBY_PATH
   [[ -n "${HOMEBREW_LINUX}" && -n "${TERMINFO_DIRS}" ]] && export TERMINFO_DIRS
 }
+
+setup-gem-home-bundle-gemfile() {
+  GEM_VERSION="$("${HOMEBREW_RUBY_PATH}" "${HOMEBREW_RUBY_DISABLE_OPTIONS}" "${HOMEBREW_LIBRARY}/Homebrew/utils/ruby_sh/ruby_gem_version.rb")"
+  GEM_HOME="${HOMEBREW_LIBRARY}/Homebrew/vendor/bundle/ruby/${GEM_VERSION}"
+  BUNDLE_GEMFILE="${HOMEBREW_LIBRARY}/Homebrew/Gemfile"
+
+  export GEM_HOME
+  export BUNDLE_GEMFILE
+}
diff --git a/Library/Homebrew/utils/ruby_check_version_script.rb b/Library/Homebrew/utils/ruby_check_version_script.rb
index 2d2ffbd26d93b..8a3471269c1a5 100755
--- a/Library/Homebrew/utils/ruby_check_version_script.rb
+++ b/Library/Homebrew/utils/ruby_check_version_script.rb
@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 HOMEBREW_REQUIRED_RUBY_VERSION = ARGV.first.freeze
@@ -8,16 +8,13 @@
 require "rubygems"
 
 ruby_version = Gem::Version.new(RUBY_VERSION)
-# This will only happen if the Ruby is too old anyway.
-abort unless ruby_version.respond_to?(:canonical_segments)
-
 homebrew_required_ruby_version = Gem::Version.new(HOMEBREW_REQUIRED_RUBY_VERSION)
 
 ruby_version_major, ruby_version_minor, = ruby_version.canonical_segments
 homebrew_required_ruby_version_major, homebrew_required_ruby_version_minor, =
   homebrew_required_ruby_version.canonical_segments
 
-if !ENV.fetch("HOMEBREW_DEVELOPER", "").empty? &&
+if (!ENV.fetch("HOMEBREW_DEVELOPER", "").empty? || !ENV.fetch("HOMEBREW_TESTS", "").empty?) &&
    !ENV.fetch("HOMEBREW_USE_RUBY_FROM_PATH", "").empty? &&
    ruby_version >= homebrew_required_ruby_version
   return
diff --git a/Library/Homebrew/utils/ruby_sh/ruby_gem_version.rb b/Library/Homebrew/utils/ruby_sh/ruby_gem_version.rb
new file mode 100644
index 0000000000000..a8538eabf1413
--- /dev/null
+++ b/Library/Homebrew/utils/ruby_sh/ruby_gem_version.rb
@@ -0,0 +1,5 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rbconfig"
+puts RbConfig::CONFIG["ruby_version"]
diff --git a/Library/Homebrew/utils/service.rb b/Library/Homebrew/utils/service.rb
new file mode 100644
index 0000000000000..3c13d75c70ce0
--- /dev/null
+++ b/Library/Homebrew/utils/service.rb
@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Utils
+  # Helpers for `brew services` related code.
+  module Service
+    # Check if a service is running for a specified formula.
+    sig { params(formula: Formula).returns(T::Boolean) }
+    def self.running?(formula)
+      if launchctl?
+        quiet_system(launchctl, "list", formula.plist_name)
+      elsif systemctl?
+        quiet_system(systemctl, "is-active", "--quiet", formula.service_name)
+      end
+    end
+
+    # Check if a service file is installed in the expected location.
+    sig { params(formula: Formula).returns(T::Boolean) }
+    def self.installed?(formula)
+      (launchctl? && formula.launchd_service_path.exist?) ||
+        (systemctl? && formula.systemd_service_path.exist?)
+    end
+
+    # Path to launchctl binary.
+    sig { returns(T.nilable(Pathname)) }
+    def self.launchctl
+      return @launchctl if defined? @launchctl
+      return if ENV["HOMEBREW_TEST_GENERIC_OS"]
+
+      @launchctl = T.let(which("launchctl"), T.nilable(Pathname))
+    end
+
+    # Path to systemctl binary.
+    sig { returns(T.nilable(Pathname)) }
+    def self.systemctl
+      return @systemctl if defined? @systemctl
+      return if ENV["HOMEBREW_TEST_GENERIC_OS"]
+
+      @systemctl = T.let(which("systemctl"), T.nilable(Pathname))
+    end
+
+    sig { returns(T::Boolean) }
+    def self.launchctl?
+      !launchctl.nil?
+    end
+
+    sig { returns(T::Boolean) }
+    def self.systemctl?
+      !systemctl.nil?
+    end
+  end
+end
diff --git a/Library/Homebrew/utils/shared_audits.rb b/Library/Homebrew/utils/shared_audits.rb
index 6845336faf80a..4dc494aca2674 100644
--- a/Library/Homebrew/utils/shared_audits.rb
+++ b/Library/Homebrew/utils/shared_audits.rb
@@ -1,38 +1,58 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "utils/curl"
+require "utils/github/api"
 
 # Auditing functions for rules common to both casks and formulae.
-#
-# @api private
 module SharedAudits
-  include Utils::Curl
-  extend Utils::Curl
-
-  module_function
+  URL_TYPE_HOMEPAGE = "homepage URL"
+
+  sig { params(product: String, cycle: String).returns(T.nilable(T::Hash[String, T.untyped])) }
+  def self.eol_data(product, cycle)
+    @eol_data ||= T.let({}, T.nilable(T::Hash[String, T.untyped]))
+    @eol_data["#{product}/#{cycle}"] ||= begin
+      out, _, status = Utils::Curl.curl_output("--location", "https://endoflife.date/api/#{product}/#{cycle}.json")
+      json = JSON.parse(out) if status.success?
+      json = nil if json&.dig("message")&.include?("Product not found")
+      json
+    end
+  end
 
-  def github_repo_data(user, repo)
-    @github_repo_data ||= {}
+  sig { params(user: String, repo: String).returns(T.nilable(T::Hash[String, T.untyped])) }
+  def self.github_repo_data(user, repo)
+    @github_repo_data ||= T.let({}, T.nilable(T::Hash[String, T.untyped]))
     @github_repo_data["#{user}/#{repo}"] ||= GitHub.repository(user, repo)
 
     @github_repo_data["#{user}/#{repo}"]
   rescue GitHub::API::HTTPNotFoundError
     nil
+  rescue GitHub::API::AuthenticationFailedError => e
+    raise unless e.message.match?(GitHub::API::GITHUB_IP_ALLOWLIST_ERROR)
   end
 
-  def github_release_data(user, repo, tag)
+  sig { params(user: String, repo: String, tag: String).returns(T.nilable(T::Hash[String, T.untyped])) }
+  private_class_method def self.github_release_data(user, repo, tag)
     id = "#{user}/#{repo}/#{tag}"
     url = "#{GitHub::API_URL}/repos/#{user}/#{repo}/releases/tags/#{tag}"
-    @github_release_data ||= {}
+    @github_release_data ||= T.let({}, T.nilable(T::Hash[String, T.untyped]))
     @github_release_data[id] ||= GitHub::API.open_rest(url)
 
     @github_release_data[id]
   rescue GitHub::API::HTTPNotFoundError
     nil
+  rescue GitHub::API::AuthenticationFailedError => e
+    raise unless e.message.match?(GitHub::API::GITHUB_IP_ALLOWLIST_ERROR)
   end
 
-  def github_release(user, repo, tag, formula: nil, cask: nil)
+  sig {
+    params(
+      user: String, repo: String, tag: String, formula: T.nilable(Formula), cask: T.nilable(Cask::Cask),
+    ).returns(
+      T.nilable(String),
+    )
+  }
+  def self.github_release(user, repo, tag, formula: nil, cask: nil)
     release = github_release_data(user, repo, tag)
     return unless release
 
@@ -48,29 +68,40 @@ def github_release(user, repo, tag, formula: nil, cask: nil)
       return "#{tag} is not a GitHub pre-release but '#{name}' is in the GitHub prerelease allowlist."
     end
 
-    return "#{tag} is a GitHub draft." if release["draft"]
+    "#{tag} is a GitHub draft." if release["draft"]
   end
 
-  def gitlab_repo_data(user, repo)
-    @gitlab_repo_data ||= {}
+  sig { params(user: String, repo: String).returns(T.nilable(T::Hash[String, T.untyped])) }
+  def self.gitlab_repo_data(user, repo)
+    @gitlab_repo_data ||= T.let({}, T.nilable(T::Hash[String, T.untyped]))
     @gitlab_repo_data["#{user}/#{repo}"] ||= begin
-      out, _, status = curl_output("https://gitlab.com/api/v4/projects/#{user}%2F#{repo}")
-      JSON.parse(out) if status.success?
+      out, _, status = Utils::Curl.curl_output("https://gitlab.com/api/v4/projects/#{user}%2F#{repo}")
+      json = JSON.parse(out) if status.success?
+      json = nil if json&.dig("message")&.include?("404 Project Not Found")
+      json
     end
   end
 
-  def gitlab_release_data(user, repo, tag)
+  sig { params(user: String, repo: String, tag: String).returns(T.nilable(T::Hash[String, T.untyped])) }
+  private_class_method def self.gitlab_release_data(user, repo, tag)
     id = "#{user}/#{repo}/#{tag}"
-    @gitlab_release_data ||= {}
+    @gitlab_release_data ||= T.let({}, T.nilable(T::Hash[String, T.untyped]))
     @gitlab_release_data[id] ||= begin
-      out, _, status = curl_output(
+      out, _, status = Utils::Curl.curl_output(
         "https://gitlab.com/api/v4/projects/#{user}%2F#{repo}/releases/#{tag}", "--fail"
       )
       JSON.parse(out) if status.success?
     end
   end
 
-  def gitlab_release(user, repo, tag, formula: nil, cask: nil)
+  sig {
+    params(
+      user: String, repo: String, tag: String, formula: T.nilable(Formula), cask: T.nilable(Cask::Cask),
+    ).returns(
+      T.nilable(String),
+    )
+  }
+  def self.gitlab_release(user, repo, tag, formula: nil, cask: nil)
     release = gitlab_release_data(user, repo, tag)
     return unless release
 
@@ -86,7 +117,8 @@ def gitlab_release(user, repo, tag, formula: nil, cask: nil)
     "#{tag} is a GitLab pre-release."
   end
 
-  def github(user, repo)
+  sig { params(user: String, repo: String).returns(T.nilable(String)) }
+  def self.github(user, repo)
     metadata = github_repo_data(user, repo)
 
     return if metadata.nil?
@@ -103,7 +135,8 @@ def github(user, repo)
     "GitHub repository too new (<30 days old)"
   end
 
-  def gitlab(user, repo)
+  sig { params(user: String, repo: String).returns(T.nilable(String)) }
+  def self.gitlab(user, repo)
     metadata = gitlab_repo_data(user, repo)
 
     return if metadata.nil?
@@ -118,24 +151,25 @@ def gitlab(user, repo)
     "GitLab repository too new (<30 days old)"
   end
 
-  def bitbucket(user, repo)
+  sig { params(user: String, repo: String).returns(T.nilable(String)) }
+  def self.bitbucket(user, repo)
     api_url = "https://api.bitbucket.org/2.0/repositories/#{user}/#{repo}"
-    out, _, status= curl_output("--request", "GET", api_url)
+    out, _, status = Utils::Curl.curl_output("--request", "GET", api_url)
     return unless status.success?
 
     metadata = JSON.parse(out)
     return if metadata.nil?
 
-    return "Uses deprecated mercurial support in Bitbucket" if metadata["scm"] == "hg"
+    return "Uses deprecated Mercurial support in Bitbucket" if metadata["scm"] == "hg"
 
     return "Bitbucket fork (not canonical repository)" unless metadata["parent"].nil?
 
     return "Bitbucket repository too new (<30 days old)" if Date.parse(metadata["created_on"]) >= (Date.today - 30)
 
-    forks_out, _, forks_status= curl_output("--request", "GET", "#{api_url}/forks")
+    forks_out, _, forks_status = Utils::Curl.curl_output("--request", "GET", "#{api_url}/forks")
     return unless forks_status.success?
 
-    watcher_out, _, watcher_status= curl_output("--request", "GET", "#{api_url}/watchers")
+    watcher_out, _, watcher_status = Utils::Curl.curl_output("--request", "GET", "#{api_url}/watchers")
     return unless watcher_status.success?
 
     forks_metadata = JSON.parse(forks_out)
@@ -149,21 +183,30 @@ def bitbucket(user, repo)
     "Bitbucket repository not notable enough (<30 forks and <75 watchers)"
   end
 
-  def github_tag_from_url(url)
-    url = url.to_s
-    tag = url.match(%r{^https://github\.com/[\w-]+/[\w-]+/archive/([^/]+)\.(tar\.gz|zip)$})
-             .to_a
-             .second
-    tag ||= url.match(%r{^https://github\.com/[\w-]+/[\w-]+/releases/download/([^/]+)/})
-               .to_a
-               .second
-    tag
+  sig { params(url: String).returns(T.nilable(String)) }
+  def self.github_tag_from_url(url)
+    tag = url[%r{^https://github\.com/[\w-]+/[\w.-]+/archive/refs/tags/(.+)\.(tar\.gz|zip)$}, 1]
+    tag || url[%r{^https://github\.com/[\w-]+/[\w.-]+/releases/download/([^/]+)/}, 1]
+  end
+
+  sig { params(url: String).returns(T.nilable(String)) }
+  def self.gitlab_tag_from_url(url)
+    url[%r{^https://gitlab\.com/(?:\w[\w.-]*/){2,}-/archive/([^/]+)/}, 1]
   end
 
-  def gitlab_tag_from_url(url)
-    url = url.to_s
-    url.match(%r{^https://gitlab\.com/[\w-]+/[\w-]+/-/archive/([^/]+)/})
-       .to_a
-       .second
+  sig { params(formula_or_cask: T.any(Formula, Cask::Cask)).returns(T.nilable(String)) }
+  def self.check_deprecate_disable_reason(formula_or_cask)
+    return if !formula_or_cask.deprecated? && !formula_or_cask.disabled?
+
+    reason = formula_or_cask.deprecated? ? formula_or_cask.deprecation_reason : formula_or_cask.disable_reason
+    return unless reason.is_a?(Symbol)
+
+    reasons = if formula_or_cask.is_a?(Formula)
+      DeprecateDisable::FORMULA_DEPRECATE_DISABLE_REASONS
+    else
+      DeprecateDisable::CASK_DEPRECATE_DISABLE_REASONS
+    end
+
+    "#{reason} is not a valid deprecate! or disable! reason" unless reasons.include?(reason)
   end
 end
diff --git a/Library/Homebrew/utils/shebang.rb b/Library/Homebrew/utils/shebang.rb
index edf36e0f0c61b..bdbe99ac3ef57 100644
--- a/Library/Homebrew/utils/shebang.rb
+++ b/Library/Homebrew/utils/shebang.rb
@@ -1,38 +1,44 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Utils
   # Helper functions for manipulating shebang lines.
-  #
-  # @api private
   module Shebang
-    extend T::Sig
+    extend T::Helpers
+
+    requires_ancestor { Kernel }
 
     module_function
 
     # Specification on how to rewrite a given shebang.
-    #
-    # @api private
     class RewriteInfo
-      extend T::Sig
+      sig { returns(Regexp) }
+      attr_reader :regex
 
-      attr_reader :regex, :max_length, :replacement
+      sig { returns(Integer) }
+      attr_reader :max_length
+
+      sig { returns(T.any(String, Pathname)) }
+      attr_reader :replacement
 
       sig { params(regex: Regexp, max_length: Integer, replacement: T.any(String, Pathname)).void }
       def initialize(regex, max_length, replacement)
-        @regex = regex
-        @max_length = max_length
-        @replacement = replacement
+        @regex = T.let(regex, Regexp)
+        @max_length = T.let(max_length, Integer)
+        @replacement = T.let(replacement, T.any(String, Pathname))
       end
     end
 
     # Rewrite shebang for the given `paths` using the given `rewrite_info`.
     #
-    # @example
-    #   rewrite_shebang detected_python_shebang, bin/"script.py"
+    # ### Example
+    #
+    # ```ruby
+    # rewrite_shebang detected_python_shebang, bin/"script.py"
+    # ```
     #
     # @api public
-    sig { params(rewrite_info: RewriteInfo, paths: T::Array[T.any(String, Pathname)]).void }
+    sig { params(rewrite_info: RewriteInfo, paths: T.any(String, Pathname)).void }
     def rewrite_shebang(rewrite_info, *paths)
       paths.each do |f|
         f = Pathname(f)
diff --git a/Library/Homebrew/utils/shebang.rbi b/Library/Homebrew/utils/shebang.rbi
deleted file mode 100644
index 9cdb0b2007155..0000000000000
--- a/Library/Homebrew/utils/shebang.rbi
+++ /dev/null
@@ -1,7 +0,0 @@
-# typed: strict
-
-module Utils
-  module Shebang
-    include Kernel
-  end
-end
diff --git a/Library/Homebrew/utils/shell.rb b/Library/Homebrew/utils/shell.rb
index b6663255db99b..a621fbff8d480 100644
--- a/Library/Homebrew/utils/shell.rb
+++ b/Library/Homebrew/utils/shell.rb
@@ -1,9 +1,11 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 module Utils
   module Shell
-    extend T::Sig
+    extend T::Helpers
+
+    requires_ancestor { Kernel }
 
     module_function
 
@@ -15,12 +17,17 @@ def from_path(path)
       shell_name = File.basename(path)
       # handle possible version suffix like `zsh-5.2`
       shell_name.sub!(/-.*\z/m, "")
-      shell_name.to_sym if %w[bash csh fish ksh mksh sh tcsh zsh].include?(shell_name)
+      shell_name.to_sym if %w[bash csh fish ksh mksh rc sh tcsh zsh].include?(shell_name)
+    end
+
+    sig { params(default: String).returns(String) }
+    def preferred_path(default: "")
+      ENV.fetch("SHELL", default)
     end
 
     sig { returns(T.nilable(Symbol)) }
     def preferred
-      from_path(ENV.fetch("SHELL", ""))
+      from_path(preferred_path)
     end
 
     sig { returns(T.nilable(Symbol)) }
@@ -39,6 +46,8 @@ def export_value(key, value, shell = preferred)
         # a single quote can be included in a single-quoted string via \'
         # and a literal \ can be included via \\
         "set -gx #{key} \"#{sh_quote(value)}\""
+      when :rc
+        "#{key}=(#{sh_quote(value)})"
       when :csh, :tcsh
         "setenv #{key} #{csh_quote(value)};"
       end
@@ -51,8 +60,11 @@ def profile
       when :bash
         bash_profile = "#{Dir.home}/.bash_profile"
         return bash_profile if File.exist? bash_profile
+      when :rc
+        rc_profile = "#{Dir.home}/.rcrc"
+        return rc_profile if File.exist? rc_profile
       when :zsh
-        return "#{ENV["ZDOTDIR"]}/.zshrc" if ENV["ZDOTDIR"].present?
+        return "#{ENV["HOMEBREW_ZDOTDIR"]}/.zshrc" if ENV["HOMEBREW_ZDOTDIR"].present?
       end
 
       SHELL_PROFILE_MAP.fetch(preferred, "~/.profile")
@@ -63,6 +75,8 @@ def set_variable_in_profile(variable, value)
       case preferred
       when :bash, :ksh, :sh, :zsh, nil
         "echo 'export #{variable}=#{sh_quote(value)}' >> #{profile}"
+      when :rc
+        "echo '#{variable}=(#{sh_quote(value)})' >> #{profile}"
       when :csh, :tcsh
         "echo 'setenv #{variable} #{csh_quote(value)}' >> #{profile}"
       when :fish
@@ -75,6 +89,8 @@ def prepend_path_in_profile(path)
       case preferred
       when :bash, :ksh, :mksh, :sh, :zsh, nil
         "echo 'export PATH=\"#{sh_quote(path)}:$PATH\"' >> #{profile}"
+      when :rc
+        "echo 'path=(#{sh_quote(path)} $path)' >> #{profile}"
       when :csh, :tcsh
         "echo 'setenv PATH #{csh_quote(path)}:$PATH' >> #{profile}"
       when :fish
@@ -88,37 +104,38 @@ def prepend_path_in_profile(path)
       fish: "~/.config/fish/config.fish",
       ksh:  "~/.kshrc",
       mksh: "~/.kshrc",
+      rc:   "~/.rcrc",
       sh:   "~/.profile",
       tcsh: "~/.tcshrc",
       zsh:  "~/.zshrc",
     }.freeze
 
-    UNSAFE_SHELL_CHAR = %r{([^A-Za-z0-9_\-.,:/@~\n])}.freeze
+    UNSAFE_SHELL_CHAR = %r{([^A-Za-z0-9_\-.,:/@~+\n])}
 
     sig { params(str: String).returns(String) }
     def csh_quote(str)
-      # ruby's implementation of shell_escape
+      # Ruby's implementation of `shell_escape`.
       str = str.to_s
       return "''" if str.empty?
 
       str = str.dup
-      # anything that isn't a known safe character is padded
+      # Anything that isn't a known safe character is padded.
       str.gsub!(UNSAFE_SHELL_CHAR, "\\\\" + "\\1") # rubocop:disable Style/StringConcatenation
-      # newlines have to be specially quoted in csh
-      str.gsub!(/\n/, "'\\\n'")
+      # Newlines have to be specially quoted in `csh`.
+      str.gsub!("\n", "'\\\n'")
       str
     end
 
     sig { params(str: String).returns(String) }
     def sh_quote(str)
-      # ruby's implementation of shell_escape
+      # Ruby's implementation of `shell_escape`.
       str = str.to_s
       return "''" if str.empty?
 
       str = str.dup
-      # anything that isn't a known safe character is padded
+      # Anything that isn't a known safe character is padded.
       str.gsub!(UNSAFE_SHELL_CHAR, "\\\\" + "\\1") # rubocop:disable Style/StringConcatenation
-      str.gsub!(/\n/, "'\n'")
+      str.gsub!("\n", "'\n'")
       str
     end
   end
diff --git a/Library/Homebrew/utils/shell.rbi b/Library/Homebrew/utils/shell.rbi
deleted file mode 100644
index b860bc1190ed9..0000000000000
--- a/Library/Homebrew/utils/shell.rbi
+++ /dev/null
@@ -1,7 +0,0 @@
-# typed: strict
-
-module Utils
-  module Shell
-    include Kernel
-  end
-end
diff --git a/Library/Homebrew/utils/shfmt.sh b/Library/Homebrew/utils/shfmt.sh
index 996d1bb18b6be..3655b315aa6da 100755
--- a/Library/Homebrew/utils/shfmt.sh
+++ b/Library/Homebrew/utils/shfmt.sh
@@ -97,7 +97,7 @@ fi
 ###
 
 # Check for specific patterns and prompt messages if detected
-no_forbidden_patten() {
+no_forbidden_pattern() {
   local file="$1"
   local tempfile="$2"
   local subject="$3"
@@ -131,7 +131,7 @@ no_tabs() {
   local file="$1"
   local tempfile="$2"
 
-  no_forbidden_patten "${file}" "${tempfile}" \
+  no_forbidden_pattern "${file}" "${tempfile}" \
     "Indent with tab" \
     'Replace tabs with 2 spaces instead.' \
     '^[[:space:]]+' \
@@ -167,7 +167,7 @@ Use the followings instead (keep for statements only one line):
 EOMSG
   )"
 
-  no_forbidden_patten "${file}" "${tempfile}" \
+  no_forbidden_pattern "${file}" "${tempfile}" \
     "Multiline for statement" \
     "${message}" \
     "${regex}"
@@ -197,7 +197,7 @@ Use the followings instead:
 EOMSG
   )"
 
-  no_forbidden_patten "${file}" "${tempfile}" \
+  no_forbidden_pattern "${file}" "${tempfile}" \
     "Pattern \`IFS=\$'\\n'\`" \
     "${message}" \
     "${regex}"
diff --git a/Library/Homebrew/utils/socket.rb b/Library/Homebrew/utils/socket.rb
new file mode 100644
index 0000000000000..7fb7139e33383
--- /dev/null
+++ b/Library/Homebrew/utils/socket.rb
@@ -0,0 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "socket"
+
+module Utils
+  # Wrapper around UNIXSocket to allow > 104 characters on macOS.
+  module UNIXSocketExt
+    extend T::Generic
+
+    sig {
+      type_parameters(:U).params(
+        path:   String,
+        _block: T.proc.params(arg0: UNIXSocket).returns(T.type_parameter(:U)),
+      ).returns(T.type_parameter(:U))
+    }
+    def self.open(path, &_block)
+      socket = Socket.new(:UNIX, :STREAM)
+      socket.connect(sockaddr_un(path))
+      unix_socket = UNIXSocket.for_fd(socket.fileno)
+      socket.autoclose = false # Transfer autoclose responsibility to UNIXSocket
+      yield unix_socket
+    end
+
+    sig { params(path: String).returns(String) }
+    def self.sockaddr_un(path)
+      Socket.sockaddr_un(path)
+    end
+  end
+
+  # Wrapper around UNIXServer to allow > 104 characters on macOS.
+  class UNIXServerExt < Socket
+    extend T::Generic
+
+    Elem = type_member(:out) { { fixed: String } }
+
+    sig { returns(String) }
+    attr_reader :path
+
+    sig { params(path: String).void }
+    def initialize(path)
+      super(:UNIX, :STREAM)
+      bind(UNIXSocketExt.sockaddr_un(path))
+      listen(Socket::SOMAXCONN)
+      @path = path
+    end
+
+    sig { returns(UNIXSocket) }
+    def accept_nonblock
+      socket, = super
+      socket.autoclose = false # Transfer autoclose responsibility to UNIXSocket
+      UNIXSocket.for_fd(socket.fileno)
+    end
+  end
+end
+
+require "extend/os/utils/socket"
diff --git a/Library/Homebrew/utils/spdx.rb b/Library/Homebrew/utils/spdx.rb
index 38e0183e92dac..c1830b5f30325 100644
--- a/Library/Homebrew/utils/spdx.rb
+++ b/Library/Homebrew/utils/spdx.rb
@@ -1,20 +1,16 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "utils/curl"
 require "utils/github"
 
 # Helper module for updating SPDX license data.
-#
-# @api private
 module SPDX
-  include Utils::Curl
-  extend Utils::Curl
-
   module_function
 
   DATA_PATH = (HOMEBREW_DATA_PATH/"spdx").freeze
   API_URL = "https://api.github.com/repos/spdx/license-list-data/releases/latest"
+  LICENSEREF_PREFIX = "LicenseRef-Homebrew-"
   ALLOWED_LICENSE_SYMBOLS = [
     :public_domain,
     :cannot_represent,
@@ -34,8 +30,8 @@ def latest_tag
 
   def download_latest_license_data!(to: DATA_PATH)
     data_url = "https://raw.githubusercontent.com/spdx/license-list-data/#{latest_tag}/json/"
-    curl_download("#{data_url}licenses.json", to: to/"spdx_licenses.json")
-    curl_download("#{data_url}exceptions.json", to: to/"spdx_exceptions.json")
+    Utils::Curl.curl_download("#{data_url}licenses.json", to: to/"spdx_licenses.json")
+    Utils::Curl.curl_download("#{data_url}exceptions.json", to: to/"spdx_exceptions.json")
   end
 
   def parse_license_expression(license_expression)
@@ -47,14 +43,14 @@ def parse_license_expression(license_expression)
       licenses.push license_expression
     when Hash, Array
       if license_expression.is_a? Hash
-        license_expression = license_expression.map do |key, value|
+        license_expression = license_expression.filter_map do |key, value|
           if key.is_a? String
             licenses.push key
             exceptions.push value[:with]
             next
           end
           value
-        end.compact
+        end
       end
 
       license_expression.each do |license|
@@ -95,17 +91,17 @@ def license_expression_to_string(license_expression, bracket: false, hash_type:
     when String
       license_expression
     when Symbol
-      license_expression.to_s.tr("_", " ").titleize
+      LICENSEREF_PREFIX + license_expression.to_s.tr("_", "-")
     when Hash
       expressions = []
 
       if license_expression.keys.length == 1
         hash_type = license_expression.keys.first
         if hash_type.is_a? String
-          expressions.push "#{hash_type} with #{license_expression[hash_type][:with]}"
+          expressions.push "#{hash_type} WITH #{license_expression[hash_type][:with]}"
         else
           expressions += license_expression[hash_type].map do |license|
-            license_expression_to_string license, bracket: true, hash_type: hash_type
+            license_expression_to_string license, bracket: true, hash_type:
           end
         end
       else
@@ -116,9 +112,9 @@ def license_expression_to_string(license_expression, bracket: false, hash_type:
       end
 
       operator = if hash_type == :any_of
-        " or "
+        " OR "
       else
-        " and "
+        " AND "
       end
 
       if bracket
@@ -129,6 +125,41 @@ def license_expression_to_string(license_expression, bracket: false, hash_type:
     end
   end
 
+  def string_to_license_expression(string)
+    return if string.blank?
+
+    result = string
+    result_type = nil
+
+    and_parts = string.split(/ and (?![^(]*\))/i)
+    if and_parts.length > 1
+      result = and_parts
+      result_type = :all_of
+    else
+      or_parts = string.split(/ or (?![^(]*\))/i)
+      if or_parts.length > 1
+        result = or_parts
+        result_type = :any_of
+      end
+    end
+
+    if result_type
+      result.map! do |part|
+        part = part[1..-2] if part[0] == "(" && part[-1] == ")"
+        string_to_license_expression(part)
+      end
+      { result_type => result }
+    else
+      with_parts = string.split(/ with /i, 2)
+      if with_parts.length > 1
+        { with_parts.first => { with: with_parts.second } }
+      else
+        license_sym = result[/^#{LICENSEREF_PREFIX}(.+)/o, 1]&.downcase&.tr("-", "_")&.to_sym
+        ALLOWED_LICENSE_SYMBOLS.include?(license_sym) ? license_sym : result
+      end
+    end
+  end
+
   def license_version_info(license)
     return [license] if ALLOWED_LICENSE_SYMBOLS.include? license
 
@@ -165,9 +196,9 @@ def forbidden_licenses_include?(license, forbidden_licenses)
 
     name, version, = license_version_info license
 
-    forbidden_licenses.each do |_, license_info|
+    forbidden_licenses.each_value do |license_info|
       forbidden_name, forbidden_version, forbidden_or_later = *license_info
-      next unless forbidden_name == name
+      next if forbidden_name != name
 
       return true if forbidden_or_later && forbidden_version <= version
 
diff --git a/Library/Homebrew/utils/string_inreplace_extension.rb b/Library/Homebrew/utils/string_inreplace_extension.rb
index ab49f00a92ac5..872a252a31fcf 100644
--- a/Library/Homebrew/utils/string_inreplace_extension.rb
+++ b/Library/Homebrew/utils/string_inreplace_extension.rb
@@ -1,27 +1,27 @@
-# typed: true
+# typed: strong
 # frozen_string_literal: true
 
-# Used by the `inreplace` function (in `utils.rb`).
-#
-# @api private
+# Used by the {Utils::Inreplace.inreplace} function.
 class StringInreplaceExtension
-  extend T::Sig
+  sig { returns(T::Array[String]) }
+  attr_accessor :errors
 
-  attr_accessor :errors, :inreplace_string
+  sig { returns(String) }
+  attr_accessor :inreplace_string
 
   sig { params(string: String).void }
   def initialize(string)
     @inreplace_string = string
-    @errors = []
+    @errors = T.let([], T::Array[String])
   end
 
   # Same as `String#sub!`, but warns if nothing was replaced.
   #
   # @api public
-  sig { params(before: T.any(Regexp, String), after: String).returns(T.nilable(String)) }
-  def sub!(before, after)
+  sig { params(before: T.any(Regexp, String), after: String, audit_result: T::Boolean).returns(T.nilable(String)) }
+  def sub!(before, after, audit_result: true)
     result = inreplace_string.sub!(before, after)
-    errors << "expected replacement of #{before.inspect} with #{after.inspect}" unless result
+    errors << "expected replacement of #{before.inspect} with #{after.inspect}" if audit_result && result.nil?
     result
   end
 
@@ -29,11 +29,22 @@ def sub!(before, after)
   #
   # @api public
   sig {
-    params(before: T.any(Regexp, String), after: T.nilable(String), audit_result: T::Boolean)
-      .returns(T.nilable(String))
+    params(
+      before:           T.any(Pathname, Regexp, String),
+      after:            T.any(Pathname, String),
+      old_audit_result: T.nilable(T::Boolean),
+      audit_result:     T::Boolean,
+    ).returns(T.nilable(String))
   }
-  def gsub!(before, after, audit_result = true) # rubocop:disable Style/OptionalBooleanParameter
-    result = inreplace_string.gsub!(before, after)
+  def gsub!(before, after, old_audit_result = nil, audit_result: true)
+    # NOTE: must check for `#nil?` and not `#blank?`, or else `old_audit_result = false` will not call `odeprecated`.
+    unless old_audit_result.nil?
+      odeprecated "gsub!(before, after, #{old_audit_result})",
+                  "gsub!(before, after, audit_result: #{old_audit_result})"
+      audit_result = old_audit_result
+    end
+    before = before.to_s if before.is_a?(Pathname)
+    result = inreplace_string.gsub!(before, after.to_s)
     errors << "expected replacement of #{before.inspect} with #{after.inspect}" if audit_result && result.nil?
     result
   end
@@ -44,7 +55,9 @@ def gsub!(before, after, audit_result = true) # rubocop:disable Style/OptionalBo
   # @api public
   sig { params(flag: String, new_value: T.any(String, Pathname)).void }
   def change_make_var!(flag, new_value)
-    return if gsub!(/^#{Regexp.escape(flag)}[ \t]*[\\?+:!]?=[ \t]*((?:.*\\\n)*.*)$/, "#{flag}=#{new_value}", false)
+    return if gsub!(/^#{Regexp.escape(flag)}[ \t]*[\\?+:!]?=[ \t]*((?:.*\\\n)*.*)$/,
+                    "#{flag}=#{new_value}",
+                    audit_result: false)
 
     errors << "expected to change #{flag.inspect} to #{new_value.inspect}"
   end
@@ -56,9 +69,11 @@ def change_make_var!(flag, new_value)
   def remove_make_var!(flags)
     Array(flags).each do |flag|
       # Also remove trailing \n, if present.
-      unless gsub!(/^#{Regexp.escape(flag)}[ \t]*[\\?+:!]?=(?:.*\\\n)*.*$\n?/, "", false)
-        errors << "expected to remove #{flag.inspect}"
-      end
+      next if gsub!(/^#{Regexp.escape(flag)}[ \t]*[\\?+:!]?=(?:.*\\\n)*.*$\n?/,
+                    "",
+                    audit_result: false)
+
+      errors << "expected to remove #{flag.inspect}"
     end
   end
 
@@ -67,6 +82,6 @@ def remove_make_var!(flags)
   # @api public
   sig { params(flag: String).returns(String) }
   def get_make_var(flag)
-    inreplace_string[/^#{Regexp.escape(flag)}[ \t]*[\\?+:!]?=[ \t]*((?:.*\\\n)*.*)$/, 1]
+    T.must(inreplace_string[/^#{Regexp.escape(flag)}[ \t]*[\\?+:!]?=[ \t]*((?:.*\\\n)*.*)$/, 1])
   end
 end
diff --git a/Library/Homebrew/utils/svn.rb b/Library/Homebrew/utils/svn.rb
index 5c4269ddd6483..049e95e7985b5 100644
--- a/Library/Homebrew/utils/svn.rb
+++ b/Library/Homebrew/utils/svn.rb
@@ -1,16 +1,12 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "system_command"
 
 module Utils
   # Helper functions for querying SVN information.
-  #
-  # @api private
   module Svn
     class << self
-      extend T::Sig
-
       include SystemCommand::Mixin
 
       sig { returns(T::Boolean) }
@@ -23,7 +19,7 @@ def version
         return @version if defined?(@version)
 
         stdout, _, status = system_command(HOMEBREW_SHIMS_PATH/"shared/svn", args: ["--version"], print_stderr: false)
-        @version = status.success? ? stdout.chomp[/svn, version (\d+(?:\.\d+)*)/, 1] : nil
+        @version = T.let(status.success? ? stdout.chomp[/svn, version (\d+(?:\.\d+)*)/, 1] : nil, T.nilable(String))
       end
 
       sig { params(url: String).returns(T::Boolean) }
@@ -31,23 +27,24 @@ def remote_exists?(url)
         return true unless available?
 
         args = ["ls", url, "--depth", "empty"]
-        _, stderr, status = system_command("svn", args: args, print_stderr: false)
+        _, stderr, status = system_command("svn", args:, print_stderr: false)
         return status.success? unless stderr.include?("certificate verification failed")
 
         # OK to unconditionally trust here because we're just checking if a URL exists.
         system_command("svn", args: args.concat(invalid_cert_flags), print_stderr: false).success?
       end
 
-      sig { returns(Array) }
+      sig { returns(T::Array[String]) }
       def invalid_cert_flags
         opoo "Ignoring Subversion certificate errors!"
         args = ["--non-interactive", "--trust-server-cert"]
-        if Version.create(version || "-1") >= Version.create("1.9")
+        if Version.new(version || "-1") >= Version.new("1.9")
           args << "--trust-server-cert-failures=expired,not-yet-valid"
         end
         args
       end
 
+      sig { void }
       def clear_version_cache
         remove_instance_variable(:@version) if defined?(@version)
       end
diff --git a/Library/Homebrew/utils/tar.rb b/Library/Homebrew/utils/tar.rb
index cb0ff5fbcadb6..dd1dca89dcce4 100644
--- a/Library/Homebrew/utils/tar.rb
+++ b/Library/Homebrew/utils/tar.rb
@@ -1,28 +1,31 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "system_command"
 
 module Utils
   # Helper functions for interacting with tar files.
-  #
-  # @api private
   module Tar
     class << self
+      include SystemCommand::Mixin
+
       TAR_FILE_EXTENSIONS = %w[.tar .tb2 .tbz .tbz2 .tgz .tlz .txz .tZ].freeze
 
+      sig { returns(T::Boolean) }
       def available?
         executable.present?
       end
 
+      sig { returns(T.nilable(Pathname)) }
       def executable
         return @executable if defined?(@executable)
 
         gnu_tar_gtar_path = HOMEBREW_PREFIX/"opt/gnu-tar/bin/gtar"
         gnu_tar_gtar = gnu_tar_gtar_path if gnu_tar_gtar_path.executable?
-        @executable = which("gtar") || gnu_tar_gtar || which("tar")
+        @executable = T.let((which("gtar") || gnu_tar_gtar || which("tar")), T.nilable(Pathname))
       end
 
+      sig { params(path: T.any(Pathname, String)).void }
       def validate_file(path)
         return unless available?
 
@@ -33,6 +36,7 @@ def validate_file(path)
         odie "#{path} is not a valid tar file!" if !status.success? || stdout.blank?
       end
 
+      sig { void }
       def clear_executable_cache
         remove_instance_variable(:@executable) if defined?(@executable)
       end
diff --git a/Library/Homebrew/utils/timer.rb b/Library/Homebrew/utils/timer.rb
new file mode 100644
index 0000000000000..b01e715de402f
--- /dev/null
+++ b/Library/Homebrew/utils/timer.rb
@@ -0,0 +1,21 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Utils
+  module Timer
+    sig { params(time: T.nilable(Time)).returns(T.any(Float, Integer, NilClass)) }
+    def self.remaining(time)
+      return unless time
+
+      [0, time - Time.now].max
+    end
+
+    sig { params(time: T.nilable(Time)).returns(T.any(Float, Integer, NilClass)) }
+    def self.remaining!(time)
+      r = remaining(time)
+      raise Timeout::Error if r && r <= 0
+
+      r
+    end
+  end
+end
diff --git a/Library/Homebrew/utils/topological_hash.rb b/Library/Homebrew/utils/topological_hash.rb
index cac774c8572db..cf7382f42b4c3 100644
--- a/Library/Homebrew/utils/topological_hash.rb
+++ b/Library/Homebrew/utils/topological_hash.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
 require "tsort"
@@ -6,8 +6,6 @@
 module Utils
   # Topologically sortable hash map.
   class TopologicalHash < Hash
-    extend T::Sig
-
     include TSort
 
     sig {
@@ -32,10 +30,10 @@ def self.graph_package_dependencies(packages, accumulator = TopologicalHash.new)
         else
           formula_deps = cask_or_formula.deps
                                         .reject(&:build?)
+                                        .reject(&:test?)
                                         .map(&:to_formula)
           cask_deps = cask_or_formula.requirements
-                                     .map(&:cask)
-                                     .compact
+                                     .filter_map(&:cask)
                                      .map { |c| Cask::CaskLoader.load(c, config: nil) }
         end
 
diff --git a/Library/Homebrew/utils/tty.rb b/Library/Homebrew/utils/tty.rb
index ddb7da38246e4..a539e37b5b13b 100644
--- a/Library/Homebrew/utils/tty.rb
+++ b/Library/Homebrew/utils/tty.rb
@@ -1,17 +1,41 @@
-# typed: true
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
-require "env_config"
-
 # Various helper functions for interacting with TTYs.
-#
-# @api private
 module Tty
   @stream = $stdout
 
-  class << self
-    extend T::Sig
+  COLOR_CODES = {
+    red:     31,
+    green:   32,
+    yellow:  33,
+    blue:    34,
+    magenta: 35,
+    cyan:    36,
+    default: 39,
+  }.freeze
+
+  STYLE_CODES = {
+    reset:         0,
+    bold:          1,
+    italic:        3,
+    underline:     4,
+    strikethrough: 9,
+    no_underline:  24,
+  }.freeze
+
+  SPECIAL_CODES = {
+    up:         "1A",
+    down:       "1B",
+    right:      "1C",
+    left:       "1D",
+    erase_line: "K",
+    erase_char: "P",
+  }.freeze
+
+  CODES = COLOR_CODES.merge(STYLE_CODES).freeze
 
+  class << self
     sig { params(stream: T.any(IO, StringIO), _block: T.proc.params(arg0: T.any(IO, StringIO)).void).void }
     def with(stream, &_block)
       previous_stream = @stream
@@ -27,14 +51,54 @@ def strip_ansi(string)
       string.gsub(/\033\[\d+(;\d+)*m/, "")
     end
 
+    sig { params(line_count: Integer).returns(String) }
+    def move_cursor_up(line_count)
+      "\033[#{line_count}A"
+    end
+
+    sig { params(line_count: Integer).returns(String) }
+    def move_cursor_up_beginning(line_count)
+      "\033[#{line_count}F"
+    end
+
+    sig { params(line_count: Integer).returns(String) }
+    def move_cursor_down(line_count)
+      "\033[#{line_count}B"
+    end
+
+    sig { returns(String) }
+    def clear_to_end
+      "\033[K"
+    end
+
+    sig { returns(String) }
+    def hide_cursor
+      "\033[?25l"
+    end
+
+    sig { returns(String) }
+    def show_cursor
+      "\033[?25h"
+    end
+
+    sig { returns(T.nilable([Integer, Integer])) }
+    def size
+      return @size if defined?(@size)
+
+      height, width = `/bin/stty size 2>/dev/null`.presence&.split&.map(&:to_i)
+      return if height.nil? || width.nil?
+
+      @size = [height, width]
+    end
+
+    sig { returns(Integer) }
+    def height
+      @height ||= size&.first || `/usr/bin/tput lines 2>/dev/null`.presence&.to_i || 40
+    end
+
     sig { returns(Integer) }
     def width
-      @width ||= begin
-        _, width = `/bin/stty size 2>/dev/null`.split
-        width, = `/usr/bin/tput cols 2>/dev/null`.split if width.to_i.zero?
-        width ||= 80
-        width.to_i
-      end
+      @width ||= size&.second || `/usr/bin/tput cols 2>/dev/null`.presence&.to_i || 80
     end
 
     sig { params(string: String).returns(String) }
@@ -42,36 +106,6 @@ def truncate(string)
       (w = width).zero? ? string.to_s : (string.to_s[0, w - 4] || "")
     end
 
-    COLOR_CODES = {
-      red:     31,
-      green:   32,
-      yellow:  33,
-      blue:    34,
-      magenta: 35,
-      cyan:    36,
-      default: 39,
-    }.freeze
-
-    STYLE_CODES = {
-      reset:         0,
-      bold:          1,
-      italic:        3,
-      underline:     4,
-      strikethrough: 9,
-      no_underline:  24,
-    }.freeze
-
-    SPECIAL_CODES = {
-      up:         "1A",
-      down:       "1B",
-      right:      "1C",
-      left:       "1D",
-      erase_line: "K",
-      erase_char: "P",
-    }.freeze
-
-    CODES = COLOR_CODES.merge(STYLE_CODES).freeze
-
     sig { returns(String) }
     def current_escape_sequence
       return "" if @escape_sequence.nil?
@@ -113,10 +147,12 @@ def to_s
 
     sig { returns(T::Boolean) }
     def color?
+      require "env_config"
+
       return false if Homebrew::EnvConfig.no_color?
       return true if Homebrew::EnvConfig.color?
 
       @stream.tty?
     end
-end
+  end
 end
diff --git a/Library/Homebrew/utils/uid.rb b/Library/Homebrew/utils/uid.rb
new file mode 100644
index 0000000000000..4c102a2b8a763
--- /dev/null
+++ b/Library/Homebrew/utils/uid.rb
@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Utils
+  module UID
+    sig { type_parameters(:U).params(_block: T.proc.returns(T.type_parameter(:U))).returns(T.type_parameter(:U)) }
+    def self.drop_euid(&_block)
+      return yield if Process.euid == Process.uid
+
+      original_euid = Process.euid
+      begin
+        Process::Sys.seteuid(Process.uid)
+        yield
+      ensure
+        Process::Sys.seteuid(original_euid)
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/utils/user.rb b/Library/Homebrew/utils/user.rb
index c2db57e637e34..72339509f6860 100644
--- a/Library/Homebrew/utils/user.rb
+++ b/Library/Homebrew/utils/user.rb
@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "delegate"
@@ -7,11 +7,7 @@
 require "system_command"
 
 # A system user.
-#
-# @api private
 class User < SimpleDelegator
-  extend T::Sig
-
   include SystemCommand::Mixin
 
   # Return whether the user has an active GUI session.
@@ -33,6 +29,6 @@ def self.current
     pwuid = Etc.getpwuid(Process.euid)
     return if pwuid.nil?
 
-    @current = new(pwuid.name)
+    @current = T.let(new(pwuid.name), T.nilable(T.attached_class))
   end
 end
diff --git a/Library/Homebrew/vendor/bundle/bundler/setup.rb b/Library/Homebrew/vendor/bundle/bundler/setup.rb
index 54f7c69dc10e8..38d9274972704 100644
--- a/Library/Homebrew/vendor/bundle/bundler/setup.rb
+++ b/Library/Homebrew/vendor/bundle/bundler/setup.rb
@@ -1,107 +1,116 @@
 require 'rbconfig'
-# ruby 1.8.7 doesn't define RUBY_ENGINE
-ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
-ruby_version = RbConfig::CONFIG["ruby_version"]
-path = File.expand_path('..', __FILE__)
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/i18n-1.12.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/minitest-5.16.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/tzinfo-2.0.5/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/zeitwerk-2.6.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/activesupport-6.1.6.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/public_suffix-4.0.7/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/addressable-2.8.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/ast-2.4.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/bindata-2.4.10/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-15/2.6.0-static/msgpack-1.5.3"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/msgpack-1.5.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-15/2.6.0-static/bootsnap-1.12.0"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/bootsnap-1.12.0/lib"
-$:.unshift "#{path}/"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-15/2.6.0-static/byebug-11.1.3"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/byebug-11.1.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/coderay-1.1.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/highline-2.0.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/commander-4.6.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/connection_pool-2.2.5/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/did_you_mean-1.6.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/diff-lcs-1.5.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/docile-1.4.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-15/2.6.0-static/unf_ext-0.0.8.2"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/unf_ext-0.0.8.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/unf-0.1.4/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/domain_name-0.5.20190701/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/regexp_parser-2.5.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/ecma-re-validator-0.4.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/elftools-1.1.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/hana-1.3.7/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-15/2.6.0-static/hpricot-0.8.6"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/hpricot-0.8.6/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/http-cookie-1.0.5/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-15/2.6.0-static/json-2.6.2"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/json-2.6.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/uri_template-0.7.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/json_schemer-0.2.21/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/mime-types-data-3.2022.0105/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/mime-types-3.4.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/net-http-digest_auth-1.4.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/net-http-persistent-4.0.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/mini_portile2-2.8.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-15/2.6.0-static/racc-1.6.0"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/racc-1.6.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/nokogiri-1.13.7-x86_64-darwin/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rubyntlm-0.6.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/webrick-1.7.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/webrobots-0.1.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/mechanize-2.8.5/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/method_source-1.0.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/mustache-1.1.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parallel-1.22.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parallel_tests-3.11.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parser-3.1.2.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rainbow-3.1.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-runtime-0.5.10175/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/parlour-8.0.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/patchelf-1.3.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/plist-3.6.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/pry-0.14.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rack-2.2.4/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/unparser-0.6.4/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rbi-0.0.14/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/extensions/x86_64-darwin-15/2.6.0-static/rdiscount-2.2.0.2"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rdiscount-2.2.0.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rexml-3.2.5/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/ronn-0.7.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-support-3.11.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-core-3.11.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-expectations-3.11.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-mocks-3.11.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-3.11.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-github-2.3.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-its-1.3.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-retry-0.6.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-sorbet-1.8.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec-wait-0.0.9/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rspec_junit_formatter-0.5.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rubocop-ast-1.19.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/ruby-progressbar-1.11.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/unicode-display_width-2.2.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rubocop-1.32.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rubocop-performance-1.14.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rubocop-rails-2.15.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rubocop-rspec-2.12.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/rubocop-sorbet-0.6.11/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/ruby-macho-3.0.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/simplecov-html-0.12.3/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/simplecov_json_formatter-0.1.4/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/simplecov-0.21.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/simplecov-cobertura-2.1.0/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-static-0.5.10175-universal-darwin-15/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-0.5.10175/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-static-and-runtime-0.5.10175/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/thor-1.2.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/spoom-1.1.11/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/yard-0.9.28/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/yard-sorbet-0.6.1/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/tapioca-0.7.2/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/warning-1.3.0/lib"
+module Kernel
+  remove_method(:gem) if private_method_defined?(:gem)
+
+  def gem(*)
+  end
+
+  private :gem
+end
+unless defined?(Gem)
+  module Gem
+    def self.ruby_api_version
+      RbConfig::CONFIG["ruby_version"]
+    end
+
+    def self.extension_api_version
+      if 'no' == RbConfig::CONFIG['ENABLE_SHARED']
+        "#{ruby_api_version}-static"
+      else
+        ruby_api_version
+      end
+    end
+  end
+end
+if Gem.respond_to?(:discover_gems_on_require=)
+  Gem.discover_gems_on_require = false
+else
+  [::Kernel.singleton_class, ::Kernel].each do |k|
+    if k.private_method_defined?(:gem_original_require)
+      private_require = k.private_method_defined?(:require)
+      k.send(:remove_method, :require)
+      k.send(:define_method, :require, k.instance_method(:gem_original_require))
+      k.send(:private, :require) if private_require
+    end
+  end
+end
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/public_suffix-6.0.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/addressable-2.8.7/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/ast-2.4.2/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/extensions/arm64-darwin-20/#{Gem.extension_api_version}/bigdecimal-3.1.8")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/bigdecimal-3.1.8/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/bindata-2.5.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/coderay-1.1.3/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/diff-lcs-1.5.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/docile-1.4.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/elftools-1.3.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/erubi-1.13.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/hana-1.3.7/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/extensions/arm64-darwin-20/#{Gem.extension_api_version}/json-2.7.5")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/json-2.7.5/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/regexp_parser-2.9.2/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/simpleidn-0.2.3/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/json_schemer-2.3.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rexml-3.3.9/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/kramdown-2.4.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/language_server-protocol-3.17.0.3/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/logger-1.6.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/method_source-1.1.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/minitest-5.25.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/netrc-0.11.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/parallel-1.26.3/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/parallel_tests-4.7.2/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/extensions/arm64-darwin-20/#{Gem.extension_api_version}/racc-1.8.1")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/racc-1.8.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/parser-3.3.5.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/patchelf-1.5.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/plist-3.7.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/extensions/arm64-darwin-20/#{Gem.extension_api_version}/prism-1.2.0")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/prism-1.2.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/pry-0.14.2/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rainbow-3.1.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/sorbet-runtime-0.5.11633/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rbi-0.2.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/extensions/arm64-darwin-20/#{Gem.extension_api_version}/rbs-3.6.1")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rbs-3.6.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/extensions/arm64-darwin-20/#{Gem.extension_api_version}/redcarpet-3.6.0")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/redcarpet-3.6.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rspec-support-3.13.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rspec-core-3.13.2/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rspec-expectations-3.13.3/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rspec-mocks-3.13.2/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rspec-3.13.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rspec-github-2.4.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rspec-retry-0.6.2/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rspec-sorbet-1.9.2/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rspec_junit_formatter-0.6.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rubocop-ast-1.33.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/ruby-progressbar-1.13.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/unicode-display_width-2.6.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rubocop-1.67.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rubocop-md-1.2.4/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rubocop-performance-1.22.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rubocop-rspec-3.2.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/rubocop-sorbet-0.8.7/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/ruby-lsp-0.21.2/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/ruby-macho-4.1.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/extensions/arm64-darwin-20/#{Gem.extension_api_version}/ruby-prof-1.7.1")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/ruby-prof-1.7.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/simplecov-html-0.13.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/simplecov_json_formatter-0.1.4/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/simplecov-0.22.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/simplecov-cobertura-2.1.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/sorbet-static-0.5.11633-universal-darwin/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/sorbet-0.5.11633/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/sorbet-static-and-runtime-0.5.11633/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/thor-1.3.2/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/spoom-1.5.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/extensions/arm64-darwin-20/#{Gem.extension_api_version}/stackprof-0.2.26")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/stackprof-0.2.26/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/yard-0.9.37/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/yard-sorbet-0.9.0/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/tapioca-0.16.3/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/extensions/arm64-darwin-20/#{Gem.extension_api_version}/vernier-1.2.1")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/vernier-1.2.1/lib")
+$:.unshift File.expand_path("#{__dir__}/../#{RUBY_ENGINE}/#{Gem.ruby_api_version}/gems/warning-1.4.0/lib")
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/actionable_error.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/actionable_error.rb
deleted file mode 100644
index 7db14cd1783a8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/actionable_error.rb
+++ /dev/null
@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  # Actionable errors let's you define actions to resolve an error.
-  #
-  # To make an error actionable, include the <tt>ActiveSupport::ActionableError</tt>
-  # module and invoke the +action+ class macro to define the action. An action
-  # needs a name and a block to execute.
-  module ActionableError
-    extend Concern
-
-    class NonActionable < StandardError; end
-
-    included do
-      class_attribute :_actions, default: {}
-    end
-
-    def self.actions(error) # :nodoc:
-      case error
-      when ActionableError, -> it { Class === it && it < ActionableError }
-        error._actions
-      else
-        {}
-      end
-    end
-
-    def self.dispatch(error, name) # :nodoc:
-      actions(error).fetch(name).call
-    rescue KeyError
-      raise NonActionable, "Cannot find action \"#{name}\""
-    end
-
-    module ClassMethods
-      # Defines an action that can resolve the error.
-      #
-      #   class PendingMigrationError < MigrationError
-      #     include ActiveSupport::ActionableError
-      #
-      #     action "Run pending migrations" do
-      #       ActiveRecord::Tasks::DatabaseTasks.migrate
-      #     end
-      #   end
-      def action(name, &block)
-        _actions[name] = block
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/array_inquirer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/array_inquirer.rb
deleted file mode 100644
index 0cbba0b6df245..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/array_inquirer.rb
+++ /dev/null
@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/symbol/starts_ends_with"
-
-module ActiveSupport
-  # Wrapping an array in an +ArrayInquirer+ gives a friendlier way to check
-  # its string-like contents:
-  #
-  #   variants = ActiveSupport::ArrayInquirer.new([:phone, :tablet])
-  #
-  #   variants.phone?    # => true
-  #   variants.tablet?   # => true
-  #   variants.desktop?  # => false
-  class ArrayInquirer < Array
-    # Passes each element of +candidates+ collection to ArrayInquirer collection.
-    # The method returns true if any element from the ArrayInquirer collection
-    # is equal to the stringified or symbolized form of any element in the +candidates+ collection.
-    #
-    # If +candidates+ collection is not given, method returns true.
-    #
-    #   variants = ActiveSupport::ArrayInquirer.new([:phone, :tablet])
-    #
-    #   variants.any?                      # => true
-    #   variants.any?(:phone, :tablet)     # => true
-    #   variants.any?('phone', 'desktop')  # => true
-    #   variants.any?(:desktop, :watch)    # => false
-    def any?(*candidates)
-      if candidates.none?
-        super
-      else
-        candidates.any? do |candidate|
-          include?(candidate.to_sym) || include?(candidate.to_s)
-        end
-      end
-    end
-
-    private
-      def respond_to_missing?(name, include_private = false)
-        name.end_with?("?") || super
-      end
-
-      def method_missing(name, *args)
-        if name.end_with?("?")
-          any?(name[0..-2])
-        else
-          super
-        end
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/backtrace_cleaner.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/backtrace_cleaner.rb
deleted file mode 100644
index 03c7dc75d6f33..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/backtrace_cleaner.rb
+++ /dev/null
@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  # Backtraces often include many lines that are not relevant for the context
-  # under review. This makes it hard to find the signal amongst the backtrace
-  # noise, and adds debugging time. With a BacktraceCleaner, filters and
-  # silencers are used to remove the noisy lines, so that only the most relevant
-  # lines remain.
-  #
-  # Filters are used to modify lines of data, while silencers are used to remove
-  # lines entirely. The typical filter use case is to remove lengthy path
-  # information from the start of each line, and view file paths relevant to the
-  # app directory instead of the file system root. The typical silencer use case
-  # is to exclude the output of a noisy library from the backtrace, so that you
-  # can focus on the rest.
-  #
-  #   bc = ActiveSupport::BacktraceCleaner.new
-  #   bc.add_filter   { |line| line.gsub(Rails.root.to_s, '') } # strip the Rails.root prefix
-  #   bc.add_silencer { |line| /puma|rubygems/.match?(line) } # skip any lines from puma or rubygems
-  #   bc.clean(exception.backtrace) # perform the cleanup
-  #
-  # To reconfigure an existing BacktraceCleaner (like the default one in Rails)
-  # and show as much data as possible, you can always call
-  # <tt>BacktraceCleaner#remove_silencers!</tt>, which will restore the
-  # backtrace to a pristine state. If you need to reconfigure an existing
-  # BacktraceCleaner so that it does not filter or modify the paths of any lines
-  # of the backtrace, you can call <tt>BacktraceCleaner#remove_filters!</tt>
-  # These two methods will give you a completely untouched backtrace.
-  #
-  # Inspired by the Quiet Backtrace gem by thoughtbot.
-  class BacktraceCleaner
-    def initialize
-      @filters, @silencers = [], []
-      add_gem_filter
-      add_gem_silencer
-      add_stdlib_silencer
-    end
-
-    # Returns the backtrace after all filters and silencers have been run
-    # against it. Filters run first, then silencers.
-    def clean(backtrace, kind = :silent)
-      filtered = filter_backtrace(backtrace)
-
-      case kind
-      when :silent
-        silence(filtered)
-      when :noise
-        noise(filtered)
-      else
-        filtered
-      end
-    end
-    alias :filter :clean
-
-    # Adds a filter from the block provided. Each line in the backtrace will be
-    # mapped against this filter.
-    #
-    #   # Will turn "/my/rails/root/app/models/person.rb" into "/app/models/person.rb"
-    #   backtrace_cleaner.add_filter { |line| line.gsub(Rails.root, '') }
-    def add_filter(&block)
-      @filters << block
-    end
-
-    # Adds a silencer from the block provided. If the silencer returns +true+
-    # for a given line, it will be excluded from the clean backtrace.
-    #
-    #   # Will reject all lines that include the word "puma", like "/gems/puma/server.rb" or "/app/my_puma_server/rb"
-    #   backtrace_cleaner.add_silencer { |line| /puma/.match?(line) }
-    def add_silencer(&block)
-      @silencers << block
-    end
-
-    # Removes all silencers, but leaves in the filters. Useful if your
-    # context of debugging suddenly expands as you suspect a bug in one of
-    # the libraries you use.
-    def remove_silencers!
-      @silencers = []
-    end
-
-    # Removes all filters, but leaves in the silencers. Useful if you suddenly
-    # need to see entire filepaths in the backtrace that you had already
-    # filtered out.
-    def remove_filters!
-      @filters = []
-    end
-
-    private
-      FORMATTED_GEMS_PATTERN = /\A[^\/]+ \([\w.]+\) /
-
-      def add_gem_filter
-        gems_paths = (Gem.path | [Gem.default_dir]).map { |p| Regexp.escape(p) }
-        return if gems_paths.empty?
-
-        gems_regexp = %r{\A(#{gems_paths.join('|')})/(bundler/)?gems/([^/]+)-([\w.]+)/(.*)}
-        gems_result = '\3 (\4) \5'
-        add_filter { |line| line.sub(gems_regexp, gems_result) }
-      end
-
-      def add_gem_silencer
-        add_silencer { |line| FORMATTED_GEMS_PATTERN.match?(line) }
-      end
-
-      def add_stdlib_silencer
-        add_silencer { |line| line.start_with?(RbConfig::CONFIG["rubylibdir"]) }
-      end
-
-      def filter_backtrace(backtrace)
-        @filters.each do |f|
-          backtrace = backtrace.map { |line| f.call(line) }
-        end
-
-        backtrace
-      end
-
-      def silence(backtrace)
-        @silencers.each do |s|
-          backtrace = backtrace.reject { |line| s.call(line) }
-        end
-
-        backtrace
-      end
-
-      def noise(backtrace)
-        backtrace.select do |line|
-          @silencers.any? do |s|
-            s.call(line)
-          end
-        end
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/benchmarkable.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/benchmarkable.rb
deleted file mode 100644
index abd0d59d9ee5a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/benchmarkable.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/benchmark"
-require "active_support/core_ext/hash/keys"
-
-module ActiveSupport
-  module Benchmarkable
-    # Allows you to measure the execution time of a block in a template and
-    # records the result to the log. Wrap this block around expensive operations
-    # or possible bottlenecks to get a time reading for the operation. For
-    # example, let's say you thought your file processing method was taking too
-    # long; you could wrap it in a benchmark block.
-    #
-    #  <% benchmark 'Process data files' do %>
-    #    <%= expensive_files_operation %>
-    #  <% end %>
-    #
-    # That would add something like "Process data files (345.2ms)" to the log,
-    # which you can then use to compare timings when optimizing your code.
-    #
-    # You may give an optional logger level (<tt>:debug</tt>, <tt>:info</tt>,
-    # <tt>:warn</tt>, <tt>:error</tt>) as the <tt>:level</tt> option. The
-    # default logger level value is <tt>:info</tt>.
-    #
-    #  <% benchmark 'Low-level files', level: :debug do %>
-    #    <%= lowlevel_files_operation %>
-    #  <% end %>
-    #
-    # Finally, you can pass true as the third argument to silence all log
-    # activity (other than the timing information) from inside the block. This
-    # is great for boiling down a noisy block to just a single statement that
-    # produces one log line:
-    #
-    #  <% benchmark 'Process data files', level: :info, silence: true do %>
-    #    <%= expensive_and_chatty_files_operation %>
-    #  <% end %>
-    def benchmark(message = "Benchmarking", options = {})
-      if logger
-        options.assert_valid_keys(:level, :silence)
-        options[:level] ||= :info
-
-        result = nil
-        ms = Benchmark.ms { result = options[:silence] ? logger.silence { yield } : yield }
-        logger.public_send(options[:level], "%s (%.1fms)" % [ message, ms ])
-        result
-      else
-        yield
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/builder.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/builder.rb
deleted file mode 100644
index 3fa7e6b26d9ac..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/builder.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require "builder"
-rescue LoadError => e
-  $stderr.puts "You don't have builder installed in your application. Please add it to your Gemfile and run bundle install"
-  raise e
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/callbacks.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/callbacks.rb
deleted file mode 100644
index 1a55f8af35098..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/callbacks.rb
+++ /dev/null
@@ -1,862 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-require "active_support/descendants_tracker"
-require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/class/attribute"
-require "active_support/core_ext/string/filters"
-require "thread"
-
-module ActiveSupport
-  # Callbacks are code hooks that are run at key points in an object's life cycle.
-  # The typical use case is to have a base class define a set of callbacks
-  # relevant to the other functionality it supplies, so that subclasses can
-  # install callbacks that enhance or modify the base functionality without
-  # needing to override or redefine methods of the base class.
-  #
-  # Mixing in this module allows you to define the events in the object's
-  # life cycle that will support callbacks (via +ClassMethods.define_callbacks+),
-  # set the instance methods, procs, or callback objects to be called (via
-  # +ClassMethods.set_callback+), and run the installed callbacks at the
-  # appropriate times (via +run_callbacks+).
-  #
-  # By default callbacks are halted by throwing +:abort+.
-  # See +ClassMethods.define_callbacks+ for details.
-  #
-  # Three kinds of callbacks are supported: before callbacks, run before a
-  # certain event; after callbacks, run after the event; and around callbacks,
-  # blocks that surround the event, triggering it when they yield. Callback code
-  # can be contained in instance methods, procs or lambdas, or callback objects
-  # that respond to certain predetermined methods. See +ClassMethods.set_callback+
-  # for details.
-  #
-  #   class Record
-  #     include ActiveSupport::Callbacks
-  #     define_callbacks :save
-  #
-  #     def save
-  #       run_callbacks :save do
-  #         puts "- save"
-  #       end
-  #     end
-  #   end
-  #
-  #   class PersonRecord < Record
-  #     set_callback :save, :before, :saving_message
-  #     def saving_message
-  #       puts "saving..."
-  #     end
-  #
-  #     set_callback :save, :after do |object|
-  #       puts "saved"
-  #     end
-  #   end
-  #
-  #   person = PersonRecord.new
-  #   person.save
-  #
-  # Output:
-  #   saving...
-  #   - save
-  #   saved
-  module Callbacks
-    extend Concern
-
-    included do
-      extend ActiveSupport::DescendantsTracker
-      class_attribute :__callbacks, instance_writer: false, default: {}
-    end
-
-    CALLBACK_FILTER_TYPES = [:before, :after, :around]
-
-    # Runs the callbacks for the given event.
-    #
-    # Calls the before and around callbacks in the order they were set, yields
-    # the block (if given one), and then runs the after callbacks in reverse
-    # order.
-    #
-    # If the callback chain was halted, returns +false+. Otherwise returns the
-    # result of the block, +nil+ if no callbacks have been set, or +true+
-    # if callbacks have been set but no block is given.
-    #
-    #   run_callbacks :save do
-    #     save
-    #   end
-    #
-    #--
-    #
-    # As this method is used in many places, and often wraps large portions of
-    # user code, it has an additional design goal of minimizing its impact on
-    # the visible call stack. An exception from inside a :before or :after
-    # callback can be as noisy as it likes -- but when control has passed
-    # smoothly through and into the supplied block, we want as little evidence
-    # as possible that we were here.
-    def run_callbacks(kind)
-      callbacks = __callbacks[kind.to_sym]
-
-      if callbacks.empty?
-        yield if block_given?
-      else
-        env = Filters::Environment.new(self, false, nil)
-        next_sequence = callbacks.compile
-
-        # Common case: no 'around' callbacks defined
-        if next_sequence.final?
-          next_sequence.invoke_before(env)
-          env.value = !env.halted && (!block_given? || yield)
-          next_sequence.invoke_after(env)
-          env.value
-        else
-          invoke_sequence = Proc.new do
-            skipped = nil
-
-            while true
-              current = next_sequence
-              current.invoke_before(env)
-              if current.final?
-                env.value = !env.halted && (!block_given? || yield)
-              elsif current.skip?(env)
-                (skipped ||= []) << current
-                next_sequence = next_sequence.nested
-                next
-              else
-                next_sequence = next_sequence.nested
-                begin
-                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
-                  target.send(method, *arguments, &block)
-                ensure
-                  next_sequence = current
-                end
-              end
-              current.invoke_after(env)
-              skipped.pop.invoke_after(env) while skipped&.first
-              break env.value
-            end
-          end
-
-          invoke_sequence.call
-        end
-      end
-    end
-
-    private
-      # A hook invoked every time a before callback is halted.
-      # This can be overridden in ActiveSupport::Callbacks implementors in order
-      # to provide better debugging/logging.
-      def halted_callback_hook(filter, name)
-      end
-
-      module Conditionals # :nodoc:
-        class Value
-          def initialize(&block)
-            @block = block
-          end
-          def call(target, value); @block.call(value); end
-        end
-      end
-
-      module Filters
-        Environment = Struct.new(:target, :halted, :value)
-
-        class Before
-          def self.build(callback_sequence, user_callback, user_conditions, chain_config, filter, name)
-            halted_lambda = chain_config[:terminator]
-
-            if user_conditions.any?
-              halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter, name)
-            else
-              halting(callback_sequence, user_callback, halted_lambda, filter, name)
-            end
-          end
-
-          def self.halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter, name)
-            callback_sequence.before do |env|
-              target = env.target
-              value  = env.value
-              halted = env.halted
-
-              if !halted && user_conditions.all? { |c| c.call(target, value) }
-                result_lambda = -> { user_callback.call target, value }
-                env.halted = halted_lambda.call(target, result_lambda)
-                if env.halted
-                  target.send :halted_callback_hook, filter, name
-                end
-              end
-
-              env
-            end
-          end
-          private_class_method :halting_and_conditional
-
-          def self.halting(callback_sequence, user_callback, halted_lambda, filter, name)
-            callback_sequence.before do |env|
-              target = env.target
-              value  = env.value
-              halted = env.halted
-
-              unless halted
-                result_lambda = -> { user_callback.call target, value }
-                env.halted = halted_lambda.call(target, result_lambda)
-                if env.halted
-                  target.send :halted_callback_hook, filter, name
-                end
-              end
-
-              env
-            end
-          end
-          private_class_method :halting
-        end
-
-        class After
-          def self.build(callback_sequence, user_callback, user_conditions, chain_config)
-            if chain_config[:skip_after_callbacks_if_terminated]
-              if user_conditions.any?
-                halting_and_conditional(callback_sequence, user_callback, user_conditions)
-              else
-                halting(callback_sequence, user_callback)
-              end
-            else
-              if user_conditions.any?
-                conditional callback_sequence, user_callback, user_conditions
-              else
-                simple callback_sequence, user_callback
-              end
-            end
-          end
-
-          def self.halting_and_conditional(callback_sequence, user_callback, user_conditions)
-            callback_sequence.after do |env|
-              target = env.target
-              value  = env.value
-              halted = env.halted
-
-              if !halted && user_conditions.all? { |c| c.call(target, value) }
-                user_callback.call target, value
-              end
-
-              env
-            end
-          end
-          private_class_method :halting_and_conditional
-
-          def self.halting(callback_sequence, user_callback)
-            callback_sequence.after do |env|
-              unless env.halted
-                user_callback.call env.target, env.value
-              end
-
-              env
-            end
-          end
-          private_class_method :halting
-
-          def self.conditional(callback_sequence, user_callback, user_conditions)
-            callback_sequence.after do |env|
-              target = env.target
-              value  = env.value
-
-              if user_conditions.all? { |c| c.call(target, value) }
-                user_callback.call target, value
-              end
-
-              env
-            end
-          end
-          private_class_method :conditional
-
-          def self.simple(callback_sequence, user_callback)
-            callback_sequence.after do |env|
-              user_callback.call env.target, env.value
-
-              env
-            end
-          end
-          private_class_method :simple
-        end
-      end
-
-      class Callback #:nodoc:#
-        def self.build(chain, filter, kind, options)
-          if filter.is_a?(String)
-            raise ArgumentError, <<-MSG.squish
-              Passing string to define a callback is not supported. See the `.set_callback`
-              documentation to see supported values.
-            MSG
-          end
-
-          new chain.name, filter, kind, options, chain.config
-        end
-
-        attr_accessor :kind, :name
-        attr_reader :chain_config
-
-        def initialize(name, filter, kind, options, chain_config)
-          @chain_config = chain_config
-          @name    = name
-          @kind    = kind
-          @filter  = filter
-          @key     = compute_identifier filter
-          @if      = check_conditionals(options[:if])
-          @unless  = check_conditionals(options[:unless])
-        end
-
-        def filter; @key; end
-        def raw_filter; @filter; end
-
-        def merge_conditional_options(chain, if_option:, unless_option:)
-          options = {
-            if: @if.dup,
-            unless: @unless.dup
-          }
-
-          options[:if].concat     Array(unless_option)
-          options[:unless].concat Array(if_option)
-
-          self.class.build chain, @filter, @kind, options
-        end
-
-        def matches?(_kind, _filter)
-          @kind == _kind && filter == _filter
-        end
-
-        def duplicates?(other)
-          case @filter
-          when Symbol
-            matches?(other.kind, other.filter)
-          else
-            false
-          end
-        end
-
-        # Wraps code with filter
-        def apply(callback_sequence)
-          user_conditions = conditions_lambdas
-          user_callback = CallTemplate.build(@filter, self)
-
-          case kind
-          when :before
-            Filters::Before.build(callback_sequence, user_callback.make_lambda, user_conditions, chain_config, @filter, name)
-          when :after
-            Filters::After.build(callback_sequence, user_callback.make_lambda, user_conditions, chain_config)
-          when :around
-            callback_sequence.around(user_callback, user_conditions)
-          end
-        end
-
-        def current_scopes
-          Array(chain_config[:scope]).map { |s| public_send(s) }
-        end
-
-        private
-          EMPTY_ARRAY = [].freeze
-          private_constant :EMPTY_ARRAY
-
-          def check_conditionals(conditionals)
-            return EMPTY_ARRAY if conditionals.blank?
-
-            conditionals = Array(conditionals)
-            if conditionals.any? { |c| c.is_a?(String) }
-              raise ArgumentError, <<-MSG.squish
-                Passing string to be evaluated in :if and :unless conditional
-                options is not supported. Pass a symbol for an instance method,
-                or a lambda, proc or block, instead.
-              MSG
-            end
-
-            conditionals.freeze
-          end
-
-          def compute_identifier(filter)
-            case filter
-            when ::Proc
-              filter.object_id
-            else
-              filter
-            end
-          end
-
-          def conditions_lambdas
-            @if.map { |c| CallTemplate.build(c, self).make_lambda } +
-              @unless.map { |c| CallTemplate.build(c, self).inverted_lambda }
-          end
-      end
-
-      # A future invocation of user-supplied code (either as a callback,
-      # or a condition filter).
-      class CallTemplate # :nodoc:
-        def initialize(target, method, arguments, block)
-          @override_target = target
-          @method_name = method
-          @arguments = arguments
-          @override_block = block
-        end
-
-        # Return the parts needed to make this call, with the given
-        # input values.
-        #
-        # Returns an array of the form:
-        #
-        #   [target, block, method, *arguments]
-        #
-        # This array can be used as such:
-        #
-        #   target.send(method, *arguments, &block)
-        #
-        # The actual invocation is left up to the caller to minimize
-        # call stack pollution.
-        def expand(target, value, block)
-          expanded = [@override_target || target, @override_block || block, @method_name]
-
-          @arguments.each do |arg|
-            case arg
-            when :value then expanded << value
-            when :target then expanded << target
-            when :block then expanded << (block || raise(ArgumentError))
-            end
-          end
-
-          expanded
-        end
-
-        # Return a lambda that will make this call when given the input
-        # values.
-        def make_lambda
-          lambda do |target, value, &block|
-            target, block, method, *arguments = expand(target, value, block)
-            target.send(method, *arguments, &block)
-          end
-        end
-
-        # Return a lambda that will make this call when given the input
-        # values, but then return the boolean inverse of that result.
-        def inverted_lambda
-          lambda do |target, value, &block|
-            target, block, method, *arguments = expand(target, value, block)
-            ! target.send(method, *arguments, &block)
-          end
-        end
-
-        # Filters support:
-        #
-        #   Symbols:: A method to call.
-        #   Procs::   A proc to call with the object.
-        #   Objects:: An object with a <tt>before_foo</tt> method on it to call.
-        #
-        # All of these objects are converted into a CallTemplate and handled
-        # the same after this point.
-        def self.build(filter, callback)
-          case filter
-          when Symbol
-            new(nil, filter, [], nil)
-          when Conditionals::Value
-            new(filter, :call, [:target, :value], nil)
-          when ::Proc
-            if filter.arity > 1
-              new(nil, :instance_exec, [:target, :block], filter)
-            elsif filter.arity > 0
-              new(nil, :instance_exec, [:target], filter)
-            else
-              new(nil, :instance_exec, [], filter)
-            end
-          else
-            method_to_call = callback.current_scopes.join("_")
-
-            new(filter, method_to_call, [:target], nil)
-          end
-        end
-      end
-
-      # Execute before and after filters in a sequence instead of
-      # chaining them with nested lambda calls, see:
-      # https://github.com/rails/rails/issues/18011
-      class CallbackSequence # :nodoc:
-        def initialize(nested = nil, call_template = nil, user_conditions = nil)
-          @nested = nested
-          @call_template = call_template
-          @user_conditions = user_conditions
-
-          @before = []
-          @after = []
-        end
-
-        def before(&before)
-          @before.unshift(before)
-          self
-        end
-
-        def after(&after)
-          @after.push(after)
-          self
-        end
-
-        def around(call_template, user_conditions)
-          CallbackSequence.new(self, call_template, user_conditions)
-        end
-
-        def skip?(arg)
-          arg.halted || !@user_conditions.all? { |c| c.call(arg.target, arg.value) }
-        end
-
-        attr_reader :nested
-
-        def final?
-          !@call_template
-        end
-
-        def expand_call_template(arg, block)
-          @call_template.expand(arg.target, arg.value, block)
-        end
-
-        def invoke_before(arg)
-          @before.each { |b| b.call(arg) }
-        end
-
-        def invoke_after(arg)
-          @after.each { |a| a.call(arg) }
-        end
-      end
-
-      class CallbackChain #:nodoc:#
-        include Enumerable
-
-        attr_reader :name, :config
-
-        def initialize(name, config)
-          @name = name
-          @config = {
-            scope: [:kind],
-            terminator: default_terminator
-          }.merge!(config)
-          @chain = []
-          @callbacks = nil
-          @mutex = Mutex.new
-        end
-
-        def each(&block); @chain.each(&block); end
-        def index(o);     @chain.index(o); end
-        def empty?;       @chain.empty?; end
-
-        def insert(index, o)
-          @callbacks = nil
-          @chain.insert(index, o)
-        end
-
-        def delete(o)
-          @callbacks = nil
-          @chain.delete(o)
-        end
-
-        def clear
-          @callbacks = nil
-          @chain.clear
-          self
-        end
-
-        def initialize_copy(other)
-          @callbacks = nil
-          @chain     = other.chain.dup
-          @mutex     = Mutex.new
-        end
-
-        def compile
-          @callbacks || @mutex.synchronize do
-            final_sequence = CallbackSequence.new
-            @callbacks ||= @chain.reverse.inject(final_sequence) do |callback_sequence, callback|
-              callback.apply callback_sequence
-            end
-          end
-        end
-
-        def append(*callbacks)
-          callbacks.each { |c| append_one(c) }
-        end
-
-        def prepend(*callbacks)
-          callbacks.each { |c| prepend_one(c) }
-        end
-
-        protected
-          attr_reader :chain
-
-        private
-          def append_one(callback)
-            @callbacks = nil
-            remove_duplicates(callback)
-            @chain.push(callback)
-          end
-
-          def prepend_one(callback)
-            @callbacks = nil
-            remove_duplicates(callback)
-            @chain.unshift(callback)
-          end
-
-          def remove_duplicates(callback)
-            @callbacks = nil
-            @chain.delete_if { |c| callback.duplicates?(c) }
-          end
-
-          def default_terminator
-            Proc.new do |target, result_lambda|
-              terminate = true
-              catch(:abort) do
-                result_lambda.call
-                terminate = false
-              end
-              terminate
-            end
-          end
-      end
-
-      module ClassMethods
-        def normalize_callback_params(filters, block) # :nodoc:
-          type = CALLBACK_FILTER_TYPES.include?(filters.first) ? filters.shift : :before
-          options = filters.extract_options!
-          filters.unshift(block) if block
-          [type, filters, options.dup]
-        end
-
-        # This is used internally to append, prepend and skip callbacks to the
-        # CallbackChain.
-        def __update_callbacks(name) #:nodoc:
-          ([self] + ActiveSupport::DescendantsTracker.descendants(self)).reverse_each do |target|
-            chain = target.get_callbacks name
-            yield target, chain.dup
-          end
-        end
-
-        # Install a callback for the given event.
-        #
-        #   set_callback :save, :before, :before_method
-        #   set_callback :save, :after,  :after_method, if: :condition
-        #   set_callback :save, :around, ->(r, block) { stuff; result = block.call; stuff }
-        #
-        # The second argument indicates whether the callback is to be run +:before+,
-        # +:after+, or +:around+ the event. If omitted, +:before+ is assumed. This
-        # means the first example above can also be written as:
-        #
-        #   set_callback :save, :before_method
-        #
-        # The callback can be specified as a symbol naming an instance method; as a
-        # proc, lambda, or block; or as an object that responds to a certain method
-        # determined by the <tt>:scope</tt> argument to +define_callbacks+.
-        #
-        # If a proc, lambda, or block is given, its body is evaluated in the context
-        # of the current object. It can also optionally accept the current object as
-        # an argument.
-        #
-        # Before and around callbacks are called in the order that they are set;
-        # after callbacks are called in the reverse order.
-        #
-        # Around callbacks can access the return value from the event, if it
-        # wasn't halted, from the +yield+ call.
-        #
-        # ===== Options
-        #
-        # * <tt>:if</tt> - A symbol or an array of symbols, each naming an instance
-        #   method or a proc; the callback will be called only when they all return
-        #   a true value.
-        #
-        #   If a proc is given, its body is evaluated in the context of the
-        #   current object. It can also optionally accept the current object as
-        #   an argument.
-        # * <tt>:unless</tt> - A symbol or an array of symbols, each naming an
-        #   instance method or a proc; the callback will be called only when they
-        #   all return a false value.
-        #
-        #   If a proc is given, its body is evaluated in the context of the
-        #   current object. It can also optionally accept the current object as
-        #   an argument.
-        # * <tt>:prepend</tt> - If +true+, the callback will be prepended to the
-        #   existing chain rather than appended.
-        def set_callback(name, *filter_list, &block)
-          type, filters, options = normalize_callback_params(filter_list, block)
-
-          self_chain = get_callbacks name
-          mapped = filters.map do |filter|
-            Callback.build(self_chain, filter, type, options)
-          end
-
-          __update_callbacks(name) do |target, chain|
-            options[:prepend] ? chain.prepend(*mapped) : chain.append(*mapped)
-            target.set_callbacks name, chain
-          end
-        end
-
-        # Skip a previously set callback. Like +set_callback+, <tt>:if</tt> or
-        # <tt>:unless</tt> options may be passed in order to control when the
-        # callback is skipped.
-        #
-        #   class Writer < Person
-        #      skip_callback :validate, :before, :check_membership, if: -> { age > 18 }
-        #   end
-        #
-        # An <tt>ArgumentError</tt> will be raised if the callback has not
-        # already been set (unless the <tt>:raise</tt> option is set to <tt>false</tt>).
-        def skip_callback(name, *filter_list, &block)
-          type, filters, options = normalize_callback_params(filter_list, block)
-
-          options[:raise] = true unless options.key?(:raise)
-
-          __update_callbacks(name) do |target, chain|
-            filters.each do |filter|
-              callback = chain.find { |c| c.matches?(type, filter) }
-
-              if !callback && options[:raise]
-                raise ArgumentError, "#{type.to_s.capitalize} #{name} callback #{filter.inspect} has not been defined"
-              end
-
-              if callback && (options.key?(:if) || options.key?(:unless))
-                new_callback = callback.merge_conditional_options(chain, if_option: options[:if], unless_option: options[:unless])
-                chain.insert(chain.index(callback), new_callback)
-              end
-
-              chain.delete(callback)
-            end
-            target.set_callbacks name, chain
-          end
-        end
-
-        # Remove all set callbacks for the given event.
-        def reset_callbacks(name)
-          callbacks = get_callbacks name
-
-          ActiveSupport::DescendantsTracker.descendants(self).each do |target|
-            chain = target.get_callbacks(name).dup
-            callbacks.each { |c| chain.delete(c) }
-            target.set_callbacks name, chain
-          end
-
-          set_callbacks(name, callbacks.dup.clear)
-        end
-
-        # Define sets of events in the object life cycle that support callbacks.
-        #
-        #   define_callbacks :validate
-        #   define_callbacks :initialize, :save, :destroy
-        #
-        # ===== Options
-        #
-        # * <tt>:terminator</tt> - Determines when a before filter will halt the
-        #   callback chain, preventing following before and around callbacks from
-        #   being called and the event from being triggered.
-        #   This should be a lambda to be executed.
-        #   The current object and the result lambda of the callback will be provided
-        #   to the terminator lambda.
-        #
-        #     define_callbacks :validate, terminator: ->(target, result_lambda) { result_lambda.call == false }
-        #
-        #   In this example, if any before validate callbacks returns +false+,
-        #   any successive before and around callback is not executed.
-        #
-        #   The default terminator halts the chain when a callback throws +:abort+.
-        #
-        # * <tt>:skip_after_callbacks_if_terminated</tt> - Determines if after
-        #   callbacks should be terminated by the <tt>:terminator</tt> option. By
-        #   default after callbacks are executed no matter if callback chain was
-        #   terminated or not. This option has no effect if <tt>:terminator</tt>
-        #   option is set to +nil+.
-        #
-        # * <tt>:scope</tt> - Indicates which methods should be executed when an
-        #   object is used as a callback.
-        #
-        #     class Audit
-        #       def before(caller)
-        #         puts 'Audit: before is called'
-        #       end
-        #
-        #       def before_save(caller)
-        #         puts 'Audit: before_save is called'
-        #       end
-        #     end
-        #
-        #     class Account
-        #       include ActiveSupport::Callbacks
-        #
-        #       define_callbacks :save
-        #       set_callback :save, :before, Audit.new
-        #
-        #       def save
-        #         run_callbacks :save do
-        #           puts 'save in main'
-        #         end
-        #       end
-        #     end
-        #
-        #   In the above case whenever you save an account the method
-        #   <tt>Audit#before</tt> will be called. On the other hand
-        #
-        #     define_callbacks :save, scope: [:kind, :name]
-        #
-        #   would trigger <tt>Audit#before_save</tt> instead. That's constructed
-        #   by calling <tt>#{kind}_#{name}</tt> on the given instance. In this
-        #   case "kind" is "before" and "name" is "save". In this context +:kind+
-        #   and +:name+ have special meanings: +:kind+ refers to the kind of
-        #   callback (before/after/around) and +:name+ refers to the method on
-        #   which callbacks are being defined.
-        #
-        #   A declaration like
-        #
-        #     define_callbacks :save, scope: [:name]
-        #
-        #   would call <tt>Audit#save</tt>.
-        #
-        # ===== Notes
-        #
-        # +names+ passed to +define_callbacks+ must not end with
-        # <tt>!</tt>, <tt>?</tt> or <tt>=</tt>.
-        #
-        # Calling +define_callbacks+ multiple times with the same +names+ will
-        # overwrite previous callbacks registered with +set_callback+.
-        def define_callbacks(*names)
-          options = names.extract_options!
-
-          names.each do |name|
-            name = name.to_sym
-
-            ([self] + ActiveSupport::DescendantsTracker.descendants(self)).each do |target|
-              target.set_callbacks name, CallbackChain.new(name, options)
-            end
-
-            module_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def _run_#{name}_callbacks(&block)
-                run_callbacks #{name.inspect}, &block
-              end
-
-              def self._#{name}_callbacks
-                get_callbacks(#{name.inspect})
-              end
-
-              def self._#{name}_callbacks=(value)
-                set_callbacks(#{name.inspect}, value)
-              end
-
-              def _#{name}_callbacks
-                __callbacks[#{name.inspect}]
-              end
-            RUBY
-          end
-        end
-
-        protected
-          def get_callbacks(name) # :nodoc:
-            __callbacks[name.to_sym]
-          end
-
-          if Module.instance_method(:method_defined?).arity == 1 # Ruby 2.5 and older
-            def set_callbacks(name, callbacks) # :nodoc:
-              self.__callbacks = __callbacks.merge(name.to_sym => callbacks)
-            end
-          else # Ruby 2.6 and newer
-            def set_callbacks(name, callbacks) # :nodoc:
-              unless singleton_class.method_defined?(:__callbacks, false)
-                self.__callbacks = __callbacks.dup
-              end
-              self.__callbacks[name.to_sym] = callbacks
-              self.__callbacks
-            end
-          end
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/concern.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/concern.rb
deleted file mode 100644
index e88862bfb4a78..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/concern.rb
+++ /dev/null
@@ -1,215 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  # A typical module looks like this:
-  #
-  #   module M
-  #     def self.included(base)
-  #       base.extend ClassMethods
-  #       base.class_eval do
-  #         scope :disabled, -> { where(disabled: true) }
-  #       end
-  #     end
-  #
-  #     module ClassMethods
-  #       ...
-  #     end
-  #   end
-  #
-  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
-  # written as:
-  #
-  #   require "active_support/concern"
-  #
-  #   module M
-  #     extend ActiveSupport::Concern
-  #
-  #     included do
-  #       scope :disabled, -> { where(disabled: true) }
-  #     end
-  #
-  #     class_methods do
-  #       ...
-  #     end
-  #   end
-  #
-  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module
-  # and a +Bar+ module which depends on the former, we would typically write the
-  # following:
-  #
-  #   module Foo
-  #     def self.included(base)
-  #       base.class_eval do
-  #         def self.method_injected_by_foo
-  #           ...
-  #         end
-  #       end
-  #     end
-  #   end
-  #
-  #   module Bar
-  #     def self.included(base)
-  #       base.method_injected_by_foo
-  #     end
-  #   end
-  #
-  #   class Host
-  #     include Foo # We need to include this dependency for Bar
-  #     include Bar # Bar is the module that Host really needs
-  #   end
-  #
-  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We
-  # could try to hide these from +Host+ directly including +Foo+ in +Bar+:
-  #
-  #   module Bar
-  #     include Foo
-  #     def self.included(base)
-  #       base.method_injected_by_foo
-  #     end
-  #   end
-  #
-  #   class Host
-  #     include Bar
-  #   end
-  #
-  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
-  # is the +Bar+ module, not the +Host+ class. With <tt>ActiveSupport::Concern</tt>,
-  # module dependencies are properly resolved:
-  #
-  #   require "active_support/concern"
-  #
-  #   module Foo
-  #     extend ActiveSupport::Concern
-  #     included do
-  #       def self.method_injected_by_foo
-  #         ...
-  #       end
-  #     end
-  #   end
-  #
-  #   module Bar
-  #     extend ActiveSupport::Concern
-  #     include Foo
-  #
-  #     included do
-  #       self.method_injected_by_foo
-  #     end
-  #   end
-  #
-  #   class Host
-  #     include Bar # It works, now Bar takes care of its dependencies
-  #   end
-  #
-  # === Prepending concerns
-  #
-  # Just like <tt>include</tt>, concerns also support <tt>prepend</tt> with a corresponding
-  # <tt>prepended do</tt> callback. <tt>module ClassMethods</tt> or <tt>class_methods do</tt> are
-  # prepended as well.
-  #
-  # <tt>prepend</tt> is also used for any dependencies.
-  module Concern
-    class MultipleIncludedBlocks < StandardError #:nodoc:
-      def initialize
-        super "Cannot define multiple 'included' blocks for a Concern"
-      end
-    end
-
-    class MultiplePrependBlocks < StandardError #:nodoc:
-      def initialize
-        super "Cannot define multiple 'prepended' blocks for a Concern"
-      end
-    end
-
-    def self.extended(base) #:nodoc:
-      base.instance_variable_set(:@_dependencies, [])
-    end
-
-    def append_features(base) #:nodoc:
-      if base.instance_variable_defined?(:@_dependencies)
-        base.instance_variable_get(:@_dependencies) << self
-        false
-      else
-        return false if base < self
-        @_dependencies.each { |dep| base.include(dep) }
-        super
-        base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
-        base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
-      end
-    end
-
-    def prepend_features(base) #:nodoc:
-      if base.instance_variable_defined?(:@_dependencies)
-        base.instance_variable_get(:@_dependencies).unshift self
-        false
-      else
-        return false if base < self
-        @_dependencies.each { |dep| base.prepend(dep) }
-        super
-        base.singleton_class.prepend const_get(:ClassMethods) if const_defined?(:ClassMethods)
-        base.class_eval(&@_prepended_block) if instance_variable_defined?(:@_prepended_block)
-      end
-    end
-
-    # Evaluate given block in context of base class,
-    # so that you can write class macros here.
-    # When you define more than one +included+ block, it raises an exception.
-    def included(base = nil, &block)
-      if base.nil?
-        if instance_variable_defined?(:@_included_block)
-          if @_included_block.source_location != block.source_location
-            raise MultipleIncludedBlocks
-          end
-        else
-          @_included_block = block
-        end
-      else
-        super
-      end
-    end
-
-    # Evaluate given block in context of base class,
-    # so that you can write class macros here.
-    # When you define more than one +prepended+ block, it raises an exception.
-    def prepended(base = nil, &block)
-      if base.nil?
-        if instance_variable_defined?(:@_prepended_block)
-          if @_prepended_block.source_location != block.source_location
-            raise MultiplePrependBlocks
-          end
-        else
-          @_prepended_block = block
-        end
-      else
-        super
-      end
-    end
-
-    # Define class methods from given block.
-    # You can define private class methods as well.
-    #
-    #   module Example
-    #     extend ActiveSupport::Concern
-    #
-    #     class_methods do
-    #       def foo; puts 'foo'; end
-    #
-    #       private
-    #         def bar; puts 'bar'; end
-    #     end
-    #   end
-    #
-    #   class Buzz
-    #     include Example
-    #   end
-    #
-    #   Buzz.foo # => "foo"
-    #   Buzz.bar # => private method 'bar' called for Buzz:Class(NoMethodError)
-    def class_methods(&class_methods_module_definition)
-      mod = const_defined?(:ClassMethods, false) ?
-        const_get(:ClassMethods) :
-        const_set(:ClassMethods, Module.new)
-
-      mod.module_eval(&class_methods_module_definition)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/configurable.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/configurable.rb
deleted file mode 100644
index 92bd411df596b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/configurable.rb
+++ /dev/null
@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-require "active_support/ordered_options"
-
-module ActiveSupport
-  # Configurable provides a <tt>config</tt> method to store and retrieve
-  # configuration options as an <tt>OrderedOptions</tt>.
-  module Configurable
-    extend ActiveSupport::Concern
-
-    class Configuration < ActiveSupport::InheritableOptions
-      def compile_methods!
-        self.class.compile_methods!(keys)
-      end
-
-      # Compiles reader methods so we don't have to go through method_missing.
-      def self.compile_methods!(keys)
-        keys.reject { |m| method_defined?(m) }.each do |key|
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{key}; _get(#{key.inspect}); end
-          RUBY
-        end
-      end
-    end
-
-    module ClassMethods
-      def config
-        @_config ||= if respond_to?(:superclass) && superclass.respond_to?(:config)
-          superclass.config.inheritable_copy
-        else
-          # create a new "anonymous" class that will host the compiled reader methods
-          Class.new(Configuration).new
-        end
-      end
-
-      def configure
-        yield config
-      end
-
-      # Allows you to add shortcut so that you don't have to refer to attribute
-      # through config. Also look at the example for config to contrast.
-      #
-      # Defines both class and instance config accessors.
-      #
-      #   class User
-      #     include ActiveSupport::Configurable
-      #     config_accessor :allowed_access
-      #   end
-      #
-      #   User.allowed_access # => nil
-      #   User.allowed_access = false
-      #   User.allowed_access # => false
-      #
-      #   user = User.new
-      #   user.allowed_access # => false
-      #   user.allowed_access = true
-      #   user.allowed_access # => true
-      #
-      #   User.allowed_access # => false
-      #
-      # The attribute name must be a valid method name in Ruby.
-      #
-      #   class User
-      #     include ActiveSupport::Configurable
-      #     config_accessor :"1_Badname"
-      #   end
-      #   # => NameError: invalid config attribute name
-      #
-      # To omit the instance writer method, pass <tt>instance_writer: false</tt>.
-      # To omit the instance reader method, pass <tt>instance_reader: false</tt>.
-      #
-      #   class User
-      #     include ActiveSupport::Configurable
-      #     config_accessor :allowed_access, instance_reader: false, instance_writer: false
-      #   end
-      #
-      #   User.allowed_access = false
-      #   User.allowed_access # => false
-      #
-      #   User.new.allowed_access = true # => NoMethodError
-      #   User.new.allowed_access        # => NoMethodError
-      #
-      # Or pass <tt>instance_accessor: false</tt>, to omit both instance methods.
-      #
-      #   class User
-      #     include ActiveSupport::Configurable
-      #     config_accessor :allowed_access, instance_accessor: false
-      #   end
-      #
-      #   User.allowed_access = false
-      #   User.allowed_access # => false
-      #
-      #   User.new.allowed_access = true # => NoMethodError
-      #   User.new.allowed_access        # => NoMethodError
-      #
-      # Also you can pass a block to set up the attribute with a default value.
-      #
-      #   class User
-      #     include ActiveSupport::Configurable
-      #     config_accessor :hair_colors do
-      #       [:brown, :black, :blonde, :red]
-      #     end
-      #   end
-      #
-      #   User.hair_colors # => [:brown, :black, :blonde, :red]
-      def config_accessor(*names, instance_reader: true, instance_writer: true, instance_accessor: true) # :doc:
-        names.each do |name|
-          raise NameError.new("invalid config attribute name") unless /\A[_A-Za-z]\w*\z/.match?(name)
-
-          reader, reader_line = "def #{name}; config.#{name}; end", __LINE__
-          writer, writer_line = "def #{name}=(value); config.#{name} = value; end", __LINE__
-
-          singleton_class.class_eval reader, __FILE__, reader_line
-          singleton_class.class_eval writer, __FILE__, writer_line
-
-          if instance_accessor
-            class_eval reader, __FILE__, reader_line if instance_reader
-            class_eval writer, __FILE__, writer_line if instance_writer
-          end
-          send("#{name}=", yield) if block_given?
-        end
-      end
-      private :config_accessor
-    end
-
-    # Reads and writes attributes from a configuration <tt>OrderedOptions</tt>.
-    #
-    #   require "active_support/configurable"
-    #
-    #   class User
-    #     include ActiveSupport::Configurable
-    #   end
-    #
-    #   user = User.new
-    #
-    #   user.config.allowed_access = true
-    #   user.config.level = 1
-    #
-    #   user.config.allowed_access # => true
-    #   user.config.level          # => 1
-    def config
-      @_config ||= self.class.config.inheritable_copy
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/configuration_file.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/configuration_file.rb
deleted file mode 100644
index 024f0e0bda273..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/configuration_file.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  # Reads a YAML configuration file, evaluating any ERB, then
-  # parsing the resulting YAML.
-  #
-  # Warns in case of YAML confusing characters, like invisible
-  # non-breaking spaces.
-  class ConfigurationFile # :nodoc:
-    class FormatError < StandardError; end
-
-    def initialize(content_path)
-      @content_path = content_path.to_s
-      @content = read content_path
-    end
-
-    def self.parse(content_path, **options)
-      new(content_path).parse(**options)
-    end
-
-    def parse(context: nil, **options)
-      source = render(context)
-      if YAML.respond_to?(:unsafe_load)
-        YAML.unsafe_load(source, **options) || {}
-      else
-        YAML.load(source, **options) || {}
-      end
-    rescue Psych::SyntaxError => error
-      raise "YAML syntax error occurred while parsing #{@content_path}. " \
-            "Please note that YAML must be consistently indented using spaces. Tabs are not allowed. " \
-            "Error: #{error.message}"
-    end
-
-    private
-      def read(content_path)
-        require "yaml"
-        require "erb"
-
-        File.read(content_path).tap do |content|
-          if content.include?("\u00A0")
-            warn "File contains invisible non-breaking spaces, you may want to remove those"
-          end
-        end
-      end
-
-      def render(context)
-        erb = ERB.new(@content).tap { |e| e.filename = @content_path }
-        context ? erb.result(context) : erb.result
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext.rb
deleted file mode 100644
index 3f5d08186e28a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).sort.each do |path|
-  require path
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array.rb
deleted file mode 100644
index 88b6567712379..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/array/wrap"
-require "active_support/core_ext/array/access"
-require "active_support/core_ext/array/conversions"
-require "active_support/core_ext/array/extract"
-require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/array/grouping"
-require "active_support/core_ext/array/inquiry"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/access.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/access.rb
deleted file mode 100644
index ea01e5891c397..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/access.rb
+++ /dev/null
@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-class Array
-  # Returns the tail of the array from +position+.
-  #
-  #   %w( a b c d ).from(0)  # => ["a", "b", "c", "d"]
-  #   %w( a b c d ).from(2)  # => ["c", "d"]
-  #   %w( a b c d ).from(10) # => []
-  #   %w().from(0)           # => []
-  #   %w( a b c d ).from(-2) # => ["c", "d"]
-  #   %w( a b c ).from(-10)  # => []
-  def from(position)
-    self[position, length] || []
-  end
-
-  # Returns the beginning of the array up to +position+.
-  #
-  #   %w( a b c d ).to(0)  # => ["a"]
-  #   %w( a b c d ).to(2)  # => ["a", "b", "c"]
-  #   %w( a b c d ).to(10) # => ["a", "b", "c", "d"]
-  #   %w().to(0)           # => []
-  #   %w( a b c d ).to(-2) # => ["a", "b", "c"]
-  #   %w( a b c ).to(-10)  # => []
-  def to(position)
-    if position >= 0
-      take position + 1
-    else
-      self[0..position]
-    end
-  end
-
-  # Returns a new array that includes the passed elements.
-  #
-  #   [ 1, 2, 3 ].including(4, 5) # => [ 1, 2, 3, 4, 5 ]
-  #   [ [ 0, 1 ] ].including([ [ 1, 0 ] ]) # => [ [ 0, 1 ], [ 1, 0 ] ]
-  def including(*elements)
-    self + elements.flatten(1)
-  end
-
-  # Returns a copy of the Array excluding the specified elements.
-  #
-  #   ["David", "Rafael", "Aaron", "Todd"].excluding("Aaron", "Todd") # => ["David", "Rafael"]
-  #   [ [ 0, 1 ], [ 1, 0 ] ].excluding([ [ 1, 0 ] ]) # => [ [ 0, 1 ] ]
-  #
-  # Note: This is an optimization of <tt>Enumerable#excluding</tt> that uses <tt>Array#-</tt>
-  # instead of <tt>Array#reject</tt> for performance reasons.
-  def excluding(*elements)
-    self - elements.flatten(1)
-  end
-
-  # Alias for #excluding.
-  def without(*elements)
-    excluding(*elements)
-  end
-
-  # Equal to <tt>self[1]</tt>.
-  #
-  #   %w( a b c d e ).second # => "b"
-  def second
-    self[1]
-  end
-
-  # Equal to <tt>self[2]</tt>.
-  #
-  #   %w( a b c d e ).third # => "c"
-  def third
-    self[2]
-  end
-
-  # Equal to <tt>self[3]</tt>.
-  #
-  #   %w( a b c d e ).fourth # => "d"
-  def fourth
-    self[3]
-  end
-
-  # Equal to <tt>self[4]</tt>.
-  #
-  #   %w( a b c d e ).fifth # => "e"
-  def fifth
-    self[4]
-  end
-
-  # Equal to <tt>self[41]</tt>. Also known as accessing "the reddit".
-  #
-  #   (1..42).to_a.forty_two # => 42
-  def forty_two
-    self[41]
-  end
-
-  # Equal to <tt>self[-3]</tt>.
-  #
-  #   %w( a b c d e ).third_to_last # => "c"
-  def third_to_last
-    self[-3]
-  end
-
-  # Equal to <tt>self[-2]</tt>.
-  #
-  #   %w( a b c d e ).second_to_last # => "d"
-  def second_to_last
-    self[-2]
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/conversions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/conversions.rb
deleted file mode 100644
index 0780c4ed8aab1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/conversions.rb
+++ /dev/null
@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/xml_mini"
-require "active_support/core_ext/hash/keys"
-require "active_support/core_ext/string/inflections"
-require "active_support/core_ext/object/to_param"
-require "active_support/core_ext/object/to_query"
-
-class Array
-  # Converts the array to a comma-separated sentence where the last element is
-  # joined by the connector word.
-  #
-  # You can pass the following options to change the default behavior. If you
-  # pass an option key that doesn't exist in the list below, it will raise an
-  # <tt>ArgumentError</tt>.
-  #
-  # ==== Options
-  #
-  # * <tt>:words_connector</tt> - The sign or word used to join the elements
-  #   in arrays with two or more elements (default: ", ").
-  # * <tt>:two_words_connector</tt> - The sign or word used to join the elements
-  #   in arrays with two elements (default: " and ").
-  # * <tt>:last_word_connector</tt> - The sign or word used to join the last element
-  #   in arrays with three or more elements (default: ", and ").
-  # * <tt>:locale</tt> - If +i18n+ is available, you can set a locale and use
-  #   the connector options defined on the 'support.array' namespace in the
-  #   corresponding dictionary file.
-  #
-  # ==== Examples
-  #
-  #   [].to_sentence                      # => ""
-  #   ['one'].to_sentence                 # => "one"
-  #   ['one', 'two'].to_sentence          # => "one and two"
-  #   ['one', 'two', 'three'].to_sentence # => "one, two, and three"
-  #
-  #   ['one', 'two'].to_sentence(passing: 'invalid option')
-  #   # => ArgumentError: Unknown key: :passing. Valid keys are: :words_connector, :two_words_connector, :last_word_connector, :locale
-  #
-  #   ['one', 'two'].to_sentence(two_words_connector: '-')
-  #   # => "one-two"
-  #
-  #   ['one', 'two', 'three'].to_sentence(words_connector: ' or ', last_word_connector: ' or at least ')
-  #   # => "one or two or at least three"
-  #
-  # Using <tt>:locale</tt> option:
-  #
-  #   # Given this locale dictionary:
-  #   #
-  #   #   es:
-  #   #     support:
-  #   #       array:
-  #   #         words_connector: " o "
-  #   #         two_words_connector: " y "
-  #   #         last_word_connector: " o al menos "
-  #
-  #   ['uno', 'dos'].to_sentence(locale: :es)
-  #   # => "uno y dos"
-  #
-  #   ['uno', 'dos', 'tres'].to_sentence(locale: :es)
-  #   # => "uno o dos o al menos tres"
-  def to_sentence(options = {})
-    options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
-
-    default_connectors = {
-      words_connector: ", ",
-      two_words_connector: " and ",
-      last_word_connector: ", and "
-    }
-    if defined?(I18n)
-      i18n_connectors = I18n.translate(:'support.array', locale: options[:locale], default: {})
-      default_connectors.merge!(i18n_connectors)
-    end
-    options = default_connectors.merge!(options)
-
-    case length
-    when 0
-      +""
-    when 1
-      +"#{self[0]}"
-    when 2
-      +"#{self[0]}#{options[:two_words_connector]}#{self[1]}"
-    else
-      +"#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
-    end
-  end
-
-  # Extends <tt>Array#to_s</tt> to convert a collection of elements into a
-  # comma separated id list if <tt>:db</tt> argument is given as the format.
-  #
-  #   Blog.all.to_formatted_s(:db)  # => "1,2,3"
-  #   Blog.none.to_formatted_s(:db) # => "null"
-  #   [1,2].to_formatted_s          # => "[1, 2]"
-  def to_formatted_s(format = :default)
-    case format
-    when :db
-      if empty?
-        "null"
-      else
-        collect(&:id).join(",")
-      end
-    else
-      to_default_s
-    end
-  end
-  alias_method :to_default_s, :to_s
-  alias_method :to_s, :to_formatted_s
-
-  # Returns a string that represents the array in XML by invoking +to_xml+
-  # on each element. Active Record collections delegate their representation
-  # in XML to this method.
-  #
-  # All elements are expected to respond to +to_xml+, if any of them does
-  # not then an exception is raised.
-  #
-  # The root node reflects the class name of the first element in plural
-  # if all elements belong to the same type and that's not Hash:
-  #
-  #   customer.projects.to_xml
-  #
-  #   <?xml version="1.0" encoding="UTF-8"?>
-  #   <projects type="array">
-  #     <project>
-  #       <amount type="decimal">20000.0</amount>
-  #       <customer-id type="integer">1567</customer-id>
-  #       <deal-date type="date">2008-04-09</deal-date>
-  #       ...
-  #     </project>
-  #     <project>
-  #       <amount type="decimal">57230.0</amount>
-  #       <customer-id type="integer">1567</customer-id>
-  #       <deal-date type="date">2008-04-15</deal-date>
-  #       ...
-  #     </project>
-  #   </projects>
-  #
-  # Otherwise the root element is "objects":
-  #
-  #   [{ foo: 1, bar: 2}, { baz: 3}].to_xml
-  #
-  #   <?xml version="1.0" encoding="UTF-8"?>
-  #   <objects type="array">
-  #     <object>
-  #       <bar type="integer">2</bar>
-  #       <foo type="integer">1</foo>
-  #     </object>
-  #     <object>
-  #       <baz type="integer">3</baz>
-  #     </object>
-  #   </objects>
-  #
-  # If the collection is empty the root element is "nil-classes" by default:
-  #
-  #   [].to_xml
-  #
-  #   <?xml version="1.0" encoding="UTF-8"?>
-  #   <nil-classes type="array"/>
-  #
-  # To ensure a meaningful root element use the <tt>:root</tt> option:
-  #
-  #   customer_with_no_projects.projects.to_xml(root: 'projects')
-  #
-  #   <?xml version="1.0" encoding="UTF-8"?>
-  #   <projects type="array"/>
-  #
-  # By default name of the node for the children of root is <tt>root.singularize</tt>.
-  # You can change it with the <tt>:children</tt> option.
-  #
-  # The +options+ hash is passed downwards:
-  #
-  #   Message.all.to_xml(skip_types: true)
-  #
-  #   <?xml version="1.0" encoding="UTF-8"?>
-  #   <messages>
-  #     <message>
-  #       <created-at>2008-03-07T09:58:18+01:00</created-at>
-  #       <id>1</id>
-  #       <name>1</name>
-  #       <updated-at>2008-03-07T09:58:18+01:00</updated-at>
-  #       <user-id>1</user-id>
-  #     </message>
-  #   </messages>
-  #
-  def to_xml(options = {})
-    require "active_support/builder" unless defined?(Builder::XmlMarkup)
-
-    options = options.dup
-    options[:indent]  ||= 2
-    options[:builder] ||= Builder::XmlMarkup.new(indent: options[:indent])
-    options[:root]    ||= \
-      if first.class != Hash && all? { |e| e.is_a?(first.class) }
-        underscored = ActiveSupport::Inflector.underscore(first.class.name)
-        ActiveSupport::Inflector.pluralize(underscored).tr("/", "_")
-      else
-        "objects"
-      end
-
-    builder = options[:builder]
-    builder.instruct! unless options.delete(:skip_instruct)
-
-    root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
-    children = options.delete(:children) || root.singularize
-    attributes = options[:skip_types] ? {} : { type: "array" }
-
-    if empty?
-      builder.tag!(root, attributes)
-    else
-      builder.tag!(root, attributes) do
-        each { |value| ActiveSupport::XmlMini.to_tag(children, value, options) }
-        yield builder if block_given?
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/extract.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/extract.rb
deleted file mode 100644
index cc5a8a3f88e55..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/extract.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-class Array
-  # Removes and returns the elements for which the block returns a true value.
-  # If no block is given, an Enumerator is returned instead.
-  #
-  #   numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-  #   odd_numbers = numbers.extract! { |number| number.odd? } # => [1, 3, 5, 7, 9]
-  #   numbers # => [0, 2, 4, 6, 8]
-  def extract!
-    return to_enum(:extract!) { size } unless block_given?
-
-    extracted_elements = []
-
-    reject! do |element|
-      extracted_elements << element if yield(element)
-    end
-
-    extracted_elements
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/extract_options.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/extract_options.rb
deleted file mode 100644
index 8c7cb2e780476..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/extract_options.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-class Hash
-  # By default, only instances of Hash itself are extractable.
-  # Subclasses of Hash may implement this method and return
-  # true to declare themselves as extractable. If a Hash
-  # is extractable, Array#extract_options! pops it from
-  # the Array when it is the last element of the Array.
-  def extractable_options?
-    instance_of?(Hash)
-  end
-end
-
-class Array
-  # Extracts options from a set of arguments. Removes and returns the last
-  # element in the array if it's a hash, otherwise returns a blank hash.
-  #
-  #   def options(*args)
-  #     args.extract_options!
-  #   end
-  #
-  #   options(1, 2)        # => {}
-  #   options(1, 2, a: :b) # => {:a=>:b}
-  def extract_options!
-    if last.is_a?(Hash) && last.extractable_options?
-      pop
-    else
-      {}
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/grouping.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/grouping.rb
deleted file mode 100644
index 67e760bc4b080..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/grouping.rb
+++ /dev/null
@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-class Array
-  # Splits or iterates over the array in groups of size +number+,
-  # padding any remaining slots with +fill_with+ unless it is +false+.
-  #
-  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups_of(3) {|group| p group}
-  #   ["1", "2", "3"]
-  #   ["4", "5", "6"]
-  #   ["7", "8", "9"]
-  #   ["10", nil, nil]
-  #
-  #   %w(1 2 3 4 5).in_groups_of(2, '&nbsp;') {|group| p group}
-  #   ["1", "2"]
-  #   ["3", "4"]
-  #   ["5", "&nbsp;"]
-  #
-  #   %w(1 2 3 4 5).in_groups_of(2, false) {|group| p group}
-  #   ["1", "2"]
-  #   ["3", "4"]
-  #   ["5"]
-  def in_groups_of(number, fill_with = nil)
-    if number.to_i <= 0
-      raise ArgumentError,
-        "Group size must be a positive integer, was #{number.inspect}"
-    end
-
-    if fill_with == false
-      collection = self
-    else
-      # size % number gives how many extra we have;
-      # subtracting from number gives how many to add;
-      # modulo number ensures we don't add group of just fill.
-      padding = (number - size % number) % number
-      collection = dup.concat(Array.new(padding, fill_with))
-    end
-
-    if block_given?
-      collection.each_slice(number) { |slice| yield(slice) }
-    else
-      collection.each_slice(number).to_a
-    end
-  end
-
-  # Splits or iterates over the array in +number+ of groups, padding any
-  # remaining slots with +fill_with+ unless it is +false+.
-  #
-  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups(3) {|group| p group}
-  #   ["1", "2", "3", "4"]
-  #   ["5", "6", "7", nil]
-  #   ["8", "9", "10", nil]
-  #
-  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups(3, '&nbsp;') {|group| p group}
-  #   ["1", "2", "3", "4"]
-  #   ["5", "6", "7", "&nbsp;"]
-  #   ["8", "9", "10", "&nbsp;"]
-  #
-  #   %w(1 2 3 4 5 6 7).in_groups(3, false) {|group| p group}
-  #   ["1", "2", "3"]
-  #   ["4", "5"]
-  #   ["6", "7"]
-  def in_groups(number, fill_with = nil)
-    # size.div number gives minor group size;
-    # size % number gives how many objects need extra accommodation;
-    # each group hold either division or division + 1 items.
-    division = size.div number
-    modulo = size % number
-
-    # create a new array avoiding dup
-    groups = []
-    start = 0
-
-    number.times do |index|
-      length = division + (modulo > 0 && modulo > index ? 1 : 0)
-      groups << last_group = slice(start, length)
-      last_group << fill_with if fill_with != false &&
-        modulo > 0 && length == division
-      start += length
-    end
-
-    if block_given?
-      groups.each { |g| yield(g) }
-    else
-      groups
-    end
-  end
-
-  # Divides the array into one or more subarrays based on a delimiting +value+
-  # or the result of an optional block.
-  #
-  #   [1, 2, 3, 4, 5].split(3)              # => [[1, 2], [4, 5]]
-  #   (1..10).to_a.split { |i| i % 3 == 0 } # => [[1, 2], [4, 5], [7, 8], [10]]
-  def split(value = nil)
-    arr = dup
-    result = []
-    if block_given?
-      while (idx = arr.index { |i| yield i })
-        result << arr.shift(idx)
-        arr.shift
-      end
-    else
-      while (idx = arr.index(value))
-        result << arr.shift(idx)
-        arr.shift
-      end
-    end
-    result << arr
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/inquiry.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/inquiry.rb
deleted file mode 100644
index 92c61bf201919..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/inquiry.rb
+++ /dev/null
@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/array_inquirer"
-
-class Array
-  # Wraps the array in an +ArrayInquirer+ object, which gives a friendlier way
-  # to check its string-like contents.
-  #
-  #   pets = [:cat, :dog].inquiry
-  #
-  #   pets.cat?     # => true
-  #   pets.ferret?  # => false
-  #
-  #   pets.any?(:cat, :ferret)  # => true
-  #   pets.any?(:ferret, :alligator)  # => false
-  def inquiry
-    ActiveSupport::ArrayInquirer.new(self)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/wrap.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/wrap.rb
deleted file mode 100644
index d62f97edbf00e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/array/wrap.rb
+++ /dev/null
@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-class Array
-  # Wraps its argument in an array unless it is already an array (or array-like).
-  #
-  # Specifically:
-  #
-  # * If the argument is +nil+ an empty array is returned.
-  # * Otherwise, if the argument responds to +to_ary+ it is invoked, and its result returned.
-  # * Otherwise, returns an array with the argument as its single element.
-  #
-  #     Array.wrap(nil)       # => []
-  #     Array.wrap([1, 2, 3]) # => [1, 2, 3]
-  #     Array.wrap(0)         # => [0]
-  #
-  # This method is similar in purpose to <tt>Kernel#Array</tt>, but there are some differences:
-  #
-  # * If the argument responds to +to_ary+ the method is invoked. <tt>Kernel#Array</tt>
-  #   moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
-  #   an array with the argument as its single element right away.
-  # * If the returned value from +to_ary+ is neither +nil+ nor an +Array+ object, <tt>Kernel#Array</tt>
-  #   raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
-  # * It does not call +to_a+ on the argument, if the argument does not respond to +to_ary+
-  #   it returns an array with the argument as its single element.
-  #
-  # The last point is easily explained with some enumerables:
-  #
-  #   Array(foo: :bar)      # => [[:foo, :bar]]
-  #   Array.wrap(foo: :bar) # => [{:foo=>:bar}]
-  #
-  # There's also a related idiom that uses the splat operator:
-  #
-  #   [*object]
-  #
-  # which returns <tt>[]</tt> for +nil+, but calls to <tt>Array(object)</tt> otherwise.
-  #
-  # The differences with <tt>Kernel#Array</tt> explained above
-  # apply to the rest of <tt>object</tt>s.
-  def self.wrap(object)
-    if object.nil?
-      []
-    elsif object.respond_to?(:to_ary)
-      object.to_ary || [object]
-    else
-      [object]
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/benchmark.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/benchmark.rb
deleted file mode 100644
index f6e1b72bcf086..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/benchmark.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "benchmark"
-
-class << Benchmark
-  # Benchmark realtime in milliseconds.
-  #
-  #   Benchmark.realtime { User.all }
-  #   # => 8.0e-05
-  #
-  #   Benchmark.ms { User.all }
-  #   # => 0.074
-  def ms(&block)
-    1000 * realtime(&block)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/big_decimal.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/big_decimal.rb
deleted file mode 100644
index 9e6a9d6331692..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/big_decimal.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/big_decimal/conversions"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/big_decimal/conversions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/big_decimal/conversions.rb
deleted file mode 100644
index 52bd2294166f0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/big_decimal/conversions.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require "bigdecimal"
-require "bigdecimal/util"
-
-module ActiveSupport
-  module BigDecimalWithDefaultFormat #:nodoc:
-    def to_s(format = "F")
-      super(format)
-    end
-  end
-end
-
-BigDecimal.prepend(ActiveSupport::BigDecimalWithDefaultFormat)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/class.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/class.rb
deleted file mode 100644
index 1c110fd07bd5c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/class.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/class/attribute"
-require "active_support/core_ext/class/subclasses"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/class/attribute.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/class/attribute.rb
deleted file mode 100644
index ec78845159f8e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/class/attribute.rb
+++ /dev/null
@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/redefine_method"
-
-class Class
-  # Declare a class-level attribute whose value is inheritable by subclasses.
-  # Subclasses can change their own value and it will not impact parent class.
-  #
-  # ==== Options
-  #
-  # * <tt>:instance_reader</tt> - Sets the instance reader method (defaults to true).
-  # * <tt>:instance_writer</tt> - Sets the instance writer method (defaults to true).
-  # * <tt>:instance_accessor</tt> - Sets both instance methods (defaults to true).
-  # * <tt>:instance_predicate</tt> - Sets a predicate method (defaults to true).
-  # * <tt>:default</tt> - Sets a default value for the attribute (defaults to nil).
-  #
-  # ==== Examples
-  #
-  #   class Base
-  #     class_attribute :setting
-  #   end
-  #
-  #   class Subclass < Base
-  #   end
-  #
-  #   Base.setting = true
-  #   Subclass.setting            # => true
-  #   Subclass.setting = false
-  #   Subclass.setting            # => false
-  #   Base.setting                # => true
-  #
-  # In the above case as long as Subclass does not assign a value to setting
-  # by performing <tt>Subclass.setting = _something_</tt>, <tt>Subclass.setting</tt>
-  # would read value assigned to parent class. Once Subclass assigns a value then
-  # the value assigned by Subclass would be returned.
-  #
-  # This matches normal Ruby method inheritance: think of writing an attribute
-  # on a subclass as overriding the reader method. However, you need to be aware
-  # when using +class_attribute+ with mutable structures as +Array+ or +Hash+.
-  # In such cases, you don't want to do changes in place. Instead use setters:
-  #
-  #   Base.setting = []
-  #   Base.setting                # => []
-  #   Subclass.setting            # => []
-  #
-  #   # Appending in child changes both parent and child because it is the same object:
-  #   Subclass.setting << :foo
-  #   Base.setting               # => [:foo]
-  #   Subclass.setting           # => [:foo]
-  #
-  #   # Use setters to not propagate changes:
-  #   Base.setting = []
-  #   Subclass.setting += [:foo]
-  #   Base.setting               # => []
-  #   Subclass.setting           # => [:foo]
-  #
-  # For convenience, an instance predicate method is defined as well.
-  # To skip it, pass <tt>instance_predicate: false</tt>.
-  #
-  #   Subclass.setting?       # => false
-  #
-  # Instances may overwrite the class value in the same way:
-  #
-  #   Base.setting = true
-  #   object = Base.new
-  #   object.setting          # => true
-  #   object.setting = false
-  #   object.setting          # => false
-  #   Base.setting            # => true
-  #
-  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
-  #
-  #   object.setting          # => NoMethodError
-  #   object.setting?         # => NoMethodError
-  #
-  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
-  #
-  #   object.setting = false  # => NoMethodError
-  #
-  # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
-  #
-  # To set a default value for the attribute, pass <tt>default:</tt>, like so:
-  #
-  #   class_attribute :settings, default: {}
-  def class_attribute(*attrs, instance_accessor: true,
-    instance_reader: instance_accessor, instance_writer: instance_accessor, instance_predicate: true, default: nil)
-
-    class_methods, methods = [], []
-    attrs.each do |name|
-      unless name.is_a?(Symbol) || name.is_a?(String)
-        raise TypeError, "#{name.inspect} is not a symbol nor a string"
-      end
-
-      class_methods << <<~RUBY # In case the method exists and is not public
-        silence_redefinition_of_method def #{name}
-        end
-      RUBY
-
-      methods << <<~RUBY if instance_reader
-        silence_redefinition_of_method def #{name}
-          defined?(@#{name}) ? @#{name} : self.class.#{name}
-        end
-      RUBY
-
-      class_methods << <<~RUBY
-        silence_redefinition_of_method def #{name}=(value)
-          redefine_method(:#{name}) { value } if singleton_class?
-          redefine_singleton_method(:#{name}) { value }
-          value
-        end
-      RUBY
-
-      methods << <<~RUBY if instance_writer
-        silence_redefinition_of_method(:#{name}=)
-        attr_writer :#{name}
-      RUBY
-
-      if instance_predicate
-        class_methods << "silence_redefinition_of_method def #{name}?; !!self.#{name}; end"
-        if instance_reader
-          methods << "silence_redefinition_of_method def #{name}?; !!self.#{name}; end"
-        end
-      end
-    end
-
-    location = caller_locations(1, 1).first
-    class_eval(["class << self", *class_methods, "end", *methods].join(";").tr("\n", ";"), location.path, location.lineno)
-
-    attrs.each { |name| public_send("#{name}=", default) }
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/class/attribute_accessors.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/class/attribute_accessors.rb
deleted file mode 100644
index a77354e1538b7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/class/attribute_accessors.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-# cattr_* became mattr_* aliases in 7dfbd91b0780fbd6a1dd9bfbc176e10894871d2d,
-# but we keep this around for libraries that directly require it knowing they
-# want cattr_*. No need to deprecate.
-require "active_support/core_ext/module/attribute_accessors"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/class/subclasses.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/class/subclasses.rb
deleted file mode 100644
index 568b413516283..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/class/subclasses.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-class Class
-  # Returns an array with all classes that are < than its receiver.
-  #
-  #   class C; end
-  #   C.descendants # => []
-  #
-  #   class B < C; end
-  #   C.descendants # => [B]
-  #
-  #   class A < B; end
-  #   C.descendants # => [B, A]
-  #
-  #   class D < C; end
-  #   C.descendants # => [B, A, D]
-  def descendants
-    ObjectSpace.each_object(singleton_class).reject do |k|
-      k.singleton_class? || k == self
-    end
-  end
-
-  # Returns an array with the direct children of +self+.
-  #
-  #   class Foo; end
-  #   class Bar < Foo; end
-  #   class Baz < Bar; end
-  #
-  #   Foo.subclasses # => [Bar]
-  def subclasses
-    descendants.select { |descendant| descendant.superclass == self }
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date.rb
deleted file mode 100644
index cce73f2db2232..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/date/acts_like"
-require "active_support/core_ext/date/blank"
-require "active_support/core_ext/date/calculations"
-require "active_support/core_ext/date/conversions"
-require "active_support/core_ext/date/zones"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/acts_like.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/acts_like.rb
deleted file mode 100644
index c8077f37747cb..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/acts_like.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/acts_like"
-
-class Date
-  # Duck-types as a Date-like class. See Object#acts_like?.
-  def acts_like_date?
-    true
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/blank.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/blank.rb
deleted file mode 100644
index e6271c79b32b1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/blank.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-
-class Date #:nodoc:
-  # No Date is blank:
-  #
-  #   Date.today.blank? # => false
-  #
-  # @return [false]
-  def blank?
-    false
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/calculations.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/calculations.rb
deleted file mode 100644
index d03a8d3997f2e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/calculations.rb
+++ /dev/null
@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-require "active_support/duration"
-require "active_support/core_ext/object/acts_like"
-require "active_support/core_ext/date/zones"
-require "active_support/core_ext/time/zones"
-require "active_support/core_ext/date_and_time/calculations"
-
-class Date
-  include DateAndTime::Calculations
-
-  class << self
-    attr_accessor :beginning_of_week_default
-
-    # Returns the week start (e.g. :monday) for the current request, if this has been set (via Date.beginning_of_week=).
-    # If <tt>Date.beginning_of_week</tt> has not been set for the current request, returns the week start specified in <tt>config.beginning_of_week</tt>.
-    # If no config.beginning_of_week was specified, returns :monday.
-    def beginning_of_week
-      Thread.current[:beginning_of_week] || beginning_of_week_default || :monday
-    end
-
-    # Sets <tt>Date.beginning_of_week</tt> to a week start (e.g. :monday) for current request/thread.
-    #
-    # This method accepts any of the following day symbols:
-    # :monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday
-    def beginning_of_week=(week_start)
-      Thread.current[:beginning_of_week] = find_beginning_of_week!(week_start)
-    end
-
-    # Returns week start day symbol (e.g. :monday), or raises an +ArgumentError+ for invalid day symbol.
-    def find_beginning_of_week!(week_start)
-      raise ArgumentError, "Invalid beginning of week: #{week_start}" unless ::Date::DAYS_INTO_WEEK.key?(week_start)
-      week_start
-    end
-
-    # Returns a new Date representing the date 1 day ago (i.e. yesterday's date).
-    def yesterday
-      ::Date.current.yesterday
-    end
-
-    # Returns a new Date representing the date 1 day after today (i.e. tomorrow's date).
-    def tomorrow
-      ::Date.current.tomorrow
-    end
-
-    # Returns Time.zone.today when <tt>Time.zone</tt> or <tt>config.time_zone</tt> are set, otherwise just returns Date.today.
-    def current
-      ::Time.zone ? ::Time.zone.today : ::Date.today
-    end
-  end
-
-  # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
-  # and then subtracts the specified number of seconds.
-  def ago(seconds)
-    in_time_zone.since(-seconds)
-  end
-
-  # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
-  # and then adds the specified number of seconds
-  def since(seconds)
-    in_time_zone.since(seconds)
-  end
-  alias :in :since
-
-  # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
-  def beginning_of_day
-    in_time_zone
-  end
-  alias :midnight :beginning_of_day
-  alias :at_midnight :beginning_of_day
-  alias :at_beginning_of_day :beginning_of_day
-
-  # Converts Date to a Time (or DateTime if necessary) with the time portion set to the middle of the day (12:00)
-  def middle_of_day
-    in_time_zone.middle_of_day
-  end
-  alias :midday :middle_of_day
-  alias :noon :middle_of_day
-  alias :at_midday :middle_of_day
-  alias :at_noon :middle_of_day
-  alias :at_middle_of_day :middle_of_day
-
-  # Converts Date to a Time (or DateTime if necessary) with the time portion set to the end of the day (23:59:59)
-  def end_of_day
-    in_time_zone.end_of_day
-  end
-  alias :at_end_of_day :end_of_day
-
-  def plus_with_duration(other) #:nodoc:
-    if ActiveSupport::Duration === other
-      other.since(self)
-    else
-      plus_without_duration(other)
-    end
-  end
-  alias_method :plus_without_duration, :+
-  alias_method :+, :plus_with_duration
-
-  def minus_with_duration(other) #:nodoc:
-    if ActiveSupport::Duration === other
-      plus_with_duration(-other)
-    else
-      minus_without_duration(other)
-    end
-  end
-  alias_method :minus_without_duration, :-
-  alias_method :-, :minus_with_duration
-
-  # Provides precise Date calculations for years, months, and days. The +options+ parameter takes a hash with
-  # any of these keys: <tt>:years</tt>, <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>.
-  def advance(options)
-    d = self
-
-    d = d >> options[:years] * 12 if options[:years]
-    d = d >> options[:months] if options[:months]
-    d = d + options[:weeks] * 7 if options[:weeks]
-    d = d + options[:days] if options[:days]
-
-    d
-  end
-
-  # Returns a new Date where one or more of the elements have been changed according to the +options+ parameter.
-  # The +options+ parameter is a hash with a combination of these keys: <tt>:year</tt>, <tt>:month</tt>, <tt>:day</tt>.
-  #
-  #   Date.new(2007, 5, 12).change(day: 1)               # => Date.new(2007, 5, 1)
-  #   Date.new(2007, 5, 12).change(year: 2005, month: 1) # => Date.new(2005, 1, 12)
-  def change(options)
-    ::Date.new(
-      options.fetch(:year, year),
-      options.fetch(:month, month),
-      options.fetch(:day, day)
-    )
-  end
-
-  # Allow Date to be compared with Time by converting to DateTime and relying on the <=> from there.
-  def compare_with_coercion(other)
-    if other.is_a?(Time)
-      to_datetime <=> other
-    else
-      compare_without_coercion(other)
-    end
-  end
-  alias_method :compare_without_coercion, :<=>
-  alias_method :<=>, :compare_with_coercion
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/conversions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/conversions.rb
deleted file mode 100644
index 050a62bb31298..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/conversions.rb
+++ /dev/null
@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-require "active_support/inflector/methods"
-require "active_support/core_ext/date/zones"
-require "active_support/core_ext/module/redefine_method"
-
-class Date
-  DATE_FORMATS = {
-    short: "%d %b",
-    long: "%B %d, %Y",
-    db: "%Y-%m-%d",
-    inspect: "%Y-%m-%d",
-    number: "%Y%m%d",
-    long_ordinal: lambda { |date|
-      day_format = ActiveSupport::Inflector.ordinalize(date.day)
-      date.strftime("%B #{day_format}, %Y") # => "April 25th, 2007"
-    },
-    rfc822: "%d %b %Y",
-    iso8601: lambda { |date| date.iso8601 }
-  }
-
-  # Convert to a formatted string. See DATE_FORMATS for predefined formats.
-  #
-  # This method is aliased to <tt>to_s</tt>.
-  #
-  #   date = Date.new(2007, 11, 10)       # => Sat, 10 Nov 2007
-  #
-  #   date.to_formatted_s(:db)            # => "2007-11-10"
-  #   date.to_s(:db)                      # => "2007-11-10"
-  #
-  #   date.to_formatted_s(:short)         # => "10 Nov"
-  #   date.to_formatted_s(:number)        # => "20071110"
-  #   date.to_formatted_s(:long)          # => "November 10, 2007"
-  #   date.to_formatted_s(:long_ordinal)  # => "November 10th, 2007"
-  #   date.to_formatted_s(:rfc822)        # => "10 Nov 2007"
-  #   date.to_formatted_s(:iso8601)       # => "2007-11-10"
-  #
-  # == Adding your own date formats to to_formatted_s
-  # You can add your own formats to the Date::DATE_FORMATS hash.
-  # Use the format name as the hash key and either a strftime string
-  # or Proc instance that takes a date argument as the value.
-  #
-  #   # config/initializers/date_formats.rb
-  #   Date::DATE_FORMATS[:month_and_year] = '%B %Y'
-  #   Date::DATE_FORMATS[:short_ordinal] = ->(date) { date.strftime("%B #{date.day.ordinalize}") }
-  def to_formatted_s(format = :default)
-    if formatter = DATE_FORMATS[format]
-      if formatter.respond_to?(:call)
-        formatter.call(self).to_s
-      else
-        strftime(formatter)
-      end
-    else
-      to_default_s
-    end
-  end
-  alias_method :to_default_s, :to_s
-  alias_method :to_s, :to_formatted_s
-
-  # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005"
-  def readable_inspect
-    strftime("%a, %d %b %Y")
-  end
-  alias_method :default_inspect, :inspect
-  alias_method :inspect, :readable_inspect
-
-  silence_redefinition_of_method :to_time
-
-  # Converts a Date instance to a Time, where the time is set to the beginning of the day.
-  # The timezone can be either :local or :utc (default :local).
-  #
-  #   date = Date.new(2007, 11, 10)  # => Sat, 10 Nov 2007
-  #
-  #   date.to_time                   # => 2007-11-10 00:00:00 0800
-  #   date.to_time(:local)           # => 2007-11-10 00:00:00 0800
-  #
-  #   date.to_time(:utc)             # => 2007-11-10 00:00:00 UTC
-  #
-  # NOTE: The :local timezone is Ruby's *process* timezone, i.e. ENV['TZ'].
-  #       If the *application's* timezone is needed, then use +in_time_zone+ instead.
-  def to_time(form = :local)
-    raise ArgumentError, "Expected :local or :utc, got #{form.inspect}." unless [:local, :utc].include?(form)
-    ::Time.public_send(form, year, month, day)
-  end
-
-  silence_redefinition_of_method :xmlschema
-
-  # Returns a string which represents the time in used time zone as DateTime
-  # defined by XML Schema:
-  #
-  #   date = Date.new(2015, 05, 23)  # => Sat, 23 May 2015
-  #   date.xmlschema                 # => "2015-05-23T00:00:00+04:00"
-  def xmlschema
-    in_time_zone.xmlschema
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/zones.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/zones.rb
deleted file mode 100644
index 2dcf97cff80e9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date/zones.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-require "active_support/core_ext/date_and_time/zones"
-
-class Date
-  include DateAndTime::Zones
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_and_time/calculations.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_and_time/calculations.rb
deleted file mode 100644
index 21cfeed557f1d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_and_time/calculations.rb
+++ /dev/null
@@ -1,364 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/try"
-require "active_support/core_ext/date_time/conversions"
-
-module DateAndTime
-  module Calculations
-    DAYS_INTO_WEEK = {
-      sunday: 0,
-      monday: 1,
-      tuesday: 2,
-      wednesday: 3,
-      thursday: 4,
-      friday: 5,
-      saturday: 6
-    }
-    WEEKEND_DAYS = [ 6, 0 ]
-
-    # Returns a new date/time representing yesterday.
-    def yesterday
-      advance(days: -1)
-    end
-
-    # Returns a new date/time representing tomorrow.
-    def tomorrow
-      advance(days: 1)
-    end
-
-    # Returns true if the date/time is today.
-    def today?
-      to_date == ::Date.current
-    end
-
-    # Returns true if the date/time is tomorrow.
-    def tomorrow?
-      to_date == ::Date.current.tomorrow
-    end
-    alias :next_day? :tomorrow?
-
-    # Returns true if the date/time is yesterday.
-    def yesterday?
-      to_date == ::Date.current.yesterday
-    end
-    alias :prev_day? :yesterday?
-
-    # Returns true if the date/time is in the past.
-    def past?
-      self < self.class.current
-    end
-
-    # Returns true if the date/time is in the future.
-    def future?
-      self > self.class.current
-    end
-
-    # Returns true if the date/time falls on a Saturday or Sunday.
-    def on_weekend?
-      WEEKEND_DAYS.include?(wday)
-    end
-
-    # Returns true if the date/time does not fall on a Saturday or Sunday.
-    def on_weekday?
-      !WEEKEND_DAYS.include?(wday)
-    end
-
-    # Returns true if the date/time falls before <tt>date_or_time</tt>.
-    def before?(date_or_time)
-      self < date_or_time
-    end
-
-    # Returns true if the date/time falls after <tt>date_or_time</tt>.
-    def after?(date_or_time)
-      self > date_or_time
-    end
-
-    # Returns a new date/time the specified number of days ago.
-    def days_ago(days)
-      advance(days: -days)
-    end
-
-    # Returns a new date/time the specified number of days in the future.
-    def days_since(days)
-      advance(days: days)
-    end
-
-    # Returns a new date/time the specified number of weeks ago.
-    def weeks_ago(weeks)
-      advance(weeks: -weeks)
-    end
-
-    # Returns a new date/time the specified number of weeks in the future.
-    def weeks_since(weeks)
-      advance(weeks: weeks)
-    end
-
-    # Returns a new date/time the specified number of months ago.
-    def months_ago(months)
-      advance(months: -months)
-    end
-
-    # Returns a new date/time the specified number of months in the future.
-    def months_since(months)
-      advance(months: months)
-    end
-
-    # Returns a new date/time the specified number of years ago.
-    def years_ago(years)
-      advance(years: -years)
-    end
-
-    # Returns a new date/time the specified number of years in the future.
-    def years_since(years)
-      advance(years: years)
-    end
-
-    # Returns a new date/time at the start of the month.
-    #
-    #   today = Date.today # => Thu, 18 Jun 2015
-    #   today.beginning_of_month # => Mon, 01 Jun 2015
-    #
-    # +DateTime+ objects will have a time set to 0:00.
-    #
-    #   now = DateTime.current # => Thu, 18 Jun 2015 15:23:13 +0000
-    #   now.beginning_of_month # => Mon, 01 Jun 2015 00:00:00 +0000
-    def beginning_of_month
-      first_hour(change(day: 1))
-    end
-    alias :at_beginning_of_month :beginning_of_month
-
-    # Returns a new date/time at the start of the quarter.
-    #
-    #   today = Date.today # => Fri, 10 Jul 2015
-    #   today.beginning_of_quarter # => Wed, 01 Jul 2015
-    #
-    # +DateTime+ objects will have a time set to 0:00.
-    #
-    #   now = DateTime.current # => Fri, 10 Jul 2015 18:41:29 +0000
-    #   now.beginning_of_quarter # => Wed, 01 Jul 2015 00:00:00 +0000
-    def beginning_of_quarter
-      first_quarter_month = month - (2 + month) % 3
-      beginning_of_month.change(month: first_quarter_month)
-    end
-    alias :at_beginning_of_quarter :beginning_of_quarter
-
-    # Returns a new date/time at the end of the quarter.
-    #
-    #   today = Date.today # => Fri, 10 Jul 2015
-    #   today.end_of_quarter # => Wed, 30 Sep 2015
-    #
-    # +DateTime+ objects will have a time set to 23:59:59.
-    #
-    #   now = DateTime.current # => Fri, 10 Jul 2015 18:41:29 +0000
-    #   now.end_of_quarter # => Wed, 30 Sep 2015 23:59:59 +0000
-    def end_of_quarter
-      last_quarter_month = month + (12 - month) % 3
-      beginning_of_month.change(month: last_quarter_month).end_of_month
-    end
-    alias :at_end_of_quarter :end_of_quarter
-
-    # Returns a new date/time at the beginning of the year.
-    #
-    #   today = Date.today # => Fri, 10 Jul 2015
-    #   today.beginning_of_year # => Thu, 01 Jan 2015
-    #
-    # +DateTime+ objects will have a time set to 0:00.
-    #
-    #   now = DateTime.current # => Fri, 10 Jul 2015 18:41:29 +0000
-    #   now.beginning_of_year # => Thu, 01 Jan 2015 00:00:00 +0000
-    def beginning_of_year
-      change(month: 1).beginning_of_month
-    end
-    alias :at_beginning_of_year :beginning_of_year
-
-    # Returns a new date/time representing the given day in the next week.
-    #
-    #   today = Date.today # => Thu, 07 May 2015
-    #   today.next_week    # => Mon, 11 May 2015
-    #
-    # The +given_day_in_next_week+ defaults to the beginning of the week
-    # which is determined by +Date.beginning_of_week+ or +config.beginning_of_week+
-    # when set.
-    #
-    #   today = Date.today       # => Thu, 07 May 2015
-    #   today.next_week(:friday) # => Fri, 15 May 2015
-    #
-    # +DateTime+ objects have their time set to 0:00 unless +same_time+ is true.
-    #
-    #   now = DateTime.current # => Thu, 07 May 2015 13:31:16 +0000
-    #   now.next_week      # => Mon, 11 May 2015 00:00:00 +0000
-    def next_week(given_day_in_next_week = Date.beginning_of_week, same_time: false)
-      result = first_hour(weeks_since(1).beginning_of_week.days_since(days_span(given_day_in_next_week)))
-      same_time ? copy_time_to(result) : result
-    end
-
-    # Returns a new date/time representing the next weekday.
-    def next_weekday
-      if next_day.on_weekend?
-        next_week(:monday, same_time: true)
-      else
-        next_day
-      end
-    end
-
-    # Short-hand for months_since(3)
-    def next_quarter
-      months_since(3)
-    end
-
-    # Returns a new date/time representing the given day in the previous week.
-    # Week is assumed to start on +start_day+, default is
-    # +Date.beginning_of_week+ or +config.beginning_of_week+ when set.
-    # DateTime objects have their time set to 0:00 unless +same_time+ is true.
-    def prev_week(start_day = Date.beginning_of_week, same_time: false)
-      result = first_hour(weeks_ago(1).beginning_of_week.days_since(days_span(start_day)))
-      same_time ? copy_time_to(result) : result
-    end
-    alias_method :last_week, :prev_week
-
-    # Returns a new date/time representing the previous weekday.
-    def prev_weekday
-      if prev_day.on_weekend?
-        copy_time_to(beginning_of_week(:friday))
-      else
-        prev_day
-      end
-    end
-    alias_method :last_weekday, :prev_weekday
-
-    # Short-hand for months_ago(1).
-    def last_month
-      months_ago(1)
-    end
-
-    # Short-hand for months_ago(3).
-    def prev_quarter
-      months_ago(3)
-    end
-    alias_method :last_quarter, :prev_quarter
-
-    # Short-hand for years_ago(1).
-    def last_year
-      years_ago(1)
-    end
-
-    # Returns the number of days to the start of the week on the given day.
-    # Week is assumed to start on +start_day+, default is
-    # +Date.beginning_of_week+ or +config.beginning_of_week+ when set.
-    def days_to_week_start(start_day = Date.beginning_of_week)
-      start_day_number = DAYS_INTO_WEEK.fetch(start_day)
-      (wday - start_day_number) % 7
-    end
-
-    # Returns a new date/time representing the start of this week on the given day.
-    # Week is assumed to start on +start_day+, default is
-    # +Date.beginning_of_week+ or +config.beginning_of_week+ when set.
-    # +DateTime+ objects have their time set to 0:00.
-    def beginning_of_week(start_day = Date.beginning_of_week)
-      result = days_ago(days_to_week_start(start_day))
-      acts_like?(:time) ? result.midnight : result
-    end
-    alias :at_beginning_of_week :beginning_of_week
-
-    # Returns Monday of this week assuming that week starts on Monday.
-    # +DateTime+ objects have their time set to 0:00.
-    def monday
-      beginning_of_week(:monday)
-    end
-
-    # Returns a new date/time representing the end of this week on the given day.
-    # Week is assumed to start on +start_day+, default is
-    # +Date.beginning_of_week+ or +config.beginning_of_week+ when set.
-    # DateTime objects have their time set to 23:59:59.
-    def end_of_week(start_day = Date.beginning_of_week)
-      last_hour(days_since(6 - days_to_week_start(start_day)))
-    end
-    alias :at_end_of_week :end_of_week
-
-    # Returns Sunday of this week assuming that week starts on Monday.
-    # +DateTime+ objects have their time set to 23:59:59.
-    def sunday
-      end_of_week(:monday)
-    end
-
-    # Returns a new date/time representing the end of the month.
-    # DateTime objects will have a time set to 23:59:59.
-    def end_of_month
-      last_day = ::Time.days_in_month(month, year)
-      last_hour(days_since(last_day - day))
-    end
-    alias :at_end_of_month :end_of_month
-
-    # Returns a new date/time representing the end of the year.
-    # DateTime objects will have a time set to 23:59:59.
-    def end_of_year
-      change(month: 12).end_of_month
-    end
-    alias :at_end_of_year :end_of_year
-
-    # Returns a Range representing the whole day of the current date/time.
-    def all_day
-      beginning_of_day..end_of_day
-    end
-
-    # Returns a Range representing the whole week of the current date/time.
-    # Week starts on start_day, default is <tt>Date.beginning_of_week</tt> or <tt>config.beginning_of_week</tt> when set.
-    def all_week(start_day = Date.beginning_of_week)
-      beginning_of_week(start_day)..end_of_week(start_day)
-    end
-
-    # Returns a Range representing the whole month of the current date/time.
-    def all_month
-      beginning_of_month..end_of_month
-    end
-
-    # Returns a Range representing the whole quarter of the current date/time.
-    def all_quarter
-      beginning_of_quarter..end_of_quarter
-    end
-
-    # Returns a Range representing the whole year of the current date/time.
-    def all_year
-      beginning_of_year..end_of_year
-    end
-
-    # Returns a new date/time representing the next occurrence of the specified day of week.
-    #
-    #   today = Date.today               # => Thu, 14 Dec 2017
-    #   today.next_occurring(:monday)    # => Mon, 18 Dec 2017
-    #   today.next_occurring(:thursday)  # => Thu, 21 Dec 2017
-    def next_occurring(day_of_week)
-      from_now = DAYS_INTO_WEEK.fetch(day_of_week) - wday
-      from_now += 7 unless from_now > 0
-      advance(days: from_now)
-    end
-
-    # Returns a new date/time representing the previous occurrence of the specified day of week.
-    #
-    #   today = Date.today               # => Thu, 14 Dec 2017
-    #   today.prev_occurring(:monday)    # => Mon, 11 Dec 2017
-    #   today.prev_occurring(:thursday)  # => Thu, 07 Dec 2017
-    def prev_occurring(day_of_week)
-      ago = wday - DAYS_INTO_WEEK.fetch(day_of_week)
-      ago += 7 unless ago > 0
-      advance(days: -ago)
-    end
-
-    private
-      def first_hour(date_or_time)
-        date_or_time.acts_like?(:time) ? date_or_time.beginning_of_day : date_or_time
-      end
-
-      def last_hour(date_or_time)
-        date_or_time.acts_like?(:time) ? date_or_time.end_of_day : date_or_time
-      end
-
-      def days_span(day)
-        (DAYS_INTO_WEEK.fetch(day) - DAYS_INTO_WEEK.fetch(Date.beginning_of_week)) % 7
-      end
-
-      def copy_time_to(other)
-        other.change(hour: hour, min: min, sec: sec, nsec: try(:nsec))
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_and_time/compatibility.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_and_time/compatibility.rb
deleted file mode 100644
index b40a0fabb11d6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_and_time/compatibility.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/attribute_accessors"
-
-module DateAndTime
-  module Compatibility
-    # If true, +to_time+ preserves the timezone offset of receiver.
-    #
-    # NOTE: With Ruby 2.4+ the default for +to_time+ changed from
-    # converting to the local system time, to preserving the offset
-    # of the receiver. For backwards compatibility we're overriding
-    # this behavior, but new apps will have an initializer that sets
-    # this to true, because the new behavior is preferred.
-    mattr_accessor :preserve_timezone, instance_writer: false, default: false
-
-    # Change the output of <tt>ActiveSupport::TimeZone.utc_to_local</tt>.
-    #
-    # When `true`, it returns local times with an UTC offset, with `false` local
-    # times are returned as UTC.
-    #
-    #   # Given this zone:
-    #   zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
-    #
-    #   # With `utc_to_local_returns_utc_offset_times = false`, local time is converted to UTC:
-    #   zone.utc_to_local(Time.utc(2000, 1)) # => 1999-12-31 19:00:00 UTC
-    #
-    #   # With `utc_to_local_returns_utc_offset_times = true`, local time is returned with UTC offset:
-    #   zone.utc_to_local(Time.utc(2000, 1)) # => 1999-12-31 19:00:00 -0500
-    mattr_accessor :utc_to_local_returns_utc_offset_times, instance_writer: false, default: false
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_and_time/zones.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_and_time/zones.rb
deleted file mode 100644
index fb6a27cb27fda..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_and_time/zones.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module DateAndTime
-  module Zones
-    # Returns the simultaneous time in <tt>Time.zone</tt> if a zone is given or
-    # if Time.zone_default is set. Otherwise, it returns the current time.
-    #
-    #   Time.zone = 'Hawaii'        # => 'Hawaii'
-    #   Time.utc(2000).in_time_zone # => Fri, 31 Dec 1999 14:00:00 HST -10:00
-    #   Date.new(2000).in_time_zone # => Sat, 01 Jan 2000 00:00:00 HST -10:00
-    #
-    # This method is similar to Time#localtime, except that it uses <tt>Time.zone</tt> as the local zone
-    # instead of the operating system's time zone.
-    #
-    # You can also pass in a TimeZone instance or string that identifies a TimeZone as an argument,
-    # and the conversion will be based on that zone instead of <tt>Time.zone</tt>.
-    #
-    #   Time.utc(2000).in_time_zone('Alaska') # => Fri, 31 Dec 1999 15:00:00 AKST -09:00
-    #   Date.new(2000).in_time_zone('Alaska') # => Sat, 01 Jan 2000 00:00:00 AKST -09:00
-    def in_time_zone(zone = ::Time.zone)
-      time_zone = ::Time.find_zone! zone
-      time = acts_like?(:time) ? self : nil
-
-      if time_zone
-        time_with_zone(time, time_zone)
-      else
-        time || to_time
-      end
-    end
-
-    private
-      def time_with_zone(time, zone)
-        if time
-          ActiveSupport::TimeWithZone.new(time.utc? ? time : time.getutc, zone)
-        else
-          ActiveSupport::TimeWithZone.new(nil, zone, to_time(:utc))
-        end
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time.rb
deleted file mode 100644
index 790dbeec1b479..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/date_time/acts_like"
-require "active_support/core_ext/date_time/blank"
-require "active_support/core_ext/date_time/calculations"
-require "active_support/core_ext/date_time/compatibility"
-require "active_support/core_ext/date_time/conversions"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/acts_like.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/acts_like.rb
deleted file mode 100644
index 5dccdfe2192f2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/acts_like.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-require "active_support/core_ext/object/acts_like"
-
-class DateTime
-  # Duck-types as a Date-like class. See Object#acts_like?.
-  def acts_like_date?
-    true
-  end
-
-  # Duck-types as a Time-like class. See Object#acts_like?.
-  def acts_like_time?
-    true
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/blank.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/blank.rb
deleted file mode 100644
index a52c8bc150a2f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/blank.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-
-class DateTime #:nodoc:
-  # No DateTime is ever blank:
-  #
-  #   DateTime.now.blank? # => false
-  #
-  # @return [false]
-  def blank?
-    false
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/calculations.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/calculations.rb
deleted file mode 100644
index bc670c3e764b0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/calculations.rb
+++ /dev/null
@@ -1,211 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-
-class DateTime
-  class << self
-    # Returns <tt>Time.zone.now.to_datetime</tt> when <tt>Time.zone</tt> or
-    # <tt>config.time_zone</tt> are set, otherwise returns
-    # <tt>Time.now.to_datetime</tt>.
-    def current
-      ::Time.zone ? ::Time.zone.now.to_datetime : ::Time.now.to_datetime
-    end
-  end
-
-  # Returns the number of seconds since 00:00:00.
-  #
-  #   DateTime.new(2012, 8, 29,  0,  0,  0).seconds_since_midnight # => 0
-  #   DateTime.new(2012, 8, 29, 12, 34, 56).seconds_since_midnight # => 45296
-  #   DateTime.new(2012, 8, 29, 23, 59, 59).seconds_since_midnight # => 86399
-  def seconds_since_midnight
-    sec + (min * 60) + (hour * 3600)
-  end
-
-  # Returns the number of seconds until 23:59:59.
-  #
-  #   DateTime.new(2012, 8, 29,  0,  0,  0).seconds_until_end_of_day # => 86399
-  #   DateTime.new(2012, 8, 29, 12, 34, 56).seconds_until_end_of_day # => 41103
-  #   DateTime.new(2012, 8, 29, 23, 59, 59).seconds_until_end_of_day # => 0
-  def seconds_until_end_of_day
-    end_of_day.to_i - to_i
-  end
-
-  # Returns the fraction of a second as a +Rational+
-  #
-  #   DateTime.new(2012, 8, 29, 0, 0, 0.5).subsec # => (1/2)
-  def subsec
-    sec_fraction
-  end
-
-  # Returns a new DateTime where one or more of the elements have been changed
-  # according to the +options+ parameter. The time options (<tt>:hour</tt>,
-  # <tt>:min</tt>, <tt>:sec</tt>) reset cascadingly, so if only the hour is
-  # passed, then minute and sec is set to 0. If the hour and minute is passed,
-  # then sec is set to 0. The +options+ parameter takes a hash with any of these
-  # keys: <tt>:year</tt>, <tt>:month</tt>, <tt>:day</tt>, <tt>:hour</tt>,
-  # <tt>:min</tt>, <tt>:sec</tt>, <tt>:offset</tt>, <tt>:start</tt>.
-  #
-  #   DateTime.new(2012, 8, 29, 22, 35, 0).change(day: 1)              # => DateTime.new(2012, 8, 1, 22, 35, 0)
-  #   DateTime.new(2012, 8, 29, 22, 35, 0).change(year: 1981, day: 1)  # => DateTime.new(1981, 8, 1, 22, 35, 0)
-  #   DateTime.new(2012, 8, 29, 22, 35, 0).change(year: 1981, hour: 0) # => DateTime.new(1981, 8, 29, 0, 0, 0)
-  def change(options)
-    if new_nsec = options[:nsec]
-      raise ArgumentError, "Can't change both :nsec and :usec at the same time: #{options.inspect}" if options[:usec]
-      new_fraction = Rational(new_nsec, 1000000000)
-    else
-      new_usec = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
-      new_fraction = Rational(new_usec, 1000000)
-    end
-
-    raise ArgumentError, "argument out of range" if new_fraction >= 1
-
-    ::DateTime.civil(
-      options.fetch(:year, year),
-      options.fetch(:month, month),
-      options.fetch(:day, day),
-      options.fetch(:hour, hour),
-      options.fetch(:min, options[:hour] ? 0 : min),
-      options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec) + new_fraction,
-      options.fetch(:offset, offset),
-      options.fetch(:start, start)
-    )
-  end
-
-  # Uses Date to provide precise Time calculations for years, months, and days.
-  # The +options+ parameter takes a hash with any of these keys: <tt>:years</tt>,
-  # <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>,
-  # <tt>:minutes</tt>, <tt>:seconds</tt>.
-  def advance(options)
-    unless options[:weeks].nil?
-      options[:weeks], partial_weeks = options[:weeks].divmod(1)
-      options[:days] = options.fetch(:days, 0) + 7 * partial_weeks
-    end
-
-    unless options[:days].nil?
-      options[:days], partial_days = options[:days].divmod(1)
-      options[:hours] = options.fetch(:hours, 0) + 24 * partial_days
-    end
-
-    d = to_date.advance(options)
-    datetime_advanced_by_date = change(year: d.year, month: d.month, day: d.day)
-    seconds_to_advance = \
-      options.fetch(:seconds, 0) +
-      options.fetch(:minutes, 0) * 60 +
-      options.fetch(:hours, 0) * 3600
-
-    if seconds_to_advance.zero?
-      datetime_advanced_by_date
-    else
-      datetime_advanced_by_date.since(seconds_to_advance)
-    end
-  end
-
-  # Returns a new DateTime representing the time a number of seconds ago.
-  # Do not use this method in combination with x.months, use months_ago instead!
-  def ago(seconds)
-    since(-seconds)
-  end
-
-  # Returns a new DateTime representing the time a number of seconds since the
-  # instance time. Do not use this method in combination with x.months, use
-  # months_since instead!
-  def since(seconds)
-    self + Rational(seconds, 86400)
-  end
-  alias :in :since
-
-  # Returns a new DateTime representing the start of the day (0:00).
-  def beginning_of_day
-    change(hour: 0)
-  end
-  alias :midnight :beginning_of_day
-  alias :at_midnight :beginning_of_day
-  alias :at_beginning_of_day :beginning_of_day
-
-  # Returns a new DateTime representing the middle of the day (12:00)
-  def middle_of_day
-    change(hour: 12)
-  end
-  alias :midday :middle_of_day
-  alias :noon :middle_of_day
-  alias :at_midday :middle_of_day
-  alias :at_noon :middle_of_day
-  alias :at_middle_of_day :middle_of_day
-
-  # Returns a new DateTime representing the end of the day (23:59:59).
-  def end_of_day
-    change(hour: 23, min: 59, sec: 59, usec: Rational(999999999, 1000))
-  end
-  alias :at_end_of_day :end_of_day
-
-  # Returns a new DateTime representing the start of the hour (hh:00:00).
-  def beginning_of_hour
-    change(min: 0)
-  end
-  alias :at_beginning_of_hour :beginning_of_hour
-
-  # Returns a new DateTime representing the end of the hour (hh:59:59).
-  def end_of_hour
-    change(min: 59, sec: 59, usec: Rational(999999999, 1000))
-  end
-  alias :at_end_of_hour :end_of_hour
-
-  # Returns a new DateTime representing the start of the minute (hh:mm:00).
-  def beginning_of_minute
-    change(sec: 0)
-  end
-  alias :at_beginning_of_minute :beginning_of_minute
-
-  # Returns a new DateTime representing the end of the minute (hh:mm:59).
-  def end_of_minute
-    change(sec: 59, usec: Rational(999999999, 1000))
-  end
-  alias :at_end_of_minute :end_of_minute
-
-  # Returns a <tt>Time</tt> instance of the simultaneous time in the system timezone.
-  def localtime(utc_offset = nil)
-    utc = new_offset(0)
-
-    Time.utc(
-      utc.year, utc.month, utc.day,
-      utc.hour, utc.min, utc.sec + utc.sec_fraction
-    ).getlocal(utc_offset)
-  end
-  alias_method :getlocal, :localtime
-
-  # Returns a <tt>Time</tt> instance of the simultaneous time in the UTC timezone.
-  #
-  #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24))     # => Mon, 21 Feb 2005 10:11:12 -0600
-  #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24)).utc # => Mon, 21 Feb 2005 16:11:12 UTC
-  def utc
-    utc = new_offset(0)
-
-    Time.utc(
-      utc.year, utc.month, utc.day,
-      utc.hour, utc.min, utc.sec + utc.sec_fraction
-    )
-  end
-  alias_method :getgm, :utc
-  alias_method :getutc, :utc
-  alias_method :gmtime, :utc
-
-  # Returns +true+ if <tt>offset == 0</tt>.
-  def utc?
-    offset == 0
-  end
-
-  # Returns the offset value in seconds.
-  def utc_offset
-    (offset * 86400).to_i
-  end
-
-  # Layers additional behavior on DateTime#<=> so that Time and
-  # ActiveSupport::TimeWithZone instances can be compared with a DateTime.
-  def <=>(other)
-    if other.respond_to? :to_datetime
-      super other.to_datetime rescue nil
-    else
-      super
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/compatibility.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/compatibility.rb
deleted file mode 100644
index 7600a067cc579..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/compatibility.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/date_and_time/compatibility"
-require "active_support/core_ext/module/redefine_method"
-
-class DateTime
-  include DateAndTime::Compatibility
-
-  silence_redefinition_of_method :to_time
-
-  # Either return an instance of +Time+ with the same UTC offset
-  # as +self+ or an instance of +Time+ representing the same time
-  # in the local system timezone depending on the setting of
-  # on the setting of +ActiveSupport.to_time_preserves_timezone+.
-  def to_time
-    preserve_timezone ? getlocal(utc_offset) : getlocal
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/conversions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/conversions.rb
deleted file mode 100644
index 231bf870a2692..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/date_time/conversions.rb
+++ /dev/null
@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-require "active_support/inflector/methods"
-require "active_support/core_ext/time/conversions"
-require "active_support/core_ext/date_time/calculations"
-require "active_support/values/time_zone"
-
-class DateTime
-  # Convert to a formatted string. See Time::DATE_FORMATS for predefined formats.
-  #
-  # This method is aliased to <tt>to_s</tt>.
-  #
-  # === Examples
-  #   datetime = DateTime.civil(2007, 12, 4, 0, 0, 0, 0)   # => Tue, 04 Dec 2007 00:00:00 +0000
-  #
-  #   datetime.to_formatted_s(:db)            # => "2007-12-04 00:00:00"
-  #   datetime.to_s(:db)                      # => "2007-12-04 00:00:00"
-  #   datetime.to_s(:number)                  # => "20071204000000"
-  #   datetime.to_formatted_s(:short)         # => "04 Dec 00:00"
-  #   datetime.to_formatted_s(:long)          # => "December 04, 2007 00:00"
-  #   datetime.to_formatted_s(:long_ordinal)  # => "December 4th, 2007 00:00"
-  #   datetime.to_formatted_s(:rfc822)        # => "Tue, 04 Dec 2007 00:00:00 +0000"
-  #   datetime.to_formatted_s(:iso8601)       # => "2007-12-04T00:00:00+00:00"
-  #
-  # == Adding your own datetime formats to to_formatted_s
-  # DateTime formats are shared with Time. You can add your own to the
-  # Time::DATE_FORMATS hash. Use the format name as the hash key and
-  # either a strftime string or Proc instance that takes a time or
-  # datetime argument as the value.
-  #
-  #   # config/initializers/time_formats.rb
-  #   Time::DATE_FORMATS[:month_and_year] = '%B %Y'
-  #   Time::DATE_FORMATS[:short_ordinal] = lambda { |time| time.strftime("%B #{time.day.ordinalize}") }
-  def to_formatted_s(format = :default)
-    if formatter = ::Time::DATE_FORMATS[format]
-      formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
-    else
-      to_default_s
-    end
-  end
-  alias_method :to_default_s, :to_s if instance_methods(false).include?(:to_s)
-  alias_method :to_s, :to_formatted_s
-
-  # Returns a formatted string of the offset from UTC, or an alternative
-  # string if the time zone is already UTC.
-  #
-  #   datetime = DateTime.civil(2000, 1, 1, 0, 0, 0, Rational(-6, 24))
-  #   datetime.formatted_offset         # => "-06:00"
-  #   datetime.formatted_offset(false)  # => "-0600"
-  def formatted_offset(colon = true, alternate_utc_string = nil)
-    utc? && alternate_utc_string || ActiveSupport::TimeZone.seconds_to_utc_offset(utc_offset, colon)
-  end
-
-  # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005 14:30:00 +0000".
-  def readable_inspect
-    to_s(:rfc822)
-  end
-  alias_method :default_inspect, :inspect
-  alias_method :inspect, :readable_inspect
-
-  # Returns DateTime with local offset for given year if format is local else
-  # offset is zero.
-  #
-  #   DateTime.civil_from_format :local, 2012
-  #   # => Sun, 01 Jan 2012 00:00:00 +0300
-  #   DateTime.civil_from_format :local, 2012, 12, 17
-  #   # => Mon, 17 Dec 2012 00:00:00 +0000
-  def self.civil_from_format(utc_or_local, year, month = 1, day = 1, hour = 0, min = 0, sec = 0)
-    if utc_or_local.to_sym == :local
-      offset = ::Time.local(year, month, day).utc_offset.to_r / 86400
-    else
-      offset = 0
-    end
-    civil(year, month, day, hour, min, sec, offset)
-  end
-
-  # Converts +self+ to a floating-point number of seconds, including fractional microseconds, since the Unix epoch.
-  def to_f
-    seconds_since_unix_epoch.to_f + sec_fraction
-  end
-
-  # Converts +self+ to an integer number of seconds since the Unix epoch.
-  def to_i
-    seconds_since_unix_epoch.to_i
-  end
-
-  # Returns the fraction of a second as microseconds
-  def usec
-    (sec_fraction * 1_000_000).to_i
-  end
-
-  # Returns the fraction of a second as nanoseconds
-  def nsec
-    (sec_fraction * 1_000_000_000).to_i
-  end
-
-  private
-    def offset_in_seconds
-      (offset * 86400).to_i
-    end
-
-    def seconds_since_unix_epoch
-      (jd - 2440588) * 86400 - offset_in_seconds + seconds_since_midnight
-    end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/digest.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/digest.rb
deleted file mode 100644
index ce1427e13a0d6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/digest.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/digest/uuid"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/digest/uuid.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/digest/uuid.rb
deleted file mode 100644
index 37f0a8e66f4ec..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/digest/uuid.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-require "digest"
-
-module Digest
-  module UUID
-    DNS_NAMESPACE  = "k\xA7\xB8\x10\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
-    URL_NAMESPACE  = "k\xA7\xB8\x11\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
-    OID_NAMESPACE  = "k\xA7\xB8\x12\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
-    X500_NAMESPACE = "k\xA7\xB8\x14\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" #:nodoc:
-
-    # Generates a v5 non-random UUID (Universally Unique IDentifier).
-    #
-    # Using Digest::MD5 generates version 3 UUIDs; Digest::SHA1 generates version 5 UUIDs.
-    # uuid_from_hash always generates the same UUID for a given name and namespace combination.
-    #
-    # See RFC 4122 for details of UUID at: https://www.ietf.org/rfc/rfc4122.txt
-    def self.uuid_from_hash(hash_class, uuid_namespace, name)
-      if hash_class == Digest::MD5
-        version = 3
-      elsif hash_class == Digest::SHA1
-        version = 5
-      else
-        raise ArgumentError, "Expected Digest::SHA1 or Digest::MD5, got #{hash_class.name}."
-      end
-
-      hash = hash_class.new
-      hash.update(uuid_namespace)
-      hash.update(name)
-
-      ary = hash.digest.unpack("NnnnnN")
-      ary[2] = (ary[2] & 0x0FFF) | (version << 12)
-      ary[3] = (ary[3] & 0x3FFF) | 0x8000
-
-      "%08x-%04x-%04x-%04x-%04x%08x" % ary
-    end
-
-    # Convenience method for uuid_from_hash using Digest::MD5.
-    def self.uuid_v3(uuid_namespace, name)
-      uuid_from_hash(Digest::MD5, uuid_namespace, name)
-    end
-
-    # Convenience method for uuid_from_hash using Digest::SHA1.
-    def self.uuid_v5(uuid_namespace, name)
-      uuid_from_hash(Digest::SHA1, uuid_namespace, name)
-    end
-
-    # Convenience method for SecureRandom.uuid.
-    def self.uuid_v4
-      SecureRandom.uuid
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/enumerable.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/enumerable.rb
deleted file mode 100644
index 97c918a71f89e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/enumerable.rb
+++ /dev/null
@@ -1,260 +0,0 @@
-# frozen_string_literal: true
-
-module Enumerable
-  INDEX_WITH_DEFAULT = Object.new
-  private_constant :INDEX_WITH_DEFAULT
-
-  # Enumerable#sum was added in Ruby 2.4, but it only works with Numeric elements
-  # when we omit an identity.
-
-  # :stopdoc:
-
-  # We can't use Refinements here because Refinements with Module which will be prepended
-  # doesn't work well https://bugs.ruby-lang.org/issues/13446
-  alias :_original_sum_with_required_identity :sum
-  private :_original_sum_with_required_identity
-
-  # :startdoc:
-
-  # Calculates a sum from the elements.
-  #
-  #  payments.sum { |p| p.price * p.tax_rate }
-  #  payments.sum(&:price)
-  #
-  # The latter is a shortcut for:
-  #
-  #  payments.inject(0) { |sum, p| sum + p.price }
-  #
-  # It can also calculate the sum without the use of a block.
-  #
-  #  [5, 15, 10].sum # => 30
-  #  ['foo', 'bar'].sum # => "foobar"
-  #  [[1, 2], [3, 1, 5]].sum # => [1, 2, 3, 1, 5]
-  #
-  # The default sum of an empty list is zero. You can override this default:
-  #
-  #  [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
-  def sum(identity = nil, &block)
-    if identity
-      _original_sum_with_required_identity(identity, &block)
-    elsif block_given?
-      map(&block).sum(identity)
-    else
-      inject(:+) || 0
-    end
-  end
-
-  # Convert an enumerable to a hash, using the block result as the key and the
-  # element as the value.
-  #
-  #   people.index_by(&:login)
-  #   # => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
-  #
-  #   people.index_by { |person| "#{person.first_name} #{person.last_name}" }
-  #   # => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
-  def index_by
-    if block_given?
-      result = {}
-      each { |elem| result[yield(elem)] = elem }
-      result
-    else
-      to_enum(:index_by) { size if respond_to?(:size) }
-    end
-  end
-
-  # Convert an enumerable to a hash, using the element as the key and the block
-  # result as the value.
-  #
-  #   post = Post.new(title: "hey there", body: "what's up?")
-  #
-  #   %i( title body ).index_with { |attr_name| post.public_send(attr_name) }
-  #   # => { title: "hey there", body: "what's up?" }
-  #
-  # If an argument is passed instead of a block, it will be used as the value
-  # for all elements:
-  #
-  #   %i( created_at updated_at ).index_with(Time.now)
-  #   # => { created_at: 2020-03-09 22:31:47, updated_at: 2020-03-09 22:31:47 }
-  def index_with(default = INDEX_WITH_DEFAULT)
-    if block_given?
-      result = {}
-      each { |elem| result[elem] = yield(elem) }
-      result
-    elsif default != INDEX_WITH_DEFAULT
-      result = {}
-      each { |elem| result[elem] = default }
-      result
-    else
-      to_enum(:index_with) { size if respond_to?(:size) }
-    end
-  end
-
-  # Returns +true+ if the enumerable has more than 1 element. Functionally
-  # equivalent to <tt>enum.to_a.size > 1</tt>. Can be called with a block too,
-  # much like any?, so <tt>people.many? { |p| p.age > 26 }</tt> returns +true+
-  # if more than one person is over 26.
-  def many?
-    cnt = 0
-    if block_given?
-      any? do |element|
-        cnt += 1 if yield element
-        cnt > 1
-      end
-    else
-      any? { (cnt += 1) > 1 }
-    end
-  end
-
-  # Returns a new array that includes the passed elements.
-  #
-  #   [ 1, 2, 3 ].including(4, 5)
-  #   # => [ 1, 2, 3, 4, 5 ]
-  #
-  #   ["David", "Rafael"].including %w[ Aaron Todd ]
-  #   # => ["David", "Rafael", "Aaron", "Todd"]
-  def including(*elements)
-    to_a.including(*elements)
-  end
-
-  # The negative of the <tt>Enumerable#include?</tt>. Returns +true+ if the
-  # collection does not include the object.
-  def exclude?(object)
-    !include?(object)
-  end
-
-  # Returns a copy of the enumerable excluding the specified elements.
-  #
-  #   ["David", "Rafael", "Aaron", "Todd"].excluding "Aaron", "Todd"
-  #   # => ["David", "Rafael"]
-  #
-  #   ["David", "Rafael", "Aaron", "Todd"].excluding %w[ Aaron Todd ]
-  #   # => ["David", "Rafael"]
-  #
-  #   {foo: 1, bar: 2, baz: 3}.excluding :bar
-  #   # => {foo: 1, baz: 3}
-  def excluding(*elements)
-    elements.flatten!(1)
-    reject { |element| elements.include?(element) }
-  end
-
-  # Alias for #excluding.
-  def without(*elements)
-    excluding(*elements)
-  end
-
-  # Extract the given key from each element in the enumerable.
-  #
-  #   [{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pluck(:name)
-  #   # => ["David", "Rafael", "Aaron"]
-  #
-  #   [{ id: 1, name: "David" }, { id: 2, name: "Rafael" }].pluck(:id, :name)
-  #   # => [[1, "David"], [2, "Rafael"]]
-  def pluck(*keys)
-    if keys.many?
-      map { |element| keys.map { |key| element[key] } }
-    else
-      key = keys.first
-      map { |element| element[key] }
-    end
-  end
-
-  # Extract the given key from the first element in the enumerable.
-  #
-  #   [{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pick(:name)
-  #   # => "David"
-  #
-  #   [{ id: 1, name: "David" }, { id: 2, name: "Rafael" }].pick(:id, :name)
-  #   # => [1, "David"]
-  def pick(*keys)
-    return if none?
-
-    if keys.many?
-      keys.map { |key| first[key] }
-    else
-      first[keys.first]
-    end
-  end
-
-  # Returns a new +Array+ without the blank items.
-  # Uses Object#blank? for determining if an item is blank.
-  #
-  #    [1, "", nil, 2, " ", [], {}, false, true].compact_blank
-  #    # =>  [1, 2, true]
-  #
-  #    Set.new([nil, "", 1, 2])
-  #    # => [2, 1] (or [1, 2])
-  #
-  # When called on a +Hash+, returns a new +Hash+ without the blank values.
-  #
-  #    { a: "", b: 1, c: nil, d: [], e: false, f: true }.compact_blank
-  #    #=> { b: 1, f: true }
-  def compact_blank
-    reject(&:blank?)
-  end
-end
-
-class Hash
-  # Hash#reject has its own definition, so this needs one too.
-  def compact_blank #:nodoc:
-    reject { |_k, v| v.blank? }
-  end
-
-  # Removes all blank values from the +Hash+ in place and returns self.
-  # Uses Object#blank? for determining if a value is blank.
-  #
-  #    h = { a: "", b: 1, c: nil, d: [], e: false, f: true }
-  #    h.compact_blank!
-  #    # => { b: 1, f: true }
-  def compact_blank!
-    # use delete_if rather than reject! because it always returns self even if nothing changed
-    delete_if { |_k, v| v.blank? }
-  end
-end
-
-class Range #:nodoc:
-  # Optimize range sum to use arithmetic progression if a block is not given and
-  # we have a range of numeric values.
-  def sum(identity = nil)
-    if block_given? || !(first.is_a?(Integer) && last.is_a?(Integer))
-      super
-    else
-      actual_last = exclude_end? ? (last - 1) : last
-      if actual_last >= first
-        sum = identity || 0
-        sum + (actual_last - first + 1) * (actual_last + first) / 2
-      else
-        identity || 0
-      end
-    end
-  end
-end
-
-# Using Refinements here in order not to expose our internal method
-using Module.new {
-  refine Array do
-    alias :orig_sum :sum
-  end
-}
-
-class Array #:nodoc:
-  # Array#sum was added in Ruby 2.4 but it only works with Numeric elements.
-  def sum(init = nil, &block)
-    if init.is_a?(Numeric) || first.is_a?(Numeric)
-      init ||= 0
-      orig_sum(init, &block)
-    else
-      super
-    end
-  end
-
-  # Removes all blank elements from the +Array+ in place and returns self.
-  # Uses Object#blank? for determining if an item is blank.
-  #
-  #    a = [1, "", nil, 2, " ", [], {}, false, true]
-  #    a.compact_blank!
-  #    # =>  [1, 2, true]
-  def compact_blank!
-    # use delete_if rather than reject! because it always returns self even if nothing changed
-    delete_if(&:blank?)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/file.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/file.rb
deleted file mode 100644
index 64553bfa4e82e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/file.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/file/atomic"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash.rb
deleted file mode 100644
index 2f0901d8534b4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/hash/conversions"
-require "active_support/core_ext/hash/deep_merge"
-require "active_support/core_ext/hash/deep_transform_values"
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/hash/indifferent_access"
-require "active_support/core_ext/hash/keys"
-require "active_support/core_ext/hash/reverse_merge"
-require "active_support/core_ext/hash/slice"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/conversions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/conversions.rb
deleted file mode 100644
index 2b5e484d215ee..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/conversions.rb
+++ /dev/null
@@ -1,263 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/xml_mini"
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/object/to_param"
-require "active_support/core_ext/object/to_query"
-require "active_support/core_ext/object/try"
-require "active_support/core_ext/array/wrap"
-require "active_support/core_ext/hash/reverse_merge"
-require "active_support/core_ext/string/inflections"
-
-class Hash
-  # Returns a string containing an XML representation of its receiver:
-  #
-  #   { foo: 1, bar: 2 }.to_xml
-  #   # =>
-  #   # <?xml version="1.0" encoding="UTF-8"?>
-  #   # <hash>
-  #   #   <foo type="integer">1</foo>
-  #   #   <bar type="integer">2</bar>
-  #   # </hash>
-  #
-  # To do so, the method loops over the pairs and builds nodes that depend on
-  # the _values_. Given a pair +key+, +value+:
-  #
-  # * If +value+ is a hash there's a recursive call with +key+ as <tt>:root</tt>.
-  #
-  # * If +value+ is an array there's a recursive call with +key+ as <tt>:root</tt>,
-  #   and +key+ singularized as <tt>:children</tt>.
-  #
-  # * If +value+ is a callable object it must expect one or two arguments. Depending
-  #   on the arity, the callable is invoked with the +options+ hash as first argument
-  #   with +key+ as <tt>:root</tt>, and +key+ singularized as second argument. The
-  #   callable can add nodes by using <tt>options[:builder]</tt>.
-  #
-  #     {foo: lambda { |options, key| options[:builder].b(key) }}.to_xml
-  #     # => "<b>foo</b>"
-  #
-  # * If +value+ responds to +to_xml+ the method is invoked with +key+ as <tt>:root</tt>.
-  #
-  #     class Foo
-  #       def to_xml(options)
-  #         options[:builder].bar 'fooing!'
-  #       end
-  #     end
-  #
-  #     { foo: Foo.new }.to_xml(skip_instruct: true)
-  #     # =>
-  #     # <hash>
-  #     #   <bar>fooing!</bar>
-  #     # </hash>
-  #
-  # * Otherwise, a node with +key+ as tag is created with a string representation of
-  #   +value+ as text node. If +value+ is +nil+ an attribute "nil" set to "true" is added.
-  #   Unless the option <tt>:skip_types</tt> exists and is true, an attribute "type" is
-  #   added as well according to the following mapping:
-  #
-  #     XML_TYPE_NAMES = {
-  #       "Symbol"     => "symbol",
-  #       "Integer"    => "integer",
-  #       "BigDecimal" => "decimal",
-  #       "Float"      => "float",
-  #       "TrueClass"  => "boolean",
-  #       "FalseClass" => "boolean",
-  #       "Date"       => "date",
-  #       "DateTime"   => "dateTime",
-  #       "Time"       => "dateTime"
-  #     }
-  #
-  # By default the root node is "hash", but that's configurable via the <tt>:root</tt> option.
-  #
-  # The default XML builder is a fresh instance of <tt>Builder::XmlMarkup</tt>. You can
-  # configure your own builder with the <tt>:builder</tt> option. The method also accepts
-  # options like <tt>:dasherize</tt> and friends, they are forwarded to the builder.
-  def to_xml(options = {})
-    require "active_support/builder" unless defined?(Builder::XmlMarkup)
-
-    options = options.dup
-    options[:indent]  ||= 2
-    options[:root]    ||= "hash"
-    options[:builder] ||= Builder::XmlMarkup.new(indent: options[:indent])
-
-    builder = options[:builder]
-    builder.instruct! unless options.delete(:skip_instruct)
-
-    root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
-
-    builder.tag!(root) do
-      each { |key, value| ActiveSupport::XmlMini.to_tag(key, value, options) }
-      yield builder if block_given?
-    end
-  end
-
-  class << self
-    # Returns a Hash containing a collection of pairs when the key is the node name and the value is
-    # its content
-    #
-    #   xml = <<-XML
-    #     <?xml version="1.0" encoding="UTF-8"?>
-    #       <hash>
-    #         <foo type="integer">1</foo>
-    #         <bar type="integer">2</bar>
-    #       </hash>
-    #   XML
-    #
-    #   hash = Hash.from_xml(xml)
-    #   # => {"hash"=>{"foo"=>1, "bar"=>2}}
-    #
-    # +DisallowedType+ is raised if the XML contains attributes with <tt>type="yaml"</tt> or
-    # <tt>type="symbol"</tt>. Use <tt>Hash.from_trusted_xml</tt> to
-    # parse this XML.
-    #
-    # Custom +disallowed_types+ can also be passed in the form of an
-    # array.
-    #
-    #   xml = <<-XML
-    #     <?xml version="1.0" encoding="UTF-8"?>
-    #       <hash>
-    #         <foo type="integer">1</foo>
-    #         <bar type="string">"David"</bar>
-    #       </hash>
-    #   XML
-    #
-    #   hash = Hash.from_xml(xml, ['integer'])
-    #   # => ActiveSupport::XMLConverter::DisallowedType: Disallowed type attribute: "integer"
-    #
-    # Note that passing custom disallowed types will override the default types,
-    # which are Symbol and YAML.
-    def from_xml(xml, disallowed_types = nil)
-      ActiveSupport::XMLConverter.new(xml, disallowed_types).to_h
-    end
-
-    # Builds a Hash from XML just like <tt>Hash.from_xml</tt>, but also allows Symbol and YAML.
-    def from_trusted_xml(xml)
-      from_xml xml, []
-    end
-  end
-end
-
-module ActiveSupport
-  class XMLConverter # :nodoc:
-    # Raised if the XML contains attributes with type="yaml" or
-    # type="symbol". Read Hash#from_xml for more details.
-    class DisallowedType < StandardError
-      def initialize(type)
-        super "Disallowed type attribute: #{type.inspect}"
-      end
-    end
-
-    DISALLOWED_TYPES = %w(symbol yaml)
-
-    def initialize(xml, disallowed_types = nil)
-      @xml = normalize_keys(XmlMini.parse(xml))
-      @disallowed_types = disallowed_types || DISALLOWED_TYPES
-    end
-
-    def to_h
-      deep_to_h(@xml)
-    end
-
-    private
-      def normalize_keys(params)
-        case params
-        when Hash
-          Hash[params.map { |k, v| [k.to_s.tr("-", "_"), normalize_keys(v)] } ]
-        when Array
-          params.map { |v| normalize_keys(v) }
-        else
-          params
-        end
-      end
-
-      def deep_to_h(value)
-        case value
-        when Hash
-          process_hash(value)
-        when Array
-          process_array(value)
-        when String
-          value
-        else
-          raise "can't typecast #{value.class.name} - #{value.inspect}"
-        end
-      end
-
-      def process_hash(value)
-        if value.include?("type") && !value["type"].is_a?(Hash) && @disallowed_types.include?(value["type"])
-          raise DisallowedType, value["type"]
-        end
-
-        if become_array?(value)
-          _, entries = Array.wrap(value.detect { |k, v| not v.is_a?(String) })
-          if entries.nil? || value["__content__"].try(:empty?)
-            []
-          else
-            case entries
-            when Array
-              entries.collect { |v| deep_to_h(v) }
-            when Hash
-              [deep_to_h(entries)]
-            else
-              raise "can't typecast #{entries.inspect}"
-            end
-          end
-        elsif become_content?(value)
-          process_content(value)
-
-        elsif become_empty_string?(value)
-          ""
-        elsif become_hash?(value)
-          xml_value = value.transform_values { |v| deep_to_h(v) }
-
-          # Turn { files: { file: #<StringIO> } } into { files: #<StringIO> } so it is compatible with
-          # how multipart uploaded files from HTML appear
-          xml_value["file"].is_a?(StringIO) ? xml_value["file"] : xml_value
-        end
-      end
-
-      def become_content?(value)
-        value["type"] == "file" || (value["__content__"] && (value.keys.size == 1 || value["__content__"].present?))
-      end
-
-      def become_array?(value)
-        value["type"] == "array"
-      end
-
-      def become_empty_string?(value)
-        # { "string" => true }
-        # No tests fail when the second term is removed.
-        value["type"] == "string" && value["nil"] != "true"
-      end
-
-      def become_hash?(value)
-        !nothing?(value) && !garbage?(value)
-      end
-
-      def nothing?(value)
-        # blank or nil parsed values are represented by nil
-        value.blank? || value["nil"] == "true"
-      end
-
-      def garbage?(value)
-        # If the type is the only element which makes it then
-        # this still makes the value nil, except if type is
-        # an XML node(where type['value'] is a Hash)
-        value["type"] && !value["type"].is_a?(::Hash) && value.size == 1
-      end
-
-      def process_content(value)
-        content = value["__content__"]
-        if parser = ActiveSupport::XmlMini::PARSING[value["type"]]
-          parser.arity == 1 ? parser.call(content) : parser.call(content, value)
-        else
-          content
-        end
-      end
-
-      def process_array(value)
-        value.map! { |i| deep_to_h(i) }
-        value.length > 1 ? value : value.first
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/deep_merge.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/deep_merge.rb
deleted file mode 100644
index 9bc50b7bc63bf..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/deep_merge.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-class Hash
-  # Returns a new hash with +self+ and +other_hash+ merged recursively.
-  #
-  #   h1 = { a: true, b: { c: [1, 2, 3] } }
-  #   h2 = { a: false, b: { x: [3, 4, 5] } }
-  #
-  #   h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
-  #
-  # Like with Hash#merge in the standard library, a block can be provided
-  # to merge values:
-  #
-  #   h1 = { a: 100, b: 200, c: { c1: 100 } }
-  #   h2 = { b: 250, c: { c1: 200 } }
-  #   h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
-  #   # => { a: 100, b: 450, c: { c1: 300 } }
-  def deep_merge(other_hash, &block)
-    dup.deep_merge!(other_hash, &block)
-  end
-
-  # Same as +deep_merge+, but modifies +self+.
-  def deep_merge!(other_hash, &block)
-    merge!(other_hash) do |key, this_val, other_val|
-      if this_val.is_a?(Hash) && other_val.is_a?(Hash)
-        this_val.deep_merge(other_val, &block)
-      elsif block_given?
-        block.call(key, this_val, other_val)
-      else
-        other_val
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/deep_transform_values.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/deep_transform_values.rb
deleted file mode 100644
index 8ad85c0a6d8eb..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/deep_transform_values.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-class Hash
-  # Returns a new hash with all values converted by the block operation.
-  # This includes the values from the root hash and from all
-  # nested hashes and arrays.
-  #
-  #  hash = { person: { name: 'Rob', age: '28' } }
-  #
-  #  hash.deep_transform_values{ |value| value.to_s.upcase }
-  #  # => {person: {name: "ROB", age: "28"}}
-  def deep_transform_values(&block)
-    _deep_transform_values_in_object(self, &block)
-  end
-
-  # Destructively converts all values by using the block operation.
-  # This includes the values from the root hash and from all
-  # nested hashes and arrays.
-  def deep_transform_values!(&block)
-    _deep_transform_values_in_object!(self, &block)
-  end
-
-  private
-    # Support methods for deep transforming nested hashes and arrays.
-    def _deep_transform_values_in_object(object, &block)
-      case object
-      when Hash
-        object.transform_values { |value| _deep_transform_values_in_object(value, &block) }
-      when Array
-        object.map { |e| _deep_transform_values_in_object(e, &block) }
-      else
-        yield(object)
-      end
-    end
-
-    def _deep_transform_values_in_object!(object, &block)
-      case object
-      when Hash
-        object.transform_values! { |value| _deep_transform_values_in_object!(value, &block) }
-      when Array
-        object.map! { |e| _deep_transform_values_in_object!(e, &block) }
-      else
-        yield(object)
-      end
-    end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/except.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/except.rb
deleted file mode 100644
index ec96929b0ae6b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/except.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-class Hash
-  # Returns a hash that includes everything except given keys.
-  #   hash = { a: true, b: false, c: nil }
-  #   hash.except(:c)     # => { a: true, b: false }
-  #   hash.except(:a, :b) # => { c: nil }
-  #   hash                # => { a: true, b: false, c: nil }
-  #
-  # This is useful for limiting a set of parameters to everything but a few known toggles:
-  #   @person.update(params[:person].except(:admin))
-  def except(*keys)
-    slice(*self.keys - keys)
-  end unless method_defined?(:except)
-
-  # Removes the given keys from hash and returns it.
-  #   hash = { a: true, b: false, c: nil }
-  #   hash.except!(:c) # => { a: true, b: false }
-  #   hash             # => { a: true, b: false }
-  def except!(*keys)
-    keys.each { |key| delete(key) }
-    self
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/indifferent_access.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/indifferent_access.rb
deleted file mode 100644
index a38f33f1282e6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/indifferent_access.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/hash_with_indifferent_access"
-
-class Hash
-  # Returns an <tt>ActiveSupport::HashWithIndifferentAccess</tt> out of its receiver:
-  #
-  #   { a: 1 }.with_indifferent_access['a'] # => 1
-  def with_indifferent_access
-    ActiveSupport::HashWithIndifferentAccess.new(self)
-  end
-
-  # Called when object is nested under an object that receives
-  # #with_indifferent_access. This method will be called on the current object
-  # by the enclosing object and is aliased to #with_indifferent_access by
-  # default. Subclasses of Hash may overwrite this method to return +self+ if
-  # converting to an <tt>ActiveSupport::HashWithIndifferentAccess</tt> would not be
-  # desirable.
-  #
-  #   b = { b: 1 }
-  #   { a: b }.with_indifferent_access['a'] # calls b.nested_under_indifferent_access
-  #   # => {"b"=>1}
-  alias nested_under_indifferent_access with_indifferent_access
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/keys.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/keys.rb
deleted file mode 100644
index f2db61f386e63..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/keys.rb
+++ /dev/null
@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-class Hash
-  # Returns a new hash with all keys converted to strings.
-  #
-  #   hash = { name: 'Rob', age: '28' }
-  #
-  #   hash.stringify_keys
-  #   # => {"name"=>"Rob", "age"=>"28"}
-  def stringify_keys
-    transform_keys(&:to_s)
-  end
-
-  # Destructively converts all keys to strings. Same as
-  # +stringify_keys+, but modifies +self+.
-  def stringify_keys!
-    transform_keys!(&:to_s)
-  end
-
-  # Returns a new hash with all keys converted to symbols, as long as
-  # they respond to +to_sym+.
-  #
-  #   hash = { 'name' => 'Rob', 'age' => '28' }
-  #
-  #   hash.symbolize_keys
-  #   # => {:name=>"Rob", :age=>"28"}
-  def symbolize_keys
-    transform_keys { |key| key.to_sym rescue key }
-  end
-  alias_method :to_options,  :symbolize_keys
-
-  # Destructively converts all keys to symbols, as long as they respond
-  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
-  def symbolize_keys!
-    transform_keys! { |key| key.to_sym rescue key }
-  end
-  alias_method :to_options!, :symbolize_keys!
-
-  # Validates all keys in a hash match <tt>*valid_keys</tt>, raising
-  # +ArgumentError+ on a mismatch.
-  #
-  # Note that keys are treated differently than HashWithIndifferentAccess,
-  # meaning that string and symbol keys will not match.
-  #
-  #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
-  #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
-  #   { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
-  def assert_valid_keys(*valid_keys)
-    valid_keys.flatten!
-    each_key do |k|
-      unless valid_keys.include?(k)
-        raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
-      end
-    end
-  end
-
-  # Returns a new hash with all keys converted by the block operation.
-  # This includes the keys from the root hash and from all
-  # nested hashes and arrays.
-  #
-  #  hash = { person: { name: 'Rob', age: '28' } }
-  #
-  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
-  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
-  def deep_transform_keys(&block)
-    _deep_transform_keys_in_object(self, &block)
-  end
-
-  # Destructively converts all keys by using the block operation.
-  # This includes the keys from the root hash and from all
-  # nested hashes and arrays.
-  def deep_transform_keys!(&block)
-    _deep_transform_keys_in_object!(self, &block)
-  end
-
-  # Returns a new hash with all keys converted to strings.
-  # This includes the keys from the root hash and from all
-  # nested hashes and arrays.
-  #
-  #   hash = { person: { name: 'Rob', age: '28' } }
-  #
-  #   hash.deep_stringify_keys
-  #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
-  def deep_stringify_keys
-    deep_transform_keys(&:to_s)
-  end
-
-  # Destructively converts all keys to strings.
-  # This includes the keys from the root hash and from all
-  # nested hashes and arrays.
-  def deep_stringify_keys!
-    deep_transform_keys!(&:to_s)
-  end
-
-  # Returns a new hash with all keys converted to symbols, as long as
-  # they respond to +to_sym+. This includes the keys from the root hash
-  # and from all nested hashes and arrays.
-  #
-  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
-  #
-  #   hash.deep_symbolize_keys
-  #   # => {:person=>{:name=>"Rob", :age=>"28"}}
-  def deep_symbolize_keys
-    deep_transform_keys { |key| key.to_sym rescue key }
-  end
-
-  # Destructively converts all keys to symbols, as long as they respond
-  # to +to_sym+. This includes the keys from the root hash and from all
-  # nested hashes and arrays.
-  def deep_symbolize_keys!
-    deep_transform_keys! { |key| key.to_sym rescue key }
-  end
-
-  private
-    # Support methods for deep transforming nested hashes and arrays.
-    def _deep_transform_keys_in_object(object, &block)
-      case object
-      when Hash
-        object.each_with_object({}) do |(key, value), result|
-          result[yield(key)] = _deep_transform_keys_in_object(value, &block)
-        end
-      when Array
-        object.map { |e| _deep_transform_keys_in_object(e, &block) }
-      else
-        object
-      end
-    end
-
-    def _deep_transform_keys_in_object!(object, &block)
-      case object
-      when Hash
-        object.keys.each do |key|
-          value = object.delete(key)
-          object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
-        end
-        object
-      when Array
-        object.map! { |e| _deep_transform_keys_in_object!(e, &block) }
-      else
-        object
-      end
-    end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/reverse_merge.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/reverse_merge.rb
deleted file mode 100644
index ef8d592829a7a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/reverse_merge.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-class Hash
-  # Merges the caller into +other_hash+. For example,
-  #
-  #   options = options.reverse_merge(size: 25, velocity: 10)
-  #
-  # is equivalent to
-  #
-  #   options = { size: 25, velocity: 10 }.merge(options)
-  #
-  # This is particularly useful for initializing an options hash
-  # with default values.
-  def reverse_merge(other_hash)
-    other_hash.merge(self)
-  end
-  alias_method :with_defaults, :reverse_merge
-
-  # Destructive +reverse_merge+.
-  def reverse_merge!(other_hash)
-    replace(reverse_merge(other_hash))
-  end
-  alias_method :reverse_update, :reverse_merge!
-  alias_method :with_defaults!, :reverse_merge!
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/slice.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/slice.rb
deleted file mode 100644
index 56bc5de382e68..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/hash/slice.rb
+++ /dev/null
@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-class Hash
-  # Replaces the hash with only the given keys.
-  # Returns a hash containing the removed key/value pairs.
-  #
-  #   hash = { a: 1, b: 2, c: 3, d: 4 }
-  #   hash.slice!(:a, :b)  # => {:c=>3, :d=>4}
-  #   hash                 # => {:a=>1, :b=>2}
-  def slice!(*keys)
-    omit = slice(*self.keys - keys)
-    hash = slice(*keys)
-    hash.default      = default
-    hash.default_proc = default_proc if default_proc
-    replace(hash)
-    omit
-  end
-
-  # Removes and returns the key/value pairs matching the given keys.
-  #
-  #   hash = { a: 1, b: 2, c: 3, d: 4 }
-  #   hash.extract!(:a, :b) # => {:a=>1, :b=>2}
-  #   hash                  # => {:c=>3, :d=>4}
-  def extract!(*keys)
-    keys.each_with_object(self.class.new) { |key, result| result[key] = delete(key) if has_key?(key) }
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/integer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/integer.rb
deleted file mode 100644
index d22701306a1ca..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/integer.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/integer/multiple"
-require "active_support/core_ext/integer/inflections"
-require "active_support/core_ext/integer/time"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/integer/inflections.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/integer/inflections.rb
deleted file mode 100644
index aef3266f2830b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/integer/inflections.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/inflector"
-
-class Integer
-  # Ordinalize turns a number into an ordinal string used to denote the
-  # position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
-  #
-  #  1.ordinalize     # => "1st"
-  #  2.ordinalize     # => "2nd"
-  #  1002.ordinalize  # => "1002nd"
-  #  1003.ordinalize  # => "1003rd"
-  #  -11.ordinalize   # => "-11th"
-  #  -1001.ordinalize # => "-1001st"
-  def ordinalize
-    ActiveSupport::Inflector.ordinalize(self)
-  end
-
-  # Ordinal returns the suffix used to denote the position
-  # in an ordered sequence such as 1st, 2nd, 3rd, 4th.
-  #
-  #  1.ordinal     # => "st"
-  #  2.ordinal     # => "nd"
-  #  1002.ordinal  # => "nd"
-  #  1003.ordinal  # => "rd"
-  #  -11.ordinal   # => "th"
-  #  -1001.ordinal # => "st"
-  def ordinal
-    ActiveSupport::Inflector.ordinal(self)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/integer/multiple.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/integer/multiple.rb
deleted file mode 100644
index bd57a909c55b3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/integer/multiple.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-class Integer
-  # Check whether the integer is evenly divisible by the argument.
-  #
-  #   0.multiple_of?(0)  # => true
-  #   6.multiple_of?(5)  # => false
-  #   10.multiple_of?(2) # => true
-  def multiple_of?(number)
-    number == 0 ? self == 0 : self % number == 0
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/integer/time.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/integer/time.rb
deleted file mode 100644
index 5efb89cf9f8f5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/integer/time.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/duration"
-require "active_support/core_ext/numeric/time"
-
-class Integer
-  # Returns a Duration instance matching the number of months provided.
-  #
-  #   2.months # => 2 months
-  def months
-    ActiveSupport::Duration.months(self)
-  end
-  alias :month :months
-
-  # Returns a Duration instance matching the number of years provided.
-  #
-  #   2.years # => 2 years
-  def years
-    ActiveSupport::Duration.years(self)
-  end
-  alias :year :years
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/kernel.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/kernel.rb
deleted file mode 100644
index 7708069301d71..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/kernel.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/kernel/concern"
-require "active_support/core_ext/kernel/reporting"
-require "active_support/core_ext/kernel/singleton_class"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/kernel/concern.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/kernel/concern.rb
deleted file mode 100644
index 0b2baed78073a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/kernel/concern.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/concerning"
-
-module Kernel
-  module_function
-
-  # A shortcut to define a toplevel concern, not within a module.
-  #
-  # See Module::Concerning for more.
-  def concern(topic, &module_definition)
-    Object.concern topic, &module_definition
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/kernel/reporting.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/kernel/reporting.rb
deleted file mode 100644
index 9155bd6c10a92..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/kernel/reporting.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Kernel
-  module_function
-
-  # Sets $VERBOSE to +nil+ for the duration of the block and back to its original
-  # value afterwards.
-  #
-  #   silence_warnings do
-  #     value = noisy_call # no warning voiced
-  #   end
-  #
-  #   noisy_call # warning voiced
-  def silence_warnings
-    with_warnings(nil) { yield }
-  end
-
-  # Sets $VERBOSE to +true+ for the duration of the block and back to its
-  # original value afterwards.
-  def enable_warnings
-    with_warnings(true) { yield }
-  end
-
-  # Sets $VERBOSE for the duration of the block and back to its original
-  # value afterwards.
-  def with_warnings(flag)
-    old_verbose, $VERBOSE = $VERBOSE, flag
-    yield
-  ensure
-    $VERBOSE = old_verbose
-  end
-
-  # Blocks and ignores any exception passed as argument if raised within the block.
-  #
-  #   suppress(ZeroDivisionError) do
-  #     1/0
-  #     puts 'This code is NOT reached'
-  #   end
-  #
-  #   puts 'This code gets executed and nothing related to ZeroDivisionError was seen'
-  def suppress(*exception_classes)
-    yield
-  rescue *exception_classes
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/kernel/singleton_class.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/kernel/singleton_class.rb
deleted file mode 100644
index 6715eba80a0b4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/kernel/singleton_class.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Kernel
-  # class_eval on an object acts like singleton_class.class_eval.
-  def class_eval(*args, &block)
-    singleton_class.class_eval(*args, &block)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/load_error.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/load_error.rb
deleted file mode 100644
index 03df2ddac4268..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/load_error.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class LoadError
-  # Returns true if the given path name (except perhaps for the ".rb"
-  # extension) is the missing file which caused the exception to be raised.
-  def is_missing?(location)
-    location.delete_suffix(".rb") == path.to_s.delete_suffix(".rb")
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/marshal.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/marshal.rb
deleted file mode 100644
index 5ff0e34d8245b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/marshal.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/string/inflections"
-
-module ActiveSupport
-  module MarshalWithAutoloading # :nodoc:
-    def load(source, proc = nil)
-      super(source, proc)
-    rescue ArgumentError, NameError => exc
-      if exc.message.match(%r|undefined class/module (.+?)(?:::)?\z|)
-        # try loading the class/module
-        loaded = $1.constantize
-
-        raise unless $1 == loaded.name
-
-        # if it is an IO we need to go back to read the object
-        source.rewind if source.respond_to?(:rewind)
-        retry
-      else
-        raise exc
-      end
-    end
-  end
-end
-
-Marshal.singleton_class.prepend(ActiveSupport::MarshalWithAutoloading)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module.rb
deleted file mode 100644
index 542af98c04f7d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/aliasing"
-require "active_support/core_ext/module/introspection"
-require "active_support/core_ext/module/anonymous"
-require "active_support/core_ext/module/attribute_accessors"
-require "active_support/core_ext/module/attribute_accessors_per_thread"
-require "active_support/core_ext/module/attr_internal"
-require "active_support/core_ext/module/concerning"
-require "active_support/core_ext/module/delegation"
-require "active_support/core_ext/module/deprecation"
-require "active_support/core_ext/module/redefine_method"
-require "active_support/core_ext/module/remove_method"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/aliasing.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/aliasing.rb
deleted file mode 100644
index 6f64d11627197..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/aliasing.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-class Module
-  # Allows you to make aliases for attributes, which includes
-  # getter, setter, and a predicate.
-  #
-  #   class Content < ActiveRecord::Base
-  #     # has a title attribute
-  #   end
-  #
-  #   class Email < Content
-  #     alias_attribute :subject, :title
-  #   end
-  #
-  #   e = Email.find(1)
-  #   e.title    # => "Superstars"
-  #   e.subject  # => "Superstars"
-  #   e.subject? # => true
-  #   e.subject = "Megastars"
-  #   e.title    # => "Megastars"
-  def alias_attribute(new_name, old_name)
-    # The following reader methods use an explicit `self` receiver in order to
-    # support aliases that start with an uppercase letter. Otherwise, they would
-    # be resolved as constants instead.
-    module_eval <<-STR, __FILE__, __LINE__ + 1
-      def #{new_name}; self.#{old_name}; end          # def subject; self.title; end
-      def #{new_name}?; self.#{old_name}?; end        # def subject?; self.title?; end
-      def #{new_name}=(v); self.#{old_name} = v; end  # def subject=(v); self.title = v; end
-    STR
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/anonymous.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/anonymous.rb
deleted file mode 100644
index d1c86b8722d51..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/anonymous.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-class Module
-  # A module may or may not have a name.
-  #
-  #   module M; end
-  #   M.name # => "M"
-  #
-  #   m = Module.new
-  #   m.name # => nil
-  #
-  # +anonymous?+ method returns true if module does not have a name, false otherwise:
-  #
-  #   Module.new.anonymous? # => true
-  #
-  #   module M; end
-  #   M.anonymous?          # => false
-  #
-  # A module gets a name when it is first assigned to a constant. Either
-  # via the +module+ or +class+ keyword or by an explicit assignment:
-  #
-  #   m = Module.new # creates an anonymous module
-  #   m.anonymous?   # => true
-  #   M = m          # m gets a name here as a side-effect
-  #   m.name         # => "M"
-  #   m.anonymous?   # => false
-  def anonymous?
-    name.nil?
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/attr_internal.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/attr_internal.rb
deleted file mode 100644
index 3bd66ff3bcee5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/attr_internal.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-class Module
-  # Declares an attribute reader backed by an internally-named instance variable.
-  def attr_internal_reader(*attrs)
-    attrs.each { |attr_name| attr_internal_define(attr_name, :reader) }
-  end
-
-  # Declares an attribute writer backed by an internally-named instance variable.
-  def attr_internal_writer(*attrs)
-    attrs.each { |attr_name| attr_internal_define(attr_name, :writer) }
-  end
-
-  # Declares an attribute reader and writer backed by an internally-named instance
-  # variable.
-  def attr_internal_accessor(*attrs)
-    attr_internal_reader(*attrs)
-    attr_internal_writer(*attrs)
-  end
-  alias_method :attr_internal, :attr_internal_accessor
-
-  class << self; attr_accessor :attr_internal_naming_format end
-  self.attr_internal_naming_format = "@_%s"
-
-  private
-    def attr_internal_ivar_name(attr)
-      Module.attr_internal_naming_format % attr
-    end
-
-    def attr_internal_define(attr_name, type)
-      internal_name = attr_internal_ivar_name(attr_name).delete_prefix("@")
-      # use native attr_* methods as they are faster on some Ruby implementations
-      public_send("attr_#{type}", internal_name)
-      attr_name, internal_name = "#{attr_name}=", "#{internal_name}=" if type == :writer
-      alias_method attr_name, internal_name
-      remove_method internal_name
-    end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/attribute_accessors.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/attribute_accessors.rb
deleted file mode 100644
index 1db905ff658d4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/attribute_accessors.rb
+++ /dev/null
@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-# Extends the module object with class/module and instance accessors for
-# class/module attributes, just like the native attr* accessors for instance
-# attributes.
-class Module
-  # Defines a class attribute and creates a class and instance reader methods.
-  # The underlying class variable is set to +nil+, if it is not previously
-  # defined. All class and instance methods created will be public, even if
-  # this method is called with a private or protected access modifier.
-  #
-  #   module HairColors
-  #     mattr_reader :hair_colors
-  #   end
-  #
-  #   HairColors.hair_colors # => nil
-  #   HairColors.class_variable_set("@@hair_colors", [:brown, :black])
-  #   HairColors.hair_colors # => [:brown, :black]
-  #
-  # The attribute name must be a valid method name in Ruby.
-  #
-  #   module Foo
-  #     mattr_reader :"1_Badname"
-  #   end
-  #   # => NameError: invalid attribute name: 1_Badname
-  #
-  # To omit the instance reader method, pass
-  # <tt>instance_reader: false</tt> or <tt>instance_accessor: false</tt>.
-  #
-  #   module HairColors
-  #     mattr_reader :hair_colors, instance_reader: false
-  #   end
-  #
-  #   class Person
-  #     include HairColors
-  #   end
-  #
-  #   Person.new.hair_colors # => NoMethodError
-  #
-  # You can set a default value for the attribute.
-  #
-  #   module HairColors
-  #     mattr_reader :hair_colors, default: [:brown, :black, :blonde, :red]
-  #   end
-  #
-  #   class Person
-  #     include HairColors
-  #   end
-  #
-  #   Person.new.hair_colors # => [:brown, :black, :blonde, :red]
-  def mattr_reader(*syms, instance_reader: true, instance_accessor: true, default: nil, location: nil)
-    raise TypeError, "module attributes should be defined directly on class, not singleton" if singleton_class?
-    location ||= caller_locations(1, 1).first
-
-    definition = []
-    syms.each do |sym|
-      raise NameError.new("invalid attribute name: #{sym}") unless /\A[_A-Za-z]\w*\z/.match?(sym)
-
-      definition << "def self.#{sym}; @@#{sym}; end"
-
-      if instance_reader && instance_accessor
-        definition << "def #{sym}; @@#{sym}; end"
-      end
-
-      sym_default_value = (block_given? && default.nil?) ? yield : default
-      class_variable_set("@@#{sym}", sym_default_value) unless sym_default_value.nil? && class_variable_defined?("@@#{sym}")
-    end
-
-    module_eval(definition.join(";"), location.path, location.lineno)
-  end
-  alias :cattr_reader :mattr_reader
-
-  # Defines a class attribute and creates a class and instance writer methods to
-  # allow assignment to the attribute. All class and instance methods created
-  # will be public, even if this method is called with a private or protected
-  # access modifier.
-  #
-  #   module HairColors
-  #     mattr_writer :hair_colors
-  #   end
-  #
-  #   class Person
-  #     include HairColors
-  #   end
-  #
-  #   HairColors.hair_colors = [:brown, :black]
-  #   Person.class_variable_get("@@hair_colors") # => [:brown, :black]
-  #   Person.new.hair_colors = [:blonde, :red]
-  #   HairColors.class_variable_get("@@hair_colors") # => [:blonde, :red]
-  #
-  # To omit the instance writer method, pass
-  # <tt>instance_writer: false</tt> or <tt>instance_accessor: false</tt>.
-  #
-  #   module HairColors
-  #     mattr_writer :hair_colors, instance_writer: false
-  #   end
-  #
-  #   class Person
-  #     include HairColors
-  #   end
-  #
-  #   Person.new.hair_colors = [:blonde, :red] # => NoMethodError
-  #
-  # You can set a default value for the attribute.
-  #
-  #   module HairColors
-  #     mattr_writer :hair_colors, default: [:brown, :black, :blonde, :red]
-  #   end
-  #
-  #   class Person
-  #     include HairColors
-  #   end
-  #
-  #   Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]
-  def mattr_writer(*syms, instance_writer: true, instance_accessor: true, default: nil, location: nil)
-    raise TypeError, "module attributes should be defined directly on class, not singleton" if singleton_class?
-    location ||= caller_locations(1, 1).first
-
-    definition = []
-    syms.each do |sym|
-      raise NameError.new("invalid attribute name: #{sym}") unless /\A[_A-Za-z]\w*\z/.match?(sym)
-      definition << "def self.#{sym}=(val); @@#{sym} = val; end"
-
-      if instance_writer && instance_accessor
-        definition << "def #{sym}=(val); @@#{sym} = val; end"
-      end
-
-      sym_default_value = (block_given? && default.nil?) ? yield : default
-      class_variable_set("@@#{sym}", sym_default_value) unless sym_default_value.nil? && class_variable_defined?("@@#{sym}")
-    end
-
-    module_eval(definition.join(";"), location.path, location.lineno)
-  end
-  alias :cattr_writer :mattr_writer
-
-  # Defines both class and instance accessors for class attributes.
-  # All class and instance methods created will be public, even if
-  # this method is called with a private or protected access modifier.
-  #
-  #   module HairColors
-  #     mattr_accessor :hair_colors
-  #   end
-  #
-  #   class Person
-  #     include HairColors
-  #   end
-  #
-  #   HairColors.hair_colors = [:brown, :black, :blonde, :red]
-  #   HairColors.hair_colors # => [:brown, :black, :blonde, :red]
-  #   Person.new.hair_colors # => [:brown, :black, :blonde, :red]
-  #
-  # If a subclass changes the value then that would also change the value for
-  # parent class. Similarly if parent class changes the value then that would
-  # change the value of subclasses too.
-  #
-  #   class Citizen < Person
-  #   end
-  #
-  #   Citizen.new.hair_colors << :blue
-  #   Person.new.hair_colors # => [:brown, :black, :blonde, :red, :blue]
-  #
-  # To omit the instance writer method, pass <tt>instance_writer: false</tt>.
-  # To omit the instance reader method, pass <tt>instance_reader: false</tt>.
-  #
-  #   module HairColors
-  #     mattr_accessor :hair_colors, instance_writer: false, instance_reader: false
-  #   end
-  #
-  #   class Person
-  #     include HairColors
-  #   end
-  #
-  #   Person.new.hair_colors = [:brown]  # => NoMethodError
-  #   Person.new.hair_colors             # => NoMethodError
-  #
-  # Or pass <tt>instance_accessor: false</tt>, to omit both instance methods.
-  #
-  #   module HairColors
-  #     mattr_accessor :hair_colors, instance_accessor: false
-  #   end
-  #
-  #   class Person
-  #     include HairColors
-  #   end
-  #
-  #   Person.new.hair_colors = [:brown]  # => NoMethodError
-  #   Person.new.hair_colors             # => NoMethodError
-  #
-  # You can set a default value for the attribute.
-  #
-  #   module HairColors
-  #     mattr_accessor :hair_colors, default: [:brown, :black, :blonde, :red]
-  #   end
-  #
-  #   class Person
-  #     include HairColors
-  #   end
-  #
-  #   Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]
-  def mattr_accessor(*syms, instance_reader: true, instance_writer: true, instance_accessor: true, default: nil, &blk)
-    location = caller_locations(1, 1).first
-    mattr_reader(*syms, instance_reader: instance_reader, instance_accessor: instance_accessor, default: default, location: location, &blk)
-    mattr_writer(*syms, instance_writer: instance_writer, instance_accessor: instance_accessor, default: default, location: location)
-  end
-  alias :cattr_accessor :mattr_accessor
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb
deleted file mode 100644
index ea4034303e1c0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb
+++ /dev/null
@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-# Extends the module object with class/module and instance accessors for
-# class/module attributes, just like the native attr* accessors for instance
-# attributes, but does so on a per-thread basis.
-#
-# So the values are scoped within the Thread.current space under the class name
-# of the module.
-class Module
-  # Defines a per-thread class attribute and creates class and instance reader methods.
-  # The underlying per-thread class variable is set to +nil+, if it is not previously defined.
-  #
-  #   module Current
-  #     thread_mattr_reader :user
-  #   end
-  #
-  #   Current.user # => nil
-  #   Thread.current[:attr_Current_user] = "DHH"
-  #   Current.user # => "DHH"
-  #
-  # The attribute name must be a valid method name in Ruby.
-  #
-  #   module Foo
-  #     thread_mattr_reader :"1_Badname"
-  #   end
-  #   # => NameError: invalid attribute name: 1_Badname
-  #
-  # To omit the instance reader method, pass
-  # <tt>instance_reader: false</tt> or <tt>instance_accessor: false</tt>.
-  #
-  #   class Current
-  #     thread_mattr_reader :user, instance_reader: false
-  #   end
-  #
-  #   Current.new.user # => NoMethodError
-  def thread_mattr_reader(*syms, instance_reader: true, instance_accessor: true, default: nil) # :nodoc:
-    syms.each do |sym|
-      raise NameError.new("invalid attribute name: #{sym}") unless /^[_A-Za-z]\w*$/.match?(sym)
-
-      # The following generated method concatenates `name` because we want it
-      # to work with inheritance via polymorphism.
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}
-          Thread.current["attr_" + name + "_#{sym}"]
-        end
-      EOS
-
-      if instance_reader && instance_accessor
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}
-            self.class.#{sym}
-          end
-        EOS
-      end
-
-      Thread.current["attr_" + name + "_#{sym}"] = default unless default.nil?
-    end
-  end
-  alias :thread_cattr_reader :thread_mattr_reader
-
-  # Defines a per-thread class attribute and creates a class and instance writer methods to
-  # allow assignment to the attribute.
-  #
-  #   module Current
-  #     thread_mattr_writer :user
-  #   end
-  #
-  #   Current.user = "DHH"
-  #   Thread.current[:attr_Current_user] # => "DHH"
-  #
-  # To omit the instance writer method, pass
-  # <tt>instance_writer: false</tt> or <tt>instance_accessor: false</tt>.
-  #
-  #   class Current
-  #     thread_mattr_writer :user, instance_writer: false
-  #   end
-  #
-  #   Current.new.user = "DHH" # => NoMethodError
-  def thread_mattr_writer(*syms, instance_writer: true, instance_accessor: true, default: nil) # :nodoc:
-    syms.each do |sym|
-      raise NameError.new("invalid attribute name: #{sym}") unless /^[_A-Za-z]\w*$/.match?(sym)
-
-      # The following generated method concatenates `name` because we want it
-      # to work with inheritance via polymorphism.
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}=(obj)
-          Thread.current["attr_" + name + "_#{sym}"] = obj
-        end
-      EOS
-
-      if instance_writer && instance_accessor
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}=(obj)
-            self.class.#{sym} = obj
-          end
-        EOS
-      end
-
-      public_send("#{sym}=", default) unless default.nil?
-    end
-  end
-  alias :thread_cattr_writer :thread_mattr_writer
-
-  # Defines both class and instance accessors for class attributes.
-  #
-  #   class Account
-  #     thread_mattr_accessor :user
-  #   end
-  #
-  #   Account.user = "DHH"
-  #   Account.user     # => "DHH"
-  #   Account.new.user # => "DHH"
-  #
-  # If a subclass changes the value, the parent class' value is not changed.
-  # Similarly, if the parent class changes the value, the value of subclasses
-  # is not changed.
-  #
-  #   class Customer < Account
-  #   end
-  #
-  #   Customer.user = "Rafael"
-  #   Customer.user # => "Rafael"
-  #   Account.user  # => "DHH"
-  #
-  # To omit the instance writer method, pass <tt>instance_writer: false</tt>.
-  # To omit the instance reader method, pass <tt>instance_reader: false</tt>.
-  #
-  #   class Current
-  #     thread_mattr_accessor :user, instance_writer: false, instance_reader: false
-  #   end
-  #
-  #   Current.new.user = "DHH"  # => NoMethodError
-  #   Current.new.user          # => NoMethodError
-  #
-  # Or pass <tt>instance_accessor: false</tt>, to omit both instance methods.
-  #
-  #   class Current
-  #     thread_mattr_accessor :user, instance_accessor: false
-  #   end
-  #
-  #   Current.new.user = "DHH"  # => NoMethodError
-  #   Current.new.user          # => NoMethodError
-  def thread_mattr_accessor(*syms, instance_reader: true, instance_writer: true, instance_accessor: true, default: nil)
-    thread_mattr_reader(*syms, instance_reader: instance_reader, instance_accessor: instance_accessor, default: default)
-    thread_mattr_writer(*syms, instance_writer: instance_writer, instance_accessor: instance_accessor)
-  end
-  alias :thread_cattr_accessor :thread_mattr_accessor
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/concerning.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/concerning.rb
deleted file mode 100644
index 36f5f85937cf9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/concerning.rb
+++ /dev/null
@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-
-class Module
-  # = Bite-sized separation of concerns
-  #
-  # We often find ourselves with a medium-sized chunk of behavior that we'd
-  # like to extract, but only mix in to a single class.
-  #
-  # Extracting a plain old Ruby object to encapsulate it and collaborate or
-  # delegate to the original object is often a good choice, but when there's
-  # no additional state to encapsulate or we're making DSL-style declarations
-  # about the parent class, introducing new collaborators can obfuscate rather
-  # than simplify.
-  #
-  # The typical route is to just dump everything in a monolithic class, perhaps
-  # with a comment, as a least-bad alternative. Using modules in separate files
-  # means tedious sifting to get a big-picture view.
-  #
-  # = Dissatisfying ways to separate small concerns
-  #
-  # == Using comments:
-  #
-  #   class Todo < ApplicationRecord
-  #     # Other todo implementation
-  #     # ...
-  #
-  #     ## Event tracking
-  #     has_many :events
-  #
-  #     before_create :track_creation
-  #
-  #     private
-  #       def track_creation
-  #         # ...
-  #       end
-  #   end
-  #
-  # == With an inline module:
-  #
-  # Noisy syntax.
-  #
-  #   class Todo < ApplicationRecord
-  #     # Other todo implementation
-  #     # ...
-  #
-  #     module EventTracking
-  #       extend ActiveSupport::Concern
-  #
-  #       included do
-  #         has_many :events
-  #         before_create :track_creation
-  #       end
-  #
-  #       private
-  #         def track_creation
-  #           # ...
-  #         end
-  #     end
-  #     include EventTracking
-  #   end
-  #
-  # == Mix-in noise exiled to its own file:
-  #
-  # Once our chunk of behavior starts pushing the scroll-to-understand-it
-  # boundary, we give in and move it to a separate file. At this size, the
-  # increased overhead can be a reasonable tradeoff even if it reduces our
-  # at-a-glance perception of how things work.
-  #
-  #   class Todo < ApplicationRecord
-  #     # Other todo implementation
-  #     # ...
-  #
-  #     include TodoEventTracking
-  #   end
-  #
-  # = Introducing Module#concerning
-  #
-  # By quieting the mix-in noise, we arrive at a natural, low-ceremony way to
-  # separate bite-sized concerns.
-  #
-  #   class Todo < ApplicationRecord
-  #     # Other todo implementation
-  #     # ...
-  #
-  #     concerning :EventTracking do
-  #       included do
-  #         has_many :events
-  #         before_create :track_creation
-  #       end
-  #
-  #       private
-  #         def track_creation
-  #           # ...
-  #         end
-  #     end
-  #   end
-  #
-  #   Todo.ancestors
-  #   # => [Todo, Todo::EventTracking, ApplicationRecord, Object]
-  #
-  # This small step has some wonderful ripple effects. We can
-  # * grok the behavior of our class in one glance,
-  # * clean up monolithic junk-drawer classes by separating their concerns, and
-  # * stop leaning on protected/private for crude "this is internal stuff" modularity.
-  #
-  # === Prepending concerning
-  #
-  # <tt>concerning</tt> supports a <tt>prepend: true</tt> argument which will <tt>prepend</tt> the
-  # concern instead of using <tt>include</tt> for it.
-  module Concerning
-    # Define a new concern and mix it in.
-    def concerning(topic, prepend: false, &block)
-      method = prepend ? :prepend : :include
-      __send__(method, concern(topic, &block))
-    end
-
-    # A low-cruft shortcut to define a concern.
-    #
-    #   concern :EventTracking do
-    #     ...
-    #   end
-    #
-    # is equivalent to
-    #
-    #   module EventTracking
-    #     extend ActiveSupport::Concern
-    #
-    #     ...
-    #   end
-    def concern(topic, &module_definition)
-      const_set topic, Module.new {
-        extend ::ActiveSupport::Concern
-        module_eval(&module_definition)
-      }
-    end
-  end
-  include Concerning
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/delegation.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/delegation.rb
deleted file mode 100644
index a44a3e7c748bd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/delegation.rb
+++ /dev/null
@@ -1,330 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-
-class Module
-  # Error generated by +delegate+ when a method is called on +nil+ and +allow_nil+
-  # option is not used.
-  class DelegationError < NoMethodError; end
-
-  RUBY_RESERVED_KEYWORDS = %w(alias and BEGIN begin break case class def defined? do
-  else elsif END end ensure false for if in module next nil not or redo rescue retry
-  return self super then true undef unless until when while yield)
-  DELEGATION_RESERVED_KEYWORDS = %w(_ arg args block)
-  DELEGATION_RESERVED_METHOD_NAMES = Set.new(
-    RUBY_RESERVED_KEYWORDS + DELEGATION_RESERVED_KEYWORDS
-  ).freeze
-
-  # Provides a +delegate+ class method to easily expose contained objects'
-  # public methods as your own.
-  #
-  # ==== Options
-  # * <tt>:to</tt> - Specifies the target object name as a symbol or string
-  # * <tt>:prefix</tt> - Prefixes the new method with the target name or a custom prefix
-  # * <tt>:allow_nil</tt> - If set to true, prevents a +Module::DelegationError+
-  #   from being raised
-  # * <tt>:private</tt> - If set to true, changes method visibility to private
-  #
-  # The macro receives one or more method names (specified as symbols or
-  # strings) and the name of the target object via the <tt>:to</tt> option
-  # (also a symbol or string).
-  #
-  # Delegation is particularly useful with Active Record associations:
-  #
-  #   class Greeter < ActiveRecord::Base
-  #     def hello
-  #       'hello'
-  #     end
-  #
-  #     def goodbye
-  #       'goodbye'
-  #     end
-  #   end
-  #
-  #   class Foo < ActiveRecord::Base
-  #     belongs_to :greeter
-  #     delegate :hello, to: :greeter
-  #   end
-  #
-  #   Foo.new.hello   # => "hello"
-  #   Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
-  #
-  # Multiple delegates to the same target are allowed:
-  #
-  #   class Foo < ActiveRecord::Base
-  #     belongs_to :greeter
-  #     delegate :hello, :goodbye, to: :greeter
-  #   end
-  #
-  #   Foo.new.goodbye # => "goodbye"
-  #
-  # Methods can be delegated to instance variables, class variables, or constants
-  # by providing them as a symbols:
-  #
-  #   class Foo
-  #     CONSTANT_ARRAY = [0,1,2,3]
-  #     @@class_array  = [4,5,6,7]
-  #
-  #     def initialize
-  #       @instance_array = [8,9,10,11]
-  #     end
-  #     delegate :sum, to: :CONSTANT_ARRAY
-  #     delegate :min, to: :@@class_array
-  #     delegate :max, to: :@instance_array
-  #   end
-  #
-  #   Foo.new.sum # => 6
-  #   Foo.new.min # => 4
-  #   Foo.new.max # => 11
-  #
-  # It's also possible to delegate a method to the class by using +:class+:
-  #
-  #   class Foo
-  #     def self.hello
-  #       "world"
-  #     end
-  #
-  #     delegate :hello, to: :class
-  #   end
-  #
-  #   Foo.new.hello # => "world"
-  #
-  # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
-  # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
-  # delegated to.
-  #
-  #   Person = Struct.new(:name, :address)
-  #
-  #   class Invoice < Struct.new(:client)
-  #     delegate :name, :address, to: :client, prefix: true
-  #   end
-  #
-  #   john_doe = Person.new('John Doe', 'Vimmersvej 13')
-  #   invoice = Invoice.new(john_doe)
-  #   invoice.client_name    # => "John Doe"
-  #   invoice.client_address # => "Vimmersvej 13"
-  #
-  # It is also possible to supply a custom prefix.
-  #
-  #   class Invoice < Struct.new(:client)
-  #     delegate :name, :address, to: :client, prefix: :customer
-  #   end
-  #
-  #   invoice = Invoice.new(john_doe)
-  #   invoice.customer_name    # => 'John Doe'
-  #   invoice.customer_address # => 'Vimmersvej 13'
-  #
-  # The delegated methods are public by default.
-  # Pass <tt>private: true</tt> to change that.
-  #
-  #   class User < ActiveRecord::Base
-  #     has_one :profile
-  #     delegate :first_name, to: :profile
-  #     delegate :date_of_birth, to: :profile, private: true
-  #
-  #     def age
-  #       Date.today.year - date_of_birth.year
-  #     end
-  #   end
-  #
-  #   User.new.first_name # => "Tomas"
-  #   User.new.date_of_birth # => NoMethodError: private method `date_of_birth' called for #<User:0x00000008221340>
-  #   User.new.age # => 2
-  #
-  # If the target is +nil+ and does not respond to the delegated method a
-  # +Module::DelegationError+ is raised. If you wish to instead return +nil+,
-  # use the <tt>:allow_nil</tt> option.
-  #
-  #   class User < ActiveRecord::Base
-  #     has_one :profile
-  #     delegate :age, to: :profile
-  #   end
-  #
-  #   User.new.age
-  #   # => Module::DelegationError: User#age delegated to profile.age, but profile is nil
-  #
-  # But if not having a profile yet is fine and should not be an error
-  # condition:
-  #
-  #   class User < ActiveRecord::Base
-  #     has_one :profile
-  #     delegate :age, to: :profile, allow_nil: true
-  #   end
-  #
-  #   User.new.age # nil
-  #
-  # Note that if the target is not +nil+ then the call is attempted regardless of the
-  # <tt>:allow_nil</tt> option, and thus an exception is still raised if said object
-  # does not respond to the method:
-  #
-  #   class Foo
-  #     def initialize(bar)
-  #       @bar = bar
-  #     end
-  #
-  #     delegate :name, to: :@bar, allow_nil: true
-  #   end
-  #
-  #   Foo.new("Bar").name # raises NoMethodError: undefined method `name'
-  #
-  # The target method must be public, otherwise it will raise +NoMethodError+.
-  def delegate(*methods, to: nil, prefix: nil, allow_nil: nil, private: nil)
-    unless to
-      raise ArgumentError, "Delegation needs a target. Supply a keyword argument 'to' (e.g. delegate :hello, to: :greeter)."
-    end
-
-    if prefix == true && /^[^a-z_]/.match?(to)
-      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
-    end
-
-    method_prefix = \
-      if prefix
-        "#{prefix == true ? to : prefix}_"
-      else
-        ""
-      end
-
-    location = caller_locations(1, 1).first
-    file, line = location.path, location.lineno
-
-    to = to.to_s
-    to = "self.#{to}" if DELEGATION_RESERVED_METHOD_NAMES.include?(to)
-
-    method_def = []
-    method_names = []
-
-    methods.map do |method|
-      method_name = prefix ? "#{method_prefix}#{method}" : method
-      method_names << method_name.to_sym
-
-      # Attribute writer methods only accept one argument. Makes sure []=
-      # methods still accept two arguments.
-      definition = if /[^\]]=$/.match?(method)
-        "arg"
-      elsif RUBY_VERSION >= "2.7"
-        "..."
-      else
-        "*args, &block"
-      end
-
-      # The following generated method calls the target exactly once, storing
-      # the returned value in a dummy variable.
-      #
-      # Reason is twofold: On one hand doing less calls is in general better.
-      # On the other hand it could be that the target has side-effects,
-      # whereas conceptually, from the user point of view, the delegator should
-      # be doing one call.
-      if allow_nil
-        method = method.to_s
-
-        method_def <<
-          "def #{method_name}(#{definition})" <<
-          "  _ = #{to}" <<
-          "  if !_.nil? || nil.respond_to?(:#{method})" <<
-          "    _.#{method}(#{definition})" <<
-          "  end" <<
-          "end"
-      else
-        method = method.to_s
-        method_name = method_name.to_s
-
-        method_def <<
-          "def #{method_name}(#{definition})" <<
-          "  _ = #{to}" <<
-          "  _.#{method}(#{definition})" <<
-          "rescue NoMethodError => e" <<
-          "  if _.nil? && e.name == :#{method}" <<
-          %(   raise DelegationError, "#{self}##{method_name} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}") <<
-          "  else" <<
-          "    raise" <<
-          "  end" <<
-          "end"
-      end
-    end
-    module_eval(method_def.join(";"), file, line)
-    private(*method_names) if private
-    method_names
-  end
-
-  # When building decorators, a common pattern may emerge:
-  #
-  #   class Partition
-  #     def initialize(event)
-  #       @event = event
-  #     end
-  #
-  #     def person
-  #       detail.person || creator
-  #     end
-  #
-  #     private
-  #       def respond_to_missing?(name, include_private = false)
-  #         @event.respond_to?(name, include_private)
-  #       end
-  #
-  #       def method_missing(method, *args, &block)
-  #         @event.send(method, *args, &block)
-  #       end
-  #   end
-  #
-  # With <tt>Module#delegate_missing_to</tt>, the above is condensed to:
-  #
-  #   class Partition
-  #     delegate_missing_to :@event
-  #
-  #     def initialize(event)
-  #       @event = event
-  #     end
-  #
-  #     def person
-  #       detail.person || creator
-  #     end
-  #   end
-  #
-  # The target can be anything callable within the object, e.g. instance
-  # variables, methods, constants, etc.
-  #
-  # The delegated method must be public on the target, otherwise it will
-  # raise +DelegationError+. If you wish to instead return +nil+,
-  # use the <tt>:allow_nil</tt> option.
-  #
-  # The <tt>marshal_dump</tt> and <tt>_dump</tt> methods are exempt from
-  # delegation due to possible interference when calling
-  # <tt>Marshal.dump(object)</tt>, should the delegation target method
-  # of <tt>object</tt> add or remove instance variables.
-  def delegate_missing_to(target, allow_nil: nil)
-    target = target.to_s
-    target = "self.#{target}" if DELEGATION_RESERVED_METHOD_NAMES.include?(target)
-
-    module_eval <<-RUBY, __FILE__, __LINE__ + 1
-      def respond_to_missing?(name, include_private = false)
-        # It may look like an oversight, but we deliberately do not pass
-        # +include_private+, because they do not get delegated.
-
-        return false if name == :marshal_dump || name == :_dump
-        #{target}.respond_to?(name) || super
-      end
-
-      def method_missing(method, *args, &block)
-        if #{target}.respond_to?(method)
-          #{target}.public_send(method, *args, &block)
-        else
-          begin
-            super
-          rescue NoMethodError
-            if #{target}.nil?
-              if #{allow_nil == true}
-                nil
-              else
-                raise DelegationError, "\#{method} delegated to #{target}, but #{target} is nil"
-              end
-            else
-              raise
-            end
-          end
-        end
-      end
-      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
-    RUBY
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/deprecation.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/deprecation.rb
deleted file mode 100644
index 71c42eb3575c9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/deprecation.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-class Module
-  #   deprecate :foo
-  #   deprecate bar: 'message'
-  #   deprecate :foo, :bar, baz: 'warning!', qux: 'gone!'
-  #
-  # You can also use custom deprecator instance:
-  #
-  #   deprecate :foo, deprecator: MyLib::Deprecator.new
-  #   deprecate :foo, bar: "warning!", deprecator: MyLib::Deprecator.new
-  #
-  # \Custom deprecators must respond to <tt>deprecation_warning(deprecated_method_name, message, caller_backtrace)</tt>
-  # method where you can implement your custom warning behavior.
-  #
-  #   class MyLib::Deprecator
-  #     def deprecation_warning(deprecated_method_name, message, caller_backtrace = nil)
-  #       message = "#{deprecated_method_name} is deprecated and will be removed from MyLibrary | #{message}"
-  #       Kernel.warn message
-  #     end
-  #   end
-  def deprecate(*method_names)
-    ActiveSupport::Deprecation.deprecate_methods(self, *method_names)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/introspection.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/introspection.rb
deleted file mode 100644
index 7cdcab59b8a76..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/introspection.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/string/filters"
-require "active_support/inflector"
-
-class Module
-  # Returns the name of the module containing this one.
-  #
-  #   M::N.module_parent_name # => "M"
-  def module_parent_name
-    if defined?(@parent_name)
-      @parent_name
-    else
-      parent_name = name =~ /::[^:]+\z/ ? -$` : nil
-      @parent_name = parent_name unless frozen?
-      parent_name
-    end
-  end
-
-  # Returns the module which contains this one according to its name.
-  #
-  #   module M
-  #     module N
-  #     end
-  #   end
-  #   X = M::N
-  #
-  #   M::N.module_parent # => M
-  #   X.module_parent    # => M
-  #
-  # The parent of top-level and anonymous modules is Object.
-  #
-  #   M.module_parent          # => Object
-  #   Module.new.module_parent # => Object
-  def module_parent
-    module_parent_name ? ActiveSupport::Inflector.constantize(module_parent_name) : Object
-  end
-
-  # Returns all the parents of this module according to its name, ordered from
-  # nested outwards. The receiver is not contained within the result.
-  #
-  #   module M
-  #     module N
-  #     end
-  #   end
-  #   X = M::N
-  #
-  #   M.module_parents    # => [Object]
-  #   M::N.module_parents # => [M, Object]
-  #   X.module_parents    # => [M, Object]
-  def module_parents
-    parents = []
-    if module_parent_name
-      parts = module_parent_name.split("::")
-      until parts.empty?
-        parents << ActiveSupport::Inflector.constantize(parts * "::")
-        parts.pop
-      end
-    end
-    parents << Object unless parents.include? Object
-    parents
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/redefine_method.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/redefine_method.rb
deleted file mode 100644
index 5bd8e6e973a3b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/redefine_method.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-class Module
-  # Marks the named method as intended to be redefined, if it exists.
-  # Suppresses the Ruby method redefinition warning. Prefer
-  # #redefine_method where possible.
-  def silence_redefinition_of_method(method)
-    if method_defined?(method) || private_method_defined?(method)
-      # This suppresses the "method redefined" warning; the self-alias
-      # looks odd, but means we don't need to generate a unique name
-      alias_method method, method
-    end
-  end
-
-  # Replaces the existing method definition, if there is one, with the passed
-  # block as its body.
-  def redefine_method(method, &block)
-    visibility = method_visibility(method)
-    silence_redefinition_of_method(method)
-    define_method(method, &block)
-    send(visibility, method)
-  end
-
-  # Replaces the existing singleton method definition, if there is one, with
-  # the passed block as its body.
-  def redefine_singleton_method(method, &block)
-    singleton_class.redefine_method(method, &block)
-  end
-
-  def method_visibility(method) # :nodoc:
-    case
-    when private_method_defined?(method)
-      :private
-    when protected_method_defined?(method)
-      :protected
-    else
-      :public
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/remove_method.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/remove_method.rb
deleted file mode 100644
index 97eb5f9eca69d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/module/remove_method.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/redefine_method"
-
-class Module
-  # Removes the named method, if it exists.
-  def remove_possible_method(method)
-    if method_defined?(method) || private_method_defined?(method)
-      undef_method(method)
-    end
-  end
-
-  # Removes the named singleton method, if it exists.
-  def remove_possible_singleton_method(method)
-    singleton_class.remove_possible_method(method)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/name_error.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/name_error.rb
deleted file mode 100644
index 15255d58b9073..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/name_error.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-class NameError
-  # Extract the name of the missing constant from the exception message.
-  #
-  #   begin
-  #     HelloWorld
-  #   rescue NameError => e
-  #     e.missing_name
-  #   end
-  #   # => "HelloWorld"
-  def missing_name
-    # Since ruby v2.3.0 `did_you_mean` gem is loaded by default.
-    # It extends NameError#message with spell corrections which are SLOW.
-    # We should use original_message message instead.
-    message = respond_to?(:original_message) ? original_message : self.message
-    return unless message.start_with?("uninitialized constant ")
-
-    receiver = begin
-      self.receiver
-    rescue ArgumentError
-      nil
-    end
-
-    if receiver == Object
-      name.to_s
-    elsif receiver
-      "#{real_mod_name(receiver)}::#{self.name}"
-    else
-      if match = message.match(/((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/)
-        match[1]
-      end
-    end
-  end
-
-  # Was this exception raised because the given name was missing?
-  #
-  #   begin
-  #     HelloWorld
-  #   rescue NameError => e
-  #     e.missing_name?("HelloWorld")
-  #   end
-  #   # => true
-  def missing_name?(name)
-    if name.is_a? Symbol
-      self.name == name
-    else
-      missing_name == name.to_s
-    end
-  end
-
-  private
-    UNBOUND_METHOD_MODULE_NAME = Module.instance_method(:name)
-    private_constant :UNBOUND_METHOD_MODULE_NAME
-
-    if UnboundMethod.method_defined?(:bind_call)
-      def real_mod_name(mod)
-        UNBOUND_METHOD_MODULE_NAME.bind_call(mod)
-      end
-    else
-      def real_mod_name(mod)
-        UNBOUND_METHOD_MODULE_NAME.bind(mod).call
-      end
-    end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/numeric.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/numeric.rb
deleted file mode 100644
index fe778470f1649..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/numeric.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/numeric/bytes"
-require "active_support/core_ext/numeric/time"
-require "active_support/core_ext/numeric/conversions"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/numeric/bytes.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/numeric/bytes.rb
deleted file mode 100644
index b002eba40690e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/numeric/bytes.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-class Numeric
-  KILOBYTE = 1024
-  MEGABYTE = KILOBYTE * 1024
-  GIGABYTE = MEGABYTE * 1024
-  TERABYTE = GIGABYTE * 1024
-  PETABYTE = TERABYTE * 1024
-  EXABYTE  = PETABYTE * 1024
-
-  # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
-  #
-  #   2.bytes # => 2
-  def bytes
-    self
-  end
-  alias :byte :bytes
-
-  # Returns the number of bytes equivalent to the kilobytes provided.
-  #
-  #   2.kilobytes # => 2048
-  def kilobytes
-    self * KILOBYTE
-  end
-  alias :kilobyte :kilobytes
-
-  # Returns the number of bytes equivalent to the megabytes provided.
-  #
-  #   2.megabytes # => 2_097_152
-  def megabytes
-    self * MEGABYTE
-  end
-  alias :megabyte :megabytes
-
-  # Returns the number of bytes equivalent to the gigabytes provided.
-  #
-  #   2.gigabytes # => 2_147_483_648
-  def gigabytes
-    self * GIGABYTE
-  end
-  alias :gigabyte :gigabytes
-
-  # Returns the number of bytes equivalent to the terabytes provided.
-  #
-  #   2.terabytes # => 2_199_023_255_552
-  def terabytes
-    self * TERABYTE
-  end
-  alias :terabyte :terabytes
-
-  # Returns the number of bytes equivalent to the petabytes provided.
-  #
-  #   2.petabytes # => 2_251_799_813_685_248
-  def petabytes
-    self * PETABYTE
-  end
-  alias :petabyte :petabytes
-
-  # Returns the number of bytes equivalent to the exabytes provided.
-  #
-  #   2.exabytes # => 2_305_843_009_213_693_952
-  def exabytes
-    self * EXABYTE
-  end
-  alias :exabyte :exabytes
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/numeric/conversions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/numeric/conversions.rb
deleted file mode 100644
index 3e623e0d1770b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/numeric/conversions.rb
+++ /dev/null
@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/big_decimal/conversions"
-require "active_support/number_helper"
-
-module ActiveSupport
-  module NumericWithFormat
-    # Provides options for converting numbers into formatted strings.
-    # Options are provided for phone numbers, currency, percentage,
-    # precision, positional notation, file size and pretty printing.
-    #
-    # ==== Options
-    #
-    # For details on which formats use which options, see ActiveSupport::NumberHelper
-    #
-    # ==== Examples
-    #
-    #  Phone Numbers:
-    #  5551234.to_s(:phone)                                     # => "555-1234"
-    #  1235551234.to_s(:phone)                                  # => "123-555-1234"
-    #  1235551234.to_s(:phone, area_code: true)                 # => "(123) 555-1234"
-    #  1235551234.to_s(:phone, delimiter: ' ')                  # => "123 555 1234"
-    #  1235551234.to_s(:phone, area_code: true, extension: 555) # => "(123) 555-1234 x 555"
-    #  1235551234.to_s(:phone, country_code: 1)                 # => "+1-123-555-1234"
-    #  1235551234.to_s(:phone, country_code: 1, extension: 1343, delimiter: '.')
-    #  # => "+1.123.555.1234 x 1343"
-    #
-    #  Currency:
-    #  1234567890.50.to_s(:currency)                     # => "$1,234,567,890.50"
-    #  1234567890.506.to_s(:currency)                    # => "$1,234,567,890.51"
-    #  1234567890.506.to_s(:currency, precision: 3)      # => "$1,234,567,890.506"
-    #  1234567890.506.to_s(:currency, round_mode: :down) # => "$1,234,567,890.50"
-    #  1234567890.506.to_s(:currency, locale: :fr)       # => "1 234 567 890,51 €"
-    #  -1234567890.50.to_s(:currency, negative_format: '(%u%n)')
-    #  # => "($1,234,567,890.50)"
-    #  1234567890.50.to_s(:currency, unit: '&pound;', separator: ',', delimiter: '')
-    #  # => "&pound;1234567890,50"
-    #  1234567890.50.to_s(:currency, unit: '&pound;', separator: ',', delimiter: '', format: '%n %u')
-    #  # => "1234567890,50 &pound;"
-    #
-    #  Percentage:
-    #  100.to_s(:percentage)                                  # => "100.000%"
-    #  100.to_s(:percentage, precision: 0)                    # => "100%"
-    #  1000.to_s(:percentage, delimiter: '.', separator: ',') # => "1.000,000%"
-    #  302.24398923423.to_s(:percentage, precision: 5)        # => "302.24399%"
-    #  302.24398923423.to_s(:percentage, round_mode: :down)   # => "302.243%"
-    #  1000.to_s(:percentage, locale: :fr)                    # => "1 000,000%"
-    #  100.to_s(:percentage, format: '%n  %')                 # => "100.000  %"
-    #
-    #  Delimited:
-    #  12345678.to_s(:delimited)                     # => "12,345,678"
-    #  12345678.05.to_s(:delimited)                  # => "12,345,678.05"
-    #  12345678.to_s(:delimited, delimiter: '.')     # => "12.345.678"
-    #  12345678.to_s(:delimited, delimiter: ',')     # => "12,345,678"
-    #  12345678.05.to_s(:delimited, separator: ' ')  # => "12,345,678 05"
-    #  12345678.05.to_s(:delimited, locale: :fr)     # => "12 345 678,05"
-    #  98765432.98.to_s(:delimited, delimiter: ' ', separator: ',')
-    #  # => "98 765 432,98"
-    #
-    #  Rounded:
-    #  111.2345.to_s(:rounded)                                      # => "111.235"
-    #  111.2345.to_s(:rounded, precision: 2)                        # => "111.23"
-    #  111.2345.to_s(:rounded, precision: 2, round_mode: :up)       # => "111.24"
-    #  13.to_s(:rounded, precision: 5)                              # => "13.00000"
-    #  389.32314.to_s(:rounded, precision: 0)                       # => "389"
-    #  111.2345.to_s(:rounded, significant: true)                   # => "111"
-    #  111.2345.to_s(:rounded, precision: 1, significant: true)     # => "100"
-    #  13.to_s(:rounded, precision: 5, significant: true)           # => "13.000"
-    #  111.234.to_s(:rounded, locale: :fr)                          # => "111,234"
-    #  13.to_s(:rounded, precision: 5, significant: true, strip_insignificant_zeros: true)
-    #  # => "13"
-    #  389.32314.to_s(:rounded, precision: 4, significant: true)    # => "389.3"
-    #  1111.2345.to_s(:rounded, precision: 2, separator: ',', delimiter: '.')
-    #  # => "1.111,23"
-    #
-    #  Human-friendly size in Bytes:
-    #  123.to_s(:human_size)                                    # => "123 Bytes"
-    #  1234.to_s(:human_size)                                   # => "1.21 KB"
-    #  12345.to_s(:human_size)                                  # => "12.1 KB"
-    #  1234567.to_s(:human_size)                                # => "1.18 MB"
-    #  1234567890.to_s(:human_size)                             # => "1.15 GB"
-    #  1234567890123.to_s(:human_size)                          # => "1.12 TB"
-    #  1234567890123456.to_s(:human_size)                       # => "1.1 PB"
-    #  1234567890123456789.to_s(:human_size)                    # => "1.07 EB"
-    #  1234567.to_s(:human_size, precision: 2)                  # => "1.2 MB"
-    #  1234567.to_s(:human_size, precision: 2, round_mode: :up) # => "1.3 MB"
-    #  483989.to_s(:human_size, precision: 2)                   # => "470 KB"
-    #  1234567.to_s(:human_size, precision: 2, separator: ',')  # => "1,2 MB"
-    #  1234567890123.to_s(:human_size, precision: 5)            # => "1.1228 TB"
-    #  524288000.to_s(:human_size, precision: 5)                # => "500 MB"
-    #
-    #  Human-friendly format:
-    #  123.to_s(:human)                                       # => "123"
-    #  1234.to_s(:human)                                      # => "1.23 Thousand"
-    #  12345.to_s(:human)                                     # => "12.3 Thousand"
-    #  1234567.to_s(:human)                                   # => "1.23 Million"
-    #  1234567890.to_s(:human)                                # => "1.23 Billion"
-    #  1234567890123.to_s(:human)                             # => "1.23 Trillion"
-    #  1234567890123456.to_s(:human)                          # => "1.23 Quadrillion"
-    #  1234567890123456789.to_s(:human)                       # => "1230 Quadrillion"
-    #  489939.to_s(:human, precision: 2)                      # => "490 Thousand"
-    #  489939.to_s(:human, precision: 2, round_mode: :down)   # => "480 Thousand"
-    #  489939.to_s(:human, precision: 4)                      # => "489.9 Thousand"
-    #  1234567.to_s(:human, precision: 4,
-    #                   significant: false)                   # => "1.2346 Million"
-    #  1234567.to_s(:human, precision: 1,
-    #                   separator: ',',
-    #                   significant: false)                   # => "1,2 Million"
-    def to_s(format = nil, options = nil)
-      case format
-      when nil
-        super()
-      when Integer, String
-        super(format)
-      when :phone
-        ActiveSupport::NumberHelper.number_to_phone(self, options || {})
-      when :currency
-        ActiveSupport::NumberHelper.number_to_currency(self, options || {})
-      when :percentage
-        ActiveSupport::NumberHelper.number_to_percentage(self, options || {})
-      when :delimited
-        ActiveSupport::NumberHelper.number_to_delimited(self, options || {})
-      when :rounded
-        ActiveSupport::NumberHelper.number_to_rounded(self, options || {})
-      when :human
-        ActiveSupport::NumberHelper.number_to_human(self, options || {})
-      when :human_size
-        ActiveSupport::NumberHelper.number_to_human_size(self, options || {})
-      when Symbol
-        super()
-      else
-        super(format)
-      end
-    end
-  end
-end
-
-Integer.prepend ActiveSupport::NumericWithFormat
-Float.prepend ActiveSupport::NumericWithFormat
-BigDecimal.prepend ActiveSupport::NumericWithFormat
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/numeric/time.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/numeric/time.rb
deleted file mode 100644
index bc4627f7a297b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/numeric/time.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/duration"
-require "active_support/core_ext/time/calculations"
-require "active_support/core_ext/time/acts_like"
-require "active_support/core_ext/date/calculations"
-require "active_support/core_ext/date/acts_like"
-
-class Numeric
-  # Returns a Duration instance matching the number of seconds provided.
-  #
-  #   2.seconds # => 2 seconds
-  def seconds
-    ActiveSupport::Duration.seconds(self)
-  end
-  alias :second :seconds
-
-  # Returns a Duration instance matching the number of minutes provided.
-  #
-  #   2.minutes # => 2 minutes
-  def minutes
-    ActiveSupport::Duration.minutes(self)
-  end
-  alias :minute :minutes
-
-  # Returns a Duration instance matching the number of hours provided.
-  #
-  #   2.hours # => 2 hours
-  def hours
-    ActiveSupport::Duration.hours(self)
-  end
-  alias :hour :hours
-
-  # Returns a Duration instance matching the number of days provided.
-  #
-  #   2.days # => 2 days
-  def days
-    ActiveSupport::Duration.days(self)
-  end
-  alias :day :days
-
-  # Returns a Duration instance matching the number of weeks provided.
-  #
-  #   2.weeks # => 2 weeks
-  def weeks
-    ActiveSupport::Duration.weeks(self)
-  end
-  alias :week :weeks
-
-  # Returns a Duration instance matching the number of fortnights provided.
-  #
-  #   2.fortnights # => 4 weeks
-  def fortnights
-    ActiveSupport::Duration.weeks(self * 2)
-  end
-  alias :fortnight :fortnights
-
-  # Returns the number of milliseconds equivalent to the seconds provided.
-  # Used with the standard time durations.
-  #
-  #   2.in_milliseconds # => 2000
-  #   1.hour.in_milliseconds # => 3600000
-  def in_milliseconds
-    self * 1000
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object.rb
deleted file mode 100644
index efd34cc69209a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/acts_like"
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/object/duplicable"
-require "active_support/core_ext/object/deep_dup"
-require "active_support/core_ext/object/try"
-require "active_support/core_ext/object/inclusion"
-
-require "active_support/core_ext/object/conversions"
-require "active_support/core_ext/object/instance_variables"
-
-require "active_support/core_ext/object/json"
-require "active_support/core_ext/object/to_param"
-require "active_support/core_ext/object/to_query"
-require "active_support/core_ext/object/with_options"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/acts_like.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/acts_like.rb
deleted file mode 100644
index 403ee20e398c6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/acts_like.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-class Object
-  # A duck-type assistant method. For example, Active Support extends Date
-  # to define an <tt>acts_like_date?</tt> method, and extends Time to define
-  # <tt>acts_like_time?</tt>. As a result, we can do <tt>x.acts_like?(:time)</tt> and
-  # <tt>x.acts_like?(:date)</tt> to do duck-type-safe comparisons, since classes that
-  # we want to act like Time simply need to define an <tt>acts_like_time?</tt> method.
-  def acts_like?(duck)
-    case duck
-    when :time
-      respond_to? :acts_like_time?
-    when :date
-      respond_to? :acts_like_date?
-    when :string
-      respond_to? :acts_like_string?
-    else
-      respond_to? :"acts_like_#{duck}?"
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/blank.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/blank.rb
deleted file mode 100644
index f36fef6cc91bc..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/blank.rb
+++ /dev/null
@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-require "concurrent/map"
-
-class Object
-  # An object is blank if it's false, empty, or a whitespace string.
-  # For example, +nil+, '', '   ', [], {}, and +false+ are all blank.
-  #
-  # This simplifies
-  #
-  #   !address || address.empty?
-  #
-  # to
-  #
-  #   address.blank?
-  #
-  # @return [true, false]
-  def blank?
-    respond_to?(:empty?) ? !!empty? : !self
-  end
-
-  # An object is present if it's not blank.
-  #
-  # @return [true, false]
-  def present?
-    !blank?
-  end
-
-  # Returns the receiver if it's present otherwise returns +nil+.
-  # <tt>object.presence</tt> is equivalent to
-  #
-  #    object.present? ? object : nil
-  #
-  # For example, something like
-  #
-  #   state   = params[:state]   if params[:state].present?
-  #   country = params[:country] if params[:country].present?
-  #   region  = state || country || 'US'
-  #
-  # becomes
-  #
-  #   region = params[:state].presence || params[:country].presence || 'US'
-  #
-  # @return [Object]
-  def presence
-    self if present?
-  end
-end
-
-class NilClass
-  # +nil+ is blank:
-  #
-  #   nil.blank? # => true
-  #
-  # @return [true]
-  def blank?
-    true
-  end
-end
-
-class FalseClass
-  # +false+ is blank:
-  #
-  #   false.blank? # => true
-  #
-  # @return [true]
-  def blank?
-    true
-  end
-end
-
-class TrueClass
-  # +true+ is not blank:
-  #
-  #   true.blank? # => false
-  #
-  # @return [false]
-  def blank?
-    false
-  end
-end
-
-class Array
-  # An array is blank if it's empty:
-  #
-  #   [].blank?      # => true
-  #   [1,2,3].blank? # => false
-  #
-  # @return [true, false]
-  alias_method :blank?, :empty?
-end
-
-class Hash
-  # A hash is blank if it's empty:
-  #
-  #   {}.blank?                # => true
-  #   { key: 'value' }.blank?  # => false
-  #
-  # @return [true, false]
-  alias_method :blank?, :empty?
-end
-
-class String
-  BLANK_RE = /\A[[:space:]]*\z/
-  ENCODED_BLANKS = Concurrent::Map.new do |h, enc|
-    h[enc] = Regexp.new(BLANK_RE.source.encode(enc), BLANK_RE.options | Regexp::FIXEDENCODING)
-  end
-
-  # A string is blank if it's empty or contains whitespaces only:
-  #
-  #   ''.blank?       # => true
-  #   '   '.blank?    # => true
-  #   "\t\n\r".blank? # => true
-  #   ' blah '.blank? # => false
-  #
-  # Unicode whitespace is supported:
-  #
-  #   "\u00a0".blank? # => true
-  #
-  # @return [true, false]
-  def blank?
-    # The regexp that matches blank strings is expensive. For the case of empty
-    # strings we can speed up this method (~3.5x) with an empty? call. The
-    # penalty for the rest of strings is marginal.
-    empty? ||
-      begin
-        BLANK_RE.match?(self)
-      rescue Encoding::CompatibilityError
-        ENCODED_BLANKS[self.encoding].match?(self)
-      end
-  end
-end
-
-class Numeric #:nodoc:
-  # No number is blank:
-  #
-  #   1.blank? # => false
-  #   0.blank? # => false
-  #
-  # @return [false]
-  def blank?
-    false
-  end
-end
-
-class Time #:nodoc:
-  # No Time is blank:
-  #
-  #   Time.now.blank? # => false
-  #
-  # @return [false]
-  def blank?
-    false
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/conversions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/conversions.rb
deleted file mode 100644
index 624fb8d77cec5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/conversions.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/to_param"
-require "active_support/core_ext/object/to_query"
-require "active_support/core_ext/array/conversions"
-require "active_support/core_ext/hash/conversions"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/deep_dup.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/deep_dup.rb
deleted file mode 100644
index 5c903917f5f06..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/deep_dup.rb
+++ /dev/null
@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/duplicable"
-
-class Object
-  # Returns a deep copy of object if it's duplicable. If it's
-  # not duplicable, returns +self+.
-  #
-  #   object = Object.new
-  #   dup    = object.deep_dup
-  #   dup.instance_variable_set(:@a, 1)
-  #
-  #   object.instance_variable_defined?(:@a) # => false
-  #   dup.instance_variable_defined?(:@a)    # => true
-  def deep_dup
-    duplicable? ? dup : self
-  end
-end
-
-class Array
-  # Returns a deep copy of array.
-  #
-  #   array = [1, [2, 3]]
-  #   dup   = array.deep_dup
-  #   dup[1][2] = 4
-  #
-  #   array[1][2] # => nil
-  #   dup[1][2]   # => 4
-  def deep_dup
-    map(&:deep_dup)
-  end
-end
-
-class Hash
-  # Returns a deep copy of hash.
-  #
-  #   hash = { a: { b: 'b' } }
-  #   dup  = hash.deep_dup
-  #   dup[:a][:c] = 'c'
-  #
-  #   hash[:a][:c] # => nil
-  #   dup[:a][:c]  # => "c"
-  def deep_dup
-    hash = dup
-    each_pair do |key, value|
-      if (::String === key && key.frozen?) || ::Symbol === key
-        hash[key] = value.deep_dup
-      else
-        hash.delete(key)
-        hash[key.deep_dup] = value.deep_dup
-      end
-    end
-    hash
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/duplicable.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/duplicable.rb
deleted file mode 100644
index 3ebcdca02b73c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/duplicable.rb
+++ /dev/null
@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-#--
-# Most objects are cloneable, but not all. For example you can't dup methods:
-#
-#   method(:puts).dup # => TypeError: allocator undefined for Method
-#
-# Classes may signal their instances are not duplicable removing +dup+/+clone+
-# or raising exceptions from them. So, to dup an arbitrary object you normally
-# use an optimistic approach and are ready to catch an exception, say:
-#
-#   arbitrary_object.dup rescue object
-#
-# Rails dups objects in a few critical spots where they are not that arbitrary.
-# That rescue is very expensive (like 40 times slower than a predicate), and it
-# is often triggered.
-#
-# That's why we hardcode the following cases and check duplicable? instead of
-# using that rescue idiom.
-#++
-class Object
-  # Can you safely dup this object?
-  #
-  # False for method objects;
-  # true otherwise.
-  def duplicable?
-    true
-  end
-end
-
-class Method
-  # Methods are not duplicable:
-  #
-  #  method(:puts).duplicable? # => false
-  #  method(:puts).dup         # => TypeError: allocator undefined for Method
-  def duplicable?
-    false
-  end
-end
-
-class UnboundMethod
-  # Unbound methods are not duplicable:
-  #
-  #  method(:puts).unbind.duplicable? # => false
-  #  method(:puts).unbind.dup         # => TypeError: allocator undefined for UnboundMethod
-  def duplicable?
-    false
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/inclusion.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/inclusion.rb
deleted file mode 100644
index 6064e92f20ace..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/inclusion.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-class Object
-  # Returns true if this object is included in the argument. Argument must be
-  # any object which responds to +#include?+. Usage:
-  #
-  #   characters = ["Konata", "Kagami", "Tsukasa"]
-  #   "Konata".in?(characters) # => true
-  #
-  # This will throw an +ArgumentError+ if the argument doesn't respond
-  # to +#include?+.
-  def in?(another_object)
-    another_object.include?(self)
-  rescue NoMethodError
-    raise ArgumentError.new("The parameter passed to #in? must respond to #include?")
-  end
-
-  # Returns the receiver if it's included in the argument otherwise returns +nil+.
-  # Argument must be any object which responds to +#include?+. Usage:
-  #
-  #   params[:bucket_type].presence_in %w( project calendar )
-  #
-  # This will throw an +ArgumentError+ if the argument doesn't respond to +#include?+.
-  #
-  # @return [Object]
-  def presence_in(another_object)
-    in?(another_object) ? self : nil
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/instance_variables.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/instance_variables.rb
deleted file mode 100644
index 12fdf840b528b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/instance_variables.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-class Object
-  # Returns a hash with string keys that maps instance variable names without "@" to their
-  # corresponding values.
-  #
-  #   class C
-  #     def initialize(x, y)
-  #       @x, @y = x, y
-  #     end
-  #   end
-  #
-  #   C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
-  def instance_values
-    Hash[instance_variables.map { |name| [name[1..-1], instance_variable_get(name)] }]
-  end
-
-  # Returns an array of instance variable names as strings including "@".
-  #
-  #   class C
-  #     def initialize(x, y)
-  #       @x, @y = x, y
-  #     end
-  #   end
-  #
-  #   C.new(0, 1).instance_variable_names # => ["@y", "@x"]
-  def instance_variable_names
-    instance_variables.map(&:to_s)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/json.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/json.rb
deleted file mode 100644
index a65e273236482..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/json.rb
+++ /dev/null
@@ -1,239 +0,0 @@
-# frozen_string_literal: true
-
-# Hack to load json gem first so we can overwrite its to_json.
-require "json"
-require "bigdecimal"
-require "ipaddr"
-require "uri/generic"
-require "pathname"
-require "active_support/core_ext/big_decimal/conversions" # for #to_s
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/hash/slice"
-require "active_support/core_ext/object/instance_variables"
-require "time"
-require "active_support/core_ext/time/conversions"
-require "active_support/core_ext/date_time/conversions"
-require "active_support/core_ext/date/conversions"
-
-#--
-# The JSON gem adds a few modules to Ruby core classes containing :to_json definition, overwriting
-# their default behavior. That said, we need to define the basic to_json method in all of them,
-# otherwise they will always use to_json gem implementation, which is backwards incompatible in
-# several cases (for instance, the JSON implementation for Hash does not work) with inheritance
-# and consequently classes as ActiveSupport::OrderedHash cannot be serialized to json.
-#
-# On the other hand, we should avoid conflict with ::JSON.{generate,dump}(obj). Unfortunately, the
-# JSON gem's encoder relies on its own to_json implementation to encode objects. Since it always
-# passes a ::JSON::State object as the only argument to to_json, we can detect that and forward the
-# calls to the original to_json method.
-#
-# It should be noted that when using ::JSON.{generate,dump} directly, ActiveSupport's encoder is
-# bypassed completely. This means that as_json won't be invoked and the JSON gem will simply
-# ignore any options it does not natively understand. This also means that ::JSON.{generate,dump}
-# should give exactly the same results with or without active support.
-
-module ActiveSupport
-  module ToJsonWithActiveSupportEncoder # :nodoc:
-    def to_json(options = nil)
-      if options.is_a?(::JSON::State)
-        # Called from JSON.{generate,dump}, forward it to JSON gem's to_json
-        super(options)
-      else
-        # to_json is being invoked directly, use ActiveSupport's encoder
-        ActiveSupport::JSON.encode(self, options)
-      end
-    end
-  end
-end
-
-[Enumerable, Object, Array, FalseClass, Float, Hash, Integer, NilClass, String, TrueClass].reverse_each do |klass|
-  klass.prepend(ActiveSupport::ToJsonWithActiveSupportEncoder)
-end
-
-class Object
-  def as_json(options = nil) #:nodoc:
-    if respond_to?(:to_hash)
-      to_hash.as_json(options)
-    else
-      instance_values.as_json(options)
-    end
-  end
-end
-
-class Struct #:nodoc:
-  def as_json(options = nil)
-    Hash[members.zip(values)].as_json(options)
-  end
-end
-
-class TrueClass
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-end
-
-class FalseClass
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-end
-
-class NilClass
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-end
-
-class String
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-end
-
-class Symbol
-  def as_json(options = nil) #:nodoc:
-    to_s
-  end
-end
-
-class Numeric
-  def as_json(options = nil) #:nodoc:
-    self
-  end
-end
-
-class Float
-  # Encoding Infinity or NaN to JSON should return "null". The default returns
-  # "Infinity" or "NaN" which are not valid JSON.
-  def as_json(options = nil) #:nodoc:
-    finite? ? self : nil
-  end
-end
-
-class BigDecimal
-  # A BigDecimal would be naturally represented as a JSON number. Most libraries,
-  # however, parse non-integer JSON numbers directly as floats. Clients using
-  # those libraries would get in general a wrong number and no way to recover
-  # other than manually inspecting the string with the JSON code itself.
-  #
-  # That's why a JSON string is returned. The JSON literal is not numeric, but
-  # if the other end knows by contract that the data is supposed to be a
-  # BigDecimal, it still has the chance to post-process the string and get the
-  # real value.
-  def as_json(options = nil) #:nodoc:
-    finite? ? to_s : nil
-  end
-end
-
-class Regexp
-  def as_json(options = nil) #:nodoc:
-    to_s
-  end
-end
-
-module Enumerable
-  def as_json(options = nil) #:nodoc:
-    to_a.as_json(options)
-  end
-end
-
-class IO
-  def as_json(options = nil) #:nodoc:
-    to_s
-  end
-end
-
-class Range
-  def as_json(options = nil) #:nodoc:
-    to_s
-  end
-end
-
-class Array
-  def as_json(options = nil) #:nodoc:
-    map { |v| options ? v.as_json(options.dup) : v.as_json }
-  end
-end
-
-class Hash
-  def as_json(options = nil) #:nodoc:
-    # create a subset of the hash by applying :only or :except
-    subset = if options
-      if attrs = options[:only]
-        slice(*Array(attrs))
-      elsif attrs = options[:except]
-        except(*Array(attrs))
-      else
-        self
-      end
-    else
-      self
-    end
-
-    result = {}
-    subset.each do |k, v|
-      result[k.to_s] = options ? v.as_json(options.dup) : v.as_json
-    end
-    result
-  end
-end
-
-class Time
-  def as_json(options = nil) #:nodoc:
-    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
-      xmlschema(ActiveSupport::JSON::Encoding.time_precision)
-    else
-      %(#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
-    end
-  end
-end
-
-class Date
-  def as_json(options = nil) #:nodoc:
-    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
-      strftime("%Y-%m-%d")
-    else
-      strftime("%Y/%m/%d")
-    end
-  end
-end
-
-class DateTime
-  def as_json(options = nil) #:nodoc:
-    if ActiveSupport::JSON::Encoding.use_standard_json_time_format
-      xmlschema(ActiveSupport::JSON::Encoding.time_precision)
-    else
-      strftime("%Y/%m/%d %H:%M:%S %z")
-    end
-  end
-end
-
-class URI::Generic #:nodoc:
-  def as_json(options = nil)
-    to_s
-  end
-end
-
-class Pathname #:nodoc:
-  def as_json(options = nil)
-    to_s
-  end
-end
-
-class IPAddr # :nodoc:
-  def as_json(options = nil)
-    to_s
-  end
-end
-
-class Process::Status #:nodoc:
-  def as_json(options = nil)
-    { exitstatus: exitstatus, pid: pid }
-  end
-end
-
-class Exception
-  def as_json(options = nil)
-    to_s
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/to_param.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/to_param.rb
deleted file mode 100644
index 6d2bdd70f3c85..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/to_param.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/to_query"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/to_query.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/to_query.rb
deleted file mode 100644
index bac6ff9c97c94..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/to_query.rb
+++ /dev/null
@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require "cgi"
-
-class Object
-  # Alias of <tt>to_s</tt>.
-  def to_param
-    to_s
-  end
-
-  # Converts an object into a string suitable for use as a URL query string,
-  # using the given <tt>key</tt> as the param name.
-  def to_query(key)
-    "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
-  end
-end
-
-class NilClass
-  # Returns +self+.
-  def to_param
-    self
-  end
-end
-
-class TrueClass
-  # Returns +self+.
-  def to_param
-    self
-  end
-end
-
-class FalseClass
-  # Returns +self+.
-  def to_param
-    self
-  end
-end
-
-class Array
-  # Calls <tt>to_param</tt> on all its elements and joins the result with
-  # slashes. This is used by <tt>url_for</tt> in Action Pack.
-  def to_param
-    collect(&:to_param).join "/"
-  end
-
-  # Converts an array into a string suitable for use as a URL query string,
-  # using the given +key+ as the param name.
-  #
-  #   ['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
-  def to_query(key)
-    prefix = "#{key}[]"
-
-    if empty?
-      nil.to_query(prefix)
-    else
-      collect { |value| value.to_query(prefix) }.join "&"
-    end
-  end
-end
-
-class Hash
-  # Returns a string representation of the receiver suitable for use as a URL
-  # query string:
-  #
-  #   {name: 'David', nationality: 'Danish'}.to_query
-  #   # => "name=David&nationality=Danish"
-  #
-  # An optional namespace can be passed to enclose key names:
-  #
-  #   {name: 'David', nationality: 'Danish'}.to_query('user')
-  #   # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
-  #
-  # The string pairs "key=value" that conform the query string
-  # are sorted lexicographically in ascending order.
-  #
-  # This method is also aliased as +to_param+.
-  def to_query(namespace = nil)
-    query = collect do |key, value|
-      unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
-        value.to_query(namespace ? "#{namespace}[#{key}]" : key)
-      end
-    end.compact
-
-    query.sort! unless namespace.to_s.include?("[]")
-    query.join("&")
-  end
-
-  alias_method :to_param, :to_query
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/try.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/try.rb
deleted file mode 100644
index 999141a993ce6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/try.rb
+++ /dev/null
@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-require "delegate"
-
-module ActiveSupport
-  module Tryable #:nodoc:
-    def try(method_name = nil, *args, &b)
-      if method_name.nil? && block_given?
-        if b.arity == 0
-          instance_eval(&b)
-        else
-          yield self
-        end
-      elsif respond_to?(method_name)
-        public_send(method_name, *args, &b)
-      end
-    end
-    ruby2_keywords(:try) if respond_to?(:ruby2_keywords, true)
-
-    def try!(method_name = nil, *args, &b)
-      if method_name.nil? && block_given?
-        if b.arity == 0
-          instance_eval(&b)
-        else
-          yield self
-        end
-      else
-        public_send(method_name, *args, &b)
-      end
-    end
-    ruby2_keywords(:try!) if respond_to?(:ruby2_keywords, true)
-  end
-end
-
-class Object
-  include ActiveSupport::Tryable
-
-  ##
-  # :method: try
-  #
-  # :call-seq:
-  #   try(*a, &b)
-  #
-  # Invokes the public method whose name goes as first argument just like
-  # +public_send+ does, except that if the receiver does not respond to it the
-  # call returns +nil+ rather than raising an exception.
-  #
-  # This method is defined to be able to write
-  #
-  #   @person.try(:name)
-  #
-  # instead of
-  #
-  #   @person.name if @person
-  #
-  # +try+ calls can be chained:
-  #
-  #   @person.try(:spouse).try(:name)
-  #
-  # instead of
-  #
-  #   @person.spouse.name if @person && @person.spouse
-  #
-  # +try+ will also return +nil+ if the receiver does not respond to the method:
-  #
-  #   @person.try(:non_existing_method) # => nil
-  #
-  # instead of
-  #
-  #   @person.non_existing_method if @person.respond_to?(:non_existing_method) # => nil
-  #
-  # +try+ returns +nil+ when called on +nil+ regardless of whether it responds
-  # to the method:
-  #
-  #   nil.try(:to_i) # => nil, rather than 0
-  #
-  # Arguments and blocks are forwarded to the method if invoked:
-  #
-  #   @posts.try(:each_slice, 2) do |a, b|
-  #     ...
-  #   end
-  #
-  # The number of arguments in the signature must match. If the object responds
-  # to the method the call is attempted and +ArgumentError+ is still raised
-  # in case of argument mismatch.
-  #
-  # If +try+ is called without arguments it yields the receiver to a given
-  # block unless it is +nil+:
-  #
-  #   @person.try do |p|
-  #     ...
-  #   end
-  #
-  # You can also call try with a block without accepting an argument, and the block
-  # will be instance_eval'ed instead:
-  #
-  #   @person.try { upcase.truncate(50) }
-  #
-  # Please also note that +try+ is defined on +Object+. Therefore, it won't work
-  # with instances of classes that do not have +Object+ among their ancestors,
-  # like direct subclasses of +BasicObject+.
-
-  ##
-  # :method: try!
-  #
-  # :call-seq:
-  #   try!(*a, &b)
-  #
-  # Same as #try, but raises a +NoMethodError+ exception if the receiver is
-  # not +nil+ and does not implement the tried method.
-  #
-  #   "a".try!(:upcase) # => "A"
-  #   nil.try!(:upcase) # => nil
-  #   123.try!(:upcase) # => NoMethodError: undefined method `upcase' for 123:Integer
-end
-
-class Delegator
-  include ActiveSupport::Tryable
-
-  ##
-  # :method: try
-  #
-  # :call-seq:
-  #   try(a*, &b)
-  #
-  # See Object#try
-
-  ##
-  # :method: try!
-  #
-  # :call-seq:
-  #   try!(a*, &b)
-  #
-  # See Object#try!
-end
-
-class NilClass
-  # Calling +try+ on +nil+ always returns +nil+.
-  # It becomes especially helpful when navigating through associations that may return +nil+.
-  #
-  #   nil.try(:name) # => nil
-  #
-  # Without +try+
-  #   @person && @person.children.any? && @person.children.first.name
-  #
-  # With +try+
-  #   @person.try(:children).try(:first).try(:name)
-  def try(_method_name = nil, *)
-    nil
-  end
-
-  # Calling +try!+ on +nil+ always returns +nil+.
-  #
-  #   nil.try!(:name) # => nil
-  def try!(_method_name = nil, *)
-    nil
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/with_options.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/with_options.rb
deleted file mode 100644
index 1d46add6e038c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/object/with_options.rb
+++ /dev/null
@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/option_merger"
-
-class Object
-  # An elegant way to factor duplication out of options passed to a series of
-  # method calls. Each method called in the block, with the block variable as
-  # the receiver, will have its options merged with the default +options+ hash
-  # provided. Each method called on the block variable must take an options
-  # hash as its final argument.
-  #
-  # Without <tt>with_options</tt>, this code contains duplication:
-  #
-  #   class Account < ActiveRecord::Base
-  #     has_many :customers, dependent: :destroy
-  #     has_many :products,  dependent: :destroy
-  #     has_many :invoices,  dependent: :destroy
-  #     has_many :expenses,  dependent: :destroy
-  #   end
-  #
-  # Using <tt>with_options</tt>, we can remove the duplication:
-  #
-  #   class Account < ActiveRecord::Base
-  #     with_options dependent: :destroy do |assoc|
-  #       assoc.has_many :customers
-  #       assoc.has_many :products
-  #       assoc.has_many :invoices
-  #       assoc.has_many :expenses
-  #     end
-  #   end
-  #
-  # It can also be used with an explicit receiver:
-  #
-  #   I18n.with_options locale: user.locale, scope: 'newsletter' do |i18n|
-  #     subject i18n.t :subject
-  #     body    i18n.t :body, user_name: user.name
-  #   end
-  #
-  # When you don't pass an explicit receiver, it executes the whole block
-  # in merging options context:
-  #
-  #   class Account < ActiveRecord::Base
-  #     with_options dependent: :destroy do
-  #       has_many :customers
-  #       has_many :products
-  #       has_many :invoices
-  #       has_many :expenses
-  #     end
-  #   end
-  #
-  # <tt>with_options</tt> can also be nested since the call is forwarded to its receiver.
-  #
-  # NOTE: Each nesting level will merge inherited defaults in addition to their own.
-  #
-  #   class Post < ActiveRecord::Base
-  #     with_options if: :persisted?, length: { minimum: 50 } do
-  #       validates :content, if: -> { content.present? }
-  #     end
-  #   end
-  #
-  # The code is equivalent to:
-  #
-  #   validates :content, length: { minimum: 50 }, if: -> { content.present? }
-  #
-  # Hence the inherited default for +if+ key is ignored.
-  #
-  # NOTE: You cannot call class methods implicitly inside of with_options.
-  # You can access these methods using the class name instead:
-  #
-  #   class Phone < ActiveRecord::Base
-  #     enum phone_number_type: { home: 0, office: 1, mobile: 2 }
-  #
-  #     with_options presence: true do
-  #       validates :phone_number_type, inclusion: { in: Phone.phone_number_types.keys }
-  #     end
-  #   end
-  #
-  def with_options(options, &block)
-    option_merger = ActiveSupport::OptionMerger.new(self, options)
-    block.arity.zero? ? option_merger.instance_eval(&block) : block.call(option_merger)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range.rb
deleted file mode 100644
index 78814fd18961c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/range/conversions"
-require "active_support/core_ext/range/compare_range"
-require "active_support/core_ext/range/include_time_with_zone"
-require "active_support/core_ext/range/overlaps"
-require "active_support/core_ext/range/each"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/compare_range.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/compare_range.rb
deleted file mode 100644
index c6d5b77e8ef2c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/compare_range.rb
+++ /dev/null
@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  module CompareWithRange
-    # Extends the default Range#=== to support range comparisons.
-    #  (1..5) === (1..5)  # => true
-    #  (1..5) === (2..3)  # => true
-    #  (1..5) === (1...6) # => true
-    #  (1..5) === (2..6)  # => false
-    #
-    # The native Range#=== behavior is untouched.
-    #  ('a'..'f') === ('c') # => true
-    #  (5..9) === (11) # => false
-    #
-    # The given range must be fully bounded, with both start and end.
-    def ===(value)
-      if value.is_a?(::Range)
-        is_backwards_op = value.exclude_end? ? :>= : :>
-        return false if value.begin && value.end && value.begin.public_send(is_backwards_op, value.end)
-        # 1...10 includes 1..9 but it does not include 1..10.
-        # 1..10 includes 1...11 but it does not include 1...12.
-        operator = exclude_end? && !value.exclude_end? ? :< : :<=
-        value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
-        super(value.first) && (self.end.nil? || value_max.public_send(operator, last))
-      else
-        super
-      end
-    end
-
-    # Extends the default Range#include? to support range comparisons.
-    #  (1..5).include?(1..5)  # => true
-    #  (1..5).include?(2..3)  # => true
-    #  (1..5).include?(1...6) # => true
-    #  (1..5).include?(2..6)  # => false
-    #
-    # The native Range#include? behavior is untouched.
-    #  ('a'..'f').include?('c') # => true
-    #  (5..9).include?(11) # => false
-    #
-    # The given range must be fully bounded, with both start and end.
-    def include?(value)
-      if value.is_a?(::Range)
-        is_backwards_op = value.exclude_end? ? :>= : :>
-        return false if value.begin && value.end && value.begin.public_send(is_backwards_op, value.end)
-        # 1...10 includes 1..9 but it does not include 1..10.
-        # 1..10 includes 1...11 but it does not include 1...12.
-        operator = exclude_end? && !value.exclude_end? ? :< : :<=
-        value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
-        super(value.first) && (self.end.nil? || value_max.public_send(operator, last))
-      else
-        super
-      end
-    end
-
-    # Extends the default Range#cover? to support range comparisons.
-    #  (1..5).cover?(1..5)  # => true
-    #  (1..5).cover?(2..3)  # => true
-    #  (1..5).cover?(1...6) # => true
-    #  (1..5).cover?(2..6)  # => false
-    #
-    # The native Range#cover? behavior is untouched.
-    #  ('a'..'f').cover?('c') # => true
-    #  (5..9).cover?(11) # => false
-    #
-    # The given range must be fully bounded, with both start and end.
-    def cover?(value)
-      if value.is_a?(::Range)
-        is_backwards_op = value.exclude_end? ? :>= : :>
-        return false if value.begin && value.end && value.begin.public_send(is_backwards_op, value.end)
-        # 1...10 covers 1..9 but it does not cover 1..10.
-        # 1..10 covers 1...11 but it does not cover 1...12.
-        operator = exclude_end? && !value.exclude_end? ? :< : :<=
-        value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
-        super(value.first) && (self.end.nil? || value_max.public_send(operator, last))
-      else
-        super
-      end
-    end
-  end
-end
-
-Range.prepend(ActiveSupport::CompareWithRange)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/conversions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/conversions.rb
deleted file mode 100644
index 024e32db40548..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/conversions.rb
+++ /dev/null
@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  module RangeWithFormat
-    RANGE_FORMATS = {
-      db: -> (start, stop) do
-        case start
-        when String then "BETWEEN '#{start}' AND '#{stop}'"
-        else
-          "BETWEEN '#{start.to_s(:db)}' AND '#{stop.to_s(:db)}'"
-        end
-      end
-    }
-
-    # Convert range to a formatted string. See RANGE_FORMATS for predefined formats.
-    #
-    #   range = (1..100)           # => 1..100
-    #
-    #   range.to_s                 # => "1..100"
-    #   range.to_s(:db)            # => "BETWEEN '1' AND '100'"
-    #
-    # == Adding your own range formats to to_s
-    # You can add your own formats to the Range::RANGE_FORMATS hash.
-    # Use the format name as the hash key and a Proc instance.
-    #
-    #   # config/initializers/range_formats.rb
-    #   Range::RANGE_FORMATS[:short] = ->(start, stop) { "Between #{start.to_s(:db)} and #{stop.to_s(:db)}" }
-    def to_s(format = :default)
-      if formatter = RANGE_FORMATS[format]
-        formatter.call(first, last)
-      else
-        super()
-      end
-    end
-
-    alias_method :to_default_s, :to_s
-    alias_method :to_formatted_s, :to_s
-  end
-end
-
-Range.prepend(ActiveSupport::RangeWithFormat)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/each.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/each.rb
deleted file mode 100644
index 2d86997edfc28..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/each.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/time_with_zone"
-
-module ActiveSupport
-  module EachTimeWithZone #:nodoc:
-    def each(&block)
-      ensure_iteration_allowed
-      super
-    end
-
-    def step(n = 1, &block)
-      ensure_iteration_allowed
-      super
-    end
-
-    private
-      def ensure_iteration_allowed
-        raise TypeError, "can't iterate from #{first.class}" if first.is_a?(TimeWithZone)
-      end
-  end
-end
-
-Range.prepend(ActiveSupport::EachTimeWithZone)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/include_time_with_zone.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/include_time_with_zone.rb
deleted file mode 100644
index 89e911b11d199..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/include_time_with_zone.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/time_with_zone"
-require "active_support/deprecation"
-
-module ActiveSupport
-  module IncludeTimeWithZone #:nodoc:
-    # Extends the default Range#include? to support ActiveSupport::TimeWithZone.
-    #
-    #   (1.hour.ago..1.hour.from_now).include?(Time.current) # => true
-    #
-    def include?(value)
-      if self.begin.is_a?(TimeWithZone) || self.end.is_a?(TimeWithZone)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          Using `Range#include?` to check the inclusion of a value in
-          a date time range is deprecated.
-          It is recommended to use `Range#cover?` instead of `Range#include?` to
-          check the inclusion of a value in a date time range.
-        MSG
-        cover?(value)
-      else
-        super
-      end
-    end
-  end
-end
-
-Range.prepend(ActiveSupport::IncludeTimeWithZone)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/overlaps.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/overlaps.rb
deleted file mode 100644
index f753607f8bbb9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/range/overlaps.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-class Range
-  # Compare two ranges and see if they overlap each other
-  #  (1..5).overlaps?(4..6) # => true
-  #  (1..5).overlaps?(7..9) # => false
-  def overlaps?(other)
-    cover?(other.first) || other.cover?(first)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/regexp.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/regexp.rb
deleted file mode 100644
index 15534ff52fc5c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/regexp.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-class Regexp
-  # Returns +true+ if the regexp has the multiline flag set.
-  #
-  #   (/./).multiline?  # => false
-  #   (/./m).multiline? # => true
-  #
-  #   Regexp.new(".").multiline?                    # => false
-  #   Regexp.new(".", Regexp::MULTILINE).multiline? # => true
-  def multiline?
-    options & MULTILINE == MULTILINE
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/securerandom.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/securerandom.rb
deleted file mode 100644
index ef812f7e1afef..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/securerandom.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-
-module SecureRandom
-  BASE58_ALPHABET = ("0".."9").to_a + ("A".."Z").to_a + ("a".."z").to_a - ["0", "O", "I", "l"]
-  BASE36_ALPHABET = ("0".."9").to_a + ("a".."z").to_a
-
-  # SecureRandom.base58 generates a random base58 string.
-  #
-  # The argument _n_ specifies the length of the random string to be generated.
-  #
-  # If _n_ is not specified or is +nil+, 16 is assumed. It may be larger in the future.
-  #
-  # The result may contain alphanumeric characters except 0, O, I and l.
-  #
-  #   p SecureRandom.base58 # => "4kUgL2pdQMSCQtjE"
-  #   p SecureRandom.base58(24) # => "77TMHrHJFvFDwodq8w7Ev2m7"
-  def self.base58(n = 16)
-    SecureRandom.random_bytes(n).unpack("C*").map do |byte|
-      idx = byte % 64
-      idx = SecureRandom.random_number(58) if idx >= 58
-      BASE58_ALPHABET[idx]
-    end.join
-  end
-
-  # SecureRandom.base36 generates a random base36 string in lowercase.
-  #
-  # The argument _n_ specifies the length of the random string to be generated.
-  #
-  # If _n_ is not specified or is +nil+, 16 is assumed. It may be larger in the future.
-  # This method can be used over +base58+ if a deterministic case key is necessary.
-  #
-  # The result will contain alphanumeric characters in lowercase.
-  #
-  #   p SecureRandom.base36 # => "4kugl2pdqmscqtje"
-  #   p SecureRandom.base36(24) # => "77tmhrhjfvfdwodq8w7ev2m7"
-  def self.base36(n = 16)
-    SecureRandom.random_bytes(n).unpack("C*").map do |byte|
-      idx = byte % 64
-      idx = SecureRandom.random_number(36) if idx >= 36
-      BASE36_ALPHABET[idx]
-    end.join
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string.rb
deleted file mode 100644
index 757d15c51ae49..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/string/conversions"
-require "active_support/core_ext/string/filters"
-require "active_support/core_ext/string/multibyte"
-require "active_support/core_ext/string/starts_ends_with"
-require "active_support/core_ext/string/inflections"
-require "active_support/core_ext/string/access"
-require "active_support/core_ext/string/behavior"
-require "active_support/core_ext/string/output_safety"
-require "active_support/core_ext/string/exclude"
-require "active_support/core_ext/string/strip"
-require "active_support/core_ext/string/inquiry"
-require "active_support/core_ext/string/indent"
-require "active_support/core_ext/string/zones"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/access.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/access.rb
deleted file mode 100644
index f6a14c08bc5f2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/access.rb
+++ /dev/null
@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-class String
-  # If you pass a single integer, returns a substring of one character at that
-  # position. The first character of the string is at position 0, the next at
-  # position 1, and so on. If a range is supplied, a substring containing
-  # characters at offsets given by the range is returned. In both cases, if an
-  # offset is negative, it is counted from the end of the string. Returns +nil+
-  # if the initial offset falls outside the string. Returns an empty string if
-  # the beginning of the range is greater than the end of the string.
-  #
-  #   str = "hello"
-  #   str.at(0)      # => "h"
-  #   str.at(1..3)   # => "ell"
-  #   str.at(-2)     # => "l"
-  #   str.at(-2..-1) # => "lo"
-  #   str.at(5)      # => nil
-  #   str.at(5..-1)  # => ""
-  #
-  # If a Regexp is given, the matching portion of the string is returned.
-  # If a String is given, that given string is returned if it occurs in
-  # the string. In both cases, +nil+ is returned if there is no match.
-  #
-  #   str = "hello"
-  #   str.at(/lo/) # => "lo"
-  #   str.at(/ol/) # => nil
-  #   str.at("lo") # => "lo"
-  #   str.at("ol") # => nil
-  def at(position)
-    self[position]
-  end
-
-  # Returns a substring from the given position to the end of the string.
-  # If the position is negative, it is counted from the end of the string.
-  #
-  #   str = "hello"
-  #   str.from(0)  # => "hello"
-  #   str.from(3)  # => "lo"
-  #   str.from(-2) # => "lo"
-  #
-  # You can mix it with +to+ method and do fun things like:
-  #
-  #   str = "hello"
-  #   str.from(0).to(-1) # => "hello"
-  #   str.from(1).to(-2) # => "ell"
-  def from(position)
-    self[position, length]
-  end
-
-  # Returns a substring from the beginning of the string to the given position.
-  # If the position is negative, it is counted from the end of the string.
-  #
-  #   str = "hello"
-  #   str.to(0)  # => "h"
-  #   str.to(3)  # => "hell"
-  #   str.to(-2) # => "hell"
-  #
-  # You can mix it with +from+ method and do fun things like:
-  #
-  #   str = "hello"
-  #   str.from(0).to(-1) # => "hello"
-  #   str.from(1).to(-2) # => "ell"
-  def to(position)
-    position += size if position < 0
-    self[0, position + 1] || +""
-  end
-
-  # Returns the first character. If a limit is supplied, returns a substring
-  # from the beginning of the string until it reaches the limit value. If the
-  # given limit is greater than or equal to the string length, returns a copy of self.
-  #
-  #   str = "hello"
-  #   str.first    # => "h"
-  #   str.first(1) # => "h"
-  #   str.first(2) # => "he"
-  #   str.first(0) # => ""
-  #   str.first(6) # => "hello"
-  def first(limit = 1)
-    self[0, limit] || raise(ArgumentError, "negative limit")
-  end
-
-  # Returns the last character of the string. If a limit is supplied, returns a substring
-  # from the end of the string until it reaches the limit value (counting backwards). If
-  # the given limit is greater than or equal to the string length, returns a copy of self.
-  #
-  #   str = "hello"
-  #   str.last    # => "o"
-  #   str.last(1) # => "o"
-  #   str.last(2) # => "lo"
-  #   str.last(0) # => ""
-  #   str.last(6) # => "hello"
-  def last(limit = 1)
-    self[[length - limit, 0].max, limit] || raise(ArgumentError, "negative limit")
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/behavior.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/behavior.rb
deleted file mode 100644
index 35a5aa78405a6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/behavior.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-class String
-  # Enables more predictable duck-typing on String-like classes. See <tt>Object#acts_like?</tt>.
-  def acts_like_string?
-    true
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/conversions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/conversions.rb
deleted file mode 100644
index e84a3909a1569..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/conversions.rb
+++ /dev/null
@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-require "active_support/core_ext/time/calculations"
-
-class String
-  # Converts a string to a Time value.
-  # The +form+ can be either :utc or :local (default :local).
-  #
-  # The time is parsed using Time.parse method.
-  # If +form+ is :local, then the time is in the system timezone.
-  # If the date part is missing then the current date is used and if
-  # the time part is missing then it is assumed to be 00:00:00.
-  #
-  #   "13-12-2012".to_time               # => 2012-12-13 00:00:00 +0100
-  #   "06:12".to_time                    # => 2012-12-13 06:12:00 +0100
-  #   "2012-12-13 06:12".to_time         # => 2012-12-13 06:12:00 +0100
-  #   "2012-12-13T06:12".to_time         # => 2012-12-13 06:12:00 +0100
-  #   "2012-12-13T06:12".to_time(:utc)   # => 2012-12-13 06:12:00 UTC
-  #   "12/13/2012".to_time               # => ArgumentError: argument out of range
-  #   "1604326192".to_time               # => ArgumentError: argument out of range
-  def to_time(form = :local)
-    parts = Date._parse(self, false)
-    used_keys = %i(year mon mday hour min sec sec_fraction offset)
-    return if (parts.keys & used_keys).empty?
-
-    now = Time.now
-    time = Time.new(
-      parts.fetch(:year, now.year),
-      parts.fetch(:mon, now.month),
-      parts.fetch(:mday, now.day),
-      parts.fetch(:hour, 0),
-      parts.fetch(:min, 0),
-      parts.fetch(:sec, 0) + parts.fetch(:sec_fraction, 0),
-      parts.fetch(:offset, form == :utc ? 0 : nil)
-    )
-
-    form == :utc ? time.utc : time.to_time
-  end
-
-  # Converts a string to a Date value.
-  #
-  #   "1-1-2012".to_date   # => Sun, 01 Jan 2012
-  #   "01/01/2012".to_date # => Sun, 01 Jan 2012
-  #   "2012-12-13".to_date # => Thu, 13 Dec 2012
-  #   "12/13/2012".to_date # => ArgumentError: invalid date
-  def to_date
-    ::Date.parse(self, false) unless blank?
-  end
-
-  # Converts a string to a DateTime value.
-  #
-  #   "1-1-2012".to_datetime            # => Sun, 01 Jan 2012 00:00:00 +0000
-  #   "01/01/2012 23:59:59".to_datetime # => Sun, 01 Jan 2012 23:59:59 +0000
-  #   "2012-12-13 12:50".to_datetime    # => Thu, 13 Dec 2012 12:50:00 +0000
-  #   "12/13/2012".to_datetime          # => ArgumentError: invalid date
-  def to_datetime
-    ::DateTime.parse(self, false) unless blank?
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/exclude.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/exclude.rb
deleted file mode 100644
index 8e462689f1cc2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/exclude.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-class String
-  # The inverse of <tt>String#include?</tt>. Returns true if the string
-  # does not include the other string.
-  #
-  #   "hello".exclude? "lo" # => false
-  #   "hello".exclude? "ol" # => true
-  #   "hello".exclude? ?h   # => false
-  def exclude?(string)
-    !include?(string)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/filters.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/filters.rb
deleted file mode 100644
index 7f28bd52f244a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/filters.rb
+++ /dev/null
@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-class String
-  # Returns the string, first removing all whitespace on both ends of
-  # the string, and then changing remaining consecutive whitespace
-  # groups into one space each.
-  #
-  # Note that it handles both ASCII and Unicode whitespace.
-  #
-  #   %{ Multi-line
-  #      string }.squish                   # => "Multi-line string"
-  #   " foo   bar    \n   \t   boo".squish # => "foo bar boo"
-  def squish
-    dup.squish!
-  end
-
-  # Performs a destructive squish. See String#squish.
-  #   str = " foo   bar    \n   \t   boo"
-  #   str.squish!                         # => "foo bar boo"
-  #   str                                 # => "foo bar boo"
-  def squish!
-    gsub!(/[[:space:]]+/, " ")
-    strip!
-    self
-  end
-
-  # Returns a new string with all occurrences of the patterns removed.
-  #   str = "foo bar test"
-  #   str.remove(" test")                 # => "foo bar"
-  #   str.remove(" test", /bar/)          # => "foo "
-  #   str                                 # => "foo bar test"
-  def remove(*patterns)
-    dup.remove!(*patterns)
-  end
-
-  # Alters the string by removing all occurrences of the patterns.
-  #   str = "foo bar test"
-  #   str.remove!(" test", /bar/)         # => "foo "
-  #   str                                 # => "foo "
-  def remove!(*patterns)
-    patterns.each do |pattern|
-      gsub! pattern, ""
-    end
-
-    self
-  end
-
-  # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
-  #
-  #   'Once upon a time in a world far far away'.truncate(27)
-  #   # => "Once upon a time in a wo..."
-  #
-  # Pass a string or regexp <tt>:separator</tt> to truncate +text+ at a natural break:
-  #
-  #   'Once upon a time in a world far far away'.truncate(27, separator: ' ')
-  #   # => "Once upon a time in a..."
-  #
-  #   'Once upon a time in a world far far away'.truncate(27, separator: /\s/)
-  #   # => "Once upon a time in a..."
-  #
-  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
-  # for a total length not exceeding <tt>length</tt>:
-  #
-  #   'And they found that many people were sleeping better.'.truncate(25, omission: '... (continued)')
-  #   # => "And they f... (continued)"
-  def truncate(truncate_at, options = {})
-    return dup unless length > truncate_at
-
-    omission = options[:omission] || "..."
-    length_with_room_for_omission = truncate_at - omission.length
-    stop = \
-      if options[:separator]
-        rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
-      else
-        length_with_room_for_omission
-      end
-
-    +"#{self[0, stop]}#{omission}"
-  end
-
-  # Truncates +text+ to at most <tt>bytesize</tt> bytes in length without
-  # breaking string encoding by splitting multibyte characters or breaking
-  # grapheme clusters ("perceptual characters") by truncating at combining
-  # characters.
-  #
-  #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".size
-  #   => 20
-  #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".bytesize
-  #   => 80
-  #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".truncate_bytes(20)
-  #   => "🔪🔪🔪🔪…"
-  #
-  # The truncated text ends with the <tt>:omission</tt> string, defaulting
-  # to "…", for a total length not exceeding <tt>bytesize</tt>.
-  def truncate_bytes(truncate_at, omission: "…")
-    omission ||= ""
-
-    case
-    when bytesize <= truncate_at
-      dup
-    when omission.bytesize > truncate_at
-      raise ArgumentError, "Omission #{omission.inspect} is #{omission.bytesize}, larger than the truncation length of #{truncate_at} bytes"
-    when omission.bytesize == truncate_at
-      omission.dup
-    else
-      self.class.new.tap do |cut|
-        cut_at = truncate_at - omission.bytesize
-
-        scan(/\X/) do |grapheme|
-          if cut.bytesize + grapheme.bytesize <= cut_at
-            cut << grapheme
-          else
-            break
-          end
-        end
-
-        cut << omission
-      end
-    end
-  end
-
-  # Truncates a given +text+ after a given number of words (<tt>words_count</tt>):
-  #
-  #   'Once upon a time in a world far far away'.truncate_words(4)
-  #   # => "Once upon a time..."
-  #
-  # Pass a string or regexp <tt>:separator</tt> to specify a different separator of words:
-  #
-  #   'Once<br>upon<br>a<br>time<br>in<br>a<br>world'.truncate_words(5, separator: '<br>')
-  #   # => "Once<br>upon<br>a<br>time<br>in..."
-  #
-  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "..."):
-  #
-  #   'And they found that many people were sleeping better.'.truncate_words(5, omission: '... (continued)')
-  #   # => "And they found that many... (continued)"
-  def truncate_words(words_count, options = {})
-    sep = options[:separator] || /\s+/
-    sep = Regexp.escape(sep.to_s) unless Regexp === sep
-    if self =~ /\A((?>.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
-      $1 + (options[:omission] || "...")
-    else
-      dup
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/indent.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/indent.rb
deleted file mode 100644
index af9d181487eb1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/indent.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-class String
-  # Same as +indent+, except it indents the receiver in-place.
-  #
-  # Returns the indented string, or +nil+ if there was nothing to indent.
-  def indent!(amount, indent_string = nil, indent_empty_lines = false)
-    indent_string = indent_string || self[/^[ \t]/] || " "
-    re = indent_empty_lines ? /^/ : /^(?!$)/
-    gsub!(re, indent_string * amount)
-  end
-
-  # Indents the lines in the receiver:
-  #
-  #   <<EOS.indent(2)
-  #   def some_method
-  #     some_code
-  #   end
-  #   EOS
-  #   # =>
-  #     def some_method
-  #       some_code
-  #     end
-  #
-  # The second argument, +indent_string+, specifies which indent string to
-  # use. The default is +nil+, which tells the method to make a guess by
-  # peeking at the first indented line, and fallback to a space if there is
-  # none.
-  #
-  #   "  foo".indent(2)        # => "    foo"
-  #   "foo\n\t\tbar".indent(2) # => "\t\tfoo\n\t\t\t\tbar"
-  #   "foo".indent(2, "\t")    # => "\t\tfoo"
-  #
-  # While +indent_string+ is typically one space or tab, it may be any string.
-  #
-  # The third argument, +indent_empty_lines+, is a flag that says whether
-  # empty lines should be indented. Default is false.
-  #
-  #   "foo\n\nbar".indent(2)            # => "  foo\n\n  bar"
-  #   "foo\n\nbar".indent(2, nil, true) # => "  foo\n  \n  bar"
-  #
-  def indent(amount, indent_string = nil, indent_empty_lines = false)
-    dup.tap { |_| _.indent!(amount, indent_string, indent_empty_lines) }
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/inflections.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/inflections.rb
deleted file mode 100644
index 9bf465bda3e97..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/inflections.rb
+++ /dev/null
@@ -1,293 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/inflector/methods"
-require "active_support/inflector/transliterate"
-
-# String inflections define new methods on the String class to transform names for different purposes.
-# For instance, you can figure out the name of a table from the name of a class.
-#
-#   'ScaleScore'.tableize # => "scale_scores"
-#
-class String
-  # Returns the plural form of the word in the string.
-  #
-  # If the optional parameter +count+ is specified,
-  # the singular form will be returned if <tt>count == 1</tt>.
-  # For any other value of +count+ the plural will be returned.
-  #
-  # If the optional parameter +locale+ is specified,
-  # the word will be pluralized as a word of that language.
-  # By default, this parameter is set to <tt>:en</tt>.
-  # You must define your own inflection rules for languages other than English.
-  #
-  #   'post'.pluralize             # => "posts"
-  #   'octopus'.pluralize          # => "octopi"
-  #   'sheep'.pluralize            # => "sheep"
-  #   'words'.pluralize            # => "words"
-  #   'the blue mailman'.pluralize # => "the blue mailmen"
-  #   'CamelOctopus'.pluralize     # => "CamelOctopi"
-  #   'apple'.pluralize(1)         # => "apple"
-  #   'apple'.pluralize(2)         # => "apples"
-  #   'ley'.pluralize(:es)         # => "leyes"
-  #   'ley'.pluralize(1, :es)      # => "ley"
-  #
-  # See ActiveSupport::Inflector.pluralize.
-  def pluralize(count = nil, locale = :en)
-    locale = count if count.is_a?(Symbol)
-    if count == 1
-      dup
-    else
-      ActiveSupport::Inflector.pluralize(self, locale)
-    end
-  end
-
-  # The reverse of +pluralize+, returns the singular form of a word in a string.
-  #
-  # If the optional parameter +locale+ is specified,
-  # the word will be singularized as a word of that language.
-  # By default, this parameter is set to <tt>:en</tt>.
-  # You must define your own inflection rules for languages other than English.
-  #
-  #   'posts'.singularize            # => "post"
-  #   'octopi'.singularize           # => "octopus"
-  #   'sheep'.singularize            # => "sheep"
-  #   'word'.singularize             # => "word"
-  #   'the blue mailmen'.singularize # => "the blue mailman"
-  #   'CamelOctopi'.singularize      # => "CamelOctopus"
-  #   'leyes'.singularize(:es)       # => "ley"
-  #
-  # See ActiveSupport::Inflector.singularize.
-  def singularize(locale = :en)
-    ActiveSupport::Inflector.singularize(self, locale)
-  end
-
-  # +constantize+ tries to find a declared constant with the name specified
-  # in the string. It raises a NameError when the name is not in CamelCase
-  # or is not initialized.
-  #
-  #   'Module'.constantize  # => Module
-  #   'Class'.constantize   # => Class
-  #   'blargle'.constantize # => NameError: wrong constant name blargle
-  #
-  # See ActiveSupport::Inflector.constantize.
-  def constantize
-    ActiveSupport::Inflector.constantize(self)
-  end
-
-  # +safe_constantize+ tries to find a declared constant with the name specified
-  # in the string. It returns +nil+ when the name is not in CamelCase
-  # or is not initialized.
-  #
-  #   'Module'.safe_constantize  # => Module
-  #   'Class'.safe_constantize   # => Class
-  #   'blargle'.safe_constantize # => nil
-  #
-  # See ActiveSupport::Inflector.safe_constantize.
-  def safe_constantize
-    ActiveSupport::Inflector.safe_constantize(self)
-  end
-
-  # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
-  # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
-  #
-  # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
-  #
-  #   'active_record'.camelize                # => "ActiveRecord"
-  #   'active_record'.camelize(:lower)        # => "activeRecord"
-  #   'active_record/errors'.camelize         # => "ActiveRecord::Errors"
-  #   'active_record/errors'.camelize(:lower) # => "activeRecord::Errors"
-  #
-  # +camelize+ is also aliased as +camelcase+.
-  #
-  # See ActiveSupport::Inflector.camelize.
-  def camelize(first_letter = :upper)
-    case first_letter
-    when :upper
-      ActiveSupport::Inflector.camelize(self, true)
-    when :lower
-      ActiveSupport::Inflector.camelize(self, false)
-    else
-      raise ArgumentError, "Invalid option, use either :upper or :lower."
-    end
-  end
-  alias_method :camelcase, :camelize
-
-  # Capitalizes all the words and replaces some characters in the string to create
-  # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
-  # used in the Rails internals.
-  #
-  # The trailing '_id','Id'.. can be kept and capitalized by setting the
-  # optional parameter +keep_id_suffix+ to true.
-  # By default, this parameter is false.
-  #
-  #   'man from the boondocks'.titleize                       # => "Man From The Boondocks"
-  #   'x-men: the last stand'.titleize                        # => "X Men: The Last Stand"
-  #   'string_ending_with_id'.titleize(keep_id_suffix: true)  # => "String Ending With Id"
-  #
-  # +titleize+ is also aliased as +titlecase+.
-  #
-  # See ActiveSupport::Inflector.titleize.
-  def titleize(keep_id_suffix: false)
-    ActiveSupport::Inflector.titleize(self, keep_id_suffix: keep_id_suffix)
-  end
-  alias_method :titlecase, :titleize
-
-  # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
-  #
-  # +underscore+ will also change '::' to '/' to convert namespaces to paths.
-  #
-  #   'ActiveModel'.underscore         # => "active_model"
-  #   'ActiveModel::Errors'.underscore # => "active_model/errors"
-  #
-  # See ActiveSupport::Inflector.underscore.
-  def underscore
-    ActiveSupport::Inflector.underscore(self)
-  end
-
-  # Replaces underscores with dashes in the string.
-  #
-  #   'puni_puni'.dasherize # => "puni-puni"
-  #
-  # See ActiveSupport::Inflector.dasherize.
-  def dasherize
-    ActiveSupport::Inflector.dasherize(self)
-  end
-
-  # Removes the module part from the constant expression in the string.
-  #
-  #   'ActiveSupport::Inflector::Inflections'.demodulize # => "Inflections"
-  #   'Inflections'.demodulize                           # => "Inflections"
-  #   '::Inflections'.demodulize                         # => "Inflections"
-  #   ''.demodulize                                      # => ''
-  #
-  # See ActiveSupport::Inflector.demodulize.
-  #
-  # See also +deconstantize+.
-  def demodulize
-    ActiveSupport::Inflector.demodulize(self)
-  end
-
-  # Removes the rightmost segment from the constant expression in the string.
-  #
-  #   'Net::HTTP'.deconstantize   # => "Net"
-  #   '::Net::HTTP'.deconstantize # => "::Net"
-  #   'String'.deconstantize      # => ""
-  #   '::String'.deconstantize    # => ""
-  #   ''.deconstantize            # => ""
-  #
-  # See ActiveSupport::Inflector.deconstantize.
-  #
-  # See also +demodulize+.
-  def deconstantize
-    ActiveSupport::Inflector.deconstantize(self)
-  end
-
-  # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
-  #
-  # If the optional parameter +locale+ is specified,
-  # the word will be parameterized as a word of that language.
-  # By default, this parameter is set to <tt>nil</tt> and it will use
-  # the configured <tt>I18n.locale</tt>.
-  #
-  #   class Person
-  #     def to_param
-  #       "#{id}-#{name.parameterize}"
-  #     end
-  #   end
-  #
-  #   @person = Person.find(1)
-  #   # => #<Person id: 1, name: "Donald E. Knuth">
-  #
-  #   <%= link_to(@person.name, person_path) %>
-  #   # => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>
-  #
-  # To preserve the case of the characters in a string, use the +preserve_case+ argument.
-  #
-  #   class Person
-  #     def to_param
-  #       "#{id}-#{name.parameterize(preserve_case: true)}"
-  #     end
-  #   end
-  #
-  #   @person = Person.find(1)
-  #   # => #<Person id: 1, name: "Donald E. Knuth">
-  #
-  #   <%= link_to(@person.name, person_path) %>
-  #   # => <a href="/person/1-Donald-E-Knuth">Donald E. Knuth</a>
-  #
-  # See ActiveSupport::Inflector.parameterize.
-  def parameterize(separator: "-", preserve_case: false, locale: nil)
-    ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case, locale: locale)
-  end
-
-  # Creates the name of a table like Rails does for models to table names. This method
-  # uses the +pluralize+ method on the last word in the string.
-  #
-  #   'RawScaledScorer'.tableize # => "raw_scaled_scorers"
-  #   'ham_and_egg'.tableize     # => "ham_and_eggs"
-  #   'fancyCategory'.tableize   # => "fancy_categories"
-  #
-  # See ActiveSupport::Inflector.tableize.
-  def tableize
-    ActiveSupport::Inflector.tableize(self)
-  end
-
-  # Creates a class name from a plural table name like Rails does for table names to models.
-  # Note that this returns a string and not a class. (To convert to an actual class
-  # follow +classify+ with +constantize+.)
-  #
-  #   'ham_and_eggs'.classify # => "HamAndEgg"
-  #   'posts'.classify        # => "Post"
-  #
-  # See ActiveSupport::Inflector.classify.
-  def classify
-    ActiveSupport::Inflector.classify(self)
-  end
-
-  # Capitalizes the first word, turns underscores into spaces, and (by default)strips a
-  # trailing '_id' if present.
-  # Like +titleize+, this is meant for creating pretty output.
-  #
-  # The capitalization of the first word can be turned off by setting the
-  # optional parameter +capitalize+ to false.
-  # By default, this parameter is true.
-  #
-  # The trailing '_id' can be kept and capitalized by setting the
-  # optional parameter +keep_id_suffix+ to true.
-  # By default, this parameter is false.
-  #
-  #   'employee_salary'.humanize                    # => "Employee salary"
-  #   'author_id'.humanize                          # => "Author"
-  #   'author_id'.humanize(capitalize: false)       # => "author"
-  #   '_id'.humanize                                # => "Id"
-  #   'author_id'.humanize(keep_id_suffix: true)    # => "Author Id"
-  #
-  # See ActiveSupport::Inflector.humanize.
-  def humanize(capitalize: true, keep_id_suffix: false)
-    ActiveSupport::Inflector.humanize(self, capitalize: capitalize, keep_id_suffix: keep_id_suffix)
-  end
-
-  # Converts just the first character to uppercase.
-  #
-  #   'what a Lovely Day'.upcase_first # => "What a Lovely Day"
-  #   'w'.upcase_first                 # => "W"
-  #   ''.upcase_first                  # => ""
-  #
-  # See ActiveSupport::Inflector.upcase_first.
-  def upcase_first
-    ActiveSupport::Inflector.upcase_first(self)
-  end
-
-  # Creates a foreign key name from a class name.
-  # +separate_class_name_and_id_with_underscore+ sets whether
-  # the method should put '_' between the name and 'id'.
-  #
-  #   'Message'.foreign_key        # => "message_id"
-  #   'Message'.foreign_key(false) # => "messageid"
-  #   'Admin::Post'.foreign_key    # => "post_id"
-  #
-  # See ActiveSupport::Inflector.foreign_key.
-  def foreign_key(separate_class_name_and_id_with_underscore = true)
-    ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/inquiry.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/inquiry.rb
deleted file mode 100644
index d78ad9b741f87..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/inquiry.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/string_inquirer"
-require "active_support/environment_inquirer"
-
-class String
-  # Wraps the current string in the <tt>ActiveSupport::StringInquirer</tt> class,
-  # which gives you a prettier way to test for equality.
-  #
-  #   env = 'production'.inquiry
-  #   env.production?  # => true
-  #   env.development? # => false
-  def inquiry
-    ActiveSupport::StringInquirer.new(self)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/multibyte.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/multibyte.rb
deleted file mode 100644
index 0542121e39bce..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/multibyte.rb
+++ /dev/null
@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/multibyte"
-
-class String
-  # == Multibyte proxy
-  #
-  # +mb_chars+ is a multibyte safe proxy for string methods.
-  #
-  # It creates and returns an instance of the ActiveSupport::Multibyte::Chars class which
-  # encapsulates the original string. A Unicode safe version of all the String methods are defined on this proxy
-  # class. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsulated string.
-  #
-  #   >> "lj".mb_chars.upcase.to_s
-  #   => "LJ"
-  #
-  # NOTE: Ruby 2.4 and later support native Unicode case mappings:
-  #
-  #   >> "lj".upcase
-  #   => "LJ"
-  #
-  # == Method chaining
-  #
-  # All the methods on the Chars proxy which normally return a string will return a Chars object. This allows
-  # method chaining on the result of any of these methods.
-  #
-  #   name.mb_chars.reverse.length # => 12
-  #
-  # == Interoperability and configuration
-  #
-  # The Chars object tries to be as interchangeable with String objects as possible: sorting and comparing between
-  # String and Char work like expected. The bang! methods change the internal string representation in the Chars
-  # object. Interoperability problems can be resolved easily with a +to_s+ call.
-  #
-  # For more information about the methods defined on the Chars proxy see ActiveSupport::Multibyte::Chars. For
-  # information about how to change the default Multibyte behavior see ActiveSupport::Multibyte.
-  def mb_chars
-    ActiveSupport::Multibyte.proxy_class.new(self)
-  end
-
-  # Returns +true+ if string has utf_8 encoding.
-  #
-  #   utf_8_str = "some string".encode "UTF-8"
-  #   iso_str = "some string".encode "ISO-8859-1"
-  #
-  #   utf_8_str.is_utf8? # => true
-  #   iso_str.is_utf8?   # => false
-  def is_utf8?
-    case encoding
-    when Encoding::UTF_8, Encoding::US_ASCII
-      valid_encoding?
-    when Encoding::ASCII_8BIT
-      dup.force_encoding(Encoding::UTF_8).valid_encoding?
-    else
-      false
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/output_safety.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/output_safety.rb
deleted file mode 100644
index 8a06ccdd8e385..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/output_safety.rb
+++ /dev/null
@@ -1,343 +0,0 @@
-# frozen_string_literal: true
-
-require "erb"
-require "active_support/core_ext/module/redefine_method"
-require "active_support/multibyte/unicode"
-
-class ERB
-  module Util
-    HTML_ESCAPE = { "&" => "&amp;",  ">" => "&gt;",   "<" => "&lt;", '"' => "&quot;", "'" => "&#39;" }
-    JSON_ESCAPE = { "&" => '\u0026', ">" => '\u003e', "<" => '\u003c', "\u2028" => '\u2028', "\u2029" => '\u2029' }
-    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+)|(#[xX][\dA-Fa-f]+));)/
-    JSON_ESCAPE_REGEXP = /[\u2028\u2029&><]/u
-
-    # Following XML requirements: https://www.w3.org/TR/REC-xml/#NT-Name
-    TAG_NAME_START_REGEXP_SET = "@:A-Z_a-z\u{C0}-\u{D6}\u{D8}-\u{F6}\u{F8}-\u{2FF}\u{370}-\u{37D}\u{37F}-\u{1FFF}" \
-                                "\u{200C}-\u{200D}\u{2070}-\u{218F}\u{2C00}-\u{2FEF}\u{3001}-\u{D7FF}\u{F900}-\u{FDCF}" \
-                                "\u{FDF0}-\u{FFFD}\u{10000}-\u{EFFFF}"
-    TAG_NAME_START_REGEXP = /[^#{TAG_NAME_START_REGEXP_SET}]/
-    TAG_NAME_FOLLOWING_REGEXP = /[^#{TAG_NAME_START_REGEXP_SET}\-.0-9\u{B7}\u{0300}-\u{036F}\u{203F}-\u{2040}]/
-    TAG_NAME_REPLACEMENT_CHAR = "_"
-
-    # A utility method for escaping HTML tag characters.
-    # This method is also aliased as <tt>h</tt>.
-    #
-    #   puts html_escape('is a > 0 & a < 10?')
-    #   # => is a &gt; 0 &amp; a &lt; 10?
-    def html_escape(s)
-      unwrapped_html_escape(s).html_safe
-    end
-
-    silence_redefinition_of_method :h
-    alias h html_escape
-
-    module_function :h
-
-    singleton_class.silence_redefinition_of_method :html_escape
-    module_function :html_escape
-
-    # HTML escapes strings but doesn't wrap them with an ActiveSupport::SafeBuffer.
-    # This method is not for public consumption! Seriously!
-    def unwrapped_html_escape(s) # :nodoc:
-      s = s.to_s
-      if s.html_safe?
-        s
-      else
-        CGI.escapeHTML(ActiveSupport::Multibyte::Unicode.tidy_bytes(s))
-      end
-    end
-    module_function :unwrapped_html_escape
-
-    # A utility method for escaping HTML without affecting existing escaped entities.
-    #
-    #   html_escape_once('1 < 2 &amp; 3')
-    #   # => "1 &lt; 2 &amp; 3"
-    #
-    #   html_escape_once('&lt;&lt; Accept & Checkout')
-    #   # => "&lt;&lt; Accept &amp; Checkout"
-    def html_escape_once(s)
-      result = ActiveSupport::Multibyte::Unicode.tidy_bytes(s.to_s).gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE)
-      s.html_safe? ? result.html_safe : result
-    end
-
-    module_function :html_escape_once
-
-    # A utility method for escaping HTML entities in JSON strings. Specifically, the
-    # &, > and < characters are replaced with their equivalent unicode escaped form -
-    # \u0026, \u003e, and \u003c. The Unicode sequences \u2028 and \u2029 are also
-    # escaped as they are treated as newline characters in some JavaScript engines.
-    # These sequences have identical meaning as the original characters inside the
-    # context of a JSON string, so assuming the input is a valid and well-formed
-    # JSON value, the output will have equivalent meaning when parsed:
-    #
-    #   json = JSON.generate({ name: "</script><script>alert('PWNED!!!')</script>"})
-    #   # => "{\"name\":\"</script><script>alert('PWNED!!!')</script>\"}"
-    #
-    #   json_escape(json)
-    #   # => "{\"name\":\"\\u003C/script\\u003E\\u003Cscript\\u003Ealert('PWNED!!!')\\u003C/script\\u003E\"}"
-    #
-    #   JSON.parse(json) == JSON.parse(json_escape(json))
-    #   # => true
-    #
-    # The intended use case for this method is to escape JSON strings before including
-    # them inside a script tag to avoid XSS vulnerability:
-    #
-    #   <script>
-    #     var currentUser = <%= raw json_escape(current_user.to_json) %>;
-    #   </script>
-    #
-    # It is necessary to +raw+ the result of +json_escape+, so that quotation marks
-    # don't get converted to <tt>&quot;</tt> entities. +json_escape+ doesn't
-    # automatically flag the result as HTML safe, since the raw value is unsafe to
-    # use inside HTML attributes.
-    #
-    # If your JSON is being used downstream for insertion into the DOM, be aware of
-    # whether or not it is being inserted via <tt>html()</tt>. Most jQuery plugins do this.
-    # If that is the case, be sure to +html_escape+ or +sanitize+ any user-generated
-    # content returned by your JSON.
-    #
-    # If you need to output JSON elsewhere in your HTML, you can just do something
-    # like this, as any unsafe characters (including quotation marks) will be
-    # automatically escaped for you:
-    #
-    #   <div data-user-info="<%= current_user.to_json %>">...</div>
-    #
-    # WARNING: this helper only works with valid JSON. Using this on non-JSON values
-    # will open up serious XSS vulnerabilities. For example, if you replace the
-    # +current_user.to_json+ in the example above with user input instead, the browser
-    # will happily eval() that string as JavaScript.
-    #
-    # The escaping performed in this method is identical to those performed in the
-    # Active Support JSON encoder when +ActiveSupport.escape_html_entities_in_json+ is
-    # set to true. Because this transformation is idempotent, this helper can be
-    # applied even if +ActiveSupport.escape_html_entities_in_json+ is already true.
-    #
-    # Therefore, when you are unsure if +ActiveSupport.escape_html_entities_in_json+
-    # is enabled, or if you are unsure where your JSON string originated from, it
-    # is recommended that you always apply this helper (other libraries, such as the
-    # JSON gem, do not provide this kind of protection by default; also some gems
-    # might override +to_json+ to bypass Active Support's encoder).
-    def json_escape(s)
-      result = s.to_s.gsub(JSON_ESCAPE_REGEXP, JSON_ESCAPE)
-      s.html_safe? ? result.html_safe : result
-    end
-
-    module_function :json_escape
-
-    # A utility method for escaping XML names of tags and names of attributes.
-    #
-    #   xml_name_escape('1 < 2 & 3')
-    #   # => "1___2___3"
-    #
-    # It follows the requirements of the specification: https://www.w3.org/TR/REC-xml/#NT-Name
-    def xml_name_escape(name)
-      name = name.to_s
-      return "" if name.blank?
-
-      starting_char = name[0].gsub(TAG_NAME_START_REGEXP, TAG_NAME_REPLACEMENT_CHAR)
-
-      return starting_char if name.size == 1
-
-      following_chars = name[1..-1].gsub(TAG_NAME_FOLLOWING_REGEXP, TAG_NAME_REPLACEMENT_CHAR)
-
-      starting_char + following_chars
-    end
-    module_function :xml_name_escape
-  end
-end
-
-class Object
-  def html_safe?
-    false
-  end
-end
-
-class Numeric
-  def html_safe?
-    true
-  end
-end
-
-module ActiveSupport #:nodoc:
-  class SafeBuffer < String
-    UNSAFE_STRING_METHODS = %w(
-      capitalize chomp chop delete delete_prefix delete_suffix
-      downcase lstrip next reverse rstrip scrub slice squeeze strip
-      succ swapcase tr tr_s unicode_normalize upcase
-    )
-
-    UNSAFE_STRING_METHODS_WITH_BACKREF = %w(gsub sub)
-
-    alias_method :original_concat, :concat
-    private :original_concat
-
-    # Raised when <tt>ActiveSupport::SafeBuffer#safe_concat</tt> is called on unsafe buffers.
-    class SafeConcatError < StandardError
-      def initialize
-        super "Could not concatenate to the buffer because it is not html safe."
-      end
-    end
-
-    def [](*args)
-      if html_safe?
-        new_string = super
-
-        return unless new_string
-
-        new_safe_buffer = new_string.is_a?(SafeBuffer) ? new_string : SafeBuffer.new(new_string)
-        new_safe_buffer.instance_variable_set :@html_safe, true
-        new_safe_buffer
-      else
-        to_str[*args]
-      end
-    end
-
-    def safe_concat(value)
-      raise SafeConcatError unless html_safe?
-      original_concat(value)
-    end
-
-    def initialize(str = "")
-      @html_safe = true
-      super
-    end
-
-    def initialize_copy(other)
-      super
-      @html_safe = other.html_safe?
-    end
-
-    def clone_empty
-      self[0, 0]
-    end
-
-    def concat(value)
-      super(html_escape_interpolated_argument(value))
-    end
-    alias << concat
-
-    def insert(index, value)
-      super(index, html_escape_interpolated_argument(value))
-    end
-
-    def prepend(value)
-      super(html_escape_interpolated_argument(value))
-    end
-
-    def replace(value)
-      super(html_escape_interpolated_argument(value))
-    end
-
-    def []=(*args)
-      if args.length == 3
-        super(args[0], args[1], html_escape_interpolated_argument(args[2]))
-      else
-        super(args[0], html_escape_interpolated_argument(args[1]))
-      end
-    end
-
-    def +(other)
-      dup.concat(other)
-    end
-
-    def *(*)
-      new_string = super
-      new_safe_buffer = new_string.is_a?(SafeBuffer) ? new_string : SafeBuffer.new(new_string)
-      new_safe_buffer.instance_variable_set(:@html_safe, @html_safe)
-      new_safe_buffer
-    end
-
-    def %(args)
-      case args
-      when Hash
-        escaped_args = args.transform_values { |arg| html_escape_interpolated_argument(arg) }
-      else
-        escaped_args = Array(args).map { |arg| html_escape_interpolated_argument(arg) }
-      end
-
-      self.class.new(super(escaped_args))
-    end
-
-    def html_safe?
-      defined?(@html_safe) && @html_safe
-    end
-
-    def to_s
-      self
-    end
-
-    def to_param
-      to_str
-    end
-
-    def encode_with(coder)
-      coder.represent_object nil, to_str
-    end
-
-    UNSAFE_STRING_METHODS.each do |unsafe_method|
-      if unsafe_method.respond_to?(unsafe_method)
-        class_eval <<-EOT, __FILE__, __LINE__ + 1
-          def #{unsafe_method}(*args, &block)       # def capitalize(*args, &block)
-            to_str.#{unsafe_method}(*args, &block)  #   to_str.capitalize(*args, &block)
-          end                                       # end
-
-          def #{unsafe_method}!(*args)              # def capitalize!(*args)
-            @html_safe = false                      #   @html_safe = false
-            super                                   #   super
-          end                                       # end
-        EOT
-      end
-    end
-
-    UNSAFE_STRING_METHODS_WITH_BACKREF.each do |unsafe_method|
-      if unsafe_method.respond_to?(unsafe_method)
-        class_eval <<-EOT, __FILE__, __LINE__ + 1
-          def #{unsafe_method}(*args, &block)             # def gsub(*args, &block)
-            if block                                      #   if block
-              to_str.#{unsafe_method}(*args) { |*params|  #     to_str.gsub(*args) { |*params|
-                set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
-                block.call(*params)                       #       block.call(*params)
-              }                                           #     }
-            else                                          #   else
-              to_str.#{unsafe_method}(*args)              #     to_str.gsub(*args)
-            end                                           #   end
-          end                                             # end
-
-          def #{unsafe_method}!(*args, &block)            # def gsub!(*args, &block)
-            @html_safe = false                            #   @html_safe = false
-            if block                                      #   if block
-              super(*args) { |*params|                    #     super(*args) { |*params|
-                set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
-                block.call(*params)                       #       block.call(*params)
-              }                                           #     }
-            else                                          #   else
-              super                                       #     super
-            end                                           #   end
-          end                                             # end
-        EOT
-      end
-    end
-
-    private
-      def html_escape_interpolated_argument(arg)
-        (!html_safe? || arg.html_safe?) ? arg : CGI.escapeHTML(arg.to_s)
-      end
-
-      def set_block_back_references(block, match_data)
-        block.binding.eval("proc { |m| $~ = m }").call(match_data)
-      rescue ArgumentError
-        # Can't create binding from C level Proc
-      end
-  end
-end
-
-class String
-  # Marks a string as trusted safe. It will be inserted into HTML with no
-  # additional escaping performed. It is your responsibility to ensure that the
-  # string contains no malicious content. This method is equivalent to the
-  # +raw+ helper in views. It is recommended that you use +sanitize+ instead of
-  # this method. It should never be called on user input.
-  def html_safe
-    ActiveSupport::SafeBuffer.new(self)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/starts_ends_with.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/starts_ends_with.rb
deleted file mode 100644
index 1e216370e4980..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/starts_ends_with.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-class String
-  alias :starts_with? :start_with?
-  alias :ends_with? :end_with?
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/strip.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/strip.rb
deleted file mode 100644
index 60e9952ee62c6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/strip.rb
+++ /dev/null
@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-class String
-  # Strips indentation in heredocs.
-  #
-  # For example in
-  #
-  #   if options[:usage]
-  #     puts <<-USAGE.strip_heredoc
-  #       This command does such and such.
-  #
-  #       Supported options are:
-  #         -h         This message
-  #         ...
-  #     USAGE
-  #   end
-  #
-  # the user would see the usage message aligned against the left margin.
-  #
-  # Technically, it looks for the least indented non-empty line
-  # in the whole string, and removes that amount of leading whitespace.
-  def strip_heredoc
-    gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "").tap do |stripped|
-      stripped.freeze if frozen?
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/zones.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/zones.rb
deleted file mode 100644
index 55dc231464bd0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/string/zones.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/string/conversions"
-require "active_support/core_ext/time/zones"
-
-class String
-  # Converts String to a TimeWithZone in the current zone if Time.zone or Time.zone_default
-  # is set, otherwise converts String to a Time via String#to_time
-  def in_time_zone(zone = ::Time.zone)
-    if zone
-      ::Time.find_zone!(zone).parse(self)
-    else
-      to_time
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/symbol.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/symbol.rb
deleted file mode 100644
index 709fed2024f2b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/symbol.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/symbol/starts_ends_with"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/symbol/starts_ends_with.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/symbol/starts_ends_with.rb
deleted file mode 100644
index 655a5394034f2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/symbol/starts_ends_with.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-class Symbol
-  def start_with?(*prefixes)
-    to_s.start_with?(*prefixes)
-  end unless method_defined?(:start_with?)
-
-  def end_with?(*suffixes)
-    to_s.end_with?(*suffixes)
-  end unless method_defined?(:end_with?)
-
-  alias :starts_with? :start_with?
-  alias :ends_with? :end_with?
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time.rb
deleted file mode 100644
index c809def05f35b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/time/acts_like"
-require "active_support/core_ext/time/calculations"
-require "active_support/core_ext/time/compatibility"
-require "active_support/core_ext/time/conversions"
-require "active_support/core_ext/time/zones"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/acts_like.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/acts_like.rb
deleted file mode 100644
index 8572b49639959..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/acts_like.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/acts_like"
-
-class Time
-  # Duck-types as a Time-like class. See Object#acts_like?.
-  def acts_like_time?
-    true
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/calculations.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/calculations.rb
deleted file mode 100644
index 1a7d503fe5689..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/calculations.rb
+++ /dev/null
@@ -1,365 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/duration"
-require "active_support/core_ext/time/conversions"
-require "active_support/time_with_zone"
-require "active_support/core_ext/time/zones"
-require "active_support/core_ext/date_and_time/calculations"
-require "active_support/core_ext/date/calculations"
-require "active_support/core_ext/module/remove_method"
-
-class Time
-  include DateAndTime::Calculations
-
-  COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-
-  class << self
-    # Overriding case equality method so that it returns true for ActiveSupport::TimeWithZone instances
-    def ===(other)
-      super || (self == Time && other.is_a?(ActiveSupport::TimeWithZone))
-    end
-
-    # Returns the number of days in the given month.
-    # If no year is specified, it will use the current year.
-    def days_in_month(month, year = current.year)
-      if month == 2 && ::Date.gregorian_leap?(year)
-        29
-      else
-        COMMON_YEAR_DAYS_IN_MONTH[month]
-      end
-    end
-
-    # Returns the number of days in the given year.
-    # If no year is specified, it will use the current year.
-    def days_in_year(year = current.year)
-      days_in_month(2, year) + 337
-    end
-
-    # Returns <tt>Time.zone.now</tt> when <tt>Time.zone</tt> or <tt>config.time_zone</tt> are set, otherwise just returns <tt>Time.now</tt>.
-    def current
-      ::Time.zone ? ::Time.zone.now : ::Time.now
-    end
-
-    # Layers additional behavior on Time.at so that ActiveSupport::TimeWithZone and DateTime
-    # instances can be used when called with a single argument
-    def at_with_coercion(*args)
-      return at_without_coercion(*args) if args.size != 1
-
-      # Time.at can be called with a time or numerical value
-      time_or_number = args.first
-
-      if time_or_number.is_a?(ActiveSupport::TimeWithZone)
-        at_without_coercion(time_or_number.to_r).getlocal
-      elsif time_or_number.is_a?(DateTime)
-        at_without_coercion(time_or_number.to_f).getlocal
-      else
-        at_without_coercion(time_or_number)
-      end
-    end
-    ruby2_keywords(:at_with_coercion) if respond_to?(:ruby2_keywords, true)
-    alias_method :at_without_coercion, :at
-    alias_method :at, :at_with_coercion
-
-    # Creates a +Time+ instance from an RFC 3339 string.
-    #
-    #   Time.rfc3339('1999-12-31T14:00:00-10:00') # => 2000-01-01 00:00:00 -1000
-    #
-    # If the time or offset components are missing then an +ArgumentError+ will be raised.
-    #
-    #   Time.rfc3339('1999-12-31') # => ArgumentError: invalid date
-    def rfc3339(str)
-      parts = Date._rfc3339(str)
-
-      raise ArgumentError, "invalid date" if parts.empty?
-
-      Time.new(
-        parts.fetch(:year),
-        parts.fetch(:mon),
-        parts.fetch(:mday),
-        parts.fetch(:hour),
-        parts.fetch(:min),
-        parts.fetch(:sec) + parts.fetch(:sec_fraction, 0),
-        parts.fetch(:offset)
-      )
-    end
-  end
-
-  # Returns the number of seconds since 00:00:00.
-  #
-  #   Time.new(2012, 8, 29,  0,  0,  0).seconds_since_midnight # => 0.0
-  #   Time.new(2012, 8, 29, 12, 34, 56).seconds_since_midnight # => 45296.0
-  #   Time.new(2012, 8, 29, 23, 59, 59).seconds_since_midnight # => 86399.0
-  def seconds_since_midnight
-    to_i - change(hour: 0).to_i + (usec / 1.0e+6)
-  end
-
-  # Returns the number of seconds until 23:59:59.
-  #
-  #   Time.new(2012, 8, 29,  0,  0,  0).seconds_until_end_of_day # => 86399
-  #   Time.new(2012, 8, 29, 12, 34, 56).seconds_until_end_of_day # => 41103
-  #   Time.new(2012, 8, 29, 23, 59, 59).seconds_until_end_of_day # => 0
-  def seconds_until_end_of_day
-    end_of_day.to_i - to_i
-  end
-
-  # Returns the fraction of a second as a +Rational+
-  #
-  #   Time.new(2012, 8, 29, 0, 0, 0.5).sec_fraction # => (1/2)
-  def sec_fraction
-    subsec
-  end
-
-  unless Time.method_defined?(:floor)
-    def floor(precision = 0)
-      change(nsec: 0) + subsec.floor(precision)
-    end
-  end
-
-  # Restricted Ruby version due to a bug in `Time#ceil`
-  # See https://bugs.ruby-lang.org/issues/17025 for more details
-  if RUBY_VERSION <= "2.8"
-    remove_possible_method :ceil
-    def ceil(precision = 0)
-      change(nsec: 0) + subsec.ceil(precision)
-    end
-  end
-
-  # Returns a new Time where one or more of the elements have been changed according
-  # to the +options+ parameter. The time options (<tt>:hour</tt>, <tt>:min</tt>,
-  # <tt>:sec</tt>, <tt>:usec</tt>, <tt>:nsec</tt>) reset cascadingly, so if only
-  # the hour is passed, then minute, sec, usec and nsec is set to 0. If the hour
-  # and minute is passed, then sec, usec and nsec is set to 0. The +options+ parameter
-  # takes a hash with any of these keys: <tt>:year</tt>, <tt>:month</tt>, <tt>:day</tt>,
-  # <tt>:hour</tt>, <tt>:min</tt>, <tt>:sec</tt>, <tt>:usec</tt>, <tt>:nsec</tt>,
-  # <tt>:offset</tt>. Pass either <tt>:usec</tt> or <tt>:nsec</tt>, not both.
-  #
-  #   Time.new(2012, 8, 29, 22, 35, 0).change(day: 1)              # => Time.new(2012, 8, 1, 22, 35, 0)
-  #   Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, day: 1)  # => Time.new(1981, 8, 1, 22, 35, 0)
-  #   Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, hour: 0) # => Time.new(1981, 8, 29, 0, 0, 0)
-  def change(options)
-    new_year   = options.fetch(:year, year)
-    new_month  = options.fetch(:month, month)
-    new_day    = options.fetch(:day, day)
-    new_hour   = options.fetch(:hour, hour)
-    new_min    = options.fetch(:min, options[:hour] ? 0 : min)
-    new_sec    = options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec)
-    new_offset = options.fetch(:offset, nil)
-
-    if new_nsec = options[:nsec]
-      raise ArgumentError, "Can't change both :nsec and :usec at the same time: #{options.inspect}" if options[:usec]
-      new_usec = Rational(new_nsec, 1000)
-    else
-      new_usec = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
-    end
-
-    raise ArgumentError, "argument out of range" if new_usec >= 1000000
-
-    new_sec += Rational(new_usec, 1000000)
-
-    if new_offset
-      ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, new_offset)
-    elsif utc?
-      ::Time.utc(new_year, new_month, new_day, new_hour, new_min, new_sec)
-    elsif zone&.respond_to?(:utc_to_local)
-      ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, zone)
-    elsif zone
-      ::Time.local(new_year, new_month, new_day, new_hour, new_min, new_sec)
-    else
-      ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, utc_offset)
-    end
-  end
-
-  # Uses Date to provide precise Time calculations for years, months, and days
-  # according to the proleptic Gregorian calendar. The +options+ parameter
-  # takes a hash with any of these keys: <tt>:years</tt>, <tt>:months</tt>,
-  # <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>, <tt>:minutes</tt>,
-  # <tt>:seconds</tt>.
-  #
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(seconds: 1) # => 2015-08-01 14:35:01 -0700
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(minutes: 1) # => 2015-08-01 14:36:00 -0700
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(hours: 1)   # => 2015-08-01 15:35:00 -0700
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(days: 1)    # => 2015-08-02 14:35:00 -0700
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(weeks: 1)   # => 2015-08-08 14:35:00 -0700
-  def advance(options)
-    unless options[:weeks].nil?
-      options[:weeks], partial_weeks = options[:weeks].divmod(1)
-      options[:days] = options.fetch(:days, 0) + 7 * partial_weeks
-    end
-
-    unless options[:days].nil?
-      options[:days], partial_days = options[:days].divmod(1)
-      options[:hours] = options.fetch(:hours, 0) + 24 * partial_days
-    end
-
-    d = to_date.gregorian.advance(options)
-    time_advanced_by_date = change(year: d.year, month: d.month, day: d.day)
-    seconds_to_advance = \
-      options.fetch(:seconds, 0) +
-      options.fetch(:minutes, 0) * 60 +
-      options.fetch(:hours, 0) * 3600
-
-    if seconds_to_advance.zero?
-      time_advanced_by_date
-    else
-      time_advanced_by_date.since(seconds_to_advance)
-    end
-  end
-
-  # Returns a new Time representing the time a number of seconds ago, this is basically a wrapper around the Numeric extension
-  def ago(seconds)
-    since(-seconds)
-  end
-
-  # Returns a new Time representing the time a number of seconds since the instance time
-  def since(seconds)
-    self + seconds
-  rescue
-    to_datetime.since(seconds)
-  end
-  alias :in :since
-
-  # Returns a new Time representing the start of the day (0:00)
-  def beginning_of_day
-    change(hour: 0)
-  end
-  alias :midnight :beginning_of_day
-  alias :at_midnight :beginning_of_day
-  alias :at_beginning_of_day :beginning_of_day
-
-  # Returns a new Time representing the middle of the day (12:00)
-  def middle_of_day
-    change(hour: 12)
-  end
-  alias :midday :middle_of_day
-  alias :noon :middle_of_day
-  alias :at_midday :middle_of_day
-  alias :at_noon :middle_of_day
-  alias :at_middle_of_day :middle_of_day
-
-  # Returns a new Time representing the end of the day, 23:59:59.999999
-  def end_of_day
-    change(
-      hour: 23,
-      min: 59,
-      sec: 59,
-      usec: Rational(999999999, 1000)
-    )
-  end
-  alias :at_end_of_day :end_of_day
-
-  # Returns a new Time representing the start of the hour (x:00)
-  def beginning_of_hour
-    change(min: 0)
-  end
-  alias :at_beginning_of_hour :beginning_of_hour
-
-  # Returns a new Time representing the end of the hour, x:59:59.999999
-  def end_of_hour
-    change(
-      min: 59,
-      sec: 59,
-      usec: Rational(999999999, 1000)
-    )
-  end
-  alias :at_end_of_hour :end_of_hour
-
-  # Returns a new Time representing the start of the minute (x:xx:00)
-  def beginning_of_minute
-    change(sec: 0)
-  end
-  alias :at_beginning_of_minute :beginning_of_minute
-
-  # Returns a new Time representing the end of the minute, x:xx:59.999999
-  def end_of_minute
-    change(
-      sec: 59,
-      usec: Rational(999999999, 1000)
-    )
-  end
-  alias :at_end_of_minute :end_of_minute
-
-  def plus_with_duration(other) #:nodoc:
-    if ActiveSupport::Duration === other
-      other.since(self)
-    else
-      plus_without_duration(other)
-    end
-  end
-  alias_method :plus_without_duration, :+
-  alias_method :+, :plus_with_duration
-
-  def minus_with_duration(other) #:nodoc:
-    if ActiveSupport::Duration === other
-      other.until(self)
-    else
-      minus_without_duration(other)
-    end
-  end
-  alias_method :minus_without_duration, :-
-  alias_method :-, :minus_with_duration
-
-  # Time#- can also be used to determine the number of seconds between two Time instances.
-  # We're layering on additional behavior so that ActiveSupport::TimeWithZone instances
-  # are coerced into values that Time#- will recognize
-  def minus_with_coercion(other)
-    other = other.comparable_time if other.respond_to?(:comparable_time)
-    other.is_a?(DateTime) ? to_f - other.to_f : minus_without_coercion(other)
-  end
-  alias_method :minus_without_coercion, :-
-  alias_method :-, :minus_with_coercion
-
-  # Layers additional behavior on Time#<=> so that DateTime and ActiveSupport::TimeWithZone instances
-  # can be chronologically compared with a Time
-  def compare_with_coercion(other)
-    # we're avoiding Time#to_datetime and Time#to_time because they're expensive
-    if other.class == Time
-      compare_without_coercion(other)
-    elsif other.is_a?(Time)
-      compare_without_coercion(other.to_time)
-    else
-      to_datetime <=> other
-    end
-  end
-  alias_method :compare_without_coercion, :<=>
-  alias_method :<=>, :compare_with_coercion
-
-  # Layers additional behavior on Time#eql? so that ActiveSupport::TimeWithZone instances
-  # can be eql? to an equivalent Time
-  def eql_with_coercion(other)
-    # if other is an ActiveSupport::TimeWithZone, coerce a Time instance from it so we can do eql? comparison
-    other = other.comparable_time if other.respond_to?(:comparable_time)
-    eql_without_coercion(other)
-  end
-  alias_method :eql_without_coercion, :eql?
-  alias_method :eql?, :eql_with_coercion
-
-  # Returns a new time the specified number of days ago.
-  def prev_day(days = 1)
-    advance(days: -days)
-  end
-
-  # Returns a new time the specified number of days in the future.
-  def next_day(days = 1)
-    advance(days: days)
-  end
-
-  # Returns a new time the specified number of months ago.
-  def prev_month(months = 1)
-    advance(months: -months)
-  end
-
-  # Returns a new time the specified number of months in the future.
-  def next_month(months = 1)
-    advance(months: months)
-  end
-
-  # Returns a new time the specified number of years ago.
-  def prev_year(years = 1)
-    advance(years: -years)
-  end
-
-  # Returns a new time the specified number of years in the future.
-  def next_year(years = 1)
-    advance(years: years)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/compatibility.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/compatibility.rb
deleted file mode 100644
index 495e4f307b3fa..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/compatibility.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/date_and_time/compatibility"
-require "active_support/core_ext/module/redefine_method"
-
-class Time
-  include DateAndTime::Compatibility
-
-  silence_redefinition_of_method :to_time
-
-  # Either return +self+ or the time in the local system timezone depending
-  # on the setting of +ActiveSupport.to_time_preserves_timezone+.
-  def to_time
-    preserve_timezone ? self : getlocal
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/conversions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/conversions.rb
deleted file mode 100644
index d61a191e33342..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/conversions.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-require "active_support/inflector/methods"
-require "active_support/values/time_zone"
-
-class Time
-  DATE_FORMATS = {
-    db: "%Y-%m-%d %H:%M:%S",
-    inspect: "%Y-%m-%d %H:%M:%S.%9N %z",
-    number: "%Y%m%d%H%M%S",
-    nsec: "%Y%m%d%H%M%S%9N",
-    usec: "%Y%m%d%H%M%S%6N",
-    time: "%H:%M",
-    short: "%d %b %H:%M",
-    long: "%B %d, %Y %H:%M",
-    long_ordinal: lambda { |time|
-      day_format = ActiveSupport::Inflector.ordinalize(time.day)
-      time.strftime("%B #{day_format}, %Y %H:%M")
-    },
-    rfc822: lambda { |time|
-      offset_format = time.formatted_offset(false)
-      time.strftime("%a, %d %b %Y %H:%M:%S #{offset_format}")
-    },
-    iso8601: lambda { |time| time.iso8601 }
-  }
-
-  # Converts to a formatted string. See DATE_FORMATS for built-in formats.
-  #
-  # This method is aliased to <tt>to_s</tt>.
-  #
-  #   time = Time.now                    # => 2007-01-18 06:10:17 -06:00
-  #
-  #   time.to_formatted_s(:time)         # => "06:10"
-  #   time.to_s(:time)                   # => "06:10"
-  #
-  #   time.to_formatted_s(:db)           # => "2007-01-18 06:10:17"
-  #   time.to_formatted_s(:number)       # => "20070118061017"
-  #   time.to_formatted_s(:short)        # => "18 Jan 06:10"
-  #   time.to_formatted_s(:long)         # => "January 18, 2007 06:10"
-  #   time.to_formatted_s(:long_ordinal) # => "January 18th, 2007 06:10"
-  #   time.to_formatted_s(:rfc822)       # => "Thu, 18 Jan 2007 06:10:17 -0600"
-  #   time.to_formatted_s(:iso8601)      # => "2007-01-18T06:10:17-06:00"
-  #
-  # == Adding your own time formats to +to_formatted_s+
-  # You can add your own formats to the Time::DATE_FORMATS hash.
-  # Use the format name as the hash key and either a strftime string
-  # or Proc instance that takes a time argument as the value.
-  #
-  #   # config/initializers/time_formats.rb
-  #   Time::DATE_FORMATS[:month_and_year] = '%B %Y'
-  #   Time::DATE_FORMATS[:short_ordinal]  = ->(time) { time.strftime("%B #{time.day.ordinalize}") }
-  def to_formatted_s(format = :default)
-    if formatter = DATE_FORMATS[format]
-      formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
-    else
-      to_default_s
-    end
-  end
-  alias_method :to_default_s, :to_s
-  alias_method :to_s, :to_formatted_s
-
-  # Returns a formatted string of the offset from UTC, or an alternative
-  # string if the time zone is already UTC.
-  #
-  #   Time.local(2000).formatted_offset        # => "-06:00"
-  #   Time.local(2000).formatted_offset(false) # => "-0600"
-  def formatted_offset(colon = true, alternate_utc_string = nil)
-    utc? && alternate_utc_string || ActiveSupport::TimeZone.seconds_to_utc_offset(utc_offset, colon)
-  end
-
-  # Aliased to +xmlschema+ for compatibility with +DateTime+
-  alias_method :rfc3339, :xmlschema
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/zones.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/zones.rb
deleted file mode 100644
index a5588fd488f90..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/time/zones.rb
+++ /dev/null
@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/time_with_zone"
-require "active_support/core_ext/time/acts_like"
-require "active_support/core_ext/date_and_time/zones"
-
-class Time
-  include DateAndTime::Zones
-  class << self
-    attr_accessor :zone_default
-
-    # Returns the TimeZone for the current request, if this has been set (via Time.zone=).
-    # If <tt>Time.zone</tt> has not been set for the current request, returns the TimeZone specified in <tt>config.time_zone</tt>.
-    def zone
-      Thread.current[:time_zone] || zone_default
-    end
-
-    # Sets <tt>Time.zone</tt> to a TimeZone object for the current request/thread.
-    #
-    # This method accepts any of the following:
-    #
-    # * A Rails TimeZone object.
-    # * An identifier for a Rails TimeZone object (e.g., "Eastern Time (US & Canada)", <tt>-5.hours</tt>).
-    # * A TZInfo::Timezone object.
-    # * An identifier for a TZInfo::Timezone object (e.g., "America/New_York").
-    #
-    # Here's an example of how you might set <tt>Time.zone</tt> on a per request basis and reset it when the request is done.
-    # <tt>current_user.time_zone</tt> just needs to return a string identifying the user's preferred time zone:
-    #
-    #   class ApplicationController < ActionController::Base
-    #     around_action :set_time_zone
-    #
-    #     def set_time_zone
-    #       if logged_in?
-    #         Time.use_zone(current_user.time_zone) { yield }
-    #       else
-    #         yield
-    #       end
-    #     end
-    #   end
-    def zone=(time_zone)
-      Thread.current[:time_zone] = find_zone!(time_zone)
-    end
-
-    # Allows override of <tt>Time.zone</tt> locally inside supplied block;
-    # resets <tt>Time.zone</tt> to existing value when done.
-    #
-    #   class ApplicationController < ActionController::Base
-    #     around_action :set_time_zone
-    #
-    #     private
-    #
-    #     def set_time_zone
-    #       Time.use_zone(current_user.timezone) { yield }
-    #     end
-    #   end
-    #
-    # NOTE: This won't affect any <tt>ActiveSupport::TimeWithZone</tt>
-    # objects that have already been created, e.g. any model timestamp
-    # attributes that have been read before the block will remain in
-    # the application's default timezone.
-    def use_zone(time_zone)
-      new_zone = find_zone!(time_zone)
-      begin
-        old_zone, ::Time.zone = ::Time.zone, new_zone
-        yield
-      ensure
-        ::Time.zone = old_zone
-      end
-    end
-
-    # Returns a TimeZone instance matching the time zone provided.
-    # Accepts the time zone in any format supported by <tt>Time.zone=</tt>.
-    # Raises an +ArgumentError+ for invalid time zones.
-    #
-    #   Time.find_zone! "America/New_York" # => #<ActiveSupport::TimeZone @name="America/New_York" ...>
-    #   Time.find_zone! "EST"              # => #<ActiveSupport::TimeZone @name="EST" ...>
-    #   Time.find_zone! -5.hours           # => #<ActiveSupport::TimeZone @name="Bogota" ...>
-    #   Time.find_zone! nil                # => nil
-    #   Time.find_zone! false              # => false
-    #   Time.find_zone! "NOT-A-TIMEZONE"   # => ArgumentError: Invalid Timezone: NOT-A-TIMEZONE
-    def find_zone!(time_zone)
-      if !time_zone || time_zone.is_a?(ActiveSupport::TimeZone)
-        time_zone
-      else
-        # Look up the timezone based on the identifier (unless we've been
-        # passed a TZInfo::Timezone)
-        unless time_zone.respond_to?(:period_for_local)
-          time_zone = ActiveSupport::TimeZone[time_zone] || TZInfo::Timezone.get(time_zone)
-        end
-
-        # Return if a TimeZone instance, or wrap in a TimeZone instance if a TZInfo::Timezone
-        if time_zone.is_a?(ActiveSupport::TimeZone)
-          time_zone
-        else
-          ActiveSupport::TimeZone.create(time_zone.name, nil, time_zone)
-        end
-      end
-    rescue TZInfo::InvalidTimezoneIdentifier
-      raise ArgumentError, "Invalid Timezone: #{time_zone}"
-    end
-
-    # Returns a TimeZone instance matching the time zone provided.
-    # Accepts the time zone in any format supported by <tt>Time.zone=</tt>.
-    # Returns +nil+ for invalid time zones.
-    #
-    #   Time.find_zone "America/New_York" # => #<ActiveSupport::TimeZone @name="America/New_York" ...>
-    #   Time.find_zone "NOT-A-TIMEZONE"   # => nil
-    def find_zone(time_zone)
-      find_zone!(time_zone) rescue nil
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/uri.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/uri.rb
deleted file mode 100644
index fd5b0b31cc535..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/core_ext/uri.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "uri"
-
-if RUBY_VERSION < "2.6.0"
-  require "active_support/core_ext/module/redefine_method"
-  URI::Parser.class_eval do
-    silence_redefinition_of_method :unescape
-    def unescape(str, escaped = /%[a-fA-F\d]{2}/)
-      # TODO: Are we actually sure that ASCII == UTF-8?
-      # YK: My initial experiments say yes, but let's be sure please
-      enc = str.encoding
-      enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
-      str.dup.force_encoding(Encoding::ASCII_8BIT).gsub(escaped) { |match| [match[1, 2].hex].pack("C") }.force_encoding(enc)
-    end
-  end
-end
-
-module URI
-  class << self
-    def parser
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        URI.parser is deprecated and will be removed in Rails 7.0.
-        Use `URI::DEFAULT_PARSER` instead.
-      MSG
-      URI::DEFAULT_PARSER
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/current_attributes.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/current_attributes.rb
deleted file mode 100644
index 9be8f881c08a0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/current_attributes.rb
+++ /dev/null
@@ -1,209 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/callbacks"
-require "active_support/core_ext/enumerable"
-require "active_support/core_ext/module/delegation"
-
-module ActiveSupport
-  # Abstract super class that provides a thread-isolated attributes singleton, which resets automatically
-  # before and after each request. This allows you to keep all the per-request attributes easily
-  # available to the whole system.
-  #
-  # The following full app-like example demonstrates how to use a Current class to
-  # facilitate easy access to the global, per-request attributes without passing them deeply
-  # around everywhere:
-  #
-  #   # app/models/current.rb
-  #   class Current < ActiveSupport::CurrentAttributes
-  #     attribute :account, :user
-  #     attribute :request_id, :user_agent, :ip_address
-  #
-  #     resets { Time.zone = nil }
-  #
-  #     def user=(user)
-  #       super
-  #       self.account = user.account
-  #       Time.zone    = user.time_zone
-  #     end
-  #   end
-  #
-  #   # app/controllers/concerns/authentication.rb
-  #   module Authentication
-  #     extend ActiveSupport::Concern
-  #
-  #     included do
-  #       before_action :authenticate
-  #     end
-  #
-  #     private
-  #       def authenticate
-  #         if authenticated_user = User.find_by(id: cookies.encrypted[:user_id])
-  #           Current.user = authenticated_user
-  #         else
-  #           redirect_to new_session_url
-  #         end
-  #       end
-  #   end
-  #
-  #   # app/controllers/concerns/set_current_request_details.rb
-  #   module SetCurrentRequestDetails
-  #     extend ActiveSupport::Concern
-  #
-  #     included do
-  #       before_action do
-  #         Current.request_id = request.uuid
-  #         Current.user_agent = request.user_agent
-  #         Current.ip_address = request.ip
-  #       end
-  #     end
-  #   end
-  #
-  #   class ApplicationController < ActionController::Base
-  #     include Authentication
-  #     include SetCurrentRequestDetails
-  #   end
-  #
-  #   class MessagesController < ApplicationController
-  #     def create
-  #       Current.account.messages.create(message_params)
-  #     end
-  #   end
-  #
-  #   class Message < ApplicationRecord
-  #     belongs_to :creator, default: -> { Current.user }
-  #     after_create { |message| Event.create(record: message) }
-  #   end
-  #
-  #   class Event < ApplicationRecord
-  #     before_create do
-  #       self.request_id = Current.request_id
-  #       self.user_agent = Current.user_agent
-  #       self.ip_address = Current.ip_address
-  #     end
-  #   end
-  #
-  # A word of caution: It's easy to overdo a global singleton like Current and tangle your model as a result.
-  # Current should only be used for a few, top-level globals, like account, user, and request details.
-  # The attributes stuck in Current should be used by more or less all actions on all requests. If you start
-  # sticking controller-specific attributes in there, you're going to create a mess.
-  class CurrentAttributes
-    include ActiveSupport::Callbacks
-    define_callbacks :reset
-
-    class << self
-      # Returns singleton instance for this class in this thread. If none exists, one is created.
-      def instance
-        current_instances[current_instances_key] ||= new
-      end
-
-      # Declares one or more attributes that will be given both class and instance accessor methods.
-      def attribute(*names)
-        generated_attribute_methods.module_eval do
-          names.each do |name|
-            define_method(name) do
-              attributes[name.to_sym]
-            end
-
-            define_method("#{name}=") do |attribute|
-              attributes[name.to_sym] = attribute
-            end
-          end
-        end
-
-        names.each do |name|
-          define_singleton_method(name) do
-            instance.public_send(name)
-          end
-
-          define_singleton_method("#{name}=") do |attribute|
-            instance.public_send("#{name}=", attribute)
-          end
-        end
-      end
-
-      # Calls this block before #reset is called on the instance. Used for resetting external collaborators that depend on current values.
-      def before_reset(&block)
-        set_callback :reset, :before, &block
-      end
-
-      # Calls this block after #reset is called on the instance. Used for resetting external collaborators, like Time.zone.
-      def resets(&block)
-        set_callback :reset, :after, &block
-      end
-      alias_method :after_reset, :resets
-
-      delegate :set, :reset, to: :instance
-
-      def reset_all # :nodoc:
-        current_instances.each_value(&:reset)
-      end
-
-      def clear_all # :nodoc:
-        reset_all
-        current_instances.clear
-      end
-
-      private
-        def generated_attribute_methods
-          @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
-        end
-
-        def current_instances
-          Thread.current[:current_attributes_instances] ||= {}
-        end
-
-        def current_instances_key
-          @current_instances_key ||= name.to_sym
-        end
-
-        def method_missing(name, *args, &block)
-          # Caches the method definition as a singleton method of the receiver.
-          #
-          # By letting #delegate handle it, we avoid an enclosure that'll capture args.
-          singleton_class.delegate name, to: :instance
-
-          send(name, *args, &block)
-        end
-    end
-
-    attr_accessor :attributes
-
-    def initialize
-      @attributes = {}
-    end
-
-    # Expose one or more attributes within a block. Old values are returned after the block concludes.
-    # Example demonstrating the common use of needing to set Current attributes outside the request-cycle:
-    #
-    #   class Chat::PublicationJob < ApplicationJob
-    #     def perform(attributes, room_number, creator)
-    #       Current.set(person: creator) do
-    #         Chat::Publisher.publish(attributes: attributes, room_number: room_number)
-    #       end
-    #     end
-    #   end
-    def set(set_attributes)
-      old_attributes = compute_attributes(set_attributes.keys)
-      assign_attributes(set_attributes)
-      yield
-    ensure
-      assign_attributes(old_attributes)
-    end
-
-    # Reset all attributes. Should be called before and after actions, when used as a per-request singleton.
-    def reset
-      run_callbacks :reset do
-        self.attributes = {}
-      end
-    end
-
-    private
-      def assign_attributes(new_attributes)
-        new_attributes.each { |key, value| public_send("#{key}=", value) }
-      end
-
-      def compute_attributes(keys)
-        keys.index_with { |key| public_send(key) }
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/current_attributes/test_helper.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/current_attributes/test_helper.rb
deleted file mode 100644
index 2016384a80d89..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/current_attributes/test_helper.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport::CurrentAttributes::TestHelper # :nodoc:
-  def before_setup
-    ActiveSupport::CurrentAttributes.reset_all
-    super
-  end
-
-  def after_teardown
-    super
-    ActiveSupport::CurrentAttributes.reset_all
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation.rb
deleted file mode 100644
index 887328dcc32b0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "singleton"
-
-module ActiveSupport
-  # \Deprecation specifies the API used by Rails to deprecate methods, instance
-  # variables, objects and constants.
-  class Deprecation
-    # active_support.rb sets an autoload for ActiveSupport::Deprecation.
-    #
-    # If these requires were at the top of the file the constant would not be
-    # defined by the time their files were loaded. Since some of them reopen
-    # ActiveSupport::Deprecation its autoload would be triggered, resulting in
-    # a circular require warning for active_support/deprecation.rb.
-    #
-    # So, we define the constant first, and load dependencies later.
-    require "active_support/deprecation/instance_delegator"
-    require "active_support/deprecation/behaviors"
-    require "active_support/deprecation/reporting"
-    require "active_support/deprecation/disallowed"
-    require "active_support/deprecation/constant_accessor"
-    require "active_support/deprecation/method_wrappers"
-    require "active_support/deprecation/proxy_wrappers"
-    require "active_support/core_ext/module/deprecation"
-    require "concurrent/atomic/thread_local_var"
-
-    include Singleton
-    include InstanceDelegator
-    include Behavior
-    include Reporting
-    include Disallowed
-    include MethodWrapper
-
-    # The version number in which the deprecated behavior will be removed, by default.
-    attr_accessor :deprecation_horizon
-
-    # It accepts two parameters on initialization. The first is a version of library
-    # and the second is a library name.
-    #
-    #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = "7.0", gem_name = "Rails")
-      self.gem_name = gem_name
-      self.deprecation_horizon = deprecation_horizon
-      # By default, warnings are not silenced and debugging is off.
-      self.silenced = false
-      self.debug = false
-      @silenced_thread = Concurrent::ThreadLocalVar.new(false)
-      @explicitly_allowed_warnings = Concurrent::ThreadLocalVar.new(nil)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/behaviors.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/behaviors.rb
deleted file mode 100644
index 9d1fc78360e74..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/behaviors.rb
+++ /dev/null
@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/notifications"
-
-module ActiveSupport
-  # Raised when <tt>ActiveSupport::Deprecation::Behavior#behavior</tt> is set with <tt>:raise</tt>.
-  # You would set <tt>:raise</tt>, as a behavior to raise errors and proactively report exceptions from deprecations.
-  class DeprecationException < StandardError
-  end
-
-  class Deprecation
-    # Default warning behaviors per Rails.env.
-    DEFAULT_BEHAVIORS = {
-      raise: ->(message, callstack, deprecation_horizon, gem_name) {
-        e = DeprecationException.new(message)
-        e.set_backtrace(callstack.map(&:to_s))
-        raise e
-      },
-
-      stderr: ->(message, callstack, deprecation_horizon, gem_name) {
-        $stderr.puts(message)
-        $stderr.puts callstack.join("\n  ") if debug
-      },
-
-      log: ->(message, callstack, deprecation_horizon, gem_name) {
-        logger =
-            if defined?(Rails.logger) && Rails.logger
-              Rails.logger
-            else
-              require "active_support/logger"
-              ActiveSupport::Logger.new($stderr)
-            end
-        logger.warn message
-        logger.debug callstack.join("\n  ") if debug
-      },
-
-      notify: ->(message, callstack, deprecation_horizon, gem_name) {
-        notification_name = "deprecation.#{gem_name.underscore.tr('/', '_')}"
-        ActiveSupport::Notifications.instrument(notification_name,
-                                                message: message,
-                                                callstack: callstack,
-                                                gem_name: gem_name,
-                                                deprecation_horizon: deprecation_horizon)
-      },
-
-      silence: ->(message, callstack, deprecation_horizon, gem_name) { },
-    }
-
-    # Behavior module allows to determine how to display deprecation messages.
-    # You can create a custom behavior or set any from the +DEFAULT_BEHAVIORS+
-    # constant. Available behaviors are:
-    #
-    # [+raise+]   Raise <tt>ActiveSupport::DeprecationException</tt>.
-    # [+stderr+]  Log all deprecation warnings to <tt>$stderr</tt>.
-    # [+log+]     Log all deprecation warnings to +Rails.logger+.
-    # [+notify+]  Use +ActiveSupport::Notifications+ to notify +deprecation.rails+.
-    # [+silence+] Do nothing.
-    #
-    # Setting behaviors only affects deprecations that happen after boot time.
-    # For more information you can read the documentation of the +behavior=+ method.
-    module Behavior
-      # Whether to print a backtrace along with the warning.
-      attr_accessor :debug
-
-      # Returns the current behavior or if one isn't set, defaults to +:stderr+.
-      def behavior
-        @behavior ||= [DEFAULT_BEHAVIORS[:stderr]]
-      end
-
-      # Returns the current behavior for disallowed deprecations or if one isn't set, defaults to +:raise+.
-      def disallowed_behavior
-        @disallowed_behavior ||= [DEFAULT_BEHAVIORS[:raise]]
-      end
-
-      # Sets the behavior to the specified value. Can be a single value, array,
-      # or an object that responds to +call+.
-      #
-      # Available behaviors:
-      #
-      # [+raise+]   Raise <tt>ActiveSupport::DeprecationException</tt>.
-      # [+stderr+]  Log all deprecation warnings to <tt>$stderr</tt>.
-      # [+log+]     Log all deprecation warnings to +Rails.logger+.
-      # [+notify+]  Use +ActiveSupport::Notifications+ to notify +deprecation.rails+.
-      # [+silence+] Do nothing.
-      #
-      # Setting behaviors only affects deprecations that happen after boot time.
-      # Deprecation warnings raised by gems are not affected by this setting
-      # because they happen before Rails boots up.
-      #
-      #   ActiveSupport::Deprecation.behavior = :stderr
-      #   ActiveSupport::Deprecation.behavior = [:stderr, :log]
-      #   ActiveSupport::Deprecation.behavior = MyCustomHandler
-      #   ActiveSupport::Deprecation.behavior = ->(message, callstack, deprecation_horizon, gem_name) {
-      #     # custom stuff
-      #   }
-      def behavior=(behavior)
-        @behavior = Array(behavior).map { |b| DEFAULT_BEHAVIORS[b] || arity_coerce(b) }
-      end
-
-      # Sets the behavior for disallowed deprecations (those configured by
-      # ActiveSupport::Deprecation.disallowed_warnings=) to the specified
-      # value. As with +behavior=+, this can be a single value, array, or an
-      # object that responds to +call+.
-      def disallowed_behavior=(behavior)
-        @disallowed_behavior = Array(behavior).map { |b| DEFAULT_BEHAVIORS[b] || arity_coerce(b) }
-      end
-
-      private
-        def arity_coerce(behavior)
-          unless behavior.respond_to?(:call)
-            raise ArgumentError, "#{behavior.inspect} is not a valid deprecation behavior."
-          end
-
-          if behavior.arity == 4 || behavior.arity == -1
-            behavior
-          else
-            -> message, callstack, _, _ { behavior.call(message, callstack) }
-          end
-        end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/constant_accessor.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/constant_accessor.rb
deleted file mode 100644
index 1ed00158123e4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/constant_accessor.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  class Deprecation
-    # DeprecatedConstantAccessor transforms a constant into a deprecated one by
-    # hooking +const_missing+.
-    #
-    # It takes the names of an old (deprecated) constant and of a new constant
-    # (both in string form) and optionally a deprecator. The deprecator defaults
-    # to +ActiveSupport::Deprecator+ if none is specified.
-    #
-    # The deprecated constant now returns the same object as the new one rather
-    # than a proxy object, so it can be used transparently in +rescue+ blocks
-    # etc.
-    #
-    #   PLANETS = %w(mercury venus earth mars jupiter saturn uranus neptune pluto)
-    #
-    #   # (In a later update, the original implementation of `PLANETS` has been removed.)
-    #
-    #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
-    #   include ActiveSupport::Deprecation::DeprecatedConstantAccessor
-    #   deprecate_constant 'PLANETS', 'PLANETS_POST_2006'
-    #
-    #   PLANETS.map { |planet| planet.capitalize }
-    #   # => DEPRECATION WARNING: PLANETS is deprecated! Use PLANETS_POST_2006 instead.
-    #        (Backtrace information…)
-    #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
-    module DeprecatedConstantAccessor
-      def self.included(base)
-        require "active_support/inflector/methods"
-
-        extension = Module.new do
-          def const_missing(missing_const_name)
-            if class_variable_defined?(:@@_deprecated_constants)
-              if (replacement = class_variable_get(:@@_deprecated_constants)[missing_const_name.to_s])
-                replacement[:deprecator].warn(replacement[:message] || "#{name}::#{missing_const_name} is deprecated! Use #{replacement[:new]} instead.", caller_locations)
-                return ActiveSupport::Inflector.constantize(replacement[:new].to_s)
-              end
-            end
-            super
-          end
-
-          def deprecate_constant(const_name, new_constant, message: nil, deprecator: ActiveSupport::Deprecation.instance)
-            class_variable_set(:@@_deprecated_constants, {}) unless class_variable_defined?(:@@_deprecated_constants)
-            class_variable_get(:@@_deprecated_constants)[const_name.to_s] = { new: new_constant, message: message, deprecator: deprecator }
-          end
-        end
-        base.singleton_class.prepend extension
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/disallowed.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/disallowed.rb
deleted file mode 100644
index 096ecaae85332..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/disallowed.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  class Deprecation
-    module Disallowed
-      # Sets the criteria used to identify deprecation messages which should be
-      # disallowed. Can be an array containing strings, symbols, or regular
-      # expressions. (Symbols are treated as strings). These are compared against
-      # the text of the generated deprecation warning.
-      #
-      # Additionally the scalar symbol +:all+ may be used to treat all
-      # deprecations as disallowed.
-      #
-      # Deprecations matching a substring or regular expression will be handled
-      # using the configured +ActiveSupport::Deprecation.disallowed_behavior+
-      # rather than +ActiveSupport::Deprecation.behavior+
-      attr_writer :disallowed_warnings
-
-      # Returns the configured criteria used to identify deprecation messages
-      # which should be treated as disallowed.
-      def disallowed_warnings
-        @disallowed_warnings ||= []
-      end
-
-      private
-        def deprecation_disallowed?(message)
-          disallowed = ActiveSupport::Deprecation.disallowed_warnings
-          return false if explicitly_allowed?(message)
-          return true if disallowed == :all
-          disallowed.any? do |rule|
-            case rule
-            when String, Symbol
-              message.include?(rule.to_s)
-            when Regexp
-              rule.match?(message)
-            end
-          end
-        end
-
-        def explicitly_allowed?(message)
-          allowances = @explicitly_allowed_warnings.value
-          return false unless allowances
-          return true if allowances == :all
-          allowances = [allowances] unless allowances.kind_of?(Array)
-          allowances.any? do |rule|
-            case rule
-            when String, Symbol
-              message.include?(rule.to_s)
-            when Regexp
-              rule.match?(message)
-            end
-          end
-        end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/instance_delegator.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/instance_delegator.rb
deleted file mode 100644
index 59dd30ae303b7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/instance_delegator.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/delegation"
-
-module ActiveSupport
-  class Deprecation
-    module InstanceDelegator # :nodoc:
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.singleton_class.prepend(OverrideDelegators)
-        base.public_class_method :new
-      end
-
-      module ClassMethods # :nodoc:
-        def include(included_module)
-          included_module.instance_methods.each { |m| method_added(m) }
-          super
-        end
-
-        def method_added(method_name)
-          singleton_class.delegate(method_name, to: :instance)
-        end
-      end
-
-      module OverrideDelegators # :nodoc:
-        def warn(message = nil, callstack = nil)
-          callstack ||= caller_locations(2)
-          super
-        end
-
-        def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)
-          caller_backtrace ||= caller_locations(2)
-          super
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/method_wrappers.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/method_wrappers.rb
deleted file mode 100644
index e6cf28a89f0aa..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/method_wrappers.rb
+++ /dev/null
@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/array/extract_options"
-require "active_support/core_ext/module/redefine_method"
-
-module ActiveSupport
-  class Deprecation
-    module MethodWrapper
-      # Declare that a method has been deprecated.
-      #
-      #   class Fred
-      #     def aaa; end
-      #     def bbb; end
-      #     def ccc; end
-      #     def ddd; end
-      #     def eee; end
-      #   end
-      #
-      # Using the default deprecator:
-      #   ActiveSupport::Deprecation.deprecate_methods(Fred, :aaa, bbb: :zzz, ccc: 'use Bar#ccc instead')
-      #   # => Fred
-      #
-      #   Fred.new.aaa
-      #   # DEPRECATION WARNING: aaa is deprecated and will be removed from Rails 5.1. (called from irb_binding at (irb):10)
-      #   # => nil
-      #
-      #   Fred.new.bbb
-      #   # DEPRECATION WARNING: bbb is deprecated and will be removed from Rails 5.1 (use zzz instead). (called from irb_binding at (irb):11)
-      #   # => nil
-      #
-      #   Fred.new.ccc
-      #   # DEPRECATION WARNING: ccc is deprecated and will be removed from Rails 5.1 (use Bar#ccc instead). (called from irb_binding at (irb):12)
-      #   # => nil
-      #
-      # Passing in a custom deprecator:
-      #   custom_deprecator = ActiveSupport::Deprecation.new('next-release', 'MyGem')
-      #   ActiveSupport::Deprecation.deprecate_methods(Fred, ddd: :zzz, deprecator: custom_deprecator)
-      #   # => [:ddd]
-      #
-      #   Fred.new.ddd
-      #   DEPRECATION WARNING: ddd is deprecated and will be removed from MyGem next-release (use zzz instead). (called from irb_binding at (irb):15)
-      #   # => nil
-      #
-      # Using a custom deprecator directly:
-      #   custom_deprecator = ActiveSupport::Deprecation.new('next-release', 'MyGem')
-      #   custom_deprecator.deprecate_methods(Fred, eee: :zzz)
-      #   # => [:eee]
-      #
-      #   Fred.new.eee
-      #   DEPRECATION WARNING: eee is deprecated and will be removed from MyGem next-release (use zzz instead). (called from irb_binding at (irb):18)
-      #   # => nil
-      def deprecate_methods(target_module, *method_names)
-        options = method_names.extract_options!
-        deprecator = options.delete(:deprecator) || self
-        method_names += options.keys
-        mod = nil
-
-        method_names.each do |method_name|
-          message = options[method_name]
-          if target_module.method_defined?(method_name) || target_module.private_method_defined?(method_name)
-            method = target_module.instance_method(method_name)
-            target_module.module_eval do
-              redefine_method(method_name) do |*args, &block|
-                deprecator.deprecation_warning(method_name, message)
-                method.bind(self).call(*args, &block)
-              end
-              ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)
-            end
-          else
-            mod ||= Module.new
-            mod.module_eval do
-              define_method(method_name) do |*args, &block|
-                deprecator.deprecation_warning(method_name, message)
-                super(*args, &block)
-              end
-              ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)
-            end
-          end
-        end
-
-        target_module.prepend(mod) if mod
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/proxy_wrappers.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/proxy_wrappers.rb
deleted file mode 100644
index 4bc112d6c43db..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/proxy_wrappers.rb
+++ /dev/null
@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  class Deprecation
-    class DeprecationProxy #:nodoc:
-      def self.new(*args, &block)
-        object = args.first
-
-        return object unless object
-        super
-      end
-
-      instance_methods.each { |m| undef_method m unless /^__|^object_id$/.match?(m) }
-
-      # Don't give a deprecation warning on inspect since test/unit and error
-      # logs rely on it for diagnostics.
-      def inspect
-        target.inspect
-      end
-
-      private
-        def method_missing(called, *args, &block)
-          warn caller_locations, called, args
-          target.__send__(called, *args, &block)
-        end
-    end
-
-    # DeprecatedObjectProxy transforms an object into a deprecated one. It
-    # takes an object, a deprecation message and optionally a deprecator. The
-    # deprecator defaults to +ActiveSupport::Deprecator+ if none is specified.
-    #
-    #   deprecated_object = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(Object.new, "This object is now deprecated")
-    #   # => #<Object:0x007fb9b34c34b0>
-    #
-    #   deprecated_object.to_s
-    #   DEPRECATION WARNING: This object is now deprecated.
-    #   (Backtrace)
-    #   # => "#<Object:0x007fb9b34c34b0>"
-    class DeprecatedObjectProxy < DeprecationProxy
-      def initialize(object, message, deprecator = ActiveSupport::Deprecation.instance)
-        @object = object
-        @message = message
-        @deprecator = deprecator
-      end
-
-      private
-        def target
-          @object
-        end
-
-        def warn(callstack, called, args)
-          @deprecator.warn(@message, callstack)
-        end
-    end
-
-    # DeprecatedInstanceVariableProxy transforms an instance variable into a
-    # deprecated one. It takes an instance of a class, a method on that class
-    # and an instance variable. It optionally takes a deprecator as the last
-    # argument. The deprecator defaults to +ActiveSupport::Deprecator+ if none
-    # is specified.
-    #
-    #   class Example
-    #     def initialize
-    #       @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request, :@request)
-    #       @_request = :special_request
-    #     end
-    #
-    #     def request
-    #       @_request
-    #     end
-    #
-    #     def old_request
-    #       @request
-    #     end
-    #   end
-    #
-    #   example = Example.new
-    #   # => #<Example:0x007fb9b31090b8 @_request=:special_request, @request=:special_request>
-    #
-    #   example.old_request.to_s
-    #   # => DEPRECATION WARNING: @request is deprecated! Call request.to_s instead of
-    #      @request.to_s
-    #      (Backtrace information…)
-    #      "special_request"
-    #
-    #   example.request.to_s
-    #   # => "special_request"
-    class DeprecatedInstanceVariableProxy < DeprecationProxy
-      def initialize(instance, method, var = "@#{method}", deprecator = ActiveSupport::Deprecation.instance)
-        @instance = instance
-        @method = method
-        @var = var
-        @deprecator = deprecator
-      end
-
-      private
-        def target
-          @instance.__send__(@method)
-        end
-
-        def warn(callstack, called, args)
-          @deprecator.warn("#{@var} is deprecated! Call #{@method}.#{called} instead of #{@var}.#{called}. Args: #{args.inspect}", callstack)
-        end
-    end
-
-    # DeprecatedConstantProxy transforms a constant into a deprecated one. It
-    # takes the names of an old (deprecated) constant and of a new constant
-    # (both in string form) and optionally a deprecator. The deprecator defaults
-    # to +ActiveSupport::Deprecator+ if none is specified. The deprecated constant
-    # now returns the value of the new one.
-    #
-    #   PLANETS = %w(mercury venus earth mars jupiter saturn uranus neptune pluto)
-    #
-    #   # (In a later update, the original implementation of `PLANETS` has been removed.)
-    #
-    #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
-    #   PLANETS = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('PLANETS', 'PLANETS_POST_2006')
-    #
-    #   PLANETS.map { |planet| planet.capitalize }
-    #   # => DEPRECATION WARNING: PLANETS is deprecated! Use PLANETS_POST_2006 instead.
-    #        (Backtrace information…)
-    #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
-    class DeprecatedConstantProxy < Module
-      def self.new(*args, **options, &block)
-        object = args.first
-
-        return object unless object
-        super
-      end
-
-      def initialize(old_const, new_const, deprecator = ActiveSupport::Deprecation.instance, message: "#{old_const} is deprecated! Use #{new_const} instead.")
-        Kernel.require "active_support/inflector/methods"
-
-        @old_const = old_const
-        @new_const = new_const
-        @deprecator = deprecator
-        @message = message
-      end
-
-      instance_methods.each { |m| undef_method m unless /^__|^object_id$/.match?(m) }
-
-      # Don't give a deprecation warning on inspect since test/unit and error
-      # logs rely on it for diagnostics.
-      def inspect
-        target.inspect
-      end
-
-      # Don't give a deprecation warning on methods that IRB may invoke
-      # during tab-completion.
-      delegate :hash, :instance_methods, :name, :respond_to?, to: :target
-
-      # Returns the class of the new constant.
-      #
-      #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
-      #   PLANETS = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('PLANETS', 'PLANETS_POST_2006')
-      #   PLANETS.class # => Array
-      def class
-        target.class
-      end
-
-      private
-        def target
-          ActiveSupport::Inflector.constantize(@new_const.to_s)
-        end
-
-        def const_missing(name)
-          @deprecator.warn(@message, caller_locations)
-          target.const_get(name)
-        end
-
-        def method_missing(called, *args, &block)
-          @deprecator.warn(@message, caller_locations)
-          target.__send__(called, *args, &block)
-        end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/reporting.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/reporting.rb
deleted file mode 100644
index 51514eb3a67ef..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/deprecation/reporting.rb
+++ /dev/null
@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-
-require "rbconfig"
-
-module ActiveSupport
-  class Deprecation
-    module Reporting
-      # Whether to print a message (silent mode)
-      attr_writer :silenced
-      # Name of gem where method is deprecated
-      attr_accessor :gem_name
-
-      # Outputs a deprecation warning to the output configured by
-      # <tt>ActiveSupport::Deprecation.behavior</tt>.
-      #
-      #   ActiveSupport::Deprecation.warn('something broke!')
-      #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
-      def warn(message = nil, callstack = nil)
-        return if silenced
-
-        callstack ||= caller_locations(2)
-        deprecation_message(callstack, message).tap do |m|
-          if deprecation_disallowed?(message)
-            disallowed_behavior.each { |b| b.call(m, callstack, deprecation_horizon, gem_name) }
-          else
-            behavior.each { |b| b.call(m, callstack, deprecation_horizon, gem_name) }
-          end
-        end
-      end
-
-      # Silence deprecation warnings within the block.
-      #
-      #   ActiveSupport::Deprecation.warn('something broke!')
-      #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
-      #
-      #   ActiveSupport::Deprecation.silence do
-      #     ActiveSupport::Deprecation.warn('something broke!')
-      #   end
-      #   # => nil
-      def silence(&block)
-        @silenced_thread.bind(true, &block)
-      end
-
-      # Allow previously disallowed deprecation warnings within the block.
-      # <tt>allowed_warnings</tt> can be an array containing strings, symbols, or regular
-      # expressions. (Symbols are treated as strings). These are compared against
-      # the text of deprecation warning messages generated within the block.
-      # Matching warnings will be exempt from the rules set by
-      # +ActiveSupport::Deprecation.disallowed_warnings+
-      #
-      # The optional <tt>if:</tt> argument accepts a truthy/falsy value or an object that
-      # responds to <tt>.call</tt>. If truthy, then matching warnings will be allowed.
-      # If falsey then the method yields to the block without allowing the warning.
-      #
-      #   ActiveSupport::Deprecation.disallowed_behavior = :raise
-      #   ActiveSupport::Deprecation.disallowed_warnings = [
-      #     "something broke"
-      #   ]
-      #
-      #   ActiveSupport::Deprecation.warn('something broke!')
-      #   # => ActiveSupport::DeprecationException
-      #
-      #   ActiveSupport::Deprecation.allow ['something broke'] do
-      #     ActiveSupport::Deprecation.warn('something broke!')
-      #   end
-      #   # => nil
-      #
-      #   ActiveSupport::Deprecation.allow ['something broke'], if: Rails.env.production? do
-      #     ActiveSupport::Deprecation.warn('something broke!')
-      #   end
-      #   # => ActiveSupport::DeprecationException for dev/test, nil for production
-      def allow(allowed_warnings = :all, if: true, &block)
-        conditional = binding.local_variable_get(:if)
-        conditional = conditional.call if conditional.respond_to?(:call)
-        if conditional
-          @explicitly_allowed_warnings.bind(allowed_warnings, &block)
-        else
-          yield
-        end
-      end
-
-      def silenced
-        @silenced || @silenced_thread.value
-      end
-
-      def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)
-        caller_backtrace ||= caller_locations(2)
-        deprecated_method_warning(deprecated_method_name, message).tap do |msg|
-          warn(msg, caller_backtrace)
-        end
-      end
-
-      private
-        # Outputs a deprecation warning message
-        #
-        #   deprecated_method_warning(:method_name)
-        #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon}"
-        #   deprecated_method_warning(:method_name, :another_method)
-        #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon} (use another_method instead)"
-        #   deprecated_method_warning(:method_name, "Optional message")
-        #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon} (Optional message)"
-        def deprecated_method_warning(method_name, message = nil)
-          warning = "#{method_name} is deprecated and will be removed from #{gem_name} #{deprecation_horizon}"
-          case message
-          when Symbol then "#{warning} (use #{message} instead)"
-          when String then "#{warning} (#{message})"
-          else warning
-          end
-        end
-
-        def deprecation_message(callstack, message = nil)
-          message ||= "You are using deprecated behavior which will be removed from the next major or minor release."
-          "DEPRECATION WARNING: #{message} #{deprecation_caller_message(callstack)}"
-        end
-
-        def deprecation_caller_message(callstack)
-          file, line, method = extract_callstack(callstack)
-          if file
-            if line && method
-              "(called from #{method} at #{file}:#{line})"
-            else
-              "(called from #{file}:#{line})"
-            end
-          end
-        end
-
-        def extract_callstack(callstack)
-          return _extract_callstack(callstack) if callstack.first.is_a? String
-
-          offending_line = callstack.find { |frame|
-            frame.absolute_path && !ignored_callstack(frame.absolute_path)
-          } || callstack.first
-
-          [offending_line.path, offending_line.lineno, offending_line.label]
-        end
-
-        def _extract_callstack(callstack)
-          warn "Please pass `caller_locations` to the deprecation API" if $VERBOSE
-          offending_line = callstack.find { |line| !ignored_callstack(line) } || callstack.first
-
-          if offending_line
-            if md = offending_line.match(/^(.+?):(\d+)(?::in `(.*?)')?/)
-              md.captures
-            else
-              offending_line
-            end
-          end
-        end
-
-        RAILS_GEM_ROOT = File.expand_path("../../../..", __dir__) + "/"
-
-        def ignored_callstack(path)
-          path.start_with?(RAILS_GEM_ROOT) || path.start_with?(RbConfig::CONFIG["rubylibdir"])
-        end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/descendants_tracker.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/descendants_tracker.rb
deleted file mode 100644
index 2362914dceeae..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/descendants_tracker.rb
+++ /dev/null
@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-require "weakref"
-
-module ActiveSupport
-  # This module provides an internal implementation to track descendants
-  # which is faster than iterating through ObjectSpace.
-  module DescendantsTracker
-    @@direct_descendants = {}
-
-    class << self
-      def direct_descendants(klass)
-        descendants = @@direct_descendants[klass]
-        descendants ? descendants.to_a : []
-      end
-      alias_method :subclasses, :direct_descendants
-
-      def descendants(klass)
-        arr = []
-        accumulate_descendants(klass, arr)
-        arr
-      end
-
-      def clear
-        if defined? ActiveSupport::Dependencies
-          @@direct_descendants.each do |klass, descendants|
-            if Dependencies.autoloaded?(klass)
-              @@direct_descendants.delete(klass)
-            else
-              descendants.reject! { |v| Dependencies.autoloaded?(v) }
-            end
-          end
-        else
-          @@direct_descendants.clear
-        end
-      end
-
-      # This is the only method that is not thread safe, but is only ever called
-      # during the eager loading phase.
-      def store_inherited(klass, descendant)
-        (@@direct_descendants[klass] ||= DescendantsArray.new) << descendant
-      end
-
-      private
-        def accumulate_descendants(klass, acc)
-          if direct_descendants = @@direct_descendants[klass]
-            direct_descendants.each do |direct_descendant|
-              acc << direct_descendant
-              accumulate_descendants(direct_descendant, acc)
-            end
-          end
-        end
-    end
-
-    def inherited(base)
-      DescendantsTracker.store_inherited(self, base)
-      super
-    end
-
-    def direct_descendants
-      DescendantsTracker.direct_descendants(self)
-    end
-    alias_method :subclasses, :direct_descendants
-
-    def descendants
-      DescendantsTracker.descendants(self)
-    end
-
-    # DescendantsArray is an array that contains weak references to classes.
-    class DescendantsArray # :nodoc:
-      include Enumerable
-
-      def initialize
-        @refs = []
-      end
-
-      def initialize_copy(orig)
-        @refs = @refs.dup
-      end
-
-      def <<(klass)
-        @refs << WeakRef.new(klass)
-      end
-
-      def each
-        @refs.reject! do |ref|
-          yield ref.__getobj__
-          false
-        rescue WeakRef::RefError
-          true
-        end
-        self
-      end
-
-      def refs_size
-        @refs.size
-      end
-
-      def cleanup!
-        @refs.delete_if { |ref| !ref.weakref_alive? }
-      end
-
-      def reject!
-        @refs.reject! do |ref|
-          yield ref.__getobj__
-        rescue WeakRef::RefError
-          true
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/digest.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/digest.rb
deleted file mode 100644
index c044214648b98..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/digest.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "digest"
-
-module ActiveSupport
-  class Digest #:nodoc:
-    class <<self
-      def hash_digest_class
-        @hash_digest_class ||= ::Digest::MD5
-      end
-
-      def hash_digest_class=(klass)
-        raise ArgumentError, "#{klass} is expected to implement hexdigest class method" unless klass.respond_to?(:hexdigest)
-        @hash_digest_class = klass
-      end
-
-      def hexdigest(arg)
-        hash_digest_class.hexdigest(arg)[0...32]
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/duration.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/duration.rb
deleted file mode 100644
index b464e5651d3cb..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/duration.rb
+++ /dev/null
@@ -1,485 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/array/conversions"
-require "active_support/core_ext/module/delegation"
-require "active_support/core_ext/object/acts_like"
-require "active_support/core_ext/string/filters"
-
-module ActiveSupport
-  # Provides accurate date and time measurements using Date#advance and
-  # Time#advance, respectively. It mainly supports the methods on Numeric.
-  #
-  #   1.month.ago       # equivalent to Time.now.advance(months: -1)
-  class Duration
-    class Scalar < Numeric #:nodoc:
-      attr_reader :value
-      delegate :to_i, :to_f, :to_s, to: :value
-
-      def initialize(value)
-        @value = value
-      end
-
-      def coerce(other)
-        [Scalar.new(other), self]
-      end
-
-      def -@
-        Scalar.new(-value)
-      end
-
-      def <=>(other)
-        if Scalar === other || Duration === other
-          value <=> other.value
-        elsif Numeric === other
-          value <=> other
-        else
-          nil
-        end
-      end
-
-      def +(other)
-        if Duration === other
-          seconds   = value + other.parts.fetch(:seconds, 0)
-          new_parts = other.parts.merge(seconds: seconds)
-          new_value = value + other.value
-
-          Duration.new(new_value, new_parts)
-        else
-          calculate(:+, other)
-        end
-      end
-
-      def -(other)
-        if Duration === other
-          seconds   = value - other.parts.fetch(:seconds, 0)
-          new_parts = other.parts.transform_values(&:-@)
-          new_parts = new_parts.merge(seconds: seconds)
-          new_value = value - other.value
-
-          Duration.new(new_value, new_parts)
-        else
-          calculate(:-, other)
-        end
-      end
-
-      def *(other)
-        if Duration === other
-          new_parts = other.parts.transform_values { |other_value| value * other_value }
-          new_value = value * other.value
-
-          Duration.new(new_value, new_parts)
-        else
-          calculate(:*, other)
-        end
-      end
-
-      def /(other)
-        if Duration === other
-          value / other.value
-        else
-          calculate(:/, other)
-        end
-      end
-
-      def %(other)
-        if Duration === other
-          Duration.build(value % other.value)
-        else
-          calculate(:%, other)
-        end
-      end
-
-      private
-        def calculate(op, other)
-          if Scalar === other
-            Scalar.new(value.public_send(op, other.value))
-          elsif Numeric === other
-            Scalar.new(value.public_send(op, other))
-          else
-            raise_type_error(other)
-          end
-        end
-
-        def raise_type_error(other)
-          raise TypeError, "no implicit conversion of #{other.class} into #{self.class}"
-        end
-    end
-
-    SECONDS_PER_MINUTE = 60
-    SECONDS_PER_HOUR   = 3600
-    SECONDS_PER_DAY    = 86400
-    SECONDS_PER_WEEK   = 604800
-    SECONDS_PER_MONTH  = 2629746  # 1/12 of a gregorian year
-    SECONDS_PER_YEAR   = 31556952 # length of a gregorian year (365.2425 days)
-
-    PARTS_IN_SECONDS = {
-      seconds: 1,
-      minutes: SECONDS_PER_MINUTE,
-      hours:   SECONDS_PER_HOUR,
-      days:    SECONDS_PER_DAY,
-      weeks:   SECONDS_PER_WEEK,
-      months:  SECONDS_PER_MONTH,
-      years:   SECONDS_PER_YEAR
-    }.freeze
-
-    PARTS = [:years, :months, :weeks, :days, :hours, :minutes, :seconds].freeze
-
-    attr_accessor :value, :parts
-
-    autoload :ISO8601Parser,     "active_support/duration/iso8601_parser"
-    autoload :ISO8601Serializer, "active_support/duration/iso8601_serializer"
-
-    class << self
-      # Creates a new Duration from string formatted according to ISO 8601 Duration.
-      #
-      # See {ISO 8601}[https://en.wikipedia.org/wiki/ISO_8601#Durations] for more information.
-      # This method allows negative parts to be present in pattern.
-      # If invalid string is provided, it will raise +ActiveSupport::Duration::ISO8601Parser::ParsingError+.
-      def parse(iso8601duration)
-        parts = ISO8601Parser.new(iso8601duration).parse!
-        new(calculate_total_seconds(parts), parts)
-      end
-
-      def ===(other) #:nodoc:
-        other.is_a?(Duration)
-      rescue ::NoMethodError
-        false
-      end
-
-      def seconds(value) #:nodoc:
-        new(value, seconds: value)
-      end
-
-      def minutes(value) #:nodoc:
-        new(value * SECONDS_PER_MINUTE, minutes: value)
-      end
-
-      def hours(value) #:nodoc:
-        new(value * SECONDS_PER_HOUR, hours: value)
-      end
-
-      def days(value) #:nodoc:
-        new(value * SECONDS_PER_DAY, days: value)
-      end
-
-      def weeks(value) #:nodoc:
-        new(value * SECONDS_PER_WEEK, weeks: value)
-      end
-
-      def months(value) #:nodoc:
-        new(value * SECONDS_PER_MONTH, months: value)
-      end
-
-      def years(value) #:nodoc:
-        new(value * SECONDS_PER_YEAR, years: value)
-      end
-
-      # Creates a new Duration from a seconds value that is converted
-      # to the individual parts:
-      #
-      #   ActiveSupport::Duration.build(31556952).parts # => {:years=>1}
-      #   ActiveSupport::Duration.build(2716146).parts  # => {:months=>1, :days=>1}
-      #
-      def build(value)
-        unless value.is_a?(::Numeric)
-          raise TypeError, "can't build an #{self.name} from a #{value.class.name}"
-        end
-
-        parts = {}
-        remainder_sign = value <=> 0
-        remainder = value.round(9).abs
-
-        PARTS.each do |part|
-          unless part == :seconds
-            part_in_seconds = PARTS_IN_SECONDS[part]
-            parts[part] = remainder.div(part_in_seconds) * remainder_sign
-            remainder %= part_in_seconds
-          end
-        end unless value == 0
-
-        parts[:seconds] = remainder * remainder_sign
-
-        new(value, parts)
-      end
-
-      private
-        def calculate_total_seconds(parts)
-          parts.inject(0) do |total, (part, value)|
-            total + value * PARTS_IN_SECONDS[part]
-          end
-        end
-    end
-
-    def initialize(value, parts) #:nodoc:
-      @value, @parts = value, parts
-      @parts.reject! { |k, v| v.zero? } unless value == 0
-    end
-
-    def coerce(other) #:nodoc:
-      case other
-      when Scalar
-        [other, self]
-      when Duration
-        [Scalar.new(other.value), self]
-      else
-        [Scalar.new(other), self]
-      end
-    end
-
-    # Compares one Duration with another or a Numeric to this Duration.
-    # Numeric values are treated as seconds.
-    def <=>(other)
-      if Duration === other
-        value <=> other.value
-      elsif Numeric === other
-        value <=> other
-      end
-    end
-
-    # Adds another Duration or a Numeric to this Duration. Numeric values
-    # are treated as seconds.
-    def +(other)
-      if Duration === other
-        parts = @parts.merge(other.parts) do |_key, value, other_value|
-          value + other_value
-        end
-        Duration.new(value + other.value, parts)
-      else
-        seconds = @parts.fetch(:seconds, 0) + other
-        Duration.new(value + other, @parts.merge(seconds: seconds))
-      end
-    end
-
-    # Subtracts another Duration or a Numeric from this Duration. Numeric
-    # values are treated as seconds.
-    def -(other)
-      self + (-other)
-    end
-
-    # Multiplies this Duration by a Numeric and returns a new Duration.
-    def *(other)
-      if Scalar === other || Duration === other
-        Duration.new(value * other.value, parts.transform_values { |number| number * other.value })
-      elsif Numeric === other
-        Duration.new(value * other, parts.transform_values { |number| number * other })
-      else
-        raise_type_error(other)
-      end
-    end
-
-    # Divides this Duration by a Numeric and returns a new Duration.
-    def /(other)
-      if Scalar === other
-        Duration.new(value / other.value, parts.transform_values { |number| number / other.value })
-      elsif Duration === other
-        value / other.value
-      elsif Numeric === other
-        Duration.new(value / other, parts.transform_values { |number| number / other })
-      else
-        raise_type_error(other)
-      end
-    end
-
-    # Returns the modulo of this Duration by another Duration or Numeric.
-    # Numeric values are treated as seconds.
-    def %(other)
-      if Duration === other || Scalar === other
-        Duration.build(value % other.value)
-      elsif Numeric === other
-        Duration.build(value % other)
-      else
-        raise_type_error(other)
-      end
-    end
-
-    def -@ #:nodoc:
-      Duration.new(-value, parts.transform_values(&:-@))
-    end
-
-    def +@ #:nodoc:
-      self
-    end
-
-    def is_a?(klass) #:nodoc:
-      Duration == klass || value.is_a?(klass)
-    end
-    alias :kind_of? :is_a?
-
-    def instance_of?(klass) # :nodoc:
-      Duration == klass || value.instance_of?(klass)
-    end
-
-    # Returns +true+ if +other+ is also a Duration instance with the
-    # same +value+, or if <tt>other == value</tt>.
-    def ==(other)
-      if Duration === other
-        other.value == value
-      else
-        other == value
-      end
-    end
-
-    # Returns the amount of seconds a duration covers as a string.
-    # For more information check to_i method.
-    #
-    #   1.day.to_s # => "86400"
-    def to_s
-      @value.to_s
-    end
-
-    # Returns the number of seconds that this Duration represents.
-    #
-    #   1.minute.to_i   # => 60
-    #   1.hour.to_i     # => 3600
-    #   1.day.to_i      # => 86400
-    #
-    # Note that this conversion makes some assumptions about the
-    # duration of some periods, e.g. months are always 1/12 of year
-    # and years are 365.2425 days:
-    #
-    #   # equivalent to (1.year / 12).to_i
-    #   1.month.to_i    # => 2629746
-    #
-    #   # equivalent to 365.2425.days.to_i
-    #   1.year.to_i     # => 31556952
-    #
-    # In such cases, Ruby's core
-    # Date[https://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
-    # Time[https://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
-    # date and time arithmetic.
-    def to_i
-      @value.to_i
-    end
-    alias :in_seconds :to_i
-
-    # Returns the amount of minutes a duration covers as a float
-    #
-    #   1.day.in_minutes # => 1440.0
-    def in_minutes
-      in_seconds / SECONDS_PER_MINUTE.to_f
-    end
-
-    # Returns the amount of hours a duration covers as a float
-    #
-    #   1.day.in_hours # => 24.0
-    def in_hours
-      in_seconds / SECONDS_PER_HOUR.to_f
-    end
-
-    # Returns the amount of days a duration covers as a float
-    #
-    #   12.hours.in_days # => 0.5
-    def in_days
-      in_seconds / SECONDS_PER_DAY.to_f
-    end
-
-    # Returns the amount of weeks a duration covers as a float
-    #
-    #   2.months.in_weeks # => 8.696
-    def in_weeks
-      in_seconds / SECONDS_PER_WEEK.to_f
-    end
-
-    # Returns the amount of months a duration covers as a float
-    #
-    #   9.weeks.in_months # => 2.07
-    def in_months
-      in_seconds / SECONDS_PER_MONTH.to_f
-    end
-
-    # Returns the amount of years a duration covers as a float
-    #
-    #   30.days.in_years # => 0.082
-    def in_years
-      in_seconds / SECONDS_PER_YEAR.to_f
-    end
-
-    # Returns +true+ if +other+ is also a Duration instance, which has the
-    # same parts as this one.
-    def eql?(other)
-      Duration === other && other.value.eql?(value)
-    end
-
-    def hash
-      @value.hash
-    end
-
-    # Calculates a new Time or Date that is as far in the future
-    # as this Duration represents.
-    def since(time = ::Time.current)
-      sum(1, time)
-    end
-    alias :from_now :since
-    alias :after :since
-
-    # Calculates a new Time or Date that is as far in the past
-    # as this Duration represents.
-    def ago(time = ::Time.current)
-      sum(-1, time)
-    end
-    alias :until :ago
-    alias :before :ago
-
-    def inspect #:nodoc:
-      return "#{value} seconds" if parts.empty?
-
-      parts.
-        sort_by { |unit,  _ | PARTS.index(unit) }.
-        map     { |unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}" }.
-        to_sentence(locale: ::I18n.default_locale)
-    end
-
-    def as_json(options = nil) #:nodoc:
-      to_i
-    end
-
-    def init_with(coder) #:nodoc:
-      initialize(coder["value"], coder["parts"])
-    end
-
-    def encode_with(coder) #:nodoc:
-      coder.map = { "value" => @value, "parts" => @parts }
-    end
-
-    # Build ISO 8601 Duration string for this duration.
-    # The +precision+ parameter can be used to limit seconds' precision of duration.
-    def iso8601(precision: nil)
-      ISO8601Serializer.new(self, precision: precision).serialize
-    end
-
-    private
-      def sum(sign, time = ::Time.current)
-        unless time.acts_like?(:time) || time.acts_like?(:date)
-          raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
-        end
-
-        if parts.empty?
-          time.since(sign * value)
-        else
-          parts.inject(time) do |t, (type, number)|
-            if type == :seconds
-              t.since(sign * number)
-            elsif type == :minutes
-              t.since(sign * number * 60)
-            elsif type == :hours
-              t.since(sign * number * 3600)
-            else
-              t.advance(type => sign * number)
-            end
-          end
-        end
-      end
-
-      def respond_to_missing?(method, _)
-        value.respond_to?(method)
-      end
-
-      def method_missing(method, *args, &block)
-        value.public_send(method, *args, &block)
-      end
-
-      def raise_type_error(other)
-        raise TypeError, "no implicit conversion of #{other.class} into #{self.class}"
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/encrypted_configuration.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/encrypted_configuration.rb
deleted file mode 100644
index cc1d026737a6c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/encrypted_configuration.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-require "active_support/encrypted_file"
-require "active_support/ordered_options"
-require "active_support/core_ext/object/inclusion"
-require "active_support/core_ext/module/delegation"
-
-module ActiveSupport
-  class EncryptedConfiguration < EncryptedFile
-    delegate :[], :fetch, to: :config
-    delegate_missing_to :options
-
-    def initialize(config_path:, key_path:, env_key:, raise_if_missing_key:)
-      super content_path: config_path, key_path: key_path,
-        env_key: env_key, raise_if_missing_key: raise_if_missing_key
-    end
-
-    # Allow a config to be started without a file present
-    def read
-      super
-    rescue ActiveSupport::EncryptedFile::MissingContentError
-      ""
-    end
-
-    def write(contents)
-      deserialize(contents)
-
-      super
-    end
-
-    def config
-      @config ||= deserialize(read).deep_symbolize_keys
-    end
-
-    private
-      def options
-        @options ||= ActiveSupport::InheritableOptions.new(config)
-      end
-
-      def deserialize(config)
-        YAML.load(config).presence || {}
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/encrypted_file.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/encrypted_file.rb
deleted file mode 100644
index a35cc54ef5c52..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/encrypted_file.rb
+++ /dev/null
@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require "pathname"
-require "tmpdir"
-require "active_support/message_encryptor"
-
-module ActiveSupport
-  class EncryptedFile
-    class MissingContentError < RuntimeError
-      def initialize(content_path)
-        super "Missing encrypted content file in #{content_path}."
-      end
-    end
-
-    class MissingKeyError < RuntimeError
-      def initialize(key_path:, env_key:)
-        super \
-          "Missing encryption key to decrypt file with. " +
-          "Ask your team for your master key and write it to #{key_path} or put it in the ENV['#{env_key}']."
-      end
-    end
-
-    class InvalidKeyLengthError < RuntimeError
-      def initialize
-        super "Encryption key must be exactly #{EncryptedFile.expected_key_length} characters."
-      end
-    end
-
-    CIPHER = "aes-128-gcm"
-
-    def self.generate_key
-      SecureRandom.hex(ActiveSupport::MessageEncryptor.key_len(CIPHER))
-    end
-
-    def self.expected_key_length # :nodoc:
-      @expected_key_length ||= generate_key.length
-    end
-
-
-    attr_reader :content_path, :key_path, :env_key, :raise_if_missing_key
-
-    def initialize(content_path:, key_path:, env_key:, raise_if_missing_key:)
-      @content_path = Pathname.new(content_path).yield_self { |path| path.symlink? ? path.realpath : path }
-      @key_path = Pathname.new(key_path)
-      @env_key, @raise_if_missing_key = env_key, raise_if_missing_key
-    end
-
-    def key
-      read_env_key || read_key_file || handle_missing_key
-    end
-
-    def read
-      if !key.nil? && content_path.exist?
-        decrypt content_path.binread
-      else
-        raise MissingContentError, content_path
-      end
-    end
-
-    def write(contents)
-      IO.binwrite "#{content_path}.tmp", encrypt(contents)
-      FileUtils.mv "#{content_path}.tmp", content_path
-    end
-
-    def change(&block)
-      writing read, &block
-    end
-
-
-    private
-      def writing(contents)
-        tmp_file = "#{Process.pid}.#{content_path.basename.to_s.chomp('.enc')}"
-        tmp_path = Pathname.new File.join(Dir.tmpdir, tmp_file)
-        tmp_path.binwrite contents
-
-        yield tmp_path
-
-        updated_contents = tmp_path.binread
-
-        write(updated_contents) if updated_contents != contents
-      ensure
-        FileUtils.rm(tmp_path) if tmp_path&.exist?
-      end
-
-
-      def encrypt(contents)
-        check_key_length
-        encryptor.encrypt_and_sign contents
-      end
-
-      def decrypt(contents)
-        encryptor.decrypt_and_verify contents
-      end
-
-      def encryptor
-        @encryptor ||= ActiveSupport::MessageEncryptor.new([ key ].pack("H*"), cipher: CIPHER)
-      end
-
-
-      def read_env_key
-        ENV[env_key]
-      end
-
-      def read_key_file
-        return @key_file_contents if defined?(@key_file_contents)
-        @key_file_contents = (key_path.binread.strip if key_path.exist?)
-      end
-
-      def handle_missing_key
-        raise MissingKeyError.new(key_path: key_path, env_key: env_key) if raise_if_missing_key
-      end
-
-      def check_key_length
-        raise InvalidKeyLengthError if key&.length != self.class.expected_key_length
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/environment_inquirer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/environment_inquirer.rb
deleted file mode 100644
index 05361d93272f1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/environment_inquirer.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/string_inquirer"
-
-module ActiveSupport
-  class EnvironmentInquirer < StringInquirer #:nodoc:
-    DEFAULT_ENVIRONMENTS = ["development", "test", "production"]
-    def initialize(env)
-      super(env)
-
-      DEFAULT_ENVIRONMENTS.each do |default|
-        instance_variable_set :"@#{default}", env == default
-      end
-    end
-
-    DEFAULT_ENVIRONMENTS.each do |env|
-      class_eval "def #{env}?; @#{env}; end"
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/evented_file_update_checker.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/evented_file_update_checker.rb
deleted file mode 100644
index f9bc3be9be684..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/evented_file_update_checker.rb
+++ /dev/null
@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-require "pathname"
-require "concurrent/atomic/atomic_boolean"
-require "listen"
-require "active_support/fork_tracker"
-
-module ActiveSupport
-  # Allows you to "listen" to changes in a file system.
-  # The evented file updater does not hit disk when checking for updates
-  # instead it uses platform specific file system events to trigger a change
-  # in state.
-  #
-  # The file checker takes an array of files to watch or a hash specifying directories
-  # and file extensions to watch. It also takes a block that is called when
-  # EventedFileUpdateChecker#execute is run or when EventedFileUpdateChecker#execute_if_updated
-  # is run and there have been changes to the file system.
-  #
-  # Note: Forking will cause the first call to `updated?` to return `true`.
-  #
-  # Example:
-  #
-  #     checker = ActiveSupport::EventedFileUpdateChecker.new(["/tmp/foo"]) { puts "changed" }
-  #     checker.updated?
-  #     # => false
-  #     checker.execute_if_updated
-  #     # => nil
-  #
-  #     FileUtils.touch("/tmp/foo")
-  #
-  #     checker.updated?
-  #     # => true
-  #     checker.execute_if_updated
-  #     # => "changed"
-  #
-  class EventedFileUpdateChecker #:nodoc: all
-    def initialize(files, dirs = {}, &block)
-      unless block
-        raise ArgumentError, "A block is required to initialize an EventedFileUpdateChecker"
-      end
-
-      @block = block
-      @core = Core.new(files, dirs)
-      ObjectSpace.define_finalizer(self, @core.finalizer)
-    end
-
-    def updated?
-      if @core.restart?
-        @core.thread_safely(&:restart)
-        @core.updated.make_true
-      end
-
-      @core.updated.true?
-    end
-
-    def execute
-      @core.updated.make_false
-      @block.call
-    end
-
-    def execute_if_updated
-      if updated?
-        yield if block_given?
-        execute
-        true
-      end
-    end
-
-    class Core
-      attr_reader :updated
-
-      def initialize(files, dirs)
-        @files = files.map { |file| Pathname(file).expand_path }.to_set
-
-        @dirs = dirs.each_with_object({}) do |(dir, exts), hash|
-          hash[Pathname(dir).expand_path] = Array(exts).map { |ext| ext.to_s.sub(/\A\.?/, ".") }.to_set
-        end
-
-        @common_path = common_path(@dirs.keys)
-
-        @dtw = directories_to_watch
-        @missing = []
-
-        @updated = Concurrent::AtomicBoolean.new(false)
-        @mutex = Mutex.new
-
-        start
-        @after_fork = ActiveSupport::ForkTracker.after_fork { start }
-      end
-
-      def finalizer
-        proc do
-          stop
-          ActiveSupport::ForkTracker.unregister(@after_fork)
-        end
-      end
-
-      def thread_safely
-        @mutex.synchronize do
-          yield self
-        end
-      end
-
-      def start
-        normalize_dirs!
-        @dtw, @missing = [*@dtw, *@missing].partition(&:exist?)
-        @listener = @dtw.any? ? Listen.to(*@dtw, &method(:changed)) : nil
-        @listener&.start
-      end
-
-      def stop
-        @listener&.stop
-      end
-
-      def restart
-        stop
-        start
-      end
-
-      def restart?
-        @missing.any?(&:exist?)
-      end
-
-      def normalize_dirs!
-        @dirs.transform_keys! do |dir|
-          dir.exist? ? dir.realpath : dir
-        end
-      end
-
-      def changed(modified, added, removed)
-        unless @updated.true?
-          @updated.make_true if (modified + added + removed).any? { |f| watching?(f) }
-        end
-      end
-
-      def watching?(file)
-        file = Pathname(file)
-
-        if @files.member?(file)
-          true
-        elsif file.directory?
-          false
-        else
-          ext = file.extname
-
-          file.dirname.ascend do |dir|
-            matching = @dirs[dir]
-
-            if matching && (matching.empty? || matching.include?(ext))
-              break true
-            elsif dir == @common_path || dir.root?
-              break false
-            end
-          end
-        end
-      end
-
-      def directories_to_watch
-        dtw = @dirs.keys | @files.map(&:dirname)
-        accounted_for = dtw.to_set + Gem.path.map { |path| Pathname(path) }
-        dtw.reject { |dir| dir.ascend.drop(1).any? { |parent| accounted_for.include?(parent) } }
-      end
-
-      def common_path(paths)
-        paths.map { |path| path.ascend.to_a }.reduce(&:&)&.first
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/execution_wrapper.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/execution_wrapper.rb
deleted file mode 100644
index 07c4f435db48e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/execution_wrapper.rb
+++ /dev/null
@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/callbacks"
-require "concurrent/hash"
-
-module ActiveSupport
-  class ExecutionWrapper
-    include ActiveSupport::Callbacks
-
-    Null = Object.new # :nodoc:
-    def Null.complete! # :nodoc:
-    end
-
-    define_callbacks :run
-    define_callbacks :complete
-
-    def self.to_run(*args, &block)
-      set_callback(:run, *args, &block)
-    end
-
-    def self.to_complete(*args, &block)
-      set_callback(:complete, *args, &block)
-    end
-
-    RunHook = Struct.new(:hook) do # :nodoc:
-      def before(target)
-        hook_state = target.send(:hook_state)
-        hook_state[hook] = hook.run
-      end
-    end
-
-    CompleteHook = Struct.new(:hook) do # :nodoc:
-      def before(target)
-        hook_state = target.send(:hook_state)
-        if hook_state.key?(hook)
-          hook.complete hook_state[hook]
-        end
-      end
-      alias after before
-    end
-
-    # Register an object to be invoked during both the +run+ and
-    # +complete+ steps.
-    #
-    # +hook.complete+ will be passed the value returned from +hook.run+,
-    # and will only be invoked if +run+ has previously been called.
-    # (Mostly, this means it won't be invoked if an exception occurs in
-    # a preceding +to_run+ block; all ordinary +to_complete+ blocks are
-    # invoked in that situation.)
-    def self.register_hook(hook, outer: false)
-      if outer
-        to_run RunHook.new(hook), prepend: true
-        to_complete :after, CompleteHook.new(hook)
-      else
-        to_run RunHook.new(hook)
-        to_complete CompleteHook.new(hook)
-      end
-    end
-
-    # Run this execution.
-    #
-    # Returns an instance, whose +complete!+ method *must* be invoked
-    # after the work has been performed.
-    #
-    # Where possible, prefer +wrap+.
-    def self.run!(reset: false)
-      if reset
-        lost_instance = active.delete(Thread.current)
-        lost_instance&.complete!
-      else
-        return Null if active?
-      end
-
-      new.tap do |instance|
-        success = nil
-        begin
-          instance.run!
-          success = true
-        ensure
-          instance.complete! unless success
-        end
-      end
-    end
-
-    # Perform the work in the supplied block as an execution.
-    def self.wrap
-      return yield if active?
-
-      instance = run!
-      begin
-        yield
-      ensure
-        instance.complete!
-      end
-    end
-
-    class << self # :nodoc:
-      attr_accessor :active
-    end
-
-    def self.inherited(other) # :nodoc:
-      super
-      other.active = Concurrent::Hash.new
-    end
-
-    self.active = Concurrent::Hash.new
-
-    def self.active? # :nodoc:
-      @active.key?(Thread.current)
-    end
-
-    def run! # :nodoc:
-      self.class.active[Thread.current] = self
-      run_callbacks(:run)
-    end
-
-    # Complete this in-flight execution. This method *must* be called
-    # exactly once on the result of any call to +run!+.
-    #
-    # Where possible, prefer +wrap+.
-    def complete!
-      run_callbacks(:complete)
-    ensure
-      self.class.active.delete Thread.current
-    end
-
-    private
-      def hook_state
-        @_hook_state ||= {}
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/executor.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/executor.rb
deleted file mode 100644
index ce391b07ec64c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/executor.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/execution_wrapper"
-
-module ActiveSupport
-  class Executor < ExecutionWrapper
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/file_update_checker.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/file_update_checker.rb
deleted file mode 100644
index 9b665e7f19625..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/file_update_checker.rb
+++ /dev/null
@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/time/calculations"
-
-module ActiveSupport
-  # FileUpdateChecker specifies the API used by Rails to watch files
-  # and control reloading. The API depends on four methods:
-  #
-  # * +initialize+ which expects two parameters and one block as
-  #   described below.
-  #
-  # * +updated?+ which returns a boolean if there were updates in
-  #   the filesystem or not.
-  #
-  # * +execute+ which executes the given block on initialization
-  #   and updates the latest watched files and timestamp.
-  #
-  # * +execute_if_updated+ which just executes the block if it was updated.
-  #
-  # After initialization, a call to +execute_if_updated+ must execute
-  # the block only if there was really a change in the filesystem.
-  #
-  # This class is used by Rails to reload the I18n framework whenever
-  # they are changed upon a new request.
-  #
-  #   i18n_reloader = ActiveSupport::FileUpdateChecker.new(paths) do
-  #     I18n.reload!
-  #   end
-  #
-  #   ActiveSupport::Reloader.to_prepare do
-  #     i18n_reloader.execute_if_updated
-  #   end
-  class FileUpdateChecker
-    # It accepts two parameters on initialization. The first is an array
-    # of files and the second is an optional hash of directories. The hash must
-    # have directories as keys and the value is an array of extensions to be
-    # watched under that directory.
-    #
-    # This method must also receive a block that will be called once a path
-    # changes. The array of files and list of directories cannot be changed
-    # after FileUpdateChecker has been initialized.
-    def initialize(files, dirs = {}, &block)
-      unless block
-        raise ArgumentError, "A block is required to initialize a FileUpdateChecker"
-      end
-
-      @files = files.freeze
-      @glob  = compile_glob(dirs)
-      @block = block
-
-      @watched    = nil
-      @updated_at = nil
-
-      @last_watched   = watched
-      @last_update_at = updated_at(@last_watched)
-    end
-
-    # Check if any of the entries were updated. If so, the watched and/or
-    # updated_at values are cached until the block is executed via +execute+
-    # or +execute_if_updated+.
-    def updated?
-      current_watched = watched
-      if @last_watched.size != current_watched.size
-        @watched = current_watched
-        true
-      else
-        current_updated_at = updated_at(current_watched)
-        if @last_update_at < current_updated_at
-          @watched    = current_watched
-          @updated_at = current_updated_at
-          true
-        else
-          false
-        end
-      end
-    end
-
-    # Executes the given block and updates the latest watched files and
-    # timestamp.
-    def execute
-      @last_watched   = watched
-      @last_update_at = updated_at(@last_watched)
-      @block.call
-    ensure
-      @watched = nil
-      @updated_at = nil
-    end
-
-    # Execute the block given if updated.
-    def execute_if_updated
-      if updated?
-        yield if block_given?
-        execute
-        true
-      else
-        false
-      end
-    end
-
-    private
-      def watched
-        @watched || begin
-          all = @files.select { |f| File.exist?(f) }
-          all.concat(Dir[@glob]) if @glob
-          all
-        end
-      end
-
-      def updated_at(paths)
-        @updated_at || max_mtime(paths) || Time.at(0)
-      end
-
-      # This method returns the maximum mtime of the files in +paths+, or +nil+
-      # if the array is empty.
-      #
-      # Files with a mtime in the future are ignored. Such abnormal situation
-      # can happen for example if the user changes the clock by hand. It is
-      # healthy to consider this edge case because with mtimes in the future
-      # reloading is not triggered.
-      def max_mtime(paths)
-        time_now = Time.now
-        max_mtime = nil
-
-        # Time comparisons are performed with #compare_without_coercion because
-        # AS redefines these operators in a way that is much slower and does not
-        # bring any benefit in this particular code.
-        #
-        # Read t1.compare_without_coercion(t2) < 0 as t1 < t2.
-        paths.each do |path|
-          mtime = File.mtime(path)
-
-          next if time_now.compare_without_coercion(mtime) < 0
-
-          if max_mtime.nil? || max_mtime.compare_without_coercion(mtime) < 0
-            max_mtime = mtime
-          end
-        end
-
-        max_mtime
-      end
-
-      def compile_glob(hash)
-        hash.freeze # Freeze so changes aren't accidentally pushed
-        return if hash.empty?
-
-        globs = hash.map do |key, value|
-          "#{escape(key)}/**/*#{compile_ext(value)}"
-        end
-        "{#{globs.join(",")}}"
-      end
-
-      def escape(key)
-        key.gsub(",", '\,')
-      end
-
-      def compile_ext(array)
-        array = Array(array)
-        return if array.empty?
-        ".{#{array.join(",")}}"
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/fork_tracker.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/fork_tracker.rb
deleted file mode 100644
index 2f250378ba661..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/fork_tracker.rb
+++ /dev/null
@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  module ForkTracker # :nodoc:
-    module CoreExt
-      def fork(*)
-        if block_given?
-          super do
-            ForkTracker.check!
-            yield
-          end
-        else
-          unless pid = super
-            ForkTracker.check!
-          end
-          pid
-        end
-      end
-      ruby2_keywords(:fork) if respond_to?(:ruby2_keywords, true)
-    end
-
-    module CoreExtPrivate
-      include CoreExt
-
-      private
-        def fork(*)
-          super
-        end
-        ruby2_keywords(:fork) if respond_to?(:ruby2_keywords, true)
-    end
-
-    @pid = Process.pid
-    @callbacks = []
-
-    class << self
-      def check!
-        if @pid != Process.pid
-          @callbacks.each(&:call)
-          @pid = Process.pid
-        end
-      end
-
-      def hook!
-        if Process.respond_to?(:fork)
-          ::Object.prepend(CoreExtPrivate)
-          ::Kernel.prepend(CoreExtPrivate)
-          ::Kernel.singleton_class.prepend(CoreExt)
-          ::Process.singleton_class.prepend(CoreExt)
-        end
-      end
-
-      def after_fork(&block)
-        @callbacks << block
-        block
-      end
-
-      def unregister(callback)
-        @callbacks.delete(callback)
-      end
-    end
-  end
-end
-
-ActiveSupport::ForkTracker.hook!
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/gem_version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/gem_version.rb
deleted file mode 100644
index 5df143a859036..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/gem_version.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  # Returns the version of the currently loaded Active Support as a <tt>Gem::Version</tt>.
-  def self.gem_version
-    Gem::Version.new VERSION::STRING
-  end
-
-  module VERSION
-    MAJOR = 6
-    MINOR = 1
-    TINY  = 6
-    PRE   = "1"
-
-    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/gzip.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/gzip.rb
deleted file mode 100644
index 7ffa6d90a205d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/gzip.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "zlib"
-require "stringio"
-
-module ActiveSupport
-  # A convenient wrapper for the zlib standard library that allows
-  # compression/decompression of strings with gzip.
-  #
-  #   gzip = ActiveSupport::Gzip.compress('compress me!')
-  #   # => "\x1F\x8B\b\x00o\x8D\xCDO\x00\x03K\xCE\xCF-(J-.V\xC8MU\x04\x00R>n\x83\f\x00\x00\x00"
-  #
-  #   ActiveSupport::Gzip.decompress(gzip)
-  #   # => "compress me!"
-  module Gzip
-    class Stream < StringIO
-      def initialize(*)
-        super
-        set_encoding "BINARY"
-      end
-      def close; rewind; end
-    end
-
-    # Decompresses a gzipped string.
-    def self.decompress(source)
-      Zlib::GzipReader.wrap(StringIO.new(source), &:read)
-    end
-
-    # Compresses a string using gzip.
-    def self.compress(source, level = Zlib::DEFAULT_COMPRESSION, strategy = Zlib::DEFAULT_STRATEGY)
-      output = Stream.new
-      gz = Zlib::GzipWriter.new(output, level, strategy)
-      gz.write(source)
-      gz.close
-      output.string
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/hash_with_indifferent_access.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/hash_with_indifferent_access.rb
deleted file mode 100644
index 4e574cd05931b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/hash_with_indifferent_access.rb
+++ /dev/null
@@ -1,423 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/hash/keys"
-require "active_support/core_ext/hash/reverse_merge"
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/hash/slice"
-
-module ActiveSupport
-  # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are considered
-  # to be the same.
-  #
-  #   rgb = ActiveSupport::HashWithIndifferentAccess.new
-  #
-  #   rgb[:black] = '#000000'
-  #   rgb[:black]  # => '#000000'
-  #   rgb['black'] # => '#000000'
-  #
-  #   rgb['white'] = '#FFFFFF'
-  #   rgb[:white]  # => '#FFFFFF'
-  #   rgb['white'] # => '#FFFFFF'
-  #
-  # Internally symbols are mapped to strings when used as keys in the entire
-  # writing interface (calling <tt>[]=</tt>, <tt>merge</tt>, etc). This
-  # mapping belongs to the public interface. For example, given:
-  #
-  #   hash = ActiveSupport::HashWithIndifferentAccess.new(a: 1)
-  #
-  # You are guaranteed that the key is returned as a string:
-  #
-  #   hash.keys # => ["a"]
-  #
-  # Technically other types of keys are accepted:
-  #
-  #   hash = ActiveSupport::HashWithIndifferentAccess.new(a: 1)
-  #   hash[0] = 0
-  #   hash # => {"a"=>1, 0=>0}
-  #
-  # but this class is intended for use cases where strings or symbols are the
-  # expected keys and it is convenient to understand both as the same. For
-  # example the +params+ hash in Ruby on Rails.
-  #
-  # Note that core extensions define <tt>Hash#with_indifferent_access</tt>:
-  #
-  #   rgb = { black: '#000000', white: '#FFFFFF' }.with_indifferent_access
-  #
-  # which may be handy.
-  #
-  # To access this class outside of Rails, require the core extension with:
-  #
-  #   require "active_support/core_ext/hash/indifferent_access"
-  #
-  # which will, in turn, require this file.
-  class HashWithIndifferentAccess < Hash
-    # Returns +true+ so that <tt>Array#extract_options!</tt> finds members of
-    # this class.
-    def extractable_options?
-      true
-    end
-
-    def with_indifferent_access
-      dup
-    end
-
-    def nested_under_indifferent_access
-      self
-    end
-
-    def initialize(constructor = {})
-      if constructor.respond_to?(:to_hash)
-        super()
-        update(constructor)
-
-        hash = constructor.is_a?(Hash) ? constructor : constructor.to_hash
-        self.default = hash.default if hash.default
-        self.default_proc = hash.default_proc if hash.default_proc
-      else
-        super(constructor)
-      end
-    end
-
-    def self.[](*args)
-      new.merge!(Hash[*args])
-    end
-
-    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-    alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-    # Assigns a new value to the hash:
-    #
-    #   hash = ActiveSupport::HashWithIndifferentAccess.new
-    #   hash[:key] = 'value'
-    #
-    # This value can be later fetched using either +:key+ or <tt>'key'</tt>.
-    def []=(key, value)
-      regular_writer(convert_key(key), convert_value(value, conversion: :assignment))
-    end
-
-    alias_method :store, :[]=
-
-    # Updates the receiver in-place, merging in the hashes passed as arguments:
-    #
-    #   hash_1 = ActiveSupport::HashWithIndifferentAccess.new
-    #   hash_1[:key] = 'value'
-    #
-    #   hash_2 = ActiveSupport::HashWithIndifferentAccess.new
-    #   hash_2[:key] = 'New Value!'
-    #
-    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
-    #
-    #   hash = ActiveSupport::HashWithIndifferentAccess.new
-    #   hash.update({ "a" => 1 }, { "b" => 2 }) # => { "a" => 1, "b" => 2 }
-    #
-    # The arguments can be either an
-    # <tt>ActiveSupport::HashWithIndifferentAccess</tt> or a regular +Hash+.
-    # In either case the merge respects the semantics of indifferent access.
-    #
-    # If the argument is a regular hash with keys +:key+ and <tt>"key"</tt> only one
-    # of the values end up in the receiver, but which one is unspecified.
-    #
-    # When given a block, the value for duplicated keys will be determined
-    # by the result of invoking the block with the duplicated key, the value
-    # in the receiver, and the value in +other_hash+. The rules for duplicated
-    # keys follow the semantics of indifferent access:
-    #
-    #   hash_1[:key] = 10
-    #   hash_2['key'] = 12
-    #   hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}
-    def update(*other_hashes, &block)
-      if other_hashes.size == 1
-        update_with_single_argument(other_hashes.first, block)
-      else
-        other_hashes.each do |other_hash|
-          update_with_single_argument(other_hash, block)
-        end
-      end
-      self
-    end
-
-    alias_method :merge!, :update
-
-    # Checks the hash for a key matching the argument passed in:
-    #
-    #   hash = ActiveSupport::HashWithIndifferentAccess.new
-    #   hash['key'] = 'value'
-    #   hash.key?(:key)  # => true
-    #   hash.key?('key') # => true
-    def key?(key)
-      super(convert_key(key))
-    end
-
-    alias_method :include?, :key?
-    alias_method :has_key?, :key?
-    alias_method :member?, :key?
-
-    # Same as <tt>Hash#[]</tt> where the key passed as argument can be
-    # either a string or a symbol:
-    #
-    #   counters = ActiveSupport::HashWithIndifferentAccess.new
-    #   counters[:foo] = 1
-    #
-    #   counters['foo'] # => 1
-    #   counters[:foo]  # => 1
-    #   counters[:zoo]  # => nil
-    def [](key)
-      super(convert_key(key))
-    end
-
-    # Same as <tt>Hash#assoc</tt> where the key passed as argument can be
-    # either a string or a symbol:
-    #
-    #   counters = ActiveSupport::HashWithIndifferentAccess.new
-    #   counters[:foo] = 1
-    #
-    #   counters.assoc('foo') # => ["foo", 1]
-    #   counters.assoc(:foo)  # => ["foo", 1]
-    #   counters.assoc(:zoo)  # => nil
-    def assoc(key)
-      super(convert_key(key))
-    end
-
-    # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
-    # either a string or a symbol:
-    #
-    #   counters = ActiveSupport::HashWithIndifferentAccess.new
-    #   counters[:foo] = 1
-    #
-    #   counters.fetch('foo')          # => 1
-    #   counters.fetch(:bar, 0)        # => 0
-    #   counters.fetch(:bar) { |key| 0 } # => 0
-    #   counters.fetch(:zoo)           # => KeyError: key not found: "zoo"
-    def fetch(key, *extras)
-      super(convert_key(key), *extras)
-    end
-
-    # Same as <tt>Hash#dig</tt> where the key passed as argument can be
-    # either a string or a symbol:
-    #
-    #   counters = ActiveSupport::HashWithIndifferentAccess.new
-    #   counters[:foo] = { bar: 1 }
-    #
-    #   counters.dig('foo', 'bar')     # => 1
-    #   counters.dig(:foo, :bar)       # => 1
-    #   counters.dig(:zoo)             # => nil
-    def dig(*args)
-      args[0] = convert_key(args[0]) if args.size > 0
-      super(*args)
-    end
-
-    # Same as <tt>Hash#default</tt> where the key passed as argument can be
-    # either a string or a symbol:
-    #
-    #   hash = ActiveSupport::HashWithIndifferentAccess.new(1)
-    #   hash.default                   # => 1
-    #
-    #   hash = ActiveSupport::HashWithIndifferentAccess.new { |hash, key| key }
-    #   hash.default                   # => nil
-    #   hash.default('foo')            # => 'foo'
-    #   hash.default(:foo)             # => 'foo'
-    def default(*args)
-      super(*args.map { |arg| convert_key(arg) })
-    end
-
-    # Returns an array of the values at the specified indices:
-    #
-    #   hash = ActiveSupport::HashWithIndifferentAccess.new
-    #   hash[:a] = 'x'
-    #   hash[:b] = 'y'
-    #   hash.values_at('a', 'b') # => ["x", "y"]
-    def values_at(*keys)
-      super(*keys.map { |key| convert_key(key) })
-    end
-
-    # Returns an array of the values at the specified indices, but also
-    # raises an exception when one of the keys can't be found.
-    #
-    #   hash = ActiveSupport::HashWithIndifferentAccess.new
-    #   hash[:a] = 'x'
-    #   hash[:b] = 'y'
-    #   hash.fetch_values('a', 'b') # => ["x", "y"]
-    #   hash.fetch_values('a', 'c') { |key| 'z' } # => ["x", "z"]
-    #   hash.fetch_values('a', 'c') # => KeyError: key not found: "c"
-    def fetch_values(*indices, &block)
-      super(*indices.map { |key| convert_key(key) }, &block)
-    end
-
-    # Returns a shallow copy of the hash.
-    #
-    #   hash = ActiveSupport::HashWithIndifferentAccess.new({ a: { b: 'b' } })
-    #   dup  = hash.dup
-    #   dup[:a][:c] = 'c'
-    #
-    #   hash[:a][:c] # => "c"
-    #   dup[:a][:c]  # => "c"
-    def dup
-      self.class.new(self).tap do |new_hash|
-        set_defaults(new_hash)
-      end
-    end
-
-    # This method has the same semantics of +update+, except it does not
-    # modify the receiver but rather returns a new hash with indifferent
-    # access with the result of the merge.
-    def merge(*hashes, &block)
-      dup.update(*hashes, &block)
-    end
-
-    # Like +merge+ but the other way around: Merges the receiver into the
-    # argument and returns a new hash with indifferent access as result:
-    #
-    #   hash = ActiveSupport::HashWithIndifferentAccess.new
-    #   hash['a'] = nil
-    #   hash.reverse_merge(a: 0, b: 1) # => {"a"=>nil, "b"=>1}
-    def reverse_merge(other_hash)
-      super(self.class.new(other_hash))
-    end
-    alias_method :with_defaults, :reverse_merge
-
-    # Same semantics as +reverse_merge+ but modifies the receiver in-place.
-    def reverse_merge!(other_hash)
-      super(self.class.new(other_hash))
-    end
-    alias_method :with_defaults!, :reverse_merge!
-
-    # Replaces the contents of this hash with other_hash.
-    #
-    #   h = { "a" => 100, "b" => 200 }
-    #   h.replace({ "c" => 300, "d" => 400 }) # => {"c"=>300, "d"=>400}
-    def replace(other_hash)
-      super(self.class.new(other_hash))
-    end
-
-    # Removes the specified key from the hash.
-    def delete(key)
-      super(convert_key(key))
-    end
-
-    # Returns a hash with indifferent access that includes everything except given keys.
-    #   hash = { a: "x", b: "y", c: 10 }.with_indifferent_access
-    #   hash.except(:a, "b") # => {c: 10}.with_indifferent_access
-    #   hash                 # => { a: "x", b: "y", c: 10 }.with_indifferent_access
-    def except(*keys)
-      slice(*self.keys - keys.map { |key| convert_key(key) })
-    end
-    alias_method :without, :except
-
-    def stringify_keys!; self end
-    def deep_stringify_keys!; self end
-    def stringify_keys; dup end
-    def deep_stringify_keys; dup end
-    undef :symbolize_keys!
-    undef :deep_symbolize_keys!
-    def symbolize_keys; to_hash.symbolize_keys! end
-    alias_method :to_options, :symbolize_keys
-    def deep_symbolize_keys; to_hash.deep_symbolize_keys! end
-    def to_options!; self end
-
-    def select(*args, &block)
-      return to_enum(:select) unless block_given?
-      dup.tap { |hash| hash.select!(*args, &block) }
-    end
-
-    def reject(*args, &block)
-      return to_enum(:reject) unless block_given?
-      dup.tap { |hash| hash.reject!(*args, &block) }
-    end
-
-    def transform_values(*args, &block)
-      return to_enum(:transform_values) unless block_given?
-      dup.tap { |hash| hash.transform_values!(*args, &block) }
-    end
-
-    def transform_keys(*args, &block)
-      return to_enum(:transform_keys) unless block_given?
-      dup.tap { |hash| hash.transform_keys!(*args, &block) }
-    end
-
-    def transform_keys!
-      return enum_for(:transform_keys!) { size } unless block_given?
-      keys.each do |key|
-        self[yield(key)] = delete(key)
-      end
-      self
-    end
-
-    def slice(*keys)
-      keys.map! { |key| convert_key(key) }
-      self.class.new(super)
-    end
-
-    def slice!(*keys)
-      keys.map! { |key| convert_key(key) }
-      super
-    end
-
-    def compact
-      dup.tap(&:compact!)
-    end
-
-    # Convert to a regular hash with string keys.
-    def to_hash
-      _new_hash = Hash.new
-      set_defaults(_new_hash)
-
-      each do |key, value|
-        _new_hash[key] = convert_value(value, conversion: :to_hash)
-      end
-      _new_hash
-    end
-
-    private
-      if Symbol.method_defined?(:name)
-        def convert_key(key)
-          key.kind_of?(Symbol) ? key.name : key
-        end
-      else
-        def convert_key(key)
-          key.kind_of?(Symbol) ? key.to_s : key
-        end
-      end
-
-      def convert_value(value, conversion: nil)
-        if value.is_a? Hash
-          if conversion == :to_hash
-            value.to_hash
-          else
-            value.nested_under_indifferent_access
-          end
-        elsif value.is_a?(Array)
-          if conversion != :assignment || value.frozen?
-            value = value.dup
-          end
-          value.map! { |e| convert_value(e, conversion: conversion) }
-        else
-          value
-        end
-      end
-
-      def set_defaults(target)
-        if default_proc
-          target.default_proc = default_proc.dup
-        else
-          target.default = default
-        end
-      end
-
-      def update_with_single_argument(other_hash, block)
-        if other_hash.is_a? HashWithIndifferentAccess
-          regular_update(other_hash, &block)
-        else
-          other_hash.to_hash.each_pair do |key, value|
-            if block && key?(key)
-              value = block.call(convert_key(key), self[key], value)
-            end
-            regular_writer(convert_key(key), convert_value(value))
-          end
-        end
-      end
-  end
-end
-
-# :stopdoc:
-
-HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/i18n.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/i18n.rb
deleted file mode 100644
index 39dab1cc71aa3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/i18n.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/hash/deep_merge"
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/hash/slice"
-begin
-  require "i18n"
-rescue LoadError => e
-  $stderr.puts "The i18n gem is not available. Please add it to your Gemfile and run bundle install"
-  raise e
-end
-require "active_support/lazy_load_hooks"
-
-ActiveSupport.run_load_hooks(:i18n)
-I18n.load_path << File.expand_path("locale/en.yml", __dir__)
-I18n.load_path << File.expand_path("locale/en.rb", __dir__)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/i18n_railtie.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/i18n_railtie.rb
deleted file mode 100644
index 094f65ad6c0a0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/i18n_railtie.rb
+++ /dev/null
@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support"
-require "active_support/core_ext/array/wrap"
-
-# :enddoc:
-
-module I18n
-  class Railtie < Rails::Railtie
-    config.i18n = ActiveSupport::OrderedOptions.new
-    config.i18n.railties_load_path = []
-    config.i18n.load_path = []
-    config.i18n.fallbacks = ActiveSupport::OrderedOptions.new
-
-    config.eager_load_namespaces << I18n
-
-    # Set the i18n configuration after initialization since a lot of
-    # configuration is still usually done in application initializers.
-    config.after_initialize do |app|
-      I18n::Railtie.initialize_i18n(app)
-    end
-
-    # Trigger i18n config before any eager loading has happened
-    # so it's ready if any classes require it when eager loaded.
-    config.before_eager_load do |app|
-      I18n::Railtie.initialize_i18n(app)
-    end
-
-    @i18n_inited = false
-
-    # Setup i18n configuration.
-    def self.initialize_i18n(app)
-      return if @i18n_inited
-
-      fallbacks = app.config.i18n.delete(:fallbacks)
-
-      # Avoid issues with setting the default_locale by disabling available locales
-      # check while configuring.
-      enforce_available_locales = app.config.i18n.delete(:enforce_available_locales)
-      enforce_available_locales = I18n.enforce_available_locales if enforce_available_locales.nil?
-      I18n.enforce_available_locales = false
-
-      reloadable_paths = []
-      app.config.i18n.each do |setting, value|
-        case setting
-        when :railties_load_path
-          reloadable_paths = value
-          app.config.i18n.load_path.unshift(*value.flat_map(&:existent))
-        when :load_path
-          I18n.load_path += value
-        when :raise_on_missing_translations
-          forward_raise_on_missing_translations_config(app)
-        else
-          I18n.public_send("#{setting}=", value)
-        end
-      end
-
-      init_fallbacks(fallbacks) if fallbacks && validate_fallbacks(fallbacks)
-
-      # Restore available locales check so it will take place from now on.
-      I18n.enforce_available_locales = enforce_available_locales
-
-      directories = watched_dirs_with_extensions(reloadable_paths)
-      reloader = app.config.file_watcher.new(I18n.load_path.dup, directories) do
-        I18n.load_path.keep_if { |p| File.exist?(p) }
-        I18n.load_path |= reloadable_paths.flat_map(&:existent)
-      end
-
-      app.reloaders << reloader
-      app.reloader.to_run do
-        reloader.execute_if_updated { require_unload_lock! }
-      end
-      reloader.execute
-
-      @i18n_inited = true
-    end
-
-    def self.forward_raise_on_missing_translations_config(app)
-      ActiveSupport.on_load(:action_view) do
-        self.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations
-      end
-
-      ActiveSupport.on_load(:action_controller) do
-        AbstractController::Translation.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations
-      end
-    end
-
-    def self.include_fallbacks_module
-      I18n.backend.class.include(I18n::Backend::Fallbacks)
-    end
-
-    def self.init_fallbacks(fallbacks)
-      include_fallbacks_module
-
-      args = \
-        case fallbacks
-        when ActiveSupport::OrderedOptions
-          [*(fallbacks[:defaults] || []) << fallbacks[:map]].compact
-        when Hash, Array
-          Array.wrap(fallbacks)
-        else # TrueClass
-          [I18n.default_locale]
-        end
-
-      I18n.fallbacks = I18n::Locale::Fallbacks.new(*args)
-    end
-
-    def self.validate_fallbacks(fallbacks)
-      case fallbacks
-      when ActiveSupport::OrderedOptions
-        !fallbacks.empty?
-      when TrueClass, Array, Hash
-        true
-      else
-        raise "Unexpected fallback type #{fallbacks.inspect}"
-      end
-    end
-
-    def self.watched_dirs_with_extensions(paths)
-      paths.each_with_object({}) do |path, result|
-        result[path.absolute_current] = path.extensions
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflections.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflections.rb
deleted file mode 100644
index baf1cb30388d7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflections.rb
+++ /dev/null
@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/inflector/inflections"
-
-#--
-# Defines the standard inflection rules. These are the starting point for
-# new projects and are not considered complete. The current set of inflection
-# rules is frozen. This means, we do not change them to become more complete.
-# This is a safety measure to keep existing applications from breaking.
-#++
-module ActiveSupport
-  Inflector.inflections(:en) do |inflect|
-    inflect.plural(/$/, "s")
-    inflect.plural(/s$/i, "s")
-    inflect.plural(/^(ax|test)is$/i, '\1es')
-    inflect.plural(/(octop|vir)us$/i, '\1i')
-    inflect.plural(/(octop|vir)i$/i, '\1i')
-    inflect.plural(/(alias|status)$/i, '\1es')
-    inflect.plural(/(bu)s$/i, '\1ses')
-    inflect.plural(/(buffal|tomat)o$/i, '\1oes')
-    inflect.plural(/([ti])um$/i, '\1a')
-    inflect.plural(/([ti])a$/i, '\1a')
-    inflect.plural(/sis$/i, "ses")
-    inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
-    inflect.plural(/(hive)$/i, '\1s')
-    inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
-    inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
-    inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
-    inflect.plural(/^(m|l)ouse$/i, '\1ice')
-    inflect.plural(/^(m|l)ice$/i, '\1ice')
-    inflect.plural(/^(ox)$/i, '\1en')
-    inflect.plural(/^(oxen)$/i, '\1')
-    inflect.plural(/(quiz)$/i, '\1zes')
-
-    inflect.singular(/s$/i, "")
-    inflect.singular(/(ss)$/i, '\1')
-    inflect.singular(/(n)ews$/i, '\1ews')
-    inflect.singular(/([ti])a$/i, '\1um')
-    inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis')
-    inflect.singular(/(^analy)(sis|ses)$/i, '\1sis')
-    inflect.singular(/([^f])ves$/i, '\1fe')
-    inflect.singular(/(hive)s$/i, '\1')
-    inflect.singular(/(tive)s$/i, '\1')
-    inflect.singular(/([lr])ves$/i, '\1f')
-    inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
-    inflect.singular(/(s)eries$/i, '\1eries')
-    inflect.singular(/(m)ovies$/i, '\1ovie')
-    inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
-    inflect.singular(/^(m|l)ice$/i, '\1ouse')
-    inflect.singular(/(bus)(es)?$/i, '\1')
-    inflect.singular(/(o)es$/i, '\1')
-    inflect.singular(/(shoe)s$/i, '\1')
-    inflect.singular(/(cris|test)(is|es)$/i, '\1is')
-    inflect.singular(/^(a)x[ie]s$/i, '\1xis')
-    inflect.singular(/(octop|vir)(us|i)$/i, '\1us')
-    inflect.singular(/(alias|status)(es)?$/i, '\1')
-    inflect.singular(/^(ox)en/i, '\1')
-    inflect.singular(/(vert|ind)ices$/i, '\1ex')
-    inflect.singular(/(matr)ices$/i, '\1ix')
-    inflect.singular(/(quiz)zes$/i, '\1')
-    inflect.singular(/(database)s$/i, '\1')
-
-    inflect.irregular("person", "people")
-    inflect.irregular("man", "men")
-    inflect.irregular("child", "children")
-    inflect.irregular("sex", "sexes")
-    inflect.irregular("move", "moves")
-    inflect.irregular("zombie", "zombies")
-
-    inflect.uncountable(%w(equipment information rice money species series fish sheep jeans police))
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflector.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflector.rb
deleted file mode 100644
index d77f04c9c5fa1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflector.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-# in case active_support/inflector is required without the rest of active_support
-require "active_support/inflector/inflections"
-require "active_support/inflector/transliterate"
-require "active_support/inflector/methods"
-
-require "active_support/inflections"
-require "active_support/core_ext/string/inflections"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflector/inflections.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflector/inflections.rb
deleted file mode 100644
index 99228a506f9c6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflector/inflections.rb
+++ /dev/null
@@ -1,255 +0,0 @@
-# frozen_string_literal: true
-
-require "concurrent/map"
-require "active_support/i18n"
-
-module ActiveSupport
-  module Inflector
-    extend self
-
-    # A singleton instance of this class is yielded by Inflector.inflections,
-    # which can then be used to specify additional inflection rules. If passed
-    # an optional locale, rules for other languages can be specified. The
-    # default locale is <tt>:en</tt>. Only rules for English are provided.
-    #
-    #   ActiveSupport::Inflector.inflections(:en) do |inflect|
-    #     inflect.plural /^(ox)$/i, '\1\2en'
-    #     inflect.singular /^(ox)en/i, '\1'
-    #
-    #     inflect.irregular 'octopus', 'octopi'
-    #
-    #     inflect.uncountable 'equipment'
-    #   end
-    #
-    # New rules are added at the top. So in the example above, the irregular
-    # rule for octopus will now be the first of the pluralization and
-    # singularization rules that is runs. This guarantees that your rules run
-    # before any of the rules that may already have been loaded.
-    class Inflections
-      @__instance__ = Concurrent::Map.new
-
-      class Uncountables < Array
-        def initialize
-          @regex_array = []
-          super
-        end
-
-        def delete(entry)
-          super entry
-          @regex_array.delete(to_regex(entry))
-        end
-
-        def <<(*word)
-          add(word)
-        end
-
-        def add(words)
-          words = words.flatten.map(&:downcase)
-          concat(words)
-          @regex_array += words.map { |word| to_regex(word) }
-          self
-        end
-
-        def uncountable?(str)
-          @regex_array.any? { |regex| regex.match? str }
-        end
-
-        private
-          def to_regex(string)
-            /\b#{::Regexp.escape(string)}\Z/i
-          end
-      end
-
-      def self.instance(locale = :en)
-        @__instance__[locale] ||= new
-      end
-
-      attr_reader :plurals, :singulars, :uncountables, :humans, :acronyms
-
-      attr_reader :acronyms_camelize_regex, :acronyms_underscore_regex # :nodoc:
-
-      def initialize
-        @plurals, @singulars, @uncountables, @humans, @acronyms = [], [], Uncountables.new, [], {}
-        define_acronym_regex_patterns
-      end
-
-      # Private, for the test suite.
-      def initialize_dup(orig) # :nodoc:
-        %w(plurals singulars uncountables humans acronyms).each do |scope|
-          instance_variable_set("@#{scope}", orig.public_send(scope).dup)
-        end
-        define_acronym_regex_patterns
-      end
-
-      # Specifies a new acronym. An acronym must be specified as it will appear
-      # in a camelized string. An underscore string that contains the acronym
-      # will retain the acronym when passed to +camelize+, +humanize+, or
-      # +titleize+. A camelized string that contains the acronym will maintain
-      # the acronym when titleized or humanized, and will convert the acronym
-      # into a non-delimited single lowercase word when passed to +underscore+.
-      #
-      #   acronym 'HTML'
-      #   titleize 'html'     # => 'HTML'
-      #   camelize 'html'     # => 'HTML'
-      #   underscore 'MyHTML' # => 'my_html'
-      #
-      # The acronym, however, must occur as a delimited unit and not be part of
-      # another word for conversions to recognize it:
-      #
-      #   acronym 'HTTP'
-      #   camelize 'my_http_delimited' # => 'MyHTTPDelimited'
-      #   camelize 'https'             # => 'Https', not 'HTTPs'
-      #   underscore 'HTTPS'           # => 'http_s', not 'https'
-      #
-      #   acronym 'HTTPS'
-      #   camelize 'https'   # => 'HTTPS'
-      #   underscore 'HTTPS' # => 'https'
-      #
-      # Note: Acronyms that are passed to +pluralize+ will no longer be
-      # recognized, since the acronym will not occur as a delimited unit in the
-      # pluralized result. To work around this, you must specify the pluralized
-      # form as an acronym as well:
-      #
-      #    acronym 'API'
-      #    camelize(pluralize('api')) # => 'Apis'
-      #
-      #    acronym 'APIs'
-      #    camelize(pluralize('api')) # => 'APIs'
-      #
-      # +acronym+ may be used to specify any word that contains an acronym or
-      # otherwise needs to maintain a non-standard capitalization. The only
-      # restriction is that the word must begin with a capital letter.
-      #
-      #   acronym 'RESTful'
-      #   underscore 'RESTful'           # => 'restful'
-      #   underscore 'RESTfulController' # => 'restful_controller'
-      #   titleize 'RESTfulController'   # => 'RESTful Controller'
-      #   camelize 'restful'             # => 'RESTful'
-      #   camelize 'restful_controller'  # => 'RESTfulController'
-      #
-      #   acronym 'McDonald'
-      #   underscore 'McDonald' # => 'mcdonald'
-      #   camelize 'mcdonald'   # => 'McDonald'
-      def acronym(word)
-        @acronyms[word.downcase] = word
-        define_acronym_regex_patterns
-      end
-
-      # Specifies a new pluralization rule and its replacement. The rule can
-      # either be a string or a regular expression. The replacement should
-      # always be a string that may include references to the matched data from
-      # the rule.
-      def plural(rule, replacement)
-        @uncountables.delete(rule) if rule.is_a?(String)
-        @uncountables.delete(replacement)
-        @plurals.prepend([rule, replacement])
-      end
-
-      # Specifies a new singularization rule and its replacement. The rule can
-      # either be a string or a regular expression. The replacement should
-      # always be a string that may include references to the matched data from
-      # the rule.
-      def singular(rule, replacement)
-        @uncountables.delete(rule) if rule.is_a?(String)
-        @uncountables.delete(replacement)
-        @singulars.prepend([rule, replacement])
-      end
-
-      # Specifies a new irregular that applies to both pluralization and
-      # singularization at the same time. This can only be used for strings, not
-      # regular expressions. You simply pass the irregular in singular and
-      # plural form.
-      #
-      #   irregular 'octopus', 'octopi'
-      #   irregular 'person', 'people'
-      def irregular(singular, plural)
-        @uncountables.delete(singular)
-        @uncountables.delete(plural)
-
-        s0 = singular[0]
-        srest = singular[1..-1]
-
-        p0 = plural[0]
-        prest = plural[1..-1]
-
-        if s0.upcase == p0.upcase
-          plural(/(#{s0})#{srest}$/i, '\1' + prest)
-          plural(/(#{p0})#{prest}$/i, '\1' + prest)
-
-          singular(/(#{s0})#{srest}$/i, '\1' + srest)
-          singular(/(#{p0})#{prest}$/i, '\1' + srest)
-        else
-          plural(/#{s0.upcase}(?i)#{srest}$/,   p0.upcase   + prest)
-          plural(/#{s0.downcase}(?i)#{srest}$/, p0.downcase + prest)
-          plural(/#{p0.upcase}(?i)#{prest}$/,   p0.upcase   + prest)
-          plural(/#{p0.downcase}(?i)#{prest}$/, p0.downcase + prest)
-
-          singular(/#{s0.upcase}(?i)#{srest}$/,   s0.upcase   + srest)
-          singular(/#{s0.downcase}(?i)#{srest}$/, s0.downcase + srest)
-          singular(/#{p0.upcase}(?i)#{prest}$/,   s0.upcase   + srest)
-          singular(/#{p0.downcase}(?i)#{prest}$/, s0.downcase + srest)
-        end
-      end
-
-      # Specifies words that are uncountable and should not be inflected.
-      #
-      #   uncountable 'money'
-      #   uncountable 'money', 'information'
-      #   uncountable %w( money information rice )
-      def uncountable(*words)
-        @uncountables.add(words)
-      end
-
-      # Specifies a humanized form of a string by a regular expression rule or
-      # by a string mapping. When using a regular expression based replacement,
-      # the normal humanize formatting is called after the replacement. When a
-      # string is used, the human form should be specified as desired (example:
-      # 'The name', not 'the_name').
-      #
-      #   human /_cnt$/i, '\1_count'
-      #   human 'legacy_col_person_name', 'Name'
-      def human(rule, replacement)
-        @humans.prepend([rule, replacement])
-      end
-
-      # Clears the loaded inflections within a given scope (default is
-      # <tt>:all</tt>). Give the scope as a symbol of the inflection type, the
-      # options are: <tt>:plurals</tt>, <tt>:singulars</tt>, <tt>:uncountables</tt>,
-      # <tt>:humans</tt>.
-      #
-      #   clear :all
-      #   clear :plurals
-      def clear(scope = :all)
-        case scope
-        when :all
-          @plurals, @singulars, @uncountables, @humans = [], [], Uncountables.new, []
-        else
-          instance_variable_set "@#{scope}", []
-        end
-      end
-
-      private
-        def define_acronym_regex_patterns
-          @acronym_regex             = @acronyms.empty? ? /(?=a)b/ : /#{@acronyms.values.join("|")}/
-          @acronyms_camelize_regex   = /^(?:#{@acronym_regex}(?=\b|[A-Z_])|\w)/
-          @acronyms_underscore_regex = /(?:(?<=([A-Za-z\d]))|\b)(#{@acronym_regex})(?=\b|[^a-z])/
-        end
-    end
-
-    # Yields a singleton instance of Inflector::Inflections so you can specify
-    # additional inflector rules. If passed an optional locale, rules for other
-    # languages can be specified. If not specified, defaults to <tt>:en</tt>.
-    # Only rules for English are provided.
-    #
-    #   ActiveSupport::Inflector.inflections(:en) do |inflect|
-    #     inflect.uncountable 'rails'
-    #   end
-    def inflections(locale = :en)
-      if block_given?
-        yield Inflections.instance(locale)
-      else
-        Inflections.instance(locale)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflector/methods.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflector/methods.rb
deleted file mode 100644
index ad136532bfe93..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflector/methods.rb
+++ /dev/null
@@ -1,401 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/inflections"
-require "active_support/core_ext/object/blank"
-
-module ActiveSupport
-  # The Inflector transforms words from singular to plural, class names to table
-  # names, modularized class names to ones without, and class names to foreign
-  # keys. The default inflections for pluralization, singularization, and
-  # uncountable words are kept in inflections.rb.
-  #
-  # The Rails core team has stated patches for the inflections library will not
-  # be accepted in order to avoid breaking legacy applications which may be
-  # relying on errant inflections. If you discover an incorrect inflection and
-  # require it for your application or wish to define rules for languages other
-  # than English, please correct or add them yourself (explained below).
-  module Inflector
-    extend self
-
-    # Returns the plural form of the word in the string.
-    #
-    # If passed an optional +locale+ parameter, the word will be
-    # pluralized using rules defined for that language. By default,
-    # this parameter is set to <tt>:en</tt>.
-    #
-    #   pluralize('post')             # => "posts"
-    #   pluralize('octopus')          # => "octopi"
-    #   pluralize('sheep')            # => "sheep"
-    #   pluralize('words')            # => "words"
-    #   pluralize('CamelOctopus')     # => "CamelOctopi"
-    #   pluralize('ley', :es)         # => "leyes"
-    def pluralize(word, locale = :en)
-      apply_inflections(word, inflections(locale).plurals, locale)
-    end
-
-    # The reverse of #pluralize, returns the singular form of a word in a
-    # string.
-    #
-    # If passed an optional +locale+ parameter, the word will be
-    # singularized using rules defined for that language. By default,
-    # this parameter is set to <tt>:en</tt>.
-    #
-    #   singularize('posts')            # => "post"
-    #   singularize('octopi')           # => "octopus"
-    #   singularize('sheep')            # => "sheep"
-    #   singularize('word')             # => "word"
-    #   singularize('CamelOctopi')      # => "CamelOctopus"
-    #   singularize('leyes', :es)       # => "ley"
-    def singularize(word, locale = :en)
-      apply_inflections(word, inflections(locale).singulars, locale)
-    end
-
-    # Converts strings to UpperCamelCase.
-    # If the +uppercase_first_letter+ parameter is set to false, then produces
-    # lowerCamelCase.
-    #
-    # Also converts '/' to '::' which is useful for converting
-    # paths to namespaces.
-    #
-    #   camelize('active_model')                # => "ActiveModel"
-    #   camelize('active_model', false)         # => "activeModel"
-    #   camelize('active_model/errors')         # => "ActiveModel::Errors"
-    #   camelize('active_model/errors', false)  # => "activeModel::Errors"
-    #
-    # As a rule of thumb you can think of +camelize+ as the inverse of
-    # #underscore, though there are cases where that does not hold:
-    #
-    #   camelize(underscore('SSLError'))        # => "SslError"
-    def camelize(term, uppercase_first_letter = true)
-      string = term.to_s
-      if uppercase_first_letter
-        string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize }
-      else
-        string = string.sub(inflections.acronyms_camelize_regex) { |match| match.downcase }
-      end
-      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }
-      string.gsub!("/", "::")
-      string
-    end
-
-    # Makes an underscored, lowercase form from the expression in the string.
-    #
-    # Changes '::' to '/' to convert namespaces to paths.
-    #
-    #   underscore('ActiveModel')         # => "active_model"
-    #   underscore('ActiveModel::Errors') # => "active_model/errors"
-    #
-    # As a rule of thumb you can think of +underscore+ as the inverse of
-    # #camelize, though there are cases where that does not hold:
-    #
-    #   camelize(underscore('SSLError'))  # => "SslError"
-    def underscore(camel_cased_word)
-      return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
-      word = camel_cased_word.to_s.gsub("::", "/")
-      word.gsub!(inflections.acronyms_underscore_regex) { "#{$1 && '_' }#{$2.downcase}" }
-      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
-      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-      word.tr!("-", "_")
-      word.downcase!
-      word
-    end
-
-    # Tweaks an attribute name for display to end users.
-    #
-    # Specifically, performs these transformations:
-    #
-    # * Applies human inflection rules to the argument.
-    # * Deletes leading underscores, if any.
-    # * Removes a "_id" suffix if present.
-    # * Replaces underscores with spaces, if any.
-    # * Downcases all words except acronyms.
-    # * Capitalizes the first word.
-    # The capitalization of the first word can be turned off by setting the
-    # +:capitalize+ option to false (default is true).
-    #
-    # The trailing '_id' can be kept and capitalized by setting the
-    # optional parameter +keep_id_suffix+ to true (default is false).
-    #
-    #   humanize('employee_salary')                  # => "Employee salary"
-    #   humanize('author_id')                        # => "Author"
-    #   humanize('author_id', capitalize: false)     # => "author"
-    #   humanize('_id')                              # => "Id"
-    #   humanize('author_id', keep_id_suffix: true)  # => "Author Id"
-    #
-    # If "SSL" was defined to be an acronym:
-    #
-    #   humanize('ssl_error') # => "SSL error"
-    #
-    def humanize(lower_case_and_underscored_word, capitalize: true, keep_id_suffix: false)
-      result = lower_case_and_underscored_word.to_s.dup
-
-      inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
-
-      result.sub!(/\A_+/, "")
-      unless keep_id_suffix
-        result.delete_suffix!("_id")
-      end
-      result.tr!("_", " ")
-
-      result.gsub!(/([a-z\d]*)/i) do |match|
-        "#{inflections.acronyms[match.downcase] || match.downcase}"
-      end
-
-      if capitalize
-        result.sub!(/\A\w/) { |match| match.upcase }
-      end
-
-      result
-    end
-
-    # Converts just the first character to uppercase.
-    #
-    #   upcase_first('what a Lovely Day') # => "What a Lovely Day"
-    #   upcase_first('w')                 # => "W"
-    #   upcase_first('')                  # => ""
-    def upcase_first(string)
-      string.length > 0 ? string[0].upcase.concat(string[1..-1]) : ""
-    end
-
-    # Capitalizes all the words and replaces some characters in the string to
-    # create a nicer looking title. +titleize+ is meant for creating pretty
-    # output. It is not used in the Rails internals.
-    #
-    # The trailing '_id','Id'.. can be kept and capitalized by setting the
-    # optional parameter +keep_id_suffix+ to true.
-    # By default, this parameter is false.
-    #
-    # +titleize+ is also aliased as +titlecase+.
-    #
-    #   titleize('man from the boondocks')                       # => "Man From The Boondocks"
-    #   titleize('x-men: the last stand')                        # => "X Men: The Last Stand"
-    #   titleize('TheManWithoutAPast')                           # => "The Man Without A Past"
-    #   titleize('raiders_of_the_lost_ark')                      # => "Raiders Of The Lost Ark"
-    #   titleize('string_ending_with_id', keep_id_suffix: true)  # => "String Ending With Id"
-    def titleize(word, keep_id_suffix: false)
-      humanize(underscore(word), keep_id_suffix: keep_id_suffix).gsub(/\b(?<!\w['’`()])[a-z]/) do |match|
-        match.capitalize
-      end
-    end
-
-    # Creates the name of a table like Rails does for models to table names.
-    # This method uses the #pluralize method on the last word in the string.
-    #
-    #   tableize('RawScaledScorer') # => "raw_scaled_scorers"
-    #   tableize('ham_and_egg')     # => "ham_and_eggs"
-    #   tableize('fancyCategory')   # => "fancy_categories"
-    def tableize(class_name)
-      pluralize(underscore(class_name))
-    end
-
-    # Creates a class name from a plural table name like Rails does for table
-    # names to models. Note that this returns a string and not a Class (To
-    # convert to an actual class follow +classify+ with #constantize).
-    #
-    #   classify('ham_and_eggs') # => "HamAndEgg"
-    #   classify('posts')        # => "Post"
-    #
-    # Singular names are not handled correctly:
-    #
-    #   classify('calculus')     # => "Calculu"
-    def classify(table_name)
-      # strip out any leading schema name
-      camelize(singularize(table_name.to_s.sub(/.*\./, "")))
-    end
-
-    # Replaces underscores with dashes in the string.
-    #
-    #   dasherize('puni_puni') # => "puni-puni"
-    def dasherize(underscored_word)
-      underscored_word.tr("_", "-")
-    end
-
-    # Removes the module part from the expression in the string.
-    #
-    #   demodulize('ActiveSupport::Inflector::Inflections') # => "Inflections"
-    #   demodulize('Inflections')                           # => "Inflections"
-    #   demodulize('::Inflections')                         # => "Inflections"
-    #   demodulize('')                                      # => ""
-    #
-    # See also #deconstantize.
-    def demodulize(path)
-      path = path.to_s
-      if i = path.rindex("::")
-        path[(i + 2)..-1]
-      else
-        path
-      end
-    end
-
-    # Removes the rightmost segment from the constant expression in the string.
-    #
-    #   deconstantize('Net::HTTP')   # => "Net"
-    #   deconstantize('::Net::HTTP') # => "::Net"
-    #   deconstantize('String')      # => ""
-    #   deconstantize('::String')    # => ""
-    #   deconstantize('')            # => ""
-    #
-    # See also #demodulize.
-    def deconstantize(path)
-      path.to_s[0, path.rindex("::") || 0] # implementation based on the one in facets' Module#spacename
-    end
-
-    # Creates a foreign key name from a class name.
-    # +separate_class_name_and_id_with_underscore+ sets whether
-    # the method should put '_' between the name and 'id'.
-    #
-    #   foreign_key('Message')        # => "message_id"
-    #   foreign_key('Message', false) # => "messageid"
-    #   foreign_key('Admin::Post')    # => "post_id"
-    def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
-      underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id")
-    end
-
-    # Tries to find a constant with the name specified in the argument string.
-    #
-    #   constantize('Module')   # => Module
-    #   constantize('Foo::Bar') # => Foo::Bar
-    #
-    # The name is assumed to be the one of a top-level constant, no matter
-    # whether it starts with "::" or not. No lexical context is taken into
-    # account:
-    #
-    #   C = 'outside'
-    #   module M
-    #     C = 'inside'
-    #     C                # => 'inside'
-    #     constantize('C') # => 'outside', same as ::C
-    #   end
-    #
-    # NameError is raised when the name is not in CamelCase or the constant is
-    # unknown.
-    def constantize(camel_cased_word)
-      if camel_cased_word.blank? || !camel_cased_word.include?("::")
-        Object.const_get(camel_cased_word)
-      else
-        names = camel_cased_word.split("::")
-
-        # Trigger a built-in NameError exception including the ill-formed constant in the message.
-        Object.const_get(camel_cased_word) if names.empty?
-
-        # Remove the first blank element in case of '::ClassName' notation.
-        names.shift if names.size > 1 && names.first.empty?
-
-        names.inject(Object) do |constant, name|
-          if constant == Object
-            constant.const_get(name)
-          else
-            candidate = constant.const_get(name)
-            next candidate if constant.const_defined?(name, false)
-            next candidate unless Object.const_defined?(name)
-
-            # Go down the ancestors to check if it is owned directly. The check
-            # stops when we reach Object or the end of ancestors tree.
-            constant = constant.ancestors.inject(constant) do |const, ancestor|
-              break const    if ancestor == Object
-              break ancestor if ancestor.const_defined?(name, false)
-              const
-            end
-
-            # owner is in Object, so raise
-            constant.const_get(name, false)
-          end
-        end
-      end
-    end
-
-    # Tries to find a constant with the name specified in the argument string.
-    #
-    #   safe_constantize('Module')   # => Module
-    #   safe_constantize('Foo::Bar') # => Foo::Bar
-    #
-    # The name is assumed to be the one of a top-level constant, no matter
-    # whether it starts with "::" or not. No lexical context is taken into
-    # account:
-    #
-    #   C = 'outside'
-    #   module M
-    #     C = 'inside'
-    #     C                     # => 'inside'
-    #     safe_constantize('C') # => 'outside', same as ::C
-    #   end
-    #
-    # +nil+ is returned when the name is not in CamelCase or the constant (or
-    # part of it) is unknown.
-    #
-    #   safe_constantize('blargle')                  # => nil
-    #   safe_constantize('UnknownModule')            # => nil
-    #   safe_constantize('UnknownModule::Foo::Bar')  # => nil
-    def safe_constantize(camel_cased_word)
-      constantize(camel_cased_word)
-    rescue NameError => e
-      raise if e.name && !(camel_cased_word.to_s.split("::").include?(e.name.to_s) ||
-        e.name.to_s == camel_cased_word.to_s)
-    rescue LoadError => e
-      message = e.respond_to?(:original_message) ? e.original_message : e.message
-      raise unless /Unable to autoload constant #{const_regexp(camel_cased_word)}/.match?(message)
-    end
-
-    # Returns the suffix that should be added to a number to denote the position
-    # in an ordered sequence such as 1st, 2nd, 3rd, 4th.
-    #
-    #   ordinal(1)     # => "st"
-    #   ordinal(2)     # => "nd"
-    #   ordinal(1002)  # => "nd"
-    #   ordinal(1003)  # => "rd"
-    #   ordinal(-11)   # => "th"
-    #   ordinal(-1021) # => "st"
-    def ordinal(number)
-      I18n.translate("number.nth.ordinals", number: number)
-    end
-
-    # Turns a number into an ordinal string used to denote the position in an
-    # ordered sequence such as 1st, 2nd, 3rd, 4th.
-    #
-    #   ordinalize(1)     # => "1st"
-    #   ordinalize(2)     # => "2nd"
-    #   ordinalize(1002)  # => "1002nd"
-    #   ordinalize(1003)  # => "1003rd"
-    #   ordinalize(-11)   # => "-11th"
-    #   ordinalize(-1021) # => "-1021st"
-    def ordinalize(number)
-      I18n.translate("number.nth.ordinalized", number: number)
-    end
-
-    private
-      # Mounts a regular expression, returned as a string to ease interpolation,
-      # that will match part by part the given constant.
-      #
-      #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
-      #   const_regexp("::")            # => "::"
-      def const_regexp(camel_cased_word)
-        parts = camel_cased_word.split("::")
-
-        return Regexp.escape(camel_cased_word) if parts.blank?
-
-        last = parts.pop
-
-        parts.reverse!.inject(last) do |acc, part|
-          part.empty? ? acc : "#{part}(::#{acc})?"
-        end
-      end
-
-      # Applies inflection rules for +singularize+ and +pluralize+.
-      #
-      # If passed an optional +locale+ parameter, the uncountables will be
-      # found for that locale.
-      #
-      #  apply_inflections('post', inflections.plurals, :en)    # => "posts"
-      #  apply_inflections('posts', inflections.singulars, :en) # => "post"
-      def apply_inflections(word, rules, locale = :en)
-        result = word.to_s.dup
-
-        if word.empty? || inflections(locale).uncountables.uncountable?(result)
-          result
-        else
-          rules.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
-          result
-        end
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflector/transliterate.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflector/transliterate.rb
deleted file mode 100644
index c398b25d0f4b7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/inflector/transliterate.rb
+++ /dev/null
@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/string/multibyte"
-require "active_support/i18n"
-
-module ActiveSupport
-  module Inflector
-    ALLOWED_ENCODINGS_FOR_TRANSLITERATE = [Encoding::UTF_8, Encoding::US_ASCII, Encoding::GB18030].freeze
-
-    # Replaces non-ASCII characters with an ASCII approximation, or if none
-    # exists, a replacement character which defaults to "?".
-    #
-    #    transliterate('Ærøskøbing')
-    #    # => "AEroskobing"
-    #
-    # Default approximations are provided for Western/Latin characters,
-    # e.g, "ø", "ñ", "é", "ß", etc.
-    #
-    # This method is I18n aware, so you can set up custom approximations for a
-    # locale. This can be useful, for example, to transliterate German's "ü"
-    # and "ö" to "ue" and "oe", or to add support for transliterating Russian
-    # to ASCII.
-    #
-    # In order to make your custom transliterations available, you must set
-    # them as the <tt>i18n.transliterate.rule</tt> i18n key:
-    #
-    #   # Store the transliterations in locales/de.yml
-    #   i18n:
-    #     transliterate:
-    #       rule:
-    #         ü: "ue"
-    #         ö: "oe"
-    #
-    #   # Or set them using Ruby
-    #   I18n.backend.store_translations(:de, i18n: {
-    #     transliterate: {
-    #       rule: {
-    #         'ü' => 'ue',
-    #         'ö' => 'oe'
-    #       }
-    #     }
-    #   })
-    #
-    # The value for <tt>i18n.transliterate.rule</tt> can be a simple Hash that
-    # maps characters to ASCII approximations as shown above, or, for more
-    # complex requirements, a Proc:
-    #
-    #   I18n.backend.store_translations(:de, i18n: {
-    #     transliterate: {
-    #       rule: ->(string) { MyTransliterator.transliterate(string) }
-    #     }
-    #   })
-    #
-    # Now you can have different transliterations for each locale:
-    #
-    #   transliterate('Jürgen', locale: :en)
-    #   # => "Jurgen"
-    #
-    #   transliterate('Jürgen', locale: :de)
-    #   # => "Juergen"
-    #
-    # Transliteration is restricted to UTF-8, US-ASCII and GB18030 strings
-    # Other encodings will raise an ArgumentError.
-    def transliterate(string, replacement = "?", locale: nil)
-      string = string.dup if string.frozen?
-      raise ArgumentError, "Can only transliterate strings. Received #{string.class.name}" unless string.is_a?(String)
-      raise ArgumentError, "Cannot transliterate strings with #{string.encoding} encoding" unless ALLOWED_ENCODINGS_FOR_TRANSLITERATE.include?(string.encoding)
-
-      input_encoding = string.encoding
-
-      # US-ASCII is a subset of UTF-8 so we'll force encoding as UTF-8 if
-      # US-ASCII is given. This way we can let tidy_bytes handle the string
-      # in the same way as we do for UTF-8
-      string.force_encoding(Encoding::UTF_8) if string.encoding == Encoding::US_ASCII
-
-      # GB18030 is Unicode compatible but is not a direct mapping so needs to be
-      # transcoded. Using invalid/undef :replace will result in loss of data in
-      # the event of invalid characters, but since tidy_bytes will replace
-      # invalid/undef with a "?" we're safe to do the same beforehand
-      string.encode!(Encoding::UTF_8, invalid: :replace, undef: :replace) if string.encoding == Encoding::GB18030
-
-      transliterated = I18n.transliterate(
-        ActiveSupport::Multibyte::Unicode.tidy_bytes(string).unicode_normalize(:nfc),
-        replacement: replacement,
-        locale: locale
-      )
-
-      # Restore the string encoding of the input if it was not UTF-8.
-      # Apply invalid/undef :replace as tidy_bytes does
-      transliterated.encode!(input_encoding, invalid: :replace, undef: :replace) if input_encoding != transliterated.encoding
-
-      transliterated
-    end
-
-    # Replaces special characters in a string so that it may be used as part of
-    # a 'pretty' URL.
-    #
-    #   parameterize("Donald E. Knuth") # => "donald-e-knuth"
-    #   parameterize("^très|Jolie-- ")  # => "tres-jolie"
-    #
-    # To use a custom separator, override the +separator+ argument.
-    #
-    #   parameterize("Donald E. Knuth", separator: '_') # => "donald_e_knuth"
-    #   parameterize("^très|Jolie__ ", separator: '_')  # => "tres_jolie"
-    #
-    # To preserve the case of the characters in a string, use the +preserve_case+ argument.
-    #
-    #   parameterize("Donald E. Knuth", preserve_case: true) # => "Donald-E-Knuth"
-    #   parameterize("^très|Jolie-- ", preserve_case: true) # => "tres-Jolie"
-    #
-    # It preserves dashes and underscores unless they are used as separators:
-    #
-    #   parameterize("^très|Jolie__ ")                 # => "tres-jolie__"
-    #   parameterize("^très|Jolie-- ", separator: "_") # => "tres_jolie--"
-    #   parameterize("^très_Jolie-- ", separator: ".") # => "tres_jolie--"
-    #
-    # If the optional parameter +locale+ is specified,
-    # the word will be parameterized as a word of that language.
-    # By default, this parameter is set to <tt>nil</tt> and it will use
-    # the configured <tt>I18n.locale</tt>.
-    def parameterize(string, separator: "-", preserve_case: false, locale: nil)
-      # Replace accented chars with their ASCII equivalents.
-      parameterized_string = transliterate(string, locale: locale)
-
-      # Turn unwanted chars into the separator.
-      parameterized_string.gsub!(/[^a-z0-9\-_]+/i, separator)
-
-      unless separator.nil? || separator.empty?
-        if separator == "-"
-          re_duplicate_separator        = /-{2,}/
-          re_leading_trailing_separator = /^-|-$/i
-        else
-          re_sep = Regexp.escape(separator)
-          re_duplicate_separator        = /#{re_sep}{2,}/
-          re_leading_trailing_separator = /^#{re_sep}|#{re_sep}$/i
-        end
-        # No more than one of the separator in a row.
-        parameterized_string.gsub!(re_duplicate_separator, separator)
-        # Remove leading/trailing separator.
-        parameterized_string.gsub!(re_leading_trailing_separator, "")
-      end
-
-      parameterized_string.downcase! unless preserve_case
-      parameterized_string
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/key_generator.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/key_generator.rb
deleted file mode 100644
index 21f7ab1bcb546..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/key_generator.rb
+++ /dev/null
@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "concurrent/map"
-require "openssl"
-
-module ActiveSupport
-  # KeyGenerator is a simple wrapper around OpenSSL's implementation of PBKDF2.
-  # It can be used to derive a number of keys for various purposes from a given secret.
-  # This lets Rails applications have a single secure secret, but avoid reusing that
-  # key in multiple incompatible contexts.
-  class KeyGenerator
-    def initialize(secret, options = {})
-      @secret = secret
-      # The default iterations are higher than required for our key derivation uses
-      # on the off chance someone uses this for password storage
-      @iterations = options[:iterations] || 2**16
-    end
-
-    # Returns a derived key suitable for use.  The default key_size is chosen
-    # to be compatible with the default settings of ActiveSupport::MessageVerifier.
-    # i.e. OpenSSL::Digest::SHA1#block_length
-    def generate_key(salt, key_size = 64)
-      OpenSSL::PKCS5.pbkdf2_hmac_sha1(@secret, salt, @iterations, key_size)
-    end
-  end
-
-  # CachingKeyGenerator is a wrapper around KeyGenerator which allows users to avoid
-  # re-executing the key generation process when it's called using the same salt and
-  # key_size.
-  class CachingKeyGenerator
-    def initialize(key_generator)
-      @key_generator = key_generator
-      @cache_keys = Concurrent::Map.new
-    end
-
-    # Returns a derived key suitable for use.
-    def generate_key(*args)
-      @cache_keys[args.join("|")] ||= @key_generator.generate_key(*args)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/lazy_load_hooks.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/lazy_load_hooks.rb
deleted file mode 100644
index c6f7ccf0a2802..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/lazy_load_hooks.rb
+++ /dev/null
@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  # lazy_load_hooks allows Rails to lazily load a lot of components and thus
-  # making the app boot faster. Because of this feature now there is no need to
-  # require <tt>ActiveRecord::Base</tt> at boot time purely to apply
-  # configuration. Instead a hook is registered that applies configuration once
-  # <tt>ActiveRecord::Base</tt> is loaded. Here <tt>ActiveRecord::Base</tt> is
-  # used as example but this feature can be applied elsewhere too.
-  #
-  # Here is an example where +on_load+ method is called to register a hook.
-  #
-  #   initializer 'active_record.initialize_timezone' do
-  #     ActiveSupport.on_load(:active_record) do
-  #       self.time_zone_aware_attributes = true
-  #       self.default_timezone = :utc
-  #     end
-  #   end
-  #
-  # When the entirety of +ActiveRecord::Base+ has been
-  # evaluated then +run_load_hooks+ is invoked. The very last line of
-  # +ActiveRecord::Base+ is:
-  #
-  #   ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
-  module LazyLoadHooks
-    def self.extended(base) # :nodoc:
-      base.class_eval do
-        @load_hooks = Hash.new { |h, k| h[k] = [] }
-        @loaded     = Hash.new { |h, k| h[k] = [] }
-        @run_once   = Hash.new { |h, k| h[k] = [] }
-      end
-    end
-
-    # Declares a block that will be executed when a Rails component is fully
-    # loaded.
-    #
-    # Options:
-    #
-    # * <tt>:yield</tt> - Yields the object that run_load_hooks to +block+.
-    # * <tt>:run_once</tt> - Given +block+ will run only once.
-    def on_load(name, options = {}, &block)
-      @loaded[name].each do |base|
-        execute_hook(name, base, options, block)
-      end
-
-      @load_hooks[name] << [block, options]
-    end
-
-    def run_load_hooks(name, base = Object)
-      @loaded[name] << base
-      @load_hooks[name].each do |hook, options|
-        execute_hook(name, base, options, hook)
-      end
-    end
-
-    private
-      def with_execution_control(name, block, once)
-        unless @run_once[name].include?(block)
-          @run_once[name] << block if once
-
-          yield
-        end
-      end
-
-      def execute_hook(name, base, options, block)
-        with_execution_control(name, block, options[:run_once]) do
-          if options[:yield]
-            block.call(base)
-          else
-            if base.is_a?(Module)
-              base.class_eval(&block)
-            else
-              base.instance_eval(&block)
-            end
-          end
-        end
-      end
-  end
-
-  extend LazyLoadHooks
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/locale/en.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/locale/en.rb
deleted file mode 100644
index 29eb9dec0c8c2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/locale/en.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-{
-  en: {
-    number: {
-      nth: {
-        ordinals: lambda do |_key, options|
-          number = options[:number]
-          case number
-          when 1; "st"
-          when 2; "nd"
-          when 3; "rd"
-          when 4, 5, 6, 7, 8, 9, 10, 11, 12, 13; "th"
-          else
-            num_modulo = number.to_i.abs % 100
-            num_modulo %= 10 if num_modulo > 13
-            case num_modulo
-            when 1; "st"
-            when 2; "nd"
-            when 3; "rd"
-            else    "th"
-            end
-          end
-        end,
-
-        ordinalized: lambda do |_key, options|
-          number = options[:number]
-          "#{number}#{ActiveSupport::Inflector.ordinal(number)}"
-        end
-      }
-    }
-  }
-}
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/locale/en.yml b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/locale/en.yml
deleted file mode 100644
index 725ec3532c90e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/locale/en.yml
+++ /dev/null
@@ -1,139 +0,0 @@
-en:
-  date:
-    formats:
-      # Use the strftime parameters for formats.
-      # When no format has been given, it uses default.
-      # You can provide other formats here if you like!
-      default: "%Y-%m-%d"
-      short: "%b %d"
-      long: "%B %d, %Y"
-
-    day_names: [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]
-    abbr_day_names: [Sun, Mon, Tue, Wed, Thu, Fri, Sat]
-
-    # Don't forget the nil at the beginning; there's no such thing as a 0th month
-    month_names: [~, January, February, March, April, May, June, July, August, September, October, November, December]
-    abbr_month_names: [~, Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec]
-    # Used in date_select and datetime_select.
-    order:
-      - year
-      - month
-      - day
-
-  time:
-    formats:
-      default: "%a, %d %b %Y %H:%M:%S %z"
-      short: "%d %b %H:%M"
-      long: "%B %d, %Y %H:%M"
-    am: "am"
-    pm: "pm"
-
-# Used in array.to_sentence.
-  support:
-    array:
-      words_connector: ", "
-      two_words_connector: " and "
-      last_word_connector: ", and "
-  number:
-    # Used in NumberHelper.number_to_delimited()
-    # These are also the defaults for 'currency', 'percentage', 'precision', and 'human'
-    format:
-      # Sets the separator between the units, for more precision (e.g. 1.0 / 2.0 == 0.5)
-      separator: "."
-      # Delimits thousands (e.g. 1,000,000 is a million) (always in groups of three)
-      delimiter: ","
-      # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
-      precision: 3
-      # Determine how rounding is performed (see BigDecimal::mode)
-      round_mode: default
-      # If set to true, precision will mean the number of significant digits instead
-      # of the number of decimal digits (1234 with precision 2 becomes 1200, 1.23543 becomes 1.2)
-      significant: false
-      # If set, the zeros after the decimal separator will always be stripped (e.g.: 1.200 will be 1.2)
-      strip_insignificant_zeros: false
-
-    # Used in NumberHelper.number_to_currency()
-    currency:
-      format:
-        # Where is the currency sign? %u is the currency unit, %n the number (default: $5.00)
-        format: "%u%n"
-        unit: "$"
-        # These six are to override number.format and are optional
-        separator: "."
-        delimiter: ","
-        precision: 2
-        # round_mode:
-        significant: false
-        strip_insignificant_zeros: false
-
-    # Used in NumberHelper.number_to_percentage()
-    percentage:
-      format:
-        # These five are to override number.format and are optional
-        # separator:
-        delimiter: ""
-        # precision:
-        # significant: false
-        # strip_insignificant_zeros: false
-        format: "%n%"
-
-    # Used in NumberHelper.number_to_rounded()
-    precision:
-      format:
-        # These five are to override number.format and are optional
-        # separator:
-        delimiter: ""
-        # precision:
-        # significant: false
-        # strip_insignificant_zeros: false
-
-    # Used in NumberHelper.number_to_human_size() and NumberHelper.number_to_human()
-    human:
-      format:
-        # These six are to override number.format and are optional
-        # separator:
-        delimiter: ""
-        precision: 3
-        # round_mode:
-        significant: true
-        strip_insignificant_zeros: true
-      # Used in number_to_human_size()
-      storage_units:
-        # Storage units output formatting.
-        # %u is the storage unit, %n is the number (default: 2 MB)
-        format: "%n %u"
-        units:
-          byte:
-            one:   "Byte"
-            other: "Bytes"
-          kb: "KB"
-          mb: "MB"
-          gb: "GB"
-          tb: "TB"
-          pb: "PB"
-          eb: "EB"
-      # Used in NumberHelper.number_to_human()
-      decimal_units:
-        format: "%n %u"
-        # Decimal units output formatting
-        # By default we will only quantify some of the exponents
-        # but the commented ones might be defined or overridden
-        # by the user.
-        units:
-          # femto: Quadrillionth
-          # pico: Trillionth
-          # nano: Billionth
-          # micro: Millionth
-          # mili: Thousandth
-          # centi: Hundredth
-          # deci: Tenth
-          unit: ""
-          # ten:
-          #   one: Ten
-          #   other: Tens
-          # hundred: Hundred
-          thousand: Thousand
-          million: Million
-          billion: Billion
-          trillion: Trillion
-          quadrillion: Quadrillion
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/logger.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/logger.rb
deleted file mode 100644
index 1e241c13ac9ef..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/logger.rb
+++ /dev/null
@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/logger_silence"
-require "active_support/logger_thread_safe_level"
-require "logger"
-
-module ActiveSupport
-  class Logger < ::Logger
-    include LoggerSilence
-
-    # Returns true if the logger destination matches one of the sources
-    #
-    #   logger = Logger.new(STDOUT)
-    #   ActiveSupport::Logger.logger_outputs_to?(logger, STDOUT)
-    #   # => true
-    def self.logger_outputs_to?(logger, *sources)
-      logdev = logger.instance_variable_get(:@logdev)
-      logger_source = logdev.dev if logdev.respond_to?(:dev)
-      sources.any? { |source| source == logger_source }
-    end
-
-    # Broadcasts logs to multiple loggers.
-    def self.broadcast(logger) # :nodoc:
-      Module.new do
-        define_method(:add) do |*args, &block|
-          logger.add(*args, &block)
-          super(*args, &block)
-        end
-
-        define_method(:<<) do |x|
-          logger << x
-          super(x)
-        end
-
-        define_method(:close) do
-          logger.close
-          super()
-        end
-
-        define_method(:progname=) do |name|
-          logger.progname = name
-          super(name)
-        end
-
-        define_method(:formatter=) do |formatter|
-          logger.formatter = formatter
-          super(formatter)
-        end
-
-        define_method(:level=) do |level|
-          logger.level = level
-          super(level)
-        end
-
-        define_method(:local_level=) do |level|
-          logger.local_level = level if logger.respond_to?(:local_level=)
-          super(level) if respond_to?(:local_level=)
-        end
-
-        define_method(:silence) do |level = Logger::ERROR, &block|
-          if logger.respond_to?(:silence)
-            logger.silence(level) do
-              if defined?(super)
-                super(level, &block)
-              else
-                block.call(self)
-              end
-            end
-          else
-            if defined?(super)
-              super(level, &block)
-            else
-              block.call(self)
-            end
-          end
-        end
-      end
-    end
-
-    def initialize(*args, **kwargs)
-      super
-      @formatter = SimpleFormatter.new
-    end
-
-    # Simple formatter which only displays the message.
-    class SimpleFormatter < ::Logger::Formatter
-      # This method is invoked when a log event occurs
-      def call(severity, timestamp, progname, msg)
-        "#{String === msg ? msg : msg.inspect}\n"
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/logger_silence.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/logger_silence.rb
deleted file mode 100644
index 8567eff403fd6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/logger_silence.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-require "active_support/core_ext/module/attribute_accessors"
-require "active_support/logger_thread_safe_level"
-
-module ActiveSupport
-  module LoggerSilence
-    extend ActiveSupport::Concern
-
-    included do
-      cattr_accessor :silencer, default: true
-      include ActiveSupport::LoggerThreadSafeLevel
-    end
-
-    # Silences the logger for the duration of the block.
-    def silence(severity = Logger::ERROR)
-      silencer ? log_at(severity) { yield self } : yield(self)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/logger_thread_safe_level.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/logger_thread_safe_level.rb
deleted file mode 100644
index 1de9ecdbbc3c3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/logger_thread_safe_level.rb
+++ /dev/null
@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-require "active_support/core_ext/module/attribute_accessors"
-require "concurrent"
-require "fiber"
-
-module ActiveSupport
-  module LoggerThreadSafeLevel # :nodoc:
-    extend ActiveSupport::Concern
-
-    included do
-      cattr_accessor :local_levels, default: Concurrent::Map.new(initial_capacity: 2), instance_accessor: false
-    end
-
-    Logger::Severity.constants.each do |severity|
-      class_eval(<<-EOT, __FILE__, __LINE__ + 1)
-        def #{severity.downcase}?                # def debug?
-          Logger::#{severity} >= level           #   DEBUG >= level
-        end                                      # end
-      EOT
-    end
-
-    def local_log_id
-      Fiber.current.__id__
-    end
-
-    def local_level
-      self.class.local_levels[local_log_id]
-    end
-
-    def local_level=(level)
-      case level
-      when Integer
-        self.class.local_levels[local_log_id] = level
-      when Symbol
-        self.class.local_levels[local_log_id] = Logger::Severity.const_get(level.to_s.upcase)
-      when nil
-        self.class.local_levels.delete(local_log_id)
-      else
-        raise ArgumentError, "Invalid log level: #{level.inspect}"
-      end
-    end
-
-    def level
-      local_level || super
-    end
-
-    # Change the thread-local level for the duration of the given block.
-    def log_at(level)
-      old_local_level, self.local_level = local_level, level
-      yield
-    ensure
-      self.local_level = old_local_level
-    end
-
-    # Redefined to check severity against #level, and thus the thread-local level, rather than +@level+.
-    # FIXME: Remove when the minimum Ruby version supports overriding Logger#level.
-    def add(severity, message = nil, progname = nil, &block) #:nodoc:
-      severity ||= UNKNOWN
-      progname ||= @progname
-
-      return true if @logdev.nil? || severity < level
-
-      if message.nil?
-        if block_given?
-          message  = yield
-        else
-          message  = progname
-          progname = @progname
-        end
-      end
-
-      @logdev.write \
-        format_message(format_severity(severity), Time.now, progname, message)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/message_encryptor.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/message_encryptor.rb
deleted file mode 100644
index 4cf4a444266ad..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/message_encryptor.rb
+++ /dev/null
@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-require "openssl"
-require "base64"
-require "active_support/core_ext/module/attribute_accessors"
-require "active_support/message_verifier"
-require "active_support/messages/metadata"
-
-module ActiveSupport
-  # MessageEncryptor is a simple way to encrypt values which get stored
-  # somewhere you don't trust.
-  #
-  # The cipher text and initialization vector are base64 encoded and returned
-  # to you.
-  #
-  # This can be used in situations similar to the <tt>MessageVerifier</tt>, but
-  # where you don't want users to be able to determine the value of the payload.
-  #
-  #   len   = ActiveSupport::MessageEncryptor.key_len
-  #   salt  = SecureRandom.random_bytes(len)
-  #   key   = ActiveSupport::KeyGenerator.new('password').generate_key(salt, len) # => "\x89\xE0\x156\xAC..."
-  #   crypt = ActiveSupport::MessageEncryptor.new(key)                            # => #<ActiveSupport::MessageEncryptor ...>
-  #   encrypted_data = crypt.encrypt_and_sign('my secret data')                   # => "NlFBTTMwOUV5UlA1QlNEN2xkY2d6eThYWWh..."
-  #   crypt.decrypt_and_verify(encrypted_data)                                    # => "my secret data"
-  #
-  # === Confining messages to a specific purpose
-  #
-  # By default any message can be used throughout your app. But they can also be
-  # confined to a specific +:purpose+.
-  #
-  #   token = crypt.encrypt_and_sign("this is the chair", purpose: :login)
-  #
-  # Then that same purpose must be passed when verifying to get the data back out:
-  #
-  #   crypt.decrypt_and_verify(token, purpose: :login)    # => "this is the chair"
-  #   crypt.decrypt_and_verify(token, purpose: :shipping) # => nil
-  #   crypt.decrypt_and_verify(token)                     # => nil
-  #
-  # Likewise, if a message has no purpose it won't be returned when verifying with
-  # a specific purpose.
-  #
-  #   token = crypt.encrypt_and_sign("the conversation is lively")
-  #   crypt.decrypt_and_verify(token, purpose: :scare_tactics) # => nil
-  #   crypt.decrypt_and_verify(token)                          # => "the conversation is lively"
-  #
-  # === Making messages expire
-  #
-  # By default messages last forever and verifying one year from now will still
-  # return the original value. But messages can be set to expire at a given
-  # time with +:expires_in+ or +:expires_at+.
-  #
-  #   crypt.encrypt_and_sign(parcel, expires_in: 1.month)
-  #   crypt.encrypt_and_sign(doowad, expires_at: Time.now.end_of_year)
-  #
-  # Then the messages can be verified and returned up to the expire time.
-  # Thereafter, verifying returns +nil+.
-  #
-  # === Rotating keys
-  #
-  # MessageEncryptor also supports rotating out old configurations by falling
-  # back to a stack of encryptors. Call +rotate+ to build and add an encryptor
-  # so +decrypt_and_verify+ will also try the fallback.
-  #
-  # By default any rotated encryptors use the values of the primary
-  # encryptor unless specified otherwise.
-  #
-  # You'd give your encryptor the new defaults:
-  #
-  #   crypt = ActiveSupport::MessageEncryptor.new(@secret, cipher: "aes-256-gcm")
-  #
-  # Then gradually rotate the old values out by adding them as fallbacks. Any message
-  # generated with the old values will then work until the rotation is removed.
-  #
-  #   crypt.rotate old_secret            # Fallback to an old secret instead of @secret.
-  #   crypt.rotate cipher: "aes-256-cbc" # Fallback to an old cipher instead of aes-256-gcm.
-  #
-  # Though if both the secret and the cipher was changed at the same time,
-  # the above should be combined into:
-  #
-  #   crypt.rotate old_secret, cipher: "aes-256-cbc"
-  class MessageEncryptor
-    prepend Messages::Rotator::Encryptor
-
-    cattr_accessor :use_authenticated_message_encryption, instance_accessor: false, default: false
-
-    class << self
-      def default_cipher #:nodoc:
-        if use_authenticated_message_encryption
-          "aes-256-gcm"
-        else
-          "aes-256-cbc"
-        end
-      end
-    end
-
-    module NullSerializer #:nodoc:
-      def self.load(value)
-        value
-      end
-
-      def self.dump(value)
-        value
-      end
-    end
-
-    module NullVerifier #:nodoc:
-      def self.verify(value)
-        value
-      end
-
-      def self.generate(value)
-        value
-      end
-    end
-
-    class InvalidMessage < StandardError; end
-    OpenSSLCipherError = OpenSSL::Cipher::CipherError
-
-    # Initialize a new MessageEncryptor. +secret+ must be at least as long as
-    # the cipher key size. For the default 'aes-256-gcm' cipher, this is 256
-    # bits. If you are using a user-entered secret, you can generate a suitable
-    # key by using <tt>ActiveSupport::KeyGenerator</tt> or a similar key
-    # derivation function.
-    #
-    # First additional parameter is used as the signature key for +MessageVerifier+.
-    # This allows you to specify keys to encrypt and sign data.
-    #
-    #    ActiveSupport::MessageEncryptor.new('secret', 'signature_secret')
-    #
-    # Options:
-    # * <tt>:cipher</tt>     - Cipher to use. Can be any cipher returned by
-    #   <tt>OpenSSL::Cipher.ciphers</tt>. Default is 'aes-256-gcm'.
-    # * <tt>:digest</tt> - String of digest to use for signing. Default is
-    #   +SHA1+. Ignored when using an AEAD cipher like 'aes-256-gcm'.
-    # * <tt>:serializer</tt> - Object serializer to use. Default is +Marshal+.
-    def initialize(secret, sign_secret = nil, cipher: nil, digest: nil, serializer: nil)
-      @secret = secret
-      @sign_secret = sign_secret
-      @cipher = cipher || self.class.default_cipher
-      @digest = digest || "SHA1" unless aead_mode?
-      @verifier = resolve_verifier
-      @serializer = serializer || Marshal
-    end
-
-    # Encrypt and sign a message. We need to sign the message in order to avoid
-    # padding attacks. Reference: https://www.limited-entropy.com/padding-oracle-attacks/.
-    def encrypt_and_sign(value, expires_at: nil, expires_in: nil, purpose: nil)
-      verifier.generate(_encrypt(value, expires_at: expires_at, expires_in: expires_in, purpose: purpose))
-    end
-
-    # Decrypt and verify a message. We need to verify the message in order to
-    # avoid padding attacks. Reference: https://www.limited-entropy.com/padding-oracle-attacks/.
-    def decrypt_and_verify(data, purpose: nil, **)
-      _decrypt(verifier.verify(data), purpose)
-    end
-
-    # Given a cipher, returns the key length of the cipher to help generate the key of desired size
-    def self.key_len(cipher = default_cipher)
-      OpenSSL::Cipher.new(cipher).key_len
-    end
-
-    private
-      def _encrypt(value, **metadata_options)
-        cipher = new_cipher
-        cipher.encrypt
-        cipher.key = @secret
-
-        # Rely on OpenSSL for the initialization vector
-        iv = cipher.random_iv
-        cipher.auth_data = "" if aead_mode?
-
-        encrypted_data = cipher.update(Messages::Metadata.wrap(@serializer.dump(value), **metadata_options))
-        encrypted_data << cipher.final
-
-        blob = "#{::Base64.strict_encode64 encrypted_data}--#{::Base64.strict_encode64 iv}"
-        blob = "#{blob}--#{::Base64.strict_encode64 cipher.auth_tag}" if aead_mode?
-        blob
-      end
-
-      def _decrypt(encrypted_message, purpose)
-        cipher = new_cipher
-        encrypted_data, iv, auth_tag = encrypted_message.split("--").map { |v| ::Base64.strict_decode64(v) }
-
-        # Currently the OpenSSL bindings do not raise an error if auth_tag is
-        # truncated, which would allow an attacker to easily forge it. See
-        # https://github.com/ruby/openssl/issues/63
-        raise InvalidMessage if aead_mode? && (auth_tag.nil? || auth_tag.bytes.length != 16)
-
-        cipher.decrypt
-        cipher.key = @secret
-        cipher.iv  = iv
-        if aead_mode?
-          cipher.auth_tag = auth_tag
-          cipher.auth_data = ""
-        end
-
-        decrypted_data = cipher.update(encrypted_data)
-        decrypted_data << cipher.final
-
-        message = Messages::Metadata.verify(decrypted_data, purpose)
-        @serializer.load(message) if message
-      rescue OpenSSLCipherError, TypeError, ArgumentError
-        raise InvalidMessage
-      end
-
-      def new_cipher
-        OpenSSL::Cipher.new(@cipher)
-      end
-
-      attr_reader :verifier
-
-      def aead_mode?
-        @aead_mode ||= new_cipher.authenticated?
-      end
-
-      def resolve_verifier
-        if aead_mode?
-          NullVerifier
-        else
-          MessageVerifier.new(@sign_secret || @secret, digest: @digest, serializer: NullSerializer)
-        end
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/message_verifier.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/message_verifier.rb
deleted file mode 100644
index ba992a17a15a5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/message_verifier.rb
+++ /dev/null
@@ -1,205 +0,0 @@
-# frozen_string_literal: true
-
-require "base64"
-require "active_support/core_ext/object/blank"
-require "active_support/security_utils"
-require "active_support/messages/metadata"
-require "active_support/messages/rotator"
-
-module ActiveSupport
-  # +MessageVerifier+ makes it easy to generate and verify messages which are
-  # signed to prevent tampering.
-  #
-  # This is useful for cases like remember-me tokens and auto-unsubscribe links
-  # where the session store isn't suitable or available.
-  #
-  # Remember Me:
-  #   cookies[:remember_me] = @verifier.generate([@user.id, 2.weeks.from_now])
-  #
-  # In the authentication filter:
-  #
-  #   id, time = @verifier.verify(cookies[:remember_me])
-  #   if Time.now < time
-  #     self.current_user = User.find(id)
-  #   end
-  #
-  # By default it uses Marshal to serialize the message. If you want to use
-  # another serialization method, you can set the serializer in the options
-  # hash upon initialization:
-  #
-  #   @verifier = ActiveSupport::MessageVerifier.new('s3Krit', serializer: YAML)
-  #
-  # +MessageVerifier+ creates HMAC signatures using SHA1 hash algorithm by default.
-  # If you want to use a different hash algorithm, you can change it by providing
-  # +:digest+ key as an option while initializing the verifier:
-  #
-  #   @verifier = ActiveSupport::MessageVerifier.new('s3Krit', digest: 'SHA256')
-  #
-  # === Confining messages to a specific purpose
-  #
-  # By default any message can be used throughout your app. But they can also be
-  # confined to a specific +:purpose+.
-  #
-  #   token = @verifier.generate("this is the chair", purpose: :login)
-  #
-  # Then that same purpose must be passed when verifying to get the data back out:
-  #
-  #   @verifier.verified(token, purpose: :login)    # => "this is the chair"
-  #   @verifier.verified(token, purpose: :shipping) # => nil
-  #   @verifier.verified(token)                     # => nil
-  #
-  #   @verifier.verify(token, purpose: :login)      # => "this is the chair"
-  #   @verifier.verify(token, purpose: :shipping)   # => ActiveSupport::MessageVerifier::InvalidSignature
-  #   @verifier.verify(token)                       # => ActiveSupport::MessageVerifier::InvalidSignature
-  #
-  # Likewise, if a message has no purpose it won't be returned when verifying with
-  # a specific purpose.
-  #
-  #   token = @verifier.generate("the conversation is lively")
-  #   @verifier.verified(token, purpose: :scare_tactics) # => nil
-  #   @verifier.verified(token)                          # => "the conversation is lively"
-  #
-  #   @verifier.verify(token, purpose: :scare_tactics)   # => ActiveSupport::MessageVerifier::InvalidSignature
-  #   @verifier.verify(token)                            # => "the conversation is lively"
-  #
-  # === Making messages expire
-  #
-  # By default messages last forever and verifying one year from now will still
-  # return the original value. But messages can be set to expire at a given
-  # time with +:expires_in+ or +:expires_at+.
-  #
-  #   @verifier.generate(parcel, expires_in: 1.month)
-  #   @verifier.generate(doowad, expires_at: Time.now.end_of_year)
-  #
-  # Then the messages can be verified and returned up to the expire time.
-  # Thereafter, the +verified+ method returns +nil+ while +verify+ raises
-  # <tt>ActiveSupport::MessageVerifier::InvalidSignature</tt>.
-  #
-  # === Rotating keys
-  #
-  # MessageVerifier also supports rotating out old configurations by falling
-  # back to a stack of verifiers. Call +rotate+ to build and add a verifier to
-  # so either +verified+ or +verify+ will also try verifying with the fallback.
-  #
-  # By default any rotated verifiers use the values of the primary
-  # verifier unless specified otherwise.
-  #
-  # You'd give your verifier the new defaults:
-  #
-  #   verifier = ActiveSupport::MessageVerifier.new(@secret, digest: "SHA512", serializer: JSON)
-  #
-  # Then gradually rotate the old values out by adding them as fallbacks. Any message
-  # generated with the old values will then work until the rotation is removed.
-  #
-  #   verifier.rotate old_secret          # Fallback to an old secret instead of @secret.
-  #   verifier.rotate digest: "SHA256"    # Fallback to an old digest instead of SHA512.
-  #   verifier.rotate serializer: Marshal # Fallback to an old serializer instead of JSON.
-  #
-  # Though the above would most likely be combined into one rotation:
-  #
-  #   verifier.rotate old_secret, digest: "SHA256", serializer: Marshal
-  class MessageVerifier
-    prepend Messages::Rotator::Verifier
-
-    class InvalidSignature < StandardError; end
-
-    def initialize(secret, digest: nil, serializer: nil)
-      raise ArgumentError, "Secret should not be nil." unless secret
-      @secret = secret
-      @digest = digest || "SHA1"
-      @serializer = serializer || Marshal
-    end
-
-    # Checks if a signed message could have been generated by signing an object
-    # with the +MessageVerifier+'s secret.
-    #
-    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
-    #   signed_message = verifier.generate 'a private message'
-    #   verifier.valid_message?(signed_message) # => true
-    #
-    #   tampered_message = signed_message.chop # editing the message invalidates the signature
-    #   verifier.valid_message?(tampered_message) # => false
-    def valid_message?(signed_message)
-      return if signed_message.nil? || !signed_message.valid_encoding? || signed_message.blank?
-
-      data, digest = signed_message.split("--")
-      data.present? && digest.present? && ActiveSupport::SecurityUtils.secure_compare(digest, generate_digest(data))
-    end
-
-    # Decodes the signed message using the +MessageVerifier+'s secret.
-    #
-    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
-    #
-    #   signed_message = verifier.generate 'a private message'
-    #   verifier.verified(signed_message) # => 'a private message'
-    #
-    # Returns +nil+ if the message was not signed with the same secret.
-    #
-    #   other_verifier = ActiveSupport::MessageVerifier.new 'd1ff3r3nt-s3Krit'
-    #   other_verifier.verified(signed_message) # => nil
-    #
-    # Returns +nil+ if the message is not Base64-encoded.
-    #
-    #   invalid_message = "f--46a0120593880c733a53b6dad75b42ddc1c8996d"
-    #   verifier.verified(invalid_message) # => nil
-    #
-    # Raises any error raised while decoding the signed message.
-    #
-    #   incompatible_message = "test--dad7b06c94abba8d46a15fafaef56c327665d5ff"
-    #   verifier.verified(incompatible_message) # => TypeError: incompatible marshal file format
-    def verified(signed_message, purpose: nil, **)
-      if valid_message?(signed_message)
-        begin
-          data = signed_message.split("--")[0]
-          message = Messages::Metadata.verify(decode(data), purpose)
-          @serializer.load(message) if message
-        rescue ArgumentError => argument_error
-          return if argument_error.message.include?("invalid base64")
-          raise
-        end
-      end
-    end
-
-    # Decodes the signed message using the +MessageVerifier+'s secret.
-    #
-    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
-    #   signed_message = verifier.generate 'a private message'
-    #
-    #   verifier.verify(signed_message) # => 'a private message'
-    #
-    # Raises +InvalidSignature+ if the message was not signed with the same
-    # secret or was not Base64-encoded.
-    #
-    #   other_verifier = ActiveSupport::MessageVerifier.new 'd1ff3r3nt-s3Krit'
-    #   other_verifier.verify(signed_message) # => ActiveSupport::MessageVerifier::InvalidSignature
-    def verify(*args, **options)
-      verified(*args, **options) || raise(InvalidSignature)
-    end
-
-    # Generates a signed message for the provided value.
-    #
-    # The message is signed with the +MessageVerifier+'s secret.
-    # Returns Base64-encoded message joined with the generated signature.
-    #
-    #   verifier = ActiveSupport::MessageVerifier.new 's3Krit'
-    #   verifier.generate 'a private message' # => "BAhJIhRwcml2YXRlLW1lc3NhZ2UGOgZFVA==--e2d724331ebdee96a10fb99b089508d1c72bd772"
-    def generate(value, expires_at: nil, expires_in: nil, purpose: nil)
-      data = encode(Messages::Metadata.wrap(@serializer.dump(value), expires_at: expires_at, expires_in: expires_in, purpose: purpose))
-      "#{data}--#{generate_digest(data)}"
-    end
-
-    private
-      def encode(data)
-        ::Base64.strict_encode64(data)
-      end
-
-      def decode(data)
-        ::Base64.strict_decode64(data)
-      end
-
-      def generate_digest(data)
-        require "openssl" unless defined?(OpenSSL)
-        OpenSSL::HMAC.hexdigest(OpenSSL::Digest.const_get(@digest).new, @secret, data)
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/multibyte.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/multibyte.rb
deleted file mode 100644
index 3fe3a05e93e5e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/multibyte.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport #:nodoc:
-  module Multibyte
-    autoload :Chars, "active_support/multibyte/chars"
-    autoload :Unicode, "active_support/multibyte/unicode"
-
-    # The proxy class returned when calling mb_chars. You can use this accessor
-    # to configure your own proxy class so you can support other encodings. See
-    # the ActiveSupport::Multibyte::Chars implementation for an example how to
-    # do this.
-    #
-    #   ActiveSupport::Multibyte.proxy_class = CharsForUTF32
-    def self.proxy_class=(klass)
-      @proxy_class = klass
-    end
-
-    # Returns the current proxy class.
-    def self.proxy_class
-      @proxy_class ||= ActiveSupport::Multibyte::Chars
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/notifications.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/notifications.rb
deleted file mode 100644
index d1227c2473ba9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/notifications.rb
+++ /dev/null
@@ -1,280 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/notifications/instrumenter"
-require "active_support/notifications/fanout"
-require "active_support/per_thread_registry"
-
-module ActiveSupport
-  # = Notifications
-  #
-  # <tt>ActiveSupport::Notifications</tt> provides an instrumentation API for
-  # Ruby.
-  #
-  # == Instrumenters
-  #
-  # To instrument an event you just need to do:
-  #
-  #   ActiveSupport::Notifications.instrument('render', extra: :information) do
-  #     render plain: 'Foo'
-  #   end
-  #
-  # That first executes the block and then notifies all subscribers once done.
-  #
-  # In the example above +render+ is the name of the event, and the rest is called
-  # the _payload_. The payload is a mechanism that allows instrumenters to pass
-  # extra information to subscribers. Payloads consist of a hash whose contents
-  # are arbitrary and generally depend on the event.
-  #
-  # == Subscribers
-  #
-  # You can consume those events and the information they provide by registering
-  # a subscriber.
-  #
-  #   ActiveSupport::Notifications.subscribe('render') do |name, start, finish, id, payload|
-  #     name    # => String, name of the event (such as 'render' from above)
-  #     start   # => Time, when the instrumented block started execution
-  #     finish  # => Time, when the instrumented block ended execution
-  #     id      # => String, unique ID for the instrumenter that fired the event
-  #     payload # => Hash, the payload
-  #   end
-  #
-  # Here, the +start+ and +finish+ values represent wall-clock time. If you are
-  # concerned about accuracy, you can register a monotonic subscriber.
-  #
-  #   ActiveSupport::Notifications.monotonic_subscribe('render') do |name, start, finish, id, payload|
-  #     name    # => String, name of the event (such as 'render' from above)
-  #     start   # => Monotonic time, when the instrumented block started execution
-  #     finish  # => Monotonic time, when the instrumented block ended execution
-  #     id      # => String, unique ID for the instrumenter that fired the event
-  #     payload # => Hash, the payload
-  #   end
-  #
-  # The +start+ and +finish+ values above represent monotonic time.
-  #
-  # For instance, let's store all "render" events in an array:
-  #
-  #   events = []
-  #
-  #   ActiveSupport::Notifications.subscribe('render') do |*args|
-  #     events << ActiveSupport::Notifications::Event.new(*args)
-  #   end
-  #
-  # That code returns right away, you are just subscribing to "render" events.
-  # The block is saved and will be called whenever someone instruments "render":
-  #
-  #   ActiveSupport::Notifications.instrument('render', extra: :information) do
-  #     render plain: 'Foo'
-  #   end
-  #
-  #   event = events.first
-  #   event.name      # => "render"
-  #   event.duration  # => 10 (in milliseconds)
-  #   event.payload   # => { extra: :information }
-  #
-  # The block in the <tt>subscribe</tt> call gets the name of the event, start
-  # timestamp, end timestamp, a string with a unique identifier for that event's instrumenter
-  # (something like "535801666f04d0298cd6"), and a hash with the payload, in
-  # that order.
-  #
-  # If an exception happens during that particular instrumentation the payload will
-  # have a key <tt>:exception</tt> with an array of two elements as value: a string with
-  # the name of the exception class, and the exception message.
-  # The <tt>:exception_object</tt> key of the payload will have the exception
-  # itself as the value:
-  #
-  #   event.payload[:exception]         # => ["ArgumentError", "Invalid value"]
-  #   event.payload[:exception_object]  # => #<ArgumentError: Invalid value>
-  #
-  # As the earlier example depicts, the class <tt>ActiveSupport::Notifications::Event</tt>
-  # is able to take the arguments as they come and provide an object-oriented
-  # interface to that data.
-  #
-  # It is also possible to pass an object which responds to <tt>call</tt> method
-  # as the second parameter to the <tt>subscribe</tt> method instead of a block:
-  #
-  #   module ActionController
-  #     class PageRequest
-  #       def call(name, started, finished, unique_id, payload)
-  #         Rails.logger.debug ['notification:', name, started, finished, unique_id, payload].join(' ')
-  #       end
-  #     end
-  #   end
-  #
-  #   ActiveSupport::Notifications.subscribe('process_action.action_controller', ActionController::PageRequest.new)
-  #
-  # resulting in the following output within the logs including a hash with the payload:
-  #
-  #   notification: process_action.action_controller 2012-04-13 01:08:35 +0300 2012-04-13 01:08:35 +0300 af358ed7fab884532ec7 {
-  #      controller: "Devise::SessionsController",
-  #      action: "new",
-  #      params: {"action"=>"new", "controller"=>"devise/sessions"},
-  #      format: :html,
-  #      method: "GET",
-  #      path: "/login/sign_in",
-  #      status: 200,
-  #      view_runtime: 279.3080806732178,
-  #      db_runtime: 40.053
-  #    }
-  #
-  # You can also subscribe to all events whose name matches a certain regexp:
-  #
-  #   ActiveSupport::Notifications.subscribe(/render/) do |*args|
-  #     ...
-  #   end
-  #
-  # and even pass no argument to <tt>subscribe</tt>, in which case you are subscribing
-  # to all events.
-  #
-  # == Temporary Subscriptions
-  #
-  # Sometimes you do not want to subscribe to an event for the entire life of
-  # the application. There are two ways to unsubscribe.
-  #
-  # WARNING: The instrumentation framework is designed for long-running subscribers,
-  # use this feature sparingly because it wipes some internal caches and that has
-  # a negative impact on performance.
-  #
-  # === Subscribe While a Block Runs
-  #
-  # You can subscribe to some event temporarily while some block runs. For
-  # example, in
-  #
-  #   callback = lambda {|*args| ... }
-  #   ActiveSupport::Notifications.subscribed(callback, "sql.active_record") do
-  #     ...
-  #   end
-  #
-  # the callback will be called for all "sql.active_record" events instrumented
-  # during the execution of the block. The callback is unsubscribed automatically
-  # after that.
-  #
-  # To record +started+ and +finished+ values with monotonic time,
-  # specify the optional <tt>:monotonic</tt> option to the
-  # <tt>subscribed</tt> method. The <tt>:monotonic</tt> option is set
-  # to +false+ by default.
-  #
-  #   callback = lambda {|name, started, finished, unique_id, payload| ... }
-  #   ActiveSupport::Notifications.subscribed(callback, "sql.active_record", monotonic: true) do
-  #     ...
-  #   end
-  #
-  # === Manual Unsubscription
-  #
-  # The +subscribe+ method returns a subscriber object:
-  #
-  #   subscriber = ActiveSupport::Notifications.subscribe("render") do |*args|
-  #     ...
-  #   end
-  #
-  # To prevent that block from being called anymore, just unsubscribe passing
-  # that reference:
-  #
-  #   ActiveSupport::Notifications.unsubscribe(subscriber)
-  #
-  # You can also unsubscribe by passing the name of the subscriber object. Note
-  # that this will unsubscribe all subscriptions with the given name:
-  #
-  #   ActiveSupport::Notifications.unsubscribe("render")
-  #
-  # Subscribers using a regexp or other pattern-matching object will remain subscribed
-  # to all events that match their original pattern, unless those events match a string
-  # passed to +unsubscribe+:
-  #
-  #   subscriber = ActiveSupport::Notifications.subscribe(/render/) { }
-  #   ActiveSupport::Notifications.unsubscribe('render_template.action_view')
-  #   subscriber.matches?('render_template.action_view') # => false
-  #   subscriber.matches?('render_partial.action_view') # => true
-  #
-  # == Default Queue
-  #
-  # Notifications ships with a queue implementation that consumes and publishes events
-  # to all log subscribers. You can use any queue implementation you want.
-  #
-  module Notifications
-    class << self
-      attr_accessor :notifier
-
-      def publish(name, *args)
-        notifier.publish(name, *args)
-      end
-
-      def instrument(name, payload = {})
-        if notifier.listening?(name)
-          instrumenter.instrument(name, payload) { yield payload if block_given? }
-        else
-          yield payload if block_given?
-        end
-      end
-
-      # Subscribe to a given event name with the passed +block+.
-      #
-      # You can subscribe to events by passing a String to match exact event
-      # names, or by passing a Regexp to match all events that match a pattern.
-      #
-      #   ActiveSupport::Notifications.subscribe(/render/) do |*args|
-      #     @event = ActiveSupport::Notifications::Event.new(*args)
-      #   end
-      #
-      # The +block+ will receive five parameters with information about the event:
-      #
-      #   ActiveSupport::Notifications.subscribe('render') do |name, start, finish, id, payload|
-      #     name    # => String, name of the event (such as 'render' from above)
-      #     start   # => Time, when the instrumented block started execution
-      #     finish  # => Time, when the instrumented block ended execution
-      #     id      # => String, unique ID for the instrumenter that fired the event
-      #     payload # => Hash, the payload
-      #   end
-      #
-      # If the block passed to the method only takes one parameter,
-      # it will yield an event object to the block:
-      #
-      #   ActiveSupport::Notifications.subscribe(/render/) do |event|
-      #     @event = event
-      #   end
-      def subscribe(pattern = nil, callback = nil, &block)
-        notifier.subscribe(pattern, callback, monotonic: false, &block)
-      end
-
-      def monotonic_subscribe(pattern = nil, callback = nil, &block)
-        notifier.subscribe(pattern, callback, monotonic: true, &block)
-      end
-
-      def subscribed(callback, pattern = nil, monotonic: false, &block)
-        subscriber = notifier.subscribe(pattern, callback, monotonic: monotonic)
-        yield
-      ensure
-        unsubscribe(subscriber)
-      end
-
-      def unsubscribe(subscriber_or_name)
-        notifier.unsubscribe(subscriber_or_name)
-      end
-
-      def instrumenter
-        InstrumentationRegistry.instance.instrumenter_for(notifier)
-      end
-    end
-
-    # This class is a registry which holds all of the +Instrumenter+ objects
-    # in a particular thread local. To access the +Instrumenter+ object for a
-    # particular +notifier+, you can call the following method:
-    #
-    #   InstrumentationRegistry.instrumenter_for(notifier)
-    #
-    # The instrumenters for multiple notifiers are held in a single instance of
-    # this class.
-    class InstrumentationRegistry # :nodoc:
-      extend ActiveSupport::PerThreadRegistry
-
-      def initialize
-        @registry = {}
-      end
-
-      def instrumenter_for(notifier)
-        @registry[notifier] ||= Instrumenter.new(notifier)
-      end
-    end
-
-    self.notifier = Fanout.new
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/notifications/fanout.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/notifications/fanout.rb
deleted file mode 100644
index 5fba8347d9c25..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/notifications/fanout.rb
+++ /dev/null
@@ -1,259 +0,0 @@
-# frozen_string_literal: true
-
-require "mutex_m"
-require "concurrent/map"
-require "set"
-require "active_support/core_ext/object/try"
-
-module ActiveSupport
-  module Notifications
-    # This is a default queue implementation that ships with Notifications.
-    # It just pushes events to all registered log subscribers.
-    #
-    # This class is thread safe. All methods are reentrant.
-    class Fanout
-      include Mutex_m
-
-      def initialize
-        @string_subscribers = Hash.new { |h, k| h[k] = [] }
-        @other_subscribers = []
-        @listeners_for = Concurrent::Map.new
-        super
-      end
-
-      def subscribe(pattern = nil, callable = nil, monotonic: false, &block)
-        subscriber = Subscribers.new(pattern, callable || block, monotonic)
-        synchronize do
-          if String === pattern
-            @string_subscribers[pattern] << subscriber
-            @listeners_for.delete(pattern)
-          else
-            @other_subscribers << subscriber
-            @listeners_for.clear
-          end
-        end
-        subscriber
-      end
-
-      def unsubscribe(subscriber_or_name)
-        synchronize do
-          case subscriber_or_name
-          when String
-            @string_subscribers[subscriber_or_name].clear
-            @listeners_for.delete(subscriber_or_name)
-            @other_subscribers.each { |sub| sub.unsubscribe!(subscriber_or_name) }
-          else
-            pattern = subscriber_or_name.try(:pattern)
-            if String === pattern
-              @string_subscribers[pattern].delete(subscriber_or_name)
-              @listeners_for.delete(pattern)
-            else
-              @other_subscribers.delete(subscriber_or_name)
-              @listeners_for.clear
-            end
-          end
-        end
-      end
-
-      def start(name, id, payload)
-        listeners_for(name).each { |s| s.start(name, id, payload) }
-      end
-
-      def finish(name, id, payload, listeners = listeners_for(name))
-        listeners.each { |s| s.finish(name, id, payload) }
-      end
-
-      def publish(name, *args)
-        listeners_for(name).each { |s| s.publish(name, *args) }
-      end
-
-      def listeners_for(name)
-        # this is correctly done double-checked locking (Concurrent::Map's lookups have volatile semantics)
-        @listeners_for[name] || synchronize do
-          # use synchronisation when accessing @subscribers
-          @listeners_for[name] ||=
-            @string_subscribers[name] + @other_subscribers.select { |s| s.subscribed_to?(name) }
-        end
-      end
-
-      def listening?(name)
-        listeners_for(name).any?
-      end
-
-      # This is a sync queue, so there is no waiting.
-      def wait
-      end
-
-      module Subscribers # :nodoc:
-        def self.new(pattern, listener, monotonic)
-          subscriber_class = monotonic ? MonotonicTimed : Timed
-
-          if listener.respond_to?(:start) && listener.respond_to?(:finish)
-            subscriber_class = Evented
-          else
-            # Doing all this to detect a block like `proc { |x| }` vs
-            # `proc { |*x| }` or `proc { |**x| }`
-            if listener.respond_to?(:parameters)
-              params = listener.parameters
-              if params.length == 1 && params.first.first == :opt
-                subscriber_class = EventObject
-              end
-            end
-          end
-
-          wrap_all pattern, subscriber_class.new(pattern, listener)
-        end
-
-        def self.wrap_all(pattern, subscriber)
-          unless pattern
-            AllMessages.new(subscriber)
-          else
-            subscriber
-          end
-        end
-
-        class Matcher #:nodoc:
-          attr_reader :pattern, :exclusions
-
-          def self.wrap(pattern)
-            return pattern if String === pattern
-            new(pattern)
-          end
-
-          def initialize(pattern)
-            @pattern = pattern
-            @exclusions = Set.new
-          end
-
-          def unsubscribe!(name)
-            exclusions << -name if pattern === name
-          end
-
-          def ===(name)
-            pattern === name && !exclusions.include?(name)
-          end
-        end
-
-        class Evented #:nodoc:
-          attr_reader :pattern
-
-          def initialize(pattern, delegate)
-            @pattern = Matcher.wrap(pattern)
-            @delegate = delegate
-            @can_publish = delegate.respond_to?(:publish)
-          end
-
-          def publish(name, *args)
-            if @can_publish
-              @delegate.publish name, *args
-            end
-          end
-
-          def start(name, id, payload)
-            @delegate.start name, id, payload
-          end
-
-          def finish(name, id, payload)
-            @delegate.finish name, id, payload
-          end
-
-          def subscribed_to?(name)
-            pattern === name
-          end
-
-          def matches?(name)
-            pattern && pattern === name
-          end
-
-          def unsubscribe!(name)
-            pattern.unsubscribe!(name)
-          end
-        end
-
-        class Timed < Evented # :nodoc:
-          def publish(name, *args)
-            @delegate.call name, *args
-          end
-
-          def start(name, id, payload)
-            timestack = Thread.current[:_timestack] ||= []
-            timestack.push Time.now
-          end
-
-          def finish(name, id, payload)
-            timestack = Thread.current[:_timestack]
-            started = timestack.pop
-            @delegate.call(name, started, Time.now, id, payload)
-          end
-        end
-
-        class MonotonicTimed < Evented # :nodoc:
-          def publish(name, *args)
-            @delegate.call name, *args
-          end
-
-          def start(name, id, payload)
-            timestack = Thread.current[:_timestack_monotonic] ||= []
-            timestack.push Concurrent.monotonic_time
-          end
-
-          def finish(name, id, payload)
-            timestack = Thread.current[:_timestack_monotonic]
-            started = timestack.pop
-            @delegate.call(name, started, Concurrent.monotonic_time, id, payload)
-          end
-        end
-
-        class EventObject < Evented
-          def start(name, id, payload)
-            stack = Thread.current[:_event_stack] ||= []
-            event = build_event name, id, payload
-            event.start!
-            stack.push event
-          end
-
-          def finish(name, id, payload)
-            stack = Thread.current[:_event_stack]
-            event = stack.pop
-            event.payload = payload
-            event.finish!
-            @delegate.call event
-          end
-
-          private
-            def build_event(name, id, payload)
-              ActiveSupport::Notifications::Event.new name, nil, nil, id, payload
-            end
-        end
-
-        class AllMessages # :nodoc:
-          def initialize(delegate)
-            @delegate = delegate
-          end
-
-          def start(name, id, payload)
-            @delegate.start name, id, payload
-          end
-
-          def finish(name, id, payload)
-            @delegate.finish name, id, payload
-          end
-
-          def publish(name, *args)
-            @delegate.publish name, *args
-          end
-
-          def subscribed_to?(name)
-            true
-          end
-
-          def unsubscribe!(*)
-            false
-          end
-
-          alias :matches? :===
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/notifications/instrumenter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/notifications/instrumenter.rb
deleted file mode 100644
index e1a9fe349c296..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/notifications/instrumenter.rb
+++ /dev/null
@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-
-module ActiveSupport
-  module Notifications
-    # Instrumenters are stored in a thread local.
-    class Instrumenter
-      attr_reader :id
-
-      def initialize(notifier)
-        @id       = unique_id
-        @notifier = notifier
-      end
-
-      # Given a block, instrument it by measuring the time taken to execute
-      # and publish it. Without a block, simply send a message via the
-      # notifier. Notice that events get sent even if an error occurs in the
-      # passed-in block.
-      def instrument(name, payload = {})
-        # some of the listeners might have state
-        listeners_state = start name, payload
-        begin
-          yield payload if block_given?
-        rescue Exception => e
-          payload[:exception] = [e.class.name, e.message]
-          payload[:exception_object] = e
-          raise e
-        ensure
-          finish_with_state listeners_state, name, payload
-        end
-      end
-
-      # Send a start notification with +name+ and +payload+.
-      def start(name, payload)
-        @notifier.start name, @id, payload
-      end
-
-      # Send a finish notification with +name+ and +payload+.
-      def finish(name, payload)
-        @notifier.finish name, @id, payload
-      end
-
-      def finish_with_state(listeners_state, name, payload)
-        @notifier.finish name, @id, payload, listeners_state
-      end
-
-      private
-        def unique_id
-          SecureRandom.hex(10)
-        end
-    end
-
-    class Event
-      attr_reader :name, :time, :end, :transaction_id, :children
-      attr_accessor :payload
-
-      def initialize(name, start, ending, transaction_id, payload)
-        @name           = name
-        @payload        = payload.dup
-        @time           = start
-        @transaction_id = transaction_id
-        @end            = ending
-        @children       = []
-        @cpu_time_start = 0
-        @cpu_time_finish = 0
-        @allocation_count_start = 0
-        @allocation_count_finish = 0
-      end
-
-      # Record information at the time this event starts
-      def start!
-        @time = now
-        @cpu_time_start = now_cpu
-        @allocation_count_start = now_allocations
-      end
-
-      # Record information at the time this event finishes
-      def finish!
-        @cpu_time_finish = now_cpu
-        @end = now
-        @allocation_count_finish = now_allocations
-      end
-
-      # Returns the CPU time (in milliseconds) passed since the call to
-      # +start!+ and the call to +finish!+
-      def cpu_time
-        (@cpu_time_finish - @cpu_time_start) * 1000
-      end
-
-      # Returns the idle time time (in milliseconds) passed since the call to
-      # +start!+ and the call to +finish!+
-      def idle_time
-        duration - cpu_time
-      end
-
-      # Returns the number of allocations made since the call to +start!+ and
-      # the call to +finish!+
-      def allocations
-        @allocation_count_finish - @allocation_count_start
-      end
-
-      # Returns the difference in milliseconds between when the execution of the
-      # event started and when it ended.
-      #
-      #   ActiveSupport::Notifications.subscribe('wait') do |*args|
-      #     @event = ActiveSupport::Notifications::Event.new(*args)
-      #   end
-      #
-      #   ActiveSupport::Notifications.instrument('wait') do
-      #     sleep 1
-      #   end
-      #
-      #   @event.duration # => 1000.138
-      def duration
-        1000.0 * (self.end - time)
-      end
-
-      def <<(event)
-        @children << event
-      end
-
-      def parent_of?(event)
-        @children.include? event
-      end
-
-      private
-        def now
-          Concurrent.monotonic_time
-        end
-
-        begin
-          Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID)
-
-          def now_cpu
-            Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID)
-          end
-        rescue
-          def now_cpu
-            0
-          end
-        end
-
-        if defined?(JRUBY_VERSION)
-          def now_allocations
-            0
-          end
-        else
-          def now_allocations
-            GC.stat :total_allocated_objects
-          end
-        end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/option_merger.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/option_merger.rb
deleted file mode 100644
index c7f7c0aa6bf2c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/option_merger.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/hash/deep_merge"
-require "active_support/core_ext/symbol/starts_ends_with"
-
-module ActiveSupport
-  class OptionMerger #:nodoc:
-    instance_methods.each do |method|
-      undef_method(method) unless method.start_with?("__", "instance_eval", "class", "object_id")
-    end
-
-    def initialize(context, options)
-      @context, @options = context, options
-    end
-
-    private
-      def method_missing(method, *arguments, &block)
-        options = nil
-        if arguments.first.is_a?(Proc)
-          proc = arguments.pop
-          arguments << lambda { |*args| @options.deep_merge(proc.call(*args)) }
-        elsif arguments.last.respond_to?(:to_hash)
-          options = @options.deep_merge(arguments.pop)
-        else
-          options = @options
-        end
-
-        invoke_method(method, arguments, options, &block)
-      end
-
-      if RUBY_VERSION >= "2.7"
-        def invoke_method(method, arguments, options, &block)
-          if options
-            @context.__send__(method, *arguments, **options, &block)
-          else
-            @context.__send__(method, *arguments, &block)
-          end
-        end
-      else
-        def invoke_method(method, arguments, options, &block)
-          arguments << options.dup if options
-          @context.__send__(method, *arguments, &block)
-        end
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/ordered_hash.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/ordered_hash.rb
deleted file mode 100644
index ad11524137e5e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/ordered_hash.rb
+++ /dev/null
@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-
-YAML.add_builtin_type("omap") do |type, val|
-  ActiveSupport::OrderedHash[val.map { |v| v.to_a.first }]
-end
-
-module ActiveSupport
-  # DEPRECATED: <tt>ActiveSupport::OrderedHash</tt> implements a hash that preserves
-  # insertion order.
-  #
-  #   oh = ActiveSupport::OrderedHash.new
-  #   oh[:a] = 1
-  #   oh[:b] = 2
-  #   oh.keys # => [:a, :b], this order is guaranteed
-  #
-  # Also, maps the +omap+ feature for YAML files
-  # (See https://yaml.org/type/omap.html) to support ordered items
-  # when loading from yaml.
-  #
-  # <tt>ActiveSupport::OrderedHash</tt> is namespaced to prevent conflicts
-  # with other implementations.
-  class OrderedHash < ::Hash
-    def to_yaml_type
-      "!tag:yaml.org,2002:omap"
-    end
-
-    def encode_with(coder)
-      coder.represent_seq "!omap", map { |k, v| { k => v } }
-    end
-
-    def select(*args, &block)
-      dup.tap { |hash| hash.select!(*args, &block) }
-    end
-
-    def reject(*args, &block)
-      dup.tap { |hash| hash.reject!(*args, &block) }
-    end
-
-    def nested_under_indifferent_access
-      self
-    end
-
-    # Returns true to make sure that this hash is extractable via <tt>Array#extract_options!</tt>
-    def extractable_options?
-      true
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/ordered_options.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/ordered_options.rb
deleted file mode 100644
index ba14907d9efee..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/ordered_options.rb
+++ /dev/null
@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/blank"
-
-module ActiveSupport
-  # +OrderedOptions+ inherits from +Hash+ and provides dynamic accessor methods.
-  #
-  # With a +Hash+, key-value pairs are typically managed like this:
-  #
-  #   h = {}
-  #   h[:boy] = 'John'
-  #   h[:girl] = 'Mary'
-  #   h[:boy]  # => 'John'
-  #   h[:girl] # => 'Mary'
-  #   h[:dog]  # => nil
-  #
-  # Using +OrderedOptions+, the above code can be written as:
-  #
-  #   h = ActiveSupport::OrderedOptions.new
-  #   h.boy = 'John'
-  #   h.girl = 'Mary'
-  #   h.boy  # => 'John'
-  #   h.girl # => 'Mary'
-  #   h.dog  # => nil
-  #
-  # To raise an exception when the value is blank, append a
-  # bang to the key name, like:
-  #
-  #   h.dog! # => raises KeyError: :dog is blank
-  #
-  class OrderedOptions < Hash
-    alias_method :_get, :[] # preserve the original #[] method
-    protected :_get # make it protected
-
-    def []=(key, value)
-      super(key.to_sym, value)
-    end
-
-    def [](key)
-      super(key.to_sym)
-    end
-
-    def method_missing(name, *args)
-      name_string = +name.to_s
-      if name_string.chomp!("=")
-        self[name_string] = args.first
-      else
-        bangs = name_string.chomp!("!")
-
-        if bangs
-          self[name_string].presence || raise(KeyError.new(":#{name_string} is blank"))
-        else
-          self[name_string]
-        end
-      end
-    end
-
-    def respond_to_missing?(name, include_private)
-      true
-    end
-
-    def extractable_options?
-      true
-    end
-
-    def inspect
-      "#<#{self.class.name} #{super}>"
-    end
-  end
-
-  # +InheritableOptions+ provides a constructor to build an +OrderedOptions+
-  # hash inherited from another hash.
-  #
-  # Use this if you already have some hash and you want to create a new one based on it.
-  #
-  #   h = ActiveSupport::InheritableOptions.new({ girl: 'Mary', boy: 'John' })
-  #   h.girl # => 'Mary'
-  #   h.boy  # => 'John'
-  class InheritableOptions < OrderedOptions
-    def initialize(parent = nil)
-      if parent.kind_of?(OrderedOptions)
-        # use the faster _get when dealing with OrderedOptions
-        super() { |h, k| parent._get(k) }
-      elsif parent
-        super() { |h, k| parent[k] }
-      else
-        super()
-      end
-    end
-
-    def inheritable_copy
-      self.class.new(self)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/parameter_filter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/parameter_filter.rb
deleted file mode 100644
index 134778251f565..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/parameter_filter.rb
+++ /dev/null
@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/duplicable"
-
-module ActiveSupport
-  # +ParameterFilter+ allows you to specify keys for sensitive data from
-  # hash-like object and replace corresponding value. Filtering only certain
-  # sub-keys from a hash is possible by using the dot notation:
-  # 'credit_card.number'. If a proc is given, each key and value of a hash and
-  # all sub-hashes are passed to it, where the value or the key can be replaced
-  # using String#replace or similar methods.
-  #
-  #   ActiveSupport::ParameterFilter.new([:password])
-  #   => replaces the value to all keys matching /password/i with "[FILTERED]"
-  #
-  #   ActiveSupport::ParameterFilter.new([:foo, "bar"])
-  #   => replaces the value to all keys matching /foo|bar/i with "[FILTERED]"
-  #
-  #   ActiveSupport::ParameterFilter.new(["credit_card.code"])
-  #   => replaces { credit_card: {code: "xxxx"} } with "[FILTERED]", does not
-  #   change { file: { code: "xxxx"} }
-  #
-  #   ActiveSupport::ParameterFilter.new([-> (k, v) do
-  #     v.reverse! if /secret/i.match?(k)
-  #   end])
-  #   => reverses the value to all keys matching /secret/i
-  class ParameterFilter
-    FILTERED = "[FILTERED]" # :nodoc:
-
-    # Create instance with given filters. Supported type of filters are +String+, +Regexp+, and +Proc+.
-    # Other types of filters are treated as +String+ using +to_s+.
-    # For +Proc+ filters, key, value, and optional original hash is passed to block arguments.
-    #
-    # ==== Options
-    #
-    # * <tt>:mask</tt> - A replaced object when filtered. Defaults to <tt>"[FILTERED]"</tt>.
-    def initialize(filters = [], mask: FILTERED)
-      @filters = filters
-      @mask = mask
-    end
-
-    # Mask value of +params+ if key matches one of filters.
-    def filter(params)
-      compiled_filter.call(params)
-    end
-
-    # Returns filtered value for given key. For +Proc+ filters, third block argument is not populated.
-    def filter_param(key, value)
-      @filters.empty? ? value : compiled_filter.value_for_key(key, value)
-    end
-
-  private
-    def compiled_filter
-      @compiled_filter ||= CompiledFilter.compile(@filters, mask: @mask)
-    end
-
-    class CompiledFilter # :nodoc:
-      def self.compile(filters, mask:)
-        return lambda { |params| params.dup } if filters.empty?
-
-        strings, regexps, blocks, deep_regexps, deep_strings = [], [], [], nil, nil
-
-        filters.each do |item|
-          case item
-          when Proc
-            blocks << item
-          when Regexp
-            if item.to_s.include?("\\.")
-              (deep_regexps ||= []) << item
-            else
-              regexps << item
-            end
-          else
-            s = Regexp.escape(item.to_s)
-            if s.include?("\\.")
-              (deep_strings ||= []) << s
-            else
-              strings << s
-            end
-          end
-        end
-
-        regexps << Regexp.new(strings.join("|"), true) unless strings.empty?
-        (deep_regexps ||= []) << Regexp.new(deep_strings.join("|"), true) if deep_strings&.any?
-
-        new regexps, deep_regexps, blocks, mask: mask
-      end
-
-      attr_reader :regexps, :deep_regexps, :blocks
-
-      def initialize(regexps, deep_regexps, blocks, mask:)
-        @regexps = regexps
-        @deep_regexps = deep_regexps&.any? ? deep_regexps : nil
-        @blocks = blocks
-        @mask = mask
-      end
-
-      def call(params, parents = [], original_params = params)
-        filtered_params = params.class.new
-
-        params.each do |key, value|
-          filtered_params[key] = value_for_key(key, value, parents, original_params)
-        end
-
-        filtered_params
-      end
-
-      def value_for_key(key, value, parents = [], original_params = nil)
-        parents.push(key) if deep_regexps
-        if regexps.any? { |r| r.match?(key.to_s) }
-          value = @mask
-        elsif deep_regexps && (joined = parents.join(".")) && deep_regexps.any? { |r| r.match?(joined) }
-          value = @mask
-        elsif value.is_a?(Hash)
-          value = call(value, parents, original_params)
-        elsif value.is_a?(Array)
-          # If we don't pop the current parent it will be duplicated as we
-          # process each array value.
-          parents.pop if deep_regexps
-          value = value.map { |v| value_for_key(key, v, parents, original_params) }
-          # Restore the parent stack after processing the array.
-          parents.push(key) if deep_regexps
-        elsif blocks.any?
-          key = key.dup if key.duplicable?
-          value = value.dup if value.duplicable?
-          blocks.each { |b| b.arity == 2 ? b.call(key, value) : b.call(key, value, original_params) }
-        end
-        parents.pop if deep_regexps
-        value
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/per_thread_registry.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/per_thread_registry.rb
deleted file mode 100644
index 2ab47079374cf..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/per_thread_registry.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/delegation"
-
-module ActiveSupport
-  # NOTE: This approach has been deprecated for end-user code in favor of {thread_mattr_accessor}[rdoc-ref:Module#thread_mattr_accessor] and friends.
-  # Please use that approach instead.
-  #
-  # This module is used to encapsulate access to thread local variables.
-  #
-  # Instead of polluting the thread locals namespace:
-  #
-  #   Thread.current[:connection_handler]
-  #
-  # you define a class that extends this module:
-  #
-  #   module ActiveRecord
-  #     class RuntimeRegistry
-  #       extend ActiveSupport::PerThreadRegistry
-  #
-  #       attr_accessor :connection_handler
-  #     end
-  #   end
-  #
-  # and invoke the declared instance accessors as class methods. So
-  #
-  #   ActiveRecord::RuntimeRegistry.connection_handler = connection_handler
-  #
-  # sets a connection handler local to the current thread, and
-  #
-  #   ActiveRecord::RuntimeRegistry.connection_handler
-  #
-  # returns a connection handler local to the current thread.
-  #
-  # This feature is accomplished by instantiating the class and storing the
-  # instance as a thread local keyed by the class name. In the example above
-  # a key "ActiveRecord::RuntimeRegistry" is stored in <tt>Thread.current</tt>.
-  # The class methods proxy to said thread local instance.
-  #
-  # If the class has an initializer, it must accept no arguments.
-  module PerThreadRegistry
-    def self.extended(object)
-      object.instance_variable_set :@per_thread_registry_key, object.name.freeze
-    end
-
-    def instance
-      Thread.current[@per_thread_registry_key] ||= new
-    end
-
-    private
-      def method_missing(name, *args, &block)
-        # Caches the method definition as a singleton method of the receiver.
-        #
-        # By letting #delegate handle it, we avoid an enclosure that'll capture args.
-        singleton_class.delegate name, to: :instance
-
-        send(name, *args, &block)
-      end
-      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/proxy_object.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/proxy_object.rb
deleted file mode 100644
index 0965fcd2d9227..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/proxy_object.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  # A class with no predefined methods that behaves similarly to Builder's
-  # BlankSlate. Used for proxy classes.
-  class ProxyObject < ::BasicObject
-    undef_method :==
-    undef_method :equal?
-
-    # Let ActiveSupport::ProxyObject at least raise exceptions.
-    def raise(*args)
-      ::Object.send(:raise, *args)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/rails.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/rails.rb
deleted file mode 100644
index 75676a2e47a13..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/rails.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-# This is a private interface.
-#
-# Rails components cherry pick from Active Support as needed, but there are a
-# few features that are used for sure in some way or another and it is not worth
-# putting individual requires absolutely everywhere. Think blank? for example.
-#
-# This file is loaded by every Rails component except Active Support itself,
-# but it does not belong to the Rails public interface. It is internal to
-# Rails and can change anytime.
-
-# Defines Object#blank? and Object#present?.
-require "active_support/core_ext/object/blank"
-
-# Support for ClassMethods and the included macro.
-require "active_support/concern"
-
-# Defines Class#class_attribute.
-require "active_support/core_ext/class/attribute"
-
-# Defines Module#delegate.
-require "active_support/core_ext/module/delegation"
-
-# Defines ActiveSupport::Deprecation.
-require "active_support/deprecation"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/railtie.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/railtie.rb
deleted file mode 100644
index a6dd1bb0257b5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/railtie.rb
+++ /dev/null
@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support"
-require "active_support/i18n_railtie"
-
-module ActiveSupport
-  class Railtie < Rails::Railtie # :nodoc:
-    config.active_support = ActiveSupport::OrderedOptions.new
-
-    config.eager_load_namespaces << ActiveSupport
-
-    initializer "active_support.set_authenticated_message_encryption" do |app|
-      config.after_initialize do
-        unless app.config.active_support.use_authenticated_message_encryption.nil?
-          ActiveSupport::MessageEncryptor.use_authenticated_message_encryption =
-            app.config.active_support.use_authenticated_message_encryption
-        end
-      end
-    end
-
-    initializer "active_support.reset_all_current_attributes_instances" do |app|
-      app.reloader.before_class_unload { ActiveSupport::CurrentAttributes.clear_all }
-      app.executor.to_run              { ActiveSupport::CurrentAttributes.reset_all }
-      app.executor.to_complete         { ActiveSupport::CurrentAttributes.reset_all }
-
-      ActiveSupport.on_load(:active_support_test_case) do
-        require "active_support/current_attributes/test_helper"
-        include ActiveSupport::CurrentAttributes::TestHelper
-      end
-    end
-
-    initializer "active_support.deprecation_behavior" do |app|
-      if deprecation = app.config.active_support.deprecation
-        ActiveSupport::Deprecation.behavior = deprecation
-      end
-
-      if disallowed_deprecation = app.config.active_support.disallowed_deprecation
-        ActiveSupport::Deprecation.disallowed_behavior = disallowed_deprecation
-      end
-
-      if disallowed_warnings = app.config.active_support.disallowed_deprecation_warnings
-        ActiveSupport::Deprecation.disallowed_warnings = disallowed_warnings
-      end
-    end
-
-    # Sets the default value for Time.zone
-    # If assigned value cannot be matched to a TimeZone, an exception will be raised.
-    initializer "active_support.initialize_time_zone" do |app|
-      begin
-        TZInfo::DataSource.get
-      rescue TZInfo::DataSourceNotFound => e
-        raise e.exception "tzinfo-data is not present. Please add gem 'tzinfo-data' to your Gemfile and run bundle install"
-      end
-      require "active_support/core_ext/time/zones"
-      Time.zone_default = Time.find_zone!(app.config.time_zone)
-    end
-
-    # Sets the default week start
-    # If assigned value is not a valid day symbol (e.g. :sunday, :monday, ...), an exception will be raised.
-    initializer "active_support.initialize_beginning_of_week" do |app|
-      require "active_support/core_ext/date/calculations"
-      beginning_of_week_default = Date.find_beginning_of_week!(app.config.beginning_of_week)
-
-      Date.beginning_of_week_default = beginning_of_week_default
-    end
-
-    initializer "active_support.require_master_key" do |app|
-      if app.config.respond_to?(:require_master_key) && app.config.require_master_key
-        begin
-          app.credentials.key
-        rescue ActiveSupport::EncryptedFile::MissingKeyError => error
-          $stderr.puts error.message
-          exit 1
-        end
-      end
-    end
-
-    initializer "active_support.set_configs" do |app|
-      app.config.active_support.each do |k, v|
-        k = "#{k}="
-        ActiveSupport.public_send(k, v) if ActiveSupport.respond_to? k
-      end
-    end
-
-    initializer "active_support.set_hash_digest_class" do |app|
-      config.after_initialize do
-        if app.config.active_support.use_sha1_digests
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            config.active_support.use_sha1_digests is deprecated and will
-            be removed from Rails 7.0. Use
-            config.active_support.hash_digest_class = ::Digest::SHA1 instead.
-          MSG
-          ActiveSupport::Digest.hash_digest_class = ::Digest::SHA1
-        end
-
-        if klass = app.config.active_support.hash_digest_class
-          ActiveSupport::Digest.hash_digest_class = klass
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/reloader.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/reloader.rb
deleted file mode 100644
index e751866a270f8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/reloader.rb
+++ /dev/null
@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/execution_wrapper"
-require "active_support/executor"
-
-module ActiveSupport
-  #--
-  # This class defines several callbacks:
-  #
-  #   to_prepare -- Run once at application startup, and also from
-  #   +to_run+.
-  #
-  #   to_run -- Run before a work run that is reloading. If
-  #   +reload_classes_only_on_change+ is true (the default), the class
-  #   unload will have already occurred.
-  #
-  #   to_complete -- Run after a work run that has reloaded. If
-  #   +reload_classes_only_on_change+ is false, the class unload will
-  #   have occurred after the work run, but before this callback.
-  #
-  #   before_class_unload -- Run immediately before the classes are
-  #   unloaded.
-  #
-  #   after_class_unload -- Run immediately after the classes are
-  #   unloaded.
-  #
-  class Reloader < ExecutionWrapper
-    define_callbacks :prepare
-
-    define_callbacks :class_unload
-
-    # Registers a callback that will run once at application startup and every time the code is reloaded.
-    def self.to_prepare(*args, &block)
-      set_callback(:prepare, *args, &block)
-    end
-
-    # Registers a callback that will run immediately before the classes are unloaded.
-    def self.before_class_unload(*args, &block)
-      set_callback(:class_unload, *args, &block)
-    end
-
-    # Registers a callback that will run immediately after the classes are unloaded.
-    def self.after_class_unload(*args, &block)
-      set_callback(:class_unload, :after, *args, &block)
-    end
-
-    to_run(:after) { self.class.prepare! }
-
-    # Initiate a manual reload
-    def self.reload!
-      executor.wrap do
-        new.tap do |instance|
-          instance.run!
-        ensure
-          instance.complete!
-        end
-      end
-      prepare!
-    end
-
-    def self.run!(reset: false) # :nodoc:
-      if check!
-        super
-      else
-        Null
-      end
-    end
-
-    # Run the supplied block as a work unit, reloading code as needed
-    def self.wrap
-      executor.wrap do
-        super
-      end
-    end
-
-    class_attribute :executor, default: Executor
-    class_attribute :check, default: lambda { false }
-
-    def self.check! # :nodoc:
-      @should_reload ||= check.call
-    end
-
-    def self.reloaded! # :nodoc:
-      @should_reload = false
-    end
-
-    def self.prepare! # :nodoc:
-      new.run_callbacks(:prepare)
-    end
-
-    def initialize
-      super
-      @locked = false
-    end
-
-    # Acquire the ActiveSupport::Dependencies::Interlock unload lock,
-    # ensuring it will be released automatically
-    def require_unload_lock!
-      unless @locked
-        ActiveSupport::Dependencies.interlock.start_unloading
-        @locked = true
-      end
-    end
-
-    # Release the unload lock if it has been previously obtained
-    def release_unload_lock!
-      if @locked
-        @locked = false
-        ActiveSupport::Dependencies.interlock.done_unloading
-      end
-    end
-
-    def run! # :nodoc:
-      super
-      release_unload_lock!
-    end
-
-    def class_unload!(&block) # :nodoc:
-      require_unload_lock!
-      run_callbacks(:class_unload, &block)
-    end
-
-    def complete! # :nodoc:
-      super
-      self.class.reloaded!
-    ensure
-      release_unload_lock!
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/rescuable.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/rescuable.rb
deleted file mode 100644
index 2b965677f3350..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/rescuable.rb
+++ /dev/null
@@ -1,174 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-require "active_support/core_ext/class/attribute"
-require "active_support/core_ext/string/inflections"
-
-module ActiveSupport
-  # Rescuable module adds support for easier exception handling.
-  module Rescuable
-    extend Concern
-
-    included do
-      class_attribute :rescue_handlers, default: []
-    end
-
-    module ClassMethods
-      # Registers exception classes with a handler to be called by <tt>rescue_with_handler</tt>.
-      #
-      # <tt>rescue_from</tt> receives a series of exception classes or class
-      # names, and an exception handler specified by a trailing <tt>:with</tt>
-      # option containing the name of a method or a Proc object. Alternatively, a block
-      # can be given as the handler.
-      #
-      # Handlers that take one argument will be called with the exception, so
-      # that the exception can be inspected when dealing with it.
-      #
-      # Handlers are inherited. They are searched from right to left, from
-      # bottom to top, and up the hierarchy. The handler of the first class for
-      # which <tt>exception.is_a?(klass)</tt> holds true is the one invoked, if
-      # any.
-      #
-      #   class ApplicationController < ActionController::Base
-      #     rescue_from User::NotAuthorized, with: :deny_access # self defined exception
-      #     rescue_from ActiveRecord::RecordInvalid, with: :show_errors
-      #
-      #     rescue_from 'MyAppError::Base' do |exception|
-      #       render xml: exception, status: 500
-      #     end
-      #
-      #     private
-      #       def deny_access
-      #         ...
-      #       end
-      #
-      #       def show_errors(exception)
-      #         exception.record.new_record? ? ...
-      #       end
-      #   end
-      #
-      # Exceptions raised inside exception handlers are not propagated up.
-      def rescue_from(*klasses, with: nil, &block)
-        unless with
-          if block_given?
-            with = block
-          else
-            raise ArgumentError, "Need a handler. Pass the with: keyword argument or provide a block."
-          end
-        end
-
-        klasses.each do |klass|
-          key = if klass.is_a?(Module) && klass.respond_to?(:===)
-            klass.name
-          elsif klass.is_a?(String)
-            klass
-          else
-            raise ArgumentError, "#{klass.inspect} must be an Exception class or a String referencing an Exception class"
-          end
-
-          # Put the new handler at the end because the list is read in reverse.
-          self.rescue_handlers += [[key, with]]
-        end
-      end
-
-      # Matches an exception to a handler based on the exception class.
-      #
-      # If no handler matches the exception, check for a handler matching the
-      # (optional) exception.cause. If no handler matches the exception or its
-      # cause, this returns +nil+, so you can deal with unhandled exceptions.
-      # Be sure to re-raise unhandled exceptions if this is what you expect.
-      #
-      #     begin
-      #       …
-      #     rescue => exception
-      #       rescue_with_handler(exception) || raise
-      #     end
-      #
-      # Returns the exception if it was handled and +nil+ if it was not.
-      def rescue_with_handler(exception, object: self, visited_exceptions: [])
-        visited_exceptions << exception
-
-        if handler = handler_for_rescue(exception, object: object)
-          handler.call exception
-          exception
-        elsif exception
-          if visited_exceptions.include?(exception.cause)
-            nil
-          else
-            rescue_with_handler(exception.cause, object: object, visited_exceptions: visited_exceptions)
-          end
-        end
-      end
-
-      def handler_for_rescue(exception, object: self) #:nodoc:
-        case rescuer = find_rescue_handler(exception)
-        when Symbol
-          method = object.method(rescuer)
-          if method.arity == 0
-            -> e { method.call }
-          else
-            method
-          end
-        when Proc
-          if rescuer.arity == 0
-            -> e { object.instance_exec(&rescuer) }
-          else
-            -> e { object.instance_exec(e, &rescuer) }
-          end
-        end
-      end
-
-      private
-        def find_rescue_handler(exception)
-          if exception
-            # Handlers are in order of declaration but the most recently declared
-            # is the highest priority match, so we search for matching handlers
-            # in reverse.
-            _, handler = rescue_handlers.reverse_each.detect do |class_or_name, _|
-              if klass = constantize_rescue_handler_class(class_or_name)
-                klass === exception
-              end
-            end
-
-            handler
-          end
-        end
-
-        def constantize_rescue_handler_class(class_or_name)
-          case class_or_name
-          when String, Symbol
-            begin
-              # Try a lexical lookup first since we support
-              #
-              #     class Super
-              #       rescue_from 'Error', with: …
-              #     end
-              #
-              #     class Sub
-              #       class Error < StandardError; end
-              #     end
-              #
-              # so an Error raised in Sub will hit the 'Error' handler.
-              const_get class_or_name
-            rescue NameError
-              class_or_name.safe_constantize
-            end
-          else
-            class_or_name
-          end
-        end
-    end
-
-    # Delegates to the class method, but uses the instance as the subject for
-    # rescue_from handlers (method calls, instance_exec blocks).
-    def rescue_with_handler(exception)
-      self.class.rescue_with_handler exception, object: self
-    end
-
-    # Internal handler lookup. Delegates to class method. Some libraries call
-    # this directly, so keeping it around for compatibility.
-    def handler_for_rescue(exception) #:nodoc:
-      self.class.handler_for_rescue exception, object: self
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/secure_compare_rotator.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/secure_compare_rotator.rb
deleted file mode 100644
index 269703c34ac77..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/secure_compare_rotator.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/security_utils"
-require "active_support/messages/rotator"
-
-module ActiveSupport
-  # The ActiveSupport::SecureCompareRotator is a wrapper around +ActiveSupport::SecurityUtils.secure_compare+
-  # and allows you to rotate a previously defined value to a new one.
-  #
-  # It can be used as follow:
-  #
-  #   rotator = ActiveSupport::SecureCompareRotator.new('new_production_value')
-  #   rotator.rotate('previous_production_value')
-  #   rotator.secure_compare!('previous_production_value')
-  #
-  # One real use case example would be to rotate a basic auth credentials:
-  #
-  #   class MyController < ApplicationController
-  #     def authenticate_request
-  #       rotator = ActiveSupport::SecureComparerotator.new('new_password')
-  #       rotator.rotate('old_password')
-  #
-  #       authenticate_or_request_with_http_basic do |username, password|
-  #         rotator.secure_compare!(password)
-  #       rescue ActiveSupport::SecureCompareRotator::InvalidMatch
-  #         false
-  #       end
-  #     end
-  #   end
-  class SecureCompareRotator
-    include SecurityUtils
-    prepend Messages::Rotator
-
-    InvalidMatch = Class.new(StandardError)
-
-    def initialize(value, **_options)
-      @value = value
-    end
-
-    def secure_compare!(other_value, on_rotation: @on_rotation)
-      secure_compare(@value, other_value) ||
-        run_rotations(on_rotation) { |wrapper| wrapper.secure_compare!(other_value) } ||
-        raise(InvalidMatch)
-    end
-
-    private
-      def build_rotation(previous_value, _options)
-        self.class.new(previous_value)
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/security_utils.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/security_utils.rb
deleted file mode 100644
index aa00474448d9b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/security_utils.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  module SecurityUtils
-    # Constant time string comparison, for fixed length strings.
-    #
-    # The values compared should be of fixed length, such as strings
-    # that have already been processed by HMAC. Raises in case of length mismatch.
-
-    if defined?(OpenSSL.fixed_length_secure_compare)
-      def fixed_length_secure_compare(a, b)
-        OpenSSL.fixed_length_secure_compare(a, b)
-      end
-    else
-      def fixed_length_secure_compare(a, b)
-        raise ArgumentError, "string length mismatch." unless a.bytesize == b.bytesize
-
-        l = a.unpack "C#{a.bytesize}"
-
-        res = 0
-        b.each_byte { |byte| res |= byte ^ l.shift }
-        res == 0
-      end
-    end
-    module_function :fixed_length_secure_compare
-
-    # Secure string comparison for strings of variable length.
-    #
-    # While a timing attack would not be able to discern the content of
-    # a secret compared via secure_compare, it is possible to determine
-    # the secret length. This should be considered when using secure_compare
-    # to compare weak, short secrets to user input.
-    def secure_compare(a, b)
-      a.bytesize == b.bytesize && fixed_length_secure_compare(a, b)
-    end
-    module_function :secure_compare
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/string_inquirer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/string_inquirer.rb
deleted file mode 100644
index 5ff3f4bfe7504..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/string_inquirer.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/symbol/starts_ends_with"
-
-module ActiveSupport
-  # Wrapping a string in this class gives you a prettier way to test
-  # for equality. The value returned by <tt>Rails.env</tt> is wrapped
-  # in a StringInquirer object, so instead of calling this:
-  #
-  #   Rails.env == 'production'
-  #
-  # you can call this:
-  #
-  #   Rails.env.production?
-  #
-  # == Instantiating a new StringInquirer
-  #
-  #   vehicle = ActiveSupport::StringInquirer.new('car')
-  #   vehicle.car?   # => true
-  #   vehicle.bike?  # => false
-  class StringInquirer < String
-    private
-      def respond_to_missing?(method_name, include_private = false)
-        method_name.end_with?("?") || super
-      end
-
-      def method_missing(method_name, *arguments)
-        if method_name.end_with?("?")
-          self == method_name[0..-2]
-        else
-          super
-        end
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/subscriber.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/subscriber.rb
deleted file mode 100644
index 24f8681af8aa5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/subscriber.rb
+++ /dev/null
@@ -1,174 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/per_thread_registry"
-require "active_support/notifications"
-
-module ActiveSupport
-  # ActiveSupport::Subscriber is an object set to consume
-  # ActiveSupport::Notifications. The subscriber dispatches notifications to
-  # a registered object based on its given namespace.
-  #
-  # An example would be an Active Record subscriber responsible for collecting
-  # statistics about queries:
-  #
-  #   module ActiveRecord
-  #     class StatsSubscriber < ActiveSupport::Subscriber
-  #       attach_to :active_record
-  #
-  #       def sql(event)
-  #         Statsd.timing("sql.#{event.payload[:name]}", event.duration)
-  #       end
-  #     end
-  #   end
-  #
-  # After configured, whenever a "sql.active_record" notification is published,
-  # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
-  # the +sql+ method.
-  #
-  # We can detach a subscriber as well:
-  #
-  #   ActiveRecord::StatsSubscriber.detach_from(:active_record)
-  class Subscriber
-    class << self
-      # Attach the subscriber to a namespace.
-      def attach_to(namespace, subscriber = new, notifier = ActiveSupport::Notifications, inherit_all: false)
-        @namespace  = namespace
-        @subscriber = subscriber
-        @notifier   = notifier
-        @inherit_all = inherit_all
-
-        subscribers << subscriber
-
-        # Add event subscribers for all existing methods on the class.
-        fetch_public_methods(subscriber, inherit_all).each do |event|
-          add_event_subscriber(event)
-        end
-      end
-
-      # Detach the subscriber from a namespace.
-      def detach_from(namespace, notifier = ActiveSupport::Notifications)
-        @namespace  = namespace
-        @subscriber = find_attached_subscriber
-        @notifier   = notifier
-
-        return unless subscriber
-
-        subscribers.delete(subscriber)
-
-        # Remove event subscribers of all existing methods on the class.
-        fetch_public_methods(subscriber, true).each do |event|
-          remove_event_subscriber(event)
-        end
-
-        # Reset notifier so that event subscribers will not add for new methods added to the class.
-        @notifier = nil
-      end
-
-      # Adds event subscribers for all new methods added to the class.
-      def method_added(event)
-        # Only public methods are added as subscribers, and only if a notifier
-        # has been set up. This means that subscribers will only be set up for
-        # classes that call #attach_to.
-        if public_method_defined?(event) && notifier
-          add_event_subscriber(event)
-        end
-      end
-
-      def subscribers
-        @@subscribers ||= []
-      end
-
-      private
-        attr_reader :subscriber, :notifier, :namespace
-
-        def add_event_subscriber(event) # :doc:
-          return if invalid_event?(event)
-
-          pattern = prepare_pattern(event)
-
-          # Don't add multiple subscribers (e.g. if methods are redefined).
-          return if pattern_subscribed?(pattern)
-
-          subscriber.patterns[pattern] = notifier.subscribe(pattern, subscriber)
-        end
-
-        def remove_event_subscriber(event) # :doc:
-          return if invalid_event?(event)
-
-          pattern = prepare_pattern(event)
-
-          return unless pattern_subscribed?(pattern)
-
-          notifier.unsubscribe(subscriber.patterns[pattern])
-          subscriber.patterns.delete(pattern)
-        end
-
-        def find_attached_subscriber
-          subscribers.find { |attached_subscriber| attached_subscriber.instance_of?(self) }
-        end
-
-        def invalid_event?(event)
-          %i{ start finish }.include?(event.to_sym)
-        end
-
-        def prepare_pattern(event)
-          "#{event}.#{namespace}"
-        end
-
-        def pattern_subscribed?(pattern)
-          subscriber.patterns.key?(pattern)
-        end
-
-        def fetch_public_methods(subscriber, inherit_all)
-          subscriber.public_methods(inherit_all) - Subscriber.public_instance_methods(true)
-        end
-    end
-
-    attr_reader :patterns # :nodoc:
-
-    def initialize
-      @queue_key = [self.class.name, object_id].join "-"
-      @patterns  = {}
-      super
-    end
-
-    def start(name, id, payload)
-      event = ActiveSupport::Notifications::Event.new(name, nil, nil, id, payload)
-      event.start!
-      parent = event_stack.last
-      parent << event if parent
-
-      event_stack.push event
-    end
-
-    def finish(name, id, payload)
-      event = event_stack.pop
-      event.finish!
-      event.payload.merge!(payload)
-
-      method = name.split(".").first
-      send(method, event)
-    end
-
-    private
-      def event_stack
-        SubscriberQueueRegistry.instance.get_queue(@queue_key)
-      end
-  end
-
-  # This is a registry for all the event stacks kept for subscribers.
-  #
-  # See the documentation of <tt>ActiveSupport::PerThreadRegistry</tt>
-  # for further details.
-  class SubscriberQueueRegistry # :nodoc:
-    extend PerThreadRegistry
-
-    def initialize
-      @registry = {}
-    end
-
-    def get_queue(queue_key)
-      @registry[queue_key] ||= []
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/tagged_logging.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/tagged_logging.rb
deleted file mode 100644
index 0bc4a21401234..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/tagged_logging.rb
+++ /dev/null
@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/delegation"
-require "active_support/core_ext/object/blank"
-require "logger"
-require "active_support/logger"
-
-module ActiveSupport
-  # Wraps any standard Logger object to provide tagging capabilities.
-  #
-  # May be called with a block:
-  #
-  #   logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
-  #   logger.tagged('BCX') { logger.info 'Stuff' }                            # Logs "[BCX] Stuff"
-  #   logger.tagged('BCX', "Jason") { logger.info 'Stuff' }                   # Logs "[BCX] [Jason] Stuff"
-  #   logger.tagged('BCX') { logger.tagged('Jason') { logger.info 'Stuff' } } # Logs "[BCX] [Jason] Stuff"
-  #
-  # If called without a block, a new logger will be returned with applied tags:
-  #
-  #   logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
-  #   logger.tagged("BCX").info "Stuff"                 # Logs "[BCX] Stuff"
-  #   logger.tagged("BCX", "Jason").info "Stuff"        # Logs "[BCX] [Jason] Stuff"
-  #   logger.tagged("BCX").tagged("Jason").info "Stuff" # Logs "[BCX] [Jason] Stuff"
-  #
-  # This is used by the default Rails.logger as configured by Railties to make
-  # it easy to stamp log lines with subdomains, request ids, and anything else
-  # to aid debugging of multi-user production applications.
-  module TaggedLogging
-    module Formatter # :nodoc:
-      # This method is invoked when a log event occurs.
-      def call(severity, timestamp, progname, msg)
-        super(severity, timestamp, progname, "#{tags_text}#{msg}")
-      end
-
-      def tagged(*tags)
-        new_tags = push_tags(*tags)
-        yield self
-      ensure
-        pop_tags(new_tags.size)
-      end
-
-      def push_tags(*tags)
-        tags.flatten!
-        tags.reject!(&:blank?)
-        current_tags.concat tags
-        tags
-      end
-
-      def pop_tags(size = 1)
-        current_tags.pop size
-      end
-
-      def clear_tags!
-        current_tags.clear
-      end
-
-      def current_tags
-        # We use our object ID here to avoid conflicting with other instances
-        thread_key = @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}"
-        Thread.current[thread_key] ||= []
-      end
-
-      def tags_text
-        tags = current_tags
-        if tags.one?
-          "[#{tags[0]}] "
-        elsif tags.any?
-          tags.collect { |tag| "[#{tag}] " }.join
-        end
-      end
-    end
-
-    module LocalTagStorage # :nodoc:
-      attr_accessor :current_tags
-
-      def self.extended(base)
-        base.current_tags = []
-      end
-    end
-
-    def self.new(logger)
-      logger = logger.clone
-
-      if logger.formatter
-        logger.formatter = logger.formatter.dup
-      else
-        # Ensure we set a default formatter so we aren't extending nil!
-        logger.formatter = ActiveSupport::Logger::SimpleFormatter.new
-      end
-
-      logger.formatter.extend Formatter
-      logger.extend(self)
-    end
-
-    delegate :push_tags, :pop_tags, :clear_tags!, to: :formatter
-
-    def tagged(*tags)
-      if block_given?
-        formatter.tagged(*tags) { yield self }
-      else
-        logger = ActiveSupport::TaggedLogging.new(self)
-        logger.formatter.extend LocalTagStorage
-        logger.push_tags(*formatter.current_tags, *tags)
-        logger
-      end
-    end
-
-    def flush
-      clear_tags!
-      super if defined?(super)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/test_case.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/test_case.rb
deleted file mode 100644
index 7be4108ed7709..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/test_case.rb
+++ /dev/null
@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-gem "minitest" # make sure we get the gem, not stdlib
-require "minitest"
-require "active_support/testing/tagged_logging"
-require "active_support/testing/setup_and_teardown"
-require "active_support/testing/assertions"
-require "active_support/testing/deprecation"
-require "active_support/testing/declarative"
-require "active_support/testing/isolation"
-require "active_support/testing/constant_lookup"
-require "active_support/testing/time_helpers"
-require "active_support/testing/file_fixtures"
-require "active_support/testing/parallelization"
-require "concurrent/utility/processor_counter"
-
-module ActiveSupport
-  class TestCase < ::Minitest::Test
-    Assertion = Minitest::Assertion
-
-    class << self
-      # Sets the order in which test cases are run.
-      #
-      #   ActiveSupport::TestCase.test_order = :random # => :random
-      #
-      # Valid values are:
-      # * +:random+   (to run tests in random order)
-      # * +:parallel+ (to run tests in parallel)
-      # * +:sorted+   (to run tests alphabetically by method name)
-      # * +:alpha+    (equivalent to +:sorted+)
-      def test_order=(new_order)
-        ActiveSupport.test_order = new_order
-      end
-
-      # Returns the order in which test cases are run.
-      #
-      #   ActiveSupport::TestCase.test_order # => :random
-      #
-      # Possible values are +:random+, +:parallel+, +:alpha+, +:sorted+.
-      # Defaults to +:random+.
-      def test_order
-        ActiveSupport.test_order ||= :random
-      end
-
-      # Parallelizes the test suite.
-      #
-      # Takes a +workers+ argument that controls how many times the process
-      # is forked. For each process a new database will be created suffixed
-      # with the worker number.
-      #
-      #   test-database-0
-      #   test-database-1
-      #
-      # If <tt>ENV["PARALLEL_WORKERS"]</tt> is set the workers argument will be ignored
-      # and the environment variable will be used instead. This is useful for CI
-      # environments, or other environments where you may need more workers than
-      # you do for local testing.
-      #
-      # If the number of workers is set to +1+ or fewer, the tests will not be
-      # parallelized.
-      #
-      # If +workers+ is set to +:number_of_processors+, the number of workers will be
-      # set to the actual core count on the machine you are on.
-      #
-      # The default parallelization method is to fork processes. If you'd like to
-      # use threads instead you can pass <tt>with: :threads</tt> to the +parallelize+
-      # method. Note the threaded parallelization does not create multiple
-      # database and will not work with system tests at this time.
-      #
-      #   parallelize(workers: :number_of_processors, with: :threads)
-      #
-      # The threaded parallelization uses minitest's parallel executor directly.
-      # The processes parallelization uses a Ruby DRb server.
-      def parallelize(workers: :number_of_processors, with: :processes)
-        workers = Concurrent.physical_processor_count if workers == :number_of_processors
-        workers = ENV["PARALLEL_WORKERS"].to_i if ENV["PARALLEL_WORKERS"]
-
-        return if workers <= 1
-
-        executor = case with
-                   when :processes
-                     Testing::Parallelization.new(workers)
-                   when :threads
-                     Minitest::Parallel::Executor.new(workers)
-                   else
-                     raise ArgumentError, "#{with} is not a supported parallelization executor."
-        end
-
-        self.lock_threads = false if defined?(self.lock_threads) && with == :threads
-
-        Minitest.parallel_executor = executor
-
-        parallelize_me!
-      end
-
-      # Set up hook for parallel testing. This can be used if you have multiple
-      # databases or any behavior that needs to be run after the process is forked
-      # but before the tests run.
-      #
-      # Note: this feature is not available with the threaded parallelization.
-      #
-      # In your +test_helper.rb+ add the following:
-      #
-      #   class ActiveSupport::TestCase
-      #     parallelize_setup do
-      #       # create databases
-      #     end
-      #   end
-      def parallelize_setup(&block)
-        ActiveSupport::Testing::Parallelization.after_fork_hook do |worker|
-          yield worker
-        end
-      end
-
-      # Clean up hook for parallel testing. This can be used to drop databases
-      # if your app uses multiple write/read databases or other clean up before
-      # the tests finish. This runs before the forked process is closed.
-      #
-      # Note: this feature is not available with the threaded parallelization.
-      #
-      # In your +test_helper.rb+ add the following:
-      #
-      #   class ActiveSupport::TestCase
-      #     parallelize_teardown do
-      #       # drop databases
-      #     end
-      #   end
-      def parallelize_teardown(&block)
-        ActiveSupport::Testing::Parallelization.run_cleanup_hook do |worker|
-          yield worker
-        end
-      end
-    end
-
-    alias_method :method_name, :name
-
-    include ActiveSupport::Testing::TaggedLogging
-    prepend ActiveSupport::Testing::SetupAndTeardown
-    include ActiveSupport::Testing::Assertions
-    include ActiveSupport::Testing::Deprecation
-    include ActiveSupport::Testing::TimeHelpers
-    include ActiveSupport::Testing::FileFixtures
-    extend ActiveSupport::Testing::Declarative
-
-    # test/unit backwards compatibility methods
-    alias :assert_raise :assert_raises
-    alias :assert_not_empty :refute_empty
-    alias :assert_not_equal :refute_equal
-    alias :assert_not_in_delta :refute_in_delta
-    alias :assert_not_in_epsilon :refute_in_epsilon
-    alias :assert_not_includes :refute_includes
-    alias :assert_not_instance_of :refute_instance_of
-    alias :assert_not_kind_of :refute_kind_of
-    alias :assert_no_match :refute_match
-    alias :assert_not_nil :refute_nil
-    alias :assert_not_operator :refute_operator
-    alias :assert_not_predicate :refute_predicate
-    alias :assert_not_respond_to :refute_respond_to
-    alias :assert_not_same :refute_same
-
-    ActiveSupport.run_load_hooks(:active_support_test_case, self)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/time.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/time.rb
deleted file mode 100644
index 51854675bf54c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/time.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveSupport
-  autoload :Duration, "active_support/duration"
-  autoload :TimeWithZone, "active_support/time_with_zone"
-  autoload :TimeZone, "active_support/values/time_zone"
-end
-
-require "date"
-require "time"
-
-require "active_support/core_ext/time"
-require "active_support/core_ext/date"
-require "active_support/core_ext/date_time"
-
-require "active_support/core_ext/integer/time"
-require "active_support/core_ext/numeric/time"
-
-require "active_support/core_ext/string/conversions"
-require "active_support/core_ext/string/zones"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/time_with_zone.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/time_with_zone.rb
deleted file mode 100644
index 03d49d597f237..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/time_with_zone.rb
+++ /dev/null
@@ -1,585 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/duration"
-require "active_support/values/time_zone"
-require "active_support/core_ext/object/acts_like"
-require "active_support/core_ext/date_and_time/compatibility"
-
-module ActiveSupport
-  # A Time-like class that can represent a time in any time zone. Necessary
-  # because standard Ruby Time instances are limited to UTC and the
-  # system's <tt>ENV['TZ']</tt> zone.
-  #
-  # You shouldn't ever need to create a TimeWithZone instance directly via +new+.
-  # Instead use methods +local+, +parse+, +at+ and +now+ on TimeZone instances,
-  # and +in_time_zone+ on Time and DateTime instances.
-  #
-  #   Time.zone = 'Eastern Time (US & Canada)'        # => 'Eastern Time (US & Canada)'
-  #   Time.zone.local(2007, 2, 10, 15, 30, 45)        # => Sat, 10 Feb 2007 15:30:45.000000000 EST -05:00
-  #   Time.zone.parse('2007-02-10 15:30:45')          # => Sat, 10 Feb 2007 15:30:45.000000000 EST -05:00
-  #   Time.zone.at(1171139445)                        # => Sat, 10 Feb 2007 15:30:45.000000000 EST -05:00
-  #   Time.zone.now                                   # => Sun, 18 May 2008 13:07:55.754107581 EDT -04:00
-  #   Time.utc(2007, 2, 10, 20, 30, 45).in_time_zone  # => Sat, 10 Feb 2007 15:30:45.000000000 EST -05:00
-  #
-  # See Time and TimeZone for further documentation of these methods.
-  #
-  # TimeWithZone instances implement the same API as Ruby Time instances, so
-  # that Time and TimeWithZone instances are interchangeable.
-  #
-  #   t = Time.zone.now                     # => Sun, 18 May 2008 13:27:25.031505668 EDT -04:00
-  #   t.hour                                # => 13
-  #   t.dst?                                # => true
-  #   t.utc_offset                          # => -14400
-  #   t.zone                                # => "EDT"
-  #   t.to_s(:rfc822)                       # => "Sun, 18 May 2008 13:27:25 -0400"
-  #   t + 1.day                             # => Mon, 19 May 2008 13:27:25.031505668 EDT -04:00
-  #   t.beginning_of_year                   # => Tue, 01 Jan 2008 00:00:00.000000000 EST -05:00
-  #   t > Time.utc(1999)                    # => true
-  #   t.is_a?(Time)                         # => true
-  #   t.is_a?(ActiveSupport::TimeWithZone)  # => true
-  class TimeWithZone
-    # Report class name as 'Time' to thwart type checking.
-    def self.name
-      "Time"
-    end
-
-    PRECISIONS = Hash.new { |h, n| h[n] = "%FT%T.%#{n}N" }
-    PRECISIONS[0] = "%FT%T"
-
-    include Comparable, DateAndTime::Compatibility
-    attr_reader :time_zone
-
-    def initialize(utc_time, time_zone, local_time = nil, period = nil)
-      @utc = utc_time ? transfer_time_values_to_utc_constructor(utc_time) : nil
-      @time_zone, @time = time_zone, local_time
-      @period = @utc ? period : get_period_and_ensure_valid_local_time(period)
-    end
-
-    # Returns a <tt>Time</tt> instance that represents the time in +time_zone+.
-    def time
-      @time ||= incorporate_utc_offset(@utc, utc_offset)
-    end
-
-    # Returns a <tt>Time</tt> instance of the simultaneous time in the UTC timezone.
-    def utc
-      @utc ||= incorporate_utc_offset(@time, -utc_offset)
-    end
-    alias_method :comparable_time, :utc
-    alias_method :getgm, :utc
-    alias_method :getutc, :utc
-    alias_method :gmtime, :utc
-
-    # Returns the underlying TZInfo::TimezonePeriod.
-    def period
-      @period ||= time_zone.period_for_utc(@utc)
-    end
-
-    # Returns the simultaneous time in <tt>Time.zone</tt>, or the specified zone.
-    def in_time_zone(new_zone = ::Time.zone)
-      return self if time_zone == new_zone
-      utc.in_time_zone(new_zone)
-    end
-
-    # Returns a <tt>Time</tt> instance of the simultaneous time in the system timezone.
-    def localtime(utc_offset = nil)
-      utc.getlocal(utc_offset)
-    end
-    alias_method :getlocal, :localtime
-
-    # Returns true if the current time is within Daylight Savings Time for the
-    # specified time zone.
-    #
-    #   Time.zone = 'Eastern Time (US & Canada)'    # => 'Eastern Time (US & Canada)'
-    #   Time.zone.parse("2012-5-30").dst?           # => true
-    #   Time.zone.parse("2012-11-30").dst?          # => false
-    def dst?
-      period.dst?
-    end
-    alias_method :isdst, :dst?
-
-    # Returns true if the current time zone is set to UTC.
-    #
-    #   Time.zone = 'UTC'                           # => 'UTC'
-    #   Time.zone.now.utc?                          # => true
-    #   Time.zone = 'Eastern Time (US & Canada)'    # => 'Eastern Time (US & Canada)'
-    #   Time.zone.now.utc?                          # => false
-    def utc?
-      zone == "UTC" || zone == "UCT"
-    end
-    alias_method :gmt?, :utc?
-
-    # Returns the offset from current time to UTC time in seconds.
-    def utc_offset
-      period.observed_utc_offset
-    end
-    alias_method :gmt_offset, :utc_offset
-    alias_method :gmtoff, :utc_offset
-
-    # Returns a formatted string of the offset from UTC, or an alternative
-    # string if the time zone is already UTC.
-    #
-    #   Time.zone = 'Eastern Time (US & Canada)'   # => "Eastern Time (US & Canada)"
-    #   Time.zone.now.formatted_offset(true)       # => "-05:00"
-    #   Time.zone.now.formatted_offset(false)      # => "-0500"
-    #   Time.zone = 'UTC'                          # => "UTC"
-    #   Time.zone.now.formatted_offset(true, "0")  # => "0"
-    def formatted_offset(colon = true, alternate_utc_string = nil)
-      utc? && alternate_utc_string || TimeZone.seconds_to_utc_offset(utc_offset, colon)
-    end
-
-    # Returns the time zone abbreviation.
-    #
-    #   Time.zone = 'Eastern Time (US & Canada)'   # => "Eastern Time (US & Canada)"
-    #   Time.zone.now.zone # => "EST"
-    def zone
-      period.abbreviation
-    end
-
-    # Returns a string of the object's date, time, zone, and offset from UTC.
-    #
-    #   Time.zone.now.inspect # => "Thu, 04 Dec 2014 11:00:25.624541392 EST -05:00"
-    def inspect
-      "#{time.strftime('%a, %d %b %Y %H:%M:%S.%9N')} #{zone} #{formatted_offset}"
-    end
-
-    # Returns a string of the object's date and time in the ISO 8601 standard
-    # format.
-    #
-    #   Time.zone.now.xmlschema  # => "2014-12-04T11:02:37-05:00"
-    def xmlschema(fraction_digits = 0)
-      "#{time.strftime(PRECISIONS[fraction_digits.to_i])}#{formatted_offset(true, 'Z')}"
-    end
-    alias_method :iso8601, :xmlschema
-    alias_method :rfc3339, :xmlschema
-
-    # Coerces time to a string for JSON encoding. The default format is ISO 8601.
-    # You can get %Y/%m/%d %H:%M:%S +offset style by setting
-    # <tt>ActiveSupport::JSON::Encoding.use_standard_json_time_format</tt>
-    # to +false+.
-    #
-    #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = true
-    #   Time.utc(2005,2,1,15,15,10).in_time_zone("Hawaii").to_json
-    #   # => "2005-02-01T05:15:10.000-10:00"
-    #
-    #   # With ActiveSupport::JSON::Encoding.use_standard_json_time_format = false
-    #   Time.utc(2005,2,1,15,15,10).in_time_zone("Hawaii").to_json
-    #   # => "2005/02/01 05:15:10 -1000"
-    def as_json(options = nil)
-      if ActiveSupport::JSON::Encoding.use_standard_json_time_format
-        xmlschema(ActiveSupport::JSON::Encoding.time_precision)
-      else
-        %(#{time.strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
-      end
-    end
-
-    def init_with(coder) #:nodoc:
-      initialize(coder["utc"], coder["zone"], coder["time"])
-    end
-
-    def encode_with(coder) #:nodoc:
-      coder.tag = "!ruby/object:ActiveSupport::TimeWithZone"
-      coder.map = { "utc" => utc, "zone" => time_zone, "time" => time }
-    end
-
-    # Returns a string of the object's date and time in the format used by
-    # HTTP requests.
-    #
-    #   Time.zone.now.httpdate  # => "Tue, 01 Jan 2013 04:39:43 GMT"
-    def httpdate
-      utc.httpdate
-    end
-
-    # Returns a string of the object's date and time in the RFC 2822 standard
-    # format.
-    #
-    #   Time.zone.now.rfc2822  # => "Tue, 01 Jan 2013 04:51:39 +0000"
-    def rfc2822
-      to_s(:rfc822)
-    end
-    alias_method :rfc822, :rfc2822
-
-    # Returns a string of the object's date and time.
-    # Accepts an optional <tt>format</tt>:
-    # * <tt>:default</tt> - default value, mimics Ruby Time#to_s format.
-    # * <tt>:db</tt> - format outputs time in UTC :db time. See Time#to_formatted_s(:db).
-    # * Any key in <tt>Time::DATE_FORMATS</tt> can be used. See active_support/core_ext/time/conversions.rb.
-    def to_s(format = :default)
-      if format == :db
-        utc.to_s(format)
-      elsif formatter = ::Time::DATE_FORMATS[format]
-        formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
-      else
-        "#{time.strftime("%Y-%m-%d %H:%M:%S")} #{formatted_offset(false, 'UTC')}" # mimicking Ruby Time#to_s format
-      end
-    end
-    alias_method :to_formatted_s, :to_s
-
-    # Replaces <tt>%Z</tt> directive with +zone before passing to Time#strftime,
-    # so that zone information is correct.
-    def strftime(format)
-      format = format.gsub(/((?:\A|[^%])(?:%%)*)%Z/, "\\1#{zone}")
-      getlocal(utc_offset).strftime(format)
-    end
-
-    # Use the time in UTC for comparisons.
-    def <=>(other)
-      utc <=> other
-    end
-    alias_method :before?, :<
-    alias_method :after?, :>
-
-    # Returns true if the current object's time is within the specified
-    # +min+ and +max+ time.
-    def between?(min, max)
-      utc.between?(min, max)
-    end
-
-    # Returns true if the current object's time is in the past.
-    def past?
-      utc.past?
-    end
-
-    # Returns true if the current object's time falls within
-    # the current day.
-    def today?
-      time.today?
-    end
-
-    # Returns true if the current object's time falls within
-    # the next day (tomorrow).
-    def tomorrow?
-      time.tomorrow?
-    end
-    alias :next_day? :tomorrow?
-
-    # Returns true if the current object's time falls within
-    # the previous day (yesterday).
-    def yesterday?
-      time.yesterday?
-    end
-    alias :prev_day? :yesterday?
-
-    # Returns true if the current object's time is in the future.
-    def future?
-      utc.future?
-    end
-
-    # Returns +true+ if +other+ is equal to current object.
-    def eql?(other)
-      other.eql?(utc)
-    end
-
-    def hash
-      utc.hash
-    end
-
-    # Adds an interval of time to the current object's time and returns that
-    # value as a new TimeWithZone object.
-    #
-    #   Time.zone = 'Eastern Time (US & Canada)' # => 'Eastern Time (US & Canada)'
-    #   now = Time.zone.now # => Sun, 02 Nov 2014 01:26:28.725182881 EDT -04:00
-    #   now + 1000          # => Sun, 02 Nov 2014 01:43:08.725182881 EDT -04:00
-    #
-    # If we're adding a Duration of variable length (i.e., years, months, days),
-    # move forward from #time, otherwise move forward from #utc, for accuracy
-    # when moving across DST boundaries.
-    #
-    # For instance, a time + 24.hours will advance exactly 24 hours, while a
-    # time + 1.day will advance 23-25 hours, depending on the day.
-    #
-    #   now + 24.hours      # => Mon, 03 Nov 2014 00:26:28.725182881 EST -05:00
-    #   now + 1.day         # => Mon, 03 Nov 2014 01:26:28.725182881 EST -05:00
-    def +(other)
-      if duration_of_variable_length?(other)
-        method_missing(:+, other)
-      else
-        result = utc.acts_like?(:date) ? utc.since(other) : utc + other rescue utc.since(other)
-        result.in_time_zone(time_zone)
-      end
-    end
-    alias_method :since, :+
-    alias_method :in, :+
-
-    # Subtracts an interval of time and returns a new TimeWithZone object unless
-    # the other value +acts_like?+ time. Then it will return a Float of the difference
-    # between the two times that represents the difference between the current
-    # object's time and the +other+ time.
-    #
-    #   Time.zone = 'Eastern Time (US & Canada)' # => 'Eastern Time (US & Canada)'
-    #   now = Time.zone.now # => Mon, 03 Nov 2014 00:26:28.725182881 EST -05:00
-    #   now - 1000          # => Mon, 03 Nov 2014 00:09:48.725182881 EST -05:00
-    #
-    # If subtracting a Duration of variable length (i.e., years, months, days),
-    # move backward from #time, otherwise move backward from #utc, for accuracy
-    # when moving across DST boundaries.
-    #
-    # For instance, a time - 24.hours will go subtract exactly 24 hours, while a
-    # time - 1.day will subtract 23-25 hours, depending on the day.
-    #
-    #   now - 24.hours      # => Sun, 02 Nov 2014 01:26:28.725182881 EDT -04:00
-    #   now - 1.day         # => Sun, 02 Nov 2014 00:26:28.725182881 EDT -04:00
-    #
-    # If both the TimeWithZone object and the other value act like Time, a Float
-    # will be returned.
-    #
-    #   Time.zone.now - 1.day.ago # => 86399.999967
-    #
-    def -(other)
-      if other.acts_like?(:time)
-        to_time - other.to_time
-      elsif duration_of_variable_length?(other)
-        method_missing(:-, other)
-      else
-        result = utc.acts_like?(:date) ? utc.ago(other) : utc - other rescue utc.ago(other)
-        result.in_time_zone(time_zone)
-      end
-    end
-
-    # Subtracts an interval of time from the current object's time and returns
-    # the result as a new TimeWithZone object.
-    #
-    #   Time.zone = 'Eastern Time (US & Canada)' # => 'Eastern Time (US & Canada)'
-    #   now = Time.zone.now # => Mon, 03 Nov 2014 00:26:28.725182881 EST -05:00
-    #   now.ago(1000)       # => Mon, 03 Nov 2014 00:09:48.725182881 EST -05:00
-    #
-    # If we're subtracting a Duration of variable length (i.e., years, months,
-    # days), move backward from #time, otherwise move backward from #utc, for
-    # accuracy when moving across DST boundaries.
-    #
-    # For instance, <tt>time.ago(24.hours)</tt> will move back exactly 24 hours,
-    # while <tt>time.ago(1.day)</tt> will move back 23-25 hours, depending on
-    # the day.
-    #
-    #   now.ago(24.hours)   # => Sun, 02 Nov 2014 01:26:28.725182881 EDT -04:00
-    #   now.ago(1.day)      # => Sun, 02 Nov 2014 00:26:28.725182881 EDT -04:00
-    def ago(other)
-      since(-other)
-    end
-
-    # Returns a new +ActiveSupport::TimeWithZone+ where one or more of the elements have
-    # been changed according to the +options+ parameter. The time options (<tt>:hour</tt>,
-    # <tt>:min</tt>, <tt>:sec</tt>, <tt>:usec</tt>, <tt>:nsec</tt>) reset cascadingly,
-    # so if only the hour is passed, then minute, sec, usec and nsec is set to 0. If the
-    # hour and minute is passed, then sec, usec and nsec is set to 0. The +options+
-    # parameter takes a hash with any of these keys: <tt>:year</tt>, <tt>:month</tt>,
-    # <tt>:day</tt>, <tt>:hour</tt>, <tt>:min</tt>, <tt>:sec</tt>, <tt>:usec</tt>,
-    # <tt>:nsec</tt>, <tt>:offset</tt>, <tt>:zone</tt>. Pass either <tt>:usec</tt>
-    # or <tt>:nsec</tt>, not both. Similarly, pass either <tt>:zone</tt> or
-    # <tt>:offset</tt>, not both.
-    #
-    #   t = Time.zone.now          # => Fri, 14 Apr 2017 11:45:15.116992711 EST -05:00
-    #   t.change(year: 2020)       # => Tue, 14 Apr 2020 11:45:15.116992711 EST -05:00
-    #   t.change(hour: 12)         # => Fri, 14 Apr 2017 12:00:00.116992711 EST -05:00
-    #   t.change(min: 30)          # => Fri, 14 Apr 2017 11:30:00.116992711 EST -05:00
-    #   t.change(offset: "-10:00") # => Fri, 14 Apr 2017 11:45:15.116992711 HST -10:00
-    #   t.change(zone: "Hawaii")   # => Fri, 14 Apr 2017 11:45:15.116992711 HST -10:00
-    def change(options)
-      if options[:zone] && options[:offset]
-        raise ArgumentError, "Can't change both :offset and :zone at the same time: #{options.inspect}"
-      end
-
-      new_time = time.change(options)
-
-      if options[:zone]
-        new_zone = ::Time.find_zone(options[:zone])
-      elsif options[:offset]
-        new_zone = ::Time.find_zone(new_time.utc_offset)
-      end
-
-      new_zone ||= time_zone
-      periods = new_zone.periods_for_local(new_time)
-
-      self.class.new(nil, new_zone, new_time, periods.include?(period) ? period : nil)
-    end
-
-    # Uses Date to provide precise Time calculations for years, months, and days
-    # according to the proleptic Gregorian calendar. The result is returned as a
-    # new TimeWithZone object.
-    #
-    # The +options+ parameter takes a hash with any of these keys:
-    # <tt>:years</tt>, <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>,
-    # <tt>:hours</tt>, <tt>:minutes</tt>, <tt>:seconds</tt>.
-    #
-    # If advancing by a value of variable length (i.e., years, weeks, months,
-    # days), move forward from #time, otherwise move forward from #utc, for
-    # accuracy when moving across DST boundaries.
-    #
-    #   Time.zone = 'Eastern Time (US & Canada)' # => 'Eastern Time (US & Canada)'
-    #   now = Time.zone.now # => Sun, 02 Nov 2014 01:26:28.558049687 EDT -04:00
-    #   now.advance(seconds: 1) # => Sun, 02 Nov 2014 01:26:29.558049687 EDT -04:00
-    #   now.advance(minutes: 1) # => Sun, 02 Nov 2014 01:27:28.558049687 EDT -04:00
-    #   now.advance(hours: 1)   # => Sun, 02 Nov 2014 01:26:28.558049687 EST -05:00
-    #   now.advance(days: 1)    # => Mon, 03 Nov 2014 01:26:28.558049687 EST -05:00
-    #   now.advance(weeks: 1)   # => Sun, 09 Nov 2014 01:26:28.558049687 EST -05:00
-    #   now.advance(months: 1)  # => Tue, 02 Dec 2014 01:26:28.558049687 EST -05:00
-    #   now.advance(years: 1)   # => Mon, 02 Nov 2015 01:26:28.558049687 EST -05:00
-    def advance(options)
-      # If we're advancing a value of variable length (i.e., years, weeks, months, days), advance from #time,
-      # otherwise advance from #utc, for accuracy when moving across DST boundaries
-      if options.values_at(:years, :weeks, :months, :days).any?
-        method_missing(:advance, options)
-      else
-        utc.advance(options).in_time_zone(time_zone)
-      end
-    end
-
-    %w(year mon month day mday wday yday hour min sec usec nsec to_date).each do |method_name|
-      class_eval <<-EOV, __FILE__, __LINE__ + 1
-        def #{method_name}    # def month
-          time.#{method_name} #   time.month
-        end                   # end
-      EOV
-    end
-
-    # Returns Array of parts of Time in sequence of
-    # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
-    #
-    #   now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27.485278555 UTC +00:00
-    #   now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
-    def to_a
-      [time.sec, time.min, time.hour, time.day, time.mon, time.year, time.wday, time.yday, dst?, zone]
-    end
-
-    # Returns the object's date and time as a floating point number of seconds
-    # since the Epoch (January 1, 1970 00:00 UTC).
-    #
-    #   Time.zone.now.to_f # => 1417709320.285418
-    def to_f
-      utc.to_f
-    end
-
-    # Returns the object's date and time as an integer number of seconds
-    # since the Epoch (January 1, 1970 00:00 UTC).
-    #
-    #   Time.zone.now.to_i # => 1417709320
-    def to_i
-      utc.to_i
-    end
-    alias_method :tv_sec, :to_i
-
-    # Returns the object's date and time as a rational number of seconds
-    # since the Epoch (January 1, 1970 00:00 UTC).
-    #
-    #   Time.zone.now.to_r # => (708854548642709/500000)
-    def to_r
-      utc.to_r
-    end
-
-    # Returns an instance of DateTime with the timezone's UTC offset
-    #
-    #   Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
-    #   Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
-    def to_datetime
-      @to_datetime ||= utc.to_datetime.new_offset(Rational(utc_offset, 86_400))
-    end
-
-    # Returns an instance of +Time+, either with the same UTC offset
-    # as +self+ or in the local system timezone depending on the setting
-    # of +ActiveSupport.to_time_preserves_timezone+.
-    def to_time
-      if preserve_timezone
-        @to_time_with_instance_offset ||= getlocal(utc_offset)
-      else
-        @to_time_with_system_offset ||= getlocal
-      end
-    end
-
-    # So that +self+ <tt>acts_like?(:time)</tt>.
-    def acts_like_time?
-      true
-    end
-
-    # Say we're a Time to thwart type checking.
-    def is_a?(klass)
-      klass == ::Time || super
-    end
-    alias_method :kind_of?, :is_a?
-
-    # An instance of ActiveSupport::TimeWithZone is never blank
-    def blank?
-      false
-    end
-
-    def freeze
-      # preload instance variables before freezing
-      period; utc; time; to_datetime; to_time
-      super
-    end
-
-    def marshal_dump
-      [utc, time_zone.name, time]
-    end
-
-    def marshal_load(variables)
-      initialize(variables[0].utc, ::Time.find_zone(variables[1]), variables[2].utc)
-    end
-
-    # respond_to_missing? is not called in some cases, such as when type conversion is
-    # performed with Kernel#String
-    def respond_to?(sym, include_priv = false)
-      # ensure that we're not going to throw and rescue from NoMethodError in method_missing which is slow
-      return false if sym.to_sym == :to_str
-      super
-    end
-
-    # Ensure proxy class responds to all methods that underlying time instance
-    # responds to.
-    def respond_to_missing?(sym, include_priv)
-      return false if sym.to_sym == :acts_like_date?
-      time.respond_to?(sym, include_priv)
-    end
-
-    # Send the missing method to +time+ instance, and wrap result in a new
-    # TimeWithZone with the existing +time_zone+.
-    def method_missing(sym, *args, &block)
-      wrap_with_time_zone time.__send__(sym, *args, &block)
-    rescue NoMethodError => e
-      raise e, e.message.sub(time.inspect, inspect), e.backtrace
-    end
-
-    private
-      SECONDS_PER_DAY = 86400
-
-      def incorporate_utc_offset(time, offset)
-        if time.kind_of?(Date)
-          time + Rational(offset, SECONDS_PER_DAY)
-        else
-          time + offset
-        end
-      end
-
-      def get_period_and_ensure_valid_local_time(period)
-        # we don't want a Time.local instance enforcing its own DST rules as well,
-        # so transfer time values to a utc constructor if necessary
-        @time = transfer_time_values_to_utc_constructor(@time) unless @time.utc?
-        begin
-          period || @time_zone.period_for_local(@time)
-        rescue ::TZInfo::PeriodNotFound
-          # time is in the "spring forward" hour gap, so we're moving the time forward one hour and trying again
-          @time += 1.hour
-          retry
-        end
-      end
-
-      def transfer_time_values_to_utc_constructor(time)
-        # avoid creating another Time object if possible
-        return time if time.instance_of?(::Time) && time.utc?
-        ::Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
-      end
-
-      def duration_of_variable_length?(obj)
-        ActiveSupport::Duration === obj && obj.parts.any? { |p| [:years, :months, :weeks, :days].include?(p[0]) }
-      end
-
-      def wrap_with_time_zone(time)
-        if time.acts_like?(:time)
-          periods = time_zone.periods_for_local(time)
-          self.class.new(nil, time_zone, time, periods.include?(period) ? period : nil)
-        elsif time.is_a?(Range)
-          wrap_with_time_zone(time.begin)..wrap_with_time_zone(time.end)
-        else
-          time
-        end
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/values/time_zone.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/values/time_zone.rb
deleted file mode 100644
index d4160eacbee95..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/values/time_zone.rb
+++ /dev/null
@@ -1,582 +0,0 @@
-# frozen_string_literal: true
-
-require "tzinfo"
-require "concurrent/map"
-
-module ActiveSupport
-  # The TimeZone class serves as a wrapper around TZInfo::Timezone instances.
-  # It allows us to do the following:
-  #
-  # * Limit the set of zones provided by TZInfo to a meaningful subset of 134
-  #   zones.
-  # * Retrieve and display zones with a friendlier name
-  #   (e.g., "Eastern Time (US & Canada)" instead of "America/New_York").
-  # * Lazily load TZInfo::Timezone instances only when they're needed.
-  # * Create ActiveSupport::TimeWithZone instances via TimeZone's +local+,
-  #   +parse+, +at+ and +now+ methods.
-  #
-  # If you set <tt>config.time_zone</tt> in the Rails Application, you can
-  # access this TimeZone object via <tt>Time.zone</tt>:
-  #
-  #   # application.rb:
-  #   class Application < Rails::Application
-  #     config.time_zone = 'Eastern Time (US & Canada)'
-  #   end
-  #
-  #   Time.zone      # => #<ActiveSupport::TimeZone:0x514834...>
-  #   Time.zone.name # => "Eastern Time (US & Canada)"
-  #   Time.zone.now  # => Sun, 18 May 2008 14:30:44 EDT -04:00
-  class TimeZone
-    # Keys are Rails TimeZone names, values are TZInfo identifiers.
-    MAPPING = {
-      "International Date Line West" => "Etc/GMT+12",
-      "Midway Island"                => "Pacific/Midway",
-      "American Samoa"               => "Pacific/Pago_Pago",
-      "Hawaii"                       => "Pacific/Honolulu",
-      "Alaska"                       => "America/Juneau",
-      "Pacific Time (US & Canada)"   => "America/Los_Angeles",
-      "Tijuana"                      => "America/Tijuana",
-      "Mountain Time (US & Canada)"  => "America/Denver",
-      "Arizona"                      => "America/Phoenix",
-      "Chihuahua"                    => "America/Chihuahua",
-      "Mazatlan"                     => "America/Mazatlan",
-      "Central Time (US & Canada)"   => "America/Chicago",
-      "Saskatchewan"                 => "America/Regina",
-      "Guadalajara"                  => "America/Mexico_City",
-      "Mexico City"                  => "America/Mexico_City",
-      "Monterrey"                    => "America/Monterrey",
-      "Central America"              => "America/Guatemala",
-      "Eastern Time (US & Canada)"   => "America/New_York",
-      "Indiana (East)"               => "America/Indiana/Indianapolis",
-      "Bogota"                       => "America/Bogota",
-      "Lima"                         => "America/Lima",
-      "Quito"                        => "America/Lima",
-      "Atlantic Time (Canada)"       => "America/Halifax",
-      "Caracas"                      => "America/Caracas",
-      "La Paz"                       => "America/La_Paz",
-      "Santiago"                     => "America/Santiago",
-      "Newfoundland"                 => "America/St_Johns",
-      "Brasilia"                     => "America/Sao_Paulo",
-      "Buenos Aires"                 => "America/Argentina/Buenos_Aires",
-      "Montevideo"                   => "America/Montevideo",
-      "Georgetown"                   => "America/Guyana",
-      "Puerto Rico"                  => "America/Puerto_Rico",
-      "Greenland"                    => "America/Godthab",
-      "Mid-Atlantic"                 => "Atlantic/South_Georgia",
-      "Azores"                       => "Atlantic/Azores",
-      "Cape Verde Is."               => "Atlantic/Cape_Verde",
-      "Dublin"                       => "Europe/Dublin",
-      "Edinburgh"                    => "Europe/London",
-      "Lisbon"                       => "Europe/Lisbon",
-      "London"                       => "Europe/London",
-      "Casablanca"                   => "Africa/Casablanca",
-      "Monrovia"                     => "Africa/Monrovia",
-      "UTC"                          => "Etc/UTC",
-      "Belgrade"                     => "Europe/Belgrade",
-      "Bratislava"                   => "Europe/Bratislava",
-      "Budapest"                     => "Europe/Budapest",
-      "Ljubljana"                    => "Europe/Ljubljana",
-      "Prague"                       => "Europe/Prague",
-      "Sarajevo"                     => "Europe/Sarajevo",
-      "Skopje"                       => "Europe/Skopje",
-      "Warsaw"                       => "Europe/Warsaw",
-      "Zagreb"                       => "Europe/Zagreb",
-      "Brussels"                     => "Europe/Brussels",
-      "Copenhagen"                   => "Europe/Copenhagen",
-      "Madrid"                       => "Europe/Madrid",
-      "Paris"                        => "Europe/Paris",
-      "Amsterdam"                    => "Europe/Amsterdam",
-      "Berlin"                       => "Europe/Berlin",
-      "Bern"                         => "Europe/Zurich",
-      "Zurich"                       => "Europe/Zurich",
-      "Rome"                         => "Europe/Rome",
-      "Stockholm"                    => "Europe/Stockholm",
-      "Vienna"                       => "Europe/Vienna",
-      "West Central Africa"          => "Africa/Algiers",
-      "Bucharest"                    => "Europe/Bucharest",
-      "Cairo"                        => "Africa/Cairo",
-      "Helsinki"                     => "Europe/Helsinki",
-      "Kyiv"                         => "Europe/Kiev",
-      "Riga"                         => "Europe/Riga",
-      "Sofia"                        => "Europe/Sofia",
-      "Tallinn"                      => "Europe/Tallinn",
-      "Vilnius"                      => "Europe/Vilnius",
-      "Athens"                       => "Europe/Athens",
-      "Istanbul"                     => "Europe/Istanbul",
-      "Minsk"                        => "Europe/Minsk",
-      "Jerusalem"                    => "Asia/Jerusalem",
-      "Harare"                       => "Africa/Harare",
-      "Pretoria"                     => "Africa/Johannesburg",
-      "Kaliningrad"                  => "Europe/Kaliningrad",
-      "Moscow"                       => "Europe/Moscow",
-      "St. Petersburg"               => "Europe/Moscow",
-      "Volgograd"                    => "Europe/Volgograd",
-      "Samara"                       => "Europe/Samara",
-      "Kuwait"                       => "Asia/Kuwait",
-      "Riyadh"                       => "Asia/Riyadh",
-      "Nairobi"                      => "Africa/Nairobi",
-      "Baghdad"                      => "Asia/Baghdad",
-      "Tehran"                       => "Asia/Tehran",
-      "Abu Dhabi"                    => "Asia/Muscat",
-      "Muscat"                       => "Asia/Muscat",
-      "Baku"                         => "Asia/Baku",
-      "Tbilisi"                      => "Asia/Tbilisi",
-      "Yerevan"                      => "Asia/Yerevan",
-      "Kabul"                        => "Asia/Kabul",
-      "Ekaterinburg"                 => "Asia/Yekaterinburg",
-      "Islamabad"                    => "Asia/Karachi",
-      "Karachi"                      => "Asia/Karachi",
-      "Tashkent"                     => "Asia/Tashkent",
-      "Chennai"                      => "Asia/Kolkata",
-      "Kolkata"                      => "Asia/Kolkata",
-      "Mumbai"                       => "Asia/Kolkata",
-      "New Delhi"                    => "Asia/Kolkata",
-      "Kathmandu"                    => "Asia/Kathmandu",
-      "Astana"                       => "Asia/Dhaka",
-      "Dhaka"                        => "Asia/Dhaka",
-      "Sri Jayawardenepura"          => "Asia/Colombo",
-      "Almaty"                       => "Asia/Almaty",
-      "Novosibirsk"                  => "Asia/Novosibirsk",
-      "Rangoon"                      => "Asia/Rangoon",
-      "Bangkok"                      => "Asia/Bangkok",
-      "Hanoi"                        => "Asia/Bangkok",
-      "Jakarta"                      => "Asia/Jakarta",
-      "Krasnoyarsk"                  => "Asia/Krasnoyarsk",
-      "Beijing"                      => "Asia/Shanghai",
-      "Chongqing"                    => "Asia/Chongqing",
-      "Hong Kong"                    => "Asia/Hong_Kong",
-      "Urumqi"                       => "Asia/Urumqi",
-      "Kuala Lumpur"                 => "Asia/Kuala_Lumpur",
-      "Singapore"                    => "Asia/Singapore",
-      "Taipei"                       => "Asia/Taipei",
-      "Perth"                        => "Australia/Perth",
-      "Irkutsk"                      => "Asia/Irkutsk",
-      "Ulaanbaatar"                  => "Asia/Ulaanbaatar",
-      "Seoul"                        => "Asia/Seoul",
-      "Osaka"                        => "Asia/Tokyo",
-      "Sapporo"                      => "Asia/Tokyo",
-      "Tokyo"                        => "Asia/Tokyo",
-      "Yakutsk"                      => "Asia/Yakutsk",
-      "Darwin"                       => "Australia/Darwin",
-      "Adelaide"                     => "Australia/Adelaide",
-      "Canberra"                     => "Australia/Melbourne",
-      "Melbourne"                    => "Australia/Melbourne",
-      "Sydney"                       => "Australia/Sydney",
-      "Brisbane"                     => "Australia/Brisbane",
-      "Hobart"                       => "Australia/Hobart",
-      "Vladivostok"                  => "Asia/Vladivostok",
-      "Guam"                         => "Pacific/Guam",
-      "Port Moresby"                 => "Pacific/Port_Moresby",
-      "Magadan"                      => "Asia/Magadan",
-      "Srednekolymsk"                => "Asia/Srednekolymsk",
-      "Solomon Is."                  => "Pacific/Guadalcanal",
-      "New Caledonia"                => "Pacific/Noumea",
-      "Fiji"                         => "Pacific/Fiji",
-      "Kamchatka"                    => "Asia/Kamchatka",
-      "Marshall Is."                 => "Pacific/Majuro",
-      "Auckland"                     => "Pacific/Auckland",
-      "Wellington"                   => "Pacific/Auckland",
-      "Nuku'alofa"                   => "Pacific/Tongatapu",
-      "Tokelau Is."                  => "Pacific/Fakaofo",
-      "Chatham Is."                  => "Pacific/Chatham",
-      "Samoa"                        => "Pacific/Apia"
-    }
-
-    UTC_OFFSET_WITH_COLON = "%s%02d:%02d" # :nodoc:
-    UTC_OFFSET_WITHOUT_COLON = UTC_OFFSET_WITH_COLON.tr(":", "") # :nodoc:
-    private_constant :UTC_OFFSET_WITH_COLON, :UTC_OFFSET_WITHOUT_COLON
-
-    @lazy_zones_map = Concurrent::Map.new
-    @country_zones  = Concurrent::Map.new
-
-    class << self
-      # Assumes self represents an offset from UTC in seconds (as returned from
-      # Time#utc_offset) and turns this into an +HH:MM formatted string.
-      #
-      #   ActiveSupport::TimeZone.seconds_to_utc_offset(-21_600) # => "-06:00"
-      def seconds_to_utc_offset(seconds, colon = true)
-        format = colon ? UTC_OFFSET_WITH_COLON : UTC_OFFSET_WITHOUT_COLON
-        sign = (seconds < 0 ? "-" : "+")
-        hours = seconds.abs / 3600
-        minutes = (seconds.abs % 3600) / 60
-        format % [sign, hours, minutes]
-      end
-
-      def find_tzinfo(name)
-        TZInfo::Timezone.get(MAPPING[name] || name)
-      end
-
-      alias_method :create, :new
-
-      # Returns a TimeZone instance with the given name, or +nil+ if no
-      # such TimeZone instance exists. (This exists to support the use of
-      # this class with the +composed_of+ macro.)
-      def new(name)
-        self[name]
-      end
-
-      # Returns an array of all TimeZone objects. There are multiple
-      # TimeZone objects per time zone, in many cases, to make it easier
-      # for users to find their own time zone.
-      def all
-        @zones ||= zones_map.values.sort
-      end
-
-      # Locate a specific time zone object. If the argument is a string, it
-      # is interpreted to mean the name of the timezone to locate. If it is a
-      # numeric value it is either the hour offset, or the second offset, of the
-      # timezone to find. (The first one with that offset will be returned.)
-      # Returns +nil+ if no such time zone is known to the system.
-      def [](arg)
-        case arg
-        when String
-          begin
-            @lazy_zones_map[arg] ||= create(arg)
-          rescue TZInfo::InvalidTimezoneIdentifier
-            nil
-          end
-        when Numeric, ActiveSupport::Duration
-          arg *= 3600 if arg.abs <= 13
-          all.find { |z| z.utc_offset == arg.to_i }
-        else
-          raise ArgumentError, "invalid argument to TimeZone[]: #{arg.inspect}"
-        end
-      end
-
-      # A convenience method for returning a collection of TimeZone objects
-      # for time zones in the USA.
-      def us_zones
-        country_zones(:us)
-      end
-
-      # A convenience method for returning a collection of TimeZone objects
-      # for time zones in the country specified by its ISO 3166-1 Alpha2 code.
-      def country_zones(country_code)
-        code = country_code.to_s.upcase
-        @country_zones[code] ||= load_country_zones(code)
-      end
-
-      def clear #:nodoc:
-        @lazy_zones_map = Concurrent::Map.new
-        @country_zones  = Concurrent::Map.new
-        @zones = nil
-        @zones_map = nil
-      end
-
-      private
-        def load_country_zones(code)
-          country = TZInfo::Country.get(code)
-          country.zone_identifiers.flat_map do |tz_id|
-            if MAPPING.value?(tz_id)
-              MAPPING.inject([]) do |memo, (key, value)|
-                memo << self[key] if value == tz_id
-                memo
-              end
-            else
-              create(tz_id, nil, TZInfo::Timezone.get(tz_id))
-            end
-          end.sort!
-        end
-
-        def zones_map
-          @zones_map ||= MAPPING.each_with_object({}) do |(name, _), zones|
-            timezone = self[name]
-            zones[name] = timezone if timezone
-          end
-        end
-    end
-
-    include Comparable
-    attr_reader :name
-    attr_reader :tzinfo
-
-    # Create a new TimeZone object with the given name and offset. The
-    # offset is the number of seconds that this time zone is offset from UTC
-    # (GMT). Seconds were chosen as the offset unit because that is the unit
-    # that Ruby uses to represent time zone offsets (see Time#utc_offset).
-    def initialize(name, utc_offset = nil, tzinfo = nil)
-      @name = name
-      @utc_offset = utc_offset
-      @tzinfo = tzinfo || TimeZone.find_tzinfo(name)
-    end
-
-    # Returns the offset of this time zone from UTC in seconds.
-    def utc_offset
-      @utc_offset || tzinfo&.current_period&.base_utc_offset
-    end
-
-    # Returns a formatted string of the offset from UTC, or an alternative
-    # string if the time zone is already UTC.
-    #
-    #   zone = ActiveSupport::TimeZone['Central Time (US & Canada)']
-    #   zone.formatted_offset        # => "-06:00"
-    #   zone.formatted_offset(false) # => "-0600"
-    def formatted_offset(colon = true, alternate_utc_string = nil)
-      utc_offset == 0 && alternate_utc_string || self.class.seconds_to_utc_offset(utc_offset, colon)
-    end
-
-    # Compare this time zone to the parameter. The two are compared first on
-    # their offsets, and then by name.
-    def <=>(zone)
-      return unless zone.respond_to? :utc_offset
-      result = (utc_offset <=> zone.utc_offset)
-      result = (name <=> zone.name) if result == 0
-      result
-    end
-
-    # Compare #name and TZInfo identifier to a supplied regexp, returning +true+
-    # if a match is found.
-    def =~(re)
-      re === name || re === MAPPING[name]
-    end
-
-    # Compare #name and TZInfo identifier to a supplied regexp, returning +true+
-    # if a match is found.
-    def match?(re)
-      (re == name) || (re == MAPPING[name]) ||
-        ((Regexp === re) && (re.match?(name) || re.match?(MAPPING[name])))
-    end
-
-    # Returns a textual representation of this time zone.
-    def to_s
-      "(GMT#{formatted_offset}) #{name}"
-    end
-
-    # Method for creating new ActiveSupport::TimeWithZone instance in time zone
-    # of +self+ from given values.
-    #
-    #   Time.zone = 'Hawaii'                    # => "Hawaii"
-    #   Time.zone.local(2007, 2, 1, 15, 30, 45) # => Thu, 01 Feb 2007 15:30:45 HST -10:00
-    def local(*args)
-      time = Time.utc(*args)
-      ActiveSupport::TimeWithZone.new(nil, self, time)
-    end
-
-    # Method for creating new ActiveSupport::TimeWithZone instance in time zone
-    # of +self+ from number of seconds since the Unix epoch.
-    #
-    #   Time.zone = 'Hawaii'        # => "Hawaii"
-    #   Time.utc(2000).to_f         # => 946684800.0
-    #   Time.zone.at(946684800.0)   # => Fri, 31 Dec 1999 14:00:00 HST -10:00
-    #
-    # A second argument can be supplied to specify sub-second precision.
-    #
-    #   Time.zone = 'Hawaii'                # => "Hawaii"
-    #   Time.at(946684800, 123456.789).nsec # => 123456789
-    def at(*args)
-      Time.at(*args).utc.in_time_zone(self)
-    end
-
-    # Method for creating new ActiveSupport::TimeWithZone instance in time zone
-    # of +self+ from an ISO 8601 string.
-    #
-    #   Time.zone = 'Hawaii'                     # => "Hawaii"
-    #   Time.zone.iso8601('1999-12-31T14:00:00') # => Fri, 31 Dec 1999 14:00:00 HST -10:00
-    #
-    # If the time components are missing then they will be set to zero.
-    #
-    #   Time.zone = 'Hawaii'            # => "Hawaii"
-    #   Time.zone.iso8601('1999-12-31') # => Fri, 31 Dec 1999 00:00:00 HST -10:00
-    #
-    # If the string is invalid then an +ArgumentError+ will be raised unlike +parse+
-    # which usually returns +nil+ when given an invalid date string.
-    def iso8601(str)
-      raise ArgumentError, "invalid date" if str.nil?
-
-      parts = Date._iso8601(str)
-
-      raise ArgumentError, "invalid date" if parts.empty?
-
-      time = Time.new(
-        parts.fetch(:year),
-        parts.fetch(:mon),
-        parts.fetch(:mday),
-        parts.fetch(:hour, 0),
-        parts.fetch(:min, 0),
-        parts.fetch(:sec, 0) + parts.fetch(:sec_fraction, 0),
-        parts.fetch(:offset, 0)
-      )
-
-      if parts[:offset]
-        TimeWithZone.new(time.utc, self)
-      else
-        TimeWithZone.new(nil, self, time)
-      end
-    end
-
-    # Method for creating new ActiveSupport::TimeWithZone instance in time zone
-    # of +self+ from parsed string.
-    #
-    #   Time.zone = 'Hawaii'                   # => "Hawaii"
-    #   Time.zone.parse('1999-12-31 14:00:00') # => Fri, 31 Dec 1999 14:00:00 HST -10:00
-    #
-    # If upper components are missing from the string, they are supplied from
-    # TimeZone#now:
-    #
-    #   Time.zone.now               # => Fri, 31 Dec 1999 14:00:00 HST -10:00
-    #   Time.zone.parse('22:30:00') # => Fri, 31 Dec 1999 22:30:00 HST -10:00
-    #
-    # However, if the date component is not provided, but any other upper
-    # components are supplied, then the day of the month defaults to 1:
-    #
-    #   Time.zone.parse('Mar 2000') # => Wed, 01 Mar 2000 00:00:00 HST -10:00
-    #
-    # If the string is invalid then an +ArgumentError+ could be raised.
-    def parse(str, now = now())
-      parts_to_time(Date._parse(str, false), now)
-    end
-
-    # Method for creating new ActiveSupport::TimeWithZone instance in time zone
-    # of +self+ from an RFC 3339 string.
-    #
-    #   Time.zone = 'Hawaii'                     # => "Hawaii"
-    #   Time.zone.rfc3339('2000-01-01T00:00:00Z') # => Fri, 31 Dec 1999 14:00:00 HST -10:00
-    #
-    # If the time or zone components are missing then an +ArgumentError+ will
-    # be raised. This is much stricter than either +parse+ or +iso8601+ which
-    # allow for missing components.
-    #
-    #   Time.zone = 'Hawaii'            # => "Hawaii"
-    #   Time.zone.rfc3339('1999-12-31') # => ArgumentError: invalid date
-    def rfc3339(str)
-      parts = Date._rfc3339(str)
-
-      raise ArgumentError, "invalid date" if parts.empty?
-
-      time = Time.new(
-        parts.fetch(:year),
-        parts.fetch(:mon),
-        parts.fetch(:mday),
-        parts.fetch(:hour),
-        parts.fetch(:min),
-        parts.fetch(:sec) + parts.fetch(:sec_fraction, 0),
-        parts.fetch(:offset)
-      )
-
-      TimeWithZone.new(time.utc, self)
-    end
-
-    # Parses +str+ according to +format+ and returns an ActiveSupport::TimeWithZone.
-    #
-    # Assumes that +str+ is a time in the time zone +self+,
-    # unless +format+ includes an explicit time zone.
-    # (This is the same behavior as +parse+.)
-    # In either case, the returned TimeWithZone has the timezone of +self+.
-    #
-    #   Time.zone = 'Hawaii'                   # => "Hawaii"
-    #   Time.zone.strptime('1999-12-31 14:00:00', '%Y-%m-%d %H:%M:%S') # => Fri, 31 Dec 1999 14:00:00 HST -10:00
-    #
-    # If upper components are missing from the string, they are supplied from
-    # TimeZone#now:
-    #
-    #   Time.zone.now                              # => Fri, 31 Dec 1999 14:00:00 HST -10:00
-    #   Time.zone.strptime('22:30:00', '%H:%M:%S') # => Fri, 31 Dec 1999 22:30:00 HST -10:00
-    #
-    # However, if the date component is not provided, but any other upper
-    # components are supplied, then the day of the month defaults to 1:
-    #
-    #   Time.zone.strptime('Mar 2000', '%b %Y') # => Wed, 01 Mar 2000 00:00:00 HST -10:00
-    def strptime(str, format, now = now())
-      parts_to_time(DateTime._strptime(str, format), now)
-    end
-
-    # Returns an ActiveSupport::TimeWithZone instance representing the current
-    # time in the time zone represented by +self+.
-    #
-    #   Time.zone = 'Hawaii'  # => "Hawaii"
-    #   Time.zone.now         # => Wed, 23 Jan 2008 20:24:27 HST -10:00
-    def now
-      time_now.utc.in_time_zone(self)
-    end
-
-    # Returns the current date in this time zone.
-    def today
-      tzinfo.now.to_date
-    end
-
-    # Returns the next date in this time zone.
-    def tomorrow
-      today + 1
-    end
-
-    # Returns the previous date in this time zone.
-    def yesterday
-      today - 1
-    end
-
-    # Adjust the given time to the simultaneous time in the time zone
-    # represented by +self+. Returns a local time with the appropriate offset
-    # -- if you want an ActiveSupport::TimeWithZone instance, use
-    # Time#in_time_zone() instead.
-    #
-    # As of tzinfo 2, utc_to_local returns a Time with a non-zero utc_offset.
-    # See the +utc_to_local_returns_utc_offset_times+ config for more info.
-    def utc_to_local(time)
-      tzinfo.utc_to_local(time).yield_self do |t|
-        ActiveSupport.utc_to_local_returns_utc_offset_times ?
-          t : Time.utc(t.year, t.month, t.day, t.hour, t.min, t.sec, t.sec_fraction)
-      end
-    end
-
-    # Adjust the given time to the simultaneous time in UTC. Returns a
-    # Time.utc() instance.
-    def local_to_utc(time, dst = true)
-      tzinfo.local_to_utc(time, dst)
-    end
-
-    # Available so that TimeZone instances respond like TZInfo::Timezone
-    # instances.
-    def period_for_utc(time)
-      tzinfo.period_for_utc(time)
-    end
-
-    # Available so that TimeZone instances respond like TZInfo::Timezone
-    # instances.
-    def period_for_local(time, dst = true)
-      tzinfo.period_for_local(time, dst) { |periods| periods.last }
-    end
-
-    def periods_for_local(time) #:nodoc:
-      tzinfo.periods_for_local(time)
-    end
-
-    def init_with(coder) #:nodoc:
-      initialize(coder["name"])
-    end
-
-    def encode_with(coder) #:nodoc:
-      coder.tag = "!ruby/object:#{self.class}"
-      coder.map = { "name" => tzinfo.name }
-    end
-
-    private
-      def parts_to_time(parts, now)
-        raise ArgumentError, "invalid date" if parts.nil?
-        return if parts.empty?
-
-        if parts[:seconds]
-          time = Time.at(parts[:seconds])
-        else
-          time = Time.new(
-            parts.fetch(:year, now.year),
-            parts.fetch(:mon, now.month),
-            parts.fetch(:mday, parts[:year] || parts[:mon] ? 1 : now.day),
-            parts.fetch(:hour, 0),
-            parts.fetch(:min, 0),
-            parts.fetch(:sec, 0) + parts.fetch(:sec_fraction, 0),
-            parts.fetch(:offset, 0)
-          )
-        end
-
-        if parts[:offset] || parts[:seconds]
-          TimeWithZone.new(time.utc, self)
-        else
-          TimeWithZone.new(nil, self, time)
-        end
-      end
-
-      def time_now
-        Time.now
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/version.rb
deleted file mode 100644
index 928838c837144..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/version.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "gem_version"
-
-module ActiveSupport
-  # Returns the version of the currently loaded ActiveSupport as a <tt>Gem::Version</tt>
-  def self.version
-    gem_version
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini.rb
deleted file mode 100644
index f6ae08bb5db07..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini.rb
+++ /dev/null
@@ -1,201 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-require "base64"
-require "bigdecimal"
-require "bigdecimal/util"
-require "active_support/core_ext/module/delegation"
-require "active_support/core_ext/string/inflections"
-require "active_support/core_ext/date_time/calculations"
-
-module ActiveSupport
-  # = XmlMini
-  #
-  # To use the much faster libxml parser:
-  #   gem 'libxml-ruby', '=0.9.7'
-  #   XmlMini.backend = 'LibXML'
-  module XmlMini
-    extend self
-
-    # This module decorates files deserialized using Hash.from_xml with
-    # the <tt>original_filename</tt> and <tt>content_type</tt> methods.
-    module FileLike #:nodoc:
-      attr_writer :original_filename, :content_type
-
-      def original_filename
-        @original_filename || "untitled"
-      end
-
-      def content_type
-        @content_type || "application/octet-stream"
-      end
-    end
-
-    DEFAULT_ENCODINGS = {
-      "binary" => "base64"
-    } unless defined?(DEFAULT_ENCODINGS)
-
-    unless defined?(TYPE_NAMES)
-      TYPE_NAMES = {
-        "Symbol"     => "symbol",
-        "Integer"    => "integer",
-        "BigDecimal" => "decimal",
-        "Float"      => "float",
-        "TrueClass"  => "boolean",
-        "FalseClass" => "boolean",
-        "Date"       => "date",
-        "DateTime"   => "dateTime",
-        "Time"       => "dateTime",
-        "Array"      => "array",
-        "Hash"       => "hash"
-      }
-    end
-
-    FORMATTING = {
-      "symbol"   => Proc.new { |symbol| symbol.to_s },
-      "date"     => Proc.new { |date| date.to_s(:db) },
-      "dateTime" => Proc.new { |time| time.xmlschema },
-      "binary"   => Proc.new { |binary| ::Base64.encode64(binary) },
-      "yaml"     => Proc.new { |yaml| yaml.to_yaml }
-    } unless defined?(FORMATTING)
-
-    # TODO use regexp instead of Date.parse
-    unless defined?(PARSING)
-      PARSING = {
-        "symbol"       => Proc.new { |symbol|  symbol.to_s.to_sym },
-        "date"         => Proc.new { |date|    ::Date.parse(date) },
-        "datetime"     => Proc.new { |time|    Time.xmlschema(time).utc rescue ::DateTime.parse(time).utc },
-        "integer"      => Proc.new { |integer| integer.to_i },
-        "float"        => Proc.new { |float|   float.to_f },
-        "decimal"      => Proc.new do |number|
-          if String === number
-            number.to_d
-          else
-            BigDecimal(number)
-          end
-        end,
-        "boolean"      => Proc.new { |boolean| %w(1 true).include?(boolean.to_s.strip) },
-        "string"       => Proc.new { |string|  string.to_s },
-        "yaml"         => Proc.new { |yaml|    YAML.load(yaml) rescue yaml },
-        "base64Binary" => Proc.new { |bin|     ::Base64.decode64(bin) },
-        "binary"       => Proc.new { |bin, entity| _parse_binary(bin, entity) },
-        "file"         => Proc.new { |file, entity| _parse_file(file, entity) }
-      }
-
-      PARSING.update(
-        "double"   => PARSING["float"],
-        "dateTime" => PARSING["datetime"]
-      )
-    end
-
-    attr_accessor :depth
-    self.depth = 100
-
-    delegate :parse, to: :backend
-
-    def backend
-      current_thread_backend || @backend
-    end
-
-    def backend=(name)
-      backend = name && cast_backend_name_to_module(name)
-      self.current_thread_backend = backend if current_thread_backend
-      @backend = backend
-    end
-
-    def with_backend(name)
-      old_backend = current_thread_backend
-      self.current_thread_backend = name && cast_backend_name_to_module(name)
-      yield
-    ensure
-      self.current_thread_backend = old_backend
-    end
-
-    def to_tag(key, value, options)
-      type_name = options.delete(:type)
-      merged_options = options.merge(root: key, skip_instruct: true)
-
-      if value.is_a?(::Method) || value.is_a?(::Proc)
-        if value.arity == 1
-          value.call(merged_options)
-        else
-          value.call(merged_options, key.to_s.singularize)
-        end
-      elsif value.respond_to?(:to_xml)
-        value.to_xml(merged_options)
-      else
-        type_name ||= TYPE_NAMES[value.class.name]
-        type_name ||= value.class.name if value && !value.respond_to?(:to_str)
-        type_name   = type_name.to_s   if type_name
-        type_name   = "dateTime" if type_name == "datetime"
-
-        key = rename_key(key.to_s, options)
-
-        attributes = options[:skip_types] || type_name.nil? ? {} : { type: type_name }
-        attributes[:nil] = true if value.nil?
-
-        encoding = options[:encoding] || DEFAULT_ENCODINGS[type_name]
-        attributes[:encoding] = encoding if encoding
-
-        formatted_value = FORMATTING[type_name] && !value.nil? ?
-          FORMATTING[type_name].call(value) : value
-
-        options[:builder].tag!(key, formatted_value, attributes)
-      end
-    end
-
-    def rename_key(key, options = {})
-      camelize  = options[:camelize]
-      dasherize = !options.has_key?(:dasherize) || options[:dasherize]
-      if camelize
-        key = true == camelize ? key.camelize : key.camelize(camelize)
-      end
-      key = _dasherize(key) if dasherize
-      key
-    end
-
-    private
-      def _dasherize(key)
-        # $2 must be a non-greedy regex for this to work
-        left, middle, right = /\A(_*)(.*?)(_*)\Z/.match(key.strip)[1, 3]
-        "#{left}#{middle.tr('_ ', '--')}#{right}"
-      end
-
-      # TODO: Add support for other encodings
-      def _parse_binary(bin, entity)
-        case entity["encoding"]
-        when "base64"
-          ::Base64.decode64(bin)
-        else
-          bin
-        end
-      end
-
-      def _parse_file(file, entity)
-        f = StringIO.new(::Base64.decode64(file))
-        f.extend(FileLike)
-        f.original_filename = entity["name"]
-        f.content_type = entity["content_type"]
-        f
-      end
-
-      def current_thread_backend
-        Thread.current[:xml_mini_backend]
-      end
-
-      def current_thread_backend=(name)
-        Thread.current[:xml_mini_backend] = name && cast_backend_name_to_module(name)
-      end
-
-      def cast_backend_name_to_module(name)
-        if name.is_a?(Module)
-          name
-        else
-          require "active_support/xml_mini/#{name.downcase}"
-          ActiveSupport.const_get("XmlMini_#{name}")
-        end
-      end
-  end
-
-  XmlMini.backend = "REXML"
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/jdom.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/jdom.rb
deleted file mode 100644
index 12ca19a76fc95..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/jdom.rb
+++ /dev/null
@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-
-raise "JRuby is required to use the JDOM backend for XmlMini" unless RUBY_PLATFORM.include?("java")
-
-require "jruby"
-include Java
-
-require "active_support/core_ext/object/blank"
-
-java_import javax.xml.parsers.DocumentBuilder unless defined? DocumentBuilder
-java_import javax.xml.parsers.DocumentBuilderFactory unless defined? DocumentBuilderFactory
-java_import java.io.StringReader unless defined? StringReader
-java_import org.xml.sax.InputSource unless defined? InputSource
-java_import org.xml.sax.Attributes unless defined? Attributes
-java_import org.w3c.dom.Node unless defined? Node
-
-module ActiveSupport
-  module XmlMini_JDOM #:nodoc:
-    extend self
-
-    CONTENT_KEY = "__content__"
-
-    NODE_TYPE_NAMES = %w{ATTRIBUTE_NODE CDATA_SECTION_NODE COMMENT_NODE DOCUMENT_FRAGMENT_NODE
-    DOCUMENT_NODE DOCUMENT_TYPE_NODE ELEMENT_NODE ENTITY_NODE ENTITY_REFERENCE_NODE NOTATION_NODE
-    PROCESSING_INSTRUCTION_NODE TEXT_NODE}
-
-    node_type_map = {}
-    NODE_TYPE_NAMES.each { |type| node_type_map[Node.send(type)] = type }
-
-    # Parse an XML Document string or IO into a simple hash using Java's jdom.
-    # data::
-    #   XML Document string or IO to parse
-    def parse(data)
-      if data.respond_to?(:read)
-        data = data.read
-      end
-
-      if data.blank?
-        {}
-      else
-        @dbf = DocumentBuilderFactory.new_instance
-        # secure processing of java xml
-        # https://archive.is/9xcQQ
-        @dbf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false)
-        @dbf.setFeature("http://xml.org/sax/features/external-general-entities", false)
-        @dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false)
-        @dbf.setFeature(javax.xml.XMLConstants::FEATURE_SECURE_PROCESSING, true)
-        xml_string_reader = StringReader.new(data)
-        xml_input_source = InputSource.new(xml_string_reader)
-        doc = @dbf.new_document_builder.parse(xml_input_source)
-        merge_element!({ CONTENT_KEY => "" }, doc.document_element, XmlMini.depth)
-      end
-    end
-
-    private
-      # Convert an XML element and merge into the hash
-      #
-      # hash::
-      #   Hash to merge the converted element into.
-      # element::
-      #   XML element to merge into hash
-      def merge_element!(hash, element, depth)
-        raise "Document too deep!" if depth == 0
-        delete_empty(hash)
-        merge!(hash, element.tag_name, collapse(element, depth))
-      end
-
-      def delete_empty(hash)
-        hash.delete(CONTENT_KEY) if hash[CONTENT_KEY] == ""
-      end
-
-      # Actually converts an XML document element into a data structure.
-      #
-      # element::
-      #   The document element to be collapsed.
-      def collapse(element, depth)
-        hash = get_attributes(element)
-
-        child_nodes = element.child_nodes
-        if child_nodes.length > 0
-          (0...child_nodes.length).each do |i|
-            child = child_nodes.item(i)
-            merge_element!(hash, child, depth - 1) unless child.node_type == Node.TEXT_NODE
-          end
-          merge_texts!(hash, element) unless empty_content?(element)
-          hash
-        else
-          merge_texts!(hash, element)
-        end
-      end
-
-      # Merge all the texts of an element into the hash
-      #
-      # hash::
-      #   Hash to add the converted element to.
-      # element::
-      #   XML element whose texts are to me merged into the hash
-      def merge_texts!(hash, element)
-        delete_empty(hash)
-        text_children = texts(element)
-        if text_children.join.empty?
-          hash
-        else
-          # must use value to prevent double-escaping
-          merge!(hash, CONTENT_KEY, text_children.join)
-        end
-      end
-
-      # Adds a new key/value pair to an existing Hash. If the key to be added
-      # already exists and the existing value associated with key is not
-      # an Array, it will be wrapped in an Array. Then the new value is
-      # appended to that Array.
-      #
-      # hash::
-      #   Hash to add key/value pair to.
-      # key::
-      #   Key to be added.
-      # value::
-      #   Value to be associated with key.
-      def merge!(hash, key, value)
-        if hash.has_key?(key)
-          if hash[key].instance_of?(Array)
-            hash[key] << value
-          else
-            hash[key] = [hash[key], value]
-          end
-        elsif value.instance_of?(Array)
-          hash[key] = [value]
-        else
-          hash[key] = value
-        end
-        hash
-      end
-
-      # Converts the attributes array of an XML element into a hash.
-      # Returns an empty Hash if node has no attributes.
-      #
-      # element::
-      #   XML element to extract attributes from.
-      def get_attributes(element)
-        attribute_hash = {}
-        attributes = element.attributes
-        (0...attributes.length).each do |i|
-          attribute_hash[CONTENT_KEY] ||= ""
-          attribute_hash[attributes.item(i).name] = attributes.item(i).value
-        end
-        attribute_hash
-      end
-
-      # Determines if a document element has text content
-      #
-      # element::
-      #   XML element to be checked.
-      def texts(element)
-        texts = []
-        child_nodes = element.child_nodes
-        (0...child_nodes.length).each do |i|
-          item = child_nodes.item(i)
-          if item.node_type == Node.TEXT_NODE
-            texts << item.get_data
-          end
-        end
-        texts
-      end
-
-      # Determines if a document element has text content
-      #
-      # element::
-      #   XML element to be checked.
-      def empty_content?(element)
-        text = +""
-        child_nodes = element.child_nodes
-        (0...child_nodes.length).each do |i|
-          item = child_nodes.item(i)
-          if item.node_type == Node.TEXT_NODE
-            text << item.get_data.strip
-          end
-        end
-        text.strip.length == 0
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/libxml.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/libxml.rb
deleted file mode 100644
index c2e999ef6cdc0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/libxml.rb
+++ /dev/null
@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require "libxml"
-require "active_support/core_ext/object/blank"
-require "stringio"
-
-module ActiveSupport
-  module XmlMini_LibXML #:nodoc:
-    extend self
-
-    # Parse an XML Document string or IO into a simple hash using libxml.
-    # data::
-    #   XML Document string or IO to parse
-    def parse(data)
-      if !data.respond_to?(:read)
-        data = StringIO.new(data || "")
-      end
-
-      if data.eof?
-        {}
-      else
-        LibXML::XML::Parser.io(data).parse.to_hash
-      end
-    end
-  end
-end
-
-module LibXML #:nodoc:
-  module Conversions #:nodoc:
-    module Document #:nodoc:
-      def to_hash
-        root.to_hash
-      end
-    end
-
-    module Node #:nodoc:
-      CONTENT_ROOT = "__content__"
-
-      # Convert XML document to hash.
-      #
-      # hash::
-      #   Hash to merge the converted element into.
-      def to_hash(hash = {})
-        node_hash = {}
-
-        # Insert node hash into parent hash correctly.
-        case hash[name]
-        when Array then hash[name] << node_hash
-        when Hash  then hash[name] = [hash[name], node_hash]
-        when nil   then hash[name] = node_hash
-        end
-
-        # Handle child elements
-        each_child do |c|
-          if c.element?
-            c.to_hash(node_hash)
-          elsif c.text? || c.cdata?
-            node_hash[CONTENT_ROOT] ||= +""
-            node_hash[CONTENT_ROOT] << c.content
-          end
-        end
-
-        # Remove content node if it is blank
-        if node_hash.length > 1 && node_hash[CONTENT_ROOT].blank?
-          node_hash.delete(CONTENT_ROOT)
-        end
-
-        # Handle attributes
-        each_attr { |a| node_hash[a.name] = a.value }
-
-        hash
-      end
-    end
-  end
-end
-
-# :enddoc:
-
-LibXML::XML::Document.include(LibXML::Conversions::Document)
-LibXML::XML::Node.include(LibXML::Conversions::Node)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/libxmlsax.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/libxmlsax.rb
deleted file mode 100644
index ac8acdfc3ce7e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/libxmlsax.rb
+++ /dev/null
@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require "libxml"
-require "active_support/core_ext/object/blank"
-require "stringio"
-
-module ActiveSupport
-  module XmlMini_LibXMLSAX #:nodoc:
-    extend self
-
-    # Class that will build the hash while the XML document
-    # is being parsed using SAX events.
-    class HashBuilder
-      include LibXML::XML::SaxParser::Callbacks
-
-      CONTENT_KEY   = "__content__"
-      HASH_SIZE_KEY = "__hash_size__"
-
-      attr_reader :hash
-
-      def current_hash
-        @hash_stack.last
-      end
-
-      def on_start_document
-        @hash = { CONTENT_KEY => +"" }
-        @hash_stack = [@hash]
-      end
-
-      def on_end_document
-        @hash = @hash_stack.pop
-        @hash.delete(CONTENT_KEY)
-      end
-
-      def on_start_element(name, attrs = {})
-        new_hash = { CONTENT_KEY => +"" }.merge!(attrs)
-        new_hash[HASH_SIZE_KEY] = new_hash.size + 1
-
-        case current_hash[name]
-        when Array then current_hash[name] << new_hash
-        when Hash  then current_hash[name] = [current_hash[name], new_hash]
-        when nil   then current_hash[name] = new_hash
-        end
-
-        @hash_stack.push(new_hash)
-      end
-
-      def on_end_element(name)
-        if current_hash.length > current_hash.delete(HASH_SIZE_KEY) && current_hash[CONTENT_KEY].blank? || current_hash[CONTENT_KEY] == ""
-          current_hash.delete(CONTENT_KEY)
-        end
-        @hash_stack.pop
-      end
-
-      def on_characters(string)
-        current_hash[CONTENT_KEY] << string
-      end
-
-      alias_method :on_cdata_block, :on_characters
-    end
-
-    attr_accessor :document_class
-    self.document_class = HashBuilder
-
-    def parse(data)
-      if !data.respond_to?(:read)
-        data = StringIO.new(data || "")
-      end
-
-      if data.eof?
-        {}
-      else
-        LibXML::XML::Error.set_handler(&LibXML::XML::Error::QUIET_HANDLER)
-        parser = LibXML::XML::SaxParser.io(data)
-        document = document_class.new
-
-        parser.callbacks = document
-        parser.parse
-        document.hash
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/nokogiri.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/nokogiri.rb
deleted file mode 100644
index f76513f48bcc2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/nokogiri.rb
+++ /dev/null
@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require "nokogiri"
-rescue LoadError => e
-  $stderr.puts "You don't have nokogiri installed in your application. Please add it to your Gemfile and run bundle install"
-  raise e
-end
-require "active_support/core_ext/object/blank"
-require "stringio"
-
-module ActiveSupport
-  module XmlMini_Nokogiri #:nodoc:
-    extend self
-
-    # Parse an XML Document string or IO into a simple hash using libxml / nokogiri.
-    # data::
-    #   XML Document string or IO to parse
-    def parse(data)
-      if !data.respond_to?(:read)
-        data = StringIO.new(data || "")
-      end
-
-      if data.eof?
-        {}
-      else
-        doc = Nokogiri::XML(data)
-        raise doc.errors.first if doc.errors.length > 0
-        doc.to_hash
-      end
-    end
-
-    module Conversions #:nodoc:
-      module Document #:nodoc:
-        def to_hash
-          root.to_hash
-        end
-      end
-
-      module Node #:nodoc:
-        CONTENT_ROOT = "__content__"
-
-        # Convert XML document to hash.
-        #
-        # hash::
-        #   Hash to merge the converted element into.
-        def to_hash(hash = {})
-          node_hash = {}
-
-          # Insert node hash into parent hash correctly.
-          case hash[name]
-          when Array then hash[name] << node_hash
-          when Hash  then hash[name] = [hash[name], node_hash]
-          when nil   then hash[name] = node_hash
-          end
-
-          # Handle child elements
-          children.each do |c|
-            if c.element?
-              c.to_hash(node_hash)
-            elsif c.text? || c.cdata?
-              node_hash[CONTENT_ROOT] ||= +""
-              node_hash[CONTENT_ROOT] << c.content
-            end
-          end
-
-          # Remove content node if it is blank and there are child tags
-          if node_hash.length > 1 && node_hash[CONTENT_ROOT].blank?
-            node_hash.delete(CONTENT_ROOT)
-          end
-
-          # Handle attributes
-          attribute_nodes.each { |a| node_hash[a.node_name] = a.value }
-
-          hash
-        end
-      end
-    end
-
-    Nokogiri::XML::Document.include(Conversions::Document)
-    Nokogiri::XML::Node.include(Conversions::Node)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/nokogirisax.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/nokogirisax.rb
deleted file mode 100644
index 55cd72e09305d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/nokogirisax.rb
+++ /dev/null
@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require "nokogiri"
-rescue LoadError => e
-  $stderr.puts "You don't have nokogiri installed in your application. Please add it to your Gemfile and run bundle install"
-  raise e
-end
-require "active_support/core_ext/object/blank"
-require "stringio"
-
-module ActiveSupport
-  module XmlMini_NokogiriSAX #:nodoc:
-    extend self
-
-    # Class that will build the hash while the XML document
-    # is being parsed using SAX events.
-    class HashBuilder < Nokogiri::XML::SAX::Document
-      CONTENT_KEY   = "__content__"
-      HASH_SIZE_KEY = "__hash_size__"
-
-      attr_reader :hash
-
-      def current_hash
-        @hash_stack.last
-      end
-
-      def start_document
-        @hash = {}
-        @hash_stack = [@hash]
-      end
-
-      def end_document
-        raise "Parse stack not empty!" if @hash_stack.size > 1
-      end
-
-      def error(error_message)
-        raise error_message
-      end
-
-      def start_element(name, attrs = [])
-        new_hash = { CONTENT_KEY => +"" }.merge!(Hash[attrs])
-        new_hash[HASH_SIZE_KEY] = new_hash.size + 1
-
-        case current_hash[name]
-        when Array then current_hash[name] << new_hash
-        when Hash  then current_hash[name] = [current_hash[name], new_hash]
-        when nil   then current_hash[name] = new_hash
-        end
-
-        @hash_stack.push(new_hash)
-      end
-
-      def end_element(name)
-        if current_hash.length > current_hash.delete(HASH_SIZE_KEY) && current_hash[CONTENT_KEY].blank? || current_hash[CONTENT_KEY] == ""
-          current_hash.delete(CONTENT_KEY)
-        end
-        @hash_stack.pop
-      end
-
-      def characters(string)
-        current_hash[CONTENT_KEY] << string
-      end
-
-      alias_method :cdata_block, :characters
-    end
-
-    attr_accessor :document_class
-    self.document_class = HashBuilder
-
-    def parse(data)
-      if !data.respond_to?(:read)
-        data = StringIO.new(data || "")
-      end
-
-      if data.eof?
-        {}
-      else
-        document = document_class.new
-        parser = Nokogiri::XML::SAX::Parser.new(document)
-        parser.parse(data)
-        document.hash
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/rexml.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/rexml.rb
deleted file mode 100644
index c700959f71b7c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/activesupport-6.1.6.1/lib/active_support/xml_mini/rexml.rb
+++ /dev/null
@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/kernel/reporting"
-require "active_support/core_ext/object/blank"
-require "stringio"
-
-module ActiveSupport
-  module XmlMini_REXML #:nodoc:
-    extend self
-
-    CONTENT_KEY = "__content__"
-
-    # Parse an XML Document string or IO into a simple hash.
-    #
-    # Same as XmlSimple::xml_in but doesn't shoot itself in the foot,
-    # and uses the defaults from Active Support.
-    #
-    # data::
-    #   XML Document string or IO to parse
-    def parse(data)
-      if !data.respond_to?(:read)
-        data = StringIO.new(data || "")
-      end
-
-      if data.eof?
-        {}
-      else
-        require_rexml unless defined?(REXML::Document)
-        doc = REXML::Document.new(data)
-
-        if doc.root
-          merge_element!({}, doc.root, XmlMini.depth)
-        else
-          raise REXML::ParseException,
-            "The document #{doc.to_s.inspect} does not have a valid root"
-        end
-      end
-    end
-
-    private
-      def require_rexml
-        silence_warnings { require "rexml/document" }
-      rescue LoadError => e
-        $stderr.puts "You don't have rexml installed in your application. Please add it to your Gemfile and run bundle install"
-        raise e
-      end
-
-      # Convert an XML element and merge into the hash
-      #
-      # hash::
-      #   Hash to merge the converted element into.
-      # element::
-      #   XML element to merge into hash
-      def merge_element!(hash, element, depth)
-        raise REXML::ParseException, "The document is too deep" if depth == 0
-        merge!(hash, element.name, collapse(element, depth))
-      end
-
-      # Actually converts an XML document element into a data structure.
-      #
-      # element::
-      #   The document element to be collapsed.
-      def collapse(element, depth)
-        hash = get_attributes(element)
-
-        if element.has_elements?
-          element.each_element { |child| merge_element!(hash, child, depth - 1) }
-          merge_texts!(hash, element) unless empty_content?(element)
-          hash
-        else
-          merge_texts!(hash, element)
-        end
-      end
-
-      # Merge all the texts of an element into the hash
-      #
-      # hash::
-      #   Hash to add the converted element to.
-      # element::
-      #   XML element whose texts are to me merged into the hash
-      def merge_texts!(hash, element)
-        unless element.has_text?
-          hash
-        else
-          # must use value to prevent double-escaping
-          texts = +""
-          element.texts.each { |t| texts << t.value }
-          merge!(hash, CONTENT_KEY, texts)
-        end
-      end
-
-      # Adds a new key/value pair to an existing Hash. If the key to be added
-      # already exists and the existing value associated with key is not
-      # an Array, it will be wrapped in an Array. Then the new value is
-      # appended to that Array.
-      #
-      # hash::
-      #   Hash to add key/value pair to.
-      # key::
-      #   Key to be added.
-      # value::
-      #   Value to be associated with key.
-      def merge!(hash, key, value)
-        if hash.has_key?(key)
-          if hash[key].instance_of?(Array)
-            hash[key] << value
-          else
-            hash[key] = [hash[key], value]
-          end
-        elsif value.instance_of?(Array)
-          hash[key] = [value]
-        else
-          hash[key] = value
-        end
-        hash
-      end
-
-      # Converts the attributes array of an XML element into a hash.
-      # Returns an empty Hash if node has no attributes.
-      #
-      # element::
-      #   XML element to extract attributes from.
-      def get_attributes(element)
-        attributes = {}
-        element.attributes.each { |n, v| attributes[n] = v }
-        attributes
-      end
-
-      # Determines if a document element has text content
-      #
-      # element::
-      #   XML element to be checked.
-      def empty_content?(element)
-        element.texts.join.blank?
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/idna/pure.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/idna/pure.rb
deleted file mode 100644
index 7a0c1fda228c9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/idna/pure.rb
+++ /dev/null
@@ -1,678 +0,0 @@
-# frozen_string_literal: true
-
-# encoding:utf-8
-#--
-# Copyright (C) Bob Aman
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-#++
-
-
-module Addressable
-  module IDNA
-    # This module is loosely based on idn_actionmailer by Mick Staugaard,
-    # the unicode library by Yoshida Masato, and the punycode implementation
-    # by Kazuhiro Nishiyama.  Most of the code was copied verbatim, but
-    # some reformatting was done, and some translation from C was done.
-    #
-    # Without their code to work from as a base, we'd all still be relying
-    # on the presence of libidn.  Which nobody ever seems to have installed.
-    #
-    # Original sources:
-    # http://github.com/staugaard/idn_actionmailer
-    # http://www.yoshidam.net/Ruby.html#unicode
-    # http://rubyforge.org/frs/?group_id=2550
-
-
-    UNICODE_TABLE = File.expand_path(
-      File.join(File.dirname(__FILE__), '../../..', 'data/unicode.data')
-    )
-
-    ACE_PREFIX = "xn--"
-
-    UTF8_REGEX = /\A(?:
-      [\x09\x0A\x0D\x20-\x7E]               # ASCII
-      | [\xC2-\xDF][\x80-\xBF]              # non-overlong 2-byte
-      | \xE0[\xA0-\xBF][\x80-\xBF]          # excluding overlongs
-      | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}   # straight 3-byte
-      | \xED[\x80-\x9F][\x80-\xBF]          # excluding surrogates
-      | \xF0[\x90-\xBF][\x80-\xBF]{2}       # planes 1-3
-      | [\xF1-\xF3][\x80-\xBF]{3}           # planes 4nil5
-      | \xF4[\x80-\x8F][\x80-\xBF]{2}       # plane 16
-      )*\z/mnx
-
-    UTF8_REGEX_MULTIBYTE = /(?:
-      [\xC2-\xDF][\x80-\xBF]                # non-overlong 2-byte
-      | \xE0[\xA0-\xBF][\x80-\xBF]          # excluding overlongs
-      | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}   # straight 3-byte
-      | \xED[\x80-\x9F][\x80-\xBF]          # excluding surrogates
-      | \xF0[\x90-\xBF][\x80-\xBF]{2}       # planes 1-3
-      | [\xF1-\xF3][\x80-\xBF]{3}           # planes 4nil5
-      | \xF4[\x80-\x8F][\x80-\xBF]{2}       # plane 16
-      )/mnx
-
-    # :startdoc:
-
-    # Converts from a Unicode internationalized domain name to an ASCII
-    # domain name as described in RFC 3490.
-    def self.to_ascii(input)
-      input = input.to_s unless input.is_a?(String)
-      input = input.dup
-      if input.respond_to?(:force_encoding)
-        input.force_encoding(Encoding::ASCII_8BIT)
-      end
-      if input =~ UTF8_REGEX && input =~ UTF8_REGEX_MULTIBYTE
-        parts = unicode_downcase(input).split('.')
-        parts.map! do |part|
-          if part.respond_to?(:force_encoding)
-            part.force_encoding(Encoding::ASCII_8BIT)
-          end
-          if part =~ UTF8_REGEX && part =~ UTF8_REGEX_MULTIBYTE
-            ACE_PREFIX + punycode_encode(unicode_normalize_kc(part))
-          else
-            part
-          end
-        end
-        parts.join('.')
-      else
-        input
-      end
-    end
-
-    # Converts from an ASCII domain name to a Unicode internationalized
-    # domain name as described in RFC 3490.
-    def self.to_unicode(input)
-      input = input.to_s unless input.is_a?(String)
-      parts = input.split('.')
-      parts.map! do |part|
-        if part =~ /^#{ACE_PREFIX}(.+)/
-          begin
-            punycode_decode(part[/^#{ACE_PREFIX}(.+)/, 1])
-          rescue Addressable::IDNA::PunycodeBadInput
-            # toUnicode is explicitly defined as never-fails by the spec
-            part
-          end
-        else
-          part
-        end
-      end
-      output = parts.join('.')
-      if output.respond_to?(:force_encoding)
-        output.force_encoding(Encoding::UTF_8)
-      end
-      output
-    end
-
-    # Unicode normalization form KC.
-    def self.unicode_normalize_kc(input)
-      input = input.to_s unless input.is_a?(String)
-      unpacked = input.unpack("U*")
-      unpacked =
-        unicode_compose(unicode_sort_canonical(unicode_decompose(unpacked)))
-      return unpacked.pack("U*")
-    end
-
-    ##
-    # Unicode aware downcase method.
-    #
-    # @api private
-    # @param [String] input
-    #   The input string.
-    # @return [String] The downcased result.
-    def self.unicode_downcase(input)
-      input = input.to_s unless input.is_a?(String)
-      unpacked = input.unpack("U*")
-      unpacked.map! { |codepoint| lookup_unicode_lowercase(codepoint) }
-      return unpacked.pack("U*")
-    end
-    private_class_method :unicode_downcase
-
-    def self.unicode_compose(unpacked)
-      unpacked_result = []
-      length = unpacked.length
-
-      return unpacked if length == 0
-
-      starter = unpacked[0]
-      starter_cc = lookup_unicode_combining_class(starter)
-      starter_cc = 256 if starter_cc != 0
-      for i in 1...length
-        ch = unpacked[i]
-
-        if (starter_cc == 0 &&
-            (composite = unicode_compose_pair(starter, ch)) != nil)
-          starter = composite
-        else
-          unpacked_result << starter
-          starter = ch
-        end
-      end
-      unpacked_result << starter
-      return unpacked_result
-    end
-    private_class_method :unicode_compose
-
-    def self.unicode_compose_pair(ch_one, ch_two)
-      if ch_one >= HANGUL_LBASE && ch_one < HANGUL_LBASE + HANGUL_LCOUNT &&
-          ch_two >= HANGUL_VBASE && ch_two < HANGUL_VBASE + HANGUL_VCOUNT
-        # Hangul L + V
-        return HANGUL_SBASE + (
-          (ch_one - HANGUL_LBASE) * HANGUL_VCOUNT + (ch_two - HANGUL_VBASE)
-        ) * HANGUL_TCOUNT
-      elsif ch_one >= HANGUL_SBASE &&
-          ch_one < HANGUL_SBASE + HANGUL_SCOUNT &&
-          (ch_one - HANGUL_SBASE) % HANGUL_TCOUNT == 0 &&
-          ch_two >= HANGUL_TBASE && ch_two < HANGUL_TBASE + HANGUL_TCOUNT
-           # Hangul LV + T
-        return ch_one + (ch_two - HANGUL_TBASE)
-      end
-
-      p = []
-
-      ucs4_to_utf8(ch_one, p)
-      ucs4_to_utf8(ch_two, p)
-
-      return lookup_unicode_composition(p)
-    end
-    private_class_method :unicode_compose_pair
-
-    def self.ucs4_to_utf8(char, buffer)
-      if char < 128
-        buffer << char
-      elsif char < 2048
-        buffer << (char >> 6 | 192)
-        buffer << (char & 63 | 128)
-      elsif char < 0x10000
-        buffer << (char >> 12 | 224)
-        buffer << (char >> 6 & 63 | 128)
-        buffer << (char & 63 | 128)
-      elsif char < 0x200000
-        buffer << (char >> 18 | 240)
-        buffer << (char >> 12 & 63 | 128)
-        buffer << (char >> 6 & 63 | 128)
-        buffer << (char & 63 | 128)
-      elsif char < 0x4000000
-        buffer << (char >> 24 | 248)
-        buffer << (char >> 18 & 63 | 128)
-        buffer << (char >> 12 & 63 | 128)
-        buffer << (char >> 6 & 63 | 128)
-        buffer << (char & 63 | 128)
-      elsif char < 0x80000000
-        buffer << (char >> 30 | 252)
-        buffer << (char >> 24 & 63 | 128)
-        buffer << (char >> 18 & 63 | 128)
-        buffer << (char >> 12 & 63 | 128)
-        buffer << (char >> 6 & 63 | 128)
-        buffer << (char & 63 | 128)
-      end
-    end
-    private_class_method :ucs4_to_utf8
-
-    def self.unicode_sort_canonical(unpacked)
-      unpacked = unpacked.dup
-      i = 1
-      length = unpacked.length
-
-      return unpacked if length < 2
-
-      while i < length
-        last = unpacked[i-1]
-        ch = unpacked[i]
-        last_cc = lookup_unicode_combining_class(last)
-        cc = lookup_unicode_combining_class(ch)
-        if cc != 0 && last_cc != 0 && last_cc > cc
-          unpacked[i] = last
-          unpacked[i-1] = ch
-          i -= 1 if i > 1
-        else
-          i += 1
-        end
-      end
-      return unpacked
-    end
-    private_class_method :unicode_sort_canonical
-
-    def self.unicode_decompose(unpacked)
-      unpacked_result = []
-      for cp in unpacked
-        if cp >= HANGUL_SBASE && cp < HANGUL_SBASE + HANGUL_SCOUNT
-          l, v, t = unicode_decompose_hangul(cp)
-          unpacked_result << l
-          unpacked_result << v if v
-          unpacked_result << t if t
-        else
-          dc = lookup_unicode_compatibility(cp)
-          unless dc
-            unpacked_result << cp
-          else
-            unpacked_result.concat(unicode_decompose(dc.unpack("U*")))
-          end
-        end
-      end
-      return unpacked_result
-    end
-    private_class_method :unicode_decompose
-
-    def self.unicode_decompose_hangul(codepoint)
-      sindex = codepoint - HANGUL_SBASE;
-      if sindex < 0 || sindex >= HANGUL_SCOUNT
-        l = codepoint
-        v = t = nil
-        return l, v, t
-      end
-      l = HANGUL_LBASE + sindex / HANGUL_NCOUNT
-      v = HANGUL_VBASE + (sindex % HANGUL_NCOUNT) / HANGUL_TCOUNT
-      t = HANGUL_TBASE + sindex % HANGUL_TCOUNT
-      if t == HANGUL_TBASE
-        t = nil
-      end
-      return l, v, t
-    end
-    private_class_method :unicode_decompose_hangul
-
-    def self.lookup_unicode_combining_class(codepoint)
-      codepoint_data = UNICODE_DATA[codepoint]
-      (codepoint_data ?
-        (codepoint_data[UNICODE_DATA_COMBINING_CLASS] || 0) :
-        0)
-    end
-    private_class_method :lookup_unicode_combining_class
-
-    def self.lookup_unicode_compatibility(codepoint)
-      codepoint_data = UNICODE_DATA[codepoint]
-      (codepoint_data ?
-        codepoint_data[UNICODE_DATA_COMPATIBILITY] : nil)
-    end
-    private_class_method :lookup_unicode_compatibility
-
-    def self.lookup_unicode_lowercase(codepoint)
-      codepoint_data = UNICODE_DATA[codepoint]
-      (codepoint_data ?
-        (codepoint_data[UNICODE_DATA_LOWERCASE] || codepoint) :
-        codepoint)
-    end
-    private_class_method :lookup_unicode_lowercase
-
-    def self.lookup_unicode_composition(unpacked)
-      return COMPOSITION_TABLE[unpacked]
-    end
-    private_class_method :lookup_unicode_composition
-
-    HANGUL_SBASE =  0xac00
-    HANGUL_LBASE =  0x1100
-    HANGUL_LCOUNT = 19
-    HANGUL_VBASE =  0x1161
-    HANGUL_VCOUNT = 21
-    HANGUL_TBASE =  0x11a7
-    HANGUL_TCOUNT = 28
-    HANGUL_NCOUNT = HANGUL_VCOUNT * HANGUL_TCOUNT # 588
-    HANGUL_SCOUNT = HANGUL_LCOUNT * HANGUL_NCOUNT # 11172
-
-    UNICODE_DATA_COMBINING_CLASS = 0
-    UNICODE_DATA_EXCLUSION = 1
-    UNICODE_DATA_CANONICAL = 2
-    UNICODE_DATA_COMPATIBILITY = 3
-    UNICODE_DATA_UPPERCASE = 4
-    UNICODE_DATA_LOWERCASE = 5
-    UNICODE_DATA_TITLECASE = 6
-
-    begin
-      if defined?(FakeFS)
-        fakefs_state = FakeFS.activated?
-        FakeFS.deactivate!
-      end
-      # This is a sparse Unicode table.  Codepoints without entries are
-      # assumed to have the value: [0, 0, nil, nil, nil, nil, nil]
-      UNICODE_DATA = File.open(UNICODE_TABLE, "rb") do |file|
-        Marshal.load(file.read)
-      end
-    ensure
-      if defined?(FakeFS)
-        FakeFS.activate! if fakefs_state
-      end
-    end
-
-    COMPOSITION_TABLE = {}
-    UNICODE_DATA.each do |codepoint, data|
-      canonical = data[UNICODE_DATA_CANONICAL]
-      exclusion = data[UNICODE_DATA_EXCLUSION]
-
-      if canonical && exclusion == 0
-        COMPOSITION_TABLE[canonical.unpack("C*")] = codepoint
-      end
-    end
-
-    UNICODE_MAX_LENGTH = 256
-    ACE_MAX_LENGTH = 256
-
-    PUNYCODE_BASE = 36
-    PUNYCODE_TMIN = 1
-    PUNYCODE_TMAX = 26
-    PUNYCODE_SKEW = 38
-    PUNYCODE_DAMP = 700
-    PUNYCODE_INITIAL_BIAS = 72
-    PUNYCODE_INITIAL_N = 0x80
-    PUNYCODE_DELIMITER = 0x2D
-
-    PUNYCODE_MAXINT = 1 << 64
-
-    PUNYCODE_PRINT_ASCII =
-      "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n" +
-      "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n" +
-      " !\"\#$%&'()*+,-./" +
-      "0123456789:;<=>?" +
-      "@ABCDEFGHIJKLMNO" +
-      "PQRSTUVWXYZ[\\]^_" +
-      "`abcdefghijklmno" +
-      "pqrstuvwxyz{|}~\n"
-
-    # Input is invalid.
-    class PunycodeBadInput < StandardError; end
-    # Output would exceed the space provided.
-    class PunycodeBigOutput < StandardError; end
-    # Input needs wider integers to process.
-    class PunycodeOverflow < StandardError; end
-
-    def self.punycode_encode(unicode)
-      unicode = unicode.to_s unless unicode.is_a?(String)
-      input = unicode.unpack("U*")
-      output = [0] * (ACE_MAX_LENGTH + 1)
-      input_length = input.size
-      output_length = [ACE_MAX_LENGTH]
-
-      # Initialize the state
-      n = PUNYCODE_INITIAL_N
-      delta = out = 0
-      max_out = output_length[0]
-      bias = PUNYCODE_INITIAL_BIAS
-
-      # Handle the basic code points:
-      input_length.times do |j|
-        if punycode_basic?(input[j])
-          if max_out - out < 2
-            raise PunycodeBigOutput,
-              "Output would exceed the space provided."
-          end
-          output[out] = input[j]
-          out += 1
-        end
-      end
-
-      h = b = out
-
-      # h is the number of code points that have been handled, b is the
-      # number of basic code points, and out is the number of characters
-      # that have been output.
-
-      if b > 0
-        output[out] = PUNYCODE_DELIMITER
-        out += 1
-      end
-
-      # Main encoding loop:
-
-      while h < input_length
-        # All non-basic code points < n have been
-        # handled already.  Find the next larger one:
-
-        m = PUNYCODE_MAXINT
-        input_length.times do |j|
-          m = input[j] if (n...m) === input[j]
-        end
-
-        # Increase delta enough to advance the decoder's
-        # <n,i> state to <m,0>, but guard against overflow:
-
-        if m - n > (PUNYCODE_MAXINT - delta) / (h + 1)
-          raise PunycodeOverflow, "Input needs wider integers to process."
-        end
-        delta += (m - n) * (h + 1)
-        n = m
-
-        input_length.times do |j|
-          # Punycode does not need to check whether input[j] is basic:
-          if input[j] < n
-            delta += 1
-            if delta == 0
-              raise PunycodeOverflow,
-                "Input needs wider integers to process."
-            end
-          end
-
-          if input[j] == n
-            # Represent delta as a generalized variable-length integer:
-
-            q = delta; k = PUNYCODE_BASE
-            while true
-              if out >= max_out
-                raise PunycodeBigOutput,
-                  "Output would exceed the space provided."
-              end
-              t = (
-                if k <= bias
-                  PUNYCODE_TMIN
-                elsif k >= bias + PUNYCODE_TMAX
-                  PUNYCODE_TMAX
-                else
-                  k - bias
-                end
-              )
-              break if q < t
-              output[out] =
-                punycode_encode_digit(t + (q - t) % (PUNYCODE_BASE - t))
-              out += 1
-              q = (q - t) / (PUNYCODE_BASE - t)
-              k += PUNYCODE_BASE
-            end
-
-            output[out] = punycode_encode_digit(q)
-            out += 1
-            bias = punycode_adapt(delta, h + 1, h == b)
-            delta = 0
-            h += 1
-          end
-        end
-
-        delta += 1
-        n += 1
-      end
-
-      output_length[0] = out
-
-      outlen = out
-      outlen.times do |j|
-        c = output[j]
-        unless c >= 0 && c <= 127
-          raise StandardError, "Invalid output char."
-        end
-        unless PUNYCODE_PRINT_ASCII[c]
-          raise PunycodeBadInput, "Input is invalid."
-        end
-      end
-
-      output[0..outlen].map { |x| x.chr }.join("").sub(/\0+\z/, "")
-    end
-    private_class_method :punycode_encode
-
-    def self.punycode_decode(punycode)
-      input = []
-      output = []
-
-      if ACE_MAX_LENGTH * 2 < punycode.size
-        raise PunycodeBigOutput, "Output would exceed the space provided."
-      end
-      punycode.each_byte do |c|
-        unless c >= 0 && c <= 127
-          raise PunycodeBadInput, "Input is invalid."
-        end
-        input.push(c)
-      end
-
-      input_length = input.length
-      output_length = [UNICODE_MAX_LENGTH]
-
-      # Initialize the state
-      n = PUNYCODE_INITIAL_N
-
-      out = i = 0
-      max_out = output_length[0]
-      bias = PUNYCODE_INITIAL_BIAS
-
-      # Handle the basic code points:  Let b be the number of input code
-      # points before the last delimiter, or 0 if there is none, then
-      # copy the first b code points to the output.
-
-      b = 0
-      input_length.times do |j|
-        b = j if punycode_delimiter?(input[j])
-      end
-      if b > max_out
-        raise PunycodeBigOutput, "Output would exceed the space provided."
-      end
-
-      b.times do |j|
-        unless punycode_basic?(input[j])
-          raise PunycodeBadInput, "Input is invalid."
-        end
-        output[out] = input[j]
-        out+=1
-      end
-
-      # Main decoding loop:  Start just after the last delimiter if any
-      # basic code points were copied; start at the beginning otherwise.
-
-      in_ = b > 0 ? b + 1 : 0
-      while in_ < input_length
-
-        # in_ is the index of the next character to be consumed, and
-        # out is the number of code points in the output array.
-
-        # Decode a generalized variable-length integer into delta,
-        # which gets added to i.  The overflow checking is easier
-        # if we increase i as we go, then subtract off its starting
-        # value at the end to obtain delta.
-
-        oldi = i; w = 1; k = PUNYCODE_BASE
-        while true
-          if in_ >= input_length
-            raise PunycodeBadInput, "Input is invalid."
-          end
-          digit = punycode_decode_digit(input[in_])
-          in_+=1
-          if digit >= PUNYCODE_BASE
-            raise PunycodeBadInput, "Input is invalid."
-          end
-          if digit > (PUNYCODE_MAXINT - i) / w
-            raise PunycodeOverflow, "Input needs wider integers to process."
-          end
-          i += digit * w
-          t = (
-            if k <= bias
-              PUNYCODE_TMIN
-            elsif k >= bias + PUNYCODE_TMAX
-              PUNYCODE_TMAX
-            else
-              k - bias
-            end
-          )
-          break if digit < t
-          if w > PUNYCODE_MAXINT / (PUNYCODE_BASE - t)
-            raise PunycodeOverflow, "Input needs wider integers to process."
-          end
-          w *= PUNYCODE_BASE - t
-          k += PUNYCODE_BASE
-        end
-
-        bias = punycode_adapt(i - oldi, out + 1, oldi == 0)
-
-        # I was supposed to wrap around from out + 1 to 0,
-        # incrementing n each time, so we'll fix that now:
-
-        if i / (out + 1) > PUNYCODE_MAXINT - n
-          raise PunycodeOverflow, "Input needs wider integers to process."
-        end
-        n += i / (out + 1)
-        i %= out + 1
-
-        # Insert n at position i of the output:
-
-        # not needed for Punycode:
-        # raise PUNYCODE_INVALID_INPUT if decode_digit(n) <= base
-        if out >= max_out
-          raise PunycodeBigOutput, "Output would exceed the space provided."
-        end
-
-        #memmove(output + i + 1, output + i, (out - i) * sizeof *output)
-        output[i + 1, out - i] = output[i, out - i]
-        output[i] = n
-        i += 1
-
-        out += 1
-      end
-
-      output_length[0] = out
-
-      output.pack("U*")
-    end
-    private_class_method :punycode_decode
-
-    def self.punycode_basic?(codepoint)
-      codepoint < 0x80
-    end
-    private_class_method :punycode_basic?
-
-    def self.punycode_delimiter?(codepoint)
-      codepoint == PUNYCODE_DELIMITER
-    end
-    private_class_method :punycode_delimiter?
-
-    def self.punycode_encode_digit(d)
-      d + 22 + 75 * ((d < 26) ? 1 : 0)
-    end
-    private_class_method :punycode_encode_digit
-
-    # Returns the numeric value of a basic codepoint
-    # (for use in representing integers) in the range 0 to
-    # base - 1, or PUNYCODE_BASE if codepoint does not represent a value.
-    def self.punycode_decode_digit(codepoint)
-      if codepoint - 48 < 10
-        codepoint - 22
-      elsif codepoint - 65 < 26
-        codepoint - 65
-      elsif codepoint - 97 < 26
-        codepoint - 97
-      else
-        PUNYCODE_BASE
-      end
-    end
-    private_class_method :punycode_decode_digit
-
-    # Bias adaptation method
-    def self.punycode_adapt(delta, numpoints, firsttime)
-      delta = firsttime ? delta / PUNYCODE_DAMP : delta >> 1
-      # delta >> 1 is a faster way of doing delta / 2
-      delta += delta / numpoints
-      difference = PUNYCODE_BASE - PUNYCODE_TMIN
-
-      k = 0
-      while delta > (difference * PUNYCODE_TMAX) / 2
-        delta /= difference
-        k += PUNYCODE_BASE
-      end
-
-      k + (difference + 1) * delta / (delta + PUNYCODE_SKEW)
-    end
-    private_class_method :punycode_adapt
-  end
-  # :startdoc:
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/uri.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/uri.rb
deleted file mode 100644
index 6b5f4fa7b4b40..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/uri.rb
+++ /dev/null
@@ -1,2556 +0,0 @@
-# frozen_string_literal: true
-
-# encoding:utf-8
-#--
-# Copyright (C) Bob Aman
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-#++
-
-
-require "addressable/version"
-require "addressable/idna"
-require "public_suffix"
-
-##
-# Addressable is a library for processing links and URIs.
-module Addressable
-  ##
-  # This is an implementation of a URI parser based on
-  # <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>,
-  # <a href="http://www.ietf.org/rfc/rfc3987.txt">RFC 3987</a>.
-  class URI
-    ##
-    # Raised if something other than a uri is supplied.
-    class InvalidURIError < StandardError
-    end
-
-    ##
-    # Container for the character classes specified in
-    # <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
-    module CharacterClasses
-      ALPHA = "a-zA-Z"
-      DIGIT = "0-9"
-      GEN_DELIMS = "\\:\\/\\?\\#\\[\\]\\@"
-      SUB_DELIMS = "\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\="
-      RESERVED = GEN_DELIMS + SUB_DELIMS
-      UNRESERVED = ALPHA + DIGIT + "\\-\\.\\_\\~"
-      PCHAR = UNRESERVED + SUB_DELIMS + "\\:\\@"
-      SCHEME = ALPHA + DIGIT + "\\-\\+\\."
-      HOST = UNRESERVED + SUB_DELIMS + "\\[\\:\\]"
-      AUTHORITY = PCHAR + "\\[\\:\\]"
-      PATH = PCHAR + "\\/"
-      QUERY = PCHAR + "\\/\\?"
-      FRAGMENT = PCHAR + "\\/\\?"
-    end
-
-    module NormalizeCharacterClasses
-      HOST = /[^#{CharacterClasses::HOST}]/
-      UNRESERVED = /[^#{CharacterClasses::UNRESERVED}]/
-      PCHAR = /[^#{CharacterClasses::PCHAR}]/
-      SCHEME = /[^#{CharacterClasses::SCHEME}]/
-      FRAGMENT = /[^#{CharacterClasses::FRAGMENT}]/
-      QUERY = %r{[^a-zA-Z0-9\-\.\_\~\!\$\'\(\)\*\+\,\=\:\@\/\?%]|%(?!2B|2b)}
-    end
-
-    SLASH = '/'
-    EMPTY_STR = ''
-
-    URIREGEX = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/
-
-    PORT_MAPPING = {
-      "http" => 80,
-      "https" => 443,
-      "ftp" => 21,
-      "tftp" => 69,
-      "sftp" => 22,
-      "ssh" => 22,
-      "svn+ssh" => 22,
-      "telnet" => 23,
-      "nntp" => 119,
-      "gopher" => 70,
-      "wais" => 210,
-      "ldap" => 389,
-      "prospero" => 1525
-    }.freeze
-
-    ##
-    # Returns a URI object based on the parsed string.
-    #
-    # @param [String, Addressable::URI, #to_str] uri
-    #   The URI string to parse.
-    #   No parsing is performed if the object is already an
-    #   <code>Addressable::URI</code>.
-    #
-    # @return [Addressable::URI] The parsed URI.
-    def self.parse(uri)
-      # If we were given nil, return nil.
-      return nil unless uri
-      # If a URI object is passed, just return itself.
-      return uri.dup if uri.kind_of?(self)
-
-      # If a URI object of the Ruby standard library variety is passed,
-      # convert it to a string, then parse the string.
-      # We do the check this way because we don't want to accidentally
-      # cause a missing constant exception to be thrown.
-      if uri.class.name =~ /^URI\b/
-        uri = uri.to_s
-      end
-
-      # Otherwise, convert to a String
-      begin
-        uri = uri.to_str
-      rescue TypeError, NoMethodError
-        raise TypeError, "Can't convert #{uri.class} into String."
-      end if not uri.is_a? String
-
-      # This Regexp supplied as an example in RFC 3986, and it works great.
-      scan = uri.scan(URIREGEX)
-      fragments = scan[0]
-      scheme = fragments[1]
-      authority = fragments[3]
-      path = fragments[4]
-      query = fragments[6]
-      fragment = fragments[8]
-      user = nil
-      password = nil
-      host = nil
-      port = nil
-      if authority != nil
-        # The Regexp above doesn't split apart the authority.
-        userinfo = authority[/^([^\[\]]*)@/, 1]
-        if userinfo != nil
-          user = userinfo.strip[/^([^:]*):?/, 1]
-          password = userinfo.strip[/:(.*)$/, 1]
-        end
-        host = authority.sub(
-          /^([^\[\]]*)@/, EMPTY_STR
-        ).sub(
-          /:([^:@\[\]]*?)$/, EMPTY_STR
-        )
-        port = authority[/:([^:@\[\]]*?)$/, 1]
-      end
-      if port == EMPTY_STR
-        port = nil
-      end
-
-      return new(
-        :scheme => scheme,
-        :user => user,
-        :password => password,
-        :host => host,
-        :port => port,
-        :path => path,
-        :query => query,
-        :fragment => fragment
-      )
-    end
-
-    ##
-    # Converts an input to a URI. The input does not have to be a valid
-    # URI — the method will use heuristics to guess what URI was intended.
-    # This is not standards-compliant, merely user-friendly.
-    #
-    # @param [String, Addressable::URI, #to_str] uri
-    #   The URI string to parse.
-    #   No parsing is performed if the object is already an
-    #   <code>Addressable::URI</code>.
-    # @param [Hash] hints
-    #   A <code>Hash</code> of hints to the heuristic parser.
-    #   Defaults to <code>{:scheme => "http"}</code>.
-    #
-    # @return [Addressable::URI] The parsed URI.
-    def self.heuristic_parse(uri, hints={})
-      # If we were given nil, return nil.
-      return nil unless uri
-      # If a URI object is passed, just return itself.
-      return uri.dup if uri.kind_of?(self)
-
-      # If a URI object of the Ruby standard library variety is passed,
-      # convert it to a string, then parse the string.
-      # We do the check this way because we don't want to accidentally
-      # cause a missing constant exception to be thrown.
-      if uri.class.name =~ /^URI\b/
-        uri = uri.to_s
-      end
-
-      if !uri.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{uri.class} into String."
-      end
-      # Otherwise, convert to a String
-      uri = uri.to_str.dup.strip
-      hints = {
-        :scheme => "http"
-      }.merge(hints)
-      case uri
-      when /^http:\//i
-        uri.sub!(/^http:\/+/i, "http://")
-      when /^https:\//i
-        uri.sub!(/^https:\/+/i, "https://")
-      when /^feed:\/+http:\//i
-        uri.sub!(/^feed:\/+http:\/+/i, "feed:http://")
-      when /^feed:\//i
-        uri.sub!(/^feed:\/+/i, "feed://")
-      when %r[^file:/{4}]i
-        uri.sub!(%r[^file:/+]i, "file:////")
-      when %r[^file://localhost/]i
-        uri.sub!(%r[^file://localhost/+]i, "file:///")
-      when %r[^file:/+]i
-        uri.sub!(%r[^file:/+]i, "file:///")
-      when /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
-        uri.sub!(/^/, hints[:scheme] + "://")
-      when /\A\d+\..*:\d+\z/
-        uri = "#{hints[:scheme]}://#{uri}"
-      end
-      match = uri.match(URIREGEX)
-      fragments = match.captures
-      authority = fragments[3]
-      if authority && authority.length > 0
-        new_authority = authority.tr("\\", "/").gsub(" ", "%20")
-        # NOTE: We want offset 4, not 3!
-        offset = match.offset(4)
-        uri = uri.dup
-        uri[offset[0]...offset[1]] = new_authority
-      end
-      parsed = self.parse(uri)
-      if parsed.scheme =~ /^[^\/?#\.]+\.[^\/?#]+$/
-        parsed = self.parse(hints[:scheme] + "://" + uri)
-      end
-      if parsed.path.include?(".")
-        if parsed.path[/\b@\b/]
-          parsed.scheme = "mailto" unless parsed.scheme
-        elsif new_host = parsed.path[/^([^\/]+\.[^\/]*)/, 1]
-          parsed.defer_validation do
-            new_path = parsed.path.sub(
-              Regexp.new("^" + Regexp.escape(new_host)), EMPTY_STR)
-            parsed.host = new_host
-            parsed.path = new_path
-            parsed.scheme = hints[:scheme] unless parsed.scheme
-          end
-        end
-      end
-      return parsed
-    end
-
-    ##
-    # Converts a path to a file scheme URI. If the path supplied is
-    # relative, it will be returned as a relative URI. If the path supplied
-    # is actually a non-file URI, it will parse the URI as if it had been
-    # parsed with <code>Addressable::URI.parse</code>. Handles all of the
-    # various Microsoft-specific formats for specifying paths.
-    #
-    # @param [String, Addressable::URI, #to_str] path
-    #   Typically a <code>String</code> path to a file or directory, but
-    #   will return a sensible return value if an absolute URI is supplied
-    #   instead.
-    #
-    # @return [Addressable::URI]
-    #   The parsed file scheme URI or the original URI if some other URI
-    #   scheme was provided.
-    #
-    # @example
-    #   base = Addressable::URI.convert_path("/absolute/path/")
-    #   uri = Addressable::URI.convert_path("relative/path")
-    #   (base + uri).to_s
-    #   #=> "file:///absolute/path/relative/path"
-    #
-    #   Addressable::URI.convert_path(
-    #     "c:\\windows\\My Documents 100%20\\foo.txt"
-    #   ).to_s
-    #   #=> "file:///c:/windows/My%20Documents%20100%20/foo.txt"
-    #
-    #   Addressable::URI.convert_path("http://example.com/").to_s
-    #   #=> "http://example.com/"
-    def self.convert_path(path)
-      # If we were given nil, return nil.
-      return nil unless path
-      # If a URI object is passed, just return itself.
-      return path if path.kind_of?(self)
-      if !path.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{path.class} into String."
-      end
-      # Otherwise, convert to a String
-      path = path.to_str.strip
-
-      path.sub!(/^file:\/?\/?/, EMPTY_STR) if path =~ /^file:\/?\/?/
-      path = SLASH + path if path =~ /^([a-zA-Z])[\|:]/
-      uri = self.parse(path)
-
-      if uri.scheme == nil
-        # Adjust windows-style uris
-        uri.path.sub!(/^\/?([a-zA-Z])[\|:][\\\/]/) do
-          "/#{$1.downcase}:/"
-        end
-        uri.path.tr!("\\", SLASH)
-        if File.exist?(uri.path) &&
-            File.stat(uri.path).directory?
-          uri.path.chomp!(SLASH)
-          uri.path = uri.path + '/'
-        end
-
-        # If the path is absolute, set the scheme and host.
-        if uri.path.start_with?(SLASH)
-          uri.scheme = "file"
-          uri.host = EMPTY_STR
-        end
-        uri.normalize!
-      end
-
-      return uri
-    end
-
-    ##
-    # Joins several URIs together.
-    #
-    # @param [String, Addressable::URI, #to_str] *uris
-    #   The URIs to join.
-    #
-    # @return [Addressable::URI] The joined URI.
-    #
-    # @example
-    #   base = "http://example.com/"
-    #   uri = Addressable::URI.parse("relative/path")
-    #   Addressable::URI.join(base, uri)
-    #   #=> #<Addressable::URI:0xcab390 URI:http://example.com/relative/path>
-    def self.join(*uris)
-      uri_objects = uris.collect do |uri|
-        if !uri.respond_to?(:to_str)
-          raise TypeError, "Can't convert #{uri.class} into String."
-        end
-        uri.kind_of?(self) ? uri : self.parse(uri.to_str)
-      end
-      result = uri_objects.shift.dup
-      for uri in uri_objects
-        result.join!(uri)
-      end
-      return result
-    end
-
-    ##
-    # Tables used to optimize encoding operations in `self.encode_component`
-    # and `self.normalize_component`
-    SEQUENCE_ENCODING_TABLE = Hash.new do |hash, sequence|
-      hash[sequence] = sequence.unpack("C*").map do |c|
-        format("%02x", c)
-      end.join
-    end
-
-    SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE = Hash.new do |hash, sequence|
-      hash[sequence] = sequence.unpack("C*").map do |c|
-        format("%%%02X", c)
-      end.join
-    end
-
-    ##
-    # Percent encodes a URI component.
-    #
-    # @param [String, #to_str] component The URI component to encode.
-    #
-    # @param [String, Regexp] character_class
-    #   The characters which are not percent encoded. If a <code>String</code>
-    #   is passed, the <code>String</code> must be formatted as a regular
-    #   expression character class. (Do not include the surrounding square
-    #   brackets.)  For example, <code>"b-zB-Z0-9"</code> would cause
-    #   everything but the letters 'b' through 'z' and the numbers '0' through
-    #  '9' to be percent encoded. If a <code>Regexp</code> is passed, the
-    #   value <code>/[^b-zB-Z0-9]/</code> would have the same effect. A set of
-    #   useful <code>String</code> values may be found in the
-    #   <code>Addressable::URI::CharacterClasses</code> module. The default
-    #   value is the reserved plus unreserved character classes specified in
-    #   <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
-    #
-    # @param [Regexp] upcase_encoded
-    #   A string of characters that may already be percent encoded, and whose
-    #   encodings should be upcased. This allows normalization of percent
-    #   encodings for characters not included in the
-    #   <code>character_class</code>.
-    #
-    # @return [String] The encoded component.
-    #
-    # @example
-    #   Addressable::URI.encode_component("simple/example", "b-zB-Z0-9")
-    #   => "simple%2Fex%61mple"
-    #   Addressable::URI.encode_component("simple/example", /[^b-zB-Z0-9]/)
-    #   => "simple%2Fex%61mple"
-    #   Addressable::URI.encode_component(
-    #     "simple/example", Addressable::URI::CharacterClasses::UNRESERVED
-    #   )
-    #   => "simple%2Fexample"
-    def self.encode_component(component, character_class=
-        CharacterClasses::RESERVED + CharacterClasses::UNRESERVED,
-        upcase_encoded='')
-      return nil if component.nil?
-
-      begin
-        if component.kind_of?(Symbol) ||
-            component.kind_of?(Numeric) ||
-            component.kind_of?(TrueClass) ||
-            component.kind_of?(FalseClass)
-          component = component.to_s
-        else
-          component = component.to_str
-        end
-      rescue TypeError, NoMethodError
-        raise TypeError, "Can't convert #{component.class} into String."
-      end if !component.is_a? String
-
-      if ![String, Regexp].include?(character_class.class)
-        raise TypeError,
-          "Expected String or Regexp, got #{character_class.inspect}"
-      end
-      if character_class.kind_of?(String)
-        character_class = /[^#{character_class}]/
-      end
-      # We can't perform regexps on invalid UTF sequences, but
-      # here we need to, so switch to ASCII.
-      component = component.dup
-      component.force_encoding(Encoding::ASCII_8BIT)
-      # Avoiding gsub! because there are edge cases with frozen strings
-      component = component.gsub(character_class) do |sequence|
-        SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE[sequence]
-      end
-      if upcase_encoded.length > 0
-        upcase_encoded_chars = upcase_encoded.chars.map do |char|
-          SEQUENCE_ENCODING_TABLE[char]
-        end
-        component = component.gsub(/%(#{upcase_encoded_chars.join('|')})/,
-                                   &:upcase)
-      end
-      return component
-    end
-
-    class << self
-      alias_method :escape_component, :encode_component
-    end
-
-    ##
-    # Unencodes any percent encoded characters within a URI component.
-    # This method may be used for unencoding either components or full URIs,
-    # however, it is recommended to use the <code>unencode_component</code>
-    # alias when unencoding components.
-    #
-    # @param [String, Addressable::URI, #to_str] uri
-    #   The URI or component to unencode.
-    #
-    # @param [Class] return_type
-    #   The type of object to return.
-    #   This value may only be set to <code>String</code> or
-    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
-    #   to <code>String</code>.
-    #
-    # @param [String] leave_encoded
-    #   A string of characters to leave encoded. If a percent encoded character
-    #   in this list is encountered then it will remain percent encoded.
-    #
-    # @return [String, Addressable::URI]
-    #   The unencoded component or URI.
-    #   The return type is determined by the <code>return_type</code>
-    #   parameter.
-    def self.unencode(uri, return_type=String, leave_encoded='')
-      return nil if uri.nil?
-
-      begin
-        uri = uri.to_str
-      rescue NoMethodError, TypeError
-        raise TypeError, "Can't convert #{uri.class} into String."
-      end if !uri.is_a? String
-      if ![String, ::Addressable::URI].include?(return_type)
-        raise TypeError,
-          "Expected Class (String or Addressable::URI), " +
-          "got #{return_type.inspect}"
-      end
-      uri = uri.dup
-      # Seriously, only use UTF-8. I'm really not kidding!
-      uri.force_encoding("utf-8")
-
-      unless leave_encoded.empty?
-        leave_encoded = leave_encoded.dup.force_encoding("utf-8")
-      end
-
-      result = uri.gsub(/%[0-9a-f]{2}/iu) do |sequence|
-        c = sequence[1..3].to_i(16).chr
-        c.force_encoding("utf-8")
-        leave_encoded.include?(c) ? sequence : c
-      end
-      result.force_encoding("utf-8")
-      if return_type == String
-        return result
-      elsif return_type == ::Addressable::URI
-        return ::Addressable::URI.parse(result)
-      end
-    end
-
-    class << self
-      alias_method :unescape, :unencode
-      alias_method :unencode_component, :unencode
-      alias_method :unescape_component, :unencode
-    end
-
-
-    ##
-    # Normalizes the encoding of a URI component.
-    #
-    # @param [String, #to_str] component The URI component to encode.
-    #
-    # @param [String, Regexp] character_class
-    #   The characters which are not percent encoded. If a <code>String</code>
-    #   is passed, the <code>String</code> must be formatted as a regular
-    #   expression character class. (Do not include the surrounding square
-    #   brackets.)  For example, <code>"b-zB-Z0-9"</code> would cause
-    #   everything but the letters 'b' through 'z' and the numbers '0'
-    #   through '9' to be percent encoded. If a <code>Regexp</code> is passed,
-    #   the value <code>/[^b-zB-Z0-9]/</code> would have the same effect. A
-    #   set of useful <code>String</code> values may be found in the
-    #   <code>Addressable::URI::CharacterClasses</code> module. The default
-    #   value is the reserved plus unreserved character classes specified in
-    #   <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
-    #
-    # @param [String] leave_encoded
-    #   When <code>character_class</code> is a <code>String</code> then
-    #   <code>leave_encoded</code> is a string of characters that should remain
-    #   percent encoded while normalizing the component; if they appear percent
-    #   encoded in the original component, then they will be upcased ("%2f"
-    #   normalized to "%2F") but otherwise left alone.
-    #
-    # @return [String] The normalized component.
-    #
-    # @example
-    #   Addressable::URI.normalize_component("simpl%65/%65xampl%65", "b-zB-Z")
-    #   => "simple%2Fex%61mple"
-    #   Addressable::URI.normalize_component(
-    #     "simpl%65/%65xampl%65", /[^b-zB-Z]/
-    #   )
-    #   => "simple%2Fex%61mple"
-    #   Addressable::URI.normalize_component(
-    #     "simpl%65/%65xampl%65",
-    #     Addressable::URI::CharacterClasses::UNRESERVED
-    #   )
-    #   => "simple%2Fexample"
-    #   Addressable::URI.normalize_component(
-    #     "one%20two%2fthree%26four",
-    #     "0-9a-zA-Z &/",
-    #     "/"
-    #   )
-    #   => "one two%2Fthree&four"
-    def self.normalize_component(component, character_class=
-        CharacterClasses::RESERVED + CharacterClasses::UNRESERVED,
-        leave_encoded='')
-      return nil if component.nil?
-
-      begin
-        component = component.to_str
-      rescue NoMethodError, TypeError
-        raise TypeError, "Can't convert #{component.class} into String."
-      end if !component.is_a? String
-
-      if ![String, Regexp].include?(character_class.class)
-        raise TypeError,
-          "Expected String or Regexp, got #{character_class.inspect}"
-      end
-      if character_class.kind_of?(String)
-        leave_re = if leave_encoded.length > 0
-          character_class = "#{character_class}%" unless character_class.include?('%')
-
-          "|%(?!#{leave_encoded.chars.map do |char|
-            seq = SEQUENCE_ENCODING_TABLE[char]
-            [seq.upcase, seq.downcase]
-          end.flatten.join('|')})"
-        end
-
-        character_class = if leave_re
-                            /[^#{character_class}]#{leave_re}/
-                          else
-                            /[^#{character_class}]/
-                          end
-      end
-      # We can't perform regexps on invalid UTF sequences, but
-      # here we need to, so switch to ASCII.
-      component = component.dup
-      component.force_encoding(Encoding::ASCII_8BIT)
-      unencoded = self.unencode_component(component, String, leave_encoded)
-      begin
-        encoded = self.encode_component(
-          Addressable::IDNA.unicode_normalize_kc(unencoded),
-          character_class,
-          leave_encoded
-        )
-      rescue ArgumentError
-        encoded = self.encode_component(unencoded)
-      end
-      encoded.force_encoding(Encoding::UTF_8)
-      return encoded
-    end
-
-    ##
-    # Percent encodes any special characters in the URI.
-    #
-    # @param [String, Addressable::URI, #to_str] uri
-    #   The URI to encode.
-    #
-    # @param [Class] return_type
-    #   The type of object to return.
-    #   This value may only be set to <code>String</code> or
-    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
-    #   to <code>String</code>.
-    #
-    # @return [String, Addressable::URI]
-    #   The encoded URI.
-    #   The return type is determined by the <code>return_type</code>
-    #   parameter.
-    def self.encode(uri, return_type=String)
-      return nil if uri.nil?
-
-      begin
-        uri = uri.to_str
-      rescue NoMethodError, TypeError
-        raise TypeError, "Can't convert #{uri.class} into String."
-      end if !uri.is_a? String
-
-      if ![String, ::Addressable::URI].include?(return_type)
-        raise TypeError,
-          "Expected Class (String or Addressable::URI), " +
-          "got #{return_type.inspect}"
-      end
-      uri_object = uri.kind_of?(self) ? uri : self.parse(uri)
-      encoded_uri = Addressable::URI.new(
-        :scheme => self.encode_component(uri_object.scheme,
-          Addressable::URI::CharacterClasses::SCHEME),
-        :authority => self.encode_component(uri_object.authority,
-          Addressable::URI::CharacterClasses::AUTHORITY),
-        :path => self.encode_component(uri_object.path,
-          Addressable::URI::CharacterClasses::PATH),
-        :query => self.encode_component(uri_object.query,
-          Addressable::URI::CharacterClasses::QUERY),
-        :fragment => self.encode_component(uri_object.fragment,
-          Addressable::URI::CharacterClasses::FRAGMENT)
-      )
-      if return_type == String
-        return encoded_uri.to_s
-      elsif return_type == ::Addressable::URI
-        return encoded_uri
-      end
-    end
-
-    class << self
-      alias_method :escape, :encode
-    end
-
-    ##
-    # Normalizes the encoding of a URI. Characters within a hostname are
-    # not percent encoded to allow for internationalized domain names.
-    #
-    # @param [String, Addressable::URI, #to_str] uri
-    #   The URI to encode.
-    #
-    # @param [Class] return_type
-    #   The type of object to return.
-    #   This value may only be set to <code>String</code> or
-    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
-    #   to <code>String</code>.
-    #
-    # @return [String, Addressable::URI]
-    #   The encoded URI.
-    #   The return type is determined by the <code>return_type</code>
-    #   parameter.
-    def self.normalized_encode(uri, return_type=String)
-      begin
-        uri = uri.to_str
-      rescue NoMethodError, TypeError
-        raise TypeError, "Can't convert #{uri.class} into String."
-      end if !uri.is_a? String
-
-      if ![String, ::Addressable::URI].include?(return_type)
-        raise TypeError,
-          "Expected Class (String or Addressable::URI), " +
-          "got #{return_type.inspect}"
-      end
-      uri_object = uri.kind_of?(self) ? uri : self.parse(uri)
-      components = {
-        :scheme => self.unencode_component(uri_object.scheme),
-        :user => self.unencode_component(uri_object.user),
-        :password => self.unencode_component(uri_object.password),
-        :host => self.unencode_component(uri_object.host),
-        :port => (uri_object.port.nil? ? nil : uri_object.port.to_s),
-        :path => self.unencode_component(uri_object.path),
-        :query => self.unencode_component(uri_object.query),
-        :fragment => self.unencode_component(uri_object.fragment)
-      }
-      components.each do |key, value|
-        if value != nil
-          begin
-            components[key] =
-              Addressable::IDNA.unicode_normalize_kc(value.to_str)
-          rescue ArgumentError
-            # Likely a malformed UTF-8 character, skip unicode normalization
-            components[key] = value.to_str
-          end
-        end
-      end
-      encoded_uri = Addressable::URI.new(
-        :scheme => self.encode_component(components[:scheme],
-          Addressable::URI::CharacterClasses::SCHEME),
-        :user => self.encode_component(components[:user],
-          Addressable::URI::CharacterClasses::UNRESERVED),
-        :password => self.encode_component(components[:password],
-          Addressable::URI::CharacterClasses::UNRESERVED),
-        :host => components[:host],
-        :port => components[:port],
-        :path => self.encode_component(components[:path],
-          Addressable::URI::CharacterClasses::PATH),
-        :query => self.encode_component(components[:query],
-          Addressable::URI::CharacterClasses::QUERY),
-        :fragment => self.encode_component(components[:fragment],
-          Addressable::URI::CharacterClasses::FRAGMENT)
-      )
-      if return_type == String
-        return encoded_uri.to_s
-      elsif return_type == ::Addressable::URI
-        return encoded_uri
-      end
-    end
-
-    ##
-    # Encodes a set of key/value pairs according to the rules for the
-    # <code>application/x-www-form-urlencoded</code> MIME type.
-    #
-    # @param [#to_hash, #to_ary] form_values
-    #   The form values to encode.
-    #
-    # @param [TrueClass, FalseClass] sort
-    #   Sort the key/value pairs prior to encoding.
-    #   Defaults to <code>false</code>.
-    #
-    # @return [String]
-    #   The encoded value.
-    def self.form_encode(form_values, sort=false)
-      if form_values.respond_to?(:to_hash)
-        form_values = form_values.to_hash.to_a
-      elsif form_values.respond_to?(:to_ary)
-        form_values = form_values.to_ary
-      else
-        raise TypeError, "Can't convert #{form_values.class} into Array."
-      end
-
-      form_values = form_values.inject([]) do |accu, (key, value)|
-        if value.kind_of?(Array)
-          value.each do |v|
-            accu << [key.to_s, v.to_s]
-          end
-        else
-          accu << [key.to_s, value.to_s]
-        end
-        accu
-      end
-
-      if sort
-        # Useful for OAuth and optimizing caching systems
-        form_values = form_values.sort
-      end
-      escaped_form_values = form_values.map do |(key, value)|
-        # Line breaks are CRLF pairs
-        [
-          self.encode_component(
-            key.gsub(/(\r\n|\n|\r)/, "\r\n"),
-            CharacterClasses::UNRESERVED
-          ).gsub("%20", "+"),
-          self.encode_component(
-            value.gsub(/(\r\n|\n|\r)/, "\r\n"),
-            CharacterClasses::UNRESERVED
-          ).gsub("%20", "+")
-        ]
-      end
-      return escaped_form_values.map do |(key, value)|
-        "#{key}=#{value}"
-      end.join("&")
-    end
-
-    ##
-    # Decodes a <code>String</code> according to the rules for the
-    # <code>application/x-www-form-urlencoded</code> MIME type.
-    #
-    # @param [String, #to_str] encoded_value
-    #   The form values to decode.
-    #
-    # @return [Array]
-    #   The decoded values.
-    #   This is not a <code>Hash</code> because of the possibility for
-    #   duplicate keys.
-    def self.form_unencode(encoded_value)
-      if !encoded_value.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{encoded_value.class} into String."
-      end
-      encoded_value = encoded_value.to_str
-      split_values = encoded_value.split("&").map do |pair|
-        pair.split("=", 2)
-      end
-      return split_values.map do |(key, value)|
-        [
-          key ? self.unencode_component(
-            key.gsub("+", "%20")).gsub(/(\r\n|\n|\r)/, "\n") : nil,
-          value ? (self.unencode_component(
-            value.gsub("+", "%20")).gsub(/(\r\n|\n|\r)/, "\n")) : nil
-        ]
-      end
-    end
-
-    ##
-    # Creates a new uri object from component parts.
-    #
-    # @option [String, #to_str] scheme The scheme component.
-    # @option [String, #to_str] user The user component.
-    # @option [String, #to_str] password The password component.
-    # @option [String, #to_str] userinfo
-    #   The userinfo component. If this is supplied, the user and password
-    #   components must be omitted.
-    # @option [String, #to_str] host The host component.
-    # @option [String, #to_str] port The port component.
-    # @option [String, #to_str] authority
-    #   The authority component. If this is supplied, the user, password,
-    #   userinfo, host, and port components must be omitted.
-    # @option [String, #to_str] path The path component.
-    # @option [String, #to_str] query The query component.
-    # @option [String, #to_str] fragment The fragment component.
-    #
-    # @return [Addressable::URI] The constructed URI object.
-    def initialize(options={})
-      if options.has_key?(:authority)
-        if (options.keys & [:userinfo, :user, :password, :host, :port]).any?
-          raise ArgumentError,
-            "Cannot specify both an authority and any of the components " +
-            "within the authority."
-        end
-      end
-      if options.has_key?(:userinfo)
-        if (options.keys & [:user, :password]).any?
-          raise ArgumentError,
-            "Cannot specify both a userinfo and either the user or password."
-        end
-      end
-
-      self.defer_validation do
-        # Bunch of crazy logic required because of the composite components
-        # like userinfo and authority.
-        self.scheme = options[:scheme] if options[:scheme]
-        self.user = options[:user] if options[:user]
-        self.password = options[:password] if options[:password]
-        self.userinfo = options[:userinfo] if options[:userinfo]
-        self.host = options[:host] if options[:host]
-        self.port = options[:port] if options[:port]
-        self.authority = options[:authority] if options[:authority]
-        self.path = options[:path] if options[:path]
-        self.query = options[:query] if options[:query]
-        self.query_values = options[:query_values] if options[:query_values]
-        self.fragment = options[:fragment] if options[:fragment]
-      end
-      self.to_s
-    end
-
-    ##
-    # Freeze URI, initializing instance variables.
-    #
-    # @return [Addressable::URI] The frozen URI object.
-    def freeze
-      self.normalized_scheme
-      self.normalized_user
-      self.normalized_password
-      self.normalized_userinfo
-      self.normalized_host
-      self.normalized_port
-      self.normalized_authority
-      self.normalized_site
-      self.normalized_path
-      self.normalized_query
-      self.normalized_fragment
-      self.hash
-      super
-    end
-
-    ##
-    # The scheme component for this URI.
-    #
-    # @return [String] The scheme component.
-    def scheme
-      return defined?(@scheme) ? @scheme : nil
-    end
-
-    ##
-    # The scheme component for this URI, normalized.
-    #
-    # @return [String] The scheme component, normalized.
-    def normalized_scheme
-      return nil unless self.scheme
-      @normalized_scheme ||= begin
-        if self.scheme =~ /^\s*ssh\+svn\s*$/i
-          "svn+ssh".dup
-        else
-          Addressable::URI.normalize_component(
-            self.scheme.strip.downcase,
-            Addressable::URI::NormalizeCharacterClasses::SCHEME
-          )
-        end
-      end
-      # All normalized values should be UTF-8
-      @normalized_scheme.force_encoding(Encoding::UTF_8) if @normalized_scheme
-      @normalized_scheme
-    end
-
-    ##
-    # Sets the scheme component for this URI.
-    #
-    # @param [String, #to_str] new_scheme The new scheme component.
-    def scheme=(new_scheme)
-      if new_scheme && !new_scheme.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{new_scheme.class} into String."
-      elsif new_scheme
-        new_scheme = new_scheme.to_str
-      end
-      if new_scheme && new_scheme !~ /\A[a-z][a-z0-9\.\+\-]*\z/i
-        raise InvalidURIError, "Invalid scheme format: '#{new_scheme}'"
-      end
-      @scheme = new_scheme
-      @scheme = nil if @scheme.to_s.strip.empty?
-
-      # Reset dependent values
-      remove_instance_variable(:@normalized_scheme) if defined?(@normalized_scheme)
-      remove_composite_values
-
-      # Ensure we haven't created an invalid URI
-      validate()
-    end
-
-    ##
-    # The user component for this URI.
-    #
-    # @return [String] The user component.
-    def user
-      return defined?(@user) ? @user : nil
-    end
-
-    ##
-    # The user component for this URI, normalized.
-    #
-    # @return [String] The user component, normalized.
-    def normalized_user
-      return nil unless self.user
-      return @normalized_user if defined?(@normalized_user)
-      @normalized_user ||= begin
-        if normalized_scheme =~ /https?/ && self.user.strip.empty? &&
-            (!self.password || self.password.strip.empty?)
-          nil
-        else
-          Addressable::URI.normalize_component(
-            self.user.strip,
-            Addressable::URI::NormalizeCharacterClasses::UNRESERVED
-          )
-        end
-      end
-      # All normalized values should be UTF-8
-      @normalized_user.force_encoding(Encoding::UTF_8) if @normalized_user
-      @normalized_user
-    end
-
-    ##
-    # Sets the user component for this URI.
-    #
-    # @param [String, #to_str] new_user The new user component.
-    def user=(new_user)
-      if new_user && !new_user.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{new_user.class} into String."
-      end
-      @user = new_user ? new_user.to_str : nil
-
-      # You can't have a nil user with a non-nil password
-      if password != nil
-        @user = EMPTY_STR if @user.nil?
-      end
-
-      # Reset dependent values
-      remove_instance_variable(:@userinfo) if defined?(@userinfo)
-      remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
-      remove_instance_variable(:@authority) if defined?(@authority)
-      remove_instance_variable(:@normalized_user) if defined?(@normalized_user)
-      remove_composite_values
-
-      # Ensure we haven't created an invalid URI
-      validate()
-    end
-
-    ##
-    # The password component for this URI.
-    #
-    # @return [String] The password component.
-    def password
-      return defined?(@password) ? @password : nil
-    end
-
-    ##
-    # The password component for this URI, normalized.
-    #
-    # @return [String] The password component, normalized.
-    def normalized_password
-      return nil unless self.password
-      return @normalized_password if defined?(@normalized_password)
-      @normalized_password ||= begin
-        if self.normalized_scheme =~ /https?/ && self.password.strip.empty? &&
-            (!self.user || self.user.strip.empty?)
-          nil
-        else
-          Addressable::URI.normalize_component(
-            self.password.strip,
-            Addressable::URI::NormalizeCharacterClasses::UNRESERVED
-          )
-        end
-      end
-      # All normalized values should be UTF-8
-      if @normalized_password
-        @normalized_password.force_encoding(Encoding::UTF_8)
-      end
-      @normalized_password
-    end
-
-    ##
-    # Sets the password component for this URI.
-    #
-    # @param [String, #to_str] new_password The new password component.
-    def password=(new_password)
-      if new_password && !new_password.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{new_password.class} into String."
-      end
-      @password = new_password ? new_password.to_str : nil
-
-      # You can't have a nil user with a non-nil password
-      @password ||= nil
-      @user ||= nil
-      if @password != nil
-        @user = EMPTY_STR if @user.nil?
-      end
-
-      # Reset dependent values
-      remove_instance_variable(:@userinfo) if defined?(@userinfo)
-      remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
-      remove_instance_variable(:@authority) if defined?(@authority)
-      remove_instance_variable(:@normalized_password) if defined?(@normalized_password)
-      remove_composite_values
-
-      # Ensure we haven't created an invalid URI
-      validate()
-    end
-
-    ##
-    # The userinfo component for this URI.
-    # Combines the user and password components.
-    #
-    # @return [String] The userinfo component.
-    def userinfo
-      current_user = self.user
-      current_password = self.password
-      (current_user || current_password) && @userinfo ||= begin
-        if current_user && current_password
-          "#{current_user}:#{current_password}"
-        elsif current_user && !current_password
-          "#{current_user}"
-        end
-      end
-    end
-
-    ##
-    # The userinfo component for this URI, normalized.
-    #
-    # @return [String] The userinfo component, normalized.
-    def normalized_userinfo
-      return nil unless self.userinfo
-      return @normalized_userinfo if defined?(@normalized_userinfo)
-      @normalized_userinfo ||= begin
-        current_user = self.normalized_user
-        current_password = self.normalized_password
-        if !current_user && !current_password
-          nil
-        elsif current_user && current_password
-          "#{current_user}:#{current_password}".dup
-        elsif current_user && !current_password
-          "#{current_user}".dup
-        end
-      end
-      # All normalized values should be UTF-8
-      if @normalized_userinfo
-        @normalized_userinfo.force_encoding(Encoding::UTF_8)
-      end
-      @normalized_userinfo
-    end
-
-    ##
-    # Sets the userinfo component for this URI.
-    #
-    # @param [String, #to_str] new_userinfo The new userinfo component.
-    def userinfo=(new_userinfo)
-      if new_userinfo && !new_userinfo.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{new_userinfo.class} into String."
-      end
-      new_user, new_password = if new_userinfo
-        [
-          new_userinfo.to_str.strip[/^(.*):/, 1],
-          new_userinfo.to_str.strip[/:(.*)$/, 1]
-        ]
-      else
-        [nil, nil]
-      end
-
-      # Password assigned first to ensure validity in case of nil
-      self.password = new_password
-      self.user = new_user
-
-      # Reset dependent values
-      remove_instance_variable(:@authority) if defined?(@authority)
-      remove_composite_values
-
-      # Ensure we haven't created an invalid URI
-      validate()
-    end
-
-    ##
-    # The host component for this URI.
-    #
-    # @return [String] The host component.
-    def host
-      return defined?(@host) ? @host : nil
-    end
-
-    ##
-    # The host component for this URI, normalized.
-    #
-    # @return [String] The host component, normalized.
-    def normalized_host
-      return nil unless self.host
-
-      @normalized_host ||= begin
-        if !self.host.strip.empty?
-          result = ::Addressable::IDNA.to_ascii(
-            URI.unencode_component(self.host.strip.downcase)
-          )
-          if result =~ /[^\.]\.$/
-            # Single trailing dots are unnecessary.
-            result = result[0...-1]
-          end
-          result = Addressable::URI.normalize_component(
-            result,
-            NormalizeCharacterClasses::HOST
-          )
-          result
-        else
-          EMPTY_STR.dup
-        end
-      end
-      # All normalized values should be UTF-8
-      if @normalized_host && !@normalized_host.empty?
-        @normalized_host.force_encoding(Encoding::UTF_8)
-      end
-      @normalized_host
-    end
-
-    ##
-    # Sets the host component for this URI.
-    #
-    # @param [String, #to_str] new_host The new host component.
-    def host=(new_host)
-      if new_host && !new_host.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{new_host.class} into String."
-      end
-      @host = new_host ? new_host.to_str : nil
-
-      # Reset dependent values
-      remove_instance_variable(:@authority) if defined?(@authority)
-      remove_instance_variable(:@normalized_host) if defined?(@normalized_host)
-      remove_composite_values
-
-      # Ensure we haven't created an invalid URI
-      validate()
-    end
-
-    ##
-    # This method is same as URI::Generic#host except
-    # brackets for IPv6 (and 'IPvFuture') addresses are removed.
-    #
-    # @see Addressable::URI#host
-    #
-    # @return [String] The hostname for this URI.
-    def hostname
-      v = self.host
-      /\A\[(.*)\]\z/ =~ v ? $1 : v
-    end
-
-    ##
-    # This method is same as URI::Generic#host= except
-    # the argument can be a bare IPv6 address (or 'IPvFuture').
-    #
-    # @see Addressable::URI#host=
-    #
-    # @param [String, #to_str] new_hostname The new hostname for this URI.
-    def hostname=(new_hostname)
-      if new_hostname &&
-          (new_hostname.respond_to?(:ipv4?) || new_hostname.respond_to?(:ipv6?))
-        new_hostname = new_hostname.to_s
-      elsif new_hostname && !new_hostname.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{new_hostname.class} into String."
-      end
-      v = new_hostname ? new_hostname.to_str : nil
-      v = "[#{v}]" if /\A\[.*\]\z/ !~ v && /:/ =~ v
-      self.host = v
-    end
-
-    ##
-    # Returns the top-level domain for this host.
-    #
-    # @example
-    #   Addressable::URI.parse("http://www.example.co.uk").tld # => "co.uk"
-    def tld
-      PublicSuffix.parse(self.host, ignore_private: true).tld
-    end
-
-    ##
-    # Sets the top-level domain for this URI.
-    #
-    # @param [String, #to_str] new_tld The new top-level domain.
-    def tld=(new_tld)
-      replaced_tld = host.sub(/#{tld}\z/, new_tld)
-      self.host = PublicSuffix::Domain.new(replaced_tld).to_s
-    end
-
-    ##
-    # Returns the public suffix domain for this host.
-    #
-    # @example
-    #   Addressable::URI.parse("http://www.example.co.uk").domain # => "example.co.uk"
-    def domain
-      PublicSuffix.domain(self.host, ignore_private: true)
-    end
-
-    ##
-    # The authority component for this URI.
-    # Combines the user, password, host, and port components.
-    #
-    # @return [String] The authority component.
-    def authority
-      self.host && @authority ||= begin
-        authority = String.new
-        if self.userinfo != nil
-          authority << "#{self.userinfo}@"
-        end
-        authority << self.host
-        if self.port != nil
-          authority << ":#{self.port}"
-        end
-        authority
-      end
-    end
-
-    ##
-    # The authority component for this URI, normalized.
-    #
-    # @return [String] The authority component, normalized.
-    def normalized_authority
-      return nil unless self.authority
-      @normalized_authority ||= begin
-        authority = String.new
-        if self.normalized_userinfo != nil
-          authority << "#{self.normalized_userinfo}@"
-        end
-        authority << self.normalized_host
-        if self.normalized_port != nil
-          authority << ":#{self.normalized_port}"
-        end
-        authority
-      end
-      # All normalized values should be UTF-8
-      if @normalized_authority
-        @normalized_authority.force_encoding(Encoding::UTF_8)
-      end
-      @normalized_authority
-    end
-
-    ##
-    # Sets the authority component for this URI.
-    #
-    # @param [String, #to_str] new_authority The new authority component.
-    def authority=(new_authority)
-      if new_authority
-        if !new_authority.respond_to?(:to_str)
-          raise TypeError, "Can't convert #{new_authority.class} into String."
-        end
-        new_authority = new_authority.to_str
-        new_userinfo = new_authority[/^([^\[\]]*)@/, 1]
-        if new_userinfo
-          new_user = new_userinfo.strip[/^([^:]*):?/, 1]
-          new_password = new_userinfo.strip[/:(.*)$/, 1]
-        end
-        new_host = new_authority.sub(
-          /^([^\[\]]*)@/, EMPTY_STR
-        ).sub(
-          /:([^:@\[\]]*?)$/, EMPTY_STR
-        )
-        new_port =
-          new_authority[/:([^:@\[\]]*?)$/, 1]
-      end
-
-      # Password assigned first to ensure validity in case of nil
-      self.password = defined?(new_password) ? new_password : nil
-      self.user = defined?(new_user) ? new_user : nil
-      self.host = defined?(new_host) ? new_host : nil
-      self.port = defined?(new_port) ? new_port : nil
-
-      # Reset dependent values
-      remove_instance_variable(:@userinfo) if defined?(@userinfo)
-      remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
-      remove_composite_values
-
-      # Ensure we haven't created an invalid URI
-      validate()
-    end
-
-    ##
-    # The origin for this URI, serialized to ASCII, as per
-    # RFC 6454, section 6.2.
-    #
-    # @return [String] The serialized origin.
-    def origin
-      if self.scheme && self.authority
-        if self.normalized_port
-          "#{self.normalized_scheme}://#{self.normalized_host}" +
-          ":#{self.normalized_port}"
-        else
-          "#{self.normalized_scheme}://#{self.normalized_host}"
-        end
-      else
-        "null"
-      end
-    end
-
-    ##
-    # Sets the origin for this URI, serialized to ASCII, as per
-    # RFC 6454, section 6.2. This assignment will reset the `userinfo`
-    # component.
-    #
-    # @param [String, #to_str] new_origin The new origin component.
-    def origin=(new_origin)
-      if new_origin
-        if !new_origin.respond_to?(:to_str)
-          raise TypeError, "Can't convert #{new_origin.class} into String."
-        end
-        new_origin = new_origin.to_str
-        new_scheme = new_origin[/^([^:\/?#]+):\/\//, 1]
-        unless new_scheme
-          raise InvalidURIError, 'An origin cannot omit the scheme.'
-        end
-        new_host = new_origin[/:\/\/([^\/?#:]+)/, 1]
-        unless new_host
-          raise InvalidURIError, 'An origin cannot omit the host.'
-        end
-        new_port = new_origin[/:([^:@\[\]\/]*?)$/, 1]
-      end
-
-      self.scheme = defined?(new_scheme) ? new_scheme : nil
-      self.host = defined?(new_host) ? new_host : nil
-      self.port = defined?(new_port) ? new_port : nil
-      self.userinfo = nil
-
-      # Reset dependent values
-      remove_instance_variable(:@userinfo) if defined?(@userinfo)
-      remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
-      remove_instance_variable(:@authority) if defined?(@authority)
-      remove_instance_variable(:@normalized_authority) if defined?(@normalized_authority)
-      remove_composite_values
-
-      # Ensure we haven't created an invalid URI
-      validate()
-    end
-
-    # Returns an array of known ip-based schemes. These schemes typically
-    # use a similar URI form:
-    # <code>//<user>:<password>@<host>:<port>/<url-path></code>
-    def self.ip_based_schemes
-      return self.port_mapping.keys
-    end
-
-    # Returns a hash of common IP-based schemes and their default port
-    # numbers. Adding new schemes to this hash, as necessary, will allow
-    # for better URI normalization.
-    def self.port_mapping
-      PORT_MAPPING
-    end
-
-    ##
-    # The port component for this URI.
-    # This is the port number actually given in the URI. This does not
-    # infer port numbers from default values.
-    #
-    # @return [Integer] The port component.
-    def port
-      return defined?(@port) ? @port : nil
-    end
-
-    ##
-    # The port component for this URI, normalized.
-    #
-    # @return [Integer] The port component, normalized.
-    def normalized_port
-      return nil unless self.port
-      return @normalized_port if defined?(@normalized_port)
-      @normalized_port ||= begin
-        if URI.port_mapping[self.normalized_scheme] == self.port
-          nil
-        else
-          self.port
-        end
-      end
-    end
-
-    ##
-    # Sets the port component for this URI.
-    #
-    # @param [String, Integer, #to_s] new_port The new port component.
-    def port=(new_port)
-      if new_port != nil && new_port.respond_to?(:to_str)
-        new_port = Addressable::URI.unencode_component(new_port.to_str)
-      end
-
-      if new_port.respond_to?(:valid_encoding?) && !new_port.valid_encoding?
-        raise InvalidURIError, "Invalid encoding in port"
-      end
-
-      if new_port != nil && !(new_port.to_s =~ /^\d+$/)
-        raise InvalidURIError,
-          "Invalid port number: #{new_port.inspect}"
-      end
-
-      @port = new_port.to_s.to_i
-      @port = nil if @port == 0
-
-      # Reset dependent values
-      remove_instance_variable(:@authority) if defined?(@authority)
-      remove_instance_variable(:@normalized_port) if defined?(@normalized_port)
-      remove_composite_values
-
-      # Ensure we haven't created an invalid URI
-      validate()
-    end
-
-    ##
-    # The inferred port component for this URI.
-    # This method will normalize to the default port for the URI's scheme if
-    # the port isn't explicitly specified in the URI.
-    #
-    # @return [Integer] The inferred port component.
-    def inferred_port
-      if self.port.to_i == 0
-        self.default_port
-      else
-        self.port.to_i
-      end
-    end
-
-    ##
-    # The default port for this URI's scheme.
-    # This method will always returns the default port for the URI's scheme
-    # regardless of the presence of an explicit port in the URI.
-    #
-    # @return [Integer] The default port.
-    def default_port
-      URI.port_mapping[self.scheme.strip.downcase] if self.scheme
-    end
-
-    ##
-    # The combination of components that represent a site.
-    # Combines the scheme, user, password, host, and port components.
-    # Primarily useful for HTTP and HTTPS.
-    #
-    # For example, <code>"http://example.com/path?query"</code> would have a
-    # <code>site</code> value of <code>"http://example.com"</code>.
-    #
-    # @return [String] The components that identify a site.
-    def site
-      (self.scheme || self.authority) && @site ||= begin
-        site_string = "".dup
-        site_string << "#{self.scheme}:" if self.scheme != nil
-        site_string << "//#{self.authority}" if self.authority != nil
-        site_string
-      end
-    end
-
-    ##
-    # The normalized combination of components that represent a site.
-    # Combines the scheme, user, password, host, and port components.
-    # Primarily useful for HTTP and HTTPS.
-    #
-    # For example, <code>"http://example.com/path?query"</code> would have a
-    # <code>site</code> value of <code>"http://example.com"</code>.
-    #
-    # @return [String] The normalized components that identify a site.
-    def normalized_site
-      return nil unless self.site
-      @normalized_site ||= begin
-        site_string = "".dup
-        if self.normalized_scheme != nil
-          site_string << "#{self.normalized_scheme}:"
-        end
-        if self.normalized_authority != nil
-          site_string << "//#{self.normalized_authority}"
-        end
-        site_string
-      end
-      # All normalized values should be UTF-8
-      @normalized_site.force_encoding(Encoding::UTF_8) if @normalized_site
-      @normalized_site
-    end
-
-    ##
-    # Sets the site value for this URI.
-    #
-    # @param [String, #to_str] new_site The new site value.
-    def site=(new_site)
-      if new_site
-        if !new_site.respond_to?(:to_str)
-          raise TypeError, "Can't convert #{new_site.class} into String."
-        end
-        new_site = new_site.to_str
-        # These two regular expressions derived from the primary parsing
-        # expression
-        self.scheme = new_site[/^(?:([^:\/?#]+):)?(?:\/\/(?:[^\/?#]*))?$/, 1]
-        self.authority = new_site[
-          /^(?:(?:[^:\/?#]+):)?(?:\/\/([^\/?#]*))?$/, 1
-        ]
-      else
-        self.scheme = nil
-        self.authority = nil
-      end
-    end
-
-    ##
-    # The path component for this URI.
-    #
-    # @return [String] The path component.
-    def path
-      return defined?(@path) ? @path : EMPTY_STR
-    end
-
-    NORMPATH = /^(?!\/)[^\/:]*:.*$/
-    ##
-    # The path component for this URI, normalized.
-    #
-    # @return [String] The path component, normalized.
-    def normalized_path
-      @normalized_path ||= begin
-        path = self.path.to_s
-        if self.scheme == nil && path =~ NORMPATH
-          # Relative paths with colons in the first segment are ambiguous.
-          path = path.sub(":", "%2F")
-        end
-        # String#split(delimeter, -1) uses the more strict splitting behavior
-        # found by default in Python.
-        result = path.strip.split(SLASH, -1).map do |segment|
-          Addressable::URI.normalize_component(
-            segment,
-            Addressable::URI::NormalizeCharacterClasses::PCHAR
-          )
-        end.join(SLASH)
-
-        result = URI.normalize_path(result)
-        if result.empty? &&
-            ["http", "https", "ftp", "tftp"].include?(self.normalized_scheme)
-          result = SLASH.dup
-        end
-        result
-      end
-      # All normalized values should be UTF-8
-      @normalized_path.force_encoding(Encoding::UTF_8) if @normalized_path
-      @normalized_path
-    end
-
-    ##
-    # Sets the path component for this URI.
-    #
-    # @param [String, #to_str] new_path The new path component.
-    def path=(new_path)
-      if new_path && !new_path.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{new_path.class} into String."
-      end
-      @path = (new_path || EMPTY_STR).to_str
-      if !@path.empty? && @path[0..0] != SLASH && host != nil
-        @path = "/#{@path}"
-      end
-
-      # Reset dependent values
-      remove_instance_variable(:@normalized_path) if defined?(@normalized_path)
-      remove_composite_values
-
-      # Ensure we haven't created an invalid URI
-      validate()
-    end
-
-    ##
-    # The basename, if any, of the file in the path component.
-    #
-    # @return [String] The path's basename.
-    def basename
-      # Path cannot be nil
-      return File.basename(self.path).sub(/;[^\/]*$/, EMPTY_STR)
-    end
-
-    ##
-    # The extname, if any, of the file in the path component.
-    # Empty string if there is no extension.
-    #
-    # @return [String] The path's extname.
-    def extname
-      return nil unless self.path
-      return File.extname(self.basename)
-    end
-
-    ##
-    # The query component for this URI.
-    #
-    # @return [String] The query component.
-    def query
-      return defined?(@query) ? @query : nil
-    end
-
-    ##
-    # The query component for this URI, normalized.
-    #
-    # @return [String] The query component, normalized.
-    def normalized_query(*flags)
-      return nil unless self.query
-      return @normalized_query if defined?(@normalized_query)
-      @normalized_query ||= begin
-        modified_query_class = Addressable::URI::CharacterClasses::QUERY.dup
-        # Make sure possible key-value pair delimiters are escaped.
-        modified_query_class.sub!("\\&", "").sub!("\\;", "")
-        pairs = (query || "").split("&", -1)
-        pairs.delete_if(&:empty?).uniq! if flags.include?(:compacted)
-        pairs.sort! if flags.include?(:sorted)
-        component = pairs.map do |pair|
-          Addressable::URI.normalize_component(
-            pair,
-            Addressable::URI::NormalizeCharacterClasses::QUERY,
-            "+"
-          )
-        end.join("&")
-        component == "" ? nil : component
-      end
-      # All normalized values should be UTF-8
-      @normalized_query.force_encoding(Encoding::UTF_8) if @normalized_query
-      @normalized_query
-    end
-
-    ##
-    # Sets the query component for this URI.
-    #
-    # @param [String, #to_str] new_query The new query component.
-    def query=(new_query)
-      if new_query && !new_query.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{new_query.class} into String."
-      end
-      @query = new_query ? new_query.to_str : nil
-
-      # Reset dependent values
-      remove_instance_variable(:@normalized_query) if defined?(@normalized_query)
-      remove_composite_values
-    end
-
-    ##
-    # Converts the query component to a Hash value.
-    #
-    # @param [Class] return_type The return type desired. Value must be either
-    #   `Hash` or `Array`.
-    #
-    # @return [Hash, Array, nil] The query string parsed as a Hash or Array
-    #   or nil if the query string is blank.
-    #
-    # @example
-    #   Addressable::URI.parse("?one=1&two=2&three=3").query_values
-    #   #=> {"one" => "1", "two" => "2", "three" => "3"}
-    #   Addressable::URI.parse("?one=two&one=three").query_values(Array)
-    #   #=> [["one", "two"], ["one", "three"]]
-    #   Addressable::URI.parse("?one=two&one=three").query_values(Hash)
-    #   #=> {"one" => "three"}
-    #   Addressable::URI.parse("?").query_values
-    #   #=> {}
-    #   Addressable::URI.parse("").query_values
-    #   #=> nil
-    def query_values(return_type=Hash)
-      empty_accumulator = Array == return_type ? [] : {}
-      if return_type != Hash && return_type != Array
-        raise ArgumentError, "Invalid return type. Must be Hash or Array."
-      end
-      return nil if self.query == nil
-      split_query = self.query.split("&").map do |pair|
-        pair.split("=", 2) if pair && !pair.empty?
-      end.compact
-      return split_query.inject(empty_accumulator.dup) do |accu, pair|
-        # I'd rather use key/value identifiers instead of array lookups,
-        # but in this case I really want to maintain the exact pair structure,
-        # so it's best to make all changes in-place.
-        pair[0] = URI.unencode_component(pair[0])
-        if pair[1].respond_to?(:to_str)
-          value = pair[1].to_str
-          # I loathe the fact that I have to do this. Stupid HTML 4.01.
-          # Treating '+' as a space was just an unbelievably bad idea.
-          # There was nothing wrong with '%20'!
-          # If it ain't broke, don't fix it!
-          value = value.tr("+", " ") if ["http", "https", nil].include?(scheme)
-          pair[1] = URI.unencode_component(value)
-        end
-        if return_type == Hash
-          accu[pair[0]] = pair[1]
-        else
-          accu << pair
-        end
-        accu
-      end
-    end
-
-    ##
-    # Sets the query component for this URI from a Hash object.
-    # An empty Hash or Array will result in an empty query string.
-    #
-    # @param [Hash, #to_hash, Array] new_query_values The new query values.
-    #
-    # @example
-    #   uri.query_values = {:a => "a", :b => ["c", "d", "e"]}
-    #   uri.query
-    #   # => "a=a&b=c&b=d&b=e"
-    #   uri.query_values = [['a', 'a'], ['b', 'c'], ['b', 'd'], ['b', 'e']]
-    #   uri.query
-    #   # => "a=a&b=c&b=d&b=e"
-    #   uri.query_values = [['a', 'a'], ['b', ['c', 'd', 'e']]]
-    #   uri.query
-    #   # => "a=a&b=c&b=d&b=e"
-    #   uri.query_values = [['flag'], ['key', 'value']]
-    #   uri.query
-    #   # => "flag&key=value"
-    def query_values=(new_query_values)
-      if new_query_values == nil
-        self.query = nil
-        return nil
-      end
-
-      if !new_query_values.is_a?(Array)
-        if !new_query_values.respond_to?(:to_hash)
-          raise TypeError,
-            "Can't convert #{new_query_values.class} into Hash."
-        end
-        new_query_values = new_query_values.to_hash
-        new_query_values = new_query_values.map do |key, value|
-          key = key.to_s if key.kind_of?(Symbol)
-          [key, value]
-        end
-        # Useful default for OAuth and caching.
-        # Only to be used for non-Array inputs. Arrays should preserve order.
-        new_query_values.sort!
-      end
-
-      # new_query_values have form [['key1', 'value1'], ['key2', 'value2']]
-      buffer = "".dup
-      new_query_values.each do |key, value|
-        encoded_key = URI.encode_component(
-          key, CharacterClasses::UNRESERVED
-        )
-        if value == nil
-          buffer << "#{encoded_key}&"
-        elsif value.kind_of?(Array)
-          value.each do |sub_value|
-            encoded_value = URI.encode_component(
-              sub_value, CharacterClasses::UNRESERVED
-            )
-            buffer << "#{encoded_key}=#{encoded_value}&"
-          end
-        else
-          encoded_value = URI.encode_component(
-            value, CharacterClasses::UNRESERVED
-          )
-          buffer << "#{encoded_key}=#{encoded_value}&"
-        end
-      end
-      self.query = buffer.chop
-    end
-
-    ##
-    # The HTTP request URI for this URI.  This is the path and the
-    # query string.
-    #
-    # @return [String] The request URI required for an HTTP request.
-    def request_uri
-      return nil if self.absolute? && self.scheme !~ /^https?$/i
-      return (
-        (!self.path.empty? ? self.path : SLASH) +
-        (self.query ? "?#{self.query}" : EMPTY_STR)
-      )
-    end
-
-    ##
-    # Sets the HTTP request URI for this URI.
-    #
-    # @param [String, #to_str] new_request_uri The new HTTP request URI.
-    def request_uri=(new_request_uri)
-      if !new_request_uri.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{new_request_uri.class} into String."
-      end
-      if self.absolute? && self.scheme !~ /^https?$/i
-        raise InvalidURIError,
-          "Cannot set an HTTP request URI for a non-HTTP URI."
-      end
-      new_request_uri = new_request_uri.to_str
-      path_component = new_request_uri[/^([^\?]*)\??(?:.*)$/, 1]
-      query_component = new_request_uri[/^(?:[^\?]*)\?(.*)$/, 1]
-      path_component = path_component.to_s
-      path_component = (!path_component.empty? ? path_component : SLASH)
-      self.path = path_component
-      self.query = query_component
-
-      # Reset dependent values
-      remove_composite_values
-    end
-
-    ##
-    # The fragment component for this URI.
-    #
-    # @return [String] The fragment component.
-    def fragment
-      return defined?(@fragment) ? @fragment : nil
-    end
-
-    ##
-    # The fragment component for this URI, normalized.
-    #
-    # @return [String] The fragment component, normalized.
-    def normalized_fragment
-      return nil unless self.fragment
-      return @normalized_fragment if defined?(@normalized_fragment)
-      @normalized_fragment ||= begin
-        component = Addressable::URI.normalize_component(
-          self.fragment,
-          Addressable::URI::NormalizeCharacterClasses::FRAGMENT
-        )
-        component == "" ? nil : component
-      end
-      # All normalized values should be UTF-8
-      if @normalized_fragment
-        @normalized_fragment.force_encoding(Encoding::UTF_8)
-      end
-      @normalized_fragment
-    end
-
-    ##
-    # Sets the fragment component for this URI.
-    #
-    # @param [String, #to_str] new_fragment The new fragment component.
-    def fragment=(new_fragment)
-      if new_fragment && !new_fragment.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{new_fragment.class} into String."
-      end
-      @fragment = new_fragment ? new_fragment.to_str : nil
-
-      # Reset dependent values
-      remove_instance_variable(:@normalized_fragment) if defined?(@normalized_fragment)
-      remove_composite_values
-
-      # Ensure we haven't created an invalid URI
-      validate()
-    end
-
-    ##
-    # Determines if the scheme indicates an IP-based protocol.
-    #
-    # @return [TrueClass, FalseClass]
-    #   <code>true</code> if the scheme indicates an IP-based protocol.
-    #   <code>false</code> otherwise.
-    def ip_based?
-      if self.scheme
-        return URI.ip_based_schemes.include?(
-          self.scheme.strip.downcase)
-      end
-      return false
-    end
-
-    ##
-    # Determines if the URI is relative.
-    #
-    # @return [TrueClass, FalseClass]
-    #   <code>true</code> if the URI is relative. <code>false</code>
-    #   otherwise.
-    def relative?
-      return self.scheme.nil?
-    end
-
-    ##
-    # Determines if the URI is absolute.
-    #
-    # @return [TrueClass, FalseClass]
-    #   <code>true</code> if the URI is absolute. <code>false</code>
-    #   otherwise.
-    def absolute?
-      return !relative?
-    end
-
-    ##
-    # Joins two URIs together.
-    #
-    # @param [String, Addressable::URI, #to_str] The URI to join with.
-    #
-    # @return [Addressable::URI] The joined URI.
-    def join(uri)
-      if !uri.respond_to?(:to_str)
-        raise TypeError, "Can't convert #{uri.class} into String."
-      end
-      if !uri.kind_of?(URI)
-        # Otherwise, convert to a String, then parse.
-        uri = URI.parse(uri.to_str)
-      end
-      if uri.to_s.empty?
-        return self.dup
-      end
-
-      joined_scheme = nil
-      joined_user = nil
-      joined_password = nil
-      joined_host = nil
-      joined_port = nil
-      joined_path = nil
-      joined_query = nil
-      joined_fragment = nil
-
-      # Section 5.2.2 of RFC 3986
-      if uri.scheme != nil
-        joined_scheme = uri.scheme
-        joined_user = uri.user
-        joined_password = uri.password
-        joined_host = uri.host
-        joined_port = uri.port
-        joined_path = URI.normalize_path(uri.path)
-        joined_query = uri.query
-      else
-        if uri.authority != nil
-          joined_user = uri.user
-          joined_password = uri.password
-          joined_host = uri.host
-          joined_port = uri.port
-          joined_path = URI.normalize_path(uri.path)
-          joined_query = uri.query
-        else
-          if uri.path == nil || uri.path.empty?
-            joined_path = self.path
-            if uri.query != nil
-              joined_query = uri.query
-            else
-              joined_query = self.query
-            end
-          else
-            if uri.path[0..0] == SLASH
-              joined_path = URI.normalize_path(uri.path)
-            else
-              base_path = self.path.dup
-              base_path = EMPTY_STR if base_path == nil
-              base_path = URI.normalize_path(base_path)
-
-              # Section 5.2.3 of RFC 3986
-              #
-              # Removes the right-most path segment from the base path.
-              if base_path.include?(SLASH)
-                base_path.sub!(/\/[^\/]+$/, SLASH)
-              else
-                base_path = EMPTY_STR
-              end
-
-              # If the base path is empty and an authority segment has been
-              # defined, use a base path of SLASH
-              if base_path.empty? && self.authority != nil
-                base_path = SLASH
-              end
-
-              joined_path = URI.normalize_path(base_path + uri.path)
-            end
-            joined_query = uri.query
-          end
-          joined_user = self.user
-          joined_password = self.password
-          joined_host = self.host
-          joined_port = self.port
-        end
-        joined_scheme = self.scheme
-      end
-      joined_fragment = uri.fragment
-
-      return self.class.new(
-        :scheme => joined_scheme,
-        :user => joined_user,
-        :password => joined_password,
-        :host => joined_host,
-        :port => joined_port,
-        :path => joined_path,
-        :query => joined_query,
-        :fragment => joined_fragment
-      )
-    end
-    alias_method :+, :join
-
-    ##
-    # Destructive form of <code>join</code>.
-    #
-    # @param [String, Addressable::URI, #to_str] The URI to join with.
-    #
-    # @return [Addressable::URI] The joined URI.
-    #
-    # @see Addressable::URI#join
-    def join!(uri)
-      replace_self(self.join(uri))
-    end
-
-    ##
-    # Merges a URI with a <code>Hash</code> of components.
-    # This method has different behavior from <code>join</code>. Any
-    # components present in the <code>hash</code> parameter will override the
-    # original components. The path component is not treated specially.
-    #
-    # @param [Hash, Addressable::URI, #to_hash] The components to merge with.
-    #
-    # @return [Addressable::URI] The merged URI.
-    #
-    # @see Hash#merge
-    def merge(hash)
-      if !hash.respond_to?(:to_hash)
-        raise TypeError, "Can't convert #{hash.class} into Hash."
-      end
-      hash = hash.to_hash
-
-      if hash.has_key?(:authority)
-        if (hash.keys & [:userinfo, :user, :password, :host, :port]).any?
-          raise ArgumentError,
-            "Cannot specify both an authority and any of the components " +
-            "within the authority."
-        end
-      end
-      if hash.has_key?(:userinfo)
-        if (hash.keys & [:user, :password]).any?
-          raise ArgumentError,
-            "Cannot specify both a userinfo and either the user or password."
-        end
-      end
-
-      uri = self.class.new
-      uri.defer_validation do
-        # Bunch of crazy logic required because of the composite components
-        # like userinfo and authority.
-        uri.scheme =
-          hash.has_key?(:scheme) ? hash[:scheme] : self.scheme
-        if hash.has_key?(:authority)
-          uri.authority =
-            hash.has_key?(:authority) ? hash[:authority] : self.authority
-        end
-        if hash.has_key?(:userinfo)
-          uri.userinfo =
-            hash.has_key?(:userinfo) ? hash[:userinfo] : self.userinfo
-        end
-        if !hash.has_key?(:userinfo) && !hash.has_key?(:authority)
-          uri.user =
-            hash.has_key?(:user) ? hash[:user] : self.user
-          uri.password =
-            hash.has_key?(:password) ? hash[:password] : self.password
-        end
-        if !hash.has_key?(:authority)
-          uri.host =
-            hash.has_key?(:host) ? hash[:host] : self.host
-          uri.port =
-            hash.has_key?(:port) ? hash[:port] : self.port
-        end
-        uri.path =
-          hash.has_key?(:path) ? hash[:path] : self.path
-        uri.query =
-          hash.has_key?(:query) ? hash[:query] : self.query
-        uri.fragment =
-          hash.has_key?(:fragment) ? hash[:fragment] : self.fragment
-      end
-
-      return uri
-    end
-
-    ##
-    # Destructive form of <code>merge</code>.
-    #
-    # @param [Hash, Addressable::URI, #to_hash] The components to merge with.
-    #
-    # @return [Addressable::URI] The merged URI.
-    #
-    # @see Addressable::URI#merge
-    def merge!(uri)
-      replace_self(self.merge(uri))
-    end
-
-    ##
-    # Returns the shortest normalized relative form of this URI that uses the
-    # supplied URI as a base for resolution. Returns an absolute URI if
-    # necessary. This is effectively the opposite of <code>route_to</code>.
-    #
-    # @param [String, Addressable::URI, #to_str] uri The URI to route from.
-    #
-    # @return [Addressable::URI]
-    #   The normalized relative URI that is equivalent to the original URI.
-    def route_from(uri)
-      uri = URI.parse(uri).normalize
-      normalized_self = self.normalize
-      if normalized_self.relative?
-        raise ArgumentError, "Expected absolute URI, got: #{self.to_s}"
-      end
-      if uri.relative?
-        raise ArgumentError, "Expected absolute URI, got: #{uri.to_s}"
-      end
-      if normalized_self == uri
-        return Addressable::URI.parse("##{normalized_self.fragment}")
-      end
-      components = normalized_self.to_hash
-      if normalized_self.scheme == uri.scheme
-        components[:scheme] = nil
-        if normalized_self.authority == uri.authority
-          components[:user] = nil
-          components[:password] = nil
-          components[:host] = nil
-          components[:port] = nil
-          if normalized_self.path == uri.path
-            components[:path] = nil
-            if normalized_self.query == uri.query
-              components[:query] = nil
-            end
-          else
-            if uri.path != SLASH and components[:path]
-              self_splitted_path = split_path(components[:path])
-              uri_splitted_path = split_path(uri.path)
-              self_dir = self_splitted_path.shift
-              uri_dir = uri_splitted_path.shift
-              while !self_splitted_path.empty? && !uri_splitted_path.empty? and self_dir == uri_dir
-                self_dir = self_splitted_path.shift
-                uri_dir = uri_splitted_path.shift
-              end
-              components[:path] = (uri_splitted_path.fill('..') + [self_dir] + self_splitted_path).join(SLASH)
-            end
-          end
-        end
-      end
-      # Avoid network-path references.
-      if components[:host] != nil
-        components[:scheme] = normalized_self.scheme
-      end
-      return Addressable::URI.new(
-        :scheme => components[:scheme],
-        :user => components[:user],
-        :password => components[:password],
-        :host => components[:host],
-        :port => components[:port],
-        :path => components[:path],
-        :query => components[:query],
-        :fragment => components[:fragment]
-      )
-    end
-
-    ##
-    # Returns the shortest normalized relative form of the supplied URI that
-    # uses this URI as a base for resolution. Returns an absolute URI if
-    # necessary. This is effectively the opposite of <code>route_from</code>.
-    #
-    # @param [String, Addressable::URI, #to_str] uri The URI to route to.
-    #
-    # @return [Addressable::URI]
-    #   The normalized relative URI that is equivalent to the supplied URI.
-    def route_to(uri)
-      return URI.parse(uri).route_from(self)
-    end
-
-    ##
-    # Returns a normalized URI object.
-    #
-    # NOTE: This method does not attempt to fully conform to specifications.
-    # It exists largely to correct other people's failures to read the
-    # specifications, and also to deal with caching issues since several
-    # different URIs may represent the same resource and should not be
-    # cached multiple times.
-    #
-    # @return [Addressable::URI] The normalized URI.
-    def normalize
-      # This is a special exception for the frequently misused feed
-      # URI scheme.
-      if normalized_scheme == "feed"
-        if self.to_s =~ /^feed:\/*http:\/*/
-          return URI.parse(
-            self.to_s[/^feed:\/*(http:\/*.*)/, 1]
-          ).normalize
-        end
-      end
-
-      return self.class.new(
-        :scheme => normalized_scheme,
-        :authority => normalized_authority,
-        :path => normalized_path,
-        :query => normalized_query,
-        :fragment => normalized_fragment
-      )
-    end
-
-    ##
-    # Destructively normalizes this URI object.
-    #
-    # @return [Addressable::URI] The normalized URI.
-    #
-    # @see Addressable::URI#normalize
-    def normalize!
-      replace_self(self.normalize)
-    end
-
-    ##
-    # Creates a URI suitable for display to users. If semantic attacks are
-    # likely, the application should try to detect these and warn the user.
-    # See <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>,
-    # section 7.6 for more information.
-    #
-    # @return [Addressable::URI] A URI suitable for display purposes.
-    def display_uri
-      display_uri = self.normalize
-      display_uri.host = ::Addressable::IDNA.to_unicode(display_uri.host)
-      return display_uri
-    end
-
-    ##
-    # Returns <code>true</code> if the URI objects are equal. This method
-    # normalizes both URIs before doing the comparison, and allows comparison
-    # against <code>Strings</code>.
-    #
-    # @param [Object] uri The URI to compare.
-    #
-    # @return [TrueClass, FalseClass]
-    #   <code>true</code> if the URIs are equivalent, <code>false</code>
-    #   otherwise.
-    def ===(uri)
-      if uri.respond_to?(:normalize)
-        uri_string = uri.normalize.to_s
-      else
-        begin
-          uri_string = ::Addressable::URI.parse(uri).normalize.to_s
-        rescue InvalidURIError, TypeError
-          return false
-        end
-      end
-      return self.normalize.to_s == uri_string
-    end
-
-    ##
-    # Returns <code>true</code> if the URI objects are equal. This method
-    # normalizes both URIs before doing the comparison.
-    #
-    # @param [Object] uri The URI to compare.
-    #
-    # @return [TrueClass, FalseClass]
-    #   <code>true</code> if the URIs are equivalent, <code>false</code>
-    #   otherwise.
-    def ==(uri)
-      return false unless uri.kind_of?(URI)
-      return self.normalize.to_s == uri.normalize.to_s
-    end
-
-    ##
-    # Returns <code>true</code> if the URI objects are equal. This method
-    # does NOT normalize either URI before doing the comparison.
-    #
-    # @param [Object] uri The URI to compare.
-    #
-    # @return [TrueClass, FalseClass]
-    #   <code>true</code> if the URIs are equivalent, <code>false</code>
-    #   otherwise.
-    def eql?(uri)
-      return false unless uri.kind_of?(URI)
-      return self.to_s == uri.to_s
-    end
-
-    ##
-    # A hash value that will make a URI equivalent to its normalized
-    # form.
-    #
-    # @return [Integer] A hash of the URI.
-    def hash
-      @hash ||= self.to_s.hash * -1
-    end
-
-    ##
-    # Clones the URI object.
-    #
-    # @return [Addressable::URI] The cloned URI.
-    def dup
-      duplicated_uri = self.class.new(
-        :scheme => self.scheme ? self.scheme.dup : nil,
-        :user => self.user ? self.user.dup : nil,
-        :password => self.password ? self.password.dup : nil,
-        :host => self.host ? self.host.dup : nil,
-        :port => self.port,
-        :path => self.path ? self.path.dup : nil,
-        :query => self.query ? self.query.dup : nil,
-        :fragment => self.fragment ? self.fragment.dup : nil
-      )
-      return duplicated_uri
-    end
-
-    ##
-    # Omits components from a URI.
-    #
-    # @param [Symbol] *components The components to be omitted.
-    #
-    # @return [Addressable::URI] The URI with components omitted.
-    #
-    # @example
-    #   uri = Addressable::URI.parse("http://example.com/path?query")
-    #   #=> #<Addressable::URI:0xcc5e7a URI:http://example.com/path?query>
-    #   uri.omit(:scheme, :authority)
-    #   #=> #<Addressable::URI:0xcc4d86 URI:/path?query>
-    def omit(*components)
-      invalid_components = components - [
-        :scheme, :user, :password, :userinfo, :host, :port, :authority,
-        :path, :query, :fragment
-      ]
-      unless invalid_components.empty?
-        raise ArgumentError,
-          "Invalid component names: #{invalid_components.inspect}."
-      end
-      duplicated_uri = self.dup
-      duplicated_uri.defer_validation do
-        components.each do |component|
-          duplicated_uri.send((component.to_s + "=").to_sym, nil)
-        end
-        duplicated_uri.user = duplicated_uri.normalized_user
-      end
-      duplicated_uri
-    end
-
-    ##
-    # Destructive form of omit.
-    #
-    # @param [Symbol] *components The components to be omitted.
-    #
-    # @return [Addressable::URI] The URI with components omitted.
-    #
-    # @see Addressable::URI#omit
-    def omit!(*components)
-      replace_self(self.omit(*components))
-    end
-
-    ##
-    # Determines if the URI is an empty string.
-    #
-    # @return [TrueClass, FalseClass]
-    #   Returns <code>true</code> if empty, <code>false</code> otherwise.
-    def empty?
-      return self.to_s.empty?
-    end
-
-    ##
-    # Converts the URI to a <code>String</code>.
-    #
-    # @return [String] The URI's <code>String</code> representation.
-    def to_s
-      if self.scheme == nil && self.path != nil && !self.path.empty? &&
-          self.path =~ NORMPATH
-        raise InvalidURIError,
-          "Cannot assemble URI string with ambiguous path: '#{self.path}'"
-      end
-      @uri_string ||= begin
-        uri_string = String.new
-        uri_string << "#{self.scheme}:" if self.scheme != nil
-        uri_string << "//#{self.authority}" if self.authority != nil
-        uri_string << self.path.to_s
-        uri_string << "?#{self.query}" if self.query != nil
-        uri_string << "##{self.fragment}" if self.fragment != nil
-        uri_string.force_encoding(Encoding::UTF_8)
-        uri_string
-      end
-    end
-
-    ##
-    # URI's are glorified <code>Strings</code>. Allow implicit conversion.
-    alias_method :to_str, :to_s
-
-    ##
-    # Returns a Hash of the URI components.
-    #
-    # @return [Hash] The URI as a <code>Hash</code> of components.
-    def to_hash
-      return {
-        :scheme => self.scheme,
-        :user => self.user,
-        :password => self.password,
-        :host => self.host,
-        :port => self.port,
-        :path => self.path,
-        :query => self.query,
-        :fragment => self.fragment
-      }
-    end
-
-    ##
-    # Returns a <code>String</code> representation of the URI object's state.
-    #
-    # @return [String] The URI object's state, as a <code>String</code>.
-    def inspect
-      sprintf("#<%s:%#0x URI:%s>", URI.to_s, self.object_id, self.to_s)
-    end
-
-    ##
-    # This method allows you to make several changes to a URI simultaneously,
-    # which separately would cause validation errors, but in conjunction,
-    # are valid.  The URI will be revalidated as soon as the entire block has
-    # been executed.
-    #
-    # @param [Proc] block
-    #   A set of operations to perform on a given URI.
-    def defer_validation
-      raise LocalJumpError, "No block given." unless block_given?
-      @validation_deferred = true
-      yield
-      @validation_deferred = false
-      validate
-      return nil
-    end
-
-  protected
-    SELF_REF = '.'
-    PARENT = '..'
-
-    RULE_2A = /\/\.\/|\/\.$/
-    RULE_2B_2C = /\/([^\/]*)\/\.\.\/|\/([^\/]*)\/\.\.$/
-    RULE_2D = /^\.\.?\/?/
-    RULE_PREFIXED_PARENT = /^\/\.\.?\/|^(\/\.\.?)+\/?$/
-
-    ##
-    # Resolves paths to their simplest form.
-    #
-    # @param [String] path The path to normalize.
-    #
-    # @return [String] The normalized path.
-    def self.normalize_path(path)
-      # Section 5.2.4 of RFC 3986
-
-      return nil if path.nil?
-      normalized_path = path.dup
-      begin
-        mod = nil
-        mod ||= normalized_path.gsub!(RULE_2A, SLASH)
-
-        pair = normalized_path.match(RULE_2B_2C)
-        parent, current = pair[1], pair[2] if pair
-        if pair && ((parent != SELF_REF && parent != PARENT) ||
-            (current != SELF_REF && current != PARENT))
-          mod ||= normalized_path.gsub!(
-            Regexp.new(
-              "/#{Regexp.escape(parent.to_s)}/\\.\\./|" +
-              "(/#{Regexp.escape(current.to_s)}/\\.\\.$)"
-            ), SLASH
-          )
-        end
-
-        mod ||= normalized_path.gsub!(RULE_2D, EMPTY_STR)
-        # Non-standard, removes prefixed dotted segments from path.
-        mod ||= normalized_path.gsub!(RULE_PREFIXED_PARENT, SLASH)
-      end until mod.nil?
-
-      return normalized_path
-    end
-
-    ##
-    # Ensures that the URI is valid.
-    def validate
-      return if !!@validation_deferred
-      if self.scheme != nil && self.ip_based? &&
-          (self.host == nil || self.host.empty?) &&
-          (self.path == nil || self.path.empty?)
-        raise InvalidURIError,
-          "Absolute URI missing hierarchical segment: '#{self.to_s}'"
-      end
-      if self.host == nil
-        if self.port != nil ||
-            self.user != nil ||
-            self.password != nil
-          raise InvalidURIError, "Hostname not supplied: '#{self.to_s}'"
-        end
-      end
-      if self.path != nil && !self.path.empty? && self.path[0..0] != SLASH &&
-          self.authority != nil
-        raise InvalidURIError,
-          "Cannot have a relative path with an authority set: '#{self.to_s}'"
-      end
-      if self.path != nil && !self.path.empty? &&
-          self.path[0..1] == SLASH + SLASH && self.authority == nil
-        raise InvalidURIError,
-          "Cannot have a path with two leading slashes " +
-          "without an authority set: '#{self.to_s}'"
-      end
-      unreserved = CharacterClasses::UNRESERVED
-      sub_delims = CharacterClasses::SUB_DELIMS
-      if !self.host.nil? && (self.host =~ /[<>{}\/\\\?\#\@"[[:space:]]]/ ||
-          (self.host[/^\[(.*)\]$/, 1] != nil && self.host[/^\[(.*)\]$/, 1] !~
-          Regexp.new("^[#{unreserved}#{sub_delims}:]*$")))
-        raise InvalidURIError, "Invalid character in host: '#{self.host.to_s}'"
-      end
-      return nil
-    end
-
-    ##
-    # Replaces the internal state of self with the specified URI's state.
-    # Used in destructive operations to avoid massive code repetition.
-    #
-    # @param [Addressable::URI] uri The URI to replace <code>self</code> with.
-    #
-    # @return [Addressable::URI] <code>self</code>.
-    def replace_self(uri)
-      # Reset dependent values
-      instance_variables.each do |var|
-        if instance_variable_defined?(var) && var != :@validation_deferred
-          remove_instance_variable(var)
-        end
-      end
-
-      @scheme = uri.scheme
-      @user = uri.user
-      @password = uri.password
-      @host = uri.host
-      @port = uri.port
-      @path = uri.path
-      @query = uri.query
-      @fragment = uri.fragment
-      return self
-    end
-
-    ##
-    # Splits path string with "/" (slash).
-    # It is considered that there is empty string after last slash when
-    # path ends with slash.
-    #
-    # @param [String] path The path to split.
-    #
-    # @return [Array<String>] An array of parts of path.
-    def split_path(path)
-      splitted = path.split(SLASH)
-      splitted << EMPTY_STR if path.end_with? SLASH
-      splitted
-    end
-
-    ##
-    # Resets composite values for the entire URI
-    #
-    # @api private
-    def remove_composite_values
-      remove_instance_variable(:@uri_string) if defined?(@uri_string)
-      remove_instance_variable(:@hash) if defined?(@hash)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/version.rb
deleted file mode 100644
index 2efe4340f30d6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/version.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-# encoding:utf-8
-#--
-# Copyright (C) Bob Aman
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-#++
-
-
-# Used to prevent the class/module from being loaded more than once
-if !defined?(Addressable::VERSION)
-  module Addressable
-    module VERSION
-      MAJOR = 2
-      MINOR = 8
-      TINY  = 0
-
-      STRING = [MAJOR, MINOR, TINY].join('.')
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/alignment.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/alignment.rb
deleted file mode 100644
index baa517ac9c686..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/alignment.rb
+++ /dev/null
@@ -1,79 +0,0 @@
-require 'bindata/base_primitive'
-
-module BinData
-  # Resets the stream alignment to the next byte.  This is
-  # only useful when using bit-based primitives.
-  #
-  #    class MyRec < BinData::Record
-  #      bit4 :a
-  #      resume_byte_alignment
-  #      bit4 :b
-  #    end
-  #
-  #    MyRec.read("\x12\x34") #=> {"a" => 1, "b" => 3}
-  #
-  class ResumeByteAlignment < BinData::Base
-    def clear?; true; end
-    def assign(val); end
-    def snapshot; nil; end
-    def do_num_bytes; 0; end
-
-    def do_read(io)
-      io.reset_read_bits
-    end
-
-    def do_write(io)
-      io.flushbits
-    end
-  end
-
-  # A monkey patch to force byte-aligned primitives to
-  # become bit-aligned.  This allows them to be used at
-  # non byte based boundaries.
-  #
-  #     class BitString < BinData::String
-  #       bit_aligned
-  #     end
-  #
-  #     class MyRecord < BinData::Record
-  #       bit4       :preamble
-  #       bit_string :str, length: 2
-  #     end
-  #
-  module BitAligned
-    class BitAlignedIO
-      def initialize(io)
-        @io = io
-      end
-      def readbytes(n)
-        n.times.inject("") do |bytes, _|
-          bytes += @io.readbits(8, :big).chr
-        end
-      end
-    end
-
-    def bit_aligned?
-      true
-    end
-
-    def read_and_return_value(io)
-      super(BitAlignedIO.new(io))
-    end
-
-    def do_num_bytes
-      super.to_f
-    end
-
-    def do_write(io)
-      value_to_binary_string(_value).each_byte { |v| io.writebits(v, 8, :big) }
-    end
-  end
-
-  def BasePrimitive.bit_aligned
-    include BitAligned
-  end
-
-  def Primitive.bit_aligned
-    fail "'bit_aligned' is not needed for BinData::Primitives"
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/array.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/array.rb
deleted file mode 100644
index 147a6110c5604..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/array.rb
+++ /dev/null
@@ -1,344 +0,0 @@
-require 'bindata/base'
-require 'bindata/dsl'
-
-module BinData
-  # An Array is a list of data objects of the same type.
-  #
-  #   require 'bindata'
-  #
-  #   data = "\x03\x04\x05\x06\x07\x08\x09"
-  #
-  #   obj = BinData::Array.new(type: :int8, initial_length: 6)
-  #   obj.read(data) #=> [3, 4, 5, 6, 7, 8]
-  #
-  #   obj = BinData::Array.new(type: :int8,
-  #                            read_until: -> { index == 1 })
-  #   obj.read(data) #=> [3, 4]
-  #
-  #   obj = BinData::Array.new(type: :int8,
-  #                            read_until: -> { element >= 6 })
-  #   obj.read(data) #=> [3, 4, 5, 6]
-  #
-  #   obj = BinData::Array.new(type: :int8,
-  #           read_until: -> { array[index] + array[index - 1] == 13 })
-  #   obj.read(data) #=> [3, 4, 5, 6, 7]
-  #
-  #   obj = BinData::Array.new(type: :int8, read_until: :eof)
-  #   obj.read(data) #=> [3, 4, 5, 6, 7, 8, 9]
-  #
-  # == Parameters
-  #
-  # Parameters may be provided at initialisation to control the behaviour of
-  # an object.  These params are:
-  #
-  # <tt>:type</tt>::           The symbol representing the data type of the
-  #                            array elements.  If the type is to have params
-  #                            passed to it, then it should be provided as
-  #                            <tt>[type_symbol, hash_params]</tt>.
-  # <tt>:initial_length</tt>:: The initial length of the array.
-  # <tt>:read_until</tt>::     While reading, elements are read until this
-  #                            condition is true.  This is typically used to
-  #                            read an array until a sentinel value is found.
-  #                            The variables +index+, +element+ and +array+
-  #                            are made available to any lambda assigned to
-  #                            this parameter.  If the value of this parameter
-  #                            is the symbol :eof, then the array will read
-  #                            as much data from the stream as possible.
-  #
-  # Each data object in an array has the variable +index+ made available
-  # to any lambda evaluated as a parameter of that data object.
-  class Array < BinData::Base
-    extend DSLMixin
-    include Enumerable
-
-    dsl_parser    :array
-    arg_processor :array
-
-    mandatory_parameter :type
-    optional_parameters :initial_length, :read_until
-    mutually_exclusive_parameters :initial_length, :read_until
-
-    def initialize_shared_instance
-      @element_prototype = get_parameter(:type)
-      if get_parameter(:read_until) == :eof
-        extend ReadUntilEOFPlugin
-      elsif has_parameter?(:read_until)
-        extend ReadUntilPlugin
-      elsif has_parameter?(:initial_length)
-        extend InitialLengthPlugin
-      end
-
-      super
-    end
-
-    def initialize_instance
-      @element_list = nil
-    end
-
-    def clear?
-      @element_list.nil? || elements.all?(&:clear?)
-    end
-
-    def assign(array)
-      return if self.equal?(array)  # prevent self assignment
-      raise ArgumentError, "can't set a nil value for #{debug_name}" if array.nil?
-
-      @element_list = []
-      concat(array)
-    end
-
-    def snapshot
-      elements.collect(&:snapshot)
-    end
-
-    def find_index(obj)
-      elements.index(obj)
-    end
-    alias index find_index
-
-    # Returns the first index of +obj+ in self.
-    #
-    # Uses equal? for the comparator.
-    def find_index_of(obj)
-      elements.index { |el| el.equal?(obj) }
-    end
-
-    def push(*args)
-      insert(-1, *args)
-      self
-    end
-    alias << push
-
-    def unshift(*args)
-      insert(0, *args)
-      self
-    end
-
-    def concat(array)
-      insert(-1, *array.to_ary)
-      self
-    end
-
-    def insert(index, *objs)
-      extend_array(index - 1)
-      abs_index = (index >= 0) ? index : index + 1 + length
-
-      # insert elements before...
-      new_elements = objs.map { new_element }
-      elements.insert(index, *new_elements)
-
-      # ...assigning values
-      objs.each_with_index do |obj, i|
-        self[abs_index + i] = obj
-      end
-
-      self
-    end
-
-    # Returns the element at +index+.
-    def [](arg1, arg2 = nil)
-      if arg1.respond_to?(:to_int) && arg2.nil?
-        slice_index(arg1.to_int)
-      elsif arg1.respond_to?(:to_int) && arg2.respond_to?(:to_int)
-        slice_start_length(arg1.to_int, arg2.to_int)
-      elsif arg1.is_a?(Range) && arg2.nil?
-        slice_range(arg1)
-      else
-        raise TypeError, "can't convert #{arg1} into Integer" unless arg1.respond_to?(:to_int)
-        raise TypeError, "can't convert #{arg2} into Integer" unless arg2.respond_to?(:to_int)
-      end
-    end
-    alias slice []
-
-    def slice_index(index)
-      extend_array(index)
-      at(index)
-    end
-
-    def slice_start_length(start, length)
-      elements[start, length]
-    end
-
-    def slice_range(range)
-      elements[range]
-    end
-    private :slice_index, :slice_start_length, :slice_range
-
-    # Returns the element at +index+.  Unlike +slice+, if +index+ is out
-    # of range the array will not be automatically extended.
-    def at(index)
-      elements[index]
-    end
-
-    # Sets the element at +index+.
-    def []=(index, value)
-      extend_array(index)
-      elements[index].assign(value)
-    end
-
-    # Returns the first element, or the first +n+ elements, of the array.
-    # If the array is empty, the first form returns nil, and the second
-    # form returns an empty array.
-    def first(n = nil)
-      if n.nil? && empty?
-        # explicitly return nil as arrays grow automatically
-        nil
-      elsif n.nil?
-        self[0]
-      else
-        self[0, n]
-      end
-    end
-
-    # Returns the last element, or the last +n+ elements, of the array.
-    # If the array is empty, the first form returns nil, and the second
-    # form returns an empty array.
-    def last(n = nil)
-      if n.nil?
-        self[-1]
-      else
-        n = length if n > length
-        self[-n, n]
-      end
-    end
-
-    def length
-      elements.length
-    end
-    alias size length
-
-    def empty?
-      length.zero?
-    end
-
-    # Allow this object to be used in array context.
-    def to_ary
-      collect { |el| el }
-    end
-
-    def each
-      elements.each { |el| yield el }
-    end
-
-    def debug_name_of(child) #:nodoc:
-      index = find_index_of(child)
-      "#{debug_name}[#{index}]"
-    end
-
-    def offset_of(child) #:nodoc:
-      index = find_index_of(child)
-      sum = sum_num_bytes_below_index(index)
-
-      child.bit_aligned? ? sum.floor : sum.ceil
-    end
-
-    def do_write(io) #:nodoc:
-      elements.each { |el| el.do_write(io) }
-    end
-
-    def do_num_bytes #:nodoc:
-      sum_num_bytes_for_all_elements
-    end
-
-    #---------------
-    private
-
-    def extend_array(max_index)
-      max_length = max_index + 1
-      while elements.length < max_length
-        append_new_element
-      end
-    end
-
-    def elements
-      @element_list ||= []
-    end
-
-    def append_new_element
-      element = new_element
-      elements << element
-      element
-    end
-
-    def new_element
-      @element_prototype.instantiate(nil, self)
-    end
-
-    def sum_num_bytes_for_all_elements
-      sum_num_bytes_below_index(length)
-    end
-
-    def sum_num_bytes_below_index(index)
-      (0...index).inject(0) do |sum, i|
-        nbytes = elements[i].do_num_bytes
-
-        if nbytes.is_a?(Integer)
-          sum.ceil + nbytes
-        else
-          sum + nbytes
-        end
-      end
-    end
-  end
-
-  class ArrayArgProcessor < BaseArgProcessor
-    def sanitize_parameters!(obj_class, params) #:nodoc:
-      # ensure one of :initial_length and :read_until exists
-      unless params.has_at_least_one_of?(:initial_length, :read_until)
-        params[:initial_length] = 0
-      end
-
-      params.warn_replacement_parameter(:length, :initial_length)
-      params.warn_replacement_parameter(:read_length, :initial_length)
-      params.must_be_integer(:initial_length)
-
-      params.merge!(obj_class.dsl_params)
-      params.sanitize_object_prototype(:type)
-    end
-  end
-
-  # Logic for the :read_until parameter
-  module ReadUntilPlugin
-    def do_read(io)
-      loop do
-        element = append_new_element
-        element.do_read(io)
-        variables = { index: self.length - 1, element: self.last, array: self }
-        break if eval_parameter(:read_until, variables)
-      end
-    end
-  end
-
-  # Logic for the read_until: :eof parameter
-  module ReadUntilEOFPlugin
-    def do_read(io)
-      loop do
-        element = append_new_element
-        begin
-          element.do_read(io)
-        rescue EOFError, IOError
-          elements.pop
-          break
-        end
-      end
-    end
-  end
-
-  # Logic for the :initial_length parameter
-  module InitialLengthPlugin
-    def do_read(io)
-      elements.each { |el| el.do_read(io) }
-    end
-
-    def elements
-      if @element_list.nil?
-        @element_list = []
-        eval_parameter(:initial_length).times do
-          @element_list << new_element
-        end
-      end
-
-      @element_list
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/base.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/base.rb
deleted file mode 100644
index 15fd39820119f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/base.rb
+++ /dev/null
@@ -1,335 +0,0 @@
-require 'bindata/framework'
-require 'bindata/io'
-require 'bindata/lazy'
-require 'bindata/name'
-require 'bindata/params'
-require 'bindata/registry'
-require 'bindata/sanitize'
-
-module BinData
-  # This is the abstract base class for all data objects.
-  class Base
-    extend AcceptedParametersPlugin
-    include Framework
-    include RegisterNamePlugin
-
-    class << self
-      # Instantiates this class and reads from +io+, returning the newly
-      # created data object.  +args+ will be used when instantiating.
-      def read(io, *args, &block)
-        obj = self.new(*args)
-        obj.read(io, &block)
-        obj
-      end
-
-      # The arg processor for this class.
-      def arg_processor(name = nil)
-        @arg_processor ||= nil
-
-        if name
-          @arg_processor = "#{name}_arg_processor".gsub(/(?:^|_)(.)/) { $1.upcase }.to_sym
-        elsif @arg_processor.is_a? Symbol
-          @arg_processor = BinData.const_get(@arg_processor).new
-        elsif @arg_processor.nil?
-          @arg_processor = superclass.arg_processor
-        else
-          @arg_processor
-        end
-      end
-
-      # The name of this class as used by Records, Arrays etc.
-      def bindata_name
-        RegisteredClasses.underscore_name(name)
-      end
-
-      # Call this method if this class is abstract and not to be used.
-      def unregister_self
-        RegisteredClasses.unregister(name)
-      end
-
-      # Registers all subclasses of this class for use
-      def register_subclasses #:nodoc:
-        singleton_class.send(:undef_method, :inherited)
-        define_singleton_method(:inherited) do |subclass|
-          RegisteredClasses.register(subclass.name, subclass)
-          register_subclasses
-        end
-      end
-
-      private :unregister_self, :register_subclasses
-    end
-
-    # Register all subclasses of this class.
-    register_subclasses
-
-    # Set the initial arg processor.
-    arg_processor :base
-
-    # Creates a new data object.
-    #
-    # Args are optional, but if present, must be in the following order.
-    #
-    # +value+ is a value that is +assign+ed immediately after initialization.
-    #
-    # +parameters+ is a hash containing symbol keys.  Some parameters may
-    # reference callable objects (methods or procs).
-    #
-    # +parent+ is the parent data object (e.g. struct, array, choice) this
-    # object resides under.
-    #
-    def initialize(*args)
-      value, @params, @parent = extract_args(args)
-
-      initialize_shared_instance
-      initialize_instance
-      assign(value) if value
-    end
-
-    attr_accessor :parent
-    protected :parent=
-
-    # Creates a new data object based on this instance.
-    #
-    # All parameters will be be duplicated.  Use this method
-    # when creating multiple objects with the same parameters.
-    def new(value = nil, parent = nil)
-      obj = clone
-      obj.parent = parent if parent
-      obj.initialize_instance
-      obj.assign(value) if value
-
-      obj
-    end
-
-    # Returns the result of evaluating the parameter identified by +key+.
-    #
-    # +overrides+ is an optional +parameters+ like hash that allow the
-    # parameters given at object construction to be overridden.
-    #
-    # Returns nil if +key+ does not refer to any parameter.
-    def eval_parameter(key, overrides = nil)
-      value = get_parameter(key)
-      if value.is_a?(Symbol) || value.respond_to?(:arity)
-        lazy_evaluator.lazy_eval(value, overrides)
-      else
-        value
-      end
-    end
-
-    # Returns a lazy evaluator for this object.
-    def lazy_evaluator #:nodoc:
-      @lazy ||= LazyEvaluator.new(self)
-    end
-
-    # Returns the parameter referenced by +key+.
-    # Use this method if you are sure the parameter is not to be evaluated.
-    # You most likely want #eval_parameter.
-    def get_parameter(key)
-      @params[key]
-    end
-
-    # Returns whether +key+ exists in the +parameters+ hash.
-    def has_parameter?(key)
-      @params.has_parameter?(key)
-    end
-
-    # Resets the internal state to that of a newly created object.
-    def clear
-      initialize_instance
-    end
-
-    # Reads data into this data object.
-    def read(io, &block)
-      io = BinData::IO::Read.new(io) unless BinData::IO::Read === io
-
-      start_read do
-        clear
-        do_read(io)
-      end
-      block.call(self) if block_given?
-
-      self
-    end
-
-    # Writes the value for this data object to +io+.
-    def write(io, &block)
-      io = BinData::IO::Write.new(io) unless BinData::IO::Write === io
-
-      do_write(io)
-      io.flush
-
-      block.call(self) if block_given?
-
-      self
-    end
-
-    # Returns the number of bytes it will take to write this data object.
-    def num_bytes
-      do_num_bytes.ceil
-    end
-
-    # Returns the string representation of this data object.
-    def to_binary_s(&block)
-      io = BinData::IO.create_string_io
-      write(io, &block)
-      io.string
-    end
-
-    # Returns the hexadecimal string representation of this data object.
-    def to_hex(&block)
-      to_binary_s(&block).unpack('H*')[0]
-    end
-
-    # Return a human readable representation of this data object.
-    def inspect
-      snapshot.inspect
-    end
-
-    # Return a string representing this data object.
-    def to_s
-      snapshot.to_s
-    end
-
-    # Work with Ruby's pretty-printer library.
-    def pretty_print(pp) #:nodoc:
-      pp.pp(snapshot)
-    end
-
-    # Override and delegate =~ as it is defined in Object.
-    def =~(other)
-      snapshot =~ other
-    end
-
-    # Returns a user friendly name of this object for debugging purposes.
-    def debug_name
-      if @parent
-        @parent.debug_name_of(self)
-      else
-        "obj"
-      end
-    end
-
-    # Returns the offset (in bytes) of this object with respect to its most
-    # distant ancestor.
-    def abs_offset
-      if @parent
-        @parent.abs_offset + @parent.offset_of(self)
-      else
-        0
-      end
-    end
-
-    # Returns the offset (in bytes) of this object with respect to its parent.
-    def rel_offset
-      if @parent
-        @parent.offset_of(self)
-      else
-        0
-      end
-    end
-
-    def ==(other) #:nodoc:
-      # double dispatch
-      other == snapshot
-    end
-
-    # A version of +respond_to?+ used by the lazy evaluator.  It doesn't
-    # reinvoke the evaluator so as to avoid infinite evaluation loops.
-    def safe_respond_to?(symbol, include_private = false) #:nodoc:
-      base_respond_to?(symbol, include_private)
-    end
-
-    alias base_respond_to? respond_to?
-
-    #---------------
-    private
-
-    def extract_args(args)
-      self.class.arg_processor.extract_args(self.class, args)
-    end
-
-    def start_read
-      top_level_set(:in_read, true)
-      yield
-    ensure
-      top_level_set(:in_read, false)
-    end
-
-    # Is this object tree currently being read?  Used by BasePrimitive.
-    def reading?
-      top_level_get(:in_read)
-    end
-
-    def top_level_set(sym, value)
-      top_level.instance_variable_set("@tl_#{sym}", value)
-    end
-
-    def top_level_get(sym)
-      tl = top_level
-      tl.instance_variable_defined?("@tl_#{sym}") &&
-        tl.instance_variable_get("@tl_#{sym}")
-    end
-
-    def top_level
-      if parent.nil?
-        tl = self
-      else
-        tl = parent
-        tl = tl.parent while tl.parent
-      end
-
-      tl
-    end
-
-    def binary_string(str)
-      str.to_s.dup.force_encoding(Encoding::BINARY)
-    end
-  end
-
-  # ArgProcessors process the arguments passed to BinData::Base.new into
-  # the form required to initialise the BinData object.
-  #
-  # Any passed parameters are sanitized so the BinData object doesn't
-  # need to perform error checking on the parameters.
-  class BaseArgProcessor
-    @@empty_hash = Hash.new.freeze
-
-    # Takes the arguments passed to BinData::Base.new and
-    # extracts [value, sanitized_parameters, parent].
-    def extract_args(obj_class, obj_args)
-      value, params, parent = separate_args(obj_class, obj_args)
-      sanitized_params = SanitizedParameters.sanitize(params, obj_class)
-
-      [value, sanitized_params, parent]
-    end
-
-    # Separates the arguments passed to BinData::Base.new into
-    # [value, parameters, parent].  Called by #extract_args.
-    def separate_args(_obj_class, obj_args)
-      args = obj_args.dup
-      value = parameters = parent = nil
-
-      if args.length > 1 && args.last.is_a?(BinData::Base)
-        parent = args.pop
-      end
-
-      if args.length > 0 && args.last.is_a?(Hash)
-        parameters = args.pop
-      end
-
-      if args.length > 0
-        value = args.pop
-      end
-
-      parameters ||= @@empty_hash
-
-      [value, parameters, parent]
-    end
-
-    # Performs sanity checks on the given parameters.
-    # This method converts the parameters to the form expected
-    # by the data object.
-    def sanitize_parameters!(obj_class, obj_params)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/buffer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/buffer.rb
deleted file mode 100644
index b504c6cdf3161..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/buffer.rb
+++ /dev/null
@@ -1,117 +0,0 @@
-require 'bindata/base'
-require 'bindata/dsl'
-
-module BinData
-  # A Buffer is conceptually a substream within a data stream.  It has a
-  # defined size and it will always read or write the exact number of bytes to
-  # fill the buffer.  Short reads will skip over unused bytes and short writes
-  # will pad the substream with "\0" bytes.
-  #
-  #   require 'bindata'
-  #
-  #   obj = BinData::Buffer.new(length: 5, type: [:string, {value: "abc"}])
-  #   obj.to_binary_s #=> "abc\000\000"
-  #
-  #
-  #   class MyBuffer < BinData::Buffer
-  #     default_parameter length: 8
-  #
-  #     endian :little
-  #
-  #     uint16 :num1
-  #     uint16 :num2
-  #     # padding occurs here
-  #   end
-  #
-  #   obj = MyBuffer.read("\001\000\002\000\000\000\000\000")
-  #   obj.num1 #=> 1
-  #   obj.num1 #=> 2
-  #   obj.raw_num_bytes #=> 4
-  #   obj.num_bytes #=> 8
-  #
-  #
-  #   class StringTable < BinData::Record
-  #     endian :little
-  #
-  #     uint16 :table_size_in_bytes
-  #     buffer :strings, length: :table_size_in_bytes do
-  #       array read_until: :eof do
-  #         uint8 :len
-  #         string :str, length: :len
-  #       end
-  #     end
-  #   end
-  #     
-  #
-  # == Parameters
-  #
-  # Parameters may be provided at initialisation to control the behaviour of
-  # an object.  These params are:
-  #
-  # <tt>:length</tt>::   The number of bytes in the buffer.
-  # <tt>:type</tt>::     The single type inside the buffer.  Use a struct if
-  #                      multiple fields are required.
-  class Buffer < BinData::Base
-    extend DSLMixin
-
-    dsl_parser    :buffer
-    arg_processor :buffer
-
-    mandatory_parameters :length, :type
-
-    def initialize_instance
-      @type = get_parameter(:type).instantiate(nil, self)
-    end
-
-    # The number of bytes used, ignoring the padding imposed by the buffer.
-    def raw_num_bytes
-      @type.num_bytes
-    end
-
-    def clear?
-      @type.clear?
-    end
-
-    def assign(val)
-      @type.assign(val)
-    end
-
-    def snapshot
-      @type.snapshot
-    end
-
-    def respond_to?(symbol, include_private = false) #:nodoc:
-      @type.respond_to?(symbol, include_private) || super
-    end
-
-    def method_missing(symbol, *args, &block) #:nodoc:
-      @type.__send__(symbol, *args, &block)
-    end
-
-    def do_read(io) #:nodoc:
-      io.with_buffer(eval_parameter(:length)) do
-        @type.do_read(io)
-      end
-    end
-
-    def do_write(io) #:nodoc:
-      io.with_buffer(eval_parameter(:length)) do
-        @type.do_write(io)
-      end
-    end
-
-    def do_num_bytes #:nodoc:
-      eval_parameter(:length)
-    end
-  end
-
-  class BufferArgProcessor < BaseArgProcessor
-    include MultiFieldArgSeparator
-
-    def sanitize_parameters!(obj_class, params)
-      params.merge!(obj_class.dsl_params)
-      params.must_be_integer(:length)
-      params.sanitize_object_prototype(:type)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/io.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/io.rb
deleted file mode 100644
index 22e0b19d40d64..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/io.rb
+++ /dev/null
@@ -1,496 +0,0 @@
-require 'stringio'
-
-module BinData
-  # A wrapper around an IO object.  The wrapper provides a consistent
-  # interface for BinData objects to use when accessing the IO.
-  module IO
-
-    # Common operations for both Read and Write.
-    module Common
-      def initialize(io)
-        if self.class === io
-          raise ArgumentError, "io must not be a #{self.class}"
-        end
-
-        # wrap strings in a StringIO
-        if io.respond_to?(:to_str)
-          io = BinData::IO.create_string_io(io.to_str)
-        end
-
-        @raw_io = io
-        @buffer_end_points = nil
-
-        extend seekable? ? SeekableStream : UnSeekableStream
-        stream_init
-      end
-
-      #-------------
-      private
-
-      def seekable?
-        @raw_io.pos
-      rescue NoMethodError, Errno::ESPIPE, Errno::EPIPE, Errno::EINVAL
-        nil
-      end
-
-      def seek(n)
-        seek_raw(buffer_limited_n(n))
-      end
-
-      def buffer_limited_n(n)
-        if @buffer_end_points
-          if n.nil? || n > 0
-            max = @buffer_end_points[1] - offset
-            n = max if n.nil? || n > max
-          else
-            min = @buffer_end_points[0] - offset
-            n = min if n < min
-          end
-        end
-
-        n
-      end
-
-      def with_buffer_common(n)
-        prev = @buffer_end_points
-        if prev
-          avail = prev[1] - offset
-          n = avail if n > avail
-        end
-        @buffer_end_points = [offset, offset + n]
-        begin
-          yield(*@buffer_end_points)
-        ensure
-          @buffer_end_points = prev
-        end
-      end
-
-      # Use #seek and #pos on seekable streams
-      module SeekableStream
-        # The number of bytes remaining in the input stream.
-        def num_bytes_remaining
-          start_mark = @raw_io.pos
-          @raw_io.seek(0, ::IO::SEEK_END)
-          end_mark = @raw_io.pos
-
-          if @buffer_end_points
-            if @buffer_end_points[1] < end_mark
-              end_mark = @buffer_end_points[1]
-            end
-          end
-
-          bytes_remaining = end_mark - start_mark
-          @raw_io.seek(start_mark, ::IO::SEEK_SET)
-
-          bytes_remaining
-        end
-
-        # All io calls in +block+ are rolled back after this
-        # method completes.
-        def with_readahead
-          mark = @raw_io.pos
-          begin
-            yield
-          ensure
-            @raw_io.seek(mark, ::IO::SEEK_SET)
-          end
-        end
-
-        #-----------
-        private
-
-        def stream_init
-          @initial_pos = @raw_io.pos
-        end
-
-        def offset_raw
-          @raw_io.pos - @initial_pos
-        end
-
-        def seek_raw(n)
-          @raw_io.seek(n, ::IO::SEEK_CUR)
-        end
-
-        def read_raw(n)
-          @raw_io.read(n)
-        end
-
-        def write_raw(data)
-          @raw_io.write(data)
-        end
-      end
-
-      # Manually keep track of offset for unseekable streams.
-      module UnSeekableStream
-        def offset_raw
-          @offset
-        end
-
-        # The number of bytes remaining in the input stream.
-        def num_bytes_remaining
-          raise IOError, "stream is unseekable"
-        end
-
-        # All io calls in +block+ are rolled back after this
-        # method completes.
-        def with_readahead
-          mark = @offset
-          @read_data = ""
-          @in_readahead = true
-
-          class << self
-            alias_method :read_raw_without_readahead, :read_raw
-            alias_method :read_raw, :read_raw_with_readahead
-          end
-
-          begin
-            yield
-          ensure
-            @offset = mark
-            @in_readahead = false
-          end
-        end
-
-        #-----------
-        private
-
-        def stream_init
-          @offset = 0
-        end
-
-        def read_raw(n)
-          data = @raw_io.read(n)
-          @offset += data.size if data
-          data
-        end
-
-        def read_raw_with_readahead(n)
-          data = ""
-
-          unless @read_data.empty? || @in_readahead
-            bytes_to_consume = [n, @read_data.length].min
-            data += @read_data.slice!(0, bytes_to_consume)
-            n -= bytes_to_consume
-
-            if @read_data.empty?
-              class << self
-                alias_method :read_raw, :read_raw_without_readahead
-              end
-            end
-          end
-
-          raw_data = @raw_io.read(n)
-          data += raw_data if raw_data
-
-          if @in_readahead
-            @read_data += data
-          end
-
-          @offset += data.size
-
-          data
-        end
-
-        def write_raw(data)
-          @offset += data.size
-          @raw_io.write(data)
-        end
-
-        def seek_raw(n)
-          raise IOError, "stream is unseekable" if n < 0
-
-          # NOTE: how do we seek on a writable stream?
-
-          # skip over data in 8k blocks
-          while n > 0
-            bytes_to_read = [n, 8192].min
-            read_raw(bytes_to_read)
-            n -= bytes_to_read
-          end
-        end
-      end
-    end
-
-    # Creates a StringIO around +str+.
-    def self.create_string_io(str = "")
-      s = StringIO.new(str.dup.force_encoding(Encoding::BINARY))
-      s.binmode
-      s
-    end
-
-    # Create a new IO Read wrapper around +io+.  +io+ must provide #read,
-    # #pos if reading the current stream position and #seek if setting the
-    # current stream position.  If +io+ is a string it will be automatically
-    # wrapped in an StringIO object.
-    #
-    # The IO can handle bitstreams in either big or little endian format.
-    #
-    #      M  byte1   L      M  byte2   L
-    #      S 76543210 S      S fedcba98 S
-    #      B          B      B          B
-    #
-    # In big endian format:
-    #   readbits(6), readbits(5) #=> [765432, 10fed]
-    #
-    # In little endian format:
-    #   readbits(6), readbits(5) #=> [543210, a9876]
-    #
-    class Read
-      include Common
-
-      def initialize(io)
-        super(io)
-
-        # bits when reading
-        @rnbits  = 0
-        @rval    = 0
-        @rendian = nil
-      end
-
-      # Sets a buffer of +n+ bytes on the io stream.  Any reading or seeking
-      # calls inside the +block+ will be contained within this buffer.
-      def with_buffer(n)
-        with_buffer_common(n) do
-          yield
-          read
-        end
-      end
-
-      # Returns the current offset of the io stream.  Offset will be rounded
-      # up when reading bitfields.
-      def offset
-        offset_raw
-      end
-
-      # Seek +n+ bytes from the current position in the io stream.
-      def seekbytes(n)
-        reset_read_bits
-        seek(n)
-      end
-
-      # Reads exactly +n+ bytes from +io+.
-      #
-      # If the data read is nil an EOFError is raised.
-      #
-      # If the data read is too short an IOError is raised.
-      def readbytes(n)
-        reset_read_bits
-        read(n)
-      end
-
-      # Reads all remaining bytes from the stream.
-      def read_all_bytes
-        reset_read_bits
-        read
-      end
-
-      # Reads exactly +nbits+ bits from the stream. +endian+ specifies whether
-      # the bits are stored in +:big+ or +:little+ endian format.
-      def readbits(nbits, endian)
-        if @rendian != endian
-          # don't mix bits of differing endian
-          reset_read_bits
-          @rendian = endian
-        end
-
-        if endian == :big
-          read_big_endian_bits(nbits)
-        else
-          read_little_endian_bits(nbits)
-        end
-      end
-
-      # Discards any read bits so the stream becomes aligned at the
-      # next byte boundary.
-      def reset_read_bits
-        @rnbits = 0
-        @rval   = 0
-      end
-
-      #---------------
-      private
-
-      def read(n = nil)
-        str = read_raw(buffer_limited_n(n))
-        if n
-          raise EOFError, "End of file reached" if str.nil?
-          raise IOError, "data truncated" if str.size < n
-        end
-        str
-      end
-
-      def read_big_endian_bits(nbits)
-        while @rnbits < nbits
-          accumulate_big_endian_bits
-        end
-
-        val     = (@rval >> (@rnbits - nbits)) & mask(nbits)
-        @rnbits -= nbits
-        @rval   &= mask(@rnbits)
-
-        val
-      end
-
-      def accumulate_big_endian_bits
-        byte = read(1).unpack('C').at(0) & 0xff
-        @rval = (@rval << 8) | byte
-        @rnbits += 8
-      end
-
-      def read_little_endian_bits(nbits)
-        while @rnbits < nbits
-          accumulate_little_endian_bits
-        end
-
-        val     = @rval & mask(nbits)
-        @rnbits -= nbits
-        @rval   >>= nbits
-
-        val
-      end
-
-      def accumulate_little_endian_bits
-        byte = read(1).unpack('C').at(0) & 0xff
-        @rval = @rval | (byte << @rnbits)
-        @rnbits += 8
-      end
-
-      def mask(nbits)
-        (1 << nbits) - 1
-      end
-    end
-
-    # Create a new IO Write wrapper around +io+.  +io+ must provide #write.
-    # If +io+ is a string it will be automatically wrapped in an StringIO
-    # object.
-    #
-    # The IO can handle bitstreams in either big or little endian format.
-    #
-    # See IO::Read for more information.
-    class Write
-      include Common
-      def initialize(io)
-        super(io)
-
-        @wnbits  = 0
-        @wval    = 0
-        @wendian = nil
-      end
-
-      # Sets a buffer of +n+ bytes on the io stream.  Any writes inside the
-      # +block+ will be contained within this buffer.  If less than +n+ bytes
-      # are written inside the block, the remainder will be padded with '\0'
-      # bytes.
-      def with_buffer(n)
-        with_buffer_common(n) do |_buf_start, buf_end|
-          yield
-          write("\0" * (buf_end - offset))
-        end
-      end
-
-      # Returns the current offset of the io stream.  Offset will be rounded
-      # up when writing bitfields.
-      def offset
-        offset_raw + (@wnbits > 0 ? 1 : 0)
-      end
-
-      # Seek +n+ bytes from the current position in the io stream.
-      def seekbytes(n)
-        flushbits
-        seek(n)
-      end
-
-      # Writes the given string of bytes to the io stream.
-      def writebytes(str)
-        flushbits
-        write(str)
-      end
-
-      # Writes +nbits+ bits from +val+ to the stream. +endian+ specifies whether
-      # the bits are to be stored in +:big+ or +:little+ endian format.
-      def writebits(val, nbits, endian)
-        if @wendian != endian
-          # don't mix bits of differing endian
-          flushbits
-          @wendian = endian
-        end
-
-        clamped_val = val & mask(nbits)
-
-        if endian == :big
-          write_big_endian_bits(clamped_val, nbits)
-        else
-          write_little_endian_bits(clamped_val, nbits)
-        end
-      end
-
-      # To be called after all +writebits+ have been applied.
-      def flushbits
-        raise "Internal state error nbits = #{@wnbits}" if @wnbits >= 8
-
-        if @wnbits > 0
-          writebits(0, 8 - @wnbits, @wendian)
-        end
-      end
-      alias flush flushbits
-
-      #---------------
-      private
-
-      def write(data)
-        n = buffer_limited_n(data.size)
-        if n < data.size
-          data = data[0, n]
-        end
-
-        write_raw(data)
-      end
-
-      def write_big_endian_bits(val, nbits)
-        while nbits > 0
-          bits_req = 8 - @wnbits
-          if nbits >= bits_req
-            msb_bits = (val >> (nbits - bits_req)) & mask(bits_req)
-            nbits -= bits_req
-            val &= mask(nbits)
-
-            @wval   = (@wval << bits_req) | msb_bits
-            write(@wval.chr)
-
-            @wval   = 0
-            @wnbits = 0
-          else
-            @wval = (@wval << nbits) | val
-            @wnbits += nbits
-            nbits = 0
-          end
-        end
-      end
-
-      def write_little_endian_bits(val, nbits)
-        while nbits > 0
-          bits_req = 8 - @wnbits
-          if nbits >= bits_req
-            lsb_bits = val & mask(bits_req)
-            nbits -= bits_req
-            val >>= bits_req
-
-            @wval   = @wval | (lsb_bits << @wnbits)
-            write(@wval.chr)
-
-            @wval   = 0
-            @wnbits = 0
-          else
-            @wval   = @wval | (val << @wnbits)
-            @wnbits += nbits
-            nbits = 0
-          end
-        end
-      end
-
-      def mask(nbits)
-        (1 << nbits) - 1
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/offset.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/offset.rb
deleted file mode 100644
index 7b9a61e658c6e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/offset.rb
+++ /dev/null
@@ -1,94 +0,0 @@
-module BinData
-  # WARNING: THIS IS UNSUPPORTED!!
-  #
-  # This was a (failed) experimental feature that allowed seeking within the
-  # input stream.  It remains here for backwards compatability for the few
-  # people that used it.
-  #
-  # The official way to skip around the stream is to use BinData::Skip with
-  # the `:to_abs_offset` parameter.
-  #
-  # == Parameters
-  #
-  # Parameters may be provided at initialisation to control the behaviour of
-  # an object.  These parameters are:
-  #
-  # [<tt>:check_offset</tt>]  Raise an error if the current IO offset doesn't
-  #                           meet this criteria.  A boolean return indicates
-  #                           success or failure.  Any other return is compared
-  #                           to the current offset.  The variable +offset+
-  #                           is made available to any lambda assigned to
-  #                           this parameter.  This parameter is only checked
-  #                           before reading.
-  # [<tt>:adjust_offset</tt>] Ensures that the current IO offset is at this
-  #                           position before reading.  This is like
-  #                           <tt>:check_offset</tt>, except that it will
-  #                           adjust the IO offset instead of raising an error.
-  module CheckOrAdjustOffsetPlugin
-
-    def self.included(base) #:nodoc:
-      base.optional_parameters :check_offset, :adjust_offset
-      base.mutually_exclusive_parameters :check_offset, :adjust_offset
-    end
-
-    def initialize_shared_instance
-      extend CheckOffsetMixin  if has_parameter?(:check_offset)
-      extend AdjustOffsetMixin if has_parameter?(:adjust_offset)
-      super
-    end
-
-    module CheckOffsetMixin
-      def do_read(io) #:nodoc:
-        check_offset(io)
-        super(io)
-      end
-
-      #---------------
-      private
-
-      def check_offset(io)
-        actual_offset = io.offset
-        expected = eval_parameter(:check_offset, offset: actual_offset)
-
-        if !expected
-          raise ValidityError, "offset not as expected for #{debug_name}"
-        elsif actual_offset != expected && expected != true
-          raise ValidityError,
-                "offset is '#{actual_offset}' but " +
-                "expected '#{expected}' for #{debug_name}"
-        end
-      end
-    end
-
-    module AdjustOffsetMixin
-      def do_read(io) #:nodoc:
-        adjust_offset(io)
-        super(io)
-      end
-
-      #---------------
-      private
-
-      def adjust_offset(io)
-        actual_offset = io.offset
-        expected = eval_parameter(:adjust_offset)
-        if actual_offset != expected
-          begin
-            seek = expected - actual_offset
-            io.seekbytes(seek)
-            warn "adjusting stream position by #{seek} bytes" if $VERBOSE
-          rescue
-            raise ValidityError,
-                  "offset is '#{actual_offset}' but couldn't seek to " +
-                  "expected '#{expected}' for #{debug_name}"
-          end
-        end
-      end
-    end
-  end
-
-  # Add these offset options to Base
-  class Base
-    include CheckOrAdjustOffsetPlugin
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/params.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/params.rb
deleted file mode 100644
index 80112483c986b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/params.rb
+++ /dev/null
@@ -1,128 +0,0 @@
-require 'bindata/lazy'
-
-module BinData
-  module AcceptedParametersPlugin
-    # Mandatory parameters must be present when instantiating a data object.
-    def mandatory_parameters(*args)
-      accepted_parameters.mandatory(*args)
-    end
-
-    # Optional parameters may be present when instantiating a data object.
-    def optional_parameters(*args)
-      accepted_parameters.optional(*args)
-    end
-
-    # Default parameters can be overridden when instantiating a data object.
-    def default_parameters(*args)
-      accepted_parameters.default(*args)
-    end
-
-    # Mutually exclusive parameters may not all be present when
-    # instantiating a data object.
-    def mutually_exclusive_parameters(*args)
-      accepted_parameters.mutually_exclusive(*args)
-    end
-
-    alias mandatory_parameter mandatory_parameters
-    alias optional_parameter  optional_parameters
-    alias default_parameter   default_parameters
-
-    def accepted_parameters #:nodoc:
-      @accepted_parameters ||= begin
-        ancestor_params = superclass.respond_to?(:accepted_parameters) ?
-                            superclass.accepted_parameters : nil
-        AcceptedParameters.new(ancestor_params)
-      end
-    end
-
-    # BinData objects accept parameters when initializing.  AcceptedParameters
-    # allow a BinData class to declaratively identify accepted parameters as
-    # mandatory, optional, default or mutually exclusive.
-    class AcceptedParameters
-      def initialize(ancestor_parameters = nil)
-        if ancestor_parameters
-          @mandatory = ancestor_parameters.mandatory.dup
-          @optional  = ancestor_parameters.optional.dup
-          @default   = ancestor_parameters.default.dup
-          @mutually_exclusive = ancestor_parameters.mutually_exclusive.dup
-        else
-          @mandatory = []
-          @optional  = []
-          @default   = Hash.new
-          @mutually_exclusive = []
-        end
-      end
-
-      def mandatory(*args)
-        unless args.empty?
-          @mandatory.concat(to_syms(args))
-          @mandatory.uniq!
-        end
-        @mandatory
-      end
-
-      def optional(*args)
-        unless args.empty?
-          @optional.concat(to_syms(args))
-          @optional.uniq!
-        end
-        @optional
-      end
-
-      def default(args = nil)
-        if args
-          to_syms(args.keys)  # call for side effect of validating names
-          args.each_pair do |param, value|
-            @default[param.to_sym] = value
-          end
-        end
-        @default
-      end
-
-      def mutually_exclusive(*args)
-        arg1 = args.shift
-        until args.empty?
-          args.each do |arg2|
-            @mutually_exclusive.push([arg1.to_sym, arg2.to_sym])
-            @mutually_exclusive.uniq!
-          end
-          arg1 = args.shift
-        end
-        @mutually_exclusive
-      end
-
-      def all
-        (@mandatory + @optional + @default.keys).uniq
-      end
-
-      #---------------
-      private
-
-      def to_syms(args)
-        syms = args.collect(&:to_sym)
-        ensure_valid_names(syms)
-        syms
-      end
-
-      def ensure_valid_names(names)
-        invalid_names = self.class.invalid_parameter_names
-        names.each do |name|
-          if invalid_names.include?(name)
-            raise NameError.new("Rename parameter '#{name}' " \
-                                "as it shadows an existing method.", name)
-          end
-        end
-      end
-
-      def self.invalid_parameter_names
-        @invalid_names ||= begin
-          all_names = LazyEvaluator.instance_methods(true) + Kernel.methods
-          allowed_names = [:name, :type]
-          invalid_names = (all_names - allowed_names).uniq
-
-          Hash[*invalid_names.collect { |key| [key.to_sym, true] }.flatten]
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/registry.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/registry.rb
deleted file mode 100644
index fc47740bd5594..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/registry.rb
+++ /dev/null
@@ -1,134 +0,0 @@
-module BinData
-
-  class UnRegisteredTypeError < StandardError ; end
-
-  # This registry contains a register of name -> class mappings.
-  #
-  # Numerics (integers and floating point numbers) have an endian property as
-  # part of their name (e.g. int32be, float_le).
-  #
-  # Classes can be looked up based on their full name or an abbreviated +name+
-  # with +hints+.
-  #
-  # There are two hints supported, :endian and :search_prefix.
-  #
-  #   #lookup("int32", { endian: :big }) will return Int32Be.
-  #
-  #   #lookup("my_type", { search_prefix: :ns }) will return NsMyType.
-  #
-  # Names are stored in under_score_style, not camelCase.
-  class Registry
-
-    def initialize
-      @registry = {}
-    end
-
-    def register(name, class_to_register)
-      return if name.nil? || class_to_register.nil?
-
-      formatted_name = underscore_name(name)
-      warn_if_name_is_already_registered(formatted_name, class_to_register)
-
-      @registry[formatted_name] = class_to_register
-    end
-
-    def unregister(name)
-      @registry.delete(underscore_name(name))
-    end
-
-    def lookup(name, hints = {})
-      the_class = @registry[normalize_name(name, hints)]
-      if the_class
-        the_class
-      elsif @registry[normalize_name(name, hints.merge(endian: :big))]
-        raise(UnRegisteredTypeError, "#{name}, do you need to specify endian?")
-      else
-        raise(UnRegisteredTypeError, name)
-      end
-    end
-
-    # Convert CamelCase +name+ to underscore style.
-    def underscore_name(name)
-      name.
-        to_s.
-        sub(/.*::/, "").
-        gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
-        gsub(/([a-z\d])([A-Z])/, '\1_\2').
-        tr("-", "_").
-        downcase
-    end
-
-    #---------------
-    private
-
-    def normalize_name(name, hints)
-      name = underscore_name(name)
-
-      if !registered?(name)
-        search_prefix = [""].concat(Array(hints[:search_prefix]))
-        search_prefix.each do |prefix|
-          nwp = name_with_prefix(name, prefix)
-          if registered?(nwp)
-            name = nwp
-            break
-          end
-
-          nwe = name_with_endian(nwp, hints[:endian])
-          if registered?(nwe)
-            name = nwe
-            break
-          end
-        end
-      end
-
-      name
-    end
-
-    def name_with_prefix(name, prefix)
-      prefix = prefix.to_s.chomp("_")
-      if prefix == ""
-        name
-      else
-        "#{prefix}_#{name}"
-      end
-    end
-
-    def name_with_endian(name, endian)
-      return name if endian.nil?
-
-      suffix = (endian == :little) ? "le" : "be"
-      if /^u?int\d+$/ =~ name
-        name + suffix
-      else
-        name + "_" + suffix
-      end
-    end
-
-    def registered?(name)
-      register_dynamic_class(name) unless @registry.key?(name)
-
-      @registry.key?(name)
-    end
-
-    def register_dynamic_class(name)
-      if /^u?int\d+(le|be)$/ =~ name || /^s?bit\d+(le)?$/ =~ name
-        class_name = name.gsub(/(?:^|_)(.)/) { $1.upcase }
-        begin
-          BinData.const_get(class_name)
-        rescue NameError
-        end
-      end
-    end
-
-    def warn_if_name_is_already_registered(name, class_to_register)
-      prev_class = @registry[name]
-      if $VERBOSE && prev_class && prev_class != class_to_register
-        warn "warning: replacing registered class #{prev_class} " \
-             "with #{class_to_register}"
-      end
-    end
-  end
-
-  # A singleton registry of all registered classes.
-  RegisteredClasses = Registry.new
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/skip.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/skip.rb
deleted file mode 100644
index 40d4fe940af67..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/skip.rb
+++ /dev/null
@@ -1,133 +0,0 @@
-require "bindata/base_primitive"
-
-module BinData
-  # Skip will skip over bytes from the input stream.  If the stream is not
-  # seekable, then the bytes are consumed and discarded.
-  #
-  # When writing, skip will write the appropriate number of zero bytes.
-  #
-  #   require 'bindata'
-  #
-  #   class A < BinData::Record
-  #     skip length: 5
-  #     string :a, read_length: 5
-  #   end
-  #
-  #   obj = A.read("abcdefghij")
-  #   obj.a #=> "fghij"
-  #
-  #
-  #   class B < BinData::Record
-  #     skip until_valid: [:string, {read_length: 2, assert: "ef"} ]
-  #     string :b, read_length: 5
-  #   end
-  #
-  #   obj = B.read("abcdefghij")
-  #   obj.b #=> "efghi"
-  #
-  #
-  # == Parameters
-  #
-  # Skip objects accept all the params that BinData::BasePrimitive
-  # does, as well as the following:
-  #
-  # <tt>:length</tt>::        The number of bytes to skip.
-  # <tt>:to_abs_offset</tt>:: Skips to the given absolute offset.
-  # <tt>:until_valid</tt>::   Skips untils a given byte pattern is matched.
-  #                           This parameter contains a type that will raise
-  #                           a BinData::ValidityError unless an acceptable byte
-  #                           sequence is found.  The type is represented by a
-  #                           Symbol, or if the type is to have params #
-  #                           passed to it, then it should be provided as #
-  #                           <tt>[type_symbol, hash_params]</tt>.
-  #
-  class Skip < BinData::BasePrimitive
-    arg_processor :skip
-
-    optional_parameters :length, :to_abs_offset, :until_valid
-    mutually_exclusive_parameters :length, :to_abs_offset, :until_valid
-
-    def initialize_shared_instance
-      extend SkipLengthPlugin      if has_parameter?(:length)
-      extend SkipToAbsOffsetPlugin if has_parameter?(:to_abs_offset)
-      extend SkipUntilValidPlugin  if has_parameter?(:until_valid)
-      super
-    end
-
-    #---------------
-    private
-
-    def value_to_binary_string(val)
-      len = skip_length
-      if len < 0
-        raise ValidityError, "#{debug_name} attempted to seek backwards by #{len.abs} bytes"
-      end
-
-      "\000" * skip_length
-    end
-
-    def read_and_return_value(io)
-      len = skip_length
-      if len < 0
-        raise ValidityError, "#{debug_name} attempted to seek backwards by #{len.abs} bytes"
-      end
-
-      io.seekbytes(len)
-      ""
-    end
-
-    def sensible_default
-      ""
-    end
-  end
-
-  class SkipArgProcessor < BaseArgProcessor
-    def sanitize_parameters!(obj_class, params)
-      unless params.has_at_least_one_of?(:length, :to_abs_offset, :until_valid)
-        raise ArgumentError,
-          "#{obj_class} requires either :length, :to_abs_offset or :until_valid"
-      end
-      params.must_be_integer(:to_abs_offset, :length)
-      params.sanitize_object_prototype(:until_valid)
-    end
-  end
-
-  # Logic for the :length parameter
-  module SkipLengthPlugin
-    def skip_length
-      eval_parameter(:length)
-    end
-  end
-
-  # Logic for the :to_abs_offset parameter
-  module SkipToAbsOffsetPlugin
-    def skip_length
-      eval_parameter(:to_abs_offset) - abs_offset
-    end
-  end
-
-  # Logic for the :until_valid parameter
-  module SkipUntilValidPlugin
-    def skip_length
-      # no skipping when writing
-      0
-    end
-
-    def read_and_return_value(io)
-      prototype = get_parameter(:until_valid)
-      validator = prototype.instantiate(nil, self)
-
-      valid = false
-      until valid
-        begin
-          io.with_readahead do
-            validator.read(io)
-            valid = true
-          end
-        rescue ValidityError
-          io.readbytes(1)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/string.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/string.rb
deleted file mode 100644
index cf744ae2dfad3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/string.rb
+++ /dev/null
@@ -1,153 +0,0 @@
-require "bindata/base_primitive"
-
-module BinData
-  # A String is a sequence of bytes.  This is the same as strings in Ruby 1.8.
-  # The issue of character encoding is ignored by this class.
-  #
-  #   require 'bindata'
-  #
-  #   data = "abcdefghij"
-  #
-  #   obj = BinData::String.new(read_length: 5)
-  #   obj.read(data)
-  #   obj #=> "abcde"
-  #
-  #   obj = BinData::String.new(length: 6)
-  #   obj.read(data)
-  #   obj #=> "abcdef"
-  #   obj.assign("abcdefghij")
-  #   obj #=> "abcdef"
-  #   obj.assign("abcd")
-  #   obj #=> "abcd\000\000"
-  #
-  #   obj = BinData::String.new(length: 6, trim_padding: true)
-  #   obj.assign("abcd")
-  #   obj #=> "abcd"
-  #   obj.to_binary_s #=> "abcd\000\000"
-  #
-  #   obj = BinData::String.new(length: 6, pad_byte: 'A')
-  #   obj.assign("abcd")
-  #   obj #=> "abcdAA"
-  #   obj.to_binary_s #=> "abcdAA"
-  #
-  # == Parameters
-  #
-  # String objects accept all the params that BinData::BasePrimitive
-  # does, as well as the following:
-  #
-  # <tt>:read_length</tt>::    The length in bytes to use when reading a value.
-  # <tt>:length</tt>::         The fixed length of the string.  If a shorter
-  #                            string is set, it will be padded to this length.
-  # <tt>:pad_byte</tt>::       The byte to use when padding a string to a
-  #                            set length.  Valid values are Integers and
-  #                            Strings of length 1.  "\0" is the default.
-  # <tt>:pad_front</tt>::      Signifies that the padding occurs at the front
-  #                            of the string rather than the end.  Default
-  #                            is false.
-  # <tt>:trim_padding</tt>::   Boolean, default false.  If set, #value will
-  #                            return the value with all pad_bytes trimmed
-  #                            from the end of the string.  The value will
-  #                            not be trimmed when writing.
-  class String < BinData::BasePrimitive
-    arg_processor :string
-
-    optional_parameters :read_length, :length, :trim_padding, :pad_front, :pad_left
-    default_parameters  pad_byte: "\0"
-    mutually_exclusive_parameters :read_length, :length
-    mutually_exclusive_parameters :length, :value
-
-    def initialize_shared_instance
-      if (has_parameter?(:value) || has_parameter?(:asserted_value)) &&
-          !has_parameter?(:read_length)
-        extend WarnNoReadLengthPlugin
-      end
-      super
-    end
-
-    def assign(val)
-      super(binary_string(val))
-    end
-
-    def snapshot
-      # override to trim padding
-      snap = super
-      snap = clamp_to_length(snap)
-
-      if get_parameter(:trim_padding)
-        trim_padding(snap)
-      else
-        snap
-      end
-    end
-
-    #---------------
-    private
-
-    def clamp_to_length(str)
-      str = binary_string(str)
-
-      len = eval_parameter(:length) || str.length
-      if str.length == len
-        str
-      elsif str.length > len
-        str.slice(0, len)
-      else
-        padding = (eval_parameter(:pad_byte) * (len - str.length))
-        if get_parameter(:pad_front)
-          padding + str
-        else
-          str + padding
-        end
-      end
-    end
-
-    def trim_padding(str)
-      if get_parameter(:pad_front)
-        str.sub(/\A#{eval_parameter(:pad_byte)}*/, "")
-      else
-        str.sub(/#{eval_parameter(:pad_byte)}*\z/, "")
-      end
-    end
-
-    def value_to_binary_string(val)
-      clamp_to_length(val)
-    end
-
-    def read_and_return_value(io)
-      len = eval_parameter(:read_length) || eval_parameter(:length) || 0
-      io.readbytes(len)
-    end
-
-    def sensible_default
-      ""
-    end
-  end
-
-  class StringArgProcessor < BaseArgProcessor
-    def sanitize_parameters!(obj_class, params)
-      params.warn_replacement_parameter(:initial_length, :read_length)
-      params.must_be_integer(:read_length, :length)
-      params.rename_parameter(:pad_left, :pad_front)
-      params.sanitize(:pad_byte) { |byte| sanitized_pad_byte(byte) }
-    end
-
-    #-------------
-    private
-
-    def sanitized_pad_byte(byte)
-      pad_byte = byte.is_a?(Integer) ? byte.chr : byte.to_s
-      if pad_byte.bytesize > 1
-        raise ArgumentError, ":pad_byte must not contain more than 1 byte"
-      end
-      pad_byte
-    end
-  end
-
-  # Warns when reading if :value && no :read_length
-  module WarnNoReadLengthPlugin
-    def read_and_return_value(io)
-      warn "#{debug_name} does not have a :read_length parameter - returning empty string"
-      ""
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/struct.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/struct.rb
deleted file mode 100644
index a34ec85701920..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/struct.rb
+++ /dev/null
@@ -1,415 +0,0 @@
-require 'bindata/base'
-
-module BinData
-
-  class Base
-    optional_parameter :onlyif, :byte_align  # Used by Struct
-  end
-
-  # A Struct is an ordered collection of named data objects.
-  #
-  #    require 'bindata'
-  #
-  #    class Tuple < BinData::Record
-  #      int8  :x
-  #      int8  :y
-  #      int8  :z
-  #    end
-  #
-  #    obj = BinData::Struct.new(hide: :a,
-  #                              fields: [ [:int32le, :a],
-  #                                        [:int16le, :b],
-  #                                        [:tuple, :s] ])
-  #    obj.field_names   =># [:b, :s]
-  #
-  #
-  # == Parameters
-  #
-  # Parameters may be provided at initialisation to control the behaviour of
-  # an object.  These params are:
-  #
-  # <tt>:fields</tt>::   An array specifying the fields for this struct.
-  #                      Each element of the array is of the form [type, name,
-  #                      params].  Type is a symbol representing a registered
-  #                      type.  Name is the name of this field.  Params is an
-  #                      optional hash of parameters to pass to this field
-  #                      when instantiating it.  If name is "" or nil, then
-  #                      that field is anonymous and behaves as a hidden field.
-  # <tt>:hide</tt>::     A list of the names of fields that are to be hidden
-  #                      from the outside world.  Hidden fields don't appear
-  #                      in #snapshot or #field_names but are still accessible
-  #                      by name.
-  # <tt>:endian</tt>::   Either :little or :big.  This specifies the default
-  #                      endian of any numerics in this struct, or in any
-  #                      nested data objects.
-  # <tt>:search_prefix</tt>::  Allows abbreviated type names.  If a type is
-  #                            unrecognised, then each prefix is applied until
-  #                            a match is found.
-  #
-  # == Field Parameters
-  #
-  # Fields may have have extra parameters as listed below:
-  #
-  # [<tt>:onlyif</tt>]     Used to indicate a data object is optional.
-  #                        if +false+, this object will not be included in any
-  #                        calls to #read, #write, #num_bytes or #snapshot.
-  # [<tt>:byte_align</tt>] This field's rel_offset must be a multiple of
-  #                        <tt>:byte_align</tt>.
-  class Struct < BinData::Base
-    arg_processor :struct
-
-    mandatory_parameter :fields
-    optional_parameters :endian, :search_prefix, :hide
-
-    # These reserved words may not be used as field names
-    RESERVED =
-      Hash[*
-        (Hash.instance_methods +
-         %w{alias and begin break case class def defined do else elsif
-            end ensure false for if in module next nil not or redo
-            rescue retry return self super then true undef unless until
-            when while yield} +
-         %w{array element index value} +
-         %w{type initial_length read_until} +
-         %w{fields endian search_prefix hide only_if byte_align} +
-         %w{choices selection copy_on_change} +
-         %w{read_abs_offset struct_params}).collect(&:to_sym).
-         uniq.collect { |key| [key, true] }.flatten
-      ]
-
-    def initialize_shared_instance
-      fields = get_parameter(:fields)
-      @field_names = fields.field_names.freeze
-      extend ByteAlignPlugin if fields.any_field_has_parameter?(:byte_align)
-      define_field_accessors
-      super
-    end
-
-    def initialize_instance
-      @field_objs = []
-    end
-
-    def clear #:nodoc:
-      @field_objs.each { |f| f.clear unless f.nil? }
-    end
-
-    def clear? #:nodoc:
-      @field_objs.all? { |f| f.nil? || f.clear? }
-    end
-
-    def assign(val)
-      clear
-      assign_fields(val)
-    end
-
-    def snapshot
-      snapshot = Snapshot.new
-      field_names.each do |name|
-        obj = find_obj_for_name(name)
-        snapshot[name] = obj.snapshot if include_obj?(obj)
-      end
-      snapshot
-    end
-
-    # Returns a list of the names of all fields accessible through this
-    # object.  +include_hidden+ specifies whether to include hidden names
-    # in the listing.
-    def field_names(include_hidden = false)
-      if include_hidden
-        @field_names.compact
-      else
-        hidden = get_parameter(:hide) || []
-        @field_names.compact - hidden
-      end
-    end
-
-    def debug_name_of(child) #:nodoc:
-      field_name = @field_names[find_index_of(child)]
-      "#{debug_name}.#{field_name}"
-    end
-
-    def offset_of(child) #:nodoc:
-      instantiate_all_objs
-      sum = sum_num_bytes_below_index(find_index_of(child))
-      child.bit_aligned? ? sum.floor : sum.ceil
-    end
-
-    def do_read(io) #:nodoc:
-      instantiate_all_objs
-      @field_objs.each { |f| f.do_read(io) if include_obj?(f) }
-    end
-
-    def do_write(io) #:nodoc
-      instantiate_all_objs
-      @field_objs.each { |f| f.do_write(io) if include_obj?(f) }
-    end
-
-    def do_num_bytes #:nodoc:
-      instantiate_all_objs
-      sum_num_bytes_for_all_fields
-    end
-
-    def [](key)
-      find_obj_for_name(key)
-    end
-
-    def []=(key, value)
-      obj = find_obj_for_name(key)
-      if obj
-        obj.assign(value)
-      end
-    end
-
-    def key?(key)
-      @field_names.index(base_field_name(key))
-    end
-
-    def each_pair
-      @field_names.compact.each do |name|
-        yield [name, find_obj_for_name(name)]
-      end
-    end
-
-    #---------------
-    private
-
-    def define_field_accessors
-      get_parameter(:fields).each_with_index do |field, i|
-        name = field.name_as_sym
-        define_field_accessors_for(name, i) if name
-      end
-    end
-
-    def define_field_accessors_for(name, index)
-      define_singleton_method(name) do
-        instantiate_obj_at(index) if @field_objs[index].nil?
-        @field_objs[index]
-      end
-      define_singleton_method("#{name}=") do |*vals|
-        instantiate_obj_at(index) if @field_objs[index].nil?
-        @field_objs[index].assign(*vals)
-      end
-      define_singleton_method("#{name}?") do
-        instantiate_obj_at(index) if @field_objs[index].nil?
-        include_obj?(@field_objs[index])
-      end
-    end
-
-    def find_index_of(obj)
-      @field_objs.index { |el| el.equal?(obj) }
-    end
-
-    def find_obj_for_name(name)
-      index = @field_names.index(base_field_name(name))
-      if index
-        instantiate_obj_at(index)
-        @field_objs[index]
-      else
-        nil
-      end
-    end
-
-    def base_field_name(name)
-      name.to_s.sub(/(=|\?)\z/, "").to_sym
-    end
-
-    def instantiate_all_objs
-      @field_names.each_index { |i| instantiate_obj_at(i) }
-    end
-
-    def instantiate_obj_at(index)
-      if @field_objs[index].nil?
-        field = get_parameter(:fields)[index]
-        @field_objs[index] = field.instantiate(nil, self)
-      end
-    end
-
-    def assign_fields(val)
-      src = as_stringified_hash(val)
-
-      @field_names.compact.each do |name|
-        obj = find_obj_for_name(name)
-        if obj && src.key?(name)
-          obj.assign(src[name])
-        end
-      end
-    end
-
-    def as_stringified_hash(val)
-      if BinData::Struct === val
-        val
-      elsif val.nil?
-        {}
-      else
-        hash = Snapshot.new
-        val.each_pair { |k,v| hash[k] = v }
-        hash
-      end
-    end
-
-    def sum_num_bytes_for_all_fields
-      sum_num_bytes_below_index(@field_objs.length)
-    end
-
-    def sum_num_bytes_below_index(index)
-      (0...index).inject(0) do |sum, i|
-        obj = @field_objs[i]
-        if include_obj?(obj)
-          nbytes = obj.do_num_bytes
-          (nbytes.is_a?(Integer) ? sum.ceil : sum) + nbytes
-        else
-          sum
-        end
-      end
-    end
-
-    def include_obj?(obj)
-      !obj.has_parameter?(:onlyif) || obj.eval_parameter(:onlyif)
-    end
-
-    # A hash that can be accessed via attributes.
-    class Snapshot < ::Hash #:nodoc:
-      def []=(key, value)
-        super unless value.nil?
-      end
-
-      def respond_to?(symbol, include_private = false)
-        key?(symbol) || super
-      end
-
-      def method_missing(symbol, *args)
-        key?(symbol) ? self[symbol] : super
-      end
-    end
-  end
-
-  # Align fields to a multiple of :byte_align
-  module ByteAlignPlugin
-    def do_read(io)
-      initial_offset = io.offset
-      instantiate_all_objs
-      @field_objs.each do |f|
-        if include_obj?(f)
-          if align_obj?(f)
-            io.seekbytes(bytes_to_align(f, io.offset - initial_offset))
-          end
-          f.do_read(io)
-        end
-      end
-    end
-
-    def do_write(io)
-      initial_offset = io.offset
-      instantiate_all_objs
-      @field_objs.each do |f|
-        if include_obj?(f)
-          if align_obj?(f)
-            io.writebytes("\x00" * bytes_to_align(f, io.offset - initial_offset))
-          end
-          f.do_write(io)
-        end
-      end
-    end
-
-    def sum_num_bytes_below_index(index)
-      sum = 0
-      (0...@field_objs.length).each do |i|
-        obj = @field_objs[i]
-        if include_obj?(obj)
-          sum = sum.ceil + bytes_to_align(obj, sum.ceil) if align_obj?(obj)
-
-          break if i >= index
-
-          nbytes = obj.do_num_bytes
-          sum = (nbytes.is_a?(Integer) ? sum.ceil : sum) + nbytes
-        end
-      end
-
-      sum
-    end
-
-    def bytes_to_align(obj, rel_offset)
-      align = obj.eval_parameter(:byte_align)
-      (align - (rel_offset % align)) % align
-    end
-
-    def align_obj?(obj)
-      obj.has_parameter?(:byte_align)
-    end
-  end
-
-  class StructArgProcessor < BaseArgProcessor
-    def sanitize_parameters!(obj_class, params)
-      sanitize_endian(params)
-      sanitize_search_prefix(params)
-      sanitize_fields(obj_class, params)
-      sanitize_hide(params)
-    end
-
-    #-------------
-    private
-
-    def sanitize_endian(params)
-      params.sanitize_endian(:endian)
-    end
-
-    def sanitize_search_prefix(params)
-      params.sanitize(:search_prefix) do |sprefix|
-        search_prefix = []
-        Array(sprefix).each do |prefix|
-          prefix = prefix.to_s.chomp("_")
-          search_prefix << prefix if prefix != ""
-        end
-
-        search_prefix
-      end
-    end
-
-    def sanitize_fields(obj_class, params)
-      params.sanitize_fields(:fields) do |fields, sanitized_fields|
-        fields.each do |ftype, fname, fparams|
-          sanitized_fields.add_field(ftype, fname, fparams)
-        end
-
-        field_names = sanitized_field_names(sanitized_fields)
-        ensure_field_names_are_valid(obj_class, field_names)
-      end
-    end
-
-    def sanitize_hide(params)
-      params.sanitize(:hide) do |hidden|
-        field_names  = sanitized_field_names(params[:fields])
-        hfield_names = hidden_field_names(hidden)
-
-        hfield_names & field_names
-      end
-    end
-
-    def sanitized_field_names(sanitized_fields)
-      sanitized_fields.field_names.compact
-    end
-
-    def hidden_field_names(hidden)
-      (hidden || []).collect(&:to_sym)
-    end
-
-    def ensure_field_names_are_valid(obj_class, field_names)
-      reserved_names = BinData::Struct::RESERVED
-
-      field_names.each do |name|
-        if obj_class.method_defined?(name)
-          raise NameError.new("Rename field '#{name}' in #{obj_class}, " \
-                              "as it shadows an existing method.", name)
-        end
-        if reserved_names.include?(name)
-          raise NameError.new("Rename field '#{name}' in #{obj_class}, " \
-                              "as it is a reserved name.", name)
-        end
-        if field_names.count(name) != 1
-          raise NameError.new("field '#{name}' in #{obj_class}, " \
-                              "is defined multiple times.", name)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/version.rb
deleted file mode 100644
index f5b9a825c5139..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/version.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-module BinData
-  VERSION = "2.4.10"
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/array.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/array.rb
deleted file mode 100644
index 60e5b5689dbfe..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/array.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-require 'concurrent/utility/engine'
-require 'concurrent/thread_safe/util'
-
-module Concurrent
-
-  # @!macro concurrent_array
-  #
-  #   A thread-safe subclass of Array. This version locks against the object
-  #   itself for every method call, ensuring only one thread can be reading
-  #   or writing at a time. This includes iteration methods like `#each`.
-  #
-  #   @note `a += b` is **not** a **thread-safe** operation on
-  #     `Concurrent::Array`. It reads array `a`, then it creates new `Concurrent::Array`
-  #     which is concatenation of `a` and `b`, then it writes the concatenation to `a`.
-  #     The read and write are independent operations they do not form a single atomic
-  #     operation therefore when two `+=` operations are executed concurrently updates
-  #     may be lost. Use `#concat` instead.
-  #
-  #   @see http://ruby-doc.org/core/Array.html Ruby standard library `Array`
-
-  # @!macro internal_implementation_note
-  ArrayImplementation = case
-                        when Concurrent.on_cruby?
-                          # Array is thread-safe in practice because CRuby runs
-                          # threads one at a time and does not do context
-                          # switching during the execution of C functions.
-                          ::Array
-
-                        when Concurrent.on_jruby?
-                          require 'jruby/synchronized'
-
-                          class JRubyArray < ::Array
-                            include JRuby::Synchronized
-                          end
-                          JRubyArray
-
-                        when Concurrent.on_rbx?
-                          require 'monitor'
-                          require 'concurrent/thread_safe/util/data_structures'
-
-                          class RbxArray < ::Array
-                          end
-
-                          ThreadSafe::Util.make_synchronized_on_rbx RbxArray
-                          RbxArray
-
-                        when Concurrent.on_truffleruby?
-                          require 'concurrent/thread_safe/util/data_structures'
-
-                          class TruffleRubyArray < ::Array
-                          end
-
-                          ThreadSafe::Util.make_synchronized_on_truffleruby TruffleRubyArray
-                          TruffleRubyArray
-
-                        else
-                          warn 'Possibly unsupported Ruby implementation'
-                          ::Array
-                        end
-  private_constant :ArrayImplementation
-
-  # @!macro concurrent_array
-  class Array < ArrayImplementation
-  end
-
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/abstract_thread_local_var.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/abstract_thread_local_var.rb
deleted file mode 100644
index fcdeed7f8506b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/abstract_thread_local_var.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-require 'concurrent/constants'
-
-module Concurrent
-
-  # @!macro thread_local_var
-  # @!macro internal_implementation_note
-  # @!visibility private
-  class AbstractThreadLocalVar
-
-    # @!macro thread_local_var_method_initialize
-    def initialize(default = nil, &default_block)
-      if default && block_given?
-        raise ArgumentError, "Cannot use both value and block as default value"
-      end
-
-      if block_given?
-        @default_block = default_block
-        @default = nil
-      else
-        @default_block = nil
-        @default = default
-      end
-
-      allocate_storage
-    end
-
-    # @!macro thread_local_var_method_get
-    def value
-      raise NotImplementedError
-    end
-
-    # @!macro thread_local_var_method_set
-    def value=(value)
-      raise NotImplementedError
-    end
-
-    # @!macro thread_local_var_method_bind
-    def bind(value, &block)
-      if block_given?
-        old_value = self.value
-        begin
-          self.value = value
-          yield
-        ensure
-          self.value = old_value
-        end
-      end
-    end
-
-    protected
-
-    # @!visibility private
-    def allocate_storage
-      raise NotImplementedError
-    end
-
-    # @!visibility private
-    def default
-      if @default_block
-        self.value = @default_block.call
-      else
-        @default
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/atomic_reference.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/atomic_reference.rb
deleted file mode 100644
index 674f866d05a04..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/atomic_reference.rb
+++ /dev/null
@@ -1,205 +0,0 @@
-require 'concurrent/synchronization'
-require 'concurrent/utility/engine'
-require 'concurrent/atomic_reference/numeric_cas_wrapper'
-
-# Shim for TruffleRuby::AtomicReference
-if Concurrent.on_truffleruby? && !defined?(TruffleRuby::AtomicReference)
-  # @!visibility private
-  module TruffleRuby
-    AtomicReference = Truffle::AtomicReference
-  end
-end
-
-module Concurrent
-
-  # Define update methods that use direct paths
-  #
-  # @!visibility private
-  # @!macro internal_implementation_note
-  module AtomicDirectUpdate
-
-    # @!macro atomic_reference_method_update
-    #
-    #   Pass the current value to the given block, replacing it
-    #   with the block's result. May retry if the value changes
-    #   during the block's execution.
-    #
-    #   @yield [Object] Calculate a new value for the atomic reference using
-    #     given (old) value
-    #   @yieldparam [Object] old_value the starting value of the atomic reference
-    #   @return [Object] the new value
-    def update
-      true until compare_and_set(old_value = get, new_value = yield(old_value))
-      new_value
-    end
-
-    # @!macro atomic_reference_method_try_update
-    #
-    #   Pass the current value to the given block, replacing it
-    #   with the block's result. Return nil if the update fails.
-    #
-    #   @yield [Object] Calculate a new value for the atomic reference using
-    #     given (old) value
-    #   @yieldparam [Object] old_value the starting value of the atomic reference
-    #   @note This method was altered to avoid raising an exception by default.
-    #     Instead, this method now returns `nil` in case of failure. For more info,
-    #     please see: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
-    #   @return [Object] the new value, or nil if update failed
-    def try_update
-      old_value = get
-      new_value = yield old_value
-
-      return unless compare_and_set old_value, new_value
-
-      new_value
-    end
-
-    # @!macro atomic_reference_method_try_update!
-    #
-    #   Pass the current value to the given block, replacing it
-    #   with the block's result. Raise an exception if the update
-    #   fails.
-    #
-    #   @yield [Object] Calculate a new value for the atomic reference using
-    #     given (old) value
-    #   @yieldparam [Object] old_value the starting value of the atomic reference
-    #   @note This behavior mimics the behavior of the original
-    #     `AtomicReference#try_update` API. The reason this was changed was to
-    #     avoid raising exceptions (which are inherently slow) by default. For more
-    #     info: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
-    #   @return [Object] the new value
-    #   @raise [Concurrent::ConcurrentUpdateError] if the update fails
-    def try_update!
-      old_value = get
-      new_value = yield old_value
-      unless compare_and_set(old_value, new_value)
-        if $VERBOSE
-          raise ConcurrentUpdateError, "Update failed"
-        else
-          raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
-        end
-      end
-      new_value
-    end
-  end
-
-  require 'concurrent/atomic_reference/mutex_atomic'
-
-  # @!macro atomic_reference
-  #
-  #   An object reference that may be updated atomically. All read and write
-  #   operations have java volatile semantic.
-  #
-  #   @!macro thread_safe_variable_comparison
-  #
-  #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html
-  #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html
-  #
-  #   @!method initialize(value = nil)
-  #     @!macro atomic_reference_method_initialize
-  #       @param [Object] value The initial value.
-  #
-  #   @!method get
-  #     @!macro atomic_reference_method_get
-  #       Gets the current value.
-  #       @return [Object] the current value
-  #
-  #   @!method set(new_value)
-  #     @!macro atomic_reference_method_set
-  #       Sets to the given value.
-  #       @param [Object] new_value the new value
-  #       @return [Object] the new value
-  #
-  #   @!method get_and_set(new_value)
-  #     @!macro atomic_reference_method_get_and_set
-  #       Atomically sets to the given value and returns the old value.
-  #       @param [Object] new_value the new value
-  #       @return [Object] the old value
-  #
-  #   @!method compare_and_set(old_value, new_value)
-  #     @!macro atomic_reference_method_compare_and_set
-  #
-  #       Atomically sets the value to the given updated value if
-  #       the current value == the expected value.
-  #
-  #       @param [Object] old_value the expected value
-  #       @param [Object] new_value the new value
-  #
-  #       @return [Boolean] `true` if successful. A `false` return indicates
-  #       that the actual value was not equal to the expected value.
-  #
-  #   @!method update
-  #     @!macro atomic_reference_method_update
-  #
-  #   @!method try_update
-  #     @!macro atomic_reference_method_try_update
-  #
-  #   @!method try_update!
-  #     @!macro atomic_reference_method_try_update!
-
-
-  # @!macro internal_implementation_note
-  class ConcurrentUpdateError < ThreadError
-    # frozen pre-allocated backtrace to speed ConcurrentUpdateError
-    CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
-  end
-
-  # @!macro internal_implementation_note
-  AtomicReferenceImplementation = case
-                                  when Concurrent.on_cruby? && Concurrent.c_extensions_loaded?
-                                    # @!visibility private
-                                    # @!macro internal_implementation_note
-                                    class CAtomicReference
-                                      include AtomicDirectUpdate
-                                      include AtomicNumericCompareAndSetWrapper
-                                      alias_method :compare_and_swap, :compare_and_set
-                                    end
-                                    CAtomicReference
-                                  when Concurrent.on_jruby?
-                                    # @!visibility private
-                                    # @!macro internal_implementation_note
-                                    class JavaAtomicReference
-                                      include AtomicDirectUpdate
-                                    end
-                                    JavaAtomicReference
-                                  when Concurrent.on_truffleruby?
-                                    class TruffleRubyAtomicReference < TruffleRuby::AtomicReference
-                                      include AtomicDirectUpdate
-                                      alias_method :value, :get
-                                      alias_method :value=, :set
-                                      alias_method :compare_and_swap, :compare_and_set
-                                      alias_method :swap, :get_and_set
-                                    end
-                                    TruffleRubyAtomicReference
-                                  when Concurrent.on_rbx?
-                                    # @note Extends `Rubinius::AtomicReference` version adding aliases
-                                    #   and numeric logic.
-                                    #
-                                    # @!visibility private
-                                    # @!macro internal_implementation_note
-                                    class RbxAtomicReference < Rubinius::AtomicReference
-                                      alias_method :_compare_and_set, :compare_and_set
-                                      include AtomicDirectUpdate
-                                      include AtomicNumericCompareAndSetWrapper
-                                      alias_method :value, :get
-                                      alias_method :value=, :set
-                                      alias_method :swap, :get_and_set
-                                      alias_method :compare_and_swap, :compare_and_set
-                                    end
-                                    RbxAtomicReference
-                                  else
-                                    MutexAtomicReference
-                                  end
-  private_constant :AtomicReferenceImplementation
-
-  # @!macro atomic_reference
-  class AtomicReference < AtomicReferenceImplementation
-
-    # @return [String] Short string representation.
-    def to_s
-      format '%s value:%s>', super[0..-2], get
-    end
-
-    alias_method :inspect, :to_s
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/java_thread_local_var.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/java_thread_local_var.rb
deleted file mode 100644
index b41018ffed837..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/java_thread_local_var.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-require 'concurrent/atomic/abstract_thread_local_var'
-
-if Concurrent.on_jruby?
-
-  module Concurrent
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class JavaThreadLocalVar < AbstractThreadLocalVar
-
-      # @!macro thread_local_var_method_get
-      def value
-        value = @var.get
-
-        if value.nil?
-          default
-        elsif value == NULL
-          nil
-        else
-          value
-        end
-      end
-
-      # @!macro thread_local_var_method_set
-      def value=(value)
-        @var.set(value)
-      end
-
-      protected
-
-      # @!visibility private
-      def allocate_storage
-        @var = java.lang.ThreadLocal.new
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/ruby_thread_local_var.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/ruby_thread_local_var.rb
deleted file mode 100644
index 9a51eb288b523..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/ruby_thread_local_var.rb
+++ /dev/null
@@ -1,181 +0,0 @@
-require 'thread'
-require 'concurrent/atomic/abstract_thread_local_var'
-
-module Concurrent
-
-  # @!visibility private
-  # @!macro internal_implementation_note
-  class RubyThreadLocalVar < AbstractThreadLocalVar
-
-    # Each thread has a (lazily initialized) array of thread-local variable values
-    # Each time a new thread-local var is created, we allocate an "index" for it
-    # For example, if the allocated index is 1, that means slot #1 in EVERY
-    #   thread's thread-local array will be used for the value of that TLV
-    #
-    # The good thing about using a per-THREAD structure to hold values, rather
-    #   than a per-TLV structure, is that no synchronization is needed when
-    #    reading and writing those values (since the structure is only ever
-    #    accessed by a single thread)
-    #
-    # Of course, when a TLV is GC'd, 1) we need to recover its index for use
-    #   by other new TLVs (otherwise the thread-local arrays could get bigger
-    #   and bigger with time), and 2) we need to null out all the references
-    #   held in the now-unused slots (both to avoid blocking GC of those objects,
-    #   and also to prevent "stale" values from being passed on to a new TLV
-    #   when the index is reused)
-    # Because we need to null out freed slots, we need to keep references to
-    #   ALL the thread-local arrays -- ARRAYS is for that
-    # But when a Thread is GC'd, we need to drop the reference to its thread-local
-    #   array, so we don't leak memory
-
-    FREE                = []
-    LOCK                = Mutex.new
-    THREAD_LOCAL_ARRAYS = {} # used as a hash set
-
-    # synchronize when not on MRI
-    # on MRI using lock in finalizer leads to "can't be called from trap context" error
-    # so the code is carefully written to be tread-safe on MRI relying on GIL
-
-    if Concurrent.on_cruby?
-      # @!visibility private
-      def self.semi_sync(&block)
-        block.call
-      end
-    else
-      # @!visibility private
-      def self.semi_sync(&block)
-        LOCK.synchronize(&block)
-      end
-    end
-
-    private_constant :FREE, :LOCK, :THREAD_LOCAL_ARRAYS
-
-    # @!macro thread_local_var_method_get
-    def value
-      if (array = get_threadlocal_array)
-        value = array[@index]
-        if value.nil?
-          default
-        elsif value.equal?(NULL)
-          nil
-        else
-          value
-        end
-      else
-        default
-      end
-    end
-
-    # @!macro thread_local_var_method_set
-    def value=(value)
-      me = Thread.current
-      # We could keep the thread-local arrays in a hash, keyed by Thread
-      # But why? That would require locking
-      # Using Ruby's built-in thread-local storage is faster
-      unless (array = get_threadlocal_array(me))
-        array = set_threadlocal_array([], me)
-        self.class.semi_sync { THREAD_LOCAL_ARRAYS[array.object_id] = array }
-        ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array.object_id))
-      end
-      array[@index] = (value.nil? ? NULL : value)
-      value
-    end
-
-    protected
-
-    # @!visibility private
-    def allocate_storage
-      @index = FREE.pop || next_index
-
-      ObjectSpace.define_finalizer(self, self.class.thread_local_finalizer(@index))
-    end
-
-    # @!visibility private
-    def self.thread_local_finalizer(index)
-      proc do
-        semi_sync do
-          # The cost of GC'ing a TLV is linear in the number of threads using TLVs
-          # But that is natural! More threads means more storage is used per TLV
-          # So naturally more CPU time is required to free more storage
-          #
-          # DO NOT use each_value which might conflict with new pair assignment
-          # into the hash in #value= method
-          THREAD_LOCAL_ARRAYS.values.each { |array| array[index] = nil }
-          # free index has to be published after the arrays are cleared
-          FREE.push(index)
-        end
-      end
-    end
-
-    # @!visibility private
-    def self.thread_finalizer(id)
-      proc do
-        semi_sync do
-          # The thread which used this thread-local array is now gone
-          # So don't hold onto a reference to the array (thus blocking GC)
-          THREAD_LOCAL_ARRAYS.delete(id)
-        end
-      end
-    end
-
-    private
-
-    # noinspection RubyClassVariableUsageInspection
-    @@next = 0
-    # noinspection RubyClassVariableUsageInspection
-    def next_index
-      LOCK.synchronize do
-        result = @@next
-        @@next += 1
-        result
-      end
-    end
-
-    if Thread.instance_methods.include?(:thread_variable_get)
-
-      def get_threadlocal_array(thread = Thread.current)
-        thread.thread_variable_get(:__threadlocal_array__)
-      end
-
-      def set_threadlocal_array(array, thread = Thread.current)
-        thread.thread_variable_set(:__threadlocal_array__, array)
-      end
-
-    else
-
-      def get_threadlocal_array(thread = Thread.current)
-        thread[:__threadlocal_array__]
-      end
-
-      def set_threadlocal_array(array, thread = Thread.current)
-        thread[:__threadlocal_array__] = array
-      end
-    end
-
-    # This exists only for use in testing
-    # @!visibility private
-    def value_for(thread)
-      if (array = get_threadlocal_array(thread))
-        value = array[@index]
-        if value.nil?
-          get_default
-        elsif value.equal?(NULL)
-          nil
-        else
-          value
-        end
-      else
-        get_default
-      end
-    end
-
-    # @!visibility private
-    def get_default
-      if @default_block
-        raise "Cannot use default_for with default block"
-      else
-        @default
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb
deleted file mode 100644
index 100cc8de8f9ff..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb
+++ /dev/null
@@ -1,104 +0,0 @@
-require 'concurrent/utility/engine'
-require 'concurrent/atomic/ruby_thread_local_var'
-require 'concurrent/atomic/java_thread_local_var'
-
-module Concurrent
-
-  ###################################################################
-
-  # @!macro thread_local_var_method_initialize
-  #
-  #   Creates a thread local variable.
-  #
-  #   @param [Object] default the default value when otherwise unset
-  #   @param [Proc] default_block Optional block that gets called to obtain the
-  #     default value for each thread
-
-  # @!macro thread_local_var_method_get
-  #
-  #   Returns the value in the current thread's copy of this thread-local variable.
-  #
-  #   @return [Object] the current value
-
-  # @!macro thread_local_var_method_set
-  #
-  #   Sets the current thread's copy of this thread-local variable to the specified value.
-  #
-  #   @param [Object] value the value to set
-  #   @return [Object] the new value
-
-  # @!macro thread_local_var_method_bind
-  #
-  #   Bind the given value to thread local storage during
-  #   execution of the given block.
-  #
-  #   @param [Object] value the value to bind
-  #   @yield the operation to be performed with the bound variable
-  #   @return [Object] the value
-
-
-  ###################################################################
-
-  # @!macro thread_local_var_public_api
-  #
-  #   @!method initialize(default = nil, &default_block)
-  #     @!macro thread_local_var_method_initialize
-  #
-  #   @!method value
-  #     @!macro thread_local_var_method_get
-  #
-  #   @!method value=(value)
-  #     @!macro thread_local_var_method_set
-  #
-  #   @!method bind(value, &block)
-  #     @!macro thread_local_var_method_bind
-
-  ###################################################################
-
-  # @!visibility private
-  # @!macro internal_implementation_note
-  ThreadLocalVarImplementation = case
-                                 when Concurrent.on_jruby?
-                                   JavaThreadLocalVar
-                                 else
-                                   RubyThreadLocalVar
-                                 end
-  private_constant :ThreadLocalVarImplementation
-
-  # @!macro thread_local_var
-  #
-  #   A `ThreadLocalVar` is a variable where the value is different for each thread.
-  #   Each variable may have a default value, but when you modify the variable only
-  #   the current thread will ever see that change.
-  #
-  #   @!macro thread_safe_variable_comparison
-  #
-  #   @example
-  #     v = ThreadLocalVar.new(14)
-  #     v.value #=> 14
-  #     v.value = 2
-  #     v.value #=> 2
-  #
-  #   @example
-  #     v = ThreadLocalVar.new(14)
-  #
-  #     t1 = Thread.new do
-  #       v.value #=> 14
-  #       v.value = 1
-  #       v.value #=> 1
-  #     end
-  #
-  #     t2 = Thread.new do
-  #       v.value #=> 14
-  #       v.value = 2
-  #       v.value #=> 2
-  #     end
-  #
-  #     v.value #=> 14
-  #
-  #   @see https://docs.oracle.com/javase/7/docs/api/java/lang/ThreadLocal.html Java ThreadLocal
-  #
-  # @!macro thread_local_var_public_api
-  class ThreadLocalVar < ThreadLocalVarImplementation
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb
deleted file mode 100644
index d092aedd5bbe2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-module Concurrent
-
-  # @!visibility private
-  # @!macro internal_implementation_note
-  class MutexAtomicReference < Synchronization::LockableObject
-    include AtomicDirectUpdate
-    include AtomicNumericCompareAndSetWrapper
-    alias_method :compare_and_swap, :compare_and_set
-
-    # @!macro atomic_reference_method_initialize
-    def initialize(value = nil)
-      super()
-      synchronize { ns_initialize(value) }
-    end
-
-    # @!macro atomic_reference_method_get
-    def get
-      synchronize { @value }
-    end
-    alias_method :value, :get
-
-    # @!macro atomic_reference_method_set
-    def set(new_value)
-      synchronize { @value = new_value }
-    end
-    alias_method :value=, :set
-
-    # @!macro atomic_reference_method_get_and_set
-    def get_and_set(new_value)
-      synchronize do
-        old_value = @value
-        @value = new_value
-        old_value
-      end
-    end
-    alias_method :swap, :get_and_set
-
-    # @!macro atomic_reference_method_compare_and_set
-    def _compare_and_set(old_value, new_value)
-      synchronize do
-        if @value.equal? old_value
-          @value = new_value
-          true
-        else
-          false
-        end
-      end
-    end
-
-    protected
-
-    def ns_initialize(value)
-      @value = value
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/map/atomic_reference_map_backend.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/map/atomic_reference_map_backend.rb
deleted file mode 100644
index dc5189389da36..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/map/atomic_reference_map_backend.rb
+++ /dev/null
@@ -1,927 +0,0 @@
-require 'concurrent/constants'
-require 'concurrent/thread_safe/util'
-require 'concurrent/thread_safe/util/adder'
-require 'concurrent/thread_safe/util/cheap_lockable'
-require 'concurrent/thread_safe/util/power_of_two_tuple'
-require 'concurrent/thread_safe/util/volatile'
-require 'concurrent/thread_safe/util/xor_shift_random'
-
-module Concurrent
-
-  # @!visibility private
-  module Collection
-
-    # A Ruby port of the Doug Lea's jsr166e.ConcurrentHashMapV8 class version 1.59
-    # available in public domain.
-    #
-    # Original source code available here:
-    # http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/jsr166e/ConcurrentHashMapV8.java?revision=1.59
-    #
-    # The Ruby port skips out the +TreeBin+ (red-black trees for use in bins whose
-    # size exceeds a threshold).
-    #
-    # A hash table supporting full concurrency of retrievals and high expected
-    # concurrency for updates. However, even though all operations are
-    # thread-safe, retrieval operations do _not_ entail locking, and there is
-    # _not_ any support for locking the entire table in a way that prevents all
-    # access.
-    #
-    # Retrieval operations generally do not block, so may overlap with update
-    # operations. Retrievals reflect the results of the most recently _completed_
-    # update operations holding upon their onset. (More formally, an update
-    # operation for a given key bears a _happens-before_ relation with any (non
-    # +nil+) retrieval for that key reporting the updated value.) For aggregate
-    # operations such as +clear()+, concurrent retrievals may reflect insertion or
-    # removal of only some entries. Similarly, the +each_pair+ iterator yields
-    # elements reflecting the state of the hash table at some point at or since
-    # the start of the +each_pair+. Bear in mind that the results of aggregate
-    # status methods including +size()+ and +empty?+} are typically useful only
-    # when a map is not undergoing concurrent updates in other threads. Otherwise
-    # the results of these methods reflect transient states that may be adequate
-    # for monitoring or estimation purposes, but not for program control.
-    #
-    # The table is dynamically expanded when there are too many collisions (i.e.,
-    # keys that have distinct hash codes but fall into the same slot modulo the
-    # table size), with the expected average effect of maintaining roughly two
-    # bins per mapping (corresponding to a 0.75 load factor threshold for
-    # resizing). There may be much variance around this average as mappings are
-    # added and removed, but overall, this maintains a commonly accepted
-    # time/space tradeoff for hash tables. However, resizing this or any other
-    # kind of hash table may be a relatively slow operation. When possible, it is
-    # a good idea to provide a size estimate as an optional :initial_capacity
-    # initializer argument. An additional optional :load_factor constructor
-    # argument provides a further means of customizing initial table capacity by
-    # specifying the table density to be used in calculating the amount of space
-    # to allocate for the given number of elements. Note that using many keys with
-    # exactly the same +hash+ is a sure way to slow down performance of any hash
-    # table.
-    #
-    # ## Design overview
-    #
-    # The primary design goal of this hash table is to maintain concurrent
-    # readability (typically method +[]+, but also iteration and related methods)
-    # while minimizing update contention. Secondary goals are to keep space
-    # consumption about the same or better than plain +Hash+, and to support high
-    # initial insertion rates on an empty table by many threads.
-    #
-    # Each key-value mapping is held in a +Node+. The validation-based approach
-    # explained below leads to a lot of code sprawl because retry-control
-    # precludes factoring into smaller methods.
-    #
-    # The table is lazily initialized to a power-of-two size upon the first
-    # insertion. Each bin in the table normally contains a list of +Node+s (most
-    # often, the list has only zero or one +Node+). Table accesses require
-    # volatile/atomic reads, writes, and CASes. The lists of nodes within bins are
-    # always accurately traversable under volatile reads, so long as lookups check
-    # hash code and non-nullness of value before checking key equality.
-    #
-    # We use the top two bits of +Node+ hash fields for control purposes -- they
-    # are available anyway because of addressing constraints. As explained further
-    # below, these top bits are used as follows:
-    #
-    #   - 00 - Normal
-    #   - 01 - Locked
-    #   - 11 - Locked and may have a thread waiting for lock
-    #   - 10 - +Node+ is a forwarding node
-    #
-    # The lower 28 bits of each +Node+'s hash field contain a the key's hash code,
-    # except for forwarding nodes, for which the lower bits are zero (and so
-    # always have hash field == +MOVED+).
-    #
-    # Insertion (via +[]=+ or its variants) of the first node in an empty bin is
-    # performed by just CASing it to the bin. This is by far the most common case
-    # for put operations under most key/hash distributions. Other update
-    # operations (insert, delete, and replace) require locks. We do not want to
-    # waste the space required to associate a distinct lock object with each bin,
-    # so instead use the first node of a bin list itself as a lock. Blocking
-    # support for these locks relies +Concurrent::ThreadSafe::Util::CheapLockable. However, we also need a
-    # +try_lock+ construction, so we overlay these by using bits of the +Node+
-    # hash field for lock control (see above), and so normally use builtin
-    # monitors only for blocking and signalling using
-    # +cheap_wait+/+cheap_broadcast+ constructions. See +Node#try_await_lock+.
-    #
-    # Using the first node of a list as a lock does not by itself suffice though:
-    # When a node is locked, any update must first validate that it is still the
-    # first node after locking it, and retry if not. Because new nodes are always
-    # appended to lists, once a node is first in a bin, it remains first until
-    # deleted or the bin becomes invalidated (upon resizing). However, operations
-    # that only conditionally update may inspect nodes until the point of update.
-    # This is a converse of sorts to the lazy locking technique described by
-    # Herlihy & Shavit.
-    #
-    # The main disadvantage of per-bin locks is that other update operations on
-    # other nodes in a bin list protected by the same lock can stall, for example
-    # when user +eql?+ or mapping functions take a long time. However,
-    # statistically, under random hash codes, this is not a common problem.
-    # Ideally, the frequency of nodes in bins follows a Poisson distribution
-    # (http://en.wikipedia.org/wiki/Poisson_distribution) with a parameter of
-    # about 0.5 on average, given the resizing threshold of 0.75, although with a
-    # large variance because of resizing granularity. Ignoring variance, the
-    # expected occurrences of list size k are (exp(-0.5) * pow(0.5, k) /
-    # factorial(k)). The first values are:
-    #
-    #   - 0:    0.60653066
-    #   - 1:    0.30326533
-    #   - 2:    0.07581633
-    #   - 3:    0.01263606
-    #   - 4:    0.00157952
-    #   - 5:    0.00015795
-    #   - 6:    0.00001316
-    #   - 7:    0.00000094
-    #   - 8:    0.00000006
-    #   - more: less than 1 in ten million
-    #
-    # Lock contention probability for two threads accessing distinct elements is
-    # roughly 1 / (8 * #elements) under random hashes.
-    #
-    # The table is resized when occupancy exceeds a percentage threshold
-    # (nominally, 0.75, but see below). Only a single thread performs the resize
-    # (using field +size_control+, to arrange exclusion), but the table otherwise
-    # remains usable for reads and updates. Resizing proceeds by transferring
-    # bins, one by one, from the table to the next table. Because we are using
-    # power-of-two expansion, the elements from each bin must either stay at same
-    # index, or move with a power of two offset. We eliminate unnecessary node
-    # creation by catching cases where old nodes can be reused because their next
-    # fields won't change. On average, only about one-sixth of them need cloning
-    # when a table doubles. The nodes they replace will be garbage collectable as
-    # soon as they are no longer referenced by any reader thread that may be in
-    # the midst of concurrently traversing table. Upon transfer, the old table bin
-    # contains only a special forwarding node (with hash field +MOVED+) that
-    # contains the next table as its key. On encountering a forwarding node,
-    # access and update operations restart, using the new table.
-    #
-    # Each bin transfer requires its bin lock. However, unlike other cases, a
-    # transfer can skip a bin if it fails to acquire its lock, and revisit it
-    # later. Method +rebuild+ maintains a buffer of TRANSFER_BUFFER_SIZE bins that
-    # have been skipped because of failure to acquire a lock, and blocks only if
-    # none are available (i.e., only very rarely). The transfer operation must
-    # also ensure that all accessible bins in both the old and new table are
-    # usable by any traversal. When there are no lock acquisition failures, this
-    # is arranged simply by proceeding from the last bin (+table.size - 1+) up
-    # towards the first. Upon seeing a forwarding node, traversals arrange to move
-    # to the new table without revisiting nodes. However, when any node is skipped
-    # during a transfer, all earlier table bins may have become visible, so are
-    # initialized with a reverse-forwarding node back to the old table until the
-    # new ones are established. (This sometimes requires transiently locking a
-    # forwarding node, which is possible under the above encoding.) These more
-    # expensive mechanics trigger only when necessary.
-    #
-    # The traversal scheme also applies to partial traversals of
-    # ranges of bins (via an alternate Traverser constructor)
-    # to support partitioned aggregate operations.  Also, read-only
-    # operations give up if ever forwarded to a null table, which
-    # provides support for shutdown-style clearing, which is also not
-    # currently implemented.
-    #
-    # Lazy table initialization minimizes footprint until first use.
-    #
-    # The element count is maintained using a +Concurrent::ThreadSafe::Util::Adder+,
-    # which avoids contention on updates but can encounter cache thrashing
-    # if read too frequently during concurrent access. To avoid reading so
-    # often, resizing is attempted either when a bin lock is
-    # contended, or upon adding to a bin already holding two or more
-    # nodes (checked before adding in the +x_if_absent+ methods, after
-    # adding in others). Under uniform hash distributions, the
-    # probability of this occurring at threshold is around 13%,
-    # meaning that only about 1 in 8 puts check threshold (and after
-    # resizing, many fewer do so). But this approximation has high
-    # variance for small table sizes, so we check on any collision
-    # for sizes <= 64. The bulk putAll operation further reduces
-    # contention by only committing count updates upon these size
-    # checks.
-    #
-    # @!visibility private
-    class AtomicReferenceMapBackend
-
-      # @!visibility private
-      class Table < Concurrent::ThreadSafe::Util::PowerOfTwoTuple
-        def cas_new_node(i, hash, key, value)
-          cas(i, nil, Node.new(hash, key, value))
-        end
-
-        def try_to_cas_in_computed(i, hash, key)
-          succeeded = false
-          new_value = nil
-          new_node  = Node.new(locked_hash = hash | LOCKED, key, NULL)
-          if cas(i, nil, new_node)
-            begin
-              if NULL == (new_value = yield(NULL))
-                was_null = true
-              else
-                new_node.value = new_value
-              end
-              succeeded = true
-            ensure
-              volatile_set(i, nil) if !succeeded || was_null
-              new_node.unlock_via_hash(locked_hash, hash)
-            end
-          end
-          return succeeded, new_value
-        end
-
-        def try_lock_via_hash(i, node, node_hash)
-          node.try_lock_via_hash(node_hash) do
-            yield if volatile_get(i) == node
-          end
-        end
-
-        def delete_node_at(i, node, predecessor_node)
-          if predecessor_node
-            predecessor_node.next = node.next
-          else
-            volatile_set(i, node.next)
-          end
-        end
-      end
-
-      # Key-value entry. Nodes with a hash field of +MOVED+ are special, and do
-      # not contain user keys or values. Otherwise, keys are never +nil+, and
-      # +NULL+ +value+ fields indicate that a node is in the process of being
-      # deleted or created. For purposes of read-only access, a key may be read
-      # before a value, but can only be used after checking value to be +!= NULL+.
-      #
-      # @!visibility private
-      class Node
-        extend Concurrent::ThreadSafe::Util::Volatile
-        attr_volatile :hash, :value, :next
-
-        include Concurrent::ThreadSafe::Util::CheapLockable
-
-        bit_shift = Concurrent::ThreadSafe::Util::FIXNUM_BIT_SIZE - 2 # need 2 bits for ourselves
-        # Encodings for special uses of Node hash fields. See above for explanation.
-        MOVED     = ('10' << ('0' * bit_shift)).to_i(2) # hash field for forwarding nodes
-        LOCKED    = ('01' << ('0' * bit_shift)).to_i(2) # set/tested only as a bit
-        WAITING   = ('11' << ('0' * bit_shift)).to_i(2) # both bits set/tested together
-        HASH_BITS = ('00' << ('1' * bit_shift)).to_i(2) # usable bits of normal node hash
-
-        SPIN_LOCK_ATTEMPTS = Concurrent::ThreadSafe::Util::CPU_COUNT > 1 ? Concurrent::ThreadSafe::Util::CPU_COUNT * 2 : 0
-
-        attr_reader :key
-
-        def initialize(hash, key, value, next_node = nil)
-          super()
-          @key = key
-          self.lazy_set_hash(hash)
-          self.lazy_set_value(value)
-          self.next = next_node
-        end
-
-        # Spins a while if +LOCKED+ bit set and this node is the first of its bin,
-        # and then sets +WAITING+ bits on hash field and blocks (once) if they are
-        # still set. It is OK for this method to return even if lock is not
-        # available upon exit, which enables these simple single-wait mechanics.
-        #
-        # The corresponding signalling operation is performed within callers: Upon
-        # detecting that +WAITING+ has been set when unlocking lock (via a failed
-        # CAS from non-waiting +LOCKED+ state), unlockers acquire the
-        # +cheap_synchronize+ lock and perform a +cheap_broadcast+.
-        def try_await_lock(table, i)
-          if table && i >= 0 && i < table.size # bounds check, TODO: why are we bounds checking?
-            spins = SPIN_LOCK_ATTEMPTS
-            randomizer = base_randomizer = Concurrent::ThreadSafe::Util::XorShiftRandom.get
-            while equal?(table.volatile_get(i)) && self.class.locked_hash?(my_hash = hash)
-              if spins >= 0
-                if (randomizer = (randomizer >> 1)).even? # spin at random
-                  if (spins -= 1) == 0
-                    Thread.pass # yield before blocking
-                  else
-                    randomizer = base_randomizer = Concurrent::ThreadSafe::Util::XorShiftRandom.xorshift(base_randomizer) if randomizer.zero?
-                  end
-                end
-              elsif cas_hash(my_hash, my_hash | WAITING)
-                force_acquire_lock(table, i)
-                break
-              end
-            end
-          end
-        end
-
-        def key?(key)
-          @key.eql?(key)
-        end
-
-        def matches?(key, hash)
-          pure_hash == hash && key?(key)
-        end
-
-        def pure_hash
-          hash & HASH_BITS
-        end
-
-        def try_lock_via_hash(node_hash = hash)
-          if cas_hash(node_hash, locked_hash = node_hash | LOCKED)
-            begin
-              yield
-            ensure
-              unlock_via_hash(locked_hash, node_hash)
-            end
-          end
-        end
-
-        def locked?
-          self.class.locked_hash?(hash)
-        end
-
-        def unlock_via_hash(locked_hash, node_hash)
-          unless cas_hash(locked_hash, node_hash)
-            self.hash = node_hash
-            cheap_synchronize { cheap_broadcast }
-          end
-        end
-
-        private
-        def force_acquire_lock(table, i)
-          cheap_synchronize do
-            if equal?(table.volatile_get(i)) && (hash & WAITING) == WAITING
-              cheap_wait
-            else
-              cheap_broadcast # possibly won race vs signaller
-            end
-          end
-        end
-
-        class << self
-          def locked_hash?(hash)
-            (hash & LOCKED) != 0
-          end
-        end
-      end
-
-      # shorthands
-      MOVED     = Node::MOVED
-      LOCKED    = Node::LOCKED
-      WAITING   = Node::WAITING
-      HASH_BITS = Node::HASH_BITS
-
-      NOW_RESIZING     = -1
-      DEFAULT_CAPACITY = 16
-      MAX_CAPACITY     = Concurrent::ThreadSafe::Util::MAX_INT
-
-      # The buffer size for skipped bins during transfers. The
-      # value is arbitrary but should be large enough to avoid
-      # most locking stalls during resizes.
-      TRANSFER_BUFFER_SIZE = 32
-
-      extend Concurrent::ThreadSafe::Util::Volatile
-      attr_volatile :table, # The array of bins. Lazily initialized upon first insertion. Size is always a power of two.
-
-        # Table initialization and resizing control.  When negative, the
-        # table is being initialized or resized. Otherwise, when table is
-        # null, holds the initial table size to use upon creation, or 0
-        # for default. After initialization, holds the next element count
-        # value upon which to resize the table.
-        :size_control
-
-      def initialize(options = nil)
-        super()
-        @counter = Concurrent::ThreadSafe::Util::Adder.new
-        initial_capacity  = options && options[:initial_capacity] || DEFAULT_CAPACITY
-        self.size_control = (capacity = table_size_for(initial_capacity)) > MAX_CAPACITY ? MAX_CAPACITY : capacity
-      end
-
-      def get_or_default(key, else_value = nil)
-        hash          = key_hash(key)
-        current_table = table
-        while current_table
-          node = current_table.volatile_get_by_hash(hash)
-          current_table =
-            while node
-              if (node_hash = node.hash) == MOVED
-                break node.key
-              elsif (node_hash & HASH_BITS) == hash && node.key?(key) && NULL != (value = node.value)
-                return value
-              end
-              node = node.next
-            end
-        end
-        else_value
-      end
-
-      def [](key)
-        get_or_default(key)
-      end
-
-      def key?(key)
-        get_or_default(key, NULL) != NULL
-      end
-
-      def []=(key, value)
-        get_and_set(key, value)
-        value
-      end
-
-      def compute_if_absent(key)
-        hash          = key_hash(key)
-        current_table = table || initialize_table
-        while true
-          if !(node = current_table.volatile_get(i = current_table.hash_to_index(hash)))
-            succeeded, new_value = current_table.try_to_cas_in_computed(i, hash, key) { yield }
-            if succeeded
-              increment_size
-              return new_value
-            end
-          elsif (node_hash = node.hash) == MOVED
-            current_table = node.key
-          elsif NULL != (current_value = find_value_in_node_list(node, key, hash, node_hash & HASH_BITS))
-            return current_value
-          elsif Node.locked_hash?(node_hash)
-            try_await_lock(current_table, i, node)
-          else
-            succeeded, value = attempt_internal_compute_if_absent(key, hash, current_table, i, node, node_hash) { yield }
-            return value if succeeded
-          end
-        end
-      end
-
-      def compute_if_present(key)
-        new_value = nil
-        internal_replace(key) do |old_value|
-          if (new_value = yield(NULL == old_value ? nil : old_value)).nil?
-            NULL
-          else
-            new_value
-          end
-        end
-        new_value
-      end
-
-      def compute(key)
-        internal_compute(key) do |old_value|
-          if (new_value = yield(NULL == old_value ? nil : old_value)).nil?
-            NULL
-          else
-            new_value
-          end
-        end
-      end
-
-      def merge_pair(key, value)
-        internal_compute(key) do |old_value|
-          if NULL == old_value || !(value = yield(old_value)).nil?
-            value
-          else
-            NULL
-          end
-        end
-      end
-
-      def replace_pair(key, old_value, new_value)
-        NULL != internal_replace(key, old_value) { new_value }
-      end
-
-      def replace_if_exists(key, new_value)
-        if (result = internal_replace(key) { new_value }) && NULL != result
-          result
-        end
-      end
-
-      def get_and_set(key, value) # internalPut in the original CHMV8
-        hash          = key_hash(key)
-        current_table = table || initialize_table
-        while true
-          if !(node = current_table.volatile_get(i = current_table.hash_to_index(hash)))
-            if current_table.cas_new_node(i, hash, key, value)
-              increment_size
-              break
-            end
-          elsif (node_hash = node.hash) == MOVED
-            current_table = node.key
-          elsif Node.locked_hash?(node_hash)
-            try_await_lock(current_table, i, node)
-          else
-            succeeded, old_value = attempt_get_and_set(key, value, hash, current_table, i, node, node_hash)
-            break old_value if succeeded
-          end
-        end
-      end
-
-      def delete(key)
-        replace_if_exists(key, NULL)
-      end
-
-      def delete_pair(key, value)
-        result = internal_replace(key, value) { NULL }
-        if result && NULL != result
-          !!result
-        else
-          false
-        end
-      end
-
-      def each_pair
-        return self unless current_table = table
-        current_table_size = base_size = current_table.size
-        i = base_index = 0
-        while base_index < base_size
-          if node = current_table.volatile_get(i)
-            if node.hash == MOVED
-              current_table      = node.key
-              current_table_size = current_table.size
-            else
-              begin
-                if NULL != (value = node.value) # skip deleted or special nodes
-                  yield node.key, value
-                end
-              end while node = node.next
-            end
-          end
-
-          if (i_with_base = i + base_size) < current_table_size
-            i = i_with_base # visit upper slots if present
-          else
-            i = base_index += 1
-          end
-        end
-        self
-      end
-
-      def size
-        (sum = @counter.sum) < 0 ? 0 : sum # ignore transient negative values
-      end
-
-      def empty?
-        size == 0
-      end
-
-      # Implementation for clear. Steps through each bin, removing all nodes.
-      def clear
-        return self unless current_table = table
-        current_table_size = current_table.size
-        deleted_count = i = 0
-        while i < current_table_size
-          if !(node = current_table.volatile_get(i))
-            i += 1
-          elsif (node_hash = node.hash) == MOVED
-            current_table      = node.key
-            current_table_size = current_table.size
-          elsif Node.locked_hash?(node_hash)
-            decrement_size(deleted_count) # opportunistically update count
-            deleted_count = 0
-            node.try_await_lock(current_table, i)
-          else
-            current_table.try_lock_via_hash(i, node, node_hash) do
-              begin
-                deleted_count += 1 if NULL != node.value # recheck under lock
-                node.value = nil
-              end while node = node.next
-              current_table.volatile_set(i, nil)
-              i += 1
-            end
-          end
-        end
-        decrement_size(deleted_count)
-        self
-      end
-
-      private
-      # Internal versions of the insertion methods, each a
-      # little more complicated than the last. All have
-      # the same basic structure:
-      #  1. If table uninitialized, create
-      #  2. If bin empty, try to CAS new node
-      #  3. If bin stale, use new table
-      #  4. Lock and validate; if valid, scan and add or update
-      #
-      # The others interweave other checks and/or alternative actions:
-      #  * Plain +get_and_set+ checks for and performs resize after insertion.
-      #  * compute_if_absent prescans for mapping without lock (and fails to add
-      #    if present), which also makes pre-emptive resize checks worthwhile.
-      #
-      # Someday when details settle down a bit more, it might be worth
-      # some factoring to reduce sprawl.
-      def internal_replace(key, expected_old_value = NULL, &block)
-        hash          = key_hash(key)
-        current_table = table
-        while current_table
-          if !(node = current_table.volatile_get(i = current_table.hash_to_index(hash)))
-            break
-          elsif (node_hash = node.hash) == MOVED
-            current_table = node.key
-          elsif (node_hash & HASH_BITS) != hash && !node.next # precheck
-            break # rules out possible existence
-          elsif Node.locked_hash?(node_hash)
-            try_await_lock(current_table, i, node)
-          else
-            succeeded, old_value = attempt_internal_replace(key, expected_old_value, hash, current_table, i, node, node_hash, &block)
-            return old_value if succeeded
-          end
-        end
-        NULL
-      end
-
-      def attempt_internal_replace(key, expected_old_value, hash, current_table, i, node, node_hash)
-        current_table.try_lock_via_hash(i, node, node_hash) do
-          predecessor_node = nil
-          old_value        = NULL
-          begin
-            if node.matches?(key, hash) && NULL != (current_value = node.value)
-              if NULL == expected_old_value || expected_old_value == current_value # NULL == expected_old_value means whatever value
-                old_value = current_value
-                if NULL == (node.value = yield(old_value))
-                  current_table.delete_node_at(i, node, predecessor_node)
-                  decrement_size
-                end
-              end
-              break
-            end
-
-            predecessor_node = node
-          end while node = node.next
-
-          return true, old_value
-        end
-      end
-
-      def find_value_in_node_list(node, key, hash, pure_hash)
-        do_check_for_resize = false
-        while true
-          if pure_hash == hash && node.key?(key) && NULL != (value = node.value)
-            return value
-          elsif node = node.next
-            do_check_for_resize = true # at least 2 nodes -> check for resize
-            pure_hash = node.pure_hash
-          else
-            return NULL
-          end
-        end
-      ensure
-        check_for_resize if do_check_for_resize
-      end
-
-      def internal_compute(key, &block)
-        hash          = key_hash(key)
-        current_table = table || initialize_table
-        while true
-          if !(node = current_table.volatile_get(i = current_table.hash_to_index(hash)))
-            succeeded, new_value = current_table.try_to_cas_in_computed(i, hash, key, &block)
-            if succeeded
-              if NULL == new_value
-                break nil
-              else
-                increment_size
-                break new_value
-              end
-            end
-          elsif (node_hash = node.hash) == MOVED
-            current_table = node.key
-          elsif Node.locked_hash?(node_hash)
-            try_await_lock(current_table, i, node)
-          else
-            succeeded, new_value = attempt_compute(key, hash, current_table, i, node, node_hash, &block)
-            break new_value if succeeded
-          end
-        end
-      end
-
-      def attempt_internal_compute_if_absent(key, hash, current_table, i, node, node_hash)
-        added = false
-        current_table.try_lock_via_hash(i, node, node_hash) do
-          while true
-            if node.matches?(key, hash) && NULL != (value = node.value)
-              return true, value
-            end
-            last = node
-            unless node = node.next
-              last.next = Node.new(hash, key, value = yield)
-              added = true
-              increment_size
-              return true, value
-            end
-          end
-        end
-      ensure
-        check_for_resize if added
-      end
-
-      def attempt_compute(key, hash, current_table, i, node, node_hash)
-        added = false
-        current_table.try_lock_via_hash(i, node, node_hash) do
-          predecessor_node = nil
-          while true
-            if node.matches?(key, hash) && NULL != (value = node.value)
-              if NULL == (node.value = value = yield(value))
-                current_table.delete_node_at(i, node, predecessor_node)
-                decrement_size
-                value = nil
-              end
-              return true, value
-            end
-            predecessor_node = node
-            unless node = node.next
-              if NULL == (value = yield(NULL))
-                value = nil
-              else
-                predecessor_node.next = Node.new(hash, key, value)
-                added = true
-                increment_size
-              end
-              return true, value
-            end
-          end
-        end
-      ensure
-        check_for_resize if added
-      end
-
-      def attempt_get_and_set(key, value, hash, current_table, i, node, node_hash)
-        node_nesting = nil
-        current_table.try_lock_via_hash(i, node, node_hash) do
-          node_nesting    = 1
-          old_value       = nil
-          found_old_value = false
-          while node
-            if node.matches?(key, hash) && NULL != (old_value = node.value)
-              found_old_value = true
-              node.value = value
-              break
-            end
-            last = node
-            unless node = node.next
-              last.next = Node.new(hash, key, value)
-              break
-            end
-            node_nesting += 1
-          end
-
-          return true, old_value if found_old_value
-          increment_size
-          true
-        end
-      ensure
-        check_for_resize if node_nesting && (node_nesting > 1 || current_table.size <= 64)
-      end
-
-      def initialize_copy(other)
-        super
-        @counter = Concurrent::ThreadSafe::Util::Adder.new
-        self.table = nil
-        self.size_control = (other_table = other.table) ? other_table.size : DEFAULT_CAPACITY
-        self
-      end
-
-      def try_await_lock(current_table, i, node)
-        check_for_resize # try resizing if can't get lock
-        node.try_await_lock(current_table, i)
-      end
-
-      def key_hash(key)
-        key.hash & HASH_BITS
-      end
-
-      # Returns a power of two table size for the given desired capacity.
-      def table_size_for(entry_count)
-        size = 2
-        size <<= 1 while size < entry_count
-        size
-      end
-
-      # Initializes table, using the size recorded in +size_control+.
-      def initialize_table
-        until current_table ||= table
-          if (size_ctrl = size_control) == NOW_RESIZING
-            Thread.pass # lost initialization race; just spin
-          else
-            try_in_resize_lock(current_table, size_ctrl) do
-              initial_size = size_ctrl > 0 ? size_ctrl : DEFAULT_CAPACITY
-              current_table = self.table = Table.new(initial_size)
-              initial_size - (initial_size >> 2) # 75% load factor
-            end
-          end
-        end
-        current_table
-      end
-
-      # If table is too small and not already resizing, creates next table and
-      # transfers bins. Rechecks occupancy after a transfer to see if another
-      # resize is already needed because resizings are lagging additions.
-      def check_for_resize
-        while (current_table = table) && MAX_CAPACITY > (table_size = current_table.size) && NOW_RESIZING != (size_ctrl = size_control) && size_ctrl < @counter.sum
-          try_in_resize_lock(current_table, size_ctrl) do
-            self.table = rebuild(current_table)
-            (table_size << 1) - (table_size >> 1) # 75% load factor
-          end
-        end
-      end
-
-      def try_in_resize_lock(current_table, size_ctrl)
-        if cas_size_control(size_ctrl, NOW_RESIZING)
-          begin
-            if current_table == table # recheck under lock
-              size_ctrl = yield # get new size_control
-            end
-          ensure
-            self.size_control = size_ctrl
-          end
-        end
-      end
-
-      # Moves and/or copies the nodes in each bin to new table. See above for explanation.
-      def rebuild(table)
-        old_table_size = table.size
-        new_table      = table.next_in_size_table
-        # puts "#{old_table_size} -> #{new_table.size}"
-        forwarder      = Node.new(MOVED, new_table, NULL)
-        rev_forwarder  = nil
-        locked_indexes = nil # holds bins to revisit; nil until needed
-        locked_arr_idx = 0
-        bin            = old_table_size - 1
-        i              = bin
-        while true
-          if !(node = table.volatile_get(i))
-            # no lock needed (or available) if bin >= 0, because we're not popping values from locked_indexes until we've run through the whole table
-            redo unless (bin >= 0 ? table.cas(i, nil, forwarder) : lock_and_clean_up_reverse_forwarders(table, old_table_size, new_table, i, forwarder))
-          elsif Node.locked_hash?(node_hash = node.hash)
-            locked_indexes ||= ::Array.new
-            if bin < 0 && locked_arr_idx > 0
-              locked_arr_idx -= 1
-              i, locked_indexes[locked_arr_idx] = locked_indexes[locked_arr_idx], i # swap with another bin
-              redo
-            end
-            if bin < 0 || locked_indexes.size >= TRANSFER_BUFFER_SIZE
-              node.try_await_lock(table, i) # no other options -- block
-              redo
-            end
-            rev_forwarder ||= Node.new(MOVED, table, NULL)
-            redo unless table.volatile_get(i) == node && node.locked? # recheck before adding to list
-            locked_indexes << i
-            new_table.volatile_set(i, rev_forwarder)
-            new_table.volatile_set(i + old_table_size, rev_forwarder)
-          else
-            redo unless split_old_bin(table, new_table, i, node, node_hash, forwarder)
-          end
-
-          if bin > 0
-            i = (bin -= 1)
-          elsif locked_indexes && !locked_indexes.empty?
-            bin = -1
-            i = locked_indexes.pop
-            locked_arr_idx = locked_indexes.size - 1
-          else
-            return new_table
-          end
-        end
-      end
-
-      def lock_and_clean_up_reverse_forwarders(old_table, old_table_size, new_table, i, forwarder)
-        # transiently use a locked forwarding node
-        locked_forwarder = Node.new(moved_locked_hash = MOVED | LOCKED, new_table, NULL)
-        if old_table.cas(i, nil, locked_forwarder)
-          new_table.volatile_set(i, nil) # kill the potential reverse forwarders
-          new_table.volatile_set(i + old_table_size, nil) # kill the potential reverse forwarders
-          old_table.volatile_set(i, forwarder)
-          locked_forwarder.unlock_via_hash(moved_locked_hash, MOVED)
-          true
-        end
-      end
-
-      # Splits a normal bin with list headed by e into lo and hi parts; installs in given table.
-      def split_old_bin(table, new_table, i, node, node_hash, forwarder)
-        table.try_lock_via_hash(i, node, node_hash) do
-          split_bin(new_table, i, node, node_hash)
-          table.volatile_set(i, forwarder)
-        end
-      end
-
-      def split_bin(new_table, i, node, node_hash)
-        bit          = new_table.size >> 1 # bit to split on
-        run_bit      = node_hash & bit
-        last_run     = nil
-        low          = nil
-        high         = nil
-        current_node = node
-        # this optimises for the lowest amount of volatile writes and objects created
-        while current_node = current_node.next
-          unless (b = current_node.hash & bit) == run_bit
-            run_bit  = b
-            last_run = current_node
-          end
-        end
-        if run_bit == 0
-          low = last_run
-        else
-          high = last_run
-        end
-        current_node = node
-        until current_node == last_run
-          pure_hash = current_node.pure_hash
-          if (pure_hash & bit) == 0
-            low = Node.new(pure_hash, current_node.key, current_node.value, low)
-          else
-            high = Node.new(pure_hash, current_node.key, current_node.value, high)
-          end
-          current_node = current_node.next
-        end
-        new_table.volatile_set(i, low)
-        new_table.volatile_set(i + bit, high)
-      end
-
-      def increment_size
-        @counter.increment
-      end
-
-      def decrement_size(by = 1)
-        @counter.add(-by)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/map/synchronized_map_backend.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/map/synchronized_map_backend.rb
deleted file mode 100644
index 190c8d98d906c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/map/synchronized_map_backend.rb
+++ /dev/null
@@ -1,82 +0,0 @@
-require 'concurrent/collection/map/non_concurrent_map_backend'
-
-module Concurrent
-
-  # @!visibility private
-  module Collection
-
-    # @!visibility private
-    class SynchronizedMapBackend < NonConcurrentMapBackend
-
-      require 'mutex_m'
-      include Mutex_m
-      # WARNING: Mutex_m is a non-reentrant lock, so the synchronized methods are
-      # not allowed to call each other.
-
-      def [](key)
-        synchronize { super }
-      end
-
-      def []=(key, value)
-        synchronize { super }
-      end
-
-      def compute_if_absent(key)
-        synchronize { super }
-      end
-
-      def compute_if_present(key)
-        synchronize { super }
-      end
-
-      def compute(key)
-        synchronize { super }
-      end
-
-      def merge_pair(key, value)
-        synchronize { super }
-      end
-
-      def replace_pair(key, old_value, new_value)
-        synchronize { super }
-      end
-
-      def replace_if_exists(key, new_value)
-        synchronize { super }
-      end
-
-      def get_and_set(key, value)
-        synchronize { super }
-      end
-
-      def key?(key)
-        synchronize { super }
-      end
-
-      def delete(key)
-        synchronize { super }
-      end
-
-      def delete_pair(key, value)
-        synchronize { super }
-      end
-
-      def clear
-        synchronize { super }
-      end
-
-      def size
-        synchronize { super }
-      end
-
-      def get_or_default(key, default_value)
-        synchronize { super }
-      end
-
-      private
-      def dupped_backend
-        synchronize { super }
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/concern/logging.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/concern/logging.rb
deleted file mode 100644
index 2c749996f94f3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/concern/logging.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-require 'logger'
-
-module Concurrent
-  module Concern
-
-    # Include where logging is needed
-    #
-    # @!visibility private
-    module Logging
-      include Logger::Severity
-
-      # Logs through {Concurrent.global_logger}, it can be overridden by setting @logger
-      # @param [Integer] level one of Logger::Severity constants
-      # @param [String] progname e.g. a path of an Actor
-      # @param [String, nil] message when nil block is used to generate the message
-      # @yieldreturn [String] a message
-      def log(level, progname, message = nil, &block)
-        #NOTE: Cannot require 'concurrent/configuration' above due to circular references.
-        #      Assume that the gem has been initialized if we've gotten this far.
-        logger = if defined?(@logger) && @logger
-                   @logger
-                 else
-                   Concurrent.global_logger
-                 end
-        logger.call level, progname, message, &block
-      rescue => error
-        $stderr.puts "`Concurrent.configuration.logger` failed to log #{[level, progname, message, block]}\n" +
-          "#{error.message} (#{error.class})\n#{error.backtrace.join "\n"}"
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/concurrent_ruby.jar b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/concurrent_ruby.jar
deleted file mode 100644
index e0d30ecb0f9da..0000000000000
Binary files a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/concurrent_ruby.jar and /dev/null differ
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/configuration.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/configuration.rb
deleted file mode 100644
index a00dc84403ff5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/configuration.rb
+++ /dev/null
@@ -1,188 +0,0 @@
-require 'thread'
-require 'concurrent/delay'
-require 'concurrent/errors'
-require 'concurrent/atomic/atomic_reference'
-require 'concurrent/concern/logging'
-require 'concurrent/concern/deprecation'
-require 'concurrent/executor/immediate_executor'
-require 'concurrent/executor/cached_thread_pool'
-require 'concurrent/utility/processor_counter'
-
-module Concurrent
-  extend Concern::Logging
-  extend Concern::Deprecation
-
-  autoload :Options, 'concurrent/options'
-  autoload :TimerSet, 'concurrent/executor/timer_set'
-  autoload :ThreadPoolExecutor, 'concurrent/executor/thread_pool_executor'
-
-  # @return [Logger] Logger with provided level and output.
-  def self.create_simple_logger(level = Logger::FATAL, output = $stderr)
-    # TODO (pitr-ch 24-Dec-2016): figure out why it had to be replaced, stdlogger was deadlocking
-    lambda do |severity, progname, message = nil, &block|
-      return false if severity < level
-
-      message           = block ? block.call : message
-      formatted_message = case message
-                          when String
-                            message
-                          when Exception
-                            format "%s (%s)\n%s",
-                                   message.message, message.class, (message.backtrace || []).join("\n")
-                          else
-                            message.inspect
-                          end
-
-      output.print format "[%s] %5s -- %s: %s\n",
-                          Time.now.strftime('%Y-%m-%d %H:%M:%S.%L'),
-                          Logger::SEV_LABEL[severity],
-                          progname,
-                          formatted_message
-      true
-    end
-  end
-
-  # Use logger created by #create_simple_logger to log concurrent-ruby messages.
-  def self.use_simple_logger(level = Logger::FATAL, output = $stderr)
-    Concurrent.global_logger = create_simple_logger level, output
-  end
-
-  # @return [Logger] Logger with provided level and output.
-  # @deprecated
-  def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
-    logger           = Logger.new(output)
-    logger.level     = level
-    logger.formatter = lambda do |severity, datetime, progname, msg|
-      formatted_message = case msg
-                          when String
-                            msg
-                          when Exception
-                            format "%s (%s)\n%s",
-                                   msg.message, msg.class, (msg.backtrace || []).join("\n")
-                          else
-                            msg.inspect
-                          end
-      format "[%s] %5s -- %s: %s\n",
-             datetime.strftime('%Y-%m-%d %H:%M:%S.%L'),
-             severity,
-             progname,
-             formatted_message
-    end
-
-    lambda do |loglevel, progname, message = nil, &block|
-      logger.add loglevel, message, progname, &block
-    end
-  end
-
-  # Use logger created by #create_stdlib_logger to log concurrent-ruby messages.
-  # @deprecated
-  def self.use_stdlib_logger(level = Logger::FATAL, output = $stderr)
-    Concurrent.global_logger = create_stdlib_logger level, output
-  end
-
-  # TODO (pitr-ch 27-Dec-2016): remove deadlocking stdlib_logger methods
-
-  # Suppresses all output when used for logging.
-  NULL_LOGGER   = lambda { |level, progname, message = nil, &block| }
-
-  # @!visibility private
-  GLOBAL_LOGGER = AtomicReference.new(create_simple_logger(Logger::WARN))
-  private_constant :GLOBAL_LOGGER
-
-  def self.global_logger
-    GLOBAL_LOGGER.value
-  end
-
-  def self.global_logger=(value)
-    GLOBAL_LOGGER.value = value
-  end
-
-  # @!visibility private
-  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor }
-  private_constant :GLOBAL_FAST_EXECUTOR
-
-  # @!visibility private
-  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor }
-  private_constant :GLOBAL_IO_EXECUTOR
-
-  # @!visibility private
-  GLOBAL_TIMER_SET = Delay.new { TimerSet.new }
-  private_constant :GLOBAL_TIMER_SET
-
-  # @!visibility private
-  GLOBAL_IMMEDIATE_EXECUTOR = ImmediateExecutor.new
-  private_constant :GLOBAL_IMMEDIATE_EXECUTOR
-
-  # Disables AtExit handlers including pool auto-termination handlers.
-  # When disabled it will be the application programmer's responsibility
-  # to ensure that the handlers are shutdown properly prior to application
-  # exit by calling `AtExit.run` method.
-  #
-  # @note this option should be needed only because of `at_exit` ordering
-  #   issues which may arise when running some of the testing frameworks.
-  #   E.g. Minitest's test-suite runs itself in `at_exit` callback which
-  #   executes after the pools are already terminated. Then auto termination
-  #   needs to be disabled and called manually after test-suite ends.
-  # @note This method should *never* be called
-  #   from within a gem. It should *only* be used from within the main
-  #   application and even then it should be used only when necessary.
-  # @deprecated Has no effect since it is no longer needed, see https://github.com/ruby-concurrency/concurrent-ruby/pull/841.
-  #
-  def self.disable_at_exit_handlers!
-    deprecated "Method #disable_at_exit_handlers! has no effect since it is no longer needed, see https://github.com/ruby-concurrency/concurrent-ruby/pull/841."
-  end
-
-  # Global thread pool optimized for short, fast *operations*.
-  #
-  # @return [ThreadPoolExecutor] the thread pool
-  def self.global_fast_executor
-    GLOBAL_FAST_EXECUTOR.value
-  end
-
-  # Global thread pool optimized for long, blocking (IO) *tasks*.
-  #
-  # @return [ThreadPoolExecutor] the thread pool
-  def self.global_io_executor
-    GLOBAL_IO_EXECUTOR.value
-  end
-
-  def self.global_immediate_executor
-    GLOBAL_IMMEDIATE_EXECUTOR
-  end
-
-  # Global thread pool user for global *timers*.
-  #
-  # @return [Concurrent::TimerSet] the thread pool
-  def self.global_timer_set
-    GLOBAL_TIMER_SET.value
-  end
-
-  # General access point to global executors.
-  # @param [Symbol, Executor] executor_identifier symbols:
-  #   - :fast - {Concurrent.global_fast_executor}
-  #   - :io - {Concurrent.global_io_executor}
-  #   - :immediate - {Concurrent.global_immediate_executor}
-  # @return [Executor]
-  def self.executor(executor_identifier)
-    Options.executor(executor_identifier)
-  end
-
-  def self.new_fast_executor(opts = {})
-    FixedThreadPool.new(
-        [2, Concurrent.processor_count].max,
-        auto_terminate:  opts.fetch(:auto_terminate, true),
-        idletime:        60, # 1 minute
-        max_queue:       0, # unlimited
-        fallback_policy: :abort, # shouldn't matter -- 0 max queue
-        name:            "fast"
-    )
-  end
-
-  def self.new_io_executor(opts = {})
-    CachedThreadPool.new(
-        auto_terminate:  opts.fetch(:auto_terminate, true),
-        fallback_policy: :abort, # shouldn't matter -- 0 max queue
-        name:            "io"
-    )
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/errors.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/errors.rb
deleted file mode 100644
index b69fec01f203d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/errors.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-module Concurrent
-
-  Error = Class.new(StandardError)
-
-  # Raised when errors occur during configuration.
-  ConfigurationError = Class.new(Error)
-
-  # Raised when an asynchronous operation is cancelled before execution.
-  CancelledOperationError = Class.new(Error)
-
-  # Raised when a lifecycle method (such as `stop`) is called in an improper
-  # sequence or when the object is in an inappropriate state.
-  LifecycleError = Class.new(Error)
-
-  # Raised when an attempt is made to violate an immutability guarantee.
-  ImmutabilityError = Class.new(Error)
-
-  # Raised when an operation is attempted which is not legal given the
-  # receiver's current state
-  IllegalOperationError = Class.new(Error)
-
-  # Raised when an object's methods are called when it has not been
-  # properly initialized.
-  InitializationError = Class.new(Error)
-
-  # Raised when an object with a start/stop lifecycle has been started an
-  # excessive number of times. Often used in conjunction with a restart
-  # policy or strategy.
-  MaxRestartFrequencyError = Class.new(Error)
-
-  # Raised when an attempt is made to modify an immutable object
-  # (such as an `IVar`) after its final state has been set.
-  class MultipleAssignmentError < Error
-    attr_reader :inspection_data
-
-    def initialize(message = nil, inspection_data = nil)
-      @inspection_data = inspection_data
-      super message
-    end
-
-    def inspect
-      format '%s %s>', super[0..-2], @inspection_data.inspect
-    end
-  end
-
-  # Raised by an `Executor` when it is unable to process a given task,
-  # possibly because of a reject policy or other internal error.
-  RejectedExecutionError = Class.new(Error)
-
-  # Raised when any finite resource, such as a lock counter, exceeds its
-  # maximum limit/threshold.
-  ResourceLimitError = Class.new(Error)
-
-  # Raised when an operation times out.
-  TimeoutError = Class.new(Error)
-
-  # Aggregates multiple exceptions.
-  class MultipleErrors < Error
-    attr_reader :errors
-
-    def initialize(errors, message = "#{errors.size} errors")
-      @errors = errors
-      super [*message,
-             *errors.map { |e| [format('%s (%s)', e.message, e.class), *e.backtrace] }.flatten(1)
-            ].join("\n")
-    end
-  end
-
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/hash.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/hash.rb
deleted file mode 100644
index 92df66b790bbc..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/hash.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-require 'concurrent/utility/engine'
-require 'concurrent/thread_safe/util'
-
-module Concurrent
-
-  # @!macro concurrent_hash
-  #
-  #   A thread-safe subclass of Hash. This version locks against the object
-  #   itself for every method call, ensuring only one thread can be reading
-  #   or writing at a time. This includes iteration methods like `#each`,
-  #   which takes the lock repeatedly when reading an item.
-  #
-  #   @see http://ruby-doc.org/core/Hash.html Ruby standard library `Hash`
-
-  # @!macro internal_implementation_note
-  HashImplementation = case
-                       when Concurrent.on_cruby?
-                         # Hash is thread-safe in practice because CRuby runs
-                         # threads one at a time and does not do context
-                         # switching during the execution of C functions.
-                         ::Hash
-
-                       when Concurrent.on_jruby?
-                         require 'jruby/synchronized'
-
-                         class JRubyHash < ::Hash
-                           include JRuby::Synchronized
-                         end
-                         JRubyHash
-
-                       when Concurrent.on_rbx?
-                         require 'monitor'
-                         require 'concurrent/thread_safe/util/data_structures'
-
-                         class RbxHash < ::Hash
-                         end
-                         ThreadSafe::Util.make_synchronized_on_rbx RbxHash
-                         RbxHash
-
-                       when Concurrent.on_truffleruby?
-                         require 'concurrent/thread_safe/util/data_structures'
-
-                         class TruffleRubyHash < ::Hash
-                         end
-
-                         ThreadSafe::Util.make_synchronized_on_truffleruby TruffleRubyHash
-                         TruffleRubyHash
-
-                       else
-                         warn 'Possibly unsupported Ruby implementation'
-                         ::Hash
-                       end
-  private_constant :HashImplementation
-
-  # @!macro concurrent_hash
-  class Hash < HashImplementation
-  end
-
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization.rb
deleted file mode 100644
index 49c68ebbb3f24..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-require 'concurrent/utility/engine'
-
-require 'concurrent/synchronization/abstract_object'
-require 'concurrent/utility/native_extension_loader' # load native parts first
-Concurrent.load_native_extensions
-
-require 'concurrent/synchronization/mri_object'
-require 'concurrent/synchronization/jruby_object'
-require 'concurrent/synchronization/rbx_object'
-require 'concurrent/synchronization/truffleruby_object'
-require 'concurrent/synchronization/object'
-require 'concurrent/synchronization/volatile'
-
-require 'concurrent/synchronization/abstract_lockable_object'
-require 'concurrent/synchronization/mutex_lockable_object'
-require 'concurrent/synchronization/jruby_lockable_object'
-require 'concurrent/synchronization/rbx_lockable_object'
-
-require 'concurrent/synchronization/lockable_object'
-
-require 'concurrent/synchronization/condition'
-require 'concurrent/synchronization/lock'
-
-module Concurrent
-  # {include:file:docs-source/synchronization.md}
-  # {include:file:docs-source/synchronization-notes.md}
-  module Synchronization
-  end
-end
-
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/jruby_lockable_object.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/jruby_lockable_object.rb
deleted file mode 100644
index 359a032b7b9c4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/jruby_lockable_object.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    if Concurrent.on_jruby? && Concurrent.java_extensions_loaded?
-
-      # @!visibility private
-      # @!macro internal_implementation_note
-      class JRubyLockableObject < AbstractLockableObject
-
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/jruby_object.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/jruby_object.rb
deleted file mode 100644
index da91ac50b8f1f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/jruby_object.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    if Concurrent.on_jruby? && Concurrent.java_extensions_loaded?
-
-      # @!visibility private
-      module JRubyAttrVolatile
-        def self.included(base)
-          base.extend(ClassMethods)
-        end
-
-        module ClassMethods
-          def attr_volatile(*names)
-            names.each do |name|
-
-              ivar = :"@volatile_#{name}"
-
-              class_eval <<-RUBY, __FILE__, __LINE__ + 1
-                def #{name}
-                  instance_variable_get_volatile(:#{ivar})
-                end
-
-                def #{name}=(value)
-                  instance_variable_set_volatile(:#{ivar}, value)
-                end
-              RUBY
-
-            end
-            names.map { |n| [n, :"#{n}="] }.flatten
-          end
-        end
-      end
-
-      # @!visibility private
-      # @!macro internal_implementation_note
-      class JRubyObject < AbstractObject
-        include JRubyAttrVolatile
-
-        def initialize
-          # nothing to do
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/lock.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/lock.rb
deleted file mode 100644
index 0dbad2eb45237..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/lock.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # @!visibility private
-    # TODO (pitr-ch 04-Dec-2016): should be in edge
-    class Lock < LockableObject
-      # TODO use JavaReentrantLock on JRuby
-
-      public :synchronize
-
-      def wait(timeout = nil)
-        synchronize { ns_wait(timeout) }
-      end
-
-      public :ns_wait
-
-      def wait_until(timeout = nil, &condition)
-        synchronize { ns_wait_until(timeout, &condition) }
-      end
-
-      public :ns_wait_until
-
-      def signal
-        synchronize { ns_signal }
-      end
-
-      public :ns_signal
-
-      def broadcast
-        synchronize { ns_broadcast }
-      end
-
-      public :ns_broadcast
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/mri_object.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/mri_object.rb
deleted file mode 100644
index 4b1d6c295649e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/mri_object.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # @!visibility private
-    module MriAttrVolatile
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def attr_volatile(*names)
-          names.each do |name|
-            ivar = :"@volatile_#{name}"
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{name}
-                #{ivar}
-              end
-
-              def #{name}=(value)
-                #{ivar} = value
-              end
-            RUBY
-          end
-          names.map { |n| [n, :"#{n}="] }.flatten
-        end
-      end
-
-      def full_memory_barrier
-        # relying on undocumented behavior of CRuby, GVL acquire has lock which ensures visibility of ivars
-        # https://github.com/ruby/ruby/blob/ruby_2_2/thread_pthread.c#L204-L211
-      end
-    end
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class MriObject < AbstractObject
-      include MriAttrVolatile
-
-      def initialize
-        # nothing to do
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/object.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/object.rb
deleted file mode 100644
index 0e621128075fc..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/object.rb
+++ /dev/null
@@ -1,183 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    ObjectImplementation = case
-                           when Concurrent.on_cruby?
-                             MriObject
-                           when Concurrent.on_jruby?
-                             JRubyObject
-                           when Concurrent.on_rbx?
-                             RbxObject
-                           when Concurrent.on_truffleruby?
-                             TruffleRubyObject
-                           else
-                             warn 'Possibly unsupported Ruby implementation'
-                             MriObject
-                           end
-    private_constant :ObjectImplementation
-
-    # Abstract object providing final, volatile, ans CAS extensions to build other concurrent abstractions.
-    # - final instance variables see {Object.safe_initialization!}
-    # - volatile instance variables see {Object.attr_volatile}
-    # - volatile instance variables see {Object.attr_atomic}
-    class Object < ObjectImplementation
-      # TODO make it a module if possible
-
-      # @!method self.attr_volatile(*names)
-      #   Creates methods for reading and writing (as `attr_accessor` does) to a instance variable with
-      #   volatile (Java) semantic. The instance variable should be accessed only through generated methods.
-      #
-      #   @param [::Array<Symbol>] names of the instance variables to be volatile
-      #   @return [::Array<Symbol>] names of defined method names
-
-      # Has to be called by children.
-      def initialize
-        super
-        __initialize_atomic_fields__
-      end
-
-      # By calling this method on a class, it and all its children are marked to be constructed safely. Meaning that
-      # all writes (ivar initializations) are made visible to all readers of newly constructed object. It ensures
-      # same behaviour as Java's final fields.
-      # @example
-      #   class AClass < Concurrent::Synchronization::Object
-      #     safe_initialization!
-      #
-      #     def initialize
-      #       @AFinalValue = 'value' # published safely, does not have to be synchronized
-      #     end
-      #   end
-      # @return [true]
-      def self.safe_initialization!
-        # define only once, and not again in children
-        return if safe_initialization?
-
-        # @!visibility private
-        def self.new(*args, &block)
-          object = super(*args, &block)
-        ensure
-          object.full_memory_barrier if object
-        end
-
-        @safe_initialization = true
-      end
-
-      # @return [true, false] if this class is safely initialized.
-      def self.safe_initialization?
-        @safe_initialization = false unless defined? @safe_initialization
-        @safe_initialization || (superclass.respond_to?(:safe_initialization?) && superclass.safe_initialization?)
-      end
-
-      # For testing purposes, quite slow. Injects assert code to new method which will raise if class instance contains
-      # any instance variables with CamelCase names and isn't {.safe_initialization?}.
-      # @raise when offend found
-      # @return [true]
-      def self.ensure_safe_initialization_when_final_fields_are_present
-        Object.class_eval do
-          def self.new(*args, &block)
-            object = super(*args, &block)
-          ensure
-            has_final_field = object.instance_variables.any? { |v| v.to_s =~ /^@[A-Z]/ }
-            if has_final_field && !safe_initialization?
-              raise "there was an instance of #{object.class} with final field but not marked with safe_initialization!"
-            end
-          end
-        end
-        true
-      end
-
-      # Creates methods for reading and writing to a instance variable with
-      # volatile (Java) semantic as {.attr_volatile} does.
-      # The instance variable should be accessed oly through generated methods.
-      # This method generates following methods: `value`, `value=(new_value) #=> new_value`,
-      # `swap_value(new_value) #=> old_value`,
-      # `compare_and_set_value(expected, value) #=> true || false`, `update_value(&block)`.
-      # @param [::Array<Symbol>] names of the instance variables to be volatile with CAS.
-      # @return [::Array<Symbol>] names of defined method names.
-      # @!macro attr_atomic
-      #   @!method $1
-      #     @return [Object] The $1.
-      #   @!method $1=(new_$1)
-      #     Set the $1.
-      #     @return [Object] new_$1.
-      #   @!method swap_$1(new_$1)
-      #     Set the $1 to new_$1 and return the old $1.
-      #     @return [Object] old $1
-      #   @!method compare_and_set_$1(expected_$1, new_$1)
-      #     Sets the $1 to new_$1 if the current $1 is expected_$1
-      #     @return [true, false]
-      #   @!method update_$1(&block)
-      #     Updates the $1 using the block.
-      #     @yield [Object] Calculate a new $1 using given (old) $1
-      #     @yieldparam [Object] old $1
-      #     @return [Object] new $1
-      def self.attr_atomic(*names)
-        @__atomic_fields__ ||= []
-        @__atomic_fields__ += names
-        safe_initialization!
-        define_initialize_atomic_fields
-
-        names.each do |name|
-          ivar = :"@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }}"
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{name}
-              #{ivar}.get
-            end
-
-            def #{name}=(value)
-              #{ivar}.set value
-            end
-
-            def swap_#{name}(value)
-              #{ivar}.swap value
-            end
-
-            def compare_and_set_#{name}(expected, value)
-              #{ivar}.compare_and_set expected, value
-            end
-
-            def update_#{name}(&block)
-              #{ivar}.update(&block)
-            end
-          RUBY
-        end
-        names.flat_map { |n| [n, :"#{n}=", :"swap_#{n}", :"compare_and_set_#{n}", :"update_#{n}"] }
-      end
-
-      # @param [true, false] inherited should inherited volatile with CAS fields be returned?
-      # @return [::Array<Symbol>] Returns defined volatile with CAS fields on this class.
-      def self.atomic_attributes(inherited = true)
-        @__atomic_fields__ ||= []
-        ((superclass.atomic_attributes if superclass.respond_to?(:atomic_attributes) && inherited) || []) + @__atomic_fields__
-      end
-
-      # @return [true, false] is the attribute with name atomic?
-      def self.atomic_attribute?(name)
-        atomic_attributes.include? name
-      end
-
-      private
-
-      def self.define_initialize_atomic_fields
-        assignments = @__atomic_fields__.map do |name|
-          "@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }} = Concurrent::AtomicReference.new(nil)"
-        end.join("\n")
-
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def __initialize_atomic_fields__
-            super
-            #{assignments}
-          end
-        RUBY
-      end
-
-      private_class_method :define_initialize_atomic_fields
-
-      def __initialize_atomic_fields__
-      end
-
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/rbx_lockable_object.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/rbx_lockable_object.rb
deleted file mode 100644
index 1c4697c39712b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/rbx_lockable_object.rb
+++ /dev/null
@@ -1,71 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class RbxLockableObject < AbstractLockableObject
-      safe_initialization!
-
-      def initialize(*defaults)
-        super(*defaults)
-        @__Waiters__ = []
-        @__owner__   = nil
-      end
-
-      def initialize_copy(other)
-        super
-        @__Waiters__ = []
-        @__owner__   = nil
-      end
-
-      protected
-
-      def synchronize(&block)
-        if @__owner__ == Thread.current
-          yield
-        else
-          result = nil
-          Rubinius.synchronize(self) do
-            begin
-              @__owner__ = Thread.current
-              result     = yield
-            ensure
-              @__owner__ = nil
-            end
-          end
-          result
-        end
-      end
-
-      def ns_wait(timeout = nil)
-        wchan = Rubinius::Channel.new
-
-        begin
-          @__Waiters__.push wchan
-          Rubinius.unlock(self)
-          signaled = wchan.receive_timeout timeout
-        ensure
-          Rubinius.lock(self)
-
-          if !signaled && !@__Waiters__.delete(wchan)
-            # we timed out, but got signaled afterwards,
-            # so pass that signal on to the next waiter
-            @__Waiters__.shift << true unless @__Waiters__.empty?
-          end
-        end
-
-        self
-      end
-
-      def ns_signal
-        @__Waiters__.shift << true unless @__Waiters__.empty?
-        self
-      end
-
-      def ns_broadcast
-        @__Waiters__.shift << true until @__Waiters__.empty?
-        self
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/rbx_object.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/rbx_object.rb
deleted file mode 100644
index 4b23f2a662f2a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/rbx_object.rb
+++ /dev/null
@@ -1,49 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # @!visibility private
-    module RbxAttrVolatile
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-
-        def attr_volatile(*names)
-          names.each do |name|
-            ivar = :"@volatile_#{name}"
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{name}
-                Rubinius.memory_barrier
-                #{ivar}
-              end
-
-              def #{name}=(value)
-                #{ivar} = value
-                Rubinius.memory_barrier
-              end
-            RUBY
-          end
-          names.map { |n| [n, :"#{n}="] }.flatten
-        end
-
-      end
-
-      def full_memory_barrier
-        # Rubinius instance variables are not volatile so we need to insert barrier
-        # TODO (pitr 26-Nov-2015): check comments like ^
-        Rubinius.memory_barrier
-      end
-    end
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class RbxObject < AbstractObject
-      include RbxAttrVolatile
-
-      def initialize
-        # nothing to do
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/truffleruby_object.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/truffleruby_object.rb
deleted file mode 100644
index 3919c76d21c8a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/truffleruby_object.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # @!visibility private
-    module TruffleRubyAttrVolatile
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def attr_volatile(*names)
-          names.each do |name|
-            ivar = :"@volatile_#{name}"
-
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{name}
-                full_memory_barrier
-                #{ivar}                  
-              end
-
-              def #{name}=(value)
-                #{ivar} = value
-                full_memory_barrier
-              end
-            RUBY
-          end
-
-          names.map { |n| [n, :"#{n}="] }.flatten
-        end
-      end
-
-      def full_memory_barrier
-        TruffleRuby.full_memory_barrier
-      end
-    end
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class TruffleRubyObject < AbstractObject
-      include TruffleRubyAttrVolatile
-
-      def initialize
-        # nothing to do
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/volatile.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/volatile.rb
deleted file mode 100644
index 9dffa914ae692..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/volatile.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-module Concurrent
-  module Synchronization
-
-    # Volatile adds the attr_volatile class method when included.
-    #
-    # @example
-    #   class Foo
-    #     include Concurrent::Synchronization::Volatile
-    #
-    #     attr_volatile :bar
-    #
-    #     def initialize
-    #       self.bar = 1
-    #     end
-    #   end
-    #
-    #  foo = Foo.new
-    #  foo.bar
-    #  => 1
-    #  foo.bar = 2
-    #  => 2
-
-    Volatile = case
-               when Concurrent.on_cruby?
-                 MriAttrVolatile
-               when Concurrent.on_jruby?
-                 JRubyAttrVolatile
-               when Concurrent.on_rbx?
-                 RbxAttrVolatile
-               when Concurrent.on_truffleruby?
-                 TruffleRubyAttrVolatile
-               else
-                 MriAttrVolatile
-               end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb
deleted file mode 100644
index 92e7c45fc50ca..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb
+++ /dev/null
@@ -1,50 +0,0 @@
-require 'delegate'
-require 'monitor'
-
-module Concurrent
-  unless defined?(SynchronizedDelegator)
-
-    # This class provides a trivial way to synchronize all calls to a given object
-    # by wrapping it with a `Delegator` that performs `Monitor#enter/exit` calls
-    # around the delegated `#send`. Example:
-    #
-    #   array = [] # not thread-safe on many impls
-    #   array = SynchronizedDelegator.new([]) # thread-safe
-    #
-    # A simple `Monitor` provides a very coarse-grained way to synchronize a given
-    # object, in that it will cause synchronization for methods that have no need
-    # for it, but this is a trivial way to get thread-safety where none may exist
-    # currently on some implementations.
-    #
-    # This class is currently being considered for inclusion into stdlib, via
-    # https://bugs.ruby-lang.org/issues/8556
-    #
-    # @!visibility private
-    class SynchronizedDelegator < SimpleDelegator
-      def setup
-        @old_abort = Thread.abort_on_exception
-        Thread.abort_on_exception = true
-      end
-
-      def teardown
-        Thread.abort_on_exception = @old_abort
-      end
-
-      def initialize(obj)
-        __setobj__(obj)
-        @monitor = Monitor.new
-      end
-
-      def method_missing(method, *args, &block)
-        monitor = @monitor
-        begin
-          monitor.enter
-          super
-        ensure
-          monitor.exit
-        end
-      end
-
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/cheap_lockable.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/cheap_lockable.rb
deleted file mode 100644
index d9b4c58186943..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/cheap_lockable.rb
+++ /dev/null
@@ -1,118 +0,0 @@
-require 'concurrent/thread_safe/util'
-require 'concurrent/thread_safe/util/volatile'
-
-module Concurrent
-
-  # @!visibility private
-  module ThreadSafe
-
-    # @!visibility private
-    module Util
-
-      # Provides a cheapest possible (mainly in terms of memory usage) +Mutex+
-      # with the +ConditionVariable+ bundled in.
-      #
-      # Usage:
-      #   class A
-      #     include CheapLockable
-      #
-      #     def do_exlusively
-      #       cheap_synchronize { yield }
-      #     end
-      #
-      #     def wait_for_something
-      #       cheap_synchronize do
-      #         cheap_wait until resource_available?
-      #         do_something
-      #         cheap_broadcast # wake up others
-      #       end
-      #     end
-      #   end
-      # 
-      # @!visibility private
-      module CheapLockable
-        private
-        engine = defined?(RUBY_ENGINE) && RUBY_ENGINE
-        if engine == 'rbx'
-          # Making use of the Rubinius' ability to lock via object headers to avoid the overhead of the extra Mutex objects.
-          def cheap_synchronize
-            Rubinius.lock(self)
-            begin
-              yield
-            ensure
-              Rubinius.unlock(self)
-            end
-          end
-
-          def cheap_wait
-            wchan = Rubinius::Channel.new
-
-            begin
-              waiters = @waiters ||= []
-              waiters.push wchan
-              Rubinius.unlock(self)
-              signaled = wchan.receive_timeout nil
-            ensure
-              Rubinius.lock(self)
-
-              unless signaled or waiters.delete(wchan)
-                # we timed out, but got signaled afterwards (e.g. while waiting to
-                # acquire @lock), so pass that signal on to the next waiter
-                waiters.shift << true unless waiters.empty?
-              end
-            end
-
-            self
-          end
-
-          def cheap_broadcast
-            waiters = @waiters ||= []
-            waiters.shift << true until waiters.empty?
-            self
-          end
-        elsif engine == 'jruby'
-          # Use Java's native synchronized (this) { wait(); notifyAll(); } to avoid the overhead of the extra Mutex objects
-          require 'jruby'
-
-          def cheap_synchronize
-            JRuby.reference0(self).synchronized { yield }
-          end
-
-          def cheap_wait
-            JRuby.reference0(self).wait
-          end
-
-          def cheap_broadcast
-            JRuby.reference0(self).notify_all
-          end
-        else
-          require 'thread'
-
-          extend Volatile
-          attr_volatile :mutex
-
-          # Non-reentrant Mutex#syncrhonize
-          def cheap_synchronize
-            true until (my_mutex = mutex) || cas_mutex(nil, my_mutex = Mutex.new)
-            my_mutex.synchronize { yield }
-          end
-
-          # Releases this object's +cheap_synchronize+ lock and goes to sleep waiting for other threads to +cheap_broadcast+, reacquires the lock on wakeup.
-          # Must only be called in +cheap_broadcast+'s block.
-          def cheap_wait
-            conditional_variable = @conditional_variable ||= ConditionVariable.new
-            conditional_variable.wait(mutex)
-          end
-
-          # Wakes up all threads waiting for this object's +cheap_synchronize+ lock.
-          # Must only be called in +cheap_broadcast+'s block.
-          def cheap_broadcast
-            if conditional_variable = @conditional_variable
-              conditional_variable.broadcast
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb
deleted file mode 100644
index 24d039b2f24b0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb
+++ /dev/null
@@ -1,88 +0,0 @@
-require 'concurrent/thread_safe/util'
-
-# Shim for TruffleRuby.synchronized
-if Concurrent.on_truffleruby? && !TruffleRuby.respond_to?(:synchronized)
-  module TruffleRuby
-    def self.synchronized(object, &block)
-      Truffle::System.synchronized(object, &block)
-    end
-  end
-end
-
-module Concurrent
-  module ThreadSafe
-    module Util
-      def self.make_synchronized_on_cruby(klass)
-        klass.class_eval do
-          def initialize(*args, &block)
-            @_monitor = Monitor.new
-            super
-          end
-
-          def initialize_copy(other)
-            # make sure a copy is not sharing a monitor with the original object!
-            @_monitor = Monitor.new
-            super
-          end
-        end
-
-        klass.superclass.instance_methods(false).each do |method|
-          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method}(*args)
-              monitor = @_monitor
-              monitor or raise("BUG: Internal monitor was not properly initialized. Please report this to the concurrent-ruby developers.")
-              monitor.synchronize { super }
-            end
-          RUBY
-        end
-      end
-
-      def self.make_synchronized_on_rbx(klass)
-        klass.class_eval do
-          private
-
-          def _mon_initialize
-            @_monitor ||= Monitor.new # avoid double initialisation
-          end
-
-          def self.new(*args)
-            obj = super(*args)
-            obj.send(:_mon_initialize)
-            obj
-          end
-        end
-
-        klass.superclass.instance_methods(false).each do |method|
-          case method
-          when :new_range, :new_reserved
-            klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{method}(*args)
-                obj = super
-                obj.send(:_mon_initialize)
-                obj
-              end
-            RUBY
-          else
-            klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{method}(*args)
-                monitor = @_monitor
-                monitor or raise("BUG: Internal monitor was not properly initialized. Please report this to the concurrent-ruby developers.")
-                monitor.synchronize { super }
-              end
-            RUBY
-          end
-        end
-      end
-
-      def self.make_synchronized_on_truffleruby(klass)
-        klass.superclass.instance_methods(false).each do |method|
-          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method}(*args, &block)    
-              TruffleRuby.synchronized(self) { super(*args, &block) }
-            end
-          RUBY
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/engine.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/engine.rb
deleted file mode 100644
index bc4173e448c6f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/engine.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-module Concurrent
-  module Utility
-
-    # @!visibility private
-    module EngineDetector
-      def on_jruby?
-        ruby_engine == 'jruby'
-      end
-
-      def on_jruby_9000?
-        on_jruby? && ruby_version(JRUBY_VERSION, :>=, 9, 0, 0)
-      end
-
-      def on_cruby?
-        ruby_engine == 'ruby'
-      end
-
-      def on_rbx?
-        ruby_engine == 'rbx'
-      end
-
-      def on_truffleruby?
-        ruby_engine == 'truffleruby'
-      end
-
-      def on_windows?
-        !(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/).nil?
-      end
-
-      def on_osx?
-        !(RbConfig::CONFIG['host_os'] =~ /darwin|mac os/).nil?
-      end
-
-      def on_linux?
-        !(RbConfig::CONFIG['host_os'] =~ /linux/).nil?
-      end
-
-      def ruby_engine
-        defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
-      end
-
-      def ruby_version(version = RUBY_VERSION, comparison, major, minor, patch)
-        result      = (version.split('.').map(&:to_i) <=> [major, minor, patch])
-        comparisons = { :== => [0],
-                        :>= => [1, 0],
-                        :<= => [-1, 0],
-                        :>  => [1],
-                        :<  => [-1] }
-        comparisons.fetch(comparison).include? result
-      end
-    end
-  end
-
-  # @!visibility private
-  extend Utility::EngineDetector
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/monotonic_time.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/monotonic_time.rb
deleted file mode 100644
index 0fa5c5094ee35..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/monotonic_time.rb
+++ /dev/null
@@ -1,90 +0,0 @@
-require 'concurrent/synchronization'
-
-module Concurrent
-
-  # @!macro monotonic_get_time
-  #
-  #   Returns the current time a tracked by the application monotonic clock.
-  #
-  #   @param [Symbol] unit the time unit to be returned, can be either
-  #     :float_second, :float_millisecond, :float_microsecond, :second,
-  #     :millisecond, :microsecond, or :nanosecond default to :float_second.
-  #
-  #   @return [Float] The current monotonic time since some unspecified
-  #     starting point
-  #
-  #   @!macro monotonic_clock_warning
-  if defined?(Process::CLOCK_MONOTONIC)
-
-    def monotonic_time(unit = :float_second)
-      Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
-    end
-
-  elsif Concurrent.on_jruby?
-
-    # @!visibility private
-    TIME_UNITS = Hash.new { |_hash, key| raise ArgumentError, "unexpected unit: #{key}" }.compare_by_identity
-    TIME_UNITS.merge!(
-      second: 1_000_000_000,
-      millisecond: 1_000_000,
-      microsecond: 1_000,
-      nanosecond: 1,
-      float_second: 1_000_000_000.0,
-      float_millisecond: 1_000_000.0,
-      float_microsecond: 1_000.0,
-    )
-    TIME_UNITS.freeze
-    private_constant :TIME_UNITS
-
-    def monotonic_time(unit = :float_second)
-      java.lang.System.nanoTime() / TIME_UNITS[unit]
-    end
-
-  else
-
-    class_definition = Class.new(Synchronization::LockableObject) do
-      def initialize
-        @last_time = Time.now.to_f
-        @time_units = Hash.new { |_hash, key| raise ArgumentError, "unexpected unit: #{key}" }.compare_by_identity
-        @time_units.merge!(
-          second: [nil, true],
-          millisecond: [1_000, true],
-          microsecond: [1_000_000, true],
-          nanosecond: [1_000_000_000, true],
-          float_second: [nil, false],
-          float_millisecond: [1_000.0, false],
-          float_microsecond: [1_000_000.0, false],
-        )
-        super()
-      end
-
-      # @!visibility private
-      def get_time(unit)
-        synchronize do
-          now = Time.now.to_f
-          if @last_time < now
-            @last_time = now
-          else # clock has moved back in time
-            @last_time += 0.000_001
-          end
-          scale, to_int = @time_units[unit]
-          now *= scale if scale
-          now = now.to_i if to_int
-          now
-        end
-      end
-    end
-
-    # Clock that cannot be set and represents monotonic time since
-    # some unspecified starting point.
-    #
-    # @!visibility private
-    GLOBAL_MONOTONIC_CLOCK = class_definition.new
-    private_constant :GLOBAL_MONOTONIC_CLOCK
-    
-    def monotonic_time(unit = :float_second)
-      GLOBAL_MONOTONIC_CLOCK.get_time(unit)
-    end
-  end
-  module_function :monotonic_time
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/processor_counter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/processor_counter.rb
deleted file mode 100644
index c59f9817a5c63..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/processor_counter.rb
+++ /dev/null
@@ -1,130 +0,0 @@
-require 'etc'
-require 'rbconfig'
-require 'concurrent/delay'
-
-module Concurrent
-  module Utility
-
-    # @!visibility private
-    class ProcessorCounter
-      def initialize
-        @processor_count          = Delay.new { compute_processor_count }
-        @physical_processor_count = Delay.new { compute_physical_processor_count }
-      end
-
-      # Number of processors seen by the OS and used for process scheduling. For
-      # performance reasons the calculated value will be memoized on the first
-      # call.
-      #
-      # When running under JRuby the Java runtime call
-      # `java.lang.Runtime.getRuntime.availableProcessors` will be used. According
-      # to the Java documentation this "value may change during a particular
-      # invocation of the virtual machine... [applications] should therefore
-      # occasionally poll this property." Subsequently the result will NOT be
-      # memoized under JRuby.
-      #
-      # Ruby's Etc.nprocessors will be used if available (MRI 2.2+).
-      #
-      # On Windows the Win32 API will be queried for the
-      # `NumberOfLogicalProcessors from Win32_Processor`. This will return the
-      # total number "logical processors for the current instance of the
-      # processor", which taked into account hyperthreading.
-      #
-      # * AIX: /usr/sbin/pmcycles (AIX 5+), /usr/sbin/lsdev
-      # * Alpha: /usr/bin/nproc (/proc/cpuinfo exists but cannot be used)
-      # * BSD: /sbin/sysctl
-      # * Cygwin: /proc/cpuinfo
-      # * Darwin: /usr/bin/hwprefs, /usr/sbin/sysctl
-      # * HP-UX: /usr/sbin/ioscan
-      # * IRIX: /usr/sbin/sysconf
-      # * Linux: /proc/cpuinfo
-      # * Minix 3+: /proc/cpuinfo
-      # * Solaris: /usr/sbin/psrinfo
-      # * Tru64 UNIX: /usr/sbin/psrinfo
-      # * UnixWare: /usr/sbin/psrinfo
-      #
-      # @return [Integer] number of processors seen by the OS or Java runtime
-      #
-      # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
-      #
-      # @see http://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html#availableProcessors()
-      # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
-      def processor_count
-        @processor_count.value
-      end
-
-      # Number of physical processor cores on the current system. For performance
-      # reasons the calculated value will be memoized on the first call.
-      #
-      # On Windows the Win32 API will be queried for the `NumberOfCores from
-      # Win32_Processor`. This will return the total number "of cores for the
-      # current instance of the processor." On Unix-like operating systems either
-      # the `hwprefs` or `sysctl` utility will be called in a subshell and the
-      # returned value will be used. In the rare case where none of these methods
-      # work or an exception is raised the function will simply return 1.
-      #
-      # @return [Integer] number physical processor cores on the current system
-      #
-      # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
-      #
-      # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
-      # @see http://www.unix.com/man-page/osx/1/HWPREFS/
-      # @see http://linux.die.net/man/8/sysctl
-      def physical_processor_count
-        @physical_processor_count.value
-      end
-
-      private
-
-      def compute_processor_count
-        if Concurrent.on_jruby?
-          java.lang.Runtime.getRuntime.availableProcessors
-        else
-          Etc.nprocessors
-        end
-      end
-
-      def compute_physical_processor_count
-        ppc = case RbConfig::CONFIG["target_os"]
-              when /darwin\d\d/
-                IO.popen("/usr/sbin/sysctl -n hw.physicalcpu", &:read).to_i
-              when /linux/
-                cores = {} # unique physical ID / core ID combinations
-                phy   = 0
-                IO.read("/proc/cpuinfo").scan(/^physical id.*|^core id.*/) do |ln|
-                  if ln.start_with?("physical")
-                    phy = ln[/\d+/]
-                  elsif ln.start_with?("core")
-                    cid        = phy + ":" + ln[/\d+/]
-                    cores[cid] = true if not cores[cid]
-                  end
-                end
-                cores.count
-              when /mswin|mingw/
-                require 'win32ole'
-                result_set = WIN32OLE.connect("winmgmts://").ExecQuery(
-                  "select NumberOfCores from Win32_Processor")
-                result_set.to_enum.collect(&:NumberOfCores).reduce(:+)
-              else
-                processor_count
-              end
-        # fall back to logical count if physical info is invalid
-        ppc > 0 ? ppc : processor_count
-      rescue
-        return 1
-      end
-    end
-  end
-
-  # create the default ProcessorCounter on load
-  @processor_counter = Utility::ProcessorCounter.new
-  singleton_class.send :attr_reader, :processor_counter
-
-  def self.processor_count
-    processor_counter.processor_count
-  end
-
-  def self.physical_processor_count
-    processor_counter.physical_processor_count
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/version.rb
deleted file mode 100644
index 4372d0d7b3bc3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/version.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-module Concurrent
-  VERSION = '1.1.10'
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean.rb
deleted file mode 100644
index 2df238da06d66..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean.rb
+++ /dev/null
@@ -1,155 +0,0 @@
-require_relative "did_you_mean/version"
-require_relative "did_you_mean/core_ext/name_error"
-
-require_relative "did_you_mean/spell_checker"
-require_relative 'did_you_mean/spell_checkers/name_error_checkers'
-require_relative 'did_you_mean/spell_checkers/method_name_checker'
-require_relative 'did_you_mean/spell_checkers/key_error_checker'
-require_relative 'did_you_mean/spell_checkers/null_checker'
-require_relative 'did_you_mean/spell_checkers/require_path_checker'
-require_relative 'did_you_mean/spell_checkers/pattern_key_name_checker'
-require_relative 'did_you_mean/formatter'
-require_relative 'did_you_mean/tree_spell_checker'
-
-# The +DidYouMean+ gem adds functionality to suggest possible method/class
-# names upon errors such as +NameError+ and +NoMethodError+. In Ruby 2.3 or
-# later, it is automatically activated during startup.
-#
-# @example
-#
-#   methosd
-#   # => NameError: undefined local variable or method `methosd' for main:Object
-#   #   Did you mean?  methods
-#   #                  method
-#
-#   OBject
-#   # => NameError: uninitialized constant OBject
-#   #    Did you mean?  Object
-#
-#   @full_name = "Yuki Nishijima"
-#   first_name, last_name = full_name.split(" ")
-#   # => NameError: undefined local variable or method `full_name' for main:Object
-#   #    Did you mean?  @full_name
-#
-#   @@full_name = "Yuki Nishijima"
-#   @@full_anme
-#   # => NameError: uninitialized class variable @@full_anme in Object
-#   #    Did you mean?  @@full_name
-#
-#   full_name = "Yuki Nishijima"
-#   full_name.starts_with?("Y")
-#   # => NoMethodError: undefined method `starts_with?' for "Yuki Nishijima":String
-#   #    Did you mean?  start_with?
-#
-#   hash = {foo: 1, bar: 2, baz: 3}
-#   hash.fetch(:fooo)
-#   # => KeyError: key not found: :fooo
-#   #    Did you mean?  :foo
-#
-#
-# == Disabling +did_you_mean+
-#
-# Occasionally, you may want to disable the +did_you_mean+ gem for e.g.
-# debugging issues in the error object itself. You can disable it entirely by
-# specifying +--disable-did_you_mean+ option to the +ruby+ command:
-#
-#   $ ruby --disable-did_you_mean -e "1.zeor?"
-#   -e:1:in `<main>': undefined method `zeor?' for 1:Integer (NameError)
-#
-# When you do not have direct access to the +ruby+ command (e.g.
-# +rails console+, +irb+), you could applyoptions using the +RUBYOPT+
-# environment variable:
-#
-#   $ RUBYOPT='--disable-did_you_mean' irb
-#   irb:0> 1.zeor?
-#   # => NoMethodError (undefined method `zeor?' for 1:Integer)
-#
-#
-# == Getting the original error message
-#
-# Sometimes, you do not want to disable the gem entirely, but need to get the
-# original error message without suggestions (e.g. testing). In this case, you
-# could use the +#original_message+ method on the error object:
-#
-#   no_method_error = begin
-#                       1.zeor?
-#                     rescue NoMethodError => error
-#                       error
-#                     end
-#
-#   no_method_error.message
-#   # => NoMethodError (undefined method `zeor?' for 1:Integer)
-#   #    Did you mean?  zero?
-#
-#   no_method_error.original_message
-#   # => NoMethodError (undefined method `zeor?' for 1:Integer)
-#
-module DidYouMean
-  # Map of error types and spell checker objects.
-  @spell_checkers = Hash.new(NullChecker)
-
-  # Returns a sharable hash map of error types and spell checker objects.
-  def self.spell_checkers
-    @spell_checkers
-  end
-
-  # Adds +DidYouMean+ functionality to an error using a given spell checker
-  def self.correct_error(error_class, spell_checker)
-    if defined?(Ractor)
-      new_mapping = { **@spell_checkers, error_class.to_s => spell_checker }
-      new_mapping.default = NullChecker
-
-      @spell_checkers = Ractor.make_shareable(new_mapping)
-    else
-      spell_checkers[error_class.to_s] = spell_checker
-    end
-
-    error_class.prepend(Correctable) if error_class.is_a?(Class) && !(error_class < Correctable)
-  end
-
-  correct_error NameError, NameErrorCheckers
-  correct_error KeyError, KeyErrorChecker
-  correct_error NoMethodError, MethodNameChecker
-  correct_error LoadError, RequirePathChecker if RUBY_VERSION >= '2.8.0'
-  correct_error NoMatchingPatternKeyError, PatternKeyNameChecker if defined?(::NoMatchingPatternKeyError)
-
-  # TODO: Remove on 3.3:
-  class DeprecatedMapping # :nodoc:
-    def []=(key, value)
-      warn "Calling `DidYouMean::SPELL_CHECKERS[#{key.to_s}] = #{value.to_s}' has been deprecated. " \
-           "Please call `DidYouMean.correct_error(#{key.to_s}, #{value.to_s})' instead."
-
-      DidYouMean.correct_error(key, value)
-    end
-
-    def merge!(hash)
-      warn "Calling `DidYouMean::SPELL_CHECKERS.merge!(error_name => spell_checker)' has been deprecated. " \
-           "Please call `DidYouMean.correct_error(error_name, spell_checker)' instead."
-
-      hash.each do |error_class, spell_checker|
-        DidYouMean.correct_error(error_class, spell_checker)
-      end
-    end
-  end
-
-  # TODO: Remove on 3.3:
-  SPELL_CHECKERS = DeprecatedMapping.new
-  deprecate_constant :SPELL_CHECKERS
-  private_constant :DeprecatedMapping
-
-  # Returns the currently set formatter. By default, it is set to +DidYouMean::Formatter+.
-  def self.formatter
-    if defined?(Ractor)
-      Ractor.current[:__did_you_mean_formatter__] || Formatter
-    else
-      Formatter
-    end
-  end
-
-  # Updates the primary formatter used to format the suggestions.
-  def self.formatter=(formatter)
-    if defined?(Ractor)
-      Ractor.current[:__did_you_mean_formatter__] = formatter
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/core_ext/name_error.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/core_ext/name_error.rb
deleted file mode 100644
index eb3ef117a04c8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/core_ext/name_error.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-module DidYouMean
-  module Correctable
-    SKIP_TO_S_FOR_SUPER_LOOKUP = true
-    private_constant :SKIP_TO_S_FOR_SUPER_LOOKUP
-
-    def original_message
-      meth = method(:to_s)
-      while meth.owner.const_defined?(:SKIP_TO_S_FOR_SUPER_LOOKUP)
-        meth = meth.super_method
-      end
-      meth.call
-    end
-
-    def to_s
-      msg = super.dup
-      suggestion = DidYouMean.formatter.message_for(corrections)
-
-      msg << suggestion if !msg.include?(suggestion)
-      msg
-    rescue
-      super
-    end
-
-    def corrections
-      @corrections ||= spell_checker.corrections
-    end
-
-    def spell_checker
-      DidYouMean.spell_checkers[self.class.to_s].new(self)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/experimental.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/experimental.rb
deleted file mode 100644
index f8e37e4532ca8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/experimental.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-warn "Experimental features in the did_you_mean gem has been removed " \
-     "and `require \"did_you_mean/experimental\"' has no effect."
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/formatter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/formatter.rb
deleted file mode 100644
index c43748f707aff..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/formatter.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-# frozen-string-literal: true
-
-module DidYouMean
-  # The +DidYouMean::Formatter+ is the basic, default formatter for the
-  # gem. The formatter responds to the +message_for+ method and it returns a
-  # human readable string.
-  class Formatter
-
-    # Returns a human readable string that contains +corrections+. This
-    # formatter is designed to be less verbose to not take too much screen
-    # space while being helpful enough to the user.
-    #
-    # @example
-    #
-    #   formatter = DidYouMean::Formatter.new
-    #
-    #   # displays suggestions in two lines with the leading empty line
-    #   puts formatter.message_for(["methods", "method"])
-    #
-    #   Did you mean?  methods
-    #                   method
-    #   # => nil
-    #
-    #   # displays an empty line
-    #   puts formatter.message_for([])
-    #
-    #   # => nil
-    #
-    def self.message_for(corrections)
-      corrections.empty? ? "" : "\nDid you mean?  #{corrections.join("\n               ")}"
-    end
-
-    def message_for(corrections)
-      warn "The instance method #message_for has been deprecated. Please use the class method " \
-           "DidYouMean::Formatter.message_for(...) instead."
-
-      self.class.message_for(corrections)
-    end
-  end
-
-  PlainFormatter = Formatter
-
-  deprecate_constant :PlainFormatter
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/formatters/plain_formatter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/formatters/plain_formatter.rb
deleted file mode 100644
index d669588e0f3d4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/formatters/plain_formatter.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-require_relative '../formatter'
-
-warn "`require 'did_you_mean/formatters/plain_formatter'` is deprecated. Please `require 'did_you_mean/formatter'` " \
-     "instead."
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/formatters/verbose_formatter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/formatters/verbose_formatter.rb
deleted file mode 100644
index 8ee98fa070efb..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/formatters/verbose_formatter.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-warn "`require 'did_you_mean/formatters/verbose_formatter'` is deprecated and falls back to the default formatter. "
-
-require_relative '../formatter'
-
-# frozen-string-literal: true
-module DidYouMean
-  # For compatibility:
-  VerboseFormatter = Formatter
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/jaro_winkler.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/jaro_winkler.rb
deleted file mode 100644
index 56db130af4599..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/jaro_winkler.rb
+++ /dev/null
@@ -1,87 +0,0 @@
-module DidYouMean
-  module Jaro
-    module_function
-
-    def distance(str1, str2)
-      str1, str2 = str2, str1 if str1.length > str2.length
-      length1, length2 = str1.length, str2.length
-
-      m          = 0.0
-      t          = 0.0
-      range      = (length2 / 2).floor - 1
-      range      = 0 if range < 0
-      flags1     = 0
-      flags2     = 0
-
-      # Avoid duplicating enumerable objects
-      str1_codepoints = str1.codepoints
-      str2_codepoints = str2.codepoints
-
-      i = 0
-      while i < length1
-        last = i + range
-        j    = (i >= range) ? i - range : 0
-
-        while j <= last
-          if flags2[j] == 0 && str1_codepoints[i] == str2_codepoints[j]
-            flags2 |= (1 << j)
-            flags1 |= (1 << i)
-            m += 1
-            break
-          end
-
-          j += 1
-        end
-
-        i += 1
-      end
-
-      k = i = 0
-      while i < length1
-        if flags1[i] != 0
-          j = index = k
-
-          k = while j < length2
-            index = j
-            break(j + 1) if flags2[j] != 0
-
-            j += 1
-          end
-
-          t += 1 if str1_codepoints[i] != str2_codepoints[index]
-        end
-
-        i += 1
-      end
-      t = (t / 2).floor
-
-      m == 0 ? 0 : (m / length1 + m / length2 + (m - t) / m) / 3
-    end
-  end
-
-  module JaroWinkler
-    WEIGHT    = 0.1
-    THRESHOLD = 0.7
-
-    module_function
-
-    def distance(str1, str2)
-      jaro_distance = Jaro.distance(str1, str2)
-
-      if jaro_distance > THRESHOLD
-        codepoints2  = str2.codepoints
-        prefix_bonus = 0
-
-        i = 0
-        str1.each_codepoint do |char1|
-          char1 == codepoints2[i] && i < 4 ? prefix_bonus += 1 : break
-          i += 1
-        end
-
-        jaro_distance + (prefix_bonus * WEIGHT * (1 - jaro_distance))
-      else
-        jaro_distance
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/levenshtein.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/levenshtein.rb
deleted file mode 100644
index 098053470f4f2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/levenshtein.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-module DidYouMean
-  module Levenshtein # :nodoc:
-    # This code is based directly on the Text gem implementation
-    # Copyright (c) 2006-2013 Paul Battley, Michael Neumann, Tim Fletcher.
-    #
-    # Returns a value representing the "cost" of transforming str1 into str2
-    def distance(str1, str2)
-      n = str1.length
-      m = str2.length
-      return m if n.zero?
-      return n if m.zero?
-
-      d = (0..m).to_a
-      x = nil
-
-      # to avoid duplicating an enumerable object, create it outside of the loop
-      str2_codepoints = str2.codepoints
-
-      str1.each_codepoint.with_index(1) do |char1, i|
-        j = 0
-        while j < m
-          cost = (char1 == str2_codepoints[j]) ? 0 : 1
-          x = min3(
-            d[j+1] + 1, # insertion
-            i + 1,      # deletion
-            d[j] + cost # substitution
-          )
-          d[j] = i
-          i = x
-
-          j += 1
-        end
-        d[m] = x
-      end
-
-      x
-    end
-    module_function :distance
-
-    private
-
-    # detects the minimum value out of three arguments. This method is
-    # faster than `[a, b, c].min` and puts less GC pressure.
-    # See https://github.com/ruby/did_you_mean/pull/1 for a performance
-    # benchmark.
-    def min3(a, b, c)
-      if a < b && a < c
-        a
-      elsif b < c
-        b
-      else
-        c
-      end
-    end
-    module_function :min3
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checker.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checker.rb
deleted file mode 100644
index 37da2fc7a6ec2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checker.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-# frozen-string-literal: true
-
-require_relative "levenshtein"
-require_relative "jaro_winkler"
-
-module DidYouMean
-  class SpellChecker
-    def initialize(dictionary:)
-      @dictionary = dictionary
-    end
-
-    def correct(input)
-      normalized_input = normalize(input)
-      threshold = normalized_input.length > 3 ? 0.834 : 0.77
-
-      words = @dictionary.select { |word| JaroWinkler.distance(normalize(word), normalized_input) >= threshold }
-      words.reject! { |word| input.to_s == word.to_s }
-      words.sort_by! { |word| JaroWinkler.distance(word.to_s, normalized_input) }
-      words.reverse!
-
-      # Correct mistypes
-      threshold   = (normalized_input.length * 0.25).ceil
-      corrections = words.select { |c| Levenshtein.distance(normalize(c), normalized_input) <= threshold }
-
-      # Correct misspells
-      if corrections.empty?
-        corrections = words.select do |word|
-          word   = normalize(word)
-          length = normalized_input.length < word.length ? normalized_input.length : word.length
-
-          Levenshtein.distance(word, normalized_input) < length
-        end.first(1)
-      end
-
-      corrections
-    end
-
-    private
-
-    def normalize(str_or_symbol) #:nodoc:
-      str = str_or_symbol.to_s.downcase
-      str.tr!("@", "")
-      str
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/key_error_checker.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/key_error_checker.rb
deleted file mode 100644
index be4bea7789c37..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/key_error_checker.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-require_relative "../spell_checker"
-
-module DidYouMean
-  class KeyErrorChecker
-    def initialize(key_error)
-      @key = key_error.key
-      @keys = key_error.receiver.keys
-    end
-
-    def corrections
-      @corrections ||= exact_matches.empty? ? SpellChecker.new(dictionary: @keys).correct(@key).map(&:inspect) : exact_matches
-    end
-
-    private
-
-    def exact_matches
-      @exact_matches ||= @keys.select { |word| @key == word.to_s }.map(&:inspect)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/method_name_checker.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/method_name_checker.rb
deleted file mode 100644
index d8ebaa461685c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/method_name_checker.rb
+++ /dev/null
@@ -1,72 +0,0 @@
-require_relative "../spell_checker"
-
-module DidYouMean
-  class MethodNameChecker
-    attr_reader :method_name, :receiver
-
-    NAMES_TO_EXCLUDE = { NilClass => nil.methods }
-    NAMES_TO_EXCLUDE.default = []
-    Ractor.make_shareable(NAMES_TO_EXCLUDE) if defined?(Ractor)
-
-    # +MethodNameChecker::RB_RESERVED_WORDS+ is the list of reserved words in
-    # Ruby that take an argument. Unlike
-    # +VariableNameChecker::RB_RESERVED_WORDS+, these reserved words require
-    # an argument, and a +NoMethodError+ is raised due to the presence of the
-    # argument.
-    #
-    # The +MethodNameChecker+ will use this list to suggest a reversed word if
-    # a +NoMethodError+ is raised and found closest matches.
-    #
-    # Also see +VariableNameChecker::RB_RESERVED_WORDS+.
-    RB_RESERVED_WORDS = %i(
-      alias
-      case
-      def
-      defined?
-      elsif
-      end
-      ensure
-      for
-      rescue
-      super
-      undef
-      unless
-      until
-      when
-      while
-      yield
-    )
-
-    Ractor.make_shareable(RB_RESERVED_WORDS) if defined?(Ractor)
-
-    def initialize(exception)
-      @method_name  = exception.name
-      @receiver     = exception.receiver
-      @private_call = exception.respond_to?(:private_call?) ? exception.private_call? : false
-    end
-
-    def corrections
-      @corrections ||= begin
-                         dictionary = method_names
-                         dictionary = RB_RESERVED_WORDS + dictionary if @private_call
-
-                         SpellChecker.new(dictionary: dictionary).correct(method_name) - names_to_exclude
-                       end
-    end
-
-    def method_names
-      if Object === receiver
-        method_names = receiver.methods + receiver.singleton_methods
-        method_names += receiver.private_methods if @private_call
-        method_names.uniq!
-        method_names
-      else
-        []
-      end
-    end
-
-    def names_to_exclude
-      Object === receiver ? NAMES_TO_EXCLUDE[receiver.class] : []
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/name_error_checkers.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/name_error_checkers.rb
deleted file mode 100644
index 6e2aaa4cb1618..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/name_error_checkers.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-require_relative 'name_error_checkers/class_name_checker'
-require_relative 'name_error_checkers/variable_name_checker'
-
-module DidYouMean
-  class << (NameErrorCheckers = Object.new)
-    def new(exception)
-      case exception.original_message
-      when /uninitialized constant/
-        ClassNameChecker
-      when /undefined local variable or method/,
-           /undefined method/,
-           /uninitialized class variable/,
-           /no member '.*' in struct/
-        VariableNameChecker
-      else
-        NullChecker
-      end.new(exception)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/name_error_checkers/class_name_checker.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/name_error_checkers/class_name_checker.rb
deleted file mode 100644
index 924265b929a2a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/name_error_checkers/class_name_checker.rb
+++ /dev/null
@@ -1,49 +0,0 @@
-# frozen-string-literal: true
-
-require_relative "../../spell_checker"
-
-module DidYouMean
-  class ClassNameChecker
-    attr_reader :class_name
-
-    def initialize(exception)
-      @class_name, @receiver, @original_message = exception.name, exception.receiver, exception.original_message
-    end
-
-    def corrections
-      @corrections ||= SpellChecker.new(dictionary: class_names)
-                         .correct(class_name)
-                         .map(&:full_name)
-                         .reject {|qualified_name| @original_message.include?(qualified_name) }
-    end
-
-    def class_names
-      scopes.flat_map do |scope|
-        scope.constants.map do |c|
-          ClassName.new(c, scope == Object ? "" : "#{scope}::")
-        end
-      end
-    end
-
-    def scopes
-      @scopes ||= @receiver.to_s.split("::").inject([Object]) do |_scopes, scope|
-        _scopes << _scopes.last.const_get(scope)
-      end.uniq
-    end
-
-    class ClassName < String
-      attr :namespace
-
-      def initialize(name, namespace = '')
-        super(name.to_s)
-        @namespace = namespace
-      end
-
-      def full_name
-        self.class.new("#{namespace}#{self}")
-      end
-    end
-
-    private_constant :ClassName
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/name_error_checkers/variable_name_checker.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/name_error_checkers/variable_name_checker.rb
deleted file mode 100644
index 36d00349c679b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/name_error_checkers/variable_name_checker.rb
+++ /dev/null
@@ -1,85 +0,0 @@
-# frozen-string-literal: true
-
-require_relative "../../spell_checker"
-
-module DidYouMean
-  class VariableNameChecker
-    attr_reader :name, :method_names, :lvar_names, :ivar_names, :cvar_names
-
-    NAMES_TO_EXCLUDE = { 'foo' => [:fork, :for] }
-    NAMES_TO_EXCLUDE.default = []
-    Ractor.make_shareable(NAMES_TO_EXCLUDE) if defined?(Ractor)
-
-    # +VariableNameChecker::RB_RESERVED_WORDS+ is the list of all reserved
-    # words in Ruby. They could be declared like methods are, and a typo would
-    # cause Ruby to raise a +NameError+ because of the way they are declared.
-    #
-    # The +:VariableNameChecker+ will use this list to suggest a reversed word
-    # if a +NameError+ is raised and found closest matches, excluding:
-    #
-    #   * +do+
-    #   * +if+
-    #   * +in+
-    #   * +or+
-    #
-    # Also see +MethodNameChecker::RB_RESERVED_WORDS+.
-    RB_RESERVED_WORDS = %i(
-      BEGIN
-      END
-      alias
-      and
-      begin
-      break
-      case
-      class
-      def
-      defined?
-      else
-      elsif
-      end
-      ensure
-      false
-      for
-      module
-      next
-      nil
-      not
-      redo
-      rescue
-      retry
-      return
-      self
-      super
-      then
-      true
-      undef
-      unless
-      until
-      when
-      while
-      yield
-      __LINE__
-      __FILE__
-      __ENCODING__
-    )
-
-    Ractor.make_shareable(RB_RESERVED_WORDS) if defined?(Ractor)
-
-    def initialize(exception)
-      @name       = exception.name.to_s.tr("@", "")
-      @lvar_names = exception.respond_to?(:local_variables) ? exception.local_variables : []
-      receiver    = exception.receiver
-
-      @method_names = receiver.methods + receiver.private_methods
-      @ivar_names   = receiver.instance_variables
-      @cvar_names   = receiver.class.class_variables
-      @cvar_names  += receiver.class_variables if receiver.kind_of?(Module)
-    end
-
-    def corrections
-      @corrections ||= SpellChecker
-                     .new(dictionary: (RB_RESERVED_WORDS + lvar_names + method_names + ivar_names + cvar_names))
-                     .correct(name) - NAMES_TO_EXCLUDE[@name]
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/null_checker.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/null_checker.rb
deleted file mode 100644
index 1306f69d4ad12..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/null_checker.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-module DidYouMean
-  class NullChecker
-    def initialize(*);  end
-    def corrections; [] end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/pattern_key_name_checker.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/pattern_key_name_checker.rb
deleted file mode 100644
index ed263c8f93732..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/pattern_key_name_checker.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-require_relative "../spell_checker"
-
-module DidYouMean
-  class PatternKeyNameChecker
-    def initialize(no_matching_pattern_key_error)
-      @key = no_matching_pattern_key_error.key
-      @keys = no_matching_pattern_key_error.matchee.keys
-    end
-
-    def corrections
-      @corrections ||= exact_matches.empty? ? SpellChecker.new(dictionary: @keys).correct(@key).map(&:inspect) : exact_matches
-    end
-
-    private
-
-    def exact_matches
-      @exact_matches ||= @keys.select { |word| @key == word.to_s }.map(&:inspect)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/require_path_checker.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/require_path_checker.rb
deleted file mode 100644
index 586ced37de22a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/spell_checkers/require_path_checker.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# frozen-string-literal: true
-
-require_relative "../spell_checker"
-require_relative "../tree_spell_checker"
-require "rbconfig"
-
-module DidYouMean
-  class RequirePathChecker
-    attr_reader :path
-
-    INITIAL_LOAD_PATH = $LOAD_PATH.dup.freeze
-    Ractor.make_shareable(INITIAL_LOAD_PATH) if defined?(Ractor)
-
-    ENV_SPECIFIC_EXT = ".#{RbConfig::CONFIG["DLEXT"]}"
-    Ractor.make_shareable(ENV_SPECIFIC_EXT) if defined?(Ractor)
-
-    private_constant :INITIAL_LOAD_PATH, :ENV_SPECIFIC_EXT
-
-    def self.requireables
-      @requireables ||= INITIAL_LOAD_PATH
-                          .flat_map {|path| Dir.glob("**/???*{.rb,#{ENV_SPECIFIC_EXT}}", base: path) }
-                          .map {|path| path.chomp!(".rb") || path.chomp!(ENV_SPECIFIC_EXT) }
-    end
-
-    def initialize(exception)
-      @path = exception.path
-    end
-
-    def corrections
-      @corrections ||= begin
-                         threshold     = path.size * 2
-                         dictionary    = self.class.requireables.reject {|str| str.size >= threshold }
-                         spell_checker = path.include?("/") ? TreeSpellChecker : SpellChecker
-
-                         spell_checker.new(dictionary: dictionary).correct(path).uniq
-                       end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/tree_spell_checker.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/tree_spell_checker.rb
deleted file mode 100644
index 799f07fcf0eef..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/tree_spell_checker.rb
+++ /dev/null
@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-module DidYouMean
-  # spell checker for a dictionary that has a tree
-  # structure, see doc/tree_spell_checker_api.md
-  class TreeSpellChecker
-    attr_reader :dictionary, :separator, :augment
-
-    def initialize(dictionary:, separator: '/', augment: nil)
-      @dictionary = dictionary
-      @separator = separator
-      @augment = augment
-    end
-
-    def correct(input)
-      plausibles = plausible_dimensions(input)
-      return fall_back_to_normal_spell_check(input) if plausibles.empty?
-
-      suggestions = find_suggestions(input, plausibles)
-      return fall_back_to_normal_spell_check(input) if suggestions.empty?
-
-      suggestions
-    end
-
-    def dictionary_without_leaves
-      @dictionary_without_leaves ||= dictionary.map { |word| word.split(separator)[0..-2] }.uniq
-    end
-
-    def tree_depth
-      @tree_depth ||= dictionary_without_leaves.max { |a, b| a.size <=> b.size }.size
-    end
-
-    def dimensions
-      @dimensions ||= tree_depth.times.map do |index|
-                        dictionary_without_leaves.map { |element| element[index] }.compact.uniq
-                      end
-    end
-
-    def find_leaves(path)
-      path_with_separator = "#{path}#{separator}"
-
-      dictionary
-        .select {|str| str.include?(path_with_separator) }
-        .map {|str| str.gsub(path_with_separator, '') }
-    end
-
-    def plausible_dimensions(input)
-      input.split(separator)[0..-2]
-        .map
-        .with_index { |element, index| correct_element(dimensions[index], element) if dimensions[index] }
-        .compact
-    end
-
-    def possible_paths(states)
-      states.map { |state| state.join(separator) }
-    end
-
-    private
-
-    def find_suggestions(input, plausibles)
-      states = plausibles[0].product(*plausibles[1..-1])
-      paths  = possible_paths(states)
-      leaf   = input.split(separator).last
-
-      find_ideas(paths, leaf)
-    end
-
-    def fall_back_to_normal_spell_check(input)
-      return [] unless augment
-
-      ::DidYouMean::SpellChecker.new(dictionary: dictionary).correct(input)
-    end
-
-    def find_ideas(paths, leaf)
-      paths.flat_map do |path|
-        names = find_leaves(path)
-        ideas = correct_element(names, leaf)
-
-        ideas_to_paths(ideas, leaf, names, path)
-      end.compact
-    end
-
-    def ideas_to_paths(ideas, leaf, names, path)
-      if ideas.empty?
-        nil
-      elsif names.include?(leaf)
-        ["#{path}#{separator}#{leaf}"]
-      else
-        ideas.map {|str| "#{path}#{separator}#{str}" }
-      end
-    end
-
-    def correct_element(names, element)
-      return names if names.size == 1
-
-      str = normalize(element)
-
-      return [str] if names.include?(str)
-
-      ::DidYouMean::SpellChecker.new(dictionary: names).correct(str)
-    end
-
-    def normalize(str)
-      str.downcase!
-      str.tr!('@', ' ') if str.include?('@')
-      str
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/verbose.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/verbose.rb
deleted file mode 100644
index 1ff19aef809dd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/verbose.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-warn "The verbose formatter has been removed and now `require 'did_you_mean/verbose'` has no effect. Please " \
-     "remove this call."
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/version.rb
deleted file mode 100644
index b5fe50b5ed160..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/did_you_mean-1.6.1/lib/did_you_mean/version.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-module DidYouMean
-  VERSION = "1.6.1".freeze
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/constants.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/constants.rb
deleted file mode 100644
index 35ee1939cac78..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/constants.rb
+++ /dev/null
@@ -1,320 +0,0 @@
-# frozen_string_literal: true
-
-module ELFTools
-  # Define constants from elf.h.
-  # Mostly refer from https://github.com/torvalds/linux/blob/master/include/uapi/linux/elf.h
-  # and binutils/elfcpp/elfcpp.h.
-  module Constants
-    # ELF magic header
-    ELFMAG = "\x7FELF"
-
-    # Values of `d_un.d_val' in the DT_FLAGS and DT_FLAGS_1 entry.
-    module DF
-      DF_ORIGIN       = 0x00000001 # Object may use DF_ORIGIN
-      DF_SYMBOLIC     = 0x00000002 # Symbol resolutions starts here
-      DF_TEXTREL      = 0x00000004 # Object contains text relocations
-      DF_BIND_NOW     = 0x00000008 # No lazy binding for this object
-      DF_STATIC_TLS   = 0x00000010 # Module uses the static TLS model
-
-      DF_1_NOW        = 0x00000001 # Set RTLD_NOW for this object.
-      DF_1_GLOBAL     = 0x00000002 # Set RTLD_GLOBAL for this object.
-      DF_1_GROUP      = 0x00000004 # Set RTLD_GROUP for this object.
-      DF_1_NODELETE   = 0x00000008 # Set RTLD_NODELETE for this object.
-      DF_1_LOADFLTR   = 0x00000010 # Trigger filtee loading at runtime.
-      DF_1_INITFIRST  = 0x00000020 # Set RTLD_INITFIRST for this object
-      DF_1_NOOPEN     = 0x00000040 # Set RTLD_NOOPEN for this object.
-      DF_1_ORIGIN     = 0x00000080 # $ORIGIN must be handled.
-      DF_1_DIRECT     = 0x00000100 # Direct binding enabled.
-      DF_1_TRANS      = 0x00000200 # :nodoc:
-      DF_1_INTERPOSE  = 0x00000400 # Object is used to interpose.
-      DF_1_NODEFLIB   = 0x00000800 # Ignore default lib search path.
-      DF_1_NODUMP     = 0x00001000 # Object can't be dldump'ed.
-      DF_1_CONFALT    = 0x00002000 # Configuration alternative created.
-      DF_1_ENDFILTEE  = 0x00004000 # Filtee terminates filters search.
-      DF_1_DISPRELDNE = 0x00008000 # Disp reloc applied at build time.
-      DF_1_DISPRELPND = 0x00010000 # Disp reloc applied at run-time.
-      DF_1_NODIRECT   = 0x00020000 # Object has no-direct binding.
-      DF_1_IGNMULDEF  = 0x00040000 # :nodoc:
-      DF_1_NOKSYMS    = 0x00080000 # :nodoc:
-      DF_1_NOHDR      = 0x00100000 # :nodoc:
-      DF_1_EDITED     = 0x00200000 # Object is modified after built.
-      DF_1_NORELOC    = 0x00400000 # :nodoc:
-      DF_1_SYMINTPOSE = 0x00800000 # Object has individual interposers.
-      DF_1_GLOBAUDIT  = 0x01000000 # Global auditing required.
-      DF_1_SINGLETON  = 0x02000000 # Singleton symbols are used.
-    end
-    include DF
-
-    # Dynamic table types, records in +d_tag+.
-    module DT
-      DT_NULL         = 0 # marks the end of the _DYNAMIC array
-      DT_NEEDED       = 1 # libraries need to be linked by loader
-      DT_PLTRELSZ     = 2 # total size of relocation entries
-      DT_PLTGOT       = 3 # address of procedure linkage table or global offset table
-      DT_HASH         = 4 # address of symbol hash table
-      DT_STRTAB       = 5 # address of string table
-      DT_SYMTAB       = 6 # address of symbol table
-      DT_RELA         = 7 # address of a relocation table
-      DT_RELASZ       = 8 # total size of the {DT_RELA} table
-      DT_RELAENT      = 9 # size of each entry in the {DT_RELA} table
-      DT_STRSZ        = 10 # total size of {DT_STRTAB}
-      DT_SYMENT       = 11 # size of each entry in {DT_SYMTAB}
-      DT_INIT         = 12 # where the initialization function is
-      DT_FINI         = 13 # where the termination function is
-      DT_SONAME       = 14 # the shared object name
-      DT_RPATH        = 15 # has been superseded by {DT_RUNPATH}
-      DT_SYMBOLIC     = 16 # has been superseded by the DF_SYMBOLIC flag
-      DT_REL          = 17 # similar to {DT_RELA}
-      DT_RELSZ        = 18 # total size of the {DT_REL} table
-      DT_RELENT       = 19 # size of each entry in the {DT_REL} table
-      DT_PLTREL       = 20 # type of relocation entry, either {DT_REL} or {DT_RELA}
-      DT_DEBUG        = 21 # for debugging
-      DT_TEXTREL      = 22 # has been superseded by the DF_TEXTREL flag
-      DT_JMPREL       = 23 # address of relocation entries that are associated solely with the procedure linkage table
-      DT_BIND_NOW     = 24 # if the loader needs to do relocate now, superseded by the DF_BIND_NOW flag
-      DT_INIT_ARRAY   = 25 # address init array
-      DT_FINI_ARRAY   = 26 # address of fini array
-      DT_INIT_ARRAYSZ = 27 # total size of init array
-      DT_FINI_ARRAYSZ = 28 # total size of fini array
-      DT_RUNPATH      = 29 # path of libraries for searching
-      DT_FLAGS        = 30 # flags
-      DT_ENCODING     = 32 # just a lower bound
-      # Values between {DT_LOOS} and {DT_HIOS} are reserved for operating system-specific semantics.
-      DT_LOOS         = 0x6000000d
-      DT_HIOS         = 0x6ffff000 # see {DT_LOOS}
-      # Values between {DT_VALRNGLO} and {DT_VALRNGHI} use the +d_un.d_val+ field of the dynamic structure.
-      DT_VALRNGLO     = 0x6ffffd00
-      DT_VALRNGHI     = 0x6ffffdff # see {DT_VALRNGLO}
-      # Values between {DT_ADDRRNGLO} and {DT_ADDRRNGHI} use the +d_un.d_ptr+ field of the dynamic structure.
-      DT_ADDRRNGLO    = 0x6ffffe00
-      DT_GNU_HASH     = 0x6ffffef5 # the gnu hash
-      DT_ADDRRNGHI    = 0x6ffffeff # see {DT_ADDRRNGLO}
-      DT_RELACOUNT    = 0x6ffffff9 # relative relocation count
-      DT_RELCOUNT     = 0x6ffffffa # relative relocation count
-      DT_FLAGS_1      = 0x6ffffffb # flags
-      DT_VERDEF       = 0x6ffffffc # address of version definition table
-      DT_VERDEFNUM    = 0x6ffffffd # number of entries in {DT_VERDEF}
-      DT_VERNEED      = 0x6ffffffe # address of version dependency table
-      DT_VERSYM       = 0x6ffffff0 # section address of .gnu.version
-      DT_VERNEEDNUM   = 0x6fffffff # number of entries in {DT_VERNEED}
-      # Values between {DT_LOPROC} and {DT_HIPROC} are reserved for processor-specific semantics.
-      DT_LOPROC       = 0x70000000
-      DT_HIPROC       = 0x7fffffff # see {DT_LOPROC}
-    end
-    include DT
-
-    # These constants define the various ELF target machines.
-    module EM
-      EM_NONE           = 0      # none
-      EM_M32            = 1      # AT&T WE 32100
-      EM_SPARC          = 2      # SPARC
-      EM_386            = 3      # Intel 80386
-      EM_68K            = 4      # Motorola 68000
-      EM_88K            = 5      # Motorola 88000
-      EM_486            = 6      # Intel 80486
-      EM_860            = 7      # Intel 80860
-      EM_MIPS           = 8      # MIPS R3000 (officially, big-endian only)
-
-      # Next two are historical and binaries and
-      # modules of these types will be rejected by Linux.
-      EM_MIPS_RS3_LE    = 10     # MIPS R3000 little-endian
-      EM_MIPS_RS4_BE    = 10     # MIPS R4000 big-endian
-
-      EM_PARISC         = 15     # HPPA
-      EM_SPARC32PLUS    = 18     # Sun's "v8plus"
-      EM_PPC            = 20     # PowerPC
-      EM_PPC64          = 21     # PowerPC64
-      EM_SPU            = 23     # Cell BE SPU
-      EM_ARM            = 40     # ARM 32 bit
-      EM_SH             = 42     # SuperH
-      EM_SPARCV9        = 43     # SPARC v9 64-bit
-      EM_H8_300         = 46     # Renesas H8/300
-      EM_IA_64          = 50     # HP/Intel IA-64
-      EM_X86_64         = 62     # AMD x86-64
-      EM_S390           = 22     # IBM S/390
-      EM_CRIS           = 76     # Axis Communications 32-bit embedded processor
-      EM_M32R           = 88     # Renesas M32R
-      EM_MN10300        = 89     # Panasonic/MEI MN10300, AM33
-      EM_OPENRISC       = 92     # OpenRISC 32-bit embedded processor
-      EM_BLACKFIN       = 106    # ADI Blackfin Processor
-      EM_ALTERA_NIOS2   = 113    # Altera Nios II soft-core processor
-      EM_TI_C6000       = 140    # TI C6X DSPs
-      EM_AARCH64        = 183    # ARM 64 bit
-      EM_TILEPRO        = 188    # Tilera TILEPro
-      EM_MICROBLAZE     = 189    # Xilinx MicroBlaze
-      EM_TILEGX         = 191    # Tilera TILE-Gx
-      EM_BPF            = 247    # Linux BPF - in-kernel virtual machine
-      EM_FRV            = 0x5441 # Fujitsu FR-V
-      EM_AVR32          = 0x18ad # Atmel AVR32
-
-      # This is an interim value that we will use until the committee comes up with a final number.
-      EM_ALPHA          = 0x9026
-
-      # Bogus old m32r magic number, used by old tools.
-      EM_CYGNUS_M32R    = 0x9041
-      # This is the old interim value for S/390 architecture
-      EM_S390_OLD       = 0xA390
-      # Also Panasonic/MEI MN10300, AM33
-      EM_CYGNUS_MN10300 = 0xbeef
-
-      # Return the architecture name according to +val+.
-      # Used by {ELFTools::ELFFile#machine}.
-      #
-      # Only supports famous archs.
-      # @param [Integer] val Value of +e_machine+.
-      # @return [String]
-      #   Name of architecture.
-      # @example
-      #   mapping(3)
-      #   #=> 'Intel 80386'
-      #   mapping(6)
-      #   #=> 'Intel 80386'
-      #   mapping(62)
-      #   #=> 'Advanced Micro Devices X86-64'
-      #   mapping(1337)
-      #   #=> '<unknown>: 0x539'
-      def self.mapping(val)
-        case val
-        when EM_NONE then 'None'
-        when EM_386, EM_486 then 'Intel 80386'
-        when EM_860 then 'Intel 80860'
-        when EM_MIPS then 'MIPS R3000'
-        when EM_PPC then 'PowerPC'
-        when EM_PPC64 then 'PowerPC64'
-        when EM_ARM then 'ARM'
-        when EM_IA_64 then 'Intel IA-64'
-        when EM_AARCH64 then 'AArch64'
-        when EM_X86_64 then 'Advanced Micro Devices X86-64'
-        else format('<unknown>: 0x%x', val)
-        end
-      end
-    end
-    include EM
-
-    # This module defines elf file types.
-    module ET
-      ET_NONE = 0 # no file type
-      ET_REL  = 1 # relocatable file
-      ET_EXEC = 2 # executable file
-      ET_DYN  = 3 # shared object
-      ET_CORE = 4 # core file
-      # Return the type name according to +e_type+ in ELF file header.
-      # @return [String] Type in string format.
-      def self.mapping(type)
-        case type
-        when Constants::ET_NONE then 'NONE'
-        when Constants::ET_REL then 'REL'
-        when Constants::ET_EXEC then 'EXEC'
-        when Constants::ET_DYN then 'DYN'
-        when Constants::ET_CORE then 'CORE'
-        else '<unknown>'
-        end
-      end
-    end
-    include ET
-
-    # Program header permission flags, records bitwise OR value in +p_flags+.
-    module PF
-      PF_X = 1
-      PF_W = 2
-      PF_R = 4
-    end
-    include PF
-
-    # Program header types, records in +p_type+.
-    module PT
-      PT_NULL         = 0          # null segment
-      PT_LOAD         = 1          # segment to be load
-      PT_DYNAMIC      = 2          # dynamic tags
-      PT_INTERP       = 3          # interpreter, same as .interp section
-      PT_NOTE         = 4          # same as .note* section
-      PT_SHLIB        = 5          # reserved
-      PT_PHDR         = 6          # where program header starts
-      PT_TLS          = 7          # thread local storage segment
-      PT_LOOS         = 0x60000000 # OS-specific
-      PT_HIOS         = 0x6fffffff # OS-specific
-      # Values between {PT_LOPROC} and {PT_HIPROC} are reserved for processor-specific semantics.
-      PT_LOPROC       = 0x70000000
-      PT_HIPROC       = 0x7fffffff # see {PT_LOPROC}
-      PT_GNU_EH_FRAME = 0x6474e550 # for exception handler
-      PT_GNU_STACK    = 0x6474e551 # permission of stack
-      PT_GNU_RELRO    = 0x6474e552 # read only after relocation
-    end
-    include PT
-
-    # Special indices to section. These are used when there is no valid index to section header.
-    # The meaning of these values is left upto the embedding header.
-    module SHN
-      SHN_UNDEF     = 0      # undefined section
-      SHN_LORESERVE = 0xff00 # start of reserved indices
-    end
-    include SHN
-
-    # Section header types, records in +sh_type+.
-    module SHT
-      SHT_NULL     = 0 # null section
-      SHT_PROGBITS = 1 # information defined by program itself
-      SHT_SYMTAB   = 2 # symbol table section
-      SHT_STRTAB   = 3 # string table section
-      SHT_RELA     = 4 # relocation with addends
-      SHT_HASH     = 5 # symbol hash table
-      SHT_DYNAMIC  = 6 # information of dynamic linking
-      SHT_NOTE     = 7 # note section
-      SHT_NOBITS   = 8 # section occupies no space
-      SHT_REL      = 9 # relocation
-      SHT_SHLIB    = 10 # reserved
-      SHT_DYNSYM   = 11 # symbols for dynamic
-      # Values between {SHT_LOPROC} and {SHT_HIPROC} are reserved for processor-specific semantics.
-      SHT_LOPROC   = 0x70000000
-      SHT_HIPROC   = 0x7fffffff # see {SHT_LOPROC}
-      # Values between {SHT_LOUSER} and {SHT_HIUSER} are reserved for application programs.
-      SHT_LOUSER   = 0x80000000
-      SHT_HIUSER   = 0xffffffff # see {SHT_LOUSER}
-    end
-    include SHT
-
-    # Symbol binding from Sym st_info field.
-    module STB
-      STB_LOCAL      = 0 # Local symbol
-      STB_GLOBAL     = 1 # Global symbol
-      STB_WEAK       = 2 # Weak symbol
-      STB_NUM        = 3 # Number of defined types.
-      STB_LOOS       = 10 # Start of OS-specific
-      STB_GNU_UNIQUE = 10 # Unique symbol.
-      STB_HIOS       = 12 # End of OS-specific
-      STB_LOPROC     = 13 # Start of processor-specific
-      STB_HIPROC     = 15 # End of processor-specific
-    end
-    include STB
-
-    # Symbol types from Sym st_info field.
-    module STT
-      STT_NOTYPE         = 0 # Symbol type is unspecified
-      STT_OBJECT         = 1 # Symbol is a data object
-      STT_FUNC           = 2 # Symbol is a code object
-      STT_SECTION        = 3 # Symbol associated with a section
-      STT_FILE           = 4 # Symbol's name is file name
-      STT_COMMON         = 5 # Symbol is a common data object
-      STT_TLS            = 6 # Symbol is thread-local data object
-      STT_NUM            = 7 # Number of defined types.
-
-      # GNU extension: symbol value points to a function which is called
-      # at runtime to determine the final value of the symbol.
-      STT_GNU_IFUNC      = 10
-
-      STT_LOOS           = 10 # Start of OS-specific
-      STT_HIOS           = 12 # End of OS-specific
-      STT_LOPROC         = 13 # Start of processor-specific
-      STT_HIPROC         = 15 # End of processor-specific
-
-      # The section type that must be used for register symbols on
-      # Sparc. These symbols initialize a global register.
-      STT_SPARC_REGISTER = 13
-
-      # ARM: a THUMB function. This is not defined in ARM ELF Specification but
-      # used by the GNU tool-chain.
-      STT_ARM_TFUNC      = 13
-    end
-    include STT
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/section.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/section.rb
deleted file mode 100644
index b0a835cde4971..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/section.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require 'elftools/constants'
-module ELFTools
-  module Sections
-    # Base class of sections.
-    class Section
-      attr_reader :header # @return [ELFTools::Structs::ELF_Shdr] Section header.
-      attr_reader :stream # @return [#pos=, #read] Streaming object.
-
-      # Instantiate a {Section} object.
-      # @param [ELFTools::Structs::ELF_Shdr] header
-      #   The section header object.
-      # @param [#pos=, #read] stream
-      #   The streaming object for further dump.
-      # @param [ELFTools::Sections::StrTabSection, Proc] strtab
-      #   The string table object. For fetching section names.
-      #   If +Proc+ if given, it will call at the first
-      #   time access +#name+.
-      # @param [Method] offset_from_vma
-      #   The method to get offset of file, given virtual memory address.
-      def initialize(header, stream, offset_from_vma: nil, strtab: nil, **_kwargs)
-        @header = header
-        @stream = stream
-        @strtab = strtab
-        @offset_from_vma = offset_from_vma
-      end
-
-      # Return +header.sh_type+ in a simplier way.
-      # @return [Integer]
-      #   The type, meaning of types are defined in {Constants::SHT}.
-      def type
-        header.sh_type.to_i
-      end
-
-      # Get name of this section.
-      # @return [String] The name.
-      def name
-        @name ||= @strtab.call.name_at(header.sh_name)
-      end
-
-      # Fetch data of this section.
-      # @return [String] Data.
-      def data
-        stream.pos = header.sh_offset
-        stream.read(header.sh_size)
-      end
-
-      # Is this a null section?
-      # @return [Boolean] No it's not.
-      def null?
-        false
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/version.rb
deleted file mode 100644
index 243f277a3fd1c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/version.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module ELFTools
-  # Current gem version
-  VERSION = '1.1.3'
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n.rb
deleted file mode 100644
index d3369704abf1f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n.rb
+++ /dev/null
@@ -1,435 +0,0 @@
-# frozen_string_literal: true
-
-require 'concurrent/map'
-require 'concurrent/hash'
-
-require 'i18n/version'
-require 'i18n/utils'
-require 'i18n/exceptions'
-require 'i18n/interpolate/ruby'
-
-module I18n
-  autoload :Backend, 'i18n/backend'
-  autoload :Config,  'i18n/config'
-  autoload :Gettext, 'i18n/gettext'
-  autoload :Locale,  'i18n/locale'
-  autoload :Tests,   'i18n/tests'
-  autoload :Middleware,   'i18n/middleware'
-
-  RESERVED_KEYS = %i[
-    cascade
-    deep_interpolation
-    default
-    exception_handler
-    fallback
-    fallback_in_progress
-    fallback_original_locale
-    format
-    object
-    raise
-    resolve
-    scope
-    separator
-    throw
-  ]
-  EMPTY_HASH = {}.freeze
-
-  def self.new_double_nested_cache # :nodoc:
-    Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new }
-  end
-
-  # Marks a key as reserved. Reserved keys are used internally,
-  # and can't also be used for interpolation. If you are using any
-  # extra keys as I18n options, you should call I18n.reserve_key
-  # before any I18n.translate (etc) calls are made.
-  def self.reserve_key(key)
-    RESERVED_KEYS << key.to_sym
-    @reserved_keys_pattern = nil
-  end
-
-  def self.reserved_keys_pattern # :nodoc:
-    @reserved_keys_pattern ||= /%\{(#{RESERVED_KEYS.join("|")})\}/
-  end
-
-  module Base
-    # Gets I18n configuration object.
-    def config
-      Thread.current[:i18n_config] ||= I18n::Config.new
-    end
-
-    # Sets I18n configuration object.
-    def config=(value)
-      Thread.current[:i18n_config] = value
-    end
-
-    # Write methods which delegates to the configuration object
-    %w(locale backend default_locale available_locales default_separator
-      exception_handler load_path enforce_available_locales).each do |method|
-      module_eval <<-DELEGATORS, __FILE__, __LINE__ + 1
-        def #{method}
-          config.#{method}
-        end
-
-        def #{method}=(value)
-          config.#{method} = (value)
-        end
-      DELEGATORS
-    end
-
-    # Tells the backend to reload translations. Used in situations like the
-    # Rails development environment. Backends can implement whatever strategy
-    # is useful.
-    def reload!
-      config.clear_available_locales_set
-      config.backend.reload!
-    end
-
-    # Tells the backend to load translations now. Used in situations like the
-    # Rails production environment. Backends can implement whatever strategy
-    # is useful.
-    def eager_load!
-      config.backend.eager_load!
-    end
-
-    # Translates, pluralizes and interpolates a given key using a given locale,
-    # scope, and default, as well as interpolation values.
-    #
-    # *LOOKUP*
-    #
-    # Translation data is organized as a nested hash using the upper-level keys
-    # as namespaces. <em>E.g.</em>, ActionView ships with the translation:
-    # <tt>:date => {:formats => {:short => "%b %d"}}</tt>.
-    #
-    # Translations can be looked up at any level of this hash using the key argument
-    # and the scope option. <em>E.g.</em>, in this example <tt>I18n.t :date</tt>
-    # returns the whole translations hash <tt>{:formats => {:short => "%b %d"}}</tt>.
-    #
-    # Key can be either a single key or a dot-separated key (both Strings and Symbols
-    # work). <em>E.g.</em>, the short format can be looked up using both:
-    #   I18n.t 'date.formats.short'
-    #   I18n.t :'date.formats.short'
-    #
-    # Scope can be either a single key, a dot-separated key or an array of keys
-    # or dot-separated keys. Keys and scopes can be combined freely. So these
-    # examples will all look up the same short date format:
-    #   I18n.t 'date.formats.short'
-    #   I18n.t 'formats.short', :scope => 'date'
-    #   I18n.t 'short', :scope => 'date.formats'
-    #   I18n.t 'short', :scope => %w(date formats)
-    #
-    # *INTERPOLATION*
-    #
-    # Translations can contain interpolation variables which will be replaced by
-    # values passed to #translate as part of the options hash, with the keys matching
-    # the interpolation variable names.
-    #
-    # <em>E.g.</em>, with a translation <tt>:foo => "foo %{bar}"</tt> the option
-    # value for the key +bar+ will be interpolated into the translation:
-    #   I18n.t :foo, :bar => 'baz' # => 'foo baz'
-    #
-    # *PLURALIZATION*
-    #
-    # Translation data can contain pluralized translations. Pluralized translations
-    # are arrays of singular/plural versions of translations like <tt>['Foo', 'Foos']</tt>.
-    #
-    # Note that <tt>I18n::Backend::Simple</tt> only supports an algorithm for English
-    # pluralization rules. Other algorithms can be supported by custom backends.
-    #
-    # This returns the singular version of a pluralized translation:
-    #   I18n.t :foo, :count => 1 # => 'Foo'
-    #
-    # These both return the plural version of a pluralized translation:
-    #   I18n.t :foo, :count => 0 # => 'Foos'
-    #   I18n.t :foo, :count => 2 # => 'Foos'
-    #
-    # The <tt>:count</tt> option can be used both for pluralization and interpolation.
-    # <em>E.g.</em>, with the translation
-    # <tt>:foo => ['%{count} foo', '%{count} foos']</tt>, count will
-    # be interpolated to the pluralized translation:
-    #   I18n.t :foo, :count => 1 # => '1 foo'
-    #
-    # *DEFAULTS*
-    #
-    # This returns the translation for <tt>:foo</tt> or <tt>default</tt> if no translation was found:
-    #   I18n.t :foo, :default => 'default'
-    #
-    # This returns the translation for <tt>:foo</tt> or the translation for <tt>:bar</tt> if no
-    # translation for <tt>:foo</tt> was found:
-    #   I18n.t :foo, :default => :bar
-    #
-    # Returns the translation for <tt>:foo</tt> or the translation for <tt>:bar</tt>
-    # or <tt>default</tt> if no translations for <tt>:foo</tt> and <tt>:bar</tt> were found.
-    #   I18n.t :foo, :default => [:bar, 'default']
-    #
-    # *BULK LOOKUP*
-    #
-    # This returns an array with the translations for <tt>:foo</tt> and <tt>:bar</tt>.
-    #   I18n.t [:foo, :bar]
-    #
-    # Can be used with dot-separated nested keys:
-    #   I18n.t [:'baz.foo', :'baz.bar']
-    #
-    # Which is the same as using a scope option:
-    #   I18n.t [:foo, :bar], :scope => :baz
-    #
-    # *LAMBDAS*
-    #
-    # Both translations and defaults can be given as Ruby lambdas. Lambdas will be
-    # called and passed the key and options.
-    #
-    # E.g. assuming the key <tt>:salutation</tt> resolves to:
-    #   lambda { |key, options| options[:gender] == 'm' ? "Mr. #{options[:name]}" : "Mrs. #{options[:name]}" }
-    #
-    # Then <tt>I18n.t(:salutation, :gender => 'w', :name => 'Smith') will result in "Mrs. Smith".
-    #
-    # Note that the string returned by lambda will go through string interpolation too,
-    # so the following lambda would give the same result:
-    #   lambda { |key, options| options[:gender] == 'm' ? "Mr. %{name}" : "Mrs. %{name}" }
-    #
-    # It is recommended to use/implement lambdas in an "idempotent" way. E.g. when
-    # a cache layer is put in front of I18n.translate it will generate a cache key
-    # from the argument values passed to #translate. Therefore your lambdas should
-    # always return the same translations/values per unique combination of argument
-    # values.
-    #
-    # *Ruby 2.7+ keyword arguments warning*
-    #
-    # This method uses keyword arguments.
-    # There is a breaking change in ruby that produces warning with ruby 2.7 and won't work as expected with ruby 3.0
-    # The "hash" parameter must be passed as keyword argument.
-    #
-    # Good:
-    #  I18n.t(:salutation, :gender => 'w', :name => 'Smith')
-    #  I18n.t(:salutation, **{ :gender => 'w', :name => 'Smith' })
-    #  I18n.t(:salutation, **any_hash)
-    #
-    # Bad:
-    #  I18n.t(:salutation, { :gender => 'w', :name => 'Smith' })
-    #  I18n.t(:salutation, any_hash)
-    #
-    def translate(key = nil, throw: false, raise: false, locale: nil, **options) # TODO deprecate :raise
-      locale ||= config.locale
-      raise Disabled.new('t') if locale == false
-      enforce_available_locales!(locale)
-
-      backend = config.backend
-
-      if key.is_a?(Array)
-        key.map do |k|
-          translate_key(k, throw, raise, locale, backend, options)
-        end
-      else
-        translate_key(key, throw, raise, locale, backend, options)
-      end
-    end
-    alias :t :translate
-
-    # Wrapper for <tt>translate</tt> that adds <tt>:raise => true</tt>. With
-    # this option, if no translation is found, it will raise <tt>I18n::MissingTranslationData</tt>
-    def translate!(key, **options)
-      translate(key, **options, raise: true)
-    end
-    alias :t! :translate!
-
-    # Returns true if a translation exists for a given key, otherwise returns false.
-    def exists?(key, _locale = nil, locale: _locale, **options)
-      locale ||= config.locale
-      raise Disabled.new('exists?') if locale == false
-      raise I18n::ArgumentError if key.is_a?(String) && key.empty?
-      config.backend.exists?(locale, key, options)
-    end
-
-    # Transliterates UTF-8 characters to ASCII. By default this method will
-    # transliterate only Latin strings to an ASCII approximation:
-    #
-    #    I18n.transliterate("Ærøskøbing")
-    #    # => "AEroskobing"
-    #
-    #    I18n.transliterate("日本語")
-    #    # => "???"
-    #
-    # It's also possible to add support for per-locale transliterations. I18n
-    # expects transliteration rules to be stored at
-    # <tt>i18n.transliterate.rule</tt>.
-    #
-    # Transliteration rules can either be a Hash or a Proc. Procs must accept a
-    # single string argument. Hash rules inherit the default transliteration
-    # rules, while Procs do not.
-    #
-    # *Examples*
-    #
-    # Setting a Hash in <locale>.yml:
-    #
-    #    i18n:
-    #      transliterate:
-    #        rule:
-    #          ü: "ue"
-    #          ö: "oe"
-    #
-    # Setting a Hash using Ruby:
-    #
-    #     store_translations(:de, i18n: {
-    #                          transliterate: {
-    #                            rule: {
-    #                              'ü' => 'ue',
-    #                              'ö' => 'oe'
-    #                            }
-    #                          }
-    #                        })
-    #
-    # Setting a Proc:
-    #
-    #     translit = lambda {|string| MyTransliterator.transliterate(string) }
-    #     store_translations(:xx, :i18n => {:transliterate => {:rule => translit})
-    #
-    # Transliterating strings:
-    #
-    #     I18n.locale = :en
-    #     I18n.transliterate("Jürgen") # => "Jurgen"
-    #     I18n.locale = :de
-    #     I18n.transliterate("Jürgen") # => "Juergen"
-    #     I18n.transliterate("Jürgen", :locale => :en) # => "Jurgen"
-    #     I18n.transliterate("Jürgen", :locale => :de) # => "Juergen"
-    def transliterate(key, throw: false, raise: false, locale: nil, replacement: nil, **options)
-      locale ||= config.locale
-      raise Disabled.new('transliterate') if locale == false
-      enforce_available_locales!(locale)
-
-      config.backend.transliterate(locale, key, replacement)
-    rescue I18n::ArgumentError => exception
-      handle_exception((throw && :throw || raise && :raise), exception, locale, key, options)
-    end
-
-    # Localizes certain objects, such as dates and numbers to local formatting.
-    def localize(object, locale: nil, format: nil, **options)
-      locale ||= config.locale
-      raise Disabled.new('l') if locale == false
-      enforce_available_locales!(locale)
-
-      format ||= :default
-      config.backend.localize(locale, object, format, options)
-    end
-    alias :l :localize
-
-    # Executes block with given I18n.locale set.
-    def with_locale(tmp_locale = nil)
-      if tmp_locale == nil
-        yield
-      else
-        current_locale = self.locale
-        self.locale = tmp_locale
-        begin
-          yield
-        ensure
-          self.locale = current_locale
-        end
-      end
-    end
-
-    # Merges the given locale, key and scope into a single array of keys.
-    # Splits keys that contain dots into multiple keys. Makes sure all
-    # keys are Symbols.
-    def normalize_keys(locale, key, scope, separator = nil)
-      separator ||= I18n.default_separator
-
-      [
-        *normalize_key(locale, separator),
-        *normalize_key(scope, separator),
-        *normalize_key(key, separator)
-      ]
-    end
-
-    # Returns true when the passed locale, which can be either a String or a
-    # Symbol, is in the list of available locales. Returns false otherwise.
-    def locale_available?(locale)
-      I18n.config.available_locales_set.include?(locale)
-    end
-
-    # Raises an InvalidLocale exception when the passed locale is not available.
-    def enforce_available_locales!(locale)
-      if locale != false && config.enforce_available_locales
-        raise I18n::InvalidLocale.new(locale) if !locale_available?(locale)
-      end
-    end
-
-    def available_locales_initialized?
-      config.available_locales_initialized?
-    end
-
-  private
-
-    def translate_key(key, throw, raise, locale, backend, options)
-      result = catch(:exception) do
-        backend.translate(locale, key, options)
-      end
-
-      if result.is_a?(MissingTranslation)
-        handle_exception((throw && :throw || raise && :raise), result, locale, key, options)
-      else
-        result
-      end
-    end
-
-    # Any exceptions thrown in translate will be sent to the @@exception_handler
-    # which can be a Symbol, a Proc or any other Object unless they're forced to
-    # be raised or thrown (MissingTranslation).
-    #
-    # If exception_handler is a Symbol then it will simply be sent to I18n as
-    # a method call. A Proc will simply be called. In any other case the
-    # method #call will be called on the exception_handler object.
-    #
-    # Examples:
-    #
-    #   I18n.exception_handler = :custom_exception_handler              # this is the default
-    #   I18n.custom_exception_handler(exception, locale, key, options)  # will be called like this
-    #
-    #   I18n.exception_handler = lambda { |*args| ... }                 # a lambda
-    #   I18n.exception_handler.call(exception, locale, key, options)    # will be called like this
-    #
-    #   I18n.exception_handler = I18nExceptionHandler.new               # an object
-    #   I18n.exception_handler.call(exception, locale, key, options)    # will be called like this
-    def handle_exception(handling, exception, locale, key, options)
-      case handling
-      when :raise
-        raise exception.respond_to?(:to_exception) ? exception.to_exception : exception
-      when :throw
-        throw :exception, exception
-      else
-        case handler = options[:exception_handler] || config.exception_handler
-        when Symbol
-          send(handler, exception, locale, key, options)
-        else
-          handler.call(exception, locale, key, options)
-        end
-      end
-    end
-
-    @@normalized_key_cache = I18n.new_double_nested_cache
-
-    def normalize_key(key, separator)
-      @@normalized_key_cache[separator][key] ||=
-        case key
-        when Array
-          key.flat_map { |k| normalize_key(k, separator) }
-        else
-          keys = key.to_s.split(separator)
-          keys.delete('')
-          keys.map! do |k|
-            case k
-            when /\A[-+]?([1-9]\d*|0)\z/ # integer
-              k.to_i
-            when 'true'
-              true
-            when 'false'
-              false
-            else
-              k.to_sym
-            end
-          end
-          keys
-        end
-    end
-  end
-
-  extend Base
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend.rb
deleted file mode 100644
index 863d618782d57..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module I18n
-  module Backend
-    autoload :Base,                  'i18n/backend/base'
-    autoload :Cache,                 'i18n/backend/cache'
-    autoload :CacheFile,             'i18n/backend/cache_file'
-    autoload :Cascade,               'i18n/backend/cascade'
-    autoload :Chain,                 'i18n/backend/chain'
-    autoload :Fallbacks,             'i18n/backend/fallbacks'
-    autoload :Flatten,               'i18n/backend/flatten'
-    autoload :Gettext,               'i18n/backend/gettext'
-    autoload :InterpolationCompiler, 'i18n/backend/interpolation_compiler'
-    autoload :KeyValue,              'i18n/backend/key_value'
-    autoload :LazyLoadable,          'i18n/backend/lazy_loadable'
-    autoload :Memoize,               'i18n/backend/memoize'
-    autoload :Metadata,              'i18n/backend/metadata'
-    autoload :Pluralization,         'i18n/backend/pluralization'
-    autoload :Simple,                'i18n/backend/simple'
-    autoload :Transliterator,        'i18n/backend/transliterator'
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/base.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/base.rb
deleted file mode 100644
index 4cbcc3c0e45af..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/base.rb
+++ /dev/null
@@ -1,299 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'json'
-
-module I18n
-  module Backend
-    module Base
-      include I18n::Backend::Transliterator
-
-      # Accepts a list of paths to translation files. Loads translations from
-      # plain Ruby (*.rb), YAML files (*.yml), or JSON files (*.json). See #load_rb, #load_yml, and #load_json
-      # for details.
-      def load_translations(*filenames)
-        filenames = I18n.load_path if filenames.empty?
-        filenames.flatten.each do |filename|
-          loaded_translations = load_file(filename)
-          yield filename, loaded_translations if block_given?
-        end
-      end
-
-      # This method receives a locale, a data hash and options for storing translations.
-      # Should be implemented
-      def store_translations(locale, data, options = EMPTY_HASH)
-        raise NotImplementedError
-      end
-
-      def translate(locale, key, options = EMPTY_HASH)
-        raise I18n::ArgumentError if (key.is_a?(String) || key.is_a?(Symbol)) && key.empty?
-        raise InvalidLocale.new(locale) unless locale
-        return nil if key.nil? && !options.key?(:default)
-
-        entry = lookup(locale, key, options[:scope], options) unless key.nil?
-
-        if entry.nil? && options.key?(:default)
-          entry = default(locale, key, options[:default], options)
-        else
-          entry = resolve_entry(locale, key, entry, options)
-        end
-
-        count = options[:count]
-
-        if entry.nil? && (subtrees? || !count)
-          if (options.key?(:default) && !options[:default].nil?) || !options.key?(:default)
-            throw(:exception, I18n::MissingTranslation.new(locale, key, options))
-          end
-        end
-
-        entry = entry.dup if entry.is_a?(String)
-        entry = pluralize(locale, entry, count) if count
-
-        if entry.nil? && !subtrees?
-          throw(:exception, I18n::MissingTranslation.new(locale, key, options))
-        end
-
-        deep_interpolation = options[:deep_interpolation]
-        values = Utils.except(options, *RESERVED_KEYS)
-        if values
-          entry = if deep_interpolation
-            deep_interpolate(locale, entry, values)
-          else
-            interpolate(locale, entry, values)
-          end
-        end
-        entry
-      end
-
-      def exists?(locale, key, options = EMPTY_HASH)
-        lookup(locale, key) != nil
-      end
-
-      # Acts the same as +strftime+, but uses a localized version of the
-      # format string. Takes a key from the date/time formats translations as
-      # a format argument (<em>e.g.</em>, <tt>:short</tt> in <tt>:'date.formats'</tt>).
-      def localize(locale, object, format = :default, options = EMPTY_HASH)
-        if object.nil? && options.include?(:default)
-          return options[:default]
-        end
-        raise ArgumentError, "Object must be a Date, DateTime or Time object. #{object.inspect} given." unless object.respond_to?(:strftime)
-
-        if Symbol === format
-          key  = format
-          type = object.respond_to?(:sec) ? 'time' : 'date'
-          options = options.merge(:raise => true, :object => object, :locale => locale)
-          format  = I18n.t(:"#{type}.formats.#{key}", **options)
-        end
-
-        format = translate_localization_format(locale, object, format, options)
-        object.strftime(format)
-      end
-
-      # Returns an array of locales for which translations are available
-      # ignoring the reserved translation meta data key :i18n.
-      def available_locales
-        raise NotImplementedError
-      end
-
-      def reload!
-        eager_load! if eager_loaded?
-      end
-
-      def eager_load!
-        @eager_loaded = true
-      end
-
-      protected
-
-        def eager_loaded?
-          @eager_loaded ||= false
-        end
-
-        # The method which actually looks up for the translation in the store.
-        def lookup(locale, key, scope = [], options = EMPTY_HASH)
-          raise NotImplementedError
-        end
-
-        def subtrees?
-          true
-        end
-
-        # Evaluates defaults.
-        # If given subject is an Array, it walks the array and returns the
-        # first translation that can be resolved. Otherwise it tries to resolve
-        # the translation directly.
-        def default(locale, object, subject, options = EMPTY_HASH)
-          options = options.reject { |key, value| key == :default }
-          case subject
-          when Array
-            subject.each do |item|
-              result = resolve(locale, object, item, options)
-              return result unless result.nil?
-            end and nil
-          else
-            resolve(locale, object, subject, options)
-          end
-        end
-
-        # Resolves a translation.
-        # If the given subject is a Symbol, it will be translated with the
-        # given options. If it is a Proc then it will be evaluated. All other
-        # subjects will be returned directly.
-        def resolve(locale, object, subject, options = EMPTY_HASH)
-          return subject if options[:resolve] == false
-          result = catch(:exception) do
-            case subject
-            when Symbol
-              I18n.translate(subject, **options.merge(:locale => locale, :throw => true))
-            when Proc
-              date_or_time = options.delete(:object) || object
-              resolve(locale, object, subject.call(date_or_time, **options))
-            else
-              subject
-            end
-          end
-          result unless result.is_a?(MissingTranslation)
-        end
-        alias_method :resolve_entry, :resolve
-
-        # Picks a translation from a pluralized mnemonic subkey according to English
-        # pluralization rules :
-        # - It will pick the :one subkey if count is equal to 1.
-        # - It will pick the :other subkey otherwise.
-        # - It will pick the :zero subkey in the special case where count is
-        #   equal to 0 and there is a :zero subkey present. This behaviour is
-        #   not standard with regards to the CLDR pluralization rules.
-        # Other backends can implement more flexible or complex pluralization rules.
-        def pluralize(locale, entry, count)
-          entry = entry.reject { |k, _v| k == :attributes } if entry.is_a?(Hash)
-          return entry unless entry.is_a?(Hash) && count && entry.values.none? { |v| v.is_a?(Hash) }
-
-          key = pluralization_key(entry, count)
-          raise InvalidPluralizationData.new(entry, count, key) unless entry.has_key?(key)
-          entry[key]
-        end
-
-        # Interpolates values into a given subject.
-        #
-        #   if the given subject is a string then:
-        #   method interpolates "file %{file} opened by %%{user}", :file => 'test.txt', :user => 'Mr. X'
-        #   # => "file test.txt opened by %{user}"
-        #
-        #   if the given subject is an array then:
-        #   each element of the array is recursively interpolated (until it finds a string)
-        #   method interpolates ["yes, %{user}", ["maybe no, %{user}, "no, %{user}"]], :user => "bartuz"
-        #   # => "["yes, bartuz",["maybe no, bartuz", "no, bartuz"]]"
-        def interpolate(locale, subject, values = EMPTY_HASH)
-          return subject if values.empty?
-
-          case subject
-          when ::String then I18n.interpolate(subject, values)
-          when ::Array then subject.map { |element| interpolate(locale, element, values) }
-          else
-            subject
-          end
-        end
-
-        # Deep interpolation
-        #
-        #   deep_interpolate { people: { ann: "Ann is %{ann}", john: "John is %{john}" } },
-        #                    ann: 'good', john: 'big'
-        #   #=> { people: { ann: "Ann is good", john: "John is big" } }
-        def deep_interpolate(locale, data, values = EMPTY_HASH)
-          return data if values.empty?
-
-          case data
-          when ::String
-            I18n.interpolate(data, values)
-          when ::Hash
-            data.each_with_object({}) do |(k, v), result|
-              result[k] = deep_interpolate(locale, v, values)
-            end
-          when ::Array
-            data.map do |v|
-              deep_interpolate(locale, v, values)
-            end
-          else
-            data
-          end
-        end
-
-        # Loads a single translations file by delegating to #load_rb or
-        # #load_yml depending on the file extension and directly merges the
-        # data to the existing translations. Raises I18n::UnknownFileType
-        # for all other file extensions.
-        def load_file(filename)
-          type = File.extname(filename).tr('.', '').downcase
-          raise UnknownFileType.new(type, filename) unless respond_to?(:"load_#{type}", true)
-          data, keys_symbolized = send(:"load_#{type}", filename)
-          unless data.is_a?(Hash)
-            raise InvalidLocaleData.new(filename, 'expects it to return a hash, but does not')
-          end
-          data.each { |locale, d| store_translations(locale, d || {}, skip_symbolize_keys: keys_symbolized) }
-
-          data
-        end
-
-        # Loads a plain Ruby translations file. eval'ing the file must yield
-        # a Hash containing translation data with locales as toplevel keys.
-        def load_rb(filename)
-          translations = eval(IO.read(filename), binding, filename)
-          [translations, false]
-        end
-
-        # Loads a YAML translations file. The data must have locales as
-        # toplevel keys.
-        def load_yml(filename)
-          begin
-            if YAML.respond_to?(:unsafe_load_file) # Psych 4.0 way
-              [YAML.unsafe_load_file(filename, symbolize_names: true, freeze: true), true]
-            else
-              [YAML.load_file(filename), false]
-            end
-          rescue TypeError, ScriptError, StandardError => e
-            raise InvalidLocaleData.new(filename, e.inspect)
-          end
-        end
-        alias_method :load_yaml, :load_yml
-
-        # Loads a JSON translations file. The data must have locales as
-        # toplevel keys.
-        def load_json(filename)
-          begin
-            # Use #load_file as a proxy for a version of JSON where symbolize_names and freeze are supported.
-            if ::JSON.respond_to?(:load_file)
-              [::JSON.load_file(filename, symbolize_names: true, freeze: true), true]
-            else
-              [::JSON.parse(File.read(filename)), false]
-            end
-          rescue TypeError, StandardError => e
-            raise InvalidLocaleData.new(filename, e.inspect)
-          end
-        end
-
-        def translate_localization_format(locale, object, format, options)
-          format.to_s.gsub(/%(|\^)[aAbBpP]/) do |match|
-            case match
-            when '%a' then I18n.t!(:"date.abbr_day_names",                  :locale => locale, :format => format)[object.wday]
-            when '%^a' then I18n.t!(:"date.abbr_day_names",                 :locale => locale, :format => format)[object.wday].upcase
-            when '%A' then I18n.t!(:"date.day_names",                       :locale => locale, :format => format)[object.wday]
-            when '%^A' then I18n.t!(:"date.day_names",                      :locale => locale, :format => format)[object.wday].upcase
-            when '%b' then I18n.t!(:"date.abbr_month_names",                :locale => locale, :format => format)[object.mon]
-            when '%^b' then I18n.t!(:"date.abbr_month_names",               :locale => locale, :format => format)[object.mon].upcase
-            when '%B' then I18n.t!(:"date.month_names",                     :locale => locale, :format => format)[object.mon]
-            when '%^B' then I18n.t!(:"date.month_names",                    :locale => locale, :format => format)[object.mon].upcase
-            when '%p' then I18n.t!(:"time.#{object.hour < 12 ? :am : :pm}", :locale => locale, :format => format).upcase if object.respond_to? :hour
-            when '%P' then I18n.t!(:"time.#{object.hour < 12 ? :am : :pm}", :locale => locale, :format => format).downcase if object.respond_to? :hour
-            end
-          end
-        rescue MissingTranslationData => e
-          e.message
-        end
-
-        def pluralization_key(entry, count)
-          key = :zero if count == 0 && entry.has_key?(:zero)
-          key ||= count == 1 ? :one : :other
-        end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/cache.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/cache.rb
deleted file mode 100644
index 40c18d657520d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/cache.rb
+++ /dev/null
@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-# This module allows you to easily cache all responses from the backend - thus
-# speeding up the I18n aspects of your application quite a bit.
-#
-# To enable caching you can simply include the Cache module to the Simple
-# backend - or whatever other backend you are using:
-#
-#   I18n::Backend::Simple.send(:include, I18n::Backend::Cache)
-#
-# You will also need to set a cache store implementation that you want to use:
-#
-#   I18n.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
-#
-# You can use any cache implementation you want that provides the same API as
-# ActiveSupport::Cache (only the methods #fetch and #write are being used).
-#
-# The cache_key implementation by default assumes you pass values that return
-# a valid key from #hash (see
-# https://www.ruby-doc.org/core/classes/Object.html#M000337). However, you can
-# configure your own digest method via which responds to #hexdigest (see
-# https://ruby-doc.org/stdlib/libdoc/openssl/rdoc/OpenSSL/Digest.html):
-#
-#   I18n.cache_key_digest = OpenSSL::Digest::SHA256.new
-#
-# If you use a lambda as a default value in your translation like this:
-#
-#   I18n.t(:"date.order", :default => lambda {[:month, :day, :year]})
-#
-# Then you will always have a cache miss, because each time this method
-# is called the lambda will have a different hash value. If you know
-# the result of the lambda is a constant as in the example above, then
-# to cache this you can make the lambda a constant, like this:
-#
-#   DEFAULT_DATE_ORDER = lambda {[:month, :day, :year]}
-#   ...
-#   I18n.t(:"date.order", :default => DEFAULT_DATE_ORDER)
-#
-# If the lambda may result in different values for each call then consider
-# also using the Memoize backend.
-#
-module I18n
-  class << self
-    @@cache_store = nil
-    @@cache_namespace = nil
-    @@cache_key_digest = nil
-
-    def cache_store
-      @@cache_store
-    end
-
-    def cache_store=(store)
-      @@cache_store = store
-    end
-
-    def cache_namespace
-      @@cache_namespace
-    end
-
-    def cache_namespace=(namespace)
-      @@cache_namespace = namespace
-    end
-
-    def cache_key_digest
-      @@cache_key_digest
-    end
-
-    def cache_key_digest=(key_digest)
-      @@cache_key_digest = key_digest
-    end
-
-    def perform_caching?
-      !cache_store.nil?
-    end
-  end
-
-  module Backend
-    # TODO Should the cache be cleared if new translations are stored?
-    module Cache
-      def translate(locale, key, options = EMPTY_HASH)
-        I18n.perform_caching? ? fetch(cache_key(locale, key, options)) { super } : super
-      end
-
-      protected
-
-        def fetch(cache_key, &block)
-          result = _fetch(cache_key, &block)
-          throw(:exception, result) if result.is_a?(MissingTranslation)
-          result = result.dup if result.frozen? rescue result
-          result
-        end
-
-        def _fetch(cache_key, &block)
-          result = I18n.cache_store.read(cache_key)
-          return result unless result.nil?
-          result = catch(:exception, &block)
-          I18n.cache_store.write(cache_key, result) unless result.is_a?(Proc)
-          result
-        end
-
-        def cache_key(locale, key, options)
-          # This assumes that only simple, native Ruby values are passed to I18n.translate.
-          "i18n/#{I18n.cache_namespace}/#{locale}/#{digest_item(key)}/#{digest_item(options)}"
-        end
-
-      private
-
-        def digest_item(key)
-          I18n.cache_key_digest ? I18n.cache_key_digest.hexdigest(key.to_s) : key.to_s.hash
-        end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/cache_file.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/cache_file.rb
deleted file mode 100644
index 0c5e192210ad7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/cache_file.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'openssl'
-
-module I18n
-  module Backend
-    # Overwrites the Base load_file method to cache loaded file contents.
-    module CacheFile
-      # Optionally provide path_roots array to normalize filename paths,
-      # to make the cached i18n data portable across environments.
-      attr_accessor :path_roots
-
-      protected
-
-      # Track loaded translation files in the `i18n.load_file` scope,
-      # and skip loading the file if its contents are still up-to-date.
-      def load_file(filename)
-        initialized = !respond_to?(:initialized?) || initialized?
-        key = I18n::Backend::Flatten.escape_default_separator(normalized_path(filename))
-        old_mtime, old_digest = initialized && lookup(:i18n, key, :load_file)
-        return if (mtime = File.mtime(filename).to_i) == old_mtime ||
-                  (digest = OpenSSL::Digest::SHA256.file(filename).hexdigest) == old_digest
-        super
-        store_translations(:i18n, load_file: { key => [mtime, digest] })
-      end
-
-      # Translate absolute filename to relative path for i18n key.
-      def normalized_path(file)
-        return file unless path_roots
-        path = path_roots.find(&file.method(:start_with?)) ||
-               raise(InvalidLocaleData.new(file, 'outside expected path roots'))
-        file.sub(path, path_roots.index(path).to_s)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/cascade.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/cascade.rb
deleted file mode 100644
index 782b07b59480d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/cascade.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-# The Cascade module adds the ability to do cascading lookups to backends that
-# are compatible to the Simple backend.
-#
-# By cascading lookups we mean that for any key that can not be found the
-# Cascade module strips one segment off the scope part of the key and then
-# tries to look up the key in that scope.
-#
-# E.g. when a lookup for the key :"foo.bar.baz" does not yield a result then
-# the segment :bar will be stripped off the scope part :"foo.bar" and the new
-# scope :foo will be used to look up the key :baz. If that does not succeed
-# then the remaining scope segment :foo will be omitted, too, and again the
-# key :baz will be looked up (now with no scope).
-#
-# To enable a cascading lookup one passes the :cascade option:
-#
-#   I18n.t(:'foo.bar.baz', :cascade => true)
-#
-# This will return the first translation found for :"foo.bar.baz", :"foo.baz"
-# or :baz in this order.
-#
-# The cascading lookup takes precedence over resolving any given defaults.
-# I.e. defaults will kick in after the cascading lookups haven't succeeded.
-#
-# This behavior is useful for libraries like ActiveRecord validations where
-# the library wants to give users a bunch of more or less fine-grained options
-# of scopes for a particular key.
-#
-# Thanks to Clemens Kofler for the initial idea and implementation! See
-# http://github.com/clemens/i18n-cascading-backend
-
-module I18n
-  module Backend
-    module Cascade
-      def lookup(locale, key, scope = [], options = EMPTY_HASH)
-        return super unless cascade = options[:cascade]
-
-        cascade   = { :step => 1 } unless cascade.is_a?(Hash)
-        step      = cascade[:step]   || 1
-        offset    = cascade[:offset] || 1
-        separator = options[:separator] || I18n.default_separator
-        skip_root = cascade.has_key?(:skip_root) ? cascade[:skip_root] : true
-
-        scope = I18n.normalize_keys(nil, key, scope, separator)
-        key   = (scope.slice!(-offset, offset) || []).join(separator)
-
-        begin
-          result = super
-          return result unless result.nil?
-          scope = scope.dup
-        end while (!scope.empty? || !skip_root) && scope.slice!(-step, step)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/chain.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/chain.rb
deleted file mode 100644
index 525dd2ded6123..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/chain.rb
+++ /dev/null
@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-module I18n
-  module Backend
-    # Backend that chains multiple other backends and checks each of them when
-    # a translation needs to be looked up. This is useful when you want to use
-    # standard translations with a Simple backend but store custom application
-    # translations in a database or other backends.
-    #
-    # To use the Chain backend instantiate it and set it to the I18n module.
-    # You can add chained backends through the initializer or backends
-    # accessor:
-    #
-    #   # preserves the existing Simple backend set to I18n.backend
-    #   I18n.backend = I18n::Backend::Chain.new(I18n::Backend::ActiveRecord.new, I18n.backend)
-    #
-    # The implementation assumes that all backends added to the Chain implement
-    # a lookup method with the same API as Simple backend does.
-    class Chain
-      module Implementation
-        include Base
-
-        attr_accessor :backends
-
-        def initialize(*backends)
-          self.backends = backends
-        end
-
-        def initialized?
-          backends.all? do |backend|
-            backend.instance_eval do
-              return false unless initialized?
-            end
-          end
-          true
-        end
-
-        def reload!
-          backends.each { |backend| backend.reload! }
-        end
-
-        def eager_load!
-          backends.each { |backend| backend.eager_load! }
-        end
-
-        def store_translations(locale, data, options = EMPTY_HASH)
-          backends.first.store_translations(locale, data, options)
-        end
-
-        def available_locales
-          backends.map { |backend| backend.available_locales }.flatten.uniq
-        end
-
-        def translate(locale, key, default_options = EMPTY_HASH)
-          namespace = nil
-          options = Utils.except(default_options, :default)
-
-          backends.each do |backend|
-            catch(:exception) do
-              options = default_options if backend == backends.last
-              translation = backend.translate(locale, key, options)
-              if namespace_lookup?(translation, options)
-                namespace = _deep_merge(translation, namespace || {})
-              elsif !translation.nil? || (options.key?(:default) && options[:default].nil?)
-                return translation
-              end
-            end
-          end
-
-          return namespace if namespace
-          throw(:exception, I18n::MissingTranslation.new(locale, key, options))
-        end
-
-        def exists?(locale, key, options = EMPTY_HASH)
-          backends.any? do |backend|
-            backend.exists?(locale, key, options)
-          end
-        end
-
-        def localize(locale, object, format = :default, options = EMPTY_HASH)
-          backends.each do |backend|
-            catch(:exception) do
-              result = backend.localize(locale, object, format, options) and return result
-            end
-          end
-          throw(:exception, I18n::MissingTranslation.new(locale, format, options))
-        end
-
-        protected
-          def init_translations
-            backends.each do |backend|
-              backend.send(:init_translations)
-            end
-          end
-
-          def translations
-            backends.reverse.each_with_object({}) do |backend, memo|
-              partial_translations = backend.instance_eval do
-                init_translations unless initialized?
-                translations
-              end
-              Utils.deep_merge!(memo, partial_translations) { |_, a, b| b || a }
-            end
-          end
-
-          def namespace_lookup?(result, options)
-            result.is_a?(Hash) && !options.has_key?(:count)
-          end
-
-        private
-          # This is approximately what gets used in ActiveSupport.
-          # However since we are not guaranteed to run in an ActiveSupport context
-          # it is wise to have our own copy. We underscore it
-          # to not pollute the namespace of the including class.
-          def _deep_merge(hash, other_hash)
-            copy = hash.dup
-            other_hash.each_pair do |k,v|
-              value_from_other = hash[k]
-              copy[k] = value_from_other.is_a?(Hash) && v.is_a?(Hash) ? _deep_merge(value_from_other, v) : v
-            end
-            copy
-          end
-      end
-
-      include Implementation
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/fallbacks.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/fallbacks.rb
deleted file mode 100644
index 6d4d6e138dc97..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/fallbacks.rb
+++ /dev/null
@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-# I18n locale fallbacks are useful when you want your application to use
-# translations from other locales when translations for the current locale are
-# missing. E.g. you might want to use :en translations when translations in
-# your applications main locale :de are missing.
-#
-# To enable locale fallbacks you can simply include the Fallbacks module to
-# the Simple backend - or whatever other backend you are using:
-#
-#   I18n::Backend::Simple.include(I18n::Backend::Fallbacks)
-module I18n
-  @@fallbacks = nil
-
-  class << self
-    # Returns the current fallbacks implementation. Defaults to +I18n::Locale::Fallbacks+.
-    def fallbacks
-      @@fallbacks ||= I18n::Locale::Fallbacks.new
-      Thread.current[:i18n_fallbacks] || @@fallbacks
-    end
-
-    # Sets the current fallbacks implementation. Use this to set a different fallbacks implementation.
-    def fallbacks=(fallbacks)
-      @@fallbacks = fallbacks.is_a?(Array) ? I18n::Locale::Fallbacks.new(fallbacks) : fallbacks
-      Thread.current[:i18n_fallbacks] = @@fallbacks
-    end
-  end
-
-  module Backend
-    module Fallbacks
-      # Overwrites the Base backend translate method so that it will try each
-      # locale given by I18n.fallbacks for the given locale. E.g. for the
-      # locale :"de-DE" it might try the locales :"de-DE", :de and :en
-      # (depends on the fallbacks implementation) until it finds a result with
-      # the given options. If it does not find any result for any of the
-      # locales it will then throw MissingTranslation as usual.
-      #
-      # The default option takes precedence over fallback locales only when
-      # it's a Symbol. When the default contains a String, Proc or Hash
-      # it is evaluated last after all the fallback locales have been tried.
-      def translate(locale, key, options = EMPTY_HASH)
-        return super unless options.fetch(:fallback, true)
-        return super if options[:fallback_in_progress]
-        default = extract_non_symbol_default!(options) if options[:default]
-
-        fallback_options = options.merge(:fallback_in_progress => true, fallback_original_locale: locale)
-        I18n.fallbacks[locale].each do |fallback|
-          begin
-            catch(:exception) do
-              result = super(fallback, key, fallback_options)
-              unless result.nil?
-                on_fallback(locale, fallback, key, options) if locale.to_s != fallback.to_s
-                return result
-              end
-            end
-          rescue I18n::InvalidLocale
-            # we do nothing when the locale is invalid, as this is a fallback anyways.
-          end
-        end
-
-        return if options.key?(:default) && options[:default].nil?
-
-        return super(locale, nil, options.merge(:default => default)) if default
-        throw(:exception, I18n::MissingTranslation.new(locale, key, options))
-      end
-
-      def resolve_entry(locale, object, subject, options = EMPTY_HASH)
-        return subject if options[:resolve] == false
-        result = catch(:exception) do
-          options.delete(:fallback_in_progress) if options.key?(:fallback_in_progress)
-
-          case subject
-          when Symbol
-            I18n.translate(subject, **options.merge(:locale => options[:fallback_original_locale], :throw => true))
-          when Proc
-            date_or_time = options.delete(:object) || object
-            resolve_entry(options[:fallback_original_locale], object, subject.call(date_or_time, **options))
-          else
-            subject
-          end
-        end
-        result unless result.is_a?(MissingTranslation)
-      end
-
-      def extract_non_symbol_default!(options)
-        defaults = [options[:default]].flatten
-        first_non_symbol_default = defaults.detect{|default| !default.is_a?(Symbol)}
-        if first_non_symbol_default
-          options[:default] = defaults[0, defaults.index(first_non_symbol_default)]
-        end
-        return first_non_symbol_default
-      end
-
-      def exists?(locale, key, options = EMPTY_HASH)
-        return super unless options.fetch(:fallback, true)
-        I18n.fallbacks[locale].each do |fallback|
-          begin
-            return true if super(fallback, key)
-          rescue I18n::InvalidLocale
-            # we do nothing when the locale is invalid, as this is a fallback anyways.
-          end
-        end
-
-        false
-      end
-
-      private
-
-        # Overwrite on_fallback to add specified logic when the fallback succeeds.
-        def on_fallback(_original_locale, _fallback_locale, _key, _options)
-          nil
-        end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/flatten.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/flatten.rb
deleted file mode 100644
index e9bd9d531df88..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/flatten.rb
+++ /dev/null
@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-module I18n
-  module Backend
-    # This module contains several helpers to assist flattening translations.
-    # You may want to flatten translations for:
-    #
-    #   1) speed up lookups, as in the Memoize backend;
-    #   2) In case you want to store translations in a data store, as in ActiveRecord backend;
-    #
-    # You can check both backends above for some examples.
-    # This module also keeps all links in a hash so they can be properly resolved when flattened.
-    module Flatten
-      SEPARATOR_ESCAPE_CHAR = "\001"
-      FLATTEN_SEPARATOR = "."
-
-      # normalize_keys the flatten way. This method is significantly faster
-      # and creates way less objects than the one at I18n.normalize_keys.
-      # It also handles escaping the translation keys.
-      def self.normalize_flat_keys(locale, key, scope, separator)
-        keys = [scope, key]
-        keys.flatten!
-        keys.compact!
-
-        separator ||= I18n.default_separator
-
-        if separator != FLATTEN_SEPARATOR
-          from_str = "#{FLATTEN_SEPARATOR}#{separator}"
-          to_str = "#{SEPARATOR_ESCAPE_CHAR}#{FLATTEN_SEPARATOR}"
-
-          keys.map! { |k| k.to_s.tr from_str, to_str }
-        end
-
-        keys.join(".")
-      end
-
-      # Receives a string and escape the default separator.
-      def self.escape_default_separator(key) #:nodoc:
-        key.to_s.tr(FLATTEN_SEPARATOR, SEPARATOR_ESCAPE_CHAR)
-      end
-
-      # Shortcut to I18n::Backend::Flatten.normalize_flat_keys
-      # and then resolve_links.
-      def normalize_flat_keys(locale, key, scope, separator)
-        key = I18n::Backend::Flatten.normalize_flat_keys(locale, key, scope, separator)
-        resolve_link(locale, key)
-      end
-
-      # Store flattened links.
-      def links
-        @links ||= I18n.new_double_nested_cache
-      end
-
-      # Flatten keys for nested Hashes by chaining up keys:
-      #
-      #   >> { "a" => { "b" => { "c" => "d", "e" => "f" }, "g" => "h" }, "i" => "j"}.wind
-      #   => { "a.b.c" => "d", "a.b.e" => "f", "a.g" => "h", "i" => "j" }
-      #
-      def flatten_keys(hash, escape, prev_key=nil, &block)
-        hash.each_pair do |key, value|
-          key = escape_default_separator(key) if escape
-          curr_key = [prev_key, key].compact.join(FLATTEN_SEPARATOR).to_sym
-          yield curr_key, value
-          flatten_keys(value, escape, curr_key, &block) if value.is_a?(Hash)
-        end
-      end
-
-      # Receives a hash of translations (where the key is a locale and
-      # the value is another hash) and return a hash with all
-      # translations flattened.
-      #
-      # Nested hashes are included in the flattened hash just if subtree
-      # is true and Symbols are automatically stored as links.
-      def flatten_translations(locale, data, escape, subtree)
-        hash = {}
-        flatten_keys(data, escape) do |key, value|
-          if value.is_a?(Hash)
-            hash[key] = value if subtree
-          else
-            store_link(locale, key, value) if value.is_a?(Symbol)
-            hash[key] = value
-          end
-        end
-        hash
-      end
-
-      protected
-
-        def store_link(locale, key, link)
-          links[locale.to_sym][key.to_s] = link.to_s
-        end
-
-        def resolve_link(locale, key)
-          key, locale = key.to_s, locale.to_sym
-          links = self.links[locale]
-
-          if links.key?(key)
-            links[key]
-          elsif link = find_link(locale, key)
-            store_link(locale, key, key.gsub(*link))
-          else
-            key
-          end
-        end
-
-        def find_link(locale, key) #:nodoc:
-          links[locale].each_pair do |from, to|
-            return [from, to] if key[0, from.length] == from
-          end && nil
-        end
-
-        def escape_default_separator(key) #:nodoc:
-          I18n::Backend::Flatten.escape_default_separator(key)
-        end
-
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/gettext.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/gettext.rb
deleted file mode 100644
index 076964638eb07..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/gettext.rb
+++ /dev/null
@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require 'i18n/gettext'
-require 'i18n/gettext/po_parser'
-
-module I18n
-  module Backend
-    # Experimental support for using Gettext po files to store translations.
-    #
-    # To use this you can simply include the module to the Simple backend - or
-    # whatever other backend you are using.
-    #
-    #  I18n::Backend::Simple.include(I18n::Backend::Gettext)
-    #
-    # Now you should be able to include your Gettext translation (*.po) files to
-    # the +I18n.load_path+ so they're loaded to the backend and you can use them as
-    # usual:
-    #
-    #  I18n.load_path += Dir["path/to/locales/*.po"]
-    #
-    # Following the Gettext convention this implementation expects that your
-    # translation files are named by their locales. E.g. the file en.po would
-    # contain the translations for the English locale.
-    #
-    # To translate text <b>you must use</b> one of the translate methods provided by
-    # I18n::Gettext::Helpers.
-    #
-    #  include I18n::Gettext::Helpers
-    #  puts _("some string")
-    #
-    # Without it strings containing periods (".") will not be translated.
-
-    module Gettext
-      class PoData < Hash
-        def set_comment(msgid_or_sym, comment)
-          # ignore
-        end
-      end
-
-      protected
-        def load_po(filename)
-          locale = ::File.basename(filename, '.po').to_sym
-          data = normalize(locale, parse(filename))
-          [{ locale => data }, false]
-        end
-
-        def parse(filename)
-          GetText::PoParser.new.parse(::File.read(filename), PoData.new)
-        end
-
-        def normalize(locale, data)
-          data.inject({}) do |result, (key, value)|
-            unless key.nil? || key.empty?
-              key = key.gsub(I18n::Gettext::CONTEXT_SEPARATOR, '|')
-              key, value = normalize_pluralization(locale, key, value) if key.index("\000")
-
-              parts = key.split('|').reverse
-              normalized = parts.inject({}) do |_normalized, part|
-                { part => _normalized.empty? ? value : _normalized }
-              end
-
-              Utils.deep_merge!(result, normalized)
-            end
-            result
-          end
-        end
-
-        def normalize_pluralization(locale, key, value)
-          # FIXME po_parser includes \000 chars that can not be turned into Symbols
-          key = key.gsub("\000", I18n::Gettext::PLURAL_SEPARATOR).split(I18n::Gettext::PLURAL_SEPARATOR).first
-
-          keys = I18n::Gettext.plural_keys(locale)
-          values = value.split("\000")
-          raise "invalid number of plurals: #{values.size}, keys: #{keys.inspect} on #{locale} locale for msgid #{key.inspect} with values #{values.inspect}" if values.size != keys.size
-
-          result = {}
-          values.each_with_index { |_value, ix| result[keys[ix]] = _value }
-          [key, result]
-        end
-
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/interpolation_compiler.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/interpolation_compiler.rb
deleted file mode 100644
index 8b52e7b3e9f69..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/interpolation_compiler.rb
+++ /dev/null
@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-# The InterpolationCompiler module contains optimizations that can tremendously
-# speed up the interpolation process on the Simple backend.
-#
-# It works by defining a pre-compiled method on stored translation Strings that
-# already bring all the knowledge about contained interpolation variables etc.
-# so that the actual recurring interpolation will be very fast.
-#
-# To enable pre-compiled interpolations you can simply include the
-# InterpolationCompiler module to the Simple backend:
-#
-#   I18n::Backend::Simple.include(I18n::Backend::InterpolationCompiler)
-#
-# Note that InterpolationCompiler does not yield meaningful results and consequently
-# should not be used with Ruby 1.9 (YARV) but improves performance everywhere else
-# (jRuby, Rubinius).
-module I18n
-  module Backend
-    module InterpolationCompiler
-      module Compiler
-        extend self
-
-        TOKENIZER                    = /(%%\{[^\}]+\}|%\{[^\}]+\})/
-        INTERPOLATION_SYNTAX_PATTERN = /(%)?(%\{([^\}]+)\})/
-
-        def compile_if_an_interpolation(string)
-          if interpolated_str?(string)
-            string.instance_eval <<-RUBY_EVAL, __FILE__, __LINE__
-              def i18n_interpolate(v = {})
-                "#{compiled_interpolation_body(string)}"
-              end
-            RUBY_EVAL
-          end
-
-          string
-        end
-
-        def interpolated_str?(str)
-          str.kind_of?(::String) && str =~ INTERPOLATION_SYNTAX_PATTERN
-        end
-
-        protected
-        # tokenize("foo %{bar} baz %%{buz}") # => ["foo ", "%{bar}", " baz ", "%%{buz}"]
-        def tokenize(str)
-          str.split(TOKENIZER)
-        end
-
-        def compiled_interpolation_body(str)
-          tokenize(str).map do |token|
-            (matchdata = token.match(INTERPOLATION_SYNTAX_PATTERN)) ? handle_interpolation_token(token, matchdata) : escape_plain_str(token)
-          end.join
-        end
-
-        def handle_interpolation_token(interpolation, matchdata)
-          escaped, pattern, key = matchdata.values_at(1, 2, 3)
-          escaped ? pattern : compile_interpolation_token(key.to_sym)
-        end
-
-        def compile_interpolation_token(key)
-          "\#{#{interpolate_or_raise_missing(key)}}"
-        end
-
-        def interpolate_or_raise_missing(key)
-          escaped_key = escape_key_sym(key)
-          RESERVED_KEYS.include?(key) ? reserved_key(escaped_key) : interpolate_key(escaped_key)
-        end
-
-        def interpolate_key(key)
-          [direct_key(key), nil_key(key), missing_key(key)].join('||')
-        end
-
-        def direct_key(key)
-          "((t = v[#{key}]) && t.respond_to?(:call) ? t.call : t)"
-        end
-
-        def nil_key(key)
-          "(v.has_key?(#{key}) && '')"
-        end
-
-        def missing_key(key)
-          "I18n.config.missing_interpolation_argument_handler.call(#{key}, v, self)"
-        end
-
-        def reserved_key(key)
-          "raise(ReservedInterpolationKey.new(#{key}, self))"
-        end
-
-        def escape_plain_str(str)
-          str.gsub(/"|\\|#/) {|x| "\\#{x}"}
-        end
-
-        def escape_key_sym(key)
-          # rely on Ruby to do all the hard work :)
-          key.to_sym.inspect
-        end
-      end
-
-      def interpolate(locale, string, values)
-        if string.respond_to?(:i18n_interpolate)
-          string.i18n_interpolate(values)
-        elsif values
-          super
-        else
-          string
-        end
-      end
-
-      def store_translations(locale, data, options = EMPTY_HASH)
-        compile_all_strings_in(data)
-        super
-      end
-
-      protected
-      def compile_all_strings_in(data)
-        data.each_value do |value|
-          Compiler.compile_if_an_interpolation(value)
-          compile_all_strings_in(value) if value.kind_of?(Hash)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/key_value.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/key_value.rb
deleted file mode 100644
index b937e253a893c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/key_value.rb
+++ /dev/null
@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-
-require 'i18n/backend/base'
-
-module I18n
-
-  begin
-    require 'oj'
-    class JSON
-      class << self
-        def encode(value)
-          Oj::Rails.encode(value)
-        end
-        def decode(value)
-          Oj.load(value)
-        end
-      end
-    end
-  rescue LoadError
-    require 'active_support/json'
-    JSON = ActiveSupport::JSON
-  end
-
-  module Backend
-    # This is a basic backend for key value stores. It receives on
-    # initialization the store, which should respond to three methods:
-    #
-    # * store#[](key)         - Used to get a value
-    # * store#[]=(key, value) - Used to set a value
-    # * store#keys            - Used to get all keys
-    #
-    # Since these stores only supports string, all values are converted
-    # to JSON before being stored, allowing it to also store booleans,
-    # hashes and arrays. However, this store does not support Procs.
-    #
-    # As the ActiveRecord backend, Symbols are just supported when loading
-    # translations from the filesystem or through explicit store translations.
-    #
-    # Also, avoid calling I18n.available_locales since it's a somehow
-    # expensive operation in most stores.
-    #
-    # == Example
-    #
-    # To setup I18n to use TokyoCabinet in memory is quite straightforward:
-    #
-    #   require 'rufus/tokyo/cabinet' # gem install rufus-tokyo
-    #   I18n.backend = I18n::Backend::KeyValue.new(Rufus::Tokyo::Cabinet.new('*'))
-    #
-    # == Performance
-    #
-    # You may make this backend even faster by including the Memoize module.
-    # However, notice that you should properly clear the cache if you change
-    # values directly in the key-store.
-    #
-    # == Subtrees
-    #
-    # In most backends, you are allowed to retrieve part of a translation tree:
-    #
-    #   I18n.backend.store_translations :en, :foo => { :bar => :baz }
-    #   I18n.t "foo" #=> { :bar => :baz }
-    #
-    # This backend supports this feature by default, but it slows down the storage
-    # of new data considerably and makes hard to delete entries. That said, you are
-    # allowed to disable the storage of subtrees on initialization:
-    #
-    #   I18n::Backend::KeyValue.new(@store, false)
-    #
-    # This is useful if you are using a KeyValue backend chained to a Simple backend.
-    class KeyValue
-      module Implementation
-        attr_accessor :store
-
-        include Base, Flatten
-
-        def initialize(store, subtrees=true)
-          @store, @subtrees = store, subtrees
-        end
-
-        def initialized?
-          !@store.nil?
-        end
-
-        def store_translations(locale, data, options = EMPTY_HASH)
-          escape = options.fetch(:escape, true)
-          flatten_translations(locale, data, escape, @subtrees).each do |key, value|
-            key = "#{locale}.#{key}"
-
-            case value
-            when Hash
-              if @subtrees && (old_value = @store[key])
-                old_value = JSON.decode(old_value)
-                value = Utils.deep_merge!(Utils.deep_symbolize_keys(old_value), value) if old_value.is_a?(Hash)
-              end
-            when Proc
-              raise "Key-value stores cannot handle procs"
-            end
-
-            @store[key] = JSON.encode(value) unless value.is_a?(Symbol)
-          end
-        end
-
-        def available_locales
-          locales = @store.keys.map { |k| k =~ /\./; $` }
-          locales.uniq!
-          locales.compact!
-          locales.map! { |k| k.to_sym }
-          locales
-        end
-
-      protected
-
-        # Queries the translations from the key-value store and converts
-        # them into a hash such as the one returned from loading the
-        # haml files
-        def translations
-          @translations = Utils.deep_symbolize_keys(@store.keys.clone.map do |main_key|
-            main_value = JSON.decode(@store[main_key])
-            main_key.to_s.split(".").reverse.inject(main_value) do |value, key|
-              {key.to_sym => value}
-            end
-          end.inject{|hash, elem| Utils.deep_merge!(hash, elem)})
-        end
-
-        def init_translations
-          # NO OP
-          # This call made also inside Simple Backend and accessed by
-          # other plugins like I18n-js and babilu and
-          # to use it along with the Chain backend we need to
-          # provide a uniform API even for protected methods :S
-        end
-
-        def subtrees?
-          @subtrees
-        end
-
-        def lookup(locale, key, scope = [], options = EMPTY_HASH)
-          key   = normalize_flat_keys(locale, key, scope, options[:separator])
-          value = @store["#{locale}.#{key}"]
-          value = JSON.decode(value) if value
-
-          if value.is_a?(Hash)
-            Utils.deep_symbolize_keys(value)
-          elsif !value.nil?
-            value
-          elsif !@subtrees
-            SubtreeProxy.new("#{locale}.#{key}", @store)
-          end
-        end
-
-        def pluralize(locale, entry, count)
-          if subtrees?
-            super
-          else
-            return entry unless entry.is_a?(Hash)
-            key = pluralization_key(entry, count)
-            entry[key]
-          end
-        end
-      end
-
-      class SubtreeProxy
-        def initialize(master_key, store)
-          @master_key = master_key
-          @store = store
-          @subtree = nil
-        end
-
-        def has_key?(key)
-          @subtree && @subtree.has_key?(key) || self[key]
-        end
-
-        def [](key)
-          unless @subtree && value = @subtree[key]
-            value = @store["#{@master_key}.#{key}"]
-            if value
-              value = JSON.decode(value)
-              (@subtree ||= {})[key] = value
-            end
-          end
-          value
-        end
-
-        def is_a?(klass)
-          Hash == klass || super
-        end
-        alias :kind_of? :is_a?
-
-        def instance_of?(klass)
-          Hash == klass || super
-        end
-
-        def nil?
-          @subtree.nil?
-        end
-
-        def inspect
-          @subtree.inspect
-        end
-      end
-
-      include Implementation
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/lazy_loadable.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/lazy_loadable.rb
deleted file mode 100644
index 60f21fa12d062..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/lazy_loadable.rb
+++ /dev/null
@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-
-module I18n
-  module Backend
-    # Backend that lazy loads translations based on the current locale. This
-    # implementation avoids loading all translations up front. Instead, it only
-    # loads the translations that belong to the current locale. This offers a
-    # performance incentive in local development and test environments for
-    # applications with many translations for many different locales. It's
-    # particularly useful when the application only refers to a single locales'
-    # translations at a time (ex. A Rails workload).  The implementation
-    # identifies which translation files from the load path belong to the
-    # current locale by pattern matching against their path name.
-    #
-    # Specifically, a translation file is considered to belong to a locale if:
-    # a) the filename is in the I18n load path
-    # b) the filename ends in a supported extension (ie. .yml, .json, .po, .rb)
-    # c) the filename starts with the locale identifier
-    # d) the locale identifier and optional proceeding text is separated by an underscore, ie. "_".
-    #
-    # Examples:
-    # Valid files that will be selected by this backend:
-    #
-    # "files/locales/en_translation.yml" (Selected for locale "en")
-    # "files/locales/fr.po"  (Selected for locale "fr")
-    #
-    # Invalid files that won't be selected by this backend:
-    #
-    # "files/locales/translation-file"
-    # "files/locales/en-translation.unsupported"
-    # "files/locales/french/translation.yml"
-    # "files/locales/fr/translation.yml"
-    #
-    # The implementation uses this assumption to defer the loading of
-    # translation files until the current locale actually requires them.
-    #
-    # The backend has two working modes: lazy_load and eager_load.
-    #
-    # Note: This backend should only be enabled in test environments!
-    # When the mode is set to false, the backend behaves exactly like the
-    # Simple backend, with an additional check that the paths being loaded
-    # abide by the format. If paths can't be matched to the format, an error is raised.
-    #
-    # You can configure lazy loaded backends through the initializer or backends
-    # accessor:
-    #
-    #   # In test environments
-    #
-    #   I18n.backend = I18n::Backend::LazyLoadable.new(lazy_load: true)
-    #
-    #   # In other environments, such as production and CI
-    #
-    #   I18n.backend = I18n::Backend::LazyLoadable.new(lazy_load: false) # default
-    #
-    class LocaleExtractor
-      class << self
-        def locale_from_path(path)
-          name = File.basename(path, ".*")
-          locale = name.split("_").first
-          locale.to_sym unless locale.nil?
-        end
-      end
-    end
-
-    class LazyLoadable < Simple
-      def initialize(lazy_load: false)
-        @lazy_load = lazy_load
-      end
-
-      # Returns whether the current locale is initialized.
-      def initialized?
-        if lazy_load?
-          initialized_locales[I18n.locale]
-        else
-          super
-        end
-      end
-
-      # Clean up translations and uninitialize all locales.
-      def reload!
-        if lazy_load?
-          @initialized_locales = nil
-          @translations = nil
-        else
-          super
-        end
-      end
-
-      # Eager loading is not supported in the lazy context.
-      def eager_load!
-        if lazy_load?
-          raise UnsupportedMethod.new(__method__, self.class, "Cannot eager load translations because backend was configured with lazy_load: true.")
-        else
-          super
-        end
-      end
-
-      # Parse the load path and extract all locales.
-      def available_locales
-        if lazy_load?
-          I18n.load_path.map { |path| LocaleExtractor.locale_from_path(path) }
-        else
-          super
-        end
-      end
-
-      def lookup(locale, key, scope = [], options = EMPTY_HASH)
-        if lazy_load?
-          I18n.with_locale(locale) do
-            super
-          end
-        else
-          super
-        end
-      end
-
-      protected
-
-
-      # Load translations from files that belong to the current locale.
-      def init_translations
-        file_errors = if lazy_load?
-          initialized_locales[I18n.locale] = true
-          load_translations_and_collect_file_errors(filenames_for_current_locale)
-        else
-          @initialized = true
-          load_translations_and_collect_file_errors(I18n.load_path)
-        end
-
-        raise InvalidFilenames.new(file_errors) unless file_errors.empty?
-      end
-
-      def initialized_locales
-        @initialized_locales ||= Hash.new(false)
-      end
-
-      private
-
-      def lazy_load?
-        @lazy_load
-      end
-
-      class FilenameIncorrect < StandardError
-        def initialize(file, expected_locale, unexpected_locales)
-          super "#{file} can only load translations for \"#{expected_locale}\". Found translations for: #{unexpected_locales}."
-        end
-      end
-
-      # Loads each file supplied and asserts that the file only loads
-      # translations as expected by the name. The method returns a list of
-      # errors corresponding to offending files.
-      def load_translations_and_collect_file_errors(files)
-        errors = []
-
-        load_translations(files) do |file, loaded_translations|
-          assert_file_named_correctly!(file, loaded_translations)
-        rescue FilenameIncorrect => e
-          errors << e
-        end
-
-        errors
-      end
-
-      # Select all files from I18n load path that belong to current locale.
-      # These files must start with the locale identifier (ie. "en", "pt-BR"),
-      # followed by an "_" demarcation to separate proceeding text.
-      def filenames_for_current_locale
-        I18n.load_path.flatten.select do |path|
-          LocaleExtractor.locale_from_path(path) == I18n.locale
-        end
-      end
-
-      # Checks if a filename is named in correspondence to the translations it loaded.
-      # The locale extracted from the path must be the single locale loaded in the translations.
-      def assert_file_named_correctly!(file, translations)
-        loaded_locales = translations.keys.map(&:to_sym)
-        expected_locale = LocaleExtractor.locale_from_path(file)
-        unexpected_locales = loaded_locales.reject { |locale| locale == expected_locale }
-
-        raise FilenameIncorrect.new(file, expected_locale, unexpected_locales) unless unexpected_locales.empty?
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/memoize.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/memoize.rb
deleted file mode 100644
index 3293d2b4273d8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/memoize.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-# Memoize module simply memoizes the values returned by lookup using
-# a flat hash and can tremendously speed up the lookup process in a backend.
-#
-# To enable it you can simply include the Memoize module to your backend:
-#
-#   I18n::Backend::Simple.include(I18n::Backend::Memoize)
-#
-# Notice that it's the responsibility of the backend to define whenever the
-# cache should be cleaned.
-module I18n
-  module Backend
-    module Memoize
-      def available_locales
-        @memoized_locales ||= super
-      end
-
-      def store_translations(locale, data, options = EMPTY_HASH)
-        reset_memoizations!(locale)
-        super
-      end
-
-      def reload!
-        reset_memoizations!
-        super
-      end
-
-      def eager_load!
-        memoized_lookup
-        available_locales
-        super
-      end
-
-      protected
-
-        def lookup(locale, key, scope = nil, options = EMPTY_HASH)
-          flat_key  = I18n::Backend::Flatten.normalize_flat_keys(locale,
-            key, scope, options[:separator]).to_sym
-          flat_hash = memoized_lookup[locale.to_sym]
-          flat_hash.key?(flat_key) ? flat_hash[flat_key] : (flat_hash[flat_key] = super)
-        end
-
-        def memoized_lookup
-          @memoized_lookup ||= I18n.new_double_nested_cache
-        end
-
-        def reset_memoizations!(locale=nil)
-          @memoized_locales = nil
-          (locale ? memoized_lookup[locale.to_sym] : memoized_lookup).clear
-        end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/metadata.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/metadata.rb
deleted file mode 100644
index 51ea7a2a8875a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/metadata.rb
+++ /dev/null
@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-# I18n translation metadata is useful when you want to access information
-# about how a translation was looked up, pluralized or interpolated in
-# your application.
-#
-#   msg = I18n.t(:message, :default => 'Hi!', :scope => :foo)
-#   msg.translation_metadata
-#   # => { :key => :message, :scope => :foo, :default => 'Hi!' }
-#
-# If a :count option was passed to #translate it will be set to the metadata.
-# Likewise, if any interpolation variables were passed they will also be set.
-#
-# To enable translation metadata you can simply include the Metadata module
-# into the Simple backend class - or whatever other backend you are using:
-#
-#   I18n::Backend::Simple.include(I18n::Backend::Metadata)
-#
-module I18n
-  module Backend
-    module Metadata
-      class << self
-        def included(base)
-          Object.class_eval do
-            def translation_metadata
-              unless self.frozen?
-                @translation_metadata ||= {}
-              else
-                {}
-              end
-            end
-
-            def translation_metadata=(translation_metadata)
-              @translation_metadata = translation_metadata unless self.frozen?
-            end
-          end unless Object.method_defined?(:translation_metadata)
-        end
-      end
-
-      def translate(locale, key, options = EMPTY_HASH)
-        metadata = {
-          :locale    => locale,
-          :key       => key,
-          :scope     => options[:scope],
-          :default   => options[:default],
-          :separator => options[:separator],
-          :values    => options.reject { |name, _value| RESERVED_KEYS.include?(name) }
-        }
-        with_metadata(metadata) { super }
-      end
-
-      def interpolate(locale, entry, values = EMPTY_HASH)
-        metadata = entry.translation_metadata.merge(:original => entry)
-        with_metadata(metadata) { super }
-      end
-
-      def pluralize(locale, entry, count)
-        with_metadata(:count => count) { super }
-      end
-
-      protected
-
-        def with_metadata(metadata, &block)
-          result = yield
-          result.translation_metadata = result.translation_metadata.merge(metadata) if result
-          result
-        end
-
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/pluralization.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/pluralization.rb
deleted file mode 100644
index b60265711fb93..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/pluralization.rb
+++ /dev/null
@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-# I18n Pluralization are useful when you want your application to
-# customize pluralization rules.
-#
-# To enable locale specific pluralizations you can simply include the
-# Pluralization module to the Simple backend - or whatever other backend you
-# are using.
-#
-#   I18n::Backend::Simple.include(I18n::Backend::Pluralization)
-#
-# You also need to make sure to provide pluralization algorithms to the
-# backend, i.e. include them to your I18n.load_path accordingly.
-module I18n
-  module Backend
-    module Pluralization
-      # Overwrites the Base backend translate method so that it will check the
-      # translation meta data space (:i18n) for a locale specific pluralization
-      # rule and use it to pluralize the given entry. I.e. the library expects
-      # pluralization rules to be stored at I18n.t(:'i18n.plural.rule')
-      #
-      # Pluralization rules are expected to respond to #call(count) and
-      # return a pluralization key. Valid keys depend on the translation data
-      # hash (entry) but it is generally recommended to follow CLDR's style,
-      # i.e., return one of the keys :zero, :one, :few, :many, :other.
-      #
-      # The :zero key is always picked directly when count equals 0 AND the
-      # translation data has the key :zero. This way translators are free to
-      # either pick a special :zero translation even for languages where the
-      # pluralizer does not return a :zero key.
-      def pluralize(locale, entry, count)
-        return entry unless entry.is_a?(Hash) && count
-
-        pluralizer = pluralizer(locale)
-        if pluralizer.respond_to?(:call)
-          key = count == 0 && entry.has_key?(:zero) ? :zero : pluralizer.call(count)
-          raise InvalidPluralizationData.new(entry, count, key) unless entry.has_key?(key)
-          entry[key]
-        else
-          super
-        end
-      end
-
-      protected
-
-        def pluralizers
-          @pluralizers ||= {}
-        end
-
-        def pluralizer(locale)
-          pluralizers[locale] ||= I18n.t(:'i18n.plural.rule', :locale => locale, :resolve => false)
-        end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/simple.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/simple.rb
deleted file mode 100644
index 0c49de8f921b6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/simple.rb
+++ /dev/null
@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-require 'i18n/backend/base'
-
-module I18n
-  module Backend
-    # A simple backend that reads translations from YAML files and stores them in
-    # an in-memory hash. Relies on the Base backend.
-    #
-    # The implementation is provided by a Implementation module allowing to easily
-    # extend Simple backend's behavior by including modules. E.g.:
-    #
-    # module I18n::Backend::Pluralization
-    #   def pluralize(*args)
-    #     # extended pluralization logic
-    #     super
-    #   end
-    # end
-    #
-    # I18n::Backend::Simple.include(I18n::Backend::Pluralization)
-    class Simple
-      module Implementation
-        include Base
-
-        def initialized?
-          @initialized ||= false
-        end
-
-        # Stores translations for the given locale in memory.
-        # This uses a deep merge for the translations hash, so existing
-        # translations will be overwritten by new ones only at the deepest
-        # level of the hash.
-        def store_translations(locale, data, options = EMPTY_HASH)
-          if I18n.enforce_available_locales &&
-            I18n.available_locales_initialized? &&
-            !I18n.locale_available?(locale)
-            return data
-          end
-          locale = locale.to_sym
-          translations[locale] ||= Concurrent::Hash.new
-          data = Utils.deep_symbolize_keys(data) unless options.fetch(:skip_symbolize_keys, false)
-          Utils.deep_merge!(translations[locale], data)
-        end
-
-        # Get available locales from the translations hash
-        def available_locales
-          init_translations unless initialized?
-          translations.inject([]) do |locales, (locale, data)|
-            locales << locale unless data.size <= 1 && (data.empty? || data.has_key?(:i18n))
-            locales
-          end
-        end
-
-        # Clean up translations hash and set initialized to false on reload!
-        def reload!
-          @initialized = false
-          @translations = nil
-          super
-        end
-
-        def eager_load!
-          init_translations unless initialized?
-          super
-        end
-
-        def translations(do_init: false)
-          # To avoid returning empty translations,
-          # call `init_translations`
-          init_translations if do_init && !initialized?
-
-          @translations ||= Concurrent::Hash.new { |h, k| h[k] = Concurrent::Hash.new }
-        end
-
-      protected
-
-        def init_translations
-          load_translations
-          @initialized = true
-        end
-
-        # Looks up a translation from the translations hash. Returns nil if
-        # either key is nil, or locale, scope or key do not exist as a key in the
-        # nested translations hash. Splits keys or scopes containing dots
-        # into multiple keys, i.e. <tt>currency.format</tt> is regarded the same as
-        # <tt>%w(currency format)</tt>.
-        def lookup(locale, key, scope = [], options = EMPTY_HASH)
-          init_translations unless initialized?
-          keys = I18n.normalize_keys(locale, key, scope, options[:separator])
-
-          keys.inject(translations) do |result, _key|
-            return nil unless result.is_a?(Hash)
-            unless result.has_key?(_key)
-              _key = _key.to_s.to_sym
-              return nil unless result.has_key?(_key)
-            end
-            result = result[_key]
-            result = resolve_entry(locale, _key, result, options.merge(:scope => nil)) if result.is_a?(Symbol)
-            result
-          end
-        end
-      end
-
-      include Implementation
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/transliterator.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/transliterator.rb
deleted file mode 100644
index bb704ab7a0594..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/backend/transliterator.rb
+++ /dev/null
@@ -1,108 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module I18n
-  module Backend
-    module Transliterator
-      DEFAULT_REPLACEMENT_CHAR = "?"
-
-      # Given a locale and a UTF-8 string, return the locale's ASCII
-      # approximation for the string.
-      def transliterate(locale, string, replacement = nil)
-        @transliterators ||= {}
-        @transliterators[locale] ||= Transliterator.get I18n.t(:'i18n.transliterate.rule',
-          :locale => locale, :resolve => false, :default => {})
-        @transliterators[locale].transliterate(string, replacement)
-      end
-
-      # Get a transliterator instance.
-      def self.get(rule = nil)
-        if !rule || rule.kind_of?(Hash)
-          HashTransliterator.new(rule)
-        elsif rule.kind_of? Proc
-          ProcTransliterator.new(rule)
-        else
-          raise I18n::ArgumentError, "Transliteration rule must be a proc or a hash."
-        end
-      end
-
-      # A transliterator which accepts a Proc as its transliteration rule.
-      class ProcTransliterator
-        def initialize(rule)
-          @rule = rule
-        end
-
-        def transliterate(string, replacement = nil)
-          @rule.call(string)
-        end
-      end
-
-      # A transliterator which accepts a Hash of characters as its translation
-      # rule.
-      class HashTransliterator
-        DEFAULT_APPROXIMATIONS = {
-          "À"=>"A", "Á"=>"A", "Â"=>"A", "Ã"=>"A", "Ä"=>"A", "Å"=>"A", "Æ"=>"AE",
-          "Ç"=>"C", "È"=>"E", "É"=>"E", "Ê"=>"E", "Ë"=>"E", "Ì"=>"I", "Í"=>"I",
-          "Î"=>"I", "Ï"=>"I", "Ð"=>"D", "Ñ"=>"N", "Ò"=>"O", "Ó"=>"O", "Ô"=>"O",
-          "Õ"=>"O", "Ö"=>"O", "×"=>"x", "Ø"=>"O", "Ù"=>"U", "Ú"=>"U", "Û"=>"U",
-          "Ü"=>"U", "Ý"=>"Y", "Þ"=>"Th", "ß"=>"ss", "à"=>"a", "á"=>"a", "â"=>"a",
-          "ã"=>"a", "ä"=>"a", "å"=>"a", "æ"=>"ae", "ç"=>"c", "è"=>"e", "é"=>"e",
-          "ê"=>"e", "ë"=>"e", "ì"=>"i", "í"=>"i", "î"=>"i", "ï"=>"i", "ð"=>"d",
-          "ñ"=>"n", "ò"=>"o", "ó"=>"o", "ô"=>"o", "õ"=>"o", "ö"=>"o", "ø"=>"o",
-          "ù"=>"u", "ú"=>"u", "û"=>"u", "ü"=>"u", "ý"=>"y", "þ"=>"th", "ÿ"=>"y",
-          "Ā"=>"A", "ā"=>"a", "Ă"=>"A", "ă"=>"a", "Ą"=>"A", "ą"=>"a", "Ć"=>"C",
-          "ć"=>"c", "Ĉ"=>"C", "ĉ"=>"c", "Ċ"=>"C", "ċ"=>"c", "Č"=>"C", "č"=>"c",
-          "Ď"=>"D", "ď"=>"d", "Đ"=>"D", "đ"=>"d", "Ē"=>"E", "ē"=>"e", "Ĕ"=>"E",
-          "ĕ"=>"e", "Ė"=>"E", "ė"=>"e", "Ę"=>"E", "ę"=>"e", "Ě"=>"E", "ě"=>"e",
-          "Ĝ"=>"G", "ĝ"=>"g", "Ğ"=>"G", "ğ"=>"g", "Ġ"=>"G", "ġ"=>"g", "Ģ"=>"G",
-          "ģ"=>"g", "Ĥ"=>"H", "ĥ"=>"h", "Ħ"=>"H", "ħ"=>"h", "Ĩ"=>"I", "ĩ"=>"i",
-          "Ī"=>"I", "ī"=>"i", "Ĭ"=>"I", "ĭ"=>"i", "Į"=>"I", "į"=>"i", "İ"=>"I",
-          "ı"=>"i", "IJ"=>"IJ", "ij"=>"ij", "Ĵ"=>"J", "ĵ"=>"j", "Ķ"=>"K", "ķ"=>"k",
-          "ĸ"=>"k", "Ĺ"=>"L", "ĺ"=>"l", "Ļ"=>"L", "ļ"=>"l", "Ľ"=>"L", "ľ"=>"l",
-          "Ŀ"=>"L", "ŀ"=>"l", "Ł"=>"L", "ł"=>"l", "Ń"=>"N", "ń"=>"n", "Ņ"=>"N",
-          "ņ"=>"n", "Ň"=>"N", "ň"=>"n", "ʼn"=>"'n", "Ŋ"=>"NG", "ŋ"=>"ng",
-          "Ō"=>"O", "ō"=>"o", "Ŏ"=>"O", "ŏ"=>"o", "Ő"=>"O", "ő"=>"o", "Œ"=>"OE",
-          "œ"=>"oe", "Ŕ"=>"R", "ŕ"=>"r", "Ŗ"=>"R", "ŗ"=>"r", "Ř"=>"R", "ř"=>"r",
-          "Ś"=>"S", "ś"=>"s", "Ŝ"=>"S", "ŝ"=>"s", "Ş"=>"S", "ş"=>"s", "Š"=>"S",
-          "š"=>"s", "Ţ"=>"T", "ţ"=>"t", "Ť"=>"T", "ť"=>"t", "Ŧ"=>"T", "ŧ"=>"t",
-          "Ũ"=>"U", "ũ"=>"u", "Ū"=>"U", "ū"=>"u", "Ŭ"=>"U", "ŭ"=>"u", "Ů"=>"U",
-          "ů"=>"u", "Ű"=>"U", "ű"=>"u", "Ų"=>"U", "ų"=>"u", "Ŵ"=>"W", "ŵ"=>"w",
-          "Ŷ"=>"Y", "ŷ"=>"y", "Ÿ"=>"Y", "Ź"=>"Z", "ź"=>"z", "Ż"=>"Z", "ż"=>"z",
-          "Ž"=>"Z", "ž"=>"z"
-        }.freeze
-
-        def initialize(rule = nil)
-          @rule = rule
-          add_default_approximations
-          add rule if rule
-        end
-
-        def transliterate(string, replacement = nil)
-          replacement ||= DEFAULT_REPLACEMENT_CHAR
-          string.gsub(/[^\x00-\x7f]/u) do |char|
-            approximations[char] || replacement
-          end
-        end
-
-        private
-
-        def approximations
-          @approximations ||= {}
-        end
-
-        def add_default_approximations
-          DEFAULT_APPROXIMATIONS.each do |key, value|
-            approximations[key] = value
-          end
-        end
-
-        # Add transliteration rules to the approximations hash.
-        def add(hash)
-          hash.each do |key, value|
-            approximations[key.to_s] = value.to_s
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/config.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/config.rb
deleted file mode 100644
index 9878e02e708c5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/config.rb
+++ /dev/null
@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-module I18n
-  class Config
-    # The only configuration value that is not global and scoped to thread is :locale.
-    # It defaults to the default_locale.
-    def locale
-      defined?(@locale) && @locale != nil ? @locale : default_locale
-    end
-
-    # Sets the current locale pseudo-globally, i.e. in the Thread.current hash.
-    def locale=(locale)
-      I18n.enforce_available_locales!(locale)
-      @locale = locale && locale.to_sym
-    end
-
-    # Returns the current backend. Defaults to +Backend::Simple+.
-    def backend
-      @@backend ||= Backend::Simple.new
-    end
-
-    # Sets the current backend. Used to set a custom backend.
-    def backend=(backend)
-      @@backend = backend
-    end
-
-    # Returns the current default locale. Defaults to :'en'
-    def default_locale
-      @@default_locale ||= :en
-    end
-
-    # Sets the current default locale. Used to set a custom default locale.
-    def default_locale=(locale)
-      I18n.enforce_available_locales!(locale)
-      @@default_locale = locale && locale.to_sym
-    end
-
-    # Returns an array of locales for which translations are available.
-    # Unless you explicitly set these through I18n.available_locales=
-    # the call will be delegated to the backend.
-    def available_locales
-      @@available_locales ||= nil
-      @@available_locales || backend.available_locales
-    end
-
-    # Caches the available locales list as both strings and symbols in a Set, so
-    # that we can have faster lookups to do the available locales enforce check.
-    def available_locales_set #:nodoc:
-      @@available_locales_set ||= available_locales.inject(Set.new) do |set, locale|
-        set << locale.to_s << locale.to_sym
-      end
-    end
-
-    # Sets the available locales.
-    def available_locales=(locales)
-      @@available_locales = Array(locales).map { |locale| locale.to_sym }
-      @@available_locales = nil if @@available_locales.empty?
-      @@available_locales_set = nil
-    end
-
-    # Returns true if the available_locales have been initialized
-    def available_locales_initialized?
-      ( !!defined?(@@available_locales) && !!@@available_locales )
-    end
-
-    # Clears the available locales set so it can be recomputed again after I18n
-    # gets reloaded.
-    def clear_available_locales_set #:nodoc:
-      @@available_locales_set = nil
-    end
-
-    # Returns the current default scope separator. Defaults to '.'
-    def default_separator
-      @@default_separator ||= '.'
-    end
-
-    # Sets the current default scope separator.
-    def default_separator=(separator)
-      @@default_separator = separator
-    end
-
-    # Returns the current exception handler. Defaults to an instance of
-    # I18n::ExceptionHandler.
-    def exception_handler
-      @@exception_handler ||= ExceptionHandler.new
-    end
-
-    # Sets the exception handler.
-    def exception_handler=(exception_handler)
-      @@exception_handler = exception_handler
-    end
-
-    # Returns the current handler for situations when interpolation argument
-    # is missing. MissingInterpolationArgument will be raised by default.
-    def missing_interpolation_argument_handler
-      @@missing_interpolation_argument_handler ||= lambda do |missing_key, provided_hash, string|
-        raise MissingInterpolationArgument.new(missing_key, provided_hash, string)
-      end
-    end
-
-    # Sets the missing interpolation argument handler. It can be any
-    # object that responds to #call. The arguments that will be passed to #call
-    # are the same as for MissingInterpolationArgument initializer. Use +Proc.new+
-    # if you don't care about arity.
-    #
-    # == Example:
-    # You can suppress raising an exception and return string instead:
-    #
-    #   I18n.config.missing_interpolation_argument_handler = Proc.new do |key|
-    #     "#{key} is missing"
-    #   end
-    def missing_interpolation_argument_handler=(exception_handler)
-      @@missing_interpolation_argument_handler = exception_handler
-    end
-
-    # Allow clients to register paths providing translation data sources. The
-    # backend defines acceptable sources.
-    #
-    # E.g. the provided SimpleBackend accepts a list of paths to translation
-    # files which are either named *.rb and contain plain Ruby Hashes or are
-    # named *.yml and contain YAML data. So for the SimpleBackend clients may
-    # register translation files like this:
-    #   I18n.load_path << 'path/to/locale/en.yml'
-    def load_path
-      @@load_path ||= []
-    end
-
-    # Sets the load path instance. Custom implementations are expected to
-    # behave like a Ruby Array.
-    def load_path=(load_path)
-      @@load_path = load_path
-      @@available_locales_set = nil
-      backend.reload!
-    end
-
-    # Whether or not to verify if locales are in the list of available locales.
-    # Defaults to true.
-    @@enforce_available_locales = true
-    def enforce_available_locales
-      @@enforce_available_locales
-    end
-
-    def enforce_available_locales=(enforce_available_locales)
-      @@enforce_available_locales = enforce_available_locales
-    end
-
-    # Returns the current interpolation patterns. Defaults to
-    # I18n::DEFAULT_INTERPOLATION_PATTERNS.
-    def interpolation_patterns
-      @@interpolation_patterns ||= I18n::DEFAULT_INTERPOLATION_PATTERNS.dup
-    end
-
-    # Sets the current interpolation patterns. Used to set a interpolation
-    # patterns.
-    #
-    # E.g. using {{}} as a placeholder like "{{hello}}, world!":
-    #
-    #   I18n.config.interpolation_patterns << /\{\{(\w+)\}\}/
-    def interpolation_patterns=(interpolation_patterns)
-      @@interpolation_patterns = interpolation_patterns
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/exceptions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/exceptions.rb
deleted file mode 100644
index 74db4d34fcf34..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/exceptions.rb
+++ /dev/null
@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require 'cgi'
-
-module I18n
-  class ExceptionHandler
-    def call(exception, _locale, _key, _options)
-      if exception.is_a?(MissingTranslation)
-        exception.message
-      else
-        raise exception
-      end
-    end
-  end
-
-  class ArgumentError < ::ArgumentError; end
-
-  class Disabled < ArgumentError
-    def initialize(method)
-      super(<<~MESSAGE)
-        I18n.#{method} is currently disabled, likely because your application is still in its loading phase.
-
-        This method is meant to display text in the user locale, so calling it before the user locale has
-        been set is likely to display text from the wrong locale to some users.
-
-        If you have a legitimate reason to access i18n data outside of the user flow, you can do so by passing
-        the desired locale explicitly with the `locale` argument, e.g. `I18n.#{method}(..., locale: :en)`
-      MESSAGE
-    end
-  end
-
-  class InvalidLocale < ArgumentError
-    attr_reader :locale
-    def initialize(locale)
-      @locale = locale
-      super "#{locale.inspect} is not a valid locale"
-    end
-  end
-
-  class InvalidLocaleData < ArgumentError
-    attr_reader :filename
-    def initialize(filename, exception_message)
-      @filename, @exception_message = filename, exception_message
-      super "can not load translations from #{filename}: #{exception_message}"
-    end
-  end
-
-  class MissingTranslation < ArgumentError
-    module Base
-      PERMITTED_KEYS = [:scope].freeze
-
-      attr_reader :locale, :key, :options
-
-      def initialize(locale, key, options = EMPTY_HASH)
-        @key, @locale, @options = key, locale, options.slice(*PERMITTED_KEYS)
-        options.each { |k, v| self.options[k] = v.inspect if v.is_a?(Proc) }
-      end
-
-      def keys
-        @keys ||= I18n.normalize_keys(locale, key, options[:scope]).tap do |keys|
-          keys << 'no key' if keys.size < 2
-        end
-      end
-
-      def message
-        "translation missing: #{keys.join('.')}"
-      end
-      alias :to_s :message
-
-      def to_exception
-        MissingTranslationData.new(locale, key, options)
-      end
-    end
-
-    include Base
-  end
-
-  class MissingTranslationData < ArgumentError
-    include MissingTranslation::Base
-  end
-
-  class InvalidPluralizationData < ArgumentError
-    attr_reader :entry, :count, :key
-    def initialize(entry, count, key)
-      @entry, @count, @key = entry, count, key
-      super "translation data #{entry.inspect} can not be used with :count => #{count}. key '#{key}' is missing."
-    end
-  end
-
-  class MissingInterpolationArgument < ArgumentError
-    attr_reader :key, :values, :string
-    def initialize(key, values, string)
-      @key, @values, @string = key, values, string
-      super "missing interpolation argument #{key.inspect} in #{string.inspect} (#{values.inspect} given)"
-    end
-  end
-
-  class ReservedInterpolationKey < ArgumentError
-    attr_reader :key, :string
-    def initialize(key, string)
-      @key, @string = key, string
-      super "reserved key #{key.inspect} used in #{string.inspect}"
-    end
-  end
-
-  class UnknownFileType < ArgumentError
-    attr_reader :type, :filename
-    def initialize(type, filename)
-      @type, @filename = type, filename
-      super "can not load translations from #{filename}, the file type #{type} is not known"
-    end
-  end
-
-  class UnsupportedMethod < ArgumentError
-    attr_reader :method, :backend_klass, :msg
-    def initialize(method, backend_klass, msg)
-      @method = method
-      @backend_klass = backend_klass
-      @msg = msg
-      super "#{backend_klass} does not support the ##{method} method. #{msg}"
-    end
-  end
-
-  class InvalidFilenames < ArgumentError
-    NUMBER_OF_ERRORS_SHOWN = 20
-    def initialize(file_errors)
-      super <<~MSG
-        Found #{file_errors.count} error(s).
-        The first #{[file_errors.count, NUMBER_OF_ERRORS_SHOWN].min} error(s):
-        #{file_errors.map(&:message).first(NUMBER_OF_ERRORS_SHOWN).join("\n")}
-
-        To use the LazyLoadable backend:
-        1. Filenames must start with the locale.
-        2. An underscore must separate the locale with any optional text that follows.
-        3. The file must only contain translation data for the single locale.
-
-        Example:
-        "/config/locales/fr.yml" which contains:
-        ```yml
-          fr:
-            dog:
-              chien
-        ```
-      MSG
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/gettext.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/gettext.rb
deleted file mode 100644
index 858daff44a871..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/gettext.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module I18n
-  module Gettext
-    PLURAL_SEPARATOR  = "\001"
-    CONTEXT_SEPARATOR = "\004"
-
-    autoload :Helpers, 'i18n/gettext/helpers'
-
-    @@plural_keys = { :en => [:one, :other] }
-
-    class << self
-      # returns an array of plural keys for the given locale or the whole hash
-      # of locale mappings to plural keys so that we can convert from gettext's
-      # integer-index based style
-      # TODO move this information to the pluralization module
-      def plural_keys(*args)
-        args.empty? ? @@plural_keys : @@plural_keys[args.first] || @@plural_keys[:en]
-      end
-
-      def extract_scope(msgid, separator)
-        scope = msgid.to_s.split(separator)
-        msgid = scope.pop
-        [scope, msgid]
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/gettext/helpers.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/gettext/helpers.rb
deleted file mode 100644
index d077619ff212f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/gettext/helpers.rb
+++ /dev/null
@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require 'i18n/gettext'
-
-module I18n
-  module Gettext
-    # Implements classical Gettext style accessors. To use this include the
-    # module to the global namespace or wherever you want to use it.
-    #
-    #   include I18n::Gettext::Helpers
-    module Helpers
-      # Makes dynamic translation messages readable for the gettext parser.
-      # <tt>_(fruit)</tt> cannot be understood by the gettext parser. To help the parser find all your translations,
-      # you can add <tt>fruit = N_("Apple")</tt> which does not translate, but tells the parser: "Apple" needs translation.
-      # * msgid: the message id.
-      # * Returns: msgid.
-      def N_(msgsid)
-        msgsid
-      end
-
-      def gettext(msgid, options = EMPTY_HASH)
-        I18n.t(msgid, **{:default => msgid, :separator => '|'}.merge(options))
-      end
-      alias _ gettext
-
-      def sgettext(msgid, separator = '|')
-        scope, msgid = I18n::Gettext.extract_scope(msgid, separator)
-        I18n.t(msgid, :scope => scope, :default => msgid, :separator => separator)
-      end
-      alias s_ sgettext
-
-      def pgettext(msgctxt, msgid)
-        separator = I18n::Gettext::CONTEXT_SEPARATOR
-        sgettext([msgctxt, msgid].join(separator), separator)
-      end
-      alias p_ pgettext
-
-      def ngettext(msgid, msgid_plural, n = 1)
-        nsgettext(msgid, msgid_plural, n)
-      end
-      alias n_ ngettext
-
-      # Method signatures:
-      #   nsgettext('Fruits|apple', 'apples', 2)
-      #   nsgettext(['Fruits|apple', 'apples'], 2)
-      def nsgettext(msgid, msgid_plural, n = 1, separator = '|')
-        if msgid.is_a?(Array)
-          msgid, msgid_plural, n, separator = msgid[0], msgid[1], msgid_plural, n
-          separator = '|' unless separator.is_a?(::String)
-        end
-
-        scope, msgid = I18n::Gettext.extract_scope(msgid, separator)
-        default = { :one => msgid, :other => msgid_plural }
-        I18n.t(msgid, :default => default, :count => n, :scope => scope, :separator => separator)
-      end
-      alias ns_ nsgettext
-
-      # Method signatures:
-      #   npgettext('Fruits', 'apple', 'apples', 2)
-      #   npgettext('Fruits', ['apple', 'apples'], 2)
-      def npgettext(msgctxt, msgid, msgid_plural, n = 1)
-        separator = I18n::Gettext::CONTEXT_SEPARATOR
-
-        if msgid.is_a?(Array)
-          msgid_plural, msgid, n = msgid[1], [msgctxt, msgid[0]].join(separator), msgid_plural
-        else
-          msgid = [msgctxt, msgid].join(separator)
-        end
-
-        nsgettext(msgid, msgid_plural, n, separator)
-      end
-      alias np_ npgettext
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/gettext/po_parser.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/gettext/po_parser.rb
deleted file mode 100644
index a07fdc5874911..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/gettext/po_parser.rb
+++ /dev/null
@@ -1,329 +0,0 @@
-=begin
-  poparser.rb - Generate a .mo
-
-  Copyright (C) 2003-2009 Masao Mutoh <mutoh at highway.ne.jp>
-
-  You may redistribute it and/or modify it under the same
-  license terms as Ruby.
-=end
-
-#MODIFIED
-# removed include GetText etc
-# added stub translation method _(x)
-require 'racc/parser'
-
-module GetText
-
-  class PoParser < Racc::Parser
-
-    def _(x)
-      x
-    end
-
-module_eval <<'..end src/poparser.ry modeval..id7a99570e05', 'src/poparser.ry', 108
-  def unescape(orig)
-    ret = orig.gsub(/\\n/, "\n")
-    ret.gsub!(/\\t/, "\t")
-    ret.gsub!(/\\r/, "\r")
-    ret.gsub!(/\\"/, "\"")
-    ret
-  end
-
-  def parse(str, data, ignore_fuzzy = true)
-    @comments = []
-    @data = data
-    @fuzzy = false
-    @msgctxt = ""
-    $ignore_fuzzy = ignore_fuzzy
-
-    str.strip!
-    @q = []
-    until str.empty? do
-      case str
-      when /\A\s+/
-	str = $'
-      when /\Amsgctxt/
-	@q.push [:MSGCTXT, $&]
-	str = $'
-      when /\Amsgid_plural/
-	@q.push [:MSGID_PLURAL, $&]
-	str = $'
-      when /\Amsgid/
-	@q.push [:MSGID, $&]
-	str = $'
-      when /\Amsgstr/
-	@q.push [:MSGSTR, $&]
-	str = $'
-      when /\A\[(\d+)\]/
-	@q.push [:PLURAL_NUM, $1]
-	str = $'
-      when /\A\#~(.*)/
-	$stderr.print _("Warning: obsolete msgid exists.\n")
-	$stderr.print "         #{$&}\n"
-	@q.push [:COMMENT, $&]
-	str = $'
-      when /\A\#(.*)/
-	@q.push [:COMMENT, $&]
-	str = $'
-      when /\A\"(.*)\"/
-	@q.push [:STRING, $1]
-	str = $'
-      else
-	#c = str[0,1]
-	#@q.push [:STRING, c]
-	str = str[1..-1]
-      end
-    end
-    @q.push [false, '$end']
-    if $DEBUG
-      @q.each do |a,b|
-      puts "[#{a}, #{b}]"
-      end
-    end
-    @yydebug = true if $DEBUG
-    do_parse
-
-    if @comments.size > 0
-      @data.set_comment(:last, @comments.join("\n"))
-    end
-    @data
-  end
-
-  def next_token
-    @q.shift
-  end
-
-  def on_message(msgid, msgstr)
-    if msgstr.size > 0
-      @data[msgid] = msgstr
-      @data.set_comment(msgid, @comments.join("\n"))
-    end
-    @comments.clear
-    @msgctxt = ""
-  end
-
-  def on_comment(comment)
-    @fuzzy = true if (/fuzzy/ =~ comment)
-    @comments << comment
-  end
-
-
-..end src/poparser.ry modeval..id7a99570e05
-
-##### racc 1.4.5 generates ###
-
-racc_reduce_table = [
- 0, 0, :racc_error,
- 0, 10, :_reduce_none,
- 2, 10, :_reduce_none,
- 2, 10, :_reduce_none,
- 2, 10, :_reduce_none,
- 2, 12, :_reduce_5,
- 1, 13, :_reduce_none,
- 1, 13, :_reduce_none,
- 4, 15, :_reduce_8,
- 5, 16, :_reduce_9,
- 2, 17, :_reduce_10,
- 1, 17, :_reduce_none,
- 3, 18, :_reduce_12,
- 1, 11, :_reduce_13,
- 2, 14, :_reduce_14,
- 1, 14, :_reduce_15 ]
-
-racc_reduce_n = 16
-
-racc_shift_n = 26
-
-racc_action_table = [
-     3,    13,     5,     7,     9,    15,    16,    17,    20,    17,
-    13,    17,    13,    13,    11,    17,    23,    20,    13,    17 ]
-
-racc_action_check = [
-     1,    16,     1,     1,     1,    12,    12,    12,    18,    18,
-     7,    14,    15,     9,     3,    19,    20,    21,    23,    25 ]
-
-racc_action_pointer = [
-   nil,     0,   nil,    14,   nil,   nil,   nil,     3,   nil,     6,
-   nil,   nil,     0,   nil,     4,     5,    -6,   nil,     2,     8,
-     8,    11,   nil,    11,   nil,    12 ]
-
-racc_action_default = [
-    -1,   -16,    -2,   -16,    -3,   -13,    -4,   -16,    -6,   -16,
-    -7,    26,   -16,   -15,    -5,   -16,   -16,   -14,   -16,    -8,
-   -16,    -9,   -11,   -16,   -10,   -12 ]
-
-racc_goto_table = [
-    12,    22,    14,     4,    24,     6,     2,     8,    18,    19,
-    10,    21,     1,   nil,   nil,   nil,    25 ]
-
-racc_goto_check = [
-     5,     9,     5,     3,     9,     4,     2,     6,     5,     5,
-     7,     8,     1,   nil,   nil,   nil,     5 ]
-
-racc_goto_pointer = [
-   nil,    12,     5,     2,     4,    -7,     6,     9,    -7,   -17 ]
-
-racc_goto_default = [
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil ]
-
-racc_token_table = {
- false => 0,
- Object.new => 1,
- :COMMENT => 2,
- :MSGID => 3,
- :MSGCTXT => 4,
- :MSGID_PLURAL => 5,
- :MSGSTR => 6,
- :STRING => 7,
- :PLURAL_NUM => 8 }
-
-racc_use_result_var = true
-
-racc_nt_base = 9
-
-Racc_arg = [
- racc_action_table,
- racc_action_check,
- racc_action_default,
- racc_action_pointer,
- racc_goto_table,
- racc_goto_check,
- racc_goto_default,
- racc_goto_pointer,
- racc_nt_base,
- racc_reduce_table,
- racc_token_table,
- racc_shift_n,
- racc_reduce_n,
- racc_use_result_var ]
-
-Racc_token_to_s_table = [
-'$end',
-'error',
-'COMMENT',
-'MSGID',
-'MSGCTXT',
-'MSGID_PLURAL',
-'MSGSTR',
-'STRING',
-'PLURAL_NUM',
-'$start',
-'msgfmt',
-'comment',
-'msgctxt',
-'message',
-'string_list',
-'single_message',
-'plural_message',
-'msgstr_plural',
-'msgstr_plural_line']
-
-Racc_debug_parser = true
-
-##### racc system variables end #####
-
- # reduce 0 omitted
-
- # reduce 1 omitted
-
- # reduce 2 omitted
-
- # reduce 3 omitted
-
- # reduce 4 omitted
-
-module_eval <<'.,.,', 'src/poparser.ry', 25
-  def _reduce_5( val, _values, result )
-    @msgctxt = unescape(val[1]) + "\004"
-   result
-  end
-.,.,
-
- # reduce 6 omitted
-
- # reduce 7 omitted
-
-module_eval <<'.,.,', 'src/poparser.ry', 48
-  def _reduce_8( val, _values, result )
-    if @fuzzy and $ignore_fuzzy
-      if val[1] != ""
-        $stderr.print _("Warning: fuzzy message was ignored.\n")
-        $stderr.print "         msgid '#{val[1]}'\n"
-      else
-        on_message('', unescape(val[3]))
-      end
-      @fuzzy = false
-    else
-      on_message(@msgctxt + unescape(val[1]), unescape(val[3]))
-    end
-    result = ""
-   result
-  end
-.,.,
-
-module_eval <<'.,.,', 'src/poparser.ry', 65
-  def _reduce_9( val, _values, result )
-    if @fuzzy and $ignore_fuzzy
-      if val[1] != ""
-        $stderr.print _("Warning: fuzzy message was ignored.\n")
-        $stderr.print "msgid = '#{val[1]}\n"
-      else
-        on_message('', unescape(val[3]))
-      end
-      @fuzzy = false
-    else
-      on_message(@msgctxt + unescape(val[1]) + "\000" + unescape(val[3]), unescape(val[4]))
-    end
-    result = ""
-   result
-  end
-.,.,
-
-module_eval <<'.,.,', 'src/poparser.ry', 76
-  def _reduce_10( val, _values, result )
-    if val[0].size > 0
-      result = val[0] + "\000" + val[1]
-    else
-      result = ""
-    end
-   result
-  end
-.,.,
-
- # reduce 11 omitted
-
-module_eval <<'.,.,', 'src/poparser.ry', 84
-  def _reduce_12( val, _values, result )
-    result = val[2]
-   result
-  end
-.,.,
-
-module_eval <<'.,.,', 'src/poparser.ry', 91
-  def _reduce_13( val, _values, result )
-    on_comment(val[0])
-   result
-  end
-.,.,
-
-module_eval <<'.,.,', 'src/poparser.ry', 99
-  def _reduce_14( val, _values, result )
-    result = val.delete_if{|item| item == ""}.join
-   result
-  end
-.,.,
-
-module_eval <<'.,.,', 'src/poparser.ry', 103
-  def _reduce_15( val, _values, result )
-    result = val[0]
-   result
-  end
-.,.,
-
- def _reduce_none( val, _values, result )
-  result
- end
-
-  end   # class PoParser
-
-end   # module GetText
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/interpolate/ruby.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/interpolate/ruby.rb
deleted file mode 100644
index dab8f0ed32efd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/interpolate/ruby.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# heavily based on Masao Mutoh's gettext String interpolation extension
-# http://github.com/mutoh/gettext/blob/f6566738b981fe0952548c421042ad1e0cdfb31e/lib/gettext/core_ext/string.rb
-
-module I18n
-  DEFAULT_INTERPOLATION_PATTERNS = [
-    /%%/,
-    /%\{([\w|]+)\}/,                            # matches placeholders like "%{foo} or %{foo|word}"
-    /%<(\w+)>([^\d]*?\d*\.?\d*[bBdiouxXeEfgGcps])/  # matches placeholders like "%<foo>.d"
-  ].freeze
-  INTERPOLATION_PATTERN = Regexp.union(DEFAULT_INTERPOLATION_PATTERNS)
-  deprecate_constant :INTERPOLATION_PATTERN
-
-  class << self
-    # Return String or raises MissingInterpolationArgument exception.
-    # Missing argument's logic is handled by I18n.config.missing_interpolation_argument_handler.
-    def interpolate(string, values)
-      raise ReservedInterpolationKey.new($1.to_sym, string) if string =~ I18n.reserved_keys_pattern
-      raise ArgumentError.new('Interpolation values must be a Hash.') unless values.kind_of?(Hash)
-      interpolate_hash(string, values)
-    end
-
-    def interpolate_hash(string, values)
-      string.gsub(Regexp.union(config.interpolation_patterns)) do |match|
-        if match == '%%'
-          '%'
-        else
-          key = ($1 || $2 || match.tr("%{}", "")).to_sym
-          value = if values.key?(key)
-                    values[key]
-                  else
-                    config.missing_interpolation_argument_handler.call(key, values, string)
-                  end
-          value = value.call(values) if value.respond_to?(:call)
-          $3 ? sprintf("%#{$3}", value) : value
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale.rb
deleted file mode 100644
index c4078e614b7a2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module I18n
-  module Locale
-  autoload :Fallbacks, 'i18n/locale/fallbacks'
-  autoload :Tag,       'i18n/locale/tag'
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/fallbacks.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/fallbacks.rb
deleted file mode 100644
index e30acc4340ac7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/fallbacks.rb
+++ /dev/null
@@ -1,97 +0,0 @@
-# Locale Fallbacks
-#
-# Extends the I18n module to hold a fallbacks instance which is set to an
-# instance of I18n::Locale::Fallbacks by default but can be swapped with a
-# different implementation.
-#
-# Locale fallbacks will compute a number of fallback locales for a given locale.
-# For example:
-#
-# <pre><code>
-# I18n.fallbacks[:"es-MX"] # => [:"es-MX", :es, :en] </code></pre>
-#
-# Locale fallbacks always fall back to
-#
-#   * all parent locales of a given locale (e.g. :es for :"es-MX") first,
-#   * the current default locales and all of their parents second
-#
-# The default locales are set to [] by default but can be set to something else.
-#
-# One can additionally add any number of additional fallback locales manually.
-# These will be added before the default locales to the fallback chain. For
-# example:
-#
-#   # using a custom locale as default fallback locale
-#
-#   I18n.fallbacks = I18n::Locale::Fallbacks.new(:"en-GB", :"de-AT" => :de, :"de-CH" => :de)
-#   I18n.fallbacks[:"de-AT"] # => [:"de-AT", :de, :"en-GB", :en]
-#   I18n.fallbacks[:"de-CH"] # => [:"de-CH", :de, :"en-GB", :en]
-#
-#   # mapping fallbacks to an existing instance
-#
-#   # people speaking Catalan also speak Spanish as spoken in Spain
-#   fallbacks = I18n.fallbacks
-#   fallbacks.map(:ca => :"es-ES")
-#   fallbacks[:ca] # => [:ca, :"es-ES", :es, :"en-US", :en]
-#
-#   # people speaking Arabian as spoken in Palestine also speak Hebrew as spoken in Israel
-#   fallbacks.map(:"ar-PS" => :"he-IL")
-#   fallbacks[:"ar-PS"] # => [:"ar-PS", :ar, :"he-IL", :he, :"en-US", :en]
-#   fallbacks[:"ar-EG"] # => [:"ar-EG", :ar, :"en-US", :en]
-#
-#   # people speaking Sami as spoken in Finland also speak Swedish and Finnish as spoken in Finland
-#   fallbacks.map(:sms => [:"se-FI", :"fi-FI"])
-#   fallbacks[:sms] # => [:sms, :"se-FI", :se, :"fi-FI", :fi, :"en-US", :en]
-
-module I18n
-  module Locale
-    class Fallbacks < Hash
-      def initialize(*mappings)
-        @map = {}
-        map(mappings.pop) if mappings.last.is_a?(Hash)
-        self.defaults = mappings.empty? ? [] : mappings
-      end
-
-      def defaults=(defaults)
-        @defaults = defaults.flat_map { |default| compute(default, false) }
-      end
-      attr_reader :defaults
-
-      def [](locale)
-        raise InvalidLocale.new(locale) if locale.nil?
-        raise Disabled.new('fallback#[]') if locale == false
-        locale = locale.to_sym
-        super || store(locale, compute(locale))
-      end
-
-      def map(*args, &block)
-        if args.count == 1 && !block_given?
-          mappings = args.first
-          mappings.each do |from, to|
-            from, to = from.to_sym, Array(to)
-            to.each do |_to|
-              @map[from] ||= []
-              @map[from] << _to.to_sym
-            end
-          end
-        else
-          @map.map(*args, &block)
-        end
-      end
-
-      protected
-
-      def compute(tags, include_defaults = true, exclude = [])
-        result = Array(tags).flat_map do |tag|
-          tags = I18n::Locale::Tag.tag(tag).self_and_parents.map! { |t| t.to_sym } - exclude
-          tags.each { |_tag| tags += compute(@map[_tag], false, exclude + tags) if @map[_tag] }
-          tags
-        end
-        result.push(*defaults) if include_defaults
-        result.uniq!
-        result.compact!
-        result
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/tag.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/tag.rb
deleted file mode 100644
index a640b4465f6c9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/tag.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-# encoding: utf-8
-
-module I18n
-  module Locale
-    module Tag
-      autoload :Parents, 'i18n/locale/tag/parents'
-      autoload :Rfc4646, 'i18n/locale/tag/rfc4646'
-      autoload :Simple,  'i18n/locale/tag/simple'
-
-      class << self
-        # Returns the current locale tag implementation. Defaults to +I18n::Locale::Tag::Simple+.
-        def implementation
-          @@implementation ||= Simple
-        end
-
-        # Sets the current locale tag implementation. Use this to set a different locale tag implementation.
-        def implementation=(implementation)
-          @@implementation = implementation
-        end
-
-        # Factory method for locale tags. Delegates to the current locale tag implementation.
-        def tag(tag)
-          implementation.tag(tag)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/tag/parents.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/tag/parents.rb
deleted file mode 100644
index 6283e667ff00f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/tag/parents.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-module I18n
-  module Locale
-    module Tag
-      module Parents
-        def parent
-          @parent ||=
-            begin
-              segs = to_a
-              segs.compact!
-              segs.length > 1 ? self.class.tag(*segs[0..(segs.length - 2)].join('-')) : nil
-            end
-        end
-
-        def self_and_parents
-          @self_and_parents ||= [self].concat parents
-        end
-
-        def parents
-          @parents ||= parent ? [parent].concat(parent.parents) : []
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/tag/rfc4646.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/tag/rfc4646.rb
deleted file mode 100644
index 4ce4c751ae11f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/tag/rfc4646.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-# RFC 4646/47 compliant Locale tag implementation that parses locale tags to
-# subtags such as language, script, region, variant etc.
-#
-# For more information see by http://en.wikipedia.org/wiki/IETF_language_tag
-#
-# Rfc4646::Parser does not implement grandfathered tags.
-
-module I18n
-  module Locale
-    module Tag
-      RFC4646_SUBTAGS = [ :language, :script, :region, :variant, :extension, :privateuse, :grandfathered ]
-      RFC4646_FORMATS = { :language => :downcase, :script => :capitalize, :region => :upcase, :variant => :downcase }
-
-      class Rfc4646 < Struct.new(*RFC4646_SUBTAGS)
-        class << self
-          # Parses the given tag and returns a Tag instance if it is valid.
-          # Returns false if the given tag is not valid according to RFC 4646.
-          def tag(tag)
-            matches = parser.match(tag)
-            new(*matches) if matches
-          end
-
-          def parser
-            @@parser ||= Rfc4646::Parser
-          end
-
-          def parser=(parser)
-            @@parser = parser
-          end
-        end
-
-        include Parents
-
-        RFC4646_FORMATS.each do |name, format|
-          define_method(name) { self[name].send(format) unless self[name].nil? }
-        end
-
-        def to_sym
-          to_s.to_sym
-        end
-
-        def to_s
-          @tag ||= to_a.compact.join("-")
-        end
-
-        def to_a
-          members.collect { |attr| self.send(attr) }
-        end
-
-        module Parser
-          PATTERN = %r{\A(?:
-            ([a-z]{2,3}(?:(?:-[a-z]{3}){0,3})?|[a-z]{4}|[a-z]{5,8}) # language
-            (?:-([a-z]{4}))?                                        # script
-            (?:-([a-z]{2}|\d{3}))?                                  # region
-            (?:-([0-9a-z]{5,8}|\d[0-9a-z]{3}))*                     # variant
-            (?:-([0-9a-wyz](?:-[0-9a-z]{2,8})+))*                   # extension
-            (?:-(x(?:-[0-9a-z]{1,8})+))?|                           # privateuse subtag
-            (x(?:-[0-9a-z]{1,8})+)|                                 # privateuse tag
-            /* ([a-z]{1,3}(?:-[0-9a-z]{2,8}){1,2}) */               # grandfathered
-            )\z}xi
-
-          class << self
-            def match(tag)
-              c = PATTERN.match(tag.to_s).captures
-              c[0..4] << (c[5].nil? ? c[6] : c[5])  << c[7] # TODO c[7] is grandfathered, throw a NotImplemented exception here?
-            rescue
-              false
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/tag/simple.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/tag/simple.rb
deleted file mode 100644
index 18d55c2861dda..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/locale/tag/simple.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# Simple Locale tag implementation that computes subtags by simply splitting
-# the locale tag at '-' occurrences.
-module I18n
-  module Locale
-    module Tag
-      class Simple
-        class << self
-          def tag(tag)
-            new(tag)
-          end
-        end
-
-        include Parents
-
-        attr_reader :tag
-
-        def initialize(*tag)
-          @tag = tag.join('-').to_sym
-        end
-
-        def subtags
-          @subtags = tag.to_s.split('-').map!(&:to_s)
-        end
-
-        def to_sym
-          tag
-        end
-
-        def to_s
-          tag.to_s
-        end
-
-        def to_a
-          subtags
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/middleware.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/middleware.rb
deleted file mode 100644
index 59b377e280cda..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/middleware.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module I18n
-  class Middleware
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      @app.call(env)
-    ensure
-      Thread.current[:i18n_config] = I18n::Config.new
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/utils.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/utils.rb
deleted file mode 100644
index 88415615f2de5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/utils.rb
+++ /dev/null
@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module I18n
-  module Utils
-    class << self
-      if Hash.method_defined?(:except)
-        def except(hash, *keys)
-          hash.except(*keys)
-        end
-      else
-        def except(hash, *keys)
-          hash = hash.dup
-          keys.each { |k| hash.delete(k) }
-          hash
-        end
-      end
-
-      def deep_merge(hash, other_hash, &block)
-        deep_merge!(hash.dup, other_hash, &block)
-      end
-
-      def deep_merge!(hash, other_hash, &block)
-        hash.merge!(other_hash) do |key, this_val, other_val|
-          if this_val.is_a?(Hash) && other_val.is_a?(Hash)
-            deep_merge(this_val, other_val, &block)
-          elsif block_given?
-            yield key, this_val, other_val
-          else
-            other_val
-          end
-        end
-      end
-
-      def deep_symbolize_keys(hash)
-        hash.each_with_object({}) do |(key, value), result|
-          result[key.respond_to?(:to_sym) ? key.to_sym : key] = deep_symbolize_keys_in_object(value)
-          result
-        end
-      end
-
-      private
-
-      def deep_symbolize_keys_in_object(value)
-        case value
-        when Hash
-          deep_symbolize_keys(value)
-        when Array
-          value.map { |e| deep_symbolize_keys_in_object(e) }
-        else
-          value
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/version.rb
deleted file mode 100644
index ad1591c91b623..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/i18n-1.12.0/lib/i18n/version.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module I18n
-  VERSION = "1.12.0"
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/mechanize-2.8.5/lib/mechanize/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/mechanize-2.8.5/lib/mechanize/version.rb
deleted file mode 100644
index 60a7e6e9331c4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/mechanize-2.8.5/lib/mechanize/version.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-class Mechanize
-  VERSION = "2.8.5"
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/alt_saver.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/alt_saver.rb
deleted file mode 100644
index 6f256995d9757..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/alt_saver.rb
+++ /dev/null
@@ -1,831 +0,0 @@
-# frozen_string_literal: true
-
-require 'elftools/constants'
-require 'elftools/elf_file'
-require 'elftools/structs'
-require 'elftools/util'
-require 'fileutils'
-
-require 'patchelf/helper'
-
-#:nodoc:
-module PatchELF
-  # TODO: refactor buf_* methods here
-  # TODO: move all refinements into a seperate file / helper file.
-  # refinements for cleaner syntax / speed / memory optimizations
-  module Refinements
-    refine StringIO do
-      # behaves like C memset. Equivalent to calling stream.write(char * nbytes)
-      # the benefit of preferring this over `stream.write(char * nbytes)` is only when data to be written is large.
-      # @param [String] char
-      # @param [Integer] nbytes
-      # @return[void]
-      def fill(char, nbytes)
-        at_once = Helper::PAGE_SIZE
-        pending = nbytes
-
-        if pending > at_once
-          to_write = char * at_once
-          while pending >= at_once
-            write(to_write)
-            pending -= at_once
-          end
-        end
-        write(char * pending) if pending.positive?
-      end
-    end
-  end
-  using Refinements
-
-  # Internal use only.
-  # alternative to +Saver+, that aims to be byte to byte equivalent with NixOS/patchelf.
-  #
-  # *DISCLAIMER*: This differs from +Saver+ in number of ways.  No lazy reading,
-  # inconsistent use of existing internal API(e.g: manual reading of data instead of calling +section.data+)
-  # @private
-  class AltSaver
-    attr_reader :in_file # @return [String] Input filename.
-    attr_reader :out_file # @return [String] Output filename.
-
-    # Instantiate a {AltSaver} object.
-    # the params passed are the same as the ones passed to +Saver+
-    # @param [String] in_file
-    # @param [String] out_file
-    # @param [{Symbol => String, Array}] set
-    def initialize(in_file, out_file, set)
-      @in_file = in_file
-      @out_file = out_file
-      @set = set
-
-      f = File.open(in_file, 'rb')
-      # the +@buffer+ and +@elf+ both could work on same +StringIO+ stream,
-      # the updating of @buffer in place blocks us from looking up old values.
-      # TODO: cache the values needed later, use same stream for +@buffer+ and +@elf+.
-      # also be sure to update the stream offset passed to Segments::Segment.
-      @elf = ELFTools::ELFFile.new(f)
-      @buffer = StringIO.new(f.tap(&:rewind).read) # StringIO makes easier to work with Bindata
-
-      @ehdr = @elf.header
-      @endian = @elf.endian
-      @elf_class = @elf.elf_class
-
-      @segments = @elf.segments # usage similar to phdrs
-      @sections = @elf.sections # usage similar to shdrs
-      update_section_idx!
-
-      # {String => String}
-      # section name to its data mapping
-      @replaced_sections = {}
-      @section_alignment = ehdr.e_phoff.num_bytes
-
-      # using the same environment flag as patchelf, makes it easier for debugging
-      Logger.level = ::Logger.const_get(ENV['PATCHELF_DEBUG'] ? :DEBUG : :WARN)
-    end
-
-    # @return [void]
-    def save!
-      @set.each { |mtd, val| send(:"modify_#{mtd}") if val }
-      rewrite_sections
-
-      FileUtils.cp(in_file, out_file) if out_file != in_file
-      patch_out
-      # Let output file have the same permission as input.
-      FileUtils.chmod(File.stat(in_file).mode, out_file)
-    end
-
-    private
-
-    attr_reader :ehdr, :endian, :elf_class
-
-    def old_sections
-      @old_sections ||= @elf.sections
-    end
-
-    def buf_cstr(off)
-      cstr = []
-      with_buf_at(off) do |buf|
-        loop do
-          c = buf.read 1
-          break if c.nil? || c == "\x00"
-
-          cstr.push c
-        end
-      end
-      cstr.join
-    end
-
-    def buf_move!(dst_idx, src_idx, n_bytes)
-      with_buf_at(src_idx) do |buf|
-        to_write = buf.read(n_bytes)
-        buf.seek dst_idx
-        buf.write to_write
-      end
-    end
-
-    def dynstr
-      find_section '.dynstr'
-    end
-
-    # yields dynamic tag, and offset in buffer
-    def each_dynamic_tags
-      return unless block_given?
-
-      sec = find_section '.dynamic'
-      return unless sec
-
-      shdr = sec.header
-      with_buf_at(shdr.sh_offset) do |buf|
-        dyn = ELFTools::Structs::ELF_Dyn.new(elf_class: elf_class, endian: endian)
-        loop do
-          buf_dyn_offset = buf.tell
-          dyn.clear
-          dyn.read(buf)
-          break if dyn.d_tag == ELFTools::Constants::DT_NULL
-
-          yield dyn, buf_dyn_offset
-          # there's a possibility for caller to modify @buffer.pos, seek to avoid such issues
-          buf.seek buf_dyn_offset + dyn.num_bytes
-        end
-      end
-    end
-
-    # the idea of uniquely identifying section by its name has its problems
-    # but this is how patchelf operates and is prone to bugs.
-    # e.g: https://github.com/NixOS/patchelf/issues/197
-    def find_section(sec_name)
-      idx = find_section_idx sec_name
-      return unless idx
-
-      @sections[idx]
-    end
-
-    def find_section_idx(sec_name)
-      @section_idx_by_name[sec_name]
-    end
-
-    def buf_grow!(newsz)
-      bufsz = @buffer.size
-      return if newsz <= bufsz
-
-      @buffer.truncate newsz
-    end
-
-    def modify_interpreter
-      @replaced_sections['.interp'] = @set[:interpreter] + "\x00"
-    end
-
-    def modify_needed
-      # due to gsoc time constraints only implmenting features used by brew.
-      raise NotImplementedError
-    end
-
-    # not checking for nil as modify_rpath is only called if @set[:rpath]
-    def modify_rpath
-      modify_rpath_helper @set[:rpath], force_rpath: true
-    end
-
-    # not checking for nil as modify_runpath is only called if @set[:runpath]
-    def modify_runpath
-      modify_rpath_helper @set[:runpath]
-    end
-
-    def collect_runpath_tags
-      tags = {}
-      each_dynamic_tags do |dyn, off|
-        case dyn.d_tag
-        when ELFTools::Constants::DT_RPATH
-          tag_type = :rpath
-        when ELFTools::Constants::DT_RUNPATH
-          tag_type = :runpath
-        else
-          next
-        end
-
-        # clone does shallow copy, and for some reason d_tag and d_val can't be pass as argument
-        dyn_rpath = ELFTools::Structs::ELF_Dyn.new(endian: endian, elf_class: elf_class)
-        dyn_rpath.assign({ d_tag: dyn.d_tag.to_i, d_val: dyn.d_val.to_i })
-        tags[tag_type] = { offset: off, header: dyn_rpath }
-      end
-      tags
-    end
-
-    def resolve_rpath_tag_conflict(dyn_tags, force_rpath: false)
-      dyn_runpath, dyn_rpath = dyn_tags.values_at(:runpath, :rpath)
-
-      update_sym =
-        if !force_rpath && dyn_rpath && dyn_runpath.nil?
-          :runpath
-        elsif force_rpath && dyn_runpath
-          :rpath
-        end
-      return unless update_sym
-
-      delete_sym, = %i[rpath runpath] - [update_sym]
-      dyn_tag = dyn_tags[update_sym] = dyn_tags[delete_sym]
-      dyn = dyn_tag[:header]
-      dyn.d_tag = ELFTools::Constants.const_get("DT_#{update_sym.upcase}")
-      with_buf_at(dyn_tag[:offset]) { |buf| dyn.write(buf) }
-      dyn_tags.delete(delete_sym)
-    end
-
-    def modify_rpath_helper(new_rpath, force_rpath: false)
-      shdr_dynstr = dynstr.header
-
-      dyn_tags = collect_runpath_tags
-      resolve_rpath_tag_conflict(dyn_tags, force_rpath: force_rpath)
-      # (:runpath, :rpath) order_matters.
-      resolved_rpath_dyns = dyn_tags.values_at(:runpath, :rpath).compact
-
-      old_rpath = ''
-      rpath_off = nil
-      resolved_rpath_dyns.each do |dyn|
-        rpath_off = shdr_dynstr.sh_offset + dyn[:header].d_val
-        old_rpath = buf_cstr(rpath_off)
-        break
-      end
-      return if old_rpath == new_rpath
-
-      with_buf_at(rpath_off) { |b| b.write('X' * old_rpath.size) } if rpath_off
-      if new_rpath.size <= old_rpath.size
-        with_buf_at(rpath_off) { |b| b.write "#{new_rpath}\x00" }
-        return
-      end
-
-      Logger.debug 'rpath is too long, resizing...'
-      new_dynstr = replace_section '.dynstr', shdr_dynstr.sh_size + new_rpath.size + 1
-      new_rpath_strtab_idx = shdr_dynstr.sh_size.to_i
-      new_dynstr[new_rpath_strtab_idx..(new_rpath_strtab_idx + new_rpath.size)] = "#{new_rpath}\x00"
-
-      dyn_tags.each do |_, dyn|
-        dyn[:header].d_val = new_rpath_strtab_idx
-        with_buf_at(dyn[:offset]) { |b| dyn[:header].write(b) }
-      end
-
-      return unless dyn_tags.empty?
-
-      add_dt_rpath!(
-        d_tag: force_rpath ? ELFTools::Constants::DT_RPATH : ELFTools::Constants::DT_RUNPATH,
-        d_val: new_rpath_strtab_idx
-      )
-    end
-
-    def modify_soname
-      return unless ehdr.e_type == ELFTools::Constants::ET_DYN
-
-      # due to gsoc time constraints only implmenting features used by brew.
-      raise NotImplementedError
-    end
-
-    def add_segment!(**phdr_vals)
-      new_phdr = ELFTools::Structs::ELF_Phdr[elf_class].new(endian: endian, **phdr_vals)
-      # nil = no reference to stream; we only want @segments[i].header
-      new_segment = ELFTools::Segments::Segment.new(new_phdr, nil)
-      @segments.push new_segment
-      ehdr.e_phnum += 1
-      nil
-    end
-
-    def add_dt_rpath!(d_tag: nil, d_val: nil)
-      dyn_num_bytes = nil
-      dt_null_idx = 0
-      each_dynamic_tags do |dyn|
-        dyn_num_bytes ||= dyn.num_bytes
-        dt_null_idx += 1
-      end
-
-      # allot for new dt_runpath
-      shdr_dynamic = find_section('.dynamic').header
-      new_dynamic_data = replace_section '.dynamic', shdr_dynamic.sh_size + dyn_num_bytes
-
-      # consider DT_NULL when copying
-      replacement_size = (dt_null_idx + 1) * dyn_num_bytes
-
-      # make space for dt_runpath tag at the top, shift data by one tag positon
-      new_dynamic_data[dyn_num_bytes..(replacement_size + dyn_num_bytes)] = new_dynamic_data[0..replacement_size]
-
-      dyn_rpath = ELFTools::Structs::ELF_Dyn.new endian: endian, elf_class: elf_class
-      dyn_rpath.d_tag = d_tag
-      dyn_rpath.d_val = d_val
-
-      zi = StringIO.new
-      dyn_rpath.write zi
-      zi.rewind
-      new_dynamic_data[0...dyn_num_bytes] = zi.read
-    end
-
-    # given a index into old_sections table
-    # returns the corresponding section index in @sections
-    #
-    # raises ArgumentError if old_shndx can't be found in old_sections
-    # TODO: handle case of non existing section in (new) @sections.
-    def new_section_idx(old_shndx)
-      return if old_shndx == ELFTools::Constants::SHN_UNDEF || old_shndx >= ELFTools::Constants::SHN_LORESERVE
-
-      raise ArgumentError if old_shndx >= old_sections.count
-
-      old_sec = old_sections[old_shndx]
-      raise PatchError, "old_sections[#{shndx}] is nil" if old_sec.nil?
-
-      # TODO: handle case of non existing section in (new) @sections.
-      find_section_idx(old_sec.name)
-    end
-
-    def page_size
-      Helper::PAGE_SIZE
-    end
-
-    def patch_out
-      with_buf_at(0) { |b| ehdr.write(b) }
-
-      File.open(out_file, 'wb') do |f|
-        @buffer.rewind
-        f.write @buffer.read
-      end
-    end
-
-    # size includes NUL byte
-    def replace_section(section_name, size)
-      data = @replaced_sections[section_name]
-      unless data
-        shdr = find_section(section_name).header
-        # avoid calling +section.data+ as the @buffer contents may vary from
-        # the stream provided to section at initialization.
-        # ideally, calling section.data should work, however avoiding it to prevent
-        # future traps.
-        with_buf_at(shdr.sh_offset) { |b| data = b.read shdr.sh_size }
-      end
-      rep_data = if data.size == size
-                   data
-                 elsif data.size < size
-                   data.ljust(size, "\x00")
-                 else
-                   data[0...size] + "\x00"
-                 end
-      @replaced_sections[section_name] = rep_data
-    end
-
-    def write_phdrs_to_buf!
-      sort_phdrs!
-      with_buf_at(ehdr.e_phoff) do |buf|
-        @segments.each { |seg| seg.header.write(buf) }
-      end
-    end
-
-    def write_shdrs_to_buf!
-      raise PatchError, 'ehdr.e_shnum != @sections.count' if ehdr.e_shnum != @sections.count
-
-      sort_shdrs!
-      with_buf_at(ehdr.e_shoff) do |buf|
-        @sections.each { |section| section.header.write(buf) }
-      end
-      sync_dyn_tags!
-    end
-
-    # data for manual packing and unpacking of symbols in symtab sections.
-    def meta_sym_pack
-      return @meta_sym_pack if @meta_sym_pack
-
-      # resort to manual packing and unpacking of data,
-      # as using bindata is painfully slow :(
-      if elf_class == 32
-        sym_num_bytes = 16 # u32 u32 u32 u8 u8 u16
-        pack_code = endian == :little ? 'VVVCCv' : 'NNNCCn'
-        pack_st_info = 3
-        pack_st_shndx = 5
-        pack_st_value = 1
-      else # 64
-        sym_num_bytes = 24 # u32 u8 u8 u16 u64 u64
-        pack_code = endian == :little ? 'VCCvQ<Q<' : 'NCCnQ>Q>'
-        pack_st_info = 1
-        pack_st_shndx = 3
-        pack_st_value = 4
-      end
-
-      @meta_sym_pack = {
-        num_bytes: sym_num_bytes, code: pack_code,
-        st_info: pack_st_info, st_shndx: pack_st_shndx, st_value: pack_st_value
-      }
-    end
-
-    # yields +symbol+, +entry+
-    def each_symbol(shdr)
-      return unless [ELFTools::Constants::SHT_SYMTAB, ELFTools::Constants::SHT_DYNSYM].include?(shdr.sh_type)
-
-      pack_code, sym_num_bytes = meta_sym_pack.values_at(:code, :num_bytes)
-
-      with_buf_at(shdr.sh_offset) do |buf|
-        num_symbols = shdr.sh_size / sym_num_bytes
-        num_symbols.times do |entry|
-          sym = buf.read(sym_num_bytes).unpack(pack_code)
-          sym_modified = yield sym, entry
-
-          if sym_modified
-            buf.seek buf.tell - sym_num_bytes
-            buf.write sym.pack(pack_code)
-          end
-        end
-      end
-    end
-
-    def rewrite_headers(phdr_address)
-      # there can only be a single program header table according to ELF spec
-      @segments.find { |seg| seg.header.p_type == ELFTools::Constants::PT_PHDR }&.tap do |seg|
-        phdr = seg.header
-        phdr.p_offset = ehdr.e_phoff.to_i
-        phdr.p_vaddr = phdr.p_paddr = phdr_address.to_i
-        phdr.p_filesz = phdr.p_memsz = phdr.num_bytes * @segments.count # e_phentsize * e_phnum
-      end
-      write_phdrs_to_buf!
-      write_shdrs_to_buf!
-
-      pack = meta_sym_pack
-      @sections.each do |sec|
-        each_symbol(sec.header) do |sym, entry|
-          old_shndx = sym[pack[:st_shndx]]
-
-          begin
-            new_index = new_section_idx(old_shndx)
-            next unless new_index
-          rescue ArgumentError
-            Logger.warn "entry #{entry} in symbol table refers to a non existing section, skipping"
-          end
-
-          sym[pack[:st_shndx]] = new_index
-
-          # right 4 bits in the st_info field is st_type
-          if (sym[pack[:st_info]] & 0xF) == ELFTools::Constants::STT_SECTION
-            sym[pack[:st_value]] = @sections[new_index].header.sh_addr.to_i
-          end
-          true
-        end
-      end
-    end
-
-    def rewrite_sections
-      return if @replaced_sections.empty?
-
-      case ehdr.e_type
-      when ELFTools::Constants::ET_DYN
-        rewrite_sections_library
-      when ELFTools::Constants::ET_EXEC
-        rewrite_sections_executable
-      else
-        raise PatchError, 'unknown ELF type'
-      end
-    end
-
-    def replaced_section_indices
-      return enum_for(:replaced_section_indices) unless block_given?
-
-      last_replaced = 0
-      @sections.each_with_index do |sec, idx|
-        if @replaced_sections[sec.name]
-          last_replaced = idx
-          yield last_replaced
-        end
-      end
-      raise PatchError, 'last_replaced = 0' if last_replaced.zero?
-      raise PatchError, 'last_replaced + 1 >= @sections.size' if last_replaced + 1 >= @sections.size
-    end
-
-    def start_replacement_shdr
-      last_replaced = replaced_section_indices.max
-      start_replacement_hdr = @sections[last_replaced + 1].header
-
-      prev_sec_name = ''
-      (1..last_replaced).each do |idx|
-        sec = @sections[idx]
-        shdr = sec.header
-        if (sec.type == ELFTools::Constants::SHT_PROGBITS && sec.name != '.interp') || prev_sec_name == '.dynstr'
-          start_replacement_hdr = shdr
-          break
-        elsif @replaced_sections[sec.name].nil?
-          Logger.debug " replacing section #{sec.name} which is in the way"
-          replace_section(sec.name, shdr.sh_size)
-        end
-        prev_sec_name = sec.name
-      end
-
-      start_replacement_hdr
-    end
-
-    def copy_shdrs_to_eof
-      shoff_new = @buffer.size
-      # honestly idk why `ehdr.e_shoff` is considered when we are only moving shdrs.
-      sh_size = ehdr.e_shoff + ehdr.e_shnum * ehdr.e_shentsize
-      buf_grow! @buffer.size + sh_size
-      ehdr.e_shoff = shoff_new
-      raise PatchError, 'ehdr.e_shnum != @sections.size' if ehdr.e_shnum != @sections.size
-
-      with_buf_at(ehdr.e_shoff + @sections.first.header.num_bytes) do |buf| # skip writing to NULL section
-        @sections.each_with_index do |sec, idx|
-          next if idx.zero?
-
-          sec.header.write buf
-        end
-      end
-    end
-
-    def rewrite_sections_executable
-      sort_shdrs!
-      shdr = start_replacement_shdr
-      start_offset = shdr.sh_offset
-      start_addr = shdr.sh_addr
-      first_page = start_addr - start_offset
-
-      Logger.debug "first reserved offset/addr is 0x#{start_offset.to_i.to_s 16}/0x#{start_addr.to_i.to_s 16}"
-
-      unless start_addr % page_size == start_offset % page_size
-        raise PatchError, 'start_addr != start_offset (mod PAGE_SIZE)'
-      end
-
-      Logger.debug "first page is 0x#{first_page.to_i.to_s 16}"
-
-      copy_shdrs_to_eof if ehdr.e_shoff < start_offset
-
-      seg_num_bytes = @segments.first.header.num_bytes
-      needed_space = (
-        ehdr.num_bytes +
-        (@segments.count * seg_num_bytes) +
-        @replaced_sections.sum { |_, str| Helper.alignup(str.size, @section_alignment) }
-      )
-
-      if needed_space > start_offset
-        needed_space += seg_num_bytes # new load segment is required
-
-        needed_pages = Helper.alignup(needed_space - start_offset, page_size) / page_size
-        Logger.debug "needed pages is #{needed_pages}"
-        raise PatchError, 'virtual address space underrun' if needed_pages * page_size > first_page
-
-        first_page -= needed_pages * page_size
-        start_offset += needed_pages * page_size
-
-        shift_file(needed_pages, first_page)
-      end
-      Logger.debug "needed space is #{needed_space}"
-
-      cur_off = ehdr.num_bytes + (@segments.count * seg_num_bytes)
-      Logger.debug "clearing first #{start_offset - cur_off} bytes"
-      with_buf_at(cur_off) { |buf| buf.fill("\x00", (start_offset - cur_off)) }
-
-      cur_off = write_replaced_sections cur_off, first_page, 0
-      raise PatchError, "cur_off(#{cur_off}) != needed_space" if cur_off != needed_space
-
-      rewrite_headers first_page + ehdr.e_phoff
-    end
-
-    def replace_sections_in_the_way_of_phdr!
-      pht_size = ehdr.num_bytes + (@segments.count + 1) * @segments.first.header.num_bytes
-
-      # replace sections that may overlap with expanded program header table
-      @sections.each_with_index do |sec, idx|
-        shdr = sec.header
-        next if idx.zero? || @replaced_sections[sec.name]
-        break if shdr.sh_addr > pht_size
-
-        replace_section sec.name, shdr.sh_size
-      end
-    end
-
-    def seg_end_addr(seg)
-      phdr = seg.header
-      Helper.alignup(phdr.p_vaddr + phdr.p_memsz, page_size)
-    end
-
-    def rewrite_sections_library
-      start_page = seg_end_addr(@segments.max_by(&method(:seg_end_addr)))
-
-      Logger.debug "Last page is 0x#{start_page.to_s 16}"
-      replace_sections_in_the_way_of_phdr!
-      needed_space = @replaced_sections.sum { |_, str| Helper.alignup(str.size, @section_alignment) }
-      Logger.debug "needed space = #{needed_space}"
-
-      start_offset = Helper.alignup(@buffer.size, page_size)
-      buf_grow! start_offset + needed_space
-
-      # executable shared object
-      if start_offset > start_page && @segments.any? { |seg| seg.header.p_type == ELFTools::Constants::PT_INTERP }
-        Logger.debug(
-          "shifting new PT_LOAD segment by #{start_offset - start_page} bytes to work around a Linux kernel bug"
-        )
-        start_page = start_offset
-      end
-
-      ehdr.e_phoff = ehdr.num_bytes
-      add_segment!(
-        p_type: ELFTools::Constants::PT_LOAD,
-        p_offset: start_offset,
-        p_vaddr: start_page,
-        p_paddr: start_page,
-        p_filesz: needed_space,
-        p_memsz: needed_space,
-        p_flags: ELFTools::Constants::PF_R | ELFTools::Constants::PF_W,
-        p_align: page_size
-      )
-
-      cur_off = write_replaced_sections start_offset, start_page, start_offset
-      raise PatchError, 'cur_off != start_offset + needed_space' if cur_off != start_offset + needed_space
-
-      rewrite_headers ehdr.e_phoff
-    end
-
-    def shift_file(extra_pages, start_page)
-      oldsz = @buffer.size
-      shift = extra_pages * page_size
-      buf_grow!(oldsz + shift)
-      buf_move! shift, 0, oldsz
-      with_buf_at(ehdr.num_bytes) { |buf| buf.write "\x00" * (shift - ehdr.num_bytes) }
-
-      ehdr.e_phoff = ehdr.num_bytes
-      ehdr.e_shoff = ehdr.e_shoff + shift
-
-      @sections.each_with_index do |sec, i|
-        next if i.zero? # dont touch NULL section
-
-        shdr = sec.header
-        shdr.sh_offset += shift
-      end
-
-      @segments.each do |seg|
-        phdr = seg.header
-        phdr.p_offset += shift
-        phdr.p_align = page_size if phdr.p_align != 0 && (phdr.p_vaddr - phdr.p_offset) % phdr.p_align != 0
-      end
-
-      add_segment!(
-        p_type: ELFTools::Constants::PT_LOAD,
-        p_offset: 0,
-        p_vaddr: start_page,
-        p_paddr: start_page,
-        p_filesz: shift,
-        p_memsz: shift,
-        p_flags: ELFTools::Constants::PF_R | ELFTools::Constants::PF_W,
-        p_align: page_size
-      )
-    end
-
-    def sort_phdrs!
-      pt_phdr = ELFTools::Constants::PT_PHDR
-      @segments.sort! do |me, you|
-        next  1 if you.header.p_type == pt_phdr
-        next -1 if me.header.p_type == pt_phdr
-
-        me.header.p_paddr.to_i <=> you.header.p_paddr.to_i
-      end
-    end
-
-    # section headers may contain sh_info and sh_link values that are
-    # references to another section
-    def collect_section_to_section_refs
-      rel_syms = [ELFTools::Constants::SHT_REL, ELFTools::Constants::SHT_RELA]
-      # Translate sh_link, sh_info mappings to section names.
-      @sections.each_with_object({ linkage: {}, info: {} }) do |s, collected|
-        hdr = s.header
-        collected[:linkage][s.name] = @sections[hdr.sh_link].name if hdr.sh_link.nonzero?
-        collected[:info][s.name] = @sections[hdr.sh_info].name if hdr.sh_info.nonzero? && rel_syms.include?(hdr.sh_type)
-      end
-    end
-
-    # @param collected
-    # this must be the value returned by +collect_section_to_section_refs+
-    def restore_section_to_section_refs!(collected)
-      rel_syms = [ELFTools::Constants::SHT_REL, ELFTools::Constants::SHT_RELA]
-      linkage, info = collected.values_at(:linkage, :info)
-      @sections.each do |sec|
-        hdr = sec.header
-        hdr.sh_link = find_section_idx(linkage[sec.name]) if hdr.sh_link.nonzero?
-        hdr.sh_info = find_section_idx(info[sec.name]) if hdr.sh_info.nonzero? && rel_syms.include?(hdr.sh_type)
-      end
-    end
-
-    def sort_shdrs!
-      section_dep_values = collect_section_to_section_refs
-      shstrtab_name = @sections[ehdr.e_shstrndx].name
-      @sections.sort! { |me, you| me.header.sh_offset.to_i <=> you.header.sh_offset.to_i }
-      update_section_idx!
-      restore_section_to_section_refs!(section_dep_values)
-      ehdr.e_shstrndx = find_section_idx shstrtab_name
-    end
-
-    # given a +dyn.d_tag+, returns the section name it must be synced to.
-    # it may return nil, when given tag maps to no section,
-    # or when its okay to skip if section is not found.
-    def dyn_tag_to_section_name(d_tag)
-      case d_tag
-      when ELFTools::Constants::DT_STRTAB, ELFTools::Constants::DT_STRSZ
-        '.dynstr'
-      when ELFTools::Constants::DT_SYMTAB
-        '.dynsym'
-      when ELFTools::Constants::DT_HASH
-        '.hash'
-      when ELFTools::Constants::DT_GNU_HASH
-        '.gnu.hash'
-      when ELFTools::Constants::DT_JMPREL
-        sec_name = %w[.rel.plt .rela.plt .rela.IA_64.pltoff].find { |s| find_section(s) }
-        raise PatchError, 'cannot find section corresponding to DT_JMPREL' unless sec_name
-
-        sec_name
-      when ELFTools::Constants::DT_REL
-        # regarding .rel.got, NixOS/patchelf says
-        # "no idea if this makes sense, but it was needed for some program"
-        #
-        # return nil if not found, patchelf claims no problem in skipping
-        %w[.rel.dyn .rel.got].find { |s| find_section(s) }
-      when ELFTools::Constants::DT_RELA
-        # return nil if not found, patchelf claims no problem in skipping
-        find_section('.rela.dyn')&.name
-      when ELFTools::Constants::DT_VERNEED
-        '.gnu.version_r'
-      when ELFTools::Constants::DT_VERSYM
-        '.gnu.version'
-      end
-    end
-
-    # updates dyn tags by syncing it with @section values
-    def sync_dyn_tags!
-      each_dynamic_tags do |dyn, buf_off|
-        sec_name = dyn_tag_to_section_name(dyn.d_tag)
-        next unless sec_name
-
-        shdr = find_section(sec_name).header
-        dyn.d_val = dyn.d_tag == ELFTools::Constants::DT_STRSZ ? shdr.sh_size.to_i : shdr.sh_addr.to_i
-
-        with_buf_at(buf_off) { |wbuf| dyn.write(wbuf) }
-      end
-    end
-
-    def update_section_idx!
-      @section_idx_by_name = @sections.map.with_index { |sec, idx| [sec.name, idx] }.to_h
-    end
-
-    def with_buf_at(pos)
-      return unless block_given?
-
-      opos = @buffer.tell
-      @buffer.seek pos
-      yield @buffer
-      @buffer.seek opos
-      nil
-    end
-
-    def sync_sec_to_seg(shdr, phdr)
-      phdr.p_offset = shdr.sh_offset.to_i
-      phdr.p_vaddr = phdr.p_paddr = shdr.sh_addr.to_i
-      phdr.p_filesz = phdr.p_memsz = shdr.sh_size.to_i
-    end
-
-    def phdrs_by_type(seg_type)
-      return unless seg_type
-
-      @segments.each_with_index do |seg, idx|
-        next unless (phdr = seg.header).p_type == seg_type
-
-        yield phdr, idx
-      end
-    end
-
-    def write_replaced_sections(cur_off, start_addr, start_offset)
-      sht_no_bits = ELFTools::Constants::SHT_NOBITS
-
-      # the original source says this has to be done seperately to
-      # prevent clobbering the previously written section contents.
-      @replaced_sections.each do |rsec_name, _|
-        shdr = find_section(rsec_name).header
-        with_buf_at(shdr.sh_offset) { |b| b.fill('X', shdr.sh_size) } if shdr.sh_type != sht_no_bits
-      end
-
-      # the sort is necessary, the strategy in ruby and Cpp to iterate map/hash
-      # is different, patchelf v0.10 iterates the replaced_sections sorted by
-      # keys.
-      @replaced_sections.sort.each do |rsec_name, rsec_data|
-        section = find_section(rsec_name)
-        shdr = section.header
-
-        Logger.debug <<~DEBUG
-          rewriting section '#{rsec_name}'
-          from offset 0x#{shdr.sh_offset.to_i.to_s 16}(size #{shdr.sh_size})
-            to offset 0x#{cur_off.to_i.to_s 16}(size #{rsec_data.size})
-        DEBUG
-
-        with_buf_at(cur_off) { |b| b.write rsec_data }
-
-        shdr.sh_offset = cur_off
-        shdr.sh_addr = start_addr + (cur_off - start_offset)
-        shdr.sh_size = rsec_data.size
-        shdr.sh_addralign = @section_alignment
-
-        seg_type = {
-          '.interp' => ELFTools::Constants::PT_INTERP,
-          '.dynamic' => ELFTools::Constants::PT_DYNAMIC
-        }[section.name]
-
-        phdrs_by_type(seg_type) { |phdr| sync_sec_to_seg(shdr, phdr) }
-
-        cur_off += Helper.alignup(rsec_data.size, @section_alignment)
-      end
-      @replaced_sections.clear
-
-      cur_off
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/exceptions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/exceptions.rb
deleted file mode 100644
index da14d19aa32b9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/exceptions.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-# encoding: ascii-8bit
-# frozen_string_literal: true
-
-require 'elftools/exceptions'
-
-module PatchELF
-  # Raised on an error during ELF modification.
-  class PatchError < ELFTools::ELFError; end
-  # Raised when Dynamic Tag is missing
-  class MissingTagError < PatchError; end
-  # Raised on missing Program Header(segment)
-  class MissingSegmentError < PatchError; end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/helper.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/helper.rb
deleted file mode 100644
index 71c1a3e469072..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/helper.rb
+++ /dev/null
@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module PatchELF
-  # Helper methods for internal usage.
-  module Helper
-    # The size of one page.
-    PAGE_SIZE = 0x1000
-
-    module_function
-
-    # Color codes for pretty print.
-    COLOR_CODE = {
-      esc_m: "\e[0m",
-      info: "\e[38;5;82m", # light green
-      warn: "\e[38;5;230m", # light yellow
-      error: "\e[38;5;196m" # heavy red
-    }.freeze
-
-    # For wrapping string with color codes for prettier inspect.
-    # @param [String] str
-    #   Content to colorize.
-    # @param [Symbol] type
-    #   Specify which kind of color to use, valid symbols are defined in {.COLOR_CODE}.
-    # @return [String]
-    #   String that wrapped with color codes.
-    def colorize(str, type)
-      return str unless color_enabled?
-
-      cc = COLOR_CODE
-      color = cc.key?(type) ? cc[type] : ''
-      "#{color}#{str.sub(COLOR_CODE[:esc_m], color)}#{cc[:esc_m]}"
-    end
-
-    # For {#colorize} to decide if need add color codes.
-    # @return [Boolean]
-    def color_enabled?
-      $stderr.tty?
-    end
-
-    # @param [Integer] val
-    # @param [Integer] align
-    # @return [Integer]
-    #   Aligned result.
-    # @example
-    #   aligndown(0x1234)
-    #   #=> 4096
-    #   aligndown(0x33, 0x20)
-    #   #=> 32
-    #   aligndown(0x10, 0x8)
-    #   #=> 16
-    def aligndown(val, align = PAGE_SIZE)
-      val - (val & (align - 1))
-    end
-
-    # @param [Integer] val
-    # @param [Integer] align
-    # @return [Integer]
-    #   Aligned result.
-    # @example
-    #   alignup(0x1234)
-    #   #=> 8192
-    #   alignup(0x33, 0x20)
-    #   #=> 64
-    #   alignup(0x10, 0x8)
-    #   #=> 16
-    def alignup(val, align = PAGE_SIZE)
-      (val & (align - 1)).zero? ? val : (aligndown(val, align) + align)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/version.rb
deleted file mode 100644
index b862ba2bab9d2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/version.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module PatchELF
-  # Current gem version.
-  VERSION = '1.3.0'.freeze
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/plist-3.6.0/lib/plist/generator.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/plist-3.6.0/lib/plist/generator.rb
deleted file mode 100644
index 0b8af54b3fcad..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/plist-3.6.0/lib/plist/generator.rb
+++ /dev/null
@@ -1,180 +0,0 @@
-# encoding: utf-8
-
-# = plist
-#
-# Copyright 2006-2010 Ben Bleything and Patrick May
-# Distributed under the MIT License
-#
-
-module Plist
-  # === Create a plist
-  # You can dump an object to a plist in one of two ways:
-  #
-  # * <tt>Plist::Emit.dump(obj)</tt>
-  # * <tt>obj.to_plist</tt>
-  #   * This requires that you mixin the <tt>Plist::Emit</tt> module, which is already done for +Array+ and +Hash+.
-  #
-  # The following Ruby classes are converted into native plist types:
-  #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time, true, false
-  # * +Array+ and +Hash+ are both recursive; their elements will be converted into plist nodes inside the <array> and <dict> containers (respectively).
-  # * +IO+ (and its descendants) and +StringIO+ objects are read from and their contents placed in a <data> element.
-  # * User classes may implement +to_plist_node+ to dictate how they should be serialized; otherwise the object will be passed to <tt>Marshal.dump</tt> and the result placed in a <data> element.
-  #
-  # For detailed usage instructions, refer to USAGE[link:files/docs/USAGE.html] and the methods documented below.
-  module Emit
-    DEFAULT_INDENT = "\t"
-
-    # Helper method for injecting into classes.  Calls <tt>Plist::Emit.dump</tt> with +self+.
-    def to_plist(envelope = true, options = {})
-      Plist::Emit.dump(self, envelope, options)
-    end
-
-    # Helper method for injecting into classes.  Calls <tt>Plist::Emit.save_plist</tt> with +self+.
-    def save_plist(filename, options = {})
-      Plist::Emit.save_plist(self, filename, options)
-    end
-
-    # The following Ruby classes are converted into native plist types:
-    #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time
-    #
-    # Write us (via RubyForge) if you think another class can be coerced safely into one of the expected plist classes.
-    #
-    # +IO+ and +StringIO+ objects are encoded and placed in <data> elements; other objects are <tt>Marshal.dump</tt>'ed unless they implement +to_plist_node+.
-    #
-    # The +envelope+ parameters dictates whether or not the resultant plist fragment is wrapped in the normal XML/plist header and footer.  Set it to false if you only want the fragment.
-    def self.dump(obj, envelope = true, options = {})
-      options = { :indent => DEFAULT_INDENT }.merge(options)
-
-      output = PlistBuilder.new(options[:indent]).build(obj)
-      output = wrap(output) if envelope
-
-      output
-    end
-
-    # Writes the serialized object's plist to the specified filename.
-    def self.save_plist(obj, filename, options = {})
-      File.open(filename, 'wb') do |f|
-        f.write(obj.to_plist(true, options))
-      end
-    end
-
-    private
-
-    class PlistBuilder
-      def initialize(indent_str)
-        @indent_str = indent_str.to_s
-      end
-
-      def build(element, level=0)
-        if element.respond_to? :to_plist_node
-          element.to_plist_node
-        else
-          case element
-          when Array
-            if element.empty?
-              tag('array', nil, level)
-            else
-              tag('array', nil, level) {
-                element.collect {|e| build(e, level + 1) }.join
-              }
-            end
-          when Hash
-            if element.empty?
-              tag('dict', nil, level)
-            else
-              tag('dict', '', level) do
-                element.sort_by{|k,v| k.to_s }.collect do |k,v| 
-                  tag('key', CGI.escapeHTML(k.to_s), level + 1) +
-                  build(v, level + 1)
-                end.join
-              end
-            end
-          when true, false
-            tag(element, nil, level)
-          when Time
-            tag('date', element.utc.strftime('%Y-%m-%dT%H:%M:%SZ'), level)
-          when Date # also catches DateTime
-            tag('date', element.strftime('%Y-%m-%dT%H:%M:%SZ'), level)
-          when String, Symbol, Integer, Float
-            tag(element_type(element), CGI.escapeHTML(element.to_s), level)
-          when IO, StringIO
-            data = element.tap(&:rewind).read 
-            data_tag(data, level)
-          else
-            data = Marshal.dump(element)
-            comment_tag('The <data> element below contains a Ruby object which has been serialized with Marshal.dump.') +
-            data_tag(data, level)
-          end
-        end
-      end
-
-      private
-
-      def tag(type, contents, level, &block)
-        if block_given?
-          indent("<#{type}>\n", level) +
-          block.call +
-          indent("</#{type}>\n", level)
-        elsif contents.to_s.empty?
-          indent("<#{type}/>\n", level)
-        else
-          indent("<#{type}>#{contents.to_s}</#{type}>\n", level)
-        end
-      end
-
-      def data_tag(data, level)
-        # note that apple plists are wrapped at a different length then
-        # what ruby's base64 wraps by default.
-        # I used #encode64 instead of #b64encode (which allows a length arg)
-        # because b64encode is b0rked and ignores the length arg.
-        tag('data', nil, level) do
-          Base64.encode64(data)
-                .gsub(/\s+/, '')
-                .scan(/.{1,68}/o)
-                .collect { |line| indent(line, level) }
-                .join("\n")
-                .concat("\n")
-        end
-      end
-
-      def indent(str, level)
-        @indent_str.to_s * level + str
-      end
-
-      def element_type(item)
-        case item
-        when String, Symbol
-          'string'
-        when Integer
-          'integer'
-        when Float
-          'real'
-        else
-          raise "Don't know about this data type... something must be wrong!"
-        end
-      end
-
-      def comment_tag(content)
-        return "<!-- #{content} -->\n"
-      end
-    end
-
-    def self.wrap(contents)
-      output =  '<?xml version="1.0" encoding="UTF-8"?>' + "\n"
-      output << '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">' + "\n"
-      output << '<plist version="1.0">' + "\n"
-      output << contents
-      output << '</plist>' + "\n"
-
-      output
-    end
-  end
-end
-
-class Array #:nodoc:
-  include Plist::Emit
-end
-
-class Hash #:nodoc:
-  include Plist::Emit
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/plist-3.6.0/lib/plist/parser.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/plist-3.6.0/lib/plist/parser.rb
deleted file mode 100755
index f325988b05bc1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/plist-3.6.0/lib/plist/parser.rb
+++ /dev/null
@@ -1,256 +0,0 @@
-# encoding: utf-8
-
-# = plist
-#
-# Copyright 2006-2010 Ben Bleything and Patrick May
-# Distributed under the MIT License
-#
-
-# Plist parses Mac OS X xml property list files into ruby data structures.
-#
-# === Load a plist file
-# This is the main point of the library:
-#
-#   r = Plist.parse_xml(filename_or_xml)
-module Plist
-  # Raised when an element is not implemented
-  class UnimplementedElementError < RuntimeError; end
-
-  # Note that I don't use these two elements much:
-  #
-  #  + Date elements are returned as DateTime objects.
-  #  + Data elements are implemented as Tempfiles
-  #
-  # Plist.parse_xml will blow up if it encounters a Date element.
-  # If you encounter such an error, or if you have a Date element which
-  # can't be parsed into a Time object, please create an issue
-  # attaching your plist file at https://github.com/patsplat/plist/issues
-  # so folks can implement the proper support.
-  def self.parse_xml(filename_or_xml)
-    listener = Listener.new
-    # parser = REXML::Parsers::StreamParser.new(File.new(filename), listener)
-    parser = StreamParser.new(filename_or_xml, listener)
-    parser.parse
-    listener.result
-  end
-
-  class Listener
-    # include REXML::StreamListener
-
-    attr_accessor :result, :open
-
-    def initialize
-      @result = nil
-      @open   = []
-    end
-
-    def tag_start(name, attributes)
-      @open.push PTag.mappings[name].new
-    end
-
-    def text(contents)
-      if @open.last
-        @open.last.text ||= ''
-        @open.last.text.concat(contents)
-      end
-    end
-
-    def tag_end(name)
-      last = @open.pop
-      if @open.empty?
-        @result = last.to_ruby
-      else
-        @open.last.children.push last
-      end
-    end
-  end
-
-  class StreamParser
-    def initialize(plist_data_or_file, listener)
-      if plist_data_or_file.respond_to? :read
-        @xml = plist_data_or_file.read
-      elsif File.exist? plist_data_or_file
-        @xml = File.read(plist_data_or_file)
-      else
-        @xml = plist_data_or_file
-      end
-
-      @listener = listener
-    end
-
-    TEXT = /([^<]+)/
-    CDATA = /<!\[CDATA\[(.*?)\]\]>/
-    XMLDECL_PATTERN = /<\?xml\s+(.*?)\?>*/m
-    DOCTYPE_PATTERN = /\s*<!DOCTYPE\s+(.*?)(\[|>)/m
-    COMMENT_START = /\A<!--/
-    COMMENT_END = /.*?-->/m
-    UNIMPLEMENTED_ERROR = 'Unimplemented element. ' \
-      'Consider reporting via https://github.com/patsplat/plist/issues'
-
-    def parse
-      plist_tags = PTag.mappings.keys.join('|')
-      start_tag  = /<(#{plist_tags})([^>]*)>/i
-      end_tag    = /<\/(#{plist_tags})[^>]*>/i
-
-      require 'strscan'
-
-      @scanner = StringScanner.new(@xml)
-      until @scanner.eos?
-        if @scanner.scan(COMMENT_START)
-          @scanner.scan(COMMENT_END)
-        elsif @scanner.scan(XMLDECL_PATTERN)
-          encoding = parse_encoding_from_xml_declaration(@scanner[1])
-          next if encoding.nil?
-
-          # use the specified encoding for the rest of the file
-          next unless String.method_defined?(:force_encoding)
-          @scanner.string = @scanner.rest.force_encoding(encoding)
-        elsif @scanner.scan(DOCTYPE_PATTERN)
-          next
-        elsif @scanner.scan(start_tag)
-          @listener.tag_start(@scanner[1], nil)
-          if (@scanner[2] =~ /\/$/)
-            @listener.tag_end(@scanner[1])
-          end
-        elsif @scanner.scan(TEXT)
-          @listener.text(@scanner[1])
-        elsif @scanner.scan(CDATA)
-          @listener.text(@scanner[1])
-        elsif @scanner.scan(end_tag)
-          @listener.tag_end(@scanner[1])
-        else
-          raise UnimplementedElementError.new(UNIMPLEMENTED_ERROR)
-        end
-      end
-    end
-
-    private
-
-    def parse_encoding_from_xml_declaration(xml_declaration)
-      return unless defined?(Encoding)
-
-      xml_encoding = xml_declaration.match(/(?:\A|\s)encoding=(?:"(.*?)"|'(.*?)')(?:\s|\Z)/)
-
-      return if xml_encoding.nil?
-
-      begin
-        Encoding.find(xml_encoding[1])
-      rescue ArgumentError
-        nil
-      end
-    end
-  end
-
-  class PTag
-    def self.mappings
-      @mappings ||= {}
-    end
-
-    def self.inherited(sub_class)
-      key = sub_class.to_s.downcase
-      key.gsub!(/^plist::/, '')
-      key.gsub!(/^p/, '')  unless key == "plist"
-
-      mappings[key] = sub_class
-    end
-
-    attr_accessor :text, :children
-    def initialize
-      @children = []
-    end
-
-    def to_ruby
-      raise "Unimplemented: " + self.class.to_s + "#to_ruby on #{self.inspect}"
-    end
-  end
-
-  class PList < PTag
-    def to_ruby
-      children.first.to_ruby if children.first
-    end
-  end
-
-  class PDict < PTag
-    def to_ruby
-      dict = {}
-      key = nil
-
-      children.each do |c|
-        if key.nil?
-          key = c.to_ruby
-        else
-          dict[key] = c.to_ruby
-          key = nil
-        end
-      end
-
-      dict
-    end
-  end
-
-  class PKey < PTag
-    def to_ruby
-      CGI.unescapeHTML(text || '')
-    end
-  end
-
-  class PString < PTag
-    def to_ruby
-      CGI.unescapeHTML(text || '')
-    end
-  end
-
-  class PArray < PTag
-    def to_ruby
-      children.collect do |c|
-        c.to_ruby
-      end
-    end
-  end
-
-  class PInteger < PTag
-    def to_ruby
-      text.to_i
-    end
-  end
-
-  class PTrue < PTag
-    def to_ruby
-      true
-    end
-  end
-
-  class PFalse < PTag
-    def to_ruby
-      false
-    end
-  end
-
-  class PReal < PTag
-    def to_ruby
-      text.to_f
-    end
-  end
-
-  require 'date'
-  class PDate < PTag
-    def to_ruby
-      DateTime.parse(text)
-    end
-  end
-
-  require 'base64'
-  class PData < PTag
-    def to_ruby
-      data = Base64.decode64(text.gsub(/\s+/, '')) unless text.nil?
-      begin
-        return Marshal.load(data)
-      rescue Exception
-        io = StringIO.new
-        io.write data
-        io.rewind
-        return io
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/plist-3.6.0/lib/plist/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/plist-3.6.0/lib/plist/version.rb
deleted file mode 100644
index 936004a70be2d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/plist-3.6.0/lib/plist/version.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-# encoding: utf-8
-
-module Plist
-  VERSION = '3.6.0'.freeze
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/data/list.txt b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/data/list.txt
deleted file mode 100644
index 237e159cb005b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/data/list.txt
+++ /dev/null
@@ -1,14035 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-// Please pull this list from, and only from https://publicsuffix.org/list/public_suffix_list.dat,
-// rather than any other VCS sites. Pulling from any other URL is not guaranteed to be supported.
-
-// Instructions on pulling and using this list can be found at https://publicsuffix.org/list/.
-
-// ===BEGIN ICANN DOMAINS===
-
-// ac : http://nic.ac/rules.htm
-ac
-com.ac
-edu.ac
-gov.ac
-net.ac
-mil.ac
-org.ac
-
-// ad : https://en.wikipedia.org/wiki/.ad
-ad
-nom.ad
-
-// ae : https://tdra.gov.ae/en/aeda/ae-policies
-ae
-co.ae
-net.ae
-org.ae
-sch.ae
-ac.ae
-gov.ae
-mil.ae
-
-// aero : see https://www.information.aero/index.php?id=66
-aero
-accident-investigation.aero
-accident-prevention.aero
-aerobatic.aero
-aeroclub.aero
-aerodrome.aero
-agents.aero
-aircraft.aero
-airline.aero
-airport.aero
-air-surveillance.aero
-airtraffic.aero
-air-traffic-control.aero
-ambulance.aero
-amusement.aero
-association.aero
-author.aero
-ballooning.aero
-broker.aero
-caa.aero
-cargo.aero
-catering.aero
-certification.aero
-championship.aero
-charter.aero
-civilaviation.aero
-club.aero
-conference.aero
-consultant.aero
-consulting.aero
-control.aero
-council.aero
-crew.aero
-design.aero
-dgca.aero
-educator.aero
-emergency.aero
-engine.aero
-engineer.aero
-entertainment.aero
-equipment.aero
-exchange.aero
-express.aero
-federation.aero
-flight.aero
-fuel.aero
-gliding.aero
-government.aero
-groundhandling.aero
-group.aero
-hanggliding.aero
-homebuilt.aero
-insurance.aero
-journal.aero
-journalist.aero
-leasing.aero
-logistics.aero
-magazine.aero
-maintenance.aero
-media.aero
-microlight.aero
-modelling.aero
-navigation.aero
-parachuting.aero
-paragliding.aero
-passenger-association.aero
-pilot.aero
-press.aero
-production.aero
-recreation.aero
-repbody.aero
-res.aero
-research.aero
-rotorcraft.aero
-safety.aero
-scientist.aero
-services.aero
-show.aero
-skydiving.aero
-software.aero
-student.aero
-trader.aero
-trading.aero
-trainer.aero
-union.aero
-workinggroup.aero
-works.aero
-
-// af : http://www.nic.af/help.jsp
-af
-gov.af
-com.af
-org.af
-net.af
-edu.af
-
-// ag : http://www.nic.ag/prices.htm
-ag
-com.ag
-org.ag
-net.ag
-co.ag
-nom.ag
-
-// ai : http://nic.com.ai/
-ai
-off.ai
-com.ai
-net.ai
-org.ai
-
-// al : http://www.ert.gov.al/ert_alb/faq_det.html?Id=31
-al
-com.al
-edu.al
-gov.al
-mil.al
-net.al
-org.al
-
-// am : https://www.amnic.net/policy/en/Policy_EN.pdf
-am
-co.am
-com.am
-commune.am
-net.am
-org.am
-
-// ao : https://en.wikipedia.org/wiki/.ao
-// http://www.dns.ao/REGISTR.DOC
-ao
-ed.ao
-gv.ao
-og.ao
-co.ao
-pb.ao
-it.ao
-
-// aq : https://en.wikipedia.org/wiki/.aq
-aq
-
-// ar : https://nic.ar/es/nic-argentina/normativa
-ar
-bet.ar
-com.ar
-coop.ar
-edu.ar
-gob.ar
-gov.ar
-int.ar
-mil.ar
-musica.ar
-mutual.ar
-net.ar
-org.ar
-senasa.ar
-tur.ar
-
-// arpa : https://en.wikipedia.org/wiki/.arpa
-// Confirmed by registry <iana-questions@icann.org> 2008-06-18
-arpa
-e164.arpa
-in-addr.arpa
-ip6.arpa
-iris.arpa
-uri.arpa
-urn.arpa
-
-// as : https://en.wikipedia.org/wiki/.as
-as
-gov.as
-
-// asia : https://en.wikipedia.org/wiki/.asia
-asia
-
-// at : https://en.wikipedia.org/wiki/.at
-// Confirmed by registry <it@nic.at> 2008-06-17
-at
-ac.at
-co.at
-gv.at
-or.at
-sth.ac.at
-
-// au : https://en.wikipedia.org/wiki/.au
-// http://www.auda.org.au/
-au
-// 2LDs
-com.au
-net.au
-org.au
-edu.au
-gov.au
-asn.au
-id.au
-// Historic 2LDs (closed to new registration, but sites still exist)
-info.au
-conf.au
-oz.au
-// CGDNs - http://www.cgdn.org.au/
-act.au
-nsw.au
-nt.au
-qld.au
-sa.au
-tas.au
-vic.au
-wa.au
-// 3LDs
-act.edu.au
-catholic.edu.au
-// eq.edu.au - Removed at the request of the Queensland Department of Education
-nsw.edu.au
-nt.edu.au
-qld.edu.au
-sa.edu.au
-tas.edu.au
-vic.edu.au
-wa.edu.au
-// act.gov.au  Bug 984824 - Removed at request of Greg Tankard
-// nsw.gov.au  Bug 547985 - Removed at request of <Shae.Donelan@services.nsw.gov.au>
-// nt.gov.au  Bug 940478 - Removed at request of Greg Connors <Greg.Connors@nt.gov.au>
-qld.gov.au
-sa.gov.au
-tas.gov.au
-vic.gov.au
-wa.gov.au
-// 4LDs
-// education.tas.edu.au - Removed at the request of the Department of Education Tasmania
-schools.nsw.edu.au
-
-// aw : https://en.wikipedia.org/wiki/.aw
-aw
-com.aw
-
-// ax : https://en.wikipedia.org/wiki/.ax
-ax
-
-// az : https://en.wikipedia.org/wiki/.az
-az
-com.az
-net.az
-int.az
-gov.az
-org.az
-edu.az
-info.az
-pp.az
-mil.az
-name.az
-pro.az
-biz.az
-
-// ba : http://nic.ba/users_data/files/pravilnik_o_registraciji.pdf
-ba
-com.ba
-edu.ba
-gov.ba
-mil.ba
-net.ba
-org.ba
-
-// bb : https://en.wikipedia.org/wiki/.bb
-bb
-biz.bb
-co.bb
-com.bb
-edu.bb
-gov.bb
-info.bb
-net.bb
-org.bb
-store.bb
-tv.bb
-
-// bd : https://en.wikipedia.org/wiki/.bd
-*.bd
-
-// be : https://en.wikipedia.org/wiki/.be
-// Confirmed by registry <tech@dns.be> 2008-06-08
-be
-ac.be
-
-// bf : https://en.wikipedia.org/wiki/.bf
-bf
-gov.bf
-
-// bg : https://en.wikipedia.org/wiki/.bg
-// https://www.register.bg/user/static/rules/en/index.html
-bg
-a.bg
-b.bg
-c.bg
-d.bg
-e.bg
-f.bg
-g.bg
-h.bg
-i.bg
-j.bg
-k.bg
-l.bg
-m.bg
-n.bg
-o.bg
-p.bg
-q.bg
-r.bg
-s.bg
-t.bg
-u.bg
-v.bg
-w.bg
-x.bg
-y.bg
-z.bg
-0.bg
-1.bg
-2.bg
-3.bg
-4.bg
-5.bg
-6.bg
-7.bg
-8.bg
-9.bg
-
-// bh : https://en.wikipedia.org/wiki/.bh
-bh
-com.bh
-edu.bh
-net.bh
-org.bh
-gov.bh
-
-// bi : https://en.wikipedia.org/wiki/.bi
-// http://whois.nic.bi/
-bi
-co.bi
-com.bi
-edu.bi
-or.bi
-org.bi
-
-// biz : https://en.wikipedia.org/wiki/.biz
-biz
-
-// bj : https://en.wikipedia.org/wiki/.bj
-bj
-asso.bj
-barreau.bj
-gouv.bj
-
-// bm : http://www.bermudanic.bm/dnr-text.txt
-bm
-com.bm
-edu.bm
-gov.bm
-net.bm
-org.bm
-
-// bn : http://www.bnnic.bn/faqs
-bn
-com.bn
-edu.bn
-gov.bn
-net.bn
-org.bn
-
-// bo : https://nic.bo/delegacion2015.php#h-1.10
-bo
-com.bo
-edu.bo
-gob.bo
-int.bo
-org.bo
-net.bo
-mil.bo
-tv.bo
-web.bo
-// Social Domains
-academia.bo
-agro.bo
-arte.bo
-blog.bo
-bolivia.bo
-ciencia.bo
-cooperativa.bo
-democracia.bo
-deporte.bo
-ecologia.bo
-economia.bo
-empresa.bo
-indigena.bo
-industria.bo
-info.bo
-medicina.bo
-movimiento.bo
-musica.bo
-natural.bo
-nombre.bo
-noticias.bo
-patria.bo
-politica.bo
-profesional.bo
-plurinacional.bo
-pueblo.bo
-revista.bo
-salud.bo
-tecnologia.bo
-tksat.bo
-transporte.bo
-wiki.bo
-
-// br : http://registro.br/dominio/categoria.html
-// Submitted by registry <fneves@registro.br>
-br
-9guacu.br
-abc.br
-adm.br
-adv.br
-agr.br
-aju.br
-am.br
-anani.br
-aparecida.br
-app.br
-arq.br
-art.br
-ato.br
-b.br
-barueri.br
-belem.br
-bhz.br
-bib.br
-bio.br
-blog.br
-bmd.br
-boavista.br
-bsb.br
-campinagrande.br
-campinas.br
-caxias.br
-cim.br
-cng.br
-cnt.br
-com.br
-contagem.br
-coop.br
-coz.br
-cri.br
-cuiaba.br
-curitiba.br
-def.br
-des.br
-det.br
-dev.br
-ecn.br
-eco.br
-edu.br
-emp.br
-enf.br
-eng.br
-esp.br
-etc.br
-eti.br
-far.br
-feira.br
-flog.br
-floripa.br
-fm.br
-fnd.br
-fortal.br
-fot.br
-foz.br
-fst.br
-g12.br
-geo.br
-ggf.br
-goiania.br
-gov.br
-// gov.br 26 states + df https://en.wikipedia.org/wiki/States_of_Brazil
-ac.gov.br
-al.gov.br
-am.gov.br
-ap.gov.br
-ba.gov.br
-ce.gov.br
-df.gov.br
-es.gov.br
-go.gov.br
-ma.gov.br
-mg.gov.br
-ms.gov.br
-mt.gov.br
-pa.gov.br
-pb.gov.br
-pe.gov.br
-pi.gov.br
-pr.gov.br
-rj.gov.br
-rn.gov.br
-ro.gov.br
-rr.gov.br
-rs.gov.br
-sc.gov.br
-se.gov.br
-sp.gov.br
-to.gov.br
-gru.br
-imb.br
-ind.br
-inf.br
-jab.br
-jampa.br
-jdf.br
-joinville.br
-jor.br
-jus.br
-leg.br
-lel.br
-log.br
-londrina.br
-macapa.br
-maceio.br
-manaus.br
-maringa.br
-mat.br
-med.br
-mil.br
-morena.br
-mp.br
-mus.br
-natal.br
-net.br
-niteroi.br
-*.nom.br
-not.br
-ntr.br
-odo.br
-ong.br
-org.br
-osasco.br
-palmas.br
-poa.br
-ppg.br
-pro.br
-psc.br
-psi.br
-pvh.br
-qsl.br
-radio.br
-rec.br
-recife.br
-rep.br
-ribeirao.br
-rio.br
-riobranco.br
-riopreto.br
-salvador.br
-sampa.br
-santamaria.br
-santoandre.br
-saobernardo.br
-saogonca.br
-seg.br
-sjc.br
-slg.br
-slz.br
-sorocaba.br
-srv.br
-taxi.br
-tc.br
-tec.br
-teo.br
-the.br
-tmp.br
-trd.br
-tur.br
-tv.br
-udi.br
-vet.br
-vix.br
-vlog.br
-wiki.br
-zlg.br
-
-// bs : http://www.nic.bs/rules.html
-bs
-com.bs
-net.bs
-org.bs
-edu.bs
-gov.bs
-
-// bt : https://en.wikipedia.org/wiki/.bt
-bt
-com.bt
-edu.bt
-gov.bt
-net.bt
-org.bt
-
-// bv : No registrations at this time.
-// Submitted by registry <jarle@uninett.no>
-bv
-
-// bw : https://en.wikipedia.org/wiki/.bw
-// http://www.gobin.info/domainname/bw.doc
-// list of other 2nd level tlds ?
-bw
-co.bw
-org.bw
-
-// by : https://en.wikipedia.org/wiki/.by
-// http://tld.by/rules_2006_en.html
-// list of other 2nd level tlds ?
-by
-gov.by
-mil.by
-// Official information does not indicate that com.by is a reserved
-// second-level domain, but it's being used as one (see www.google.com.by and
-// www.yahoo.com.by, for example), so we list it here for safety's sake.
-com.by
-
-// http://hoster.by/
-of.by
-
-// bz : https://en.wikipedia.org/wiki/.bz
-// http://www.belizenic.bz/
-bz
-com.bz
-net.bz
-org.bz
-edu.bz
-gov.bz
-
-// ca : https://en.wikipedia.org/wiki/.ca
-ca
-// ca geographical names
-ab.ca
-bc.ca
-mb.ca
-nb.ca
-nf.ca
-nl.ca
-ns.ca
-nt.ca
-nu.ca
-on.ca
-pe.ca
-qc.ca
-sk.ca
-yk.ca
-// gc.ca: https://en.wikipedia.org/wiki/.gc.ca
-// see also: http://registry.gc.ca/en/SubdomainFAQ
-gc.ca
-
-// cat : https://en.wikipedia.org/wiki/.cat
-cat
-
-// cc : https://en.wikipedia.org/wiki/.cc
-cc
-
-// cd : https://en.wikipedia.org/wiki/.cd
-// see also: https://www.nic.cd/domain/insertDomain_2.jsp?act=1
-cd
-gov.cd
-
-// cf : https://en.wikipedia.org/wiki/.cf
-cf
-
-// cg : https://en.wikipedia.org/wiki/.cg
-cg
-
-// ch : https://en.wikipedia.org/wiki/.ch
-ch
-
-// ci : https://en.wikipedia.org/wiki/.ci
-// http://www.nic.ci/index.php?page=charte
-ci
-org.ci
-or.ci
-com.ci
-co.ci
-edu.ci
-ed.ci
-ac.ci
-net.ci
-go.ci
-asso.ci
-aéroport.ci
-int.ci
-presse.ci
-md.ci
-gouv.ci
-
-// ck : https://en.wikipedia.org/wiki/.ck
-*.ck
-!www.ck
-
-// cl : https://www.nic.cl
-// Confirmed by .CL registry <hsalgado@nic.cl>
-cl
-co.cl
-gob.cl
-gov.cl
-mil.cl
-
-// cm : https://en.wikipedia.org/wiki/.cm plus bug 981927
-cm
-co.cm
-com.cm
-gov.cm
-net.cm
-
-// cn : https://en.wikipedia.org/wiki/.cn
-// Submitted by registry <tanyaling@cnnic.cn>
-cn
-ac.cn
-com.cn
-edu.cn
-gov.cn
-net.cn
-org.cn
-mil.cn
-公司.cn
-网络.cn
-網絡.cn
-// cn geographic names
-ah.cn
-bj.cn
-cq.cn
-fj.cn
-gd.cn
-gs.cn
-gz.cn
-gx.cn
-ha.cn
-hb.cn
-he.cn
-hi.cn
-hl.cn
-hn.cn
-jl.cn
-js.cn
-jx.cn
-ln.cn
-nm.cn
-nx.cn
-qh.cn
-sc.cn
-sd.cn
-sh.cn
-sn.cn
-sx.cn
-tj.cn
-xj.cn
-xz.cn
-yn.cn
-zj.cn
-hk.cn
-mo.cn
-tw.cn
-
-// co : https://en.wikipedia.org/wiki/.co
-// Submitted by registry <tecnico@uniandes.edu.co>
-co
-arts.co
-com.co
-edu.co
-firm.co
-gov.co
-info.co
-int.co
-mil.co
-net.co
-nom.co
-org.co
-rec.co
-web.co
-
-// com : https://en.wikipedia.org/wiki/.com
-com
-
-// coop : https://en.wikipedia.org/wiki/.coop
-coop
-
-// cr : http://www.nic.cr/niccr_publico/showRegistroDominiosScreen.do
-cr
-ac.cr
-co.cr
-ed.cr
-fi.cr
-go.cr
-or.cr
-sa.cr
-
-// cu : https://en.wikipedia.org/wiki/.cu
-cu
-com.cu
-edu.cu
-org.cu
-net.cu
-gov.cu
-inf.cu
-
-// cv : https://en.wikipedia.org/wiki/.cv
-// cv : http://www.dns.cv/tldcv_portal/do?com=DS;5446457100;111;+PAGE(4000018)+K-CAT-CODIGO(RDOM)+RCNT(100); <- registration rules
-cv
-com.cv
-edu.cv
-int.cv
-nome.cv
-org.cv
-
-// cw : http://www.una.cw/cw_registry/
-// Confirmed by registry <registry@una.net> 2013-03-26
-cw
-com.cw
-edu.cw
-net.cw
-org.cw
-
-// cx : https://en.wikipedia.org/wiki/.cx
-// list of other 2nd level tlds ?
-cx
-gov.cx
-
-// cy : http://www.nic.cy/
-// Submitted by registry Panayiotou Fotia <cydns@ucy.ac.cy>
-// namespace policies URL https://www.nic.cy/portal//sites/default/files/symfonia_gia_eggrafi.pdf
-cy
-ac.cy
-biz.cy
-com.cy
-ekloges.cy
-gov.cy
-ltd.cy
-mil.cy
-net.cy
-org.cy
-press.cy
-pro.cy
-tm.cy
-
-// cz : https://en.wikipedia.org/wiki/.cz
-cz
-
-// de : https://en.wikipedia.org/wiki/.de
-// Confirmed by registry <ops@denic.de> (with technical
-// reservations) 2008-07-01
-de
-
-// dj : https://en.wikipedia.org/wiki/.dj
-dj
-
-// dk : https://en.wikipedia.org/wiki/.dk
-// Confirmed by registry <robert@dk-hostmaster.dk> 2008-06-17
-dk
-
-// dm : https://en.wikipedia.org/wiki/.dm
-dm
-com.dm
-net.dm
-org.dm
-edu.dm
-gov.dm
-
-// do : https://en.wikipedia.org/wiki/.do
-do
-art.do
-com.do
-edu.do
-gob.do
-gov.do
-mil.do
-net.do
-org.do
-sld.do
-web.do
-
-// dz : http://www.nic.dz/images/pdf_nic/charte.pdf
-dz
-art.dz
-asso.dz
-com.dz
-edu.dz
-gov.dz
-org.dz
-net.dz
-pol.dz
-soc.dz
-tm.dz
-
-// ec : http://www.nic.ec/reg/paso1.asp
-// Submitted by registry <vabboud@nic.ec>
-ec
-com.ec
-info.ec
-net.ec
-fin.ec
-k12.ec
-med.ec
-pro.ec
-org.ec
-edu.ec
-gov.ec
-gob.ec
-mil.ec
-
-// edu : https://en.wikipedia.org/wiki/.edu
-edu
-
-// ee : http://www.eenet.ee/EENet/dom_reeglid.html#lisa_B
-ee
-edu.ee
-gov.ee
-riik.ee
-lib.ee
-med.ee
-com.ee
-pri.ee
-aip.ee
-org.ee
-fie.ee
-
-// eg : https://en.wikipedia.org/wiki/.eg
-eg
-com.eg
-edu.eg
-eun.eg
-gov.eg
-mil.eg
-name.eg
-net.eg
-org.eg
-sci.eg
-
-// er : https://en.wikipedia.org/wiki/.er
-*.er
-
-// es : https://www.nic.es/site_ingles/ingles/dominios/index.html
-es
-com.es
-nom.es
-org.es
-gob.es
-edu.es
-
-// et : https://en.wikipedia.org/wiki/.et
-et
-com.et
-gov.et
-org.et
-edu.et
-biz.et
-name.et
-info.et
-net.et
-
-// eu : https://en.wikipedia.org/wiki/.eu
-eu
-
-// fi : https://en.wikipedia.org/wiki/.fi
-fi
-// aland.fi : https://en.wikipedia.org/wiki/.ax
-// This domain is being phased out in favor of .ax. As there are still many
-// domains under aland.fi, we still keep it on the list until aland.fi is
-// completely removed.
-// TODO: Check for updates (expected to be phased out around Q1/2009)
-aland.fi
-
-// fj : http://domains.fj/
-// Submitted by registry <garth.miller@cocca.org.nz> 2020-02-11
-fj
-ac.fj
-biz.fj
-com.fj
-gov.fj
-info.fj
-mil.fj
-name.fj
-net.fj
-org.fj
-pro.fj
-
-// fk : https://en.wikipedia.org/wiki/.fk
-*.fk
-
-// fm : https://en.wikipedia.org/wiki/.fm
-com.fm
-edu.fm
-net.fm
-org.fm
-fm
-
-// fo : https://en.wikipedia.org/wiki/.fo
-fo
-
-// fr : http://www.afnic.fr/
-// domaines descriptifs : https://www.afnic.fr/medias/documents/Cadre_legal/Afnic_Naming_Policy_12122016_VEN.pdf
-fr
-asso.fr
-com.fr
-gouv.fr
-nom.fr
-prd.fr
-tm.fr
-// domaines sectoriels : https://www.afnic.fr/en/products-and-services/the-fr-tld/sector-based-fr-domains-4.html
-aeroport.fr
-avocat.fr
-avoues.fr
-cci.fr
-chambagri.fr
-chirurgiens-dentistes.fr
-experts-comptables.fr
-geometre-expert.fr
-greta.fr
-huissier-justice.fr
-medecin.fr
-notaires.fr
-pharmacien.fr
-port.fr
-veterinaire.fr
-
-// ga : https://en.wikipedia.org/wiki/.ga
-ga
-
-// gb : This registry is effectively dormant
-// Submitted by registry <Damien.Shaw@ja.net>
-gb
-
-// gd : https://en.wikipedia.org/wiki/.gd
-edu.gd
-gov.gd
-gd
-
-// ge : http://www.nic.net.ge/policy_en.pdf
-ge
-com.ge
-edu.ge
-gov.ge
-org.ge
-mil.ge
-net.ge
-pvt.ge
-
-// gf : https://en.wikipedia.org/wiki/.gf
-gf
-
-// gg : http://www.channelisles.net/register-domains/
-// Confirmed by registry <nigel@channelisles.net> 2013-11-28
-gg
-co.gg
-net.gg
-org.gg
-
-// gh : https://en.wikipedia.org/wiki/.gh
-// see also: http://www.nic.gh/reg_now.php
-// Although domains directly at second level are not possible at the moment,
-// they have been possible for some time and may come back.
-gh
-com.gh
-edu.gh
-gov.gh
-org.gh
-mil.gh
-
-// gi : http://www.nic.gi/rules.html
-gi
-com.gi
-ltd.gi
-gov.gi
-mod.gi
-edu.gi
-org.gi
-
-// gl : https://en.wikipedia.org/wiki/.gl
-// http://nic.gl
-gl
-co.gl
-com.gl
-edu.gl
-net.gl
-org.gl
-
-// gm : http://www.nic.gm/htmlpages%5Cgm-policy.htm
-gm
-
-// gn : http://psg.com/dns/gn/gn.txt
-// Submitted by registry <randy@psg.com>
-gn
-ac.gn
-com.gn
-edu.gn
-gov.gn
-org.gn
-net.gn
-
-// gov : https://en.wikipedia.org/wiki/.gov
-gov
-
-// gp : http://www.nic.gp/index.php?lang=en
-gp
-com.gp
-net.gp
-mobi.gp
-edu.gp
-org.gp
-asso.gp
-
-// gq : https://en.wikipedia.org/wiki/.gq
-gq
-
-// gr : https://grweb.ics.forth.gr/english/1617-B-2005.html
-// Submitted by registry <segred@ics.forth.gr>
-gr
-com.gr
-edu.gr
-net.gr
-org.gr
-gov.gr
-
-// gs : https://en.wikipedia.org/wiki/.gs
-gs
-
-// gt : https://www.gt/sitio/registration_policy.php?lang=en
-gt
-com.gt
-edu.gt
-gob.gt
-ind.gt
-mil.gt
-net.gt
-org.gt
-
-// gu : http://gadao.gov.gu/register.html
-// University of Guam : https://www.uog.edu
-// Submitted by uognoc@triton.uog.edu
-gu
-com.gu
-edu.gu
-gov.gu
-guam.gu
-info.gu
-net.gu
-org.gu
-web.gu
-
-// gw : https://en.wikipedia.org/wiki/.gw
-// gw : https://nic.gw/regras/
-gw
-
-// gy : https://en.wikipedia.org/wiki/.gy
-// http://registry.gy/
-gy
-co.gy
-com.gy
-edu.gy
-gov.gy
-net.gy
-org.gy
-
-// hk : https://www.hkirc.hk
-// Submitted by registry <hk.tech@hkirc.hk>
-hk
-com.hk
-edu.hk
-gov.hk
-idv.hk
-net.hk
-org.hk
-公司.hk
-教育.hk
-敎育.hk
-政府.hk
-個人.hk
-个人.hk
-箇人.hk
-網络.hk
-网络.hk
-组織.hk
-網絡.hk
-网絡.hk
-组织.hk
-組織.hk
-組织.hk
-
-// hm : https://en.wikipedia.org/wiki/.hm
-hm
-
-// hn : http://www.nic.hn/politicas/ps02,,05.html
-hn
-com.hn
-edu.hn
-org.hn
-net.hn
-mil.hn
-gob.hn
-
-// hr : http://www.dns.hr/documents/pdf/HRTLD-regulations.pdf
-hr
-iz.hr
-from.hr
-name.hr
-com.hr
-
-// ht : http://www.nic.ht/info/charte.cfm
-ht
-com.ht
-shop.ht
-firm.ht
-info.ht
-adult.ht
-net.ht
-pro.ht
-org.ht
-med.ht
-art.ht
-coop.ht
-pol.ht
-asso.ht
-edu.ht
-rel.ht
-gouv.ht
-perso.ht
-
-// hu : http://www.domain.hu/domain/English/sld.html
-// Confirmed by registry <pasztor@iszt.hu> 2008-06-12
-hu
-co.hu
-info.hu
-org.hu
-priv.hu
-sport.hu
-tm.hu
-2000.hu
-agrar.hu
-bolt.hu
-casino.hu
-city.hu
-erotica.hu
-erotika.hu
-film.hu
-forum.hu
-games.hu
-hotel.hu
-ingatlan.hu
-jogasz.hu
-konyvelo.hu
-lakas.hu
-media.hu
-news.hu
-reklam.hu
-sex.hu
-shop.hu
-suli.hu
-szex.hu
-tozsde.hu
-utazas.hu
-video.hu
-
-// id : https://pandi.id/en/domain/registration-requirements/
-id
-ac.id
-biz.id
-co.id
-desa.id
-go.id
-mil.id
-my.id
-net.id
-or.id
-ponpes.id
-sch.id
-web.id
-
-// ie : https://en.wikipedia.org/wiki/.ie
-ie
-gov.ie
-
-// il : http://www.isoc.org.il/domains/
-il
-ac.il
-co.il
-gov.il
-idf.il
-k12.il
-muni.il
-net.il
-org.il
-
-// im : https://www.nic.im/
-// Submitted by registry <info@nic.im>
-im
-ac.im
-co.im
-com.im
-ltd.co.im
-net.im
-org.im
-plc.co.im
-tt.im
-tv.im
-
-// in : https://en.wikipedia.org/wiki/.in
-// see also: https://registry.in/Policies
-// Please note, that nic.in is not an official eTLD, but used by most
-// government institutions.
-in
-co.in
-firm.in
-net.in
-org.in
-gen.in
-ind.in
-nic.in
-ac.in
-edu.in
-res.in
-gov.in
-mil.in
-
-// info : https://en.wikipedia.org/wiki/.info
-info
-
-// int : https://en.wikipedia.org/wiki/.int
-// Confirmed by registry <iana-questions@icann.org> 2008-06-18
-int
-eu.int
-
-// io : http://www.nic.io/rules.htm
-// list of other 2nd level tlds ?
-io
-com.io
-
-// iq : http://www.cmc.iq/english/iq/iqregister1.htm
-iq
-gov.iq
-edu.iq
-mil.iq
-com.iq
-org.iq
-net.iq
-
-// ir : http://www.nic.ir/Terms_and_Conditions_ir,_Appendix_1_Domain_Rules
-// Also see http://www.nic.ir/Internationalized_Domain_Names
-// Two <iran>.ir entries added at request of <tech-team@nic.ir>, 2010-04-16
-ir
-ac.ir
-co.ir
-gov.ir
-id.ir
-net.ir
-org.ir
-sch.ir
-// xn--mgba3a4f16a.ir (<iran>.ir, Persian YEH)
-ایران.ir
-// xn--mgba3a4fra.ir (<iran>.ir, Arabic YEH)
-ايران.ir
-
-// is : http://www.isnic.is/domain/rules.php
-// Confirmed by registry <marius@isgate.is> 2008-12-06
-is
-net.is
-com.is
-edu.is
-gov.is
-org.is
-int.is
-
-// it : https://en.wikipedia.org/wiki/.it
-it
-gov.it
-edu.it
-// Reserved geo-names (regions and provinces):
-// https://www.nic.it/sites/default/files/archivio/docs/Regulation_assignation_v7.1.pdf
-// Regions
-abr.it
-abruzzo.it
-aosta-valley.it
-aostavalley.it
-bas.it
-basilicata.it
-cal.it
-calabria.it
-cam.it
-campania.it
-emilia-romagna.it
-emiliaromagna.it
-emr.it
-friuli-v-giulia.it
-friuli-ve-giulia.it
-friuli-vegiulia.it
-friuli-venezia-giulia.it
-friuli-veneziagiulia.it
-friuli-vgiulia.it
-friuliv-giulia.it
-friulive-giulia.it
-friulivegiulia.it
-friulivenezia-giulia.it
-friuliveneziagiulia.it
-friulivgiulia.it
-fvg.it
-laz.it
-lazio.it
-lig.it
-liguria.it
-lom.it
-lombardia.it
-lombardy.it
-lucania.it
-mar.it
-marche.it
-mol.it
-molise.it
-piedmont.it
-piemonte.it
-pmn.it
-pug.it
-puglia.it
-sar.it
-sardegna.it
-sardinia.it
-sic.it
-sicilia.it
-sicily.it
-taa.it
-tos.it
-toscana.it
-trentin-sud-tirol.it
-trentin-süd-tirol.it
-trentin-sudtirol.it
-trentin-südtirol.it
-trentin-sued-tirol.it
-trentin-suedtirol.it
-trentino-a-adige.it
-trentino-aadige.it
-trentino-alto-adige.it
-trentino-altoadige.it
-trentino-s-tirol.it
-trentino-stirol.it
-trentino-sud-tirol.it
-trentino-süd-tirol.it
-trentino-sudtirol.it
-trentino-südtirol.it
-trentino-sued-tirol.it
-trentino-suedtirol.it
-trentino.it
-trentinoa-adige.it
-trentinoaadige.it
-trentinoalto-adige.it
-trentinoaltoadige.it
-trentinos-tirol.it
-trentinostirol.it
-trentinosud-tirol.it
-trentinosüd-tirol.it
-trentinosudtirol.it
-trentinosüdtirol.it
-trentinosued-tirol.it
-trentinosuedtirol.it
-trentinsud-tirol.it
-trentinsüd-tirol.it
-trentinsudtirol.it
-trentinsüdtirol.it
-trentinsued-tirol.it
-trentinsuedtirol.it
-tuscany.it
-umb.it
-umbria.it
-val-d-aosta.it
-val-daosta.it
-vald-aosta.it
-valdaosta.it
-valle-aosta.it
-valle-d-aosta.it
-valle-daosta.it
-valleaosta.it
-valled-aosta.it
-valledaosta.it
-vallee-aoste.it
-vallée-aoste.it
-vallee-d-aoste.it
-vallée-d-aoste.it
-valleeaoste.it
-valléeaoste.it
-valleedaoste.it
-valléedaoste.it
-vao.it
-vda.it
-ven.it
-veneto.it
-// Provinces
-ag.it
-agrigento.it
-al.it
-alessandria.it
-alto-adige.it
-altoadige.it
-an.it
-ancona.it
-andria-barletta-trani.it
-andria-trani-barletta.it
-andriabarlettatrani.it
-andriatranibarletta.it
-ao.it
-aosta.it
-aoste.it
-ap.it
-aq.it
-aquila.it
-ar.it
-arezzo.it
-ascoli-piceno.it
-ascolipiceno.it
-asti.it
-at.it
-av.it
-avellino.it
-ba.it
-balsan-sudtirol.it
-balsan-südtirol.it
-balsan-suedtirol.it
-balsan.it
-bari.it
-barletta-trani-andria.it
-barlettatraniandria.it
-belluno.it
-benevento.it
-bergamo.it
-bg.it
-bi.it
-biella.it
-bl.it
-bn.it
-bo.it
-bologna.it
-bolzano-altoadige.it
-bolzano.it
-bozen-sudtirol.it
-bozen-südtirol.it
-bozen-suedtirol.it
-bozen.it
-br.it
-brescia.it
-brindisi.it
-bs.it
-bt.it
-bulsan-sudtirol.it
-bulsan-südtirol.it
-bulsan-suedtirol.it
-bulsan.it
-bz.it
-ca.it
-cagliari.it
-caltanissetta.it
-campidano-medio.it
-campidanomedio.it
-campobasso.it
-carbonia-iglesias.it
-carboniaiglesias.it
-carrara-massa.it
-carraramassa.it
-caserta.it
-catania.it
-catanzaro.it
-cb.it
-ce.it
-cesena-forli.it
-cesena-forlì.it
-cesenaforli.it
-cesenaforlì.it
-ch.it
-chieti.it
-ci.it
-cl.it
-cn.it
-co.it
-como.it
-cosenza.it
-cr.it
-cremona.it
-crotone.it
-cs.it
-ct.it
-cuneo.it
-cz.it
-dell-ogliastra.it
-dellogliastra.it
-en.it
-enna.it
-fc.it
-fe.it
-fermo.it
-ferrara.it
-fg.it
-fi.it
-firenze.it
-florence.it
-fm.it
-foggia.it
-forli-cesena.it
-forlì-cesena.it
-forlicesena.it
-forlìcesena.it
-fr.it
-frosinone.it
-ge.it
-genoa.it
-genova.it
-go.it
-gorizia.it
-gr.it
-grosseto.it
-iglesias-carbonia.it
-iglesiascarbonia.it
-im.it
-imperia.it
-is.it
-isernia.it
-kr.it
-la-spezia.it
-laquila.it
-laspezia.it
-latina.it
-lc.it
-le.it
-lecce.it
-lecco.it
-li.it
-livorno.it
-lo.it
-lodi.it
-lt.it
-lu.it
-lucca.it
-macerata.it
-mantova.it
-massa-carrara.it
-massacarrara.it
-matera.it
-mb.it
-mc.it
-me.it
-medio-campidano.it
-mediocampidano.it
-messina.it
-mi.it
-milan.it
-milano.it
-mn.it
-mo.it
-modena.it
-monza-brianza.it
-monza-e-della-brianza.it
-monza.it
-monzabrianza.it
-monzaebrianza.it
-monzaedellabrianza.it
-ms.it
-mt.it
-na.it
-naples.it
-napoli.it
-no.it
-novara.it
-nu.it
-nuoro.it
-og.it
-ogliastra.it
-olbia-tempio.it
-olbiatempio.it
-or.it
-oristano.it
-ot.it
-pa.it
-padova.it
-padua.it
-palermo.it
-parma.it
-pavia.it
-pc.it
-pd.it
-pe.it
-perugia.it
-pesaro-urbino.it
-pesarourbino.it
-pescara.it
-pg.it
-pi.it
-piacenza.it
-pisa.it
-pistoia.it
-pn.it
-po.it
-pordenone.it
-potenza.it
-pr.it
-prato.it
-pt.it
-pu.it
-pv.it
-pz.it
-ra.it
-ragusa.it
-ravenna.it
-rc.it
-re.it
-reggio-calabria.it
-reggio-emilia.it
-reggiocalabria.it
-reggioemilia.it
-rg.it
-ri.it
-rieti.it
-rimini.it
-rm.it
-rn.it
-ro.it
-roma.it
-rome.it
-rovigo.it
-sa.it
-salerno.it
-sassari.it
-savona.it
-si.it
-siena.it
-siracusa.it
-so.it
-sondrio.it
-sp.it
-sr.it
-ss.it
-suedtirol.it
-südtirol.it
-sv.it
-ta.it
-taranto.it
-te.it
-tempio-olbia.it
-tempioolbia.it
-teramo.it
-terni.it
-tn.it
-to.it
-torino.it
-tp.it
-tr.it
-trani-andria-barletta.it
-trani-barletta-andria.it
-traniandriabarletta.it
-tranibarlettaandria.it
-trapani.it
-trento.it
-treviso.it
-trieste.it
-ts.it
-turin.it
-tv.it
-ud.it
-udine.it
-urbino-pesaro.it
-urbinopesaro.it
-va.it
-varese.it
-vb.it
-vc.it
-ve.it
-venezia.it
-venice.it
-verbania.it
-vercelli.it
-verona.it
-vi.it
-vibo-valentia.it
-vibovalentia.it
-vicenza.it
-viterbo.it
-vr.it
-vs.it
-vt.it
-vv.it
-
-// je : http://www.channelisles.net/register-domains/
-// Confirmed by registry <nigel@channelisles.net> 2013-11-28
-je
-co.je
-net.je
-org.je
-
-// jm : http://www.com.jm/register.html
-*.jm
-
-// jo : http://www.dns.jo/Registration_policy.aspx
-jo
-com.jo
-org.jo
-net.jo
-edu.jo
-sch.jo
-gov.jo
-mil.jo
-name.jo
-
-// jobs : https://en.wikipedia.org/wiki/.jobs
-jobs
-
-// jp : https://en.wikipedia.org/wiki/.jp
-// http://jprs.co.jp/en/jpdomain.html
-// Submitted by registry <info@jprs.jp>
-jp
-// jp organizational type names
-ac.jp
-ad.jp
-co.jp
-ed.jp
-go.jp
-gr.jp
-lg.jp
-ne.jp
-or.jp
-// jp prefecture type names
-aichi.jp
-akita.jp
-aomori.jp
-chiba.jp
-ehime.jp
-fukui.jp
-fukuoka.jp
-fukushima.jp
-gifu.jp
-gunma.jp
-hiroshima.jp
-hokkaido.jp
-hyogo.jp
-ibaraki.jp
-ishikawa.jp
-iwate.jp
-kagawa.jp
-kagoshima.jp
-kanagawa.jp
-kochi.jp
-kumamoto.jp
-kyoto.jp
-mie.jp
-miyagi.jp
-miyazaki.jp
-nagano.jp
-nagasaki.jp
-nara.jp
-niigata.jp
-oita.jp
-okayama.jp
-okinawa.jp
-osaka.jp
-saga.jp
-saitama.jp
-shiga.jp
-shimane.jp
-shizuoka.jp
-tochigi.jp
-tokushima.jp
-tokyo.jp
-tottori.jp
-toyama.jp
-wakayama.jp
-yamagata.jp
-yamaguchi.jp
-yamanashi.jp
-栃木.jp
-愛知.jp
-愛媛.jp
-兵庫.jp
-熊本.jp
-茨城.jp
-北海道.jp
-千葉.jp
-和歌山.jp
-長崎.jp
-長野.jp
-新潟.jp
-青森.jp
-静岡.jp
-東京.jp
-石川.jp
-埼玉.jp
-三重.jp
-京都.jp
-佐賀.jp
-大分.jp
-大阪.jp
-奈良.jp
-宮城.jp
-宮崎.jp
-富山.jp
-山口.jp
-山形.jp
-山梨.jp
-岩手.jp
-岐阜.jp
-岡山.jp
-島根.jp
-広島.jp
-徳島.jp
-沖縄.jp
-滋賀.jp
-神奈川.jp
-福井.jp
-福岡.jp
-福島.jp
-秋田.jp
-群馬.jp
-香川.jp
-高知.jp
-鳥取.jp
-鹿児島.jp
-// jp geographic type names
-// http://jprs.jp/doc/rule/saisoku-1.html
-*.kawasaki.jp
-*.kitakyushu.jp
-*.kobe.jp
-*.nagoya.jp
-*.sapporo.jp
-*.sendai.jp
-*.yokohama.jp
-!city.kawasaki.jp
-!city.kitakyushu.jp
-!city.kobe.jp
-!city.nagoya.jp
-!city.sapporo.jp
-!city.sendai.jp
-!city.yokohama.jp
-// 4th level registration
-aisai.aichi.jp
-ama.aichi.jp
-anjo.aichi.jp
-asuke.aichi.jp
-chiryu.aichi.jp
-chita.aichi.jp
-fuso.aichi.jp
-gamagori.aichi.jp
-handa.aichi.jp
-hazu.aichi.jp
-hekinan.aichi.jp
-higashiura.aichi.jp
-ichinomiya.aichi.jp
-inazawa.aichi.jp
-inuyama.aichi.jp
-isshiki.aichi.jp
-iwakura.aichi.jp
-kanie.aichi.jp
-kariya.aichi.jp
-kasugai.aichi.jp
-kira.aichi.jp
-kiyosu.aichi.jp
-komaki.aichi.jp
-konan.aichi.jp
-kota.aichi.jp
-mihama.aichi.jp
-miyoshi.aichi.jp
-nishio.aichi.jp
-nisshin.aichi.jp
-obu.aichi.jp
-oguchi.aichi.jp
-oharu.aichi.jp
-okazaki.aichi.jp
-owariasahi.aichi.jp
-seto.aichi.jp
-shikatsu.aichi.jp
-shinshiro.aichi.jp
-shitara.aichi.jp
-tahara.aichi.jp
-takahama.aichi.jp
-tobishima.aichi.jp
-toei.aichi.jp
-togo.aichi.jp
-tokai.aichi.jp
-tokoname.aichi.jp
-toyoake.aichi.jp
-toyohashi.aichi.jp
-toyokawa.aichi.jp
-toyone.aichi.jp
-toyota.aichi.jp
-tsushima.aichi.jp
-yatomi.aichi.jp
-akita.akita.jp
-daisen.akita.jp
-fujisato.akita.jp
-gojome.akita.jp
-hachirogata.akita.jp
-happou.akita.jp
-higashinaruse.akita.jp
-honjo.akita.jp
-honjyo.akita.jp
-ikawa.akita.jp
-kamikoani.akita.jp
-kamioka.akita.jp
-katagami.akita.jp
-kazuno.akita.jp
-kitaakita.akita.jp
-kosaka.akita.jp
-kyowa.akita.jp
-misato.akita.jp
-mitane.akita.jp
-moriyoshi.akita.jp
-nikaho.akita.jp
-noshiro.akita.jp
-odate.akita.jp
-oga.akita.jp
-ogata.akita.jp
-semboku.akita.jp
-yokote.akita.jp
-yurihonjo.akita.jp
-aomori.aomori.jp
-gonohe.aomori.jp
-hachinohe.aomori.jp
-hashikami.aomori.jp
-hiranai.aomori.jp
-hirosaki.aomori.jp
-itayanagi.aomori.jp
-kuroishi.aomori.jp
-misawa.aomori.jp
-mutsu.aomori.jp
-nakadomari.aomori.jp
-noheji.aomori.jp
-oirase.aomori.jp
-owani.aomori.jp
-rokunohe.aomori.jp
-sannohe.aomori.jp
-shichinohe.aomori.jp
-shingo.aomori.jp
-takko.aomori.jp
-towada.aomori.jp
-tsugaru.aomori.jp
-tsuruta.aomori.jp
-abiko.chiba.jp
-asahi.chiba.jp
-chonan.chiba.jp
-chosei.chiba.jp
-choshi.chiba.jp
-chuo.chiba.jp
-funabashi.chiba.jp
-futtsu.chiba.jp
-hanamigawa.chiba.jp
-ichihara.chiba.jp
-ichikawa.chiba.jp
-ichinomiya.chiba.jp
-inzai.chiba.jp
-isumi.chiba.jp
-kamagaya.chiba.jp
-kamogawa.chiba.jp
-kashiwa.chiba.jp
-katori.chiba.jp
-katsuura.chiba.jp
-kimitsu.chiba.jp
-kisarazu.chiba.jp
-kozaki.chiba.jp
-kujukuri.chiba.jp
-kyonan.chiba.jp
-matsudo.chiba.jp
-midori.chiba.jp
-mihama.chiba.jp
-minamiboso.chiba.jp
-mobara.chiba.jp
-mutsuzawa.chiba.jp
-nagara.chiba.jp
-nagareyama.chiba.jp
-narashino.chiba.jp
-narita.chiba.jp
-noda.chiba.jp
-oamishirasato.chiba.jp
-omigawa.chiba.jp
-onjuku.chiba.jp
-otaki.chiba.jp
-sakae.chiba.jp
-sakura.chiba.jp
-shimofusa.chiba.jp
-shirako.chiba.jp
-shiroi.chiba.jp
-shisui.chiba.jp
-sodegaura.chiba.jp
-sosa.chiba.jp
-tako.chiba.jp
-tateyama.chiba.jp
-togane.chiba.jp
-tohnosho.chiba.jp
-tomisato.chiba.jp
-urayasu.chiba.jp
-yachimata.chiba.jp
-yachiyo.chiba.jp
-yokaichiba.chiba.jp
-yokoshibahikari.chiba.jp
-yotsukaido.chiba.jp
-ainan.ehime.jp
-honai.ehime.jp
-ikata.ehime.jp
-imabari.ehime.jp
-iyo.ehime.jp
-kamijima.ehime.jp
-kihoku.ehime.jp
-kumakogen.ehime.jp
-masaki.ehime.jp
-matsuno.ehime.jp
-matsuyama.ehime.jp
-namikata.ehime.jp
-niihama.ehime.jp
-ozu.ehime.jp
-saijo.ehime.jp
-seiyo.ehime.jp
-shikokuchuo.ehime.jp
-tobe.ehime.jp
-toon.ehime.jp
-uchiko.ehime.jp
-uwajima.ehime.jp
-yawatahama.ehime.jp
-echizen.fukui.jp
-eiheiji.fukui.jp
-fukui.fukui.jp
-ikeda.fukui.jp
-katsuyama.fukui.jp
-mihama.fukui.jp
-minamiechizen.fukui.jp
-obama.fukui.jp
-ohi.fukui.jp
-ono.fukui.jp
-sabae.fukui.jp
-sakai.fukui.jp
-takahama.fukui.jp
-tsuruga.fukui.jp
-wakasa.fukui.jp
-ashiya.fukuoka.jp
-buzen.fukuoka.jp
-chikugo.fukuoka.jp
-chikuho.fukuoka.jp
-chikujo.fukuoka.jp
-chikushino.fukuoka.jp
-chikuzen.fukuoka.jp
-chuo.fukuoka.jp
-dazaifu.fukuoka.jp
-fukuchi.fukuoka.jp
-hakata.fukuoka.jp
-higashi.fukuoka.jp
-hirokawa.fukuoka.jp
-hisayama.fukuoka.jp
-iizuka.fukuoka.jp
-inatsuki.fukuoka.jp
-kaho.fukuoka.jp
-kasuga.fukuoka.jp
-kasuya.fukuoka.jp
-kawara.fukuoka.jp
-keisen.fukuoka.jp
-koga.fukuoka.jp
-kurate.fukuoka.jp
-kurogi.fukuoka.jp
-kurume.fukuoka.jp
-minami.fukuoka.jp
-miyako.fukuoka.jp
-miyama.fukuoka.jp
-miyawaka.fukuoka.jp
-mizumaki.fukuoka.jp
-munakata.fukuoka.jp
-nakagawa.fukuoka.jp
-nakama.fukuoka.jp
-nishi.fukuoka.jp
-nogata.fukuoka.jp
-ogori.fukuoka.jp
-okagaki.fukuoka.jp
-okawa.fukuoka.jp
-oki.fukuoka.jp
-omuta.fukuoka.jp
-onga.fukuoka.jp
-onojo.fukuoka.jp
-oto.fukuoka.jp
-saigawa.fukuoka.jp
-sasaguri.fukuoka.jp
-shingu.fukuoka.jp
-shinyoshitomi.fukuoka.jp
-shonai.fukuoka.jp
-soeda.fukuoka.jp
-sue.fukuoka.jp
-tachiarai.fukuoka.jp
-tagawa.fukuoka.jp
-takata.fukuoka.jp
-toho.fukuoka.jp
-toyotsu.fukuoka.jp
-tsuiki.fukuoka.jp
-ukiha.fukuoka.jp
-umi.fukuoka.jp
-usui.fukuoka.jp
-yamada.fukuoka.jp
-yame.fukuoka.jp
-yanagawa.fukuoka.jp
-yukuhashi.fukuoka.jp
-aizubange.fukushima.jp
-aizumisato.fukushima.jp
-aizuwakamatsu.fukushima.jp
-asakawa.fukushima.jp
-bandai.fukushima.jp
-date.fukushima.jp
-fukushima.fukushima.jp
-furudono.fukushima.jp
-futaba.fukushima.jp
-hanawa.fukushima.jp
-higashi.fukushima.jp
-hirata.fukushima.jp
-hirono.fukushima.jp
-iitate.fukushima.jp
-inawashiro.fukushima.jp
-ishikawa.fukushima.jp
-iwaki.fukushima.jp
-izumizaki.fukushima.jp
-kagamiishi.fukushima.jp
-kaneyama.fukushima.jp
-kawamata.fukushima.jp
-kitakata.fukushima.jp
-kitashiobara.fukushima.jp
-koori.fukushima.jp
-koriyama.fukushima.jp
-kunimi.fukushima.jp
-miharu.fukushima.jp
-mishima.fukushima.jp
-namie.fukushima.jp
-nango.fukushima.jp
-nishiaizu.fukushima.jp
-nishigo.fukushima.jp
-okuma.fukushima.jp
-omotego.fukushima.jp
-ono.fukushima.jp
-otama.fukushima.jp
-samegawa.fukushima.jp
-shimogo.fukushima.jp
-shirakawa.fukushima.jp
-showa.fukushima.jp
-soma.fukushima.jp
-sukagawa.fukushima.jp
-taishin.fukushima.jp
-tamakawa.fukushima.jp
-tanagura.fukushima.jp
-tenei.fukushima.jp
-yabuki.fukushima.jp
-yamato.fukushima.jp
-yamatsuri.fukushima.jp
-yanaizu.fukushima.jp
-yugawa.fukushima.jp
-anpachi.gifu.jp
-ena.gifu.jp
-gifu.gifu.jp
-ginan.gifu.jp
-godo.gifu.jp
-gujo.gifu.jp
-hashima.gifu.jp
-hichiso.gifu.jp
-hida.gifu.jp
-higashishirakawa.gifu.jp
-ibigawa.gifu.jp
-ikeda.gifu.jp
-kakamigahara.gifu.jp
-kani.gifu.jp
-kasahara.gifu.jp
-kasamatsu.gifu.jp
-kawaue.gifu.jp
-kitagata.gifu.jp
-mino.gifu.jp
-minokamo.gifu.jp
-mitake.gifu.jp
-mizunami.gifu.jp
-motosu.gifu.jp
-nakatsugawa.gifu.jp
-ogaki.gifu.jp
-sakahogi.gifu.jp
-seki.gifu.jp
-sekigahara.gifu.jp
-shirakawa.gifu.jp
-tajimi.gifu.jp
-takayama.gifu.jp
-tarui.gifu.jp
-toki.gifu.jp
-tomika.gifu.jp
-wanouchi.gifu.jp
-yamagata.gifu.jp
-yaotsu.gifu.jp
-yoro.gifu.jp
-annaka.gunma.jp
-chiyoda.gunma.jp
-fujioka.gunma.jp
-higashiagatsuma.gunma.jp
-isesaki.gunma.jp
-itakura.gunma.jp
-kanna.gunma.jp
-kanra.gunma.jp
-katashina.gunma.jp
-kawaba.gunma.jp
-kiryu.gunma.jp
-kusatsu.gunma.jp
-maebashi.gunma.jp
-meiwa.gunma.jp
-midori.gunma.jp
-minakami.gunma.jp
-naganohara.gunma.jp
-nakanojo.gunma.jp
-nanmoku.gunma.jp
-numata.gunma.jp
-oizumi.gunma.jp
-ora.gunma.jp
-ota.gunma.jp
-shibukawa.gunma.jp
-shimonita.gunma.jp
-shinto.gunma.jp
-showa.gunma.jp
-takasaki.gunma.jp
-takayama.gunma.jp
-tamamura.gunma.jp
-tatebayashi.gunma.jp
-tomioka.gunma.jp
-tsukiyono.gunma.jp
-tsumagoi.gunma.jp
-ueno.gunma.jp
-yoshioka.gunma.jp
-asaminami.hiroshima.jp
-daiwa.hiroshima.jp
-etajima.hiroshima.jp
-fuchu.hiroshima.jp
-fukuyama.hiroshima.jp
-hatsukaichi.hiroshima.jp
-higashihiroshima.hiroshima.jp
-hongo.hiroshima.jp
-jinsekikogen.hiroshima.jp
-kaita.hiroshima.jp
-kui.hiroshima.jp
-kumano.hiroshima.jp
-kure.hiroshima.jp
-mihara.hiroshima.jp
-miyoshi.hiroshima.jp
-naka.hiroshima.jp
-onomichi.hiroshima.jp
-osakikamijima.hiroshima.jp
-otake.hiroshima.jp
-saka.hiroshima.jp
-sera.hiroshima.jp
-seranishi.hiroshima.jp
-shinichi.hiroshima.jp
-shobara.hiroshima.jp
-takehara.hiroshima.jp
-abashiri.hokkaido.jp
-abira.hokkaido.jp
-aibetsu.hokkaido.jp
-akabira.hokkaido.jp
-akkeshi.hokkaido.jp
-asahikawa.hokkaido.jp
-ashibetsu.hokkaido.jp
-ashoro.hokkaido.jp
-assabu.hokkaido.jp
-atsuma.hokkaido.jp
-bibai.hokkaido.jp
-biei.hokkaido.jp
-bifuka.hokkaido.jp
-bihoro.hokkaido.jp
-biratori.hokkaido.jp
-chippubetsu.hokkaido.jp
-chitose.hokkaido.jp
-date.hokkaido.jp
-ebetsu.hokkaido.jp
-embetsu.hokkaido.jp
-eniwa.hokkaido.jp
-erimo.hokkaido.jp
-esan.hokkaido.jp
-esashi.hokkaido.jp
-fukagawa.hokkaido.jp
-fukushima.hokkaido.jp
-furano.hokkaido.jp
-furubira.hokkaido.jp
-haboro.hokkaido.jp
-hakodate.hokkaido.jp
-hamatonbetsu.hokkaido.jp
-hidaka.hokkaido.jp
-higashikagura.hokkaido.jp
-higashikawa.hokkaido.jp
-hiroo.hokkaido.jp
-hokuryu.hokkaido.jp
-hokuto.hokkaido.jp
-honbetsu.hokkaido.jp
-horokanai.hokkaido.jp
-horonobe.hokkaido.jp
-ikeda.hokkaido.jp
-imakane.hokkaido.jp
-ishikari.hokkaido.jp
-iwamizawa.hokkaido.jp
-iwanai.hokkaido.jp
-kamifurano.hokkaido.jp
-kamikawa.hokkaido.jp
-kamishihoro.hokkaido.jp
-kamisunagawa.hokkaido.jp
-kamoenai.hokkaido.jp
-kayabe.hokkaido.jp
-kembuchi.hokkaido.jp
-kikonai.hokkaido.jp
-kimobetsu.hokkaido.jp
-kitahiroshima.hokkaido.jp
-kitami.hokkaido.jp
-kiyosato.hokkaido.jp
-koshimizu.hokkaido.jp
-kunneppu.hokkaido.jp
-kuriyama.hokkaido.jp
-kuromatsunai.hokkaido.jp
-kushiro.hokkaido.jp
-kutchan.hokkaido.jp
-kyowa.hokkaido.jp
-mashike.hokkaido.jp
-matsumae.hokkaido.jp
-mikasa.hokkaido.jp
-minamifurano.hokkaido.jp
-mombetsu.hokkaido.jp
-moseushi.hokkaido.jp
-mukawa.hokkaido.jp
-muroran.hokkaido.jp
-naie.hokkaido.jp
-nakagawa.hokkaido.jp
-nakasatsunai.hokkaido.jp
-nakatombetsu.hokkaido.jp
-nanae.hokkaido.jp
-nanporo.hokkaido.jp
-nayoro.hokkaido.jp
-nemuro.hokkaido.jp
-niikappu.hokkaido.jp
-niki.hokkaido.jp
-nishiokoppe.hokkaido.jp
-noboribetsu.hokkaido.jp
-numata.hokkaido.jp
-obihiro.hokkaido.jp
-obira.hokkaido.jp
-oketo.hokkaido.jp
-okoppe.hokkaido.jp
-otaru.hokkaido.jp
-otobe.hokkaido.jp
-otofuke.hokkaido.jp
-otoineppu.hokkaido.jp
-oumu.hokkaido.jp
-ozora.hokkaido.jp
-pippu.hokkaido.jp
-rankoshi.hokkaido.jp
-rebun.hokkaido.jp
-rikubetsu.hokkaido.jp
-rishiri.hokkaido.jp
-rishirifuji.hokkaido.jp
-saroma.hokkaido.jp
-sarufutsu.hokkaido.jp
-shakotan.hokkaido.jp
-shari.hokkaido.jp
-shibecha.hokkaido.jp
-shibetsu.hokkaido.jp
-shikabe.hokkaido.jp
-shikaoi.hokkaido.jp
-shimamaki.hokkaido.jp
-shimizu.hokkaido.jp
-shimokawa.hokkaido.jp
-shinshinotsu.hokkaido.jp
-shintoku.hokkaido.jp
-shiranuka.hokkaido.jp
-shiraoi.hokkaido.jp
-shiriuchi.hokkaido.jp
-sobetsu.hokkaido.jp
-sunagawa.hokkaido.jp
-taiki.hokkaido.jp
-takasu.hokkaido.jp
-takikawa.hokkaido.jp
-takinoue.hokkaido.jp
-teshikaga.hokkaido.jp
-tobetsu.hokkaido.jp
-tohma.hokkaido.jp
-tomakomai.hokkaido.jp
-tomari.hokkaido.jp
-toya.hokkaido.jp
-toyako.hokkaido.jp
-toyotomi.hokkaido.jp
-toyoura.hokkaido.jp
-tsubetsu.hokkaido.jp
-tsukigata.hokkaido.jp
-urakawa.hokkaido.jp
-urausu.hokkaido.jp
-uryu.hokkaido.jp
-utashinai.hokkaido.jp
-wakkanai.hokkaido.jp
-wassamu.hokkaido.jp
-yakumo.hokkaido.jp
-yoichi.hokkaido.jp
-aioi.hyogo.jp
-akashi.hyogo.jp
-ako.hyogo.jp
-amagasaki.hyogo.jp
-aogaki.hyogo.jp
-asago.hyogo.jp
-ashiya.hyogo.jp
-awaji.hyogo.jp
-fukusaki.hyogo.jp
-goshiki.hyogo.jp
-harima.hyogo.jp
-himeji.hyogo.jp
-ichikawa.hyogo.jp
-inagawa.hyogo.jp
-itami.hyogo.jp
-kakogawa.hyogo.jp
-kamigori.hyogo.jp
-kamikawa.hyogo.jp
-kasai.hyogo.jp
-kasuga.hyogo.jp
-kawanishi.hyogo.jp
-miki.hyogo.jp
-minamiawaji.hyogo.jp
-nishinomiya.hyogo.jp
-nishiwaki.hyogo.jp
-ono.hyogo.jp
-sanda.hyogo.jp
-sannan.hyogo.jp
-sasayama.hyogo.jp
-sayo.hyogo.jp
-shingu.hyogo.jp
-shinonsen.hyogo.jp
-shiso.hyogo.jp
-sumoto.hyogo.jp
-taishi.hyogo.jp
-taka.hyogo.jp
-takarazuka.hyogo.jp
-takasago.hyogo.jp
-takino.hyogo.jp
-tamba.hyogo.jp
-tatsuno.hyogo.jp
-toyooka.hyogo.jp
-yabu.hyogo.jp
-yashiro.hyogo.jp
-yoka.hyogo.jp
-yokawa.hyogo.jp
-ami.ibaraki.jp
-asahi.ibaraki.jp
-bando.ibaraki.jp
-chikusei.ibaraki.jp
-daigo.ibaraki.jp
-fujishiro.ibaraki.jp
-hitachi.ibaraki.jp
-hitachinaka.ibaraki.jp
-hitachiomiya.ibaraki.jp
-hitachiota.ibaraki.jp
-ibaraki.ibaraki.jp
-ina.ibaraki.jp
-inashiki.ibaraki.jp
-itako.ibaraki.jp
-iwama.ibaraki.jp
-joso.ibaraki.jp
-kamisu.ibaraki.jp
-kasama.ibaraki.jp
-kashima.ibaraki.jp
-kasumigaura.ibaraki.jp
-koga.ibaraki.jp
-miho.ibaraki.jp
-mito.ibaraki.jp
-moriya.ibaraki.jp
-naka.ibaraki.jp
-namegata.ibaraki.jp
-oarai.ibaraki.jp
-ogawa.ibaraki.jp
-omitama.ibaraki.jp
-ryugasaki.ibaraki.jp
-sakai.ibaraki.jp
-sakuragawa.ibaraki.jp
-shimodate.ibaraki.jp
-shimotsuma.ibaraki.jp
-shirosato.ibaraki.jp
-sowa.ibaraki.jp
-suifu.ibaraki.jp
-takahagi.ibaraki.jp
-tamatsukuri.ibaraki.jp
-tokai.ibaraki.jp
-tomobe.ibaraki.jp
-tone.ibaraki.jp
-toride.ibaraki.jp
-tsuchiura.ibaraki.jp
-tsukuba.ibaraki.jp
-uchihara.ibaraki.jp
-ushiku.ibaraki.jp
-yachiyo.ibaraki.jp
-yamagata.ibaraki.jp
-yawara.ibaraki.jp
-yuki.ibaraki.jp
-anamizu.ishikawa.jp
-hakui.ishikawa.jp
-hakusan.ishikawa.jp
-kaga.ishikawa.jp
-kahoku.ishikawa.jp
-kanazawa.ishikawa.jp
-kawakita.ishikawa.jp
-komatsu.ishikawa.jp
-nakanoto.ishikawa.jp
-nanao.ishikawa.jp
-nomi.ishikawa.jp
-nonoichi.ishikawa.jp
-noto.ishikawa.jp
-shika.ishikawa.jp
-suzu.ishikawa.jp
-tsubata.ishikawa.jp
-tsurugi.ishikawa.jp
-uchinada.ishikawa.jp
-wajima.ishikawa.jp
-fudai.iwate.jp
-fujisawa.iwate.jp
-hanamaki.iwate.jp
-hiraizumi.iwate.jp
-hirono.iwate.jp
-ichinohe.iwate.jp
-ichinoseki.iwate.jp
-iwaizumi.iwate.jp
-iwate.iwate.jp
-joboji.iwate.jp
-kamaishi.iwate.jp
-kanegasaki.iwate.jp
-karumai.iwate.jp
-kawai.iwate.jp
-kitakami.iwate.jp
-kuji.iwate.jp
-kunohe.iwate.jp
-kuzumaki.iwate.jp
-miyako.iwate.jp
-mizusawa.iwate.jp
-morioka.iwate.jp
-ninohe.iwate.jp
-noda.iwate.jp
-ofunato.iwate.jp
-oshu.iwate.jp
-otsuchi.iwate.jp
-rikuzentakata.iwate.jp
-shiwa.iwate.jp
-shizukuishi.iwate.jp
-sumita.iwate.jp
-tanohata.iwate.jp
-tono.iwate.jp
-yahaba.iwate.jp
-yamada.iwate.jp
-ayagawa.kagawa.jp
-higashikagawa.kagawa.jp
-kanonji.kagawa.jp
-kotohira.kagawa.jp
-manno.kagawa.jp
-marugame.kagawa.jp
-mitoyo.kagawa.jp
-naoshima.kagawa.jp
-sanuki.kagawa.jp
-tadotsu.kagawa.jp
-takamatsu.kagawa.jp
-tonosho.kagawa.jp
-uchinomi.kagawa.jp
-utazu.kagawa.jp
-zentsuji.kagawa.jp
-akune.kagoshima.jp
-amami.kagoshima.jp
-hioki.kagoshima.jp
-isa.kagoshima.jp
-isen.kagoshima.jp
-izumi.kagoshima.jp
-kagoshima.kagoshima.jp
-kanoya.kagoshima.jp
-kawanabe.kagoshima.jp
-kinko.kagoshima.jp
-kouyama.kagoshima.jp
-makurazaki.kagoshima.jp
-matsumoto.kagoshima.jp
-minamitane.kagoshima.jp
-nakatane.kagoshima.jp
-nishinoomote.kagoshima.jp
-satsumasendai.kagoshima.jp
-soo.kagoshima.jp
-tarumizu.kagoshima.jp
-yusui.kagoshima.jp
-aikawa.kanagawa.jp
-atsugi.kanagawa.jp
-ayase.kanagawa.jp
-chigasaki.kanagawa.jp
-ebina.kanagawa.jp
-fujisawa.kanagawa.jp
-hadano.kanagawa.jp
-hakone.kanagawa.jp
-hiratsuka.kanagawa.jp
-isehara.kanagawa.jp
-kaisei.kanagawa.jp
-kamakura.kanagawa.jp
-kiyokawa.kanagawa.jp
-matsuda.kanagawa.jp
-minamiashigara.kanagawa.jp
-miura.kanagawa.jp
-nakai.kanagawa.jp
-ninomiya.kanagawa.jp
-odawara.kanagawa.jp
-oi.kanagawa.jp
-oiso.kanagawa.jp
-sagamihara.kanagawa.jp
-samukawa.kanagawa.jp
-tsukui.kanagawa.jp
-yamakita.kanagawa.jp
-yamato.kanagawa.jp
-yokosuka.kanagawa.jp
-yugawara.kanagawa.jp
-zama.kanagawa.jp
-zushi.kanagawa.jp
-aki.kochi.jp
-geisei.kochi.jp
-hidaka.kochi.jp
-higashitsuno.kochi.jp
-ino.kochi.jp
-kagami.kochi.jp
-kami.kochi.jp
-kitagawa.kochi.jp
-kochi.kochi.jp
-mihara.kochi.jp
-motoyama.kochi.jp
-muroto.kochi.jp
-nahari.kochi.jp
-nakamura.kochi.jp
-nankoku.kochi.jp
-nishitosa.kochi.jp
-niyodogawa.kochi.jp
-ochi.kochi.jp
-okawa.kochi.jp
-otoyo.kochi.jp
-otsuki.kochi.jp
-sakawa.kochi.jp
-sukumo.kochi.jp
-susaki.kochi.jp
-tosa.kochi.jp
-tosashimizu.kochi.jp
-toyo.kochi.jp
-tsuno.kochi.jp
-umaji.kochi.jp
-yasuda.kochi.jp
-yusuhara.kochi.jp
-amakusa.kumamoto.jp
-arao.kumamoto.jp
-aso.kumamoto.jp
-choyo.kumamoto.jp
-gyokuto.kumamoto.jp
-kamiamakusa.kumamoto.jp
-kikuchi.kumamoto.jp
-kumamoto.kumamoto.jp
-mashiki.kumamoto.jp
-mifune.kumamoto.jp
-minamata.kumamoto.jp
-minamioguni.kumamoto.jp
-nagasu.kumamoto.jp
-nishihara.kumamoto.jp
-oguni.kumamoto.jp
-ozu.kumamoto.jp
-sumoto.kumamoto.jp
-takamori.kumamoto.jp
-uki.kumamoto.jp
-uto.kumamoto.jp
-yamaga.kumamoto.jp
-yamato.kumamoto.jp
-yatsushiro.kumamoto.jp
-ayabe.kyoto.jp
-fukuchiyama.kyoto.jp
-higashiyama.kyoto.jp
-ide.kyoto.jp
-ine.kyoto.jp
-joyo.kyoto.jp
-kameoka.kyoto.jp
-kamo.kyoto.jp
-kita.kyoto.jp
-kizu.kyoto.jp
-kumiyama.kyoto.jp
-kyotamba.kyoto.jp
-kyotanabe.kyoto.jp
-kyotango.kyoto.jp
-maizuru.kyoto.jp
-minami.kyoto.jp
-minamiyamashiro.kyoto.jp
-miyazu.kyoto.jp
-muko.kyoto.jp
-nagaokakyo.kyoto.jp
-nakagyo.kyoto.jp
-nantan.kyoto.jp
-oyamazaki.kyoto.jp
-sakyo.kyoto.jp
-seika.kyoto.jp
-tanabe.kyoto.jp
-uji.kyoto.jp
-ujitawara.kyoto.jp
-wazuka.kyoto.jp
-yamashina.kyoto.jp
-yawata.kyoto.jp
-asahi.mie.jp
-inabe.mie.jp
-ise.mie.jp
-kameyama.mie.jp
-kawagoe.mie.jp
-kiho.mie.jp
-kisosaki.mie.jp
-kiwa.mie.jp
-komono.mie.jp
-kumano.mie.jp
-kuwana.mie.jp
-matsusaka.mie.jp
-meiwa.mie.jp
-mihama.mie.jp
-minamiise.mie.jp
-misugi.mie.jp
-miyama.mie.jp
-nabari.mie.jp
-shima.mie.jp
-suzuka.mie.jp
-tado.mie.jp
-taiki.mie.jp
-taki.mie.jp
-tamaki.mie.jp
-toba.mie.jp
-tsu.mie.jp
-udono.mie.jp
-ureshino.mie.jp
-watarai.mie.jp
-yokkaichi.mie.jp
-furukawa.miyagi.jp
-higashimatsushima.miyagi.jp
-ishinomaki.miyagi.jp
-iwanuma.miyagi.jp
-kakuda.miyagi.jp
-kami.miyagi.jp
-kawasaki.miyagi.jp
-marumori.miyagi.jp
-matsushima.miyagi.jp
-minamisanriku.miyagi.jp
-misato.miyagi.jp
-murata.miyagi.jp
-natori.miyagi.jp
-ogawara.miyagi.jp
-ohira.miyagi.jp
-onagawa.miyagi.jp
-osaki.miyagi.jp
-rifu.miyagi.jp
-semine.miyagi.jp
-shibata.miyagi.jp
-shichikashuku.miyagi.jp
-shikama.miyagi.jp
-shiogama.miyagi.jp
-shiroishi.miyagi.jp
-tagajo.miyagi.jp
-taiwa.miyagi.jp
-tome.miyagi.jp
-tomiya.miyagi.jp
-wakuya.miyagi.jp
-watari.miyagi.jp
-yamamoto.miyagi.jp
-zao.miyagi.jp
-aya.miyazaki.jp
-ebino.miyazaki.jp
-gokase.miyazaki.jp
-hyuga.miyazaki.jp
-kadogawa.miyazaki.jp
-kawaminami.miyazaki.jp
-kijo.miyazaki.jp
-kitagawa.miyazaki.jp
-kitakata.miyazaki.jp
-kitaura.miyazaki.jp
-kobayashi.miyazaki.jp
-kunitomi.miyazaki.jp
-kushima.miyazaki.jp
-mimata.miyazaki.jp
-miyakonojo.miyazaki.jp
-miyazaki.miyazaki.jp
-morotsuka.miyazaki.jp
-nichinan.miyazaki.jp
-nishimera.miyazaki.jp
-nobeoka.miyazaki.jp
-saito.miyazaki.jp
-shiiba.miyazaki.jp
-shintomi.miyazaki.jp
-takaharu.miyazaki.jp
-takanabe.miyazaki.jp
-takazaki.miyazaki.jp
-tsuno.miyazaki.jp
-achi.nagano.jp
-agematsu.nagano.jp
-anan.nagano.jp
-aoki.nagano.jp
-asahi.nagano.jp
-azumino.nagano.jp
-chikuhoku.nagano.jp
-chikuma.nagano.jp
-chino.nagano.jp
-fujimi.nagano.jp
-hakuba.nagano.jp
-hara.nagano.jp
-hiraya.nagano.jp
-iida.nagano.jp
-iijima.nagano.jp
-iiyama.nagano.jp
-iizuna.nagano.jp
-ikeda.nagano.jp
-ikusaka.nagano.jp
-ina.nagano.jp
-karuizawa.nagano.jp
-kawakami.nagano.jp
-kiso.nagano.jp
-kisofukushima.nagano.jp
-kitaaiki.nagano.jp
-komagane.nagano.jp
-komoro.nagano.jp
-matsukawa.nagano.jp
-matsumoto.nagano.jp
-miasa.nagano.jp
-minamiaiki.nagano.jp
-minamimaki.nagano.jp
-minamiminowa.nagano.jp
-minowa.nagano.jp
-miyada.nagano.jp
-miyota.nagano.jp
-mochizuki.nagano.jp
-nagano.nagano.jp
-nagawa.nagano.jp
-nagiso.nagano.jp
-nakagawa.nagano.jp
-nakano.nagano.jp
-nozawaonsen.nagano.jp
-obuse.nagano.jp
-ogawa.nagano.jp
-okaya.nagano.jp
-omachi.nagano.jp
-omi.nagano.jp
-ookuwa.nagano.jp
-ooshika.nagano.jp
-otaki.nagano.jp
-otari.nagano.jp
-sakae.nagano.jp
-sakaki.nagano.jp
-saku.nagano.jp
-sakuho.nagano.jp
-shimosuwa.nagano.jp
-shinanomachi.nagano.jp
-shiojiri.nagano.jp
-suwa.nagano.jp
-suzaka.nagano.jp
-takagi.nagano.jp
-takamori.nagano.jp
-takayama.nagano.jp
-tateshina.nagano.jp
-tatsuno.nagano.jp
-togakushi.nagano.jp
-togura.nagano.jp
-tomi.nagano.jp
-ueda.nagano.jp
-wada.nagano.jp
-yamagata.nagano.jp
-yamanouchi.nagano.jp
-yasaka.nagano.jp
-yasuoka.nagano.jp
-chijiwa.nagasaki.jp
-futsu.nagasaki.jp
-goto.nagasaki.jp
-hasami.nagasaki.jp
-hirado.nagasaki.jp
-iki.nagasaki.jp
-isahaya.nagasaki.jp
-kawatana.nagasaki.jp
-kuchinotsu.nagasaki.jp
-matsuura.nagasaki.jp
-nagasaki.nagasaki.jp
-obama.nagasaki.jp
-omura.nagasaki.jp
-oseto.nagasaki.jp
-saikai.nagasaki.jp
-sasebo.nagasaki.jp
-seihi.nagasaki.jp
-shimabara.nagasaki.jp
-shinkamigoto.nagasaki.jp
-togitsu.nagasaki.jp
-tsushima.nagasaki.jp
-unzen.nagasaki.jp
-ando.nara.jp
-gose.nara.jp
-heguri.nara.jp
-higashiyoshino.nara.jp
-ikaruga.nara.jp
-ikoma.nara.jp
-kamikitayama.nara.jp
-kanmaki.nara.jp
-kashiba.nara.jp
-kashihara.nara.jp
-katsuragi.nara.jp
-kawai.nara.jp
-kawakami.nara.jp
-kawanishi.nara.jp
-koryo.nara.jp
-kurotaki.nara.jp
-mitsue.nara.jp
-miyake.nara.jp
-nara.nara.jp
-nosegawa.nara.jp
-oji.nara.jp
-ouda.nara.jp
-oyodo.nara.jp
-sakurai.nara.jp
-sango.nara.jp
-shimoichi.nara.jp
-shimokitayama.nara.jp
-shinjo.nara.jp
-soni.nara.jp
-takatori.nara.jp
-tawaramoto.nara.jp
-tenkawa.nara.jp
-tenri.nara.jp
-uda.nara.jp
-yamatokoriyama.nara.jp
-yamatotakada.nara.jp
-yamazoe.nara.jp
-yoshino.nara.jp
-aga.niigata.jp
-agano.niigata.jp
-gosen.niigata.jp
-itoigawa.niigata.jp
-izumozaki.niigata.jp
-joetsu.niigata.jp
-kamo.niigata.jp
-kariwa.niigata.jp
-kashiwazaki.niigata.jp
-minamiuonuma.niigata.jp
-mitsuke.niigata.jp
-muika.niigata.jp
-murakami.niigata.jp
-myoko.niigata.jp
-nagaoka.niigata.jp
-niigata.niigata.jp
-ojiya.niigata.jp
-omi.niigata.jp
-sado.niigata.jp
-sanjo.niigata.jp
-seiro.niigata.jp
-seirou.niigata.jp
-sekikawa.niigata.jp
-shibata.niigata.jp
-tagami.niigata.jp
-tainai.niigata.jp
-tochio.niigata.jp
-tokamachi.niigata.jp
-tsubame.niigata.jp
-tsunan.niigata.jp
-uonuma.niigata.jp
-yahiko.niigata.jp
-yoita.niigata.jp
-yuzawa.niigata.jp
-beppu.oita.jp
-bungoono.oita.jp
-bungotakada.oita.jp
-hasama.oita.jp
-hiji.oita.jp
-himeshima.oita.jp
-hita.oita.jp
-kamitsue.oita.jp
-kokonoe.oita.jp
-kuju.oita.jp
-kunisaki.oita.jp
-kusu.oita.jp
-oita.oita.jp
-saiki.oita.jp
-taketa.oita.jp
-tsukumi.oita.jp
-usa.oita.jp
-usuki.oita.jp
-yufu.oita.jp
-akaiwa.okayama.jp
-asakuchi.okayama.jp
-bizen.okayama.jp
-hayashima.okayama.jp
-ibara.okayama.jp
-kagamino.okayama.jp
-kasaoka.okayama.jp
-kibichuo.okayama.jp
-kumenan.okayama.jp
-kurashiki.okayama.jp
-maniwa.okayama.jp
-misaki.okayama.jp
-nagi.okayama.jp
-niimi.okayama.jp
-nishiawakura.okayama.jp
-okayama.okayama.jp
-satosho.okayama.jp
-setouchi.okayama.jp
-shinjo.okayama.jp
-shoo.okayama.jp
-soja.okayama.jp
-takahashi.okayama.jp
-tamano.okayama.jp
-tsuyama.okayama.jp
-wake.okayama.jp
-yakage.okayama.jp
-aguni.okinawa.jp
-ginowan.okinawa.jp
-ginoza.okinawa.jp
-gushikami.okinawa.jp
-haebaru.okinawa.jp
-higashi.okinawa.jp
-hirara.okinawa.jp
-iheya.okinawa.jp
-ishigaki.okinawa.jp
-ishikawa.okinawa.jp
-itoman.okinawa.jp
-izena.okinawa.jp
-kadena.okinawa.jp
-kin.okinawa.jp
-kitadaito.okinawa.jp
-kitanakagusuku.okinawa.jp
-kumejima.okinawa.jp
-kunigami.okinawa.jp
-minamidaito.okinawa.jp
-motobu.okinawa.jp
-nago.okinawa.jp
-naha.okinawa.jp
-nakagusuku.okinawa.jp
-nakijin.okinawa.jp
-nanjo.okinawa.jp
-nishihara.okinawa.jp
-ogimi.okinawa.jp
-okinawa.okinawa.jp
-onna.okinawa.jp
-shimoji.okinawa.jp
-taketomi.okinawa.jp
-tarama.okinawa.jp
-tokashiki.okinawa.jp
-tomigusuku.okinawa.jp
-tonaki.okinawa.jp
-urasoe.okinawa.jp
-uruma.okinawa.jp
-yaese.okinawa.jp
-yomitan.okinawa.jp
-yonabaru.okinawa.jp
-yonaguni.okinawa.jp
-zamami.okinawa.jp
-abeno.osaka.jp
-chihayaakasaka.osaka.jp
-chuo.osaka.jp
-daito.osaka.jp
-fujiidera.osaka.jp
-habikino.osaka.jp
-hannan.osaka.jp
-higashiosaka.osaka.jp
-higashisumiyoshi.osaka.jp
-higashiyodogawa.osaka.jp
-hirakata.osaka.jp
-ibaraki.osaka.jp
-ikeda.osaka.jp
-izumi.osaka.jp
-izumiotsu.osaka.jp
-izumisano.osaka.jp
-kadoma.osaka.jp
-kaizuka.osaka.jp
-kanan.osaka.jp
-kashiwara.osaka.jp
-katano.osaka.jp
-kawachinagano.osaka.jp
-kishiwada.osaka.jp
-kita.osaka.jp
-kumatori.osaka.jp
-matsubara.osaka.jp
-minato.osaka.jp
-minoh.osaka.jp
-misaki.osaka.jp
-moriguchi.osaka.jp
-neyagawa.osaka.jp
-nishi.osaka.jp
-nose.osaka.jp
-osakasayama.osaka.jp
-sakai.osaka.jp
-sayama.osaka.jp
-sennan.osaka.jp
-settsu.osaka.jp
-shijonawate.osaka.jp
-shimamoto.osaka.jp
-suita.osaka.jp
-tadaoka.osaka.jp
-taishi.osaka.jp
-tajiri.osaka.jp
-takaishi.osaka.jp
-takatsuki.osaka.jp
-tondabayashi.osaka.jp
-toyonaka.osaka.jp
-toyono.osaka.jp
-yao.osaka.jp
-ariake.saga.jp
-arita.saga.jp
-fukudomi.saga.jp
-genkai.saga.jp
-hamatama.saga.jp
-hizen.saga.jp
-imari.saga.jp
-kamimine.saga.jp
-kanzaki.saga.jp
-karatsu.saga.jp
-kashima.saga.jp
-kitagata.saga.jp
-kitahata.saga.jp
-kiyama.saga.jp
-kouhoku.saga.jp
-kyuragi.saga.jp
-nishiarita.saga.jp
-ogi.saga.jp
-omachi.saga.jp
-ouchi.saga.jp
-saga.saga.jp
-shiroishi.saga.jp
-taku.saga.jp
-tara.saga.jp
-tosu.saga.jp
-yoshinogari.saga.jp
-arakawa.saitama.jp
-asaka.saitama.jp
-chichibu.saitama.jp
-fujimi.saitama.jp
-fujimino.saitama.jp
-fukaya.saitama.jp
-hanno.saitama.jp
-hanyu.saitama.jp
-hasuda.saitama.jp
-hatogaya.saitama.jp
-hatoyama.saitama.jp
-hidaka.saitama.jp
-higashichichibu.saitama.jp
-higashimatsuyama.saitama.jp
-honjo.saitama.jp
-ina.saitama.jp
-iruma.saitama.jp
-iwatsuki.saitama.jp
-kamiizumi.saitama.jp
-kamikawa.saitama.jp
-kamisato.saitama.jp
-kasukabe.saitama.jp
-kawagoe.saitama.jp
-kawaguchi.saitama.jp
-kawajima.saitama.jp
-kazo.saitama.jp
-kitamoto.saitama.jp
-koshigaya.saitama.jp
-kounosu.saitama.jp
-kuki.saitama.jp
-kumagaya.saitama.jp
-matsubushi.saitama.jp
-minano.saitama.jp
-misato.saitama.jp
-miyashiro.saitama.jp
-miyoshi.saitama.jp
-moroyama.saitama.jp
-nagatoro.saitama.jp
-namegawa.saitama.jp
-niiza.saitama.jp
-ogano.saitama.jp
-ogawa.saitama.jp
-ogose.saitama.jp
-okegawa.saitama.jp
-omiya.saitama.jp
-otaki.saitama.jp
-ranzan.saitama.jp
-ryokami.saitama.jp
-saitama.saitama.jp
-sakado.saitama.jp
-satte.saitama.jp
-sayama.saitama.jp
-shiki.saitama.jp
-shiraoka.saitama.jp
-soka.saitama.jp
-sugito.saitama.jp
-toda.saitama.jp
-tokigawa.saitama.jp
-tokorozawa.saitama.jp
-tsurugashima.saitama.jp
-urawa.saitama.jp
-warabi.saitama.jp
-yashio.saitama.jp
-yokoze.saitama.jp
-yono.saitama.jp
-yorii.saitama.jp
-yoshida.saitama.jp
-yoshikawa.saitama.jp
-yoshimi.saitama.jp
-aisho.shiga.jp
-gamo.shiga.jp
-higashiomi.shiga.jp
-hikone.shiga.jp
-koka.shiga.jp
-konan.shiga.jp
-kosei.shiga.jp
-koto.shiga.jp
-kusatsu.shiga.jp
-maibara.shiga.jp
-moriyama.shiga.jp
-nagahama.shiga.jp
-nishiazai.shiga.jp
-notogawa.shiga.jp
-omihachiman.shiga.jp
-otsu.shiga.jp
-ritto.shiga.jp
-ryuoh.shiga.jp
-takashima.shiga.jp
-takatsuki.shiga.jp
-torahime.shiga.jp
-toyosato.shiga.jp
-yasu.shiga.jp
-akagi.shimane.jp
-ama.shimane.jp
-gotsu.shimane.jp
-hamada.shimane.jp
-higashiizumo.shimane.jp
-hikawa.shimane.jp
-hikimi.shimane.jp
-izumo.shimane.jp
-kakinoki.shimane.jp
-masuda.shimane.jp
-matsue.shimane.jp
-misato.shimane.jp
-nishinoshima.shimane.jp
-ohda.shimane.jp
-okinoshima.shimane.jp
-okuizumo.shimane.jp
-shimane.shimane.jp
-tamayu.shimane.jp
-tsuwano.shimane.jp
-unnan.shimane.jp
-yakumo.shimane.jp
-yasugi.shimane.jp
-yatsuka.shimane.jp
-arai.shizuoka.jp
-atami.shizuoka.jp
-fuji.shizuoka.jp
-fujieda.shizuoka.jp
-fujikawa.shizuoka.jp
-fujinomiya.shizuoka.jp
-fukuroi.shizuoka.jp
-gotemba.shizuoka.jp
-haibara.shizuoka.jp
-hamamatsu.shizuoka.jp
-higashiizu.shizuoka.jp
-ito.shizuoka.jp
-iwata.shizuoka.jp
-izu.shizuoka.jp
-izunokuni.shizuoka.jp
-kakegawa.shizuoka.jp
-kannami.shizuoka.jp
-kawanehon.shizuoka.jp
-kawazu.shizuoka.jp
-kikugawa.shizuoka.jp
-kosai.shizuoka.jp
-makinohara.shizuoka.jp
-matsuzaki.shizuoka.jp
-minamiizu.shizuoka.jp
-mishima.shizuoka.jp
-morimachi.shizuoka.jp
-nishiizu.shizuoka.jp
-numazu.shizuoka.jp
-omaezaki.shizuoka.jp
-shimada.shizuoka.jp
-shimizu.shizuoka.jp
-shimoda.shizuoka.jp
-shizuoka.shizuoka.jp
-susono.shizuoka.jp
-yaizu.shizuoka.jp
-yoshida.shizuoka.jp
-ashikaga.tochigi.jp
-bato.tochigi.jp
-haga.tochigi.jp
-ichikai.tochigi.jp
-iwafune.tochigi.jp
-kaminokawa.tochigi.jp
-kanuma.tochigi.jp
-karasuyama.tochigi.jp
-kuroiso.tochigi.jp
-mashiko.tochigi.jp
-mibu.tochigi.jp
-moka.tochigi.jp
-motegi.tochigi.jp
-nasu.tochigi.jp
-nasushiobara.tochigi.jp
-nikko.tochigi.jp
-nishikata.tochigi.jp
-nogi.tochigi.jp
-ohira.tochigi.jp
-ohtawara.tochigi.jp
-oyama.tochigi.jp
-sakura.tochigi.jp
-sano.tochigi.jp
-shimotsuke.tochigi.jp
-shioya.tochigi.jp
-takanezawa.tochigi.jp
-tochigi.tochigi.jp
-tsuga.tochigi.jp
-ujiie.tochigi.jp
-utsunomiya.tochigi.jp
-yaita.tochigi.jp
-aizumi.tokushima.jp
-anan.tokushima.jp
-ichiba.tokushima.jp
-itano.tokushima.jp
-kainan.tokushima.jp
-komatsushima.tokushima.jp
-matsushige.tokushima.jp
-mima.tokushima.jp
-minami.tokushima.jp
-miyoshi.tokushima.jp
-mugi.tokushima.jp
-nakagawa.tokushima.jp
-naruto.tokushima.jp
-sanagochi.tokushima.jp
-shishikui.tokushima.jp
-tokushima.tokushima.jp
-wajiki.tokushima.jp
-adachi.tokyo.jp
-akiruno.tokyo.jp
-akishima.tokyo.jp
-aogashima.tokyo.jp
-arakawa.tokyo.jp
-bunkyo.tokyo.jp
-chiyoda.tokyo.jp
-chofu.tokyo.jp
-chuo.tokyo.jp
-edogawa.tokyo.jp
-fuchu.tokyo.jp
-fussa.tokyo.jp
-hachijo.tokyo.jp
-hachioji.tokyo.jp
-hamura.tokyo.jp
-higashikurume.tokyo.jp
-higashimurayama.tokyo.jp
-higashiyamato.tokyo.jp
-hino.tokyo.jp
-hinode.tokyo.jp
-hinohara.tokyo.jp
-inagi.tokyo.jp
-itabashi.tokyo.jp
-katsushika.tokyo.jp
-kita.tokyo.jp
-kiyose.tokyo.jp
-kodaira.tokyo.jp
-koganei.tokyo.jp
-kokubunji.tokyo.jp
-komae.tokyo.jp
-koto.tokyo.jp
-kouzushima.tokyo.jp
-kunitachi.tokyo.jp
-machida.tokyo.jp
-meguro.tokyo.jp
-minato.tokyo.jp
-mitaka.tokyo.jp
-mizuho.tokyo.jp
-musashimurayama.tokyo.jp
-musashino.tokyo.jp
-nakano.tokyo.jp
-nerima.tokyo.jp
-ogasawara.tokyo.jp
-okutama.tokyo.jp
-ome.tokyo.jp
-oshima.tokyo.jp
-ota.tokyo.jp
-setagaya.tokyo.jp
-shibuya.tokyo.jp
-shinagawa.tokyo.jp
-shinjuku.tokyo.jp
-suginami.tokyo.jp
-sumida.tokyo.jp
-tachikawa.tokyo.jp
-taito.tokyo.jp
-tama.tokyo.jp
-toshima.tokyo.jp
-chizu.tottori.jp
-hino.tottori.jp
-kawahara.tottori.jp
-koge.tottori.jp
-kotoura.tottori.jp
-misasa.tottori.jp
-nanbu.tottori.jp
-nichinan.tottori.jp
-sakaiminato.tottori.jp
-tottori.tottori.jp
-wakasa.tottori.jp
-yazu.tottori.jp
-yonago.tottori.jp
-asahi.toyama.jp
-fuchu.toyama.jp
-fukumitsu.toyama.jp
-funahashi.toyama.jp
-himi.toyama.jp
-imizu.toyama.jp
-inami.toyama.jp
-johana.toyama.jp
-kamiichi.toyama.jp
-kurobe.toyama.jp
-nakaniikawa.toyama.jp
-namerikawa.toyama.jp
-nanto.toyama.jp
-nyuzen.toyama.jp
-oyabe.toyama.jp
-taira.toyama.jp
-takaoka.toyama.jp
-tateyama.toyama.jp
-toga.toyama.jp
-tonami.toyama.jp
-toyama.toyama.jp
-unazuki.toyama.jp
-uozu.toyama.jp
-yamada.toyama.jp
-arida.wakayama.jp
-aridagawa.wakayama.jp
-gobo.wakayama.jp
-hashimoto.wakayama.jp
-hidaka.wakayama.jp
-hirogawa.wakayama.jp
-inami.wakayama.jp
-iwade.wakayama.jp
-kainan.wakayama.jp
-kamitonda.wakayama.jp
-katsuragi.wakayama.jp
-kimino.wakayama.jp
-kinokawa.wakayama.jp
-kitayama.wakayama.jp
-koya.wakayama.jp
-koza.wakayama.jp
-kozagawa.wakayama.jp
-kudoyama.wakayama.jp
-kushimoto.wakayama.jp
-mihama.wakayama.jp
-misato.wakayama.jp
-nachikatsuura.wakayama.jp
-shingu.wakayama.jp
-shirahama.wakayama.jp
-taiji.wakayama.jp
-tanabe.wakayama.jp
-wakayama.wakayama.jp
-yuasa.wakayama.jp
-yura.wakayama.jp
-asahi.yamagata.jp
-funagata.yamagata.jp
-higashine.yamagata.jp
-iide.yamagata.jp
-kahoku.yamagata.jp
-kaminoyama.yamagata.jp
-kaneyama.yamagata.jp
-kawanishi.yamagata.jp
-mamurogawa.yamagata.jp
-mikawa.yamagata.jp
-murayama.yamagata.jp
-nagai.yamagata.jp
-nakayama.yamagata.jp
-nanyo.yamagata.jp
-nishikawa.yamagata.jp
-obanazawa.yamagata.jp
-oe.yamagata.jp
-oguni.yamagata.jp
-ohkura.yamagata.jp
-oishida.yamagata.jp
-sagae.yamagata.jp
-sakata.yamagata.jp
-sakegawa.yamagata.jp
-shinjo.yamagata.jp
-shirataka.yamagata.jp
-shonai.yamagata.jp
-takahata.yamagata.jp
-tendo.yamagata.jp
-tozawa.yamagata.jp
-tsuruoka.yamagata.jp
-yamagata.yamagata.jp
-yamanobe.yamagata.jp
-yonezawa.yamagata.jp
-yuza.yamagata.jp
-abu.yamaguchi.jp
-hagi.yamaguchi.jp
-hikari.yamaguchi.jp
-hofu.yamaguchi.jp
-iwakuni.yamaguchi.jp
-kudamatsu.yamaguchi.jp
-mitou.yamaguchi.jp
-nagato.yamaguchi.jp
-oshima.yamaguchi.jp
-shimonoseki.yamaguchi.jp
-shunan.yamaguchi.jp
-tabuse.yamaguchi.jp
-tokuyama.yamaguchi.jp
-toyota.yamaguchi.jp
-ube.yamaguchi.jp
-yuu.yamaguchi.jp
-chuo.yamanashi.jp
-doshi.yamanashi.jp
-fuefuki.yamanashi.jp
-fujikawa.yamanashi.jp
-fujikawaguchiko.yamanashi.jp
-fujiyoshida.yamanashi.jp
-hayakawa.yamanashi.jp
-hokuto.yamanashi.jp
-ichikawamisato.yamanashi.jp
-kai.yamanashi.jp
-kofu.yamanashi.jp
-koshu.yamanashi.jp
-kosuge.yamanashi.jp
-minami-alps.yamanashi.jp
-minobu.yamanashi.jp
-nakamichi.yamanashi.jp
-nanbu.yamanashi.jp
-narusawa.yamanashi.jp
-nirasaki.yamanashi.jp
-nishikatsura.yamanashi.jp
-oshino.yamanashi.jp
-otsuki.yamanashi.jp
-showa.yamanashi.jp
-tabayama.yamanashi.jp
-tsuru.yamanashi.jp
-uenohara.yamanashi.jp
-yamanakako.yamanashi.jp
-yamanashi.yamanashi.jp
-
-// ke : http://www.kenic.or.ke/index.php/en/ke-domains/ke-domains
-ke
-ac.ke
-co.ke
-go.ke
-info.ke
-me.ke
-mobi.ke
-ne.ke
-or.ke
-sc.ke
-
-// kg : http://www.domain.kg/dmn_n.html
-kg
-org.kg
-net.kg
-com.kg
-edu.kg
-gov.kg
-mil.kg
-
-// kh : http://www.mptc.gov.kh/dns_registration.htm
-*.kh
-
-// ki : http://www.ki/dns/index.html
-ki
-edu.ki
-biz.ki
-net.ki
-org.ki
-gov.ki
-info.ki
-com.ki
-
-// km : https://en.wikipedia.org/wiki/.km
-// http://www.domaine.km/documents/charte.doc
-km
-org.km
-nom.km
-gov.km
-prd.km
-tm.km
-edu.km
-mil.km
-ass.km
-com.km
-// These are only mentioned as proposed suggestions at domaine.km, but
-// https://en.wikipedia.org/wiki/.km says they're available for registration:
-coop.km
-asso.km
-presse.km
-medecin.km
-notaires.km
-pharmaciens.km
-veterinaire.km
-gouv.km
-
-// kn : https://en.wikipedia.org/wiki/.kn
-// http://www.dot.kn/domainRules.html
-kn
-net.kn
-org.kn
-edu.kn
-gov.kn
-
-// kp : http://www.kcce.kp/en_index.php
-kp
-com.kp
-edu.kp
-gov.kp
-org.kp
-rep.kp
-tra.kp
-
-// kr : https://en.wikipedia.org/wiki/.kr
-// see also: http://domain.nida.or.kr/eng/registration.jsp
-kr
-ac.kr
-co.kr
-es.kr
-go.kr
-hs.kr
-kg.kr
-mil.kr
-ms.kr
-ne.kr
-or.kr
-pe.kr
-re.kr
-sc.kr
-// kr geographical names
-busan.kr
-chungbuk.kr
-chungnam.kr
-daegu.kr
-daejeon.kr
-gangwon.kr
-gwangju.kr
-gyeongbuk.kr
-gyeonggi.kr
-gyeongnam.kr
-incheon.kr
-jeju.kr
-jeonbuk.kr
-jeonnam.kr
-seoul.kr
-ulsan.kr
-
-// kw : https://www.nic.kw/policies/
-// Confirmed by registry <nic.tech@citra.gov.kw>
-kw
-com.kw
-edu.kw
-emb.kw
-gov.kw
-ind.kw
-net.kw
-org.kw
-
-// ky : http://www.icta.ky/da_ky_reg_dom.php
-// Confirmed by registry <kysupport@perimeterusa.com> 2008-06-17
-ky
-com.ky
-edu.ky
-net.ky
-org.ky
-
-// kz : https://en.wikipedia.org/wiki/.kz
-// see also: http://www.nic.kz/rules/index.jsp
-kz
-org.kz
-edu.kz
-net.kz
-gov.kz
-mil.kz
-com.kz
-
-// la : https://en.wikipedia.org/wiki/.la
-// Submitted by registry <gavin.brown@nic.la>
-la
-int.la
-net.la
-info.la
-edu.la
-gov.la
-per.la
-com.la
-org.la
-
-// lb : https://en.wikipedia.org/wiki/.lb
-// Submitted by registry <randy@psg.com>
-lb
-com.lb
-edu.lb
-gov.lb
-net.lb
-org.lb
-
-// lc : https://en.wikipedia.org/wiki/.lc
-// see also: http://www.nic.lc/rules.htm
-lc
-com.lc
-net.lc
-co.lc
-org.lc
-edu.lc
-gov.lc
-
-// li : https://en.wikipedia.org/wiki/.li
-li
-
-// lk : https://www.nic.lk/index.php/domain-registration/lk-domain-naming-structure
-lk
-gov.lk
-sch.lk
-net.lk
-int.lk
-com.lk
-org.lk
-edu.lk
-ngo.lk
-soc.lk
-web.lk
-ltd.lk
-assn.lk
-grp.lk
-hotel.lk
-ac.lk
-
-// lr : http://psg.com/dns/lr/lr.txt
-// Submitted by registry <randy@psg.com>
-lr
-com.lr
-edu.lr
-gov.lr
-org.lr
-net.lr
-
-// ls : http://www.nic.ls/
-// Confirmed by registry <lsadmin@nic.ls>
-ls
-ac.ls
-biz.ls
-co.ls
-edu.ls
-gov.ls
-info.ls
-net.ls
-org.ls
-sc.ls
-
-// lt : https://en.wikipedia.org/wiki/.lt
-lt
-// gov.lt : http://www.gov.lt/index_en.php
-gov.lt
-
-// lu : http://www.dns.lu/en/
-lu
-
-// lv : http://www.nic.lv/DNS/En/generic.php
-lv
-com.lv
-edu.lv
-gov.lv
-org.lv
-mil.lv
-id.lv
-net.lv
-asn.lv
-conf.lv
-
-// ly : http://www.nic.ly/regulations.php
-ly
-com.ly
-net.ly
-gov.ly
-plc.ly
-edu.ly
-sch.ly
-med.ly
-org.ly
-id.ly
-
-// ma : https://en.wikipedia.org/wiki/.ma
-// http://www.anrt.ma/fr/admin/download/upload/file_fr782.pdf
-ma
-co.ma
-net.ma
-gov.ma
-org.ma
-ac.ma
-press.ma
-
-// mc : http://www.nic.mc/
-mc
-tm.mc
-asso.mc
-
-// md : https://en.wikipedia.org/wiki/.md
-md
-
-// me : https://en.wikipedia.org/wiki/.me
-me
-co.me
-net.me
-org.me
-edu.me
-ac.me
-gov.me
-its.me
-priv.me
-
-// mg : http://nic.mg/nicmg/?page_id=39
-mg
-org.mg
-nom.mg
-gov.mg
-prd.mg
-tm.mg
-edu.mg
-mil.mg
-com.mg
-co.mg
-
-// mh : https://en.wikipedia.org/wiki/.mh
-mh
-
-// mil : https://en.wikipedia.org/wiki/.mil
-mil
-
-// mk : https://en.wikipedia.org/wiki/.mk
-// see also: http://dns.marnet.net.mk/postapka.php
-mk
-com.mk
-org.mk
-net.mk
-edu.mk
-gov.mk
-inf.mk
-name.mk
-
-// ml : http://www.gobin.info/domainname/ml-template.doc
-// see also: https://en.wikipedia.org/wiki/.ml
-ml
-com.ml
-edu.ml
-gouv.ml
-gov.ml
-net.ml
-org.ml
-presse.ml
-
-// mm : https://en.wikipedia.org/wiki/.mm
-*.mm
-
-// mn : https://en.wikipedia.org/wiki/.mn
-mn
-gov.mn
-edu.mn
-org.mn
-
-// mo : http://www.monic.net.mo/
-mo
-com.mo
-net.mo
-org.mo
-edu.mo
-gov.mo
-
-// mobi : https://en.wikipedia.org/wiki/.mobi
-mobi
-
-// mp : http://www.dot.mp/
-// Confirmed by registry <dcamacho@saipan.com> 2008-06-17
-mp
-
-// mq : https://en.wikipedia.org/wiki/.mq
-mq
-
-// mr : https://en.wikipedia.org/wiki/.mr
-mr
-gov.mr
-
-// ms : http://www.nic.ms/pdf/MS_Domain_Name_Rules.pdf
-ms
-com.ms
-edu.ms
-gov.ms
-net.ms
-org.ms
-
-// mt : https://www.nic.org.mt/go/policy
-// Submitted by registry <help@nic.org.mt>
-mt
-com.mt
-edu.mt
-net.mt
-org.mt
-
-// mu : https://en.wikipedia.org/wiki/.mu
-mu
-com.mu
-net.mu
-org.mu
-gov.mu
-ac.mu
-co.mu
-or.mu
-
-// museum : http://about.museum/naming/
-// http://index.museum/
-museum
-academy.museum
-agriculture.museum
-air.museum
-airguard.museum
-alabama.museum
-alaska.museum
-amber.museum
-ambulance.museum
-american.museum
-americana.museum
-americanantiques.museum
-americanart.museum
-amsterdam.museum
-and.museum
-annefrank.museum
-anthro.museum
-anthropology.museum
-antiques.museum
-aquarium.museum
-arboretum.museum
-archaeological.museum
-archaeology.museum
-architecture.museum
-art.museum
-artanddesign.museum
-artcenter.museum
-artdeco.museum
-arteducation.museum
-artgallery.museum
-arts.museum
-artsandcrafts.museum
-asmatart.museum
-assassination.museum
-assisi.museum
-association.museum
-astronomy.museum
-atlanta.museum
-austin.museum
-australia.museum
-automotive.museum
-aviation.museum
-axis.museum
-badajoz.museum
-baghdad.museum
-bahn.museum
-bale.museum
-baltimore.museum
-barcelona.museum
-baseball.museum
-basel.museum
-baths.museum
-bauern.museum
-beauxarts.museum
-beeldengeluid.museum
-bellevue.museum
-bergbau.museum
-berkeley.museum
-berlin.museum
-bern.museum
-bible.museum
-bilbao.museum
-bill.museum
-birdart.museum
-birthplace.museum
-bonn.museum
-boston.museum
-botanical.museum
-botanicalgarden.museum
-botanicgarden.museum
-botany.museum
-brandywinevalley.museum
-brasil.museum
-bristol.museum
-british.museum
-britishcolumbia.museum
-broadcast.museum
-brunel.museum
-brussel.museum
-brussels.museum
-bruxelles.museum
-building.museum
-burghof.museum
-bus.museum
-bushey.museum
-cadaques.museum
-california.museum
-cambridge.museum
-can.museum
-canada.museum
-capebreton.museum
-carrier.museum
-cartoonart.museum
-casadelamoneda.museum
-castle.museum
-castres.museum
-celtic.museum
-center.museum
-chattanooga.museum
-cheltenham.museum
-chesapeakebay.museum
-chicago.museum
-children.museum
-childrens.museum
-childrensgarden.museum
-chiropractic.museum
-chocolate.museum
-christiansburg.museum
-cincinnati.museum
-cinema.museum
-circus.museum
-civilisation.museum
-civilization.museum
-civilwar.museum
-clinton.museum
-clock.museum
-coal.museum
-coastaldefence.museum
-cody.museum
-coldwar.museum
-collection.museum
-colonialwilliamsburg.museum
-coloradoplateau.museum
-columbia.museum
-columbus.museum
-communication.museum
-communications.museum
-community.museum
-computer.museum
-computerhistory.museum
-comunicações.museum
-contemporary.museum
-contemporaryart.museum
-convent.museum
-copenhagen.museum
-corporation.museum
-correios-e-telecomunicações.museum
-corvette.museum
-costume.museum
-countryestate.museum
-county.museum
-crafts.museum
-cranbrook.museum
-creation.museum
-cultural.museum
-culturalcenter.museum
-culture.museum
-cyber.museum
-cymru.museum
-dali.museum
-dallas.museum
-database.museum
-ddr.museum
-decorativearts.museum
-delaware.museum
-delmenhorst.museum
-denmark.museum
-depot.museum
-design.museum
-detroit.museum
-dinosaur.museum
-discovery.museum
-dolls.museum
-donostia.museum
-durham.museum
-eastafrica.museum
-eastcoast.museum
-education.museum
-educational.museum
-egyptian.museum
-eisenbahn.museum
-elburg.museum
-elvendrell.museum
-embroidery.museum
-encyclopedic.museum
-england.museum
-entomology.museum
-environment.museum
-environmentalconservation.museum
-epilepsy.museum
-essex.museum
-estate.museum
-ethnology.museum
-exeter.museum
-exhibition.museum
-family.museum
-farm.museum
-farmequipment.museum
-farmers.museum
-farmstead.museum
-field.museum
-figueres.museum
-filatelia.museum
-film.museum
-fineart.museum
-finearts.museum
-finland.museum
-flanders.museum
-florida.museum
-force.museum
-fortmissoula.museum
-fortworth.museum
-foundation.museum
-francaise.museum
-frankfurt.museum
-franziskaner.museum
-freemasonry.museum
-freiburg.museum
-fribourg.museum
-frog.museum
-fundacio.museum
-furniture.museum
-gallery.museum
-garden.museum
-gateway.museum
-geelvinck.museum
-gemological.museum
-geology.museum
-georgia.museum
-giessen.museum
-glas.museum
-glass.museum
-gorge.museum
-grandrapids.museum
-graz.museum
-guernsey.museum
-halloffame.museum
-hamburg.museum
-handson.museum
-harvestcelebration.museum
-hawaii.museum
-health.museum
-heimatunduhren.museum
-hellas.museum
-helsinki.museum
-hembygdsforbund.museum
-heritage.museum
-histoire.museum
-historical.museum
-historicalsociety.museum
-historichouses.museum
-historisch.museum
-historisches.museum
-history.museum
-historyofscience.museum
-horology.museum
-house.museum
-humanities.museum
-illustration.museum
-imageandsound.museum
-indian.museum
-indiana.museum
-indianapolis.museum
-indianmarket.museum
-intelligence.museum
-interactive.museum
-iraq.museum
-iron.museum
-isleofman.museum
-jamison.museum
-jefferson.museum
-jerusalem.museum
-jewelry.museum
-jewish.museum
-jewishart.museum
-jfk.museum
-journalism.museum
-judaica.museum
-judygarland.museum
-juedisches.museum
-juif.museum
-karate.museum
-karikatur.museum
-kids.museum
-koebenhavn.museum
-koeln.museum
-kunst.museum
-kunstsammlung.museum
-kunstunddesign.museum
-labor.museum
-labour.museum
-lajolla.museum
-lancashire.museum
-landes.museum
-lans.museum
-läns.museum
-larsson.museum
-lewismiller.museum
-lincoln.museum
-linz.museum
-living.museum
-livinghistory.museum
-localhistory.museum
-london.museum
-losangeles.museum
-louvre.museum
-loyalist.museum
-lucerne.museum
-luxembourg.museum
-luzern.museum
-mad.museum
-madrid.museum
-mallorca.museum
-manchester.museum
-mansion.museum
-mansions.museum
-manx.museum
-marburg.museum
-maritime.museum
-maritimo.museum
-maryland.museum
-marylhurst.museum
-media.museum
-medical.museum
-medizinhistorisches.museum
-meeres.museum
-memorial.museum
-mesaverde.museum
-michigan.museum
-midatlantic.museum
-military.museum
-mill.museum
-miners.museum
-mining.museum
-minnesota.museum
-missile.museum
-missoula.museum
-modern.museum
-moma.museum
-money.museum
-monmouth.museum
-monticello.museum
-montreal.museum
-moscow.museum
-motorcycle.museum
-muenchen.museum
-muenster.museum
-mulhouse.museum
-muncie.museum
-museet.museum
-museumcenter.museum
-museumvereniging.museum
-music.museum
-national.museum
-nationalfirearms.museum
-nationalheritage.museum
-nativeamerican.museum
-naturalhistory.museum
-naturalhistorymuseum.museum
-naturalsciences.museum
-nature.museum
-naturhistorisches.museum
-natuurwetenschappen.museum
-naumburg.museum
-naval.museum
-nebraska.museum
-neues.museum
-newhampshire.museum
-newjersey.museum
-newmexico.museum
-newport.museum
-newspaper.museum
-newyork.museum
-niepce.museum
-norfolk.museum
-north.museum
-nrw.museum
-nyc.museum
-nyny.museum
-oceanographic.museum
-oceanographique.museum
-omaha.museum
-online.museum
-ontario.museum
-openair.museum
-oregon.museum
-oregontrail.museum
-otago.museum
-oxford.museum
-pacific.museum
-paderborn.museum
-palace.museum
-paleo.museum
-palmsprings.museum
-panama.museum
-paris.museum
-pasadena.museum
-pharmacy.museum
-philadelphia.museum
-philadelphiaarea.museum
-philately.museum
-phoenix.museum
-photography.museum
-pilots.museum
-pittsburgh.museum
-planetarium.museum
-plantation.museum
-plants.museum
-plaza.museum
-portal.museum
-portland.museum
-portlligat.museum
-posts-and-telecommunications.museum
-preservation.museum
-presidio.museum
-press.museum
-project.museum
-public.museum
-pubol.museum
-quebec.museum
-railroad.museum
-railway.museum
-research.museum
-resistance.museum
-riodejaneiro.museum
-rochester.museum
-rockart.museum
-roma.museum
-russia.museum
-saintlouis.museum
-salem.museum
-salvadordali.museum
-salzburg.museum
-sandiego.museum
-sanfrancisco.museum
-santabarbara.museum
-santacruz.museum
-santafe.museum
-saskatchewan.museum
-satx.museum
-savannahga.museum
-schlesisches.museum
-schoenbrunn.museum
-schokoladen.museum
-school.museum
-schweiz.museum
-science.museum
-scienceandhistory.museum
-scienceandindustry.museum
-sciencecenter.museum
-sciencecenters.museum
-science-fiction.museum
-sciencehistory.museum
-sciences.museum
-sciencesnaturelles.museum
-scotland.museum
-seaport.museum
-settlement.museum
-settlers.museum
-shell.museum
-sherbrooke.museum
-sibenik.museum
-silk.museum
-ski.museum
-skole.museum
-society.museum
-sologne.museum
-soundandvision.museum
-southcarolina.museum
-southwest.museum
-space.museum
-spy.museum
-square.museum
-stadt.museum
-stalbans.museum
-starnberg.museum
-state.museum
-stateofdelaware.museum
-station.museum
-steam.museum
-steiermark.museum
-stjohn.museum
-stockholm.museum
-stpetersburg.museum
-stuttgart.museum
-suisse.museum
-surgeonshall.museum
-surrey.museum
-svizzera.museum
-sweden.museum
-sydney.museum
-tank.museum
-tcm.museum
-technology.museum
-telekommunikation.museum
-television.museum
-texas.museum
-textile.museum
-theater.museum
-time.museum
-timekeeping.museum
-topology.museum
-torino.museum
-touch.museum
-town.museum
-transport.museum
-tree.museum
-trolley.museum
-trust.museum
-trustee.museum
-uhren.museum
-ulm.museum
-undersea.museum
-university.museum
-usa.museum
-usantiques.museum
-usarts.museum
-uscountryestate.museum
-usculture.museum
-usdecorativearts.museum
-usgarden.museum
-ushistory.museum
-ushuaia.museum
-uslivinghistory.museum
-utah.museum
-uvic.museum
-valley.museum
-vantaa.museum
-versailles.museum
-viking.museum
-village.museum
-virginia.museum
-virtual.museum
-virtuel.museum
-vlaanderen.museum
-volkenkunde.museum
-wales.museum
-wallonie.museum
-war.museum
-washingtondc.museum
-watchandclock.museum
-watch-and-clock.museum
-western.museum
-westfalen.museum
-whaling.museum
-wildlife.museum
-williamsburg.museum
-windmill.museum
-workshop.museum
-york.museum
-yorkshire.museum
-yosemite.museum
-youth.museum
-zoological.museum
-zoology.museum
-ירושלים.museum
-иком.museum
-
-// mv : https://en.wikipedia.org/wiki/.mv
-// "mv" included because, contra Wikipedia, google.mv exists.
-mv
-aero.mv
-biz.mv
-com.mv
-coop.mv
-edu.mv
-gov.mv
-info.mv
-int.mv
-mil.mv
-museum.mv
-name.mv
-net.mv
-org.mv
-pro.mv
-
-// mw : http://www.registrar.mw/
-mw
-ac.mw
-biz.mw
-co.mw
-com.mw
-coop.mw
-edu.mw
-gov.mw
-int.mw
-museum.mw
-net.mw
-org.mw
-
-// mx : http://www.nic.mx/
-// Submitted by registry <farias@nic.mx>
-mx
-com.mx
-org.mx
-gob.mx
-edu.mx
-net.mx
-
-// my : http://www.mynic.my/
-// Available strings: https://mynic.my/resources/domains/buying-a-domain/
-my
-biz.my
-com.my
-edu.my
-gov.my
-mil.my
-name.my
-net.my
-org.my
-
-// mz : http://www.uem.mz/
-// Submitted by registry <antonio@uem.mz>
-mz
-ac.mz
-adv.mz
-co.mz
-edu.mz
-gov.mz
-mil.mz
-net.mz
-org.mz
-
-// na : http://www.na-nic.com.na/
-// http://www.info.na/domain/
-na
-info.na
-pro.na
-name.na
-school.na
-or.na
-dr.na
-us.na
-mx.na
-ca.na
-in.na
-cc.na
-tv.na
-ws.na
-mobi.na
-co.na
-com.na
-org.na
-
-// name : has 2nd-level tlds, but there's no list of them
-name
-
-// nc : http://www.cctld.nc/
-nc
-asso.nc
-nom.nc
-
-// ne : https://en.wikipedia.org/wiki/.ne
-ne
-
-// net : https://en.wikipedia.org/wiki/.net
-net
-
-// nf : https://en.wikipedia.org/wiki/.nf
-nf
-com.nf
-net.nf
-per.nf
-rec.nf
-web.nf
-arts.nf
-firm.nf
-info.nf
-other.nf
-store.nf
-
-// ng : http://www.nira.org.ng/index.php/join-us/register-ng-domain/189-nira-slds
-ng
-com.ng
-edu.ng
-gov.ng
-i.ng
-mil.ng
-mobi.ng
-name.ng
-net.ng
-org.ng
-sch.ng
-
-// ni : http://www.nic.ni/
-ni
-ac.ni
-biz.ni
-co.ni
-com.ni
-edu.ni
-gob.ni
-in.ni
-info.ni
-int.ni
-mil.ni
-net.ni
-nom.ni
-org.ni
-web.ni
-
-// nl : https://en.wikipedia.org/wiki/.nl
-//      https://www.sidn.nl/
-//      ccTLD for the Netherlands
-nl
-
-// no : https://www.norid.no/en/om-domenenavn/regelverk-for-no/
-// Norid geographical second level domains : https://www.norid.no/en/om-domenenavn/regelverk-for-no/vedlegg-b/
-// Norid category second level domains : https://www.norid.no/en/om-domenenavn/regelverk-for-no/vedlegg-c/
-// Norid category second-level domains managed by parties other than Norid : https://www.norid.no/en/om-domenenavn/regelverk-for-no/vedlegg-d/
-// RSS feed: https://teknisk.norid.no/en/feed/
-no
-// Norid category second level domains : https://www.norid.no/en/om-domenenavn/regelverk-for-no/vedlegg-c/
-fhs.no
-vgs.no
-fylkesbibl.no
-folkebibl.no
-museum.no
-idrett.no
-priv.no
-// Norid category second-level domains managed by parties other than Norid : https://www.norid.no/en/om-domenenavn/regelverk-for-no/vedlegg-d/
-mil.no
-stat.no
-dep.no
-kommune.no
-herad.no
-// Norid geographical second level domains : https://www.norid.no/en/om-domenenavn/regelverk-for-no/vedlegg-b/
-// counties
-aa.no
-ah.no
-bu.no
-fm.no
-hl.no
-hm.no
-jan-mayen.no
-mr.no
-nl.no
-nt.no
-of.no
-ol.no
-oslo.no
-rl.no
-sf.no
-st.no
-svalbard.no
-tm.no
-tr.no
-va.no
-vf.no
-// primary and lower secondary schools per county
-gs.aa.no
-gs.ah.no
-gs.bu.no
-gs.fm.no
-gs.hl.no
-gs.hm.no
-gs.jan-mayen.no
-gs.mr.no
-gs.nl.no
-gs.nt.no
-gs.of.no
-gs.ol.no
-gs.oslo.no
-gs.rl.no
-gs.sf.no
-gs.st.no
-gs.svalbard.no
-gs.tm.no
-gs.tr.no
-gs.va.no
-gs.vf.no
-// cities
-akrehamn.no
-åkrehamn.no
-algard.no
-ålgård.no
-arna.no
-brumunddal.no
-bryne.no
-bronnoysund.no
-brønnøysund.no
-drobak.no
-drøbak.no
-egersund.no
-fetsund.no
-floro.no
-florø.no
-fredrikstad.no
-hokksund.no
-honefoss.no
-hønefoss.no
-jessheim.no
-jorpeland.no
-jørpeland.no
-kirkenes.no
-kopervik.no
-krokstadelva.no
-langevag.no
-langevåg.no
-leirvik.no
-mjondalen.no
-mjøndalen.no
-mo-i-rana.no
-mosjoen.no
-mosjøen.no
-nesoddtangen.no
-orkanger.no
-osoyro.no
-osøyro.no
-raholt.no
-råholt.no
-sandnessjoen.no
-sandnessjøen.no
-skedsmokorset.no
-slattum.no
-spjelkavik.no
-stathelle.no
-stavern.no
-stjordalshalsen.no
-stjørdalshalsen.no
-tananger.no
-tranby.no
-vossevangen.no
-// communities
-afjord.no
-åfjord.no
-agdenes.no
-al.no
-ål.no
-alesund.no
-ålesund.no
-alstahaug.no
-alta.no
-áltá.no
-alaheadju.no
-álaheadju.no
-alvdal.no
-amli.no
-åmli.no
-amot.no
-åmot.no
-andebu.no
-andoy.no
-andøy.no
-andasuolo.no
-ardal.no
-årdal.no
-aremark.no
-arendal.no
-ås.no
-aseral.no
-åseral.no
-asker.no
-askim.no
-askvoll.no
-askoy.no
-askøy.no
-asnes.no
-åsnes.no
-audnedaln.no
-aukra.no
-aure.no
-aurland.no
-aurskog-holand.no
-aurskog-høland.no
-austevoll.no
-austrheim.no
-averoy.no
-averøy.no
-balestrand.no
-ballangen.no
-balat.no
-bálát.no
-balsfjord.no
-bahccavuotna.no
-báhccavuotna.no
-bamble.no
-bardu.no
-beardu.no
-beiarn.no
-bajddar.no
-bájddar.no
-baidar.no
-báidár.no
-berg.no
-bergen.no
-berlevag.no
-berlevåg.no
-bearalvahki.no
-bearalváhki.no
-bindal.no
-birkenes.no
-bjarkoy.no
-bjarkøy.no
-bjerkreim.no
-bjugn.no
-bodo.no
-bodø.no
-badaddja.no
-bådåddjå.no
-budejju.no
-bokn.no
-bremanger.no
-bronnoy.no
-brønnøy.no
-bygland.no
-bykle.no
-barum.no
-bærum.no
-bo.telemark.no
-bø.telemark.no
-bo.nordland.no
-bø.nordland.no
-bievat.no
-bievát.no
-bomlo.no
-bømlo.no
-batsfjord.no
-båtsfjord.no
-bahcavuotna.no
-báhcavuotna.no
-dovre.no
-drammen.no
-drangedal.no
-dyroy.no
-dyrøy.no
-donna.no
-dønna.no
-eid.no
-eidfjord.no
-eidsberg.no
-eidskog.no
-eidsvoll.no
-eigersund.no
-elverum.no
-enebakk.no
-engerdal.no
-etne.no
-etnedal.no
-evenes.no
-evenassi.no
-evenášši.no
-evje-og-hornnes.no
-farsund.no
-fauske.no
-fuossko.no
-fuoisku.no
-fedje.no
-fet.no
-finnoy.no
-finnøy.no
-fitjar.no
-fjaler.no
-fjell.no
-flakstad.no
-flatanger.no
-flekkefjord.no
-flesberg.no
-flora.no
-fla.no
-flå.no
-folldal.no
-forsand.no
-fosnes.no
-frei.no
-frogn.no
-froland.no
-frosta.no
-frana.no
-fræna.no
-froya.no
-frøya.no
-fusa.no
-fyresdal.no
-forde.no
-førde.no
-gamvik.no
-gangaviika.no
-gáŋgaviika.no
-gaular.no
-gausdal.no
-gildeskal.no
-gildeskål.no
-giske.no
-gjemnes.no
-gjerdrum.no
-gjerstad.no
-gjesdal.no
-gjovik.no
-gjøvik.no
-gloppen.no
-gol.no
-gran.no
-grane.no
-granvin.no
-gratangen.no
-grimstad.no
-grong.no
-kraanghke.no
-kråanghke.no
-grue.no
-gulen.no
-hadsel.no
-halden.no
-halsa.no
-hamar.no
-hamaroy.no
-habmer.no
-hábmer.no
-hapmir.no
-hápmir.no
-hammerfest.no
-hammarfeasta.no
-hámmárfeasta.no
-haram.no
-hareid.no
-harstad.no
-hasvik.no
-aknoluokta.no
-ákŋoluokta.no
-hattfjelldal.no
-aarborte.no
-haugesund.no
-hemne.no
-hemnes.no
-hemsedal.no
-heroy.more-og-romsdal.no
-herøy.møre-og-romsdal.no
-heroy.nordland.no
-herøy.nordland.no
-hitra.no
-hjartdal.no
-hjelmeland.no
-hobol.no
-hobøl.no
-hof.no
-hol.no
-hole.no
-holmestrand.no
-holtalen.no
-holtålen.no
-hornindal.no
-horten.no
-hurdal.no
-hurum.no
-hvaler.no
-hyllestad.no
-hagebostad.no
-hægebostad.no
-hoyanger.no
-høyanger.no
-hoylandet.no
-høylandet.no
-ha.no
-hå.no
-ibestad.no
-inderoy.no
-inderøy.no
-iveland.no
-jevnaker.no
-jondal.no
-jolster.no
-jølster.no
-karasjok.no
-karasjohka.no
-kárášjohka.no
-karlsoy.no
-galsa.no
-gálsá.no
-karmoy.no
-karmøy.no
-kautokeino.no
-guovdageaidnu.no
-klepp.no
-klabu.no
-klæbu.no
-kongsberg.no
-kongsvinger.no
-kragero.no
-kragerø.no
-kristiansand.no
-kristiansund.no
-krodsherad.no
-krødsherad.no
-kvalsund.no
-rahkkeravju.no
-ráhkkerávju.no
-kvam.no
-kvinesdal.no
-kvinnherad.no
-kviteseid.no
-kvitsoy.no
-kvitsøy.no
-kvafjord.no
-kvæfjord.no
-giehtavuoatna.no
-kvanangen.no
-kvænangen.no
-navuotna.no
-návuotna.no
-kafjord.no
-kåfjord.no
-gaivuotna.no
-gáivuotna.no
-larvik.no
-lavangen.no
-lavagis.no
-loabat.no
-loabát.no
-lebesby.no
-davvesiida.no
-leikanger.no
-leirfjord.no
-leka.no
-leksvik.no
-lenvik.no
-leangaviika.no
-leaŋgaviika.no
-lesja.no
-levanger.no
-lier.no
-lierne.no
-lillehammer.no
-lillesand.no
-lindesnes.no
-lindas.no
-lindås.no
-lom.no
-loppa.no
-lahppi.no
-láhppi.no
-lund.no
-lunner.no
-luroy.no
-lurøy.no
-luster.no
-lyngdal.no
-lyngen.no
-ivgu.no
-lardal.no
-lerdal.no
-lærdal.no
-lodingen.no
-lødingen.no
-lorenskog.no
-lørenskog.no
-loten.no
-løten.no
-malvik.no
-masoy.no
-måsøy.no
-muosat.no
-muosát.no
-mandal.no
-marker.no
-marnardal.no
-masfjorden.no
-meland.no
-meldal.no
-melhus.no
-meloy.no
-meløy.no
-meraker.no
-meråker.no
-moareke.no
-moåreke.no
-midsund.no
-midtre-gauldal.no
-modalen.no
-modum.no
-molde.no
-moskenes.no
-moss.no
-mosvik.no
-malselv.no
-målselv.no
-malatvuopmi.no
-málatvuopmi.no
-namdalseid.no
-aejrie.no
-namsos.no
-namsskogan.no
-naamesjevuemie.no
-nååmesjevuemie.no
-laakesvuemie.no
-nannestad.no
-narvik.no
-narviika.no
-naustdal.no
-nedre-eiker.no
-nes.akershus.no
-nes.buskerud.no
-nesna.no
-nesodden.no
-nesseby.no
-unjarga.no
-unjárga.no
-nesset.no
-nissedal.no
-nittedal.no
-nord-aurdal.no
-nord-fron.no
-nord-odal.no
-norddal.no
-nordkapp.no
-davvenjarga.no
-davvenjárga.no
-nordre-land.no
-nordreisa.no
-raisa.no
-ráisa.no
-nore-og-uvdal.no
-notodden.no
-naroy.no
-nærøy.no
-notteroy.no
-nøtterøy.no
-odda.no
-oksnes.no
-øksnes.no
-oppdal.no
-oppegard.no
-oppegård.no
-orkdal.no
-orland.no
-ørland.no
-orskog.no
-ørskog.no
-orsta.no
-ørsta.no
-os.hedmark.no
-os.hordaland.no
-osen.no
-osteroy.no
-osterøy.no
-ostre-toten.no
-østre-toten.no
-overhalla.no
-ovre-eiker.no
-øvre-eiker.no
-oyer.no
-øyer.no
-oygarden.no
-øygarden.no
-oystre-slidre.no
-øystre-slidre.no
-porsanger.no
-porsangu.no
-porsáŋgu.no
-porsgrunn.no
-radoy.no
-radøy.no
-rakkestad.no
-rana.no
-ruovat.no
-randaberg.no
-rauma.no
-rendalen.no
-rennebu.no
-rennesoy.no
-rennesøy.no
-rindal.no
-ringebu.no
-ringerike.no
-ringsaker.no
-rissa.no
-risor.no
-risør.no
-roan.no
-rollag.no
-rygge.no
-ralingen.no
-rælingen.no
-rodoy.no
-rødøy.no
-romskog.no
-rømskog.no
-roros.no
-røros.no
-rost.no
-røst.no
-royken.no
-røyken.no
-royrvik.no
-røyrvik.no
-rade.no
-råde.no
-salangen.no
-siellak.no
-saltdal.no
-salat.no
-sálát.no
-sálat.no
-samnanger.no
-sande.more-og-romsdal.no
-sande.møre-og-romsdal.no
-sande.vestfold.no
-sandefjord.no
-sandnes.no
-sandoy.no
-sandøy.no
-sarpsborg.no
-sauda.no
-sauherad.no
-sel.no
-selbu.no
-selje.no
-seljord.no
-sigdal.no
-siljan.no
-sirdal.no
-skaun.no
-skedsmo.no
-ski.no
-skien.no
-skiptvet.no
-skjervoy.no
-skjervøy.no
-skierva.no
-skiervá.no
-skjak.no
-skjåk.no
-skodje.no
-skanland.no
-skånland.no
-skanit.no
-skánit.no
-smola.no
-smøla.no
-snillfjord.no
-snasa.no
-snåsa.no
-snoasa.no
-snaase.no
-snåase.no
-sogndal.no
-sokndal.no
-sola.no
-solund.no
-songdalen.no
-sortland.no
-spydeberg.no
-stange.no
-stavanger.no
-steigen.no
-steinkjer.no
-stjordal.no
-stjørdal.no
-stokke.no
-stor-elvdal.no
-stord.no
-stordal.no
-storfjord.no
-omasvuotna.no
-strand.no
-stranda.no
-stryn.no
-sula.no
-suldal.no
-sund.no
-sunndal.no
-surnadal.no
-sveio.no
-svelvik.no
-sykkylven.no
-sogne.no
-søgne.no
-somna.no
-sømna.no
-sondre-land.no
-søndre-land.no
-sor-aurdal.no
-sør-aurdal.no
-sor-fron.no
-sør-fron.no
-sor-odal.no
-sør-odal.no
-sor-varanger.no
-sør-varanger.no
-matta-varjjat.no
-mátta-várjjat.no
-sorfold.no
-sørfold.no
-sorreisa.no
-sørreisa.no
-sorum.no
-sørum.no
-tana.no
-deatnu.no
-time.no
-tingvoll.no
-tinn.no
-tjeldsund.no
-dielddanuorri.no
-tjome.no
-tjøme.no
-tokke.no
-tolga.no
-torsken.no
-tranoy.no
-tranøy.no
-tromso.no
-tromsø.no
-tromsa.no
-romsa.no
-trondheim.no
-troandin.no
-trysil.no
-trana.no
-træna.no
-trogstad.no
-trøgstad.no
-tvedestrand.no
-tydal.no
-tynset.no
-tysfjord.no
-divtasvuodna.no
-divttasvuotna.no
-tysnes.no
-tysvar.no
-tysvær.no
-tonsberg.no
-tønsberg.no
-ullensaker.no
-ullensvang.no
-ulvik.no
-utsira.no
-vadso.no
-vadsø.no
-cahcesuolo.no
-čáhcesuolo.no
-vaksdal.no
-valle.no
-vang.no
-vanylven.no
-vardo.no
-vardø.no
-varggat.no
-várggát.no
-vefsn.no
-vaapste.no
-vega.no
-vegarshei.no
-vegårshei.no
-vennesla.no
-verdal.no
-verran.no
-vestby.no
-vestnes.no
-vestre-slidre.no
-vestre-toten.no
-vestvagoy.no
-vestvågøy.no
-vevelstad.no
-vik.no
-vikna.no
-vindafjord.no
-volda.no
-voss.no
-varoy.no
-værøy.no
-vagan.no
-vågan.no
-voagat.no
-vagsoy.no
-vågsøy.no
-vaga.no
-vågå.no
-valer.ostfold.no
-våler.østfold.no
-valer.hedmark.no
-våler.hedmark.no
-
-// np : http://www.mos.com.np/register.html
-*.np
-
-// nr : http://cenpac.net.nr/dns/index.html
-// Submitted by registry <technician@cenpac.net.nr>
-nr
-biz.nr
-info.nr
-gov.nr
-edu.nr
-org.nr
-net.nr
-com.nr
-
-// nu : https://en.wikipedia.org/wiki/.nu
-nu
-
-// nz : https://en.wikipedia.org/wiki/.nz
-// Submitted by registry <jay@nzrs.net.nz>
-nz
-ac.nz
-co.nz
-cri.nz
-geek.nz
-gen.nz
-govt.nz
-health.nz
-iwi.nz
-kiwi.nz
-maori.nz
-mil.nz
-māori.nz
-net.nz
-org.nz
-parliament.nz
-school.nz
-
-// om : https://en.wikipedia.org/wiki/.om
-om
-co.om
-com.om
-edu.om
-gov.om
-med.om
-museum.om
-net.om
-org.om
-pro.om
-
-// onion : https://tools.ietf.org/html/rfc7686
-onion
-
-// org : https://en.wikipedia.org/wiki/.org
-org
-
-// pa : http://www.nic.pa/
-// Some additional second level "domains" resolve directly as hostnames, such as
-// pannet.pa, so we add a rule for "pa".
-pa
-ac.pa
-gob.pa
-com.pa
-org.pa
-sld.pa
-edu.pa
-net.pa
-ing.pa
-abo.pa
-med.pa
-nom.pa
-
-// pe : https://www.nic.pe/InformeFinalComision.pdf
-pe
-edu.pe
-gob.pe
-nom.pe
-mil.pe
-org.pe
-com.pe
-net.pe
-
-// pf : http://www.gobin.info/domainname/formulaire-pf.pdf
-pf
-com.pf
-org.pf
-edu.pf
-
-// pg : https://en.wikipedia.org/wiki/.pg
-*.pg
-
-// ph : http://www.domains.ph/FAQ2.asp
-// Submitted by registry <jed@email.com.ph>
-ph
-com.ph
-net.ph
-org.ph
-gov.ph
-edu.ph
-ngo.ph
-mil.ph
-i.ph
-
-// pk : http://pk5.pknic.net.pk/pk5/msgNamepk.PK
-pk
-com.pk
-net.pk
-edu.pk
-org.pk
-fam.pk
-biz.pk
-web.pk
-gov.pk
-gob.pk
-gok.pk
-gon.pk
-gop.pk
-gos.pk
-info.pk
-
-// pl http://www.dns.pl/english/index.html
-// Submitted by registry
-pl
-com.pl
-net.pl
-org.pl
-// pl functional domains (http://www.dns.pl/english/index.html)
-aid.pl
-agro.pl
-atm.pl
-auto.pl
-biz.pl
-edu.pl
-gmina.pl
-gsm.pl
-info.pl
-mail.pl
-miasta.pl
-media.pl
-mil.pl
-nieruchomosci.pl
-nom.pl
-pc.pl
-powiat.pl
-priv.pl
-realestate.pl
-rel.pl
-sex.pl
-shop.pl
-sklep.pl
-sos.pl
-szkola.pl
-targi.pl
-tm.pl
-tourism.pl
-travel.pl
-turystyka.pl
-// Government domains
-gov.pl
-ap.gov.pl
-ic.gov.pl
-is.gov.pl
-us.gov.pl
-kmpsp.gov.pl
-kppsp.gov.pl
-kwpsp.gov.pl
-psp.gov.pl
-wskr.gov.pl
-kwp.gov.pl
-mw.gov.pl
-ug.gov.pl
-um.gov.pl
-umig.gov.pl
-ugim.gov.pl
-upow.gov.pl
-uw.gov.pl
-starostwo.gov.pl
-pa.gov.pl
-po.gov.pl
-psse.gov.pl
-pup.gov.pl
-rzgw.gov.pl
-sa.gov.pl
-so.gov.pl
-sr.gov.pl
-wsa.gov.pl
-sko.gov.pl
-uzs.gov.pl
-wiih.gov.pl
-winb.gov.pl
-pinb.gov.pl
-wios.gov.pl
-witd.gov.pl
-wzmiuw.gov.pl
-piw.gov.pl
-wiw.gov.pl
-griw.gov.pl
-wif.gov.pl
-oum.gov.pl
-sdn.gov.pl
-zp.gov.pl
-uppo.gov.pl
-mup.gov.pl
-wuoz.gov.pl
-konsulat.gov.pl
-oirm.gov.pl
-// pl regional domains (http://www.dns.pl/english/index.html)
-augustow.pl
-babia-gora.pl
-bedzin.pl
-beskidy.pl
-bialowieza.pl
-bialystok.pl
-bielawa.pl
-bieszczady.pl
-boleslawiec.pl
-bydgoszcz.pl
-bytom.pl
-cieszyn.pl
-czeladz.pl
-czest.pl
-dlugoleka.pl
-elblag.pl
-elk.pl
-glogow.pl
-gniezno.pl
-gorlice.pl
-grajewo.pl
-ilawa.pl
-jaworzno.pl
-jelenia-gora.pl
-jgora.pl
-kalisz.pl
-kazimierz-dolny.pl
-karpacz.pl
-kartuzy.pl
-kaszuby.pl
-katowice.pl
-kepno.pl
-ketrzyn.pl
-klodzko.pl
-kobierzyce.pl
-kolobrzeg.pl
-konin.pl
-konskowola.pl
-kutno.pl
-lapy.pl
-lebork.pl
-legnica.pl
-lezajsk.pl
-limanowa.pl
-lomza.pl
-lowicz.pl
-lubin.pl
-lukow.pl
-malbork.pl
-malopolska.pl
-mazowsze.pl
-mazury.pl
-mielec.pl
-mielno.pl
-mragowo.pl
-naklo.pl
-nowaruda.pl
-nysa.pl
-olawa.pl
-olecko.pl
-olkusz.pl
-olsztyn.pl
-opoczno.pl
-opole.pl
-ostroda.pl
-ostroleka.pl
-ostrowiec.pl
-ostrowwlkp.pl
-pila.pl
-pisz.pl
-podhale.pl
-podlasie.pl
-polkowice.pl
-pomorze.pl
-pomorskie.pl
-prochowice.pl
-pruszkow.pl
-przeworsk.pl
-pulawy.pl
-radom.pl
-rawa-maz.pl
-rybnik.pl
-rzeszow.pl
-sanok.pl
-sejny.pl
-slask.pl
-slupsk.pl
-sosnowiec.pl
-stalowa-wola.pl
-skoczow.pl
-starachowice.pl
-stargard.pl
-suwalki.pl
-swidnica.pl
-swiebodzin.pl
-swinoujscie.pl
-szczecin.pl
-szczytno.pl
-tarnobrzeg.pl
-tgory.pl
-turek.pl
-tychy.pl
-ustka.pl
-walbrzych.pl
-warmia.pl
-warszawa.pl
-waw.pl
-wegrow.pl
-wielun.pl
-wlocl.pl
-wloclawek.pl
-wodzislaw.pl
-wolomin.pl
-wroclaw.pl
-zachpomor.pl
-zagan.pl
-zarow.pl
-zgora.pl
-zgorzelec.pl
-
-// pm : http://www.afnic.fr/medias/documents/AFNIC-naming-policy2012.pdf
-pm
-
-// pn : http://www.government.pn/PnRegistry/policies.htm
-pn
-gov.pn
-co.pn
-org.pn
-edu.pn
-net.pn
-
-// post : https://en.wikipedia.org/wiki/.post
-post
-
-// pr : http://www.nic.pr/index.asp?f=1
-pr
-com.pr
-net.pr
-org.pr
-gov.pr
-edu.pr
-isla.pr
-pro.pr
-biz.pr
-info.pr
-name.pr
-// these aren't mentioned on nic.pr, but on https://en.wikipedia.org/wiki/.pr
-est.pr
-prof.pr
-ac.pr
-
-// pro : http://registry.pro/get-pro
-pro
-aaa.pro
-aca.pro
-acct.pro
-avocat.pro
-bar.pro
-cpa.pro
-eng.pro
-jur.pro
-law.pro
-med.pro
-recht.pro
-
-// ps : https://en.wikipedia.org/wiki/.ps
-// http://www.nic.ps/registration/policy.html#reg
-ps
-edu.ps
-gov.ps
-sec.ps
-plo.ps
-com.ps
-org.ps
-net.ps
-
-// pt : https://www.dns.pt/en/domain/pt-terms-and-conditions-registration-rules/
-pt
-net.pt
-gov.pt
-org.pt
-edu.pt
-int.pt
-publ.pt
-com.pt
-nome.pt
-
-// pw : https://en.wikipedia.org/wiki/.pw
-pw
-co.pw
-ne.pw
-or.pw
-ed.pw
-go.pw
-belau.pw
-
-// py : http://www.nic.py/pautas.html#seccion_9
-// Submitted by registry
-py
-com.py
-coop.py
-edu.py
-gov.py
-mil.py
-net.py
-org.py
-
-// qa : http://domains.qa/en/
-qa
-com.qa
-edu.qa
-gov.qa
-mil.qa
-name.qa
-net.qa
-org.qa
-sch.qa
-
-// re : http://www.afnic.re/obtenir/chartes/nommage-re/annexe-descriptifs
-re
-asso.re
-com.re
-nom.re
-
-// ro : http://www.rotld.ro/
-ro
-arts.ro
-com.ro
-firm.ro
-info.ro
-nom.ro
-nt.ro
-org.ro
-rec.ro
-store.ro
-tm.ro
-www.ro
-
-// rs : https://www.rnids.rs/en/domains/national-domains
-rs
-ac.rs
-co.rs
-edu.rs
-gov.rs
-in.rs
-org.rs
-
-// ru : https://cctld.ru/files/pdf/docs/en/rules_ru-rf.pdf
-// Submitted by George Georgievsky <gug@cctld.ru>
-ru
-
-// rw : https://www.ricta.org.rw/sites/default/files/resources/registry_registrar_contract_0.pdf
-rw
-ac.rw
-co.rw
-coop.rw
-gov.rw
-mil.rw
-net.rw
-org.rw
-
-// sa : http://www.nic.net.sa/
-sa
-com.sa
-net.sa
-org.sa
-gov.sa
-med.sa
-pub.sa
-edu.sa
-sch.sa
-
-// sb : http://www.sbnic.net.sb/
-// Submitted by registry <lee.humphries@telekom.com.sb>
-sb
-com.sb
-edu.sb
-gov.sb
-net.sb
-org.sb
-
-// sc : http://www.nic.sc/
-sc
-com.sc
-gov.sc
-net.sc
-org.sc
-edu.sc
-
-// sd : http://www.isoc.sd/sudanic.isoc.sd/billing_pricing.htm
-// Submitted by registry <admin@isoc.sd>
-sd
-com.sd
-net.sd
-org.sd
-edu.sd
-med.sd
-tv.sd
-gov.sd
-info.sd
-
-// se : https://en.wikipedia.org/wiki/.se
-// Submitted by registry <patrik.wallstrom@iis.se>
-se
-a.se
-ac.se
-b.se
-bd.se
-brand.se
-c.se
-d.se
-e.se
-f.se
-fh.se
-fhsk.se
-fhv.se
-g.se
-h.se
-i.se
-k.se
-komforb.se
-kommunalforbund.se
-komvux.se
-l.se
-lanbib.se
-m.se
-n.se
-naturbruksgymn.se
-o.se
-org.se
-p.se
-parti.se
-pp.se
-press.se
-r.se
-s.se
-t.se
-tm.se
-u.se
-w.se
-x.se
-y.se
-z.se
-
-// sg : http://www.nic.net.sg/page/registration-policies-procedures-and-guidelines
-sg
-com.sg
-net.sg
-org.sg
-gov.sg
-edu.sg
-per.sg
-
-// sh : http://nic.sh/rules.htm
-sh
-com.sh
-net.sh
-gov.sh
-org.sh
-mil.sh
-
-// si : https://en.wikipedia.org/wiki/.si
-si
-
-// sj : No registrations at this time.
-// Submitted by registry <jarle@uninett.no>
-sj
-
-// sk : https://en.wikipedia.org/wiki/.sk
-// list of 2nd level domains ?
-sk
-
-// sl : http://www.nic.sl
-// Submitted by registry <adam@neoip.com>
-sl
-com.sl
-net.sl
-edu.sl
-gov.sl
-org.sl
-
-// sm : https://en.wikipedia.org/wiki/.sm
-sm
-
-// sn : https://en.wikipedia.org/wiki/.sn
-sn
-art.sn
-com.sn
-edu.sn
-gouv.sn
-org.sn
-perso.sn
-univ.sn
-
-// so : http://sonic.so/policies/
-so
-com.so
-edu.so
-gov.so
-me.so
-net.so
-org.so
-
-// sr : https://en.wikipedia.org/wiki/.sr
-sr
-
-// ss : https://registry.nic.ss/
-// Submitted by registry <technical@nic.ss>
-ss
-biz.ss
-com.ss
-edu.ss
-gov.ss
-me.ss
-net.ss
-org.ss
-sch.ss
-
-// st : http://www.nic.st/html/policyrules/
-st
-co.st
-com.st
-consulado.st
-edu.st
-embaixada.st
-mil.st
-net.st
-org.st
-principe.st
-saotome.st
-store.st
-
-// su : https://en.wikipedia.org/wiki/.su
-su
-
-// sv : http://www.svnet.org.sv/niveldos.pdf
-sv
-com.sv
-edu.sv
-gob.sv
-org.sv
-red.sv
-
-// sx : https://en.wikipedia.org/wiki/.sx
-// Submitted by registry <jcvignes@openregistry.com>
-sx
-gov.sx
-
-// sy : https://en.wikipedia.org/wiki/.sy
-// see also: http://www.gobin.info/domainname/sy.doc
-sy
-edu.sy
-gov.sy
-net.sy
-mil.sy
-com.sy
-org.sy
-
-// sz : https://en.wikipedia.org/wiki/.sz
-// http://www.sispa.org.sz/
-sz
-co.sz
-ac.sz
-org.sz
-
-// tc : https://en.wikipedia.org/wiki/.tc
-tc
-
-// td : https://en.wikipedia.org/wiki/.td
-td
-
-// tel: https://en.wikipedia.org/wiki/.tel
-// http://www.telnic.org/
-tel
-
-// tf : https://en.wikipedia.org/wiki/.tf
-tf
-
-// tg : https://en.wikipedia.org/wiki/.tg
-// http://www.nic.tg/
-tg
-
-// th : https://en.wikipedia.org/wiki/.th
-// Submitted by registry <krit@thains.co.th>
-th
-ac.th
-co.th
-go.th
-in.th
-mi.th
-net.th
-or.th
-
-// tj : http://www.nic.tj/policy.html
-tj
-ac.tj
-biz.tj
-co.tj
-com.tj
-edu.tj
-go.tj
-gov.tj
-int.tj
-mil.tj
-name.tj
-net.tj
-nic.tj
-org.tj
-test.tj
-web.tj
-
-// tk : https://en.wikipedia.org/wiki/.tk
-tk
-
-// tl : https://en.wikipedia.org/wiki/.tl
-tl
-gov.tl
-
-// tm : http://www.nic.tm/local.html
-tm
-com.tm
-co.tm
-org.tm
-net.tm
-nom.tm
-gov.tm
-mil.tm
-edu.tm
-
-// tn : http://www.registre.tn/fr/
-// https://whois.ati.tn/
-tn
-com.tn
-ens.tn
-fin.tn
-gov.tn
-ind.tn
-info.tn
-intl.tn
-mincom.tn
-nat.tn
-net.tn
-org.tn
-perso.tn
-tourism.tn
-
-// to : https://en.wikipedia.org/wiki/.to
-// Submitted by registry <egullich@colo.to>
-to
-com.to
-gov.to
-net.to
-org.to
-edu.to
-mil.to
-
-// tr : https://nic.tr/
-// https://nic.tr/forms/eng/policies.pdf
-// https://nic.tr/index.php?USRACTN=PRICELST
-tr
-av.tr
-bbs.tr
-bel.tr
-biz.tr
-com.tr
-dr.tr
-edu.tr
-gen.tr
-gov.tr
-info.tr
-mil.tr
-k12.tr
-kep.tr
-name.tr
-net.tr
-org.tr
-pol.tr
-tel.tr
-tsk.tr
-tv.tr
-web.tr
-// Used by Northern Cyprus
-nc.tr
-// Used by government agencies of Northern Cyprus
-gov.nc.tr
-
-// tt : http://www.nic.tt/
-tt
-co.tt
-com.tt
-org.tt
-net.tt
-biz.tt
-info.tt
-pro.tt
-int.tt
-coop.tt
-jobs.tt
-mobi.tt
-travel.tt
-museum.tt
-aero.tt
-name.tt
-gov.tt
-edu.tt
-
-// tv : https://en.wikipedia.org/wiki/.tv
-// Not listing any 2LDs as reserved since none seem to exist in practice,
-// Wikipedia notwithstanding.
-tv
-
-// tw : https://en.wikipedia.org/wiki/.tw
-tw
-edu.tw
-gov.tw
-mil.tw
-com.tw
-net.tw
-org.tw
-idv.tw
-game.tw
-ebiz.tw
-club.tw
-網路.tw
-組織.tw
-商業.tw
-
-// tz : http://www.tznic.or.tz/index.php/domains
-// Submitted by registry <manager@tznic.or.tz>
-tz
-ac.tz
-co.tz
-go.tz
-hotel.tz
-info.tz
-me.tz
-mil.tz
-mobi.tz
-ne.tz
-or.tz
-sc.tz
-tv.tz
-
-// ua : https://hostmaster.ua/policy/?ua
-// Submitted by registry <dk@cctld.ua>
-ua
-// ua 2LD
-com.ua
-edu.ua
-gov.ua
-in.ua
-net.ua
-org.ua
-// ua geographic names
-// https://hostmaster.ua/2ld/
-cherkassy.ua
-cherkasy.ua
-chernigov.ua
-chernihiv.ua
-chernivtsi.ua
-chernovtsy.ua
-ck.ua
-cn.ua
-cr.ua
-crimea.ua
-cv.ua
-dn.ua
-dnepropetrovsk.ua
-dnipropetrovsk.ua
-donetsk.ua
-dp.ua
-if.ua
-ivano-frankivsk.ua
-kh.ua
-kharkiv.ua
-kharkov.ua
-kherson.ua
-khmelnitskiy.ua
-khmelnytskyi.ua
-kiev.ua
-kirovograd.ua
-km.ua
-kr.ua
-krym.ua
-ks.ua
-kv.ua
-kyiv.ua
-lg.ua
-lt.ua
-lugansk.ua
-lutsk.ua
-lv.ua
-lviv.ua
-mk.ua
-mykolaiv.ua
-nikolaev.ua
-od.ua
-odesa.ua
-odessa.ua
-pl.ua
-poltava.ua
-rivne.ua
-rovno.ua
-rv.ua
-sb.ua
-sebastopol.ua
-sevastopol.ua
-sm.ua
-sumy.ua
-te.ua
-ternopil.ua
-uz.ua
-uzhgorod.ua
-vinnica.ua
-vinnytsia.ua
-vn.ua
-volyn.ua
-yalta.ua
-zaporizhzhe.ua
-zaporizhzhia.ua
-zhitomir.ua
-zhytomyr.ua
-zp.ua
-zt.ua
-
-// ug : https://www.registry.co.ug/
-ug
-co.ug
-or.ug
-ac.ug
-sc.ug
-go.ug
-ne.ug
-com.ug
-org.ug
-
-// uk : https://en.wikipedia.org/wiki/.uk
-// Submitted by registry <Michael.Daly@nominet.org.uk>
-uk
-ac.uk
-co.uk
-gov.uk
-ltd.uk
-me.uk
-net.uk
-nhs.uk
-org.uk
-plc.uk
-police.uk
-*.sch.uk
-
-// us : https://en.wikipedia.org/wiki/.us
-us
-dni.us
-fed.us
-isa.us
-kids.us
-nsn.us
-// us geographic names
-ak.us
-al.us
-ar.us
-as.us
-az.us
-ca.us
-co.us
-ct.us
-dc.us
-de.us
-fl.us
-ga.us
-gu.us
-hi.us
-ia.us
-id.us
-il.us
-in.us
-ks.us
-ky.us
-la.us
-ma.us
-md.us
-me.us
-mi.us
-mn.us
-mo.us
-ms.us
-mt.us
-nc.us
-nd.us
-ne.us
-nh.us
-nj.us
-nm.us
-nv.us
-ny.us
-oh.us
-ok.us
-or.us
-pa.us
-pr.us
-ri.us
-sc.us
-sd.us
-tn.us
-tx.us
-ut.us
-vi.us
-vt.us
-va.us
-wa.us
-wi.us
-wv.us
-wy.us
-// The registrar notes several more specific domains available in each state,
-// such as state.*.us, dst.*.us, etc., but resolution of these is somewhat
-// haphazard; in some states these domains resolve as addresses, while in others
-// only subdomains are available, or even nothing at all. We include the
-// most common ones where it's clear that different sites are different
-// entities.
-k12.ak.us
-k12.al.us
-k12.ar.us
-k12.as.us
-k12.az.us
-k12.ca.us
-k12.co.us
-k12.ct.us
-k12.dc.us
-k12.de.us
-k12.fl.us
-k12.ga.us
-k12.gu.us
-// k12.hi.us  Bug 614565 - Hawaii has a state-wide DOE login
-k12.ia.us
-k12.id.us
-k12.il.us
-k12.in.us
-k12.ks.us
-k12.ky.us
-k12.la.us
-k12.ma.us
-k12.md.us
-k12.me.us
-k12.mi.us
-k12.mn.us
-k12.mo.us
-k12.ms.us
-k12.mt.us
-k12.nc.us
-// k12.nd.us  Bug 1028347 - Removed at request of Travis Rosso <trossow@nd.gov>
-k12.ne.us
-k12.nh.us
-k12.nj.us
-k12.nm.us
-k12.nv.us
-k12.ny.us
-k12.oh.us
-k12.ok.us
-k12.or.us
-k12.pa.us
-k12.pr.us
-// k12.ri.us  Removed at request of Kim Cournoyer <netsupport@staff.ri.net>
-k12.sc.us
-// k12.sd.us  Bug 934131 - Removed at request of James Booze <James.Booze@k12.sd.us>
-k12.tn.us
-k12.tx.us
-k12.ut.us
-k12.vi.us
-k12.vt.us
-k12.va.us
-k12.wa.us
-k12.wi.us
-// k12.wv.us  Bug 947705 - Removed at request of Verne Britton <verne@wvnet.edu>
-k12.wy.us
-cc.ak.us
-cc.al.us
-cc.ar.us
-cc.as.us
-cc.az.us
-cc.ca.us
-cc.co.us
-cc.ct.us
-cc.dc.us
-cc.de.us
-cc.fl.us
-cc.ga.us
-cc.gu.us
-cc.hi.us
-cc.ia.us
-cc.id.us
-cc.il.us
-cc.in.us
-cc.ks.us
-cc.ky.us
-cc.la.us
-cc.ma.us
-cc.md.us
-cc.me.us
-cc.mi.us
-cc.mn.us
-cc.mo.us
-cc.ms.us
-cc.mt.us
-cc.nc.us
-cc.nd.us
-cc.ne.us
-cc.nh.us
-cc.nj.us
-cc.nm.us
-cc.nv.us
-cc.ny.us
-cc.oh.us
-cc.ok.us
-cc.or.us
-cc.pa.us
-cc.pr.us
-cc.ri.us
-cc.sc.us
-cc.sd.us
-cc.tn.us
-cc.tx.us
-cc.ut.us
-cc.vi.us
-cc.vt.us
-cc.va.us
-cc.wa.us
-cc.wi.us
-cc.wv.us
-cc.wy.us
-lib.ak.us
-lib.al.us
-lib.ar.us
-lib.as.us
-lib.az.us
-lib.ca.us
-lib.co.us
-lib.ct.us
-lib.dc.us
-// lib.de.us  Issue #243 - Moved to Private section at request of Ed Moore <Ed.Moore@lib.de.us>
-lib.fl.us
-lib.ga.us
-lib.gu.us
-lib.hi.us
-lib.ia.us
-lib.id.us
-lib.il.us
-lib.in.us
-lib.ks.us
-lib.ky.us
-lib.la.us
-lib.ma.us
-lib.md.us
-lib.me.us
-lib.mi.us
-lib.mn.us
-lib.mo.us
-lib.ms.us
-lib.mt.us
-lib.nc.us
-lib.nd.us
-lib.ne.us
-lib.nh.us
-lib.nj.us
-lib.nm.us
-lib.nv.us
-lib.ny.us
-lib.oh.us
-lib.ok.us
-lib.or.us
-lib.pa.us
-lib.pr.us
-lib.ri.us
-lib.sc.us
-lib.sd.us
-lib.tn.us
-lib.tx.us
-lib.ut.us
-lib.vi.us
-lib.vt.us
-lib.va.us
-lib.wa.us
-lib.wi.us
-// lib.wv.us  Bug 941670 - Removed at request of Larry W Arnold <arnold@wvlc.lib.wv.us>
-lib.wy.us
-// k12.ma.us contains school districts in Massachusetts. The 4LDs are
-//  managed independently except for private (PVT), charter (CHTR) and
-//  parochial (PAROCH) schools.  Those are delegated directly to the
-//  5LD operators.   <k12-ma-hostmaster _ at _ rsuc.gweep.net>
-pvt.k12.ma.us
-chtr.k12.ma.us
-paroch.k12.ma.us
-// Merit Network, Inc. maintains the registry for =~ /(k12|cc|lib).mi.us/ and the following
-//    see also: http://domreg.merit.edu
-//    see also: whois -h whois.domreg.merit.edu help
-ann-arbor.mi.us
-cog.mi.us
-dst.mi.us
-eaton.mi.us
-gen.mi.us
-mus.mi.us
-tec.mi.us
-washtenaw.mi.us
-
-// uy : http://www.nic.org.uy/
-uy
-com.uy
-edu.uy
-gub.uy
-mil.uy
-net.uy
-org.uy
-
-// uz : http://www.reg.uz/
-uz
-co.uz
-com.uz
-net.uz
-org.uz
-
-// va : https://en.wikipedia.org/wiki/.va
-va
-
-// vc : https://en.wikipedia.org/wiki/.vc
-// Submitted by registry <kshah@ca.afilias.info>
-vc
-com.vc
-net.vc
-org.vc
-gov.vc
-mil.vc
-edu.vc
-
-// ve : https://registro.nic.ve/
-// Submitted by registry nic@nic.ve and nicve@conatel.gob.ve
-ve
-arts.ve
-bib.ve
-co.ve
-com.ve
-e12.ve
-edu.ve
-firm.ve
-gob.ve
-gov.ve
-info.ve
-int.ve
-mil.ve
-net.ve
-nom.ve
-org.ve
-rar.ve
-rec.ve
-store.ve
-tec.ve
-web.ve
-
-// vg : https://en.wikipedia.org/wiki/.vg
-vg
-
-// vi : http://www.nic.vi/newdomainform.htm
-// http://www.nic.vi/Domain_Rules/body_domain_rules.html indicates some other
-// TLDs are "reserved", such as edu.vi and gov.vi, but doesn't actually say they
-// are available for registration (which they do not seem to be).
-vi
-co.vi
-com.vi
-k12.vi
-net.vi
-org.vi
-
-// vn : https://www.dot.vn/vnnic/vnnic/domainregistration.jsp
-vn
-com.vn
-net.vn
-org.vn
-edu.vn
-gov.vn
-int.vn
-ac.vn
-biz.vn
-info.vn
-name.vn
-pro.vn
-health.vn
-
-// vu : https://en.wikipedia.org/wiki/.vu
-// http://www.vunic.vu/
-vu
-com.vu
-edu.vu
-net.vu
-org.vu
-
-// wf : http://www.afnic.fr/medias/documents/AFNIC-naming-policy2012.pdf
-wf
-
-// ws : https://en.wikipedia.org/wiki/.ws
-// http://samoanic.ws/index.dhtml
-ws
-com.ws
-net.ws
-org.ws
-gov.ws
-edu.ws
-
-// yt : http://www.afnic.fr/medias/documents/AFNIC-naming-policy2012.pdf
-yt
-
-// IDN ccTLDs
-// When submitting patches, please maintain a sort by ISO 3166 ccTLD, then
-// U-label, and follow this format:
-// // A-Label ("<Latin renderings>", <language name>[, variant info]) : <ISO 3166 ccTLD>
-// // [sponsoring org]
-// U-Label
-
-// xn--mgbaam7a8h ("Emerat", Arabic) : AE
-// http://nic.ae/english/arabicdomain/rules.jsp
-امارات
-
-// xn--y9a3aq ("hye", Armenian) : AM
-// ISOC AM (operated by .am Registry)
-հայ
-
-// xn--54b7fta0cc ("Bangla", Bangla) : BD
-বাংলা
-
-// xn--90ae ("bg", Bulgarian) : BG
-бг
-
-// xn--mgbcpq6gpa1a ("albahrain", Arabic) : BH
-البحرين
-
-// xn--90ais ("bel", Belarusian/Russian Cyrillic) : BY
-// Operated by .by registry
-бел
-
-// xn--fiqs8s ("Zhongguo/China", Chinese, Simplified) : CN
-// CNNIC
-// http://cnnic.cn/html/Dir/2005/10/11/3218.htm
-中国
-
-// xn--fiqz9s ("Zhongguo/China", Chinese, Traditional) : CN
-// CNNIC
-// http://cnnic.cn/html/Dir/2005/10/11/3218.htm
-中國
-
-// xn--lgbbat1ad8j ("Algeria/Al Jazair", Arabic) : DZ
-الجزائر
-
-// xn--wgbh1c ("Egypt/Masr", Arabic) : EG
-// http://www.dotmasr.eg/
-مصر
-
-// xn--e1a4c ("eu", Cyrillic) : EU
-// https://eurid.eu
-ею
-
-// xn--qxa6a ("eu", Greek) : EU
-// https://eurid.eu
-ευ
-
-// xn--mgbah1a3hjkrd ("Mauritania", Arabic) : MR
-موريتانيا
-
-// xn--node ("ge", Georgian Mkhedruli) : GE
-გე
-
-// xn--qxam ("el", Greek) : GR
-// Hellenic Ministry of Infrastructure, Transport, and Networks
-ελ
-
-// xn--j6w193g ("Hong Kong", Chinese) : HK
-// https://www.hkirc.hk
-// Submitted by registry <hk.tech@hkirc.hk>
-// https://www.hkirc.hk/content.jsp?id=30#!/34
-香港
-公司.香港
-教育.香港
-政府.香港
-個人.香港
-網絡.香港
-組織.香港
-
-// xn--2scrj9c ("Bharat", Kannada) : IN
-// India
-ಭಾರತ
-
-// xn--3hcrj9c ("Bharat", Oriya) : IN
-// India
-ଭାରତ
-
-// xn--45br5cyl ("Bharatam", Assamese) : IN
-// India
-ভাৰত
-
-// xn--h2breg3eve ("Bharatam", Sanskrit) : IN
-// India
-भारतम्
-
-// xn--h2brj9c8c ("Bharot", Santali) : IN
-// India
-भारोत
-
-// xn--mgbgu82a ("Bharat", Sindhi) : IN
-// India
-ڀارت
-
-// xn--rvc1e0am3e ("Bharatam", Malayalam) : IN
-// India
-ഭാരതം
-
-// xn--h2brj9c ("Bharat", Devanagari) : IN
-// India
-भारत
-
-// xn--mgbbh1a ("Bharat", Kashmiri) : IN
-// India
-بارت
-
-// xn--mgbbh1a71e ("Bharat", Arabic) : IN
-// India
-بھارت
-
-// xn--fpcrj9c3d ("Bharat", Telugu) : IN
-// India
-భారత్
-
-// xn--gecrj9c ("Bharat", Gujarati) : IN
-// India
-ભારત
-
-// xn--s9brj9c ("Bharat", Gurmukhi) : IN
-// India
-ਭਾਰਤ
-
-// xn--45brj9c ("Bharat", Bengali) : IN
-// India
-ভারত
-
-// xn--xkc2dl3a5ee0h ("India", Tamil) : IN
-// India
-இந்தியா
-
-// xn--mgba3a4f16a ("Iran", Persian) : IR
-ایران
-
-// xn--mgba3a4fra ("Iran", Arabic) : IR
-ايران
-
-// xn--mgbtx2b ("Iraq", Arabic) : IQ
-// Communications and Media Commission
-عراق
-
-// xn--mgbayh7gpa ("al-Ordon", Arabic) : JO
-// National Information Technology Center (NITC)
-// Royal Scientific Society, Al-Jubeiha
-الاردن
-
-// xn--3e0b707e ("Republic of Korea", Hangul) : KR
-한국
-
-// xn--80ao21a ("Kaz", Kazakh) : KZ
-қаз
-
-// xn--q7ce6a ("Lao", Lao) : LA
-ລາວ
-
-// xn--fzc2c9e2c ("Lanka", Sinhalese-Sinhala) : LK
-// https://nic.lk
-ලංකා
-
-// xn--xkc2al3hye2a ("Ilangai", Tamil) : LK
-// https://nic.lk
-இலங்கை
-
-// xn--mgbc0a9azcg ("Morocco/al-Maghrib", Arabic) : MA
-المغرب
-
-// xn--d1alf ("mkd", Macedonian) : MK
-// MARnet
-мкд
-
-// xn--l1acc ("mon", Mongolian) : MN
-мон
-
-// xn--mix891f ("Macao", Chinese, Traditional) : MO
-// MONIC / HNET Asia (Registry Operator for .mo)
-澳門
-
-// xn--mix082f ("Macao", Chinese, Simplified) : MO
-澳门
-
-// xn--mgbx4cd0ab ("Malaysia", Malay) : MY
-مليسيا
-
-// xn--mgb9awbf ("Oman", Arabic) : OM
-عمان
-
-// xn--mgbai9azgqp6j ("Pakistan", Urdu/Arabic) : PK
-پاکستان
-
-// xn--mgbai9a5eva00b ("Pakistan", Urdu/Arabic, variant) : PK
-پاكستان
-
-// xn--ygbi2ammx ("Falasteen", Arabic) : PS
-// The Palestinian National Internet Naming Authority (PNINA)
-// http://www.pnina.ps
-فلسطين
-
-// xn--90a3ac ("srb", Cyrillic) : RS
-// https://www.rnids.rs/en/domains/national-domains
-срб
-пр.срб
-орг.срб
-обр.срб
-од.срб
-упр.срб
-ак.срб
-
-// xn--p1ai ("rf", Russian-Cyrillic) : RU
-// https://cctld.ru/files/pdf/docs/en/rules_ru-rf.pdf
-// Submitted by George Georgievsky <gug@cctld.ru>
-рф
-
-// xn--wgbl6a ("Qatar", Arabic) : QA
-// http://www.ict.gov.qa/
-قطر
-
-// xn--mgberp4a5d4ar ("AlSaudiah", Arabic) : SA
-// http://www.nic.net.sa/
-السعودية
-
-// xn--mgberp4a5d4a87g ("AlSaudiah", Arabic, variant)  : SA
-السعودیة
-
-// xn--mgbqly7c0a67fbc ("AlSaudiah", Arabic, variant) : SA
-السعودیۃ
-
-// xn--mgbqly7cvafr ("AlSaudiah", Arabic, variant) : SA
-السعوديه
-
-// xn--mgbpl2fh ("sudan", Arabic) : SD
-// Operated by .sd registry
-سودان
-
-// xn--yfro4i67o Singapore ("Singapore", Chinese) : SG
-新加坡
-
-// xn--clchc0ea0b2g2a9gcd ("Singapore", Tamil) : SG
-சிங்கப்பூர்
-
-// xn--ogbpf8fl ("Syria", Arabic) : SY
-سورية
-
-// xn--mgbtf8fl ("Syria", Arabic, variant) : SY
-سوريا
-
-// xn--o3cw4h ("Thai", Thai) : TH
-// http://www.thnic.co.th
-ไทย
-ศึกษา.ไทย
-ธุรกิจ.ไทย
-รัฐบาล.ไทย
-ทหาร.ไทย
-เน็ต.ไทย
-องค์กร.ไทย
-
-// xn--pgbs0dh ("Tunisia", Arabic) : TN
-// http://nic.tn
-تونس
-
-// xn--kpry57d ("Taiwan", Chinese, Traditional) : TW
-// http://www.twnic.net/english/dn/dn_07a.htm
-台灣
-
-// xn--kprw13d ("Taiwan", Chinese, Simplified) : TW
-// http://www.twnic.net/english/dn/dn_07a.htm
-台湾
-
-// xn--nnx388a ("Taiwan", Chinese, variant) : TW
-臺灣
-
-// xn--j1amh ("ukr", Cyrillic) : UA
-укр
-
-// xn--mgb2ddes ("AlYemen", Arabic) : YE
-اليمن
-
-// xxx : http://icmregistry.com
-xxx
-
-// ye : http://www.y.net.ye/services/domain_name.htm
-ye
-com.ye
-edu.ye
-gov.ye
-net.ye
-mil.ye
-org.ye
-
-// za : https://www.zadna.org.za/content/page/domain-information/
-ac.za
-agric.za
-alt.za
-co.za
-edu.za
-gov.za
-grondar.za
-law.za
-mil.za
-net.za
-ngo.za
-nic.za
-nis.za
-nom.za
-org.za
-school.za
-tm.za
-web.za
-
-// zm : https://zicta.zm/
-// Submitted by registry <info@zicta.zm>
-zm
-ac.zm
-biz.zm
-co.zm
-com.zm
-edu.zm
-gov.zm
-info.zm
-mil.zm
-net.zm
-org.zm
-sch.zm
-
-// zw : https://www.potraz.gov.zw/
-// Confirmed by registry <bmtengwa@potraz.gov.zw> 2017-01-25
-zw
-ac.zw
-co.zw
-gov.zw
-mil.zw
-org.zw
-
-
-// newGTLDs
-
-// List of new gTLDs imported from https://www.icann.org/resources/registries/gtlds/v2/gtlds.json on 2022-03-27T15:13:38Z
-// This list is auto-generated, don't edit it manually.
-// aaa : 2015-02-26 American Automobile Association, Inc.
-aaa
-
-// aarp : 2015-05-21 AARP
-aarp
-
-// abarth : 2015-07-30 Fiat Chrysler Automobiles N.V.
-abarth
-
-// abb : 2014-10-24 ABB Ltd
-abb
-
-// abbott : 2014-07-24 Abbott Laboratories, Inc.
-abbott
-
-// abbvie : 2015-07-30 AbbVie Inc.
-abbvie
-
-// abc : 2015-07-30 Disney Enterprises, Inc.
-abc
-
-// able : 2015-06-25 Able Inc.
-able
-
-// abogado : 2014-04-24 Registry Services, LLC
-abogado
-
-// abudhabi : 2015-07-30 Abu Dhabi Systems and Information Centre
-abudhabi
-
-// academy : 2013-11-07 Binky Moon, LLC
-academy
-
-// accenture : 2014-08-15 Accenture plc
-accenture
-
-// accountant : 2014-11-20 dot Accountant Limited
-accountant
-
-// accountants : 2014-03-20 Binky Moon, LLC
-accountants
-
-// aco : 2015-01-08 ACO Severin Ahlmann GmbH & Co. KG
-aco
-
-// actor : 2013-12-12 Dog Beach, LLC
-actor
-
-// adac : 2015-07-16 Allgemeiner Deutscher Automobil-Club e.V. (ADAC)
-adac
-
-// ads : 2014-12-04 Charleston Road Registry Inc.
-ads
-
-// adult : 2014-10-16 ICM Registry AD LLC
-adult
-
-// aeg : 2015-03-19 Aktiebolaget Electrolux
-aeg
-
-// aetna : 2015-05-21 Aetna Life Insurance Company
-aetna
-
-// afl : 2014-10-02 Australian Football League
-afl
-
-// africa : 2014-03-24 ZA Central Registry NPC trading as Registry.Africa
-africa
-
-// agakhan : 2015-04-23 Fondation Aga Khan (Aga Khan Foundation)
-agakhan
-
-// agency : 2013-11-14 Binky Moon, LLC
-agency
-
-// aig : 2014-12-18 American International Group, Inc.
-aig
-
-// airbus : 2015-07-30 Airbus S.A.S.
-airbus
-
-// airforce : 2014-03-06 Dog Beach, LLC
-airforce
-
-// airtel : 2014-10-24 Bharti Airtel Limited
-airtel
-
-// akdn : 2015-04-23 Fondation Aga Khan (Aga Khan Foundation)
-akdn
-
-// alfaromeo : 2015-07-31 Fiat Chrysler Automobiles N.V.
-alfaromeo
-
-// alibaba : 2015-01-15 Alibaba Group Holding Limited
-alibaba
-
-// alipay : 2015-01-15 Alibaba Group Holding Limited
-alipay
-
-// allfinanz : 2014-07-03 Allfinanz Deutsche Vermögensberatung Aktiengesellschaft
-allfinanz
-
-// allstate : 2015-07-31 Allstate Fire and Casualty Insurance Company
-allstate
-
-// ally : 2015-06-18 Ally Financial Inc.
-ally
-
-// alsace : 2014-07-02 Region Grand Est
-alsace
-
-// alstom : 2015-07-30 ALSTOM
-alstom
-
-// amazon : 2019-12-19 Amazon Registry Services, Inc.
-amazon
-
-// americanexpress : 2015-07-31 American Express Travel Related Services Company, Inc.
-americanexpress
-
-// americanfamily : 2015-07-23 AmFam, Inc.
-americanfamily
-
-// amex : 2015-07-31 American Express Travel Related Services Company, Inc.
-amex
-
-// amfam : 2015-07-23 AmFam, Inc.
-amfam
-
-// amica : 2015-05-28 Amica Mutual Insurance Company
-amica
-
-// amsterdam : 2014-07-24 Gemeente Amsterdam
-amsterdam
-
-// analytics : 2014-12-18 Campus IP LLC
-analytics
-
-// android : 2014-08-07 Charleston Road Registry Inc.
-android
-
-// anquan : 2015-01-08 Beijing Qihu Keji Co., Ltd.
-anquan
-
-// anz : 2015-07-31 Australia and New Zealand Banking Group Limited
-anz
-
-// aol : 2015-09-17 Oath Inc.
-aol
-
-// apartments : 2014-12-11 Binky Moon, LLC
-apartments
-
-// app : 2015-05-14 Charleston Road Registry Inc.
-app
-
-// apple : 2015-05-14 Apple Inc.
-apple
-
-// aquarelle : 2014-07-24 Aquarelle.com
-aquarelle
-
-// arab : 2015-11-12 League of Arab States
-arab
-
-// aramco : 2014-11-20 Aramco Services Company
-aramco
-
-// archi : 2014-02-06 Afilias Limited
-archi
-
-// army : 2014-03-06 Dog Beach, LLC
-army
-
-// art : 2016-03-24 UK Creative Ideas Limited
-art
-
-// arte : 2014-12-11 Association Relative à la Télévision Européenne G.E.I.E.
-arte
-
-// asda : 2015-07-31 Wal-Mart Stores, Inc.
-asda
-
-// associates : 2014-03-06 Binky Moon, LLC
-associates
-
-// athleta : 2015-07-30 The Gap, Inc.
-athleta
-
-// attorney : 2014-03-20 Dog Beach, LLC
-attorney
-
-// auction : 2014-03-20 Dog Beach, LLC
-auction
-
-// audi : 2015-05-21 AUDI Aktiengesellschaft
-audi
-
-// audible : 2015-06-25 Amazon Registry Services, Inc.
-audible
-
-// audio : 2014-03-20 XYZ.COM LLC
-audio
-
-// auspost : 2015-08-13 Australian Postal Corporation
-auspost
-
-// author : 2014-12-18 Amazon Registry Services, Inc.
-author
-
-// auto : 2014-11-13 XYZ.COM LLC
-auto
-
-// autos : 2014-01-09 XYZ.COM LLC
-autos
-
-// avianca : 2015-01-08 Avianca Holdings S.A.
-avianca
-
-// aws : 2015-06-25 AWS Registry LLC
-aws
-
-// axa : 2013-12-19 AXA Group Operations SAS
-axa
-
-// azure : 2014-12-18 Microsoft Corporation
-azure
-
-// baby : 2015-04-09 XYZ.COM LLC
-baby
-
-// baidu : 2015-01-08 Baidu, Inc.
-baidu
-
-// banamex : 2015-07-30 Citigroup Inc.
-banamex
-
-// bananarepublic : 2015-07-31 The Gap, Inc.
-bananarepublic
-
-// band : 2014-06-12 Dog Beach, LLC
-band
-
-// bank : 2014-09-25 fTLD Registry Services LLC
-bank
-
-// bar : 2013-12-12 Punto 2012 Sociedad Anonima Promotora de Inversion de Capital Variable
-bar
-
-// barcelona : 2014-07-24 Municipi de Barcelona
-barcelona
-
-// barclaycard : 2014-11-20 Barclays Bank PLC
-barclaycard
-
-// barclays : 2014-11-20 Barclays Bank PLC
-barclays
-
-// barefoot : 2015-06-11 Gallo Vineyards, Inc.
-barefoot
-
-// bargains : 2013-11-14 Binky Moon, LLC
-bargains
-
-// baseball : 2015-10-29 MLB Advanced Media DH, LLC
-baseball
-
-// basketball : 2015-08-20 Fédération Internationale de Basketball (FIBA)
-basketball
-
-// bauhaus : 2014-04-17 Werkhaus GmbH
-bauhaus
-
-// bayern : 2014-01-23 Bayern Connect GmbH
-bayern
-
-// bbc : 2014-12-18 British Broadcasting Corporation
-bbc
-
-// bbt : 2015-07-23 BB&T Corporation
-bbt
-
-// bbva : 2014-10-02 BANCO BILBAO VIZCAYA ARGENTARIA, S.A.
-bbva
-
-// bcg : 2015-04-02 The Boston Consulting Group, Inc.
-bcg
-
-// bcn : 2014-07-24 Municipi de Barcelona
-bcn
-
-// beats : 2015-05-14 Beats Electronics, LLC
-beats
-
-// beauty : 2015-12-03 XYZ.COM LLC
-beauty
-
-// beer : 2014-01-09 Registry Services, LLC
-beer
-
-// bentley : 2014-12-18 Bentley Motors Limited
-bentley
-
-// berlin : 2013-10-31 dotBERLIN GmbH & Co. KG
-berlin
-
-// best : 2013-12-19 BestTLD Pty Ltd
-best
-
-// bestbuy : 2015-07-31 BBY Solutions, Inc.
-bestbuy
-
-// bet : 2015-05-07 Afilias Limited
-bet
-
-// bharti : 2014-01-09 Bharti Enterprises (Holding) Private Limited
-bharti
-
-// bible : 2014-06-19 American Bible Society
-bible
-
-// bid : 2013-12-19 dot Bid Limited
-bid
-
-// bike : 2013-08-27 Binky Moon, LLC
-bike
-
-// bing : 2014-12-18 Microsoft Corporation
-bing
-
-// bingo : 2014-12-04 Binky Moon, LLC
-bingo
-
-// bio : 2014-03-06 Afilias Limited
-bio
-
-// black : 2014-01-16 Afilias Limited
-black
-
-// blackfriday : 2014-01-16 UNR Corp.
-blackfriday
-
-// blockbuster : 2015-07-30 Dish DBS Corporation
-blockbuster
-
-// blog : 2015-05-14 Knock Knock WHOIS There, LLC
-blog
-
-// bloomberg : 2014-07-17 Bloomberg IP Holdings LLC
-bloomberg
-
-// blue : 2013-11-07 Afilias Limited
-blue
-
-// bms : 2014-10-30 Bristol-Myers Squibb Company
-bms
-
-// bmw : 2014-01-09 Bayerische Motoren Werke Aktiengesellschaft
-bmw
-
-// bnpparibas : 2014-05-29 BNP Paribas
-bnpparibas
-
-// boats : 2014-12-04 XYZ.COM LLC
-boats
-
-// boehringer : 2015-07-09 Boehringer Ingelheim International GmbH
-boehringer
-
-// bofa : 2015-07-31 Bank of America Corporation
-bofa
-
-// bom : 2014-10-16 Núcleo de Informação e Coordenação do Ponto BR - NIC.br
-bom
-
-// bond : 2014-06-05 ShortDot SA
-bond
-
-// boo : 2014-01-30 Charleston Road Registry Inc.
-boo
-
-// book : 2015-08-27 Amazon Registry Services, Inc.
-book
-
-// booking : 2015-07-16 Booking.com B.V.
-booking
-
-// bosch : 2015-06-18 Robert Bosch GMBH
-bosch
-
-// bostik : 2015-05-28 Bostik SA
-bostik
-
-// boston : 2015-12-10 Registry Services, LLC
-boston
-
-// bot : 2014-12-18 Amazon Registry Services, Inc.
-bot
-
-// boutique : 2013-11-14 Binky Moon, LLC
-boutique
-
-// box : 2015-11-12 Intercap Registry Inc.
-box
-
-// bradesco : 2014-12-18 Banco Bradesco S.A.
-bradesco
-
-// bridgestone : 2014-12-18 Bridgestone Corporation
-bridgestone
-
-// broadway : 2014-12-22 Celebrate Broadway, Inc.
-broadway
-
-// broker : 2014-12-11 Dog Beach, LLC
-broker
-
-// brother : 2015-01-29 Brother Industries, Ltd.
-brother
-
-// brussels : 2014-02-06 DNS.be vzw
-brussels
-
-// bugatti : 2015-07-23 Bugatti International SA
-bugatti
-
-// build : 2013-11-07 Plan Bee LLC
-build
-
-// builders : 2013-11-07 Binky Moon, LLC
-builders
-
-// business : 2013-11-07 Binky Moon, LLC
-business
-
-// buy : 2014-12-18 Amazon Registry Services, Inc.
-buy
-
-// buzz : 2013-10-02 DOTSTRATEGY CO.
-buzz
-
-// bzh : 2014-02-27 Association www.bzh
-bzh
-
-// cab : 2013-10-24 Binky Moon, LLC
-cab
-
-// cafe : 2015-02-11 Binky Moon, LLC
-cafe
-
-// cal : 2014-07-24 Charleston Road Registry Inc.
-cal
-
-// call : 2014-12-18 Amazon Registry Services, Inc.
-call
-
-// calvinklein : 2015-07-30 PVH gTLD Holdings LLC
-calvinklein
-
-// cam : 2016-04-21 Cam Connecting SARL
-cam
-
-// camera : 2013-08-27 Binky Moon, LLC
-camera
-
-// camp : 2013-11-07 Binky Moon, LLC
-camp
-
-// cancerresearch : 2014-05-15 Australian Cancer Research Foundation
-cancerresearch
-
-// canon : 2014-09-12 Canon Inc.
-canon
-
-// capetown : 2014-03-24 ZA Central Registry NPC trading as ZA Central Registry
-capetown
-
-// capital : 2014-03-06 Binky Moon, LLC
-capital
-
-// capitalone : 2015-08-06 Capital One Financial Corporation
-capitalone
-
-// car : 2015-01-22 XYZ.COM LLC
-car
-
-// caravan : 2013-12-12 Caravan International, Inc.
-caravan
-
-// cards : 2013-12-05 Binky Moon, LLC
-cards
-
-// care : 2014-03-06 Binky Moon, LLC
-care
-
-// career : 2013-10-09 dotCareer LLC
-career
-
-// careers : 2013-10-02 Binky Moon, LLC
-careers
-
-// cars : 2014-11-13 XYZ.COM LLC
-cars
-
-// casa : 2013-11-21 Registry Services, LLC
-casa
-
-// case : 2015-09-03 Helium TLDs Ltd
-case
-
-// cash : 2014-03-06 Binky Moon, LLC
-cash
-
-// casino : 2014-12-18 Binky Moon, LLC
-casino
-
-// catering : 2013-12-05 Binky Moon, LLC
-catering
-
-// catholic : 2015-10-21 Pontificium Consilium de Comunicationibus Socialibus (PCCS) (Pontifical Council for Social Communication)
-catholic
-
-// cba : 2014-06-26 COMMONWEALTH BANK OF AUSTRALIA
-cba
-
-// cbn : 2014-08-22 The Christian Broadcasting Network, Inc.
-cbn
-
-// cbre : 2015-07-02 CBRE, Inc.
-cbre
-
-// cbs : 2015-08-06 CBS Domains Inc.
-cbs
-
-// center : 2013-11-07 Binky Moon, LLC
-center
-
-// ceo : 2013-11-07 CEOTLD Pty Ltd
-ceo
-
-// cern : 2014-06-05 European Organization for Nuclear Research ("CERN")
-cern
-
-// cfa : 2014-08-28 CFA Institute
-cfa
-
-// cfd : 2014-12-11 ShortDot SA
-cfd
-
-// chanel : 2015-04-09 Chanel International B.V.
-chanel
-
-// channel : 2014-05-08 Charleston Road Registry Inc.
-channel
-
-// charity : 2018-04-11 Binky Moon, LLC
-charity
-
-// chase : 2015-04-30 JPMorgan Chase Bank, National Association
-chase
-
-// chat : 2014-12-04 Binky Moon, LLC
-chat
-
-// cheap : 2013-11-14 Binky Moon, LLC
-cheap
-
-// chintai : 2015-06-11 CHINTAI Corporation
-chintai
-
-// christmas : 2013-11-21 XYZ.COM LLC
-christmas
-
-// chrome : 2014-07-24 Charleston Road Registry Inc.
-chrome
-
-// church : 2014-02-06 Binky Moon, LLC
-church
-
-// cipriani : 2015-02-19 Hotel Cipriani Srl
-cipriani
-
-// circle : 2014-12-18 Amazon Registry Services, Inc.
-circle
-
-// cisco : 2014-12-22 Cisco Technology, Inc.
-cisco
-
-// citadel : 2015-07-23 Citadel Domain LLC
-citadel
-
-// citi : 2015-07-30 Citigroup Inc.
-citi
-
-// citic : 2014-01-09 CITIC Group Corporation
-citic
-
-// city : 2014-05-29 Binky Moon, LLC
-city
-
-// cityeats : 2014-12-11 Lifestyle Domain Holdings, Inc.
-cityeats
-
-// claims : 2014-03-20 Binky Moon, LLC
-claims
-
-// cleaning : 2013-12-05 Binky Moon, LLC
-cleaning
-
-// click : 2014-06-05 UNR Corp.
-click
-
-// clinic : 2014-03-20 Binky Moon, LLC
-clinic
-
-// clinique : 2015-10-01 The Estée Lauder Companies Inc.
-clinique
-
-// clothing : 2013-08-27 Binky Moon, LLC
-clothing
-
-// cloud : 2015-04-16 Aruba PEC S.p.A.
-cloud
-
-// club : 2013-11-08 Registry Services, LLC
-club
-
-// clubmed : 2015-06-25 Club Méditerranée S.A.
-clubmed
-
-// coach : 2014-10-09 Binky Moon, LLC
-coach
-
-// codes : 2013-10-31 Binky Moon, LLC
-codes
-
-// coffee : 2013-10-17 Binky Moon, LLC
-coffee
-
-// college : 2014-01-16 XYZ.COM LLC
-college
-
-// cologne : 2014-02-05 dotKoeln GmbH
-cologne
-
-// comcast : 2015-07-23 Comcast IP Holdings I, LLC
-comcast
-
-// commbank : 2014-06-26 COMMONWEALTH BANK OF AUSTRALIA
-commbank
-
-// community : 2013-12-05 Binky Moon, LLC
-community
-
-// company : 2013-11-07 Binky Moon, LLC
-company
-
-// compare : 2015-10-08 Registry Services, LLC
-compare
-
-// computer : 2013-10-24 Binky Moon, LLC
-computer
-
-// comsec : 2015-01-08 VeriSign, Inc.
-comsec
-
-// condos : 2013-12-05 Binky Moon, LLC
-condos
-
-// construction : 2013-09-16 Binky Moon, LLC
-construction
-
-// consulting : 2013-12-05 Dog Beach, LLC
-consulting
-
-// contact : 2015-01-08 Dog Beach, LLC
-contact
-
-// contractors : 2013-09-10 Binky Moon, LLC
-contractors
-
-// cooking : 2013-11-21 Registry Services, LLC
-cooking
-
-// cookingchannel : 2015-07-02 Lifestyle Domain Holdings, Inc.
-cookingchannel
-
-// cool : 2013-11-14 Binky Moon, LLC
-cool
-
-// corsica : 2014-09-25 Collectivité de Corse
-corsica
-
-// country : 2013-12-19 DotCountry LLC
-country
-
-// coupon : 2015-02-26 Amazon Registry Services, Inc.
-coupon
-
-// coupons : 2015-03-26 Binky Moon, LLC
-coupons
-
-// courses : 2014-12-04 OPEN UNIVERSITIES AUSTRALIA PTY LTD
-courses
-
-// cpa : 2019-06-10 American Institute of Certified Public Accountants
-cpa
-
-// credit : 2014-03-20 Binky Moon, LLC
-credit
-
-// creditcard : 2014-03-20 Binky Moon, LLC
-creditcard
-
-// creditunion : 2015-01-22 DotCooperation LLC
-creditunion
-
-// cricket : 2014-10-09 dot Cricket Limited
-cricket
-
-// crown : 2014-10-24 Crown Equipment Corporation
-crown
-
-// crs : 2014-04-03 Federated Co-operatives Limited
-crs
-
-// cruise : 2015-12-10 Viking River Cruises (Bermuda) Ltd.
-cruise
-
-// cruises : 2013-12-05 Binky Moon, LLC
-cruises
-
-// cuisinella : 2014-04-03 SCHMIDT GROUPE S.A.S.
-cuisinella
-
-// cymru : 2014-05-08 Nominet UK
-cymru
-
-// cyou : 2015-01-22 ShortDot SA
-cyou
-
-// dabur : 2014-02-06 Dabur India Limited
-dabur
-
-// dad : 2014-01-23 Charleston Road Registry Inc.
-dad
-
-// dance : 2013-10-24 Dog Beach, LLC
-dance
-
-// data : 2016-06-02 Dish DBS Corporation
-data
-
-// date : 2014-11-20 dot Date Limited
-date
-
-// dating : 2013-12-05 Binky Moon, LLC
-dating
-
-// datsun : 2014-03-27 NISSAN MOTOR CO., LTD.
-datsun
-
-// day : 2014-01-30 Charleston Road Registry Inc.
-day
-
-// dclk : 2014-11-20 Charleston Road Registry Inc.
-dclk
-
-// dds : 2015-05-07 Registry Services, LLC
-dds
-
-// deal : 2015-06-25 Amazon Registry Services, Inc.
-deal
-
-// dealer : 2014-12-22 Intercap Registry Inc.
-dealer
-
-// deals : 2014-05-22 Binky Moon, LLC
-deals
-
-// degree : 2014-03-06 Dog Beach, LLC
-degree
-
-// delivery : 2014-09-11 Binky Moon, LLC
-delivery
-
-// dell : 2014-10-24 Dell Inc.
-dell
-
-// deloitte : 2015-07-31 Deloitte Touche Tohmatsu
-deloitte
-
-// delta : 2015-02-19 Delta Air Lines, Inc.
-delta
-
-// democrat : 2013-10-24 Dog Beach, LLC
-democrat
-
-// dental : 2014-03-20 Binky Moon, LLC
-dental
-
-// dentist : 2014-03-20 Dog Beach, LLC
-dentist
-
-// desi : 2013-11-14 Desi Networks LLC
-desi
-
-// design : 2014-11-07 Registry Services, LLC
-design
-
-// dev : 2014-10-16 Charleston Road Registry Inc.
-dev
-
-// dhl : 2015-07-23 Deutsche Post AG
-dhl
-
-// diamonds : 2013-09-22 Binky Moon, LLC
-diamonds
-
-// diet : 2014-06-26 XYZ.COM LLC
-diet
-
-// digital : 2014-03-06 Binky Moon, LLC
-digital
-
-// direct : 2014-04-10 Binky Moon, LLC
-direct
-
-// directory : 2013-09-20 Binky Moon, LLC
-directory
-
-// discount : 2014-03-06 Binky Moon, LLC
-discount
-
-// discover : 2015-07-23 Discover Financial Services
-discover
-
-// dish : 2015-07-30 Dish DBS Corporation
-dish
-
-// diy : 2015-11-05 Lifestyle Domain Holdings, Inc.
-diy
-
-// dnp : 2013-12-13 Dai Nippon Printing Co., Ltd.
-dnp
-
-// docs : 2014-10-16 Charleston Road Registry Inc.
-docs
-
-// doctor : 2016-06-02 Binky Moon, LLC
-doctor
-
-// dog : 2014-12-04 Binky Moon, LLC
-dog
-
-// domains : 2013-10-17 Binky Moon, LLC
-domains
-
-// dot : 2015-05-21 Dish DBS Corporation
-dot
-
-// download : 2014-11-20 dot Support Limited
-download
-
-// drive : 2015-03-05 Charleston Road Registry Inc.
-drive
-
-// dtv : 2015-06-04 Dish DBS Corporation
-dtv
-
-// dubai : 2015-01-01 Dubai Smart Government Department
-dubai
-
-// dunlop : 2015-07-02 The Goodyear Tire & Rubber Company
-dunlop
-
-// dupont : 2015-06-25 DuPont Specialty Products USA, LLC
-dupont
-
-// durban : 2014-03-24 ZA Central Registry NPC trading as ZA Central Registry
-durban
-
-// dvag : 2014-06-23 Deutsche Vermögensberatung Aktiengesellschaft DVAG
-dvag
-
-// dvr : 2016-05-26 DISH Technologies L.L.C.
-dvr
-
-// earth : 2014-12-04 Interlink Co., Ltd.
-earth
-
-// eat : 2014-01-23 Charleston Road Registry Inc.
-eat
-
-// eco : 2016-07-08 Big Room Inc.
-eco
-
-// edeka : 2014-12-18 EDEKA Verband kaufmännischer Genossenschaften e.V.
-edeka
-
-// education : 2013-11-07 Binky Moon, LLC
-education
-
-// email : 2013-10-31 Binky Moon, LLC
-email
-
-// emerck : 2014-04-03 Merck KGaA
-emerck
-
-// energy : 2014-09-11 Binky Moon, LLC
-energy
-
-// engineer : 2014-03-06 Dog Beach, LLC
-engineer
-
-// engineering : 2014-03-06 Binky Moon, LLC
-engineering
-
-// enterprises : 2013-09-20 Binky Moon, LLC
-enterprises
-
-// epson : 2014-12-04 Seiko Epson Corporation
-epson
-
-// equipment : 2013-08-27 Binky Moon, LLC
-equipment
-
-// ericsson : 2015-07-09 Telefonaktiebolaget L M Ericsson
-ericsson
-
-// erni : 2014-04-03 ERNI Group Holding AG
-erni
-
-// esq : 2014-05-08 Charleston Road Registry Inc.
-esq
-
-// estate : 2013-08-27 Binky Moon, LLC
-estate
-
-// etisalat : 2015-09-03 Emirates Telecommunications Corporation (trading as Etisalat)
-etisalat
-
-// eurovision : 2014-04-24 European Broadcasting Union (EBU)
-eurovision
-
-// eus : 2013-12-12 Puntueus Fundazioa
-eus
-
-// events : 2013-12-05 Binky Moon, LLC
-events
-
-// exchange : 2014-03-06 Binky Moon, LLC
-exchange
-
-// expert : 2013-11-21 Binky Moon, LLC
-expert
-
-// exposed : 2013-12-05 Binky Moon, LLC
-exposed
-
-// express : 2015-02-11 Binky Moon, LLC
-express
-
-// extraspace : 2015-05-14 Extra Space Storage LLC
-extraspace
-
-// fage : 2014-12-18 Fage International S.A.
-fage
-
-// fail : 2014-03-06 Binky Moon, LLC
-fail
-
-// fairwinds : 2014-11-13 FairWinds Partners, LLC
-fairwinds
-
-// faith : 2014-11-20 dot Faith Limited
-faith
-
-// family : 2015-04-02 Dog Beach, LLC
-family
-
-// fan : 2014-03-06 Dog Beach, LLC
-fan
-
-// fans : 2014-11-07 ZDNS International Limited
-fans
-
-// farm : 2013-11-07 Binky Moon, LLC
-farm
-
-// farmers : 2015-07-09 Farmers Insurance Exchange
-farmers
-
-// fashion : 2014-07-03 Registry Services, LLC
-fashion
-
-// fast : 2014-12-18 Amazon Registry Services, Inc.
-fast
-
-// fedex : 2015-08-06 Federal Express Corporation
-fedex
-
-// feedback : 2013-12-19 Top Level Spectrum, Inc.
-feedback
-
-// ferrari : 2015-07-31 Fiat Chrysler Automobiles N.V.
-ferrari
-
-// ferrero : 2014-12-18 Ferrero Trading Lux S.A.
-ferrero
-
-// fiat : 2015-07-31 Fiat Chrysler Automobiles N.V.
-fiat
-
-// fidelity : 2015-07-30 Fidelity Brokerage Services LLC
-fidelity
-
-// fido : 2015-08-06 Rogers Communications Canada Inc.
-fido
-
-// film : 2015-01-08 Motion Picture Domain Registry Pty Ltd
-film
-
-// final : 2014-10-16 Núcleo de Informação e Coordenação do Ponto BR - NIC.br
-final
-
-// finance : 2014-03-20 Binky Moon, LLC
-finance
-
-// financial : 2014-03-06 Binky Moon, LLC
-financial
-
-// fire : 2015-06-25 Amazon Registry Services, Inc.
-fire
-
-// firestone : 2014-12-18 Bridgestone Licensing Services, Inc
-firestone
-
-// firmdale : 2014-03-27 Firmdale Holdings Limited
-firmdale
-
-// fish : 2013-12-12 Binky Moon, LLC
-fish
-
-// fishing : 2013-11-21 Registry Services, LLC
-fishing
-
-// fit : 2014-11-07 Registry Services, LLC
-fit
-
-// fitness : 2014-03-06 Binky Moon, LLC
-fitness
-
-// flickr : 2015-04-02 Flickr, Inc.
-flickr
-
-// flights : 2013-12-05 Binky Moon, LLC
-flights
-
-// flir : 2015-07-23 FLIR Systems, Inc.
-flir
-
-// florist : 2013-11-07 Binky Moon, LLC
-florist
-
-// flowers : 2014-10-09 XYZ.COM LLC
-flowers
-
-// fly : 2014-05-08 Charleston Road Registry Inc.
-fly
-
-// foo : 2014-01-23 Charleston Road Registry Inc.
-foo
-
-// food : 2016-04-21 Lifestyle Domain Holdings, Inc.
-food
-
-// foodnetwork : 2015-07-02 Lifestyle Domain Holdings, Inc.
-foodnetwork
-
-// football : 2014-12-18 Binky Moon, LLC
-football
-
-// ford : 2014-11-13 Ford Motor Company
-ford
-
-// forex : 2014-12-11 Dog Beach, LLC
-forex
-
-// forsale : 2014-05-22 Dog Beach, LLC
-forsale
-
-// forum : 2015-04-02 Fegistry, LLC
-forum
-
-// foundation : 2013-12-05 Binky Moon, LLC
-foundation
-
-// fox : 2015-09-11 FOX Registry, LLC
-fox
-
-// free : 2015-12-10 Amazon Registry Services, Inc.
-free
-
-// fresenius : 2015-07-30 Fresenius Immobilien-Verwaltungs-GmbH
-fresenius
-
-// frl : 2014-05-15 FRLregistry B.V.
-frl
-
-// frogans : 2013-12-19 OP3FT
-frogans
-
-// frontdoor : 2015-07-02 Lifestyle Domain Holdings, Inc.
-frontdoor
-
-// frontier : 2015-02-05 Frontier Communications Corporation
-frontier
-
-// ftr : 2015-07-16 Frontier Communications Corporation
-ftr
-
-// fujitsu : 2015-07-30 Fujitsu Limited
-fujitsu
-
-// fun : 2016-01-14 Radix FZC
-fun
-
-// fund : 2014-03-20 Binky Moon, LLC
-fund
-
-// furniture : 2014-03-20 Binky Moon, LLC
-furniture
-
-// futbol : 2013-09-20 Dog Beach, LLC
-futbol
-
-// fyi : 2015-04-02 Binky Moon, LLC
-fyi
-
-// gal : 2013-11-07 Asociación puntoGAL
-gal
-
-// gallery : 2013-09-13 Binky Moon, LLC
-gallery
-
-// gallo : 2015-06-11 Gallo Vineyards, Inc.
-gallo
-
-// gallup : 2015-02-19 Gallup, Inc.
-gallup
-
-// game : 2015-05-28 XYZ.COM LLC
-game
-
-// games : 2015-05-28 Dog Beach, LLC
-games
-
-// gap : 2015-07-31 The Gap, Inc.
-gap
-
-// garden : 2014-06-26 Registry Services, LLC
-garden
-
-// gay : 2019-05-23 Top Level Design, LLC
-gay
-
-// gbiz : 2014-07-17 Charleston Road Registry Inc.
-gbiz
-
-// gdn : 2014-07-31 Joint Stock Company "Navigation-information systems"
-gdn
-
-// gea : 2014-12-04 GEA Group Aktiengesellschaft
-gea
-
-// gent : 2014-01-23 COMBELL NV
-gent
-
-// genting : 2015-03-12 Resorts World Inc Pte. Ltd.
-genting
-
-// george : 2015-07-31 Wal-Mart Stores, Inc.
-george
-
-// ggee : 2014-01-09 GMO Internet, Inc.
-ggee
-
-// gift : 2013-10-17 DotGift, LLC
-gift
-
-// gifts : 2014-07-03 Binky Moon, LLC
-gifts
-
-// gives : 2014-03-06 Dog Beach, LLC
-gives
-
-// giving : 2014-11-13 Giving Limited
-giving
-
-// glass : 2013-11-07 Binky Moon, LLC
-glass
-
-// gle : 2014-07-24 Charleston Road Registry Inc.
-gle
-
-// global : 2014-04-17 Dot Global Domain Registry Limited
-global
-
-// globo : 2013-12-19 Globo Comunicação e Participações S.A
-globo
-
-// gmail : 2014-05-01 Charleston Road Registry Inc.
-gmail
-
-// gmbh : 2016-01-29 Binky Moon, LLC
-gmbh
-
-// gmo : 2014-01-09 GMO Internet, Inc.
-gmo
-
-// gmx : 2014-04-24 1&1 Mail & Media GmbH
-gmx
-
-// godaddy : 2015-07-23 Go Daddy East, LLC
-godaddy
-
-// gold : 2015-01-22 Binky Moon, LLC
-gold
-
-// goldpoint : 2014-11-20 YODOBASHI CAMERA CO.,LTD.
-goldpoint
-
-// golf : 2014-12-18 Binky Moon, LLC
-golf
-
-// goo : 2014-12-18 NTT Resonant Inc.
-goo
-
-// goodyear : 2015-07-02 The Goodyear Tire & Rubber Company
-goodyear
-
-// goog : 2014-11-20 Charleston Road Registry Inc.
-goog
-
-// google : 2014-07-24 Charleston Road Registry Inc.
-google
-
-// gop : 2014-01-16 Republican State Leadership Committee, Inc.
-gop
-
-// got : 2014-12-18 Amazon Registry Services, Inc.
-got
-
-// grainger : 2015-05-07 Grainger Registry Services, LLC
-grainger
-
-// graphics : 2013-09-13 Binky Moon, LLC
-graphics
-
-// gratis : 2014-03-20 Binky Moon, LLC
-gratis
-
-// green : 2014-05-08 Afilias Limited
-green
-
-// gripe : 2014-03-06 Binky Moon, LLC
-gripe
-
-// grocery : 2016-06-16 Wal-Mart Stores, Inc.
-grocery
-
-// group : 2014-08-15 Binky Moon, LLC
-group
-
-// guardian : 2015-07-30 The Guardian Life Insurance Company of America
-guardian
-
-// gucci : 2014-11-13 Guccio Gucci S.p.a.
-gucci
-
-// guge : 2014-08-28 Charleston Road Registry Inc.
-guge
-
-// guide : 2013-09-13 Binky Moon, LLC
-guide
-
-// guitars : 2013-11-14 XYZ.COM LLC
-guitars
-
-// guru : 2013-08-27 Binky Moon, LLC
-guru
-
-// hair : 2015-12-03 XYZ.COM LLC
-hair
-
-// hamburg : 2014-02-20 Hamburg Top-Level-Domain GmbH
-hamburg
-
-// hangout : 2014-11-13 Charleston Road Registry Inc.
-hangout
-
-// haus : 2013-12-05 Dog Beach, LLC
-haus
-
-// hbo : 2015-07-30 HBO Registry Services, Inc.
-hbo
-
-// hdfc : 2015-07-30 HOUSING DEVELOPMENT FINANCE CORPORATION LIMITED
-hdfc
-
-// hdfcbank : 2015-02-12 HDFC Bank Limited
-hdfcbank
-
-// health : 2015-02-11 DotHealth, LLC
-health
-
-// healthcare : 2014-06-12 Binky Moon, LLC
-healthcare
-
-// help : 2014-06-26 UNR Corp.
-help
-
-// helsinki : 2015-02-05 City of Helsinki
-helsinki
-
-// here : 2014-02-06 Charleston Road Registry Inc.
-here
-
-// hermes : 2014-07-10 HERMES INTERNATIONAL
-hermes
-
-// hgtv : 2015-07-02 Lifestyle Domain Holdings, Inc.
-hgtv
-
-// hiphop : 2014-03-06 Dot Hip Hop, LLC
-hiphop
-
-// hisamitsu : 2015-07-16 Hisamitsu Pharmaceutical Co.,Inc.
-hisamitsu
-
-// hitachi : 2014-10-31 Hitachi, Ltd.
-hitachi
-
-// hiv : 2014-03-13 UNR Corp.
-hiv
-
-// hkt : 2015-05-14 PCCW-HKT DataCom Services Limited
-hkt
-
-// hockey : 2015-03-19 Binky Moon, LLC
-hockey
-
-// holdings : 2013-08-27 Binky Moon, LLC
-holdings
-
-// holiday : 2013-11-07 Binky Moon, LLC
-holiday
-
-// homedepot : 2015-04-02 Home Depot Product Authority, LLC
-homedepot
-
-// homegoods : 2015-07-16 The TJX Companies, Inc.
-homegoods
-
-// homes : 2014-01-09 XYZ.COM LLC
-homes
-
-// homesense : 2015-07-16 The TJX Companies, Inc.
-homesense
-
-// honda : 2014-12-18 Honda Motor Co., Ltd.
-honda
-
-// horse : 2013-11-21 Registry Services, LLC
-horse
-
-// hospital : 2016-10-20 Binky Moon, LLC
-hospital
-
-// host : 2014-04-17 Radix FZC
-host
-
-// hosting : 2014-05-29 XYZ.COM LLC
-hosting
-
-// hot : 2015-08-27 Amazon Registry Services, Inc.
-hot
-
-// hoteles : 2015-03-05 Travel Reservations SRL
-hoteles
-
-// hotels : 2016-04-07 Booking.com B.V.
-hotels
-
-// hotmail : 2014-12-18 Microsoft Corporation
-hotmail
-
-// house : 2013-11-07 Binky Moon, LLC
-house
-
-// how : 2014-01-23 Charleston Road Registry Inc.
-how
-
-// hsbc : 2014-10-24 HSBC Global Services (UK) Limited
-hsbc
-
-// hughes : 2015-07-30 Hughes Satellite Systems Corporation
-hughes
-
-// hyatt : 2015-07-30 Hyatt GTLD, L.L.C.
-hyatt
-
-// hyundai : 2015-07-09 Hyundai Motor Company
-hyundai
-
-// ibm : 2014-07-31 International Business Machines Corporation
-ibm
-
-// icbc : 2015-02-19 Industrial and Commercial Bank of China Limited
-icbc
-
-// ice : 2014-10-30 IntercontinentalExchange, Inc.
-ice
-
-// icu : 2015-01-08 ShortDot SA
-icu
-
-// ieee : 2015-07-23 IEEE Global LLC
-ieee
-
-// ifm : 2014-01-30 ifm electronic gmbh
-ifm
-
-// ikano : 2015-07-09 Ikano S.A.
-ikano
-
-// imamat : 2015-08-06 Fondation Aga Khan (Aga Khan Foundation)
-imamat
-
-// imdb : 2015-06-25 Amazon Registry Services, Inc.
-imdb
-
-// immo : 2014-07-10 Binky Moon, LLC
-immo
-
-// immobilien : 2013-11-07 Dog Beach, LLC
-immobilien
-
-// inc : 2018-03-10 Intercap Registry Inc.
-inc
-
-// industries : 2013-12-05 Binky Moon, LLC
-industries
-
-// infiniti : 2014-03-27 NISSAN MOTOR CO., LTD.
-infiniti
-
-// ing : 2014-01-23 Charleston Road Registry Inc.
-ing
-
-// ink : 2013-12-05 Top Level Design, LLC
-ink
-
-// institute : 2013-11-07 Binky Moon, LLC
-institute
-
-// insurance : 2015-02-19 fTLD Registry Services LLC
-insurance
-
-// insure : 2014-03-20 Binky Moon, LLC
-insure
-
-// international : 2013-11-07 Binky Moon, LLC
-international
-
-// intuit : 2015-07-30 Intuit Administrative Services, Inc.
-intuit
-
-// investments : 2014-03-20 Binky Moon, LLC
-investments
-
-// ipiranga : 2014-08-28 Ipiranga Produtos de Petroleo S.A.
-ipiranga
-
-// irish : 2014-08-07 Binky Moon, LLC
-irish
-
-// ismaili : 2015-08-06 Fondation Aga Khan (Aga Khan Foundation)
-ismaili
-
-// ist : 2014-08-28 Istanbul Metropolitan Municipality
-ist
-
-// istanbul : 2014-08-28 Istanbul Metropolitan Municipality
-istanbul
-
-// itau : 2014-10-02 Itau Unibanco Holding S.A.
-itau
-
-// itv : 2015-07-09 ITV Services Limited
-itv
-
-// jaguar : 2014-11-13 Jaguar Land Rover Ltd
-jaguar
-
-// java : 2014-06-19 Oracle Corporation
-java
-
-// jcb : 2014-11-20 JCB Co., Ltd.
-jcb
-
-// jeep : 2015-07-30 FCA US LLC.
-jeep
-
-// jetzt : 2014-01-09 Binky Moon, LLC
-jetzt
-
-// jewelry : 2015-03-05 Binky Moon, LLC
-jewelry
-
-// jio : 2015-04-02 Reliance Industries Limited
-jio
-
-// jll : 2015-04-02 Jones Lang LaSalle Incorporated
-jll
-
-// jmp : 2015-03-26 Matrix IP LLC
-jmp
-
-// jnj : 2015-06-18 Johnson & Johnson Services, Inc.
-jnj
-
-// joburg : 2014-03-24 ZA Central Registry NPC trading as ZA Central Registry
-joburg
-
-// jot : 2014-12-18 Amazon Registry Services, Inc.
-jot
-
-// joy : 2014-12-18 Amazon Registry Services, Inc.
-joy
-
-// jpmorgan : 2015-04-30 JPMorgan Chase Bank, National Association
-jpmorgan
-
-// jprs : 2014-09-18 Japan Registry Services Co., Ltd.
-jprs
-
-// juegos : 2014-03-20 UNR Corp.
-juegos
-
-// juniper : 2015-07-30 JUNIPER NETWORKS, INC.
-juniper
-
-// kaufen : 2013-11-07 Dog Beach, LLC
-kaufen
-
-// kddi : 2014-09-12 KDDI CORPORATION
-kddi
-
-// kerryhotels : 2015-04-30 Kerry Trading Co. Limited
-kerryhotels
-
-// kerrylogistics : 2015-04-09 Kerry Trading Co. Limited
-kerrylogistics
-
-// kerryproperties : 2015-04-09 Kerry Trading Co. Limited
-kerryproperties
-
-// kfh : 2014-12-04 Kuwait Finance House
-kfh
-
-// kia : 2015-07-09 KIA MOTORS CORPORATION
-kia
-
-// kids : 2021-08-13 DotKids Foundation Limited
-kids
-
-// kim : 2013-09-23 Afilias Limited
-kim
-
-// kinder : 2014-11-07 Ferrero Trading Lux S.A.
-kinder
-
-// kindle : 2015-06-25 Amazon Registry Services, Inc.
-kindle
-
-// kitchen : 2013-09-20 Binky Moon, LLC
-kitchen
-
-// kiwi : 2013-09-20 DOT KIWI LIMITED
-kiwi
-
-// koeln : 2014-01-09 dotKoeln GmbH
-koeln
-
-// komatsu : 2015-01-08 Komatsu Ltd.
-komatsu
-
-// kosher : 2015-08-20 Kosher Marketing Assets LLC
-kosher
-
-// kpmg : 2015-04-23 KPMG International Cooperative (KPMG International Genossenschaft)
-kpmg
-
-// kpn : 2015-01-08 Koninklijke KPN N.V.
-kpn
-
-// krd : 2013-12-05 KRG Department of Information Technology
-krd
-
-// kred : 2013-12-19 KredTLD Pty Ltd
-kred
-
-// kuokgroup : 2015-04-09 Kerry Trading Co. Limited
-kuokgroup
-
-// kyoto : 2014-11-07 Academic Institution: Kyoto Jyoho Gakuen
-kyoto
-
-// lacaixa : 2014-01-09 Fundación Bancaria Caixa d’Estalvis i Pensions de Barcelona, “la Caixa”
-lacaixa
-
-// lamborghini : 2015-06-04 Automobili Lamborghini S.p.A.
-lamborghini
-
-// lamer : 2015-10-01 The Estée Lauder Companies Inc.
-lamer
-
-// lancaster : 2015-02-12 LANCASTER
-lancaster
-
-// lancia : 2015-07-31 Fiat Chrysler Automobiles N.V.
-lancia
-
-// land : 2013-09-10 Binky Moon, LLC
-land
-
-// landrover : 2014-11-13 Jaguar Land Rover Ltd
-landrover
-
-// lanxess : 2015-07-30 LANXESS Corporation
-lanxess
-
-// lasalle : 2015-04-02 Jones Lang LaSalle Incorporated
-lasalle
-
-// lat : 2014-10-16 ECOM-LAC Federaciòn de Latinoamèrica y el Caribe para Internet y el Comercio Electrònico
-lat
-
-// latino : 2015-07-30 Dish DBS Corporation
-latino
-
-// latrobe : 2014-06-16 La Trobe University
-latrobe
-
-// law : 2015-01-22 Registry Services, LLC
-law
-
-// lawyer : 2014-03-20 Dog Beach, LLC
-lawyer
-
-// lds : 2014-03-20 IRI Domain Management, LLC
-lds
-
-// lease : 2014-03-06 Binky Moon, LLC
-lease
-
-// leclerc : 2014-08-07 A.C.D. LEC Association des Centres Distributeurs Edouard Leclerc
-leclerc
-
-// lefrak : 2015-07-16 LeFrak Organization, Inc.
-lefrak
-
-// legal : 2014-10-16 Binky Moon, LLC
-legal
-
-// lego : 2015-07-16 LEGO Juris A/S
-lego
-
-// lexus : 2015-04-23 TOYOTA MOTOR CORPORATION
-lexus
-
-// lgbt : 2014-05-08 Afilias Limited
-lgbt
-
-// lidl : 2014-09-18 Schwarz Domains und Services GmbH & Co. KG
-lidl
-
-// life : 2014-02-06 Binky Moon, LLC
-life
-
-// lifeinsurance : 2015-01-15 American Council of Life Insurers
-lifeinsurance
-
-// lifestyle : 2014-12-11 Lifestyle Domain Holdings, Inc.
-lifestyle
-
-// lighting : 2013-08-27 Binky Moon, LLC
-lighting
-
-// like : 2014-12-18 Amazon Registry Services, Inc.
-like
-
-// lilly : 2015-07-31 Eli Lilly and Company
-lilly
-
-// limited : 2014-03-06 Binky Moon, LLC
-limited
-
-// limo : 2013-10-17 Binky Moon, LLC
-limo
-
-// lincoln : 2014-11-13 Ford Motor Company
-lincoln
-
-// linde : 2014-12-04 Linde Aktiengesellschaft
-linde
-
-// link : 2013-11-14 UNR Corp.
-link
-
-// lipsy : 2015-06-25 Lipsy Ltd
-lipsy
-
-// live : 2014-12-04 Dog Beach, LLC
-live
-
-// living : 2015-07-30 Lifestyle Domain Holdings, Inc.
-living
-
-// llc : 2017-12-14 Afilias Limited
-llc
-
-// llp : 2019-08-26 UNR Corp.
-llp
-
-// loan : 2014-11-20 dot Loan Limited
-loan
-
-// loans : 2014-03-20 Binky Moon, LLC
-loans
-
-// locker : 2015-06-04 Dish DBS Corporation
-locker
-
-// locus : 2015-06-25 Locus Analytics LLC
-locus
-
-// loft : 2015-07-30 Annco, Inc.
-loft
-
-// lol : 2015-01-30 XYZ.COM LLC
-lol
-
-// london : 2013-11-14 Dot London Domains Limited
-london
-
-// lotte : 2014-11-07 Lotte Holdings Co., Ltd.
-lotte
-
-// lotto : 2014-04-10 Afilias Limited
-lotto
-
-// love : 2014-12-22 Merchant Law Group LLP
-love
-
-// lpl : 2015-07-30 LPL Holdings, Inc.
-lpl
-
-// lplfinancial : 2015-07-30 LPL Holdings, Inc.
-lplfinancial
-
-// ltd : 2014-09-25 Binky Moon, LLC
-ltd
-
-// ltda : 2014-04-17 InterNetX, Corp
-ltda
-
-// lundbeck : 2015-08-06 H. Lundbeck A/S
-lundbeck
-
-// luxe : 2014-01-09 Registry Services, LLC
-luxe
-
-// luxury : 2013-10-17 Luxury Partners, LLC
-luxury
-
-// macys : 2015-07-31 Macys, Inc.
-macys
-
-// madrid : 2014-05-01 Comunidad de Madrid
-madrid
-
-// maif : 2014-10-02 Mutuelle Assurance Instituteur France (MAIF)
-maif
-
-// maison : 2013-12-05 Binky Moon, LLC
-maison
-
-// makeup : 2015-01-15 XYZ.COM LLC
-makeup
-
-// man : 2014-12-04 MAN SE
-man
-
-// management : 2013-11-07 Binky Moon, LLC
-management
-
-// mango : 2013-10-24 PUNTO FA S.L.
-mango
-
-// map : 2016-06-09 Charleston Road Registry Inc.
-map
-
-// market : 2014-03-06 Dog Beach, LLC
-market
-
-// marketing : 2013-11-07 Binky Moon, LLC
-marketing
-
-// markets : 2014-12-11 Dog Beach, LLC
-markets
-
-// marriott : 2014-10-09 Marriott Worldwide Corporation
-marriott
-
-// marshalls : 2015-07-16 The TJX Companies, Inc.
-marshalls
-
-// maserati : 2015-07-31 Fiat Chrysler Automobiles N.V.
-maserati
-
-// mattel : 2015-08-06 Mattel Sites, Inc.
-mattel
-
-// mba : 2015-04-02 Binky Moon, LLC
-mba
-
-// mckinsey : 2015-07-31 McKinsey Holdings, Inc.
-mckinsey
-
-// med : 2015-08-06 Medistry LLC
-med
-
-// media : 2014-03-06 Binky Moon, LLC
-media
-
-// meet : 2014-01-16 Charleston Road Registry Inc.
-meet
-
-// melbourne : 2014-05-29 The Crown in right of the State of Victoria, represented by its Department of State Development, Business and Innovation
-melbourne
-
-// meme : 2014-01-30 Charleston Road Registry Inc.
-meme
-
-// memorial : 2014-10-16 Dog Beach, LLC
-memorial
-
-// men : 2015-02-26 Exclusive Registry Limited
-men
-
-// menu : 2013-09-11 Dot Menu Registry, LLC
-menu
-
-// merckmsd : 2016-07-14 MSD Registry Holdings, Inc.
-merckmsd
-
-// miami : 2013-12-19 Registry Services, LLC
-miami
-
-// microsoft : 2014-12-18 Microsoft Corporation
-microsoft
-
-// mini : 2014-01-09 Bayerische Motoren Werke Aktiengesellschaft
-mini
-
-// mint : 2015-07-30 Intuit Administrative Services, Inc.
-mint
-
-// mit : 2015-07-02 Massachusetts Institute of Technology
-mit
-
-// mitsubishi : 2015-07-23 Mitsubishi Corporation
-mitsubishi
-
-// mlb : 2015-05-21 MLB Advanced Media DH, LLC
-mlb
-
-// mls : 2015-04-23 The Canadian Real Estate Association
-mls
-
-// mma : 2014-11-07 MMA IARD
-mma
-
-// mobile : 2016-06-02 Dish DBS Corporation
-mobile
-
-// moda : 2013-11-07 Dog Beach, LLC
-moda
-
-// moe : 2013-11-13 Interlink Co., Ltd.
-moe
-
-// moi : 2014-12-18 Amazon Registry Services, Inc.
-moi
-
-// mom : 2015-04-16 XYZ.COM LLC
-mom
-
-// monash : 2013-09-30 Monash University
-monash
-
-// money : 2014-10-16 Binky Moon, LLC
-money
-
-// monster : 2015-09-11 XYZ.COM LLC
-monster
-
-// mormon : 2013-12-05 IRI Domain Management, LLC
-mormon
-
-// mortgage : 2014-03-20 Dog Beach, LLC
-mortgage
-
-// moscow : 2013-12-19 Foundation for Assistance for Internet Technologies and Infrastructure Development (FAITID)
-moscow
-
-// moto : 2015-06-04 Motorola Trademark Holdings, LLC
-moto
-
-// motorcycles : 2014-01-09 XYZ.COM LLC
-motorcycles
-
-// mov : 2014-01-30 Charleston Road Registry Inc.
-mov
-
-// movie : 2015-02-05 Binky Moon, LLC
-movie
-
-// msd : 2015-07-23 MSD Registry Holdings, Inc.
-msd
-
-// mtn : 2014-12-04 MTN Dubai Limited
-mtn
-
-// mtr : 2015-03-12 MTR Corporation Limited
-mtr
-
-// music : 2021-05-04 DotMusic Limited
-music
-
-// mutual : 2015-04-02 Northwestern Mutual MU TLD Registry, LLC
-mutual
-
-// nab : 2015-08-20 National Australia Bank Limited
-nab
-
-// nagoya : 2013-10-24 GMO Registry, Inc.
-nagoya
-
-// natura : 2015-03-12 NATURA COSMÉTICOS S.A.
-natura
-
-// navy : 2014-03-06 Dog Beach, LLC
-navy
-
-// nba : 2015-07-31 NBA REGISTRY, LLC
-nba
-
-// nec : 2015-01-08 NEC Corporation
-nec
-
-// netbank : 2014-06-26 COMMONWEALTH BANK OF AUSTRALIA
-netbank
-
-// netflix : 2015-06-18 Netflix, Inc.
-netflix
-
-// network : 2013-11-14 Binky Moon, LLC
-network
-
-// neustar : 2013-12-05 NeuStar, Inc.
-neustar
-
-// new : 2014-01-30 Charleston Road Registry Inc.
-new
-
-// news : 2014-12-18 Dog Beach, LLC
-news
-
-// next : 2015-06-18 Next plc
-next
-
-// nextdirect : 2015-06-18 Next plc
-nextdirect
-
-// nexus : 2014-07-24 Charleston Road Registry Inc.
-nexus
-
-// nfl : 2015-07-23 NFL Reg Ops LLC
-nfl
-
-// ngo : 2014-03-06 Public Interest Registry
-ngo
-
-// nhk : 2014-02-13 Japan Broadcasting Corporation (NHK)
-nhk
-
-// nico : 2014-12-04 DWANGO Co., Ltd.
-nico
-
-// nike : 2015-07-23 NIKE, Inc.
-nike
-
-// nikon : 2015-05-21 NIKON CORPORATION
-nikon
-
-// ninja : 2013-11-07 Dog Beach, LLC
-ninja
-
-// nissan : 2014-03-27 NISSAN MOTOR CO., LTD.
-nissan
-
-// nissay : 2015-10-29 Nippon Life Insurance Company
-nissay
-
-// nokia : 2015-01-08 Nokia Corporation
-nokia
-
-// northwesternmutual : 2015-06-18 Northwestern Mutual Registry, LLC
-northwesternmutual
-
-// norton : 2014-12-04 NortonLifeLock Inc.
-norton
-
-// now : 2015-06-25 Amazon Registry Services, Inc.
-now
-
-// nowruz : 2014-09-04 Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
-nowruz
-
-// nowtv : 2015-05-14 Starbucks (HK) Limited
-nowtv
-
-// nra : 2014-05-22 NRA Holdings Company, INC.
-nra
-
-// nrw : 2013-11-21 Minds + Machines GmbH
-nrw
-
-// ntt : 2014-10-31 NIPPON TELEGRAPH AND TELEPHONE CORPORATION
-ntt
-
-// nyc : 2014-01-23 The City of New York by and through the New York City Department of Information Technology & Telecommunications
-nyc
-
-// obi : 2014-09-25 OBI Group Holding SE & Co. KGaA
-obi
-
-// observer : 2015-04-30 Dog Beach, LLC
-observer
-
-// office : 2015-03-12 Microsoft Corporation
-office
-
-// okinawa : 2013-12-05 BRregistry, Inc.
-okinawa
-
-// olayan : 2015-05-14 Crescent Holding GmbH
-olayan
-
-// olayangroup : 2015-05-14 Crescent Holding GmbH
-olayangroup
-
-// oldnavy : 2015-07-31 The Gap, Inc.
-oldnavy
-
-// ollo : 2015-06-04 Dish DBS Corporation
-ollo
-
-// omega : 2015-01-08 The Swatch Group Ltd
-omega
-
-// one : 2014-11-07 One.com A/S
-one
-
-// ong : 2014-03-06 Public Interest Registry
-ong
-
-// onl : 2013-09-16 iRegistry GmbH
-onl
-
-// online : 2015-01-15 Radix FZC
-online
-
-// ooo : 2014-01-09 INFIBEAM AVENUES LIMITED
-ooo
-
-// open : 2015-07-31 American Express Travel Related Services Company, Inc.
-open
-
-// oracle : 2014-06-19 Oracle Corporation
-oracle
-
-// orange : 2015-03-12 Orange Brand Services Limited
-orange
-
-// organic : 2014-03-27 Afilias Limited
-organic
-
-// origins : 2015-10-01 The Estée Lauder Companies Inc.
-origins
-
-// osaka : 2014-09-04 Osaka Registry Co., Ltd.
-osaka
-
-// otsuka : 2013-10-11 Otsuka Holdings Co., Ltd.
-otsuka
-
-// ott : 2015-06-04 Dish DBS Corporation
-ott
-
-// ovh : 2014-01-16 MédiaBC
-ovh
-
-// page : 2014-12-04 Charleston Road Registry Inc.
-page
-
-// panasonic : 2015-07-30 Panasonic Corporation
-panasonic
-
-// paris : 2014-01-30 City of Paris
-paris
-
-// pars : 2014-09-04 Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
-pars
-
-// partners : 2013-12-05 Binky Moon, LLC
-partners
-
-// parts : 2013-12-05 Binky Moon, LLC
-parts
-
-// party : 2014-09-11 Blue Sky Registry Limited
-party
-
-// passagens : 2015-03-05 Travel Reservations SRL
-passagens
-
-// pay : 2015-08-27 Amazon Registry Services, Inc.
-pay
-
-// pccw : 2015-05-14 PCCW Enterprises Limited
-pccw
-
-// pet : 2015-05-07 Afilias Limited
-pet
-
-// pfizer : 2015-09-11 Pfizer Inc.
-pfizer
-
-// pharmacy : 2014-06-19 National Association of Boards of Pharmacy
-pharmacy
-
-// phd : 2016-07-28 Charleston Road Registry Inc.
-phd
-
-// philips : 2014-11-07 Koninklijke Philips N.V.
-philips
-
-// phone : 2016-06-02 Dish DBS Corporation
-phone
-
-// photo : 2013-11-14 UNR Corp.
-photo
-
-// photography : 2013-09-20 Binky Moon, LLC
-photography
-
-// photos : 2013-10-17 Binky Moon, LLC
-photos
-
-// physio : 2014-05-01 PhysBiz Pty Ltd
-physio
-
-// pics : 2013-11-14 XYZ.COM LLC
-pics
-
-// pictet : 2014-06-26 Pictet Europe S.A.
-pictet
-
-// pictures : 2014-03-06 Binky Moon, LLC
-pictures
-
-// pid : 2015-01-08 Top Level Spectrum, Inc.
-pid
-
-// pin : 2014-12-18 Amazon Registry Services, Inc.
-pin
-
-// ping : 2015-06-11 Ping Registry Provider, Inc.
-ping
-
-// pink : 2013-10-01 Afilias Limited
-pink
-
-// pioneer : 2015-07-16 Pioneer Corporation
-pioneer
-
-// pizza : 2014-06-26 Binky Moon, LLC
-pizza
-
-// place : 2014-04-24 Binky Moon, LLC
-place
-
-// play : 2015-03-05 Charleston Road Registry Inc.
-play
-
-// playstation : 2015-07-02 Sony Interactive Entertainment Inc.
-playstation
-
-// plumbing : 2013-09-10 Binky Moon, LLC
-plumbing
-
-// plus : 2015-02-05 Binky Moon, LLC
-plus
-
-// pnc : 2015-07-02 PNC Domain Co., LLC
-pnc
-
-// pohl : 2014-06-23 Deutsche Vermögensberatung Aktiengesellschaft DVAG
-pohl
-
-// poker : 2014-07-03 Afilias Limited
-poker
-
-// politie : 2015-08-20 Politie Nederland
-politie
-
-// porn : 2014-10-16 ICM Registry PN LLC
-porn
-
-// pramerica : 2015-07-30 Prudential Financial, Inc.
-pramerica
-
-// praxi : 2013-12-05 Praxi S.p.A.
-praxi
-
-// press : 2014-04-03 Radix FZC
-press
-
-// prime : 2015-06-25 Amazon Registry Services, Inc.
-prime
-
-// prod : 2014-01-23 Charleston Road Registry Inc.
-prod
-
-// productions : 2013-12-05 Binky Moon, LLC
-productions
-
-// prof : 2014-07-24 Charleston Road Registry Inc.
-prof
-
-// progressive : 2015-07-23 Progressive Casualty Insurance Company
-progressive
-
-// promo : 2014-12-18 Afilias Limited
-promo
-
-// properties : 2013-12-05 Binky Moon, LLC
-properties
-
-// property : 2014-05-22 UNR Corp.
-property
-
-// protection : 2015-04-23 XYZ.COM LLC
-protection
-
-// pru : 2015-07-30 Prudential Financial, Inc.
-pru
-
-// prudential : 2015-07-30 Prudential Financial, Inc.
-prudential
-
-// pub : 2013-12-12 Dog Beach, LLC
-pub
-
-// pwc : 2015-10-29 PricewaterhouseCoopers LLP
-pwc
-
-// qpon : 2013-11-14 dotCOOL, Inc.
-qpon
-
-// quebec : 2013-12-19 PointQuébec Inc
-quebec
-
-// quest : 2015-03-26 XYZ.COM LLC
-quest
-
-// racing : 2014-12-04 Premier Registry Limited
-racing
-
-// radio : 2016-07-21 European Broadcasting Union (EBU)
-radio
-
-// read : 2014-12-18 Amazon Registry Services, Inc.
-read
-
-// realestate : 2015-09-11 dotRealEstate LLC
-realestate
-
-// realtor : 2014-05-29 Real Estate Domains LLC
-realtor
-
-// realty : 2015-03-19 Dog Beach, LLC
-realty
-
-// recipes : 2013-10-17 Binky Moon, LLC
-recipes
-
-// red : 2013-11-07 Afilias Limited
-red
-
-// redstone : 2014-10-31 Redstone Haute Couture Co., Ltd.
-redstone
-
-// redumbrella : 2015-03-26 Travelers TLD, LLC
-redumbrella
-
-// rehab : 2014-03-06 Dog Beach, LLC
-rehab
-
-// reise : 2014-03-13 Binky Moon, LLC
-reise
-
-// reisen : 2014-03-06 Binky Moon, LLC
-reisen
-
-// reit : 2014-09-04 National Association of Real Estate Investment Trusts, Inc.
-reit
-
-// reliance : 2015-04-02 Reliance Industries Limited
-reliance
-
-// ren : 2013-12-12 ZDNS International Limited
-ren
-
-// rent : 2014-12-04 XYZ.COM LLC
-rent
-
-// rentals : 2013-12-05 Binky Moon, LLC
-rentals
-
-// repair : 2013-11-07 Binky Moon, LLC
-repair
-
-// report : 2013-12-05 Binky Moon, LLC
-report
-
-// republican : 2014-03-20 Dog Beach, LLC
-republican
-
-// rest : 2013-12-19 Punto 2012 Sociedad Anonima Promotora de Inversion de Capital Variable
-rest
-
-// restaurant : 2014-07-03 Binky Moon, LLC
-restaurant
-
-// review : 2014-11-20 dot Review Limited
-review
-
-// reviews : 2013-09-13 Dog Beach, LLC
-reviews
-
-// rexroth : 2015-06-18 Robert Bosch GMBH
-rexroth
-
-// rich : 2013-11-21 iRegistry GmbH
-rich
-
-// richardli : 2015-05-14 Pacific Century Asset Management (HK) Limited
-richardli
-
-// ricoh : 2014-11-20 Ricoh Company, Ltd.
-ricoh
-
-// ril : 2015-04-02 Reliance Industries Limited
-ril
-
-// rio : 2014-02-27 Empresa Municipal de Informática SA - IPLANRIO
-rio
-
-// rip : 2014-07-10 Dog Beach, LLC
-rip
-
-// rocher : 2014-12-18 Ferrero Trading Lux S.A.
-rocher
-
-// rocks : 2013-11-14 Dog Beach, LLC
-rocks
-
-// rodeo : 2013-12-19 Registry Services, LLC
-rodeo
-
-// rogers : 2015-08-06 Rogers Communications Canada Inc.
-rogers
-
-// room : 2014-12-18 Amazon Registry Services, Inc.
-room
-
-// rsvp : 2014-05-08 Charleston Road Registry Inc.
-rsvp
-
-// rugby : 2016-12-15 World Rugby Strategic Developments Limited
-rugby
-
-// ruhr : 2013-10-02 regiodot GmbH & Co. KG
-ruhr
-
-// run : 2015-03-19 Binky Moon, LLC
-run
-
-// rwe : 2015-04-02 RWE AG
-rwe
-
-// ryukyu : 2014-01-09 BRregistry, Inc.
-ryukyu
-
-// saarland : 2013-12-12 dotSaarland GmbH
-saarland
-
-// safe : 2014-12-18 Amazon Registry Services, Inc.
-safe
-
-// safety : 2015-01-08 Safety Registry Services, LLC.
-safety
-
-// sakura : 2014-12-18 SAKURA Internet Inc.
-sakura
-
-// sale : 2014-10-16 Dog Beach, LLC
-sale
-
-// salon : 2014-12-11 Binky Moon, LLC
-salon
-
-// samsclub : 2015-07-31 Wal-Mart Stores, Inc.
-samsclub
-
-// samsung : 2014-04-03 SAMSUNG SDS CO., LTD
-samsung
-
-// sandvik : 2014-11-13 Sandvik AB
-sandvik
-
-// sandvikcoromant : 2014-11-07 Sandvik AB
-sandvikcoromant
-
-// sanofi : 2014-10-09 Sanofi
-sanofi
-
-// sap : 2014-03-27 SAP AG
-sap
-
-// sarl : 2014-07-03 Binky Moon, LLC
-sarl
-
-// sas : 2015-04-02 Research IP LLC
-sas
-
-// save : 2015-06-25 Amazon Registry Services, Inc.
-save
-
-// saxo : 2014-10-31 Saxo Bank A/S
-saxo
-
-// sbi : 2015-03-12 STATE BANK OF INDIA
-sbi
-
-// sbs : 2014-11-07 ShortDot SA
-sbs
-
-// sca : 2014-03-13 SVENSKA CELLULOSA AKTIEBOLAGET SCA (publ)
-sca
-
-// scb : 2014-02-20 The Siam Commercial Bank Public Company Limited ("SCB")
-scb
-
-// schaeffler : 2015-08-06 Schaeffler Technologies AG & Co. KG
-schaeffler
-
-// schmidt : 2014-04-03 SCHMIDT GROUPE S.A.S.
-schmidt
-
-// scholarships : 2014-04-24 Scholarships.com, LLC
-scholarships
-
-// school : 2014-12-18 Binky Moon, LLC
-school
-
-// schule : 2014-03-06 Binky Moon, LLC
-schule
-
-// schwarz : 2014-09-18 Schwarz Domains und Services GmbH & Co. KG
-schwarz
-
-// science : 2014-09-11 dot Science Limited
-science
-
-// scot : 2014-01-23 Dot Scot Registry Limited
-scot
-
-// search : 2016-06-09 Charleston Road Registry Inc.
-search
-
-// seat : 2014-05-22 SEAT, S.A. (Sociedad Unipersonal)
-seat
-
-// secure : 2015-08-27 Amazon Registry Services, Inc.
-secure
-
-// security : 2015-05-14 XYZ.COM LLC
-security
-
-// seek : 2014-12-04 Seek Limited
-seek
-
-// select : 2015-10-08 Registry Services, LLC
-select
-
-// sener : 2014-10-24 Sener Ingeniería y Sistemas, S.A.
-sener
-
-// services : 2014-02-27 Binky Moon, LLC
-services
-
-// ses : 2015-07-23 SES
-ses
-
-// seven : 2015-08-06 Seven West Media Ltd
-seven
-
-// sew : 2014-07-17 SEW-EURODRIVE GmbH & Co KG
-sew
-
-// sex : 2014-11-13 ICM Registry SX LLC
-sex
-
-// sexy : 2013-09-11 UNR Corp.
-sexy
-
-// sfr : 2015-08-13 Societe Francaise du Radiotelephone - SFR
-sfr
-
-// shangrila : 2015-09-03 Shangri‐La International Hotel Management Limited
-shangrila
-
-// sharp : 2014-05-01 Sharp Corporation
-sharp
-
-// shaw : 2015-04-23 Shaw Cablesystems G.P.
-shaw
-
-// shell : 2015-07-30 Shell Information Technology International Inc
-shell
-
-// shia : 2014-09-04 Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
-shia
-
-// shiksha : 2013-11-14 Afilias Limited
-shiksha
-
-// shoes : 2013-10-02 Binky Moon, LLC
-shoes
-
-// shop : 2016-04-08 GMO Registry, Inc.
-shop
-
-// shopping : 2016-03-31 Binky Moon, LLC
-shopping
-
-// shouji : 2015-01-08 Beijing Qihu Keji Co., Ltd.
-shouji
-
-// show : 2015-03-05 Binky Moon, LLC
-show
-
-// showtime : 2015-08-06 CBS Domains Inc.
-showtime
-
-// silk : 2015-06-25 Amazon Registry Services, Inc.
-silk
-
-// sina : 2015-03-12 Sina Corporation
-sina
-
-// singles : 2013-08-27 Binky Moon, LLC
-singles
-
-// site : 2015-01-15 Radix FZC
-site
-
-// ski : 2015-04-09 Afilias Limited
-ski
-
-// skin : 2015-01-15 XYZ.COM LLC
-skin
-
-// sky : 2014-06-19 Sky International AG
-sky
-
-// skype : 2014-12-18 Microsoft Corporation
-skype
-
-// sling : 2015-07-30 DISH Technologies L.L.C.
-sling
-
-// smart : 2015-07-09 Smart Communications, Inc. (SMART)
-smart
-
-// smile : 2014-12-18 Amazon Registry Services, Inc.
-smile
-
-// sncf : 2015-02-19 Société Nationale des Chemins de fer Francais S N C F
-sncf
-
-// soccer : 2015-03-26 Binky Moon, LLC
-soccer
-
-// social : 2013-11-07 Dog Beach, LLC
-social
-
-// softbank : 2015-07-02 SoftBank Group Corp.
-softbank
-
-// software : 2014-03-20 Dog Beach, LLC
-software
-
-// sohu : 2013-12-19 Sohu.com Limited
-sohu
-
-// solar : 2013-11-07 Binky Moon, LLC
-solar
-
-// solutions : 2013-11-07 Binky Moon, LLC
-solutions
-
-// song : 2015-02-26 Amazon Registry Services, Inc.
-song
-
-// sony : 2015-01-08 Sony Corporation
-sony
-
-// soy : 2014-01-23 Charleston Road Registry Inc.
-soy
-
-// spa : 2019-09-19 Asia Spa and Wellness Promotion Council Limited
-spa
-
-// space : 2014-04-03 Radix FZC
-space
-
-// sport : 2017-11-16 Global Association of International Sports Federations (GAISF)
-sport
-
-// spot : 2015-02-26 Amazon Registry Services, Inc.
-spot
-
-// srl : 2015-05-07 InterNetX, Corp
-srl
-
-// stada : 2014-11-13 STADA Arzneimittel AG
-stada
-
-// staples : 2015-07-30 Staples, Inc.
-staples
-
-// star : 2015-01-08 Star India Private Limited
-star
-
-// statebank : 2015-03-12 STATE BANK OF INDIA
-statebank
-
-// statefarm : 2015-07-30 State Farm Mutual Automobile Insurance Company
-statefarm
-
-// stc : 2014-10-09 Saudi Telecom Company
-stc
-
-// stcgroup : 2014-10-09 Saudi Telecom Company
-stcgroup
-
-// stockholm : 2014-12-18 Stockholms kommun
-stockholm
-
-// storage : 2014-12-22 XYZ.COM LLC
-storage
-
-// store : 2015-04-09 Radix FZC
-store
-
-// stream : 2016-01-08 dot Stream Limited
-stream
-
-// studio : 2015-02-11 Dog Beach, LLC
-studio
-
-// study : 2014-12-11 OPEN UNIVERSITIES AUSTRALIA PTY LTD
-study
-
-// style : 2014-12-04 Binky Moon, LLC
-style
-
-// sucks : 2014-12-22 Vox Populi Registry Ltd.
-sucks
-
-// supplies : 2013-12-19 Binky Moon, LLC
-supplies
-
-// supply : 2013-12-19 Binky Moon, LLC
-supply
-
-// support : 2013-10-24 Binky Moon, LLC
-support
-
-// surf : 2014-01-09 Registry Services, LLC
-surf
-
-// surgery : 2014-03-20 Binky Moon, LLC
-surgery
-
-// suzuki : 2014-02-20 SUZUKI MOTOR CORPORATION
-suzuki
-
-// swatch : 2015-01-08 The Swatch Group Ltd
-swatch
-
-// swiss : 2014-10-16 Swiss Confederation
-swiss
-
-// sydney : 2014-09-18 State of New South Wales, Department of Premier and Cabinet
-sydney
-
-// systems : 2013-11-07 Binky Moon, LLC
-systems
-
-// tab : 2014-12-04 Tabcorp Holdings Limited
-tab
-
-// taipei : 2014-07-10 Taipei City Government
-taipei
-
-// talk : 2015-04-09 Amazon Registry Services, Inc.
-talk
-
-// taobao : 2015-01-15 Alibaba Group Holding Limited
-taobao
-
-// target : 2015-07-31 Target Domain Holdings, LLC
-target
-
-// tatamotors : 2015-03-12 Tata Motors Ltd
-tatamotors
-
-// tatar : 2014-04-24 Limited Liability Company "Coordination Center of Regional Domain of Tatarstan Republic"
-tatar
-
-// tattoo : 2013-08-30 UNR Corp.
-tattoo
-
-// tax : 2014-03-20 Binky Moon, LLC
-tax
-
-// taxi : 2015-03-19 Binky Moon, LLC
-taxi
-
-// tci : 2014-09-12 Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
-tci
-
-// tdk : 2015-06-11 TDK Corporation
-tdk
-
-// team : 2015-03-05 Binky Moon, LLC
-team
-
-// tech : 2015-01-30 Radix FZC
-tech
-
-// technology : 2013-09-13 Binky Moon, LLC
-technology
-
-// temasek : 2014-08-07 Temasek Holdings (Private) Limited
-temasek
-
-// tennis : 2014-12-04 Binky Moon, LLC
-tennis
-
-// teva : 2015-07-02 Teva Pharmaceutical Industries Limited
-teva
-
-// thd : 2015-04-02 Home Depot Product Authority, LLC
-thd
-
-// theater : 2015-03-19 Binky Moon, LLC
-theater
-
-// theatre : 2015-05-07 XYZ.COM LLC
-theatre
-
-// tiaa : 2015-07-23 Teachers Insurance and Annuity Association of America
-tiaa
-
-// tickets : 2015-02-05 XYZ.COM LLC
-tickets
-
-// tienda : 2013-11-14 Binky Moon, LLC
-tienda
-
-// tiffany : 2015-01-30 Tiffany and Company
-tiffany
-
-// tips : 2013-09-20 Binky Moon, LLC
-tips
-
-// tires : 2014-11-07 Binky Moon, LLC
-tires
-
-// tirol : 2014-04-24 punkt Tirol GmbH
-tirol
-
-// tjmaxx : 2015-07-16 The TJX Companies, Inc.
-tjmaxx
-
-// tjx : 2015-07-16 The TJX Companies, Inc.
-tjx
-
-// tkmaxx : 2015-07-16 The TJX Companies, Inc.
-tkmaxx
-
-// tmall : 2015-01-15 Alibaba Group Holding Limited
-tmall
-
-// today : 2013-09-20 Binky Moon, LLC
-today
-
-// tokyo : 2013-11-13 GMO Registry, Inc.
-tokyo
-
-// tools : 2013-11-21 Binky Moon, LLC
-tools
-
-// top : 2014-03-20 .TOP Registry
-top
-
-// toray : 2014-12-18 Toray Industries, Inc.
-toray
-
-// toshiba : 2014-04-10 TOSHIBA Corporation
-toshiba
-
-// total : 2015-08-06 TOTAL SE
-total
-
-// tours : 2015-01-22 Binky Moon, LLC
-tours
-
-// town : 2014-03-06 Binky Moon, LLC
-town
-
-// toyota : 2015-04-23 TOYOTA MOTOR CORPORATION
-toyota
-
-// toys : 2014-03-06 Binky Moon, LLC
-toys
-
-// trade : 2014-01-23 Elite Registry Limited
-trade
-
-// trading : 2014-12-11 Dog Beach, LLC
-trading
-
-// training : 2013-11-07 Binky Moon, LLC
-training
-
-// travel : 2015-10-09 Dog Beach, LLC
-travel
-
-// travelchannel : 2015-07-02 Lifestyle Domain Holdings, Inc.
-travelchannel
-
-// travelers : 2015-03-26 Travelers TLD, LLC
-travelers
-
-// travelersinsurance : 2015-03-26 Travelers TLD, LLC
-travelersinsurance
-
-// trust : 2014-10-16 UNR Corp.
-trust
-
-// trv : 2015-03-26 Travelers TLD, LLC
-trv
-
-// tube : 2015-06-11 Latin American Telecom LLC
-tube
-
-// tui : 2014-07-03 TUI AG
-tui
-
-// tunes : 2015-02-26 Amazon Registry Services, Inc.
-tunes
-
-// tushu : 2014-12-18 Amazon Registry Services, Inc.
-tushu
-
-// tvs : 2015-02-19 T V SUNDRAM IYENGAR  & SONS LIMITED
-tvs
-
-// ubank : 2015-08-20 National Australia Bank Limited
-ubank
-
-// ubs : 2014-12-11 UBS AG
-ubs
-
-// unicom : 2015-10-15 China United Network Communications Corporation Limited
-unicom
-
-// university : 2014-03-06 Binky Moon, LLC
-university
-
-// uno : 2013-09-11 Radix FZC
-uno
-
-// uol : 2014-05-01 UBN INTERNET LTDA.
-uol
-
-// ups : 2015-06-25 UPS Market Driver, Inc.
-ups
-
-// vacations : 2013-12-05 Binky Moon, LLC
-vacations
-
-// vana : 2014-12-11 Lifestyle Domain Holdings, Inc.
-vana
-
-// vanguard : 2015-09-03 The Vanguard Group, Inc.
-vanguard
-
-// vegas : 2014-01-16 Dot Vegas, Inc.
-vegas
-
-// ventures : 2013-08-27 Binky Moon, LLC
-ventures
-
-// verisign : 2015-08-13 VeriSign, Inc.
-verisign
-
-// versicherung : 2014-03-20 tldbox GmbH
-versicherung
-
-// vet : 2014-03-06 Dog Beach, LLC
-vet
-
-// viajes : 2013-10-17 Binky Moon, LLC
-viajes
-
-// video : 2014-10-16 Dog Beach, LLC
-video
-
-// vig : 2015-05-14 VIENNA INSURANCE GROUP AG Wiener Versicherung Gruppe
-vig
-
-// viking : 2015-04-02 Viking River Cruises (Bermuda) Ltd.
-viking
-
-// villas : 2013-12-05 Binky Moon, LLC
-villas
-
-// vin : 2015-06-18 Binky Moon, LLC
-vin
-
-// vip : 2015-01-22 Registry Services, LLC
-vip
-
-// virgin : 2014-09-25 Virgin Enterprises Limited
-virgin
-
-// visa : 2015-07-30 Visa Worldwide Pte. Limited
-visa
-
-// vision : 2013-12-05 Binky Moon, LLC
-vision
-
-// viva : 2014-11-07 Saudi Telecom Company
-viva
-
-// vivo : 2015-07-31 Telefonica Brasil S.A.
-vivo
-
-// vlaanderen : 2014-02-06 DNS.be vzw
-vlaanderen
-
-// vodka : 2013-12-19 Registry Services, LLC
-vodka
-
-// volkswagen : 2015-05-14 Volkswagen Group of America Inc.
-volkswagen
-
-// volvo : 2015-11-12 Volvo Holding Sverige Aktiebolag
-volvo
-
-// vote : 2013-11-21 Monolith Registry LLC
-vote
-
-// voting : 2013-11-13 Valuetainment Corp.
-voting
-
-// voto : 2013-11-21 Monolith Registry LLC
-voto
-
-// voyage : 2013-08-27 Binky Moon, LLC
-voyage
-
-// vuelos : 2015-03-05 Travel Reservations SRL
-vuelos
-
-// wales : 2014-05-08 Nominet UK
-wales
-
-// walmart : 2015-07-31 Wal-Mart Stores, Inc.
-walmart
-
-// walter : 2014-11-13 Sandvik AB
-walter
-
-// wang : 2013-10-24 Zodiac Wang Limited
-wang
-
-// wanggou : 2014-12-18 Amazon Registry Services, Inc.
-wanggou
-
-// watch : 2013-11-14 Binky Moon, LLC
-watch
-
-// watches : 2014-12-22 Afilias Limited
-watches
-
-// weather : 2015-01-08 International Business Machines Corporation
-weather
-
-// weatherchannel : 2015-03-12 International Business Machines Corporation
-weatherchannel
-
-// webcam : 2014-01-23 dot Webcam Limited
-webcam
-
-// weber : 2015-06-04 Saint-Gobain Weber SA
-weber
-
-// website : 2014-04-03 Radix FZC
-website
-
-// wedding : 2014-04-24 Registry Services, LLC
-wedding
-
-// weibo : 2015-03-05 Sina Corporation
-weibo
-
-// weir : 2015-01-29 Weir Group IP Limited
-weir
-
-// whoswho : 2014-02-20 Who's Who Registry
-whoswho
-
-// wien : 2013-10-28 punkt.wien GmbH
-wien
-
-// wiki : 2013-11-07 Top Level Design, LLC
-wiki
-
-// williamhill : 2014-03-13 William Hill Organization Limited
-williamhill
-
-// win : 2014-11-20 First Registry Limited
-win
-
-// windows : 2014-12-18 Microsoft Corporation
-windows
-
-// wine : 2015-06-18 Binky Moon, LLC
-wine
-
-// winners : 2015-07-16 The TJX Companies, Inc.
-winners
-
-// wme : 2014-02-13 William Morris Endeavor Entertainment, LLC
-wme
-
-// wolterskluwer : 2015-08-06 Wolters Kluwer N.V.
-wolterskluwer
-
-// woodside : 2015-07-09 Woodside Petroleum Limited
-woodside
-
-// work : 2013-12-19 Registry Services, LLC
-work
-
-// works : 2013-11-14 Binky Moon, LLC
-works
-
-// world : 2014-06-12 Binky Moon, LLC
-world
-
-// wow : 2015-10-08 Amazon Registry Services, Inc.
-wow
-
-// wtc : 2013-12-19 World Trade Centers Association, Inc.
-wtc
-
-// wtf : 2014-03-06 Binky Moon, LLC
-wtf
-
-// xbox : 2014-12-18 Microsoft Corporation
-xbox
-
-// xerox : 2014-10-24 Xerox DNHC LLC
-xerox
-
-// xfinity : 2015-07-09 Comcast IP Holdings I, LLC
-xfinity
-
-// xihuan : 2015-01-08 Beijing Qihu Keji Co., Ltd.
-xihuan
-
-// xin : 2014-12-11 Elegant Leader Limited
-xin
-
-// xn--11b4c3d : 2015-01-15 VeriSign Sarl
-कॉम
-
-// xn--1ck2e1b : 2015-02-26 Amazon Registry Services, Inc.
-セール
-
-// xn--1qqw23a : 2014-01-09 Guangzhou YU Wei Information Technology Co., Ltd.
-佛山
-
-// xn--30rr7y : 2014-06-12 Excellent First Limited
-慈善
-
-// xn--3bst00m : 2013-09-13 Eagle Horizon Limited
-集团
-
-// xn--3ds443g : 2013-09-08 TLD REGISTRY LIMITED OY
-在线
-
-// xn--3pxu8k : 2015-01-15 VeriSign Sarl
-点看
-
-// xn--42c2d9a : 2015-01-15 VeriSign Sarl
-คอม
-
-// xn--45q11c : 2013-11-21 Zodiac Gemini Ltd
-八卦
-
-// xn--4gbrim : 2013-10-04 Helium TLDs Ltd
-موقع
-
-// xn--55qw42g : 2013-11-08 China Organizational Name Administration Center
-公益
-
-// xn--55qx5d : 2013-11-14 China Internet Network Information Center (CNNIC)
-公司
-
-// xn--5su34j936bgsg : 2015-09-03 Shangri‐La International Hotel Management Limited
-香格里拉
-
-// xn--5tzm5g : 2014-12-22 Global Website TLD Asia Limited
-网站
-
-// xn--6frz82g : 2013-09-23 Afilias Limited
-移动
-
-// xn--6qq986b3xl : 2013-09-13 Tycoon Treasure Limited
-我爱你
-
-// xn--80adxhks : 2013-12-19 Foundation for Assistance for Internet Technologies and Infrastructure Development (FAITID)
-москва
-
-// xn--80aqecdr1a : 2015-10-21 Pontificium Consilium de Comunicationibus Socialibus (PCCS) (Pontifical Council for Social Communication)
-католик
-
-// xn--80asehdb : 2013-07-14 CORE Association
-онлайн
-
-// xn--80aswg : 2013-07-14 CORE Association
-сайт
-
-// xn--8y0a063a : 2015-03-26 China United Network Communications Corporation Limited
-联通
-
-// xn--9dbq2a : 2015-01-15 VeriSign Sarl
-קום
-
-// xn--9et52u : 2014-06-12 RISE VICTORY LIMITED
-时尚
-
-// xn--9krt00a : 2015-03-12 Sina Corporation
-微博
-
-// xn--b4w605ferd : 2014-08-07 Temasek Holdings (Private) Limited
-淡马锡
-
-// xn--bck1b9a5dre4c : 2015-02-26 Amazon Registry Services, Inc.
-ファッション
-
-// xn--c1avg : 2013-11-14 Public Interest Registry
-орг
-
-// xn--c2br7g : 2015-01-15 VeriSign Sarl
-नेट
-
-// xn--cck2b3b : 2015-02-26 Amazon Registry Services, Inc.
-ストア
-
-// xn--cckwcxetd : 2019-12-19 Amazon Registry Services, Inc.
-アマゾン
-
-// xn--cg4bki : 2013-09-27 SAMSUNG SDS CO., LTD
-삼성
-
-// xn--czr694b : 2014-01-16 Internet DotTrademark Organisation Limited
-商标
-
-// xn--czrs0t : 2013-12-19 Binky Moon, LLC
-商店
-
-// xn--czru2d : 2013-11-21 Zodiac Aquarius Limited
-商城
-
-// xn--d1acj3b : 2013-11-20 The Foundation for Network Initiatives “The Smart Internet”
-дети
-
-// xn--eckvdtc9d : 2014-12-18 Amazon Registry Services, Inc.
-ポイント
-
-// xn--efvy88h : 2014-08-22 Guangzhou YU Wei Information Technology Co., Ltd.
-新闻
-
-// xn--fct429k : 2015-04-09 Amazon Registry Services, Inc.
-家電
-
-// xn--fhbei : 2015-01-15 VeriSign Sarl
-كوم
-
-// xn--fiq228c5hs : 2013-09-08 TLD REGISTRY LIMITED OY
-中文网
-
-// xn--fiq64b : 2013-10-14 CITIC Group Corporation
-中信
-
-// xn--fjq720a : 2014-05-22 Binky Moon, LLC
-娱乐
-
-// xn--flw351e : 2014-07-31 Charleston Road Registry Inc.
-谷歌
-
-// xn--fzys8d69uvgm : 2015-05-14 PCCW Enterprises Limited
-電訊盈科
-
-// xn--g2xx48c : 2015-01-30 Nawang Heli(Xiamen) Network Service Co., LTD.
-购物
-
-// xn--gckr3f0f : 2015-02-26 Amazon Registry Services, Inc.
-クラウド
-
-// xn--gk3at1e : 2015-10-08 Amazon Registry Services, Inc.
-通販
-
-// xn--hxt814e : 2014-05-15 Zodiac Taurus Limited
-网店
-
-// xn--i1b6b1a6a2e : 2013-11-14 Public Interest Registry
-संगठन
-
-// xn--imr513n : 2014-12-11 Internet DotTrademark Organisation Limited
-餐厅
-
-// xn--io0a7i : 2013-11-14 China Internet Network Information Center (CNNIC)
-网络
-
-// xn--j1aef : 2015-01-15 VeriSign Sarl
-ком
-
-// xn--jlq480n2rg : 2019-12-19 Amazon Registry Services, Inc.
-亚马逊
-
-// xn--jlq61u9w7b : 2015-01-08 Nokia Corporation
-诺基亚
-
-// xn--jvr189m : 2015-02-26 Amazon Registry Services, Inc.
-食品
-
-// xn--kcrx77d1x4a : 2014-11-07 Koninklijke Philips N.V.
-飞利浦
-
-// xn--kput3i : 2014-02-13 Beijing RITT-Net Technology Development Co., Ltd
-手机
-
-// xn--mgba3a3ejt : 2014-11-20 Aramco Services Company
-ارامكو
-
-// xn--mgba7c0bbn0a : 2015-05-14 Crescent Holding GmbH
-العليان
-
-// xn--mgbaakc7dvf : 2015-09-03 Emirates Telecommunications Corporation (trading as Etisalat)
-اتصالات
-
-// xn--mgbab2bd : 2013-10-31 CORE Association
-بازار
-
-// xn--mgbca7dzdo : 2015-07-30 Abu Dhabi Systems and Information Centre
-ابوظبي
-
-// xn--mgbi4ecexp : 2015-10-21 Pontificium Consilium de Comunicationibus Socialibus (PCCS) (Pontifical Council for Social Communication)
-كاثوليك
-
-// xn--mgbt3dhd : 2014-09-04 Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
-همراه
-
-// xn--mk1bu44c : 2015-01-15 VeriSign Sarl
-닷컴
-
-// xn--mxtq1m : 2014-03-06 Net-Chinese Co., Ltd.
-政府
-
-// xn--ngbc5azd : 2013-07-13 International Domain Registry Pty. Ltd.
-شبكة
-
-// xn--ngbe9e0a : 2014-12-04 Kuwait Finance House
-بيتك
-
-// xn--ngbrx : 2015-11-12 League of Arab States
-عرب
-
-// xn--nqv7f : 2013-11-14 Public Interest Registry
-机构
-
-// xn--nqv7fs00ema : 2013-11-14 Public Interest Registry
-组织机构
-
-// xn--nyqy26a : 2014-11-07 Stable Tone Limited
-健康
-
-// xn--otu796d : 2017-08-06 Jiang Yu Liang Cai Technology Company Limited
-招聘
-
-// xn--p1acf : 2013-12-12 Rusnames Limited
-рус
-
-// xn--pssy2u : 2015-01-15 VeriSign Sarl
-大拿
-
-// xn--q9jyb4c : 2013-09-17 Charleston Road Registry Inc.
-みんな
-
-// xn--qcka1pmc : 2014-07-31 Charleston Road Registry Inc.
-グーグル
-
-// xn--rhqv96g : 2013-09-11 Stable Tone Limited
-世界
-
-// xn--rovu88b : 2015-02-26 Amazon Registry Services, Inc.
-書籍
-
-// xn--ses554g : 2014-01-16 KNET Co., Ltd.
-网址
-
-// xn--t60b56a : 2015-01-15 VeriSign Sarl
-닷넷
-
-// xn--tckwe : 2015-01-15 VeriSign Sarl
-コム
-
-// xn--tiq49xqyj : 2015-10-21 Pontificium Consilium de Comunicationibus Socialibus (PCCS) (Pontifical Council for Social Communication)
-天主教
-
-// xn--unup4y : 2013-07-14 Binky Moon, LLC
-游戏
-
-// xn--vermgensberater-ctb : 2014-06-23 Deutsche Vermögensberatung Aktiengesellschaft DVAG
-vermögensberater
-
-// xn--vermgensberatung-pwb : 2014-06-23 Deutsche Vermögensberatung Aktiengesellschaft DVAG
-vermögensberatung
-
-// xn--vhquv : 2013-08-27 Binky Moon, LLC
-企业
-
-// xn--vuq861b : 2014-10-16 Beijing Tele-info Network Technology Co., Ltd.
-信息
-
-// xn--w4r85el8fhu5dnra : 2015-04-30 Kerry Trading Co. Limited
-嘉里大酒店
-
-// xn--w4rs40l : 2015-07-30 Kerry Trading Co. Limited
-嘉里
-
-// xn--xhq521b : 2013-11-14 Guangzhou YU Wei Information Technology Co., Ltd.
-广东
-
-// xn--zfr164b : 2013-11-08 China Organizational Name Administration Center
-政务
-
-// xyz : 2013-12-05 XYZ.COM LLC
-xyz
-
-// yachts : 2014-01-09 XYZ.COM LLC
-yachts
-
-// yahoo : 2015-04-02 Oath Inc.
-yahoo
-
-// yamaxun : 2014-12-18 Amazon Registry Services, Inc.
-yamaxun
-
-// yandex : 2014-04-10 Yandex Europe B.V.
-yandex
-
-// yodobashi : 2014-11-20 YODOBASHI CAMERA CO.,LTD.
-yodobashi
-
-// yoga : 2014-05-29 Registry Services, LLC
-yoga
-
-// yokohama : 2013-12-12 GMO Registry, Inc.
-yokohama
-
-// you : 2015-04-09 Amazon Registry Services, Inc.
-you
-
-// youtube : 2014-05-01 Charleston Road Registry Inc.
-youtube
-
-// yun : 2015-01-08 Beijing Qihu Keji Co., Ltd.
-yun
-
-// zappos : 2015-06-25 Amazon Registry Services, Inc.
-zappos
-
-// zara : 2014-11-07 Industria de Diseño Textil, S.A. (INDITEX, S.A.)
-zara
-
-// zero : 2014-12-18 Amazon Registry Services, Inc.
-zero
-
-// zip : 2014-05-08 Charleston Road Registry Inc.
-zip
-
-// zone : 2013-11-14 Binky Moon, LLC
-zone
-
-// zuerich : 2014-11-07 Kanton Zürich (Canton of Zurich)
-zuerich
-
-
-// ===END ICANN DOMAINS===
-// ===BEGIN PRIVATE DOMAINS===
-// (Note: these are in alphabetical order by company name)
-
-// 1GB LLC : https://www.1gb.ua/
-// Submitted by 1GB LLC <noc@1gb.com.ua>
-cc.ua
-inf.ua
-ltd.ua
-
-// 611coin : https://611project.org/
-611.to
-
-// Aaron Marais' Gitlab pages: https://lab.aaronleem.co.za
-// Submitted by Aaron Marais <its_me@aaronleem.co.za>
-graphox.us
-
-// accesso Technology Group, plc. : https://accesso.com/
-// Submitted by accesso Team <accessoecommerce@accesso.com>
-*.devcdnaccesso.com
-
-// Adobe : https://www.adobe.com/
-// Submitted by Ian Boston <boston@adobe.com> and Lars Trieloff <trieloff@adobe.com>
-adobeaemcloud.com
-*.dev.adobeaemcloud.com
-hlx.live
-adobeaemcloud.net
-hlx.page
-hlx3.page
-
-// Agnat sp. z o.o. : https://domena.pl
-// Submitted by Przemyslaw Plewa <it-admin@domena.pl>
-beep.pl
-
-// Airkit : https://www.airkit.com/
-// Submitted by Grant Cooksey <security@airkit.com>
-airkitapps.com
-airkitapps-au.com
-airkitapps.eu
-
-// Aiven: https://aiven.io/
-// Submitted by Etienne Stalmans <security@aiven.io>
-aivencloud.com
-
-// alboto.ca : http://alboto.ca
-// Submitted by Anton Avramov <avramov@alboto.ca>
-barsy.ca
-
-// Alces Software Ltd : http://alces-software.com
-// Submitted by Mark J. Titorenko <mark.titorenko@alces-software.com>
-*.compute.estate
-*.alces.network
-
-// all-inkl.com : https://all-inkl.com
-// Submitted by Werner Kaltofen <wk@all-inkl.com>
-kasserver.com
-
-// Altervista: https://www.altervista.org
-// Submitted by Carlo Cannas <tech_staff@altervista.it>
-altervista.org
-
-// alwaysdata : https://www.alwaysdata.com
-// Submitted by Cyril <admin@alwaysdata.com>
-alwaysdata.net
-
-// Amazon CloudFront : https://aws.amazon.com/cloudfront/
-// Submitted by Donavan Miller <donavanm@amazon.com>
-cloudfront.net
-
-// Amazon Elastic Compute Cloud : https://aws.amazon.com/ec2/
-// Submitted by Luke Wells <psl-maintainers@amazon.com>
-*.compute.amazonaws.com
-*.compute-1.amazonaws.com
-*.compute.amazonaws.com.cn
-us-east-1.amazonaws.com
-
-// Amazon Elastic Beanstalk : https://aws.amazon.com/elasticbeanstalk/
-// Submitted by Luke Wells <psl-maintainers@amazon.com>
-cn-north-1.eb.amazonaws.com.cn
-cn-northwest-1.eb.amazonaws.com.cn
-elasticbeanstalk.com
-ap-northeast-1.elasticbeanstalk.com
-ap-northeast-2.elasticbeanstalk.com
-ap-northeast-3.elasticbeanstalk.com
-ap-south-1.elasticbeanstalk.com
-ap-southeast-1.elasticbeanstalk.com
-ap-southeast-2.elasticbeanstalk.com
-ca-central-1.elasticbeanstalk.com
-eu-central-1.elasticbeanstalk.com
-eu-west-1.elasticbeanstalk.com
-eu-west-2.elasticbeanstalk.com
-eu-west-3.elasticbeanstalk.com
-sa-east-1.elasticbeanstalk.com
-us-east-1.elasticbeanstalk.com
-us-east-2.elasticbeanstalk.com
-us-gov-west-1.elasticbeanstalk.com
-us-west-1.elasticbeanstalk.com
-us-west-2.elasticbeanstalk.com
-
-// Amazon Elastic Load Balancing : https://aws.amazon.com/elasticloadbalancing/
-// Submitted by Luke Wells <psl-maintainers@amazon.com>
-*.elb.amazonaws.com
-*.elb.amazonaws.com.cn
-
-// Amazon Global Accelerator : https://aws.amazon.com/global-accelerator/
-// Submitted by Daniel Massaguer <psl-maintainers@amazon.com>
-awsglobalaccelerator.com
-
-// Amazon S3 : https://aws.amazon.com/s3/
-// Submitted by Luke Wells <psl-maintainers@amazon.com>
-s3.amazonaws.com
-s3-ap-northeast-1.amazonaws.com
-s3-ap-northeast-2.amazonaws.com
-s3-ap-south-1.amazonaws.com
-s3-ap-southeast-1.amazonaws.com
-s3-ap-southeast-2.amazonaws.com
-s3-ca-central-1.amazonaws.com
-s3-eu-central-1.amazonaws.com
-s3-eu-west-1.amazonaws.com
-s3-eu-west-2.amazonaws.com
-s3-eu-west-3.amazonaws.com
-s3-external-1.amazonaws.com
-s3-fips-us-gov-west-1.amazonaws.com
-s3-sa-east-1.amazonaws.com
-s3-us-gov-west-1.amazonaws.com
-s3-us-east-2.amazonaws.com
-s3-us-west-1.amazonaws.com
-s3-us-west-2.amazonaws.com
-s3.ap-northeast-2.amazonaws.com
-s3.ap-south-1.amazonaws.com
-s3.cn-north-1.amazonaws.com.cn
-s3.ca-central-1.amazonaws.com
-s3.eu-central-1.amazonaws.com
-s3.eu-west-2.amazonaws.com
-s3.eu-west-3.amazonaws.com
-s3.us-east-2.amazonaws.com
-s3.dualstack.ap-northeast-1.amazonaws.com
-s3.dualstack.ap-northeast-2.amazonaws.com
-s3.dualstack.ap-south-1.amazonaws.com
-s3.dualstack.ap-southeast-1.amazonaws.com
-s3.dualstack.ap-southeast-2.amazonaws.com
-s3.dualstack.ca-central-1.amazonaws.com
-s3.dualstack.eu-central-1.amazonaws.com
-s3.dualstack.eu-west-1.amazonaws.com
-s3.dualstack.eu-west-2.amazonaws.com
-s3.dualstack.eu-west-3.amazonaws.com
-s3.dualstack.sa-east-1.amazonaws.com
-s3.dualstack.us-east-1.amazonaws.com
-s3.dualstack.us-east-2.amazonaws.com
-s3-website-us-east-1.amazonaws.com
-s3-website-us-west-1.amazonaws.com
-s3-website-us-west-2.amazonaws.com
-s3-website-ap-northeast-1.amazonaws.com
-s3-website-ap-southeast-1.amazonaws.com
-s3-website-ap-southeast-2.amazonaws.com
-s3-website-eu-west-1.amazonaws.com
-s3-website-sa-east-1.amazonaws.com
-s3-website.ap-northeast-2.amazonaws.com
-s3-website.ap-south-1.amazonaws.com
-s3-website.ca-central-1.amazonaws.com
-s3-website.eu-central-1.amazonaws.com
-s3-website.eu-west-2.amazonaws.com
-s3-website.eu-west-3.amazonaws.com
-s3-website.us-east-2.amazonaws.com
-
-// Amune : https://amune.org/
-// Submitted by Team Amune <cert@amune.org>
-t3l3p0rt.net
-tele.amune.org
-
-// Apigee : https://apigee.com/
-// Submitted by Apigee Security Team <security@apigee.com>
-apigee.io
-
-// Apphud : https://apphud.com
-// Submitted by Alexander Selivanov <alex@apphud.com>
-siiites.com
-
-// Appspace : https://www.appspace.com
-// Submitted by Appspace Security Team <security@appspace.com>
-appspacehosted.com
-appspaceusercontent.com
-
-// Appudo UG (haftungsbeschränkt) : https://www.appudo.com
-// Submitted by Alexander Hochbaum <admin@appudo.com>
-appudo.net
-
-// Aptible : https://www.aptible.com/
-// Submitted by Thomas Orozco <thomas@aptible.com>
-on-aptible.com
-
-// ASEINet : https://www.aseinet.com/
-// Submitted by Asei SEKIGUCHI <mail@aseinet.com>
-user.aseinet.ne.jp
-gv.vc
-d.gv.vc
-
-// Asociación Amigos de la Informática "Euskalamiga" : http://encounter.eus/
-// Submitted by Hector Martin <marcan@euskalencounter.org>
-user.party.eus
-
-// Association potager.org : https://potager.org/
-// Submitted by Lunar <jardiniers@potager.org>
-pimienta.org
-poivron.org
-potager.org
-sweetpepper.org
-
-// ASUSTOR Inc. : http://www.asustor.com
-// Submitted by Vincent Tseng <vincenttseng@asustor.com>
-myasustor.com
-
-// Atlassian : https://atlassian.com
-// Submitted by Sam Smyth <devloop@atlassian.com>
-cdn.prod.atlassian-dev.net
-
-// Authentick UG (haftungsbeschränkt) : https://authentick.net
-// Submitted by Lukas Reschke <lukas@authentick.net>
-translated.page
-
-// AVM : https://avm.de
-// Submitted by Andreas Weise <a.weise@avm.de>
-myfritz.net
-
-// AVStack Pte. Ltd. : https://avstack.io
-// Submitted by Jasper Hugo <jasper@avstack.io>
-onavstack.net
-
-// AW AdvisorWebsites.com Software Inc : https://advisorwebsites.com
-// Submitted by James Kennedy <domains@advisorwebsites.com>
-*.awdev.ca
-*.advisor.ws
-
-// AZ.pl sp. z.o.o: https://az.pl
-// Submitted by Krzysztof Wolski <krzysztof.wolski@home.eu>
-ecommerce-shop.pl
-
-// b-data GmbH : https://www.b-data.io
-// Submitted by Olivier Benz <olivier.benz@b-data.ch>
-b-data.io
-
-// backplane : https://www.backplane.io
-// Submitted by Anthony Voutas <anthony@backplane.io>
-backplaneapp.io
-
-// Balena : https://www.balena.io
-// Submitted by Petros Angelatos <petrosagg@balena.io>
-balena-devices.com
-
-// University of Banja Luka : https://unibl.org
-// Domains for Republic of Srpska administrative entity.
-// Submitted by Marko Ivanovic <kormang@hotmail.rs>
-rs.ba
-
-// Banzai Cloud
-// Submitted by Janos Matyas <info@banzaicloud.com>
-*.banzai.cloud
-app.banzaicloud.io
-*.backyards.banzaicloud.io
-
-// BASE, Inc. : https://binc.jp
-// Submitted by Yuya NAGASAWA <public-suffix-list@binc.jp>
-base.ec
-official.ec
-buyshop.jp
-fashionstore.jp
-handcrafted.jp
-kawaiishop.jp
-supersale.jp
-theshop.jp
-shopselect.net
-base.shop
-
-// Beget Ltd
-// Submitted by Lev Nekrasov <lnekrasov@beget.com>
-*.beget.app
-
-// BetaInABox
-// Submitted by Adrian <adrian@betainabox.com>
-betainabox.com
-
-// BinaryLane : http://www.binarylane.com
-// Submitted by Nathan O'Sullivan <nathan@mammoth.com.au>
-bnr.la
-
-// Bitbucket : http://bitbucket.org
-// Submitted by Andy Ortlieb <aortlieb@atlassian.com>
-bitbucket.io
-
-// Blackbaud, Inc. : https://www.blackbaud.com
-// Submitted by Paul Crowder <paul.crowder@blackbaud.com>
-blackbaudcdn.net
-
-// Blatech : http://www.blatech.net
-// Submitted by Luke Bratch <luke@bratch.co.uk>
-of.je
-
-// Blue Bite, LLC : https://bluebite.com
-// Submitted by Joshua Weiss <admin.engineering@bluebite.com>
-bluebite.io
-
-// Boomla : https://boomla.com
-// Submitted by Tibor Halter <thalter@boomla.com>
-boomla.net
-
-// Boutir : https://www.boutir.com
-// Submitted by Eric Ng Ka Ka <ngkaka@boutir.com>
-boutir.com
-
-// Boxfuse : https://boxfuse.com
-// Submitted by Axel Fontaine <axel@boxfuse.com>
-boxfuse.io
-
-// bplaced : https://www.bplaced.net/
-// Submitted by Miroslav Bozic <security@bplaced.net>
-square7.ch
-bplaced.com
-bplaced.de
-square7.de
-bplaced.net
-square7.net
-
-// Brendly : https://brendly.rs
-// Submitted by Dusan Radovanovic <dusan.radovanovic@brendly.rs>
-shop.brendly.rs
-
-// BrowserSafetyMark
-// Submitted by Dave Tharp <browsersafetymark.io@quicinc.com>
-browsersafetymark.io
-
-// Bytemark Hosting : https://www.bytemark.co.uk
-// Submitted by Paul Cammish <paul.cammish@bytemark.co.uk>
-uk0.bigv.io
-dh.bytemark.co.uk
-vm.bytemark.co.uk
-
-// Caf.js Labs LLC : https://www.cafjs.com
-// Submitted by Antonio Lain <antlai@cafjs.com>
-cafjs.com
-
-// callidomus : https://www.callidomus.com/
-// Submitted by Marcus Popp <admin@callidomus.com>
-mycd.eu
-
-// Carrd : https://carrd.co
-// Submitted by AJ <aj@carrd.co>
-drr.ac
-uwu.ai
-carrd.co
-crd.co
-ju.mp
-
-// CentralNic : http://www.centralnic.com/names/domains
-// Submitted by registry <gavin.brown@centralnic.com>
-ae.org
-br.com
-cn.com
-com.de
-com.se
-de.com
-eu.com
-gb.net
-hu.net
-jp.net
-jpn.com
-mex.com
-ru.com
-sa.com
-se.net
-uk.com
-uk.net
-us.com
-za.bz
-za.com
-
-// No longer operated by CentralNic, these entries should be adopted and/or removed by current operators
-// Submitted by Gavin Brown <gavin.brown@centralnic.com>
-ar.com
-hu.com
-kr.com
-no.com
-qc.com
-uy.com
-
-// Africa.com Web Solutions Ltd : https://registry.africa.com
-// Submitted by Gavin Brown <gavin.brown@centralnic.com>
-africa.com
-
-// iDOT Services Limited : http://www.domain.gr.com
-// Submitted by Gavin Brown <gavin.brown@centralnic.com>
-gr.com
-
-// Radix FZC : http://domains.in.net
-// Submitted by Gavin Brown <gavin.brown@centralnic.com>
-in.net
-web.in
-
-// US REGISTRY LLC : http://us.org
-// Submitted by Gavin Brown <gavin.brown@centralnic.com>
-us.org
-
-// co.com Registry, LLC : https://registry.co.com
-// Submitted by Gavin Brown <gavin.brown@centralnic.com>
-co.com
-
-// Roar Domains LLC : https://roar.basketball/
-// Submitted by Gavin Brown <gavin.brown@centralnic.com>
-aus.basketball
-nz.basketball
-
-// BRS Media : https://brsmedia.com/
-// Submitted by Gavin Brown <gavin.brown@centralnic.com>
-radio.am
-radio.fm
-
-// c.la : http://www.c.la/
-c.la
-
-// certmgr.org : https://certmgr.org
-// Submitted by B. Blechschmidt <hostmaster@certmgr.org>
-certmgr.org
-
-// Cityhost LLC  : https://cityhost.ua
-// Submitted by Maksym Rivtin <support@cityhost.net.ua>
-cx.ua
-
-// Civilized Discourse Construction Kit, Inc. : https://www.discourse.org/
-// Submitted by Rishabh Nambiar & Michael Brown <team@discourse.org>
-discourse.group
-discourse.team
-
-// Clever Cloud : https://www.clever-cloud.com/
-// Submitted by Quentin Adam <noc@clever-cloud.com>
-cleverapps.io
-
-// Clerk : https://www.clerk.dev
-// Submitted by Colin Sidoti <systems@clerk.dev>
-clerk.app
-clerkstage.app
-*.lcl.dev
-*.lclstage.dev
-*.stg.dev
-*.stgstage.dev
-
-// ClickRising : https://clickrising.com/
-// Submitted by Umut Gumeli <infrastructure-publicsuffixlist@clickrising.com>
-clickrising.net
-
-// Cloud66 : https://www.cloud66.com/
-// Submitted by Khash Sajadi <khash@cloud66.com>
-c66.me
-cloud66.ws
-cloud66.zone
-
-// CloudAccess.net : https://www.cloudaccess.net/
-// Submitted by Pawel Panek <noc@cloudaccess.net>
-jdevcloud.com
-wpdevcloud.com
-cloudaccess.host
-freesite.host
-cloudaccess.net
-
-// cloudControl : https://www.cloudcontrol.com/
-// Submitted by Tobias Wilken <tw@cloudcontrol.com>
-cloudcontrolled.com
-cloudcontrolapp.com
-
-// Cloudera, Inc. : https://www.cloudera.com/
-// Submitted by Kedarnath Waikar <security@cloudera.com>
-*.cloudera.site
-
-// Cloudflare, Inc. : https://www.cloudflare.com/
-// Submitted by Cloudflare Team <publicsuffixlist@cloudflare.com>
-pages.dev
-trycloudflare.com
-workers.dev
-
-// Clovyr : https://clovyr.io
-// Submitted by Patrick Nielsen <patrick@clovyr.io>
-wnext.app
-
-// co.ca : http://registry.co.ca/
-co.ca
-
-// Co & Co : https://co-co.nl/
-// Submitted by Govert Versluis <govert@co-co.nl>
-*.otap.co
-
-// i-registry s.r.o. : http://www.i-registry.cz/
-// Submitted by Martin Semrad <semrad@i-registry.cz>
-co.cz
-
-// CDN77.com : http://www.cdn77.com
-// Submitted by Jan Krpes <jan.krpes@cdn77.com>
-c.cdn77.org
-cdn77-ssl.net
-r.cdn77.net
-rsc.cdn77.org
-ssl.origin.cdn77-secure.org
-
-// Cloud DNS Ltd : http://www.cloudns.net
-// Submitted by Aleksander Hristov <noc@cloudns.net>
-cloudns.asia
-cloudns.biz
-cloudns.club
-cloudns.cc
-cloudns.eu
-cloudns.in
-cloudns.info
-cloudns.org
-cloudns.pro
-cloudns.pw
-cloudns.us
-
-// CNPY : https://cnpy.gdn
-// Submitted by Angelo Gladding <angelo@lahacker.net>
-cnpy.gdn
-
-// Codeberg e. V. : https://codeberg.org
-// Submitted by Moritz Marquardt <git@momar.de>
-codeberg.page
-
-// CoDNS B.V.
-co.nl
-co.no
-
-// Combell.com : https://www.combell.com
-// Submitted by Thomas Wouters <thomas.wouters@combellgroup.com>
-webhosting.be
-hosting-cluster.nl
-
-// Coordination Center for TLD RU and XN--P1AI : https://cctld.ru/en/domains/domens_ru/reserved/
-// Submitted by George Georgievsky <gug@cctld.ru>
-ac.ru
-edu.ru
-gov.ru
-int.ru
-mil.ru
-test.ru
-
-// COSIMO GmbH : http://www.cosimo.de
-// Submitted by Rene Marticke <rmarticke@cosimo.de>
-dyn.cosidns.de
-dynamisches-dns.de
-dnsupdater.de
-internet-dns.de
-l-o-g-i-n.de
-dynamic-dns.info
-feste-ip.net
-knx-server.net
-static-access.net
-
-// Craynic, s.r.o. : http://www.craynic.com/
-// Submitted by Ales Krajnik <ales.krajnik@craynic.com>
-realm.cz
-
-// Cryptonomic : https://cryptonomic.net/
-// Submitted by Andrew Cady <public-suffix-list@cryptonomic.net>
-*.cryptonomic.net
-
-// Cupcake : https://cupcake.io/
-// Submitted by Jonathan Rudenberg <jonathan@cupcake.io>
-cupcake.is
-
-// Curv UG : https://curv-labs.de/
-// Submitted by Marvin Wiesner <Marvin@curv-labs.de>
-curv.dev
-
-// Customer OCI - Oracle Dyn https://cloud.oracle.com/home https://dyn.com/dns/
-// Submitted by Gregory Drake <support@dyn.com>
-// Note: This is intended to also include customer-oci.com due to wildcards implicitly including the current label
-*.customer-oci.com
-*.oci.customer-oci.com
-*.ocp.customer-oci.com
-*.ocs.customer-oci.com
-
-// cyon GmbH : https://www.cyon.ch/
-// Submitted by Dominic Luechinger <dol@cyon.ch>
-cyon.link
-cyon.site
-
-// Danger Science Group: https://dangerscience.com/
-// Submitted by Skylar MacDonald <skylar@dangerscience.com>
-fnwk.site
-folionetwork.site
-platform0.app
-
-// Daplie, Inc : https://daplie.com
-// Submitted by AJ ONeal <aj@daplie.com>
-daplie.me
-localhost.daplie.me
-
-// Datto, Inc. : https://www.datto.com/
-// Submitted by Philipp Heckel <ph@datto.com>
-dattolocal.com
-dattorelay.com
-dattoweb.com
-mydatto.com
-dattolocal.net
-mydatto.net
-
-// Dansk.net : http://www.dansk.net/
-// Submitted by Anani Voule <digital@digital.co.dk>
-biz.dk
-co.dk
-firm.dk
-reg.dk
-store.dk
-
-// dappnode.io : https://dappnode.io/
-// Submitted by Abel Boldu / DAppNode Team <community@dappnode.io>
-dyndns.dappnode.io
-
-// dapps.earth : https://dapps.earth/
-// Submitted by Daniil Burdakov <icqkill@gmail.com>
-*.dapps.earth
-*.bzz.dapps.earth
-
-// Dark, Inc. : https://darklang.com
-// Submitted by Paul Biggar <ops@darklang.com>
-builtwithdark.com
-
-// DataDetect, LLC. : https://datadetect.com
-// Submitted by Andrew Banchich <abanchich@sceven.com>
-demo.datadetect.com
-instance.datadetect.com
-
-// Datawire, Inc : https://www.datawire.io
-// Submitted by Richard Li <secalert@datawire.io>
-edgestack.me
-
-// DDNS5 : https://ddns5.com
-// Submitted by Cameron Elliott <cameron@cameronelliott.com>
-ddns5.com
-
-// Debian : https://www.debian.org/
-// Submitted by Peter Palfrader / Debian Sysadmin Team <dsa-publicsuffixlist@debian.org>
-debian.net
-
-// Deno Land Inc : https://deno.com/
-// Submitted by Luca Casonato <hostmaster@deno.com>
-deno.dev
-deno-staging.dev
-
-// deSEC : https://desec.io/
-// Submitted by Peter Thomassen <peter@desec.io>
-dedyn.io
-
-// Deta: https://www.deta.sh/
-// Submitted by Aavash Shrestha <aavash@deta.sh>
-deta.app
-deta.dev
-
-// Diher Solutions : https://diher.solutions
-// Submitted by Didi Hermawan <mail@diher.solutions>
-*.rss.my.id
-*.diher.solutions
-
-// Discord Inc : https://discord.com
-// Submitted by Sahn Lam <slam@discordapp.com>
-discordsays.com
-discordsez.com
-
-// DNS Africa Ltd https://dns.business
-// Submitted by Calvin Browne <calvin@dns.business>
-jozi.biz
-
-// DNShome : https://www.dnshome.de/
-// Submitted by Norbert Auler <mail@dnshome.de>
-dnshome.de
-
-// DotArai : https://www.dotarai.com/
-// Submitted by Atsadawat Netcharadsang <atsadawat@dotarai.co.th>
-online.th
-shop.th
-
-// DrayTek Corp. : https://www.draytek.com/
-// Submitted by Paul Fang <mis@draytek.com>
-drayddns.com
-
-// DreamCommerce : https://shoper.pl/
-// Submitted by Konrad Kotarba <konrad.kotarba@dreamcommerce.com>
-shoparena.pl
-
-// DreamHost : http://www.dreamhost.com/
-// Submitted by Andrew Farmer <andrew.farmer@dreamhost.com>
-dreamhosters.com
-
-// Drobo : http://www.drobo.com/
-// Submitted by Ricardo Padilha <rpadilha@drobo.com>
-mydrobo.com
-
-// Drud Holdings, LLC. : https://www.drud.com/
-// Submitted by Kevin Bridges <kevin@drud.com>
-drud.io
-drud.us
-
-// DuckDNS : http://www.duckdns.org/
-// Submitted by Richard Harper <richard@duckdns.org>
-duckdns.org
-
-// Bip : https://bip.sh
-// Submitted by Joel Kennedy <joel@bip.sh>
-bip.sh
-
-// bitbridge.net : Submitted by Craig Welch, abeliidev@gmail.com
-bitbridge.net
-
-// dy.fi : http://dy.fi/
-// Submitted by Heikki Hannikainen <hessu@hes.iki.fi>
-dy.fi
-tunk.org
-
-// DynDNS.com : http://www.dyndns.com/services/dns/dyndns/
-dyndns-at-home.com
-dyndns-at-work.com
-dyndns-blog.com
-dyndns-free.com
-dyndns-home.com
-dyndns-ip.com
-dyndns-mail.com
-dyndns-office.com
-dyndns-pics.com
-dyndns-remote.com
-dyndns-server.com
-dyndns-web.com
-dyndns-wiki.com
-dyndns-work.com
-dyndns.biz
-dyndns.info
-dyndns.org
-dyndns.tv
-at-band-camp.net
-ath.cx
-barrel-of-knowledge.info
-barrell-of-knowledge.info
-better-than.tv
-blogdns.com
-blogdns.net
-blogdns.org
-blogsite.org
-boldlygoingnowhere.org
-broke-it.net
-buyshouses.net
-cechire.com
-dnsalias.com
-dnsalias.net
-dnsalias.org
-dnsdojo.com
-dnsdojo.net
-dnsdojo.org
-does-it.net
-doesntexist.com
-doesntexist.org
-dontexist.com
-dontexist.net
-dontexist.org
-doomdns.com
-doomdns.org
-dvrdns.org
-dyn-o-saur.com
-dynalias.com
-dynalias.net
-dynalias.org
-dynathome.net
-dyndns.ws
-endofinternet.net
-endofinternet.org
-endoftheinternet.org
-est-a-la-maison.com
-est-a-la-masion.com
-est-le-patron.com
-est-mon-blogueur.com
-for-better.biz
-for-more.biz
-for-our.info
-for-some.biz
-for-the.biz
-forgot.her.name
-forgot.his.name
-from-ak.com
-from-al.com
-from-ar.com
-from-az.net
-from-ca.com
-from-co.net
-from-ct.com
-from-dc.com
-from-de.com
-from-fl.com
-from-ga.com
-from-hi.com
-from-ia.com
-from-id.com
-from-il.com
-from-in.com
-from-ks.com
-from-ky.com
-from-la.net
-from-ma.com
-from-md.com
-from-me.org
-from-mi.com
-from-mn.com
-from-mo.com
-from-ms.com
-from-mt.com
-from-nc.com
-from-nd.com
-from-ne.com
-from-nh.com
-from-nj.com
-from-nm.com
-from-nv.com
-from-ny.net
-from-oh.com
-from-ok.com
-from-or.com
-from-pa.com
-from-pr.com
-from-ri.com
-from-sc.com
-from-sd.com
-from-tn.com
-from-tx.com
-from-ut.com
-from-va.com
-from-vt.com
-from-wa.com
-from-wi.com
-from-wv.com
-from-wy.com
-ftpaccess.cc
-fuettertdasnetz.de
-game-host.org
-game-server.cc
-getmyip.com
-gets-it.net
-go.dyndns.org
-gotdns.com
-gotdns.org
-groks-the.info
-groks-this.info
-ham-radio-op.net
-here-for-more.info
-hobby-site.com
-hobby-site.org
-home.dyndns.org
-homedns.org
-homeftp.net
-homeftp.org
-homeip.net
-homelinux.com
-homelinux.net
-homelinux.org
-homeunix.com
-homeunix.net
-homeunix.org
-iamallama.com
-in-the-band.net
-is-a-anarchist.com
-is-a-blogger.com
-is-a-bookkeeper.com
-is-a-bruinsfan.org
-is-a-bulls-fan.com
-is-a-candidate.org
-is-a-caterer.com
-is-a-celticsfan.org
-is-a-chef.com
-is-a-chef.net
-is-a-chef.org
-is-a-conservative.com
-is-a-cpa.com
-is-a-cubicle-slave.com
-is-a-democrat.com
-is-a-designer.com
-is-a-doctor.com
-is-a-financialadvisor.com
-is-a-geek.com
-is-a-geek.net
-is-a-geek.org
-is-a-green.com
-is-a-guru.com
-is-a-hard-worker.com
-is-a-hunter.com
-is-a-knight.org
-is-a-landscaper.com
-is-a-lawyer.com
-is-a-liberal.com
-is-a-libertarian.com
-is-a-linux-user.org
-is-a-llama.com
-is-a-musician.com
-is-a-nascarfan.com
-is-a-nurse.com
-is-a-painter.com
-is-a-patsfan.org
-is-a-personaltrainer.com
-is-a-photographer.com
-is-a-player.com
-is-a-republican.com
-is-a-rockstar.com
-is-a-socialist.com
-is-a-soxfan.org
-is-a-student.com
-is-a-teacher.com
-is-a-techie.com
-is-a-therapist.com
-is-an-accountant.com
-is-an-actor.com
-is-an-actress.com
-is-an-anarchist.com
-is-an-artist.com
-is-an-engineer.com
-is-an-entertainer.com
-is-by.us
-is-certified.com
-is-found.org
-is-gone.com
-is-into-anime.com
-is-into-cars.com
-is-into-cartoons.com
-is-into-games.com
-is-leet.com
-is-lost.org
-is-not-certified.com
-is-saved.org
-is-slick.com
-is-uberleet.com
-is-very-bad.org
-is-very-evil.org
-is-very-good.org
-is-very-nice.org
-is-very-sweet.org
-is-with-theband.com
-isa-geek.com
-isa-geek.net
-isa-geek.org
-isa-hockeynut.com
-issmarterthanyou.com
-isteingeek.de
-istmein.de
-kicks-ass.net
-kicks-ass.org
-knowsitall.info
-land-4-sale.us
-lebtimnetz.de
-leitungsen.de
-likes-pie.com
-likescandy.com
-merseine.nu
-mine.nu
-misconfused.org
-mypets.ws
-myphotos.cc
-neat-url.com
-office-on-the.net
-on-the-web.tv
-podzone.net
-podzone.org
-readmyblog.org
-saves-the-whales.com
-scrapper-site.net
-scrapping.cc
-selfip.biz
-selfip.com
-selfip.info
-selfip.net
-selfip.org
-sells-for-less.com
-sells-for-u.com
-sells-it.net
-sellsyourhome.org
-servebbs.com
-servebbs.net
-servebbs.org
-serveftp.net
-serveftp.org
-servegame.org
-shacknet.nu
-simple-url.com
-space-to-rent.com
-stuff-4-sale.org
-stuff-4-sale.us
-teaches-yoga.com
-thruhere.net
-traeumtgerade.de
-webhop.biz
-webhop.info
-webhop.net
-webhop.org
-worse-than.tv
-writesthisblog.com
-
-// ddnss.de : https://www.ddnss.de/
-// Submitted by Robert Niedziela <webmaster@ddnss.de>
-ddnss.de
-dyn.ddnss.de
-dyndns.ddnss.de
-dyndns1.de
-dyn-ip24.de
-home-webserver.de
-dyn.home-webserver.de
-myhome-server.de
-ddnss.org
-
-// Definima : http://www.definima.com/
-// Submitted by Maxence Bitterli <maxence@definima.com>
-definima.net
-definima.io
-
-// DigitalOcean App Platform : https://www.digitalocean.com/products/app-platform/
-// Submitted by Braxton Huggins <psl-maintainers@digitalocean.com>
-ondigitalocean.app
-
-// DigitalOcean Spaces : https://www.digitalocean.com/products/spaces/
-// Submitted by Robin H. Johnson <psl-maintainers@digitalocean.com>
-*.digitaloceanspaces.com
-
-// dnstrace.pro : https://dnstrace.pro/
-// Submitted by Chris Partridge <chris@partridge.tech>
-bci.dnstrace.pro
-
-// Dynu.com : https://www.dynu.com/
-// Submitted by Sue Ye <sue@dynu.com>
-ddnsfree.com
-ddnsgeek.com
-giize.com
-gleeze.com
-kozow.com
-loseyourip.com
-ooguy.com
-theworkpc.com
-casacam.net
-dynu.net
-accesscam.org
-camdvr.org
-freeddns.org
-mywire.org
-webredirect.org
-myddns.rocks
-blogsite.xyz
-
-// dynv6 : https://dynv6.com
-// Submitted by Dominik Menke <dom@digineo.de>
-dynv6.net
-
-// E4YOU spol. s.r.o. : https://e4you.cz/
-// Submitted by Vladimir Dudr <info@e4you.cz>
-e4.cz
-
-// eero : https://eero.com/
-// Submitted by Yue Kang <eero-dynamic-dns@amazon.com>
-eero.online
-eero-stage.online
-
-// Elementor : Elementor Ltd.
-// Submitted by Anton Barkan <antonb@elementor.com>
-elementor.cloud
-elementor.cool
-
-// En root‽ : https://en-root.org
-// Submitted by Emmanuel Raviart <emmanuel@raviart.com>
-en-root.fr
-
-// Enalean SAS: https://www.enalean.com
-// Submitted by Thomas Cottier <thomas.cottier@enalean.com>
-mytuleap.com
-tuleap-partners.com
-
-// Encoretivity AB: https://encore.dev
-// Submitted by André Eriksson <andre@encore.dev>
-encr.app
-encoreapi.com
-
-// ECG Robotics, Inc: https://ecgrobotics.org
-// Submitted by <frc1533@ecgrobotics.org>
-onred.one
-staging.onred.one
-
-// encoway GmbH : https://www.encoway.de
-// Submitted by Marcel Daus <cloudops@encoway.de>
-eu.encoway.cloud
-
-// EU.org https://eu.org/
-// Submitted by Pierre Beyssac <hostmaster@eu.org>
-eu.org
-al.eu.org
-asso.eu.org
-at.eu.org
-au.eu.org
-be.eu.org
-bg.eu.org
-ca.eu.org
-cd.eu.org
-ch.eu.org
-cn.eu.org
-cy.eu.org
-cz.eu.org
-de.eu.org
-dk.eu.org
-edu.eu.org
-ee.eu.org
-es.eu.org
-fi.eu.org
-fr.eu.org
-gr.eu.org
-hr.eu.org
-hu.eu.org
-ie.eu.org
-il.eu.org
-in.eu.org
-int.eu.org
-is.eu.org
-it.eu.org
-jp.eu.org
-kr.eu.org
-lt.eu.org
-lu.eu.org
-lv.eu.org
-mc.eu.org
-me.eu.org
-mk.eu.org
-mt.eu.org
-my.eu.org
-net.eu.org
-ng.eu.org
-nl.eu.org
-no.eu.org
-nz.eu.org
-paris.eu.org
-pl.eu.org
-pt.eu.org
-q-a.eu.org
-ro.eu.org
-ru.eu.org
-se.eu.org
-si.eu.org
-sk.eu.org
-tr.eu.org
-uk.eu.org
-us.eu.org
-
-// Eurobyte : https://eurobyte.ru
-// Submitted by Evgeniy Subbotin <e.subbotin@eurobyte.ru>
-eurodir.ru
-
-// Evennode : http://www.evennode.com/
-// Submitted by Michal Kralik <support@evennode.com>
-eu-1.evennode.com
-eu-2.evennode.com
-eu-3.evennode.com
-eu-4.evennode.com
-us-1.evennode.com
-us-2.evennode.com
-us-3.evennode.com
-us-4.evennode.com
-
-// eDirect Corp. : https://hosting.url.com.tw/
-// Submitted by C.S. chang <cschang@corp.url.com.tw>
-twmail.cc
-twmail.net
-twmail.org
-mymailer.com.tw
-url.tw
-
-// Fabrica Technologies, Inc. : https://www.fabrica.dev/
-// Submitted by Eric Jiang <eric@fabrica.dev>
-onfabrica.com
-
-// Facebook, Inc.
-// Submitted by Peter Ruibal <public-suffix@fb.com>
-apps.fbsbx.com
-
-// FAITID : https://faitid.org/
-// Submitted by Maxim Alzoba <tech.contact@faitid.org>
-// https://www.flexireg.net/stat_info
-ru.net
-adygeya.ru
-bashkiria.ru
-bir.ru
-cbg.ru
-com.ru
-dagestan.ru
-grozny.ru
-kalmykia.ru
-kustanai.ru
-marine.ru
-mordovia.ru
-msk.ru
-mytis.ru
-nalchik.ru
-nov.ru
-pyatigorsk.ru
-spb.ru
-vladikavkaz.ru
-vladimir.ru
-abkhazia.su
-adygeya.su
-aktyubinsk.su
-arkhangelsk.su
-armenia.su
-ashgabad.su
-azerbaijan.su
-balashov.su
-bashkiria.su
-bryansk.su
-bukhara.su
-chimkent.su
-dagestan.su
-east-kazakhstan.su
-exnet.su
-georgia.su
-grozny.su
-ivanovo.su
-jambyl.su
-kalmykia.su
-kaluga.su
-karacol.su
-karaganda.su
-karelia.su
-khakassia.su
-krasnodar.su
-kurgan.su
-kustanai.su
-lenug.su
-mangyshlak.su
-mordovia.su
-msk.su
-murmansk.su
-nalchik.su
-navoi.su
-north-kazakhstan.su
-nov.su
-obninsk.su
-penza.su
-pokrovsk.su
-sochi.su
-spb.su
-tashkent.su
-termez.su
-togliatti.su
-troitsk.su
-tselinograd.su
-tula.su
-tuva.su
-vladikavkaz.su
-vladimir.su
-vologda.su
-
-// Fancy Bits, LLC : http://getchannels.com
-// Submitted by Aman Gupta <aman@getchannels.com>
-channelsdvr.net
-u.channelsdvr.net
-
-// Fastly Inc. : http://www.fastly.com/
-// Submitted by Fastly Security <security@fastly.com>
-edgecompute.app
-fastly-terrarium.com
-fastlylb.net
-map.fastlylb.net
-freetls.fastly.net
-map.fastly.net
-a.prod.fastly.net
-global.prod.fastly.net
-a.ssl.fastly.net
-b.ssl.fastly.net
-global.ssl.fastly.net
-
-// FASTVPS EESTI OU : https://fastvps.ru/
-// Submitted by Likhachev Vasiliy <lihachev@fastvps.ru>
-fastvps-server.com
-fastvps.host
-myfast.host
-fastvps.site
-myfast.space
-
-// Fedora : https://fedoraproject.org/
-// submitted by Patrick Uiterwijk <puiterwijk@fedoraproject.org>
-fedorainfracloud.org
-fedorapeople.org
-cloud.fedoraproject.org
-app.os.fedoraproject.org
-app.os.stg.fedoraproject.org
-
-// FearWorks Media Ltd. : https://fearworksmedia.co.uk
-// submitted by Keith Fairley <domains@fearworksmedia.co.uk>
-conn.uk
-copro.uk
-hosp.uk
-
-// Fermax : https://fermax.com/
-// submitted by Koen Van Isterdael <k.vanisterdael@fermax.be>
-mydobiss.com
-
-// FH Muenster : https://www.fh-muenster.de
-// Submitted by Robin Naundorf <r.naundorf@fh-muenster.de>
-fh-muenster.io
-
-// Filegear Inc. : https://www.filegear.com
-// Submitted by Jason Zhu <jason@owtware.com>
-filegear.me
-filegear-au.me
-filegear-de.me
-filegear-gb.me
-filegear-ie.me
-filegear-jp.me
-filegear-sg.me
-
-// Firebase, Inc.
-// Submitted by Chris Raynor <chris@firebase.com>
-firebaseapp.com
-
-// Firewebkit : https://www.firewebkit.com
-// Submitted by Majid Qureshi <mqureshi@amrayn.com>
-fireweb.app
-
-// FLAP : https://www.flap.cloud
-// Submitted by Louis Chemineau <louis@chmn.me>
-flap.id
-
-// FlashDrive : https://flashdrive.io
-// Submitted by Eric Chan <support@flashdrive.io>
-onflashdrive.app
-fldrv.com
-
-// fly.io: https://fly.io
-// Submitted by Kurt Mackey <kurt@fly.io>
-fly.dev
-edgeapp.net
-shw.io
-
-// Flynn : https://flynn.io
-// Submitted by Jonathan Rudenberg <jonathan@flynn.io>
-flynnhosting.net
-
-// Forgerock : https://www.forgerock.com
-// Submitted by Roderick Parr <roderick.parr@forgerock.com>
-forgeblocks.com
-id.forgerock.io
-
-// Framer : https://www.framer.com
-// Submitted by Koen Rouwhorst <koenrh@framer.com>
-framer.app
-framercanvas.com
-
-// Frusky MEDIA&PR : https://www.frusky.de
-// Submitted by Victor Pupynin <hallo@frusky.de>
-*.frusky.de
-
-// RavPage : https://www.ravpage.co.il
-// Submitted by Roni Horowitz <roni@responder.co.il>
-ravpage.co.il
-
-// Frederik Braun https://frederik-braun.com
-// Submitted by Frederik Braun <fb@frederik-braun.com>
-0e.vc
-
-// Freebox : http://www.freebox.fr
-// Submitted by Romain Fliedel <rfliedel@freebox.fr>
-freebox-os.com
-freeboxos.com
-fbx-os.fr
-fbxos.fr
-freebox-os.fr
-freeboxos.fr
-
-// freedesktop.org : https://www.freedesktop.org
-// Submitted by Daniel Stone <daniel@fooishbar.org>
-freedesktop.org
-
-// freemyip.com : https://freemyip.com
-// Submitted by Cadence <contact@freemyip.com>
-freemyip.com
-
-// FunkFeuer - Verein zur Förderung freier Netze : https://www.funkfeuer.at
-// Submitted by Daniel A. Maierhofer <vorstand@funkfeuer.at>
-wien.funkfeuer.at
-
-// Futureweb OG : http://www.futureweb.at
-// Submitted by Andreas Schnederle-Wagner <schnederle@futureweb.at>
-*.futurecms.at
-*.ex.futurecms.at
-*.in.futurecms.at
-futurehosting.at
-futuremailing.at
-*.ex.ortsinfo.at
-*.kunden.ortsinfo.at
-*.statics.cloud
-
-// GDS : https://www.gov.uk/service-manual/technology/managing-domain-names
-// Submitted by Stephen Ford <hostmaster@digital.cabinet-office.gov.uk>
-independent-commission.uk
-independent-inquest.uk
-independent-inquiry.uk
-independent-panel.uk
-independent-review.uk
-public-inquiry.uk
-royal-commission.uk
-campaign.gov.uk
-service.gov.uk
-
-// CDDO : https://www.gov.uk/guidance/get-an-api-domain-on-govuk
-// Submitted by Jamie Tanna <jamie.tanna@digital.cabinet-office.gov.uk>
-api.gov.uk
-
-// Gehirn Inc. : https://www.gehirn.co.jp/
-// Submitted by Kohei YOSHIDA <tech@gehirn.co.jp>
-gehirn.ne.jp
-usercontent.jp
-
-// Gentlent, Inc. : https://www.gentlent.com
-// Submitted by Tom Klein <tom@gentlent.com>
-gentapps.com
-gentlentapis.com
-lab.ms
-cdn-edges.net
-
-// Ghost Foundation : https://ghost.org
-// Submitted by Matt Hanley <security@ghost.org>
-ghost.io
-
-// GignoSystemJapan: http://gsj.bz
-// Submitted by GignoSystemJapan <kakutou-ec@gsj.bz>
-gsj.bz
-
-// GitHub, Inc.
-// Submitted by Patrick Toomey <security@github.com>
-githubusercontent.com
-githubpreview.dev
-github.io
-
-// GitLab, Inc.
-// Submitted by Alex Hanselka <alex@gitlab.com>
-gitlab.io
-
-// Gitplac.si - https://gitplac.si
-// Submitted by Aljaž Starc <me@aljaxus.eu>
-gitapp.si
-gitpage.si
-
-// Glitch, Inc : https://glitch.com
-// Submitted by Mads Hartmann <mads@glitch.com>
-glitch.me
-
-// Global NOG Alliance : https://nogalliance.org/
-// Submitted by Sander Steffann <sander@nogalliance.org>
-nog.community
-
-// Globe Hosting SRL : https://www.globehosting.com/
-// Submitted by Gavin Brown <gavin.brown@centralnic.com>
-co.ro
-shop.ro
-
-// GMO Pepabo, Inc. : https://pepabo.com/
-// Submitted by Hosting Div <admin@pepabo.com>
-lolipop.io
-angry.jp
-babyblue.jp
-babymilk.jp
-backdrop.jp
-bambina.jp
-bitter.jp
-blush.jp
-boo.jp
-boy.jp
-boyfriend.jp
-but.jp
-candypop.jp
-capoo.jp
-catfood.jp
-cheap.jp
-chicappa.jp
-chillout.jp
-chips.jp
-chowder.jp
-chu.jp
-ciao.jp
-cocotte.jp
-coolblog.jp
-cranky.jp
-cutegirl.jp
-daa.jp
-deca.jp
-deci.jp
-digick.jp
-egoism.jp
-fakefur.jp
-fem.jp
-flier.jp
-floppy.jp
-fool.jp
-frenchkiss.jp
-girlfriend.jp
-girly.jp
-gloomy.jp
-gonna.jp
-greater.jp
-hacca.jp
-heavy.jp
-her.jp
-hiho.jp
-hippy.jp
-holy.jp
-hungry.jp
-icurus.jp
-itigo.jp
-jellybean.jp
-kikirara.jp
-kill.jp
-kilo.jp
-kuron.jp
-littlestar.jp
-lolitapunk.jp
-lomo.jp
-lovepop.jp
-lovesick.jp
-main.jp
-mods.jp
-mond.jp
-mongolian.jp
-moo.jp
-namaste.jp
-nikita.jp
-nobushi.jp
-noor.jp
-oops.jp
-parallel.jp
-parasite.jp
-pecori.jp
-peewee.jp
-penne.jp
-pepper.jp
-perma.jp
-pigboat.jp
-pinoko.jp
-punyu.jp
-pupu.jp
-pussycat.jp
-pya.jp
-raindrop.jp
-readymade.jp
-sadist.jp
-schoolbus.jp
-secret.jp
-staba.jp
-stripper.jp
-sub.jp
-sunnyday.jp
-thick.jp
-tonkotsu.jp
-under.jp
-upper.jp
-velvet.jp
-verse.jp
-versus.jp
-vivian.jp
-watson.jp
-weblike.jp
-whitesnow.jp
-zombie.jp
-heteml.net
-
-// GOV.UK Platform as a Service : https://www.cloud.service.gov.uk/
-// Submitted by Tom Whitwell <gov-uk-paas-support@digital.cabinet-office.gov.uk>
-cloudapps.digital
-london.cloudapps.digital
-
-// GOV.UK Pay : https://www.payments.service.gov.uk/
-// Submitted by Richard Baker <richard.baker@digital.cabinet-office.gov.uk>
-pymnt.uk
-
-// UKHomeOffice : https://www.gov.uk/government/organisations/home-office
-// Submitted by Jon Shanks <jon.shanks@digital.homeoffice.gov.uk>
-homeoffice.gov.uk
-
-// GlobeHosting, Inc.
-// Submitted by Zoltan Egresi <egresi@globehosting.com>
-ro.im
-
-// GoIP DNS Services : http://www.goip.de
-// Submitted by Christian Poulter <milchstrasse@goip.de>
-goip.de
-
-// Google, Inc.
-// Submitted by Eduardo Vela <evn@google.com>
-run.app
-a.run.app
-web.app
-*.0emm.com
-appspot.com
-*.r.appspot.com
-codespot.com
-googleapis.com
-googlecode.com
-pagespeedmobilizer.com
-publishproxy.com
-withgoogle.com
-withyoutube.com
-*.gateway.dev
-cloud.goog
-translate.goog
-*.usercontent.goog
-cloudfunctions.net
-blogspot.ae
-blogspot.al
-blogspot.am
-blogspot.ba
-blogspot.be
-blogspot.bg
-blogspot.bj
-blogspot.ca
-blogspot.cf
-blogspot.ch
-blogspot.cl
-blogspot.co.at
-blogspot.co.id
-blogspot.co.il
-blogspot.co.ke
-blogspot.co.nz
-blogspot.co.uk
-blogspot.co.za
-blogspot.com
-blogspot.com.ar
-blogspot.com.au
-blogspot.com.br
-blogspot.com.by
-blogspot.com.co
-blogspot.com.cy
-blogspot.com.ee
-blogspot.com.eg
-blogspot.com.es
-blogspot.com.mt
-blogspot.com.ng
-blogspot.com.tr
-blogspot.com.uy
-blogspot.cv
-blogspot.cz
-blogspot.de
-blogspot.dk
-blogspot.fi
-blogspot.fr
-blogspot.gr
-blogspot.hk
-blogspot.hr
-blogspot.hu
-blogspot.ie
-blogspot.in
-blogspot.is
-blogspot.it
-blogspot.jp
-blogspot.kr
-blogspot.li
-blogspot.lt
-blogspot.lu
-blogspot.md
-blogspot.mk
-blogspot.mr
-blogspot.mx
-blogspot.my
-blogspot.nl
-blogspot.no
-blogspot.pe
-blogspot.pt
-blogspot.qa
-blogspot.re
-blogspot.ro
-blogspot.rs
-blogspot.ru
-blogspot.se
-blogspot.sg
-blogspot.si
-blogspot.sk
-blogspot.sn
-blogspot.td
-blogspot.tw
-blogspot.ug
-blogspot.vn
-
-// Goupile : https://goupile.fr
-// Submitted by Niels Martignene <hello@goupile.fr>
-goupile.fr
-
-// Group 53, LLC : https://www.group53.com
-// Submitted by Tyler Todd <noc@nova53.net>
-awsmppl.com
-
-// GünstigBestellen : https://günstigbestellen.de
-// Submitted by Furkan Akkoc <info@hendelzon.de>
-günstigbestellen.de
-günstigliefern.de
-
-// Hakaran group: http://hakaran.cz
-// Submitted by Arseniy Sokolov <security@hakaran.cz>
-fin.ci
-free.hr
-caa.li
-ua.rs
-conf.se
-
-// Handshake : https://handshake.org
-// Submitted by Mike Damm <md@md.vc>
-hs.zone
-hs.run
-
-// Hashbang : https://hashbang.sh
-hashbang.sh
-
-// Hasura : https://hasura.io
-// Submitted by Shahidh K Muhammed <shahidh@hasura.io>
-hasura.app
-hasura-app.io
-
-// Heilbronn University of Applied Sciences - Faculty Informatics (GitLab Pages): https://www.hs-heilbronn.de
-// Submitted by Richard Zowalla <mi-admin@hs-heilbronn.de>
-pages.it.hs-heilbronn.de
-
-// Hepforge : https://www.hepforge.org
-// Submitted by David Grellscheid <admin@hepforge.org>
-hepforge.org
-
-// Heroku : https://www.heroku.com/
-// Submitted by Tom Maher <tmaher@heroku.com>
-herokuapp.com
-herokussl.com
-
-// Hibernating Rhinos
-// Submitted by Oren Eini <oren@ravendb.net>
-ravendb.cloud
-myravendb.com
-ravendb.community
-ravendb.me
-development.run
-ravendb.run
-
-// home.pl S.A.: https://home.pl
-// Submitted by Krzysztof Wolski <krzysztof.wolski@home.eu>
-homesklep.pl
-
-// Hong Kong Productivity Council: https://www.hkpc.org/
-// Submitted by SECaaS Team <summchan@hkpc.org>
-secaas.hk
-
-// Hoplix : https://www.hoplix.com
-// Submitted by Danilo De Franco<info@hoplix.shop>
-hoplix.shop
-
-
-// HOSTBIP REGISTRY : https://www.hostbip.com/
-// Submitted by Atanunu Igbunuroghene <publicsuffixlist@hostbip.com>
-orx.biz
-biz.gl
-col.ng
-firm.ng
-gen.ng
-ltd.ng
-ngo.ng
-edu.scot
-sch.so
-org.yt
-
-// HostyHosting (hostyhosting.com)
-hostyhosting.io
-
-// Häkkinen.fi
-// Submitted by Eero Häkkinen <Eero+psl@Häkkinen.fi>
-häkkinen.fi
-
-// Ici la Lune : http://www.icilalune.com/
-// Submitted by Simon Morvan <simon@icilalune.com>
-*.moonscale.io
-moonscale.net
-
-// iki.fi
-// Submitted by Hannu Aronsson <haa@iki.fi>
-iki.fi
-
-// Impertrix Solutions : <https://impertrixcdn.com>
-// Submitted by Zhixiang Zhao <csuite@impertrix.com>
-impertrixcdn.com
-impertrix.com
-
-// Incsub, LLC: https://incsub.com/
-// Submitted by Aaron Edwards <sysadmins@incsub.com>
-smushcdn.com
-wphostedmail.com
-wpmucdn.com
-tempurl.host
-wpmudev.host
-
-// Individual Network Berlin e.V. : https://www.in-berlin.de/
-// Submitted by Christian Seitz <chris@in-berlin.de>
-dyn-berlin.de
-in-berlin.de
-in-brb.de
-in-butter.de
-in-dsl.de
-in-dsl.net
-in-dsl.org
-in-vpn.de
-in-vpn.net
-in-vpn.org
-
-// info.at : http://www.info.at/
-biz.at
-info.at
-
-// info.cx : http://info.cx
-// Submitted by Jacob Slater <whois@igloo.to>
-info.cx
-
-// Interlegis : http://www.interlegis.leg.br
-// Submitted by Gabriel Ferreira <registrobr@interlegis.leg.br>
-ac.leg.br
-al.leg.br
-am.leg.br
-ap.leg.br
-ba.leg.br
-ce.leg.br
-df.leg.br
-es.leg.br
-go.leg.br
-ma.leg.br
-mg.leg.br
-ms.leg.br
-mt.leg.br
-pa.leg.br
-pb.leg.br
-pe.leg.br
-pi.leg.br
-pr.leg.br
-rj.leg.br
-rn.leg.br
-ro.leg.br
-rr.leg.br
-rs.leg.br
-sc.leg.br
-se.leg.br
-sp.leg.br
-to.leg.br
-
-// intermetrics GmbH : https://pixolino.com/
-// Submitted by Wolfgang Schwarz <admin@intermetrics.de>
-pixolino.com
-
-// Internet-Pro, LLP: https://netangels.ru/
-// Submitted by Vasiliy Sheredeko <piphon@gmail.com>
-na4u.ru
-
-// iopsys software solutions AB : https://iopsys.eu/
-// Submitted by Roman Azarenko <roman.azarenko@iopsys.eu>
-iopsys.se
-
-// IPiFony Systems, Inc. : https://www.ipifony.com/
-// Submitted by Matthew Hardeman <mhardeman@ipifony.com>
-ipifony.net
-
-// IServ GmbH : https://iserv.eu
-// Submitted by Kim-Alexander Brodowski <info@iserv.eu>
-mein-iserv.de
-schulserver.de
-test-iserv.de
-iserv.dev
-
-// I-O DATA DEVICE, INC. : http://www.iodata.com/
-// Submitted by Yuji Minagawa <domains-admin@iodata.jp>
-iobb.net
-
-// Jelastic, Inc. : https://jelastic.com/
-// Submitted by Ihor Kolodyuk <ik@jelastic.com>
-mel.cloudlets.com.au
-cloud.interhostsolutions.be
-users.scale.virtualcloud.com.br
-mycloud.by
-alp1.ae.flow.ch
-appengine.flow.ch
-es-1.axarnet.cloud
-diadem.cloud
-vip.jelastic.cloud
-jele.cloud
-it1.eur.aruba.jenv-aruba.cloud
-it1.jenv-aruba.cloud
-keliweb.cloud
-cs.keliweb.cloud
-oxa.cloud
-tn.oxa.cloud
-uk.oxa.cloud
-primetel.cloud
-uk.primetel.cloud
-ca.reclaim.cloud
-uk.reclaim.cloud
-us.reclaim.cloud
-ch.trendhosting.cloud
-de.trendhosting.cloud
-jele.club
-amscompute.com
-clicketcloud.com
-dopaas.com
-hidora.com
-paas.hosted-by-previder.com
-rag-cloud.hosteur.com
-rag-cloud-ch.hosteur.com
-jcloud.ik-server.com
-jcloud-ver-jpc.ik-server.com
-demo.jelastic.com
-kilatiron.com
-paas.massivegrid.com
-jed.wafaicloud.com
-lon.wafaicloud.com
-ryd.wafaicloud.com
-j.scaleforce.com.cy
-jelastic.dogado.eu
-fi.cloudplatform.fi
-demo.datacenter.fi
-paas.datacenter.fi
-jele.host
-mircloud.host
-paas.beebyte.io
-sekd1.beebyteapp.io
-jele.io
-cloud-fr1.unispace.io
-jc.neen.it
-cloud.jelastic.open.tim.it
-jcloud.kz
-upaas.kazteleport.kz
-cloudjiffy.net
-fra1-de.cloudjiffy.net
-west1-us.cloudjiffy.net
-jls-sto1.elastx.net
-jls-sto2.elastx.net
-jls-sto3.elastx.net
-faststacks.net
-fr-1.paas.massivegrid.net
-lon-1.paas.massivegrid.net
-lon-2.paas.massivegrid.net
-ny-1.paas.massivegrid.net
-ny-2.paas.massivegrid.net
-sg-1.paas.massivegrid.net
-jelastic.saveincloud.net
-nordeste-idc.saveincloud.net
-j.scaleforce.net
-jelastic.tsukaeru.net
-sdscloud.pl
-unicloud.pl
-mircloud.ru
-jelastic.regruhosting.ru
-enscaled.sg
-jele.site
-jelastic.team
-orangecloud.tn
-j.layershift.co.uk
-phx.enscaled.us
-mircloud.us
-
-// Jino : https://www.jino.ru
-// Submitted by Sergey Ulyashin <ulyashin@jino.ru>
-myjino.ru
-*.hosting.myjino.ru
-*.landing.myjino.ru
-*.spectrum.myjino.ru
-*.vps.myjino.ru
-
-// Jotelulu S.L. : https://jotelulu.com
-// Submitted by Daniel Fariña <ingenieria@jotelulu.com>
-jotelulu.cloud
-
-// Joyent : https://www.joyent.com/
-// Submitted by Brian Bennett <brian.bennett@joyent.com>
-*.triton.zone
-*.cns.joyent.com
-
-// JS.ORG : http://dns.js.org
-// Submitted by Stefan Keim <admin@js.org>
-js.org
-
-// KaasHosting : http://www.kaashosting.nl/
-// Submitted by Wouter Bakker <hostmaster@kaashosting.nl>
-kaas.gg
-khplay.nl
-
-// Kakao : https://www.kakaocorp.com/
-// Submitted by JaeYoong Lee <cec@kakaocorp.com>
-ktistory.com
-
-// Kapsi : https://kapsi.fi
-// Submitted by Tomi Juntunen <erani@kapsi.fi>
-kapsi.fi
-
-// Keyweb AG : https://www.keyweb.de
-// Submitted by Martin Dannehl <postmaster@keymachine.de>
-keymachine.de
-
-// KingHost : https://king.host
-// Submitted by Felipe Keller Braz <felipebraz@kinghost.com.br>
-kinghost.net
-uni5.net
-
-// KnightPoint Systems, LLC : http://www.knightpoint.com/
-// Submitted by Roy Keene <rkeene@knightpoint.com>
-knightpoint.systems
-
-// KoobinEvent, SL: https://www.koobin.com
-// Submitted by Iván Oliva <ivan.oliva@koobin.com>
-koobin.events
-
-// KUROKU LTD : https://kuroku.ltd/
-// Submitted by DisposaBoy <security@oya.to>
-oya.to
-
-// Katholieke Universiteit Leuven: https://www.kuleuven.be
-// Submitted by Abuse KU Leuven <abuse@kuleuven.be>
-kuleuven.cloud
-ezproxy.kuleuven.be
-
-// .KRD : http://nic.krd/data/krd/Registration%20Policy.pdf
-co.krd
-edu.krd
-
-// Krellian Ltd. : https://krellian.com
-// Submitted by Ben Francis <ben@krellian.com>
-krellian.net
-webthings.io
-
-// LCube - Professional hosting e.K. : https://www.lcube-webhosting.de
-// Submitted by Lars Laehn <info@lcube.de>
-git-repos.de
-lcube-server.de
-svn-repos.de
-
-// Leadpages : https://www.leadpages.net
-// Submitted by Greg Dallavalle <domains@leadpages.net>
-leadpages.co
-lpages.co
-lpusercontent.com
-
-// Lelux.fi : https://lelux.fi/
-// Submitted by Lelux Admin <publisuffix@lelux.site>
-lelux.site
-
-// Lifetime Hosting : https://Lifetime.Hosting/
-// Submitted by Mike Fillator <support@lifetime.hosting>
-co.business
-co.education
-co.events
-co.financial
-co.network
-co.place
-co.technology
-
-// Lightmaker Property Manager, Inc. : https://app.lmpm.com/
-// Submitted by Greg Holland <greg.holland@lmpm.com>
-app.lmpm.com
-
-// linkyard ldt: https://www.linkyard.ch/
-// Submitted by Mario Siegenthaler <mario.siegenthaler@linkyard.ch>
-linkyard.cloud
-linkyard-cloud.ch
-
-// Linode : https://linode.com
-// Submitted by <security@linode.com>
-members.linode.com
-*.nodebalancer.linode.com
-*.linodeobjects.com
-ip.linodeusercontent.com
-
-// LiquidNet Ltd : http://www.liquidnetlimited.com/
-// Submitted by Victor Velchev <admin@liquidnetlimited.com>
-we.bs
-
-// Localcert : https://localcert.dev
-// Submitted by Lann Martin <security@localcert.dev>
-*.user.localcert.dev
-
-// localzone.xyz
-// Submitted by Kenny Niehage <hello@yahe.sh>
-localzone.xyz
-
-// Log'in Line : https://www.loginline.com/
-// Submitted by Rémi Mach <remi.mach@loginline.com>
-loginline.app
-loginline.dev
-loginline.io
-loginline.services
-loginline.site
-
-// Lokalized : https://lokalized.nl
-// Submitted by Noah Taheij <noah@lokalized.nl>
-servers.run
-
-// Lõhmus Family, The
-// Submitted by Heiki Lõhmus <hostmaster at lohmus dot me>
-lohmus.me
-
-// LubMAN UMCS Sp. z o.o : https://lubman.pl/
-// Submitted by Ireneusz Maliszewski <ireneusz.maliszewski@lubman.pl>
-krasnik.pl
-leczna.pl
-lubartow.pl
-lublin.pl
-poniatowa.pl
-swidnik.pl
-
-// Lug.org.uk : https://lug.org.uk
-// Submitted by Jon Spriggs <admin@lug.org.uk>
-glug.org.uk
-lug.org.uk
-lugs.org.uk
-
-// Lukanet Ltd : https://lukanet.com
-// Submitted by Anton Avramov <register@lukanet.com>
-barsy.bg
-barsy.co.uk
-barsyonline.co.uk
-barsycenter.com
-barsyonline.com
-barsy.club
-barsy.de
-barsy.eu
-barsy.in
-barsy.info
-barsy.io
-barsy.me
-barsy.menu
-barsy.mobi
-barsy.net
-barsy.online
-barsy.org
-barsy.pro
-barsy.pub
-barsy.ro
-barsy.shop
-barsy.site
-barsy.support
-barsy.uk
-
-// Magento Commerce
-// Submitted by Damien Tournoud <dtournoud@magento.cloud>
-*.magentosite.cloud
-
-// May First - People Link : https://mayfirst.org/
-// Submitted by Jamie McClelland <info@mayfirst.org>
-mayfirst.info
-mayfirst.org
-
-// Mail.Ru Group : https://hb.cldmail.ru
-// Submitted by Ilya Zaretskiy <zaretskiy@corp.mail.ru>
-hb.cldmail.ru
-
-// Mail Transfer Platform : https://www.neupeer.com
-// Submitted by Li Hui <lihui@neupeer.com>
-cn.vu
-
-// Maze Play: https://www.mazeplay.com
-// Submitted by Adam Humpherys <adam@mws.dev>
-mazeplay.com
-
-// mcpe.me : https://mcpe.me
-// Submitted by Noa Heyl <hi@noa.dev>
-mcpe.me
-
-// McHost : https://mchost.ru
-// Submitted by Evgeniy Subbotin <e.subbotin@mchost.ru>
-mcdir.me
-mcdir.ru
-mcpre.ru
-vps.mcdir.ru
-
-// Mediatech : https://mediatech.by
-// Submitted by Evgeniy Kozhuhovskiy <ugenk@mediatech.by>
-mediatech.by
-mediatech.dev
-
-// Medicom Health : https://medicomhealth.com
-// Submitted by Michael Olson <molson@medicomhealth.com>
-hra.health
-
-// Memset hosting : https://www.memset.com
-// Submitted by Tom Whitwell <domains@memset.com>
-miniserver.com
-memset.net
-
-// MetaCentrum, CESNET z.s.p.o. : https://www.metacentrum.cz/en/
-// Submitted by Zdeněk Šustr <zdenek.sustr@cesnet.cz>
-*.cloud.metacentrum.cz
-custom.metacentrum.cz
-
-// MetaCentrum, CESNET z.s.p.o. : https://www.metacentrum.cz/en/
-// Submitted by Radim Janča <janca@cesnet.cz>
-flt.cloud.muni.cz
-usr.cloud.muni.cz
-
-// Meteor Development Group : https://www.meteor.com/hosting
-// Submitted by Pierre Carrier <pierre@meteor.com>
-meteorapp.com
-eu.meteorapp.com
-
-// Michau Enterprises Limited : http://www.co.pl/
-co.pl
-
-// Microsoft Corporation : http://microsoft.com
-// Submitted by Mitch Webster <miwebst@microsoft.com>
-*.azurecontainer.io
-azurewebsites.net
-azure-mobile.net
-cloudapp.net
-azurestaticapps.net
-centralus.azurestaticapps.net
-eastasia.azurestaticapps.net
-eastus2.azurestaticapps.net
-westeurope.azurestaticapps.net
-westus2.azurestaticapps.net
-
-// minion.systems : http://minion.systems
-// Submitted by Robert Böttinger <r@minion.systems>
-csx.cc
-
-// Mintere : https://mintere.com/
-// Submitted by Ben Aubin <security@mintere.com>
-mintere.site
-
-// MobileEducation, LLC : https://joinforte.com
-// Submitted by Grayson Martin <grayson.martin@mobileeducation.us>
-forte.id
-
-// Mozilla Corporation : https://mozilla.com
-// Submitted by Ben Francis <bfrancis@mozilla.com>
-mozilla-iot.org
-
-// Mozilla Foundation : https://mozilla.org/
-// Submitted by glob <glob@mozilla.com>
-bmoattachments.org
-
-// MSK-IX : https://www.msk-ix.ru/
-// Submitted by Khannanov Roman <r.khannanov@msk-ix.ru>
-net.ru
-org.ru
-pp.ru
-
-// Mythic Beasts : https://www.mythic-beasts.com
-// Submitted by Paul Cammish <kelduum@mythic-beasts.com>
-hostedpi.com
-customer.mythic-beasts.com
-caracal.mythic-beasts.com
-fentiger.mythic-beasts.com
-lynx.mythic-beasts.com
-ocelot.mythic-beasts.com
-oncilla.mythic-beasts.com
-onza.mythic-beasts.com
-sphinx.mythic-beasts.com
-vs.mythic-beasts.com
-x.mythic-beasts.com
-yali.mythic-beasts.com
-cust.retrosnub.co.uk
-
-// Nabu Casa : https://www.nabucasa.com
-// Submitted by Paulus Schoutsen <infra@nabucasa.com>
-ui.nabu.casa
-
-// Names.of.London : https://names.of.london/
-// Submitted by James Stevens <registry[at]names.of.london> or <publiclist[at]jrcs.net>
-pony.club
-of.fashion
-in.london
-of.london
-from.marketing
-with.marketing
-for.men
-repair.men
-and.mom
-for.mom
-for.one
-under.one
-for.sale
-that.win
-from.work
-to.work
-
-// Net at Work Gmbh : https://www.netatwork.de
-// Submitted by Jan Jaeschke <jan.jaeschke@netatwork.de>
-cloud.nospamproxy.com
-
-// Netlify : https://www.netlify.com
-// Submitted by Jessica Parsons <jessica@netlify.com>
-netlify.app
-
-// Neustar Inc.
-// Submitted by Trung Tran <Trung.Tran@neustar.biz>
-4u.com
-
-// ngrok : https://ngrok.com/
-// Submitted by Alan Shreve <alan@ngrok.com>
-ngrok.io
-
-// Nimbus Hosting Ltd. : https://www.nimbushosting.co.uk/
-// Submitted by Nicholas Ford <nick@nimbushosting.co.uk>
-nh-serv.co.uk
-
-// NFSN, Inc. : https://www.NearlyFreeSpeech.NET/
-// Submitted by Jeff Wheelhouse <support@nearlyfreespeech.net>
-nfshost.com
-
-// Noop : https://noop.app
-// Submitted by Nathaniel Schweinberg <noop@rearc.io>
-*.developer.app
-noop.app
-
-// Northflank Ltd. : https://northflank.com/
-// Submitted by Marco Suter <marco@northflank.com>
-*.northflank.app
-*.build.run
-*.code.run
-*.database.run
-*.migration.run
-
-// Noticeable : https://noticeable.io
-// Submitted by Laurent Pellegrino <security@noticeable.io>
-noticeable.news
-
-// Now-DNS : https://now-dns.com
-// Submitted by Steve Russell <steve@now-dns.com>
-dnsking.ch
-mypi.co
-n4t.co
-001www.com
-ddnslive.com
-myiphost.com
-forumz.info
-16-b.it
-32-b.it
-64-b.it
-soundcast.me
-tcp4.me
-dnsup.net
-hicam.net
-now-dns.net
-ownip.net
-vpndns.net
-dynserv.org
-now-dns.org
-x443.pw
-now-dns.top
-ntdll.top
-freeddns.us
-crafting.xyz
-zapto.xyz
-
-// nsupdate.info : https://www.nsupdate.info/
-// Submitted by Thomas Waldmann <info@nsupdate.info>
-nsupdate.info
-nerdpol.ovh
-
-// No-IP.com : https://noip.com/
-// Submitted by Deven Reza <publicsuffixlist@noip.com>
-blogsyte.com
-brasilia.me
-cable-modem.org
-ciscofreak.com
-collegefan.org
-couchpotatofries.org
-damnserver.com
-ddns.me
-ditchyourip.com
-dnsfor.me
-dnsiskinky.com
-dvrcam.info
-dynns.com
-eating-organic.net
-fantasyleague.cc
-geekgalaxy.com
-golffan.us
-health-carereform.com
-homesecuritymac.com
-homesecuritypc.com
-hopto.me
-ilovecollege.info
-loginto.me
-mlbfan.org
-mmafan.biz
-myactivedirectory.com
-mydissent.net
-myeffect.net
-mymediapc.net
-mypsx.net
-mysecuritycamera.com
-mysecuritycamera.net
-mysecuritycamera.org
-net-freaks.com
-nflfan.org
-nhlfan.net
-no-ip.ca
-no-ip.co.uk
-no-ip.net
-noip.us
-onthewifi.com
-pgafan.net
-point2this.com
-pointto.us
-privatizehealthinsurance.net
-quicksytes.com
-read-books.org
-securitytactics.com
-serveexchange.com
-servehumour.com
-servep2p.com
-servesarcasm.com
-stufftoread.com
-ufcfan.org
-unusualperson.com
-workisboring.com
-3utilities.com
-bounceme.net
-ddns.net
-ddnsking.com
-gotdns.ch
-hopto.org
-myftp.biz
-myftp.org
-myvnc.com
-no-ip.biz
-no-ip.info
-no-ip.org
-noip.me
-redirectme.net
-servebeer.com
-serveblog.net
-servecounterstrike.com
-serveftp.com
-servegame.com
-servehalflife.com
-servehttp.com
-serveirc.com
-serveminecraft.net
-servemp3.com
-servepics.com
-servequake.com
-sytes.net
-webhop.me
-zapto.org
-
-// NodeArt : https://nodeart.io
-// Submitted by Konstantin Nosov <Nosov@nodeart.io>
-stage.nodeart.io
-
-// Nucleos Inc. : https://nucleos.com
-// Submitted by Piotr Zduniak <piotr@nucleos.com>
-pcloud.host
-
-// NYC.mn : http://www.information.nyc.mn
-// Submitted by Matthew Brown <mattbrown@nyc.mn>
-nyc.mn
-
-// Observable, Inc. : https://observablehq.com
-// Submitted by Mike Bostock <dns@observablehq.com>
-static.observableusercontent.com
-
-// Octopodal Solutions, LLC. : https://ulterius.io/
-// Submitted by Andrew Sampson <andrew@ulterius.io>
-cya.gg
-
-// OMG.LOL : <https://omg.lol>
-// Submitted by Adam Newbold <adam@omg.lol>
-omg.lol
-
-// Omnibond Systems, LLC. : https://www.omnibond.com
-// Submitted by Cole Estep <cole@omnibond.com>
-cloudycluster.net
-
-// OmniWe Limited: https://omniwe.com
-// Submitted by Vicary Archangel <vicary@omniwe.com>
-omniwe.site
-
-// One.com: https://www.one.com/
-// Submitted by Jacob Bunk Nielsen <jbn@one.com>
-service.one
-
-// One Fold Media : http://www.onefoldmedia.com/
-// Submitted by Eddie Jones <eddie@onefoldmedia.com>
-nid.io
-
-// Open Social : https://www.getopensocial.com/
-// Submitted by Alexander Varwijk <security@getopensocial.com>
-opensocial.site
-
-// OpenCraft GmbH : http://opencraft.com/
-// Submitted by Sven Marnach <sven@opencraft.com>
-opencraft.hosting
-
-// OpenResearch GmbH: https://openresearch.com/
-// Submitted by Philipp Schmid <ops@openresearch.com>
-orsites.com
-
-// Opera Software, A.S.A.
-// Submitted by Yngve Pettersen <yngve@opera.com>
-operaunite.com
-
-// Orange : https://www.orange.com
-// Submitted by Alexandre Linte <alexandre.linte@orange.com>
-tech.orange
-
-// Oursky Limited : https://authgear.com/, https://skygear.io/
-// Submitted by Authgear Team <hello@authgear.com>, Skygear Developer <hello@skygear.io>
-authgear-staging.com
-authgearapps.com
-skygearapp.com
-
-// OutSystems
-// Submitted by Duarte Santos <domain-admin@outsystemscloud.com>
-outsystemscloud.com
-
-// OVHcloud: https://ovhcloud.com
-// Submitted by Vincent Cassé <vincent.casse@ovhcloud.com>
-*.webpaas.ovh.net
-*.hosting.ovh.net
-
-// OwnProvider GmbH: http://www.ownprovider.com
-// Submitted by Jan Moennich <jan.moennich@ownprovider.com>
-ownprovider.com
-own.pm
-
-// OwO : https://whats-th.is/
-// Submitted by Dean Sheather <dean@deansheather.com>
-*.owo.codes
-
-// OX : http://www.ox.rs
-// Submitted by Adam Grand <webmaster@mail.ox.rs>
-ox.rs
-
-// oy.lc
-// Submitted by Charly Coste <changaco@changaco.oy.lc>
-oy.lc
-
-// Pagefog : https://pagefog.com/
-// Submitted by Derek Myers <derek@pagefog.com>
-pgfog.com
-
-// Pagefront : https://www.pagefronthq.com/
-// Submitted by Jason Kriss <jason@pagefronthq.com>
-pagefrontapp.com
-
-// PageXL : https://pagexl.com
-// Submitted by Yann Guichard <yann@pagexl.com>
-pagexl.com
-
-// Paywhirl, Inc : https://paywhirl.com/
-// Submitted by Daniel Netzer <dan@paywhirl.com>
-*.paywhirl.com
-
-// pcarrier.ca Software Inc: https://pcarrier.ca/
-// Submitted by Pierre Carrier <pc@rrier.ca>
-bar0.net
-bar1.net
-bar2.net
-rdv.to
-
-// .pl domains (grandfathered)
-art.pl
-gliwice.pl
-krakow.pl
-poznan.pl
-wroc.pl
-zakopane.pl
-
-// Pantheon Systems, Inc. : https://pantheon.io/
-// Submitted by Gary Dylina <gary@pantheon.io>
-pantheonsite.io
-gotpantheon.com
-
-// Peplink | Pepwave : http://peplink.com/
-// Submitted by Steve Leung <steveleung@peplink.com>
-mypep.link
-
-// Perspecta : https://perspecta.com/
-// Submitted by Kenneth Van Alstyne <kvanalstyne@perspecta.com>
-perspecta.cloud
-
-// PE Ulyanov Kirill Sergeevich : https://airy.host
-// Submitted by Kirill Ulyanov <k.ulyanov@airy.host>
-lk3.ru
-
-// Planet-Work : https://www.planet-work.com/
-// Submitted by Frédéric VANNIÈRE <f.vanniere@planet-work.com>
-on-web.fr
-
-// Platform.sh : https://platform.sh
-// Submitted by Nikola Kotur <nikola@platform.sh>
-bc.platform.sh
-ent.platform.sh
-eu.platform.sh
-us.platform.sh
-*.platformsh.site
-*.tst.site
-
-// Platter: https://platter.dev
-// Submitted by Patrick Flor <patrick@platter.dev>
-platter-app.com
-platter-app.dev
-platterp.us
-
-// Plesk : https://www.plesk.com/
-// Submitted by Anton Akhtyamov <program-managers@plesk.com>
-pdns.page
-plesk.page
-pleskns.com
-
-// Port53 : https://port53.io/
-// Submitted by Maximilian Schieder <maxi@zeug.co>
-dyn53.io
-
-// Porter : https://porter.run/
-// Submitted by Rudraksh MK <rudi@porter.run>
-onporter.run
-
-// Positive Codes Technology Company : http://co.bn/faq.html
-// Submitted by Zulfais <pc@co.bn>
-co.bn
-
-// Postman, Inc : https://postman.com
-// Submitted by Rahul Dhawan <security@postman.com>
-postman-echo.com
-pstmn.io
-mock.pstmn.io
-httpbin.org
-
-//prequalifyme.today : https://prequalifyme.today
-//Submitted by DeepakTiwari deepak@ivylead.io
-prequalifyme.today
-
-// prgmr.com : https://prgmr.com/
-// Submitted by Sarah Newman <owner@prgmr.com>
-xen.prgmr.com
-
-// priv.at : http://www.nic.priv.at/
-// Submitted by registry <lendl@nic.at>
-priv.at
-
-// privacytools.io : https://www.privacytools.io/
-// Submitted by Jonah Aragon <jonah@privacytools.io>
-prvcy.page
-
-// Protocol Labs : https://protocol.ai/
-// Submitted by Michael Burns <noc@protocol.ai>
-*.dweb.link
-
-// Protonet GmbH : http://protonet.io
-// Submitted by Martin Meier <admin@protonet.io>
-protonet.io
-
-// Publication Presse Communication SARL : https://ppcom.fr
-// Submitted by Yaacov Akiba Slama <admin@chirurgiens-dentistes-en-france.fr>
-chirurgiens-dentistes-en-france.fr
-byen.site
-
-// pubtls.org: https://www.pubtls.org
-// Submitted by Kor Nielsen <kor@pubtls.org>
-pubtls.org
-
-// PythonAnywhere LLP: https://www.pythonanywhere.com
-// Submitted by Giles Thomas <giles@pythonanywhere.com>
-pythonanywhere.com
-eu.pythonanywhere.com
-
-// QOTO, Org.
-// Submitted by Jeffrey Phillips Freeman <jeffrey.freeman@qoto.org>
-qoto.io
-
-// Qualifio : https://qualifio.com/
-// Submitted by Xavier De Cock <xdecock@gmail.com>
-qualifioapp.com
-
-// QuickBackend: https://www.quickbackend.com
-// Submitted by Dani Biro <dani@pymet.com>
-qbuser.com
-
-// Rad Web Hosting: https://radwebhosting.com
-// Submitted by Scott Claeys <s.claeys@radwebhosting.com>
-cloudsite.builders
-
-// Redgate Software: https://red-gate.com
-// Submitted by Andrew Farries <andrew.farries@red-gate.com>
-instances.spawn.cc
-
-// Redstar Consultants : https://www.redstarconsultants.com/
-// Submitted by Jons Slemmer <jons@redstarconsultants.com>
-instantcloud.cn
-
-// Russian Academy of Sciences
-// Submitted by Tech Support <support@rasnet.ru>
-ras.ru
-
-// QA2
-// Submitted by Daniel Dent (https://www.danieldent.com/)
-qa2.com
-
-// QCX
-// Submitted by Cassandra Beelen <cassandra@beelen.one>
-qcx.io
-*.sys.qcx.io
-
-// QNAP System Inc : https://www.qnap.com
-// Submitted by Nick Chang <nickchang@qnap.com>
-dev-myqnapcloud.com
-alpha-myqnapcloud.com
-myqnapcloud.com
-
-// Quip : https://quip.com
-// Submitted by Patrick Linehan <plinehan@quip.com>
-*.quipelements.com
-
-// Qutheory LLC : http://qutheory.io
-// Submitted by Jonas Schwartz <jonas@qutheory.io>
-vapor.cloud
-vaporcloud.io
-
-// Rackmaze LLC : https://www.rackmaze.com
-// Submitted by Kirill Pertsev <kika@rackmaze.com>
-rackmaze.com
-rackmaze.net
-
-// Rakuten Games, Inc : https://dev.viberplay.io
-// Submitted by Joshua Zhang <public-suffix@rgames.jp>
-g.vbrplsbx.io
-
-// Rancher Labs, Inc : https://rancher.com
-// Submitted by Vincent Fiduccia <domains@rancher.com>
-*.on-k3s.io
-*.on-rancher.cloud
-*.on-rio.io
-
-// Read The Docs, Inc : https://www.readthedocs.org
-// Submitted by David Fischer <team@readthedocs.org>
-readthedocs.io
-
-// Red Hat, Inc. OpenShift : https://openshift.redhat.com/
-// Submitted by Tim Kramer <tkramer@rhcloud.com>
-rhcloud.com
-
-// Render : https://render.com
-// Submitted by Anurag Goel <dev@render.com>
-app.render.com
-onrender.com
-
-// Repl.it : https://repl.it
-// Submitted by Mason Clayton <mason@repl.it>
-repl.co
-id.repl.co
-repl.run
-
-// Resin.io : https://resin.io
-// Submitted by Tim Perry <tim@resin.io>
-resindevice.io
-devices.resinstaging.io
-
-// RethinkDB : https://www.rethinkdb.com/
-// Submitted by Chris Kastorff <info@rethinkdb.com>
-hzc.io
-
-// Revitalised Limited : http://www.revitalised.co.uk
-// Submitted by Jack Price <jack@revitalised.co.uk>
-wellbeingzone.eu
-wellbeingzone.co.uk
-
-// Rico Developments Limited : https://adimo.co
-// Submitted by Colin Brown <hello@adimo.co>
-adimo.co.uk
-
-// Riseup Networks : https://riseup.net
-// Submitted by Micah Anderson <micah@riseup.net>
-itcouldbewor.se
-
-// Rochester Institute of Technology : http://www.rit.edu/
-// Submitted by Jennifer Herting <jchits@rit.edu>
-git-pages.rit.edu
-
-// Rocky Enterprise Software Foundation : https://resf.org
-// Submitted by Neil Hanlon <neil@resf.org>
-rocky.page
-
-// Rusnames Limited: http://rusnames.ru/
-// Submitted by Sergey Zotov <admin@rusnames.ru>
-биз.рус
-ком.рус
-крым.рус
-мир.рус
-мск.рус
-орг.рус
-самара.рус
-сочи.рус
-спб.рус
-я.рус
-
-// Sandstorm Development Group, Inc. : https://sandcats.io/
-// Submitted by Asheesh Laroia <asheesh@sandstorm.io>
-sandcats.io
-
-// SBE network solutions GmbH : https://www.sbe.de/
-// Submitted by Norman Meilick <nm@sbe.de>
-logoip.de
-logoip.com
-
-// Scaleway : https://www.scaleway.com/
-// Submitted by Rémy Léone <rleone@scaleway.com>
-fr-par-1.baremetal.scw.cloud
-fr-par-2.baremetal.scw.cloud
-nl-ams-1.baremetal.scw.cloud
-fnc.fr-par.scw.cloud
-functions.fnc.fr-par.scw.cloud
-k8s.fr-par.scw.cloud
-nodes.k8s.fr-par.scw.cloud
-s3.fr-par.scw.cloud
-s3-website.fr-par.scw.cloud
-whm.fr-par.scw.cloud
-priv.instances.scw.cloud
-pub.instances.scw.cloud
-k8s.scw.cloud
-k8s.nl-ams.scw.cloud
-nodes.k8s.nl-ams.scw.cloud
-s3.nl-ams.scw.cloud
-s3-website.nl-ams.scw.cloud
-whm.nl-ams.scw.cloud
-k8s.pl-waw.scw.cloud
-nodes.k8s.pl-waw.scw.cloud
-s3.pl-waw.scw.cloud
-s3-website.pl-waw.scw.cloud
-scalebook.scw.cloud
-smartlabeling.scw.cloud
-dedibox.fr
-
-// schokokeks.org GbR : https://schokokeks.org/
-// Submitted by Hanno Böck <hanno@schokokeks.org>
-schokokeks.net
-
-// Scottish Government: https://www.gov.scot
-// Submitted by Martin Ellis <martin.ellis@gov.scot>
-gov.scot
-service.gov.scot
-
-// Scry Security : http://www.scrysec.com
-// Submitted by Shante Adam <shante@skyhat.io>
-scrysec.com
-
-// Securepoint GmbH : https://www.securepoint.de
-// Submitted by Erik Anders <erik.anders@securepoint.de>
-firewall-gateway.com
-firewall-gateway.de
-my-gateway.de
-my-router.de
-spdns.de
-spdns.eu
-firewall-gateway.net
-my-firewall.org
-myfirewall.org
-spdns.org
-
-// Seidat : https://www.seidat.com
-// Submitted by Artem Kondratev <accounts@seidat.com>
-seidat.net
-
-// Sellfy : https://sellfy.com
-// Submitted by Yuriy Romadin <contact@sellfy.com>
-sellfy.store
-
-// Senseering GmbH : https://www.senseering.de
-// Submitted by Felix Mönckemeyer <f.moenckemeyer@senseering.de>
-senseering.net
-
-// Sendmsg: https://www.sendmsg.co.il
-// Submitted by Assaf Stern <domains@comstar.co.il>
-minisite.ms
-
-// Service Magnet : https://myservicemagnet.com
-// Submitted by Dave Sanders <dave@myservicemagnet.com>
-magnet.page
-
-// Service Online LLC : http://drs.ua/
-// Submitted by Serhii Bulakh <support@drs.ua>
-biz.ua
-co.ua
-pp.ua
-
-// Shift Crypto AG : https://shiftcrypto.ch
-// Submitted by alex <alex@shiftcrypto.ch>
-shiftcrypto.dev
-shiftcrypto.io
-
-// ShiftEdit : https://shiftedit.net/
-// Submitted by Adam Jimenez <adam@shiftcreate.com>
-shiftedit.io
-
-// Shopblocks : http://www.shopblocks.com/
-// Submitted by Alex Bowers <alex@shopblocks.com>
-myshopblocks.com
-
-// Shopify : https://www.shopify.com
-// Submitted by Alex Richter <alex.richter@shopify.com>
-myshopify.com
-
-// Shopit : https://www.shopitcommerce.com/
-// Submitted by Craig McMahon <craig@shopitcommerce.com>
-shopitsite.com
-
-// shopware AG : https://shopware.com
-// Submitted by Jens Küper <cloud@shopware.com>
-shopware.store
-
-// Siemens Mobility GmbH
-// Submitted by Oliver Graebner <security@mo-siemens.io>
-mo-siemens.io
-
-// SinaAppEngine : http://sae.sina.com.cn/
-// Submitted by SinaAppEngine <saesupport@sinacloud.com>
-1kapp.com
-appchizi.com
-applinzi.com
-sinaapp.com
-vipsinaapp.com
-
-// Siteleaf : https://www.siteleaf.com/
-// Submitted by Skylar Challand <support@siteleaf.com>
-siteleaf.net
-
-// Skyhat : http://www.skyhat.io
-// Submitted by Shante Adam <shante@skyhat.io>
-bounty-full.com
-alpha.bounty-full.com
-beta.bounty-full.com
-
-// Small Technology Foundation : https://small-tech.org
-// Submitted by Aral Balkan <aral@small-tech.org>
-small-web.org
-
-// Smoove.io : https://www.smoove.io/
-// Submitted by Dan Kozak <dan@smoove.io>
-vp4.me
-
-// Snowplow Analytics : https://snowplowanalytics.com/
-// Submitted by Ian Streeter <ian@snowplowanalytics.com>
-try-snowplow.com
-
-// SourceHut : https://sourcehut.org
-// Submitted by Drew DeVault <sir@cmpwn.com>
-srht.site
-
-// Stackhero : https://www.stackhero.io
-// Submitted by Adrien Gillon <adrien+public-suffix-list@stackhero.io>
-stackhero-network.com
-
-// Staclar : https://staclar.com
-// Submitted by Q Misell <q@staclar.com>
-musician.io
-// Submitted by Matthias Merkel <matthias.merkel@staclar.com>
-novecore.site
-
-// staticland : https://static.land
-// Submitted by Seth Vincent <sethvincent@gmail.com>
-static.land
-dev.static.land
-sites.static.land
-
-// Storebase : https://www.storebase.io
-// Submitted by Tony Schirmer <tony@storebase.io>
-storebase.store
-
-// Strategic System Consulting (eApps Hosting): https://www.eapps.com/
-// Submitted by Alex Oancea <aoancea@cloudscale365.com>
-vps-host.net
-atl.jelastic.vps-host.net
-njs.jelastic.vps-host.net
-ric.jelastic.vps-host.net
-
-// Sony Interactive Entertainment LLC : https://sie.com/
-// Submitted by David Coles <david.coles@sony.com>
-playstation-cloud.com
-
-// SourceLair PC : https://www.sourcelair.com
-// Submitted by Antonis Kalipetis <akalipetis@sourcelair.com>
-apps.lair.io
-*.stolos.io
-
-// SpaceKit : https://www.spacekit.io/
-// Submitted by Reza Akhavan <spacekit.io@gmail.com>
-spacekit.io
-
-// SpeedPartner GmbH: https://www.speedpartner.de/
-// Submitted by Stefan Neufeind <info@speedpartner.de>
-customer.speedpartner.de
-
-// Spreadshop (sprd.net AG) : https://www.spreadshop.com/
-// Submitted by Martin Breest <security@spreadshop.com>
-myspreadshop.at
-myspreadshop.com.au
-myspreadshop.be
-myspreadshop.ca
-myspreadshop.ch
-myspreadshop.com
-myspreadshop.de
-myspreadshop.dk
-myspreadshop.es
-myspreadshop.fi
-myspreadshop.fr
-myspreadshop.ie
-myspreadshop.it
-myspreadshop.net
-myspreadshop.nl
-myspreadshop.no
-myspreadshop.pl
-myspreadshop.se
-myspreadshop.co.uk
-
-// Standard Library : https://stdlib.com
-// Submitted by Jacob Lee <jacob@stdlib.com>
-api.stdlib.com
-
-// Storj Labs Inc. : https://storj.io/
-// Submitted by Philip Hutchins <hostmaster@storj.io>
-storj.farm
-
-// Studenten Net Twente : http://www.snt.utwente.nl/
-// Submitted by Silke Hofstra <syscom@snt.utwente.nl>
-utwente.io
-
-// Student-Run Computing Facility : https://www.srcf.net/
-// Submitted by Edwin Balani <sysadmins@srcf.net>
-soc.srcf.net
-user.srcf.net
-
-// Sub 6 Limited: http://www.sub6.com
-// Submitted by Dan Miller <dm@sub6.com>
-temp-dns.com
-
-// Supabase : https://supabase.io
-// Submitted by Inian Parameshwaran <security@supabase.io>
-supabase.co
-supabase.in
-supabase.net
-su.paba.se
-
-// Symfony, SAS : https://symfony.com/
-// Submitted by Fabien Potencier <fabien@symfony.com>
-*.s5y.io
-*.sensiosite.cloud
-
-// Syncloud : https://syncloud.org
-// Submitted by Boris Rybalkin <syncloud@syncloud.it>
-syncloud.it
-
-// Synology, Inc. : https://www.synology.com/
-// Submitted by Rony Weng <ronyweng@synology.com>
-dscloud.biz
-direct.quickconnect.cn
-dsmynas.com
-familyds.com
-diskstation.me
-dscloud.me
-i234.me
-myds.me
-synology.me
-dscloud.mobi
-dsmynas.net
-familyds.net
-dsmynas.org
-familyds.org
-vpnplus.to
-direct.quickconnect.to
-
-// Tabit Technologies Ltd. : https://tabit.cloud/
-// Submitted by Oren Agiv <oren@tabit.cloud>
-tabitorder.co.il
-
-// TAIFUN Software AG : http://taifun-software.de
-// Submitted by Bjoern Henke <dev-server@taifun-software.de>
-taifun-dns.de
-
-// Tailscale Inc. : https://www.tailscale.com
-// Submitted by David Anderson <danderson@tailscale.com>
-beta.tailscale.net
-ts.net
-
-// TASK geographical domains (www.task.gda.pl/uslugi/dns)
-gda.pl
-gdansk.pl
-gdynia.pl
-med.pl
-sopot.pl
-
-// team.blue https://team.blue
-// Submitted by Cedric Dubois <cedric.dubois@team.blue>
-site.tb-hosting.com
-
-// Teckids e.V. : https://www.teckids.org
-// Submitted by Dominik George <dominik.george@teckids.org>
-edugit.io
-s3.teckids.org
-
-// Telebit : https://telebit.cloud
-// Submitted by AJ ONeal <aj@telebit.cloud>
-telebit.app
-telebit.io
-*.telebit.xyz
-
-// The Gwiddle Foundation : https://gwiddlefoundation.org.uk
-// Submitted by Joshua Bayfield <joshua.bayfield@gwiddlefoundation.org.uk>
-gwiddle.co.uk
-
-// Thingdust AG : https://thingdust.com/
-// Submitted by Adrian Imboden <adi@thingdust.com>
-*.firenet.ch
-*.svc.firenet.ch
-reservd.com
-thingdustdata.com
-cust.dev.thingdust.io
-cust.disrec.thingdust.io
-cust.prod.thingdust.io
-cust.testing.thingdust.io
-reservd.dev.thingdust.io
-reservd.disrec.thingdust.io
-reservd.testing.thingdust.io
-
-// ticket i/O GmbH : https://ticket.io
-// Submitted by Christian Franke <it@ticket.io>
-tickets.io
-
-// Tlon.io : https://tlon.io
-// Submitted by Mark Staarink <mark@tlon.io>
-arvo.network
-azimuth.network
-tlon.network
-
-// Tor Project, Inc. : https://torproject.org
-// Submitted by Antoine Beaupré <anarcat@torproject.org
-torproject.net
-pages.torproject.net
-
-// TownNews.com : http://www.townnews.com
-// Submitted by Dustin Ward <dward@townnews.com>
-bloxcms.com
-townnews-staging.com
-
-// TradableBits: https://tradablebits.com
-// Submitted by Dmitry Khrisanov dmitry@tradablebits.com
-tbits.me
-
-// TrafficPlex GmbH : https://www.trafficplex.de/
-// Submitted by Phillipp Röll <phillipp.roell@trafficplex.de>
-12hp.at
-2ix.at
-4lima.at
-lima-city.at
-12hp.ch
-2ix.ch
-4lima.ch
-lima-city.ch
-trafficplex.cloud
-de.cool
-12hp.de
-2ix.de
-4lima.de
-lima-city.de
-1337.pictures
-clan.rip
-lima-city.rocks
-webspace.rocks
-lima.zone
-
-// TransIP : https://www.transip.nl
-// Submitted by Rory Breuk <rbreuk@transip.nl>
-*.transurl.be
-*.transurl.eu
-*.transurl.nl
-
-// TransIP: https://www.transip.nl
-// Submitted by Cedric Dubois <cedric.dubois@team.blue>
-site.transip.me
-
-// TuxFamily : http://tuxfamily.org
-// Submitted by TuxFamily administrators <adm@staff.tuxfamily.org>
-tuxfamily.org
-
-// TwoDNS : https://www.twodns.de/
-// Submitted by TwoDNS-Support <support@two-dns.de>
-dd-dns.de
-diskstation.eu
-diskstation.org
-dray-dns.de
-draydns.de
-dyn-vpn.de
-dynvpn.de
-mein-vigor.de
-my-vigor.de
-my-wan.de
-syno-ds.de
-synology-diskstation.de
-synology-ds.de
-
-// Typedream : https://typedream.com
-// Submitted by Putri Karunia <putri@typedream.com>
-typedream.app
-
-// Typeform : https://www.typeform.com
-// Submitted by Sergi Ferriz <sergi.ferriz@typeform.com>
-pro.typeform.com
-
-// Uberspace : https://uberspace.de
-// Submitted by Moritz Werner <mwerner@jonaspasche.com>
-uber.space
-*.uberspace.de
-
-// UDR Limited : http://www.udr.hk.com
-// Submitted by registry <hostmaster@udr.hk.com>
-hk.com
-hk.org
-ltd.hk
-inc.hk
-
-// United Gameserver GmbH : https://united-gameserver.de
-// Submitted by Stefan Schwarz <sysadm@united-gameserver.de>
-virtualuser.de
-virtual-user.de
-
-// Upli : https://upli.io
-// Submitted by Lenny Bakkalian <lenny.bakkalian@gmail.com>
-upli.io
-
-// urown.net : https://urown.net
-// Submitted by Hostmaster <hostmaster@urown.net>
-urown.cloud
-dnsupdate.info
-
-// .US
-// Submitted by Ed Moore <Ed.Moore@lib.de.us>
-lib.de.us
-
-// VeryPositive SIA : http://very.lv
-// Submitted by Danko Aleksejevs <danko@very.lv>
-2038.io
-
-// Vercel, Inc : https://vercel.com/
-// Submitted by Connor Davis <security@vercel.com>
-vercel.app
-vercel.dev
-now.sh
-
-// Viprinet Europe GmbH : http://www.viprinet.com
-// Submitted by Simon Kissel <hostmaster@viprinet.com>
-router.management
-
-// Virtual-Info : https://www.virtual-info.info/
-// Submitted by Adnan RIHAN <hostmaster@v-info.info>
-v-info.info
-
-// Voorloper.com: https://voorloper.com
-// Submitted by Nathan van Bakel <info@voorloper.com>
-voorloper.cloud
-
-// Voxel.sh DNS : https://voxel.sh/dns/
-// Submitted by Mia Rehlinger <dns@voxel.sh>
-neko.am
-nyaa.am
-be.ax
-cat.ax
-es.ax
-eu.ax
-gg.ax
-mc.ax
-us.ax
-xy.ax
-nl.ci
-xx.gl
-app.gp
-blog.gt
-de.gt
-to.gt
-be.gy
-cc.hn
-blog.kg
-io.kg
-jp.kg
-tv.kg
-uk.kg
-us.kg
-de.ls
-at.md
-de.md
-jp.md
-to.md
-indie.porn
-vxl.sh
-ch.tc
-me.tc
-we.tc
-nyan.to
-at.vg
-blog.vu
-dev.vu
-me.vu
-
-// V.UA Domain Administrator : https://domain.v.ua/
-// Submitted by Serhii Rostilo <sergey@rostilo.kiev.ua>
-v.ua
-
-// Vultr Objects : https://www.vultr.com/products/object-storage/
-// Submitted by Niels Maumenee <storage@vultr.com>
-*.vultrobjects.com
-
-// Waffle Computer Inc., Ltd. : https://docs.waffleinfo.com
-// Submitted by Masayuki Note <masa@blade.wafflecell.com>
-wafflecell.com
-
-// WebHare bv: https://www.webhare.com/
-// Submitted by Arnold Hendriks <info@webhare.com>
-*.webhare.dev
-
-// WebHotelier Technologies Ltd: https://www.webhotelier.net/
-// Submitted by Apostolos Tsakpinis <apostolos.tsakpinis@gmail.com>
-reserve-online.net
-reserve-online.com
-bookonline.app
-hotelwithflight.com
-
-// WeDeploy by Liferay, Inc. : https://www.wedeploy.com
-// Submitted by Henrique Vicente <security@wedeploy.com>
-wedeploy.io
-wedeploy.me
-wedeploy.sh
-
-// Western Digital Technologies, Inc : https://www.wdc.com
-// Submitted by Jung Jin <jungseok.jin@wdc.com>
-remotewd.com
-
-// WIARD Enterprises : https://wiardweb.com
-// Submitted by Kidd Hustle <kiddhustle@wiardweb.com>
-pages.wiardweb.com
-
-// Wikimedia Labs : https://wikitech.wikimedia.org
-// Submitted by Arturo Borrero Gonzalez <aborrero@wikimedia.org>
-wmflabs.org
-toolforge.org
-wmcloud.org
-
-// WISP : https://wisp.gg
-// Submitted by Stepan Fedotov <stepan@wisp.gg>
-panel.gg
-daemon.panel.gg
-
-// Wizard Zines : https://wizardzines.com
-// Submitted by Julia Evans <julia@wizardzines.com>
-messwithdns.com
-
-// WoltLab GmbH : https://www.woltlab.com
-// Submitted by Tim Düsterhus <security@woltlab.cloud>
-woltlab-demo.com
-myforum.community
-community-pro.de
-diskussionsbereich.de
-community-pro.net
-meinforum.net
-
-// Woods Valldata : https://www.woodsvalldata.co.uk/
-// Submitted by Chris Whittle <chris.whittle@woodsvalldata.co.uk>
-affinitylottery.org.uk
-raffleentry.org.uk
-weeklylottery.org.uk
-
-// WP Engine : https://wpengine.com/
-// Submitted by Michael Smith <michael.smith@wpengine.com>
-// Submitted by Brandon DuRette <brandon.durette@wpengine.com>
-wpenginepowered.com
-js.wpenginepowered.com
-
-// Wix.com, Inc. : https://www.wix.com
-// Submitted by Shahar Talmi <shahar@wix.com>
-wixsite.com
-editorx.io
-
-// XenonCloud GbR: https://xenoncloud.net
-// Submitted by Julian Uphoff <publicsuffixlist@xenoncloud.net>
-half.host
-
-// XnBay Technology : http://www.xnbay.com/
-// Submitted by XnBay Developer <developer.xncloud@gmail.com>
-xnbay.com
-u2.xnbay.com
-u2-local.xnbay.com
-
-// XS4ALL Internet bv : https://www.xs4all.nl/
-// Submitted by Daniel Mostertman <unixbeheer+publicsuffix@xs4all.net>
-cistron.nl
-demon.nl
-xs4all.space
-
-// Yandex.Cloud LLC: https://cloud.yandex.com
-// Submitted by Alexander Lodin <security+psl@yandex-team.ru>
-yandexcloud.net
-storage.yandexcloud.net
-website.yandexcloud.net
-
-// YesCourse Pty Ltd : https://yescourse.com
-// Submitted by Atul Bhouraskar <atul@yescourse.com>
-official.academy
-
-// Yola : https://www.yola.com/
-// Submitted by Stefano Rivera <stefano@yola.com>
-yolasite.com
-
-// Yombo : https://yombo.net
-// Submitted by Mitch Schwenk <mitch@yombo.net>
-ybo.faith
-yombo.me
-homelink.one
-ybo.party
-ybo.review
-ybo.science
-ybo.trade
-
-// Yunohost : https://yunohost.org
-// Submitted by Valentin Grimaud <security@yunohost.org>
-ynh.fr
-nohost.me
-noho.st
-
-// ZaNiC : http://www.za.net/
-// Submitted by registry <hostmaster@nic.za.net>
-za.net
-za.org
-
-// Zine EOOD : https://zine.bg/
-// Submitted by Martin Angelov <martin@zine.bg>
-bss.design
-
-// Zitcom A/S : https://www.zitcom.dk
-// Submitted by Emil Stahl <esp@zitcom.dk>
-basicserver.io
-virtualserver.io
-enterprisecloud.nu
-
-// ===END PRIVATE DOMAINS===
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/errors.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/errors.rb
deleted file mode 100644
index 2fca2c13b5b3d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/errors.rb
+++ /dev/null
@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-# = Public Suffix
-#
-# Domain name parser based on the Public Suffix List.
-#
-# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
-
-module PublicSuffix
-
-  class Error < StandardError
-  end
-
-  # Raised when trying to parse an invalid name.
-  # A name is considered invalid when no rule is found in the definition list.
-  #
-  # @example
-  #
-  #   PublicSuffix.parse("nic.test")
-  #   # => PublicSuffix::DomainInvalid
-  #
-  #   PublicSuffix.parse("http://www.nic.it")
-  #   # => PublicSuffix::DomainInvalid
-  #
-  class DomainInvalid < Error
-  end
-
-  # Raised when trying to parse a name that matches a suffix.
-  #
-  # @example
-  #
-  #   PublicSuffix.parse("nic.do")
-  #   # => PublicSuffix::DomainNotAllowed
-  #
-  #   PublicSuffix.parse("www.nic.do")
-  #   # => PublicSuffix::Domain
-  #
-  class DomainNotAllowed < DomainInvalid
-  end
-
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/list.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/list.rb
deleted file mode 100644
index e11f071d43d89..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/list.rb
+++ /dev/null
@@ -1,247 +0,0 @@
-# frozen_string_literal: true
-
-# = Public Suffix
-#
-# Domain name parser based on the Public Suffix List.
-#
-# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
-
-module PublicSuffix
-
-  # A {PublicSuffix::List} is a collection of one
-  # or more {PublicSuffix::Rule}.
-  #
-  # Given a {PublicSuffix::List},
-  # you can add or remove {PublicSuffix::Rule},
-  # iterate all items in the list or search for the first rule
-  # which matches a specific domain name.
-  #
-  #   # Create a new list
-  #   list =  PublicSuffix::List.new
-  #
-  #   # Push two rules to the list
-  #   list << PublicSuffix::Rule.factory("it")
-  #   list << PublicSuffix::Rule.factory("com")
-  #
-  #   # Get the size of the list
-  #   list.size
-  #   # => 2
-  #
-  #   # Search for the rule matching given domain
-  #   list.find("example.com")
-  #   # => #<PublicSuffix::Rule::Normal>
-  #   list.find("example.org")
-  #   # => nil
-  #
-  # You can create as many {PublicSuffix::List} you want.
-  # The {PublicSuffix::List.default} rule list is used
-  # to tokenize and validate a domain.
-  #
-  class List
-
-    DEFAULT_LIST_PATH = File.expand_path("../../data/list.txt", __dir__)
-
-    # Gets the default rule list.
-    #
-    # Initializes a new {PublicSuffix::List} parsing the content
-    # of {PublicSuffix::List.default_list_content}, if required.
-    #
-    # @return [PublicSuffix::List]
-    def self.default(**options)
-      @default ||= parse(File.read(DEFAULT_LIST_PATH), **options)
-    end
-
-    # Sets the default rule list to +value+.
-    #
-    # @param  value [PublicSuffix::List] the new list
-    # @return [PublicSuffix::List]
-    def self.default=(value)
-      @default = value
-    end
-
-    # Parse given +input+ treating the content as Public Suffix List.
-    #
-    # See http://publicsuffix.org/format/ for more details about input format.
-    #
-    # @param  input [#each_line] the list to parse
-    # @param  private_domains [Boolean] whether to ignore the private domains section
-    # @return [PublicSuffix::List]
-    def self.parse(input, private_domains: true)
-      comment_token = "//"
-      private_token = "===BEGIN PRIVATE DOMAINS==="
-      section = nil # 1 == ICANN, 2 == PRIVATE
-
-      new do |list|
-        input.each_line do |line|
-          line.strip!
-          case # rubocop:disable Style/EmptyCaseCondition
-
-          # skip blank lines
-          when line.empty?
-            next
-
-          # include private domains or stop scanner
-          when line.include?(private_token)
-            break if !private_domains
-
-            section = 2
-
-          # skip comments
-          when line.start_with?(comment_token)
-            next
-
-          else
-            list.add(Rule.factory(line, private: section == 2))
-
-          end
-        end
-      end
-    end
-
-
-    # Initializes an empty {PublicSuffix::List}.
-    #
-    # @yield [self] Yields on self.
-    # @yieldparam [PublicSuffix::List] self The newly created instance.
-    def initialize
-      @rules = {}
-      yield(self) if block_given?
-    end
-
-
-    # Checks whether two lists are equal.
-    #
-    # List <tt>one</tt> is equal to <tt>two</tt>, if <tt>two</tt> is an instance of
-    # {PublicSuffix::List} and each +PublicSuffix::Rule::*+
-    # in list <tt>one</tt> is available in list <tt>two</tt>, in the same order.
-    #
-    # @param  other [PublicSuffix::List] the List to compare
-    # @return [Boolean]
-    def ==(other)
-      return false unless other.is_a?(List)
-
-      equal?(other) || @rules == other.rules
-    end
-    alias eql? ==
-
-    # Iterates each rule in the list.
-    def each(&block)
-      Enumerator.new do |y|
-        @rules.each do |key, node|
-          y << entry_to_rule(node, key)
-        end
-      end.each(&block)
-    end
-
-
-    # Adds the given object to the list and optionally refreshes the rule index.
-    #
-    # @param  rule [PublicSuffix::Rule::*] the rule to add to the list
-    # @return [self]
-    def add(rule)
-      @rules[rule.value] = rule_to_entry(rule)
-      self
-    end
-    alias << add
-
-    # Gets the number of rules in the list.
-    #
-    # @return [Integer]
-    def size
-      @rules.size
-    end
-
-    # Checks whether the list is empty.
-    #
-    # @return [Boolean]
-    def empty?
-      @rules.empty?
-    end
-
-    # Removes all rules.
-    #
-    # @return [self]
-    def clear
-      @rules.clear
-      self
-    end
-
-    # Finds and returns the rule corresponding to the longest public suffix for the hostname.
-    #
-    # @param  name [#to_s] the hostname
-    # @param  default [PublicSuffix::Rule::*] the default rule to return in case no rule matches
-    # @return [PublicSuffix::Rule::*]
-    def find(name, default: default_rule, **options)
-      rule = select(name, **options).inject do |l, r|
-        return r if r.instance_of?(Rule::Exception)
-
-        l.length > r.length ? l : r
-      end
-      rule || default
-    end
-
-    # Selects all the rules matching given hostame.
-    #
-    # If `ignore_private` is set to true, the algorithm will skip the rules that are flagged as
-    # private domain. Note that the rules will still be part of the loop.
-    # If you frequently need to access lists ignoring the private domains,
-    # you should create a list that doesn't include these domains setting the
-    # `private_domains: false` option when calling {.parse}.
-    #
-    # Note that this method is currently private, as you should not rely on it. Instead,
-    # the public interface is {#find}. The current internal algorithm allows to return all
-    # matching rules, but different data structures may not be able to do it, and instead would
-    # return only the match. For this reason, you should rely on {#find}.
-    #
-    # @param  name [#to_s] the hostname
-    # @param  ignore_private [Boolean]
-    # @return [Array<PublicSuffix::Rule::*>]
-    def select(name, ignore_private: false)
-      name = name.to_s
-
-      parts = name.split(DOT).reverse!
-      index = 0
-      query = parts[index]
-      rules = []
-
-      loop do
-        match = @rules[query]
-        rules << entry_to_rule(match, query) if !match.nil? && (ignore_private == false || match.private == false)
-
-        index += 1
-        break if index >= parts.size
-
-        query = parts[index] + DOT + query
-      end
-
-      rules
-    end
-    private :select
-
-    # Gets the default rule.
-    #
-    # @see PublicSuffix::Rule.default_rule
-    #
-    # @return [PublicSuffix::Rule::*]
-    def default_rule
-      PublicSuffix::Rule.default
-    end
-
-
-    protected
-
-    attr_reader :rules
-
-
-    private
-
-    def entry_to_rule(entry, value)
-      entry.type.new(value: value, length: entry.length, private: entry.private)
-    end
-
-    def rule_to_entry(rule)
-      Rule::Entry.new(rule.class, rule.length, rule.private)
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/version.rb
deleted file mode 100644
index 80d373f7c49fd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/version.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-#
-# = Public Suffix
-#
-# Domain name parser based on the Public Suffix List.
-#
-# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
-
-module PublicSuffix
-
-  # @return [String] The current library version.
-  VERSION = "4.0.7"
-
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack.rb
deleted file mode 100644
index e4494e5bac407..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack.rb
+++ /dev/null
@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (C) 2007-2019 Leah Neukirchen <http://leahneukirchen.org/infopage.html>
-#
-# Rack is freely distributable under the terms of an MIT-style license.
-# See MIT-LICENSE or https://opensource.org/licenses/MIT.
-
-# The Rack main module, serving as a namespace for all core Rack
-# modules and classes.
-#
-# All modules meant for use in your application are <tt>autoload</tt>ed here,
-# so it should be enough just to <tt>require 'rack'</tt> in your code.
-
-require_relative 'rack/version'
-
-module Rack
-  HTTP_HOST         = 'HTTP_HOST'
-  HTTP_PORT         = 'HTTP_PORT'
-  HTTP_VERSION      = 'HTTP_VERSION'
-  HTTPS             = 'HTTPS'
-  PATH_INFO         = 'PATH_INFO'
-  REQUEST_METHOD    = 'REQUEST_METHOD'
-  REQUEST_PATH      = 'REQUEST_PATH'
-  SCRIPT_NAME       = 'SCRIPT_NAME'
-  QUERY_STRING      = 'QUERY_STRING'
-  SERVER_PROTOCOL   = 'SERVER_PROTOCOL'
-  SERVER_NAME       = 'SERVER_NAME'
-  SERVER_PORT       = 'SERVER_PORT'
-  CACHE_CONTROL     = 'Cache-Control'
-  EXPIRES           = 'Expires'
-  CONTENT_LENGTH    = 'Content-Length'
-  CONTENT_TYPE      = 'Content-Type'
-  SET_COOKIE        = 'Set-Cookie'
-  TRANSFER_ENCODING = 'Transfer-Encoding'
-  HTTP_COOKIE       = 'HTTP_COOKIE'
-  ETAG              = 'ETag'
-
-  # HTTP method verbs
-  GET     = 'GET'
-  POST    = 'POST'
-  PUT     = 'PUT'
-  PATCH   = 'PATCH'
-  DELETE  = 'DELETE'
-  HEAD    = 'HEAD'
-  OPTIONS = 'OPTIONS'
-  LINK    = 'LINK'
-  UNLINK  = 'UNLINK'
-  TRACE   = 'TRACE'
-
-  # Rack environment variables
-  RACK_VERSION                        = 'rack.version'
-  RACK_TEMPFILES                      = 'rack.tempfiles'
-  RACK_ERRORS                         = 'rack.errors'
-  RACK_LOGGER                         = 'rack.logger'
-  RACK_INPUT                          = 'rack.input'
-  RACK_SESSION                        = 'rack.session'
-  RACK_SESSION_OPTIONS                = 'rack.session.options'
-  RACK_SHOWSTATUS_DETAIL              = 'rack.showstatus.detail'
-  RACK_MULTITHREAD                    = 'rack.multithread'
-  RACK_MULTIPROCESS                   = 'rack.multiprocess'
-  RACK_RUNONCE                        = 'rack.run_once'
-  RACK_URL_SCHEME                     = 'rack.url_scheme'
-  RACK_HIJACK                         = 'rack.hijack'
-  RACK_IS_HIJACK                      = 'rack.hijack?'
-  RACK_HIJACK_IO                      = 'rack.hijack_io'
-  RACK_RECURSIVE_INCLUDE              = 'rack.recursive.include'
-  RACK_MULTIPART_BUFFER_SIZE          = 'rack.multipart.buffer_size'
-  RACK_MULTIPART_TEMPFILE_FACTORY     = 'rack.multipart.tempfile_factory'
-  RACK_REQUEST_FORM_INPUT             = 'rack.request.form_input'
-  RACK_REQUEST_FORM_HASH              = 'rack.request.form_hash'
-  RACK_REQUEST_FORM_VARS              = 'rack.request.form_vars'
-  RACK_REQUEST_COOKIE_HASH            = 'rack.request.cookie_hash'
-  RACK_REQUEST_COOKIE_STRING          = 'rack.request.cookie_string'
-  RACK_REQUEST_QUERY_HASH             = 'rack.request.query_hash'
-  RACK_REQUEST_QUERY_STRING           = 'rack.request.query_string'
-  RACK_METHODOVERRIDE_ORIGINAL_METHOD = 'rack.methodoverride.original_method'
-  RACK_SESSION_UNPACKED_COOKIE_DATA   = 'rack.session.unpacked_cookie_data'
-
-  autoload :Builder, "rack/builder"
-  autoload :BodyProxy, "rack/body_proxy"
-  autoload :Cascade, "rack/cascade"
-  autoload :Chunked, "rack/chunked"
-  autoload :CommonLogger, "rack/common_logger"
-  autoload :ConditionalGet, "rack/conditional_get"
-  autoload :Config, "rack/config"
-  autoload :ContentLength, "rack/content_length"
-  autoload :ContentType, "rack/content_type"
-  autoload :ETag, "rack/etag"
-  autoload :Events, "rack/events"
-  autoload :File, "rack/file"
-  autoload :Files, "rack/files"
-  autoload :Deflater, "rack/deflater"
-  autoload :Directory, "rack/directory"
-  autoload :ForwardRequest, "rack/recursive"
-  autoload :Handler, "rack/handler"
-  autoload :Head, "rack/head"
-  autoload :Lint, "rack/lint"
-  autoload :Lock, "rack/lock"
-  autoload :Logger, "rack/logger"
-  autoload :MediaType, "rack/media_type"
-  autoload :MethodOverride, "rack/method_override"
-  autoload :Mime, "rack/mime"
-  autoload :NullLogger, "rack/null_logger"
-  autoload :Recursive, "rack/recursive"
-  autoload :Reloader, "rack/reloader"
-  autoload :RewindableInput, "rack/rewindable_input"
-  autoload :Runtime, "rack/runtime"
-  autoload :Sendfile, "rack/sendfile"
-  autoload :Server, "rack/server"
-  autoload :ShowExceptions, "rack/show_exceptions"
-  autoload :ShowStatus, "rack/show_status"
-  autoload :Static, "rack/static"
-  autoload :TempfileReaper, "rack/tempfile_reaper"
-  autoload :URLMap, "rack/urlmap"
-  autoload :Utils, "rack/utils"
-  autoload :Multipart, "rack/multipart"
-
-  autoload :MockRequest, "rack/mock"
-  autoload :MockResponse, "rack/mock"
-
-  autoload :Request, "rack/request"
-  autoload :Response, "rack/response"
-
-  module Auth
-    autoload :Basic, "rack/auth/basic"
-    autoload :AbstractRequest, "rack/auth/abstract/request"
-    autoload :AbstractHandler, "rack/auth/abstract/handler"
-    module Digest
-      autoload :MD5, "rack/auth/digest/md5"
-      autoload :Nonce, "rack/auth/digest/nonce"
-      autoload :Params, "rack/auth/digest/params"
-      autoload :Request, "rack/auth/digest/request"
-    end
-  end
-
-  module Session
-    autoload :Cookie, "rack/session/cookie"
-    autoload :Pool, "rack/session/pool"
-    autoload :Memcache, "rack/session/memcache"
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/abstract/handler.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/abstract/handler.rb
deleted file mode 100644
index 3ed87091c7e7a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/abstract/handler.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  module Auth
-    # Rack::Auth::AbstractHandler implements common authentication functionality.
-    #
-    # +realm+ should be set for all handlers.
-
-    class AbstractHandler
-
-      attr_accessor :realm
-
-      def initialize(app, realm = nil, &authenticator)
-        @app, @realm, @authenticator = app, realm, authenticator
-      end
-
-
-      private
-
-      def unauthorized(www_authenticate = challenge)
-        return [ 401,
-          { CONTENT_TYPE => 'text/plain',
-            CONTENT_LENGTH => '0',
-            'WWW-Authenticate' => www_authenticate.to_s },
-          []
-        ]
-      end
-
-      def bad_request
-        return [ 400,
-          { CONTENT_TYPE => 'text/plain',
-            CONTENT_LENGTH => '0' },
-          []
-        ]
-      end
-
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/abstract/request.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/abstract/request.rb
deleted file mode 100644
index 34042c401b7b8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/abstract/request.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  module Auth
-    class AbstractRequest
-
-      def initialize(env)
-        @env = env
-      end
-
-      def request
-        @request ||= Request.new(@env)
-      end
-
-      def provided?
-        !authorization_key.nil? && valid?
-      end
-
-      def valid?
-        !@env[authorization_key].nil?
-      end
-
-      def parts
-        @parts ||= @env[authorization_key].split(' ', 2)
-      end
-
-      def scheme
-        @scheme ||= parts.first && parts.first.downcase
-      end
-
-      def params
-        @params ||= parts.last
-      end
-
-
-      private
-
-      AUTHORIZATION_KEYS = ['HTTP_AUTHORIZATION', 'X-HTTP_AUTHORIZATION', 'X_HTTP_AUTHORIZATION']
-
-      def authorization_key
-        @authorization_key ||= AUTHORIZATION_KEYS.detect { |key| @env.has_key?(key) }
-      end
-
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/basic.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/basic.rb
deleted file mode 100644
index d5b4ea16da3d9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/basic.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'abstract/handler'
-require_relative 'abstract/request'
-require 'base64'
-
-module Rack
-  module Auth
-    # Rack::Auth::Basic implements HTTP Basic Authentication, as per RFC 2617.
-    #
-    # Initialize with the Rack application that you want protecting,
-    # and a block that checks if a username and password pair are valid.
-    #
-    # See also: <tt>example/protectedlobster.rb</tt>
-
-    class Basic < AbstractHandler
-
-      def call(env)
-        auth = Basic::Request.new(env)
-
-        return unauthorized unless auth.provided?
-
-        return bad_request unless auth.basic?
-
-        if valid?(auth)
-          env['REMOTE_USER'] = auth.username
-
-          return @app.call(env)
-        end
-
-        unauthorized
-      end
-
-
-      private
-
-      def challenge
-        'Basic realm="%s"' % realm
-      end
-
-      def valid?(auth)
-        @authenticator.call(*auth.credentials)
-      end
-
-      class Request < Auth::AbstractRequest
-        def basic?
-          "basic" == scheme && credentials.length == 2
-        end
-
-        def credentials
-          @credentials ||= Base64.decode64(params).split(':', 2)
-        end
-
-        def username
-          credentials.first
-        end
-      end
-
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/digest/md5.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/digest/md5.rb
deleted file mode 100644
index 04b103e2583fc..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/digest/md5.rb
+++ /dev/null
@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../abstract/handler'
-require_relative 'request'
-require_relative 'params'
-require_relative 'nonce'
-require 'digest/md5'
-
-module Rack
-  module Auth
-    module Digest
-      # Rack::Auth::Digest::MD5 implements the MD5 algorithm version of
-      # HTTP Digest Authentication, as per RFC 2617.
-      #
-      # Initialize with the [Rack] application that you want protecting,
-      # and a block that looks up a plaintext password for a given username.
-      #
-      # +opaque+ needs to be set to a constant base64/hexadecimal string.
-      #
-      class MD5 < AbstractHandler
-
-        attr_accessor :opaque
-
-        attr_writer :passwords_hashed
-
-        def initialize(app, realm = nil, opaque = nil, &authenticator)
-          @passwords_hashed = nil
-          if opaque.nil? and realm.respond_to? :values_at
-            realm, opaque, @passwords_hashed = realm.values_at :realm, :opaque, :passwords_hashed
-          end
-          super(app, realm, &authenticator)
-          @opaque = opaque
-        end
-
-        def passwords_hashed?
-          !!@passwords_hashed
-        end
-
-        def call(env)
-          auth = Request.new(env)
-
-          unless auth.provided?
-            return unauthorized
-          end
-
-          if !auth.digest? || !auth.correct_uri? || !valid_qop?(auth)
-            return bad_request
-          end
-
-          if valid?(auth)
-            if auth.nonce.stale?
-              return unauthorized(challenge(stale: true))
-            else
-              env['REMOTE_USER'] = auth.username
-
-              return @app.call(env)
-            end
-          end
-
-          unauthorized
-        end
-
-
-        private
-
-        QOP = 'auth'
-
-        def params(hash = {})
-          Params.new do |params|
-            params['realm'] = realm
-            params['nonce'] = Nonce.new.to_s
-            params['opaque'] = H(opaque)
-            params['qop'] = QOP
-
-            hash.each { |k, v| params[k] = v }
-          end
-        end
-
-        def challenge(hash = {})
-          "Digest #{params(hash)}"
-        end
-
-        def valid?(auth)
-          valid_opaque?(auth) && valid_nonce?(auth) && valid_digest?(auth)
-        end
-
-        def valid_qop?(auth)
-          QOP == auth.qop
-        end
-
-        def valid_opaque?(auth)
-          H(opaque) == auth.opaque
-        end
-
-        def valid_nonce?(auth)
-          auth.nonce.valid?
-        end
-
-        def valid_digest?(auth)
-          pw = @authenticator.call(auth.username)
-          pw && Rack::Utils.secure_compare(digest(auth, pw), auth.response)
-        end
-
-        def md5(data)
-          ::Digest::MD5.hexdigest(data)
-        end
-
-        alias :H :md5
-
-        def KD(secret, data)
-          H "#{secret}:#{data}"
-        end
-
-        def A1(auth, password)
-          "#{auth.username}:#{auth.realm}:#{password}"
-        end
-
-        def A2(auth)
-          "#{auth.method}:#{auth.uri}"
-        end
-
-        def digest(auth, password)
-          password_hash = passwords_hashed? ? password : H(A1(auth, password))
-
-          KD password_hash, "#{auth.nonce}:#{auth.nc}:#{auth.cnonce}:#{QOP}:#{H A2(auth)}"
-        end
-
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/digest/nonce.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/digest/nonce.rb
deleted file mode 100644
index 3216d973e0dad..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/digest/nonce.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'digest/md5'
-require 'base64'
-
-module Rack
-  module Auth
-    module Digest
-      # Rack::Auth::Digest::Nonce is the default nonce generator for the
-      # Rack::Auth::Digest::MD5 authentication handler.
-      #
-      # +private_key+ needs to set to a constant string.
-      #
-      # +time_limit+ can be optionally set to an integer (number of seconds),
-      # to limit the validity of the generated nonces.
-
-      class Nonce
-
-        class << self
-          attr_accessor :private_key, :time_limit
-        end
-
-        def self.parse(string)
-          new(*Base64.decode64(string).split(' ', 2))
-        end
-
-        def initialize(timestamp = Time.now, given_digest = nil)
-          @timestamp, @given_digest = timestamp.to_i, given_digest
-        end
-
-        def to_s
-          Base64.encode64("#{@timestamp} #{digest}").strip
-        end
-
-        def digest
-          ::Digest::MD5.hexdigest("#{@timestamp}:#{self.class.private_key}")
-        end
-
-        def valid?
-          digest == @given_digest
-        end
-
-        def stale?
-          !self.class.time_limit.nil? && (Time.now.to_i - @timestamp) > self.class.time_limit
-        end
-
-        def fresh?
-          !stale?
-        end
-
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/digest/params.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/digest/params.rb
deleted file mode 100644
index f611b3c35eb4d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/digest/params.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  module Auth
-    module Digest
-      class Params < Hash
-
-        def self.parse(str)
-          Params[*split_header_value(str).map do |param|
-            k, v = param.split('=', 2)
-            [k, dequote(v)]
-          end.flatten]
-        end
-
-        def self.dequote(str) # From WEBrick::HTTPUtils
-          ret = (/\A"(.*)"\Z/ =~ str) ? $1 : str.dup
-          ret.gsub!(/\\(.)/, "\\1")
-          ret
-        end
-
-        def self.split_header_value(str)
-          str.scan(/\w+\=(?:"[^\"]+"|[^,]+)/n)
-        end
-
-        def initialize
-          super()
-
-          yield self if block_given?
-        end
-
-        def [](k)
-          super k.to_s
-        end
-
-        def []=(k, v)
-          super k.to_s, v.to_s
-        end
-
-        UNQUOTED = ['nc', 'stale']
-
-        def to_s
-          map do |k, v|
-            "#{k}=#{(UNQUOTED.include?(k) ? v.to_s : quote(v))}"
-          end.join(', ')
-        end
-
-        def quote(str) # From WEBrick::HTTPUtils
-          '"' + str.gsub(/[\\\"]/o, "\\\1") + '"'
-        end
-
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/digest/request.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/digest/request.rb
deleted file mode 100644
index 7b89b76052272..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/auth/digest/request.rb
+++ /dev/null
@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../abstract/request'
-require_relative 'params'
-require_relative 'nonce'
-
-module Rack
-  module Auth
-    module Digest
-      class Request < Auth::AbstractRequest
-        def method
-          @env[RACK_METHODOVERRIDE_ORIGINAL_METHOD] || @env[REQUEST_METHOD]
-        end
-
-        def digest?
-          "digest" == scheme
-        end
-
-        def correct_uri?
-          request.fullpath == uri
-        end
-
-        def nonce
-          @nonce ||= Nonce.parse(params['nonce'])
-        end
-
-        def params
-          @params ||= Params.parse(parts.last)
-        end
-
-        def respond_to?(sym, *)
-          super or params.has_key? sym.to_s
-        end
-
-        def method_missing(sym, *args)
-          return super unless params.has_key?(key = sym.to_s)
-          return params[key] if args.size == 0
-          raise ArgumentError, "wrong number of arguments (#{args.size} for 0)"
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/body_proxy.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/body_proxy.rb
deleted file mode 100644
index cfc0796a612e0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/body_proxy.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  # Proxy for response bodies allowing calling a block when
-  # the response body is closed (after the response has been fully
-  # sent to the client).
-  class BodyProxy
-    # Set the response body to wrap, and the block to call when the
-    # response has been fully sent.
-    def initialize(body, &block)
-      @body = body
-      @block = block
-      @closed = false
-    end
-
-    # Return whether the wrapped body responds to the method.
-    def respond_to_missing?(method_name, include_all = false)
-      super or @body.respond_to?(method_name, include_all)
-    end
-
-    # If not already closed, close the wrapped body and
-    # then call the block the proxy was initialized with.
-    def close
-      return if @closed
-      @closed = true
-      begin
-        @body.close if @body.respond_to? :close
-      ensure
-        @block.call
-      end
-    end
-
-    # Whether the proxy is closed.  The proxy starts as not closed,
-    # and becomes closed on the first call to close.
-    def closed?
-      @closed
-    end
-
-    # Delegate missing methods to the wrapped body.
-    def method_missing(method_name, *args, &block)
-      @body.__send__(method_name, *args, &block)
-    end
-    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/builder.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/builder.rb
deleted file mode 100644
index 816ecf62085ef..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/builder.rb
+++ /dev/null
@@ -1,257 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  # Rack::Builder implements a small DSL to iteratively construct Rack
-  # applications.
-  #
-  # Example:
-  #
-  #  require 'rack/lobster'
-  #  app = Rack::Builder.new do
-  #    use Rack::CommonLogger
-  #    use Rack::ShowExceptions
-  #    map "/lobster" do
-  #      use Rack::Lint
-  #      run Rack::Lobster.new
-  #    end
-  #  end
-  #
-  #  run app
-  #
-  # Or
-  #
-  #  app = Rack::Builder.app do
-  #    use Rack::CommonLogger
-  #    run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['OK']] }
-  #  end
-  #
-  #  run app
-  #
-  # +use+ adds middleware to the stack, +run+ dispatches to an application.
-  # You can use +map+ to construct a Rack::URLMap in a convenient way.
-
-  class Builder
-
-    # https://stackoverflow.com/questions/2223882/whats-the-difference-between-utf-8-and-utf-8-without-bom
-    UTF_8_BOM = '\xef\xbb\xbf'
-
-    # Parse the given config file to get a Rack application.
-    #
-    # If the config file ends in +.ru+, it is treated as a
-    # rackup file and the contents will be treated as if
-    # specified inside a Rack::Builder block, using the given
-    # options.
-    #
-    # If the config file does not end in +.ru+, it is
-    # required and Rack will use the basename of the file
-    # to guess which constant will be the Rack application to run.
-    # The options given will be ignored in this case.
-    #
-    # Examples:
-    #
-    #   Rack::Builder.parse_file('config.ru')
-    #   # Rack application built using Rack::Builder.new
-    #
-    #   Rack::Builder.parse_file('app.rb')
-    #   # requires app.rb, which can be anywhere in Ruby's
-    #   # load path. After requiring, assumes App constant
-    #   # contains Rack application
-    #
-    #   Rack::Builder.parse_file('./my_app.rb')
-    #   # requires ./my_app.rb, which should be in the
-    #   # process's current directory.  After requiring,
-    #   # assumes MyApp constant contains Rack application
-    def self.parse_file(config, opts = Server::Options.new)
-      if config.end_with?('.ru')
-        return self.load_file(config, opts)
-      else
-        require config
-        app = Object.const_get(::File.basename(config, '.rb').split('_').map(&:capitalize).join(''))
-        return app, {}
-      end
-    end
-
-    # Load the given file as a rackup file, treating the
-    # contents as if specified inside a Rack::Builder block.
-    #
-    # Treats the first comment at the beginning of a line
-    # that starts with a backslash as options similar to
-    # options passed on a rackup command line.
-    #
-    # Ignores content in the file after +__END__+, so that
-    # use of +__END__+ will not result in a syntax error.
-    #
-    # Example config.ru file:
-    #
-    #   $ cat config.ru
-    #
-    #   #\ -p 9393
-    #
-    #   use Rack::ContentLength
-    #   require './app.rb'
-    #   run App
-    def self.load_file(path, opts = Server::Options.new)
-      options = {}
-
-      cfgfile = ::File.read(path)
-      cfgfile.slice!(/\A#{UTF_8_BOM}/) if cfgfile.encoding == Encoding::UTF_8
-
-      if cfgfile[/^#\\(.*)/] && opts
-        warn "Parsing options from the first comment line is deprecated!"
-        options = opts.parse! $1.split(/\s+/)
-      end
-
-      cfgfile.sub!(/^__END__\n.*\Z/m, '')
-      app = new_from_string cfgfile, path
-
-      return app, options
-    end
-
-    # Evaluate the given +builder_script+ string in the context of
-    # a Rack::Builder block, returning a Rack application.
-    def self.new_from_string(builder_script, file = "(rackup)")
-      # We want to build a variant of TOPLEVEL_BINDING with self as a Rack::Builder instance.
-      # We cannot use instance_eval(String) as that would resolve constants differently.
-      binding, builder = TOPLEVEL_BINDING.eval('Rack::Builder.new.instance_eval { [binding, self] }')
-      eval builder_script, binding, file
-      builder.to_app
-    end
-
-    # Initialize a new Rack::Builder instance.  +default_app+ specifies the
-    # default application if +run+ is not called later.  If a block
-    # is given, it is evaluted in the context of the instance.
-    def initialize(default_app = nil, &block)
-      @use, @map, @run, @warmup, @freeze_app = [], nil, default_app, nil, false
-      instance_eval(&block) if block_given?
-    end
-
-    # Create a new Rack::Builder instance and return the Rack application
-    # generated from it.
-    def self.app(default_app = nil, &block)
-      self.new(default_app, &block).to_app
-    end
-
-    # Specifies middleware to use in a stack.
-    #
-    #   class Middleware
-    #     def initialize(app)
-    #       @app = app
-    #     end
-    #
-    #     def call(env)
-    #       env["rack.some_header"] = "setting an example"
-    #       @app.call(env)
-    #     end
-    #   end
-    #
-    #   use Middleware
-    #   run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }
-    #
-    # All requests through to this application will first be processed by the middleware class.
-    # The +call+ method in this example sets an additional environment key which then can be
-    # referenced in the application if required.
-    def use(middleware, *args, &block)
-      if @map
-        mapping, @map = @map, nil
-        @use << proc { |app| generate_map(app, mapping) }
-      end
-      @use << proc { |app| middleware.new(app, *args, &block) }
-    end
-    ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
-
-    # Takes an argument that is an object that responds to #call and returns a Rack response.
-    # The simplest form of this is a lambda object:
-    #
-    #   run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }
-    #
-    # However this could also be a class:
-    #
-    #   class Heartbeat
-    #     def self.call(env)
-    #      [200, { "Content-Type" => "text/plain" }, ["OK"]]
-    #     end
-    #   end
-    #
-    #   run Heartbeat
-    def run(app)
-      @run = app
-    end
-
-    # Takes a lambda or block that is used to warm-up the application. This block is called
-    # before the Rack application is returned by to_app.
-    #
-    #   warmup do |app|
-    #     client = Rack::MockRequest.new(app)
-    #     client.get('/')
-    #   end
-    #
-    #   use SomeMiddleware
-    #   run MyApp
-    def warmup(prc = nil, &block)
-      @warmup = prc || block
-    end
-
-    # Creates a route within the application.  Routes under the mapped path will be sent to
-    # the Rack application specified by run inside the block.  Other requests will be sent to the
-    # default application specified by run outside the block.
-    #
-    #   Rack::Builder.app do
-    #     map '/heartbeat' do
-    #       run Heartbeat
-    #     end
-    #     run App
-    #   end
-    #
-    # The +use+ method can also be used inside the block to specify middleware to run under a specific path:
-    #
-    #   Rack::Builder.app do
-    #     map '/heartbeat' do
-    #       use Middleware
-    #       run Heartbeat
-    #     end
-    #     run App
-    #   end
-    #
-    # This example includes a piece of middleware which will run before +/heartbeat+ requests hit +Heartbeat+.
-    #
-    # Note that providing a +path+ of +/+ will ignore any default application given in a +run+ statement
-    # outside the block.
-    def map(path, &block)
-      @map ||= {}
-      @map[path] = block
-    end
-
-    # Freeze the app (set using run) and all middleware instances when building the application
-    # in to_app.
-    def freeze_app
-      @freeze_app = true
-    end
-
-    # Return the Rack application generated by this instance.
-    def to_app
-      app = @map ? generate_map(@run, @map) : @run
-      fail "missing run or map statement" unless app
-      app.freeze if @freeze_app
-      app = @use.reverse.inject(app) { |a, e| e[a].tap { |x| x.freeze if @freeze_app } }
-      @warmup.call(app) if @warmup
-      app
-    end
-
-    # Call the Rack application generated by this builder instance. Note that
-    # this rebuilds the Rack application and runs the warmup code (if any)
-    # every time it is called, so it should not be used if performance is important.
-    def call(env)
-      to_app.call(env)
-    end
-
-    private
-
-    # Generate a URLMap instance by generating new Rack applications for each
-    # map block in this instance.
-    def generate_map(default_app, mapping)
-      mapped = default_app ? { '/' => default_app } : {}
-      mapping.each { |r, b| mapped[r] = self.class.new(default_app, &b).to_app }
-      URLMap.new(mapped)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/cascade.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/cascade.rb
deleted file mode 100644
index d71274c2b7cca..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/cascade.rb
+++ /dev/null
@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  # Rack::Cascade tries a request on several apps, and returns the
-  # first response that is not 404 or 405 (or in a list of configured
-  # status codes).  If all applications tried return one of the configured
-  # status codes, return the last response.
-
-  class Cascade
-    # deprecated, no longer used
-    NotFound = [404, { CONTENT_TYPE => "text/plain" }, []]
-
-    # An array of applications to try in order.
-    attr_reader :apps
-
-    # Set the apps to send requests to, and what statuses result in
-    # cascading.  Arguments:
-    #
-    # apps: An enumerable of rack applications.
-    # cascade_for: The statuses to use cascading for.  If a response is received
-    #              from an app, the next app is tried.
-    def initialize(apps, cascade_for = [404, 405])
-      @apps = []
-      apps.each { |app| add app }
-
-      @cascade_for = {}
-      [*cascade_for].each { |status| @cascade_for[status] = true }
-    end
-
-    # Call each app in order.  If the responses uses a status that requires
-    # cascading, try the next app.  If all responses require cascading,
-    # return the response from the last app.
-    def call(env)
-      return [404, { CONTENT_TYPE => "text/plain" }, []] if @apps.empty?
-      result = nil
-      last_body = nil
-
-      @apps.each do |app|
-        # The SPEC says that the body must be closed after it has been iterated
-        # by the server, or if it is replaced by a middleware action. Cascade
-        # replaces the body each time a cascade happens. It is assumed that nil
-        # does not respond to close, otherwise the previous application body
-        # will be closed. The final application body will not be closed, as it
-        # will be passed to the server as a result.
-        last_body.close if last_body.respond_to? :close
-
-        result = app.call(env)
-        return result unless @cascade_for.include?(result[0].to_i)
-        last_body = result[2]
-      end
-
-      result
-    end
-
-    # Append an app to the list of apps to cascade.  This app will
-    # be tried last.
-    def add(app)
-      @apps << app
-    end
-
-    # Whether the given app is one of the apps to cascade to.
-    def include?(app)
-      @apps.include?(app)
-    end
-
-    alias_method :<<, :add
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/chunked.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/chunked.rb
deleted file mode 100644
index 84c6600140524..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/chunked.rb
+++ /dev/null
@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-
-  # Middleware that applies chunked transfer encoding to response bodies
-  # when the response does not include a Content-Length header.
-  #
-  # This supports the Trailer response header to allow the use of trailing
-  # headers in the chunked encoding.  However, using this requires you manually
-  # specify a response body that supports a +trailers+ method.  Example:
-  #
-  #   [200, { 'Trailer' => 'Expires'}, ["Hello", "World"]]
-  #   # error raised
-  #
-  #   body = ["Hello", "World"]
-  #   def body.trailers
-  #     { 'Expires' => Time.now.to_s }
-  #   end
-  #   [200, { 'Trailer' => 'Expires'}, body]
-  #   # No exception raised
-  class Chunked
-    include Rack::Utils
-
-    # A body wrapper that emits chunked responses.
-    class Body
-      TERM = "\r\n"
-      TAIL = "0#{TERM}"
-
-      # Store the response body to be chunked.
-      def initialize(body)
-        @body = body
-      end
-
-      # For each element yielded by the response body, yield
-      # the element in chunked encoding.
-      def each(&block)
-        term = TERM
-        @body.each do |chunk|
-          size = chunk.bytesize
-          next if size == 0
-
-          yield [size.to_s(16), term, chunk.b, term].join
-        end
-        yield TAIL
-        yield_trailers(&block)
-        yield term
-      end
-
-      # Close the response body if the response body supports it.
-      def close
-        @body.close if @body.respond_to?(:close)
-      end
-
-      private
-
-      # Do nothing as this class does not support trailer headers.
-      def yield_trailers
-      end
-    end
-
-    # A body wrapper that emits chunked responses and also supports
-    # sending Trailer headers.  Note that the response body provided to
-    # initialize must have a +trailers+ method that returns a hash
-    # of trailer headers, and the rack response itself should have a
-    # Trailer header listing the headers that the +trailers+ method
-    # will return.
-    class TrailerBody < Body
-      private
-
-      # Yield strings for each trailer header.
-      def yield_trailers
-        @body.trailers.each_pair do |k, v|
-          yield "#{k}: #{v}\r\n"
-        end
-      end
-    end
-
-    def initialize(app)
-      @app = app
-    end
-
-    # Whether the HTTP version supports chunked encoding (HTTP 1.1 does).
-    def chunkable_version?(ver)
-      case ver
-      # pre-HTTP/1.0 (informally "HTTP/0.9") HTTP requests did not have
-      # a version (nor response headers)
-      when 'HTTP/1.0', nil, 'HTTP/0.9'
-        false
-      else
-        true
-      end
-    end
-
-    # If the rack app returns a response that should have a body,
-    # but does not have Content-Length or Transfer-Encoding headers,
-    # modify the response to use chunked Transfer-Encoding.
-    def call(env)
-      status, headers, body = @app.call(env)
-      headers = HeaderHash[headers]
-
-      if chunkable_version?(env[SERVER_PROTOCOL]) &&
-         !STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) &&
-         !headers[CONTENT_LENGTH] &&
-         !headers[TRANSFER_ENCODING]
-
-        headers[TRANSFER_ENCODING] = 'chunked'
-        if headers['Trailer']
-          body = TrailerBody.new(body)
-        else
-          body = Body.new(body)
-        end
-      end
-
-      [status, headers, body]
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/common_logger.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/common_logger.rb
deleted file mode 100644
index 9c6f92147d946..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/common_logger.rb
+++ /dev/null
@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  # Rack::CommonLogger forwards every request to the given +app+, and
-  # logs a line in the
-  # {Apache common log format}[http://httpd.apache.org/docs/1.3/logs.html#common]
-  # to the configured logger.
-  class CommonLogger
-    # Common Log Format: http://httpd.apache.org/docs/1.3/logs.html#common
-    #
-    #   lilith.local - - [07/Aug/2006 23:58:02 -0400] "GET / HTTP/1.1" 500 -
-    #
-    #   %{%s - %s [%s] "%s %s%s %s" %d %s\n} %
-    #
-    # The actual format is slightly different than the above due to the
-    # separation of SCRIPT_NAME and PATH_INFO, and because the elapsed
-    # time in seconds is included at the end.
-    FORMAT = %{%s - %s [%s] "%s %s%s%s %s" %d %s %0.4f\n}
-
-    # +logger+ can be any object that supports the +write+ or +<<+ methods,
-    # which includes the standard library Logger.  These methods are called
-    # with a single string argument, the log message.
-    # If +logger+ is nil, CommonLogger will fall back <tt>env['rack.errors']</tt>.
-    def initialize(app, logger = nil)
-      @app = app
-      @logger = logger
-    end
-
-    # Log all requests in common_log format after a response has been
-    # returned.  Note that if the app raises an exception, the request
-    # will not be logged, so if exception handling middleware are used,
-    # they should be loaded after this middleware.  Additionally, because
-    # the logging happens after the request body has been fully sent, any
-    # exceptions raised during the sending of the response body will
-    # cause the request not to be logged.
-    def call(env)
-      began_at = Utils.clock_time
-      status, headers, body = @app.call(env)
-      headers = Utils::HeaderHash[headers]
-      body = BodyProxy.new(body) { log(env, status, headers, began_at) }
-      [status, headers, body]
-    end
-
-    private
-
-    # Log the request to the configured logger.
-    def log(env, status, header, began_at)
-      length = extract_content_length(header)
-
-      msg = FORMAT % [
-        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
-        env["REMOTE_USER"] || "-",
-        Time.now.strftime("%d/%b/%Y:%H:%M:%S %z"),
-        env[REQUEST_METHOD],
-        env[SCRIPT_NAME],
-        env[PATH_INFO],
-        env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
-        env[SERVER_PROTOCOL],
-        status.to_s[0..3],
-        length,
-        Utils.clock_time - began_at ]
-
-      msg.gsub!(/[^[:print:]\n]/) { |c| "\\x#{c.ord}" }
-
-      logger = @logger || env[RACK_ERRORS]
-
-      # Standard library logger doesn't support write but it supports << which actually
-      # calls to write on the log device without formatting
-      if logger.respond_to?(:write)
-        logger.write(msg)
-      else
-        logger << msg
-      end
-    end
-
-    # Attempt to determine the content length for the response to
-    # include it in the logged data.
-    def extract_content_length(headers)
-      value = headers[CONTENT_LENGTH]
-      !value || value.to_s == '0' ? '-' : value
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/conditional_get.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/conditional_get.rb
deleted file mode 100644
index 7b7808ac1f770..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/conditional_get.rb
+++ /dev/null
@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-
-  # Middleware that enables conditional GET using If-None-Match and
-  # If-Modified-Since. The application should set either or both of the
-  # Last-Modified or Etag response headers according to RFC 2616. When
-  # either of the conditions is met, the response body is set to be zero
-  # length and the response status is set to 304 Not Modified.
-  #
-  # Applications that defer response body generation until the body's each
-  # message is received will avoid response body generation completely when
-  # a conditional GET matches.
-  #
-  # Adapted from Michael Klishin's Merb implementation:
-  # https://github.com/wycats/merb/blob/master/merb-core/lib/merb-core/rack/middleware/conditional_get.rb
-  class ConditionalGet
-    def initialize(app)
-      @app = app
-    end
-
-    # Return empty 304 response if the response has not been
-    # modified since the last request.
-    def call(env)
-      case env[REQUEST_METHOD]
-      when "GET", "HEAD"
-        status, headers, body = @app.call(env)
-        headers = Utils::HeaderHash[headers]
-        if status == 200 && fresh?(env, headers)
-          status = 304
-          headers.delete(CONTENT_TYPE)
-          headers.delete(CONTENT_LENGTH)
-          original_body = body
-          body = Rack::BodyProxy.new([]) do
-            original_body.close if original_body.respond_to?(:close)
-          end
-        end
-        [status, headers, body]
-      else
-        @app.call(env)
-      end
-    end
-
-  private
-
-    # Return whether the response has not been modified since the
-    # last request.
-    def fresh?(env, headers)
-      # If-None-Match has priority over If-Modified-Since per RFC 7232
-      if none_match = env['HTTP_IF_NONE_MATCH']
-        etag_matches?(none_match, headers)
-      elsif (modified_since = env['HTTP_IF_MODIFIED_SINCE']) && (modified_since = to_rfc2822(modified_since))
-        modified_since?(modified_since, headers)
-      end
-    end
-
-    # Whether the ETag response header matches the If-None-Match request header.
-    # If so, the request has not been modified.
-    def etag_matches?(none_match, headers)
-      headers['ETag'] == none_match
-    end
-
-    # Whether the Last-Modified response header matches the If-Modified-Since
-    # request header.  If so, the request has not been modified.
-    def modified_since?(modified_since, headers)
-      last_modified = to_rfc2822(headers['Last-Modified']) and
-        modified_since >= last_modified
-    end
-
-    # Return a Time object for the given string (which should be in RFC2822
-    # format), or nil if the string cannot be parsed.
-    def to_rfc2822(since)
-      # shortest possible valid date is the obsolete: 1 Nov 97 09:55 A
-      # anything shorter is invalid, this avoids exceptions for common cases
-      # most common being the empty string
-      if since && since.length >= 16
-        # NOTE: there is no trivial way to write this in a non exception way
-        #   _rfc2822 returns a hash but is not that usable
-        Time.rfc2822(since) rescue nil
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/config.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/config.rb
deleted file mode 100644
index 41f6f7dd57314..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/config.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  # Rack::Config modifies the environment using the block given during
-  # initialization.
-  #
-  # Example:
-  #     use Rack::Config do |env|
-  #       env['my-key'] = 'some-value'
-  #     end
-  class Config
-    def initialize(app, &block)
-      @app = app
-      @block = block
-    end
-
-    def call(env)
-      @block.call(env)
-      @app.call(env)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/content_length.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/content_length.rb
deleted file mode 100644
index 9e2b5fc42a1c1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/content_length.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-
-  # Sets the Content-Length header on responses that do not specify
-  # a Content-Length or Transfer-Encoding header.  Note that this
-  # does not fix responses that have an invalid Content-Length
-  # header specified.
-  class ContentLength
-    include Rack::Utils
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      headers = HeaderHash[headers]
-
-      if !STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) &&
-         !headers[CONTENT_LENGTH] &&
-         !headers[TRANSFER_ENCODING]
-
-        obody = body
-        body, length = [], 0
-        obody.each { |part| body << part; length += part.bytesize }
-
-        body = BodyProxy.new(body) do
-          obody.close if obody.respond_to?(:close)
-        end
-
-        headers[CONTENT_LENGTH] = length.to_s
-      end
-
-      [status, headers, body]
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/content_type.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/content_type.rb
deleted file mode 100644
index 503f7070621e7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/content_type.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-
-  # Sets the Content-Type header on responses which don't have one.
-  #
-  # Builder Usage:
-  #   use Rack::ContentType, "text/plain"
-  #
-  # When no content type argument is provided, "text/html" is the
-  # default.
-  class ContentType
-    include Rack::Utils
-
-    def initialize(app, content_type = "text/html")
-      @app, @content_type = app, content_type
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      headers = Utils::HeaderHash[headers]
-
-      unless STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i)
-        headers[CONTENT_TYPE] ||= @content_type
-      end
-
-      [status, headers, body]
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/core_ext/regexp.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/core_ext/regexp.rb
deleted file mode 100644
index a32fcdf629a3f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/core_ext/regexp.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-# Regexp has `match?` since Ruby 2.4
-# so to support Ruby < 2.4 we need to define this method
-
-module Rack
-  module RegexpExtensions
-    refine Regexp do
-      def match?(string, pos = 0)
-        !!match(string, pos)
-      end
-    end unless //.respond_to?(:match?)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/deflater.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/deflater.rb
deleted file mode 100644
index e177fabb017c9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/deflater.rb
+++ /dev/null
@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require "zlib"
-require "time"  # for Time.httpdate
-
-module Rack
-  # This middleware enables content encoding of http responses,
-  # usually for purposes of compression.
-  #
-  # Currently supported encodings:
-  #
-  # * gzip
-  # * identity (no transformation)
-  #
-  # This middleware automatically detects when encoding is supported
-  # and allowed. For example no encoding is made when a cache
-  # directive of 'no-transform' is present, when the response status
-  # code is one that doesn't allow an entity body, or when the body
-  # is empty.
-  #
-  # Note that despite the name, Deflater does not support the +deflate+
-  # encoding.
-  class Deflater
-    (require_relative 'core_ext/regexp'; using ::Rack::RegexpExtensions) if RUBY_VERSION < '2.4'
-
-    # Creates Rack::Deflater middleware. Options:
-    #
-    # :if :: a lambda enabling / disabling deflation based on returned boolean value
-    #        (e.g <tt>use Rack::Deflater, :if => lambda { |*, body| sum=0; body.each { |i| sum += i.length }; sum > 512 }</tt>).
-    #        However, be aware that calling `body.each` inside the block will break cases where `body.each` is not idempotent,
-    #        such as when it is an +IO+ instance.
-    # :include :: a list of content types that should be compressed. By default, all content types are compressed.
-    # :sync :: determines if the stream is going to be flushed after every chunk.  Flushing after every chunk reduces
-    #          latency for time-sensitive streaming applications, but hurts compression and throughput.
-    #          Defaults to +true+.
-    def initialize(app, options = {})
-      @app = app
-      @condition = options[:if]
-      @compressible_types = options[:include]
-      @sync = options.fetch(:sync, true)
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      headers = Utils::HeaderHash[headers]
-
-      unless should_deflate?(env, status, headers, body)
-        return [status, headers, body]
-      end
-
-      request = Request.new(env)
-
-      encoding = Utils.select_best_encoding(%w(gzip identity),
-                                            request.accept_encoding)
-
-      # Set the Vary HTTP header.
-      vary = headers["Vary"].to_s.split(",").map(&:strip)
-      unless vary.include?("*") || vary.include?("Accept-Encoding")
-        headers["Vary"] = vary.push("Accept-Encoding").join(",")
-      end
-
-      case encoding
-      when "gzip"
-        headers['Content-Encoding'] = "gzip"
-        headers.delete(CONTENT_LENGTH)
-        mtime = headers["Last-Modified"]
-        mtime = Time.httpdate(mtime).to_i if mtime
-        [status, headers, GzipStream.new(body, mtime, @sync)]
-      when "identity"
-        [status, headers, body]
-      when nil
-        message = "An acceptable encoding for the requested resource #{request.fullpath} could not be found."
-        bp = Rack::BodyProxy.new([message]) { body.close if body.respond_to?(:close) }
-        [406, { CONTENT_TYPE => "text/plain", CONTENT_LENGTH => message.length.to_s }, bp]
-      end
-    end
-
-    # Body class used for gzip encoded responses.
-    class GzipStream
-      # Initialize the gzip stream.  Arguments:
-      # body :: Response body to compress with gzip
-      # mtime :: The modification time of the body, used to set the
-      #          modification time in the gzip header.
-      # sync :: Whether to flush each gzip chunk as soon as it is ready.
-      def initialize(body, mtime, sync)
-        @body = body
-        @mtime = mtime
-        @sync = sync
-      end
-
-      # Yield gzip compressed strings to the given block.
-      def each(&block)
-        @writer = block
-        gzip = ::Zlib::GzipWriter.new(self)
-        gzip.mtime = @mtime if @mtime
-        @body.each { |part|
-          # Skip empty strings, as they would result in no output,
-          # and flushing empty parts would raise Zlib::BufError.
-          next if part.empty?
-
-          gzip.write(part)
-          gzip.flush if @sync
-        }
-      ensure
-        gzip.close
-      end
-
-      # Call the block passed to #each with the the gzipped data.
-      def write(data)
-        @writer.call(data)
-      end
-
-      # Close the original body if possible.
-      def close
-        @body.close if @body.respond_to?(:close)
-      end
-    end
-
-    private
-
-    # Whether the body should be compressed.
-    def should_deflate?(env, status, headers, body)
-      # Skip compressing empty entity body responses and responses with
-      # no-transform set.
-      if Utils::STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) ||
-          /\bno-transform\b/.match?(headers['Cache-Control'].to_s) ||
-          headers['Content-Encoding']&.!~(/\bidentity\b/)
-        return false
-      end
-
-      # Skip if @compressible_types are given and does not include request's content type
-      return false if @compressible_types && !(headers.has_key?('Content-Type') && @compressible_types.include?(headers['Content-Type'][/[^;]*/]))
-
-      # Skip if @condition lambda is given and evaluates to false
-      return false if @condition && !@condition.call(env, status, headers, body)
-
-      # No point in compressing empty body, also handles usage with
-      # Rack::Sendfile.
-      return false if headers[CONTENT_LENGTH] == '0'
-
-      true
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/directory.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/directory.rb
deleted file mode 100644
index be72be0144405..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/directory.rb
+++ /dev/null
@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-
-module Rack
-  # Rack::Directory serves entries below the +root+ given, according to the
-  # path info of the Rack request. If a directory is found, the file's contents
-  # will be presented in an html based index. If a file is found, the env will
-  # be passed to the specified +app+.
-  #
-  # If +app+ is not specified, a Rack::Files of the same +root+ will be used.
-
-  class Directory
-    DIR_FILE = "<tr><td class='name'><a href='%s'>%s</a></td><td class='size'>%s</td><td class='type'>%s</td><td class='mtime'>%s</td></tr>\n"
-    DIR_PAGE_HEADER = <<-PAGE
-<html><head>
-  <title>%s</title>
-  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
-  <style type='text/css'>
-table { width:100%%; }
-.name { text-align:left; }
-.size, .mtime { text-align:right; }
-.type { width:11em; }
-.mtime { width:15em; }
-  </style>
-</head><body>
-<h1>%s</h1>
-<hr />
-<table>
-  <tr>
-    <th class='name'>Name</th>
-    <th class='size'>Size</th>
-    <th class='type'>Type</th>
-    <th class='mtime'>Last Modified</th>
-  </tr>
-    PAGE
-    DIR_PAGE_FOOTER = <<-PAGE
-</table>
-<hr />
-</body></html>
-    PAGE
-
-    # Body class for directory entries, showing an index page with links
-    # to each file.
-    class DirectoryBody < Struct.new(:root, :path, :files)
-      # Yield strings for each part of the directory entry
-      def each
-        show_path = Utils.escape_html(path.sub(/^#{root}/, ''))
-        yield(DIR_PAGE_HEADER % [ show_path, show_path ])
-
-        unless path.chomp('/') == root
-          yield(DIR_FILE % DIR_FILE_escape(files.call('..')))
-        end
-
-        Dir.foreach(path) do |basename|
-          next if basename.start_with?('.')
-          next unless f = files.call(basename)
-          yield(DIR_FILE % DIR_FILE_escape(f))
-        end
-
-        yield(DIR_PAGE_FOOTER)
-      end
-
-      private
-
-      # Escape each element in the array of html strings.
-      def DIR_FILE_escape(htmls)
-        htmls.map { |e| Utils.escape_html(e) }
-      end
-    end
-
-    # The root of the directory hierarchy.  Only requests for files and
-    # directories inside of the root directory are supported.
-    attr_reader :root
-
-    # Set the root directory and application for serving files.
-    def initialize(root, app = nil)
-      @root = ::File.expand_path(root)
-      @app = app || Files.new(@root)
-      @head = Head.new(method(:get))
-    end
-
-    def call(env)
-      # strip body if this is a HEAD call
-      @head.call env
-    end
-
-    # Internals of request handling.  Similar to call but does
-    # not remove body for HEAD requests.
-    def get(env)
-      script_name = env[SCRIPT_NAME]
-      path_info = Utils.unescape_path(env[PATH_INFO])
-
-      if client_error_response = check_bad_request(path_info) || check_forbidden(path_info)
-        client_error_response
-      else
-        path = ::File.join(@root, path_info)
-        list_path(env, path, path_info, script_name)
-      end
-    end
-
-    # Rack response to use for requests with invalid paths, or nil if path is valid.
-    def check_bad_request(path_info)
-      return if Utils.valid_path?(path_info)
-
-      body = "Bad Request\n"
-      [400, { CONTENT_TYPE => "text/plain",
-        CONTENT_LENGTH => body.bytesize.to_s,
-        "X-Cascade" => "pass" }, [body]]
-    end
-
-    # Rack response to use for requests with paths outside the root, or nil if path is inside the root.
-    def check_forbidden(path_info)
-      return unless path_info.include? ".."
-      return if ::File.expand_path(::File.join(@root, path_info)).start_with?(@root)
-
-      body = "Forbidden\n"
-      [403, { CONTENT_TYPE => "text/plain",
-        CONTENT_LENGTH => body.bytesize.to_s,
-        "X-Cascade" => "pass" }, [body]]
-    end
-
-    # Rack response to use for directories under the root.
-    def list_directory(path_info, path, script_name)
-      url_head = (script_name.split('/') + path_info.split('/')).map do |part|
-        Utils.escape_path part
-      end
-
-      # Globbing not safe as path could contain glob metacharacters
-      body = DirectoryBody.new(@root, path, ->(basename) do
-        stat = stat(::File.join(path, basename))
-        next unless stat
-
-        url = ::File.join(*url_head + [Utils.escape_path(basename)])
-        mtime = stat.mtime.httpdate
-        if stat.directory?
-          type = 'directory'
-          size = '-'
-          url << '/'
-          if basename == '..'
-            basename = 'Parent Directory'
-          else
-            basename << '/'
-          end
-        else
-          type = Mime.mime_type(::File.extname(basename))
-          size = filesize_format(stat.size)
-        end
-
-        [ url, basename, size, type, mtime ]
-      end)
-
-      [ 200, { CONTENT_TYPE => 'text/html; charset=utf-8' }, body ]
-    end
-
-    # File::Stat for the given path, but return nil for missing/bad entries.
-    def stat(path)
-      ::File.stat(path)
-    rescue Errno::ENOENT, Errno::ELOOP
-      return nil
-    end
-
-    # Rack response to use for files and directories under the root.
-    # Unreadable and non-file, non-directory entries will get a 404 response.
-    def list_path(env, path, path_info, script_name)
-      if (stat = stat(path)) && stat.readable?
-        return @app.call(env) if stat.file?
-        return list_directory(path_info, path, script_name) if stat.directory?
-      end
-
-      entity_not_found(path_info)
-    end
-
-    # Rack response to use for unreadable and non-file, non-directory entries.
-    def entity_not_found(path_info)
-      body = "Entity not found: #{path_info}\n"
-      [404, { CONTENT_TYPE => "text/plain",
-        CONTENT_LENGTH => body.bytesize.to_s,
-        "X-Cascade" => "pass" }, [body]]
-    end
-
-    # Stolen from Ramaze
-    FILESIZE_FORMAT = [
-      ['%.1fT', 1 << 40],
-      ['%.1fG', 1 << 30],
-      ['%.1fM', 1 << 20],
-      ['%.1fK', 1 << 10],
-    ]
-
-    # Provide human readable file sizes
-    def filesize_format(int)
-      FILESIZE_FORMAT.each do |format, size|
-        return format % (int.to_f / size) if int >= size
-      end
-
-      "#{int}B"
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/etag.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/etag.rb
deleted file mode 100644
index 5039437e1c13e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/etag.rb
+++ /dev/null
@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../rack'
-require 'digest/sha2'
-
-module Rack
-  # Automatically sets the ETag header on all String bodies.
-  #
-  # The ETag header is skipped if ETag or Last-Modified headers are sent or if
-  # a sendfile body (body.responds_to :to_path) is given (since such cases
-  # should be handled by apache/nginx).
-  #
-  # On initialization, you can pass two parameters: a Cache-Control directive
-  # used when Etag is absent and a directive when it is present. The first
-  # defaults to nil, while the second defaults to "max-age=0, private, must-revalidate"
-  class ETag
-    ETAG_STRING = Rack::ETAG
-    DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate"
-
-    def initialize(app, no_cache_control = nil, cache_control = DEFAULT_CACHE_CONTROL)
-      @app = app
-      @cache_control = cache_control
-      @no_cache_control = no_cache_control
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-
-      headers = Utils::HeaderHash[headers]
-
-      if etag_status?(status) && etag_body?(body) && !skip_caching?(headers)
-        original_body = body
-        digest, new_body = digest_body(body)
-        body = Rack::BodyProxy.new(new_body) do
-          original_body.close if original_body.respond_to?(:close)
-        end
-        headers[ETAG_STRING] = %(W/"#{digest}") if digest
-      end
-
-      unless headers[CACHE_CONTROL]
-        if digest
-          headers[CACHE_CONTROL] = @cache_control if @cache_control
-        else
-          headers[CACHE_CONTROL] = @no_cache_control if @no_cache_control
-        end
-      end
-
-      [status, headers, body]
-    end
-
-    private
-
-      def etag_status?(status)
-        status == 200 || status == 201
-      end
-
-      def etag_body?(body)
-        !body.respond_to?(:to_path)
-      end
-
-      def skip_caching?(headers)
-        headers.key?(ETAG_STRING) || headers.key?('Last-Modified')
-      end
-
-      def digest_body(body)
-        parts = []
-        digest = nil
-
-        body.each do |part|
-          parts << part
-          (digest ||= Digest::SHA256.new) << part unless part.empty?
-        end
-
-        [digest && digest.hexdigest.byteslice(0, 32), parts]
-      end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/events.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/events.rb
deleted file mode 100644
index 65055fdc51e6d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/events.rb
+++ /dev/null
@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  ### This middleware provides hooks to certain places in the request /
-  # response lifecycle.  This is so that middleware that don't need to filter
-  # the response data can safely leave it alone and not have to send messages
-  # down the traditional "rack stack".
-  #
-  # The events are:
-  #
-  # * on_start(request, response)
-  #
-  #   This event is sent at the start of the request, before the next
-  #   middleware in the chain is called.  This method is called with a request
-  #   object, and a response object.  Right now, the response object is always
-  #   nil, but in the future it may actually be a real response object.
-  #
-  # * on_commit(request, response)
-  #
-  #   The response has been committed.  The application has returned, but the
-  #   response has not been sent to the webserver yet.  This method is always
-  #   called with a request object and the response object.  The response
-  #   object is constructed from the rack triple that the application returned.
-  #   Changes may still be made to the response object at this point.
-  #
-  # * on_send(request, response)
-  #
-  #   The webserver has started iterating over the response body and presumably
-  #   has started sending data over the wire. This method is always called with
-  #   a request object and the response object.  The response object is
-  #   constructed from the rack triple that the application returned.  Changes
-  #   SHOULD NOT be made to the response object as the webserver has already
-  #   started sending data.  Any mutations will likely result in an exception.
-  #
-  # * on_finish(request, response)
-  #
-  #   The webserver has closed the response, and all data has been written to
-  #   the response socket.  The request and response object should both be
-  #   read-only at this point.  The body MAY NOT be available on the response
-  #   object as it may have been flushed to the socket.
-  #
-  # * on_error(request, response, error)
-  #
-  #   An exception has occurred in the application or an `on_commit` event.
-  #   This method will get the request, the response (if available) and the
-  #   exception that was raised.
-  #
-  # ## Order
-  #
-  # `on_start` is called on the handlers in the order that they were passed to
-  # the constructor.  `on_commit`, on_send`, `on_finish`, and `on_error` are
-  # called in the reverse order.  `on_finish` handlers are called inside an
-  # `ensure` block, so they are guaranteed to be called even if something
-  # raises an exception.  If something raises an exception in a `on_finish`
-  # method, then nothing is guaranteed.
-
-  class Events
-    module Abstract
-      def on_start(req, res)
-      end
-
-      def on_commit(req, res)
-      end
-
-      def on_send(req, res)
-      end
-
-      def on_finish(req, res)
-      end
-
-      def on_error(req, res, e)
-      end
-    end
-
-    class EventedBodyProxy < Rack::BodyProxy # :nodoc:
-      attr_reader :request, :response
-
-      def initialize(body, request, response, handlers, &block)
-        super(body, &block)
-        @request  = request
-        @response = response
-        @handlers = handlers
-      end
-
-      def each
-        @handlers.reverse_each { |handler| handler.on_send request, response }
-        super
-      end
-    end
-
-    class BufferedResponse < Rack::Response::Raw # :nodoc:
-      attr_reader :body
-
-      def initialize(status, headers, body)
-        super(status, headers)
-        @body = body
-      end
-
-      def to_a; [status, headers, body]; end
-    end
-
-    def initialize(app, handlers)
-      @app      = app
-      @handlers = handlers
-    end
-
-    def call(env)
-      request = make_request env
-      on_start request, nil
-
-      begin
-        status, headers, body = @app.call request.env
-        response = make_response status, headers, body
-        on_commit request, response
-      rescue StandardError => e
-        on_error request, response, e
-        on_finish request, response
-        raise
-      end
-
-      body = EventedBodyProxy.new(body, request, response, @handlers) do
-        on_finish request, response
-      end
-      [response.status, response.headers, body]
-    end
-
-    private
-
-    def on_error(request, response, e)
-      @handlers.reverse_each { |handler| handler.on_error request, response, e }
-    end
-
-    def on_commit(request, response)
-      @handlers.reverse_each { |handler| handler.on_commit request, response }
-    end
-
-    def on_start(request, response)
-      @handlers.each { |handler| handler.on_start request, nil }
-    end
-
-    def on_finish(request, response)
-      @handlers.reverse_each { |handler| handler.on_finish request, response }
-    end
-
-    def make_request(env)
-      Rack::Request.new env
-    end
-
-    def make_response(status, headers, body)
-      BufferedResponse.new status, headers, body
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/file.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/file.rb
deleted file mode 100644
index fdcf9b3ec0645..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/file.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'files'
-
-module Rack
-  File = Files
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/files.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/files.rb
deleted file mode 100644
index e745eb3984373..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/files.rb
+++ /dev/null
@@ -1,218 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-
-module Rack
-  # Rack::Files serves files below the +root+ directory given, according to the
-  # path info of the Rack request.
-  # e.g. when Rack::Files.new("/etc") is used, you can access 'passwd' file
-  # as http://localhost:9292/passwd
-  #
-  # Handlers can detect if bodies are a Rack::Files, and use mechanisms
-  # like sendfile on the +path+.
-
-  class Files
-    ALLOWED_VERBS = %w[GET HEAD OPTIONS]
-    ALLOW_HEADER = ALLOWED_VERBS.join(', ')
-    MULTIPART_BOUNDARY = 'AaB03x'
-
-    # @todo remove in 3.0
-    def self.method_added(name)
-      if name == :response_body
-        raise "#{self.class}\#response_body is no longer supported."
-      end
-      super
-    end
-
-    attr_reader :root
-
-    def initialize(root, headers = {}, default_mime = 'text/plain')
-      @root = (::File.expand_path(root) if root)
-      @headers = headers
-      @default_mime = default_mime
-      @head = Rack::Head.new(lambda { |env| get env })
-    end
-
-    def call(env)
-      # HEAD requests drop the response body, including 4xx error messages.
-      @head.call env
-    end
-
-    def get(env)
-      request = Rack::Request.new env
-      unless ALLOWED_VERBS.include? request.request_method
-        return fail(405, "Method Not Allowed", { 'Allow' => ALLOW_HEADER })
-      end
-
-      path_info = Utils.unescape_path request.path_info
-      return fail(400, "Bad Request") unless Utils.valid_path?(path_info)
-
-      clean_path_info = Utils.clean_path_info(path_info)
-      path = ::File.join(@root, clean_path_info)
-
-      available = begin
-        ::File.file?(path) && ::File.readable?(path)
-      rescue SystemCallError
-        # Not sure in what conditions this exception can occur, but this
-        # is a safe way to handle such an error.
-        # :nocov:
-        false
-        # :nocov:
-      end
-
-      if available
-        serving(request, path)
-      else
-        fail(404, "File not found: #{path_info}")
-      end
-    end
-
-    def serving(request, path)
-      if request.options?
-        return [200, { 'Allow' => ALLOW_HEADER, CONTENT_LENGTH => '0' }, []]
-      end
-      last_modified = ::File.mtime(path).httpdate
-      return [304, {}, []] if request.get_header('HTTP_IF_MODIFIED_SINCE') == last_modified
-
-      headers = { "Last-Modified" => last_modified }
-      mime_type = mime_type path, @default_mime
-      headers[CONTENT_TYPE] = mime_type if mime_type
-
-      # Set custom headers
-      headers.merge!(@headers) if @headers
-
-      status = 200
-      size = filesize path
-
-      ranges = Rack::Utils.get_byte_ranges(request.get_header('HTTP_RANGE'), size)
-      if ranges.nil?
-        # No ranges:
-        ranges = [0..size - 1]
-      elsif ranges.empty?
-        # Unsatisfiable. Return error, and file size:
-        response = fail(416, "Byte range unsatisfiable")
-        response[1]["Content-Range"] = "bytes */#{size}"
-        return response
-      elsif ranges.size >= 1
-        # Partial content
-        partial_content = true
-
-        if ranges.size == 1
-          range = ranges[0]
-          headers["Content-Range"] = "bytes #{range.begin}-#{range.end}/#{size}"
-        else
-          headers[CONTENT_TYPE] = "multipart/byteranges; boundary=#{MULTIPART_BOUNDARY}"
-        end
-
-        status = 206
-        body = BaseIterator.new(path, ranges, mime_type: mime_type, size: size)
-        size = body.bytesize
-      end
-
-      headers[CONTENT_LENGTH] = size.to_s
-
-      if request.head?
-        body = []
-      elsif !partial_content
-        body = Iterator.new(path, ranges, mime_type: mime_type, size: size)
-      end
-
-      [status, headers, body]
-    end
-
-    class BaseIterator
-      attr_reader :path, :ranges, :options
-
-      def initialize(path, ranges, options)
-        @path = path
-        @ranges = ranges
-        @options = options
-      end
-
-      def each
-        ::File.open(path, "rb") do |file|
-          ranges.each do |range|
-            yield multipart_heading(range) if multipart?
-
-            each_range_part(file, range) do |part|
-              yield part
-            end
-          end
-
-          yield "\r\n--#{MULTIPART_BOUNDARY}--\r\n" if multipart?
-        end
-      end
-
-      def bytesize
-        size = ranges.inject(0) do |sum, range|
-          sum += multipart_heading(range).bytesize if multipart?
-          sum += range.size
-        end
-        size += "\r\n--#{MULTIPART_BOUNDARY}--\r\n".bytesize if multipart?
-        size
-      end
-
-      def close; end
-
-      private
-
-      def multipart?
-        ranges.size > 1
-      end
-
-      def multipart_heading(range)
-<<-EOF
-\r
---#{MULTIPART_BOUNDARY}\r
-Content-Type: #{options[:mime_type]}\r
-Content-Range: bytes #{range.begin}-#{range.end}/#{options[:size]}\r
-\r
-EOF
-      end
-
-      def each_range_part(file, range)
-        file.seek(range.begin)
-        remaining_len = range.end - range.begin + 1
-        while remaining_len > 0
-          part = file.read([8192, remaining_len].min)
-          break unless part
-          remaining_len -= part.length
-
-          yield part
-        end
-      end
-    end
-
-    class Iterator < BaseIterator
-      alias :to_path :path
-    end
-
-    private
-
-    def fail(status, body, headers = {})
-      body += "\n"
-
-      [
-        status,
-        {
-          CONTENT_TYPE   => "text/plain",
-          CONTENT_LENGTH => body.size.to_s,
-          "X-Cascade" => "pass"
-        }.merge!(headers),
-        [body]
-      ]
-    end
-
-    # The MIME type for the contents of the file located at @path
-    def mime_type(path, default_mime)
-      Mime.mime_type(::File.extname(path), default_mime)
-    end
-
-    def filesize(path)
-      #   We check via File::size? whether this file provides size info
-      #   via stat (e.g. /proc files often don't), otherwise we have to
-      #   figure it out by reading the whole file into memory.
-      ::File.size?(path) || ::File.read(path).bytesize
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler.rb
deleted file mode 100644
index df17b238ddb73..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler.rb
+++ /dev/null
@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  # *Handlers* connect web servers with Rack.
-  #
-  # Rack includes Handlers for Thin, WEBrick, FastCGI, CGI, SCGI
-  # and LiteSpeed.
-  #
-  # Handlers usually are activated by calling <tt>MyHandler.run(myapp)</tt>.
-  # A second optional hash can be passed to include server-specific
-  # configuration.
-  module Handler
-    def self.get(server)
-      return unless server
-      server = server.to_s
-
-      unless @handlers.include? server
-        load_error = try_require('rack/handler', server)
-      end
-
-      if klass = @handlers[server]
-        const_get(klass)
-      else
-        const_get(server, false)
-      end
-
-    rescue NameError => name_error
-      raise load_error || name_error
-    end
-
-    # Select first available Rack handler given an `Array` of server names.
-    # Raises `LoadError` if no handler was found.
-    #
-    #   > pick ['thin', 'webrick']
-    #   => Rack::Handler::WEBrick
-    def self.pick(server_names)
-      server_names = Array(server_names)
-      server_names.each do |server_name|
-        begin
-          return get(server_name.to_s)
-        rescue LoadError, NameError
-        end
-      end
-
-      raise LoadError, "Couldn't find handler for: #{server_names.join(', ')}."
-    end
-
-    SERVER_NAMES = %w(puma thin falcon webrick).freeze
-    private_constant :SERVER_NAMES
-
-    def self.default
-      # Guess.
-      if ENV.include?("PHP_FCGI_CHILDREN")
-        Rack::Handler::FastCGI
-      elsif ENV.include?(REQUEST_METHOD)
-        Rack::Handler::CGI
-      elsif ENV.include?("RACK_HANDLER")
-        self.get(ENV["RACK_HANDLER"])
-      else
-        pick SERVER_NAMES
-      end
-    end
-
-    # Transforms server-name constants to their canonical form as filenames,
-    # then tries to require them but silences the LoadError if not found
-    #
-    # Naming convention:
-    #
-    #   Foo # => 'foo'
-    #   FooBar # => 'foo_bar.rb'
-    #   FooBAR # => 'foobar.rb'
-    #   FOObar # => 'foobar.rb'
-    #   FOOBAR # => 'foobar.rb'
-    #   FooBarBaz # => 'foo_bar_baz.rb'
-    def self.try_require(prefix, const_name)
-      file = const_name.gsub(/^[A-Z]+/) { |pre| pre.downcase }.
-        gsub(/[A-Z]+[^A-Z]/, '_\&').downcase
-
-      require(::File.join(prefix, file))
-      nil
-    rescue LoadError => error
-      error
-    end
-
-    def self.register(server, klass)
-      @handlers ||= {}
-      @handlers[server.to_s] = klass.to_s
-    end
-
-    autoload :CGI, "rack/handler/cgi"
-    autoload :FastCGI, "rack/handler/fastcgi"
-    autoload :WEBrick, "rack/handler/webrick"
-    autoload :LSWS, "rack/handler/lsws"
-    autoload :SCGI, "rack/handler/scgi"
-    autoload :Thin, "rack/handler/thin"
-
-    register 'cgi', 'Rack::Handler::CGI'
-    register 'fastcgi', 'Rack::Handler::FastCGI'
-    register 'webrick', 'Rack::Handler::WEBrick'
-    register 'lsws', 'Rack::Handler::LSWS'
-    register 'scgi', 'Rack::Handler::SCGI'
-    register 'thin', 'Rack::Handler::Thin'
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/cgi.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/cgi.rb
deleted file mode 100644
index 1c11ab360622c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/cgi.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  module Handler
-    class CGI
-      def self.run(app, **options)
-        $stdin.binmode
-        serve app
-      end
-
-      def self.serve(app)
-        env = ENV.to_hash
-        env.delete "HTTP_CONTENT_LENGTH"
-
-        env[SCRIPT_NAME] = ""  if env[SCRIPT_NAME] == "/"
-
-        env.update(
-          RACK_VERSION      => Rack::VERSION,
-          RACK_INPUT        => Rack::RewindableInput.new($stdin),
-          RACK_ERRORS       => $stderr,
-          RACK_MULTITHREAD  => false,
-          RACK_MULTIPROCESS => true,
-          RACK_RUNONCE      => true,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(ENV[HTTPS]) ? "https" : "http"
-        )
-
-        env[QUERY_STRING] ||= ""
-        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
-        env[REQUEST_PATH] ||= "/"
-
-        status, headers, body = app.call(env)
-        begin
-          send_headers status, headers
-          send_body body
-        ensure
-          body.close  if body.respond_to? :close
-        end
-      end
-
-      def self.send_headers(status, headers)
-        $stdout.print "Status: #{status}\r\n"
-        headers.each { |k, vs|
-          vs.split("\n").each { |v|
-            $stdout.print "#{k}: #{v}\r\n"
-          }
-        }
-        $stdout.print "\r\n"
-        $stdout.flush
-      end
-
-      def self.send_body(body)
-        body.each { |part|
-          $stdout.print part
-          $stdout.flush
-        }
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/fastcgi.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/fastcgi.rb
deleted file mode 100644
index 1df123e02a65a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/fastcgi.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require 'fcgi'
-require 'socket'
-
-if defined? FCGI::Stream
-  class FCGI::Stream
-    alias _rack_read_without_buffer read
-
-    def read(n, buffer = nil)
-      buf = _rack_read_without_buffer n
-      buffer.replace(buf.to_s)  if buffer
-      buf
-    end
-  end
-end
-
-module Rack
-  module Handler
-    class FastCGI
-      def self.run(app, **options)
-        if options[:File]
-          STDIN.reopen(UNIXServer.new(options[:File]))
-        elsif options[:Port]
-          STDIN.reopen(TCPServer.new(options[:Host], options[:Port]))
-        end
-        FCGI.each { |request|
-          serve request, app
-        }
-      end
-
-      def self.valid_options
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-        {
-          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
-          "Port=PORT" => "Port to listen on (default: 8080)",
-          "File=PATH" => "Creates a Domain socket at PATH instead of a TCP socket. Ignores Host and Port if set.",
-        }
-      end
-
-      def self.serve(request, app)
-        env = request.env
-        env.delete "HTTP_CONTENT_LENGTH"
-
-        env[SCRIPT_NAME] = ""  if env[SCRIPT_NAME] == "/"
-
-        rack_input = RewindableInput.new(request.in)
-
-        env.update(
-          RACK_VERSION      => Rack::VERSION,
-          RACK_INPUT        => rack_input,
-          RACK_ERRORS       => request.err,
-          RACK_MULTITHREAD  => false,
-          RACK_MULTIPROCESS => true,
-          RACK_RUNONCE      => false,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http"
-        )
-
-        env[QUERY_STRING] ||= ""
-        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
-        env[REQUEST_PATH] ||= "/"
-        env.delete "CONTENT_TYPE"  if env["CONTENT_TYPE"] == ""
-        env.delete "CONTENT_LENGTH"  if env["CONTENT_LENGTH"] == ""
-
-        begin
-          status, headers, body = app.call(env)
-          begin
-            send_headers request.out, status, headers
-            send_body request.out, body
-          ensure
-            body.close  if body.respond_to? :close
-          end
-        ensure
-          rack_input.close
-          request.finish
-        end
-      end
-
-      def self.send_headers(out, status, headers)
-        out.print "Status: #{status}\r\n"
-        headers.each { |k, vs|
-          vs.split("\n").each { |v|
-            out.print "#{k}: #{v}\r\n"
-          }
-        }
-        out.print "\r\n"
-        out.flush
-      end
-
-      def self.send_body(out, body)
-        body.each { |part|
-          out.print part
-          out.flush
-        }
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/lsws.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/lsws.rb
deleted file mode 100644
index f12090bd62df9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/lsws.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'lsapi'
-
-module Rack
-  module Handler
-    class LSWS
-      def self.run(app, **options)
-        while LSAPI.accept != nil
-          serve app
-        end
-      end
-      def self.serve(app)
-        env = ENV.to_hash
-        env.delete "HTTP_CONTENT_LENGTH"
-        env[SCRIPT_NAME] = "" if env[SCRIPT_NAME] == "/"
-
-        rack_input = RewindableInput.new($stdin.read.to_s)
-
-        env.update(
-          RACK_VERSION      => Rack::VERSION,
-          RACK_INPUT        => rack_input,
-          RACK_ERRORS       => $stderr,
-          RACK_MULTITHREAD  => false,
-          RACK_MULTIPROCESS => true,
-          RACK_RUNONCE      => false,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(ENV[HTTPS]) ? "https" : "http"
-        )
-
-        env[QUERY_STRING] ||= ""
-        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
-        env[REQUEST_PATH] ||= "/"
-        status, headers, body = app.call(env)
-        begin
-          send_headers status, headers
-          send_body body
-        ensure
-          body.close if body.respond_to? :close
-        end
-      ensure
-        rack_input.close
-      end
-      def self.send_headers(status, headers)
-        print "Status: #{status}\r\n"
-        headers.each { |k, vs|
-          vs.split("\n").each { |v|
-            print "#{k}: #{v}\r\n"
-          }
-        }
-        print "\r\n"
-        STDOUT.flush
-      end
-      def self.send_body(body)
-        body.each { |part|
-          print part
-          STDOUT.flush
-        }
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/scgi.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/scgi.rb
deleted file mode 100644
index e3b8d3c6f240a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/scgi.rb
+++ /dev/null
@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'scgi'
-require 'stringio'
-
-module Rack
-  module Handler
-    class SCGI < ::SCGI::Processor
-      attr_accessor :app
-
-      def self.run(app, **options)
-        options[:Socket] = UNIXServer.new(options[:File]) if options[:File]
-        new(options.merge(app: app,
-                          host: options[:Host],
-                          port: options[:Port],
-                          socket: options[:Socket])).listen
-      end
-
-      def self.valid_options
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-        {
-          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
-          "Port=PORT" => "Port to listen on (default: 8080)",
-        }
-      end
-
-      def initialize(settings = {})
-        @app = settings[:app]
-        super(settings)
-      end
-
-      def process_request(request, input_body, socket)
-        env = Hash[request]
-        env.delete "HTTP_CONTENT_TYPE"
-        env.delete "HTTP_CONTENT_LENGTH"
-        env[REQUEST_PATH], env[QUERY_STRING] = env["REQUEST_URI"].split('?', 2)
-        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
-        env[PATH_INFO] = env[REQUEST_PATH]
-        env[QUERY_STRING] ||= ""
-        env[SCRIPT_NAME] = ""
-
-        rack_input = StringIO.new(input_body)
-        rack_input.set_encoding(Encoding::BINARY)
-
-        env.update(
-          RACK_VERSION      => Rack::VERSION,
-          RACK_INPUT        => rack_input,
-          RACK_ERRORS       => $stderr,
-          RACK_MULTITHREAD  => true,
-          RACK_MULTIPROCESS => true,
-          RACK_RUNONCE      => false,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http"
-        )
-
-        status, headers, body = app.call(env)
-        begin
-          socket.write("Status: #{status}\r\n")
-          headers.each do |k, vs|
-            vs.split("\n").each { |v| socket.write("#{k}: #{v}\r\n")}
-          end
-          socket.write("\r\n")
-          body.each {|s| socket.write(s)}
-        ensure
-          body.close if body.respond_to? :close
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/thin.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/thin.rb
deleted file mode 100644
index 393a6e98699dc..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/thin.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require "thin"
-require "thin/server"
-require "thin/logging"
-require "thin/backends/tcp_server"
-
-module Rack
-  module Handler
-    class Thin
-      def self.run(app, **options)
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-        host = options.delete(:Host) || default_host
-        port = options.delete(:Port) || 8080
-        args = [host, port, app, options]
-        # Thin versions below 0.8.0 do not support additional options
-        args.pop if ::Thin::VERSION::MAJOR < 1 && ::Thin::VERSION::MINOR < 8
-        server = ::Thin::Server.new(*args)
-        yield server if block_given?
-        server.start
-      end
-
-      def self.valid_options
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-        {
-          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
-          "Port=PORT" => "Port to listen on (default: 8080)",
-        }
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/webrick.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/webrick.rb
deleted file mode 100644
index d2f389758a33c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/handler/webrick.rb
+++ /dev/null
@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require 'webrick'
-require 'stringio'
-
-# This monkey patch allows for applications to perform their own chunking
-# through WEBrick::HTTPResponse if rack is set to true.
-class WEBrick::HTTPResponse
-  attr_accessor :rack
-
-  alias _rack_setup_header setup_header
-  def setup_header
-    app_chunking = rack && @header['transfer-encoding'] == 'chunked'
-
-    @chunked = app_chunking if app_chunking
-
-    _rack_setup_header
-
-    @chunked = false if app_chunking
-  end
-end
-
-module Rack
-  module Handler
-    class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
-      def self.run(app, **options)
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : nil
-
-        if !options[:BindAddress] || options[:Host]
-          options[:BindAddress] = options.delete(:Host) || default_host
-        end
-        options[:Port] ||= 8080
-        if options[:SSLEnable]
-          require 'webrick/https'
-        end
-
-        @server = ::WEBrick::HTTPServer.new(options)
-        @server.mount "/", Rack::Handler::WEBrick, app
-        yield @server  if block_given?
-        @server.start
-      end
-
-      def self.valid_options
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-        {
-          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
-          "Port=PORT" => "Port to listen on (default: 8080)",
-        }
-      end
-
-      def self.shutdown
-        if @server
-          @server.shutdown
-          @server = nil
-        end
-      end
-
-      def initialize(server, app)
-        super server
-        @app = app
-      end
-
-      def service(req, res)
-        res.rack = true
-        env = req.meta_vars
-        env.delete_if { |k, v| v.nil? }
-
-        rack_input = StringIO.new(req.body.to_s)
-        rack_input.set_encoding(Encoding::BINARY)
-
-        env.update(
-          RACK_VERSION      => Rack::VERSION,
-          RACK_INPUT        => rack_input,
-          RACK_ERRORS       => $stderr,
-          RACK_MULTITHREAD  => true,
-          RACK_MULTIPROCESS => false,
-          RACK_RUNONCE      => false,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http",
-          RACK_IS_HIJACK    => true,
-          RACK_HIJACK       => lambda { raise NotImplementedError, "only partial hijack is supported."},
-          RACK_HIJACK_IO    => nil
-        )
-
-        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
-        env[QUERY_STRING] ||= ""
-        unless env[PATH_INFO] == ""
-          path, n = req.request_uri.path, env[SCRIPT_NAME].length
-          env[PATH_INFO] = path[n, path.length - n]
-        end
-        env[REQUEST_PATH] ||= [env[SCRIPT_NAME], env[PATH_INFO]].join
-
-        status, headers, body = @app.call(env)
-        begin
-          res.status = status.to_i
-          io_lambda = nil
-          headers.each { |k, vs|
-            if k == RACK_HIJACK
-              io_lambda = vs
-            elsif k.downcase == "set-cookie"
-              res.cookies.concat vs.split("\n")
-            else
-              # Since WEBrick won't accept repeated headers,
-              # merge the values per RFC 1945 section 4.2.
-              res[k] = vs.split("\n").join(", ")
-            end
-          }
-
-          if io_lambda
-            rd, wr = IO.pipe
-            res.body = rd
-            res.chunked = true
-            io_lambda.call wr
-          elsif body.respond_to?(:to_path)
-            res.body = ::File.open(body.to_path, 'rb')
-          else
-            body.each { |part|
-              res.body << part
-            }
-          end
-        ensure
-          body.close  if body.respond_to? :close
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/head.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/head.rb
deleted file mode 100644
index 8025a27d514c2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/head.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  # Rack::Head returns an empty body for all HEAD requests. It leaves
-  # all other requests unchanged.
-  class Head
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-
-      if env[REQUEST_METHOD] == HEAD
-        [
-          status, headers, Rack::BodyProxy.new([]) do
-            body.close if body.respond_to? :close
-          end
-        ]
-      else
-        [status, headers, body]
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/lint.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/lint.rb
deleted file mode 100644
index 67d2eb1294c27..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/lint.rb
+++ /dev/null
@@ -1,806 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-module Rack
-  # Rack::Lint validates your application and the requests and
-  # responses according to the Rack spec.
-
-  class Lint
-    def initialize(app)
-      @app = app
-      @content_length = nil
-    end
-
-    # :stopdoc:
-
-    class LintError < RuntimeError; end
-    module Assertion
-      def assert(message)
-        unless yield
-          raise LintError, message
-        end
-      end
-    end
-    include Assertion
-
-    ## This specification aims to formalize the Rack protocol.  You
-    ## can (and should) use Rack::Lint to enforce it.
-    ##
-    ## When you develop middleware, be sure to add a Lint before and
-    ## after to catch all mistakes.
-
-    ## = Rack applications
-
-    ## A Rack application is a Ruby object (not a class) that
-    ## responds to +call+.
-    def call(env = nil)
-      dup._call(env)
-    end
-
-    def _call(env)
-      ## It takes exactly one argument, the *environment*
-      assert("No env given") { env }
-      check_env env
-
-      env[RACK_INPUT] = InputWrapper.new(env[RACK_INPUT])
-      env[RACK_ERRORS] = ErrorWrapper.new(env[RACK_ERRORS])
-
-      ## and returns an Array of exactly three values:
-      ary = @app.call(env)
-      assert("response is not an Array, but #{ary.class}") {
-        ary.kind_of? Array
-      }
-      assert("response array has #{ary.size} elements instead of 3") {
-        ary.size == 3
-      }
-
-      status, headers, @body = ary
-      ## The *status*,
-      check_status status
-      ## the *headers*,
-      check_headers headers
-
-      hijack_proc = check_hijack_response headers, env
-      if hijack_proc && headers.is_a?(Hash)
-        headers[RACK_HIJACK] = hijack_proc
-      end
-
-      ## and the *body*.
-      check_content_type status, headers
-      check_content_length status, headers
-      @head_request = env[REQUEST_METHOD] == HEAD
-      [status, headers, self]
-    end
-
-    ## == The Environment
-    def check_env(env)
-      ## The environment must be an unfrozen instance of Hash that includes
-      ## CGI-like headers.  The application is free to modify the
-      ## environment.
-      assert("env #{env.inspect} is not a Hash, but #{env.class}") {
-        env.kind_of? Hash
-      }
-      assert("env should not be frozen, but is") {
-        !env.frozen?
-      }
-
-      ##
-      ## The environment is required to include these variables
-      ## (adopted from PEP333), except when they'd be empty, but see
-      ## below.
-
-      ## <tt>REQUEST_METHOD</tt>:: The HTTP request method, such as
-      ##                           "GET" or "POST". This cannot ever
-      ##                           be an empty string, and so is
-      ##                           always required.
-
-      ## <tt>SCRIPT_NAME</tt>:: The initial portion of the request
-      ##                        URL's "path" that corresponds to the
-      ##                        application object, so that the
-      ##                        application knows its virtual
-      ##                        "location". This may be an empty
-      ##                        string, if the application corresponds
-      ##                        to the "root" of the server.
-
-      ## <tt>PATH_INFO</tt>:: The remainder of the request URL's
-      ##                      "path", designating the virtual
-      ##                      "location" of the request's target
-      ##                      within the application. This may be an
-      ##                      empty string, if the request URL targets
-      ##                      the application root and does not have a
-      ##                      trailing slash. This value may be
-      ##                      percent-encoded when originating from
-      ##                      a URL.
-
-      ## <tt>QUERY_STRING</tt>:: The portion of the request URL that
-      ##                         follows the <tt>?</tt>, if any. May be
-      ##                         empty, but is always required!
-
-      ## <tt>SERVER_NAME</tt>:: When combined with <tt>SCRIPT_NAME</tt> and
-      ##                        <tt>PATH_INFO</tt>, these variables can be
-      ##                        used to complete the URL. Note, however,
-      ##                        that <tt>HTTP_HOST</tt>, if present,
-      ##                        should be used in preference to
-      ##                        <tt>SERVER_NAME</tt> for reconstructing
-      ##                        the request URL.
-      ##                        <tt>SERVER_NAME</tt> can never be an empty
-      ##                        string, and so is always required.
-
-      ## <tt>SERVER_PORT</tt>:: An optional +Integer+ which is the port the
-      ##                        server is running on. Should be specified if
-      ##                        the server is running on a non-standard port.
-
-      ## <tt>HTTP_</tt> Variables:: Variables corresponding to the
-      ##                            client-supplied HTTP request
-      ##                            headers (i.e., variables whose
-      ##                            names begin with <tt>HTTP_</tt>). The
-      ##                            presence or absence of these
-      ##                            variables should correspond with
-      ##                            the presence or absence of the
-      ##                            appropriate HTTP header in the
-      ##                            request. See
-      ##                            {RFC3875 section 4.1.18}[https://tools.ietf.org/html/rfc3875#section-4.1.18]
-      ##                            for specific behavior.
-
-      ## In addition to this, the Rack environment must include these
-      ## Rack-specific variables:
-
-      ## <tt>rack.version</tt>:: The Array representing this version of Rack
-      ##                         See Rack::VERSION, that corresponds to
-      ##                         the version of this SPEC.
-
-      ## <tt>rack.url_scheme</tt>:: +http+ or +https+, depending on the
-      ##                            request URL.
-
-      ## <tt>rack.input</tt>:: See below, the input stream.
-
-      ## <tt>rack.errors</tt>:: See below, the error stream.
-
-      ## <tt>rack.multithread</tt>:: true if the application object may be
-      ##                             simultaneously invoked by another thread
-      ##                             in the same process, false otherwise.
-
-      ## <tt>rack.multiprocess</tt>:: true if an equivalent application object
-      ##                              may be simultaneously invoked by another
-      ##                              process, false otherwise.
-
-      ## <tt>rack.run_once</tt>:: true if the server expects
-      ##                          (but does not guarantee!) that the
-      ##                          application will only be invoked this one
-      ##                          time during the life of its containing
-      ##                          process. Normally, this will only be true
-      ##                          for a server based on CGI
-      ##                          (or something similar).
-
-      ## <tt>rack.hijack?</tt>:: present and true if the server supports
-      ##                         connection hijacking. See below, hijacking.
-
-      ## <tt>rack.hijack</tt>:: an object responding to #call that must be
-      ##                        called at least once before using
-      ##                        rack.hijack_io.
-      ##                        It is recommended #call return rack.hijack_io
-      ##                        as well as setting it in env if necessary.
-
-      ## <tt>rack.hijack_io</tt>:: if rack.hijack? is true, and rack.hijack
-      ##                           has received #call, this will contain
-      ##                           an object resembling an IO. See hijacking.
-
-      ## Additional environment specifications have approved to
-      ## standardized middleware APIs.  None of these are required to
-      ## be implemented by the server.
-
-      ## <tt>rack.session</tt>:: A hash like interface for storing
-      ##                         request session data.
-      ##                         The store must implement:
-      if session = env[RACK_SESSION]
-        ##                         store(key, value)         (aliased as []=);
-        assert("session #{session.inspect} must respond to store and []=") {
-          session.respond_to?(:store) && session.respond_to?(:[]=)
-        }
-
-        ##                         fetch(key, default = nil) (aliased as []);
-        assert("session #{session.inspect} must respond to fetch and []") {
-          session.respond_to?(:fetch) && session.respond_to?(:[])
-        }
-
-        ##                         delete(key);
-        assert("session #{session.inspect} must respond to delete") {
-          session.respond_to?(:delete)
-        }
-
-        ##                         clear;
-        assert("session #{session.inspect} must respond to clear") {
-          session.respond_to?(:clear)
-        }
-
-        ##                         to_hash (returning unfrozen Hash instance);
-        assert("session #{session.inspect} must respond to to_hash and return unfrozen Hash instance") {
-          session.respond_to?(:to_hash) && session.to_hash.kind_of?(Hash) && !session.to_hash.frozen?
-        }
-      end
-
-      ## <tt>rack.logger</tt>:: A common object interface for logging messages.
-      ##                        The object must implement:
-      if logger = env[RACK_LOGGER]
-        ##                         info(message, &block)
-        assert("logger #{logger.inspect} must respond to info") {
-          logger.respond_to?(:info)
-        }
-
-        ##                         debug(message, &block)
-        assert("logger #{logger.inspect} must respond to debug") {
-          logger.respond_to?(:debug)
-        }
-
-        ##                         warn(message, &block)
-        assert("logger #{logger.inspect} must respond to warn") {
-          logger.respond_to?(:warn)
-        }
-
-        ##                         error(message, &block)
-        assert("logger #{logger.inspect} must respond to error") {
-          logger.respond_to?(:error)
-        }
-
-        ##                         fatal(message, &block)
-        assert("logger #{logger.inspect} must respond to fatal") {
-          logger.respond_to?(:fatal)
-        }
-      end
-
-      ## <tt>rack.multipart.buffer_size</tt>:: An Integer hint to the multipart parser as to what chunk size to use for reads and writes.
-      if bufsize = env[RACK_MULTIPART_BUFFER_SIZE]
-        assert("rack.multipart.buffer_size must be an Integer > 0 if specified") {
-          bufsize.is_a?(Integer) && bufsize > 0
-        }
-      end
-
-      ## <tt>rack.multipart.tempfile_factory</tt>:: An object responding to #call with two arguments, the filename and content_type given for the multipart form field, and returning an IO-like object that responds to #<< and optionally #rewind. This factory will be used to instantiate the tempfile for each multipart form file upload field, rather than the default class of Tempfile.
-      if tempfile_factory = env[RACK_MULTIPART_TEMPFILE_FACTORY]
-        assert("rack.multipart.tempfile_factory must respond to #call") { tempfile_factory.respond_to?(:call) }
-        env[RACK_MULTIPART_TEMPFILE_FACTORY] = lambda do |filename, content_type|
-          io = tempfile_factory.call(filename, content_type)
-          assert("rack.multipart.tempfile_factory return value must respond to #<<") { io.respond_to?(:<<) }
-          io
-        end
-      end
-
-      ## The server or the application can store their own data in the
-      ## environment, too.  The keys must contain at least one dot,
-      ## and should be prefixed uniquely.  The prefix <tt>rack.</tt>
-      ## is reserved for use with the Rack core distribution and other
-      ## accepted specifications and must not be used otherwise.
-      ##
-
-      %w[REQUEST_METHOD SERVER_NAME QUERY_STRING
-         rack.version rack.input rack.errors
-         rack.multithread rack.multiprocess rack.run_once].each { |header|
-        assert("env missing required key #{header}") { env.include? header }
-      }
-
-      ## The <tt>SERVER_PORT</tt> must be an Integer if set.
-      assert("env[SERVER_PORT] is not an Integer") do
-        server_port = env["SERVER_PORT"]
-        server_port.nil? || (Integer(server_port) rescue false)
-      end
-
-      ## The <tt>SERVER_NAME</tt> must be a valid authority as defined by RFC7540.
-      assert("#{env[SERVER_NAME]} must be a valid authority") do
-        URI.parse("http://#{env[SERVER_NAME]}/") rescue false
-      end
-
-      ## The <tt>HTTP_HOST</tt> must be a valid authority as defined by RFC7540.
-      assert("#{env[HTTP_HOST]} must be a valid authority") do
-        URI.parse("http://#{env[HTTP_HOST]}/") rescue false
-      end
-
-      ## The environment must not contain the keys
-      ## <tt>HTTP_CONTENT_TYPE</tt> or <tt>HTTP_CONTENT_LENGTH</tt>
-      ## (use the versions without <tt>HTTP_</tt>).
-      %w[HTTP_CONTENT_TYPE HTTP_CONTENT_LENGTH].each { |header|
-        assert("env contains #{header}, must use #{header[5, -1]}") {
-          not env.include? header
-        }
-      }
-
-      ## The CGI keys (named without a period) must have String values.
-      ## If the string values for CGI keys contain non-ASCII characters,
-      ## they should use ASCII-8BIT encoding.
-      env.each { |key, value|
-        next  if key.include? "."   # Skip extensions
-        assert("env variable #{key} has non-string value #{value.inspect}") {
-          value.kind_of? String
-        }
-        next if value.encoding == Encoding::ASCII_8BIT
-        assert("env variable #{key} has value containing non-ASCII characters and has non-ASCII-8BIT encoding #{value.inspect} encoding: #{value.encoding}") {
-          value.b !~ /[\x80-\xff]/n
-        }
-      }
-
-      ## There are the following restrictions:
-
-      ## * <tt>rack.version</tt> must be an array of Integers.
-      assert("rack.version must be an Array, was #{env[RACK_VERSION].class}") {
-        env[RACK_VERSION].kind_of? Array
-      }
-      ## * <tt>rack.url_scheme</tt> must either be +http+ or +https+.
-      assert("rack.url_scheme unknown: #{env[RACK_URL_SCHEME].inspect}") {
-        %w[http https].include?(env[RACK_URL_SCHEME])
-      }
-
-      ## * There must be a valid input stream in <tt>rack.input</tt>.
-      check_input env[RACK_INPUT]
-      ## * There must be a valid error stream in <tt>rack.errors</tt>.
-      check_error env[RACK_ERRORS]
-      ## * There may be a valid hijack stream in <tt>rack.hijack_io</tt>
-      check_hijack env
-
-      ## * The <tt>REQUEST_METHOD</tt> must be a valid token.
-      assert("REQUEST_METHOD unknown: #{env[REQUEST_METHOD].dump}") {
-        env[REQUEST_METHOD] =~ /\A[0-9A-Za-z!\#$%&'*+.^_`|~-]+\z/
-      }
-
-      ## * The <tt>SCRIPT_NAME</tt>, if non-empty, must start with <tt>/</tt>
-      assert("SCRIPT_NAME must start with /") {
-        !env.include?(SCRIPT_NAME) ||
-        env[SCRIPT_NAME] == "" ||
-        env[SCRIPT_NAME] =~ /\A\//
-      }
-      ## * The <tt>PATH_INFO</tt>, if non-empty, must start with <tt>/</tt>
-      assert("PATH_INFO must start with /") {
-        !env.include?(PATH_INFO) ||
-        env[PATH_INFO] == "" ||
-        env[PATH_INFO] =~ /\A\//
-      }
-      ## * The <tt>CONTENT_LENGTH</tt>, if given, must consist of digits only.
-      assert("Invalid CONTENT_LENGTH: #{env["CONTENT_LENGTH"]}") {
-        !env.include?("CONTENT_LENGTH") || env["CONTENT_LENGTH"] =~ /\A\d+\z/
-      }
-
-      ## * One of <tt>SCRIPT_NAME</tt> or <tt>PATH_INFO</tt> must be
-      ##   set.  <tt>PATH_INFO</tt> should be <tt>/</tt> if
-      ##   <tt>SCRIPT_NAME</tt> is empty.
-      assert("One of SCRIPT_NAME or PATH_INFO must be set (make PATH_INFO '/' if SCRIPT_NAME is empty)") {
-        env[SCRIPT_NAME] || env[PATH_INFO]
-      }
-      ##   <tt>SCRIPT_NAME</tt> never should be <tt>/</tt>, but instead be empty.
-      assert("SCRIPT_NAME cannot be '/', make it '' and PATH_INFO '/'") {
-        env[SCRIPT_NAME] != "/"
-      }
-    end
-
-    ## === The Input Stream
-    ##
-    ## The input stream is an IO-like object which contains the raw HTTP
-    ## POST data.
-    def check_input(input)
-      ## When applicable, its external encoding must be "ASCII-8BIT" and it
-      ## must be opened in binary mode, for Ruby 1.9 compatibility.
-      assert("rack.input #{input} does not have ASCII-8BIT as its external encoding") {
-        input.external_encoding == Encoding::ASCII_8BIT
-      } if input.respond_to?(:external_encoding)
-      assert("rack.input #{input} is not opened in binary mode") {
-        input.binmode?
-      } if input.respond_to?(:binmode?)
-
-      ## The input stream must respond to +gets+, +each+, +read+ and +rewind+.
-      [:gets, :each, :read, :rewind].each { |method|
-        assert("rack.input #{input} does not respond to ##{method}") {
-          input.respond_to? method
-        }
-      }
-    end
-
-    class InputWrapper
-      include Assertion
-
-      def initialize(input)
-        @input = input
-      end
-
-      ## * +gets+ must be called without arguments and return a string,
-      ##   or +nil+ on EOF.
-      def gets(*args)
-        assert("rack.input#gets called with arguments") { args.size == 0 }
-        v = @input.gets
-        assert("rack.input#gets didn't return a String") {
-          v.nil? or v.kind_of? String
-        }
-        v
-      end
-
-      ## * +read+ behaves like IO#read.
-      ##   Its signature is <tt>read([length, [buffer]])</tt>.
-      ##
-      ##   If given, +length+ must be a non-negative Integer (>= 0) or +nil+,
-      ##   and +buffer+ must be a String and may not be nil.
-      ##
-      ##   If +length+ is given and not nil, then this method reads at most
-      ##   +length+ bytes from the input stream.
-      ##
-      ##   If +length+ is not given or nil, then this method reads
-      ##   all data until EOF.
-      ##
-      ##   When EOF is reached, this method returns nil if +length+ is given
-      ##   and not nil, or "" if +length+ is not given or is nil.
-      ##
-      ##   If +buffer+ is given, then the read data will be placed
-      ##   into +buffer+ instead of a newly created String object.
-      def read(*args)
-        assert("rack.input#read called with too many arguments") {
-          args.size <= 2
-        }
-        if args.size >= 1
-          assert("rack.input#read called with non-integer and non-nil length") {
-            args.first.kind_of?(Integer) || args.first.nil?
-          }
-          assert("rack.input#read called with a negative length") {
-            args.first.nil? || args.first >= 0
-          }
-        end
-        if args.size >= 2
-          assert("rack.input#read called with non-String buffer") {
-            args[1].kind_of?(String)
-          }
-        end
-
-        v = @input.read(*args)
-
-        assert("rack.input#read didn't return nil or a String") {
-          v.nil? or v.kind_of? String
-        }
-        if args[0].nil?
-          assert("rack.input#read(nil) returned nil on EOF") {
-            !v.nil?
-          }
-        end
-
-        v
-      end
-
-      ## * +each+ must be called without arguments and only yield Strings.
-      def each(*args)
-        assert("rack.input#each called with arguments") { args.size == 0 }
-        @input.each { |line|
-          assert("rack.input#each didn't yield a String") {
-            line.kind_of? String
-          }
-          yield line
-        }
-      end
-
-      ## * +rewind+ must be called without arguments. It rewinds the input
-      ##   stream back to the beginning. It must not raise Errno::ESPIPE:
-      ##   that is, it may not be a pipe or a socket. Therefore, handler
-      ##   developers must buffer the input data into some rewindable object
-      ##   if the underlying input stream is not rewindable.
-      def rewind(*args)
-        assert("rack.input#rewind called with arguments") { args.size == 0 }
-        assert("rack.input#rewind raised Errno::ESPIPE") {
-          begin
-            @input.rewind
-            true
-          rescue Errno::ESPIPE
-            false
-          end
-        }
-      end
-
-      ## * +close+ must never be called on the input stream.
-      def close(*args)
-        assert("rack.input#close must not be called") { false }
-      end
-    end
-
-    ## === The Error Stream
-    def check_error(error)
-      ## The error stream must respond to +puts+, +write+ and +flush+.
-      [:puts, :write, :flush].each { |method|
-        assert("rack.error #{error} does not respond to ##{method}") {
-          error.respond_to? method
-        }
-      }
-    end
-
-    class ErrorWrapper
-      include Assertion
-
-      def initialize(error)
-        @error = error
-      end
-
-      ## * +puts+ must be called with a single argument that responds to +to_s+.
-      def puts(str)
-        @error.puts str
-      end
-
-      ## * +write+ must be called with a single argument that is a String.
-      def write(str)
-        assert("rack.errors#write not called with a String") { str.kind_of? String }
-        @error.write str
-      end
-
-      ## * +flush+ must be called without arguments and must be called
-      ##   in order to make the error appear for sure.
-      def flush
-        @error.flush
-      end
-
-      ## * +close+ must never be called on the error stream.
-      def close(*args)
-        assert("rack.errors#close must not be called") { false }
-      end
-    end
-
-    class HijackWrapper
-      include Assertion
-      extend Forwardable
-
-      REQUIRED_METHODS = [
-        :read, :write, :read_nonblock, :write_nonblock, :flush, :close,
-        :close_read, :close_write, :closed?
-      ]
-
-      def_delegators :@io, *REQUIRED_METHODS
-
-      def initialize(io)
-        @io = io
-        REQUIRED_METHODS.each do |meth|
-          assert("rack.hijack_io must respond to #{meth}") { io.respond_to? meth }
-        end
-      end
-    end
-
-    ## === Hijacking
-    #
-    # AUTHORS: n.b. The trailing whitespace between paragraphs is important and
-    # should not be removed. The whitespace creates paragraphs in the RDoc
-    # output.
-    #
-    ## ==== Request (before status)
-    def check_hijack(env)
-      if env[RACK_IS_HIJACK]
-        ## If rack.hijack? is true then rack.hijack must respond to #call.
-        original_hijack = env[RACK_HIJACK]
-        assert("rack.hijack must respond to call") { original_hijack.respond_to?(:call) }
-        env[RACK_HIJACK] = proc do
-          ## rack.hijack must return the io that will also be assigned (or is
-          ## already present, in rack.hijack_io.
-          io = original_hijack.call
-          HijackWrapper.new(io)
-          ##
-          ## rack.hijack_io must respond to:
-          ## <tt>read, write, read_nonblock, write_nonblock, flush, close,
-          ## close_read, close_write, closed?</tt>
-          ##
-          ## The semantics of these IO methods must be a best effort match to
-          ## those of a normal ruby IO or Socket object, using standard
-          ## arguments and raising standard exceptions. Servers are encouraged
-          ## to simply pass on real IO objects, although it is recognized that
-          ## this approach is not directly compatible with SPDY and HTTP 2.0.
-          ##
-          ## IO provided in rack.hijack_io should preference the
-          ## IO::WaitReadable and IO::WaitWritable APIs wherever supported.
-          ##
-          ## There is a deliberate lack of full specification around
-          ## rack.hijack_io, as semantics will change from server to server.
-          ## Users are encouraged to utilize this API with a knowledge of their
-          ## server choice, and servers may extend the functionality of
-          ## hijack_io to provide additional features to users. The purpose of
-          ## rack.hijack is for Rack to "get out of the way", as such, Rack only
-          ## provides the minimum of specification and support.
-          env[RACK_HIJACK_IO] = HijackWrapper.new(env[RACK_HIJACK_IO])
-          io
-        end
-      else
-        ##
-        ## If rack.hijack? is false, then rack.hijack should not be set.
-        assert("rack.hijack? is false, but rack.hijack is present") { env[RACK_HIJACK].nil? }
-        ##
-        ## If rack.hijack? is false, then rack.hijack_io should not be set.
-        assert("rack.hijack? is false, but rack.hijack_io is present") { env[RACK_HIJACK_IO].nil? }
-      end
-    end
-
-    ## ==== Response (after headers)
-    ## It is also possible to hijack a response after the status and headers
-    ## have been sent.
-    def check_hijack_response(headers, env)
-
-      # this check uses headers like a hash, but the spec only requires
-      # headers respond to #each
-      headers = Rack::Utils::HeaderHash[headers]
-
-      ## In order to do this, an application may set the special header
-      ## <tt>rack.hijack</tt> to an object that responds to <tt>call</tt>
-      ## accepting an argument that conforms to the <tt>rack.hijack_io</tt>
-      ## protocol.
-      ##
-      ## After the headers have been sent, and this hijack callback has been
-      ## called, the application is now responsible for the remaining lifecycle
-      ## of the IO. The application is also responsible for maintaining HTTP
-      ## semantics. Of specific note, in almost all cases in the current SPEC,
-      ## applications will have wanted to specify the header Connection:close in
-      ## HTTP/1.1, and not Connection:keep-alive, as there is no protocol for
-      ## returning hijacked sockets to the web server. For that purpose, use the
-      ## body streaming API instead (progressively yielding strings via each).
-      ##
-      ## Servers must ignore the <tt>body</tt> part of the response tuple when
-      ## the <tt>rack.hijack</tt> response API is in use.
-
-      if env[RACK_IS_HIJACK] && headers[RACK_HIJACK]
-        assert('rack.hijack header must respond to #call') {
-          headers[RACK_HIJACK].respond_to? :call
-        }
-        original_hijack = headers[RACK_HIJACK]
-        proc do |io|
-          original_hijack.call HijackWrapper.new(io)
-        end
-      else
-        ##
-        ## The special response header <tt>rack.hijack</tt> must only be set
-        ## if the request env has <tt>rack.hijack?</tt> <tt>true</tt>.
-        assert('rack.hijack header must not be present if server does not support hijacking') {
-          headers[RACK_HIJACK].nil?
-        }
-
-        nil
-      end
-    end
-    ## ==== Conventions
-    ## * Middleware should not use hijack unless it is handling the whole
-    ##   response.
-    ## * Middleware may wrap the IO object for the response pattern.
-    ## * Middleware should not wrap the IO object for the request pattern. The
-    ##   request pattern is intended to provide the hijacker with "raw tcp".
-
-    ## == The Response
-
-    ## === The Status
-    def check_status(status)
-      ## This is an HTTP status. When parsed as integer (+to_i+), it must be
-      ## greater than or equal to 100.
-      assert("Status must be >=100 seen as integer") { status.to_i >= 100 }
-    end
-
-    ## === The Headers
-    def check_headers(header)
-      ## The header must respond to +each+, and yield values of key and value.
-      assert("headers object should respond to #each, but doesn't (got #{header.class} as headers)") {
-         header.respond_to? :each
-      }
-
-      header.each { |key, value|
-        ## The header keys must be Strings.
-        assert("header key must be a string, was #{key.class}") {
-          key.kind_of? String
-        }
-
-        ## Special headers starting "rack." are for communicating with the
-        ## server, and must not be sent back to the client.
-        next if key =~ /^rack\..+$/
-
-        ## The header must not contain a +Status+ key.
-        assert("header must not contain Status") { key.downcase != "status" }
-        ## The header must conform to RFC7230 token specification, i.e. cannot
-        ## contain non-printable ASCII, DQUOTE or "(),/:;<=>?@[\]{}".
-        assert("invalid header name: #{key}") { key !~ /[\(\),\/:;<=>\?@\[\\\]{}[:cntrl:]]/ }
-
-        ## The values of the header must be Strings,
-        assert("a header value must be a String, but the value of " +
-          "'#{key}' is a #{value.class}") { value.kind_of? String }
-        ## consisting of lines (for multiple header values, e.g. multiple
-        ## <tt>Set-Cookie</tt> values) separated by "\\n".
-        value.split("\n").each { |item|
-          ## The lines must not contain characters below 037.
-          assert("invalid header value #{key}: #{item.inspect}") {
-            item !~ /[\000-\037]/
-          }
-        }
-      }
-    end
-
-    ## === The Content-Type
-    def check_content_type(status, headers)
-      headers.each { |key, value|
-        ## There must not be a <tt>Content-Type</tt>, when the +Status+ is 1xx,
-        ## 204 or 304.
-        if key.downcase == "content-type"
-          assert("Content-Type header found in #{status} response, not allowed") {
-            not Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.key? status.to_i
-          }
-          return
-        end
-      }
-    end
-
-    ## === The Content-Length
-    def check_content_length(status, headers)
-      headers.each { |key, value|
-        if key.downcase == 'content-length'
-          ## There must not be a <tt>Content-Length</tt> header when the
-          ## +Status+ is 1xx, 204 or 304.
-          assert("Content-Length header found in #{status} response, not allowed") {
-            not Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.key? status.to_i
-          }
-          @content_length = value
-        end
-      }
-    end
-
-    def verify_content_length(bytes)
-      if @head_request
-        assert("Response body was given for HEAD request, but should be empty") {
-          bytes == 0
-        }
-      elsif @content_length
-        assert("Content-Length header was #{@content_length}, but should be #{bytes}") {
-          @content_length == bytes.to_s
-        }
-      end
-    end
-
-    ## === The Body
-    def each
-      @closed = false
-      bytes = 0
-
-      ## The Body must respond to +each+
-      assert("Response body must respond to each") do
-        @body.respond_to?(:each)
-      end
-
-      @body.each { |part|
-        ## and must only yield String values.
-        assert("Body yielded non-string value #{part.inspect}") {
-          part.kind_of? String
-        }
-        bytes += part.bytesize
-        yield part
-      }
-      verify_content_length(bytes)
-
-      ##
-      ## The Body itself should not be an instance of String, as this will
-      ## break in Ruby 1.9.
-      ##
-      ## If the Body responds to +close+, it will be called after iteration. If
-      ## the body is replaced by a middleware after action, the original body
-      ## must be closed first, if it responds to close.
-      # XXX howto: assert("Body has not been closed") { @closed }
-
-
-      ##
-      ## If the Body responds to +to_path+, it must return a String
-      ## identifying the location of a file whose contents are identical
-      ## to that produced by calling +each+; this may be used by the
-      ## server as an alternative, possibly more efficient way to
-      ## transport the response.
-
-      if @body.respond_to?(:to_path)
-        assert("The file identified by body.to_path does not exist") {
-          ::File.exist? @body.to_path
-        }
-      end
-
-      ##
-      ## The Body commonly is an Array of Strings, the application
-      ## instance itself, or a File-like object.
-    end
-
-    def close
-      @closed = true
-      @body.close  if @body.respond_to?(:close)
-    end
-
-    # :startdoc:
-
-  end
-end
-
-## == Thanks
-## Some parts of this specification are adopted from PEP333: Python
-## Web Server Gateway Interface
-## v1.0 (http://www.python.org/dev/peps/pep-0333/). I'd like to thank
-## everyone involved in that effort.
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/lobster.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/lobster.rb
deleted file mode 100644
index b86a625de0c2f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/lobster.rb
+++ /dev/null
@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require 'zlib'
-
-module Rack
-  # Paste has a Pony, Rack has a Lobster!
-  class Lobster
-    LobsterString = Zlib::Inflate.inflate("eJx9kEEOwyAMBO99xd7MAcytUhPlJyj2
-    P6jy9i4k9EQyGAnBarEXeCBqSkntNXsi/ZCvC48zGQoZKikGrFMZvgS5ZHd+aGWVuWwhVF0
-    t1drVmiR42HcWNz5w3QanT+2gIvTVCiE1lm1Y0eU4JGmIIbaKwextKn8rvW+p5PIwFl8ZWJ
-    I8jyiTlhTcYXkekJAzTyYN6E08A+dk8voBkAVTJQ==".delete("\n ").unpack("m*")[0])
-
-    LambdaLobster = lambda { |env|
-      if env[QUERY_STRING].include?("flip")
-        lobster = LobsterString.split("\n").
-          map { |line| line.ljust(42).reverse }.
-          join("\n")
-        href = "?"
-      else
-        lobster = LobsterString
-        href = "?flip"
-      end
-
-      content = ["<title>Lobstericious!</title>",
-                 "<pre>", lobster, "</pre>",
-                 "<a href='#{href}'>flip!</a>"]
-      length = content.inject(0) { |a, e| a + e.size }.to_s
-      [200, { CONTENT_TYPE => "text/html", CONTENT_LENGTH => length }, content]
-    }
-
-    def call(env)
-      req = Request.new(env)
-      if req.GET["flip"] == "left"
-        lobster = LobsterString.split("\n").map do |line|
-          line.ljust(42).reverse.
-            gsub('\\', 'TEMP').
-            gsub('/', '\\').
-            gsub('TEMP', '/').
-            gsub('{', '}').
-            gsub('(', ')')
-        end.join("\n")
-        href = "?flip=right"
-      elsif req.GET["flip"] == "crash"
-        raise "Lobster crashed"
-      else
-        lobster = LobsterString
-        href = "?flip=left"
-      end
-
-      res = Response.new
-      res.write "<title>Lobstericious!</title>"
-      res.write "<pre>"
-      res.write lobster
-      res.write "</pre>"
-      res.write "<p><a href='#{href}'>flip!</a></p>"
-      res.write "<p><a href='?flip=crash'>crash!</a></p>"
-      res.finish
-    end
-
-  end
-end
-
-if $0 == __FILE__
-  # :nocov:
-  require_relative '../rack'
-  Rack::Server.start(
-    app: Rack::ShowExceptions.new(Rack::Lint.new(Rack::Lobster.new)), Port: 9292
-  )
-  # :nocov:
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/lock.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/lock.rb
deleted file mode 100644
index 4bae3a9034e83..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/lock.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'thread'
-
-module Rack
-  # Rack::Lock locks every request inside a mutex, so that every request
-  # will effectively be executed synchronously.
-  class Lock
-    def initialize(app, mutex = Mutex.new)
-      @app, @mutex = app, mutex
-    end
-
-    def call(env)
-      @mutex.lock
-      @env = env
-      @old_rack_multithread = env[RACK_MULTITHREAD]
-      begin
-        response = @app.call(env.merge!(RACK_MULTITHREAD => false))
-        returned = response << BodyProxy.new(response.pop) { unlock }
-      ensure
-        unlock unless returned
-      end
-    end
-
-    private
-
-    def unlock
-      @mutex.unlock
-      @env[RACK_MULTITHREAD] = @old_rack_multithread
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/logger.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/logger.rb
deleted file mode 100644
index 6c4bede0cf37e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/logger.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'logger'
-
-module Rack
-  # Sets up rack.logger to write to rack.errors stream
-  class Logger
-    def initialize(app, level = ::Logger::INFO)
-      @app, @level = app, level
-    end
-
-    def call(env)
-      logger = ::Logger.new(env[RACK_ERRORS])
-      logger.level = @level
-
-      env[RACK_LOGGER] = logger
-      @app.call(env)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/media_type.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/media_type.rb
deleted file mode 100644
index 41937c9947e63..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/media_type.rb
+++ /dev/null
@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  # Rack::MediaType parse media type and parameters out of content_type string
-
-  class MediaType
-    SPLIT_PATTERN = %r{\s*[;,]\s*}
-
-    class << self
-      # The media type (type/subtype) portion of the CONTENT_TYPE header
-      # without any media type parameters. e.g., when CONTENT_TYPE is
-      # "text/plain;charset=utf-8", the media-type is "text/plain".
-      #
-      # For more information on the use of media types in HTTP, see:
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
-      def type(content_type)
-        return nil unless content_type
-        content_type.split(SPLIT_PATTERN, 2).first.tap &:downcase!
-      end
-
-      # The media type parameters provided in CONTENT_TYPE as a Hash, or
-      # an empty Hash if no CONTENT_TYPE or media-type parameters were
-      # provided.  e.g., when the CONTENT_TYPE is "text/plain;charset=utf-8",
-      # this method responds with the following Hash:
-      #   { 'charset' => 'utf-8' }
-      def params(content_type)
-        return {} if content_type.nil?
-
-        content_type.split(SPLIT_PATTERN)[1..-1].each_with_object({}) do |s, hsh|
-          k, v = s.split('=', 2)
-
-          hsh[k.tap(&:downcase!)] = strip_doublequotes(v)
-        end
-      end
-
-      private
-
-        def strip_doublequotes(str)
-          (str.start_with?('"') && str.end_with?('"')) ? str[1..-2] : str
-        end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/method_override.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/method_override.rb
deleted file mode 100644
index 453901fc60692..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/method_override.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  class MethodOverride
-    HTTP_METHODS = %w[GET HEAD PUT POST DELETE OPTIONS PATCH LINK UNLINK]
-
-    METHOD_OVERRIDE_PARAM_KEY = "_method"
-    HTTP_METHOD_OVERRIDE_HEADER = "HTTP_X_HTTP_METHOD_OVERRIDE"
-    ALLOWED_METHODS = %w[POST]
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      if allowed_methods.include?(env[REQUEST_METHOD])
-        method = method_override(env)
-        if HTTP_METHODS.include?(method)
-          env[RACK_METHODOVERRIDE_ORIGINAL_METHOD] = env[REQUEST_METHOD]
-          env[REQUEST_METHOD] = method
-        end
-      end
-
-      @app.call(env)
-    end
-
-    def method_override(env)
-      req = Request.new(env)
-      method = method_override_param(req) ||
-        env[HTTP_METHOD_OVERRIDE_HEADER]
-      begin
-        method.to_s.upcase
-      rescue ArgumentError
-        env[RACK_ERRORS].puts "Invalid string for method"
-      end
-    end
-
-    private
-
-    def allowed_methods
-      ALLOWED_METHODS
-    end
-
-    def method_override_param(req)
-      req.POST[METHOD_OVERRIDE_PARAM_KEY]
-    rescue Utils::InvalidParameterError, Utils::ParameterTypeError
-      req.get_header(RACK_ERRORS).puts "Invalid or incomplete POST params"
-    rescue EOFError
-      req.get_header(RACK_ERRORS).puts "Bad request content body"
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/mime.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/mime.rb
deleted file mode 100644
index f6c02c1fd6ad8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/mime.rb
+++ /dev/null
@@ -1,685 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  module Mime
-    # Returns String with mime type if found, otherwise use +fallback+.
-    # +ext+ should be filename extension in the '.ext' format that
-    #       File.extname(file) returns.
-    # +fallback+ may be any object
-    #
-    # Also see the documentation for MIME_TYPES
-    #
-    # Usage:
-    #     Rack::Mime.mime_type('.foo')
-    #
-    # This is a shortcut for:
-    #     Rack::Mime::MIME_TYPES.fetch('.foo', 'application/octet-stream')
-
-    def mime_type(ext, fallback = 'application/octet-stream')
-      MIME_TYPES.fetch(ext.to_s.downcase, fallback)
-    end
-    module_function :mime_type
-
-    # Returns true if the given value is a mime match for the given mime match
-    # specification, false otherwise.
-    #
-    #    Rack::Mime.match?('text/html', 'text/*') => true
-    #    Rack::Mime.match?('text/plain', '*') => true
-    #    Rack::Mime.match?('text/html', 'application/json') => false
-
-    def match?(value, matcher)
-      v1, v2 = value.split('/', 2)
-      m1, m2 = matcher.split('/', 2)
-
-      (m1 == '*' || v1 == m1) && (m2.nil? || m2 == '*' || m2 == v2)
-    end
-    module_function :match?
-
-    # List of most common mime-types, selected various sources
-    # according to their usefulness in a webserving scope for Ruby
-    # users.
-    #
-    # To amend this list with your local mime.types list you can use:
-    #
-    #     require 'webrick/httputils'
-    #     list = WEBrick::HTTPUtils.load_mime_types('/etc/mime.types')
-    #     Rack::Mime::MIME_TYPES.merge!(list)
-    #
-    # N.B. On Ubuntu the mime.types file does not include the leading period, so
-    # users may need to modify the data before merging into the hash.
-
-    MIME_TYPES = {
-      ".123"       => "application/vnd.lotus-1-2-3",
-      ".3dml"      => "text/vnd.in3d.3dml",
-      ".3g2"       => "video/3gpp2",
-      ".3gp"       => "video/3gpp",
-      ".a"         => "application/octet-stream",
-      ".acc"       => "application/vnd.americandynamics.acc",
-      ".ace"       => "application/x-ace-compressed",
-      ".acu"       => "application/vnd.acucobol",
-      ".aep"       => "application/vnd.audiograph",
-      ".afp"       => "application/vnd.ibm.modcap",
-      ".ai"        => "application/postscript",
-      ".aif"       => "audio/x-aiff",
-      ".aiff"      => "audio/x-aiff",
-      ".ami"       => "application/vnd.amiga.ami",
-      ".appcache"  => "text/cache-manifest",
-      ".apr"       => "application/vnd.lotus-approach",
-      ".asc"       => "application/pgp-signature",
-      ".asf"       => "video/x-ms-asf",
-      ".asm"       => "text/x-asm",
-      ".aso"       => "application/vnd.accpac.simply.aso",
-      ".asx"       => "video/x-ms-asf",
-      ".atc"       => "application/vnd.acucorp",
-      ".atom"      => "application/atom+xml",
-      ".atomcat"   => "application/atomcat+xml",
-      ".atomsvc"   => "application/atomsvc+xml",
-      ".atx"       => "application/vnd.antix.game-component",
-      ".au"        => "audio/basic",
-      ".avi"       => "video/x-msvideo",
-      ".bat"       => "application/x-msdownload",
-      ".bcpio"     => "application/x-bcpio",
-      ".bdm"       => "application/vnd.syncml.dm+wbxml",
-      ".bh2"       => "application/vnd.fujitsu.oasysprs",
-      ".bin"       => "application/octet-stream",
-      ".bmi"       => "application/vnd.bmi",
-      ".bmp"       => "image/bmp",
-      ".box"       => "application/vnd.previewsystems.box",
-      ".btif"      => "image/prs.btif",
-      ".bz"        => "application/x-bzip",
-      ".bz2"       => "application/x-bzip2",
-      ".c"         => "text/x-c",
-      ".c4g"       => "application/vnd.clonk.c4group",
-      ".cab"       => "application/vnd.ms-cab-compressed",
-      ".cc"        => "text/x-c",
-      ".ccxml"     => "application/ccxml+xml",
-      ".cdbcmsg"   => "application/vnd.contact.cmsg",
-      ".cdkey"     => "application/vnd.mediastation.cdkey",
-      ".cdx"       => "chemical/x-cdx",
-      ".cdxml"     => "application/vnd.chemdraw+xml",
-      ".cdy"       => "application/vnd.cinderella",
-      ".cer"       => "application/pkix-cert",
-      ".cgm"       => "image/cgm",
-      ".chat"      => "application/x-chat",
-      ".chm"       => "application/vnd.ms-htmlhelp",
-      ".chrt"      => "application/vnd.kde.kchart",
-      ".cif"       => "chemical/x-cif",
-      ".cii"       => "application/vnd.anser-web-certificate-issue-initiation",
-      ".cil"       => "application/vnd.ms-artgalry",
-      ".cla"       => "application/vnd.claymore",
-      ".class"     => "application/octet-stream",
-      ".clkk"      => "application/vnd.crick.clicker.keyboard",
-      ".clkp"      => "application/vnd.crick.clicker.palette",
-      ".clkt"      => "application/vnd.crick.clicker.template",
-      ".clkw"      => "application/vnd.crick.clicker.wordbank",
-      ".clkx"      => "application/vnd.crick.clicker",
-      ".clp"       => "application/x-msclip",
-      ".cmc"       => "application/vnd.cosmocaller",
-      ".cmdf"      => "chemical/x-cmdf",
-      ".cml"       => "chemical/x-cml",
-      ".cmp"       => "application/vnd.yellowriver-custom-menu",
-      ".cmx"       => "image/x-cmx",
-      ".com"       => "application/x-msdownload",
-      ".conf"      => "text/plain",
-      ".cpio"      => "application/x-cpio",
-      ".cpp"       => "text/x-c",
-      ".cpt"       => "application/mac-compactpro",
-      ".crd"       => "application/x-mscardfile",
-      ".crl"       => "application/pkix-crl",
-      ".crt"       => "application/x-x509-ca-cert",
-      ".csh"       => "application/x-csh",
-      ".csml"      => "chemical/x-csml",
-      ".csp"       => "application/vnd.commonspace",
-      ".css"       => "text/css",
-      ".csv"       => "text/csv",
-      ".curl"      => "application/vnd.curl",
-      ".cww"       => "application/prs.cww",
-      ".cxx"       => "text/x-c",
-      ".daf"       => "application/vnd.mobius.daf",
-      ".davmount"  => "application/davmount+xml",
-      ".dcr"       => "application/x-director",
-      ".dd2"       => "application/vnd.oma.dd2+xml",
-      ".ddd"       => "application/vnd.fujixerox.ddd",
-      ".deb"       => "application/x-debian-package",
-      ".der"       => "application/x-x509-ca-cert",
-      ".dfac"      => "application/vnd.dreamfactory",
-      ".diff"      => "text/x-diff",
-      ".dis"       => "application/vnd.mobius.dis",
-      ".djv"       => "image/vnd.djvu",
-      ".djvu"      => "image/vnd.djvu",
-      ".dll"       => "application/x-msdownload",
-      ".dmg"       => "application/octet-stream",
-      ".dna"       => "application/vnd.dna",
-      ".doc"       => "application/msword",
-      ".docm"      => "application/vnd.ms-word.document.macroEnabled.12",
-      ".docx"      => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-      ".dot"       => "application/msword",
-      ".dotm"      => "application/vnd.ms-word.template.macroEnabled.12",
-      ".dotx"      => "application/vnd.openxmlformats-officedocument.wordprocessingml.template",
-      ".dp"        => "application/vnd.osgi.dp",
-      ".dpg"       => "application/vnd.dpgraph",
-      ".dsc"       => "text/prs.lines.tag",
-      ".dtd"       => "application/xml-dtd",
-      ".dts"       => "audio/vnd.dts",
-      ".dtshd"     => "audio/vnd.dts.hd",
-      ".dv"        => "video/x-dv",
-      ".dvi"       => "application/x-dvi",
-      ".dwf"       => "model/vnd.dwf",
-      ".dwg"       => "image/vnd.dwg",
-      ".dxf"       => "image/vnd.dxf",
-      ".dxp"       => "application/vnd.spotfire.dxp",
-      ".ear"       => "application/java-archive",
-      ".ecelp4800" => "audio/vnd.nuera.ecelp4800",
-      ".ecelp7470" => "audio/vnd.nuera.ecelp7470",
-      ".ecelp9600" => "audio/vnd.nuera.ecelp9600",
-      ".ecma"      => "application/ecmascript",
-      ".edm"       => "application/vnd.novadigm.edm",
-      ".edx"       => "application/vnd.novadigm.edx",
-      ".efif"      => "application/vnd.picsel",
-      ".ei6"       => "application/vnd.pg.osasli",
-      ".eml"       => "message/rfc822",
-      ".eol"       => "audio/vnd.digital-winds",
-      ".eot"       => "application/vnd.ms-fontobject",
-      ".eps"       => "application/postscript",
-      ".es3"       => "application/vnd.eszigno3+xml",
-      ".esf"       => "application/vnd.epson.esf",
-      ".etx"       => "text/x-setext",
-      ".exe"       => "application/x-msdownload",
-      ".ext"       => "application/vnd.novadigm.ext",
-      ".ez"        => "application/andrew-inset",
-      ".ez2"       => "application/vnd.ezpix-album",
-      ".ez3"       => "application/vnd.ezpix-package",
-      ".f"         => "text/x-fortran",
-      ".f77"       => "text/x-fortran",
-      ".f90"       => "text/x-fortran",
-      ".fbs"       => "image/vnd.fastbidsheet",
-      ".fdf"       => "application/vnd.fdf",
-      ".fe_launch" => "application/vnd.denovo.fcselayout-link",
-      ".fg5"       => "application/vnd.fujitsu.oasysgp",
-      ".fli"       => "video/x-fli",
-      ".flo"       => "application/vnd.micrografx.flo",
-      ".flv"       => "video/x-flv",
-      ".flw"       => "application/vnd.kde.kivio",
-      ".flx"       => "text/vnd.fmi.flexstor",
-      ".fly"       => "text/vnd.fly",
-      ".fm"        => "application/vnd.framemaker",
-      ".fnc"       => "application/vnd.frogans.fnc",
-      ".for"       => "text/x-fortran",
-      ".fpx"       => "image/vnd.fpx",
-      ".fsc"       => "application/vnd.fsc.weblaunch",
-      ".fst"       => "image/vnd.fst",
-      ".ftc"       => "application/vnd.fluxtime.clip",
-      ".fti"       => "application/vnd.anser-web-funds-transfer-initiation",
-      ".fvt"       => "video/vnd.fvt",
-      ".fzs"       => "application/vnd.fuzzysheet",
-      ".g3"        => "image/g3fax",
-      ".gac"       => "application/vnd.groove-account",
-      ".gdl"       => "model/vnd.gdl",
-      ".gem"       => "application/octet-stream",
-      ".gemspec"   => "text/x-script.ruby",
-      ".ghf"       => "application/vnd.groove-help",
-      ".gif"       => "image/gif",
-      ".gim"       => "application/vnd.groove-identity-message",
-      ".gmx"       => "application/vnd.gmx",
-      ".gph"       => "application/vnd.flographit",
-      ".gqf"       => "application/vnd.grafeq",
-      ".gram"      => "application/srgs",
-      ".grv"       => "application/vnd.groove-injector",
-      ".grxml"     => "application/srgs+xml",
-      ".gtar"      => "application/x-gtar",
-      ".gtm"       => "application/vnd.groove-tool-message",
-      ".gtw"       => "model/vnd.gtw",
-      ".gv"        => "text/vnd.graphviz",
-      ".gz"        => "application/x-gzip",
-      ".h"         => "text/x-c",
-      ".h261"      => "video/h261",
-      ".h263"      => "video/h263",
-      ".h264"      => "video/h264",
-      ".hbci"      => "application/vnd.hbci",
-      ".hdf"       => "application/x-hdf",
-      ".hh"        => "text/x-c",
-      ".hlp"       => "application/winhlp",
-      ".hpgl"      => "application/vnd.hp-hpgl",
-      ".hpid"      => "application/vnd.hp-hpid",
-      ".hps"       => "application/vnd.hp-hps",
-      ".hqx"       => "application/mac-binhex40",
-      ".htc"       => "text/x-component",
-      ".htke"      => "application/vnd.kenameaapp",
-      ".htm"       => "text/html",
-      ".html"      => "text/html",
-      ".hvd"       => "application/vnd.yamaha.hv-dic",
-      ".hvp"       => "application/vnd.yamaha.hv-voice",
-      ".hvs"       => "application/vnd.yamaha.hv-script",
-      ".icc"       => "application/vnd.iccprofile",
-      ".ice"       => "x-conference/x-cooltalk",
-      ".ico"       => "image/vnd.microsoft.icon",
-      ".ics"       => "text/calendar",
-      ".ief"       => "image/ief",
-      ".ifb"       => "text/calendar",
-      ".ifm"       => "application/vnd.shana.informed.formdata",
-      ".igl"       => "application/vnd.igloader",
-      ".igs"       => "model/iges",
-      ".igx"       => "application/vnd.micrografx.igx",
-      ".iif"       => "application/vnd.shana.informed.interchange",
-      ".imp"       => "application/vnd.accpac.simply.imp",
-      ".ims"       => "application/vnd.ms-ims",
-      ".ipk"       => "application/vnd.shana.informed.package",
-      ".irm"       => "application/vnd.ibm.rights-management",
-      ".irp"       => "application/vnd.irepository.package+xml",
-      ".iso"       => "application/octet-stream",
-      ".itp"       => "application/vnd.shana.informed.formtemplate",
-      ".ivp"       => "application/vnd.immervision-ivp",
-      ".ivu"       => "application/vnd.immervision-ivu",
-      ".jad"       => "text/vnd.sun.j2me.app-descriptor",
-      ".jam"       => "application/vnd.jam",
-      ".jar"       => "application/java-archive",
-      ".java"      => "text/x-java-source",
-      ".jisp"      => "application/vnd.jisp",
-      ".jlt"       => "application/vnd.hp-jlyt",
-      ".jnlp"      => "application/x-java-jnlp-file",
-      ".joda"      => "application/vnd.joost.joda-archive",
-      ".jp2"       => "image/jp2",
-      ".jpeg"      => "image/jpeg",
-      ".jpg"       => "image/jpeg",
-      ".jpgv"      => "video/jpeg",
-      ".jpm"       => "video/jpm",
-      ".js"        => "application/javascript",
-      ".json"      => "application/json",
-      ".karbon"    => "application/vnd.kde.karbon",
-      ".kfo"       => "application/vnd.kde.kformula",
-      ".kia"       => "application/vnd.kidspiration",
-      ".kml"       => "application/vnd.google-earth.kml+xml",
-      ".kmz"       => "application/vnd.google-earth.kmz",
-      ".kne"       => "application/vnd.kinar",
-      ".kon"       => "application/vnd.kde.kontour",
-      ".kpr"       => "application/vnd.kde.kpresenter",
-      ".ksp"       => "application/vnd.kde.kspread",
-      ".ktz"       => "application/vnd.kahootz",
-      ".kwd"       => "application/vnd.kde.kword",
-      ".latex"     => "application/x-latex",
-      ".lbd"       => "application/vnd.llamagraphics.life-balance.desktop",
-      ".lbe"       => "application/vnd.llamagraphics.life-balance.exchange+xml",
-      ".les"       => "application/vnd.hhe.lesson-player",
-      ".link66"    => "application/vnd.route66.link66+xml",
-      ".log"       => "text/plain",
-      ".lostxml"   => "application/lost+xml",
-      ".lrm"       => "application/vnd.ms-lrm",
-      ".ltf"       => "application/vnd.frogans.ltf",
-      ".lvp"       => "audio/vnd.lucent.voice",
-      ".lwp"       => "application/vnd.lotus-wordpro",
-      ".m3u"       => "audio/x-mpegurl",
-      ".m3u8"      => "application/x-mpegurl",
-      ".m4a"       => "audio/mp4a-latm",
-      ".m4v"       => "video/mp4",
-      ".ma"        => "application/mathematica",
-      ".mag"       => "application/vnd.ecowin.chart",
-      ".man"       => "text/troff",
-      ".manifest"  => "text/cache-manifest",
-      ".mathml"    => "application/mathml+xml",
-      ".mbk"       => "application/vnd.mobius.mbk",
-      ".mbox"      => "application/mbox",
-      ".mc1"       => "application/vnd.medcalcdata",
-      ".mcd"       => "application/vnd.mcd",
-      ".mdb"       => "application/x-msaccess",
-      ".mdi"       => "image/vnd.ms-modi",
-      ".mdoc"      => "text/troff",
-      ".me"        => "text/troff",
-      ".mfm"       => "application/vnd.mfmp",
-      ".mgz"       => "application/vnd.proteus.magazine",
-      ".mid"       => "audio/midi",
-      ".midi"      => "audio/midi",
-      ".mif"       => "application/vnd.mif",
-      ".mime"      => "message/rfc822",
-      ".mj2"       => "video/mj2",
-      ".mlp"       => "application/vnd.dolby.mlp",
-      ".mmd"       => "application/vnd.chipnuts.karaoke-mmd",
-      ".mmf"       => "application/vnd.smaf",
-      ".mml"       => "application/mathml+xml",
-      ".mmr"       => "image/vnd.fujixerox.edmics-mmr",
-      ".mng"       => "video/x-mng",
-      ".mny"       => "application/x-msmoney",
-      ".mov"       => "video/quicktime",
-      ".movie"     => "video/x-sgi-movie",
-      ".mp3"       => "audio/mpeg",
-      ".mp4"       => "video/mp4",
-      ".mp4a"      => "audio/mp4",
-      ".mp4s"      => "application/mp4",
-      ".mp4v"      => "video/mp4",
-      ".mpc"       => "application/vnd.mophun.certificate",
-      ".mpd"       => "application/dash+xml",
-      ".mpeg"      => "video/mpeg",
-      ".mpg"       => "video/mpeg",
-      ".mpga"      => "audio/mpeg",
-      ".mpkg"      => "application/vnd.apple.installer+xml",
-      ".mpm"       => "application/vnd.blueice.multipass",
-      ".mpn"       => "application/vnd.mophun.application",
-      ".mpp"       => "application/vnd.ms-project",
-      ".mpy"       => "application/vnd.ibm.minipay",
-      ".mqy"       => "application/vnd.mobius.mqy",
-      ".mrc"       => "application/marc",
-      ".ms"        => "text/troff",
-      ".mscml"     => "application/mediaservercontrol+xml",
-      ".mseq"      => "application/vnd.mseq",
-      ".msf"       => "application/vnd.epson.msf",
-      ".msh"       => "model/mesh",
-      ".msi"       => "application/x-msdownload",
-      ".msl"       => "application/vnd.mobius.msl",
-      ".msty"      => "application/vnd.muvee.style",
-      ".mts"       => "model/vnd.mts",
-      ".mus"       => "application/vnd.musician",
-      ".mvb"       => "application/x-msmediaview",
-      ".mwf"       => "application/vnd.mfer",
-      ".mxf"       => "application/mxf",
-      ".mxl"       => "application/vnd.recordare.musicxml",
-      ".mxml"      => "application/xv+xml",
-      ".mxs"       => "application/vnd.triscape.mxs",
-      ".mxu"       => "video/vnd.mpegurl",
-      ".n"         => "application/vnd.nokia.n-gage.symbian.install",
-      ".nc"        => "application/x-netcdf",
-      ".ngdat"     => "application/vnd.nokia.n-gage.data",
-      ".nlu"       => "application/vnd.neurolanguage.nlu",
-      ".nml"       => "application/vnd.enliven",
-      ".nnd"       => "application/vnd.noblenet-directory",
-      ".nns"       => "application/vnd.noblenet-sealer",
-      ".nnw"       => "application/vnd.noblenet-web",
-      ".npx"       => "image/vnd.net-fpx",
-      ".nsf"       => "application/vnd.lotus-notes",
-      ".oa2"       => "application/vnd.fujitsu.oasys2",
-      ".oa3"       => "application/vnd.fujitsu.oasys3",
-      ".oas"       => "application/vnd.fujitsu.oasys",
-      ".obd"       => "application/x-msbinder",
-      ".oda"       => "application/oda",
-      ".odc"       => "application/vnd.oasis.opendocument.chart",
-      ".odf"       => "application/vnd.oasis.opendocument.formula",
-      ".odg"       => "application/vnd.oasis.opendocument.graphics",
-      ".odi"       => "application/vnd.oasis.opendocument.image",
-      ".odp"       => "application/vnd.oasis.opendocument.presentation",
-      ".ods"       => "application/vnd.oasis.opendocument.spreadsheet",
-      ".odt"       => "application/vnd.oasis.opendocument.text",
-      ".oga"       => "audio/ogg",
-      ".ogg"       => "application/ogg",
-      ".ogv"       => "video/ogg",
-      ".ogx"       => "application/ogg",
-      ".org"       => "application/vnd.lotus-organizer",
-      ".otc"       => "application/vnd.oasis.opendocument.chart-template",
-      ".otf"       => "application/vnd.oasis.opendocument.formula-template",
-      ".otg"       => "application/vnd.oasis.opendocument.graphics-template",
-      ".oth"       => "application/vnd.oasis.opendocument.text-web",
-      ".oti"       => "application/vnd.oasis.opendocument.image-template",
-      ".otm"       => "application/vnd.oasis.opendocument.text-master",
-      ".ots"       => "application/vnd.oasis.opendocument.spreadsheet-template",
-      ".ott"       => "application/vnd.oasis.opendocument.text-template",
-      ".oxt"       => "application/vnd.openofficeorg.extension",
-      ".p"         => "text/x-pascal",
-      ".p10"       => "application/pkcs10",
-      ".p12"       => "application/x-pkcs12",
-      ".p7b"       => "application/x-pkcs7-certificates",
-      ".p7m"       => "application/pkcs7-mime",
-      ".p7r"       => "application/x-pkcs7-certreqresp",
-      ".p7s"       => "application/pkcs7-signature",
-      ".pas"       => "text/x-pascal",
-      ".pbd"       => "application/vnd.powerbuilder6",
-      ".pbm"       => "image/x-portable-bitmap",
-      ".pcl"       => "application/vnd.hp-pcl",
-      ".pclxl"     => "application/vnd.hp-pclxl",
-      ".pcx"       => "image/x-pcx",
-      ".pdb"       => "chemical/x-pdb",
-      ".pdf"       => "application/pdf",
-      ".pem"       => "application/x-x509-ca-cert",
-      ".pfr"       => "application/font-tdpfr",
-      ".pgm"       => "image/x-portable-graymap",
-      ".pgn"       => "application/x-chess-pgn",
-      ".pgp"       => "application/pgp-encrypted",
-      ".pic"       => "image/x-pict",
-      ".pict"      => "image/pict",
-      ".pkg"       => "application/octet-stream",
-      ".pki"       => "application/pkixcmp",
-      ".pkipath"   => "application/pkix-pkipath",
-      ".pl"        => "text/x-script.perl",
-      ".plb"       => "application/vnd.3gpp.pic-bw-large",
-      ".plc"       => "application/vnd.mobius.plc",
-      ".plf"       => "application/vnd.pocketlearn",
-      ".pls"       => "application/pls+xml",
-      ".pm"        => "text/x-script.perl-module",
-      ".pml"       => "application/vnd.ctc-posml",
-      ".png"       => "image/png",
-      ".pnm"       => "image/x-portable-anymap",
-      ".pntg"      => "image/x-macpaint",
-      ".portpkg"   => "application/vnd.macports.portpkg",
-      ".pot"       => "application/vnd.ms-powerpoint",
-      ".potm"      => "application/vnd.ms-powerpoint.template.macroEnabled.12",
-      ".potx"      => "application/vnd.openxmlformats-officedocument.presentationml.template",
-      ".ppa"       => "application/vnd.ms-powerpoint",
-      ".ppam"      => "application/vnd.ms-powerpoint.addin.macroEnabled.12",
-      ".ppd"       => "application/vnd.cups-ppd",
-      ".ppm"       => "image/x-portable-pixmap",
-      ".pps"       => "application/vnd.ms-powerpoint",
-      ".ppsm"      => "application/vnd.ms-powerpoint.slideshow.macroEnabled.12",
-      ".ppsx"      => "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
-      ".ppt"       => "application/vnd.ms-powerpoint",
-      ".pptm"      => "application/vnd.ms-powerpoint.presentation.macroEnabled.12",
-      ".pptx"      => "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-      ".prc"       => "application/vnd.palm",
-      ".pre"       => "application/vnd.lotus-freelance",
-      ".prf"       => "application/pics-rules",
-      ".ps"        => "application/postscript",
-      ".psb"       => "application/vnd.3gpp.pic-bw-small",
-      ".psd"       => "image/vnd.adobe.photoshop",
-      ".ptid"      => "application/vnd.pvi.ptid1",
-      ".pub"       => "application/x-mspublisher",
-      ".pvb"       => "application/vnd.3gpp.pic-bw-var",
-      ".pwn"       => "application/vnd.3m.post-it-notes",
-      ".py"        => "text/x-script.python",
-      ".pya"       => "audio/vnd.ms-playready.media.pya",
-      ".pyv"       => "video/vnd.ms-playready.media.pyv",
-      ".qam"       => "application/vnd.epson.quickanime",
-      ".qbo"       => "application/vnd.intu.qbo",
-      ".qfx"       => "application/vnd.intu.qfx",
-      ".qps"       => "application/vnd.publishare-delta-tree",
-      ".qt"        => "video/quicktime",
-      ".qtif"      => "image/x-quicktime",
-      ".qxd"       => "application/vnd.quark.quarkxpress",
-      ".ra"        => "audio/x-pn-realaudio",
-      ".rake"      => "text/x-script.ruby",
-      ".ram"       => "audio/x-pn-realaudio",
-      ".rar"       => "application/x-rar-compressed",
-      ".ras"       => "image/x-cmu-raster",
-      ".rb"        => "text/x-script.ruby",
-      ".rcprofile" => "application/vnd.ipunplugged.rcprofile",
-      ".rdf"       => "application/rdf+xml",
-      ".rdz"       => "application/vnd.data-vision.rdz",
-      ".rep"       => "application/vnd.businessobjects",
-      ".rgb"       => "image/x-rgb",
-      ".rif"       => "application/reginfo+xml",
-      ".rl"        => "application/resource-lists+xml",
-      ".rlc"       => "image/vnd.fujixerox.edmics-rlc",
-      ".rld"       => "application/resource-lists-diff+xml",
-      ".rm"        => "application/vnd.rn-realmedia",
-      ".rmp"       => "audio/x-pn-realaudio-plugin",
-      ".rms"       => "application/vnd.jcp.javame.midlet-rms",
-      ".rnc"       => "application/relax-ng-compact-syntax",
-      ".roff"      => "text/troff",
-      ".rpm"       => "application/x-redhat-package-manager",
-      ".rpss"      => "application/vnd.nokia.radio-presets",
-      ".rpst"      => "application/vnd.nokia.radio-preset",
-      ".rq"        => "application/sparql-query",
-      ".rs"        => "application/rls-services+xml",
-      ".rsd"       => "application/rsd+xml",
-      ".rss"       => "application/rss+xml",
-      ".rtf"       => "application/rtf",
-      ".rtx"       => "text/richtext",
-      ".ru"        => "text/x-script.ruby",
-      ".s"         => "text/x-asm",
-      ".saf"       => "application/vnd.yamaha.smaf-audio",
-      ".sbml"      => "application/sbml+xml",
-      ".sc"        => "application/vnd.ibm.secure-container",
-      ".scd"       => "application/x-msschedule",
-      ".scm"       => "application/vnd.lotus-screencam",
-      ".scq"       => "application/scvp-cv-request",
-      ".scs"       => "application/scvp-cv-response",
-      ".sdkm"      => "application/vnd.solent.sdkm+xml",
-      ".sdp"       => "application/sdp",
-      ".see"       => "application/vnd.seemail",
-      ".sema"      => "application/vnd.sema",
-      ".semd"      => "application/vnd.semd",
-      ".semf"      => "application/vnd.semf",
-      ".setpay"    => "application/set-payment-initiation",
-      ".setreg"    => "application/set-registration-initiation",
-      ".sfd"       => "application/vnd.hydrostatix.sof-data",
-      ".sfs"       => "application/vnd.spotfire.sfs",
-      ".sgm"       => "text/sgml",
-      ".sgml"      => "text/sgml",
-      ".sh"        => "application/x-sh",
-      ".shar"      => "application/x-shar",
-      ".shf"       => "application/shf+xml",
-      ".sig"       => "application/pgp-signature",
-      ".sit"       => "application/x-stuffit",
-      ".sitx"      => "application/x-stuffitx",
-      ".skp"       => "application/vnd.koan",
-      ".slt"       => "application/vnd.epson.salt",
-      ".smi"       => "application/smil+xml",
-      ".snd"       => "audio/basic",
-      ".so"        => "application/octet-stream",
-      ".spf"       => "application/vnd.yamaha.smaf-phrase",
-      ".spl"       => "application/x-futuresplash",
-      ".spot"      => "text/vnd.in3d.spot",
-      ".spp"       => "application/scvp-vp-response",
-      ".spq"       => "application/scvp-vp-request",
-      ".src"       => "application/x-wais-source",
-      ".srt"       => "text/srt",
-      ".srx"       => "application/sparql-results+xml",
-      ".sse"       => "application/vnd.kodak-descriptor",
-      ".ssf"       => "application/vnd.epson.ssf",
-      ".ssml"      => "application/ssml+xml",
-      ".stf"       => "application/vnd.wt.stf",
-      ".stk"       => "application/hyperstudio",
-      ".str"       => "application/vnd.pg.format",
-      ".sus"       => "application/vnd.sus-calendar",
-      ".sv4cpio"   => "application/x-sv4cpio",
-      ".sv4crc"    => "application/x-sv4crc",
-      ".svd"       => "application/vnd.svd",
-      ".svg"       => "image/svg+xml",
-      ".svgz"      => "image/svg+xml",
-      ".swf"       => "application/x-shockwave-flash",
-      ".swi"       => "application/vnd.arastra.swi",
-      ".t"         => "text/troff",
-      ".tao"       => "application/vnd.tao.intent-module-archive",
-      ".tar"       => "application/x-tar",
-      ".tbz"       => "application/x-bzip-compressed-tar",
-      ".tcap"      => "application/vnd.3gpp2.tcap",
-      ".tcl"       => "application/x-tcl",
-      ".tex"       => "application/x-tex",
-      ".texi"      => "application/x-texinfo",
-      ".texinfo"   => "application/x-texinfo",
-      ".text"      => "text/plain",
-      ".tif"       => "image/tiff",
-      ".tiff"      => "image/tiff",
-      ".tmo"       => "application/vnd.tmobile-livetv",
-      ".torrent"   => "application/x-bittorrent",
-      ".tpl"       => "application/vnd.groove-tool-template",
-      ".tpt"       => "application/vnd.trid.tpt",
-      ".tr"        => "text/troff",
-      ".tra"       => "application/vnd.trueapp",
-      ".trm"       => "application/x-msterminal",
-      ".ts"        => "video/mp2t",
-      ".tsv"       => "text/tab-separated-values",
-      ".ttf"       => "application/octet-stream",
-      ".twd"       => "application/vnd.simtech-mindmapper",
-      ".txd"       => "application/vnd.genomatix.tuxedo",
-      ".txf"       => "application/vnd.mobius.txf",
-      ".txt"       => "text/plain",
-      ".ufd"       => "application/vnd.ufdl",
-      ".umj"       => "application/vnd.umajin",
-      ".unityweb"  => "application/vnd.unity",
-      ".uoml"      => "application/vnd.uoml+xml",
-      ".uri"       => "text/uri-list",
-      ".ustar"     => "application/x-ustar",
-      ".utz"       => "application/vnd.uiq.theme",
-      ".uu"        => "text/x-uuencode",
-      ".vcd"       => "application/x-cdlink",
-      ".vcf"       => "text/x-vcard",
-      ".vcg"       => "application/vnd.groove-vcard",
-      ".vcs"       => "text/x-vcalendar",
-      ".vcx"       => "application/vnd.vcx",
-      ".vis"       => "application/vnd.visionary",
-      ".viv"       => "video/vnd.vivo",
-      ".vrml"      => "model/vrml",
-      ".vsd"       => "application/vnd.visio",
-      ".vsf"       => "application/vnd.vsf",
-      ".vtt"       => "text/vtt",
-      ".vtu"       => "model/vnd.vtu",
-      ".vxml"      => "application/voicexml+xml",
-      ".war"       => "application/java-archive",
-      ".wasm"      => "application/wasm",
-      ".wav"       => "audio/x-wav",
-      ".wax"       => "audio/x-ms-wax",
-      ".wbmp"      => "image/vnd.wap.wbmp",
-      ".wbs"       => "application/vnd.criticaltools.wbs+xml",
-      ".wbxml"     => "application/vnd.wap.wbxml",
-      ".webm"      => "video/webm",
-      ".wm"        => "video/x-ms-wm",
-      ".wma"       => "audio/x-ms-wma",
-      ".wmd"       => "application/x-ms-wmd",
-      ".wmf"       => "application/x-msmetafile",
-      ".wml"       => "text/vnd.wap.wml",
-      ".wmlc"      => "application/vnd.wap.wmlc",
-      ".wmls"      => "text/vnd.wap.wmlscript",
-      ".wmlsc"     => "application/vnd.wap.wmlscriptc",
-      ".wmv"       => "video/x-ms-wmv",
-      ".wmx"       => "video/x-ms-wmx",
-      ".wmz"       => "application/x-ms-wmz",
-      ".woff"      => "application/font-woff",
-      ".woff2"     => "application/font-woff2",
-      ".wpd"       => "application/vnd.wordperfect",
-      ".wpl"       => "application/vnd.ms-wpl",
-      ".wps"       => "application/vnd.ms-works",
-      ".wqd"       => "application/vnd.wqd",
-      ".wri"       => "application/x-mswrite",
-      ".wrl"       => "model/vrml",
-      ".wsdl"      => "application/wsdl+xml",
-      ".wspolicy"  => "application/wspolicy+xml",
-      ".wtb"       => "application/vnd.webturbo",
-      ".wvx"       => "video/x-ms-wvx",
-      ".x3d"       => "application/vnd.hzn-3d-crossword",
-      ".xar"       => "application/vnd.xara",
-      ".xbd"       => "application/vnd.fujixerox.docuworks.binder",
-      ".xbm"       => "image/x-xbitmap",
-      ".xdm"       => "application/vnd.syncml.dm+xml",
-      ".xdp"       => "application/vnd.adobe.xdp+xml",
-      ".xdw"       => "application/vnd.fujixerox.docuworks",
-      ".xenc"      => "application/xenc+xml",
-      ".xer"       => "application/patch-ops-error+xml",
-      ".xfdf"      => "application/vnd.adobe.xfdf",
-      ".xfdl"      => "application/vnd.xfdl",
-      ".xhtml"     => "application/xhtml+xml",
-      ".xif"       => "image/vnd.xiff",
-      ".xla"       => "application/vnd.ms-excel",
-      ".xlam"      => "application/vnd.ms-excel.addin.macroEnabled.12",
-      ".xls"       => "application/vnd.ms-excel",
-      ".xlsb"      => "application/vnd.ms-excel.sheet.binary.macroEnabled.12",
-      ".xlsx"      => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-      ".xlsm"      => "application/vnd.ms-excel.sheet.macroEnabled.12",
-      ".xlt"       => "application/vnd.ms-excel",
-      ".xltx"      => "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
-      ".xml"       => "application/xml",
-      ".xo"        => "application/vnd.olpc-sugar",
-      ".xop"       => "application/xop+xml",
-      ".xpm"       => "image/x-xpixmap",
-      ".xpr"       => "application/vnd.is-xpr",
-      ".xps"       => "application/vnd.ms-xpsdocument",
-      ".xpw"       => "application/vnd.intercon.formnet",
-      ".xsl"       => "application/xml",
-      ".xslt"      => "application/xslt+xml",
-      ".xsm"       => "application/vnd.syncml+xml",
-      ".xspf"      => "application/xspf+xml",
-      ".xul"       => "application/vnd.mozilla.xul+xml",
-      ".xwd"       => "image/x-xwindowdump",
-      ".xyz"       => "chemical/x-xyz",
-      ".yaml"      => "text/yaml",
-      ".yml"       => "text/yaml",
-      ".zaz"       => "application/vnd.zzazz.deck+xml",
-      ".zip"       => "application/zip",
-      ".zmm"       => "application/vnd.handheld-entertainment+xml",
-    }
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/mock.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/mock.rb
deleted file mode 100644
index 5b2512ca091de..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/mock.rb
+++ /dev/null
@@ -1,273 +0,0 @@
-# frozen_string_literal: true
-
-require 'uri'
-require 'stringio'
-require_relative '../rack'
-require 'cgi/cookie'
-
-module Rack
-  # Rack::MockRequest helps testing your Rack application without
-  # actually using HTTP.
-  #
-  # After performing a request on a URL with get/post/put/patch/delete, it
-  # returns a MockResponse with useful helper methods for effective
-  # testing.
-  #
-  # You can pass a hash with additional configuration to the
-  # get/post/put/patch/delete.
-  # <tt>:input</tt>:: A String or IO-like to be used as rack.input.
-  # <tt>:fatal</tt>:: Raise a FatalWarning if the app writes to rack.errors.
-  # <tt>:lint</tt>:: If true, wrap the application in a Rack::Lint.
-
-  class MockRequest
-    class FatalWarning < RuntimeError
-    end
-
-    class FatalWarner
-      def puts(warning)
-        raise FatalWarning, warning
-      end
-
-      def write(warning)
-        raise FatalWarning, warning
-      end
-
-      def flush
-      end
-
-      def string
-        ""
-      end
-    end
-
-    DEFAULT_ENV = {
-      RACK_VERSION      => Rack::VERSION,
-      RACK_INPUT        => StringIO.new,
-      RACK_ERRORS       => StringIO.new,
-      RACK_MULTITHREAD  => true,
-      RACK_MULTIPROCESS => true,
-      RACK_RUNONCE      => false,
-    }.freeze
-
-    def initialize(app)
-      @app = app
-    end
-
-    # Make a GET request and return a MockResponse. See #request.
-    def get(uri, opts = {})     request(GET, uri, opts)     end
-    # Make a POST request and return a MockResponse. See #request.
-    def post(uri, opts = {})    request(POST, uri, opts)    end
-    # Make a PUT request and return a MockResponse. See #request.
-    def put(uri, opts = {})     request(PUT, uri, opts)     end
-    # Make a PATCH request and return a MockResponse. See #request.
-    def patch(uri, opts = {})   request(PATCH, uri, opts)   end
-    # Make a DELETE request and return a MockResponse. See #request.
-    def delete(uri, opts = {})  request(DELETE, uri, opts)  end
-    # Make a HEAD request and return a MockResponse. See #request.
-    def head(uri, opts = {})    request(HEAD, uri, opts)    end
-    # Make an OPTIONS request and return a MockResponse. See #request.
-    def options(uri, opts = {}) request(OPTIONS, uri, opts) end
-
-    # Make a request using the given request method for the given
-    # uri to the rack application and return a MockResponse.
-    # Options given are passed to MockRequest.env_for.
-    def request(method = GET, uri = "", opts = {})
-      env = self.class.env_for(uri, opts.merge(method: method))
-
-      if opts[:lint]
-        app = Rack::Lint.new(@app)
-      else
-        app = @app
-      end
-
-      errors = env[RACK_ERRORS]
-      status, headers, body = app.call(env)
-      MockResponse.new(status, headers, body, errors)
-    ensure
-      body.close if body.respond_to?(:close)
-    end
-
-    # For historical reasons, we're pinning to RFC 2396.
-    # URI::Parser = URI::RFC2396_Parser
-    def self.parse_uri_rfc2396(uri)
-      @parser ||= URI::Parser.new
-      @parser.parse(uri)
-    end
-
-    # Return the Rack environment used for a request to +uri+.
-    # All options that are strings are added to the returned environment.
-    # Options:
-    # :fatal :: Whether to raise an exception if request outputs to rack.errors
-    # :input :: The rack.input to set
-    # :method :: The HTTP request method to use
-    # :params :: The params to use
-    # :script_name :: The SCRIPT_NAME to set
-    def self.env_for(uri = "", opts = {})
-      uri = parse_uri_rfc2396(uri)
-      uri.path = "/#{uri.path}" unless uri.path[0] == ?/
-
-      env = DEFAULT_ENV.dup
-
-      env[REQUEST_METHOD]  = (opts[:method] ? opts[:method].to_s.upcase : GET).b
-      env[SERVER_NAME]     = (uri.host || "example.org").b
-      env[SERVER_PORT]     = (uri.port ? uri.port.to_s : "80").b
-      env[QUERY_STRING]    = (uri.query.to_s).b
-      env[PATH_INFO]       = ((!uri.path || uri.path.empty?) ? "/" : uri.path).b
-      env[RACK_URL_SCHEME] = (uri.scheme || "http").b
-      env[HTTPS]           = (env[RACK_URL_SCHEME] == "https" ? "on" : "off").b
-
-      env[SCRIPT_NAME] = opts[:script_name] || ""
-
-      if opts[:fatal]
-        env[RACK_ERRORS] = FatalWarner.new
-      else
-        env[RACK_ERRORS] = StringIO.new
-      end
-
-      if params = opts[:params]
-        if env[REQUEST_METHOD] == GET
-          params = Utils.parse_nested_query(params) if params.is_a?(String)
-          params.update(Utils.parse_nested_query(env[QUERY_STRING]))
-          env[QUERY_STRING] = Utils.build_nested_query(params)
-        elsif !opts.has_key?(:input)
-          opts["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
-          if params.is_a?(Hash)
-            if data = Rack::Multipart.build_multipart(params)
-              opts[:input] = data
-              opts["CONTENT_LENGTH"] ||= data.length.to_s
-              opts["CONTENT_TYPE"] = "multipart/form-data; boundary=#{Rack::Multipart::MULTIPART_BOUNDARY}"
-            else
-              opts[:input] = Utils.build_nested_query(params)
-            end
-          else
-            opts[:input] = params
-          end
-        end
-      end
-
-      empty_str = String.new
-      opts[:input] ||= empty_str
-      if String === opts[:input]
-        rack_input = StringIO.new(opts[:input])
-      else
-        rack_input = opts[:input]
-      end
-
-      rack_input.set_encoding(Encoding::BINARY)
-      env[RACK_INPUT] = rack_input
-
-      env["CONTENT_LENGTH"] ||= env[RACK_INPUT].size.to_s if env[RACK_INPUT].respond_to?(:size)
-
-      opts.each { |field, value|
-        env[field] = value  if String === field
-      }
-
-      env
-    end
-  end
-
-  # Rack::MockResponse provides useful helpers for testing your apps.
-  # Usually, you don't create the MockResponse on your own, but use
-  # MockRequest.
-
-  class MockResponse < Rack::Response
-    class << self
-      alias [] new
-    end
-
-    # Headers
-    attr_reader :original_headers, :cookies
-
-    # Errors
-    attr_accessor :errors
-
-    def initialize(status, headers, body, errors = StringIO.new(""))
-      @original_headers = headers
-      @errors           = errors.string if errors.respond_to?(:string)
-      @cookies = parse_cookies_from_header
-
-      super(body, status, headers)
-
-      buffered_body!
-    end
-
-    def =~(other)
-      body =~ other
-    end
-
-    def match(other)
-      body.match other
-    end
-
-    def body
-      # FIXME: apparently users of MockResponse expect the return value of
-      # MockResponse#body to be a string.  However, the real response object
-      # returns the body as a list.
-      #
-      # See spec_showstatus.rb:
-      #
-      #   should "not replace existing messages" do
-      #     ...
-      #     res.body.should == "foo!"
-      #   end
-      buffer = String.new
-
-      super.each do |chunk|
-        buffer << chunk
-      end
-
-      return buffer
-    end
-
-    def empty?
-      [201, 204, 304].include? status
-    end
-
-    def cookie(name)
-      cookies.fetch(name, nil)
-    end
-
-    private
-
-    def parse_cookies_from_header
-      cookies = Hash.new
-      if original_headers.has_key? 'Set-Cookie'
-        set_cookie_header = original_headers.fetch('Set-Cookie')
-        set_cookie_header.split("\n").each do |cookie|
-          cookie_name, cookie_filling = cookie.split('=', 2)
-          cookie_attributes = identify_cookie_attributes cookie_filling
-          parsed_cookie = CGI::Cookie.new(
-            'name' => cookie_name.strip,
-            'value' => cookie_attributes.fetch('value'),
-            'path' => cookie_attributes.fetch('path', nil),
-            'domain' => cookie_attributes.fetch('domain', nil),
-            'expires' => cookie_attributes.fetch('expires', nil),
-            'secure' => cookie_attributes.fetch('secure', false)
-          )
-          cookies.store(cookie_name, parsed_cookie)
-        end
-      end
-      cookies
-    end
-
-    def identify_cookie_attributes(cookie_filling)
-      cookie_bits = cookie_filling.split(';')
-      cookie_attributes = Hash.new
-      cookie_attributes.store('value', cookie_bits[0].strip)
-      cookie_bits.each do |bit|
-        if bit.include? '='
-          cookie_attribute, attribute_value = bit.split('=')
-          cookie_attributes.store(cookie_attribute.strip, attribute_value.strip)
-          if cookie_attribute.include? 'max-age'
-            cookie_attributes.store('expires', Time.now + attribute_value.strip.to_i)
-          end
-        end
-        if bit.include? 'secure'
-          cookie_attributes.store('secure', true)
-        end
-      end
-      cookie_attributes
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/multipart.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/multipart.rb
deleted file mode 100644
index 10f8e5fa3ccea..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/multipart.rb
+++ /dev/null
@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'multipart/parser'
-
-module Rack
-  # A multipart form data parser, adapted from IOWA.
-  #
-  # Usually, Rack::Request#POST takes care of calling this.
-  module Multipart
-    autoload :UploadedFile, 'rack/multipart/uploaded_file'
-    autoload :Generator, 'rack/multipart/generator'
-
-    EOL = "\r\n"
-    MULTIPART_BOUNDARY = "AaB03x"
-    MULTIPART = %r|\Amultipart/.*boundary=\"?([^\";,]+)\"?|ni
-    TOKEN = /[^\s()<>,;:\\"\/\[\]?=]+/
-    CONDISP = /Content-Disposition:\s*#{TOKEN}\s*/i
-    VALUE = /"(?:\\"|[^"])*"|#{TOKEN}/
-    BROKEN = /^#{CONDISP}.*;\s*filename=(#{VALUE})/i
-    MULTIPART_CONTENT_TYPE = /Content-Type: (.*)#{EOL}/ni
-    MULTIPART_CONTENT_DISPOSITION = /Content-Disposition:.*;\s*name=(#{VALUE})/ni
-    MULTIPART_CONTENT_ID = /Content-ID:\s*([^#{EOL}]*)/ni
-    # Updated definitions from RFC 2231
-    ATTRIBUTE_CHAR = %r{[^ \t\v\n\r)(><@,;:\\"/\[\]?='*%]}
-    ATTRIBUTE = /#{ATTRIBUTE_CHAR}+/
-    SECTION = /\*[0-9]+/
-    REGULAR_PARAMETER_NAME = /#{ATTRIBUTE}#{SECTION}?/
-    REGULAR_PARAMETER = /(#{REGULAR_PARAMETER_NAME})=(#{VALUE})/
-    EXTENDED_OTHER_NAME = /#{ATTRIBUTE}\*[1-9][0-9]*\*/
-    EXTENDED_OTHER_VALUE = /%[0-9a-fA-F]{2}|#{ATTRIBUTE_CHAR}/
-    EXTENDED_OTHER_PARAMETER = /(#{EXTENDED_OTHER_NAME})=(#{EXTENDED_OTHER_VALUE}*)/
-    EXTENDED_INITIAL_NAME = /#{ATTRIBUTE}(?:\*0)?\*/
-    EXTENDED_INITIAL_VALUE = /[a-zA-Z0-9\-]*'[a-zA-Z0-9\-]*'#{EXTENDED_OTHER_VALUE}*/
-    EXTENDED_INITIAL_PARAMETER = /(#{EXTENDED_INITIAL_NAME})=(#{EXTENDED_INITIAL_VALUE})/
-    EXTENDED_PARAMETER = /#{EXTENDED_INITIAL_PARAMETER}|#{EXTENDED_OTHER_PARAMETER}/
-    DISPPARM = /;\s*(?:#{REGULAR_PARAMETER}|#{EXTENDED_PARAMETER})\s*/
-    RFC2183 = /^#{CONDISP}(#{DISPPARM})+$/i
-
-    class << self
-      def parse_multipart(env, params = Rack::Utils.default_query_parser)
-        extract_multipart Rack::Request.new(env), params
-      end
-
-      def extract_multipart(req, params = Rack::Utils.default_query_parser)
-        io = req.get_header(RACK_INPUT)
-        io.rewind
-        content_length = req.content_length
-        content_length = content_length.to_i if content_length
-
-        tempfile = req.get_header(RACK_MULTIPART_TEMPFILE_FACTORY) || Parser::TEMPFILE_FACTORY
-        bufsize = req.get_header(RACK_MULTIPART_BUFFER_SIZE) || Parser::BUFSIZE
-
-        info = Parser.parse io, content_length, req.get_header('CONTENT_TYPE'), tempfile, bufsize, params
-        req.set_header(RACK_TEMPFILES, info.tmp_files)
-        info.params
-      end
-
-      def build_multipart(params, first = true)
-        Generator.new(params, first).dump
-      end
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/multipart/generator.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/multipart/generator.rb
deleted file mode 100644
index f798a98c51012..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/multipart/generator.rb
+++ /dev/null
@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  module Multipart
-    class Generator
-      def initialize(params, first = true)
-        @params, @first = params, first
-
-        if @first && !@params.is_a?(Hash)
-          raise ArgumentError, "value must be a Hash"
-        end
-      end
-
-      def dump
-        return nil if @first && !multipart?
-        return flattened_params unless @first
-
-        flattened_params.map do |name, file|
-          if file.respond_to?(:original_filename)
-            if file.path
-              ::File.open(file.path, 'rb') do |f|
-                f.set_encoding(Encoding::BINARY)
-                content_for_tempfile(f, file, name)
-              end
-            else
-              content_for_tempfile(file, file, name)
-            end
-          else
-            content_for_other(file, name)
-          end
-        end.join << "--#{MULTIPART_BOUNDARY}--\r"
-      end
-
-      private
-      def multipart?
-        query = lambda { |value|
-          case value
-          when Array
-            value.any?(&query)
-          when Hash
-            value.values.any?(&query)
-          when Rack::Multipart::UploadedFile
-            true
-          end
-        }
-
-        @params.values.any?(&query)
-      end
-
-      def flattened_params
-        @flattened_params ||= begin
-          h = Hash.new
-          @params.each do |key, value|
-            k = @first ? key.to_s : "[#{key}]"
-
-            case value
-            when Array
-              value.map { |v|
-                Multipart.build_multipart(v, false).each { |subkey, subvalue|
-                  h["#{k}[]#{subkey}"] = subvalue
-                }
-              }
-            when Hash
-              Multipart.build_multipart(value, false).each { |subkey, subvalue|
-                h[k + subkey] = subvalue
-              }
-            else
-              h[k] = value
-            end
-          end
-          h
-        end
-      end
-
-      def content_for_tempfile(io, file, name)
-        length = ::File.stat(file.path).size if file.path
-        filename = "; filename=\"#{Utils.escape(file.original_filename)}\"" if file.original_filename
-<<-EOF
---#{MULTIPART_BOUNDARY}\r
-Content-Disposition: form-data; name="#{name}"#{filename}\r
-Content-Type: #{file.content_type}\r
-#{"Content-Length: #{length}\r\n" if length}\r
-#{io.read}\r
-EOF
-      end
-
-      def content_for_other(file, name)
-<<-EOF
---#{MULTIPART_BOUNDARY}\r
-Content-Disposition: form-data; name="#{name}"\r
-\r
-#{file}\r
-EOF
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/multipart/parser.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/multipart/parser.rb
deleted file mode 100644
index e8ed3e976acc7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/multipart/parser.rb
+++ /dev/null
@@ -1,365 +0,0 @@
-# frozen_string_literal: true
-
-require 'strscan'
-
-module Rack
-  module Multipart
-    class MultipartPartLimitError < Errno::EMFILE; end
-
-    class Parser
-      (require_relative '../core_ext/regexp'; using ::Rack::RegexpExtensions) if RUBY_VERSION < '2.4'
-
-      BUFSIZE = 1_048_576
-      TEXT_PLAIN = "text/plain"
-      TEMPFILE_FACTORY = lambda { |filename, content_type|
-        Tempfile.new(["RackMultipart", ::File.extname(filename.gsub("\0", '%00'))])
-      }
-
-      BOUNDARY_REGEX = /\A([^\n]*(?:\n|\Z))/
-
-      class BoundedIO # :nodoc:
-        def initialize(io, content_length)
-          @io             = io
-          @content_length = content_length
-          @cursor = 0
-        end
-
-        def read(size, outbuf = nil)
-          return if @cursor >= @content_length
-
-          left = @content_length - @cursor
-
-          str = if left < size
-                  @io.read left, outbuf
-                else
-                  @io.read size, outbuf
-                end
-
-          if str
-            @cursor += str.bytesize
-          else
-            # Raise an error for mismatching Content-Length and actual contents
-            raise EOFError, "bad content body"
-          end
-
-          str
-        end
-
-        def rewind
-          @io.rewind
-        end
-      end
-
-      MultipartInfo = Struct.new :params, :tmp_files
-      EMPTY         = MultipartInfo.new(nil, [])
-
-      def self.parse_boundary(content_type)
-        return unless content_type
-        data = content_type.match(MULTIPART)
-        return unless data
-        data[1]
-      end
-
-      def self.parse(io, content_length, content_type, tmpfile, bufsize, qp)
-        return EMPTY if 0 == content_length
-
-        boundary = parse_boundary content_type
-        return EMPTY unless boundary
-
-        io = BoundedIO.new(io, content_length) if content_length
-        outbuf = String.new
-
-        parser = new(boundary, tmpfile, bufsize, qp)
-        parser.on_read io.read(bufsize, outbuf)
-
-        loop do
-          break if parser.state == :DONE
-          parser.on_read io.read(bufsize, outbuf)
-        end
-
-        io.rewind
-        parser.result
-      end
-
-      class Collector
-        class MimePart < Struct.new(:body, :head, :filename, :content_type, :name)
-          def get_data
-            data = body
-            if filename == ""
-              # filename is blank which means no file has been selected
-              return
-            elsif filename
-              body.rewind if body.respond_to?(:rewind)
-
-              # Take the basename of the upload's original filename.
-              # This handles the full Windows paths given by Internet Explorer
-              # (and perhaps other broken user agents) without affecting
-              # those which give the lone filename.
-              fn = filename.split(/[\/\\]/).last
-
-              data = { filename: fn, type: content_type,
-                      name: name, tempfile: body, head: head }
-            end
-
-            yield data
-          end
-        end
-
-        class BufferPart < MimePart
-          def file?; false; end
-          def close; end
-        end
-
-        class TempfilePart < MimePart
-          def file?; true; end
-          def close; body.close; end
-        end
-
-        include Enumerable
-
-        def initialize(tempfile)
-          @tempfile = tempfile
-          @mime_parts = []
-          @open_files = 0
-        end
-
-        def each
-          @mime_parts.each { |part| yield part }
-        end
-
-        def on_mime_head(mime_index, head, filename, content_type, name)
-          if filename
-            body = @tempfile.call(filename, content_type)
-            body.binmode if body.respond_to?(:binmode)
-            klass = TempfilePart
-            @open_files += 1
-          else
-            body = String.new
-            klass = BufferPart
-          end
-
-          @mime_parts[mime_index] = klass.new(body, head, filename, content_type, name)
-
-          check_open_files
-        end
-
-        def on_mime_body(mime_index, content)
-          @mime_parts[mime_index].body << content
-        end
-
-        def on_mime_finish(mime_index)
-        end
-
-        private
-
-        def check_open_files
-          if Utils.multipart_part_limit > 0
-            if @open_files >= Utils.multipart_part_limit
-              @mime_parts.each(&:close)
-              raise MultipartPartLimitError, 'Maximum file multiparts in content reached'
-            end
-          end
-        end
-      end
-
-      attr_reader :state
-
-      def initialize(boundary, tempfile, bufsize, query_parser)
-        @query_parser   = query_parser
-        @params         = query_parser.make_params
-        @boundary       = "--#{boundary}"
-        @bufsize        = bufsize
-
-        @full_boundary = @boundary
-        @end_boundary = @boundary + '--'
-        @state = :FAST_FORWARD
-        @mime_index = 0
-        @collector = Collector.new tempfile
-
-        @sbuf = StringScanner.new("".dup)
-        @body_regex = /(?:#{EOL})?#{Regexp.quote(@boundary)}(?:#{EOL}|--)/m
-        @rx_max_size = EOL.size + @boundary.bytesize + [EOL.size, '--'.size].max
-        @head_regex = /(.*?#{EOL})#{EOL}/m
-      end
-
-      def on_read(content)
-        handle_empty_content!(content)
-        @sbuf.concat content
-        run_parser
-      end
-
-      def result
-        @collector.each do |part|
-          part.get_data do |data|
-            tag_multipart_encoding(part.filename, part.content_type, part.name, data)
-            @query_parser.normalize_params(@params, part.name, data, @query_parser.param_depth_limit)
-          end
-        end
-        MultipartInfo.new @params.to_params_hash, @collector.find_all(&:file?).map(&:body)
-      end
-
-      private
-
-      def run_parser
-        loop do
-          case @state
-          when :FAST_FORWARD
-            break if handle_fast_forward == :want_read
-          when :CONSUME_TOKEN
-            break if handle_consume_token == :want_read
-          when :MIME_HEAD
-            break if handle_mime_head == :want_read
-          when :MIME_BODY
-            break if handle_mime_body == :want_read
-          when :DONE
-            break
-          end
-        end
-      end
-
-      def handle_fast_forward
-        if consume_boundary
-          @state = :MIME_HEAD
-        else
-          raise EOFError, "bad content body" if @sbuf.rest_size >= @bufsize
-          :want_read
-        end
-      end
-
-      def handle_consume_token
-        tok = consume_boundary
-        # break if we're at the end of a buffer, but not if it is the end of a field
-        @state = if tok == :END_BOUNDARY || (@sbuf.eos? && tok != :BOUNDARY)
-          :DONE
-        else
-          :MIME_HEAD
-        end
-      end
-
-      def handle_mime_head
-        if @sbuf.scan_until(@head_regex)
-          head = @sbuf[1]
-          content_type = head[MULTIPART_CONTENT_TYPE, 1]
-          if name = head[MULTIPART_CONTENT_DISPOSITION, 1]
-            name = Rack::Auth::Digest::Params::dequote(name)
-          else
-            name = head[MULTIPART_CONTENT_ID, 1]
-          end
-
-          filename = get_filename(head)
-
-          if name.nil? || name.empty?
-            name = filename || "#{content_type || TEXT_PLAIN}[]".dup
-          end
-
-          @collector.on_mime_head @mime_index, head, filename, content_type, name
-          @state = :MIME_BODY
-        else
-          :want_read
-        end
-      end
-
-      def handle_mime_body
-        if (body_with_boundary = @sbuf.check_until(@body_regex)) # check but do not advance the pointer yet
-          body = body_with_boundary.sub(/#{@body_regex}\z/m, '') # remove the boundary from the string
-          @collector.on_mime_body @mime_index, body
-          @sbuf.pos += body.length + 2 # skip \r\n after the content
-          @state = :CONSUME_TOKEN
-          @mime_index += 1
-        else
-          # Save what we have so far
-          if @rx_max_size < @sbuf.rest_size
-            delta = @sbuf.rest_size - @rx_max_size
-            @collector.on_mime_body @mime_index, @sbuf.peek(delta)
-            @sbuf.pos += delta
-            @sbuf.string = @sbuf.rest
-          end
-          :want_read
-        end
-      end
-
-      def full_boundary; @full_boundary; end
-
-      def consume_boundary
-        while read_buffer = @sbuf.scan_until(BOUNDARY_REGEX)
-          case read_buffer.strip
-          when full_boundary then return :BOUNDARY
-          when @end_boundary then return :END_BOUNDARY
-          end
-          return if @sbuf.eos?
-        end
-      end
-
-      def get_filename(head)
-        filename = nil
-        case head
-        when RFC2183
-          params = Hash[*head.scan(DISPPARM).flat_map(&:compact)]
-
-          if filename = params['filename']
-            filename = $1 if filename =~ /^"(.*)"$/
-          elsif filename = params['filename*']
-            encoding, _, filename = filename.split("'", 3)
-          end
-        when BROKEN
-          filename = $1
-          filename = $1 if filename =~ /^"(.*)"$/
-        end
-
-        return unless filename
-
-        if filename.scan(/%.?.?/).all? { |s| /%[0-9a-fA-F]{2}/.match?(s) }
-          filename = Utils.unescape_path(filename)
-        end
-
-        filename.scrub!
-
-        if filename !~ /\\[^\\"]/
-          filename = filename.gsub(/\\(.)/, '\1')
-        end
-
-        if encoding
-          filename.force_encoding ::Encoding.find(encoding)
-        end
-
-        filename
-      end
-
-      CHARSET = "charset"
-
-      def tag_multipart_encoding(filename, content_type, name, body)
-        name = name.to_s
-        encoding = Encoding::UTF_8
-
-        name.force_encoding(encoding)
-
-        return if filename
-
-        if content_type
-          list         = content_type.split(';')
-          type_subtype = list.first
-          type_subtype.strip!
-          if TEXT_PLAIN == type_subtype
-            rest = list.drop 1
-            rest.each do |param|
-              k, v = param.split('=', 2)
-              k.strip!
-              v.strip!
-              v = v[1..-2] if v.start_with?('"') && v.end_with?('"')
-              encoding = Encoding.find v if k == CHARSET
-            end
-          end
-        end
-
-        name.force_encoding(encoding)
-        body.force_encoding(encoding)
-      end
-
-      def handle_empty_content!(content)
-        if content.nil? || content.empty?
-          raise EOFError
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/multipart/uploaded_file.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/multipart/uploaded_file.rb
deleted file mode 100644
index 9eaf691277b1e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/multipart/uploaded_file.rb
+++ /dev/null
@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  module Multipart
-    class UploadedFile
-      # The filename, *not* including the path, of the "uploaded" file
-      attr_reader :original_filename
-
-      # The content type of the "uploaded" file
-      attr_accessor :content_type
-
-      def initialize(filepath = nil, ct = "text/plain", bin = false,
-                     path: filepath, content_type: ct, binary: bin, filename: nil, io: nil)
-        if io
-          @tempfile = io
-          @original_filename = filename
-        else
-          raise "#{path} file does not exist" unless ::File.exist?(path)
-          @original_filename = filename || ::File.basename(path)
-          @tempfile = Tempfile.new([@original_filename, ::File.extname(path)], encoding: Encoding::BINARY)
-          @tempfile.binmode if binary
-          FileUtils.copy_file(path, @tempfile.path)
-        end
-        @content_type = content_type
-      end
-
-      def path
-        @tempfile.path if @tempfile.respond_to?(:path)
-      end
-      alias_method :local_path, :path
-
-      def respond_to?(*args)
-        super or @tempfile.respond_to?(*args)
-      end
-
-      def method_missing(method_name, *args, &block) #:nodoc:
-        @tempfile.__send__(method_name, *args, &block)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/null_logger.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/null_logger.rb
deleted file mode 100644
index 3eff73d683fd3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/null_logger.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  class NullLogger
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      env[RACK_LOGGER] = self
-      @app.call(env)
-    end
-
-    def info(progname = nil, &block); end
-    def debug(progname = nil, &block); end
-    def warn(progname = nil, &block); end
-    def error(progname = nil, &block); end
-    def fatal(progname = nil, &block); end
-    def unknown(progname = nil, &block); end
-    def info? ;  end
-    def debug? ; end
-    def warn? ;  end
-    def error? ; end
-    def fatal? ; end
-    def level ; end
-    def progname ; end
-    def datetime_format ; end
-    def formatter ; end
-    def sev_threshold ; end
-    def level=(level); end
-    def progname=(progname); end
-    def datetime_format=(datetime_format); end
-    def formatter=(formatter); end
-    def sev_threshold=(sev_threshold); end
-    def close ; end
-    def add(severity, message = nil, progname = nil, &block); end
-    def <<(msg); end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/query_parser.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/query_parser.rb
deleted file mode 100644
index 1c3923c32ff79..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/query_parser.rb
+++ /dev/null
@@ -1,221 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  class QueryParser
-    (require_relative 'core_ext/regexp'; using ::Rack::RegexpExtensions) if RUBY_VERSION < '2.4'
-
-    DEFAULT_SEP = /[&;] */n
-    COMMON_SEP = { ";" => /[;] */n, ";," => /[;,] */n, "&" => /[&] */n }
-
-    # ParameterTypeError is the error that is raised when incoming structural
-    # parameters (parsed by parse_nested_query) contain conflicting types.
-    class ParameterTypeError < TypeError; end
-
-    # InvalidParameterError is the error that is raised when incoming structural
-    # parameters (parsed by parse_nested_query) contain invalid format or byte
-    # sequence.
-    class InvalidParameterError < ArgumentError; end
-
-    # ParamsTooDeepError is the error that is raised when params are recursively
-    # nested over the specified limit.
-    class ParamsTooDeepError < RangeError; end
-
-    def self.make_default(key_space_limit, param_depth_limit)
-      new Params, key_space_limit, param_depth_limit
-    end
-
-    attr_reader :key_space_limit, :param_depth_limit
-
-    def initialize(params_class, key_space_limit, param_depth_limit)
-      @params_class = params_class
-      @key_space_limit = key_space_limit
-      @param_depth_limit = param_depth_limit
-    end
-
-    # Stolen from Mongrel, with some small modifications:
-    # Parses a query string by breaking it up at the '&'
-    # and ';' characters.  You can also use this to parse
-    # cookies by changing the characters used in the second
-    # parameter (which defaults to '&;').
-    def parse_query(qs, d = nil, &unescaper)
-      unescaper ||= method(:unescape)
-
-      params = make_params
-
-      (qs || '').split(d ? (COMMON_SEP[d] || /[#{d}] */n) : DEFAULT_SEP).each do |p|
-        next if p.empty?
-        k, v = p.split('=', 2).map!(&unescaper)
-
-        if cur = params[k]
-          if cur.class == Array
-            params[k] << v
-          else
-            params[k] = [cur, v]
-          end
-        else
-          params[k] = v
-        end
-      end
-
-      return params.to_h
-    end
-
-    # parse_nested_query expands a query string into structural types. Supported
-    # types are Arrays, Hashes and basic value types. It is possible to supply
-    # query strings with parameters of conflicting types, in this case a
-    # ParameterTypeError is raised. Users are encouraged to return a 400 in this
-    # case.
-    def parse_nested_query(qs, d = nil)
-      params = make_params
-
-      unless qs.nil? || qs.empty?
-        (qs || '').split(d ? (COMMON_SEP[d] || /[#{d}] */n) : DEFAULT_SEP).each do |p|
-          k, v = p.split('=', 2).map! { |s| unescape(s) }
-
-          normalize_params(params, k, v, param_depth_limit)
-        end
-      end
-
-      return params.to_h
-    rescue ArgumentError => e
-      raise InvalidParameterError, e.message, e.backtrace
-    end
-
-    # normalize_params recursively expands parameters into structural types. If
-    # the structural types represented by two different parameter names are in
-    # conflict, a ParameterTypeError is raised.
-    def normalize_params(params, name, v, depth)
-      raise ParamsTooDeepError if depth <= 0
-
-      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
-      k = $1 || ''
-      after = $' || ''
-
-      if k.empty?
-        if !v.nil? && name == "[]"
-          return Array(v)
-        else
-          return
-        end
-      end
-
-      if after == ''
-        params[k] = v
-      elsif after == "["
-        params[name] = v
-      elsif after == "[]"
-        params[k] ||= []
-        raise ParameterTypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
-        params[k] << v
-      elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
-        child_key = $1
-        params[k] ||= []
-        raise ParameterTypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
-        if params_hash_type?(params[k].last) && !params_hash_has_key?(params[k].last, child_key)
-          normalize_params(params[k].last, child_key, v, depth - 1)
-        else
-          params[k] << normalize_params(make_params, child_key, v, depth - 1)
-        end
-      else
-        params[k] ||= make_params
-        raise ParameterTypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params_hash_type?(params[k])
-        params[k] = normalize_params(params[k], after, v, depth - 1)
-      end
-
-      params
-    end
-
-    def make_params
-      @params_class.new @key_space_limit
-    end
-
-    def new_space_limit(key_space_limit)
-      self.class.new @params_class, key_space_limit, param_depth_limit
-    end
-
-    def new_depth_limit(param_depth_limit)
-      self.class.new @params_class, key_space_limit, param_depth_limit
-    end
-
-    private
-
-    def params_hash_type?(obj)
-      obj.kind_of?(@params_class)
-    end
-
-    def params_hash_has_key?(hash, key)
-      return false if /\[\]/.match?(key)
-
-      key.split(/[\[\]]+/).inject(hash) do |h, part|
-        next h if part == ''
-        return false unless params_hash_type?(h) && h.key?(part)
-        h[part]
-      end
-
-      true
-    end
-
-    def unescape(s)
-      Utils.unescape(s)
-    end
-
-    class Params
-      def initialize(limit)
-        @limit  = limit
-        @size   = 0
-        @params = {}
-      end
-
-      def [](key)
-        @params[key]
-      end
-
-      def []=(key, value)
-        @size += key.size if key && !@params.key?(key)
-        raise ParamsTooDeepError, 'exceeded available parameter key space' if @size > @limit
-        @params[key] = value
-      end
-
-      def key?(key)
-        @params.key?(key)
-      end
-
-      # Recursively unwraps nested `Params` objects and constructs an object
-      # of the same shape, but using the objects' internal representations
-      # (Ruby hashes) in place of the objects. The result is a hash consisting
-      # purely of Ruby primitives.
-      #
-      #   Mutation warning!
-      #
-      #   1. This method mutates the internal representation of the `Params`
-      #      objects in order to save object allocations.
-      #
-      #   2. The value you get back is a reference to the internal hash
-      #      representation, not a copy.
-      #
-      #   3. Because the `Params` object's internal representation is mutable
-      #      through the `#[]=` method, it is not thread safe. The result of
-      #      getting the hash representation while another thread is adding a
-      #      key to it is non-deterministic.
-      #
-      def to_h
-        @params.each do |key, value|
-          case value
-          when self
-            # Handle circular references gracefully.
-            @params[key] = @params
-          when Params
-            @params[key] = value.to_h
-          when Array
-            value.map! { |v| v.kind_of?(Params) ? v.to_h : v }
-          else
-            # Ignore anything that is not a `Params` object or
-            # a collection that can contain one.
-          end
-        end
-        @params
-      end
-      alias_method :to_params_hash, :to_h
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/recursive.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/recursive.rb
deleted file mode 100644
index 6971cbfd69dd2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/recursive.rb
+++ /dev/null
@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'uri'
-
-module Rack
-  # Rack::ForwardRequest gets caught by Rack::Recursive and redirects
-  # the current request to the app at +url+.
-  #
-  #   raise ForwardRequest.new("/not-found")
-  #
-
-  class ForwardRequest < Exception
-    attr_reader :url, :env
-
-    def initialize(url, env = {})
-      @url = URI(url)
-      @env = env
-
-      @env[PATH_INFO]       = @url.path
-      @env[QUERY_STRING]    = @url.query  if @url.query
-      @env[HTTP_HOST]       = @url.host   if @url.host
-      @env[HTTP_PORT]       = @url.port   if @url.port
-      @env[RACK_URL_SCHEME] = @url.scheme if @url.scheme
-
-      super "forwarding to #{url}"
-    end
-  end
-
-  # Rack::Recursive allows applications called down the chain to
-  # include data from other applications (by using
-  # <tt>rack['rack.recursive.include'][...]</tt> or raise a
-  # ForwardRequest to redirect internally.
-
-  class Recursive
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      dup._call(env)
-    end
-
-    def _call(env)
-      @script_name = env[SCRIPT_NAME]
-      @app.call(env.merge(RACK_RECURSIVE_INCLUDE => method(:include)))
-    rescue ForwardRequest => req
-      call(env.merge(req.env))
-    end
-
-    def include(env, path)
-      unless path.index(@script_name) == 0 && (path[@script_name.size] == ?/ ||
-                                               path[@script_name.size].nil?)
-        raise ArgumentError, "can only include below #{@script_name}, not #{path}"
-      end
-
-      env = env.merge(PATH_INFO => path,
-                      SCRIPT_NAME => @script_name,
-                      REQUEST_METHOD => GET,
-                      "CONTENT_LENGTH" => "0", "CONTENT_TYPE" => "",
-                      RACK_INPUT => StringIO.new(""))
-      @app.call(env)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/reloader.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/reloader.rb
deleted file mode 100644
index 2f17f50b83609..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/reloader.rb
+++ /dev/null
@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (C) 2009-2018 Michael Fellinger <m.fellinger@gmail.com>
-# Rack::Reloader is subject to the terms of an MIT-style license.
-# See MIT-LICENSE or https://opensource.org/licenses/MIT.
-
-require 'pathname'
-
-module Rack
-
-  # High performant source reloader
-  #
-  # This class acts as Rack middleware.
-  #
-  # What makes it especially suited for use in a production environment is that
-  # any file will only be checked once and there will only be made one system
-  # call stat(2).
-  #
-  # Please note that this will not reload files in the background, it does so
-  # only when actively called.
-  #
-  # It is performing a check/reload cycle at the start of every request, but
-  # also respects a cool down time, during which nothing will be done.
-  class Reloader
-    (require_relative 'core_ext/regexp'; using ::Rack::RegexpExtensions) if RUBY_VERSION < '2.4'
-
-    def initialize(app, cooldown = 10, backend = Stat)
-      @app = app
-      @cooldown = cooldown
-      @last = (Time.now - cooldown)
-      @cache = {}
-      @mtimes = {}
-      @reload_mutex = Mutex.new
-
-      extend backend
-    end
-
-    def call(env)
-      if @cooldown and Time.now > @last + @cooldown
-        if Thread.list.size > 1
-          @reload_mutex.synchronize{ reload! }
-        else
-          reload!
-        end
-
-        @last = Time.now
-      end
-
-      @app.call(env)
-    end
-
-    def reload!(stderr = $stderr)
-      rotation do |file, mtime|
-        previous_mtime = @mtimes[file] ||= mtime
-        safe_load(file, mtime, stderr) if mtime > previous_mtime
-      end
-    end
-
-    # A safe Kernel::load, issuing the hooks depending on the results
-    def safe_load(file, mtime, stderr = $stderr)
-      load(file)
-      stderr.puts "#{self.class}: reloaded `#{file}'"
-      file
-    rescue LoadError, SyntaxError => ex
-      stderr.puts ex
-    ensure
-      @mtimes[file] = mtime
-    end
-
-    module Stat
-      def rotation
-        files = [$0, *$LOADED_FEATURES].uniq
-        paths = ['./', *$LOAD_PATH].uniq
-
-        files.map{|file|
-          next if /\.(so|bundle)$/.match?(file) # cannot reload compiled files
-
-          found, stat = figure_path(file, paths)
-          next unless found && stat && mtime = stat.mtime
-
-          @cache[file] = found
-
-          yield(found, mtime)
-        }.compact
-      end
-
-      # Takes a relative or absolute +file+ name, a couple possible +paths+ that
-      # the +file+ might reside in. Returns the full path and File::Stat for the
-      # path.
-      def figure_path(file, paths)
-        found = @cache[file]
-        found = file if !found and Pathname.new(file).absolute?
-        found, stat = safe_stat(found)
-        return found, stat if found
-
-        paths.find do |possible_path|
-          path = ::File.join(possible_path, file)
-          found, stat = safe_stat(path)
-          return ::File.expand_path(found), stat if found
-        end
-
-        return false, false
-      end
-
-      def safe_stat(file)
-        return unless file
-        stat = ::File.stat(file)
-        return file, stat if stat.file?
-      rescue Errno::ENOENT, Errno::ENOTDIR, Errno::ESRCH
-        @cache.delete(file) and false
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/request.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/request.rb
deleted file mode 100644
index 750a0dc44f6a7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/request.rb
+++ /dev/null
@@ -1,659 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  # Rack::Request provides a convenient interface to a Rack
-  # environment.  It is stateless, the environment +env+ passed to the
-  # constructor will be directly modified.
-  #
-  #   req = Rack::Request.new(env)
-  #   req.post?
-  #   req.params["data"]
-
-  class Request
-    (require_relative 'core_ext/regexp'; using ::Rack::RegexpExtensions) if RUBY_VERSION < '2.4'
-
-    class << self
-      attr_accessor :ip_filter
-    end
-
-    self.ip_filter = lambda { |ip| /\A127\.0\.0\.1\Z|\A(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\.|\A::1\Z|\Afd[0-9a-f]{2}:.+|\Alocalhost\Z|\Aunix\Z|\Aunix:/i.match?(ip) }
-    ALLOWED_SCHEMES = %w(https http).freeze
-    SCHEME_WHITELIST = ALLOWED_SCHEMES
-    if Object.respond_to?(:deprecate_constant)
-      deprecate_constant :SCHEME_WHITELIST
-    end
-
-    def initialize(env)
-      @params = nil
-      super(env)
-    end
-
-    def params
-      @params ||= super
-    end
-
-    def update_param(k, v)
-      super
-      @params = nil
-    end
-
-    def delete_param(k)
-      v = super
-      @params = nil
-      v
-    end
-
-    module Env
-      # The environment of the request.
-      attr_reader :env
-
-      def initialize(env)
-        @env = env
-        super()
-      end
-
-      # Predicate method to test to see if `name` has been set as request
-      # specific data
-      def has_header?(name)
-        @env.key? name
-      end
-
-      # Get a request specific value for `name`.
-      def get_header(name)
-        @env[name]
-      end
-
-      # If a block is given, it yields to the block if the value hasn't been set
-      # on the request.
-      def fetch_header(name, &block)
-        @env.fetch(name, &block)
-      end
-
-      # Loops through each key / value pair in the request specific data.
-      def each_header(&block)
-        @env.each(&block)
-      end
-
-      # Set a request specific value for `name` to `v`
-      def set_header(name, v)
-        @env[name] = v
-      end
-
-      # Add a header that may have multiple values.
-      #
-      # Example:
-      #   request.add_header 'Accept', 'image/png'
-      #   request.add_header 'Accept', '*/*'
-      #
-      #   assert_equal 'image/png,*/*', request.get_header('Accept')
-      #
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
-      def add_header(key, v)
-        if v.nil?
-          get_header key
-        elsif has_header? key
-          set_header key, "#{get_header key},#{v}"
-        else
-          set_header key, v
-        end
-      end
-
-      # Delete a request specific value for `name`.
-      def delete_header(name)
-        @env.delete name
-      end
-
-      def initialize_copy(other)
-        @env = other.env.dup
-      end
-    end
-
-    module Helpers
-      # The set of form-data media-types. Requests that do not indicate
-      # one of the media types present in this list will not be eligible
-      # for form-data / param parsing.
-      FORM_DATA_MEDIA_TYPES = [
-        'application/x-www-form-urlencoded',
-        'multipart/form-data'
-      ]
-
-      # The set of media-types. Requests that do not indicate
-      # one of the media types present in this list will not be eligible
-      # for param parsing like soap attachments or generic multiparts
-      PARSEABLE_DATA_MEDIA_TYPES = [
-        'multipart/related',
-        'multipart/mixed'
-      ]
-
-      # Default ports depending on scheme. Used to decide whether or not
-      # to include the port in a generated URI.
-      DEFAULT_PORTS = { 'http' => 80, 'https' => 443, 'coffee' => 80 }
-
-      # The address of the client which connected to the proxy.
-      HTTP_X_FORWARDED_FOR = 'HTTP_X_FORWARDED_FOR'
-
-      # The contents of the host/:authority header sent to the proxy.
-      HTTP_X_FORWARDED_HOST = 'HTTP_X_FORWARDED_HOST'
-
-      # The value of the scheme sent to the proxy.
-      HTTP_X_FORWARDED_SCHEME = 'HTTP_X_FORWARDED_SCHEME'
-
-      # The protocol used to connect to the proxy.
-      HTTP_X_FORWARDED_PROTO = 'HTTP_X_FORWARDED_PROTO'
-
-      # The port used to connect to the proxy.
-      HTTP_X_FORWARDED_PORT = 'HTTP_X_FORWARDED_PORT'
-
-      # Another way for specifing https scheme was used.
-      HTTP_X_FORWARDED_SSL = 'HTTP_X_FORWARDED_SSL'
-
-      def body;            get_header(RACK_INPUT)                         end
-      def script_name;     get_header(SCRIPT_NAME).to_s                   end
-      def script_name=(s); set_header(SCRIPT_NAME, s.to_s)                end
-
-      def path_info;       get_header(PATH_INFO).to_s                     end
-      def path_info=(s);   set_header(PATH_INFO, s.to_s)                  end
-
-      def request_method;  get_header(REQUEST_METHOD)                     end
-      def query_string;    get_header(QUERY_STRING).to_s                  end
-      def content_length;  get_header('CONTENT_LENGTH')                   end
-      def logger;          get_header(RACK_LOGGER)                        end
-      def user_agent;      get_header('HTTP_USER_AGENT')                  end
-      def multithread?;    get_header(RACK_MULTITHREAD)                   end
-
-      # the referer of the client
-      def referer;         get_header('HTTP_REFERER')                     end
-      alias referrer referer
-
-      def session
-        fetch_header(RACK_SESSION) do |k|
-          set_header RACK_SESSION, default_session
-        end
-      end
-
-      def session_options
-        fetch_header(RACK_SESSION_OPTIONS) do |k|
-          set_header RACK_SESSION_OPTIONS, {}
-        end
-      end
-
-      # Checks the HTTP request method (or verb) to see if it was of type DELETE
-      def delete?;  request_method == DELETE  end
-
-      # Checks the HTTP request method (or verb) to see if it was of type GET
-      def get?;     request_method == GET     end
-
-      # Checks the HTTP request method (or verb) to see if it was of type HEAD
-      def head?;    request_method == HEAD    end
-
-      # Checks the HTTP request method (or verb) to see if it was of type OPTIONS
-      def options?; request_method == OPTIONS end
-
-      # Checks the HTTP request method (or verb) to see if it was of type LINK
-      def link?;    request_method == LINK    end
-
-      # Checks the HTTP request method (or verb) to see if it was of type PATCH
-      def patch?;   request_method == PATCH   end
-
-      # Checks the HTTP request method (or verb) to see if it was of type POST
-      def post?;    request_method == POST    end
-
-      # Checks the HTTP request method (or verb) to see if it was of type PUT
-      def put?;     request_method == PUT     end
-
-      # Checks the HTTP request method (or verb) to see if it was of type TRACE
-      def trace?;   request_method == TRACE   end
-
-      # Checks the HTTP request method (or verb) to see if it was of type UNLINK
-      def unlink?;  request_method == UNLINK  end
-
-      def scheme
-        if get_header(HTTPS) == 'on'
-          'https'
-        elsif get_header(HTTP_X_FORWARDED_SSL) == 'on'
-          'https'
-        elsif forwarded_scheme
-          forwarded_scheme
-        else
-          get_header(RACK_URL_SCHEME)
-        end
-      end
-
-      # The authority of the incoming request as defined by RFC3976.
-      # https://tools.ietf.org/html/rfc3986#section-3.2
-      #
-      # In HTTP/1, this is the `host` header.
-      # In HTTP/2, this is the `:authority` pseudo-header.
-      def authority
-        forwarded_authority || host_authority || server_authority
-      end
-
-      # The authority as defined by the `SERVER_NAME` and `SERVER_PORT`
-      # variables.
-      def server_authority
-        host = self.server_name
-        port = self.server_port
-
-        if host
-          if port
-            "#{host}:#{port}"
-          else
-            host
-          end
-        end
-      end
-
-      def server_name
-        get_header(SERVER_NAME)
-      end
-
-      def server_port
-        if port = get_header(SERVER_PORT)
-          Integer(port)
-        end
-      end
-
-      def cookies
-        hash = fetch_header(RACK_REQUEST_COOKIE_HASH) do |key|
-          set_header(key, {})
-        end
-
-        string = get_header(HTTP_COOKIE)
-
-        unless string == get_header(RACK_REQUEST_COOKIE_STRING)
-          hash.replace Utils.parse_cookies_header(string)
-          set_header(RACK_REQUEST_COOKIE_STRING, string)
-        end
-
-        hash
-      end
-
-      def content_type
-        content_type = get_header('CONTENT_TYPE')
-        content_type.nil? || content_type.empty? ? nil : content_type
-      end
-
-      def xhr?
-        get_header("HTTP_X_REQUESTED_WITH") == "XMLHttpRequest"
-      end
-
-      # The `HTTP_HOST` header.
-      def host_authority
-        get_header(HTTP_HOST)
-      end
-
-      def host_with_port(authority = self.authority)
-        host, _, port = split_authority(authority)
-
-        if port == DEFAULT_PORTS[self.scheme]
-          host
-        else
-          authority
-        end
-      end
-
-      # Returns a formatted host, suitable for being used in a URI.
-      def host
-        split_authority(self.authority)[0]
-      end
-
-      # Returns an address suitable for being to resolve to an address.
-      # In the case of a domain name or IPv4 address, the result is the same
-      # as +host+. In the case of IPv6 or future address formats, the square
-      # brackets are removed.
-      def hostname
-        split_authority(self.authority)[1]
-      end
-
-      def port
-        if authority = self.authority
-          _, _, port = split_authority(self.authority)
-
-          if port
-            return port
-          end
-        end
-
-        if forwarded_port = self.forwarded_port
-          return forwarded_port.first
-        end
-
-        if scheme = self.scheme
-          if port = DEFAULT_PORTS[self.scheme]
-            return port
-          end
-        end
-
-        self.server_port
-      end
-
-      def forwarded_for
-        if value = get_header(HTTP_X_FORWARDED_FOR)
-          split_header(value).map do |authority|
-            split_authority(wrap_ipv6(authority))[1]
-          end
-        end
-      end
-
-      def forwarded_port
-        if value = get_header(HTTP_X_FORWARDED_PORT)
-          split_header(value).map(&:to_i)
-        end
-      end
-
-      def forwarded_authority
-        if value = get_header(HTTP_X_FORWARDED_HOST)
-          wrap_ipv6(split_header(value).first)
-        end
-      end
-
-      def ssl?
-        scheme == 'https' || scheme == 'wss'
-      end
-
-      def ip
-        remote_addresses = split_header(get_header('REMOTE_ADDR'))
-        external_addresses = reject_trusted_ip_addresses(remote_addresses)
-
-        unless external_addresses.empty?
-          return external_addresses.first
-        end
-
-        if forwarded_for = self.forwarded_for
-          unless forwarded_for.empty?
-            # The forwarded for addresses are ordered: client, proxy1, proxy2.
-            # So we reject all the trusted addresses (proxy*) and return the
-            # last client. Or if we trust everyone, we just return the first
-            # address.
-            return reject_trusted_ip_addresses(forwarded_for).last || forwarded_for.first
-          end
-        end
-
-        # If all the addresses are trusted, and we aren't forwarded, just return
-        # the first remote address, which represents the source of the request.
-        remote_addresses.first
-      end
-
-      # The media type (type/subtype) portion of the CONTENT_TYPE header
-      # without any media type parameters. e.g., when CONTENT_TYPE is
-      # "text/plain;charset=utf-8", the media-type is "text/plain".
-      #
-      # For more information on the use of media types in HTTP, see:
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
-      def media_type
-        MediaType.type(content_type)
-      end
-
-      # The media type parameters provided in CONTENT_TYPE as a Hash, or
-      # an empty Hash if no CONTENT_TYPE or media-type parameters were
-      # provided.  e.g., when the CONTENT_TYPE is "text/plain;charset=utf-8",
-      # this method responds with the following Hash:
-      #   { 'charset' => 'utf-8' }
-      def media_type_params
-        MediaType.params(content_type)
-      end
-
-      # The character set of the request body if a "charset" media type
-      # parameter was given, or nil if no "charset" was specified. Note
-      # that, per RFC2616, text/* media types that specify no explicit
-      # charset are to be considered ISO-8859-1.
-      def content_charset
-        media_type_params['charset']
-      end
-
-      # Determine whether the request body contains form-data by checking
-      # the request Content-Type for one of the media-types:
-      # "application/x-www-form-urlencoded" or "multipart/form-data". The
-      # list of form-data media types can be modified through the
-      # +FORM_DATA_MEDIA_TYPES+ array.
-      #
-      # A request body is also assumed to contain form-data when no
-      # Content-Type header is provided and the request_method is POST.
-      def form_data?
-        type = media_type
-        meth = get_header(RACK_METHODOVERRIDE_ORIGINAL_METHOD) || get_header(REQUEST_METHOD)
-
-        (meth == POST && type.nil?) || FORM_DATA_MEDIA_TYPES.include?(type)
-      end
-
-      # Determine whether the request body contains data by checking
-      # the request media_type against registered parse-data media-types
-      def parseable_data?
-        PARSEABLE_DATA_MEDIA_TYPES.include?(media_type)
-      end
-
-      # Returns the data received in the query string.
-      def GET
-        if get_header(RACK_REQUEST_QUERY_STRING) == query_string
-          get_header(RACK_REQUEST_QUERY_HASH)
-        else
-          query_hash = parse_query(query_string, '&;')
-          set_header(RACK_REQUEST_QUERY_STRING, query_string)
-          set_header(RACK_REQUEST_QUERY_HASH, query_hash)
-        end
-      end
-
-      # Returns the data received in the request body.
-      #
-      # This method support both application/x-www-form-urlencoded and
-      # multipart/form-data.
-      def POST
-        if get_header(RACK_INPUT).nil?
-          raise "Missing rack.input"
-        elsif get_header(RACK_REQUEST_FORM_INPUT) == get_header(RACK_INPUT)
-          get_header(RACK_REQUEST_FORM_HASH)
-        elsif form_data? || parseable_data?
-          unless set_header(RACK_REQUEST_FORM_HASH, parse_multipart)
-            form_vars = get_header(RACK_INPUT).read
-
-            # Fix for Safari Ajax postings that always append \0
-            # form_vars.sub!(/\0\z/, '') # performance replacement:
-            form_vars.slice!(-1) if form_vars.end_with?("\0")
-
-            set_header RACK_REQUEST_FORM_VARS, form_vars
-            set_header RACK_REQUEST_FORM_HASH, parse_query(form_vars, '&')
-
-            get_header(RACK_INPUT).rewind
-          end
-          set_header RACK_REQUEST_FORM_INPUT, get_header(RACK_INPUT)
-          get_header RACK_REQUEST_FORM_HASH
-        else
-          {}
-        end
-      end
-
-      # The union of GET and POST data.
-      #
-      # Note that modifications will not be persisted in the env. Use update_param or delete_param if you want to destructively modify params.
-      def params
-        self.GET.merge(self.POST)
-      end
-
-      # Destructively update a parameter, whether it's in GET and/or POST. Returns nil.
-      #
-      # The parameter is updated wherever it was previous defined, so GET, POST, or both. If it wasn't previously defined, it's inserted into GET.
-      #
-      # <tt>env['rack.input']</tt> is not touched.
-      def update_param(k, v)
-        found = false
-        if self.GET.has_key?(k)
-          found = true
-          self.GET[k] = v
-        end
-        if self.POST.has_key?(k)
-          found = true
-          self.POST[k] = v
-        end
-        unless found
-          self.GET[k] = v
-        end
-      end
-
-      # Destructively delete a parameter, whether it's in GET or POST. Returns the value of the deleted parameter.
-      #
-      # If the parameter is in both GET and POST, the POST value takes precedence since that's how #params works.
-      #
-      # <tt>env['rack.input']</tt> is not touched.
-      def delete_param(k)
-        post_value, get_value = self.POST.delete(k), self.GET.delete(k)
-        post_value || get_value
-      end
-
-      def base_url
-        "#{scheme}://#{host_with_port}"
-      end
-
-      # Tries to return a remake of the original request URL as a string.
-      def url
-        base_url + fullpath
-      end
-
-      def path
-        script_name + path_info
-      end
-
-      def fullpath
-        query_string.empty? ? path : "#{path}?#{query_string}"
-      end
-
-      def accept_encoding
-        parse_http_accept_header(get_header("HTTP_ACCEPT_ENCODING"))
-      end
-
-      def accept_language
-        parse_http_accept_header(get_header("HTTP_ACCEPT_LANGUAGE"))
-      end
-
-      def trusted_proxy?(ip)
-        Rack::Request.ip_filter.call(ip)
-      end
-
-      # shortcut for <tt>request.params[key]</tt>
-      def [](key)
-        if $VERBOSE
-          warn("Request#[] is deprecated and will be removed in a future version of Rack. Please use request.params[] instead")
-        end
-
-        params[key.to_s]
-      end
-
-      # shortcut for <tt>request.params[key] = value</tt>
-      #
-      # Note that modifications will not be persisted in the env. Use update_param or delete_param if you want to destructively modify params.
-      def []=(key, value)
-        if $VERBOSE
-          warn("Request#[]= is deprecated and will be removed in a future version of Rack. Please use request.params[]= instead")
-        end
-
-        params[key.to_s] = value
-      end
-
-      # like Hash#values_at
-      def values_at(*keys)
-        keys.map { |key| params[key] }
-      end
-
-      private
-
-      def default_session; {}; end
-
-      # Assist with compatibility when processing `X-Forwarded-For`.
-      def wrap_ipv6(host)
-        # Even thought IPv6 addresses should be wrapped in square brackets,
-        # sometimes this is not done in various legacy/underspecified headers.
-        # So we try to fix this situation for compatibility reasons.
-
-        # Try to detect IPv6 addresses which aren't escaped yet:
-        if !host.start_with?('[') && host.count(':') > 1
-          "[#{host}]"
-        else
-          host
-        end
-      end
-
-      def parse_http_accept_header(header)
-        header.to_s.split(/\s*,\s*/).map do |part|
-          attribute, parameters = part.split(/\s*;\s*/, 2)
-          quality = 1.0
-          if parameters and /\Aq=([\d.]+)/ =~ parameters
-            quality = $1.to_f
-          end
-          [attribute, quality]
-        end
-      end
-
-      def query_parser
-        Utils.default_query_parser
-      end
-
-      def parse_query(qs, d = '&')
-        query_parser.parse_nested_query(qs, d)
-      end
-
-      def parse_multipart
-        Rack::Multipart.extract_multipart(self, query_parser)
-      end
-
-      def split_header(value)
-        value ? value.strip.split(/[,\s]+/) : []
-      end
-
-      AUTHORITY = /^
-        # The host:
-        (?<host>
-          # An IPv6 address:
-          (\[(?<ip6>.*)\])
-          |
-          # An IPv4 address:
-          (?<ip4>[\d\.]+)
-          |
-          # A hostname:
-          (?<name>[a-zA-Z0-9\.\-]+)
-        )
-        # The optional port:
-        (:(?<port>\d+))?
-      $/x
-
-      private_constant :AUTHORITY
-
-      def split_authority(authority)
-        if match = AUTHORITY.match(authority)
-          if address = match[:ip6]
-            return match[:host], address, match[:port]&.to_i
-          else
-            return match[:host], match[:host], match[:port]&.to_i
-          end
-        end
-
-        # Give up!
-        return authority, authority, nil
-      end
-
-      def reject_trusted_ip_addresses(ip_addresses)
-        ip_addresses.reject { |ip| trusted_proxy?(ip) }
-      end
-
-      def forwarded_scheme
-        allowed_scheme(get_header(HTTP_X_FORWARDED_SCHEME)) ||
-        allowed_scheme(extract_proto_header(get_header(HTTP_X_FORWARDED_PROTO)))
-      end
-
-      def allowed_scheme(header)
-        header if ALLOWED_SCHEMES.include?(header)
-      end
-
-      def extract_proto_header(header)
-        if header
-          if (comma_index = header.index(','))
-            header[0, comma_index]
-          else
-            header
-          end
-        end
-      end
-    end
-
-    include Env
-    include Helpers
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/response.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/response.rb
deleted file mode 100644
index fd6d2f5d55550..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/response.rb
+++ /dev/null
@@ -1,318 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-
-module Rack
-  # Rack::Response provides a convenient interface to create a Rack
-  # response.
-  #
-  # It allows setting of headers and cookies, and provides useful
-  # defaults (an OK response with empty headers and body).
-  #
-  # You can use Response#write to iteratively generate your response,
-  # but note that this is buffered by Rack::Response until you call
-  # +finish+.  +finish+ however can take a block inside which calls to
-  # +write+ are synchronous with the Rack response.
-  #
-  # Your application's +call+ should end returning Response#finish.
-  class Response
-    def self.[](status, headers, body)
-      self.new(body, status, headers)
-    end
-
-    CHUNKED = 'chunked'
-    STATUS_WITH_NO_ENTITY_BODY = Utils::STATUS_WITH_NO_ENTITY_BODY
-
-    attr_accessor :length, :status, :body
-    attr_reader :headers
-
-    # @deprecated Use {#headers} instead.
-    alias header headers
-
-    # Initialize the response object with the specified body, status
-    # and headers.
-    #
-    # @param body [nil, #each, #to_str] the response body.
-    # @param status [Integer] the integer status as defined by the
-    # HTTP protocol RFCs.
-    # @param headers [#each] a list of key-value header pairs which
-    # conform to the HTTP protocol RFCs.
-    #
-    # Providing a body which responds to #to_str is legacy behaviour.
-    def initialize(body = nil, status = 200, headers = {})
-      @status = status.to_i
-      @headers = Utils::HeaderHash[headers]
-
-      @writer = self.method(:append)
-
-      @block = nil
-
-      # Keep track of whether we have expanded the user supplied body.
-      if body.nil?
-        @body = []
-        @buffered = true
-        @length = 0
-      elsif body.respond_to?(:to_str)
-        @body = [body]
-        @buffered = true
-        @length = body.to_str.bytesize
-      else
-        @body = body
-        @buffered = false
-        @length = 0
-      end
-
-      yield self if block_given?
-    end
-
-    def redirect(target, status = 302)
-      self.status = status
-      self.location = target
-    end
-
-    def chunked?
-      CHUNKED == get_header(TRANSFER_ENCODING)
-    end
-
-    # Generate a response array consistent with the requirements of the SPEC.
-    # @return [Array] a 3-tuple suitable of `[status, headers, body]`
-    # which is suitable to be returned from the middleware `#call(env)` method.
-    def finish(&block)
-      if STATUS_WITH_NO_ENTITY_BODY[status.to_i]
-        delete_header CONTENT_TYPE
-        delete_header CONTENT_LENGTH
-        close
-        return [@status, @headers, []]
-      else
-        if block_given?
-          @block = block
-          return [@status, @headers, self]
-        else
-          return [@status, @headers, @body]
-        end
-      end
-    end
-
-    alias to_a finish           # For *response
-
-    def each(&callback)
-      @body.each(&callback)
-      @buffered = true
-
-      if @block
-        @writer = callback
-        @block.call(self)
-      end
-    end
-
-    # Append to body and update Content-Length.
-    #
-    # NOTE: Do not mix #write and direct #body access!
-    #
-    def write(chunk)
-      buffered_body!
-
-      @writer.call(chunk.to_s)
-    end
-
-    def close
-      @body.close if @body.respond_to?(:close)
-    end
-
-    def empty?
-      @block == nil && @body.empty?
-    end
-
-    def has_header?(key);   headers.key? key;   end
-    def get_header(key);    headers[key];       end
-    def set_header(key, v); headers[key] = v;   end
-    def delete_header(key); headers.delete key; end
-
-    alias :[] :get_header
-    alias :[]= :set_header
-
-    module Helpers
-      def invalid?;             status < 100 || status >= 600;        end
-
-      def informational?;       status >= 100 && status < 200;        end
-      def successful?;          status >= 200 && status < 300;        end
-      def redirection?;         status >= 300 && status < 400;        end
-      def client_error?;        status >= 400 && status < 500;        end
-      def server_error?;        status >= 500 && status < 600;        end
-
-      def ok?;                  status == 200;                        end
-      def created?;             status == 201;                        end
-      def accepted?;            status == 202;                        end
-      def no_content?;          status == 204;                        end
-      def moved_permanently?;   status == 301;                        end
-      def bad_request?;         status == 400;                        end
-      def unauthorized?;        status == 401;                        end
-      def forbidden?;           status == 403;                        end
-      def not_found?;           status == 404;                        end
-      def method_not_allowed?;  status == 405;                        end
-      def precondition_failed?; status == 412;                        end
-      def unprocessable?;       status == 422;                        end
-
-      def redirect?;            [301, 302, 303, 307, 308].include? status; end
-
-      def include?(header)
-        has_header? header
-      end
-
-      # Add a header that may have multiple values.
-      #
-      # Example:
-      #   response.add_header 'Vary', 'Accept-Encoding'
-      #   response.add_header 'Vary', 'Cookie'
-      #
-      #   assert_equal 'Accept-Encoding,Cookie', response.get_header('Vary')
-      #
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
-      def add_header(key, v)
-        if v.nil?
-          get_header key
-        elsif has_header? key
-          set_header key, "#{get_header key},#{v}"
-        else
-          set_header key, v
-        end
-      end
-
-      # Get the content type of the response.
-      def content_type
-        get_header CONTENT_TYPE
-      end
-
-      # Set the content type of the response.
-      def content_type=(content_type)
-        set_header CONTENT_TYPE, content_type
-      end
-
-      def media_type
-        MediaType.type(content_type)
-      end
-
-      def media_type_params
-        MediaType.params(content_type)
-      end
-
-      def content_length
-        cl = get_header CONTENT_LENGTH
-        cl ? cl.to_i : cl
-      end
-
-      def location
-        get_header "Location"
-      end
-
-      def location=(location)
-        set_header "Location", location
-      end
-
-      def set_cookie(key, value)
-        cookie_header = get_header SET_COOKIE
-        set_header SET_COOKIE, ::Rack::Utils.add_cookie_to_header(cookie_header, key, value)
-      end
-
-      def delete_cookie(key, value = {})
-        set_header SET_COOKIE, ::Rack::Utils.add_remove_cookie_to_header(get_header(SET_COOKIE), key, value)
-      end
-
-      def set_cookie_header
-        get_header SET_COOKIE
-      end
-
-      def set_cookie_header=(v)
-        set_header SET_COOKIE, v
-      end
-
-      def cache_control
-        get_header CACHE_CONTROL
-      end
-
-      def cache_control=(v)
-        set_header CACHE_CONTROL, v
-      end
-
-      # Specifies that the content shouldn't be cached. Overrides `cache!` if already called.
-      def do_not_cache!
-        set_header CACHE_CONTROL, "no-cache, must-revalidate"
-        set_header EXPIRES, Time.now.httpdate
-      end
-
-      # Specify that the content should be cached.
-      # @param duration [Integer] The number of seconds until the cache expires.
-      # @option directive [String] The cache control directive, one of "public", "private", "no-cache" or "no-store".
-      def cache!(duration = 3600, directive: "public")
-        unless headers[CACHE_CONTROL] =~ /no-cache/
-          set_header CACHE_CONTROL, "#{directive}, max-age=#{duration}"
-          set_header EXPIRES, (Time.now + duration).httpdate
-        end
-      end
-
-      def etag
-        get_header ETAG
-      end
-
-      def etag=(v)
-        set_header ETAG, v
-      end
-
-    protected
-
-      def buffered_body!
-        return if @buffered
-
-        if @body.is_a?(Array)
-          # The user supplied body was an array:
-          @body = @body.compact
-          @body.each do |part|
-            @length += part.to_s.bytesize
-          end
-        else
-          # Turn the user supplied body into a buffered array:
-          body = @body
-          @body = Array.new
-
-          body.each do |part|
-            @writer.call(part.to_s)
-          end
-
-          body.close if body.respond_to?(:close)
-        end
-
-        @buffered = true
-      end
-
-      def append(chunk)
-        @body << chunk
-
-        unless chunked?
-          @length += chunk.bytesize
-          set_header(CONTENT_LENGTH, @length.to_s)
-        end
-
-        return chunk
-      end
-    end
-
-    include Helpers
-
-    class Raw
-      include Helpers
-
-      attr_reader :headers
-      attr_accessor :status
-
-      def initialize(status, headers)
-        @status = status
-        @headers = headers
-      end
-
-      def has_header?(key);   headers.key? key;   end
-      def get_header(key);    headers[key];       end
-      def set_header(key, v); headers[key] = v;   end
-      def delete_header(key); headers.delete key; end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/rewindable_input.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/rewindable_input.rb
deleted file mode 100644
index 91b9d1eb367e8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/rewindable_input.rb
+++ /dev/null
@@ -1,94 +0,0 @@
-# -*- encoding: binary -*-
-# frozen_string_literal: true
-
-require 'tempfile'
-
-module Rack
-  # Class which can make any IO object rewindable, including non-rewindable ones. It does
-  # this by buffering the data into a tempfile, which is rewindable.
-  #
-  # rack.input is required to be rewindable, so if your input stream IO is non-rewindable
-  # by nature (e.g. a pipe or a socket) then you can wrap it in an object of this class
-  # to easily make it rewindable.
-  #
-  # Don't forget to call #close when you're done. This frees up temporary resources that
-  # RewindableInput uses, though it does *not* close the original IO object.
-  class RewindableInput
-    def initialize(io)
-      @io = io
-      @rewindable_io = nil
-      @unlinked = false
-    end
-
-    def gets
-      make_rewindable unless @rewindable_io
-      @rewindable_io.gets
-    end
-
-    def read(*args)
-      make_rewindable unless @rewindable_io
-      @rewindable_io.read(*args)
-    end
-
-    def each(&block)
-      make_rewindable unless @rewindable_io
-      @rewindable_io.each(&block)
-    end
-
-    def rewind
-      make_rewindable unless @rewindable_io
-      @rewindable_io.rewind
-    end
-
-    # Closes this RewindableInput object without closing the originally
-    # wrapped IO object. Cleans up any temporary resources that this RewindableInput
-    # has created.
-    #
-    # This method may be called multiple times. It does nothing on subsequent calls.
-    def close
-      if @rewindable_io
-        if @unlinked
-          @rewindable_io.close
-        else
-          @rewindable_io.close!
-        end
-        @rewindable_io = nil
-      end
-    end
-
-    private
-
-    def make_rewindable
-      # Buffer all data into a tempfile. Since this tempfile is private to this
-      # RewindableInput object, we chmod it so that nobody else can read or write
-      # it. On POSIX filesystems we also unlink the file so that it doesn't
-      # even have a file entry on the filesystem anymore, though we can still
-      # access it because we have the file handle open.
-      @rewindable_io = Tempfile.new('RackRewindableInput')
-      @rewindable_io.chmod(0000)
-      @rewindable_io.set_encoding(Encoding::BINARY) if @rewindable_io.respond_to?(:set_encoding)
-      @rewindable_io.binmode
-      if filesystem_has_posix_semantics?
-        raise 'Unlink failed. IO closed.' if @rewindable_io.closed?
-        @unlinked = true
-      end
-
-      buffer = "".dup
-      while @io.read(1024 * 4, buffer)
-        entire_buffer_written_out = false
-        while !entire_buffer_written_out
-          written = @rewindable_io.write(buffer)
-          entire_buffer_written_out = written == buffer.bytesize
-          if !entire_buffer_written_out
-            buffer.slice!(0 .. written - 1)
-          end
-        end
-      end
-      @rewindable_io.rewind
-    end
-
-    def filesystem_has_posix_semantics?
-      RUBY_PLATFORM !~ /(mswin|mingw|cygwin|java)/
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/runtime.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/runtime.rb
deleted file mode 100644
index d9b2d8ed19982..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/runtime.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  # Sets an "X-Runtime" response header, indicating the response
-  # time of the request, in seconds
-  #
-  # You can put it right before the application to see the processing
-  # time, or before all the other middlewares to include time for them,
-  # too.
-  class Runtime
-    FORMAT_STRING = "%0.6f" # :nodoc:
-    HEADER_NAME = "X-Runtime" # :nodoc:
-
-    def initialize(app, name = nil)
-      @app = app
-      @header_name = HEADER_NAME
-      @header_name += "-#{name}" if name
-    end
-
-    def call(env)
-      start_time = Utils.clock_time
-      status, headers, body = @app.call(env)
-      headers = Utils::HeaderHash[headers]
-
-      request_time = Utils.clock_time - start_time
-
-      unless headers.key?(@header_name)
-        headers[@header_name] = FORMAT_STRING % request_time
-      end
-
-      [status, headers, body]
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/sendfile.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/sendfile.rb
deleted file mode 100644
index 3d5e786ff7685..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/sendfile.rb
+++ /dev/null
@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-
-  # = Sendfile
-  #
-  # The Sendfile middleware intercepts responses whose body is being
-  # served from a file and replaces it with a server specific X-Sendfile
-  # header. The web server is then responsible for writing the file contents
-  # to the client. This can dramatically reduce the amount of work required
-  # by the Ruby backend and takes advantage of the web server's optimized file
-  # delivery code.
-  #
-  # In order to take advantage of this middleware, the response body must
-  # respond to +to_path+ and the request must include an X-Sendfile-Type
-  # header. Rack::Files and other components implement +to_path+ so there's
-  # rarely anything you need to do in your application. The X-Sendfile-Type
-  # header is typically set in your web servers configuration. The following
-  # sections attempt to document
-  #
-  # === Nginx
-  #
-  # Nginx supports the X-Accel-Redirect header. This is similar to X-Sendfile
-  # but requires parts of the filesystem to be mapped into a private URL
-  # hierarchy.
-  #
-  # The following example shows the Nginx configuration required to create
-  # a private "/files/" area, enable X-Accel-Redirect, and pass the special
-  # X-Sendfile-Type and X-Accel-Mapping headers to the backend:
-  #
-  #   location ~ /files/(.*) {
-  #     internal;
-  #     alias /var/www/$1;
-  #   }
-  #
-  #   location / {
-  #     proxy_redirect     off;
-  #
-  #     proxy_set_header   Host                $host;
-  #     proxy_set_header   X-Real-IP           $remote_addr;
-  #     proxy_set_header   X-Forwarded-For     $proxy_add_x_forwarded_for;
-  #
-  #     proxy_set_header   X-Sendfile-Type     X-Accel-Redirect;
-  #     proxy_set_header   X-Accel-Mapping     /var/www/=/files/;
-  #
-  #     proxy_pass         http://127.0.0.1:8080/;
-  #   }
-  #
-  # Note that the X-Sendfile-Type header must be set exactly as shown above.
-  # The X-Accel-Mapping header should specify the location on the file system,
-  # followed by an equals sign (=), followed name of the private URL pattern
-  # that it maps to. The middleware performs a simple substitution on the
-  # resulting path.
-  #
-  # See Also: https://www.nginx.com/resources/wiki/start/topics/examples/xsendfile
-  #
-  # === lighttpd
-  #
-  # Lighttpd has supported some variation of the X-Sendfile header for some
-  # time, although only recent version support X-Sendfile in a reverse proxy
-  # configuration.
-  #
-  #   $HTTP["host"] == "example.com" {
-  #      proxy-core.protocol = "http"
-  #      proxy-core.balancer = "round-robin"
-  #      proxy-core.backends = (
-  #        "127.0.0.1:8000",
-  #        "127.0.0.1:8001",
-  #        ...
-  #      )
-  #
-  #      proxy-core.allow-x-sendfile = "enable"
-  #      proxy-core.rewrite-request = (
-  #        "X-Sendfile-Type" => (".*" => "X-Sendfile")
-  #      )
-  #    }
-  #
-  # See Also: http://redmine.lighttpd.net/wiki/lighttpd/Docs:ModProxyCore
-  #
-  # === Apache
-  #
-  # X-Sendfile is supported under Apache 2.x using a separate module:
-  #
-  # https://tn123.org/mod_xsendfile/
-  #
-  # Once the module is compiled and installed, you can enable it using
-  # XSendFile config directive:
-  #
-  #   RequestHeader Set X-Sendfile-Type X-Sendfile
-  #   ProxyPassReverse / http://localhost:8001/
-  #   XSendFile on
-  #
-  # === Mapping parameter
-  #
-  # The third parameter allows for an overriding extension of the
-  # X-Accel-Mapping header. Mappings should be provided in tuples of internal to
-  # external. The internal values may contain regular expression syntax, they
-  # will be matched with case indifference.
-
-  class Sendfile
-    def initialize(app, variation = nil, mappings = [])
-      @app = app
-      @variation = variation
-      @mappings = mappings.map do |internal, external|
-        [/^#{internal}/i, external]
-      end
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      if body.respond_to?(:to_path)
-        case type = variation(env)
-        when 'X-Accel-Redirect'
-          path = ::File.expand_path(body.to_path)
-          if url = map_accel_path(env, path)
-            headers[CONTENT_LENGTH] = '0'
-            # '?' must be percent-encoded because it is not query string but a part of path
-            headers[type] = ::Rack::Utils.escape_path(url).gsub('?', '%3F')
-            obody = body
-            body = Rack::BodyProxy.new([]) do
-              obody.close if obody.respond_to?(:close)
-            end
-          else
-            env[RACK_ERRORS].puts "X-Accel-Mapping header missing"
-          end
-        when 'X-Sendfile', 'X-Lighttpd-Send-File'
-          path = ::File.expand_path(body.to_path)
-          headers[CONTENT_LENGTH] = '0'
-          headers[type] = path
-          obody = body
-          body = Rack::BodyProxy.new([]) do
-            obody.close if obody.respond_to?(:close)
-          end
-        when '', nil
-        else
-          env[RACK_ERRORS].puts "Unknown x-sendfile variation: '#{type}'.\n"
-        end
-      end
-      [status, headers, body]
-    end
-
-    private
-    def variation(env)
-      @variation ||
-        env['sendfile.type'] ||
-        env['HTTP_X_SENDFILE_TYPE']
-    end
-
-    def map_accel_path(env, path)
-      if mapping = @mappings.find { |internal, _| internal =~ path }
-        path.sub(*mapping)
-      elsif mapping = env['HTTP_X_ACCEL_MAPPING']
-        mapping.split(',').map(&:strip).each do |m|
-          internal, external = m.split('=', 2).map(&:strip)
-          new_path = path.sub(/^#{internal}/i, external)
-          return new_path unless path == new_path
-        end
-        path
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/server.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/server.rb
deleted file mode 100644
index c1f2f5caa321f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/server.rb
+++ /dev/null
@@ -1,466 +0,0 @@
-# frozen_string_literal: true
-
-require 'optparse'
-require 'fileutils'
-
-module Rack
-
-  class Server
-    (require_relative 'core_ext/regexp'; using ::Rack::RegexpExtensions) if RUBY_VERSION < '2.4'
-
-    class Options
-      def parse!(args)
-        options = {}
-        opt_parser = OptionParser.new("", 24, '  ') do |opts|
-          opts.banner = "Usage: rackup [ruby options] [rack options] [rackup config]"
-
-          opts.separator ""
-          opts.separator "Ruby options:"
-
-          lineno = 1
-          opts.on("-e", "--eval LINE", "evaluate a LINE of code") { |line|
-            eval line, TOPLEVEL_BINDING, "-e", lineno
-            lineno += 1
-          }
-
-          opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") {
-            options[:debug] = true
-          }
-          opts.on("-w", "--warn", "turn warnings on for your script") {
-            options[:warn] = true
-          }
-          opts.on("-q", "--quiet", "turn off logging") {
-            options[:quiet] = true
-          }
-
-          opts.on("-I", "--include PATH",
-                  "specify $LOAD_PATH (may be used more than once)") { |path|
-            (options[:include] ||= []).concat(path.split(":"))
-          }
-
-          opts.on("-r", "--require LIBRARY",
-                  "require the library, before executing your script") { |library|
-            (options[:require] ||= []) << library
-          }
-
-          opts.separator ""
-          opts.separator "Rack options:"
-          opts.on("-b", "--builder BUILDER_LINE", "evaluate a BUILDER_LINE of code as a builder script") { |line|
-            options[:builder] = line
-          }
-
-          opts.on("-s", "--server SERVER", "serve using SERVER (thin/puma/webrick)") { |s|
-            options[:server] = s
-          }
-
-          opts.on("-o", "--host HOST", "listen on HOST (default: localhost)") { |host|
-            options[:Host] = host
-          }
-
-          opts.on("-p", "--port PORT", "use PORT (default: 9292)") { |port|
-            options[:Port] = port
-          }
-
-          opts.on("-O", "--option NAME[=VALUE]", "pass VALUE to the server as option NAME. If no VALUE, sets it to true. Run '#{$0} -s SERVER -h' to get a list of options for SERVER") { |name|
-            name, value = name.split('=', 2)
-            value = true if value.nil?
-            options[name.to_sym] = value
-          }
-
-          opts.on("-E", "--env ENVIRONMENT", "use ENVIRONMENT for defaults (default: development)") { |e|
-            options[:environment] = e
-          }
-
-          opts.on("-D", "--daemonize", "run daemonized in the background") { |d|
-            options[:daemonize] = d ? true : false
-          }
-
-          opts.on("-P", "--pid FILE", "file to store PID") { |f|
-            options[:pid] = ::File.expand_path(f)
-          }
-
-          opts.separator ""
-          opts.separator "Profiling options:"
-
-          opts.on("--heap HEAPFILE", "Build the application, then dump the heap to HEAPFILE") do |e|
-            options[:heapfile] = e
-          end
-
-          opts.on("--profile PROFILE", "Dump CPU or Memory profile to PROFILE (defaults to a tempfile)") do |e|
-            options[:profile_file] = e
-          end
-
-          opts.on("--profile-mode MODE", "Profile mode (cpu|wall|object)") do |e|
-            { cpu: true, wall: true, object: true }.fetch(e.to_sym) do
-              raise OptionParser::InvalidOption, "unknown profile mode: #{e}"
-            end
-            options[:profile_mode] = e.to_sym
-          end
-
-          opts.separator ""
-          opts.separator "Common options:"
-
-          opts.on_tail("-h", "-?", "--help", "Show this message") do
-            puts opts
-            puts handler_opts(options)
-
-            exit
-          end
-
-          opts.on_tail("--version", "Show version") do
-            puts "Rack #{Rack.version} (Release: #{Rack.release})"
-            exit
-          end
-        end
-
-        begin
-          opt_parser.parse! args
-        rescue OptionParser::InvalidOption => e
-          warn e.message
-          abort opt_parser.to_s
-        end
-
-        options[:config] = args.last if args.last && !args.last.empty?
-        options
-      end
-
-      def handler_opts(options)
-        begin
-          info = []
-          server = Rack::Handler.get(options[:server]) || Rack::Handler.default
-          if server && server.respond_to?(:valid_options)
-            info << ""
-            info << "Server-specific options for #{server.name}:"
-
-            has_options = false
-            server.valid_options.each do |name, description|
-              next if /^(Host|Port)[^a-zA-Z]/.match?(name.to_s) # ignore handler's host and port options, we do our own.
-              info << "  -O %-21s %s" % [name, description]
-              has_options = true
-            end
-            return "" if !has_options
-          end
-          info.join("\n")
-        rescue NameError, LoadError
-          return "Warning: Could not find handler specified (#{options[:server] || 'default'}) to determine handler-specific options"
-        end
-      end
-    end
-
-    # Start a new rack server (like running rackup). This will parse ARGV and
-    # provide standard ARGV rackup options, defaulting to load 'config.ru'.
-    #
-    # Providing an options hash will prevent ARGV parsing and will not include
-    # any default options.
-    #
-    # This method can be used to very easily launch a CGI application, for
-    # example:
-    #
-    #  Rack::Server.start(
-    #    :app => lambda do |e|
-    #      [200, {'Content-Type' => 'text/html'}, ['hello world']]
-    #    end,
-    #    :server => 'cgi'
-    #  )
-    #
-    # Further options available here are documented on Rack::Server#initialize
-    def self.start(options = nil)
-      new(options).start
-    end
-
-    attr_writer :options
-
-    # Options may include:
-    # * :app
-    #     a rack application to run (overrides :config and :builder)
-    # * :builder
-    #     a string to evaluate a Rack::Builder from
-    # * :config
-    #     a rackup configuration file path to load (.ru)
-    # * :environment
-    #     this selects the middleware that will be wrapped around
-    #     your application. Default options available are:
-    #       - development: CommonLogger, ShowExceptions, and Lint
-    #       - deployment: CommonLogger
-    #       - none: no extra middleware
-    #     note: when the server is a cgi server, CommonLogger is not included.
-    # * :server
-    #     choose a specific Rack::Handler, e.g. cgi, fcgi, webrick
-    # * :daemonize
-    #     if true, the server will daemonize itself (fork, detach, etc)
-    # * :pid
-    #     path to write a pid file after daemonize
-    # * :Host
-    #     the host address to bind to (used by supporting Rack::Handler)
-    # * :Port
-    #     the port to bind to (used by supporting Rack::Handler)
-    # * :AccessLog
-    #     webrick access log options (or supporting Rack::Handler)
-    # * :debug
-    #     turn on debug output ($DEBUG = true)
-    # * :warn
-    #     turn on warnings ($-w = true)
-    # * :include
-    #     add given paths to $LOAD_PATH
-    # * :require
-    #     require the given libraries
-    #
-    # Additional options for profiling app initialization include:
-    # * :heapfile
-    #     location for ObjectSpace.dump_all to write the output to
-    # * :profile_file
-    #     location for CPU/Memory (StackProf) profile output (defaults to a tempfile)
-    # * :profile_mode
-    #     StackProf profile mode (cpu|wall|object)
-    def initialize(options = nil)
-      @ignore_options = []
-
-      if options
-        @use_default_options = false
-        @options = options
-        @app = options[:app] if options[:app]
-      else
-        argv = defined?(SPEC_ARGV) ? SPEC_ARGV : ARGV
-        @use_default_options = true
-        @options = parse_options(argv)
-      end
-    end
-
-    def options
-      merged_options = @use_default_options ? default_options.merge(@options) : @options
-      merged_options.reject { |k, v| @ignore_options.include?(k) }
-    end
-
-    def default_options
-      environment  = ENV['RACK_ENV'] || 'development'
-      default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-      {
-        environment: environment,
-        pid: nil,
-        Port: 9292,
-        Host: default_host,
-        AccessLog: [],
-        config: "config.ru"
-      }
-    end
-
-    def app
-      @app ||= options[:builder] ? build_app_from_string : build_app_and_options_from_config
-    end
-
-    class << self
-      def logging_middleware
-        lambda { |server|
-          /CGI/.match?(server.server.name) || server.options[:quiet] ? nil : [Rack::CommonLogger, $stderr]
-        }
-      end
-
-      def default_middleware_by_environment
-        m = Hash.new {|h, k| h[k] = []}
-        m["deployment"] = [
-          [Rack::ContentLength],
-          logging_middleware,
-          [Rack::TempfileReaper]
-        ]
-        m["development"] = [
-          [Rack::ContentLength],
-          logging_middleware,
-          [Rack::ShowExceptions],
-          [Rack::Lint],
-          [Rack::TempfileReaper]
-        ]
-
-        m
-      end
-
-      def middleware
-        default_middleware_by_environment
-      end
-    end
-
-    def middleware
-      self.class.middleware
-    end
-
-    def start(&block)
-      if options[:warn]
-        $-w = true
-      end
-
-      if includes = options[:include]
-        $LOAD_PATH.unshift(*includes)
-      end
-
-      Array(options[:require]).each do |library|
-        require library
-      end
-
-      if options[:debug]
-        $DEBUG = true
-        require 'pp'
-        p options[:server]
-        pp wrapped_app
-        pp app
-      end
-
-      check_pid! if options[:pid]
-
-      # Touch the wrapped app, so that the config.ru is loaded before
-      # daemonization (i.e. before chdir, etc).
-      handle_profiling(options[:heapfile], options[:profile_mode], options[:profile_file]) do
-        wrapped_app
-      end
-
-      daemonize_app if options[:daemonize]
-
-      write_pid if options[:pid]
-
-      trap(:INT) do
-        if server.respond_to?(:shutdown)
-          server.shutdown
-        else
-          exit
-        end
-      end
-
-      server.run(wrapped_app, **options, &block)
-    end
-
-    def server
-      @_server ||= Rack::Handler.get(options[:server])
-
-      unless @_server
-        @_server = Rack::Handler.default
-
-        # We already speak FastCGI
-        @ignore_options = [:File, :Port] if @_server.to_s == 'Rack::Handler::FastCGI'
-      end
-
-      @_server
-    end
-
-    private
-      def build_app_and_options_from_config
-        if !::File.exist? options[:config]
-          abort "configuration #{options[:config]} not found"
-        end
-
-        app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
-        @options.merge!(options) { |key, old, new| old }
-        app
-      end
-
-      def handle_profiling(heapfile, profile_mode, filename)
-        if heapfile
-          require "objspace"
-          ObjectSpace.trace_object_allocations_start
-          yield
-          GC.start
-          ::File.open(heapfile, "w") { |f| ObjectSpace.dump_all(output: f) }
-          exit
-        end
-
-        if profile_mode
-          require "stackprof"
-          require "tempfile"
-
-          make_profile_name(filename) do |filename|
-            ::File.open(filename, "w") do |f|
-              StackProf.run(mode: profile_mode, out: f) do
-                yield
-              end
-              puts "Profile written to: #{filename}"
-            end
-          end
-          exit
-        end
-
-        yield
-      end
-
-      def make_profile_name(filename)
-        if filename
-          yield filename
-        else
-          ::Dir::Tmpname.create("profile.dump") do |tmpname, _, _|
-            yield tmpname
-          end
-        end
-      end
-
-      def build_app_from_string
-        Rack::Builder.new_from_string(self.options[:builder])
-      end
-
-      def parse_options(args)
-        # Don't evaluate CGI ISINDEX parameters.
-        # http://www.meb.uni-bonn.de/docs/cgi/cl.html
-        args.clear if ENV.include?(REQUEST_METHOD)
-
-        @options = opt_parser.parse!(args)
-        @options[:config] = ::File.expand_path(options[:config])
-        ENV["RACK_ENV"] = options[:environment]
-        @options
-      end
-
-      def opt_parser
-        Options.new
-      end
-
-      def build_app(app)
-        middleware[options[:environment]].reverse_each do |middleware|
-          middleware = middleware.call(self) if middleware.respond_to?(:call)
-          next unless middleware
-          klass, *args = middleware
-          app = klass.new(app, *args)
-        end
-        app
-      end
-
-      def wrapped_app
-        @wrapped_app ||= build_app app
-      end
-
-      def daemonize_app
-        # Cannot be covered as it forks
-        # :nocov:
-        Process.daemon
-        # :nocov:
-      end
-
-      def write_pid
-        ::File.open(options[:pid], ::File::CREAT | ::File::EXCL | ::File::WRONLY ){ |f| f.write("#{Process.pid}") }
-        at_exit { ::FileUtils.rm_f(options[:pid]) }
-      rescue Errno::EEXIST
-        check_pid!
-        retry
-      end
-
-      def check_pid!
-        case pidfile_process_status
-        when :running, :not_owned
-          $stderr.puts "A server is already running. Check #{options[:pid]}."
-          exit(1)
-        when :dead
-          ::File.delete(options[:pid])
-        end
-      end
-
-      def pidfile_process_status
-        return :exited unless ::File.exist?(options[:pid])
-
-        pid = ::File.read(options[:pid]).to_i
-        return :dead if pid == 0
-
-        Process.kill(0, pid)
-        :running
-      rescue Errno::ESRCH
-        :dead
-      rescue Errno::EPERM
-        :not_owned
-      end
-
-  end
-
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/session/abstract/id.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/session/abstract/id.rb
deleted file mode 100644
index 638bd3b3b08ee..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/session/abstract/id.rb
+++ /dev/null
@@ -1,523 +0,0 @@
-# frozen_string_literal: true
-
-# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
-# bugrep: Andreas Zehnder
-
-require_relative '../../../rack'
-require 'time'
-require 'securerandom'
-require 'digest/sha2'
-
-module Rack
-
-  module Session
-
-    class SessionId
-      ID_VERSION = 2
-
-      attr_reader :public_id
-
-      def initialize(public_id)
-        @public_id = public_id
-      end
-
-      def private_id
-        "#{ID_VERSION}::#{hash_sid(public_id)}"
-      end
-
-      alias :cookie_value :public_id
-      alias :to_s :public_id
-
-      def empty?; false; end
-      def inspect; public_id.inspect; end
-
-      private
-
-      def hash_sid(sid)
-        Digest::SHA256.hexdigest(sid)
-      end
-    end
-
-    module Abstract
-      # SessionHash is responsible to lazily load the session from store.
-
-      class SessionHash
-        include Enumerable
-        attr_writer :id
-
-        Unspecified = Object.new
-
-        def self.find(req)
-          req.get_header RACK_SESSION
-        end
-
-        def self.set(req, session)
-          req.set_header RACK_SESSION, session
-        end
-
-        def self.set_options(req, options)
-          req.set_header RACK_SESSION_OPTIONS, options.dup
-        end
-
-        def initialize(store, req)
-          @store = store
-          @req = req
-          @loaded = false
-        end
-
-        def id
-          return @id if @loaded or instance_variable_defined?(:@id)
-          @id = @store.send(:extract_session_id, @req)
-        end
-
-        def options
-          @req.session_options
-        end
-
-        def each(&block)
-          load_for_read!
-          @data.each(&block)
-        end
-
-        def [](key)
-          load_for_read!
-          @data[key.to_s]
-        end
-
-        def dig(key, *keys)
-          load_for_read!
-          @data.dig(key.to_s, *keys)
-        end
-
-        def fetch(key, default = Unspecified, &block)
-          load_for_read!
-          if default == Unspecified
-            @data.fetch(key.to_s, &block)
-          else
-            @data.fetch(key.to_s, default, &block)
-          end
-        end
-
-        def has_key?(key)
-          load_for_read!
-          @data.has_key?(key.to_s)
-        end
-        alias :key? :has_key?
-        alias :include? :has_key?
-
-        def []=(key, value)
-          load_for_write!
-          @data[key.to_s] = value
-        end
-        alias :store :[]=
-
-        def clear
-          load_for_write!
-          @data.clear
-        end
-
-        def destroy
-          clear
-          @id = @store.send(:delete_session, @req, id, options)
-        end
-
-        def to_hash
-          load_for_read!
-          @data.dup
-        end
-
-        def update(hash)
-          load_for_write!
-          @data.update(stringify_keys(hash))
-        end
-        alias :merge! :update
-
-        def replace(hash)
-          load_for_write!
-          @data.replace(stringify_keys(hash))
-        end
-
-        def delete(key)
-          load_for_write!
-          @data.delete(key.to_s)
-        end
-
-        def inspect
-          if loaded?
-            @data.inspect
-          else
-            "#<#{self.class}:0x#{self.object_id.to_s(16)} not yet loaded>"
-          end
-        end
-
-        def exists?
-          return @exists if instance_variable_defined?(:@exists)
-          @data = {}
-          @exists = @store.send(:session_exists?, @req)
-        end
-
-        def loaded?
-          @loaded
-        end
-
-        def empty?
-          load_for_read!
-          @data.empty?
-        end
-
-        def keys
-          load_for_read!
-          @data.keys
-        end
-
-        def values
-          load_for_read!
-          @data.values
-        end
-
-      private
-
-        def load_for_read!
-          load! if !loaded? && exists?
-        end
-
-        def load_for_write!
-          load! unless loaded?
-        end
-
-        def load!
-          @id, session = @store.send(:load_session, @req)
-          @data = stringify_keys(session)
-          @loaded = true
-        end
-
-        def stringify_keys(other)
-          # Use transform_keys after dropping Ruby 2.4 support
-          hash = {}
-          other.to_hash.each do |key, value|
-            hash[key.to_s] = value
-          end
-          hash
-        end
-      end
-
-      # ID sets up a basic framework for implementing an id based sessioning
-      # service. Cookies sent to the client for maintaining sessions will only
-      # contain an id reference. Only #find_session, #write_session and
-      # #delete_session are required to be overwritten.
-      #
-      # All parameters are optional.
-      # * :key determines the name of the cookie, by default it is
-      #   'rack.session'
-      # * :path, :domain, :expire_after, :secure, and :httponly set the related
-      #   cookie options as by Rack::Response#set_cookie
-      # * :skip will not a set a cookie in the response nor update the session state
-      # * :defer will not set a cookie in the response but still update the session
-      #   state if it is used with a backend
-      # * :renew (implementation dependent) will prompt the generation of a new
-      #   session id, and migration of data to be referenced at the new id. If
-      #   :defer is set, it will be overridden and the cookie will be set.
-      # * :sidbits sets the number of bits in length that a generated session
-      #   id will be.
-      #
-      # These options can be set on a per request basis, at the location of
-      # <tt>env['rack.session.options']</tt>. Additionally the id of the
-      # session can be found within the options hash at the key :id. It is
-      # highly not recommended to change its value.
-      #
-      # Is Rack::Utils::Context compatible.
-      #
-      # Not included by default; you must require 'rack/session/abstract/id'
-      # to use.
-
-      class Persisted
-        DEFAULT_OPTIONS = {
-          key: RACK_SESSION,
-          path: '/',
-          domain: nil,
-          expire_after: nil,
-          secure: false,
-          httponly: true,
-          defer: false,
-          renew: false,
-          sidbits: 128,
-          cookie_only: true,
-          secure_random: ::SecureRandom
-        }.freeze
-
-        attr_reader :key, :default_options, :sid_secure
-
-        def initialize(app, options = {})
-          @app = app
-          @default_options = self.class::DEFAULT_OPTIONS.merge(options)
-          @key = @default_options.delete(:key)
-          @cookie_only = @default_options.delete(:cookie_only)
-          @same_site = @default_options.delete(:same_site)
-          initialize_sid
-        end
-
-        def call(env)
-          context(env)
-        end
-
-        def context(env, app = @app)
-          req = make_request env
-          prepare_session(req)
-          status, headers, body = app.call(req.env)
-          res = Rack::Response::Raw.new status, headers
-          commit_session(req, res)
-          [status, headers, body]
-        end
-
-        private
-
-        def make_request(env)
-          Rack::Request.new env
-        end
-
-        def initialize_sid
-          @sidbits = @default_options[:sidbits]
-          @sid_secure = @default_options[:secure_random]
-          @sid_length = @sidbits / 4
-        end
-
-        # Generate a new session id using Ruby #rand.  The size of the
-        # session id is controlled by the :sidbits option.
-        # Monkey patch this to use custom methods for session id generation.
-
-        def generate_sid(secure = @sid_secure)
-          if secure
-            secure.hex(@sid_length)
-          else
-            "%0#{@sid_length}x" % Kernel.rand(2**@sidbits - 1)
-          end
-        rescue NotImplementedError
-          generate_sid(false)
-        end
-
-        # Sets the lazy session at 'rack.session' and places options and session
-        # metadata into 'rack.session.options'.
-
-        def prepare_session(req)
-          session_was               = req.get_header RACK_SESSION
-          session                   = session_class.new(self, req)
-          req.set_header RACK_SESSION, session
-          req.set_header RACK_SESSION_OPTIONS, @default_options.dup
-          session.merge! session_was if session_was
-        end
-
-        # Extracts the session id from provided cookies and passes it and the
-        # environment to #find_session.
-
-        def load_session(req)
-          sid = current_session_id(req)
-          sid, session = find_session(req, sid)
-          [sid, session || {}]
-        end
-
-        # Extract session id from request object.
-
-        def extract_session_id(request)
-          sid = request.cookies[@key]
-          sid ||= request.params[@key] unless @cookie_only
-          sid
-        end
-
-        # Returns the current session id from the SessionHash.
-
-        def current_session_id(req)
-          req.get_header(RACK_SESSION).id
-        end
-
-        # Check if the session exists or not.
-
-        def session_exists?(req)
-          value = current_session_id(req)
-          value && !value.empty?
-        end
-
-        # Session should be committed if it was loaded, any of specific options like :renew, :drop
-        # or :expire_after was given and the security permissions match. Skips if skip is given.
-
-        def commit_session?(req, session, options)
-          if options[:skip]
-            false
-          else
-            has_session = loaded_session?(session) || forced_session_update?(session, options)
-            has_session && security_matches?(req, options)
-          end
-        end
-
-        def loaded_session?(session)
-          !session.is_a?(session_class) || session.loaded?
-        end
-
-        def forced_session_update?(session, options)
-          force_options?(options) && session && !session.empty?
-        end
-
-        def force_options?(options)
-          options.values_at(:max_age, :renew, :drop, :defer, :expire_after).any?
-        end
-
-        def security_matches?(request, options)
-          return true unless options[:secure]
-          request.ssl?
-        end
-
-        # Acquires the session from the environment and the session id from
-        # the session options and passes them to #write_session. If successful
-        # and the :defer option is not true, a cookie will be added to the
-        # response with the session's id.
-
-        def commit_session(req, res)
-          session = req.get_header RACK_SESSION
-          options = session.options
-
-          if options[:drop] || options[:renew]
-            session_id = delete_session(req, session.id || generate_sid, options)
-            return unless session_id
-          end
-
-          return unless commit_session?(req, session, options)
-
-          session.send(:load!) unless loaded_session?(session)
-          session_id ||= session.id
-          session_data = session.to_hash.delete_if { |k, v| v.nil? }
-
-          if not data = write_session(req, session_id, session_data, options)
-            req.get_header(RACK_ERRORS).puts("Warning! #{self.class.name} failed to save session. Content dropped.")
-          elsif options[:defer] and not options[:renew]
-            req.get_header(RACK_ERRORS).puts("Deferring cookie for #{session_id}") if $VERBOSE
-          else
-            cookie = Hash.new
-            cookie[:value] = cookie_value(data)
-            cookie[:expires] = Time.now + options[:expire_after] if options[:expire_after]
-            cookie[:expires] = Time.now + options[:max_age] if options[:max_age]
-
-            if @same_site.respond_to? :call
-              cookie[:same_site] = @same_site.call(req, res)
-            else
-              cookie[:same_site] = @same_site
-            end
-            set_cookie(req, res, cookie.merge!(options))
-          end
-        end
-        public :commit_session
-
-        def cookie_value(data)
-          data
-        end
-
-        # Sets the cookie back to the client with session id. We skip the cookie
-        # setting if the value didn't change (sid is the same) or expires was given.
-
-        def set_cookie(request, res, cookie)
-          if request.cookies[@key] != cookie[:value] || cookie[:expires]
-            res.set_cookie_header =
-              Utils.add_cookie_to_header(res.set_cookie_header, @key, cookie)
-          end
-        end
-
-        # Allow subclasses to prepare_session for different Session classes
-
-        def session_class
-          SessionHash
-        end
-
-        # All thread safety and session retrieval procedures should occur here.
-        # Should return [session_id, session].
-        # If nil is provided as the session id, generation of a new valid id
-        # should occur within.
-
-        def find_session(env, sid)
-          raise '#find_session not implemented.'
-        end
-
-        # All thread safety and session storage procedures should occur here.
-        # Must return the session id if the session was saved successfully, or
-        # false if the session could not be saved.
-
-        def write_session(req, sid, session, options)
-          raise '#write_session not implemented.'
-        end
-
-        # All thread safety and session destroy procedures should occur here.
-        # Should return a new session id or nil if options[:drop]
-
-        def delete_session(req, sid, options)
-          raise '#delete_session not implemented'
-        end
-      end
-
-      class PersistedSecure < Persisted
-        class SecureSessionHash < SessionHash
-          def [](key)
-            if key == "session_id"
-              load_for_read!
-              id.public_id if id
-            else
-              super
-            end
-          end
-        end
-
-        def generate_sid(*)
-          public_id = super
-
-          SessionId.new(public_id)
-        end
-
-        def extract_session_id(*)
-          public_id = super
-          public_id && SessionId.new(public_id)
-        end
-
-        private
-
-        def session_class
-          SecureSessionHash
-        end
-
-        def cookie_value(data)
-          data.cookie_value
-        end
-      end
-
-      class ID < Persisted
-        def self.inherited(klass)
-          k = klass.ancestors.find { |kl| kl.respond_to?(:superclass) && kl.superclass == ID }
-          unless k.instance_variable_defined?(:"@_rack_warned")
-            warn "#{klass} is inheriting from #{ID}.  Inheriting from #{ID} is deprecated, please inherit from #{Persisted} instead" if $VERBOSE
-            k.instance_variable_set(:"@_rack_warned", true)
-          end
-          super
-        end
-
-        # All thread safety and session retrieval procedures should occur here.
-        # Should return [session_id, session].
-        # If nil is provided as the session id, generation of a new valid id
-        # should occur within.
-
-        def find_session(req, sid)
-          get_session req.env, sid
-        end
-
-        # All thread safety and session storage procedures should occur here.
-        # Must return the session id if the session was saved successfully, or
-        # false if the session could not be saved.
-
-        def write_session(req, sid, session, options)
-          set_session req.env, sid, session, options
-        end
-
-        # All thread safety and session destroy procedures should occur here.
-        # Should return a new session id or nil if options[:drop]
-
-        def delete_session(req, sid, options)
-          destroy_session req.env, sid, options
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/session/cookie.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/session/cookie.rb
deleted file mode 100644
index bb541396f7b0e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/session/cookie.rb
+++ /dev/null
@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-require 'openssl'
-require 'zlib'
-require_relative 'abstract/id'
-require 'json'
-require 'base64'
-
-module Rack
-
-  module Session
-
-    # Rack::Session::Cookie provides simple cookie based session management.
-    # By default, the session is a Ruby Hash stored as base64 encoded marshalled
-    # data set to :key (default: rack.session).  The object that encodes the
-    # session data is configurable and must respond to +encode+ and +decode+.
-    # Both methods must take a string and return a string.
-    #
-    # When the secret key is set, cookie data is checked for data integrity.
-    # The old secret key is also accepted and allows graceful secret rotation.
-    #
-    # Example:
-    #
-    #     use Rack::Session::Cookie, :key => 'rack.session',
-    #                                :domain => 'foo.com',
-    #                                :path => '/',
-    #                                :expire_after => 2592000,
-    #                                :secret => 'change_me',
-    #                                :old_secret => 'also_change_me'
-    #
-    #     All parameters are optional.
-    #
-    # Example of a cookie with no encoding:
-    #
-    #   Rack::Session::Cookie.new(application, {
-    #     :coder => Rack::Session::Cookie::Identity.new
-    #   })
-    #
-    # Example of a cookie with custom encoding:
-    #
-    #   Rack::Session::Cookie.new(application, {
-    #     :coder => Class.new {
-    #       def encode(str); str.reverse; end
-    #       def decode(str); str.reverse; end
-    #     }.new
-    #   })
-    #
-
-    class Cookie < Abstract::PersistedSecure
-      # Encode session cookies as Base64
-      class Base64
-        def encode(str)
-          ::Base64.strict_encode64(str)
-        end
-
-        def decode(str)
-          ::Base64.decode64(str)
-        end
-
-        # Encode session cookies as Marshaled Base64 data
-        class Marshal < Base64
-          def encode(str)
-            super(::Marshal.dump(str))
-          end
-
-          def decode(str)
-            return unless str
-            ::Marshal.load(super(str)) rescue nil
-          end
-        end
-
-        # N.B. Unlike other encoding methods, the contained objects must be a
-        # valid JSON composite type, either a Hash or an Array.
-        class JSON < Base64
-          def encode(obj)
-            super(::JSON.dump(obj))
-          end
-
-          def decode(str)
-            return unless str
-            ::JSON.parse(super(str)) rescue nil
-          end
-        end
-
-        class ZipJSON < Base64
-          def encode(obj)
-            super(Zlib::Deflate.deflate(::JSON.dump(obj)))
-          end
-
-          def decode(str)
-            return unless str
-            ::JSON.parse(Zlib::Inflate.inflate(super(str)))
-          rescue
-            nil
-          end
-        end
-      end
-
-      # Use no encoding for session cookies
-      class Identity
-        def encode(str); str; end
-        def decode(str); str; end
-      end
-
-      attr_reader :coder
-
-      def initialize(app, options = {})
-        @secrets = options.values_at(:secret, :old_secret).compact
-        @hmac = options.fetch(:hmac, OpenSSL::Digest::SHA1)
-
-        warn <<-MSG unless secure?(options)
-        SECURITY WARNING: No secret option provided to Rack::Session::Cookie.
-        This poses a security threat. It is strongly recommended that you
-        provide a secret to prevent exploits that may be possible from crafted
-        cookies. This will not be supported in future versions of Rack, and
-        future versions will even invalidate your existing user cookies.
-
-        Called from: #{caller[0]}.
-        MSG
-        @coder = options[:coder] ||= Base64::Marshal.new
-        super(app, options.merge!(cookie_only: true))
-      end
-
-      private
-
-      def find_session(req, sid)
-        data = unpacked_cookie_data(req)
-        data = persistent_session_id!(data)
-        [data["session_id"], data]
-      end
-
-      def extract_session_id(request)
-        unpacked_cookie_data(request)["session_id"]
-      end
-
-      def unpacked_cookie_data(request)
-        request.fetch_header(RACK_SESSION_UNPACKED_COOKIE_DATA) do |k|
-          session_data = request.cookies[@key]
-
-          if @secrets.size > 0 && session_data
-            session_data, _, digest = session_data.rpartition('--')
-            session_data = nil unless digest_match?(session_data, digest)
-          end
-
-          request.set_header(k, coder.decode(session_data) || {})
-        end
-      end
-
-      def persistent_session_id!(data, sid = nil)
-        data ||= {}
-        data["session_id"] ||= sid || generate_sid
-        data
-      end
-
-      class SessionId < DelegateClass(Session::SessionId)
-        attr_reader :cookie_value
-
-        def initialize(session_id, cookie_value)
-          super(session_id)
-          @cookie_value = cookie_value
-        end
-      end
-
-      def write_session(req, session_id, session, options)
-        session = session.merge("session_id" => session_id)
-        session_data = coder.encode(session)
-
-        if @secrets.first
-          session_data << "--#{generate_hmac(session_data, @secrets.first)}"
-        end
-
-        if session_data.size > (4096 - @key.size)
-          req.get_header(RACK_ERRORS).puts("Warning! Rack::Session::Cookie data size exceeds 4K.")
-          nil
-        else
-          SessionId.new(session_id, session_data)
-        end
-      end
-
-      def delete_session(req, session_id, options)
-        # Nothing to do here, data is in the client
-        generate_sid unless options[:drop]
-      end
-
-      def digest_match?(data, digest)
-        return unless data && digest
-        @secrets.any? do |secret|
-          Rack::Utils.secure_compare(digest, generate_hmac(data, secret))
-        end
-      end
-
-      def generate_hmac(data, secret)
-        OpenSSL::HMAC.hexdigest(@hmac.new, secret, data)
-      end
-
-      def secure?(options)
-        @secrets.size >= 1 ||
-        (options[:coder] && options[:let_coder_handle_secure_encoding])
-      end
-
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/session/memcache.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/session/memcache.rb
deleted file mode 100644
index 6a601174075b2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/session/memcache.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack/session/dalli'
-
-module Rack
-  module Session
-    warn "Rack::Session::Memcache is deprecated, please use Rack::Session::Dalli from 'dalli' gem instead."
-    Memcache = Dalli
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/session/pool.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/session/pool.rb
deleted file mode 100644
index 4885605f5d294..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/session/pool.rb
+++ /dev/null
@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
-# THANKS:
-#   apeiros, for session id generation, expiry setup, and threadiness
-#   sergio, threadiness and bugreps
-
-require_relative 'abstract/id'
-require 'thread'
-
-module Rack
-  module Session
-    # Rack::Session::Pool provides simple cookie based session management.
-    # Session data is stored in a hash held by @pool.
-    # In the context of a multithreaded environment, sessions being
-    # committed to the pool is done in a merging manner.
-    #
-    # The :drop option is available in rack.session.options if you wish to
-    # explicitly remove the session from the session cache.
-    #
-    # Example:
-    #   myapp = MyRackApp.new
-    #   sessioned = Rack::Session::Pool.new(myapp,
-    #     :domain => 'foo.com',
-    #     :expire_after => 2592000
-    #   )
-    #   Rack::Handler::WEBrick.run sessioned
-
-    class Pool < Abstract::PersistedSecure
-      attr_reader :mutex, :pool
-      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge drop: false
-
-      def initialize(app, options = {})
-        super
-        @pool = Hash.new
-        @mutex = Mutex.new
-      end
-
-      def generate_sid
-        loop do
-          sid = super
-          break sid unless @pool.key? sid.private_id
-        end
-      end
-
-      def find_session(req, sid)
-        with_lock(req) do
-          unless sid and session = get_session_with_fallback(sid)
-            sid, session = generate_sid, {}
-            @pool.store sid.private_id, session
-          end
-          [sid, session]
-        end
-      end
-
-      def write_session(req, session_id, new_session, options)
-        with_lock(req) do
-          @pool.store session_id.private_id, new_session
-          session_id
-        end
-      end
-
-      def delete_session(req, session_id, options)
-        with_lock(req) do
-          @pool.delete(session_id.public_id)
-          @pool.delete(session_id.private_id)
-          generate_sid unless options[:drop]
-        end
-      end
-
-      def with_lock(req)
-        @mutex.lock if req.multithread?
-        yield
-      ensure
-        @mutex.unlock if @mutex.locked?
-      end
-
-      private
-
-      def get_session_with_fallback(sid)
-        @pool[sid.private_id] || @pool[sid.public_id]
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/show_exceptions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/show_exceptions.rb
deleted file mode 100644
index 07e60388069f7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/show_exceptions.rb
+++ /dev/null
@@ -1,390 +0,0 @@
-# frozen_string_literal: true
-
-require 'ostruct'
-require 'erb'
-
-module Rack
-  # Rack::ShowExceptions catches all exceptions raised from the app it
-  # wraps.  It shows a useful backtrace with the sourcefile and
-  # clickable context, the whole Rack environment and the request
-  # data.
-  #
-  # Be careful when you use this on public-facing sites as it could
-  # reveal information helpful to attackers.
-
-  class ShowExceptions
-    CONTEXT = 7
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      @app.call(env)
-    rescue StandardError, LoadError, SyntaxError => e
-      exception_string = dump_exception(e)
-
-      env[RACK_ERRORS].puts(exception_string)
-      env[RACK_ERRORS].flush
-
-      if accepts_html?(env)
-        content_type = "text/html"
-        body = pretty(env, e)
-      else
-        content_type = "text/plain"
-        body = exception_string
-      end
-
-      [
-        500,
-        {
-          CONTENT_TYPE => content_type,
-          CONTENT_LENGTH => body.bytesize.to_s,
-        },
-        [body],
-      ]
-    end
-
-    def prefers_plaintext?(env)
-      !accepts_html?(env)
-    end
-
-    def accepts_html?(env)
-      Rack::Utils.best_q_match(env["HTTP_ACCEPT"], %w[text/html])
-    end
-    private :accepts_html?
-
-    def dump_exception(exception)
-      string = "#{exception.class}: #{exception.message}\n".dup
-      string << exception.backtrace.map { |l| "\t#{l}" }.join("\n")
-      string
-    end
-
-    def pretty(env, exception)
-      req = Rack::Request.new(env)
-
-      # This double assignment is to prevent an "unused variable" warning.
-      # Yes, it is dumb, but I don't like Ruby yelling at me.
-      path = path = (req.script_name + req.path_info).squeeze("/")
-
-      # This double assignment is to prevent an "unused variable" warning.
-      # Yes, it is dumb, but I don't like Ruby yelling at me.
-      frames = frames = exception.backtrace.map { |line|
-        frame = OpenStruct.new
-        if line =~ /(.*?):(\d+)(:in `(.*)')?/
-          frame.filename = $1
-          frame.lineno = $2.to_i
-          frame.function = $4
-
-          begin
-            lineno = frame.lineno - 1
-            lines = ::File.readlines(frame.filename)
-            frame.pre_context_lineno = [lineno - CONTEXT, 0].max
-            frame.pre_context = lines[frame.pre_context_lineno...lineno]
-            frame.context_line = lines[lineno].chomp
-            frame.post_context_lineno = [lineno + CONTEXT, lines.size].min
-            frame.post_context = lines[lineno + 1..frame.post_context_lineno]
-          rescue
-          end
-
-          frame
-        else
-          nil
-        end
-      }.compact
-
-      template.result(binding)
-    end
-
-    def template
-      TEMPLATE
-    end
-
-    def h(obj)                  # :nodoc:
-      case obj
-      when String
-        Utils.escape_html(obj)
-      else
-        Utils.escape_html(obj.inspect)
-      end
-    end
-
-    # :stopdoc:
-
-    # adapted from Django <www.djangoproject.com>
-    # Copyright (c) Django Software Foundation and individual contributors.
-    # Used under the modified BSD license:
-    # http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5
-    TEMPLATE = ERB.new(<<-'HTML'.gsub(/^      /, ''))
-      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-      <html lang="en">
-      <head>
-        <meta http-equiv="content-type" content="text/html; charset=utf-8" />
-        <meta name="robots" content="NONE,NOARCHIVE" />
-        <title><%=h exception.class %> at <%=h path %></title>
-        <style type="text/css">
-          html * { padding:0; margin:0; }
-          body * { padding:10px 20px; }
-          body * * { padding:0; }
-          body { font:small sans-serif; }
-          body>div { border-bottom:1px solid #ddd; }
-          h1 { font-weight:normal; }
-          h2 { margin-bottom:.8em; }
-          h2 span { font-size:80%; color:#666; font-weight:normal; }
-          h3 { margin:1em 0 .5em 0; }
-          h4 { margin:0 0 .5em 0; font-weight: normal; }
-          table {
-              border:1px solid #ccc; border-collapse: collapse; background:white; }
-          tbody td, tbody th { vertical-align:top; padding:2px 3px; }
-          thead th {
-              padding:1px 6px 1px 3px; background:#fefefe; text-align:left;
-              font-weight:normal; font-size:11px; border:1px solid #ddd; }
-          tbody th { text-align:right; color:#666; padding-right:.5em; }
-          table.vars { margin:5px 0 2px 40px; }
-          table.vars td, table.req td { font-family:monospace; }
-          table td.code { width:100%;}
-          table td.code div { overflow:hidden; }
-          table.source th { color:#666; }
-          table.source td {
-              font-family:monospace; white-space:pre; border-bottom:1px solid #eee; }
-          ul.traceback { list-style-type:none; }
-          ul.traceback li.frame { margin-bottom:1em; }
-          div.context { margin: 10px 0; }
-          div.context ol {
-              padding-left:30px; margin:0 10px; list-style-position: inside; }
-          div.context ol li {
-              font-family:monospace; white-space:pre; color:#666; cursor:pointer; }
-          div.context ol.context-line li { color:black; background-color:#ccc; }
-          div.context ol.context-line li span { float: right; }
-          div.commands { margin-left: 40px; }
-          div.commands a { color:black; text-decoration:none; }
-          #summary { background: #ffc; }
-          #summary h2 { font-weight: normal; color: #666; }
-          #summary ul#quicklinks { list-style-type: none; margin-bottom: 2em; }
-          #summary ul#quicklinks li { float: left; padding: 0 1em; }
-          #summary ul#quicklinks>li+li { border-left: 1px #666 solid; }
-          #explanation { background:#eee; }
-          #template, #template-not-exist { background:#f6f6f6; }
-          #template-not-exist ul { margin: 0 0 0 20px; }
-          #traceback { background:#eee; }
-          #requestinfo { background:#f6f6f6; padding-left:120px; }
-          #summary table { border:none; background:transparent; }
-          #requestinfo h2, #requestinfo h3 { position:relative; margin-left:-100px; }
-          #requestinfo h3 { margin-bottom:-1em; }
-          .error { background: #ffc; }
-          .specific { color:#cc3300; font-weight:bold; }
-        </style>
-        <script type="text/javascript">
-        //<!--
-          function getElementsByClassName(oElm, strTagName, strClassName){
-              // Written by Jonathan Snook, http://www.snook.ca/jon;
-              // Add-ons by Robert Nyman, http://www.robertnyman.com
-              var arrElements = (strTagName == "*" && document.all)? document.all :
-              oElm.getElementsByTagName(strTagName);
-              var arrReturnElements = new Array();
-              strClassName = strClassName.replace(/\-/g, "\\-");
-              var oRegExp = new RegExp("(^|\\s)" + strClassName + "(\\s|$$)");
-              var oElement;
-              for(var i=0; i<arrElements.length; i++){
-                  oElement = arrElements[i];
-                  if(oRegExp.test(oElement.className)){
-                      arrReturnElements.push(oElement);
-                  }
-              }
-              return (arrReturnElements)
-          }
-          function hideAll(elems) {
-            for (var e = 0; e < elems.length; e++) {
-              elems[e].style.display = 'none';
-            }
-          }
-          window.onload = function() {
-            hideAll(getElementsByClassName(document, 'table', 'vars'));
-            hideAll(getElementsByClassName(document, 'ol', 'pre-context'));
-            hideAll(getElementsByClassName(document, 'ol', 'post-context'));
-          }
-          function toggle() {
-            for (var i = 0; i < arguments.length; i++) {
-              var e = document.getElementById(arguments[i]);
-              if (e) {
-                e.style.display = e.style.display == 'none' ? 'block' : 'none';
-              }
-            }
-            return false;
-          }
-          function varToggle(link, id) {
-            toggle('v' + id);
-            var s = link.getElementsByTagName('span')[0];
-            var uarr = String.fromCharCode(0x25b6);
-            var darr = String.fromCharCode(0x25bc);
-            s.innerHTML = s.innerHTML == uarr ? darr : uarr;
-            return false;
-          }
-          //-->
-        </script>
-      </head>
-      <body>
-
-      <div id="summary">
-        <h1><%=h exception.class %> at <%=h path %></h1>
-        <h2><%=h exception.message %></h2>
-        <table><tr>
-          <th>Ruby</th>
-          <td>
-      <% if first = frames.first %>
-            <code><%=h first.filename %></code>: in <code><%=h first.function %></code>, line <%=h frames.first.lineno %>
-      <% else %>
-            unknown location
-      <% end %>
-          </td>
-        </tr><tr>
-          <th>Web</th>
-          <td><code><%=h req.request_method %> <%=h(req.host + path)%></code></td>
-        </tr></table>
-
-        <h3>Jump to:</h3>
-        <ul id="quicklinks">
-          <li><a href="#get-info">GET</a></li>
-          <li><a href="#post-info">POST</a></li>
-          <li><a href="#cookie-info">Cookies</a></li>
-          <li><a href="#env-info">ENV</a></li>
-        </ul>
-      </div>
-
-      <div id="traceback">
-        <h2>Traceback <span>(innermost first)</span></h2>
-        <ul class="traceback">
-      <% frames.each { |frame| %>
-            <li class="frame">
-              <code><%=h frame.filename %></code>: in <code><%=h frame.function %></code>
-
-                <% if frame.context_line %>
-                <div class="context" id="c<%=h frame.object_id %>">
-                    <% if frame.pre_context %>
-                    <ol start="<%=h frame.pre_context_lineno+1 %>" class="pre-context" id="pre<%=h frame.object_id %>">
-                      <% frame.pre_context.each { |line| %>
-                      <li onclick="toggle('pre<%=h frame.object_id %>', 'post<%=h frame.object_id %>')"><%=h line %></li>
-                      <% } %>
-                    </ol>
-                    <% end %>
-
-                  <ol start="<%=h frame.lineno %>" class="context-line">
-                    <li onclick="toggle('pre<%=h frame.object_id %>', 'post<%=h frame.object_id %>')"><%=h frame.context_line %><span>...</span></li></ol>
-
-                    <% if frame.post_context %>
-                    <ol start='<%=h frame.lineno+1 %>' class="post-context" id="post<%=h frame.object_id %>">
-                      <% frame.post_context.each { |line| %>
-                      <li onclick="toggle('pre<%=h frame.object_id %>', 'post<%=h frame.object_id %>')"><%=h line %></li>
-                      <% } %>
-                    </ol>
-                    <% end %>
-                </div>
-                <% end %>
-            </li>
-      <% } %>
-        </ul>
-      </div>
-
-      <div id="requestinfo">
-        <h2>Request information</h2>
-
-        <h3 id="get-info">GET</h3>
-        <% if req.GET and not req.GET.empty? %>
-          <table class="req">
-            <thead>
-              <tr>
-                <th>Variable</th>
-                <th>Value</th>
-              </tr>
-            </thead>
-            <tbody>
-                <% req.GET.sort_by { |k, v| k.to_s }.each { |key, val| %>
-                <tr>
-                  <td><%=h key %></td>
-                  <td class="code"><div><%=h val.inspect %></div></td>
-                </tr>
-                <% } %>
-            </tbody>
-          </table>
-        <% else %>
-          <p>No GET data.</p>
-        <% end %>
-
-        <h3 id="post-info">POST</h3>
-        <% if ((req.POST and not req.POST.empty?) rescue (no_post_data = "Invalid POST data"; nil)) %>
-          <table class="req">
-            <thead>
-              <tr>
-                <th>Variable</th>
-                <th>Value</th>
-              </tr>
-            </thead>
-            <tbody>
-                <% req.POST.sort_by { |k, v| k.to_s }.each { |key, val| %>
-                <tr>
-                  <td><%=h key %></td>
-                  <td class="code"><div><%=h val.inspect %></div></td>
-                </tr>
-                <% } %>
-            </tbody>
-          </table>
-        <% else %>
-          <p><%= no_post_data || "No POST data" %>.</p>
-        <% end %>
-
-
-        <h3 id="cookie-info">COOKIES</h3>
-        <% unless req.cookies.empty? %>
-          <table class="req">
-            <thead>
-              <tr>
-                <th>Variable</th>
-                <th>Value</th>
-              </tr>
-            </thead>
-            <tbody>
-              <% req.cookies.each { |key, val| %>
-                <tr>
-                  <td><%=h key %></td>
-                  <td class="code"><div><%=h val.inspect %></div></td>
-                </tr>
-              <% } %>
-            </tbody>
-          </table>
-        <% else %>
-          <p>No cookie data.</p>
-        <% end %>
-
-        <h3 id="env-info">Rack ENV</h3>
-          <table class="req">
-            <thead>
-              <tr>
-                <th>Variable</th>
-                <th>Value</th>
-              </tr>
-            </thead>
-            <tbody>
-                <% env.sort_by { |k, v| k.to_s }.each { |key, val| %>
-                <tr>
-                  <td><%=h key %></td>
-                  <td class="code"><div><%=h val.inspect %></div></td>
-                </tr>
-                <% } %>
-            </tbody>
-          </table>
-
-      </div>
-
-      <div id="explanation">
-        <p>
-          You're seeing this error because you use <code>Rack::ShowExceptions</code>.
-        </p>
-      </div>
-
-      </body>
-      </html>
-    HTML
-
-    # :startdoc:
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/show_status.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/show_status.rb
deleted file mode 100644
index a99bdaf33aa7e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/show_status.rb
+++ /dev/null
@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require 'erb'
-
-module Rack
-  # Rack::ShowStatus catches all empty responses and replaces them
-  # with a site explaining the error.
-  #
-  # Additional details can be put into <tt>rack.showstatus.detail</tt>
-  # and will be shown as HTML.  If such details exist, the error page
-  # is always rendered, even if the reply was not empty.
-
-  class ShowStatus
-    def initialize(app)
-      @app = app
-      @template = ERB.new(TEMPLATE)
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      headers = Utils::HeaderHash[headers]
-      empty = headers[CONTENT_LENGTH].to_i <= 0
-
-      # client or server error, or explicit message
-      if (status.to_i >= 400 && empty) || env[RACK_SHOWSTATUS_DETAIL]
-        # This double assignment is to prevent an "unused variable" warning.
-        # Yes, it is dumb, but I don't like Ruby yelling at me.
-        req = req = Rack::Request.new(env)
-
-        message = Rack::Utils::HTTP_STATUS_CODES[status.to_i] || status.to_s
-
-        # This double assignment is to prevent an "unused variable" warning.
-        # Yes, it is dumb, but I don't like Ruby yelling at me.
-        detail = detail = env[RACK_SHOWSTATUS_DETAIL] || message
-
-        body = @template.result(binding)
-        size = body.bytesize
-        [status, headers.merge(CONTENT_TYPE => "text/html", CONTENT_LENGTH => size.to_s), [body]]
-      else
-        [status, headers, body]
-      end
-    end
-
-    def h(obj)                  # :nodoc:
-      case obj
-      when String
-        Utils.escape_html(obj)
-      else
-        Utils.escape_html(obj.inspect)
-      end
-    end
-
-    # :stopdoc:
-
-# adapted from Django <www.djangoproject.com>
-# Copyright (c) Django Software Foundation and individual contributors.
-# Used under the modified BSD license:
-# http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5
-TEMPLATE = <<'HTML'
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<html lang="en">
-<head>
-  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
-  <title><%=h message %> at <%=h req.script_name + req.path_info %></title>
-  <meta name="robots" content="NONE,NOARCHIVE" />
-  <style type="text/css">
-    html * { padding:0; margin:0; }
-    body * { padding:10px 20px; }
-    body * * { padding:0; }
-    body { font:small sans-serif; background:#eee; }
-    body>div { border-bottom:1px solid #ddd; }
-    h1 { font-weight:normal; margin-bottom:.4em; }
-    h1 span { font-size:60%; color:#666; font-weight:normal; }
-    table { border:none; border-collapse: collapse; width:100%; }
-    td, th { vertical-align:top; padding:2px 3px; }
-    th { width:12em; text-align:right; color:#666; padding-right:.5em; }
-    #info { background:#f6f6f6; }
-    #info ol { margin: 0.5em 4em; }
-    #info ol li { font-family: monospace; }
-    #summary { background: #ffc; }
-    #explanation { background:#eee; border-bottom: 0px none; }
-  </style>
-</head>
-<body>
-  <div id="summary">
-    <h1><%=h message %> <span>(<%= status.to_i %>)</span></h1>
-    <table class="meta">
-      <tr>
-        <th>Request Method:</th>
-        <td><%=h req.request_method %></td>
-      </tr>
-      <tr>
-        <th>Request URL:</th>
-      <td><%=h req.url %></td>
-      </tr>
-    </table>
-  </div>
-  <div id="info">
-    <p><%=h detail %></p>
-  </div>
-
-  <div id="explanation">
-    <p>
-    You're seeing this error because you use <code>Rack::ShowStatus</code>.
-    </p>
-  </div>
-</body>
-</html>
-HTML
-
-    # :startdoc:
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/static.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/static.rb
deleted file mode 100644
index 8cb58b2fd7342..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/static.rb
+++ /dev/null
@@ -1,187 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-
-  # The Rack::Static middleware intercepts requests for static files
-  # (javascript files, images, stylesheets, etc) based on the url prefixes or
-  # route mappings passed in the options, and serves them using a Rack::Files
-  # object. This allows a Rack stack to serve both static and dynamic content.
-  #
-  # Examples:
-  #
-  # Serve all requests beginning with /media from the "media" folder located
-  # in the current directory (ie media/*):
-  #
-  #     use Rack::Static, :urls => ["/media"]
-  #
-  # Same as previous, but instead of returning 404 for missing files under
-  # /media, call the next middleware:
-  #
-  #     use Rack::Static, :urls => ["/media"], :cascade => true
-  #
-  # Serve all requests beginning with /css or /images from the folder "public"
-  # in the current directory (ie public/css/* and public/images/*):
-  #
-  #     use Rack::Static, :urls => ["/css", "/images"], :root => "public"
-  #
-  # Serve all requests to / with "index.html" from the folder "public" in the
-  # current directory (ie public/index.html):
-  #
-  #     use Rack::Static, :urls => {"/" => 'index.html'}, :root => 'public'
-  #
-  # Serve all requests normally from the folder "public" in the current
-  # directory but uses index.html as default route for "/"
-  #
-  #     use Rack::Static, :urls => [""], :root => 'public', :index =>
-  #     'index.html'
-  #
-  # Set custom HTTP Headers for based on rules:
-  #
-  #     use Rack::Static, :root => 'public',
-  #         :header_rules => [
-  #           [rule, {header_field => content, header_field => content}],
-  #           [rule, {header_field => content}]
-  #         ]
-  #
-  #  Rules for selecting files:
-  #
-  #  1) All files
-  #     Provide the :all symbol
-  #     :all => Matches every file
-  #
-  #  2) Folders
-  #     Provide the folder path as a string
-  #     '/folder' or '/folder/subfolder' => Matches files in a certain folder
-  #
-  #  3) File Extensions
-  #     Provide the file extensions as an array
-  #     ['css', 'js'] or %w(css js) => Matches files ending in .css or .js
-  #
-  #  4) Regular Expressions / Regexp
-  #     Provide a regular expression
-  #     %r{\.(?:css|js)\z} => Matches files ending in .css or .js
-  #     /\.(?:eot|ttf|otf|woff2|woff|svg)\z/ => Matches files ending in
-  #       the most common web font formats (.eot, .ttf, .otf, .woff2, .woff, .svg)
-  #       Note: This Regexp is available as a shortcut, using the :fonts rule
-  #
-  #  5) Font Shortcut
-  #     Provide the :fonts symbol
-  #     :fonts => Uses the Regexp rule stated right above to match all common web font endings
-  #
-  #  Rule Ordering:
-  #    Rules are applied in the order that they are provided.
-  #    List rather general rules above special ones.
-  #
-  #  Complete example use case including HTTP header rules:
-  #
-  #     use Rack::Static, :root => 'public',
-  #         :header_rules => [
-  #           # Cache all static files in public caches (e.g. Rack::Cache)
-  #           #  as well as in the browser
-  #           [:all, {'Cache-Control' => 'public, max-age=31536000'}],
-  #
-  #           # Provide web fonts with cross-origin access-control-headers
-  #           #  Firefox requires this when serving assets using a Content Delivery Network
-  #           [:fonts, {'Access-Control-Allow-Origin' => '*'}]
-  #         ]
-  #
-  class Static
-    (require_relative 'core_ext/regexp'; using ::Rack::RegexpExtensions) if RUBY_VERSION < '2.4'
-
-    def initialize(app, options = {})
-      @app = app
-      @urls = options[:urls] || ["/favicon.ico"]
-      @index = options[:index]
-      @gzip = options[:gzip]
-      @cascade = options[:cascade]
-      root = options[:root] || Dir.pwd
-
-      # HTTP Headers
-      @header_rules = options[:header_rules] || []
-      # Allow for legacy :cache_control option while prioritizing global header_rules setting
-      @header_rules.unshift([:all, { CACHE_CONTROL => options[:cache_control] }]) if options[:cache_control]
-
-      @file_server = Rack::Files.new(root)
-    end
-
-    def add_index_root?(path)
-      @index && route_file(path) && path.end_with?('/')
-    end
-
-    def overwrite_file_path(path)
-      @urls.kind_of?(Hash) && @urls.key?(path) || add_index_root?(path)
-    end
-
-    def route_file(path)
-      @urls.kind_of?(Array) && @urls.any? { |url| path.index(url) == 0 }
-    end
-
-    def can_serve(path)
-      route_file(path) || overwrite_file_path(path)
-    end
-
-    def call(env)
-      path = env[PATH_INFO]
-
-      if can_serve(path)
-        if overwrite_file_path(path)
-          env[PATH_INFO] = (add_index_root?(path) ? path + @index : @urls[path])
-        elsif @gzip && env['HTTP_ACCEPT_ENCODING'] && /\bgzip\b/.match?(env['HTTP_ACCEPT_ENCODING'])
-          path = env[PATH_INFO]
-          env[PATH_INFO] += '.gz'
-          response = @file_server.call(env)
-          env[PATH_INFO] = path
-
-          if response[0] == 404
-            response = nil
-          elsif response[0] == 304
-            # Do nothing, leave headers as is
-          else
-            if mime_type = Mime.mime_type(::File.extname(path), 'text/plain')
-              response[1][CONTENT_TYPE] = mime_type
-            end
-            response[1]['Content-Encoding'] = 'gzip'
-          end
-        end
-
-        path = env[PATH_INFO]
-        response ||= @file_server.call(env)
-
-        if @cascade && response[0] == 404
-          return @app.call(env)
-        end
-
-        headers = response[1]
-        applicable_rules(path).each do |rule, new_headers|
-          new_headers.each { |field, content| headers[field] = content }
-        end
-
-        response
-      else
-        @app.call(env)
-      end
-    end
-
-    # Convert HTTP header rules to HTTP headers
-    def applicable_rules(path)
-      @header_rules.find_all do |rule, new_headers|
-        case rule
-        when :all
-          true
-        when :fonts
-          /\.(?:ttf|otf|eot|woff2|woff|svg)\z/.match?(path)
-        when String
-          path = ::Rack::Utils.unescape(path)
-          path.start_with?(rule) || path.start_with?('/' + rule)
-        when Array
-          /\.(#{rule.join('|')})\z/.match?(path)
-        when Regexp
-          rule.match?(path)
-        else
-          false
-        end
-      end
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/tempfile_reaper.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/tempfile_reaper.rb
deleted file mode 100644
index 9b04fefc24414..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/tempfile_reaper.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-
-  # Middleware tracks and cleans Tempfiles created throughout a request (i.e. Rack::Multipart)
-  # Ideas/strategy based on posts by Eric Wong and Charles Oliver Nutter
-  # https://groups.google.com/forum/#!searchin/rack-devel/temp/rack-devel/brK8eh-MByw/sw61oJJCGRMJ
-  class TempfileReaper
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      env[RACK_TEMPFILES] ||= []
-      status, headers, body = @app.call(env)
-      body_proxy = BodyProxy.new(body) do
-        env[RACK_TEMPFILES].each(&:close!) unless env[RACK_TEMPFILES].nil?
-      end
-      [status, headers, body_proxy]
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/urlmap.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/urlmap.rb
deleted file mode 100644
index 31a642c4183a5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/urlmap.rb
+++ /dev/null
@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-module Rack
-  # Rack::URLMap takes a hash mapping urls or paths to apps, and
-  # dispatches accordingly.  Support for HTTP/1.1 host names exists if
-  # the URLs start with <tt>http://</tt> or <tt>https://</tt>.
-  #
-  # URLMap modifies the SCRIPT_NAME and PATH_INFO such that the part
-  # relevant for dispatch is in the SCRIPT_NAME, and the rest in the
-  # PATH_INFO.  This should be taken care of when you need to
-  # reconstruct the URL in order to create links.
-  #
-  # URLMap dispatches in such a way that the longest paths are tried
-  # first, since they are most specific.
-
-  class URLMap
-    def initialize(map = {})
-      remap(map)
-    end
-
-    def remap(map)
-      @known_hosts = Set[]
-      @mapping = map.map { |location, app|
-        if location =~ %r{\Ahttps?://(.*?)(/.*)}
-          host, location = $1, $2
-          @known_hosts << host
-        else
-          host = nil
-        end
-
-        unless location[0] == ?/
-          raise ArgumentError, "paths need to start with /"
-        end
-
-        location = location.chomp('/')
-        match = Regexp.new("^#{Regexp.quote(location).gsub('/', '/+')}(.*)", nil, 'n')
-
-        [host, location, match, app]
-      }.sort_by do |(host, location, _, _)|
-        [host ? -host.size : Float::INFINITY, -location.size]
-      end
-    end
-
-    def call(env)
-      path        = env[PATH_INFO]
-      script_name = env[SCRIPT_NAME]
-      http_host   = env[HTTP_HOST]
-      server_name = env[SERVER_NAME]
-      server_port = env[SERVER_PORT]
-
-      is_same_server = casecmp?(http_host, server_name) ||
-                       casecmp?(http_host, "#{server_name}:#{server_port}")
-
-      is_host_known = @known_hosts.include? http_host
-
-      @mapping.each do |host, location, match, app|
-        unless casecmp?(http_host, host) \
-            || casecmp?(server_name, host) \
-            || (!host && is_same_server) \
-            || (!host && !is_host_known) # If we don't have a matching host, default to the first without a specified host
-          next
-        end
-
-        next unless m = match.match(path.to_s)
-
-        rest = m[1]
-        next unless !rest || rest.empty? || rest[0] == ?/
-
-        env[SCRIPT_NAME] = (script_name + location)
-        env[PATH_INFO] = rest
-
-        return app.call(env)
-      end
-
-      [404, { CONTENT_TYPE => "text/plain", "X-Cascade" => "pass" }, ["Not Found: #{path}"]]
-
-    ensure
-      env[PATH_INFO]   = path
-      env[SCRIPT_NAME] = script_name
-    end
-
-    private
-    def casecmp?(v1, v2)
-      # if both nil, or they're the same string
-      return true if v1 == v2
-
-      # if either are nil... (but they're not the same)
-      return false if v1.nil?
-      return false if v2.nil?
-
-      # otherwise check they're not case-insensitive the same
-      v1.casecmp(v2).zero?
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/utils.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/utils.rb
deleted file mode 100644
index 34849ded1ce7d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/utils.rb
+++ /dev/null
@@ -1,616 +0,0 @@
-# -*- encoding: binary -*-
-# frozen_string_literal: true
-
-require 'uri'
-require 'fileutils'
-require 'set'
-require 'tempfile'
-require 'time'
-
-require_relative 'query_parser'
-
-module Rack
-  # Rack::Utils contains a grab-bag of useful methods for writing web
-  # applications adopted from all kinds of Ruby libraries.
-
-  module Utils
-    (require_relative 'core_ext/regexp'; using ::Rack::RegexpExtensions) if RUBY_VERSION < '2.4'
-
-    ParameterTypeError = QueryParser::ParameterTypeError
-    InvalidParameterError = QueryParser::InvalidParameterError
-    DEFAULT_SEP = QueryParser::DEFAULT_SEP
-    COMMON_SEP = QueryParser::COMMON_SEP
-    KeySpaceConstrainedParams = QueryParser::Params
-
-    RFC2822_DAY_NAME = [ 'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat' ]
-    RFC2822_MONTH_NAME = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
-
-    class << self
-      attr_accessor :default_query_parser
-    end
-    # The default number of bytes to allow parameter keys to take up.
-    # This helps prevent a rogue client from flooding a Request.
-    self.default_query_parser = QueryParser.make_default(65536, 100)
-
-    module_function
-
-    # URI escapes. (CGI style space to +)
-    def escape(s)
-      URI.encode_www_form_component(s)
-    end
-
-    # Like URI escaping, but with %20 instead of +. Strictly speaking this is
-    # true URI escaping.
-    def escape_path(s)
-      ::URI::DEFAULT_PARSER.escape s
-    end
-
-    # Unescapes the **path** component of a URI.  See Rack::Utils.unescape for
-    # unescaping query parameters or form components.
-    def unescape_path(s)
-      ::URI::DEFAULT_PARSER.unescape s
-    end
-
-    # Unescapes a URI escaped string with +encoding+. +encoding+ will be the
-    # target encoding of the string returned, and it defaults to UTF-8
-    def unescape(s, encoding = Encoding::UTF_8)
-      URI.decode_www_form_component(s, encoding)
-    end
-
-    class << self
-      attr_accessor :multipart_part_limit
-    end
-
-    # The maximum number of parts a request can contain. Accepting too many part
-    # can lead to the server running out of file handles.
-    # Set to `0` for no limit.
-    self.multipart_part_limit = (ENV['RACK_MULTIPART_PART_LIMIT'] || 128).to_i
-
-    def self.param_depth_limit
-      default_query_parser.param_depth_limit
-    end
-
-    def self.param_depth_limit=(v)
-      self.default_query_parser = self.default_query_parser.new_depth_limit(v)
-    end
-
-    def self.key_space_limit
-      default_query_parser.key_space_limit
-    end
-
-    def self.key_space_limit=(v)
-      self.default_query_parser = self.default_query_parser.new_space_limit(v)
-    end
-
-    if defined?(Process::CLOCK_MONOTONIC)
-      def clock_time
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-    else
-      # :nocov:
-      def clock_time
-        Time.now.to_f
-      end
-      # :nocov:
-    end
-
-    def parse_query(qs, d = nil, &unescaper)
-      Rack::Utils.default_query_parser.parse_query(qs, d, &unescaper)
-    end
-
-    def parse_nested_query(qs, d = nil)
-      Rack::Utils.default_query_parser.parse_nested_query(qs, d)
-    end
-
-    def build_query(params)
-      params.map { |k, v|
-        if v.class == Array
-          build_query(v.map { |x| [k, x] })
-        else
-          v.nil? ? escape(k) : "#{escape(k)}=#{escape(v)}"
-        end
-      }.join("&")
-    end
-
-    def build_nested_query(value, prefix = nil)
-      case value
-      when Array
-        value.map { |v|
-          build_nested_query(v, "#{prefix}[]")
-        }.join("&")
-      when Hash
-        value.map { |k, v|
-          build_nested_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
-        }.delete_if(&:empty?).join('&')
-      when nil
-        prefix
-      else
-        raise ArgumentError, "value must be a Hash" if prefix.nil?
-        "#{prefix}=#{escape(value)}"
-      end
-    end
-
-    def q_values(q_value_header)
-      q_value_header.to_s.split(/\s*,\s*/).map do |part|
-        value, parameters = part.split(/\s*;\s*/, 2)
-        quality = 1.0
-        if parameters && (md = /\Aq=([\d.]+)/.match(parameters))
-          quality = md[1].to_f
-        end
-        [value, quality]
-      end
-    end
-
-    # Return best accept value to use, based on the algorithm
-    # in RFC 2616 Section 14.  If there are multiple best
-    # matches (same specificity and quality), the value returned
-    # is arbitrary.
-    def best_q_match(q_value_header, available_mimes)
-      values = q_values(q_value_header)
-
-      matches = values.map do |req_mime, quality|
-        match = available_mimes.find { |am| Rack::Mime.match?(am, req_mime) }
-        next unless match
-        [match, quality]
-      end.compact.sort_by do |match, quality|
-        (match.split('/', 2).count('*') * -10) + quality
-      end.last
-      matches && matches.first
-    end
-
-    ESCAPE_HTML = {
-      "&" => "&amp;",
-      "<" => "&lt;",
-      ">" => "&gt;",
-      "'" => "&#x27;",
-      '"' => "&quot;",
-      "/" => "&#x2F;"
-    }
-
-    ESCAPE_HTML_PATTERN = Regexp.union(*ESCAPE_HTML.keys)
-
-    # Escape ampersands, brackets and quotes to their HTML/XML entities.
-    def escape_html(string)
-      string.to_s.gsub(ESCAPE_HTML_PATTERN){|c| ESCAPE_HTML[c] }
-    end
-
-    def select_best_encoding(available_encodings, accept_encoding)
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
-
-      expanded_accept_encoding = []
-
-      accept_encoding.each do |m, q|
-        preference = available_encodings.index(m) || available_encodings.size
-
-        if m == "*"
-          (available_encodings - accept_encoding.map(&:first)).each do |m2|
-            expanded_accept_encoding << [m2, q, preference]
-          end
-        else
-          expanded_accept_encoding << [m, q, preference]
-        end
-      end
-
-      encoding_candidates = expanded_accept_encoding
-        .sort_by { |_, q, p| [-q, p] }
-        .map!(&:first)
-
-      unless encoding_candidates.include?("identity")
-        encoding_candidates.push("identity")
-      end
-
-      expanded_accept_encoding.each do |m, q|
-        encoding_candidates.delete(m) if q == 0.0
-      end
-
-      (encoding_candidates & available_encodings)[0]
-    end
-
-    def parse_cookies(env)
-      parse_cookies_header env[HTTP_COOKIE]
-    end
-
-    def parse_cookies_header(header)
-      # According to RFC 6265:
-      # The syntax for cookie headers only supports semicolons
-      # User Agent -> Server ==
-      # Cookie: SID=31d4d96e407aad42; lang=en-US
-      return {} unless header
-      header.split(/[;] */n).each_with_object({}) do |cookie, cookies|
-        next if cookie.empty?
-        key, value = cookie.split('=', 2)
-        cookies[key] = (unescape(value) rescue value) unless cookies.key?(key)
-      end
-    end
-
-    def add_cookie_to_header(header, key, value)
-      case value
-      when Hash
-        domain  = "; domain=#{value[:domain]}"   if value[:domain]
-        path    = "; path=#{value[:path]}"       if value[:path]
-        max_age = "; max-age=#{value[:max_age]}" if value[:max_age]
-        expires = "; expires=#{value[:expires].httpdate}" if value[:expires]
-        secure = "; secure"  if value[:secure]
-        httponly = "; HttpOnly" if (value.key?(:httponly) ? value[:httponly] : value[:http_only])
-        same_site =
-          case value[:same_site]
-          when false, nil
-            nil
-          when :none, 'None', :None
-            '; SameSite=None'
-          when :lax, 'Lax', :Lax
-            '; SameSite=Lax'
-          when true, :strict, 'Strict', :Strict
-            '; SameSite=Strict'
-          else
-            raise ArgumentError, "Invalid SameSite value: #{value[:same_site].inspect}"
-          end
-        value = value[:value]
-      end
-      value = [value] unless Array === value
-
-      cookie = "#{escape(key)}=#{value.map { |v| escape v }.join('&')}#{domain}" \
-        "#{path}#{max_age}#{expires}#{secure}#{httponly}#{same_site}"
-
-      case header
-      when nil, ''
-        cookie
-      when String
-        [header, cookie].join("\n")
-      when Array
-        (header + [cookie]).join("\n")
-      else
-        raise ArgumentError, "Unrecognized cookie header value. Expected String, Array, or nil, got #{header.inspect}"
-      end
-    end
-
-    def set_cookie_header!(header, key, value)
-      header[SET_COOKIE] = add_cookie_to_header(header[SET_COOKIE], key, value)
-      nil
-    end
-
-    def make_delete_cookie_header(header, key, value)
-      case header
-      when nil, ''
-        cookies = []
-      when String
-        cookies = header.split("\n")
-      when Array
-        cookies = header
-      end
-
-      key = escape(key)
-      domain = value[:domain]
-      path = value[:path]
-      regexp = if domain
-                 if path
-                   /\A#{key}=.*(?:domain=#{domain}(?:;|$).*path=#{path}(?:;|$)|path=#{path}(?:;|$).*domain=#{domain}(?:;|$))/
-                 else
-                   /\A#{key}=.*domain=#{domain}(?:;|$)/
-                 end
-               elsif path
-                 /\A#{key}=.*path=#{path}(?:;|$)/
-               else
-                 /\A#{key}=/
-               end
-
-      cookies.reject! { |cookie| regexp.match? cookie }
-
-      cookies.join("\n")
-    end
-
-    def delete_cookie_header!(header, key, value = {})
-      header[SET_COOKIE] = add_remove_cookie_to_header(header[SET_COOKIE], key, value)
-      nil
-    end
-
-    # Adds a cookie that will *remove* a cookie from the client.  Hence the
-    # strange method name.
-    def add_remove_cookie_to_header(header, key, value = {})
-      new_header = make_delete_cookie_header(header, key, value)
-
-      add_cookie_to_header(new_header, key,
-                 { value: '', path: nil, domain: nil,
-                   max_age: '0',
-                   expires: Time.at(0) }.merge(value))
-
-    end
-
-    def rfc2822(time)
-      time.rfc2822
-    end
-
-    # Modified version of stdlib time.rb Time#rfc2822 to use '%d-%b-%Y' instead
-    # of '% %b %Y'.
-    # It assumes that the time is in GMT to comply to the RFC 2109.
-    #
-    # NOTE: I'm not sure the RFC says it requires GMT, but is ambiguous enough
-    # that I'm certain someone implemented only that option.
-    # Do not use %a and %b from Time.strptime, it would use localized names for
-    # weekday and month.
-    #
-    def rfc2109(time)
-      wday = RFC2822_DAY_NAME[time.wday]
-      mon = RFC2822_MONTH_NAME[time.mon - 1]
-      time.strftime("#{wday}, %d-#{mon}-%Y %H:%M:%S GMT")
-    end
-
-    # Parses the "Range:" header, if present, into an array of Range objects.
-    # Returns nil if the header is missing or syntactically invalid.
-    # Returns an empty array if none of the ranges are satisfiable.
-    def byte_ranges(env, size)
-      warn "`byte_ranges` is deprecated, please use `get_byte_ranges`" if $VERBOSE
-      get_byte_ranges env['HTTP_RANGE'], size
-    end
-
-    def get_byte_ranges(http_range, size)
-      # See <http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35>
-      return nil unless http_range && http_range =~ /bytes=([^;]+)/
-      ranges = []
-      $1.split(/,\s*/).each do |range_spec|
-        return nil  unless range_spec =~ /(\d*)-(\d*)/
-        r0, r1 = $1, $2
-        if r0.empty?
-          return nil  if r1.empty?
-          # suffix-byte-range-spec, represents trailing suffix of file
-          r0 = size - r1.to_i
-          r0 = 0  if r0 < 0
-          r1 = size - 1
-        else
-          r0 = r0.to_i
-          if r1.empty?
-            r1 = size - 1
-          else
-            r1 = r1.to_i
-            return nil  if r1 < r0  # backwards range is syntactically invalid
-            r1 = size - 1  if r1 >= size
-          end
-        end
-        ranges << (r0..r1)  if r0 <= r1
-      end
-      ranges
-    end
-
-    # Constant time string comparison.
-    #
-    # NOTE: the values compared should be of fixed length, such as strings
-    # that have already been processed by HMAC. This should not be used
-    # on variable length plaintext strings because it could leak length info
-    # via timing attacks.
-    def secure_compare(a, b)
-      return false unless a.bytesize == b.bytesize
-
-      l = a.unpack("C*")
-
-      r, i = 0, -1
-      b.each_byte { |v| r |= v ^ l[i += 1] }
-      r == 0
-    end
-
-    # Context allows the use of a compatible middleware at different points
-    # in a request handling stack. A compatible middleware must define
-    # #context which should take the arguments env and app. The first of which
-    # would be the request environment. The second of which would be the rack
-    # application that the request would be forwarded to.
-    class Context
-      attr_reader :for, :app
-
-      def initialize(app_f, app_r)
-        raise 'running context does not respond to #context' unless app_f.respond_to? :context
-        @for, @app = app_f, app_r
-      end
-
-      def call(env)
-        @for.context(env, @app)
-      end
-
-      def recontext(app)
-        self.class.new(@for, app)
-      end
-
-      def context(env, app = @app)
-        recontext(app).call(env)
-      end
-    end
-
-    # A case-insensitive Hash that preserves the original case of a
-    # header when set.
-    #
-    # @api private
-    class HeaderHash < Hash # :nodoc:
-      def self.[](headers)
-        if headers.is_a?(HeaderHash) && !headers.frozen?
-          return headers
-        else
-          return self.new(headers)
-        end
-      end
-
-      def initialize(hash = {})
-        super()
-        @names = {}
-        hash.each { |k, v| self[k] = v }
-      end
-
-      # on dup/clone, we need to duplicate @names hash
-      def initialize_copy(other)
-        super
-        @names = other.names.dup
-      end
-
-      # on clear, we need to clear @names hash
-      def clear
-        super
-        @names.clear
-      end
-
-      def each
-        super do |k, v|
-          yield(k, v.respond_to?(:to_ary) ? v.to_ary.join("\n") : v)
-        end
-      end
-
-      def to_hash
-        hash = {}
-        each { |k, v| hash[k] = v }
-        hash
-      end
-
-      def [](k)
-        super(k) || super(@names[k.downcase])
-      end
-
-      def []=(k, v)
-        canonical = k.downcase.freeze
-        delete k if @names[canonical] && @names[canonical] != k # .delete is expensive, don't invoke it unless necessary
-        @names[canonical] = k
-        super k, v
-      end
-
-      def delete(k)
-        canonical = k.downcase
-        result = super @names.delete(canonical)
-        result
-      end
-
-      def include?(k)
-        super || @names.include?(k.downcase)
-      end
-
-      alias_method :has_key?, :include?
-      alias_method :member?, :include?
-      alias_method :key?, :include?
-
-      def merge!(other)
-        other.each { |k, v| self[k] = v }
-        self
-      end
-
-      def merge(other)
-        hash = dup
-        hash.merge! other
-      end
-
-      def replace(other)
-        clear
-        other.each { |k, v| self[k] = v }
-        self
-      end
-
-      protected
-        def names
-          @names
-        end
-    end
-
-    # Every standard HTTP code mapped to the appropriate message.
-    # Generated with:
-    #   curl -s https://www.iana.org/assignments/http-status-codes/http-status-codes-1.csv | \
-    #     ruby -ne 'm = /^(\d{3}),(?!Unassigned|\(Unused\))([^,]+)/.match($_) and \
-    #               puts "#{m[1]} => \x27#{m[2].strip}\x27,"'
-    HTTP_STATUS_CODES = {
-      100 => 'Continue',
-      101 => 'Switching Protocols',
-      102 => 'Processing',
-      103 => 'Early Hints',
-      200 => 'OK',
-      201 => 'Created',
-      202 => 'Accepted',
-      203 => 'Non-Authoritative Information',
-      204 => 'No Content',
-      205 => 'Reset Content',
-      206 => 'Partial Content',
-      207 => 'Multi-Status',
-      208 => 'Already Reported',
-      226 => 'IM Used',
-      300 => 'Multiple Choices',
-      301 => 'Moved Permanently',
-      302 => 'Found',
-      303 => 'See Other',
-      304 => 'Not Modified',
-      305 => 'Use Proxy',
-      306 => '(Unused)',
-      307 => 'Temporary Redirect',
-      308 => 'Permanent Redirect',
-      400 => 'Bad Request',
-      401 => 'Unauthorized',
-      402 => 'Payment Required',
-      403 => 'Forbidden',
-      404 => 'Not Found',
-      405 => 'Method Not Allowed',
-      406 => 'Not Acceptable',
-      407 => 'Proxy Authentication Required',
-      408 => 'Request Timeout',
-      409 => 'Conflict',
-      410 => 'Gone',
-      411 => 'Length Required',
-      412 => 'Precondition Failed',
-      413 => 'Payload Too Large',
-      414 => 'URI Too Long',
-      415 => 'Unsupported Media Type',
-      416 => 'Range Not Satisfiable',
-      417 => 'Expectation Failed',
-      421 => 'Misdirected Request',
-      422 => 'Unprocessable Entity',
-      423 => 'Locked',
-      424 => 'Failed Dependency',
-      425 => 'Too Early',
-      426 => 'Upgrade Required',
-      428 => 'Precondition Required',
-      429 => 'Too Many Requests',
-      431 => 'Request Header Fields Too Large',
-      451 => 'Unavailable for Legal Reasons',
-      500 => 'Internal Server Error',
-      501 => 'Not Implemented',
-      502 => 'Bad Gateway',
-      503 => 'Service Unavailable',
-      504 => 'Gateway Timeout',
-      505 => 'HTTP Version Not Supported',
-      506 => 'Variant Also Negotiates',
-      507 => 'Insufficient Storage',
-      508 => 'Loop Detected',
-      509 => 'Bandwidth Limit Exceeded',
-      510 => 'Not Extended',
-      511 => 'Network Authentication Required'
-    }
-
-    # Responses with HTTP status codes that should not have an entity body
-    STATUS_WITH_NO_ENTITY_BODY = Hash[((100..199).to_a << 204 << 304).product([true])]
-
-    SYMBOL_TO_STATUS_CODE = Hash[*HTTP_STATUS_CODES.map { |code, message|
-      [message.downcase.gsub(/\s|-|'/, '_').to_sym, code]
-    }.flatten]
-
-    def status_code(status)
-      if status.is_a?(Symbol)
-        SYMBOL_TO_STATUS_CODE.fetch(status) { raise ArgumentError, "Unrecognized status code #{status.inspect}" }
-      else
-        status.to_i
-      end
-    end
-
-    PATH_SEPS = Regexp.union(*[::File::SEPARATOR, ::File::ALT_SEPARATOR].compact)
-
-    def clean_path_info(path_info)
-      parts = path_info.split PATH_SEPS
-
-      clean = []
-
-      parts.each do |part|
-        next if part.empty? || part == '.'
-        part == '..' ? clean.pop : clean << part
-      end
-
-      clean_path = clean.join(::File::SEPARATOR)
-      clean_path.prepend("/") if parts.empty? || parts.first.empty?
-      clean_path
-    end
-
-    NULL_BYTE = "\0"
-
-    def valid_path?(path)
-      path.valid_encoding? && !path.include?(NULL_BYTE)
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/version.rb
deleted file mode 100644
index f05a2c602c6cf..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rack-2.2.4/lib/rack/version.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (C) 2007-2019 Leah Neukirchen <http://leahneukirchen.org/infopage.html>
-#
-# Rack is freely distributable under the terms of an MIT-style license.
-# See MIT-LICENSE or https://opensource.org/licenses/MIT.
-
-# The Rack main module, serving as a namespace for all core Rack
-# modules and classes.
-#
-# All modules meant for use in your application are <tt>autoload</tt>ed here,
-# so it should be enough just to <tt>require 'rack'</tt> in your code.
-
-module Rack
-  # The Rack protocol version number implemented.
-  VERSION = [1, 3]
-
-  # Return the Rack protocol version as a dotted string.
-  def self.version
-    VERSION.join(".")
-  end
-
-  RELEASE = "2.2.4"
-
-  # Return the Rack release as a dotted string.
-  def self.release
-    RELEASE
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/config/default.yml b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/config/default.yml
deleted file mode 100644
index 0b5f4c5a5d178..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/config/default.yml
+++ /dev/null
@@ -1,362 +0,0 @@
-# This is the default configuration file.
-
-Performance/AncestorsInclude:
-  Description: 'Use `A <= B` instead of `A.ancestors.include?(B)`.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#ancestorsinclude-vs--code'
-  Enabled: 'pending'
-  Safe: false
-  VersionAdded: '1.7'
-
-Performance/ArraySemiInfiniteRangeSlice:
-  Description: 'Identifies places where slicing arrays with semi-infinite ranges can be replaced by `Array#take` and `Array#drop`.'
-  # This cop was created due to a mistake in microbenchmark.
-  # Refer https://github.com/rubocop/rubocop-performance/pull/175#issuecomment-731892717
-  Enabled: false
-  # Unsafe for string slices because strings do not have `#take` and `#drop` methods.
-  Safe: false
-  VersionAdded: '1.9'
-
-Performance/BigDecimalWithNumericArgument:
-  Description: 'Convert numeric literal to string and pass it to `BigDecimal`.'
-  Enabled: 'pending'
-  VersionAdded: '1.7'
-
-Performance/BindCall:
-  Description: 'Use `bind_call(obj, args, ...)` instead of `bind(obj).call(args, ...)`.'
-  Enabled: true
-  VersionAdded: '1.6'
-
-Performance/BlockGivenWithExplicitBlock:
-  Description: 'Check block argument explicitly instead of using `block_given?`.'
-  Enabled: pending
-  VersionAdded: '1.9'
-
-Performance/Caller:
-  Description: >-
-             Use `caller(n..n)` instead of `caller`.
-  Enabled: true
-  VersionAdded: '0.49'
-  VersionChanged: '1.9'
-
-Performance/CaseWhenSplat:
-  Description: >-
-                 Reordering `when` conditions with a splat to the end
-                 of the `when` branches can improve performance.
-  Enabled: false
-  SafeAutoCorrect: false
-  VersionAdded: '0.34'
-  VersionChanged: '1.13'
-
-Performance/Casecmp:
-  Description: >-
-             Use `casecmp` rather than `downcase ==`, `upcase ==`, `== downcase`, or `== upcase`..
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringcasecmp-vs-stringdowncase---code'
-  Enabled: true
-  Safe: false
-  VersionAdded: '0.36'
-
-Performance/ChainArrayAllocation:
-  Description: >-
-                  Instead of chaining array methods that allocate new arrays, mutate an
-                  existing array.
-  Reference: 'https://twitter.com/schneems/status/1034123879978029057'
-  Enabled: false
-  VersionAdded: '0.59'
-
-Performance/CollectionLiteralInLoop:
-  Description: 'Extract Array and Hash literals outside of loops into local variables or constants.'
-  Enabled: 'pending'
-  VersionAdded: '1.8'
-  # Min number of elements to consider an offense
-  MinSize: 1
-
-Performance/CompareWithBlock:
-  Description: 'Use `sort_by(&:foo)` instead of `sort { |a, b| a.foo <=> b.foo }`.'
-  Enabled: true
-  VersionAdded: '0.46'
-
-Performance/ConcurrentMonotonicTime:
-  Description: 'Use `Process.clock_gettime(Process::CLOCK_MONOTONIC)` instead of `Concurrent.monotonic_time`.'
-  Reference: 'https://github.com/rails/rails/pull/43502'
-  Enabled: pending
-  VersionAdded: '1.12'
-
-Performance/ConstantRegexp:
-  Description: 'Finds regular expressions with dynamic components that are all constants.'
-  Enabled: pending
-  VersionAdded: '1.9'
-  VersionChanged: '1.10'
-
-Performance/Count:
-  Description: >-
-                  Use `count` instead of `{select,find_all,filter,reject}...{size,count,length}`.
-  # This cop has known compatibility issues with `ActiveRecord` and other
-  # frameworks. ActiveRecord's `count` ignores the block that is passed to it.
-  # For more information, see the documentation in the cop itself.
-  SafeAutoCorrect: false
-  Enabled: true
-  VersionAdded: '0.31'
-  VersionChanged: '1.8'
-
-Performance/DeletePrefix:
-  Description: 'Use `delete_prefix` instead of `gsub`.'
-  Enabled: true
-  Safe: false
-  SafeMultiline: true
-  VersionAdded: '1.6'
-  VersionChanged: '1.11'
-
-Performance/DeleteSuffix:
-  Description: 'Use `delete_suffix` instead of `gsub`.'
-  Enabled: true
-  Safe: false
-  SafeMultiline: true
-  VersionAdded: '1.6'
-  VersionChanged: '1.11'
-
-Performance/Detect:
-  Description: >-
-                  Use `detect` instead of `select.first`, `find_all.first`, `filter.first`,
-                  `select.last`, `find_all.last`, and `filter.last`.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code'
-  # This cop has known compatibility issues with `ActiveRecord` and other
-  # frameworks. `ActiveRecord` does not implement a `detect` method and `find`
-  # has its own meaning. Correcting `ActiveRecord` methods with this cop
-  # should be considered unsafe.
-  SafeAutoCorrect: false
-  Enabled: true
-  VersionAdded: '0.30'
-  VersionChanged: '1.8'
-
-Performance/DoubleStartEndWith:
-  Description: >-
-                  Use `str.{start,end}_with?(x, ..., y, ...)`
-                  instead of `str.{start,end}_with?(x, ...) || str.{start,end}_with?(y, ...)`.
-  Enabled: true
-  VersionAdded: '0.36'
-  VersionChanged: '0.48'
-  # Used to check for `starts_with?` and `ends_with?`.
-  # These methods are defined by Active Support.
-  IncludeActiveSupportAliases: false
-
-Performance/EndWith:
-  Description: 'Use `end_with?` instead of a regex match anchored to the end of a string.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end'
-  # This will change to a new method call which isn't guaranteed to be on the
-  # object. Switching these methods has to be done with knowledge of the types
-  # of the variables which rubocop doesn't have.
-  SafeAutoCorrect: false
-  Enabled: true
-  SafeMultiline: true
-  VersionAdded: '0.36'
-  VersionChanged: '1.10'
-
-Performance/FixedSize:
-  Description: 'Do not compute the size of statically sized objects except in constants.'
-  Enabled: true
-  VersionAdded: '0.35'
-
-Performance/FlatMap:
-  Description: >-
-                  Use `Enumerable#flat_map`
-                  instead of `Enumerable#map...Array#flatten(1)`
-                  or `Enumerable#collect..Array#flatten(1)`.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerablemaparrayflatten-vs-enumerableflat_map-code'
-  Enabled: true
-  VersionAdded: '0.30'
-  EnabledForFlattenWithoutParams: false
-  # If enabled, this cop will warn about usages of
-  # `flatten` being called without any parameters.
-  # This can be dangerous since `flat_map` will only flatten 1 level, and
-  # `flatten` without any parameters can flatten multiple levels.
-
-Performance/InefficientHashSearch:
-  Description: 'Use `key?` or `value?` instead of `keys.include?` or `values.include?`.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#hashkey-instead-of-hashkeysinclude-code'
-  Enabled: true
-  VersionAdded: '0.56'
-  Safe: false
-
-Performance/IoReadlines:
-  Description: 'Use `IO.each_line` (`IO#each_line`) instead of `IO.readlines` (`IO#readlines`).'
-  Reference: 'https://docs.gitlab.com/ee/development/performance.html#reading-from-files-and-other-data-sources'
-  Enabled: false
-  VersionAdded: '1.7'
-
-Performance/MapCompact:
-  Description: 'Use `filter_map` instead of `collection.map(&:do_something).compact`.'
-  Enabled: pending
-  SafeAutoCorrect: false
-  VersionAdded: '1.11'
-
-Performance/MethodObjectAsBlock:
-  Description: 'Use block explicitly instead of block-passing a method object.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#normal-way-to-apply-method-vs-method-code'
-  Enabled: pending
-  VersionAdded: '1.9'
-
-Performance/OpenStruct:
-  Description: 'Use `Struct` instead of `OpenStruct`.'
-  Enabled: false
-  VersionAdded: '0.61'
-  Safe: false
-
-Performance/RangeInclude:
-  Description: 'Use `Range#cover?` instead of `Range#include?` (or `Range#member?`).'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#cover-vs-include-code'
-  Enabled: true
-  VersionAdded: '0.36'
-  VersionChanged: '1.7'
-  Safe: false
-
-Performance/RedundantBlockCall:
-  Description: 'Use `yield` instead of `block.call`.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#proccall-and-block-arguments-vs-yieldcode'
-  Enabled: true
-  VersionAdded: '0.36'
-
-Performance/RedundantEqualityComparisonBlock:
-  Description: >-
-                  Checks for uses `Enumerable#all?`, `Enumerable#any?`, `Enumerable#one?`,
-                  or `Enumerable#none?` are compared with `===` or similar methods in block.
-  Reference: 'https://github.com/rails/rails/pull/41363'
-  Enabled: pending
-  Safe: false
-  VersionAdded: '1.10'
-
-Performance/RedundantMatch:
-  Description: >-
-                  Use `=~` instead of `String#match` or `Regexp#match` in a context where the
-                  returned `MatchData` is not needed.
-  Enabled: true
-  VersionAdded: '0.36'
-
-Performance/RedundantMerge:
-  Description: 'Use Hash#[]=, rather than Hash#merge! with a single key-value pair.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#hashmerge-vs-hash-code'
-  Enabled: true
-  Safe: false
-  VersionAdded: '0.36'
-  VersionChanged: '1.11'
-  # Max number of key-value pairs to consider an offense
-  MaxKeyValuePairs: 2
-
-Performance/RedundantSortBlock:
-  Description: 'Use `sort` instead of `sort { |a, b| a <=> b }`.'
-  Enabled: 'pending'
-  VersionAdded: '1.7'
-
-Performance/RedundantSplitRegexpArgument:
-  Description: 'Identifies places where `split` argument can be replaced from a deterministic regexp to a string.'
-  Enabled: pending
-  VersionAdded: '1.10'
-
-Performance/RedundantStringChars:
-  Description: 'Checks for redundant `String#chars`.'
-  Enabled: 'pending'
-  VersionAdded: '1.7'
-
-Performance/RegexpMatch:
-  Description: >-
-                  Use `match?` instead of `Regexp#match`, `String#match`, `Symbol#match`,
-                  `Regexp#===`, or `=~` when `MatchData` is not used.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#regexp-vs-stringmatch-vs-string-vs-stringmatch-code-'
-  Enabled: true
-  VersionAdded: '0.47'
-
-Performance/ReverseEach:
-  Description: 'Use `reverse_each` instead of `reverse.each`.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerablereverseeach-vs-enumerablereverse_each-code'
-  Enabled: true
-  VersionAdded: '0.30'
-
-Performance/ReverseFirst:
-  Description: 'Use `last(n).reverse` instead of `reverse.first(n)`.'
-  Enabled: 'pending'
-  VersionAdded: '1.7'
-
-Performance/SelectMap:
-  Description: 'Use `filter_map` instead of `ary.select(&:foo).map(&:bar)`.'
-  Enabled: false
-  VersionAdded: '1.11'
-
-Performance/Size:
-  Description: >-
-                  Use `size` instead of `count` for counting
-                  the number of elements in `Array` and `Hash`.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#arraylength-vs-arraysize-vs-arraycount-code'
-  Enabled: true
-  VersionAdded: '0.30'
-
-Performance/SortReverse:
-  Description: 'Use `sort.reverse` instead of `sort { |a, b| b <=> a }`.'
-  Enabled: 'pending'
-  VersionAdded: '1.7'
-
-Performance/Squeeze:
-  Description: "Use `squeeze('a')` instead of `gsub(/a+/, 'a')`."
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#remove-extra-spaces-or-other-contiguous-characters-code'
-  Enabled: 'pending'
-  VersionAdded: '1.7'
-
-Performance/StartWith:
-  Description: 'Use `start_with?` instead of a regex match anchored to the beginning of a string.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end'
-  # This will change to a new method call which isn't guaranteed to be on the
-  # object. Switching these methods has to be done with knowledge of the types
-  # of the variables which rubocop doesn't have.
-  SafeAutoCorrect: false
-  Enabled: true
-  SafeMultiline: true
-  VersionAdded: '0.36'
-  VersionChanged: '1.10'
-
-Performance/StringIdentifierArgument:
-  Description: 'Use symbol identifier argument instead of string identifier argument.'
-  Enabled: pending
-  VersionAdded: '1.13'
-
-Performance/StringInclude:
-  Description: 'Use `String#include?` instead of a regex match with literal-only pattern.'
-  Enabled: 'pending'
-  SafeAutoCorrect: false
-  VersionAdded: '1.7'
-  VersionChanged: '1.12'
-
-Performance/StringReplacement:
-  Description: >-
-                  Use `tr` instead of `gsub` when you are replacing the same
-                  number of characters. Use `delete` instead of `gsub` when
-                  you are deleting characters.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringgsub-vs-stringtr-code'
-  Enabled: true
-  VersionAdded: '0.33'
-
-Performance/Sum:
-  Description: 'Use `sum` instead of a custom array summation.'
-  SafeAutoCorrect: false
-  Reference: 'https://blog.bigbinary.com/2016/11/02/ruby-2-4-introduces-enumerable-sum.html'
-  Enabled: 'pending'
-  VersionAdded: '1.8'
-  VersionChanged: '1.13'
-  OnlySumOrWithInitialValue: false
-
-Performance/TimesMap:
-  Description: 'Checks for .times.map calls.'
-  Enabled: true
-  # See https://github.com/rubocop/rubocop/issues/4658
-  SafeAutoCorrect: false
-  VersionAdded: '0.36'
-  VersionChanged: '1.13'
-
-Performance/UnfreezeString:
-  Description: 'Use unary plus to get an unfrozen string literal.'
-  Enabled: true
-  SafeAutoCorrect: false
-  VersionAdded: '0.50'
-  VersionChanged: '1.9'
-
-Performance/UriDefaultParser:
-  Description: 'Use `URI::DEFAULT_PARSER` instead of `URI::Parser.new`.'
-  Enabled: true
-  VersionAdded: '0.50'
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/config/obsoletion.yml b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/config/obsoletion.yml
deleted file mode 100644
index 2aade6c4135d1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/config/obsoletion.yml
+++ /dev/null
@@ -1,7 +0,0 @@
-#
-# Configuration for obsoletion.
-#
-# See: https://docs.rubocop.org/rubocop/extensions.html#config-obsoletions
-#
-extracted:
-  Performance/*: ~
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop-performance.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop-performance.rb
deleted file mode 100644
index d7865b5453bb3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop-performance.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubocop'
-
-require_relative 'rubocop/performance'
-require_relative 'rubocop/performance/version'
-require_relative 'rubocop/performance/inject'
-
-RuboCop::Performance::Inject.defaults!
-
-require_relative 'rubocop/cop/performance_cops'
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/mixin/regexp_metacharacter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/mixin/regexp_metacharacter.rb
deleted file mode 100644
index e1f543b8c59ef..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/mixin/regexp_metacharacter.rb
+++ /dev/null
@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for handling regexp metacharacters.
-    module RegexpMetacharacter
-      private
-
-      def literal_at_start?(regexp)
-        return true if literal_at_start_with_backslash_a?(regexp)
-
-        !safe_multiline? && literal_at_start_with_caret?(regexp)
-      end
-
-      def literal_at_end?(regexp)
-        return true if literal_at_end_with_backslash_z?(regexp)
-
-        !safe_multiline? && literal_at_end_with_dollar?(regexp)
-      end
-
-      def literal_at_start_with_backslash_a?(regex_str)
-        # is this regexp 'literal' in the sense of only matching literal
-        # chars, rather than using metachars like `.` and `*` and so on?
-        # also, is it anchored at the start of the string?
-        # (tricky: \s, \d, and so on are metacharacters, but other characters
-        #  escaped with a slash are just literals. LITERAL_REGEX takes all
-        #  that into account.)
-        /\A\\A(?:#{Util::LITERAL_REGEX})+\z/o.match?(regex_str)
-      end
-
-      def literal_at_start_with_caret?(regex_str)
-        # is this regexp 'literal' in the sense of only matching literal
-        # chars, rather than using metachars like `.` and `*` and so on?
-        # also, is it anchored at the start of the string?
-        # (tricky: \s, \d, and so on are metacharacters, but other characters
-        #  escaped with a slash are just literals. LITERAL_REGEX takes all
-        #  that into account.)
-        /\A\^(?:#{Util::LITERAL_REGEX})+\z/o.match?(regex_str)
-      end
-
-      def literal_at_end_with_backslash_z?(regex_str)
-        # is this regexp 'literal' in the sense of only matching literal
-        # chars, rather than using metachars like . and * and so on?
-        # also, is it anchored at the end of the string?
-        /\A(?:#{Util::LITERAL_REGEX})+\\z\z/o.match?(regex_str)
-      end
-
-      def literal_at_end_with_dollar?(regex_str)
-        # is this regexp 'literal' in the sense of only matching literal
-        # chars, rather than using metachars like . and * and so on?
-        # also, is it anchored at the end of the string?
-        /\A(?:#{Util::LITERAL_REGEX})+\$\z/o.match?(regex_str)
-      end
-
-      def drop_start_metacharacter(regexp_string)
-        if regexp_string.start_with?('\\A')
-          regexp_string[2..] # drop `\A` anchor
-        else
-          regexp_string[1..] # drop `^` anchor
-        end
-      end
-
-      def drop_end_metacharacter(regexp_string)
-        if regexp_string.end_with?('\\z')
-          regexp_string.chomp('\z') # drop `\z` anchor
-        else
-          regexp_string.chop # drop `$` anchor
-        end
-      end
-
-      def safe_multiline?
-        cop_config.fetch('SafeMultiline', true)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/mixin/sort_block.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/mixin/sort_block.rb
deleted file mode 100644
index 8a287b9c4d884..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/mixin/sort_block.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for cops checking `Enumerable#sort` blocks.
-    module SortBlock
-      extend NodePattern::Macros
-      include RangeHelp
-
-      def_node_matcher :sort_with_block?, <<~PATTERN
-        (block
-          $(send _ :sort)
-          (args (arg $_a) (arg $_b))
-          $send)
-      PATTERN
-
-      def_node_matcher :replaceable_body?, <<~PATTERN
-        (send (lvar %1) :<=> (lvar %2))
-      PATTERN
-
-      private
-
-      def sort_range(send, node)
-        range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/ancestors_include.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/ancestors_include.rb
deleted file mode 100644
index a65db86b0cd7b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/ancestors_include.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies usages of `ancestors.include?` and change them to use `<=` instead.
-      #
-      # @safety
-      #   This cop is unsafe because it can't tell whether the receiver is a class or an object.
-      #   e.g. the false positive was for `Nokogiri::XML::Node#ancestors`.
-      #
-      # @example
-      #   # bad
-      #   A.ancestors.include?(B)
-      #
-      #   # good
-      #   A <= B
-      #
-      class AncestorsInclude < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `<=` instead of `ancestors.include?`.'
-        RESTRICT_ON_SEND = %i[include?].freeze
-
-        def_node_matcher :ancestors_include_candidate?, <<~PATTERN
-          (send (send $_subclass :ancestors) :include? $_superclass)
-        PATTERN
-
-        def on_send(node)
-          return unless (subclass, superclass = ancestors_include_candidate?(node))
-          return if subclass && !subclass.const_type?
-
-          add_offense(range(node)) do |corrector|
-            subclass_source = subclass ? subclass.source : 'self'
-
-            corrector.replace(node, "#{subclass_source} <= #{superclass.source}")
-          end
-        end
-
-        private
-
-        def range(node)
-          location_of_ancestors = node.children[0].loc.selector.begin_pos
-          end_location = node.loc.selector.end_pos
-
-          range_between(location_of_ancestors, end_location)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb
deleted file mode 100644
index a81b40f132f14..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb
+++ /dev/null
@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where slicing arrays with semi-infinite ranges
-      # can be replaced by `Array#take` and `Array#drop`.
-      # This cop was created due to a mistake in microbenchmark and hence is disabled by default.
-      # Refer https://github.com/rubocop/rubocop-performance/pull/175#issuecomment-731892717
-      #
-      # @safety
-      #   This cop is unsafe for string slices because strings do not have `#take` and `#drop` methods.
-      #
-      # @example
-      #   # bad
-      #   array[..2]
-      #   array[...2]
-      #   array[2..]
-      #   array[2...]
-      #   array.slice(..2)
-      #
-      #   # good
-      #   array.take(3)
-      #   array.take(2)
-      #   array.drop(2)
-      #   array.drop(2)
-      #   array.take(3)
-      #
-      class ArraySemiInfiniteRangeSlice < Base
-        include RangeHelp
-        extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.7
-
-        MSG = 'Use `%<prefer>s` instead of `%<current>s` with semi-infinite range.'
-
-        SLICE_METHODS = Set[:[], :slice].freeze
-        RESTRICT_ON_SEND = SLICE_METHODS
-
-        def_node_matcher :endless_range_slice?, <<~PATTERN
-          (send $_ $%SLICE_METHODS $#endless_range?)
-        PATTERN
-
-        def_node_matcher :endless_range?, <<~PATTERN
-          {
-            ({irange erange} nil? (int positive?))
-            ({irange erange} (int positive?) nil?)
-          }
-        PATTERN
-
-        def on_send(node)
-          endless_range_slice?(node) do |receiver, method_name, range_node|
-            prefer = range_node.begin ? :drop : :take
-            message = format(MSG, prefer: prefer, current: method_name)
-
-            add_offense(node, message: message) do |corrector|
-              corrector.replace(node, correction(receiver, range_node))
-            end
-          end
-        end
-
-        private
-
-        def correction(receiver, range_node)
-          method_call = if range_node.begin
-                          "drop(#{range_node.begin.value})"
-                        elsif range_node.irange_type?
-                          "take(#{range_node.end.value + 1})"
-                        else
-                          "take(#{range_node.end.value})"
-                        end
-
-          "#{receiver.source}.#{method_call}"
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/big_decimal_with_numeric_argument.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/big_decimal_with_numeric_argument.rb
deleted file mode 100644
index d41d38c397ac9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/big_decimal_with_numeric_argument.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where numeric argument to BigDecimal should be
-      # converted to string. Initializing from String is faster
-      # than from Numeric for BigDecimal.
-      #
-      # @example
-      #   # bad
-      #   BigDecimal(1, 2)
-      #   4.to_d(6)
-      #   BigDecimal(1.2, 3, exception: true)
-      #   4.5.to_d(6, exception: true)
-      #
-      #   # good
-      #   BigDecimal('1', 2)
-      #   BigDecimal('4', 6)
-      #   BigDecimal('1.2', 3, exception: true)
-      #   BigDecimal('4.5', 6, exception: true)
-      #
-      class BigDecimalWithNumericArgument < Base
-        extend AutoCorrector
-
-        MSG = 'Convert numeric literal to string and pass it to `BigDecimal`.'
-        RESTRICT_ON_SEND = %i[BigDecimal to_d].freeze
-
-        def_node_matcher :big_decimal_with_numeric_argument?, <<~PATTERN
-          (send nil? :BigDecimal $numeric_type? ...)
-        PATTERN
-
-        def_node_matcher :to_d?, <<~PATTERN
-          (send [!nil? $numeric_type?] :to_d ...)
-        PATTERN
-
-        def on_send(node)
-          if (numeric = big_decimal_with_numeric_argument?(node))
-            add_offense(numeric.source_range) do |corrector|
-              corrector.wrap(numeric, "'", "'")
-            end
-          elsif (numeric_to_d = to_d?(node))
-            add_offense(numeric_to_d.source_range) do |corrector|
-              big_decimal_args = node
-                                 .arguments
-                                 .map(&:source)
-                                 .unshift("'#{numeric_to_d.source}'")
-                                 .join(', ')
-
-              corrector.replace(node, "BigDecimal(#{big_decimal_args})")
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/bind_call.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/bind_call.rb
deleted file mode 100644
index 0e97597ba20f0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/bind_call.rb
+++ /dev/null
@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # In Ruby 2.7, `UnboundMethod#bind_call` has been added.
-      #
-      # This cop identifies places where `bind(obj).call(args, ...)`
-      # can be replaced by `bind_call(obj, args, ...)`.
-      #
-      # The `bind_call(obj, args, ...)` method is faster than
-      # `bind(obj).call(args, ...)`.
-      #
-      # @example
-      #   # bad
-      #   umethod.bind(obj).call(foo, bar)
-      #   umethod.bind(obj).(foo, bar)
-      #
-      #   # good
-      #   umethod.bind_call(obj, foo, bar)
-      #
-      class BindCall < Base
-        include RangeHelp
-        extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.7
-
-        MSG = 'Use `bind_call(%<bind_arg>s%<comma>s%<call_args>s)` ' \
-              'instead of `bind(%<bind_arg>s).call(%<call_args>s)`.'
-        RESTRICT_ON_SEND = %i[call].freeze
-
-        def_node_matcher :bind_with_call_method?, <<~PATTERN
-          (send
-            $(send
-              _ :bind
-              $(...)) :call
-            $...)
-        PATTERN
-
-        def on_send(node)
-          return unless (receiver, bind_arg, call_args_node = bind_with_call_method?(node))
-
-          range = correction_range(receiver, node)
-          call_args = build_call_args(call_args_node)
-          message = message(bind_arg.source, call_args)
-
-          add_offense(range, message: message) do |corrector|
-            call_args = ", #{call_args}" unless call_args.empty?
-
-            replacement_method = "bind_call(#{bind_arg.source}#{call_args})"
-
-            corrector.replace(range, replacement_method)
-          end
-        end
-
-        private
-
-        def message(bind_arg, call_args)
-          comma = call_args.empty? ? '' : ', '
-
-          format(MSG, bind_arg: bind_arg, comma: comma, call_args: call_args)
-        end
-
-        def correction_range(receiver, node)
-          location_of_bind = receiver.loc.selector.begin_pos
-          location_of_call = node.source_range.end.end_pos
-
-          range_between(location_of_bind, location_of_call)
-        end
-
-        def build_call_args(call_args_node)
-          call_args_node.map(&:source).join(', ')
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/block_given_with_explicit_block.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/block_given_with_explicit_block.rb
deleted file mode 100644
index 4c717d27743c2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/block_given_with_explicit_block.rb
+++ /dev/null
@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies unnecessary use of a `block_given?` where explicit check
-      # of block argument would suffice.
-      #
-      # @example
-      #   # bad
-      #   def method(&block)
-      #     do_something if block_given?
-      #   end
-      #
-      #   # good
-      #   def method(&block)
-      #     do_something if block
-      #   end
-      #
-      #   # good - block is reassigned
-      #   def method(&block)
-      #     block ||= -> { do_something }
-      #     warn "Using default ..." unless block_given?
-      #     # ...
-      #   end
-      #
-      class BlockGivenWithExplicitBlock < Base
-        extend AutoCorrector
-
-        RESTRICT_ON_SEND = %i[block_given?].freeze
-        MSG = 'Check block argument explicitly instead of using `block_given?`.'
-
-        def_node_matcher :reassigns_block_arg?, '`(lvasgn %1 ...)'
-
-        def on_send(node)
-          def_node = node.each_ancestor(:def, :defs).first
-          return unless def_node
-
-          block_arg = def_node.arguments.find(&:blockarg_type?)
-          return unless block_arg
-          return unless (block_arg_name = block_arg.loc.name)
-
-          block_arg_name = block_arg_name.source.to_sym
-          return if reassigns_block_arg?(def_node, block_arg_name)
-
-          add_offense(node) do |corrector|
-            corrector.replace(node, block_arg_name)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/caller.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/caller.rb
deleted file mode 100644
index bba8758a6b509..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/caller.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where `caller[n]` can be replaced by `caller(n..n).first`.
-      #
-      # @example
-      #   # bad
-      #   caller[1]
-      #   caller.first
-      #   caller_locations[1]
-      #   caller_locations.first
-      #
-      #   # good
-      #   caller(2..2).first
-      #   caller(1..1).first
-      #   caller_locations(2..2).first
-      #   caller_locations(1..1).first
-      class Caller < Base
-        extend AutoCorrector
-
-        MSG = 'Use `%<preferred_method>s` instead of `%<current_method>s`.'
-        RESTRICT_ON_SEND = %i[first []].freeze
-
-        def_node_matcher :slow_caller?, <<~PATTERN
-          {
-            (send nil? {:caller :caller_locations})
-            (send nil? {:caller :caller_locations} int)
-          }
-        PATTERN
-
-        def_node_matcher :caller_with_scope_method?, <<~PATTERN
-          {
-            (send #slow_caller? :first)
-            (send #slow_caller? :[] int)
-          }
-        PATTERN
-
-        def on_send(node)
-          return unless caller_with_scope_method?(node)
-
-          method_name = node.receiver.method_name
-          caller_arg = node.receiver.first_argument
-          n = caller_arg ? int_value(caller_arg) : 1
-          if node.method?(:[])
-            m = int_value(node.first_argument)
-            n += m
-          end
-
-          preferred_method = "#{method_name}(#{n}..#{n}).first"
-
-          message = format(MSG, preferred_method: preferred_method, current_method: node.source)
-          add_offense(node, message: message) do |corrector|
-            corrector.replace(node, preferred_method)
-          end
-        end
-
-        private
-
-        def int_value(node)
-          node.children[0]
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb
deleted file mode 100644
index 20ca76efbc729..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb
+++ /dev/null
@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Reordering `when` conditions with a splat to the end
-      # of the `when` branches can improve performance.
-      #
-      # Ruby has to allocate memory for the splat expansion every time
-      # that the `case` `when` statement is run. Since Ruby does not support
-      # fall through inside of `case` `when`, like some other languages do,
-      # the order of the `when` branches should not matter. By placing any
-      # splat expansions at the end of the list of `when` branches we will
-      # reduce the number of times that memory has to be allocated for
-      # the expansion. The exception to this is if multiple of your `when`
-      # conditions can be true for any given condition. A likely scenario for
-      # this defining a higher level when condition to override a condition
-      # that is inside of the splat expansion.
-      #
-      # @safety
-      #   This cop is not unsafe autocorrection because it is not a guaranteed
-      #   performance improvement. If the data being processed by the `case` condition is
-      #   normalized in a manner that favors hitting a condition in the splat expansion,
-      #   it is possible that moving the splat condition to the end will use more memory,
-      #   and run slightly slower.
-      #   See for more details: https://github.com/rubocop/rubocop/pull/6163
-      #
-      # @example
-      #   # bad
-      #   case foo
-      #   when *condition
-      #     bar
-      #   when baz
-      #     foobar
-      #   end
-      #
-      #   case foo
-      #   when *[1, 2, 3, 4]
-      #     bar
-      #   when 5
-      #     baz
-      #   end
-      #
-      #   # good
-      #   case foo
-      #   when baz
-      #     foobar
-      #   when *condition
-      #     bar
-      #   end
-      #
-      #   case foo
-      #   when 1, 2, 3, 4
-      #     bar
-      #   when 5
-      #     baz
-      #   end
-      class CaseWhenSplat < Base
-        include Alignment
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Reordering `when` conditions with a splat to the end of the `when` branches can improve performance.'
-        ARRAY_MSG = 'Pass the contents of array literals directly to `when` conditions.'
-
-        def on_case(case_node)
-          when_conditions = case_node.when_branches.flat_map(&:conditions)
-
-          splat_offenses(when_conditions).reverse_each do |condition|
-            next if ignored_node?(condition.parent)
-
-            ignore_node(condition.parent)
-            variable, = *condition
-            message = variable.array_type? ? ARRAY_MSG : MSG
-            add_offense(range(condition), message: message) do |corrector|
-              autocorrect(corrector, condition.parent)
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, when_node)
-          if needs_reorder?(when_node)
-            reorder_condition(corrector, when_node)
-          else
-            inline_fix_branch(corrector, when_node)
-          end
-        end
-
-        def range(node)
-          node.parent.loc.keyword.join(node.source_range)
-        end
-
-        def replacement(conditions)
-          reordered = conditions.partition(&:splat_type?).reverse
-          reordered.flatten.map(&:source).join(', ')
-        end
-
-        def inline_fix_branch(corrector, when_node)
-          conditions = when_node.conditions
-          range = range_between(conditions[0].loc.expression.begin_pos,
-                                conditions[-1].loc.expression.end_pos)
-
-          corrector.replace(range, replacement(conditions))
-        end
-
-        def reorder_condition(corrector, when_node)
-          when_branches = when_node.parent.when_branches
-
-          return if when_branches.one?
-
-          corrector.remove(when_branch_range(when_node))
-          corrector.insert_after(when_branches.last.source_range,
-                                 reordering_correction(when_node))
-        end
-
-        def reordering_correction(when_node)
-          new_condition = replacement(when_node.conditions)
-
-          if same_line?(when_node, when_node.body)
-            new_condition_with_then(when_node, new_condition)
-          else
-            new_branch_without_then(when_node, new_condition)
-          end
-        end
-
-        def when_branch_range(when_node)
-          next_branch =
-            when_node.parent.when_branches[when_node.branch_index + 1]
-
-          range_between(when_node.source_range.begin_pos,
-                        next_branch.source_range.begin_pos)
-        end
-
-        def new_condition_with_then(node, new_condition)
-          "\n#{indent_for(node)}when #{new_condition} then #{node.body.source}"
-        end
-
-        def new_branch_without_then(node, new_condition)
-          "\n#{indent_for(node)}when #{new_condition}\n#{indent_for(node.body)}#{node.body.source}"
-        end
-
-        def indent_for(node)
-          ' ' * node.loc.column
-        end
-
-        def splat_offenses(when_conditions)
-          found_non_splat = false
-
-          offenses = when_conditions.reverse.map do |condition|
-            found_non_splat ||= non_splat?(condition)
-
-            next if non_splat?(condition)
-
-            condition if found_non_splat
-          end
-
-          offenses.compact
-        end
-
-        def non_splat?(condition)
-          variable, = *condition
-
-          (condition.splat_type? && variable.array_type?) ||
-            !condition.splat_type?
-        end
-
-        def needs_reorder?(when_node)
-          following_branches =
-            when_node.parent.when_branches[(when_node.branch_index + 1)..]
-
-          following_branches.any? do |when_branch|
-            when_branch.conditions.any? do |condition|
-              non_splat?(condition)
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/casecmp.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/casecmp.rb
deleted file mode 100644
index 29471c7d59a42..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/casecmp.rb
+++ /dev/null
@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where a case-insensitive string comparison
-      # can better be implemented using `casecmp`.
-      #
-      # @safety
-      #   This cop is unsafe because `String#casecmp` and `String#casecmp?` behave
-      #   differently when using Non-ASCII characters.
-      #
-      # @example
-      #   # bad
-      #   str.downcase == 'abc'
-      #   str.upcase.eql? 'ABC'
-      #   'abc' == str.downcase
-      #   'ABC'.eql? str.upcase
-      #   str.downcase == str.downcase
-      #
-      #   # good
-      #   str.casecmp('ABC').zero?
-      #   'abc'.casecmp(str).zero?
-      class Casecmp < Base
-        extend AutoCorrector
-
-        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
-        RESTRICT_ON_SEND = %i[== eql? !=].freeze
-        CASE_METHODS = %i[downcase upcase].freeze
-
-        def_node_matcher :downcase_eq, <<~PATTERN
-          (send
-            $(send _ ${:downcase :upcase})
-            ${:== :eql? :!=}
-            ${str (send _ {:downcase :upcase} ...) (begin str)})
-        PATTERN
-
-        def_node_matcher :eq_downcase, <<~PATTERN
-          (send
-            {str (send _ {:downcase :upcase} ...) (begin str)}
-            ${:== :eql? :!=}
-            $(send _ ${:downcase :upcase}))
-        PATTERN
-
-        def_node_matcher :downcase_downcase, <<~PATTERN
-          (send
-            $(send _ ${:downcase :upcase})
-            ${:== :eql? :!=}
-            $(send _ ${:downcase :upcase}))
-        PATTERN
-
-        def on_send(node)
-          return unless downcase_eq(node) || eq_downcase(node)
-          return unless (parts = take_method_apart(node))
-
-          _receiver, method, arg, variable = parts
-          good_method = build_good_method(method, arg, variable)
-
-          message = format(MSG, good: good_method, bad: node.source)
-          add_offense(node, message: message) do |corrector|
-            autocorrect(corrector, node, good_method)
-          end
-        end
-
-        private
-
-        def take_method_apart(node)
-          if downcase_downcase(node)
-            receiver, method, rhs = *node
-            arg, = *rhs
-          elsif downcase_eq(node)
-            receiver, method, arg = *node
-          elsif eq_downcase(node)
-            arg, method, receiver = *node
-          else
-            return
-          end
-
-          variable, = *receiver
-
-          [receiver, method, arg, variable]
-        end
-
-        def autocorrect(corrector, node, replacement)
-          corrector.replace(node, replacement)
-        end
-
-        def build_good_method(method, arg, variable)
-          bang = method == :!= ? '!' : ''
-
-          # We want resulting call to be parenthesized
-          # if arg already includes one or more sets of parens, don't add more
-          # or if method call already used parens, again, don't add more
-          if arg.send_type? || !parentheses?(arg)
-            "#{bang}#{variable.source}.casecmp(#{arg.source}).zero?"
-          else
-            "#{bang}#{variable.source}.casecmp#{arg.source}.zero?"
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/chain_array_allocation.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/chain_array_allocation.rb
deleted file mode 100644
index 840ecf5cf3c96..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/chain_array_allocation.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies usages of `array.compact.flatten.map { |x| x.downcase }`.
-      # Each of these methods (`compact`, `flatten`, `map`) will generate a new intermediate array
-      # that is promptly thrown away. Instead it is faster to mutate when we know it's safe.
-      #
-      # @example
-      #   # bad
-      #   array = ["a", "b", "c"]
-      #   array.compact.flatten.map { |x| x.downcase }
-      #
-      #   # good
-      #   array = ["a", "b", "c"]
-      #   array.compact!
-      #   array.flatten!
-      #   array.map! { |x| x.downcase }
-      #   array
-      class ChainArrayAllocation < Base
-        include RangeHelp
-
-        # These methods return a new array but only sometimes. They must be
-        # called with an argument. For example:
-        #
-        #   [1,2].first    # => 1
-        #   [1,2].first(1) # => [1]
-        #
-        RETURN_NEW_ARRAY_WHEN_ARGS = %i[first last pop sample shift].to_set.freeze
-
-        # These methods return a new array only when called without a block.
-        RETURNS_NEW_ARRAY_WHEN_NO_BLOCK = %i[zip product].to_set.freeze
-
-        # These methods ALWAYS return a new array
-        # after they're called it's safe to mutate the the resulting array
-        ALWAYS_RETURNS_NEW_ARRAY = %i[* + - collect compact drop
-                                      drop_while flatten map reject
-                                      reverse rotate select shuffle sort
-                                      take take_while transpose uniq
-                                      values_at |].to_set.freeze
-
-        # These methods have a mutation alternative. For example :collect
-        # can be called as :collect!
-        HAS_MUTATION_ALTERNATIVE = %i[collect compact flatten map reject
-                                      reverse rotate select shuffle sort uniq].to_set.freeze
-
-        RETURNS_NEW_ARRAY = (ALWAYS_RETURNS_NEW_ARRAY + RETURNS_NEW_ARRAY_WHEN_NO_BLOCK).freeze
-
-        MSG = 'Use unchained `%<method>s` and `%<second_method>s!` ' \
-              '(followed by `return array` if required) instead of chaining ' \
-              '`%<method>s...%<second_method>s`.'
-
-        def_node_matcher :chain_array_allocation?, <<~PATTERN
-          (send {
-            (send _ $%RETURN_NEW_ARRAY_WHEN_ARGS {int lvar ivar cvar gvar send})
-            (block (send _ $%ALWAYS_RETURNS_NEW_ARRAY) ...)
-            (send _ $%RETURNS_NEW_ARRAY ...)
-          } $%HAS_MUTATION_ALTERNATIVE ...)
-        PATTERN
-
-        def on_send(node)
-          chain_array_allocation?(node) do |fm, sm|
-            return if node.each_descendant(:send).any? { |descendant| descendant.method?(:lazy) }
-
-            range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
-
-            add_offense(range, message: format(MSG, method: fm, second_method: sm))
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb
deleted file mode 100644
index 50b0bbc20f38e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb
+++ /dev/null
@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where Array and Hash literals are used within loops.
-      # It is better to extract them into a local variable or constant
-      # to avoid unnecessary allocations on each iteration.
-      #
-      # You can set the minimum number of elements to consider
-      # an offense with `MinSize`.
-      #
-      # @example
-      #   # bad
-      #   users.select do |user|
-      #     %i[superadmin admin].include?(user.role)
-      #   end
-      #
-      #   # good
-      #   admin_roles = %i[superadmin admin]
-      #   users.select do |user|
-      #     admin_roles.include?(user.role)
-      #   end
-      #
-      #   # good
-      #   ADMIN_ROLES = %i[superadmin admin]
-      #   ...
-      #   users.select do |user|
-      #     ADMIN_ROLES.include?(user.role)
-      #   end
-      #
-      class CollectionLiteralInLoop < Base
-        MSG = 'Avoid immutable %<literal_class>s literals in loops. ' \
-              'It is better to extract it into a local variable or a constant.'
-
-        POST_CONDITION_LOOP_TYPES = %i[while_post until_post].freeze
-        LOOP_TYPES = (POST_CONDITION_LOOP_TYPES + %i[while until for]).freeze
-
-        ENUMERABLE_METHOD_NAMES = (Enumerable.instance_methods + [:each]).to_set.freeze
-        NONMUTATING_ARRAY_METHODS = %i[& * + - <=> == [] all? any? assoc at
-                                       bsearch bsearch_index collect combination
-                                       compact count cycle deconstruct difference dig
-                                       drop drop_while each each_index empty? eql?
-                                       fetch filter find_index first flatten hash
-                                       include? index inspect intersection join
-                                       last length map max min minmax none? one? pack
-                                       permutation product rassoc reject
-                                       repeated_combination repeated_permutation reverse
-                                       reverse_each rindex rotate sample select shuffle
-                                       size slice sort sum take take_while
-                                       to_a to_ary to_h to_s transpose union uniq
-                                       values_at zip |].freeze
-
-        ARRAY_METHODS = (ENUMERABLE_METHOD_NAMES | NONMUTATING_ARRAY_METHODS).to_set.freeze
-
-        NONMUTATING_HASH_METHODS = %i[< <= == > >= [] any? assoc compact dig
-                                      each each_key each_pair each_value empty?
-                                      eql? fetch fetch_values filter flatten has_key?
-                                      has_value? hash include? inspect invert key key?
-                                      keys? length member? merge rassoc rehash reject
-                                      select size slice to_a to_h to_hash to_proc to_s
-                                      transform_keys transform_values value? values values_at].freeze
-
-        HASH_METHODS = (ENUMERABLE_METHOD_NAMES | NONMUTATING_HASH_METHODS).to_set.freeze
-
-        def_node_matcher :kernel_loop?, <<~PATTERN
-          (block
-            (send {nil? (const nil? :Kernel)} :loop)
-            ...)
-        PATTERN
-
-        def_node_matcher :enumerable_loop?, <<~PATTERN
-          (block
-            (send $_ #enumerable_method? ...)
-            ...)
-        PATTERN
-
-        def on_send(node)
-          receiver, method, = *node.children
-          return unless check_literal?(receiver, method) && parent_is_loop?(receiver)
-
-          message = format(MSG, literal_class: literal_class(receiver))
-          add_offense(receiver, message: message)
-        end
-
-        private
-
-        def check_literal?(node, method)
-          !node.nil? &&
-            nonmutable_method_of_array_or_hash?(node, method) &&
-            node.children.size >= min_size &&
-            node.recursive_basic_literal?
-        end
-
-        def nonmutable_method_of_array_or_hash?(node, method)
-          (node.array_type? && ARRAY_METHODS.include?(method)) ||
-            (node.hash_type? && HASH_METHODS.include?(method))
-        end
-
-        def parent_is_loop?(node)
-          node.each_ancestor.any? { |ancestor| loop?(ancestor, node) }
-        end
-
-        def loop?(ancestor, node)
-          keyword_loop?(ancestor.type) ||
-            kernel_loop?(ancestor) ||
-            node_within_enumerable_loop?(node, ancestor)
-        end
-
-        def keyword_loop?(type)
-          LOOP_TYPES.include?(type)
-        end
-
-        def node_within_enumerable_loop?(node, ancestor)
-          enumerable_loop?(ancestor) do |receiver|
-            receiver != node && !receiver&.descendants&.include?(node)
-          end
-        end
-
-        def literal_class(node)
-          if node.array_type?
-            'Array'
-          elsif node.hash_type?
-            'Hash'
-          end
-        end
-
-        def enumerable_method?(method_name)
-          ENUMERABLE_METHOD_NAMES.include?(method_name)
-        end
-
-        def min_size
-          Integer(cop_config['MinSize'] || 1)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/compare_with_block.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/compare_with_block.rb
deleted file mode 100644
index cfbbb1de9bea0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/compare_with_block.rb
+++ /dev/null
@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where `sort { |a, b| a.foo <=> b.foo }`
-      # can be replaced by `sort_by(&:foo)`.
-      # This cop also checks `max` and `min` methods.
-      #
-      # @example
-      #   # bad
-      #   array.sort { |a, b| a.foo <=> b.foo }
-      #   array.max { |a, b| a.foo <=> b.foo }
-      #   array.min { |a, b| a.foo <=> b.foo }
-      #   array.sort { |a, b| a[:foo] <=> b[:foo] }
-      #
-      #   # good
-      #   array.sort_by(&:foo)
-      #   array.sort_by { |v| v.foo }
-      #   array.sort_by do |var|
-      #     var.foo
-      #   end
-      #   array.max_by(&:foo)
-      #   array.min_by(&:foo)
-      #   array.sort_by { |a| a[:foo] }
-      class CompareWithBlock < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `%<compare_method>s_by%<instead>s` instead of ' \
-              '`%<compare_method>s { |%<var_a>s, %<var_b>s| %<str_a>s ' \
-              '<=> %<str_b>s }`.'
-
-        def_node_matcher :compare?, <<~PATTERN
-          (block
-            $(send _ {:sort :min :max})
-            (args (arg $_a) (arg $_b))
-            $send)
-        PATTERN
-
-        def_node_matcher :replaceable_body?, <<~PATTERN
-          (send
-            (send (lvar %1) $_method $...)
-            :<=>
-            (send (lvar %2) _method $...))
-        PATTERN
-
-        def on_block(node)
-          compare?(node) do |send, var_a, var_b, body|
-            replaceable_body?(body, var_a, var_b) do |method, args_a, args_b|
-              return unless slow_compare?(method, args_a, args_b)
-
-              range = compare_range(send, node)
-
-              add_offense(range, message: message(send, method, var_a, var_b, args_a)) do |corrector|
-                replacement = if method == :[]
-                                "#{send.method_name}_by { |a| a[#{args_a.first.source}] }"
-                              else
-                                "#{send.method_name}_by(&:#{method})"
-                              end
-                corrector.replace(range, replacement)
-              end
-            end
-          end
-        end
-
-        private
-
-        def slow_compare?(method, args_a, args_b)
-          return false unless args_a == args_b
-
-          if method == :[]
-            return false unless args_a.size == 1
-
-            key = args_a.first
-            return false unless %i[sym str int].include?(key.type)
-          else
-            return false unless args_a.empty?
-          end
-          true
-        end
-
-        # rubocop:disable Metrics/MethodLength
-        def message(send, method, var_a, var_b, args)
-          compare_method = send.method_name
-          if method == :[]
-            key = args.first
-            instead = " { |a| a[#{key.source}] }"
-            str_a = "#{var_a}[#{key.source}]"
-            str_b = "#{var_b}[#{key.source}]"
-          else
-            instead = "(&:#{method})"
-            str_a = "#{var_a}.#{method}"
-            str_b = "#{var_b}.#{method}"
-          end
-          format(MSG, compare_method: compare_method,
-                      instead: instead,
-                      var_a: var_a,
-                      var_b: var_b,
-                      str_a: str_a,
-                      str_b: str_b)
-        end
-        # rubocop:enable Metrics/MethodLength
-
-        def compare_range(send, node)
-          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/concurrent_monotonic_time.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/concurrent_monotonic_time.rb
deleted file mode 100644
index 9756070b91286..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/concurrent_monotonic_time.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where `Concurrent.monotonic_time`
-      # can be replaced by `Process.clock_gettime(Process::CLOCK_MONOTONIC)`.
-      #
-      # @example
-      #
-      #   # bad
-      #   Concurrent.monotonic_time
-      #
-      #   # good
-      #   Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      #
-      class ConcurrentMonotonicTime < Base
-        extend AutoCorrector
-
-        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
-        RESTRICT_ON_SEND = %i[monotonic_time].freeze
-
-        def_node_matcher :concurrent_monotonic_time?, <<~PATTERN
-          (send
-            (const {nil? cbase} :Concurrent) :monotonic_time ...)
-        PATTERN
-
-        def on_send(node)
-          return unless concurrent_monotonic_time?(node)
-
-          optional_unit_parameter = ", #{node.first_argument.source}" if node.first_argument
-          prefer = "Process.clock_gettime(Process::CLOCK_MONOTONIC#{optional_unit_parameter})"
-          message = format(MSG, prefer: prefer, current: node.source)
-
-          add_offense(node, message: message) do |corrector|
-            corrector.replace(node, prefer)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/constant_regexp.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/constant_regexp.rb
deleted file mode 100644
index af70c73966dbd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/constant_regexp.rb
+++ /dev/null
@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Finds regular expressions with dynamic components that are all constants.
-      #
-      # Ruby allocates a new Regexp object every time it executes a code containing such
-      # a regular expression. It is more efficient to extract it into a constant,
-      # memoize it, or add an `/o` option to perform `#{}` interpolation only once and
-      # reuse that Regexp object.
-      #
-      # @example
-      #
-      #   # bad
-      #   def tokens(pattern)
-      #     pattern.scan(TOKEN).reject { |token| token.match?(/\A#{SEPARATORS}\Z/) }
-      #   end
-      #
-      #   # good
-      #   ALL_SEPARATORS = /\A#{SEPARATORS}\Z/
-      #   def tokens(pattern)
-      #     pattern.scan(TOKEN).reject { |token| token.match?(ALL_SEPARATORS) }
-      #   end
-      #
-      #   # good
-      #   def tokens(pattern)
-      #     pattern.scan(TOKEN).reject { |token| token.match?(/\A#{SEPARATORS}\Z/o) }
-      #   end
-      #
-      #   # good
-      #   def separators
-      #     @separators ||= /\A#{SEPARATORS}\Z/
-      #   end
-      #
-      class ConstantRegexp < Base
-        extend AutoCorrector
-
-        MSG = 'Extract this regexp into a constant, memoize it, or append an `/o` option to its options.'
-
-        def on_regexp(node)
-          return if within_allowed_assignment?(node) ||
-                    !include_interpolated_const?(node) ||
-                    node.single_interpolation?
-
-          add_offense(node) do |corrector|
-            corrector.insert_after(node, 'o')
-          end
-        end
-
-        private
-
-        def within_allowed_assignment?(node)
-          node.each_ancestor(:casgn, :or_asgn).any?
-        end
-
-        def_node_matcher :regexp_escape?, <<~PATTERN
-          (send
-            (const nil? :Regexp) :escape const_type?)
-        PATTERN
-
-        def include_interpolated_const?(node)
-          return false unless node.interpolation?
-
-          node.each_child_node(:begin).all? do |begin_node|
-            inner_node = begin_node.children.first
-            inner_node && (inner_node.const_type? || regexp_escape?(inner_node))
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/count.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/count.rb
deleted file mode 100644
index d3d32335705ea..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/count.rb
+++ /dev/null
@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies usages of `count` on an `Enumerable` that
-      # follow calls to `select`, `find_all`, `filter` or `reject`. Querying logic can instead be
-      # passed to the `count` call.
-      #
-      # @safety
-      #   This cop is unsafe because it has known compatibility issues with `ActiveRecord` and other
-      #   frameworks. ActiveRecord's `count` ignores the block that is passed to it.
-      #   `ActiveRecord` will ignore the block that is passed to `count`.
-      #   Other methods, such as `select`, will convert the association to an
-      #   array and then run the block on the array. A simple work around to
-      #   make `count` work with a block is to call `to_a.count {...}`.
-      #
-      #   For example:
-      #
-      #   [source,ruby]
-      #   ----
-      #   `Model.where(id: [1, 2, 3]).select { |m| m.method == true }.size`
-      #   ----
-      #
-      #   becomes:
-      #
-      #   [source,ruby]
-      #   ----
-      #   `Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }`
-      #   ----
-      #
-      # @example
-      #   # bad
-      #   [1, 2, 3].select { |e| e > 2 }.size
-      #   [1, 2, 3].reject { |e| e > 2 }.size
-      #   [1, 2, 3].select { |e| e > 2 }.length
-      #   [1, 2, 3].reject { |e| e > 2 }.length
-      #   [1, 2, 3].select { |e| e > 2 }.count { |e| e.odd? }
-      #   [1, 2, 3].reject { |e| e > 2 }.count { |e| e.even? }
-      #   array.select(&:value).count
-      #
-      #   # good
-      #   [1, 2, 3].count { |e| e > 2 }
-      #   [1, 2, 3].count { |e| e < 2 }
-      #   [1, 2, 3].count { |e| e > 2 && e.odd? }
-      #   [1, 2, 3].count { |e| e < 2 && e.even? }
-      #   Model.select('field AS field_one').count
-      #   Model.select(:value).count
-      class Count < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `count` instead of `%<selector>s...%<counter>s`.'
-        RESTRICT_ON_SEND = %i[count length size].freeze
-
-        def_node_matcher :count_candidate?, <<~PATTERN
-          {
-            (send (block $(send _ ${:select :filter :find_all :reject}) ...) ${:count :length :size})
-            (send $(send _ ${:select :filter :find_all :reject} (:block_pass _)) ${:count :length :size})
-          }
-        PATTERN
-
-        def on_send(node)
-          count_candidate?(node) do |selector_node, selector, counter|
-            return unless eligible_node?(node)
-
-            range = source_starting_at(node) do
-              selector_node.loc.selector.begin_pos
-            end
-
-            add_offense(range, message: format(MSG, selector: selector, counter: counter)) do |corrector|
-              autocorrect(corrector, node, selector_node, selector)
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node, selector_node, selector)
-          selector_loc = selector_node.loc.selector
-
-          return if selector == :reject
-
-          range = source_starting_at(node) { |n| n.loc.dot.begin_pos }
-
-          corrector.remove(range)
-          corrector.replace(selector_loc, 'count')
-        end
-
-        def eligible_node?(node)
-          !(node.parent && node.parent.block_type?)
-        end
-
-        def source_starting_at(node)
-          begin_pos = if block_given?
-                        yield node
-                      else
-                        node.source_range.begin_pos
-                      end
-
-          range_between(begin_pos, node.source_range.end_pos)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_prefix.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_prefix.rb
deleted file mode 100644
index 4df4f6f120e2a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_prefix.rb
+++ /dev/null
@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # In Ruby 2.5, `String#delete_prefix` has been added.
-      #
-      # This cop identifies places where `gsub(/\Aprefix/, '')` and `sub(/\Aprefix/, '')`
-      # can be replaced by `delete_prefix('prefix')`.
-      #
-      # This cop has `SafeMultiline` configuration option that `true` by default because
-      # `^prefix` is unsafe as it will behave incompatible with `delete_prefix`
-      # for receiver is multiline string.
-      #
-      # The `delete_prefix('prefix')` method is faster than `gsub(/\Aprefix/, '')`.
-      #
-      # @safety
-      #   This cop is unsafe because `Pathname` has `sub` but not `delete_prefix`.
-      #
-      # @example
-      #
-      #   # bad
-      #   str.gsub(/\Aprefix/, '')
-      #   str.gsub!(/\Aprefix/, '')
-      #
-      #   str.sub(/\Aprefix/, '')
-      #   str.sub!(/\Aprefix/, '')
-      #
-      #   # good
-      #   str.delete_prefix('prefix')
-      #   str.delete_prefix!('prefix')
-      #
-      # @example SafeMultiline: true (default)
-      #
-      #   # good
-      #   str.gsub(/^prefix/, '')
-      #   str.gsub!(/^prefix/, '')
-      #   str.sub(/^prefix/, '')
-      #   str.sub!(/^prefix/, '')
-      #
-      # @example SafeMultiline: false
-      #
-      #   # bad
-      #   str.gsub(/^prefix/, '')
-      #   str.gsub!(/^prefix/, '')
-      #   str.sub(/^prefix/, '')
-      #   str.sub!(/^prefix/, '')
-      #
-      class DeletePrefix < Base
-        include RegexpMetacharacter
-        extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.5
-
-        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
-        RESTRICT_ON_SEND = %i[gsub gsub! sub sub!].freeze
-
-        PREFERRED_METHODS = {
-          gsub: :delete_prefix,
-          gsub!: :delete_prefix!,
-          sub: :delete_prefix,
-          sub!: :delete_prefix!
-        }.freeze
-
-        def_node_matcher :delete_prefix_candidate?, <<~PATTERN
-          (send $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_start?) (regopt)) (str $_))
-        PATTERN
-
-        def on_send(node)
-          return unless (receiver, bad_method, regexp_str, replace_string = delete_prefix_candidate?(node))
-          return unless replace_string.empty?
-
-          good_method = PREFERRED_METHODS[bad_method]
-
-          message = format(MSG, current: bad_method, prefer: good_method)
-
-          add_offense(node.loc.selector, message: message) do |corrector|
-            regexp_str = drop_start_metacharacter(regexp_str)
-            regexp_str = interpret_string_escapes(regexp_str)
-            string_literal = to_string_literal(regexp_str)
-
-            new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
-
-            corrector.replace(node, new_code)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_suffix.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_suffix.rb
deleted file mode 100644
index ae13359db1164..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_suffix.rb
+++ /dev/null
@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # In Ruby 2.5, `String#delete_suffix` has been added.
-      #
-      # This cop identifies places where `gsub(/suffix\z/, '')` and `sub(/suffix\z/, '')`
-      # can be replaced by `delete_suffix('suffix')`.
-      #
-      # This cop has `SafeMultiline` configuration option that `true` by default because
-      # `suffix$` is unsafe as it will behave incompatible with `delete_suffix?`
-      # for receiver is multiline string.
-      #
-      # The `delete_suffix('suffix')` method is faster than `gsub(/suffix\z/, '')`.
-      #
-      # @safety
-      #   This cop is unsafe because `Pathname` has `sub` but not `delete_suffix`.
-      #
-      # @example
-      #
-      #   # bad
-      #   str.gsub(/suffix\z/, '')
-      #   str.gsub!(/suffix\z/, '')
-      #
-      #   str.sub(/suffix\z/, '')
-      #   str.sub!(/suffix\z/, '')
-      #
-      #   # good
-      #   str.delete_suffix('suffix')
-      #   str.delete_suffix!('suffix')
-      #
-      # @example SafeMultiline: true (default)
-      #
-      #   # good
-      #   str.gsub(/suffix$/, '')
-      #   str.gsub!(/suffix$/, '')
-      #   str.sub(/suffix$/, '')
-      #   str.sub!(/suffix$/, '')
-      #
-      # @example SafeMultiline: false
-      #
-      #   # bad
-      #   str.gsub(/suffix$/, '')
-      #   str.gsub!(/suffix$/, '')
-      #   str.sub(/suffix$/, '')
-      #   str.sub!(/suffix$/, '')
-      #
-      class DeleteSuffix < Base
-        include RegexpMetacharacter
-        extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.5
-
-        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
-        RESTRICT_ON_SEND = %i[gsub gsub! sub sub!].freeze
-
-        PREFERRED_METHODS = {
-          gsub: :delete_suffix,
-          gsub!: :delete_suffix!,
-          sub: :delete_suffix,
-          sub!: :delete_suffix!
-        }.freeze
-
-        def_node_matcher :delete_suffix_candidate?, <<~PATTERN
-          (send $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_end?) (regopt)) (str $_))
-        PATTERN
-
-        def on_send(node)
-          return unless (receiver, bad_method, regexp_str, replace_string = delete_suffix_candidate?(node))
-          return unless replace_string.empty?
-
-          good_method = PREFERRED_METHODS[bad_method]
-
-          message = format(MSG, current: bad_method, prefer: good_method)
-
-          add_offense(node.loc.selector, message: message) do |corrector|
-            regexp_str = drop_end_metacharacter(regexp_str)
-            regexp_str = interpret_string_escapes(regexp_str)
-            string_literal = to_string_literal(regexp_str)
-
-            new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
-
-            corrector.replace(node, new_code)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb
deleted file mode 100644
index 1cee1e8d937d3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb
+++ /dev/null
@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies usages of `first`, `last`, `[0]` or `[-1]`
-      # chained to `select`, `find_all` or `filter` and change them to use
-      # `detect` instead.
-      #
-      # @safety
-      #   This cop is unsafe because is has known compatibility issues with `ActiveRecord` and other
-      #   frameworks. `ActiveRecord` does not implement a `detect` method and `find` has its own
-      #   meaning. Correcting `ActiveRecord` methods with this cop should be considered unsafe.
-      #
-      # @example
-      #   # bad
-      #   [].select { |item| true }.first
-      #   [].select { |item| true }.last
-      #   [].find_all { |item| true }.first
-      #   [].find_all { |item| true }.last
-      #   [].filter { |item| true }.first
-      #   [].filter { |item| true }.last
-      #   [].filter { |item| true }[0]
-      #   [].filter { |item| true }[-1]
-      #
-      #   # good
-      #   [].detect { |item| true }
-      #   [].reverse.detect { |item| true }
-      #
-      class Detect < Base
-        extend AutoCorrector
-
-        CANDIDATE_METHODS = Set[:select, :find_all, :filter].freeze
-
-        MSG = 'Use `%<prefer>s` instead of `%<first_method>s.%<second_method>s`.'
-        REVERSE_MSG = 'Use `reverse.%<prefer>s` instead of `%<first_method>s.%<second_method>s`.'
-        INDEX_MSG = 'Use `%<prefer>s` instead of `%<first_method>s[%<index>i]`.'
-        INDEX_REVERSE_MSG = 'Use `reverse.%<prefer>s` instead of `%<first_method>s[%<index>i]`.'
-        RESTRICT_ON_SEND = %i[first last []].freeze
-
-        def_node_matcher :detect_candidate?, <<~PATTERN
-          {
-            (send $(block (send _ %CANDIDATE_METHODS) ...) ${:first :last} $...)
-            (send $(block (send _ %CANDIDATE_METHODS) ...) $:[] (int ${0 -1}))
-            (send $(send _ %CANDIDATE_METHODS ...) ${:first :last} $...)
-            (send $(send _ %CANDIDATE_METHODS ...) $:[] (int ${0 -1}))
-          }
-        PATTERN
-
-        def on_send(node)
-          detect_candidate?(node) do |receiver, second_method, args|
-            if second_method == :[]
-              index = args
-              args = {}
-            end
-
-            return unless args.empty?
-            return unless receiver
-
-            receiver, _args, body = *receiver if receiver.block_type?
-            return if accept_first_call?(receiver, body)
-
-            register_offense(node, receiver, second_method, index)
-          end
-        end
-
-        private
-
-        def accept_first_call?(receiver, body)
-          caller, _first_method, args = *receiver
-
-          # check that we have usual block or block pass
-          return true if body.nil? && (args.nil? || !args.block_pass_type?)
-
-          lazy?(caller)
-        end
-
-        def register_offense(node, receiver, second_method, index)
-          _caller, first_method, _args = *receiver
-          range = receiver.loc.selector.join(node.loc.selector)
-
-          message = message_for_method(second_method, index)
-          formatted_message = format(message, prefer: preferred_method,
-                                              first_method: first_method,
-                                              second_method: second_method,
-                                              index: index)
-
-          add_offense(range, message: formatted_message) do |corrector|
-            autocorrect(corrector, node, replacement(second_method, index))
-          end
-        end
-
-        def replacement(method, index)
-          if method == :last || (method == :[] && index == -1)
-            "reverse.#{preferred_method}"
-          else
-            preferred_method
-          end
-        end
-
-        def autocorrect(corrector, node, replacement)
-          receiver, _first_method = *node
-
-          first_range = receiver.source_range.end.join(node.loc.selector)
-
-          receiver, _args, _body = *receiver if receiver.block_type?
-
-          corrector.remove(first_range)
-          corrector.replace(receiver.loc.selector, replacement)
-        end
-
-        def message_for_method(method, index)
-          case method
-          when :[]
-            index == -1 ? INDEX_REVERSE_MSG : INDEX_MSG
-          when :last
-            REVERSE_MSG
-          else
-            MSG
-          end
-        end
-
-        def preferred_method
-          config.for_cop('Style/CollectionMethods')['PreferredMethods']['detect'] || 'detect'
-        end
-
-        def lazy?(node)
-          return false unless node
-
-          receiver, method, _args = *node
-          method == :lazy && !receiver.nil?
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/double_start_end_with.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/double_start_end_with.rb
deleted file mode 100644
index 3f922ba502163..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/double_start_end_with.rb
+++ /dev/null
@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Checks for double `#start_with?` or `#end_with?` calls
-      # separated by `||`. In some cases such calls can be replaced
-      # with an single `#start_with?`/`#end_with?` call.
-      #
-      # `IncludeActiveSupportAliases` configuration option is used to check for
-      # `starts_with?` and `ends_with?`. These methods are defined by Active Support.
-      #
-      # @example
-      #   # bad
-      #   str.start_with?("a") || str.start_with?(Some::CONST)
-      #   str.start_with?("a", "b") || str.start_with?("c")
-      #   str.end_with?(var1) || str.end_with?(var2)
-      #
-      #   # good
-      #   str.start_with?("a", Some::CONST)
-      #   str.start_with?("a", "b", "c")
-      #   str.end_with?(var1, var2)
-      #
-      # @example IncludeActiveSupportAliases: false (default)
-      #   # good
-      #   str.starts_with?("a", "b") || str.starts_with?("c")
-      #   str.ends_with?(var1) || str.ends_with?(var2)
-      #
-      #   str.starts_with?("a", "b", "c")
-      #   str.ends_with?(var1, var2)
-      #
-      # @example IncludeActiveSupportAliases: true
-      #   # bad
-      #   str.starts_with?("a", "b") || str.starts_with?("c")
-      #   str.ends_with?(var1) || str.ends_with?(var2)
-      #
-      #   # good
-      #   str.starts_with?("a", "b", "c")
-      #   str.ends_with?(var1, var2)
-      #
-      class DoubleStartEndWith < Base
-        extend AutoCorrector
-
-        MSG = 'Use `%<receiver>s.%<method>s(%<combined_args>s)` ' \
-              'instead of `%<original_code>s`.'
-
-        def on_or(node)
-          receiver, method, first_call_args, second_call_args = process_source(node)
-
-          return unless receiver && second_call_args.all?(&:pure?)
-
-          combined_args = combine_args(first_call_args, second_call_args)
-
-          add_offense(node, message: message(node, receiver, method, combined_args)) do |corrector|
-            autocorrect(corrector, first_call_args, second_call_args, combined_args)
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, first_call_args, second_call_args, combined_args)
-          first_argument = first_call_args.first.loc.expression
-          last_argument = second_call_args.last.loc.expression
-          range = first_argument.join(last_argument)
-
-          corrector.replace(range, combined_args)
-        end
-
-        def process_source(node)
-          if check_for_active_support_aliases?
-            check_with_active_support_aliases(node)
-          else
-            two_start_end_with_calls(node)
-          end
-        end
-
-        def message(node, receiver, method, combined_args)
-          format(
-            MSG, receiver: receiver.source, method: method, combined_args: combined_args, original_code: node.source
-          )
-        end
-
-        def combine_args(first_call_args, second_call_args)
-          (first_call_args + second_call_args).map(&:source).join(', ')
-        end
-
-        def check_for_active_support_aliases?
-          cop_config['IncludeActiveSupportAliases']
-        end
-
-        def_node_matcher :two_start_end_with_calls, <<~PATTERN
-          (or
-            (send $_recv [{:start_with? :end_with?} $_method] $...)
-            (send _recv _method $...))
-        PATTERN
-
-        def_node_matcher :check_with_active_support_aliases, <<~PATTERN
-          (or
-            (send $_recv
-                    [{:start_with? :starts_with? :end_with? :ends_with?} $_method]
-                  $...)
-            (send _recv _method $...))
-        PATTERN
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/end_with.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/end_with.rb
deleted file mode 100644
index 460367be6c725..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/end_with.rb
+++ /dev/null
@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies unnecessary use of a regex where `String#end_with?` would suffice.
-      #
-      # This cop has `SafeMultiline` configuration option that `true` by default because
-      # `end$` is unsafe as it will behave incompatible with `end_with?`
-      # for receiver is multiline string.
-      #
-      # @safety
-      #   This will change to a new method call which isn't guaranteed to be on the
-      #   object. Switching these methods has to be done with knowledge of the types
-      #   of the variables which rubocop doesn't have.
-      #
-      # @example
-      #   # bad
-      #   'abc'.match?(/bc\Z/)
-      #   /bc\Z/.match?('abc')
-      #   'abc' =~ /bc\Z/
-      #   /bc\Z/ =~ 'abc'
-      #   'abc'.match(/bc\Z/)
-      #   /bc\Z/.match('abc')
-      #
-      #   # good
-      #   'abc'.end_with?('bc')
-      #
-      # @example SafeMultiline: true (default)
-      #
-      #   # good
-      #   'abc'.match?(/bc$/)
-      #   /bc$/.match?('abc')
-      #   'abc' =~ /bc$/
-      #   /bc$/ =~ 'abc'
-      #   'abc'.match(/bc$/)
-      #   /bc$/.match('abc')
-      #
-      # @example SafeMultiline: false
-      #
-      #   # bad
-      #   'abc'.match?(/bc$/)
-      #   /bc$/.match?('abc')
-      #   'abc' =~ /bc$/
-      #   /bc$/ =~ 'abc'
-      #   'abc'.match(/bc$/)
-      #   /bc$/.match('abc')
-      #
-      class EndWith < Base
-        include RegexpMetacharacter
-        extend AutoCorrector
-
-        MSG = 'Use `String#end_with?` instead of a regex match anchored to ' \
-              'the end of the string.'
-        RESTRICT_ON_SEND = %i[match =~ match?].freeze
-
-        def_node_matcher :redundant_regex?, <<~PATTERN
-          {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_end?) (regopt)))
-           (send (regexp (str $#literal_at_end?) (regopt)) {:match :match?} $_)
-           (match-with-lvasgn (regexp (str $#literal_at_end?) (regopt)) $_)}
-        PATTERN
-
-        def on_send(node)
-          return unless (receiver, regex_str = redundant_regex?(node))
-
-          add_offense(node) do |corrector|
-            receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
-            regex_str = drop_end_metacharacter(regex_str)
-            regex_str = interpret_string_escapes(regex_str)
-
-            new_source = "#{receiver.source}.end_with?(#{to_string_literal(regex_str)})"
-
-            corrector.replace(node.source_range, new_source)
-          end
-        end
-        alias on_match_with_lvasgn on_send
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/fixed_size.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/fixed_size.rb
deleted file mode 100644
index 01959f2130b83..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/fixed_size.rb
+++ /dev/null
@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Do not compute the size of statically sized objects.
-      #
-      # @example
-      #   # String methods
-      #   # bad
-      #   'foo'.size
-      #   %q[bar].count
-      #   %(qux).length
-      #
-      #   # Symbol methods
-      #   # bad
-      #   :fred.size
-      #   :'baz'.length
-      #
-      #   # Array methods
-      #   # bad
-      #   [1, 2, thud].count
-      #   %W(1, 2, bar).size
-      #
-      #   # Hash methods
-      #   # bad
-      #   { a: corge, b: grault }.length
-      #
-      #   # good
-      #   foo.size
-      #   bar.count
-      #   qux.length
-      #
-      #   # good
-      #   :"#{fred}".size
-      #   CONST = :baz.length
-      #
-      #   # good
-      #   [1, 2, *thud].count
-      #   garply = [1, 2, 3]
-      #   garply.size
-      #
-      #   # good
-      #   { a: corge, **grault }.length
-      #   waldo = { a: corge, b: grault }
-      #   waldo.size
-      #
-      class FixedSize < Base
-        MSG = 'Do not compute the size of statically sized objects.'
-        RESTRICT_ON_SEND = %i[count length size].freeze
-
-        def_node_matcher :counter, <<~MATCHER
-          (send ${array hash str sym} {:count :length :size} $...)
-        MATCHER
-
-        def on_send(node)
-          return if node.ancestors.any? { |ancestor| allowed_parent?(ancestor) }
-
-          counter(node) do |var, arg|
-            return if allowed_variable?(var) || allowed_argument?(arg)
-
-            add_offense(node)
-          end
-        end
-
-        private
-
-        def allowed_variable?(var)
-          contains_splat?(var) || contains_double_splat?(var)
-        end
-
-        def allowed_argument?(arg)
-          arg && non_string_argument?(arg.first)
-        end
-
-        def allowed_parent?(node)
-          node && (node.casgn_type? || node.block_type?)
-        end
-
-        def contains_splat?(node)
-          return unless node.array_type?
-
-          node.each_child_node(:splat).any?
-        end
-
-        def contains_double_splat?(node)
-          return unless node.hash_type?
-
-          node.each_child_node(:kwsplat).any?
-        end
-
-        def non_string_argument?(node)
-          node && !node.str_type?
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/flat_map.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/flat_map.rb
deleted file mode 100644
index 29cd0fe62e677..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/flat_map.rb
+++ /dev/null
@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies usages of `map { ... }.flatten` and
-      # change them to use `flat_map { ... }` instead.
-      #
-      # @example
-      #   # bad
-      #   [1, 2, 3, 4].map { |e| [e, e] }.flatten(1)
-      #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten(1)
-      #
-      #   # good
-      #   [1, 2, 3, 4].flat_map { |e| [e, e] }
-      #   [1, 2, 3, 4].map { |e| [e, e] }.flatten
-      #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten
-      class FlatMap < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `flat_map` instead of `%<method>s...%<flatten>s`.'
-        RESTRICT_ON_SEND = %i[flatten flatten!].freeze
-        FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
-                                  'and `flatten` can be used to flatten ' \
-                                  'multiple levels.'
-
-        def_node_matcher :flat_map_candidate?, <<~PATTERN
-          (send
-            {
-              (block $(send _ ${:collect :map}) ...)
-              $(send _ ${:collect :map} (block_pass _))
-            }
-            ${:flatten :flatten!}
-            $...
-          )
-        PATTERN
-
-        def on_send(node)
-          flat_map_candidate?(node) do |map_node, first_method, flatten, params|
-            flatten_level, = *params.first
-            if cop_config['EnabledForFlattenWithoutParams'] && !flatten_level
-              offense_for_levels(node, map_node, first_method, flatten)
-            elsif flatten_level == 1
-              offense_for_method(node, map_node, first_method, flatten)
-            end
-          end
-        end
-
-        private
-
-        def offense_for_levels(node, map_node, first_method, flatten)
-          message = MSG + FLATTEN_MULTIPLE_LEVELS
-
-          register_offense(node, map_node, first_method, flatten, message)
-        end
-
-        def offense_for_method(node, map_node, first_method, flatten)
-          register_offense(node, map_node, first_method, flatten, MSG)
-        end
-
-        def register_offense(node, map_node, first_method, flatten, message)
-          range = range_between(map_node.loc.selector.begin_pos, node.loc.expression.end_pos)
-          message = format(message, method: first_method, flatten: flatten)
-
-          add_offense(range, message: message) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-
-        def autocorrect(corrector, node)
-          map_node, _first_method, _flatten, params = flat_map_candidate?(node)
-          flatten_level, = *params.first
-
-          return unless flatten_level
-
-          range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
-
-          corrector.remove(range)
-          corrector.replace(map_node.loc.selector, 'flat_map')
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/inefficient_hash_search.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/inefficient_hash_search.rb
deleted file mode 100644
index dd38a94b208f6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/inefficient_hash_search.rb
+++ /dev/null
@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Checks for inefficient searching of keys and values within
-      # hashes.
-      #
-      # `Hash#keys.include?` is less efficient than `Hash#key?` because
-      # the former allocates a new array and then performs an O(n) search
-      # through that array, while `Hash#key?` does not allocate any array and
-      # performs a faster O(1) search for the key.
-      #
-      # `Hash#values.include?` is less efficient than `Hash#value?`. While they
-      # both perform an O(n) search through all of the values, calling `values`
-      # allocates a new array while using `value?` does not.
-      #
-      # @safety
-      #   This cop is unsafe because it can't tell whether the receiver is a hash object.
-      #
-      # @example
-      #   # bad
-      #   { a: 1, b: 2 }.keys.include?(:a)
-      #   { a: 1, b: 2 }.keys.include?(:z)
-      #   h = { a: 1, b: 2 }; h.keys.include?(100)
-      #
-      #   # good
-      #   { a: 1, b: 2 }.key?(:a)
-      #   { a: 1, b: 2 }.has_key?(:z)
-      #   h = { a: 1, b: 2 }; h.key?(100)
-      #
-      #   # bad
-      #   { a: 1, b: 2 }.values.include?(2)
-      #   { a: 1, b: 2 }.values.include?('garbage')
-      #   h = { a: 1, b: 2 }; h.values.include?(nil)
-      #
-      #   # good
-      #   { a: 1, b: 2 }.value?(2)
-      #   { a: 1, b: 2 }.has_value?('garbage')
-      #   h = { a: 1, b: 2 }; h.value?(nil)
-      #
-      class InefficientHashSearch < Base
-        extend AutoCorrector
-
-        RESTRICT_ON_SEND = %i[include?].freeze
-
-        def_node_matcher :inefficient_include?, <<~PATTERN
-          (send (send $_ {:keys :values}) :include? _)
-        PATTERN
-
-        def on_send(node)
-          inefficient_include?(node) do |receiver|
-            return if receiver.nil?
-
-            message = message(node)
-            add_offense(node, message: message) do |corrector|
-              # Replace `keys.include?` or `values.include?` with the appropriate
-              # `key?`/`value?` method.
-              corrector.replace(
-                node.loc.expression,
-                "#{autocorrect_hash_expression(node)}.#{autocorrect_method(node)}(#{autocorrect_argument(node)})"
-              )
-            end
-          end
-        end
-
-        private
-
-        def message(node)
-          "Use `##{autocorrect_method(node)}` instead of `##{current_method(node)}.include?`."
-        end
-
-        def autocorrect_method(node)
-          case current_method(node)
-          when :keys then use_long_method ? 'has_key?' : 'key?'
-          when :values then use_long_method ? 'has_value?' : 'value?'
-          end
-        end
-
-        def current_method(node)
-          node.receiver.method_name
-        end
-
-        def use_long_method
-          preferred_config = config.for_all_cops['Style/PreferredHashMethods']
-          preferred_config &&
-            preferred_config['EnforcedStyle'] == 'long' &&
-            preferred_config['Enabled']
-        end
-
-        def autocorrect_argument(node)
-          node.arguments.first.source
-        end
-
-        def autocorrect_hash_expression(node)
-          node.receiver.receiver.source
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb
deleted file mode 100644
index 354bc7eca6eb8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb
+++ /dev/null
@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where inefficient `readlines` method
-      # can be replaced by `each_line` to avoid fully loading file content into memory.
-      #
-      # @example
-      #
-      #   # bad
-      #   File.readlines('testfile').each { |l| puts l }
-      #   IO.readlines('testfile', chomp: true).each { |l| puts l }
-      #
-      #   conn.readlines(10).map { |l| l.size }
-      #   file.readlines.find { |l| l.start_with?('#') }
-      #   file.readlines.each { |l| puts l }
-      #
-      #   # good
-      #   File.open('testfile', 'r').each_line { |l| puts l }
-      #   IO.open('testfile').each_line(chomp: true) { |l| puts l }
-      #
-      #   conn.each_line(10).map { |l| l.size }
-      #   file.each_line.find { |l| l.start_with?('#') }
-      #   file.each_line { |l| puts l }
-      #
-      class IoReadlines < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
-        RESTRICT_ON_SEND = (Enumerable.instance_methods + [:each]).freeze
-
-        def_node_matcher :readlines_on_class?, <<~PATTERN
-          $(send $(send (const nil? {:IO :File}) :readlines ...) _)
-        PATTERN
-
-        def_node_matcher :readlines_on_instance?, <<~PATTERN
-          $(send $(send ${nil? !const_type?} :readlines ...) _ ...)
-        PATTERN
-
-        def on_send(node)
-          return unless (captured_values = readlines_on_class?(node) || readlines_on_instance?(node))
-
-          enumerable_call, readlines_call, receiver = *captured_values
-
-          range = offense_range(enumerable_call, readlines_call)
-          good_method = build_good_method(enumerable_call)
-          bad_method = build_bad_method(enumerable_call)
-
-          add_offense(range, message: format(MSG, good: good_method, bad: bad_method)) do |corrector|
-            autocorrect(corrector, enumerable_call, readlines_call, receiver)
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, enumerable_call, readlines_call, receiver)
-          # We cannot safely correct `.readlines` method called on IO/File classes
-          # due to its signature and we are not sure with implicit receiver
-          # if it is called in the context of some instance or mentioned class.
-          return if receiver.nil?
-
-          range = correction_range(enumerable_call, readlines_call)
-
-          if readlines_call.arguments?
-            call_args = build_call_args(readlines_call.arguments)
-            replacement = "each_line(#{call_args})"
-          else
-            replacement = 'each_line'
-          end
-
-          corrector.replace(range, replacement)
-        end
-
-        def offense_range(enumerable_call, readlines_call)
-          readlines_pos = readlines_call.loc.selector.begin_pos
-          enumerable_pos = enumerable_call.loc.selector.end_pos
-          range_between(readlines_pos, enumerable_pos)
-        end
-
-        def build_good_method(enumerable_call)
-          if enumerable_call.method?(:each)
-            'each_line'
-          else
-            "each_line.#{enumerable_call.method_name}"
-          end
-        end
-
-        def build_bad_method(enumerable_call)
-          "readlines.#{enumerable_call.method_name}"
-        end
-
-        def correction_range(enumerable_call, readlines_call)
-          begin_pos = readlines_call.loc.selector.begin_pos
-
-          end_pos = if enumerable_call.method?(:each)
-                      enumerable_call.loc.expression.end_pos
-                    else
-                      enumerable_call.loc.dot.begin_pos
-                    end
-
-          range_between(begin_pos, end_pos)
-        end
-
-        def build_call_args(call_args_node)
-          call_args_node.map(&:source).join(', ')
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/map_compact.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/map_compact.rb
deleted file mode 100644
index b3a168d772c43..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/map_compact.rb
+++ /dev/null
@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # In Ruby 2.7, `Enumerable#filter_map` has been added.
-      #
-      # This cop identifies places where `map { ... }.compact` can be replaced by `filter_map`.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because `map { ... }.compact` that is not
-      #   compatible with `filter_map`.
-      #
-      # [source,ruby]
-      # ----
-      # [true, false, nil].compact              #=> [true, false]
-      # [true, false, nil].filter_map(&:itself) #=> [true]
-      # ----
-      #
-      # @example
-      #   # bad
-      #   ary.map(&:foo).compact
-      #   ary.collect(&:foo).compact
-      #
-      #   # good
-      #   ary.filter_map(&:foo)
-      #   ary.map(&:foo).compact!
-      #   ary.compact.map(&:foo)
-      #
-      class MapCompact < Base
-        include RangeHelp
-        extend AutoCorrector
-        extend TargetRubyVersion
-
-        MSG = 'Use `filter_map` instead.'
-        RESTRICT_ON_SEND = %i[compact].freeze
-
-        minimum_target_ruby_version 2.7
-
-        def_node_matcher :map_compact, <<~PATTERN
-          {
-            (send
-              $(send _ {:map :collect}
-                (block_pass
-                  (sym _))) _)
-            (send
-              (block
-                $(send _ {:map :collect})
-                  (args ...) _) _)
-          }
-        PATTERN
-
-        def on_send(node)
-          return unless (map_node = map_compact(node))
-
-          compact_loc = node.loc
-          range = range_between(map_node.loc.selector.begin_pos, compact_loc.selector.end_pos)
-
-          add_offense(range) do |corrector|
-            corrector.replace(map_node.loc.selector, 'filter_map')
-            remove_compact_method(corrector, map_node, node, node.parent)
-          end
-        end
-
-        private
-
-        def remove_compact_method(corrector, map_node, compact_node, chained_method)
-          compact_method_range = compact_node.loc.selector
-
-          if compact_node.multiline? && chained_method&.loc.respond_to?(:selector) && chained_method.dot? &&
-             !map_method_and_compact_method_on_same_line?(map_node, compact_node) &&
-             !invoke_method_after_map_compact_on_same_line?(compact_node, chained_method)
-            compact_method_range = compact_method_with_final_newline_range(compact_method_range)
-          else
-            corrector.remove(compact_node.loc.dot)
-          end
-
-          corrector.remove(compact_method_range)
-        end
-
-        def map_method_and_compact_method_on_same_line?(map_node, compact_node)
-          compact_node.loc.selector.line == map_node.loc.selector.line
-        end
-
-        def invoke_method_after_map_compact_on_same_line?(compact_node, chained_method)
-          compact_node.loc.selector.line == chained_method.loc.last_line
-        end
-
-        def compact_method_with_final_newline_range(compact_method_range)
-          range_by_whole_lines(compact_method_range, include_final_newline: true)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/method_object_as_block.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/method_object_as_block.rb
deleted file mode 100644
index 8e342165a72aa..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/method_object_as_block.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where methods are converted to blocks, with the
-      # use of `&method`, and passed as arguments to method calls.
-      # It is faster to replace those with explicit blocks, calling those methods inside.
-      #
-      # @example
-      #   # bad
-      #   array.map(&method(:do_something))
-      #   [1, 2, 3].each(&out.method(:puts))
-      #
-      #   # good
-      #   array.map { |x| do_something(x) }
-      #   [1, 2, 3].each { |x| out.puts(x) }
-      #
-      class MethodObjectAsBlock < Base
-        MSG = 'Use block explicitly instead of block-passing a method object.'
-
-        def_node_matcher :method_object_as_argument?, <<~PATTERN
-          (^send (send _ :method sym))
-        PATTERN
-
-        def on_block_pass(node)
-          add_offense(node) if method_object_as_argument?(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/open_struct.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/open_struct.rb
deleted file mode 100644
index 9e4351eb704f0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/open_struct.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Checks for `OpenStruct.new` calls.
-      # Instantiation of an `OpenStruct` invalidates
-      # Ruby global method cache as it causes dynamic method
-      # definition during program runtime.
-      # This could have an effect on performance,
-      # especially in case of single-threaded
-      # applications with multiple `OpenStruct` instantiations.
-      #
-      # @safety
-      #   This cop is unsafe because `OpenStruct.new` and `Struct.new`
-      #   are not equivalent.
-      #
-      # @example
-      #   # bad
-      #   class MyClass
-      #     def my_method
-      #       OpenStruct.new(my_key1: 'my_value1', my_key2: 'my_value2')
-      #     end
-      #   end
-      #
-      #   # good
-      #   class MyClass
-      #     MyStruct = Struct.new(:my_key1, :my_key2)
-      #     def my_method
-      #       MyStruct.new('my_value1', 'my_value2')
-      #     end
-      #   end
-      #
-      class OpenStruct < Base
-        MSG = 'Consider using `Struct` over `OpenStruct` ' \
-              'to optimize the performance.'
-        RESTRICT_ON_SEND = %i[new].freeze
-
-        def_node_matcher :open_struct, <<~PATTERN
-          (send (const {nil? cbase} :OpenStruct) :new ...)
-        PATTERN
-
-        def on_send(node)
-          open_struct(node) do
-            add_offense(node.loc.selector)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/range_include.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/range_include.rb
deleted file mode 100644
index 1187bb3b4fb86..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/range_include.rb
+++ /dev/null
@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies uses of `Range#include?` and `Range#member?`, which iterates over each
-      # item in a `Range` to see if a specified item is there. In contrast,
-      # `Range#cover?` simply compares the target item with the beginning and
-      # end points of the `Range`. In a great majority of cases, this is what
-      # is wanted.
-      #
-      # @safety
-      #   This cop is unsafe because `Range#include?` (or `Range#member?`) and `Range#cover?`
-      #   are not equivalent behavior.
-      #
-      # @example
-      #   # bad
-      #   ('a'..'z').include?('b') # => true
-      #   ('a'..'z').member?('b')  # => true
-      #
-      #   # good
-      #   ('a'..'z').cover?('b') # => true
-      #
-      #   # Example of a case where `Range#cover?` may not provide
-      #   # the desired result:
-      #
-      #   ('a'..'z').cover?('yellow') # => true
-      class RangeInclude < Base
-        extend AutoCorrector
-
-        MSG = 'Use `Range#cover?` instead of `Range#%<bad_method>s`.'
-        RESTRICT_ON_SEND = %i[include? member?].freeze
-
-        # TODO: If we traced out assignments of variables to their uses, we
-        # might pick up on a few more instances of this issue
-        # Right now, we only detect direct calls on a Range literal
-        # (We don't even catch it if the Range is in double parens)
-
-        def_node_matcher :range_include, <<~PATTERN
-          (send {irange erange (begin {irange erange})} ${:include? :member?} ...)
-        PATTERN
-
-        def on_send(node)
-          range_include(node) do |bad_method|
-            message = format(MSG, bad_method: bad_method)
-
-            add_offense(node.loc.selector, message: message) do |corrector|
-              corrector.replace(node.loc.selector, 'cover?')
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb
deleted file mode 100644
index d3b6a3d992123..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb
+++ /dev/null
@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies the use of a `&block` parameter and `block.call`
-      # where `yield` would do just as well.
-      #
-      # @example
-      #   # bad
-      #   def method(&block)
-      #     block.call
-      #   end
-      #   def another(&func)
-      #     func.call 1, 2, 3
-      #   end
-      #
-      #   # good
-      #   def method
-      #     yield
-      #   end
-      #   def another
-      #     yield 1, 2, 3
-      #   end
-      class RedundantBlockCall < Base
-        extend AutoCorrector
-
-        MSG = 'Use `yield` instead of `%<argname>s.call`.'
-        YIELD = 'yield'
-        OPEN_PAREN = '('
-        CLOSE_PAREN = ')'
-        SPACE = ' '
-
-        def_node_matcher :blockarg_def, <<~PATTERN
-          {(def  _   (args ... (blockarg $_)) $_)
-           (defs _ _ (args ... (blockarg $_)) $_)}
-        PATTERN
-
-        def_node_search :blockarg_calls, <<~PATTERN
-          (send (lvar %1) :call ...)
-        PATTERN
-
-        def_node_search :blockarg_assigned?, <<~PATTERN
-          (lvasgn %1 ...)
-        PATTERN
-
-        def on_def(node)
-          blockarg_def(node) do |argname, body|
-            next unless body
-
-            calls_to_report(argname, body).each do |blockcall|
-              add_offense(blockcall, message: format(MSG, argname: argname)) do |corrector|
-                autocorrect(corrector, blockcall)
-              end
-            end
-          end
-        end
-        alias on_defs on_def
-
-        private
-
-        # offenses are registered on the `block.call` nodes
-        def autocorrect(corrector, node)
-          _receiver, _method, *args = *node
-          new_source = String.new(YIELD)
-          unless args.empty?
-            new_source += if parentheses?(node)
-                            OPEN_PAREN
-                          else
-                            SPACE
-                          end
-
-            new_source << args.map(&:source).join(', ')
-          end
-
-          new_source << CLOSE_PAREN if parentheses?(node) && !args.empty?
-
-          corrector.replace(node.source_range, new_source)
-        end
-
-        def calls_to_report(argname, body)
-          return [] if blockarg_assigned?(body, argname) || shadowed_block_argument?(body, argname)
-
-          blockarg_calls(body, argname).map do |call|
-            return [] if args_include_block_pass?(call)
-
-            call
-          end
-        end
-
-        def shadowed_block_argument?(body, block_argument_of_method_signature)
-          return false unless body.block_type?
-
-          body.arguments.map(&:source).include?(block_argument_of_method_signature.to_s)
-        end
-
-        def args_include_block_pass?(blockcall)
-          _receiver, _call, *args = *blockcall
-
-          args.any?(&:block_pass_type?)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb
deleted file mode 100644
index 39903b3176b6f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb
+++ /dev/null
@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Checks for uses `Enumerable#all?`, `Enumerable#any?`, `Enumerable#one?`,
-      # and `Enumerable#none?` are compared with `===` or similar methods in block.
-      #
-      # By default, `Object#===` behaves the same as `Object#==`, but this
-      # behavior is appropriately overridden in subclass. For example,
-      # `Range#===` returns `true` when argument is within the range.
-      #
-      # @safety
-      #   This cop is unsafe because `===` and `==` do not always behave the same.
-      #
-      # @example
-      #   # bad
-      #   items.all? { |item| pattern === item }
-      #   items.all? { |item| item == other }
-      #   items.all? { |item| item.is_a?(Klass) }
-      #   items.all? { |item| item.kind_of?(Klass) }
-      #
-      #   # good
-      #   items.all?(pattern)
-      #
-      class RedundantEqualityComparisonBlock < Base
-        extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.5
-
-        MSG = 'Use `%<prefer>s` instead of block.'
-
-        TARGET_METHODS = %i[all? any? one? none?].freeze
-        COMPARISON_METHODS = %i[== === is_a? kind_of?].freeze
-        IS_A_METHODS = %i[is_a? kind_of?].freeze
-
-        def on_block(node)
-          return unless TARGET_METHODS.include?(node.method_name)
-          return unless one_block_argument?(node.arguments)
-
-          block_argument = node.arguments.first
-          block_body = node.body
-          return unless use_equality_comparison_block?(block_body)
-          return if same_block_argument_and_is_a_argument?(block_body, block_argument)
-          return unless (new_argument = new_argument(block_argument, block_body))
-
-          range = offense_range(node)
-          prefer = "#{node.method_name}(#{new_argument})"
-
-          add_offense(range, message: format(MSG, prefer: prefer)) do |corrector|
-            corrector.replace(range, prefer)
-          end
-        end
-
-        private
-
-        def one_block_argument?(block_arguments)
-          block_arguments.one? && !block_arguments.source.include?(',')
-        end
-
-        def use_equality_comparison_block?(block_body)
-          block_body.send_type? && COMPARISON_METHODS.include?(block_body.method_name)
-        end
-
-        def same_block_argument_and_is_a_argument?(block_body, block_argument)
-          if block_body.method?(:===)
-            block_argument.source != block_body.children[2].source
-          elsif IS_A_METHODS.include?(block_body.method_name)
-            block_argument.source == block_body.first_argument.source
-          else
-            false
-          end
-        end
-
-        def new_argument(block_argument, block_body)
-          if block_argument.source == block_body.receiver.source
-            rhs = block_body.first_argument
-            return if use_block_argument_in_method_argument_of_operand?(block_argument, rhs)
-
-            rhs.source
-          elsif block_argument.source == block_body.first_argument.source
-            lhs = block_body.receiver
-            return if use_block_argument_in_method_argument_of_operand?(block_argument, lhs)
-
-            lhs.source
-          end
-        end
-
-        def use_block_argument_in_method_argument_of_operand?(block_argument, operand)
-          return false unless operand.send_type?
-
-          arguments = operand.arguments
-          arguments.inject(arguments.map(&:source)) do |operand_sources, argument|
-            operand_sources + argument.each_descendant(:lvar).map(&:source)
-          end.any?(block_argument.source)
-        end
-
-        def offense_range(node)
-          node.send_node.loc.selector.join(node.source_range.end)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_match.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_match.rb
deleted file mode 100644
index c2fa42c0c4d95..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_match.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies the use of `Regexp#match` or `String#match`, which
-      # returns `#<MatchData>`/`nil`. The return value of `=~` is an integral
-      # index/`nil` and is more performant.
-      #
-      # @example
-      #   # bad
-      #   do_something if str.match(/regex/)
-      #   while regex.match('str')
-      #     do_something
-      #   end
-      #
-      #   # good
-      #   method(str =~ /regex/)
-      #   return value unless regex =~ 'str'
-      class RedundantMatch < Base
-        extend AutoCorrector
-
-        MSG = 'Use `=~` in places where the `MatchData` returned by ' \
-              '`#match` will not be used.'
-        RESTRICT_ON_SEND = %i[match].freeze
-
-        # 'match' is a fairly generic name, so we don't flag it unless we see
-        # a string or regexp literal on one side or the other
-        def_node_matcher :match_call?, <<~PATTERN
-          {(send {str regexp} :match _)
-           (send !nil? :match {str regexp})}
-        PATTERN
-
-        def_node_matcher :only_truthiness_matters?, <<~PATTERN
-          ^({if while until case while_post until_post} equal?(%0) ...)
-        PATTERN
-
-        def on_send(node)
-          return unless match_call?(node) &&
-                        (!node.value_used? || only_truthiness_matters?(node)) &&
-                        !(node.parent && node.parent.block_type?)
-
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          # Regexp#match can take a second argument, but this cop doesn't
-          # register an offense in that case
-          return unless node.first_argument.regexp_type?
-
-          new_source = "#{node.receiver.source} =~ #{node.first_argument.source}"
-
-          corrector.replace(node.source_range, new_source)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb
deleted file mode 100644
index 7dfb53a267a06..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb
+++ /dev/null
@@ -1,201 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where `Hash#merge!` can be replaced by `Hash#[]=`.
-      # You can set the maximum number of key-value pairs to consider
-      # an offense with `MaxKeyValuePairs`.
-      #
-      # @safety
-      #   This cop is unsafe because RuboCop cannot determine if the
-      #   receiver of `merge!` is actually a hash or not.
-      #
-      # @example
-      #   # bad
-      #   hash.merge!(a: 1)
-      #   hash.merge!({'key' => 'value'})
-      #
-      #   # good
-      #   hash[:a] = 1
-      #   hash['key'] = 'value'
-      #
-      # @example MaxKeyValuePairs: 2 (default)
-      #   # bad
-      #   hash.merge!(a: 1, b: 2)
-      #
-      #   # good
-      #   hash[:a] = 1
-      #   hash[:b] = 2
-      class RedundantMerge < Base
-        extend AutoCorrector
-
-        AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'
-        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
-        RESTRICT_ON_SEND = %i[merge!].freeze
-
-        WITH_MODIFIER_CORRECTION = <<~RUBY
-          %<keyword>s %<condition>s
-          %<leading_space>s%<indent>s%<body>s
-          %<leading_space>send
-        RUBY
-
-        def_node_matcher :redundant_merge_candidate, <<~PATTERN
-          (send $!nil? :merge! [(hash $...) !kwsplat_type?])
-        PATTERN
-
-        def_node_matcher :modifier_flow_control?, <<~PATTERN
-          [{if while until} modifier_form?]
-        PATTERN
-
-        def on_send(node)
-          each_redundant_merge(node) do |redundant_merge_node|
-            message = message(node)
-            add_offense(redundant_merge_node, message: message) do |corrector|
-              redundant_merge_candidate(node) do |receiver, pairs|
-                new_source = to_assignments(receiver, pairs).join("\n")
-
-                if node.parent && pairs.size > 1
-                  correct_multiple_elements(corrector, node, node.parent, new_source)
-                else
-                  correct_single_element(corrector, node, new_source)
-                end
-              end
-            end
-          end
-        end
-
-        private
-
-        def message(node)
-          redundant_merge_candidate(node) do |receiver, pairs|
-            assignments = to_assignments(receiver, pairs).join('; ')
-
-            format(MSG, prefer: assignments, current: node.source)
-          end
-        end
-
-        def each_redundant_merge(node)
-          redundant_merge_candidate(node) do |receiver, pairs|
-            next if non_redundant_merge?(node, receiver, pairs)
-
-            yield node
-          end
-        end
-
-        def non_redundant_merge?(node, receiver, pairs)
-          pairs.empty? ||
-            non_redundant_pairs?(receiver, pairs) ||
-            kwsplat_used?(pairs) ||
-            non_redundant_value_used?(receiver, node)
-        end
-
-        def non_redundant_pairs?(receiver, pairs)
-          (pairs.size > 1 && !receiver.pure?) || pairs.size > max_key_value_pairs
-        end
-
-        def kwsplat_used?(pairs)
-          pairs.any?(&:kwsplat_type?)
-        end
-
-        def non_redundant_value_used?(receiver, node)
-          node.value_used? &&
-            !EachWithObjectInspector.new(node, receiver).value_used?
-        end
-
-        def correct_multiple_elements(corrector, node, parent, new_source)
-          if modifier_flow_control?(parent)
-            new_source = rewrite_with_modifier(node, parent, new_source)
-            node = parent
-          else
-            padding = "\n#{leading_spaces(node)}"
-            new_source.gsub!(/\n/, padding)
-          end
-
-          corrector.replace(node.source_range, new_source)
-        end
-
-        def correct_single_element(corrector, node, new_source)
-          corrector.replace(node.source_range, new_source)
-        end
-
-        def to_assignments(receiver, pairs)
-          pairs.map do |pair|
-            key, value = *pair
-
-            key = key.sym_type? && pair.colon? ? ":#{key.source}" : key.source
-
-            format(AREF_ASGN, receiver: receiver.source,
-                              key: key,
-                              value: value.source)
-          end
-        end
-
-        def rewrite_with_modifier(node, parent, new_source)
-          indent = ' ' * indent_width
-          padding = "\n#{indent + leading_spaces(node)}"
-          new_source.gsub!(/\n/, padding)
-
-          format(WITH_MODIFIER_CORRECTION, keyword: parent.loc.keyword.source,
-                                           condition: parent.condition.source,
-                                           leading_space: leading_spaces(node),
-                                           indent: indent,
-                                           body: new_source).chomp
-        end
-
-        def leading_spaces(node)
-          node.source_range.source_line[/\A\s*/]
-        end
-
-        def indent_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
-        def max_key_value_pairs
-          Integer(cop_config['MaxKeyValuePairs'] || 2)
-        end
-
-        # A utility class for checking the use of values within an
-        # `each_with_object` call.
-        class EachWithObjectInspector
-          extend NodePattern::Macros
-
-          def initialize(node, receiver)
-            @node = node
-            @receiver = unwind(receiver)
-          end
-
-          def value_used?
-            return false unless eligible_receiver? && second_argument
-
-            receiver.loc.name.source == second_argument.loc.name.source
-          end
-
-          private
-
-          attr_reader :node, :receiver
-
-          def eligible_receiver?
-            receiver.respond_to?(:lvar_type?) && receiver.lvar_type?
-          end
-
-          def second_argument
-            parent = node.parent
-            parent = parent.parent if parent.begin_type?
-
-            @second_argument ||= each_with_object_node(parent)
-          end
-
-          def unwind(receiver)
-            receiver, = *receiver while receiver.respond_to?(:send_type?) && receiver.send_type?
-            receiver
-          end
-
-          def_node_matcher :each_with_object_node, <<~PATTERN
-            (block (send _ :each_with_object _) (args _ $_) ...)
-          PATTERN
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_sort_block.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_sort_block.rb
deleted file mode 100644
index 55c3af49cb05c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_sort_block.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where `sort { |a, b| a <=> b }` can be replaced with `sort`.
-      #
-      # @example
-      #   # bad
-      #   array.sort { |a, b| a <=> b }
-      #
-      #   # good
-      #   array.sort
-      #
-      class RedundantSortBlock < Base
-        include SortBlock
-        extend AutoCorrector
-
-        MSG = 'Use `sort` instead of `%<bad_method>s`.'
-
-        def on_block(node)
-          return unless (send, var_a, var_b, body = sort_with_block?(node))
-
-          replaceable_body?(body, var_a, var_b) do
-            range = sort_range(send, node)
-
-            add_offense(range, message: message(var_a, var_b)) do |corrector|
-              corrector.replace(range, 'sort')
-            end
-          end
-        end
-
-        private
-
-        def message(var_a, var_b)
-          bad_method = "sort { |#{var_a}, #{var_b}| #{var_a} <=> #{var_b} }"
-          format(MSG, bad_method: bad_method)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_split_regexp_argument.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_split_regexp_argument.rb
deleted file mode 100644
index 77a0b95c649db..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_split_regexp_argument.rb
+++ /dev/null
@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where `split` argument can be replaced from
-      # a deterministic regexp to a string.
-      #
-      # @example
-      #   # bad
-      #   'a,b,c'.split(/,/)
-      #
-      #   # good
-      #   'a,b,c'.split(',')
-      class RedundantSplitRegexpArgument < Base
-        extend AutoCorrector
-
-        MSG = 'Use string as argument instead of regexp.'
-        RESTRICT_ON_SEND = %i[split].freeze
-        DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
-        STR_SPECIAL_CHARS = %w[\n \" \' \\\\ \t \b \f \r].freeze
-
-        def_node_matcher :split_call_with_regexp?, <<~PATTERN
-          {(send !nil? :split $regexp)}
-        PATTERN
-
-        def on_send(node)
-          return unless (regexp_node = split_call_with_regexp?(node))
-          return if regexp_node.ignore_case? || regexp_node.content == ' '
-          return unless determinist_regexp?(regexp_node)
-
-          add_offense(regexp_node) do |corrector|
-            new_argument = replacement(regexp_node)
-
-            corrector.replace(regexp_node, "\"#{new_argument}\"")
-          end
-        end
-
-        private
-
-        def determinist_regexp?(regexp_node)
-          DETERMINISTIC_REGEX.match?(regexp_node.source)
-        end
-
-        def replacement(regexp_node)
-          regexp_content = regexp_node.content
-          stack = []
-          chars = regexp_content.chars.each_with_object([]) do |char, strings|
-            if stack.empty? && char == '\\'
-              stack.push(char)
-            else
-              strings << "#{stack.pop}#{char}"
-            end
-          end
-          chars.map do |char|
-            char = char.dup
-            char.delete!('\\') unless STR_SPECIAL_CHARS.include?(char)
-            char
-          end.join
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb
deleted file mode 100644
index 000d887ced299..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb
+++ /dev/null
@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Checks for redundant `String#chars`.
-      #
-      # @example
-      #   # bad
-      #   str.chars[0..2]
-      #   str.chars.slice(0..2)
-      #
-      #   # good
-      #   str[0..2].chars
-      #
-      #   # bad
-      #   str.chars.first
-      #   str.chars.first(2)
-      #
-      #   # good
-      #   str[0]
-      #   str[0...2].chars
-      #
-      #   # bad
-      #   str.chars.take(2)
-      #   str.chars.length
-      #   str.chars.size
-      #   str.chars.empty?
-      #
-      #   # good
-      #   str[0...2].chars
-      #   str.length
-      #   str.size
-      #   str.empty?
-      #
-      #   # For example, if the receiver is a blank string, it will be incompatible.
-      #   # If a negative value is specified for the receiver, `nil` is returned.
-      #   str.chars.last    # Incompatible with `str[-1]`.
-      #   str.chars.last(2) # Incompatible with `str[-2..-1].chars`.
-      #   str.chars.drop(2) # Incompatible with `str[2..-1].chars`.
-      #
-      class RedundantStringChars < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
-        RESTRICT_ON_SEND = %i[[] slice first take length size empty?].freeze
-
-        def_node_matcher :redundant_chars_call?, <<~PATTERN
-          (send $(send _ :chars) $_ $...)
-        PATTERN
-
-        def on_send(node)
-          return unless (receiver, method, args = redundant_chars_call?(node))
-
-          range = offense_range(receiver, node)
-          message = build_message(method, args)
-
-          add_offense(range, message: message) do |corrector|
-            range = correction_range(receiver, node)
-            replacement = build_good_method(method, args)
-
-            corrector.replace(range, replacement)
-          end
-        end
-
-        private
-
-        def offense_range(receiver, node)
-          range_between(receiver.loc.selector.begin_pos, node.loc.expression.end_pos)
-        end
-
-        def correction_range(receiver, node)
-          range_between(receiver.loc.dot.begin_pos, node.loc.expression.end_pos)
-        end
-
-        def build_message(method, args)
-          good_method = build_good_method(method, args)
-          bad_method = build_bad_method(method, args)
-          format(MSG, good_method: good_method, bad_method: bad_method)
-        end
-
-        def build_good_method(method, args)
-          case method
-          when :slice
-            "[#{build_call_args(args)}].chars"
-          when :[], :first
-            build_good_method_for_brackets_or_first_method(method, args)
-          when :take
-            "[0...#{args.first.source}].chars"
-          else
-            ".#{method}"
-          end
-        end
-
-        def build_good_method_for_brackets_or_first_method(method, args)
-          first_arg = args.first
-
-          if first_arg&.range_type?
-            "[#{build_call_args(args)}].chars"
-          elsif method == :first && args.any?
-            "[0...#{args.first.source}].chars"
-          else
-            first_arg ? "[#{first_arg.source}]" : '[0]'
-          end
-        end
-
-        def build_bad_method(method, args)
-          case method
-          when :[]
-            "chars[#{build_call_args(args)}]"
-          else
-            if args.any?
-              "chars.#{method}(#{build_call_args(args)})"
-            else
-              "chars.#{method}"
-            end
-          end
-        end
-
-        def build_call_args(call_args_node)
-          call_args_node.map(&:source).join(', ')
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb
deleted file mode 100644
index 2b7eecc7e84be..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb
+++ /dev/null
@@ -1,288 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # In Ruby 2.4, `String#match?`, `Regexp#match?`, and `Symbol#match?`
-      # have been added. The methods are faster than `match`.
-      # Because the methods avoid creating a `MatchData` object or saving
-      # backref.
-      # So, when `MatchData` is not used, use `match?` instead of `match`.
-      #
-      # @example
-      #   # bad
-      #   def foo
-      #     if x =~ /re/
-      #       do_something
-      #     end
-      #   end
-      #
-      #   # bad
-      #   def foo
-      #     if x !~ /re/
-      #       do_something
-      #     end
-      #   end
-      #
-      #   # bad
-      #   def foo
-      #     if x.match(/re/)
-      #       do_something
-      #     end
-      #   end
-      #
-      #   # bad
-      #   def foo
-      #     if /re/ === x
-      #       do_something
-      #     end
-      #   end
-      #
-      #   # good
-      #   def foo
-      #     if x.match?(/re/)
-      #       do_something
-      #     end
-      #   end
-      #
-      #   # good
-      #   def foo
-      #     if !x.match?(/re/)
-      #       do_something
-      #     end
-      #   end
-      #
-      #   # good
-      #   def foo
-      #     if x =~ /re/
-      #       do_something(Regexp.last_match)
-      #     end
-      #   end
-      #
-      #   # good
-      #   def foo
-      #     if x.match(/re/)
-      #       do_something($~)
-      #     end
-      #   end
-      #
-      #   # good
-      #   def foo
-      #     if /re/ === x
-      #       do_something($~)
-      #     end
-      #   end
-      class RegexpMatch < Base
-        extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.4
-
-        # Constants are included in this list because it is unlikely that
-        # someone will store `nil` as a constant and then use it for comparison
-        TYPES_IMPLEMENTING_MATCH = %i[const regexp str sym].freeze
-        MSG = 'Use `match?` instead of `%<current>s` when `MatchData` is not used.'
-
-        def_node_matcher :match_method?, <<~PATTERN
-          {
-            (send _recv :match {regexp str sym})
-            (send {regexp str sym} :match _)
-          }
-        PATTERN
-
-        def_node_matcher :match_with_int_arg_method?, <<~PATTERN
-          (send _recv :match _ (int ...))
-        PATTERN
-
-        def_node_matcher :match_operator?, <<~PATTERN
-          (send !nil? {:=~ :!~} !nil?)
-        PATTERN
-
-        def_node_matcher :match_threequals?, <<~PATTERN
-          (send (regexp (str _) {(regopt) (regopt _)}) :=== !nil?)
-        PATTERN
-
-        def match_with_lvasgn?(node)
-          return false unless node.match_with_lvasgn_type?
-
-          regexp, _rhs = *node
-          regexp.to_regexp.named_captures.empty?
-        end
-
-        MATCH_NODE_PATTERN = <<~PATTERN
-          {
-            #match_method?
-            #match_with_int_arg_method?
-            #match_operator?
-            #match_threequals?
-            #match_with_lvasgn?
-          }
-        PATTERN
-
-        def_node_matcher :match_node?, MATCH_NODE_PATTERN
-        def_node_search :search_match_nodes, MATCH_NODE_PATTERN
-
-        def_node_search :last_matches, <<~PATTERN
-          {
-            (send (const nil? :Regexp) :last_match)
-            (send (const nil? :Regexp) :last_match _)
-            ({back_ref nth_ref} _)
-            (gvar #match_gvar?)
-          }
-        PATTERN
-
-        def on_if(node)
-          check_condition(node.condition)
-        end
-
-        def on_case(node)
-          return if node.condition
-
-          node.each_when do |when_node|
-            when_node.each_condition do |condition|
-              check_condition(condition)
-            end
-          end
-        end
-
-        private
-
-        def check_condition(cond)
-          match_node?(cond) do
-            return if last_match_used?(cond)
-
-            message = message(cond)
-            add_offense(cond, message: message) do |corrector|
-              autocorrect(corrector, cond)
-            end
-          end
-        end
-
-        def autocorrect(corrector, node)
-          if match_method?(node) || match_with_int_arg_method?(node)
-            corrector.replace(node.loc.selector, 'match?')
-          elsif match_operator?(node) || match_threequals?(node)
-            recv, oper, arg = *node
-            correct_operator(corrector, recv, arg, oper)
-          elsif match_with_lvasgn?(node)
-            recv, arg = *node
-            correct_operator(corrector, recv, arg)
-          end
-        end
-
-        def message(node)
-          format(MSG, current: node.loc.selector.source)
-        end
-
-        def last_match_used?(match_node)
-          scope_root = scope_root(match_node)
-          body = scope_root ? scope_body(scope_root) : match_node.ancestors.last
-
-          range = range_to_search_for_last_matches(match_node, body, scope_root)
-
-          find_last_match(body, range, scope_root)
-        end
-
-        def range_to_search_for_last_matches(match_node, body, scope_root)
-          expression = if modifier_form?(match_node)
-                         match_node.parent.if_branch.loc.expression
-                       else
-                         match_node.loc.expression
-                       end
-
-          match_node_pos = expression.begin_pos
-          next_match_pos = next_match_pos(body, match_node_pos, scope_root)
-
-          match_node_pos..next_match_pos
-        end
-
-        def next_match_pos(body, match_node_pos, scope_root)
-          node = search_match_nodes(body).find do |match|
-            begin_pos = if modifier_form?(match)
-                          match.parent.if_branch.loc.expression.begin_pos
-                        else
-                          match.loc.expression.begin_pos
-                        end
-
-            begin_pos > match_node_pos && scope_root(match) == scope_root
-          end
-
-          node ? node.loc.expression.begin_pos : Float::INFINITY
-        end
-
-        def modifier_form?(match_node)
-          match_node.parent.if_type? && match_node.parent.modifier_form?
-        end
-
-        def find_last_match(body, range, scope_root)
-          last_matches(body).find do |ref|
-            ref_pos = ref.loc.expression.begin_pos
-            range.cover?(ref_pos) &&
-              scope_root(ref) == scope_root
-          end
-        end
-
-        def scope_body(node)
-          children = node.children
-          case node.type
-          when :module
-            children[1]
-          when :defs
-            children[3]
-          else
-            children[2]
-          end
-        end
-
-        def scope_root(node)
-          node.each_ancestor.find do |ancestor|
-            ancestor.def_type? || ancestor.defs_type? || ancestor.class_type? || ancestor.module_type?
-          end
-        end
-
-        def match_gvar?(sym)
-          %i[
-            $~
-            $MATCH
-            $PREMATCH
-            $POSTMATCH
-            $LAST_PAREN_MATCH
-            $LAST_MATCH_INFO
-          ].include?(sym)
-        end
-
-        def correct_operator(corrector, recv, arg, oper = nil)
-          op_range = correction_range(recv, arg)
-
-          replace_with_match_predicate_method(corrector, recv, arg, op_range)
-
-          corrector.insert_after(arg.loc.expression, ')') unless op_range.source.end_with?('(')
-          corrector.insert_before(recv.loc.expression, '!') if oper == :!~
-        end
-
-        def replace_with_match_predicate_method(corrector, recv, arg, op_range)
-          if TYPES_IMPLEMENTING_MATCH.include?(recv.type)
-            corrector.replace(op_range, '.match?(')
-          elsif TYPES_IMPLEMENTING_MATCH.include?(arg.type)
-            corrector.replace(op_range, '.match?(')
-            swap_receiver_and_arg(corrector, recv, arg)
-          else
-            corrector.replace(op_range, '&.match?(')
-          end
-        end
-
-        def swap_receiver_and_arg(corrector, recv, arg)
-          corrector.replace(recv.loc.expression, arg.source)
-          corrector.replace(arg.loc.expression, recv.source)
-        end
-
-        def correction_range(recv, arg)
-          buffer = processed_source.buffer
-          op_begin_pos = recv.loc.expression.end_pos
-          op_end_pos = arg.loc.expression.begin_pos
-          Parser::Source::Range.new(buffer, op_begin_pos, op_end_pos)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_each.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_each.rb
deleted file mode 100644
index 4be4fb7b039c2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_each.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies usages of `reverse.each` and change them to use `reverse_each` instead.
-      #
-      # If the return value is used, it will not be detected because the result will be different.
-      #
-      # [source,ruby]
-      # ----
-      # [1, 2, 3].reverse.each {} #=> [3, 2, 1]
-      # [1, 2, 3].reverse_each {} #=> [1, 2, 3]
-      # ----
-      #
-      # @example
-      #   # bad
-      #   items.reverse.each
-      #
-      #   # good
-      #   items.reverse_each
-      class ReverseEach < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `reverse_each` instead of `reverse.each`.'
-        RESTRICT_ON_SEND = %i[each].freeze
-
-        def_node_matcher :reverse_each?, <<~MATCHER
-          (send (send _ :reverse) :each)
-        MATCHER
-
-        def on_send(node)
-          return if use_return_value?(node)
-
-          reverse_each?(node) do
-            range = offense_range(node)
-
-            add_offense(range) do |corrector|
-              corrector.replace(range, 'reverse_each')
-            end
-          end
-        end
-
-        private
-
-        def use_return_value?(node)
-          !!node.ancestors.detect do |ancestor|
-            ancestor.assignment? || ancestor.send_type? || ancestor.return_type?
-          end
-        end
-
-        def offense_range(node)
-          range_between(node.children.first.loc.selector.begin_pos, node.loc.selector.end_pos)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_first.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_first.rb
deleted file mode 100644
index dde61bd38a652..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_first.rb
+++ /dev/null
@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where `reverse.first(n)` and `reverse.first`
-      # can be replaced by `last(n).reverse` and `last`.
-      #
-      # @example
-      #
-      #   # bad
-      #   array.reverse.first(5)
-      #   array.reverse.first
-      #
-      #   # good
-      #   array.last(5).reverse
-      #   array.last
-      #
-      class ReverseFirst < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
-        RESTRICT_ON_SEND = %i[first].freeze
-
-        def_node_matcher :reverse_first_candidate?, <<~PATTERN
-          (send $(send _ :reverse) :first (int _)?)
-        PATTERN
-
-        def on_send(node)
-          reverse_first_candidate?(node) do |receiver|
-            range = correction_range(receiver, node)
-            message = build_message(node)
-
-            add_offense(range, message: message) do |corrector|
-              replacement = build_good_method(node)
-
-              corrector.replace(range, replacement)
-            end
-          end
-        end
-
-        private
-
-        def correction_range(receiver, node)
-          range_between(receiver.loc.selector.begin_pos, node.loc.expression.end_pos)
-        end
-
-        def build_message(node)
-          good_method = build_good_method(node)
-          bad_method = build_bad_method(node)
-          format(MSG, good_method: good_method, bad_method: bad_method)
-        end
-
-        def build_good_method(node)
-          if node.arguments?
-            "last(#{node.arguments.first.source}).reverse"
-          else
-            'last'
-          end
-        end
-
-        def build_bad_method(node)
-          if node.arguments?
-            "reverse.first(#{node.arguments.first.source})"
-          else
-            'reverse.first'
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/select_map.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/select_map.rb
deleted file mode 100644
index ee13f68ad310a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/select_map.rb
+++ /dev/null
@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # In Ruby 2.7, `Enumerable#filter_map` has been added.
-      #
-      # This cop identifies places where `select.map` can be replaced by `filter_map`.
-      #
-      # @example
-      #   # bad
-      #   ary.select(&:foo).map(&:bar)
-      #   ary.filter(&:foo).map(&:bar)
-      #
-      #   # good
-      #   ary.filter_map { |o| o.bar if o.foo }
-      #
-      class SelectMap < Base
-        include RangeHelp
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.7
-
-        MSG = 'Use `filter_map` instead of `%<method_name>s.map`.'
-        RESTRICT_ON_SEND = %i[select filter].freeze
-
-        def_node_matcher :bad_method?, <<~PATTERN
-          (send nil? :bad_method ...)
-        PATTERN
-
-        def on_send(node)
-          return if (first_argument = node.first_argument) && !first_argument.block_pass_type?
-          return unless (send_node = map_method_candidate(node))
-          return unless send_node.method?(:map)
-
-          map_method = send_node.parent&.block_type? ? send_node.parent : send_node
-
-          range = offense_range(node, map_method)
-          add_offense(range, message: format(MSG, method_name: node.method_name))
-        end
-
-        private
-
-        def map_method_candidate(node)
-          return unless (parent = node.parent)
-
-          if parent.block_type? && parent.parent&.send_type?
-            parent.parent
-          elsif parent.send_type?
-            parent
-          end
-        end
-
-        def offense_range(node, map_method)
-          range_between(node.loc.selector.begin_pos, map_method.loc.expression.end_pos)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/size.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/size.rb
deleted file mode 100644
index b107949a7801d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/size.rb
+++ /dev/null
@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies usages of `count` on an `Array` and `Hash` and change them to `size`.
-      #
-      # @example
-      #   # bad
-      #   [1, 2, 3].count
-      #   (1..3).to_a.count
-      #   Array[*1..3].count
-      #   Array(1..3).count
-      #
-      #   # bad
-      #   {a: 1, b: 2, c: 3}.count
-      #   [[:foo, :bar], [1, 2]].to_h.count
-      #   Hash[*('a'..'z')].count
-      #   Hash(key: :value).count
-      #
-      #   # good
-      #   [1, 2, 3].size
-      #   (1..3).to_a.size
-      #   Array[*1..3].size
-      #   Array(1..3).size
-      #
-      #   # good
-      #   {a: 1, b: 2, c: 3}.size
-      #   [[:foo, :bar], [1, 2]].to_h.size
-      #   Hash[*('a'..'z')].size
-      #   Hash(key: :value).size
-      #
-      #   # good
-      #   [1, 2, 3].count { |e| e > 2 }
-      # TODO: Add advanced detection of variables that could
-      # have been assigned to an array or a hash.
-      class Size < Base
-        extend AutoCorrector
-
-        MSG = 'Use `size` instead of `count`.'
-        RESTRICT_ON_SEND = %i[count].freeze
-
-        def_node_matcher :array?, <<~PATTERN
-          {
-            [!nil? array_type?]
-            (send _ :to_a)
-            (send (const nil? :Array) :[] _)
-            (send nil? :Array _)
-          }
-        PATTERN
-
-        def_node_matcher :hash?, <<~PATTERN
-          {
-            [!nil? hash_type?]
-            (send _ :to_h)
-            (send (const nil? :Hash) :[] _)
-            (send nil? :Hash _)
-          }
-        PATTERN
-
-        def_node_matcher :count?, <<~PATTERN
-          (send {#array? #hash?} :count)
-        PATTERN
-
-        def on_send(node)
-          return if node.parent&.block_type? || !count?(node)
-
-          add_offense(node.loc.selector) do |corrector|
-            corrector.replace(node.loc.selector, 'size')
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/sort_reverse.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/sort_reverse.rb
deleted file mode 100644
index 301906804ec2d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/sort_reverse.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where `sort { |a, b| b <=> a }`
-      # can be replaced by a faster `sort.reverse`.
-      #
-      # @example
-      #   # bad
-      #   array.sort { |a, b| b <=> a }
-      #
-      #   # good
-      #   array.sort.reverse
-      #
-      class SortReverse < Base
-        include SortBlock
-        extend AutoCorrector
-
-        MSG = 'Use `sort.reverse` instead of `%<bad_method>s`.'
-
-        def on_block(node)
-          sort_with_block?(node) do |send, var_a, var_b, body|
-            replaceable_body?(body, var_b, var_a) do
-              range = sort_range(send, node)
-
-              add_offense(range, message: message(var_a, var_b)) do |corrector|
-                replacement = 'sort.reverse'
-
-                corrector.replace(range, replacement)
-              end
-            end
-          end
-        end
-
-        private
-
-        def message(var_a, var_b)
-          bad_method = "sort { |#{var_a}, #{var_b}| #{var_b} <=> #{var_a} }"
-          format(MSG, bad_method: bad_method)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/squeeze.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/squeeze.rb
deleted file mode 100644
index 3b7c0bfb58702..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/squeeze.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where `gsub(/a+/, 'a')` and `gsub!(/a+/, 'a')`
-      # can be replaced by `squeeze('a')` and `squeeze!('a')`.
-      #
-      # The `squeeze('a')` method is faster than `gsub(/a+/, 'a')`.
-      #
-      # @example
-      #
-      #   # bad
-      #   str.gsub(/a+/, 'a')
-      #   str.gsub!(/a+/, 'a')
-      #
-      #   # good
-      #   str.squeeze('a')
-      #   str.squeeze!('a')
-      #
-      class Squeeze < Base
-        extend AutoCorrector
-
-        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
-        RESTRICT_ON_SEND = %i[gsub gsub!].freeze
-
-        PREFERRED_METHODS = {
-          gsub: :squeeze,
-          gsub!: :squeeze!
-        }.freeze
-
-        def_node_matcher :squeeze_candidate?, <<~PATTERN
-          (send
-            $!nil? ${:gsub :gsub!}
-            (regexp
-              (str $#repeating_literal?)
-              (regopt))
-            (str $_))
-        PATTERN
-
-        def on_send(node)
-          squeeze_candidate?(node) do |receiver, bad_method, regexp_str, replace_str|
-            regexp_str = regexp_str[0..-2] # delete '+' from the end
-            regexp_str = interpret_string_escapes(regexp_str)
-            return unless replace_str == regexp_str
-
-            good_method = PREFERRED_METHODS[bad_method]
-            message = format(MSG, current: bad_method, prefer: good_method)
-
-            add_offense(node.loc.selector, message: message) do |corrector|
-              string_literal = to_string_literal(replace_str)
-              new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
-
-              corrector.replace(node.source_range, new_code)
-            end
-          end
-        end
-
-        private
-
-        def repeating_literal?(regex_str)
-          regex_str.match?(/\A(?:#{Util::LITERAL_REGEX})\+\z/o)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/start_with.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/start_with.rb
deleted file mode 100644
index bf35a10af23e2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/start_with.rb
+++ /dev/null
@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies unnecessary use of a regex where `String#start_with?` would suffice.
-      #
-      # This cop has `SafeMultiline` configuration option that `true` by default because
-      # `^start` is unsafe as it will behave incompatible with `start_with?`
-      # for receiver is multiline string.
-      #
-      # @safety
-      #   This will change to a new method call which isn't guaranteed to be on the
-      #   object. Switching these methods has to be done with knowledge of the types
-      #   of the variables which rubocop doesn't have.
-      #
-      # @example
-      #   # bad
-      #   'abc'.match?(/\Aab/)
-      #   /\Aab/.match?('abc')
-      #   'abc' =~ /\Aab/
-      #   /\Aab/ =~ 'abc'
-      #   'abc'.match(/\Aab/)
-      #   /\Aab/.match('abc')
-      #
-      #   # good
-      #   'abc'.start_with?('ab')
-      #
-      # @example SafeMultiline: true (default)
-      #
-      #   # good
-      #   'abc'.match?(/^ab/)
-      #   /^ab/.match?('abc')
-      #   'abc' =~ /^ab/
-      #   /^ab/ =~ 'abc'
-      #   'abc'.match(/^ab/)
-      #   /^ab/.match('abc')
-      #
-      # @example SafeMultiline: false
-      #
-      #   # bad
-      #   'abc'.match?(/^ab/)
-      #   /^ab/.match?('abc')
-      #   'abc' =~ /^ab/
-      #   /^ab/ =~ 'abc'
-      #   'abc'.match(/^ab/)
-      #   /^ab/.match('abc')
-      #
-      class StartWith < Base
-        include RegexpMetacharacter
-        extend AutoCorrector
-
-        MSG = 'Use `String#start_with?` instead of a regex match anchored to ' \
-              'the beginning of the string.'
-        RESTRICT_ON_SEND = %i[match =~ match?].freeze
-
-        def_node_matcher :redundant_regex?, <<~PATTERN
-          {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_start?) (regopt)))
-           (send (regexp (str $#literal_at_start?) (regopt)) {:match :match?} $_)
-           (match-with-lvasgn (regexp (str $#literal_at_start?) (regopt)) $_)}
-        PATTERN
-
-        def on_send(node)
-          return unless (receiver, regex_str = redundant_regex?(node))
-
-          add_offense(node) do |corrector|
-            receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
-            regex_str = drop_start_metacharacter(regex_str)
-            regex_str = interpret_string_escapes(regex_str)
-
-            new_source = "#{receiver.source}.start_with?(#{to_string_literal(regex_str)})"
-
-            corrector.replace(node.source_range, new_source)
-          end
-        end
-        alias on_match_with_lvasgn on_send
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_identifier_argument.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_identifier_argument.rb
deleted file mode 100644
index 00a0bacd9e3bc..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_identifier_argument.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where string identifier argument can be replaced
-      # by symbol identifier argument.
-      # It prevents the redundancy of the internal string-to-symbol conversion.
-      #
-      # This cop targets methods that take identifier (e.g. method name) argument
-      # and the following examples are parts of it.
-      #
-      # @example
-      #
-      #   # bad
-      #   send('do_something')
-      #   attr_accessor 'do_something'
-      #   instance_variable_get('@ivar')
-      #
-      #   # good
-      #   send(:do_something)
-      #   attr_accessor :do_something
-      #   instance_variable_get(:@ivar)
-      #
-      class StringIdentifierArgument < Base
-        extend AutoCorrector
-
-        MSG = 'Use `%<symbol_arg>s` instead of `%<string_arg>s`.'
-
-        # NOTE: `attr` method is not included in this list as it can cause false positives in Nokogiri API.
-        # And `attr` may not be used because `Style/Attr` registers an offense.
-        # https://github.com/rubocop/rubocop-performance/issues/278
-        RESTRICT_ON_SEND = %i[
-          alias_method attr_accessor attr_reader attr_writer autoload autoload?
-          class_variable_defined? const_defined? const_get const_set const_source_location
-          define_method instance_method method_defined? private_class_method? private_method_defined?
-          protected_method_defined? public_class_method public_instance_method public_method_defined?
-          remove_class_variable remove_method undef_method class_variable_get class_variable_set
-          deprecate_constant module_function private private_constant protected public public_constant
-          remove_const ruby2_keywords
-          define_singleton_method instance_variable_defined? instance_variable_get instance_variable_set
-          method public_method public_send remove_instance_variable respond_to? send singleton_method
-          __send__
-        ].freeze
-
-        def on_send(node)
-          return unless (first_argument = node.first_argument)
-          return unless first_argument.str_type?
-          return if first_argument.value.include?(' ') || first_argument.value.include?('::')
-
-          replacement = first_argument.value.to_sym.inspect
-
-          message = format(MSG, symbol_arg: replacement, string_arg: first_argument.source)
-
-          add_offense(first_argument, message: message) do |corrector|
-            corrector.replace(first_argument, replacement)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_include.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_include.rb
deleted file mode 100644
index c3d8dcf30a82b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_include.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies unnecessary use of a regex where `String#include?` would suffice.
-      #
-      # @safety
-      #   This cop's offenses are not safe to autocorrect if a receiver is nil.
-      #
-      # @example
-      #   # bad
-      #   'abc'.match?(/ab/)
-      #   /ab/.match?('abc')
-      #   'abc' =~ /ab/
-      #   /ab/ =~ 'abc'
-      #   'abc'.match(/ab/)
-      #   /ab/.match('abc')
-      #
-      #   # good
-      #   'abc'.include?('ab')
-      class StringInclude < Base
-        extend AutoCorrector
-
-        MSG = 'Use `String#include?` instead of a regex match with literal-only pattern.'
-        RESTRICT_ON_SEND = %i[match =~ match?].freeze
-
-        def_node_matcher :redundant_regex?, <<~PATTERN
-          {(send $!nil? {:match :=~ :match?} (regexp (str $#literal?) (regopt)))
-           (send (regexp (str $#literal?) (regopt)) {:match :match?} $str)
-           (match-with-lvasgn (regexp (str $#literal?) (regopt)) $_)}
-        PATTERN
-
-        def on_send(node)
-          return unless (receiver, regex_str = redundant_regex?(node))
-
-          add_offense(node) do |corrector|
-            receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
-            regex_str = interpret_string_escapes(regex_str)
-
-            new_source = "#{receiver.source}.include?(#{to_string_literal(regex_str)})"
-
-            corrector.replace(node.source_range, new_source)
-          end
-        end
-        alias on_match_with_lvasgn on_send
-
-        private
-
-        def literal?(regex_str)
-          regex_str.match?(/\A#{Util::LITERAL_REGEX}+\z/o)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb
deleted file mode 100644
index cc9358a528c57..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb
+++ /dev/null
@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where `gsub` can be replaced by `tr` or `delete`.
-      #
-      # @example
-      #   # bad
-      #   'abc'.gsub('b', 'd')
-      #   'abc'.gsub('a', '')
-      #   'abc'.gsub(/a/, 'd')
-      #   'abc'.gsub!('a', 'd')
-      #
-      #   # good
-      #   'abc'.gsub(/.*/, 'a')
-      #   'abc'.gsub(/a+/, 'd')
-      #   'abc'.tr('b', 'd')
-      #   'a b c'.delete(' ')
-      class StringReplacement < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
-        RESTRICT_ON_SEND = %i[gsub gsub!].freeze
-        DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
-        DELETE = 'delete'
-        TR = 'tr'
-        BANG = '!'
-
-        def_node_matcher :string_replacement?, <<~PATTERN
-          (send _ {:gsub :gsub!}
-                    ${regexp str (send (const nil? :Regexp) {:new :compile} _)}
-                    $str)
-        PATTERN
-
-        def on_send(node)
-          string_replacement?(node) do |first_param, second_param|
-            return if accept_second_param?(second_param)
-            return if accept_first_param?(first_param)
-
-            offense(node, first_param, second_param)
-          end
-        end
-
-        private
-
-        def offense(node, first_param, second_param)
-          first_source, = first_source(first_param)
-          first_source = interpret_string_escapes(first_source) unless first_param.str_type?
-          second_source, = *second_param
-          message = message(node, first_source, second_source)
-
-          add_offense(range(node), message: message) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-
-        def autocorrect(corrector, node)
-          _string, _method, first_param, second_param = *node
-          first_source, = first_source(first_param)
-          second_source, = *second_param
-
-          first_source = interpret_string_escapes(first_source) unless first_param.str_type?
-
-          replace_method(corrector, node, first_source, second_source, first_param)
-        end
-
-        def replace_method(corrector, node, first_source, second_source, first_param)
-          replacement_method = replacement_method(node, first_source, second_source)
-
-          corrector.replace(node.loc.selector, replacement_method)
-          corrector.replace(first_param.source_range, to_string_literal(first_source)) unless first_param.str_type?
-
-          remove_second_param(corrector, node, first_param) if second_source.empty? && first_source.length == 1
-        end
-
-        def accept_second_param?(second_param)
-          second_source, = *second_param
-          second_source.length > 1
-        end
-
-        def accept_first_param?(first_param)
-          first_source, options = first_source(first_param)
-          return true if first_source.nil?
-
-          unless first_param.str_type?
-            return true if options
-            return true unless first_source.is_a?(String) &&
-                               first_source =~ DETERMINISTIC_REGEX
-
-            # This must be done after checking DETERMINISTIC_REGEX
-            # Otherwise things like \s will trip us up
-            first_source = interpret_string_escapes(first_source)
-          end
-
-          first_source.length != 1
-        end
-
-        def first_source(first_param)
-          case first_param.type
-          when :regexp
-            source_from_regex_literal(first_param)
-          when :send
-            source_from_regex_constructor(first_param)
-          when :str
-            first_param.children.first
-          end
-        end
-
-        def source_from_regex_literal(node)
-          regex, options = *node
-          source, = *regex
-          options, = *options
-          [source, options]
-        end
-
-        def source_from_regex_constructor(node)
-          _const, _init, regex = *node
-          case regex.type
-          when :regexp
-            source_from_regex_literal(regex)
-          when :str
-            source, = *regex
-            source
-          end
-        end
-
-        def range(node)
-          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
-        end
-
-        def replacement_method(node, first_source, second_source)
-          replacement = if second_source.empty? && first_source.length == 1
-                          DELETE
-                        else
-                          TR
-                        end
-
-          "#{replacement}#{BANG if node.bang_method?}"
-        end
-
-        def message(node, first_source, second_source)
-          replacement_method =
-            replacement_method(node, first_source, second_source)
-
-          format(MSG, prefer: replacement_method, current: node.method_name)
-        end
-
-        def method_suffix(node)
-          node.loc.end ? node.loc.end.source : ''
-        end
-
-        def remove_second_param(corrector, node, first_param)
-          end_range = range_between(first_param.source_range.end_pos,
-                                    node.source_range.end_pos)
-
-          corrector.replace(end_range, method_suffix(node))
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb
deleted file mode 100644
index 10303a56b9e47..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb
+++ /dev/null
@@ -1,266 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where custom code finding the sum of elements
-      # in some Enumerable object can be replaced by `Enumerable#sum` method.
-      #
-      # @safety
-      #   Autocorrections are unproblematic wherever an initial value is provided explicitly:
-      #
-      #   [source,ruby]
-      #   ----
-      #   [1, 2, 3].reduce(4, :+) # => 10
-      #   [1, 2, 3].sum(4) # => 10
-      #
-      #   [].reduce(4, :+) # => 4
-      #   [].sum(4) # => 4
-      #   ----
-      #
-      #   This also holds true for non-numeric types which implement a `:+` method:
-      #
-      #   [source,ruby]
-      #   ----
-      #   ['l', 'o'].reduce('Hel', :+) # => "Hello"
-      #   ['l', 'o'].sum('Hel') # => "Hello"
-      #   ----
-      #
-      #   When no initial value is provided though, `Enumerable#reduce` will pick the first enumerated value
-      #   as initial value and successively add all following values to it, whereas
-      #   `Enumerable#sum` will set an initial value of `0` (`Integer`) which can lead to a `TypeError`:
-      #
-      #   [source,ruby]
-      #   ----
-      #   [].reduce(:+) # => nil
-      #   [1, 2, 3].reduce(:+) # => 6
-      #   ['H', 'e', 'l', 'l', 'o'].reduce(:+) # => "Hello"
-      #
-      #   [].sum # => 0
-      #   [1, 2, 3].sum # => 6
-      #   ['H', 'e', 'l', 'l', 'o'].sum # => in `+': String can't be coerced into Integer (TypeError)
-      #   ----
-      #
-      # @example OnlySumOrWithInitialValue: false (default)
-      #   # bad
-      #   [1, 2, 3].inject(:+)                        # Autocorrections for cases without initial value are unsafe
-      #   [1, 2, 3].inject(&:+)                       # and will only be performed when using the `-A` option.
-      #   [1, 2, 3].reduce { |acc, elem| acc + elem } # They can be prohibited completely using `SafeAutoCorrect: true`.
-      #   [1, 2, 3].reduce(10, :+)
-      #   [1, 2, 3].map { |elem| elem ** 2 }.sum
-      #   [1, 2, 3].collect(&:count).sum(10)
-      #
-      #   # good
-      #   [1, 2, 3].sum
-      #   [1, 2, 3].sum(10)
-      #   [1, 2, 3].sum { |elem| elem ** 2 }
-      #   [1, 2, 3].sum(10, &:count)
-      #
-      # @example OnlySumOrWithInitialValue: true
-      #   # bad
-      #   [1, 2, 3].reduce(10, :+)
-      #   [1, 2, 3].map { |elem| elem ** 2 }.sum
-      #   [1, 2, 3].collect(&:count).sum(10)
-      #
-      #   # good
-      #   [1, 2, 3].sum(10)
-      #   [1, 2, 3].sum { |elem| elem ** 2 }
-      #   [1, 2, 3].sum(10, &:count)
-      #
-      class Sum < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
-        MSG_IF_NO_INIT_VALUE =
-          'Use `%<good_method>s` instead of `%<bad_method>s`, unless calling `%<bad_method>s` on an empty array.'
-        RESTRICT_ON_SEND = %i[inject reduce sum].freeze
-
-        def_node_matcher :sum_candidate?, <<~PATTERN
-          (send _ ${:inject :reduce} $_init ? ${(sym :+) (block_pass (sym :+))})
-        PATTERN
-
-        def_node_matcher :sum_map_candidate?, <<~PATTERN
-          (send
-            {
-              (block $(send _ {:map :collect}) ...)
-              $(send _ {:map :collect} (block_pass _))
-            }
-          :sum $_init ?)
-        PATTERN
-
-        def_node_matcher :sum_with_block_candidate?, <<~PATTERN
-          (block
-            $(send _ {:inject :reduce} $_init ?)
-            (args (arg $_acc) (arg $_elem))
-            $send)
-        PATTERN
-
-        def_node_matcher :acc_plus_elem?, <<~PATTERN
-          (send (lvar %1) :+ (lvar %2))
-        PATTERN
-        alias elem_plus_acc? acc_plus_elem?
-
-        def on_send(node)
-          return if empty_array_literal?(node)
-
-          handle_sum_candidate(node)
-          handle_sum_map_candidate(node)
-        end
-
-        def on_block(node)
-          sum_with_block_candidate?(node) do |send, init, var_acc, var_elem, body|
-            if acc_plus_elem?(body, var_acc, var_elem) || elem_plus_acc?(body, var_elem, var_acc)
-              range = sum_block_range(send, node)
-              message = build_block_message(send, init, var_acc, var_elem, body)
-
-              add_offense(range, message: message) do |corrector|
-                autocorrect(corrector, init, range)
-              end
-            end
-          end
-        end
-
-        private
-
-        def handle_sum_candidate(node)
-          sum_candidate?(node) do |method, init, operation|
-            next if cop_config['OnlySumOrWithInitialValue'] && init.empty?
-
-            range = sum_method_range(node)
-            message = build_method_message(node, method, init, operation)
-
-            add_offense(range, message: message) do |corrector|
-              autocorrect(corrector, init, range)
-            end
-          end
-        end
-
-        def handle_sum_map_candidate(node)
-          sum_map_candidate?(node) do |map, init|
-            next if node.block_literal? || node.block_argument?
-
-            message = build_sum_map_message(map.method_name, init)
-
-            add_offense(sum_map_range(map, node), message: message) do |corrector|
-              autocorrect_sum_map(corrector, node, map, init)
-            end
-          end
-        end
-
-        def empty_array_literal?(node)
-          receiver = node.children.first
-          array_literal?(node) && receiver && receiver.children.empty?
-        end
-
-        def array_literal?(node)
-          receiver = node.children.first
-          receiver&.literal? && receiver&.array_type?
-        end
-
-        def autocorrect(corrector, init, range)
-          return if init.empty? && safe_autocorrect?
-
-          replacement = build_good_method(init)
-
-          corrector.replace(range, replacement)
-        end
-
-        def autocorrect_sum_map(corrector, sum, map, init)
-          sum_range = method_call_with_args_range(sum)
-          map_range = method_call_with_args_range(map)
-
-          block_pass = map.last_argument if map.last_argument&.block_pass_type?
-          replacement = build_good_method(init, block_pass)
-
-          corrector.remove(sum_range)
-
-          dot = '.' if map.receiver
-          corrector.replace(map_range, "#{dot}#{replacement}")
-        end
-
-        def sum_method_range(node)
-          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
-        end
-
-        def sum_map_range(map, sum)
-          range_between(map.loc.selector.begin_pos, sum.source_range.end.end_pos)
-        end
-
-        def sum_block_range(send, node)
-          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
-        end
-
-        def build_method_message(node, method, init, operation)
-          good_method = build_good_method(init)
-          bad_method = build_method_bad_method(init, method, operation)
-          msg = if init.empty? && !array_literal?(node)
-                  MSG_IF_NO_INIT_VALUE
-                else
-                  MSG
-                end
-          format(msg, good_method: good_method, bad_method: bad_method)
-        end
-
-        def build_sum_map_message(method, init)
-          sum_method = build_good_method(init)
-          good_method = "#{sum_method} { ... }"
-          bad_method = "#{method} { ... }.#{sum_method}"
-          format(MSG, good_method: good_method, bad_method: bad_method)
-        end
-
-        def build_block_message(send, init, var_acc, var_elem, body)
-          good_method = build_good_method(init)
-          bad_method = build_block_bad_method(send.method_name, init, var_acc, var_elem, body)
-          format(MSG, good_method: good_method, bad_method: bad_method)
-        end
-
-        def build_good_method(init, block_pass = nil)
-          good_method = 'sum'
-
-          args = []
-          unless init.empty?
-            init = init.first
-            args << init.source unless init.int_type? && init.value.zero?
-          end
-          args << block_pass.source if block_pass
-          good_method += "(#{args.join(', ')})" unless args.empty?
-          good_method
-        end
-
-        def build_method_bad_method(init, method, operation)
-          bad_method = "#{method}("
-          unless init.empty?
-            init = init.first
-            bad_method += "#{init.source}, "
-          end
-          bad_method += if operation.block_pass_type?
-                          '&:+)'
-                        else
-                          ':+)'
-                        end
-          bad_method
-        end
-
-        def build_block_bad_method(method, init, var_acc, var_elem, body)
-          bad_method = method.to_s
-
-          unless init.empty?
-            init = init.first
-            bad_method += "(#{init.source})"
-          end
-          bad_method += " { |#{var_acc}, #{var_elem}| #{body.source} }"
-          bad_method
-        end
-
-        def method_call_with_args_range(node)
-          if (receiver = node.receiver)
-            receiver.source_range.end.join(node.source_range.end)
-          else
-            node.source_range
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/times_map.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/times_map.rb
deleted file mode 100644
index 977b2c54a8cc4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/times_map.rb
+++ /dev/null
@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Checks for .times.map calls.
-      # In most cases such calls can be replaced
-      # with an explicit array creation.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because `Integer#times` does nothing if receiver is 0
-      #   or less. However, `Array.new` raises an error if argument is less than 0.
-      #
-      #   For example:
-      #
-      #   [source,ruby]
-      #   ----
-      #   -1.times{}    # does nothing
-      #   Array.new(-1) # ArgumentError: negative array size
-      #   ----
-      #
-      # @example
-      #   # bad
-      #   9.times.map do |i|
-      #     i.to_s
-      #   end
-      #
-      #   # good
-      #   Array.new(9) do |i|
-      #     i.to_s
-      #   end
-      class TimesMap < Base
-        extend AutoCorrector
-
-        MESSAGE = 'Use `Array.new(%<count>s)` with a block ' \
-                  'instead of `.times.%<map_or_collect>s`'
-        MESSAGE_ONLY_IF = 'only if `%<count>s` is always 0 or more'
-        RESTRICT_ON_SEND = %i[map collect].freeze
-
-        def on_send(node)
-          check(node)
-        end
-
-        def on_block(node)
-          check(node)
-        end
-
-        private
-
-        def check(node)
-          times_map_call(node) do |map_or_collect, count|
-            add_offense(node, message: message(map_or_collect, count)) do |corrector|
-              replacement = "Array.new(#{count.source}" \
-                            "#{map_or_collect.arguments.map { |arg| ", #{arg.source}" }.join})"
-
-              corrector.replace(map_or_collect.loc.expression, replacement)
-            end
-          end
-        end
-
-        def message(map_or_collect, count)
-          template = if count.literal?
-                       "#{MESSAGE}."
-                     else
-                       "#{MESSAGE} #{MESSAGE_ONLY_IF}."
-                     end
-          format(template, count: count.source, map_or_collect: map_or_collect.method_name)
-        end
-
-        def_node_matcher :times_map_call, <<~PATTERN
-          {(block $(send (send $!nil? :times) {:map :collect}) ...)
-           $(send (send $!nil? :times) {:map :collect} (block_pass ...))}
-        PATTERN
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/unfreeze_string.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/unfreeze_string.rb
deleted file mode 100644
index 7860c269c7590..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/unfreeze_string.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # In Ruby 2.3 or later, use unary plus operator to unfreeze a string
-      # literal instead of `String#dup` and `String.new`.
-      # Unary plus operator is faster than `String#dup`.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because `String.new` (without operator) is not
-      #   exactly the same as `+''`. These differ in encoding. `String.new.encoding` is always
-      #   `ASCII-8BIT`. However, `(+'').encoding` is the same as script encoding(e.g. `UTF-8`).
-      #   if you expect `ASCII-8BIT` encoding, disable this cop.
-      #
-      # @example
-      #   # bad
-      #   ''.dup
-      #   "something".dup
-      #   String.new
-      #   String.new('')
-      #   String.new('something')
-      #
-      #   # good
-      #   +'something'
-      #   +''
-      class UnfreezeString < Base
-        extend AutoCorrector
-
-        MSG = 'Use unary plus to get an unfrozen string literal.'
-        RESTRICT_ON_SEND = %i[dup new].freeze
-
-        def_node_matcher :dup_string?, <<~PATTERN
-          (send {str dstr} :dup)
-        PATTERN
-
-        def_node_matcher :string_new?, <<~PATTERN
-          {
-            (send (const nil? :String) :new {str dstr})
-            (send (const nil? :String) :new)
-          }
-        PATTERN
-
-        def on_send(node)
-          return unless dup_string?(node) || string_new?(node)
-
-          add_offense(node) do |corrector|
-            string_value = "+#{string_value(node)}"
-            string_value = "(#{string_value})" if node.parent&.send_type?
-
-            corrector.replace(node, string_value)
-          end
-        end
-
-        private
-
-        def string_value(node)
-          if node.receiver.source == 'String' && node.method?(:new)
-            node.arguments.empty? ? "''" : node.first_argument.source
-          else
-            node.receiver.source
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/uri_default_parser.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/uri_default_parser.rb
deleted file mode 100644
index 0f8de7d86a21a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance/uri_default_parser.rb
+++ /dev/null
@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Identifies places where `URI::Parser.new` can be replaced by `URI::DEFAULT_PARSER`.
-      #
-      # @example
-      #   # bad
-      #   URI::Parser.new
-      #
-      #   # good
-      #   URI::DEFAULT_PARSER
-      #
-      class UriDefaultParser < Base
-        extend AutoCorrector
-
-        MSG = 'Use `%<double_colon>sURI::DEFAULT_PARSER` instead of ' \
-              '`%<double_colon>sURI::Parser.new`.'
-        RESTRICT_ON_SEND = %i[new].freeze
-
-        def_node_matcher :uri_parser_new?, <<~PATTERN
-          (send
-            (const
-              (const ${nil? cbase} :URI) :Parser) :new)
-        PATTERN
-
-        def on_send(node)
-          return unless uri_parser_new?(node) do |captured_value|
-            double_colon = captured_value ? '::' : ''
-            message = format(MSG, double_colon: double_colon)
-
-            add_offense(node, message: message) do |corrector|
-              corrector.replace(node.loc.expression, "#{double_colon}URI::DEFAULT_PARSER")
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance_cops.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance_cops.rb
deleted file mode 100644
index 02a64a6300fb8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/cop/performance_cops.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'mixin/regexp_metacharacter'
-require_relative 'mixin/sort_block'
-
-require_relative 'performance/ancestors_include'
-require_relative 'performance/array_semi_infinite_range_slice'
-require_relative 'performance/big_decimal_with_numeric_argument'
-require_relative 'performance/bind_call'
-require_relative 'performance/block_given_with_explicit_block'
-require_relative 'performance/caller'
-require_relative 'performance/case_when_splat'
-require_relative 'performance/casecmp'
-require_relative 'performance/collection_literal_in_loop'
-require_relative 'performance/compare_with_block'
-require_relative 'performance/concurrent_monotonic_time'
-require_relative 'performance/constant_regexp'
-require_relative 'performance/count'
-require_relative 'performance/delete_prefix'
-require_relative 'performance/delete_suffix'
-require_relative 'performance/detect'
-require_relative 'performance/double_start_end_with'
-require_relative 'performance/end_with'
-require_relative 'performance/fixed_size'
-require_relative 'performance/flat_map'
-require_relative 'performance/inefficient_hash_search'
-require_relative 'performance/map_compact'
-require_relative 'performance/method_object_as_block'
-require_relative 'performance/open_struct'
-require_relative 'performance/range_include'
-require_relative 'performance/io_readlines'
-require_relative 'performance/redundant_block_call'
-require_relative 'performance/redundant_equality_comparison_block'
-require_relative 'performance/redundant_match'
-require_relative 'performance/redundant_merge'
-require_relative 'performance/redundant_sort_block'
-require_relative 'performance/redundant_split_regexp_argument'
-require_relative 'performance/redundant_string_chars'
-require_relative 'performance/regexp_match'
-require_relative 'performance/reverse_each'
-require_relative 'performance/reverse_first'
-require_relative 'performance/select_map'
-require_relative 'performance/size'
-require_relative 'performance/sort_reverse'
-require_relative 'performance/squeeze'
-require_relative 'performance/start_with'
-require_relative 'performance/string_identifier_argument'
-require_relative 'performance/string_include'
-require_relative 'performance/string_replacement'
-require_relative 'performance/sum'
-require_relative 'performance/times_map'
-require_relative 'performance/unfreeze_string'
-require_relative 'performance/uri_default_parser'
-require_relative 'performance/chain_array_allocation'
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/performance.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/performance.rb
deleted file mode 100644
index 4ed61a2fa0794..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/performance.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  # RuboCop Performance project namespace
-  module Performance
-    PROJECT_ROOT = Pathname.new(__dir__).parent.parent.expand_path.freeze
-    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
-    CONFIG = YAML.safe_load(CONFIG_DEFAULT.read).freeze
-
-    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
-
-    ::RuboCop::ConfigObsoletion.files << PROJECT_ROOT.join('config', 'obsoletion.yml')
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/performance/inject.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/performance/inject.rb
deleted file mode 100644
index e255a881a4df3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/performance/inject.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Performance
-    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
-    # bit of our configuration.
-    module Inject
-      def self.defaults!
-        path = CONFIG_DEFAULT.to_s
-        hash = ConfigLoader.send(:load_yaml_configuration, path)
-        config = Config.new(hash, path).tap(&:make_excludes_absolute)
-        puts "configuration from #{path}" if ConfigLoader.debug?
-        config = ConfigLoader.merge_with_default(config, path)
-        ConfigLoader.instance_variable_set(:@default_configuration, config)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/performance/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/performance/version.rb
deleted file mode 100644
index 1d9846349b97c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-performance-1.14.3/lib/rubocop/performance/version.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Performance
-    # This module holds the RuboCop Performance version information.
-    module Version
-      STRING = '1.14.3'
-
-      def self.document_version
-        STRING.match('\d+\.\d+').to_s
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/config/default.yml b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/config/default.yml
deleted file mode 100644
index 27446c2fed5e9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/config/default.yml
+++ /dev/null
@@ -1,1014 +0,0 @@
-# Common configuration.
-
-inherit_mode:
-  merge:
-    - Exclude
-
-AllCops:
-  Exclude:
-    - bin/*
-    # Exclude db/schema.rb and db/[CONFIGURATION_NAMESPACE]_schema.rb by default.
-    # See: https://guides.rubyonrails.org/active_record_multiple_databases.html#setting-up-your-application
-    - db/*schema.rb
-  # What version of Rails is the inspected code using?  If a value is specified
-  # for TargetRailsVersion then it is used.  Acceptable values are specified
-  # as a float (i.e. 5.1); the patch version of Rails should not be included.
-  # If TargetRailsVersion is not set, RuboCop will parse the Gemfile.lock or
-  # gems.locked file to find the version of Rails that has been bound to the
-  # application.  If neither of those files exist, RuboCop will use Rails 5.0
-  # as the default.
-  TargetRailsVersion: ~
-
-Lint/NumberConversion:
-  # Add Rails' duration methods to the ignore list for `Lint/NumberConversion`
-  # so that calling `to_i` on one of these does not register an offense.
-  # See: https://github.com/rubocop/rubocop/issues/8950
-  IgnoredMethods:
-    - ago
-    - from_now
-    - second
-    - seconds
-    - minute
-    - minutes
-    - hour
-    - hours
-    - day
-    - days
-    - week
-    - weeks
-    - fortnight
-    - fortnights
-    - in_milliseconds
-
-Rails/ActionControllerTestCase:
-  Description: 'Use `ActionDispatch::IntegrationTest` instead of `ActionController::TestCase`.'
-  StyleGuide: 'https://rails.rubystyle.guide/#integration-testing'
-  Reference: 'https://api.rubyonrails.org/classes/ActionController/TestCase.html'
-  Enabled: 'pending'
-  SafeAutocorrect: false
-  VersionAdded: '2.14'
-  Include:
-    - '**/test/**/*.rb'
-
-Rails/ActionFilter:
-  Description: 'Enforces consistent use of action filter methods.'
-  Enabled: true
-  VersionAdded: '0.19'
-  EnforcedStyle: action
-  SupportedStyles:
-    - action
-    - filter
-  Include:
-    - app/controllers/**/*.rb
-    - app/mailers/**/*.rb
-
-Rails/ActiveRecordAliases:
-  Description: >-
-                  Avoid Active Record aliases:
-                  Use `update` instead of `update_attributes`.
-                  Use `update!` instead of `update_attributes!`.
-  Enabled: true
-  VersionAdded: '0.53'
-  SafeAutoCorrect: false
-
-Rails/ActiveRecordCallbacksOrder:
-  Description: 'Order callback declarations in the order in which they will be executed.'
-  StyleGuide: 'https://rails.rubystyle.guide/#callbacks-order'
-  Enabled: 'pending'
-  VersionAdded: '2.7'
-  Include:
-    - app/models/**/*.rb
-
-Rails/ActiveRecordOverride:
-  Description: >-
-                  Check for overriding Active Record methods instead of using
-                  callbacks.
-  Enabled: true
-  VersionAdded: '0.67'
-  Include:
-    - app/models/**/*.rb
-
-Rails/ActiveSupportAliases:
-  Description: >-
-                  Avoid ActiveSupport aliases of standard ruby methods:
-                  `String#starts_with?`, `String#ends_with?`,
-                  `Array#append`, `Array#prepend`.
-  Enabled: true
-  VersionAdded: '0.48'
-
-Rails/AddColumnIndex:
-  Description: >-
-    Rails migrations don't make use of a given `index` key, but also
-    doesn't given an error when it's used, so it makes it seem like an
-    index might be used.
-  Enabled: pending
-  VersionAdded: '2.11'
-  Include:
-    - db/migrate/*.rb
-
-Rails/AfterCommitOverride:
-  Description: >-
-                  Enforces that there is only one call to `after_commit`
-                  (and its aliases - `after_create_commit`, `after_update_commit`,
-                  and `after_destroy_commit`) with the same callback name per model.
-  Enabled: 'pending'
-  VersionAdded: '2.8'
-
-Rails/ApplicationController:
-  Description: 'Check that controllers subclass ApplicationController.'
-  Enabled: true
-  SafeAutoCorrect: false
-  VersionAdded: '2.4'
-  VersionChanged: '2.5'
-
-Rails/ApplicationJob:
-  Description: 'Check that jobs subclass ApplicationJob.'
-  Enabled: true
-  SafeAutoCorrect: false
-  VersionAdded: '0.49'
-  VersionChanged: '2.5'
-
-Rails/ApplicationMailer:
-  Description: 'Check that mailers subclass ApplicationMailer.'
-  Enabled: true
-  SafeAutoCorrect: false
-  VersionAdded: '2.4'
-  VersionChanged: '2.5'
-
-Rails/ApplicationRecord:
-  Description: 'Check that models subclass ApplicationRecord.'
-  Enabled: true
-  SafeAutoCorrect: false
-  VersionAdded: '0.49'
-  VersionChanged: '2.5'
-
-Rails/ArelStar:
-  Description: 'Enforces `Arel.star` instead of `"*"` for expanded columns.'
-  Enabled: true
-  SafeAutoCorrect: false
-  VersionAdded: '2.9'
-
-Rails/AssertNot:
-  Description: 'Use `assert_not` instead of `assert !`.'
-  Enabled: true
-  VersionAdded: '0.56'
-  Include:
-    - '**/test/**/*'
-
-Rails/AttributeDefaultBlockValue:
-  Description: 'Pass method call in block for attribute option `default`.'
-  Enabled: pending
-  VersionAdded: '2.9'
-  Include:
-    - 'app/models/**/*'
-
-Rails/BelongsTo:
-  Description: >-
-                  Use `optional: true` instead of `required: false` for
-                  `belongs_to` relations.
-  Enabled: true
-  VersionAdded: '0.62'
-
-Rails/Blank:
-  Description: 'Enforces use of `blank?`.'
-  Enabled: true
-  SafeAutoCorrect: false
-  VersionAdded: '0.48'
-  VersionChanged: '2.10'
-  # Convert usages of `nil? || empty?` to `blank?`
-  NilOrEmpty: true
-  # Convert usages of `!present?` to `blank?`
-  NotPresent: true
-  # Convert usages of `unless present?` to `if blank?`
-  UnlessPresent: true
-
-Rails/BulkChangeTable:
-  Description: 'Check whether alter queries are combinable.'
-  Enabled: true
-  VersionAdded: '0.57'
-  Database: null
-  SupportedDatabases:
-    - mysql
-    - postgresql
-  Include:
-    - db/migrate/*.rb
-
-Rails/CompactBlank:
-  Description: 'Checks if collection can be blank-compacted with `compact_blank`.'
-  Enabled: pending
-  Safe: false
-  VersionAdded: '2.13'
-
-Rails/ContentTag:
-  Description: 'Use `tag.something` instead of `tag(:something)`.'
-  Reference:
-    - 'https://github.com/rubocop/rubocop-rails/issues/260'
-    - 'https://github.com/rails/rails/issues/25195'
-    - 'https://api.rubyonrails.org/classes/ActionView/Helpers/TagHelper.html#method-i-content_tag'
-  Enabled: true
-  VersionAdded: '2.6'
-  VersionChanged: '2.12'
-  # This `Exclude` config prevents false positives for `tag` calls to `has_one: tag` and Puma configuration:
-  # https://puma.io/puma/Puma/DSL.html#tag-instance_method
-  # No helpers are used in normal models and configs.
-  Exclude:
-    - app/models/**/*.rb
-    - config/**/*.rb
-
-Rails/CreateTableWithTimestamps:
-  Description: >-
-                  Checks the migration for which timestamps are not included
-                  when creating a new table.
-  Enabled: true
-  VersionAdded: '0.52'
-  Include:
-    - db/migrate/*.rb
-  Exclude:
-    # Respect the `active_storage_variant_records` table of `*_create_active_storage_tables.active_storage.rb`
-    # auto-generated by `bin/rails active_storage:install` even if `created_at` is not specified.
-    - db/migrate/*_create_active_storage_tables.active_storage.rb
-
-Rails/Date:
-  Description: >-
-                  Checks the correct usage of date aware methods,
-                  such as Date.today, Date.current etc.
-  Enabled: true
-  VersionAdded: '0.30'
-  VersionChanged: '2.11'
-  # The value `strict` disallows usage of `Date.today`, `Date.current`,
-  # `Date#to_time` etc.
-  # The value `flexible` allows usage of `Date.current`, `Date.yesterday`, etc
-  # (but not `Date.today`) which are overridden by ActiveSupport to handle current
-  # time zone.
-  EnforcedStyle: flexible
-  SupportedStyles:
-    - strict
-    - flexible
-  AllowToTime: true
-
-Rails/DefaultScope:
-  Description: 'Avoid use of `default_scope`.'
-  StyleGuide: 'https://rails.rubystyle.guide#avoid-default-scope'
-  Enabled: false
-  VersionAdded: '2.7'
-
-Rails/Delegate:
-  Description: 'Prefer delegate method for delegations.'
-  Enabled: true
-  VersionAdded: '0.21'
-  VersionChanged: '0.50'
-  # When set to true, using the target object as a prefix of the
-  # method name without using the `delegate` method will be a
-  # violation. When set to false, this case is legal.
-  EnforceForPrefixed: true
-
-Rails/DelegateAllowBlank:
-  Description: 'Do not use allow_blank as an option to delegate.'
-  Enabled: true
-  VersionAdded: '0.44'
-
-Rails/DeprecatedActiveModelErrorsMethods:
-  Description: 'Avoid manipulating ActiveModel errors hash directly.'
-  Enabled: pending
-  Safe: false
-  VersionAdded: '2.14'
-  VersionChanged: '2.15'
-
-Rails/DotSeparatedKeys:
-  Description: 'Enforces the use of dot-separated keys instead of `:scope` options in `I18n` translation methods.'
-  StyleGuide: 'https://rails.rubystyle.guide/#dot-separated-keys'
-  Enabled: pending
-  VersionAdded: '2.15'
-
-Rails/DuplicateAssociation:
-  Description: "Don't repeat associations in a model."
-  Enabled: pending
-  VersionAdded: '2.14'
-
-Rails/DuplicateScope:
-  Description: 'Multiple scopes share this same where clause.'
-  Enabled: pending
-  VersionAdded: '2.14'
-
-Rails/DurationArithmetic:
-  Description: 'Do not use duration as arithmetic operand with `Time.current`.'
-  StyleGuide: 'https://rails.rubystyle.guide#duration-arithmetic'
-  Enabled: pending
-  VersionAdded: '2.13'
-
-Rails/DynamicFindBy:
-  Description: 'Use `find_by` instead of dynamic `find_by_*`.'
-  StyleGuide: 'https://rails.rubystyle.guide#find_by'
-  Enabled: true
-  Safe: false
-  VersionAdded: '0.44'
-  VersionChanged: '2.10'
-  # The `Whitelist` has been deprecated, Please use `AllowedMethods` instead.
-  Whitelist:
-    - find_by_sql
-  AllowedMethods:
-    - find_by_sql
-  AllowedReceivers:
-    - Gem::Specification
-
-Rails/EagerEvaluationLogMessage:
-  Description: 'Checks that blocks are used for interpolated strings passed to `Rails.logger.debug`.'
-  Reference: 'https://guides.rubyonrails.org/debugging_rails_applications.html#impact-of-logs-on-performance'
-  Enabled: pending
-  VersionAdded: '2.11'
-
-Rails/EnumHash:
-  Description: 'Prefer hash syntax over array syntax when defining enums.'
-  StyleGuide: 'https://rails.rubystyle.guide#enums'
-  Enabled: true
-  VersionAdded: '2.3'
-  Include:
-    - app/models/**/*.rb
-
-Rails/EnumUniqueness:
-  Description: 'Avoid duplicate integers in hash-syntax `enum` declaration.'
-  Enabled: true
-  VersionAdded: '0.46'
-  Include:
-    - app/models/**/*.rb
-
-Rails/EnvironmentComparison:
-  Description: "Favor `Rails.env.production?` over `Rails.env == 'production'`."
-  Enabled: true
-  VersionAdded: '0.52'
-
-Rails/EnvironmentVariableAccess:
-  Description: 'Do not access `ENV` directly after initialization.'
-  # TODO: Set to `pending` status in RuboCop Rails 2 series when migration doc will be written.
-  Enabled: false
-  VersionAdded: '2.10'
-  VersionChanged: '2.11'
-  Include:
-    - app/**/*.rb
-    - lib/**/*.rb
-  Exclude:
-    - lib/**/*.rake
-  AllowReads: false
-  AllowWrites: false
-
-Rails/Exit:
-  Description: >-
-                  Favor `fail`, `break`, `return`, etc. over `exit` in
-                  application or library code outside of Rake files to avoid
-                  exits during unit testing or running in production.
-  Enabled: true
-  VersionAdded: '0.41'
-  Include:
-    - app/**/*.rb
-    - config/**/*.rb
-    - lib/**/*.rb
-  Exclude:
-    - lib/**/*.rake
-
-Rails/ExpandedDateRange:
-  Description: 'Checks for expanded date range.'
-  StyleGuide: 'https://rails.rubystyle.guide/#date-time-range'
-  Enabled: pending
-  VersionAdded: '2.11'
-
-Rails/FilePath:
-  Description: 'Use `Rails.root.join` for file path joining.'
-  Enabled: true
-  VersionAdded: '0.47'
-  VersionChanged: '2.4'
-  EnforcedStyle: slashes
-  SupportedStyles:
-    - slashes
-    - arguments
-
-Rails/FindBy:
-  Description: 'Prefer find_by over where.first.'
-  StyleGuide: 'https://rails.rubystyle.guide#find_by'
-  Enabled: true
-  VersionAdded: '0.30'
-  VersionChanged: '2.11'
-  IgnoreWhereFirst: true
-  Include:
-    - app/models/**/*.rb
-
-Rails/FindById:
-  Description: >-
-                Favor the use of `find` over `where.take!`, `find_by!`, and `find_by_id!` when you
-                need to retrieve a single record by primary key when you expect it to be found.
-  StyleGuide: 'https://rails.rubystyle.guide/#find'
-  Enabled: 'pending'
-  VersionAdded: '2.7'
-
-Rails/FindEach:
-  Description: 'Prefer all.find_each over all.find.'
-  StyleGuide: 'https://rails.rubystyle.guide#find-each'
-  Enabled: true
-  VersionAdded: '0.30'
-  VersionChanged: '2.9'
-  Include:
-    - app/models/**/*.rb
-  IgnoredMethods:
-    # Methods that don't work well with `find_each`.
-    - order
-    - limit
-    - select
-    - lock
-
-Rails/HasAndBelongsToMany:
-  Description: 'Prefer has_many :through to has_and_belongs_to_many.'
-  StyleGuide: 'https://rails.rubystyle.guide#has-many-through'
-  Enabled: true
-  VersionAdded: '0.12'
-  Include:
-    - app/models/**/*.rb
-
-Rails/HasManyOrHasOneDependent:
-  Description: 'Define the dependent option to the has_many and has_one associations.'
-  StyleGuide: 'https://rails.rubystyle.guide#has_many-has_one-dependent-option'
-  Enabled: true
-  VersionAdded: '0.50'
-  Include:
-    - app/models/**/*.rb
-
-Rails/HelperInstanceVariable:
-  Description: 'Do not use instance variables in helpers.'
-  Enabled: true
-  VersionAdded: '2.0'
-  Include:
-    - app/helpers/**/*.rb
-
-Rails/HttpPositionalArguments:
-  Description: 'Use keyword arguments instead of positional arguments in http method calls.'
-  Enabled: true
-  VersionAdded: '0.44'
-  Include:
-    - 'spec/**/*'
-    - 'test/**/*'
-
-Rails/HttpStatus:
-  Description: 'Enforces use of symbolic or numeric value to define HTTP status.'
-  Enabled: true
-  VersionAdded: '0.54'
-  VersionChanged: '2.11'
-  EnforcedStyle: symbolic
-  SupportedStyles:
-    - numeric
-    - symbolic
-
-Rails/I18nLazyLookup:
-  Description: 'Checks for places where I18n "lazy" lookup can be used.'
-  StyleGuide: 'https://rails.rubystyle.guide/#lazy-lookup'
-  Reference: 'https://guides.rubyonrails.org/i18n.html#lazy-lookup'
-  Enabled: pending
-  VersionAdded: '2.14'
-  Include:
-    - 'controllers/**/*'
-
-Rails/I18nLocaleAssignment:
-  Description: 'Prefer the usage of `I18n.with_locale` instead of manually updating `I18n.locale` value.'
-  Enabled: 'pending'
-  VersionAdded: '2.11'
-  Include:
-    - spec/**/*.rb
-    - test/**/*.rb
-
-Rails/I18nLocaleTexts:
-  Description: 'Enforces use of I18n and locale files instead of locale specific strings.'
-  StyleGuide: 'https://rails.rubystyle.guide/#locale-texts'
-  Enabled: pending
-  VersionAdded: '2.14'
-
-Rails/IgnoredSkipActionFilterOption:
-  Description: 'Checks that `if` and `only` (or `except`) are not used together as options of `skip_*` action filter.'
-  Reference: 'https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-_normalize_callback_options'
-  Enabled: true
-  VersionAdded: '0.63'
-  Include:
-    - app/controllers/**/*.rb
-    - app/mailers/**/*.rb
-
-Rails/IndexBy:
-  Description: 'Prefer `index_by` over `each_with_object`, `to_h`, or `map`.'
-  Enabled: true
-  VersionAdded: '2.5'
-  VersionChanged: '2.8'
-
-Rails/IndexWith:
-  Description: 'Prefer `index_with` over `each_with_object`, `to_h`, or `map`.'
-  Enabled: true
-  VersionAdded: '2.5'
-  VersionChanged: '2.8'
-
-Rails/Inquiry:
-  Description: "Prefer Ruby's comparison operators over Active Support's `Array#inquiry` and `String#inquiry`."
-  StyleGuide: 'https://rails.rubystyle.guide/#inquiry'
-  Enabled: 'pending'
-  VersionAdded: '2.7'
-
-Rails/InverseOf:
-  Description: 'Checks for associations where the inverse cannot be determined automatically.'
-  Enabled: true
-  VersionAdded: '0.52'
-  IgnoreScopes: false
-  Include:
-    - app/models/**/*.rb
-
-Rails/LexicallyScopedActionFilter:
-  Description: "Checks that methods specified in the filter's `only` or `except` options are explicitly defined in the class."
-  StyleGuide: 'https://rails.rubystyle.guide#lexically-scoped-action-filter'
-  Enabled: true
-  Safe: false
-  VersionAdded: '0.52'
-  Include:
-    - app/controllers/**/*.rb
-    - app/mailers/**/*.rb
-
-Rails/LinkToBlank:
-  Description: 'Checks that `link_to` with a `target: "_blank"` have a `rel: "noopener"` option passed to them.'
-  Reference:
-    - https://mathiasbynens.github.io/rel-noopener/
-    - https://html.spec.whatwg.org/multipage/links.html#link-type-noopener
-    - https://html.spec.whatwg.org/multipage/links.html#link-type-noreferrer
-  Enabled: true
-  VersionAdded: '0.62'
-
-Rails/MailerName:
-  Description: 'Mailer should end with `Mailer` suffix.'
-  StyleGuide: 'https://rails.rubystyle.guide/#mailer-name'
-  Enabled: 'pending'
-  SafeAutoCorrect: false
-  VersionAdded: '2.7'
-  Include:
-    - app/mailers/**/*.rb
-
-Rails/MatchRoute:
-  Description: >-
-                  Don't use `match` to define any routes unless there is a need to map multiple request types
-                  among [:get, :post, :patch, :put, :delete] to a single action using the `:via` option.
-  StyleGuide: 'https://rails.rubystyle.guide/#no-match-routes'
-  Enabled: 'pending'
-  VersionAdded: '2.7'
-  Include:
-    - config/routes.rb
-    - config/routes/**/*.rb
-
-Rails/MigrationClassName:
-  Description: 'The class name of the migration should match its file name.'
-  Enabled: pending
-  VersionAdded: '2.14'
-  Include:
-    - db/migrate/*.rb
-
-Rails/NegateInclude:
-  Description: 'Prefer `collection.exclude?(obj)` over `!collection.include?(obj)`.'
-  StyleGuide: 'https://rails.rubystyle.guide#exclude'
-  Enabled: 'pending'
-  Safe: false
-  VersionAdded: '2.7'
-  VersionChanged: '2.9'
-
-Rails/NotNullColumn:
-  Description: 'Do not add a NOT NULL column without a default value.'
-  Enabled: true
-  VersionAdded: '0.43'
-  Include:
-    - db/migrate/*.rb
-
-Rails/OrderById:
-  Description: >-
-                  Do not use the `id` column for ordering.
-                  Use a timestamp column to order chronologically.
-  StyleGuide: 'https://rails.rubystyle.guide/#order-by-id'
-  Enabled: false
-  VersionAdded: '2.8'
-
-Rails/Output:
-  Description: 'Checks for calls to puts, print, etc.'
-  Enabled: true
-  SafeAutoCorrect: false
-  VersionAdded: '0.15'
-  VersionChanged: '0.19'
-  Include:
-    - app/**/*.rb
-    - config/**/*.rb
-    - db/**/*.rb
-    - lib/**/*.rb
-
-Rails/OutputSafety:
-  Description: 'The use of `html_safe` or `raw` may be a security risk.'
-  Enabled: true
-  VersionAdded: '0.41'
-
-Rails/Pick:
-  Description: 'Prefer `pick` over `pluck(...).first`.'
-  StyleGuide: 'https://rails.rubystyle.guide#pick'
-  Enabled: true
-  Safe: false
-  VersionAdded: '2.6'
-
-Rails/Pluck:
-  Description: 'Prefer `pluck` over `map { ... }`.'
-  StyleGuide: 'https://rails.rubystyle.guide#pluck'
-  Enabled: 'pending'
-  VersionAdded: '2.7'
-
-Rails/PluckId:
-  Description: 'Use `ids` instead of `pluck(:id)` or `pluck(primary_key)`.'
-  StyleGuide: 'https://rails.rubystyle.guide/#ids'
-  Enabled: false
-  Safe: false
-  VersionAdded: '2.7'
-
-Rails/PluckInWhere:
-  Description: 'Use `select` instead of `pluck` in `where` query methods.'
-  Enabled: 'pending'
-  Safe: false
-  VersionAdded: '2.7'
-  VersionChanged: '2.8'
-  EnforcedStyle: conservative
-  SupportedStyles:
-    - conservative
-    - aggressive
-
-Rails/PluralizationGrammar:
-  Description: 'Checks for incorrect grammar when using methods like `3.day.ago`.'
-  Enabled: true
-  VersionAdded: '0.35'
-
-Rails/Presence:
-  Description: 'Checks code that can be written more easily using `Object#presence` defined by Active Support.'
-  Enabled: true
-  VersionAdded: '0.52'
-
-Rails/Present:
-  Description: 'Enforces use of `present?`.'
-  Enabled: true
-  VersionAdded: '0.48'
-  VersionChanged: '0.67'
-  # Convert usages of `!nil? && !empty?` to `present?`
-  NotNilAndNotEmpty: true
-  # Convert usages of `!blank?` to `present?`
-  NotBlank: true
-  # Convert usages of `unless blank?` to `if present?`
-  UnlessBlank: true
-
-Rails/RakeEnvironment:
-  Description: 'Include `:environment` as a dependency for all Rake tasks.'
-  Enabled: true
-  Safe: false
-  VersionAdded: '2.4'
-  VersionChanged: '2.6'
-  Include:
-    - '**/Rakefile'
-    - '**/*.rake'
-  Exclude:
-    - 'lib/capistrano/tasks/**/*.rake'
-
-Rails/ReadWriteAttribute:
-  Description: >-
-                 Checks for read_attribute(:attr) and
-                 write_attribute(:attr, val).
-  StyleGuide: 'https://rails.rubystyle.guide#read-attribute'
-  Enabled: true
-  VersionAdded: '0.20'
-  VersionChanged: '0.29'
-  Include:
-    - app/models/**/*.rb
-
-Rails/RedundantAllowNil:
-  Description: >-
-                 Finds redundant use of `allow_nil` when `allow_blank` is set to
-                 certain values in model validations.
-  Enabled: true
-  VersionAdded: '0.67'
-  Include:
-    - app/models/**/*.rb
-
-Rails/RedundantForeignKey:
-  Description: 'Checks for associations where the `:foreign_key` option is redundant.'
-  Enabled: true
-  VersionAdded: '2.6'
-
-Rails/RedundantPresenceValidationOnBelongsTo:
-  Description: 'Checks for redundant presence validation on belongs_to association.'
-  Enabled: pending
-  SafeAutoCorrect: false
-  VersionAdded: '2.13'
-
-Rails/RedundantReceiverInWithOptions:
-  Description: 'Checks for redundant receiver in `with_options`.'
-  Enabled: true
-  VersionAdded: '0.52'
-
-Rails/RedundantTravelBack:
-  Description: Checks for redundant `travel_back` calls.
-  Enabled: pending
-  VersionAdded: '2.12'
-  Include:
-    - spec/**/*.rb
-    - test/**/*.rb
-
-Rails/ReflectionClassName:
-  Description: 'Use a string for `class_name` option value in the definition of a reflection.'
-  Enabled: true
-  Safe: false
-  VersionAdded: '0.64'
-  VersionChanged: '2.10'
-
-Rails/RefuteMethods:
-  Description: 'Use `assert_not` methods instead of `refute` methods.'
-  Enabled: true
-  VersionAdded: '0.56'
-  EnforcedStyle: assert_not
-  SupportedStyles:
-    - assert_not
-    - refute
-  Include:
-    - '**/test/**/*'
-
-Rails/RelativeDateConstant:
-  Description: 'Do not assign relative date to constants.'
-  Enabled: true
-  SafeAutoCorrect: false
-  VersionAdded: '0.48'
-  VersionChanged: '2.13'
-
-Rails/RenderInline:
-  Description: 'Prefer using a template over inline rendering.'
-  StyleGuide: 'https://rails.rubystyle.guide/#inline-rendering'
-  Enabled: 'pending'
-  VersionAdded: '2.7'
-
-Rails/RenderPlainText:
-  Description: 'Prefer `render plain:` over `render text:`.'
-  StyleGuide: 'https://rails.rubystyle.guide/#plain-text-rendering'
-  Enabled: 'pending'
-  VersionAdded: '2.7'
-  # Convert only when `content_type` is explicitly set to `text/plain`.
-  ContentTypeCompatibility: true
-
-Rails/RequestReferer:
-  Description: 'Use consistent syntax for request.referer.'
-  Enabled: true
-  VersionAdded: '0.41'
-  EnforcedStyle: referer
-  SupportedStyles:
-    - referer
-    - referrer
-
-Rails/RequireDependency:
-  Description: 'Do not use `require_dependency` when running in Zeitwerk mode. `require_dependency` is for autoloading in classic mode.'
-  Reference: 'https://guides.rubyonrails.org/autoloading_and_reloading_constants.html'
-  Enabled: false
-  VersionAdded: '2.10'
-
-Rails/ReversibleMigration:
-  Description: 'Checks whether the change method of the migration file is reversible.'
-  StyleGuide: 'https://rails.rubystyle.guide#reversible-migration'
-  Reference: 'https://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html'
-  Enabled: true
-  VersionAdded: '0.47'
-  VersionChanged: '2.13'
-  Include:
-    - db/**/*.rb
-
-Rails/ReversibleMigrationMethodDefinition:
-  Description: 'Checks whether the migration implements either a `change` method or both an `up` and a `down` method.'
-  Enabled: false
-  VersionAdded: '2.10'
-  VersionChanged: '2.13'
-  Include:
-    - db/**/*.rb
-
-Rails/RootJoinChain:
-  Description: 'Use a single `#join` instead of chaining on `Rails.root` or `Rails.public_path`.'
-  Enabled: pending
-  VersionAdded: '2.13'
-
-Rails/RootPublicPath:
-  Description: "Favor `Rails.public_path` over `Rails.root` with `'public'`."
-  Enabled: pending
-  VersionAdded: '2.15'
-
-Rails/SafeNavigation:
-  Description: "Use Ruby's safe navigation operator (`&.`) instead of `try!`."
-  Enabled: true
-  VersionAdded: '0.43'
-  # This will convert usages of `try` to use safe navigation as well as `try!`.
-  # `try` and `try!` work slightly differently. `try!` and safe navigation will
-  # both raise a `NoMethodError` if the receiver of the method call does not
-  # implement the intended method. `try` will not raise an exception for this.
-  ConvertTry: false
-
-Rails/SafeNavigationWithBlank:
-  Description: 'Avoid `foo&.blank?` in conditionals.'
-  Enabled: true
-  VersionAdded: '2.4'
-  # While the safe navigation operator is generally a good idea, when
-  # checking `foo&.blank?` in a conditional, `foo` being `nil` will actually
-  # do the opposite of what the author intends.
-  #
-  # foo&.blank? #=> nil
-  # foo.blank? #=> true
-  SafeAutoCorrect: false
-
-Rails/SaveBang:
-  Description: 'Identifies possible cases where Active Record save! or related should be used.'
-  StyleGuide: 'https://rails.rubystyle.guide#save-bang'
-  Enabled: false
-  VersionAdded: '0.42'
-  VersionChanged: '0.59'
-  AllowImplicitReturn: true
-  AllowedReceivers: []
-  SafeAutoCorrect: false
-
-Rails/SchemaComment:
-  Description: >-
-    Enforces the use of the `comment` option when adding a new table or column
-    to the database during a migration.
-  Enabled: false
-  VersionAdded: '2.13'
-
-Rails/ScopeArgs:
-  Description: 'Checks the arguments of ActiveRecord scopes.'
-  Enabled: true
-  VersionAdded: '0.19'
-  VersionChanged: '2.12'
-  Include:
-    - app/models/**/*.rb
-
-Rails/ShortI18n:
-  Description: 'Use the short form of the I18n methods: `t` instead of `translate` and `l` instead of `localize`.'
-  StyleGuide: 'https://rails.rubystyle.guide/#short-i18n'
-  Enabled: 'pending'
-  VersionAdded: '2.7'
-  EnforcedStyle: conservative
-  SupportedStyles:
-    - conservative
-    - aggressive
-
-Rails/SkipsModelValidations:
-  Description: >-
-                 Use methods that skips model validations with caution.
-                 See reference for more information.
-  Reference: 'https://guides.rubyonrails.org/active_record_validations.html#skipping-validations'
-  Enabled: true
-  VersionAdded: '0.47'
-  VersionChanged: '2.7'
-  ForbiddenMethods:
-    - decrement!
-    - decrement_counter
-    - increment!
-    - increment_counter
-    - insert
-    - insert!
-    - insert_all
-    - insert_all!
-    - toggle!
-    - touch
-    - touch_all
-    - update_all
-    - update_attribute
-    - update_column
-    - update_columns
-    - update_counters
-    - upsert
-    - upsert_all
-  AllowedMethods: []
-
-Rails/SquishedSQLHeredocs:
-  Description: 'Checks SQL heredocs to use `.squish`.'
-  StyleGuide: 'https://rails.rubystyle.guide/#squished-heredocs'
-  Enabled: 'pending'
-  VersionAdded: '2.8'
-  VersionChanged: '2.9'
-  # Some SQL syntax (e.g. PostgreSQL comments and functions) requires newlines
-  # to be preserved in order to work, thus autocorrection is not safe.
-  SafeAutoCorrect: false
-
-Rails/StripHeredoc:
-  Description: 'Enforces the use of squiggly heredoc over `strip_heredoc`.'
-  StyleGuide: 'https://rails.rubystyle.guide/#prefer-squiggly-heredoc'
-  Enabled: pending
-  VersionAdded: '2.15'
-
-Rails/TableNameAssignment:
-  Description: >-
-    Do not use `self.table_name =`. Use Inflections or `table_name_prefix` instead.
-  StyleGuide: 'https://rails.rubystyle.guide/#keep-ar-defaults'
-  Enabled: false
-  VersionAdded: '2.14'
-  Include:
-    - app/models/**/*.rb
-
-Rails/TimeZone:
-  Description: 'Checks the correct usage of time zone aware methods.'
-  StyleGuide: 'https://rails.rubystyle.guide#time'
-  Reference: 'http://danilenko.org/2012/7/6/rails_timezones'
-  Enabled: true
-  SafeAutoCorrect: false
-  VersionAdded: '0.30'
-  VersionChanged: '2.13'
-  # The value `strict` means that `Time` should be used with `zone`.
-  # The value `flexible` allows usage of `in_time_zone` instead of `zone`.
-  EnforcedStyle: flexible
-  SupportedStyles:
-    - strict
-    - flexible
-  Exclude:
-    - '**/*.gemspec'
-
-Rails/TimeZoneAssignment:
-  Description: 'Prefer the usage of `Time.use_zone` instead of manually updating `Time.zone` value.'
-  Reference: 'https://thoughtbot.com/blog/its-about-time-zones'
-  Enabled: 'pending'
-  VersionAdded: '2.10'
-  Include:
-    - spec/**/*.rb
-    - test/**/*.rb
-
-Rails/ToFormattedS:
-  Description: 'Checks for consistent uses of `to_fs` or `to_formatted_s`.'
-  StyleGuide: 'https://rails.rubystyle.guide/#prefer-to-fs'
-  Enabled: pending
-  EnforcedStyle: to_fs
-  SupportedStyles:
-    - to_fs
-    - to_formatted_s
-  VersionAdded: '2.15'
-
-Rails/TransactionExitStatement:
-  Description: 'Avoid the usage of `return`, `break` and `throw` in transaction blocks.'
-  Enabled: pending
-  VersionAdded: '2.14'
-
-Rails/UniqBeforePluck:
-  Description: 'Prefer the use of uniq or distinct before pluck.'
-  Enabled: true
-  VersionAdded: '0.40'
-  VersionChanged: '2.13'
-  EnforcedStyle: conservative
-  SupportedStyles:
-    - conservative
-    - aggressive
-  SafeAutoCorrect: false
-
-Rails/UniqueValidationWithoutIndex:
-  Description: 'Uniqueness validation should have a unique index on the database column.'
-  Enabled: true
-  VersionAdded: '2.5'
-  Include:
-    - app/models/**/*.rb
-
-Rails/UnknownEnv:
-  Description: 'Use correct environment name.'
-  Enabled: true
-  VersionAdded: '0.51'
-  Environments:
-    - development
-    - test
-    - production
-
-Rails/UnusedIgnoredColumns:
-  Description: 'Remove a column that does not exist from `ignored_columns`.'
-  Enabled: pending
-  VersionAdded: '2.11'
-  Include:
-    - app/models/**/*.rb
-
-Rails/Validation:
-  Description: 'Use validates :attribute, hash of validations.'
-  Enabled: true
-  VersionAdded: '0.9'
-  VersionChanged: '0.41'
-  Include:
-    - app/models/**/*.rb
-
-Rails/WhereEquals:
-  Description: 'Pass conditions to `where` as a hash instead of manually constructing SQL.'
-  StyleGuide: 'https://rails.rubystyle.guide/#hash-conditions'
-  Enabled: 'pending'
-  SafeAutoCorrect: false
-  VersionAdded: '2.9'
-  VersionChanged: '2.10'
-
-Rails/WhereExists:
-  Description: 'Prefer `exists?(...)` over `where(...).exists?`.'
-  Enabled: 'pending'
-  SafeAutoCorrect: false
-  EnforcedStyle: exists
-  SupportedStyles:
-    - exists
-    - where
-  VersionAdded: '2.7'
-  VersionChanged: '2.10'
-
-Rails/WhereNot:
-  Description: 'Use `where.not(...)` instead of manually constructing negated SQL in `where`.'
-  StyleGuide: 'https://rails.rubystyle.guide/#hash-conditions'
-  Enabled: 'pending'
-  VersionAdded: '2.8'
-
-# Accept `redirect_to(...) and return` and similar cases.
-Style/AndOr:
-  EnforcedStyle: conditionals
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/config/obsoletion.yml b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/config/obsoletion.yml
deleted file mode 100644
index 9cfb451ff78fc..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/config/obsoletion.yml
+++ /dev/null
@@ -1,7 +0,0 @@
-#
-# Configuration for obsoletion.
-#
-# See: https://docs.rubocop.org/rubocop/extensions.html#config-obsoletions
-#
-extracted:
-  Rails/*: ~
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop-rails.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop-rails.rb
deleted file mode 100644
index a5ac04629eccf..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop-rails.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubocop'
-require 'rack/utils'
-require 'active_support/inflector'
-
-require_relative 'rubocop/rails'
-require_relative 'rubocop/rails/version'
-require_relative 'rubocop/rails/inject'
-require_relative 'rubocop/rails/schema_loader'
-require_relative 'rubocop/rails/schema_loader/schema'
-
-RuboCop::Rails::Inject.defaults!
-
-require_relative 'rubocop/cop/rails_cops'
-
-RuboCop::Cop::Style::RedundantSelf.singleton_class.prepend(
-  Module.new do
-    def autocorrect_incompatible_with
-      super.push(RuboCop::Cop::Rails::SafeNavigation)
-    end
-  end
-)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/active_record_helper.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/active_record_helper.rb
deleted file mode 100644
index 3a9b1ea4b3daf..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/active_record_helper.rb
+++ /dev/null
@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # A mixin to extend cops for Active Record features
-    module ActiveRecordHelper
-      extend NodePattern::Macros
-
-      WHERE_METHODS = %i[where rewhere].freeze
-
-      def_node_matcher :active_record?, <<~PATTERN
-        {
-          (const nil? :ApplicationRecord)
-          (const (const nil? :ActiveRecord) :Base)
-        }
-      PATTERN
-
-      def_node_search :find_set_table_name, <<~PATTERN
-        (send self :table_name= {str sym})
-      PATTERN
-
-      def_node_search :find_belongs_to, <<~PATTERN
-        (send nil? :belongs_to {str sym} ...)
-      PATTERN
-
-      def inherit_active_record_base?(node)
-        node.each_ancestor(:class).any? { |class_node| active_record?(class_node.parent_class) }
-      end
-
-      def external_dependency_checksum
-        return @external_dependency_checksum if defined?(@external_dependency_checksum)
-
-        schema_path = RuboCop::Rails::SchemaLoader.db_schema_path
-        return nil if schema_path.nil?
-
-        schema_code = File.read(schema_path)
-
-        @external_dependency_checksum ||= Digest::SHA1.hexdigest(schema_code)
-      end
-
-      def schema
-        RuboCop::Rails::SchemaLoader.load(target_ruby_version)
-      end
-
-      def table_name(class_node)
-        table_name = find_set_table_name(class_node).to_a.last&.first_argument
-        return table_name.value.to_s if table_name
-
-        class_nodes = class_node.defined_module.each_node
-        namespaces = class_node.each_ancestor(:class, :module).map(&:identifier)
-        [*class_nodes, *namespaces]
-          .reverse
-          .map { |node| node.children[1] }.join('_')
-          .tableize
-      end
-
-      # Resolve relation into column name.
-      # It just returns column_name if the column exists.
-      # Or it tries to resolve column_name as a relation.
-      # Returns an array of column names if the relation is polymorphic.
-      # It returns `nil` if it can't resolve.
-      #
-      # @param name [String]
-      # @param class_node [RuboCop::AST::Node]
-      # @param table [RuboCop::Rails::SchemaLoader::Table]
-      # @return [Array, String, nil]
-      def resolve_relation_into_column(name:, class_node:, table:)
-        return unless table
-        return name if table.with_column?(name: name)
-
-        find_belongs_to(class_node) do |belongs_to|
-          next unless belongs_to.first_argument.value.to_s == name
-
-          fk = foreign_key_of(belongs_to) || "#{name}_id"
-          next unless table.with_column?(name: fk)
-
-          return polymorphic?(belongs_to) ? [fk, "#{name}_type"] : fk
-        end
-        nil
-      end
-
-      def foreign_key_of(belongs_to)
-        options = belongs_to.last_argument
-        return unless options.hash_type?
-
-        options.each_pair.find do |pair|
-          next unless pair.key.sym_type? && pair.key.value == :foreign_key
-          next unless pair.value.sym_type? || pair.value.str_type?
-
-          break pair.value.value.to_s
-        end
-      end
-
-      def polymorphic?(belongs_to)
-        options = belongs_to.last_argument
-        return false unless options.hash_type?
-
-        options.each_pair.any? do |pair|
-          pair.key.sym_type? && pair.key.value == :polymorphic && pair.value.true_type?
-        end
-      end
-
-      def in_where?(node)
-        send_node = node.each_ancestor(:send).first
-        send_node && WHERE_METHODS.include?(send_node.method_name)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/active_record_migrations_helper.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/active_record_migrations_helper.rb
deleted file mode 100644
index 0934d2693f054..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/active_record_migrations_helper.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # A mixin to extend cops for Active Record features
-    module ActiveRecordMigrationsHelper
-      extend NodePattern::Macros
-
-      RAILS_ABSTRACT_SCHEMA_DEFINITIONS = %i[
-        bigint binary boolean date datetime decimal float integer json string
-        text time timestamp virtual
-      ].freeze
-      RAILS_ABSTRACT_SCHEMA_DEFINITIONS_HELPERS = %i[
-        column references belongs_to primary_key numeric
-      ].freeze
-      POSTGRES_SCHEMA_DEFINITIONS = %i[
-        bigserial bit bit_varying cidr citext daterange hstore inet interval
-        int4range int8range jsonb ltree macaddr money numrange oid point line
-        lseg box path polygon circle serial tsrange tstzrange tsvector uuid xml
-      ].freeze
-      MYSQL_SCHEMA_DEFINITIONS = %i[
-        blob tinyblob mediumblob longblob tinytext mediumtext longtext
-        unsigned_integer unsigned_bigint unsigned_float unsigned_decimal
-      ].freeze
-
-      def_node_matcher :create_table_with_block?, <<~PATTERN
-        (block
-          (send nil? :create_table ...)
-          (args (arg _var))
-          _)
-      PATTERN
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/class_send_node_helper.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/class_send_node_helper.rb
deleted file mode 100644
index e68737d47fe7b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/class_send_node_helper.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # A mixin to return all of the class send nodes.
-    module ClassSendNodeHelper
-      def class_send_nodes(class_node)
-        class_def = class_node.body
-
-        return [] unless class_def
-
-        if class_def.send_type?
-          [class_def]
-        else
-          class_def.each_child_node(:send)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/enforce_superclass.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/enforce_superclass.rb
deleted file mode 100644
index b534f37dc75b0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/enforce_superclass.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for enforcing a specific superclass.
-    module EnforceSuperclass
-      def self.included(base)
-        base.def_node_matcher :class_definition, <<~PATTERN
-          (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
-        PATTERN
-
-        base.def_node_matcher :class_new_definition, <<~PATTERN
-          [!^(casgn {nil? cbase} :#{base::SUPERCLASS} ...)
-           !^^(casgn {nil? cbase} :#{base::SUPERCLASS} (block ...))
-           (send (const {nil? cbase} :Class) :new #{base::BASE_PATTERN})]
-        PATTERN
-      end
-
-      def on_class(node)
-        class_definition(node) do
-          register_offense(node.children[1])
-        end
-      end
-
-      def on_send(node)
-        class_new_definition(node) do
-          register_offense(node.children.last)
-        end
-      end
-
-      private
-
-      def register_offense(offense_node)
-        add_offense(offense_node) do |corrector|
-          corrector.replace(offense_node.source_range, self.class::SUPERCLASS)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/index_method.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/index_method.rb
deleted file mode 100644
index 952ffcf8626cb..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/index_method.rb
+++ /dev/null
@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for Rails/IndexBy and Rails/IndexWith
-    module IndexMethod # rubocop:disable Metrics/ModuleLength
-      RESTRICT_ON_SEND = %i[each_with_object to_h map collect []].freeze
-
-      def on_block(node)
-        on_bad_each_with_object(node) do |*match|
-          handle_possible_offense(node, match, 'each_with_object')
-        end
-
-        return if target_ruby_version < 2.6
-
-        on_bad_to_h(node) do |*match|
-          handle_possible_offense(node, match, 'to_h { ... }')
-        end
-      end
-
-      def on_send(node)
-        on_bad_map_to_h(node) do |*match|
-          handle_possible_offense(node, match, 'map { ... }.to_h')
-        end
-
-        on_bad_hash_brackets_map(node) do |*match|
-          handle_possible_offense(node, match, 'Hash[map { ... }]')
-        end
-      end
-
-      def on_csend(node)
-        on_bad_map_to_h(node) do |*match|
-          handle_possible_offense(node, match, 'map { ... }.to_h')
-        end
-      end
-
-      private
-
-      # @abstract Implemented with `def_node_matcher`
-      def on_bad_each_with_object(_node)
-        raise NotImplementedError
-      end
-
-      # @abstract Implemented with `def_node_matcher`
-      def on_bad_to_h(_node)
-        raise NotImplementedError
-      end
-
-      # @abstract Implemented with `def_node_matcher`
-      def on_bad_map_to_h(_node)
-        raise NotImplementedError
-      end
-
-      # @abstract Implemented with `def_node_matcher`
-      def on_bad_hash_brackets_map(_node)
-        raise NotImplementedError
-      end
-
-      def handle_possible_offense(node, match, match_desc)
-        captures = extract_captures(match)
-
-        return if captures.noop_transformation?
-
-        add_offense(
-          node, message: "Prefer `#{new_method_name}` over `#{match_desc}`."
-        ) do |corrector|
-          correction = prepare_correction(node)
-          execute_correction(corrector, node, correction)
-        end
-      end
-
-      def extract_captures(match)
-        argname, body_expr = *match
-        Captures.new(argname, body_expr)
-      end
-
-      def new_method_name
-        raise NotImplementedError
-      end
-
-      def prepare_correction(node)
-        if (match = on_bad_each_with_object(node))
-          Autocorrection.from_each_with_object(node, match)
-        elsif (match = on_bad_to_h(node))
-          Autocorrection.from_to_h(node, match)
-        elsif (match = on_bad_map_to_h(node))
-          Autocorrection.from_map_to_h(node, match)
-        elsif (match = on_bad_hash_brackets_map(node))
-          Autocorrection.from_hash_brackets_map(node, match)
-        else
-          raise 'unreachable'
-        end
-      end
-
-      def execute_correction(corrector, node, correction)
-        correction.strip_prefix_and_suffix(node, corrector)
-        correction.set_new_method_name(new_method_name, corrector)
-
-        captures = extract_captures(correction.match)
-        correction.set_new_arg_name(captures.transformed_argname, corrector)
-        correction.set_new_body_expression(
-          captures.transforming_body_expr,
-          corrector
-        )
-      end
-
-      # Internal helper class to hold match data
-      Captures = Struct.new(
-        :transformed_argname,
-        :transforming_body_expr
-      ) do
-        def noop_transformation?
-          transforming_body_expr.lvar_type? &&
-            transforming_body_expr.children == [transformed_argname]
-        end
-      end
-
-      # Internal helper class to hold autocorrect data
-      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
-        def self.from_each_with_object(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def self.from_to_h(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def self.from_map_to_h(node, match)
-          strip_trailing_chars = 0
-
-          unless node.parent&.block_type?
-            map_range = node.children.first.source_range
-            node_range = node.source_range
-            strip_trailing_chars = node_range.end_pos - map_range.end_pos
-          end
-
-          new(match, node.children.first, 0, strip_trailing_chars)
-        end
-
-        def self.from_hash_brackets_map(node, match)
-          new(match, node.children.last, 'Hash['.length, ']'.length)
-        end
-
-        def strip_prefix_and_suffix(node, corrector)
-          expression = node.loc.expression
-          corrector.remove_leading(expression, leading)
-          corrector.remove_trailing(expression, trailing)
-        end
-
-        def set_new_method_name(new_method_name, corrector)
-          range = block_node.send_node.loc.selector
-          if (send_end = block_node.send_node.loc.end)
-            # If there are arguments (only true in the `each_with_object` case)
-            range = range.begin.join(send_end)
-          end
-          corrector.replace(range, new_method_name)
-        end
-
-        def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(
-            block_node.arguments.loc.expression,
-            "|#{transformed_argname}|"
-          )
-        end
-
-        def set_new_body_expression(transforming_body_expr, corrector)
-          corrector.replace(
-            block_node.body.loc.expression,
-            transforming_body_expr.loc.expression.source
-          )
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/migrations_helper.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/migrations_helper.rb
deleted file mode 100644
index 8784a6d98cc33..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/migrations_helper.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for cops working with migrations
-    module MigrationsHelper
-      extend NodePattern::Macros
-
-      def_node_matcher :migration_class?, <<~PATTERN
-        (class
-          (const nil? _)
-          (send
-            (const (const {nil? cbase} :ActiveRecord) :Migration)
-            :[]
-            (float _))
-          _)
-      PATTERN
-
-      def in_migration?(node)
-        node.each_ancestor(:class).any? do |class_node|
-          migration_class?(class_node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/target_rails_version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/target_rails_version.rb
deleted file mode 100644
index 6f9021407fddf..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/mixin/target_rails_version.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking target rails version.
-    module TargetRailsVersion
-      def minimum_target_rails_version(version)
-        @minimum_target_rails_version = version
-      end
-
-      def support_target_rails_version?(version)
-        @minimum_target_rails_version <= version
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/action_controller_test_case.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/action_controller_test_case.rb
deleted file mode 100644
index 0811e699ab6e0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/action_controller_test_case.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Using `ActionController::TestCase`` is discouraged and should be replaced by
-      # `ActionDispatch::IntegrationTest``. Controller tests are too close to the
-      # internals of a controller whereas integration tests mimic the browser/user.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because the API of each test case class is different.
-      #   Make sure to update each test of your controller test cases after changing the superclass.
-      #
-      # @example
-      #   # bad
-      #   class MyControllerTest < ActionController::TestCase
-      #   end
-      #
-      #   # good
-      #   class MyControllerTest < ActionDispatch::IntegrationTest
-      #   end
-      #
-      class ActionControllerTestCase < Base
-        extend AutoCorrector
-        extend TargetRailsVersion
-
-        MSG = 'Use `ActionDispatch::IntegrationTest` instead.'
-
-        minimum_target_rails_version 5.0
-
-        def_node_matcher :action_controller_test_case?, <<~PATTERN
-          (class
-            (const nil? _)
-            (const (const {nil? cbase} :ActionController) :TestCase) nil?)
-        PATTERN
-
-        def on_class(node)
-          return unless action_controller_test_case?(node)
-
-          add_offense(node.parent_class) do |corrector|
-            corrector.replace(node.parent_class, 'ActionDispatch::IntegrationTest')
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/action_filter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/action_filter.rb
deleted file mode 100644
index 83db0ade84371..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/action_filter.rb
+++ /dev/null
@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces the consistent use of action filter methods.
-      #
-      # The cop is configurable and can enforce the use of the older
-      # something_filter methods or the newer something_action methods.
-      #
-      # @example EnforcedStyle: action (default)
-      #   # bad
-      #   after_filter :do_stuff
-      #   append_around_filter :do_stuff
-      #   skip_after_filter :do_stuff
-      #
-      #   # good
-      #   after_action :do_stuff
-      #   append_around_action :do_stuff
-      #   skip_after_action :do_stuff
-      #
-      # @example EnforcedStyle: filter
-      #   # bad
-      #   after_action :do_stuff
-      #   append_around_action :do_stuff
-      #   skip_after_action :do_stuff
-      #
-      #   # good
-      #   after_filter :do_stuff
-      #   append_around_filter :do_stuff
-      #   skip_after_filter :do_stuff
-      class ActionFilter < Base
-        include ConfigurableEnforcedStyle
-        extend AutoCorrector
-
-        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
-
-        FILTER_METHODS = %i[
-          after_filter
-          append_after_filter
-          append_around_filter
-          append_before_filter
-          around_filter
-          before_filter
-          prepend_after_filter
-          prepend_around_filter
-          prepend_before_filter
-          skip_after_filter
-          skip_around_filter
-          skip_before_filter
-          skip_filter
-        ].freeze
-
-        ACTION_METHODS = %i[
-          after_action
-          append_after_action
-          append_around_action
-          append_before_action
-          around_action
-          before_action
-          prepend_after_action
-          prepend_around_action
-          prepend_before_action
-          skip_after_action
-          skip_around_action
-          skip_before_action
-          skip_action_callback
-        ].freeze
-
-        RESTRICT_ON_SEND = FILTER_METHODS + ACTION_METHODS
-
-        def on_block(node)
-          check_method_node(node.send_node)
-        end
-
-        def on_send(node)
-          check_method_node(node) unless node.receiver
-        end
-
-        private
-
-        def check_method_node(node)
-          method_name = node.method_name
-          return unless bad_methods.include?(method_name)
-
-          message = format(MSG, prefer: preferred_method(method_name), current: method_name)
-
-          add_offense(node.loc.selector, message: message) do |corrector|
-            corrector.replace(node.loc.selector, preferred_method(node.loc.selector.source))
-          end
-        end
-
-        def bad_methods
-          style == :action ? FILTER_METHODS : ACTION_METHODS
-        end
-
-        def good_methods
-          style == :action ? ACTION_METHODS : FILTER_METHODS
-        end
-
-        def preferred_method(method)
-          good_methods[bad_methods.index(method.to_sym)]
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/active_record_aliases.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/active_record_aliases.rb
deleted file mode 100644
index d48e184723129..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/active_record_aliases.rb
+++ /dev/null
@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks that ActiveRecord aliases are not used. The direct method names
-      # are more clear and easier to read.
-      #
-      # @safety
-      #   This cop is unsafe because custom `update_attributes` method call was changed to
-      #   `update` but the method name remained same in the method definition.
-      #
-      # @example
-      #   #bad
-      #   book.update_attributes!(author: 'Alice')
-      #
-      #   #good
-      #   book.update!(author: 'Alice')
-      class ActiveRecordAliases < Base
-        extend AutoCorrector
-
-        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
-
-        ALIASES = {
-          update_attributes: :update,
-          update_attributes!: :update!
-        }.freeze
-
-        RESTRICT_ON_SEND = ALIASES.keys.freeze
-
-        def on_send(node)
-          method_name = node.method_name
-          alias_method = ALIASES[method_name]
-
-          add_offense(
-            node.loc.selector,
-            message: format(MSG, prefer: alias_method, current: method_name),
-            severity: :warning
-          ) do |corrector|
-            corrector.replace(node.loc.selector, alias_method)
-          end
-        end
-
-        alias on_csend on_send
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/active_record_callbacks_order.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/active_record_callbacks_order.rb
deleted file mode 100644
index 734f117347f7f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/active_record_callbacks_order.rb
+++ /dev/null
@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks that Active Record callbacks are declared
-      # in the order in which they will be executed.
-      #
-      # @example
-      #   # bad
-      #   class Person < ApplicationRecord
-      #     after_commit :after_commit_callback
-      #     before_validation :before_validation_callback
-      #   end
-      #
-      #   # good
-      #   class Person < ApplicationRecord
-      #     before_validation :before_validation_callback
-      #     after_commit :after_commit_callback
-      #   end
-      #
-      class ActiveRecordCallbacksOrder < Base
-        extend AutoCorrector
-
-        MSG = '`%<current>s` is supposed to appear before `%<previous>s`.'
-
-        CALLBACKS_IN_ORDER = %i[
-          after_initialize
-          before_validation
-          after_validation
-          before_save
-          around_save
-          before_create
-          around_create
-          after_create
-          before_update
-          around_update
-          after_update
-          before_destroy
-          around_destroy
-          after_destroy
-          after_save
-          after_commit
-          after_rollback
-          after_find
-          after_touch
-        ].freeze
-
-        CALLBACKS_ORDER_MAP = CALLBACKS_IN_ORDER.each_with_index.to_h.freeze
-
-        def on_class(class_node)
-          previous_index = -1
-          previous_callback = nil
-
-          defined_callbacks(class_node).each do |node|
-            callback = node.method_name
-            index = CALLBACKS_ORDER_MAP[callback]
-
-            if index < previous_index
-              message = format(MSG, current: callback, previous: previous_callback)
-              add_offense(node, message: message) do |corrector|
-                autocorrect(corrector, node)
-              end
-            end
-            previous_index = index
-            previous_callback = callback
-          end
-        end
-
-        private
-
-        # Autocorrect by swapping between two nodes autocorrecting them
-        def autocorrect(corrector, node)
-          previous = node.left_siblings.reverse_each.find do |sibling|
-            callback?(sibling)
-          end
-
-          current_range = source_range_with_comment(node)
-          previous_range = source_range_with_comment(previous)
-
-          corrector.insert_before(previous_range, current_range.source)
-          corrector.remove(current_range)
-        end
-
-        def defined_callbacks(class_node)
-          class_def = class_node.body
-
-          if class_def
-            class_def.each_child_node.select { |c| callback?(c) }
-          else
-            []
-          end
-        end
-
-        def callback?(node)
-          node.send_type? && CALLBACKS_ORDER_MAP.key?(node.method_name)
-        end
-
-        def source_range_with_comment(node)
-          begin_pos = begin_pos_with_comment(node)
-          end_pos = end_position_for(node)
-
-          Parser::Source::Range.new(buffer, begin_pos, end_pos)
-        end
-
-        def end_position_for(node)
-          end_line = buffer.line_for_position(node.loc.expression.end_pos)
-          buffer.line_range(end_line).end_pos
-        end
-
-        def begin_pos_with_comment(node)
-          annotation_line = node.first_line - 1
-          first_comment = nil
-
-          processed_source.comments_before_line(annotation_line)
-                          .reverse_each do |comment|
-            if comment.location.line == annotation_line && !inline_comment?(comment)
-              first_comment = comment
-              annotation_line -= 1
-            end
-          end
-
-          start_line_position(first_comment || node)
-        end
-
-        def inline_comment?(comment)
-          !comment_line?(comment.loc.expression.source_line)
-        end
-
-        def start_line_position(node)
-          buffer.line_range(node.loc.line).begin_pos - 1
-        end
-
-        def buffer
-          processed_source.buffer
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/active_record_override.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/active_record_override.rb
deleted file mode 100644
index 16fe42e82d229..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/active_record_override.rb
+++ /dev/null
@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for overriding built-in Active Record methods instead of using
-      # callbacks.
-      #
-      # @example
-      #   # bad
-      #   class Book < ApplicationRecord
-      #     def save
-      #       self.title = title.upcase!
-      #       super
-      #     end
-      #   end
-      #
-      #   # good
-      #   class Book < ApplicationRecord
-      #     before_save :upcase_title
-      #
-      #     def upcase_title
-      #       self.title = title.upcase!
-      #     end
-      #   end
-      #
-      class ActiveRecordOverride < Base
-        MSG =
-          'Use %<prefer>s callbacks instead of overriding the Active Record ' \
-          'method `%<bad>s`.'
-        BAD_METHODS = %i[create destroy save update].freeze
-        ACTIVE_RECORD_CLASSES = %w[ApplicationRecord ActiveModel::Base
-                                   ActiveRecord::Base].freeze
-
-        def on_def(node)
-          return unless BAD_METHODS.include?(node.method_name)
-
-          parent_class_name = find_parent_class_name(node)
-          return unless active_model?(parent_class_name)
-
-          return unless node.descendants.any?(&:zsuper_type?)
-
-          add_offense(node, message: message(node.method_name))
-        end
-
-        private
-
-        def active_model?(parent_class_name)
-          ACTIVE_RECORD_CLASSES.include?(parent_class_name)
-        end
-
-        def callback_names(method_name)
-          names = %w[before_ around_ after_].map do |prefix|
-            "`#{prefix}#{method_name}`"
-          end
-
-          names[-1] = "or #{names.last}"
-
-          names.join(', ')
-        end
-
-        def message(method_name)
-          format(MSG, prefer: callback_names(method_name), bad: method_name)
-        end
-
-        def find_parent_class_name(node)
-          return nil unless node
-
-          if node.class_type?
-            parent_class_name = node.node_parts[1]
-
-            return nil if parent_class_name.nil?
-
-            return parent_class_name.source
-          end
-
-          find_parent_class_name(node.parent)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/active_support_aliases.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/active_support_aliases.rb
deleted file mode 100644
index 312490da4b38a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/active_support_aliases.rb
+++ /dev/null
@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks that ActiveSupport aliases to core ruby methods
-      # are not used.
-      #
-      # @example
-      #   # good
-      #   'some_string'.start_with?('prefix')
-      #   'some_string'.end_with?('suffix')
-      #   [1, 2, 'a'] << 'b'
-      #   [1, 2, 'a'].unshift('b')
-      #
-      #   # bad
-      #   'some_string'.starts_with?('prefix')
-      #   'some_string'.ends_with?('suffix')
-      #   [1, 2, 'a'].append('b')
-      #   [1, 2, 'a'].prepend('b')
-      #
-      class ActiveSupportAliases < Base
-        extend AutoCorrector
-
-        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
-        RESTRICT_ON_SEND = %i[starts_with? ends_with? append prepend].freeze
-
-        ALIASES = {
-          starts_with?: {
-            original: :start_with?, matcher: '(send str :starts_with? _)'
-          },
-          ends_with?: {
-            original: :end_with?, matcher: '(send str :ends_with? _)'
-          },
-          append: { original: :<<, matcher: '(send array :append _)' },
-          prepend: { original: :unshift, matcher: '(send array :prepend _)' }
-        }.freeze
-
-        ALIASES.each do |aliased_method, options|
-          def_node_matcher aliased_method, options[:matcher]
-        end
-
-        def on_send(node)
-          ALIASES.each_key do |aliased_method|
-            next unless public_send(aliased_method, node)
-
-            preferred_method = ALIASES[aliased_method][:original]
-            message = format(MSG, prefer: preferred_method, current: aliased_method)
-
-            add_offense(node, message: message) do |corrector|
-              next if append(node)
-
-              corrector.replace(node.loc.selector, preferred_method)
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/add_column_index.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/add_column_index.rb
deleted file mode 100644
index 9bc6bb7cd4971..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/add_column_index.rb
+++ /dev/null
@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for migrations using `add_column` that have an `index`
-      # key. `add_column` does not accept `index`, but also does not raise an
-      # error for extra keys, so it is possible to mistakenly add the key without
-      # realizing it will not actually add an index.
-      #
-      # @example
-      #   # bad (will not add an index)
-      #   add_column :table, :column, :integer, index: true
-      #
-      #   # good
-      #   add_column :table, :column, :integer
-      #   add_index :table, :column
-      #
-      class AddColumnIndex < Base
-        extend AutoCorrector
-        include RangeHelp
-
-        MSG = '`add_column` does not accept an `index` key, use `add_index` instead.'
-        RESTRICT_ON_SEND = %i[add_column].freeze
-
-        # @!method add_column_with_index(node)
-        def_node_matcher :add_column_with_index, <<~PATTERN
-          (
-            send nil? :add_column $_table $_column
-              <(hash <$(pair {(sym :index) (str "index")} $_) ...>) ...>
-          )
-        PATTERN
-
-        def on_send(node)
-          table, column, pair, value = add_column_with_index(node)
-          return unless pair
-
-          add_offense(pair) do |corrector|
-            corrector.remove(index_range(pair))
-
-            add_index = "add_index #{table.source}, #{column.source}"
-            add_index_opts = ''
-
-            if value.hash_type?
-              hash = value.loc.expression.adjust(begin_pos: 1, end_pos: -1).source.strip
-              add_index_opts = ", #{hash}"
-            end
-
-            corrector.insert_after(node, "\n#{add_index}#{add_index_opts}")
-          end
-        end
-
-        private
-
-        def index_range(pair_node)
-          range_with_surrounding_comma(
-            range_with_surrounding_space(range: pair_node.loc.expression, side: :left),
-            :left
-          )
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/after_commit_override.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/after_commit_override.rb
deleted file mode 100644
index 070941de77af3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/after_commit_override.rb
+++ /dev/null
@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces that there is only one call to `after_commit`
-      # (and its aliases - `after_create_commit`, `after_update_commit`,
-      # and `after_destroy_commit`) with the same callback name per model.
-      #
-      # @example
-      #   # bad
-      #   # This won't be triggered.
-      #   after_create_commit :log_action
-      #
-      #   # This will override the callback added by
-      #   # after_create_commit.
-      #   after_update_commit :log_action
-      #
-      #   # bad
-      #   # This won't be triggered.
-      #   after_commit :log_action, on: :create
-      #   # This won't be triggered.
-      #   after_update_commit :log_action
-      #   # This will override both previous callbacks.
-      #   after_commit :log_action, on: :destroy
-      #
-      #   # good
-      #   after_save_commit :log_action
-      #
-      #   # good
-      #   after_create_commit :log_create_action
-      #   after_update_commit :log_update_action
-      #
-      class AfterCommitOverride < Base
-        include ClassSendNodeHelper
-
-        MSG = 'There can only be one `after_*_commit :%<name>s` hook defined for a model.'
-
-        AFTER_COMMIT_CALLBACKS = %i[
-          after_commit
-          after_create_commit
-          after_update_commit
-          after_save_commit
-          after_destroy_commit
-        ].freeze
-
-        def on_class(class_node)
-          seen_callback_names = {}
-
-          each_after_commit_callback(class_node) do |node|
-            callback_name = node.arguments[0].value
-            if seen_callback_names.key?(callback_name)
-              add_offense(node, message: format(MSG, name: callback_name))
-            else
-              seen_callback_names[callback_name] = true
-            end
-          end
-        end
-
-        private
-
-        def each_after_commit_callback(class_node)
-          class_send_nodes(class_node).each do |node|
-            yield node if after_commit_callback?(node) && named_callback?(node)
-          end
-        end
-
-        def after_commit_callback?(node)
-          AFTER_COMMIT_CALLBACKS.include?(node.method_name)
-        end
-
-        def named_callback?(node)
-          name = node.first_argument
-          return false unless name
-
-          name.sym_type?
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/application_controller.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/application_controller.rb
deleted file mode 100644
index 6e67472256931..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/application_controller.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks that controllers subclass `ApplicationController`.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because it may let the logic from `ApplicationController`
-      #   sneak into a controller that is not purposed to inherit logic common among other controllers.
-      #
-      # @example
-      #
-      #  # good
-      #  class MyController < ApplicationController
-      #    # ...
-      #  end
-      #
-      #  # bad
-      #  class MyController < ActionController::Base
-      #    # ...
-      #  end
-      class ApplicationController < Base
-        extend AutoCorrector
-
-        MSG = 'Controllers should subclass `ApplicationController`.'
-        SUPERCLASS = 'ApplicationController'
-        BASE_PATTERN = '(const (const nil? :ActionController) :Base)'
-
-        # rubocop:disable Layout/ClassStructure
-        include RuboCop::Cop::EnforceSuperclass
-        # rubocop:enable Layout/ClassStructure
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/application_job.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/application_job.rb
deleted file mode 100644
index d02e32b2535a5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/application_job.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks that jobs subclass `ApplicationJob` with Rails 5.0.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because it may let the logic from `ApplicationJob`
-      #   sneak into a job that is not purposed to inherit logic common among other jobs.
-      #
-      # @example
-      #
-      #  # good
-      #  class Rails5Job < ApplicationJob
-      #    # ...
-      #  end
-      #
-      #  # bad
-      #  class Rails4Job < ActiveJob::Base
-      #    # ...
-      #  end
-      class ApplicationJob < Base
-        extend AutoCorrector
-        extend TargetRailsVersion
-
-        minimum_target_rails_version 5.0
-
-        MSG = 'Jobs should subclass `ApplicationJob`.'
-        SUPERCLASS = 'ApplicationJob'
-        BASE_PATTERN = '(const (const nil? :ActiveJob) :Base)'
-
-        # rubocop:disable Layout/ClassStructure
-        include RuboCop::Cop::EnforceSuperclass
-        # rubocop:enable Layout/ClassStructure
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, self.class::SUPERCLASS)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/application_mailer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/application_mailer.rb
deleted file mode 100644
index c8638da9f257a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/application_mailer.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks that mailers subclass `ApplicationMailer` with Rails 5.0.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because it may let the logic from `ApplicationMailer`
-      #   sneak into a mailer that is not purposed to inherit logic common among other mailers.
-      #
-      # @example
-      #
-      #  # good
-      #  class MyMailer < ApplicationMailer
-      #    # ...
-      #  end
-      #
-      #  # bad
-      #  class MyMailer < ActionMailer::Base
-      #    # ...
-      #  end
-      class ApplicationMailer < Base
-        extend AutoCorrector
-        extend TargetRailsVersion
-
-        minimum_target_rails_version 5.0
-
-        MSG = 'Mailers should subclass `ApplicationMailer`.'
-        SUPERCLASS = 'ApplicationMailer'
-        BASE_PATTERN = '(const (const nil? :ActionMailer) :Base)'
-
-        # rubocop:disable Layout/ClassStructure
-        include RuboCop::Cop::EnforceSuperclass
-        # rubocop:enable Layout/ClassStructure
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/application_record.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/application_record.rb
deleted file mode 100644
index ebd46b179ffd8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/application_record.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks that models subclass `ApplicationRecord` with Rails 5.0.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because it may let the logic from `ApplicationRecord`
-      #   sneak into an Active Record model that is not purposed to inherit logic common among other
-      #   Active Record models.
-      #
-      # @example
-      #
-      #  # good
-      #  class Rails5Model < ApplicationRecord
-      #    # ...
-      #  end
-      #
-      #  # bad
-      #  class Rails4Model < ActiveRecord::Base
-      #    # ...
-      #  end
-      class ApplicationRecord < Base
-        extend AutoCorrector
-        extend TargetRailsVersion
-
-        minimum_target_rails_version 5.0
-
-        MSG = 'Models should subclass `ApplicationRecord`.'
-        SUPERCLASS = 'ApplicationRecord'
-        BASE_PATTERN = '(const (const nil? :ActiveRecord) :Base)'
-
-        # rubocop:disable Layout/ClassStructure
-        include RuboCop::Cop::EnforceSuperclass
-        # rubocop:enable Layout/ClassStructure
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/arel_star.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/arel_star.rb
deleted file mode 100644
index 77e5441a9a53c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/arel_star.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Prevents usage of `"*"` on an Arel::Table column reference.
-      #
-      # Using `arel_table["*"]` causes the outputted string to be a literal
-      # quoted asterisk (e.g. <tt>`my_model`.`*`</tt>). This causes the
-      # database to look for a column named <tt>`*`</tt> (or `"*"`) as opposed
-      # to expanding the column list as one would likely expect.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because it turns a quoted `*` into
-      #   an SQL `*`, unquoted. `*` is a valid column name in certain databases
-      #   supported by Rails, and even though it is usually a mistake,
-      #   it might denote legitimate access to a column named `*`.
-      #
-      # @example
-      #   # bad
-      #   MyTable.arel_table["*"]
-      #
-      #   # good
-      #   MyTable.arel_table[Arel.star]
-      #
-      class ArelStar < Base
-        extend AutoCorrector
-
-        MSG = 'Use `Arel.star` instead of `"*"` for expanded column lists.'
-
-        RESTRICT_ON_SEND = %i[[]].freeze
-
-        def_node_matcher :star_bracket?, <<~PATTERN
-          (send {const (send _ :arel_table)} :[] $(str "*"))
-        PATTERN
-
-        def on_send(node)
-          return unless (star = star_bracket?(node))
-
-          add_offense(star) do |corrector|
-            corrector.replace(star.loc.expression, 'Arel.star')
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/assert_not.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/assert_not.rb
deleted file mode 100644
index 5acc24416eedd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/assert_not.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      #
-      # Use `assert_not` instead of `assert !`.
-      #
-      # @example
-      #   # bad
-      #   assert !x
-      #
-      #   # good
-      #   assert_not x
-      #
-      class AssertNot < Base
-        extend AutoCorrector
-
-        MSG = 'Prefer `assert_not` over `assert !`.'
-        RESTRICT_ON_SEND = %i[assert].freeze
-
-        def_node_matcher :offensive?, '(send nil? :assert (send ... :!) ...)'
-
-        def on_send(node)
-          return unless offensive?(node)
-
-          add_offense(node) do |corrector|
-            expression = node.loc.expression
-
-            corrector.replace(expression, corrected_source(expression.source))
-          end
-        end
-
-        private
-
-        def corrected_source(source)
-          source.gsub(/^assert(\(| ) *! */, 'assert_not\\1')
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/attribute_default_block_value.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/attribute_default_block_value.rb
deleted file mode 100644
index 42bac8e3b2c21..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/attribute_default_block_value.rb
+++ /dev/null
@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Looks for `attribute` class methods that specify a `:default` option
-      # which value is an array, string literal or method call without a block.
-      # It will accept all other values, such as string, symbol, integer and float literals
-      # as well as constants.
-      #
-      # @example
-      #   # bad
-      #   class User < ApplicationRecord
-      #     attribute :confirmed_at, :datetime, default: Time.zone.now
-      #   end
-      #
-      #   # good
-      #   class User < ApplicationRecord
-      #     attribute :confirmed_at, :datetime, default: -> { Time.zone.now }
-      #   end
-      #
-      #   # bad
-      #   class User < ApplicationRecord
-      #     attribute :roles, :string, array: true, default: []
-      #   end
-      #
-      #   # good
-      #   class User < ApplicationRecord
-      #     attribute :roles, :string, array: true, default: -> { [] }
-      #   end
-      #
-      #   # bad
-      #   class User < ApplicationRecord
-      #     attribute :configuration, default: {}
-      #   end
-      #
-      #   # good
-      #   class User < ApplicationRecord
-      #     attribute :configuration, default: -> { {} }
-      #   end
-      #
-      #   # good
-      #   class User < ApplicationRecord
-      #     attribute :role, :string, default: :customer
-      #   end
-      #
-      #   # good
-      #   class User < ApplicationRecord
-      #     attribute :activated, :boolean, default: false
-      #   end
-      #
-      #   # good
-      #   class User < ApplicationRecord
-      #     attribute :login_count, :integer, default: 0
-      #   end
-      #
-      #   # good
-      #   class User < ApplicationRecord
-      #     FOO = 123
-      #     attribute :custom_attribute, :integer, default: FOO
-      #   end
-      class AttributeDefaultBlockValue < Base
-        extend AutoCorrector
-
-        MSG = 'Pass method in a block to `:default` option.'
-        RESTRICT_ON_SEND = %i[attribute].freeze
-        TYPE_OFFENDERS = %i[send array hash].freeze
-
-        def_node_matcher :default_attribute, <<~PATTERN
-          (send nil? :attribute _ ?_ (hash <$#attribute ...>))
-        PATTERN
-
-        def_node_matcher :attribute, '(pair (sym :default) $_)'
-
-        def on_send(node)
-          default_attribute(node) do |attribute|
-            value = attribute.children.last
-            return unless TYPE_OFFENDERS.any?(value.type)
-
-            add_offense(value) do |corrector|
-              expression = default_attribute(node).children.last
-
-              corrector.replace(value, "-> { #{expression.source} }")
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/belongs_to.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/belongs_to.rb
deleted file mode 100644
index 37d4ea255a5af..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/belongs_to.rb
+++ /dev/null
@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Looks for belongs_to associations where we control whether the
-      # association is required via the deprecated `required` option instead.
-      #
-      # Since Rails 5, belongs_to associations are required by default and this
-      # can be controlled through the use of `optional: true`.
-      #
-      # From the release notes:
-      #
-      #     belongs_to will now trigger a validation error by default if the
-      #     association is not present. You can turn this off on a
-      #     per-association basis with optional: true. Also deprecate required
-      #     option in favor of optional for belongs_to. (Pull Request)
-      #
-      # In the case that the developer is doing `required: false`, we
-      # definitely want to autocorrect to `optional: true`.
-      #
-      # However, without knowing whether they've set overridden the default
-      # value of `config.active_record.belongs_to_required_by_default`, we
-      # can't say whether it's safe to remove `required: true` or whether we
-      # should replace it with `optional: false` (or, similarly, remove a
-      # superfluous `optional: false`). Therefore, in the cases we're using
-      # `required: true`, we'll simply invert it to `optional: false` and the
-      # user can remove depending on their defaults.
-      #
-      # @example
-      #   # bad
-      #   class Post < ApplicationRecord
-      #     belongs_to :blog, required: false
-      #   end
-      #
-      #   # good
-      #   class Post < ApplicationRecord
-      #     belongs_to :blog, optional: true
-      #   end
-      #
-      #   # bad
-      #   class Post < ApplicationRecord
-      #     belongs_to :blog, required: true
-      #   end
-      #
-      #   # good
-      #   class Post < ApplicationRecord
-      #     belongs_to :blog, optional: false
-      #   end
-      #
-      # @see https://guides.rubyonrails.org/5_0_release_notes.html
-      # @see https://github.com/rails/rails/pull/18937
-      class BelongsTo < Base
-        extend AutoCorrector
-        extend TargetRailsVersion
-
-        minimum_target_rails_version 5.0
-
-        SUPERFLOUS_REQUIRE_FALSE_MSG =
-          'You specified `required: false`, in Rails > 5.0 the required ' \
-          'option is deprecated and you want to use `optional: true`.'
-
-        SUPERFLOUS_REQUIRE_TRUE_MSG =
-          'You specified `required: true`, in Rails > 5.0 the required ' \
-          'option is deprecated and you want to use `optional: false`. ' \
-          'In most configurations, this is the default and you can omit ' \
-          'this option altogether'
-        RESTRICT_ON_SEND = %i[belongs_to].freeze
-
-        def_node_matcher :match_belongs_to_with_options, <<~PATTERN
-          (send _ :belongs_to ...
-            (hash <$(pair (sym :required) ${true false}) ...>)
-          )
-        PATTERN
-
-        def on_send(node)
-          match_belongs_to_with_options(node) do |option_node, option_value|
-            message, replacement =
-              if option_value.true_type?
-                [SUPERFLOUS_REQUIRE_TRUE_MSG, 'optional: false']
-              elsif option_value.false_type?
-                [SUPERFLOUS_REQUIRE_FALSE_MSG, 'optional: true']
-              end
-
-            add_offense(node.loc.selector, message: message) do |corrector|
-              corrector.replace(option_node.loc.expression, replacement)
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/blank.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/blank.rb
deleted file mode 100644
index d5a0a8fa2cbcd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/blank.rb
+++ /dev/null
@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for code that can be written with simpler conditionals
-      # using `Object#blank?` defined by Active Support.
-      #
-      # Interaction with `Style/UnlessElse`:
-      # The configuration of `NotPresent` will not produce an offense in the
-      # context of `unless else` if `Style/UnlessElse` is inabled. This is
-      # to prevent interference between the autocorrection of the two cops.
-      #
-      # @safety
-      #   This cop is unsafe autocorrection, because `' '.empty?` returns false,
-      #   but `' '.blank?` returns true. Therefore, autocorrection is not compatible
-      #   if the receiver is a non-empty blank string, tab, or newline meta characters.
-      #
-      # @example NilOrEmpty: true (default)
-      #   # Converts usages of `nil? || empty?` to `blank?`
-      #
-      #   # bad
-      #   foo.nil? || foo.empty?
-      #   foo == nil || foo.empty?
-      #
-      #   # good
-      #   foo.blank?
-      #
-      # @example NotPresent: true (default)
-      #   # Converts usages of `!present?` to `blank?`
-      #
-      #   # bad
-      #   !foo.present?
-      #
-      #   # good
-      #   foo.blank?
-      #
-      # @example UnlessPresent: true (default)
-      #   # Converts usages of `unless present?` to `if blank?`
-      #
-      #   # bad
-      #   something unless foo.present?
-      #
-      #   # good
-      #   something if foo.blank?
-      #
-      #   # bad
-      #   unless foo.present?
-      #     something
-      #   end
-      #
-      #   # good
-      #   if foo.blank?
-      #     something
-      #   end
-      #
-      #   # good
-      #   def blank?
-      #     !present?
-      #   end
-      class Blank < Base
-        extend AutoCorrector
-
-        MSG_NIL_OR_EMPTY = 'Use `%<prefer>s` instead of `%<current>s`.'
-        MSG_NOT_PRESENT = 'Use `%<prefer>s` instead of `%<current>s`.'
-        MSG_UNLESS_PRESENT = 'Use `if %<prefer>s` instead of ' \
-                             '`%<current>s`.'
-        RESTRICT_ON_SEND = %i[!].freeze
-
-        # `(send nil $_)` is not actually a valid match for an offense. Nodes
-        # that have a single method call on the left hand side
-        # (`bar || foo.empty?`) will blow up when checking
-        # `(send (:nil) :== $_)`.
-        def_node_matcher :nil_or_empty?, <<~PATTERN
-          (or
-              {
-                (send $_ :!)
-                (send $_ :nil?)
-                (send $_ :== nil)
-                (send nil :== $_)
-              }
-              {
-                (send $_ :empty?)
-                (send (send (send $_ :empty?) :!) :!)
-              }
-          )
-        PATTERN
-
-        def_node_matcher :not_present?, '(send (send $_ :present?) :!)'
-
-        def_node_matcher :defining_blank?, '(def :blank? (args) ...)'
-
-        def_node_matcher :unless_present?, <<~PATTERN
-          (:if $(send $_ :present?) {nil? (...)} ...)
-        PATTERN
-
-        def on_send(node)
-          return unless cop_config['NotPresent']
-
-          not_present?(node) do |receiver|
-            # accepts !present? if its in the body of a `blank?` method
-            next if defining_blank?(node.parent)
-
-            message = format(MSG_NOT_PRESENT, prefer: replacement(receiver), current: node.source)
-            add_offense(node, message: message) do |corrector|
-              autocorrect(corrector, node)
-            end
-          end
-        end
-
-        def on_or(node)
-          return unless cop_config['NilOrEmpty']
-
-          nil_or_empty?(node) do |var1, var2|
-            return unless var1 == var2
-
-            message = format(MSG_NIL_OR_EMPTY, prefer: replacement(var1), current: node.source)
-            add_offense(node, message: message) do |corrector|
-              autocorrect(corrector, node)
-            end
-          end
-        end
-
-        def on_if(node)
-          return unless cop_config['UnlessPresent']
-          return unless node.unless?
-          return if node.else? && config.for_cop('Style/UnlessElse')['Enabled']
-
-          unless_present?(node) do |method_call, receiver|
-            range = unless_condition(node, method_call)
-
-            message = format(MSG_UNLESS_PRESENT, prefer: replacement(receiver), current: range.source)
-            add_offense(range, message: message) do |corrector|
-              autocorrect(corrector, node)
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          method_call, variable1 = unless_present?(node)
-
-          if method_call
-            corrector.replace(node.loc.keyword, 'if')
-            range = method_call.loc.expression
-          else
-            variable1, _variable2 = nil_or_empty?(node) || not_present?(node)
-            range = node.loc.expression
-          end
-
-          corrector.replace(range, replacement(variable1))
-        end
-
-        def unless_condition(node, method_call)
-          if node.modifier_form?
-            node.loc.keyword.join(node.loc.expression.end)
-          else
-            node.loc.expression.begin.join(method_call.loc.expression)
-          end
-        end
-
-        def replacement(node)
-          node.respond_to?(:source) ? "#{node.source}.blank?" : 'blank?'
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/bulk_change_table.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/bulk_change_table.rb
deleted file mode 100644
index a9bfb2c9e561c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/bulk_change_table.rb
+++ /dev/null
@@ -1,311 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks whether alter queries are combinable.
-      # If combinable queries are detected, it suggests to you
-      # to use `change_table` with `bulk: true` instead.
-      # This option causes the migration to generate a single
-      # ALTER TABLE statement combining multiple column alterations.
-      #
-      # The `bulk` option is only supported on the MySQL and
-      # the PostgreSQL (5.2 later) adapter; thus it will
-      # automatically detect an adapter from `development` environment
-      # in `config/database.yml` when the `Database` option is not set.
-      # If the adapter is not `mysql2` or `postgresql`,
-      # this Cop ignores offenses.
-      #
-      # @example
-      #   # bad
-      #   def change
-      #     add_column :users, :name, :string, null: false
-      #     add_column :users, :nickname, :string
-      #
-      #     # ALTER TABLE `users` ADD `name` varchar(255) NOT NULL
-      #     # ALTER TABLE `users` ADD `nickname` varchar(255)
-      #   end
-      #
-      #   # good
-      #   def change
-      #     change_table :users, bulk: true do |t|
-      #       t.string :name, null: false
-      #       t.string :nickname
-      #     end
-      #
-      #     # ALTER TABLE `users` ADD `name` varchar(255) NOT NULL,
-      #     #                     ADD `nickname` varchar(255)
-      #   end
-      #
-      # @example
-      #   # bad
-      #   def change
-      #     change_table :users do |t|
-      #       t.string :name, null: false
-      #       t.string :nickname
-      #     end
-      #   end
-      #
-      #   # good
-      #   def change
-      #     change_table :users, bulk: true do |t|
-      #       t.string :name, null: false
-      #       t.string :nickname
-      #     end
-      #   end
-      #
-      #   # good
-      #   # When you don't want to combine alter queries.
-      #   def change
-      #     change_table :users, bulk: false do |t|
-      #       t.string :name, null: false
-      #       t.string :nickname
-      #     end
-      #   end
-      #
-      # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-change_table
-      # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/Table.html
-      class BulkChangeTable < Base
-        MSG_FOR_CHANGE_TABLE = <<~MSG.chomp
-          You can combine alter queries using `bulk: true` options.
-        MSG
-        MSG_FOR_ALTER_METHODS = <<~MSG.chomp
-          You can use `change_table :%<table>s, bulk: true` to combine alter queries.
-        MSG
-
-        MYSQL = 'mysql'
-        POSTGRESQL = 'postgresql'
-
-        MIGRATION_METHODS = %i[change up down].freeze
-
-        COMBINABLE_TRANSFORMATIONS = %i[
-          primary_key
-          column
-          string
-          text
-          integer
-          bigint
-          float
-          decimal
-          numeric
-          datetime
-          timestamp
-          time
-          date
-          binary
-          boolean
-          json
-          virtual
-          remove
-          change
-          timestamps
-          remove_timestamps
-        ].freeze
-
-        COMBINABLE_ALTER_METHODS = %i[
-          add_column
-          remove_column
-          remove_columns
-          change_column
-          add_timestamps
-          remove_timestamps
-        ].freeze
-
-        MYSQL_COMBINABLE_TRANSFORMATIONS = %i[
-          rename
-          index
-          remove_index
-        ].freeze
-
-        MYSQL_COMBINABLE_ALTER_METHODS = %i[
-          rename_column
-          add_index
-          remove_index
-        ].freeze
-
-        POSTGRESQL_COMBINABLE_TRANSFORMATIONS = %i[
-          change_default
-        ].freeze
-
-        POSTGRESQL_COMBINABLE_ALTER_METHODS = %i[
-          change_column_default
-        ].freeze
-
-        def on_def(node)
-          return unless support_bulk_alter?
-          return unless MIGRATION_METHODS.include?(node.method_name)
-          return unless node.body
-
-          recorder = AlterMethodsRecorder.new
-
-          node.body.child_nodes.each do |child_node|
-            if call_to_combinable_alter_method? child_node
-              recorder.process(child_node)
-            else
-              recorder.flush
-            end
-          end
-
-          recorder.offensive_nodes.each { |n| add_offense_for_alter_methods(n) }
-        end
-
-        def on_send(node)
-          return unless support_bulk_alter?
-          return unless node.command?(:change_table)
-          return if include_bulk_options?(node)
-          return unless node.block_node
-
-          send_nodes = send_nodes_from_change_table_block(node.block_node.body)
-
-          add_offense_for_change_table(node) if count_transformations(send_nodes) > 1
-        end
-
-        private
-
-        def send_nodes_from_change_table_block(body)
-          if body.send_type?
-            [body]
-          else
-            body.each_child_node(:send).to_a
-          end
-        end
-
-        def count_transformations(send_nodes)
-          send_nodes.sum do |node|
-            if node.method?(:remove)
-              node.arguments.count { |arg| !arg.hash_type? }
-            else
-              combinable_transformations.include?(node.method_name) ? 1 : 0
-            end
-          end
-        end
-
-        # @param node [RuboCop::AST::SendNode] (send nil? :change_table ...)
-        def include_bulk_options?(node)
-          # arguments: [{(sym :table)(str "table")} (hash (pair (sym :bulk) _))]
-          options = node.arguments[1]
-          return false unless options
-
-          options.hash_type? &&
-            options.keys.any? { |key| key.sym_type? && key.value == :bulk }
-        end
-
-        def database
-          cop_config['Database'] || database_from_yaml
-        end
-
-        def database_from_yaml
-          return nil unless database_yaml
-
-          case database_yaml['adapter']
-          when 'mysql2'
-            MYSQL
-          when 'postgresql'
-            POSTGRESQL
-          end
-        end
-
-        def database_yaml
-          return nil unless File.exist?('config/database.yml')
-
-          yaml = if YAML.respond_to?(:unsafe_load_file)
-                   YAML.unsafe_load_file('config/database.yml')
-                 else
-                   YAML.load_file('config/database.yml')
-                 end
-          return nil unless yaml.is_a? Hash
-
-          config = yaml['development']
-          return nil unless config.is_a?(Hash)
-
-          config
-        rescue Psych::SyntaxError
-          nil
-        end
-
-        def support_bulk_alter?
-          case database
-          when MYSQL
-            true
-          when POSTGRESQL
-            # Add bulk alter support for PostgreSQL in 5.2.0
-            # @see https://github.com/rails/rails/pull/31331
-            target_rails_version >= 5.2
-          else
-            false
-          end
-        end
-
-        def call_to_combinable_alter_method?(child_node)
-          child_node.send_type? &&
-            combinable_alter_methods.include?(child_node.method_name)
-        end
-
-        def combinable_alter_methods
-          case database
-          when MYSQL
-            COMBINABLE_ALTER_METHODS + MYSQL_COMBINABLE_ALTER_METHODS
-          when POSTGRESQL
-            COMBINABLE_ALTER_METHODS + POSTGRESQL_COMBINABLE_ALTER_METHODS
-          end
-        end
-
-        def combinable_transformations
-          case database
-          when MYSQL
-            COMBINABLE_TRANSFORMATIONS + MYSQL_COMBINABLE_TRANSFORMATIONS
-          when POSTGRESQL
-            COMBINABLE_TRANSFORMATIONS + POSTGRESQL_COMBINABLE_TRANSFORMATIONS
-          end
-        end
-
-        # @param node [RuboCop::AST::SendNode]
-        def add_offense_for_alter_methods(node)
-          # arguments: [{(sym :table)(str "table")} ...]
-          table_node = node.arguments[0]
-          return unless table_node.is_a? RuboCop::AST::BasicLiteralNode
-
-          message = format(MSG_FOR_ALTER_METHODS, table: table_node.value)
-          add_offense(node, message: message)
-        end
-
-        # @param node [RuboCop::AST::SendNode]
-        def add_offense_for_change_table(node)
-          add_offense(node, message: MSG_FOR_CHANGE_TABLE)
-        end
-
-        # Record combinable alter methods and register offensive nodes.
-        class AlterMethodsRecorder
-          def initialize
-            @nodes = []
-            @offensive_nodes = []
-          end
-
-          # @param new_node [RuboCop::AST::SendNode]
-          def process(new_node)
-            # arguments: [{(sym :table)(str "table")} ...]
-            table_node = new_node.arguments[0]
-            if table_node.is_a? RuboCop::AST::BasicLiteralNode
-              flush unless @nodes.all? do |node|
-                node.arguments[0].value.to_s == table_node.value.to_s
-              end
-              @nodes << new_node
-            else
-              flush
-            end
-          end
-
-          def flush
-            @offensive_nodes << @nodes.first if @nodes.size > 1
-            @nodes = []
-          end
-
-          def offensive_nodes
-            flush
-            @offensive_nodes
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/compact_blank.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/compact_blank.rb
deleted file mode 100644
index 8efcf30f1d4b2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/compact_blank.rb
+++ /dev/null
@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks if collection can be blank-compacted with `compact_blank`.
-      #
-      # @safety
-      #   It is unsafe by default because false positives may occur in the
-      #   blank check of block arguments to the receiver object.
-      #
-      #   For example, `[[1, 2], [3, nil]].reject { |first, second| second.blank? }` and
-      #   `[[1, 2], [3, nil]].compact_blank` are not compatible. The same is true for `blank?`.
-      #   This will work fine when the receiver is a hash object.
-      #
-      #   And `compact_blank!` has different implementations for `Array`, `Hash`, and
-      #   `ActionController::Parameters`.
-      #   `Array#compact_blank!`, `Hash#compact_blank!` are equivalent to `delete_if(&:blank?)`.
-      #   `ActionController::Parameters#compact_blank!` is equivalent to `reject!(&:blank?)`.
-      #   If the cop makes a mistake, autocorrected code may get unexpected behavior.
-      #
-      # @example
-      #
-      #   # bad
-      #   collection.reject(&:blank?)
-      #   collection.reject { |_k, v| v.blank? }
-      #
-      #   # good
-      #   collection.compact_blank
-      #
-      #   # bad
-      #   collection.delete_if(&:blank?)            # Same behavior as `Array#compact_blank!` and `Hash#compact_blank!`
-      #   collection.delete_if { |_k, v| v.blank? } # Same behavior as `Array#compact_blank!` and `Hash#compact_blank!`
-      #   collection.reject!(&:blank?)              # Same behavior as `ActionController::Parameters#compact_blank!`
-      #   collection.reject! { |_k, v| v.blank? }   # Same behavior as `ActionController::Parameters#compact_blank!`
-      #
-      #   # good
-      #   collection.compact_blank!
-      #
-      class CompactBlank < Base
-        include RangeHelp
-        extend AutoCorrector
-        extend TargetRailsVersion
-
-        MSG = 'Use `%<preferred_method>s` instead.'
-        RESTRICT_ON_SEND = %i[reject delete_if reject!].freeze
-
-        minimum_target_rails_version 6.1
-
-        def_node_matcher :reject_with_block?, <<~PATTERN
-          (block
-            (send _ {:reject :delete_if :reject!})
-            $(args ...)
-            (send
-              $(lvar _) :blank?))
-        PATTERN
-
-        def_node_matcher :reject_with_block_pass?, <<~PATTERN
-          (send _ {:reject :delete_if :reject!}
-            (block_pass
-              (sym :blank?)))
-        PATTERN
-
-        def on_send(node)
-          return unless bad_method?(node)
-
-          range = offense_range(node)
-          preferred_method = preferred_method(node)
-          add_offense(range, message: format(MSG, preferred_method: preferred_method)) do |corrector|
-            corrector.replace(range, preferred_method)
-          end
-        end
-
-        private
-
-        def bad_method?(node)
-          return true if reject_with_block_pass?(node)
-
-          if (arguments, receiver_in_block = reject_with_block?(node.parent))
-            return use_single_value_block_argument?(arguments, receiver_in_block) ||
-                   use_hash_value_block_argument?(arguments, receiver_in_block)
-          end
-
-          false
-        end
-
-        def use_single_value_block_argument?(arguments, receiver_in_block)
-          arguments.length == 1 && arguments[0].source == receiver_in_block.source
-        end
-
-        def use_hash_value_block_argument?(arguments, receiver_in_block)
-          arguments.length == 2 && arguments[1].source == receiver_in_block.source
-        end
-
-        def offense_range(node)
-          end_pos = node.parent&.block_type? ? node.parent.loc.expression.end_pos : node.loc.expression.end_pos
-
-          range_between(node.loc.selector.begin_pos, end_pos)
-        end
-
-        def preferred_method(node)
-          node.method?(:reject) ? 'compact_blank' : 'compact_blank!'
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/content_tag.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/content_tag.rb
deleted file mode 100644
index 2c36621d1c092..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/content_tag.rb
+++ /dev/null
@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks legacy syntax usage of `tag`
-      #
-      # NOTE: Allow `tag` when the first argument is a variable because
-      # `tag(name)` is simpler rather than `tag.public_send(name)`.
-      # And this cop will be renamed to something like `LegacyTag` in the future. (e.g. RuboCop Rails 2.0)
-      #
-      # @example
-      #  # bad
-      #  tag(:p)
-      #  tag(:br, class: 'classname')
-      #
-      #  # good
-      #  tag.p
-      #  tag.br(class: 'classname')
-      #  tag(name, class: 'classname')
-      class ContentTag < Base
-        include RangeHelp
-        extend AutoCorrector
-        extend TargetRailsVersion
-
-        minimum_target_rails_version 5.1
-
-        MSG = 'Use `tag.%<preferred_method>s` instead of `tag(%<current_argument>s)`.'
-        RESTRICT_ON_SEND = %i[tag].freeze
-
-        def on_new_investigation
-          @corrected_nodes = nil
-        end
-
-        def on_send(node)
-          return unless node.receiver.nil?
-          return if node.arguments.count >= 3
-
-          first_argument = node.first_argument
-          return if !first_argument ||
-                    allowed_argument?(first_argument) ||
-                    corrected_ancestor?(node)
-
-          preferred_method = node.first_argument.value.to_s.underscore
-          message = format(MSG, preferred_method: preferred_method, current_argument: first_argument.source)
-
-          register_offense(node, message, preferred_method)
-        end
-
-        private
-
-        def corrected_ancestor?(node)
-          node.each_ancestor(:send).any? { |ancestor| @corrected_nodes&.include?(ancestor) }
-        end
-
-        def allowed_argument?(argument)
-          argument.variable? ||
-            argument.send_type? ||
-            argument.const_type? ||
-            argument.splat_type? ||
-            allowed_name?(argument)
-        end
-
-        def register_offense(node, message, preferred_method)
-          add_offense(node, message: message) do |corrector|
-            autocorrect(corrector, node, preferred_method)
-
-            @corrected_nodes ||= Set.new.compare_by_identity
-            @corrected_nodes.add(node)
-          end
-        end
-
-        def autocorrect(corrector, node, preferred_method)
-          range = correction_range(node)
-
-          rest_args = node.arguments.drop(1)
-          replacement = "tag.#{preferred_method}(#{rest_args.map(&:source).join(', ')})"
-
-          corrector.replace(range, replacement)
-        end
-
-        def allowed_name?(argument)
-          return false unless argument.str_type? || argument.sym_type?
-
-          !/^[a-zA-Z\-][a-zA-Z\-0-9]*$/.match?(argument.value)
-        end
-
-        def correction_range(node)
-          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/create_table_with_timestamps.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/create_table_with_timestamps.rb
deleted file mode 100644
index 6b676436b6d0c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/create_table_with_timestamps.rb
+++ /dev/null
@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks the migration for which timestamps are not included
-      # when creating a new table.
-      # In many cases, timestamps are useful information and should be added.
-      #
-      # @example
-      #   # bad
-      #   create_table :users
-      #
-      #   # bad
-      #   create_table :users do |t|
-      #     t.string :name
-      #     t.string :email
-      #   end
-      #
-      #   # good
-      #   create_table :users do |t|
-      #     t.string :name
-      #     t.string :email
-      #
-      #     t.timestamps
-      #   end
-      #
-      #   # good
-      #   create_table :users do |t|
-      #     t.string :name
-      #     t.string :email
-      #
-      #     t.datetime :created_at, default: -> { 'CURRENT_TIMESTAMP' }
-      #   end
-      #
-      #   # good
-      #   create_table :users do |t|
-      #     t.string :name
-      #     t.string :email
-      #
-      #     t.datetime :updated_at, default: -> { 'CURRENT_TIMESTAMP' }
-      #   end
-      class CreateTableWithTimestamps < Base
-        include ActiveRecordMigrationsHelper
-
-        MSG = 'Add timestamps when creating a new table.'
-        RESTRICT_ON_SEND = %i[create_table].freeze
-
-        def_node_matcher :create_table_with_timestamps_proc?, <<~PATTERN
-          (send nil? :create_table (sym _) ... (block-pass (sym :timestamps)))
-        PATTERN
-
-        def_node_search :timestamps_included?, <<~PATTERN
-          (send _var :timestamps ...)
-        PATTERN
-
-        def_node_search :created_at_or_updated_at_included?, <<~PATTERN
-          (send _var :datetime
-            {(sym {:created_at :updated_at})(str {"created_at" "updated_at"})}
-            ...)
-        PATTERN
-
-        def on_send(node)
-          return unless node.command?(:create_table)
-
-          parent = node.parent
-
-          if create_table_with_block?(parent)
-            add_offense(parent) if parent.body.nil? || !time_columns_included?(parent.body)
-          elsif create_table_with_timestamps_proc?(node)
-            # nothing to do
-          else
-            add_offense(node)
-          end
-        end
-
-        private
-
-        def time_columns_included?(node)
-          timestamps_included?(node) || created_at_or_updated_at_included?(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/date.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/date.rb
deleted file mode 100644
index 15153879259d0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/date.rb
+++ /dev/null
@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for the correct use of Date methods,
-      # such as Date.today, Date.current etc.
-      #
-      # Using `Date.today` is dangerous, because it doesn't know anything about
-      # Rails time zone. You must use `Time.zone.today` instead.
-      #
-      # The cop also reports warnings when you are using `to_time` method,
-      # because it doesn't know about Rails time zone either.
-      #
-      # Two styles are supported for this cop. When `EnforcedStyle` is 'strict'
-      # then the Date methods `today`, `current`, `yesterday`, and `tomorrow`
-      # are prohibited and the usage of both `to_time`
-      # and 'to_time_in_current_zone' are reported as warning.
-      #
-      # When `EnforcedStyle` is `flexible` then only `Date.today` is prohibited.
-      #
-      # And you can set a warning for `to_time` with `AllowToTime: false`.
-      # `AllowToTime` is `true` by default to prevent false positive on `DateTime` object.
-      #
-      # @example EnforcedStyle: flexible (default)
-      #   # bad
-      #   Date.today
-      #
-      #   # good
-      #   Time.zone.today
-      #   Time.zone.today - 1.day
-      #   Date.current
-      #   Date.yesterday
-      #   date.in_time_zone
-      #
-      # @example EnforcedStyle: strict
-      #   # bad
-      #   Date.current
-      #   Date.yesterday
-      #   Date.today
-      #
-      #   # good
-      #   Time.zone.today
-      #   Time.zone.today - 1.day
-      #
-      # @example AllowToTime: true (default)
-      #   # good
-      #   date.to_time
-      #
-      # @example AllowToTime: false
-      #   # bad
-      #   date.to_time
-      class Date < Base
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Do not use `Date.%<method_called>s` without zone. Use ' \
-              '`Time.zone.%<day>s` instead.'
-
-        MSG_SEND = 'Do not use `%<method>s` on Date objects, because they ' \
-                   'know nothing about the time zone in use.'
-
-        RESTRICT_ON_SEND = %i[to_time to_time_in_current_zone].freeze
-
-        BAD_DAYS = %i[today current yesterday tomorrow].freeze
-
-        DEPRECATED_METHODS = [
-          { deprecated: 'to_time_in_current_zone', relevant: 'in_time_zone' }
-        ].freeze
-
-        DEPRECATED_MSG = '`%<deprecated>s` is deprecated. ' \
-                         'Use `%<relevant>s` instead.'
-
-        def on_const(node)
-          mod, klass = *node.children
-          # we should only check core Date class (`Date` or `::Date`)
-          return unless (mod.nil? || mod.cbase_type?) && method_send?(node)
-
-          check_date_node(node.parent) if klass == :Date
-        end
-
-        def on_send(node)
-          return unless node.receiver && bad_methods.include?(node.method_name)
-          return if allow_to_time? && node.method?(:to_time)
-          return if safe_chain?(node) || safe_to_time?(node)
-
-          check_deprecated_methods(node)
-
-          add_offense(node.loc.selector, message: format(MSG_SEND, method: node.method_name))
-        end
-        alias on_csend on_send
-
-        private
-
-        def check_deprecated_methods(node)
-          DEPRECATED_METHODS.each do |method|
-            next unless node.method?(method[:deprecated].to_sym)
-
-            message = format(DEPRECATED_MSG, deprecated: method[:deprecated], relevant: method[:relevant])
-
-            add_offense(node.loc.selector, message: message)
-          end
-        end
-
-        def check_date_node(node)
-          chain = extract_method_chain(node)
-
-          return if (chain & bad_days).empty?
-
-          method_name = (chain & bad_days).join('.')
-
-          day = method_name
-          day = 'today' if method_name == 'current'
-
-          message = format(MSG, method_called: method_name, day: day)
-
-          add_offense(node.loc.selector, message: message)
-        end
-
-        def extract_method_chain(node)
-          [node, *node.each_ancestor(:send)].map(&:method_name)
-        end
-
-        # checks that parent node of send_type
-        # and receiver is the given node
-        def method_send?(node)
-          return false unless node.parent&.send_type?
-
-          node.parent.receiver == node
-        end
-
-        def safe_chain?(node)
-          chain = extract_method_chain(node)
-
-          (chain & bad_methods).empty? || !(chain & good_methods).empty?
-        end
-
-        def safe_to_time?(node)
-          return unless node.method?(:to_time)
-
-          if node.receiver.str_type?
-            zone_regexp = /([+-][\d:]+|\dZ)\z/
-
-            node.receiver.str_content.match(zone_regexp)
-          else
-            node.arguments.one?
-          end
-        end
-
-        def allow_to_time?
-          cop_config.fetch('AllowToTime', true)
-        end
-
-        def good_days
-          style == :strict ? [] : %i[current yesterday tomorrow]
-        end
-
-        def bad_days
-          BAD_DAYS - good_days
-        end
-
-        def bad_methods
-          %i[to_time to_time_in_current_zone]
-        end
-
-        def good_methods
-          style == :strict ? [] : TimeZone::ACCEPTED_METHODS
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/default_scope.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/default_scope.rb
deleted file mode 100644
index 3bbd88d009723..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/default_scope.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Looks for uses of `default_scope`.
-      #
-      # @example
-      #   # bad
-      #   default_scope -> { where(hidden: false) }
-      #
-      #   # good
-      #   scope :published, -> { where(hidden: false) }
-      #
-      #   # bad
-      #   def self.default_scope
-      #     where(hidden: false)
-      #   end
-      #
-      #   # good
-      #   def self.published
-      #     where(hidden: false)
-      #   end
-      #
-      class DefaultScope < Base
-        MSG = 'Avoid use of `default_scope`. It is better to use explicitly named scopes.'
-        RESTRICT_ON_SEND = %i[default_scope].freeze
-
-        def_node_matcher :method_call?, <<~PATTERN
-          (send nil? :default_scope ...)
-        PATTERN
-
-        def_node_matcher :class_method_definition?, <<~PATTERN
-          (defs _ :default_scope args ...)
-        PATTERN
-
-        def_node_matcher :eigenclass_method_definition?, <<~PATTERN
-          (sclass (self) $(def :default_scope args ...))
-        PATTERN
-
-        def on_send(node)
-          return unless method_call?(node)
-
-          add_offense(node.loc.selector)
-        end
-
-        def on_defs(node)
-          return unless class_method_definition?(node)
-
-          add_offense(node.loc.name)
-        end
-
-        def on_sclass(node)
-          eigenclass_method_definition?(node) do |default_scope|
-            add_offense(default_scope.loc.name)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/delegate.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/delegate.rb
deleted file mode 100644
index 7bc8f27c08f7f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/delegate.rb
+++ /dev/null
@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Looks for delegations that could have been created
-      # automatically with the `delegate` method.
-      #
-      # Safe navigation `&.` is ignored because Rails' `allow_nil`
-      # option checks not just for nil but also delegates if nil
-      # responds to the delegated method.
-      #
-      # The `EnforceForPrefixed` option (defaulted to `true`) means that
-      # using the target object as a prefix of the method name
-      # without using the `delegate` method will be a violation.
-      # When set to `false`, this case is legal.
-      #
-      # @example
-      #   # bad
-      #   def bar
-      #     foo.bar
-      #   end
-      #
-      #   # good
-      #   delegate :bar, to: :foo
-      #
-      #   # good
-      #   def bar
-      #     foo&.bar
-      #   end
-      #
-      #   # good
-      #   private
-      #   def bar
-      #     foo.bar
-      #   end
-      #
-      # @example EnforceForPrefixed: true (default)
-      #   # bad
-      #   def foo_bar
-      #     foo.bar
-      #   end
-      #
-      #   # good
-      #   delegate :bar, to: :foo, prefix: true
-      #
-      # @example EnforceForPrefixed: false
-      #   # good
-      #   def foo_bar
-      #     foo.bar
-      #   end
-      #
-      #   # good
-      #   delegate :bar, to: :foo, prefix: true
-      class Delegate < Base
-        extend AutoCorrector
-        include VisibilityHelp
-
-        MSG = 'Use `delegate` to define delegations.'
-
-        def_node_matcher :delegate?, <<~PATTERN
-          (def _method_name _args
-            (send (send nil? _) _ ...))
-        PATTERN
-
-        def on_def(node)
-          return unless trivial_delegate?(node)
-          return if private_or_protected_delegation(node)
-
-          register_offense(node)
-        end
-
-        private
-
-        def register_offense(node)
-          add_offense(node.loc.keyword) do |corrector|
-            delegation = ["delegate :#{node.body.method_name}", "to: :#{node.body.receiver.method_name}"]
-            delegation << ['prefix: true'] if node.method?(prefixed_method_name(node.body))
-
-            corrector.replace(node.source_range, delegation.join(', '))
-          end
-        end
-
-        def trivial_delegate?(def_node)
-          delegate?(def_node) &&
-            method_name_matches?(def_node.method_name, def_node.body) &&
-            arguments_match?(def_node.arguments, def_node.body)
-        end
-
-        def arguments_match?(arg_array, body)
-          argument_array = body.arguments
-
-          return false if arg_array.size != argument_array.size
-
-          arg_array.zip(argument_array).all? do |arg, argument|
-            arg.arg_type? &&
-              argument.lvar_type? &&
-              arg.children == argument.children
-          end
-        end
-
-        def method_name_matches?(method_name, body)
-          method_name == body.method_name ||
-            (include_prefix_case? && method_name == prefixed_method_name(body))
-        end
-
-        def include_prefix_case?
-          cop_config['EnforceForPrefixed']
-        end
-
-        def prefixed_method_name(body)
-          [body.receiver.method_name, body.method_name].join('_').to_sym
-        end
-
-        def private_or_protected_delegation(node)
-          private_or_protected_inline(node) || node_visibility(node) != :public
-        end
-
-        def private_or_protected_inline(node)
-          processed_source[node.first_line - 1].strip.match?(/\A(private )|(protected )/)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/delegate_allow_blank.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/delegate_allow_blank.rb
deleted file mode 100644
index a3eb325a3cf75..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/delegate_allow_blank.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Looks for delegations that pass :allow_blank as an option
-      # instead of :allow_nil. :allow_blank is not a valid option to pass
-      # to ActiveSupport#delegate.
-      #
-      # @example
-      #   # bad
-      #   delegate :foo, to: :bar, allow_blank: true
-      #
-      #   # good
-      #   delegate :foo, to: :bar, allow_nil: true
-      class DelegateAllowBlank < Base
-        extend AutoCorrector
-
-        MSG = '`allow_blank` is not a valid option, use `allow_nil`.'
-        RESTRICT_ON_SEND = %i[delegate].freeze
-
-        def_node_matcher :allow_blank_option, <<~PATTERN
-          (send nil? :delegate _ (hash <$(pair (sym :allow_blank) true) ...>))
-        PATTERN
-
-        def on_send(node)
-          return unless (offending_node = allow_blank_option(node))
-
-          add_offense(offending_node) do |corrector|
-            corrector.replace(offending_node.key.source_range, 'allow_nil')
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/deprecated_active_model_errors_methods.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/deprecated_active_model_errors_methods.rb
deleted file mode 100644
index e2c9d79e93478..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/deprecated_active_model_errors_methods.rb
+++ /dev/null
@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks direct manipulation of ActiveModel#errors as hash.
-      # These operations are deprecated in Rails 6.1 and will not work in Rails 7.
-      #
-      # @safety
-      #   This cop is unsafe because it can report `errors` manipulation on non-ActiveModel,
-      #   which is obviously valid.
-      #   The cop has no way of knowing whether a variable is an ActiveModel or not.
-      #
-      # @example
-      #   # bad
-      #   user.errors[:name] << 'msg'
-      #   user.errors.messages[:name] << 'msg'
-      #
-      #   # good
-      #   user.errors.add(:name, 'msg')
-      #
-      #   # bad
-      #   user.errors[:name].clear
-      #   user.errors.messages[:name].clear
-      #
-      #   # good
-      #   user.errors.delete(:name)
-      #
-      #   # bad
-      #   user.errors.keys.include?(:attr)
-      #
-      #   # good
-      #   user.errors.attribute_names.include?(:attr)
-      #
-      class DeprecatedActiveModelErrorsMethods < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Avoid manipulating ActiveModel errors as hash directly.'
-        AUTOCORECTABLE_METHODS = %i[<< clear keys].freeze
-
-        MANIPULATIVE_METHODS = Set[
-          *%i[
-            << append clear collect! compact! concat
-            delete delete_at delete_if drop drop_while fill filter! keep_if
-            flatten! insert map! pop prepend push reject! replace reverse!
-            rotate! select! shift shuffle! slice! sort! sort_by! uniq! unshift
-          ]
-        ].freeze
-
-        def_node_matcher :receiver_matcher_outside_model, '{send ivar lvar}'
-        def_node_matcher :receiver_matcher_inside_model, '{nil? send ivar lvar}'
-
-        def_node_matcher :any_manipulation?, <<~PATTERN
-          {
-            #root_manipulation?
-            #root_assignment?
-            #errors_keys?
-            #messages_details_manipulation?
-            #messages_details_assignment?
-          }
-        PATTERN
-
-        def_node_matcher :root_manipulation?, <<~PATTERN
-          (send
-            (send
-              (send #receiver_matcher :errors) :[] ...)
-            MANIPULATIVE_METHODS
-            ...
-          )
-        PATTERN
-
-        def_node_matcher :root_assignment?, <<~PATTERN
-          (send
-            (send #receiver_matcher :errors)
-            :[]=
-            ...)
-        PATTERN
-
-        def_node_matcher :errors_keys?, <<~PATTERN
-          (send
-            (send #receiver_matcher :errors)
-            :keys)
-        PATTERN
-
-        def_node_matcher :messages_details_manipulation?, <<~PATTERN
-          (send
-            (send
-              (send
-                (send #receiver_matcher :errors)
-                {:messages :details})
-                :[]
-                ...)
-              MANIPULATIVE_METHODS
-            ...)
-        PATTERN
-
-        def_node_matcher :messages_details_assignment?, <<~PATTERN
-          (send
-            (send
-              (send #receiver_matcher :errors)
-              {:messages :details})
-            :[]=
-            ...)
-        PATTERN
-
-        def on_send(node)
-          any_manipulation?(node) do
-            next if node.method?(:keys) && target_rails_version <= 6.0
-
-            add_offense(node) do |corrector|
-              next unless AUTOCORECTABLE_METHODS.include?(node.method_name)
-
-              autocorrect(corrector, node)
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          receiver = node.receiver
-
-          if receiver.receiver.send_type? && receiver.receiver.method?(:messages)
-            corrector.remove(receiver.receiver.loc.dot)
-            corrector.remove(receiver.receiver.loc.selector)
-          end
-
-          range = offense_range(node, receiver)
-          replacement = replacement(node, receiver)
-
-          corrector.replace(range, replacement)
-        end
-
-        def offense_range(node, receiver)
-          range_between(receiver.receiver.source_range.end_pos, node.source_range.end_pos)
-        end
-
-        def replacement(node, receiver)
-          return '.errors.attribute_names' if node.method?(:keys)
-
-          key = receiver.first_argument.source
-
-          case node.method_name
-          when :<<
-            value = node.first_argument.source
-
-            ".add(#{key}, #{value})"
-          when :clear
-            ".delete(#{key})"
-          end
-        end
-
-        def receiver_matcher(node)
-          model_file? ? receiver_matcher_inside_model(node) : receiver_matcher_outside_model(node)
-        end
-
-        def model_file?
-          processed_source.buffer.name.include?('/models/')
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/dot_separated_keys.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/dot_separated_keys.rb
deleted file mode 100644
index 29d9ece7b9a27..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/dot_separated_keys.rb
+++ /dev/null
@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces the use of dot-separated locale keys instead of specifying the `:scope` option
-      # with an array or a single symbol in `I18n` translation methods.
-      # Dot-separated notation is easier to read and trace the hierarchy.
-      #
-      # @example
-      #   # bad
-      #   I18n.t :record_invalid, scope: [:activerecord, :errors, :messages]
-      #   I18n.t :title, scope: :invitation
-      #
-      #   # good
-      #   I18n.t 'activerecord.errors.messages.record_invalid'
-      #   I18n.t :record_invalid, scope: 'activerecord.errors.messages'
-      #
-      class DotSeparatedKeys < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use the dot-separated keys instead of specifying the `:scope` option.'
-        TRANSLATE_METHODS = %i[translate t].freeze
-
-        def_node_matcher :translate_with_scope?, <<~PATTERN
-          (send {nil? (const nil? :I18n)} {:translate :t} ${sym_type? str_type?}
-            (hash <$(pair (sym :scope) ${array_type? sym_type?}) ...>)
-          )
-        PATTERN
-
-        def on_send(node)
-          return unless TRANSLATE_METHODS.include?(node.method_name)
-
-          translate_with_scope?(node) do |key_node, scope_node|
-            return unless should_convert_scope?(scope_node)
-
-            add_offense(scope_node) do |corrector|
-              # Eat the comma on the left.
-              range = range_with_surrounding_space(range: scope_node.source_range, side: :left)
-              range = range_with_surrounding_comma(range, :left)
-              corrector.remove(range)
-
-              corrector.replace(key_node, new_key(key_node, scope_node))
-            end
-          end
-        end
-
-        private
-
-        def should_convert_scope?(scope_node)
-          scopes(scope_node).all?(&:basic_literal?)
-        end
-
-        def new_key(key_node, scope_node)
-          "'#{scopes(scope_node).map(&:value).join('.')}.#{key_node.value}'".squeeze('.')
-        end
-
-        def scopes(scope_node)
-          value = scope_node.value
-
-          if value.array_type?
-            value.values
-          else
-            [value]
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/duplicate_association.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/duplicate_association.rb
deleted file mode 100644
index 6c7b972bfbb93..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/duplicate_association.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Looks for associations that have been defined multiple times in the same file.
-      #
-      # When an association is defined multiple times on a model, Active Record overrides the
-      # previously defined association with the new one. Because of this, this cop's autocorrection
-      # simply keeps the last of any duplicates and discards the rest.
-      #
-      # @example
-      #
-      #   # bad
-      #   belongs_to :foo
-      #   belongs_to :bar
-      #   has_one :foo
-      #
-      #   # good
-      #   belongs_to :bar
-      #   has_one :foo
-      #
-      class DuplicateAssociation < Base
-        include RangeHelp
-        extend AutoCorrector
-        include ClassSendNodeHelper
-
-        MSG = "Association `%<name>s` is defined multiple times. Don't repeat associations."
-
-        def_node_matcher :association, <<~PATTERN
-          (send nil? {:belongs_to :has_one :has_many :has_and_belongs_to_many} ({sym str} $_) ...)
-        PATTERN
-
-        def on_class(class_node)
-          offenses(class_node).each do |name, nodes|
-            nodes.each do |node|
-              add_offense(node, message: format(MSG, name: name)) do |corrector|
-                next if same_line?(nodes.last, node)
-
-                corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
-              end
-            end
-          end
-        end
-
-        private
-
-        def offenses(class_node)
-          class_send_nodes(class_node).select { |node| association(node) }
-                                      .group_by { |node| association(node).to_sym }
-                                      .select { |_, nodes| nodes.length > 1 }
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/duplicate_scope.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/duplicate_scope.rb
deleted file mode 100644
index e5c2e0fdacb2d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/duplicate_scope.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for multiple scopes in a model that have the same `where` clause. This
-      # often means you copy/pasted a scope, updated the name, and forgot to change the condition.
-      #
-      # @example
-      #
-      #   # bad
-      #   scope :visible, -> { where(visible: true) }
-      #   scope :hidden, -> { where(visible: true) }
-      #
-      #   # good
-      #   scope :visible, -> { where(visible: true) }
-      #   scope :hidden, -> { where(visible: false) }
-      #
-      class DuplicateScope < Base
-        include ClassSendNodeHelper
-
-        MSG = 'Multiple scopes share this same where clause.'
-
-        def_node_matcher :scope, <<~PATTERN
-          (send nil? :scope _ $...)
-        PATTERN
-
-        def on_class(class_node)
-          offenses(class_node).each do |node|
-            add_offense(node)
-          end
-        end
-
-        private
-
-        def offenses(class_node)
-          class_send_nodes(class_node).select { |node| scope(node) }
-                                      .group_by { |node| scope(node) }
-                                      .select { |_, nodes| nodes.length > 1 }
-                                      .values
-                                      .flatten
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/duration_arithmetic.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/duration_arithmetic.rb
deleted file mode 100644
index 47f2ab0b73b2a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/duration_arithmetic.rb
+++ /dev/null
@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks if a duration is added to or subtracted from `Time.current`.
-      #
-      # @example
-      #   # bad
-      #   Time.current - 1.minute
-      #   Time.current + 2.days
-      #
-      #   # good - using relative would make it harder to express and read
-      #   Date.yesterday + 3.days
-      #   created_at - 1.minute
-      #   3.days - 1.hour
-      #
-      #   # good
-      #   1.minute.ago
-      #   2.days.from_now
-      class DurationArithmetic < Base
-        extend AutoCorrector
-
-        MSG = 'Do not add or subtract duration.'
-
-        RESTRICT_ON_SEND = %i[+ -].freeze
-
-        DURATIONS = Set[:second, :seconds, :minute, :minutes, :hour, :hours,
-                        :day, :days, :week, :weeks, :fortnight, :fortnights,
-                        :month, :months, :year, :years]
-
-        # @!method duration_arithmetic_argument?(node)
-        #   Match duration subtraction or addition with current time.
-        #
-        #   @example source that matches
-        #     Time.current - 1.hour
-        #
-        #   @example source that matches
-        #     ::Time.zone.now + 1.hour
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @yield operator and duration
-        def_node_matcher :duration_arithmetic_argument?, <<~PATTERN
-          (send #time_current? ${ :+ :- } $#duration?)
-        PATTERN
-
-        # @!method duration?(node)
-        #   Match a literal Duration
-        #
-        #   @example source that matches
-        #     1.hour
-        #
-        #   @example source that matches
-        #     9.5.weeks
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @return [Boolean] true if matches
-        def_node_matcher :duration?, '(send { int float (send nil _) } DURATIONS)'
-
-        # @!method time_current?(node)
-        #   Match Time.current
-        #
-        #   @example source that matches
-        #     Time.current
-        #
-        #   @example source that matches
-        #     ::Time.zone.now
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @return [Boolean] true if matches
-        def_node_matcher :time_current?, <<~PATTERN
-          {
-            (send (const _ :Time) :current)
-            (send (send (const _ :Time) :zone) :now)
-          }
-        PATTERN
-
-        def on_send(node)
-          duration_arithmetic_argument?(node) do |*operation|
-            add_offense(node) do |corrector|
-              corrector.replace(node.source_range, corrected_source(*operation))
-            end
-          end
-        end
-
-        private
-
-        def corrected_source(operator, duration)
-          if operator == :-
-            "#{duration.source}.ago"
-          else
-            "#{duration.source}.from_now"
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/dynamic_find_by.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/dynamic_find_by.rb
deleted file mode 100644
index b3a87503535c5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/dynamic_find_by.rb
+++ /dev/null
@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks dynamic `find_by_*` methods.
-      # Use `find_by` instead of dynamic method.
-      # See. https://rails.rubystyle.guide#find_by
-      #
-      # @safety
-      #   It is certainly unsafe when not configured properly, i.e. user-defined `find_by_xxx`
-      #   method is not added to cop's `AllowedMethods`.
-      #
-      # @example
-      #   # bad
-      #   User.find_by_name(name)
-      #   User.find_by_name_and_email(name)
-      #   User.find_by_email!(name)
-      #
-      #   # good
-      #   User.find_by(name: name)
-      #   User.find_by(name: name, email: email)
-      #   User.find_by!(email: email)
-      #
-      # @example AllowedMethods: find_by_sql
-      #   # bad
-      #   User.find_by_query(users_query)
-      #
-      #   # good
-      #   User.find_by_sql(users_sql)
-      #
-      # @example AllowedReceivers: Gem::Specification
-      #   # bad
-      #   Specification.find_by_name('backend').gem_dir
-      #
-      #   # good
-      #   Gem::Specification.find_by_name('backend').gem_dir
-      class DynamicFindBy < Base
-        include ActiveRecordHelper
-        extend AutoCorrector
-
-        MSG = 'Use `%<static_name>s` instead of dynamic `%<method>s`.'
-        METHOD_PATTERN = /^find_by_(.+?)(!)?$/.freeze
-        IGNORED_ARGUMENT_TYPES = %i[hash splat].freeze
-
-        def on_send(node)
-          return if (node.receiver.nil? && !inherit_active_record_base?(node)) || allowed_invocation?(node)
-
-          method_name = node.method_name
-          static_name = static_method_name(method_name)
-          return unless static_name
-          return if node.arguments.any? { |argument| IGNORED_ARGUMENT_TYPES.include?(argument.type) }
-
-          message = format(MSG, static_name: static_name, method: method_name)
-          add_offense(node, message: message) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-        alias on_csend on_send
-
-        private
-
-        def autocorrect(corrector, node)
-          keywords = column_keywords(node.method_name)
-
-          return if keywords.size != node.arguments.size
-
-          autocorrect_method_name(corrector, node)
-          autocorrect_argument_keywords(corrector, node, keywords)
-        end
-
-        def allowed_invocation?(node)
-          allowed_method?(node) || allowed_receiver?(node) ||
-            whitelisted?(node)
-        end
-
-        def allowed_method?(node)
-          return unless cop_config['AllowedMethods']
-
-          cop_config['AllowedMethods'].include?(node.method_name.to_s)
-        end
-
-        def allowed_receiver?(node)
-          return unless cop_config['AllowedReceivers'] && node.receiver
-
-          cop_config['AllowedReceivers'].include?(node.receiver.source)
-        end
-
-        # config option `WhiteList` will be deprecated soon
-        def whitelisted?(node)
-          whitelist_config = cop_config['Whitelist']
-          return unless whitelist_config
-
-          whitelist_config.include?(node.method_name.to_s)
-        end
-
-        def autocorrect_method_name(corrector, node)
-          corrector.replace(node.loc.selector,
-                            static_method_name(node.method_name.to_s))
-        end
-
-        def autocorrect_argument_keywords(corrector, node, keywords)
-          keywords.each.with_index do |keyword, idx|
-            corrector.insert_before(node.arguments[idx].loc.expression, keyword)
-          end
-        end
-
-        def column_keywords(method)
-          keyword_string = method.to_s[METHOD_PATTERN, 1]
-          keyword_string.split('_and_').map { |keyword| "#{keyword}: " }
-        end
-
-        # Returns static method name.
-        # If code isn't wrong, returns nil
-        def static_method_name(method_name)
-          match = METHOD_PATTERN.match(method_name)
-          return nil unless match
-
-          match[2] ? 'find_by!' : 'find_by'
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/eager_evaluation_log_message.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/eager_evaluation_log_message.rb
deleted file mode 100644
index 549e2ccdcd1e6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/eager_evaluation_log_message.rb
+++ /dev/null
@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks that blocks are used for interpolated strings passed to
-      # `Rails.logger.debug`.
-      #
-      # By default, Rails production environments use the `:info` log level.
-      # At the `:info` log level, `Rails.logger.debug` statements do not result
-      # in log output. However, Ruby must eagerly evaluate interpolated string
-      # arguments passed as method arguments. Passing a block to
-      # `Rails.logger.debug` prevents costly evaluation of interpolated strings
-      # when no output would be produced anyway.
-      #
-      # @example
-      #   #bad
-      #   Rails.logger.debug "The time is #{Time.zone.now}."
-      #
-      #   #good
-      #   Rails.logger.debug { "The time is #{Time.zone.now}." }
-      #
-      class EagerEvaluationLogMessage < Base
-        extend AutoCorrector
-
-        MSG = 'Pass a block to `Rails.logger.debug`.'
-        RESTRICT_ON_SEND = %i[debug].freeze
-
-        def_node_matcher :interpolated_string_passed_to_debug, <<~PATTERN
-          (send
-            (send
-              (const {cbase nil?} :Rails)
-              :logger
-            )
-            :debug
-            $(dstr ...)
-          )
-        PATTERN
-
-        def on_send(node)
-          return if node.parent&.block_type?
-
-          interpolated_string_passed_to_debug(node) do |arguments|
-            message = format(MSG)
-
-            range = replacement_range(node)
-            replacement = replacement_source(node, arguments)
-
-            add_offense(range, message: message) do |corrector|
-              corrector.replace(range, replacement)
-            end
-          end
-        end
-
-        private
-
-        def replacement_range(node)
-          stop = node.loc.expression.end
-          start = node.loc.selector.end
-
-          if node.parenthesized_call?
-            stop.with(begin_pos: start.begin_pos)
-          else
-            stop.with(begin_pos: start.begin_pos + 1)
-          end
-        end
-
-        def replacement_source(node, arguments)
-          if node.parenthesized_call?
-            " { #{arguments.source} }"
-          else
-            "{ #{arguments.source} }"
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/enum_hash.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/enum_hash.rb
deleted file mode 100644
index 04d4a86d4e7c8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/enum_hash.rb
+++ /dev/null
@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Looks for enums written with array syntax.
-      #
-      # When using array syntax, adding an element in a
-      # position other than the last causes all previous
-      # definitions to shift. Explicitly specifying the
-      # value for each key prevents this from happening.
-      #
-      # @example
-      #   # bad
-      #   enum status: [:active, :archived]
-      #
-      #   # good
-      #   enum status: { active: 0, archived: 1 }
-      #
-      class EnumHash < Base
-        extend AutoCorrector
-
-        MSG = 'Enum defined as an array found in `%<enum>s` enum declaration. Use hash syntax instead.'
-        RESTRICT_ON_SEND = %i[enum].freeze
-
-        def_node_matcher :enum?, <<~PATTERN
-          (send nil? :enum (hash $...))
-        PATTERN
-
-        def_node_matcher :array_pair?, <<~PATTERN
-          (pair $_ $array)
-        PATTERN
-
-        def on_send(node)
-          enum?(node) do |pairs|
-            pairs.each do |pair|
-              key, array = array_pair?(pair)
-              next unless key
-
-              add_offense(array, message: format(MSG, enum: enum_name(key))) do |corrector|
-                hash = array.children.each_with_index.map do |elem, index|
-                  "#{source(elem)} => #{index}"
-                end.join(', ')
-
-                corrector.replace(array.loc.expression, "{#{hash}}")
-              end
-            end
-          end
-        end
-
-        private
-
-        def enum_name(key)
-          case key.type
-          when :sym, :str
-            key.value
-          else
-            key.source
-          end
-        end
-
-        def source(elem)
-          case elem.type
-          when :str
-            elem.value.dump
-          when :sym
-            elem.value.inspect
-          else
-            elem.source
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/enum_uniqueness.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/enum_uniqueness.rb
deleted file mode 100644
index e01ff831f88ea..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/enum_uniqueness.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Looks for duplicate values in enum declarations.
-      #
-      # @example
-      #   # bad
-      #   enum status: { active: 0, archived: 0 }
-      #
-      #   # good
-      #   enum status: { active: 0, archived: 1 }
-      #
-      #   # bad
-      #   enum status: [:active, :archived, :active]
-      #
-      #   # good
-      #   enum status: [:active, :archived]
-      class EnumUniqueness < Base
-        include Duplication
-
-        MSG = 'Duplicate value `%<value>s` found in `%<enum>s` ' \
-              'enum declaration.'
-        RESTRICT_ON_SEND = %i[enum].freeze
-
-        def_node_matcher :enum?, <<~PATTERN
-          (send nil? :enum (hash $...))
-        PATTERN
-
-        def_node_matcher :enum_values, <<~PATTERN
-          (pair $_ ${array hash})
-        PATTERN
-
-        def on_send(node)
-          enum?(node) do |pairs|
-            pairs.each do |pair|
-              enum_values(pair) do |key, args|
-                items = args.values
-
-                next unless duplicates?(items)
-
-                consecutive_duplicates(items).each do |item|
-                  add_offense(item, message: format(
-                    MSG, value: item.source, enum: enum_name(key)
-                  ))
-                end
-              end
-            end
-          end
-        end
-
-        private
-
-        def enum_name(key)
-          case key.type
-          when :sym, :str
-            key.value
-          else
-            key.source
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/environment_comparison.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/environment_comparison.rb
deleted file mode 100644
index c5a25465bf7af..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/environment_comparison.rb
+++ /dev/null
@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks that Rails.env is compared using `.production?`-like
-      # methods instead of equality against a string or symbol.
-      #
-      # @example
-      #   # bad
-      #   Rails.env == 'production'
-      #
-      #   # bad, always returns false
-      #   Rails.env == :test
-      #
-      #   # good
-      #   Rails.env.production?
-      class EnvironmentComparison < Base
-        extend AutoCorrector
-
-        MSG = 'Favor `%<bang>sRails.env.%<env>s?` over `%<source>s`.'
-
-        SYM_MSG = 'Do not compare `Rails.env` with a symbol, it will always evaluate to `false`.'
-
-        RESTRICT_ON_SEND = %i[== !=].freeze
-
-        def_node_matcher :comparing_str_env_with_rails_env_on_lhs?, <<~PATTERN
-          (send
-            (send (const {nil? cbase} :Rails) :env)
-            {:== :!=}
-            $str
-          )
-        PATTERN
-
-        def_node_matcher :comparing_str_env_with_rails_env_on_rhs?, <<~PATTERN
-          (send
-            $str
-            {:== :!=}
-            (send (const {nil? cbase} :Rails) :env)
-          )
-        PATTERN
-
-        def_node_matcher :comparing_sym_env_with_rails_env_on_lhs?, <<~PATTERN
-          (send
-            (send (const {nil? cbase} :Rails) :env)
-            {:== :!=}
-            $sym
-          )
-        PATTERN
-
-        def_node_matcher :comparing_sym_env_with_rails_env_on_rhs?, <<~PATTERN
-          (send
-            $sym
-            {:== :!=}
-            (send (const {nil? cbase} :Rails) :env)
-          )
-        PATTERN
-
-        def_node_matcher :content, <<~PATTERN
-          ({str sym} $_)
-        PATTERN
-
-        def on_send(node)
-          if (env_node = comparing_str_env_with_rails_env_on_lhs?(node) ||
-                         comparing_str_env_with_rails_env_on_rhs?(node))
-            env, = *env_node
-            bang = node.method?(:!=) ? '!' : ''
-            message = format(MSG, bang: bang, env: env, source: node.source)
-
-            add_offense(node, message: message) do |corrector|
-              autocorrect(corrector, node)
-            end
-          end
-
-          return unless comparing_sym_env_with_rails_env_on_lhs?(node) || comparing_sym_env_with_rails_env_on_rhs?(node)
-
-          add_offense(node, message: SYM_MSG) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          replacement = build_predicate_method(node)
-
-          corrector.replace(node.source_range, replacement)
-        end
-
-        def build_predicate_method(node)
-          if rails_env_on_lhs?(node)
-            build_predicate_method_for_rails_env_on_lhs(node)
-          else
-            build_predicate_method_for_rails_env_on_rhs(node)
-          end
-        end
-
-        def rails_env_on_lhs?(node)
-          comparing_str_env_with_rails_env_on_lhs?(node) ||
-            comparing_sym_env_with_rails_env_on_lhs?(node)
-        end
-
-        def build_predicate_method_for_rails_env_on_lhs(node)
-          bang = node.method?(:!=) ? '!' : ''
-
-          "#{bang}#{node.receiver.source}.#{content(node.first_argument)}?"
-        end
-
-        def build_predicate_method_for_rails_env_on_rhs(node)
-          bang = node.method?(:!=) ? '!' : ''
-
-          "#{bang}#{node.first_argument.source}.#{content(node.receiver)}?"
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/environment_variable_access.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/environment_variable_access.rb
deleted file mode 100644
index e3642820c9bf9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/environment_variable_access.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Looks for direct access to environment variables through the
-      # `ENV` variable within the application code. This can lead to runtime
-      # errors due to misconfiguration that could have been discovered at boot
-      # time if the environment variables were loaded as part of initialization
-      # and copied into the application's configuration or secrets. The cop can
-      # be configured to allow either reads or writes if required.
-      #
-      # @example
-      #   # good
-      #   Rails.application.config.foo
-      #   Rails.application.config.x.foo.bar
-      #   Rails.application.secrets.foo
-      #   Rails.application.config.foo = "bar"
-      #
-      # @example AllowReads: false (default)
-      #   # bad
-      #   ENV["FOO"]
-      #   ENV.fetch("FOO")
-      #
-      # @example AllowReads: true
-      #   # good
-      #   ENV["FOO"]
-      #   ENV.fetch("FOO")
-      #
-      # @example AllowWrites: false (default)
-      #   # bad
-      #   ENV["FOO"] = "bar"
-      #
-      # @example AllowWrites: true
-      #   # good
-      #   ENV["FOO"] = "bar"
-      class EnvironmentVariableAccess < Base
-        READ_MSG = 'Do not read from `ENV` directly post initialization.'
-        WRITE_MSG = 'Do not write to `ENV` directly post initialization.'
-
-        def on_const(node)
-          add_offense(node, message: READ_MSG) if env_read?(node) && !allow_reads?
-          add_offense(node, message: WRITE_MSG) if env_write?(node) && !allow_writes?
-        end
-
-        def_node_search :env_read?, <<~PATTERN
-          ^(send (const {cbase nil?} :ENV) !:[]= ...)
-        PATTERN
-
-        def_node_search :env_write?, <<~PATTERN
-          {^(indexasgn (const {cbase nil?} :ENV) ...)
-           ^(send (const {cbase nil?} :ENV) :[]= ...)}
-        PATTERN
-
-        private
-
-        def allow_reads?
-          cop_config['AllowReads'] == true
-        end
-
-        def allow_writes?
-          cop_config['AllowWrites'] == true
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/exit.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/exit.rb
deleted file mode 100644
index 9bd3cd4ab934d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/exit.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces that `exit` calls are not used within a rails app.
-      # Valid options are instead to raise an error, break, return, or some
-      # other form of stopping execution of current request.
-      #
-      # There are two obvious cases where `exit` is particularly harmful:
-      #
-      # * Usage in library code for your application. Even though Rails will
-      # rescue from a `SystemExit` and continue on, unit testing that library
-      # code will result in specs exiting (potentially silently if `exit(0)`
-      # is used.)
-      # * Usage in application code outside of the web process could result in
-      # the program exiting, which could result in the code failing to run and
-      # do its job.
-      #
-      # @example
-      #   # bad
-      #   exit(0)
-      #
-      #   # good
-      #   raise 'a bad error has happened'
-      class Exit < Base
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Do not use `exit` in Rails applications.'
-        RESTRICT_ON_SEND = %i[exit exit!].freeze
-        EXPLICIT_RECEIVERS = %i[Kernel Process].freeze
-
-        def on_send(node)
-          add_offense(node.loc.selector) if offending_node?(node)
-        end
-
-        private
-
-        def offending_node?(node)
-          right_argument_count?(node.arguments) && right_receiver?(node.receiver)
-        end
-
-        # More than 1 argument likely means it is a different
-        # `exit` implementation than the one we are preventing.
-        def right_argument_count?(arg_nodes)
-          arg_nodes.size <= 1
-        end
-
-        # Only register if exit is being called explicitly on `Kernel`,
-        # `Process`, or if receiver node is nil for plain `exit` calls.
-        def right_receiver?(receiver_node)
-          return true unless receiver_node
-
-          _a, receiver_node_class, _c = *receiver_node
-
-          EXPLICIT_RECEIVERS.include?(receiver_node_class)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/expanded_date_range.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/expanded_date_range.rb
deleted file mode 100644
index 073d41abe9f13..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/expanded_date_range.rb
+++ /dev/null
@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for expanded date range. It only compatible `..` range is targeted.
-      # Incompatible `...` range is ignored.
-      #
-      # @example
-      #   # bad
-      #   date.beginning_of_day..date.end_of_day
-      #   date.beginning_of_week..date.end_of_week
-      #   date.beginning_of_month..date.end_of_month
-      #   date.beginning_of_quarter..date.end_of_quarter
-      #   date.beginning_of_year..date.end_of_year
-      #
-      #   # good
-      #   date.all_day
-      #   date.all_week
-      #   date.all_month
-      #   date.all_quarter
-      #   date.all_year
-      #
-      class ExpandedDateRange < Base
-        extend AutoCorrector
-        extend TargetRailsVersion
-
-        MSG = 'Use `%<preferred_method>s` instead.'
-
-        minimum_target_rails_version 5.1
-
-        PREFERRED_METHODS = {
-          beginning_of_day: 'all_day',
-          beginning_of_week: 'all_week',
-          beginning_of_month: 'all_month',
-          beginning_of_quarter: 'all_quarter',
-          beginning_of_year: 'all_year'
-        }.freeze
-
-        MAPPED_DATE_RANGE_METHODS = {
-          beginning_of_day: :end_of_day,
-          beginning_of_week: :end_of_week,
-          beginning_of_month: :end_of_month,
-          beginning_of_quarter: :end_of_quarter,
-          beginning_of_year: :end_of_year
-        }.freeze
-
-        def on_irange(node)
-          begin_node = node.begin
-          end_node = node.end
-          return if allow?(begin_node, end_node)
-
-          preferred_method = preferred_method(begin_node)
-          if begin_node.method?(:beginning_of_week) && begin_node.arguments.one?
-            return unless same_argument?(begin_node, end_node)
-
-            preferred_method << "(#{begin_node.first_argument.source})"
-          elsif any_arguments?(begin_node, end_node)
-            return
-          end
-
-          register_offense(node, preferred_method)
-        end
-
-        private
-
-        def allow?(begin_node, end_node)
-          return true unless (begin_source = receiver_source(begin_node))
-          return true unless (end_source = receiver_source(end_node))
-
-          begin_source != end_source || MAPPED_DATE_RANGE_METHODS[begin_node.method_name] != end_node.method_name
-        end
-
-        def receiver_source(node)
-          return if !node&.send_type? || node.receiver.nil?
-
-          node.receiver.source
-        end
-
-        def same_argument?(begin_node, end_node)
-          begin_node.first_argument.source == end_node.first_argument.source
-        end
-
-        def preferred_method(begin_node)
-          +"#{begin_node.receiver.source}.#{PREFERRED_METHODS[begin_node.method_name]}"
-        end
-
-        def any_arguments?(begin_node, end_node)
-          begin_node.arguments.any? || end_node.arguments.any?
-        end
-
-        def register_offense(node, preferred_method)
-          message = format(MSG, preferred_method: preferred_method)
-
-          add_offense(node, message: message) do |corrector|
-            corrector.replace(node, preferred_method)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/file_path.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/file_path.rb
deleted file mode 100644
index bde2094342925..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/file_path.rb
+++ /dev/null
@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Identifies usages of file path joining process
-      # to use `Rails.root.join` clause. It is used to add uniformity when
-      # joining paths.
-      #
-      # @example EnforcedStyle: slashes (default)
-      #   # bad
-      #   Rails.root.join('app', 'models', 'goober')
-      #   File.join(Rails.root, 'app/models/goober')
-      #   "#{Rails.root}/app/models/goober"
-      #
-      #   # good
-      #   Rails.root.join('app/models/goober')
-      #
-      # @example EnforcedStyle: arguments
-      #   # bad
-      #   Rails.root.join('app/models/goober')
-      #   File.join(Rails.root, 'app/models/goober')
-      #   "#{Rails.root}/app/models/goober"
-      #
-      #   # good
-      #   Rails.root.join('app', 'models', 'goober')
-      #
-      class FilePath < Base
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-
-        MSG_SLASHES = 'Prefer `Rails.root.join(\'path/to\')`.'
-        MSG_ARGUMENTS = 'Prefer `Rails.root.join(\'path\', \'to\')`.'
-        RESTRICT_ON_SEND = %i[join].freeze
-
-        def_node_matcher :file_join_nodes?, <<~PATTERN
-          (send (const nil? :File) :join ...)
-        PATTERN
-
-        def_node_search :rails_root_nodes?, <<~PATTERN
-          (send (const nil? :Rails) :root)
-        PATTERN
-
-        def_node_matcher :rails_root_join_nodes?, <<~PATTERN
-          (send (send (const nil? :Rails) :root) :join ...)
-        PATTERN
-
-        def on_dstr(node)
-          return unless rails_root_nodes?(node)
-          return unless node.children.last.str_type?
-
-          last_child_source = node.children.last.source
-          return unless last_child_source.start_with?('.') ||
-                        last_child_source.include?(File::SEPARATOR)
-          return if last_child_source.start_with?(':')
-
-          register_offense(node)
-        end
-
-        def on_send(node)
-          check_for_file_join_with_rails_root(node)
-          check_for_rails_root_join_with_slash_separated_path(node)
-          check_for_rails_root_join_with_string_arguments(node)
-        end
-
-        private
-
-        def check_for_file_join_with_rails_root(node)
-          return unless file_join_nodes?(node)
-          return unless node.arguments.any? { |e| rails_root_nodes?(e) }
-
-          register_offense(node)
-        end
-
-        def check_for_rails_root_join_with_string_arguments(node)
-          return unless style == :slashes
-          return unless rails_root_nodes?(node)
-          return unless rails_root_join_nodes?(node)
-          return unless node.arguments.size > 1
-          return unless node.arguments.all?(&:str_type?)
-
-          register_offense(node)
-        end
-
-        def check_for_rails_root_join_with_slash_separated_path(node)
-          return unless style == :arguments
-          return unless rails_root_nodes?(node)
-          return unless rails_root_join_nodes?(node)
-          return unless node.arguments.any? { |arg| string_with_slash?(arg) }
-
-          register_offense(node)
-        end
-
-        def string_with_slash?(node)
-          node.str_type? && node.source.include?('/')
-        end
-
-        def register_offense(node)
-          line_range = node.loc.column...node.loc.last_column
-          source_range = source_range(processed_source.buffer, node.first_line,
-                                      line_range)
-          add_offense(source_range)
-        end
-
-        def message(_range)
-          format(style == :arguments ? MSG_ARGUMENTS : MSG_SLASHES)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/find_by.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/find_by.rb
deleted file mode 100644
index 74da0840f326c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/find_by.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Identifies usages of `where.take` and change them to use `find_by` instead.
-      #
-      # And `where(...).first` can return different results from `find_by`.
-      # (They order records differently, so the "first" record can be different.)
-      #
-      # If you also want to detect `where.first`, you can set `IgnoreWhereFirst` to false.
-      #
-      # @example
-      #   # bad
-      #   User.where(name: 'Bruce').take
-      #
-      #   # good
-      #   User.find_by(name: 'Bruce')
-      #
-      # @example IgnoreWhereFirst: true (default)
-      #   # good
-      #   User.where(name: 'Bruce').first
-      #
-      # @example IgnoreWhereFirst: false
-      #   # bad
-      #   User.where(name: 'Bruce').first
-      class FindBy < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `find_by` instead of `where.%<method>s`.'
-        RESTRICT_ON_SEND = %i[first take].freeze
-
-        def on_send(node)
-          return unless node.arguments.empty? && where_method?(node.receiver)
-          return if ignore_where_first? && node.method?(:first)
-
-          range = offense_range(node)
-
-          add_offense(range, message: format(MSG, method: node.method_name)) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-        alias on_csend on_send
-
-        private
-
-        def where_method?(receiver)
-          return false unless receiver
-
-          receiver.respond_to?(:method?) && receiver.method?(:where)
-        end
-
-        def offense_range(node)
-          range_between(node.receiver.loc.selector.begin_pos, node.loc.selector.end_pos)
-        end
-
-        def autocorrect(corrector, node)
-          return if node.method?(:first)
-
-          where_loc = node.receiver.loc.selector
-          first_loc = range_between(node.loc.dot.begin_pos, node.loc.selector.end_pos)
-
-          corrector.replace(where_loc, 'find_by')
-          corrector.replace(first_loc, '')
-        end
-
-        def ignore_where_first?
-          cop_config.fetch('IgnoreWhereFirst', true)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/find_by_id.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/find_by_id.rb
deleted file mode 100644
index 415e45e25b8f4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/find_by_id.rb
+++ /dev/null
@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces that `ActiveRecord#find` is used instead of
-      # `where.take!`, `find_by!`, and `find_by_id!` to retrieve a single record
-      # by primary key when you expect it to be found.
-      #
-      # @example
-      #   # bad
-      #   User.where(id: id).take!
-      #   User.find_by_id!(id)
-      #   User.find_by!(id: id)
-      #
-      #   # good
-      #   User.find(id)
-      #
-      class FindById < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
-        RESTRICT_ON_SEND = %i[take! find_by_id! find_by!].freeze
-
-        def_node_matcher :where_take?, <<~PATTERN
-          (send
-            $(send _ :where
-              (hash
-                (pair (sym :id) $_))) :take!)
-        PATTERN
-
-        def_node_matcher :find_by?, <<~PATTERN
-          {
-            (send _ :find_by_id! $_)
-            (send _ :find_by! (hash (pair (sym :id) $_)))
-          }
-        PATTERN
-
-        def on_send(node)
-          where_take?(node) do |where, id_value|
-            range = where_take_offense_range(node, where)
-            bad_method = build_where_take_bad_method(id_value)
-
-            register_offense(range, id_value, bad_method)
-          end
-
-          find_by?(node) do |id_value|
-            range = find_by_offense_range(node)
-            bad_method = build_find_by_bad_method(node, id_value)
-
-            register_offense(range, id_value, bad_method)
-          end
-        end
-
-        private
-
-        def register_offense(range, id_value, bad_method)
-          good_method = build_good_method(id_value)
-          message = format(MSG, good_method: good_method, bad_method: bad_method)
-
-          add_offense(range, message: message) do |corrector|
-            corrector.replace(range, good_method)
-          end
-        end
-
-        def where_take_offense_range(node, where)
-          range_between(where.loc.selector.begin_pos, node.loc.expression.end_pos)
-        end
-
-        def find_by_offense_range(node)
-          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
-        end
-
-        def build_good_method(id_value)
-          "find(#{id_value.source})"
-        end
-
-        def build_where_take_bad_method(id_value)
-          "where(id: #{id_value.source}).take!"
-        end
-
-        def build_find_by_bad_method(node, id_value)
-          case node.method_name
-          when :find_by_id!
-            "find_by_id!(#{id_value.source})"
-          when :find_by!
-            "find_by!(id: #{id_value.source})"
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/find_each.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/find_each.rb
deleted file mode 100644
index 73eb23fc452c3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/find_each.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Identifies usages of `all.each` and
-      # change them to use `all.find_each` instead.
-      #
-      # @example
-      #   # bad
-      #   User.all.each
-      #
-      #   # good
-      #   User.all.find_each
-      #
-      # @example IgnoredMethods: ['order']
-      #   # good
-      #   User.order(:foo).each
-      class FindEach < Base
-        include ActiveRecordHelper
-        extend AutoCorrector
-
-        MSG = 'Use `find_each` instead of `each`.'
-        RESTRICT_ON_SEND = %i[each].freeze
-
-        SCOPE_METHODS = %i[
-          all eager_load includes joins left_joins left_outer_joins not preload
-          references unscoped where
-        ].freeze
-
-        def on_send(node)
-          return unless node.receiver&.send_type?
-          return unless SCOPE_METHODS.include?(node.receiver.method_name)
-          return if node.receiver.receiver.nil? && !inherit_active_record_base?(node)
-          return if ignored?(node)
-
-          range = node.loc.selector
-          add_offense(range) do |corrector|
-            corrector.replace(range, 'find_each')
-          end
-        end
-
-        private
-
-        def ignored?(node)
-          return true if active_model_error_where?(node.receiver)
-
-          method_chain = node.each_node(:send).map(&:method_name)
-
-          (cop_config['IgnoredMethods'].map(&:to_sym) & method_chain).any?
-        end
-
-        def active_model_error_where?(node)
-          node.method?(:where) && active_model_error?(node.receiver)
-        end
-
-        def active_model_error?(node)
-          return false if node.nil?
-
-          node.send_type? && node.method?(:errors)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/has_and_belongs_to_many.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/has_and_belongs_to_many.rb
deleted file mode 100644
index cf6ca32c32d14..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/has_and_belongs_to_many.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for the use of the has_and_belongs_to_many macro.
-      #
-      # @example
-      #   # bad
-      #   # has_and_belongs_to_many :ingredients
-      #
-      #   # good
-      #   # has_many :ingredients, through: :recipe_ingredients
-      class HasAndBelongsToMany < Base
-        MSG = 'Prefer `has_many :through` to `has_and_belongs_to_many`.'
-        RESTRICT_ON_SEND = %i[has_and_belongs_to_many].freeze
-
-        def on_send(node)
-          return unless node.command?(:has_and_belongs_to_many)
-
-          add_offense(node.loc.selector)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/has_many_or_has_one_dependent.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/has_many_or_has_one_dependent.rb
deleted file mode 100644
index e8f4e69cc31f2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/has_many_or_has_one_dependent.rb
+++ /dev/null
@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Looks for `has_many` or `has_one` associations that don't
-      # specify a `:dependent` option.
-      #
-      # It doesn't register an offense if `:through` or `dependent: nil`
-      # is specified, or if the model is read-only.
-      #
-      # @example
-      #   # bad
-      #   class User < ActiveRecord::Base
-      #     has_many :comments
-      #     has_one :avatar
-      #   end
-      #
-      #   # good
-      #   class User < ActiveRecord::Base
-      #     has_many :comments, dependent: :restrict_with_exception
-      #     has_one :avatar, dependent: :destroy
-      #     has_many :articles, dependent: nil
-      #     has_many :patients, through: :appointments
-      #   end
-      #
-      #   class User < ActiveRecord::Base
-      #     has_many :comments
-      #     has_one :avatar
-      #
-      #     def readonly?
-      #       true
-      #     end
-      #   end
-      class HasManyOrHasOneDependent < Base
-        MSG = 'Specify a `:dependent` option.'
-        RESTRICT_ON_SEND = %i[has_many has_one].freeze
-
-        def_node_search :active_resource_class?, <<~PATTERN
-          (const (const nil? :ActiveResource) :Base)
-        PATTERN
-
-        def_node_matcher :association_without_options?, <<~PATTERN
-          (send nil? {:has_many :has_one} _)
-        PATTERN
-
-        def_node_matcher :association_with_options?, <<~PATTERN
-          (send nil? {:has_many :has_one} ... (hash $...))
-        PATTERN
-
-        def_node_matcher :dependent_option?, <<~PATTERN
-          (pair (sym :dependent) {!nil (nil)})
-        PATTERN
-
-        def_node_matcher :present_option?, <<~PATTERN
-          (pair (sym :through) !nil)
-        PATTERN
-
-        def_node_matcher :with_options_block, <<~PATTERN
-          (block
-            (send nil? :with_options
-              (hash $...))
-            (args) ...)
-        PATTERN
-
-        def_node_matcher :association_extension_block?, <<~PATTERN
-          (block
-            (send nil? :has_many _)
-            (args) ...)
-        PATTERN
-
-        def_node_matcher :readonly?, <<~PATTERN
-          (def :readonly?
-            (args)
-            (true))
-        PATTERN
-
-        def on_send(node)
-          return if active_resource?(node.parent) || readonly_model?(node)
-          return if !association_without_options?(node) && valid_options?(association_with_options?(node))
-          return if valid_options_in_with_options_block?(node)
-
-          add_offense(node.loc.selector)
-        end
-
-        private
-
-        def readonly_model?(node)
-          return false unless (parent = node.parent)
-
-          parent.each_descendant(:def).any? { |def_node| readonly?(def_node) }
-        end
-
-        def valid_options_in_with_options_block?(node)
-          return true unless node.parent
-
-          n = node.parent.begin_type? || association_extension_block?(node.parent) ? node.parent.parent : node.parent
-
-          contain_valid_options_in_with_options_block?(n)
-        end
-
-        def contain_valid_options_in_with_options_block?(node)
-          if (options = with_options_block(node))
-            return true if valid_options?(options)
-
-            return false unless node.parent
-
-            return true if contain_valid_options_in_with_options_block?(
-              node.parent.parent
-            )
-          end
-
-          false
-        end
-
-        def valid_options?(options)
-          return false if options.nil?
-
-          options = extract_option_if_kwsplat(options)
-
-          return true unless options
-          return true if options.any? do |o|
-            dependent_option?(o) || present_option?(o)
-          end
-
-          false
-        end
-
-        def extract_option_if_kwsplat(options)
-          if options.first.kwsplat_type? && options.first.children.first.hash_type?
-            return options.first.children.first.pairs
-          end
-
-          options
-        end
-
-        def active_resource?(node)
-          return false if node.nil?
-
-          active_resource_class?(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/helper_instance_variable.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/helper_instance_variable.rb
deleted file mode 100644
index d390b414fa244..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/helper_instance_variable.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for use of the helper methods which reference
-      # instance variables.
-      #
-      # Relying on instance variables makes it difficult to re-use helper
-      # methods.
-      #
-      # If it seems awkward to explicitly pass in each dependent
-      # variable, consider moving the behavior elsewhere, for
-      # example to a model, decorator or presenter.
-      #
-      # Provided that a class inherits `ActionView::Helpers::FormBuilder`,
-      # an offense will not be registered.
-      #
-      # @example
-      #   # bad
-      #   def welcome_message
-      #     "Hello #{@user.name}"
-      #   end
-      #
-      #   # good
-      #   def welcome_message(user)
-      #     "Hello #{user.name}"
-      #   end
-      #
-      #   # good
-      #   class MyFormBuilder < ActionView::Helpers::FormBuilder
-      #     @template.do_something
-      #   end
-      class HelperInstanceVariable < Base
-        MSG = 'Do not use instance variables in helpers.'
-
-        def_node_matcher :form_builder_class?, <<~PATTERN
-          (const
-            (const
-               (const nil? :ActionView) :Helpers) :FormBuilder)
-        PATTERN
-
-        def on_ivar(node)
-          return if inherit_form_builder?(node)
-
-          add_offense(node)
-        end
-
-        def on_ivasgn(node)
-          return if node.parent.or_asgn_type? || inherit_form_builder?(node)
-
-          add_offense(node.loc.name)
-        end
-
-        private
-
-        def inherit_form_builder?(node)
-          node.each_ancestor(:class) do |class_node|
-            return true if form_builder_class?(class_node.parent_class)
-          end
-
-          false
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/http_positional_arguments.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/http_positional_arguments.rb
deleted file mode 100644
index bb0f214eae776..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/http_positional_arguments.rb
+++ /dev/null
@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Identifies usages of http methods like `get`, `post`,
-      # `put`, `patch` without the usage of keyword arguments in your tests and
-      # change them to use keyword args. This cop only applies to Rails >= 5.
-      # If you are running Rails < 5 you should disable the
-      # Rails/HttpPositionalArguments cop or set your TargetRailsVersion in your
-      # .rubocop.yml file to 4.2.
-      #
-      # @example
-      #   # bad
-      #   get :new, { user_id: 1}
-      #
-      #   # good
-      #   get :new, params: { user_id: 1 }
-      #   get :new, **options
-      class HttpPositionalArguments < Base
-        include RangeHelp
-        extend AutoCorrector
-        extend TargetRailsVersion
-
-        MSG = 'Use keyword arguments instead of ' \
-              'positional arguments for http call: `%<verb>s`.'
-        KEYWORD_ARGS = %i[
-          method params session body flash xhr as headers env to
-        ].freeze
-        ROUTING_METHODS = %i[draw routes].freeze
-        RESTRICT_ON_SEND = %i[get post put patch delete head].freeze
-
-        minimum_target_rails_version 5.0
-
-        def_node_matcher :http_request?, <<~PATTERN
-          (send nil? {#{RESTRICT_ON_SEND.map(&:inspect).join(' ')}} !nil? $_ ...)
-        PATTERN
-
-        def_node_matcher :kwsplat_hash?, <<~PATTERN
-          (hash (kwsplat _))
-        PATTERN
-
-        def on_send(node)
-          return if in_routing_block?(node)
-
-          http_request?(node) do |data|
-            return unless needs_conversion?(data)
-
-            message = format(MSG, verb: node.method_name)
-
-            add_offense(highlight_range(node), message: message) do |corrector|
-              # given a pre Rails 5 method: get :new, {user_id: @user.id}, {}
-              #
-              # @return lambda of auto correct procedure
-              # the result should look like:
-              #     get :new, params: { user_id: @user.id }, session: {}
-              # the http_method is the method used to call the controller
-              # the controller node can be a symbol, method, object or string
-              # that represents the path/action on the Rails controller
-              # the data is the http parameters and environment sent in
-              # the Rails 5 http call
-              corrector.replace(node.loc.expression, correction(node))
-            end
-          end
-        end
-
-        private
-
-        def in_routing_block?(node)
-          !!node.each_ancestor(:block).detect { |block| ROUTING_METHODS.include?(block.method_name) }
-        end
-
-        def needs_conversion?(data)
-          return true unless data.hash_type?
-          return false if kwsplat_hash?(data)
-
-          data.each_pair.none? do |pair|
-            special_keyword_arg?(pair.key) ||
-              (format_arg?(pair.key) && data.pairs.one?)
-          end
-        end
-
-        def special_keyword_arg?(node)
-          node.sym_type? && KEYWORD_ARGS.include?(node.value)
-        end
-
-        def format_arg?(node)
-          node.sym_type? && node.value == :format
-        end
-
-        def highlight_range(node)
-          _http_path, *data = *node.arguments
-
-          range_between(data.first.source_range.begin_pos, data.last.source_range.end_pos)
-        end
-
-        def convert_hash_data(data, type)
-          return '' if data.hash_type? && data.empty?
-
-          hash_data = if data.hash_type?
-                        format('{ %<data>s }',
-                               data: data.pairs.map(&:source).join(', '))
-                      else
-                        # user supplies an object,
-                        # no need to surround with braces
-                        data.source
-                      end
-
-          format(', %<type>s: %<hash_data>s', type: type, hash_data: hash_data)
-        end
-
-        def correction(node)
-          http_path, *data = *node.arguments
-
-          controller_action = http_path.source
-          params = convert_hash_data(data.first, 'params')
-          session = convert_hash_data(data.last, 'session') if data.size > 1
-
-          format(correction_template(node), name: node.method_name,
-                                            action: controller_action,
-                                            params: params,
-                                            session: session)
-        end
-
-        def correction_template(node)
-          if parentheses?(node)
-            '%<name>s(%<action>s%<params>s%<session>s)'
-          else
-            '%<name>s %<action>s%<params>s%<session>s'
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/http_status.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/http_status.rb
deleted file mode 100644
index adc4047a8c071..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/http_status.rb
+++ /dev/null
@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces use of symbolic or numeric value to define HTTP status.
-      #
-      # @example EnforcedStyle: symbolic (default)
-      #   # bad
-      #   render :foo, status: 200
-      #   render json: { foo: 'bar' }, status: 200
-      #   render plain: 'foo/bar', status: 304
-      #   redirect_to root_url, status: 301
-      #   head 200
-      #
-      #   # good
-      #   render :foo, status: :ok
-      #   render json: { foo: 'bar' }, status: :ok
-      #   render plain: 'foo/bar', status: :not_modified
-      #   redirect_to root_url, status: :moved_permanently
-      #   head :ok
-      #
-      # @example EnforcedStyle: numeric
-      #   # bad
-      #   render :foo, status: :ok
-      #   render json: { foo: 'bar' }, status: :not_found
-      #   render plain: 'foo/bar', status: :not_modified
-      #   redirect_to root_url, status: :moved_permanently
-      #   head :ok
-      #
-      #   # good
-      #   render :foo, status: 200
-      #   render json: { foo: 'bar' }, status: 404
-      #   render plain: 'foo/bar', status: 304
-      #   redirect_to root_url, status: 301
-      #   head 200
-      #
-      class HttpStatus < Base
-        include ConfigurableEnforcedStyle
-        extend AutoCorrector
-
-        RESTRICT_ON_SEND = %i[render redirect_to head].freeze
-
-        def_node_matcher :http_status, <<~PATTERN
-          {
-            (send nil? {:render :redirect_to} _ $hash)
-            (send nil? {:render :redirect_to} $hash)
-            (send nil? :head ${int sym} ...)
-          }
-        PATTERN
-
-        def_node_matcher :status_code, <<~PATTERN
-          (hash <(pair (sym :status) ${int sym}) ...>)
-        PATTERN
-
-        def on_send(node)
-          http_status(node) do |hash_node_or_status_code|
-            status = if hash_node_or_status_code.hash_type?
-                       status_code(hash_node_or_status_code)
-                     else
-                       hash_node_or_status_code
-                     end
-            return unless status
-
-            checker = checker_class.new(status)
-            return unless checker.offensive?
-
-            add_offense(checker.node, message: checker.message) do |corrector|
-              corrector.replace(checker.node.loc.expression, checker.preferred_style)
-            end
-          end
-        end
-
-        private
-
-        def checker_class
-          case style
-          when :symbolic
-            SymbolicStyleChecker
-          when :numeric
-            NumericStyleChecker
-          end
-        end
-
-        # :nodoc:
-        class SymbolicStyleChecker
-          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                'to define HTTP status code.'
-          DEFAULT_MSG = 'Prefer `symbolic` over `numeric` ' \
-                        'to define HTTP status code.'
-
-          attr_reader :node
-
-          def initialize(node)
-            @node = node
-          end
-
-          def offensive?
-            !node.sym_type? && !custom_http_status_code?
-          end
-
-          def message
-            format(MSG, prefer: preferred_style, current: number.to_s)
-          end
-
-          def preferred_style
-            symbol.inspect
-          end
-
-          private
-
-          def symbol
-            ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
-          end
-
-          def number
-            node.children.first
-          end
-
-          def custom_http_status_code?
-            node.int_type? &&
-              !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(number)
-          end
-        end
-
-        # :nodoc:
-        class NumericStyleChecker
-          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                'to define HTTP status code.'
-          DEFAULT_MSG = 'Prefer `numeric` over `symbolic` ' \
-                        'to define HTTP status code.'
-          PERMITTED_STATUS = %i[error success missing redirect].freeze
-
-          attr_reader :node
-
-          def initialize(node)
-            @node = node
-          end
-
-          def offensive?
-            !node.int_type? && !permitted_symbol?
-          end
-
-          def message
-            format(MSG, prefer: preferred_style, current: symbol.inspect)
-          end
-
-          def preferred_style
-            number.to_s
-          end
-
-          private
-
-          def number
-            ::Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol]
-          end
-
-          def symbol
-            node.value
-          end
-
-          def permitted_symbol?
-            node.sym_type? && PERMITTED_STATUS.include?(node.value)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/i18n_lazy_lookup.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/i18n_lazy_lookup.rb
deleted file mode 100644
index 9cc3709058f97..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/i18n_lazy_lookup.rb
+++ /dev/null
@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for places where I18n "lazy" lookup can be used.
-      #
-      # @example
-      #   # en.yml
-      #   # en:
-      #   #   books:
-      #   #     create:
-      #   #       success: Book created!
-      #
-      #   # bad
-      #   class BooksController < ApplicationController
-      #     def create
-      #       # ...
-      #       redirect_to books_url, notice: t('books.create.success')
-      #     end
-      #   end
-      #
-      #   # good
-      #   class BooksController < ApplicationController
-      #     def create
-      #       # ...
-      #       redirect_to books_url, notice: t('.success')
-      #     end
-      #   end
-      #
-      class I18nLazyLookup < Base
-        include VisibilityHelp
-        extend AutoCorrector
-
-        MSG = 'Use "lazy" lookup for the text used in controllers.'
-
-        def_node_matcher :translate_call?, <<~PATTERN
-          (send nil? {:translate :t} ${sym_type? str_type?} ...)
-        PATTERN
-
-        def on_send(node)
-          translate_call?(node) do |key_node|
-            key = key_node.value
-            return if key.to_s.start_with?('.')
-
-            controller, action = controller_and_action(node)
-            return unless controller && action
-
-            scoped_key = get_scoped_key(key_node, controller, action)
-            return unless key == scoped_key
-
-            add_offense(key_node) do |corrector|
-              unscoped_key = key_node.value.to_s.split('.').last
-              corrector.replace(key_node, "'.#{unscoped_key}'")
-            end
-          end
-        end
-
-        private
-
-        def controller_and_action(node)
-          action_node = node.each_ancestor(:def).first
-          return unless action_node && node_visibility(action_node) == :public
-
-          controller_node = node.each_ancestor(:class).first
-          return unless controller_node && controller_node.identifier.source.end_with?('Controller')
-
-          [controller_node, action_node]
-        end
-
-        def get_scoped_key(key_node, controller, action)
-          path = controller_path(controller).tr('/', '.')
-          action_name = action.method_name
-          key = key_node.value.to_s.split('.').last
-
-          "#{path}.#{action_name}.#{key}"
-        end
-
-        def controller_path(controller)
-          module_name = controller.parent_module_name
-          controller_name = controller.identifier.source
-
-          path = if module_name == 'Object'
-                   controller_name
-                 else
-                   "#{module_name}::#{controller_name}"
-                 end
-
-          path.delete_suffix('Controller').underscore
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/i18n_locale_assignment.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/i18n_locale_assignment.rb
deleted file mode 100644
index 1f9e852d5ae1d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/i18n_locale_assignment.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for the use of `I18n.locale=` method.
-      #
-      # The `locale` attribute persists for the rest of the Ruby runtime, potentially causing
-      # unexpected behavior at a later time.
-      # Using `I18n.with_locale` ensures the code passed in the block is the only place `I18n.locale` is affected.
-      # It eliminates the possibility of a `locale` sticking around longer than intended.
-      #
-      # @example
-      #   # bad
-      #   I18n.locale = :fr
-      #
-      #   # good
-      #   I18n.with_locale(:fr) do
-      #   end
-      #
-      class I18nLocaleAssignment < Base
-        MSG = 'Use `I18n.with_locale` with block instead of `I18n.locale=`.'
-        RESTRICT_ON_SEND = %i[locale=].freeze
-
-        def_node_matcher :i18n_locale_assignment?, <<~PATTERN
-          (send (const {nil? cbase} :I18n) :locale= ...)
-        PATTERN
-
-        def on_send(node)
-          return unless i18n_locale_assignment?(node)
-
-          add_offense(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/i18n_locale_texts.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/i18n_locale_texts.rb
deleted file mode 100644
index 353adac5044e0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/i18n_locale_texts.rb
+++ /dev/null
@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces use of I18n and locale files instead of locale specific strings.
-      #
-      # @example
-      #   # bad
-      #   class User < ApplicationRecord
-      #     validates :email, presence: { message: "must be present" }
-      #   end
-      #
-      #   # good
-      #   # config/locales/en.yml
-      #   # en:
-      #   #   activerecord:
-      #   #     errors:
-      #   #       models:
-      #   #         user:
-      #   #           blank: "must be present"
-      #
-      #   class User < ApplicationRecord
-      #     validates :email, presence: true
-      #   end
-      #
-      #   # bad
-      #   class PostsController < ApplicationController
-      #     def create
-      #       # ...
-      #       redirect_to root_path, notice: "Post created!"
-      #     end
-      #   end
-      #
-      #   # good
-      #   # config/locales/en.yml
-      #   # en:
-      #   #   posts:
-      #   #     create:
-      #   #       success: "Post created!"
-      #
-      #   class PostsController < ApplicationController
-      #     def create
-      #       # ...
-      #       redirect_to root_path, notice: t(".success")
-      #     end
-      #   end
-      #
-      #   # bad
-      #   class UserMailer < ApplicationMailer
-      #     def welcome(user)
-      #       mail(to: user.email, subject: "Welcome to My Awesome Site")
-      #     end
-      #   end
-      #
-      #   # good
-      #   # config/locales/en.yml
-      #   # en:
-      #   #   user_mailer:
-      #   #     welcome:
-      #   #       subject: "Welcome to My Awesome Site"
-      #
-      #   class UserMailer < ApplicationMailer
-      #     def welcome(user)
-      #       mail(to: user.email)
-      #     end
-      #   end
-      #
-      class I18nLocaleTexts < Base
-        MSG = 'Move locale texts to the locale files in the `config/locales` directory.'
-
-        RESTRICT_ON_SEND = %i[validates redirect_to []= mail].freeze
-
-        def_node_search :validation_message, <<~PATTERN
-          (pair (sym :message) $str)
-        PATTERN
-
-        def_node_search :redirect_to_flash, <<~PATTERN
-          (pair (sym {:notice :alert}) $str)
-        PATTERN
-
-        def_node_matcher :flash_assignment?, <<~PATTERN
-          (send (send nil? :flash) :[]= _ $str)
-        PATTERN
-
-        def_node_search :mail_subject, <<~PATTERN
-          (pair (sym :subject) $str)
-        PATTERN
-
-        def on_send(node)
-          case node.method_name
-          when :validates
-            validation_message(node) do |text_node|
-              add_offense(text_node)
-            end
-            return
-          when :redirect_to
-            text_node = redirect_to_flash(node).to_a.last
-          when :[]=
-            text_node = flash_assignment?(node)
-          when :mail
-            text_node = mail_subject(node).to_a.last
-          end
-
-          add_offense(text_node) if text_node
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/ignored_skip_action_filter_option.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/ignored_skip_action_filter_option.rb
deleted file mode 100644
index 57a2ca9847845..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/ignored_skip_action_filter_option.rb
+++ /dev/null
@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks that `if` and `only` (or `except`) are not used together
-      # as options of `skip_*` action filter.
-      #
-      # The `if` option will be ignored when `if` and `only` are used together.
-      # Similarly, the `except` option will be ignored when `if` and `except`
-      # are used together.
-      #
-      # @example
-      #   # bad
-      #   class MyPageController < ApplicationController
-      #     skip_before_action :login_required,
-      #       only: :show, if: :trusted_origin?
-      #   end
-      #
-      #   # good
-      #   class MyPageController < ApplicationController
-      #     skip_before_action :login_required,
-      #       if: -> { trusted_origin? && action_name == "show" }
-      #   end
-      #
-      # @example
-      #   # bad
-      #   class MyPageController < ApplicationController
-      #     skip_before_action :login_required,
-      #       except: :admin, if: :trusted_origin?
-      #   end
-      #
-      #   # good
-      #   class MyPageController < ApplicationController
-      #     skip_before_action :login_required,
-      #       if: -> { trusted_origin? && action_name != "admin" }
-      #   end
-      #
-      # @see https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-_normalize_callback_options
-      class IgnoredSkipActionFilterOption < Base
-        MSG = <<~MSG.chomp.freeze
-          `%<ignore>s` option will be ignored when `%<prefer>s` and `%<ignore>s` are used together.
-        MSG
-
-        RESTRICT_ON_SEND = %i[
-          skip_after_action
-          skip_around_action
-          skip_before_action
-          skip_action_callback
-        ].freeze
-
-        FILTERS = RESTRICT_ON_SEND.map { |method_name| ":#{method_name}" }
-
-        def_node_matcher :filter_options, <<~PATTERN
-          (send
-            nil?
-            {#{FILTERS.join(' ')}}
-            _
-            $_)
-        PATTERN
-
-        def on_send(node)
-          options = filter_options(node)
-          return unless options
-          return unless options.hash_type?
-
-          options = options_hash(options)
-
-          if if_and_only?(options)
-            add_offense(options[:if],
-                        message: format(MSG, prefer: :only, ignore: :if))
-          elsif if_and_except?(options)
-            add_offense(options[:except],
-                        message: format(MSG, prefer: :if, ignore: :except))
-          end
-        end
-
-        private
-
-        def options_hash(options)
-          options.pairs
-                 .select { |pair| pair.key.sym_type? }
-                 .to_h { |pair| [pair.key.value, pair] }
-        end
-
-        def if_and_only?(options)
-          options.key?(:if) && options.key?(:only)
-        end
-
-        def if_and_except?(options)
-          options.key?(:if) && options.key?(:except)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/index_by.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/index_by.rb
deleted file mode 100644
index 5de9a56f8e27e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/index_by.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Looks for uses of `each_with_object({}) { ... }`,
-      # `map { ... }.to_h`, and `Hash[map { ... }]` that are transforming
-      # an enumerable into a hash where the values are the original elements.
-      # Rails provides the `index_by` method for this purpose.
-      #
-      # @example
-      #   # bad
-      #   [1, 2, 3].each_with_object({}) { |el, h| h[foo(el)] = el }
-      #   [1, 2, 3].to_h { |el| [foo(el), el] }
-      #   [1, 2, 3].map { |el| [foo(el), el] }.to_h
-      #   Hash[[1, 2, 3].collect { |el| [foo(el), el] }]
-      #
-      #   # good
-      #   [1, 2, 3].index_by { |el| foo(el) }
-      class IndexBy < Base
-        include IndexMethod
-        extend AutoCorrector
-
-        def_node_matcher :on_bad_each_with_object, <<~PATTERN
-          (block
-            (call _ :each_with_object (hash))
-            (args (arg $_el) (arg _memo))
-            (call (lvar _memo) :[]= $!`_memo (lvar _el)))
-        PATTERN
-
-        def_node_matcher :on_bad_to_h, <<~PATTERN
-          (block
-            (call _ :to_h)
-            (args (arg $_el))
-            (array $_ (lvar _el)))
-        PATTERN
-
-        def_node_matcher :on_bad_map_to_h, <<~PATTERN
-          (call
-            (block
-              (call _ {:map :collect})
-              (args (arg $_el))
-              (array $_ (lvar _el)))
-            :to_h)
-        PATTERN
-
-        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
-          (send
-            (const _ :Hash)
-            :[]
-            (block
-              (call _ {:map :collect})
-              (args (arg $_el))
-              (array $_ (lvar _el))))
-        PATTERN
-
-        private
-
-        def new_method_name
-          'index_by'
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/index_with.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/index_with.rb
deleted file mode 100644
index 2ef1b9fc7013e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/index_with.rb
+++ /dev/null
@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Looks for uses of `each_with_object({}) { ... }`,
-      # `map { ... }.to_h`, and `Hash[map { ... }]` that are transforming
-      # an enumerable into a hash where the keys are the original elements.
-      # Rails provides the `index_with` method for this purpose.
-      #
-      # @example
-      #   # bad
-      #   [1, 2, 3].each_with_object({}) { |el, h| h[el] = foo(el) }
-      #   [1, 2, 3].to_h { |el| [el, foo(el)] }
-      #   [1, 2, 3].map { |el| [el, foo(el)] }.to_h
-      #   Hash[[1, 2, 3].collect { |el| [el, foo(el)] }]
-      #
-      #   # good
-      #   [1, 2, 3].index_with { |el| foo(el) }
-      class IndexWith < Base
-        extend AutoCorrector
-        extend TargetRailsVersion
-        include IndexMethod
-
-        minimum_target_rails_version 6.0
-
-        def_node_matcher :on_bad_each_with_object, <<~PATTERN
-          (block
-            (call _ :each_with_object (hash))
-            (args (arg $_el) (arg _memo))
-            (call (lvar _memo) :[]= (lvar _el) $!`_memo))
-        PATTERN
-
-        def_node_matcher :on_bad_to_h, <<~PATTERN
-          (block
-            (call _ :to_h)
-            (args (arg $_el))
-            (array (lvar _el) $_))
-        PATTERN
-
-        def_node_matcher :on_bad_map_to_h, <<~PATTERN
-          (call
-            (block
-              (call _ {:map :collect})
-              (args (arg $_el))
-              (array (lvar _el) $_))
-            :to_h)
-        PATTERN
-
-        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
-          (send
-            (const _ :Hash)
-            :[]
-            (block
-              (call _ {:map :collect})
-              (args (arg $_el))
-              (array (lvar _el) $_)))
-        PATTERN
-
-        private
-
-        def new_method_name
-          'index_with'
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/inquiry.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/inquiry.rb
deleted file mode 100644
index a7933a9347831..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/inquiry.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks that Active Support's `inquiry` method is not used.
-      #
-      # @example
-      #   # bad - String#inquiry
-      #   ruby = 'two'.inquiry
-      #   ruby.two?
-      #
-      #   # good
-      #   ruby = 'two'
-      #   ruby == 'two'
-      #
-      #   # bad - Array#inquiry
-      #   pets = %w(cat dog).inquiry
-      #   pets.gopher?
-      #
-      #   # good
-      #   pets = %w(cat dog)
-      #   pets.include? 'cat'
-      #
-      class Inquiry < Base
-        MSG = "Prefer Ruby's comparison operators over Active Support's `inquiry`."
-        RESTRICT_ON_SEND = %i[inquiry].freeze
-
-        def on_send(node)
-          return unless node.arguments.empty?
-          return unless (receiver = node.receiver)
-          return if !receiver.str_type? && !receiver.array_type?
-
-          add_offense(node.loc.selector)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/inverse_of.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/inverse_of.rb
deleted file mode 100644
index e80351a7de72e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/inverse_of.rb
+++ /dev/null
@@ -1,258 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Looks for has_(one|many) and belongs_to associations where
-      # Active Record can't automatically determine the inverse association
-      # because of a scope or the options used. Using the blog with order scope
-      # example below, traversing the a Blog's association in both directions
-      # with `blog.posts.first.blog` would cause the `blog` to be loaded from
-      # the database twice.
-      #
-      # `:inverse_of` must be manually specified for Active Record to use the
-      # associated object in memory, or set to `false` to opt-out. Note that
-      # setting `nil` does not stop Active Record from trying to determine the
-      # inverse automatically, and is not considered a valid value for this.
-      #
-      # @example
-      #   # good
-      #   class Blog < ApplicationRecord
-      #     has_many :posts
-      #   end
-      #
-      #   class Post < ApplicationRecord
-      #     belongs_to :blog
-      #   end
-      #
-      # @example
-      #   # bad
-      #   class Blog < ApplicationRecord
-      #     has_many :posts, -> { order(published_at: :desc) }
-      #   end
-      #
-      #   class Post < ApplicationRecord
-      #     belongs_to :blog
-      #   end
-      #
-      #   # good
-      #   class Blog < ApplicationRecord
-      #     has_many(:posts,
-      #              -> { order(published_at: :desc) },
-      #              inverse_of: :blog)
-      #   end
-      #
-      #   class Post < ApplicationRecord
-      #     belongs_to :blog
-      #   end
-      #
-      #   # good
-      #   class Blog < ApplicationRecord
-      #     with_options inverse_of: :blog do
-      #       has_many :posts, -> { order(published_at: :desc) }
-      #     end
-      #   end
-      #
-      #   class Post < ApplicationRecord
-      #     belongs_to :blog
-      #   end
-      #
-      #   # good
-      #   # When you don't want to use the inverse association.
-      #   class Blog < ApplicationRecord
-      #     has_many(:posts,
-      #              -> { order(published_at: :desc) },
-      #              inverse_of: false)
-      #   end
-      #
-      # @example
-      #   # bad
-      #   class Picture < ApplicationRecord
-      #     belongs_to :imageable, polymorphic: true
-      #   end
-      #
-      #   class Employee < ApplicationRecord
-      #     has_many :pictures, as: :imageable
-      #   end
-      #
-      #   class Product < ApplicationRecord
-      #     has_many :pictures, as: :imageable
-      #   end
-      #
-      #   # good
-      #   class Picture < ApplicationRecord
-      #     belongs_to :imageable, polymorphic: true
-      #   end
-      #
-      #   class Employee < ApplicationRecord
-      #     has_many :pictures, as: :imageable, inverse_of: :imageable
-      #   end
-      #
-      #   class Product < ApplicationRecord
-      #     has_many :pictures, as: :imageable, inverse_of: :imageable
-      #   end
-      #
-      # @example
-      #   # bad
-      #   # However, RuboCop can not detect this pattern...
-      #   class Physician < ApplicationRecord
-      #     has_many :appointments
-      #     has_many :patients, through: :appointments
-      #   end
-      #
-      #   class Appointment < ApplicationRecord
-      #     belongs_to :physician
-      #     belongs_to :patient
-      #   end
-      #
-      #   class Patient < ApplicationRecord
-      #     has_many :appointments
-      #     has_many :physicians, through: :appointments
-      #   end
-      #
-      #   # good
-      #   class Physician < ApplicationRecord
-      #     has_many :appointments
-      #     has_many :patients, through: :appointments
-      #   end
-      #
-      #   class Appointment < ApplicationRecord
-      #     belongs_to :physician, inverse_of: :appointments
-      #     belongs_to :patient, inverse_of: :appointments
-      #   end
-      #
-      #   class Patient < ApplicationRecord
-      #     has_many :appointments
-      #     has_many :physicians, through: :appointments
-      #   end
-      #
-      # @example IgnoreScopes: false (default)
-      #   # bad
-      #   class Blog < ApplicationRecord
-      #     has_many :posts, -> { order(published_at: :desc) }
-      #   end
-      #
-      # @example IgnoreScopes: true
-      #   # good
-      #   class Blog < ApplicationRecord
-      #     has_many :posts, -> { order(published_at: :desc) }
-      #   end
-      #
-      # @see https://guides.rubyonrails.org/association_basics.html#bi-directional-associations
-      # @see https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Setting+Inverses
-      class InverseOf < Base
-        SPECIFY_MSG = 'Specify an `:inverse_of` option.'
-        NIL_MSG = 'You specified `inverse_of: nil`, you probably meant to use `inverse_of: false`.'
-        RESTRICT_ON_SEND = %i[has_many has_one belongs_to].freeze
-
-        def_node_matcher :association_recv_arguments, <<~PATTERN
-          (send $_ {:has_many :has_one :belongs_to} _ $...)
-        PATTERN
-
-        def_node_matcher :options_from_argument, <<~PATTERN
-          (hash $...)
-        PATTERN
-
-        def_node_matcher :conditions_option?, <<~PATTERN
-          (pair (sym :conditions) !nil)
-        PATTERN
-
-        def_node_matcher :through_option?, <<~PATTERN
-          (pair (sym :through) !nil)
-        PATTERN
-
-        def_node_matcher :polymorphic_option?, <<~PATTERN
-          (pair (sym :polymorphic) !nil)
-        PATTERN
-
-        def_node_matcher :as_option?, <<~PATTERN
-          (pair (sym :as) !nil)
-        PATTERN
-
-        def_node_matcher :foreign_key_option?, <<~PATTERN
-          (pair (sym :foreign_key) !nil)
-        PATTERN
-
-        def_node_matcher :inverse_of_option?, <<~PATTERN
-          (pair (sym :inverse_of) !nil)
-        PATTERN
-
-        def_node_matcher :inverse_of_nil_option?, <<~PATTERN
-          (pair (sym :inverse_of) nil)
-        PATTERN
-
-        def on_send(node)
-          recv, arguments = association_recv_arguments(node)
-          return unless arguments
-
-          with_options = with_options_arguments(recv, node)
-
-          options = arguments.concat(with_options).flat_map do |arg|
-            options_from_argument(arg)
-          end
-          return if options_ignoring_inverse_of?(options)
-
-          return unless scope?(arguments) ||
-                        options_requiring_inverse_of?(options)
-
-          return if options_contain_inverse_of?(options)
-
-          add_offense(node.loc.selector, message: message(options))
-        end
-
-        def scope?(arguments)
-          !ignore_scopes? && arguments.any?(&:block_type?)
-        end
-
-        def options_requiring_inverse_of?(options)
-          required = options.any? do |opt|
-            conditions_option?(opt) ||
-              foreign_key_option?(opt)
-          end
-
-          return required if target_rails_version >= 5.2
-
-          required || options.any? { |opt| as_option?(opt) }
-        end
-
-        def options_ignoring_inverse_of?(options)
-          options.any? do |opt|
-            through_option?(opt) || polymorphic_option?(opt)
-          end
-        end
-
-        def options_contain_inverse_of?(options)
-          options.any? { |opt| inverse_of_option?(opt) }
-        end
-
-        def with_options_arguments(recv, node)
-          blocks = node.each_ancestor(:block).select do |block|
-            block.send_node.command?(:with_options) &&
-              same_context_in_with_options?(block.arguments.first, recv)
-          end
-          blocks.flat_map { |n| n.send_node.arguments }
-        end
-
-        def same_context_in_with_options?(arg, recv)
-          return true if arg.nil? && recv.nil?
-
-          arg && recv && arg.children[0] == recv.children[0]
-        end
-
-        private
-
-        def message(options)
-          if options.any? { |opt| inverse_of_nil_option?(opt) }
-            NIL_MSG
-          else
-            SPECIFY_MSG
-          end
-        end
-
-        def ignore_scopes?
-          cop_config['IgnoreScopes'] == true
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/lexically_scoped_action_filter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/lexically_scoped_action_filter.rb
deleted file mode 100644
index 3b96591f8854f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/lexically_scoped_action_filter.rb
+++ /dev/null
@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks that methods specified in the filter's `only` or
-      # `except` options are defined within the same class or module.
-      #
-      # @safety
-      #   You can technically specify methods of superclass or methods added by
-      #   mixins on the filter, but these can confuse developers. If you specify
-      #   methods that are defined in other classes or modules, you should
-      #   define the filter in that class or module.
-      #
-      #   If you rely on behavior defined in the superclass actions, you must
-      #   remember to invoke `super` in the subclass actions.
-      #
-      # @example
-      #   # bad
-      #   class LoginController < ApplicationController
-      #     before_action :require_login, only: %i[index settings logout]
-      #
-      #     def index
-      #     end
-      #   end
-      #
-      #   # good
-      #   class LoginController < ApplicationController
-      #     before_action :require_login, only: %i[index settings logout]
-      #
-      #     def index
-      #     end
-      #
-      #     def settings
-      #     end
-      #
-      #     def logout
-      #     end
-      #   end
-      #
-      # @example
-      #   # bad
-      #   module FooMixin
-      #     extend ActiveSupport::Concern
-      #
-      #     included do
-      #       before_action proc { authenticate }, only: :foo
-      #     end
-      #   end
-      #
-      #   # good
-      #   module FooMixin
-      #     extend ActiveSupport::Concern
-      #
-      #     included do
-      #       before_action proc { authenticate }, only: :foo
-      #     end
-      #
-      #     def foo
-      #       # something
-      #     end
-      #   end
-      #
-      # @example
-      #   class ContentController < ApplicationController
-      #     def update
-      #       @content.update(content_attributes)
-      #     end
-      #   end
-      #
-      #   class ArticlesController < ContentController
-      #     before_action :load_article, only: [:update]
-      #
-      #     # the cop requires this method, but it relies on behavior defined
-      #     # in the superclass, so needs to invoke `super`
-      #     def update
-      #       super
-      #     end
-      #
-      #     private
-      #
-      #     def load_article
-      #       @content = Article.find(params[:article_id])
-      #     end
-      #   end
-      class LexicallyScopedActionFilter < Base
-        MSG = '%<action>s not explicitly defined on the %<type>s.'
-
-        RESTRICT_ON_SEND = %i[
-          after_action
-          append_after_action
-          append_around_action
-          append_before_action
-          around_action
-          before_action
-          prepend_after_action
-          prepend_around_action
-          prepend_before_action
-          skip_after_action
-          skip_around_action
-          skip_before_action
-          skip_action_callback
-        ].freeze
-
-        FILTERS = RESTRICT_ON_SEND.map { |method_name| ":#{method_name}" }
-
-        def_node_matcher :only_or_except_filter_methods, <<~PATTERN
-          (send
-            nil?
-            {#{FILTERS.join(' ')}}
-            _
-            (hash
-              (pair
-                (sym {:only :except})
-                $_)))
-        PATTERN
-
-        def on_send(node)
-          methods_node = only_or_except_filter_methods(node)
-          return unless methods_node
-
-          parent = node.each_ancestor(:class, :module).first
-          return unless parent
-
-          block = parent.each_child_node(:begin).first
-          return unless block
-
-          defined_action_methods = defined_action_methods(block)
-
-          methods = array_values(methods_node).reject do |method|
-            defined_action_methods.include?(method)
-          end
-
-          message = message(methods, parent)
-          add_offense(node, message: message) unless methods.empty?
-        end
-
-        private
-
-        def defined_action_methods(block)
-          defined_methods = block.each_child_node(:def).map(&:method_name)
-
-          defined_methods + aliased_action_methods(block, defined_methods)
-        end
-
-        def aliased_action_methods(node, defined_methods)
-          alias_methods = node.each_child_node(:send).select { |send_node| send_node.method?(:alias_method) }
-
-          hash_of_alias_methods = alias_methods.each_with_object({}) do |alias_method, result|
-            result[alias_method.last_argument.value] = alias_method.first_argument.value
-          end
-
-          defined_methods.each_with_object([]) do |defined_method, aliased_method|
-            if (new_method_name = hash_of_alias_methods[defined_method])
-              aliased_method << new_method_name
-            end
-          end
-        end
-
-        # @param node [RuboCop::AST::Node]
-        # @return [Array<Symbol>]
-        def array_values(node) # rubocop:disable Metrics/MethodLength
-          case node.type
-          when :str
-            [node.str_content.to_sym]
-          when :sym
-            [node.value]
-          when :array
-            node.values.map do |v|
-              case v.type
-              when :str
-                v.str_content.to_sym
-              when :sym
-                v.value
-              end
-            end.compact
-          else
-            []
-          end
-        end
-
-        # @param methods [Array<String>]
-        # @param parent [RuboCop::AST::Node]
-        # @return [String]
-        def message(methods, parent)
-          if methods.size == 1
-            format(MSG,
-                   action: "`#{methods[0]}` is",
-                   type: parent.type)
-          else
-            format(MSG,
-                   action: "`#{methods.join('`, `')}` are",
-                   type: parent.type)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/link_to_blank.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/link_to_blank.rb
deleted file mode 100644
index a0c2899f99ff2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/link_to_blank.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for calls to `link_to` that contain a
-      # `target: '_blank'` but no `rel: 'noopener'`. This can be a security
-      # risk as the loaded page will have control over the previous page
-      # and could change its location for phishing purposes.
-      #
-      # The option `rel: 'noreferrer'` also blocks this behavior
-      # and removes the http-referrer header.
-      #
-      # @example
-      #   # bad
-      #   link_to 'Click here', url, target: '_blank'
-      #
-      #   # good
-      #   link_to 'Click here', url, target: '_blank', rel: 'noopener'
-      #
-      #   # good
-      #   link_to 'Click here', url, target: '_blank', rel: 'noreferrer'
-      class LinkToBlank < Base
-        extend AutoCorrector
-
-        MSG = 'Specify a `:rel` option containing noopener.'
-        RESTRICT_ON_SEND = %i[link_to].freeze
-
-        def_node_matcher :blank_target?, <<~PATTERN
-          (pair {(sym :target) (str "target")} {(str "_blank") (sym :_blank)})
-        PATTERN
-
-        def_node_matcher :includes_noopener?, <<~PATTERN
-          (pair {(sym :rel) (str "rel")} ({str sym} #contains_noopener?))
-        PATTERN
-
-        def_node_matcher :rel_node?, <<~PATTERN
-          (pair {(sym :rel) (str "rel")} (str _))
-        PATTERN
-
-        def on_send(node)
-          option_nodes = node.each_child_node(:hash)
-
-          option_nodes.map(&:children).each do |options|
-            blank = options.find { |o| blank_target?(o) }
-            next unless blank && options.none? { |o| includes_noopener?(o) }
-
-            add_offense(blank) do |corrector|
-              autocorrect(corrector, node, blank, option_nodes)
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, send_node, node, option_nodes)
-          rel_node = nil
-          option_nodes.map(&:children).each do |options|
-            rel_node ||= options.find { |o| rel_node?(o) }
-          end
-
-          if rel_node
-            append_to_rel(rel_node, corrector)
-          else
-            add_rel(send_node, node, corrector)
-          end
-        end
-
-        def append_to_rel(rel_node, corrector)
-          existing_rel = rel_node.children.last.value
-          str_range = rel_node.children.last.loc.expression.adjust(
-            begin_pos: 1,
-            end_pos: -1
-          )
-          corrector.replace(str_range, "#{existing_rel} noopener")
-        end
-
-        def add_rel(send_node, offense_node, corrector)
-          opening_quote = offense_node.children.last.source[0]
-          closing_quote = opening_quote == ':' ? '' : opening_quote
-          new_rel_exp = ", rel: #{opening_quote}noopener#{closing_quote}"
-          range = if (last_argument = send_node.last_argument).hash_type?
-                    last_argument.pairs.last.source_range
-                  else
-                    last_argument.source_range
-                  end
-
-          corrector.insert_after(range, new_rel_exp)
-        end
-
-        def contains_noopener?(value)
-          return false unless value
-
-          rel_array = value.to_s.split
-          rel_array.include?('noopener') || rel_array.include?('noreferrer')
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/mailer_name.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/mailer_name.rb
deleted file mode 100644
index e50ca97513830..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/mailer_name.rb
+++ /dev/null
@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces that mailer names end with `Mailer` suffix.
-      #
-      # Without the `Mailer` suffix it isn't immediately apparent what's a mailer
-      # and which views are related to the mailer.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because renaming a constant is
-      #   always an unsafe operation.
-      #
-      # @example
-      #   # bad
-      #   class User < ActionMailer::Base
-      #   end
-      #
-      #   class User < ApplicationMailer
-      #   end
-      #
-      #   # good
-      #   class UserMailer < ActionMailer::Base
-      #   end
-      #
-      #   class UserMailer < ApplicationMailer
-      #   end
-      #
-      class MailerName < Base
-        extend AutoCorrector
-
-        MSG = 'Mailer should end with `Mailer` suffix.'
-
-        def_node_matcher :mailer_base_class?, <<~PATTERN
-          {
-            (const (const nil? :ActionMailer) :Base)
-            (const nil? :ApplicationMailer)
-          }
-        PATTERN
-
-        def_node_matcher :class_definition?, <<~PATTERN
-          (class $(const _ !#mailer_suffix?) #mailer_base_class? ...)
-        PATTERN
-
-        def_node_matcher :class_new_definition?, <<~PATTERN
-          (send (const nil? :Class) :new #mailer_base_class?)
-        PATTERN
-
-        def on_class(node)
-          class_definition?(node) do |name_node|
-            add_offense(name_node) do |corrector|
-              autocorrect(corrector, name_node)
-            end
-          end
-        end
-
-        def on_send(node)
-          return unless class_new_definition?(node)
-
-          casgn_parent = node.each_ancestor(:casgn).first
-          return unless casgn_parent
-
-          name = casgn_parent.children[1]
-          return if mailer_suffix?(name)
-
-          add_offense(casgn_parent.loc.name) do |corrector|
-            autocorrect(corrector, casgn_parent)
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          if node.casgn_type?
-            name = node.children[1]
-            corrector.replace(node.loc.name, "#{name}Mailer")
-          else
-            name = node.children.last
-            corrector.replace(node.source_range, "#{name}Mailer")
-          end
-        end
-
-        def mailer_suffix?(mailer_name)
-          mailer_name.to_s.end_with?('Mailer')
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/match_route.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/match_route.rb
deleted file mode 100644
index e7c7b4c418cd3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/match_route.rb
+++ /dev/null
@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Identifies places where defining routes with `match`
-      # can be replaced with a specific HTTP method.
-      #
-      # Don't use `match` to define any routes unless there is a need to map multiple request types
-      # among [:get, :post, :patch, :put, :delete] to a single action using the `:via` option.
-      #
-      # @example
-      #   # bad
-      #   match ':controller/:action/:id'
-      #   match 'photos/:id', to: 'photos#show', via: :get
-      #
-      #   # good
-      #   get ':controller/:action/:id'
-      #   get 'photos/:id', to: 'photos#show'
-      #   match 'photos/:id', to: 'photos#show', via: [:get, :post]
-      #   match 'photos/:id', to: 'photos#show', via: :all
-      #
-      class MatchRoute < Base
-        extend AutoCorrector
-
-        MSG = 'Use `%<http_method>s` instead of `match` to define a route.'
-        RESTRICT_ON_SEND = %i[match].freeze
-        HTTP_METHODS = %i[get post put patch delete].freeze
-
-        def_node_matcher :match_method_call?, <<~PATTERN
-          (send nil? :match $_ $(hash ...) ?)
-        PATTERN
-
-        def on_send(node)
-          match_method_call?(node) do |path_node, options_node|
-            return unless within_routes?(node)
-
-            options_node = path_node.hash_type? ? path_node : options_node.first
-
-            if options_node.nil?
-              register_offense(node, 'get')
-            else
-              via = extract_via(options_node)
-              return unless via.size == 1 && http_method?(via.first)
-
-              register_offense(node, via.first)
-            end
-          end
-        end
-
-        private
-
-        def register_offense(node, http_method)
-          add_offense(node, message: format(MSG, http_method: http_method)) do |corrector|
-            match_method_call?(node) do |path_node, options_node|
-              options_node = options_node.first
-
-              corrector.replace(node, replacement(path_node, options_node))
-            end
-          end
-        end
-
-        def_node_matcher :routes_draw?, <<~PATTERN
-          (send (send _ :routes) :draw)
-        PATTERN
-
-        def within_routes?(node)
-          node.each_ancestor(:block).any? { |a| routes_draw?(a.send_node) }
-        end
-
-        def extract_via(node)
-          via_pair = via_pair(node)
-          return %i[get] unless via_pair
-
-          _, via = *via_pair
-
-          if via.basic_literal?
-            [via.value]
-          elsif via.array_type?
-            via.values.map(&:value)
-          else
-            []
-          end
-        end
-
-        def via_pair(node)
-          node.pairs.find { |p| p.key.value == :via }
-        end
-
-        def http_method?(method)
-          HTTP_METHODS.include?(method.to_sym)
-        end
-
-        def replacement(path_node, options_node)
-          if path_node.hash_type?
-            http_method, options = *http_method_and_options(path_node)
-            "#{http_method} #{options.map(&:source).join(', ')}"
-          elsif options_node.nil?
-            "get #{path_node.source}"
-          else
-            http_method, options = *http_method_and_options(options_node)
-
-            if options.any?
-              "#{http_method} #{path_node.source}, #{options.map(&:source).join(', ')}"
-            else
-              "#{http_method} #{path_node.source}"
-            end
-          end
-        end
-
-        def http_method_and_options(node)
-          via_pair = via_pair(node)
-          http_method = extract_via(node).first
-          rest_pairs = node.pairs - [via_pair]
-          [http_method, rest_pairs]
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/migration_class_name.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/migration_class_name.rb
deleted file mode 100644
index d204d450b4a0d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/migration_class_name.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Makes sure that each migration file defines a migration class
-      # whose name matches the file name.
-      # (e.g. `20220224111111_create_users.rb` should define `CreateUsers` class.)
-      #
-      # @example
-      #   # db/migrate/20220224111111_create_users.rb
-      #
-      #   # bad
-      #   class SellBooks < ActiveRecord::Migration[7.0]
-      #   end
-      #
-      #   # good
-      #   class CreateUsers < ActiveRecord::Migration[7.0]
-      #   end
-      #
-      class MigrationClassName < Base
-        extend AutoCorrector
-        include MigrationsHelper
-
-        MSG = 'Replace with `%<camelized_basename>s` that matches the file name.'
-
-        def on_class(node)
-          return unless migration_class?(node)
-
-          basename = basename_without_timestamp_and_suffix(processed_source.file_path)
-
-          class_identifier = node.identifier
-          camelized_basename = camelize(basename)
-          return if class_identifier.source.casecmp(camelized_basename).zero?
-
-          message = format(MSG, camelized_basename: camelized_basename)
-
-          add_offense(class_identifier, message: message) do |corrector|
-            corrector.replace(class_identifier, camelized_basename)
-          end
-        end
-
-        private
-
-        def basename_without_timestamp_and_suffix(filepath)
-          basename = File.basename(filepath, '.rb')
-          basename = remove_gem_suffix(basename)
-
-          basename.sub(/\A\d+_/, '')
-        end
-
-        # e.g.: from `add_blobs.active_storage` to `add_blobs`.
-        def remove_gem_suffix(file_name)
-          file_name.sub(/\..+\z/, '')
-        end
-
-        def camelize(word)
-          word.split('_').map(&:capitalize).join
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/negate_include.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/negate_include.rb
deleted file mode 100644
index 1aed7adf45f95..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/negate_include.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces the use of `collection.exclude?(obj)`
-      # over `!collection.include?(obj)`.
-      #
-      # @safety
-      #   This cop is unsafe because false positive will occur for
-      #   receiver objects that do not have an `exclude?` method. (e.g. `IPAddr`)
-      #
-      # @example
-      #   # bad
-      #   !array.include?(2)
-      #   !hash.include?(:key)
-      #
-      #   # good
-      #   array.exclude?(2)
-      #   hash.exclude?(:key)
-      #
-      class NegateInclude < Base
-        extend AutoCorrector
-
-        MSG = 'Use `.exclude?` and remove the negation part.'
-        RESTRICT_ON_SEND = %i[!].freeze
-
-        def_node_matcher :negate_include_call?, <<~PATTERN
-          (send (send $_ :include? $_) :!)
-        PATTERN
-
-        def on_send(node)
-          return unless (receiver, obj = negate_include_call?(node))
-
-          add_offense(node) do |corrector|
-            corrector.replace(node, "#{receiver.source}.exclude?(#{obj.source})")
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/not_null_column.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/not_null_column.rb
deleted file mode 100644
index 9c22495df5077..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/not_null_column.rb
+++ /dev/null
@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for add_column call with NOT NULL constraint
-      # in migration file.
-      #
-      # @example
-      #   # bad
-      #   add_column :users, :name, :string, null: false
-      #   add_reference :products, :category, null: false
-      #
-      #   # good
-      #   add_column :users, :name, :string, null: true
-      #   add_column :users, :name, :string, null: false, default: ''
-      #   add_reference :products, :category
-      #   add_reference :products, :category, null: false, default: 1
-      class NotNullColumn < Base
-        MSG = 'Do not add a NOT NULL column without a default value.'
-        RESTRICT_ON_SEND = %i[add_column add_reference].freeze
-
-        def_node_matcher :add_not_null_column?, <<~PATTERN
-          (send nil? :add_column _ _ _ (hash $...))
-        PATTERN
-
-        def_node_matcher :add_not_null_reference?, <<~PATTERN
-          (send nil? :add_reference _ _ (hash $...))
-        PATTERN
-
-        def_node_matcher :null_false?, <<~PATTERN
-          (pair (sym :null) (false))
-        PATTERN
-
-        def_node_matcher :default_option?, <<~PATTERN
-          (pair (sym :default) !nil)
-        PATTERN
-
-        def on_send(node)
-          check_add_column(node)
-          check_add_reference(node)
-        end
-
-        private
-
-        def check_add_column(node)
-          pairs = add_not_null_column?(node)
-          check_pairs(pairs)
-        end
-
-        def check_add_reference(node)
-          pairs = add_not_null_reference?(node)
-          check_pairs(pairs)
-        end
-
-        def check_pairs(pairs)
-          return unless pairs
-          return if pairs.any? { |pair| default_option?(pair) }
-
-          null_false = pairs.find { |pair| null_false?(pair) }
-          return unless null_false
-
-          add_offense(null_false)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/order_by_id.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/order_by_id.rb
deleted file mode 100644
index f5925821524de..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/order_by_id.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for places where ordering by `id` column is used.
-      #
-      # Don't use the `id` column for ordering. The sequence of ids is not guaranteed
-      # to be in any particular order, despite often (incidentally) being chronological.
-      # Use a timestamp column to order chronologically. As a bonus the intent is clearer.
-      #
-      # NOTE: Make sure the changed order column does not introduce performance
-      # bottlenecks and appropriate database indexes are added.
-      #
-      # @example
-      #   # bad
-      #   scope :chronological, -> { order(id: :asc) }
-      #   scope :chronological, -> { order(primary_key => :asc) }
-      #
-      #   # good
-      #   scope :chronological, -> { order(created_at: :asc) }
-      #
-      class OrderById < Base
-        include RangeHelp
-
-        MSG = 'Do not use the `id` column for ordering. Use a timestamp column to order chronologically.'
-        RESTRICT_ON_SEND = %i[order].freeze
-
-        def_node_matcher :order_by_id?, <<~PATTERN
-          (send _ :order
-            {
-              (sym :id)
-              (hash (pair (sym :id) _))
-              (send _ :primary_key)
-              (hash (pair (send _ :primary_key) _))
-            })
-        PATTERN
-
-        def on_send(node)
-          add_offense(offense_range(node)) if order_by_id?(node)
-        end
-
-        private
-
-        def offense_range(node)
-          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/output.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/output.rb
deleted file mode 100644
index 655cef658eaf0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/output.rb
+++ /dev/null
@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for the use of output calls like puts and print
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because depending on the Rails log level configuration,
-      #   changing from `puts` to `Rails.logger.debug` could result in no output being shown.
-      #
-      # @example
-      #   # bad
-      #   puts 'A debug message'
-      #   pp 'A debug message'
-      #   print 'A debug message'
-      #
-      #   # good
-      #   Rails.logger.debug 'A debug message'
-      class Output < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Do not write to stdout. ' \
-              "Use Rails's logger if you want to log."
-        RESTRICT_ON_SEND = %i[
-          ap p pp pretty_print print puts binwrite syswrite write write_nonblock
-        ].freeze
-
-        def_node_matcher :output?, <<~PATTERN
-          (send nil? {:ap :p :pp :pretty_print :print :puts} ...)
-        PATTERN
-
-        def_node_matcher :io_output?, <<~PATTERN
-          (send
-            {
-              (gvar #match_gvar?)
-              {(const nil? :STDOUT) (const nil? :STDERR)}
-            }
-            {:binwrite :syswrite :write :write_nonblock}
-            ...)
-        PATTERN
-
-        def on_send(node)
-          return unless (output?(node) || io_output?(node)) && node.arguments?
-
-          range = offense_range(node)
-
-          add_offense(range) do |corrector|
-            corrector.replace(range, 'Rails.logger.debug')
-          end
-        end
-
-        private
-
-        def match_gvar?(sym)
-          %i[$stdout $stderr].include?(sym)
-        end
-
-        def offense_range(node)
-          if node.receiver
-            range_between(node.loc.expression.begin_pos, node.loc.selector.end_pos)
-          else
-            node.loc.selector
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/output_safety.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/output_safety.rb
deleted file mode 100644
index 869fa3030e671..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/output_safety.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for the use of output safety calls like `html_safe`,
-      # `raw`, and `safe_concat`. These methods do not escape content. They
-      # simply return a SafeBuffer containing the content as is. Instead,
-      # use `safe_join` to join content and escape it and concat to
-      # concatenate content and escape it, ensuring its safety.
-      #
-      # @example
-      #   user_content = "<b>hi</b>"
-      #
-      #   # bad
-      #   "<p>#{user_content}</p>".html_safe
-      #   # => ActiveSupport::SafeBuffer "<p><b>hi</b></p>"
-      #
-      #   # good
-      #   content_tag(:p, user_content)
-      #   # => ActiveSupport::SafeBuffer "<p>&lt;b&gt;hi&lt;/b&gt;</p>"
-      #
-      #   # bad
-      #   out = ""
-      #   out << "<li>#{user_content}</li>"
-      #   out << "<li>#{user_content}</li>"
-      #   out.html_safe
-      #   # => ActiveSupport::SafeBuffer "<li><b>hi</b></li><li><b>hi</b></li>"
-      #
-      #   # good
-      #   out = []
-      #   out << content_tag(:li, user_content)
-      #   out << content_tag(:li, user_content)
-      #   safe_join(out)
-      #   # => ActiveSupport::SafeBuffer
-      #   #    "<li>&lt;b&gt;hi&lt;/b&gt;</li><li>&lt;b&gt;hi&lt;/b&gt;</li>"
-      #
-      #   # bad
-      #   out = "<h1>trusted content</h1>".html_safe
-      #   out.safe_concat(user_content)
-      #   # => ActiveSupport::SafeBuffer "<h1>trusted_content</h1><b>hi</b>"
-      #
-      #   # good
-      #   out = "<h1>trusted content</h1>".html_safe
-      #   out.concat(user_content)
-      #   # => ActiveSupport::SafeBuffer
-      #   #    "<h1>trusted_content</h1>&lt;b&gt;hi&lt;/b&gt;"
-      #
-      #   # safe, though maybe not good style
-      #   out = "trusted content"
-      #   result = out.concat(user_content)
-      #   # => String "trusted content<b>hi</b>"
-      #   # because when rendered in ERB the String will be escaped:
-      #   # <%= result %>
-      #   # => trusted content&lt;b&gt;hi&lt;/b&gt;
-      #
-      #   # bad
-      #   (user_content + " " + content_tag(:span, user_content)).html_safe
-      #   # => ActiveSupport::SafeBuffer "<b>hi</b> <span><b>hi</b></span>"
-      #
-      #   # good
-      #   safe_join([user_content, " ", content_tag(:span, user_content)])
-      #   # => ActiveSupport::SafeBuffer
-      #   #    "&lt;b&gt;hi&lt;/b&gt; <span>&lt;b&gt;hi&lt;/b&gt;</span>"
-      class OutputSafety < Base
-        MSG = 'Tagging a string as html safe may be a security risk.'
-        RESTRICT_ON_SEND = %i[html_safe raw safe_concat].freeze
-
-        def on_send(node)
-          return if non_interpolated_string?(node)
-
-          return unless looks_like_rails_html_safe?(node) ||
-                        looks_like_rails_raw?(node) ||
-                        looks_like_rails_safe_concat?(node)
-
-          add_offense(node.loc.selector)
-        end
-        alias on_csend on_send
-
-        private
-
-        def non_interpolated_string?(node)
-          node.receiver&.str_type? && !node.receiver.dstr_type?
-        end
-
-        def looks_like_rails_html_safe?(node)
-          node.receiver && node.method?(:html_safe) && !node.arguments?
-        end
-
-        def looks_like_rails_raw?(node)
-          node.command?(:raw) && node.arguments.one?
-        end
-
-        def looks_like_rails_safe_concat?(node)
-          node.method?(:safe_concat) && node.arguments.one?
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pick.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pick.rb
deleted file mode 100644
index a13ba846f0a58..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pick.rb
+++ /dev/null
@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces the use of `pick` over `pluck(...).first`.
-      #
-      # Using `pluck` followed by `first` creates an intermediate array, which
-      # `pick` avoids. When called on an Active Record relation, `pick` adds a
-      # limit to the query so that only one value is fetched from the database.
-      #
-      # @safety
-      #   This cop is unsafe because `pluck` is defined on both `ActiveRecord::Relation` and `Enumerable`,
-      #   whereas `pick` is only defined on `ActiveRecord::Relation` in Rails 6.0. This was addressed
-      #   in Rails 6.1 via rails/rails#38760, at which point the cop is safe.
-      #
-      #   See: https://github.com/rubocop/rubocop-rails/pull/249
-      #
-      # @example
-      #   # bad
-      #   Model.pluck(:a).first
-      #   [{ a: :b, c: :d }].pluck(:a, :b).first
-      #
-      #   # good
-      #   Model.pick(:a)
-      #   [{ a: :b, c: :d }].pick(:a, :b)
-      class Pick < Base
-        extend AutoCorrector
-        extend TargetRailsVersion
-
-        MSG = 'Prefer `pick(%<args>s)` over `pluck(%<args>s).first`.'
-        RESTRICT_ON_SEND = %i[first].freeze
-
-        minimum_target_rails_version 6.0
-
-        def_node_matcher :pick_candidate?, <<~PATTERN
-          (send (send _ :pluck ...) :first)
-        PATTERN
-
-        def on_send(node)
-          pick_candidate?(node) do
-            receiver = node.receiver
-            receiver_selector = receiver.loc.selector
-            node_selector = node.loc.selector
-            range = receiver_selector.join(node_selector)
-
-            add_offense(range, message: message(receiver)) do |corrector|
-              first_range = receiver.source_range.end.join(node_selector)
-
-              corrector.remove(first_range)
-              corrector.replace(receiver_selector, 'pick')
-            end
-          end
-        end
-
-        private
-
-        def message(receiver)
-          format(MSG, args: receiver.arguments.map(&:source).join(', '))
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pluck.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pluck.rb
deleted file mode 100644
index f8c3201135c03..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pluck.rb
+++ /dev/null
@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces the use of `pluck` over `map`.
-      #
-      # `pluck` can be used instead of `map` to extract a single key from each
-      # element in an enumerable. When called on an Active Record relation, it
-      # results in a more efficient query that only selects the necessary key.
-      #
-      # @example
-      #   # bad
-      #   Post.published.map { |post| post[:title] }
-      #   [{ a: :b, c: :d }].collect { |el| el[:a] }
-      #
-      #   # good
-      #   Post.published.pluck(:title)
-      #   [{ a: :b, c: :d }].pluck(:a)
-      class Pluck < Base
-        extend AutoCorrector
-        extend TargetRailsVersion
-
-        MSG = 'Prefer `pluck(:%<value>s)` over `%<current>s`.'
-
-        minimum_target_rails_version 5.0
-
-        def_node_matcher :pluck_candidate?, <<~PATTERN
-          ({block numblock} (send _ {:map :collect}) $_argument (send (lvar $_element) :[] (sym $_value)))
-        PATTERN
-
-        def on_block(node)
-          pluck_candidate?(node) do |argument, element, value|
-            match = if node.block_type?
-                      argument.children.first.source.to_sym == element
-                    else # numblock
-                      argument == 1 && element == :_1
-                    end
-            next unless match
-
-            message = message(value, node)
-
-            add_offense(offense_range(node), message: message) do |corrector|
-              corrector.replace(offense_range(node), "pluck(:#{value})")
-            end
-          end
-        end
-        alias on_numblock on_block
-
-        private
-
-        def offense_range(node)
-          node.send_node.loc.selector.join(node.loc.end)
-        end
-
-        def message(value, node)
-          current = offense_range(node).source
-
-          format(MSG, value: value, current: current)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pluck_id.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pluck_id.rb
deleted file mode 100644
index 4a99691f07d86..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pluck_id.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces the use of `ids` over `pluck(:id)` and `pluck(primary_key)`.
-      #
-      # @safety
-      #   This cop is unsafe if the receiver object is not an Active Record object.
-      #
-      # @example
-      #   # bad
-      #   User.pluck(:id)
-      #   user.posts.pluck(:id)
-      #
-      #   def self.user_ids
-      #     pluck(primary_key)
-      #   end
-      #
-      #   # good
-      #   User.ids
-      #   user.posts.ids
-      #
-      #   def self.user_ids
-      #     ids
-      #   end
-      #
-      class PluckId < Base
-        include RangeHelp
-        include ActiveRecordHelper
-        extend AutoCorrector
-
-        MSG = 'Use `ids` instead of `%<bad_method>s`.'
-        RESTRICT_ON_SEND = %i[pluck].freeze
-
-        def_node_matcher :pluck_id_call?, <<~PATTERN
-          (send _ :pluck {(sym :id) (send nil? :primary_key)})
-        PATTERN
-
-        def on_send(node)
-          return if !pluck_id_call?(node) || in_where?(node)
-
-          range = offense_range(node)
-          message = format(MSG, bad_method: range.source)
-
-          add_offense(range, message: message) do |corrector|
-            corrector.replace(offense_range(node), 'ids')
-          end
-        end
-
-        private
-
-        def offense_range(node)
-          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pluck_in_where.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pluck_in_where.rb
deleted file mode 100644
index 1da59673867e6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pluck_in_where.rb
+++ /dev/null
@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Identifies places where `pluck` is used in `where` query methods
-      # and can be replaced with `select`.
-      #
-      # Since `pluck` is an eager method and hits the database immediately,
-      # using `select` helps to avoid additional database queries.
-      #
-      # This cop has two different enforcement modes. When the `EnforcedStyle`
-      # is `conservative` (the default) then only calls to `pluck` on a constant
-      # (i.e. a model class) in the `where` is used as offenses.
-      #
-      # @safety
-      #   When the `EnforcedStyle` is `aggressive` then all calls to `pluck` in the
-      #   `where` is used as offenses. This may lead to false positives
-      #   as the cop cannot replace to `select` between calls to `pluck` on an
-      #   `ActiveRecord::Relation` instance vs a call to `pluck` on an `Array` instance.
-      #
-      # @example
-      #   # bad
-      #   Post.where(user_id: User.active.pluck(:id))
-      #
-      #   # good
-      #   Post.where(user_id: User.active.select(:id))
-      #   Post.where(user_id: active_users.select(:id))
-      #
-      # @example EnforcedStyle: conservative (default)
-      #   # good
-      #   Post.where(user_id: active_users.pluck(:id))
-      #
-      # @example EnforcedStyle: aggressive
-      #   # bad
-      #   Post.where(user_id: active_users.pluck(:id))
-      #
-      class PluckInWhere < Base
-        include ActiveRecordHelper
-        include ConfigurableEnforcedStyle
-        extend AutoCorrector
-
-        MSG = 'Use `select` instead of `pluck` within `where` query method.'
-        RESTRICT_ON_SEND = %i[pluck].freeze
-
-        def on_send(node)
-          return unless in_where?(node)
-          return if style == :conservative && !root_receiver(node)&.const_type?
-
-          range = node.loc.selector
-
-          add_offense(range) do |corrector|
-            corrector.replace(range, 'select')
-          end
-        end
-
-        private
-
-        def root_receiver(node)
-          receiver = node.receiver
-
-          if receiver&.send_type?
-            root_receiver(receiver)
-          else
-            receiver
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pluralization_grammar.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pluralization_grammar.rb
deleted file mode 100644
index 24f6f1e660577..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/pluralization_grammar.rb
+++ /dev/null
@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for correct grammar when using ActiveSupport's
-      # core extensions to the numeric classes.
-      #
-      # @example
-      #   # bad
-      #   3.day.ago
-      #   1.months.ago
-      #
-      #   # good
-      #   3.days.ago
-      #   1.month.ago
-      class PluralizationGrammar < Base
-        extend AutoCorrector
-
-        SINGULAR_DURATION_METHODS = { second: :seconds,
-                                      minute: :minutes,
-                                      hour: :hours,
-                                      day: :days,
-                                      week: :weeks,
-                                      fortnight: :fortnights,
-                                      month: :months,
-                                      year: :years }.freeze
-
-        RESTRICT_ON_SEND = SINGULAR_DURATION_METHODS.keys + SINGULAR_DURATION_METHODS.values
-
-        PLURAL_DURATION_METHODS = SINGULAR_DURATION_METHODS.invert.freeze
-
-        MSG = 'Prefer `%<number>s.%<correct>s`.'
-
-        def on_send(node)
-          return unless duration_method?(node.method_name) && literal_number?(node.receiver) && offense?(node)
-
-          number, = *node.receiver
-
-          add_offense(node, message: message(number, node.method_name)) do |corrector|
-            method_name = node.loc.selector.source
-
-            corrector.replace(node.loc.selector, correct_method(method_name))
-          end
-        end
-
-        private
-
-        def message(number, method_name)
-          format(MSG, number: number, correct: correct_method(method_name))
-        end
-
-        def correct_method(method_name)
-          if plural_method?(method_name)
-            singularize(method_name)
-          else
-            pluralize(method_name)
-          end
-        end
-
-        def offense?(node)
-          number, = *node.receiver
-
-          (singular_receiver?(number) && plural_method?(node.method_name)) ||
-            (plural_receiver?(number) && singular_method?(node.method_name))
-        end
-
-        def plural_method?(method_name)
-          method_name.to_s.end_with?('s')
-        end
-
-        def singular_method?(method_name)
-          !plural_method?(method_name)
-        end
-
-        def singular_receiver?(number)
-          number.abs == 1
-        end
-
-        def plural_receiver?(number)
-          !singular_receiver?(number)
-        end
-
-        def literal_number?(node)
-          node && (node.int_type? || node.float_type?)
-        end
-
-        def pluralize(method_name)
-          SINGULAR_DURATION_METHODS.fetch(method_name.to_sym).to_s
-        end
-
-        def singularize(method_name)
-          PLURAL_DURATION_METHODS.fetch(method_name.to_sym).to_s
-        end
-
-        def duration_method?(method_name)
-          SINGULAR_DURATION_METHODS.key?(method_name) ||
-            PLURAL_DURATION_METHODS.key?(method_name)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/presence.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/presence.rb
deleted file mode 100644
index 2fbba874c1356..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/presence.rb
+++ /dev/null
@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks code that can be written more easily using
-      # `Object#presence` defined by Active Support.
-      #
-      # @example
-      #   # bad
-      #   a.present? ? a : nil
-      #
-      #   # bad
-      #   !a.present? ? nil : a
-      #
-      #   # bad
-      #   a.blank? ? nil : a
-      #
-      #   # bad
-      #   !a.blank? ? a : nil
-      #
-      #   # good
-      #   a.presence
-      #
-      # @example
-      #   # bad
-      #   a.present? ? a : b
-      #
-      #   # bad
-      #   !a.present? ? b : a
-      #
-      #   # bad
-      #   a.blank? ? b : a
-      #
-      #   # bad
-      #   !a.blank? ? a : b
-      #
-      #   # good
-      #   a.presence || b
-      class Presence < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
-
-        def_node_matcher :redundant_receiver_and_other, <<~PATTERN
-          {
-            (if
-              (send $_recv :present?)
-              _recv
-              $!begin
-            )
-            (if
-              (send $_recv :blank?)
-              $!begin
-              _recv
-            )
-          }
-        PATTERN
-
-        def_node_matcher :redundant_negative_receiver_and_other, <<~PATTERN
-          {
-            (if
-              (send (send $_recv :present?) :!)
-              $!begin
-              _recv
-            )
-            (if
-              (send (send $_recv :blank?) :!)
-              _recv
-              $!begin
-            )
-          }
-        PATTERN
-
-        def on_if(node)
-          return if ignore_if_node?(node)
-
-          redundant_receiver_and_other(node) do |receiver, other|
-            return if ignore_other_node?(other) || receiver.nil?
-
-            register_offense(node, receiver, other)
-          end
-
-          redundant_negative_receiver_and_other(node) do |receiver, other|
-            return if ignore_other_node?(other) || receiver.nil?
-
-            register_offense(node, receiver, other)
-          end
-        end
-
-        private
-
-        def register_offense(node, receiver, other)
-          add_offense(node, message: message(node, receiver, other)) do |corrector|
-            corrector.replace(node.source_range, replacement(receiver, other))
-          end
-        end
-
-        def ignore_if_node?(node)
-          node.elsif?
-        end
-
-        def ignore_other_node?(node)
-          node && (node.if_type? || node.rescue_type? || node.while_type?)
-        end
-
-        def message(node, receiver, other)
-          format(MSG,
-                 prefer: replacement(receiver, other),
-                 current: node.source)
-        end
-
-        def replacement(receiver, other)
-          or_source = if other&.send_type?
-                        build_source_for_or_method(other)
-                      elsif other.nil? || other.nil_type?
-                        ''
-                      else
-                        " || #{other.source}"
-                      end
-
-          "#{receiver.source}.presence" + or_source
-        end
-
-        def build_source_for_or_method(other)
-          if other.parenthesized? || other.method?('[]') || !other.arguments?
-            " || #{other.source}"
-          else
-            method = range_between(
-              other.source_range.begin_pos,
-              other.first_argument.source_range.begin_pos - 1
-            ).source
-
-            arguments = other.arguments.map(&:source).join(', ')
-
-            " || #{method}(#{arguments})"
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/present.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/present.rb
deleted file mode 100644
index 55b5bd923e921..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/present.rb
+++ /dev/null
@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for code that can be written with simpler conditionals
-      # using `Object#present?` defined by Active Support.
-      #
-      # Interaction with `Style/UnlessElse`:
-      # The configuration of `NotBlank` will not produce an offense in the
-      # context of `unless else` if `Style/UnlessElse` is inabled. This is
-      # to prevent interference between the autocorrection of the two cops.
-      #
-      # @example NotNilAndNotEmpty: true (default)
-      #   # Converts usages of `!nil? && !empty?` to `present?`
-      #
-      #   # bad
-      #   !foo.nil? && !foo.empty?
-      #
-      #   # bad
-      #   foo != nil && !foo.empty?
-      #
-      #   # good
-      #   foo.present?
-      #
-      # @example NotBlank: true (default)
-      #   # Converts usages of `!blank?` to `present?`
-      #
-      #   # bad
-      #   !foo.blank?
-      #
-      #   # bad
-      #   not foo.blank?
-      #
-      #   # good
-      #   foo.present?
-      #
-      # @example UnlessBlank: true (default)
-      #   # Converts usages of `unless blank?` to `if present?`
-      #
-      #   # bad
-      #   something unless foo.blank?
-      #
-      #   # good
-      #   something if foo.present?
-      class Present < Base
-        extend AutoCorrector
-
-        MSG_NOT_BLANK = 'Use `%<prefer>s` instead of `%<current>s`.'
-        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%<prefer>s` instead of ' \
-                                   '`%<current>s`.'
-        MSG_UNLESS_BLANK = 'Use `if %<prefer>s` instead of ' \
-                           '`%<current>s`.'
-        RESTRICT_ON_SEND = %i[!].freeze
-
-        def_node_matcher :exists_and_not_empty?, <<~PATTERN
-          (and
-              {
-                (send (send $_ :nil?) :!)
-                (send (send $_ :!) :!)
-                (send $_ :!= nil)
-                $_
-              }
-              {
-                (send (send $_ :empty?) :!)
-              }
-          )
-        PATTERN
-
-        def_node_matcher :not_blank?, '(send (send $_ :blank?) :!)'
-
-        def_node_matcher :unless_blank?, <<~PATTERN
-          (:if $(send $_ :blank?) {nil? (...)} ...)
-        PATTERN
-
-        def on_send(node)
-          return unless cop_config['NotBlank']
-
-          not_blank?(node) do |receiver|
-            message = format(MSG_NOT_BLANK, prefer: replacement(receiver), current: node.source)
-
-            add_offense(node, message: message) do |corrector|
-              autocorrect(corrector, node)
-            end
-          end
-        end
-
-        def on_and(node)
-          return unless cop_config['NotNilAndNotEmpty']
-
-          exists_and_not_empty?(node) do |var1, var2|
-            return unless var1 == var2
-
-            message = format(MSG_EXISTS_AND_NOT_EMPTY, prefer: replacement(var1), current: node.source)
-
-            add_offense(node, message: message) do |corrector|
-              autocorrect(corrector, node)
-            end
-          end
-        end
-
-        def on_or(node)
-          return unless cop_config['NilOrEmpty']
-
-          exists_and_not_empty?(node) do |var1, var2|
-            return unless var1 == var2
-
-            add_offense(node, message: MSG_EXISTS_AND_NOT_EMPTY) do |corrector|
-              autocorrect(corrector, node)
-            end
-          end
-        end
-
-        def on_if(node)
-          return unless cop_config['UnlessBlank']
-          return unless node.unless?
-          return if node.else? && config.for_cop('Style/UnlessElse')['Enabled']
-
-          unless_blank?(node) do |method_call, receiver|
-            range = unless_condition(node, method_call)
-            msg = format(MSG_UNLESS_BLANK, prefer: replacement(receiver),
-                                           current: range.source)
-            add_offense(range, message: msg) do |corrector|
-              autocorrect(corrector, node)
-            end
-          end
-        end
-
-        def autocorrect(corrector, node)
-          method_call, variable1 = unless_blank?(node)
-
-          if method_call
-            corrector.replace(node.loc.keyword, 'if')
-            range = method_call.loc.expression
-          else
-            variable1, _variable2 = exists_and_not_empty?(node) || not_blank?(node)
-            range = node.loc.expression
-          end
-
-          corrector.replace(range, replacement(variable1))
-        end
-
-        private
-
-        def unless_condition(node, method_call)
-          if node.modifier_form?
-            node.loc.keyword.join(node.loc.expression.end)
-          else
-            node.loc.expression.begin.join(method_call.loc.expression)
-          end
-        end
-
-        def replacement(node)
-          node.respond_to?(:source) ? "#{node.source}.present?" : 'present?'
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/rake_environment.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/rake_environment.rb
deleted file mode 100644
index fdb6f76924cbe..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/rake_environment.rb
+++ /dev/null
@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for Rake tasks without the `:environment` task
-      # dependency. The `:environment` task loads application code for other
-      # Rake tasks. Without it, tasks cannot make use of application code like
-      # models.
-      #
-      # You can ignore the offense if the task satisfies at least one of the
-      # following conditions:
-      #
-      # * The task does not need application code.
-      # * The task invokes the `:environment` task.
-      #
-      # @safety
-      #   Probably not a problem in most cases, but it is possible that calling `:environment` task
-      #   will break a behavior. It's also slower. E.g. some task that only needs one gem to be
-      #   loaded to run will run significantly faster without loading the whole application.
-      #
-      # @example
-      #   # bad
-      #   task :foo do
-      #     do_something
-      #   end
-      #
-      #   # good
-      #   task foo: :environment do
-      #     do_something
-      #   end
-      #
-      class RakeEnvironment < Base
-        extend AutoCorrector
-
-        MSG = 'Include `:environment` task as a dependency for all Rake tasks.'
-
-        def_node_matcher :task_definition?, <<~PATTERN
-          (block $(send nil? :task ...) ...)
-        PATTERN
-
-        def on_block(node)
-          task_definition?(node) do |task_method|
-            return if task_name(task_method) == :default
-            return if with_dependencies?(task_method)
-
-            add_offense(task_method) do |corrector|
-              task_name = task_method.arguments[0]
-              task_dependency = correct_task_dependency(task_name)
-
-              corrector.replace(task_name.loc.expression, task_dependency)
-            end
-          end
-        end
-
-        private
-
-        def correct_task_dependency(task_name)
-          if task_name.sym_type?
-            "#{task_name.source.delete(':|\'|"')}: :environment"
-          else
-            "#{task_name.source} => :environment"
-          end
-        end
-
-        def task_name(node)
-          first_arg = node.arguments[0]
-          case first_arg&.type
-          when :sym, :str
-            first_arg.value.to_sym
-          when :hash
-            return nil if first_arg.children.size != 1
-
-            pair = first_arg.children.first
-            key = pair.children.first
-            case key.type
-            when :sym, :str
-              key.value.to_sym
-            end
-          end
-        end
-
-        def with_dependencies?(node)
-          first_arg = node.arguments[0]
-          return false unless first_arg
-
-          if first_arg.hash_type?
-            with_hash_style_dependencies?(first_arg)
-          else
-            task_args = node.arguments[1]
-            return false unless task_args
-            return false unless task_args.hash_type?
-
-            with_hash_style_dependencies?(task_args)
-          end
-        end
-
-        def with_hash_style_dependencies?(hash_node)
-          deps = hash_node.pairs.first&.value
-          return false unless deps
-
-          case deps.type
-          when :array
-            !deps.values.empty?
-          else
-            true
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/read_write_attribute.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/read_write_attribute.rb
deleted file mode 100644
index 1f481a17771d4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/read_write_attribute.rb
+++ /dev/null
@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for the use of the `read_attribute` or `write_attribute`
-      # methods and recommends square brackets instead.
-      #
-      # If an attribute is missing from the instance (for example, when
-      # initialized by a partial `select`) then `read_attribute`
-      # will return nil, but square brackets will raise
-      # an `ActiveModel::MissingAttributeError`.
-      #
-      # Explicitly raising an error in this situation is preferable, and that
-      # is why rubocop recommends using square brackets.
-      #
-      # @example
-      #
-      #   # bad
-      #   x = read_attribute(:attr)
-      #   write_attribute(:attr, val)
-      #
-      #   # good
-      #   x = self[:attr]
-      #   self[:attr] = val
-      #
-      # When called from within a method with the same name as the attribute,
-      # `read_attribute` and `write_attribute` must be used to prevent an
-      # infinite loop:
-      #
-      # @example
-      #
-      #   # good
-      #   def foo
-      #     bar || read_attribute(:foo)
-      #   end
-      class ReadWriteAttribute < Base
-        extend AutoCorrector
-
-        MSG = 'Prefer `%<prefer>s`.'
-        RESTRICT_ON_SEND = %i[read_attribute write_attribute].freeze
-
-        def_node_matcher :read_write_attribute?, <<~PATTERN
-          {
-            (send nil? :read_attribute _)
-            (send nil? :write_attribute _ _)
-          }
-        PATTERN
-
-        def on_send(node)
-          return unless read_write_attribute?(node)
-          return if within_shadowing_method?(node)
-
-          add_offense(node, message: build_message(node)) do |corrector|
-            corrector.replace(node.source_range, node_replacement(node))
-          end
-        end
-
-        private
-
-        def within_shadowing_method?(node)
-          first_arg = node.first_argument
-          return false unless first_arg.respond_to?(:value)
-
-          enclosing_method = node.each_ancestor(:def).first
-          return false unless enclosing_method
-
-          shadowing_method_name = first_arg.value.to_s
-          shadowing_method_name << '=' if node.method?(:write_attribute)
-          enclosing_method.method?(shadowing_method_name)
-        end
-
-        def build_message(node)
-          if node.single_line?
-            single_line_message(node)
-          else
-            multi_line_message(node)
-          end
-        end
-
-        def single_line_message(node)
-          format(MSG, prefer: node_replacement(node))
-        end
-
-        def multi_line_message(node)
-          if node.method?(:read_attribute)
-            format(MSG, prefer: 'self[:attr]')
-          else
-            format(MSG, prefer: 'self[:attr] = val')
-          end
-        end
-
-        def node_replacement(node)
-          case node.method_name
-          when :read_attribute
-            read_attribute_replacement(node)
-          when :write_attribute
-            write_attribute_replacement(node)
-          end
-        end
-
-        def read_attribute_replacement(node)
-          "self[#{node.first_argument.source}]"
-        end
-
-        def write_attribute_replacement(node)
-          "self[#{node.first_argument.source}] = #{node.last_argument.source}"
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_allow_nil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_allow_nil.rb
deleted file mode 100644
index 9fb17bdf7308b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_allow_nil.rb
+++ /dev/null
@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks Rails model validations for a redundant `allow_nil` when
-      # `allow_blank` is present.
-      #
-      # @example
-      #   # bad
-      #   validates :x, length: { is: 5 }, allow_nil: true, allow_blank: true
-      #
-      #   # bad
-      #   validates :x, length: { is: 5 }, allow_nil: false, allow_blank: true
-      #
-      #   # bad
-      #   validates :x, length: { is: 5 }, allow_nil: false, allow_blank: false
-      #
-      #   # good
-      #   validates :x, length: { is: 5 }, allow_blank: true
-      #
-      #   # good
-      #   validates :x, length: { is: 5 }, allow_blank: false
-      #
-      #   # good
-      #   # Here, `nil` is valid but `''` is not
-      #   validates :x, length: { is: 5 }, allow_nil: true, allow_blank: false
-      #
-      class RedundantAllowNil < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG_SAME =
-          '`allow_nil` is redundant when `allow_blank` has the same value.'
-
-        MSG_ALLOW_NIL_FALSE =
-          '`allow_nil: false` is redundant when `allow_blank` is true.'
-
-        RESTRICT_ON_SEND = %i[validates].freeze
-
-        def on_send(node)
-          allow_nil, allow_blank = find_allow_nil_and_allow_blank(node)
-          return unless allow_nil && allow_blank
-
-          allow_nil_val = allow_nil.children.last
-          allow_blank_val = allow_blank.children.last
-
-          if allow_nil_val.type == allow_blank_val.type
-            register_offense(allow_nil, MSG_SAME)
-          elsif allow_nil_val.false_type? && allow_blank_val.true_type?
-            register_offense(allow_nil, MSG_ALLOW_NIL_FALSE)
-          end
-        end
-
-        private
-
-        def register_offense(allow_nil, message)
-          add_offense(allow_nil, message: message) do |corrector|
-            prv_sib = allow_nil.left_sibling
-            nxt_sib = allow_nil.right_sibling
-
-            if nxt_sib
-              corrector.remove(range_between(node_beg(allow_nil), node_beg(nxt_sib)))
-            elsif prv_sib
-              corrector.remove(range_between(node_end(prv_sib), node_end(allow_nil)))
-            else
-              corrector.remove(allow_nil.loc.expression)
-            end
-          end
-        end
-
-        def find_allow_nil_and_allow_blank(node)
-          allow_nil, allow_blank = nil
-
-          node.each_child_node do |child_node|
-            if child_node.pair_type?
-              key = child_node.children.first.source
-
-              allow_nil = child_node if key == 'allow_nil'
-              allow_blank = child_node if key == 'allow_blank'
-            end
-            return [allow_nil, allow_blank] if allow_nil && allow_blank
-
-            found_in_children_nodes = find_allow_nil_and_allow_blank(child_node)
-            return found_in_children_nodes if found_in_children_nodes
-          end
-
-          nil
-        end
-
-        def node_beg(node)
-          node.loc.expression.begin_pos
-        end
-
-        def node_end(node)
-          node.loc.expression.end_pos
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_foreign_key.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_foreign_key.rb
deleted file mode 100644
index e32d207aa14cc..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_foreign_key.rb
+++ /dev/null
@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Detects cases where the `:foreign_key` option on associations
-      # is redundant.
-      #
-      # @example
-      #   # bad
-      #   class Post
-      #     has_many :comments, foreign_key: 'post_id'
-      #   end
-      #
-      #   class Comment
-      #     belongs_to :post, foreign_key: 'post_id'
-      #   end
-      #
-      #   # good
-      #   class Post
-      #     has_many :comments
-      #   end
-      #
-      #   class Comment
-      #     belongs_to :author, foreign_key: 'user_id'
-      #   end
-      class RedundantForeignKey < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Specifying the default value for `foreign_key` is redundant.'
-        RESTRICT_ON_SEND = %i[belongs_to has_one has_many has_and_belongs_to_many].freeze
-
-        def_node_matcher :association_with_foreign_key, <<~PATTERN
-          (send nil? ${:belongs_to :has_one :has_many :has_and_belongs_to_many} ({sym str} $_)
-            $(hash <$(pair (sym :foreign_key) ({sym str} $_)) ...>)
-          )
-        PATTERN
-
-        def on_send(node)
-          association_with_foreign_key(node) do |type, name, options, foreign_key_pair, foreign_key|
-            if redundant?(node, type, name, options, foreign_key)
-              add_offense(foreign_key_pair.loc.expression) do |corrector|
-                range = range_with_surrounding_space(range: foreign_key_pair.source_range, side: :left)
-                range = range_with_surrounding_comma(range, :left)
-
-                corrector.remove(range)
-              end
-            end
-          end
-        end
-
-        private
-
-        def redundant?(node, association_type, association_name, options, foreign_key)
-          foreign_key.to_s == default_foreign_key(node, association_type, association_name, options)
-        end
-
-        def default_foreign_key(node, association_type, association_name, options)
-          if association_type == :belongs_to
-            "#{association_name}_id"
-          elsif (as = find_as_option(options))
-            "#{as}_id"
-          else
-            node.parent_module_name&.foreign_key
-          end
-        end
-
-        def find_as_option(options)
-          options.pairs.find do |pair|
-            pair.key.sym_type? && pair.key.value == :as
-          end&.value&.value
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_presence_validation_on_belongs_to.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_presence_validation_on_belongs_to.rb
deleted file mode 100644
index d9a877abc939a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_presence_validation_on_belongs_to.rb
+++ /dev/null
@@ -1,257 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Since Rails 5.0 the default for `belongs_to` is `optional: false`
-      # unless `config.active_record.belongs_to_required_by_default` is
-      # explicitly set to `false`. The presence validator is added
-      # automatically, and explicit presence validation is redundant.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because it changes the default error message
-      #   from "can't be blank" to "must exist".
-      #
-      # @example
-      #   # bad
-      #   belongs_to :user
-      #   validates :user, presence: true
-      #
-      #   # bad
-      #   belongs_to :user
-      #   validates :user_id, presence: true
-      #
-      #   # bad
-      #   belongs_to :author, foreign_key: :user_id
-      #   validates :user_id, presence: true
-      #
-      #   # good
-      #   belongs_to :user
-      #
-      #   # good
-      #   belongs_to :author, foreign_key: :user_id
-      #
-      class RedundantPresenceValidationOnBelongsTo < Base
-        include RangeHelp
-        extend AutoCorrector
-        extend TargetRailsVersion
-
-        MSG = 'Remove explicit presence validation for %<association>s.'
-        RESTRICT_ON_SEND = %i[validates].freeze
-
-        minimum_target_rails_version 5.0
-
-        # @!method presence_validation?(node)
-        #   Match a `validates` statement with a presence check
-        #
-        #   @example source that matches - by association
-        #     validates :user, presence: true
-        #
-        #   @example source that matches - by association
-        #     validates :name, :user, presence: true
-        #
-        #   @example source that matches - by a foreign key
-        #     validates :user_id, presence: true
-        #
-        #   @example source that DOES NOT match - strict validation
-        #     validates :user_id, presence: true, strict: true
-        #
-        #   @example source that DOES NOT match - custom strict validation
-        #     validates :user_id, presence: true, strict: MissingUserError
-        def_node_matcher :presence_validation?, <<~PATTERN
-          (
-            send nil? :validates
-            (sym $_)+
-            $[
-              (hash <$(pair (sym :presence) true) ...>)         # presence: true
-              !(hash <$(pair (sym :strict) {true const}) ...>)  # strict: true
-            ]
-          )
-        PATTERN
-
-        # @!method optional?(node)
-        #   Match a `belongs_to` association with an optional option in a hash
-        def_node_matcher :optional?, <<~PATTERN
-          (send nil? :belongs_to _ ... #optional_option?)
-        PATTERN
-
-        # @!method optional_option?(node)
-        #   Match an optional option in a hash
-        def_node_matcher :optional_option?, <<~PATTERN
-          {
-            (hash <(pair (sym :optional) true) ...>)   # optional: true
-            (hash <(pair (sym :required) false) ...>)  # required: false
-          }
-        PATTERN
-
-        # @!method any_belongs_to?(node, association:)
-        #   Match a class with `belongs_to` with no regard to `foreign_key` option
-        #
-        #   @example source that matches
-        #     belongs_to :user
-        #
-        #   @example source that matches - regardless of `foreign_key`
-        #     belongs_to :author, foreign_key: :user_id
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @param association [Symbol]
-        #   @return [Array<RuboCop::AST::Node>, nil] matching node
-        def_node_matcher :any_belongs_to?, <<~PATTERN
-          (begin
-            <
-              $(send nil? :belongs_to (sym %association) ...)
-              ...
-            >
-          )
-        PATTERN
-
-        # @!method belongs_to?(node, key:, fk:)
-        #   Match a class with a matching association, either by name or an explicit
-        #   `foreign_key` option
-        #
-        #   @example source that matches - fk matches `foreign_key` option
-        #     belongs_to :author, foreign_key: :user_id
-        #
-        #   @example source that matches - key matches association name
-        #     belongs_to :user
-        #
-        #   @example source that does not match - explicit `foreign_key` does not match
-        #     belongs_to :user, foreign_key: :account_id
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @param key [Symbol] e.g. `:user`
-        #   @param fk [Symbol] e.g. `:user_id`
-        #   @return [Array<RuboCop::AST::Node>] matching nodes
-        def_node_matcher :belongs_to?, <<~PATTERN
-          (begin
-            <
-              ${
-                #belongs_to_without_fk?(%key)         # belongs_to :user
-                #belongs_to_with_a_matching_fk?(%fk)  # belongs_to :author, foreign_key: :user_id
-              }
-              ...
-            >
-          )
-        PATTERN
-
-        # @!method belongs_to_without_fk?(node, key)
-        #   Match a matching `belongs_to` association, without an explicit `foreign_key` option
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @param key [Symbol] e.g. `:user`
-        #   @return [Array<RuboCop::AST::Node>] matching nodes
-        def_node_matcher :belongs_to_without_fk?, <<~PATTERN
-          {
-            (send nil? :belongs_to (sym %1))        # belongs_to :user
-            (send nil? :belongs_to (sym %1) !hash)  # belongs_to :user, -> { not_deleted }
-            (send nil? :belongs_to (sym %1) !(hash <(pair (sym :foreign_key) _) ...>))
-          }
-        PATTERN
-
-        # @!method belongs_to_with_a_matching_fk?(node, fk)
-        #   Match a matching `belongs_to` association with a matching explicit `foreign_key` option
-        #
-        #   @example source that matches
-        #     belongs_to :author, foreign_key: :user_id
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @param fk [Symbol] e.g. `:user_id`
-        #   @return [Array<RuboCop::AST::Node>] matching nodes
-        def_node_matcher :belongs_to_with_a_matching_fk?, <<~PATTERN
-          (send nil? :belongs_to ... (hash <(pair (sym :foreign_key) (sym %1)) ...>))
-        PATTERN
-
-        def on_send(node)
-          presence_validation?(node) do |all_keys, options, presence|
-            keys = non_optional_belongs_to(node.parent, all_keys)
-            return if keys.none?
-
-            add_offense_and_correct(node, all_keys, keys, options, presence)
-          end
-        end
-
-        private
-
-        def add_offense_and_correct(node, all_keys, keys, options, presence)
-          add_offense(presence, message: message_for(keys)) do |corrector|
-            if options.children.one? # `presence: true` is the only option
-              if keys == all_keys
-                remove_validation(corrector, node)
-              else
-                remove_keys_from_validation(corrector, node, keys)
-              end
-            elsif keys == all_keys
-              remove_presence_option(corrector, presence)
-            else
-              extract_validation_for_keys(corrector, node, keys, options)
-            end
-          end
-        end
-
-        def message_for(keys)
-          display_keys = keys.map { |key| "`#{key}`" }.join('/')
-          format(MSG, association: display_keys)
-        end
-
-        def non_optional_belongs_to(node, keys)
-          keys.select do |key|
-            belongs_to = belongs_to_for(node, key)
-            belongs_to && !optional?(belongs_to)
-          end
-        end
-
-        def belongs_to_for(model_class_node, key)
-          if key.to_s.end_with?('_id')
-            normalized_key = key.to_s.delete_suffix('_id').to_sym
-            belongs_to?(model_class_node, key: normalized_key, fk: key)
-          else
-            any_belongs_to?(model_class_node, association: key)
-          end
-        end
-
-        def remove_validation(corrector, node)
-          corrector.remove(validation_range(node))
-        end
-
-        def remove_keys_from_validation(corrector, node, keys)
-          keys.each do |key|
-            key_node = node.arguments.find { |arg| arg.value == key }
-            key_range = range_with_surrounding_space(
-              range: range_with_surrounding_comma(key_node.source_range, :right),
-              side: :right
-            )
-            corrector.remove(key_range)
-          end
-        end
-
-        def remove_presence_option(corrector, presence)
-          range = range_with_surrounding_comma(
-            range_with_surrounding_space(range: presence.source_range, side: :left),
-            :left
-          )
-          corrector.remove(range)
-        end
-
-        def extract_validation_for_keys(corrector, node, keys, options)
-          indentation = ' ' * node.source_range.column
-          options_without_presence = options.children.reject { |pair| pair.key.value == :presence }
-          source = [
-            indentation,
-            'validates ',
-            keys.map(&:inspect).join(', '),
-            ', ',
-            options_without_presence.map(&:source).join(', '),
-            "\n"
-          ].join
-
-          remove_keys_from_validation(corrector, node, keys)
-          corrector.insert_after(validation_range(node), source)
-        end
-
-        def validation_range(node)
-          range_by_whole_lines(node.source_range, include_final_newline: true)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_receiver_in_with_options.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_receiver_in_with_options.rb
deleted file mode 100644
index f289e76217102..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_receiver_in_with_options.rb
+++ /dev/null
@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for redundant receiver in `with_options`.
-      # Receiver is implicit from Rails 4.2 or higher.
-      #
-      # @example
-      #   # bad
-      #   class Account < ApplicationRecord
-      #     with_options dependent: :destroy do |assoc|
-      #       assoc.has_many :customers
-      #       assoc.has_many :products
-      #       assoc.has_many :invoices
-      #       assoc.has_many :expenses
-      #     end
-      #   end
-      #
-      #   # good
-      #   class Account < ApplicationRecord
-      #     with_options dependent: :destroy do
-      #       has_many :customers
-      #       has_many :products
-      #       has_many :invoices
-      #       has_many :expenses
-      #     end
-      #   end
-      #
-      # @example
-      #   # bad
-      #   with_options options: false do |merger|
-      #     merger.invoke(merger.something)
-      #   end
-      #
-      #   # good
-      #   with_options options: false do
-      #     invoke(something)
-      #   end
-      #
-      #   # good
-      #   client = Client.new
-      #   with_options options: false do |merger|
-      #     client.invoke(merger.something, something)
-      #   end
-      #
-      #   # ok
-      #   # When `with_options` includes a block, all scoping scenarios
-      #   # cannot be evaluated. Thus, it is ok to include the explicit
-      #   # receiver.
-      #   with_options options: false do |merger|
-      #     merger.invoke
-      #     with_another_method do |another_receiver|
-      #       merger.invoke(another_receiver)
-      #     end
-      #   end
-      class RedundantReceiverInWithOptions < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Redundant receiver in `with_options`.'
-
-        def_node_matcher :with_options?, <<~PATTERN
-          (block
-            (send nil? :with_options
-              (...))
-            (args
-              $_arg)
-            $_body)
-        PATTERN
-
-        def_node_search :all_block_nodes_in, <<~PATTERN
-          (block ...)
-        PATTERN
-
-        def_node_search :all_send_nodes_in, <<~PATTERN
-          (send ...)
-        PATTERN
-
-        def on_block(node)
-          with_options?(node) do |arg, body|
-            return if body.nil?
-            return unless all_block_nodes_in(body).count.zero?
-
-            send_nodes = all_send_nodes_in(body)
-
-            if send_nodes.all? { |n| same_value?(arg, n.receiver) }
-              send_nodes.each do |send_node|
-                receiver = send_node.receiver
-                add_offense(receiver.source_range) do |corrector|
-                  autocorrect(corrector, send_node)
-                end
-              end
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          corrector.remove(node.receiver.source_range)
-          corrector.remove(node.loc.dot)
-          corrector.remove(block_argument_range(node))
-        end
-
-        def block_argument_range(node)
-          block_node = node.each_ancestor(:block).first
-          block_argument = block_node.children[1].source_range
-
-          range_between(
-            search_begin_pos_of_space_before_block_argument(
-              block_argument.begin_pos
-            ),
-            block_argument.end_pos
-          )
-        end
-
-        def search_begin_pos_of_space_before_block_argument(begin_pos)
-          position = begin_pos - 1
-
-          if processed_source.raw_source[position] == ' '
-            search_begin_pos_of_space_before_block_argument(position)
-          else
-            begin_pos
-          end
-        end
-
-        def same_value?(arg_node, recv_node)
-          recv_node && recv_node.children[0] == arg_node.children[0]
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_travel_back.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_travel_back.rb
deleted file mode 100644
index f26c08677da66..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/redundant_travel_back.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for redundant `travel_back` calls.
-      # Since Rails 5.2, `travel_back` is automatically called at the end of the test.
-      #
-      # @example
-      #
-      #   # bad
-      #   def teardown
-      #     do_something
-      #     travel_back
-      #   end
-      #
-      #   # good
-      #   def teardown
-      #     do_something
-      #   end
-      #
-      #   # bad
-      #   after do
-      #     do_something
-      #     travel_back
-      #   end
-      #
-      #   # good
-      #   after do
-      #     do_something
-      #   end
-      #
-      class RedundantTravelBack < Base
-        include RangeHelp
-        extend AutoCorrector
-        extend TargetRailsVersion
-
-        minimum_target_rails_version 5.2
-
-        MSG = 'Redundant `travel_back` detected.'
-        RESTRICT_ON_SEND = %i[travel_back].freeze
-
-        def on_send(node)
-          return unless node.each_ancestor(:def, :block).any? do |ancestor|
-            method_name = ancestor.def_type? ? :teardown : :after
-
-            ancestor.method?(method_name)
-          end
-
-          add_offense(node) do |corrector|
-            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/reflection_class_name.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/reflection_class_name.rb
deleted file mode 100644
index 2de89b84ac2f0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/reflection_class_name.rb
+++ /dev/null
@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks if the value of the option `class_name`, in
-      # the definition of a reflection is a string.
-      #
-      # @safety
-      #   This cop is unsafe because it cannot be determined whether
-      #   constant or method return value specified to `class_name` is a string.
-      #
-      # @example
-      #   # bad
-      #   has_many :accounts, class_name: Account
-      #   has_many :accounts, class_name: Account.name
-      #
-      #   # good
-      #   has_many :accounts, class_name: 'Account'
-      class ReflectionClassName < Base
-        MSG = 'Use a string value for `class_name`.'
-        RESTRICT_ON_SEND = %i[has_many has_one belongs_to].freeze
-        ALLOWED_REFLECTION_CLASS_TYPES = %i[dstr str sym].freeze
-
-        def_node_matcher :association_with_reflection, <<~PATTERN
-          (send nil? {:has_many :has_one :belongs_to} _ _ ?
-            (hash <$#reflection_class_name ...>)
-          )
-        PATTERN
-
-        def_node_matcher :reflection_class_name, <<~PATTERN
-          (pair (sym :class_name) #reflection_class_value?)
-        PATTERN
-
-        def on_send(node)
-          association_with_reflection(node) do |reflection_class_name|
-            add_offense(reflection_class_name.loc.expression)
-          end
-        end
-
-        private
-
-        def reflection_class_value?(class_value)
-          if class_value.send_type?
-            !class_value.method?(:to_s) || class_value.receiver&.const_type?
-          else
-            !ALLOWED_REFLECTION_CLASS_TYPES.include?(class_value.type)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/refute_methods.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/refute_methods.rb
deleted file mode 100644
index eb86dee436573..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/refute_methods.rb
+++ /dev/null
@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      #
-      # Use `assert_not` methods instead of `refute` methods.
-      #
-      # @example EnforcedStyle: assert_not (default)
-      #   # bad
-      #   refute false
-      #   refute_empty [1, 2, 3]
-      #   refute_equal true, false
-      #
-      #   # good
-      #   assert_not false
-      #   assert_not_empty [1, 2, 3]
-      #   assert_not_equal true, false
-      #
-      # @example EnforcedStyle: refute
-      #   # bad
-      #   assert_not false
-      #   assert_not_empty [1, 2, 3]
-      #   assert_not_equal true, false
-      #
-      #   # good
-      #   refute false
-      #   refute_empty [1, 2, 3]
-      #   refute_equal true, false
-      #
-      class RefuteMethods < Base
-        include ConfigurableEnforcedStyle
-        extend AutoCorrector
-
-        MSG = 'Prefer `%<good_method>s` over `%<bad_method>s`.'
-
-        CORRECTIONS = {
-          refute:             :assert_not,
-          refute_empty:       :assert_not_empty,
-          refute_equal:       :assert_not_equal,
-          refute_in_delta:    :assert_not_in_delta,
-          refute_in_epsilon:  :assert_not_in_epsilon,
-          refute_includes:    :assert_not_includes,
-          refute_instance_of: :assert_not_instance_of,
-          refute_kind_of:     :assert_not_kind_of,
-          refute_nil:         :assert_not_nil,
-          refute_operator:    :assert_not_operator,
-          refute_predicate:   :assert_not_predicate,
-          refute_respond_to:  :assert_not_respond_to,
-          refute_same:        :assert_not_same,
-          refute_match:       :assert_no_match
-        }.freeze
-
-        REFUTE_METHODS = CORRECTIONS.keys.freeze
-        ASSERT_NOT_METHODS = CORRECTIONS.values.freeze
-
-        RESTRICT_ON_SEND = REFUTE_METHODS + ASSERT_NOT_METHODS
-
-        def_node_matcher :offensive?, '(send nil? #bad_method? ...)'
-
-        def on_send(node)
-          return unless offensive?(node)
-
-          method_name = node.method_name
-          message = offense_message(method_name)
-          range = node.loc.selector
-
-          add_offense(range, message: message) do |corrector|
-            corrector.replace(range, convert_good_method(method_name))
-          end
-        end
-
-        private
-
-        def bad_method?(method_name)
-          if style == :assert_not
-            REFUTE_METHODS.include?(method_name)
-          else
-            ASSERT_NOT_METHODS.include?(method_name)
-          end
-        end
-
-        def offense_message(method_name)
-          format(
-            MSG,
-            bad_method: method_name,
-            good_method: convert_good_method(method_name)
-          )
-        end
-
-        def convert_good_method(bad_method)
-          if style == :assert_not
-            CORRECTIONS.fetch(bad_method)
-          else
-            CORRECTIONS.invert.fetch(bad_method)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/relative_date_constant.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/relative_date_constant.rb
deleted file mode 100644
index ac57ef0350d9c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/relative_date_constant.rb
+++ /dev/null
@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks whether constant value isn't relative date.
-      # Because the relative date will be evaluated only once.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because its dependence on the constant is not corrected.
-      #
-      # @example
-      #   # bad
-      #   class SomeClass
-      #     EXPIRED_AT = 1.week.since
-      #   end
-      #
-      #   # good
-      #   class SomeClass
-      #     EXPIRES = 1.week
-      #
-      #     def self.expired_at
-      #       EXPIRES.since
-      #     end
-      #   end
-      #
-      #   # good
-      #   class SomeClass
-      #     def self.expired_at
-      #       1.week.since
-      #     end
-      #   end
-      class RelativeDateConstant < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Do not assign `%<method_name>s` to constants as it ' \
-              'will be evaluated only once.'
-        RELATIVE_DATE_METHODS = %i[since from_now after ago until before yesterday tomorrow].to_set.freeze
-
-        def on_casgn(node)
-          nested_relative_date(node) do |method_name|
-            add_offense(node, message: message(method_name)) do |corrector|
-              autocorrect(corrector, node)
-            end
-          end
-        end
-
-        def on_masgn(node)
-          lhs, rhs = *node
-
-          return unless rhs&.array_type?
-
-          lhs.children.zip(rhs.children).each do |(name, value)|
-            next unless name.casgn_type?
-
-            nested_relative_date(value) do |method_name|
-              add_offense(offense_range(name, value), message: message(method_name)) do |corrector|
-                autocorrect(corrector, node)
-              end
-            end
-          end
-        end
-
-        def on_or_asgn(node)
-          relative_date_or_assignment(node) do |method_name|
-            add_offense(node, message: format(MSG, method_name: method_name))
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          return unless node.casgn_type?
-
-          scope, const_name, value = *node
-          return unless scope.nil?
-
-          indent = ' ' * node.loc.column
-          new_code = ["def self.#{const_name.downcase}",
-                      "#{indent}#{value.source}",
-                      'end'].join("\n#{indent}")
-
-          corrector.replace(node.source_range, new_code)
-        end
-
-        def message(method_name)
-          format(MSG, method_name: method_name)
-        end
-
-        def offense_range(name, value)
-          range_between(name.loc.expression.begin_pos, value.loc.expression.end_pos)
-        end
-
-        def nested_relative_date(node, &callback)
-          return if node.nil? || node.block_type?
-
-          node.each_child_node do |child|
-            nested_relative_date(child, &callback)
-          end
-
-          relative_date(node, &callback)
-        end
-
-        def_node_matcher :relative_date_or_assignment, <<~PATTERN
-          (:or_asgn (casgn _ _) (send _ $RELATIVE_DATE_METHODS))
-        PATTERN
-
-        def_node_matcher :relative_date, <<~PATTERN
-          (send _ $RELATIVE_DATE_METHODS)
-        PATTERN
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/render_inline.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/render_inline.rb
deleted file mode 100644
index 6d7db676c2590..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/render_inline.rb
+++ /dev/null
@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Looks for inline rendering within controller actions.
-      #
-      # @example
-      #   # bad
-      #   class ProductsController < ApplicationController
-      #     def index
-      #       render inline: "<% products.each do |p| %><p><%= p.name %></p><% end %>", type: :erb
-      #     end
-      #   end
-      #
-      #   # good
-      #   # app/views/products/index.html.erb
-      #   # <% products.each do |p| %>
-      #   #   <p><%= p.name %></p>
-      #   # <% end %>
-      #
-      #   class ProductsController < ApplicationController
-      #     def index
-      #     end
-      #   end
-      #
-      class RenderInline < Base
-        MSG = 'Prefer using a template over inline rendering.'
-        RESTRICT_ON_SEND = %i[render].freeze
-
-        def_node_matcher :render_with_inline_option?, <<~PATTERN
-          (send nil? :render (hash <(pair {(sym :inline) (str "inline")} _) ...>))
-        PATTERN
-
-        def on_send(node)
-          add_offense(node) if render_with_inline_option?(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/render_plain_text.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/render_plain_text.rb
deleted file mode 100644
index 0736bb3c28246..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/render_plain_text.rb
+++ /dev/null
@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Identifies places where `render text:` can be
-      # replaced with `render plain:`.
-      #
-      # @example
-      #   # bad - explicit MIME type to `text/plain`
-      #   render text: 'Ruby!', content_type: 'text/plain'
-      #
-      #   # good - short and precise
-      #   render plain: 'Ruby!'
-      #
-      #   # good - explicit MIME type not to `text/plain`
-      #   render text: 'Ruby!', content_type: 'text/html'
-      #
-      # @example ContentTypeCompatibility: true (default)
-      #   # good - sets MIME type to `text/html`
-      #   render text: 'Ruby!'
-      #
-      # @example ContentTypeCompatibility: false
-      #   # bad - sets MIME type to `text/html`
-      #   render text: 'Ruby!'
-      #
-      class RenderPlainText < Base
-        extend AutoCorrector
-
-        MSG = 'Prefer `render plain:` over `render text:`.'
-        RESTRICT_ON_SEND = %i[render].freeze
-
-        def_node_matcher :render_plain_text?, <<~PATTERN
-          (send nil? :render $(hash <$(pair (sym :text) $_) ...>))
-        PATTERN
-
-        def on_send(node)
-          render_plain_text?(node) do |options_node, option_node, option_value|
-            content_type_node = find_content_type(options_node)
-            return unless compatible_content_type?(content_type_node)
-
-            add_offense(node) do |corrector|
-              rest_options = options_node.pairs - [option_node, content_type_node].compact
-
-              corrector.replace(node, replacement(rest_options, option_value))
-            end
-          end
-        end
-
-        private
-
-        def find_content_type(node)
-          node.pairs.find { |p| p.key.value.to_sym == :content_type }
-        end
-
-        def compatible_content_type?(node)
-          (node && node.value.value == 'text/plain') ||
-            (!node && !cop_config['ContentTypeCompatibility'])
-        end
-
-        def replacement(rest_options, option_value)
-          if rest_options.any?
-            "render plain: #{option_value.source}, #{rest_options.map(&:source).join(', ')}"
-          else
-            "render plain: #{option_value.source}"
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/request_referer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/request_referer.rb
deleted file mode 100644
index 4ad0f3a23712d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/request_referer.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for consistent uses of `request.referer` or
-      # `request.referrer`, depending on the cop's configuration.
-      #
-      # @example EnforcedStyle: referer (default)
-      #   # bad
-      #   request.referrer
-      #
-      #   # good
-      #   request.referer
-      #
-      # @example EnforcedStyle: referrer
-      #   # bad
-      #   request.referer
-      #
-      #   # good
-      #   request.referrer
-      class RequestReferer < Base
-        include ConfigurableEnforcedStyle
-        extend AutoCorrector
-
-        MSG = 'Use `request.%<prefer>s` instead of ' \
-              '`request.%<current>s`.'
-        RESTRICT_ON_SEND = %i[referer referrer].freeze
-
-        def_node_matcher :referer?, <<~PATTERN
-          (send (send nil? :request) {:referer :referrer})
-        PATTERN
-
-        def on_send(node)
-          referer?(node) do
-            return unless node.method?(wrong_method_name)
-
-            add_offense(node.source_range) do |corrector|
-              corrector.replace(node, "request.#{style}")
-            end
-          end
-        end
-
-        private
-
-        def message(_range)
-          format(MSG, prefer: style, current: wrong_method_name)
-        end
-
-        def wrong_method_name
-          style == :referer ? :referrer : :referer
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/require_dependency.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/require_dependency.rb
deleted file mode 100644
index f6e444a4e6fa2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/require_dependency.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for the usage of `require_dependency`.
-      #
-      # `require_dependency` is an obsolete method for Rails applications running in Zeitwerk mode.
-      # In Zeitwerk mode, the semantics should match Ruby's and no need to be defensive with load order,
-      # just refer to classes and modules normally.
-      # If the constant name is dynamic, camelize if needed, and constantize.
-      #
-      # Applications running in Zeitwerk mode should not use `require_dependency`.
-      #
-      # NOTE: This cop is disabled by default. Please enable it if you are using Zeitwerk mode.
-      #
-      # @example
-      #   # bad
-      #   require_dependency 'some_lib'
-      class RequireDependency < Base
-        extend TargetRailsVersion
-
-        minimum_target_rails_version 6.0
-
-        MSG = 'Do not use `require_dependency` with Zeitwerk mode.'
-        RESTRICT_ON_SEND = %i[require_dependency].freeze
-
-        def_node_matcher :require_dependency_call?, <<~PATTERN
-          (send {nil? (const _ :Kernel)} :require_dependency _)
-        PATTERN
-
-        def on_send(node)
-          require_dependency_call?(node) { add_offense(node) }
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/reversible_migration.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/reversible_migration.rb
deleted file mode 100644
index ceb9940379ea1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/reversible_migration.rb
+++ /dev/null
@@ -1,374 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks whether the change method of the migration file is
-      # reversible.
-      #
-      # @example
-      #   # bad
-      #   def change
-      #     change_table :users do |t|
-      #       t.remove :name
-      #     end
-      #   end
-      #
-      #   # good
-      #   def change
-      #     create_table :users do |t|
-      #       t.string :name
-      #     end
-      #   end
-      #
-      #   # good
-      #   def change
-      #     reversible do |dir|
-      #       change_table :users do |t|
-      #         dir.up do
-      #           t.column :name, :string
-      #         end
-      #
-      #         dir.down do
-      #           t.remove :name
-      #         end
-      #       end
-      #     end
-      #   end
-      #
-      # @example
-      #   # drop_table
-      #
-      #   # bad
-      #   def change
-      #     drop_table :users
-      #   end
-      #
-      #   # good
-      #   def change
-      #     drop_table :users do |t|
-      #       t.string :name
-      #     end
-      #   end
-      #
-      # @example
-      #   # change_column_default
-      #
-      #   # bad
-      #   def change
-      #     change_column_default(:suppliers, :qualification, 'new')
-      #   end
-      #
-      #   # good
-      #   def change
-      #     change_column_default(:posts, :state, from: nil, to: "draft")
-      #   end
-      #
-      # @example
-      #   # remove_column
-      #
-      #   # bad
-      #   def change
-      #     remove_column(:suppliers, :qualification)
-      #   end
-      #
-      #   # good
-      #   def change
-      #     remove_column(:suppliers, :qualification, :string)
-      #   end
-      #
-      # @example
-      #   # remove_foreign_key
-      #
-      #   # bad
-      #   def change
-      #     remove_foreign_key :accounts, column: :owner_id
-      #   end
-      #
-      #   # good
-      #   def change
-      #     remove_foreign_key :accounts, :branches
-      #   end
-      #
-      #   # good
-      #   def change
-      #     remove_foreign_key :accounts, to_table: :branches
-      #   end
-      #
-      # @example
-      #   # change_table
-      #
-      #   # bad
-      #   def change
-      #     change_table :users do |t|
-      #       t.remove :name
-      #       t.change_default :authorized, 1
-      #       t.change :price, :string
-      #     end
-      #   end
-      #
-      #   # good
-      #   def change
-      #     change_table :users do |t|
-      #       t.string :name
-      #     end
-      #   end
-      #
-      #   # good
-      #   def change
-      #     reversible do |dir|
-      #       change_table :users do |t|
-      #         dir.up do
-      #           t.change :price, :string
-      #         end
-      #
-      #         dir.down do
-      #           t.change :price, :integer
-      #         end
-      #       end
-      #     end
-      #   end
-      #
-      # @example
-      #   # remove_columns
-      #
-      #   # bad
-      #   def change
-      #     remove_columns :users, :name, :email
-      #   end
-      #
-      #   # good
-      #   def change
-      #     reversible do |dir|
-      #       dir.up do
-      #         remove_columns :users, :name, :email
-      #       end
-      #
-      #       dir.down do
-      #         add_column :users, :name, :string
-      #         add_column :users, :email, :string
-      #       end
-      #     end
-      #   end
-      #
-      #   # good (Rails >= 6.1, see https://github.com/rails/rails/pull/36589)
-      #   def change
-      #     remove_columns :users, :name, :email, type: :string
-      #   end
-      #
-      # @example
-      #   # remove_index
-      #
-      #   # bad
-      #   def change
-      #     remove_index :users, name: :index_users_on_email
-      #   end
-      #
-      #   # good
-      #   def change
-      #     remove_index :users, :email
-      #   end
-      #
-      #   # good
-      #   def change
-      #     remove_index :users, column: :email
-      #   end
-      #
-      # @see https://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html
-      class ReversibleMigration < Base
-        include MigrationsHelper
-
-        MSG = '%<action>s is not reversible.'
-
-        def_node_matcher :irreversible_schema_statement_call, <<~PATTERN
-          (send nil? ${:change_column :execute} ...)
-        PATTERN
-
-        def_node_matcher :drop_table_call, <<~PATTERN
-          (send nil? :drop_table ...)
-        PATTERN
-
-        def_node_matcher :remove_column_call, <<~PATTERN
-          (send nil? :remove_column $...)
-        PATTERN
-
-        def_node_matcher :remove_foreign_key_call, <<~PATTERN
-          (send nil? :remove_foreign_key _ $_)
-        PATTERN
-
-        def_node_matcher :change_table_call, <<~PATTERN
-          (send nil? :change_table $_ ...)
-        PATTERN
-
-        def_node_matcher :remove_columns_call, <<~PATTERN
-          (send nil? :remove_columns ... $_)
-        PATTERN
-
-        def_node_matcher :remove_index_call, <<~PATTERN
-          (send nil? :remove_index _ $_)
-        PATTERN
-
-        def on_send(node)
-          return unless in_migration?(node) && within_change_method?(node)
-          return if within_reversible_or_up_only_block?(node)
-
-          check_irreversible_schema_statement_node(node)
-          check_drop_table_node(node)
-          check_reversible_hash_node(node)
-          check_remove_column_node(node)
-          check_remove_foreign_key_node(node)
-          check_remove_columns_node(node)
-          check_remove_index_node(node)
-        end
-
-        def on_block(node)
-          return unless in_migration?(node) && within_change_method?(node)
-          return if within_reversible_or_up_only_block?(node)
-          return if node.body.nil?
-
-          check_change_table_node(node.send_node, node.body)
-        end
-
-        private
-
-        def check_irreversible_schema_statement_node(node)
-          irreversible_schema_statement_call(node) do |method_name|
-            add_offense(node, message: format(MSG, action: method_name))
-          end
-        end
-
-        def check_drop_table_node(node)
-          drop_table_call(node) do
-            unless node.parent.block_type? || node.last_argument.block_pass_type?
-              add_offense(
-                node,
-                message: format(MSG, action: 'drop_table(without block)')
-              )
-            end
-          end
-        end
-
-        def check_reversible_hash_node(node)
-          return if reversible_change_table_call?(node)
-
-          add_offense(
-            node,
-            message: format(
-              MSG, action: "#{node.method_name}(without :from and :to)"
-            )
-          )
-        end
-
-        def check_remove_column_node(node)
-          remove_column_call(node) do |args|
-            if args.to_a.size < 3
-              add_offense(
-                node,
-                message: format(MSG, action: 'remove_column(without type)')
-              )
-            end
-          end
-        end
-
-        def check_remove_foreign_key_node(node)
-          remove_foreign_key_call(node) do |arg|
-            if arg.hash_type? && !all_hash_key?(arg, :to_table)
-              add_offense(node, message: format(MSG, action: 'remove_foreign_key(without table)'))
-            end
-          end
-        end
-
-        def check_change_table_node(node, block)
-          change_table_call(node) do |arg|
-            if block.send_type?
-              check_change_table_offense(arg, block)
-            else
-              block.each_child_node(:send) do |child_node|
-                check_change_table_offense(arg, child_node)
-              end
-            end
-          end
-        end
-
-        def check_remove_columns_node(node)
-          remove_columns_call(node) do |args|
-            unless all_hash_key?(args, :type) && target_rails_version >= 6.1
-              action = target_rails_version >= 6.1 ? 'remove_columns(without type)' : 'remove_columns'
-
-              add_offense(
-                node,
-                message: format(MSG, action: action)
-              )
-            end
-          end
-        end
-
-        def check_remove_index_node(node)
-          remove_index_call(node) do |args|
-            if args.hash_type? && !all_hash_key?(args, :column)
-              add_offense(
-                node,
-                message: format(MSG, action: 'remove_index(without column)')
-              )
-            end
-          end
-        end
-
-        def check_change_table_offense(receiver, node)
-          method_name = node.method_name
-          return if receiver != node.receiver &&
-                    reversible_change_table_call?(node)
-
-          action = if method_name == :remove
-                     target_rails_version >= 6.1 ? 't.remove (without type)' : 't.remove'
-                   else
-                     "change_table(with #{method_name})"
-                   end
-
-          add_offense(
-            node,
-            message: format(MSG, action: action)
-          )
-        end
-
-        def reversible_change_table_call?(node)
-          case node.method_name
-          when :change
-            false
-          when :remove
-            target_rails_version >= 6.1 && all_hash_key?(node.arguments.last, :type)
-          when :change_default, :change_column_default, :change_table_comment,
-               :change_column_comment
-            all_hash_key?(node.arguments.last, :from, :to)
-          else
-            true
-          end
-        end
-
-        def within_change_method?(node)
-          node.each_ancestor(:def).any? do |ancestor|
-            ancestor.method?(:change)
-          end
-        end
-
-        def within_reversible_or_up_only_block?(node)
-          node.each_ancestor(:block).any? do |ancestor|
-            (ancestor.block_type? &&
-              ancestor.send_node.method?(:reversible)) ||
-              ancestor.send_node.method?(:up_only)
-          end
-        end
-
-        def all_hash_key?(args, *keys)
-          return false unless args&.hash_type?
-
-          hash_keys = args.keys.map do |key|
-            key.children.first.to_sym
-          end
-
-          (hash_keys & keys).sort == keys
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/reversible_migration_method_definition.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/reversible_migration_method_definition.rb
deleted file mode 100644
index acc506cadff24..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/reversible_migration_method_definition.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks whether the migration implements
-      # either a `change` method or both an `up` and a `down`
-      # method.
-      #
-      # @example
-      #   # bad
-      #   class SomeMigration < ActiveRecord::Migration[6.0]
-      #     def up
-      #       # up migration
-      #     end
-      #
-      #     # <----- missing down method
-      #   end
-      #
-      #   class SomeMigration < ActiveRecord::Migration[6.0]
-      #     # <----- missing up method
-      #
-      #     def down
-      #       # down migration
-      #     end
-      #   end
-      #
-      #   # good
-      #   class SomeMigration < ActiveRecord::Migration[6.0]
-      #     def change
-      #       # reversible migration
-      #     end
-      #   end
-      #
-      #   # good
-      #   class SomeMigration < ActiveRecord::Migration[6.0]
-      #     def up
-      #       # up migration
-      #     end
-      #
-      #     def down
-      #       # down migration
-      #     end
-      #   end
-      class ReversibleMigrationMethodDefinition < Base
-        include MigrationsHelper
-
-        MSG = 'Migrations must contain either a `change` method, or ' \
-              'both an `up` and a `down` method.'
-
-        def_node_matcher :change_method?, <<~PATTERN
-          `(def :change (args) _)
-        PATTERN
-
-        def_node_matcher :up_and_down_methods?, <<~PATTERN
-          [`(def :up (args) _) `(def :down (args) _)]
-        PATTERN
-
-        def on_class(node)
-          return if !migration_class?(node) || change_method?(node) || up_and_down_methods?(node)
-
-          add_offense(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/root_join_chain.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/root_join_chain.rb
deleted file mode 100644
index fb28d0c2d3946..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/root_join_chain.rb
+++ /dev/null
@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Use a single `#join` instead of chaining on `Rails.root` or `Rails.public_path`.
-      #
-      # @example
-      #   # bad
-      #   Rails.root.join('db').join('schema.rb')
-      #   Rails.root.join('db').join(migrate).join('migration.rb')
-      #   Rails.public_path.join('path').join('file.pdf')
-      #   Rails.public_path.join('path').join(to).join('file.pdf')
-      #
-      #   # good
-      #   Rails.root.join('db', 'schema.rb')
-      #   Rails.root.join('db', migrate, 'migration.rb')
-      #   Rails.public_path.join('path', 'file.pdf')
-      #   Rails.public_path.join('path', to, 'file.pdf')
-      #
-      class RootJoinChain < Base
-        extend AutoCorrector
-        include RangeHelp
-
-        MSG = 'Use `%<root>s.join(...)` instead of chaining `#join` calls.'
-
-        RESTRICT_ON_SEND = %i[join].to_set.freeze
-
-        # @!method rails_root?(node)
-        def_node_matcher :rails_root?, <<~PATTERN
-          (send (const {nil? cbase} :Rails) {:root :public_path})
-        PATTERN
-
-        # @!method join?(node)
-        def_node_matcher :join?, <<~PATTERN
-          (send _ :join $...)
-        PATTERN
-
-        def on_send(node)
-          evidence(node) do |rails_node, args|
-            add_offense(node, message: format(MSG, root: rails_node.source)) do |corrector|
-              range = range_between(rails_node.loc.selector.end_pos, node.loc.expression.end_pos)
-              replacement = ".join(#{args.map(&:source).join(', ')})"
-
-              corrector.replace(range, replacement)
-            end
-          end
-        end
-
-        private
-
-        def evidence(node)
-          # Are we at the *end* of the join chain?
-          return if join?(node.parent)
-          # Is there only one join?
-          return if rails_root?(node.receiver)
-
-          all_args = []
-
-          while (args = join?(node))
-            all_args = args + all_args
-            node = node.receiver
-          end
-
-          rails_root?(node) do
-            yield(node, all_args)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/root_public_path.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/root_public_path.rb
deleted file mode 100644
index 78448c6f5996c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/root_public_path.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Favor `Rails.public_path` over `Rails.root` with `'public'`
-      #
-      # @example
-      #   # bad
-      #   Rails.root.join('public')
-      #   Rails.root.join('public/file.pdf')
-      #   Rails.root.join('public', 'file.pdf')
-      #
-      #   # good
-      #   Rails.public_path
-      #   Rails.public_path.join('file.pdf')
-      #   Rails.public_path.join('file.pdf')
-      #
-      class RootPublicPath < Base
-        extend AutoCorrector
-
-        MSG = 'Use `Rails.public_path`.'
-
-        RESTRICT_ON_SEND = %i[join].to_set.freeze
-
-        PATTERN = %r{\Apublic(/|\z)}.freeze
-
-        def_node_matcher :rails_root_public, <<~PATTERN
-          (send
-            (send
-              $(const {nil? cbase} :Rails) :root) :join
-            (str $#public_path?) $...)
-        PATTERN
-
-        def on_send(node)
-          return unless (rails, maybe_public_path, other_args = rails_root_public(node))
-
-          add_offense(node) do |corrector|
-            first_args = maybe_public_path.gsub(PATTERN, '')
-
-            args = other_args.map(&:source)
-            args.unshift("'#{first_args}'") unless first_args.empty?
-
-            replacement = "#{rails.source}.public_path"
-            replacement += ".join(#{args.join(', ')})" unless args.empty?
-
-            corrector.replace(node, replacement)
-          end
-        end
-
-        private
-
-        def public_path?(string)
-          PATTERN.match?(string)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/safe_navigation.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/safe_navigation.rb
deleted file mode 100644
index c75ee8ac64a79..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/safe_navigation.rb
+++ /dev/null
@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Converts usages of `try!` to `&.`. It can also be configured
-      # to convert `try`. It will convert code to use safe navigation
-      # if the target Ruby version is set to 2.3+
-      #
-      # @example ConvertTry: false (default)
-      #   # bad
-      #   foo.try!(:bar)
-      #   foo.try!(:bar, baz)
-      #   foo.try!(:bar) { |e| e.baz }
-      #
-      #   foo.try!(:[], 0)
-      #
-      #   # good
-      #   foo.try(:bar)
-      #   foo.try(:bar, baz)
-      #   foo.try(:bar) { |e| e.baz }
-      #
-      #   foo&.bar
-      #   foo&.bar(baz)
-      #   foo&.bar { |e| e.baz }
-      #
-      # @example ConvertTry: true
-      #   # bad
-      #   foo.try!(:bar)
-      #   foo.try!(:bar, baz)
-      #   foo.try!(:bar) { |e| e.baz }
-      #   foo.try(:bar)
-      #   foo.try(:bar, baz)
-      #   foo.try(:bar) { |e| e.baz }
-      #
-      #   # good
-      #   foo&.bar
-      #   foo&.bar(baz)
-      #   foo&.bar { |e| e.baz }
-      class SafeNavigation < Base
-        include RangeHelp
-        extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.3
-
-        MSG = 'Use safe navigation (`&.`) instead of `%<try>s`.'
-        RESTRICT_ON_SEND = %i[try try!].freeze
-
-        def_node_matcher :try_call, <<~PATTERN
-          (send _ ${:try :try!} $_ ...)
-        PATTERN
-
-        def self.autocorrect_incompatible_with
-          [Style::RedundantSelf]
-        end
-
-        def on_send(node)
-          try_call(node) do |try_method, dispatch|
-            return if try_method == :try && !cop_config['ConvertTry']
-            return unless dispatch.sym_type? && dispatch.value.match?(/\w+[=!?]?/)
-
-            add_offense(node, message: format(MSG, try: try_method)) do |corrector|
-              autocorrect(corrector, node)
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          method_node, *params = *node.arguments
-          method = method_node.source[1..]
-
-          range = if node.receiver
-                    range_between(node.loc.dot.begin_pos, node.loc.expression.end_pos)
-                  else
-                    corrector.insert_before(node, 'self')
-                    node
-                  end
-
-          corrector.replace(range, replacement(method, params))
-        end
-
-        def replacement(method, params)
-          new_params = params.map(&:source).join(', ')
-
-          if method.end_with?('=')
-            "&.#{method[0...-1]} = #{new_params}"
-          elsif params.empty?
-            "&.#{method}"
-          else
-            "&.#{method}(#{new_params})"
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/safe_navigation_with_blank.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/safe_navigation_with_blank.rb
deleted file mode 100644
index 37cb73474ef24..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/safe_navigation_with_blank.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks to make sure safe navigation isn't used with `blank?` in
-      # a conditional.
-      #
-      # @safety
-      #   While the safe navigation operator is generally a good idea, when
-      #   checking `foo&.blank?` in a conditional, `foo` being `nil` will actually
-      #   do the opposite of what the author intends.
-      #
-      #   For example:
-      #
-      #   [source,ruby]
-      #   ----
-      #   foo&.blank? #=> nil
-      #   foo.blank? #=> true
-      #   ----
-      #
-      # @example
-      #   # bad
-      #   do_something if foo&.blank?
-      #   do_something unless foo&.blank?
-      #
-      #   # good
-      #   do_something if foo.blank?
-      #   do_something unless foo.blank?
-      #
-      class SafeNavigationWithBlank < Base
-        extend AutoCorrector
-
-        MSG =
-          'Avoid calling `blank?` with the safe navigation operator ' \
-          'in conditionals.'
-
-        def_node_matcher :safe_navigation_blank_in_conditional?, <<~PATTERN
-          (if $(csend ... :blank?) ...)
-        PATTERN
-
-        def on_if(node)
-          return unless safe_navigation_blank_in_conditional?(node)
-
-          add_offense(node) do |corrector|
-            corrector.replace(safe_navigation_blank_in_conditional?(node).location.dot, '.')
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/save_bang.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/save_bang.rb
deleted file mode 100644
index da2b0cc7bd973..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/save_bang.rb
+++ /dev/null
@@ -1,354 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Identifies possible cases where Active Record save! or related
-      # should be used instead of save because the model might have failed to
-      # save and an exception is better than unhandled failure.
-      #
-      # This will allow:
-      #
-      # * update or save calls, assigned to a variable,
-      #   or used as a condition in an if/unless/case statement.
-      # * create calls, assigned to a variable that then has a
-      #   call to `persisted?`, or whose return value is checked by
-      #   `persisted?` immediately
-      # * calls if the result is explicitly returned from methods and blocks,
-      #   or provided as arguments.
-      # * calls whose signature doesn't look like an ActiveRecord
-      #   persistence method.
-      #
-      # By default it will also allow implicit returns from methods and blocks.
-      # that behavior can be turned off with `AllowImplicitReturn: false`.
-      #
-      # You can permit receivers that are giving false positives with
-      # `AllowedReceivers: []`
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because a custom `update` method call would be changed to `update!`,
-      #   but the method name in the definition would be unchanged.
-      #
-      #   [source,ruby]
-      #   ----
-      #   # Original code
-      #   def update_attributes
-      #   end
-      #
-      #   update_attributes
-      #
-      #   # After running rubocop --safe-autocorrect
-      #   def update_attributes
-      #   end
-      #
-      #   update
-      #   ----
-      #
-      # @example
-      #
-      #   # bad
-      #   user.save
-      #   user.update(name: 'Joe')
-      #   user.find_or_create_by(name: 'Joe')
-      #   user.destroy
-      #
-      #   # good
-      #   unless user.save
-      #     # ...
-      #   end
-      #   user.save!
-      #   user.update!(name: 'Joe')
-      #   user.find_or_create_by!(name: 'Joe')
-      #   user.destroy!
-      #
-      #   user = User.find_or_create_by(name: 'Joe')
-      #   unless user.persisted?
-      #     # ...
-      #   end
-      #
-      #   def save_user
-      #     return user.save
-      #   end
-      #
-      # @example AllowImplicitReturn: true (default)
-      #
-      #   # good
-      #   users.each { |u| u.save }
-      #
-      #   def save_user
-      #     user.save
-      #   end
-      #
-      # @example AllowImplicitReturn: false
-      #
-      #   # bad
-      #   users.each { |u| u.save }
-      #   def save_user
-      #     user.save
-      #   end
-      #
-      #   # good
-      #   users.each { |u| u.save! }
-      #
-      #   def save_user
-      #     user.save!
-      #   end
-      #
-      #   def save_user
-      #     return user.save
-      #   end
-      #
-      # @example AllowedReceivers: ['merchant.customers', 'Service::Mailer']
-      #
-      #   # bad
-      #   merchant.create
-      #   customers.builder.save
-      #   Mailer.create
-      #
-      #   module Service::Mailer
-      #     self.create
-      #   end
-      #
-      #   # good
-      #   merchant.customers.create
-      #   MerchantService.merchant.customers.destroy
-      #   Service::Mailer.update(message: 'Message')
-      #   ::Service::Mailer.update
-      #   Services::Service::Mailer.update(message: 'Message')
-      #   Service::Mailer::update
-      #
-      class SaveBang < Base
-        include NegativeConditional
-        extend AutoCorrector
-
-        MSG = 'Use `%<prefer>s` instead of `%<current>s` if the return ' \
-              'value is not checked.'
-        CREATE_MSG = (MSG +
-                      ' Or check `persisted?` on model returned from ' \
-                      '`%<current>s`.').freeze
-        CREATE_CONDITIONAL_MSG = '`%<current>s` returns a model which is ' \
-                                 'always truthy.'
-
-        CREATE_PERSIST_METHODS = %i[create create_or_find_by
-                                    first_or_create find_or_create_by].freeze
-        MODIFY_PERSIST_METHODS = %i[save
-                                    update update_attributes destroy].freeze
-        RESTRICT_ON_SEND = (CREATE_PERSIST_METHODS + MODIFY_PERSIST_METHODS).freeze
-
-        def self.joining_forces
-          VariableForce
-        end
-
-        def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            variable.assignments.each do |assignment|
-              check_assignment(assignment)
-            end
-          end
-        end
-
-        def check_assignment(assignment)
-          node = right_assignment_node(assignment)
-
-          return unless node&.send_type?
-          return unless persist_method?(node, CREATE_PERSIST_METHODS)
-          return if persisted_referenced?(assignment)
-
-          register_offense(node, CREATE_MSG)
-        end
-
-        # rubocop:disable Metrics/CyclomaticComplexity
-        def on_send(node)
-          return unless persist_method?(node)
-          return if return_value_assigned?(node)
-          return if implicit_return?(node)
-          return if check_used_in_condition_or_compound_boolean(node)
-          return if argument?(node)
-          return if explicit_return?(node)
-          return if checked_immediately?(node)
-
-          register_offense(node, MSG)
-        end
-        # rubocop:enable Metrics/CyclomaticComplexity
-        alias on_csend on_send
-
-        private
-
-        def register_offense(node, msg)
-          current_method = node.method_name
-          bang_method = "#{current_method}!"
-          full_message = format(msg, prefer: bang_method, current: current_method)
-
-          range = node.loc.selector
-          add_offense(range, message: full_message) do |corrector|
-            corrector.replace(range, bang_method)
-          end
-        end
-
-        def right_assignment_node(assignment)
-          node = assignment.node.child_nodes.first
-
-          return node unless node&.block_type?
-
-          node.send_node
-        end
-
-        def persisted_referenced?(assignment)
-          return unless assignment.referenced?
-
-          assignment.variable.references.any? do |reference|
-            call_to_persisted?(reference.node.parent)
-          end
-        end
-
-        def call_to_persisted?(node)
-          node.send_type? && node.method?(:persisted?)
-        end
-
-        def assignable_node(node)
-          assignable = node.block_node || node
-          while node
-            node = hash_parent(node) || array_parent(node)
-            assignable = node if node
-          end
-          assignable
-        end
-
-        def hash_parent(node)
-          pair = node.parent
-          return unless pair&.pair_type?
-
-          hash = pair.parent
-          return unless hash&.hash_type?
-
-          hash
-        end
-
-        def array_parent(node)
-          array = node.parent
-          return unless array&.array_type?
-
-          array
-        end
-
-        def check_used_in_condition_or_compound_boolean(node)
-          return false unless in_condition_or_compound_boolean?(node)
-
-          register_offense(node, CREATE_CONDITIONAL_MSG) unless MODIFY_PERSIST_METHODS.include?(node.method_name)
-
-          true
-        end
-
-        def in_condition_or_compound_boolean?(node)
-          node = node.block_node || node
-          parent = node.parent
-          return false unless parent
-
-          operator_or_single_negative?(parent) ||
-            (conditional?(parent) && node == parent.condition)
-        end
-
-        def operator_or_single_negative?(node)
-          node.or_type? || node.and_type? || single_negative?(node)
-        end
-
-        def conditional?(parent)
-          parent.if_type? || parent.case_type?
-        end
-
-        def checked_immediately?(node)
-          node.parent && call_to_persisted?(node.parent)
-        end
-
-        def allowed_receiver?(node)
-          return false unless node.receiver
-          return true if node.receiver.const_name == 'ENV'
-          return false unless cop_config['AllowedReceivers']
-
-          cop_config['AllowedReceivers'].any? do |allowed_receiver|
-            receiver_chain_matches?(node, allowed_receiver)
-          end
-        end
-
-        def receiver_chain_matches?(node, allowed_receiver)
-          allowed_receiver.split('.').reverse.all? do |receiver_part|
-            node = node.receiver
-            return false unless node
-
-            if node.variable?
-              node.node_parts.first == receiver_part.to_sym
-            elsif node.send_type?
-              node.method?(receiver_part.to_sym)
-            elsif node.const_type?
-              const_matches?(node.const_name, receiver_part)
-            end
-          end
-        end
-
-        # Const == Const
-        # ::Const == ::Const
-        # ::Const == Const
-        # Const == ::Const
-        # NameSpace::Const == Const
-        # NameSpace::Const == NameSpace::Const
-        # NameSpace::Const != ::Const
-        # Const != NameSpace::Const
-        def const_matches?(const, allowed_const)
-          parts = allowed_const.split('::').reverse.zip(
-            const.split('::').reverse
-          )
-          parts.all? do |(allowed_part, const_part)|
-            allowed_part == const_part.to_s
-          end
-        end
-
-        def implicit_return?(node)
-          return false unless cop_config['AllowImplicitReturn']
-
-          node = assignable_node(node)
-          method, sibling_index = find_method_with_sibling_index(node.parent)
-          return unless method && (method.def_type? || method.block_type?)
-
-          method.children.size == node.sibling_index + sibling_index
-        end
-
-        def find_method_with_sibling_index(node, sibling_index = 1)
-          return node, sibling_index unless node&.or_type?
-
-          sibling_index += 1
-
-          find_method_with_sibling_index(node.parent, sibling_index)
-        end
-
-        def argument?(node)
-          assignable_node(node).argument?
-        end
-
-        def explicit_return?(node)
-          ret = assignable_node(node).parent
-          ret && (ret.return_type? || ret.next_type?)
-        end
-
-        def return_value_assigned?(node)
-          assignment = assignable_node(node).parent
-          assignment&.lvasgn_type?
-        end
-
-        def persist_method?(node, methods = RESTRICT_ON_SEND)
-          methods.include?(node.method_name) &&
-            expected_signature?(node) &&
-            !allowed_receiver?(node)
-        end
-
-        # Check argument signature as no arguments or one hash
-        def expected_signature?(node)
-          !node.arguments? ||
-            (node.arguments.one? &&
-              node.method_name != :destroy &&
-              (node.first_argument.hash_type? ||
-              !node.first_argument.literal?))
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/schema_comment.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/schema_comment.rb
deleted file mode 100644
index 0e1c23028d16d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/schema_comment.rb
+++ /dev/null
@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces the use of the `comment` option when adding a new table or column
-      # to the database during a migration.
-      #
-      # @example
-      #   # bad (no comment for a new column or table)
-      #   add_column :table, :column, :integer
-      #
-      #   create_table :table do |t|
-      #     t.type :column
-      #   end
-      #
-      #   # good
-      #   add_column :table, :column, :integer, comment: 'Number of offenses'
-      #
-      #   create_table :table, comment: 'Table of offenses data' do |t|
-      #     t.type :column, comment: 'Number of offenses'
-      #   end
-      #
-      class SchemaComment < Base
-        include ActiveRecordMigrationsHelper
-
-        COLUMN_MSG = 'New database column without `comment`.'
-        TABLE_MSG = 'New database table without `comment`.'
-        RESTRICT_ON_SEND = %i[add_column create_table].freeze
-        CREATE_TABLE_COLUMN_METHODS = Set[
-          *(
-            RAILS_ABSTRACT_SCHEMA_DEFINITIONS |
-            RAILS_ABSTRACT_SCHEMA_DEFINITIONS_HELPERS |
-            POSTGRES_SCHEMA_DEFINITIONS |
-            MYSQL_SCHEMA_DEFINITIONS
-          )
-        ].freeze
-
-        # @!method comment_present?(node)
-        def_node_matcher :comment_present?, <<~PATTERN
-          (hash <(pair {(sym :comment) (str "comment")} (_ [present?])) ...>)
-        PATTERN
-
-        # @!method add_column?(node)
-        def_node_matcher :add_column?, <<~PATTERN
-          (send nil? :add_column _table _column _type _?)
-        PATTERN
-
-        # @!method add_column_with_comment?(node)
-        def_node_matcher :add_column_with_comment?, <<~PATTERN
-          (send nil? :add_column _table _column _type #comment_present?)
-        PATTERN
-
-        # @!method create_table?(node)
-        def_node_matcher :create_table?, <<~PATTERN
-          (send nil? :create_table _table _?)
-        PATTERN
-
-        # @!method create_table?(node)
-        def_node_matcher :create_table_with_comment?, <<~PATTERN
-          (send nil? :create_table _table #comment_present? ...)
-        PATTERN
-
-        # @!method t_column?(node)
-        def_node_matcher :t_column?, <<~PATTERN
-          (send _var CREATE_TABLE_COLUMN_METHODS ...)
-        PATTERN
-
-        # @!method t_column_with_comment?(node)
-        def_node_matcher :t_column_with_comment?, <<~PATTERN
-          (send _var CREATE_TABLE_COLUMN_METHODS _column _type? #comment_present?)
-        PATTERN
-
-        def on_send(node)
-          if add_column_without_comment?(node)
-            add_offense(node, message: COLUMN_MSG)
-          elsif create_table?(node)
-            if create_table_without_comment?(node)
-              add_offense(node, message: TABLE_MSG)
-            elsif create_table_column_call_without_comment?(node)
-              add_offense(node.parent.body, message: COLUMN_MSG)
-            end
-          end
-        end
-
-        private
-
-        def add_column_without_comment?(node)
-          add_column?(node) && !add_column_with_comment?(node)
-        end
-
-        def create_table_without_comment?(node)
-          create_table?(node) && !create_table_with_comment?(node)
-        end
-
-        def create_table_column_call_without_comment?(node)
-          create_table_with_block?(node.parent) &&
-            t_column?(node.parent.body) &&
-            !t_column_with_comment?(node.parent.body)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/scope_args.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/scope_args.rb
deleted file mode 100644
index 100007b7b478c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/scope_args.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for scope calls where it was passed
-      # a method (usually a scope) instead of a lambda/proc.
-      #
-      # @example
-      #
-      #   # bad
-      #   scope :something, where(something: true)
-      #
-      #   # good
-      #   scope :something, -> { where(something: true) }
-      class ScopeArgs < Base
-        extend AutoCorrector
-
-        MSG = 'Use `lambda`/`proc` instead of a plain method call.'
-        RESTRICT_ON_SEND = %i[scope].freeze
-
-        def_node_matcher :scope?, '(send nil? :scope _ $send)'
-
-        def on_send(node)
-          scope?(node) do |second_arg|
-            add_offense(second_arg) do |corrector|
-              corrector.replace(second_arg, "-> { #{second_arg.source} }")
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/short_i18n.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/short_i18n.rb
deleted file mode 100644
index 82152a15800cc..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/short_i18n.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces that short forms of `I18n` methods are used:
-      # `t` instead of `translate` and `l` instead of `localize`.
-      #
-      # This cop has two different enforcement modes. When the EnforcedStyle
-      # is conservative (the default) then only `I18n.translate` and `I18n.localize`
-      # calls are added as offenses.
-      #
-      # When the EnforcedStyle is aggressive then all `translate` and `localize` calls
-      # without a receiver are added as offenses.
-      #
-      # @example
-      #   # bad
-      #   I18n.translate :key
-      #   I18n.localize Time.now
-      #
-      #   # good
-      #   I18n.t :key
-      #   I18n.l Time.now
-      #
-      # @example EnforcedStyle: conservative (default)
-      #   # good
-      #   translate :key
-      #   localize Time.now
-      #   t :key
-      #   l Time.now
-      #
-      # @example EnforcedStyle: aggressive
-      #   # bad
-      #   translate :key
-      #   localize Time.now
-      #
-      #   # good
-      #   t :key
-      #   l Time.now
-      #
-      class ShortI18n < Base
-        include ConfigurableEnforcedStyle
-        extend AutoCorrector
-
-        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
-
-        PREFERRED_METHODS = {
-          translate: :t,
-          localize: :l
-        }.freeze
-
-        RESTRICT_ON_SEND = PREFERRED_METHODS.keys.freeze
-
-        def_node_matcher :long_i18n?, <<~PATTERN
-          (send {nil? (const nil? :I18n)} ${:translate :localize} ...)
-        PATTERN
-
-        def on_send(node)
-          return if style == :conservative && !node.receiver
-
-          long_i18n?(node) do |method_name|
-            good_method = PREFERRED_METHODS[method_name]
-            message = format(MSG, good_method: good_method, bad_method: method_name)
-            range = node.loc.selector
-
-            add_offense(range, message: message) do |corrector|
-              corrector.replace(range, PREFERRED_METHODS[method_name])
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/skips_model_validations.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/skips_model_validations.rb
deleted file mode 100644
index 16266c2d8651a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/skips_model_validations.rb
+++ /dev/null
@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for the use of methods which skip
-      # validations which are listed in
-      # https://guides.rubyonrails.org/active_record_validations.html#skipping-validations
-      #
-      # Methods may be ignored from this rule by configuring a `AllowedMethods`.
-      #
-      # @example
-      #   # bad
-      #   Article.first.decrement!(:view_count)
-      #   DiscussionBoard.decrement_counter(:post_count, 5)
-      #   Article.first.increment!(:view_count)
-      #   DiscussionBoard.increment_counter(:post_count, 5)
-      #   person.toggle :active
-      #   product.touch
-      #   Billing.update_all("category = 'authorized', author = 'David'")
-      #   user.update_attribute(:website, 'example.com')
-      #   user.update_columns(last_request_at: Time.current)
-      #   Post.update_counters 5, comment_count: -1, action_count: 1
-      #
-      #   # good
-      #   user.update(website: 'example.com')
-      #   FileUtils.touch('file')
-      #
-      # @example AllowedMethods: ["touch"]
-      #   # bad
-      #   DiscussionBoard.decrement_counter(:post_count, 5)
-      #   DiscussionBoard.increment_counter(:post_count, 5)
-      #   person.toggle :active
-      #
-      #   # good
-      #   user.touch
-      #
-      class SkipsModelValidations < Base
-        MSG = 'Avoid using `%<method>s` because it skips validations.'
-
-        METHODS_WITH_ARGUMENTS = %w[decrement!
-                                    decrement_counter
-                                    increment!
-                                    increment_counter
-                                    insert
-                                    insert!
-                                    insert_all
-                                    insert_all!
-                                    toggle!
-                                    update_all
-                                    update_attribute
-                                    update_column
-                                    update_columns
-                                    update_counters
-                                    upsert
-                                    upsert_all].freeze
-
-        def_node_matcher :good_touch?, <<~PATTERN
-          {
-            (send (const nil? :FileUtils) :touch ...)
-            (send _ :touch {true false})
-          }
-        PATTERN
-
-        def_node_matcher :good_insert?, <<~PATTERN
-          (send _ {:insert :insert!} _ {
-            !(hash ...)
-            (hash <(pair (sym !{:returning :unique_by}) _) ...>)
-          } ...)
-        PATTERN
-
-        def on_send(node)
-          return if allowed_methods.include?(node.method_name.to_s)
-          return unless forbidden_methods.include?(node.method_name.to_s)
-          return if allowed_method?(node)
-          return if good_touch?(node)
-          return if good_insert?(node)
-
-          add_offense(node.loc.selector, message: message(node))
-        end
-        alias on_csend on_send
-
-        def initialize(*)
-          super
-          @displayed_allowed_warning = false
-          @displayed_forbidden_warning = false
-        end
-
-        private
-
-        def message(node)
-          format(MSG, method: node.method_name)
-        end
-
-        def allowed_method?(node)
-          METHODS_WITH_ARGUMENTS.include?(node.method_name.to_s) &&
-            !node.arguments?
-        end
-
-        def forbidden_methods
-          obsolete_result = cop_config['Blacklist']
-          if obsolete_result
-            warn '`Blacklist` has been renamed to `ForbiddenMethods`.' unless @displayed_forbidden_warning
-            @displayed_forbidden_warning = true
-            return obsolete_result
-          end
-
-          cop_config['ForbiddenMethods'] || []
-        end
-
-        def allowed_methods
-          obsolete_result = cop_config['Whitelist']
-          if obsolete_result
-            warn '`Whitelist` has been renamed to `AllowedMethods`.' unless @displayed_allowed_warning
-            @displayed_allowed_warning = true
-
-            return obsolete_result
-          end
-
-          cop_config['AllowedMethods'] || []
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/squished_sql_heredocs.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/squished_sql_heredocs.rb
deleted file mode 100644
index ec36e3be85778..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/squished_sql_heredocs.rb
+++ /dev/null
@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      #
-      # Checks SQL heredocs to use `.squish`.
-      #
-      # @safety
-      #   Some SQL syntax (e.g. PostgreSQL comments and functions) requires newlines
-      #   to be preserved in order to work, thus autocorrection for this cop is not safe.
-      #
-      # @example
-      #   # bad
-      #   <<-SQL
-      #     SELECT * FROM posts;
-      #   SQL
-      #
-      #   <<-SQL
-      #     SELECT * FROM posts
-      #       WHERE id = 1
-      #   SQL
-      #
-      #   execute(<<~SQL, "Post Load")
-      #     SELECT * FROM posts
-      #       WHERE post_id = 1
-      #   SQL
-      #
-      #   # good
-      #   <<-SQL.squish
-      #     SELECT * FROM posts;
-      #   SQL
-      #
-      #   <<~SQL.squish
-      #     SELECT * FROM table
-      #       WHERE id = 1
-      #   SQL
-      #
-      #   execute(<<~SQL.squish, "Post Load")
-      #     SELECT * FROM posts
-      #       WHERE post_id = 1
-      #   SQL
-      #
-      class SquishedSQLHeredocs < Base
-        include Heredoc
-        extend AutoCorrector
-
-        SQL = 'SQL'
-        SQUISH = '.squish'
-        MSG = 'Use `%<expect>s` instead of `%<current>s`.'
-
-        def on_heredoc(node)
-          return unless offense_detected?(node)
-
-          add_offense(node) do |corrector|
-            corrector.insert_after(node, SQUISH)
-          end
-        end
-
-        private
-
-        def offense_detected?(node)
-          sql_heredoc?(node) && !using_squish?(node)
-        end
-
-        def sql_heredoc?(node)
-          delimiter_string(node) == SQL
-        end
-
-        def using_squish?(node)
-          node.parent&.send_type? && node.parent&.method?(:squish)
-        end
-
-        def message(node)
-          format(
-            MSG,
-            expect: "#{node.source}#{SQUISH}",
-            current: node.source
-          )
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/strip_heredoc.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/strip_heredoc.rb
deleted file mode 100644
index 201ad0463bb34..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/strip_heredoc.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces the use of squiggly heredoc over `strip_heredoc`.
-      #
-      # @example
-      #
-      #   # bad
-      #   <<EOS.strip_heredoc
-      #     some text
-      #   EOS
-      #
-      #   # bad
-      #   <<-EOS.strip_heredoc
-      #     some text
-      #   EOS
-      #
-      #   # good
-      #   <<~EOS
-      #     some text
-      #   EOS
-      #
-      class StripHeredoc < Base
-        extend AutoCorrector
-        extend TargetRubyVersion
-
-        MSG = 'Use squiggly heredoc (`<<~`) instead of `strip_heredoc`.'
-        RESTRICT_ON_SEND = %i[strip_heredoc].freeze
-
-        minimum_target_ruby_version 2.3
-
-        def on_send(node)
-          return unless (receiver = node.receiver)
-          return unless receiver.str_type? || receiver.dstr_type?
-          return unless receiver.respond_to?(:heredoc?) && receiver.heredoc?
-
-          register_offense(node, receiver)
-        end
-
-        private
-
-        def register_offense(node, heredoc)
-          add_offense(node) do |corrector|
-            squiggly_heredoc = heredoc.source.sub(/\A<<(-|~)?/, '<<~')
-
-            corrector.replace(heredoc, squiggly_heredoc)
-            corrector.remove(node.loc.dot)
-            corrector.remove(node.loc.selector)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/table_name_assignment.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/table_name_assignment.rb
deleted file mode 100644
index e99271a588c82..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/table_name_assignment.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces the absence of explicit table name assignment.
-      #
-      # `self.table_name=` should only be used for very good reasons,
-      # such as not having control over the database, or working
-      # on a legacy project.
-      #
-      # If you need to change how your model's name is translated to
-      # a table name, you may want to look at Inflections:
-      # https://api.rubyonrails.org/classes/ActiveSupport/Inflector/Inflections.html
-      #
-      # If you wish to add a prefix in front of your model, or wish to change
-      # the default prefix, `self.table_name_prefix` might better suit your needs:
-      # https://api.rubyonrails.org/classes/ActiveRecord/ModelSchema.html#method-c-table_name_prefix-3D
-      #
-      # STI base classes named `Base` are ignored by this cop.
-      # For more information: https://api.rubyonrails.org/classes/ActiveRecord/Inheritance.html
-      #
-      # @example
-      #   # bad
-      #   self.table_name = 'some_table_name'
-      #   self.table_name = :some_other_name
-      class TableNameAssignment < Base
-        include ActiveRecordHelper
-
-        MSG = 'Do not use `self.table_name =`.'
-
-        def_node_matcher :base_class?, <<~PATTERN
-          (class (const ... :Base) ...)
-        PATTERN
-
-        def on_class(class_node)
-          return if base_class?(class_node)
-
-          find_set_table_name(class_node).each { |node| add_offense(node) }
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/time_zone.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/time_zone.rb
deleted file mode 100644
index 5cf55ec422d76..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/time_zone.rb
+++ /dev/null
@@ -1,252 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for the use of Time methods without zone.
-      #
-      # Built on top of Ruby on Rails style guide (https://rails.rubystyle.guide#time)
-      # and the article http://danilenko.org/2012/7/6/rails_timezones/
-      #
-      # Two styles are supported for this cop. When `EnforcedStyle` is 'strict'
-      # then only use of `Time.zone` is allowed.
-      #
-      # When EnforcedStyle is 'flexible' then it's also allowed
-      # to use `Time#in_time_zone`.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because it may change handling time.
-      #
-      # @example
-      #   # bad
-      #   Time.now
-      #   Time.parse('2015-03-02T19:05:37')
-      #
-      #   # good
-      #   Time.current
-      #   Time.zone.now
-      #   Time.zone.parse('2015-03-02T19:05:37')
-      #   Time.zone.parse('2015-03-02T19:05:37Z') # Respect ISO 8601 format with timezone specifier.
-      #
-      # @example EnforcedStyle: flexible (default)
-      #   # `flexible` allows usage of `in_time_zone` instead of `zone`.
-      #
-      #   # good
-      #   Time.at(timestamp).in_time_zone
-      #
-      # @example EnforcedStyle: strict
-      #   # `strict` means that `Time` should be used with `zone`.
-      #
-      #   # bad
-      #   Time.at(timestamp).in_time_zone
-      class TimeZone < Base
-        include ConfigurableEnforcedStyle
-        extend AutoCorrector
-
-        MSG = 'Do not use `%<current>s` without zone. Use `%<prefer>s` ' \
-              'instead.'
-
-        MSG_ACCEPTABLE = 'Do not use `%<current>s` without zone. ' \
-                         'Use one of %<prefer>s instead.'
-
-        MSG_LOCALTIME = 'Do not use `Time.localtime` without ' \
-                        'offset or zone.'
-
-        GOOD_METHODS = %i[zone zone_default find_zone find_zone!].freeze
-
-        DANGEROUS_METHODS = %i[now local new parse at].freeze
-
-        ACCEPTED_METHODS = %i[in_time_zone utc getlocal xmlschema iso8601
-                              jisx0301 rfc3339 httpdate to_i to_f].freeze
-
-        TIMEZONE_SPECIFIER = /[A-z]/.freeze
-
-        def on_const(node)
-          mod, klass = *node
-          # we should only check core classes
-          # (`Time` or `::Time`)
-          return unless (mod.nil? || mod.cbase_type?) && method_send?(node)
-
-          check_time_node(klass, node.parent) if klass == :Time
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          # add `.zone`: `Time.at` => `Time.zone.at`
-          corrector.insert_after(node.children[0].source_range, '.zone')
-
-          case node.method_name
-          when :current
-            # replace `Time.zone.current` => `Time.zone.now`
-            corrector.replace(node.loc.selector, 'now')
-          when :new
-            autocorrect_time_new(node, corrector)
-          end
-
-          # prefer `Time` over `DateTime` class
-          corrector.replace(node.children.first.source_range, 'Time') if strict?
-          remove_redundant_in_time_zone(corrector, node)
-        end
-
-        def autocorrect_time_new(node, corrector)
-          if node.arguments?
-            corrector.replace(node.loc.selector, 'local')
-          else
-            corrector.replace(node.loc.selector, 'now')
-          end
-        end
-
-        # remove redundant `.in_time_zone` from `Time.zone.now.in_time_zone`
-        def remove_redundant_in_time_zone(corrector, node)
-          time_methods_called = extract_method_chain(node)
-          return unless time_methods_called.include?(:in_time_zone) ||
-                        time_methods_called.include?(:zone)
-
-          while node&.send_type?
-            if node.children.last == :in_time_zone
-              in_time_zone_with_dot =
-                node.loc.selector.adjust(begin_pos: -1)
-              corrector.remove(in_time_zone_with_dot)
-            end
-            node = node.parent
-          end
-        end
-
-        def check_time_node(klass, node)
-          return if attach_timezone_specifier?(node.first_argument)
-
-          chain = extract_method_chain(node)
-          return if not_danger_chain?(chain)
-          return check_localtime(node) if need_check_localtime?(chain)
-
-          method_name = (chain & DANGEROUS_METHODS).join('.')
-
-          return if offset_provided?(node)
-
-          message = build_message(klass, method_name, node)
-
-          add_offense(node.loc.selector, message: message) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-
-        def attach_timezone_specifier?(date)
-          date.respond_to?(:value) && TIMEZONE_SPECIFIER.match?(date.value.to_s[-1])
-        end
-
-        def build_message(klass, method_name, node)
-          if flexible?
-            format(
-              MSG_ACCEPTABLE,
-              current: "#{klass}.#{method_name}",
-              prefer: acceptable_methods(klass, method_name, node).join(', ')
-            )
-          else
-            safe_method_name = safe_method(method_name, node)
-            format(MSG,
-                   current: "#{klass}.#{method_name}",
-                   prefer: "Time.zone.#{safe_method_name}")
-          end
-        end
-
-        def extract_method_chain(node)
-          chain = []
-          while !node.nil? && node.send_type?
-            chain << node.method_name if method_from_time_class?(node)
-            node = node.parent
-          end
-          chain
-        end
-
-        # Only add the method to the chain if the method being
-        # called is part of the time class.
-        def method_from_time_class?(node)
-          receiver, method_name, *_args = *node
-          if (receiver.is_a? RuboCop::AST::Node) && !receiver.cbase_type?
-            method_from_time_class?(receiver)
-          else
-            method_name == :Time
-          end
-        end
-
-        # checks that parent node of send_type
-        # and receiver is the given node
-        def method_send?(node)
-          return false unless node.parent&.send_type?
-
-          node.parent.receiver == node
-        end
-
-        def safe_method(method_name, node)
-          if %w[new current].include?(method_name)
-            node.arguments? ? 'local' : 'now'
-          else
-            method_name
-          end
-        end
-
-        def check_localtime(node)
-          selector_node = node
-
-          while node&.send_type?
-            break if node.method?(:localtime)
-
-            node = node.parent
-          end
-
-          return if node.arguments?
-
-          add_offense(selector_node.loc.selector, message: MSG_LOCALTIME) do |corrector|
-            autocorrect(corrector, selector_node)
-          end
-        end
-
-        def not_danger_chain?(chain)
-          (chain & DANGEROUS_METHODS).empty? || !(chain & good_methods).empty?
-        end
-
-        def need_check_localtime?(chain)
-          flexible? && chain.include?(:localtime)
-        end
-
-        def flexible?
-          style == :flexible
-        end
-
-        def strict?
-          style == :strict
-        end
-
-        def good_methods
-          if strict?
-            GOOD_METHODS
-          else
-            GOOD_METHODS + [:current] + ACCEPTED_METHODS
-          end
-        end
-
-        def acceptable_methods(klass, method_name, node)
-          acceptable = [
-            "`Time.zone.#{safe_method(method_name, node)}`",
-            "`#{klass}.current`"
-          ]
-
-          ACCEPTED_METHODS.each do |am|
-            acceptable << "`#{klass}.#{method_name}.#{am}`"
-          end
-
-          acceptable
-        end
-
-        # Time.new can be called with a time zone offset
-        # When it is, that should be considered safe
-        # Example:
-        # Time.new(1988, 3, 15, 3, 0, 0, "-05:00")
-        def offset_provided?(node)
-          node.arguments.size >= 7
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/time_zone_assignment.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/time_zone_assignment.rb
deleted file mode 100644
index 0cc54b5b9f5da..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/time_zone_assignment.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for the use of `Time.zone=` method.
-      #
-      # The `zone` attribute persists for the rest of the Ruby runtime, potentially causing
-      # unexpected behavior at a later time.
-      # Using `Time.use_zone` ensures the code passed in the block is the only place Time.zone is affected.
-      # It eliminates the possibility of a `zone` sticking around longer than intended.
-      #
-      # @example
-      #   # bad
-      #   Time.zone = 'EST'
-      #
-      #   # good
-      #   Time.use_zone('EST') do
-      #   end
-      #
-      class TimeZoneAssignment < Base
-        MSG = 'Use `Time.use_zone` with block instead of `Time.zone=`.'
-        RESTRICT_ON_SEND = %i[zone=].freeze
-
-        def_node_matcher :time_zone_assignment?, <<~PATTERN
-          (send (const nil? :Time) :zone= ...)
-        PATTERN
-
-        def on_send(node)
-          return unless time_zone_assignment?(node)
-
-          add_offense(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/to_formatted_s.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/to_formatted_s.rb
deleted file mode 100644
index fbad7de7872fc..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/to_formatted_s.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for consistent uses of `to_fs` or `to_formatted_s`,
-      # depending on the cop's configuration.
-      #
-      # @example EnforcedStyle: to_fs (default)
-      #
-      #   # bad
-      #   time.to_formatted_s(:db)
-      #
-      #   # good
-      #   time.to_fs(:db)
-      #
-      # @example EnforcedStyle: to_formatted_s
-      #
-      #   # bad
-      #   time.to_fs(:db)
-      #
-      #   # good
-      #   time.to_formatted_s(:db)
-      #
-      class ToFormattedS < Base
-        include ConfigurableEnforcedStyle
-        extend AutoCorrector
-        extend TargetRailsVersion
-
-        minimum_target_rails_version 7.0
-
-        MSG = 'Use `%<prefer>s` instead.'
-        RESTRICT_ON_SEND = %i[to_formatted_s to_fs].freeze
-
-        def on_send(node)
-          return if node.method?(style)
-
-          add_offense(node.loc.selector, message: format(MSG, prefer: style)) do |corrector|
-            corrector.replace(node.loc.selector, style)
-          end
-        end
-        alias on_csend on_send
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/transaction_exit_statement.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/transaction_exit_statement.rb
deleted file mode 100644
index d21241e6b3e8a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/transaction_exit_statement.rb
+++ /dev/null
@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for the use of exit statements (namely `return`,
-      # `break` and `throw`) in transactions. This is due to the eventual
-      # unexpected behavior when using ActiveRecord >= 7, where transactions
-      # exited using these statements are being rollbacked rather than
-      # committed (pre ActiveRecord 7 behavior).
-      #
-      # As alternatives, it would be more intuitive to explicitly raise an
-      # error when rollback is desired, and to use `next` when commit is
-      # desired.
-      #
-      # @example
-      #   # bad
-      #   ApplicationRecord.transaction do
-      #     return if user.active?
-      #   end
-      #
-      #   # bad
-      #   ApplicationRecord.transaction do
-      #     break if user.active?
-      #   end
-      #
-      #   # bad
-      #   ApplicationRecord.transaction do
-      #     throw if user.active?
-      #   end
-      #
-      #   # bad, as `with_lock` implicitly opens a transaction too
-      #   user.with_lock do
-      #     throw if user.active?
-      #   end
-      #
-      #   # good
-      #   ApplicationRecord.transaction do
-      #     # Rollback
-      #     raise "User is active" if user.active?
-      #   end
-      #
-      #   # good
-      #   ApplicationRecord.transaction do
-      #     # Commit
-      #     next if user.active?
-      #   end
-      #
-      # @see https://github.com/rails/rails/commit/15aa4200e083
-      class TransactionExitStatement < Base
-        MSG = <<~MSG.chomp
-          Exit statement `%<statement>s` is not allowed. Use `raise` (rollback) or `next` (commit).
-        MSG
-
-        RESTRICT_ON_SEND = %i[transaction with_lock].freeze
-
-        def_node_search :exit_statements, <<~PATTERN
-          ({return | break | send nil? :throw} ...)
-        PATTERN
-
-        def_node_matcher :rescue_body_return_node?, <<~PATTERN
-          (:resbody ...
-            ...
-            ({return | break | send nil? :throw} ...)
-            ...
-          )
-        PATTERN
-
-        def on_send(node)
-          return unless (parent = node.parent)
-          return unless parent.block_type? && parent.body
-
-          exit_statements(parent.body).each do |statement_node|
-            next if statement_node.break_type? && nested_block?(statement_node)
-
-            statement = statement(statement_node)
-            message = format(MSG, statement: statement)
-
-            add_offense(statement_node, message: message)
-          end
-        end
-
-        private
-
-        def statement(statement_node)
-          if statement_node.return_type?
-            'return'
-          elsif statement_node.break_type?
-            'break'
-          else
-            statement_node.method_name
-          end
-        end
-
-        def nested_block?(statement_node)
-          !statement_node.ancestors.find(&:block_type?).method?(:transaction)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/uniq_before_pluck.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/uniq_before_pluck.rb
deleted file mode 100644
index bcbe1477e9579..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/uniq_before_pluck.rb
+++ /dev/null
@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Prefer using `distinct` before `pluck` instead of `uniq` after `pluck`.
-      #
-      # The use of distinct before pluck is preferred because it executes by
-      # the database.
-      #
-      # This cop has two different enforcement modes. When the EnforcedStyle
-      # is `conservative` (the default), then only calls to `pluck` on a constant
-      # (i.e. a model class) before `uniq` are added as offenses.
-      #
-      # When the EnforcedStyle is `aggressive` then all calls to `pluck` before
-      # distinct are added as offenses. This may lead to false positives
-      # as the cop cannot distinguish between calls to `pluck` on an
-      # ActiveRecord::Relation vs a call to pluck on an
-      # ActiveRecord::Associations::CollectionProxy.
-      #
-      # @safety
-      #   This cop is unsafe for autocorrection because the behavior may change
-      #   depending on the database collation.
-      #
-      # @example EnforcedStyle: conservative (default)
-      #   # bad - redundantly fetches duplicate values
-      #   Album.pluck(:band_name).uniq
-      #
-      #   # good
-      #   Album.distinct.pluck(:band_name)
-      #
-      # @example EnforcedStyle: aggressive
-      #   # bad - redundantly fetches duplicate values
-      #   Album.pluck(:band_name).uniq
-      #
-      #   # bad - redundantly fetches duplicate values
-      #   Album.where(year: 1985).pluck(:band_name).uniq
-      #
-      #   # bad - redundantly fetches duplicate values
-      #   customer.favourites.pluck(:color).uniq
-      #
-      #   # good
-      #   Album.distinct.pluck(:band_name)
-      #   Album.distinct.where(year: 1985).pluck(:band_name)
-      #   customer.favourites.distinct.pluck(:color)
-      #
-      class UniqBeforePluck < Base
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `distinct` before `pluck`.'
-        RESTRICT_ON_SEND = %i[uniq].freeze
-        NEWLINE = "\n"
-        PATTERN = '[!^block (send (send %<type>s :pluck ...) :uniq ...)]'
-
-        def_node_matcher :conservative_node_match,
-                         format(PATTERN, type: 'const')
-
-        def_node_matcher :aggressive_node_match,
-                         format(PATTERN, type: '_')
-
-        def on_send(node)
-          uniq = if style == :conservative
-                   conservative_node_match(node)
-                 else
-                   aggressive_node_match(node)
-                 end
-
-          return unless uniq
-
-          add_offense(node.loc.selector) do |corrector|
-            method = node.method_name
-
-            corrector.remove(dot_method_with_whitespace(method, node))
-            corrector.insert_before(node.receiver.loc.dot.begin, '.distinct')
-          end
-        end
-
-        private
-
-        def dot_method_with_whitespace(method, node)
-          range_between(dot_method_begin_pos(method, node),
-                        node.loc.selector.end_pos)
-        end
-
-        def dot_method_begin_pos(method, node)
-          lines = node.source.split(NEWLINE)
-
-          if lines.last.strip == ".#{method}"
-            node.source.rindex(NEWLINE)
-          else
-            node.loc.dot.begin_pos
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/unique_validation_without_index.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/unique_validation_without_index.rb
deleted file mode 100644
index f2aa63db349a4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/unique_validation_without_index.rb
+++ /dev/null
@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # When you define a uniqueness validation in Active Record model,
-      # you also should add a unique index for the column. There are two reasons
-      # First, duplicated records may occur even if Active Record's validation
-      # is defined.
-      # Second, it will cause slow queries. The validation executes a `SELECT`
-      # statement with the target column when inserting/updating a record.
-      # If the column does not have an index and the table is large,
-      # the query will be heavy.
-      #
-      # Note that the cop does nothing if db/schema.rb does not exist.
-      #
-      # @example
-      #   # bad - if the schema does not have a unique index
-      #   validates :account, uniqueness: true
-      #
-      #   # good - if the schema has a unique index
-      #   validates :account, uniqueness: true
-      #
-      #   # good - even if the schema does not have a unique index
-      #   validates :account, length: { minimum: MIN_LENGTH }
-      #
-      class UniqueValidationWithoutIndex < Base
-        include ActiveRecordHelper
-
-        MSG = 'Uniqueness validation should have a unique index on the database column.'
-        RESTRICT_ON_SEND = %i[validates].freeze
-
-        def on_send(node)
-          return unless uniqueness_part(node)
-          return if condition_part?(node)
-          return unless schema
-
-          klass, table, names = find_schema_information(node)
-          return unless names
-          return if with_index?(klass, table, names)
-
-          add_offense(node)
-        end
-
-        private
-
-        def find_schema_information(node)
-          klass = class_node(node)
-          return unless klass
-
-          table = schema.table_by(name: table_name(klass))
-          names = column_names(node)
-
-          [klass, table, names]
-        end
-
-        def with_index?(klass, table, names)
-          # Compatibility for Rails 4.2.
-          add_indices = schema.add_indices_by(table_name: table_name(klass))
-
-          (table.indices + add_indices).any? do |index|
-            index.unique &&
-              (index.columns.to_set == names ||
-               include_column_names_in_expression_index?(index, names))
-          end
-        end
-
-        def include_column_names_in_expression_index?(index, column_names)
-          return false unless (expression_index = index.expression)
-
-          column_names.all? do |column_name|
-            expression_index.include?(column_name)
-          end
-        end
-
-        def column_names(node)
-          arg = node.first_argument
-          return unless arg.str_type? || arg.sym_type?
-
-          ret = [arg.value]
-          names_from_scope = column_names_from_scope(node)
-          ret.concat(names_from_scope) if names_from_scope
-
-          ret = ret.flat_map do |name|
-            klass = class_node(node)
-            resolve_relation_into_column(
-              name: name.to_s,
-              class_node: klass,
-              table: schema.table_by(name: table_name(klass))
-            )
-          end
-          ret.include?(nil) ? nil : ret.to_set
-        end
-
-        def column_names_from_scope(node)
-          uniq = uniqueness_part(node)
-          return unless uniq.hash_type?
-
-          scope = find_scope(uniq)
-          return unless scope
-
-          scope = unfreeze_scope(scope)
-
-          case scope.type
-          when :sym, :str
-            [scope.value]
-          when :array
-            array_node_to_array(scope)
-          end
-        end
-
-        def find_scope(pairs)
-          pairs.each_pair.find do |pair|
-            key = pair.key
-            next unless key.sym_type? && key.value == :scope
-
-            break pair.value
-          end
-        end
-
-        def unfreeze_scope(scope)
-          scope.send_type? && scope.method?(:freeze) ? scope.children.first : scope
-        end
-
-        def class_node(node)
-          node.each_ancestor.find(&:class_type?)
-        end
-
-        def uniqueness_part(node)
-          pairs = node.arguments.last
-          return unless pairs.hash_type?
-
-          pairs.each_pair.find do |pair|
-            next unless pair.key.sym_type? && pair.key.value == :uniqueness
-
-            break pair.value
-          end
-        end
-
-        def condition_part?(node)
-          pairs = node.arguments.last
-          return unless pairs.hash_type?
-
-          pairs.each_pair.any? do |pair|
-            key = pair.key
-            next unless key.sym_type?
-
-            key.value == :if || key.value == :unless
-          end
-        end
-
-        def array_node_to_array(node)
-          node.values.map do |elm|
-            case elm.type
-            when :str, :sym
-              elm.value
-            else
-              return nil
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/unknown_env.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/unknown_env.rb
deleted file mode 100644
index 42020b4155a2c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/unknown_env.rb
+++ /dev/null
@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks that environments called with `Rails.env` predicates
-      # exist.
-      # By default the cop allows three environments which Rails ships with:
-      # `development`, `test`, and `production`.
-      # More can be added to the `Environments` config parameter.
-      #
-      # @example
-      #   # bad
-      #   Rails.env.proudction?
-      #   Rails.env == 'proudction'
-      #
-      #   # good
-      #   Rails.env.production?
-      #   Rails.env == 'production'
-      class UnknownEnv < Base
-        MSG = 'Unknown environment `%<name>s`.'
-        MSG_SIMILAR = 'Unknown environment `%<name>s`. ' \
-                      'Did you mean `%<similar>s`?'
-
-        def_node_matcher :rails_env?, <<~PATTERN
-          (send
-            {(const nil? :Rails) (const (cbase) :Rails)}
-            :env)
-        PATTERN
-
-        def_node_matcher :unknown_environment_predicate?, <<~PATTERN
-          (send #rails_env? $#unknown_env_predicate?)
-        PATTERN
-
-        def_node_matcher :unknown_environment_equal?, <<~PATTERN
-          {
-            (send #rails_env? {:== :===} $(str #unknown_env_name?))
-            (send $(str #unknown_env_name?) {:== :===} #rails_env?)
-          }
-        PATTERN
-
-        def on_send(node)
-          unknown_environment_predicate?(node) do |name|
-            add_offense(node.loc.selector, message: message(name))
-          end
-
-          unknown_environment_equal?(node) do |str_node|
-            name = str_node.value
-            add_offense(str_node, message: message(name))
-          end
-        end
-
-        private
-
-        def collect_variable_like_names(_scope)
-          environments
-        end
-
-        def message(name)
-          name = name.to_s.chomp('?')
-
-          # DidYouMean::SpellChecker is not available in all versions of Ruby,
-          # and even on versions where it *is* available (>= 2.3), it is not
-          # always required correctly. So we do a feature check first. See:
-          # https://github.com/rubocop/rubocop/issues/7979
-          similar_names = if defined?(DidYouMean::SpellChecker)
-                            spell_checker = DidYouMean::SpellChecker.new(dictionary: environments)
-                            spell_checker.correct(name)
-                          else
-                            []
-                          end
-
-          if similar_names.empty?
-            format(MSG, name: name)
-          else
-            format(MSG_SIMILAR, name: name, similar: similar_names.join(', '))
-          end
-        end
-
-        def unknown_env_predicate?(name)
-          name = name.to_s
-          name.end_with?('?') &&
-            !environments.include?(name[0..-2])
-        end
-
-        def unknown_env_name?(name)
-          !environments.include?(name)
-        end
-
-        def environments
-          cop_config['Environments']
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/unused_ignored_columns.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/unused_ignored_columns.rb
deleted file mode 100644
index 02a0caa4c6056..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/unused_ignored_columns.rb
+++ /dev/null
@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Suggests you remove a column that does not exist in the schema from `ignored_columns`.
-      # `ignored_columns` is necessary to drop a column from RDBMS, but you don't need it after the migration
-      # to drop the column. You avoid forgetting to remove `ignored_columns` by this cop.
-      #
-      # @example
-      #   # bad
-      #   class User < ApplicationRecord
-      #     self.ignored_columns = [:already_removed_column]
-      #   end
-      #
-      #   # good
-      #   class User < ApplicationRecord
-      #     self.ignored_columns = [:still_existing_column]
-      #   end
-      #
-      class UnusedIgnoredColumns < Base
-        include ActiveRecordHelper
-
-        MSG = 'Remove `%<column_name>s` from `ignored_columns` because the column does not exist.'
-        RESTRICT_ON_SEND = %i[ignored_columns=].freeze
-
-        def_node_matcher :ignored_columns, <<~PATTERN
-          (send self :ignored_columns= $array)
-        PATTERN
-
-        def_node_matcher :column_name, <<~PATTERN
-          ({str sym} $_)
-        PATTERN
-
-        def on_send(node)
-          return unless (columns = ignored_columns(node))
-          return unless schema
-
-          table = table(node)
-          return unless table
-
-          columns.children.each do |column_node|
-            check_column_existence(column_node, table)
-          end
-        end
-
-        private
-
-        def check_column_existence(column_node, table)
-          column_name = column_name(column_node)
-          return unless column_name
-          return if table.with_column?(name: column_name.to_s)
-
-          message = format(MSG, column_name: column_name)
-          add_offense(column_node, message: message)
-        end
-
-        def class_node(node)
-          node.each_ancestor.find(&:class_type?)
-        end
-
-        def table(node)
-          klass = class_node(node)
-          return unless klass
-
-          schema.table_by(name: table_name(klass))
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/validation.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/validation.rb
deleted file mode 100644
index 29f5f33629626..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/validation.rb
+++ /dev/null
@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks for the use of old-style attribute validation macros.
-      #
-      # @example
-      #   # bad
-      #   validates_acceptance_of :foo
-      #   validates_confirmation_of :foo
-      #   validates_exclusion_of :foo
-      #   validates_format_of :foo
-      #   validates_inclusion_of :foo
-      #   validates_length_of :foo
-      #   validates_numericality_of :foo
-      #   validates_presence_of :foo
-      #   validates_absence_of :foo
-      #   validates_size_of :foo
-      #   validates_uniqueness_of :foo
-      #
-      #   # good
-      #   validates :foo, acceptance: true
-      #   validates :foo, confirmation: true
-      #   validates :foo, exclusion: true
-      #   validates :foo, format: true
-      #   validates :foo, inclusion: true
-      #   validates :foo, length: true
-      #   validates :foo, numericality: true
-      #   validates :foo, presence: true
-      #   validates :foo, absence: true
-      #   validates :foo, size: true
-      #   validates :foo, uniqueness: true
-      #
-      class Validation < Base
-        extend AutoCorrector
-
-        MSG = 'Prefer the new style validations `%<prefer>s` over ' \
-              '`%<current>s`.'
-
-        TYPES = %w[
-          acceptance
-          confirmation
-          exclusion
-          format
-          inclusion
-          length
-          numericality
-          presence
-          absence
-          size
-          uniqueness
-        ].freeze
-
-        RESTRICT_ON_SEND = TYPES.map { |p| "validates_#{p}_of".to_sym }.freeze
-        ALLOWLIST = TYPES.map { |p| "validates :column, #{p}: value" }.freeze
-
-        def on_send(node)
-          return if node.receiver
-
-          range = node.loc.selector
-
-          add_offense(range, message: message(node)) do |corrector|
-            last_argument = node.arguments.last
-            return if !last_argument.literal? && !last_argument.splat_type? &&
-                      !frozen_array_argument?(last_argument)
-
-            corrector.replace(range, 'validates')
-            correct_validate_type(corrector, node)
-          end
-        end
-
-        private
-
-        def message(node)
-          method_name = node.method_name
-
-          format(MSG, prefer: preferred_method(method_name), current: method_name)
-        end
-
-        def preferred_method(method)
-          ALLOWLIST[RESTRICT_ON_SEND.index(method.to_sym)]
-        end
-
-        def correct_validate_type(corrector, node)
-          last_argument = node.last_argument
-
-          if last_argument.hash_type?
-            correct_validate_type_for_hash(corrector, node, last_argument)
-          elsif last_argument.array_type?
-            loc = last_argument.loc
-
-            correct_validate_type_for_array(corrector, node, last_argument, loc)
-          elsif frozen_array_argument?(last_argument)
-            arguments = node.last_argument.receiver
-            loc = arguments.parent.loc
-
-            correct_validate_type_for_array(corrector, node, arguments, loc)
-          else
-            range = last_argument.source_range
-
-            corrector.insert_after(range, ", #{validate_type(node)}: true")
-          end
-        end
-
-        def correct_validate_type_for_hash(corrector, node, arguments)
-          corrector.replace(
-            arguments.loc.expression,
-            "#{validate_type(node)}: #{braced_options(arguments)}"
-          )
-        end
-
-        def correct_validate_type_for_array(corrector, node, arguments, loc)
-          attributes = []
-
-          arguments.each_child_node do |child_node|
-            attributes << if arguments.percent_literal?
-                            ":#{child_node.source}"
-                          else
-                            child_node.source
-                          end
-          end
-
-          corrector.replace(
-            loc.expression,
-            "#{attributes.join(', ')}, #{validate_type(node)}: true"
-          )
-        end
-
-        def validate_type(node)
-          node.method_name.to_s.split('_')[1]
-        end
-
-        def frozen_array_argument?(argument)
-          argument.send_type? && argument.method?(:freeze)
-        end
-
-        def braced_options(options)
-          if options.braces?
-            options.source
-          else
-            "{ #{options.source} }"
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/where_equals.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/where_equals.rb
deleted file mode 100644
index 217e83a711385..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/where_equals.rb
+++ /dev/null
@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Identifies places where manually constructed SQL
-      # in `where` can be replaced with `where(attribute: value)`.
-      #
-      # @safety
-      #   This cop's autocorrection is unsafe because is may change SQL.
-      #   See: https://github.com/rubocop/rubocop-rails/issues/403
-      #
-      # @example
-      #   # bad
-      #   User.where('name = ?', 'Gabe')
-      #   User.where('name = :name', name: 'Gabe')
-      #   User.where('name IS NULL')
-      #   User.where('name IN (?)', ['john', 'jane'])
-      #   User.where('name IN (:names)', names: ['john', 'jane'])
-      #   User.where('users.name = :name', name: 'Gabe')
-      #
-      #   # good
-      #   User.where(name: 'Gabe')
-      #   User.where(name: nil)
-      #   User.where(name: ['john', 'jane'])
-      #   User.where(users: { name: 'Gabe' })
-      class WhereEquals < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `%<good_method>s` instead of manually constructing SQL.'
-        RESTRICT_ON_SEND = %i[where].freeze
-
-        def_node_matcher :where_method_call?, <<~PATTERN
-          {
-            (send _ :where (array $str_type? $_ ?))
-            (send _ :where $str_type? $_ ?)
-          }
-        PATTERN
-
-        def on_send(node)
-          where_method_call?(node) do |template_node, value_node|
-            value_node = value_node.first
-
-            range = offense_range(node)
-
-            column_and_value = extract_column_and_value(template_node, value_node)
-            return unless column_and_value
-
-            good_method = build_good_method(*column_and_value)
-            message = format(MSG, good_method: good_method)
-
-            add_offense(range, message: message) do |corrector|
-              corrector.replace(range, good_method)
-            end
-          end
-        end
-
-        EQ_ANONYMOUS_RE = /\A([\w.]+)\s+=\s+\?\z/.freeze             # column = ?
-        IN_ANONYMOUS_RE = /\A([\w.]+)\s+IN\s+\(\?\)\z/i.freeze       # column IN (?)
-        EQ_NAMED_RE     = /\A([\w.]+)\s+=\s+:(\w+)\z/.freeze         # column = :column
-        IN_NAMED_RE     = /\A([\w.]+)\s+IN\s+\(:(\w+)\)\z/i.freeze   # column IN (:column)
-        IS_NULL_RE      = /\A([\w.]+)\s+IS\s+NULL\z/i.freeze         # column IS NULL
-
-        private
-
-        def offense_range(node)
-          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
-        end
-
-        def extract_column_and_value(template_node, value_node)
-          value =
-            case template_node.value
-            when EQ_ANONYMOUS_RE, IN_ANONYMOUS_RE
-              value_node.source
-            when EQ_NAMED_RE, IN_NAMED_RE
-              return unless value_node&.hash_type?
-
-              pair = value_node.pairs.find { |p| p.key.value.to_sym == Regexp.last_match(2).to_sym }
-              pair.value.source
-            when IS_NULL_RE
-              'nil'
-            else
-              return
-            end
-
-          [Regexp.last_match(1), value]
-        end
-
-        def build_good_method(column, value)
-          if column.include?('.')
-            table, column = column.split('.')
-
-            "where(#{table}: { #{column}: #{value} })"
-          else
-            "where(#{column}: #{value})"
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/where_exists.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/where_exists.rb
deleted file mode 100644
index 65b32cb467d78..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/where_exists.rb
+++ /dev/null
@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Enforces consistent style when using `exists?`.
-      #
-      # Two styles are supported for this cop. When EnforcedStyle is 'exists'
-      # then the cop enforces `exists?(...)` over `where(...).exists?`.
-      #
-      # When EnforcedStyle is 'where' then the cop enforces
-      # `where(...).exists?` over `exists?(...)`.
-      #
-      # @safety
-      #   This cop is unsafe for autocorrection because the behavior may change on the following case:
-      #
-      #   [source,ruby]
-      #   ----
-      #   Author.includes(:articles).where(articles: {id: id}).exists?
-      #   #=> Perform `eager_load` behavior (`LEFT JOIN` query) and get result.
-      #
-      #   Author.includes(:articles).exists?(articles: {id: id})
-      #   #=> Perform `preload` behavior and `ActiveRecord::StatementInvalid` error occurs.
-      #   ----
-      #
-      # @example EnforcedStyle: exists (default)
-      #   # bad
-      #   User.where(name: 'john').exists?
-      #   User.where(['name = ?', 'john']).exists?
-      #   User.where('name = ?', 'john').exists?
-      #   user.posts.where(published: true).exists?
-      #
-      #   # good
-      #   User.exists?(name: 'john')
-      #   User.where('length(name) > 10').exists?
-      #   user.posts.exists?(published: true)
-      #
-      # @example EnforcedStyle: where
-      #   # bad
-      #   User.exists?(name: 'john')
-      #   User.exists?(['name = ?', 'john'])
-      #   User.exists?('name = ?', 'john')
-      #   user.posts.exists?(published: true)
-      #
-      #   # good
-      #   User.where(name: 'john').exists?
-      #   User.where(['name = ?', 'john']).exists?
-      #   User.where('name = ?', 'john').exists?
-      #   user.posts.where(published: true).exists?
-      #   User.where('length(name) > 10').exists?
-      class WhereExists < Base
-        include ConfigurableEnforcedStyle
-        extend AutoCorrector
-
-        MSG = 'Prefer `%<good_method>s` over `%<bad_method>s`.'
-        RESTRICT_ON_SEND = %i[exists?].freeze
-
-        def_node_matcher :where_exists_call?, <<~PATTERN
-          (send (send _ :where $...) :exists?)
-        PATTERN
-
-        def_node_matcher :exists_with_args?, <<~PATTERN
-          (send _ :exists? $...)
-        PATTERN
-
-        def on_send(node)
-          find_offenses(node) do |args|
-            return unless convertable_args?(args)
-
-            range = correction_range(node)
-            good_method = build_good_method(args)
-            message = format(MSG, good_method: good_method, bad_method: range.source)
-
-            add_offense(range, message: message) do |corrector|
-              corrector.replace(range, good_method)
-            end
-          end
-        end
-
-        private
-
-        def where_style?
-          style == :where
-        end
-
-        def exists_style?
-          style == :exists
-        end
-
-        def find_offenses(node, &block)
-          if exists_style?
-            where_exists_call?(node, &block)
-          elsif where_style?
-            exists_with_args?(node, &block)
-          end
-        end
-
-        def convertable_args?(args)
-          return false if args.empty?
-
-          args.size > 1 || args[0].hash_type? || args[0].array_type?
-        end
-
-        def correction_range(node)
-          if exists_style?
-            node.receiver.loc.selector.join(node.loc.selector)
-          elsif where_style?
-            node.loc.selector.with(end_pos: node.loc.expression.end_pos)
-          end
-        end
-
-        def build_good_method(args)
-          if exists_style?
-            build_good_method_exists(args)
-          elsif where_style?
-            build_good_method_where(args)
-          end
-        end
-
-        def build_good_method_exists(args)
-          if args.size > 1
-            "exists?([#{args.map(&:source).join(', ')}])"
-          else
-            "exists?(#{args[0].source})"
-          end
-        end
-
-        def build_good_method_where(args)
-          if args.size > 1
-            "where(#{args.map(&:source).join(', ')}).exists?"
-          else
-            "where(#{args[0].source}).exists?"
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/where_not.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/where_not.rb
deleted file mode 100644
index 126b7926fa479..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails/where_not.rb
+++ /dev/null
@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Identifies places where manually constructed SQL
-      # in `where` can be replaced with `where.not(...)`.
-      #
-      # @example
-      #   # bad
-      #   User.where('name != ?', 'Gabe')
-      #   User.where('name != :name', name: 'Gabe')
-      #   User.where('name <> ?', 'Gabe')
-      #   User.where('name <> :name', name: 'Gabe')
-      #   User.where('name IS NOT NULL')
-      #   User.where('name NOT IN (?)', ['john', 'jane'])
-      #   User.where('name NOT IN (:names)', names: ['john', 'jane'])
-      #   User.where('users.name != :name', name: 'Gabe')
-      #
-      #   # good
-      #   User.where.not(name: 'Gabe')
-      #   User.where.not(name: nil)
-      #   User.where.not(name: ['john', 'jane'])
-      #   User.where.not(users: { name: 'Gabe' })
-      #
-      class WhereNot < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Use `%<good_method>s` instead of manually constructing negated SQL in `where`.'
-        RESTRICT_ON_SEND = %i[where].freeze
-
-        def_node_matcher :where_method_call?, <<~PATTERN
-          {
-            (send _ :where (array $str_type? $_ ?))
-            (send _ :where $str_type? $_ ?)
-          }
-        PATTERN
-
-        def on_send(node)
-          where_method_call?(node) do |template_node, value_node|
-            value_node = value_node.first
-
-            range = offense_range(node)
-
-            column_and_value = extract_column_and_value(template_node, value_node)
-            return unless column_and_value
-
-            good_method = build_good_method(*column_and_value)
-            message = format(MSG, good_method: good_method)
-
-            add_offense(range, message: message) do |corrector|
-              corrector.replace(range, good_method)
-            end
-          end
-        end
-
-        NOT_EQ_ANONYMOUS_RE = /\A([\w.]+)\s+(?:!=|<>)\s+\?\z/.freeze           # column != ?, column <> ?
-        NOT_IN_ANONYMOUS_RE = /\A([\w.]+)\s+NOT\s+IN\s+\(\?\)\z/i.freeze       # column NOT IN (?)
-        NOT_EQ_NAMED_RE     = /\A([\w.]+)\s+(?:!=|<>)\s+:(\w+)\z/.freeze       # column != :column, column <> :column
-        NOT_IN_NAMED_RE     = /\A([\w.]+)\s+NOT\s+IN\s+\(:(\w+)\)\z/i.freeze   # column NOT IN (:column)
-        IS_NOT_NULL_RE      = /\A([\w.]+)\s+IS\s+NOT\s+NULL\z/i.freeze         # column IS NOT NULL
-
-        private
-
-        def offense_range(node)
-          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
-        end
-
-        def extract_column_and_value(template_node, value_node)
-          value =
-            case template_node.value
-            when NOT_EQ_ANONYMOUS_RE, NOT_IN_ANONYMOUS_RE
-              value_node.source
-            when NOT_EQ_NAMED_RE, NOT_IN_NAMED_RE
-              return unless value_node.hash_type?
-
-              pair = value_node.pairs.find { |p| p.key.value.to_sym == Regexp.last_match(2).to_sym }
-              pair.value.source
-            when IS_NOT_NULL_RE
-              'nil'
-            else
-              return
-            end
-
-          [Regexp.last_match(1), value]
-        end
-
-        def build_good_method(column, value)
-          if column.include?('.')
-            table, column = column.split('.')
-
-            "where.not(#{table}: { #{column}: #{value} })"
-          else
-            "where.not(#{column}: #{value})"
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails_cops.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails_cops.rb
deleted file mode 100644
index cf7c6c5769693..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/cop/rails_cops.rb
+++ /dev/null
@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'mixin/active_record_helper'
-require_relative 'mixin/active_record_migrations_helper'
-require_relative 'mixin/class_send_node_helper'
-require_relative 'mixin/enforce_superclass'
-require_relative 'mixin/index_method'
-require_relative 'mixin/migrations_helper'
-require_relative 'mixin/target_rails_version'
-
-require_relative 'rails/action_controller_test_case'
-require_relative 'rails/action_filter'
-require_relative 'rails/active_record_aliases'
-require_relative 'rails/active_record_callbacks_order'
-require_relative 'rails/active_record_override'
-require_relative 'rails/active_support_aliases'
-require_relative 'rails/add_column_index'
-require_relative 'rails/after_commit_override'
-require_relative 'rails/application_controller'
-require_relative 'rails/application_job'
-require_relative 'rails/application_mailer'
-require_relative 'rails/application_record'
-require_relative 'rails/arel_star'
-require_relative 'rails/assert_not'
-require_relative 'rails/attribute_default_block_value'
-require_relative 'rails/belongs_to'
-require_relative 'rails/blank'
-require_relative 'rails/bulk_change_table'
-require_relative 'rails/compact_blank'
-require_relative 'rails/content_tag'
-require_relative 'rails/create_table_with_timestamps'
-require_relative 'rails/date'
-require_relative 'rails/default_scope'
-require_relative 'rails/delegate'
-require_relative 'rails/delegate_allow_blank'
-require_relative 'rails/deprecated_active_model_errors_methods'
-require_relative 'rails/dot_separated_keys'
-require_relative 'rails/duplicate_association'
-require_relative 'rails/duplicate_scope'
-require_relative 'rails/duration_arithmetic'
-require_relative 'rails/dynamic_find_by'
-require_relative 'rails/eager_evaluation_log_message'
-require_relative 'rails/enum_hash'
-require_relative 'rails/enum_uniqueness'
-require_relative 'rails/environment_comparison'
-require_relative 'rails/environment_variable_access'
-require_relative 'rails/exit'
-require_relative 'rails/expanded_date_range'
-require_relative 'rails/file_path'
-require_relative 'rails/find_by'
-require_relative 'rails/find_by_id'
-require_relative 'rails/find_each'
-require_relative 'rails/has_and_belongs_to_many'
-require_relative 'rails/has_many_or_has_one_dependent'
-require_relative 'rails/helper_instance_variable'
-require_relative 'rails/http_positional_arguments'
-require_relative 'rails/http_status'
-require_relative 'rails/i18n_lazy_lookup'
-require_relative 'rails/i18n_locale_assignment'
-require_relative 'rails/i18n_locale_texts'
-require_relative 'rails/ignored_skip_action_filter_option'
-require_relative 'rails/index_by'
-require_relative 'rails/index_with'
-require_relative 'rails/inquiry'
-require_relative 'rails/inverse_of'
-require_relative 'rails/lexically_scoped_action_filter'
-require_relative 'rails/link_to_blank'
-require_relative 'rails/mailer_name'
-require_relative 'rails/match_route'
-require_relative 'rails/migration_class_name'
-require_relative 'rails/negate_include'
-require_relative 'rails/not_null_column'
-require_relative 'rails/order_by_id'
-require_relative 'rails/output'
-require_relative 'rails/output_safety'
-require_relative 'rails/pick'
-require_relative 'rails/pluck'
-require_relative 'rails/pluck_id'
-require_relative 'rails/pluck_in_where'
-require_relative 'rails/pluralization_grammar'
-require_relative 'rails/presence'
-require_relative 'rails/present'
-require_relative 'rails/rake_environment'
-require_relative 'rails/read_write_attribute'
-require_relative 'rails/redundant_allow_nil'
-require_relative 'rails/redundant_foreign_key'
-require_relative 'rails/redundant_presence_validation_on_belongs_to'
-require_relative 'rails/redundant_receiver_in_with_options'
-require_relative 'rails/redundant_travel_back'
-require_relative 'rails/reflection_class_name'
-require_relative 'rails/refute_methods'
-require_relative 'rails/relative_date_constant'
-require_relative 'rails/render_inline'
-require_relative 'rails/render_plain_text'
-require_relative 'rails/request_referer'
-require_relative 'rails/require_dependency'
-require_relative 'rails/reversible_migration'
-require_relative 'rails/reversible_migration_method_definition'
-require_relative 'rails/root_join_chain'
-require_relative 'rails/root_public_path'
-require_relative 'rails/safe_navigation'
-require_relative 'rails/safe_navigation_with_blank'
-require_relative 'rails/save_bang'
-require_relative 'rails/schema_comment'
-require_relative 'rails/scope_args'
-require_relative 'rails/short_i18n'
-require_relative 'rails/skips_model_validations'
-require_relative 'rails/squished_sql_heredocs'
-require_relative 'rails/strip_heredoc'
-require_relative 'rails/table_name_assignment'
-require_relative 'rails/time_zone'
-require_relative 'rails/time_zone_assignment'
-require_relative 'rails/to_formatted_s'
-require_relative 'rails/transaction_exit_statement'
-require_relative 'rails/uniq_before_pluck'
-require_relative 'rails/unique_validation_without_index'
-require_relative 'rails/unknown_env'
-require_relative 'rails/unused_ignored_columns'
-require_relative 'rails/validation'
-require_relative 'rails/where_equals'
-require_relative 'rails/where_exists'
-require_relative 'rails/where_not'
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails.rb
deleted file mode 100644
index f94bb9658d2d9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  # RuboCop Rails project namespace
-  module Rails
-    PROJECT_ROOT   = Pathname.new(__dir__).parent.parent.expand_path.freeze
-    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
-    CONFIG         = YAML.safe_load(CONFIG_DEFAULT.read).freeze
-
-    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
-
-    ::RuboCop::ConfigObsoletion.files << PROJECT_ROOT.join('config', 'obsoletion.yml')
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails/inject.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails/inject.rb
deleted file mode 100644
index da7ead5ea2e73..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails/inject.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Rails
-    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
-    # bit of our configuration.
-    module Inject
-      def self.defaults!
-        path = CONFIG_DEFAULT.to_s
-        hash = ConfigLoader.send(:load_yaml_configuration, path)
-        config = Config.new(hash, path).tap(&:make_excludes_absolute)
-        puts "configuration from #{path}" if ConfigLoader.debug?
-        config = ConfigLoader.merge_with_default(config, path, unset_nil: false)
-        ConfigLoader.instance_variable_set(:@default_configuration, config)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails/schema_loader.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails/schema_loader.rb
deleted file mode 100644
index 86041d69310b5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails/schema_loader.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Rails
-    # It loads db/schema.rb and return Schema object.
-    # Cops refers database schema information with this module.
-    module SchemaLoader
-      extend self
-
-      # It parses `db/schema.rb` and return it.
-      # It returns `nil` if it can't find `db/schema.rb`.
-      # So a cop that uses the loader should handle `nil` properly.
-      #
-      # @return [Schema, nil]
-      def load(target_ruby_version)
-        return @load if defined?(@load)
-
-        @load = load!(target_ruby_version)
-      end
-
-      def reset!
-        return unless instance_variable_defined?(:@load)
-
-        remove_instance_variable(:@load)
-      end
-
-      def db_schema_path
-        path = Pathname.pwd
-        until path.root?
-          schema_path = path.join('db/schema.rb')
-          return schema_path if schema_path.exist?
-
-          path = path.join('../').cleanpath
-        end
-
-        nil
-      end
-
-      private
-
-      def load!(target_ruby_version)
-        path = db_schema_path
-        return unless path
-
-        ast = parse(path, target_ruby_version)
-        Schema.new(ast)
-      end
-
-      def parse(path, target_ruby_version)
-        klass_name = :"Ruby#{target_ruby_version.to_s.sub('.', '')}"
-        klass = ::Parser.const_get(klass_name)
-        parser = klass.new(RuboCop::AST::Builder.new)
-
-        buffer = Parser::Source::Buffer.new(path, 1)
-        buffer.source = path.read
-
-        parser.parse(buffer)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails/schema_loader/schema.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails/schema_loader/schema.rb
deleted file mode 100644
index 60a77213663af..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails/schema_loader/schema.rb
+++ /dev/null
@@ -1,191 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Rails
-    module SchemaLoader
-      # Represent db/schema.rb
-      class Schema
-        attr_reader :tables, :add_indices
-
-        def initialize(ast)
-          @tables = []
-          @add_indices = []
-
-          build!(ast)
-        end
-
-        def table_by(name:)
-          tables.find do |table|
-            table.name == name
-          end
-        end
-
-        def add_indices_by(table_name:)
-          add_indices.select do |add_index|
-            add_index.table_name == table_name
-          end
-        end
-
-        private
-
-        def build!(ast)
-          raise "Unexpected type: #{ast.type}" unless ast.block_type?
-
-          each_table(ast) do |table_def|
-            next unless table_def.method?(:create_table)
-
-            @tables << Table.new(table_def)
-          end
-
-          # Compatibility for Rails 4.2.
-          each_add_index(ast) do |add_index_def|
-            @add_indices << AddIndex.new(add_index_def)
-          end
-        end
-
-        def each_table(ast)
-          case ast.body.type
-          when :begin
-            ast.body.children.each do |node|
-              next unless node.block_type? && node.method?(:create_table)
-
-              yield(node)
-            end
-          else
-            yield ast.body
-          end
-        end
-
-        def each_add_index(ast)
-          ast.body.children.each do |node|
-            next unless node.respond_to?(:send_type?)
-            next if !node&.send_type? || !node.method?(:add_index)
-
-            yield(node)
-          end
-        end
-      end
-
-      # Represent a table
-      class Table
-        attr_reader :name, :columns, :indices
-
-        def initialize(node)
-          @name = node.send_node.first_argument.value
-          @columns = build_columns(node)
-          @indices = build_indices(node)
-        end
-
-        def with_column?(name:)
-          @columns.any? { |c| c.name == name }
-        end
-
-        private
-
-        def build_columns(node)
-          each_content(node).map do |child|
-            next unless child&.send_type?
-            next if child.method?(:index)
-
-            Column.new(child)
-          end.compact
-        end
-
-        def build_indices(node)
-          each_content(node).map do |child|
-            next unless child&.send_type?
-            next unless child.method?(:index)
-
-            Index.new(child)
-          end.compact
-        end
-
-        def each_content(node, &block)
-          return enum_for(__method__, node) unless block
-
-          case node.body&.type
-          when :begin
-            node.body.children.each(&block)
-          else
-            yield(node.body)
-          end
-        end
-      end
-
-      # Represent a column
-      class Column
-        attr_reader :name, :type, :not_null
-
-        def initialize(node)
-          @name = node.first_argument.str_content
-          @type = node.method_name
-          @not_null = nil
-
-          analyze_keywords!(node)
-        end
-
-        private
-
-        def analyze_keywords!(node)
-          pairs = node.arguments.last
-          return unless pairs.hash_type?
-
-          pairs.each_pair do |k, v|
-            @not_null = !v.true_type? if k.value == :null
-          end
-        end
-      end
-
-      # Represent an index
-      class Index
-        attr_reader :name, :columns, :expression, :unique
-
-        def initialize(node)
-          @columns, @expression = build_columns_or_expr(node.first_argument)
-          @unique = nil
-
-          analyze_keywords!(node)
-        end
-
-        private
-
-        def build_columns_or_expr(columns)
-          if columns.array_type?
-            [columns.values.map(&:value), nil]
-          else
-            [[], columns.value]
-          end
-        end
-
-        def analyze_keywords!(node)
-          pairs = node.arguments.last
-          return unless pairs.hash_type?
-
-          pairs.each_pair do |k, v|
-            case k.value
-            when :name
-              @name = v.value
-            when :unique
-              @unique = true
-            end
-          end
-        end
-      end
-
-      # Represent an `add_index`
-      class AddIndex < Index
-        attr_reader :table_name
-
-        def initialize(node)
-          super(node)
-
-          @table_name = node.first_argument.value
-          @columns, @expression = build_columns_or_expr(node.arguments[1])
-          @unique = nil
-
-          analyze_keywords!(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails/version.rb
deleted file mode 100644
index 0b65ad0ee2747..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rails-2.15.2/lib/rubocop/rails/version.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Rails
-    # This module holds the RuboCop Rails version information.
-    module Version
-      STRING = '2.15.2'
-
-      def self.document_version
-        STRING.match('\d+\.\d+').to_s
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/config/default.yml b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/config/default.yml
deleted file mode 100644
index b584a7c591ba4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/config/default.yml
+++ /dev/null
@@ -1,928 +0,0 @@
----
-RSpec:
-  Enabled: true
-  StyleGuideBaseURL: https://rspec.rubystyle.guide
-  Include: &1
-    - "**/*_spec.rb"
-    - "**/spec/**/*"
-  Language: &2
-    inherit_mode:
-      merge:
-        - Expectations
-        - Helpers
-        - Hooks
-        - HookScopes
-        - Runners
-        - Subjects
-    ExampleGroups:
-      inherit_mode:
-        merge:
-          - Regular
-          - Skipped
-          - Focused
-      Regular:
-        - describe
-        - context
-        - feature
-        - example_group
-      Skipped:
-        - xdescribe
-        - xcontext
-        - xfeature
-      Focused:
-        - fdescribe
-        - fcontext
-        - ffeature
-    Examples:
-      inherit_mode:
-        merge:
-          - Regular
-          - Skipped
-          - Focused
-          - Pending
-      Regular:
-        - it
-        - specify
-        - example
-        - scenario
-        - its
-      Focused:
-        - fit
-        - fspecify
-        - fexample
-        - fscenario
-        - focus
-      Skipped:
-        - xit
-        - xspecify
-        - xexample
-        - xscenario
-        - skip
-      Pending:
-        - pending
-    Expectations:
-      - expect
-      - is_expected
-      - expect_any_instance_of
-    Helpers:
-      - let
-      - let!
-    Hooks:
-      - prepend_before
-      - before
-      - append_before
-      - around
-      - prepend_after
-      - after
-      - append_after
-    HookScopes:
-      - each
-      - example
-      - context
-      - all
-      - suite
-    Includes:
-      inherit_mode:
-        merge:
-          - Examples
-          - Context
-      Examples:
-        - it_behaves_like
-        - it_should_behave_like
-        - include_examples
-      Context:
-        - include_context
-    Runners:
-      - to
-      - to_not
-      - not_to
-    SharedGroups:
-      inherit_mode:
-        merge:
-          - Examples
-          - Context
-      Examples:
-        - shared_examples
-        - shared_examples_for
-      Context:
-        - shared_context
-    Subjects:
-      - subject
-      - subject!
-
-Metrics/BlockLength:
-  inherit_mode:
-    merge:
-      - Exclude
-  Exclude:
-    - "**/*_spec.rb"
-    - "**/spec/**/*"
-
-RSpec/AlignLeftLetBrace:
-  Description: Checks that left braces for adjacent single line lets are aligned.
-  Enabled: false
-  VersionAdded: '1.16'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AlignLeftLetBrace
-
-RSpec/AlignRightLetBrace:
-  Description: Checks that right braces for adjacent single line lets are aligned.
-  Enabled: false
-  VersionAdded: '1.16'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AlignRightLetBrace
-
-RSpec/AnyInstance:
-  Description: Check that instances are not being stubbed globally.
-  Enabled: true
-  VersionAdded: '1.4'
-  StyleGuide: https://rspec.rubystyle.guide/#any_instance_of
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AnyInstance
-
-RSpec/AroundBlock:
-  Description: Checks that around blocks actually run the test.
-  Enabled: true
-  VersionAdded: '1.11'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AroundBlock
-
-RSpec/Be:
-  Description: Check for expectations where `be` is used without argument.
-  Enabled: true
-  VersionAdded: '1.25'
-  StyleGuide: https://rspec.rubystyle.guide/#be-matcher
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Be
-
-RSpec/BeEq:
-  Description: Check for expectations where `be(...)` can replace `eq(...)`.
-  Enabled: pending
-  VersionAdded: 2.9.0
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeEq
-
-RSpec/BeEql:
-  Description: Check for expectations where `be(...)` can replace `eql(...)`.
-  Enabled: true
-  VersionAdded: '1.7'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeEql
-
-RSpec/BeNil:
-  Description: Ensures a consistent style is used when matching `nil`.
-  Enabled: pending
-  EnforcedStyle: be_nil
-  SupportedStyles:
-    - be
-    - be_nil
-  VersionAdded: 2.9.0
-  VersionChanged: 2.10.0
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeNil
-
-RSpec/BeforeAfterAll:
-  Description: Check that before/after(:all) isn't being used.
-  Enabled: true
-  Exclude:
-    - spec/spec_helper.rb
-    - spec/rails_helper.rb
-    - spec/support/**/*.rb
-  VersionAdded: '1.12'
-  StyleGuide: https://rspec.rubystyle.guide/#avoid-hooks-with-context-scope
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeforeAfterAll
-
-RSpec/ChangeByZero:
-  Description: Prefer negated matchers over `to change.by(0)`.
-  Enabled: pending
-  VersionAdded: 2.11.0
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ChangeByZero
-
-RSpec/ContextMethod:
-  Description: "`context` should not be used for specifying methods."
-  Enabled: true
-  VersionAdded: '1.36'
-  StyleGuide: https://rspec.rubystyle.guide/#example-group-naming
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContextMethod
-
-RSpec/ContextWording:
-  Description: Checks that `context` docstring starts with an allowed prefix.
-  Enabled: true
-  Prefixes:
-    - when
-    - with
-    - without
-  VersionAdded: '1.20'
-  VersionChanged: 1.20.1
-  StyleGuide: https://rspec.rubystyle.guide/#context-descriptions
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContextWording
-
-RSpec/DescribeClass:
-  Description: Check that the first argument to the top-level describe is a constant.
-  Enabled: true
-  Exclude:
-    - "**/spec/features/**/*"
-    - "**/spec/requests/**/*"
-    - "**/spec/routing/**/*"
-    - "**/spec/system/**/*"
-    - "**/spec/views/**/*"
-  IgnoredMetadata:
-    type:
-      - channel
-      - controller
-      - helper
-      - job
-      - mailer
-      - model
-      - request
-      - routing
-      - view
-      - feature
-      - system
-      - mailbox
-      - aruba
-      - task
-  VersionAdded: '1.0'
-  VersionChanged: '2.7'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeClass
-
-RSpec/DescribeMethod:
-  Description: Checks that the second argument to `describe` specifies a method.
-  Enabled: true
-  VersionAdded: '1.0'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeMethod
-
-RSpec/DescribeSymbol:
-  Description: Avoid describing symbols.
-  Enabled: true
-  VersionAdded: '1.15'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeSymbol
-
-RSpec/DescribedClass:
-  Description: Checks that tests use `described_class`.
-  Enabled: true
-  SkipBlocks: false
-  EnforcedStyle: described_class
-  SupportedStyles:
-    - described_class
-    - explicit
-  SafeAutoCorrect: false
-  VersionAdded: '1.0'
-  VersionChanged: '1.11'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribedClass
-
-RSpec/DescribedClassModuleWrapping:
-  Description: Avoid opening modules and defining specs within them.
-  Enabled: false
-  VersionAdded: '1.37'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribedClassModuleWrapping
-
-RSpec/Dialect:
-  Description: Enforces custom RSpec dialects.
-  Enabled: false
-  PreferredMethods: {}
-  VersionAdded: '1.33'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Dialect
-
-RSpec/EmptyExampleGroup:
-  Description: Checks if an example group does not include any tests.
-  Enabled: true
-  VersionAdded: '1.7'
-  VersionChanged: '2.0'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyExampleGroup
-
-RSpec/EmptyHook:
-  Description: Checks for empty before and after hooks.
-  Enabled: true
-  VersionAdded: '1.39'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyHook
-
-RSpec/EmptyLineAfterExample:
-  Description: Checks if there is an empty line after example blocks.
-  Enabled: true
-  AllowConsecutiveOneLiners: true
-  VersionAdded: '1.36'
-  StyleGuide: https://rspec.rubystyle.guide/#empty-lines-around-examples
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterExample
-
-RSpec/EmptyLineAfterExampleGroup:
-  Description: Checks if there is an empty line after example group blocks.
-  Enabled: true
-  VersionAdded: '1.27'
-  StyleGuide: https://rspec.rubystyle.guide/#empty-lines-between-describes
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterExampleGroup
-
-RSpec/EmptyLineAfterFinalLet:
-  Description: Checks if there is an empty line after the last let block.
-  Enabled: true
-  VersionAdded: '1.14'
-  StyleGuide: https://rspec.rubystyle.guide/#empty-line-after-let
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterFinalLet
-
-RSpec/EmptyLineAfterHook:
-  Description: Checks if there is an empty line after hook blocks.
-  Enabled: true
-  VersionAdded: '1.27'
-  StyleGuide: https://rspec.rubystyle.guide/#empty-line-after-let
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterHook
-
-RSpec/EmptyLineAfterSubject:
-  Description: Checks if there is an empty line after subject block.
-  Enabled: true
-  VersionAdded: '1.14'
-  StyleGuide: https://rspec.rubystyle.guide/#empty-line-after-let
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterSubject
-
-RSpec/ExampleLength:
-  Description: Checks for long examples.
-  Enabled: true
-  Max: 5
-  CountAsOne: []
-  VersionAdded: '1.5'
-  VersionChanged: '2.3'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleLength
-
-RSpec/ExampleWithoutDescription:
-  Description: Checks for examples without a description.
-  Enabled: true
-  EnforcedStyle: always_allow
-  SupportedStyles:
-    - always_allow
-    - single_line_only
-    - disallow
-  VersionAdded: '1.22'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleWithoutDescription
-
-RSpec/ExcessiveDocstringSpacing:
-  Description: Checks for excessive whitespace in example descriptions.
-  Enabled: pending
-  VersionAdded: '2.5'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExcessiveDocstringSpacing
-
-RSpec/ExampleWording:
-  Description: Checks for common mistakes in example descriptions.
-  Enabled: true
-  CustomTransform:
-    be: is
-    BE: IS
-    have: has
-    HAVE: HAS
-  IgnoredWords: []
-  VersionAdded: '1.0'
-  VersionChanged: '1.2'
-  StyleGuide: https://rspec.rubystyle.guide/#should-in-example-docstrings
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleWording
-
-RSpec/ExpectActual:
-  Description: Checks for `expect(...)` calls containing literal values.
-  Enabled: true
-  Exclude:
-    - spec/routing/**/*
-  VersionAdded: '1.7'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectActual
-
-RSpec/ExpectChange:
-  Description: Checks for consistent style of change matcher.
-  Enabled: true
-  EnforcedStyle: method_call
-  SupportedStyles:
-    - method_call
-    - block
-  SafeAutoCorrect: false
-  VersionAdded: '1.22'
-  VersionChanged: '2.5'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectChange
-
-RSpec/ExpectInHook:
-  Description: Do not use `expect` in hooks such as `before`.
-  Enabled: true
-  VersionAdded: '1.16'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectInHook
-
-RSpec/ExpectOutput:
-  Description: Checks for opportunities to use `expect { ... }.to output`.
-  Enabled: true
-  VersionAdded: '1.10'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectOutput
-
-RSpec/FilePath:
-  Description: Checks that spec file paths are consistent and well-formed.
-  Enabled: true
-  Include:
-    - "**/*_spec*rb*"
-    - "**/spec/**/*"
-  CustomTransform:
-    RuboCop: rubocop
-    RSpec: rspec
-  IgnoreMethods: false
-  SpecSuffixOnly: false
-  VersionAdded: '1.2'
-  VersionChanged: '1.40'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FilePath
-
-RSpec/Focus:
-  Description: Checks if examples are focused.
-  Enabled: true
-  VersionAdded: '1.5'
-  VersionChanged: '2.1'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Focus
-
-RSpec/HookArgument:
-  Description: Checks the arguments passed to `before`, `around`, and `after`.
-  Enabled: true
-  EnforcedStyle: implicit
-  SupportedStyles:
-    - implicit
-    - each
-    - example
-  VersionAdded: '1.7'
-  StyleGuide: https://rspec.rubystyle.guide/#redundant-beforeeach
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/HookArgument
-
-RSpec/HooksBeforeExamples:
-  Description: Checks for before/around/after hooks that come after an example.
-  Enabled: true
-  VersionAdded: '1.29'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/HooksBeforeExamples
-
-RSpec/IdenticalEqualityAssertion:
-  Description: Checks for equality assertions with identical expressions on both sides.
-  Enabled: pending
-  VersionAdded: '2.4'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IdenticalEqualityAssertion
-
-RSpec/ImplicitBlockExpectation:
-  Description: Check that implicit block expectation syntax is not used.
-  Enabled: true
-  VersionAdded: '1.35'
-  StyleGuide: https://rspec.rubystyle.guide/#implicit-block-expectations
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitBlockExpectation
-
-RSpec/ImplicitExpect:
-  Description: Check that a consistent implicit expectation style is used.
-  Enabled: true
-  EnforcedStyle: is_expected
-  SupportedStyles:
-    - is_expected
-    - should
-  VersionAdded: '1.8'
-  StyleGuide: https://rspec.rubystyle.guide/#use-expect
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitExpect
-
-RSpec/ImplicitSubject:
-  Description: Checks for usage of implicit subject (`is_expected` / `should`).
-  Enabled: true
-  EnforcedStyle: single_line_only
-  SupportedStyles:
-    - single_line_only
-    - single_statement_only
-    - disallow
-  VersionAdded: '1.29'
-  VersionChanged: '1.30'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitSubject
-
-RSpec/InstanceSpy:
-  Description: Checks for `instance_double` used with `have_received`.
-  Enabled: true
-  VersionAdded: '1.12'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InstanceSpy
-
-RSpec/InstanceVariable:
-  Description: Checks for instance variable usage in specs.
-  Enabled: true
-  AssignmentOnly: false
-  VersionAdded: '1.0'
-  VersionChanged: '1.7'
-  StyleGuide: https://rspec.rubystyle.guide/#instance-variables
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InstanceVariable
-
-RSpec/ItBehavesLike:
-  Description: Checks that only one `it_behaves_like` style is used.
-  Enabled: true
-  EnforcedStyle: it_behaves_like
-  SupportedStyles:
-    - it_behaves_like
-    - it_should_behave_like
-  VersionAdded: '1.13'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ItBehavesLike
-
-RSpec/IteratedExpectation:
-  Description: Check that `all` matcher is used instead of iterating over an array.
-  Enabled: true
-  VersionAdded: '1.14'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IteratedExpectation
-
-RSpec/LeadingSubject:
-  Description: Enforce that subject is the first definition in the test.
-  Enabled: true
-  VersionAdded: '1.7'
-  VersionChanged: '1.14'
-  StyleGuide: https://rspec.rubystyle.guide/#leading-subject
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LeadingSubject
-
-RSpec/LeakyConstantDeclaration:
-  Description: Checks that no class, module, or constant is declared.
-  Enabled: true
-  VersionAdded: '1.35'
-  StyleGuide: https://rspec.rubystyle.guide/#declare-constants
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LeakyConstantDeclaration
-
-RSpec/LetBeforeExamples:
-  Description: Checks for `let` definitions that come after an example.
-  Enabled: true
-  VersionAdded: '1.16'
-  VersionChanged: '1.22'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LetBeforeExamples
-
-RSpec/LetSetup:
-  Description: Checks unreferenced `let!` calls being used for test setup.
-  Enabled: true
-  VersionAdded: '1.7'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LetSetup
-
-RSpec/MessageChain:
-  Description: Check that chains of messages are not being stubbed.
-  Enabled: true
-  VersionAdded: '1.7'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageChain
-
-RSpec/MessageExpectation:
-  Description: Checks for consistent message expectation style.
-  Enabled: false
-  EnforcedStyle: allow
-  SupportedStyles:
-    - allow
-    - expect
-  VersionAdded: '1.7'
-  VersionChanged: '1.8'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageExpectation
-
-RSpec/MessageSpies:
-  Description: Checks that message expectations are set using spies.
-  Enabled: true
-  EnforcedStyle: have_received
-  SupportedStyles:
-    - have_received
-    - receive
-  VersionAdded: '1.9'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageSpies
-
-RSpec/MissingExampleGroupArgument:
-  Description: Checks that the first argument to an example group is not empty.
-  Enabled: true
-  VersionAdded: '1.28'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MissingExampleGroupArgument
-
-RSpec/MultipleDescribes:
-  Description: Checks for multiple top-level example groups.
-  Enabled: true
-  VersionAdded: '1.0'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleDescribes
-
-RSpec/MultipleExpectations:
-  Description: Checks if examples contain too many `expect` calls.
-  Enabled: true
-  Max: 1
-  VersionAdded: '1.7'
-  VersionChanged: '1.21'
-  StyleGuide: https://rspec.rubystyle.guide/#expectation-per-example
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleExpectations
-
-RSpec/MultipleMemoizedHelpers:
-  Description: Checks if example groups contain too many `let` and `subject` calls.
-  Enabled: true
-  AllowSubject: true
-  Max: 5
-  VersionAdded: '1.43'
-  StyleGuide: https://rspec.rubystyle.guide/#let-blocks
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleMemoizedHelpers
-
-RSpec/MultipleSubjects:
-  Description: Checks if an example group defines `subject` multiple times.
-  Enabled: true
-  VersionAdded: '1.16'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleSubjects
-
-RSpec/NamedSubject:
-  Description: Checks for explicitly referenced test subjects.
-  Enabled: true
-  IgnoreSharedExamples: true
-  VersionAdded: 1.5.3
-  StyleGuide: https://rspec.rubystyle.guide/#use-subject
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NamedSubject
-
-RSpec/NestedGroups:
-  Description: Checks for nested example groups.
-  Enabled: true
-  Max: 3
-  VersionAdded: '1.7'
-  VersionChanged: '1.10'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NestedGroups
-
-RSpec/NotToNot:
-  Description: Checks for consistent method usage for negating expectations.
-  Enabled: true
-  EnforcedStyle: not_to
-  SupportedStyles:
-    - not_to
-    - to_not
-  VersionAdded: '1.4'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NotToNot
-
-RSpec/OverwritingSetup:
-  Description: Checks if there is a let/subject that overwrites an existing one.
-  Enabled: true
-  VersionAdded: '1.14'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/OverwritingSetup
-
-RSpec/Pending:
-  Description: Checks for any pending or skipped examples.
-  Enabled: false
-  VersionAdded: '1.25'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Pending
-
-RSpec/PredicateMatcher:
-  Description: Prefer using predicate matcher over using predicate method directly.
-  Enabled: true
-  Strict: true
-  EnforcedStyle: inflected
-  AllowedExplicitMatchers: []
-  SupportedStyles:
-    - inflected
-    - explicit
-  SafeAutoCorrect: false
-  VersionAdded: '1.16'
-  StyleGuide: https://rspec.rubystyle.guide/#predicate-matchers
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/PredicateMatcher
-
-RSpec/ReceiveCounts:
-  Description: Check for `once` and `twice` receive counts matchers usage.
-  Enabled: true
-  VersionAdded: '1.26'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReceiveCounts
-
-RSpec/ReceiveNever:
-  Description: Prefer `not_to receive(...)` over `receive(...).never`.
-  Enabled: true
-  VersionAdded: '1.28'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReceiveNever
-
-RSpec/RepeatedDescription:
-  Description: Check for repeated description strings in example groups.
-  Enabled: true
-  VersionAdded: '1.9'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedDescription
-
-RSpec/RepeatedExample:
-  Description: Check for repeated examples within example groups.
-  Enabled: true
-  VersionAdded: '1.10'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExample
-
-RSpec/RepeatedExampleGroupBody:
-  Description: Check for repeated describe and context block body.
-  Enabled: true
-  VersionAdded: '1.38'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExampleGroupBody
-
-RSpec/RepeatedExampleGroupDescription:
-  Description: Check for repeated example group descriptions.
-  Enabled: true
-  VersionAdded: '1.38'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExampleGroupDescription
-
-RSpec/RepeatedIncludeExample:
-  Description: Check for repeated include of shared examples.
-  Enabled: true
-  VersionAdded: '1.44'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedIncludeExample
-
-RSpec/ReturnFromStub:
-  Description: Checks for consistent style of stub's return setting.
-  Enabled: true
-  EnforcedStyle: and_return
-  SupportedStyles:
-    - and_return
-    - block
-  VersionAdded: '1.16'
-  VersionChanged: '1.22'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReturnFromStub
-
-RSpec/ScatteredLet:
-  Description: Checks for let scattered across the example group.
-  Enabled: true
-  VersionAdded: '1.14'
-  VersionChanged: '1.39'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ScatteredLet
-
-RSpec/ScatteredSetup:
-  Description: Checks for setup scattered across multiple hooks in an example group.
-  Enabled: true
-  VersionAdded: '1.10'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ScatteredSetup
-
-RSpec/SharedContext:
-  Description: Checks for proper shared_context and shared_examples usage.
-  Enabled: true
-  VersionAdded: '1.13'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SharedContext
-
-RSpec/SharedExamples:
-  Description: Enforces use of string to titleize shared examples.
-  Enabled: true
-  VersionAdded: '1.25'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SharedExamples
-
-RSpec/SingleArgumentMessageChain:
-  Description: Checks that chains of messages contain more than one element.
-  Enabled: true
-  VersionAdded: '1.9'
-  VersionChanged: '1.10'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SingleArgumentMessageChain
-
-RSpec/StubbedMock:
-  Description: Checks that message expectations do not have a configured response.
-  Enabled: true
-  VersionAdded: '1.44'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/StubbedMock
-
-RSpec/SubjectDeclaration:
-  Description: Ensure that subject is defined using subject helper.
-  Enabled: pending
-  VersionAdded: '2.5'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SubjectDeclaration
-
-RSpec/SubjectStub:
-  Description: Checks for stubbed test subjects.
-  Enabled: true
-  VersionAdded: '1.7'
-  VersionChanged: '2.8'
-  StyleGuide: https://rspec.rubystyle.guide/#dont-stub-subject
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SubjectStub
-
-RSpec/UnspecifiedException:
-  Description: Checks for a specified error in checking raised errors.
-  Enabled: true
-  VersionAdded: '1.30'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/UnspecifiedException
-
-RSpec/VariableDefinition:
-  Description: Checks that memoized helpers names are symbols or strings.
-  Enabled: true
-  EnforcedStyle: symbols
-  SupportedStyles:
-    - symbols
-    - strings
-  VersionAdded: '1.40'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VariableDefinition
-
-RSpec/VariableName:
-  Description: Checks that memoized helper names use the configured style.
-  Enabled: true
-  EnforcedStyle: snake_case
-  SupportedStyles:
-    - snake_case
-    - camelCase
-  IgnoredPatterns: []
-  VersionAdded: '1.40'
-  VersionChanged: '1.43'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VariableName
-
-RSpec/VerifiedDoubleReference:
-  Description: Checks for consistent verified double reference style.
-  Enabled: pending
-  SafeAutoCorrect: false
-  EnforcedStyle: constant
-  SupportedStyles:
-    - constant
-    - string
-  VersionAdded: 2.10.0
-  VersionChanged: '2.12'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VerifiedDoubleReference
-
-RSpec/VerifiedDoubles:
-  Description: Prefer using verifying doubles over normal doubles.
-  Enabled: true
-  IgnoreNameless: true
-  IgnoreSymbolicNames: false
-  VersionAdded: 1.2.1
-  VersionChanged: '1.5'
-  StyleGuide: https://rspec.rubystyle.guide/#doubles
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VerifiedDoubles
-
-RSpec/VoidExpect:
-  Description: Checks void `expect()`.
-  Enabled: true
-  VersionAdded: '1.16'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VoidExpect
-
-RSpec/Yield:
-  Description: Checks for calling a block within a stub.
-  Enabled: true
-  VersionAdded: '1.32'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Yield
-
-RSpec/Capybara:
-  Enabled: true
-  Include: *1
-  Language: *2
-
-RSpec/Capybara/CurrentPathExpectation:
-  Description: Checks that no expectations are set on Capybara's `current_path`.
-  Enabled: true
-  VersionAdded: '1.18'
-  VersionChanged: '2.0'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/CurrentPathExpectation
-
-RSpec/Capybara/FeatureMethods:
-  Description: Checks for consistent method usage in feature specs.
-  Enabled: true
-  EnabledMethods: []
-  VersionAdded: '1.17'
-  VersionChanged: '2.0'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/FeatureMethods
-
-RSpec/Capybara/SpecificMatcher:
-  Description: Checks for there is a more specific matcher offered by Capybara.
-  Enabled: pending
-  VersionAdded: '2.12'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/SpecificMatcher
-
-RSpec/Capybara/VisibilityMatcher:
-  Description: Checks for boolean visibility in Capybara finders.
-  Enabled: true
-  VersionAdded: '1.39'
-  VersionChanged: '2.0'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/VisibilityMatcher
-
-RSpec/FactoryBot:
-  Enabled: true
-  Include: *1
-  Language: *2
-
-RSpec/FactoryBot/AttributeDefinedStatically:
-  Description: Always declare attribute values as blocks.
-  Enabled: true
-  Include:
-    - spec/factories.rb
-    - spec/factories/**/*.rb
-    - features/support/factories/**/*.rb
-  VersionAdded: '1.28'
-  VersionChanged: '2.0'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/AttributeDefinedStatically
-
-RSpec/FactoryBot/CreateList:
-  Description: Checks for create_list usage.
-  Enabled: true
-  Include:
-    - "**/*_spec.rb"
-    - "**/spec/**/*"
-    - spec/factories.rb
-    - spec/factories/**/*.rb
-    - features/support/factories/**/*.rb
-  EnforcedStyle: create_list
-  SupportedStyles:
-    - create_list
-    - n_times
-  VersionAdded: '1.25'
-  VersionChanged: '2.0'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/CreateList
-
-RSpec/FactoryBot/FactoryClassName:
-  Description: Use string value when setting the class attribute explicitly.
-  Enabled: true
-  Include:
-    - spec/factories.rb
-    - spec/factories/**/*.rb
-    - features/support/factories/**/*.rb
-  VersionAdded: '1.37'
-  VersionChanged: '2.0'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/FactoryClassName
-
-RSpec/FactoryBot/SyntaxMethods:
-  Description: Use shorthands from `FactoryBot::Syntax::Methods` in your specs.
-  Enabled: pending
-  SafeAutoCorrect: false
-  VersionAdded: '2.7'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/SyntaxMethods
-
-RSpec/Rails:
-  Enabled: true
-  Include: *1
-  Language: *2
-
-RSpec/Rails/AvoidSetupHook:
-  Description: Checks that tests use RSpec `before` hook over Rails `setup` method.
-  Enabled: pending
-  VersionAdded: '2.4'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Rails/AvoidSetupHook
-
-RSpec/Rails/HaveHttpStatus:
-  Description: Checks that tests use `have_http_status` instead of equality matchers.
-  Enabled: pending
-  SafeAutoCorrect: false
-  VersionAdded: '2.12'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Rails/HaveHttpStatus
-
-RSpec/Rails/HttpStatus:
-  Description: Enforces use of symbolic or numeric value to describe HTTP status.
-  Enabled: true
-  EnforcedStyle: symbolic
-  SupportedStyles:
-    - numeric
-    - symbolic
-  VersionAdded: '1.23'
-  VersionChanged: '2.0'
-  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Rails/HttpStatus
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop-rspec.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop-rspec.rb
deleted file mode 100644
index cac7dc77d7255..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop-rspec.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'pathname'
-require 'yaml'
-
-require 'rubocop'
-
-require_relative 'rubocop/rspec/version'
-require_relative 'rubocop/rspec/inject'
-require_relative 'rubocop/rspec/node'
-require_relative 'rubocop/rspec/wording'
-require_relative 'rubocop/rspec/language/node_pattern'
-require_relative 'rubocop/rspec/language'
-
-require_relative 'rubocop/rspec/factory_bot/language'
-
-require_relative 'rubocop/cop/rspec/mixin/top_level_group'
-require_relative 'rubocop/cop/rspec/mixin/variable'
-require_relative 'rubocop/cop/rspec/mixin/final_end_location'
-require_relative 'rubocop/cop/rspec/mixin/comments_help'
-require_relative 'rubocop/cop/rspec/mixin/empty_line_separation'
-require_relative 'rubocop/cop/rspec/mixin/inside_example_group'
-
-require_relative 'rubocop/rspec/concept'
-require_relative 'rubocop/rspec/example_group'
-require_relative 'rubocop/rspec/example'
-require_relative 'rubocop/rspec/hook'
-require_relative 'rubocop/cop/rspec/base'
-require_relative 'rubocop/rspec/align_let_brace'
-require_relative 'rubocop/rspec/factory_bot'
-require_relative 'rubocop/rspec/corrector/move_node'
-
-RuboCop::RSpec::Inject.defaults!
-
-require_relative 'rubocop/cop/rspec_cops'
-
-# We have to register our autocorrect incompatibilities in RuboCop's cops
-# as well so we do not hit infinite loops
-
-RuboCop::Cop::Layout::ExtraSpacing.singleton_class.prepend(
-  Module.new do
-    def autocorrect_incompatible_with
-      super.push(RuboCop::Cop::RSpec::AlignLeftLetBrace)
-      .push(RuboCop::Cop::RSpec::AlignRightLetBrace)
-    end
-  end
-)
-
-RuboCop::Cop::Style::TrailingCommaInArguments.singleton_class.prepend(
-  Module.new do
-    def autocorrect_incompatible_with
-      super.push(RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation)
-    end
-  end
-)
-
-RuboCop::AST::Node.include(RuboCop::RSpec::Node)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_left_let_brace.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_left_let_brace.rb
deleted file mode 100644
index 1d943c23e16c2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_left_let_brace.rb
+++ /dev/null
@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that left braces for adjacent single line lets are aligned.
-      #
-      # @example
-      #
-      #     # bad
-      #     let(:foobar) { blahblah }
-      #     let(:baz) { bar }
-      #     let(:a) { b }
-      #
-      #     # good
-      #     let(:foobar) { blahblah }
-      #     let(:baz)    { bar }
-      #     let(:a)      { b }
-      #
-      class AlignLeftLetBrace < Base
-        extend AutoCorrector
-
-        MSG = 'Align left let brace'
-
-        def self.autocorrect_incompatible_with
-          [Layout::ExtraSpacing]
-        end
-
-        def on_new_investigation
-          super
-          return if processed_source.blank?
-
-          token_aligner.offending_tokens.each do |let|
-            add_offense(let.loc.begin) do |corrector|
-              corrector.insert_before(
-                let.loc.begin, token_aligner.indent_for(let)
-              )
-            end
-          end
-        end
-
-        private
-
-        def token_aligner
-          RuboCop::RSpec::AlignLetBrace.new(processed_source.ast, :begin)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_right_let_brace.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_right_let_brace.rb
deleted file mode 100644
index 93e7fc464a0cd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_right_let_brace.rb
+++ /dev/null
@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that right braces for adjacent single line lets are aligned.
-      #
-      # @example
-      #
-      #     # bad
-      #     let(:foobar) { blahblah }
-      #     let(:baz)    { bar }
-      #     let(:a)      { b }
-      #
-      #     # good
-      #     let(:foobar) { blahblah }
-      #     let(:baz)    { bar      }
-      #     let(:a)      { b        }
-      #
-      class AlignRightLetBrace < Base
-        extend AutoCorrector
-
-        MSG = 'Align right let brace'
-
-        def self.autocorrect_incompatible_with
-          [Layout::ExtraSpacing]
-        end
-
-        def on_new_investigation
-          super
-          return if processed_source.blank?
-
-          token_aligner.offending_tokens.each do |let|
-            add_offense(let.loc.end) do |corrector|
-              corrector.insert_before(
-                let.loc.end, token_aligner.indent_for(let)
-              )
-            end
-          end
-        end
-
-        private
-
-        def token_aligner
-          RuboCop::RSpec::AlignLetBrace.new(processed_source.ast, :end)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/any_instance.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/any_instance.rb
deleted file mode 100644
index 282b0b7111d8a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/any_instance.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check that instances are not being stubbed globally.
-      #
-      # Prefer instance doubles over stubbing any instance of a class
-      #
-      # @example
-      #   # bad
-      #   describe MyClass do
-      #     before { allow_any_instance_of(MyClass).to receive(:foo) }
-      #   end
-      #
-      #   # good
-      #   describe MyClass do
-      #     let(:my_instance) { instance_double(MyClass) }
-      #
-      #     before do
-      #       allow(MyClass).to receive(:new).and_return(my_instance)
-      #       allow(my_instance).to receive(:foo)
-      #     end
-      #   end
-      class AnyInstance < Base
-        MSG = 'Avoid stubbing using `%<method>s`.'
-        RESTRICT_ON_SEND = %i[
-          any_instance
-          allow_any_instance_of
-          expect_any_instance_of
-        ].freeze
-
-        def on_send(node)
-          add_offense(node, message: format(MSG, method: node.method_name))
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/around_block.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/around_block.rb
deleted file mode 100644
index f2c1e29d56f57..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/around_block.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that around blocks actually run the test.
-      #
-      # @example
-      #   # bad
-      #   around do
-      #     some_method
-      #   end
-      #
-      #   around do |test|
-      #     some_method
-      #   end
-      #
-      #   # good
-      #   around do |test|
-      #     some_method
-      #     test.call
-      #   end
-      #
-      #   around do |test|
-      #     some_method
-      #     test.run
-      #   end
-      class AroundBlock < Base
-        MSG_NO_ARG     = 'Test object should be passed to around block.'
-        MSG_UNUSED_ARG = 'You should call `%<arg>s.call` ' \
-                         'or `%<arg>s.run`.'
-
-        # @!method hook(node)
-        def_node_matcher :hook, <<-PATTERN
-          (block (send nil? :around sym ?) (args $...) ...)
-        PATTERN
-
-        # @!method find_arg_usage(node)
-        def_node_search :find_arg_usage, <<-PATTERN
-          {(send $... {:call :run}) (send _ _ $...) (yield $...) (block-pass $...)}
-        PATTERN
-
-        def on_block(node)
-          hook(node) do |(example_proxy)|
-            if example_proxy.nil?
-              add_no_arg_offense(node)
-            else
-              check_for_unused_proxy(node, example_proxy)
-            end
-          end
-        end
-
-        private
-
-        def add_no_arg_offense(node)
-          add_offense(node, message: MSG_NO_ARG)
-        end
-
-        def check_for_unused_proxy(block, proxy)
-          name, = *proxy
-
-          find_arg_usage(block) do |usage|
-            return if usage.include?(s(:lvar, name))
-          end
-
-          add_offense(
-            proxy,
-            message: format(MSG_UNUSED_ARG, arg: name)
-          )
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/base.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/base.rb
deleted file mode 100644
index 93c174a7e9d2f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/base.rb
+++ /dev/null
@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # @abstract parent class to RSpec cops
-      class Base < ::RuboCop::Cop::Base
-        include RuboCop::RSpec::Language
-        extend RuboCop::RSpec::Language::NodePattern
-
-        exclude_from_registry
-
-        # Invoke the original inherited hook so our cops are recognized
-        def self.inherited(subclass) # rubocop:disable Lint/MissingSuper
-          RuboCop::Cop::Base.inherited(subclass)
-        end
-
-        # Set the config for dynamic DSL configuration-aware helpers
-        # that have no other means of accessing the configuration.
-        def on_new_investigation
-          super
-          RuboCop::RSpec::Language.config = config['RSpec']['Language']
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be.rb
deleted file mode 100644
index 30ae14fb45ed1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check for expectations where `be` is used without argument.
-      #
-      # The `be` matcher is too generic, as it pass on everything that is not
-      # nil or false. If that is the exact intend, use `be_truthy`. In all other
-      # cases it's better to specify what exactly is the expected value.
-      #
-      # @example
-      #
-      #   # bad
-      #   expect(foo).to be
-      #
-      #   # good
-      #   expect(foo).to be_truthy
-      #   expect(foo).to be 1.0
-      #   expect(foo).to be(true)
-      #
-      class Be < Base
-        MSG = "Don't use `be` without an argument."
-
-        # @!method be_without_args(node)
-        def_node_matcher :be_without_args, <<-PATTERN
-          (send _ #Runners.all $(send nil? :be))
-        PATTERN
-
-        def on_send(node)
-          be_without_args(node) do |matcher|
-            add_offense(matcher.loc.selector)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eq.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eq.rb
deleted file mode 100644
index 04cb5e40e60b0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eq.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check for expectations where `be(...)` can replace `eq(...)`.
-      #
-      # The `be` matcher compares by identity while the `eq` matcher compares
-      # using `==`. Booleans and nil can be compared by identity and therefore
-      # the `be` matcher is preferable as it is a more strict test.
-      #
-      # @example
-      #
-      #   # bad
-      #   expect(foo).to eq(true)
-      #   expect(foo).to eq(false)
-      #   expect(foo).to eq(nil)
-      #
-      #   # good
-      #   expect(foo).to be(true)
-      #   expect(foo).to be(false)
-      #   expect(foo).to be(nil)
-      #
-      class BeEq < Base
-        extend AutoCorrector
-
-        MSG = 'Prefer `be` over `eq`.'
-        RESTRICT_ON_SEND = %i[eq].freeze
-
-        # @!method eq_type_with_identity?(node)
-        def_node_matcher :eq_type_with_identity?, <<-PATTERN
-          (send nil? :eq {true false nil})
-        PATTERN
-
-        def on_send(node)
-          return unless eq_type_with_identity?(node)
-
-          add_offense(node.loc.selector) do |corrector|
-            corrector.replace(node.loc.selector, 'be')
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eql.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eql.rb
deleted file mode 100644
index fdf7cc04013dd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eql.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check for expectations where `be(...)` can replace `eql(...)`.
-      #
-      # The `be` matcher compares by identity while the `eql` matcher
-      # compares using `eql?`. Integers, floats, booleans, symbols, and nil
-      # can be compared by identity and therefore the `be` matcher is
-      # preferable as it is a more strict test.
-      #
-      # @example
-      #
-      #   # bad
-      #   expect(foo).to eql(1)
-      #   expect(foo).to eql(1.0)
-      #   expect(foo).to eql(true)
-      #   expect(foo).to eql(false)
-      #   expect(foo).to eql(:bar)
-      #   expect(foo).to eql(nil)
-      #
-      #   # good
-      #   expect(foo).to be(1)
-      #   expect(foo).to be(1.0)
-      #   expect(foo).to be(true)
-      #   expect(foo).to be(false)
-      #   expect(foo).to be(:bar)
-      #   expect(foo).to be(nil)
-      #
-      # This cop only looks for instances of `expect(...).to eql(...)`. We
-      # do not check `to_not` or `not_to` since `!eql?` is more strict
-      # than `!equal?`. We also do not try to flag `eq` because if
-      # `a == b`, and `b` is comparable by identity, `a` is still not
-      # necessarily the same type as `b` since the `#==` operator can
-      # coerce objects for comparison.
-      #
-      class BeEql < Base
-        extend AutoCorrector
-
-        MSG = 'Prefer `be` over `eql`.'
-        RESTRICT_ON_SEND = %i[to].freeze
-
-        # @!method eql_type_with_identity(node)
-        def_node_matcher :eql_type_with_identity, <<-PATTERN
-          (send _ :to $(send nil? :eql {true false int float sym nil}))
-        PATTERN
-
-        def on_send(node)
-          eql_type_with_identity(node) do |eql|
-            add_offense(eql.loc.selector) do |corrector|
-              corrector.replace(eql.loc.selector, 'be')
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_nil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_nil.rb
deleted file mode 100644
index a969ff8edc475..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_nil.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Ensures a consistent style is used when matching `nil`.
-      #
-      # You can either use the more specific `be_nil` matcher, or the more
-      # generic `be` matcher with a `nil` argument.
-      #
-      # This cop can be configured using the `EnforcedStyle` option
-      #
-      # @example `EnforcedStyle: be_nil` (default)
-      #   # bad
-      #   expect(foo).to be(nil)
-      #
-      #   # good
-      #   expect(foo).to be_nil
-      #
-      # @example `EnforcedStyle: be`
-      #   # bad
-      #   expect(foo).to be_nil
-      #
-      #   # good
-      #   expect(foo).to be(nil)
-      #
-      class BeNil < Base
-        extend AutoCorrector
-        include ConfigurableEnforcedStyle
-
-        BE_MSG = 'Prefer `be(nil)` over `be_nil`.'
-        BE_NIL_MSG = 'Prefer `be_nil` over `be(nil)`.'
-        RESTRICT_ON_SEND = %i[be be_nil].freeze
-
-        # @!method be_nil_matcher?(node)
-        def_node_matcher :be_nil_matcher?, <<-PATTERN
-          (send nil? :be_nil)
-        PATTERN
-
-        # @!method nil_value_expectation?(node)
-        def_node_matcher :nil_value_expectation?, <<-PATTERN
-          (send nil? :be nil)
-        PATTERN
-
-        def on_send(node)
-          case style
-          when :be
-            check_be_style(node)
-          when :be_nil
-            check_be_nil_style(node)
-          end
-        end
-
-        private
-
-        def check_be_style(node)
-          return unless be_nil_matcher?(node)
-
-          add_offense(node, message: BE_MSG) do |corrector|
-            corrector.replace(node.loc.expression, 'be(nil)')
-          end
-        end
-
-        def check_be_nil_style(node)
-          return unless nil_value_expectation?(node)
-
-          add_offense(node, message: BE_NIL_MSG) do |corrector|
-            corrector.replace(node.loc.expression, 'be_nil')
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/before_after_all.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/before_after_all.rb
deleted file mode 100644
index eb18e7fbb49bb..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/before_after_all.rb
+++ /dev/null
@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check that before/after(:all) isn't being used.
-      #
-      # @example
-      #   # bad
-      #   #
-      #   # Faster but risk of state leaking between examples
-      #   #
-      #   describe MyClass do
-      #     before(:all) { Widget.create }
-      #     after(:all) { Widget.delete_all }
-      #   end
-      #
-      #   # good
-      #   #
-      #   # Slower but examples are properly isolated
-      #   #
-      #   describe MyClass do
-      #     before(:each) { Widget.create }
-      #     after(:each) { Widget.delete_all }
-      #   end
-      class BeforeAfterAll < Base
-        MSG = 'Beware of using `%<hook>s` as it may cause state to leak ' \
-              'between tests. If you are using `rspec-rails`, and ' \
-              '`use_transactional_fixtures` is enabled, then records created ' \
-              'in `%<hook>s` are not automatically rolled back.'
-
-        RESTRICT_ON_SEND = %i[before after].freeze
-
-        # @!method before_or_after_all(node)
-        def_node_matcher :before_or_after_all, <<-PATTERN
-          $(send _ {:before :after} (sym {:all :context}))
-        PATTERN
-
-        def on_send(node)
-          before_or_after_all(node) do |hook|
-            add_offense(
-              node,
-              message: format(MSG, hook: hook.source)
-            )
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb
deleted file mode 100644
index 0606570ed5698..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb
+++ /dev/null
@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module Capybara
-        # Checks that no expectations are set on Capybara's `current_path`.
-        #
-        # The
-        # https://www.rubydoc.info/github/teamcapybara/capybara/master/Capybara/RSpecMatchers#have_current_path-instance_method[`have_current_path` matcher]
-        # should be used on `page` to set expectations on Capybara's
-        # current path, since it uses
-        # https://github.com/teamcapybara/capybara/blob/master/README.md#asynchronous-javascript-ajax-and-friends[Capybara's waiting functionality]
-        # which ensures that preceding actions (like `click_link`) have
-        # completed.
-        #
-        # @example
-        #   # bad
-        #   expect(current_path).to eq('/callback')
-        #   expect(page.current_path).to match(/widgets/)
-        #
-        #   # good
-        #   expect(page).to have_current_path("/callback")
-        #   expect(page).to have_current_path(/widgets/)
-        #
-        class CurrentPathExpectation < Base
-          extend AutoCorrector
-
-          MSG = 'Do not set an RSpec expectation on `current_path` in ' \
-                'Capybara feature specs - instead, use the ' \
-                '`have_current_path` matcher on `page`'
-
-          RESTRICT_ON_SEND = %i[expect].freeze
-
-          # @!method expectation_set_on_current_path(node)
-          def_node_matcher :expectation_set_on_current_path, <<-PATTERN
-            (send nil? :expect (send {(send nil? :page) nil?} :current_path))
-          PATTERN
-
-          # Supported matchers: eq(...) / match(/regexp/) / match('regexp')
-          # @!method as_is_matcher(node)
-          def_node_matcher :as_is_matcher, <<-PATTERN
-            (send
-              #expectation_set_on_current_path $#Runners.all
-              ${(send nil? :eq ...) (send nil? :match (regexp ...))})
-          PATTERN
-
-          # @!method regexp_str_matcher(node)
-          def_node_matcher :regexp_str_matcher, <<-PATTERN
-            (send
-              #expectation_set_on_current_path $#Runners.all
-              $(send nil? :match (str $_)))
-          PATTERN
-
-          def self.autocorrect_incompatible_with
-            [Style::TrailingCommaInArguments]
-          end
-
-          def on_send(node)
-            expectation_set_on_current_path(node) do
-              add_offense(node.loc.selector) do |corrector|
-                next unless node.chained?
-
-                autocorrect(corrector, node)
-              end
-            end
-          end
-
-          private
-
-          def autocorrect(corrector, node)
-            as_is_matcher(node.parent) do |to_sym, matcher_node|
-              rewrite_expectation(corrector, node, to_sym, matcher_node)
-            end
-
-            regexp_str_matcher(node.parent) do |to_sym, matcher_node, regexp|
-              rewrite_expectation(corrector, node, to_sym, matcher_node)
-              convert_regexp_str_to_literal(corrector, matcher_node, regexp)
-            end
-          end
-
-          def rewrite_expectation(corrector, node, to_symbol, matcher_node)
-            current_path_node = node.first_argument
-            corrector.replace(current_path_node, 'page')
-            corrector.replace(node.parent.loc.selector, 'to')
-            matcher_method = if to_symbol == :to
-                               'have_current_path'
-                             else
-                               'have_no_current_path'
-                             end
-            corrector.replace(matcher_node.loc.selector, matcher_method)
-            add_ignore_query_options(corrector, node)
-          end
-
-          def convert_regexp_str_to_literal(corrector, matcher_node, regexp_str)
-            str_node = matcher_node.first_argument
-            regexp_expr = Regexp.new(regexp_str).inspect
-            corrector.replace(str_node, regexp_expr)
-          end
-
-          # `have_current_path` with no options will include the querystring
-          # while `page.current_path` does not.
-          # This ensures the option `ignore_query: true` is added
-          # except when the expectation is a regexp or string
-          def add_ignore_query_options(corrector, node)
-            expectation_node = node.parent.last_argument
-            expectation_last_child = expectation_node.children.last
-            return if %i[regexp str].include?(expectation_last_child.type)
-
-            corrector.insert_after(
-              expectation_last_child,
-              ', ignore_query: true'
-            )
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/feature_methods.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/feature_methods.rb
deleted file mode 100644
index 413b5068b6746..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/feature_methods.rb
+++ /dev/null
@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module Capybara
-        # Checks for consistent method usage in feature specs.
-        #
-        # By default, the cop disables all Capybara-specific methods that have
-        # the same native RSpec method (e.g. are just aliases). Some teams
-        # however may prefer using some of the Capybara methods (like `feature`)
-        # to make it obvious that the test uses Capybara, while still disable
-        # the rest of the methods, like `given` (alias for `let`), `background`
-        # (alias for `before`), etc. You can configure which of the methods to
-        # be enabled by using the EnabledMethods configuration option.
-        #
-        # @example
-        #   # bad
-        #   feature 'User logs in' do
-        #     given(:user) { User.new }
-        #
-        #     background do
-        #       visit new_session_path
-        #     end
-        #
-        #     scenario 'with OAuth' do
-        #       # ...
-        #     end
-        #   end
-        #
-        #   # good
-        #   describe 'User logs in' do
-        #     let(:user) { User.new }
-        #
-        #     before do
-        #       visit new_session_path
-        #     end
-        #
-        #     it 'with OAuth' do
-        #       # ...
-        #     end
-        #   end
-        class FeatureMethods < Base
-          extend AutoCorrector
-          include InsideExampleGroup
-
-          MSG = 'Use `%<replacement>s` instead of `%<method>s`.'
-
-          # https://github.com/teamcapybara/capybara/blob/e283c1aeaa72441f5403963577e16333bf111a81/lib/capybara/rspec/features.rb#L31-L36
-          MAP = {
-            background: :before,
-            scenario:   :it,
-            xscenario:  :xit,
-            given:      :let,
-            given!:     :let!,
-            feature:    :describe
-          }.freeze
-
-          # @!method capybara_speak(node)
-          def_node_matcher :capybara_speak, <<-PATTERN
-            {#{MAP.keys.map(&:inspect).join(' ')}}
-          PATTERN
-
-          # @!method feature_method(node)
-          def_node_matcher :feature_method, <<-PATTERN
-            (block
-              $(send #rspec? $#capybara_speak ...)
-            ...)
-          PATTERN
-
-          def on_block(node)
-            return unless inside_example_group?(node)
-
-            feature_method(node) do |send_node, match|
-              next if enabled?(match)
-
-              add_offense(send_node.loc.selector) do |corrector|
-                corrector.replace(send_node.loc.selector, MAP[match].to_s)
-              end
-            end
-          end
-
-          def message(range)
-            name = range.source.to_sym
-            format(MSG, method: name, replacement: MAP[name])
-          end
-
-          private
-
-          def enabled?(method_name)
-            enabled_methods.include?(method_name)
-          end
-
-          def enabled_methods
-            cop_config
-              .fetch('EnabledMethods', [])
-              .map(&:to_sym)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/specific_matcher.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/specific_matcher.rb
deleted file mode 100644
index 2df783c9054f7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/specific_matcher.rb
+++ /dev/null
@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module Capybara
-        # Checks for there is a more specific matcher offered by Capybara.
-        #
-        # @example
-        #
-        #   # bad
-        #   expect(page).to have_selector('button')
-        #   expect(page).to have_no_selector('button.cls')
-        #   expect(page).to have_css('button')
-        #   expect(page).to have_no_css('a.cls', exact_text: 'foo')
-        #   expect(page).to have_css('table.cls')
-        #   expect(page).to have_css('select')
-        #
-        #   # good
-        #   expect(page).to have_button
-        #   expect(page).to have_no_button(class: 'cls')
-        #   expect(page).to have_button
-        #   expect(page).to have_no_link('foo', class: 'cls')
-        #   expect(page).to have_table(class: 'cls')
-        #   expect(page).to have_select
-        #
-        class SpecificMatcher < Base
-          MSG = 'Prefer `%<good_matcher>s` over `%<bad_matcher>s`.'
-          RESTRICT_ON_SEND = %i[have_selector have_no_selector have_css
-                                have_no_css].freeze
-          SPECIFIC_MATCHER = {
-            'button' => 'button',
-            'a' => 'link',
-            'table' => 'table',
-            'select' => 'select'
-          }.freeze
-
-          # @!method first_argument(node)
-          def_node_matcher :first_argument, <<-PATTERN
-            (send nil? _ (str $_) ... )
-          PATTERN
-
-          def on_send(node)
-            return unless (arg = first_argument(node))
-            return unless (matcher = specific_matcher(arg))
-            return if acceptable_pattern?(arg)
-
-            add_offense(node, message: message(node, matcher))
-          end
-
-          private
-
-          def specific_matcher(arg)
-            splitted_arg = arg[/^\w+/, 0]
-            SPECIFIC_MATCHER[splitted_arg]
-          end
-
-          def acceptable_pattern?(arg)
-            arg.match?(/\[.+=\w+\]/) || arg.match?(/[ >,+]/)
-          end
-
-          def message(node, matcher)
-            format(MSG,
-                   good_matcher: good_matcher(node, matcher),
-                   bad_matcher: node.method_name)
-          end
-
-          def good_matcher(node, matcher)
-            node.method_name
-              .to_s
-              .gsub(/selector|css/, matcher.to_s)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/visibility_matcher.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/visibility_matcher.rb
deleted file mode 100644
index 163066e89080d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/visibility_matcher.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module Capybara
-        # Checks for boolean visibility in Capybara finders.
-        #
-        # Capybara lets you find elements that match a certain visibility using
-        # the `:visible` option. `:visible` accepts both boolean and symbols as
-        # values, however using booleans can have unwanted effects. `visible:
-        # false` does not find just invisible elements, but both visible and
-        # invisible elements. For expressiveness and clarity, use one of the
-        # symbol values, `:all`, `:hidden` or `:visible`.
-        # Read more in
-        # https://www.rubydoc.info/gems/capybara/Capybara%2FNode%2FFinders:all[the documentation].
-        #
-        # @example
-        #
-        #   # bad
-        #   expect(page).to have_selector('.foo', visible: false)
-        #   expect(page).to have_css('.foo', visible: true)
-        #   expect(page).to have_link('my link', visible: false)
-        #
-        #   # good
-        #   expect(page).to have_selector('.foo', visible: :visible)
-        #   expect(page).to have_css('.foo', visible: :all)
-        #   expect(page).to have_link('my link', visible: :hidden)
-        #
-        class VisibilityMatcher < Base
-          MSG_FALSE = 'Use `:all` or `:hidden` instead of `false`.'
-          MSG_TRUE = 'Use `:visible` instead of `true`.'
-          CAPYBARA_MATCHER_METHODS = %i[
-            have_selector
-            have_css
-            have_xpath
-            have_link
-            have_button
-            have_field
-            have_select
-            have_table
-            have_checked_field
-            have_unchecked_field
-            have_text
-            have_content
-          ].freeze
-
-          RESTRICT_ON_SEND = CAPYBARA_MATCHER_METHODS
-
-          # @!method visible_true?(node)
-          def_node_matcher :visible_true?, <<~PATTERN
-            (send nil? #capybara_matcher? ... (hash <$(pair (sym :visible) true) ...>))
-          PATTERN
-
-          # @!method visible_false?(node)
-          def_node_matcher :visible_false?, <<~PATTERN
-            (send nil? #capybara_matcher? ... (hash <$(pair (sym :visible) false) ...>))
-          PATTERN
-
-          def on_send(node)
-            visible_false?(node) { |arg| add_offense(arg, message: MSG_FALSE) }
-            visible_true?(node) { |arg| add_offense(arg, message: MSG_TRUE) }
-          end
-
-          private
-
-          def capybara_matcher?(method_name)
-            CAPYBARA_MATCHER_METHODS.include? method_name
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/change_by_zero.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/change_by_zero.rb
deleted file mode 100644
index 11741614977bd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/change_by_zero.rb
+++ /dev/null
@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Prefer negated matchers over `to change.by(0)`.
-      #
-      # @example
-      #   # bad
-      #   expect { run }.to change(Foo, :bar).by(0)
-      #   expect { run }.to change { Foo.bar }.by(0)
-      #
-      #   # bad - compound expectations
-      #   expect { run }
-      #     .to change(Foo, :bar).by(0)
-      #     .and change(Foo, :baz).by(0)
-      #   expect { run }
-      #     .to change { Foo.bar }.by(0)
-      #     .and change { Foo.baz }.by(0)
-      #
-      #   # good
-      #   expect { run }.not_to change(Foo, :bar)
-      #   expect { run }.not_to change { Foo.bar }
-      #
-      #   # good - compound expectations
-      #   define_negated_matcher :not_change, :change
-      #   expect { run }
-      #     .to not_change(Foo, :bar)
-      #     .and not_change(Foo, :baz)
-      #   expect { run }
-      #     .to not_change { Foo.bar }
-      #     .and not_change { Foo.baz }
-      #
-      class ChangeByZero < Base
-        extend AutoCorrector
-        MSG = 'Prefer `not_to change` over `to change.by(0)`.'
-        MSG_COMPOUND = 'Prefer negated matchers with compound expectations ' \
-                          'over `change.by(0)`.'
-        RESTRICT_ON_SEND = %i[change].freeze
-
-        # @!method expect_change_with_arguments(node)
-        def_node_matcher :expect_change_with_arguments, <<-PATTERN
-          (send
-            (send nil? :change ...) :by
-            (int 0))
-        PATTERN
-
-        # @!method expect_change_with_block(node)
-        def_node_matcher :expect_change_with_block, <<-PATTERN
-          (send
-            (block
-              (send nil? :change)
-              (args)
-              (send (...) $_)) :by
-            (int 0))
-        PATTERN
-
-        def on_send(node)
-          expect_change_with_arguments(node.parent) do
-            check_offense(node.parent)
-          end
-
-          expect_change_with_block(node.parent.parent) do
-            check_offense(node.parent.parent)
-          end
-        end
-
-        private
-
-        def check_offense(node)
-          expression = node.loc.expression
-          if compound_expectations?(node)
-            add_offense(expression, message: MSG_COMPOUND)
-          else
-            add_offense(expression) do |corrector|
-              autocorrect(corrector, node)
-            end
-          end
-        end
-
-        def compound_expectations?(node)
-          %i[and or].include?(node.parent.method_name)
-        end
-
-        def autocorrect(corrector, node)
-          corrector.replace(node.parent.loc.selector, 'not_to')
-          range = node.loc.dot.with(end_pos: node.loc.expression.end_pos)
-          corrector.remove(range)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_method.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_method.rb
deleted file mode 100644
index c0f52b568329f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_method.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # `context` should not be used for specifying methods.
-      #
-      # @example
-      #   # bad
-      #   context '#foo_bar' do
-      #     # ...
-      #   end
-      #
-      #   context '.foo_bar' do
-      #     # ...
-      #   end
-      #
-      #   # good
-      #   describe '#foo_bar' do
-      #     # ...
-      #   end
-      #
-      #   describe '.foo_bar' do
-      #     # ...
-      #   end
-      class ContextMethod < Base
-        extend AutoCorrector
-
-        MSG = 'Use `describe` for testing methods.'
-
-        # @!method context_method(node)
-        def_node_matcher :context_method, <<-PATTERN
-          (block (send #rspec? :context $(str #method_name?) ...) ...)
-        PATTERN
-
-        def on_block(node)
-          context_method(node) do |context|
-            add_offense(context) do |corrector|
-              corrector.replace(node.send_node.loc.selector, 'describe')
-            end
-          end
-        end
-
-        private
-
-        def method_name?(description)
-          description.start_with?('.', '#')
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_wording.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_wording.rb
deleted file mode 100644
index 623468c95f388..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_wording.rb
+++ /dev/null
@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that `context` docstring starts with an allowed prefix.
-      #
-      # The default list of prefixes is minimal. Users are encouraged to tailor
-      # the configuration to meet project needs. Other acceptable prefixes may
-      # include `if`, `unless`, `for`, `before`, `after`, or `during`.
-      # They may consist of multiple words if desired.
-      #
-      # @see https://rspec.rubystyle.guide/#context-descriptions
-      # @see http://www.betterspecs.org/#contexts
-      #
-      # @example `Prefixes` configuration
-      #
-      #   # .rubocop.yml
-      #   # RSpec/ContextWording:
-      #   #   Prefixes:
-      #   #     - when
-      #   #     - with
-      #   #     - without
-      #   #     - if
-      #   #     - unless
-      #   #     - for
-      #
-      # @example
-      #   # bad
-      #   context 'the display name not present' do
-      #     # ...
-      #   end
-      #
-      #   # good
-      #   context 'when the display name is not present' do
-      #     # ...
-      #   end
-      class ContextWording < Base
-        MSG = 'Start context description with %<prefixes>s.'
-
-        # @!method context_wording(node)
-        def_node_matcher :context_wording, <<-PATTERN
-          (block (send #rspec? { :context :shared_context } $(str #bad_prefix?) ...) ...)
-        PATTERN
-
-        def on_block(node)
-          context_wording(node) do |context|
-            add_offense(context,
-                        message: format(MSG, prefixes: joined_prefixes))
-          end
-        end
-
-        private
-
-        def bad_prefix?(description)
-          !prefix_regex.match?(description)
-        end
-
-        def joined_prefixes
-          quoted = prefixes.map { |prefix| "'#{prefix}'" }
-          return quoted.first if quoted.size == 1
-
-          quoted << "or #{quoted.pop}"
-          quoted.join(', ')
-        end
-
-        def prefixes
-          cop_config['Prefixes'] || []
-        end
-
-        def prefix_regex
-          /^#{Regexp.union(prefixes)}\b/
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_class.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_class.rb
deleted file mode 100644
index 9443220ee185b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_class.rb
+++ /dev/null
@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check that the first argument to the top-level describe is a constant.
-      #
-      # It can be configured to ignore strings when certain metadata is passed.
-      #
-      # Ignores Rails and Aruba `type` metadata by default.
-      #
-      # @example `IgnoredMetadata` configuration
-      #
-      #   # .rubocop.yml
-      #   # RSpec/DescribeClass:
-      #   #   IgnoredMetadata:
-      #   #     type:
-      #   #       - request
-      #   #       - controller
-      #
-      # @example
-      #   # bad
-      #   describe 'Do something' do
-      #   end
-      #
-      #   # good
-      #   describe TestedClass do
-      #     subject { described_class }
-      #   end
-      #
-      #   describe 'TestedClass::VERSION' do
-      #     subject { Object.const_get(self.class.description) }
-      #   end
-      #
-      #   describe "A feature example", type: :feature do
-      #   end
-      class DescribeClass < Base
-        include TopLevelGroup
-
-        MSG = 'The first argument to describe should be ' \
-              'the class or module being tested.'
-
-        # @!method example_group_with_ignored_metadata?(node)
-        def_node_matcher :example_group_with_ignored_metadata?, <<~PATTERN
-          (send #rspec? :describe ... (hash <#ignored_metadata? ...>))
-        PATTERN
-
-        # @!method not_a_const_described(node)
-        def_node_matcher :not_a_const_described, <<~PATTERN
-          (send #rspec? :describe $[!const !#string_constant?] ...)
-        PATTERN
-
-        # @!method sym_pair(node)
-        def_node_matcher :sym_pair, <<~PATTERN
-          (pair $sym $sym)
-        PATTERN
-
-        def on_top_level_group(node)
-          return if example_group_with_ignored_metadata?(node.send_node)
-
-          not_a_const_described(node.send_node) do |described|
-            add_offense(described)
-          end
-        end
-
-        private
-
-        def ignored_metadata?(node)
-          sym_pair(node) do |key, value|
-            ignored_metadata[key.value.to_s].to_a.include?(value.value.to_s)
-          end
-        end
-
-        def string_constant?(described)
-          described.str_type? &&
-            described.value.match?(/^(?:(?:::)?[A-Z]\w*)+$/)
-        end
-
-        def ignored_metadata
-          cop_config['IgnoredMetadata'] || {}
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_method.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_method.rb
deleted file mode 100644
index 8a8c114133053..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_method.rb
+++ /dev/null
@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that the second argument to `describe` specifies a method.
-      #
-      # @example
-      #   # bad
-      #   describe MyClass, 'do something' do
-      #   end
-      #
-      #   # good
-      #   describe MyClass, '#my_instance_method' do
-      #   end
-      #
-      #   describe MyClass, '.my_class_method' do
-      #   end
-      class DescribeMethod < Base
-        include TopLevelGroup
-
-        MSG = 'The second argument to describe should be the method ' \
-              "being tested. '#instance' or '.class'."
-
-        # @!method second_argument(node)
-        def_node_matcher :second_argument, <<~PATTERN
-          (block
-            (send #rspec? :describe _first_argument $(str _) ...) ...
-          )
-        PATTERN
-
-        def on_top_level_group(node)
-          second_argument = second_argument(node)
-
-          return unless second_argument
-          return if second_argument.str_content.start_with?('#', '.')
-
-          add_offense(second_argument)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_symbol.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_symbol.rb
deleted file mode 100644
index 09c8220ac549c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_symbol.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Avoid describing symbols.
-      #
-      # @example
-      #   # bad
-      #   describe :my_method do
-      #     # ...
-      #   end
-      #
-      #   # good
-      #   describe '#my_method' do
-      #     # ...
-      #   end
-      #
-      # @see https://github.com/rspec/rspec-core/issues/1610
-      class DescribeSymbol < Base
-        MSG = 'Avoid describing symbols.'
-        RESTRICT_ON_SEND = %i[describe].freeze
-
-        # @!method describe_symbol?(node)
-        def_node_matcher :describe_symbol?, <<-PATTERN
-          (send #rspec? :describe $sym ...)
-        PATTERN
-
-        def on_send(node)
-          describe_symbol?(node) do |match|
-            add_offense(match)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb
deleted file mode 100644
index f1b4ed73002e9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb
+++ /dev/null
@@ -1,218 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that tests use `described_class`.
-      #
-      # If the first argument of describe is a class, the class is exposed to
-      # each example via described_class.
-      #
-      # This cop can be configured using the `EnforcedStyle` and `SkipBlocks`
-      # options.
-      #
-      # @example `EnforcedStyle: described_class` (default)
-      #   # bad
-      #   describe MyClass do
-      #     subject { MyClass.do_something }
-      #   end
-      #
-      #   # good
-      #   describe MyClass do
-      #     subject { described_class.do_something }
-      #   end
-      #
-      # @example `EnforcedStyle: explicit`
-      #   # bad
-      #   describe MyClass do
-      #     subject { described_class.do_something }
-      #   end
-      #
-      #   # good
-      #   describe MyClass do
-      #     subject { MyClass.do_something }
-      #   end
-      #
-      # There's a known caveat with rspec-rails's `controller` helper that
-      # runs its block in a different context, and `described_class` is not
-      # available to it. `SkipBlocks` option excludes detection in all
-      # non-RSpec related blocks.
-      #
-      # To narrow down this setting to only a specific directory, it is
-      # possible to use an overriding configuration file local to that
-      # directory.
-      #
-      # @example `SkipBlocks: true`
-      #   # spec/controllers/.rubocop.yml
-      #   # RSpec/DescribedClass:
-      #   #   SkipBlocks: true
-      #
-      #   # acceptable
-      #   describe MyConcern do
-      #     controller(ApplicationController) do
-      #       include MyConcern
-      #     end
-      #   end
-      #
-      class DescribedClass < Base
-        extend AutoCorrector
-        include ConfigurableEnforcedStyle
-
-        DESCRIBED_CLASS = 'described_class'
-        MSG             = 'Use `%<replacement>s` instead of `%<src>s`.'
-
-        # @!method common_instance_exec_closure?(node)
-        def_node_matcher :common_instance_exec_closure?, <<-PATTERN
-          (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
-        PATTERN
-
-        # @!method rspec_block?(node)
-        def_node_matcher :rspec_block?, block_pattern('#ALL.all')
-
-        # @!method scope_changing_syntax?(node)
-        def_node_matcher :scope_changing_syntax?, '{def class module}'
-
-        # @!method described_constant(node)
-        def_node_matcher :described_constant, <<-PATTERN
-          (block (send _ :describe $(const ...) ...) (args) $_)
-        PATTERN
-
-        # @!method contains_described_class?(node)
-        def_node_search :contains_described_class?,
-                        '(send nil? :described_class)'
-
-        def on_block(node)
-          # In case the explicit style is used, we need to remember what's
-          # being described.
-          @described_class, body = described_constant(node)
-
-          return unless body
-
-          find_usage(body) do |match|
-            msg = message(match.const_name)
-            add_offense(match, message: msg) do |corrector|
-              autocorrect(corrector, match)
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, match)
-          replacement = if style == :described_class
-                          DESCRIBED_CLASS
-                        else
-                          @described_class.const_name
-                        end
-
-          corrector.replace(match, replacement)
-        end
-
-        def find_usage(node, &block)
-          yield(node) if offensive?(node)
-
-          return if scope_change?(node) || node.const_type?
-
-          node.each_child_node do |child|
-            find_usage(child, &block)
-          end
-        end
-
-        def message(offense)
-          if style == :described_class
-            format(MSG, replacement: DESCRIBED_CLASS, src: offense)
-          else
-            format(MSG, replacement: @described_class.const_name,
-                        src: DESCRIBED_CLASS)
-          end
-        end
-
-        def scope_change?(node)
-          scope_changing_syntax?(node) ||
-            common_instance_exec_closure?(node) ||
-            skippable_block?(node)
-        end
-
-        def skippable_block?(node)
-          node.block_type? && !rspec_block?(node) && cop_config['SkipBlocks']
-        end
-
-        def offensive?(node)
-          if style == :described_class
-            offensive_described_class?(node)
-          else
-            node.send_type? && node.method?(:described_class)
-          end
-        end
-
-        def offensive_described_class?(node)
-          return unless node.const_type?
-
-          # E.g. `described_class::CONSTANT`
-          return if contains_described_class?(node)
-
-          nearest_described_class, = node.each_ancestor(:block)
-            .map { |ancestor| described_constant(ancestor) }.find(&:itself)
-
-          return if nearest_described_class.equal?(node)
-
-          full_const_name(nearest_described_class) == full_const_name(node)
-        end
-
-        def full_const_name(node)
-          collapse_namespace(namespace(node), const_name(node))
-        end
-
-        # @param namespace [Array<Symbol>]
-        # @param const [Array<Symbol>]
-        # @return [Array<Symbol>]
-        # @example
-        #   # nil represents base constant
-        #   collapse_namespace([], [:C])                # => [:C]
-        #   collapse_namespace([:A, :B], [:C])          # => [:A, :B, :C]
-        #   collapse_namespace([:A, :B], [:B, :C])      # => [:A, :B, :C]
-        #   collapse_namespace([:A, :B], [nil, :C])     # => [nil, :C]
-        #   collapse_namespace([:A, :B], [nil, :B, :C]) # => [nil, :B, :C]
-        def collapse_namespace(namespace, const)
-          return const if namespace.empty? || const.first.nil?
-
-          start = [0, (namespace.length - const.length)].max
-          max = namespace.length
-          intersection = (start..max).find do |shift|
-            namespace[shift, max - shift] == const[0, max - shift]
-          end
-          [*namespace[0, intersection], *const]
-        end
-
-        # @param node [RuboCop::AST::Node]
-        # @return [Array<Symbol>]
-        # @example
-        #   const_name(s(:const, nil, :C))                # => [:C]
-        #   const_name(s(:const, s(:const, nil, :M), :C)) # => [:M, :C]
-        #   const_name(s(:const, s(:cbase), :C))          # => [nil, :C]
-        def const_name(node)
-          namespace, name = *node # rubocop:disable InternalAffairs/NodeDestructuring
-          if !namespace
-            [name]
-          elsif namespace.const_type?
-            [*const_name(namespace), name]
-          elsif %i[lvar cbase send].include?(namespace.type)
-            [nil, name]
-          end
-        end
-
-        # @param node [RuboCop::AST::Node]
-        # @return [Array<Symbol>]
-        # @example
-        #   namespace(node) # => [:A, :B, :C]
-        def namespace(node)
-          node
-            .each_ancestor(:class, :module)
-            .reverse_each
-            .flat_map { |ancestor| ancestor.defined_module_name.split('::') }
-            .map(&:to_sym)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class_module_wrapping.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class_module_wrapping.rb
deleted file mode 100644
index cbfdca539d50f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class_module_wrapping.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Avoid opening modules and defining specs within them.
-      #
-      # @example
-      #   # bad
-      #   module MyModule
-      #     RSpec.describe MyClass do
-      #       # ...
-      #     end
-      #   end
-      #
-      #   # good
-      #   RSpec.describe MyModule::MyClass do
-      #     # ...
-      #   end
-      #
-      # @see https://github.com/rubocop/rubocop-rspec/issues/735
-      class DescribedClassModuleWrapping < Base
-        MSG = 'Avoid opening modules and defining specs within them.'
-
-        # @!method find_rspec_blocks(node)
-        def_node_search :find_rspec_blocks, block_pattern('#ExampleGroups.all')
-
-        def on_module(node)
-          find_rspec_blocks(node) do
-            add_offense(node)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/dialect.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/dialect.rb
deleted file mode 100644
index 1fca3d0fdcb48..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/dialect.rb
+++ /dev/null
@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Enforces custom RSpec dialects.
-      #
-      # A dialect can be based on the following RSpec methods:
-      #
-      # - describe, context, feature, example_group
-      # - xdescribe, xcontext, xfeature
-      # - fdescribe, fcontext, ffeature
-      # - shared_examples, shared_examples_for, shared_context
-      # - it, specify, example, scenario, its
-      # - fit, fspecify, fexample, fscenario, focus
-      # - xit, xspecify, xexample, xscenario, skip
-      # - pending
-      # - prepend_before, before, append_before,
-      # - around
-      # - prepend_after, after, append_after
-      # - let, let!
-      # - subject, subject!
-      # - expect, is_expected, expect_any_instance_of
-      #
-      # By default all of the RSpec methods and aliases are allowed. By setting
-      # a config like:
-      #
-      #   RSpec/Dialect:
-      #     PreferredMethods:
-      #       context: describe
-      #
-      # You can expect the following behavior:
-      #
-      # @example
-      #   # bad
-      #   context 'display name presence' do
-      #     # ...
-      #   end
-      #
-      #   # good
-      #   describe 'display name presence' do
-      #     # ...
-      #   end
-      class Dialect < Base
-        extend AutoCorrector
-        include MethodPreference
-
-        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
-
-        # @!method rspec_method?(node)
-        def_node_matcher :rspec_method?, send_pattern('#ALL.all')
-
-        def on_send(node)
-          return unless rspec_method?(node)
-          return unless preferred_methods[node.method_name]
-
-          msg = format(MSG, prefer: preferred_method(node.method_name),
-                            current: node.method_name)
-
-          add_offense(node, message: msg) do |corrector|
-            current = node.loc.selector
-            preferred = preferred_method(current.source)
-
-            corrector.replace(current, preferred)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_example_group.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_example_group.rb
deleted file mode 100644
index e0162627c5cd8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_example_group.rb
+++ /dev/null
@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks if an example group does not include any tests.
-      #
-      # @example usage
-      #
-      #   # bad
-      #   describe Bacon do
-      #     let(:bacon)      { Bacon.new(chunkiness) }
-      #     let(:chunkiness) { false                 }
-      #
-      #     context 'extra chunky' do   # flagged by rubocop
-      #       let(:chunkiness) { true }
-      #     end
-      #
-      #     it 'is chunky' do
-      #       expect(bacon.chunky?).to be_truthy
-      #     end
-      #   end
-      #
-      #   # good
-      #   describe Bacon do
-      #     let(:bacon)      { Bacon.new(chunkiness) }
-      #     let(:chunkiness) { false                 }
-      #
-      #     it 'is chunky' do
-      #       expect(bacon.chunky?).to be_truthy
-      #     end
-      #   end
-      #
-      #   # good
-      #   describe Bacon do
-      #     pending 'will add tests later'
-      #   end
-      class EmptyExampleGroup < Base
-        MSG = 'Empty example group detected.'
-
-        # @!method example_group_body(node)
-        #   Match example group blocks and yield their body
-        #
-        #   @example source that matches
-        #     describe 'example group' do
-        #       it { is_expected.to be }
-        #     end
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @yield [RuboCop::AST::Node] example group body
-        def_node_matcher :example_group_body, <<~PATTERN
-          (block #{send_pattern('#ExampleGroups.all')} args $_)
-        PATTERN
-
-        # @!method example_or_group_or_include?(node)
-        #   Match examples, example groups and includes
-        #
-        #   @example source that matches
-        #     it { is_expected.to fly }
-        #     describe('non-empty example groups too') { }
-        #     it_behaves_like 'an animal'
-        #     it_behaves_like('a cat') { let(:food) { 'milk' } }
-        #     it_has_root_access
-        #     skip
-        #     it 'will be implemented later'
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @return [Array<RuboCop::AST::Node>] matching nodes
-        def_node_matcher :example_or_group_or_include?, <<~PATTERN
-          {
-            #{block_pattern(
-              '{#Examples.all #ExampleGroups.all #Includes.all}'
-            )}
-            #{send_pattern('{#Examples.all #Includes.all}')}
-          }
-        PATTERN
-
-        # @!method examples_inside_block?(node)
-        #   Match examples defined inside a block which is not a hook
-        #
-        #   @example source that matches
-        #     %w(r g b).each do |color|
-        #       it { is_expected.to have_color(color) }
-        #     end
-        #
-        #   @example source that does not match
-        #     before do
-        #       it { is_expected.to fall_into_oblivion }
-        #     end
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @return [Array<RuboCop::AST::Node>] matching nodes
-        def_node_matcher :examples_inside_block?, <<~PATTERN
-          (block !#{send_pattern('#Hooks.all')} _ #examples?)
-        PATTERN
-
-        # @!method examples_directly_or_in_block?(node)
-        #   Match examples or examples inside blocks
-        #
-        #   @example source that matches
-        #     it { expect(drink).to be_cold }
-        #     context('when winter') { it { expect(drink).to be_hot } }
-        #     (1..5).each { |divisor| it { is_expected.to divide_by(divisor) } }
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @return [Array<RuboCop::AST::Node>] matching nodes
-        def_node_matcher :examples_directly_or_in_block?, <<~PATTERN
-          {
-            #example_or_group_or_include?
-            #examples_inside_block?
-          }
-        PATTERN
-
-        # @!method examples?(node)
-        #   Matches examples defined in scopes where they could run
-        #
-        #   @example source that matches
-        #     it { expect(myself).to be_run }
-        #     describe { it { i_run_as_well } }
-        #
-        #   @example source that does not match
-        #     before { it { whatever here wont run anyway } }
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @return [Array<RuboCop::AST::Node>] matching nodes
-        def_node_matcher :examples?, <<~PATTERN
-          {
-            #examples_directly_or_in_block?
-            (begin <#examples_directly_or_in_block? ...>)
-          }
-        PATTERN
-
-        def on_block(node)
-          return if node.each_ancestor(:def, :defs).any?
-          return if node.each_ancestor(:block).any? { |block| example?(block) }
-
-          example_group_body(node) do |body|
-            add_offense(node.send_node) if offensive?(body)
-          end
-        end
-
-        private
-
-        def offensive?(body)
-          return true unless body
-          return false if conditionals_with_examples?(body)
-
-          if body.if_type? || body.case_type?
-            !examples_in_branches?(body)
-          else
-            !examples?(body)
-          end
-        end
-
-        def conditionals_with_examples?(body)
-          return unless body.begin_type? || body.case_type?
-
-          body.each_descendant(:if, :case).any? do |condition_node|
-            examples_in_branches?(condition_node)
-          end
-        end
-
-        def examples_in_branches?(condition_node)
-          condition_node.branches.any? { |branch| examples?(branch) }
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_hook.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_hook.rb
deleted file mode 100644
index 820c1c53287f3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_hook.rb
+++ /dev/null
@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      #  Checks for empty before and after hooks.
-      #
-      # @example
-      #   # bad
-      #   before {}
-      #   after do; end
-      #   before(:all) do
-      #   end
-      #   after(:all) { }
-      #
-      #   # good
-      #   before { create_users }
-      #   after do
-      #     cleanup_users
-      #   end
-      #   before(:all) do
-      #     create_feed
-      #   end
-      #   after(:all) { cleanup_feed }
-      class EmptyHook < Base
-        extend AutoCorrector
-        include RuboCop::Cop::RangeHelp
-
-        MSG = 'Empty hook detected.'
-
-        # @!method empty_hook?(node)
-        def_node_matcher :empty_hook?, <<~PATTERN
-          (block $#{send_pattern('#Hooks.all')} _ nil?)
-        PATTERN
-
-        def on_block(node)
-          empty_hook?(node) do |hook|
-            add_offense(hook) do |corrector|
-              corrector.remove(
-                range_with_surrounding_space(node.loc.expression, side: :left)
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example.rb
deleted file mode 100644
index 912225188397b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example.rb
+++ /dev/null
@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks if there is an empty line after example blocks.
-      #
-      # @example
-      #   # bad
-      #   RSpec.describe Foo do
-      #     it 'does this' do
-      #     end
-      #     it 'does that' do
-      #     end
-      #   end
-      #
-      #   # good
-      #   RSpec.describe Foo do
-      #     it 'does this' do
-      #     end
-      #
-      #     it 'does that' do
-      #     end
-      #   end
-      #
-      #   # fair - it's ok to have non-separated one-liners
-      #   RSpec.describe Foo do
-      #     it { one }
-      #     it { two }
-      #   end
-      #
-      # @example with AllowConsecutiveOneLiners configuration
-      #
-      #   # rubocop.yml
-      #   # RSpec/EmptyLineAfterExample:
-      #   #   AllowConsecutiveOneLiners: false
-      #
-      #   # bad
-      #   RSpec.describe Foo do
-      #     it { one }
-      #     it { two }
-      #   end
-      #
-      class EmptyLineAfterExample < Base
-        extend AutoCorrector
-        include EmptyLineSeparation
-
-        MSG = 'Add an empty line after `%<example>s`.'
-
-        def on_block(node)
-          return unless example?(node)
-          return if allowed_one_liner?(node)
-
-          missing_separating_line_offense(node) do |method|
-            format(MSG, example: method)
-          end
-        end
-
-        def allowed_one_liner?(node)
-          consecutive_one_liner?(node) && allow_consecutive_one_liners?
-        end
-
-        def allow_consecutive_one_liners?
-          cop_config['AllowConsecutiveOneLiners']
-        end
-
-        def consecutive_one_liner?(node)
-          node.line_count == 1 && next_one_line_example?(node)
-        end
-
-        def next_one_line_example?(node)
-          next_sibling = next_sibling(node)
-          return unless next_sibling
-          return unless example?(next_sibling)
-
-          next_sibling.line_count == 1
-        end
-
-        def next_sibling(node)
-          node.parent.children[node.sibling_index + 1]
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example_group.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example_group.rb
deleted file mode 100644
index e0f89f8854b16..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example_group.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks if there is an empty line after example group blocks.
-      #
-      # @example
-      #   # bad
-      #   RSpec.describe Foo do
-      #     describe '#bar' do
-      #     end
-      #     describe '#baz' do
-      #     end
-      #   end
-      #
-      #   # good
-      #   RSpec.describe Foo do
-      #     describe '#bar' do
-      #     end
-      #
-      #     describe '#baz' do
-      #     end
-      #   end
-      #
-      class EmptyLineAfterExampleGroup < Base
-        extend AutoCorrector
-        include EmptyLineSeparation
-
-        MSG = 'Add an empty line after `%<example_group>s`.'
-
-        def on_block(node)
-          return unless example_group?(node)
-
-          missing_separating_line_offense(node) do |method|
-            format(MSG, example_group: method)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_final_let.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_final_let.rb
deleted file mode 100644
index 1f91190edfe35..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_final_let.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks if there is an empty line after the last let block.
-      #
-      # @example
-      #   # bad
-      #   let(:foo) { bar }
-      #   let(:something) { other }
-      #   it { does_something }
-      #
-      #   # good
-      #   let(:foo) { bar }
-      #   let(:something) { other }
-      #
-      #   it { does_something }
-      class EmptyLineAfterFinalLet < Base
-        extend AutoCorrector
-        include EmptyLineSeparation
-
-        MSG = 'Add an empty line after the last `%<let>s`.'
-
-        def on_block(node)
-          return unless example_group_with_body?(node)
-
-          final_let = node.body.child_nodes.reverse.find { |child| let?(child) }
-
-          return if final_let.nil?
-
-          missing_separating_line_offense(final_let) do |method|
-            format(MSG, let: method)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_hook.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_hook.rb
deleted file mode 100644
index bf2ae16f68438..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_hook.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks if there is an empty line after hook blocks.
-      #
-      # @example
-      #   # bad
-      #   before { do_something }
-      #   it { does_something }
-      #
-      #   # bad
-      #   after { do_something }
-      #   it { does_something }
-      #
-      #   # bad
-      #   around { |test| test.run }
-      #   it { does_something }
-      #
-      #   # good
-      #   before { do_something }
-      #
-      #   it { does_something }
-      #
-      #   # good
-      #   after { do_something }
-      #
-      #   it { does_something }
-      #
-      #   # good
-      #   around { |test| test.run }
-      #
-      #   it { does_something }
-      #
-      class EmptyLineAfterHook < Base
-        extend AutoCorrector
-        include EmptyLineSeparation
-
-        MSG = 'Add an empty line after `%<hook>s`.'
-
-        def on_block(node)
-          return unless hook?(node)
-
-          missing_separating_line_offense(node) do |method|
-            format(MSG, hook: method)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_subject.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_subject.rb
deleted file mode 100644
index 47d515d8429b9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_subject.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks if there is an empty line after subject block.
-      #
-      # @example
-      #   # bad
-      #   subject(:obj) { described_class }
-      #   let(:foo) { bar }
-      #
-      #   # good
-      #   subject(:obj) { described_class }
-      #
-      #   let(:foo) { bar }
-      class EmptyLineAfterSubject < Base
-        extend AutoCorrector
-        include EmptyLineSeparation
-        include InsideExampleGroup
-
-        MSG = 'Add an empty line after `%<subject>s`.'
-
-        def on_block(node)
-          return unless subject?(node)
-          return unless inside_example_group?(node)
-
-          missing_separating_line_offense(node) do |method|
-            format(MSG, subject: method)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_length.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_length.rb
deleted file mode 100644
index 9f5625046c11d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_length.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for long examples.
-      #
-      # A long example is usually more difficult to understand. Consider
-      # extracting out some behavior, e.g. with a `let` block, or a helper
-      # method.
-      #
-      # @example
-      #   # bad
-      #   it do
-      #     service = described_class.new
-      #     more_setup
-      #     more_setup
-      #     result = service.call
-      #     expect(result).to be(true)
-      #   end
-      #
-      #   # good
-      #   it do
-      #     service = described_class.new
-      #     result = service.call
-      #     expect(result).to be(true)
-      #   end
-      #
-      # You can set literals you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', and 'heredoc'. Each literal
-      # will be counted as one line regardless of its actual size.
-      #
-      # @example CountAsOne: ['array', 'heredoc']
-      #
-      #   it do
-      #     array = [         # +1
-      #       1,
-      #       2
-      #     ]
-      #
-      #     hash = {          # +3
-      #       key: 'value'
-      #     }
-      #
-      #     msg = <<~HEREDOC  # +1
-      #       Heredoc
-      #       content.
-      #     HEREDOC
-      #   end                 # 5 points
-      class ExampleLength < Base
-        include CodeLength
-
-        LABEL = 'Example'
-
-        def on_block(node)
-          return unless example?(node)
-
-          check_code_length(node)
-        end
-
-        private
-
-        def cop_label
-          LABEL
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_without_description.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_without_description.rb
deleted file mode 100644
index 3ada55b5bffaf..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_without_description.rb
+++ /dev/null
@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for examples without a description.
-      #
-      # RSpec allows for auto-generated example descriptions when there is no
-      # description provided or the description is an empty one.
-      #
-      # This cop removes empty descriptions.
-      # It also defines whether auto-generated description is allowed, based
-      # on the configured style.
-      #
-      # This cop can be configured using the `EnforcedStyle` option
-      #
-      # @example `EnforcedStyle: always_allow` (default)
-      #   # bad
-      #   it('') { is_expected.to be_good }
-      #   it '' do
-      #     result = service.call
-      #     expect(result).to be(true)
-      #   end
-      #
-      #   # good
-      #   it { is_expected.to be_good }
-      #   it do
-      #     result = service.call
-      #     expect(result).to be(true)
-      #   end
-      #
-      # @example `EnforcedStyle: single_line_only`
-      #   # bad
-      #   it('') { is_expected.to be_good }
-      #   it do
-      #     result = service.call
-      #     expect(result).to be(true)
-      #   end
-      #
-      #   # good
-      #   it { is_expected.to be_good }
-      #
-      # @example `EnforcedStyle: disallow`
-      #   # bad
-      #   it { is_expected.to be_good }
-      #   it do
-      #     result = service.call
-      #     expect(result).to be(true)
-      #   end
-      class ExampleWithoutDescription < Base
-        include ConfigurableEnforcedStyle
-
-        MSG_DEFAULT_ARGUMENT = 'Omit the argument when you want to ' \
-                               'have auto-generated description.'
-        MSG_ADD_DESCRIPTION  = 'Add a description.'
-
-        # @!method example_description(node)
-        def_node_matcher :example_description, '(send nil? _ $(str $_))'
-
-        def on_block(node)
-          return unless example?(node)
-
-          check_example_without_description(node.send_node)
-
-          example_description(node.send_node) do |message_node, message|
-            return unless message.to_s.empty?
-
-            add_offense(message_node, message: MSG_DEFAULT_ARGUMENT)
-          end
-        end
-
-        private
-
-        def check_example_without_description(node)
-          return if node.arguments?
-          return unless disallow_empty_description?(node)
-
-          add_offense(node, message: MSG_ADD_DESCRIPTION)
-        end
-
-        def disallow_empty_description?(node)
-          style == :disallow ||
-            (style == :single_line_only && node.parent.multiline?)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb
deleted file mode 100644
index 19d460164d112..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb
+++ /dev/null
@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for common mistakes in example descriptions.
-      #
-      # This cop will correct docstrings that begin with 'should' and 'it'.
-      #
-      # @see http://betterspecs.org/#should
-      #
-      # The autocorrect is experimental - use with care! It can be configured
-      # with CustomTransform (e.g. have => has) and IgnoredWords (e.g. only).
-      #
-      # @example
-      #   # bad
-      #   it 'should find nothing' do
-      #   end
-      #
-      #   # good
-      #   it 'finds nothing' do
-      #   end
-      #
-      # @example
-      #   # bad
-      #   it 'it does things' do
-      #   end
-      #
-      #   # good
-      #   it 'does things' do
-      #   end
-      class ExampleWording < Base
-        extend AutoCorrector
-
-        MSG_SHOULD = 'Do not use should when describing your tests.'
-        MSG_IT     = "Do not repeat 'it' when describing your tests."
-
-        SHOULD_PREFIX = /\Ashould(?:n't)?\b/i.freeze
-        IT_PREFIX     = /\Ait /i.freeze
-
-        # @!method it_description(node)
-        def_node_matcher :it_description, <<-PATTERN
-          (block (send _ :it ${
-            (str $_)
-            (dstr (str $_ ) ...)
-          } ...) ...)
-        PATTERN
-
-        def on_block(node)
-          it_description(node) do |description_node, message|
-            if message.match?(SHOULD_PREFIX)
-              add_wording_offense(description_node, MSG_SHOULD)
-            elsif message.match?(IT_PREFIX)
-              add_wording_offense(description_node, MSG_IT)
-            end
-          end
-        end
-
-        private
-
-        def add_wording_offense(node, message)
-          docstring = docstring(node)
-
-          add_offense(docstring, message: message) do |corrector|
-            next if node.heredoc?
-
-            corrector.replace(docstring, replacement_text(node))
-          end
-        end
-
-        def docstring(node)
-          expr = node.loc.expression
-
-          Parser::Source::Range.new(
-            expr.source_buffer,
-            expr.begin_pos + 1,
-            expr.end_pos - 1
-          )
-        end
-
-        def replacement_text(node)
-          text = text(node)
-
-          if text.match?(SHOULD_PREFIX)
-            RuboCop::RSpec::Wording.new(
-              text,
-              ignore:  ignored_words,
-              replace: custom_transform
-            ).rewrite
-          else
-            text.sub(IT_PREFIX, '')
-          end
-        end
-
-        # Recursive processing is required to process nested dstr nodes
-        # that is the case for \-separated multiline strings with interpolation.
-        def text(node)
-          case node.type
-          when :dstr
-            node.node_parts.map { |child_node| text(child_node) }.join
-          when :str
-            node.value
-          when :begin
-            node.source
-          end
-        end
-
-        def custom_transform
-          cop_config.fetch('CustomTransform', {})
-        end
-
-        def ignored_words
-          cop_config.fetch('IgnoredWords', [])
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb
deleted file mode 100644
index bc9800505ef4f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for excessive whitespace in example descriptions.
-      #
-      # @example
-      #   # bad
-      #   it '  has  excessive   spacing  ' do
-      #   end
-      #
-      #   # good
-      #   it 'has excessive spacing' do
-      #   end
-      #
-      # @example
-      #   # bad
-      #   context '  when a condition   is met  ' do
-      #   end
-      #
-      #   # good
-      #   context 'when a condition is met' do
-      #   end
-      class ExcessiveDocstringSpacing < Base
-        extend AutoCorrector
-
-        MSG = 'Excessive whitespace.'
-
-        # @!method example_description(node)
-        def_node_matcher :example_description, <<-PATTERN
-          (send _ {#Examples.all #ExampleGroups.all} ${
-            $str
-            $(dstr ({str dstr `sym} ...) ...)
-          } ...)
-        PATTERN
-
-        def on_send(node)
-          example_description(node) do |description_node, message|
-            return if description_node.heredoc?
-
-            text = text(message)
-
-            return unless excessive_whitespace?(text)
-
-            add_whitespace_offense(description_node, text)
-          end
-        end
-
-        private
-
-        # @param text [String]
-        def excessive_whitespace?(text)
-          return true if text.start_with?(' ') || text.end_with?(' ')
-
-          text.match?(/[^\n ]  +[^ ]/)
-        end
-
-        # @param text [String]
-        def strip_excessive_whitespace(text)
-          text.strip.gsub(/  +/, ' ')
-        end
-
-        # @param node [RuboCop::AST::Node]
-        # @param text [String]
-        def add_whitespace_offense(node, text)
-          docstring = docstring(node)
-          corrected = strip_excessive_whitespace(text)
-
-          add_offense(docstring) do |corrector|
-            corrector.replace(docstring, corrected)
-          end
-        end
-
-        def docstring(node)
-          expr = node.loc.expression
-
-          Parser::Source::Range.new(
-            expr.source_buffer,
-            expr.begin_pos + 1,
-            expr.end_pos - 1
-          )
-        end
-
-        # Recursive processing is required to process nested dstr nodes
-        # that is the case for \-separated multiline strings with interpolation.
-        def text(node)
-          case node.type
-          when :dstr
-            node.node_parts.map { |child_node| text(child_node) }.join
-          when :str, :sym
-            node.value
-          when :begin
-            node.source
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_actual.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_actual.rb
deleted file mode 100644
index 9f5867f960f73..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_actual.rb
+++ /dev/null
@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for `expect(...)` calls containing literal values.
-      #
-      # Autocorrection is performed when the expected is not a literal.
-      #
-      # @example
-      #   # bad
-      #   expect(5).to eq(price)
-      #   expect(/foo/).to eq(pattern)
-      #   expect("John").to eq(name)
-      #
-      #   # good
-      #   expect(price).to eq(5)
-      #   expect(pattern).to eq(/foo/)
-      #   expect(name).to eq("John")
-      #
-      class ExpectActual < Base
-        extend AutoCorrector
-
-        MSG = 'Provide the actual you are testing to `expect(...)`.'
-
-        SIMPLE_LITERALS = %i[
-          true
-          false
-          nil
-          int
-          float
-          str
-          sym
-          complex
-          rational
-          regopt
-        ].freeze
-
-        COMPLEX_LITERALS = %i[
-          array
-          hash
-          pair
-          irange
-          erange
-          regexp
-        ].freeze
-
-        SUPPORTED_MATCHERS = %i[eq eql equal be].freeze
-
-        # @!method expect_literal(node)
-        def_node_matcher :expect_literal, <<~PATTERN
-          (send
-            (send nil? :expect $#literal?)
-            #Runners.all
-            {
-              (send (send nil? $:be) :== $_)
-              (send nil? $_ $_ ...)
-            }
-          )
-        PATTERN
-
-        def on_send(node)
-          expect_literal(node) do |actual, matcher, expected|
-            add_offense(actual.source_range) do |corrector|
-              next unless SUPPORTED_MATCHERS.include?(matcher)
-              next if literal?(expected)
-
-              swap(corrector, actual, expected)
-            end
-          end
-        end
-
-        private
-
-        # This is not implement using a NodePattern because it seems
-        # to not be able to match against an explicit (nil) sexp
-        def literal?(node)
-          node && (simple_literal?(node) || complex_literal?(node))
-        end
-
-        def simple_literal?(node)
-          SIMPLE_LITERALS.include?(node.type)
-        end
-
-        def complex_literal?(node)
-          COMPLEX_LITERALS.include?(node.type) &&
-            node.each_child_node.all?(&method(:literal?))
-        end
-
-        def swap(corrector, actual, expected)
-          corrector.replace(actual.source_range, expected.source)
-          corrector.replace(expected.source_range, actual.source)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_change.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_change.rb
deleted file mode 100644
index 8864ca3489589..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_change.rb
+++ /dev/null
@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for consistent style of change matcher.
-      #
-      # Enforces either passing object and attribute as arguments to the matcher
-      # or passing a block that reads the attribute value.
-      #
-      # This cop can be configured using the `EnforcedStyle` option.
-      #
-      # @example `EnforcedStyle: method_call` (default)
-      #   # bad
-      #   expect { run }.to change { Foo.bar }
-      #   expect { run }.to change { foo.baz }
-      #
-      #   # good
-      #   expect { run }.to change(Foo, :bar)
-      #   expect { run }.to change(foo, :baz)
-      #   # also good when there are arguments or chained method calls
-      #   expect { run }.to change { Foo.bar(:count) }
-      #   expect { run }.to change { user.reload.name }
-      #
-      # @example `EnforcedStyle: block`
-      #   # bad
-      #   expect { run }.to change(Foo, :bar)
-      #
-      #   # good
-      #   expect { run }.to change { Foo.bar }
-      #
-      class ExpectChange < Base
-        extend AutoCorrector
-        include ConfigurableEnforcedStyle
-
-        MSG_BLOCK = 'Prefer `change(%<obj>s, :%<attr>s)`.'
-        MSG_CALL = 'Prefer `change { %<obj>s.%<attr>s }`.'
-        RESTRICT_ON_SEND = %i[change].freeze
-
-        # @!method expect_change_with_arguments(node)
-        def_node_matcher :expect_change_with_arguments, <<-PATTERN
-          (send nil? :change $_ ({sym str} $_))
-        PATTERN
-
-        # @!method expect_change_with_block(node)
-        def_node_matcher :expect_change_with_block, <<-PATTERN
-          (block
-            (send nil? :change)
-            (args)
-            (send
-              ${
-                (send nil? _)  # change { user.name }
-                const          # change { User.count }
-              }
-              $_
-            )
-          )
-        PATTERN
-
-        def on_send(node)
-          return unless style == :block
-
-          expect_change_with_arguments(node) do |receiver, message|
-            msg = format(MSG_CALL, obj: receiver.source, attr: message)
-            add_offense(node, message: msg) do |corrector|
-              replacement = "change { #{receiver.source}.#{message} }"
-              corrector.replace(node, replacement)
-            end
-          end
-        end
-
-        def on_block(node)
-          return unless style == :method_call
-
-          expect_change_with_block(node) do |receiver, message|
-            msg = format(MSG_BLOCK, obj: receiver.source, attr: message)
-            add_offense(node, message: msg) do |corrector|
-              replacement = "change(#{receiver.source}, :#{message})"
-              corrector.replace(node, replacement)
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_in_hook.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_in_hook.rb
deleted file mode 100644
index c111f150b93c0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_in_hook.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Do not use `expect` in hooks such as `before`.
-      #
-      # @example
-      #   # bad
-      #   before do
-      #     expect(something).to eq 'foo'
-      #   end
-      #
-      #   # bad
-      #   after do
-      #     expect_any_instance_of(Something).to receive(:foo)
-      #   end
-      #
-      #   # good
-      #   it do
-      #     expect(something).to eq 'foo'
-      #   end
-      class ExpectInHook < Base
-        MSG = 'Do not use `%<expect>s` in `%<hook>s` hook'
-
-        # @!method expectation(node)
-        def_node_search :expectation, send_pattern('#Expectations.all')
-
-        def on_block(node)
-          return unless hook?(node)
-          return if node.body.nil?
-
-          expectation(node.body) do |expect|
-            add_offense(expect.loc.selector,
-                        message: message(expect, node))
-          end
-        end
-
-        private
-
-        def message(expect, hook)
-          format(MSG, expect: expect.method_name, hook: hook.method_name)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_output.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_output.rb
deleted file mode 100644
index 70e8a771cc8be..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_output.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for opportunities to use `expect { ... }.to output`.
-      #
-      # @example
-      #   # bad
-      #   $stdout = StringIO.new
-      #   my_app.print_report
-      #   $stdout = STDOUT
-      #   expect($stdout.string).to eq('Hello World')
-      #
-      #   # good
-      #   expect { my_app.print_report }.to output('Hello World').to_stdout
-      class ExpectOutput < Base
-        MSG = 'Use `expect { ... }.to output(...).to_%<name>s` ' \
-              'instead of mutating $%<name>s.'
-
-        def on_gvasgn(node)
-          return unless inside_example_scope?(node)
-
-          # rubocop:disable InternalAffairs/NodeDestructuring
-          variable_name, _rhs = *node
-          # rubocop:enable InternalAffairs/NodeDestructuring
-          name = variable_name[1..]
-          return unless name.eql?('stdout') || name.eql?('stderr')
-
-          add_offense(node.loc.name, message: format(MSG, name: name))
-        end
-
-        private
-
-        # Detect if we are inside the scope of a single example
-        #
-        # We want to encourage using `expect { ... }.to output` so
-        # we only care about situations where you would replace with
-        # an expectation. Therefore, assignments to stderr or stdout
-        # within a `before(:all)` or otherwise outside of an example
-        # don't matter.
-        def inside_example_scope?(node)
-          return false if node.nil? || example_group?(node)
-          return true if example?(node)
-          return RuboCop::RSpec::Hook.new(node).example? if hook?(node)
-
-          inside_example_scope?(node.parent)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb
deleted file mode 100644
index a4b6dbe17ca4a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb
+++ /dev/null
@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module FactoryBot
-        # Always declare attribute values as blocks.
-        #
-        # @example
-        #   # bad
-        #   kind [:active, :rejected].sample
-        #
-        #   # good
-        #   kind { [:active, :rejected].sample }
-        #
-        #   # bad
-        #   closed_at 1.day.from_now
-        #
-        #   # good
-        #   closed_at { 1.day.from_now }
-        #
-        #   # bad
-        #   count 1
-        #
-        #   # good
-        #   count { 1 }
-        class AttributeDefinedStatically < Base
-          extend AutoCorrector
-
-          MSG = 'Use a block to declare attribute values.'
-
-          # @!method value_matcher(node)
-          def_node_matcher :value_matcher, <<-PATTERN
-            (send _ !#reserved_method? $...)
-          PATTERN
-
-          # @!method factory_attributes(node)
-          def_node_matcher :factory_attributes, <<-PATTERN
-            (block (send _ #attribute_defining_method? ...) _ { (begin $...) $(send ...) } )
-          PATTERN
-
-          def on_block(node)
-            attributes = factory_attributes(node) || []
-            attributes = [attributes] unless attributes.is_a?(Array) # rubocop:disable Style/ArrayCoercion, Lint/RedundantCopDisableDirective
-
-            attributes.each do |attribute|
-              next unless offensive_receiver?(attribute.receiver, node)
-              next if proc?(attribute) || association?(attribute.first_argument)
-
-              add_offense(attribute) do |corrector|
-                autocorrect(corrector, attribute)
-              end
-            end
-          end
-
-          private
-
-          def autocorrect(corrector, node)
-            if node.parenthesized?
-              autocorrect_replacing_parens(corrector, node)
-            else
-              autocorrect_without_parens(corrector, node)
-            end
-          end
-
-          def offensive_receiver?(receiver, node)
-            receiver.nil? ||
-              receiver.self_type? ||
-              receiver_matches_first_block_argument?(receiver, node)
-          end
-
-          def receiver_matches_first_block_argument?(receiver, node)
-            first_block_argument = node.arguments.first
-
-            !first_block_argument.nil? &&
-              receiver.lvar_type? &&
-              receiver.node_parts == first_block_argument.node_parts
-          end
-
-          def proc?(attribute)
-            value_matcher(attribute).to_a.all?(&:block_pass_type?)
-          end
-
-          # @!method association?(node)
-          def_node_matcher :association?, '(hash <(pair (sym :factory) _) ...>)'
-
-          def autocorrect_replacing_parens(corrector, node)
-            left_braces, right_braces = braces(node)
-
-            corrector.replace(node.location.begin, " #{left_braces}")
-            corrector.replace(node.location.end, right_braces)
-          end
-
-          def autocorrect_without_parens(corrector, node)
-            left_braces, right_braces = braces(node)
-
-            argument = node.first_argument
-            expression = argument.location.expression
-            corrector.insert_before(expression, left_braces)
-            corrector.insert_after(expression, right_braces)
-          end
-
-          def braces(node)
-            if value_hash_without_braces?(node.first_argument)
-              ['{ { ', ' } }']
-            else
-              ['{ ', ' }']
-            end
-          end
-
-          def value_hash_without_braces?(node)
-            node.hash_type? && !node.braces?
-          end
-
-          def reserved_method?(method_name)
-            RuboCop::RSpec::FactoryBot.reserved_methods.include?(method_name)
-          end
-
-          def attribute_defining_method?(method_name)
-            RuboCop::RSpec::FactoryBot.attribute_defining_methods
-              .include?(method_name)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb
deleted file mode 100644
index 12db0979ea25f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb
+++ /dev/null
@@ -1,239 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module FactoryBot
-        # Checks for create_list usage.
-        #
-        # This cop can be configured using the `EnforcedStyle` option
-        #
-        # @example `EnforcedStyle: create_list` (default)
-        #   # bad
-        #   3.times { create :user }
-        #
-        #   # good
-        #   create_list :user, 3
-        #
-        #   # bad
-        #   3.times { create :user, age: 18 }
-        #
-        #   # good - index is used to alter the created models attributes
-        #   3.times { |n| create :user, age: n }
-        #
-        #   # good - contains a method call, may return different values
-        #   3.times { create :user, age: rand }
-        #
-        # @example `EnforcedStyle: n_times`
-        #   # bad
-        #   create_list :user, 3
-        #
-        #   # good
-        #   3.times { create :user }
-        class CreateList < Base
-          extend AutoCorrector
-          include ConfigurableEnforcedStyle
-          include RuboCop::RSpec::FactoryBot::Language
-
-          MSG_CREATE_LIST = 'Prefer create_list.'
-          MSG_N_TIMES = 'Prefer %<number>s.times.'
-          RESTRICT_ON_SEND = %i[create_list].freeze
-
-          # @!method n_times_block?(node)
-          def_node_matcher :n_times_block?, <<-PATTERN
-            (block
-              (send (int _) :times)
-              ...
-            )
-          PATTERN
-
-          # @!method n_times_block_with_arg_and_used?(node)
-          def_node_matcher :n_times_block_with_arg_and_used?, <<-PATTERN
-            (block
-              (send (int _) :times)
-              (args (arg _value))
-                `_value
-            )
-          PATTERN
-
-          # @!method arguments_include_method_call?(node)
-          def_node_matcher :arguments_include_method_call?, <<-PATTERN
-            (send ${nil? #factory_bot?} :create (sym $_) `$(send ...))
-          PATTERN
-
-          # @!method factory_call(node)
-          def_node_matcher :factory_call, <<-PATTERN
-            (send ${nil? #factory_bot?} :create (sym $_) $...)
-          PATTERN
-
-          # @!method factory_list_call(node)
-          def_node_matcher :factory_list_call, <<-PATTERN
-            (send {nil? #factory_bot?} :create_list (sym _) (int $_) ...)
-          PATTERN
-
-          def on_block(node)
-            return unless style == :create_list
-
-            return unless n_times_block?(node)
-            return if n_times_block_with_arg_and_used?(node)
-            return unless node.body
-            return if arguments_include_method_call?(node.body)
-            return unless contains_only_factory?(node.body)
-
-            add_offense(node.send_node, message: MSG_CREATE_LIST) do |corrector|
-              CreateListCorrector.new(node.send_node).call(corrector)
-            end
-          end
-
-          def on_send(node)
-            return unless style == :n_times
-
-            factory_list_call(node) do |count|
-              message = format(MSG_N_TIMES, number: count)
-              add_offense(node.loc.selector, message: message) do |corrector|
-                TimesCorrector.new(node).call(corrector)
-              end
-            end
-          end
-
-          private
-
-          def contains_only_factory?(node)
-            if node.block_type?
-              factory_call(node.send_node)
-            else
-              factory_call(node)
-            end
-          end
-
-          # :nodoc
-          module Corrector
-            private
-
-            def build_options_string(options)
-              options.map(&:source).join(', ')
-            end
-
-            def format_method_call(node, method, arguments)
-              if node.block_type? || node.parenthesized?
-                "#{method}(#{arguments})"
-              else
-                "#{method} #{arguments}"
-              end
-            end
-
-            def format_receiver(receiver)
-              return '' unless receiver
-
-              "#{receiver.source}."
-            end
-          end
-
-          # :nodoc
-          class TimesCorrector
-            include Corrector
-
-            def initialize(node)
-              @node = node
-            end
-
-            def call(corrector)
-              replacement = generate_n_times_block(node)
-              corrector.replace(node, replacement)
-            end
-
-            private
-
-            attr_reader :node
-
-            def generate_n_times_block(node)
-              factory, count, *options = node.arguments
-
-              arguments = factory.source
-              options = build_options_string(options)
-              arguments += ", #{options}" unless options.empty?
-
-              replacement = format_receiver(node.receiver)
-              replacement += format_method_call(node, 'create', arguments)
-              "#{count.source}.times { #{replacement} }"
-            end
-          end
-
-          # :nodoc:
-          class CreateListCorrector
-            include Corrector
-
-            def initialize(node)
-              @node = node.parent
-            end
-
-            def call(corrector)
-              replacement = if node.body.block_type?
-                              call_with_block_replacement(node)
-                            else
-                              call_replacement(node)
-                            end
-
-              corrector.replace(node, replacement)
-            end
-
-            private
-
-            attr_reader :node
-
-            def call_with_block_replacement(node)
-              block = node.body
-              arguments = build_arguments(block, node.receiver.source)
-              replacement = format_receiver(block.receiver)
-              replacement += format_method_call(block, 'create_list', arguments)
-              replacement += format_block(block)
-              replacement
-            end
-
-            def build_arguments(node, count)
-              factory, *options = *node.send_node.arguments
-
-              arguments = ":#{factory.value}, #{count}"
-              options = build_options_string(options)
-              arguments += ", #{options}" unless options.empty?
-              arguments
-            end
-
-            def call_replacement(node)
-              block = node.body
-              factory, *options = *block.arguments
-
-              arguments = "#{factory.source}, #{node.receiver.source}"
-              options = build_options_string(options)
-              arguments += ", #{options}" unless options.empty?
-
-              replacement = format_receiver(block.receiver)
-              replacement += format_method_call(block, 'create_list', arguments)
-              replacement
-            end
-
-            def format_block(node)
-              if node.body.begin_type?
-                format_multiline_block(node)
-              else
-                format_singleline_block(node)
-              end
-            end
-
-            def format_multiline_block(node)
-              indent = ' ' * node.body.loc.column
-              indent_end = ' ' * node.parent.loc.column
-              " do #{node.arguments.source}\n" \
-              "#{indent}#{node.body.source}\n" \
-              "#{indent_end}end"
-            end
-
-            def format_singleline_block(node)
-              " { #{node.arguments.source} #{node.body.source} }"
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb
deleted file mode 100644
index 2deb3584ff487..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb
+++ /dev/null
@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module FactoryBot
-        # Use string value when setting the class attribute explicitly.
-        #
-        # This cop would promote faster tests by lazy-loading of
-        # application files. Also, this could help you suppress potential bugs
-        # in combination with external libraries by avoiding a preload of
-        # application files from the factory files.
-        #
-        # @example
-        #   # bad
-        #   factory :foo, class: Foo do
-        #   end
-        #
-        #   # good
-        #   factory :foo, class: 'Foo' do
-        #   end
-        class FactoryClassName < Base
-          extend AutoCorrector
-
-          MSG = "Pass '%<class_name>s' string instead of `%<class_name>s` " \
-                'constant.'
-          ALLOWED_CONSTANTS = %w[Hash OpenStruct].freeze
-          RESTRICT_ON_SEND = %i[factory].freeze
-
-          # @!method class_name(node)
-          def_node_matcher :class_name, <<~PATTERN
-            (send _ :factory _ (hash <(pair (sym :class) $(const ...)) ...>))
-          PATTERN
-
-          def on_send(node)
-            class_name(node) do |cn|
-              next if allowed?(cn.const_name)
-
-              msg = format(MSG, class_name: cn.const_name)
-              add_offense(cn, message: msg) do |corrector|
-                corrector.replace(cn, "'#{cn.source}'")
-              end
-            end
-          end
-
-          private
-
-          def allowed?(const_name)
-            ALLOWED_CONSTANTS.include?(const_name)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/syntax_methods.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/syntax_methods.rb
deleted file mode 100644
index 24a2e711a7562..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/syntax_methods.rb
+++ /dev/null
@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module FactoryBot
-        # Use shorthands from `FactoryBot::Syntax::Methods` in your specs.
-        #
-        # @safety
-        #   The autocorrection is marked as unsafe because the cop
-        #   cannot verify whether you already include
-        #   `FactoryBot::Syntax::Methods` in your test suite.
-        #
-        #   If you're using Rails, add the following configuration to
-        #   `spec/support/factory_bot.rb` and be sure to require that file in
-        #   `rails_helper.rb`:
-        #
-        #   [source,ruby]
-        #   ----
-        #   RSpec.configure do |config|
-        #     config.include FactoryBot::Syntax::Methods
-        #   end
-        #   ----
-        #
-        #   If you're not using Rails:
-        #
-        #   [source,ruby]
-        #   ----
-        #   RSpec.configure do |config|
-        #     config.include FactoryBot::Syntax::Methods
-        #
-        #     config.before(:suite) do
-        #       FactoryBot.find_definitions
-        #     end
-        #   end
-        #   ----
-        #
-        # @example
-        #   # bad
-        #   FactoryBot.create(:bar)
-        #   FactoryBot.build(:bar)
-        #   FactoryBot.attributes_for(:bar)
-        #
-        #   # good
-        #   create(:bar)
-        #   build(:bar)
-        #   attributes_for(:bar)
-        #
-        class SyntaxMethods < Base
-          extend AutoCorrector
-          include InsideExampleGroup
-          include RangeHelp
-          include RuboCop::RSpec::FactoryBot::Language
-
-          MSG = 'Use `%<method>s` from `FactoryBot::Syntax::Methods`.'
-
-          RESTRICT_ON_SEND = %i[
-            attributes_for
-            attributes_for_list
-            attributes_for_pair
-            build
-            build_list
-            build_pair
-            build_stubbed
-            build_stubbed_list
-            build_stubbed_pair
-            create
-            create_list
-            create_pair
-            generate
-            generate_list
-            null
-            null_list
-            null_pair
-          ].to_set.freeze
-
-          def on_send(node)
-            return unless factory_bot?(node.receiver)
-            return unless inside_example_group?(node)
-
-            message = format(MSG, method: node.method_name)
-
-            add_offense(crime_scene(node), message: message) do |corrector|
-              corrector.remove(offense(node))
-            end
-          end
-
-          private
-
-          def crime_scene(node)
-            range_between(
-              node.loc.expression.begin_pos,
-              node.loc.selector.end_pos
-            )
-          end
-
-          def offense(node)
-            range_between(
-              node.loc.expression.begin_pos,
-              node.loc.selector.begin_pos
-            )
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb
deleted file mode 100644
index 00ff71508b418..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb
+++ /dev/null
@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that spec file paths are consistent and well-formed.
-      #
-      # By default, this checks that spec file paths are consistent with the
-      # test subject and and enforces that it reflects the described
-      # class/module and its optionally called out method.
-      #
-      # With the configuration option `IgnoreMethods` the called out method will
-      # be ignored when determining the enforced path.
-      #
-      # With the configuration option `CustomTransform` modules or classes can
-      # be specified that should not as usual be transformed from CamelCase to
-      # snake_case (e.g. 'RuboCop' => 'rubocop' ).
-      #
-      # With the configuration option `SpecSuffixOnly` test files will only
-      # be checked to ensure they end in '_spec.rb'. This option disables
-      # checking for consistency in the test subject or test methods.
-      #
-      # @example
-      #   # bad
-      #   whatever_spec.rb         # describe MyClass
-      #
-      #   # bad
-      #   my_class_spec.rb         # describe MyClass, '#method'
-      #
-      #   # good
-      #   my_class_spec.rb         # describe MyClass
-      #
-      #   # good
-      #   my_class_method_spec.rb  # describe MyClass, '#method'
-      #
-      #   # good
-      #   my_class/method_spec.rb  # describe MyClass, '#method'
-      #
-      # @example when configuration is `IgnoreMethods: true`
-      #   # bad
-      #   whatever_spec.rb         # describe MyClass
-      #
-      #   # good
-      #   my_class_spec.rb         # describe MyClass
-      #
-      #   # good
-      #   my_class_spec.rb         # describe MyClass, '#method'
-      #
-      # @example when configuration is `SpecSuffixOnly: true`
-      #   # good
-      #   whatever_spec.rb         # describe MyClass
-      #
-      #   # good
-      #   my_class_spec.rb         # describe MyClass
-      #
-      #   # good
-      #   my_class_spec.rb         # describe MyClass, '#method'
-      #
-      class FilePath < Base
-        include TopLevelGroup
-
-        MSG = 'Spec path should end with `%<suffix>s`.'
-
-        # @!method example_group(node)
-        def_node_matcher :example_group, <<~PATTERN
-          (block
-            $(send #rspec? _example_group $_ $...) ...
-          )
-        PATTERN
-
-        # @!method routing_metadata?(node)
-        def_node_search :routing_metadata?, '(pair (sym :type) (sym :routing))'
-
-        def on_top_level_example_group(node)
-          return unless top_level_groups.one?
-
-          example_group(node) do |send_node, example_group, arguments|
-            next if routing_spec?(arguments)
-
-            ensure_correct_file_path(send_node, example_group, arguments)
-          end
-        end
-
-        private
-
-        def ensure_correct_file_path(send_node, example_group, arguments)
-          pattern = pattern_for(example_group, arguments.first)
-          return if filename_ends_with?(pattern)
-
-          # For the suffix shown in the offense message, modify the regular
-          # expression pattern to resemble a glob pattern for clearer error
-          # messages.
-          offense_suffix = pattern.gsub('.*', '*').sub('[^/]', '')
-            .sub('\.', '.')
-          add_offense(send_node, message: format(MSG, suffix: offense_suffix))
-        end
-
-        def routing_spec?(args)
-          args.any?(&method(:routing_metadata?))
-        end
-
-        def pattern_for(example_group, method_name)
-          if spec_suffix_only? || !example_group.const_type?
-            return pattern_for_spec_suffix_only?
-          end
-
-          [
-            expected_path(example_group),
-            name_pattern(method_name),
-            '[^/]*_spec\.rb'
-          ].join
-        end
-
-        def pattern_for_spec_suffix_only?
-          '.*_spec\.rb'
-        end
-
-        def name_pattern(method_name)
-          return unless method_name&.str_type?
-          return if ignore_methods?
-
-          ".*#{method_name.str_content.gsub(/\s/, '_').gsub(/\W/, '')}"
-        end
-
-        def expected_path(constant)
-          File.join(
-            constant.const_name.split('::').map do |name|
-              custom_transform.fetch(name) { camel_to_snake_case(name) }
-            end
-          )
-        end
-
-        def camel_to_snake_case(string)
-          string
-            .gsub(/([^A-Z])([A-Z]+)/, '\1_\2')
-            .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
-            .downcase
-        end
-
-        def custom_transform
-          cop_config.fetch('CustomTransform', {})
-        end
-
-        def ignore_methods?
-          cop_config['IgnoreMethods']
-        end
-
-        def filename_ends_with?(pattern)
-          filename = File.expand_path(processed_source.buffer.name)
-          filename.match?("#{pattern}$")
-        end
-
-        def relevant_rubocop_rspec_file?(_file)
-          true
-        end
-
-        def spec_suffix_only?
-          cop_config['SpecSuffixOnly']
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/focus.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/focus.rb
deleted file mode 100644
index 2ecaeba076716..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/focus.rb
+++ /dev/null
@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks if examples are focused.
-      #
-      # @example
-      #   # bad
-      #   describe MyClass, focus: true do
-      #   end
-      #
-      #   describe MyClass, :focus do
-      #   end
-      #
-      #   fdescribe MyClass do
-      #   end
-      #
-      #   # good
-      #   describe MyClass do
-      #   end
-      class Focus < Base
-        extend AutoCorrector
-        include RangeHelp
-
-        MSG = 'Focused spec found.'
-
-        # @!method focusable_selector?(node)
-        def_node_matcher :focusable_selector?, <<-PATTERN
-          {
-            #ExampleGroups.regular
-            #ExampleGroups.skipped
-            #Examples.regular
-            #Examples.skipped
-            #Examples.pending
-          }
-        PATTERN
-
-        # @!method metadata(node)
-        def_node_matcher :metadata, <<-PATTERN
-          {(send #rspec? #focusable_selector? <$(sym :focus) ...>)
-           (send #rspec? #focusable_selector? ... (hash <$(pair (sym :focus) true) ...>))}
-        PATTERN
-
-        # @!method focused_block?(node)
-        def_node_matcher :focused_block?,
-                         send_pattern(<<~PATTERN)
-                           {#ExampleGroups.focused #Examples.focused}
-                         PATTERN
-
-        def on_send(node)
-          focus_metadata(node) do |focus|
-            add_offense(focus) do |corrector|
-              if focus.pair_type? || focus.str_type? || focus.sym_type?
-                corrector.remove(with_surrounding(focus))
-              elsif focus.send_type?
-                correct_send(corrector, focus)
-              end
-            end
-          end
-        end
-
-        private
-
-        def focus_metadata(node, &block)
-          yield(node) if focused_block?(node)
-
-          metadata(node, &block)
-        end
-
-        def with_surrounding(focus)
-          range_with_space =
-            range_with_surrounding_space(focus.loc.expression, side: :left)
-
-          range_with_surrounding_comma(range_with_space, :left)
-        end
-
-        def correct_send(corrector, focus)
-          range = focus.loc.selector
-          unfocused = focus.method_name.to_s.sub(/^f/, '')
-          unless Examples.regular(unfocused) || ExampleGroups.regular(unfocused)
-            return
-          end
-
-          corrector.replace(range,
-                            range.source.sub(focus.method_name.to_s, unfocused))
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hook_argument.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hook_argument.rb
deleted file mode 100644
index 5fa9c8f41c882..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hook_argument.rb
+++ /dev/null
@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks the arguments passed to `before`, `around`, and `after`.
-      #
-      # This cop checks for consistent style when specifying RSpec
-      # hooks which run for each example. There are three supported
-      # styles: "implicit", "each", and "example." All styles have
-      # the same behavior.
-      #
-      # @example `EnforcedStyle: implicit` (default)
-      #   # bad
-      #   before(:each) do
-      #     # ...
-      #   end
-      #
-      #   # bad
-      #   before(:example) do
-      #     # ...
-      #   end
-      #
-      #   # good
-      #   before do
-      #     # ...
-      #   end
-      #
-      # @example `EnforcedStyle: each`
-      #   # bad
-      #   before(:example) do
-      #     # ...
-      #   end
-      #
-      #   # bad
-      #   before do
-      #     # ...
-      #   end
-      #
-      #   # good
-      #   before(:each) do
-      #     # ...
-      #   end
-      #
-      # @example `EnforcedStyle: example`
-      #   # bad
-      #   before(:each) do
-      #     # ...
-      #   end
-      #
-      #   # bad
-      #   before do
-      #     # ...
-      #   end
-      #
-      #   # good
-      #   before(:example) do
-      #     # ...
-      #   end
-      class HookArgument < Base
-        extend AutoCorrector
-        include ConfigurableEnforcedStyle
-
-        IMPLICIT_MSG = 'Omit the default `%<scope>p` argument for RSpec hooks.'
-        EXPLICIT_MSG = 'Use `%<scope>p` for RSpec hooks.'
-
-        # @!method scoped_hook(node)
-        def_node_matcher :scoped_hook, <<-PATTERN
-          (block $(send _ #Hooks.all (sym ${:each :example})) ...)
-        PATTERN
-
-        # @!method unscoped_hook(node)
-        def_node_matcher :unscoped_hook, '(block $(send _ #Hooks.all) ...)'
-
-        def on_block(node)
-          hook(node) do |method_send, scope_name|
-            return correct_style_detected if scope_name.equal?(style)
-            return check_implicit(method_send) unless scope_name
-
-            style_detected(scope_name)
-            msg = explicit_message(scope_name)
-            add_offense(method_send, message: msg) do |corrector|
-              scope = implicit_style? ? '' : "(#{style.inspect})"
-              corrector.replace(argument_range(method_send), scope)
-            end
-          end
-        end
-
-        private
-
-        def check_implicit(method_send)
-          style_detected(:implicit)
-          return if implicit_style?
-
-          msg = explicit_message(nil)
-          add_offense(method_send.loc.selector, message: msg) do |corrector|
-            scope = "(#{style.inspect})"
-            corrector.replace(argument_range(method_send), scope)
-          end
-        end
-
-        def explicit_message(scope)
-          if implicit_style?
-            format(IMPLICIT_MSG, scope: scope)
-          else
-            format(EXPLICIT_MSG, scope: style)
-          end
-        end
-
-        def implicit_style?
-          style.equal?(:implicit)
-        end
-
-        def hook(node, &block)
-          scoped_hook(node, &block) || unscoped_hook(node, &block)
-        end
-
-        def argument_range(send_node)
-          send_node.loc.selector.end.with(
-            end_pos: send_node.loc.expression.end_pos
-          )
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hooks_before_examples.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hooks_before_examples.rb
deleted file mode 100644
index 412314a2c8d49..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hooks_before_examples.rb
+++ /dev/null
@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for before/around/after hooks that come after an example.
-      #
-      # @example
-      #   # Bad
-      #
-      #   it 'checks what foo does' do
-      #     expect(foo).to be
-      #   end
-      #
-      #   before { prepare }
-      #   after { clean_up }
-      #
-      #   # Good
-      #   before { prepare }
-      #   after { clean_up }
-      #
-      #   it 'checks what foo does' do
-      #     expect(foo).to be
-      #   end
-      #
-      class HooksBeforeExamples < Base
-        extend AutoCorrector
-
-        MSG = 'Move `%<hook>s` above the examples in the group.'
-
-        # @!method example_or_group?(node)
-        def_node_matcher :example_or_group?, <<-PATTERN
-          {
-            #{block_pattern('{#ExampleGroups.all #Examples.all}')}
-            #{send_pattern('#Includes.examples')}
-          }
-        PATTERN
-
-        def on_block(node)
-          return unless example_group_with_body?(node)
-
-          check_hooks(node.body) if multiline_block?(node.body)
-        end
-
-        private
-
-        def multiline_block?(block)
-          block.begin_type?
-        end
-
-        def check_hooks(node)
-          first_example = find_first_example(node)
-          return unless first_example
-
-          node.each_child_node do |child|
-            next if child.sibling_index < first_example.sibling_index
-            next unless hook?(child)
-
-            msg = format(MSG, hook: child.method_name)
-            add_offense(child, message: msg) do |corrector|
-              autocorrect(corrector, child, first_example)
-            end
-          end
-        end
-
-        def find_first_example(node)
-          node.children.find { |sibling| example_or_group?(sibling) }
-        end
-
-        def autocorrect(corrector, node, first_example)
-          RuboCop::RSpec::Corrector::MoveNode.new(
-            node, corrector, processed_source
-          ).move_before(first_example)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/identical_equality_assertion.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/identical_equality_assertion.rb
deleted file mode 100644
index 89f911b999eca..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/identical_equality_assertion.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for equality assertions with identical expressions on both sides.
-      #
-      # @example
-      #
-      #   # bad
-      #   expect(foo.bar).to eq(foo.bar)
-      #   expect(foo.bar).to eql(foo.bar)
-      #
-      #   # good
-      #   expect(foo.bar).to eq(2)
-      #   expect(foo.bar).to eql(2)
-      #
-      class IdenticalEqualityAssertion < Base
-        MSG = 'Identical expressions on both sides of the equality ' \
-              'may indicate a flawed test.'
-        RESTRICT_ON_SEND = %i[to].freeze
-
-        # @!method equality_check?(node)
-        def_node_matcher :equality_check?, <<~PATTERN
-          (send (send nil? :expect $_) :to
-            {(send nil? {:eql :eq :be} $_)
-             (send (send nil? :be) :== $_)})
-        PATTERN
-
-        def on_send(node)
-          equality_check?(node) do |left, right|
-            add_offense(node) if left == right
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_block_expectation.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_block_expectation.rb
deleted file mode 100644
index 9ad8a360d732b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_block_expectation.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check that implicit block expectation syntax is not used.
-      #
-      # Prefer using explicit block expectations.
-      #
-      # @example
-      #   # bad
-      #   subject { -> { do_something } }
-      #   it { is_expected.to change(something).to(new_value) }
-      #
-      #   # good
-      #   it 'changes something to a new value' do
-      #     expect { do_something }.to change(something).to(new_value)
-      #   end
-      class ImplicitBlockExpectation < Base
-        MSG = 'Avoid implicit block expectations.'
-        RESTRICT_ON_SEND = %i[is_expected should should_not].freeze
-
-        # @!method lambda?(node)
-        def_node_matcher :lambda?, <<-PATTERN
-          {
-            (send (const nil? :Proc) :new)
-            (send nil? {:proc :lambda})
-          }
-        PATTERN
-
-        # @!method lambda_subject?(node)
-        def_node_matcher :lambda_subject?, '(block #lambda? ...)'
-
-        # @!method implicit_expect(node)
-        def_node_matcher :implicit_expect, <<-PATTERN
-          $(send nil? {:is_expected :should :should_not} ...)
-        PATTERN
-
-        def on_send(node)
-          implicit_expect(node) do |implicit_expect|
-            subject = nearest_subject(implicit_expect)
-            add_offense(implicit_expect) if lambda_subject?(subject&.body)
-          end
-        end
-
-        private
-
-        def nearest_subject(node)
-          node
-            .each_ancestor(:block)
-            .lazy
-            .select { |block_node| multi_statement_example_group?(block_node) }
-            .map { |block_node| find_subject(block_node) }
-            .find(&:itself)
-        end
-
-        def multi_statement_example_group?(node)
-          example_group_with_body?(node) && node.body.begin_type?
-        end
-
-        def find_subject(block_node)
-          block_node.body.child_nodes.find { |send_node| subject?(send_node) }
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_expect.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_expect.rb
deleted file mode 100644
index e69f66978513d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_expect.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check that a consistent implicit expectation style is used.
-      #
-      # This cop can be configured using the `EnforcedStyle` option
-      # and supports the `--auto-gen-config` flag.
-      #
-      # @example `EnforcedStyle: is_expected` (default)
-      #
-      #   # bad
-      #   it { should be_truthy }
-      #
-      #   # good
-      #   it { is_expected.to be_truthy }
-      #
-      # @example `EnforcedStyle: should`
-      #
-      #   # bad
-      #   it { is_expected.to be_truthy }
-      #
-      #   # good
-      #   it { should be_truthy }
-      #
-      class ImplicitExpect < Base
-        extend AutoCorrector
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Prefer `%<good>s` over `%<bad>s`.'
-
-        # @!method implicit_expect(node)
-        def_node_matcher :implicit_expect, <<-PATTERN
-          {
-            (send nil? ${:should :should_not} ...)
-            (send (send nil? $:is_expected) #Runners.all ...)
-          }
-        PATTERN
-
-        alternatives = {
-          'is_expected.to'     => 'should',
-          'is_expected.not_to' => 'should_not',
-          'is_expected.to_not' => 'should_not'
-        }
-
-        ENFORCED_REPLACEMENTS = alternatives.merge(alternatives.invert).freeze
-
-        def on_send(node) # rubocop:disable Metrics/MethodLength
-          return unless (source_range = offending_expect(node))
-
-          expectation_source = source_range.source
-
-          if expectation_source.start_with?(style.to_s)
-            correct_style_detected
-          else
-            opposite_style_detected
-
-            msg = offense_message(expectation_source)
-            add_offense(source_range, message: msg) do |corrector|
-              replacement = replacement_source(expectation_source)
-              corrector.replace(source_range, replacement)
-            end
-          end
-        end
-
-        private
-
-        def offending_expect(node)
-          case implicit_expect(node)
-          when :is_expected
-            is_expected_range(node.loc)
-          when :should, :should_not
-            node.loc.selector
-          end
-        end
-
-        def is_expected_range(source_map) # rubocop:disable Naming/PredicateName
-          Parser::Source::Range.new(
-            source_map.expression.source_buffer,
-            source_map.expression.begin_pos,
-            source_map.selector.end_pos
-          )
-        end
-
-        def offense_message(offending_source)
-          format(
-            MSG,
-            good: replacement_source(offending_source),
-            bad:  offending_source
-          )
-        end
-
-        def replacement_source(offending_source)
-          ENFORCED_REPLACEMENTS.fetch(offending_source)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_subject.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_subject.rb
deleted file mode 100644
index dafb022995bb2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_subject.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for usage of implicit subject (`is_expected` / `should`).
-      #
-      # This cop can be configured using the `EnforcedStyle` option
-      #
-      # @example `EnforcedStyle: single_line_only` (default)
-      #   # bad
-      #   it do
-      #     is_expected.to be_truthy
-      #   end
-      #
-      #   # good
-      #   it { is_expected.to be_truthy }
-      #   it do
-      #     expect(subject).to be_truthy
-      #   end
-      #
-      # @example `EnforcedStyle: single_statement_only`
-      #   # bad
-      #   it do
-      #     foo = 1
-      #     is_expected.to be_truthy
-      #   end
-      #
-      #   # good
-      #   it do
-      #     foo = 1
-      #     expect(subject).to be_truthy
-      #   end
-      #   it do
-      #     is_expected.to be_truthy
-      #   end
-      #
-      # @example `EnforcedStyle: disallow`
-      #   # bad
-      #   it { is_expected.to be_truthy }
-      #
-      #   # good
-      #   it { expect(subject).to be_truthy }
-      #
-      class ImplicitSubject < Base
-        extend AutoCorrector
-        include ConfigurableEnforcedStyle
-
-        MSG = "Don't use implicit subject."
-        RESTRICT_ON_SEND = %i[is_expected should should_not].freeze
-
-        # @!method implicit_subject?(node)
-        def_node_matcher :implicit_subject?, <<-PATTERN
-          (send nil? {:should :should_not :is_expected} ...)
-        PATTERN
-
-        def on_send(node)
-          return unless implicit_subject?(node)
-          return if valid_usage?(node)
-
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          replacement = 'expect(subject)'
-          case node.method_name
-          when :should
-            replacement += '.to'
-          when :should_not
-            replacement += '.not_to'
-          end
-
-          corrector.replace(node.loc.selector, replacement)
-        end
-
-        def valid_usage?(node)
-          example = node.ancestors.find { |parent| example?(parent) }
-          return false if example.nil?
-
-          example.method?(:its) || allowed_by_style?(example)
-        end
-
-        def allowed_by_style?(example)
-          case style
-          when :single_line_only
-            example.single_line?
-          when :single_statement_only
-            !example.body.begin_type?
-          else
-            false
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_spy.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_spy.rb
deleted file mode 100644
index 5b186ecff8e35..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_spy.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for `instance_double` used with `have_received`.
-      #
-      # @example
-      #   # bad
-      #   it do
-      #     foo = instance_double(Foo).as_null_object
-      #     expect(foo).to have_received(:bar)
-      #   end
-      #
-      #   # good
-      #   it do
-      #     foo = instance_spy(Foo)
-      #     expect(foo).to have_received(:bar)
-      #   end
-      #
-      class InstanceSpy < Base
-        extend AutoCorrector
-
-        MSG = 'Use `instance_spy` when you check your double ' \
-              'with `have_received`.'
-
-        # @!method null_double(node)
-        def_node_search :null_double, <<-PATTERN
-          (lvasgn $_
-            (send
-              $(send nil? :instance_double
-                ...) :as_null_object))
-        PATTERN
-
-        # @!method have_received_usage(node)
-        def_node_search :have_received_usage, <<-PATTERN
-          (send
-            (send nil? :expect
-            (lvar $_)) :to
-            (send nil? :have_received
-            ...)
-          ...)
-        PATTERN
-
-        def on_block(node)
-          return unless example?(node)
-
-          null_double(node) do |var, receiver|
-            have_received_usage(node) do |expected|
-              next if expected != var
-
-              add_offense(receiver) do |corrector|
-                autocorrect(corrector, receiver)
-              end
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          replacement = 'instance_spy'
-          corrector.replace(node.loc.selector, replacement)
-
-          double_source_map = node.parent.loc
-          as_null_object_range = double_source_map
-            .dot
-            .join(double_source_map.selector)
-          corrector.remove(as_null_object_range)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_variable.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_variable.rb
deleted file mode 100644
index ea1aab4dfe972..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_variable.rb
+++ /dev/null
@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for instance variable usage in specs.
-      #
-      # This cop can be configured with the option `AssignmentOnly` which
-      # will configure the cop to only register offenses on instance
-      # variable usage if the instance variable is also assigned within
-      # the spec
-      #
-      # @example
-      #   # bad
-      #   describe MyClass do
-      #     before { @foo = [] }
-      #     it { expect(@foo).to be_empty }
-      #   end
-      #
-      #   # good
-      #   describe MyClass do
-      #     let(:foo) { [] }
-      #     it { expect(foo).to be_empty }
-      #   end
-      #
-      # @example with AssignmentOnly configuration
-      #
-      #   # rubocop.yml
-      #   # RSpec/InstanceVariable:
-      #   #   AssignmentOnly: false
-      #
-      #   # bad
-      #   describe MyClass do
-      #     before { @foo = [] }
-      #     it { expect(@foo).to be_empty }
-      #   end
-      #
-      #   # allowed
-      #   describe MyClass do
-      #     it { expect(@foo).to be_empty }
-      #   end
-      #
-      #   # good
-      #   describe MyClass do
-      #     let(:foo) { [] }
-      #     it { expect(foo).to be_empty }
-      #   end
-      #
-      class InstanceVariable < Base
-        include TopLevelGroup
-
-        MSG = 'Avoid instance variables – use let, ' \
-              'a method call, or a local variable (if possible).'
-
-        # @!method dynamic_class?(node)
-        def_node_matcher :dynamic_class?, <<-PATTERN
-          (block (send (const nil? :Class) :new ...) ...)
-        PATTERN
-
-        # @!method custom_matcher?(node)
-        def_node_matcher :custom_matcher?, <<-PATTERN
-          (block {
-            (send nil? :matcher sym)
-            (send (const (const nil? :RSpec) :Matchers) :define sym)
-          } ...)
-        PATTERN
-
-        # @!method ivar_usage(node)
-        def_node_search :ivar_usage, '$(ivar $_)'
-
-        # @!method ivar_assigned?(node)
-        def_node_search :ivar_assigned?, '(ivasgn % ...)'
-
-        def on_top_level_group(node)
-          ivar_usage(node) do |ivar, name|
-            next if valid_usage?(ivar)
-            next if assignment_only? && !ivar_assigned?(node, name)
-
-            add_offense(ivar)
-          end
-        end
-
-        private
-
-        def valid_usage?(node)
-          node.each_ancestor(:block).any? do |block|
-            dynamic_class?(block) || custom_matcher?(block)
-          end
-        end
-
-        def assignment_only?
-          cop_config['AssignmentOnly']
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/it_behaves_like.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/it_behaves_like.rb
deleted file mode 100644
index 8ed681ff21ad8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/it_behaves_like.rb
+++ /dev/null
@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that only one `it_behaves_like` style is used.
-      #
-      # @example `EnforcedStyle: it_behaves_like` (default)
-      #   # bad
-      #   it_should_behave_like 'a foo'
-      #
-      #   # good
-      #   it_behaves_like 'a foo'
-      #
-      # @example `EnforcedStyle: it_should_behave_like`
-      #   # bad
-      #   it_behaves_like 'a foo'
-      #
-      #   # good
-      #   it_should_behave_like 'a foo'
-      class ItBehavesLike < Base
-        extend AutoCorrector
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Prefer `%<replacement>s` over `%<original>s` when including ' \
-              'examples in a nested context.'
-        RESTRICT_ON_SEND = %i[it_behaves_like it_should_behave_like].freeze
-
-        # @!method example_inclusion_offense(node)
-        def_node_matcher :example_inclusion_offense, '(send _ % ...)'
-
-        def on_send(node)
-          example_inclusion_offense(node, alternative_style) do
-            add_offense(node) do |corrector|
-              corrector.replace(node.loc.selector, style.to_s)
-            end
-          end
-        end
-
-        private
-
-        def message(_node)
-          format(MSG, replacement: style, original: alternative_style)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/iterated_expectation.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/iterated_expectation.rb
deleted file mode 100644
index 58bef7acd6bb7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/iterated_expectation.rb
+++ /dev/null
@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check that `all` matcher is used instead of iterating over an array.
-      #
-      # @example
-      #   # bad
-      #   it 'validates users' do
-      #     [user1, user2, user3].each { |user| expect(user).to be_valid }
-      #   end
-      #
-      #   # good
-      #   it 'validates users' do
-      #     expect([user1, user2, user3]).to all(be_valid)
-      #   end
-      class IteratedExpectation < Base
-        MSG = 'Prefer using the `all` matcher instead ' \
-              'of iterating over an array.'
-
-        # @!method each?(node)
-        def_node_matcher :each?, <<-PATTERN
-          (block
-            (send ... :each)
-            (args (arg $_))
-            $(...)
-          )
-        PATTERN
-
-        # @!method expectation?(node)
-        def_node_matcher :expectation?, <<-PATTERN
-          (send (send nil? :expect (lvar %)) :to ...)
-        PATTERN
-
-        def on_block(node)
-          each?(node) do |arg, body|
-            if single_expectation?(body, arg) || only_expectations?(body, arg)
-              add_offense(node.send_node)
-            end
-          end
-        end
-
-        private
-
-        def single_expectation?(body, arg)
-          expectation?(body, arg)
-        end
-
-        def only_expectations?(body, arg)
-          return false unless body.each_child_node.any?
-
-          body.each_child_node.all? { |child| expectation?(child, arg) }
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leading_subject.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leading_subject.rb
deleted file mode 100644
index c1ceb28770d21..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leading_subject.rb
+++ /dev/null
@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Enforce that subject is the first definition in the test.
-      #
-      # @example
-      #   # bad
-      #     let(:params) { blah }
-      #     subject { described_class.new(params) }
-      #
-      #     before { do_something }
-      #     subject { described_class.new(params) }
-      #
-      #     it { expect_something }
-      #     subject { described_class.new(params) }
-      #     it { expect_something_else }
-      #
-      #
-      #   # good
-      #     subject { described_class.new(params) }
-      #     let(:params) { blah }
-      #
-      #   # good
-      #     subject { described_class.new(params) }
-      #     before { do_something }
-      #
-      #   # good
-      #     subject { described_class.new(params) }
-      #     it { expect_something }
-      #     it { expect_something_else }
-      #
-      class LeadingSubject < Base
-        extend AutoCorrector
-        include InsideExampleGroup
-
-        MSG = 'Declare `subject` above any other `%<offending>s` declarations.'
-
-        def on_block(node)
-          return unless subject?(node)
-          return unless inside_example_group?(node)
-
-          check_previous_nodes(node)
-        end
-
-        def check_previous_nodes(node)
-          offending_node(node) do |offender|
-            msg = format(MSG, offending: offender.method_name)
-            add_offense(node, message: msg) do |corrector|
-              autocorrect(corrector, node, offender)
-            end
-          end
-        end
-
-        private
-
-        def offending_node(node)
-          parent(node).each_child_node.find do |sibling|
-            break if sibling.equal?(node)
-
-            yield sibling if offending?(sibling)
-          end
-        end
-
-        def parent(node)
-          node.each_ancestor(:block).first.body
-        end
-
-        def autocorrect(corrector, node, sibling)
-          RuboCop::RSpec::Corrector::MoveNode.new(
-            node, corrector, processed_source
-          ).move_before(sibling)
-        end
-
-        def offending?(node)
-          let?(node) ||
-            hook?(node) ||
-            example?(node) ||
-            spec_group?(node) ||
-            include?(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leaky_constant_declaration.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leaky_constant_declaration.rb
deleted file mode 100644
index da1288a6de56a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leaky_constant_declaration.rb
+++ /dev/null
@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that no class, module, or constant is declared.
-      #
-      # Constants, including classes and modules, when declared in a block
-      # scope, are defined in global namespace, and leak between examples.
-      #
-      # If several examples may define a `DummyClass`, instead of being a
-      # blank slate class as it will be in the first example, subsequent
-      # examples will be reopening it and modifying its behavior in
-      # unpredictable ways.
-      # Even worse when a class that exists in the codebase is reopened.
-      #
-      # Anonymous classes are fine, since they don't result in global
-      # namespace name clashes.
-      #
-      # @see https://relishapp.com/rspec/rspec-mocks/docs/mutating-constants
-      #
-      # @example Constants leak between examples
-      #   # bad
-      #   describe SomeClass do
-      #     OtherClass = Struct.new
-      #     CONSTANT_HERE = 'I leak into global namespace'
-      #   end
-      #
-      #   # good
-      #   describe SomeClass do
-      #     before do
-      #       stub_const('OtherClass', Struct.new)
-      #       stub_const('CONSTANT_HERE', 'I only exist during this example')
-      #     end
-      #   end
-      #
-      # @example
-      #   # bad
-      #   describe SomeClass do
-      #     class FooClass < described_class
-      #       def double_that
-      #         some_base_method * 2
-      #       end
-      #     end
-      #
-      #     it { expect(FooClass.new.double_that).to eq(4) }
-      #   end
-      #
-      #   # good - anonymous class, no constant needs to be defined
-      #   describe SomeClass do
-      #     let(:foo_class) do
-      #       Class.new(described_class) do
-      #         def double_that
-      #           some_base_method * 2
-      #         end
-      #       end
-      #     end
-      #
-      #     it { expect(foo_class.new.double_that).to eq(4) }
-      #   end
-      #
-      #   # good - constant is stubbed
-      #   describe SomeClass do
-      #     before do
-      #       foo_class = Class.new(described_class) do
-      #                     def do_something
-      #                     end
-      #                   end
-      #       stub_const('FooClass', foo_class)
-      #     end
-      #
-      #     it { expect(FooClass.new.double_that).to eq(4) }
-      #   end
-      #
-      # @example
-      #   # bad
-      #   describe SomeClass do
-      #     module SomeModule
-      #       class SomeClass
-      #         def do_something
-      #         end
-      #       end
-      #     end
-      #   end
-      #
-      #   # good
-      #   describe SomeClass do
-      #     before do
-      #       foo_class = Class.new(described_class) do
-      #                     def do_something
-      #                     end
-      #                   end
-      #       stub_const('SomeModule::SomeClass', foo_class)
-      #     end
-      #   end
-      class LeakyConstantDeclaration < Base
-        MSG_CONST = 'Stub constant instead of declaring explicitly.'
-        MSG_CLASS = 'Stub class constant instead of declaring explicitly.'
-        MSG_MODULE = 'Stub module constant instead of declaring explicitly.'
-
-        def on_casgn(node)
-          return unless inside_describe_block?(node)
-
-          add_offense(node, message: MSG_CONST)
-        end
-
-        def on_class(node)
-          return unless inside_describe_block?(node)
-
-          add_offense(node, message: MSG_CLASS)
-        end
-
-        def on_module(node)
-          return unless inside_describe_block?(node)
-
-          add_offense(node, message: MSG_MODULE)
-        end
-
-        private
-
-        def inside_describe_block?(node)
-          node.each_ancestor(:block).any?(&method(:spec_group?))
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_before_examples.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_before_examples.rb
deleted file mode 100644
index 3df02cc57cc3f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_before_examples.rb
+++ /dev/null
@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for `let` definitions that come after an example.
-      #
-      # @example
-      #   # Bad
-      #   let(:foo) { bar }
-      #
-      #   it 'checks what foo does' do
-      #     expect(foo).to be
-      #   end
-      #
-      #   let(:some) { other }
-      #
-      #   it 'checks what some does' do
-      #     expect(some).to be
-      #   end
-      #
-      #   # Good
-      #   let(:foo) { bar }
-      #   let(:some) { other }
-      #
-      #   it 'checks what foo does' do
-      #     expect(foo).to be
-      #   end
-      #
-      #   it 'checks what some does' do
-      #     expect(some).to be
-      #   end
-      class LetBeforeExamples < Base
-        extend AutoCorrector
-
-        MSG = 'Move `let` before the examples in the group.'
-
-        # @!method example_or_group?(node)
-        def_node_matcher :example_or_group?, <<-PATTERN
-          {
-            #{block_pattern('{#ExampleGroups.all #Examples.all}')}
-            #{send_pattern('#Includes.examples')}
-          }
-        PATTERN
-
-        def on_block(node)
-          return unless example_group_with_body?(node)
-
-          check_let_declarations(node.body) if multiline_block?(node.body)
-        end
-
-        private
-
-        def multiline_block?(block)
-          block.begin_type?
-        end
-
-        def check_let_declarations(node)
-          first_example = find_first_example(node)
-          return unless first_example
-
-          node.each_child_node do |child|
-            next if child.sibling_index < first_example.sibling_index
-            next unless let?(child)
-
-            add_offense(child) do |corrector|
-              autocorrect(corrector, child, first_example)
-            end
-          end
-        end
-
-        def find_first_example(node)
-          node.children.find { |sibling| example_or_group?(sibling) }
-        end
-
-        def autocorrect(corrector, node, first_example)
-          RuboCop::RSpec::Corrector::MoveNode.new(
-            node, corrector, processed_source
-          ).move_before(first_example)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_setup.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_setup.rb
deleted file mode 100644
index 482e4de589ab2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_setup.rb
+++ /dev/null
@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks unreferenced `let!` calls being used for test setup.
-      #
-      # @example
-      #   # Bad
-      #   let!(:my_widget) { create(:widget) }
-      #
-      #   it 'counts widgets' do
-      #     expect(Widget.count).to eq(1)
-      #   end
-      #
-      #   # Good
-      #   it 'counts widgets' do
-      #     create(:widget)
-      #     expect(Widget.count).to eq(1)
-      #   end
-      #
-      #   # Good
-      #   before { create(:widget) }
-      #
-      #   it 'counts widgets' do
-      #     expect(Widget.count).to eq(1)
-      #   end
-      class LetSetup < Base
-        MSG = 'Do not use `let!` to setup objects not referenced in tests.'
-
-        # @!method example_or_shared_group_or_including?(node)
-        def_node_matcher :example_or_shared_group_or_including?,
-                         block_pattern(<<~PATTERN)
-                           {
-                             #SharedGroups.all
-                             #ExampleGroups.all
-                             #Includes.all
-                           }
-                         PATTERN
-
-        # @!method let_bang(node)
-        def_node_matcher :let_bang, <<-PATTERN
-          {
-            (block $(send nil? :let! {(sym $_) (str $_)}) ...)
-            $(send nil? :let! {(sym $_) (str $_)} block_pass)
-          }
-        PATTERN
-
-        # @!method method_called?(node)
-        def_node_search :method_called?, '(send nil? %)'
-
-        def on_block(node)
-          return unless example_or_shared_group_or_including?(node)
-
-          unused_let_bang(node) do |let|
-            add_offense(let)
-          end
-        end
-
-        private
-
-        def unused_let_bang(node)
-          child_let_bang(node) do |method_send, method_name|
-            yield(method_send) unless method_called?(node, method_name.to_sym)
-          end
-        end
-
-        def child_let_bang(node, &block)
-          RuboCop::RSpec::ExampleGroup.new(node).lets.each do |let|
-            let_bang(let, &block)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_chain.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_chain.rb
deleted file mode 100644
index fc3593cad2b7a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_chain.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check that chains of messages are not being stubbed.
-      #
-      # @example
-      #   # bad
-      #   allow(foo).to receive_message_chain(:bar, :baz).and_return(42)
-      #
-      #   # better
-      #   thing = Thing.new(baz: 42)
-      #   allow(foo).to receive(:bar).and_return(thing)
-      #
-      class MessageChain < Base
-        MSG = 'Avoid stubbing using `%<method>s`.'
-        RESTRICT_ON_SEND = %i[receive_message_chain stub_chain].freeze
-
-        def on_send(node)
-          add_offense(
-            node.loc.selector, message: format(MSG, method: node.method_name)
-          )
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_expectation.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_expectation.rb
deleted file mode 100644
index b625b592f44aa..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_expectation.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for consistent message expectation style.
-      #
-      # This cop can be configured in your configuration using the
-      # `EnforcedStyle` option and supports `--auto-gen-config`.
-      #
-      # @example `EnforcedStyle: allow` (default)
-      #
-      #   # bad
-      #   expect(foo).to receive(:bar)
-      #
-      #   # good
-      #   allow(foo).to receive(:bar)
-      #
-      # @example `EnforcedStyle: expect`
-      #
-      #   # bad
-      #   allow(foo).to receive(:bar)
-      #
-      #   # good
-      #   expect(foo).to receive(:bar)
-      #
-      class MessageExpectation < Base
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Prefer `%<style>s` for setting message expectations.'
-
-        SUPPORTED_STYLES = %w[allow expect].freeze
-        RESTRICT_ON_SEND = %i[to].freeze
-
-        # @!method message_expectation(node)
-        def_node_matcher :message_expectation, <<-PATTERN
-          (send $(send nil? {:expect :allow} ...) :to #receive_message?)
-        PATTERN
-
-        # @!method receive_message?(node)
-        def_node_search :receive_message?, '(send nil? :receive ...)'
-
-        def on_send(node)
-          message_expectation(node) do |match|
-            return correct_style_detected if preferred_style?(match)
-
-            message = format(MSG, style: style)
-            add_offense(match.loc.selector, message: message) do
-              opposite_style_detected
-            end
-          end
-        end
-
-        private
-
-        def preferred_style?(expectation)
-          expectation.method_name.equal?(style)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_spies.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_spies.rb
deleted file mode 100644
index 8902b9093a396..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_spies.rb
+++ /dev/null
@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that message expectations are set using spies.
-      #
-      # This cop can be configured in your configuration using the
-      # `EnforcedStyle` option and supports `--auto-gen-config`.
-      #
-      # @example `EnforcedStyle: have_received` (default)
-      #
-      #   # bad
-      #   expect(foo).to receive(:bar)
-      #   do_something
-      #
-      #   # good
-      #   allow(foo).to receive(:bar) # or use instance_spy
-      #   do_something
-      #   expect(foo).to have_received(:bar)
-      #
-      # @example `EnforcedStyle: receive`
-      #
-      #   # bad
-      #   allow(foo).to receive(:bar)
-      #   do_something
-      #   expect(foo).to have_received(:bar)
-      #
-      #   # good
-      #   expect(foo).to receive(:bar)
-      #   do_something
-      #
-      class MessageSpies < Base
-        include ConfigurableEnforcedStyle
-
-        MSG_RECEIVE = 'Prefer `receive` for setting message expectations.'
-
-        MSG_HAVE_RECEIVED = 'Prefer `have_received` for setting message ' \
-                            'expectations. Setup `%<source>s` as a spy using ' \
-                            '`allow` or `instance_spy`.'
-
-        SUPPORTED_STYLES = %w[have_received receive].freeze
-
-        # @!method message_expectation(node)
-        def_node_matcher :message_expectation, %(
-          (send (send nil? :expect $_) #Runners.all ...)
-        )
-
-        # @!method receive_message(node)
-        def_node_search :receive_message, %(
-          $(send nil? {:receive :have_received} ...)
-        )
-
-        def on_send(node)
-          receive_message_matcher(node) do |receiver, message_matcher|
-            return correct_style_detected if preferred_style?(message_matcher)
-
-            add_offense(
-              message_matcher.loc.selector,
-              message: error_message(receiver)
-            ) { opposite_style_detected }
-          end
-        end
-
-        private
-
-        def receive_message_matcher(node)
-          return unless (receiver = message_expectation(node))
-
-          receive_message(node) { |match| yield(receiver, match) }
-        end
-
-        def preferred_style?(expectation)
-          expectation.method_name.equal?(style)
-        end
-
-        def error_message(receiver)
-          case style
-          when :receive
-            MSG_RECEIVE
-          when :have_received
-            format(MSG_HAVE_RECEIVED, source: receiver.source)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/missing_example_group_argument.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/missing_example_group_argument.rb
deleted file mode 100644
index a29df6f591c27..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/missing_example_group_argument.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that the first argument to an example group is not empty.
-      #
-      # @example
-      #   # bad
-      #   describe do
-      #   end
-      #
-      #   RSpec.describe do
-      #   end
-      #
-      #   # good
-      #   describe TestedClass do
-      #   end
-      #
-      #   describe "A feature example" do
-      #   end
-      class MissingExampleGroupArgument < Base
-        MSG = 'The first argument to `%<method>s` should not be empty.'
-
-        def on_block(node)
-          return unless example_group?(node)
-          return if node.send_node.arguments?
-
-          add_offense(node, message: format(MSG, method: node.method_name))
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/comments_help.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/comments_help.rb
deleted file mode 100644
index 297d0501eef7d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/comments_help.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Help methods for working with nodes containing comments.
-      module CommentsHelp
-        include FinalEndLocation
-
-        def source_range_with_comment(node)
-          begin_pos = begin_pos_with_comment(node).begin_pos
-          end_pos = end_line_position(node).end_pos
-
-          Parser::Source::Range.new(buffer, begin_pos, end_pos)
-        end
-
-        def begin_pos_with_comment(node)
-          first_comment = processed_source.ast_with_comments[node].first
-
-          start_line_position(first_comment || node)
-        end
-
-        def start_line_position(node)
-          buffer.line_range(node.loc.line)
-        end
-
-        def end_line_position(node)
-          end_line = buffer.line_for_position(final_end_location(node).end_pos)
-          buffer.line_range(end_line)
-        end
-
-        def buffer
-          processed_source.buffer
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/empty_line_separation.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/empty_line_separation.rb
deleted file mode 100644
index d22284fa8d2e5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/empty_line_separation.rb
+++ /dev/null
@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Helps determine the offending location if there is not an empty line
-      # following the node. Allows comments to follow directly after
-      # in the following cases.
-      # - `rubocop:enable` directive
-      # - followed by empty line(s)
-      module EmptyLineSeparation
-        include FinalEndLocation
-        include RangeHelp
-
-        def missing_separating_line_offense(node)
-          return if last_child?(node)
-
-          missing_separating_line(node) do |location|
-            msg = yield(node.method_name)
-            add_offense(location, message: msg) do |corrector|
-              corrector.insert_after(location.end, "\n")
-            end
-          end
-        end
-
-        def missing_separating_line(node)
-          line = final_end_line = final_end_location(node).line
-
-          while comment_line?(processed_source[line])
-            line += 1
-            comment = processed_source.comment_at_line(line)
-            if DirectiveComment.new(comment).enabled?
-              enable_directive_line = line
-            end
-          end
-
-          return if processed_source[line].blank?
-
-          yield offending_loc(enable_directive_line || final_end_line)
-        end
-
-        def offending_loc(last_line)
-          offending_line = processed_source[last_line - 1]
-
-          content_length = offending_line.lstrip.length
-          start          = offending_line.length - content_length
-
-          source_range(processed_source.buffer,
-                       last_line, start, content_length)
-        end
-
-        def last_child?(node)
-          return true unless node.parent&.begin_type?
-
-          node.equal?(node.parent.children.last)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/final_end_location.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/final_end_location.rb
deleted file mode 100644
index 526049f5df39a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/final_end_location.rb
+++ /dev/null
@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Helps find the true end location of nodes which might contain heredocs.
-      module FinalEndLocation
-        def final_end_location(start_node)
-          heredoc_endings =
-            start_node.each_node(:str, :dstr, :xstr)
-              .select(&:heredoc?)
-              .map { |node| node.loc.heredoc_end }
-
-          [start_node.loc.end, *heredoc_endings].max_by(&:line)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/inside_example_group.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/inside_example_group.rb
deleted file mode 100644
index ffd3958ddf601..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/inside_example_group.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Helps you identify whether a given node
-      # is within an example group or not.
-      module InsideExampleGroup
-        private
-
-        def inside_example_group?(node)
-          return spec_group?(node) if example_group_root?(node)
-
-          root = node.ancestors.find { |parent| example_group_root?(parent) }
-
-          spec_group?(root)
-        end
-
-        def example_group_root?(node)
-          node.parent.nil? || example_group_root_with_siblings?(node.parent)
-        end
-
-        def example_group_root_with_siblings?(node)
-          node.begin_type? && node.parent.nil?
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/top_level_group.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/top_level_group.rb
deleted file mode 100644
index c3b48fb1d9579..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/top_level_group.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Helper methods for top level example group cops
-      module TopLevelGroup
-        extend RuboCop::NodePattern::Macros
-
-        def on_new_investigation
-          super
-
-          top_level_groups.each do |node|
-            on_top_level_example_group(node) if example_group?(node)
-            on_top_level_group(node)
-          end
-        end
-
-        def top_level_groups
-          @top_level_groups ||=
-            top_level_nodes(root_node).select { |n| spec_group?(n) }
-        end
-
-        private
-
-        # Dummy methods to be overridden in the consumer
-        def on_top_level_example_group(_node); end
-
-        def on_top_level_group(_node); end
-
-        def top_level_group?(node)
-          top_level_groups.include?(node)
-        end
-
-        def top_level_nodes(node)
-          return [] if node.nil?
-
-          case node.type
-          when :begin
-            node.children
-          when :module, :class
-            top_level_nodes(node.body)
-          else
-            [node]
-          end
-        end
-
-        def root_node
-          processed_source.ast
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/variable.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/variable.rb
deleted file mode 100644
index e469cd335aa83..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/variable.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Helps check offenses with variable definitions
-      module Variable
-        extend RuboCop::NodePattern::Macros
-
-        Subjects = RuboCop::RSpec::Language::Subjects
-        Helpers = RuboCop::RSpec::Language::Helpers
-
-        # @!method variable_definition?(node)
-        def_node_matcher :variable_definition?, <<~PATTERN
-          (send nil? {#Subjects.all #Helpers.all}
-            $({sym str dsym dstr} ...) ...)
-        PATTERN
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_describes.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_describes.rb
deleted file mode 100644
index 20662eeba7781..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_describes.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for multiple top-level example groups.
-      #
-      # Multiple descriptions for the same class or module should either
-      # be nested or separated into different test files.
-      #
-      # @example
-      #   # bad
-      #   describe MyClass, '.do_something' do
-      #   end
-      #   describe MyClass, '.do_something_else' do
-      #   end
-      #
-      #   # good
-      #   describe MyClass do
-      #     describe '.do_something' do
-      #     end
-      #     describe '.do_something_else' do
-      #     end
-      #   end
-      class MultipleDescribes < Base
-        include TopLevelGroup
-
-        MSG = 'Do not use multiple top-level example groups - try to nest them.'
-
-        def on_top_level_group(node)
-          top_level_example_groups =
-            top_level_groups.select(&method(:example_group?))
-
-          return if top_level_example_groups.one?
-          return unless top_level_example_groups.first.equal?(node)
-
-          add_offense(node.send_node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb
deleted file mode 100644
index 33df173fd6ee6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb
+++ /dev/null
@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks if examples contain too many `expect` calls.
-      #
-      # @see http://betterspecs.org/#single Single expectation test
-      #
-      # This cop is configurable using the `Max` option
-      # and works with `--auto-gen-config`.
-      #
-      # @example
-      #
-      #   # bad
-      #   describe UserCreator do
-      #     it 'builds a user' do
-      #       expect(user.name).to eq("John")
-      #       expect(user.age).to eq(22)
-      #     end
-      #   end
-      #
-      #   # good
-      #   describe UserCreator do
-      #     it 'sets the users name' do
-      #       expect(user.name).to eq("John")
-      #     end
-      #
-      #     it 'sets the users age' do
-      #       expect(user.age).to eq(22)
-      #     end
-      #   end
-      #
-      # @example `aggregate_failures: true` (default)
-      #
-      #  # good - the cop ignores when RSpec aggregates failures
-      #   describe UserCreator do
-      #     it 'builds a user', :aggregate_failures do
-      #       expect(user.name).to eq("John")
-      #       expect(user.age).to eq(22)
-      #     end
-      #   end
-      #
-      # @example `aggregate_failures: false`
-      #
-      #  # Detected as an offense
-      #   describe UserCreator do
-      #     it 'builds a user', aggregate_failures: false do
-      #       expect(user.name).to eq("John")
-      #       expect(user.age).to eq(22)
-      #     end
-      #   end
-      #
-      # @example configuration
-      #
-      #   # .rubocop.yml
-      #   # RSpec/MultipleExpectations:
-      #   #   Max: 2
-      #
-      #   # not flagged by rubocop
-      #   describe UserCreator do
-      #     it 'builds a user' do
-      #       expect(user.name).to eq("John")
-      #       expect(user.age).to eq(22)
-      #     end
-      #   end
-      #
-      class MultipleExpectations < Base
-        include ConfigurableMax
-
-        MSG = 'Example has too many expectations [%<total>d/%<max>d].'
-
-        ANYTHING = ->(_node) { true }
-        TRUE = ->(node) { node.true_type? }
-
-        # @!method aggregate_failures?(node)
-        def_node_matcher :aggregate_failures?, <<-PATTERN
-          (block {
-              (send _ _ <(sym :aggregate_failures) ...>)
-              (send _ _ ... (hash <(pair (sym :aggregate_failures) %1) ...>))
-            } ...)
-        PATTERN
-
-        # @!method expect?(node)
-        def_node_matcher :expect?, send_pattern('#Expectations.all')
-        # @!method aggregate_failures_block?(node)
-        def_node_matcher :aggregate_failures_block?, <<-PATTERN
-          (block (send nil? :aggregate_failures ...) ...)
-        PATTERN
-
-        def on_block(node)
-          return unless example?(node)
-
-          return if example_with_aggregate_failures?(node)
-
-          expectations_count = to_enum(:find_expectation, node).count
-
-          return if expectations_count <= max_expectations
-
-          self.max = expectations_count
-
-          flag_example(node, expectation_count: expectations_count)
-        end
-
-        private
-
-        def example_with_aggregate_failures?(example_node)
-          node_with_aggregate_failures = find_aggregate_failures(example_node)
-          return false unless node_with_aggregate_failures
-
-          aggregate_failures?(node_with_aggregate_failures, TRUE)
-        end
-
-        def find_aggregate_failures(example_node)
-          example_node.send_node.each_ancestor(:block)
-            .find { |block_node| aggregate_failures?(block_node, ANYTHING) }
-        end
-
-        def find_expectation(node, &block)
-          yield if expect?(node) || aggregate_failures_block?(node)
-
-          # do not search inside of aggregate_failures block
-          return if aggregate_failures_block?(node)
-
-          node.each_child_node do |child|
-            find_expectation(child, &block)
-          end
-        end
-
-        def flag_example(node, expectation_count:)
-          add_offense(
-            node.send_node,
-            message: format(
-              MSG,
-              total: expectation_count,
-              max: max_expectations
-            )
-          )
-        end
-
-        def max_expectations
-          Integer(cop_config.fetch('Max', 1))
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb
deleted file mode 100644
index 674b383b93b83..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb
+++ /dev/null
@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks if example groups contain too many `let` and `subject` calls.
-      #
-      # This cop is configurable using the `Max` option and the `AllowSubject`
-      # which will configure the cop to only register offenses on calls to
-      # `let` and not calls to `subject`.
-      #
-      # @example
-      #   # bad
-      #   describe MyClass do
-      #     let(:foo) { [] }
-      #     let(:bar) { [] }
-      #     let!(:baz) { [] }
-      #     let(:qux) { [] }
-      #     let(:quux) { [] }
-      #     let(:quuz) { {} }
-      #   end
-      #
-      #   describe MyClass do
-      #     let(:foo) { [] }
-      #     let(:bar) { [] }
-      #     let!(:baz) { [] }
-      #
-      #     context 'when stuff' do
-      #       let(:qux) { [] }
-      #       let(:quux) { [] }
-      #       let(:quuz) { {} }
-      #     end
-      #   end
-      #
-      #   # good
-      #   describe MyClass do
-      #     let(:bar) { [] }
-      #     let!(:baz) { [] }
-      #     let(:qux) { [] }
-      #     let(:quux) { [] }
-      #     let(:quuz) { {} }
-      #   end
-      #
-      #   describe MyClass do
-      #     context 'when stuff' do
-      #       let(:foo) { [] }
-      #       let(:bar) { [] }
-      #       let!(:booger) { [] }
-      #     end
-      #
-      #     context 'when other stuff' do
-      #       let(:qux) { [] }
-      #       let(:quux) { [] }
-      #       let(:quuz) { {} }
-      #     end
-      #   end
-      #
-      # @example when disabling AllowSubject configuration
-      #
-      #   # rubocop.yml
-      #   # RSpec/MultipleMemoizedHelpers:
-      #   #   AllowSubject: false
-      #
-      #   # bad - `subject` counts towards memoized helpers
-      #   describe MyClass do
-      #     subject { {} }
-      #     let(:foo) { [] }
-      #     let(:bar) { [] }
-      #     let!(:baz) { [] }
-      #     let(:qux) { [] }
-      #     let(:quux) { [] }
-      #   end
-      #
-      # @example with Max configuration
-      #
-      #   # rubocop.yml
-      #   # RSpec/MultipleMemoizedHelpers:
-      #   #   Max: 1
-      #
-      #   # bad
-      #   describe MyClass do
-      #     let(:foo) { [] }
-      #     let(:bar) { [] }
-      #   end
-      #
-      class MultipleMemoizedHelpers < Base
-        include ConfigurableMax
-        include Variable
-
-        MSG = 'Example group has too many memoized helpers [%<count>d/%<max>d]'
-
-        def on_block(node)
-          return unless spec_group?(node)
-
-          count = all_helpers(node).uniq.count
-
-          return if count <= max
-
-          self.max = count
-          add_offense(node, message: format(MSG, count: count, max: max))
-        end
-
-        def on_new_investigation
-          super
-          @example_group_memoized_helpers = {}
-        end
-
-        private
-
-        attr_reader :example_group_memoized_helpers
-
-        def all_helpers(node)
-          [
-            *helpers(node),
-            *node.each_ancestor(:block).flat_map(&method(:helpers))
-          ]
-        end
-
-        def helpers(node)
-          @example_group_memoized_helpers[node] ||=
-            variable_nodes(node).map do |variable_node|
-              if variable_node.block_type?
-                variable_definition?(variable_node.send_node)
-              else # block-pass (`let(:foo, &bar)`)
-                variable_definition?(variable_node)
-              end
-            end
-        end
-
-        def variable_nodes(node)
-          example_group = RuboCop::RSpec::ExampleGroup.new(node)
-
-          if allow_subject?
-            example_group.lets
-          else
-            example_group.lets + example_group.subjects
-          end
-        end
-
-        def max
-          cop_config['Max']
-        end
-
-        def allow_subject?
-          cop_config['AllowSubject']
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_subjects.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_subjects.rb
deleted file mode 100644
index 1667748a85eed..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_subjects.rb
+++ /dev/null
@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks if an example group defines `subject` multiple times.
-      #
-      # @example
-      #
-      #   # bad
-      #   describe Foo do
-      #     subject(:user) { User.new }
-      #     subject(:post) { Post.new }
-      #   end
-      #
-      #   # good
-      #   describe Foo do
-      #     let(:user) { User.new }
-      #     subject(:post) { Post.new }
-      #   end
-      #
-      # The autocorrect behavior for this cop depends on the type of
-      # duplication:
-      #
-      #   - If multiple named subjects are defined then this probably indicates
-      #     that the overwritten subjects (all subjects except the last
-      #     definition) are effectively being used to define helpers. In this
-      #     case they are replaced with `let`.
-      #
-      #   - If multiple unnamed subjects are defined though then this can *only*
-      #     be dead code and we remove the overwritten subject definitions.
-      #
-      #   - If subjects are defined with `subject!` then we don't autocorrect.
-      #     This is enough of an edge case that people can just move this to
-      #     a `before` hook on their own
-      class MultipleSubjects < Base
-        extend AutoCorrector
-        include RangeHelp
-
-        MSG = 'Do not set more than one subject per example group'
-
-        def on_block(node)
-          return unless example_group?(node)
-
-          subjects = RuboCop::RSpec::ExampleGroup.new(node).subjects
-
-          subjects[0...-1].each do |subject|
-            add_offense(subject) do |corrector|
-              autocorrect(corrector, subject)
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, subject)
-          return unless subject.method_name.equal?(:subject) # Ignore `subject!`
-
-          if named_subject?(subject)
-            rename_autocorrect(corrector, subject)
-          else
-            remove_autocorrect(corrector, subject)
-          end
-        end
-
-        def named_subject?(node)
-          node.send_node.arguments?
-        end
-
-        def rename_autocorrect(corrector, node)
-          corrector.replace(node.send_node.loc.selector, 'let')
-        end
-
-        def remove_autocorrect(corrector, node)
-          range = range_by_whole_lines(node.source_range,
-                                       include_final_newline: true)
-          corrector.remove(range)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/named_subject.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/named_subject.rb
deleted file mode 100644
index 1f18855237ceb..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/named_subject.rb
+++ /dev/null
@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for explicitly referenced test subjects.
-      #
-      # RSpec lets you declare an "implicit subject" using `subject { ... }`
-      # which allows for tests like `it { is_expected.to be_valid }`.
-      # If you need to reference your test subject you should explicitly
-      # name it using `subject(:your_subject_name) { ... }`. Your test subjects
-      # should be the most important object in your tests so they deserve
-      # a descriptive name.
-      #
-      # This cop can be configured in your configuration using the
-      # `IgnoreSharedExamples` which will not report offenses for implicit
-      # subjects in shared example groups.
-      #
-      # @example
-      #   # bad
-      #   RSpec.describe User do
-      #     subject { described_class.new }
-      #
-      #     it 'is valid' do
-      #       expect(subject.valid?).to be(true)
-      #     end
-      #   end
-      #
-      #   # good
-      #   RSpec.describe Foo do
-      #     subject(:user) { described_class.new }
-      #
-      #     it 'is valid' do
-      #       expect(user.valid?).to be(true)
-      #     end
-      #   end
-      #
-      #   # also good
-      #   RSpec.describe Foo do
-      #     subject(:user) { described_class.new }
-      #
-      #     it { is_expected.to be_valid }
-      #   end
-      class NamedSubject < Base
-        MSG = 'Name your test subject if you need to reference it explicitly.'
-
-        # @!method example_or_hook_block?(node)
-        def_node_matcher :example_or_hook_block?,
-                         block_pattern('{#Examples.all #Hooks.all}')
-
-        # @!method shared_example?(node)
-        def_node_matcher :shared_example?,
-                         block_pattern('#SharedGroups.examples')
-
-        # @!method subject_usage(node)
-        def_node_search :subject_usage, '$(send nil? :subject)'
-
-        def on_block(node)
-          if !example_or_hook_block?(node) || ignored_shared_example?(node)
-            return
-          end
-
-          subject_usage(node) do |subject_node|
-            add_offense(subject_node.loc.selector)
-          end
-        end
-
-        def ignored_shared_example?(node)
-          cop_config['IgnoreSharedExamples'] &&
-            node.each_ancestor(:block).any?(&method(:shared_example?))
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/nested_groups.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/nested_groups.rb
deleted file mode 100644
index 53c60ffe64cd2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/nested_groups.rb
+++ /dev/null
@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for nested example groups.
-      #
-      # This cop is configurable using the `Max` option
-      # and supports `--auto-gen-config`.
-      #
-      # @example
-      #   # bad
-      #   context 'when using some feature' do
-      #     let(:some)    { :various }
-      #     let(:feature) { :setup   }
-      #
-      #     context 'when user is signed in' do  # flagged by rubocop
-      #       let(:user) do
-      #         UserCreate.call(user_attributes)
-      #       end
-      #
-      #       let(:user_attributes) do
-      #         {
-      #           name: 'John',
-      #           age:  22,
-      #           role: role
-      #         }
-      #       end
-      #
-      #       context 'when user is an admin' do # flagged by rubocop
-      #         let(:role) { 'admin' }
-      #
-      #         it 'blah blah'
-      #         it 'yada yada'
-      #       end
-      #     end
-      #   end
-      #
-      #   # better
-      #   context 'using some feature as an admin' do
-      #     let(:some)    { :various }
-      #     let(:feature) { :setup   }
-      #
-      #     let(:user) do
-      #       UserCreate.call(
-      #         name: 'John',
-      #         age:  22,
-      #         role: 'admin'
-      #       )
-      #     end
-      #
-      #     it 'blah blah'
-      #     it 'yada yada'
-      #   end
-      #
-      # @example configuration
-      #
-      #   # .rubocop.yml
-      #   # RSpec/NestedGroups:
-      #   #   Max: 2
-      #
-      #   context 'when using some feature' do
-      #     let(:some)    { :various }
-      #     let(:feature) { :setup   }
-      #
-      #     context 'when user is signed in' do
-      #       let(:user) do
-      #         UserCreate.call(user_attributes)
-      #       end
-      #
-      #       let(:user_attributes) do
-      #         {
-      #           name: 'John',
-      #           age:  22,
-      #           role: role
-      #         }
-      #       end
-      #
-      #       context 'when user is an admin' do # flagged by rubocop
-      #         let(:role) { 'admin' }
-      #
-      #         it 'blah blah'
-      #         it 'yada yada'
-      #       end
-      #     end
-      #   end
-      #
-      class NestedGroups < Base
-        include ConfigurableMax
-        include TopLevelGroup
-
-        MSG = 'Maximum example group nesting exceeded [%<total>d/%<max>d].'
-
-        DEPRECATED_MAX_KEY = 'MaxNesting'
-
-        DEPRECATION_WARNING =
-          "Configuration key `#{DEPRECATED_MAX_KEY}` for #{cop_name} is " \
-          'deprecated in favor of `Max`. Please use that instead.'
-
-        def on_top_level_group(node)
-          find_nested_example_groups(node) do |example_group, nesting|
-            self.max = nesting
-            add_offense(
-              example_group.send_node,
-              message: message(nesting)
-            )
-          end
-        end
-
-        private
-
-        def find_nested_example_groups(node, nesting: 1, &block)
-          example_group = example_group?(node)
-          yield node, nesting if example_group && nesting > max_nesting
-
-          next_nesting = example_group ? nesting + 1 : nesting
-
-          node.each_child_node(:block, :begin) do |child|
-            find_nested_example_groups(child, nesting: next_nesting, &block)
-          end
-        end
-
-        def message(nesting)
-          format(MSG, total: nesting, max: max_nesting)
-        end
-
-        def max_nesting
-          @max_nesting ||= Integer(max_nesting_config)
-        end
-
-        def max_nesting_config
-          if cop_config.key?(DEPRECATED_MAX_KEY)
-            warn DEPRECATION_WARNING
-            cop_config.fetch(DEPRECATED_MAX_KEY)
-          else
-            cop_config.fetch('Max', 3)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/not_to_not.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/not_to_not.rb
deleted file mode 100644
index d79b4bd2bfd9f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/not_to_not.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for consistent method usage for negating expectations.
-      #
-      # @example `EnforcedStyle: not_to` (default)
-      #
-      #   # bad
-      #   it '...' do
-      #     expect(false).to_not be_true
-      #   end
-      #
-      #   # good
-      #   it '...' do
-      #     expect(false).not_to be_true
-      #   end
-      #
-      # @example `EnforcedStyle: to_not`
-      #
-      #   # bad
-      #   it '...' do
-      #     expect(false).not_to be_true
-      #   end
-      #
-      #   # good
-      #   it '...' do
-      #     expect(false).to_not be_true
-      #   end
-      class NotToNot < Base
-        extend AutoCorrector
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Prefer `%<replacement>s` over `%<original>s`.'
-        RESTRICT_ON_SEND = %i[not_to to_not].freeze
-
-        # @!method not_to_not_offense(node)
-        def_node_matcher :not_to_not_offense, '(send _ % ...)'
-
-        def on_send(node)
-          not_to_not_offense(node, alternative_style) do
-            add_offense(node.loc.selector) do |corrector|
-              corrector.replace(node.loc.selector, style.to_s)
-            end
-          end
-        end
-
-        private
-
-        def message(_node)
-          format(MSG, replacement: style, original: alternative_style)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/overwriting_setup.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/overwriting_setup.rb
deleted file mode 100644
index 1339755000ddc..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/overwriting_setup.rb
+++ /dev/null
@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks if there is a let/subject that overwrites an existing one.
-      #
-      # @example
-      #   # bad
-      #   let(:foo) { bar }
-      #   let(:foo) { baz }
-      #
-      #   subject(:foo) { bar }
-      #   let(:foo) { baz }
-      #
-      #   let(:foo) { bar }
-      #   let!(:foo) { baz }
-      #
-      #   # good
-      #   subject(:test) { something }
-      #   let(:foo) { bar }
-      #   let(:baz) { baz }
-      #   let!(:other) { other }
-      class OverwritingSetup < Base
-        MSG = '`%<name>s` is already defined.'
-
-        # @!method setup?(node)
-        def_node_matcher :setup?, block_pattern('{#Helpers.all #Subjects.all}')
-
-        # @!method first_argument_name(node)
-        def_node_matcher :first_argument_name, '(send _ _ ({str sym} $_))'
-
-        def on_block(node)
-          return unless example_group_with_body?(node)
-
-          find_duplicates(node.body) do |duplicate, name|
-            add_offense(
-              duplicate,
-              message: format(MSG, name: name)
-            )
-          end
-        end
-
-        private
-
-        def find_duplicates(node)
-          setup_expressions = Set.new
-          node.each_child_node(:block) do |child|
-            next unless common_setup?(child)
-
-            name = if child.send_node.arguments?
-                     first_argument_name(child.send_node).to_sym
-                   else
-                     :subject
-                   end
-
-            yield child, name unless setup_expressions.add?(name)
-          end
-        end
-
-        def common_setup?(node)
-          return false unless setup?(node)
-
-          # Search only for setup with basic_literal arguments (e.g. :sym, :str)
-          # or no arguments at all.
-          node.send_node.arguments.all?(&:basic_literal?)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/pending.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/pending.rb
deleted file mode 100644
index 5a2515560f1d8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/pending.rb
+++ /dev/null
@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for any pending or skipped examples.
-      #
-      # @example
-      #   # bad
-      #   describe MyClass do
-      #     it "should be true"
-      #   end
-      #
-      #   describe MyClass do
-      #     it "should be true", skip: true do
-      #       expect(1).to eq(2)
-      #     end
-      #   end
-      #
-      #   describe MyClass do
-      #     it "should be true" do
-      #       pending
-      #     end
-      #   end
-      #
-      #   describe MyClass do
-      #     xit "should be true" do
-      #     end
-      #   end
-      #
-      #   # good
-      #   describe MyClass do
-      #   end
-      class Pending < Base
-        MSG = 'Pending spec found.'
-
-        # @!method skippable?(node)
-        def_node_matcher :skippable?,
-                         send_pattern(<<~PATTERN)
-                           {#ExampleGroups.regular #Examples.regular}
-                         PATTERN
-
-        # @!method skipped_in_metadata?(node)
-        def_node_matcher :skipped_in_metadata?, <<-PATTERN
-          {
-            (send _ _ <#skip_or_pending? ...>)
-            (send _ _ ... (hash <(pair #skip_or_pending? { true str }) ...>))
-          }
-        PATTERN
-
-        # @!method skip_or_pending?(node)
-        def_node_matcher :skip_or_pending?, '{(sym :skip) (sym :pending)}'
-
-        # @!method pending_block?(node)
-        def_node_matcher :pending_block?,
-                         send_pattern(<<~PATTERN)
-                           {
-                             #ExampleGroups.skipped
-                             #Examples.skipped
-                             #Examples.pending
-                           }
-                         PATTERN
-
-        def on_send(node)
-          return unless pending_block?(node) || skipped?(node)
-
-          add_offense(node)
-        end
-
-        private
-
-        def skipped?(node)
-          skippable?(node) && skipped_in_metadata?(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb
deleted file mode 100644
index f29ce2d3f5be3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb
+++ /dev/null
@@ -1,325 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # A helper for `inflected` style
-      module InflectedHelper
-        include RuboCop::RSpec::Language
-        extend NodePattern::Macros
-
-        MSG_INFLECTED = 'Prefer using `%<matcher_name>s` matcher over ' \
-                        '`%<predicate_name>s`.'
-
-        private
-
-        def check_inflected(node)
-          predicate_in_actual?(node) do |predicate, to, matcher|
-            msg = message_inflected(predicate)
-            add_offense(node, message: msg) do |corrector|
-              remove_predicate(corrector, predicate)
-              corrector.replace(node.loc.selector,
-                                true?(to, matcher) ? 'to' : 'not_to')
-              rewrite_matcher(corrector, predicate, matcher)
-            end
-          end
-        end
-
-        # @!method predicate_in_actual?(node)
-        def_node_matcher :predicate_in_actual?, <<-PATTERN
-          (send
-            (send nil? :expect {
-              (block $(send !nil? #predicate? ...) ...)
-              $(send !nil? #predicate? ...)})
-            $#Runners.all
-            $#boolean_matcher?)
-        PATTERN
-
-        # @!method be_bool?(node)
-        def_node_matcher :be_bool?, <<-PATTERN
-          (send nil? {:be :eq :eql :equal} {true false})
-        PATTERN
-
-        # @!method be_boolthy?(node)
-        def_node_matcher :be_boolthy?, <<-PATTERN
-          (send nil? {:be_truthy :be_falsey :be_falsy :a_truthy_value :a_falsey_value :a_falsy_value})
-        PATTERN
-
-        def boolean_matcher?(node)
-          if cop_config['Strict']
-            be_boolthy?(node)
-          else
-            be_bool?(node) || be_boolthy?(node)
-          end
-        end
-
-        def predicate?(sym)
-          sym.to_s.end_with?('?')
-        end
-
-        def message_inflected(predicate)
-          format(MSG_INFLECTED,
-                 predicate_name: predicate.method_name,
-                 matcher_name: to_predicate_matcher(predicate.method_name))
-        end
-
-        # rubocop:disable Metrics/MethodLength
-        def to_predicate_matcher(name)
-          case name = name.to_s
-          when 'is_a?'
-            'be_a'
-          when 'instance_of?'
-            'be_an_instance_of'
-          when 'include?', 'respond_to?'
-            name[0..-2]
-          when 'exist?', 'exists?'
-            'exist'
-          when /^has_/
-            name.sub('has_', 'have_')[0..-2]
-          else
-            "be_#{name[0..-2]}"
-          end
-        end
-        # rubocop:enable Metrics/MethodLength
-
-        def remove_predicate(corrector, predicate)
-          range = predicate.loc.dot.with(
-            end_pos: predicate.loc.expression.end_pos
-          )
-
-          corrector.remove(range)
-
-          block_range = block_loc(predicate)
-          corrector.remove(block_range) if block_range
-        end
-
-        def rewrite_matcher(corrector, predicate, matcher)
-          args = args_loc(predicate).source
-          block_loc = block_loc(predicate)
-          block = block_loc ? block_loc.source : ''
-
-          corrector.replace(
-            matcher.loc.expression,
-            to_predicate_matcher(predicate.method_name) + args + block
-          )
-        end
-
-        def true?(to_symbol, matcher)
-          result = case matcher.method_name
-                   when :be, :eq
-                     matcher.first_argument.true_type?
-                   when :be_truthy, :a_truthy_value
-                     true
-                   when :be_falsey, :be_falsy, :a_falsey_value, :a_falsy_value
-                     false
-                   end
-          to_symbol == :to ? result : !result
-        end
-      end
-
-      # A helper for `explicit` style
-      module ExplicitHelper
-        include RuboCop::RSpec::Language
-        extend NodePattern::Macros
-
-        MSG_EXPLICIT = 'Prefer using `%<predicate_name>s` over ' \
-                       '`%<matcher_name>s` matcher.'
-        BUILT_IN_MATCHERS = %w[
-          be_truthy be_falsey be_falsy
-          have_attributes have_received
-          be_between be_within
-        ].freeze
-
-        private
-
-        def allowed_explicit_matchers
-          cop_config.fetch('AllowedExplicitMatchers', []) + BUILT_IN_MATCHERS
-        end
-
-        def check_explicit(node) # rubocop:disable Metrics/MethodLength
-          predicate_matcher_block?(node) do |actual, matcher|
-            add_offense(node, message: message_explicit(matcher)) do |corrector|
-              to_node = node.send_node
-              corrector_explicit(corrector, to_node, actual, matcher, to_node)
-            end
-            ignore_node(node.children.first)
-            return
-          end
-
-          return if part_of_ignored_node?(node)
-
-          predicate_matcher?(node) do |actual, matcher|
-            add_offense(node, message: message_explicit(matcher)) do |corrector|
-              corrector_explicit(corrector, node, actual, matcher, matcher)
-            end
-          end
-        end
-
-        # @!method predicate_matcher?(node)
-        def_node_matcher :predicate_matcher?, <<-PATTERN
-          (send
-            (send nil? :expect $!nil?)
-            #Runners.all
-            {$(send nil? #predicate_matcher_name? ...)
-              (block $(send nil? #predicate_matcher_name? ...) ...)})
-        PATTERN
-
-        # @!method predicate_matcher_block?(node)
-        def_node_matcher :predicate_matcher_block?, <<-PATTERN
-          (block
-            (send
-              (send nil? :expect $!nil?)
-              #Runners.all
-              $(send nil? #predicate_matcher_name?))
-            ...)
-        PATTERN
-
-        def predicate_matcher_name?(name)
-          name = name.to_s
-
-          return false if allowed_explicit_matchers.include?(name)
-
-          name.start_with?('be_', 'have_') && !name.end_with?('?')
-        end
-
-        def message_explicit(matcher)
-          format(MSG_EXPLICIT,
-                 predicate_name: to_predicate_method(matcher.method_name),
-                 matcher_name: matcher.method_name)
-        end
-
-        def corrector_explicit(corrector, to_node, actual, matcher, block_child)
-          replacement_matcher = replacement_matcher(to_node)
-          corrector.replace(matcher.loc.expression, replacement_matcher)
-          move_predicate(corrector, actual, matcher, block_child)
-          corrector.replace(to_node.loc.selector, 'to')
-        end
-
-        def move_predicate(corrector, actual, matcher, block_child)
-          predicate = to_predicate_method(matcher.method_name)
-          args = args_loc(matcher).source
-          block_loc = block_loc(block_child)
-          block = block_loc ? block_loc.source : ''
-
-          corrector.remove(block_loc) if block_loc
-          corrector.insert_after(actual.loc.expression,
-                                 ".#{predicate}" + args + block)
-        end
-
-        # rubocop:disable Metrics/MethodLength
-        def to_predicate_method(matcher)
-          case matcher = matcher.to_s
-          when 'be_a', 'be_an', 'be_a_kind_of', 'a_kind_of', 'be_kind_of'
-            'is_a?'
-          when 'be_an_instance_of', 'be_instance_of', 'an_instance_of'
-            'instance_of?'
-          when 'include'
-            'include?'
-          when 'respond_to'
-            'respond_to?'
-          when /^have_(.+)/
-            "has_#{Regexp.last_match(1)}?"
-          else
-            "#{matcher[/^be_(.+)/, 1]}?"
-          end
-        end
-        # rubocop:enable Metrics/MethodLength
-
-        def replacement_matcher(node)
-          case [cop_config['Strict'], node.method?(:to)]
-          when [true, true]
-            'be(true)'
-          when [true, false]
-            'be(false)'
-          when [false, true]
-            'be_truthy'
-          when [false, false]
-            'be_falsey'
-          end
-        end
-      end
-
-      # Prefer using predicate matcher over using predicate method directly.
-      #
-      # RSpec defines magic matchers for predicate methods.
-      # This cop recommends to use the predicate matcher instead of using
-      # predicate method directly.
-      #
-      # @example Strict: true, EnforcedStyle: inflected (default)
-      #   # bad
-      #   expect(foo.something?).to be_truthy
-      #
-      #   # good
-      #   expect(foo).to be_something
-      #
-      #   # also good - It checks "true" strictly.
-      #   expect(foo.something?).to be(true)
-      #
-      # @example Strict: false, EnforcedStyle: inflected
-      #   # bad
-      #   expect(foo.something?).to be_truthy
-      #   expect(foo.something?).to be(true)
-      #
-      #   # good
-      #   expect(foo).to be_something
-      #
-      # @example Strict: true, EnforcedStyle: explicit
-      #   # bad
-      #   expect(foo).to be_something
-      #
-      #   # good - the above code is rewritten to it by this cop
-      #   expect(foo.something?).to be(true)
-      #
-      # @example Strict: false, EnforcedStyle: explicit
-      #   # bad
-      #   expect(foo).to be_something
-      #
-      #   # good - the above code is rewritten to it by this cop
-      #   expect(foo.something?).to be_truthy
-      class PredicateMatcher < Base
-        extend AutoCorrector
-        include ConfigurableEnforcedStyle
-        include InflectedHelper
-        include ExplicitHelper
-
-        def on_send(node)
-          case style
-          when :inflected
-            check_inflected(node)
-          when :explicit
-            check_explicit(node)
-          end
-        end
-
-        def on_block(node)
-          check_explicit(node) if style == :explicit
-        end
-
-        private
-
-        # returns args location with whitespace
-        # @example
-        #   foo 1, 2
-        #      ^^^^^
-        def args_loc(send_node)
-          send_node.loc.selector.end.with(
-            end_pos: send_node.loc.expression.end_pos
-          )
-        end
-
-        # returns block location with whitespace
-        # @example
-        #   foo { bar }
-        #      ^^^^^^^^
-        def block_loc(send_node)
-          parent = send_node.parent
-          return unless parent.block_type?
-
-          send_node.loc.expression.end.with(
-            end_pos: parent.loc.expression.end_pos
-          )
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/avoid_setup_hook.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/avoid_setup_hook.rb
deleted file mode 100644
index 00c1abe88bbc6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/avoid_setup_hook.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module Rails
-        # Checks that tests use RSpec `before` hook over Rails `setup` method.
-        #
-        # @example
-        #
-        #   # bad
-        #   setup do
-        #     allow(foo).to receive(:bar)
-        #   end
-        #
-        #   # good
-        #   before do
-        #     allow(foo).to receive(:bar)
-        #   end
-        #
-        class AvoidSetupHook < Base
-          extend AutoCorrector
-
-          MSG = 'Use `before` instead of `setup`.'
-
-          # @!method setup_call(node)
-          def_node_matcher :setup_call, <<-PATTERN
-            (block
-              $(send nil? :setup)
-              (args) _)
-          PATTERN
-
-          def on_block(node)
-            setup_call(node) do |setup|
-              add_offense(node) do |corrector|
-                corrector.replace setup, 'before'
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/have_http_status.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/have_http_status.rb
deleted file mode 100644
index 780dddb310f69..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/have_http_status.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module Rails
-        # Checks that tests use `have_http_status` instead of equality matchers.
-        #
-        # @example
-        #   # bad
-        #   expect(response.status).to be(200)
-        #
-        #   # good
-        #   expect(response).to have_http_status(200)
-        #
-        class HaveHttpStatus < Base
-          extend AutoCorrector
-
-          MSG =
-            'Prefer `expect(response).%<to>s have_http_status(%<status>i)` ' \
-            'over `expect(response.status).%<to>s %<match>s`.'
-
-          # @!method match_status(node)
-          def_node_matcher :match_status, <<-PATTERN
-            (send
-              (send nil? :expect
-                $(send (send nil? :response) :status)
-              )
-              $#Runners.all
-              $(send nil? {:be :eq :eql :equal} (int $_))
-            )
-          PATTERN
-
-          def on_send(node)
-            match_status(node) do |response_status, to, match, status|
-              message = format(MSG, to: to, match: match.source, status: status)
-              add_offense(node, message: message) do |corrector|
-                corrector.replace(response_status.source_range, 'response')
-                corrector.replace(match.loc.selector, 'have_http_status')
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/http_status.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/http_status.rb
deleted file mode 100644
index e9ea41f33c993..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/http_status.rb
+++ /dev/null
@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack/utils'
-
-module RuboCop
-  module Cop
-    module RSpec
-      module Rails
-        # Enforces use of symbolic or numeric value to describe HTTP status.
-        #
-        # @example `EnforcedStyle: symbolic` (default)
-        #   # bad
-        #   it { is_expected.to have_http_status 200 }
-        #   it { is_expected.to have_http_status 404 }
-        #
-        #   # good
-        #   it { is_expected.to have_http_status :ok }
-        #   it { is_expected.to have_http_status :not_found }
-        #   it { is_expected.to have_http_status :success }
-        #   it { is_expected.to have_http_status :error }
-        #
-        # @example `EnforcedStyle: numeric`
-        #   # bad
-        #   it { is_expected.to have_http_status :ok }
-        #   it { is_expected.to have_http_status :not_found }
-        #
-        #   # good
-        #   it { is_expected.to have_http_status 200 }
-        #   it { is_expected.to have_http_status 404 }
-        #   it { is_expected.to have_http_status :success }
-        #   it { is_expected.to have_http_status :error }
-        #
-        class HttpStatus < Base
-          extend AutoCorrector
-          include ConfigurableEnforcedStyle
-          RESTRICT_ON_SEND = %i[have_http_status].freeze
-
-          # @!method http_status(node)
-          def_node_matcher :http_status, <<-PATTERN
-            (send nil? :have_http_status ${int sym})
-          PATTERN
-
-          def on_send(node)
-            http_status(node) do |ast_node|
-              checker = checker_class.new(ast_node)
-              return unless checker.offensive?
-
-              add_offense(checker.node, message: checker.message) do |corrector|
-                corrector.replace(checker.node, checker.preferred_style)
-              end
-            end
-          end
-
-          private
-
-          def checker_class
-            case style
-            when :symbolic
-              SymbolicStyleChecker
-            when :numeric
-              NumericStyleChecker
-            end
-          end
-
-          # :nodoc:
-          class SymbolicStyleChecker
-            MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                  'to describe HTTP status code.'
-
-            attr_reader :node
-
-            def initialize(node)
-              @node = node
-            end
-
-            def offensive?
-              !node.sym_type? && !custom_http_status_code?
-            end
-
-            def message
-              format(MSG, prefer: preferred_style, current: number.to_s)
-            end
-
-            def preferred_style
-              symbol.inspect
-            end
-
-            private
-
-            def symbol
-              ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
-            end
-
-            def number
-              node.source.to_i
-            end
-
-            def custom_http_status_code?
-              node.int_type? &&
-                !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(node.source.to_i)
-            end
-          end
-
-          # :nodoc:
-          class NumericStyleChecker
-            MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                  'to describe HTTP status code.'
-
-            ALLOWED_STATUSES = %i[error success missing redirect].freeze
-
-            attr_reader :node
-
-            def initialize(node)
-              @node = node
-            end
-
-            def offensive?
-              !node.int_type? && !allowed_symbol?
-            end
-
-            def message
-              format(MSG, prefer: preferred_style, current: symbol.inspect)
-            end
-
-            def preferred_style
-              number.to_s
-            end
-
-            private
-
-            def number
-              ::Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol]
-            end
-
-            def symbol
-              node.value
-            end
-
-            def allowed_symbol?
-              node.sym_type? && ALLOWED_STATUSES.include?(node.value)
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_counts.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_counts.rb
deleted file mode 100644
index 5ad9e590ca07b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_counts.rb
+++ /dev/null
@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check for `once` and `twice` receive counts matchers usage.
-      #
-      # @example
-      #
-      #     # bad
-      #     expect(foo).to receive(:bar).exactly(1).times
-      #     expect(foo).to receive(:bar).exactly(2).times
-      #     expect(foo).to receive(:bar).at_least(1).times
-      #     expect(foo).to receive(:bar).at_least(2).times
-      #     expect(foo).to receive(:bar).at_most(1).times
-      #     expect(foo).to receive(:bar).at_most(2).times
-      #
-      #     # good
-      #     expect(foo).to receive(:bar).once
-      #     expect(foo).to receive(:bar).twice
-      #     expect(foo).to receive(:bar).at_least(:once)
-      #     expect(foo).to receive(:bar).at_least(:twice)
-      #     expect(foo).to receive(:bar).at_most(:once)
-      #     expect(foo).to receive(:bar).at_most(:twice).times
-      #
-      class ReceiveCounts < Base
-        extend AutoCorrector
-
-        MSG = 'Use `%<alternative>s` instead of `%<original>s`.'
-
-        RESTRICT_ON_SEND = %i[times].freeze
-
-        # @!method receive_counts(node)
-        def_node_matcher :receive_counts, <<-PATTERN
-          (send $(send _ {:exactly :at_least :at_most} (int {1 2})) :times)
-        PATTERN
-
-        # @!method stub?(node)
-        def_node_search :stub?, '(send nil? :receive ...)'
-
-        def on_send(node)
-          receive_counts(node) do |offending_node|
-            return unless stub?(offending_node.receiver)
-
-            offending_range = range(node, offending_node)
-
-            msg = message_for(offending_node, offending_range.source)
-            add_offense(offending_range, message: msg) do |corrector|
-              autocorrect(corrector, offending_node, offending_range)
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node, range)
-          replacement = matcher_for(
-            node.method_name,
-            node.first_argument.source.to_i
-          )
-
-          corrector.replace(range, replacement)
-        end
-
-        def message_for(node, source)
-          alternative = matcher_for(
-            node.method_name,
-            node.first_argument.source.to_i
-          )
-          format(MSG, alternative: alternative, original: source)
-        end
-
-        def matcher_for(method, count)
-          matcher = count == 1 ? 'once' : 'twice'
-          if method == :exactly
-            ".#{matcher}"
-          else
-            ".#{method}(:#{matcher})"
-          end
-        end
-
-        def range(node, offending_node)
-          offending_node.loc.dot.with(
-            end_pos: node.loc.expression.end_pos
-          )
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_never.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_never.rb
deleted file mode 100644
index c5538ee583e78..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_never.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Prefer `not_to receive(...)` over `receive(...).never`.
-      #
-      # @example
-      #
-      #     # bad
-      #     expect(foo).to receive(:bar).never
-      #
-      #     # good
-      #     expect(foo).not_to receive(:bar)
-      #
-      class ReceiveNever < Base
-        extend AutoCorrector
-        MSG = 'Use `not_to receive` instead of `never`.'
-        RESTRICT_ON_SEND = %i[never].freeze
-
-        # @!method method_on_stub?(node)
-        def_node_search :method_on_stub?, '(send nil? :receive ...)'
-
-        def on_send(node)
-          return unless node.method?(:never) && method_on_stub?(node)
-
-          add_offense(node.loc.selector) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          corrector.replace(node.parent.loc.selector, 'not_to')
-          range = node.loc.dot.with(end_pos: node.loc.selector.end_pos)
-          corrector.remove(range)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_description.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_description.rb
deleted file mode 100644
index f499bb102337a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_description.rb
+++ /dev/null
@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check for repeated description strings in example groups.
-      #
-      # @example
-      #
-      #     # bad
-      #     RSpec.describe User do
-      #       it 'is valid' do
-      #         # ...
-      #       end
-      #
-      #       it 'is valid' do
-      #         # ...
-      #       end
-      #     end
-      #
-      #     # good
-      #     RSpec.describe User do
-      #       it 'is valid when first and last name are present' do
-      #         # ...
-      #       end
-      #
-      #       it 'is valid when last name only is present' do
-      #         # ...
-      #       end
-      #     end
-      #
-      #     # good
-      #     RSpec.describe User do
-      #       it 'is valid' do
-      #         # ...
-      #       end
-      #
-      #       it 'is valid', :flag do
-      #         # ...
-      #       end
-      #     end
-      #
-      class RepeatedDescription < Base
-        MSG = "Don't repeat descriptions within an example group."
-
-        def on_block(node)
-          return unless example_group?(node)
-
-          repeated_descriptions(node).each do |repeated_description|
-            add_offense(repeated_description)
-          end
-        end
-
-        private
-
-        # Select examples in the current scope with repeated description strings
-        def repeated_descriptions(node)
-          grouped_examples =
-            RuboCop::RSpec::ExampleGroup.new(node)
-              .examples
-              .group_by { |example| example_signature(example) }
-
-          grouped_examples
-            .select { |signatures, group| signatures.any? && group.size > 1 }
-            .values
-            .flatten
-            .map(&:definition)
-        end
-
-        def example_signature(example)
-          [example.metadata, example.doc_string]
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example.rb
deleted file mode 100644
index 7a7274aade20b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example.rb
+++ /dev/null
@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check for repeated examples within example groups.
-      #
-      # @example
-      #
-      #    it 'is valid' do
-      #      expect(user).to be_valid
-      #    end
-      #
-      #    it 'validates the user' do
-      #      expect(user).to be_valid
-      #    end
-      #
-      class RepeatedExample < Base
-        MSG = "Don't repeat examples within an example group."
-
-        def on_block(node)
-          return unless example_group?(node)
-
-          repeated_examples(node).each do |repeated_example|
-            add_offense(repeated_example)
-          end
-        end
-
-        private
-
-        def repeated_examples(node)
-          RuboCop::RSpec::ExampleGroup.new(node)
-            .examples
-            .group_by { |example| example_signature(example) }
-            .values
-            .reject(&:one?)
-            .flatten
-            .map(&:to_node)
-        end
-
-        def example_signature(example)
-          key_parts = [example.metadata, example.implementation]
-
-          if example.definition.method?(:its)
-            key_parts << example.definition.arguments
-          end
-
-          key_parts
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb
deleted file mode 100644
index 596d6d61c832a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb
+++ /dev/null
@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check for repeated describe and context block body.
-      #
-      # @example
-      #
-      #    # bad
-      #    describe 'cool feature x' do
-      #      it { cool_predicate }
-      #    end
-      #
-      #    describe 'cool feature y' do
-      #      it { cool_predicate }
-      #    end
-      #
-      #    # good
-      #    describe 'cool feature' do
-      #      it { cool_predicate }
-      #    end
-      #
-      #    describe 'another cool feature' do
-      #      it { another_predicate }
-      #    end
-      #
-      #    # good
-      #    context 'when case x', :tag do
-      #      it { cool_predicate }
-      #    end
-      #
-      #    context 'when case y' do
-      #      it { cool_predicate }
-      #    end
-      #
-      #    # good
-      #    context Array do
-      #      it { is_expected.to respond_to :each }
-      #    end
-      #
-      #    context Hash do
-      #      it { is_expected.to respond_to :each }
-      #    end
-      #
-      class RepeatedExampleGroupBody < Base
-        MSG = 'Repeated %<group>s block body on line(s) %<loc>s'
-
-        # @!method several_example_groups?(node)
-        def_node_matcher :several_example_groups?, <<-PATTERN
-          (begin <#example_group_with_body? #example_group_with_body? ...>)
-        PATTERN
-
-        # @!method metadata(node)
-        def_node_matcher :metadata, '(block (send _ _ _ $...) ...)'
-
-        # @!method body(node)
-        def_node_matcher :body, '(block _ args $...)'
-
-        # @!method const_arg(node)
-        def_node_matcher :const_arg, '(block (send _ _ $const ...) ...)'
-
-        # @!method skip_or_pending?(node)
-        def_node_matcher :skip_or_pending?, <<-PATTERN
-          (block <(send nil? {:skip :pending} ...) ...>)
-        PATTERN
-
-        def on_begin(node)
-          return unless several_example_groups?(node)
-
-          repeated_group_bodies(node).each do |group, repeats|
-            add_offense(group, message: message(group, repeats))
-          end
-        end
-
-        private
-
-        def repeated_group_bodies(node)
-          node
-            .children
-            .select { |child| example_group_with_body?(child) }
-            .reject { |child| skip_or_pending?(child) }
-            .group_by { |group| signature_keys(group) }
-            .values
-            .reject(&:one?)
-            .flat_map { |groups| add_repeated_lines(groups) }
-        end
-
-        def add_repeated_lines(groups)
-          repeated_lines = groups.map(&:first_line)
-          groups.map { |group| [group, repeated_lines - [group.first_line]] }
-        end
-
-        def signature_keys(group)
-          [metadata(group), body(group), const_arg(group)]
-        end
-
-        def message(group, repeats)
-          format(MSG, group: group.method_name, loc: repeats)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_description.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_description.rb
deleted file mode 100644
index b36b18dff3bc5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_description.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check for repeated example group descriptions.
-      #
-      # @example
-      #
-      #    # bad
-      #    describe 'cool feature' do
-      #      # example group
-      #    end
-      #
-      #    describe 'cool feature' do
-      #      # example group
-      #    end
-      #
-      #    # bad
-      #    context 'when case x' do
-      #      # example group
-      #    end
-      #
-      #    describe 'when case x' do
-      #      # example group
-      #    end
-      #
-      #    # good
-      #    describe 'cool feature' do
-      #      # example group
-      #    end
-      #
-      #    describe 'another cool feature' do
-      #      # example group
-      #    end
-      #
-      #    # good
-      #    context 'when case x' do
-      #      # example group
-      #    end
-      #
-      #    context 'when another case' do
-      #      # example group
-      #    end
-      #
-      class RepeatedExampleGroupDescription < Base
-        MSG = 'Repeated %<group>s block description on line(s) %<loc>s'
-
-        # @!method several_example_groups?(node)
-        def_node_matcher :several_example_groups?, <<-PATTERN
-          (begin <#example_group? #example_group? ...>)
-        PATTERN
-
-        # @!method doc_string_and_metadata(node)
-        def_node_matcher :doc_string_and_metadata, <<-PATTERN
-          (block (send _ _ $_ $...) ...)
-        PATTERN
-
-        # @!method skip_or_pending?(node)
-        def_node_matcher :skip_or_pending?, <<-PATTERN
-          (block <(send nil? {:skip :pending}) ...>)
-        PATTERN
-
-        # @!method empty_description?(node)
-        def_node_matcher :empty_description?, '(block (send _ _) ...)'
-
-        def on_begin(node)
-          return unless several_example_groups?(node)
-
-          repeated_group_descriptions(node).each do |group, repeats|
-            add_offense(group, message: message(group, repeats))
-          end
-        end
-
-        private
-
-        def repeated_group_descriptions(node)
-          node
-            .children
-            .select { |child| example_group?(child) }
-            .reject { |child| skip_or_pending?(child) }
-            .reject { |child| empty_description?(child) }
-            .group_by { |group| doc_string_and_metadata(group) }
-            .values
-            .reject(&:one?)
-            .flat_map { |groups| add_repeated_lines(groups) }
-        end
-
-        def add_repeated_lines(groups)
-          repeated_lines = groups.map(&:first_line)
-          groups.map { |group| [group, repeated_lines - [group.first_line]] }
-        end
-
-        def message(group, repeats)
-          format(MSG, group: group.method_name, loc: repeats)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_include_example.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_include_example.rb
deleted file mode 100644
index 90baf2b5e862e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_include_example.rb
+++ /dev/null
@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Check for repeated include of shared examples.
-      #
-      # @example
-      #
-      #    # bad
-      #    describe 'foo' do
-      #      include_examples 'cool stuff'
-      #      include_examples 'cool stuff'
-      #    end
-      #
-      #    # bad
-      #    describe 'foo' do
-      #      it_behaves_like 'a cool', 'thing'
-      #      it_behaves_like 'a cool', 'thing'
-      #    end
-      #
-      #    # bad
-      #    context 'foo' do
-      #      it_should_behave_like 'a duck'
-      #      it_should_behave_like 'a duck'
-      #    end
-      #
-      #    # good
-      #    describe 'foo' do
-      #      include_examples 'cool stuff'
-      #    end
-      #
-      #    describe 'bar' do
-      #      include_examples 'cool stuff'
-      #    end
-      #
-      #    # good
-      #    describe 'foo' do
-      #      it_behaves_like 'a cool', 'thing'
-      #      it_behaves_like 'a cool', 'person'
-      #    end
-      #
-      #    # good
-      #    context 'foo' do
-      #      it_should_behave_like 'a duck'
-      #      it_should_behave_like 'a goose'
-      #    end
-      #
-      class RepeatedIncludeExample < Base
-        MSG = 'Repeated include of shared_examples %<name>s ' \
-          'on line(s) %<repeat>s'
-
-        # @!method several_include_examples?(node)
-        def_node_matcher :several_include_examples?, <<-PATTERN
-          (begin <#include_examples? #include_examples? ...>)
-        PATTERN
-
-        # @!method include_examples?(node)
-        def_node_matcher :include_examples?,
-                         send_pattern('#Includes.examples')
-
-        # @!method shared_examples_name(node)
-        def_node_matcher :shared_examples_name, <<-PATTERN
-          (send _ #Includes.examples $_ ...)
-        PATTERN
-
-        def on_begin(node)
-          return unless several_include_examples?(node)
-
-          repeated_include_examples(node).each do |item, repeats|
-            add_offense(item, message: message(item, repeats))
-          end
-        end
-
-        private
-
-        def repeated_include_examples(node)
-          node
-            .children
-            .select { |child| literal_include_examples?(child) }
-            .group_by { |child| signature_keys(child) }
-            .values
-            .reject(&:one?)
-            .flat_map { |items| add_repeated_lines(items) }
-        end
-
-        def literal_include_examples?(node)
-          include_examples?(node) &&
-            node.arguments.all?(&:recursive_literal_or_const?)
-        end
-
-        def add_repeated_lines(items)
-          repeated_lines = items.map(&:first_line)
-          items.map { |item| [item, repeated_lines - [item.first_line]] }
-        end
-
-        def signature_keys(item)
-          item.arguments
-        end
-
-        def message(item, repeats)
-          format(MSG, name: shared_examples_name(item).source, repeat: repeats)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb
deleted file mode 100644
index 759a0d32fc2e3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb
+++ /dev/null
@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for consistent style of stub's return setting.
-      #
-      # Enforces either `and_return` or block-style return in the cases
-      # where the returned value is constant. Ignores dynamic returned values
-      # are the result would be different
-      #
-      # This cop can be configured using the `EnforcedStyle` option
-      #
-      # @example `EnforcedStyle: and_return` (default)
-      #   # bad
-      #   allow(Foo).to receive(:bar) { "baz" }
-      #   expect(Foo).to receive(:bar) { "baz" }
-      #
-      #   # good
-      #   allow(Foo).to receive(:bar).and_return("baz")
-      #   expect(Foo).to receive(:bar).and_return("baz")
-      #   # also good as the returned value is dynamic
-      #   allow(Foo).to receive(:bar) { bar.baz }
-      #
-      # @example `EnforcedStyle: block`
-      #   # bad
-      #   allow(Foo).to receive(:bar).and_return("baz")
-      #   expect(Foo).to receive(:bar).and_return("baz")
-      #
-      #   # good
-      #   allow(Foo).to receive(:bar) { "baz" }
-      #   expect(Foo).to receive(:bar) { "baz" }
-      #   # also good as the returned value is dynamic
-      #   allow(Foo).to receive(:bar).and_return(bar.baz)
-      #
-      class ReturnFromStub < Base
-        extend AutoCorrector
-        include ConfigurableEnforcedStyle
-
-        MSG_AND_RETURN = 'Use `and_return` for static values.'
-        MSG_BLOCK = 'Use block for static values.'
-        RESTRICT_ON_SEND = %i[and_return].freeze
-
-        # @!method contains_stub?(node)
-        def_node_search :contains_stub?, '(send nil? :receive (...))'
-
-        # @!method stub_with_block?(node)
-        def_node_matcher :stub_with_block?, '(block #contains_stub? ...)'
-
-        # @!method and_return_value(node)
-        def_node_search :and_return_value, <<-PATTERN
-          $(send _ :and_return $(...))
-        PATTERN
-
-        def on_send(node)
-          return unless style == :block
-          return unless contains_stub?(node)
-
-          check_and_return_call(node)
-        end
-
-        def on_block(node)
-          return unless style == :and_return
-          return unless stub_with_block?(node)
-
-          check_block_body(node)
-        end
-
-        private
-
-        def check_and_return_call(node)
-          and_return_value(node) do |and_return, args|
-            unless dynamic?(args)
-              add_offense(and_return.loc.selector, message: MSG_BLOCK) do |corr|
-                AndReturnCallCorrector.new(and_return).call(corr)
-              end
-            end
-          end
-        end
-
-        def check_block_body(block)
-          body = block.body
-          unless dynamic?(body) # rubocop:disable Style/GuardClause
-            add_offense(block.loc.begin, message: MSG_AND_RETURN) do |corrector|
-              BlockBodyCorrector.new(block).call(corrector)
-            end
-          end
-        end
-
-        def dynamic?(node)
-          node && !node.recursive_literal_or_const?
-        end
-
-        # :nodoc:
-        class AndReturnCallCorrector
-          def initialize(node)
-            @node = node
-            @receiver = node.receiver
-            @arg = node.first_argument
-          end
-
-          def call(corrector)
-            # Heredoc autocorrection is not yet implemented.
-            return if heredoc?
-
-            corrector.replace(range, " { #{replacement} }")
-          end
-
-          private
-
-          attr_reader :node, :receiver, :arg
-
-          def heredoc?
-            arg.loc.is_a?(Parser::Source::Map::Heredoc)
-          end
-
-          def range
-            Parser::Source::Range.new(
-              node.source_range.source_buffer,
-              receiver.source_range.end_pos,
-              node.source_range.end_pos
-            )
-          end
-
-          def replacement
-            if hash_without_braces?
-              "{ #{arg.source} }"
-            else
-              arg.source
-            end
-          end
-
-          def hash_without_braces?
-            arg.hash_type? && !arg.braces?
-          end
-        end
-
-        # :nodoc:
-        class BlockBodyCorrector
-          def initialize(block)
-            @block = block
-            @node = block.parent
-            @body = block.body || NULL_BLOCK_BODY
-          end
-
-          def call(corrector)
-            # Heredoc autocorrection is not yet implemented.
-            return if heredoc?
-
-            corrector.replace(
-              block,
-              "#{block.send_node.source}.and_return(#{body.source})"
-            )
-          end
-
-          private
-
-          attr_reader :node, :block, :body
-
-          def heredoc?
-            body.loc.is_a?(Parser::Source::Map::Heredoc)
-          end
-
-          NULL_BLOCK_BODY = Struct.new(:loc, :source).new(nil, 'nil')
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_let.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_let.rb
deleted file mode 100644
index 8644b81e0912c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_let.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for let scattered across the example group.
-      #
-      # Group lets together
-      #
-      # @example
-      #   # bad
-      #   describe Foo do
-      #     let(:foo) { 1 }
-      #     subject { Foo }
-      #     let(:bar) { 2 }
-      #     before { prepare }
-      #     let!(:baz) { 3 }
-      #   end
-      #
-      #   # good
-      #   describe Foo do
-      #     subject { Foo }
-      #     before { prepare }
-      #     let(:foo) { 1 }
-      #     let(:bar) { 2 }
-      #     let!(:baz) { 3 }
-      #   end
-      #
-      class ScatteredLet < Base
-        extend AutoCorrector
-
-        MSG = 'Group all let/let! blocks in the example group together.'
-
-        def on_block(node)
-          return unless example_group_with_body?(node)
-
-          check_let_declarations(node.body)
-        end
-
-        private
-
-        def check_let_declarations(body)
-          lets = body.each_child_node.select { |node| let?(node) }
-
-          first_let = lets.first
-          lets.each_with_index do |node, idx|
-            next if node.sibling_index == first_let.sibling_index + idx
-
-            add_offense(node) do |corrector|
-              RuboCop::RSpec::Corrector::MoveNode.new(
-                node, corrector, processed_source
-              ).move_after(first_let)
-            end
-          end
-        end
-
-        def find_first_let(node)
-          node.children.find { |child| let?(child) }
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_setup.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_setup.rb
deleted file mode 100644
index 58312857b8863..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_setup.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for setup scattered across multiple hooks in an example group.
-      #
-      # Unify `before`, `after`, and `around` hooks when possible.
-      #
-      # @example
-      #   # bad
-      #   describe Foo do
-      #     before { setup1 }
-      #     before { setup2 }
-      #   end
-      #
-      #   # good
-      #   describe Foo do
-      #     before do
-      #       setup1
-      #       setup2
-      #     end
-      #   end
-      #
-      class ScatteredSetup < Base
-        MSG = 'Do not define multiple `%<hook_name>s` hooks in the same ' \
-              'example group (also defined on %<lines>s).'
-
-        def on_block(node)
-          return unless example_group?(node)
-
-          repeated_hooks(node).each do |occurrences|
-            lines = occurrences.map(&:first_line)
-
-            occurrences.each do |occurrence|
-              lines_except_current = lines - [occurrence.first_line]
-              message = format(MSG, hook_name: occurrences.first.method_name,
-                                    lines: lines_msg(lines_except_current))
-              add_offense(occurrence, message: message)
-            end
-          end
-        end
-
-        def repeated_hooks(node)
-          hooks = RuboCop::RSpec::ExampleGroup.new(node)
-            .hooks
-            .select(&:knowable_scope?)
-            .group_by { |hook| [hook.name, hook.scope, hook.metadata] }
-            .values
-            .reject(&:one?)
-
-          hooks.map do |hook|
-            hook.map(&:to_node)
-          end
-        end
-
-        def lines_msg(numbers)
-          if numbers.size == 1
-            "line #{numbers.first}"
-          else
-            "lines #{numbers.join(', ')}"
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_context.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_context.rb
deleted file mode 100644
index 0f93f8d157dfb..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_context.rb
+++ /dev/null
@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for proper shared_context and shared_examples usage.
-      #
-      # If there are no examples defined, use shared_context.
-      # If there is no setup defined, use shared_examples.
-      #
-      # @example
-      #   # bad
-      #   RSpec.shared_context 'only examples here' do
-      #     it 'does x' do
-      #     end
-      #
-      #     it 'does y' do
-      #     end
-      #   end
-      #
-      #   # good
-      #   RSpec.shared_examples 'only examples here' do
-      #     it 'does x' do
-      #     end
-      #
-      #     it 'does y' do
-      #     end
-      #   end
-      #
-      # @example
-      #   # bad
-      #   RSpec.shared_examples 'only setup here' do
-      #     subject(:foo) { :bar }
-      #
-      #     let(:baz) { :bazz }
-      #
-      #     before do
-      #       something
-      #     end
-      #   end
-      #
-      #   # good
-      #   RSpec.shared_context 'only setup here' do
-      #     subject(:foo) { :bar }
-      #
-      #     let(:baz) { :bazz }
-      #
-      #     before do
-      #       something
-      #     end
-      #   end
-      #
-      class SharedContext < Base
-        extend AutoCorrector
-
-        MSG_EXAMPLES = "Use `shared_examples` when you don't define context."
-        MSG_CONTEXT  = "Use `shared_context` when you don't define examples."
-
-        # @!method examples?(node)
-        def_node_search :examples?,
-                        send_pattern('{#Includes.examples #Examples.all}')
-
-        # @!method context?(node)
-        def_node_search :context?, <<-PATTERN
-          (
-            send #rspec? {
-              #Subjects.all
-              #Helpers.all
-              #Includes.context
-              #Hooks.all
-            } ...
-          )
-        PATTERN
-
-        # @!method shared_context(node)
-        def_node_matcher :shared_context,
-                         block_pattern('#SharedGroups.context')
-        # @!method shared_example(node)
-        def_node_matcher :shared_example,
-                         block_pattern('#SharedGroups.examples')
-
-        def on_block(node)
-          context_with_only_examples(node) do
-            add_offense(node.send_node, message: MSG_EXAMPLES) do |corrector|
-              corrector.replace(node.send_node.loc.selector, 'shared_examples')
-            end
-          end
-
-          examples_with_only_context(node) do
-            add_offense(node.send_node, message: MSG_CONTEXT) do |corrector|
-              corrector.replace(node.send_node.loc.selector, 'shared_context')
-            end
-          end
-        end
-
-        private
-
-        def context_with_only_examples(node)
-          shared_context(node) { yield if examples?(node) && !context?(node) }
-        end
-
-        def examples_with_only_context(node)
-          shared_example(node) { yield if context?(node) && !examples?(node) }
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_examples.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_examples.rb
deleted file mode 100644
index 52bd2e03a5be5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_examples.rb
+++ /dev/null
@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Enforces use of string to titleize shared examples.
-      #
-      # @example
-      #   # bad
-      #   it_behaves_like :foo_bar_baz
-      #   it_should_behave_like :foo_bar_baz
-      #   shared_examples :foo_bar_baz
-      #   shared_examples_for :foo_bar_baz
-      #   include_examples :foo_bar_baz
-      #
-      #   # good
-      #   it_behaves_like 'foo bar baz'
-      #   it_should_behave_like 'foo bar baz'
-      #   shared_examples 'foo bar baz'
-      #   shared_examples_for 'foo bar baz'
-      #   include_examples 'foo bar baz'
-      #
-      class SharedExamples < Base
-        extend AutoCorrector
-
-        # @!method shared_examples(node)
-        def_node_matcher :shared_examples,
-                         send_pattern(
-                           '{#SharedGroups.all #Includes.all}'
-                         )
-
-        def on_send(node)
-          shared_examples(node) do
-            ast_node = node.first_argument
-            next unless ast_node&.sym_type?
-
-            checker = Checker.new(ast_node)
-            add_offense(checker.node, message: checker.message) do |corrector|
-              corrector.replace(checker.node, checker.preferred_style)
-            end
-          end
-        end
-
-        # :nodoc:
-        class Checker
-          MSG = 'Prefer %<prefer>s over `%<current>s` ' \
-                'to titleize shared examples.'
-
-          attr_reader :node
-
-          def initialize(node)
-            @node = node
-          end
-
-          def message
-            format(MSG, prefer: preferred_style, current: symbol.inspect)
-          end
-
-          def preferred_style
-            string = symbol.to_s.tr('_', ' ')
-            wrap_with_single_quotes(string)
-          end
-
-          private
-
-          def symbol
-            node.value
-          end
-
-          def wrap_with_single_quotes(string)
-            "'#{string}'"
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb
deleted file mode 100644
index 2c8c119762185..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb
+++ /dev/null
@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that chains of messages contain more than one element.
-      #
-      # @example
-      #   # bad
-      #   allow(foo).to receive_message_chain(:bar).and_return(42)
-      #
-      #   # good
-      #   allow(foo).to receive(:bar).and_return(42)
-      #
-      #   # also good
-      #   allow(foo).to receive(:bar, :baz)
-      #   allow(foo).to receive("bar.baz")
-      #
-      class SingleArgumentMessageChain < Base
-        extend AutoCorrector
-
-        MSG = 'Use `%<recommended>s` instead of calling ' \
-              '`%<called>s` with a single argument.'
-        RESTRICT_ON_SEND = %i[receive_message_chain stub_chain].freeze
-
-        # @!method message_chain(node)
-        def_node_matcher :message_chain, <<-PATTERN
-          (send _ {:receive_message_chain :stub_chain} $_)
-        PATTERN
-
-        # @!method single_key_hash?(node)
-        def_node_matcher :single_key_hash?, '(hash pair)'
-
-        def on_send(node)
-          message_chain(node) do |arg|
-            return if valid_usage?(arg)
-
-            method = node.method_name
-            msg = format(MSG, recommended: replacement(method), called: method)
-
-            add_offense(node.loc.selector, message: msg) do |corrector|
-              autocorrect(corrector, node, method, arg)
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node, method, arg)
-          corrector.replace(node.loc.selector, replacement(method))
-          autocorrect_hash_arg(corrector, arg) if single_key_hash?(arg)
-          autocorrect_array_arg(corrector, arg) if arg.array_type?
-        end
-
-        def valid_usage?(node)
-          return true unless node.literal? || node.array_type?
-
-          case node.type
-          when :hash then !single_key_hash?(node)
-          when :array then !single_element_array?(node)
-          else node.to_s.include?('.')
-          end
-        end
-
-        def single_element_array?(node)
-          node.child_nodes.one?
-        end
-
-        def autocorrect_hash_arg(corrector, arg)
-          key, value = *arg.children.first
-
-          corrector.replace(arg, key_to_arg(key))
-          corrector.insert_after(arg.parent.loc.end,
-                                 ".and_return(#{value.source})")
-        end
-
-        def autocorrect_array_arg(corrector, arg)
-          value = arg.children.first
-
-          corrector.replace(arg, value.source)
-        end
-
-        def key_to_arg(node)
-          key, = *node # rubocop:disable InternalAffairs/NodeDestructuring
-          node.sym_type? ? ":#{key}" : node.source
-        end
-
-        def replacement(method)
-          method.equal?(:receive_message_chain) ? 'receive' : 'stub'
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb
deleted file mode 100644
index 43646dda667e8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb
+++ /dev/null
@@ -1,173 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that message expectations do not have a configured response.
-      #
-      # @example
-      #
-      #   # bad
-      #   expect(foo).to receive(:bar).with(42).and_return("hello world")
-      #
-      #   # good (without spies)
-      #   allow(foo).to receive(:bar).with(42).and_return("hello world")
-      #   expect(foo).to receive(:bar).with(42)
-      #
-      class StubbedMock < Base
-        MSG = 'Prefer `%<replacement>s` over `%<method_name>s` when ' \
-              'configuring a response.'
-
-        # @!method message_expectation?(node)
-        #   Match message expectation matcher
-        #
-        #   @example source that matches
-        #     receive(:foo)
-        #
-        #   @example source that matches
-        #     receive_message_chain(:foo, :bar)
-        #
-        #   @example source that matches
-        #     receive(:foo).with('bar')
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @return [Array<RuboCop::AST::Node>] matching nodes
-        def_node_matcher :message_expectation?, <<-PATTERN
-          {
-            (send nil? { :receive :receive_message_chain } ...)  # receive(:foo)
-            (send (send nil? :receive ...) :with ...)            # receive(:foo).with('bar')
-          }
-        PATTERN
-
-        # @!method configured_response?(node)
-        def_node_matcher :configured_response?, <<~PATTERN
-          { :and_return :and_raise :and_throw :and_yield
-            :and_call_original :and_wrap_original }
-        PATTERN
-
-        # @!method expectation(node)
-        #   Match expectation
-        #
-        #   @example source that matches
-        #     is_expected.to be_in_the_bar
-        #
-        #   @example source that matches
-        #     expect(cocktail).to contain_exactly(:fresh_orange_juice, :campari)
-        #
-        #   @example source that matches
-        #     expect_any_instance_of(Officer).to be_alert
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @yield [RuboCop::AST::Node] expectation, method name, matcher
-        def_node_matcher :expectation, <<~PATTERN
-          (send
-            $(send nil? $#Expectations.all ...)
-            :to $_)
-        PATTERN
-
-        # @!method matcher_with_configured_response(node)
-        #   Match matcher with a configured response
-        #
-        #   @example source that matches
-        #     receive(:foo).and_return('bar')
-        #
-        #   @example source that matches
-        #     receive(:lower).and_raise(SomeError)
-        #
-        #   @example source that matches
-        #     receive(:redirect).and_call_original
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @yield [RuboCop::AST::Node] matcher
-        def_node_matcher :matcher_with_configured_response, <<~PATTERN
-          (send #message_expectation? #configured_response? _)
-        PATTERN
-
-        # @!method matcher_with_return_block(node)
-        #   Match matcher with a return block
-        #
-        #   @example source that matches
-        #     receive(:foo) { 'bar' }
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @yield [RuboCop::AST::Node] matcher
-        def_node_matcher :matcher_with_return_block, <<~PATTERN
-          (block #message_expectation? args _)  # receive(:foo) { 'bar' }
-        PATTERN
-
-        # @!method matcher_with_hash(node)
-        #   Match matcher with a configured response defined as a hash
-        #
-        #   @example source that matches
-        #     receive_messages(foo: 'bar', baz: 'qux')
-        #
-        #   @example source that matches
-        #     receive_message_chain(:foo, bar: 'baz')
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @yield [RuboCop::AST::Node] matcher
-        def_node_matcher :matcher_with_hash, <<~PATTERN
-          {
-            (send nil? :receive_messages hash)           # receive_messages(foo: 'bar', baz: 'qux')
-            (send nil? :receive_message_chain ... hash)  # receive_message_chain(:foo, bar: 'baz')
-          }
-        PATTERN
-
-        # @!method matcher_with_blockpass(node)
-        #   Match matcher with a configured response in block-pass
-        #
-        #   @example source that matches
-        #     receive(:foo, &canned)
-        #
-        #   @example source that matches
-        #     receive_message_chain(:foo, :bar, &canned)
-        #
-        #   @example source that matches
-        #     receive(:foo).with('bar', &canned)
-        #
-        #   @param node [RuboCop::AST::Node]
-        #   @yield [RuboCop::AST::Node] matcher
-        def_node_matcher :matcher_with_blockpass, <<~PATTERN
-          {
-            (send nil? { :receive :receive_message_chain } ... block_pass)  # receive(:foo, &canned)
-            (send (send nil? :receive ...) :with ... block_pass)            # receive(:foo).with('foo', &canned)
-          }
-        PATTERN
-
-        def on_send(node)
-          expectation(node, &method(:on_expectation))
-        end
-
-        private
-
-        def on_expectation(expectation, method_name, matcher)
-          flag_expectation = lambda do
-            add_offense(expectation, message: msg(method_name))
-          end
-
-          matcher_with_configured_response(matcher, &flag_expectation)
-          matcher_with_return_block(matcher, &flag_expectation)
-          matcher_with_hash(matcher, &flag_expectation)
-          matcher_with_blockpass(matcher, &flag_expectation)
-        end
-
-        def msg(method_name)
-          format(MSG,
-                 method_name: method_name,
-                 replacement: replacement(method_name))
-        end
-
-        def replacement(method_name)
-          case method_name
-          when :expect
-            :allow
-          when :is_expected
-            'allow(subject)'
-          when :expect_any_instance_of
-            :allow_any_instance_of
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_declaration.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_declaration.rb
deleted file mode 100644
index ce4d948a64d64..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_declaration.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Ensure that subject is defined using subject helper.
-      #
-      # @example
-      #
-      #   # bad
-      #   let(:subject) { foo }
-      #   let!(:subject) { foo }
-      #   subject(:subject) { foo }
-      #   subject!(:subject) { foo }
-      #
-      #   # bad
-      #   block = -> {}
-      #   let(:subject, &block)
-      #
-      #   # good
-      #   subject(:test_subject) { foo }
-      #
-      class SubjectDeclaration < Base
-        MSG_LET = 'Use subject explicitly rather than using let'
-        MSG_REDUNDANT = 'Ambiguous declaration of subject'
-
-        # @!method offensive_subject_declaration?(node)
-        def_node_matcher :offensive_subject_declaration?, <<~PATTERN
-          (send nil? ${#Subjects.all #Helpers.all} {(sym :subject) (str "subject")} ...)
-        PATTERN
-
-        def on_send(node)
-          offense = offensive_subject_declaration?(node)
-          return unless offense
-
-          add_offense(node, message: message_for(offense))
-        end
-
-        private
-
-        def message_for(offense)
-          Helpers.all(offense) ? MSG_LET : MSG_REDUNDANT
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_stub.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_stub.rb
deleted file mode 100644
index 588f1848938aa..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_stub.rb
+++ /dev/null
@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for stubbed test subjects.
-      #
-      # Checks nested subject stubs for innermost subject definition
-      # when subject is also defined in parent example groups.
-      #
-      # @see https://robots.thoughtbot.com/don-t-stub-the-system-under-test
-      # @see https://samphippen.com/introducing-rspec-smells-and-where-to-find-them#smell-1-stubject
-      # @see https://github.com/rubocop-hq/rspec-style-guide#dont-stub-subject
-      #
-      # @example
-      #   # bad
-      #   describe Article do
-      #     subject(:article) { Article.new }
-      #
-      #     it 'indicates that the author is unknown' do
-      #       allow(article).to receive(:author).and_return(nil)
-      #       expect(article.description).to include('by an unknown author')
-      #     end
-      #   end
-      #
-      #   # bad
-      #   describe Article do
-      #     subject(:foo) { Article.new }
-      #
-      #     context 'nested subject' do
-      #       subject(:article) { Article.new }
-      #
-      #       it 'indicates that the author is unknown' do
-      #         allow(article).to receive(:author).and_return(nil)
-      #         expect(article.description).to include('by an unknown author')
-      #       end
-      #     end
-      #   end
-      #
-      #   # good
-      #   describe Article do
-      #     subject(:article) { Article.new(author: nil) }
-      #
-      #     it 'indicates that the author is unknown' do
-      #       expect(article.description).to include('by an unknown author')
-      #     end
-      #   end
-      #
-      class SubjectStub < Base
-        include TopLevelGroup
-
-        MSG = 'Do not stub methods of the object under test.'
-
-        # @!method subject?(node)
-        #   Find a named or unnamed subject definition
-        #
-        #   @example anonymous subject
-        #     subject?(parse('subject { foo }').ast) do |name|
-        #       name # => :subject
-        #     end
-        #
-        #   @example named subject
-        #     subject?(parse('subject(:thing) { foo }').ast) do |name|
-        #       name # => :thing
-        #     end
-        #
-        #   @param node [RuboCop::AST::Node]
-        #
-        #   @yield [Symbol] subject name
-        def_node_matcher :subject?, <<-PATTERN
-          (block
-            (send nil?
-              {:subject (sym $_) | $:subject}
-            ) args ...)
-        PATTERN
-
-        # @!method let?(node)
-        #   Find a memoized helper
-        def_node_matcher :let?, <<-PATTERN
-          (block
-            (send nil? :let (sym $_)
-            ) args ...)
-        PATTERN
-
-        # @!method message_expectation?(node, method_name)
-        #   Match `allow` and `expect(...).to receive`
-        #
-        #   @example source that matches
-        #     allow(foo).to  receive(:bar)
-        #     allow(foo).to  receive(:bar).with(1)
-        #     allow(foo).to  receive(:bar).with(1).and_return(2)
-        #     expect(foo).to receive(:bar)
-        #     expect(foo).to receive(:bar).with(1)
-        #     expect(foo).to receive(:bar).with(1).and_return(2)
-        #
-        def_node_matcher :message_expectation?, <<-PATTERN
-          (send
-            {
-              (send nil? { :expect :allow } (send nil? %))
-              (send nil? :is_expected)
-            }
-            #Runners.all
-            #message_expectation_matcher?
-          )
-        PATTERN
-
-        # @!method message_expectation_matcher?(node)
-        def_node_search :message_expectation_matcher?, <<-PATTERN
-          (send nil? {
-            :receive :receive_messages :receive_message_chain :have_received
-            } ...)
-        PATTERN
-
-        def on_top_level_group(node)
-          @explicit_subjects = find_all_explicit(node, &method(:subject?))
-          @subject_overrides = find_all_explicit(node, &method(:let?))
-
-          find_subject_expectations(node) do |stub|
-            add_offense(stub)
-          end
-        end
-
-        private
-
-        def find_all_explicit(node)
-          node.each_descendant(:block).with_object({}) do |child, h|
-            name = yield(child)
-            next unless name
-
-            outer_example_group = child.each_ancestor(:block).find do |a|
-              example_group?(a)
-            end
-
-            h[outer_example_group] ||= []
-            h[outer_example_group] << name
-          end
-        end
-
-        def find_subject_expectations(node, subject_names = [], &block)
-          subject_names = [*subject_names, *@explicit_subjects[node]]
-          subject_names -= @subject_overrides[node] if @subject_overrides[node]
-
-          names = Set[*subject_names, :subject]
-          expectation_detected = message_expectation?(node, names)
-          return yield(node) if expectation_detected
-
-          node.each_child_node(:send, :def, :block, :begin) do |child|
-            find_subject_expectations(child, subject_names, &block)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/unspecified_exception.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/unspecified_exception.rb
deleted file mode 100644
index 257aafc28140c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/unspecified_exception.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for a specified error in checking raised errors.
-      #
-      # Enforces one of an Exception type, a string, or a regular
-      # expression to match against the exception message as a parameter
-      # to `raise_error`
-      #
-      # @example
-      #
-      #     # bad
-      #     expect {
-      #       raise StandardError.new('error')
-      #     }.to raise_error
-      #
-      #     # good
-      #     expect {
-      #       raise StandardError.new('error')
-      #     }.to raise_error(StandardError)
-      #
-      #     expect {
-      #       raise StandardError.new('error')
-      #     }.to raise_error('error')
-      #
-      #     expect {
-      #       raise StandardError.new('error')
-      #     }.to raise_error(/err/)
-      #
-      #     expect { do_something }.not_to raise_error
-      class UnspecifiedException < Base
-        MSG = 'Specify the exception being captured'
-        RESTRICT_ON_SEND = %i[to].freeze
-
-        # @!method empty_raise_error_or_exception(node)
-        def_node_matcher :empty_raise_error_or_exception, <<-PATTERN
-          (send
-            (block
-                (send nil? :expect) ...)
-            :to
-            (send nil? {:raise_error :raise_exception})
-          )
-        PATTERN
-
-        def on_send(node)
-          return unless empty_exception_matcher?(node)
-
-          add_offense(node.children.last)
-        end
-
-        def empty_exception_matcher?(node)
-          empty_raise_error_or_exception(node) && !block_with_args?(node.parent)
-        end
-
-        def block_with_args?(node)
-          return unless node&.block_type?
-
-          node.arguments?
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_definition.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_definition.rb
deleted file mode 100644
index 3df2fc6d38002..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_definition.rb
+++ /dev/null
@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that memoized helpers names are symbols or strings.
-      #
-      # @example EnforcedStyle: symbols (default)
-      #   # bad
-      #   subject('user') { create_user }
-      #   let('user_name') { 'Adam' }
-      #
-      #   # good
-      #   subject(:user) { create_user }
-      #   let(:user_name) { 'Adam' }
-      #
-      # @example EnforcedStyle: strings
-      #   # bad
-      #   subject(:user) { create_user }
-      #   let(:user_name) { 'Adam' }
-      #
-      #   # good
-      #   subject('user') { create_user }
-      #   let('user_name') { 'Adam' }
-      class VariableDefinition < Base
-        extend AutoCorrector
-        include ConfigurableEnforcedStyle
-        include Variable
-
-        MSG = 'Use %<style>s for variable names.'
-
-        def on_send(node)
-          variable_definition?(node) do |variable|
-            next unless style_violation?(variable)
-
-            add_offense(
-              variable,
-              message: format(MSG, style: style)
-            ) do |corrector|
-              corrector.replace(variable, correct_variable(variable))
-            end
-          end
-        end
-
-        private
-
-        def correct_variable(variable)
-          case variable.type
-          when :dsym
-            variable.source[1..]
-          when :sym
-            variable.value.to_s.inspect
-          else
-            variable.value.to_sym.inspect
-          end
-        end
-
-        def style_violation?(variable)
-          style == :symbols && string?(variable) ||
-            style == :strings && symbol?(variable)
-        end
-
-        def string?(node)
-          node.str_type?
-        end
-
-        def symbol?(node)
-          node.sym_type? || node.dsym_type?
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_name.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_name.rb
deleted file mode 100644
index ed93a6e284ade..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_name.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that memoized helper names use the configured style.
-      #
-      # Variables can be excluded from checking using the `IgnoredPatterns`
-      # option.
-      #
-      # @example EnforcedStyle: snake_case (default)
-      #   # bad
-      #   subject(:userName1) { 'Adam' }
-      #   let(:userName2) { 'Adam' }
-      #
-      #   # good
-      #   subject(:user_name_1) { 'Adam' }
-      #   let(:user_name_2) { 'Adam' }
-      #
-      # @example EnforcedStyle: camelCase
-      #   # bad
-      #   subject(:user_name_1) { 'Adam' }
-      #   let(:user_name_2) { 'Adam' }
-      #
-      #   # good
-      #   subject(:userName1) { 'Adam' }
-      #   let(:userName2) { 'Adam' }
-      #
-      # @example IgnoredPatterns configuration
-      #
-      #   # rubocop.yml
-      #   # RSpec/VariableName:
-      #   #   EnforcedStyle: snake_case
-      #   #   IgnoredPatterns:
-      #   #     - ^userFood
-      #
-      # @example
-      #   # okay because it matches the `^userFood` regex in `IgnoredPatterns`
-      #   subject(:userFood_1) { 'spaghetti' }
-      #   let(:userFood_2) { 'fettuccine' }
-      #
-      class VariableName < Base
-        include ConfigurableNaming
-        include IgnoredPattern
-        include Variable
-
-        MSG = 'Use %<style>s for variable names.'
-
-        def on_send(node)
-          variable_definition?(node) do |variable|
-            return if variable.dstr_type? || variable.dsym_type?
-            return if matches_ignored_pattern?(variable.value)
-
-            check_name(node, variable.value, variable.loc.expression)
-          end
-        end
-
-        private
-
-        def message(style)
-          format(MSG, style: style)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_double_reference.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_double_reference.rb
deleted file mode 100644
index 7d15199f53adf..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_double_reference.rb
+++ /dev/null
@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for consistent verified double reference style.
-      #
-      # Only investigates references that are one of the supported styles.
-      #
-      # @see https://relishapp.com/rspec/rspec-mocks/docs/verifying-doubles
-      #
-      # This cop can be configured in your configuration using the
-      # `EnforcedStyle` option and supports `--auto-gen-config`.
-      #
-      # @example `EnforcedStyle: constant` (default)
-      #   # bad
-      #   let(:foo) do
-      #     instance_double('ClassName', method_name: 'returned_value')
-      #   end
-      #
-      #   # good
-      #   let(:foo) do
-      #     instance_double(ClassName, method_name: 'returned_value')
-      #   end
-      #
-      # @example `EnforcedStyle: string`
-      #   # bad
-      #   let(:foo) do
-      #     instance_double(ClassName, method_name: 'returned_value')
-      #   end
-      #
-      #   # good
-      #   let(:foo) do
-      #     instance_double('ClassName', method_name: 'returned_value')
-      #   end
-      #
-      # @example Reference is not in the supported style list. No enforcement
-      #
-      #   # good
-      #   let(:foo) do
-      #     instance_double(@klass, method_name: 'returned_value')
-      #   end
-      class VerifiedDoubleReference < Base
-        extend AutoCorrector
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Use a %<style>s class reference for verified doubles.'
-
-        RESTRICT_ON_SEND = Set[
-          :class_double,
-          :class_spy,
-          :instance_double,
-          :instance_spy,
-          :mock_model,
-          :object_double,
-          :object_spy,
-          :stub_model
-        ].freeze
-
-        REFERENCE_TYPE_STYLES = {
-          str: :string,
-          const: :constant
-        }.freeze
-
-        # @!method verified_double(node)
-        def_node_matcher :verified_double, <<~PATTERN
-          (send
-            nil?
-            RESTRICT_ON_SEND
-            $_class_reference
-            ...)
-        PATTERN
-
-        def on_send(node)
-          verified_double(node) do |class_reference|
-            break correct_style_detected unless opposing_style?(class_reference)
-
-            message = format(MSG, style: style)
-            expression = class_reference.loc.expression
-
-            add_offense(expression, message: message) do |corrector|
-              violation = class_reference.children.last.to_s
-              corrector.replace(expression, correct_style(violation))
-
-              opposite_style_detected
-            end
-          end
-        end
-
-        private
-
-        def opposing_style?(class_reference)
-          class_reference_style = REFERENCE_TYPE_STYLES[class_reference.type]
-
-          # Only enforce supported styles
-          return false unless class_reference_style
-
-          class_reference_style != style
-        end
-
-        def correct_style(violation)
-          if style == :string
-            "'#{violation}'"
-          else
-            violation
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_doubles.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_doubles.rb
deleted file mode 100644
index 3e04cef562424..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_doubles.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Prefer using verifying doubles over normal doubles.
-      #
-      # @see https://relishapp.com/rspec/rspec-mocks/docs/verifying-doubles
-      #
-      # @example
-      #   # bad
-      #   let(:foo) do
-      #     double(method_name: 'returned value')
-      #   end
-      #
-      #   # bad
-      #   let(:foo) do
-      #     double("ClassName", method_name: 'returned value')
-      #   end
-      #
-      #   # good
-      #   let(:foo) do
-      #     instance_double("ClassName", method_name: 'returned value')
-      #   end
-      class VerifiedDoubles < Base
-        MSG = 'Prefer using verifying doubles over normal doubles.'
-        RESTRICT_ON_SEND = %i[double spy].freeze
-
-        # @!method unverified_double(node)
-        def_node_matcher :unverified_double, <<-PATTERN
-          {(send nil? {:double :spy} $...)}
-        PATTERN
-
-        def on_send(node)
-          unverified_double(node) do |name, *_args|
-            return if name.nil? && cop_config['IgnoreNameless']
-            return if symbol?(name) && cop_config['IgnoreSymbolicNames']
-
-            add_offense(node)
-          end
-        end
-
-        private
-
-        def symbol?(name)
-          name&.sym_type?
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/void_expect.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/void_expect.rb
deleted file mode 100644
index f63a993b72ab2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/void_expect.rb
+++ /dev/null
@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks void `expect()`.
-      #
-      # @example
-      #   # bad
-      #   expect(something)
-      #
-      #   # good
-      #   expect(something).to be(1)
-      class VoidExpect < Base
-        MSG = 'Do not use `expect()` without `.to` or `.not_to`. ' \
-              'Chain the methods or remove it.'
-        RESTRICT_ON_SEND = %i[expect].freeze
-
-        # @!method expect?(node)
-        def_node_matcher :expect?, <<-PATTERN
-          (send nil? :expect ...)
-        PATTERN
-
-        # @!method expect_block?(node)
-        def_node_matcher :expect_block?, <<-PATTERN
-          (block #expect? (args) _body)
-        PATTERN
-
-        def on_send(node)
-          return unless expect?(node)
-
-          check_expect(node)
-        end
-
-        def on_block(node)
-          return unless expect_block?(node)
-
-          check_expect(node)
-        end
-
-        private
-
-        def check_expect(node)
-          return unless void?(node)
-
-          add_offense(node)
-        end
-
-        def void?(expect)
-          parent = expect.parent
-          return true unless parent
-          return true if parent.begin_type?
-          return true if parent.block_type? && parent.body == expect
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/yield.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/yield.rb
deleted file mode 100644
index 6a9d2e2094c40..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/yield.rb
+++ /dev/null
@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks for calling a block within a stub.
-      #
-      # @example
-      #   # bad
-      #   allow(foo).to receive(:bar) { |&block| block.call(1) }
-      #
-      #   # good
-      #   expect(foo).to receive(:bar).and_yield(1)
-      class Yield < Base
-        extend AutoCorrector
-        include RangeHelp
-
-        MSG = 'Use `.and_yield`.'
-
-        # @!method method_on_stub?(node)
-        def_node_search :method_on_stub?, '(send nil? :receive ...)'
-
-        # @!method block_arg(node)
-        def_node_matcher :block_arg, '(args (blockarg $_))'
-
-        # @!method block_call?(node)
-        def_node_matcher :block_call?, '(send (lvar %) :call ...)'
-
-        def on_block(node)
-          return unless method_on_stub?(node.send_node)
-
-          block_arg(node.arguments) do |block|
-            if calling_block?(node.body, block)
-              range = block_range(node)
-
-              add_offense(range) do |corrector|
-                autocorrect(corrector, node, range)
-              end
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node, range)
-          corrector.replace(
-            range_with_surrounding_space(range, side: :left),
-            generate_replacement(node.body)
-          )
-        end
-
-        def calling_block?(node, block)
-          if node.begin_type?
-            node.each_child_node.all? { |child| block_call?(child, block) }
-          else
-            block_call?(node, block)
-          end
-        end
-
-        def block_range(node)
-          node.loc.begin.with(end_pos: node.loc.end.end_pos)
-        end
-
-        def generate_replacement(node)
-          if node.begin_type?
-            node.children.map { |child| convert_block_to_yield(child) }.join
-          else
-            convert_block_to_yield(node)
-          end
-        end
-
-        def convert_block_to_yield(node)
-          args = node.arguments
-          replacement = '.and_yield'
-          replacement += "(#{args.map(&:source).join(', ')})" if args.any?
-          replacement
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec_cops.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec_cops.rb
deleted file mode 100644
index 3ce86db8b53a3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/cop/rspec_cops.rb
+++ /dev/null
@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'rspec/capybara/current_path_expectation'
-require_relative 'rspec/capybara/feature_methods'
-require_relative 'rspec/capybara/specific_matcher'
-require_relative 'rspec/capybara/visibility_matcher'
-
-require_relative 'rspec/factory_bot/attribute_defined_statically'
-require_relative 'rspec/factory_bot/create_list'
-require_relative 'rspec/factory_bot/factory_class_name'
-require_relative 'rspec/factory_bot/syntax_methods'
-
-require_relative 'rspec/rails/avoid_setup_hook'
-require_relative 'rspec/rails/have_http_status'
-begin
-  require_relative 'rspec/rails/http_status'
-rescue LoadError
-  # Rails/HttpStatus cannot be loaded if rack/utils is unavailable.
-end
-
-require_relative 'rspec/align_left_let_brace'
-require_relative 'rspec/align_right_let_brace'
-require_relative 'rspec/any_instance'
-require_relative 'rspec/around_block'
-require_relative 'rspec/be'
-require_relative 'rspec/be_eq'
-require_relative 'rspec/be_eql'
-require_relative 'rspec/be_nil'
-require_relative 'rspec/before_after_all'
-require_relative 'rspec/change_by_zero'
-require_relative 'rspec/context_method'
-require_relative 'rspec/context_wording'
-require_relative 'rspec/describe_class'
-require_relative 'rspec/describe_method'
-require_relative 'rspec/describe_symbol'
-require_relative 'rspec/described_class'
-require_relative 'rspec/described_class_module_wrapping'
-require_relative 'rspec/dialect'
-require_relative 'rspec/empty_example_group'
-require_relative 'rspec/empty_hook'
-require_relative 'rspec/empty_line_after_example'
-require_relative 'rspec/empty_line_after_example_group'
-require_relative 'rspec/empty_line_after_final_let'
-require_relative 'rspec/empty_line_after_hook'
-require_relative 'rspec/empty_line_after_subject'
-require_relative 'rspec/example_length'
-require_relative 'rspec/example_without_description'
-require_relative 'rspec/example_wording'
-require_relative 'rspec/excessive_docstring_spacing'
-require_relative 'rspec/expect_actual'
-require_relative 'rspec/expect_change'
-require_relative 'rspec/expect_in_hook'
-require_relative 'rspec/expect_output'
-require_relative 'rspec/file_path'
-require_relative 'rspec/focus'
-require_relative 'rspec/hook_argument'
-require_relative 'rspec/hooks_before_examples'
-require_relative 'rspec/identical_equality_assertion'
-require_relative 'rspec/implicit_block_expectation'
-require_relative 'rspec/implicit_expect'
-require_relative 'rspec/implicit_subject'
-require_relative 'rspec/instance_spy'
-require_relative 'rspec/instance_variable'
-require_relative 'rspec/it_behaves_like'
-require_relative 'rspec/iterated_expectation'
-require_relative 'rspec/leading_subject'
-require_relative 'rspec/leaky_constant_declaration'
-require_relative 'rspec/let_before_examples'
-require_relative 'rspec/let_setup'
-require_relative 'rspec/message_chain'
-require_relative 'rspec/message_expectation'
-require_relative 'rspec/message_spies'
-require_relative 'rspec/missing_example_group_argument'
-require_relative 'rspec/multiple_describes'
-require_relative 'rspec/multiple_expectations'
-require_relative 'rspec/multiple_memoized_helpers'
-require_relative 'rspec/multiple_subjects'
-require_relative 'rspec/named_subject'
-require_relative 'rspec/nested_groups'
-require_relative 'rspec/not_to_not'
-require_relative 'rspec/overwriting_setup'
-require_relative 'rspec/pending'
-require_relative 'rspec/predicate_matcher'
-require_relative 'rspec/receive_counts'
-require_relative 'rspec/receive_never'
-require_relative 'rspec/repeated_description'
-require_relative 'rspec/repeated_example'
-require_relative 'rspec/repeated_example_group_body'
-require_relative 'rspec/repeated_example_group_description'
-require_relative 'rspec/repeated_include_example'
-require_relative 'rspec/return_from_stub'
-require_relative 'rspec/scattered_let'
-require_relative 'rspec/scattered_setup'
-require_relative 'rspec/shared_context'
-require_relative 'rspec/shared_examples'
-require_relative 'rspec/single_argument_message_chain'
-require_relative 'rspec/stubbed_mock'
-require_relative 'rspec/subject_declaration'
-require_relative 'rspec/subject_stub'
-require_relative 'rspec/unspecified_exception'
-require_relative 'rspec/variable_definition'
-require_relative 'rspec/variable_name'
-require_relative 'rspec/verified_double_reference'
-require_relative 'rspec/verified_doubles'
-require_relative 'rspec/void_expect'
-require_relative 'rspec/yield'
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/align_let_brace.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/align_let_brace.rb
deleted file mode 100644
index d5c01fdc0c734..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/align_let_brace.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # Shared behavior for aligning braces for single line lets
-    class AlignLetBrace
-      include RuboCop::RSpec::Language
-      include RuboCop::Cop::Util
-
-      def initialize(root, token)
-        @root  = root
-        @token = token
-      end
-
-      def offending_tokens
-        single_line_lets.reject do |let|
-          target_column_for(let) == let_token(let).column
-        end
-      end
-
-      def indent_for(node)
-        ' ' * (target_column_for(node) - let_token(node).column)
-      end
-
-      private
-
-      def let_token(node)
-        node.loc.public_send(token)
-      end
-
-      def target_column_for(let)
-        let_group_for(let).map { |member| let_token(member).column }.max
-      end
-
-      def let_group_for(let)
-        adjacent_let_chunks.detect do |chunk|
-          chunk.any? do |member|
-            member == let && same_line?(member, let)
-          end
-        end
-      end
-
-      def adjacent_let_chunks
-        last_line = nil
-
-        single_line_lets.chunk do |node|
-          line      = node.loc.line
-          last_line = (line if last_line.nil? || last_line + 1 == line)
-          last_line.nil?
-        end.map(&:last)
-      end
-
-      def single_line_lets
-        @single_line_lets ||=
-          root.each_node(:block).select do |node|
-            let?(node) && node.single_line?
-          end
-      end
-
-      attr_reader :root, :token
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/concept.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/concept.rb
deleted file mode 100644
index 53790a1ec8e35..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/concept.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # Wrapper for RSpec DSL methods
-    class Concept
-      extend RuboCop::NodePattern::Macros
-      extend Language::NodePattern
-      include Language
-
-      def initialize(node)
-        @node = node
-      end
-
-      def eql?(other)
-        node == other.node
-      end
-
-      alias == eql?
-
-      def hash
-        [self.class, node].hash
-      end
-
-      def to_node
-        node
-      end
-
-      protected
-
-      attr_reader :node
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/config_formatter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/config_formatter.rb
deleted file mode 100644
index f9c16352e87f9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/config_formatter.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-
-module RuboCop
-  module RSpec
-    # Builds a YAML config file from two config hashes
-    class ConfigFormatter
-      EXTENSION_ROOT_DEPARTMENT = %r{^(RSpec/)}.freeze
-      SUBDEPARTMENTS = %(RSpec/Capybara RSpec/FactoryBot RSpec/Rails)
-      AMENDMENTS = %(Metrics/BlockLength)
-      COP_DOC_BASE_URL = 'https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/'
-
-      def initialize(config, descriptions)
-        @config       = config
-        @descriptions = descriptions
-      end
-
-      def dump
-        YAML.dump(unified_config)
-          .gsub(EXTENSION_ROOT_DEPARTMENT, "\n\\1")
-          .gsub(*AMENDMENTS, "\n\\0")
-          .gsub(/^(\s+)- /, '\1  - ')
-      end
-
-      private
-
-      def unified_config
-        cops.each_with_object(config.dup) do |cop, unified|
-          next if SUBDEPARTMENTS.include?(cop)
-          next if AMENDMENTS.include?(cop)
-
-          unified[cop].merge!(descriptions.fetch(cop))
-          unified[cop]['Reference'] = COP_DOC_BASE_URL + cop.sub('RSpec/', '')
-        end
-      end
-
-      def cops
-        (descriptions.keys | config.keys).grep(EXTENSION_ROOT_DEPARTMENT)
-      end
-
-      attr_reader :config, :descriptions
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/corrector/move_node.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/corrector/move_node.rb
deleted file mode 100644
index 3e07e49d54921..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/corrector/move_node.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    module Corrector
-      # Helper methods to move a node
-      class MoveNode
-        include RuboCop::Cop::RangeHelp
-        include RuboCop::Cop::RSpec::CommentsHelp
-        include RuboCop::Cop::RSpec::FinalEndLocation
-
-        attr_reader :original, :corrector, :processed_source
-
-        def initialize(node, corrector, processed_source)
-          @original = node
-          @corrector = corrector
-          @processed_source = processed_source # used by RangeHelp
-        end
-
-        def move_before(other)
-          position = start_line_position(other)
-
-          corrector.insert_before(position, "#{source(original)}\n")
-          corrector.remove(node_range_with_surrounding_space(original))
-        end
-
-        def move_after(other)
-          position = end_line_position(other)
-
-          corrector.insert_after(position, "\n#{source(original)}")
-          corrector.remove(node_range_with_surrounding_space(original))
-        end
-
-        private
-
-        def source(node)
-          node_range(node).source
-        end
-
-        def node_range(node)
-          source_range_with_comment(node)
-        end
-
-        def node_range_with_surrounding_space(node)
-          range = node_range(node)
-          range_by_whole_lines(range, include_final_newline: true)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/description_extractor.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/description_extractor.rb
deleted file mode 100644
index 52e71cb88b5e7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/description_extractor.rb
+++ /dev/null
@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # Extracts cop descriptions from YARD docstrings
-    class DescriptionExtractor
-      def initialize(yardocs)
-        @code_objects = yardocs.map(&CodeObject.public_method(:new))
-      end
-
-      def to_h
-        code_objects
-          .select(&:rspec_cop?)
-          .map(&:configuration)
-          .reduce(:merge)
-      end
-
-      private
-
-      attr_reader :code_objects
-
-      # Decorator of a YARD code object for working with documented rspec cops
-      class CodeObject
-        COP_CLASS_NAME = 'RuboCop::Cop::RSpec::Base'
-        RSPEC_NAMESPACE = 'RuboCop::Cop::RSpec'
-
-        def initialize(yardoc)
-          @yardoc = yardoc
-        end
-
-        # Test if the YARD code object documents a concrete rspec cop class
-        #
-        # @return [Boolean]
-        def rspec_cop?
-          class_documentation? &&
-            rspec_cop_namespace? &&
-            cop_subclass? &&
-            !abstract?
-        end
-
-        # Configuration for the documented cop that would live in default.yml
-        #
-        # @return [Hash]
-        def configuration
-          { cop_name => { 'Description' => description } }
-        end
-
-        private
-
-        def cop_name
-          Object.const_get(documented_constant).cop_name
-        end
-
-        def description
-          yardoc.docstring.split("\n\n").first.to_s
-        end
-
-        def class_documentation?
-          yardoc.type.equal?(:class)
-        end
-
-        def rspec_cop_namespace?
-          documented_constant.start_with?(RSPEC_NAMESPACE)
-        end
-
-        def documented_constant
-          yardoc.to_s
-        end
-
-        def cop_subclass?
-          yardoc.superclass.path == COP_CLASS_NAME
-        end
-
-        def abstract?
-          yardoc.tags.any? { |tag| tag.tag_name.eql?('abstract') }
-        end
-
-        attr_reader :yardoc
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/example.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/example.rb
deleted file mode 100644
index ff008d8408110..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/example.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # Wrapper for RSpec examples
-    class Example < Concept
-      # @!method extract_doc_string(node)
-      def_node_matcher :extract_doc_string,     '(send _ _ $_ ...)'
-
-      # @!method extract_metadata(node)
-      def_node_matcher :extract_metadata,       '(send _ _ _ $...)'
-
-      # @!method extract_implementation(node)
-      def_node_matcher :extract_implementation, '(block send args $_)'
-
-      def doc_string
-        extract_doc_string(definition)
-      end
-
-      def metadata
-        extract_metadata(definition)
-      end
-
-      def implementation
-        extract_implementation(node)
-      end
-
-      def definition
-        if node.send_type?
-          node
-        else
-          node.send_node
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/example_group.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/example_group.rb
deleted file mode 100644
index 9c993f9efc993..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/example_group.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # Wrapper for RSpec example groups
-    class ExampleGroup < Concept
-      # @!method scope_change?(node)
-      #
-      #   Detect if the node is an example group or shared example
-      #
-      #   Selectors which indicate that we should stop searching
-      #
-      def_node_matcher :scope_change?,
-                       block_pattern(<<~PATTERN)
-                         {
-                           #SharedGroups.all
-                           #ExampleGroups.all
-                           #Includes.all
-                         }
-                       PATTERN
-
-      def lets
-        find_all_in_scope(node, :let?)
-      end
-
-      def subjects
-        find_all_in_scope(node, :subject?)
-      end
-
-      def examples
-        find_all_in_scope(node, :example?).map do |node|
-          Example.new(node)
-        end
-      end
-
-      def hooks
-        find_all_in_scope(node, :hook?).map do |node|
-          Hook.new(node)
-        end
-      end
-
-      private
-
-      # Recursively search for predicate within the current scope
-      #
-      # Searches node and halts when a scope change is detected
-      #
-      # @param node [RuboCop::AST::Node] node to recursively search
-      # @param predicate [Symbol] method to call with node as argument
-      #
-      # @return [Array<RuboCop::AST::Node>] discovered nodes
-      def find_all_in_scope(node, predicate)
-        node.each_child_node.flat_map do |child|
-          find_all(child, predicate)
-        end
-      end
-
-      def find_all(node, predicate)
-        if public_send(predicate, node)
-          [node]
-        elsif scope_change?(node) || example?(node)
-          []
-        else
-          find_all_in_scope(node, predicate)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot.rb
deleted file mode 100644
index 9fbda437fd0b5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot.rb
+++ /dev/null
@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # RuboCop FactoryBot project namespace
-    module FactoryBot
-      ATTRIBUTE_DEFINING_METHODS = %i[
-        factory
-        ignore
-        trait
-        traits_for_enum
-        transient
-      ].freeze
-
-      UNPROXIED_METHODS = %i[
-        __send__
-        __id__
-        nil?
-        send
-        object_id
-        extend
-        instance_eval
-        initialize
-        block_given?
-        raise
-        caller
-        method
-      ].freeze
-
-      DEFINITION_PROXY_METHODS = %i[
-        add_attribute
-        after
-        association
-        before
-        callback
-        ignore
-        initialize_with
-        sequence
-        skip_create
-        to_create
-      ].freeze
-
-      RESERVED_METHODS =
-        DEFINITION_PROXY_METHODS +
-        UNPROXIED_METHODS +
-        ATTRIBUTE_DEFINING_METHODS
-
-      private_constant(
-        :ATTRIBUTE_DEFINING_METHODS,
-        :UNPROXIED_METHODS,
-        :DEFINITION_PROXY_METHODS,
-        :RESERVED_METHODS
-      )
-
-      def self.attribute_defining_methods
-        ATTRIBUTE_DEFINING_METHODS
-      end
-
-      def self.reserved_methods
-        RESERVED_METHODS
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot/language.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot/language.rb
deleted file mode 100644
index 64f46458c5ae7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot/language.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    module FactoryBot
-      # Contains node matchers for common FactoryBot DSL.
-      module Language
-        extend RuboCop::NodePattern::Macros
-
-        # @!method factory_bot?(node)
-        def_node_matcher :factory_bot?, <<~PATTERN
-          (const {nil? cbase} {:FactoryGirl :FactoryBot})
-        PATTERN
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb
deleted file mode 100644
index d0272c156daf4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb
+++ /dev/null
@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # Wrapper for RSpec hook
-    class Hook < Concept
-      # @!method extract_metadata(node)
-      def_node_matcher :extract_metadata, <<~PATTERN
-        (block
-          (send _ _ #valid_scope? ? $...) ...
-        )
-      PATTERN
-
-      def name
-        node.method_name
-      end
-
-      def knowable_scope?
-        scope_argument.nil? ||
-          scope_argument.sym_type? ||
-          scope_argument.hash_type?
-      end
-
-      def example?
-        scope.equal?(:each)
-      end
-
-      def scope
-        return :each if scope_argument&.hash_type?
-
-        case scope_name
-        when nil, :each, :example then :each
-        when :context, :all       then :context
-        when :suite               then :suite
-        end
-      end
-
-      def metadata
-        (extract_metadata(node) || [])
-          .map { |meta| transform_metadata(meta) }
-          .flatten
-          .inject(&:merge)
-      end
-
-      private
-
-      def valid_scope?(node)
-        node&.sym_type? && Language::HookScopes.all(node.value)
-      end
-
-      def transform_metadata(meta)
-        if meta.sym_type?
-          { meta => true }
-        else
-          # This check is to be able to compare those two hooks:
-          #
-          #   before(:example, :special) { ... }
-          #   before(:example, special: true) { ... }
-          #
-          # In the second case it's a node with a pair that has a value
-          # of a `true_type?`.
-          meta.pairs.map { |pair| { pair.key => transform_true(pair.value) } }
-        end
-      end
-
-      def transform_true(node)
-        node.true_type? ? true : node
-      end
-
-      def scope_name
-        scope_argument.to_a.first
-      end
-
-      def scope_argument
-        node.send_node.first_argument
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/inject.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/inject.rb
deleted file mode 100644
index 02424bc2c77a9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/inject.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
-    # bit of our configuration.
-    module Inject
-      def self.defaults!
-        project_root = Pathname.new(__dir__).parent.parent.parent.expand_path
-        config_default = project_root.join('config', 'default.yml')
-        path = config_default.to_s
-        hash = ConfigLoader.send(:load_yaml_configuration, path)
-        config = RuboCop::Config.new(hash, path)
-        puts "configuration from #{path}" if ConfigLoader.debug?
-        config = ConfigLoader.merge_with_default(config, path)
-        ConfigLoader.instance_variable_set(:@default_configuration, config)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb
deleted file mode 100644
index da2c19b2588af..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb
+++ /dev/null
@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # Contains node matchers for common RSpec DSL.
-    #
-    # RSpec allows for configuring aliases for commonly used DSL elements, e.g.
-    # example groups and hooks. It is possible to configure RuboCop RSpec to
-    # be able to properly detect these elements in the `RSpec/Language` section
-    # of the RuboCop YAML configuration file.
-    #
-    # In addition to providing useful matchers, this class is responsible for
-    # using the configured aliases.
-    module Language
-      extend RuboCop::NodePattern::Macros
-      extend NodePattern
-
-      class << self
-        attr_accessor :config
-      end
-
-      # @!method rspec?(node)
-      def_node_matcher :rspec?, '{(const {nil? cbase} :RSpec) nil?}'
-
-      # @!method example_group?(node)
-      def_node_matcher :example_group?, block_pattern('#ExampleGroups.all')
-
-      # @!method shared_group?(node)
-      def_node_matcher :shared_group?, block_pattern('#SharedGroups.all')
-
-      # @!method spec_group?(node)
-      def_node_matcher :spec_group?,
-                       block_pattern('{#SharedGroups.all #ExampleGroups.all}')
-
-      # @!method example_group_with_body?(node)
-      def_node_matcher :example_group_with_body?, <<-PATTERN
-        (block #{send_pattern('#ExampleGroups.all')} args !nil?)
-      PATTERN
-
-      # @!method example?(node)
-      def_node_matcher :example?, block_pattern('#Examples.all')
-
-      # @!method hook?(node)
-      def_node_matcher :hook?, block_pattern('#Hooks.all')
-
-      # @!method let?(node)
-      def_node_matcher :let?, <<-PATTERN
-        {
-          #{block_pattern('#Helpers.all')}
-          (send #rspec? #Helpers.all _ block_pass)
-        }
-      PATTERN
-
-      # @!method include?(node)
-      def_node_matcher :include?, <<-PATTERN
-        {
-          #{send_pattern('#Includes.all')}
-          #{block_pattern('#Includes.all')}
-        }
-      PATTERN
-
-      # @!method subject?(node)
-      def_node_matcher :subject?, block_pattern('#Subjects.all')
-
-      module ExampleGroups # :nodoc:
-        class << self
-          def all(element)
-            regular(element) ||
-              skipped(element) ||
-              focused(element)
-          end
-
-          def regular(element)
-            Language.config['ExampleGroups']['Regular'].include?(element.to_s)
-          end
-
-          def focused(element)
-            Language.config['ExampleGroups']['Focused'].include?(element.to_s)
-          end
-
-          def skipped(element)
-            Language.config['ExampleGroups']['Skipped'].include?(element.to_s)
-          end
-        end
-      end
-
-      module Examples # :nodoc:
-        class << self
-          def all(element)
-            regular(element) ||
-              focused(element) ||
-              skipped(element) ||
-              pending(element)
-          end
-
-          def regular(element)
-            Language.config['Examples']['Regular'].include?(element.to_s)
-          end
-
-          def focused(element)
-            Language.config['Examples']['Focused'].include?(element.to_s)
-          end
-
-          def skipped(element)
-            Language.config['Examples']['Skipped'].include?(element.to_s)
-          end
-
-          def pending(element)
-            Language.config['Examples']['Pending'].include?(element.to_s)
-          end
-        end
-      end
-
-      module Expectations # :nodoc:
-        def self.all(element)
-          Language.config['Expectations'].include?(element.to_s)
-        end
-      end
-
-      module Helpers # :nodoc:
-        def self.all(element)
-          Language.config['Helpers'].include?(element.to_s)
-        end
-      end
-
-      module Hooks # :nodoc:
-        def self.all(element)
-          Language.config['Hooks'].include?(element.to_s)
-        end
-      end
-
-      module HookScopes # :nodoc:
-        def self.all(element)
-          Language.config['HookScopes'].include?(element.to_s)
-        end
-      end
-
-      module Includes # :nodoc:
-        class << self
-          def all(element)
-            examples(element) ||
-              context(element)
-          end
-
-          def examples(element)
-            Language.config['Includes']['Examples'].include?(element.to_s)
-          end
-
-          def context(element)
-            Language.config['Includes']['Context'].include?(element.to_s)
-          end
-        end
-      end
-
-      module Runners # :nodoc:
-        def self.all(element)
-          Language.config['Runners'].include?(element.to_s)
-        end
-      end
-
-      module SharedGroups # :nodoc:
-        class << self
-          def all(element)
-            examples(element) ||
-              context(element)
-          end
-
-          def examples(element)
-            Language.config['SharedGroups']['Examples'].include?(element.to_s)
-          end
-
-          def context(element)
-            Language.config['SharedGroups']['Context'].include?(element.to_s)
-          end
-        end
-      end
-
-      module Subjects # :nodoc:
-        def self.all(element)
-          Language.config['Subjects'].include?(element.to_s)
-        end
-      end
-
-      # This is used in Dialect and DescribeClass cops to detect RSpec blocks.
-      module ALL # :nodoc:
-        def self.all(element)
-          [ExampleGroups, Examples, Expectations, Helpers, Hooks, Includes,
-           Runners, SharedGroups, Subjects]
-            .find { |concept| concept.all(element) }
-        end
-      end
-
-      private_constant :ExampleGroups, :Examples, :Expectations, :Hooks,
-                       :Includes, :Runners, :SharedGroups, :ALL
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/language/node_pattern.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/language/node_pattern.rb
deleted file mode 100644
index 486516206a266..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/language/node_pattern.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    module Language
-      # Helper methods to detect RSpec DSL used with send and block
-      module NodePattern
-        def send_pattern(string)
-          "(send #rspec? #{string} ...)"
-        end
-
-        def block_pattern(string)
-          "(block #{send_pattern(string)} ...)"
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/node.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/node.rb
deleted file mode 100644
index 2721e9fe2f0c7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/node.rb
+++ /dev/null
@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # RuboCop RSpec specific extensions of RuboCop::AST::Node
-    module Node
-      # In various cops we want to regard const as literal although it's not
-      # strictly literal.
-      def recursive_literal_or_const?
-        case type
-        when :begin, :pair, *AST::Node::COMPOSITE_LITERALS
-          children.all?(&:recursive_literal_or_const?)
-        else
-          literal? || const_type?
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/version.rb
deleted file mode 100644
index bccbd57809c53..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/version.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # Version information for the RSpec RuboCop plugin.
-    module Version
-      STRING = '2.12.1'
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb
deleted file mode 100644
index 736c54f48251e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb
+++ /dev/null
@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # RSpec example wording rewriter
-    class Wording
-      SHOULDNT_PREFIX    = /\Ashould(?:n't| not)\b/i.freeze
-      SHOULDNT_BE_PREFIX = /#{SHOULDNT_PREFIX} be\b/i.freeze
-      ES_SUFFIX_PATTERN  = /(?:o|s|x|ch|sh|z)\z/i.freeze
-      IES_SUFFIX_PATTERN = /[^aeou]y\z/i.freeze
-
-      def initialize(text, ignore:, replace:)
-        @text         = text
-        @ignores      = ignore
-        @replacements = replace
-      end
-
-      def rewrite
-        case text
-        when SHOULDNT_BE_PREFIX
-          replace_prefix(SHOULDNT_BE_PREFIX, 'is not')
-        when SHOULDNT_PREFIX
-          replace_prefix(SHOULDNT_PREFIX, 'does not')
-        else
-          remove_should_and_pluralize
-        end
-      end
-
-      private
-
-      attr_reader :text, :ignores, :replacements
-
-      def replace_prefix(pattern, replacement)
-        text.sub(pattern) do |shouldnt|
-          uppercase?(shouldnt) ? replacement.upcase : replacement
-        end
-      end
-
-      def uppercase?(word)
-        word.upcase.eql?(word)
-      end
-
-      def remove_should_and_pluralize
-        _should, *words = text.split
-
-        words.each_with_index do |word, index|
-          next if ignored_word?(word)
-
-          words[index] = substitute(word)
-
-          break
-        end
-
-        words.join(' ')
-      end
-
-      def ignored_word?(word)
-        ignores.any? { |ignore| ignore.casecmp(word).zero? }
-      end
-
-      def substitute(word)
-        # NOTE: Custom replacements are case sensitive.
-        return replacements.fetch(word) if replacements.key?(word)
-
-        case word
-        when ES_SUFFIX_PATTERN  then append_suffix(word, 'es')
-        when IES_SUFFIX_PATTERN then append_suffix(word[0..-2], 'ies')
-        else append_suffix(word, 's')
-        end
-      end
-
-      def append_suffix(word, suffix)
-        suffix = suffix.upcase if uppercase?(word)
-
-        "#{word}#{suffix}"
-      end
-
-      private_constant(*constants(false))
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/config/default.yml b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/config/default.yml
deleted file mode 100644
index e9edad4fbad98..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/config/default.yml
+++ /dev/null
@@ -1,229 +0,0 @@
-inherit_mode:
-  merge:
-  - Exclude
-
-Sorbet/AllowIncompatibleOverride:
-  Description: 'Disallows using `.override(allow_incompatible: true)`.'
-  Enabled: true
-  VersionAdded: 0.2.0
-
-Sorbet/BindingConstantWithoutTypeAlias:
-  Description: >-
-                  Disallows binding the return value of `T.any`, `T.all`, `T.enum`
-                  to a constant directly. To bind the value, one must use `T.type_alias`.
-  Enabled: true
-  VersionAdded: 0.2.0
-
-Sorbet/CallbackConditionalsBinding:
-  Description: 'Ensures callback conditionals are bound to the right type.'
-  Enabled: false
-  Safe: false
-  VersionAdded: 0.7.0
-
-Sorbet/CheckedTrueInSignature:
-  Description: 'Disallows the usage of `checked(true)` in signatures.'
-  Enabled: true
-  VersionAdded: 0.2.0
-
-Sorbet/ConstantsFromStrings:
-  Description: >-
-                  Forbids constant access through meta-programming.
-
-                  For example, things like `constantize` or `const_get`
-                  are forbidden.
-  Enabled: true
-  VersionAdded: 0.2.0
-
-Sorbet/EnforceSigilOrder:
-  Description: 'Ensures that Sorbet sigil comes first in a file.'
-  Enabled: true
-  VersionAdded: 0.3.4
-
-Sorbet/EnforceSingleSigil:
-  Description: 'Ensures that there is only one Sorbet sigil in a file.'
-  Enabled: true
-  VersionAdded: '<<next>>'
-
-Sorbet/EnforceSignatures:
-  Description: 'Ensures all methods have a valid signature.'
-  Enabled: false
-  VersionAdded: 0.3.4
-
-Sorbet/FalseSigil:
-  Description: 'All files must be at least at strictness `false`.'
-  Enabled: true
-  VersionAdded: 0.3.3
-  SuggestedStrictness: "false"
-  Include:
-  - "**/*.{rb,rbi,rake,ru}"
-  Exclude:
-  - bin/**/*
-  - db/**/*.rb
-  - script/**/*
-
-Sorbet/ForbidExtendTSigHelpersInShims:
-  Description: 'Forbid the use of `extend T::Sig` and `extend T::Helpers` in RBI shims'
-  Enabled: true
-  VersionAdded: '0.6.0'
-  Include:
-  - "**/*.rbi"
-
-Sorbet/ForbidRBIOutsideOfAllowedPaths:
-  Description: 'Forbids RBI files outside of the allowed paths'
-  Enabled: true
-  VersionAdded: 0.6.1
-  AllowedPaths:
-  - "sorbet/rbi/**"
-  Include:
-  - "**/*.rbi"
-
-Sorbet/ForbidIncludeConstLiteral:
-  Description: 'Forbids include of non-literal constants.'
-  Enabled: false
-  VersionAdded: 0.2.0
-  VersionChanged: 0.5.0
-
-Sorbet/ForbidSuperclassConstLiteral:
-  Description: 'Forbid superclasses which are non-literal constants.'
-  Enabled: false
-  VersionAdded: 0.2.0
-  VersionChanged: 0.6.1
-  Exclude:
-  - db/migrate/*.rb
-
-Sorbet/ForbidTUnsafe:
-  Description: 'Forbid usage of T.unsafe.'
-  Enabled: false
-  VersionAdded: 0.7.0
-  VersionChanged: 0.7.0
-
-Sorbet/ForbidTUntyped:
-  Description: 'Forbid usage of T.untyped'
-  Enabled: false
-  VersionAdded: 0.6.9
-  VersionChanged: 0.7.0
-
-Sorbet/ForbidUntypedStructProps:
-  Description: >-
-                  Disallows use of `T.untyped` or `T.nilable(T.untyped)` as a
-                  prop type for `T::Struct` subclasses.
-  Enabled: true
-  VersionAdded: 0.4.0
-
-Sorbet/HasSigil:
-  Description: 'Makes the Sorbet typed sigil mandatory in all files.'
-  Enabled: false
-  SuggestedStrictness: "false"
-  MinimumStrictness: "false"
-  VersionAdded: 0.3.3
-  Include:
-  - "**/*.{rb,rbi,rake,ru}"
-  Exclude:
-  - bin/**/*
-  - db/**/*.rb
-  - script/**/*
-
-Sorbet/IgnoreSigil:
-  Description: 'All files must be at least at strictness `ignore`.'
-  Enabled: false
-  SuggestedStrictness: "ignore"
-  VersionAdded: 0.3.3
-  Include:
-  - "**/*.{rb,rbi,rake,ru}"
-  Exclude:
-  - bin/**/*
-  - db/**/*.rb
-  - script/**/*
-
-Sorbet/KeywordArgumentOrdering:
-  Description: >-
-                  Enforces a compatible keyword arguments with Sorbet.
-
-                  All keyword arguments must be at the end of the parameters
-                  list, and all keyword arguments with a default value must be
-                  after those without default values.
-  Enabled: true
-  VersionAdded: 0.2.0
-
-Sorbet/OneAncestorPerLine:
-  Description: 'Enforces one ancestor per call to requires_ancestor'
-  Enabled: false
-  VersionAdded: '0.6.0'
-
-Sorbet/SignatureBuildOrder:
-  Description: >-
-                  Enforces the order of parts in a signature.
-
-                  The order is first inheritance related builders,
-                  then params, then return and finally the modifier
-                  such as: `abstract.params(...).returns(...).soft`.'
-  Enabled: true
-  VersionAdded: 0.3.0
-
-Sorbet/SingleLineRbiClassModuleDefinitions:
-  Description: 'Empty class and module definitions in RBI must be on a single line.'
-  Enabled: false
-  VersionAdded: '0.6.0'
-  Include:
-  - "**/*.rbi"
-
-Sorbet/StrictSigil:
-  Description: 'All files must be at least at strictness `strict`.'
-  Enabled: false
-  SuggestedStrictness: "strict"
-  VersionAdded: 0.3.3
-  Include:
-  - "**/*.{rb,rbi,rake,ru}"
-  Exclude:
-  - bin/**/*
-  - db/**/*.rb
-  - script/**/*
-
-Sorbet/StrongSigil:
-  Description: 'All files must be at least at strictness `strong`.'
-  Enabled: false
-  SuggestedStrictness: "strong"
-  VersionAdded: 0.3.3
-  Include:
-  - "**/*.{rb,rbi,rake,ru}"
-  Exclude:
-  - bin/**/*
-  - db/**/*.rb
-  - script/**/*
-
-Sorbet/TrueSigil:
-  Description: 'All files must be at least at strictness `true`.'
-  Enabled: false
-  SuggestedStrictness: "true"
-  VersionAdded: 0.3.3
-  Include:
-  - "**/*.{rb,rbi,rake,ru}"
-  Exclude:
-  - bin/**/*
-  - db/**/*.rb
-  - script/**/*
-
-Sorbet/TypeAliasName:
-  Description: 'Type alias constant names must be in CamelCase.'
-  Enabled: true
-  VersionAdded: 0.6.6
-  Include:
-  - "**/*.{rb,rbi,rake,ru}"
-  Exclude:
-  - bin/**/*
-  - db/**/*.rb
-  - script/**/*
-
-Sorbet/ValidSigil:
-  Description: 'All files must have a valid sigil.'
-  Enabled: true
-  RequireSigilOnAllFiles: false
-  SuggestedStrictness: "false"
-  MinimumStrictness: "false"
-  VersionAdded: 0.3.3
-  Include:
-  - "**/*.{rb,rbi,rake,ru}"
-  Exclude:
-  - bin/**/*
-  - db/**/*.rb
-  - script/**/*
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/config/rbi.yml b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/config/rbi.yml
deleted file mode 100644
index 63398c7c959c4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/config/rbi.yml
+++ /dev/null
@@ -1,272 +0,0 @@
-require:
-  - rubocop-sorbet
-
-AllCops:
-  TargetRubyVersion: 3.0
-  DisabledByDefault: true
-  Include:
-    - '**/*.rbi'
-
-## Layout
-
-Layout/AccessModifierIndentation:
-  Enabled: true
-
-Layout/ArgumentAlignment:
-  Enabled: true
-
-Layout/BlockAlignment:
-  Enabled: true
-
-Layout/BlockEndNewline:
-  Enabled: true
-
-Layout/ClassStructure:
-  Enabled: true
-  ExpectedOrder:
-    - module_inclusion
-    - constants
-    - macros
-    - public_attribute_macros
-    - protected_attribute_macros
-    - private_attribute_macros
-    - initializer
-    - public_methods
-    - protected_methods
-    - private_methods
-    - public_class_methods
-
-Layout/ClosingParenthesisIndentation:
-  Enabled: true
-
-Layout/CommentIndentation:
-  Enabled: true
-
-Layout/EmptyComment:
-  Enabled: true
-
-Layout/EmptyLineAfterMagicComment:
-  Enabled: true
-
-Layout/EmptyLineBetweenDefs:
-  Enabled: true
-  AllowAdjacentOneLineDefs: true
-
-Layout/EmptyLines:
-  Enabled: true
-
-Layout/EmptyLinesAroundAccessModifier:
-  Enabled: true
-
-Layout/EmptyLinesAroundArguments:
-  Enabled: true
-
-Layout/EmptyLinesAroundAttributeAccessor:
-  Enabled: true
-
-Layout/EmptyLinesAroundBlockBody:
-  Enabled: true
-
-Layout/EmptyLinesAroundClassBody:
-  Enabled: true
-
-Layout/EmptyLinesAroundModuleBody:
-  Enabled: true
-
-Layout/EndOfLine:
-  Enabled: true
-  EnforcedStyle: lf
-
-Layout/ExtraSpacing:
-  Enabled: true
-
-Layout/FirstMethodArgumentLineBreak:
-  Enabled: true
-
-Layout/FirstMethodParameterLineBreak:
-  Enabled: true
-
-Layout/FirstParameterIndentation:
-  Enabled: true
-
-Layout/IndentationConsistency:
-  Enabled: true
-
-Layout/IndentationStyle:
-  Enabled: true
-  EnforcedStyle: spaces
-
-Layout/IndentationWidth:
-  Enabled: true
-
-Layout/InitialIndentation:
-  Enabled: true
-
-Layout/LeadingCommentSpace:
-  Enabled: true
-
-Layout/LeadingEmptyLines:
-  Enabled: true
-
-# TODO: make Tapioca break long lines?
-Layout/LineLength:
-  Enabled: false
-
-Layout/MultilineBlockLayout:
-  Enabled: true
-
-Layout/MultilineMethodArgumentLineBreaks:
-  Enabled: true
-
-Layout/MultilineMethodCallBraceLayout:
-  Enabled: true
-
-Layout/MultilineMethodCallIndentation:
-  Enabled: true
-
-Layout/ParameterAlignment:
-  Enabled: true
-
-Layout/RedundantLineBreak:
-  Enabled: true
-  InspectBlocks: true
-
-Layout/SpaceAfterColon:
-  Enabled: true
-
-Layout/SpaceAfterComma:
-  Enabled: true
-
-Layout/SpaceAfterMethodName:
-  Enabled: true
-
-Layout/SpaceAfterSemicolon:
-  Enabled: true
-
-Layout/SpaceAroundEqualsInParameterDefault:
-  Enabled: true
-
-Layout/SpaceAroundKeyword:
-  Enabled: true
-
-Layout/SpaceAroundMethodCallOperator:
-  Enabled: true
-
-Layout/SpaceBeforeBlockBraces:
-  Enabled: true
-
-Layout/SpaceBeforeBrackets:
-  Enabled: true
-
-Layout/SpaceBeforeComma:
-  Enabled: true
-
-Layout/SpaceBeforeComment:
-  Enabled: true
-
-Layout/SpaceBeforeFirstArg:
-  Enabled: true
-
-Layout/SpaceBeforeSemicolon:
-  Enabled: true
-
-Layout/SpaceInsideParens:
-  Enabled: true
-
-Layout/TrailingEmptyLines:
-  Enabled: true
-  EnforcedStyle: final_newline
-
-Layout/TrailingWhitespace:
-  Enabled: true
-
-## Lint
-
-Lint/DuplicateMethods:
-  Enabled: true
-
-Lint/EmptyFile:
-  Enabled: true
-  AllowComments: false
-
-Lint/Syntax:
-  Enabled: true
-
-## Sorbet
-
-Sorbet:
-  DisabledByDefault: true
-
-Sorbet/EnforceSigilOrder:
-  Enabled: true
-
-Sorbet/EnforceSingleSigil:
-  Enabled: true
-
-Sorbet/ForbidExtendTSigHelpersInShims:
-  Enabled: true
-
-Sorbet/ForbidIncludeConstLiteral:
-  Enabled: true
-
-Sorbet/ForbidSuperclassConstLiteral:
-  Enabled: true
-
-Sorbet/OneAncestorPerLine:
-  Enabled: true
-
-Sorbet/SignatureBuildOrder:
-  Enabled: true
-
-Sorbet/SingleLineRbiClassModuleDefinitions:
-  Enabled: true
-
-Sorbet/TypeAliasName:
-  Enabled: true
-
-Sorbet/ValidSigil:
-  Enabled: true
-  RequireSigilOnAllFiles: true
-  MinimumStrictness: "false"
-  SuggestedStrictness: "true"
-
-## Style
-
-Style/BlockDelimiters:
-  Enabled: true
-
-Style/ClassAndModuleChildren:
-  Enabled: true
-  EnforcedStyle: compact
-
-Style/DefWithParentheses:
-  Enabled: true
-
-Style/EmptyMethod:
-  Enabled: true
-  EnforcedStyle: compact
-
-Style/FrozenStringLiteralComment:
-  Enabled: true
-  EnforcedStyle: never
-
-Style/MethodCallWithArgsParentheses:
-  Enabled: true
-  IgnoreMacros: true
-
-Style/MethodCallWithoutArgsParentheses:
-  Enabled: true
-
-Style/MethodDefParentheses:
-  Enabled: true
-
-Style/MixinGrouping:
-  Enabled: true
-  EnforcedStyle: separated
-
-Style/MixinUsage:
-  Enabled: true
-
-Style/ModuleFunction:
-  Enabled: true
-  EnforcedStyle: forbidden
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop-sorbet.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop-sorbet.rb
deleted file mode 100644
index cfa990a074193..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop-sorbet.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-
-require_relative "rubocop/sorbet"
-require_relative "rubocop/sorbet/version"
-require_relative "rubocop/sorbet/inject"
-
-RuboCop::Sorbet::Inject.defaults!
-
-require_relative "rubocop/cop/sorbet_cops"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb
deleted file mode 100644
index cc584413d1385..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb
+++ /dev/null
@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop disallows binding the return value of `T.any`, `T.all`, `T.enum`
-      # to a constant directly. To bind the value, one must use `T.type_alias`.
-      #
-      # @example
-      #
-      #   # bad
-      #   FooOrBar = T.any(Foo, Bar)
-      #
-      #   # good
-      #   FooOrBar = T.type_alias { T.any(Foo, Bar) }
-      class BindingConstantWithoutTypeAlias < RuboCop::Cop::Cop
-        def_node_matcher(:binding_unaliased_type?, <<-PATTERN)
-          (casgn _ _ [#not_nil? #not_t_let? #not_dynamic_type_creation_with_block? #not_generic_parameter_decl? #method_needing_aliasing_on_t?])
-        PATTERN
-
-        def_node_matcher(:using_type_alias?, <<-PATTERN)
-          (block
-            (send
-              (const nil? :T) :type_alias)
-              _
-              _
-          )
-        PATTERN
-
-        def_node_matcher(:using_deprecated_type_alias_syntax?, <<-PATTERN)
-          (
-            send
-            (const nil? :T)
-            :type_alias
-            _
-          )
-        PATTERN
-
-        def_node_matcher(:t_let?, <<-PATTERN)
-          (
-            send
-            (const nil? :T)
-            :let
-            _
-            _
-          )
-        PATTERN
-
-        def_node_matcher(:dynamic_type_creation_with_block?, <<-PATTERN)
-          (block
-            (send
-              const :new ...)
-              _
-              _
-          )
-        PATTERN
-
-        def_node_matcher(:generic_parameter_decl_call?, <<-PATTERN)
-          (
-            send nil? {:type_template :type_member} ...
-          )
-        PATTERN
-
-        def_node_matcher(:generic_parameter_decl_block_call?, <<-PATTERN)
-          (block
-            (send nil? {:type_template :type_member} ...) ...
-          )
-        PATTERN
-
-        def_node_search(:method_needing_aliasing_on_t?, <<-PATTERN)
-          (
-            send
-            (const nil? :T)
-            {:any :all :noreturn :class_of :untyped :nilable :self_type :enum :proc}
-             ...
-          )
-        PATTERN
-
-        def not_t_let?(node)
-          !t_let?(node)
-        end
-
-        def not_dynamic_type_creation_with_block?(node)
-          !dynamic_type_creation_with_block?(node)
-        end
-
-        def not_generic_parameter_decl?(node)
-          !generic_parameter_decl_call?(node) && !generic_parameter_decl_block_call?(node)
-        end
-
-        def not_nil?(node)
-          !node.nil?
-        end
-
-        def on_casgn(node)
-          return unless binding_unaliased_type?(node) && !using_type_alias?(node.children[2])
-          if using_deprecated_type_alias_syntax?(node.children[2])
-            add_offense(
-              node.children[2],
-              message: "It looks like you're using the old `T.type_alias` syntax. " \
-              "`T.type_alias` now expects a block." \
-              'Run Sorbet with the options "--autocorrect --error-white-list=5043" ' \
-              "to automatically upgrade to the new syntax."
-            )
-            return
-          end
-          add_offense(
-            node.children[2],
-            message: "It looks like you're trying to bind a type to a constant. " \
-            "To do this, you must alias the type using `T.type_alias`."
-          )
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(
-              node.source_range,
-              "T.type_alias { #{node.source} }"
-            )
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/callback_conditionals_binding.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/callback_conditionals_binding.rb
deleted file mode 100644
index 1f7ecf10ae619..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/callback_conditionals_binding.rb
+++ /dev/null
@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop ensures that callback conditionals are bound to the right type
-      # so that they are type checked properly.
-      #
-      # Auto-correction is unsafe because other libraries define similar style callbacks as Rails, but don't always need
-      # binding to the attached class. Auto-correcting those usages can lead to false positives and auto-correction
-      # introduces new typing errors.
-      #
-      # @example
-      #
-      #   # bad
-      #   class Post < ApplicationRecord
-      #     before_create :do_it, if: -> { should_do_it? }
-      #
-      #     def should_do_it?
-      #       true
-      #     end
-      #   end
-      #
-      #   # good
-      #   class Post < ApplicationRecord
-      #     before_create :do_it, if: -> {
-      #       T.bind(self, Post)
-      #       should_do_it?
-      #     }
-      #
-      #     def should_do_it?
-      #       true
-      #     end
-      #   end
-      class CallbackConditionalsBinding < RuboCop::Cop::Cop
-        CALLBACKS = [
-          :validate, :validates, :validates_with, :before_validation, :around_validation, :before_create,
-          :before_save, :before_destroy, :before_update, :after_create, :after_save, :after_destroy,
-          :after_update, :after_touch, :after_initialize, :after_find, :around_create, :around_save,
-          :around_destroy, :around_update, :before_commit, :after_commit, :after_create_commit,
-          :after_destroy_commit, :after_rollback, :after_save_commit, :after_update_commit,
-          :before_action, :prepend_before_action, :append_before_action, :around_action,
-          :prepend_around_action, :append_around_action, :after_action, :prepend_after_action,
-          :append_after_action
-        ].freeze
-
-        def autocorrect(node)
-          lambda do |corrector|
-            options = node.each_child_node.find(&:hash_type?)
-
-            conditional = nil
-            options.each_pair do |keyword, block|
-              if keyword.value == :if || keyword.value == :unless
-                conditional = block
-                break
-              end
-            end
-
-            _, _, block = conditional.child_nodes
-
-            # Find the class node and check if it includes a namespace on the
-            # same line e.g.: Namespace::Class, which will require the fully
-            # qualified name
-
-            klass = node.ancestors.find(&:class_type?)
-
-            expected_class = if klass.children.first.children.first.nil?
-              node.parent_module_name.split("::").last
-            else
-              klass.identifier.source
-            end
-
-            do_end_lambda = conditional.source.include?("do") && conditional.source.include?("end")
-
-            unless do_end_lambda
-              # We are converting a one line lambda into a multiline
-              # Remove the space after the `{`
-              if /{\s/.match?(conditional.source)
-                corrector.remove_preceding(block, 1)
-              end
-
-              # Remove the last space and `}` and re-add it with a line break
-              # and the correct indentation
-              base_indentation = " " * node.loc.column
-              chars_to_remove = /\s}/.match?(conditional.source) ? 2 : 1
-              corrector.remove_trailing(conditional, chars_to_remove)
-              corrector.insert_after(block, "\n#{base_indentation}}")
-            end
-
-            # Add the T.bind
-            indentation = " " * (node.loc.column + 2)
-            line_start = do_end_lambda ? "" : "\n#{indentation}"
-            bind = "#{line_start}T.bind(self, #{expected_class})\n#{indentation}"
-
-            corrector.insert_before(block, bind)
-          end
-        end
-
-        def on_send(node)
-          return unless CALLBACKS.include?(node.method_name)
-
-          options = node.each_child_node.find(&:hash_type?)
-          return if options.nil?
-
-          conditional = nil
-          options.each_pair do |keyword, block|
-            next unless keyword.sym_type?
-
-            if keyword.value == :if || keyword.value == :unless
-              conditional = block
-              break
-            end
-          end
-
-          return if conditional.nil? || conditional.array_type? || conditional.child_nodes.empty?
-
-          return unless conditional.arguments.empty?
-
-          type, _, block = conditional.child_nodes
-          return unless type.lambda_or_proc? || type.block_literal?
-
-          klass = node.ancestors.find(&:class_type?)
-
-          expected_class = if klass&.children&.first&.children&.first.nil?
-            node.parent_module_name&.split("::")&.last
-          else
-            klass.identifier.source
-          end
-
-          return if expected_class.nil?
-
-          unless block.source.include?("T.bind(self")
-            add_offense(
-              node,
-              message: "Callback conditionals should be bound to the right type. Use T.bind(self, #{expected_class})"
-            )
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/constants_from_strings.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/constants_from_strings.rb
deleted file mode 100644
index eccd55f402596..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/constants_from_strings.rb
+++ /dev/null
@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop disallows the calls that are used to get constants fom Strings
-      # such as +constantize+, +const_get+, and +constants+.
-      #
-      # The goal of this cop is to make the code easier to statically analyze,
-      # more IDE-friendly, and more predictable. It leads to code that clearly
-      # expresses which values the constant can have.
-      #
-      # @example
-      #
-      #   # bad
-      #   class_name.constantize
-      #
-      #   # bad
-      #   constants.detect { |c| c.name == "User" }
-      #
-      #   # bad
-      #   const_get(class_name)
-      #
-      #   # good
-      #   case class_name
-      #   when "User"
-      #     User
-      #   else
-      #     raise ArgumentError
-      #   end
-      #
-      #   # good
-      #   { "User" => User }.fetch(class_name)
-      class ConstantsFromStrings < ::RuboCop::Cop::Cop
-        def_node_matcher(:constant_from_string?, <<-PATTERN)
-          (send _ {:constantize :constants :const_get} ...)
-        PATTERN
-
-        def on_send(node)
-          return unless constant_from_string?(node)
-          add_offense(
-            node,
-            location: :selector,
-            message: "Don't use `#{node.method_name}`, it makes the code harder to understand, less editor-friendly, " \
-              "and impossible to analyze. Replace `#{node.method_name}` with a case/when or a hash."
-          )
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb
deleted file mode 100644
index 087e27d74b399..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-require "rubocop"
-
-# Correct `send` expressions in include statements by constant literals.
-#
-# Sorbet, the static checker, is not (yet) able to support constructs on the
-# following form:
-#
-# ```ruby
-# class MyClass
-#   include send_expr
-# end
-# ```
-#
-# Multiple occurences of this can be found in Shopify's code base like:
-#
-# ```ruby
-# include Rails.application.routes.url_helpers
-# ```
-# or
-# ```ruby
-# include Polaris::Engine.helpers
-# ```
-module RuboCop
-  module Cop
-    module Sorbet
-      class ForbidIncludeConstLiteral < RuboCop::Cop::Cop
-        MSG = "Includes must only contain constant literals"
-
-        attr_accessor :used_names
-
-        def_node_matcher :not_lit_const_include?, <<-PATTERN
-          (send nil? {:include :extend :prepend}
-            $_
-          )
-        PATTERN
-
-        def initialize(*)
-          super
-          self.used_names = Set.new
-        end
-
-        def on_send(node)
-          return unless not_lit_const_include?(node) do |send_argument|
-            ![:const, :self].include?(send_argument.type)
-          end
-          parent = node.parent
-          return unless parent
-          parent = parent.parent if [:begin, :block].include?(parent.type)
-          return unless [:module, :class, :sclass].include?(parent.type)
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(
-              node.source_range,
-              "T.unsafe(self).#{node.source}"
-            )
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb
deleted file mode 100644
index 97b6337c871d2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-require "rubocop"
-
-# Correct superclass `send` expressions by constant literals.
-#
-# Sorbet, the static checker, is not (yet) able to support constructs on the
-# following form:
-#
-# ```ruby
-# class Foo < send_expr; end
-# ```
-#
-# Multiple occurences of this can be found in Shopify's code base like:
-#
-# ```ruby
-# class ShopScope < Component::TrustedIdScope[ShopIdentity::ShopId]
-# ```
-# or
-# ```ruby
-# class ApiClientEligibility < Struct.new(:api_client, :match_results, :shop)
-# ```
-module RuboCop
-  module Cop
-    module Sorbet
-      class ForbidSuperclassConstLiteral < RuboCop::Cop::Cop
-        MSG = "Superclasses must only contain constant literals"
-
-        def_node_matcher :not_lit_const_superclass?, <<-PATTERN
-          (class
-            (const ...)
-            (send ...)
-            ...
-          )
-        PATTERN
-
-        def on_class(node)
-          return unless not_lit_const_superclass?(node)
-          add_offense(node.child_nodes[1])
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_t_unsafe.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_t_unsafe.rb
deleted file mode 100644
index 9f4280301c640..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_t_unsafe.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop disallows using `T.unsafe` anywhere.
-      #
-      # @example
-      #
-      #   # bad
-      #   T.unsafe(foo)
-      #
-      #   # good
-      #   foo
-      class ForbidTUnsafe < RuboCop::Cop::Cop
-        def_node_matcher(:t_unsafe?, "(send (const nil? :T) :unsafe _)")
-
-        def on_send(node)
-          add_offense(node, message: "Do not use `T.unsafe`.") if t_unsafe?(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_t_untyped.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_t_untyped.rb
deleted file mode 100644
index b6d4923e08631..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_t_untyped.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop disallows using `T.untyped` anywhere.
-      #
-      # @example
-      #
-      #   # bad
-      #   sig { params(my_argument: T.untyped).void }
-      #   def foo(my_argument); end
-      #
-      #   # good
-      #   sig { params(my_argument: String).void }
-      #   def foo(my_argument); end
-      #
-      class ForbidTUntyped < RuboCop::Cop::Cop
-        def_node_matcher(:t_untyped?, "(send (const nil? :T) :untyped)")
-
-        def on_send(node)
-          add_offense(node, message: "Do not use `T.untyped`.") if t_untyped?(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb
deleted file mode 100644
index 5fe2731b77204..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb
+++ /dev/null
@@ -1,58 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-require "rubocop"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop disallows use of `T.untyped` or `T.nilable(T.untyped)`
-      # as a prop type for `T::Struct`.
-      #
-      # @example
-      #
-      #   # bad
-      #   class SomeClass
-      #     const :foo, T.untyped
-      #     prop :bar, T.nilable(T.untyped)
-      #   end
-      #
-      #   # good
-      #   class SomeClass
-      #     const :foo, Integer
-      #     prop :bar, T.nilable(String)
-      #   end
-      class ForbidUntypedStructProps < RuboCop::Cop::Cop
-        MSG = "Struct props cannot be T.untyped"
-
-        def_node_matcher :t_struct, <<~PATTERN
-          (const (const nil? :T) :Struct)
-        PATTERN
-
-        def_node_matcher :t_untyped, <<~PATTERN
-          (send (const nil? :T) :untyped)
-        PATTERN
-
-        def_node_matcher :t_nilable_untyped, <<~PATTERN
-          (send (const nil? :T) :nilable {#t_untyped #t_nilable_untyped})
-        PATTERN
-
-        def_node_matcher :subclass_of_t_struct?, <<~PATTERN
-          (class (const ...) #t_struct ...)
-        PATTERN
-
-        def_node_search :untyped_props, <<~PATTERN
-          (send nil? {:prop :const} _ {#t_untyped #t_nilable_untyped} ...)
-        PATTERN
-
-        def on_class(node)
-          return unless subclass_of_t_struct?(node)
-
-          untyped_props(node).each do |untyped_prop|
-            add_offense(untyped_prop.child_nodes[1])
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb
deleted file mode 100644
index 3d96a41803c01..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop/cop/style/mutable_constant"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      module MutableConstantSorbetAwareBehaviour
-        def self.prepended(base)
-          base.def_node_matcher(:t_let, <<~PATTERN)
-            (send (const nil? :T) :let $_constant _type)
-          PATTERN
-        end
-
-        def on_assignment(value)
-          t_let(value) do |constant|
-            value = constant
-          end
-
-          super(value)
-        end
-      end
-    end
-  end
-end
-
-RuboCop::Cop::Style::MutableConstant.prepend(
-  RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour
-)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb
deleted file mode 100644
index 66b778a3e6716..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb
+++ /dev/null
@@ -1,75 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-require "rubocop"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop ensures one ancestor per requires_ancestor line
-      # rather than chaining them as a comma-separated list.
-      #
-      # @example
-      #
-      #   # bad
-      #   module SomeModule
-      #     requires_ancestor Kernel, Minitest::Assertions
-      #   end
-      #
-      #   # good
-      #   module SomeModule
-      #     requires_ancestor Kernel
-      #     requires_ancestor Minitest::Assertions
-      #   end
-      class OneAncestorPerLine < RuboCop::Cop::Cop
-        MSG = "Cannot require more than one ancestor per line"
-
-        def_node_search :requires_ancestors, <<~PATTERN
-          (send nil? :requires_ancestor ...)
-        PATTERN
-
-        def_node_matcher :more_than_one_ancestor, <<~PATTERN
-          (send nil? :requires_ancestor const const+)
-        PATTERN
-
-        def_node_search :abstract?, <<~PATTERN
-          (send nil? :abstract!)
-        PATTERN
-
-        def on_module(node)
-          return unless node.body
-          return unless requires_ancestors(node)
-          process_node(node)
-        end
-
-        def on_class(node)
-          return unless abstract?(node)
-          return unless requires_ancestors(node)
-          process_node(node)
-        end
-
-        def autocorrect(node)
-          -> (corrector) do
-            ra_call = node.parent
-            split_ra_calls = ra_call.source.gsub(/,\s+/, new_ra_line(ra_call.loc.column))
-            corrector.replace(ra_call, split_ra_calls)
-          end
-        end
-
-        private
-
-        def process_node(node)
-          requires_ancestors(node).each do |ra|
-            add_offense(ra.child_nodes[1]) if more_than_one_ancestor(ra)
-          end
-        end
-
-        def new_ra_line(indent_count)
-          indents = " " * indent_count
-          indented_ra_call = "#{indents}requires_ancestor "
-          "\n#{indented_ra_call}"
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb
deleted file mode 100644
index c7b897098f765..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb
+++ /dev/null
@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop ensures RBI shims do not include a call to extend T::Sig
-      # or to extend T::Helpers
-      #
-      # @example
-      #
-      #   # bad
-      #   module SomeModule
-      #     extend T::Sig
-      #     extend T::Helpers
-      #
-      #     sig { returns(String) }
-      #     def foo; end
-      #   end
-      #
-      #   # good
-      #   module SomeModule
-      #     sig { returns(String) }
-      #     def foo; end
-      #   end
-      class ForbidExtendTSigHelpersInShims < RuboCop::Cop::Cop
-        include RangeHelp
-
-        MSG = "Extending T::Sig or T::Helpers in a shim is unnecessary"
-        RESTRICT_ON_SEND = [:extend]
-
-        def_node_matcher :extend_t_sig?, <<~PATTERN
-          (send nil? :extend (const (const nil? :T) :Sig))
-        PATTERN
-
-        def_node_matcher :extend_t_helpers?, <<~PATTERN
-          (send nil? :extend (const (const nil? :T) :Helpers))
-        PATTERN
-
-        def autocorrect(node)
-          -> (corrector) do
-            corrector.remove(
-              range_by_whole_lines(node.source_range, include_final_newline: true)
-            )
-          end
-        end
-
-        def on_send(node)
-          add_offense(node) if extend_t_helpers?(node) || extend_t_sig?(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb
deleted file mode 100644
index b3ad93ce2fbeb..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require "pathname"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop makes sure that RBI files are always located under the defined allowed paths.
-      #
-      # Options:
-      #
-      # * `AllowedPaths`: A list of the paths where RBI files are allowed (default: ["sorbet/rbi/**"])
-      #
-      # @example
-      #   # bad
-      #   # lib/some_file.rbi
-      #   # other_file.rbi
-      #
-      #   # good
-      #   # sorbet/rbi/some_file.rbi
-      #   # sorbet/rbi/any/path/for/file.rbi
-      class ForbidRBIOutsideOfAllowedPaths < RuboCop::Cop::Cop
-        include RangeHelp
-
-        def investigate(processed_source)
-          paths = allowed_paths
-
-          if paths.nil?
-            add_offense(
-              nil,
-              location: source_range(processed_source.buffer, 1, 0),
-              message: "AllowedPaths expects an array"
-            )
-            return
-          elsif paths.empty?
-            add_offense(
-              nil,
-              location: source_range(processed_source.buffer, 1, 0),
-              message: "AllowedPaths cannot be empty"
-            )
-            return
-          end
-
-          # When executed the path to the source file is absolute.
-          # We need to remove the exec path directory prefix before matching with the filename regular expressions.
-          rel_path = processed_source.file_path.sub("#{Dir.pwd}/", "")
-
-          add_offense(
-            nil,
-            location: source_range(processed_source.buffer, 1, 0),
-            message: "RBI file path should match one of: #{paths.join(", ")}"
-          ) if paths.none? { |pattern| File.fnmatch(pattern, rel_path) }
-        end
-
-        private
-
-        def allowed_paths
-          paths = cop_config["AllowedPaths"]
-          return nil unless paths.is_a?(Array)
-          paths.compact
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb
deleted file mode 100644
index cef6d6033669f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop ensures empty class/module definitions in RBI files are
-      # done on a single line rather than being split across multiple lines.
-      #
-      # @example
-      #
-      #   # bad
-      #   module SomeModule
-      #   end
-      #
-      #   # good
-      #   module SomeModule; end
-      class SingleLineRbiClassModuleDefinitions < RuboCop::Cop::Cop
-        MSG = "Empty class/module definitions in RBI files should be on a single line."
-
-        def on_module(node)
-          process_node(node)
-        end
-
-        def on_class(node)
-          process_node(node)
-        end
-
-        def autocorrect(node)
-          -> (corrector) { corrector.replace(node, convert_newlines(node.source)) }
-        end
-
-        protected
-
-        def convert_newlines(source)
-          source.sub(/[\r\n]+\s*[\r\n]*/, "; ")
-        end
-
-        def process_node(node)
-          return if node.body
-          return if node.single_line?
-          add_offense(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb
deleted file mode 100644
index fa85eb71a0df1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb
+++ /dev/null
@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop checks that the Sorbet sigil comes as the first magic comment in the file.
-      #
-      # The expected order for magic comments is: typed, (en)?coding, warn_indent then frozen_string_literal.
-      #
-      # For example, the following bad ordering:
-      #
-      # ```ruby
-      # # frozen_string_literal: true
-      # # typed: true
-      # class Foo; end
-      # ```
-      #
-      # Will be corrected as:
-      #
-      # ```ruby
-      # # typed: true
-      # # frozen_string_literal: true
-      # class Foo; end
-      # ```
-      #
-      # Only `typed`, `(en)?coding`, `warn_indent` and `frozen_string_literal` magic comments are considered,
-      # other comments or magic comments are left in the same place.
-      class EnforceSigilOrder < ValidSigil
-        include RangeHelp
-
-        def investigate(processed_source)
-          return if processed_source.tokens.empty?
-
-          tokens = extract_magic_comments(processed_source)
-          return if tokens.empty?
-
-          check_magic_comments_order(tokens)
-        end
-
-        def autocorrect(_node)
-          lambda do |corrector|
-            tokens = extract_magic_comments(processed_source)
-
-            # Get the magic comments tokens in their expected order
-            expected = PREFERRED_ORDER.keys.map do |re|
-              tokens.select { |token| re.match?(token.text) }
-            end.flatten
-
-            tokens.each_with_index do |token, index|
-              corrector.replace(token.pos, expected[index].text)
-            end
-
-            # Remove blank lines between the magic comments
-            lines = tokens.map(&:line).to_set
-            (lines.min...lines.max).each do |line|
-              next if lines.include?(line)
-              next unless processed_source[line - 1].empty?
-              corrector.remove(source_range(processed_source.buffer, line, 0))
-            end
-          end
-        end
-
-        protected
-
-        CODING_REGEX = /#\s+(en)?coding:(?:\s+([\w]+))?/
-        INDENT_REGEX = /#\s+warn_indent:(?:\s+([\w]+))?/
-        FROZEN_REGEX = /#\s+frozen_string_literal:(?:\s+([\w]+))?/
-
-        PREFERRED_ORDER = {
-          CODING_REGEX => "encoding",
-          SIGIL_REGEX => "typed",
-          INDENT_REGEX => "warn_indent",
-          FROZEN_REGEX => "frozen_string_literal",
-        }.freeze
-
-        MAGIC_REGEX = Regexp.union(*PREFERRED_ORDER.keys)
-
-        # extraction
-
-        # Get all the tokens in `processed_source` that match `MAGIC_REGEX`
-        def extract_magic_comments(processed_source)
-          processed_source.tokens
-            .take_while { |token| token.type == :tCOMMENT }
-            .select { |token| MAGIC_REGEX.match?(token.text) }
-        end
-
-        # checks
-
-        def check_magic_comments_order(tokens)
-          # Get the current magic comments order
-          order = tokens.map do |token|
-            PREFERRED_ORDER.keys.find { |re| re.match?(token.text) }
-          end.compact.uniq
-
-          # Get the expected magic comments order based on the one used in the actual source
-          expected = PREFERRED_ORDER.keys.select do |re|
-            tokens.any? { |token| re.match?(token.text) }
-          end.uniq
-
-          if order != expected
-            tokens.each do |token|
-              add_offense(
-                token,
-                location: token.pos,
-                message: "Magic comments should be in the following order: #{PREFERRED_ORDER.values.join(", ")}."
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb
deleted file mode 100644
index ee2de41a4bd45..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop checks that there is only one Sorbet sigil in a given file
-      #
-      # For example, the following class with two sigils
-      #
-      # ```ruby
-      # # typed: true
-      # # typed: true
-      # # frozen_string_literal: true
-      # class Foo; end
-      # ```
-      #
-      # Will be corrected as:
-      #
-      # ```ruby
-      # # typed: true
-      # # frozen_string_literal: true
-      # class Foo; end
-      # ```
-      #
-      # Other comments or magic comments are left in place.
-      class EnforceSingleSigil < ValidSigil
-        include RangeHelp
-
-        def investigate(processed_source)
-          return if processed_source.tokens.empty?
-          sigils = extract_all_sigils(processed_source)
-          return unless sigils.size > 1
-
-          sigils[1..sigils.size].each do |token|
-            add_offense(token, location: token.pos, message: "Files must only contain one sigil")
-          end
-        end
-
-        def autocorrect(_node)
-          -> (corrector) do
-            sigils = extract_all_sigils(processed_source)
-            return unless sigils.size > 1
-
-            # The first sigil encountered represents the "real" strictness so remove any below
-            sigils[1..sigils.size].each do |token|
-              corrector.remove(
-                source_range(processed_source.buffer, token.line, (0..token.pos.last_column))
-              )
-            end
-          end
-        end
-
-        protected
-
-        def extract_all_sigils(processed_source)
-          processed_source.tokens
-            .take_while { |token| token.type == :tCOMMENT }
-            .find_all { |token| SIGIL_REGEX.match?(token.text) }
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/false_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/false_sigil.rb
deleted file mode 100644
index 1f7d9e4ff13db..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/false_sigil.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-require_relative "has_sigil"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop makes the Sorbet `false` sigil mandatory in all files.
-      class FalseSigil < HasSigil
-        def minimum_strictness
-          "false"
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/has_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/has_sigil.rb
deleted file mode 100644
index 4143b0aa5ef84..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/has_sigil.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-require_relative "valid_sigil"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop makes the Sorbet typed sigil mandatory in all files.
-      #
-      # Options:
-      #
-      # * `SuggestedStrictness`: Sorbet strictness level suggested in offense messages (default: 'false')
-      # * `MinimumStrictness`: If set, make offense if the strictness level in the file is below this one
-      #
-      # If a `MinimumStrictness` level is specified, it will be used in offense messages and autocorrect.
-      class HasSigil < ValidSigil
-        @registry = Cop.registry # So we can properly subclass this cop
-
-        def require_sigil_on_all_files?
-          true
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/ignore_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/ignore_sigil.rb
deleted file mode 100644
index 0e1130310a71d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/ignore_sigil.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-require_relative "has_sigil"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop makes the Sorbet `ignore` sigil mandatory in all files.
-      class IgnoreSigil < HasSigil
-        def minimum_strictness
-          "ignore"
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/strict_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/strict_sigil.rb
deleted file mode 100644
index 6c415ea04e1f5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/strict_sigil.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-require_relative "has_sigil"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop makes the Sorbet `strict` sigil mandatory in all files.
-      class StrictSigil < HasSigil
-        def minimum_strictness
-          "strict"
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/strong_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/strong_sigil.rb
deleted file mode 100644
index 567c46c790624..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/strong_sigil.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-require_relative "has_sigil"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop makes the Sorbet `strong` sigil mandatory in all files.
-      class StrongSigil < HasSigil
-        def minimum_strictness
-          "strong"
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/true_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/true_sigil.rb
deleted file mode 100644
index 415e69155447c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/true_sigil.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-require_relative "has_sigil"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop makes the Sorbet `true` sigil mandatory in all files.
-      class TrueSigil < HasSigil
-        def minimum_strictness
-          "true"
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb
deleted file mode 100644
index 7c35e693ff176..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb
+++ /dev/null
@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop checks that every Ruby file contains a valid Sorbet sigil.
-      # Adapted from: https://gist.github.com/clarkdave/85aca4e16f33fd52aceb6a0a29936e52
-      #
-      # Options:
-      #
-      # * `RequireSigilOnAllFiles`: make offense if the Sorbet typed is not found in the file (default: false)
-      # * `SuggestedStrictness`: Sorbet strictness level suggested in offense messages (default: 'false')
-      # * `MinimumStrictness`: If set, make offense if the strictness level in the file is below this one
-      #
-      # If a `MinimumStrictness` level is specified, it will be used in offense messages and autocorrect.
-      class ValidSigil < RuboCop::Cop::Cop
-        @registry = Cop.registry # So we can properly subclass this cop
-
-        def investigate(processed_source)
-          return if processed_source.tokens.empty?
-
-          sigil = extract_sigil(processed_source)
-          return unless check_sigil_present(sigil)
-
-          strictness = extract_strictness(sigil)
-          return unless check_strictness_not_empty(sigil, strictness)
-          return unless check_strictness_valid(sigil, strictness)
-          return unless check_strictness_level(sigil, strictness)
-        end
-
-        def autocorrect(_node)
-          lambda do |corrector|
-            return unless require_sigil_on_all_files?
-            return unless extract_sigil(processed_source).nil?
-
-            token = processed_source.tokens.first
-            replace_with = suggested_strictness_level(minimum_strictness, suggested_strictness)
-            sigil = "# typed: #{replace_with}"
-            if token.text.start_with?("#!") # shebang line
-              corrector.insert_after(token.pos, "\n#{sigil}")
-            else
-              corrector.insert_before(token.pos, "#{sigil}\n")
-            end
-          end
-        end
-
-        protected
-
-        STRICTNESS_LEVELS = ["ignore", "false", "true", "strict", "strong"]
-        SIGIL_REGEX = /^\s*#\s+typed:(?:\s+([\w]+))?/
-
-        # extraction
-
-        def extract_sigil(processed_source)
-          processed_source.tokens
-            .take_while { |token| token.type == :tCOMMENT }
-            .find { |token| SIGIL_REGEX.match?(token.text) }
-        end
-
-        def extract_strictness(sigil)
-          sigil.text.match(SIGIL_REGEX)&.captures&.first
-        end
-
-        # checks
-
-        def check_sigil_present(sigil)
-          return true unless sigil.nil?
-
-          token = processed_source.tokens.first
-          if require_sigil_on_all_files?
-            strictness = suggested_strictness_level(minimum_strictness, suggested_strictness)
-            add_offense(
-              token,
-              location: token.pos,
-              message: "No Sorbet sigil found in file. " \
-                "Try a `typed: #{strictness}` to start (you can also use `rubocop -a` to automatically add this)."
-            )
-          end
-          false
-        end
-
-        def suggested_strictness_level(minimum_strictness, suggested_strictness)
-          # if no minimum strictness is set (eg. using Sorbet/HasSigil without config) then
-          # we always use the suggested strictness which defaults to `false`
-          return suggested_strictness unless minimum_strictness
-
-          # special case: if you're using Sorbet/IgnoreSigil without config, we should recommend `ignore`
-          return "ignore" if minimum_strictness == "ignore" && cop_config["SuggestedStrictness"].nil?
-
-          # if a minimum strictness is set (eg. you're using Sorbet/FalseSigil)
-          # we want to compare the minimum strictness and suggested strictness. this is because
-          # the suggested strictness might be higher than the minimum (eg. if you want all new files
-          # at a higher strictness level, without having to migrate existing files at lower levels).
-
-          suggested_level = STRICTNESS_LEVELS.index(suggested_strictness)
-          minimum_level = STRICTNESS_LEVELS.index(minimum_strictness)
-
-          suggested_level > minimum_level ? suggested_strictness : minimum_strictness
-        end
-
-        def check_strictness_not_empty(sigil, strictness)
-          return true if strictness
-
-          add_offense(
-            sigil,
-            location: sigil.pos,
-            message: "Sorbet sigil should not be empty."
-          )
-          false
-        end
-
-        def check_strictness_valid(sigil, strictness)
-          return true if STRICTNESS_LEVELS.include?(strictness)
-
-          add_offense(
-            sigil,
-            location: sigil.pos,
-            message: "Invalid Sorbet sigil `#{strictness}`."
-          )
-          false
-        end
-
-        def check_strictness_level(sigil, strictness)
-          return true unless minimum_strictness
-
-          minimum_level = STRICTNESS_LEVELS.index(minimum_strictness)
-          current_level = STRICTNESS_LEVELS.index(strictness)
-          if current_level < minimum_level
-            add_offense(
-              sigil,
-              location: sigil.pos,
-              message: "Sorbet sigil should be at least `#{minimum_strictness}` got `#{strictness}`."
-            )
-            return false
-          end
-          true
-        end
-
-        # options
-
-        # Default is `false`
-        def require_sigil_on_all_files?
-          !!cop_config["RequireSigilOnAllFiles"]
-        end
-
-        # Default is `'false'`
-        def suggested_strictness
-          config = cop_config["SuggestedStrictness"].to_s
-          STRICTNESS_LEVELS.include?(config) ? config : "false"
-        end
-
-        # Default is `nil`
-        def minimum_strictness
-          config = cop_config["MinimumStrictness"].to_s
-          config if STRICTNESS_LEVELS.include?(config)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb
deleted file mode 100644
index 73420ccf8d0d8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop disallows using `.override(allow_incompatible: true)`.
-      # Using `allow_incompatible` suggests a violation of the Liskov
-      # Substitution Principle, meaning that a subclass is not a valid
-      # subtype of it's superclass. This Cop prevents these design smells
-      # from occurring.
-      #
-      # @example
-      #
-      #   # bad
-      #   sig.override(allow_incompatible: true)
-      #
-      #   # good
-      #   sig.override
-      class AllowIncompatibleOverride < RuboCop::Cop::Cop
-        def_node_search(:sig?, <<-PATTERN)
-          (
-            send
-            nil?
-            :sig
-             ...
-          )
-        PATTERN
-
-        def not_nil?(node)
-          !node.nil?
-        end
-
-        def_node_search(:allow_incompatible?, <<-PATTERN)
-          (pair (sym :allow_incompatible) (true))
-        PATTERN
-
-        def_node_matcher(:allow_incompatible_override?, <<-PATTERN)
-          (
-            send
-            [#not_nil? #sig?]
-            :override
-            [#not_nil? #allow_incompatible?]
-          )
-        PATTERN
-
-        def on_send(node)
-          return unless allow_incompatible_override?(node)
-          add_offense(
-            node.children[2],
-            message: "Usage of `allow_incompatible` suggests a violation of the Liskov Substitution Principle. "\
-            "Instead, strive to write interfaces which respect subtyping principles and remove `allow_incompatible`",
-          )
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb
deleted file mode 100644
index 4166214a9bf6b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb
+++ /dev/null
@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-require_relative "signature_cop"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop disallows the usage of `checked(true)`. This usage could cause
-      # confusion; it could lead some people to believe that a method would be checked
-      # even if runtime checks have not been enabled on the class or globally.
-      # Additionally, in the event where checks are enabled, `checked(true)` would
-      # be redundant; only `checked(false)` or `soft` would change the behaviour.
-      #
-      # @example
-      #
-      #   # bad
-      #   sig { void.checked(true) }
-      #
-      #   # good
-      #   sig { void }
-      class CheckedTrueInSignature < SignatureCop
-        include(RuboCop::Cop::RangeHelp)
-
-        def_node_search(:offending_node, <<~PATTERN)
-          (send _ :checked (true))
-        PATTERN
-
-        MESSAGE =
-          "Using `checked(true)` in a method signature definition is not allowed. " \
-            "`checked(true)` is the default behavior for modules/classes with runtime checks enabled. " \
-            "To enable typechecking at runtime for this module, regardless of global settings, " \
-            "`include(WaffleCone::RuntimeChecks)` to this module and set other methods to `checked(false)`."
-        private_constant(:MESSAGE)
-
-        def on_signature(node)
-          error = offending_node(node).first
-          return unless error
-
-          add_offense(
-            error,
-            location: source_range(
-              processed_source.buffer,
-              error.location.line,
-              (error.location.selector.begin_pos)..(error.location.end.begin_pos),
-            ),
-            message: MESSAGE
-          )
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb
deleted file mode 100644
index a6fd572970d63..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb
+++ /dev/null
@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-require "stringio"
-require_relative "signature_cop"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop checks that every method definition and attribute accessor has a Sorbet signature.
-      #
-      # It also suggest an autocorrect with placeholders so the following code:
-      #
-      # ```
-      # def foo(a, b, c); end
-      # ```
-      #
-      # Will be corrected as:
-      #
-      # ```
-      # sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped)
-      # def foo(a, b, c); end
-      # ```
-      #
-      # You can configure the placeholders used by changing the following options:
-      #
-      # * `ParameterTypePlaceholder`: placeholders used for parameter types (default: 'T.untyped')
-      # * `ReturnTypePlaceholder`: placeholders used for return types (default: 'T.untyped')
-      class EnforceSignatures < SignatureCop
-        def initialize(config = nil, options = nil)
-          super(config, options)
-          @last_sig_for_scope = {}
-        end
-
-        def_node_matcher(:accessor?, <<-PATTERN)
-          (send nil? {:attr_reader :attr_writer :attr_accessor} ...)
-        PATTERN
-
-        def on_def(node)
-          check_node(node)
-        end
-
-        def on_defs(node)
-          check_node(node)
-        end
-
-        def on_send(node)
-          check_node(node) if accessor?(node)
-        end
-
-        def on_signature(node)
-          @last_sig_for_scope[scope(node)] = node
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            suggest = SigSuggestion.new(node.loc.column, param_type_placeholder, return_type_placeholder)
-
-            if node.is_a?(RuboCop::AST::DefNode) # def something
-              node.arguments.each do |arg|
-                suggest.params << arg.children.first
-              end
-            elsif accessor?(node) # attr reader, writer, accessor
-              method = node.children[1]
-              symbol = node.children[2]
-              suggest.params << symbol.value if symbol && (method == :attr_writer || method == :attr_accessor)
-              suggest.returns = "void" if method == :attr_writer
-            end
-
-            corrector.insert_before(node.loc.expression, suggest.to_autocorrect)
-          end
-        end
-
-        def scope(node)
-          return nil unless node.parent
-          return node.parent if [:begin, :block, :class, :module].include?(node.parent.type)
-          scope(node.parent)
-        end
-
-        private
-
-        def check_node(node)
-          scope = self.scope(node)
-          unless @last_sig_for_scope[scope]
-            add_offense(
-              node,
-              message: "Each method is required to have a signature."
-            )
-          end
-          @last_sig_for_scope[scope] = nil
-        end
-
-        def param_type_placeholder
-          cop_config["ParameterTypePlaceholder"] || "T.untyped"
-        end
-
-        def return_type_placeholder
-          cop_config["ReturnTypePlaceholder"] || "T.untyped"
-        end
-
-        class SigSuggestion
-          attr_accessor :params, :returns
-
-          def initialize(indent, param_placeholder, return_placeholder)
-            @params = []
-            @returns = nil
-            @indent = indent
-            @param_placeholder = param_placeholder
-            @return_placeholder = return_placeholder
-          end
-
-          def to_autocorrect
-            out = StringIO.new
-            out << "sig { "
-            out << generate_params
-            out << generate_return
-            out << " }\n"
-            out << " " * @indent # preserve indent for the next line
-            out.string
-          end
-
-          private
-
-          def generate_params
-            return if @params.empty?
-            out = StringIO.new
-            out << "params("
-            out << @params.map do |param|
-              "#{param}: #{@param_placeholder}"
-            end.join(", ")
-            out << ")."
-            out.string
-          end
-
-          def generate_return
-            return "returns(#{@return_placeholder})" if @returns.nil?
-            return @returns if @returns == "void"
-            "returns(#{@returns})"
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb
deleted file mode 100644
index d98d9032aa710..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-require_relative "signature_cop"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop checks for the ordering of keyword arguments required by
-      # sorbet-runtime. The ordering requires that all keyword arguments
-      # are at the end of the parameters list, and all keyword arguments
-      # with a default value must be after those without default values.
-      #
-      # @example
-      #
-      #   # bad
-      #   sig { params(a: Integer, b: String).void }
-      #   def foo(a: 1, b:); end
-      #
-      #   # good
-      #   sig { params(b: String, a: Integer).void }
-      #   def foo(b:, a: 1); end
-      class KeywordArgumentOrdering < SignatureCop
-        def on_signature(node)
-          method_node = node.parent.children[node.sibling_index + 1]
-          return if method_node.nil?
-          method_parameters = method_node.arguments
-
-          check_order_for_kwoptargs(method_parameters)
-        end
-
-        private
-
-        def check_order_for_kwoptargs(parameters)
-          out_of_kwoptarg = false
-
-          parameters.reverse.each do |param|
-            out_of_kwoptarg = true unless param.type == :kwoptarg || param.type == :blockarg || param.type == :kwrestarg
-
-            next unless param.type == :kwoptarg && out_of_kwoptarg
-
-            add_offense(
-              param,
-              message: "Optional keyword arguments must be at the end of the parameter list."
-            )
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb
deleted file mode 100644
index 45d6234e7d033..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb
+++ /dev/null
@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-require_relative "signature_cop"
-
-begin
-  require "unparser"
-rescue LoadError
-  nil
-end
-
-module RuboCop
-  module Cop
-    module Sorbet
-      class SignatureBuildOrder < SignatureCop
-        ORDER =
-          [
-            :abstract,
-            :override,
-            :overridable,
-            :type_parameters,
-            :params,
-            :returns,
-            :void,
-            :soft,
-            :checked,
-            :on_failure,
-          ].each_with_index.to_h.freeze
-
-        def_node_search(:root_call, <<~PATTERN)
-          (send nil? {#{ORDER.keys.map(&:inspect).join(" ")}} ...)
-        PATTERN
-
-        def on_signature(node)
-          calls = call_chain(node.children[2]).map(&:method_name)
-          return unless calls.any?
-
-          expected_order = calls.sort_by { |call| ORDER[call] }
-          return if expected_order == calls
-
-          message = "Sig builders must be invoked in the following order: #{expected_order.join(", ")}."
-
-          unless can_autocorrect?
-            message += " For autocorrection, add the `unparser` gem to your project."
-          end
-
-          add_offense(
-            node.children[2],
-            message: message,
-          )
-          node
-        end
-
-        def autocorrect(node)
-          return nil unless can_autocorrect?
-
-          lambda do |corrector|
-            tree = call_chain(node_reparsed_with_modern_features(node))
-              .sort_by { |call| ORDER[call.method_name] }
-              .reduce(nil) do |receiver, caller|
-                caller.updated(nil, [receiver] + caller.children.drop(1))
-              end
-
-            corrector.replace(
-              node.source_range,
-              Unparser.unparse(tree),
-            )
-          end
-        end
-
-        # Create a subclass of AST Builder that has modern features turned on
-        class ModernBuilder < RuboCop::AST::Builder
-          modernize
-        end
-        private_constant :ModernBuilder
-
-        private
-
-        # This method exists to reparse the current node with modern features enabled.
-        # Modern features include "index send" emitting, which is necessary to unparse
-        # "index sends" (i.e. `[]` calls) back to index accessors (i.e. as `foo[bar]``).
-        # Otherwise, we would get the unparsed node as `foo.[](bar)`.
-        def node_reparsed_with_modern_features(node)
-          # Create a new parser with a modern builder class instance
-          parser = Parser::CurrentRuby.new(ModernBuilder.new)
-          # Create a new source buffer with the node source
-          buffer = Parser::Source::Buffer.new(processed_source.path, source: node.source)
-          # Re-parse the buffer
-          parser.parse(buffer)
-        end
-
-        def can_autocorrect?
-          defined?(::Unparser)
-        end
-
-        def call_chain(sig_child_node)
-          call_node = root_call(sig_child_node).first
-          return [] unless call_node
-
-          calls = []
-          while call_node != sig_child_node
-            calls << call_node
-            call_node = call_node.parent
-          end
-
-          calls << sig_child_node
-
-          calls
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_cop.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_cop.rb
deleted file mode 100644
index 389593ded351f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_cop.rb
+++ /dev/null
@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # Abstract cop specific to Sorbet signatures
-      #
-      # You can subclass it to use the `on_signature` trigger and the `signature?` node matcher.
-      class SignatureCop < RuboCop::Cop::Cop
-        @registry = Cop.registry # So we can properly subclass this cop
-
-        def_node_matcher(:signature?, <<~PATTERN)
-          (block (send #allowed_recv :sig) (args) ...)
-        PATTERN
-
-        def_node_matcher(:with_runtime?, <<~PATTERN)
-          (const (const nil? :T) :Sig)
-        PATTERN
-
-        def_node_matcher(:without_runtime?, <<~PATTERN)
-          (const (const (const nil? :T) :Sig) :WithoutRuntime)
-        PATTERN
-
-        def allowed_recv(recv)
-          return true unless recv
-          return true if with_runtime?(recv)
-          return true if without_runtime?(recv)
-          false
-        end
-
-        def on_block(node)
-          on_signature(node) if signature?(node)
-        end
-
-        def on_signature(_)
-          # To be defined in subclasses
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/type_alias_name.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/type_alias_name.rb
deleted file mode 100644
index c22b3d16e5345..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/type_alias_name.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-
-module RuboCop
-  module Cop
-    module Sorbet
-      # This cop ensures all constants used as `T.type_alias` are using CamelCase.
-      #
-      # @example
-      #
-      #   # bad
-      #   FOO_OR_BAR = T.type_alias { T.any(Foo, Bar) }
-      #
-      #   # good
-      #   FooOrBar = T.type_alias { T.any(Foo, Bar) }
-      class TypeAliasName < RuboCop::Cop::Cop
-        MSG = "Type alias constant name should be in CamelCase"
-
-        def_node_matcher(:casgn_type_alias?, <<-PATTERN)
-          (casgn
-            _
-            _
-            (block
-              (send
-                (const nil? :T) :type_alias)
-                _
-                _
-            ))
-        PATTERN
-
-        def on_casgn(node)
-          return unless casgn_type_alias?(node)
-
-          name = node.children[1]
-
-          # From https://github.com/rubocop/rubocop/blob/master/lib/rubocop/cop/naming/class_and_module_camel_case.rb
-          return unless /_/.match?(name)
-
-          add_offense(node)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet_cops.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet_cops.rb
deleted file mode 100644
index 8a825d2139812..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet_cops.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-require_relative "sorbet/binding_constants_without_type_alias"
-require_relative "sorbet/constants_from_strings"
-require_relative "sorbet/forbid_superclass_const_literal"
-require_relative "sorbet/forbid_include_const_literal"
-require_relative "sorbet/forbid_untyped_struct_props"
-require_relative "sorbet/one_ancestor_per_line"
-require_relative "sorbet/callback_conditionals_binding"
-require_relative "sorbet/forbid_t_unsafe"
-require_relative "sorbet/forbid_t_untyped"
-require_relative "sorbet/type_alias_name"
-
-require_relative "sorbet/rbi/forbid_extend_t_sig_helpers_in_shims"
-require_relative "sorbet/rbi/forbid_rbi_outside_of_allowed_paths"
-require_relative "sorbet/rbi/single_line_rbi_class_module_definitions"
-
-require_relative "sorbet/signatures/allow_incompatible_override"
-require_relative "sorbet/signatures/checked_true_in_signature"
-require_relative "sorbet/signatures/keyword_argument_ordering"
-require_relative "sorbet/signatures/signature_build_order"
-require_relative "sorbet/signatures/enforce_signatures"
-
-require_relative "sorbet/sigils/valid_sigil"
-require_relative "sorbet/sigils/has_sigil"
-require_relative "sorbet/sigils/ignore_sigil"
-require_relative "sorbet/sigils/false_sigil"
-require_relative "sorbet/sigils/true_sigil"
-require_relative "sorbet/sigils/strict_sigil"
-require_relative "sorbet/sigils/strong_sigil"
-require_relative "sorbet/sigils/enforce_sigil_order"
-require_relative "sorbet/sigils/enforce_single_sigil"
-
-require_relative "sorbet/mutable_constant_sorbet_aware_behaviour"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/sorbet.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/sorbet.rb
deleted file mode 100644
index 23e6647ed5ee6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/sorbet.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-require "rubocop/sorbet/version"
-require "yaml"
-
-module RuboCop
-  module Sorbet
-    class Error < StandardError; end
-
-    PROJECT_ROOT   = Pathname.new(__dir__).parent.parent.expand_path.freeze
-    CONFIG_DEFAULT = PROJECT_ROOT.join("config", "default.yml").freeze
-    CONFIG         = YAML.safe_load(CONFIG_DEFAULT.read).freeze
-
-    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/sorbet/inject.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/sorbet/inject.rb
deleted file mode 100644
index f0440faac0f5f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/sorbet/inject.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-# The original code is from https://github.com/rubocop-hq/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
-# See https://github.com/rubocop-hq/rubocop-rspec/blob/master/MIT-LICENSE.md
-module RuboCop
-  module Sorbet
-    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
-    # bit of our configuration.
-    module Inject
-      def self.defaults!
-        path = CONFIG_DEFAULT.to_s
-        hash = ConfigLoader.send(:load_yaml_configuration, path)
-        config = Config.new(hash, path).tap(&:make_excludes_absolute)
-        puts "configuration from #{path}" if ConfigLoader.debug?
-        config = ConfigLoader.merge_with_default(config, path)
-        ConfigLoader.instance_variable_set(:@default_configuration, config)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/sorbet/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/sorbet/version.rb
deleted file mode 100644
index a7a1d47e4e69f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubocop-sorbet-0.6.11/lib/rubocop/sorbet/version.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-module RuboCop
-  module Sorbet
-    VERSION = "0.6.11"
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/exceptions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/exceptions.rb
deleted file mode 100644
index 368c16e9c2c34..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/exceptions.rb
+++ /dev/null
@@ -1,220 +0,0 @@
-# frozen_string_literal: true
-
-module MachO
-  # A generic Mach-O error in execution.
-  class MachOError < RuntimeError
-  end
-
-  # Raised when a Mach-O file modification fails.
-  class ModificationError < MachOError
-  end
-
-  # Raised when codesigning fails. Certain environments
-  # may want to rescue this to treat it as non-fatal.
-  class CodeSigningError < MachOError
-  end
-
-  # Raised when a Mach-O file modification fails but can be recovered when
-  # operating on multiple Mach-O slices of a fat binary in non-strict mode.
-  class RecoverableModificationError < ModificationError
-    # @return [Integer, nil] The index of the Mach-O slice of a fat binary for
-    #   which modification failed or `nil` if not a fat binary. This is used to
-    #   make the error message more useful.
-    attr_accessor :macho_slice
-
-    # @return [String] The exception message.
-    def to_s
-      s = super.to_s
-      s = "While modifying Mach-O slice #{@macho_slice}: #{s}" if @macho_slice
-      s
-    end
-  end
-
-  # Raised when a file is not a Mach-O.
-  class NotAMachOError < MachOError
-  end
-
-  # Raised when a file is too short to be a valid Mach-O file.
-  class TruncatedFileError < NotAMachOError
-    def initialize
-      super "File is too short to be a valid Mach-O"
-    end
-  end
-
-  # Raised when a file's magic bytes are not valid Mach-O magic.
-  class MagicError < NotAMachOError
-    # @param num [Integer] the unknown number
-    def initialize(magic)
-      super "Unrecognized Mach-O magic: 0x%02<magic>x" % { :magic => magic }
-    end
-  end
-
-  # Raised when a file is a Java classfile instead of a fat Mach-O.
-  class JavaClassFileError < NotAMachOError
-    def initialize
-      super "File is a Java class file"
-    end
-  end
-
-  # Raised when a fat binary is loaded with MachOFile.
-  class FatBinaryError < MachOError
-    def initialize
-      super "Fat binaries must be loaded with MachO::FatFile"
-    end
-  end
-
-  # Raised when a Mach-O is loaded with FatFile.
-  class MachOBinaryError < MachOError
-    def initialize
-      super "Normal binaries must be loaded with MachO::MachOFile"
-    end
-  end
-
-  # Raised when the CPU type is unknown.
-  class CPUTypeError < MachOError
-    # @param cputype [Integer] the unknown CPU type
-    def initialize(cputype)
-      super "Unrecognized CPU type: 0x%08<cputype>x" % { :cputype => cputype }
-    end
-  end
-
-  # Raised when the CPU type/sub-type pair is unknown.
-  class CPUSubtypeError < MachOError
-    # @param cputype [Integer] the CPU type of the unknown pair
-    # @param cpusubtype [Integer] the CPU sub-type of the unknown pair
-    def initialize(cputype, cpusubtype)
-      super "Unrecognized CPU sub-type: 0x%08<cpusubtype>x" \
-            " (for CPU type: 0x%08<cputype>x" % { :cputype => cputype, :cpusubtype => cpusubtype }
-    end
-  end
-
-  # Raised when a mach-o file's filetype field is unknown.
-  class FiletypeError < MachOError
-    # @param num [Integer] the unknown number
-    def initialize(num)
-      super "Unrecognized Mach-O filetype code: 0x%02<num>x" % { :num => num }
-    end
-  end
-
-  # Raised when an unknown load command is encountered.
-  class LoadCommandError < MachOError
-    # @param num [Integer] the unknown number
-    def initialize(num)
-      super "Unrecognized Mach-O load command: 0x%02<num>x" % { :num => num }
-    end
-  end
-
-  # Raised when a load command can't be created manually.
-  class LoadCommandNotCreatableError < MachOError
-    # @param cmd_sym [Symbol] the uncreatable load command's symbol
-    def initialize(cmd_sym)
-      super "Load commands of type #{cmd_sym} cannot be created manually"
-    end
-  end
-
-  # Raised when the number of arguments used to create a load command manually
-  # is wrong.
-  class LoadCommandCreationArityError < MachOError
-    # @param cmd_sym [Symbol] the load command's symbol
-    # @param expected_arity [Integer] the number of arguments expected
-    # @param actual_arity [Integer] the number of arguments received
-    def initialize(cmd_sym, expected_arity, actual_arity)
-      super "Expected #{expected_arity} arguments for #{cmd_sym} creation," \
-            " got #{actual_arity}"
-    end
-  end
-
-  # Raised when a load command can't be serialized.
-  class LoadCommandNotSerializableError < MachOError
-    # @param cmd_sym [Symbol] the load command's symbol
-    def initialize(cmd_sym)
-      super "Load commands of type #{cmd_sym} cannot be serialized"
-    end
-  end
-
-  # Raised when a load command string is malformed in some way.
-  class LCStrMalformedError < MachOError
-    # @param lc [MachO::LoadCommand] the load command containing the string
-    def initialize(lc)
-      super "Load command #{lc.type} at offset #{lc.view.offset} contains a" \
-            " malformed string"
-    end
-  end
-
-  # Raised when a change at an offset is not valid.
-  class OffsetInsertionError < ModificationError
-    # @param offset [Integer] the invalid offset
-    def initialize(offset)
-      super "Insertion at offset #{offset} is not valid"
-    end
-  end
-
-  # Raised when load commands are too large to fit in the current file.
-  class HeaderPadError < ModificationError
-    # @param filename [String] the filename
-    def initialize(filename)
-      super "Updated load commands do not fit in the header of " \
-            "#{filename}. #{filename} needs to be relinked, possibly with " \
-            "-headerpad or -headerpad_max_install_names"
-    end
-  end
-
-  # Raised when attempting to change a dylib name that doesn't exist.
-  class DylibUnknownError < RecoverableModificationError
-    # @param dylib [String] the unknown shared library name
-    def initialize(dylib)
-      super "No such dylib name: #{dylib}"
-    end
-  end
-
-  # Raised when a dylib is missing an ID
-  class DylibIdMissingError < RecoverableModificationError
-    def initialize
-      super "Dylib is missing a dylib ID"
-    end
-  end
-
-  # Raised when attempting to change an rpath that doesn't exist.
-  class RpathUnknownError < RecoverableModificationError
-    # @param path [String] the unknown runtime path
-    def initialize(path)
-      super "No such runtime path: #{path}"
-    end
-  end
-
-  # Raised when attempting to add an rpath that already exists.
-  class RpathExistsError < RecoverableModificationError
-    # @param path [String] the extant path
-    def initialize(path)
-      super "#{path} already exists"
-    end
-  end
-
-  # Raised whenever unfinished code is called.
-  class UnimplementedError < MachOError
-    # @param thing [String] the thing that is unimplemented
-    def initialize(thing)
-      super "Unimplemented: #{thing}"
-    end
-  end
-
-  # Raised when attempting to create a {FatFile} from one or more {MachOFile}s
-  #  whose offsets will not fit within the resulting 32-bit {Headers::FatArch#offset} fields.
-  class FatArchOffsetOverflowError < MachOError
-    # @param offset [Integer] the offending offset
-    def initialize(offset)
-      super "Offset #{offset} exceeds the 32-bit width of a fat_arch offset." \
-            " Consider merging with `fat64: true`"
-    end
-  end
-
-  # Raised when attempting to parse a compressed Mach-O without explicitly
-  # requesting decompression.
-  class CompressedMachOError < MachOError
-  end
-
-  # Raised when attempting to decompress a compressed Mach-O without adequate
-  # dependencies, or on other decompression errors.
-  class DecompressionError < MachOError
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/load_commands.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/load_commands.rb
deleted file mode 100644
index c1404e4c4a19a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/load_commands.rb
+++ /dev/null
@@ -1,1844 +0,0 @@
-# frozen_string_literal: true
-
-module MachO
-  # Classes and constants for parsing load commands in Mach-O binaries.
-  module LoadCommands
-    # load commands added after OS X 10.1 need to be bitwise ORed with
-    # LC_REQ_DYLD to be recognized by the dynamic linker (dyld)
-    # @api private
-    LC_REQ_DYLD = 0x80000000
-
-    # association of load commands to symbol representations
-    # @api private
-    LOAD_COMMANDS = {
-      0x1 => :LC_SEGMENT,
-      0x2 => :LC_SYMTAB,
-      0x3 => :LC_SYMSEG,
-      0x4 => :LC_THREAD,
-      0x5 => :LC_UNIXTHREAD,
-      0x6 => :LC_LOADFVMLIB,
-      0x7 => :LC_IDFVMLIB,
-      0x8 => :LC_IDENT,
-      0x9 => :LC_FVMFILE,
-      0xa => :LC_PREPAGE,
-      0xb => :LC_DYSYMTAB,
-      0xc => :LC_LOAD_DYLIB,
-      0xd => :LC_ID_DYLIB,
-      0xe => :LC_LOAD_DYLINKER,
-      0xf => :LC_ID_DYLINKER,
-      0x10 => :LC_PREBOUND_DYLIB,
-      0x11 => :LC_ROUTINES,
-      0x12 => :LC_SUB_FRAMEWORK,
-      0x13 => :LC_SUB_UMBRELLA,
-      0x14 => :LC_SUB_CLIENT,
-      0x15 => :LC_SUB_LIBRARY,
-      0x16 => :LC_TWOLEVEL_HINTS,
-      0x17 => :LC_PREBIND_CKSUM,
-      (0x18 | LC_REQ_DYLD) => :LC_LOAD_WEAK_DYLIB,
-      0x19 => :LC_SEGMENT_64,
-      0x1a => :LC_ROUTINES_64,
-      0x1b => :LC_UUID,
-      (0x1c | LC_REQ_DYLD) => :LC_RPATH,
-      0x1d => :LC_CODE_SIGNATURE,
-      0x1e => :LC_SEGMENT_SPLIT_INFO,
-      (0x1f | LC_REQ_DYLD) => :LC_REEXPORT_DYLIB,
-      0x20 => :LC_LAZY_LOAD_DYLIB,
-      0x21 => :LC_ENCRYPTION_INFO,
-      0x22 => :LC_DYLD_INFO,
-      (0x22 | LC_REQ_DYLD) => :LC_DYLD_INFO_ONLY,
-      (0x23 | LC_REQ_DYLD) => :LC_LOAD_UPWARD_DYLIB,
-      0x24 => :LC_VERSION_MIN_MACOSX,
-      0x25 => :LC_VERSION_MIN_IPHONEOS,
-      0x26 => :LC_FUNCTION_STARTS,
-      0x27 => :LC_DYLD_ENVIRONMENT,
-      (0x28 | LC_REQ_DYLD) => :LC_MAIN,
-      0x29 => :LC_DATA_IN_CODE,
-      0x2a => :LC_SOURCE_VERSION,
-      0x2b => :LC_DYLIB_CODE_SIGN_DRS,
-      0x2c => :LC_ENCRYPTION_INFO_64,
-      0x2d => :LC_LINKER_OPTION,
-      0x2e => :LC_LINKER_OPTIMIZATION_HINT,
-      0x2f => :LC_VERSION_MIN_TVOS,
-      0x30 => :LC_VERSION_MIN_WATCHOS,
-      0x31 => :LC_NOTE,
-      0x32 => :LC_BUILD_VERSION,
-      (0x33 | LC_REQ_DYLD) => :LC_DYLD_EXPORTS_TRIE,
-      (0x34 | LC_REQ_DYLD) => :LC_DYLD_CHAINED_FIXUPS,
-      (0x35 | LC_REQ_DYLD) => :LC_FILESET_ENTRY,
-    }.freeze
-
-    # association of symbol representations to load command constants
-    # @api private
-    LOAD_COMMAND_CONSTANTS = LOAD_COMMANDS.invert.freeze
-
-    # load commands responsible for loading dylibs
-    # @api private
-    DYLIB_LOAD_COMMANDS = %i[
-      LC_LOAD_DYLIB
-      LC_LOAD_WEAK_DYLIB
-      LC_REEXPORT_DYLIB
-      LC_LAZY_LOAD_DYLIB
-      LC_LOAD_UPWARD_DYLIB
-    ].freeze
-
-    # load commands that can be created manually via {LoadCommand.create}
-    # @api private
-    CREATABLE_LOAD_COMMANDS = DYLIB_LOAD_COMMANDS + %i[
-      LC_ID_DYLIB
-      LC_RPATH
-      LC_LOAD_DYLINKER
-    ].freeze
-
-    # association of load command symbols to string representations of classes
-    # @api private
-    LC_STRUCTURES = {
-      :LC_SEGMENT => "SegmentCommand",
-      :LC_SYMTAB => "SymtabCommand",
-      # "obsolete"
-      :LC_SYMSEG => "SymsegCommand",
-      # seems obsolete, but not documented as such
-      :LC_THREAD => "ThreadCommand",
-      :LC_UNIXTHREAD => "ThreadCommand",
-      # "obsolete"
-      :LC_LOADFVMLIB => "FvmlibCommand",
-      # "obsolete"
-      :LC_IDFVMLIB => "FvmlibCommand",
-      # "obsolete"
-      :LC_IDENT => "IdentCommand",
-      # "reserved for internal use only"
-      :LC_FVMFILE => "FvmfileCommand",
-      # "reserved for internal use only", no public struct
-      :LC_PREPAGE => "LoadCommand",
-      :LC_DYSYMTAB => "DysymtabCommand",
-      :LC_LOAD_DYLIB => "DylibCommand",
-      :LC_ID_DYLIB => "DylibCommand",
-      :LC_LOAD_DYLINKER => "DylinkerCommand",
-      :LC_ID_DYLINKER => "DylinkerCommand",
-      :LC_PREBOUND_DYLIB => "PreboundDylibCommand",
-      :LC_ROUTINES => "RoutinesCommand",
-      :LC_SUB_FRAMEWORK => "SubFrameworkCommand",
-      :LC_SUB_UMBRELLA => "SubUmbrellaCommand",
-      :LC_SUB_CLIENT => "SubClientCommand",
-      :LC_SUB_LIBRARY => "SubLibraryCommand",
-      :LC_TWOLEVEL_HINTS => "TwolevelHintsCommand",
-      :LC_PREBIND_CKSUM => "PrebindCksumCommand",
-      :LC_LOAD_WEAK_DYLIB => "DylibCommand",
-      :LC_SEGMENT_64 => "SegmentCommand64",
-      :LC_ROUTINES_64 => "RoutinesCommand64",
-      :LC_UUID => "UUIDCommand",
-      :LC_RPATH => "RpathCommand",
-      :LC_CODE_SIGNATURE => "LinkeditDataCommand",
-      :LC_SEGMENT_SPLIT_INFO => "LinkeditDataCommand",
-      :LC_REEXPORT_DYLIB => "DylibCommand",
-      :LC_LAZY_LOAD_DYLIB => "DylibCommand",
-      :LC_ENCRYPTION_INFO => "EncryptionInfoCommand",
-      :LC_DYLD_INFO => "DyldInfoCommand",
-      :LC_DYLD_INFO_ONLY => "DyldInfoCommand",
-      :LC_LOAD_UPWARD_DYLIB => "DylibCommand",
-      :LC_VERSION_MIN_MACOSX => "VersionMinCommand",
-      :LC_VERSION_MIN_IPHONEOS => "VersionMinCommand",
-      :LC_FUNCTION_STARTS => "LinkeditDataCommand",
-      :LC_DYLD_ENVIRONMENT => "DylinkerCommand",
-      :LC_MAIN => "EntryPointCommand",
-      :LC_DATA_IN_CODE => "LinkeditDataCommand",
-      :LC_SOURCE_VERSION => "SourceVersionCommand",
-      :LC_DYLIB_CODE_SIGN_DRS => "LinkeditDataCommand",
-      :LC_ENCRYPTION_INFO_64 => "EncryptionInfoCommand64",
-      :LC_LINKER_OPTION => "LinkerOptionCommand",
-      :LC_LINKER_OPTIMIZATION_HINT => "LinkeditDataCommand",
-      :LC_VERSION_MIN_TVOS => "VersionMinCommand",
-      :LC_VERSION_MIN_WATCHOS => "VersionMinCommand",
-      :LC_NOTE => "NoteCommand",
-      :LC_BUILD_VERSION => "BuildVersionCommand",
-      :LC_DYLD_EXPORTS_TRIE => "LinkeditDataCommand",
-      :LC_DYLD_CHAINED_FIXUPS => "LinkeditDataCommand",
-      :LC_FILESET_ENTRY => "FilesetEntryCommand",
-    }.freeze
-
-    # association of segment name symbols to names
-    # @api private
-    SEGMENT_NAMES = {
-      :SEG_PAGEZERO => "__PAGEZERO",
-      :SEG_TEXT => "__TEXT",
-      :SEG_DATA => "__DATA",
-      :SEG_OBJC => "__OBJC",
-      :SEG_ICON => "__ICON",
-      :SEG_LINKEDIT => "__LINKEDIT",
-      :SEG_UNIXSTACK => "__UNIXSTACK",
-      :SEG_IMPORT => "__IMPORT",
-    }.freeze
-
-    # association of segment flag symbols to values
-    # @api private
-    SEGMENT_FLAGS = {
-      :SG_HIGHVM => 0x1,
-      :SG_FVMLIB => 0x2,
-      :SG_NORELOC => 0x4,
-      :SG_PROTECTED_VERSION_1 => 0x8,
-      :SG_READ_ONLY => 0x10,
-    }.freeze
-
-    # The top-level Mach-O load command structure.
-    #
-    # This is the most generic load command -- only the type ID and size are
-    # represented. Used when a more specific class isn't available or isn't implemented.
-    class LoadCommand < MachOStructure
-      # @return [MachO::MachOView, nil] the raw view associated with the load command,
-      #  or nil if the load command was created via {create}.
-      attr_reader :view
-
-      # @return [Integer] the load command's type ID
-      attr_reader :cmd
-
-      # @return [Integer] the size of the load command, in bytes
-      attr_reader :cmdsize
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=2"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 8
-
-      # Instantiates a new LoadCommand given a view into its origin Mach-O
-      # @param view [MachO::MachOView] the load command's raw view
-      # @return [LoadCommand] the new load command
-      # @api private
-      def self.new_from_bin(view)
-        bin = view.raw_data.slice(view.offset, bytesize)
-        format = Utils.specialize_format(self::FORMAT, view.endianness)
-
-        new(view, *bin.unpack(format))
-      end
-
-      # Creates a new (viewless) command corresponding to the symbol provided
-      # @param cmd_sym [Symbol] the symbol of the load command being created
-      # @param args [Array] the arguments for the load command being created
-      def self.create(cmd_sym, *args)
-        raise LoadCommandNotCreatableError, cmd_sym unless CREATABLE_LOAD_COMMANDS.include?(cmd_sym)
-
-        klass = LoadCommands.const_get LC_STRUCTURES[cmd_sym]
-        cmd = LOAD_COMMAND_CONSTANTS[cmd_sym]
-
-        # cmd will be filled in, view and cmdsize will be left unpopulated
-        klass_arity = klass.instance_method(:initialize).arity - 3
-
-        raise LoadCommandCreationArityError.new(cmd_sym, klass_arity, args.size) if klass_arity != args.size
-
-        klass.new(nil, cmd, nil, *args)
-      end
-
-      # @param view [MachO::MachOView] the load command's raw view
-      # @param cmd [Integer] the load command's identifying number
-      # @param cmdsize [Integer] the size of the load command in bytes
-      # @api private
-      def initialize(view, cmd, cmdsize)
-        super()
-        @view = view
-        @cmd = cmd
-        @cmdsize = cmdsize
-      end
-
-      # @return [Boolean] whether the load command can be serialized
-      def serializable?
-        CREATABLE_LOAD_COMMANDS.include?(LOAD_COMMANDS[cmd])
-      end
-
-      # @param context [SerializationContext] the context
-      #  to serialize into
-      # @return [String, nil] the serialized fields of the load command, or nil
-      #  if the load command can't be serialized
-      # @api private
-      def serialize(context)
-        raise LoadCommandNotSerializableError, LOAD_COMMANDS[cmd] unless serializable?
-
-        format = Utils.specialize_format(FORMAT, context.endianness)
-        [cmd, SIZEOF].pack(format)
-      end
-
-      # @return [Integer] the load command's offset in the source file
-      # @deprecated use {#view} instead
-      def offset
-        view.offset
-      end
-
-      # @return [Symbol, nil] a symbol representation of the load command's
-      #  type ID, or nil if the ID doesn't correspond to a known load command class
-      def type
-        LOAD_COMMANDS[cmd]
-      end
-
-      alias to_sym type
-
-      # @return [String] a string representation of the load command's
-      #  identifying number
-      def to_s
-        type.to_s
-      end
-
-      # @return [Hash] a hash representation of this load command
-      # @note Children should override this to include additional information.
-      def to_h
-        {
-          "view" => view.to_h,
-          "cmd" => cmd,
-          "cmdsize" => cmdsize,
-          "type" => type,
-        }.merge super
-      end
-
-      # Represents a Load Command string. A rough analogue to the lc_str
-      # struct used internally by OS X. This class allows ruby-macho to
-      # pretend that strings stored in LCs are immediately available without
-      # explicit operations on the raw Mach-O data.
-      class LCStr
-        # @param lc [LoadCommand] the load command
-        # @param lc_str [Integer, String] the offset to the beginning of the
-        #  string, or the string itself if not being initialized with a view.
-        # @raise [MachO::LCStrMalformedError] if the string is malformed
-        # @todo devise a solution such that the `lc_str` parameter is not
-        #  interpreted differently depending on `lc.view`. The current behavior
-        #  is a hack to allow viewless load command creation.
-        # @api private
-        def initialize(lc, lc_str)
-          view = lc.view
-
-          if view
-            lc_str_abs = view.offset + lc_str
-            lc_end = view.offset + lc.cmdsize - 1
-            raw_string = view.raw_data.slice(lc_str_abs..lc_end)
-            @string, null_byte, _padding = raw_string.partition("\x00")
-
-            raise LCStrMalformedError, lc if null_byte.empty?
-
-            @string_offset = lc_str
-          else
-            @string = lc_str
-            @string_offset = 0
-          end
-        end
-
-        # @return [String] a string representation of the LCStr
-        def to_s
-          @string
-        end
-
-        # @return [Integer] the offset to the beginning of the string in the
-        #  load command
-        def to_i
-          @string_offset
-        end
-
-        # @return [Hash] a hash representation of this {LCStr}.
-        def to_h
-          {
-            "string" => to_s,
-            "offset" => to_i,
-          }
-        end
-      end
-
-      # Represents the contextual information needed by a load command to
-      # serialize itself correctly into a binary string.
-      class SerializationContext
-        # @return [Symbol] the endianness of the serialized load command
-        attr_reader :endianness
-
-        # @return [Integer] the constant alignment value used to pad the
-        #  serialized load command
-        attr_reader :alignment
-
-        # @param macho [MachO::MachOFile] the file to contextualize
-        # @return [SerializationContext] the
-        #  resulting context
-        def self.context_for(macho)
-          new(macho.endianness, macho.alignment)
-        end
-
-        # @param endianness [Symbol] the endianness of the context
-        # @param alignment [Integer] the alignment of the context
-        # @api private
-        def initialize(endianness, alignment)
-          @endianness = endianness
-          @alignment = alignment
-        end
-      end
-    end
-
-    # A load command containing a single 128-bit unique random number
-    # identifying an object produced by static link editor. Corresponds to
-    # LC_UUID.
-    class UUIDCommand < LoadCommand
-      # @return [Array<Integer>] the UUID
-      attr_reader :uuid
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=2a16"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 24
-
-      # @api private
-      def initialize(view, cmd, cmdsize, uuid)
-        super(view, cmd, cmdsize)
-        @uuid = uuid.unpack("C16") # re-unpack for the actual UUID array
-      end
-
-      # @return [String] a string representation of the UUID
-      def uuid_string
-        hexes = uuid.map { |elem| "%02<elem>x" % { :elem => elem } }
-        segs = [
-          hexes[0..3].join, hexes[4..5].join, hexes[6..7].join,
-          hexes[8..9].join, hexes[10..15].join
-        ]
-
-        segs.join("-")
-      end
-
-      # @return [Hash] returns a hash representation of this {UUIDCommand}
-      def to_h
-        {
-          "uuid" => uuid,
-          "uuid_string" => uuid_string,
-        }.merge super
-      end
-    end
-
-    # A load command indicating that part of this file is to be mapped into
-    # the task's address space. Corresponds to LC_SEGMENT.
-    class SegmentCommand < LoadCommand
-      # @return [String] the name of the segment
-      attr_reader :segname
-
-      # @return [Integer] the memory address of the segment
-      attr_reader :vmaddr
-
-      # @return [Integer] the memory size of the segment
-      attr_reader :vmsize
-
-      # @return [Integer] the file offset of the segment
-      attr_reader :fileoff
-
-      # @return [Integer] the amount to map from the file
-      attr_reader :filesize
-
-      # @return [Integer] the maximum VM protection
-      attr_reader :maxprot
-
-      # @return [Integer] the initial VM protection
-      attr_reader :initprot
-
-      # @return [Integer] the number of sections in the segment
-      attr_reader :nsects
-
-      # @return [Integer] any flags associated with the segment
-      attr_reader :flags
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=2Z16L=4l=2L=2"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 56
-
-      # @api private
-      def initialize(view, cmd, cmdsize, segname, vmaddr, vmsize, fileoff,
-                     filesize, maxprot, initprot, nsects, flags)
-        super(view, cmd, cmdsize)
-        @segname = segname
-        @vmaddr = vmaddr
-        @vmsize = vmsize
-        @fileoff = fileoff
-        @filesize = filesize
-        @maxprot = maxprot
-        @initprot = initprot
-        @nsects = nsects
-        @flags = flags
-      end
-
-      # All sections referenced within this segment.
-      # @return [Array<MachO::Sections::Section>] if the Mach-O is 32-bit
-      # @return [Array<MachO::Sections::Section64>] if the Mach-O is 64-bit
-      def sections
-        klass = case self
-        when SegmentCommand64
-          MachO::Sections::Section64
-        when SegmentCommand
-          MachO::Sections::Section
-        end
-
-        offset = view.offset + self.class.bytesize
-        length = nsects * klass.bytesize
-
-        bins = view.raw_data[offset, length]
-        bins.unpack("a#{klass.bytesize}" * nsects).map do |bin|
-          klass.new_from_bin(view.endianness, bin)
-        end
-      end
-
-      # @example
-      #  puts "this segment relocated in/to it" if sect.flag?(:SG_NORELOC)
-      # @param flag [Symbol] a segment flag symbol
-      # @return [Boolean] true if `flag` is present in the segment's flag field
-      def flag?(flag)
-        flag = SEGMENT_FLAGS[flag]
-
-        return false if flag.nil?
-
-        flags & flag == flag
-      end
-
-      # Guesses the alignment of the segment.
-      # @return [Integer] the guessed alignment, as a power of 2
-      # @note See `guess_align` in `cctools/misc/lipo.c`
-      def guess_align
-        return Sections::MAX_SECT_ALIGN if vmaddr.zero?
-
-        align = 0
-        segalign = 1
-
-        while (segalign & vmaddr).zero?
-          segalign <<= 1
-          align += 1
-        end
-
-        return 2 if align < 2
-        return Sections::MAX_SECT_ALIGN if align > Sections::MAX_SECT_ALIGN
-
-        align
-      end
-
-      # @return [Hash] a hash representation of this {SegmentCommand}
-      def to_h
-        {
-          "segname" => segname,
-          "vmaddr" => vmaddr,
-          "vmsize" => vmsize,
-          "fileoff" => fileoff,
-          "filesize" => filesize,
-          "maxprot" => maxprot,
-          "initprot" => initprot,
-          "nsects" => nsects,
-          "flags" => flags,
-          "sections" => sections.map(&:to_h),
-        }.merge super
-      end
-    end
-
-    # A load command indicating that part of this file is to be mapped into
-    # the task's address space. Corresponds to LC_SEGMENT_64.
-    class SegmentCommand64 < SegmentCommand
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=2Z16Q=4l=2L=2"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 72
-    end
-
-    # A load command representing some aspect of shared libraries, depending
-    # on filetype. Corresponds to LC_ID_DYLIB, LC_LOAD_DYLIB,
-    # LC_LOAD_WEAK_DYLIB, and LC_REEXPORT_DYLIB.
-    class DylibCommand < LoadCommand
-      # @return [LCStr] the library's path
-      #  name as an LCStr
-      attr_reader :name
-
-      # @return [Integer] the library's build time stamp
-      attr_reader :timestamp
-
-      # @return [Integer] the library's current version number
-      attr_reader :current_version
-
-      # @return [Integer] the library's compatibility version number
-      attr_reader :compatibility_version
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=6"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 24
-
-      # @api private
-      def initialize(view, cmd, cmdsize, name, timestamp, current_version,
-                     compatibility_version)
-        super(view, cmd, cmdsize)
-        @name = LCStr.new(self, name)
-        @timestamp = timestamp
-        @current_version = current_version
-        @compatibility_version = compatibility_version
-      end
-
-      # @param context [SerializationContext]
-      #  the context
-      # @return [String] the serialized fields of the load command
-      # @api private
-      def serialize(context)
-        format = Utils.specialize_format(FORMAT, context.endianness)
-        string_payload, string_offsets = Utils.pack_strings(SIZEOF,
-                                                            context.alignment,
-                                                            :name => name.to_s)
-        cmdsize = SIZEOF + string_payload.bytesize
-        [cmd, cmdsize, string_offsets[:name], timestamp, current_version,
-         compatibility_version].pack(format) + string_payload
-      end
-
-      # @return [Hash] a hash representation of this {DylibCommand}
-      def to_h
-        {
-          "name" => name.to_h,
-          "timestamp" => timestamp,
-          "current_version" => current_version,
-          "compatibility_version" => compatibility_version,
-        }.merge super
-      end
-    end
-
-    # A load command representing some aspect of the dynamic linker, depending
-    # on filetype. Corresponds to LC_ID_DYLINKER, LC_LOAD_DYLINKER, and
-    # LC_DYLD_ENVIRONMENT.
-    class DylinkerCommand < LoadCommand
-      # @return [LCStr] the dynamic linker's
-      #  path name as an LCStr
-      attr_reader :name
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=3"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 12
-
-      # @api private
-      def initialize(view, cmd, cmdsize, name)
-        super(view, cmd, cmdsize)
-        @name = LCStr.new(self, name)
-      end
-
-      # @param context [SerializationContext]
-      #  the context
-      # @return [String] the serialized fields of the load command
-      # @api private
-      def serialize(context)
-        format = Utils.specialize_format(FORMAT, context.endianness)
-        string_payload, string_offsets = Utils.pack_strings(SIZEOF,
-                                                            context.alignment,
-                                                            :name => name.to_s)
-        cmdsize = SIZEOF + string_payload.bytesize
-        [cmd, cmdsize, string_offsets[:name]].pack(format) + string_payload
-      end
-
-      # @return [Hash] a hash representation of this {DylinkerCommand}
-      def to_h
-        {
-          "name" => name.to_h,
-        }.merge super
-      end
-    end
-
-    # A load command used to indicate dynamic libraries used in prebinding.
-    # Corresponds to LC_PREBOUND_DYLIB.
-    class PreboundDylibCommand < LoadCommand
-      # @return [LCStr] the library's path
-      #  name as an LCStr
-      attr_reader :name
-
-      # @return [Integer] the number of modules in the library
-      attr_reader :nmodules
-
-      # @return [Integer] a bit vector of linked modules
-      attr_reader :linked_modules
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=5"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 20
-
-      # @api private
-      def initialize(view, cmd, cmdsize, name, nmodules, linked_modules)
-        super(view, cmd, cmdsize)
-        @name = LCStr.new(self, name)
-        @nmodules = nmodules
-        @linked_modules = linked_modules
-      end
-
-      # @return [Hash] a hash representation of this {PreboundDylibCommand}
-      def to_h
-        {
-          "name" => name.to_h,
-          "nmodules" => nmodules,
-          "linked_modules" => linked_modules,
-        }.merge super
-      end
-    end
-
-    # A load command used to represent threads.
-    # @note cctools-870 and onwards have all fields of thread_command commented
-    # out except the common ones (cmd, cmdsize)
-    class ThreadCommand < LoadCommand
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=2"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 8
-    end
-
-    # A load command containing the address of the dynamic shared library
-    # initialization routine and an index into the module table for the module
-    # that defines the routine. Corresponds to LC_ROUTINES.
-    class RoutinesCommand < LoadCommand
-      # @return [Integer] the address of the initialization routine
-      attr_reader :init_address
-
-      # @return [Integer] the index into the module table that the init routine
-      #  is defined in
-      attr_reader :init_module
-
-      # @return [void]
-      attr_reader :reserved1
-
-      # @return [void]
-      attr_reader :reserved2
-
-      # @return [void]
-      attr_reader :reserved3
-
-      # @return [void]
-      attr_reader :reserved4
-
-      # @return [void]
-      attr_reader :reserved5
-
-      # @return [void]
-      attr_reader :reserved6
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=10"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 40
-
-      # @api private
-      def initialize(view, cmd, cmdsize, init_address, init_module, reserved1,
-                     reserved2, reserved3, reserved4, reserved5, reserved6)
-        super(view, cmd, cmdsize)
-        @init_address = init_address
-        @init_module = init_module
-        @reserved1 = reserved1
-        @reserved2 = reserved2
-        @reserved3 = reserved3
-        @reserved4 = reserved4
-        @reserved5 = reserved5
-        @reserved6 = reserved6
-      end
-
-      # @return [Hash] a hash representation of this {RoutinesCommand}
-      def to_h
-        {
-          "init_address" => init_address,
-          "init_module" => init_module,
-          "reserved1" => reserved1,
-          "reserved2" => reserved2,
-          "reserved3" => reserved3,
-          "reserved4" => reserved4,
-          "reserved5" => reserved5,
-          "reserved6" => reserved6,
-        }.merge super
-      end
-    end
-
-    # A load command containing the address of the dynamic shared library
-    # initialization routine and an index into the module table for the module
-    # that defines the routine. Corresponds to LC_ROUTINES_64.
-    class RoutinesCommand64 < RoutinesCommand
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=2Q=8"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 72
-    end
-
-    # A load command signifying membership of a subframework containing the name
-    # of an umbrella framework. Corresponds to LC_SUB_FRAMEWORK.
-    class SubFrameworkCommand < LoadCommand
-      # @return [LCStr] the umbrella framework name as an LCStr
-      attr_reader :umbrella
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=3"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 12
-
-      # @api private
-      def initialize(view, cmd, cmdsize, umbrella)
-        super(view, cmd, cmdsize)
-        @umbrella = LCStr.new(self, umbrella)
-      end
-
-      # @return [Hash] a hash representation of this {SubFrameworkCommand}
-      def to_h
-        {
-          "umbrella" => umbrella.to_h,
-        }.merge super
-      end
-    end
-
-    # A load command signifying membership of a subumbrella containing the name
-    # of an umbrella framework. Corresponds to LC_SUB_UMBRELLA.
-    class SubUmbrellaCommand < LoadCommand
-      # @return [LCStr] the subumbrella framework name as an LCStr
-      attr_reader :sub_umbrella
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=3"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 12
-
-      # @api private
-      def initialize(view, cmd, cmdsize, sub_umbrella)
-        super(view, cmd, cmdsize)
-        @sub_umbrella = LCStr.new(self, sub_umbrella)
-      end
-
-      # @return [Hash] a hash representation of this {SubUmbrellaCommand}
-      def to_h
-        {
-          "sub_umbrella" => sub_umbrella.to_h,
-        }.merge super
-      end
-    end
-
-    # A load command signifying a sublibrary of a shared library. Corresponds
-    # to LC_SUB_LIBRARY.
-    class SubLibraryCommand < LoadCommand
-      # @return [LCStr] the sublibrary name as an LCStr
-      attr_reader :sub_library
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=3"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 12
-
-      # @api private
-      def initialize(view, cmd, cmdsize, sub_library)
-        super(view, cmd, cmdsize)
-        @sub_library = LCStr.new(self, sub_library)
-      end
-
-      # @return [Hash] a hash representation of this {SubLibraryCommand}
-      def to_h
-        {
-          "sub_library" => sub_library.to_h,
-        }.merge super
-      end
-    end
-
-    # A load command signifying a shared library that is a subframework of
-    # an umbrella framework. Corresponds to LC_SUB_CLIENT.
-    class SubClientCommand < LoadCommand
-      # @return [LCStr] the subclient name as an LCStr
-      attr_reader :sub_client
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=3"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 12
-
-      # @api private
-      def initialize(view, cmd, cmdsize, sub_client)
-        super(view, cmd, cmdsize)
-        @sub_client = LCStr.new(self, sub_client)
-      end
-
-      # @return [Hash] a hash representation of this {SubClientCommand}
-      def to_h
-        {
-          "sub_client" => sub_client.to_h,
-        }.merge super
-      end
-    end
-
-    # A load command containing the offsets and sizes of the link-edit 4.3BSD
-    # "stab" style symbol table information. Corresponds to LC_SYMTAB.
-    class SymtabCommand < LoadCommand
-      # @return [Integer] the symbol table's offset
-      attr_reader :symoff
-
-      # @return [Integer] the number of symbol table entries
-      attr_reader :nsyms
-
-      # @return [Integer] the string table's offset
-      attr_reader :stroff
-
-      # @return [Integer] the string table size in bytes
-      attr_reader :strsize
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=6"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 24
-
-      # @api private
-      def initialize(view, cmd, cmdsize, symoff, nsyms, stroff, strsize)
-        super(view, cmd, cmdsize)
-        @symoff = symoff
-        @nsyms = nsyms
-        @stroff = stroff
-        @strsize = strsize
-      end
-
-      # @return [Hash] a hash representation of this {SymtabCommand}
-      def to_h
-        {
-          "symoff" => symoff,
-          "nsyms" => nsyms,
-          "stroff" => stroff,
-          "strsize" => strsize,
-        }.merge super
-      end
-    end
-
-    # A load command containing symbolic information needed to support data
-    # structures used by the dynamic link editor. Corresponds to LC_DYSYMTAB.
-    class DysymtabCommand < LoadCommand
-      # @return [Integer] the index to local symbols
-      attr_reader :ilocalsym
-
-      # @return [Integer] the number of local symbols
-      attr_reader :nlocalsym
-
-      # @return [Integer] the index to externally defined symbols
-      attr_reader :iextdefsym
-
-      # @return [Integer] the number of externally defined symbols
-      attr_reader :nextdefsym
-
-      # @return [Integer] the index to undefined symbols
-      attr_reader :iundefsym
-
-      # @return [Integer] the number of undefined symbols
-      attr_reader :nundefsym
-
-      # @return [Integer] the file offset to the table of contents
-      attr_reader :tocoff
-
-      # @return [Integer] the number of entries in the table of contents
-      attr_reader :ntoc
-
-      # @return [Integer] the file offset to the module table
-      attr_reader :modtaboff
-
-      # @return [Integer] the number of entries in the module table
-      attr_reader :nmodtab
-
-      # @return [Integer] the file offset to the referenced symbol table
-      attr_reader :extrefsymoff
-
-      # @return [Integer] the number of entries in the referenced symbol table
-      attr_reader :nextrefsyms
-
-      # @return [Integer] the file offset to the indirect symbol table
-      attr_reader :indirectsymoff
-
-      # @return [Integer] the number of entries in the indirect symbol table
-      attr_reader :nindirectsyms
-
-      # @return [Integer] the file offset to the external relocation entries
-      attr_reader :extreloff
-
-      # @return [Integer] the number of external relocation entries
-      attr_reader :nextrel
-
-      # @return [Integer] the file offset to the local relocation entries
-      attr_reader :locreloff
-
-      # @return [Integer] the number of local relocation entries
-      attr_reader :nlocrel
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=20"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 80
-
-      # ugh
-      # @api private
-      def initialize(view, cmd, cmdsize, ilocalsym, nlocalsym, iextdefsym,
-                     nextdefsym, iundefsym, nundefsym, tocoff, ntoc, modtaboff,
-                     nmodtab, extrefsymoff, nextrefsyms, indirectsymoff,
-                     nindirectsyms, extreloff, nextrel, locreloff, nlocrel)
-        super(view, cmd, cmdsize)
-        @ilocalsym = ilocalsym
-        @nlocalsym = nlocalsym
-        @iextdefsym = iextdefsym
-        @nextdefsym = nextdefsym
-        @iundefsym = iundefsym
-        @nundefsym = nundefsym
-        @tocoff = tocoff
-        @ntoc = ntoc
-        @modtaboff = modtaboff
-        @nmodtab = nmodtab
-        @extrefsymoff = extrefsymoff
-        @nextrefsyms = nextrefsyms
-        @indirectsymoff = indirectsymoff
-        @nindirectsyms = nindirectsyms
-        @extreloff = extreloff
-        @nextrel = nextrel
-        @locreloff = locreloff
-        @nlocrel = nlocrel
-      end
-
-      # @return [Hash] a hash representation of this {DysymtabCommand}
-      def to_h
-        {
-          "ilocalsym" => ilocalsym,
-          "nlocalsym" => nlocalsym,
-          "iextdefsym" => iextdefsym,
-          "nextdefsym" => nextdefsym,
-          "iundefsym" => iundefsym,
-          "nundefsym" => nundefsym,
-          "tocoff" => tocoff,
-          "ntoc" => ntoc,
-          "modtaboff" => modtaboff,
-          "nmodtab" => nmodtab,
-          "extrefsymoff" => extrefsymoff,
-          "nextrefsyms" => nextrefsyms,
-          "indirectsymoff" => indirectsymoff,
-          "nindirectsyms" => nindirectsyms,
-          "extreloff" => extreloff,
-          "nextrel" => nextrel,
-          "locreloff" => locreloff,
-          "nlocrel" => nlocrel,
-        }.merge super
-      end
-    end
-
-    # A load command containing the offset and number of hints in the two-level
-    # namespace lookup hints table. Corresponds to LC_TWOLEVEL_HINTS.
-    class TwolevelHintsCommand < LoadCommand
-      # @return [Integer] the offset to the hint table
-      attr_reader :htoffset
-
-      # @return [Integer] the number of hints in the hint table
-      attr_reader :nhints
-
-      # @return [TwolevelHintsTable]
-      #  the hint table
-      attr_reader :table
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=4"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 16
-
-      # @api private
-      def initialize(view, cmd, cmdsize, htoffset, nhints)
-        super(view, cmd, cmdsize)
-        @htoffset = htoffset
-        @nhints = nhints
-        @table = TwolevelHintsTable.new(view, htoffset, nhints)
-      end
-
-      # @return [Hash] a hash representation of this {TwolevelHintsCommand}
-      def to_h
-        {
-          "htoffset" => htoffset,
-          "nhints" => nhints,
-          "table" => table.hints.map(&:to_h),
-        }.merge super
-      end
-
-      # A representation of the two-level namespace lookup hints table exposed
-      # by a {TwolevelHintsCommand} (`LC_TWOLEVEL_HINTS`).
-      class TwolevelHintsTable
-        # @return [Array<TwolevelHint>] all hints in the table
-        attr_reader :hints
-
-        # @param view [MachO::MachOView] the view into the current Mach-O
-        # @param htoffset [Integer] the offset of the hints table
-        # @param nhints [Integer] the number of two-level hints in the table
-        # @api private
-        def initialize(view, htoffset, nhints)
-          format = Utils.specialize_format("L=#{nhints}", view.endianness)
-          raw_table = view.raw_data[htoffset, nhints * 4]
-          blobs = raw_table.unpack(format)
-
-          @hints = blobs.map { |b| TwolevelHint.new(b) }
-        end
-
-        # An individual two-level namespace lookup hint.
-        class TwolevelHint
-          # @return [Integer] the index into the sub-images
-          attr_reader :isub_image
-
-          # @return [Integer] the index into the table of contents
-          attr_reader :itoc
-
-          # @param blob [Integer] the 32-bit number containing the lookup hint
-          # @api private
-          def initialize(blob)
-            @isub_image = blob >> 24
-            @itoc = blob & 0x00FFFFFF
-          end
-
-          # @return [Hash] a hash representation of this {TwolevelHint}
-          def to_h
-            {
-              "isub_image" => isub_image,
-              "itoc" => itoc,
-            }
-          end
-        end
-      end
-    end
-
-    # A load command containing the value of the original checksum for prebound
-    # files, or zero. Corresponds to LC_PREBIND_CKSUM.
-    class PrebindCksumCommand < LoadCommand
-      # @return [Integer] the checksum or 0
-      attr_reader :cksum
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=3"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 12
-
-      # @api private
-      def initialize(view, cmd, cmdsize, cksum)
-        super(view, cmd, cmdsize)
-        @cksum = cksum
-      end
-
-      # @return [Hash] a hash representation of this {PrebindCksumCommand}
-      def to_h
-        {
-          "cksum" => cksum,
-        }.merge super
-      end
-    end
-
-    # A load command representing an rpath, which specifies a path that should
-    # be added to the current run path used to find @rpath prefixed dylibs.
-    # Corresponds to LC_RPATH.
-    class RpathCommand < LoadCommand
-      # @return [LCStr] the path to add to the run path as an LCStr
-      attr_reader :path
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=3"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 12
-
-      # @api private
-      def initialize(view, cmd, cmdsize, path)
-        super(view, cmd, cmdsize)
-        @path = LCStr.new(self, path)
-      end
-
-      # @param context [SerializationContext] the context
-      # @return [String] the serialized fields of the load command
-      # @api private
-      def serialize(context)
-        format = Utils.specialize_format(FORMAT, context.endianness)
-        string_payload, string_offsets = Utils.pack_strings(SIZEOF,
-                                                            context.alignment,
-                                                            :path => path.to_s)
-        cmdsize = SIZEOF + string_payload.bytesize
-        [cmd, cmdsize, string_offsets[:path]].pack(format) + string_payload
-      end
-
-      # @return [Hash] a hash representation of this {RpathCommand}
-      def to_h
-        {
-          "path" => path.to_h,
-        }.merge super
-      end
-    end
-
-    # A load command representing the offsets and sizes of a blob of data in
-    # the __LINKEDIT segment. Corresponds to LC_CODE_SIGNATURE,
-    # LC_SEGMENT_SPLIT_INFO, LC_FUNCTION_STARTS, LC_DATA_IN_CODE,
-    # LC_DYLIB_CODE_SIGN_DRS, LC_LINKER_OPTIMIZATION_HINT, LC_DYLD_EXPORTS_TRIE,
-    # or LC_DYLD_CHAINED_FIXUPS.
-    class LinkeditDataCommand < LoadCommand
-      # @return [Integer] offset to the data in the __LINKEDIT segment
-      attr_reader :dataoff
-
-      # @return [Integer] size of the data in the __LINKEDIT segment
-      attr_reader :datasize
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=4"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 16
-
-      # @api private
-      def initialize(view, cmd, cmdsize, dataoff, datasize)
-        super(view, cmd, cmdsize)
-        @dataoff = dataoff
-        @datasize = datasize
-      end
-
-      # @return [Hash] a hash representation of this {LinkeditDataCommand}
-      def to_h
-        {
-          "dataoff" => dataoff,
-          "datasize" => datasize,
-        }.merge super
-      end
-    end
-
-    # A load command representing the offset to and size of an encrypted
-    # segment. Corresponds to LC_ENCRYPTION_INFO.
-    class EncryptionInfoCommand < LoadCommand
-      # @return [Integer] the offset to the encrypted segment
-      attr_reader :cryptoff
-
-      # @return [Integer] the size of the encrypted segment
-      attr_reader :cryptsize
-
-      # @return [Integer] the encryption system, or 0 if not encrypted yet
-      attr_reader :cryptid
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=5"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 20
-
-      # @api private
-      def initialize(view, cmd, cmdsize, cryptoff, cryptsize, cryptid)
-        super(view, cmd, cmdsize)
-        @cryptoff = cryptoff
-        @cryptsize = cryptsize
-        @cryptid = cryptid
-      end
-
-      # @return [Hash] a hash representation of this {EncryptionInfoCommand}
-      def to_h
-        {
-          "cryptoff" => cryptoff,
-          "cryptsize" => cryptsize,
-          "cryptid" => cryptid,
-        }.merge super
-      end
-    end
-
-    # A load command representing the offset to and size of an encrypted
-    # segment. Corresponds to LC_ENCRYPTION_INFO_64.
-    class EncryptionInfoCommand64 < EncryptionInfoCommand
-      # @return [Integer] 64-bit padding value
-      attr_reader :pad
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=6"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 24
-
-      # @api private
-      def initialize(view, cmd, cmdsize, cryptoff, cryptsize, cryptid, pad)
-        super(view, cmd, cmdsize, cryptoff, cryptsize, cryptid)
-        @pad = pad
-      end
-
-      # @return [Hash] a hash representation of this {EncryptionInfoCommand64}
-      def to_h
-        {
-          "pad" => pad,
-        }.merge super
-      end
-    end
-
-    # A load command containing the minimum OS version on which the binary
-    # was built to run. Corresponds to LC_VERSION_MIN_MACOSX and
-    # LC_VERSION_MIN_IPHONEOS.
-    class VersionMinCommand < LoadCommand
-      # @return [Integer] the version X.Y.Z packed as x16.y8.z8
-      attr_reader :version
-
-      # @return [Integer] the SDK version X.Y.Z packed as x16.y8.z8
-      attr_reader :sdk
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=4"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 16
-
-      # @api private
-      def initialize(view, cmd, cmdsize, version, sdk)
-        super(view, cmd, cmdsize)
-        @version = version
-        @sdk = sdk
-      end
-
-      # A string representation of the binary's minimum OS version.
-      # @return [String] a string representing the minimum OS version.
-      def version_string
-        binary = "%032<version>b" % { :version => version }
-        segs = [
-          binary[0..15], binary[16..23], binary[24..31]
-        ].map { |s| s.to_i(2) }
-
-        segs.join(".")
-      end
-
-      # A string representation of the binary's SDK version.
-      # @return [String] a string representing the SDK version.
-      def sdk_string
-        binary = "%032<sdk>b" % { :sdk => sdk }
-        segs = [
-          binary[0..15], binary[16..23], binary[24..31]
-        ].map { |s| s.to_i(2) }
-
-        segs.join(".")
-      end
-
-      # @return [Hash] a hash representation of this {VersionMinCommand}
-      def to_h
-        {
-          "version" => version,
-          "version_string" => version_string,
-          "sdk" => sdk,
-          "sdk_string" => sdk_string,
-        }.merge super
-      end
-    end
-
-    # A load command containing the minimum OS version on which
-    # the binary was built for its platform.
-    # Corresponds to LC_BUILD_VERSION.
-    class BuildVersionCommand < LoadCommand
-      # @return [Integer]
-      attr_reader :platform
-
-      # @return [Integer] the minimum OS version X.Y.Z packed as x16.y8.z8
-      attr_reader :minos
-
-      # @return [Integer] the SDK version X.Y.Z packed as x16.y8.z8
-      attr_reader :sdk
-
-      # @return [ToolEntries] tool entries
-      attr_reader :tool_entries
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=6"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 24
-
-      # @api private
-      def initialize(view, cmd, cmdsize, platform, minos, sdk, ntools)
-        super(view, cmd, cmdsize)
-        @platform = platform
-        @minos = minos
-        @sdk = sdk
-        @tool_entries = ToolEntries.new(view, ntools)
-      end
-
-      # A string representation of the binary's minimum OS version.
-      # @return [String] a string representing the minimum OS version.
-      def minos_string
-        binary = "%032<minos>b" % { :minos => minos }
-        segs = [
-          binary[0..15], binary[16..23], binary[24..31]
-        ].map { |s| s.to_i(2) }
-
-        segs.join(".")
-      end
-
-      # A string representation of the binary's SDK version.
-      # @return [String] a string representing the SDK version.
-      def sdk_string
-        binary = "%032<sdk>b" % { :sdk => sdk }
-        segs = [
-          binary[0..15], binary[16..23], binary[24..31]
-        ].map { |s| s.to_i(2) }
-
-        segs.join(".")
-      end
-
-      # @return [Hash] a hash representation of this {BuildVersionCommand}
-      def to_h
-        {
-          "platform" => platform,
-          "minos" => minos,
-          "minos_string" => minos_string,
-          "sdk" => sdk,
-          "sdk_string" => sdk_string,
-          "tool_entries" => tool_entries.tools.map(&:to_h),
-        }.merge super
-      end
-
-      # A representation of the tool versions exposed
-      # by a {BuildVersionCommand} (`LC_BUILD_VERSION`).
-      class ToolEntries
-        # @return [Array<Tool>] all tools
-        attr_reader :tools
-
-        # @param view [MachO::MachOView] the view into the current Mach-O
-        # @param ntools [Integer] the number of tools
-        # @api private
-        def initialize(view, ntools)
-          format = Utils.specialize_format("L=#{ntools * 2}", view.endianness)
-          raw_table = view.raw_data[view.offset + 24, ntools * 8]
-          blobs = raw_table.unpack(format).each_slice(2).to_a
-
-          @tools = blobs.map { |b| Tool.new(*b) }
-        end
-
-        # An individual tool.
-        class Tool
-          # @return [Integer] the enum for the tool
-          attr_reader :tool
-
-          # @return [Integer] the tool's version number
-          attr_reader :version
-
-          # @param tool [Integer] 32-bit integer
-          # @param version [Integer] 32-bit integer
-          # @api private
-          def initialize(tool, version)
-            @tool = tool
-            @version = version
-          end
-
-          # @return [Hash] a hash representation of this {Tool}
-          def to_h
-            {
-              "tool" => tool,
-              "version" => version,
-            }
-          end
-        end
-      end
-    end
-
-    # A load command containing the file offsets and sizes of the new
-    # compressed form of the information dyld needs to load the image.
-    # Corresponds to LC_DYLD_INFO and LC_DYLD_INFO_ONLY.
-    class DyldInfoCommand < LoadCommand
-      # @return [Integer] the file offset to the rebase information
-      attr_reader :rebase_off
-
-      # @return [Integer] the size of the rebase information
-      attr_reader :rebase_size
-
-      # @return [Integer] the file offset to the binding information
-      attr_reader :bind_off
-
-      # @return [Integer] the size of the binding information
-      attr_reader :bind_size
-
-      # @return [Integer] the file offset to the weak binding information
-      attr_reader :weak_bind_off
-
-      # @return [Integer] the size of the weak binding information
-      attr_reader :weak_bind_size
-
-      # @return [Integer] the file offset to the lazy binding information
-      attr_reader :lazy_bind_off
-
-      # @return [Integer] the size of the lazy binding information
-      attr_reader :lazy_bind_size
-
-      # @return [Integer] the file offset to the export information
-      attr_reader :export_off
-
-      # @return [Integer] the size of the export information
-      attr_reader :export_size
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=12"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 48
-
-      # @api private
-      def initialize(view, cmd, cmdsize, rebase_off, rebase_size, bind_off,
-                     bind_size, weak_bind_off, weak_bind_size, lazy_bind_off,
-                     lazy_bind_size, export_off, export_size)
-        super(view, cmd, cmdsize)
-        @rebase_off = rebase_off
-        @rebase_size = rebase_size
-        @bind_off = bind_off
-        @bind_size = bind_size
-        @weak_bind_off = weak_bind_off
-        @weak_bind_size = weak_bind_size
-        @lazy_bind_off = lazy_bind_off
-        @lazy_bind_size = lazy_bind_size
-        @export_off = export_off
-        @export_size = export_size
-      end
-
-      # @return [Hash] a hash representation of this {DyldInfoCommand}
-      def to_h
-        {
-          "rebase_off" => rebase_off,
-          "rebase_size" => rebase_size,
-          "bind_off" => bind_off,
-          "bind_size" => bind_size,
-          "weak_bind_off" => weak_bind_off,
-          "weak_bind_size" => weak_bind_size,
-          "lazy_bind_off" => lazy_bind_off,
-          "lazy_bind_size" => lazy_bind_size,
-          "export_off" => export_off,
-          "export_size" => export_size,
-        }.merge super
-      end
-    end
-
-    # A load command containing linker options embedded in object files.
-    # Corresponds to LC_LINKER_OPTION.
-    class LinkerOptionCommand < LoadCommand
-      # @return [Integer] the number of strings
-      attr_reader :count
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=3"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 12
-
-      # @api private
-      def initialize(view, cmd, cmdsize, count)
-        super(view, cmd, cmdsize)
-        @count = count
-      end
-
-      # @return [Hash] a hash representation of this {LinkerOptionCommand}
-      def to_h
-        {
-          "count" => count,
-        }.merge super
-      end
-    end
-
-    # A load command specifying the offset of main(). Corresponds to LC_MAIN.
-    class EntryPointCommand < LoadCommand
-      # @return [Integer] the file (__TEXT) offset of main()
-      attr_reader :entryoff
-
-      # @return [Integer] if not 0, the initial stack size.
-      attr_reader :stacksize
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=2Q=2"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 24
-
-      # @api private
-      def initialize(view, cmd, cmdsize, entryoff, stacksize)
-        super(view, cmd, cmdsize)
-        @entryoff = entryoff
-        @stacksize = stacksize
-      end
-
-      # @return [Hash] a hash representation of this {EntryPointCommand}
-      def to_h
-        {
-          "entryoff" => entryoff,
-          "stacksize" => stacksize,
-        }.merge super
-      end
-    end
-
-    # A load command specifying the version of the sources used to build the
-    # binary. Corresponds to LC_SOURCE_VERSION.
-    class SourceVersionCommand < LoadCommand
-      # @return [Integer] the version packed as a24.b10.c10.d10.e10
-      attr_reader :version
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=2Q=1"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 16
-
-      # @api private
-      def initialize(view, cmd, cmdsize, version)
-        super(view, cmd, cmdsize)
-        @version = version
-      end
-
-      # A string representation of the sources used to build the binary.
-      # @return [String] a string representation of the version
-      def version_string
-        binary = "%064<version>b" % { :version => version }
-        segs = [
-          binary[0..23], binary[24..33], binary[34..43], binary[44..53],
-          binary[54..63]
-        ].map { |s| s.to_i(2) }
-
-        segs.join(".")
-      end
-
-      # @return [Hash] a hash representation of this {SourceVersionCommand}
-      def to_h
-        {
-          "version" => version,
-          "version_string" => version_string,
-        }.merge super
-      end
-    end
-
-    # An obsolete load command containing the offset and size of the (GNU style)
-    # symbol table information. Corresponds to LC_SYMSEG.
-    class SymsegCommand < LoadCommand
-      # @return [Integer] the offset to the symbol segment
-      attr_reader :offset
-
-      # @return [Integer] the size of the symbol segment in bytes
-      attr_reader :size
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=4"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 16
-
-      # @api private
-      def initialize(view, cmd, cmdsize, offset, size)
-        super(view, cmd, cmdsize)
-        @offset = offset
-        @size = size
-      end
-
-      # @return [Hash] a hash representation of this {SymsegCommand}
-      def to_h
-        {
-          "offset" => offset,
-          "size" => size,
-        }.merge super
-      end
-    end
-
-    # An obsolete load command containing a free format string table. Each
-    # string is null-terminated and the command is zero-padded to a multiple of
-    # 4. Corresponds to LC_IDENT.
-    class IdentCommand < LoadCommand
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=2"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 8
-    end
-
-    # An obsolete load command containing the path to a file to be loaded into
-    # memory. Corresponds to LC_FVMFILE.
-    class FvmfileCommand < LoadCommand
-      # @return [LCStr] the pathname of the file being loaded
-      attr_reader :name
-
-      # @return [Integer] the virtual address being loaded at
-      attr_reader :header_addr
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=4"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 16
-
-      def initialize(view, cmd, cmdsize, name, header_addr)
-        super(view, cmd, cmdsize)
-        @name = LCStr.new(self, name)
-        @header_addr = header_addr
-      end
-
-      # @return [Hash] a hash representation of this {FvmfileCommand}
-      def to_h
-        {
-          "name" => name.to_h,
-          "header_addr" => header_addr,
-        }.merge super
-      end
-    end
-
-    # An obsolete load command containing the path to a library to be loaded
-    # into memory. Corresponds to LC_LOADFVMLIB and LC_IDFVMLIB.
-    class FvmlibCommand < LoadCommand
-      # @return [LCStr] the library's target pathname
-      attr_reader :name
-
-      # @return [Integer] the library's minor version number
-      attr_reader :minor_version
-
-      # @return [Integer] the library's header address
-      attr_reader :header_addr
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=5"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 20
-
-      def initialize(view, cmd, cmdsize, name, minor_version, header_addr)
-        super(view, cmd, cmdsize)
-        @name = LCStr.new(self, name)
-        @minor_version = minor_version
-        @header_addr = header_addr
-      end
-
-      # @return [Hash] a hash representation of this {FvmlibCommand}
-      def to_h
-        {
-          "name" => name.to_h,
-          "minor_version" => minor_version,
-          "header_addr" => header_addr,
-        }.merge super
-      end
-    end
-
-    # A load command containing an owner name and offset/size for an arbitrary data region.
-    # Corresponds to LC_NOTE.
-    class NoteCommand < LoadCommand
-      # @return [String] the name of the owner for this note
-      attr_reader :data_owner
-
-      # @return [Integer] the offset, within the file, of the note
-      attr_reader :offset
-
-      # @return [Integer] the size, in bytes, of the note
-      attr_reader :size
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=2Z16Q=2"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 48
-
-      def initialize(view, cmd, cmdsize, data_owner, offset, size)
-        super(view, cmd, cmdsize)
-        @data_owner = data_owner
-        @offset = offset
-        @size = size
-      end
-
-      # @return [Hash] a hash representation of this {NoteCommand}
-      def to_h
-        {
-          "data_owner" => data_owner,
-          "offset" => offset,
-          "size" => size,
-        }.merge super
-      end
-    end
-
-    # A load command containing a description of a Mach-O that is a constituent of a fileset.
-    # Each entry is further described by its own Mach header.
-    # Corresponds to LC_FILESET_ENTRY.
-    class FilesetEntryCommand < LoadCommand
-      # @return [Integer] the virtual memory address of the entry
-      attr_reader :vmaddr
-
-      # @return [Integer] the file offset of the entry
-      attr_reader :fileoff
-
-      # @return [LCStr] the entry's ID
-      attr_reader :entry_id
-
-      # @return [void]
-      attr_reader :reserved
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=2Q=2L=2"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 28
-
-      def initialize(view, cmd, cmdsize, vmaddr, fileoff, entry_id, reserved)
-        super(view, cmd, cmdsize)
-        @vmaddr = vmaddr
-        @fileoff = fileoff
-        @entry_id = LCStr.new(self, entry_id)
-        @reserved = reserved
-      end
-
-      # @return [Hash] a hash representation of this {FilesetEntryCommand}
-      def to_h
-        {
-          "vmaddr" => vmaddr,
-          "fileoff" => fileoff,
-          "entry_id" => entry_id,
-          "reserved" => reserved,
-        }.merge super
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/structure.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/structure.rb
deleted file mode 100644
index 0356d605af695..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/structure.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module MachO
-  # A general purpose pseudo-structure.
-  # @abstract
-  class MachOStructure
-    # The String#unpack format of the data structure.
-    # @return [String] the unpacking format
-    # @api private
-    FORMAT = ""
-
-    # The size of the data structure, in bytes.
-    # @return [Integer] the size, in bytes
-    # @api private
-    SIZEOF = 0
-
-    # @return [Integer] the size, in bytes, of the represented structure.
-    def self.bytesize
-      self::SIZEOF
-    end
-
-    # @param endianness [Symbol] either `:big` or `:little`
-    # @param bin [String] the string to be unpacked into the new structure
-    # @return [MachO::MachOStructure] the resulting structure
-    # @api private
-    def self.new_from_bin(endianness, bin)
-      format = Utils.specialize_format(self::FORMAT, endianness)
-
-      new(*bin.unpack(format))
-    end
-
-    # @return [Hash] a hash representation of this {MachOStructure}.
-    def to_h
-      {
-        "structure" => {
-          "format" => self.class::FORMAT,
-          "bytesize" => self.class.bytesize,
-        },
-      }
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/view.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/view.rb
deleted file mode 100644
index ad68ee30ed611..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/view.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module MachO
-  # A representation of some unspecified Mach-O data.
-  class MachOView
-    # @return [String] the raw Mach-O data
-    attr_reader :raw_data
-
-    # @return [Symbol] the endianness of the data (`:big` or `:little`)
-    attr_reader :endianness
-
-    # @return [Integer] the offset of the relevant data (in {#raw_data})
-    attr_reader :offset
-
-    # Creates a new MachOView.
-    # @param raw_data [String] the raw Mach-O data
-    # @param endianness [Symbol] the endianness of the data
-    # @param offset [Integer] the offset of the relevant data
-    def initialize(raw_data, endianness, offset)
-      @raw_data = raw_data
-      @endianness = endianness
-      @offset = offset
-    end
-
-    # @return [Hash] a hash representation of this {MachOView}.
-    def to_h
-      {
-        "endianness" => endianness,
-        "offset" => offset,
-      }
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar.rb
deleted file mode 100644
index 48962f25785b1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'ruby-progressbar/output'
-require 'ruby-progressbar/outputs/tty'
-require 'ruby-progressbar/outputs/non_tty'
-require 'ruby-progressbar/timer'
-require 'ruby-progressbar/progress'
-require 'ruby-progressbar/throttle'
-require 'ruby-progressbar/calculators/length'
-require 'ruby-progressbar/calculators/running_average'
-require 'ruby-progressbar/components'
-require 'ruby-progressbar/format'
-require 'ruby-progressbar/base'
-require 'ruby-progressbar/refinements' if Module.
-                                         private_instance_methods.
-                                         include?(:using)
-
-class ProgressBar
-  def self.create(*args)
-    ProgressBar::Base.new(*args)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb
deleted file mode 100644
index 3afb728f65e31..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb
+++ /dev/null
@@ -1,183 +0,0 @@
-require 'forwardable'
-
-class   ProgressBar
-class   Base
-  extend Forwardable
-
-  def_delegators :output,
-                 :clear,
-                 :log,
-                 :refresh
-
-  def_delegators :progressable,
-                 :progress,
-                 :total
-
-  def initialize(options = {}) # rubocop:disable Metrics/AbcSize
-    self.autostart    = options.fetch(:autostart,  true)
-    self.autofinish   = options.fetch(:autofinish, true)
-    self.finished     = false
-
-    self.timer        = Timer.new(options)
-    self.progressable = Progress.new(options)
-
-    options           = options.merge(:timer    => timer,
-                                      :progress => progressable)
-
-    self.title_comp   = Components::Title.new(options)
-    self.bar          = Components::Bar.new(options)
-    self.percentage   = Components::Percentage.new(options)
-    self.rate         = Components::Rate.new(options)
-    self.time         = Components::Time.new(options)
-
-    self.output       = Output.detect(options.merge(:bar => self))
-    @format           = Format::String.new(output.resolve_format(options[:format]))
-
-    start :at => options[:starting_at] if autostart
-  end
-
-  def start(options = {})
-    timer.start
-    update_progress(:start, options)
-  end
-
-  def finish
-    return if finished?
-
-    output.with_refresh do
-      self.finished = true
-      progressable.finish
-      timer.stop
-    end
-  end
-
-  def pause
-    output.with_refresh { timer.pause } unless paused?
-  end
-
-  def stop
-    output.with_refresh { timer.stop } unless stopped?
-  end
-
-  def resume
-    output.with_refresh { timer.resume } if stopped?
-  end
-
-  def reset
-    output.with_refresh do
-      self.finished = false
-      progressable.reset
-      timer.reset
-    end
-  end
-
-  def stopped?
-    timer.stopped? || finished?
-  end
-
-  alias paused? stopped?
-
-  def finished?
-    finished || (autofinish && progressable.finished?)
-  end
-
-  def started?
-    timer.started?
-  end
-
-  def decrement
-    update_progress(:decrement)
-  end
-
-  def increment
-    update_progress(:increment)
-  end
-
-  def progress=(new_progress)
-    update_progress(:progress=, new_progress)
-  end
-
-  def total=(new_total)
-    update_progress(:total=, new_total)
-  end
-
-  def progress_mark=(mark)
-    output.refresh_with_format_change { bar.progress_mark = mark }
-  end
-
-  def remainder_mark=(mark)
-    output.refresh_with_format_change { bar.remainder_mark = mark }
-  end
-
-  def title
-    title_comp.title
-  end
-
-  def title=(title)
-    output.refresh_with_format_change { title_comp.title = title }
-  end
-
-  def to_s(new_format = nil)
-    self.format = new_format if new_format
-
-    Format::Formatter.process(@format, output.length, self)
-  end
-
-  # rubocop:disable Metrics/AbcSize, Layout/LineLength
-  def to_h
-    {
-      'output_stream'                       => output.__send__(:stream),
-      'length'                              => output.length,
-      'title'                               => title_comp.title,
-      'progress_mark'                       => bar.progress_mark,
-      'remainder_mark'                      => bar.remainder_mark,
-      'progress'                            => progressable.progress,
-      'total'                               => progressable.total,
-      'percentage'                          => progressable.percentage_completed_with_precision.to_f,
-      'elapsed_time_in_seconds'             => time.__send__(:timer).elapsed_seconds,
-      'estimated_time_remaining_in_seconds' => time.__send__(:estimated_seconds_remaining),
-      'base_rate_of_change'                 => rate.__send__(:base_rate),
-      'scaled_rate_of_change'               => rate.__send__(:scaled_rate),
-      'unknown_progress_animation_steps'    => bar.upa_steps,
-      'throttle_rate'                       => output.__send__(:throttle).rate,
-      'started?'                            => started?,
-      'stopped?'                            => stopped?,
-      'finished?'                           => finished?
-    }
-  end
-  # rubocop:enable Metrics/AbcSize, Layout/LineLength
-
-  def inspect
-    "#<ProgressBar:#{progress}/#{total || 'unknown'}>"
-  end
-
-  def format=(other)
-    output.refresh_with_format_change do
-      @format = Format::String.new(other || output.default_format)
-    end
-  end
-
-  alias format format=
-
-  protected
-
-  attr_accessor :output,
-                :timer,
-                :progressable,
-                :title_comp,
-                :bar,
-                :percentage,
-                :rate,
-                :time,
-                :autostart,
-                :autofinish,
-                :finished
-
-  def update_progress(*args)
-    output.with_refresh do
-      progressable.__send__(*args)
-      timer.stop if finished?
-    end
-  end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb
deleted file mode 100644
index 8ff6e38b14bc4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-class   ProgressBar
-module  Calculators
-class   Length
-  attr_reader   :length_override
-  attr_accessor :current_length,
-                :output
-
-  def initialize(options = {})
-    self.length_override = options[:length]
-    self.output          = options[:output]
-    self.current_length  = nil
-  end
-
-  def length
-    current_length || reset_length
-  end
-
-  def length_changed?
-    previous_length     = current_length
-    self.current_length = calculate_length
-
-    previous_length != current_length
-  end
-
-  def calculate_length
-    length_override || terminal_width || 80
-  end
-
-  def reset_length
-    self.current_length = calculate_length
-  end
-
-  def length_override=(other)
-    @length_override ||= ENV['RUBY_PROGRESS_BAR_LENGTH'] || other
-    @length_override = @length_override.to_i if @length_override
-  end
-
-  private
-
-  # This code was copied and modified from Rake, available under MIT-LICENSE
-  # Copyright (c) 2003, 2004 Jim Weirich
-  # rubocop:disable Style/RescueStandardError
-  def terminal_width
-    return 80 unless unix?
-
-    result = dynamic_width
-    (result < 20) ? 80 : result
-  rescue
-    80
-  end
-  # rubocop:enable Style/RescueStandardError
-
-  # rubocop:disable Lint/DuplicateMethods
-  begin
-    require 'io/console'
-
-    def dynamic_width
-      if output && output.tty? && output.respond_to?(:winsize)
-        dynamic_width_via_output_stream_object
-      elsif IO.console
-        dynamic_width_via_io_object
-      else
-        dynamic_width_via_system_calls
-      end
-    end
-  rescue LoadError
-    def dynamic_width
-      dynamic_width_via_system_calls
-    end
-  end
-  # rubocop:enable Lint/DuplicateMethods
-
-  def dynamic_width_via_output_stream_object
-    _rows, columns = output.winsize
-    columns
-  end
-
-  def dynamic_width_via_io_object
-    _rows, columns = IO.console.winsize
-    columns
-  end
-
-  def dynamic_width_via_system_calls
-    dynamic_width_stty.nonzero? || dynamic_width_tput
-  end
-
-  def dynamic_width_stty
-    `stty size 2>/dev/null`.split[1].to_i
-  end
-
-  def dynamic_width_tput
-    `tput cols 2>/dev/null`.to_i
-  end
-
-  def unix?
-    RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
-  end
-end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/running_average.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/running_average.rb
deleted file mode 100644
index 45fae7238b32e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/running_average.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-class   ProgressBar
-module  Calculators
-class   RunningAverage
-  def self.calculate(current_average, new_value_to_average, smoothing_factor)
-    new_value_to_average * (1.0 - smoothing_factor) + current_average * smoothing_factor
-  end
-end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components.rb
deleted file mode 100644
index 20ee0595dfe6a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-require 'ruby-progressbar/components/bar'
-require 'ruby-progressbar/components/percentage'
-require 'ruby-progressbar/components/rate'
-require 'ruby-progressbar/components/time'
-require 'ruby-progressbar/components/title'
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb
deleted file mode 100644
index c409bbf8aebd2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb
+++ /dev/null
@@ -1,102 +0,0 @@
-###
-# UPA = Unknown Progress Animation
-#
-class   ProgressBar
-module  Components
-class   Bar
-  DEFAULT_PROGRESS_MARK  = '='.freeze
-  DEFAULT_REMAINDER_MARK = ' '.freeze
-  DEFAULT_UPA_STEPS      = ['=---', '-=--', '--=-', '---='].freeze
-
-  attr_accessor :progress_mark,
-                :remainder_mark,
-                :length,
-                :progress,
-                :upa_steps
-
-  def initialize(options = {})
-    self.upa_steps      = options[:unknown_progress_animation_steps] || DEFAULT_UPA_STEPS
-    self.progress_mark  = options[:progress_mark]  || DEFAULT_PROGRESS_MARK
-    self.remainder_mark = options[:remainder_mark] || DEFAULT_REMAINDER_MARK
-    self.progress       = options[:progress]
-    self.length         = options[:length]
-  end
-
-  def to_s(options = { :format => :standard })
-    if progress.unknown?
-      unknown_string
-    elsif options[:format] == :standard
-      "#{standard_complete_string}#{incomplete_string}"
-    elsif options[:format] == :integrated_percentage
-      "#{integrated_percentage_complete_string}#{incomplete_string}"
-    end
-  end
-
-  private
-
-  def integrated_percentage_complete_string
-    return standard_complete_string if completed_length < 5
-
-    " #{progress.percentage_completed} ".to_s.center(completed_length, progress_mark)
-  end
-
-  def standard_complete_string
-    progress_mark * completed_length
-  end
-
-  def incomplete_string
-    remainder_mark * (length - completed_length)
-  end
-
-  def bar(length)
-    self.length = length
-
-    standard_complete_string
-  end
-
-  def complete_bar(length)
-    self.length = length
-
-    to_s(:format => :standard)
-  end
-
-  def complete_bar_with_percentage(length)
-    self.length = length
-
-    to_s(:format => :integrated_percentage)
-  end
-
-  def unknown_string
-    unknown_frame_string = unknown_progress_frame * ((length / upa_steps.size) + 2)
-
-    unknown_frame_string[0, length]
-  end
-
-  def incomplete_space(length)
-    self.length = length
-
-    if progress.unknown?
-      unknown_string
-    else
-      incomplete_string
-    end
-  end
-
-  def bar_with_percentage(length)
-    self.length = length
-
-    integrated_percentage_complete_string
-  end
-
-  def completed_length
-    (length * progress.percentage_completed / 100).floor
-  end
-
-  def unknown_progress_frame
-    current_animation_step = progress.progress % upa_steps.size
-
-    upa_steps[current_animation_step]
-  end
-end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/percentage.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/percentage.rb
deleted file mode 100644
index aef34d9385871..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/percentage.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-class   ProgressBar
-module  Components
-class   Percentage
-  attr_accessor :progress
-
-  def initialize(options = {})
-    self.progress = options[:progress]
-  end
-
-  private
-
-  def percentage
-    progress.percentage_completed
-  end
-
-  def justified_percentage
-    progress.percentage_completed.to_s.rjust(3)
-  end
-
-  def percentage_with_precision
-    progress.percentage_completed_with_precision
-  end
-
-  def justified_percentage_with_precision
-    progress.percentage_completed_with_precision.to_s.rjust(6)
-  end
-end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb
deleted file mode 100644
index 28b4eda86ac96..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb
+++ /dev/null
@@ -1,43 +0,0 @@
-class   ProgressBar
-module  Components
-class   Rate
-  attr_accessor :rate_scale,
-                :started_at,
-                :stopped_at,
-                :timer,
-                :progress
-
-  def initialize(options = {})
-    self.rate_scale = options[:rate_scale] || lambda { |x| x }
-    self.started_at = nil
-    self.stopped_at = nil
-    self.timer      = options[:timer]
-    self.progress   = options[:progress]
-  end
-
-  private
-
-  def rate_of_change(format_string = '%i')
-    return 0 unless elapsed_seconds > 0
-
-    format_string % scaled_rate
-  end
-
-  def rate_of_change_with_precision
-    rate_of_change('%.2f')
-  end
-
-  def scaled_rate
-    rate_scale.call(base_rate)
-  end
-
-  def base_rate
-    progress.absolute / elapsed_seconds
-  end
-
-  def elapsed_seconds
-    timer.elapsed_whole_seconds.to_f
-  end
-end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb
deleted file mode 100644
index e29d20dc3f74c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb
+++ /dev/null
@@ -1,101 +0,0 @@
-###
-# OOB = 'Out of Bounds'
-#
-class   ProgressBar
-module  Components
-class   Time
-  TIME_FORMAT            = '%02d:%02d:%02d'.freeze
-  OOB_TIME_FORMATS       = [:unknown, :friendly, nil].freeze
-  OOB_LIMIT_IN_HOURS     = 99
-  OOB_UNKNOWN_TIME_TEXT  = '??:??:??'.freeze
-  OOB_FRIENDLY_TIME_TEXT = '> 4 Days'.freeze
-  NO_TIME_ELAPSED_TEXT   = '--:--:--'.freeze
-  ESTIMATED_LABEL        = ' ETA'.freeze
-  ELAPSED_LABEL          = 'Time'.freeze
-  OOB_TEXT_TO_FORMAT     = {
-    :unknown  => OOB_UNKNOWN_TIME_TEXT,
-    :friendly => OOB_FRIENDLY_TIME_TEXT
-  }.freeze
-
-  def initialize(options = {})
-    self.out_of_bounds_time_format = options[:out_of_bounds_time_format]
-    self.timer                     = options[:timer]
-    self.progress                  = options[:progress]
-  end
-
-  def estimated_with_label
-    "#{ESTIMATED_LABEL}: #{estimated}"
-  end
-
-  def elapsed_with_label
-    "#{ELAPSED_LABEL}: #{elapsed}"
-  end
-
-  protected
-
-  def estimated_with_no_oob
-    self.out_of_bounds_time_format = nil
-
-    estimated_with_elapsed_fallback
-  end
-
-  def estimated_with_unknown_oob
-    self.out_of_bounds_time_format = :unknown
-
-    estimated_with_elapsed_fallback
-  end
-
-  def estimated_with_friendly_oob
-    self.out_of_bounds_time_format = :friendly
-
-    estimated_with_elapsed_fallback
-  end
-
-  attr_reader   :out_of_bounds_time_format
-  attr_accessor :timer,
-                :progress
-
-  def out_of_bounds_time_format=(format)
-    unless OOB_TIME_FORMATS.include? format
-      fail StandardError, "Invalid Out Of Bounds time format.  Valid formats are #{OOB_TIME_FORMATS.inspect}"
-    end
-
-    @out_of_bounds_time_format = format
-  end
-
-  private
-
-  def estimated
-    memo_estimated_seconds_remaining = estimated_seconds_remaining
-
-    return OOB_UNKNOWN_TIME_TEXT unless memo_estimated_seconds_remaining
-
-    hours, minutes, seconds = timer.divide_seconds(memo_estimated_seconds_remaining)
-
-    if hours > OOB_LIMIT_IN_HOURS && out_of_bounds_time_format
-      OOB_TEXT_TO_FORMAT[out_of_bounds_time_format]
-    else
-      TIME_FORMAT % [hours, minutes, seconds]
-    end
-  end
-
-  def elapsed
-    return NO_TIME_ELAPSED_TEXT unless timer.started?
-
-    hours, minutes, seconds = timer.divide_seconds(timer.elapsed_whole_seconds)
-
-    TIME_FORMAT % [hours, minutes, seconds]
-  end
-
-  def estimated_with_elapsed_fallback
-    progress.finished? ? elapsed_with_label : estimated_with_label
-  end
-
-  def estimated_seconds_remaining
-    return if progress.unknown? || progress.none? || timer.stopped? || timer.reset?
-
-    (timer.elapsed_seconds * (progress.total / progress.running_average - 1)).round
-  end
-end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/title.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/title.rb
deleted file mode 100644
index 86ee65765a7fa..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/components/title.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-class   ProgressBar
-module  Components
-class   Title
-  DEFAULT_TITLE = 'Progress'.freeze
-
-  attr_accessor :title
-
-  def initialize(options = {})
-    self.title = options[:title] || DEFAULT_TITLE
-  end
-end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/errors/invalid_progress_error.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/errors/invalid_progress_error.rb
deleted file mode 100644
index fa6f480601432..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/errors/invalid_progress_error.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-class   ProgressBar
-class   InvalidProgressError < RuntimeError
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/format.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/format.rb
deleted file mode 100644
index 28fcb2cddff07..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/format.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-require 'ruby-progressbar/format/molecule'
-require 'ruby-progressbar/format/formatter'
-require 'ruby-progressbar/format/string'
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/format/formatter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/format/formatter.rb
deleted file mode 100644
index a7179ebf0fe9b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/format/formatter.rb
+++ /dev/null
@@ -1,27 +0,0 @@
-class   ProgressBar
-module  Format
-class   Formatter
-  def self.process(format_string, max_length, bar)
-    processed_string = format_string.dup
-
-    format_string.non_bar_molecules.each do |molecule|
-      processed_string.gsub!(molecule.full_key, molecule.lookup_value(bar, nil))
-    end
-
-    processed_string.gsub!(/%%/, '%')
-
-    bar_length         = max_length -
-                         processed_string.displayable_length +
-                         format_string.bar_molecule_placeholder_length
-    bar_length         = (bar_length < 0) ? 0 : bar_length
-
-    format_string.bar_molecules.each do |molecule|
-      processed_string.gsub!(molecule.full_key,
-                             molecule.lookup_value(bar, bar_length))
-    end
-
-    processed_string
-  end
-end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb
deleted file mode 100644
index 95d18e11d796c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb
+++ /dev/null
@@ -1,60 +0,0 @@
-class   ProgressBar
-module  Format
-class   Molecule
-  MOLECULES = {
-    :t => [:title_comp,   :title],
-    :T => [:title_comp,   :title],
-    :c => [:progressable, :progress],
-    :C => [:progressable, :total],
-    :u => [:progressable, :total_with_unknown_indicator],
-    :p => [:percentage,   :percentage],
-    :P => [:percentage,   :percentage_with_precision],
-    :j => [:percentage,   :justified_percentage],
-    :J => [:percentage,   :justified_percentage_with_precision],
-    :a => [:time,         :elapsed_with_label],
-    :e => [:time,         :estimated_with_unknown_oob],
-    :E => [:time,         :estimated_with_friendly_oob],
-    :f => [:time,         :estimated_with_no_oob],
-    :B => [:bar,          :complete_bar],
-    :b => [:bar,          :bar],
-    :W => [:bar,          :complete_bar_with_percentage],
-    :w => [:bar,          :bar_with_percentage],
-    :i => [:bar,          :incomplete_space],
-    :r => [:rate,         :rate_of_change],
-    :R => [:rate,         :rate_of_change_with_precision]
-  }.freeze
-
-  BAR_MOLECULES = %w{W w B b i}.freeze
-
-  attr_accessor :key,
-                :method_name
-
-  def initialize(letter)
-    self.key         = letter
-    self.method_name = MOLECULES.fetch(key.to_sym)
-  end
-
-  def bar_molecule?
-    BAR_MOLECULES.include? key
-  end
-
-  def non_bar_molecule?
-    !bar_molecule?
-  end
-
-  def full_key
-    "%#{key}"
-  end
-
-  def lookup_value(environment, length = 0)
-    component = environment.__send__(method_name[0])
-
-    if bar_molecule?
-      component.__send__(method_name[1], length).to_s
-    else
-      component.__send__(method_name[1]).to_s
-    end
-  end
-end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/format/string.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/format/string.rb
deleted file mode 100644
index e0f1ea413d770..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/format/string.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-class   ProgressBar
-module  Format
-class   String < ::String
-  MOLECULE_PATTERN = /%[a-zA-Z]/.freeze
-  ANSI_SGR_PATTERN = /\e\[[\d;]+m/.freeze
-
-  def displayable_length
-    gsub(ANSI_SGR_PATTERN, '').length
-  end
-
-  def bar_molecule_placeholder_length
-    @bar_molecule_placeholder_length ||= bar_molecules.size * 2
-  end
-
-  def non_bar_molecules
-    @non_bar_molecules ||= molecules.select(&:non_bar_molecule?)
-  end
-
-  def bar_molecules
-    @bar_molecules ||= molecules.select(&:bar_molecule?)
-  end
-
-  def molecules
-    @molecules ||= begin
-                      molecules = []
-
-                      scan(MOLECULE_PATTERN) do |match|
-                        molecules << Molecule.new(match[1, 1])
-                      end
-
-                      molecules
-                   end
-  end
-end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb
deleted file mode 100644
index 2096892fda006..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb
+++ /dev/null
@@ -1,68 +0,0 @@
-class   ProgressBar
-class   Output
-  DEFAULT_OUTPUT_STREAM = $stdout
-
-  attr_accessor :stream
-
-  def initialize(options = {})
-    self.bar               = options[:bar]
-    self.stream            = options[:output] || DEFAULT_OUTPUT_STREAM
-    self.throttle          = Throttle.new(options)
-    self.length_calculator = Calculators::Length.new(
-                               :length => options[:length],
-                               :output => stream
-                             )
-  end
-
-  def self.detect(options = {})
-    if options[:output].is_a?(Class) && options[:output] <= ProgressBar::Output
-      options[:output].new(options)
-    elsif (options[:output] || DEFAULT_OUTPUT_STREAM).tty?
-      Outputs::Tty.new(options)
-    else
-      Outputs::NonTty.new(options)
-    end
-  end
-
-  def log(string)
-    clear
-    stream.puts string
-
-    refresh(:force => true) unless bar.stopped?
-  end
-
-  def clear_string
-    ' ' * length_calculator.length
-  end
-
-  def length
-    length_calculator.length
-  end
-
-  def with_refresh
-    yield
-    refresh
-  end
-
-  def refresh(options = {})
-    throttle.choke(:force_update_if => (bar.stopped? || options[:force])) do
-      clear if length_calculator.length_changed?
-
-      print_and_flush
-    end
-  end
-
-  protected
-
-  attr_accessor :length_calculator,
-                :throttle,
-                :bar
-
-  private
-
-  def print_and_flush
-    stream.print bar_update_string + eol
-    stream.flush
-  end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/non_tty.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/non_tty.rb
deleted file mode 100644
index 181718684cd6b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/non_tty.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-require 'ruby-progressbar/output'
-
-class   ProgressBar
-module  Outputs
-class   NonTty < Output
-  DEFAULT_FORMAT_STRING = '%t: |%b|'.freeze
-
-  def clear
-    self.last_update_length = 0
-
-    stream.print "\n"
-  end
-
-  def last_update_length
-    @last_update_length ||= 0
-  end
-
-  def bar_update_string
-    formatted_string        = bar.to_s
-    formatted_string        = formatted_string[0...-1] unless bar.finished?
-
-    output_string           = formatted_string[last_update_length..-1]
-    self.last_update_length = formatted_string.length
-
-    output_string.to_s
-  end
-
-  def default_format
-    DEFAULT_FORMAT_STRING
-  end
-
-  def resolve_format(*)
-    default_format
-  end
-
-  def refresh_with_format_change(*); end
-
-  def eol
-    bar.stopped? ? "\n" : ''
-  end
-
-  protected
-
-  attr_writer :last_update_length
-end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/null.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/null.rb
deleted file mode 100644
index 96b85b5289a77..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/null.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-require 'ruby-progressbar/output'
-
-class   ProgressBar
-module  Outputs
-class   Null < Output
-  alias refresh_with_format_change with_refresh
-
-  def clear;        end
-  def log(_string); end
-  def refresh(*);   end
-
-  def clear_string
-    ''
-  end
-
-  def bar_update_string
-    ''
-  end
-
-  def default_format
-    ''
-  end
-
-  def resolve_format(_format)
-    ''
-  end
-
-  def eol
-    ''
-  end
-end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/tty.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/tty.rb
deleted file mode 100644
index 80266c68a5dfd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/tty.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-require 'ruby-progressbar/output'
-
-class   ProgressBar
-module  Outputs
-class   Tty < Output
-  DEFAULT_FORMAT_STRING = '%t: |%B|'.freeze
-
-  alias refresh_with_format_change with_refresh
-
-  def clear
-    stream.print clear_string
-    stream.print "\r"
-  end
-
-  def bar_update_string
-    bar.to_s
-  end
-
-  def default_format
-    ENV['RUBY_PROGRESS_BAR_FORMAT'] || DEFAULT_FORMAT_STRING
-  end
-
-  def resolve_format(other_format)
-    other_format || default_format
-  end
-
-  def eol
-    bar.stopped? ? "\n" : "\r"
-  end
-end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb
deleted file mode 100644
index 44941c9137ecf..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb
+++ /dev/null
@@ -1,118 +0,0 @@
-require 'ruby-progressbar/errors/invalid_progress_error'
-
-class   ProgressBar
-class   Progress
-  DEFAULT_TOTAL              = 100
-  DEFAULT_BEGINNING_POSITION = 0
-  DEFAULT_SMOOTHING          = 0.1
-
-  attr_reader               :total,
-                            :progress
-
-  attr_accessor             :starting_position,
-                            :running_average,
-                            :smoothing
-
-  def initialize(options = {})
-    self.total     = options.fetch(:total, DEFAULT_TOTAL)
-    self.smoothing = options[:smoothing] || DEFAULT_SMOOTHING
-
-    start :at => DEFAULT_BEGINNING_POSITION
-  end
-
-  def start(options = {})
-    self.running_average   = 0
-    self.progress          = \
-      self.starting_position = options[:at] || progress
-  end
-
-  def finish
-    self.progress = total unless unknown?
-  end
-
-  def finished?
-    @progress == @total
-  end
-
-  def increment
-    if progress == total
-      warn "WARNING: Your progress bar is currently at #{progress} out of #{total} " \
-           "and cannot be incremented. In v2.0.0 this will become a " \
-           "ProgressBar::InvalidProgressError."
-    end
-
-    self.progress += 1 unless progress == total
-  end
-
-  def decrement
-    if progress == 0
-      warn "WARNING: Your progress bar is currently at #{progress} out of #{total} " \
-           "and cannot be decremented. In v2.0.0 this will become a " \
-           "ProgressBar::InvalidProgressError."
-    end
-
-    self.progress -= 1 unless progress == 0
-  end
-
-  def reset
-    start :at => starting_position
-  end
-
-  def progress=(new_progress)
-    if total && new_progress > total
-      fail ProgressBar::InvalidProgressError,
-           "You can't set the item's current value to be greater than the total."
-    end
-
-    @progress = new_progress
-
-    self.running_average = Calculators::RunningAverage.calculate(running_average,
-                                                                 absolute,
-                                                                 smoothing)
-  end
-
-  def total=(new_total)
-    unless progress.nil? || new_total.nil? || new_total >= progress
-      fail ProgressBar::InvalidProgressError,
-           "You can't set the item's total value to less than the current progress."
-    end
-
-    @total = new_total
-  end
-
-  def percentage_completed
-    return 0   if total.nil?
-    return 100 if total == 0
-
-    # progress / total * 100
-    #
-    # Doing this way so we can avoid converting each
-    # number to a float and then back to an integer.
-    #
-    (progress * 100 / total).to_i
-  end
-
-  def none?
-    running_average.zero? || progress.zero?
-  end
-
-  def unknown?
-    progress.nil? || total.nil?
-  end
-
-  def total_with_unknown_indicator
-    total || '??'
-  end
-
-  def percentage_completed_with_precision
-    return 100.0  if total == 0
-    return 0.0    if total.nil?
-
-    '%5.2f' % [(progress * 100 / total.to_f * 100).floor / 100.0]
-  end
-
-  def absolute
-    progress - starting_position
-  end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/refinements.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/refinements.rb
deleted file mode 100644
index 4fc0d04300ac6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/refinements.rb
+++ /dev/null
@@ -1 +0,0 @@
-require 'ruby-progressbar/refinements/enumerator'
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/refinements/enumerator.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/refinements/enumerator.rb
deleted file mode 100644
index 70dae62800035..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/refinements/enumerator.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-class  ProgressBar
-module Refinements
-module Enumerator
-refine ::Enumerator do
-  def with_progressbar(options = {}, &block)
-    chain = ::Enumerator.new do |yielder|
-      progress_bar = ProgressBar.create(options.merge(:starting_at => 0, :total => size))
-
-      each do |*args|
-        yielder.yield(*args).tap do
-          progress_bar.increment
-        end
-      end
-    end
-
-    return chain unless block
-
-    chain.each(&block)
-  end
-end
-end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/throttle.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/throttle.rb
deleted file mode 100644
index 743e8cee3d3a1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/throttle.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-class   ProgressBar
-class   Throttle
-  attr_accessor :rate,
-                :started_at,
-                :stopped_at,
-                :timer
-
-  def initialize(options = {})
-    self.rate       = options[:throttle_rate] || 0.01
-    self.started_at = nil
-    self.stopped_at = nil
-    self.timer      = options.fetch(:throttle_timer, Timer.new)
-  end
-
-  def choke(options = {})
-    return unless !timer.started?                        ||
-                  options.fetch(:force_update_if, false) ||
-                  timer.elapsed_seconds >= rate
-
-    timer.restart
-
-    yield
-  end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/time.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/time.rb
deleted file mode 100644
index 63c8c0e16b22b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/time.rb
+++ /dev/null
@@ -1,32 +0,0 @@
-# rubocop:disable Style/InlineComment
-class   ProgressBar
-class   Time
-  TIME_MOCKING_LIBRARY_METHODS = [
-                                   :__simple_stub__now,     # ActiveSupport
-                                   :now_without_mock_time,  # Timecop
-                                   :now_without_delorean,   # Delorean
-                                   :now                     # Unmocked
-                                 ].freeze
-
-  def initialize(time = ::Time)
-    self.time = time
-  end
-
-  def now
-    time.__send__(unmocked_time_method)
-  end
-
-  def unmocked_time_method
-    @unmocked_time_method ||= begin
-                                TIME_MOCKING_LIBRARY_METHODS.find do |method|
-                                  time.respond_to? method
-                                end
-                              end
-  end
-
-  protected
-
-  attr_accessor :time
-end
-end
-# rubocop:enable Style/InlineComment
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb
deleted file mode 100644
index d21a0d23184d0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb
+++ /dev/null
@@ -1,72 +0,0 @@
-require 'ruby-progressbar/time'
-
-class   ProgressBar
-class   Timer
-  attr_accessor :started_at,
-                :stopped_at
-
-  def initialize(options = {})
-    self.time = options[:time] || ::ProgressBar::Time.new
-  end
-
-  def start
-    self.started_at = stopped? ? time.now - (stopped_at - started_at) : time.now
-    self.stopped_at = nil
-  end
-
-  def stop
-    return unless started?
-
-    self.stopped_at = time.now
-  end
-
-  def pause
-    stop
-  end
-
-  def resume
-    start
-  end
-
-  def started?
-    started_at
-  end
-
-  def stopped?
-    stopped_at
-  end
-
-  def reset
-    self.started_at = nil
-    self.stopped_at = nil
-  end
-
-  def reset?
-    !started_at
-  end
-
-  def restart
-    reset
-    start
-  end
-
-  def elapsed_seconds
-    ((stopped_at || time.now) - started_at)
-  end
-
-  def elapsed_whole_seconds
-    elapsed_seconds.floor
-  end
-
-  def divide_seconds(seconds)
-    hours, seconds   = seconds.divmod(3600)
-    minutes, seconds = seconds.divmod(60)
-
-    [hours, minutes, seconds]
-  end
-
-  protected
-
-  attr_accessor :time
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/version.rb
deleted file mode 100644
index 6a0ebac2766fb..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-progressbar-1.11.0/lib/ruby-progressbar/version.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-class ProgressBar
-  VERSION = '1.11.0'.freeze
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm.rb
deleted file mode 100644
index e085a0d26aca5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm.rb
+++ /dev/null
@@ -1,266 +0,0 @@
-# encoding: UTF-8
-#
-# = net/ntlm.rb
-#
-# An NTLM Authentication Library for Ruby
-#
-# This code is a derivative of "dbf2.rb" written by yrock
-# and Minero Aoki. You can find original code here:
-# http://jp.rubyist.net/magazine/?0013-CodeReview
-# -------------------------------------------------------------
-# Copyright (c) 2005,2006 yrock
-#
-#
-# 2006-02-11 refactored by Minero Aoki
-# -------------------------------------------------------------
-#
-# All protocol information used to write this code stems from
-# "The NTLM Authentication Protocol" by Eric Glass. The author
-# would thank to him for this tremendous work and making it
-# available on the net.
-# http://davenport.sourceforge.net/ntlm.html
-# -------------------------------------------------------------
-# Copyright (c) 2003 Eric Glass
-#
-# -------------------------------------------------------------
-#
-# The author also looked Mozilla-Firefox-1.0.7 source code,
-# namely, security/manager/ssl/src/nsNTLMAuthModule.cpp and
-# Jonathan Bastien-Filiatrault's libntlm-ruby.
-# "http://x2a.org/websvn/filedetails.php?
-# repname=libntlm-ruby&path=%2Ftrunk%2Fntlm.rb&sc=1"
-# The latter has a minor bug in its separate_keys function.
-# The third key has to begin from the 14th character of the
-# input string instead of 13th:)
-#--
-# $Id: ntlm.rb,v 1.1 2006/10/05 01:36:52 koheik Exp $
-#++
-
-require 'base64'
-require 'openssl'
-require 'openssl/digest'
-require 'socket'
-
-# Load Order is important here
-require 'net/ntlm/exceptions'
-require 'net/ntlm/field'
-require 'net/ntlm/int16_le'
-require 'net/ntlm/int32_le'
-require 'net/ntlm/int64_le'
-require 'net/ntlm/string'
-
-require 'net/ntlm/field_set'
-require 'net/ntlm/blob'
-require 'net/ntlm/security_buffer'
-require 'net/ntlm/message'
-require 'net/ntlm/message/type0'
-require 'net/ntlm/message/type1'
-require 'net/ntlm/message/type2'
-require 'net/ntlm/message/type3'
-
-require 'net/ntlm/encode_util'
-
-require 'net/ntlm/client'
-require 'net/ntlm/channel_binding'
-require 'net/ntlm/target_info'
-
-module Net
-  module NTLM
-
-    LM_MAGIC = "KGS!@\#$%"
-    TIME_OFFSET = 11644473600
-    MAX64 = 0xffffffffffffffff
-
-
-    class << self
-
-      # Valid format for LAN Manager hex digest portion: 32 hexadecimal characters.
-      LAN_MANAGER_HEX_DIGEST_REGEXP = /[0-9a-f]{32}/i
-      # Valid format for NT LAN Manager hex digest portion: 32 hexadecimal characters.
-      NT_LAN_MANAGER_HEX_DIGEST_REGEXP = /[0-9a-f]{32}/i
-      # Valid format for an NTLM hash composed of `'<LAN Manager hex digest>:<NT LAN Manager hex digest>'`.
-      DATA_REGEXP = /\A#{LAN_MANAGER_HEX_DIGEST_REGEXP}:#{NT_LAN_MANAGER_HEX_DIGEST_REGEXP}\z/
-
-      # Takes a string and determines whether it is a valid NTLM Hash
-      # @param [String] the string to validate
-      # @return [Boolean] whether or not the string is a valid NTLM hash
-      def is_ntlm_hash?(data)
-        decoded_data = data.dup
-        decoded_data = EncodeUtil.decode_utf16le(decoded_data)
-        if DATA_REGEXP.match(decoded_data)
-          true
-        else
-          false
-        end
-      end
-
-      # Conver the value to a 64-Bit Little Endian Int
-      # @param [String] val The string to convert
-      def pack_int64le(val)
-          [val & 0x00000000ffffffff, val >> 32].pack("V2")
-      end
-
-      # Builds an array of strings that are 7 characters long
-      # @param [String] str The string to split
-      # @api private
-      def split7(str)
-        s = str.dup
-        until s.empty?
-          (ret ||= []).push s.slice!(0, 7)
-        end
-        ret
-      end
-
-      # Not sure what this is doing
-      # @param [String] str String to generate keys for
-      # @api private
-      def gen_keys(str)
-        split7(str).map{ |str7|
-          bits = split7(str7.unpack("B*")[0]).inject('')\
-            {|ret, tkn| ret += tkn + (tkn.gsub('1', '').size % 2).to_s }
-          [bits].pack("B*")
-        }
-      end
-
-      def apply_des(plain, keys)
-        dec = OpenSSL::Cipher.new("des-cbc").encrypt
-        dec.padding = 0
-        keys.map {|k|
-          dec.key = k
-          dec.update(plain) + dec.final
-        }
-      end
-
-      # Generates a Lan Manager Hash
-      # @param [String] password The password to base the hash on
-      def lm_hash(password)
-        keys = gen_keys password.upcase.ljust(14, "\0")
-        apply_des(LM_MAGIC, keys).join
-      end
-
-      # Generate a NTLM Hash
-      # @param [String] password The password to base the hash on
-      # @option opt :unicode (false) Unicode encode the password
-      def ntlm_hash(password, opt = {})
-        pwd = password.dup
-        unless opt[:unicode]
-          pwd = EncodeUtil.encode_utf16le(pwd)
-        end
-        OpenSSL::Digest::MD4.digest pwd
-      end
-
-      # Generate a NTLMv2 Hash
-      # @param [String] user The username
-      # @param [String] password The password
-      # @param [String] target The domain or workstation to authenticate to
-      # @option opt :unicode (false) Unicode encode the domain
-      def ntlmv2_hash(user, password, target, opt={})
-        if is_ntlm_hash? password
-          decoded_password = EncodeUtil.decode_utf16le(password)
-          ntlmhash = [decoded_password.upcase[33,65]].pack('H32')
-        else
-          ntlmhash = ntlm_hash(password, opt)
-        end
-        userdomain = user.upcase + target
-        unless opt[:unicode]
-          userdomain = EncodeUtil.encode_utf16le(userdomain)
-        end
-        OpenSSL::HMAC.digest(OpenSSL::Digest::MD5.new, ntlmhash, userdomain)
-      end
-
-      def lm_response(arg)
-        begin
-          hash = arg[:lm_hash]
-          chal = arg[:challenge]
-        rescue
-          raise ArgumentError
-        end
-        chal = NTLM::pack_int64le(chal) if chal.is_a?(Integer)
-        keys = gen_keys hash.ljust(21, "\0")
-        apply_des(chal, keys).join
-      end
-
-      def ntlm_response(arg)
-        hash = arg[:ntlm_hash]
-        chal = arg[:challenge]
-        chal = NTLM::pack_int64le(chal) if chal.is_a?(Integer)
-        keys = gen_keys hash.ljust(21, "\0")
-        apply_des(chal, keys).join
-      end
-
-      def ntlmv2_response(arg, opt = {})
-        begin
-          key = arg[:ntlmv2_hash]
-          chal = arg[:challenge]
-          ti = arg[:target_info]
-        rescue
-          raise ArgumentError
-        end
-        chal = NTLM::pack_int64le(chal) if chal.is_a?(Integer)
-
-        if opt[:client_challenge]
-          cc  = opt[:client_challenge]
-        else
-          cc = rand(MAX64)
-        end
-        cc = NTLM::pack_int64le(cc) if cc.is_a?(Integer)
-
-        if opt[:timestamp]
-          ts = opt[:timestamp]
-        else
-          ts = Time.now.to_i
-        end
-        # epoch -> milsec from Jan 1, 1601
-        ts = 10_000_000 * (ts + TIME_OFFSET)
-
-        blob = Blob.new
-        blob.timestamp = ts
-        blob.challenge = cc
-        blob.target_info = ti
-
-        bb = blob.serialize
-
-        OpenSSL::HMAC.digest(OpenSSL::Digest::MD5.new, key, chal + bb) + bb
-      end
-
-      def lmv2_response(arg, opt = {})
-        key = arg[:ntlmv2_hash]
-        chal = arg[:challenge]
-
-        chal = NTLM::pack_int64le(chal) if chal.is_a?(Integer)
-
-        if opt[:client_challenge]
-          cc  = opt[:client_challenge]
-        else
-          cc = rand(MAX64)
-        end
-        cc = NTLM::pack_int64le(cc) if cc.is_a?(Integer)
-
-        OpenSSL::HMAC.digest(OpenSSL::Digest::MD5.new, key, chal + cc) + cc
-      end
-
-      def ntlm2_session(arg, opt = {})
-        begin
-          passwd_hash = arg[:ntlm_hash]
-          chal = arg[:challenge]
-        rescue
-          raise ArgumentError
-        end
-        chal = NTLM::pack_int64le(chal) if chal.is_a?(Integer)
-
-        if opt[:client_challenge]
-          cc = opt[:client_challenge]
-        else
-          cc = rand(MAX64)
-        end
-        cc = NTLM::pack_int64le(cc) if cc.is_a?(Integer)
-
-        keys = gen_keys(passwd_hash.ljust(21, "\0"))
-        session_hash = OpenSSL::Digest::MD5.digest(chal + cc).slice(0, 8)
-        response = apply_des(session_hash, keys).join
-        [cc.ljust(24, "\0"), response]
-      end
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/blob.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/blob.rb
deleted file mode 100644
index f670eb3d39461..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/blob.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-module Net
-  module NTLM
-
-    BLOB_SIGN = 0x00000101
-
-    class Blob < FieldSet
-      int32LE    :blob_signature, {:value => BLOB_SIGN}
-      int32LE    :reserved,       {:value => 0}
-      int64LE    :timestamp,      {:value => 0}
-      string     :challenge,      {:value => "", :size => 8}
-      int32LE    :unknown1,       {:value => 0}
-      string     :target_info,    {:value => "", :size => 0}
-      int32LE    :unknown2,       {:value => 0}
-
-      def parse(str, offset=0)
-        # 28 is the length of all fields before the variable-length
-        # target_info field.
-        if str.size > 28
-          enable(:target_info)
-          # Grab everything except the last 4 bytes (which will be :unknown2)
-          self[:target_info].value = str[28..-5]
-        end
-        super
-      end
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/channel_binding.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/channel_binding.rb
deleted file mode 100644
index fda9c6355b789..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/channel_binding.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-module Net
-  module NTLM
-    class ChannelBinding
-
-      # Creates a ChannelBinding used for Extended Protection Authentication
-      # @see http://blogs.msdn.com/b/openspecification/archive/2013/03/26/ntlm-and-channel-binding-hash-aka-exteneded-protection-for-authentication.aspx
-      #
-      # @param outer_channel [OpenSSL::X509::Certificate] Server certificate securing
-      #   the outer TLS channel
-      # @return [NTLM::ChannelBinding] A ChannelBinding holding a token that can be
-      #   embedded in a {Type3} message
-      def self.create(outer_channel)
-        new(outer_channel)
-      end
-
-      # @param outer_channel [OpenSSL::X509::Certificate] Server certificate securing
-      #   the outer TLS channel
-      def initialize(outer_channel)
-        @channel = outer_channel
-        @unique_prefix = 'tls-server-end-point'
-        @initiator_addtype = 0
-        @initiator_address_length = 0
-        @acceptor_addrtype = 0
-        @acceptor_address_length = 0
-      end
-
-      attr_reader :channel, :unique_prefix, :initiator_addtype
-      attr_reader :initiator_address_length, :acceptor_addrtype
-      attr_reader :acceptor_address_length
-
-      # Returns a channel binding hash acceptable for use as a AV_PAIR MsvAvChannelBindings
-      #   field value as specified in the NTLM protocol
-      #
-      # @return [String] MD5 hash of gss_channel_bindings_struct
-      def channel_binding_token
-        @channel_binding_token ||= OpenSSL::Digest::MD5.new(gss_channel_bindings_struct).digest
-      end
-
-      def gss_channel_bindings_struct
-        @gss_channel_bindings_struct ||= begin
-          token = [initiator_addtype].pack('I')
-          token << [initiator_address_length].pack('I')
-          token << [acceptor_addrtype].pack('I')
-          token << [acceptor_address_length].pack('I')
-          token << [application_data.length].pack('I')
-          token << application_data
-          token
-        end
-      end
-
-      def channel_hash
-        @channel_hash ||= OpenSSL::Digest::SHA256.new(channel.to_der)
-      end
-
-      def application_data
-        @application_data ||= begin
-          data = unique_prefix
-          data << ':'
-          data << channel_hash.digest
-          data
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/client.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/client.rb
deleted file mode 100644
index 91d0895c683a9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/client.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-module Net
-  module NTLM
-    class Client
-
-      DEFAULT_FLAGS = NTLM::FLAGS[:UNICODE] | NTLM::FLAGS[:OEM] |
-        NTLM::FLAGS[:SIGN]   | NTLM::FLAGS[:SEAL]         | NTLM::FLAGS[:REQUEST_TARGET] |
-        NTLM::FLAGS[:NTLM]   | NTLM::FLAGS[:ALWAYS_SIGN]  | NTLM::FLAGS[:NTLM2_KEY] |
-        NTLM::FLAGS[:KEY128] | NTLM::FLAGS[:KEY_EXCHANGE] | NTLM::FLAGS[:KEY56]
-
-      attr_reader :username, :password, :domain, :workstation, :flags
-
-      # @note All string parameters should be encoded in UTF-8. The proper
-      #   final encoding for placing in the various {Message messages} will be
-      #   chosen based on negotiation with the server.
-      #
-      # @param username [String]
-      # @param password [String]
-      # @option opts [String] :domain where we're authenticating to
-      # @option opts [String] :workstation local workstation name
-      # @option opts [Fixnum] :flags (DEFAULT_FLAGS) see Net::NTLM::Message::Type1.flag
-      def initialize(username, password, opts = {})
-        @username     = username
-        @password     = password
-        @domain       = opts[:domain] || nil
-        @workstation  = opts[:workstation] || nil
-        @flags        = opts[:flags] || DEFAULT_FLAGS
-      end
-
-      # @return [NTLM::Message]
-      def init_context(resp = nil, channel_binding = nil)
-        if resp.nil?
-          @session = nil
-          type1_message
-        else
-          @session = Client::Session.new(self, Net::NTLM::Message.decode64(resp), channel_binding)
-          @session.authenticate!
-        end
-      end
-
-      # @return [Client::Session]
-      def session
-        @session
-      end
-
-      def session_key
-        @session.exported_session_key
-      end
-
-      private
-
-      # @return [Message::Type1]
-      def type1_message
-        type1 = Message::Type1.new
-        type1[:flag].value = flags
-        type1.domain = domain if domain
-        type1.workstation = workstation if workstation
-
-        type1
-      end
-
-    end
-  end
-end
-
-require "net/ntlm/client/session"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/client/session.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/client/session.rb
deleted file mode 100644
index b1b496a0b77f3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/client/session.rb
+++ /dev/null
@@ -1,237 +0,0 @@
-module Net
-  module NTLM
-    class Client::Session
-
-      VERSION_MAGIC = "\x01\x00\x00\x00"
-      TIME_OFFSET   = 11644473600
-      MAX64         = 0xffffffffffffffff
-      CLIENT_TO_SERVER_SIGNING = "session key to client-to-server signing key magic constant\0"
-      SERVER_TO_CLIENT_SIGNING = "session key to server-to-client signing key magic constant\0"
-      CLIENT_TO_SERVER_SEALING = "session key to client-to-server sealing key magic constant\0"
-      SERVER_TO_CLIENT_SEALING = "session key to server-to-client sealing key magic constant\0"
-
-      attr_reader :client, :challenge_message, :channel_binding
-
-      # @param client [Net::NTLM::Client] the client instance
-      # @param challenge_message [Net::NTLM::Message::Type2] server message
-      def initialize(client, challenge_message, channel_binding = nil)
-        @client = client
-        @challenge_message = challenge_message
-        @channel_binding = channel_binding
-      end
-
-      # Generate an NTLMv2 AUTHENTICATE_MESSAGE
-      # @see http://msdn.microsoft.com/en-us/library/cc236643.aspx
-      # @return [Net::NTLM::Message::Type3]
-      def authenticate!
-        calculate_user_session_key!
-        type3_opts = {
-          :lm_response   => lmv2_resp,
-          :ntlm_response => ntlmv2_resp,
-          :domain        => domain,
-          :user          => username,
-          :workstation   => workstation,
-          :flag          => (challenge_message.flag & client.flags)
-        }
-        t3 = Message::Type3.create type3_opts
-        if negotiate_key_exchange?
-          t3.enable(:session_key)
-          rc4 = OpenSSL::Cipher.new("rc4")
-          rc4.encrypt
-          rc4.key = user_session_key
-          sk = rc4.update exported_session_key
-          sk << rc4.final
-          t3.session_key = sk
-        end
-        t3
-      end
-
-      def exported_session_key
-        @exported_session_key ||=
-          begin
-            if negotiate_key_exchange?
-              OpenSSL::Cipher.new("rc4").random_key
-            else
-              user_session_key
-            end
-          end
-      end
-
-      def sign_message(message)
-        seq = sequence
-        sig = OpenSSL::HMAC.digest(OpenSSL::Digest::MD5.new, client_sign_key, "#{seq}#{message}")[0..7]
-        if negotiate_key_exchange?
-          sig = client_cipher.update sig
-          sig << client_cipher.final
-        end
-        "#{VERSION_MAGIC}#{sig}#{seq}"
-      end
-
-      def verify_signature(signature, message)
-        seq = signature[-4..-1]
-        sig = OpenSSL::HMAC.digest(OpenSSL::Digest::MD5.new, server_sign_key, "#{seq}#{message}")[0..7]
-        if negotiate_key_exchange?
-          sig = server_cipher.update sig
-          sig << server_cipher.final
-        end
-        "#{VERSION_MAGIC}#{sig}#{seq}" == signature
-      end
-
-      def seal_message(message)
-        emessage = client_cipher.update(message)
-        emessage + client_cipher.final
-      end
-
-      def unseal_message(emessage)
-        message = server_cipher.update(emessage)
-        message + server_cipher.final
-      end
-
-      private
-
-
-      def user_session_key
-        @user_session_key ||=  nil
-      end
-
-      def sequence
-        [raw_sequence].pack("V*")
-      end
-
-      def raw_sequence
-        if defined? @raw_sequence
-          @raw_sequence += 1
-        else
-          @raw_sequence = 0
-        end
-      end
-
-      def client_sign_key
-        @client_sign_key ||= OpenSSL::Digest::MD5.digest "#{exported_session_key}#{CLIENT_TO_SERVER_SIGNING}"
-      end
-
-      def server_sign_key
-        @server_sign_key ||= OpenSSL::Digest::MD5.digest "#{exported_session_key}#{SERVER_TO_CLIENT_SIGNING}"
-      end
-
-      def client_seal_key
-        @client_seal_key ||= OpenSSL::Digest::MD5.digest "#{exported_session_key}#{CLIENT_TO_SERVER_SEALING}"
-      end
-
-      def server_seal_key
-        @server_seal_key ||= OpenSSL::Digest::MD5.digest "#{exported_session_key}#{SERVER_TO_CLIENT_SEALING}"
-      end
-
-      def client_cipher
-        @client_cipher ||=
-          begin
-            rc4 = OpenSSL::Cipher.new("rc4")
-            rc4.encrypt
-            rc4.key = client_seal_key
-            rc4
-          end
-      end
-
-      def server_cipher
-        @server_cipher ||=
-          begin
-            rc4 = OpenSSL::Cipher.new("rc4")
-            rc4.decrypt
-            rc4.key = server_seal_key
-            rc4
-          end
-      end
-
-      def client_challenge
-        @client_challenge ||= NTLM.pack_int64le(rand(MAX64))
-      end
-
-      def server_challenge
-        @server_challenge ||= challenge_message[:challenge].serialize
-      end
-
-      # epoch -> milsec from Jan 1, 1601
-      # @see http://support.microsoft.com/kb/188768
-      def timestamp
-        @timestamp ||= 10_000_000 * (Time.now.to_i + TIME_OFFSET)
-      end
-
-      def use_oem_strings?
-        challenge_message.has_flag? :OEM
-      end
-
-      def negotiate_key_exchange?
-        challenge_message.has_flag? :KEY_EXCHANGE
-      end
-
-      def username
-        oem_or_unicode_str client.username
-      end
-
-      def password
-        oem_or_unicode_str client.password
-      end
-
-      def workstation
-        (client.workstation ? oem_or_unicode_str(client.workstation) : "")
-      end
-
-      def domain
-        (client.domain ? oem_or_unicode_str(client.domain) : "")
-      end
-
-      def oem_or_unicode_str(str)
-        if use_oem_strings?
-          NTLM::EncodeUtil.decode_utf16le str
-        else
-          NTLM::EncodeUtil.encode_utf16le str
-        end
-      end
-
-      def ntlmv2_hash
-        @ntlmv2_hash ||= NTLM.ntlmv2_hash(username, password, domain, {:client_challenge => client_challenge, :unicode => !use_oem_strings?})
-      end
-
-      def calculate_user_session_key!
-        @user_session_key = OpenSSL::HMAC.digest(OpenSSL::Digest::MD5.new, ntlmv2_hash, nt_proof_str)
-      end
-
-      def lmv2_resp
-        OpenSSL::HMAC.digest(OpenSSL::Digest::MD5.new, ntlmv2_hash, server_challenge + client_challenge) + client_challenge
-      end
-
-      def ntlmv2_resp
-        nt_proof_str + blob
-      end
-
-      def nt_proof_str
-        @nt_proof_str ||= OpenSSL::HMAC.digest(OpenSSL::Digest::MD5.new, ntlmv2_hash, server_challenge + blob)
-      end
-
-      def blob
-        @blob ||=
-          begin
-            b = Blob.new
-            b.timestamp = timestamp
-            b.challenge = client_challenge
-            b.target_info = target_info
-            b.serialize
-          end
-      end
-
-      def target_info
-        @target_info ||= begin
-          if channel_binding
-            t = Net::NTLM::TargetInfo.new(challenge_message.target_info)
-            av_id = Net::NTLM::TargetInfo::MSV_AV_CHANNEL_BINDINGS
-            t.av_pairs[av_id] = channel_binding.channel_binding_token
-            t.to_s
-          else
-            challenge_message.target_info
-          end
-        end
-      end
-
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/encode_util.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/encode_util.rb
deleted file mode 100644
index 5a13e7866f56e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/encode_util.rb
+++ /dev/null
@@ -1,48 +0,0 @@
-module Net
-module NTLM
-
-  class EncodeUtil
-    if RUBY_VERSION == "1.8.7"
-      require "kconv"
-
-      # Decode a UTF16 string to a ASCII string
-      # @param [String] str The string to convert
-      def self.decode_utf16le(str)
-        Kconv.kconv(swap16(str), Kconv::ASCII, Kconv::UTF16)
-      end
-
-      # Encodes a ASCII string to a UTF16 string
-      # @param [String] str The string to convert
-      def self.encode_utf16le(str)
-        swap16(Kconv.kconv(str, Kconv::UTF16, Kconv::ASCII))
-      end
-
-      # Taggle the strings endianness between big/little and little/big
-      # @param [String] str The string to swap the endianness on
-      def self.swap16(str)
-        str.unpack("v*").pack("n*")
-      end
-    else # Use native 1.9 string encoding functions
-
-      # Decode a UTF16 string to a ASCII string
-      # @param [String] str The string to convert
-      def self.decode_utf16le(str)
-        str = str.dup.force_encoding(Encoding::UTF_16LE)
-        str.encode(Encoding::UTF_8, Encoding::UTF_16LE).force_encoding('UTF-8')
-      end
-
-      # Encodes a ASCII string to a UTF16 string
-      # @param [String] str The string to convert
-      # @note This implementation may seem stupid but the problem is that UTF16-LE and UTF-8 are incompatiable
-      #   encodings. This library uses string contatination to build the packet bytes. The end result is that
-      #   you can either marshal the encodings elsewhere of simply know that each time you call encode_utf16le
-      #   the function will convert the string bytes to UTF-16LE and note the encoding as UTF-8 so that byte
-      #   concatination works seamlessly.
-      def self.encode_utf16le(str)
-        str.dup.force_encoding('UTF-8').encode(Encoding::UTF_16LE, Encoding::UTF_8).force_encoding('UTF-8')
-      end
-    end
-  end
-
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/exceptions.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/exceptions.rb
deleted file mode 100644
index 12f52015b213c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/exceptions.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-module Net
-  module NTLM
-    class NtlmError < StandardError; end
-
-    class InvalidTargetDataError < NtlmError
-      attr_reader :data
-
-      def initialize(msg, data)
-        @data = data
-        super(msg)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/field.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/field.rb
deleted file mode 100644
index 3109bd7dba975..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/field.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-module Net
-module NTLM
-
-  # base classes for primitives
-  # @private
-  class Field
-    attr_accessor :active, :value
-
-    def initialize(opts)
-      @value  = opts[:value]
-      @active = opts[:active].nil? ? true : opts[:active]
-      @size   = opts[:size].nil? ? 0 : opts[:size]
-    end
-
-    def size
-      @active ? @size : 0
-    end
-
-    # Serializer function for field data
-    # Exists in this class to be overridden by child classes
-    def serialize
-      raise NotImplementedError
-    end
-
-    # Parser function for field data
-    # Exists in this class to be overridden by child classes
-    def parse(str, offset=0)
-      raise NotImplementedError
-    end
-
-  end
-
-
-end
-end
\ No newline at end of file
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/field_set.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/field_set.rb
deleted file mode 100644
index e79cc66f1221c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/field_set.rb
+++ /dev/null
@@ -1,129 +0,0 @@
-module Net
-  module NTLM
-
-    # base class of data structure
-    class FieldSet
-      class << FieldSet
-
-        # @macro string_security_buffer
-        #   @method $1
-        #   @method $1=
-        #   @return [String]
-        def string(name, opts)
-          add_field(name, Net::NTLM::String, opts)
-        end
-
-        # @macro int16le_security_buffer
-        #   @method $1
-        #   @method $1=
-        #   @return [Int16LE]
-        def int16LE(name, opts)
-          add_field(name, Net::NTLM::Int16LE, opts)
-        end
-
-        # @macro int32le_security_buffer
-        #   @method $1
-        #   @method $1=
-        #   @return [Int32LE]
-        def int32LE(name, opts)
-          add_field(name, Net::NTLM::Int32LE, opts)
-        end
-
-        # @macro int64le_security_buffer
-        #   @method $1
-        #   @method $1=
-        #   @return [Int64]
-        def int64LE(name, opts)
-          add_field(name, Net::NTLM::Int64LE, opts)
-        end
-
-        # @macro security_buffer
-        #   @method $1
-        #   @method $1=
-        #   @return [SecurityBuffer]
-        def security_buffer(name, opts)
-          add_field(name, Net::NTLM::SecurityBuffer, opts)
-        end
-
-        def prototypes
-          @proto
-        end
-
-        def names
-          return [] if @proto.nil?
-          @proto.map{|n, t, o| n}
-        end
-
-        def types
-          return [] if @proto.nil?
-          @proto.map{|n, t, o| t}
-        end
-
-        def opts
-          return [] if @proto.nil?
-          @proto.map{|n, t, o| o}
-        end
-
-        private
-
-        def add_field(name, type, opts)
-          (@proto ||= []).push [name, type, opts]
-          define_accessor name
-        end
-
-        def define_accessor(name)
-          module_eval(<<-End, __FILE__, __LINE__ + 1)
-          def #{name}
-            self['#{name}'].value
-          end
-
-          def #{name}=(val)
-            self['#{name}'].value = val
-          end
-          End
-        end
-      end
-
-      def initialize
-        @alist = self.class.prototypes.map{ |n, t, o| [n, t.new(o)] }
-      end
-
-      def parse(str, offset=0)
-        @alist.inject(offset){|cur, a| cur += a[1].parse(str, cur)}
-      end
-
-      def serialize
-        @alist.map{|n, f| f.serialize }.join
-      end
-
-      def size
-        @alist.inject(0){|sum, a| sum += a[1].size}
-      end
-
-      def [](name)
-        a = @alist.assoc(name.to_s.intern)
-        raise ArgumentError, "no such field: #{name}" unless a
-        a[1]
-      end
-
-      def []=(name, val)
-        a = @alist.assoc(name.to_s.intern)
-        raise ArgumentError, "no such field: #{name}" unless a
-        a[1] = val
-      end
-
-      def enable(name)
-        self[name].active = true
-      end
-
-      def disable(name)
-        self[name].active = false
-      end
-
-      def has_disabled_fields?
-        @alist.any? { |name, field| !field.active }
-      end
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/int16_le.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/int16_le.rb
deleted file mode 100644
index e9fb45bf85beb..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/int16_le.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-module Net
-  module NTLM
-
-    class Int16LE < Field
-
-      def initialize(opt)
-        super(opt)
-        @size = 2
-      end
-
-      def parse(str, offset=0)
-        if @active and str.size >= offset + @size
-          @value = str[offset, @size].unpack("v")[0]
-          @size
-        else
-          0
-        end
-      end
-
-      def serialize
-        [@value].pack("v")
-      end
-    end
-
-  end
-end
\ No newline at end of file
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/int32_le.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/int32_le.rb
deleted file mode 100644
index 789013388bc8c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/int32_le.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-module Net
-  module NTLM
-
-    class Int32LE < Field
-      def initialize(opt)
-        super(opt)
-        @size = 4
-      end
-
-      def parse(str, offset=0)
-        if @active and str.size >= offset + @size
-          @value = str.slice(offset, @size).unpack("V")[0]
-          @size
-        else
-          0
-        end
-      end
-
-      def serialize
-        [@value].pack("V") if @active
-      end
-    end
-
-  end
-end
\ No newline at end of file
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/int64_le.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/int64_le.rb
deleted file mode 100644
index 37bc75537d83b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/int64_le.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-module Net
-  module NTLM
-
-    class Int64LE < Field
-      def initialize(opt)
-        super(opt)
-        @size = 8
-      end
-
-      def parse(str, offset=0)
-        if @active and str.size >= offset + @size
-          d, u = str.slice(offset, @size).unpack("V2")
-          @value = (u * 0x100000000 + d)
-          @size
-        else
-          0
-        end
-      end
-
-      def serialize
-        [@value & 0x00000000ffffffff, @value >> 32].pack("V2") if @active
-      end
-    end
-
-  end
-end
\ No newline at end of file
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message.rb
deleted file mode 100644
index eba8bc13b38a1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message.rb
+++ /dev/null
@@ -1,129 +0,0 @@
-module Net
-module NTLM
-
-  SSP_SIGN = "NTLMSSP\0"
-
-  FLAGS = {
-      :UNICODE              => 0x00000001,
-      :OEM                  => 0x00000002,
-      :REQUEST_TARGET       => 0x00000004,
-      :MBZ9                 => 0x00000008,
-      :SIGN                 => 0x00000010,
-      :SEAL                 => 0x00000020,
-      :NEG_DATAGRAM         => 0x00000040,
-      :NETWARE              => 0x00000100,
-      :NTLM                 => 0x00000200,
-      :NEG_NT_ONLY          => 0x00000400,
-      :MBZ7                 => 0x00000800,
-      :DOMAIN_SUPPLIED      => 0x00001000,
-      :WORKSTATION_SUPPLIED => 0x00002000,
-      :LOCAL_CALL           => 0x00004000,
-      :ALWAYS_SIGN          => 0x00008000,
-      :TARGET_TYPE_DOMAIN   => 0x00010000,
-      :NTLM2_KEY            => 0x00080000,
-      :TARGET_INFO          => 0x00800000,
-      :KEY128               => 0x20000000,
-      :KEY_EXCHANGE         => 0x40000000,
-      :KEY56                => 0x80000000
-  }.freeze
-
-  FLAG_KEYS = FLAGS.keys.sort{|a, b| FLAGS[a] <=> FLAGS[b] }
-
-  DEFAULT_FLAGS = {
-      :TYPE1 => FLAGS[:UNICODE] | FLAGS[:OEM] | FLAGS[:REQUEST_TARGET] | FLAGS[:NTLM] | FLAGS[:ALWAYS_SIGN] | FLAGS[:NTLM2_KEY],
-      :TYPE2 => FLAGS[:UNICODE],
-      :TYPE3 => FLAGS[:UNICODE] | FLAGS[:REQUEST_TARGET] | FLAGS[:NTLM] | FLAGS[:ALWAYS_SIGN] | FLAGS[:NTLM2_KEY]
-  }
-
-
-  # @private false
-  class Message < FieldSet
-    class << Message
-      def parse(str)
-        m = Type0.new
-        m.parse(str)
-        case m.type
-        when 1
-          t = Type1.new.parse(str)
-        when 2
-          t = Type2.new.parse(str)
-        when 3
-          t = Type3.new.parse(str)
-        else
-          raise ArgumentError, "unknown type: #{m.type}"
-        end
-        t
-      end
-
-      def decode64(str)
-        parse(Base64.decode64(str))
-      end
-    end
-
-    # @return [self]
-    def parse(str)
-      super
-
-      while has_disabled_fields? && serialize.size < str.size
-        # enable the next disabled field
-        self.class.names.find { |name| !self[name].active && enable(name) }
-        super
-      end
-
-      self
-    end
-
-    def has_flag?(flag)
-      (self[:flag].value & FLAGS[flag]) == FLAGS[flag]
-    end
-
-    def set_flag(flag)
-      self[:flag].value  |= FLAGS[flag]
-    end
-
-    def dump_flags
-      FLAG_KEYS.each{ |k| print(k, "=", has_flag?(k), "\n") }
-    end
-
-    def serialize
-      deflag
-      super + security_buffers.map{|n, f| f.value}.join
-    end
-
-    def encode64
-      Base64.encode64(serialize).gsub(/\n/, '')
-    end
-
-    def decode64(str)
-      parse(Base64.decode64(str))
-    end
-
-    alias head_size size
-
-    def data_size
-      security_buffers.inject(0){|sum, a| sum += a[1].data_size}
-    end
-
-    def size
-      head_size + data_size
-    end
-
-
-    def security_buffers
-      @alist.find_all{|n, f| f.instance_of?(SecurityBuffer)}
-    end
-
-    def deflag
-      security_buffers.inject(head_size){|cur, a|
-        a[1].offset = cur
-        cur += a[1].data_size
-      }
-    end
-
-    def data_edge
-      security_buffers.map{ |n, f| f.active ? f.offset : size}.min
-    end
-
-  end
-end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message/type0.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message/type0.rb
deleted file mode 100644
index 02334c0def8e2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message/type0.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-module Net
-  module NTLM
-    class Message
-
-      # sub class definitions
-      class Type0 < Message
-        string        :sign,      {:size => 8, :value => SSP_SIGN}
-        int32LE       :type,      {:value => 0}
-      end
-
-
-    end
-  end
-end
-
-
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message/type1.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message/type1.rb
deleted file mode 100644
index 83a8efd773e36..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message/type1.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-module Net
-  module NTLM
-    class Message
-
-      # @private false
-      class Type1 < Message
-
-        string          :sign,         {:size => 8, :value => SSP_SIGN}
-        int32LE         :type,         {:value => 1}
-        int32LE         :flag,         {:value => DEFAULT_FLAGS[:TYPE1] }
-        security_buffer :domain,       {:value => ""}
-        security_buffer :workstation,  {:value => Socket.gethostname }
-        string          :os_version,   {:size => 8, :value => "", :active => false }
-
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message/type2.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message/type2.rb
deleted file mode 100644
index 200dd254647dd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message/type2.rb
+++ /dev/null
@@ -1,102 +0,0 @@
-module Net
-  module NTLM
-    class Message
-
-      # @private false
-      class Type2 < Message
-
-        string          :sign,        { :size => 8, :value => SSP_SIGN }
-        int32LE         :type,        { :value => 2 }
-        security_buffer :target_name, { :size => 0, :value => "" }
-        int32LE         :flag,        { :value => DEFAULT_FLAGS[:TYPE2] }
-        int64LE         :challenge,   { :value => 0}
-        int64LE         :context,     { :value => 0, :active => false }
-        security_buffer :target_info, { :value => "", :active => false }
-        string          :os_version,  { :size => 8, :value => "", :active => false }
-
-        # Generates a Type 3 response based on the Type 2 Information
-        # @return [Type3]
-        # @option arg [String] :username The username to authenticate with
-        # @option arg [String] :password The user's password
-        # @option arg [String] :domain ('') The domain to authenticate to
-        # @option opt [String] :workstation (Socket.gethostname) The name of the calling workstation
-        # @option opt [Boolean] :use_default_target (false) Use the domain supplied by the server in the Type 2 packet
-        # @note An empty :domain option authenticates to the local machine.
-        # @note The :use_default_target has precedence over the :domain option
-        def response(arg, opt = {})
-          usr = arg[:user]
-          pwd = arg[:password]
-          domain = arg[:domain] ? arg[:domain].upcase : ""
-          if usr.nil? or pwd.nil?
-            raise ArgumentError, "user and password have to be supplied"
-          end
-
-          if opt[:workstation]
-            ws = opt[:workstation]
-          else
-            ws = Socket.gethostname
-          end
-
-          if opt[:client_challenge]
-            cc  = opt[:client_challenge]
-          else
-            cc = rand(MAX64)
-          end
-          cc = NTLM::pack_int64le(cc) if cc.is_a?(Integer)
-          opt[:client_challenge] = cc
-
-          if has_flag?(:OEM) and opt[:unicode]
-            usr = NTLM::EncodeUtil.decode_utf16le(usr)
-            pwd = NTLM::EncodeUtil.decode_utf16le(pwd)
-            ws  = NTLM::EncodeUtil.decode_utf16le(ws)
-            domain = NTLM::EncodeUtil.decode_utf16le(domain)
-            opt[:unicode] = false
-          end
-
-          if has_flag?(:UNICODE) and !opt[:unicode]
-            usr = NTLM::EncodeUtil.encode_utf16le(usr)
-            pwd = NTLM::EncodeUtil.encode_utf16le(pwd)
-            ws  = NTLM::EncodeUtil.encode_utf16le(ws)
-            domain = NTLM::EncodeUtil.encode_utf16le(domain)
-            opt[:unicode] = true
-          end
-
-          if opt[:use_default_target]
-            domain = self.target_name
-          end
-
-          ti = self.target_info
-
-          chal = self[:challenge].serialize
-
-          if opt[:ntlmv2]
-            ar = {:ntlmv2_hash => NTLM::ntlmv2_hash(usr, pwd, domain, opt), :challenge => chal, :target_info => ti}
-            lm_res = NTLM::lmv2_response(ar, opt)
-            ntlm_res = NTLM::ntlmv2_response(ar, opt)
-          elsif has_flag?(:NTLM2_KEY)
-            ar = {:ntlm_hash => NTLM::ntlm_hash(pwd, opt), :challenge => chal}
-            lm_res, ntlm_res = NTLM::ntlm2_session(ar, opt)
-          else
-            ar = {:lm_hash => NTLM::lm_hash(pwd), :challenge => chal}
-            lm_res = NTLM::lm_response(ar)
-            ar = {:ntlm_hash => NTLM::ntlm_hash(pwd, opt), :challenge => chal}
-            ntlm_res = NTLM::ntlm_response(ar)
-          end
-
-          Type3.create({
-                           :lm_response => lm_res,
-                           :ntlm_response => ntlm_res,
-                           :domain => domain,
-                           :user => usr,
-                           :workstation => ws,
-                           :flag => self.flag
-                       })
-        end
-
-      end
-
-    end
-  end
-end
-
-
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message/type3.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message/type3.rb
deleted file mode 100644
index 88a8774f00538..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/message/type3.rb
+++ /dev/null
@@ -1,131 +0,0 @@
-module Net
-  module NTLM
-    class Message
-
-      # @private false
-      class Type3 < Message
-
-        string          :sign,          {:size => 8, :value => SSP_SIGN}
-        int32LE         :type,          {:value => 3}
-        security_buffer :lm_response,   {:value => ""}
-        security_buffer :ntlm_response, {:value => ""}
-        security_buffer :domain,        {:value => ""}
-        security_buffer :user,          {:value => ""}
-        security_buffer :workstation,   {:value => ""}
-        security_buffer :session_key,   {:value => "", :active => false }
-        int32LE         :flag,          {:value => 0, :active => false }
-        string          :os_version,    {:size => 8, :active => false }
-
-        class << Type3
-          # Builds a Type 3 packet
-          # @note All options must be properly encoded with either unicode or oem encoding
-          # @return [Type3]
-          # @option arg [String] :lm_response The LM hash
-          # @option arg [String] :ntlm_response The NTLM hash
-          # @option arg [String] :domain The domain to authenticate to
-          # @option arg [String] :workstation The name of the calling workstation
-          # @option arg [String] :session_key The session key
-          # @option arg [Integer] :flag Flags for the packet
-          def create(arg, opt ={})
-            t = new
-            t.lm_response = arg[:lm_response]
-            t.ntlm_response = arg[:ntlm_response]
-            t.domain = arg[:domain]
-            t.user = arg[:user]
-
-            if arg[:workstation]
-              t.workstation = arg[:workstation]
-            end
-
-            if arg[:session_key]
-              t.enable(:session_key)
-              t.session_key = arg[:session_key]
-            end
-
-            if arg[:flag]
-              t.enable(:session_key)
-              t.enable(:flag)
-              t.flag = arg[:flag]
-            end
-            t
-          end
-        end
-
-        # @param server_challenge (see #password?)
-        def blank_password?(server_challenge)
-          password?('', server_challenge)
-        end
-
-        # @param password [String]
-        # @param server_challenge [String] The server's {Type2#challenge challenge} from the
-        #   {Type2} message for which this object is a response.
-        # @return [true] if +password+ was the password used to generate this
-        #   {Type3} message
-        # @return [false] otherwise
-        def password?(password, server_challenge)
-          case ntlm_version
-          when :ntlm2_session
-            ntlm2_session_password?(password, server_challenge)
-          when :ntlmv2
-            ntlmv2_password?(password, server_challenge)
-          else
-            raise
-          end
-        end
-
-        # @return [Symbol]
-        def ntlm_version
-          if ntlm_response.size == 24 && lm_response[0,8] != "\x00"*8 && lm_response[8,16] == "\x00"*16
-            :ntlm2_session
-          elsif ntlm_response.size == 24
-            :ntlmv1
-          elsif ntlm_response.size > 24
-            :ntlmv2
-          end
-        end
-
-        private
-
-        def ntlm2_session_password?(password, server_challenge)
-          hash = ntlm_response
-          _lm, empty_hash = NTLM.ntlm2_session(
-            {
-              :ntlm_hash => NTLM.ntlm_hash(password),
-              :challenge => server_challenge,
-            },
-            {
-              :client_challenge => lm_response[0,8]
-            }
-          )
-          hash == empty_hash
-        end
-
-        def ntlmv2_password?(password, server_challenge)
-
-          # The first 16 bytes of the ntlm_response are the HMAC of the blob
-          # that follows it.
-          blob = Blob.new
-          blob.parse(ntlm_response[16..-1])
-
-          empty_hash = NTLM.ntlmv2_response(
-            {
-              # user and domain came from the serialized data here, so
-              # they're already unicode
-              :ntlmv2_hash => NTLM.ntlmv2_hash(user, '', domain, :unicode => true),
-              :challenge => server_challenge,
-              :target_info => blob.target_info
-            },
-            {
-              :client_challenge => blob.challenge,
-              # The blob's timestamp is already in milliseconds since 1601,
-              # so convert it back to epoch time first
-              :timestamp => (blob.timestamp / 10_000_000) - NTLM::TIME_OFFSET,
-            }
-          )
-
-          empty_hash == ntlm_response
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/security_buffer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/security_buffer.rb
deleted file mode 100644
index 92645c8da22af..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/security_buffer.rb
+++ /dev/null
@@ -1,48 +0,0 @@
-
-module Net
-  module NTLM
-
-    class SecurityBuffer < FieldSet
-
-      int16LE   :length,        {:value => 0}
-      int16LE   :allocated,     {:value => 0}
-      int32LE   :offset,        {:value => 0}
-
-      attr_accessor :active
-      def initialize(opts={})
-        super()
-        @value  = opts[:value]
-        @active = opts[:active].nil? ? true : opts[:active]
-        @size = 8
-      end
-
-      def parse(str, offset=0)
-        if @active and str.size >= offset + @size
-          super(str, offset)
-          @value = str[self.offset, self.length]
-          @size
-        else
-          0
-        end
-      end
-
-      def serialize
-        super if @active
-      end
-
-      def value
-        @value
-      end
-
-      def value=(val)
-        @value = val
-        self.length = self.allocated = val.size
-      end
-
-      def data_size
-        @active ? @value.size : 0
-      end
-    end
-
-  end
-end
\ No newline at end of file
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/string.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/string.rb
deleted file mode 100644
index 28edd9caa2877..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/string.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-module Net
-  module NTLM
-
-    class String < Field
-      def initialize(opts)
-        super(opts)
-        @size = opts[:size]
-      end
-
-      def parse(str, offset=0)
-        if @active and str.size >= offset + @size
-          @value = str[offset, @size]
-          @size
-        else
-          0
-        end
-      end
-
-      def serialize
-        if @active
-          @value.to_s
-        else
-          ""
-        end
-      end
-
-      def value=(val)
-        @value = val
-        @size = @value.nil? ? 0 : @value.size
-        @active = (@size > 0)
-      end
-    end
-
-  end
-end
\ No newline at end of file
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/target_info.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/target_info.rb
deleted file mode 100644
index 7cc50acb10939..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/target_info.rb
+++ /dev/null
@@ -1,89 +0,0 @@
-module Net
-  module NTLM
-
-    # Represents a list of AV_PAIR structures
-    # @see https://msdn.microsoft.com/en-us/library/cc236646.aspx
-    class TargetInfo
-
-      # Allowed AvId values for an AV_PAIR
-      MSV_AV_EOL               = "\x00\x00".freeze
-      MSV_AV_NB_COMPUTER_NAME  = "\x01\x00".freeze
-      MSV_AV_NB_DOMAIN_NAME    = "\x02\x00".freeze
-      MSV_AV_DNS_COMPUTER_NAME = "\x03\x00".freeze
-      MSV_AV_DNS_DOMAIN_NAME   = "\x04\x00".freeze
-      MSV_AV_DNS_TREE_NAME     = "\x05\x00".freeze
-      MSV_AV_FLAGS             = "\x06\x00".freeze
-      MSV_AV_TIMESTAMP         = "\x07\x00".freeze
-      MSV_AV_SINGLE_HOST       = "\x08\x00".freeze
-      MSV_AV_TARGET_NAME       = "\x09\x00".freeze
-      MSV_AV_CHANNEL_BINDINGS  = "\x0A\x00".freeze
-
-      # @param av_pair_sequence [String] AV_PAIR list from challenge message
-      def initialize(av_pair_sequence)
-        @av_pairs = read_pairs(av_pair_sequence)
-      end
-
-      attr_reader :av_pairs
-
-      def to_s
-        result = ''
-        av_pairs.each do |k,v|
-          result << k
-          result << [v.length].pack('S')
-          result << v
-        end
-        result << Net::NTLM::TargetInfo::MSV_AV_EOL
-        result << [0].pack('S')
-        result.force_encoding(Encoding::ASCII_8BIT)
-      end
-
-      private
-
-      VALID_PAIR_ID = [
-          MSV_AV_EOL,
-          MSV_AV_NB_COMPUTER_NAME,
-          MSV_AV_NB_DOMAIN_NAME,
-          MSV_AV_DNS_COMPUTER_NAME,
-          MSV_AV_DNS_DOMAIN_NAME,
-          MSV_AV_DNS_TREE_NAME,
-          MSV_AV_FLAGS,
-          MSV_AV_TIMESTAMP,
-          MSV_AV_SINGLE_HOST,
-          MSV_AV_TARGET_NAME,
-          MSV_AV_CHANNEL_BINDINGS
-      ].freeze
-
-      def read_pairs(av_pair_sequence)
-        offset = 0
-        result = {}
-        return result if av_pair_sequence.nil?
-
-        until offset >= av_pair_sequence.length
-          id = av_pair_sequence[offset..offset+1]
-
-          unless VALID_PAIR_ID.include?(id)
-            raise Net::NTLM::InvalidTargetDataError.new( 
-              "Invalid AvId #{to_hex(id)} in AV_PAIR structure",
-              av_pair_sequence
-            )
-          end
-
-          length = av_pair_sequence[offset+2..offset+3].unpack('S')[0].to_i
-          if length > 0
-            value = av_pair_sequence[offset+4..offset+4+length-1]
-            result[id] = value
-          end
-
-          offset += 4 + length
-        end
-
-        result
-      end
-
-      def to_hex(str)
-        return nil if str.nil?
-        str.bytes.map {|b| '0x' + b.to_s(16).rjust(2,'0').upcase}.join('-')
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/version.rb
deleted file mode 100644
index b6a2dba74fc40..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/net/ntlm/version.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-module Net
-  module NTLM
-    # @private
-    module VERSION
-      MAJOR = 0
-      MINOR = 6
-      TINY  = 3
-      STRING = [MAJOR, MINOR, TINY].join('.')
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/rubyntlm.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/rubyntlm.rb
deleted file mode 100644
index 969c19c714c97..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/rubyntlm-0.6.3/lib/rubyntlm.rb
+++ /dev/null
@@ -1 +0,0 @@
-require 'net/ntlm'
\ No newline at end of file
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter.rb
deleted file mode 100644
index 6f25f5dd31ce6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'simplecov_json_formatter/result_hash_formatter'
-require 'simplecov_json_formatter/result_exporter'
-require 'json'
-
-module SimpleCov
-  module Formatter
-    class JSONFormatter
-      def format(result)
-        result_hash = format_result(result)
-
-        export_formatted_result(result_hash)
-
-        puts output_message(result)
-      end
-
-      private
-
-      def format_result(result)
-        result_hash_formater = SimpleCovJSONFormatter::ResultHashFormatter.new(result)
-        result_hash_formater.format
-      end
-
-      def export_formatted_result(result_hash)
-        result_exporter = SimpleCovJSONFormatter::ResultExporter.new(result_hash)
-        result_exporter.export
-      end
-
-      def output_message(result)
-        "JSON Coverage report generated for #{result.command_name} to #{SimpleCov.coverage_path}. \
-        #{result.covered_lines} / #{result.total_lines} LOC (#{result.covered_percent.round(2)}%) covered."
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter/result_exporter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter/result_exporter.rb
deleted file mode 100644
index 65d2ff603a632..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter/result_exporter.rb
+++ /dev/null
@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module SimpleCovJSONFormatter
-  class ResultExporter
-    FILENAME = 'coverage.json'
-
-    def initialize(result_hash)
-      @result = result_hash
-    end
-
-    def export
-      File.open(export_path, 'w') do |file|
-        file << json_result
-      end
-    end
-
-    private
-
-    def json_result
-      JSON.pretty_generate(@result)
-    end
-
-    def export_path
-      File.join(SimpleCov.coverage_path, FILENAME)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter/result_hash_formatter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter/result_hash_formatter.rb
deleted file mode 100644
index e9c8fc8ae4c11..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter/result_hash_formatter.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'simplecov_json_formatter/source_file_formatter'
-
-module SimpleCovJSONFormatter
-  class ResultHashFormatter
-    def initialize(result)
-      @result = result
-    end
-
-    def format
-      format_files
-      format_groups
-
-      formatted_result
-    end
-
-    private
-
-    def format_files
-      @result.files.each do |source_file|
-        formatted_result[:coverage][source_file.filename] =
-          format_source_file(source_file)
-      end
-    end
-
-    def format_groups
-      @result.groups.each do |name, file_list|
-        formatted_result[:groups][name] = {
-          lines: {
-            covered_percent: file_list.covered_percent
-          }
-        }
-      end
-    end
-
-    def formatted_result
-      @formatted_result ||= {
-        meta: {
-          simplecov_version: SimpleCov::VERSION
-        },
-        coverage: {},
-        groups: {}
-      }
-    end
-
-    def format_source_file(source_file)
-      source_file_formatter = SourceFileFormatter.new(source_file)
-      source_file_formatter.format
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter/source_file_formatter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter/source_file_formatter.rb
deleted file mode 100644
index 6f44f5230bc65..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter/source_file_formatter.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module SimpleCovJSONFormatter
-  class SourceFileFormatter
-    def initialize(source_file)
-      @source_file = source_file
-      @line_coverage = nil
-    end
-
-    def format
-      if SimpleCov.branch_coverage?
-        line_coverage.merge(branch_coverage)
-      else
-        line_coverage
-      end
-    end
-
-    private
-
-    def line_coverage
-      @line_coverage ||= {
-        lines: lines
-      }
-    end
-
-    def branch_coverage
-      {
-        branches: branches
-      }
-    end
-
-    def lines
-      lines = []
-      @source_file.lines.each do |line|
-        lines << parse_line(line)
-      end
-
-      lines
-    end
-
-    def branches
-      branches = []
-      @source_file.branches.each do |branch|
-        branches << parse_branch(branch)
-      end
-
-      branches
-    end
-
-    def parse_line(line)
-      return line.coverage unless line.skipped?
-
-      'ignored'
-    end
-
-    def parse_branch(branch)
-      {
-        type: branch.type,
-        start_line: branch.start_line,
-        end_line: branch.end_line,
-        coverage: parse_line(branch)
-      }
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter/version.rb
deleted file mode 100644
index ef8fadce942f7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/simplecov_json_formatter-0.1.4/lib/simplecov_json_formatter/version.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module SimpleCovJSONFormatter
-  VERSION = '0.1.4'
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/configuration.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/configuration.rb
deleted file mode 100644
index c012b6e8b6eff..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/configuration.rb
+++ /dev/null
@@ -1,591 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module T::Configuration
-  # Cache this comparisonn to avoid two allocations all over the place.
-  AT_LEAST_RUBY_2_7 = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7')
-
-  # Announces to Sorbet that we are currently in a test environment, so it
-  # should treat any sigs which are marked `.checked(:tests)` as if they were
-  # just a normal sig.
-  #
-  # If this method is not called, sigs marked `.checked(:tests)` will not be
-  # checked. In fact, such methods won't even be wrapped--the runtime will put
-  # back the original method.
-  #
-  # Note: Due to the way sigs are evaluated and methods are wrapped, this
-  # method MUST be called before any code calls `sig`. This method raises if
-  # it has been called too late.
-  def self.enable_checking_for_sigs_marked_checked_tests
-    T::Private::RuntimeLevels.enable_checking_in_tests
-  end
-
-  # Announce to Sorbet that we would like the final checks to be enabled when
-  # including and extending modules. Iff this is not called, then the following
-  # example will not raise an error.
-  #
-  # ```ruby
-  # module M
-  #   extend T::Sig
-  #   sig(:final) {void}
-  #   def foo; end
-  # end
-  # class C
-  #   include M
-  #   def foo; end
-  # end
-  # ```
-  def self.enable_final_checks_on_hooks
-    T::Private::Methods.set_final_checks_on_hooks(true)
-  end
-
-  # Undo the effects of a previous call to
-  # `enable_final_checks_on_hooks`.
-  def self.reset_final_checks_on_hooks
-    T::Private::Methods.set_final_checks_on_hooks(false)
-  end
-
-  @include_value_in_type_errors = true
-  # Whether to include values in TypeError messages.
-  #
-  # Including values is useful for debugging, but can potentially leak
-  # sensitive information to logs.
-  #
-  # @return [T::Boolean]
-  def self.include_value_in_type_errors?
-    @include_value_in_type_errors
-  end
-
-  # Configure if type errors excludes the value of the problematic type.
-  #
-  # The default is to include values in type errors:
-  #   TypeError: Expected type Integer, got String with value "foo"
-  #
-  # When values are excluded from type errors:
-  #   TypeError: Expected type Integer, got String
-  def self.exclude_value_in_type_errors
-    @include_value_in_type_errors = false
-  end
-
-  # Opposite of exclude_value_in_type_errors.
-  # (Including values in type errors is the default)
-  def self.include_value_in_type_errors
-    @include_value_in_type_errors = true
-  end
-
-  # Whether VM-defined prop serialization/deserialization routines can be enabled.
-  #
-  # @return [T::Boolean]
-  def self.can_enable_vm_prop_serde?
-    T::Props::Private::DeserializerGenerator.respond_to?(:generate2)
-  end
-
-  @use_vm_prop_serde = false
-  # Whether to use VM-defined prop serialization/deserialization routines.
-  #
-  # The default is to use runtime codegen inside sorbet-runtime itself.
-  #
-  # @return [T::Boolean]
-  def self.use_vm_prop_serde?
-    @use_vm_prop_serde || false
-  end
-
-  # Enable using VM-defined prop serialization/deserialization routines.
-  #
-  # This method is likely to break things outside of Stripe's systems.
-  def self.enable_vm_prop_serde
-    if !can_enable_vm_prop_serde?
-      hard_assert_handler('Ruby VM is not setup to use VM-defined prop serde')
-    end
-    @use_vm_prop_serde = true
-  end
-
-  # Disable using VM-defined prop serialization/deserialization routines.
-  def self.disable_vm_prop_serde
-    @use_vm_prop_serde = false
-  end
-
-  # Configure the default checked level for a sig with no explicit `.checked`
-  # builder. When unset, the default checked level is `:always`.
-  #
-  # Note: setting this option is potentially dangerous! Sorbet can't check all
-  # code statically. The runtime checks complement the checks that Sorbet does
-  # statically, so that methods don't have to guard themselves from being
-  # called incorrectly by untyped code.
-  #
-  # @param [:never, :compiled, :tests, :always] default_checked_level
-  def self.default_checked_level=(default_checked_level)
-    T::Private::RuntimeLevels.default_checked_level = default_checked_level
-  end
-
-  @inline_type_error_handler = nil
-  # Set a handler to handle `TypeError`s raised by any in-line type assertions,
-  # including `T.must`, `T.let`, `T.cast`, and `T.assert_type!`.
-  #
-  # By default, any `TypeError`s detected by this gem will be raised. Setting
-  # inline_type_error_handler to an object that implements :call (e.g. proc or
-  # lambda) allows users to customize the behavior when a `TypeError` is
-  # raised on any inline type assertion.
-  #
-  # @param [Lambda, Proc, Object, nil] value Proc that handles the error (pass
-  #   nil to reset to default behavior)
-  #
-  # Parameters passed to value.call:
-  #
-  #  @param [TypeError] error TypeError that was raised
-  #  @param [Hash] opts A hash containing contextual information on the error:
-  #  @option opts [String] :kind One of:
-  #    ['T.cast', 'T.let', 'T.bind', 'T.assert_type!', 'T.must', 'T.absurd']
-  #  @option opts [Object, nil] :type Expected param/return value type
-  #  @option opts [Object] :value Actual param/return value
-  #
-  # @example
-  #   T::Configuration.inline_type_error_handler = lambda do |error, opts|
-  #     puts error.message
-  #   end
-  def self.inline_type_error_handler=(value)
-    validate_lambda_given!(value)
-    @inline_type_error_handler = value
-  end
-
-  private_class_method def self.inline_type_error_handler_default(error, opts)
-    raise error
-  end
-
-  def self.inline_type_error_handler(error, opts={})
-    if @inline_type_error_handler
-      # Backwards compatibility before `inline_type_error_handler` took a second arg
-      if @inline_type_error_handler.arity == 1
-        @inline_type_error_handler.call(error)
-      else
-        @inline_type_error_handler.call(error, opts)
-      end
-    else
-      inline_type_error_handler_default(error, opts)
-    end
-    nil
-  end
-
-  @sig_builder_error_handler = nil
-  # Set a handler to handle errors that occur when the builder methods in the
-  # body of a sig are executed. The sig builder methods are inside a proc so
-  # that they can be lazily evaluated the first time the method being sig'd is
-  # called.
-  #
-  # By default, improper use of the builder methods within the body of a sig
-  # cause an ArgumentError to be raised. Setting sig_builder_error_handler to an
-  # object that implements :call (e.g. proc or lambda) allows users to
-  # customize the behavior when a sig can't be built for some reason.
-  #
-  # @param [Lambda, Proc, Object, nil] value Proc that handles the error (pass
-  #   nil to reset to default behavior)
-  #
-  # Parameters passed to value.call:
-  #
-  #  @param [StandardError] error The error that was raised
-  #  @param [Thread::Backtrace::Location] location Location of the error
-  #
-  # @example
-  #   T::Configuration.sig_builder_error_handler = lambda do |error, location|
-  #     puts error.message
-  #   end
-  def self.sig_builder_error_handler=(value)
-    validate_lambda_given!(value)
-    @sig_builder_error_handler = value
-  end
-
-  private_class_method def self.sig_builder_error_handler_default(error, location)
-    raise ArgumentError.new("#{location.path}:#{location.lineno}: Error interpreting `sig`:\n  #{error.message}\n\n")
-  end
-
-  def self.sig_builder_error_handler(error, location)
-    if @sig_builder_error_handler
-      @sig_builder_error_handler.call(error, location)
-    else
-      sig_builder_error_handler_default(error, location)
-    end
-    nil
-  end
-
-  @sig_validation_error_handler = nil
-  # Set a handler to handle sig validation errors.
-  #
-  # Sig validation errors include things like abstract checks, override checks,
-  # and type compatibility of arguments. They happen after a sig has been
-  # successfully built, but the built sig is incompatible with other sigs in
-  # some way.
-  #
-  # By default, sig validation errors cause an exception to be raised.
-  # Setting sig_validation_error_handler to an object that implements :call
-  # (e.g. proc or lambda) allows users to customize the behavior when a method
-  # signature's build fails.
-  #
-  # @param [Lambda, Proc, Object, nil] value Proc that handles the error (pass
-  #   nil to reset to default behavior)
-  #
-  # Parameters passed to value.call:
-  #
-  #  @param [StandardError] error The error that was raised
-  #  @param [Hash] opts A hash containing contextual information on the error:
-  #  @option opts [Method, UnboundMethod] :method Method on which the signature build failed
-  #  @option opts [T::Private::Methods::Declaration] :declaration Method
-  #    signature declaration struct
-  #  @option opts [T::Private::Methods::Signature, nil] :signature Signature
-  #    that failed (nil if sig build failed before Signature initialization)
-  #  @option opts [T::Private::Methods::Signature, nil] :super_signature Super
-  #    method's signature (nil if method is not an override or super method
-  #    does not have a method signature)
-  #
-  # @example
-  #   T::Configuration.sig_validation_error_handler = lambda do |error, opts|
-  #     puts error.message
-  #   end
-  def self.sig_validation_error_handler=(value)
-    validate_lambda_given!(value)
-    @sig_validation_error_handler = value
-  end
-
-  private_class_method def self.sig_validation_error_handler_default(error, opts)
-    raise error
-  end
-
-  def self.sig_validation_error_handler(error, opts={})
-    if @sig_validation_error_handler
-      @sig_validation_error_handler.call(error, opts)
-    else
-      sig_validation_error_handler_default(error, opts)
-    end
-    nil
-  end
-
-  @call_validation_error_handler = nil
-  # Set a handler for type errors that result from calling a method.
-  #
-  # By default, errors from calling a method cause an exception to be raised.
-  # Setting call_validation_error_handler to an object that implements :call
-  # (e.g. proc or lambda) allows users to customize the behavior when a method
-  # is called with invalid parameters, or returns an invalid value.
-  #
-  # @param [Lambda, Proc, Object, nil] value Proc that handles the error
-  #   report (pass nil to reset to default behavior)
-  #
-  # Parameters passed to value.call:
-  #
-  #  @param [T::Private::Methods::Signature] signature Signature that failed
-  #  @param [Hash] opts A hash containing contextual information on the error:
-  #  @option opts [String] :message Error message
-  #  @option opts [String] :kind One of:
-  #    ['Parameter', 'Block parameter', 'Return value']
-  #  @option opts [Symbol] :name Param or block param name (nil for return
-  #    value)
-  #  @option opts [Object] :type Expected param/return value type
-  #  @option opts [Object] :value Actual param/return value
-  #  @option opts [Thread::Backtrace::Location] :location Location of the
-  #    caller
-  #
-  # @example
-  #   T::Configuration.call_validation_error_handler = lambda do |signature, opts|
-  #     puts opts[:message]
-  #   end
-  def self.call_validation_error_handler=(value)
-    validate_lambda_given!(value)
-    @call_validation_error_handler = value
-  end
-
-  private_class_method def self.call_validation_error_handler_default(signature, opts)
-    raise TypeError.new(opts[:pretty_message])
-  end
-
-  def self.call_validation_error_handler(signature, opts={})
-    if @call_validation_error_handler
-      @call_validation_error_handler.call(signature, opts)
-    else
-      call_validation_error_handler_default(signature, opts)
-    end
-    nil
-  end
-
-  @log_info_handler = nil
-  # Set a handler for logging
-  #
-  # @param [Lambda, Proc, Object, nil] value Proc that handles the error
-  #   report (pass nil to reset to default behavior)
-  #
-  # Parameters passed to value.call:
-  #
-  #  @param [String] str Message to be logged
-  #  @param [Hash] extra A hash containing additional parameters to be passed along to the logger.
-  #
-  # @example
-  #   T::Configuration.log_info_handler = lambda do |str, extra|
-  #     puts "#{str}, context: #{extra}"
-  #   end
-  def self.log_info_handler=(value)
-    validate_lambda_given!(value)
-    @log_info_handler = value
-  end
-
-  private_class_method def self.log_info_handler_default(str, extra)
-    puts "#{str}, extra: #{extra}"
-  end
-
-  def self.log_info_handler(str, extra)
-    if @log_info_handler
-      @log_info_handler.call(str, extra)
-    else
-      log_info_handler_default(str, extra)
-    end
-  end
-
-  @soft_assert_handler = nil
-  # Set a handler for soft assertions
-  #
-  # These generally shouldn't stop execution of the program, but rather inform
-  # some party of the assertion to action on later.
-  #
-  # @param [Lambda, Proc, Object, nil] value Proc that handles the error
-  #   report (pass nil to reset to default behavior)
-  #
-  # Parameters passed to value.call:
-  #
-  #  @param [String] str Assertion message
-  #  @param [Hash] extra A hash containing additional parameters to be passed along to the handler.
-  #
-  # @example
-  #   T::Configuration.soft_assert_handler = lambda do |str, extra|
-  #     puts "#{str}, context: #{extra}"
-  #   end
-  def self.soft_assert_handler=(value)
-    validate_lambda_given!(value)
-    @soft_assert_handler = value
-  end
-
-  private_class_method def self.soft_assert_handler_default(str, extra)
-    puts "#{str}, extra: #{extra}"
-  end
-
-  def self.soft_assert_handler(str, extra)
-    if @soft_assert_handler
-      @soft_assert_handler.call(str, extra)
-    else
-      soft_assert_handler_default(str, extra)
-    end
-  end
-
-  @hard_assert_handler = nil
-  # Set a handler for hard assertions
-  #
-  # These generally should stop execution of the program, and optionally inform
-  # some party of the assertion.
-  #
-  # @param [Lambda, Proc, Object, nil] value Proc that handles the error
-  #   report (pass nil to reset to default behavior)
-  #
-  # Parameters passed to value.call:
-  #
-  #  @param [String] str Assertion message
-  #  @param [Hash] extra A hash containing additional parameters to be passed along to the handler.
-  #
-  # @example
-  #   T::Configuration.hard_assert_handler = lambda do |str, extra|
-  #     raise "#{str}, context: #{extra}"
-  #   end
-  def self.hard_assert_handler=(value)
-    validate_lambda_given!(value)
-    @hard_assert_handler = value
-  end
-
-  private_class_method def self.hard_assert_handler_default(str, _)
-    raise str
-  end
-
-  def self.hard_assert_handler(str, extra={})
-    if @hard_assert_handler
-      @hard_assert_handler.call(str, extra)
-    else
-      hard_assert_handler_default(str, extra)
-    end
-  end
-
-  @scalar_types = nil
-  # Set a list of class strings that are to be considered scalar.
-  #   (pass nil to reset to default behavior)
-  #
-  # @param [String] values Class name.
-  #
-  # @example
-  #   T::Configuration.scalar_types = ["NilClass", "TrueClass", "FalseClass", ...]
-  def self.scalar_types=(values)
-    if values.nil?
-      @scalar_types = values
-    else
-      bad_values = values.reject {|v| v.class == String}
-      unless bad_values.empty?
-        raise ArgumentError.new("Provided values must all be class name strings.")
-      end
-
-      @scalar_types = values.each_with_object({}) {|x, acc| acc[x] = true}.freeze
-    end
-  end
-
-  @default_scalar_types = {
-    "NilClass" => true,
-    "TrueClass" => true,
-    "FalseClass" => true,
-    "Integer" => true,
-    "Float" => true,
-    "String" => true,
-    "Symbol" => true,
-    "Time" => true,
-    "T::Enum" => true,
-  }.freeze
-
-  def self.scalar_types
-    @scalar_types || @default_scalar_types
-  end
-
-  # Guard against overrides of `name` or `to_s`
-  MODULE_NAME = Module.instance_method(:name)
-  private_constant :MODULE_NAME
-
-  @default_module_name_mangler = if T::Configuration::AT_LEAST_RUBY_2_7
-    ->(type) {MODULE_NAME.bind_call(type)}
-  else
-    ->(type) {MODULE_NAME.bind(type).call}
-  end
-
-  @module_name_mangler = nil
-
-  def self.module_name_mangler
-    @module_name_mangler || @default_module_name_mangler
-  end
-
-  # Set to override the default behavior for converting types
-  #   to names in generated code. Used by the runtime implementation
-  #   associated with `--stripe-packages` mode.
-  #
-  # @param [Lambda, Proc, nil] handler Proc that converts a type (Class/Module)
-  #   to a String (pass nil to reset to default behavior)
-  def self.module_name_mangler=(handler)
-    @module_name_mangler = handler
-  end
-
-  @sensitivity_and_pii_handler = nil
-  # Set to a PII handler function. This will be called with the `sensitivity:`
-  # annotations on things that use `T::Props` and can modify them ahead-of-time.
-  #
-  # @param [Lambda, Proc, nil] handler Proc that takes a hash mapping symbols to the
-  # prop values. Pass nil to avoid changing `sensitivity:` annotations.
-  def self.normalize_sensitivity_and_pii_handler=(handler)
-    @sensitivity_and_pii_handler = handler
-  end
-
-  def self.normalize_sensitivity_and_pii_handler
-    @sensitivity_and_pii_handler
-  end
-
-  @redaction_handler = nil
-  # Set to a redaction handling function. This will be called when the
-  # `_redacted` version of a prop reader is used. By default this is set to
-  # `nil` and will raise an exception when the redacted version of a prop is
-  # accessed.
-  #
-  # @param [Lambda, Proc, nil] handler Proc that converts a value into its
-  # redacted version according to the spec passed as the second argument.
-  def self.redaction_handler=(handler)
-    @redaction_handler = handler
-  end
-
-  def self.redaction_handler
-    @redaction_handler
-  end
-
-  @class_owner_finder = nil
-  # Set to a function which can get the 'owner' of a class. This is
-  # used in reporting deserialization errors
-  #
-  # @param [Lambda, Proc, nil] handler Proc that takes a class and
-  # produces its owner, or `nil` if it does not have one.
-  def self.class_owner_finder=(handler)
-    @class_owner_finder = handler
-  end
-
-  def self.class_owner_finder
-    @class_owner_finder
-  end
-
-  # Temporarily disable ruby warnings while executing the given block. This is
-  # useful when doing something that would normally cause a warning to be
-  # emitted in Ruby verbose mode ($VERBOSE = true).
-  #
-  # @yield
-  #
-  def self.without_ruby_warnings
-    if $VERBOSE
-      begin
-        original_verbose = $VERBOSE
-        $VERBOSE = false
-        yield
-      ensure
-        $VERBOSE = original_verbose
-      end
-    else
-      yield
-    end
-  end
-
-  @legacy_t_enum_migration_mode = false
-  def self.enable_legacy_t_enum_migration_mode
-    @legacy_t_enum_migration_mode = true
-  end
-  def self.disable_legacy_t_enum_migration_mode
-    @legacy_t_enum_migration_mode = false
-  end
-  def self.legacy_t_enum_migration_mode?
-    @legacy_t_enum_migration_mode || false
-  end
-
-  @prop_freeze_handler = ->(instance, prop_name) {}
-
-  def self.prop_freeze_handler=(handler)
-    @prop_freeze_handler = handler
-  end
-
-  def self.prop_freeze_handler
-    @prop_freeze_handler
-  end
-
-  @sealed_violation_whitelist = nil
-  # @param [Array] sealed_violation_whitelist An array of Regexp to validate
-  #   whether inheriting /including a sealed module outside the defining module
-  #   should be allowed. Useful to whitelist benign violations, like shim files
-  #   generated for an autoloader.
-  def self.sealed_violation_whitelist=(sealed_violation_whitelist)
-    if !@sealed_violation_whitelist.nil?
-      raise ArgumentError.new("Cannot overwrite sealed_violation_whitelist after setting it")
-    end
-
-    case sealed_violation_whitelist
-    when Array
-      sealed_violation_whitelist.each do |x|
-        case x
-        when Regexp then nil
-        else raise TypeError.new("sealed_violation_whitelist accepts an Array of Regexp")
-        end
-      end
-    else
-      raise TypeError.new("sealed_violation_whitelist= accepts an Array of Regexp")
-    end
-
-    @sealed_violation_whitelist = sealed_violation_whitelist
-  end
-  def self.sealed_violation_whitelist
-    @sealed_violation_whitelist
-  end
-
-  private_class_method def self.validate_lambda_given!(value)
-    if !value.nil? && !value.respond_to?(:call)
-      raise ArgumentError.new("Provided value must respond to :call")
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/enum.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/enum.rb
deleted file mode 100644
index c2de09abafd73..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/enum.rb
+++ /dev/null
@@ -1,377 +0,0 @@
-# frozen_string_literal: true
-# typed: strict
-
-# Enumerations allow for type-safe declarations of a fixed set of values.
-#
-# Every value is a singleton instance of the class (i.e. `Suit::SPADE.is_a?(Suit) == true`).
-#
-# Each value has a corresponding serialized value. By default this is the constant's name converted
-# to lowercase (e.g. `Suit::Club.serialize == 'club'`); however a custom value may be passed to the
-# constructor. Enum will `freeze` the serialized value.
-#
-# @example Declaring an Enum:
-#   class Suit < T::Enum
-#     enums do
-#       CLUB = new
-#       SPADE = new
-#       DIAMOND = new
-#       HEART = new
-#     end
-#   end
-#
-# @example Custom serialization value:
-#   class Status < T::Enum
-#     enums do
-#       READY = new('rdy')
-#       ...
-#     end
-#   end
-#
-# @example Accessing values:
-#   Suit::SPADE
-#
-# @example Converting from serialized value to enum instance:
-#   Suit.deserialize('club') == Suit::CLUB
-#
-# @example Using enums in type signatures:
-#   sig {params(suit: Suit).returns(Boolean)}
-#   def is_red?(suit); ...; end
-#
-# WARNING: Enum instances are singletons that are shared among all their users. Their internals
-# should be kept immutable to avoid unpredictable action at a distance.
-class T::Enum
-  extend T::Sig
-  extend T::Props::CustomType
-
-  # TODO(jez) Might want to restrict this, or make subclasses provide this type
-  SerializedVal = T.type_alias {T.untyped}
-  private_constant :SerializedVal
-
-  ### Enum class methods ###
-  sig {returns(T::Array[T.attached_class])}
-  def self.values
-    if @values.nil?
-      raise "Attempting to access values of #{self.class} before it has been initialized." \
-        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
-    end
-    @values
-  end
-
-  # This exists for compatibility with the interface of `Hash` & mostly to support
-  # the HashEachMethods Rubocop.
-  sig {params(blk: T.nilable(T.proc.params(arg0: T.attached_class).void)).returns(T.any(T::Enumerator[T.attached_class], T::Array[T.attached_class]))}
-  def self.each_value(&blk)
-    if blk
-      values.each(&blk)
-    else
-      values.each
-    end
-  end
-
-  # Convert from serialized value to enum instance
-  #
-  # Note: It would have been nice to make this method final before people started overriding it.
-  # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {params(serialized_val: SerializedVal).returns(T.nilable(T.attached_class)).checked(:never)}
-  def self.try_deserialize(serialized_val)
-    if @mapping.nil?
-      raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
-        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
-    end
-    @mapping[serialized_val]
-  end
-
-  # Convert from serialized value to enum instance.
-  #
-  # Note: It would have been nice to make this method final before people started overriding it.
-  # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  #
-  # @return [self]
-  # @raise [KeyError] if serialized value does not match any instance.
-  sig {overridable.params(serialized_val: SerializedVal).returns(T.attached_class).checked(:never)}
-  def self.from_serialized(serialized_val)
-    res = try_deserialize(serialized_val)
-    if res.nil?
-      raise KeyError.new("Enum #{self} key not found: #{serialized_val.inspect}")
-    end
-    res
-  end
-
-  # Note: It would have been nice to make this method final before people started overriding it.
-  # @return [Boolean] Does the given serialized value correspond with any of this enum's values.
-  sig {overridable.params(serialized_val: SerializedVal).returns(T::Boolean).checked(:never)}
-  def self.has_serialized?(serialized_val)
-    if @mapping.nil?
-      raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
-        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
-    end
-    @mapping.include?(serialized_val)
-  end
-
-  # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {override.params(instance: T.nilable(T::Enum)).returns(SerializedVal).checked(:never)}
-  def self.serialize(instance)
-    # This is needed otherwise if a Chalk::ODM::Document with a property of the shape
-    # T::Hash[T.nilable(MyEnum), Integer] and a value that looks like {nil => 0} is
-    # serialized, we throw the error on L102.
-    return nil if instance.nil?
-
-    if self == T::Enum
-      raise "Cannot call T::Enum.serialize directly. You must call on a specific child class."
-    end
-    if instance.class != self
-      raise "Cannot call #serialize on a value that is not an instance of #{self}."
-    end
-    instance.serialize
-  end
-
-  # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {override.params(mongo_value: SerializedVal).returns(T.attached_class).checked(:never)}
-  def self.deserialize(mongo_value)
-    if self == T::Enum
-      raise "Cannot call T::Enum.deserialize directly. You must call on a specific child class."
-    end
-    self.from_serialized(mongo_value)
-  end
-
-  ### Enum instance methods ###
-
-  sig {returns(T.self_type)}
-  def dup
-    self
-  end
-
-  sig {returns(T.self_type).checked(:tests)}
-  def clone
-    self
-  end
-
-  # Note: Failed CriticalMethodsNoRuntimeTypingTest
-  sig {returns(SerializedVal).checked(:never)}
-  def serialize
-    assert_bound!
-    @serialized_val
-  end
-
-  sig {params(args: T.untyped).returns(T.untyped)}
-  def to_json(*args)
-    serialize.to_json(*args)
-  end
-
-  sig {params(args: T.untyped).returns(T.untyped)}
-  def as_json(*args)
-    serialized_val = serialize
-    return serialized_val unless serialized_val.respond_to?(:as_json)
-    serialized_val.as_json(*args)
-  end
-
-  sig {returns(String)}
-  def to_s
-    inspect
-  end
-
-  sig {returns(String)}
-  def inspect
-    "#<#{self.class.name}::#{@const_name || '__UNINITIALIZED__'}>"
-  end
-
-  sig {params(other: BasicObject).returns(T.nilable(Integer))}
-  def <=>(other)
-    case other
-    when self.class
-      self.serialize <=> other.serialize
-    else
-      nil
-    end
-  end
-
-  # NB: Do not call this method. This exists to allow for a safe migration path in places where enum
-  # values are compared directly against string values.
-  #
-  # Ruby's string has a weird quirk where `'my_string' == obj` calls obj.==('my_string') if obj
-  # responds to the `to_str` method. It does not actually call `to_str` however.
-  #
-  # See https://ruby-doc.org/core-2.4.0/String.html#method-i-3D-3D
-  sig {returns(String)}
-  def to_str
-    msg = 'Implicit conversion of Enum instances to strings is not allowed. Call #serialize instead.'
-    if T::Configuration.legacy_t_enum_migration_mode?
-      T::Configuration.soft_assert_handler(
-        msg,
-        storytime: {class: self.class.name},
-      )
-      serialize.to_s
-    else
-      raise NoMethodError.new(msg)
-    end
-  end
-
-  sig {params(other: BasicObject).returns(T::Boolean).checked(:never)}
-  def ==(other)
-    case other
-    when String
-      if T::Configuration.legacy_t_enum_migration_mode?
-        comparison_assertion_failed(:==, other)
-        self.serialize == other
-      else
-        false
-      end
-    else
-      super(other)
-    end
-  end
-
-  sig {params(other: BasicObject).returns(T::Boolean).checked(:never)}
-  def ===(other)
-    case other
-    when String
-      if T::Configuration.legacy_t_enum_migration_mode?
-        comparison_assertion_failed(:===, other)
-        self.serialize == other
-      else
-        false
-      end
-    else
-      super(other)
-    end
-  end
-
-  sig {params(method: Symbol, other: T.untyped).void}
-  private def comparison_assertion_failed(method, other)
-    T::Configuration.soft_assert_handler(
-      'Enum to string comparison not allowed. Compare to the Enum instance directly instead. See go/enum-migration',
-      storytime: {
-        class: self.class.name,
-        self: self.inspect,
-        other: other,
-        other_class: other.class.name,
-        method: method,
-      }
-    )
-  end
-
-  ### Private implementation ###
-
-  sig {params(serialized_val: SerializedVal).void}
-  def initialize(serialized_val=nil)
-    raise 'T::Enum is abstract' if self.class == T::Enum
-    if !self.class.started_initializing?
-      raise "Must instantiate all enum values of #{self.class} inside 'enums do'."
-    end
-    if self.class.fully_initialized?
-      raise "Cannot instantiate a new enum value of #{self.class} after it has been initialized."
-    end
-
-    serialized_val = serialized_val.frozen? ? serialized_val : serialized_val.dup.freeze
-    @serialized_val = T.let(serialized_val, T.nilable(SerializedVal))
-    @const_name = T.let(nil, T.nilable(Symbol))
-    self.class._register_instance(self)
-  end
-
-  sig {returns(NilClass).checked(:never)}
-  private def assert_bound!
-    if @const_name.nil?
-      raise "Attempting to access Enum value on #{self.class} before it has been initialized." \
-        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
-    end
-  end
-
-  sig {params(const_name: Symbol).void}
-  def _bind_name(const_name)
-    @const_name = const_name
-    @serialized_val = const_to_serialized_val(const_name) if @serialized_val.nil?
-    freeze
-  end
-
-  sig {params(const_name: Symbol).returns(String)}
-  private def const_to_serialized_val(const_name)
-    # Historical note: We convert to lowercase names because the majority of existing calls to
-    # `make_accessible` were arrays of lowercase strings. Doing this conversion allowed for the
-    # least amount of repetition in migrated declarations.
-    -const_name.to_s.downcase.freeze
-  end
-
-  sig {returns(T::Boolean)}
-  def self.started_initializing?
-    unless defined?(@started_initializing)
-      @started_initializing = T.let(false, T.nilable(T::Boolean))
-    end
-    T.must(@started_initializing)
-  end
-
-  sig {returns(T::Boolean)}
-  def self.fully_initialized?
-    unless defined?(@fully_initialized)
-      @fully_initialized = T.let(false, T.nilable(T::Boolean))
-    end
-    T.must(@fully_initialized)
-  end
-
-  # Maintains the order in which values are defined
-  sig {params(instance: T.untyped).void}
-  def self._register_instance(instance)
-    @values ||= []
-    @values << T.cast(instance, T.attached_class)
-  end
-
-  # Entrypoint for allowing people to register new enum values.
-  # All enum values must be defined within this block.
-  sig {params(blk: T.proc.void).void}
-  def self.enums(&blk)
-    raise "enums cannot be defined for T::Enum" if self == T::Enum
-    raise "Enum #{self} was already initialized" if fully_initialized?
-    raise "Enum #{self} is still initializing" if started_initializing?
-
-    @started_initializing = true
-
-    @values = T.let(nil, T.nilable(T::Array[T.attached_class]))
-
-    yield
-
-    @mapping = T.let(nil, T.nilable(T::Hash[SerializedVal, T.attached_class]))
-    @mapping = {}
-
-    # Freeze the Enum class and bind the constant names into each of the instances.
-    self.constants(false).each do |const_name|
-      instance = self.const_get(const_name, false)
-      if !instance.is_a?(self)
-        raise "Invalid constant #{self}::#{const_name} on enum. " \
-          "All constants defined for an enum must be instances itself (e.g. `Foo = new`)."
-      end
-
-      instance._bind_name(const_name)
-      serialized = instance.serialize
-      if @mapping.include?(serialized)
-        raise "Enum values must have unique serializations. Value '#{serialized}' is repeated on #{self}."
-      end
-      @mapping[serialized] = instance
-    end
-    @values.freeze
-    @mapping.freeze
-
-    orphaned_instances = T.must(@values) - @mapping.values
-    if !orphaned_instances.empty?
-      raise "Enum values must be assigned to constants: #{orphaned_instances.map {|v| v.instance_variable_get('@serialized_val')}}"
-    end
-
-    @fully_initialized = true
-  end
-
-  sig {params(child_class: Module).void}
-  def self.inherited(child_class)
-    super
-
-    raise "Inheriting from children of T::Enum is prohibited" if self != T::Enum
-  end
-
-  # Marshal support
-  sig {params(_level: Integer).returns(String)}
-  def _dump(_level)
-    Marshal.dump(serialize)
-  end
-
-  sig {params(args: String).returns(T.attached_class)}
-  def self._load(args)
-    deserialize(Marshal.load(args)) # rubocop:disable Security/MarshalLoad
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/helpers.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/helpers.rb
deleted file mode 100644
index 7f326e73842d3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/helpers.rb
+++ /dev/null
@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-# Use as a mixin with extend (`extend T::Helpers`).
-# Docs at https://sorbet.org/docs/
-module T::Helpers
-  extend T::Sig
-
-  Private = T::Private
-
-  ### Class/Module Helpers ###
-
-  def abstract!
-    Private::Abstract::Declare.declare_abstract(self, type: :abstract)
-  end
-
-  def interface!
-    Private::Abstract::Declare.declare_abstract(self, type: :interface)
-  end
-
-  def final!
-    Private::Final.declare(self)
-  end
-
-  def sealed!
-    Private::Sealed.declare(self, Kernel.caller(1..1)&.first&.split(':')&.first)
-  end
-
-  # Causes a mixin to also mix in class methods from the named module.
-  #
-  # Nearly equivalent to
-  #
-  #  def self.included(other)
-  #    other.extend(mod)
-  #  end
-  #
-  # Except that it is statically analyzed by sorbet.
-  def mixes_in_class_methods(mod, *mods)
-    Private::Mixins.declare_mixes_in_class_methods(self, [mod].concat(mods))
-  end
-
-  # Specify an inclusion or inheritance requirement for `self`.
-  #
-  # Example:
-  #
-  #   module MyHelper
-  #     extend T::Helpers
-  #
-  #     requires_ancestor { Kernel }
-  #   end
-  #
-  #   class MyClass < BasicObject # error: `MyClass` must include `Kernel` (required by `MyHelper`)
-  #     include MyHelper
-  #   end
-  #
-  # TODO: implement the checks in sorbet-runtime.
-  def requires_ancestor(&block); end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/interface_wrapper.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/interface_wrapper.rb
deleted file mode 100644
index 82998667f774c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/interface_wrapper.rb
+++ /dev/null
@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-# typed: false
-
-# Wraps an object, exposing only the methods defined on a given class/module. The idea is that, in
-# the absence of a static type checker that would prevent you from calling non-Bar methods on a
-# variable of type Bar, we can use these wrappers as a way of enforcing it at runtime.
-#
-# Once we ship static type checking, we should get rid of this entirely.
-class T::InterfaceWrapper
-  extend T::Sig
-
-  module Helpers
-    def wrap_instance(obj)
-      T::InterfaceWrapper.wrap_instance(obj, self)
-    end
-
-    def wrap_instances(arr)
-      T::InterfaceWrapper.wrap_instances(arr, self)
-    end
-  end
-
-  private_class_method :new # use `wrap_instance`
-
-  def self.wrap_instance(obj, interface_mod)
-    wrapper = wrapped_dynamic_cast(obj, interface_mod)
-    if wrapper.nil?
-      raise "#{obj.class} cannot be cast to #{interface_mod}"
-    end
-    wrapper
-  end
-
-  sig do
-    params(
-      arr: Array,
-      interface_mod: T.untyped
-    )
-    .returns(Array)
-  end
-  def self.wrap_instances(arr, interface_mod)
-    arr.map {|instance| self.wrap_instance(instance, interface_mod)}
-  end
-
-  def initialize(target_obj, interface_mod)
-    if target_obj.is_a?(T::InterfaceWrapper)
-      # wrapped_dynamic_cast should guarantee this never happens.
-      raise "Unexpected: wrapping a wrapper. Please report this bug at https://github.com/sorbet/sorbet/issues"
-    end
-
-    if !target_obj.is_a?(interface_mod)
-      # wrapped_dynamic_cast should guarantee this never happens.
-      raise "Unexpected: `is_a?` failed. Please report this bug at https://github.com/sorbet/sorbet/issues"
-    end
-
-    if target_obj.class == interface_mod
-      # wrapped_dynamic_cast should guarantee this never happens.
-      raise "Unexpected: exact class match. Please report this bug at https://github.com/sorbet/sorbet/issues"
-    end
-
-    @target_obj = target_obj
-    @interface_mod = interface_mod
-    self_methods = self.class.self_methods
-
-    # If perf becomes an issue, we can define these on an anonymous subclass, and keep a cache
-    # so we only need to do it once per unique `interface_mod`
-    T::Utils.methods_excluding_object(interface_mod).each do |method_name|
-      if self_methods.include?(method_name)
-        raise "interface_mod has a method that conflicts with #{self.class}: #{method_name}"
-      end
-
-      define_singleton_method(method_name) do |*args, &blk|
-        target_obj.send(method_name, *args, &blk)
-      end
-
-      if target_obj.singleton_class.public_method_defined?(method_name)
-        # no-op, it's already public
-      elsif target_obj.singleton_class.protected_method_defined?(method_name)
-        singleton_class.send(:protected, method_name)
-      elsif target_obj.singleton_class.private_method_defined?(method_name)
-        singleton_class.send(:private, method_name)
-      else
-        raise "This should never happen. Report this bug at https://github.com/sorbet/sorbet/issues"
-      end
-    end
-  end
-
-  def kind_of?(other)
-    is_a?(other)
-  end
-
-  def is_a?(other)
-    if !other.is_a?(Module)
-      raise TypeError.new("class or module required")
-    end
-
-    # This makes is_a? return true for T::InterfaceWrapper (and its ancestors),
-    # as well as for @interface_mod and its ancestors.
-    self.class <= other || @interface_mod <= other
-  end
-
-  # Prefixed because we're polluting the namespace of the interface we're wrapping, and we don't
-  # want anyone else (besides dynamic_cast) calling it.
-  def __target_obj_DO_NOT_USE # rubocop:disable Naming/MethodName
-    @target_obj
-  end
-
-  # Prefixed because we're polluting the namespace of the interface we're wrapping, and we don't
-  # want anyone else (besides wrapped_dynamic_cast) calling it.
-  def __interface_mod_DO_NOT_USE # rubocop:disable Naming/MethodName
-    @interface_mod
-  end
-
-  # "Cast" an object to another type. If `obj` is an InterfaceWrapper, returns the the wrapped
-  # object if that matches `type`. Otherwise, returns `obj` if it matches `type`. Otherwise,
-  # returns nil.
-  #
-  # @param obj [Object] object to cast
-  # @param mod [Module] type to cast `obj` to
-  #
-  # @example
-  #   if (impl = T::InterfaceWrapper.dynamic_cast(iface, MyImplementation))
-  #     impl.do_things
-  #   end
-  def self.dynamic_cast(obj, mod)
-    if obj.is_a?(T::InterfaceWrapper)
-      target_obj = obj.__target_obj_DO_NOT_USE
-      target_obj.is_a?(mod) ? target_obj : nil
-    elsif obj.is_a?(mod)
-      obj
-    else
-      nil
-    end
-  end
-
-  # Like dynamic_cast, but puts the result in its own wrapper if necessary.
-  #
-  # @param obj [Object] object to cast
-  # @param mod [Module] type to cast `obj` to
-  def self.wrapped_dynamic_cast(obj, mod)
-    # Avoid unwrapping and creating an equivalent wrapper.
-    if obj.is_a?(T::InterfaceWrapper) && obj.__interface_mod_DO_NOT_USE == mod
-      return obj
-    end
-
-    cast_obj = dynamic_cast(obj, mod)
-    if cast_obj.nil?
-      nil
-    elsif cast_obj.class == mod
-      # Nothing to wrap, they want the full class
-      cast_obj
-    else
-      new(cast_obj, mod)
-    end
-  end
-
-  def self.self_methods
-    @self_methods ||= self.instance_methods(false).to_set
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/non_forcing_constants.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/non_forcing_constants.rb
deleted file mode 100644
index 96445357cbaed..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/non_forcing_constants.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-# typed: strict
-
-module T::NonForcingConstants
-  # NOTE: This method is documented on the RBI in Sorbet's payload, so that it
-  # shows up in the hover/completion documentation via LSP.
-  T::Sig::WithoutRuntime.sig {params(val: BasicObject, klass: String, package: T.nilable(String)).returns(T::Boolean)}
-  def self.non_forcing_is_a?(val, klass, package: nil)
-    method_name = "T::NonForcingConstants.non_forcing_is_a?"
-    if klass.empty?
-      raise ArgumentError.new("The string given to `#{method_name}` must not be empty")
-    end
-
-    # We don't treat packages differently at runtime, but the static
-    # type-checker still needs to have the package and constant
-    # separated out. This just re-assembles the string as needed
-    if !package.nil?
-      klass = "::#{package}::#{klass}"
-    end
-
-    current_klass = T.let(nil, T.nilable(Module))
-    current_prefix = T.let(nil, T.nilable(String))
-
-    parts = klass.split('::')
-    parts.each do |part|
-      if current_klass.nil?
-        # First iteration
-        if part != "" && package.nil?
-          # if we've supplied a package, we're probably running in
-          # package mode, which means absolute references are
-          # meaningless
-          raise ArgumentError.new("The string given to `#{method_name}` must be an absolute constant reference that starts with `::`")
-        end
-
-        current_klass = Object
-        current_prefix = ''
-
-        # if this had a :: prefix, then there's no more loading to
-        # do---skip to the next one
-        next if part == ""
-      end
-
-      if current_klass.autoload?(part)
-        # There's an autoload registered for that constant, which means it's not
-        # yet loaded. `value` can't be an instance of something not yet loaded.
-        return false
-      end
-
-      # Sorbet guarantees that the string is an absolutely resolved name.
-      search_inheritance_chain = false
-      if !current_klass.const_defined?(part, search_inheritance_chain)
-        return false
-      end
-
-      current_klass = current_klass.const_get(part)
-      current_prefix = "#{current_prefix}::#{part}"
-
-      if !Module.===(current_klass)
-        raise ArgumentError.new("#{current_prefix} is not a class or module")
-      end
-    end
-
-    current_klass.===(val)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/class_utils.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/class_utils.rb
deleted file mode 100644
index 269b70cbee798..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/class_utils.rb
+++ /dev/null
@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-# typed: false
-
-# Cut down version of Chalk::Tools::ClassUtils with only :replace_method functionality.
-# Extracted to a separate namespace so the type system can be used standalone.
-module T::Private::ClassUtils
-  class ReplacedMethod
-    def initialize(mod, old_method, new_method, overwritten, visibility)
-      if old_method.name != new_method.name
-        raise "Method names must match. old=#{old_method.name} new=#{new_method.name}"
-      end
-      @mod = mod
-      @old_method = old_method
-      @new_method = new_method
-      @overwritten = overwritten
-      @name = old_method.name
-      @visibility = visibility
-      @restored = false
-    end
-
-    def restore
-      # The check below would also catch this, but this makes the failure mode much clearer
-      if @restored
-        raise "Method '#{@name}' on '#{@mod}' was already restored"
-      end
-
-      if @mod.instance_method(@name) != @new_method
-        raise "Trying to restore #{@mod}##{@name} but the method has changed since the call to replace_method"
-      end
-
-      @restored = true
-
-      if @overwritten
-        # The original method was overwritten. Overwrite again to restore it.
-        T::Configuration.without_ruby_warnings do
-          @mod.send(:define_method, @old_method.name, @old_method)
-        end
-      else
-        # The original method was in an ancestor. Restore it by removing the overriding method.
-        @mod.send(:remove_method, @old_method.name)
-      end
-
-      # Restore the visibility. Note that we need to do this even when we call remove_method
-      # above, because the module may have set custom visibility for a method it inherited.
-      @mod.send(@visibility, @old_method.name)
-
-      nil
-    end
-
-    def bind(obj)
-      @old_method.bind(obj)
-    end
-
-    def to_s
-      @old_method.to_s
-    end
-  end
-
-  # `name` must be an instance method (for class methods, pass in mod.singleton_class)
-  private_class_method def self.visibility_method_name(mod, name)
-    if mod.public_method_defined?(name)
-      :public
-    elsif mod.protected_method_defined?(name)
-      :protected
-    elsif mod.private_method_defined?(name)
-      :private
-    else
-      raise NameError.new("undefined method `#{name}` for `#{mod}`")
-    end
-  end
-
-  # Replaces a method, either by overwriting it (if it is defined directly on `mod`) or by
-  # overriding it (if it is defined by one of mod's ancestors). Returns a ReplacedMethod instance
-  # on which you can call `bind(...).call(...)` to call the original method, or `restore` to
-  # restore the original method (by overwriting or removing the override).
-  def self.replace_method(mod, name, &blk)
-    original_method = mod.instance_method(name)
-    original_visibility = visibility_method_name(mod, name)
-    original_owner = original_method.owner
-
-    mod.ancestors.each do |ancestor|
-      break if ancestor == mod
-      if ancestor == original_owner
-        # If we get here, that means the method we're trying to replace exists on a *prepended*
-        # mixin, which means in order to supersede it, we'd need to create a method on a new
-        # module that we'd prepend before `ancestor`. The problem with that approach is there'd
-        # be no way to remove that new module after prepending it, so we'd be left with these
-        # empty anonymous modules in the ancestor chain after calling `restore`.
-        #
-        # That's not necessarily a deal breaker, but for now, we're keeping it as unsupported.
-        raise "You're trying to replace `#{name}` on `#{mod}`, but that method exists in a " \
-              "prepended module (#{ancestor}), which we don't currently support."
-      end
-    end
-
-    overwritten = original_owner == mod
-    T::Configuration.without_ruby_warnings do
-      T::Private::DeclState.current.without_on_method_added do
-        mod.send(:define_method, name, &blk)
-        if blk.arity < 0 && mod.respond_to?(:ruby2_keywords, true)
-          mod.send(:ruby2_keywords, name)
-        end
-      end
-    end
-    mod.send(original_visibility, name)
-    new_method = mod.instance_method(name)
-
-    ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/compiler.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/compiler.rb
deleted file mode 100644
index fed86b40f345d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/compiler.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Private
-  module Compiler
-    # If this code ever runs, the caller is running interpreted (or the
-    # compiler didn't see the call to `running_compiled?` statically.)
-    #
-    # The Sorbet Compiler replaces calls to this method unconditionally (no
-    # runtime guards) to return `true` when compiling a file.
-    def self.running_compiled?
-      false
-    end
-
-    # Returns `nil` because the compiler isn't running.
-    #
-    # The Sorbet Compiler replaces calls to this method unconditionally (no
-    # runtime guards) to return a String showing the Sorbet Compiler's version
-    # string.
-    def self.compiler_version
-      nil
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/call_validation.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/call_validation.rb
deleted file mode 100644
index 1889daa991a8c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/call_validation.rb
+++ /dev/null
@@ -1,221 +0,0 @@
-# frozen_string_literal: true
-# typed: false
-
-module T::Private::Methods::CallValidation
-  CallValidation = T::Private::Methods::CallValidation
-  Modes = T::Private::Methods::Modes
-
-  # Wraps a method with a layer of validation for the given type signature.
-  # This wrapper is meant to be fast, and is applied by a previous wrapper,
-  # which was placed by `_on_method_added`.
-  #
-  # @param method_sig [T::Private::Methods::Signature]
-  # @return [UnboundMethod] the new wrapper method (or the original one if we didn't wrap it)
-  def self.wrap_method_if_needed(mod, method_sig, original_method)
-    original_visibility = visibility_method_name(mod, method_sig.method_name)
-    if method_sig.mode == T::Private::Methods::Modes.abstract
-      T::Private::ClassUtils.replace_method(mod, method_sig.method_name) do |*args, &blk|
-        # TODO: write a cop to ensure that abstract methods have an empty body
-        #
-        # We allow abstract methods to be implemented by things further down the ancestor chain.
-        # So, if a super method exists, call it.
-        if defined?(super)
-          super(*args, &blk)
-        else
-          raise NotImplementedError.new(
-            "The method `#{method_sig.method_name}` on #{mod} is declared as `abstract`. It does not have an implementation."
-          )
-        end
-      end
-    # Do nothing in this case; this method was not wrapped in _on_method_added.
-    elsif method_sig.defined_raw
-    # Note, this logic is duplicated (intentionally, for micro-perf) at `Methods._on_method_added`,
-    # make sure to keep changes in sync.
-    # This is a trapdoor point for each method:
-    # if a given method is wrapped, it stays wrapped; and if not, it's never wrapped.
-    # (Therefore, we need the `@wrapped_tests_with_validation` check in `T::RuntimeLevels`.)
-    elsif method_sig.check_level == :always || (method_sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
-      create_validator_method(mod, original_method, method_sig, original_visibility)
-    else
-      T::Configuration.without_ruby_warnings do
-        # get all the shims out of the way and put back the original method
-        T::Private::DeclState.current.without_on_method_added do
-          mod.send(:define_method, method_sig.method_name, original_method)
-        end
-        mod.send(original_visibility, method_sig.method_name)
-      end
-    end
-    # Return the newly created method (or the original one if we didn't replace it)
-    mod.instance_method(method_sig.method_name)
-  end
-
-  @is_allowed_to_have_fast_path = true
-  def self.is_allowed_to_have_fast_path
-    @is_allowed_to_have_fast_path
-  end
-
-  def self.disable_fast_path
-    @is_allowed_to_have_fast_path = false
-  end
-
-  def self.create_validator_method(mod, original_method, method_sig, original_visibility)
-    has_fixed_arity = method_sig.kwarg_types.empty? && !method_sig.has_rest && !method_sig.has_keyrest &&
-      original_method.parameters.all? {|(kind, _name)| kind == :req}
-    ok_for_fast_path = has_fixed_arity && !method_sig.bind && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
-
-    all_args_are_simple = ok_for_fast_path && method_sig.arg_types.all? {|_name, type| type.is_a?(T::Types::Simple)}
-    simple_method = all_args_are_simple && method_sig.return_type.is_a?(T::Types::Simple)
-    simple_procedure = all_args_are_simple && method_sig.return_type.is_a?(T::Private::Types::Void)
-
-    T::Configuration.without_ruby_warnings do
-      T::Private::DeclState.current.without_on_method_added do
-        if simple_method
-          create_validator_method_fast(mod, original_method, method_sig)
-        elsif simple_procedure
-          create_validator_procedure_fast(mod, original_method, method_sig)
-        elsif ok_for_fast_path && method_sig.return_type.is_a?(T::Private::Types::Void)
-          create_validator_procedure_medium(mod, original_method, method_sig)
-        elsif ok_for_fast_path
-          create_validator_method_medium(mod, original_method, method_sig)
-        else
-          create_validator_slow(mod, original_method, method_sig)
-        end
-      end
-    end
-    mod.send(original_visibility, method_sig.method_name)
-  end
-
-  def self.create_validator_slow(mod, original_method, method_sig)
-    mod.send(:define_method, method_sig.method_name) do |*args, &blk|
-      CallValidation.validate_call(self, original_method, method_sig, args, blk)
-    end
-    if mod.respond_to?(:ruby2_keywords, true)
-      mod.send(:ruby2_keywords, method_sig.method_name)
-    end
-  end
-
-  def self.validate_call(instance, original_method, method_sig, args, blk)
-    # This method is called for every `sig`. It's critical to keep it fast and
-    # reduce number of allocations that happen here.
-
-    if method_sig.bind
-      message = method_sig.bind.error_message_for_obj(instance)
-      if message
-        CallValidation.report_error(
-          method_sig,
-          message,
-          'Bind',
-          nil,
-          method_sig.bind,
-          instance
-        )
-      end
-    end
-
-    # NOTE: We don't bother validating for missing or extra kwargs;
-    # the method call itself will take care of that.
-    method_sig.each_args_value_type(args) do |name, arg, type|
-      message = type.error_message_for_obj(arg)
-      if message
-        CallValidation.report_error(
-          method_sig,
-          message,
-          'Parameter',
-          name,
-          type,
-          arg,
-          caller_offset: 2
-        )
-      end
-    end
-
-    if method_sig.block_type
-      message = method_sig.block_type.error_message_for_obj(blk)
-      if message
-        CallValidation.report_error(
-          method_sig,
-          message,
-          'Block parameter',
-          method_sig.block_name,
-          method_sig.block_type,
-          blk
-        )
-      end
-    end
-
-    # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-    # PRY note:
-    # this code is sig validation code.
-    # Please issue `finish` to step out of it
-
-    return_value = T::Configuration::AT_LEAST_RUBY_2_7 ? original_method.bind_call(instance, *args, &blk) : original_method.bind(instance).call(*args, &blk)
-
-    # The only type that is allowed to change the return value is `.void`.
-    # It ignores what you returned and changes it to be a private singleton.
-    if method_sig.return_type.is_a?(T::Private::Types::Void)
-      T::Private::Types::Void::VOID
-    else
-      message = method_sig.return_type.error_message_for_obj(return_value)
-      if message
-        CallValidation.report_error(
-          method_sig,
-          message,
-          'Return value',
-          nil,
-          method_sig.return_type,
-          return_value,
-        )
-      end
-      return_value
-    end
-  end
-
-  def self.report_error(method_sig, error_message, kind, name, type, value, caller_offset: 0)
-    caller_loc = T.must(caller_locations(3 + caller_offset, 1))[0]
-    definition_file, definition_line = method_sig.method.source_location
-
-    pretty_message = "#{kind}#{name ? " '#{name}'" : ''}: #{error_message}\n" \
-      "Caller: #{caller_loc.path}:#{caller_loc.lineno}\n" \
-      "Definition: #{definition_file}:#{definition_line}"
-
-    T::Configuration.call_validation_error_handler(
-      method_sig,
-      message: error_message,
-      pretty_message: pretty_message,
-      kind: kind,
-      name: name,
-      type: type,
-      value: value,
-      location: caller_loc
-    )
-  end
-
-  # `name` must be an instance method (for class methods, pass in mod.singleton_class)
-  private_class_method def self.visibility_method_name(mod, name)
-    if mod.public_method_defined?(name)
-      :public
-    elsif mod.protected_method_defined?(name)
-      :protected
-    elsif mod.private_method_defined?(name)
-      :private
-    else
-      raise NameError.new("undefined method `#{name}` for `#{mod}`")
-    end
-  end
-end
-
-if T::Configuration::AT_LEAST_RUBY_2_7
-  require_relative './call_validation_2_7'
-else
-  require_relative './call_validation_2_6'
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/call_validation_2_6.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/call_validation_2_6.rb
deleted file mode 100644
index 753580dc364ec..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/call_validation_2_6.rb
+++ /dev/null
@@ -1,1203 +0,0 @@
-# frozen_string_literal: true
-# typed: false
-
-# DO NOT EDIT. This file is autogenerated. To regenerate, run:
-#
-#     bazel test //gems/sorbet-runtime:update_call_validation
-
-module T::Private::Methods::CallValidation
-  def self.create_validator_method_fast(mod, original_method, method_sig)
-    if method_sig.return_type.is_a?(T::Private::Types::Void)
-      raise 'Should have used create_validator_procedure_fast'
-    end
-    # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
-      create_validator_method_fast0(mod, original_method, method_sig, method_sig.return_type.raw_type)
-    elsif method_sig.arg_types.length == 1
-      create_validator_method_fast1(mod, original_method, method_sig, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type)
-    elsif method_sig.arg_types.length == 2
-      create_validator_method_fast2(mod, original_method, method_sig, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type)
-    elsif method_sig.arg_types.length == 3
-      create_validator_method_fast3(mod, original_method, method_sig, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type)
-    elsif method_sig.arg_types.length == 4
-      create_validator_method_fast4(mod, original_method, method_sig, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type,
-                                    method_sig.arg_types[3][1].raw_type)
-    else
-      raise 'should not happen'
-    end
-  end
-
-  def self.create_validator_method_fast0(mod, original_method, method_sig, return_type)
-    mod.send(:define_method, method_sig.method_name) do |&blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(&blk)
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_fast1(mod, original_method, method_sig, return_type, arg0_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(arg0, &blk)
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_fast2(mod, original_method, method_sig, return_type, arg0_type, arg1_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(arg0, arg1, &blk)
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_fast3(mod, original_method, method_sig, return_type, arg0_type, arg1_type, arg2_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2.is_a?(arg2_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(arg0, arg1, arg2, &blk)
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_fast4(mod, original_method, method_sig, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, arg3, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2.is_a?(arg2_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      unless arg3.is_a?(arg3_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[3][1].error_message_for_obj(arg3),
-          'Parameter',
-          method_sig.arg_types[3][0],
-          arg3_type,
-          arg3,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_procedure_fast(mod, original_method, method_sig)
-    # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
-      create_validator_procedure_fast0(mod, original_method, method_sig)
-    elsif method_sig.arg_types.length == 1
-      create_validator_procedure_fast1(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1].raw_type)
-    elsif method_sig.arg_types.length == 2
-      create_validator_procedure_fast2(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type)
-    elsif method_sig.arg_types.length == 3
-      create_validator_procedure_fast3(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type)
-    elsif method_sig.arg_types.length == 4
-      create_validator_procedure_fast4(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type,
-                                    method_sig.arg_types[3][1].raw_type)
-    else
-      raise 'should not happen'
-    end
-  end
-
-  def self.create_validator_procedure_fast0(mod, original_method, method_sig)
-    mod.send(:define_method, method_sig.method_name) do |&blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind(self).call(&blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_fast1(mod, original_method, method_sig, arg0_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind(self).call(arg0, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_fast2(mod, original_method, method_sig, arg0_type, arg1_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind(self).call(arg0, arg1, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_fast3(mod, original_method, method_sig, arg0_type, arg1_type, arg2_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2.is_a?(arg2_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind(self).call(arg0, arg1, arg2, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_fast4(mod, original_method, method_sig, arg0_type, arg1_type, arg2_type, arg3_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, arg3, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2.is_a?(arg2_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      unless arg3.is_a?(arg3_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[3][1].error_message_for_obj(arg3),
-          'Parameter',
-          method_sig.arg_types[3][0],
-          arg3_type,
-          arg3,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_method_medium(mod, original_method, method_sig)
-    if method_sig.return_type.is_a?(T::Private::Types::Void)
-      raise 'Should have used create_validator_procedure_medium'
-    end
-    # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
-      create_validator_method_medium0(mod, original_method, method_sig, method_sig.return_type)
-    elsif method_sig.arg_types.length == 1
-      create_validator_method_medium1(mod, original_method, method_sig, method_sig.return_type,
-                                    method_sig.arg_types[0][1])
-    elsif method_sig.arg_types.length == 2
-      create_validator_method_medium2(mod, original_method, method_sig, method_sig.return_type,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1])
-    elsif method_sig.arg_types.length == 3
-      create_validator_method_medium3(mod, original_method, method_sig, method_sig.return_type,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1])
-    elsif method_sig.arg_types.length == 4
-      create_validator_method_medium4(mod, original_method, method_sig, method_sig.return_type,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1],
-                                    method_sig.arg_types[3][1])
-    else
-      raise 'should not happen'
-    end
-  end
-
-  def self.create_validator_method_medium0(mod, original_method, method_sig, return_type)
-    mod.send(:define_method, method_sig.method_name) do |&blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(&blk)
-      unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_medium1(mod, original_method, method_sig, return_type, arg0_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(arg0, &blk)
-      unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_medium2(mod, original_method, method_sig, return_type, arg0_type, arg1_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1_type.valid?(arg1)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(arg0, arg1, &blk)
-      unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_medium3(mod, original_method, method_sig, return_type, arg0_type, arg1_type, arg2_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1_type.valid?(arg1)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2_type.valid?(arg2)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(arg0, arg1, arg2, &blk)
-      unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_medium4(mod, original_method, method_sig, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, arg3, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1_type.valid?(arg1)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2_type.valid?(arg2)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      unless arg3_type.valid?(arg3)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[3][1].error_message_for_obj(arg3),
-          'Parameter',
-          method_sig.arg_types[3][0],
-          arg3_type,
-          arg3,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
-      unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_procedure_medium(mod, original_method, method_sig)
-    # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
-      create_validator_procedure_medium0(mod, original_method, method_sig)
-    elsif method_sig.arg_types.length == 1
-      create_validator_procedure_medium1(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1])
-    elsif method_sig.arg_types.length == 2
-      create_validator_procedure_medium2(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1])
-    elsif method_sig.arg_types.length == 3
-      create_validator_procedure_medium3(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1])
-    elsif method_sig.arg_types.length == 4
-      create_validator_procedure_medium4(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1],
-                                    method_sig.arg_types[3][1])
-    else
-      raise 'should not happen'
-    end
-  end
-
-  def self.create_validator_procedure_medium0(mod, original_method, method_sig)
-    mod.send(:define_method, method_sig.method_name) do |&blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind(self).call(&blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_medium1(mod, original_method, method_sig, arg0_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind(self).call(arg0, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_medium2(mod, original_method, method_sig, arg0_type, arg1_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1_type.valid?(arg1)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind(self).call(arg0, arg1, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_medium3(mod, original_method, method_sig, arg0_type, arg1_type, arg2_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1_type.valid?(arg1)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2_type.valid?(arg2)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind(self).call(arg0, arg1, arg2, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_medium4(mod, original_method, method_sig, arg0_type, arg1_type, arg2_type, arg3_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, arg3, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1_type.valid?(arg1)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2_type.valid?(arg2)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      unless arg3_type.valid?(arg3)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[3][1].error_message_for_obj(arg3),
-          'Parameter',
-          method_sig.arg_types[3][0],
-          arg3_type,
-          arg3,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/call_validation_2_7.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/call_validation_2_7.rb
deleted file mode 100644
index 1686db8977cf4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/call_validation_2_7.rb
+++ /dev/null
@@ -1,1203 +0,0 @@
-# frozen_string_literal: true
-# typed: false
-
-# DO NOT EDIT. This file is autogenerated. To regenerate, run:
-#
-#     bazel test //gems/sorbet-runtime:update_call_validation
-
-module T::Private::Methods::CallValidation
-  def self.create_validator_method_fast(mod, original_method, method_sig)
-    if method_sig.return_type.is_a?(T::Private::Types::Void)
-      raise 'Should have used create_validator_procedure_fast'
-    end
-    # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
-      create_validator_method_fast0(mod, original_method, method_sig, method_sig.return_type.raw_type)
-    elsif method_sig.arg_types.length == 1
-      create_validator_method_fast1(mod, original_method, method_sig, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type)
-    elsif method_sig.arg_types.length == 2
-      create_validator_method_fast2(mod, original_method, method_sig, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type)
-    elsif method_sig.arg_types.length == 3
-      create_validator_method_fast3(mod, original_method, method_sig, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type)
-    elsif method_sig.arg_types.length == 4
-      create_validator_method_fast4(mod, original_method, method_sig, method_sig.return_type.raw_type,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type,
-                                    method_sig.arg_types[3][1].raw_type)
-    else
-      raise 'should not happen'
-    end
-  end
-
-  def self.create_validator_method_fast0(mod, original_method, method_sig, return_type)
-    mod.send(:define_method, method_sig.method_name) do |&blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind_call(self, &blk)
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_fast1(mod, original_method, method_sig, return_type, arg0_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind_call(self, arg0, &blk)
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_fast2(mod, original_method, method_sig, return_type, arg0_type, arg1_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind_call(self, arg0, arg1, &blk)
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_fast3(mod, original_method, method_sig, return_type, arg0_type, arg1_type, arg2_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2.is_a?(arg2_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind_call(self, arg0, arg1, arg2, &blk)
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_fast4(mod, original_method, method_sig, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, arg3, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2.is_a?(arg2_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      unless arg3.is_a?(arg3_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[3][1].error_message_for_obj(arg3),
-          'Parameter',
-          method_sig.arg_types[3][0],
-          arg3_type,
-          arg3,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind_call(self, arg0, arg1, arg2, arg3, &blk)
-      unless return_value.is_a?(return_type)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_procedure_fast(mod, original_method, method_sig)
-    # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
-      create_validator_procedure_fast0(mod, original_method, method_sig)
-    elsif method_sig.arg_types.length == 1
-      create_validator_procedure_fast1(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1].raw_type)
-    elsif method_sig.arg_types.length == 2
-      create_validator_procedure_fast2(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type)
-    elsif method_sig.arg_types.length == 3
-      create_validator_procedure_fast3(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type)
-    elsif method_sig.arg_types.length == 4
-      create_validator_procedure_fast4(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1].raw_type,
-                                    method_sig.arg_types[1][1].raw_type,
-                                    method_sig.arg_types[2][1].raw_type,
-                                    method_sig.arg_types[3][1].raw_type)
-    else
-      raise 'should not happen'
-    end
-  end
-
-  def self.create_validator_procedure_fast0(mod, original_method, method_sig)
-    mod.send(:define_method, method_sig.method_name) do |&blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind_call(self, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_fast1(mod, original_method, method_sig, arg0_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind_call(self, arg0, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_fast2(mod, original_method, method_sig, arg0_type, arg1_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind_call(self, arg0, arg1, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_fast3(mod, original_method, method_sig, arg0_type, arg1_type, arg2_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2.is_a?(arg2_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind_call(self, arg0, arg1, arg2, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_fast4(mod, original_method, method_sig, arg0_type, arg1_type, arg2_type, arg3_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, arg3, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0.is_a?(arg0_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1.is_a?(arg1_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2.is_a?(arg2_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      unless arg3.is_a?(arg3_type)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[3][1].error_message_for_obj(arg3),
-          'Parameter',
-          method_sig.arg_types[3][0],
-          arg3_type,
-          arg3,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind_call(self, arg0, arg1, arg2, arg3, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_method_medium(mod, original_method, method_sig)
-    if method_sig.return_type.is_a?(T::Private::Types::Void)
-      raise 'Should have used create_validator_procedure_medium'
-    end
-    # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
-      create_validator_method_medium0(mod, original_method, method_sig, method_sig.return_type)
-    elsif method_sig.arg_types.length == 1
-      create_validator_method_medium1(mod, original_method, method_sig, method_sig.return_type,
-                                    method_sig.arg_types[0][1])
-    elsif method_sig.arg_types.length == 2
-      create_validator_method_medium2(mod, original_method, method_sig, method_sig.return_type,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1])
-    elsif method_sig.arg_types.length == 3
-      create_validator_method_medium3(mod, original_method, method_sig, method_sig.return_type,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1])
-    elsif method_sig.arg_types.length == 4
-      create_validator_method_medium4(mod, original_method, method_sig, method_sig.return_type,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1],
-                                    method_sig.arg_types[3][1])
-    else
-      raise 'should not happen'
-    end
-  end
-
-  def self.create_validator_method_medium0(mod, original_method, method_sig, return_type)
-    mod.send(:define_method, method_sig.method_name) do |&blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind_call(self, &blk)
-      unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_medium1(mod, original_method, method_sig, return_type, arg0_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind_call(self, arg0, &blk)
-      unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_medium2(mod, original_method, method_sig, return_type, arg0_type, arg1_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1_type.valid?(arg1)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind_call(self, arg0, arg1, &blk)
-      unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_medium3(mod, original_method, method_sig, return_type, arg0_type, arg1_type, arg2_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1_type.valid?(arg1)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2_type.valid?(arg2)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind_call(self, arg0, arg1, arg2, &blk)
-      unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_method_medium4(mod, original_method, method_sig, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, arg3, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1_type.valid?(arg1)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2_type.valid?(arg2)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      unless arg3_type.valid?(arg3)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[3][1].error_message_for_obj(arg3),
-          'Parameter',
-          method_sig.arg_types[3][0],
-          arg3_type,
-          arg3,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      return_value = original_method.bind_call(self, arg0, arg1, arg2, arg3, &blk)
-      unless return_type.valid?(return_value)
-        message = method_sig.return_type.error_message_for_obj(return_value)
-        if message
-          CallValidation.report_error(
-            method_sig,
-            message,
-            'Return value',
-            nil,
-            method_sig.return_type,
-            return_value,
-            caller_offset: -1
-          )
-        end
-      end
-      return_value
-    end
-  end
-
-  def self.create_validator_procedure_medium(mod, original_method, method_sig)
-    # trampoline to reduce stack frame size
-    if method_sig.arg_types.empty?
-      create_validator_procedure_medium0(mod, original_method, method_sig)
-    elsif method_sig.arg_types.length == 1
-      create_validator_procedure_medium1(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1])
-    elsif method_sig.arg_types.length == 2
-      create_validator_procedure_medium2(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1])
-    elsif method_sig.arg_types.length == 3
-      create_validator_procedure_medium3(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1])
-    elsif method_sig.arg_types.length == 4
-      create_validator_procedure_medium4(mod, original_method, method_sig,
-                                    method_sig.arg_types[0][1],
-                                    method_sig.arg_types[1][1],
-                                    method_sig.arg_types[2][1],
-                                    method_sig.arg_types[3][1])
-    else
-      raise 'should not happen'
-    end
-  end
-
-  def self.create_validator_procedure_medium0(mod, original_method, method_sig)
-    mod.send(:define_method, method_sig.method_name) do |&blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind_call(self, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_medium1(mod, original_method, method_sig, arg0_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind_call(self, arg0, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_medium2(mod, original_method, method_sig, arg0_type, arg1_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1_type.valid?(arg1)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind_call(self, arg0, arg1, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_medium3(mod, original_method, method_sig, arg0_type, arg1_type, arg2_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1_type.valid?(arg1)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2_type.valid?(arg2)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind_call(self, arg0, arg1, arg2, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-  def self.create_validator_procedure_medium4(mod, original_method, method_sig, arg0_type, arg1_type, arg2_type, arg3_type)
-    mod.send(:define_method, method_sig.method_name) do |arg0, arg1, arg2, arg3, &blk|
-      # This method is a manually sped-up version of more general code in `validate_call`
-      unless arg0_type.valid?(arg0)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[0][1].error_message_for_obj(arg0),
-          'Parameter',
-          method_sig.arg_types[0][0],
-          arg0_type,
-          arg0,
-          caller_offset: -1
-        )
-      end
-
-      unless arg1_type.valid?(arg1)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[1][1].error_message_for_obj(arg1),
-          'Parameter',
-          method_sig.arg_types[1][0],
-          arg1_type,
-          arg1,
-          caller_offset: -1
-        )
-      end
-
-      unless arg2_type.valid?(arg2)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[2][1].error_message_for_obj(arg2),
-          'Parameter',
-          method_sig.arg_types[2][0],
-          arg2_type,
-          arg2,
-          caller_offset: -1
-        )
-      end
-
-      unless arg3_type.valid?(arg3)
-        CallValidation.report_error(
-          method_sig,
-          method_sig.arg_types[3][1].error_message_for_obj(arg3),
-          'Parameter',
-          method_sig.arg_types[3][0],
-          arg3_type,
-          arg3,
-          caller_offset: -1
-        )
-      end
-
-      # The following line breaks are intentional to show nice pry message
-
-
-
-
-
-
-
-
-
-
-      # PRY note:
-      # this code is sig validation code.
-      # Please issue `finish` to step out of it
-
-      original_method.bind_call(self, arg0, arg1, arg2, arg3, &blk)
-      T::Private::Types::Void::VOID
-    end
-  end
-
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/signature.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/signature.rb
deleted file mode 100644
index bd15977bd5dd8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/signature.rb
+++ /dev/null
@@ -1,225 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-class T::Private::Methods::Signature
-  attr_reader :method, :method_name, :arg_types, :kwarg_types, :block_type, :block_name,
-              :rest_type, :rest_name, :keyrest_type, :keyrest_name, :bind,
-              :return_type, :mode, :req_arg_count, :req_kwarg_names, :has_rest, :has_keyrest,
-              :check_level, :parameters, :on_failure, :override_allow_incompatible,
-              :defined_raw
-
-  def self.new_untyped(method:, mode: T::Private::Methods::Modes.untyped, parameters: method.parameters)
-    # Using `Untyped` ensures we'll get an error if we ever try validation on these.
-    not_typed = T::Private::Types::NotTyped.new
-    raw_return_type = not_typed
-    # Map missing parameter names to "argN" positionally
-    parameters = parameters.each_with_index.map do |(param_kind, param_name), index|
-      [param_kind, param_name || "arg#{index}"]
-    end
-    raw_arg_types = parameters.map do |_param_kind, param_name|
-      [param_name, not_typed]
-    end.to_h
-
-    self.new(
-      method: method,
-      method_name: method.name,
-      raw_arg_types: raw_arg_types,
-      raw_return_type: raw_return_type,
-      bind: nil,
-      mode: mode,
-      check_level: :never,
-      parameters: parameters,
-      on_failure: nil,
-    )
-  end
-
-  def initialize(method:, method_name:, raw_arg_types:, raw_return_type:, bind:, mode:, check_level:, on_failure:, parameters: method.parameters, override_allow_incompatible: false, defined_raw: false)
-    @method = method
-    @method_name = method_name
-    @arg_types = []
-    @kwarg_types = {}
-    @block_type = nil
-    @block_name = nil
-    @rest_type = nil
-    @rest_name = nil
-    @keyrest_type = nil
-    @keyrest_name = nil
-    @return_type = T::Utils.coerce(raw_return_type)
-    @bind = bind ? T::Utils.coerce(bind) : bind
-    @mode = mode
-    @check_level = check_level
-    @req_arg_count = 0
-    @req_kwarg_names = []
-    @has_rest = false
-    @has_keyrest = false
-    @parameters = parameters
-    @on_failure = on_failure
-    @override_allow_incompatible = override_allow_incompatible
-    @defined_raw = defined_raw
-
-    declared_param_names = raw_arg_types.keys
-    # If sig params are declared but there is a single parameter with a missing name
-    # **and** the method ends with a "=", assume it is a writer method generated
-    # by attr_writer or attr_accessor
-    writer_method = declared_param_names != [nil] && parameters == [[:req]] && method_name[-1] == "="
-    # For writer methods, map the single parameter to the method name without the "=" at the end
-    parameters = [[:req, method_name[0...-1].to_sym]] if writer_method
-    param_names = parameters.map {|_, name| name}
-    missing_names = param_names - declared_param_names
-    extra_names = declared_param_names - param_names
-    if !missing_names.empty?
-      raise "The declaration for `#{method.name}` is missing parameter(s): #{missing_names.join(', ')}"
-    end
-    if !extra_names.empty?
-      raise "The declaration for `#{method.name}` has extra parameter(s): #{extra_names.join(', ')}"
-    end
-
-    if parameters.size != raw_arg_types.size
-      raise "The declaration for `#{method.name}` has arguments with duplicate names"
-    end
-
-    parameters.zip(raw_arg_types) do |(param_kind, param_name), (type_name, raw_type)|
-      if type_name != param_name
-        hint = ""
-        # Ruby reorders params so that required keyword arguments
-        # always precede optional keyword arguments. We can't tell
-        # whether the culprit is the Ruby reordering or user error, so
-        # we error but include a note
-        if param_kind == :keyreq && parameters.any? {|k, _| k == :key}
-          hint = "\n\nNote: Any required keyword arguments must precede any optional keyword " \
-                 "arguments. If your method declaration matches your `def`, try reordering any " \
-                 "optional keyword parameters to the end of the method list."
-        end
-
-        raise "Parameter `#{type_name}` is declared out of order (declared as arg number " \
-              "#{declared_param_names.index(type_name) + 1}, defined in the method as arg number " \
-              "#{param_names.index(type_name) + 1}).#{hint}\nMethod: #{method_desc}"
-      end
-
-      type = T::Utils.coerce(raw_type)
-
-      case param_kind
-      when :req
-        if @arg_types.length > @req_arg_count
-          # Note that this is actually is supported by Ruby, but it would add complexity to
-          # support it here, and I'm happy to discourage its use anyway.
-          #
-          # If you are seeing this error and surprised by it, it's possible that you have
-          # overridden the method described in the error message. For example, Rails defines
-          # def self.update!(id = :all, attributes)
-          # on AR models. If you have also defined `self.update!` on an AR model you might
-          # see this error. The simplest resolution is to rename your method.
-          raise "Required params after optional params are not supported in method declarations. Method: #{method_desc}"
-        end
-        @arg_types << [param_name, type]
-        @req_arg_count += 1
-      when :opt
-        @arg_types << [param_name, type]
-      when :key, :keyreq
-        @kwarg_types[param_name] = type
-        if param_kind == :keyreq
-          @req_kwarg_names << param_name
-        end
-      when :block
-        @block_name = param_name
-        @block_type = type
-      when :rest
-        @has_rest = true
-        @rest_name = param_name
-        @rest_type = type
-      when :keyrest
-        @has_keyrest = true
-        @keyrest_name = param_name
-        @keyrest_type = type
-      else
-        raise "Unexpected param_kind: `#{param_kind}`. Method: #{method_desc}"
-      end
-    end
-  end
-
-  attr_writer :method_name
-  protected :method_name=
-
-  def as_alias(alias_name)
-    new_sig = clone
-    new_sig.method_name = alias_name
-    new_sig
-  end
-
-  def arg_count
-    @arg_types.length
-  end
-
-  def kwarg_names
-    @kwarg_types.keys
-  end
-
-  def owner
-    @method.owner
-  end
-
-  def dsl_method
-    "#{@mode}_method"
-  end
-
-  # @return [Hash] a mapping like `{arg_name: [val, type], ...}`, for only those args actually present.
-  def each_args_value_type(args)
-    # Manually split out args and kwargs based on ruby's behavior. Do not try to implement this by
-    # getting ruby to determine the kwargs for you (e.g., by defining this method to take *args and
-    # **kwargs). That won't work, because ruby's behavior for determining kwargs is dependent on the
-    # the other parameters in the method definition, and our method definition here doesn't (and
-    # can't) match the definition of the method we're validating. In addition, Ruby has a bug that
-    # causes forwarding **kwargs to do the wrong thing: see https://bugs.ruby-lang.org/issues/10708
-    # and https://bugs.ruby-lang.org/issues/11860.
-    args_length = args.length
-    if (args_length > @req_arg_count) && (!@kwarg_types.empty? || @has_keyrest) && args[-1].is_a?(Hash)
-      kwargs = args[-1]
-      args_length -= 1
-    else
-      kwargs = EMPTY_HASH
-    end
-
-    arg_types = @arg_types
-
-    if @has_rest
-      rest_count = args_length - @arg_types.length
-      rest_count = 0 if rest_count.negative?
-
-      arg_types += [[@rest_name, @rest_type]] * rest_count
-
-    elsif (args_length < @req_arg_count) || (args_length > @arg_types.length)
-      expected_str = @req_arg_count.to_s
-      if @arg_types.length != @req_arg_count
-        expected_str += "..#{@arg_types.length}"
-      end
-      raise ArgumentError.new("wrong number of arguments (given #{args_length}, expected #{expected_str})")
-    end
-
-    begin
-      it = 0
-      while it < args_length
-        yield arg_types[it][0], args[it], arg_types[it][1]
-        it += 1
-      end
-    end
-
-    kwargs.each do |name, val|
-      type = @kwarg_types[name]
-      if !type && @has_keyrest
-        type = @keyrest_type
-      end
-      yield name, val, type if type
-    end
-  end
-
-  def method_desc
-    loc = if @method.source_location
-      @method.source_location.join(':')
-    else
-      "<unknown location>"
-    end
-    "#{@method} at #{loc}"
-  end
-
-  EMPTY_HASH = {}.freeze
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/signature_validation.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/signature_validation.rb
deleted file mode 100644
index 16188e0bf3dde..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/signature_validation.rb
+++ /dev/null
@@ -1,225 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Private::Methods::SignatureValidation
-  Methods = T::Private::Methods
-  Modes = Methods::Modes
-
-  def self.validate(signature)
-    if signature.method_name == :initialize && signature.method.owner.is_a?(Class)
-      # Constructors are special. They look like overrides in terms of a super_method existing,
-      # but in practice, you never call them polymorphically. Conceptually, they're standard
-      # methods (this is consistent with how they're treated in other languages, e.g. Java)
-      if signature.mode != Modes.standard
-        raise "`initialize` should not use `.abstract` or `.implementation` or any other inheritance modifiers."
-      end
-      return
-    end
-
-    super_method = signature.method.super_method
-
-    if super_method && super_method.owner != signature.method.owner
-      Methods.maybe_run_sig_block_for_method(super_method)
-      super_signature = Methods.signature_for_method(super_method)
-
-      # If the super_method has any kwargs we can't build a
-      # Signature for it, so we'll just skip validation in that case.
-      if !super_signature && !super_method.parameters.select {|kind, _| kind == :rest || kind == :kwrest}.empty?
-        nil
-      else
-        # super_signature can be nil when we're overriding a method (perhaps a builtin) that didn't use
-        # one of the method signature helpers. Use an untyped signature so we can still validate
-        # everything but types.
-        #
-        # We treat these signatures as overridable, that way people can use `.override` with
-        # overrides of builtins. In the future we could try to distinguish when the method is a
-        # builtin and treat non-builtins as non-overridable (so you'd be forced to declare them with
-        # `.overridable`).
-        #
-        super_signature ||= Methods::Signature.new_untyped(method: super_method)
-
-        validate_override_mode(signature, super_signature)
-        validate_override_shape(signature, super_signature)
-        validate_override_types(signature, super_signature)
-      end
-    else
-      validate_non_override_mode(signature)
-    end
-  end
-
-  private_class_method def self.pretty_mode(signature)
-    if signature.mode == Modes.overridable_override
-      '.overridable.override'
-    else
-      ".#{signature.mode}"
-    end
-  end
-
-  def self.validate_override_mode(signature, super_signature)
-    case signature.mode
-    when *Modes::OVERRIDE_MODES
-      # Peaceful
-    when *Modes::NON_OVERRIDE_MODES
-      if super_signature.mode == Modes.standard
-        # Peaceful
-      elsif super_signature.mode == Modes.abstract
-        raise "You must use `.override` when overriding the abstract method `#{signature.method_name}`.\n" \
-              "  Abstract definition: #{method_loc_str(super_signature.method)}\n" \
-              "  Implementation definition: #{method_loc_str(signature.method)}\n"
-      elsif super_signature.mode != Modes.untyped
-        raise "You must use `.override` when overriding the existing method `#{signature.method_name}`.\n" \
-              "  Parent definition: #{method_loc_str(super_signature.method)}\n" \
-              "  Child definition:  #{method_loc_str(signature.method)}\n"
-      end
-    else
-      raise "Unexpected mode: #{signature.mode}. Please report this bug at https://github.com/sorbet/sorbet/issues"
-    end
-  end
-
-  def self.validate_non_override_mode(signature)
-    case signature.mode
-    when Modes.override
-      if signature.method_name == :each && signature.method.owner < Enumerable
-        # Enumerable#each is the only method in Sorbet's RBI payload that defines an abstract method.
-        # Enumerable#each does not actually exist at runtime, but it is required to be implemented by
-        # any class which includes Enumerable. We want to declare Enumerable#each as abstract so that
-        # people can call it anything which implements the Enumerable interface, and so that it's a
-        # static error to forget to implement it.
-        #
-        # This is a one-off hack, and we should think carefully before adding more methods here.
-        nil
-      else
-        raise "You marked `#{signature.method_name}` as #{pretty_mode(signature)}, but that method doesn't already exist in this class/module to be overriden.\n" \
-          "  Either check for typos and for missing includes or super classes to make the parent method shows up\n" \
-          "  ... or remove #{pretty_mode(signature)} here: #{method_loc_str(signature.method)}\n"
-      end
-    when Modes.standard, *Modes::NON_OVERRIDE_MODES
-      # Peaceful
-      nil
-    else
-      raise "Unexpected mode: #{signature.mode}. Please report this bug at https://github.com/sorbet/sorbet/issues"
-    end
-
-    # Given a singleton class, we can check if it belongs to a
-    # module by looking at its superclass; given `module M`,
-    # `M.singleton_class.superclass == Module`, which is not true
-    # for any class.
-    owner = signature.method.owner
-    if (signature.mode == Modes.abstract || Modes::OVERRIDABLE_MODES.include?(signature.mode)) &&
-        owner.singleton_class? && owner.superclass == Module
-      raise "Defining an overridable class method (via #{pretty_mode(signature)}) " \
-            "on a module is not allowed. Class methods on " \
-            "modules do not get inherited and thus cannot be overridden."
-    end
-  end
-
-  def self.validate_override_shape(signature, super_signature)
-    return if signature.override_allow_incompatible
-    return if super_signature.mode == Modes.untyped
-
-    method_name = signature.method_name
-    mode_verb = super_signature.mode == Modes.abstract ? 'implements' : 'overrides'
-
-    if !signature.has_rest && signature.arg_count < super_signature.arg_count
-      raise "Your definition of `#{method_name}` must accept at least #{super_signature.arg_count} " \
-            "positional arguments to be compatible with the method it #{mode_verb}: " \
-            "#{base_override_loc_str(signature, super_signature)}"
-    end
-
-    if !signature.has_rest && super_signature.has_rest
-      raise "Your definition of `#{method_name}` must have `*#{super_signature.rest_name}` " \
-            "to be compatible with the method it #{mode_verb}: " \
-            "#{base_override_loc_str(signature, super_signature)}"
-    end
-
-    if signature.req_arg_count > super_signature.req_arg_count
-      raise "Your definition of `#{method_name}` must have no more than #{super_signature.req_arg_count} " \
-            "required argument(s) to be compatible with the method it #{mode_verb}: " \
-            "#{base_override_loc_str(signature, super_signature)}"
-    end
-
-    if !signature.has_keyrest
-      # O(nm), but n and m are tiny here
-      missing_kwargs = super_signature.kwarg_names - signature.kwarg_names
-      if !missing_kwargs.empty?
-        raise "Your definition of `#{method_name}` is missing these keyword arg(s): #{missing_kwargs} " \
-              "which are defined in the method it #{mode_verb}: " \
-              "#{base_override_loc_str(signature, super_signature)}"
-      end
-    end
-
-    if !signature.has_keyrest && super_signature.has_keyrest
-      raise "Your definition of `#{method_name}` must have `**#{super_signature.keyrest_name}` " \
-            "to be compatible with the method it #{mode_verb}: " \
-            "#{base_override_loc_str(signature, super_signature)}"
-    end
-
-    # O(nm), but n and m are tiny here
-    extra_req_kwargs = signature.req_kwarg_names - super_signature.req_kwarg_names
-    if !extra_req_kwargs.empty?
-      raise "Your definition of `#{method_name}` has extra required keyword arg(s) " \
-            "#{extra_req_kwargs} relative to the method it #{mode_verb}, making it incompatible: " \
-            "#{base_override_loc_str(signature, super_signature)}"
-    end
-
-    if super_signature.block_name && !signature.block_name
-      raise "Your definition of `#{method_name}` must accept a block parameter to be compatible " \
-            "with the method it #{mode_verb}: " \
-            "#{base_override_loc_str(signature, super_signature)}"
-    end
-  end
-
-  def self.validate_override_types(signature, super_signature)
-    return if signature.override_allow_incompatible
-    return if super_signature.mode == Modes.untyped
-    return unless [signature, super_signature].all? do |sig|
-      sig.check_level == :always || sig.check_level == :compiled || (sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
-    end
-    mode_noun = super_signature.mode == Modes.abstract ? 'implementation' : 'override'
-
-    # arg types must be contravariant
-    super_signature.arg_types.zip(signature.arg_types).each_with_index do |((_super_name, super_type), (name, type)), index|
-      if !super_type.subtype_of?(type)
-        raise "Incompatible type for arg ##{index + 1} (`#{name}`) in signature for #{mode_noun} of method " \
-              "`#{signature.method_name}`:\n" \
-              "* Base: `#{super_type}` (in #{method_loc_str(super_signature.method)})\n" \
-              "* #{mode_noun.capitalize}: `#{type}` (in #{method_loc_str(signature.method)})\n" \
-              "(The types must be contravariant.)"
-      end
-    end
-
-    # kwarg types must be contravariant
-    super_signature.kwarg_types.each do |name, super_type|
-      type = signature.kwarg_types[name]
-      if !super_type.subtype_of?(type)
-        raise "Incompatible type for arg `#{name}` in signature for #{mode_noun} of method `#{signature.method_name}`:\n" \
-              "* Base: `#{super_type}` (in #{method_loc_str(super_signature.method)})\n" \
-              "* #{mode_noun.capitalize}: `#{type}` (in #{method_loc_str(signature.method)})\n" \
-              "(The types must be contravariant.)"
-      end
-    end
-
-    # return types must be covariant
-    if !signature.return_type.subtype_of?(super_signature.return_type)
-      raise "Incompatible return type in signature for #{mode_noun} of method `#{signature.method_name}`:\n" \
-            "* Base: `#{super_signature.return_type}` (in #{method_loc_str(super_signature.method)})\n" \
-            "* #{mode_noun.capitalize}: `#{signature.return_type}` (in #{method_loc_str(signature.method)})\n" \
-            "(The types must be covariant.)"
-    end
-  end
-
-  private_class_method def self.base_override_loc_str(signature, super_signature)
-    mode_noun = super_signature.mode == Modes.abstract ? 'Implementation' : 'Override'
-    "\n * Base definition: in #{method_loc_str(super_signature.method)}" \
-    "\n * #{mode_noun}: in #{method_loc_str(signature.method)}"
-  end
-
-  private_class_method def self.method_loc_str(method)
-    loc = if method.source_location
-      method.source_location.join(':')
-    else
-      "<unknown location>"
-    end
-    "#{method.owner} at #{loc}"
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/runtime_levels.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/runtime_levels.rb
deleted file mode 100644
index 2454b219883f5..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/runtime_levels.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-# Used in `sig.checked(level)` to determine when runtime type checking
-# is enabled on a method.
-module T::Private::RuntimeLevels
-  LEVELS = [
-    # Validate every call in every environment
-    :always,
-    # Validate in tests, but not in production
-    :tests,
-    # Don't even validate in tests, b/c too expensive,
-    # or b/c we fully trust the static typing
-    :never,
-    # Validate the sig when the file is using the Sorbet Compiler.
-    # Behaves like :never when interpreted.
-    :compiled,
-  ].freeze
-
-  @check_tests = false
-  @wrapped_tests_with_validation = false
-
-  @has_read_default_checked_level = false
-  @default_checked_level = :always
-
-  def self.check_tests?
-    # Assume that this code path means that some `sig.checked(:tests)`
-    # has been wrapped (or not wrapped) already, which is a trapdoor
-    # for toggling `@check_tests`.
-    @wrapped_tests_with_validation = true
-
-    @check_tests
-  end
-
-  def self.enable_checking_in_tests
-    if !@check_tests && @wrapped_tests_with_validation
-      all_checked_tests_sigs = T::Private::Methods.all_checked_tests_sigs
-      locations = all_checked_tests_sigs.map {|sig| sig.method.source_location.join(':')}.join("\n- ")
-      raise "Toggle `:tests`-level runtime type checking earlier. " \
-        "There are already some methods wrapped with `sig.checked(:tests)`:\n" \
-        "- #{locations}"
-    end
-
-    _toggle_checking_tests(true)
-  end
-
-  def self.default_checked_level
-    @has_read_default_checked_level = true
-    @default_checked_level
-  end
-
-  def self.default_checked_level=(default_checked_level)
-    if @has_read_default_checked_level
-      raise "Set the default checked level earlier. There are already some methods whose sig blocks have evaluated which would not be affected by the new default."
-    end
-    @default_checked_level = default_checked_level
-  end
-
-  def self._toggle_checking_tests(checked)
-    @check_tests = checked
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/types/void.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/types/void.rb
deleted file mode 100644
index 310fc56abc708..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/types/void.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-# A marking class for when methods return void.
-# Should never appear in types directly.
-class T::Private::Types::Void < T::Types::Base
-  ERROR_MESSAGE = "Validation is being done on an `Void`. Please report this bug at https://github.com/sorbet/sorbet/issues"
-
-  # The actual return value of `.void` methods.
-  #
-  # Uses `module VOID` because this gives it a readable name when someone
-  # examines it in Pry or with `#inspect` like:
-  #
-  #     T::Private::Types::Void::VOID
-  #
-  module VOID
-    freeze
-  end
-
-  # overrides Base
-  def name
-    "<VOID>"
-  end
-
-  # overrides Base
-  def valid?(obj)
-    raise ERROR_MESSAGE
-  end
-
-  # overrides Base
-  private def subtype_of_single?(other)
-    raise ERROR_MESSAGE
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/pretty_printable.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/pretty_printable.rb
deleted file mode 100644
index e821cd3435836..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/pretty_printable.rb
+++ /dev/null
@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Props::PrettyPrintable
-  include T::Props::Plugin
-
-  # Return a string representation of this object and all of its props
-  def inspect
-    T.unsafe(T.cast(self, Object).class).decorator.inspect_instance(self)
-  end
-
-  # Override the PP gem with something that's similar, but gives us a hook
-  # to do redaction
-  def pretty_inspect
-    T.unsafe(T.cast(self, Object).class).decorator.inspect_instance(self, multiline: true)
-  end
-
-  module DecoratorMethods
-    extend T::Sig
-
-    sig {params(key: Symbol).returns(T::Boolean).checked(:never)}
-    def valid_rule_key?(key)
-      super || key == :inspect
-    end
-
-    sig do
-      params(instance: T::Props::PrettyPrintable, multiline: T::Boolean, indent: String)
-      .returns(String)
-    end
-    def inspect_instance(instance, multiline: false, indent: '  ')
-      components =
-        inspect_instance_components(
-          instance,
-          multiline: multiline,
-          indent: indent
-        )
-          .reject(&:empty?)
-
-      # Not using #<> here as that makes pry highlight these objects
-      # as if they were all comments, whereas this makes them look
-      # like the structured thing they are.
-      if multiline
-        "#{components[0]}:\n" + T.must(components[1..-1]).join("\n")
-      else
-        "<#{components.join(' ')}>"
-      end
-    end
-
-    sig do
-      params(instance: T::Props::PrettyPrintable, multiline: T::Boolean, indent: String)
-      .returns(T::Array[String])
-    end
-    private def inspect_instance_components(instance, multiline:, indent:)
-      pretty_props = T.unsafe(self).all_props.map do |prop|
-        [prop, inspect_prop_value(instance, prop, multiline: multiline, indent: indent)]
-      end
-
-      joined_props = join_props_with_pretty_values(
-        pretty_props,
-        multiline: multiline,
-        indent: indent
-      )
-
-      [
-        T.unsafe(self).decorated_class.to_s,
-        joined_props,
-      ]
-    end
-
-    sig do
-      params(instance: T::Props::PrettyPrintable, prop: Symbol, multiline: T::Boolean, indent: String)
-      .returns(String)
-      .checked(:never)
-    end
-    private def inspect_prop_value(instance, prop, multiline:, indent:)
-      val = T.unsafe(self).get(instance, prop)
-      rules = T.unsafe(self).prop_rules(prop)
-      if (custom_inspect = rules[:inspect])
-        if T::Utils.arity(custom_inspect) == 1
-          custom_inspect.call(val)
-        else
-          custom_inspect.call(val, {multiline: multiline, indent: indent})
-        end
-      elsif rules[:sensitivity] && !rules[:sensitivity].empty? && !val.nil?
-        "<REDACTED #{rules[:sensitivity].join(', ')}>"
-      else
-        val.inspect
-      end
-    end
-
-    sig do
-      params(pretty_kvs: T::Array[[Symbol, String]], multiline: T::Boolean, indent: String)
-      .returns(String)
-    end
-    private def join_props_with_pretty_values(pretty_kvs, multiline:, indent: '  ')
-      pairs = pretty_kvs
-        .sort_by {|k, _v| k.to_s}
-        .map {|k, v| "#{k}=#{v}"}
-
-      if multiline
-        indent + pairs.join("\n#{indent}")
-      else
-        pairs.join(', ')
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/private/setter_factory.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/private/setter_factory.rb
deleted file mode 100644
index 00c76ed1e7f31..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/private/setter_factory.rb
+++ /dev/null
@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-# typed: strict
-
-module T::Props
-  module Private
-    module SetterFactory
-      extend T::Sig
-
-      SetterProc = T.type_alias {T.proc.params(val: T.untyped).void}
-      ValidateProc = T.type_alias {T.proc.params(prop: Symbol, value: T.untyped).void}
-
-      sig do
-        params(
-          klass: T.all(Module, T::Props::ClassMethods),
-          prop: Symbol,
-          rules: T::Hash[Symbol, T.untyped]
-        )
-        .returns(SetterProc)
-        .checked(:never)
-      end
-      def self.build_setter_proc(klass, prop, rules)
-        # Our nil check works differently than a simple T.nilable for various
-        # reasons (including the `raise_on_nil_write` setting and the existence
-        # of defaults & factories), so unwrap any T.nilable and do a check
-        # manually.
-        non_nil_type = T::Utils::Nilable.get_underlying_type_object(rules.fetch(:type_object))
-        accessor_key = rules.fetch(:accessor_key)
-        validate = rules[:setter_validate]
-
-        # It seems like a bug that this affects the behavior of setters, but
-        # some existing code relies on this behavior
-        has_explicit_nil_default = rules.key?(:default) && rules.fetch(:default).nil?
-
-        # Use separate methods in order to ensure that we only close over necessary
-        # variables
-        if !T::Props::Utils.need_nil_write_check?(rules) || has_explicit_nil_default
-          if validate.nil? && non_nil_type.is_a?(T::Types::Simple)
-            simple_nilable_proc(prop, accessor_key, non_nil_type.raw_type, klass)
-          else
-            nilable_proc(prop, accessor_key, non_nil_type, klass, validate)
-          end
-        else
-          if validate.nil? && non_nil_type.is_a?(T::Types::Simple)
-            simple_non_nil_proc(prop, accessor_key, non_nil_type.raw_type, klass)
-          else
-            non_nil_proc(prop, accessor_key, non_nil_type, klass, validate)
-          end
-        end
-      end
-
-      sig do
-        params(
-          prop: Symbol,
-          accessor_key: Symbol,
-          non_nil_type: Module,
-          klass: T.all(Module, T::Props::ClassMethods),
-        )
-        .returns(SetterProc)
-      end
-      private_class_method def self.simple_non_nil_proc(prop, accessor_key, non_nil_type, klass)
-        proc do |val|
-          unless val.is_a?(non_nil_type)
-            T::Props::Private::SetterFactory.raise_pretty_error(
-              klass,
-              prop,
-              T::Utils.coerce(non_nil_type),
-              val,
-            )
-          end
-          instance_variable_set(accessor_key, val)
-        end
-      end
-
-      sig do
-        params(
-          prop: Symbol,
-          accessor_key: Symbol,
-          non_nil_type: T::Types::Base,
-          klass: T.all(Module, T::Props::ClassMethods),
-          validate: T.nilable(ValidateProc)
-        )
-        .returns(SetterProc)
-      end
-      private_class_method def self.non_nil_proc(prop, accessor_key, non_nil_type, klass, validate)
-        proc do |val|
-          # this use of recursively_valid? is intentional: unlike for
-          # methods, we want to make sure data at the 'edge'
-          # (e.g. models that go into databases or structs serialized
-          # from disk) are correct, so we use more thorough runtime
-          # checks there
-          if non_nil_type.recursively_valid?(val)
-            validate&.call(prop, val)
-          else
-            T::Props::Private::SetterFactory.raise_pretty_error(
-              klass,
-              prop,
-              non_nil_type,
-              val,
-            )
-          end
-          instance_variable_set(accessor_key, val)
-        end
-      end
-
-      sig do
-        params(
-          prop: Symbol,
-          accessor_key: Symbol,
-          non_nil_type: Module,
-          klass: T.all(Module, T::Props::ClassMethods),
-        )
-        .returns(SetterProc)
-      end
-      private_class_method def self.simple_nilable_proc(prop, accessor_key, non_nil_type, klass)
-        proc do |val|
-          if val.nil?
-            instance_variable_set(accessor_key, nil)
-          elsif val.is_a?(non_nil_type)
-            instance_variable_set(accessor_key, val)
-          else
-            T::Props::Private::SetterFactory.raise_pretty_error(
-              klass,
-              prop,
-              T::Utils.coerce(non_nil_type),
-              val,
-            )
-            instance_variable_set(accessor_key, val)
-          end
-        end
-      end
-
-      sig do
-        params(
-          prop: Symbol,
-          accessor_key: Symbol,
-          non_nil_type: T::Types::Base,
-          klass: T.all(Module, T::Props::ClassMethods),
-          validate: T.nilable(ValidateProc),
-        )
-        .returns(SetterProc)
-      end
-      private_class_method def self.nilable_proc(prop, accessor_key, non_nil_type, klass, validate)
-        proc do |val|
-          if val.nil?
-            instance_variable_set(accessor_key, nil)
-          # this use of recursively_valid? is intentional: unlike for
-          # methods, we want to make sure data at the 'edge'
-          # (e.g. models that go into databases or structs serialized
-          # from disk) are correct, so we use more thorough runtime
-          # checks there
-          elsif non_nil_type.recursively_valid?(val)
-            validate&.call(prop, val)
-            instance_variable_set(accessor_key, val)
-          else
-            T::Props::Private::SetterFactory.raise_pretty_error(
-              klass,
-              prop,
-              non_nil_type,
-              val,
-            )
-            instance_variable_set(accessor_key, val)
-          end
-        end
-      end
-
-      sig do
-        params(
-          klass: T.all(Module, T::Props::ClassMethods),
-          prop: Symbol,
-          type: T.any(T::Types::Base, Module),
-          val: T.untyped,
-        )
-        .void
-      end
-      def self.raise_pretty_error(klass, prop, type, val)
-        base_message = "Can't set #{klass.name}.#{prop} to #{val.inspect} (instance of #{val.class}) - need a #{type}"
-
-        pretty_message = "Parameter '#{prop}': #{base_message}\n"
-        caller_loc = caller_locations&.find {|l| !l.to_s.include?('sorbet-runtime/lib/types/props')}
-        if caller_loc
-          pretty_message += "Caller: #{caller_loc.path}:#{caller_loc.lineno}\n"
-        end
-
-        T::Configuration.call_validation_error_handler(
-          nil,
-          message: base_message,
-          pretty_message: pretty_message,
-          kind: 'Parameter',
-          name: prop,
-          type: type,
-          value: val,
-          location: caller_loc,
-        )
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/struct.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/struct.rb
deleted file mode 100644
index 79e6b303d391c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/struct.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-class T::InexactStruct
-  include T::Props
-  include T::Props::Serializable
-  include T::Props::Constructor
-end
-
-class T::Struct < T::InexactStruct
-  def self.inherited(subclass)
-    super(subclass)
-    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited) do |s|
-      super(s)
-      raise "#{self.name} is a subclass of T::Struct and cannot be subclassed"
-    end
-  end
-end
-
-class T::ImmutableStruct < T::InexactStruct
-  extend T::Sig
-
-  def self.inherited(subclass)
-    super(subclass)
-
-    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited) do |s|
-      super(s)
-      raise "#{self.name} is a subclass of T::ImmutableStruct and cannot be subclassed"
-    end
-  end
-
-  # Matches the one in WeakConstructor, but freezes the object
-  sig {params(hash: T::Hash[Symbol, T.untyped]).void.checked(:never)}
-  def initialize(hash={})
-    super
-
-    freeze
-  end
-
-  # Matches the signature in Props, but raises since this is an immutable struct and only const is allowed
-  sig {params(name: Symbol, cls: T.untyped, rules: T.untyped).void}
-  def self.prop(name, cls, rules={})
-    return super if (cls.is_a?(Hash) && cls[:immutable]) || rules[:immutable]
-
-    raise "Cannot use `prop` in #{self.name} because it is an immutable struct. Use `const` instead"
-  end
-
-  def with(changed_props)
-    raise "Cannot use `with` in #{self.class.name} because it is an immutable struct"
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/base.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/base.rb
deleted file mode 100644
index cce89b178a049..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/base.rb
+++ /dev/null
@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Types
-  class Base
-    def self.method_added(method_name)
-      super(method_name)
-      # What is now `subtype_of_single?` used to be named `subtype_of?`. Make sure people don't
-      # override the wrong thing.
-      #
-      # NB: Outside of T::Types, we would enforce this by using `sig` and not declaring the method
-      # as overridable, but doing so here would result in a dependency cycle.
-      if method_name == :subtype_of? && self != T::Types::Base
-        raise "`subtype_of?` should not be overridden. You probably want to override " \
-              "`subtype_of_single?` instead."
-      end
-    end
-
-    # this will be redefined in certain subclasses
-    def recursively_valid?(obj)
-      valid?(obj)
-    end
-
-    def valid?(obj)
-      raise NotImplementedError
-    end
-
-    # @return [T::Boolean] This method must be implemented to return whether the subclass is a subtype
-    # of `type`. This should only be called by `subtype_of?`, which guarantees that `type` will be
-    # a "single" type, by which we mean it won't be a Union or an Intersection (c.f.
-    # `isSubTypeSingle` in sorbet).
-    private def subtype_of_single?(type)
-      raise NotImplementedError
-    end
-
-    # Equality is based on name, so be sure the name reflects all relevant state when implementing.
-    def name
-      raise NotImplementedError
-    end
-
-    # Mirrors ruby_typer::core::Types::isSubType
-    # See https://git.corp.stripe.com/stripe-internal/ruby-typer/blob/9fc8ed998c04ac0b96592ae6bb3493b8a925c5c1/core/types/subtyping.cc#L912-L950
-    #
-    # This method cannot be overridden (see `method_added` above).
-    # Subclasses only need to implement `subtype_of_single?`).
-    def subtype_of?(t2)
-      t1 = self
-
-      if t2.is_a?(T::Private::Types::TypeAlias)
-        t2 = t2.aliased_type
-      end
-
-      if t1.is_a?(T::Private::Types::TypeAlias)
-        return t1.aliased_type.subtype_of?(t2)
-      end
-
-      # pairs to cover: 1  (_, _)
-      #                 2  (_, And)
-      #                 3  (_, Or)
-      #                 4  (And, _)
-      #                 5  (And, And)
-      #                 6  (And, Or)
-      #                 7  (Or, _)
-      #                 8  (Or, And)
-      #                 9  (Or, Or)
-
-      # Note: order of cases here matters!
-      if t1.is_a?(T::Types::Union) # 7, 8, 9
-        # this will be incorrect if/when we have Type members
-        return t1.types.all? {|t1_member| t1_member.subtype_of?(t2)}
-      end
-
-      if t2.is_a?(T::Types::Intersection) # 2, 5
-        # this will be incorrect if/when we have Type members
-        return t2.types.all? {|t2_member| t1.subtype_of?(t2_member)}
-      end
-
-      if t2.is_a?(T::Types::Union)
-        if t1.is_a?(T::Types::Intersection) # 6
-          # dropping either of parts eagerly make subtype test be too strict.
-          # we have to try both cases, when we normally try only one
-          return t2.types.any? {|t2_member| t1.subtype_of?(t2_member)} ||
-              t1.types.any? {|t1_member| t1_member.subtype_of?(t2)}
-        end
-        return t2.types.any? {|t2_member| t1.subtype_of?(t2_member)} # 3
-      end
-
-      if t1.is_a?(T::Types::Intersection) # 4
-        # this will be incorrect if/when we have Type members
-        return t1.types.any? {|t1_member| t1_member.subtype_of?(t2)}
-      end
-
-      # 1; Start with some special cases
-      if t1.is_a?(T::Private::Types::Void)
-        return t2.is_a?(T::Private::Types::Void)
-      end
-
-      if t1.is_a?(T::Types::Untyped) || t2.is_a?(T::Types::Untyped)
-        return true
-      end
-
-      # Rest of (1)
-      subtype_of_single?(t2)
-    end
-
-    def to_s
-      name
-    end
-
-    def describe_obj(obj)
-      # Would be redundant to print class and value in these common cases.
-      case obj
-      when nil, true, false
-        return "type #{obj.class}"
-      end
-
-      # In rare cases, obj.inspect may fail, or be undefined, so rescue.
-      begin
-        # Default inspect behavior of, eg; `#<Object:0x0...>` is ugly; just print the hash instead, which is more concise/readable.
-        if obj.method(:inspect).owner == Kernel
-          "type #{obj.class} with hash #{obj.hash}"
-        elsif T::Configuration.include_value_in_type_errors?
-          "type #{obj.class} with value #{T::Utils.string_truncate_middle(obj.inspect, 30, 30)}"
-        else
-          "type #{obj.class}"
-        end
-      rescue StandardError, SystemStackError
-        "type #{obj.class} with unprintable value"
-      end
-    end
-
-    def error_message_for_obj(obj)
-      if valid?(obj)
-        nil
-      else
-        error_message(obj)
-      end
-    end
-
-    def error_message_for_obj_recursive(obj)
-      if recursively_valid?(obj)
-        nil
-      else
-        error_message(obj)
-      end
-    end
-
-    private def error_message(obj)
-      "Expected type #{self.name}, got #{describe_obj(obj)}"
-    end
-
-    def validate!(obj)
-      err = error_message_for_obj(obj)
-      raise TypeError.new(err) if err
-    end
-
-    ### Equality methods (necessary for deduping types with `uniq`)
-
-    def hash
-      name.hash
-    end
-
-    # Type equivalence, defined by serializing the type to a string (with
-    # `#name`) and comparing the resulting strings for equality.
-    def ==(other)
-      (T::Utils.resolve_alias(other).class == T::Utils.resolve_alias(self).class) &&
-        other.name == self.name
-    end
-
-    alias_method :eql?, :==
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/class_of.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/class_of.rb
deleted file mode 100644
index d56f21d4c7939..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/class_of.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Types
-  # Validates that an object belongs to the specified class.
-  class ClassOf < Base
-    attr_reader :type
-
-    def initialize(type)
-      @type = type
-    end
-
-    # overrides Base
-    def name
-      "T.class_of(#{@type})"
-    end
-
-    # overrides Base
-    def valid?(obj)
-      obj.is_a?(Module) && obj <= @type
-    end
-
-    # overrides Base
-    def subtype_of_single?(other)
-      case other
-      when ClassOf
-        @type <= other.type
-      when Simple
-        @type.is_a?(other.raw_type)
-      else
-        false
-      end
-    end
-
-    # overrides Base
-    def describe_obj(obj)
-      obj.inspect
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/enum.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/enum.rb
deleted file mode 100644
index 97ecfe0c0c43a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/enum.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Types
-  # validates that the provided value is within a given set/enum
-  class Enum < Base
-    extend T::Sig
-
-    attr_reader :values
-
-    def initialize(values)
-      @values = values
-    end
-
-    # overrides Base
-    def valid?(obj)
-      @values.member?(obj)
-    end
-
-    # overrides Base
-    private def subtype_of_single?(other)
-      case other
-      when Enum
-        (other.values - @values).empty?
-      else
-        false
-      end
-    end
-
-    # overrides Base
-    def name
-      "T.deprecated_enum([#{@values.map(&:inspect).join(', ')}])"
-    end
-
-    # overrides Base
-    def describe_obj(obj)
-      obj.inspect
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/fixed_array.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/fixed_array.rb
deleted file mode 100644
index 3bed082bcc996..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/fixed_array.rb
+++ /dev/null
@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-# https://jira.corp.stripe.com/browse/RUBYPLAT-1107
-# typed: false
-
-module T::Types
-  # Takes a list of types. Validates each item in an array using the type in the same position
-  # in the list.
-  class FixedArray < Base
-    attr_reader :types
-
-    def initialize(types)
-      @types = types.map {|type| T::Utils.coerce(type)}
-    end
-
-    # overrides Base
-    def name
-      "[#{@types.join(', ')}]"
-    end
-
-    # overrides Base
-    def recursively_valid?(obj)
-      if obj.is_a?(Array) && obj.length == @types.length
-        i = 0
-        while i < @types.length
-          if !@types[i].recursively_valid?(obj[i])
-            return false
-          end
-          i += 1
-        end
-        true
-      else
-        false
-      end
-    end
-
-    # overrides Base
-    def valid?(obj)
-      if obj.is_a?(Array) && obj.length == @types.length
-        i = 0
-        while i < @types.length
-          if !@types[i].valid?(obj[i])
-            return false
-          end
-          i += 1
-        end
-        true
-      else
-        false
-      end
-    end
-
-    # overrides Base
-    private def subtype_of_single?(other)
-      case other
-      when FixedArray
-        # Properly speaking, covariance here is unsound since arrays
-        # can be mutated, but sorbet implements covariant tuples for
-        # ease of adoption.
-        @types.size == other.types.size && @types.zip(other.types).all? do |t1, t2|
-          t1.subtype_of?(t2)
-        end
-      else
-        false
-      end
-    end
-
-    # This gives us better errors, e.g.:
-    # "Expected [String, Symbol], got [String, String]"
-    # instead of
-    # "Expected [String, Symbol], got Array".
-    #
-    # overrides Base
-    def describe_obj(obj)
-      if obj.is_a?(Array)
-        if obj.length == @types.length
-          item_classes = obj.map(&:class).join(', ')
-          "type [#{item_classes}]"
-        else
-          "array of size #{obj.length}"
-        end
-      else
-        super
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/fixed_hash.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/fixed_hash.rb
deleted file mode 100644
index d8fddb3703b89..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/fixed_hash.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Types
-  # Takes a hash of types. Validates each item in a hash using the type in the same position
-  # in the list.
-  class FixedHash < Base
-    attr_reader :types
-
-    def initialize(types)
-      @types = types.transform_values {|v| T::Utils.coerce(v)}
-    end
-
-    # overrides Base
-    def name
-      serialize_hash(@types)
-    end
-
-    # overrides Base
-    def recursively_valid?(obj)
-      return false unless obj.is_a?(Hash)
-      return false if @types.any? {|key, type| !type.recursively_valid?(obj[key])}
-      return false if obj.any? {|key, _| !@types[key]}
-      true
-    end
-
-    # overrides Base
-    def valid?(obj)
-      return false unless obj.is_a?(Hash)
-      return false if @types.any? {|key, type| !type.valid?(obj[key])}
-      return false if obj.any? {|key, _| !@types[key]}
-      true
-    end
-
-    # overrides Base
-    private def subtype_of_single?(other)
-      case other
-      when FixedHash
-        # Using `subtype_of?` here instead of == would be unsound
-        @types == other.types
-      else
-        false
-      end
-    end
-
-    # This gives us better errors, e.g.:
-    # `Expected {a: String}, got {a: TrueClass}`
-    # instead of
-    # `Expected {a: String}, got Hash`.
-    #
-    # overrides Base
-    def describe_obj(obj)
-      if obj.is_a?(Hash)
-        "type #{serialize_hash(obj.transform_values(&:class))}"
-      else
-        super
-      end
-    end
-
-    private
-
-    def serialize_hash(hash)
-      entries = hash.map do |(k, v)|
-        if Symbol === k && ":#{k}" == k.inspect
-          "#{k}: #{v}"
-        else
-          "#{k.inspect} => #{v}"
-        end
-      end
-
-      "{#{entries.join(', ')}}"
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/intersection.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/intersection.rb
deleted file mode 100644
index 8e4b42f187a4c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/intersection.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Types
-  # Takes a list of types. Validates that an object matches all of the types.
-  class Intersection < Base
-    attr_reader :types
-
-    def initialize(types)
-      @types = types.flat_map do |type|
-        type = T::Utils.resolve_alias(type)
-        if type.is_a?(Intersection)
-          # Simplify nested intersections (mostly so `name` returns a nicer value)
-          type.types
-        else
-          T::Utils.coerce(type)
-        end
-      end.uniq
-    end
-
-    # overrides Base
-    def name
-      "T.all(#{@types.map(&:name).sort.join(', ')})"
-    end
-
-    # overrides Base
-    def recursively_valid?(obj)
-      @types.all? {|type| type.recursively_valid?(obj)}
-    end
-
-    # overrides Base
-    def valid?(obj)
-      @types.all? {|type| type.valid?(obj)}
-    end
-
-    # overrides Base
-    private def subtype_of_single?(other)
-      raise "This should never be reached if you're going through `subtype_of?` (and you should be)"
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/proc.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/proc.rb
deleted file mode 100644
index aece6a3a2f058..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/proc.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Types
-  # Defines the type of a proc (a ruby callable). At runtime, only
-  # validates that the value is a `::Proc`.
-  #
-  # At present, we only support fixed-arity procs with no optional or
-  # keyword arguments.
-  class Proc < Base
-    attr_reader :arg_types
-    attr_reader :returns
-
-    def initialize(arg_types, returns)
-      @arg_types = {}
-      arg_types.each do |key, raw_type|
-        @arg_types[key] = T::Utils.coerce(raw_type)
-      end
-      @returns = T::Utils.coerce(returns)
-    end
-
-    # overrides Base
-    def name
-      args = []
-      @arg_types.each do |k, v|
-        args << "#{k}: #{v.name}"
-      end
-      "T.proc.params(#{args.join(', ')}).returns(#{returns})"
-    end
-
-    # overrides Base
-    def valid?(obj)
-      obj.is_a?(::Proc)
-    end
-
-    # overrides Base
-    private def subtype_of_single?(other)
-      case other
-      when self.class
-        if arg_types.size != other.arg_types.size
-          return false
-        end
-        arg_types.values.zip(other.arg_types.values).all? do |a, b|
-          b.subtype_of?(a)
-        end && returns.subtype_of?(other.returns)
-      else
-        false
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/simple.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/simple.rb
deleted file mode 100644
index 2789adbb67cdf..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/simple.rb
+++ /dev/null
@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Types
-  # Validates that an object belongs to the specified class.
-  class Simple < Base
-    attr_reader :raw_type
-
-    def initialize(raw_type)
-      @raw_type = raw_type
-    end
-
-    # overrides Base
-    def name
-      # Memoize to mitigate pathological performance with anonymous modules (https://bugs.ruby-lang.org/issues/11119)
-      #
-      # `name` isn't normally a hot path for types, but it is used in initializing a T::Types::Union,
-      # and so in `T.nilable`, and so in runtime constructions like `x = T.let(nil, T.nilable(Integer))`.
-      @name ||= @raw_type.name.freeze
-    end
-
-    # overrides Base
-    def valid?(obj)
-      obj.is_a?(@raw_type)
-    end
-
-    # overrides Base
-    private def subtype_of_single?(other)
-      case other
-      when Simple
-        @raw_type <= other.raw_type
-      else
-        false
-      end
-    end
-
-    # overrides Base
-    private def error_message(obj)
-      error_message = super(obj)
-      actual_name = obj.class.name
-
-      return error_message unless name == actual_name
-
-      <<~MSG.strip
-        #{error_message}
-
-        The expected type and received object type have the same name but refer to different constants.
-        Expected type is #{name} with object id #{@raw_type.__id__}, but received type is #{actual_name} with object id #{obj.class.__id__}.
-
-        There might be a constant reloading problem in your application.
-      MSG
-    end
-
-    def to_nilable
-      @nilable ||= T::Types::Union.new([self, T::Utils::Nilable::NIL_TYPE])
-    end
-
-    module Private
-      module Pool
-        @cache = ObjectSpace::WeakMap.new
-
-        def self.type_for_module(mod)
-          cached = @cache[mod]
-          return cached if cached
-
-          type = if mod == ::Array
-            T::Array[T.untyped]
-          elsif mod == ::Hash
-            T::Hash[T.untyped, T.untyped]
-          elsif mod == ::Enumerable
-            T::Enumerable[T.untyped]
-          elsif mod == ::Enumerator
-            T::Enumerator[T.untyped]
-          elsif mod == ::Range
-            T::Range[T.untyped]
-          elsif !Object.autoload?(:Set) && Object.const_defined?(:Set) && mod == ::Set
-            T::Set[T.untyped]
-          else
-            Simple.new(mod)
-          end
-
-          # Unfortunately, we still need to check if the module is frozen,
-          # since WeakMap adds a finalizer to the key that is added
-          # to the map, so that it can clear the map entry when the key is
-          # garbage collected.
-          # For a frozen object, though, adding a finalizer is not a valid
-          # operation, so this still raises if `mod` is frozen.
-          @cache[mod] = type unless mod.frozen?
-          type
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/type_parameter.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/type_parameter.rb
deleted file mode 100644
index ea82a07cc3a05..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/type_parameter.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Types
-  class TypeParameter < Base
-    def initialize(name)
-      raise ArgumentError.new("not a symbol: #{name}") unless name.is_a?(Symbol)
-      @name = name
-    end
-
-    def valid?(obj)
-      true
-    end
-
-    def subtype_of_single?(type)
-      true
-    end
-
-    def name
-      "T.type_parameter(:#{@name})"
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_array.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_array.rb
deleted file mode 100644
index 0b5f3541a934e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_array.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Types
-  class TypedArray < TypedEnumerable
-    # overrides Base
-    def name
-      "T::Array[#{@type.name}]"
-    end
-
-    def underlying_class
-      Array
-    end
-
-    # overrides Base
-    def recursively_valid?(obj)
-      obj.is_a?(Array) && super
-    end
-
-    # overrides Base
-    def valid?(obj)
-      obj.is_a?(Array)
-    end
-
-    def new(*args)
-      Array.new(*T.unsafe(args))
-    end
-
-    class Untyped < TypedArray
-      def initialize
-        super(T.untyped)
-      end
-
-      def valid?(obj)
-        obj.is_a?(Array)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_hash.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_hash.rb
deleted file mode 100644
index f48e0c1595a21..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_hash.rb
+++ /dev/null
@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Types
-  class TypedHash < TypedEnumerable
-    # Technically we don't need these, but they are a nice api
-    attr_reader :keys, :values
-
-    def underlying_class
-      Hash
-    end
-
-    def initialize(keys:, values:)
-      @keys = T::Utils.coerce(keys)
-      @values = T::Utils.coerce(values)
-      @type = T::Utils.coerce([keys, values])
-    end
-
-    # overrides Base
-    def name
-      "T::Hash[#{@keys.name}, #{@values.name}]"
-    end
-
-    # overrides Base
-    def recursively_valid?(obj)
-      obj.is_a?(Hash) && super
-    end
-
-    # overrides Base
-    def valid?(obj)
-      obj.is_a?(Hash)
-    end
-
-    def new(*args, &blk)
-      Hash.new(*T.unsafe(args), &blk)
-    end
-
-    class Untyped < TypedHash
-      def initialize
-        super(keys: T.untyped, values: T.untyped)
-      end
-
-      def valid?(obj)
-        obj.is_a?(Hash)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/union.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/union.rb
deleted file mode 100644
index 3729dc48de681..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/union.rb
+++ /dev/null
@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Types
-  # Takes a list of types. Validates that an object matches at least one of the types.
-  class Union < Base
-    attr_reader :types
-
-    def initialize(types)
-      @types = types.flat_map do |type|
-        type = T::Utils.coerce(type)
-        if type.is_a?(Union)
-          # Simplify nested unions (mostly so `name` returns a nicer value)
-          type.types
-        else
-          type
-        end
-      end.uniq
-    end
-
-    # overrides Base
-    def name
-      type_shortcuts(@types)
-    end
-
-    private def type_shortcuts(types)
-      if types.size == 1
-        return types[0].name
-      end
-      nilable = T::Utils.coerce(NilClass)
-      trueclass = T::Utils.coerce(TrueClass)
-      falseclass = T::Utils.coerce(FalseClass)
-      if types.any? {|t| t == nilable}
-        remaining_types = types.reject {|t| t == nilable}
-        "T.nilable(#{type_shortcuts(remaining_types)})"
-      elsif types.any? {|t| t == trueclass} && types.any? {|t| t == falseclass}
-        remaining_types = types.reject {|t| t == trueclass || t == falseclass}
-        type_shortcuts([T::Private::Types::StringHolder.new("T::Boolean")] + remaining_types)
-      else
-        names = types.map(&:name).compact.sort
-        "T.any(#{names.join(', ')})"
-      end
-    end
-
-    # overrides Base
-    def recursively_valid?(obj)
-      @types.any? {|type| type.recursively_valid?(obj)}
-    end
-
-    # overrides Base
-    def valid?(obj)
-      @types.any? {|type| type.valid?(obj)}
-    end
-
-    # overrides Base
-    private def subtype_of_single?(other)
-      raise "This should never be reached if you're going through `subtype_of?` (and you should be)"
-    end
-
-    module Private
-      module Pool
-        EMPTY_ARRAY = [].freeze
-        private_constant :EMPTY_ARRAY
-
-        # @param type_a [T::Types::Base]
-        # @param type_b [T::Types::Base]
-        # @param types [Array] optional array of additional T::Types::Base instances
-        def self.union_of_types(type_a, type_b, types=EMPTY_ARRAY)
-          if types.empty?
-            # We aren't guaranteed to detect a simple `T.nilable(<Module>)` type here
-            # in cases where there are duplicate types, nested unions, etc.
-            #
-            # That's ok, because this is an optimization which isn't necessary for
-            # correctness.
-            if type_b == T::Utils::Nilable::NIL_TYPE && type_a.is_a?(T::Types::Simple)
-              type_a.to_nilable
-            elsif type_a == T::Utils::Nilable::NIL_TYPE && type_b.is_a?(T::Types::Simple)
-              type_b.to_nilable
-            else
-              Union.new([type_a, type_b])
-            end
-          else
-            # This can't be a `T.nilable(<Module>)` case unless there are duplicates,
-            # which is possible but unexpected.
-            Union.new([type_a, type_b] + types)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/utils.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/utils.rb
deleted file mode 100644
index 7897eaa38f772..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/utils.rb
+++ /dev/null
@@ -1,209 +0,0 @@
-# frozen_string_literal: true
-# typed: true
-
-module T::Utils
-  # Used to convert from a type specification to a `T::Types::Base`.
-  def self.coerce(val)
-    if val.is_a?(T::Private::Types::TypeAlias)
-      val.aliased_type
-    elsif val.is_a?(T::Types::Base)
-      val
-    elsif val.is_a?(Module)
-      T::Types::Simple::Private::Pool.type_for_module(val)
-    elsif val.is_a?(::Array)
-      T::Types::FixedArray.new(val)
-    elsif val.is_a?(::Hash)
-      T::Types::FixedHash.new(val)
-    elsif val.is_a?(T::Private::Methods::DeclBuilder)
-      T::Private::Methods.finalize_proc(val.decl)
-    elsif val.is_a?(::T::Enum)
-      T::Types::TEnum.new(val)
-    elsif val.is_a?(::String)
-      raise "Invalid String literal for type constraint. Must be an #{T::Types::Base}, a " \
-            "class/module, or an array. Got a String with value `#{val}`."
-    else
-      raise "Invalid value for type constraint. Must be an #{T::Types::Base}, a " \
-            "class/module, or an array. Got a `#{val.class}`."
-    end
-  end
-
-  # Dynamically confirm that `value` is recursively a valid value of
-  # type `type`, including recursively through collections. Note that
-  # in some cases this runtime check can be very expensive, especially
-  # with large collections of objects.
-  def self.check_type_recursive!(value, type)
-    T::Private::Casts.cast_recursive(value, type, cast_method: "T.check_type_recursive!")
-  end
-
-  # Returns the set of all methods (public, protected, private) defined on a module or its
-  # ancestors, excluding Object and its ancestors. Overrides of methods from Object (and its
-  # ancestors) are included.
-  def self.methods_excluding_object(mod)
-    # We can't just do mod.instance_methods - Object.instance_methods, because that would leave out
-    # any methods from Object that are overridden in mod.
-    mod.ancestors.flat_map do |ancestor|
-      # equivalent to checking Object.ancestors.include?(ancestor)
-      next [] if Object <= ancestor
-      ancestor.instance_methods(false) + ancestor.private_instance_methods(false)
-    end.uniq
-  end
-
-  # Returns the signature for the `UnboundMethod`, or nil if it's not sig'd
-  #
-  # @example T::Utils.signature_for_method(x.method(:foo))
-  def self.signature_for_method(method)
-    T::Private::Methods.signature_for_method(method)
-  end
-
-  # Returns the signature for the instance method on the supplied module, or nil if it's not found or not typed.
-  #
-  # @example T::Utils.signature_for_instance_method(MyClass, :my_method)
-  def self.signature_for_instance_method(mod, method_name)
-    T::Private::Methods.signature_for_method(mod.instance_method(method_name))
-  end
-
-  def self.wrap_method_with_call_validation_if_needed(mod, method_sig, original_method)
-    T::Private::Methods::CallValidation.wrap_method_if_needed(mod, method_sig, original_method)
-  end
-
-  # Unwraps all the sigs.
-  def self.run_all_sig_blocks
-    T::Private::Methods.run_all_sig_blocks
-  end
-
-  # Return the underlying type for a type alias. Otherwise returns type.
-  def self.resolve_alias(type)
-    case type
-    when T::Private::Types::TypeAlias
-      type.aliased_type
-    else
-      type
-    end
-  end
-
-  # Give a type which is a subclass of T::Types::Base, determines if the type is a simple nilable type (union of NilClass and something else).
-  # If so, returns the T::Types::Base of the something else. Otherwise, returns nil.
-  def self.unwrap_nilable(type)
-    case type
-    when T::Types::Union
-      non_nil_types = type.types.reject {|t| t == Nilable::NIL_TYPE}
-      return nil if type.types.length == non_nil_types.length
-      case non_nil_types.length
-      when 0 then nil
-      when 1 then non_nil_types.first
-      else
-        T::Types::Union::Private::Pool.union_of_types(non_nil_types[0], non_nil_types[1], non_nil_types[2..-1])
-      end
-    else
-      nil
-    end
-  end
-
-  # Returns the arity of a method, unwrapping the sig if needed
-  def self.arity(method)
-    arity = method.arity
-    return arity if arity != -1 || method.is_a?(Proc)
-    sig = T::Private::Methods.signature_for_method(method)
-    sig ? sig.method.arity : arity
-  end
-
-  # Elide the middle of a string as needed and replace it with an ellipsis.
-  # Keep the given number of characters at the start and end of the string.
-  #
-  # This method operates on string length, not byte length.
-  #
-  # If the string is shorter than the requested truncation length, return it
-  # without adding an ellipsis. This method may return a longer string than
-  # the original if the characters removed are shorter than the ellipsis.
-  #
-  # @param [String] str
-  #
-  # @param [Fixnum] start_len The length of string before the ellipsis
-  # @param [Fixnum] end_len The length of string after the ellipsis
-  #
-  # @param [String] ellipsis The string to add in place of the elided text
-  #
-  # @return [String]
-  #
-  def self.string_truncate_middle(str, start_len, end_len, ellipsis='...')
-    return unless str
-
-    raise ArgumentError.new('must provide start_len') unless start_len
-    raise ArgumentError.new('must provide end_len') unless end_len
-
-    raise ArgumentError.new('start_len must be >= 0') if start_len < 0
-    raise ArgumentError.new('end_len must be >= 0') if end_len < 0
-
-    str = str.to_s
-    return str if str.length <= start_len + end_len
-
-    start_part = str[0...start_len - ellipsis.length]
-    end_part = end_len == 0 ? '' : str[-end_len..-1]
-
-    "#{start_part}#{ellipsis}#{end_part}"
-  end
-
-  def self.lift_enum(enum)
-    unless enum.is_a?(T::Types::Enum)
-      raise ArgumentError.new("#{enum.inspect} is not a T.deprecated_enum")
-    end
-
-    classes = enum.values.map(&:class).uniq
-    if classes.empty?
-      T.untyped
-    elsif classes.length > 1
-      T::Types::Union.new(classes)
-    else
-      T::Types::Simple::Private::Pool.type_for_module(classes.first)
-    end
-  end
-
-  module Nilable
-    # :is_union_type, T::Boolean: whether the type is an T::Types::Union type
-    # :non_nilable_type, Class: if it is an T.nilable type, the corresponding underlying type; otherwise, nil.
-    TypeInfo = Struct.new(:is_union_type, :non_nilable_type)
-
-    NIL_TYPE = T::Utils.coerce(NilClass)
-
-    def self.get_type_info(prop_type)
-      if prop_type.is_a?(T::Types::Union)
-        non_nilable_type = T::Utils.unwrap_nilable(prop_type)
-        if non_nilable_type&.is_a?(T::Types::Simple)
-          non_nilable_type = non_nilable_type.raw_type
-        end
-        TypeInfo.new(true, non_nilable_type)
-      else
-        TypeInfo.new(false, nil)
-      end
-    end
-
-    # Get the underlying type inside prop_type:
-    #  - if the type is A, the function returns A
-    #  - if the type is T.nilable(A), the function returns A
-    def self.get_underlying_type(prop_type)
-      type_info = get_type_info(prop_type)
-      if type_info.is_union_type
-        type_info.non_nilable_type || prop_type
-      elsif prop_type.is_a?(T::Types::Simple)
-        prop_type.raw_type
-      else
-        prop_type
-      end
-    end
-
-    # The difference between this function and the above function is that the Sorbet type, like T::Types::Simple
-    # is preserved.
-    def self.get_underlying_type_object(prop_type)
-      T::Utils.unwrap_nilable(prop_type) || prop_type
-    end
-
-    def self.is_union_with_nilclass(prop_type)
-      case prop_type
-      when T::Types::Union
-        prop_type.types.include?(NIL_TYPE)
-      else
-        false
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo.rb
deleted file mode 100644
index b1b53449258da..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo.rb
+++ /dev/null
@@ -1,85 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-# The top level module for TZInfo.
-module TZInfo
-  class << self
-    # Instructs the current {DataSource} to load all timezone and country data
-    # into memory (initializing the {DataSource} first if not previously
-    # accessed or set).
-    #
-    # This may be desirable in production environments to improve copy-on-write
-    # performance and to avoid flushing the constant cache every time a new
-    # timezone or country is loaded from {DataSources::RubyDataSource}.
-    def eager_load!
-      DataSource.get.eager_load!
-    end
-  end
-end
-
-# Object#untaint is a deprecated no-op in Ruby >= 2.7 and will be removed in
-# 3.2. Add a refinement to either silence the warning, or supply the method if
-# needed.
-if !Object.new.respond_to?(:untaint) || RUBY_VERSION =~ /\A(\d+)\.(\d+)(?:\.|\z)/ && ($1 == '2' && $2.to_i >= 7 || $1.to_i >= 3)
-  require_relative 'tzinfo/untaint_ext'
-end
-
-require_relative 'tzinfo/version'
-
-require_relative 'tzinfo/string_deduper'
-
-require_relative 'tzinfo/timestamp'
-
-require_relative 'tzinfo/with_offset'
-require_relative 'tzinfo/datetime_with_offset'
-require_relative 'tzinfo/time_with_offset'
-require_relative 'tzinfo/timestamp_with_offset'
-
-require_relative 'tzinfo/timezone_offset'
-require_relative 'tzinfo/timezone_transition'
-require_relative 'tzinfo/transition_rule'
-require_relative 'tzinfo/annual_rules'
-
-require_relative 'tzinfo/data_sources'
-require_relative 'tzinfo/data_sources/timezone_info'
-require_relative 'tzinfo/data_sources/data_timezone_info'
-require_relative 'tzinfo/data_sources/linked_timezone_info'
-require_relative 'tzinfo/data_sources/constant_offset_data_timezone_info'
-require_relative 'tzinfo/data_sources/transitions_data_timezone_info'
-
-require_relative 'tzinfo/data_sources/country_info'
-
-require_relative 'tzinfo/data_sources/posix_time_zone_parser'
-require_relative 'tzinfo/data_sources/zoneinfo_reader'
-
-require_relative 'tzinfo/data_source'
-require_relative 'tzinfo/data_sources/ruby_data_source'
-require_relative 'tzinfo/data_sources/zoneinfo_data_source'
-
-require_relative 'tzinfo/timezone_period'
-require_relative 'tzinfo/offset_timezone_period'
-require_relative 'tzinfo/transitions_timezone_period'
-require_relative 'tzinfo/timezone'
-require_relative 'tzinfo/info_timezone'
-require_relative 'tzinfo/data_timezone'
-require_relative 'tzinfo/linked_timezone'
-require_relative 'tzinfo/timezone_proxy'
-
-require_relative 'tzinfo/country'
-require_relative 'tzinfo/country_timezone'
-
-require_relative 'tzinfo/format2'
-require_relative 'tzinfo/format2/country_definer'
-require_relative 'tzinfo/format2/country_index_definer'
-require_relative 'tzinfo/format2/country_index_definition'
-require_relative 'tzinfo/format2/timezone_definer'
-require_relative 'tzinfo/format2/timezone_definition'
-require_relative 'tzinfo/format2/timezone_index_definer'
-require_relative 'tzinfo/format2/timezone_index_definition'
-
-require_relative 'tzinfo/format1'
-require_relative 'tzinfo/format1/country_definer'
-require_relative 'tzinfo/format1/country_index_definition'
-require_relative 'tzinfo/format1/timezone_definer'
-require_relative 'tzinfo/format1/timezone_definition'
-require_relative 'tzinfo/format1/timezone_index_definition'
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/annual_rules.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/annual_rules.rb
deleted file mode 100644
index c73e38b6a8906..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/annual_rules.rb
+++ /dev/null
@@ -1,71 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # A set of rules that define when transitions occur in time zones with
-  # annually occurring daylight savings time.
-  #
-  # @private
-  class AnnualRules #:nodoc:
-    # @return [TimezoneOffset] the standard offset that applies when daylight
-    #   savings time is not in force.
-    attr_reader :std_offset
-
-    # @return [TimezoneOffset] the offset that applies when daylight savings
-    #   time is in force.
-    attr_reader :dst_offset
-
-    # @return [TransitionRule] the rule that determines when daylight savings
-    #   time starts.
-    attr_reader :dst_start_rule
-
-    # @return [TransitionRule] the rule that determines when daylight savings
-    #   time ends.
-    attr_reader :dst_end_rule
-
-    # Initializes a new {AnnualRules} instance.
-    #
-    # @param std_offset [TimezoneOffset] the standard offset that applies when
-    #   daylight savings time is not in force.
-    # @param dst_offset [TimezoneOffset] the offset that applies when daylight
-    #   savings time is in force.
-    # @param dst_start_rule [TransitionRule] the rule that determines when
-    #   daylight savings time starts.
-    # @param dst_end_rule [TransitionRule] the rule that determines when daylight
-    #   savings time ends.
-    def initialize(std_offset, dst_offset, dst_start_rule, dst_end_rule)
-      @std_offset = std_offset
-      @dst_offset = dst_offset
-      @dst_start_rule = dst_start_rule
-      @dst_end_rule = dst_end_rule
-    end
-
-    # Returns the transitions between standard and daylight savings time for a
-    # given year. The results are ordered by time of occurrence (earliest to
-    # latest).
-    #
-    # @param year [Integer] the year to calculate transitions for.
-    # @return [Array<TimezoneTransition>] the transitions for the year.
-    def transitions(year)
-      start_dst = apply_rule(@dst_start_rule, @std_offset, @dst_offset, year)
-      end_dst = apply_rule(@dst_end_rule, @dst_offset, @std_offset, year)
-
-      end_dst.timestamp_value < start_dst.timestamp_value ? [end_dst, start_dst] : [start_dst, end_dst]
-    end
-
-    private
-
-    # Applies a given rule between offsets on a year.
-    #
-    # @param rule [TransitionRule] the rule to apply.
-    # @param from_offset [TimezoneOffset] the offset the rule transitions from.
-    # @param to_offset [TimezoneOffset] the offset the rule transitions to.
-    # @param year [Integer] the year when the transition occurs.
-    # @return [TimezoneTransition] the transition determined by the rule.
-    def apply_rule(rule, from_offset, to_offset, year)
-      at = rule.at(from_offset, year)
-      TimezoneTransition.new(to_offset, from_offset, at.value)
-    end
-  end
-  private_constant :AnnualRules
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/country.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/country.rb
deleted file mode 100644
index 1bd216afd434f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/country.rb
+++ /dev/null
@@ -1,208 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # {InvalidCountryCode} is raised by {Country#get} if the code given is not a
-  # valid ISO 3166-1 alpha-2 code.
-  class InvalidCountryCode < StandardError
-  end
-
-  # The {Country} class represents an ISO 3166-1 country. It can be used to
-  # obtain a list of time zones observed by a country. For example:
-  #
-  #     united_states = Country.get('US')
-  #     united_states.zone_identifiers
-  #     united_states.zones
-  #     united_states.zone_info
-  #
-  # The {Country} class is thread-safe. It is safe to use class and instance
-  # methods of {Country} in concurrently executing threads. Instances of
-  # {Country} can be shared across thread boundaries.
-  #
-  # Country information available through TZInfo is intended as an aid for
-  # users, to help them select time zone data appropriate for their practical
-  # needs. It is not intended to take or endorse any position on legal or
-  # territorial claims.
-  class Country
-    include Comparable
-
-    class << self
-      # Gets a {Country} by its ISO 3166-1 alpha-2 code.
-      #
-      # The {Country.all_codes} method can be used to obtain a list of valid ISO
-      # 3166-1 alpha-2 codes.
-      #
-      # @param code [String] An ISO 3166-1 alpha-2 code.
-      # @return [Country] a {Country} instance representing the ISO-3166-1
-      #   country identified by the `code` parameter.
-      # @raise [InvalidCountryCode] If {code} is not a valid ISO 3166-1 alpha-2
-      #   code it couldn't be found.
-      def get(code)
-        Country.new(data_source.get_country_info(code))
-      end
-
-      # @return [Array<String>] an `Array` containing all the valid ISO 3166-1
-      #   alpha-2 country codes.
-      def all_codes
-        data_source.country_codes
-      end
-
-      # @return [Array<Country>] an `Array` containing one {Country} instance
-      #   for each defined country.
-      def all
-        data_source.country_codes.collect {|code| get(code)}
-      end
-
-      private
-
-      # @return [DataSource] the current DataSource.
-      def data_source
-        DataSource.get
-      end
-    end
-
-    # Initializes a new {Country} based upon a {DataSources::CountryInfo}
-    # instance.
-    #
-    # {Country} instances should not normally be constructed directly. Use
-    # the {Country.get} method to obtain instances instead.
-    #
-    # @param info [DataSources::CountryInfo] the data to base the new {Country}
-    #   instance upon.
-    def initialize(info)
-      @info = info
-    end
-
-    # @return [String] the ISO 3166-1 alpha-2 country code.
-    def code
-      @info.code
-    end
-
-    # @return [String] the name of the country.
-    def name
-      @info.name
-    end
-
-    # @return [String] a `String` representation of this {Country} (the name of
-    #   the country).
-    def to_s
-      name
-    end
-
-    # @return [String] the internal object state as a programmer-readable
-    #   `String`.
-    def inspect
-      "#<#{self.class}: #{@info.code}>"
-    end
-
-    # Returns an `Array` containing the identifier for each time zone observed
-    # by the country. These are in an order that
-    #
-    # 1. makes some geographical sense, and
-    # 2. puts the most populous zones first, where that does not contradict 1.
-    #
-    # Returned zone identifiers may refer to cities and regions outside of the
-    # country. This will occur if the zone covers multiple countries. Any zones
-    # referring to a city or region in a different country will be listed after
-    # those relating to this country.
-    #
-    # @return [Array<String>] an `Array` containing the identifier for each time
-    #   zone observed by the country
-    def zone_identifiers
-      zone_info.map(&:identifier)
-    end
-    alias zone_names zone_identifiers
-
-    # Returns An `Array` containing a {Timezone} instance for each time zone
-    # observed by the country. These are in an order that
-    #
-    # 1. makes some geographical sense, and
-    # 2. puts the most populous zones first, where that does not contradict 1.
-    #
-    # The identifiers of the time zones returned may refer to cities and regions
-    # outside of the country. This will occur if the time zone covers multiple
-    # countries. Any zones referring to a city or region in a different country
-    # will be listed after those relating to this country.
-    #
-    # The results are actually instances of {TimezoneProxy} in order to defer
-    # loading of the time zone transition data until it is first needed.
-    #
-    # @return [Array<Timezone>] an `Array` containing a {Timezone} instance for
-    #   each time zone observed by the country.
-    def zones
-      zone_info.map(&:timezone)
-    end
-
-    # Returns a frozen `Array` containing a {CountryTimezone} instance for each
-    # time zone observed by the country. These are in an order that
-    #
-    # 1. makes some geographical sense, and
-    # 2. puts the most populous zones first, where that does not contradict 1.
-    #
-    # The {CountryTimezone} instances can be used to obtain the location and
-    # descriptions of the observed time zones.
-    #
-    # Identifiers and descriptions of the time zones returned may refer to
-    # cities and regions outside of the country. This will occur if the time
-    # zone covers multiple countries. Any zones referring to a city or region in
-    # a different country will be listed after those relating to this country.
-    #
-    # @return [Array<CountryTimezone>] a frozen `Array` containing a
-    #   {CountryTimezone} instance for each time zone observed by the country.
-    def zone_info
-      @info.zones
-    end
-
-    # Compares this {Country} with another based on their {code}.
-    #
-    # @param c [Object] an `Object` to compare this {Country} with.
-    # @return [Integer] -1 if `c` is less than `self`, 0 if `c` is equal to
-    #   `self` and +1 if `c` is greater than `self`, or `nil` if `c` is not an
-    #   instance of {Country}.
-    def <=>(c)
-      return nil unless c.is_a?(Country)
-      code <=> c.code
-    end
-
-    # @param c [Object] an `Object` to compare this {Country} with.
-    # @return [Boolean] `true` if `c` is an instance of {Country} and has the
-    #   same code as `self`, otherwise `false`.
-    def eql?(c)
-      self == c
-    end
-
-    # @return [Integer] a hash based on the {code}.
-    def hash
-      code.hash
-    end
-
-    # Matches `regexp` against the {code} of this {Country}.
-    #
-    # @param regexp [Regexp] a `Regexp` to match against the {code} of
-    #   this {Country}.
-    # @return [Integer] the position the match starts, or `nil` if there is no
-    #   match.
-    def =~(regexp)
-      regexp =~ code
-    end
-
-    # Returns a serialized representation of this {Country}. This method is
-    # called when using `Marshal.dump` with an instance of {Country}.
-    #
-    # @param limit [Integer] the maximum depth to dump - ignored.
-    # @return [String] a serialized representation of this {Country}.
-    def _dump(limit)
-      code
-    end
-
-    # Loads a {Country} from the serialized representation returned by {_dump}.
-    # This is method is called when using `Marshal.load` or `Marshal.restore`
-    # to restore a serialized {Country}.
-    #
-    # @param data [String] a serialized representation of a {Country}.
-    # @return [Country] the result of converting `data` back into a {Country}.
-    def self._load(data)
-      Country.get(data)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/country_timezone.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/country_timezone.rb
deleted file mode 100644
index 0def7fe1e82b2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/country_timezone.rb
+++ /dev/null
@@ -1,93 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  # Information about a time zone used by a {Country}.
-  class CountryTimezone
-    # @return [String] the identifier of the {Timezone} being described.
-    attr_reader :identifier
-
-    # The latitude of this time zone in degrees. Positive numbers are degrees
-    # north and negative numbers are degrees south.
-    #
-    # Note that depending on the data source, the position given by {#latitude}
-    # and {#longitude} may not be within the country.
-    #
-    # @return [Rational] the latitude in degrees.
-    attr_reader :latitude
-
-    # The longitude of this time zone in degrees. Positive numbers are degrees
-    # east and negative numbers are degrees west.
-    #
-    # Note that depending on the data source, the position given by {#latitude}
-    # and {#longitude} may not be within the country.
-    #
-    # @return [Rational] the longitude in degrees.
-    attr_reader :longitude
-
-    # A description of this time zone in relation to the country, e.g. "Eastern
-    # Time". This is usually `nil` for countries that have a single time zone.
-    #
-    # @return [String] an optional description of the time zone.
-    attr_reader :description
-
-    # Creates a new {CountryTimezone}.
-    #
-    # The passed in identifier and description instances will be frozen.
-    #
-    # {CountryTimezone} instances should normally only be constructed
-    # by implementations of {DataSource}.
-    #
-    # @param identifier [String] the {Timezone} identifier.
-    # @param latitude [Rational] the latitude of the time zone.
-    # @param longitude [Rational] the longitude of the time zone.
-    # @param description [String] an optional description of the time zone.
-    def initialize(identifier, latitude, longitude, description = nil)
-      @identifier = identifier.freeze
-      @latitude = latitude
-      @longitude = longitude
-      @description = description && description.freeze
-    end
-
-    # Returns the associated {Timezone}.
-    #
-    # The result is actually an instance of {TimezoneProxy} in order to defer
-    # loading of the time zone transition data until it is first needed.
-    #
-    # @return [Timezone] the associated {Timezone}.
-    def timezone
-      Timezone.get_proxy(@identifier)
-    end
-
-    # @return [String] the {description} if present, otherwise a human-readable
-    #   representation of the identifier (using {Timezone#friendly_identifier}).
-    def description_or_friendly_identifier
-      description || timezone.friendly_identifier(true)
-    end
-
-    # Tests if the given object is equal to the current instance (has the same
-    # identifier, latitude, longitude and description).
-    #
-    # @param ct [Object] the object to be compared.
-    # @return [TrueClass] `true` if `ct` is equal to the current instance.
-    def ==(ct)
-      ct.kind_of?(CountryTimezone) &&
-        identifier == ct.identifier  && latitude == ct.latitude &&
-        longitude == ct.longitude   && description == ct.description
-    end
-
-    # Tests if the given object is equal to the current instance (has the same
-    # identifier, latitude, longitude and description).
-    #
-    # @param ct [Object] the object to be compared.
-    # @return [Boolean] `true` if `ct` is equal to the current instance.
-    def eql?(ct)
-      self == ct
-    end
-
-    # @return [Integer] a hash based on the {identifier}, {latitude},
-    # {longitude} and {description}.
-    def hash
-      [@identifier, @latitude, @longitude, @description].hash
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_source.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_source.rb
deleted file mode 100644
index 952b435a15d54..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_source.rb
+++ /dev/null
@@ -1,446 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-require 'concurrent'
-require 'thread'
-
-module TZInfo
-  # {InvalidDataSource} is raised if the selected {DataSource} doesn't implement
-  # one of the required methods.
-  class InvalidDataSource < StandardError
-  end
-
-  # {DataSourceNotFound} is raised if no data source could be found (i.e. if
-  # `'tzinfo/data'` cannot be found on the load path and no valid zoneinfo
-  # directory can be found on the system).
-  class DataSourceNotFound < StandardError
-  end
-
-  # TZInfo can be used with different data sources for time zone and country
-  # data. Each source of data is implemented as a subclass of {DataSource}.
-  #
-  # To choose a data source and override the default selection, use the
-  # {DataSource.set} method.
-  #
-  # @abstract To create a custom data source, create a subclass of {DataSource}
-  #   and implement the {load_timezone_info}, {data_timezone_identifiers},
-  #   {linked_timezone_identifiers}, {load_country_info} and {country_codes}
-  #   methods.
-  class DataSource
-    # The currently selected data source.
-    #
-    # @private
-    @@instance = nil
-
-    # A `Mutex` used to ensure the default data source is only created once.
-    #
-    # @private
-    @@default_mutex = Mutex.new
-
-    class << self
-      # @return [DataSource] the currently selected source of data.
-      def get
-        # If a DataSource hasn't been manually set when the first request is
-        # made to obtain a DataSource, then a default data source is created.
-        #
-        # This is done at the first request rather than when TZInfo is loaded to
-        # avoid unnecessary attempts to find a suitable DataSource.
-        #
-        # A `Mutex` is used to ensure that only a single default instance is
-        # created (this avoiding the possibility of retaining two copies of the
-        # same data in memory).
-
-        unless @@instance
-          @@default_mutex.synchronize do
-            set(create_default_data_source) unless @@instance
-          end
-        end
-
-        @@instance
-      end
-
-      # Sets the currently selected data source for time zone and country data.
-      #
-      # This should usually be set to one of the two standard data source types:
-      #
-      # * `:ruby` - read data from the Ruby modules included in the TZInfo::Data
-      #   library (tzinfo-data gem).
-      # * `:zoneinfo` - read data from the zoneinfo files included with most
-      #   Unix-like operating systems (e.g. in /usr/share/zoneinfo).
-      #
-      # To set TZInfo to use one of the standard data source types, call
-      # `TZInfo::DataSource.set`` in one of the following ways:
-      #
-      #     TZInfo::DataSource.set(:ruby)
-      #     TZInfo::DataSource.set(:zoneinfo)
-      #     TZInfo::DataSource.set(:zoneinfo, zoneinfo_dir)
-      #     TZInfo::DataSource.set(:zoneinfo, zoneinfo_dir, iso3166_tab_file)
-      #
-      # `DataSource.set(:zoneinfo)` will automatically search for the zoneinfo
-      # directory by checking the paths specified in
-      # {DataSources::ZoneinfoDataSource.search_path}.
-      # {DataSources::ZoneinfoDirectoryNotFound} will be raised if no valid
-      # zoneinfo directory could be found.
-      #
-      # `DataSource.set(:zoneinfo, zoneinfo_dir)` uses the specified
-      # `zoneinfo_dir` directory as the data source. If the directory is not a
-      # valid zoneinfo directory, a {DataSources::InvalidZoneinfoDirectory}
-      # exception will be raised.
-      #
-      # `DataSource.set(:zoneinfo, zoneinfo_dir, iso3166_tab_file)` uses the
-      # specified `zoneinfo_dir` directory as the data source, but loads the
-      # `iso3166.tab` file from the path given by `iso3166_tab_file`. If the
-      # directory is not a valid zoneinfo directory, a
-      # {DataSources::InvalidZoneinfoDirectory} exception will be raised.
-      #
-      # Custom data sources can be created by subclassing TZInfo::DataSource and
-      # implementing the following methods:
-      #
-      # * {load_timezone_info}
-      # * {data_timezone_identifiers}
-      # * {linked_timezone_identifiers}
-      # * {load_country_info}
-      # * {country_codes}
-      #
-      # To have TZInfo use the custom data source, call {DataSource.set},
-      # passing an instance of the custom data source implementation as follows:
-      #
-      #     TZInfo::DataSource.set(CustomDataSource.new)
-      #
-      # Calling {DataSource.set} will only affect instances of {Timezone} and
-      # {Country} obtained with {Timezone.get} and {Country.get} subsequent to
-      # the {DataSource.set} call. Existing {Timezone} and {Country} instances
-      # will be unaffected.
-      #
-      # If {DataSource.set} is not called, TZInfo will by default attempt to use
-      # TZInfo::Data as the data source. If TZInfo::Data is not available (i.e.
-      # if `require 'tzinfo/data'` fails), then TZInfo will search for a
-      # zoneinfo directory instead (using the search path specified by
-      # {DataSources::ZoneinfoDataSource.search_path}).
-      #
-      # @param data_source_or_type [Object] either `:ruby`, `:zoneinfo` or an
-      #   instance of a {DataSource}.
-      # @param args [Array<Object>] when `data_source_or_type` is a symbol,
-      #   optional arguments to use when initializing the data source.
-      # @raise [ArgumentError] if `data_source_or_type` is not `:ruby`,
-      #   `:zoneinfo` or an instance of {DataSource}.
-      def set(data_source_or_type, *args)
-        if data_source_or_type.kind_of?(DataSource)
-          @@instance = data_source_or_type
-        elsif data_source_or_type == :ruby
-          @@instance = DataSources::RubyDataSource.new
-        elsif data_source_or_type == :zoneinfo
-          @@instance = DataSources::ZoneinfoDataSource.new(*args)
-        else
-          raise ArgumentError, 'data_source_or_type must be a DataSource instance or a data source type (:ruby or :zoneinfo)'
-        end
-      end
-
-      private
-
-      # Creates a {DataSource} instance for use as the default. Used if no
-      # preference has been specified manually.
-      #
-      # @return [DataSource] the newly created default {DataSource} instance.
-      def create_default_data_source
-        has_tzinfo_data = false
-
-        begin
-          require 'tzinfo/data'
-          has_tzinfo_data = true
-        rescue LoadError
-        end
-
-        return DataSources::RubyDataSource.new if has_tzinfo_data
-
-        begin
-          return DataSources::ZoneinfoDataSource.new
-        rescue DataSources::ZoneinfoDirectoryNotFound
-          raise DataSourceNotFound, "No source of timezone data could be found.\nPlease refer to https://tzinfo.github.io/datasourcenotfound for help resolving this error."
-        end
-      end
-    end
-
-    # Initializes a new {DataSource} instance. Typically only called via
-    # subclasses of {DataSource}.
-    def initialize
-      @timezones = Concurrent::Map.new
-    end
-
-    # Returns a {DataSources::TimezoneInfo} instance for the given identifier.
-    # The result will derive from either {DataSources::DataTimezoneInfo} for
-    # time zones that define their own data or {DataSources::LinkedTimezoneInfo}
-    # for links or aliases to other time zones.
-    #
-    # {get_timezone_info} calls {load_timezone_info} to create the
-    # {DataSources::TimezoneInfo} instance. The returned instance is cached and
-    # returned in subsequent calls to {get_timezone_info} for the identifier.
-    #
-    # @param identifier [String] A time zone identifier.
-    # @return [DataSources::TimezoneInfo] a {DataSources::TimezoneInfo} instance
-    #   for a given identifier.
-    # @raise [InvalidTimezoneIdentifier] if the time zone is not found or the
-    #   identifier is invalid.
-    def get_timezone_info(identifier)
-      result = @timezones[identifier]
-
-      unless result
-        # Thread-safety: It is possible that multiple equivalent TimezoneInfo
-        # instances could be created here in concurrently executing threads. The
-        # consequences of this are that the data may be loaded more than once
-        # (depending on the data source). The performance benefit of ensuring
-        # that only a single instance is created is unlikely to be worth the
-        # overhead of only allowing one TimezoneInfo to be loaded at a time.
-
-        result = load_timezone_info(identifier)
-        @timezones[result.identifier] = result
-      end
-
-      result
-    end
-
-    # @return [Array<String>] a frozen `Array`` of all the available time zone
-    #   identifiers. The identifiers are sorted according to `String#<=>`.
-    def timezone_identifiers
-      # Thread-safety: It is possible that the value of @timezone_identifiers
-      # may be calculated multiple times in concurrently executing threads. It
-      # is not worth the overhead of locking to ensure that
-      # @timezone_identifiers is only calculated once.
-      @timezone_identifiers ||= build_timezone_identifiers
-    end
-
-    # Returns a frozen `Array` of all the available time zone identifiers for
-    # data time zones (i.e. those that actually contain definitions). The
-    # identifiers are sorted according to `String#<=>`.
-    #
-    # @return [Array<String>] a frozen `Array` of all the available time zone
-    #   identifiers for data time zones.
-    def data_timezone_identifiers
-      raise_invalid_data_source('data_timezone_identifiers')
-    end
-
-    # Returns a frozen `Array` of all the available time zone identifiers that
-    # are links to other time zones. The identifiers are sorted according to
-    # `String#<=>`.
-    #
-    # @return [Array<String>] a frozen `Array` of all the available time zone
-    #   identifiers that are links to other time zones.
-    def linked_timezone_identifiers
-      raise_invalid_data_source('linked_timezone_identifiers')
-    end
-
-    # @param code [String] an ISO 3166-1 alpha-2 country code.
-    # @return [DataSources::CountryInfo] a {DataSources::CountryInfo} instance
-    #   for the given ISO 3166-1 alpha-2 country code.
-    # @raise [InvalidCountryCode] if the country could not be found or the code
-    #   is invalid.
-    def get_country_info(code)
-      load_country_info(code)
-    end
-
-    # Returns a frozen `Array` of all the available ISO 3166-1 alpha-2 country
-    # codes. The identifiers are sorted according to `String#<=>`.
-    #
-    # @return [Array<String>] a frozen `Array` of all the available ISO 3166-1
-    #   alpha-2 country codes.
-    def country_codes
-      raise_invalid_data_source('country_codes')
-    end
-
-    # Loads all timezone and country data into memory.
-    #
-    # This may be desirable in production environments to improve copy-on-write
-    # performance and to avoid flushing the constant cache every time a new
-    # timezone or country is loaded from {DataSources::RubyDataSource}.
-    def eager_load!
-      timezone_identifiers.each {|identifier| load_timezone_info(identifier) }
-      country_codes.each {|code| load_country_info(code) }
-      nil
-    end
-
-    # @return [String] a description of the {DataSource}.
-    def to_s
-      "Default DataSource"
-    end
-
-    # @return [String] the internal object state as a programmer-readable
-    #   `String`.
-    def inspect
-      "#<#{self.class}>"
-    end
-
-    protected
-
-    # Returns a {DataSources::TimezoneInfo} instance for the given time zone
-    # identifier. The result should derive from either
-    # {DataSources::DataTimezoneInfo} for time zones that define their own data
-    # or {DataSources::LinkedTimezoneInfo} for links to or aliases for other
-    # time zones.
-    #
-    # @param identifier [String] A time zone identifier.
-    # @return [DataSources::TimezoneInfo] a {DataSources::TimezoneInfo} instance
-    #   for the given time zone identifier.
-    # @raise [InvalidTimezoneIdentifier] if the time zone is not found or the
-    #   identifier is invalid.
-    def load_timezone_info(identifier)
-      raise_invalid_data_source('load_timezone_info')
-    end
-
-    # @param code [String] an ISO 3166-1 alpha-2 country code.
-    # @return [DataSources::CountryInfo] a {DataSources::CountryInfo} instance
-    #   for the given ISO 3166-1 alpha-2 country code.
-    # @raise [InvalidCountryCode] if the country could not be found or the code
-    #   is invalid.
-    def load_country_info(code)
-      raise_invalid_data_source('load_country_info')
-    end
-
-    # @return [Encoding] the `Encoding` used by the `String` instances returned
-    #   by {data_timezone_identifiers} and {linked_timezone_identifiers}.
-    def timezone_identifier_encoding
-      Encoding::UTF_8
-    end
-
-    # Checks that the given identifier is a valid time zone identifier (can be
-    # found in the {timezone_identifiers} `Array`). If the identifier is valid,
-    # the `String` instance representing that identifier from
-    # `timezone_identifiers` is returned. Otherwise an
-    # {InvalidTimezoneIdentifier} exception is raised.
-    #
-    # @param identifier [String] a time zone identifier to be validated.
-    # @return [String] the `String` instance equivalent to `identifier` from
-    #   {timezone_identifiers}.
-    # @raise [InvalidTimezoneIdentifier] if `identifier` was not found in
-    #   {timezone_identifiers}.
-    def validate_timezone_identifier(identifier)
-      raise InvalidTimezoneIdentifier, "Invalid identifier: #{identifier.nil? ? 'nil' : identifier}" unless identifier.kind_of?(String)
-
-      valid_identifier = try_with_encoding(identifier, timezone_identifier_encoding) {|id| find_timezone_identifier(id) }
-      return valid_identifier if valid_identifier
-
-      raise InvalidTimezoneIdentifier, "Invalid identifier: #{identifier.encode(Encoding::UTF_8)}"
-    end
-
-    # Looks up a given code in the given hash of code to
-    # {DataSources::CountryInfo} mappings. If the code is found the
-    # {DataSources::CountryInfo} is returned. Otherwise an {InvalidCountryCode}
-    # exception is raised.
-    #
-    # @param hash [String, DataSources::CountryInfo] a mapping from ISO 3166-1
-    #   alpha-2 country codes to {DataSources::CountryInfo} instances.
-    # @param code [String] a country code to lookup.
-    # @param encoding [Encoding] the encoding used for the country codes in
-    #   `hash`.
-    # @return [DataSources::CountryInfo] the {DataSources::CountryInfo} instance
-    #   corresponding to `code`.
-    # @raise [InvalidCountryCode] if `code` was not found in `hash`.
-    def lookup_country_info(hash, code, encoding = Encoding::UTF_8)
-      raise InvalidCountryCode, "Invalid country code: #{code.nil? ? 'nil' : code}" unless code.kind_of?(String)
-
-      info = try_with_encoding(code, encoding) {|c| hash[c] }
-      return info if info
-
-      raise InvalidCountryCode, "Invalid country code: #{code.encode(Encoding::UTF_8)}"
-    end
-
-    private
-
-    # Raises {InvalidDataSource} to indicate that a method has not been
-    # overridden by a particular data source implementation.
-    #
-    # @raise [InvalidDataSource] always.
-    def raise_invalid_data_source(method_name)
-      raise InvalidDataSource, "#{method_name} not defined"
-    end
-
-    # Combines {data_timezone_identifiers} and {linked_timezone_identifiers}
-    # to create an `Array` containing all valid time zone identifiers. If
-    # {linked_timezone_identifiers} is empty, the {data_timezone_identifiers}
-    # instance is returned.
-    #
-    # The returned `Array` is frozen. The identifiers are sorted according to
-    # `String#<=>`.
-    #
-    # @return [Array<String>] an `Array` containing all valid time zone
-    #   identifiers.
-    def build_timezone_identifiers
-      data = data_timezone_identifiers
-      linked = linked_timezone_identifiers
-      linked.empty? ? data : (data + linked).sort!.freeze
-    end
-
-    if [].respond_to?(:bsearch)
-      # If the given `identifier` is contained within the {timezone_identifiers}
-      # `Array`, the `String` instance representing that identifier from
-      # {timezone_identifiers} is returned. Otherwise, `nil` is returned.
-      #
-      # @param identifier [String] A time zone identifier to search for.
-      # @return [String] the `String` instance representing `identifier` from
-      #   {timezone_identifiers} if found, or `nil` if not found.
-      #
-      # :nocov_no_array_bsearch:
-      def find_timezone_identifier(identifier)
-
-        result = timezone_identifiers.bsearch {|i| i >= identifier }
-        result == identifier ? result : nil
-      end
-      # :nocov_no_array_bsearch:
-    else
-      # If the given `identifier` is contained within the {timezone_identifiers}
-      # `Array`, the `String` instance representing that identifier from
-      # {timezone_identifiers} is returned. Otherwise, `nil` is returned.
-      #
-      # @param identifier [String] A time zone identifier to search for.
-      # @return [String] the `String` instance representing `identifier` from
-      #   {timezone_identifiers} if found, or `nil` if not found.
-      #
-      # :nocov_array_bsearch:
-      def find_timezone_identifier(identifier)
-        identifiers = timezone_identifiers
-        low = 0
-        high = identifiers.length
-
-        while low < high do
-          mid = (low + high).div(2)
-          mid_identifier = identifiers[mid]
-          cmp = mid_identifier <=> identifier
-
-          return mid_identifier if cmp == 0
-
-          if cmp > 0
-            high = mid
-          else
-            low = mid + 1
-          end
-        end
-
-        nil
-      end
-      # :nocov_array_bsearch:
-    end
-
-    # Tries an operation using `string` directly. If the operation fails, the
-    # string is copied and encoded with `encoding` and the operation is tried
-    # again.
-    #
-    # @param string [String] The `String` to perform the operation on.
-    # @param encoding [Encoding] The `Encoding` to use if the initial attempt
-    #   fails.
-    # @yield [s] the caller will be yielded to once or twice to attempt the
-    #   operation.
-    # @yieldparam s [String] either `string` or an encoded copy of `string`.
-    # @yieldreturn [Object] The result of the operation. Must be truthy if
-    #   successful.
-    # @return [Object] the result of the operation or `nil` if the first attempt
-    # fails and `string` is already encoded with `encoding`.
-    def try_with_encoding(string, encoding)
-      result = yield string
-      return result if result
-
-      unless encoding == string.encoding
-        string = string.encode(encoding)
-        yield string
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources.rb
deleted file mode 100644
index 712920da6ed3c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  # {DataSource} implementations and classes used by {DataSource}
-  # implementations.
-  module DataSources
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/constant_offset_data_timezone_info.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/constant_offset_data_timezone_info.rb
deleted file mode 100644
index 076ee9bfe4b69..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/constant_offset_data_timezone_info.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  module DataSources
-    # Represents a data time zone defined by a constantly observed offset.
-    class ConstantOffsetDataTimezoneInfo < DataTimezoneInfo
-      # @return [TimezoneOffset] the offset that is constantly observed.
-      attr_reader :constant_offset
-
-      # Initializes a new {ConstantOffsetDataTimezoneInfo}.
-      #
-      # The passed in `identifier` instance will be frozen. A reference to the
-      # passed in {TimezoneOffset} will be retained.
-      #
-      # @param identifier [String] the identifier of the time zone.
-      # @param constant_offset [TimezoneOffset] the constantly observed offset.
-      # @raise [ArgumentError] if `identifier` or `constant_offset` is `nil`.
-      def initialize(identifier, constant_offset)
-        super(identifier)
-        raise ArgumentError, 'constant_offset must be specified' unless constant_offset
-        @constant_offset = constant_offset
-      end
-
-      # @param timestamp [Timestamp] ignored.
-      # @return [TimezonePeriod] an unbounded {TimezonePeriod} for the time
-      #   zone's constantly observed offset.
-      def period_for(timestamp)
-        constant_period
-      end
-
-      # @param local_timestamp [Timestamp] ignored.
-      # @return [Array<TimezonePeriod>] an `Array` containing a single unbounded
-      #   {TimezonePeriod} for the time zone's constantly observed offset.
-      def periods_for_local(local_timestamp)
-        [constant_period]
-      end
-
-      # @param to_timestamp [Timestamp] ignored.
-      # @param from_timestamp [Timestamp] ignored.
-      # @return [Array] an empty `Array`, since there are no transitions in time
-      #   zones that observe a constant offset.
-      def transitions_up_to(to_timestamp, from_timestamp = nil)
-        []
-      end
-
-      private
-
-      # @return [TimezonePeriod] an unbounded {TimezonePeriod} with the constant
-      #   offset of this timezone.
-      def constant_period
-        OffsetTimezonePeriod.new(@constant_offset)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/country_info.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/country_info.rb
deleted file mode 100644
index 4745f3bed1bc8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/country_info.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  module DataSources
-    # Represents a country and references to its time zones as returned by a
-    # {DataSource}.
-    class CountryInfo
-      # @return [String] the ISO 3166-1 alpha-2 country code.
-      attr_reader :code
-
-      # @return [String] the name of the country.
-      attr_reader :name
-
-      # @return [Array<CountryTimezone>] the time zones observed in the country.
-      attr_reader :zones
-
-      # Initializes a new {CountryInfo}. The passed in `code`, `name` and
-      # `zones` instances will be frozen.
-      #
-      # @param code [String] an ISO 3166-1 alpha-2 country code.
-      # @param name [String] the name of the country.
-      # @param zones [Array<CountryTimezone>] the time zones observed in the
-      #   country.
-      # @raise [ArgumentError] if `code`, `name` or `zones` is `nil`.
-      def initialize(code, name, zones)
-        raise ArgumentError, 'code must be specified' unless code
-        raise ArgumentError, 'name must be specified' unless name
-        raise ArgumentError, 'zones must be specified' unless zones
-        @code = code.freeze
-        @name = name.freeze
-        @zones = zones.freeze
-      end
-
-      # @return [String] the internal object state as a programmer-readable
-      #   `String`.
-      def inspect
-        "#<#{self.class}: #@code>"
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/data_timezone_info.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/data_timezone_info.rb
deleted file mode 100644
index d43203a1a2d88..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/data_timezone_info.rb
+++ /dev/null
@@ -1,91 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  module DataSources
-    # The base class for time zones defined as either a series of transitions
-    # ({TransitionsDataTimezoneInfo}) or a constantly observed offset
-    # ({ConstantOffsetDataTimezoneInfo}).
-    #
-    # @abstract Data sources return instances of {DataTimezoneInfo} subclasses.
-    class DataTimezoneInfo < TimezoneInfo
-      # @param timestamp [Timestamp] a {Timestamp} with a specified
-      #   {Timestamp#utc_offset utc_offset}.
-      # @return [TimezonePeriod] the {TimezonePeriod} observed at the time
-      #   specified by `timestamp`.
-      # @raise [ArgumentError] may be raised if `timestamp` is `nil` or does not
-      #   have a specified {Timestamp#utc_offset utc_offset}.
-      def period_for(timestamp)
-        raise_not_implemented('period_for')
-      end
-
-      # Returns an `Array` containing the {TimezonePeriod TimezonePeriods} that
-      # could be observed at the local time specified by `local_timestamp`. The
-      # results are are ordered by increasing UTC start date. An empty `Array`
-      # is returned if no periods are found for the given local time.
-      #
-      # @param local_timestamp [Timestamp] a {Timestamp} representing a local
-      #   time - must have an unspecified {Timestamp#utc_offset utc_offset}.
-      # @return [Array<TimezonePeriod>] an `Array` containing the
-      #   {TimezonePeriod TimezonePeriods} that could be observed at the local
-      #   time specified by `local_timestamp`.
-      # @raise [ArgumentError] may be raised if `local_timestamp` is `nil`, or
-      #   has a specified {Timestamp#utc_offset utc_offset}.
-      def periods_for_local(local_timestamp)
-        raise_not_implemented('periods_for_local')
-      end
-
-      # Returns an `Array` of {TimezoneTransition} instances representing the
-      # times where the UTC offset of the time zone changes.
-      #
-      # Transitions are returned up to a given {Timestamp} (`to_timestamp`).
-      #
-      # A from {Timestamp} may also be supplied using the `from_timestamp`
-      # parameter. If `from_timestamp` is specified, only transitions from that
-      # time onwards will be returned.
-      #
-      # Comparisons with `to_timestamp` are exclusive. Comparisons with
-      # `from_timestamp` are inclusive. If a transition falls precisely on
-      # `to_timestamp`, it will be excluded. If a transition falls on
-      # `from_timestamp`, it will be included.
-      #
-      # Transitions returned are ordered by when they occur, from earliest to
-      # latest.
-      #
-      # @param to_timestamp [Timestamp] a {Timestamp} with a specified
-      #   {Timestamp#utc_offset utc_offset}. Transitions are returned if they
-      #   occur before this time.
-      # @param from_timestamp [Timestamp] an optional {Timestamp} with a
-      #   specified {Timestamp#utc_offset utc_offset}. If specified, transitions
-      #   are returned if they occur at or after this time.
-      # @return [Array<TimezoneTransition>] an `Array` of {TimezoneTransition}
-      #   instances representing the times where the UTC offset of the time zone
-      #   changes.
-      # @raise [ArgumentError] may be raised if `to_timestamp` is `nil` or does
-      #   not have a specified {Timestamp#utc_offset utc_offset}.
-      # @raise [ArgumentError] may be raised if `from_timestamp` is specified
-      #   but does not have a specified {Timestamp#utc_offset utc_offset}.
-      # @raise [ArgumentError] may be raised if `from_timestamp` is specified
-      #   but is not earlier than or at the same time as `to_timestamp`.
-      def transitions_up_to(to_timestamp, from_timestamp = nil)
-        raise_not_implemented('transitions_up_to')
-      end
-
-      # @return [DataTimezone] a new {DataTimezone} instance for the time zone
-      #   represented by this {DataTimezoneInfo}.
-      def create_timezone
-        DataTimezone.new(self)
-      end
-
-      private
-
-      # Raises a {NotImplementedError} to indicate that the base class is
-      # incorrectly being used directly.
-      #
-      # raise [NotImplementedError] always.
-      def raise_not_implemented(method_name)
-        raise NotImplementedError, "Subclasses must override #{method_name}"
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/linked_timezone_info.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/linked_timezone_info.rb
deleted file mode 100644
index f44e79d42436b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/linked_timezone_info.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  module DataSources
-    # Represents a time zone that is defined as a link to or alias of another
-    # zone.
-    class LinkedTimezoneInfo < TimezoneInfo
-      # @return [String] the identifier of the time zone that provides the data
-      # (that this zone links to or is an alias for).
-      attr_reader :link_to_identifier
-
-      # Initializes a new {LinkedTimezoneInfo}. The passed in `identifier` and
-      # `link_to_identifier` instances will be frozen.
-      #
-      # @param identifier [String] the identifier of the time zone.
-      # @param link_to_identifier [String] the identifier of the time zone that
-      #   this zone link to.
-      # @raise [ArgumentError] if `identifier` or `link_to_identifier` are
-      # `nil`.
-      def initialize(identifier, link_to_identifier)
-        super(identifier)
-        raise ArgumentError, 'link_to_identifier must be specified' unless link_to_identifier
-        @link_to_identifier = link_to_identifier.freeze
-      end
-
-      # @return [LinkedTimezone] a new {LinkedTimezone} instance for the time
-      #   zone represented by this {LinkedTimezoneInfo}.
-      def create_timezone
-        LinkedTimezone.new(self)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/posix_time_zone_parser.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/posix_time_zone_parser.rb
deleted file mode 100644
index b3d2b2e36142c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/posix_time_zone_parser.rb
+++ /dev/null
@@ -1,181 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-require 'strscan'
-
-module TZInfo
-  # Use send as a workaround for erroneous 'wrong number of arguments' errors
-  # with JRuby 9.0.5.0 when calling methods with Java implementations. See #114.
-  send(:using, UntaintExt) if TZInfo.const_defined?(:UntaintExt)
-
-  module DataSources
-    # An {InvalidPosixTimeZone} exception is raised if an invalid POSIX-style
-    # time zone string is encountered.
-    #
-    # @private
-    class InvalidPosixTimeZone < StandardError #:nodoc:
-    end
-    private_constant :InvalidPosixTimeZone
-
-    # A parser for POSIX-style TZ strings used in zoneinfo files and specified
-    # by tzfile.5 and tzset.3.
-    #
-    # @private
-    class PosixTimeZoneParser #:nodoc:
-      # Initializes a new {PosixTimeZoneParser}.
-      #
-      # @param string_deduper [StringDeduper] a {StringDeduper} instance to use
-      #   to dedupe abbreviations.
-      def initialize(string_deduper)
-        @string_deduper = string_deduper
-      end
-
-      # Parses a POSIX-style TZ string.
-      #
-      # @param tz_string [String] the string to parse.
-      # @return [Object] either a {TimezoneOffset} for a constantly applied
-      #   offset or an {AnnualRules} instance representing the rules.
-      # @raise [InvalidPosixTimeZone] if `tz_string` is not a `String`.
-      # @raise [InvalidPosixTimeZone] if `tz_string` is is not valid.
-      def parse(tz_string)
-        raise InvalidPosixTimeZone unless tz_string.kind_of?(String)
-        return nil if tz_string.empty?
-
-        s = StringScanner.new(tz_string)
-        check_scan(s, /([^-+,\d<][^-+,\d]*) | <([^>]+)>/x)
-        std_abbrev = @string_deduper.dedupe((s[1] || s[2]).untaint)
-        check_scan(s, /([-+]?\d+)(?::(\d+)(?::(\d+))?)?/)
-        std_offset = get_offset_from_hms(s[1], s[2], s[3])
-
-        if s.scan(/([^-+,\d<][^-+,\d]*) | <([^>]+)>/x)
-          dst_abbrev = @string_deduper.dedupe((s[1] || s[2]).untaint)
-
-          if s.scan(/([-+]?\d+)(?::(\d+)(?::(\d+))?)?/)
-            dst_offset = get_offset_from_hms(s[1], s[2], s[3])
-          else
-            # POSIX is negative for ahead of UTC.
-            dst_offset = std_offset - 3600
-          end
-
-          dst_difference = std_offset - dst_offset
-
-          start_rule = parse_rule(s, 'start')
-          end_rule = parse_rule(s, 'end')
-
-          raise InvalidPosixTimeZone, "Expected the end of a POSIX-style time zone string but found '#{s.rest}'." if s.rest?
-
-          if start_rule.is_always_first_day_of_year? && start_rule.transition_at == 0 &&
-               end_rule.is_always_last_day_of_year? && end_rule.transition_at == 86400 + dst_difference
-            # Constant daylight savings time.
-            # POSIX is negative for ahead of UTC.
-            TimezoneOffset.new(-std_offset, dst_difference, dst_abbrev)
-          else
-            AnnualRules.new(
-              TimezoneOffset.new(-std_offset, 0, std_abbrev),
-              TimezoneOffset.new(-std_offset, dst_difference, dst_abbrev),
-              start_rule,
-              end_rule)
-          end
-        elsif !s.rest?
-          # Constant standard time.
-          # POSIX is negative for ahead of UTC.
-          TimezoneOffset.new(-std_offset, 0, std_abbrev)
-        else
-          raise InvalidPosixTimeZone, "Expected the end of a POSIX-style time zone string but found '#{s.rest}'."
-        end
-      end
-
-      private
-
-      # Parses a rule.
-      #
-      # @param s [StringScanner] the `StringScanner` to read the rule from.
-      # @param type [String] the type of rule (either `'start'` or `'end'`).
-      # @raise [InvalidPosixTimeZone] if the rule is not valid.
-      # @return [TransitionRule] the parsed rule.
-      def parse_rule(s, type)
-        check_scan(s, /,(?: (?: J(\d+) ) | (\d+) | (?: M(\d+)\.(\d)\.(\d) ) )/x)
-        julian_day_of_year = s[1]
-        absolute_day_of_year = s[2]
-        month = s[3]
-        week = s[4]
-        day_of_week = s[5]
-
-        if s.scan(/\//)
-          check_scan(s, /([-+]?\d+)(?::(\d+)(?::(\d+))?)?/)
-          transition_at = get_seconds_after_midnight_from_hms(s[1], s[2], s[3])
-        else
-          transition_at = 7200
-        end
-
-        begin
-          if julian_day_of_year
-            JulianDayOfYearTransitionRule.new(julian_day_of_year.to_i, transition_at)
-          elsif absolute_day_of_year
-            AbsoluteDayOfYearTransitionRule.new(absolute_day_of_year.to_i, transition_at)
-          elsif week == '5'
-            LastDayOfMonthTransitionRule.new(month.to_i, day_of_week.to_i, transition_at)
-          else
-            DayOfMonthTransitionRule.new(month.to_i, week.to_i, day_of_week.to_i, transition_at)
-          end
-        rescue ArgumentError => e
-          raise InvalidPosixTimeZone, "Invalid #{type} rule in POSIX-style time zone string: #{e}"
-        end
-      end
-
-      # Returns an offset in seconds from hh:mm:ss values. The value can be
-      # negative. -02:33:12 would represent 2 hours, 33 minutes and 12 seconds
-      # ahead of UTC.
-      #
-      # @param h [String] the hours.
-      # @param m [String] the minutes.
-      # @param s [String] the seconds.
-      # @return [Integer] the offset.
-      # @raise [InvalidPosixTimeZone] if the mm and ss values are greater than
-      #   59.
-      def get_offset_from_hms(h, m, s)
-        h = h.to_i
-        m = m.to_i
-        s = s.to_i
-        raise InvalidPosixTimeZone, "Invalid minute #{m} in offset for POSIX-style time zone string." if m > 59
-        raise InvalidPosixTimeZone, "Invalid second #{s} in offset for POSIX-style time zone string." if s > 59
-        magnitude = (h.abs * 60 + m) * 60 + s
-        h < 0 ? -magnitude : magnitude
-      end
-
-      # Returns the seconds from midnight from hh:mm:ss values. Hours can exceed
-      # 24 for a time on the following day. Hours can be negative to subtract
-      # hours from midnight on the given day. -02:33:12 represents 22:33:12 on
-      # the prior day.
-      #
-      # @param h [String] the hour.
-      # @param m [String] the minutes past the hour.
-      # @param s [String] the seconds past the minute.
-      # @return [Integer] the number of seconds after midnight.
-      # @raise [InvalidPosixTimeZone] if the mm and ss values are greater than
-      #   59.
-      def get_seconds_after_midnight_from_hms(h, m, s)
-        h = h.to_i
-        m = m.to_i
-        s = s.to_i
-        raise InvalidPosixTimeZone, "Invalid minute #{m} in time for POSIX-style time zone string." if m > 59
-        raise InvalidPosixTimeZone, "Invalid second #{s} in time for POSIX-style time zone string." if s > 59
-        (h * 3600) + m * 60 + s
-      end
-
-      # Scans for a pattern and raises an exception if the pattern does not
-      # match the input.
-      #
-      # @param s [StringScanner] the `StringScanner` to scan.
-      # @param pattern [Regexp] the pattern to match.
-      # @return [String] the result of the scan.
-      # @raise [InvalidPosixTimeZone] if the pattern does not match the input.
-      def check_scan(s, pattern)
-        result = s.scan(pattern)
-        raise InvalidPosixTimeZone, "Expected '#{s.rest}' to match #{pattern} in POSIX-style time zone string." unless result
-        result
-      end
-    end
-    private_constant :PosixTimeZoneParser
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/ruby_data_source.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/ruby_data_source.rb
deleted file mode 100644
index 9c12322567a65..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/ruby_data_source.rb
+++ /dev/null
@@ -1,145 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # Use send as a workaround for erroneous 'wrong number of arguments' errors
-  # with JRuby 9.0.5.0 when calling methods with Java implementations. See #114.
-  send(:using, UntaintExt) if TZInfo.const_defined?(:UntaintExt)
-
-  module DataSources
-    # A {TZInfoDataNotFound} exception is raised if the tzinfo-data gem could
-    # not be found (i.e. `require 'tzinfo/data'` failed) when selecting the Ruby
-    # data source.
-    class TZInfoDataNotFound < StandardError
-    end
-
-    # A DataSource implementation that loads data from the set of Ruby modules
-    # included in the tzinfo-data gem.
-    #
-    # TZInfo will use {RubyDataSource} by default if the tzinfo-data gem
-    # is available on the load path. It can also be selected by calling
-    # {DataSource.set} as follows:
-    #
-    #     TZInfo::DataSource.set(:ruby)
-    class RubyDataSource < DataSource
-      # (see DataSource#data_timezone_identifiers)
-      attr_reader :data_timezone_identifiers
-
-      # (see DataSource#linked_timezone_identifiers)
-      attr_reader :linked_timezone_identifiers
-
-      # (see DataSource#country_codes)
-      attr_reader :country_codes
-
-      # Initializes a new {RubyDataSource} instance.
-      #
-      # @raise [TZInfoDataNotFound] if the tzinfo-data gem could not be found
-      #   (i.e. `require 'tzinfo/data'` failed).
-      def initialize
-        super
-
-        begin
-          require('tzinfo/data')
-        rescue LoadError
-          raise TZInfoDataNotFound, "The tzinfo-data gem could not be found (require 'tzinfo/data' failed)."
-        end
-
-        if TZInfo::Data.const_defined?(:LOCATION)
-          # Format 2
-          @base_path = File.join(TZInfo::Data::LOCATION, 'tzinfo', 'data')
-        else
-          # Format 1
-          data_file = File.join('', 'tzinfo', 'data.rb')
-          path = $".reverse_each.detect {|p| p.end_with?(data_file) }
-          if path
-            @base_path = File.join(File.dirname(path), 'data').untaint
-          else
-            @base_path = 'tzinfo/data'
-          end
-        end
-
-        require_index('timezones')
-        require_index('countries')
-
-        @data_timezone_identifiers = Data::Indexes::Timezones.data_timezones
-        @linked_timezone_identifiers = Data::Indexes::Timezones.linked_timezones
-        @countries = Data::Indexes::Countries.countries
-        @country_codes = @countries.keys.sort!.freeze
-      end
-
-      # (see DataSource#to_s)
-      def to_s
-        "Ruby DataSource: #{version_info}"
-      end
-
-      # (see DataSource#inspect)
-      def inspect
-        "#<TZInfo::DataSources::RubyDataSource: #{version_info}>"
-      end
-
-      protected
-
-      # Returns a {TimezoneInfo} instance for the given time zone identifier.
-      # The result will either be a {ConstantOffsetDataTimezoneInfo}, a
-      # {TransitionsDataTimezoneInfo} or a {LinkedTimezoneInfo} depending on the
-      # type of time zone.
-      #
-      # @param identifier [String] A time zone identifier.
-      # @return [TimezoneInfo] a {TimezoneInfo} instance for the given time zone
-      #   identifier.
-      # @raise [InvalidTimezoneIdentifier] if the time zone is not found or the
-      #   identifier is invalid.
-      def load_timezone_info(identifier)
-        valid_identifier = validate_timezone_identifier(identifier)
-        split_identifier = valid_identifier.gsub(/-/, '__m__').gsub(/\+/, '__p__').split('/')
-
-        begin
-          require_definition(split_identifier)
-
-          m = Data::Definitions
-          split_identifier.each {|part| m = m.const_get(part) }
-          m.get
-        rescue LoadError, NameError => e
-          raise InvalidTimezoneIdentifier, "#{e.message.encode(Encoding::UTF_8)} (loading #{valid_identifier})"
-        end
-      end
-
-      # (see DataSource#load_country_info)
-      def load_country_info(code)
-        lookup_country_info(@countries, code)
-      end
-
-      private
-
-      # Requires a zone definition by its identifier (split on /).
-      #
-      # @param identifier [Array<string>] the component parts of a time zone
-      #   identifier (split on /). This must have already been validated.
-      def require_definition(identifier)
-        require_data('definitions', *identifier)
-      end
-
-      # Requires an index by its name.
-      #
-      # @param name [String] an index name.
-      def require_index(name)
-        require_data('indexes', name)
-      end
-
-      # Requires a file from tzinfo/data.
-      #
-      # @param file [Array<String>] a relative path to a file to be required.
-      def require_data(*file)
-        require(File.join(@base_path, *file))
-      end
-
-      # @return [String] a `String` containing TZInfo::Data version infomation
-      #   for inclusion in the #to_s and #inspect output.
-      def version_info
-        # The TZInfo::Data::VERSION constant is only available from v1.2014.8
-        # onwards.
-        "tzdb v#{TZInfo::Data::Version::TZDATA}#{TZInfo::Data.const_defined?(:VERSION) ? ", tzinfo-data v#{TZInfo::Data::VERSION}" : ''}"
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/timezone_info.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/timezone_info.rb
deleted file mode 100644
index 51d8d51acdfe8..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/timezone_info.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  module DataSources
-    # Represents a time zone defined by a data source.
-    #
-    # @abstract Data sources return instances of {TimezoneInfo} subclasses.
-    class TimezoneInfo
-      # @return [String] the identifier of the time zone.
-      attr_reader :identifier
-
-      # Initializes a new TimezoneInfo. The passed in `identifier` instance will
-      # be frozen.
-      #
-      # @param identifier [String] the identifier of the time zone.
-      # @raise [ArgumentError] if `identifier` is `nil`.
-      def initialize(identifier)
-        raise ArgumentError, 'identifier must be specified' unless identifier
-        @identifier = identifier.freeze
-      end
-
-      # @return [String] the internal object state as a programmer-readable
-      #   `String`.
-      def inspect
-        "#<#{self.class}: #@identifier>"
-      end
-
-      # @return [Timezone] a new {Timezone} instance for the time zone
-      #   represented by this {TimezoneInfo}.
-      def create_timezone
-        raise_not_implemented('create_timezone')
-      end
-
-      private
-
-      # Raises a {NotImplementedError}.
-      #
-      # @param method_name [String] the name of the method that must be
-      #   overridden.
-      # @raise NotImplementedError always.
-      def raise_not_implemented(method_name)
-        raise NotImplementedError, "Subclasses must override #{method_name}"
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/transitions_data_timezone_info.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/transitions_data_timezone_info.rb
deleted file mode 100644
index 14fe51e4e9f8a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/transitions_data_timezone_info.rb
+++ /dev/null
@@ -1,214 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  module DataSources
-    # Represents a data time zone defined by a list of transitions that change
-    # the locally observed time.
-    class TransitionsDataTimezoneInfo < DataTimezoneInfo
-      # @return [Array<TimezoneTransition>] the transitions that define this
-      #   time zone in order of ascending timestamp.
-      attr_reader :transitions
-
-      # Initializes a new {TransitionsDataTimezoneInfo}.
-      #
-      # The passed in `identifier` instance will be frozen. A reference to the
-      # passed in `Array` will be retained.
-      #
-      # The `transitions` `Array` must be sorted in order of ascending
-      # timestamp. Each transition must have a
-      # {TimezoneTransition#timestamp_value timestamp_value} that is greater
-      # than the {TimezoneTransition#timestamp_value timestamp_value} of the
-      # prior transition.
-      #
-      # @param identifier [String] the identifier of the time zone.
-      # @param transitions [Array<TimezoneTransitions>] an `Array` of
-      #   transitions that each indicate when a change occurs in the locally
-      #   observed time.
-      # @raise [ArgumentError] if `identifier` is `nil`.
-      # @raise [ArgumentError] if `transitions` is `nil`.
-      # @raise [ArgumentError] if `transitions` is an empty `Array`.
-      def initialize(identifier, transitions)
-        super(identifier)
-        raise ArgumentError, 'transitions must be specified' unless transitions
-        raise ArgumentError, 'transitions must not be an empty Array' if transitions.empty?
-        @transitions = transitions.freeze
-      end
-
-      # (see DataTimezoneInfo#period_for)
-      def period_for(timestamp)
-        raise ArgumentError, 'timestamp must be specified' unless timestamp
-        raise ArgumentError, 'timestamp must have a specified utc_offset' unless timestamp.utc_offset
-
-        timestamp_value = timestamp.value
-
-        index = find_minimum_transition {|t| t.timestamp_value >= timestamp_value }
-
-        if index
-          transition = @transitions[index]
-
-          if transition.timestamp_value == timestamp_value
-            # timestamp occurs within the second of the found transition, so is
-            # the transition that starts the period.
-            start_transition = transition
-            end_transition = @transitions[index + 1]
-          else
-            # timestamp occurs before the second of the found transition, so is
-            # the transition that ends the period.
-            start_transition = index == 0 ? nil : @transitions[index - 1]
-            end_transition = transition
-          end
-        else
-          start_transition = @transitions.last
-          end_transition = nil
-        end
-
-        TransitionsTimezonePeriod.new(start_transition, end_transition)
-      end
-
-      # (see DataTimezoneInfo#periods_for_local)
-      def periods_for_local(local_timestamp)
-        raise ArgumentError, 'local_timestamp must be specified' unless local_timestamp
-        raise ArgumentError, 'local_timestamp must have an unspecified utc_offset' if local_timestamp.utc_offset
-
-        local_timestamp_value = local_timestamp.value
-        latest_possible_utc_value = local_timestamp_value + 86400
-        earliest_possible_utc_value = local_timestamp_value - 86400
-
-        # Find the index of the first transition that occurs after a latest
-        # possible UTC representation of the local timestamp and then search
-        # backwards until an earliest possible UTC representation.
-
-        index = find_minimum_transition {|t| t.timestamp_value >= latest_possible_utc_value }
-
-        # No transitions after latest_possible_utc_value, set to max index + 1
-        # to search backwards including the period after the last transition
-        index = @transitions.length unless index
-
-        result = []
-
-        index.downto(0) do |i|
-          start_transition = i > 0 ? @transitions[i - 1] : nil
-          end_transition = @transitions[i]
-          offset = start_transition ? start_transition.offset : end_transition.previous_offset
-          utc_timestamp_value = local_timestamp_value - offset.observed_utc_offset
-
-          # It is not necessary to compare the sub-seconds because a timestamp
-          # is in the period if is >= the start transition (sub-seconds would
-          # make == become >) and if it is < the end transition (which
-          # sub-seconds cannot affect).
-          if (!start_transition || utc_timestamp_value >= start_transition.timestamp_value) && (!end_transition || utc_timestamp_value < end_transition.timestamp_value)
-            result << TransitionsTimezonePeriod.new(start_transition, end_transition)
-          elsif end_transition && end_transition.timestamp_value < earliest_possible_utc_value
-            break
-          end
-        end
-
-        result.reverse!
-      end
-
-      # (see DataTimezoneInfo#transitions_up_to)
-      def transitions_up_to(to_timestamp, from_timestamp = nil)
-        raise ArgumentError, 'to_timestamp must be specified' unless to_timestamp
-        raise ArgumentError, 'to_timestamp must have a specified utc_offset' unless to_timestamp.utc_offset
-
-        if from_timestamp
-          raise ArgumentError, 'from_timestamp must have a specified utc_offset' unless from_timestamp.utc_offset
-          raise ArgumentError, 'to_timestamp must be greater than from_timestamp' if to_timestamp <= from_timestamp
-        end
-
-        if from_timestamp
-          from_index = find_minimum_transition {|t| transition_on_or_after_timestamp?(t, from_timestamp) }
-          return [] unless from_index
-        else
-          from_index = 0
-        end
-
-        to_index = find_minimum_transition {|t| transition_on_or_after_timestamp?(t, to_timestamp) }
-
-        if to_index
-          return [] if to_index < 1
-          to_index -= 1
-        else
-          to_index = -1
-        end
-
-        @transitions[from_index..to_index]
-      end
-
-      private
-
-      # Array#bsearch_index was added in Ruby 2.3.0. Use bsearch_index to find
-      # transitions if it is available, otherwise use a Ruby implementation.
-      if [].respond_to?(:bsearch_index)
-        # Performs a binary search on {transitions} to find the index of the
-        # earliest transition satisfying a condition.
-        #
-        # @yield [transition] the caller will be yielded to to test the search
-        #   condition.
-        # @yieldparam transition [TimezoneTransition] a {TimezoneTransition}
-        #   instance from {transitions}.
-        # @yieldreturn [Boolean] `true` for the earliest transition that
-        #   satisfies the condition and return `true` for all subsequent
-        #   transitions. In all other cases, the result of the block must be
-        #   `false`.
-        # @return [Integer] the index of the earliest transition safisfying
-        #   the condition or `nil` if there are no such transitions.
-        #
-        # :nocov_no_array_bsearch_index:
-        def find_minimum_transition(&block)
-          @transitions.bsearch_index(&block)
-        end
-        # :nocov_no_array_bsearch_index:
-      else
-        # Performs a binary search on {transitions} to find the index of the
-        # earliest transition satisfying a condition.
-        #
-        # @yield [transition] the caller will be yielded to to test the search
-        #   condition.
-        # @yieldparam transition [TimezoneTransition] a {TimezoneTransition}
-        #   instance from {transitions}.
-        # @yieldreturn [Boolean] `true` for the earliest transition that
-        #   satisfies the condition and return `true` for all subsequent
-        #   transitions. In all other cases, the result of the block must be
-        #   `false`.
-        # @return [Integer] the index of the earliest transition safisfying
-        #   the condition or `nil` if there are no such transitions.
-        #
-        # :nocov_array_bsearch_index:
-        def find_minimum_transition
-          # A Ruby implementation of the find-minimum mode of Array#bsearch_index.
-          low = 0
-          high = @transitions.length
-          satisfied = false
-
-          while low < high do
-            mid = (low + high).div(2)
-            if yield @transitions[mid]
-              satisfied = true
-              high = mid
-            else
-              low = mid + 1
-            end
-          end
-
-          satisfied ? low : nil
-        end
-        # :nocov_array_bsearch_index:
-      end
-
-      # Determines if a transition occurs at or after a given {Timestamp},
-      # taking the {Timestamp#sub_second sub_second} into consideration.
-      #
-      # @param transition [TimezoneTransition] the transition to compare.
-      # @param timestamp [Timestamp] the timestamp to compare.
-      # @return [Boolean] `true` if `transition` occurs at or after `timestamp`,
-      #   otherwise `false`.
-      def transition_on_or_after_timestamp?(transition, timestamp)
-        transition_timestamp_value = transition.timestamp_value
-        timestamp_value = timestamp.value
-        transition_timestamp_value > timestamp_value || transition_timestamp_value == timestamp_value && timestamp.sub_second == 0
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/zoneinfo_data_source.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/zoneinfo_data_source.rb
deleted file mode 100644
index cf77576f4c452..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/zoneinfo_data_source.rb
+++ /dev/null
@@ -1,596 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # Use send as a workaround for erroneous 'wrong number of arguments' errors
-  # with JRuby 9.0.5.0 when calling methods with Java implementations. See #114.
-  send(:using, UntaintExt) if TZInfo.const_defined?(:UntaintExt)
-
-  module DataSources
-    # An {InvalidZoneinfoDirectory} exception is raised if {ZoneinfoDataSource}
-    # is initialized with a specific zoneinfo path that is not a valid zoneinfo
-    # directory. A valid zoneinfo directory is one that contains time zone
-    # files, a country code index file named iso3166.tab and a time zone index
-    # file named zone1970.tab or zone.tab.
-    class InvalidZoneinfoDirectory < StandardError
-    end
-
-    # A {ZoneinfoDirectoryNotFound} exception is raised if no valid zoneinfo
-    # directory could be found when checking the paths listed in
-    # {ZoneinfoDataSource.search_path}. A valid zoneinfo directory is one that
-    # contains time zone files, a country code index file named iso3166.tab and
-    # a time zone index file named zone1970.tab or zone.tab.
-    class ZoneinfoDirectoryNotFound < StandardError
-    end
-
-    # A DataSource implementation that loads data from a 'zoneinfo' directory
-    # containing compiled "TZif" version 3 (or earlier) files in addition to
-    # iso3166.tab and zone1970.tab or zone.tab index files.
-    #
-    # To have TZInfo load the system zoneinfo files, call
-    # {TZInfo::DataSource.set} as follows:
-    #
-    #     TZInfo::DataSource.set(:zoneinfo)
-    #
-    # To load zoneinfo files from a particular directory, pass the directory to
-    # {TZInfo::DataSource.set}:
-    #
-    #     TZInfo::DataSource.set(:zoneinfo, directory)
-    #
-    # To load zoneinfo files from a particular directory, but load the
-    # iso3166.tab index file from a separate location, pass the directory and
-    # path to the iso3166.tab file to {TZInfo::DataSource.set}:
-    #
-    #     TZInfo::DataSource.set(:zoneinfo, directory, iso3166_path)
-    #
-    # Please note that versions of the 'zic' tool (used to build zoneinfo files)
-    # that were released prior to February 2006 created zoneinfo files that used
-    # 32-bit integers for transition timestamps. Later versions of zic produce
-    # zoneinfo files that use 64-bit integers. If you have 32-bit zoneinfo files
-    # on your system, then any queries falling outside of the range 1901-12-13
-    # 20:45:52 to 2038-01-19 03:14:07 may be inaccurate.
-    #
-    # Most modern platforms include 64-bit zoneinfo files. However, Mac OS X (up
-    # to at least 10.8.4) still uses 32-bit zoneinfo files.
-    #
-    # To check whether your zoneinfo files contain 32-bit or 64-bit transition
-    # data, you can run the following code (substituting the identifier of the
-    # zone you want to test for `zone_identifier`):
-    #
-    #     TZInfo::DataSource.set(:zoneinfo)
-    #     dir = TZInfo::DataSource.get.zoneinfo_dir
-    #     File.open(File.join(dir, zone_identifier), 'r') {|f| f.read(5) }
-    #
-    # If the last line returns `"TZif\\x00"`, then you have a 32-bit zoneinfo
-    # file. If it returns `"TZif2"` or `"TZif3"` then you have a 64-bit zoneinfo
-    # file.
-    #
-    # It is also worth noting that as of the 2017c release of the IANA Time Zone
-    # Database, 64-bit zoneinfo files only include future transitions up to
-    # 2038-01-19 03:14:07. Any queries falling after this time may be
-    # inaccurate.
-    class ZoneinfoDataSource < DataSource
-      # The default value of {ZoneinfoDataSource.search_path}.
-      DEFAULT_SEARCH_PATH = ['/usr/share/zoneinfo', '/usr/share/lib/zoneinfo', '/etc/zoneinfo'].freeze
-      private_constant :DEFAULT_SEARCH_PATH
-
-      # The default value of {ZoneinfoDataSource.alternate_iso3166_tab_search_path}.
-      DEFAULT_ALTERNATE_ISO3166_TAB_SEARCH_PATH = ['/usr/share/misc/iso3166.tab', '/usr/share/misc/iso3166'].freeze
-      private_constant :DEFAULT_ALTERNATE_ISO3166_TAB_SEARCH_PATH
-
-      # Files and directories in the top level zoneinfo directory that will be
-      # excluded from the list of available time zones:
-      #
-      #   - +VERSION is included on Mac OS X.
-      #   - leapseconds is a list of leap seconds.
-      #   - localtime is the current local timezone (may be a link).
-      #   - posix, posixrules and right are directories containing other
-      #     versions of the zoneinfo files.
-      #   - SECURITY is included in the Arch Linux tzdata package.
-      #   - src is a directory containing the tzdata source included on Solaris.
-      #   - timeconfig is a symlink included on Slackware.
-      EXCLUDED_FILENAMES = [
-        '+VERSION',
-        'leapseconds',
-        'localtime',
-        'posix',
-        'posixrules',
-        'right',
-        'SECURITY',
-        'src',
-        'timeconfig'
-      ].freeze
-      private_constant :EXCLUDED_FILENAMES
-
-      # Paths to be checked to find the system zoneinfo directory.
-      #
-      # @private
-      @@search_path = DEFAULT_SEARCH_PATH.dup
-
-      # Paths to possible alternate iso3166.tab files (used to locate the
-      # system-wide iso3166.tab files on FreeBSD and OpenBSD).
-      #
-      # @private
-      @@alternate_iso3166_tab_search_path = DEFAULT_ALTERNATE_ISO3166_TAB_SEARCH_PATH.dup
-
-      class << self
-        # An `Array` of directories that will be checked to find the system
-        # zoneinfo directory.
-        #
-        # Directories are checked in the order they appear in the `Array`.
-        #
-        # The default value is `['/usr/share/zoneinfo',
-        # '/usr/share/lib/zoneinfo', '/etc/zoneinfo']`.
-        #
-        # @return [Array<String>] an `Array` of directories to check in order to
-        #   find the system zoneinfo directory.
-        def search_path
-          @@search_path
-        end
-
-        # Sets the directories to be checked when locating the system zoneinfo
-        # directory.
-        #
-        # Can be set to an `Array` of directories or a `String` containing
-        # directories separated with `File::PATH_SEPARATOR`.
-        #
-        # Directories are checked in the order they appear in the `Array` or
-        # `String`.
-        #
-        # Set to `nil` to revert to the default paths.
-        #
-        # @param search_path [Object] either `nil` or a list of directories to
-        #   check as either an `Array` of `String` or a `File::PATH_SEPARATOR`
-        #   separated `String`.
-        def search_path=(search_path)
-          @@search_path = process_search_path(search_path, DEFAULT_SEARCH_PATH)
-        end
-
-        # An `Array` of paths that will be checked to find an alternate
-        # iso3166.tab file if one was not included in the zoneinfo directory
-        # (for example, on FreeBSD and OpenBSD systems).
-        #
-        # Paths are checked in the order they appear in the `Array`.
-        #
-        # The default value is `['/usr/share/misc/iso3166.tab',
-        # '/usr/share/misc/iso3166']`.
-        #
-        # @return [Array<String>] an `Array` of paths to check in order to
-        #   locate an iso3166.tab file.
-        def alternate_iso3166_tab_search_path
-          @@alternate_iso3166_tab_search_path
-        end
-
-        # Sets the paths to check to locate an alternate iso3166.tab file if one
-        # was not included in the zoneinfo directory.
-        #
-        # Can be set to an `Array` of paths or a `String` containing paths
-        # separated with `File::PATH_SEPARATOR`.
-        #
-        # Paths are checked in the order they appear in the array.
-        #
-        # Set to `nil` to revert to the default paths.
-        #
-        # @param alternate_iso3166_tab_search_path [Object] either `nil` or a
-        #   list of paths to check as either an `Array` of `String` or a
-        #   `File::PATH_SEPARATOR` separated `String`.
-        def alternate_iso3166_tab_search_path=(alternate_iso3166_tab_search_path)
-          @@alternate_iso3166_tab_search_path = process_search_path(alternate_iso3166_tab_search_path, DEFAULT_ALTERNATE_ISO3166_TAB_SEARCH_PATH)
-        end
-
-        private
-
-        # Processes a path for use as the {search_path} or
-        # {alternate_iso3166_tab_search_path}.
-        #
-        # @param path [Object] either `nil` or a list of paths to check as
-        #   either an `Array` of `String` or a `File::PATH_SEPARATOR` separated
-        #   `String`.
-        # @param default [Array<String>] the default value.
-        # @return [Array<String>] the processed path.
-        def process_search_path(path, default)
-          if path
-            if path.kind_of?(String)
-              path.split(File::PATH_SEPARATOR)
-            else
-              path.collect(&:to_s)
-            end
-          else
-            default.dup
-          end
-        end
-      end
-
-      # @return [String] the zoneinfo directory being used.
-      attr_reader :zoneinfo_dir
-
-      # (see DataSource#country_codes)
-      attr_reader :country_codes
-
-      # Initializes a new {ZoneinfoDataSource}.
-      #
-      # If `zoneinfo_dir` is specified, it will be checked and used as the
-      # source of zoneinfo files.
-      #
-      # The directory must contain a file named iso3166.tab and a file named
-      # either zone1970.tab or zone.tab. These may either be included in the
-      # root of the directory or in a 'tab' sub-directory and named country.tab
-      # and zone_sun.tab respectively (as is the case on Solaris).
-      #
-      # Additionally, the path to iso3166.tab can be overridden using the
-      # `alternate_iso3166_tab_path` parameter.
-      #
-      # If `zoneinfo_dir` is not specified or `nil`, the paths referenced in
-      # {search_path} are searched in order to find a valid zoneinfo directory
-      # (one that contains zone1970.tab or zone.tab and iso3166.tab files as
-      # above).
-      #
-      # The paths referenced in {alternate_iso3166_tab_search_path} are also
-      # searched to find an iso3166.tab file if one of the searched zoneinfo
-      # directories doesn't contain an iso3166.tab file.
-      #
-      # @param zoneinfo_dir [String] an optional path to a directory to use as
-      #   the source of zoneinfo files.
-      # @param alternate_iso3166_tab_path [String] an optional path to the
-      #   iso3166.tab file.
-      # @raise [InvalidZoneinfoDirectory] if the iso3166.tab and zone1970.tab or
-      #   zone.tab files cannot be found using the `zoneinfo_dir` and
-      #   `alternate_iso3166_tab_path` parameters.
-      # @raise [ZoneinfoDirectoryNotFound] if no valid directory can be found
-      #   by searching.
-      def initialize(zoneinfo_dir = nil, alternate_iso3166_tab_path = nil)
-        super()
-
-        if zoneinfo_dir
-          iso3166_tab_path, zone_tab_path = validate_zoneinfo_dir(zoneinfo_dir, alternate_iso3166_tab_path)
-
-          unless iso3166_tab_path && zone_tab_path
-            raise InvalidZoneinfoDirectory, "#{zoneinfo_dir} is not a directory or doesn't contain a iso3166.tab file and a zone1970.tab or zone.tab file."
-          end
-
-          @zoneinfo_dir = zoneinfo_dir
-        else
-          @zoneinfo_dir, iso3166_tab_path, zone_tab_path = find_zoneinfo_dir
-
-          unless @zoneinfo_dir && iso3166_tab_path && zone_tab_path
-            raise ZoneinfoDirectoryNotFound, "None of the paths included in #{self.class.name}.search_path are valid zoneinfo directories."
-          end
-        end
-
-        @zoneinfo_dir = File.expand_path(@zoneinfo_dir).freeze
-        @timezone_identifiers = load_timezone_identifiers.freeze
-        @countries = load_countries(iso3166_tab_path, zone_tab_path).freeze
-        @country_codes = @countries.keys.sort!.freeze
-
-        string_deduper = ConcurrentStringDeduper.new
-        posix_tz_parser = PosixTimeZoneParser.new(string_deduper)
-        @zoneinfo_reader = ZoneinfoReader.new(posix_tz_parser, string_deduper)
-      end
-
-      # Returns a frozen `Array` of all the available time zone identifiers. The
-      # identifiers are sorted according to `String#<=>`.
-      #
-      # @return [Array<String>] a frozen `Array` of all the available time zone
-      #   identifiers.
-      def data_timezone_identifiers
-        @timezone_identifiers
-      end
-
-      # Returns an empty `Array`. There is no information about linked/aliased
-      # time zones in the zoneinfo files. When using {ZoneinfoDataSource}, every
-      # time zone will be returned as a {DataTimezone}.
-      #
-      # @return [Array<String>] an empty `Array`.
-      def linked_timezone_identifiers
-        [].freeze
-      end
-
-      # (see DataSource#to_s)
-      def to_s
-        "Zoneinfo DataSource: #{@zoneinfo_dir}"
-      end
-
-      # (see DataSource#inspect)
-      def inspect
-        "#<#{self.class}: #{@zoneinfo_dir}>"
-      end
-
-      protected
-
-      # Returns a {TimezoneInfo} instance for the given time zone identifier.
-      # The result will either be a {ConstantOffsetDataTimezoneInfo} or a
-      # {TransitionsDataTimezoneInfo}.
-      #
-      # @param identifier [String] A time zone identifier.
-      # @return [TimezoneInfo] a {TimezoneInfo} instance for the given time zone
-      #   identifier.
-      # @raise [InvalidTimezoneIdentifier] if the time zone is not found, the
-      #   identifier is invalid, the zoneinfo file cannot be opened or the
-      #   zoneinfo file is not valid.
-      def load_timezone_info(identifier)
-        valid_identifier = validate_timezone_identifier(identifier)
-        path = File.join(@zoneinfo_dir, valid_identifier)
-
-        zoneinfo = begin
-          @zoneinfo_reader.read(path)
-        rescue Errno::EACCES, InvalidZoneinfoFile => e
-          raise InvalidTimezoneIdentifier, "#{e.message.encode(Encoding::UTF_8)} (loading #{valid_identifier})"
-        rescue Errno::EISDIR, Errno::ENAMETOOLONG, Errno::ENOENT, Errno::ENOTDIR
-          raise InvalidTimezoneIdentifier, "Invalid identifier: #{valid_identifier}"
-        end
-
-        if zoneinfo.kind_of?(TimezoneOffset)
-          ConstantOffsetDataTimezoneInfo.new(valid_identifier, zoneinfo)
-        else
-          TransitionsDataTimezoneInfo.new(valid_identifier, zoneinfo)
-        end
-      end
-
-      # (see DataSource#load_country_info)
-      def load_country_info(code)
-        lookup_country_info(@countries, code)
-      end
-
-      private
-
-      # Validates a zoneinfo directory and returns the paths to the iso3166.tab
-      # and zone1970.tab or zone.tab files if valid. If the directory is not
-      # valid, returns `nil`.
-      #
-      # The path to the iso3166.tab file may be overridden by passing in a path.
-      # This is treated as either absolute or relative to the current working
-      # directory.
-      #
-      # @param path [String] the path to a possible zoneinfo directory.
-      # @param iso3166_tab_path [String] an optional path to an external
-      #   iso3166.tab file.
-      # @return [Array<String>] an `Array` containing the iso3166.tab and
-      #   zone.tab paths if the directory is valid, otherwise `nil`.
-      def validate_zoneinfo_dir(path, iso3166_tab_path = nil)
-        if File.directory?(path)
-          if iso3166_tab_path
-            return nil unless File.file?(iso3166_tab_path)
-          else
-            iso3166_tab_path = resolve_tab_path(path, ['iso3166.tab'], 'country.tab')
-            return nil unless iso3166_tab_path
-          end
-
-          zone_tab_path = resolve_tab_path(path, ['zone1970.tab', 'zone.tab'], 'zone_sun.tab')
-          return nil unless zone_tab_path
-
-          [iso3166_tab_path, zone_tab_path]
-        else
-          nil
-        end
-      end
-
-      # Attempts to resolve the path to a tab file given its standard names and
-      # tab sub-directory name (as used on Solaris).
-      #
-      # @param zoneinfo_path [String] the path to a zoneinfo directory.
-      # @param standard_names [Array<String>] the standard names for the tab
-      #   file.
-      # @param tab_name [String] the alternate name for the tab file to check in
-      #   the tab sub-directory.
-      # @return [String] the path to the tab file.
-      def resolve_tab_path(zoneinfo_path, standard_names, tab_name)
-        standard_names.each do |standard_name|
-          path = File.join(zoneinfo_path, standard_name)
-          return path if File.file?(path)
-        end
-
-        path = File.join(zoneinfo_path, 'tab', tab_name)
-        return path if File.file?(path)
-
-        nil
-      end
-
-      # Finds a zoneinfo directory using {search_path} and
-      # {alternate_iso3166_tab_search_path}.
-      #
-      # @return [Array<String>] an `Array` containing the iso3166.tab and
-      #   zone.tab paths if a zoneinfo directory was found, otherwise `nil`.
-      def find_zoneinfo_dir
-        alternate_iso3166_tab_path = self.class.alternate_iso3166_tab_search_path.detect do |path|
-          File.file?(path)
-        end
-
-        self.class.search_path.each do |path|
-          # Try without the alternate_iso3166_tab_path first.
-          iso3166_tab_path, zone_tab_path = validate_zoneinfo_dir(path)
-          return path, iso3166_tab_path, zone_tab_path if iso3166_tab_path && zone_tab_path
-
-          if alternate_iso3166_tab_path
-            iso3166_tab_path, zone_tab_path = validate_zoneinfo_dir(path, alternate_iso3166_tab_path)
-            return path, iso3166_tab_path, zone_tab_path if iso3166_tab_path && zone_tab_path
-          end
-        end
-
-        # Not found.
-        nil
-      end
-
-      # Scans @zoneinfo_dir and returns an `Array` of available time zone
-      # identifiers. The result is sorted according to `String#<=>`.
-      #
-      # @return [Array<String>] an `Array` containing all the time zone
-      #   identifiers found.
-      def load_timezone_identifiers
-        index = []
-
-        enum_timezones([], EXCLUDED_FILENAMES) do |identifier|
-          index << identifier.join('/').freeze
-        end
-
-        index.sort!
-      end
-
-      # Recursively enumerate a directory of time zones.
-      #
-      # @param dir [Array<String>] the directory to enumerate as an `Array` of
-      #   path components.
-      # @param exclude [Array<String>] file names to exclude when scanning
-      #   `dir`.
-      # @yield [path] the path of each time zone file found is passed to
-      #   the block.
-      # @yieldparam path [Array<String>] the path of a time zone file as an
-      #   `Array` of path components.
-      def enum_timezones(dir, exclude = [], &block)
-        Dir.foreach(File.join(@zoneinfo_dir, *dir)) do |entry|
-          begin
-            entry.encode!(Encoding::UTF_8)
-          rescue EncodingError
-            next
-          end
-
-          unless entry =~ /\./ || exclude.include?(entry)
-            entry.untaint
-            path = dir + [entry]
-            full_path = File.join(@zoneinfo_dir, *path)
-
-            if File.directory?(full_path)
-              enum_timezones(path, [], &block)
-            elsif File.file?(full_path)
-              yield path
-            end
-          end
-        end
-      end
-
-      # Uses the iso3166.tab and zone1970.tab or zone.tab files to return a Hash
-      # mapping country codes to CountryInfo instances.
-      #
-      # @param iso3166_tab_path [String] the path to the iso3166.tab file.
-      # @param zone_tab_path [String] the path to the zone.tab file.
-      # @return [Hash<String, CountryInfo>] a mapping from ISO 3166-1 alpha-2
-      #   country codes to {CountryInfo} instances.
-      def load_countries(iso3166_tab_path, zone_tab_path)
-
-        # Handle standard 3 to 4 column zone.tab files as well as the 4 to 5
-        # column format used by Solaris.
-        #
-        # On Solaris, an extra column before the comment gives an optional
-        # linked/alternate timezone identifier (or '-' if not set).
-        #
-        # Additionally, there is a section at the end of the file for timezones
-        # covering regions. These are given lower-case "country" codes. The timezone
-        # identifier column refers to a continent instead of an identifier. These
-        # lines will be ignored by TZInfo.
-        #
-        # Since the last column is optional in both formats, testing for the
-        # Solaris format is done in two passes. The first pass identifies if there
-        # are any lines using 5 columns.
-
-
-        # The first column is allowed to be a comma separated list of country
-        # codes, as used in zone1970.tab (introduced in tzdata 2014f).
-        #
-        # The first country code in the comma-separated list is the country that
-        # contains the city the zone identifier is based on. The first country
-        # code on each line is considered to be primary with the others
-        # secondary.
-        #
-        # The zones for each country are ordered primary first, then secondary.
-        # Within the primary and secondary groups, the zones are ordered by their
-        # order in the file.
-
-        file_is_5_column = false
-        zone_tab = []
-
-        file = File.read(zone_tab_path, external_encoding: Encoding::UTF_8, internal_encoding: Encoding::UTF_8)
-        file.each_line do |line|
-          line.chomp!
-
-          if line =~ /\A([A-Z]{2}(?:,[A-Z]{2})*)\t(?:([+\-])(\d{2})(\d{2})([+\-])(\d{3})(\d{2})|([+\-])(\d{2})(\d{2})(\d{2})([+\-])(\d{3})(\d{2})(\d{2}))\t([^\t]+)(?:\t([^\t]+))?(?:\t([^\t]+))?\z/
-            codes = $1
-
-            if $2
-              latitude = dms_to_rational($2, $3, $4)
-              longitude = dms_to_rational($5, $6, $7)
-            else
-              latitude = dms_to_rational($8, $9, $10, $11)
-              longitude = dms_to_rational($12, $13, $14, $15)
-            end
-
-            zone_identifier = $16
-            column4 = $17
-            column5 = $18
-
-            file_is_5_column = true if column5
-
-            zone_tab << [codes.split(','.freeze), zone_identifier, latitude, longitude, column4, column5]
-          end
-        end
-
-        string_deduper = StringDeduper.new
-        primary_zones = {}
-        secondary_zones = {}
-
-        zone_tab.each do |codes, zone_identifier, latitude, longitude, column4, column5|
-          description = file_is_5_column ? column5 : column4
-          description = string_deduper.dedupe(description) if description
-
-          # Lookup the identifier in the timezone index, so that the same
-          # String instance can be used (saving memory).
-          begin
-            zone_identifier = validate_timezone_identifier(zone_identifier)
-          rescue InvalidTimezoneIdentifier
-            # zone_identifier is not valid, dedupe and allow anyway.
-            zone_identifier = string_deduper.dedupe(zone_identifier)
-          end
-
-          country_timezone = CountryTimezone.new(zone_identifier, latitude, longitude, description)
-
-          # codes will always have at least one element
-
-          (primary_zones[codes.first.freeze] ||= []) << country_timezone
-
-          codes[1..-1].each do |code|
-            (secondary_zones[code.freeze] ||= []) << country_timezone
-          end
-        end
-
-        countries = {}
-
-        file = File.read(iso3166_tab_path, external_encoding: Encoding::UTF_8, internal_encoding: Encoding::UTF_8)
-        file.each_line do |line|
-          line.chomp!
-
-          # Handle both the two column alpha-2 and name format used in the tz
-          # database as well as the 4 column alpha-2, alpha-3, numeric-3 and
-          # name format used by FreeBSD and OpenBSD.
-
-          if line =~ /\A([A-Z]{2})(?:\t[A-Z]{3}\t[0-9]{3})?\t(.+)\z/
-            code = $1
-            name = $2
-            zones = (primary_zones[code] || []) + (secondary_zones[code] || [])
-
-            countries[code] = CountryInfo.new(code, name, zones)
-          end
-        end
-
-        countries
-      end
-
-      # Converts degrees, minutes and seconds to a Rational.
-      #
-      # @param sign [String] `'-'` or `'+'`.
-      # @param degrees [String] the number of degrees.
-      # @param minutes [String] the number of minutes.
-      # @param seconds [String] the number of seconds (optional).
-      # @return [Rational] the result of converting from degrees, minutes and
-      #   seconds to a `Rational`.
-      def dms_to_rational(sign, degrees, minutes, seconds = nil)
-        degrees = degrees.to_i
-        minutes = minutes.to_i
-        sign = sign == '-'.freeze ? -1 : 1
-
-        if seconds
-          Rational(sign * (degrees * 3600 + minutes * 60 + seconds.to_i), 3600)
-        else
-          Rational(sign * (degrees * 60 + minutes), 60)
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/zoneinfo_reader.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/zoneinfo_reader.rb
deleted file mode 100644
index ac82585c13d01..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_sources/zoneinfo_reader.rb
+++ /dev/null
@@ -1,486 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # Use send as a workaround for erroneous 'wrong number of arguments' errors
-  # with JRuby 9.0.5.0 when calling methods with Java implementations. See #114.
-  send(:using, UntaintExt) if TZInfo.const_defined?(:UntaintExt)
-
-  module DataSources
-    # An {InvalidZoneinfoFile} exception is raised if an attempt is made to load
-    # an invalid zoneinfo file.
-    class InvalidZoneinfoFile < StandardError
-    end
-
-    # Reads compiled zoneinfo TZif (\0, 2 or 3) files.
-    class ZoneinfoReader #:nodoc:
-      # The year to generate transitions up to.
-      #
-      # @private
-      GENERATE_UP_TO = Time.now.utc.year + 100
-      private_constant :GENERATE_UP_TO
-
-      # Initializes a new {ZoneinfoReader}.
-      #
-      # @param posix_tz_parser [PosixTimeZoneParser] a {PosixTimeZoneParser}
-      #   instance to use to parse POSIX-style TZ strings.
-      # @param string_deduper [StringDeduper] a {StringDeduper} instance to use
-      #   to dedupe abbreviations.
-      def initialize(posix_tz_parser, string_deduper)
-        @posix_tz_parser = posix_tz_parser
-        @string_deduper = string_deduper
-      end
-
-      # Reads a zoneinfo structure from the given path. Returns either a
-      # {TimezoneOffset} that is constantly observed or an `Array`
-      # {TimezoneTransition}s.
-      #
-      # @param file_path [String] the path of a zoneinfo file.
-      # @return [Object] either a {TimezoneOffset} or an `Array` of
-      #   {TimezoneTransition}s.
-      # @raise [SecurityError] if safe mode is enabled and `file_path` is
-      #   tainted.
-      # @raise [InvalidZoneinfoFile] if `file_path`` does not refer to a valid
-      #   zoneinfo file.
-      def read(file_path)
-        File.open(file_path, 'rb') { |file| parse(file) }
-      end
-
-      private
-
-      # Translates an unsigned 32-bit integer (as returned by unpack) to signed
-      # 32-bit.
-      #
-      # @param long [Integer] an unsigned 32-bit integer.
-      # @return [Integer] {long} translated to signed 32-bit.
-      def make_signed_int32(long)
-        long >= 0x80000000 ? long - 0x100000000 : long
-      end
-
-      # Translates a pair of unsigned 32-bit integers (as returned by unpack,
-      # most significant first) to a signed 64-bit integer.
-      #
-      # @param high [Integer] the most significant 32-bits.
-      # @param low [Integer] the least significant 32-bits.
-      # @return [Integer] {high} and {low} combined and translated to signed
-      #   64-bit.
-      def make_signed_int64(high, low)
-        unsigned = (high << 32) | low
-        unsigned >= 0x8000000000000000 ? unsigned - 0x10000000000000000 : unsigned
-      end
-
-      # Reads the given number of bytes from the given file and checks that the
-      # correct number of bytes could be read.
-      #
-      # @param file [IO] the file to read from.
-      # @param bytes [Integer] the number of bytes to read.
-      # @return [String] the bytes that were read.
-      # @raise [InvalidZoneinfoFile] if the number of bytes available didn't
-      #   match the number requested.
-      def check_read(file, bytes)
-        result = file.read(bytes)
-
-        unless result && result.length == bytes
-          raise InvalidZoneinfoFile, "Expected #{bytes} bytes reading '#{file.path}', but got #{result ? result.length : 0} bytes"
-        end
-
-        result
-      end
-
-      # Zoneinfo files don't include the offset from standard time (std_offset)
-      # for DST periods. Derive the base offset (base_utc_offset) where DST is
-      # observed from either the previous or next non-DST period.
-      #
-      # @param transitions [Array<Hash>] an `Array` of transition hashes.
-      # @param offsets [Array<Hash>] an `Array` of offset hashes.
-      # @return [Integer] the index of the offset to be used prior to the first
-      #   transition.
-      def derive_offsets(transitions, offsets)
-        # The first non-DST offset (if there is one) is the offset observed
-        # before the first transition. Fall back to the first DST offset if
-        # there are no non-DST offsets.
-        first_non_dst_offset_index = offsets.index {|o| !o[:is_dst] }
-        first_offset_index = first_non_dst_offset_index || 0
-        return first_offset_index if transitions.empty?
-
-        # Determine the base_utc_offset of the next non-dst offset at each transition.
-        base_utc_offset_from_next = nil
-
-        transitions.reverse_each do |transition|
-          offset = offsets[transition[:offset]]
-          if offset[:is_dst]
-            transition[:base_utc_offset_from_next] = base_utc_offset_from_next if base_utc_offset_from_next
-          else
-            base_utc_offset_from_next = offset[:observed_utc_offset]
-          end
-        end
-
-        base_utc_offset_from_previous = first_non_dst_offset_index ? offsets[first_non_dst_offset_index][:observed_utc_offset] : nil
-        defined_offsets = {}
-
-        transitions.each do |transition|
-          offset_index = transition[:offset]
-          offset = offsets[offset_index]
-          observed_utc_offset = offset[:observed_utc_offset]
-
-          if offset[:is_dst]
-            base_utc_offset_from_next = transition[:base_utc_offset_from_next]
-
-            difference_to_previous = (observed_utc_offset - (base_utc_offset_from_previous || observed_utc_offset)).abs
-            difference_to_next = (observed_utc_offset - (base_utc_offset_from_next || observed_utc_offset)).abs
-
-            base_utc_offset = if difference_to_previous == 3600
-              base_utc_offset_from_previous
-            elsif difference_to_next == 3600
-              base_utc_offset_from_next
-            elsif difference_to_previous > 0 && difference_to_next > 0
-              difference_to_previous < difference_to_next ? base_utc_offset_from_previous : base_utc_offset_from_next
-            elsif difference_to_previous > 0
-              base_utc_offset_from_previous
-            elsif difference_to_next > 0
-              base_utc_offset_from_next
-            else
-              # No difference, assume a 1 hour offset from standard time.
-              observed_utc_offset - 3600
-            end
-
-            if !offset[:base_utc_offset]
-              offset[:base_utc_offset] = base_utc_offset
-              defined_offsets[offset] = offset_index
-            elsif offset[:base_utc_offset] != base_utc_offset
-              # An earlier transition has already derived a different
-              # base_utc_offset. Define a new offset or reuse an existing identically
-              # defined offset.
-              new_offset = offset.dup
-              new_offset[:base_utc_offset] = base_utc_offset
-
-              offset_index = defined_offsets[new_offset]
-
-              unless offset_index
-                offsets << new_offset
-                offset_index = offsets.length - 1
-                defined_offsets[new_offset] = offset_index
-              end
-
-              transition[:offset] = offset_index
-            end
-          else
-            base_utc_offset_from_previous = observed_utc_offset
-          end
-        end
-
-        first_offset_index
-      end
-
-      # Determines if the offset from a transition matches the offset from a
-      # rule. This is a looser match than equality, not requiring that the
-      # base_utc_offset and std_offset both match (which have to be derived for
-      # transitions, but are known for rules.
-      #
-      # @param offset [TimezoneOffset] an offset from a transition.
-      # @param rule_offset [TimezoneOffset] an offset from a rule.
-      # @return [Boolean] whether the offsets match.
-      def offset_matches_rule?(offset, rule_offset)
-        offset.observed_utc_offset == rule_offset.observed_utc_offset &&
-          offset.dst? == rule_offset.dst? &&
-          offset.abbreviation == rule_offset.abbreviation
-      end
-
-      # Apply the rules from the TZ string when there were no defined
-      # transitions. Checks for a matching offset. Returns the rules-based
-      # constant offset or generates transitions from 1970 until 100 years into
-      # the future (at the time of loading zoneinfo_reader.rb).
-      #
-      # @param file [IO] the file being processed.
-      # @param first_offset [TimezoneOffset] the first offset included in the
-      #   file that would normally apply without the rules.
-      # @param rules [Object] a {TimezoneOffset} specifying a constant offset or
-      #   {AnnualRules} instance specfying transitions.
-      # @return [Object] either a {TimezoneOffset} or an `Array` of
-      #   {TimezoneTransition}s.
-      # @raise [InvalidZoneinfoFile] if the first offset does not match the
-      #   rules.
-      def apply_rules_without_transitions(file, first_offset, rules)
-        if rules.kind_of?(TimezoneOffset)
-          unless offset_matches_rule?(first_offset, rules)
-            raise InvalidZoneinfoFile, "Constant offset POSIX-style TZ string does not match constant offset in file '#{file.path}'."
-          end
-          rules
-        else
-          transitions = 1970.upto(GENERATE_UP_TO).flat_map {|y| rules.transitions(y) }
-          first_transition = transitions[0]
-
-          unless offset_matches_rule?(first_offset, first_transition.previous_offset)
-            # Not transitioning from the designated first offset.
-
-            if offset_matches_rule?(first_offset, first_transition.offset)
-              # Skip an unnecessary transition to the first offset.
-              transitions.shift
-            else
-              # The initial offset doesn't match the ongoing rules. Replace the
-              # previous offset of the first transition.
-              transitions[0] = TimezoneTransition.new(first_transition.offset, first_offset, first_transition.timestamp_value)
-            end
-          end
-
-          transitions
-        end
-      end
-
-      # Finds an offset that is equivalent to the one specified in the given
-      # `Array`. Matching is performed with {TimezoneOffset#==}.
-      #
-      # @param offsets [Array<TimezoneOffset>] an `Array` to search.
-      # @param offset [TimezoneOffset] the offset to search for.
-      # @return [TimezoneOffset] the matching offset from `offsets` or `nil`
-      #   if not found.
-      def find_existing_offset(offsets, offset)
-        offsets.find {|o| o == offset }
-      end
-
-      # Returns a new AnnualRules instance with standard and daylight savings
-      # offsets replaced with equivalents from an array. This reduces the memory
-      # requirement for loaded time zones by reusing offsets for rule-generated
-      # transitions.
-      #
-      # @param offsets [Array<TimezoneOffset>] an `Array` to search for
-      #   equivalent offsets.
-      # @param annual_rules [AnnualRules] the {AnnualRules} instance to check.
-      # @return [AnnualRules] either a new {AnnualRules} instance with either
-      #   the {AnnualRules#std_offset std_offset} or {AnnualRules#dst_offset
-      #   dst_offset} replaced, or the original instance if no equivalent for
-      #   either {AnnualRules#std_offset std_offset} or {AnnualRules#dst_offset
-      #   dst_offset} could be found.
-      def replace_with_existing_offsets(offsets, annual_rules)
-        existing_std_offset = find_existing_offset(offsets, annual_rules.std_offset)
-        existing_dst_offset = find_existing_offset(offsets, annual_rules.dst_offset)
-        if existing_std_offset || existing_dst_offset
-          AnnualRules.new(existing_std_offset || annual_rules.std_offset, existing_dst_offset || annual_rules.dst_offset,
-            annual_rules.dst_start_rule, annual_rules.dst_end_rule)
-        else
-          annual_rules
-        end
-      end
-
-      # Validates the offset indicated to be observed by the rules before the
-      # first generated transition against the offset of the last defined
-      # transition.
-      #
-      # Fix the last defined transition if it differ on just base/std offsets
-      # (which are derived). Raise an error if the observed UTC offset or
-      # abbreviations differ.
-      #
-      # @param file [IO] the file being processed.
-      # @param last_defined [TimezoneTransition] the last defined transition in
-      #   the file.
-      # @param first_rule_offset [TimezoneOffset] the offset the rules indicate
-      #   is observed prior to the first rules generated transition.
-      # @return [TimezoneTransition] the last defined transition (either the
-      #   original instance or a replacement).
-      # @raise [InvalidZoneinfoFile] if the offset of {last_defined} and
-      #   {first_rule_offset} do not match.
-      def validate_and_fix_last_defined_transition_offset(file, last_defined, first_rule_offset)
-        offset_of_last_defined = last_defined.offset
-
-        if offset_of_last_defined == first_rule_offset
-          last_defined
-        else
-          if offset_matches_rule?(offset_of_last_defined, first_rule_offset)
-            # The same overall offset, but differing in the base or std
-            # offset (which are derived). Correct by using the rule.
-            TimezoneTransition.new(first_rule_offset, last_defined.previous_offset, last_defined.timestamp_value)
-          else
-            raise InvalidZoneinfoFile, "The first offset indicated by the POSIX-style TZ string did not match the final defined offset in file '#{file.path}'."
-          end
-        end
-      end
-
-      # Apply the rules from the TZ string when there were defined
-      # transitions. Checks for a matching offset with the last transition.
-      # Redefines the last transition if required and if the rules don't
-      # specific a constant offset, generates transitions until 100 years into
-      # the future (at the time of loading zoneinfo_reader.rb).
-      #
-      # @param file [IO] the file being processed.
-      # @param transitions [Array<TimezoneTransition>] the defined transitions.
-      # @param offsets [Array<TimezoneOffset>] the offsets used by the defined
-      #   transitions.
-      # @param rules [Object] a {TimezoneOffset} specifying a constant offset or
-      #   {AnnualRules} instance specfying transitions.
-      # @raise [InvalidZoneinfoFile] if the first offset does not match the
-      #   rules.
-      # @raise [InvalidZoneinfoFile] if the previous offset of the first
-      #   generated transition does not match the offset of the last defined
-      #   transition.
-      def apply_rules_with_transitions(file, transitions, offsets, rules)
-        last_defined = transitions[-1]
-
-        if rules.kind_of?(TimezoneOffset)
-          transitions[-1] = validate_and_fix_last_defined_transition_offset(file, last_defined, rules)
-        else
-          last_year = last_defined.local_end_at.to_time.year
-
-          if last_year <= GENERATE_UP_TO
-            rules = replace_with_existing_offsets(offsets, rules)
-
-            generated = rules.transitions(last_year).find_all do |t|
-              t.timestamp_value > last_defined.timestamp_value && !offset_matches_rule?(last_defined.offset, t.offset)
-            end
-
-            generated += (last_year + 1).upto(GENERATE_UP_TO).flat_map {|y| rules.transitions(y) }
-
-            unless generated.empty?
-              transitions[-1] = validate_and_fix_last_defined_transition_offset(file, last_defined, generated[0].previous_offset)
-              transitions.concat(generated)
-            end
-          end
-        end
-      end
-
-      # Parses a zoneinfo file and returns either a {TimezoneOffset} that is
-      # constantly observed or an `Array` of {TimezoneTransition}s.
-      #
-      # @param file [IO] the file to be read.
-      # @return [Object] either a {TimezoneOffset} or an `Array` of
-      #   {TimezoneTransition}s.
-      # @raise [InvalidZoneinfoFile] if the file is not a valid zoneinfo file.
-      def parse(file)
-        magic, version, ttisutccnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt =
-          check_read(file, 44).unpack('a4 a x15 NNNNNN')
-
-        if magic != 'TZif'
-          raise InvalidZoneinfoFile, "The file '#{file.path}' does not start with the expected header."
-        end
-
-        if version == '2' || version == '3'
-          # Skip the first 32-bit section and read the header of the second 64-bit section
-          file.seek(timecnt * 5 + typecnt * 6 + charcnt + leapcnt * 8 + ttisstdcnt + ttisutccnt, IO::SEEK_CUR)
-
-          prev_version = version
-
-          magic, version, ttisutccnt, ttisstdcnt, leapcnt, timecnt, typecnt, charcnt =
-            check_read(file, 44).unpack('a4 a x15 NNNNNN')
-
-          unless magic == 'TZif' && (version == prev_version)
-            raise InvalidZoneinfoFile, "The file '#{file.path}' contains an invalid 64-bit section header."
-          end
-
-          using_64bit = true
-        elsif version != '3' && version != '2' && version != "\0"
-          raise InvalidZoneinfoFile, "The file '#{file.path}' contains a version of the zoneinfo format that is not currently supported."
-        else
-          using_64bit = false
-        end
-
-        unless leapcnt == 0
-          raise InvalidZoneinfoFile, "The file '#{file.path}' contains leap second data. TZInfo requires zoneinfo files that omit leap seconds."
-        end
-
-        transitions = if using_64bit
-          timecnt.times.map do |i|
-            high, low = check_read(file, 8).unpack('NN'.freeze)
-            transition_time = make_signed_int64(high, low)
-            {at: transition_time}
-          end
-        else
-          timecnt.times.map do |i|
-            transition_time = make_signed_int32(check_read(file, 4).unpack('N'.freeze)[0])
-            {at: transition_time}
-          end
-        end
-
-        check_read(file, timecnt).unpack('C*'.freeze).each_with_index do |localtime_type, i|
-          raise InvalidZoneinfoFile, "Invalid offset referenced by transition in file '#{file.path}'." if localtime_type >= typecnt
-          transitions[i][:offset] = localtime_type
-        end
-
-        offsets = typecnt.times.map do |i|
-          gmtoff, isdst, abbrind = check_read(file, 6).unpack('NCC'.freeze)
-          gmtoff = make_signed_int32(gmtoff)
-          isdst = isdst == 1
-          {observed_utc_offset: gmtoff, is_dst: isdst, abbr_index: abbrind}
-        end
-
-        abbrev = check_read(file, charcnt)
-
-        if using_64bit
-          # Skip to the POSIX-style TZ string.
-          file.seek(ttisstdcnt + ttisutccnt, IO::SEEK_CUR) # + leapcnt * 8, but leapcnt is checked above and guaranteed to be 0.
-          tz_string_start = check_read(file, 1)
-          raise InvalidZoneinfoFile, "Expected newline starting POSIX-style TZ string in file '#{file.path}'." unless tz_string_start == "\n"
-          tz_string = file.readline("\n").force_encoding(Encoding::UTF_8)
-          raise InvalidZoneinfoFile, "Expected newline ending POSIX-style TZ string in file '#{file.path}'." unless tz_string.chomp!("\n")
-
-          begin
-            rules = @posix_tz_parser.parse(tz_string)
-          rescue InvalidPosixTimeZone => e
-            raise InvalidZoneinfoFile, "Failed to parse POSIX-style TZ string in file '#{file.path}': #{e}"
-          end
-        else
-          rules = nil
-        end
-
-        # Derive the offsets from standard time (std_offset).
-        first_offset_index = derive_offsets(transitions, offsets)
-
-        offsets = offsets.map do |o|
-          observed_utc_offset = o[:observed_utc_offset]
-          base_utc_offset = o[:base_utc_offset]
-
-          if base_utc_offset
-            # DST offset with base_utc_offset derived by derive_offsets.
-            std_offset = observed_utc_offset - base_utc_offset
-          elsif o[:is_dst]
-            # DST offset unreferenced by a transition (offset in use before the
-            # first transition). No derived base UTC offset, so assume 1 hour
-            # DST.
-            base_utc_offset = observed_utc_offset - 3600
-            std_offset = 3600
-          else
-            # Non-DST offset.
-            base_utc_offset = observed_utc_offset
-            std_offset = 0
-          end
-
-          abbrev_start = o[:abbr_index]
-          raise InvalidZoneinfoFile, "Abbreviation index is out of range in file '#{file.path}'." unless abbrev_start < abbrev.length
-
-          abbrev_end = abbrev.index("\0", abbrev_start)
-          raise InvalidZoneinfoFile, "Missing abbreviation null terminator in file '#{file.path}'." unless abbrev_end
-
-          abbr = @string_deduper.dedupe(abbrev[abbrev_start...abbrev_end].force_encoding(Encoding::UTF_8).untaint)
-
-          TimezoneOffset.new(base_utc_offset, std_offset, abbr)
-        end
-
-        first_offset = offsets[first_offset_index]
-
-
-        if transitions.empty?
-          if rules
-            apply_rules_without_transitions(file, first_offset, rules)
-          else
-            first_offset
-          end
-        else
-          previous_offset = first_offset
-          previous_at = nil
-
-          transitions = transitions.map do |t|
-            offset = offsets[t[:offset]]
-            at = t[:at]
-            raise InvalidZoneinfoFile, "Transition at #{at} is not later than the previous transition at #{previous_at} in file '#{file.path}'." if previous_at && previous_at >= at
-            tt = TimezoneTransition.new(offset, previous_offset, at)
-            previous_offset = offset
-            previous_at = at
-            tt
-          end
-
-          apply_rules_with_transitions(file, transitions, offsets, rules) if rules
-          transitions
-        end
-      end
-    end
-    private_constant :ZoneinfoReader
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_timezone.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_timezone.rb
deleted file mode 100644
index a7c60d9c7a612..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/data_timezone.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # Represents time zones that are defined by rules that set out when
-  # transitions occur.
-  class DataTimezone < InfoTimezone
-    # (see Timezone#period_for)
-    def period_for(time)
-      raise ArgumentError, 'time must be specified' unless time
-      timestamp = Timestamp.for(time)
-      raise ArgumentError, 'time must have a specified utc_offset' unless timestamp.utc_offset
-      info.period_for(timestamp)
-    end
-
-    # (see Timezone#periods_for_local)
-    def periods_for_local(local_time)
-      raise ArgumentError, 'local_time must be specified' unless local_time
-      info.periods_for_local(Timestamp.for(local_time, :ignore))
-    end
-
-    # (see Timezone#transitions_up_to)
-    def transitions_up_to(to, from = nil)
-      raise ArgumentError, 'to must be specified' unless to
-      to_timestamp = Timestamp.for(to)
-      from_timestamp = from && Timestamp.for(from)
-
-      begin
-        info.transitions_up_to(to_timestamp, from_timestamp)
-      rescue ArgumentError => e
-        raise ArgumentError, e.message.gsub('_timestamp', '')
-      end
-    end
-
-    # Returns the canonical {Timezone} instance for this {DataTimezone}.
-    #
-    # For a {DataTimezone}, this is always `self`.
-    #
-    # @return [Timezone] `self`.
-    def canonical_zone
-      self
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/datetime_with_offset.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/datetime_with_offset.rb
deleted file mode 100644
index 63c4bedcbe9b1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/datetime_with_offset.rb
+++ /dev/null
@@ -1,153 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-require 'date'
-
-module TZInfo
-  # A subclass of `DateTime` used to represent local times. {DateTimeWithOffset}
-  # holds a reference to the related {TimezoneOffset} and overrides various
-  # methods to return results appropriate for the {TimezoneOffset}. Certain
-  # operations will clear the associated {TimezoneOffset} (if the
-  # {TimezoneOffset} would not necessarily be valid for the result). Once the
-  # {TimezoneOffset} has been cleared, {DateTimeWithOffset} behaves identically
-  # to `DateTime`.
-  #
-  # Arithmetic performed on {DateTimeWithOffset} instances is _not_ time
-  # zone-aware. Regardless of whether transitions in the time zone are crossed,
-  # results of arithmetic operations will always maintain the same offset from
-  # UTC (`offset`). The associated {TimezoneOffset} will aways be cleared.
-  class DateTimeWithOffset < DateTime
-    include WithOffset
-
-    # @return [TimezoneOffset] the {TimezoneOffset} associated with this
-    #   instance.
-    attr_reader :timezone_offset
-
-    # Sets the associated {TimezoneOffset}.
-    #
-    # @param timezone_offset [TimezoneOffset] a {TimezoneOffset} valid at the
-    #   time and for the offset of this {DateTimeWithOffset}.
-    # @return [DateTimeWithOffset] `self`.
-    # @raise [ArgumentError] if `timezone_offset` is `nil`.
-    # @raise [ArgumentError] if `timezone_offset.observed_utc_offset` does not
-    #   equal `self.offset * 86400`.
-    def set_timezone_offset(timezone_offset)
-      raise ArgumentError, 'timezone_offset must be specified' unless timezone_offset
-      raise ArgumentError, 'timezone_offset.observed_utc_offset does not match self.utc_offset' if offset * 86400 != timezone_offset.observed_utc_offset
-      @timezone_offset = timezone_offset
-      self
-    end
-
-    # An overridden version of `DateTime#to_time` that, if there is an
-    # associated {TimezoneOffset}, returns a {DateTimeWithOffset} with that
-    # offset.
-    #
-    # @return [Time] if there is an associated {TimezoneOffset}, a
-    #   {TimeWithOffset} representation of this {DateTimeWithOffset}, otherwise
-    #   a `Time` representation.
-    def to_time
-      if_timezone_offset(super) do |o,t|
-        # Ruby 2.4.0 changed the behaviour of to_time so that it preserves the
-        # offset instead of converting to the system local timezone.
-        #
-        # When self has an associated TimezonePeriod, this implementation will
-        # preserve the offset on all versions of Ruby.
-        TimeWithOffset.at(t.to_i, t.subsec * 1_000_000).set_timezone_offset(o)
-      end
-    end
-
-    # An overridden version of `DateTime#downto` that clears the associated
-    # {TimezoneOffset} of the returned or yielded instances.
-    def downto(min)
-      if block_given?
-        super {|dt| yield dt.clear_timezone_offset }
-      else
-        enum = super
-        enum.each {|dt| dt.clear_timezone_offset }
-        enum
-      end
-    end
-
-    # An overridden version of `DateTime#england` that preserves the associated
-    # {TimezoneOffset}.
-    #
-    # @return [DateTime]
-    def england
-      # super doesn't call #new_start on MRI, so each method has to be
-      # individually overridden.
-      if_timezone_offset(super) {|o,dt| dt.set_timezone_offset(o) }
-    end
-
-    # An overridden version of `DateTime#gregorian` that preserves the
-    # associated {TimezoneOffset}.
-    #
-    # @return [DateTime]
-    def gregorian
-      # super doesn't call #new_start on MRI, so each method has to be
-      # individually overridden.
-      if_timezone_offset(super) {|o,dt| dt.set_timezone_offset(o) }
-    end
-
-    # An overridden version of `DateTime#italy` that preserves the associated
-    # {TimezoneOffset}.
-    #
-    # @return [DateTime]
-    def italy
-      # super doesn't call #new_start on MRI, so each method has to be
-      # individually overridden.
-      if_timezone_offset(super) {|o,dt| dt.set_timezone_offset(o) }
-    end
-
-    # An overridden version of `DateTime#julian` that preserves the associated
-    # {TimezoneOffset}.
-    #
-    # @return [DateTime]
-    def julian
-      # super doesn't call #new_start on MRI, so each method has to be
-      # individually overridden.
-      if_timezone_offset(super) {|o,dt| dt.set_timezone_offset(o) }
-    end
-
-    # An overridden version of `DateTime#new_start` that preserves the
-    # associated {TimezoneOffset}.
-    #
-    # @return [DateTime]
-    def new_start(start = Date::ITALY)
-      if_timezone_offset(super) {|o,dt| dt.set_timezone_offset(o) }
-    end
-
-    # An overridden version of `DateTime#step` that clears the associated
-    # {TimezoneOffset} of the returned or yielded instances.
-    def step(limit, step = 1)
-      if block_given?
-        super {|dt| yield dt.clear_timezone_offset }
-      else
-        enum = super
-        enum.each {|dt| dt.clear_timezone_offset }
-        enum
-      end
-    end
-
-    # An overridden version of `DateTime#upto` that clears the associated
-    # {TimezoneOffset} of the returned or yielded instances.
-    def upto(max)
-      if block_given?
-        super {|dt| yield dt.clear_timezone_offset }
-      else
-        enum = super
-        enum.each {|dt| dt.clear_timezone_offset }
-        enum
-      end
-    end
-
-    protected
-
-    # Clears the associated {TimezoneOffset}.
-    #
-    # @return [DateTimeWithOffset] `self`.
-    def clear_timezone_offset
-      @timezone_offset = nil
-      self
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1.rb
deleted file mode 100644
index ff3a2eb24d196..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  # Modules and classes used by the format 1 version of TZInfo::Data.
-  #
-  # @private
-  module Format1 #:nodoc:
-  end
-  private_constant :Format1
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/country_definer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/country_definer.rb
deleted file mode 100644
index 67bf044b7f5e7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/country_definer.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  module Format1
-    # Instances of {Format1::CountryDefiner} are yielded to the format 1 version
-    # of `TZInfo::Data::Indexes::Countries` by {CountryIndexDefinition} to allow
-    # the zones of a country to be specified.
-    #
-    # @private
-    class CountryDefiner < Format2::CountryDefiner #:nodoc:
-      # Initializes a new {CountryDefiner}.
-      def initialize(identifier_deduper, description_deduper)
-        super(nil, identifier_deduper, description_deduper)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/country_index_definition.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/country_index_definition.rb
deleted file mode 100644
index 040ed24975091..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/country_index_definition.rb
+++ /dev/null
@@ -1,64 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  module Format1
-    # The format 1 TZInfo::Data country index file includes
-    # {Format1::CountryIndexDefinition}, which provides a
-    # {CountryIndexDefinition::ClassMethods#country country} method used to
-    # define each country in the index.
-    #
-    # @private
-    module CountryIndexDefinition #:nodoc:
-      # Adds class methods to the includee and initializes class instance
-      # variables.
-      #
-      # @param base [Module] the includee.
-      def self.append_features(base)
-        super
-        base.extend(ClassMethods)
-        base.instance_eval { @countries = {} }
-      end
-
-      # Class methods for inclusion.
-      #
-      # @private
-      module ClassMethods #:nodoc:
-        # @return [Hash<String, DataSources::CountryInfo>] a frozen `Hash`
-        #   of all the countries that have been defined in the index keyed by
-        #   their codes.
-        def countries
-          @description_deduper = nil
-          @countries.freeze
-        end
-
-        private
-
-        # Defines a country with an ISO 3166-1 alpha-2 country code and name.
-        #
-        # @param code [String] the ISO 3166-1 alpha-2 country code.
-        # @param name [String] the name of the country.
-        # @yield [definer] (optional) to obtain the time zones for the country.
-        # @yieldparam definer [CountryDefiner] a {CountryDefiner} instance.
-        def country(code, name)
-          @description_deduper ||= StringDeduper.new
-
-          zones = if block_given?
-            definer = CountryDefiner.new(StringDeduper.global, @description_deduper)
-            yield definer
-            definer.timezones
-          else
-            []
-          end
-
-          @countries[code.freeze] = DataSources::CountryInfo.new(code, name, zones)
-        end
-      end
-    end
-  end
-
-  # Alias used by TZInfo::Data format1 releases.
-  #
-  # @private
-  CountryIndexDefinition = Format1::CountryIndexDefinition #:nodoc:
-  private_constant :CountryIndexDefinition
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/timezone_definer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/timezone_definer.rb
deleted file mode 100644
index 578e4ea864f46..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/timezone_definer.rb
+++ /dev/null
@@ -1,64 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  module Format1
-    # Instances of {Format1::TimezoneDefiner} are yielded to TZInfo::Data
-    # format 1 modules by {TimezoneDefinition} to allow the offsets and
-    # transitions of the time zone to be specified.
-    #
-    # @private
-    class TimezoneDefiner < Format2::TimezoneDefiner #:nodoc:
-      undef_method :subsequent_rules
-
-      # Defines an offset.
-      #
-      # @param id [Symbol] an arbitrary value used identify the offset in
-      #   subsequent calls to transition. It must be unique.
-      # @param utc_offset [Integer] the base offset from UTC of the zone in
-      #   seconds. This does not include daylight savings time.
-      # @param std_offset [Integer] the daylight savings offset from the base
-      #   offset in seconds. Typically either 0 or 3600.
-      # @param abbreviation [Symbol] an abbreviation for the offset, for
-      #   example, `:EST` or `:EDT`.
-      # @raise [ArgumentError] if another offset has already been defined with
-      #   the given id.
-      def offset(id, utc_offset, std_offset, abbreviation)
-        super(id, utc_offset, std_offset, abbreviation.to_s)
-      end
-
-      # Defines a transition to a given offset.
-      #
-      # Transitions must be defined in increasing time order.
-      #
-      # @param year [Integer] the UTC year in which the transition occurs. Used
-      #   in earlier versions of TZInfo, but now ignored.
-      # @param month [Integer] the UTC month in which the transition occurs.
-      #   Used in earlier versions of TZInfo, but now ignored.
-      # @param offset_id [Symbol] references the id of a previously defined
-      #   offset (see #offset).
-      # @param timestamp_value [Integer] the time the transition occurs as an
-      #   Integer number of seconds since 1970-01-01 00:00:00 UTC ignoring leap
-      #   seconds (i.e. each day is treated as if it were 86,400 seconds long).
-      # @param datetime_numerator [Integer] the time of the transition as the
-      #   numerator of the `Rational` returned by `DateTime#ajd`. Used in
-      #   earlier versions of TZInfo, but now ignored.
-      # @param datetime_denominator [Integer] the time of the transition as the
-      #   denominator of the `Rational` returned by `DateTime#ajd`. Used in
-      #   earlier versions of TZInfo, but now ignored.
-      # @raise [ArgumentError] if `offset_id` does not reference a defined
-      #   offset.
-      # @raise [ArgumentError] if `timestamp_value` is not greater than the
-      #   `timestamp_value` of the previously defined transition.
-      # @raise [ArgumentError] if `datetime_numerator` is specified, but
-      #   `datetime_denominator` is not. In older versions of TZInfo, it was
-      #   possible to define a transition with the `DateTime` numerator as the
-      #   4th parameter and the denominator as the 5th parameter. This style of
-      #   definition is not used in released versions of TZInfo::Data.
-      def transition(year, month, offset_id, timestamp_value, datetime_numerator = nil, datetime_denominator = nil)
-        raise ArgumentError, 'DateTime-only transitions are not supported' if datetime_numerator && !datetime_denominator
-        super(offset_id, timestamp_value)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/timezone_definition.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/timezone_definition.rb
deleted file mode 100644
index 4acf9a0b4a2ec..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/timezone_definition.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  module Format1
-    # {Format1::TimezoneDefinition} is included into format 1 time zone
-    # definition modules and provides the methods for defining time zones.
-    #
-    # @private
-    module TimezoneDefinition #:nodoc:
-      # Adds class methods to the includee.
-      #
-      # @param base [Module] the includee.
-      def self.append_features(base)
-        super
-        base.extend(Format2::TimezoneDefinition::ClassMethods)
-        base.extend(ClassMethods)
-      end
-
-      # Class methods for inclusion.
-      #
-      # @private
-      module ClassMethods #:nodoc:
-        private
-
-        # @return the class to be instantiated and yielded by
-        # {Format2::TimezoneDefinition::ClassMethods#timezone}.
-        def timezone_definer_class
-          TimezoneDefiner
-        end
-      end
-    end
-  end
-
-  # Alias used by TZInfo::Data format1 releases.
-  #
-  # @private
-  TimezoneDefinition = Format1::TimezoneDefinition #:nodoc:
-  private_constant :TimezoneDefinition
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/timezone_index_definition.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/timezone_index_definition.rb
deleted file mode 100644
index 5d4518aa40387..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format1/timezone_index_definition.rb
+++ /dev/null
@@ -1,77 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  module Format1
-    # The format 1 TZInfo::Data time zone index file includes
-    # {Format1::TimezoneIndexDefinition}, which provides methods used to define
-    # time zones in the index.
-    #
-    # @private
-    module TimezoneIndexDefinition #:nodoc:
-      # Adds class methods to the includee and initializes class instance
-      # variables.
-      #
-      # @param base [Module] the includee.
-      def self.append_features(base)
-        super
-        base.extend(ClassMethods)
-        base.instance_eval do
-          @timezones = []
-          @data_timezones = []
-          @linked_timezones = []
-        end
-      end
-
-      # Class methods for inclusion.
-      #
-      # @private
-      module ClassMethods #:nodoc:
-        # @return [Array<String>] a frozen `Array` containing the identifiers of
-        #   all data time zones. Identifiers are sorted according to
-        #   `String#<=>`.
-        def data_timezones
-          unless @data_timezones.frozen?
-            @data_timezones = @data_timezones.sort.freeze
-          end
-          @data_timezones
-        end
-
-        # @return [Array<String>] a frozen `Array` containing the identifiers of
-        #   all linked time zones. Identifiers are sorted according to
-        #   `String#<=>`.
-        def linked_timezones
-          unless @linked_timezones.frozen?
-            @linked_timezones = @linked_timezones.sort.freeze
-          end
-          @linked_timezones
-        end
-
-        private
-
-        # Adds a data time zone to the index.
-        #
-        # @param identifier [String] the time zone identifier.
-        def timezone(identifier)
-          identifier = StringDeduper.global.dedupe(identifier)
-          @timezones << identifier
-          @data_timezones << identifier
-        end
-
-        # Adds a linked time zone to the index.
-        #
-        # @param identifier [String] the time zone identifier.
-        def linked_timezone(identifier)
-          identifier = StringDeduper.global.dedupe(identifier)
-          @timezones << identifier
-          @linked_timezones << identifier
-        end
-      end
-    end
-  end
-
-  # Alias used by TZInfo::Data format 1 releases.
-  #
-  # @private
-  TimezoneIndexDefinition = Format1::TimezoneIndexDefinition #:nodoc:
-  private_constant :TimezoneIndexDefinition
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2.rb
deleted file mode 100644
index f7c63167d2065..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  # Modules and classes used by the format 2 version of TZInfo::Data.
-  #
-  # @private
-  module Format2 #:nodoc:
-  end
-  private_constant :Format2
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/country_definer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/country_definer.rb
deleted file mode 100644
index 158e3ec1bb6a6..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/country_definer.rb
+++ /dev/null
@@ -1,68 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  module Format2
-    # Instances of {Format2::CountryDefiner} are yielded to the format 2 version
-    # of `TZInfo::Data::Indexes::Countries` by {CountryIndexDefiner} to allow
-    # the zones of a country to be specified.
-    #
-    # @private
-    class CountryDefiner #:nodoc:
-      # @return [Array<CountryTimezone>] the time zones observed in the country.
-      attr_reader :timezones
-
-      # Initializes a new {CountryDefiner}.
-      #
-      # @param shared_timezones [Hash<Symbol, CountryTimezone>] a `Hash`
-      #   containing time zones shared by more than one country, keyed by a
-      #   unique reference.
-      # @param identifier_deduper [StringDeduper] a {StringDeduper} instance to
-      #   use when deduping time zone identifiers.
-      # @param description_deduper [StringDeduper] a {StringDeduper} instance to
-      #   use when deduping time zone descriptions.
-      def initialize(shared_timezones, identifier_deduper, description_deduper)
-        @shared_timezones = shared_timezones
-        @identifier_deduper = identifier_deduper
-        @description_deduper = description_deduper
-        @timezones = []
-      end
-
-      # @overload timezone(reference)
-      #   Defines a time zone of a country as a reference to a pre-defined
-      #   shared time zone.
-      #   @param reference [Symbol] a reference for a pre-defined shared time
-      #     zone.
-      # @overload timezone(identifier, latitude_numerator, latitude_denominator, longitude_numerator, longitude_denominator, description)
-      #   Defines a (non-shared) time zone of a country. The latitude and
-      #   longitude are given as the numerator and denominator of a `Rational`.
-      #   @param identifier [String] the time zone identifier.
-      #   @param latitude_numerator [Integer] the numerator of the latitude.
-      #   @param latitude_denominator [Integer] the denominator of the latitude.
-      #   @param longitude_numerator [Integer] the numerator of the longitude.
-      #   @param longitude_denominator [Integer] the denominator of the
-      #     longitude.
-      #   @param description [String] an optional description for the time zone.
-      def timezone(identifier_or_reference, latitude_numerator = nil,
-                  latitude_denominator = nil, longitude_numerator = nil,
-                  longitude_denominator = nil, description = nil)
-        if latitude_numerator
-          unless latitude_denominator && longitude_numerator && longitude_denominator
-            raise ArgumentError, 'Either just a reference should be supplied, or the identifier, latitude and longitude must all be specified'
-          end
-
-          # Dedupe non-frozen literals from format 1 on all Ruby versions and
-          # format 2 on Ruby < 2.3 (without frozen_string_literal support).
-
-          @timezones << CountryTimezone.new(@identifier_deduper.dedupe(identifier_or_reference),
-            Rational(latitude_numerator, latitude_denominator),
-            Rational(longitude_numerator, longitude_denominator), description && @description_deduper.dedupe(description))
-        else
-          shared_timezone = @shared_timezones[identifier_or_reference]
-          raise ArgumentError, "Unknown shared timezone: #{identifier_or_reference}" unless shared_timezone
-          @timezones << shared_timezone
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/country_index_definer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/country_index_definer.rb
deleted file mode 100644
index be28095e0c0d2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/country_index_definer.rb
+++ /dev/null
@@ -1,68 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  module Format2
-    # Instances of {Format2::CountryIndexDefiner} are yielded to the format 2
-    # version of `TZInfo::Data::Indexes::Countries` by {CountryIndexDefinition}
-    # to allow countries and their time zones to be specified.
-    #
-    # @private
-    class CountryIndexDefiner #:nodoc:
-      # @return [Hash<String, CountryInfo>] a `Hash` of all the countries that
-      #     have been defined in the index keyed by their codes.
-      attr_reader :countries
-
-      # Initializes a new {CountryIndexDefiner}.
-      #
-      # @param identifier_deduper [StringDeduper] a {StringDeduper} instance to
-      #   use when deduping time zone identifiers.
-      # @param description_deduper [StringDeduper] a {StringDeduper} instance to
-      #   use when deduping time zone descriptions.
-      def initialize(identifier_deduper, description_deduper)
-        @identifier_deduper = identifier_deduper
-        @description_deduper = description_deduper
-        @shared_timezones = {}
-        @countries = {}
-      end
-
-      # Defines a time zone shared by many countries with an reference for
-      # subsequent use in country definitions. The latitude and longitude are
-      # given as the numerator and denominator of a `Rational`.
-      #
-      # @param reference [Symbol] a unique reference for the time zone.
-      # @param identifier [String] the time zone identifier.
-      # @param latitude_numerator [Integer] the numerator of the latitude.
-      # @param latitude_denominator [Integer] the denominator of the latitude.
-      # @param longitude_numerator [Integer] the numerator of the longitude.
-      # @param longitude_denominator [Integer] the denominator of the longitude.
-      # @param description [String] an optional description for the time zone.
-      def timezone(reference, identifier, latitude_numerator, latitude_denominator,
-                    longitude_numerator, longitude_denominator, description = nil)
-        # Dedupe non-frozen literals from format 1 on all Ruby versions and
-        # format 2 on Ruby < 2.3 (without frozen_string_literal support).
-        @shared_timezones[reference] = CountryTimezone.new(@identifier_deduper.dedupe(identifier),
-          Rational(latitude_numerator, latitude_denominator),
-          Rational(longitude_numerator, longitude_denominator), description && @description_deduper.dedupe(description))
-      end
-
-      # Defines a country.
-      #
-      # @param code [String] The ISO 3166-1 alpha-2 code of the country.
-      # @param name [String] Then name of the country.
-      # @yield [definer] yields (optional) to obtain the time zones for the
-      #   country.
-      # @yieldparam definer [CountryDefiner] a {CountryDefiner}
-      #   instance that should be used to specify the time zones of the country.
-      def country(code, name)
-        timezones = if block_given?
-          definer = CountryDefiner.new(@shared_timezones, @identifier_deduper, @description_deduper)
-          yield definer
-          definer.timezones
-        else
-          []
-        end
-        @countries[code.freeze] = DataSources::CountryInfo.new(code, name, timezones)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/country_index_definition.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/country_index_definition.rb
deleted file mode 100644
index 82b2127bcd43c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/country_index_definition.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  module Format2
-    # The format 2 country index file includes
-    # {Format2::CountryIndexDefinition}, which provides a
-    # {CountryIndexDefinition::ClassMethods#country_index country_index} method
-    # used to define the country index.
-    #
-    # @private
-    module CountryIndexDefinition #:nodoc:
-      # Adds class methods to the includee and initializes class instance
-      # variables.
-      #
-      # @param base [Module] the includee.
-      def self.append_features(base)
-        super
-        base.extend(ClassMethods)
-        base.instance_eval { @countries = {}.freeze }
-      end
-
-      # Class methods for inclusion.
-      #
-      # @private
-      module ClassMethods #:nodoc:
-        # @return [Hash<String, DataSources::CountryInfo>] a frozen `Hash`
-        #   of all the countries that have been defined in the index keyed by
-        #   their codes.
-        attr_reader :countries
-
-        private
-
-        # Defines the index.
-        #
-        # @yield [definer] yields to allow the index to be defined.
-        # @yieldparam definer [CountryIndexDefiner] a {CountryIndexDefiner}
-        #   instance that should be used to define the index.
-        def country_index
-          definer = CountryIndexDefiner.new(StringDeduper.global, StringDeduper.new)
-          yield definer
-          @countries = definer.countries.freeze
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/timezone_definer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/timezone_definer.rb
deleted file mode 100644
index 3c43caabaeaf1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/timezone_definer.rb
+++ /dev/null
@@ -1,94 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  module Format2
-    # Instances of {TimezoneDefiner} are yielded to TZInfo::Data modules by
-    # {TimezoneDefinition} to allow the offsets and transitions of the time zone
-    # to be specified.
-    #
-    # @private
-    class TimezoneDefiner #:nodoc:
-      # @return [Array<TimezoneTransition>] the defined transitions of the time
-      #   zone.
-      attr_reader :transitions
-
-      # Initializes a new TimezoneDefiner.
-      #
-      # @param string_deduper [StringDeduper] a {StringDeduper} instance to use
-      #   when deduping abbreviations.
-      def initialize(string_deduper)
-        @string_deduper = string_deduper
-        @offsets = {}
-        @transitions = []
-      end
-
-      # Returns the first offset to be defined or `nil` if no offsets have been
-      #  defined. The first offset is observed before the time of the first
-      #  transition.
-      #
-      # @return [TimezoneOffset] the first offset to be defined or `nil` if no
-      #   offsets have been defined.
-      def first_offset
-        first = @offsets.first
-        first && first.last
-      end
-
-      # Defines an offset.
-      #
-      # @param id [Symbol] an arbitrary value used identify the offset in
-      #   subsequent calls to transition. It must be unique.
-      # @param base_utc_offset [Integer] the base offset from UTC of the zone in
-      #   seconds. This does not include daylight savings time.
-      # @param std_offset [Integer] the daylight savings offset from the base
-      #   offset in seconds. Typically either 0 or 3600.
-      # @param abbreviation [String] an abbreviation for the offset, for
-      #   example, EST or EDT.
-      # @raise [ArgumentError] if another offset has already been defined with
-      #   the given id.
-      def offset(id, base_utc_offset, std_offset, abbreviation)
-        raise ArgumentError, 'An offset has already been defined with the given id' if @offsets.has_key?(id)
-
-        # Dedupe non-frozen literals from format 1 on all Ruby versions and
-        # format 2 on Ruby < 2.3 (without frozen_string_literal support).
-        abbreviation = @string_deduper.dedupe(abbreviation)
-
-        offset = TimezoneOffset.new(base_utc_offset, std_offset, abbreviation)
-        @offsets[id] = offset
-        @previous_offset ||= offset
-      end
-
-      # Defines a transition to a given offset.
-      #
-      # Transitions must be defined in increasing time order.
-      #
-      # @param offset_id [Symbol] references the id of a previously defined
-      #   offset.
-      # @param timestamp_value [Integer] the time the transition occurs as a
-      #   number of seconds since 1970-01-01 00:00:00 UTC ignoring leap seconds
-      #   (i.e. each day is treated as if it were 86,400 seconds long).
-      # @raise [ArgumentError] if `offset_id` does not reference a defined
-      #   offset.
-      # @raise [ArgumentError] if `timestamp_value` is not greater than the
-      #   `timestamp_value` of the previously defined transition.
-      def transition(offset_id, timestamp_value)
-        offset = @offsets[offset_id]
-        raise ArgumentError, 'offset_id has not been defined' unless offset
-        raise ArgumentError, 'timestamp is not greater than the timestamp of the previously defined transition' if !@transitions.empty? && @transitions.last.timestamp_value >= timestamp_value
-        @transitions << TimezoneTransition.new(offset, @previous_offset, timestamp_value)
-        @previous_offset = offset
-      end
-
-      # Defines the rules that will be used for handling instants after the last
-      # transition.
-      #
-      # This method is currently just a placeholder for forward compatibility
-      # that accepts and ignores any arguments passed.
-      #
-      # Support for subsequent rules will be added in a future version of TZInfo
-      # and the rules will be included in format 2 releases of TZInfo::Data.
-      def subsequent_rules(*args)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/timezone_definition.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/timezone_definition.rb
deleted file mode 100644
index 216df90f165ba..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/timezone_definition.rb
+++ /dev/null
@@ -1,73 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  module Format2
-    # {Format2::TimezoneDefinition} is included into format 2 time zone
-    # definition modules and provides methods for defining time zones.
-    #
-    # @private
-    module TimezoneDefinition #:nodoc:
-      # Adds class methods to the includee.
-      #
-      # @param base [Module] the includee.
-      def self.append_features(base)
-        super
-        base.extend(ClassMethods)
-      end
-
-      # Class methods for inclusion.
-      #
-      # @private
-      module ClassMethods #:nodoc:
-        # @return [TimezoneInfo] the last time zone to be defined.
-        def get
-          @timezone
-        end
-
-        private
-
-        # @return [Class] the class to be instantiated and yielded by
-        #   {#timezone}.
-        def timezone_definer_class
-          TimezoneDefiner
-        end
-
-        # Defines a data time zone.
-        #
-        # @param identifier [String] the identifier of the time zone.
-        # @yield [definer] yields to the caller to define the time zone.
-        # @yieldparam definer [Object] an instance of the class returned by
-        #   {#timezone_definer_class}, typically {TimezoneDefiner}.
-        def timezone(identifier)
-          # Dedupe non-frozen literals from format 1 on all Ruby versions and
-          # format 2 on Ruby < 2.3 (without frozen_string_literal support).
-          string_deduper = StringDeduper.global
-          identifier = string_deduper.dedupe(identifier)
-
-          definer = timezone_definer_class.new(string_deduper)
-          yield definer
-          transitions = definer.transitions
-
-          @timezone = if transitions.empty?
-            DataSources::ConstantOffsetDataTimezoneInfo.new(identifier, definer.first_offset)
-          else
-            DataSources::TransitionsDataTimezoneInfo.new(identifier, transitions)
-          end
-        end
-
-        # Defines a linked time zone.
-        #
-        # @param identifier [String] the identifier of the time zone being
-        #   defined.
-        # @param link_to_identifier [String] the identifier the new time zone
-        #   links to (is an alias for).
-        def linked_timezone(identifier, link_to_identifier)
-          # Dedupe non-frozen literals from format 1 on all Ruby versions and
-          # format 2 on Ruby < 2.3 (without frozen_string_literal support).
-          string_deduper = StringDeduper.global
-          @timezone = DataSources::LinkedTimezoneInfo.new(string_deduper.dedupe(identifier), string_deduper.dedupe(link_to_identifier))
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/timezone_index_definer.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/timezone_index_definer.rb
deleted file mode 100644
index f90e77682d7dd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/timezone_index_definer.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  module Format2
-    # Instances of {TimezoneIndexDefiner} are yielded by
-    # {TimezoneIndexDefinition} to allow the time zone index to be defined.
-    #
-    # @private
-    class TimezoneIndexDefiner #:nodoc:
-      # @return [Array<String>] the identifiers of all data time zones.
-      attr_reader :data_timezones
-
-      # @return [Array<String>] the identifiers of all linked time zones.
-      attr_reader :linked_timezones
-
-      # Initializes a new TimezoneDefiner.
-      #
-      # @param string_deduper [StringDeduper] a {StringDeduper} instance to use
-      #   when deduping identifiers.
-      def initialize(string_deduper)
-        @string_deduper = string_deduper
-        @data_timezones = []
-        @linked_timezones = []
-      end
-
-      # Adds a data time zone to the index.
-      #
-      # @param identifier [String] the time zone identifier.
-      def data_timezone(identifier)
-        # Dedupe non-frozen literals from format 1 on all Ruby versions and
-        # format 2 on Ruby < 2.3 (without frozen_string_literal support).
-        @data_timezones << @string_deduper.dedupe(identifier)
-      end
-
-      # Adds a linked time zone to the index.
-      #
-      # @param identifier [String] the time zone identifier.
-      def linked_timezone(identifier)
-        # Dedupe non-frozen literals from format 1 on all Ruby versions and
-        # format 2 on Ruby < 2.3 (without frozen_string_literal support).
-        @linked_timezones << @string_deduper.dedupe(identifier)
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/timezone_index_definition.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/timezone_index_definition.rb
deleted file mode 100644
index ceafd0cf1ac27..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/format2/timezone_index_definition.rb
+++ /dev/null
@@ -1,55 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  module Format2
-    # The format 2 time zone index file includes {TimezoneIndexDefinition},
-    # which provides the {TimezoneIndexDefinition::ClassMethods#timezone_index
-    # timezone_index} method used to define the index.
-    #
-    # @private
-    module TimezoneIndexDefinition #:nodoc:
-      # Adds class methods to the includee and initializes class instance
-      # variables.
-      #
-      # @param base [Module] the includee.
-      def self.append_features(base)
-        super
-        base.extend(ClassMethods)
-        base.instance_eval do
-          empty = [].freeze
-          @timezones = empty
-          @data_timezones = empty
-          @linked_timezones = empty
-        end
-      end
-
-      # Class methods for inclusion.
-      #
-      # @private
-      module ClassMethods #:nodoc:
-        # @return [Array<String>] a frozen `Array` containing the identifiers of
-        #   all data time zones. Identifiers are sorted according to
-        #   `String#<=>`.
-        attr_reader :data_timezones
-
-        # @return [Array<String>] a frozen `Array` containing the identifiers of
-        #   all linked time zones. Identifiers are sorted according to
-        #   `String#<=>`.
-        attr_reader :linked_timezones
-
-        # Defines the index.
-        #
-        # @yield [definer] yields to the caller to allow the index to be
-        #   defined.
-        # @yieldparam definer [TimezoneIndexDefiner] a {TimezoneIndexDefiner}
-        #   instance that should be used to define the index.
-        def timezone_index
-          definer = TimezoneIndexDefiner.new(StringDeduper.global)
-          yield definer
-          @data_timezones = definer.data_timezones.sort!.freeze
-          @linked_timezones = definer.linked_timezones.sort!.freeze
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/info_timezone.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/info_timezone.rb
deleted file mode 100644
index ff9dcfa137981..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/info_timezone.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-
-  # A {Timezone} based on a {DataSources::TimezoneInfo}.
-  #
-  # @abstract
-  class InfoTimezone < Timezone
-    # Initializes a new {InfoTimezone}.
-    #
-    # {InfoTimezone} instances should not normally be created directly. Use
-    # the {Timezone.get} method to obtain {Timezone} instances.
-    #
-    # @param info [DataSources::TimezoneInfo] a {DataSources::TimezoneInfo}
-    #   instance supplied by a {DataSource} that will be used as the source of
-    #   data for this {InfoTimezone}.
-    def initialize(info)
-      super()
-      @info = info
-    end
-
-    # (see Timezone#identifier)
-    def identifier
-      @info.identifier
-    end
-
-    protected
-
-    # @return [DataSources::TimezoneInfo] the {DataSources::TimezoneInfo} this
-    #   {InfoTimezone} is based on.
-    def info
-      @info
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/linked_timezone.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/linked_timezone.rb
deleted file mode 100644
index af800dc1ee5d1..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/linked_timezone.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  # Represents time zones that are defined as a link to or alias for another
-  # time zone.
-  class LinkedTimezone < InfoTimezone
-    # Initializes a new {LinkedTimezone}.
-    #
-    # {LinkedTimezone} instances should not normally be created directly. Use
-    # the {Timezone.get} method to obtain {Timezone} instances.
-    #
-    # @param info [DataSources::LinkedTimezoneInfo] a
-    #   {DataSources::LinkedTimezoneInfo} instance supplied by a {DataSource}
-    #   that will be used as the source of data for this {LinkedTimezone}.
-    def initialize(info)
-      super
-      @linked_timezone = Timezone.get(info.link_to_identifier)
-    end
-
-    # (see Timezone#period_for)
-    def period_for(time)
-      @linked_timezone.period_for(time)
-    end
-
-    # (see Timezone#periods_for_local)
-    def periods_for_local(local_time)
-      @linked_timezone.periods_for_local(local_time)
-    end
-
-    # (see Timezone#transitions_up_to)
-    def transitions_up_to(to, from = nil)
-      @linked_timezone.transitions_up_to(to, from)
-    end
-
-    # Returns the canonical {Timezone} instance for this {LinkedTimezone}.
-    #
-    # For a {LinkedTimezone}, this is the canonical zone of the link target.
-    #
-    # @return [Timezone] the canonical {Timezone} instance for this {Timezone}.
-    def canonical_zone
-      @linked_timezone.canonical_zone
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/offset_timezone_period.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/offset_timezone_period.rb
deleted file mode 100644
index a5988e071475a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/offset_timezone_period.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-  # Represents the infinite period of time in a time zone that constantly
-  # observes the same offset from UTC (has an unbounded start and end).
-  class OffsetTimezonePeriod < TimezonePeriod
-    # Initializes an {OffsetTimezonePeriod}.
-    #
-    # @param offset [TimezoneOffset] the offset that is constantly observed.
-    # @raise [ArgumentError] if `offset` is `nil`.
-    def initialize(offset)
-      super
-    end
-
-    # @return [TimezoneTransition] the transition that defines the start of this
-    #   {TimezonePeriod}, always `nil` for {OffsetTimezonePeriod}.
-    def start_transition
-      nil
-    end
-
-    # @return [TimezoneTransition] the transition that defines the end of this
-    #   {TimezonePeriod}, always `nil` for {OffsetTimezonePeriod}.
-    def end_transition
-      nil
-    end
-
-    # Determines if this {OffsetTimezonePeriod} is equal to another instance.
-    #
-    # @param p [Object] the instance to test for equality.
-    # @return [Boolean] `true` if `p` is a {OffsetTimezonePeriod} with the same
-    #   {offset}, otherwise `false`.
-    def ==(p)
-      p.kind_of?(OffsetTimezonePeriod) && offset == p.offset
-    end
-    alias eql? ==
-
-    # @return [Integer] a hash based on {offset}.
-    def hash
-      offset.hash
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/string_deduper.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/string_deduper.rb
deleted file mode 100644
index e07fa10ac55cf..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/string_deduper.rb
+++ /dev/null
@@ -1,118 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-require 'concurrent'
-
-module TZInfo
-  # Maintains a pool of `String` instances. The {#dedupe} method will return
-  # either a pooled copy of a given `String` or add the instance to the pool.
-  #
-  # @private
-  class StringDeduper #:nodoc:
-    class << self
-      # @return [StringDeduper] a globally available singleton instance of
-      #   {StringDeduper}. This instance is safe for use in concurrently
-      #   executing threads.
-      attr_reader :global
-    end
-
-    # Initializes a new {StringDeduper}.
-    def initialize
-      @strings = create_hash do |h, k|
-        v = k.dup.freeze
-        h[v] = v
-      end
-    end
-
-    # @param string [String] the string to deduplicate.
-    # @return [bool] `string` if it is frozen, otherwise a frozen, possibly
-    #   pre-existing copy of `string`.
-    def dedupe(string)
-      return string if string.frozen?
-      @strings[string]
-    end
-
-    protected
-
-    # Creates a `Hash` to store pooled `String` instances.
-    #
-    # @param block [Proc] Default value block to be passed to `Hash.new`.
-    # @return [Hash] a `Hash` to store pooled `String` instances.
-    def create_hash(&block)
-      Hash.new(&block)
-    end
-  end
-  private_constant :StringDeduper
-
-  # A thread-safe version of {StringDeduper}.
-  #
-  # @private
-  class ConcurrentStringDeduper < StringDeduper #:nodoc:
-    protected
-
-    def create_hash(&block)
-      Concurrent::Map.new(&block)
-    end
-  end
-  private_constant :ConcurrentStringDeduper
-
-
-  string_unary_minus_does_dedupe = if '0'.respond_to?(:-@)
-    # :nocov_no_string_-@:
-    s1 = -('0'.dup)
-    s2 = -('0'.dup)
-    s1.object_id == s2.object_id
-    # :nocov_no_string_-@:
-  else
-    # :nocov_string_-@:
-    false
-    # :nocov_string_-@:
-  end
-
-  if string_unary_minus_does_dedupe
-    # :nocov_no_deduping_string_unary_minus:
-
-    # An implementation of {StringDeduper} using the `String#-@` method where
-    # that method performs deduplication (Ruby 2.5 and later).
-    #
-    # Note that this is slightly different to the plain {StringDeduper}
-    # implementation. In this implementation, frozen literal strings are already
-    # in the pool and are candidates for being returned, even when passed
-    # another equal frozen non-literal string. {StringDeduper} will always
-    # return frozen strings.
-    #
-    # There are also differences in encoding handling. This implementation will
-    # treat strings with different encodings as different strings.
-    # {StringDeduper} will treat strings with the compatible encodings as the
-    # same string.
-    #
-    # @private
-    class UnaryMinusGlobalStringDeduper #:nodoc:
-      # @param string [String] the string to deduplicate.
-      # @return [bool] `string` if it is frozen, otherwise a frozen, possibly
-      #   pre-existing copy of `string`.
-      def dedupe(string)
-        # String#-@ on Ruby 2.6 will dedupe a frozen non-literal String. Ruby
-        # 2.5 will just return frozen strings.
-        #
-        # The pooled implementation can't tell the difference between frozen
-        # literals and frozen non-literals, so must always return frozen String
-        # instances to avoid doing unncessary work when loading format 2
-        # TZInfo::Data modules.
-        #
-        # For compatibility with the pooled implementation, just return frozen
-        # string instances (acting like Ruby 2.5).
-        return string if string.frozen?
-        -string
-      end
-    end
-    private_constant :UnaryMinusGlobalStringDeduper
-
-    StringDeduper.instance_variable_set(:@global, UnaryMinusGlobalStringDeduper.new)
-    # :nocov_no_deduping_string_unary_minus:
-  else
-    # :nocov_deduping_string_unary_minus:
-    StringDeduper.instance_variable_set(:@global, ConcurrentStringDeduper.new)
-    # :nocov_deduping_string_unary_minus:
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/time_with_offset.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/time_with_offset.rb
deleted file mode 100644
index 6b9bebb085f7f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/time_with_offset.rb
+++ /dev/null
@@ -1,154 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # A subclass of `Time` used to represent local times. {TimeWithOffset} holds a
-  # reference to the related {TimezoneOffset} and overrides various methods to
-  # return results appropriate for the {TimezoneOffset}. Certain operations will
-  # clear the associated {TimezoneOffset} (if the {TimezoneOffset} would not
-  # necessarily be valid for the result). Once the {TimezoneOffset} has been
-  # cleared, {TimeWithOffset} behaves identically to `Time`.
-  #
-  # Arithmetic performed on {TimeWithOffset} instances is _not_ time zone-aware.
-  # Regardless of whether transitions in the time zone are crossed, results of
-  # arithmetic operations will always maintain the same offset from UTC
-  # (`utc_offset`). The associated {TimezoneOffset} will aways be cleared.
-  class TimeWithOffset < Time
-    include WithOffset
-
-    # @return [TimezoneOffset] the {TimezoneOffset} associated with this
-    #   instance.
-    attr_reader :timezone_offset
-
-    # Marks this {TimeWithOffset} as a local time with the UTC offset of a given
-    # {TimezoneOffset} and sets the associated {TimezoneOffset}.
-    #
-    # @param timezone_offset [TimezoneOffset] the {TimezoneOffset} to use to set
-    #   the offset of this {TimeWithOffset}.
-    # @return [TimeWithOffset] `self`.
-    # @raise [ArgumentError] if `timezone_offset` is `nil`.
-    def set_timezone_offset(timezone_offset)
-      raise ArgumentError, 'timezone_offset must be specified' unless timezone_offset
-      localtime(timezone_offset.observed_utc_offset)
-      @timezone_offset = timezone_offset
-      self
-    end
-
-    # An overridden version of `Time#dst?` that, if there is an associated
-    # {TimezoneOffset}, returns the result of calling {TimezoneOffset#dst? dst?}
-    # on that offset.
-    #
-    # @return [Boolean] `true` if daylight savings time is being observed,
-    #   otherwise `false`.
-    def dst?
-      to = timezone_offset
-      to ? to.dst? : super
-    end
-    alias isdst dst?
-
-    # An overridden version of `Time#getlocal` that clears the associated
-    # {TimezoneOffset} if the base implementation of `getlocal` returns a
-    # {TimeWithOffset}.
-    #
-    # @return [Time] a representation of the {TimeWithOffset} using either the
-    #   local time zone or the given offset.
-    def getlocal(*args)
-      # JRuby < 9.3 returns a Time in all cases.
-      # JRuby >= 9.3 returns a Time when called with no arguments and a
-      # TimeWithOffset with a timezone_offset assigned when called with an
-      # offset argument.
-      result = super
-      result.clear_timezone_offset if result.kind_of?(TimeWithOffset)
-      result
-    end
-
-    # An overridden version of `Time#gmtime` that clears the associated
-    # {TimezoneOffset}.
-    #
-    # @return [TimeWithOffset] `self`.
-    def gmtime
-      super
-      @timezone_offset = nil
-      self
-    end
-
-    # An overridden version of `Time#localtime` that clears the associated
-    # {TimezoneOffset}.
-    #
-    # @return [TimeWithOffset] `self`.
-    def localtime(*args)
-      super
-      @timezone_offset = nil
-      self
-    end
-
-    # An overridden version of `Time#round` that, if there is an associated
-    # {TimezoneOffset}, returns a {TimeWithOffset} preserving that offset.
-    #
-    # @return [Time] the rounded time.
-    def round(ndigits = 0)
-      if_timezone_offset(super) {|o,t| self.class.at(t.to_i, t.subsec * 1_000_000).set_timezone_offset(o) }
-    end
-
-    # An overridden version of `Time#to_a`. The `isdst` (index 8) and `zone`
-    # (index 9) elements of the array are set according to the associated
-    # {TimezoneOffset}.
-    #
-    # @return [Array] an `Array` representation of the {TimeWithOffset}.
-    def to_a
-      if_timezone_offset(super) do |o,a|
-        a[8] = o.dst?
-        a[9] = o.abbreviation
-        a
-      end
-    end
-
-    # An overridden version of `Time#utc` that clears the associated
-    # {TimezoneOffset}.
-    #
-    # @return [TimeWithOffset] `self`.
-    def utc
-      super
-      @timezone_offset = nil
-      self
-    end
-
-    # An overridden version of `Time#zone` that, if there is an associated
-    # {TimezoneOffset}, returns the {TimezoneOffset#abbreviation abbreviation}
-    # of that offset.
-    #
-    # @return [String] the {TimezoneOffset#abbreviation abbreviation} of the
-    #   associated {TimezoneOffset}, or the result from `Time#zone` if there is
-    #   no such offset.
-    def zone
-      to = timezone_offset
-      to ? to.abbreviation : super
-    end
-
-    # An overridden version of `Time#to_datetime` that, if there is an
-    # associated {TimezoneOffset}, returns a {DateTimeWithOffset} with that
-    # offset.
-    #
-    # @return [DateTime] if there is an associated {TimezoneOffset}, a
-    #   {DateTimeWithOffset} representation of this {TimeWithOffset}, otherwise
-    #   a `Time` representation.
-    def to_datetime
-      if_timezone_offset(super) do |o,dt|
-        offset = dt.offset
-        result = DateTimeWithOffset.jd(dt.jd + dt.day_fraction - offset)
-        result = result.new_offset(offset) unless offset == 0
-        result.set_timezone_offset(o)
-      end
-    end
-
-    protected
-
-    # Clears the associated {TimezoneOffset}.
-    #
-    # @return [TimeWithOffset] `self`.
-    def clear_timezone_offset
-      @timezone_offset = nil
-      self
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timestamp.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timestamp.rb
deleted file mode 100644
index 9ec195c0870fa..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timestamp.rb
+++ /dev/null
@@ -1,552 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # A time represented as an `Integer` number of seconds since 1970-01-01
-  # 00:00:00 UTC (ignoring leap seconds and using the proleptic Gregorian
-  # calendar), the fraction through the second (sub_second as a `Rational`) and
-  # an optional UTC offset. Like Ruby's `Time` class, {Timestamp} can
-  # distinguish between a local time with a zero offset and a time specified
-  # explicitly as UTC.
-  class Timestamp
-    include Comparable
-
-    # The Unix epoch (1970-01-01 00:00:00 UTC) as a chronological Julian day
-    # number.
-    JD_EPOCH = 2440588
-    private_constant :JD_EPOCH
-
-    class << self
-      # Returns a new {Timestamp} representing the (proleptic Gregorian
-      # calendar) date and time specified by the supplied parameters.
-      #
-      # If `utc_offset` is `nil`, `:utc` or 0, the date and time parameters will
-      # be interpreted as representing a UTC date and time. Otherwise the date
-      # and time parameters will be interpreted as a local date and time with
-      # the given offset.
-      #
-      # @param year [Integer] the year.
-      # @param month [Integer] the month (1-12).
-      # @param day [Integer] the day of the month (1-31).
-      # @param hour [Integer] the hour (0-23).
-      # @param minute [Integer] the minute (0-59).
-      # @param second [Integer] the second (0-59).
-      # @param sub_second [Numeric] the fractional part of the second as either
-      #   a `Rational` that is greater than or equal to 0 and less than 1, or
-      #   the `Integer` 0.
-      # @param utc_offset [Object] either `nil` for a {Timestamp} without a
-      #   specified offset, an offset from UTC specified as an `Integer` number
-      #   of seconds or the `Symbol` `:utc`).
-      # @return [Timestamp] a new {Timestamp} representing the specified
-      #   (proleptic Gregorian calendar) date and time.
-      # @raise [ArgumentError] if either of `year`, `month`, `day`, `hour`,
-      #   `minute`, or `second` is not an `Integer`.
-      # @raise [ArgumentError] if `sub_second` is not a `Rational`, or the
-      #   `Integer` 0.
-      # @raise [ArgumentError] if `utc_offset` is not `nil`, not an `Integer`
-      #   and not the `Symbol` `:utc`.
-      # @raise [RangeError] if `month` is not between 1 and 12.
-      # @raise [RangeError] if `day` is not between 1 and 31.
-      # @raise [RangeError] if `hour` is not between 0 and 23.
-      # @raise [RangeError] if `minute` is not between 0 and 59.
-      # @raise [RangeError] if `second` is not between 0 and 59.
-      # @raise [RangeError] if `sub_second` is a `Rational` but that is less
-      #   than 0 or greater than or equal to 1.
-      def create(year, month = 1, day = 1, hour = 0, minute = 0, second = 0, sub_second = 0, utc_offset = nil)
-        raise ArgumentError, 'year must be an Integer' unless year.kind_of?(Integer)
-        raise ArgumentError, 'month must be an Integer' unless month.kind_of?(Integer)
-        raise ArgumentError, 'day must be an Integer' unless day.kind_of?(Integer)
-        raise ArgumentError, 'hour must be an Integer' unless hour.kind_of?(Integer)
-        raise ArgumentError, 'minute must be an Integer' unless minute.kind_of?(Integer)
-        raise ArgumentError, 'second must be an Integer' unless second.kind_of?(Integer)
-        raise RangeError, 'month must be between 1 and 12' if month < 1 || month > 12
-        raise RangeError, 'day must be between 1 and 31' if day < 1 || day > 31
-        raise RangeError, 'hour must be between 0 and 23' if hour < 0 || hour > 23
-        raise RangeError, 'minute must be between 0 and 59' if minute < 0 || minute > 59
-        raise RangeError, 'second must be between 0 and 59' if second < 0 || second > 59
-
-        # Based on days_from_civil from https://howardhinnant.github.io/date_algorithms.html#days_from_civil
-        after_february = month > 2
-        year -= 1 unless after_february
-        era = year / 400
-        year_of_era = year - era * 400
-        day_of_year = (153 * (month + (after_february ? -3 : 9)) + 2) / 5 + day - 1
-        day_of_era = year_of_era * 365 + year_of_era / 4 - year_of_era / 100 + day_of_year
-        days_since_epoch = era * 146097 + day_of_era - 719468
-        value = ((days_since_epoch * 24 + hour) * 60 + minute) * 60 + second
-        value -= utc_offset if utc_offset.kind_of?(Integer)
-
-        new(value, sub_second, utc_offset)
-      end
-
-      # When used without a block, returns a {Timestamp} representation of a
-      # given `Time`, `DateTime` or {Timestamp}.
-      #
-      # When called with a block, the {Timestamp} representation of `value` is
-      # passed to the block. The block must then return a {Timestamp}, which
-      # will be converted back to the type of the initial value. If the initial
-      # value was a {Timestamp}, the block result will be returned. If the
-      # initial value was a `DateTime`, a Gregorian `DateTime` will be returned.
-      #
-      # The UTC offset of `value` can either be preserved (the {Timestamp}
-      # representation will have the same UTC offset as `value`), ignored (the
-      # {Timestamp} representation will have no defined UTC offset), or treated
-      # as though it were UTC (the {Timestamp} representation will have a
-      # {utc_offset} of 0 and {utc?} will return `true`).
-      #
-      # @param value [Object] a `Time`, `DateTime` or {Timestamp}.
-      # @param offset [Symbol] either `:preserve` to preserve the offset of
-      #   `value`, `:ignore` to ignore the offset of `value` and create a
-      #   {Timestamp} with an unspecified offset, or `:treat_as_utc` to treat
-      #   the offset of `value` as though it were UTC and create a UTC
-      #   {Timestamp}.
-      # @yield [timestamp] if a block is provided, the {Timestamp}
-      #   representation is passed to the block.
-      # @yieldparam timestamp [Timestamp] the {Timestamp} representation of
-      #   `value`.
-      # @yieldreturn [Timestamp] a {Timestamp} to be converted back to the type
-      #   of `value`.
-      # @return [Object] if called without a block, the {Timestamp}
-      #   representation of `value`, otherwise the result of the block,
-      #   converted back to the type of `value`.
-      def for(value, offset = :preserve)
-        raise ArgumentError, 'value must be specified' unless value
-
-        case offset
-          when :ignore
-            ignore_offset = true
-            target_utc_offset = nil
-          when :treat_as_utc
-            ignore_offset = true
-            target_utc_offset = :utc
-          when :preserve
-            ignore_offset = false
-            target_utc_offset = nil
-          else
-            raise ArgumentError, 'offset must be :preserve, :ignore or :treat_as_utc'
-        end
-
-        time_like = false
-        timestamp = case value
-          when Time
-            for_time(value, ignore_offset, target_utc_offset)
-          when DateTime
-            for_datetime(value, ignore_offset, target_utc_offset)
-          when Timestamp
-            for_timestamp(value, ignore_offset, target_utc_offset)
-          else
-            raise ArgumentError, "#{value.class} values are not supported" unless is_time_like?(value)
-            time_like = true
-            for_time_like(value, ignore_offset, target_utc_offset)
-        end
-
-        if block_given?
-          result = yield timestamp
-          raise ArgumentError, 'block must return a Timestamp' unless result.kind_of?(Timestamp)
-
-          case value
-            when Time
-              result.to_time
-            when DateTime
-              result.to_datetime
-            else # A Time-like value or a Timestamp
-              time_like ? result.to_time : result
-          end
-        else
-          timestamp
-        end
-      end
-
-      # Creates a new UTC {Timestamp}.
-      #
-      # @param value [Integer] the number of seconds since 1970-01-01 00:00:00
-      #   UTC ignoring leap seconds.
-      # @param sub_second [Numeric] the fractional part of the second as either
-      #   a `Rational` that is greater than or equal to 0 and less than 1, or
-      #   the `Integer` 0.
-      # @raise [ArgumentError] if `value` is not an `Integer`.
-      # @raise [ArgumentError] if `sub_second` is not a `Rational`, or the
-      #   `Integer` 0.
-      # @raise [RangeError] if `sub_second` is a `Rational` but that is less
-      #   than 0 or greater than or equal to 1.
-      def utc(value, sub_second = 0)
-        new(value, sub_second, :utc)
-      end
-
-      private
-
-      # Constructs a new instance of `self` (i.e. {Timestamp} or a subclass of
-      # {Timestamp}) without validating the parameters. This method is used
-      # internally within {Timestamp} to avoid the overhead of checking
-      # parameters.
-      #
-      # @param value [Integer] the number of seconds since 1970-01-01 00:00:00
-      #   UTC ignoring leap seconds.
-      # @param sub_second [Numeric] the fractional part of the second as either
-      #   a `Rational` that is greater than or equal to 0 and less than 1, or
-      #   the `Integer` 0.
-      # @param utc_offset [Object] either `nil` for a {Timestamp} without a
-      #   specified offset, an offset from UTC specified as an `Integer` number
-      #   of seconds or the `Symbol` `:utc`).
-      # @return [Timestamp] a new instance of `self`.
-      def new!(value, sub_second = 0, utc_offset = nil)
-        result = allocate
-        result.send(:initialize!, value, sub_second, utc_offset)
-        result
-      end
-
-      # Creates a {Timestamp} that represents a given `Time`, optionally
-      # ignoring the offset.
-      #
-      # @param time [Time] a `Time`.
-      # @param ignore_offset [Boolean] whether to ignore the offset of `time`.
-      # @param target_utc_offset [Object] if `ignore_offset` is `true`, the UTC
-      #   offset of the result (`:utc`, `nil` or an `Integer`).
-      # @return [Timestamp] the {Timestamp} representation of `time`.
-      def for_time(time, ignore_offset, target_utc_offset)
-        value = time.to_i
-        sub_second = time.subsec
-
-        if ignore_offset
-          utc_offset = target_utc_offset
-          value += time.utc_offset
-        elsif time.utc?
-          utc_offset = :utc
-        else
-          utc_offset = time.utc_offset
-        end
-
-        new!(value, sub_second, utc_offset)
-      end
-
-      # Creates a {Timestamp} that represents a given `DateTime`, optionally
-      # ignoring the offset.
-      #
-      # @param datetime [DateTime] a `DateTime`.
-      # @param ignore_offset [Boolean] whether to ignore the offset of
-      #   `datetime`.
-      # @param target_utc_offset [Object] if `ignore_offset` is `true`, the UTC
-      #   offset of the result (`:utc`, `nil` or an `Integer`).
-      # @return [Timestamp] the {Timestamp} representation of `datetime`.
-      def for_datetime(datetime, ignore_offset, target_utc_offset)
-        value = (datetime.jd - JD_EPOCH) * 86400 + datetime.sec + datetime.min * 60 + datetime.hour * 3600
-        sub_second = datetime.sec_fraction
-
-        if ignore_offset
-          utc_offset = target_utc_offset
-        else
-          utc_offset = (datetime.offset * 86400).to_i
-          value -= utc_offset
-        end
-
-        new!(value, sub_second, utc_offset)
-      end
-
-      # Returns a {Timestamp} that represents another {Timestamp}, optionally
-      # ignoring the offset. If the result would be identical to `value`, the
-      # same instance is returned. If the passed in value is an instance of a
-      # subclass of {Timestamp}, then a new {Timestamp} will always be returned.
-      #
-      # @param timestamp [Timestamp] a {Timestamp}.
-      # @param ignore_offset [Boolean] whether to ignore the offset of
-      #   `timestamp`.
-      # @param target_utc_offset [Object] if `ignore_offset` is `true`, the UTC
-      #   offset of the result (`:utc`, `nil` or an `Integer`).
-      # @return [Timestamp] a [Timestamp] representation of `timestamp`.
-      def for_timestamp(timestamp, ignore_offset, target_utc_offset)
-        if ignore_offset
-          if target_utc_offset
-            unless target_utc_offset == :utc && timestamp.utc? || timestamp.utc_offset == target_utc_offset
-              return new!(timestamp.value + (timestamp.utc_offset || 0), timestamp.sub_second, target_utc_offset)
-            end
-          elsif timestamp.utc_offset
-            return new!(timestamp.value + timestamp.utc_offset, timestamp.sub_second)
-          end
-        end
-
-        unless timestamp.instance_of?(Timestamp)
-          # timestamp is identical in value, sub_second and utc_offset but is a
-          # subclass (i.e. TimestampWithOffset). Return a new Timestamp
-          # instance.
-          return new!(timestamp.value, timestamp.sub_second, timestamp.utc? ? :utc : timestamp.utc_offset)
-        end
-
-        timestamp
-      end
-
-      # Determines if an object is like a `Time` (for the purposes of converting
-      # to a {Timestamp} with {for}), responding to `to_i` and `subsec`.
-      #
-      # @param value [Object] an object to test.
-      # @return [Boolean] `true` if the object is `Time`-like, otherwise
-      #   `false`.
-      def is_time_like?(value)
-        value.respond_to?(:to_i) && value.respond_to?(:subsec)
-      end
-
-      # Creates a {Timestamp} that represents a given `Time`-like object,
-      # optionally ignoring the offset (if the `time_like` responds to
-      # `utc_offset`).
-      #
-      # @param time_like [Object] a `Time`-like object.
-      # @param ignore_offset [Boolean] whether to ignore the offset of `time`.
-      # @param target_utc_offset [Object] if `ignore_offset` is `true`, the UTC
-      #   offset of the result (`:utc`, `nil` or an `Integer`).
-      # @return [Timestamp] the {Timestamp} representation of `time_like`.
-      def for_time_like(time_like, ignore_offset, target_utc_offset)
-        value = time_like.to_i
-        sub_second = time_like.subsec.to_r
-
-        if ignore_offset
-          utc_offset = target_utc_offset
-          value += time_like.utc_offset.to_i if time_like.respond_to?(:utc_offset)
-        elsif time_like.respond_to?(:utc_offset)
-          utc_offset = time_like.utc_offset.to_i
-        else
-          utc_offset = 0
-        end
-
-        new(value, sub_second, utc_offset)
-      end
-    end
-
-    # @return [Integer] the number of seconds since 1970-01-01 00:00:00 UTC
-    #   ignoring leap seconds (i.e. each day is treated as if it were 86,400
-    #   seconds long).
-    attr_reader :value
-
-    # @return [Numeric] the fraction of a second elapsed since timestamp as
-    #   either a `Rational` or the `Integer` 0. Always greater than or equal to
-    #   0 and less than 1.
-    attr_reader :sub_second
-
-    # @return [Integer] the offset from UTC in seconds or `nil` if the
-    #   {Timestamp} doesn't have a specified offset.
-    attr_reader :utc_offset
-
-    # Initializes a new {Timestamp}.
-    #
-    # @param value [Integer] the number of seconds since 1970-01-01 00:00:00 UTC
-    #   ignoring leap seconds.
-    # @param sub_second [Numeric] the fractional part of the second as either a
-    #   `Rational` that is greater than or equal to 0 and less than 1, or
-    #   the `Integer` 0.
-    # @param utc_offset [Object] either `nil` for a {Timestamp} without a
-    #   specified offset, an offset from UTC specified as an `Integer` number of
-    #   seconds or the `Symbol` `:utc`).
-    # @raise [ArgumentError] if `value` is not an `Integer`.
-    # @raise [ArgumentError] if `sub_second` is not a `Rational`, or the
-    #   `Integer` 0.
-    # @raise [RangeError] if `sub_second` is a `Rational` but that is less
-    #   than 0 or greater than or equal to 1.
-    # @raise [ArgumentError] if `utc_offset` is not `nil`, not an `Integer` and
-    #   not the `Symbol` `:utc`.
-    def initialize(value, sub_second = 0, utc_offset = nil)
-      raise ArgumentError, 'value must be an Integer' unless value.kind_of?(Integer)
-      raise ArgumentError, 'sub_second must be a Rational or the Integer 0' unless (sub_second.kind_of?(Integer) && sub_second == 0) || sub_second.kind_of?(Rational)
-      raise RangeError, 'sub_second must be >= 0 and < 1' if sub_second < 0 || sub_second >= 1
-      raise ArgumentError, 'utc_offset must be an Integer, :utc or nil' if utc_offset && utc_offset != :utc && !utc_offset.kind_of?(Integer)
-      initialize!(value, sub_second, utc_offset)
-    end
-
-    # @return [Boolean] `true` if this {Timestamp} represents UTC, `false` if
-    #   the {Timestamp} wasn't specified as UTC or `nil` if the {Timestamp} has
-    #   no specified offset.
-    def utc?
-      @utc
-    end
-
-    # Adds a number of seconds to the {Timestamp} value, setting the UTC offset
-    # of the result.
-    #
-    # @param seconds [Integer] the number of seconds to be added.
-    # @param utc_offset [Object] either `nil` for a {Timestamp} without a
-    #   specified offset, an offset from UTC specified as an `Integer` number of
-    #   seconds or the `Symbol` `:utc`).
-    # @return [Timestamp] the result of adding `seconds` to the
-    #   {Timestamp} value as a new {Timestamp} instance with the chosen
-    #   `utc_offset`.
-    # @raise [ArgumentError] if `seconds` is not an `Integer`.
-    # @raise [ArgumentError] if `utc_offset` is not `nil`, not an `Integer` and
-    #   not the `Symbol` `:utc`.
-    def add_and_set_utc_offset(seconds, utc_offset)
-      raise ArgumentError, 'seconds must be an Integer' unless seconds.kind_of?(Integer)
-      raise ArgumentError, 'utc_offset must be an Integer, :utc or nil' if utc_offset && utc_offset != :utc && !utc_offset.kind_of?(Integer)
-      return self if seconds == 0 && utc_offset == (@utc ? :utc : @utc_offset)
-      Timestamp.send(:new!, @value + seconds, @sub_second, utc_offset)
-    end
-
-    # @return [Timestamp] a UTC {Timestamp} equivalent to this instance. Returns
-    #   `self` if {#utc? self.utc?} is `true`.
-    def utc
-      return self if @utc
-      Timestamp.send(:new!, @value, @sub_second, :utc)
-    end
-
-    # Converts this {Timestamp} to a `Time`.
-    #
-    # @return [Time] a `Time` representation of this {Timestamp}. If the UTC
-    #   offset of this {Timestamp} is not specified, a UTC `Time` will be
-    #   returned.
-    def to_time
-      time = new_time
-
-      if @utc_offset && !@utc
-        time.localtime(@utc_offset)
-      else
-        time.utc
-      end
-    end
-
-    # Converts this {Timestamp} to a Gregorian `DateTime`.
-    #
-    # @return [DateTime] a Gregorian `DateTime` representation of this
-    #   {Timestamp}. If the UTC offset of this {Timestamp} is not specified, a
-    #   UTC `DateTime` will be returned.
-    def to_datetime
-      new_datetime
-    end
-
-    # Converts this {Timestamp} to an `Integer` number of seconds since
-    # 1970-01-01 00:00:00 UTC (ignoring leap seconds).
-    #
-    # @return [Integer] an `Integer` representation of this {Timestamp} (the
-    #   number of seconds since 1970-01-01 00:00:00 UTC ignoring leap seconds).
-    def to_i
-      value
-    end
-
-    # Formats this {Timestamp} according to the directives in the given format
-    # string.
-    #
-    # @param format [String] the format string. Please refer to `Time#strftime`
-    #   for a list of supported format directives.
-    # @return [String] the formatted {Timestamp}.
-    # @raise [ArgumentError] if `format` is not specified.
-    def strftime(format)
-      raise ArgumentError, 'format must be specified' unless format
-      to_time.strftime(format)
-    end
-
-    # @return [String] a `String` representation of this {Timestamp}.
-    def to_s
-      return value_and_sub_second_to_s unless @utc_offset
-      return "#{value_and_sub_second_to_s} UTC" if @utc
-
-      sign = @utc_offset >= 0 ? '+' : '-'
-      min, sec = @utc_offset.abs.divmod(60)
-      hour, min = min.divmod(60)
-
-      "#{value_and_sub_second_to_s(@utc_offset)} #{sign}#{'%02d' % hour}:#{'%02d' % min}#{sec > 0 ? ':%02d' % sec : nil}#{@utc_offset != 0 ? " (#{value_and_sub_second_to_s} UTC)" : nil}"
-    end
-
-    # Compares this {Timestamp} with another.
-    #
-    # {Timestamp} instances without a defined UTC offset are not comparable with
-    # {Timestamp} instances that have a defined UTC offset.
-    #
-    # @param t [Timestamp] the {Timestamp} to compare this instance with.
-    # @return [Integer] -1, 0 or 1 depending if this instance is earlier, equal
-    #   or later than `t` respectively. Returns `nil` when comparing a
-    #   {Timestamp} that does not have a defined UTC offset with a {Timestamp}
-    #   that does have a defined UTC offset. Returns `nil` if `t` is not a
-    #   {Timestamp}.
-    def <=>(t)
-      return nil unless t.kind_of?(Timestamp)
-      return nil if utc_offset && !t.utc_offset
-      return nil if !utc_offset && t.utc_offset
-
-      result = value <=> t.value
-      result = sub_second <=> t.sub_second if result == 0
-      result
-    end
-
-    alias eql? ==
-
-    # @return [Integer] a hash based on the value, sub-second and whether there
-    #   is a defined UTC offset.
-    def hash
-      [@value, @sub_second, !!@utc_offset].hash
-    end
-
-    # @return [String] the internal object state as a programmer-readable
-    #   `String`.
-    def inspect
-      "#<#{self.class}: @value=#{@value}, @sub_second=#{@sub_second}, @utc_offset=#{@utc_offset.inspect}, @utc=#{@utc.inspect}>"
-    end
-
-    protected
-
-    # Creates a new instance of a `Time` or `Time`-like class matching the
-    # {value} and {sub_second} of this {Timestamp}, but not setting the offset.
-    #
-    # @param klass [Class] the class to instantiate.
-    #
-    # @private
-    def new_time(klass = Time)
-      klass.at(@value, @sub_second * 1_000_000)
-    end
-
-    # Constructs a new instance of a `DateTime` or `DateTime`-like class with
-    # the same {value}, {sub_second} and {utc_offset} as this {Timestamp}.
-    #
-    # @param klass [Class] the class to instantiate.
-    #
-    # @private
-    def new_datetime(klass = DateTime)
-      # Can't specify the start parameter unless the jd parameter is an exact number of days.
-      # Use #gregorian instead.
-      datetime = klass.jd(JD_EPOCH + ((@value.to_r + @sub_second) / 86400)).gregorian
-      @utc_offset && @utc_offset != 0 ? datetime.new_offset(Rational(@utc_offset, 86400)) : datetime
-    end
-
-    private
-
-    # Converts the value and sub-seconds to a `String`, adding on the given
-    # offset.
-    #
-    # @param offset [Integer] the offset to add to the value.
-    # @return [String] the value and sub-seconds.
-    def value_and_sub_second_to_s(offset = 0)
-      "#{@value + offset}#{sub_second_to_s}"
-    end
-
-    # Converts the {sub_second} value to a `String` suitable for appending to
-    # the `String` representation of a {Timestamp}.
-    #
-    # @return [String] a `String` representation of {sub_second}.
-    def sub_second_to_s
-      if @sub_second == 0
-        ''
-      else
-        " #{@sub_second.numerator}/#{@sub_second.denominator}"
-      end
-    end
-
-    # Initializes a new {Timestamp} without validating the parameters. This
-    # method is used internally within {Timestamp} to avoid the overhead of
-    # checking parameters.
-    #
-    # @param value [Integer] the number of seconds since 1970-01-01 00:00:00 UTC
-    #   ignoring leap seconds.
-    # @param sub_second [Numeric] the fractional part of the second as either a
-    #   `Rational` that is greater than or equal to 0 and less than 1, or the
-    #   `Integer` 0.
-    # @param utc_offset [Object] either `nil` for a {Timestamp} without a
-    #   specified offset, an offset from UTC specified as an `Integer` number of
-    #   seconds or the `Symbol` `:utc`).
-    def initialize!(value, sub_second = 0, utc_offset = nil)
-      @value = value
-
-      # Convert Rational(0,1) to 0.
-      @sub_second = sub_second == 0 ? 0 : sub_second
-
-      if utc_offset
-        @utc = utc_offset == :utc
-        @utc_offset = @utc ? 0 : utc_offset
-      else
-        @utc = @utc_offset = nil
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timestamp_with_offset.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timestamp_with_offset.rb
deleted file mode 100644
index 5fd6212604e6c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timestamp_with_offset.rb
+++ /dev/null
@@ -1,85 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # A subclass of {Timestamp} used to represent local times.
-  # {TimestampWithOffset} holds a reference to the related {TimezoneOffset} and
-  # overrides various methods to return results appropriate for the
-  # {TimezoneOffset}. Certain operations will clear the associated
-  # {TimezoneOffset} (if the {TimezoneOffset} would not necessarily be valid for
-  # the result). Once the {TimezoneOffset} has been cleared,
-  # {TimestampWithOffset} behaves identically to {Timestamp}.
-  class TimestampWithOffset < Timestamp
-    include WithOffset
-
-    # @return [TimezoneOffset] the {TimezoneOffset} associated with this
-    #   instance.
-    attr_reader :timezone_offset
-
-    # Creates a new {TimestampWithOffset} from a given {Timestamp} and
-    # {TimezoneOffset}.
-    #
-    # @param timestamp [Timestamp] a {Timestamp}.
-    # @param timezone_offset [TimezoneOffset] a {TimezoneOffset} valid at the
-    # time of `timestamp`.
-    # @return [TimestampWithOffset] a {TimestampWithOffset} that has the same
-    #   {value value} and {sub_second sub_second} as the `timestamp` parameter,
-    #   a {utc_offset utc_offset} equal to the
-    #   {TimezoneOffset#observed_utc_offset observed_utc_offset} of the
-    #   `timezone_offset` parameter and {timezone_offset timezone_offset} set to
-    #   the `timezone_offset` parameter.
-    # @raise [ArgumentError] if `timestamp` or `timezone_offset` is `nil`.
-    def self.set_timezone_offset(timestamp, timezone_offset)
-      raise ArgumentError, 'timestamp must be specified' unless timestamp
-      raise ArgumentError, 'timezone_offset must be specified' unless timezone_offset
-      new!(timestamp.value, timestamp.sub_second, timezone_offset.observed_utc_offset).set_timezone_offset(timezone_offset)
-    end
-
-    # Sets the associated {TimezoneOffset} of this {TimestampWithOffset}.
-    #
-    # @param timezone_offset [TimezoneOffset] a {TimezoneOffset} valid at the time
-    #   and for the offset of this {TimestampWithOffset}.
-    # @return [TimestampWithOffset] `self`.
-    # @raise [ArgumentError] if `timezone_offset` is `nil`.
-    # @raise [ArgumentError] if {utc? self.utc?} is `true`.
-    # @raise [ArgumentError] if `timezone_offset.observed_utc_offset` does not equal
-    #   `self.utc_offset`.
-    def set_timezone_offset(timezone_offset)
-      raise ArgumentError, 'timezone_offset must be specified' unless timezone_offset
-      raise ArgumentError, 'timezone_offset.observed_utc_offset does not match self.utc_offset' if utc? || utc_offset != timezone_offset.observed_utc_offset
-      @timezone_offset = timezone_offset
-      self
-    end
-
-    # An overridden version of {Timestamp#to_time} that, if there is an
-    # associated {TimezoneOffset}, returns a {TimeWithOffset} with that offset.
-    #
-    # @return [Time] if there is an associated {TimezoneOffset}, a
-    #   {TimeWithOffset} representation of this {TimestampWithOffset}, otherwise
-    #   a `Time` representation.
-    def to_time
-      to = timezone_offset
-      if to
-        new_time(TimeWithOffset).set_timezone_offset(to)
-      else
-        super
-      end
-    end
-
-    # An overridden version of {Timestamp#to_datetime}, if there is an
-    # associated {TimezoneOffset}, returns a {DateTimeWithOffset} with that
-    # offset.
-    #
-    # @return [DateTime] if there is an associated {TimezoneOffset}, a
-    #   {DateTimeWithOffset} representation of this {TimestampWithOffset},
-    #   otherwise a `DateTime` representation.
-    def to_datetime
-      to = timezone_offset
-      if to
-        new_datetime(DateTimeWithOffset).set_timezone_offset(to)
-      else
-        super
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone.rb
deleted file mode 100644
index 1fb5681307344..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone.rb
+++ /dev/null
@@ -1,1160 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-require 'set'
-
-module TZInfo
-  # {AmbiguousTime} is raised to indicate that a specified local time has more
-  # than one possible equivalent UTC time. Such ambiguities arise when the
-  # clocks are set back in a time zone, most commonly during the repeated hour
-  # when transitioning from daylight savings time to standard time.
-  #
-  # {AmbiguousTime} is raised by {Timezone#local_datetime},
-  # {Timezone#local_time}, {Timezone#local_timestamp}, {Timezone#local_to_utc}
-  # and {Timezone#period_for_local} when using an ambiguous time and not
-  # specifying how to resolve the ambiguity.
-  class AmbiguousTime < StandardError
-  end
-
-  # {PeriodNotFound} is raised to indicate that no {TimezonePeriod} matching a
-  # given time could be found.
-  class PeriodNotFound < StandardError
-  end
-
-  # {InvalidTimezoneIdentifier} is raised by {Timezone.get} if the identifier
-  # given is not valid.
-  class InvalidTimezoneIdentifier < StandardError
-  end
-
-  # {UnknownTimezone} is raised when calling methods on an instance of
-  # {Timezone} that was created directly. To obtain {Timezone} instances the
-  # {Timezone.get} method should be used instead.
-  class UnknownTimezone < StandardError
-  end
-
-  # The {Timezone} class represents a time zone. It provides a factory method,
-  # {get}, to retrieve {Timezone} instances by their identifier.
-  #
-  # The {Timezone#to_local} method can be used to convert `Time` and `DateTime`
-  # instances to the local time for the zone. For example:
-  #
-  #     tz = TZInfo::Timezone.get('America/New_York')
-  #     local_time = tz.to_local(Time.utc(2005,8,29,15,35,0))
-  #     local_datetime = tz.to_local(DateTime.new(2005,8,29,15,35,0))
-  #
-  # Local `Time` and `DateTime` instances returned by `Timezone` have the
-  # correct local offset.
-  #
-  # The {Timezone#local_to_utc} method can by used to convert local `Time` and
-  # `DateTime` instances to UTC. {Timezone#local_to_utc} ignores the UTC offset
-  # of the supplied value and treats if it is a local time for the zone. For
-  # example:
-  #
-  #     tz = TZInfo::Timezone.get('America/New_York')
-  #     utc_time = tz.local_to_utc(Time.new(2005,8,29,11,35,0))
-  #     utc_datetime = tz.local_to_utc(DateTime.new(2005,8,29,11,35,0))
-  #
-  # Each time zone is treated as sequence of periods of time ({TimezonePeriod})
-  # that observe the same offset ({TimezoneOffset}). Transitions
-  # ({TimezoneTransition}) denote the end of one period and the start of the
-  # next. The {Timezone} class has methods that allow the periods, offsets and
-  # transitions of a time zone to be interrogated.
-  #
-  # All methods that take `Time` objects as parameters can be used with
-  # arbitrary `Time`-like objects that respond to both `to_i` and `subsec` and
-  # optionally `utc_offset`.
-  #
-  # The {Timezone} class is thread-safe. It is safe to use class and instance
-  # methods of {Timezone} in concurrently executing threads. Instances of
-  # {Timezone} can be shared across thread boundaries.
-  #
-  # The IANA Time Zone Database maintainers recommend that time zone identifiers
-  # are not made visible to end-users (see [Names of
-  # timezones](https://data.iana.org/time-zones/theory.html#naming)). The
-  # {Country} class can be used to obtain lists of time zones by country,
-  # including user-friendly descriptions and approximate locations.
-  #
-  # @abstract The {get} method returns an instance of either {DataTimezone} or
-  #   {LinkedTimezone}. The {get_proxy} method and other methods returning
-  #   collections of time zones return instances of {TimezoneProxy}.
-  class Timezone
-    include Comparable
-
-    # The default value of the dst parameter of the {local_datetime},
-    # {local_time}, {local_timestamp}, {local_to_utc} and {period_for_local}
-    # methods.
-    #
-    # @!visibility private
-    @@default_dst = nil
-
-    class << self
-      # Sets the default value of the optional `dst` parameter of the
-      # {local_datetime}, {local_time}, {local_timestamp}, {local_to_utc} and
-      # {period_for_local} methods. Can be set to `nil`, `true` or `false`.
-      #
-      # @param value [Boolean] `nil`, `true` or `false`.
-      def default_dst=(value)
-        @@default_dst = value.nil? ? nil : !!value
-      end
-
-      # Returns the default value of the optional `dst` parameter of the
-      # {local_time}, {local_datetime} and {local_timestamp}, {local_to_utc}
-      # and {period_for_local} methods (`nil`, `true` or `false`).
-      #
-      # {default_dst} defaults to `nil` unless changed with {default_dst=}.
-      #
-      # @return [Boolean] the default value of the optional `dst` parameter of
-      #   the {local_time}, {local_datetime} and {local_timestamp},
-      #   {local_to_utc} and {period_for_local} methods (`nil`, `true` or
-      #   `false`).
-      def default_dst
-        @@default_dst
-      end
-
-      # Returns a time zone by its IANA Time Zone Database identifier (e.g.
-      # `"Europe/London"` or `"America/Chicago"`). Call {all_identifiers} for a
-      # list of all the valid identifiers.
-      #
-      # The {get} method will return a subclass of {Timezone}, either a
-      # {DataTimezone} (for a time zone defined by rules that set out when
-      # transitions occur) or a {LinkedTimezone} (for a time zone that is just a
-      # link to or alias for a another time zone).
-      #
-      # @param identifier [String] an IANA Time Zone Database time zone
-      #   identifier.
-      # @return [Timezone] the {Timezone} with the given `identifier`.
-      # @raise [InvalidTimezoneIdentifier] if the `identifier` is not valid.
-      def get(identifier)
-        data_source.get_timezone_info(identifier).create_timezone
-      end
-
-      # Returns a proxy for the time zone with the given identifier. This allows
-      # loading of the time zone data to be deferred until it is first needed.
-      #
-      # The identifier will not be validated. If an invalid identifier is
-      # specified, no exception will be raised until the proxy is used.
-      #
-      # @param identifier [String] an IANA Time Zone Database time zone
-      #   identifier.
-      # @return [TimezoneProxy] a proxy for the time zone with the given
-      #   `identifier`.
-      def get_proxy(identifier)
-        TimezoneProxy.new(identifier)
-      end
-
-      # Returns an `Array` of all the available time zones.
-      #
-      # {TimezoneProxy} instances are returned to avoid the overhead of loading
-      # time zone data until it is first needed.
-      #
-      # @return [Array<Timezone>] all available time zones.
-      def all
-        get_proxies(all_identifiers)
-      end
-
-      # @return [Array<String>] an `Array` containing the identifiers of all the
-      #   available time zones.
-      def all_identifiers
-        data_source.timezone_identifiers
-      end
-
-      # Returns an `Array` of all the available time zones that are
-      # defined by offsets and transitions.
-      #
-      # {TimezoneProxy} instances are returned to avoid the overhead of loading
-      # time zone data until it is first needed.
-      #
-      # @return [Array<Timezone>] an `Array` of all the available time zones
-      #   that are defined by offsets and transitions.
-      def all_data_zones
-        get_proxies(all_data_zone_identifiers)
-      end
-
-      # @return [Array<String>] an `Array` of the identifiers of all available
-      # time zones that are defined by offsets and transitions.
-      def all_data_zone_identifiers
-        data_source.data_timezone_identifiers
-      end
-
-      # Returns an `Array` of all the available time zones that are
-      # defined as links to / aliases for other time zones.
-      #
-      # {TimezoneProxy} instances are returned to avoid the overhead of loading
-      # time zone data until it is first needed.
-      #
-      # @return [Array<Timezone>] an `Array` of all the available time zones
-      #   that are defined as links to / aliases for other time zones.
-      def all_linked_zones
-        get_proxies(all_linked_zone_identifiers)
-      end
-
-      # @return [Array<String>] an `Array` of the identifiers of all available
-      # time zones that are defined as links to / aliases for other time zones.
-      def all_linked_zone_identifiers
-        data_source.linked_timezone_identifiers
-      end
-
-      # Returns an `Array` of all the time zones that are observed by at least
-      # one {Country}. This is not the complete set of time zones as some are
-      # not country specific (e.g. `'Etc/GMT'`).
-      #
-      # {TimezoneProxy} instances are returned to avoid the overhead of loading
-      # time zone data until it is first needed.
-      #
-      # @return [Array<Timezone>] an `Array` of all the time zones that are
-      #   observed by at least one {Country}.
-      def all_country_zones
-        Country.all.map(&:zones).flatten.uniq
-      end
-
-      # Returns an `Array` of the identifiers of all the time zones that are
-      # observed by at least one {Country}. This is not the complete set of time
-      # zone identifiers as some are not country specific (e.g. `'Etc/GMT'`).
-      #
-      # {TimezoneProxy} instances are returned to avoid the overhead of loading
-      # time zone data until it is first needed.
-      #
-      # @return [Array<String>] an `Array` of the identifiers of all the time
-      # zones that are observed by at least one {Country}.
-      def all_country_zone_identifiers
-        Country.all.map(&:zone_identifiers).flatten.uniq
-      end
-
-      private
-
-      # @param [Enumerable<String>] identifiers an `Enumerable` of time zone
-      #   identifiers.
-      # @return [Array<TimezoneProxy>] an `Array` of {TimezoneProxy}
-      #   instances corresponding to the given identifiers.
-      def get_proxies(identifiers)
-        identifiers.collect {|identifier| get_proxy(identifier)}
-      end
-
-      # @return [DataSource] the current DataSource.
-      def data_source
-        DataSource.get
-      end
-    end
-
-    # @return [String] the identifier of the time zone, for example,
-    #   `"Europe/Paris"`.
-    def identifier
-      raise_unknown_timezone
-    end
-
-    # @return [String] the identifier of the time zone, for example,
-    #   `"Europe/Paris"`.
-    def name
-      # Don't use alias, as identifier gets overridden.
-      identifier
-    end
-
-    # @return [String] {identifier}, modified to make it more readable.
-    def to_s
-      friendly_identifier
-    end
-
-    # @return [String] the internal object state as a programmer-readable
-    #   `String`.
-    def inspect
-      "#<#{self.class}: #{identifier}>"
-    end
-
-    # Returns {identifier}, modified to make it more readable. Set
-    # `skip_first_part` to omit the first part of the identifier (typically a
-    # region name) where there is more than one part.
-    #
-    # For example:
-    #
-    #     TZInfo::Timezone.get('Europe/Paris').friendly_identifier(false)         #=> "Europe - Paris"
-    #     TZInfo::Timezone.get('Europe/Paris').friendly_identifier(true)          #=> "Paris"
-    #     TZInfo::Timezone.get('America/Indiana/Knox').friendly_identifier(false) #=> "America - Knox, Indiana"
-    #     TZInfo::Timezone.get('America/Indiana/Knox').friendly_identifier(true)  #=> "Knox, Indiana"
-    #
-    # @param skip_first_part [Boolean] whether the first part of the identifier
-    #   (typically a region name) should be omitted.
-    # @return [String] the modified identifier.
-    def friendly_identifier(skip_first_part = false)
-      id = identifier
-      id = id.encode(Encoding::UTF_8) unless id.encoding.ascii_compatible?
-      parts = id.split('/')
-      if parts.empty?
-        # shouldn't happen
-        identifier
-      elsif parts.length == 1
-        parts[0]
-      else
-        prefix = skip_first_part ? nil : "#{parts[0]} - "
-
-        parts = parts.drop(1).map do |part|
-          part.gsub!(/_/, ' ')
-
-          if part.index(/[a-z]/)
-            # Missing a space if a lower case followed by an upper case and the
-            # name isn't McXxxx.
-            part.gsub!(/([^M][a-z])([A-Z])/, '\1 \2')
-            part.gsub!(/([M][a-bd-z])([A-Z])/, '\1 \2')
-
-            # Missing an apostrophe if two consecutive upper case characters.
-            part.gsub!(/([A-Z])([A-Z])/, '\1\'\2')
-          end
-
-          part
-        end
-
-        "#{prefix}#{parts.reverse.join(', ')}"
-      end
-    end
-
-    # Returns the {TimezonePeriod} that is valid at a given time.
-    #
-    # Unlike {period_for_local} and {period_for_utc}, the UTC offset of the
-    # `time` parameter is taken into consideration.
-    #
-    # @param time [Object] a `Time`, `DateTime` or {Timestamp}.
-    # @return [TimezonePeriod] the {TimezonePeriod} that is valid at `time`.
-    # @raise [ArgumentError] if `time` is `nil`.
-    # @raise [ArgumentError] if `time` is a {Timestamp} with an unspecified
-    #   offset.
-    def period_for(time)
-      raise_unknown_timezone
-    end
-
-    # Returns the set of {TimezonePeriod}s that are valid for the given
-    # local time as an `Array`.
-    #
-    # The UTC offset of the `local_time` parameter is ignored (it is treated as
-    # a time in the time zone represented by `self`).
-    #
-    # This will typically return an `Array` containing a single
-    # {TimezonePeriod}. More than one {TimezonePeriod} will be returned when the
-    # local time is ambiguous (for example, when daylight savings time ends). An
-    # empty `Array` will be returned when the local time is not valid (for
-    # example, when daylight savings time begins).
-    #
-    # To obtain just a single {TimezonePeriod} in all cases, use
-    # {period_for_local} instead and specify how ambiguities should be resolved.
-    #
-    # @param local_time [Object] a `Time`, `DateTime` or {Timestamp}.
-    # @return [Array<TimezonePeriod>] the set of {TimezonePeriod}s that are
-    #   valid at `local_time`.
-    # @raise [ArgumentError] if `local_time` is `nil`.
-    def periods_for_local(local_time)
-      raise_unknown_timezone
-    end
-
-    # Returns an `Array` of {TimezoneTransition} instances representing the
-    # times where the UTC offset of the timezone changes.
-    #
-    # Transitions are returned up to a given time (`to`).
-    #
-    # A from time may also be supplied using the `from` parameter. If from is
-    # not `nil`, only transitions from that time onwards will be returned.
-    #
-    # Comparisons with `to` are exclusive. Comparisons with `from` are
-    # inclusive. If a transition falls precisely on `to`, it will be excluded.
-    # If a transition falls on `from`, it will be included.
-    #
-    # @param to [Object] a `Time`, `DateTime` or {Timestamp} specifying the
-    #   latest (exclusive) transition to return.
-    # @param from [Object] an optional `Time`, `DateTime` or {Timestamp}
-    #   specifying the earliest (inclusive) transition to return.
-    # @return [Array<TimezoneTransition>] the transitions that are earlier than
-    #   `to` and, if specified, at or later than `from`. Transitions are ordered
-    #   by when they occur, from earliest to latest.
-    # @raise [ArgumentError] if `from` is specified and `to` is not greater than
-    #   `from`.
-    # @raise [ArgumentError] is raised if `to` is `nil`.
-    # @raise [ArgumentError] if either `to` or `from` is a {Timestamp} with an
-    #   unspecified offset.
-    def transitions_up_to(to, from = nil)
-      raise_unknown_timezone
-    end
-
-    # Returns the canonical {Timezone} instance for this {Timezone}.
-    #
-    # The IANA Time Zone database contains two types of definition: Zones and
-    # Links. Zones are defined by rules that set out when transitions occur.
-    # Links are just references to fully defined Zone, creating an alias for
-    # that Zone.
-    #
-    # Links are commonly used where a time zone has been renamed in a release of
-    # the Time Zone database. For example, the US/Eastern Zone was renamed as
-    # America/New_York. A US/Eastern Link was added in its place, linking to
-    # (and creating an alias for) America/New_York.
-    #
-    # Links are also used for time zones that are currently identical to a full
-    # Zone, but that are administered separately. For example, Europe/Vatican is
-    # a Link to (and alias for) Europe/Rome.
-    #
-    # For a full Zone (implemented by {DataTimezone}), {canonical_zone} returns
-    # self.
-    #
-    # For a Link (implemented by {LinkedTimezone}), {canonical_zone} returns a
-    # {Timezone} instance representing the full Zone that the link targets.
-    #
-    # TZInfo can be used with different data sources (see the documentation for
-    # {TZInfo::DataSource}). Some DataSource implementations may not support
-    # distinguishing between full Zones and Links and will treat all time zones
-    # as full Zones. In this case, {canonical_zone} will always return `self`.
-    #
-    # There are two built-in DataSource implementations.
-    # {DataSources::RubyDataSource} (which will be used if the tzinfo-data gem
-    # is available) supports Link zones. {DataSources::ZoneinfoDataSource}
-    # returns Link zones as if they were full Zones. If the {canonical_zone} or
-    # {canonical_identifier} methods are needed, the tzinfo-data gem should be
-    # installed.
-    #
-    # The {TZInfo::DataSource.get} method can be used to check which DataSource
-    # implementation is being used.
-    #
-    # @return [Timezone] the canonical {Timezone} instance for this {Timezone}.
-    def canonical_zone
-      raise_unknown_timezone
-    end
-
-    # Returns the {TimezonePeriod} that is valid at a given time.
-    #
-    # The UTC offset of the `utc_time` parameter is ignored (it is treated as a
-    # UTC time). Use the {period_for} method instead if the UTC offset of the
-    # time needs to be taken into consideration.
-    #
-    # @param utc_time [Object] a `Time`, `DateTime` or {Timestamp}.
-    # @return [TimezonePeriod] the {TimezonePeriod} that is valid at `utc_time`.
-    # @raise [ArgumentError] if `utc_time` is `nil`.
-    def period_for_utc(utc_time)
-      raise ArgumentError, 'utc_time must be specified' unless utc_time
-      period_for(Timestamp.for(utc_time, :treat_as_utc))
-    end
-
-    # Returns the {TimezonePeriod} that is valid at the given local time.
-    #
-    # The UTC offset of the `local_time` parameter is ignored (it is treated as
-    # a time in the time zone represented by `self`). Use the {period_for}
-    # method instead if the the UTC offset of the time needs to be taken into
-    # consideration.
-    #
-    # _Warning:_ There are local times that have no equivalent UTC times (for
-    # example, during the transition from standard time to daylight savings
-    # time). There are also local times that have more than one UTC equivalent
-    # (for example, during the transition from daylight savings time to standard
-    # time).
-    #
-    # In the first case (no equivalent UTC time), a {PeriodNotFound} exception
-    # will be raised.
-    #
-    # In the second case (more than one equivalent UTC time), an {AmbiguousTime}
-    # exception will be raised unless the optional `dst` parameter or block
-    # handles the ambiguity.
-    #
-    # If the ambiguity is due to a transition from daylight savings time to
-    # standard time, the `dst` parameter can be used to select whether the
-    # daylight savings time or local time is used. For example, the following
-    # code would raise an {AmbiguousTime} exception:
-    #
-    #     tz = TZInfo::Timezone.get('America/New_York')
-    #     tz.period_for_local(Time.new(2004,10,31,1,30,0))
-    #
-    # Specifying `dst = true` would select the daylight savings period from
-    # April to October 2004. Specifying `dst = false` would return the
-    # standard time period from October 2004 to April 2005.
-    #
-    # The `dst` parameter will not be able to resolve an ambiguity resulting
-    # from the clocks being set back without changing from daylight savings time
-    # to standard time. In this case, if a block is specified, it will be called
-    # to resolve the ambiguity. The block must take a single parameter - an
-    # `Array` of {TimezonePeriod}s that need to be resolved. The block can
-    # select and return a single {TimezonePeriod} or return `nil` or an empty
-    # `Array` to cause an {AmbiguousTime} exception to be raised.
-    #
-    # The default value of the `dst` parameter can be specified using
-    # {Timezone.default_dst=}.
-    #
-    # @param local_time [Object] a `Time`, `DateTime` or {Timestamp}.
-    # @param dst [Boolean] whether to resolve ambiguous local times by always
-    #   selecting the period observing daylight savings time (`true`), always
-    #   selecting the period observing standard time (`false`), or leaving the
-    #   ambiguity unresolved (`nil`).
-    # @yield [periods] if the `dst` parameter did not resolve an ambiguity, an
-    #   optional block is yielded to.
-    # @yieldparam periods [Array<TimezonePeriod>] an `Array` containing all
-    #   the {TimezonePeriod}s that still match `local_time` after applying the
-    #   `dst` parameter.
-    # @yieldreturn [Object] to resolve the ambiguity: a chosen {TimezonePeriod}
-    #   or an `Array` containing a chosen {TimezonePeriod}; to leave the
-    #   ambiguity unresolved: an empty `Array`, an `Array` containing more than
-    #   one {TimezonePeriod}, or `nil`.
-    # @return [TimezonePeriod] the {TimezonePeriod} that is valid at
-    #   `local_time`.
-    # @raise [ArgumentError] if `local_time` is `nil`.
-    # @raise [PeriodNotFound] if `local_time` is not valid for the time zone
-    #   (there is no equivalent UTC time).
-    # @raise [AmbiguousTime] if `local_time` was ambiguous for the time zone and
-    #   the `dst` parameter or block did not resolve the ambiguity.
-    def period_for_local(local_time, dst = Timezone.default_dst)
-      raise ArgumentError, 'local_time must be specified' unless local_time
-      local_time = Timestamp.for(local_time, :ignore)
-      results = periods_for_local(local_time)
-
-      if results.empty?
-        raise PeriodNotFound, "#{local_time.strftime('%Y-%m-%d %H:%M:%S')} is an invalid local time."
-      elsif results.size < 2
-        results.first
-      else
-        # ambiguous result try to resolve
-
-        if !dst.nil?
-          matches = results.find_all {|period| period.dst? == dst}
-          results = matches if !matches.empty?
-        end
-
-        if results.size < 2
-          results.first
-        else
-          # still ambiguous, try the block
-
-          if block_given?
-            results = yield results
-          end
-
-          if results.is_a?(TimezonePeriod)
-            results
-          elsif results && results.size == 1
-            results.first
-          else
-            raise AmbiguousTime, "#{local_time.strftime('%Y-%m-%d %H:%M:%S')} is an ambiguous local time."
-          end
-        end
-      end
-    end
-
-    # Converts a time to the local time for the time zone.
-    #
-    # The result will be of type {TimeWithOffset} (if passed a `Time`),
-    # {DateTimeWithOffset} (if passed a `DateTime`) or {TimestampWithOffset} (if
-    # passed a {Timestamp}). {TimeWithOffset}, {DateTimeWithOffset} and
-    # {TimestampWithOffset} are subclasses of `Time`, `DateTime` and {Timestamp}
-    # that provide additional information about the local result.
-    #
-    # Unlike {utc_to_local}, {to_local} takes the UTC offset of the given time
-    # into consideration.
-    #
-    # @param time [Object] a `Time`, `DateTime` or {Timestamp}.
-    # @return [Object] the local equivalent of `time` as a {TimeWithOffset},
-    #   {DateTimeWithOffset} or {TimestampWithOffset}.
-    # @raise [ArgumentError] if `time` is `nil`.
-    # @raise [ArgumentError] if `time` is a {Timestamp} that does not have a
-    #   specified UTC offset.
-    def to_local(time)
-      raise ArgumentError, 'time must be specified' unless time
-
-      Timestamp.for(time) do |ts|
-        TimestampWithOffset.set_timezone_offset(ts, period_for(ts).offset)
-      end
-    end
-
-    # Converts a time in UTC to the local time for the time zone.
-    #
-    # The result will be of type {TimeWithOffset} (if passed a `Time`),
-    # {DateTimeWithOffset} (if passed a `DateTime`) or {TimestampWithOffset} (if
-    # passed a {Timestamp}). {TimeWithOffset}, {DateTimeWithOffset} and
-    # {TimestampWithOffset} are subclasses of `Time`, `DateTime` and {Timestamp}
-    # that provide additional information about the local result.
-    #
-    # The UTC offset of the `utc_time` parameter is ignored (it is treated as a
-    # UTC time). Use the {to_local} method instead if the the UTC offset of the
-    # time needs to be taken into consideration.
-    #
-    # @param utc_time [Object] a `Time`, `DateTime` or {Timestamp}.
-    # @return [Object] the local equivalent of `utc_time` as a {TimeWithOffset},
-    #   {DateTimeWithOffset} or {TimestampWithOffset}.
-    # @raise [ArgumentError] if `utc_time` is `nil`.
-    def utc_to_local(utc_time)
-      raise ArgumentError, 'utc_time must be specified' unless utc_time
-
-      Timestamp.for(utc_time, :treat_as_utc) do |ts|
-        to_local(ts)
-      end
-    end
-
-    # Converts a local time for the time zone to UTC.
-    #
-    # The result will either be a `Time`, `DateTime` or {Timestamp} according to
-    # the type of the `local_time` parameter.
-    #
-    # The UTC offset of the `local_time` parameter is ignored (it is treated as
-    # a time in the time zone represented by `self`).
-    #
-    # _Warning:_ There are local times that have no equivalent UTC times (for
-    # example, during the transition from standard time to daylight savings
-    # time). There are also local times that have more than one UTC equivalent
-    # (for example, during the transition from daylight savings time to standard
-    # time).
-    #
-    # In the first case (no equivalent UTC time), a {PeriodNotFound} exception
-    # will be raised.
-    #
-    # In the second case (more than one equivalent UTC time), an {AmbiguousTime}
-    # exception will be raised unless the optional `dst` parameter or block
-    # handles the ambiguity.
-    #
-    # If the ambiguity is due to a transition from daylight savings time to
-    # standard time, the `dst` parameter can be used to select whether the
-    # daylight savings time or local time is used. For example, the following
-    # code would raise an {AmbiguousTime} exception:
-    #
-    #     tz = TZInfo::Timezone.get('America/New_York')
-    #     tz.period_for_local(Time.new(2004,10,31,1,30,0))
-    #
-    # Specifying `dst = true` would select the daylight savings period from
-    # April to October 2004. Specifying `dst = false` would return the
-    # standard time period from October 2004 to April 2005.
-    #
-    # The `dst` parameter will not be able to resolve an ambiguity resulting
-    # from the clocks being set back without changing from daylight savings time
-    # to standard time. In this case, if a block is specified, it will be called
-    # to resolve the ambiguity. The block must take a single parameter - an
-    # `Array` of {TimezonePeriod}s that need to be resolved. The block can
-    # select and return a single {TimezonePeriod} or return `nil` or an empty
-    # `Array` to cause an {AmbiguousTime} exception to be raised.
-    #
-    # The default value of the `dst` parameter can be specified using
-    # {Timezone.default_dst=}.
-    #
-    # @param local_time [Object] a `Time`, `DateTime` or {Timestamp}.
-    # @param dst [Boolean] whether to resolve ambiguous local times by always
-    #   selecting the period observing daylight savings time (`true`), always
-    #   selecting the period observing standard time (`false`), or leaving the
-    #   ambiguity unresolved (`nil`).
-    # @yield [periods] if the `dst` parameter did not resolve an ambiguity, an
-    #   optional block is yielded to.
-    # @yieldparam periods [Array<TimezonePeriod>] an `Array` containing all
-    #   the {TimezonePeriod}s that still match `local_time` after applying the
-    #   `dst` parameter.
-    # @yieldreturn [Object] to resolve the ambiguity: a chosen {TimezonePeriod}
-    #   or an `Array` containing a chosen {TimezonePeriod}; to leave the
-    #   ambiguity unresolved: an empty `Array`, an `Array` containing more than
-    #   one {TimezonePeriod}, or `nil`.
-    # @return [Object] the UTC equivalent of `local_time` as a `Time`,
-    #   `DateTime` or {Timestamp}.
-    # @raise [ArgumentError] if `local_time` is `nil`.
-    # @raise [PeriodNotFound] if `local_time` is not valid for the time zone
-    #   (there is no equivalent UTC time).
-    # @raise [AmbiguousTime] if `local_time` was ambiguous for the time zone and
-    #   the `dst` parameter or block did not resolve the ambiguity.
-    def local_to_utc(local_time, dst = Timezone.default_dst)
-      raise ArgumentError, 'local_time must be specified' unless local_time
-
-      Timestamp.for(local_time, :ignore) do |ts|
-        period = if block_given?
-          period_for_local(ts, dst) {|periods| yield periods }
-        else
-          period_for_local(ts, dst)
-        end
-
-        ts.add_and_set_utc_offset(-period.observed_utc_offset, :utc)
-      end
-    end
-
-    # Creates a `Time` object based on the given (Gregorian calendar) date and
-    # time parameters. The parameters are interpreted as a local time in the
-    # time zone. The result has the appropriate `utc_offset`, `zone` and
-    # {TimeWithOffset#timezone_offset timezone_offset}.
-    #
-    # _Warning:_ There are time values that are not valid as local times in a
-    # time zone (for example, during the transition from standard time to
-    # daylight savings time). There are also time values that are ambiguous,
-    # occurring more than once with different offsets to UTC (for example,
-    # during the transition from daylight savings time to standard time).
-    #
-    # In the first case (an invalid local time), a {PeriodNotFound} exception
-    # will be raised.
-    #
-    # In the second case (more than one occurrence), an {AmbiguousTime}
-    # exception will be raised unless the optional `dst` parameter or block
-    # handles the ambiguity.
-    #
-    # If the ambiguity is due to a transition from daylight savings time to
-    # standard time, the `dst` parameter can be used to select whether the
-    # daylight savings time or local time is used. For example, the following
-    # code would raise an {AmbiguousTime} exception:
-    #
-    #     tz = TZInfo::Timezone.get('America/New_York')
-    #     tz.local_time(2004,10,31,1,30,0,0)
-    #
-    # Specifying `dst = true` would return a `Time` with a UTC offset of -4
-    # hours and abbreviation EDT (Eastern Daylight Time). Specifying `dst =
-    # false` would return a `Time` with a UTC offset of -5 hours and
-    # abbreviation EST (Eastern Standard Time).
-    #
-    # The `dst` parameter will not be able to resolve an ambiguity resulting
-    # from the clocks being set back without changing from daylight savings time
-    # to standard time. In this case, if a block is specified, it will be called
-    # to resolve the ambiguity. The block must take a single parameter - an
-    # `Array` of {TimezonePeriod}s that need to be resolved. The block can
-    # select and return a single {TimezonePeriod} or return `nil` or an empty
-    # `Array` to cause an {AmbiguousTime} exception to be raised.
-    #
-    # The default value of the `dst` parameter can be specified using
-    # {Timezone.default_dst=}.
-    #
-    # @param year [Integer] the year.
-    # @param month [Integer] the month (1-12).
-    # @param day [Integer] the day of the month (1-31).
-    # @param hour [Integer] the hour (0-23).
-    # @param minute [Integer] the minute (0-59).
-    # @param second [Integer] the second (0-59).
-    # @param sub_second [Numeric] the fractional part of the second as either
-    #   a `Rational` that is greater than or equal to 0 and less than 1, or
-    #   the `Integer` 0.
-    # @param dst [Boolean] whether to resolve ambiguous local times by always
-    #   selecting the period observing daylight savings time (`true`), always
-    #   selecting the period observing standard time (`false`), or leaving the
-    #   ambiguity unresolved (`nil`).
-    # @yield [periods] if the `dst` parameter did not resolve an ambiguity, an
-    #   optional block is yielded to.
-    # @yieldparam periods [Array<TimezonePeriod>] an `Array` containing all
-    #   the {TimezonePeriod}s that still match `local_time` after applying the
-    #   `dst` parameter.
-    # @yieldreturn [Object] to resolve the ambiguity: a chosen {TimezonePeriod}
-    #   or an `Array` containing a chosen {TimezonePeriod}; to leave the
-    #   ambiguity unresolved: an empty `Array`, an `Array` containing more than
-    #   one {TimezonePeriod}, or `nil`.
-    # @return [TimeWithOffset] a new `Time` object based on the given values,
-    #   interpreted as a local time in the time zone.
-    # @raise [ArgumentError] if either of `year`, `month`, `day`, `hour`,
-    #   `minute`, or `second` is not an `Integer`.
-    # @raise [ArgumentError] if `sub_second` is not a `Rational`, or the
-    #   `Integer` 0.
-    # @raise [ArgumentError] if `utc_offset` is not `nil`, not an `Integer`
-    #   and not the `Symbol` `:utc`.
-    # @raise [RangeError] if `month` is not between 1 and 12.
-    # @raise [RangeError] if `day` is not between 1 and 31.
-    # @raise [RangeError] if `hour` is not between 0 and 23.
-    # @raise [RangeError] if `minute` is not between 0 and 59.
-    # @raise [RangeError] if `second` is not between 0 and 59.
-    # @raise [RangeError] if `sub_second` is a `Rational` but that is less
-    #   than 0 or greater than or equal to 1.
-    # @raise [PeriodNotFound] if the date and time parameters do not specify a
-    #   valid local time in the time zone.
-    # @raise [AmbiguousTime] if the date and time parameters are ambiguous for
-    #   the time zone and the `dst` parameter or block did not resolve the
-    #   ambiguity.
-    def local_time(year, month = 1, day = 1, hour = 0, minute = 0, second = 0, sub_second = 0, dst = Timezone.default_dst, &block)
-      local_timestamp(year, month, day, hour, minute, second, sub_second, dst, &block).to_time
-    end
-
-    # Creates a `DateTime` object based on the given (Gregorian calendar) date
-    # and time parameters. The parameters are interpreted as a local time in the
-    # time zone. The result has the appropriate `offset` and
-    # {DateTimeWithOffset#timezone_offset timezone_offset}.
-    #
-    # _Warning:_ There are time values that are not valid as local times in a
-    # time zone (for example, during the transition from standard time to
-    # daylight savings time). There are also time values that are ambiguous,
-    # occurring more than once with different offsets to UTC (for example,
-    # during the transition from daylight savings time to standard time).
-    #
-    # In the first case (an invalid local time), a {PeriodNotFound} exception
-    # will be raised.
-    #
-    # In the second case (more than one occurrence), an {AmbiguousTime}
-    # exception will be raised unless the optional `dst` parameter or block
-    # handles the ambiguity.
-    #
-    # If the ambiguity is due to a transition from daylight savings time to
-    # standard time, the `dst` parameter can be used to select whether the
-    # daylight savings time or local time is used. For example, the following
-    # code would raise an {AmbiguousTime} exception:
-    #
-    #     tz = TZInfo::Timezone.get('America/New_York')
-    #     tz.local_datetime(2004,10,31,1,30,0,0)
-    #
-    # Specifying `dst = true` would return a `Time` with a UTC offset of -4
-    # hours and abbreviation EDT (Eastern Daylight Time). Specifying `dst =
-    # false` would return a `Time` with a UTC offset of -5 hours and
-    # abbreviation EST (Eastern Standard Time).
-    #
-    # The `dst` parameter will not be able to resolve an ambiguity resulting
-    # from the clocks being set back without changing from daylight savings time
-    # to standard time. In this case, if a block is specified, it will be called
-    # to resolve the ambiguity. The block must take a single parameter - an
-    # `Array` of {TimezonePeriod}s that need to be resolved. The block can
-    # select and return a single {TimezonePeriod} or return `nil` or an empty
-    # `Array` to cause an {AmbiguousTime} exception to be raised.
-    #
-    # The default value of the `dst` parameter can be specified using
-    # {Timezone.default_dst=}.
-    #
-    # @param year [Integer] the year.
-    # @param month [Integer] the month (1-12).
-    # @param day [Integer] the day of the month (1-31).
-    # @param hour [Integer] the hour (0-23).
-    # @param minute [Integer] the minute (0-59).
-    # @param second [Integer] the second (0-59).
-    # @param sub_second [Numeric] the fractional part of the second as either
-    #   a `Rational` that is greater than or equal to 0 and less than 1, or
-    #   the `Integer` 0.
-    # @param dst [Boolean] whether to resolve ambiguous local times by always
-    #   selecting the period observing daylight savings time (`true`), always
-    #   selecting the period observing standard time (`false`), or leaving the
-    #   ambiguity unresolved (`nil`).
-    # @yield [periods] if the `dst` parameter did not resolve an ambiguity, an
-    #   optional block is yielded to.
-    # @yieldparam periods [Array<TimezonePeriod>] an `Array` containing all
-    #   the {TimezonePeriod}s that still match `local_time` after applying the
-    #   `dst` parameter.
-    # @yieldreturn [Object] to resolve the ambiguity: a chosen {TimezonePeriod}
-    #   or an `Array` containing a chosen {TimezonePeriod}; to leave the
-    #   ambiguity unresolved: an empty `Array`, an `Array` containing more than
-    #   one {TimezonePeriod}, or `nil`.
-    # @return [DateTimeWithOffset] a new `DateTime` object based on the given
-    # values, interpreted as a local time in the time zone.
-    # @raise [ArgumentError] if either of `year`, `month`, `day`, `hour`,
-    #   `minute`, or `second` is not an `Integer`.
-    # @raise [ArgumentError] if `sub_second` is not a `Rational`, or the
-    #   `Integer` 0.
-    # @raise [ArgumentError] if `utc_offset` is not `nil`, not an `Integer`
-    #   and not the `Symbol` `:utc`.
-    # @raise [RangeError] if `month` is not between 1 and 12.
-    # @raise [RangeError] if `day` is not between 1 and 31.
-    # @raise [RangeError] if `hour` is not between 0 and 23.
-    # @raise [RangeError] if `minute` is not between 0 and 59.
-    # @raise [RangeError] if `second` is not between 0 and 59.
-    # @raise [RangeError] if `sub_second` is a `Rational` but that is less
-    #   than 0 or greater than or equal to 1.
-    # @raise [PeriodNotFound] if the date and time parameters do not specify a
-    #   valid local time in the time zone.
-    # @raise [AmbiguousTime] if the date and time parameters are ambiguous for
-    #   the time zone and the `dst` parameter or block did not resolve the
-    #   ambiguity.
-    def local_datetime(year, month = 1, day = 1, hour = 0, minute = 0, second = 0, sub_second = 0, dst = Timezone.default_dst, &block)
-      local_timestamp(year, month, day, hour, minute, second, sub_second, dst, &block).to_datetime
-    end
-
-    # Creates a {Timestamp} object based on the given (Gregorian calendar) date
-    # and time parameters. The parameters are interpreted as a local time in the
-    # time zone. The result has the appropriate {Timestamp#utc_offset
-    # utc_offset} and {TimestampWithOffset#timezone_offset timezone_offset}.
-    #
-    # _Warning:_ There are time values that are not valid as local times in a
-    # time zone (for example, during the transition from standard time to
-    # daylight savings time). There are also time values that are ambiguous,
-    # occurring more than once with different offsets to UTC (for example,
-    # during the transition from daylight savings time to standard time).
-    #
-    # In the first case (an invalid local time), a {PeriodNotFound} exception
-    # will be raised.
-    #
-    # In the second case (more than one occurrence), an {AmbiguousTime}
-    # exception will be raised unless the optional `dst` parameter or block
-    # handles the ambiguity.
-    #
-    # If the ambiguity is due to a transition from daylight savings time to
-    # standard time, the `dst` parameter can be used to select whether the
-    # daylight savings time or local time is used. For example, the following
-    # code would raise an {AmbiguousTime} exception:
-    #
-    #     tz = TZInfo::Timezone.get('America/New_York')
-    #     tz.local_timestamp(2004,10,31,1,30,0,0)
-    #
-    # Specifying `dst = true` would return a `Time` with a UTC offset of -4
-    # hours and abbreviation EDT (Eastern Daylight Time). Specifying `dst =
-    # false` would return a `Time` with a UTC offset of -5 hours and
-    # abbreviation EST (Eastern Standard Time).
-    #
-    # The `dst` parameter will not be able to resolve an ambiguity resulting
-    # from the clocks being set back without changing from daylight savings time
-    # to standard time. In this case, if a block is specified, it will be called
-    # to resolve the ambiguity. The block must take a single parameter - an
-    # `Array` of {TimezonePeriod}s that need to be resolved. The block can
-    # select and return a single {TimezonePeriod} or return `nil` or an empty
-    # `Array` to cause an {AmbiguousTime} exception to be raised.
-    #
-    # The default value of the `dst` parameter can be specified using
-    # {Timezone.default_dst=}.
-    #
-    # @param year [Integer] the year.
-    # @param month [Integer] the month (1-12).
-    # @param day [Integer] the day of the month (1-31).
-    # @param hour [Integer] the hour (0-23).
-    # @param minute [Integer] the minute (0-59).
-    # @param second [Integer] the second (0-59).
-    # @param sub_second [Numeric] the fractional part of the second as either
-    #   a `Rational` that is greater than or equal to 0 and less than 1, or
-    #   the `Integer` 0.
-    # @param dst [Boolean] whether to resolve ambiguous local times by always
-    #   selecting the period observing daylight savings time (`true`), always
-    #   selecting the period observing standard time (`false`), or leaving the
-    #   ambiguity unresolved (`nil`).
-    # @yield [periods] if the `dst` parameter did not resolve an ambiguity, an
-    #   optional block is yielded to.
-    # @yieldparam periods [Array<TimezonePeriod>] an `Array` containing all
-    #   the {TimezonePeriod}s that still match `local_time` after applying the
-    #   `dst` parameter.
-    # @yieldreturn [Object] to resolve the ambiguity: a chosen {TimezonePeriod}
-    #   or an `Array` containing a chosen {TimezonePeriod}; to leave the
-    #   ambiguity unresolved: an empty `Array`, an `Array` containing more than
-    #   one {TimezonePeriod}, or `nil`.
-    # @return [TimestampWithOffset] a new {Timestamp} object based on the given
-    #   values, interpreted as a local time in the time zone.
-    # @raise [ArgumentError] if either of `year`, `month`, `day`, `hour`,
-    #   `minute`, or `second` is not an `Integer`.
-    # @raise [ArgumentError] if `sub_second` is not a `Rational`, or the
-    #   `Integer` 0.
-    # @raise [ArgumentError] if `utc_offset` is not `nil`, not an `Integer`
-    #   and not the `Symbol` `:utc`.
-    # @raise [RangeError] if `month` is not between 1 and 12.
-    # @raise [RangeError] if `day` is not between 1 and 31.
-    # @raise [RangeError] if `hour` is not between 0 and 23.
-    # @raise [RangeError] if `minute` is not between 0 and 59.
-    # @raise [RangeError] if `second` is not between 0 and 59.
-    # @raise [RangeError] if `sub_second` is a `Rational` but that is less
-    #   than 0 or greater than or equal to 1.
-    # @raise [PeriodNotFound] if the date and time parameters do not specify a
-    #   valid local time in the time zone.
-    # @raise [AmbiguousTime] if the date and time parameters are ambiguous for
-    #   the time zone and the `dst` parameter or block did not resolve the
-    #   ambiguity.
-    def local_timestamp(year, month = 1, day = 1, hour = 0, minute = 0, second = 0, sub_second = 0, dst = Timezone.default_dst, &block)
-      ts = Timestamp.create(year, month, day, hour, minute, second, sub_second)
-      timezone_offset = period_for_local(ts, dst, &block).offset
-      utc_offset = timezone_offset.observed_utc_offset
-      TimestampWithOffset.new(ts.value - utc_offset, sub_second, utc_offset).set_timezone_offset(timezone_offset)
-    end
-
-    # Returns the unique offsets used by the time zone up to a given time (`to`)
-    # as an `Array` of {TimezoneOffset} instances.
-    #
-    # A from time may also be supplied using the `from` parameter. If from is
-    # not `nil`, only offsets used from that time onwards will be returned.
-    #
-    # Comparisons with `to` are exclusive. Comparisons with `from` are
-    # inclusive.
-    #
-    # @param to [Object] a `Time`, `DateTime` or {Timestamp} specifying the
-    #   latest (exclusive) offset to return.
-    # @param from [Object] an optional `Time`, `DateTime` or {Timestamp}
-    #   specifying the earliest (inclusive) offset to return.
-    # @return [Array<TimezoneOffsets>] the offsets that are used earlier than
-    #   `to` and, if specified, at or later than `from`. Offsets may be returned
-    #   in any order.
-    # @raise [ArgumentError] if `from` is specified and `to` is not greater than
-    #   `from`.
-    # @raise [ArgumentError] is raised if `to` is `nil`.
-    # @raise [ArgumentError] if either `to` or `from` is a {Timestamp} with an
-    #   unspecified offset.
-    def offsets_up_to(to, from = nil)
-      raise ArgumentError, 'to must be specified' unless to
-
-      to_timestamp = Timestamp.for(to)
-      from_timestamp = from && Timestamp.for(from)
-      transitions = transitions_up_to(to_timestamp, from_timestamp)
-
-      if transitions.empty?
-        # No transitions in the range, find the period that covers it.
-
-        if from_timestamp
-          # Use the from date as it is inclusive.
-          period = period_for(from_timestamp)
-        else
-          # to is exclusive, so this can't be used with period_for. However, any
-          # time earlier than to can be used. Subtract 1 hour.
-          period = period_for(to_timestamp.add_and_set_utc_offset(-3600, :utc))
-        end
-
-        [period.offset]
-      else
-        result = Set.new
-
-        first = transitions.first
-        result << first.previous_offset unless from_timestamp && first.at == from_timestamp
-
-        transitions.each do |t|
-          result << t.offset
-        end
-
-        result.to_a
-      end
-    end
-
-    # Returns the canonical identifier of this time zone.
-    #
-    # This is a shortcut for calling `canonical_zone.identifier`. Please refer
-    # to the {canonical_zone} documentation for further information.
-    #
-    # @return [String] the canonical identifier of this time zone.
-    def canonical_identifier
-      canonical_zone.identifier
-    end
-
-    # @return [TimeWithOffset] the current local time in the time zone.
-    def now
-      to_local(Time.now)
-    end
-
-    # @return [TimezonePeriod] the current {TimezonePeriod} for the time zone.
-    def current_period
-      period_for(Time.now)
-    end
-
-    # Returns the current local time and {TimezonePeriod} for the time zone as
-    # an `Array`. The first element is the time as a {TimeWithOffset}. The
-    # second element is the period.
-    #
-    # @return [Array] an `Array` containing the current {TimeWithOffset} for the
-    #   time zone as the first element and the current {TimezonePeriod} for the
-    #   time zone as the second element.
-    def current_time_and_period
-      period = nil
-
-      local_time = Timestamp.for(Time.now) do |ts|
-        period = period_for(ts)
-        TimestampWithOffset.set_timezone_offset(ts, period.offset)
-      end
-
-      [local_time, period]
-    end
-    alias current_period_and_time current_time_and_period
-
-    # Converts a time to local time for the time zone and returns a `String`
-    # representation of the local time according to the given format.
-    #
-    # `Timezone#strftime` first expands any occurrences of `%Z` in the format
-    # string to the time zone abbreviation for the local time (for example, EST
-    # or EDT). Depending on the type of `time` parameter, the result of the
-    # expansion is then passed to either `Time#strftime`, `DateTime#strftime` or
-    # `Timestamp#strftime` to handle any other format directives.
-    #
-    # This method is equivalent to the following:
-    #
-    #     time_zone.to_local(time).strftime(format)
-    #
-    # @param format [String] the format string.
-    # @param time [Object] a `Time`, `DateTime` or `Timestamp`.
-    # @return [String] the formatted local time.
-    # @raise [ArgumentError] if `format` or `time` is `nil`.
-    # @raise [ArgumentError] if `time` is a {Timestamp} with an unspecified UTC
-    #   offset.
-    def strftime(format, time = Time.now)
-      to_local(time).strftime(format)
-    end
-
-    # @param time [Object] a `Time`, `DateTime` or `Timestamp`.
-    # @return [String] the abbreviation of this {Timezone} at the given time.
-    # @raise [ArgumentError] if `time` is `nil`.
-    # @raise [ArgumentError] if `time` is a {Timestamp} with an unspecified UTC
-    #   offset.
-    def abbreviation(time = Time.now)
-      period_for(time).abbreviation
-    end
-    alias abbr abbreviation
-
-    # @param time [Object] a `Time`, `DateTime` or `Timestamp`.
-    # @return [Boolean] whether daylight savings time is in effect at the given
-    #   time.
-    # @raise [ArgumentError] if `time` is `nil`.
-    # @raise [ArgumentError] if `time` is a {Timestamp} with an unspecified UTC
-    #   offset.
-    def dst?(time = Time.now)
-      period_for(time).dst?
-    end
-
-    # Returns the base offset from UTC in seconds at the given time. This does
-    # not include any adjustment made for daylight savings time and will
-    # typically remain constant throughout the year.
-    #
-    # To obtain the observed offset from UTC, including the effect of daylight
-    # savings time, use {observed_utc_offset} instead.
-    #
-    # If you require accurate {base_utc_offset} values, you should install the
-    # tzinfo-data gem and set {DataSources::RubyDataSource} as the {DataSource}.
-    # When using {DataSources::ZoneinfoDataSource}, the value of
-    # {base_utc_offset} has to be derived from changes to the observed UTC
-    # offset and DST status since it is not included in zoneinfo files.
-    #
-    # @param time [Object] a `Time`, `DateTime` or `Timestamp`.
-    # @return [Integer] the base offset from UTC in seconds at the given time.
-    # @raise [ArgumentError] if `time` is `nil`.
-    # @raise [ArgumentError] if `time` is a {Timestamp} with an unspecified UTC
-    #   offset.
-    def base_utc_offset(time = Time.now)
-      period_for(time).base_utc_offset
-    end
-
-    # Returns the observed offset from UTC in seconds at the given time. This
-    # includes adjustments made for daylight savings time.
-    #
-    # @param time [Object] a `Time`, `DateTime` or `Timestamp`.
-    # @return [Integer] the observed offset from UTC in seconds at the given
-    #   time.
-    # @raise [ArgumentError] if `time` is `nil`.
-    # @raise [ArgumentError] if `time` is a {Timestamp} with an unspecified UTC
-    #   offset.
-    def observed_utc_offset(time = Time.now)
-      period_for(time).observed_utc_offset
-    end
-    alias utc_offset observed_utc_offset
-
-    # Compares this {Timezone} with another based on the {identifier}.
-    #
-    # @param tz [Object] an `Object` to compare this {Timezone} with.
-    # @return [Integer] -1 if `tz` is less than `self`, 0 if `tz` is equal to
-    #   `self` and +1 if `tz` is greater than `self`, or `nil` if `tz` is not an
-    #   instance of {Timezone}.
-    def <=>(tz)
-      return nil unless tz.is_a?(Timezone)
-      identifier <=> tz.identifier
-    end
-
-    # @param tz [Object] an `Object` to compare this {Timezone} with.
-    # @return [Boolean] `true` if `tz` is an instance of {Timezone} and has the
-    #   same {identifier} as `self`, otherwise `false`.
-    def eql?(tz)
-      self == tz
-    end
-
-    # @return [Integer] a hash based on the {identifier}.
-    def hash
-      identifier.hash
-    end
-
-    # Matches `regexp` against the {identifier} of this {Timezone}.
-    #
-    # @param regexp [Regexp] a `Regexp` to match against the {identifier} of
-    #   this {Timezone}.
-    # @return [Integer] the position the match starts, or `nil` if there is no
-    #   match.
-    def =~(regexp)
-      regexp =~ identifier
-    end
-
-    # Returns a serialized representation of this {Timezone}. This method is
-    # called when using `Marshal.dump` with an instance of {Timezone}.
-    #
-    # @param limit [Integer] the maximum depth to dump - ignored.
-    # @return [String] a serialized representation of this {Timezone}.
-    def _dump(limit)
-      identifier
-    end
-
-    # Loads a {Timezone} from the serialized representation returned by {_dump}.
-    # This is method is called when using `Marshal.load` or `Marshal.restore`
-    # to restore a serialized {Timezone}.
-    #
-    # @param data [String] a serialized representation of a {Timezone}.
-    # @return [Timezone] the result of converting `data` back into a {Timezone}.
-    def self._load(data)
-      Timezone.get(data)
-    end
-
-    private
-
-    # Raises an {UnknownTimezone} exception.
-    #
-    # @raise [UnknownTimezone] always.
-    def raise_unknown_timezone
-      raise UnknownTimezone, 'TZInfo::Timezone should not be constructed directly (use TZInfo::Timezone.get instead)'
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone_offset.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone_offset.rb
deleted file mode 100644
index 25c98c38ac8c3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone_offset.rb
+++ /dev/null
@@ -1,111 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # Represents an offset from UTC observed by a time zone.
-  class TimezoneOffset
-    # Returns the base offset from UTC in seconds (`observed_utc_offset -
-    # std_offset`). This does not include any adjustment made for daylight
-    # savings time and will typically remain constant throughout the year.
-    #
-    # To obtain the currently observed offset from UTC, including the effect of
-    # daylight savings time, use {observed_utc_offset} instead.
-    #
-    # If you require accurate {base_utc_offset} values, you should install the
-    # tzinfo-data gem and set {DataSources::RubyDataSource} as the {DataSource}.
-    # When using {DataSources::ZoneinfoDataSource}, the value of
-    # {base_utc_offset} has to be derived from changes to the observed UTC
-    # offset and DST status since it is not included in zoneinfo files.
-    #
-    # @return [Integer] the base offset from UTC in seconds.
-    attr_reader :base_utc_offset
-    alias utc_offset base_utc_offset
-
-    # Returns the offset from the time zone's standard time in seconds
-    # (`observed_utc_offset - base_utc_offset`). Zero when daylight savings time
-    # is not in effect. Non-zero (usually 3600 = 1 hour) if daylight savings is
-    # being observed.
-    #
-    # If you require accurate {std_offset} values, you should install the
-    # tzinfo-data gem and set {DataSources::RubyDataSource} as the {DataSource}.
-    # When using {DataSources::ZoneinfoDataSource}, the value of {std_offset}
-    # has to be derived from changes to the observed UTC offset and DST status
-    # since it is not included in zoneinfo files.
-    #
-    # @return [Integer] the offset from the time zone's standard time in
-    #   seconds.
-    attr_reader :std_offset
-
-    # Returns the observed offset from UTC in seconds (`base_utc_offset +
-    # std_offset`). This includes adjustments made for daylight savings time.
-    #
-    # @return [Integer] the observed offset from UTC in seconds.
-    attr_reader :observed_utc_offset
-    alias utc_total_offset observed_utc_offset
-
-    # The abbreviation that identifies this offset. For example GMT
-    # (Greenwich Mean Time) or BST (British Summer Time) for Europe/London.
-    #
-    # @return [String] the abbreviation that identifies this offset.
-    attr_reader :abbreviation
-    alias abbr abbreviation
-
-    # Initializes a new {TimezoneOffset}.
-    #
-    # {TimezoneOffset} instances should not normally be constructed manually.
-    #
-    # The passed in `abbreviation` instance will be frozen.
-    #
-    # @param base_utc_offset [Integer] the base offset from UTC in seconds.
-    # @param std_offset [Integer] the offset from standard time in seconds.
-    # @param abbreviation [String] the abbreviation identifying the offset.
-    def initialize(base_utc_offset, std_offset, abbreviation)
-      @base_utc_offset = base_utc_offset
-      @std_offset = std_offset
-      @abbreviation = abbreviation.freeze
-
-      @observed_utc_offset = @base_utc_offset + @std_offset
-    end
-
-    # Determines if daylight savings is in effect (i.e. if {std_offset} is
-    # non-zero).
-    #
-    # @return [Boolean] `true` if {std_offset} is non-zero, otherwise `false`.
-    def dst?
-      @std_offset != 0
-    end
-
-    # Determines if this {TimezoneOffset} is equal to another instance.
-    #
-    # @param toi [Object] the instance to test for equality.
-    # @return [Boolean] `true` if `toi` is a {TimezoneOffset} with the same
-    #   {utc_offset}, {std_offset} and {abbreviation} as this {TimezoneOffset},
-    #   otherwise `false`.
-    def ==(toi)
-      toi.kind_of?(TimezoneOffset) &&
-        base_utc_offset == toi.base_utc_offset && std_offset == toi.std_offset && abbreviation == toi.abbreviation
-    end
-
-    # Determines if this {TimezoneOffset} is equal to another instance.
-    #
-    # @param toi [Object] the instance to test for equality.
-    # @return [Boolean] `true` if `toi` is a {TimezoneOffset} with the same
-    #   {utc_offset}, {std_offset} and {abbreviation} as this {TimezoneOffset},
-    #   otherwise `false`.
-    def eql?(toi)
-      self == toi
-    end
-
-    # @return [Integer] a hash based on {utc_offset}, {std_offset} and
-    #   {abbreviation}.
-    def hash
-      [@base_utc_offset, @std_offset, @abbreviation].hash
-    end
-
-    # @return [String] the internal object state as a programmer-readable
-    #   `String`.
-    def inspect
-      "#<#{self.class}: @base_utc_offset=#{@base_utc_offset}, @std_offset=#{@std_offset}, @abbreviation=#{@abbreviation}>"
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone_period.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone_period.rb
deleted file mode 100644
index a2cc985a94015..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone_period.rb
+++ /dev/null
@@ -1,179 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # {TimezonePeriod} represents a period of time for a time zone where the same
-  # offset from UTC applies. It provides access to the observed offset, time
-  # zone abbreviation, start time and end time.
-  #
-  # The period of time can be unbounded at the start, end, or both the start
-  # and end.
-  #
-  # @abstract Time zone period data will returned as an instance of one of the
-  #  subclasses of {TimezonePeriod}.
-  class TimezonePeriod
-    # @return [TimezoneOffset] the offset that applies in the period of time.
-    attr_reader :offset
-
-    # Initializes a {TimezonePeriod}.
-    #
-    # @param offset [TimezoneOffset] the offset that is observed for the period
-    #   of time.
-    # @raise [ArgumentError] if `offset` is `nil`.
-    def initialize(offset)
-      raise ArgumentError, 'offset must be specified' unless offset
-      @offset = offset
-    end
-
-    # @return [TimezoneTransition] the transition that defines the start of this
-    #   {TimezonePeriod} (`nil` if the start is unbounded).
-    def start_transition
-      raise_not_implemented(:start_transition)
-    end
-
-    # @return [TimezoneTransition] the transition that defines the end of this
-    #   {TimezonePeriod} (`nil` if the end is unbounded).
-    def end_transition
-      raise_not_implemented(:end_transition)
-    end
-
-    # Returns the base offset from UTC in seconds (`observed_utc_offset -
-    # std_offset`). This does not include any adjustment made for daylight
-    # savings time and will typically remain constant throughout the year.
-    #
-    # To obtain the currently observed offset from UTC, including the effect of
-    # daylight savings time, use {observed_utc_offset} instead.
-    #
-    # If you require accurate {base_utc_offset} values, you should install the
-    # tzinfo-data gem and set {DataSources::RubyDataSource} as the {DataSource}.
-    # When using {DataSources::ZoneinfoDataSource}, the value of
-    # {base_utc_offset} has to be derived from changes to the observed UTC
-    # offset and DST status since it is not included in zoneinfo files.
-    #
-    # @return [Integer] the base offset from UTC in seconds.
-    def base_utc_offset
-      @offset.base_utc_offset
-    end
-    alias utc_offset base_utc_offset
-
-    # Returns the offset from the time zone's standard time in seconds
-    # (`observed_utc_offset - base_utc_offset`). Zero when daylight savings time
-    # is not in effect. Non-zero (usually 3600 = 1 hour) if daylight savings is
-    # being observed.
-    #
-    # If you require accurate {std_offset} values, you should install the
-    # tzinfo-data gem and set {DataSources::RubyDataSource} as the {DataSource}.
-    # When using {DataSources::ZoneinfoDataSource}, the value of {std_offset}
-    # has to be derived from changes to the observed UTC offset and DST status
-    # since it is not included in zoneinfo files.
-    #
-    # @return [Integer] the offset from the time zone's standard time in
-    #   seconds.
-    def std_offset
-      @offset.std_offset
-    end
-
-    # The abbreviation that identifies this offset. For example GMT
-    # (Greenwich Mean Time) or BST (British Summer Time) for Europe/London.
-    #
-    # @return [String] the abbreviation that identifies this offset.
-    def abbreviation
-      @offset.abbreviation
-    end
-    alias abbr abbreviation
-    alias zone_identifier abbreviation
-
-    # Returns the observed offset from UTC in seconds (`base_utc_offset +
-    # std_offset`). This includes adjustments made for daylight savings time.
-    #
-    # @return [Integer] the observed offset from UTC in seconds.
-    def observed_utc_offset
-      @offset.observed_utc_offset
-    end
-    alias utc_total_offset observed_utc_offset
-
-    # Determines if daylight savings is in effect (i.e. if {std_offset} is
-    # non-zero).
-    #
-    # @return [Boolean] `true` if {std_offset} is non-zero, otherwise `false`.
-    def dst?
-      @offset.dst?
-    end
-
-    # Returns the UTC start time of the period or `nil` if the start of the
-    # period is unbounded.
-    #
-    # The result is returned as a {Timestamp}. To obtain the start time as a
-    # `Time` or `DateTime`, call either {Timestamp#to_time to_time} or
-    # {Timestamp#to_datetime to_datetime} on the result.
-    #
-    # @return [Timestamp] the UTC start time of the period or `nil` if the start
-    #   of the period is unbounded.
-    def starts_at
-      timestamp(start_transition)
-    end
-
-    # Returns the UTC end time of the period or `nil` if the end of the period
-    # is unbounded.
-    #
-    # The result is returned as a {Timestamp}. To obtain the end time as a
-    # `Time` or `DateTime`, call either {Timestamp#to_time to_time} or
-    # {Timestamp#to_datetime to_datetime} on the result.
-    #
-    # @return [Timestamp] the UTC end time of the period or `nil` if the end of
-    #   the period is unbounded.
-    def ends_at
-      timestamp(end_transition)
-    end
-
-    # Returns the local start time of the period or `nil` if the start of the
-    # period is unbounded.
-    #
-    # The result is returned as a {TimestampWithOffset}. To obtain the start
-    # time as a `Time` or `DateTime`, call either {TimestampWithOffset#to_time
-    # to_time} or {TimestampWithOffset#to_datetime to_datetime} on the result.
-    #
-    # @return [TimestampWithOffset] the local start time of the period or `nil`
-    #   if the start of the period is unbounded.
-    def local_starts_at
-      timestamp_with_offset(start_transition)
-    end
-
-    # Returns the local end time of the period or `nil` if the end of the period
-    # is unbounded.
-    #
-    # The result is returned as a {TimestampWithOffset}. To obtain the end time
-    # as a `Time` or `DateTime`, call either {TimestampWithOffset#to_time
-    # to_time} or {TimestampWithOffset#to_datetime to_datetime} on the result.
-    #
-    # @return [TimestampWithOffset] the local end time of the period or `nil` if
-    #   the end of the period is unbounded.
-    def local_ends_at
-      timestamp_with_offset(end_transition)
-    end
-
-    private
-
-    # Raises a {NotImplementedError} to indicate that subclasses should override
-    # a method.
-    #
-    # @raise [NotImplementedError] always.
-    def raise_not_implemented(method_name)
-      raise NotImplementedError, "Subclasses must override #{method_name}"
-    end
-
-    # @param  transition [TimezoneTransition] a transition or `nil`.
-    # @return [Timestamp] the {Timestamp} representing when a transition occurs,
-    #   or `nil` if `transition` is `nil`.
-    def timestamp(transition)
-      transition ? transition.at : nil
-    end
-
-    # @param transition [TimezoneTransition] a transition or `nil`.
-    # @return [TimestampWithOffset] a {Timestamp} representing when a transition
-    #   occurs with offset set to {#offset}, or `nil` if `transition` is `nil`.
-    def timestamp_with_offset(transition)
-      transition ? TimestampWithOffset.set_timezone_offset(transition.at, offset) : nil
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone_proxy.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone_proxy.rb
deleted file mode 100644
index 749f8408de281..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone_proxy.rb
+++ /dev/null
@@ -1,96 +0,0 @@
-# encoding: UTF-8
-
-module TZInfo
-
-  # A proxy class standing in for a {Timezone} with a given identifier.
-  # {TimezoneProxy} inherits from {Timezone} and can be treated identically to
-  # {Timezone} instances loaded with {Timezone.get}.
-  #
-  # {TimezoneProxy} instances are used to avoid the performance overhead of
-  # loading time zone data into memory, for example, by {Timezone.all}.
-  #
-  # The first time an attempt is made to access the data for the time zone, the
-  # real {Timezone} will be loaded is loaded. If the proxy's identifier was not
-  # valid, then an exception will be raised at this point.
-  class TimezoneProxy < Timezone
-    # Initializes a new {TimezoneProxy}.
-    #
-    # The `identifier` parameter is not checked when initializing the proxy. It
-    # will be validated when the real {Timezone} instance is loaded.
-    #
-    # @param identifier [String] an IANA Time Zone Database time zone
-    #   identifier.
-    def initialize(identifier)
-      super()
-      @identifier = identifier
-      @real_timezone = nil
-    end
-
-    # (see Timezone#identifier)
-    def identifier
-      @real_timezone ? @real_timezone.identifier : @identifier
-    end
-
-    # (see Timezone#period_for)
-    def period_for(time)
-      real_timezone.period_for_utc(time)
-    end
-
-    # (see Timezone#periods_for_local)
-    def periods_for_local(local_time)
-      real_timezone.periods_for_local(local_time)
-    end
-
-    # (see Timezone#transitions_up_to)
-    def transitions_up_to(to, from = nil)
-      real_timezone.transitions_up_to(to, from)
-    end
-
-    # (see Timezone#canonical_zone)
-    def canonical_zone
-      real_timezone.canonical_zone
-    end
-
-    # Returns a serialized representation of this {TimezoneProxy}. This method
-    # is called when using `Marshal.dump` with an instance of {TimezoneProxy}.
-    #
-    # @param limit [Integer] the maximum depth to dump - ignored. @return
-    #   [String] a serialized representation of this {TimezoneProxy}.
-    # @return [String] a serialized representation of this {TimezoneProxy}.
-    def _dump(limit)
-      identifier
-    end
-
-    # Loads a {TimezoneProxy} from the serialized representation returned by
-    # {_dump}. This is method is called when using `Marshal.load` or
-    # `Marshal.restore` to restore a serialized {Timezone}.
-    #
-    # @param data [String] a serialized representation of a {TimezoneProxy}.
-    # @return [TimezoneProxy] the result of converting `data` back into a
-    #   {TimezoneProxy}.
-    def self._load(data)
-      TimezoneProxy.new(data)
-    end
-
-    private
-
-    # Returns the real {Timezone} instance being proxied.
-    #
-    # The real {Timezone} is loaded using {Timezone.get} on the first access.
-    #
-    # @return [Timezone] the real {Timezone} instance being proxied.
-    def real_timezone
-      # Thread-safety: It is possible that the value of @real_timezone may be
-      # calculated multiple times in concurrently executing threads. It is not
-      # worth the overhead of locking to ensure that @real_timezone is only
-      # calculated once.
-      unless @real_timezone
-        result = Timezone.get(@identifier)
-        return result if frozen?
-        @real_timezone = result
-      end
-
-      @real_timezone
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone_transition.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone_transition.rb
deleted file mode 100644
index db75b2330f506..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/timezone_transition.rb
+++ /dev/null
@@ -1,98 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # Represents a transition from one observed UTC offset ({TimezoneOffset} to
-  # another for a time zone.
-  class TimezoneTransition
-    # @return [TimezoneOffset] the offset this transition changes to.
-    attr_reader :offset
-
-    # @return [TimezoneOffset] the offset this transition changes from.
-    attr_reader :previous_offset
-
-    # When this transition occurs as an `Integer` number of seconds since
-    # 1970-01-01 00:00:00 UTC ignoring leap seconds (i.e. each day is treated as
-    # if it were 86,400 seconds long). Equivalent to the result of calling the
-    # {Timestamp#value value} method on the {Timestamp} returned by {at}.
-    #
-    # @return [Integer] when this transition occurs as a number of seconds since
-    #   1970-01-01 00:00:00 UTC ignoring leap seconds.
-    attr_reader :timestamp_value
-
-    # Initializes a new {TimezoneTransition}.
-    #
-    # {TimezoneTransition} instances should not normally be constructed
-    # manually.
-    #
-    # @param offset [TimezoneOffset] the offset the transition changes to.
-    # @param previous_offset [TimezoneOffset] the offset the transition changes
-    #   from.
-    # @param timestamp_value [Integer] when the transition occurs as a
-    #   number of seconds since 1970-01-01 00:00:00 UTC ignoring leap seconds
-    #   (i.e. each day is treated as if it were 86,400 seconds long).
-    def initialize(offset, previous_offset, timestamp_value)
-      @offset = offset
-      @previous_offset = previous_offset
-      @timestamp_value = timestamp_value
-    end
-
-    # Returns a {Timestamp} instance representing the UTC time when this
-    # transition occurs.
-    #
-    # To obtain the result as a `Time` or `DateTime`, call either
-    # {Timestamp#to_time to_time} or {Timestamp#to_datetime to_datetime} on the
-    # {Timestamp} instance that is returned.
-    #
-    # @return [Timestamp] the UTC time when this transition occurs.
-    def at
-      Timestamp.utc(@timestamp_value)
-    end
-
-    # Returns a {TimestampWithOffset} instance representing the local time when
-    # this transition causes the previous observance to end (calculated from
-    # {at} using {previous_offset}).
-    #
-    # To obtain the result as a `Time` or `DateTime`, call either
-    # {TimestampWithOffset#to_time to_time} or {TimestampWithOffset#to_datetime
-    # to_datetime} on the {TimestampWithOffset} instance that is returned.
-    #
-    # @return [TimestampWithOffset] the local time when this transition causes
-    #   the previous observance to end.
-    def local_end_at
-      TimestampWithOffset.new(@timestamp_value, 0, @previous_offset.observed_utc_offset).set_timezone_offset(@previous_offset)
-    end
-
-    # Returns a {TimestampWithOffset} instance representing the local time when
-    # this transition causes the next observance to start (calculated from {at}
-    # using {offset}).
-    #
-    # To obtain the result as a `Time` or `DateTime`, call either
-    # {TimestampWithOffset#to_time to_time} or {TimestampWithOffset#to_datetime
-    # to_datetime} on the {TimestampWithOffset} instance that is returned.
-    #
-    # @return [TimestampWithOffset] the local time when this transition causes
-    #   the next observance to start.
-    def local_start_at
-      TimestampWithOffset.new(@timestamp_value, 0, @offset.observed_utc_offset).set_timezone_offset(@offset)
-    end
-
-    # Determines if this {TimezoneTransition} is equal to another instance.
-    #
-    # @param tti [Object] the instance to test for equality.
-    # @return [Boolean] `true` if `tti` is a {TimezoneTransition} with the same
-    #   {offset}, {previous_offset} and {timestamp_value} as this
-    #   {TimezoneTransition}, otherwise `false`.
-    def ==(tti)
-      tti.kind_of?(TimezoneTransition) &&
-        offset == tti.offset && previous_offset == tti.previous_offset && timestamp_value == tti.timestamp_value
-    end
-    alias eql? ==
-
-    # @return [Integer] a hash based on {offset}, {previous_offset} and
-    #   {timestamp_value}.
-    def hash
-      [@offset, @previous_offset, @timestamp_value].hash
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/transition_rule.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/transition_rule.rb
deleted file mode 100644
index 58ef5684feac9..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/transition_rule.rb
+++ /dev/null
@@ -1,455 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # Base class for rules definining the transition between standard and daylight
-  # savings time.
-  #
-  # @abstract
-  # @private
-  class TransitionRule #:nodoc:
-    # Returns the number of seconds after midnight local time on the day
-    # identified by the rule at which the transition occurs. Can be negative to
-    # denote a time on the prior day. Can be greater than or equal to 86,400 to
-    # denote a time of the following day.
-    #
-    # @return [Integer] the time in seconds after midnight local time at which
-    #   the transition occurs.
-    attr_reader :transition_at
-
-    # Initializes a new {TransitionRule}.
-    #
-    # @param transition_at [Integer] the time in seconds after midnight local
-    #   time at which the transition occurs.
-    # @raise [ArgumentError] if `transition_at` is not an `Integer`.
-    def initialize(transition_at)
-      raise ArgumentError, 'Invalid transition_at' unless transition_at.kind_of?(Integer)
-      @transition_at = transition_at
-    end
-
-    # Calculates the time of the transition from a given offset on a given year.
-    #
-    # @param offset [TimezoneOffset] the current offset at the time the rule
-    #   will transition.
-    # @param year [Integer] the year in which the transition occurs (local
-    #   time).
-    # @return [TimestampWithOffset] the time at which the transition occurs.
-    def at(offset, year)
-      day = get_day(offset, year)
-      TimestampWithOffset.set_timezone_offset(Timestamp.for(day + @transition_at), offset)
-    end
-
-    # Determines if this {TransitionRule} is equal to another instance.
-    #
-    # @param r [Object] the instance to test for equality.
-    # @return [Boolean] `true` if `r` is a {TransitionRule} with the same
-    #   {transition_at} as this {TransitionRule}, otherwise `false`.
-    def ==(r)
-      r.kind_of?(TransitionRule) && @transition_at == r.transition_at
-    end
-    alias eql? ==
-
-    # @return [Integer] a hash based on {hash_args} (defaulting to
-    #  {transition_at}).
-    def hash
-      hash_args.hash
-    end
-
-    protected
-
-    # @return [Array] an `Array` of parameters that will influence the output of
-    #  {hash}.
-    def hash_args
-      [@transition_at]
-    end
-  end
-  private_constant :TransitionRule
-
-  # A base class for transition rules that activate based on an integer day of
-  # the year.
-  #
-  # @abstract
-  # @private
-  class DayOfYearTransitionRule < TransitionRule #:nodoc:
-    # Initializes a new {DayOfYearTransitionRule}.
-    #
-    # @param day [Integer] the day of the year on which the transition occurs.
-    #   The precise meaning is defined by subclasses.
-    # @param transition_at [Integer] the time in seconds after midnight local
-    #   time at which the transition occurs.
-    # @raise [ArgumentError] if `transition_at` is not an `Integer`.
-    # @raise [ArgumentError] if `day` is not an `Integer`.
-    def initialize(day, transition_at)
-      super(transition_at)
-      raise ArgumentError, 'Invalid day' unless day.kind_of?(Integer)
-      @seconds = day * 86400
-    end
-
-    # Determines if this {DayOfYearTransitionRule} is equal to another instance.
-    #
-    # @param r [Object] the instance to test for equality.
-    # @return [Boolean] `true` if `r` is a {DayOfYearTransitionRule} with the
-    #   same {transition_at} and day as this {DayOfYearTransitionRule},
-    #   otherwise `false`.
-    def ==(r)
-      super(r) && r.kind_of?(DayOfYearTransitionRule) && @seconds == r.seconds
-    end
-    alias eql? ==
-
-    protected
-
-    # @return [Integer] the day multipled by the number of seconds in a day.
-    attr_reader :seconds
-
-    # (see TransitionRule#hash_args)
-    def hash_args
-      [@seconds] + super
-    end
-  end
-  private_constant :DayOfYearTransitionRule
-
-  # Defines transitions that occur on the zero-based nth day of the year.
-  #
-  # Day 0 is 1 January.
-  #
-  # Leap days are counted. Day 59 will be 29 February on a leap year and 1 March
-  # on a non-leap year. Day 365 will be 31 December on a leap year and 1 January
-  # the following year on a non-leap year.
-  #
-  # @private
-  class AbsoluteDayOfYearTransitionRule < DayOfYearTransitionRule #:nodoc:
-    # Initializes a new {AbsoluteDayOfYearTransitionRule}.
-    #
-    # @param day [Integer] the zero-based day of the year on which the
-    #   transition occurs (0 to 365 inclusive).
-    # @param transition_at [Integer] the time in seconds after midnight local
-    #   time at which the transition occurs.
-    # @raise [ArgumentError] if `transition_at` is not an `Integer`.
-    # @raise [ArgumentError] if `day` is not an `Integer`.
-    # @raise [ArgumentError] if `day` is less than 0 or greater than 365.
-    def initialize(day, transition_at = 0)
-      super(day, transition_at)
-      raise ArgumentError, 'Invalid day' unless day >= 0 && day <= 365
-    end
-
-    # @return [Boolean] `true` if the day specified by this transition is the
-    #   first in the year (a day number of 0), otherwise `false`.
-    def is_always_first_day_of_year?
-      seconds == 0
-    end
-
-    # @return [Boolean] `false`.
-    def is_always_last_day_of_year?
-      false
-    end
-
-    # Determines if this {AbsoluteDayOfYearTransitionRule} is equal to another
-    # instance.
-    #
-    # @param r [Object] the instance to test for equality.
-    # @return [Boolean] `true` if `r` is a {AbsoluteDayOfYearTransitionRule}
-    #   with the same {transition_at} and day as this
-    #   {AbsoluteDayOfYearTransitionRule}, otherwise `false`.
-    def ==(r)
-      super(r) && r.kind_of?(AbsoluteDayOfYearTransitionRule)
-    end
-    alias eql? ==
-
-    protected
-
-    # Returns a `Time` representing midnight local time on the day specified by
-    # the rule for the given offset and year.
-    #
-    # @param offset [TimezoneOffset] the current offset at the time of the
-    #  transition.
-    # @param year [Integer] the year in which the transition occurs.
-    # @return [Time] midnight local time on the day specified by the rule for
-    #  the given offset and year.
-    def get_day(offset, year)
-      Time.new(year, 1, 1, 0, 0, 0, offset.observed_utc_offset) + seconds
-    end
-
-    # (see TransitionRule#hash_args)
-    def hash_args
-      [AbsoluteDayOfYearTransitionRule] + super
-    end
-  end
-
-  # Defines transitions that occur on the one-based nth Julian day of the year.
-  #
-  # Leap days are not counted. Day 1 is 1 January. Day 60 is always 1 March.
-  # Day 365 is always 31 December.
-  #
-  # @private
-  class JulianDayOfYearTransitionRule < DayOfYearTransitionRule #:nodoc:
-    # The 60 days in seconds.
-    LEAP = 60 * 86400
-    private_constant :LEAP
-
-    # The length of a non-leap year in seconds.
-    YEAR = 365 * 86400
-    private_constant :YEAR
-
-    # Initializes a new {JulianDayOfYearTransitionRule}.
-    #
-    # @param day [Integer] the one-based Julian day of the year on which the
-    #   transition occurs (1 to 365 inclusive).
-    # @param transition_at [Integer] the time in seconds after midnight local
-    #   time at which the transition occurs.
-    # @raise [ArgumentError] if `transition_at` is not an `Integer`.
-    # @raise [ArgumentError] if `day` is not an `Integer`.
-    # @raise [ArgumentError] if `day` is less than 1 or greater than 365.
-    def initialize(day, transition_at = 0)
-      super(day, transition_at)
-      raise ArgumentError, 'Invalid day' unless day >= 1 && day <= 365
-    end
-
-    # @return [Boolean] `true` if the day specified by this transition is the
-    #   first in the year (a day number of 1), otherwise `false`.
-    def is_always_first_day_of_year?
-      seconds == 86400
-    end
-
-    # @return [Boolean] `true` if the day specified by this transition is the
-    #   last in the year (a day number of 365), otherwise `false`.
-    def is_always_last_day_of_year?
-      seconds == YEAR
-    end
-
-    # Determines if this {JulianDayOfYearTransitionRule} is equal to another
-    # instance.
-    #
-    # @param r [Object] the instance to test for equality.
-    # @return [Boolean] `true` if `r` is a {JulianDayOfYearTransitionRule} with
-    #   the same {transition_at} and day as this
-    #   {JulianDayOfYearTransitionRule}, otherwise `false`.
-    def ==(r)
-      super(r) && r.kind_of?(JulianDayOfYearTransitionRule)
-    end
-    alias eql? ==
-
-    protected
-
-    # Returns a `Time` representing midnight local time on the day specified by
-    # the rule for the given offset and year.
-    #
-    # @param offset [TimezoneOffset] the current offset at the time of the
-    #  transition.
-    # @param year [Integer] the year in which the transition occurs.
-    # @return [Time] midnight local time on the day specified by the rule for
-    #  the given offset and year.
-    def get_day(offset, year)
-      # Returns 1 March on non-leap years.
-      leap = Time.new(year, 2, 29, 0, 0, 0, offset.observed_utc_offset)
-      diff = seconds - LEAP
-      diff += 86400 if diff >= 0 && leap.mday == 29
-      leap + diff
-    end
-
-    # (see TransitionRule#hash_args)
-    def hash_args
-      [JulianDayOfYearTransitionRule] + super
-    end
-  end
-  private_constant :JulianDayOfYearTransitionRule
-
-  # A base class for rules that transition on a particular day of week of a
-  # given week (subclasses specify which week of the month).
-  #
-  # @abstract
-  # @private
-  class DayOfWeekTransitionRule < TransitionRule #:nodoc:
-    # Initializes a new {DayOfWeekTransitionRule}.
-    #
-    # @param month [Integer] the month of the year when the transition occurs.
-    # @param day_of_week [Integer] the day of the week when the transition
-    #   occurs. 0 is Sunday, 6 is Saturday.
-    # @param transition_at [Integer] the time in seconds after midnight local
-    #   time at which the transition occurs.
-    # @raise [ArgumentError] if `transition_at` is not an `Integer`.
-    # @raise [ArgumentError] if `month` is not an `Integer`.
-    # @raise [ArgumentError] if `month` is less than 1 or greater than 12.
-    # @raise [ArgumentError] if `day_of_week` is not an `Integer`.
-    # @raise [ArgumentError] if `day_of_week` is less than 0 or greater than 6.
-    def initialize(month, day_of_week, transition_at)
-      super(transition_at)
-      raise ArgumentError, 'Invalid month' unless month.kind_of?(Integer) && month >= 1 && month <= 12
-      raise ArgumentError, 'Invalid day_of_week' unless day_of_week.kind_of?(Integer) && day_of_week >= 0 && day_of_week <= 6
-      @month = month
-      @day_of_week = day_of_week
-    end
-
-    # @return [Boolean] `false`.
-    def is_always_first_day_of_year?
-      false
-    end
-
-    # @return [Boolean] `false`.
-    def is_always_last_day_of_year?
-      false
-    end
-
-    # Determines if this {DayOfWeekTransitionRule} is equal to another
-    # instance.
-    #
-    # @param r [Object] the instance to test for equality.
-    # @return [Boolean] `true` if `r` is a {DayOfWeekTransitionRule} with the
-    #   same {transition_at}, month and day of week as this
-    #   {DayOfWeekTransitionRule}, otherwise `false`.
-    def ==(r)
-      super(r) && r.kind_of?(DayOfWeekTransitionRule) && @month == r.month && @day_of_week == r.day_of_week
-    end
-    alias eql? ==
-
-    protected
-
-    # @return [Integer] the month of the year (1 to 12).
-    attr_reader :month
-
-    # @return [Integer] the day of the week (0 to 6 for Sunday to Monday).
-    attr_reader :day_of_week
-
-    # (see TransitionRule#hash_args)
-    def hash_args
-      [@month, @day_of_week] + super
-    end
-  end
-  private_constant :DayOfWeekTransitionRule
-
-  # A rule that transitions on the nth occurrence of a particular day of week
-  # of a calendar month.
-  #
-  # @private
-  class DayOfMonthTransitionRule < DayOfWeekTransitionRule #:nodoc:
-    # Initializes a new {DayOfMonthTransitionRule}.
-    #
-    # @param month [Integer] the month of the year when the transition occurs.
-    # @param week [Integer] the week of the month when the transition occurs (1
-    #   to 4).
-    # @param day_of_week [Integer] the day of the week when the transition
-    #   occurs. 0 is Sunday, 6 is Saturday.
-    # @param transition_at [Integer] the time in seconds after midnight local
-    #   time at which the transition occurs.
-    # @raise [ArgumentError] if `transition_at` is not an `Integer`.
-    # @raise [ArgumentError] if `month` is not an `Integer`.
-    # @raise [ArgumentError] if `month` is less than 1 or greater than 12.
-    # @raise [ArgumentError] if `week` is not an `Integer`.
-    # @raise [ArgumentError] if `week` is less than 1 or greater than 4.
-    # @raise [ArgumentError] if `day_of_week` is not an `Integer`.
-    # @raise [ArgumentError] if `day_of_week` is less than 0 or greater than 6.
-    def initialize(month, week, day_of_week, transition_at = 0)
-      super(month, day_of_week, transition_at)
-      raise ArgumentError, 'Invalid week' unless week.kind_of?(Integer) && week >= 1 && week <= 4
-      @offset_start = (week - 1) * 7 + 1
-    end
-
-    # Determines if this {DayOfMonthTransitionRule} is equal to another
-    # instance.
-    #
-    # @param r [Object] the instance to test for equality.
-    # @return [Boolean] `true` if `r` is a {DayOfMonthTransitionRule} with the
-    #   same {transition_at}, month, week and day of week as this
-    #   {DayOfMonthTransitionRule}, otherwise `false`.
-    def ==(r)
-      super(r) && r.kind_of?(DayOfMonthTransitionRule) && @offset_start == r.offset_start
-    end
-    alias eql? ==
-
-    protected
-
-    # @return [Integer] the day the week starts on for a month starting on a
-    #   Sunday.
-    attr_reader :offset_start
-
-    # Returns a `Time` representing midnight local time on the day specified by
-    # the rule for the given offset and year.
-    #
-    # @param offset [TimezoneOffset] the current offset at the time of the
-    #  transition.
-    # @param year [Integer] the year in which the transition occurs.
-    # @return [Time] midnight local time on the day specified by the rule for
-    #  the given offset and year.
-    def get_day(offset, year)
-      candidate = Time.new(year, month, @offset_start, 0, 0, 0, offset.observed_utc_offset)
-      diff = day_of_week - candidate.wday
-
-      if diff < 0
-        candidate + (7 + diff) * 86400
-      elsif diff > 0
-        candidate + diff * 86400
-      else
-        candidate
-      end
-    end
-
-    # (see TransitionRule#hash_args)
-    def hash_args
-      [@offset_start] + super
-    end
-  end
-  private_constant :DayOfMonthTransitionRule
-
-  # A rule that transitions on the last occurrence of a particular day of week
-  # of a calendar month.
-  #
-  # @private
-  class LastDayOfMonthTransitionRule < DayOfWeekTransitionRule #:nodoc:
-    # Initializes a new {LastDayOfMonthTransitionRule}.
-    #
-    # @param month [Integer] the month of the year when the transition occurs.
-    # @param day_of_week [Integer] the day of the week when the transition
-    #   occurs. 0 is Sunday, 6 is Saturday.
-    # @param transition_at [Integer] the time in seconds after midnight local
-    #   time at which the transition occurs.
-    # @raise [ArgumentError] if `transition_at` is not an `Integer`.
-    # @raise [ArgumentError] if `month` is not an `Integer`.
-    # @raise [ArgumentError] if `month` is less than 1 or greater than 12.
-    # @raise [ArgumentError] if `day_of_week` is not an `Integer`.
-    # @raise [ArgumentError] if `day_of_week` is less than 0 or greater than 6.
-    def initialize(month, day_of_week, transition_at = 0)
-      super(month, day_of_week, transition_at)
-    end
-
-    # Determines if this {LastDayOfMonthTransitionRule} is equal to another
-    # instance.
-    #
-    # @param r [Object] the instance to test for equality.
-    # @return [Boolean] `true` if `r` is a {LastDayOfMonthTransitionRule} with
-    #   the same {transition_at}, month and day of week as this
-    #   {LastDayOfMonthTransitionRule}, otherwise `false`.
-    def ==(r)
-      super(r) && r.kind_of?(LastDayOfMonthTransitionRule)
-    end
-    alias eql? ==
-
-    protected
-
-    # Returns a `Time` representing midnight local time on the day specified by
-    # the rule for the given offset and year.
-    #
-    # @param offset [TimezoneOffset] the current offset at the time of the
-    #  transition.
-    # @param year [Integer] the year in which the transition occurs.
-    # @return [Time] midnight local time on the day specified by the rule for
-    #  the given offset and year.
-    def get_day(offset, year)
-      next_month = month + 1
-      if next_month == 13
-        year += 1
-        next_month = 1
-      end
-
-      candidate = Time.new(year, next_month, 1, 0, 0, 0, offset.observed_utc_offset) - 86400
-      diff = candidate.wday - day_of_week
-
-      if diff < 0
-        candidate - (diff + 7) * 86400
-      elsif diff > 0
-        candidate - diff * 86400
-      else
-        candidate
-      end
-    end
-  end
-  private_constant :LastDayOfMonthTransitionRule
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/transitions_timezone_period.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/transitions_timezone_period.rb
deleted file mode 100644
index aea87f33fbf4b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/transitions_timezone_period.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # Represents a period of time in a time zone where the same offset from UTC
-  # applies. The period of time is bounded at at least one end, either having a
-  # start transition, end transition or both start and end transitions.
-  class TransitionsTimezonePeriod < TimezonePeriod
-    # @return [TimezoneTransition] the transition that defines the start of this
-    #   {TimezonePeriod} (`nil` if the start is unbounded).
-    attr_reader :start_transition
-
-    # @return [TimezoneTransition] the transition that defines the end of this
-    #   {TimezonePeriod} (`nil` if the end is unbounded).
-    attr_reader :end_transition
-
-    # Initializes a {TransitionsTimezonePeriod}.
-    #
-    # At least one of `start_transition` and `end_transition` must be specified.
-    #
-    # @param start_transition [TimezoneTransition] the transition that defines
-    #   the start of the period, or `nil` if the start is unbounded.
-    # @param end_transition [TimezoneTransition] the transition that defines the
-    #   end of the period, or `nil` if the end is unbounded.
-    # @raise [ArgumentError] if both `start_transition` and `end_transition` are
-    #   `nil`.
-    def initialize(start_transition, end_transition)
-      if start_transition
-        super(start_transition.offset)
-      elsif end_transition
-        super(end_transition.previous_offset)
-      else
-        raise ArgumentError, 'At least one of start_transition and end_transition must be specified'
-      end
-
-      @start_transition = start_transition
-      @end_transition = end_transition
-    end
-
-    # Determines if this {TransitionsTimezonePeriod} is equal to another
-    # instance.
-    #
-    # @param p [Object] the instance to test for equality.
-    # @return [Boolean] `true` if `p` is a {TransitionsTimezonePeriod} with the
-    #   same {offset}, {start_transition} and {end_transition}, otherwise
-    #   `false`.
-    def ==(p)
-      p.kind_of?(TransitionsTimezonePeriod) && start_transition == p.start_transition && end_transition == p.end_transition
-    end
-    alias eql? ==
-
-    # @return [Integer] a hash based on {start_transition} and {end_transition}.
-    def hash
-      [@start_transition, @end_transition].hash
-    end
-
-    # @return [String] the internal object state as a programmer-readable
-    #   `String`.
-    def inspect
-      "#<#{self.class}: @start_transition=#{@start_transition.inspect}, @end_transition=#{@end_transition.inspect}>"
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/untaint_ext.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/untaint_ext.rb
deleted file mode 100644
index 4e8d0c078a265..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/untaint_ext.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # Object#untaint is deprecated in Ruby >= 2.7 and will be removed in 3.2.
-  # UntaintExt adds a refinement to make Object#untaint a no-op and avoid the
-  # warning.
-  #
-  # @private
-  module UntaintExt # :nodoc:
-    refine Object do
-      def untaint
-        self
-      end
-    end
-  end
-  private_constant :UntaintExt
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/version.rb
deleted file mode 100644
index 1b1599423f0f0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/version.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # The TZInfo version number.
-  VERSION = '2.0.5'
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/with_offset.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/with_offset.rb
deleted file mode 100644
index 3f2d9b05ca870..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/tzinfo-2.0.5/lib/tzinfo/with_offset.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-module TZInfo
-  # The {WithOffset} module is included in {TimeWithOffset},
-  # {DateTimeWithOffset} and {TimestampWithOffset}. It provides an override for
-  # the {strftime} method that handles expanding the `%Z` directive according to
-  # the {TimezoneOffset#abbreviation abbreviation} of the {TimezoneOffset}
-  # associated with a local time.
-  module WithOffset
-    # Overrides the `Time`, `DateTime` or {Timestamp} version of `strftime`,
-    # replacing `%Z` with the {TimezoneOffset#abbreviation abbreviation} of the
-    # associated {TimezoneOffset}. If there is no associated offset, `%Z` is
-    # expanded by the base class instead.
-    #
-    # All the format directives handled by the base class are supported.
-    #
-    # @param format [String] the format string.
-    # @return [String] the formatted time.
-    # @raise [ArgumentError] if `format` is `nil`.
-    def strftime(format)
-      raise ArgumentError, 'format must be specified' unless format
-
-      if_timezone_offset do |o|
-        abbreviation = nil
-
-        format = format.gsub(/%(%*)Z/) do
-          if $1.length.odd?
-            # Return %%Z so the real strftime treats it as a literal %Z too.
-            "#$1%Z"
-          else
-            "#$1#{abbreviation ||= o.abbreviation.gsub(/%/, '%%')}"
-          end
-        end
-      end
-
-      super
-    end
-
-    protected
-
-    # Performs a calculation if there is an associated {TimezoneOffset}.
-    #
-    # @param result [Object] a result value that can be manipulated by the block
-    #   if there is an associated {TimezoneOffset}.
-    # @yield [period, result] if there is an associated {TimezoneOffset}, the
-    #   block is yielded to in order to calculate the method result.
-    # @yieldparam period [TimezoneOffset] the associated {TimezoneOffset}.
-    # @yieldparam result [Object] the `result` parameter.
-    # @yieldreturn [Object] the result of the calculation performed if there is
-    #   an associated {TimezoneOffset}.
-    # @return [Object] the result of the block if there is an associated
-    #   {TimezoneOffset}, otherwise the `result` parameter.
-    #
-    # @private
-    def if_timezone_offset(result = nil) #:nodoc:
-      to = timezone_offset
-      to ? yield(to, result) : result
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick.rb
deleted file mode 100644
index b854b68db4a98..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick.rb
+++ /dev/null
@@ -1,232 +0,0 @@
-# frozen_string_literal: false
-##
-# = WEB server toolkit.
-#
-# WEBrick is an HTTP server toolkit that can be configured as an HTTPS server,
-# a proxy server, and a virtual-host server.  WEBrick features complete
-# logging of both server operations and HTTP access.  WEBrick supports both
-# basic and digest authentication in addition to algorithms not in RFC 2617.
-#
-# A WEBrick server can be composed of multiple WEBrick servers or servlets to
-# provide differing behavior on a per-host or per-path basis.  WEBrick
-# includes servlets for handling CGI scripts, ERB pages, Ruby blocks and
-# directory listings.
-#
-# WEBrick also includes tools for daemonizing a process and starting a process
-# at a higher privilege level and dropping permissions.
-#
-# == Security
-#
-# *Warning:* WEBrick is not recommended for production.  It only implements
-# basic security checks.
-#
-# == Starting an HTTP server
-#
-# To create a new WEBrick::HTTPServer that will listen to connections on port
-# 8000 and serve documents from the current user's public_html folder:
-#
-#   require 'webrick'
-#
-#   root = File.expand_path '~/public_html'
-#   server = WEBrick::HTTPServer.new :Port => 8000, :DocumentRoot => root
-#
-# To run the server you will need to provide a suitable shutdown hook as
-# starting the server blocks the current thread:
-#
-#   trap 'INT' do server.shutdown end
-#
-#   server.start
-#
-# == Custom Behavior
-#
-# The easiest way to have a server perform custom operations is through
-# WEBrick::HTTPServer#mount_proc.  The block given will be called with a
-# WEBrick::HTTPRequest with request info and a WEBrick::HTTPResponse which
-# must be filled in appropriately:
-#
-#   server.mount_proc '/' do |req, res|
-#     res.body = 'Hello, world!'
-#   end
-#
-# Remember that +server.mount_proc+ must precede +server.start+.
-#
-# == Servlets
-#
-# Advanced custom behavior can be obtained through mounting a subclass of
-# WEBrick::HTTPServlet::AbstractServlet.  Servlets provide more modularity
-# when writing an HTTP server than mount_proc allows.  Here is a simple
-# servlet:
-#
-#   class Simple < WEBrick::HTTPServlet::AbstractServlet
-#     def do_GET request, response
-#       status, content_type, body = do_stuff_with request
-#
-#       response.status = 200
-#       response['Content-Type'] = 'text/plain'
-#       response.body = 'Hello, World!'
-#     end
-#   end
-#
-# To initialize the servlet you mount it on the server:
-#
-#   server.mount '/simple', Simple
-#
-# See WEBrick::HTTPServlet::AbstractServlet for more details.
-#
-# == Virtual Hosts
-#
-# A server can act as a virtual host for multiple host names.  After creating
-# the listening host, additional hosts that do not listen can be created and
-# attached as virtual hosts:
-#
-#   server = WEBrick::HTTPServer.new # ...
-#
-#   vhost = WEBrick::HTTPServer.new :ServerName => 'vhost.example',
-#                                   :DoNotListen => true, # ...
-#   vhost.mount '/', ...
-#
-#   server.virtual_host vhost
-#
-# If no +:DocumentRoot+ is provided and no servlets or procs are mounted on the
-# main server it will return 404 for all URLs.
-#
-# == HTTPS
-#
-# To create an HTTPS server you only need to enable SSL and provide an SSL
-# certificate name:
-#
-#   require 'webrick'
-#   require 'webrick/https'
-#
-#   cert_name = [
-#     %w[CN localhost],
-#   ]
-#
-#   server = WEBrick::HTTPServer.new(:Port => 8000,
-#                                    :SSLEnable => true,
-#                                    :SSLCertName => cert_name)
-#
-# This will start the server with a self-generated self-signed certificate.
-# The certificate will be changed every time the server is restarted.
-#
-# To create a server with a pre-determined key and certificate you can provide
-# them:
-#
-#   require 'webrick'
-#   require 'webrick/https'
-#   require 'openssl'
-#
-#   cert = OpenSSL::X509::Certificate.new File.read '/path/to/cert.pem'
-#   pkey = OpenSSL::PKey::RSA.new File.read '/path/to/pkey.pem'
-#
-#   server = WEBrick::HTTPServer.new(:Port => 8000,
-#                                    :SSLEnable => true,
-#                                    :SSLCertificate => cert,
-#                                    :SSLPrivateKey => pkey)
-#
-# == Proxy Server
-#
-# WEBrick can act as a proxy server:
-#
-#   require 'webrick'
-#   require 'webrick/httpproxy'
-#
-#   proxy = WEBrick::HTTPProxyServer.new :Port => 8000
-#
-#   trap 'INT' do proxy.shutdown end
-#
-# See WEBrick::HTTPProxy for further details including modifying proxied
-# responses.
-#
-# == Basic and Digest authentication
-#
-# WEBrick provides both Basic and Digest authentication for regular and proxy
-# servers.  See WEBrick::HTTPAuth, WEBrick::HTTPAuth::BasicAuth and
-# WEBrick::HTTPAuth::DigestAuth.
-#
-# == WEBrick as a daemonized Web Server
-#
-# WEBrick can be run as a daemonized server for small loads.
-#
-# === Daemonizing
-#
-# To start a WEBrick server as a daemon simple run WEBrick::Daemon.start
-# before starting the server.
-#
-# === Dropping Permissions
-#
-# WEBrick can be started as one user to gain permission to bind to port 80 or
-# 443 for serving HTTP or HTTPS traffic then can drop these permissions for
-# regular operation.  To listen on all interfaces for HTTP traffic:
-#
-#   sockets = WEBrick::Utils.create_listeners nil, 80
-#
-# Then drop privileges:
-#
-#   WEBrick::Utils.su 'www'
-#
-# Then create a server that does not listen by default:
-#
-#   server = WEBrick::HTTPServer.new :DoNotListen => true, # ...
-#
-# Then overwrite the listening sockets with the port 80 sockets:
-#
-#   server.listeners.replace sockets
-#
-# === Logging
-#
-# WEBrick can separately log server operations and end-user access.  For
-# server operations:
-#
-#   log_file = File.open '/var/log/webrick.log', 'a+'
-#   log = WEBrick::Log.new log_file
-#
-# For user access logging:
-#
-#   access_log = [
-#     [log_file, WEBrick::AccessLog::COMBINED_LOG_FORMAT],
-#   ]
-#
-#   server = WEBrick::HTTPServer.new :Logger => log, :AccessLog => access_log
-#
-# See WEBrick::AccessLog for further log formats.
-#
-# === Log Rotation
-#
-# To rotate logs in WEBrick on a HUP signal (like syslogd can send), open the
-# log file in 'a+' mode (as above) and trap 'HUP' to reopen the log file:
-#
-#   trap 'HUP' do log_file.reopen '/path/to/webrick.log', 'a+'
-#
-# == Copyright
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-#
-# Copyright (c) 2000 TAKAHASHI Masayoshi, GOTOU YUUZOU
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#--
-# $IPR: webrick.rb,v 1.12 2002/10/01 17:16:31 gotoyuzo Exp $
-
-module WEBrick
-end
-
-require 'webrick/compat.rb'
-
-require 'webrick/version.rb'
-require 'webrick/config.rb'
-require 'webrick/log.rb'
-require 'webrick/server.rb'
-require_relative 'webrick/utils.rb'
-require 'webrick/accesslog'
-
-require 'webrick/htmlutils.rb'
-require 'webrick/httputils.rb'
-require 'webrick/cookie.rb'
-require 'webrick/httpversion.rb'
-require 'webrick/httpstatus.rb'
-require 'webrick/httprequest.rb'
-require 'webrick/httpresponse.rb'
-require 'webrick/httpserver.rb'
-require 'webrick/httpservlet.rb'
-require 'webrick/httpauth.rb'
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/accesslog.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/accesslog.rb
deleted file mode 100644
index e4849637f3589..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/accesslog.rb
+++ /dev/null
@@ -1,157 +0,0 @@
-# frozen_string_literal: false
-#--
-# accesslog.rb -- Access log handling utilities
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2002 keita yamaguchi
-# Copyright (c) 2002 Internet Programming with Ruby writers
-#
-# $IPR: accesslog.rb,v 1.1 2002/10/01 17:16:32 gotoyuzo Exp $
-
-module WEBrick
-
-  ##
-  # AccessLog provides logging to various files in various formats.
-  #
-  # Multiple logs may be written to at the same time:
-  #
-  #   access_log = [
-  #     [$stderr, WEBrick::AccessLog::COMMON_LOG_FORMAT],
-  #     [$stderr, WEBrick::AccessLog::REFERER_LOG_FORMAT],
-  #   ]
-  #
-  #   server = WEBrick::HTTPServer.new :AccessLog => access_log
-  #
-  # Custom log formats may be defined.  WEBrick::AccessLog provides a subset
-  # of the formatting from Apache's mod_log_config
-  # http://httpd.apache.org/docs/mod/mod_log_config.html#formats.  See
-  # AccessLog::setup_params for a list of supported options
-
-  module AccessLog
-
-    ##
-    # Raised if a parameter such as %e, %i, %o or %n is used without fetching
-    # a specific field.
-
-    class AccessLogError < StandardError; end
-
-    ##
-    # The Common Log Format's time format
-
-    CLF_TIME_FORMAT     = "[%d/%b/%Y:%H:%M:%S %Z]"
-
-    ##
-    # Common Log Format
-
-    COMMON_LOG_FORMAT   = "%h %l %u %t \"%r\" %s %b"
-
-    ##
-    # Short alias for Common Log Format
-
-    CLF                 = COMMON_LOG_FORMAT
-
-    ##
-    # Referer Log Format
-
-    REFERER_LOG_FORMAT  = "%{Referer}i -> %U"
-
-    ##
-    # User-Agent Log Format
-
-    AGENT_LOG_FORMAT    = "%{User-Agent}i"
-
-    ##
-    # Combined Log Format
-
-    COMBINED_LOG_FORMAT = "#{CLF} \"%{Referer}i\" \"%{User-agent}i\""
-
-    module_function
-
-    # This format specification is a subset of mod_log_config of Apache:
-    #
-    # %a:: Remote IP address
-    # %b:: Total response size
-    # %e{variable}:: Given variable in ENV
-    # %f:: Response filename
-    # %h:: Remote host name
-    # %{header}i:: Given request header
-    # %l:: Remote logname, always "-"
-    # %m:: Request method
-    # %{attr}n:: Given request attribute from <tt>req.attributes</tt>
-    # %{header}o:: Given response header
-    # %p:: Server's request port
-    # %{format}p:: The canonical port of the server serving the request or the
-    #              actual port or the client's actual port.  Valid formats are
-    #              canonical, local or remote.
-    # %q:: Request query string
-    # %r:: First line of the request
-    # %s:: Request status
-    # %t:: Time the request was received
-    # %T:: Time taken to process the request
-    # %u:: Remote user from auth
-    # %U:: Unparsed URI
-    # %%:: Literal %
-
-    def setup_params(config, req, res)
-      params = Hash.new("")
-      params["a"] = req.peeraddr[3]
-      params["b"] = res.sent_size
-      params["e"] = ENV
-      params["f"] = res.filename || ""
-      params["h"] = req.peeraddr[2]
-      params["i"] = req
-      params["l"] = "-"
-      params["m"] = req.request_method
-      params["n"] = req.attributes
-      params["o"] = res
-      params["p"] = req.port
-      params["q"] = req.query_string
-      params["r"] = req.request_line.sub(/\x0d?\x0a\z/o, '')
-      params["s"] = res.status       # won't support "%>s"
-      params["t"] = req.request_time
-      params["T"] = Time.now - req.request_time
-      params["u"] = req.user || "-"
-      params["U"] = req.unparsed_uri
-      params["v"] = config[:ServerName]
-      params
-    end
-
-    ##
-    # Formats +params+ according to +format_string+ which is described in
-    # setup_params.
-
-    def format(format_string, params)
-      format_string.gsub(/\%(?:\{(.*?)\})?>?([a-zA-Z%])/){
-         param, spec = $1, $2
-         case spec[0]
-         when ?e, ?i, ?n, ?o
-           raise AccessLogError,
-             "parameter is required for \"#{spec}\"" unless param
-           (param = params[spec][param]) ? escape(param) : "-"
-         when ?t
-           params[spec].strftime(param || CLF_TIME_FORMAT)
-         when ?p
-           case param
-           when 'remote'
-             escape(params["i"].peeraddr[1].to_s)
-           else
-             escape(params["p"].to_s)
-           end
-         when ?%
-           "%"
-         else
-           escape(params[spec].to_s)
-         end
-      }
-    end
-
-    ##
-    # Escapes control characters in +data+
-
-    def escape(data)
-      data = data.gsub(/[[:cntrl:]\\]+/) {$&.dump[1...-1]}
-      data.untaint if RUBY_VERSION < '2.7'
-      data
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/cgi.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/cgi.rb
deleted file mode 100644
index bb0ae2fc84421..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/cgi.rb
+++ /dev/null
@@ -1,313 +0,0 @@
-# frozen_string_literal: false
-#
-# cgi.rb -- Yet another CGI library
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2003 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $Id$
-
-require_relative "httprequest"
-require_relative "httpresponse"
-require_relative "config"
-require "stringio"
-
-module WEBrick
-
-  # A CGI library using WEBrick requests and responses.
-  #
-  # Example:
-  #
-  #   class MyCGI < WEBrick::CGI
-  #     def do_GET req, res
-  #       res.body = 'it worked!'
-  #       res.status = 200
-  #     end
-  #   end
-  #
-  #   MyCGI.new.start
-
-  class CGI
-
-    # The CGI error exception class
-
-    CGIError = Class.new(StandardError)
-
-    ##
-    # The CGI configuration.  This is based on WEBrick::Config::HTTP
-
-    attr_reader :config
-
-    ##
-    # The CGI logger
-
-    attr_reader :logger
-
-    ##
-    # Creates a new CGI interface.
-    #
-    # The first argument in +args+ is a configuration hash which would update
-    # WEBrick::Config::HTTP.
-    #
-    # Any remaining arguments are stored in the <code>@options</code> instance
-    # variable for use by a subclass.
-
-    def initialize(*args)
-      if defined?(MOD_RUBY)
-        unless ENV.has_key?("GATEWAY_INTERFACE")
-          Apache.request.setup_cgi_env
-        end
-      end
-      if %r{HTTP/(\d+\.\d+)} =~ ENV["SERVER_PROTOCOL"]
-        httpv = $1
-      end
-      @config = WEBrick::Config::HTTP.dup.update(
-        :ServerSoftware => ENV["SERVER_SOFTWARE"] || "null",
-        :HTTPVersion    => HTTPVersion.new(httpv || "1.0"),
-        :RunOnCGI       => true,   # to detect if it runs on CGI.
-        :NPH            => false   # set true to run as NPH script.
-      )
-      if config = args.shift
-        @config.update(config)
-      end
-      @config[:Logger] ||= WEBrick::BasicLog.new($stderr)
-      @logger = @config[:Logger]
-      @options = args
-    end
-
-    ##
-    # Reads +key+ from the configuration
-
-    def [](key)
-      @config[key]
-    end
-
-    ##
-    # Starts the CGI process with the given environment +env+ and standard
-    # input and output +stdin+ and +stdout+.
-
-    def start(env=ENV, stdin=$stdin, stdout=$stdout)
-      sock = WEBrick::CGI::Socket.new(@config, env, stdin, stdout)
-      req = HTTPRequest.new(@config)
-      res = HTTPResponse.new(@config)
-      unless @config[:NPH] or defined?(MOD_RUBY)
-        def res.setup_header
-          unless @header["status"]
-            phrase = HTTPStatus::reason_phrase(@status)
-            @header["status"] = "#{@status} #{phrase}"
-          end
-          super
-        end
-        def res.status_line
-          ""
-        end
-      end
-
-      begin
-        req.parse(sock)
-        req.script_name = (env["SCRIPT_NAME"] || File.expand_path($0)).dup
-        req.path_info = (env["PATH_INFO"] || "").dup
-        req.query_string = env["QUERY_STRING"]
-        req.user = env["REMOTE_USER"]
-        res.request_method = req.request_method
-        res.request_uri = req.request_uri
-        res.request_http_version = req.http_version
-        res.keep_alive = req.keep_alive?
-        self.service(req, res)
-      rescue HTTPStatus::Error => ex
-        res.set_error(ex)
-      rescue HTTPStatus::Status => ex
-        res.status = ex.code
-      rescue Exception => ex
-        @logger.error(ex)
-        res.set_error(ex, true)
-      ensure
-        req.fixup
-        if defined?(MOD_RUBY)
-          res.setup_header
-          Apache.request.status_line = "#{res.status} #{res.reason_phrase}"
-          Apache.request.status = res.status
-          table = Apache.request.headers_out
-          res.header.each{|key, val|
-            case key
-            when /^content-encoding$/i
-              Apache::request.content_encoding = val
-            when /^content-type$/i
-              Apache::request.content_type = val
-            else
-              table[key] = val.to_s
-            end
-          }
-          res.cookies.each{|cookie|
-            table.add("Set-Cookie", cookie.to_s)
-          }
-          Apache.request.send_http_header
-          res.send_body(sock)
-        else
-          res.send_response(sock)
-        end
-      end
-    end
-
-    ##
-    # Services the request +req+ which will fill in the response +res+.  See
-    # WEBrick::HTTPServlet::AbstractServlet#service for details.
-
-    def service(req, res)
-      method_name = "do_" + req.request_method.gsub(/-/, "_")
-      if respond_to?(method_name)
-        __send__(method_name, req, res)
-      else
-        raise HTTPStatus::MethodNotAllowed,
-              "unsupported method `#{req.request_method}'."
-      end
-    end
-
-    ##
-    # Provides HTTP socket emulation from the CGI environment
-
-    class Socket # :nodoc:
-      include Enumerable
-
-      private
-
-      def initialize(config, env, stdin, stdout)
-        @config = config
-        @env = env
-        @header_part = StringIO.new
-        @body_part = stdin
-        @out_port = stdout
-        @out_port.binmode
-
-        @server_addr = @env["SERVER_ADDR"] || "0.0.0.0"
-        @server_name = @env["SERVER_NAME"]
-        @server_port = @env["SERVER_PORT"]
-        @remote_addr = @env["REMOTE_ADDR"]
-        @remote_host = @env["REMOTE_HOST"] || @remote_addr
-        @remote_port = @env["REMOTE_PORT"] || 0
-
-        begin
-          @header_part << request_line << CRLF
-          setup_header
-          @header_part << CRLF
-          @header_part.rewind
-        rescue Exception
-          raise CGIError, "invalid CGI environment"
-        end
-      end
-
-      def request_line
-        meth = @env["REQUEST_METHOD"] || "GET"
-        unless url = @env["REQUEST_URI"]
-          url = (@env["SCRIPT_NAME"] || File.expand_path($0)).dup
-          url << @env["PATH_INFO"].to_s
-          url = WEBrick::HTTPUtils.escape_path(url)
-          if query_string = @env["QUERY_STRING"]
-            unless query_string.empty?
-              url << "?" << query_string
-            end
-          end
-        end
-        # we cannot get real HTTP version of client ;)
-        httpv = @config[:HTTPVersion]
-        return "#{meth} #{url} HTTP/#{httpv}"
-      end
-
-      def setup_header
-        @env.each{|key, value|
-          case key
-          when "CONTENT_TYPE", "CONTENT_LENGTH"
-            add_header(key.gsub(/_/, "-"), value)
-          when /^HTTP_(.*)/
-            add_header($1.gsub(/_/, "-"), value)
-          end
-        }
-      end
-
-      def add_header(hdrname, value)
-        unless value.empty?
-          @header_part << hdrname << ": " << value << CRLF
-        end
-      end
-
-      def input
-        @header_part.eof? ? @body_part : @header_part
-      end
-
-      public
-
-      def peeraddr
-        [nil, @remote_port, @remote_host, @remote_addr]
-      end
-
-      def addr
-        [nil, @server_port, @server_name, @server_addr]
-      end
-
-      def gets(eol=LF, size=nil)
-        input.gets(eol, size)
-      end
-
-      def read(size=nil)
-        input.read(size)
-      end
-
-      def each
-        input.each{|line| yield(line) }
-      end
-
-      def eof?
-        input.eof?
-      end
-
-      def <<(data)
-        @out_port << data
-      end
-
-      def write(data)
-        @out_port.write(data)
-      end
-
-      def cert
-        return nil unless defined?(OpenSSL)
-        if pem = @env["SSL_SERVER_CERT"]
-          OpenSSL::X509::Certificate.new(pem) unless pem.empty?
-        end
-      end
-
-      def peer_cert
-        return nil unless defined?(OpenSSL)
-        if pem = @env["SSL_CLIENT_CERT"]
-          OpenSSL::X509::Certificate.new(pem) unless pem.empty?
-        end
-      end
-
-      def peer_cert_chain
-        return nil unless defined?(OpenSSL)
-        if @env["SSL_CLIENT_CERT_CHAIN_0"]
-          keys = @env.keys
-          certs = keys.sort.collect{|k|
-            if /^SSL_CLIENT_CERT_CHAIN_\d+$/ =~ k
-              if pem = @env[k]
-                OpenSSL::X509::Certificate.new(pem) unless pem.empty?
-              end
-            end
-          }
-          certs.compact
-        end
-      end
-
-      def cipher
-        return nil unless defined?(OpenSSL)
-        if cipher = @env["SSL_CIPHER"]
-          ret = [ cipher ]
-          ret << @env["SSL_PROTOCOL"]
-          ret << @env["SSL_CIPHER_USEKEYSIZE"]
-          ret << @env["SSL_CIPHER_ALGKEYSIZE"]
-          ret
-        end
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/compat.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/compat.rb
deleted file mode 100644
index c497a1933c92a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/compat.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-# frozen_string_literal: false
-#
-# compat.rb -- cross platform compatibility
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2002 GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: compat.rb,v 1.6 2002/10/01 17:16:32 gotoyuzo Exp $
-
-##
-# System call error module used by webrick for cross platform compatibility.
-#
-# EPROTO:: protocol error
-# ECONNRESET:: remote host reset the connection request
-# ECONNABORTED:: Client sent TCP reset (RST) before server has accepted the
-#                connection requested by client.
-#
-module Errno
-  ##
-  # Protocol error.
-
-  class EPROTO       < SystemCallError; end
-
-  ##
-  # Remote host reset the connection request.
-
-  class ECONNRESET   < SystemCallError; end
-
-  ##
-  # Client sent TCP reset (RST) before server has accepted the connection
-  # requested by client.
-
-  class ECONNABORTED < SystemCallError; end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/config.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/config.rb
deleted file mode 100644
index 9f2ab44f49d80..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/config.rb
+++ /dev/null
@@ -1,158 +0,0 @@
-# frozen_string_literal: false
-#
-# config.rb -- Default configurations.
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2003 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: config.rb,v 1.52 2003/07/22 19:20:42 gotoyuzo Exp $
-
-require_relative 'version'
-require_relative 'httpversion'
-require_relative 'httputils'
-require_relative 'utils'
-require_relative 'log'
-
-module WEBrick
-  module Config
-    LIBDIR = File::dirname(__FILE__) # :nodoc:
-
-    # for GenericServer
-    General = Hash.new { |hash, key|
-      case key
-      when :ServerName
-        hash[key] = Utils.getservername
-      else
-        nil
-      end
-    }.update(
-      :BindAddress    => nil,   # "0.0.0.0" or "::" or nil
-      :Port           => nil,   # users MUST specify this!!
-      :MaxClients     => 100,   # maximum number of the concurrent connections
-      :ServerType     => nil,   # default: WEBrick::SimpleServer
-      :Logger         => nil,   # default: WEBrick::Log.new
-      :ServerSoftware => "WEBrick/#{WEBrick::VERSION} " +
-                         "(Ruby/#{RUBY_VERSION}/#{RUBY_RELEASE_DATE})",
-      :TempDir        => ENV['TMPDIR']||ENV['TMP']||ENV['TEMP']||'/tmp',
-      :DoNotListen    => false,
-      :StartCallback  => nil,
-      :StopCallback   => nil,
-      :AcceptCallback => nil,
-      :DoNotReverseLookup => true,
-      :ShutdownSocketWithoutClose => false,
-    )
-
-    # for HTTPServer, HTTPRequest, HTTPResponse ...
-    HTTP = General.dup.update(
-      :Port           => 80,
-      :RequestTimeout => 30,
-      :HTTPVersion    => HTTPVersion.new("1.1"),
-      :AccessLog      => nil,
-      :MimeTypes      => HTTPUtils::DefaultMimeTypes,
-      :DirectoryIndex => ["index.html","index.htm","index.cgi","index.rhtml"],
-      :DocumentRoot   => nil,
-      :DocumentRootOptions => { :FancyIndexing => true },
-      :RequestCallback => nil,
-      :ServerAlias    => nil,
-      :InputBufferSize  => 65536, # input buffer size in reading request body
-      :OutputBufferSize => 65536, # output buffer size in sending File or IO
-
-      # for HTTPProxyServer
-      :ProxyAuthProc  => nil,
-      :ProxyContentHandler => nil,
-      :ProxyVia       => true,
-      :ProxyTimeout   => true,
-      :ProxyURI       => nil,
-
-      :CGIInterpreter => nil,
-      :CGIPathEnv     => nil,
-
-      # workaround: if Request-URIs contain 8bit chars,
-      # they should be escaped before calling of URI::parse().
-      :Escape8bitURI  => false
-    )
-
-    ##
-    # Default configuration for WEBrick::HTTPServlet::FileHandler
-    #
-    # :AcceptableLanguages::
-    #   Array of languages allowed for accept-language.  There is no default
-    # :DirectoryCallback::
-    #   Allows preprocessing of directory requests.  There is no default
-    #   callback.
-    # :FancyIndexing::
-    #   If true, show an index for directories.  The default is true.
-    # :FileCallback::
-    #   Allows preprocessing of file requests.  There is no default callback.
-    # :HandlerCallback::
-    #   Allows preprocessing of requests.  There is no default callback.
-    # :HandlerTable::
-    #   Maps file suffixes to file handlers.  DefaultFileHandler is used by
-    #   default but any servlet can be used.
-    # :NondisclosureName::
-    #   Do not show files matching this array of globs.  .ht* and *~ are
-    #   excluded by default.
-    # :UserDir::
-    #   Directory inside ~user to serve content from for /~user requests.
-    #   Only works if mounted on /.  Disabled by default.
-
-    FileHandler = {
-      :NondisclosureName => [".ht*", "*~"],
-      :FancyIndexing     => false,
-      :HandlerTable      => {},
-      :HandlerCallback   => nil,
-      :DirectoryCallback => nil,
-      :FileCallback      => nil,
-      :UserDir           => nil,  # e.g. "public_html"
-      :AcceptableLanguages => []  # ["en", "ja", ... ]
-    }
-
-    ##
-    # Default configuration for WEBrick::HTTPAuth::BasicAuth
-    #
-    # :AutoReloadUserDB:: Reload the user database provided by :UserDB
-    #                     automatically?
-
-    BasicAuth = {
-      :AutoReloadUserDB     => true,
-    }
-
-    ##
-    # Default configuration for WEBrick::HTTPAuth::DigestAuth.
-    #
-    # :Algorithm:: MD5, MD5-sess (default), SHA1, SHA1-sess
-    # :Domain:: An Array of URIs that define the protected space
-    # :Qop:: 'auth' for authentication, 'auth-int' for integrity protection or
-    #        both
-    # :UseOpaque:: Should the server send opaque values to the client?  This
-    #              helps prevent replay attacks.
-    # :CheckNc:: Should the server check the nonce count?  This helps the
-    #            server detect replay attacks.
-    # :UseAuthenticationInfoHeader:: Should the server send an
-    #                                AuthenticationInfo header?
-    # :AutoReloadUserDB:: Reload the user database provided by :UserDB
-    #                     automatically?
-    # :NonceExpirePeriod:: How long should we store used nonces?  Default is
-    #                      30 minutes.
-    # :NonceExpireDelta:: How long is a nonce valid?  Default is 1 minute
-    # :InternetExplorerHack:: Hack which allows Internet Explorer to work.
-    # :OperaHack:: Hack which allows Opera to work.
-
-    DigestAuth = {
-      :Algorithm            => 'MD5-sess', # or 'MD5'
-      :Domain               => nil,        # an array includes domain names.
-      :Qop                  => [ 'auth' ], # 'auth' or 'auth-int' or both.
-      :UseOpaque            => true,
-      :UseNextNonce         => false,
-      :CheckNc              => false,
-      :UseAuthenticationInfoHeader => true,
-      :AutoReloadUserDB     => true,
-      :NonceExpirePeriod    => 30*60,
-      :NonceExpireDelta     => 60,
-      :InternetExplorerHack => true,
-      :OperaHack            => true,
-    }
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/cookie.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/cookie.rb
deleted file mode 100644
index 5fd3bfb22862e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/cookie.rb
+++ /dev/null
@@ -1,172 +0,0 @@
-# frozen_string_literal: false
-#
-# cookie.rb -- Cookie class
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: cookie.rb,v 1.16 2002/09/21 12:23:35 gotoyuzo Exp $
-
-require 'time'
-require_relative 'httputils'
-
-module WEBrick
-
-  ##
-  # Processes HTTP cookies
-
-  class Cookie
-
-    ##
-    # The cookie name
-
-    attr_reader :name
-
-    ##
-    # The cookie value
-
-    attr_accessor :value
-
-    ##
-    # The cookie version
-
-    attr_accessor :version
-
-    ##
-    # The cookie domain
-    attr_accessor :domain
-
-    ##
-    # The cookie path
-
-    attr_accessor :path
-
-    ##
-    # Is this a secure cookie?
-
-    attr_accessor :secure
-
-    ##
-    # The cookie comment
-
-    attr_accessor :comment
-
-    ##
-    # The maximum age of the cookie
-
-    attr_accessor :max_age
-
-    #attr_accessor :comment_url, :discard, :port
-
-    ##
-    # Creates a new cookie with the given +name+ and +value+
-
-    def initialize(name, value)
-      @name = name
-      @value = value
-      @version = 0     # Netscape Cookie
-
-      @domain = @path = @secure = @comment = @max_age =
-      @expires = @comment_url = @discard = @port = nil
-    end
-
-    ##
-    # Sets the cookie expiration to the time +t+.  The expiration time may be
-    # a false value to disable expiration or a Time or HTTP format time string
-    # to set the expiration date.
-
-    def expires=(t)
-      @expires = t && (t.is_a?(Time) ? t.httpdate : t.to_s)
-    end
-
-    ##
-    # Retrieves the expiration time as a Time
-
-    def expires
-      @expires && Time.parse(@expires)
-    end
-
-    ##
-    # The cookie string suitable for use in an HTTP header
-
-    def to_s
-      ret = ""
-      ret << @name << "=" << @value
-      ret << "; " << "Version=" << @version.to_s if @version > 0
-      ret << "; " << "Domain="  << @domain  if @domain
-      ret << "; " << "Expires=" << @expires if @expires
-      ret << "; " << "Max-Age=" << @max_age.to_s if @max_age
-      ret << "; " << "Comment=" << @comment if @comment
-      ret << "; " << "Path="    << @path if @path
-      ret << "; " << "Secure"   if @secure
-      ret
-    end
-
-    ##
-    # Parses a Cookie field sent from the user-agent.  Returns an array of
-    # cookies.
-
-    def self.parse(str)
-      if str
-        ret = []
-        cookie = nil
-        ver = 0
-        str.split(/;\s+/).each{|x|
-          key, val = x.split(/=/,2)
-          val = val ? HTTPUtils::dequote(val) : ""
-          case key
-          when "$Version"; ver = val.to_i
-          when "$Path";    cookie.path = val
-          when "$Domain";  cookie.domain = val
-          when "$Port";    cookie.port = val
-          else
-            ret << cookie if cookie
-            cookie = self.new(key, val)
-            cookie.version = ver
-          end
-        }
-        ret << cookie if cookie
-        ret
-      end
-    end
-
-    ##
-    # Parses the cookie in +str+
-
-    def self.parse_set_cookie(str)
-      cookie_elem = str.split(/;/)
-      first_elem = cookie_elem.shift
-      first_elem.strip!
-      key, value = first_elem.split(/=/, 2)
-      cookie = new(key, HTTPUtils.dequote(value))
-      cookie_elem.each{|pair|
-        pair.strip!
-        key, value = pair.split(/=/, 2)
-        if value
-          value = HTTPUtils.dequote(value.strip)
-        end
-        case key.downcase
-        when "domain"  then cookie.domain  = value
-        when "path"    then cookie.path    = value
-        when "expires" then cookie.expires = value
-        when "max-age" then cookie.max_age = Integer(value)
-        when "comment" then cookie.comment = value
-        when "version" then cookie.version = Integer(value)
-        when "secure"  then cookie.secure = true
-        end
-      }
-      return cookie
-    end
-
-    ##
-    # Parses the cookies in +str+
-
-    def self.parse_set_cookies(str)
-      return str.split(/,(?=[^;,]*=)|,$/).collect{|c|
-        parse_set_cookie(c)
-      }
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/htmlutils.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/htmlutils.rb
deleted file mode 100644
index ed9f4ac0d3e97..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/htmlutils.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-# frozen_string_literal: false
-#--
-# htmlutils.rb -- HTMLUtils Module
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: htmlutils.rb,v 1.7 2002/09/21 12:23:35 gotoyuzo Exp $
-
-module WEBrick
-  module HTMLUtils
-
-    ##
-    # Escapes &, ", > and < in +string+
-
-    def escape(string)
-      return "" unless string
-      str = string.b
-      str.gsub!(/&/n, '&amp;')
-      str.gsub!(/\"/n, '&quot;')
-      str.gsub!(/>/n, '&gt;')
-      str.gsub!(/</n, '&lt;')
-      str.force_encoding(string.encoding)
-    end
-    module_function :escape
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth.rb
deleted file mode 100644
index f8bf09a6f1972..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth.rb
+++ /dev/null
@@ -1,96 +0,0 @@
-# frozen_string_literal: false
-#
-# httpauth.rb -- HTTP access authentication
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: httpauth.rb,v 1.14 2003/07/22 19:20:42 gotoyuzo Exp $
-
-require_relative 'httpauth/basicauth'
-require_relative 'httpauth/digestauth'
-require_relative 'httpauth/htpasswd'
-require_relative 'httpauth/htdigest'
-require_relative 'httpauth/htgroup'
-
-module WEBrick
-
-  ##
-  # HTTPAuth provides both basic and digest authentication.
-  #
-  # To enable authentication for requests in WEBrick you will need a user
-  # database and an authenticator.  To start, here's an Htpasswd database for
-  # use with a DigestAuth authenticator:
-  #
-  #   config = { :Realm => 'DigestAuth example realm' }
-  #
-  #   htpasswd = WEBrick::HTTPAuth::Htpasswd.new 'my_password_file'
-  #   htpasswd.auth_type = WEBrick::HTTPAuth::DigestAuth
-  #   htpasswd.set_passwd config[:Realm], 'username', 'password'
-  #   htpasswd.flush
-  #
-  # The +:Realm+ is used to provide different access to different groups
-  # across several resources on a server.  Typically you'll need only one
-  # realm for a server.
-  #
-  # This database can be used to create an authenticator:
-  #
-  #   config[:UserDB] = htpasswd
-  #
-  #   digest_auth = WEBrick::HTTPAuth::DigestAuth.new config
-  #
-  # To authenticate a request call #authenticate with a request and response
-  # object in a servlet:
-  #
-  #   def do_GET req, res
-  #     @authenticator.authenticate req, res
-  #   end
-  #
-  # For digest authentication the authenticator must not be created every
-  # request, it must be passed in as an option via WEBrick::HTTPServer#mount.
-
-  module HTTPAuth
-    module_function
-
-    def _basic_auth(req, res, realm, req_field, res_field, err_type,
-                    block) # :nodoc:
-      user = pass = nil
-      if /^Basic\s+(.*)/o =~ req[req_field]
-        userpass = $1
-        user, pass = userpass.unpack("m*")[0].split(":", 2)
-      end
-      if block.call(user, pass)
-        req.user = user
-        return
-      end
-      res[res_field] = "Basic realm=\"#{realm}\""
-      raise err_type
-    end
-
-    ##
-    # Simple wrapper for providing basic authentication for a request.  When
-    # called with a request +req+, response +res+, authentication +realm+ and
-    # +block+ the block will be called with a +username+ and +password+.  If
-    # the block returns true the request is allowed to continue, otherwise an
-    # HTTPStatus::Unauthorized error is raised.
-
-    def basic_auth(req, res, realm, &block) # :yield: username, password
-      _basic_auth(req, res, realm, "Authorization", "WWW-Authenticate",
-                  HTTPStatus::Unauthorized, block)
-    end
-
-    ##
-    # Simple wrapper for providing basic authentication for a proxied request.
-    # When called with a request +req+, response +res+, authentication +realm+
-    # and +block+ the block will be called with a +username+ and +password+.
-    # If the block returns true the request is allowed to continue, otherwise
-    # an HTTPStatus::ProxyAuthenticationRequired error is raised.
-
-    def proxy_basic_auth(req, res, realm, &block) # :yield: username, password
-      _basic_auth(req, res, realm, "Proxy-Authorization", "Proxy-Authenticate",
-                  HTTPStatus::ProxyAuthenticationRequired, block)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/authenticator.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/authenticator.rb
deleted file mode 100644
index 8f0eaa3acaef2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/authenticator.rb
+++ /dev/null
@@ -1,117 +0,0 @@
-# frozen_string_literal: false
-#--
-# httpauth/authenticator.rb -- Authenticator mix-in module.
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2003 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: authenticator.rb,v 1.3 2003/02/20 07:15:47 gotoyuzo Exp $
-
-module WEBrick
-  module HTTPAuth
-
-    ##
-    # Module providing generic support for both Digest and Basic
-    # authentication schemes.
-
-    module Authenticator
-
-      RequestField      = "Authorization" # :nodoc:
-      ResponseField     = "WWW-Authenticate" # :nodoc:
-      ResponseInfoField = "Authentication-Info" # :nodoc:
-      AuthException     = HTTPStatus::Unauthorized # :nodoc:
-
-      ##
-      # Method of authentication, must be overridden by the including class
-
-      AuthScheme        = nil
-
-      ##
-      # The realm this authenticator covers
-
-      attr_reader :realm
-
-      ##
-      # The user database for this authenticator
-
-      attr_reader :userdb
-
-      ##
-      # The logger for this authenticator
-
-      attr_reader :logger
-
-      private
-
-      # :stopdoc:
-
-      ##
-      # Initializes the authenticator from +config+
-
-      def check_init(config)
-        [:UserDB, :Realm].each{|sym|
-          unless config[sym]
-            raise ArgumentError, "Argument #{sym.inspect} missing."
-          end
-        }
-        @realm     = config[:Realm]
-        @userdb    = config[:UserDB]
-        @logger    = config[:Logger] || Log::new($stderr)
-        @reload_db = config[:AutoReloadUserDB]
-        @request_field   = self::class::RequestField
-        @response_field  = self::class::ResponseField
-        @resp_info_field = self::class::ResponseInfoField
-        @auth_exception  = self::class::AuthException
-        @auth_scheme     = self::class::AuthScheme
-      end
-
-      ##
-      # Ensures +req+ has credentials that can be authenticated.
-
-      def check_scheme(req)
-        unless credentials = req[@request_field]
-          error("no credentials in the request.")
-          return nil
-        end
-        unless match = /^#{@auth_scheme}\s+/i.match(credentials)
-          error("invalid scheme in %s.", credentials)
-          info("%s: %s", @request_field, credentials) if $DEBUG
-          return nil
-        end
-        return match.post_match
-      end
-
-      def log(meth, fmt, *args)
-        msg = format("%s %s: ", @auth_scheme, @realm)
-        msg << fmt % args
-        @logger.__send__(meth, msg)
-      end
-
-      def error(fmt, *args)
-        if @logger.error?
-          log(:error, fmt, *args)
-        end
-      end
-
-      def info(fmt, *args)
-        if @logger.info?
-          log(:info, fmt, *args)
-        end
-      end
-
-      # :startdoc:
-    end
-
-    ##
-    # Module providing generic support for both Digest and Basic
-    # authentication schemes for proxies.
-
-    module ProxyAuthenticator
-      RequestField  = "Proxy-Authorization" # :nodoc:
-      ResponseField = "Proxy-Authenticate" # :nodoc:
-      InfoField     = "Proxy-Authentication-Info" # :nodoc:
-      AuthException = HTTPStatus::ProxyAuthenticationRequired # :nodoc:
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/basicauth.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/basicauth.rb
deleted file mode 100644
index 7d0a9cfc8fd43..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/basicauth.rb
+++ /dev/null
@@ -1,116 +0,0 @@
-# frozen_string_literal: false
-#
-# httpauth/basicauth.rb -- HTTP basic access authentication
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2003 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: basicauth.rb,v 1.5 2003/02/20 07:15:47 gotoyuzo Exp $
-
-require_relative '../config'
-require_relative '../httpstatus'
-require_relative 'authenticator'
-
-module WEBrick
-  module HTTPAuth
-
-    ##
-    # Basic Authentication for WEBrick
-    #
-    # Use this class to add basic authentication to a WEBrick servlet.
-    #
-    # Here is an example of how to set up a BasicAuth:
-    #
-    #   config = { :Realm => 'BasicAuth example realm' }
-    #
-    #   htpasswd = WEBrick::HTTPAuth::Htpasswd.new 'my_password_file', password_hash: :bcrypt
-    #   htpasswd.set_passwd config[:Realm], 'username', 'password'
-    #   htpasswd.flush
-    #
-    #   config[:UserDB] = htpasswd
-    #
-    #   basic_auth = WEBrick::HTTPAuth::BasicAuth.new config
-
-    class BasicAuth
-      include Authenticator
-
-      AuthScheme = "Basic" # :nodoc:
-
-      ##
-      # Used by UserDB to create a basic password entry
-
-      def self.make_passwd(realm, user, pass)
-        pass ||= ""
-        pass.crypt(Utils::random_string(2))
-      end
-
-      attr_reader :realm, :userdb, :logger
-
-      ##
-      # Creates a new BasicAuth instance.
-      #
-      # See WEBrick::Config::BasicAuth for default configuration entries
-      #
-      # You must supply the following configuration entries:
-      #
-      # :Realm:: The name of the realm being protected.
-      # :UserDB:: A database of usernames and passwords.
-      #           A WEBrick::HTTPAuth::Htpasswd instance should be used.
-
-      def initialize(config, default=Config::BasicAuth)
-        check_init(config)
-        @config = default.dup.update(config)
-      end
-
-      ##
-      # Authenticates a +req+ and returns a 401 Unauthorized using +res+ if
-      # the authentication was not correct.
-
-      def authenticate(req, res)
-        unless basic_credentials = check_scheme(req)
-          challenge(req, res)
-        end
-        userid, password = basic_credentials.unpack("m*")[0].split(":", 2)
-        password ||= ""
-        if userid.empty?
-          error("user id was not given.")
-          challenge(req, res)
-        end
-        unless encpass = @userdb.get_passwd(@realm, userid, @reload_db)
-          error("%s: the user is not allowed.", userid)
-          challenge(req, res)
-        end
-
-        case encpass
-        when /\A\$2[aby]\$/
-          password_matches = BCrypt::Password.new(encpass.sub(/\A\$2[aby]\$/, '$2a$')) == password
-        else
-          password_matches = password.crypt(encpass) == encpass
-        end
-
-        unless password_matches
-          error("%s: password unmatch.", userid)
-          challenge(req, res)
-        end
-        info("%s: authentication succeeded.", userid)
-        req.user = userid
-      end
-
-      ##
-      # Returns a challenge response which asks for authentication information
-
-      def challenge(req, res)
-        res[@response_field] = "#{@auth_scheme} realm=\"#{@realm}\""
-        raise @auth_exception
-      end
-    end
-
-    ##
-    # Basic authentication for proxy servers.  See BasicAuth for details.
-
-    class ProxyBasicAuth < BasicAuth
-      include ProxyAuthenticator
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/digestauth.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/digestauth.rb
deleted file mode 100644
index 3cf12899d2f2a..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/digestauth.rb
+++ /dev/null
@@ -1,395 +0,0 @@
-# frozen_string_literal: false
-#
-# httpauth/digestauth.rb -- HTTP digest access authentication
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2003 Internet Programming with Ruby writers.
-# Copyright (c) 2003 H.M.
-#
-# The original implementation is provided by H.M.
-#   URL: http://rwiki.jin.gr.jp/cgi-bin/rw-cgi.rb?cmd=view;name=
-#        %C7%A7%BE%DA%B5%A1%C7%BD%A4%F2%B2%FE%C2%A4%A4%B7%A4%C6%A4%DF%A4%EB
-#
-# $IPR: digestauth.rb,v 1.5 2003/02/20 07:15:47 gotoyuzo Exp $
-
-require_relative '../config'
-require_relative '../httpstatus'
-require_relative 'authenticator'
-require 'digest/md5'
-require 'digest/sha1'
-
-module WEBrick
-  module HTTPAuth
-
-    ##
-    # RFC 2617 Digest Access Authentication for WEBrick
-    #
-    # Use this class to add digest authentication to a WEBrick servlet.
-    #
-    # Here is an example of how to set up DigestAuth:
-    #
-    #   config = { :Realm => 'DigestAuth example realm' }
-    #
-    #   htdigest = WEBrick::HTTPAuth::Htdigest.new 'my_password_file'
-    #   htdigest.set_passwd config[:Realm], 'username', 'password'
-    #   htdigest.flush
-    #
-    #   config[:UserDB] = htdigest
-    #
-    #   digest_auth = WEBrick::HTTPAuth::DigestAuth.new config
-    #
-    # When using this as with a servlet be sure not to create a new DigestAuth
-    # object in the servlet's #initialize.  By default WEBrick creates a new
-    # servlet instance for every request and the DigestAuth object must be
-    # used across requests.
-
-    class DigestAuth
-      include Authenticator
-
-      AuthScheme = "Digest" # :nodoc:
-
-      ##
-      # Struct containing the opaque portion of the digest authentication
-
-      OpaqueInfo = Struct.new(:time, :nonce, :nc) # :nodoc:
-
-      ##
-      # Digest authentication algorithm
-
-      attr_reader :algorithm
-
-      ##
-      # Quality of protection.  RFC 2617 defines "auth" and "auth-int"
-
-      attr_reader :qop
-
-      ##
-      # Used by UserDB to create a digest password entry
-
-      def self.make_passwd(realm, user, pass)
-        pass ||= ""
-        Digest::MD5::hexdigest([user, realm, pass].join(":"))
-      end
-
-      ##
-      # Creates a new DigestAuth instance.  Be sure to use the same DigestAuth
-      # instance for multiple requests as it saves state between requests in
-      # order to perform authentication.
-      #
-      # See WEBrick::Config::DigestAuth for default configuration entries
-      #
-      # You must supply the following configuration entries:
-      #
-      # :Realm:: The name of the realm being protected.
-      # :UserDB:: A database of usernames and passwords.
-      #           A WEBrick::HTTPAuth::Htdigest instance should be used.
-
-      def initialize(config, default=Config::DigestAuth)
-        check_init(config)
-        @config                 = default.dup.update(config)
-        @algorithm              = @config[:Algorithm]
-        @domain                 = @config[:Domain]
-        @qop                    = @config[:Qop]
-        @use_opaque             = @config[:UseOpaque]
-        @use_next_nonce         = @config[:UseNextNonce]
-        @check_nc               = @config[:CheckNc]
-        @use_auth_info_header   = @config[:UseAuthenticationInfoHeader]
-        @nonce_expire_period    = @config[:NonceExpirePeriod]
-        @nonce_expire_delta     = @config[:NonceExpireDelta]
-        @internet_explorer_hack = @config[:InternetExplorerHack]
-
-        case @algorithm
-        when 'MD5','MD5-sess'
-          @h = Digest::MD5
-        when 'SHA1','SHA1-sess'  # it is a bonus feature :-)
-          @h = Digest::SHA1
-        else
-          msg = format('Algorithm "%s" is not supported.', @algorithm)
-          raise ArgumentError.new(msg)
-        end
-
-        @instance_key = hexdigest(self.__id__, Time.now.to_i, Process.pid)
-        @opaques = {}
-        @last_nonce_expire = Time.now
-        @mutex = Thread::Mutex.new
-      end
-
-      ##
-      # Authenticates a +req+ and returns a 401 Unauthorized using +res+ if
-      # the authentication was not correct.
-
-      def authenticate(req, res)
-        unless result = @mutex.synchronize{ _authenticate(req, res) }
-          challenge(req, res)
-        end
-        if result == :nonce_is_stale
-          challenge(req, res, true)
-        end
-        return true
-      end
-
-      ##
-      # Returns a challenge response which asks for authentication information
-
-      def challenge(req, res, stale=false)
-        nonce = generate_next_nonce(req)
-        if @use_opaque
-          opaque = generate_opaque(req)
-          @opaques[opaque].nonce = nonce
-        end
-
-        param = Hash.new
-        param["realm"]  = HTTPUtils::quote(@realm)
-        param["domain"] = HTTPUtils::quote(@domain.to_a.join(" ")) if @domain
-        param["nonce"]  = HTTPUtils::quote(nonce)
-        param["opaque"] = HTTPUtils::quote(opaque) if opaque
-        param["stale"]  = stale.to_s
-        param["algorithm"] = @algorithm
-        param["qop"]    = HTTPUtils::quote(@qop.to_a.join(",")) if @qop
-
-        res[@response_field] =
-          "#{@auth_scheme} " + param.map{|k,v| "#{k}=#{v}" }.join(", ")
-        info("%s: %s", @response_field, res[@response_field]) if $DEBUG
-        raise @auth_exception
-      end
-
-      private
-
-      # :stopdoc:
-
-      MustParams = ['username','realm','nonce','uri','response']
-      MustParamsAuth = ['cnonce','nc']
-
-      def _authenticate(req, res)
-        unless digest_credentials = check_scheme(req)
-          return false
-        end
-
-        auth_req = split_param_value(digest_credentials)
-        if auth_req['qop'] == "auth" || auth_req['qop'] == "auth-int"
-          req_params = MustParams + MustParamsAuth
-        else
-          req_params = MustParams
-        end
-        req_params.each{|key|
-          unless auth_req.has_key?(key)
-            error('%s: parameter missing. "%s"', auth_req['username'], key)
-            raise HTTPStatus::BadRequest
-          end
-        }
-
-        if !check_uri(req, auth_req)
-          raise HTTPStatus::BadRequest
-        end
-
-        if auth_req['realm'] != @realm
-          error('%s: realm unmatch. "%s" for "%s"',
-                auth_req['username'], auth_req['realm'], @realm)
-          return false
-        end
-
-        auth_req['algorithm'] ||= 'MD5'
-        if auth_req['algorithm'].upcase != @algorithm.upcase
-          error('%s: algorithm unmatch. "%s" for "%s"',
-                auth_req['username'], auth_req['algorithm'], @algorithm)
-          return false
-        end
-
-        if (@qop.nil? && auth_req.has_key?('qop')) ||
-           (@qop && (! @qop.member?(auth_req['qop'])))
-          error('%s: the qop is not allowed. "%s"',
-                auth_req['username'], auth_req['qop'])
-          return false
-        end
-
-        password = @userdb.get_passwd(@realm, auth_req['username'], @reload_db)
-        unless password
-          error('%s: the user is not allowed.', auth_req['username'])
-          return false
-        end
-
-        nonce_is_invalid = false
-        if @use_opaque
-          info("@opaque = %s", @opaque.inspect) if $DEBUG
-          if !(opaque = auth_req['opaque'])
-            error('%s: opaque is not given.', auth_req['username'])
-            nonce_is_invalid = true
-          elsif !(opaque_struct = @opaques[opaque])
-            error('%s: invalid opaque is given.', auth_req['username'])
-            nonce_is_invalid = true
-          elsif !check_opaque(opaque_struct, req, auth_req)
-            @opaques.delete(auth_req['opaque'])
-            nonce_is_invalid = true
-          end
-        elsif !check_nonce(req, auth_req)
-          nonce_is_invalid = true
-        end
-
-        if /-sess$/i =~ auth_req['algorithm']
-          ha1 = hexdigest(password, auth_req['nonce'], auth_req['cnonce'])
-        else
-          ha1 = password
-        end
-
-        if auth_req['qop'] == "auth" || auth_req['qop'] == nil
-          ha2 = hexdigest(req.request_method, auth_req['uri'])
-          ha2_res = hexdigest("", auth_req['uri'])
-        elsif auth_req['qop'] == "auth-int"
-          body_digest = @h.new
-          req.body { |chunk| body_digest.update(chunk) }
-          body_digest = body_digest.hexdigest
-          ha2 = hexdigest(req.request_method, auth_req['uri'], body_digest)
-          ha2_res = hexdigest("", auth_req['uri'], body_digest)
-        end
-
-        if auth_req['qop'] == "auth" || auth_req['qop'] == "auth-int"
-          param2 = ['nonce', 'nc', 'cnonce', 'qop'].map{|key|
-            auth_req[key]
-          }.join(':')
-          digest     = hexdigest(ha1, param2, ha2)
-          digest_res = hexdigest(ha1, param2, ha2_res)
-        else
-          digest     = hexdigest(ha1, auth_req['nonce'], ha2)
-          digest_res = hexdigest(ha1, auth_req['nonce'], ha2_res)
-        end
-
-        if digest != auth_req['response']
-          error("%s: digest unmatch.", auth_req['username'])
-          return false
-        elsif nonce_is_invalid
-          error('%s: digest is valid, but nonce is not valid.',
-                auth_req['username'])
-          return :nonce_is_stale
-        elsif @use_auth_info_header
-          auth_info = {
-            'nextnonce' => generate_next_nonce(req),
-            'rspauth'   => digest_res
-          }
-          if @use_opaque
-            opaque_struct.time  = req.request_time
-            opaque_struct.nonce = auth_info['nextnonce']
-            opaque_struct.nc    = "%08x" % (auth_req['nc'].hex + 1)
-          end
-          if auth_req['qop'] == "auth" || auth_req['qop'] == "auth-int"
-            ['qop','cnonce','nc'].each{|key|
-              auth_info[key] = auth_req[key]
-            }
-          end
-          res[@resp_info_field] = auth_info.keys.map{|key|
-            if key == 'nc'
-              key + '=' + auth_info[key]
-            else
-              key + "=" + HTTPUtils::quote(auth_info[key])
-            end
-          }.join(', ')
-        end
-        info('%s: authentication succeeded.', auth_req['username'])
-        req.user = auth_req['username']
-        return true
-      end
-
-      def split_param_value(string)
-        ret = {}
-        string.scan(/\G\s*([\w\-.*%!]+)=\s*(?:\"((?>\\.|[^\"])*)\"|([^,\"]*))\s*,?/) do
-          ret[$1] = $3 || $2.gsub(/\\(.)/, "\\1")
-        end
-        ret
-      end
-
-      def generate_next_nonce(req)
-        now = "%012d" % req.request_time.to_i
-        pk  = hexdigest(now, @instance_key)[0,32]
-        nonce = [now + ":" + pk].pack("m0") # it has 60 length of chars.
-        nonce
-      end
-
-      def check_nonce(req, auth_req)
-        username = auth_req['username']
-        nonce = auth_req['nonce']
-
-        pub_time, pk = nonce.unpack("m*")[0].split(":", 2)
-        if (!pub_time || !pk)
-          error("%s: empty nonce is given", username)
-          return false
-        elsif (hexdigest(pub_time, @instance_key)[0,32] != pk)
-          error("%s: invalid private-key: %s for %s",
-                username, hexdigest(pub_time, @instance_key)[0,32], pk)
-          return false
-        end
-
-        diff_time = req.request_time.to_i - pub_time.to_i
-        if (diff_time < 0)
-          error("%s: difference of time-stamp is negative.", username)
-          return false
-        elsif diff_time > @nonce_expire_period
-          error("%s: nonce is expired.", username)
-          return false
-        end
-
-        return true
-      end
-
-      def generate_opaque(req)
-        @mutex.synchronize{
-          now = req.request_time
-          if now - @last_nonce_expire > @nonce_expire_delta
-            @opaques.delete_if{|key,val|
-              (now - val.time) > @nonce_expire_period
-            }
-            @last_nonce_expire = now
-          end
-          begin
-            opaque = Utils::random_string(16)
-          end while @opaques[opaque]
-          @opaques[opaque] = OpaqueInfo.new(now, nil, '00000001')
-          opaque
-        }
-      end
-
-      def check_opaque(opaque_struct, req, auth_req)
-        if (@use_next_nonce && auth_req['nonce'] != opaque_struct.nonce)
-          error('%s: nonce unmatched. "%s" for "%s"',
-                auth_req['username'], auth_req['nonce'], opaque_struct.nonce)
-          return false
-        elsif !check_nonce(req, auth_req)
-          return false
-        end
-        if (@check_nc && auth_req['nc'] != opaque_struct.nc)
-          error('%s: nc unmatched."%s" for "%s"',
-                auth_req['username'], auth_req['nc'], opaque_struct.nc)
-          return false
-        end
-        true
-      end
-
-      def check_uri(req, auth_req)
-        uri = auth_req['uri']
-        if uri != req.request_uri.to_s && uri != req.unparsed_uri &&
-           (@internet_explorer_hack && uri != req.path)
-          error('%s: uri unmatch. "%s" for "%s"', auth_req['username'],
-                auth_req['uri'], req.request_uri.to_s)
-          return false
-        end
-        true
-      end
-
-      def hexdigest(*args)
-        @h.hexdigest(args.join(":"))
-      end
-
-      # :startdoc:
-    end
-
-    ##
-    # Digest authentication for proxy servers.  See DigestAuth for details.
-
-    class ProxyDigestAuth < DigestAuth
-      include ProxyAuthenticator
-
-      private
-      def check_uri(req, auth_req) # :nodoc:
-        return true
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/htdigest.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/htdigest.rb
deleted file mode 100644
index 93b18e2c750bd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/htdigest.rb
+++ /dev/null
@@ -1,132 +0,0 @@
-# frozen_string_literal: false
-#
-# httpauth/htdigest.rb -- Apache compatible htdigest file
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2003 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: htdigest.rb,v 1.4 2003/07/22 19:20:45 gotoyuzo Exp $
-
-require_relative 'userdb'
-require_relative 'digestauth'
-require 'tempfile'
-
-module WEBrick
-  module HTTPAuth
-
-    ##
-    # Htdigest accesses apache-compatible digest password files.  Passwords are
-    # matched to a realm where they are valid.  For security, the path for a
-    # digest password database should be stored outside of the paths available
-    # to the HTTP server.
-    #
-    # Htdigest is intended for use with WEBrick::HTTPAuth::DigestAuth and
-    # stores passwords using cryptographic hashes.
-    #
-    #   htpasswd = WEBrick::HTTPAuth::Htdigest.new 'my_password_file'
-    #   htpasswd.set_passwd 'my realm', 'username', 'password'
-    #   htpasswd.flush
-
-    class Htdigest
-      include UserDB
-
-      ##
-      # Open a digest password database at +path+
-
-      def initialize(path)
-        @path = path
-        @mtime = Time.at(0)
-        @digest = Hash.new
-        @mutex = Thread::Mutex::new
-        @auth_type = DigestAuth
-        File.open(@path,"a").close unless File.exist?(@path)
-        reload
-      end
-
-      ##
-      # Reloads passwords from the database
-
-      def reload
-        mtime = File::mtime(@path)
-        if mtime > @mtime
-          @digest.clear
-          File.open(@path){|io|
-            while line = io.gets
-              line.chomp!
-              user, realm, pass = line.split(/:/, 3)
-              unless @digest[realm]
-                @digest[realm] = Hash.new
-              end
-              @digest[realm][user] = pass
-            end
-          }
-          @mtime = mtime
-        end
-      end
-
-      ##
-      # Flush the password database.  If +output+ is given the database will
-      # be written there instead of to the original path.
-
-      def flush(output=nil)
-        output ||= @path
-        tmp = Tempfile.create("htpasswd", File::dirname(output))
-        renamed = false
-        begin
-          each{|item| tmp.puts(item.join(":")) }
-          tmp.close
-          File::rename(tmp.path, output)
-          renamed = true
-        ensure
-          tmp.close
-          File.unlink(tmp.path) if !renamed
-        end
-      end
-
-      ##
-      # Retrieves a password from the database for +user+ in +realm+.  If
-      # +reload_db+ is true the database will be reloaded first.
-
-      def get_passwd(realm, user, reload_db)
-        reload() if reload_db
-        if hash = @digest[realm]
-          hash[user]
-        end
-      end
-
-      ##
-      # Sets a password in the database for +user+ in +realm+ to +pass+.
-
-      def set_passwd(realm, user, pass)
-        @mutex.synchronize{
-          unless @digest[realm]
-            @digest[realm] = Hash.new
-          end
-          @digest[realm][user] = make_passwd(realm, user, pass)
-        }
-      end
-
-      ##
-      # Removes a password from the database for +user+ in +realm+.
-
-      def delete_passwd(realm, user)
-        if hash = @digest[realm]
-          hash.delete(user)
-        end
-      end
-
-      ##
-      # Iterate passwords in the database.
-
-      def each # :yields: [user, realm, password_hash]
-        @digest.keys.sort.each{|realm|
-          hash = @digest[realm]
-          hash.keys.sort.each{|user|
-            yield([user, realm, hash[user]])
-          }
-        }
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/htgroup.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/htgroup.rb
deleted file mode 100644
index e06c441b18f35..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/htgroup.rb
+++ /dev/null
@@ -1,97 +0,0 @@
-# frozen_string_literal: false
-#
-# httpauth/htgroup.rb -- Apache compatible htgroup file
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2003 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: htgroup.rb,v 1.1 2003/02/16 22:22:56 gotoyuzo Exp $
-
-require 'tempfile'
-
-module WEBrick
-  module HTTPAuth
-
-    ##
-    # Htgroup accesses apache-compatible group files.  Htgroup can be used to
-    # provide group-based authentication for users.  Currently Htgroup is not
-    # directly integrated with any authenticators in WEBrick.  For security,
-    # the path for a digest password database should be stored outside of the
-    # paths available to the HTTP server.
-    #
-    # Example:
-    #
-    #   htgroup = WEBrick::HTTPAuth::Htgroup.new 'my_group_file'
-    #   htgroup.add 'superheroes', %w[spiderman batman]
-    #
-    #   htgroup.members('superheroes').include? 'magneto' # => false
-
-    class Htgroup
-
-      ##
-      # Open a group database at +path+
-
-      def initialize(path)
-        @path = path
-        @mtime = Time.at(0)
-        @group = Hash.new
-        File.open(@path,"a").close unless File.exist?(@path)
-        reload
-      end
-
-      ##
-      # Reload groups from the database
-
-      def reload
-        if (mtime = File::mtime(@path)) > @mtime
-          @group.clear
-          File.open(@path){|io|
-            while line = io.gets
-              line.chomp!
-              group, members = line.split(/:\s*/)
-              @group[group] = members.split(/\s+/)
-            end
-          }
-          @mtime = mtime
-        end
-      end
-
-      ##
-      # Flush the group database.  If +output+ is given the database will be
-      # written there instead of to the original path.
-
-      def flush(output=nil)
-        output ||= @path
-        tmp = Tempfile.create("htgroup", File::dirname(output))
-        begin
-          @group.keys.sort.each{|group|
-            tmp.puts(format("%s: %s", group, self.members(group).join(" ")))
-          }
-        ensure
-          tmp.close
-          if $!
-            File.unlink(tmp.path)
-          else
-            return File.rename(tmp.path, output)
-          end
-        end
-      end
-
-      ##
-      # Retrieve the list of members from +group+
-
-      def members(group)
-        reload
-        @group[group] || []
-      end
-
-      ##
-      # Add an Array of +members+ to +group+
-
-      def add(group, members)
-        @group[group] = members(group) | members
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/htpasswd.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/htpasswd.rb
deleted file mode 100644
index abca30532e042..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/htpasswd.rb
+++ /dev/null
@@ -1,158 +0,0 @@
-# frozen_string_literal: false
-#
-# httpauth/htpasswd -- Apache compatible htpasswd file
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2003 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: htpasswd.rb,v 1.4 2003/07/22 19:20:45 gotoyuzo Exp $
-
-require_relative 'userdb'
-require_relative 'basicauth'
-require 'tempfile'
-
-module WEBrick
-  module HTTPAuth
-
-    ##
-    # Htpasswd accesses apache-compatible password files.  Passwords are
-    # matched to a realm where they are valid.  For security, the path for a
-    # password database should be stored outside of the paths available to the
-    # HTTP server.
-    #
-    # Htpasswd is intended for use with WEBrick::HTTPAuth::BasicAuth.
-    #
-    # To create an Htpasswd database with a single user:
-    #
-    #   htpasswd = WEBrick::HTTPAuth::Htpasswd.new 'my_password_file'
-    #   htpasswd.set_passwd 'my realm', 'username', 'password'
-    #   htpasswd.flush
-
-    class Htpasswd
-      include UserDB
-
-      ##
-      # Open a password database at +path+
-
-      def initialize(path, password_hash: nil)
-        @path = path
-        @mtime = Time.at(0)
-        @passwd = Hash.new
-        @auth_type = BasicAuth
-        @password_hash = password_hash
-
-        case @password_hash
-        when nil
-          # begin
-          #   require "string/crypt"
-          # rescue LoadError
-          #   warn("Unable to load string/crypt, proceeding with deprecated use of String#crypt, consider using password_hash: :bcrypt")
-          # end
-          @password_hash = :crypt
-        when :crypt
-          # require "string/crypt"
-        when :bcrypt
-          require "bcrypt"
-        else
-          raise ArgumentError, "only :crypt and :bcrypt are supported for password_hash keyword argument"
-        end
-
-        File.open(@path,"a").close unless File.exist?(@path)
-        reload
-      end
-
-      ##
-      # Reload passwords from the database
-
-      def reload
-        mtime = File::mtime(@path)
-        if mtime > @mtime
-          @passwd.clear
-          File.open(@path){|io|
-            while line = io.gets
-              line.chomp!
-              case line
-              when %r!\A[^:]+:[a-zA-Z0-9./]{13}\z!
-                if @password_hash == :bcrypt
-                  raise StandardError, ".htpasswd file contains crypt password, only bcrypt passwords supported"
-                end
-                user, pass = line.split(":")
-              when %r!\A[^:]+:\$2[aby]\$\d{2}\$.{53}\z!
-                if @password_hash == :crypt
-                  raise StandardError, ".htpasswd file contains bcrypt password, only crypt passwords supported"
-                end
-                user, pass = line.split(":")
-              when /:\$/, /:{SHA}/
-                raise NotImplementedError,
-                      'MD5, SHA1 .htpasswd file not supported'
-              else
-                raise StandardError, 'bad .htpasswd file'
-              end
-              @passwd[user] = pass
-            end
-          }
-          @mtime = mtime
-        end
-      end
-
-      ##
-      # Flush the password database.  If +output+ is given the database will
-      # be written there instead of to the original path.
-
-      def flush(output=nil)
-        output ||= @path
-        tmp = Tempfile.create("htpasswd", File::dirname(output))
-        renamed = false
-        begin
-          each{|item| tmp.puts(item.join(":")) }
-          tmp.close
-          File::rename(tmp.path, output)
-          renamed = true
-        ensure
-          tmp.close
-          File.unlink(tmp.path) if !renamed
-        end
-      end
-
-      ##
-      # Retrieves a password from the database for +user+ in +realm+.  If
-      # +reload_db+ is true the database will be reloaded first.
-
-      def get_passwd(realm, user, reload_db)
-        reload() if reload_db
-        @passwd[user]
-      end
-
-      ##
-      # Sets a password in the database for +user+ in +realm+ to +pass+.
-
-      def set_passwd(realm, user, pass)
-        if @password_hash == :bcrypt
-          # Cost of 5 to match Apache default, and because the
-          # bcrypt default of 10 will introduce significant delays
-          # for every request.
-          @passwd[user] = BCrypt::Password.create(pass, :cost=>5)
-        else
-          @passwd[user] = make_passwd(realm, user, pass)
-        end
-      end
-
-      ##
-      # Removes a password from the database for +user+ in +realm+.
-
-      def delete_passwd(realm, user)
-        @passwd.delete(user)
-      end
-
-      ##
-      # Iterate passwords in the database.
-
-      def each # :yields: [user, password]
-        @passwd.keys.sort.each{|user|
-          yield([user, @passwd[user]])
-        }
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/userdb.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/userdb.rb
deleted file mode 100644
index 7a17715cdf395..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpauth/userdb.rb
+++ /dev/null
@@ -1,53 +0,0 @@
-# frozen_string_literal: false
-#--
-# httpauth/userdb.rb -- UserDB mix-in module.
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2003 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: userdb.rb,v 1.2 2003/02/20 07:15:48 gotoyuzo Exp $
-
-module WEBrick
-  module HTTPAuth
-
-    ##
-    # User database mixin for HTTPAuth.  This mixin dispatches user record
-    # access to the underlying auth_type for this database.
-
-    module UserDB
-
-      ##
-      # The authentication type.
-      #
-      # WEBrick::HTTPAuth::BasicAuth or WEBrick::HTTPAuth::DigestAuth are
-      # built-in.
-
-      attr_accessor :auth_type
-
-      ##
-      # Creates an obscured password in +realm+ with +user+ and +password+
-      # using the auth_type of this database.
-
-      def make_passwd(realm, user, pass)
-        @auth_type::make_passwd(realm, user, pass)
-      end
-
-      ##
-      # Sets a password in +realm+ with +user+ and +password+ for the
-      # auth_type of this database.
-
-      def set_passwd(realm, user, pass)
-        self[user] = pass
-      end
-
-      ##
-      # Retrieves a password in +realm+ for +user+ for the auth_type of this
-      # database.  +reload_db+ is a dummy value.
-
-      def get_passwd(realm, user, reload_db=false)
-        make_passwd(realm, user, self[user])
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpproxy.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpproxy.rb
deleted file mode 100644
index 7607c3df88e3e..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpproxy.rb
+++ /dev/null
@@ -1,354 +0,0 @@
-# frozen_string_literal: false
-#
-# httpproxy.rb -- HTTPProxy Class
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2002 GOTO Kentaro
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: httpproxy.rb,v 1.18 2003/03/08 18:58:10 gotoyuzo Exp $
-# $kNotwork: straw.rb,v 1.3 2002/02/12 15:13:07 gotoken Exp $
-
-require_relative "httpserver"
-require "net/http"
-
-module WEBrick
-
-  NullReader = Object.new # :nodoc:
-  class << NullReader # :nodoc:
-    def read(*args)
-      nil
-    end
-    alias gets read
-  end
-
-  FakeProxyURI = Object.new # :nodoc:
-  class << FakeProxyURI # :nodoc:
-    def method_missing(meth, *args)
-      if %w(scheme host port path query userinfo).member?(meth.to_s)
-        return nil
-      end
-      super
-    end
-  end
-
-  # :startdoc:
-
-  ##
-  # An HTTP Proxy server which proxies GET, HEAD and POST requests.
-  #
-  # To create a simple proxy server:
-  #
-  #   require 'webrick'
-  #   require 'webrick/httpproxy'
-  #
-  #   proxy = WEBrick::HTTPProxyServer.new Port: 8000
-  #
-  #   trap 'INT'  do proxy.shutdown end
-  #   trap 'TERM' do proxy.shutdown end
-  #
-  #   proxy.start
-  #
-  # See ::new for proxy-specific configuration items.
-  #
-  # == Modifying proxied responses
-  #
-  # To modify content the proxy server returns use the +:ProxyContentHandler+
-  # option:
-  #
-  #   handler = proc do |req, res|
-  #     if res['content-type'] == 'text/plain' then
-  #       res.body << "\nThis content was proxied!\n"
-  #     end
-  #   end
-  #
-  #   proxy =
-  #     WEBrick::HTTPProxyServer.new Port: 8000, ProxyContentHandler: handler
-
-  class HTTPProxyServer < HTTPServer
-
-    ##
-    # Proxy server configurations.  The proxy server handles the following
-    # configuration items in addition to those supported by HTTPServer:
-    #
-    # :ProxyAuthProc:: Called with a request and response to authorize a
-    #                  request
-    # :ProxyVia:: Appended to the via header
-    # :ProxyURI:: The proxy server's URI
-    # :ProxyContentHandler:: Called with a request and response and allows
-    #                        modification of the response
-    # :ProxyTimeout:: Sets the proxy timeouts to 30 seconds for open and 60
-    #                 seconds for read operations
-
-    def initialize(config={}, default=Config::HTTP)
-      super(config, default)
-      c = @config
-      @via = "#{c[:HTTPVersion]} #{c[:ServerName]}:#{c[:Port]}"
-    end
-
-    # :stopdoc:
-    def service(req, res)
-      if req.request_method == "CONNECT"
-        do_CONNECT(req, res)
-      elsif req.unparsed_uri =~ %r!^http://!
-        proxy_service(req, res)
-      else
-        super(req, res)
-      end
-    end
-
-    def proxy_auth(req, res)
-      if proc = @config[:ProxyAuthProc]
-        proc.call(req, res)
-      end
-      req.header.delete("proxy-authorization")
-    end
-
-    def proxy_uri(req, res)
-      # should return upstream proxy server's URI
-      return @config[:ProxyURI]
-    end
-
-    def proxy_service(req, res)
-      # Proxy Authentication
-      proxy_auth(req, res)
-
-      begin
-        public_send("do_#{req.request_method}", req, res)
-      rescue NoMethodError
-        raise HTTPStatus::MethodNotAllowed,
-          "unsupported method `#{req.request_method}'."
-      rescue => err
-        logger.debug("#{err.class}: #{err.message}")
-        raise HTTPStatus::ServiceUnavailable, err.message
-      end
-
-      # Process contents
-      if handler = @config[:ProxyContentHandler]
-        handler.call(req, res)
-      end
-    end
-
-    def do_CONNECT(req, res)
-      # Proxy Authentication
-      proxy_auth(req, res)
-
-      ua = Thread.current[:WEBrickSocket]  # User-Agent
-      raise HTTPStatus::InternalServerError,
-        "[BUG] cannot get socket" unless ua
-
-      host, port = req.unparsed_uri.split(":", 2)
-      # Proxy authentication for upstream proxy server
-      if proxy = proxy_uri(req, res)
-        proxy_request_line = "CONNECT #{host}:#{port} HTTP/1.0"
-        if proxy.userinfo
-          credentials = "Basic " + [proxy.userinfo].pack("m0")
-        end
-        host, port = proxy.host, proxy.port
-      end
-
-      begin
-        @logger.debug("CONNECT: upstream proxy is `#{host}:#{port}'.")
-        os = TCPSocket.new(host, port)     # origin server
-
-        if proxy
-          @logger.debug("CONNECT: sending a Request-Line")
-          os << proxy_request_line << CRLF
-          @logger.debug("CONNECT: > #{proxy_request_line}")
-          if credentials
-            @logger.debug("CONNECT: sending credentials")
-            os << "Proxy-Authorization: " << credentials << CRLF
-          end
-          os << CRLF
-          proxy_status_line = os.gets(LF)
-          @logger.debug("CONNECT: read Status-Line from the upstream server")
-          @logger.debug("CONNECT: < #{proxy_status_line}")
-          if %r{^HTTP/\d+\.\d+\s+200\s*} =~ proxy_status_line
-            while line = os.gets(LF)
-              break if /\A(#{CRLF}|#{LF})\z/om =~ line
-            end
-          else
-            raise HTTPStatus::BadGateway
-          end
-        end
-        @logger.debug("CONNECT #{host}:#{port}: succeeded")
-        res.status = HTTPStatus::RC_OK
-      rescue => ex
-        @logger.debug("CONNECT #{host}:#{port}: failed `#{ex.message}'")
-        res.set_error(ex)
-        raise HTTPStatus::EOFError
-      ensure
-        if handler = @config[:ProxyContentHandler]
-          handler.call(req, res)
-        end
-        res.send_response(ua)
-        access_log(@config, req, res)
-
-        # Should clear request-line not to send the response twice.
-        # see: HTTPServer#run
-        req.parse(NullReader) rescue nil
-      end
-
-      begin
-        while fds = IO::select([ua, os])
-          if fds[0].member?(ua)
-            buf = ua.readpartial(1024);
-            @logger.debug("CONNECT: #{buf.bytesize} byte from User-Agent")
-            os.write(buf)
-          elsif fds[0].member?(os)
-            buf = os.readpartial(1024);
-            @logger.debug("CONNECT: #{buf.bytesize} byte from #{host}:#{port}")
-            ua.write(buf)
-          end
-        end
-      rescue
-        os.close
-        @logger.debug("CONNECT #{host}:#{port}: closed")
-      end
-
-      raise HTTPStatus::EOFError
-    end
-
-    def do_GET(req, res)
-      perform_proxy_request(req, res, Net::HTTP::Get)
-    end
-
-    def do_HEAD(req, res)
-      perform_proxy_request(req, res, Net::HTTP::Head)
-    end
-
-    def do_POST(req, res)
-      perform_proxy_request(req, res, Net::HTTP::Post, req.body_reader)
-    end
-
-    def do_OPTIONS(req, res)
-      res['allow'] = "GET,HEAD,POST,OPTIONS,CONNECT"
-    end
-
-    private
-
-    # Some header fields should not be transferred.
-    HopByHop = %w( connection keep-alive proxy-authenticate upgrade
-                   proxy-authorization te trailers transfer-encoding )
-    ShouldNotTransfer = %w( set-cookie proxy-connection )
-    def split_field(f) f ? f.split(/,\s+/).collect{|i| i.downcase } : [] end
-
-    def choose_header(src, dst)
-      connections = split_field(src['connection'])
-      src.each{|key, value|
-        key = key.downcase
-        if HopByHop.member?(key)          || # RFC2616: 13.5.1
-           connections.member?(key)       || # RFC2616: 14.10
-           ShouldNotTransfer.member?(key)    # pragmatics
-          @logger.debug("choose_header: `#{key}: #{value}'")
-          next
-        end
-        dst[key] = value
-      }
-    end
-
-    # Net::HTTP is stupid about the multiple header fields.
-    # Here is workaround:
-    def set_cookie(src, dst)
-      if str = src['set-cookie']
-        cookies = []
-        str.split(/,\s*/).each{|token|
-          if /^[^=]+;/o =~ token
-            cookies[-1] << ", " << token
-          elsif /=/o =~ token
-            cookies << token
-          else
-            cookies[-1] << ", " << token
-          end
-        }
-        dst.cookies.replace(cookies)
-      end
-    end
-
-    def set_via(h)
-      if @config[:ProxyVia]
-        if  h['via']
-          h['via'] << ", " << @via
-        else
-          h['via'] = @via
-        end
-      end
-    end
-
-    def setup_proxy_header(req, res)
-      # Choose header fields to transfer
-      header = Hash.new
-      choose_header(req, header)
-      set_via(header)
-      return header
-    end
-
-    def setup_upstream_proxy_authentication(req, res, header)
-      if upstream = proxy_uri(req, res)
-        if upstream.userinfo
-          header['proxy-authorization'] =
-            "Basic " + [upstream.userinfo].pack("m0")
-        end
-        return upstream
-      end
-      return FakeProxyURI
-    end
-
-    def create_net_http(uri, upstream)
-      Net::HTTP.new(uri.host, uri.port, upstream.host, upstream.port)
-    end
-
-    def perform_proxy_request(req, res, req_class, body_stream = nil)
-      uri = req.request_uri
-      path = uri.path.dup
-      path << "?" << uri.query if uri.query
-      header = setup_proxy_header(req, res)
-      upstream = setup_upstream_proxy_authentication(req, res, header)
-
-      body_tmp = []
-      http = create_net_http(uri, upstream)
-      req_fib = Fiber.new do
-        http.start do
-          if @config[:ProxyTimeout]
-            ##################################   these issues are
-            http.open_timeout = 30   # secs  #   necessary (maybe because
-            http.read_timeout = 60   # secs  #   Ruby's bug, but why?)
-            ##################################
-          end
-          if body_stream && req['transfer-encoding'] =~ /\bchunked\b/i
-            header['Transfer-Encoding'] = 'chunked'
-          end
-          http_req = req_class.new(path, header)
-          http_req.body_stream = body_stream if body_stream
-          http.request(http_req) do |response|
-            # Persistent connection requirements are mysterious for me.
-            # So I will close the connection in every response.
-            res['proxy-connection'] = "close"
-            res['connection'] = "close"
-
-            # stream Net::HTTP::HTTPResponse to WEBrick::HTTPResponse
-            res.status = response.code.to_i
-            res.chunked = response.chunked?
-            choose_header(response, res)
-            set_cookie(response, res)
-            set_via(res)
-            response.read_body do |buf|
-              body_tmp << buf
-              Fiber.yield # wait for res.body Proc#call
-            end
-          end # http.request
-        end
-      end
-      req_fib.resume # read HTTP response headers and first chunk of the body
-      res.body = ->(socket) do
-        while buf = body_tmp.shift
-          socket.write(buf)
-          buf.clear
-          req_fib.resume # continue response.read_body
-        end
-      end
-    end
-    # :stopdoc:
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httprequest.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httprequest.rb
deleted file mode 100644
index d34eac7ecf6ed..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httprequest.rb
+++ /dev/null
@@ -1,636 +0,0 @@
-# frozen_string_literal: false
-#
-# httprequest.rb -- HTTPRequest Class
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: httprequest.rb,v 1.64 2003/07/13 17:18:22 gotoyuzo Exp $
-
-require 'fiber'
-require 'uri'
-require_relative 'httpversion'
-require_relative 'httpstatus'
-require_relative 'httputils'
-require_relative 'cookie'
-
-module WEBrick
-
-  ##
-  # An HTTP request.  This is consumed by service and do_* methods in
-  # WEBrick servlets
-
-  class HTTPRequest
-
-    BODY_CONTAINABLE_METHODS = [ "POST", "PUT" ] # :nodoc:
-
-    # :section: Request line
-
-    ##
-    # The complete request line such as:
-    #
-    #   GET / HTTP/1.1
-
-    attr_reader :request_line
-
-    ##
-    # The request method, GET, POST, PUT, etc.
-
-    attr_reader :request_method
-
-    ##
-    # The unparsed URI of the request
-
-    attr_reader :unparsed_uri
-
-    ##
-    # The HTTP version of the request
-
-    attr_reader :http_version
-
-    # :section: Request-URI
-
-    ##
-    # The parsed URI of the request
-
-    attr_reader :request_uri
-
-    ##
-    # The request path
-
-    attr_reader :path
-
-    ##
-    # The script name (CGI variable)
-
-    attr_accessor :script_name
-
-    ##
-    # The path info (CGI variable)
-
-    attr_accessor :path_info
-
-    ##
-    # The query from the URI of the request
-
-    attr_accessor :query_string
-
-    # :section: Header and entity body
-
-    ##
-    # The raw header of the request
-
-    attr_reader :raw_header
-
-    ##
-    # The parsed header of the request
-
-    attr_reader :header
-
-    ##
-    # The parsed request cookies
-
-    attr_reader :cookies
-
-    ##
-    # The Accept header value
-
-    attr_reader :accept
-
-    ##
-    # The Accept-Charset header value
-
-    attr_reader :accept_charset
-
-    ##
-    # The Accept-Encoding header value
-
-    attr_reader :accept_encoding
-
-    ##
-    # The Accept-Language header value
-
-    attr_reader :accept_language
-
-    # :section:
-
-    ##
-    # The remote user (CGI variable)
-
-    attr_accessor :user
-
-    ##
-    # The socket address of the server
-
-    attr_reader :addr
-
-    ##
-    # The socket address of the client
-
-    attr_reader :peeraddr
-
-    ##
-    # Hash of request attributes
-
-    attr_reader :attributes
-
-    ##
-    # Is this a keep-alive connection?
-
-    attr_reader :keep_alive
-
-    ##
-    # The local time this request was received
-
-    attr_reader :request_time
-
-    ##
-    # Creates a new HTTP request.  WEBrick::Config::HTTP is the default
-    # configuration.
-
-    def initialize(config)
-      @config = config
-      @buffer_size = @config[:InputBufferSize]
-      @logger = config[:Logger]
-
-      @request_line = @request_method =
-        @unparsed_uri = @http_version = nil
-
-      @request_uri = @host = @port = @path = nil
-      @script_name = @path_info = nil
-      @query_string = nil
-      @query = nil
-      @form_data = nil
-
-      @raw_header = Array.new
-      @header = nil
-      @cookies = []
-      @accept = []
-      @accept_charset = []
-      @accept_encoding = []
-      @accept_language = []
-      @body = ""
-
-      @addr = @peeraddr = nil
-      @attributes = {}
-      @user = nil
-      @keep_alive = false
-      @request_time = nil
-
-      @remaining_size = nil
-      @socket = nil
-
-      @forwarded_proto = @forwarded_host = @forwarded_port =
-        @forwarded_server = @forwarded_for = nil
-    end
-
-    ##
-    # Parses a request from +socket+.  This is called internally by
-    # WEBrick::HTTPServer.
-
-    def parse(socket=nil)
-      @socket = socket
-      begin
-        @peeraddr = socket.respond_to?(:peeraddr) ? socket.peeraddr : []
-        @addr = socket.respond_to?(:addr) ? socket.addr : []
-      rescue Errno::ENOTCONN
-        raise HTTPStatus::EOFError
-      end
-
-      read_request_line(socket)
-      if @http_version.major > 0
-        read_header(socket)
-        @header['cookie'].each{|cookie|
-          @cookies += Cookie::parse(cookie)
-        }
-        @accept = HTTPUtils.parse_qvalues(self['accept'])
-        @accept_charset = HTTPUtils.parse_qvalues(self['accept-charset'])
-        @accept_encoding = HTTPUtils.parse_qvalues(self['accept-encoding'])
-        @accept_language = HTTPUtils.parse_qvalues(self['accept-language'])
-      end
-      return if @request_method == "CONNECT"
-      return if @unparsed_uri == "*"
-
-      begin
-        setup_forwarded_info
-        @request_uri = parse_uri(@unparsed_uri)
-        @path = HTTPUtils::unescape(@request_uri.path)
-        @path = HTTPUtils::normalize_path(@path)
-        @host = @request_uri.host
-        @port = @request_uri.port
-        @query_string = @request_uri.query
-        @script_name = ""
-        @path_info = @path.dup
-      rescue
-        raise HTTPStatus::BadRequest, "bad URI `#{@unparsed_uri}'."
-      end
-
-      if /\Aclose\z/io =~ self["connection"]
-        @keep_alive = false
-      elsif /\Akeep-alive\z/io =~ self["connection"]
-        @keep_alive = true
-      elsif @http_version < "1.1"
-        @keep_alive = false
-      else
-        @keep_alive = true
-      end
-    end
-
-    ##
-    # Generate HTTP/1.1 100 continue response if the client expects it,
-    # otherwise does nothing.
-
-    def continue # :nodoc:
-      if self['expect'] == '100-continue' && @config[:HTTPVersion] >= "1.1"
-        @socket << "HTTP/#{@config[:HTTPVersion]} 100 continue#{CRLF}#{CRLF}"
-        @header.delete('expect')
-      end
-    end
-
-    ##
-    # Returns the request body.
-
-    def body(&block) # :yields: body_chunk
-      block ||= Proc.new{|chunk| @body << chunk }
-      read_body(@socket, block)
-      @body.empty? ? nil : @body
-    end
-
-    ##
-    # Prepares the HTTPRequest object for use as the
-    # source for IO.copy_stream
-
-    def body_reader
-      @body_tmp = []
-      @body_rd = Fiber.new do
-        body do |buf|
-          @body_tmp << buf
-          Fiber.yield
-        end
-      end
-      @body_rd.resume # grab the first chunk and yield
-      self
-    end
-
-    # for IO.copy_stream.
-    def readpartial(size, buf = ''.b) # :nodoc
-      res = @body_tmp.shift or raise EOFError, 'end of file reached'
-      if res.length > size
-        @body_tmp.unshift(res[size..-1])
-        res = res[0..size - 1]
-      end
-      buf.replace(res)
-      res.clear
-      # get more chunks - check alive? because we can take a partial chunk
-      @body_rd.resume if @body_rd.alive?
-      buf
-    end
-
-    ##
-    # Request query as a Hash
-
-    def query
-      unless @query
-        parse_query()
-      end
-      @query
-    end
-
-    ##
-    # The content-length header
-
-    def content_length
-      return Integer(self['content-length'])
-    end
-
-    ##
-    # The content-type header
-
-    def content_type
-      return self['content-type']
-    end
-
-    ##
-    # Retrieves +header_name+
-
-    def [](header_name)
-      if @header
-        value = @header[header_name.downcase]
-        value.empty? ? nil : value.join(", ")
-      end
-    end
-
-    ##
-    # Iterates over the request headers
-
-    def each
-      if @header
-        @header.each{|k, v|
-          value = @header[k]
-          yield(k, value.empty? ? nil : value.join(", "))
-        }
-      end
-    end
-
-    ##
-    # The host this request is for
-
-    def host
-      return @forwarded_host || @host
-    end
-
-    ##
-    # The port this request is for
-
-    def port
-      return @forwarded_port || @port
-    end
-
-    ##
-    # The server name this request is for
-
-    def server_name
-      return @forwarded_server || @config[:ServerName]
-    end
-
-    ##
-    # The client's IP address
-
-    def remote_ip
-      return self["client-ip"] || @forwarded_for || @peeraddr[3]
-    end
-
-    ##
-    # Is this an SSL request?
-
-    def ssl?
-      return @request_uri.scheme == "https"
-    end
-
-    ##
-    # Should the connection this request was made on be kept alive?
-
-    def keep_alive?
-      @keep_alive
-    end
-
-    def to_s # :nodoc:
-      ret = @request_line.dup
-      @raw_header.each{|line| ret << line }
-      ret << CRLF
-      ret << body if body
-      ret
-    end
-
-    ##
-    # Consumes any remaining body and updates keep-alive status
-
-    def fixup() # :nodoc:
-      begin
-        body{|chunk| }   # read remaining body
-      rescue HTTPStatus::Error => ex
-        @logger.error("HTTPRequest#fixup: #{ex.class} occurred.")
-        @keep_alive = false
-      rescue => ex
-        @logger.error(ex)
-        @keep_alive = false
-      end
-    end
-
-    # This method provides the metavariables defined by the revision 3
-    # of "The WWW Common Gateway Interface Version 1.1"
-    # To browse the current document of CGI Version 1.1, see below:
-    # http://tools.ietf.org/html/rfc3875
-
-    def meta_vars
-      meta = Hash.new
-
-      cl = self["Content-Length"]
-      ct = self["Content-Type"]
-      meta["CONTENT_LENGTH"]    = cl if cl.to_i > 0
-      meta["CONTENT_TYPE"]      = ct.dup if ct
-      meta["GATEWAY_INTERFACE"] = "CGI/1.1"
-      meta["PATH_INFO"]         = @path_info ? @path_info.dup : ""
-     #meta["PATH_TRANSLATED"]   = nil      # no plan to be provided
-      meta["QUERY_STRING"]      = @query_string ? @query_string.dup : ""
-      meta["REMOTE_ADDR"]       = @peeraddr[3]
-      meta["REMOTE_HOST"]       = @peeraddr[2]
-     #meta["REMOTE_IDENT"]      = nil      # no plan to be provided
-      meta["REMOTE_USER"]       = @user
-      meta["REQUEST_METHOD"]    = @request_method.dup
-      meta["REQUEST_URI"]       = @request_uri.to_s
-      meta["SCRIPT_NAME"]       = @script_name.dup
-      meta["SERVER_NAME"]       = @host
-      meta["SERVER_PORT"]       = @port.to_s
-      meta["SERVER_PROTOCOL"]   = "HTTP/" + @config[:HTTPVersion].to_s
-      meta["SERVER_SOFTWARE"]   = @config[:ServerSoftware].dup
-
-      self.each{|key, val|
-        next if /^content-type$/i =~ key
-        next if /^content-length$/i =~ key
-        name = "HTTP_" + key
-        name.gsub!(/-/o, "_")
-        name.upcase!
-        meta[name] = val
-      }
-
-      meta
-    end
-
-    private
-
-    # :stopdoc:
-
-    MAX_URI_LENGTH = 2083 # :nodoc:
-
-    # same as Mongrel, Thin and Puma
-    MAX_HEADER_LENGTH = (112 * 1024) # :nodoc:
-
-    def read_request_line(socket)
-      @request_line = read_line(socket, MAX_URI_LENGTH) if socket
-      raise HTTPStatus::EOFError unless @request_line
-
-      @request_bytes = @request_line.bytesize
-      if @request_bytes >= MAX_URI_LENGTH and @request_line[-1, 1] != LF
-        raise HTTPStatus::RequestURITooLarge
-      end
-
-      @request_time = Time.now
-      if /^(\S+)\s+(\S++)(?:\s+HTTP\/(\d+\.\d+))?\r?\n/mo =~ @request_line
-        @request_method = $1
-        @unparsed_uri   = $2
-        @http_version   = HTTPVersion.new($3 ? $3 : "0.9")
-      else
-        rl = @request_line.sub(/\x0d?\x0a\z/o, '')
-        raise HTTPStatus::BadRequest, "bad Request-Line `#{rl}'."
-      end
-    end
-
-    def read_header(socket)
-      if socket
-        while line = read_line(socket)
-          break if /\A(#{CRLF}|#{LF})\z/om =~ line
-          if (@request_bytes += line.bytesize) > MAX_HEADER_LENGTH
-            raise HTTPStatus::RequestEntityTooLarge, 'headers too large'
-          end
-          @raw_header << line
-        end
-      end
-      @header = HTTPUtils::parse_header(@raw_header.join)
-    end
-
-    def parse_uri(str, scheme="http")
-      if @config[:Escape8bitURI]
-        str = HTTPUtils::escape8bit(str)
-      end
-      str.sub!(%r{\A/+}o, '/')
-      uri = URI::parse(str)
-      return uri if uri.absolute?
-      if @forwarded_host
-        host, port = @forwarded_host, @forwarded_port
-      elsif self["host"]
-        pattern = /\A(#{URI::REGEXP::PATTERN::HOST})(?::(\d+))?\z/n
-        host, port = *self['host'].scan(pattern)[0]
-      elsif @addr.size > 0
-        host, port = @addr[2], @addr[1]
-      else
-        host, port = @config[:ServerName], @config[:Port]
-      end
-      uri.scheme = @forwarded_proto || scheme
-      uri.host = host
-      uri.port = port ? port.to_i : nil
-      return URI::parse(uri.to_s)
-    end
-
-    def read_body(socket, block)
-      return unless socket
-      if tc = self['transfer-encoding']
-        case tc
-        when /\Achunked\z/io then read_chunked(socket, block)
-        else raise HTTPStatus::NotImplemented, "Transfer-Encoding: #{tc}."
-        end
-      elsif self['content-length'] || @remaining_size
-        @remaining_size ||= self['content-length'].to_i
-        while @remaining_size > 0
-          sz = [@buffer_size, @remaining_size].min
-          break unless buf = read_data(socket, sz)
-          @remaining_size -= buf.bytesize
-          block.call(buf)
-        end
-        if @remaining_size > 0 && @socket.eof?
-          raise HTTPStatus::BadRequest, "invalid body size."
-        end
-      elsif BODY_CONTAINABLE_METHODS.member?(@request_method) && !@socket.eof
-        raise HTTPStatus::LengthRequired
-      end
-      return @body
-    end
-
-    def read_chunk_size(socket)
-      line = read_line(socket)
-      if /^([0-9a-fA-F]+)(?:;(\S+))?/ =~ line
-        chunk_size = $1.hex
-        chunk_ext = $2
-        [ chunk_size, chunk_ext ]
-      else
-        raise HTTPStatus::BadRequest, "bad chunk `#{line}'."
-      end
-    end
-
-    def read_chunked(socket, block)
-      chunk_size, = read_chunk_size(socket)
-      while chunk_size > 0
-        begin
-          sz = [ chunk_size, @buffer_size ].min
-          data = read_data(socket, sz) # read chunk-data
-          if data.nil? || data.bytesize != sz
-            raise HTTPStatus::BadRequest, "bad chunk data size."
-          end
-          block.call(data)
-        end while (chunk_size -= sz) > 0
-
-        read_line(socket)                    # skip CRLF
-        chunk_size, = read_chunk_size(socket)
-      end
-      read_header(socket)                    # trailer + CRLF
-      @header.delete("transfer-encoding")
-      @remaining_size = 0
-    end
-
-    def _read_data(io, method, *arg)
-      begin
-        WEBrick::Utils.timeout(@config[:RequestTimeout]){
-          return io.__send__(method, *arg)
-        }
-      rescue Errno::ECONNRESET
-        return nil
-      rescue Timeout::Error
-        raise HTTPStatus::RequestTimeout
-      end
-    end
-
-    def read_line(io, size=4096)
-      _read_data(io, :gets, LF, size)
-    end
-
-    def read_data(io, size)
-      _read_data(io, :read, size)
-    end
-
-    def parse_query()
-      begin
-        if @request_method == "GET" || @request_method == "HEAD"
-          @query = HTTPUtils::parse_query(@query_string)
-        elsif self['content-type'] =~ /^application\/x-www-form-urlencoded/
-          @query = HTTPUtils::parse_query(body)
-        elsif self['content-type'] =~ /^multipart\/form-data; boundary=(.+)/
-          boundary = HTTPUtils::dequote($1)
-          @query = HTTPUtils::parse_form_data(body, boundary)
-        else
-          @query = Hash.new
-        end
-      rescue => ex
-        raise HTTPStatus::BadRequest, ex.message
-      end
-    end
-
-    PrivateNetworkRegexp = /
-      ^unknown$|
-      ^((::ffff:)?127.0.0.1|::1)$|
-      ^(::ffff:)?(10|172\.(1[6-9]|2[0-9]|3[01])|192\.168)\.
-    /ixo
-
-    # It's said that all X-Forwarded-* headers will contain more than one
-    # (comma-separated) value if the original request already contained one of
-    # these headers. Since we could use these values as Host header, we choose
-    # the initial(first) value. (apr_table_mergen() adds new value after the
-    # existing value with ", " prefix)
-    def setup_forwarded_info
-      if @forwarded_server = self["x-forwarded-server"]
-        @forwarded_server = @forwarded_server.split(",", 2).first
-      end
-      if @forwarded_proto = self["x-forwarded-proto"]
-        @forwarded_proto = @forwarded_proto.split(",", 2).first
-      end
-      if host_port = self["x-forwarded-host"]
-        host_port = host_port.split(",", 2).first
-        if host_port =~ /\A(\[[0-9a-fA-F:]+\])(?::(\d+))?\z/
-          @forwarded_host = $1
-          tmp = $2
-        else
-          @forwarded_host, tmp = host_port.split(":", 2)
-        end
-        @forwarded_port = (tmp || (@forwarded_proto == "https" ? 443 : 80)).to_i
-      end
-      if addrs = self["x-forwarded-for"]
-        addrs = addrs.split(",").collect(&:strip)
-        addrs.reject!{|ip| PrivateNetworkRegexp =~ ip }
-        @forwarded_for = addrs.first
-      end
-    end
-
-    # :startdoc:
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpresponse.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpresponse.rb
deleted file mode 100644
index ba4494ab748af..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpresponse.rb
+++ /dev/null
@@ -1,564 +0,0 @@
-# frozen_string_literal: false
-#
-# httpresponse.rb -- HTTPResponse Class
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: httpresponse.rb,v 1.45 2003/07/11 11:02:25 gotoyuzo Exp $
-
-require 'time'
-require 'uri'
-require_relative 'httpversion'
-require_relative 'htmlutils'
-require_relative 'httputils'
-require_relative 'httpstatus'
-
-module WEBrick
-  ##
-  # An HTTP response.  This is filled in by the service or do_* methods of a
-  # WEBrick HTTP Servlet.
-
-  class HTTPResponse
-    class InvalidHeader < StandardError
-    end
-
-    ##
-    # HTTP Response version
-
-    attr_reader :http_version
-
-    ##
-    # Response status code (200)
-
-    attr_reader :status
-
-    ##
-    # Response header
-
-    attr_reader :header
-
-    ##
-    # Response cookies
-
-    attr_reader :cookies
-
-    ##
-    # Response reason phrase ("OK")
-
-    attr_accessor :reason_phrase
-
-    ##
-    # Body may be:
-    # * a String;
-    # * an IO-like object that responds to +#read+ and +#readpartial+;
-    # * a Proc-like object that responds to +#call+.
-    #
-    # In the latter case, either #chunked= should be set to +true+,
-    # or <code>header['content-length']</code> explicitly provided.
-    # Example:
-    #
-    #   server.mount_proc '/' do |req, res|
-    #     res.chunked = true
-    #     # or
-    #     # res.header['content-length'] = 10
-    #     res.body = proc { |out| out.write(Time.now.to_s) }
-    #   end
-
-    attr_accessor :body
-
-    ##
-    # Request method for this response
-
-    attr_accessor :request_method
-
-    ##
-    # Request URI for this response
-
-    attr_accessor :request_uri
-
-    ##
-    # Request HTTP version for this response
-
-    attr_accessor :request_http_version
-
-    ##
-    # Filename of the static file in this response.  Only used by the
-    # FileHandler servlet.
-
-    attr_accessor :filename
-
-    ##
-    # Is this a keep-alive response?
-
-    attr_accessor :keep_alive
-
-    ##
-    # Configuration for this response
-
-    attr_reader :config
-
-    ##
-    # Bytes sent in this response
-
-    attr_reader :sent_size
-
-    ##
-    # Creates a new HTTP response object.  WEBrick::Config::HTTP is the
-    # default configuration.
-
-    def initialize(config)
-      @config = config
-      @buffer_size = config[:OutputBufferSize]
-      @logger = config[:Logger]
-      @header = Hash.new
-      @status = HTTPStatus::RC_OK
-      @reason_phrase = nil
-      @http_version = HTTPVersion::convert(@config[:HTTPVersion])
-      @body = ''
-      @keep_alive = true
-      @cookies = []
-      @request_method = nil
-      @request_uri = nil
-      @request_http_version = @http_version  # temporary
-      @chunked = false
-      @filename = nil
-      @sent_size = 0
-      @bodytempfile = nil
-    end
-
-    ##
-    # The response's HTTP status line
-
-    def status_line
-      "HTTP/#@http_version #@status #@reason_phrase".rstrip << CRLF
-    end
-
-    ##
-    # Sets the response's status to the +status+ code
-
-    def status=(status)
-      @status = status
-      @reason_phrase = HTTPStatus::reason_phrase(status)
-    end
-
-    ##
-    # Retrieves the response header +field+
-
-    def [](field)
-      @header[field.downcase]
-    end
-
-    ##
-    # Sets the response header +field+ to +value+
-
-    def []=(field, value)
-      @chunked = value.to_s.downcase == 'chunked' if field.downcase == 'transfer-encoding'
-      @header[field.downcase] = value.to_s
-    end
-
-    ##
-    # The content-length header
-
-    def content_length
-      if len = self['content-length']
-        return Integer(len)
-      end
-    end
-
-    ##
-    # Sets the content-length header to +len+
-
-    def content_length=(len)
-      self['content-length'] = len.to_s
-    end
-
-    ##
-    # The content-type header
-
-    def content_type
-      self['content-type']
-    end
-
-    ##
-    # Sets the content-type header to +type+
-
-    def content_type=(type)
-      self['content-type'] = type
-    end
-
-    ##
-    # Iterates over each header in the response
-
-    def each
-      @header.each{|field, value|  yield(field, value) }
-    end
-
-    ##
-    # Will this response body be returned using chunked transfer-encoding?
-
-    def chunked?
-      @chunked
-    end
-
-    ##
-    # Enables chunked transfer encoding.
-
-    def chunked=(val)
-      @chunked = val ? true : false
-    end
-
-    ##
-    # Will this response's connection be kept alive?
-
-    def keep_alive?
-      @keep_alive
-    end
-
-    ##
-    # Sends the response on +socket+
-
-    def send_response(socket) # :nodoc:
-      begin
-        setup_header()
-        send_header(socket)
-        send_body(socket)
-      rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ENOTCONN => ex
-        @logger.debug(ex)
-        @keep_alive = false
-      rescue Exception => ex
-        @logger.error(ex)
-        @keep_alive = false
-      end
-    end
-
-    ##
-    # Sets up the headers for sending
-
-    def setup_header() # :nodoc:
-      @reason_phrase    ||= HTTPStatus::reason_phrase(@status)
-      @header['server'] ||= @config[:ServerSoftware]
-      @header['date']   ||= Time.now.httpdate
-
-      # HTTP/0.9 features
-      if @request_http_version < "1.0"
-        @http_version = HTTPVersion.new("0.9")
-        @keep_alive = false
-      end
-
-      # HTTP/1.0 features
-      if @request_http_version < "1.1"
-        if chunked?
-          @chunked = false
-          ver = @request_http_version.to_s
-          msg = "chunked is set for an HTTP/#{ver} request. (ignored)"
-          @logger.warn(msg)
-        end
-      end
-
-      # Determine the message length (RFC2616 -- 4.4 Message Length)
-      if @status == 304 || @status == 204 || HTTPStatus::info?(@status)
-        @header.delete('content-length')
-        @body = ""
-      elsif chunked?
-        @header["transfer-encoding"] = "chunked"
-        @header.delete('content-length')
-      elsif %r{^multipart/byteranges} =~ @header['content-type']
-        @header.delete('content-length')
-      elsif @header['content-length'].nil?
-        if @body.respond_to? :readpartial
-        elsif @body.respond_to? :call
-          make_body_tempfile
-        else
-          @header['content-length'] = (@body ? @body.bytesize : 0).to_s
-        end
-      end
-
-      # Keep-Alive connection.
-      if @header['connection'] == "close"
-         @keep_alive = false
-      elsif keep_alive?
-        if chunked? || @header['content-length'] || @status == 304 || @status == 204 || HTTPStatus.info?(@status)
-          @header['connection'] = "Keep-Alive"
-        else
-          msg = "Could not determine content-length of response body. Set content-length of the response or set Response#chunked = true"
-          @logger.warn(msg)
-          @header['connection'] = "close"
-          @keep_alive = false
-        end
-      else
-        @header['connection'] = "close"
-      end
-
-      # Location is a single absoluteURI.
-      if location = @header['location']
-        if @request_uri
-          @header['location'] = @request_uri.merge(location).to_s
-        end
-      end
-    end
-
-    def make_body_tempfile # :nodoc:
-      return if @bodytempfile
-      bodytempfile = Tempfile.create("webrick")
-      if @body.nil?
-        # nothing
-      elsif @body.respond_to? :readpartial
-        IO.copy_stream(@body, bodytempfile)
-        @body.close
-      elsif @body.respond_to? :call
-        @body.call(bodytempfile)
-      else
-        bodytempfile.write @body
-      end
-      bodytempfile.rewind
-      @body = @bodytempfile = bodytempfile
-      @header['content-length'] = bodytempfile.stat.size.to_s
-    end
-
-    def remove_body_tempfile # :nodoc:
-      if @bodytempfile
-        @bodytempfile.close
-        File.unlink @bodytempfile.path
-        @bodytempfile = nil
-      end
-    end
-
-
-    ##
-    # Sends the headers on +socket+
-
-    def send_header(socket) # :nodoc:
-      if @http_version.major > 0
-        data = status_line()
-        @header.each{|key, value|
-          tmp = key.gsub(/\bwww|^te$|\b\w/){ $&.upcase }
-          data << "#{tmp}: #{check_header(value)}" << CRLF
-        }
-        @cookies.each{|cookie|
-          data << "Set-Cookie: " << check_header(cookie.to_s) << CRLF
-        }
-        data << CRLF
-        socket.write(data)
-      end
-    rescue InvalidHeader => e
-      @header.clear
-      @cookies.clear
-      set_error e
-      retry
-    end
-
-    ##
-    # Sends the body on +socket+
-
-    def send_body(socket) # :nodoc:
-      if @body.respond_to? :readpartial then
-        send_body_io(socket)
-      elsif @body.respond_to?(:call) then
-        send_body_proc(socket)
-      else
-        send_body_string(socket)
-      end
-    end
-
-    ##
-    # Redirects to +url+ with a WEBrick::HTTPStatus::Redirect +status+.
-    #
-    # Example:
-    #
-    #   res.set_redirect WEBrick::HTTPStatus::TemporaryRedirect
-
-    def set_redirect(status, url)
-      url = URI(url).to_s
-      @body = "<HTML><A HREF=\"#{url}\">#{url}</A>.</HTML>\n"
-      @header['location'] = url
-      raise status
-    end
-
-    ##
-    # Creates an error page for exception +ex+ with an optional +backtrace+
-
-    def set_error(ex, backtrace=false)
-      case ex
-      when HTTPStatus::Status
-        @keep_alive = false if HTTPStatus::error?(ex.code)
-        self.status = ex.code
-      else
-        @keep_alive = false
-        self.status = HTTPStatus::RC_INTERNAL_SERVER_ERROR
-      end
-      @header['content-type'] = "text/html; charset=ISO-8859-1"
-
-      if respond_to?(:create_error_page)
-        create_error_page()
-        return
-      end
-
-      if @request_uri
-        host, port = @request_uri.host, @request_uri.port
-      else
-        host, port = @config[:ServerName], @config[:Port]
-      end
-
-      error_body(backtrace, ex, host, port)
-    end
-
-    private
-
-    def check_header(header_value)
-      header_value = header_value.to_s
-      if /[\r\n]/ =~ header_value
-        raise InvalidHeader
-      else
-        header_value
-      end
-    end
-
-    # :stopdoc:
-
-    def error_body(backtrace, ex, host, port)
-      @body = ''
-      @body << <<-_end_of_html_
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
-<HTML>
-  <HEAD><TITLE>#{HTMLUtils::escape(@reason_phrase)}</TITLE></HEAD>
-  <BODY>
-    <H1>#{HTMLUtils::escape(@reason_phrase)}</H1>
-    #{HTMLUtils::escape(ex.message)}
-    <HR>
-      _end_of_html_
-
-      if backtrace && $DEBUG
-        @body << "backtrace of `#{HTMLUtils::escape(ex.class.to_s)}' "
-        @body << "#{HTMLUtils::escape(ex.message)}"
-        @body << "<PRE>"
-        ex.backtrace.each{|line| @body << "\t#{line}\n"}
-        @body << "</PRE><HR>"
-      end
-
-      @body << <<-_end_of_html_
-    <ADDRESS>
-     #{HTMLUtils::escape(@config[:ServerSoftware])} at
-     #{host}:#{port}
-    </ADDRESS>
-  </BODY>
-</HTML>
-      _end_of_html_
-    end
-
-    def send_body_io(socket)
-      begin
-        if @request_method == "HEAD"
-          # do nothing
-        elsif chunked?
-          buf  = ''
-          begin
-            @body.readpartial(@buffer_size, buf)
-            size = buf.bytesize
-            data = "#{size.to_s(16)}#{CRLF}#{buf}#{CRLF}"
-            socket.write(data)
-            data.clear
-            @sent_size += size
-          rescue EOFError
-            break
-          end while true
-          buf.clear
-          socket.write("0#{CRLF}#{CRLF}")
-        else
-          if %r{\Abytes (\d+)-(\d+)/\d+\z} =~ @header['content-range']
-            offset = $1.to_i
-            size = $2.to_i - offset + 1
-          else
-            offset = nil
-            size = @header['content-length']
-            size = size.to_i if size
-          end
-          begin
-            @sent_size = IO.copy_stream(@body, socket, size, offset)
-          rescue NotImplementedError
-            @body.seek(offset, IO::SEEK_SET)
-            @sent_size = IO.copy_stream(@body, socket, size)
-          end
-        end
-      ensure
-        @body.close
-      end
-      remove_body_tempfile
-    end
-
-    def send_body_string(socket)
-      if @request_method == "HEAD"
-        # do nothing
-      elsif chunked?
-        body ? @body.bytesize : 0
-        while buf = @body[@sent_size, @buffer_size]
-          break if buf.empty?
-          size = buf.bytesize
-          data = "#{size.to_s(16)}#{CRLF}#{buf}#{CRLF}"
-          buf.clear
-          socket.write(data)
-          @sent_size += size
-        end
-        socket.write("0#{CRLF}#{CRLF}")
-      else
-        if @body && @body.bytesize > 0
-          socket.write(@body)
-          @sent_size = @body.bytesize
-        end
-      end
-    end
-
-    def send_body_proc(socket)
-      if @request_method == "HEAD"
-        # do nothing
-      elsif chunked?
-        @body.call(ChunkedWrapper.new(socket, self))
-        socket.write("0#{CRLF}#{CRLF}")
-      else
-        size = @header['content-length'].to_i
-        if @bodytempfile
-          @bodytempfile.rewind
-          IO.copy_stream(@bodytempfile, socket)
-        else
-          @body.call(socket)
-        end
-        @sent_size = size
-      end
-    end
-
-    class ChunkedWrapper
-      def initialize(socket, resp)
-        @socket = socket
-        @resp = resp
-      end
-
-      def write(buf)
-        return 0 if buf.empty?
-        socket = @socket
-        @resp.instance_eval {
-          size = buf.bytesize
-          data = "#{size.to_s(16)}#{CRLF}#{buf}#{CRLF}"
-          socket.write(data)
-          data.clear
-          @sent_size += size
-          size
-        }
-      end
-
-      def <<(*buf)
-        write(buf)
-        self
-      end
-    end
-
-    # preserved for compatibility with some 3rd-party handlers
-    def _write_data(socket, data)
-      socket << data
-    end
-
-    # :startdoc:
-  end
-
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/https.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/https.rb
deleted file mode 100644
index b0a49bc40bae0..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/https.rb
+++ /dev/null
@@ -1,152 +0,0 @@
-# frozen_string_literal: false
-#
-# https.rb -- SSL/TLS enhancement for HTTPServer
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2001 GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: https.rb,v 1.15 2003/07/22 19:20:42 gotoyuzo Exp $
-
-require_relative 'ssl'
-require_relative 'httpserver'
-
-module WEBrick
-  module Config
-    HTTP.update(SSL)
-  end
-
-  ##
-  #--
-  # Adds SSL functionality to WEBrick::HTTPRequest
-
-  class HTTPRequest
-
-    ##
-    # HTTP request SSL cipher
-
-    attr_reader :cipher
-
-    ##
-    # HTTP request server certificate
-
-    attr_reader :server_cert
-
-    ##
-    # HTTP request client certificate
-
-    attr_reader :client_cert
-
-    # :stopdoc:
-
-    alias orig_parse parse
-
-    def parse(socket=nil)
-      if socket.respond_to?(:cert)
-        @server_cert = socket.cert || @config[:SSLCertificate]
-        @client_cert = socket.peer_cert
-        @client_cert_chain = socket.peer_cert_chain
-        @cipher      = socket.cipher
-      end
-      orig_parse(socket)
-    end
-
-    alias orig_parse_uri parse_uri
-
-    def parse_uri(str, scheme="https")
-      if server_cert
-        return orig_parse_uri(str, scheme)
-      end
-      return orig_parse_uri(str)
-    end
-    private :parse_uri
-
-    alias orig_meta_vars meta_vars
-
-    def meta_vars
-      meta = orig_meta_vars
-      if server_cert
-        meta["HTTPS"] = "on"
-        meta["SSL_SERVER_CERT"] = @server_cert.to_pem
-        meta["SSL_CLIENT_CERT"] = @client_cert ? @client_cert.to_pem : ""
-        if @client_cert_chain
-          @client_cert_chain.each_with_index{|cert, i|
-            meta["SSL_CLIENT_CERT_CHAIN_#{i}"] = cert.to_pem
-          }
-        end
-        meta["SSL_CIPHER"] = @cipher[0]
-        meta["SSL_PROTOCOL"] = @cipher[1]
-        meta["SSL_CIPHER_USEKEYSIZE"] = @cipher[2].to_s
-        meta["SSL_CIPHER_ALGKEYSIZE"] = @cipher[3].to_s
-      end
-      meta
-    end
-
-    # :startdoc:
-  end
-
-  ##
-  #--
-  # Fake WEBrick::HTTPRequest for lookup_server
-
-  class SNIRequest
-
-    ##
-    # The SNI hostname
-
-    attr_reader :host
-
-    ##
-    # The socket address of the server
-
-    attr_reader :addr
-
-    ##
-    # The port this request is for
-
-    attr_reader :port
-
-    ##
-    # Creates a new SNIRequest.
-
-    def initialize(sslsocket, hostname)
-      @host = hostname
-      @addr = sslsocket.addr
-      @port = @addr[1]
-    end
-  end
-
-
-  ##
-  #--
-  # Adds SSL functionality to WEBrick::HTTPServer
-
-  class HTTPServer < ::WEBrick::GenericServer
-    ##
-    # ServerNameIndication callback
-
-    def ssl_servername_callback(sslsocket, hostname = nil)
-      req = SNIRequest.new(sslsocket, hostname)
-      server = lookup_server(req)
-      server ? server.ssl_context : nil
-    end
-
-    # :stopdoc:
-
-    ##
-    # Check whether +server+ is also SSL server.
-    # Also +server+'s SSL context will be created.
-
-    alias orig_virtual_host virtual_host
-
-    def virtual_host(server)
-      if @config[:SSLEnable] && !server.ssl_context
-        raise ArgumentError, "virtual host must set SSLEnable to true"
-      end
-      orig_virtual_host(server)
-    end
-
-    # :startdoc:
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpserver.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpserver.rb
deleted file mode 100644
index e85d059319011..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpserver.rb
+++ /dev/null
@@ -1,294 +0,0 @@
-# frozen_string_literal: false
-#
-# httpserver.rb -- HTTPServer Class
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: httpserver.rb,v 1.63 2002/10/01 17:16:32 gotoyuzo Exp $
-
-require 'io/wait'
-require_relative 'server'
-require_relative 'httputils'
-require_relative 'httpstatus'
-require_relative 'httprequest'
-require_relative 'httpresponse'
-require_relative 'httpservlet'
-require_relative 'accesslog'
-
-module WEBrick
-  class HTTPServerError < ServerError; end
-
-  ##
-  # An HTTP Server
-
-  class HTTPServer < ::WEBrick::GenericServer
-    ##
-    # Creates a new HTTP server according to +config+
-    #
-    # An HTTP server uses the following attributes:
-    #
-    # :AccessLog:: An array of access logs.  See WEBrick::AccessLog
-    # :BindAddress:: Local address for the server to bind to
-    # :DocumentRoot:: Root path to serve files from
-    # :DocumentRootOptions:: Options for the default HTTPServlet::FileHandler
-    # :HTTPVersion:: The HTTP version of this server
-    # :Port:: Port to listen on
-    # :RequestCallback:: Called with a request and response before each
-    #                    request is serviced.
-    # :RequestTimeout:: Maximum time to wait between requests
-    # :ServerAlias:: Array of alternate names for this server for virtual
-    #                hosting
-    # :ServerName:: Name for this server for virtual hosting
-
-    def initialize(config={}, default=Config::HTTP)
-      super(config, default)
-      @http_version = HTTPVersion::convert(@config[:HTTPVersion])
-
-      @mount_tab = MountTable.new
-      if @config[:DocumentRoot]
-        mount("/", HTTPServlet::FileHandler, @config[:DocumentRoot],
-              @config[:DocumentRootOptions])
-      end
-
-      unless @config[:AccessLog]
-        @config[:AccessLog] = [
-          [ $stderr, AccessLog::COMMON_LOG_FORMAT ],
-          [ $stderr, AccessLog::REFERER_LOG_FORMAT ]
-        ]
-      end
-
-      @virtual_hosts = Array.new
-    end
-
-    ##
-    # Processes requests on +sock+
-
-    def run(sock)
-      while true
-        req = create_request(@config)
-        res = create_response(@config)
-        server = self
-        begin
-          timeout = @config[:RequestTimeout]
-          while timeout > 0
-            break if sock.to_io.wait_readable(0.5)
-            break if @status != :Running
-            timeout -= 0.5
-          end
-          raise HTTPStatus::EOFError if timeout <= 0 || @status != :Running
-          raise HTTPStatus::EOFError if sock.eof?
-          req.parse(sock)
-          res.request_method = req.request_method
-          res.request_uri = req.request_uri
-          res.request_http_version = req.http_version
-          res.keep_alive = req.keep_alive?
-          server = lookup_server(req) || self
-          if callback = server[:RequestCallback]
-            callback.call(req, res)
-          elsif callback = server[:RequestHandler]
-            msg = ":RequestHandler is deprecated, please use :RequestCallback"
-            @logger.warn(msg)
-            callback.call(req, res)
-          end
-          server.service(req, res)
-        rescue HTTPStatus::EOFError, HTTPStatus::RequestTimeout => ex
-          res.set_error(ex)
-        rescue HTTPStatus::Error => ex
-          @logger.error(ex.message)
-          res.set_error(ex)
-        rescue HTTPStatus::Status => ex
-          res.status = ex.code
-        rescue StandardError => ex
-          @logger.error(ex)
-          res.set_error(ex, true)
-        ensure
-          if req.request_line
-            if req.keep_alive? && res.keep_alive?
-              req.fixup()
-            end
-            res.send_response(sock)
-            server.access_log(@config, req, res)
-          end
-        end
-        break if @http_version < "1.1"
-        break unless req.keep_alive?
-        break unless res.keep_alive?
-      end
-    end
-
-    ##
-    # Services +req+ and fills in +res+
-
-    def service(req, res)
-      if req.unparsed_uri == "*"
-        if req.request_method == "OPTIONS"
-          do_OPTIONS(req, res)
-          raise HTTPStatus::OK
-        end
-        raise HTTPStatus::NotFound, "`#{req.unparsed_uri}' not found."
-      end
-
-      servlet, options, script_name, path_info = search_servlet(req.path)
-      raise HTTPStatus::NotFound, "`#{req.path}' not found." unless servlet
-      req.script_name = script_name
-      req.path_info = path_info
-      si = servlet.get_instance(self, *options)
-      @logger.debug(format("%s is invoked.", si.class.name))
-      si.service(req, res)
-    end
-
-    ##
-    # The default OPTIONS request handler says GET, HEAD, POST and OPTIONS
-    # requests are allowed.
-
-    def do_OPTIONS(req, res)
-      res["allow"] = "GET,HEAD,POST,OPTIONS"
-    end
-
-    ##
-    # Mounts +servlet+ on +dir+ passing +options+ to the servlet at creation
-    # time
-
-    def mount(dir, servlet, *options)
-      @logger.debug(sprintf("%s is mounted on %s.", servlet.inspect, dir))
-      @mount_tab[dir] = [ servlet, options ]
-    end
-
-    ##
-    # Mounts +proc+ or +block+ on +dir+ and calls it with a
-    # WEBrick::HTTPRequest and WEBrick::HTTPResponse
-
-    def mount_proc(dir, proc=nil, &block)
-      proc ||= block
-      raise HTTPServerError, "must pass a proc or block" unless proc
-      mount(dir, HTTPServlet::ProcHandler.new(proc))
-    end
-
-    ##
-    # Unmounts +dir+
-
-    def unmount(dir)
-      @logger.debug(sprintf("unmount %s.", dir))
-      @mount_tab.delete(dir)
-    end
-    alias umount unmount
-
-    ##
-    # Finds a servlet for +path+
-
-    def search_servlet(path)
-      script_name, path_info = @mount_tab.scan(path)
-      servlet, options = @mount_tab[script_name]
-      if servlet
-        [ servlet, options, script_name, path_info ]
-      end
-    end
-
-    ##
-    # Adds +server+ as a virtual host.
-
-    def virtual_host(server)
-      @virtual_hosts << server
-      @virtual_hosts = @virtual_hosts.sort_by{|s|
-        num = 0
-        num -= 4 if s[:BindAddress]
-        num -= 2 if s[:Port]
-        num -= 1 if s[:ServerName]
-        num
-      }
-    end
-
-    ##
-    # Finds the appropriate virtual host to handle +req+
-
-    def lookup_server(req)
-      @virtual_hosts.find{|s|
-        (s[:BindAddress].nil? || req.addr[3] == s[:BindAddress]) &&
-        (s[:Port].nil?        || req.port == s[:Port])           &&
-        ((s[:ServerName].nil?  || req.host == s[:ServerName]) ||
-         (!s[:ServerAlias].nil? && s[:ServerAlias].find{|h| h === req.host}))
-      }
-    end
-
-    ##
-    # Logs +req+ and +res+ in the access logs.  +config+ is used for the
-    # server name.
-
-    def access_log(config, req, res)
-      param = AccessLog::setup_params(config, req, res)
-      @config[:AccessLog].each{|logger, fmt|
-        logger << AccessLog::format(fmt+"\n", param)
-      }
-    end
-
-    ##
-    # Creates the HTTPRequest used when handling the HTTP
-    # request. Can be overridden by subclasses.
-    def create_request(with_webrick_config)
-      HTTPRequest.new(with_webrick_config)
-    end
-
-    ##
-    # Creates the HTTPResponse used when handling the HTTP
-    # request. Can be overridden by subclasses.
-    def create_response(with_webrick_config)
-      HTTPResponse.new(with_webrick_config)
-    end
-
-    ##
-    # Mount table for the path a servlet is mounted on in the directory space
-    # of the server.  Users of WEBrick can only access this indirectly via
-    # WEBrick::HTTPServer#mount, WEBrick::HTTPServer#unmount and
-    # WEBrick::HTTPServer#search_servlet
-
-    class MountTable # :nodoc:
-      def initialize
-        @tab = Hash.new
-        compile
-      end
-
-      def [](dir)
-        dir = normalize(dir)
-        @tab[dir]
-      end
-
-      def []=(dir, val)
-        dir = normalize(dir)
-        @tab[dir] = val
-        compile
-        val
-      end
-
-      def delete(dir)
-        dir = normalize(dir)
-        res = @tab.delete(dir)
-        compile
-        res
-      end
-
-      def scan(path)
-        @scanner =~ path
-        [ $&, $' ]
-      end
-
-      private
-
-      def compile
-        k = @tab.keys
-        k.sort!
-        k.reverse!
-        k.collect!{|path| Regexp.escape(path) }
-        @scanner = Regexp.new("\\A(" + k.join("|") +")(?=/|\\z)")
-      end
-
-      def normalize(dir)
-        ret = dir ? dir.dup : ""
-        ret.sub!(%r|/+\z|, "")
-        ret
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet.rb
deleted file mode 100644
index da49a1405b3af..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-# frozen_string_literal: false
-#
-# httpservlet.rb -- HTTPServlet Utility File
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: httpservlet.rb,v 1.21 2003/02/23 12:24:46 gotoyuzo Exp $
-
-require_relative 'httpservlet/abstract'
-require_relative 'httpservlet/filehandler'
-require_relative 'httpservlet/cgihandler'
-require_relative 'httpservlet/erbhandler'
-require_relative 'httpservlet/prochandler'
-
-module WEBrick
-  module HTTPServlet
-    FileHandler.add_handler("cgi", CGIHandler)
-    FileHandler.add_handler("rhtml", ERBHandler)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/abstract.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/abstract.rb
deleted file mode 100644
index bccb091861d7f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/abstract.rb
+++ /dev/null
@@ -1,152 +0,0 @@
-# frozen_string_literal: false
-#
-# httpservlet.rb -- HTTPServlet Module
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: abstract.rb,v 1.24 2003/07/11 11:16:46 gotoyuzo Exp $
-
-require_relative '../htmlutils'
-require_relative '../httputils'
-require_relative '../httpstatus'
-
-module WEBrick
-  module HTTPServlet
-    class HTTPServletError < StandardError; end
-
-    ##
-    # AbstractServlet allows HTTP server modules to be reused across multiple
-    # servers and allows encapsulation of functionality.
-    #
-    # By default a servlet will respond to GET, HEAD (through an alias to GET)
-    # and OPTIONS requests.
-    #
-    # By default a new servlet is initialized for every request.  A servlet
-    # instance can be reused by overriding ::get_instance in the
-    # AbstractServlet subclass.
-    #
-    # == A Simple Servlet
-    #
-    #  class Simple < WEBrick::HTTPServlet::AbstractServlet
-    #    def do_GET request, response
-    #      status, content_type, body = do_stuff_with request
-    #
-    #      response.status = status
-    #      response['Content-Type'] = content_type
-    #      response.body = body
-    #    end
-    #
-    #    def do_stuff_with request
-    #      return 200, 'text/plain', 'you got a page'
-    #    end
-    #  end
-    #
-    # This servlet can be mounted on a server at a given path:
-    #
-    #   server.mount '/simple', Simple
-    #
-    # == Servlet Configuration
-    #
-    # Servlets can be configured via initialize.  The first argument is the
-    # HTTP server the servlet is being initialized for.
-    #
-    #  class Configurable < Simple
-    #    def initialize server, color, size
-    #      super server
-    #      @color = color
-    #      @size = size
-    #    end
-    #
-    #    def do_stuff_with request
-    #      content = "<p " \
-    #                %q{style="color: #{@color}; font-size: #{@size}"} \
-    #                ">Hello, World!"
-    #
-    #      return 200, "text/html", content
-    #    end
-    #  end
-    #
-    # This servlet must be provided two arguments at mount time:
-    #
-    #   server.mount '/configurable', Configurable, 'red', '2em'
-
-    class AbstractServlet
-
-      ##
-      # Factory for servlet instances that will handle a request from +server+
-      # using +options+ from the mount point.  By default a new servlet
-      # instance is created for every call.
-
-      def self.get_instance(server, *options)
-        self.new(server, *options)
-      end
-
-      ##
-      # Initializes a new servlet for +server+ using +options+ which are
-      # stored as-is in +@options+.  +@logger+ is also provided.
-
-      def initialize(server, *options)
-        @server = @config = server
-        @logger = @server[:Logger]
-        @options = options
-      end
-
-      ##
-      # Dispatches to a +do_+ method based on +req+ if such a method is
-      # available.  (+do_GET+ for a GET request).  Raises a MethodNotAllowed
-      # exception if the method is not implemented.
-
-      def service(req, res)
-        method_name = "do_" + req.request_method.gsub(/-/, "_")
-        if respond_to?(method_name)
-          __send__(method_name, req, res)
-        else
-          raise HTTPStatus::MethodNotAllowed,
-                "unsupported method `#{req.request_method}'."
-        end
-      end
-
-      ##
-      # Raises a NotFound exception
-
-      def do_GET(req, res)
-        raise HTTPStatus::NotFound, "not found."
-      end
-
-      ##
-      # Dispatches to do_GET
-
-      def do_HEAD(req, res)
-        do_GET(req, res)
-      end
-
-      ##
-      # Returns the allowed HTTP request methods
-
-      def do_OPTIONS(req, res)
-        m = self.methods.grep(/\Ado_([A-Z]+)\z/) {$1}
-        m.sort!
-        res["allow"] = m.join(",")
-      end
-
-      private
-
-      ##
-      # Redirects to a path ending in /
-
-      def redirect_to_directory_uri(req, res)
-        if req.path[-1] != ?/
-          location = WEBrick::HTTPUtils.escape_path(req.path + "/")
-          if req.query_string && req.query_string.bytesize > 0
-            location << "?" << req.query_string
-          end
-          res.set_redirect(HTTPStatus::MovedPermanently, location)
-        end
-      end
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/cgi_runner.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/cgi_runner.rb
deleted file mode 100644
index 0398c16749c0c..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/cgi_runner.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# frozen_string_literal: false
-#
-# cgi_runner.rb -- CGI launcher.
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000 TAKAHASHI Masayoshi, GOTOU YUUZOU
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: cgi_runner.rb,v 1.9 2002/09/25 11:33:15 gotoyuzo Exp $
-
-def sysread(io, size)
-  buf = ""
-  while size > 0
-    tmp = io.sysread(size)
-    buf << tmp
-    size -= tmp.bytesize
-  end
-  return buf
-end
-
-STDIN.binmode
-
-len = sysread(STDIN, 8).to_i
-out = sysread(STDIN, len)
-STDOUT.reopen(File.open(out, "w"))
-
-len = sysread(STDIN, 8).to_i
-err = sysread(STDIN, len)
-STDERR.reopen(File.open(err, "w"))
-
-len  = sysread(STDIN, 8).to_i
-dump = sysread(STDIN, len)
-hash = Marshal.restore(dump)
-ENV.keys.each{|name| ENV.delete(name) }
-hash.each{|k, v| ENV[k] = v if v }
-
-dir = File::dirname(ENV["SCRIPT_FILENAME"])
-Dir::chdir dir
-
-if ARGV[0]
-  argv = ARGV.dup
-  argv << ENV["SCRIPT_FILENAME"]
-  exec(*argv)
-  # NOTREACHED
-end
-exec ENV["SCRIPT_FILENAME"]
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/cgihandler.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/cgihandler.rb
deleted file mode 100644
index 4457770b7a006..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/cgihandler.rb
+++ /dev/null
@@ -1,126 +0,0 @@
-# frozen_string_literal: false
-#
-# cgihandler.rb -- CGIHandler Class
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: cgihandler.rb,v 1.27 2003/03/21 19:56:01 gotoyuzo Exp $
-
-require 'rbconfig'
-require 'tempfile'
-require_relative '../config'
-require_relative 'abstract'
-
-module WEBrick
-  module HTTPServlet
-
-    ##
-    # Servlet for handling CGI scripts
-    #
-    # Example:
-    #
-    #  server.mount('/cgi/my_script', WEBrick::HTTPServlet::CGIHandler,
-    #               '/path/to/my_script')
-
-    class CGIHandler < AbstractServlet
-      Ruby = RbConfig.ruby # :nodoc:
-      CGIRunner = "\"#{Ruby}\" \"#{WEBrick::Config::LIBDIR}/httpservlet/cgi_runner.rb\"" # :nodoc:
-      CGIRunnerArray = [Ruby, "#{WEBrick::Config::LIBDIR}/httpservlet/cgi_runner.rb".freeze].freeze # :nodoc:
-
-      ##
-      # Creates a new CGI script servlet for the script at +name+
-
-      def initialize(server, name)
-        super(server, name)
-        @script_filename = name
-        @tempdir = server[:TempDir]
-        interpreter = server[:CGIInterpreter]
-        if interpreter.is_a?(Array)
-          @cgicmd = CGIRunnerArray + interpreter
-        else
-          @cgicmd = "#{CGIRunner} #{interpreter}"
-        end
-      end
-
-      # :stopdoc:
-
-      def do_GET(req, res)
-        cgi_in = IO::popen(@cgicmd, "wb")
-        cgi_out = Tempfile.new("webrick.cgiout.", @tempdir, mode: IO::BINARY)
-        cgi_out.set_encoding("ASCII-8BIT")
-        cgi_err = Tempfile.new("webrick.cgierr.", @tempdir, mode: IO::BINARY)
-        cgi_err.set_encoding("ASCII-8BIT")
-        begin
-          cgi_in.sync = true
-          meta = req.meta_vars
-          meta["SCRIPT_FILENAME"] = @script_filename
-          meta["PATH"] = @config[:CGIPathEnv]
-          meta.delete("HTTP_PROXY")
-          if /mswin|bccwin|mingw/ =~ RUBY_PLATFORM
-            meta["SystemRoot"] = ENV["SystemRoot"]
-          end
-          dump = Marshal.dump(meta)
-
-          cgi_in.write("%8d" % cgi_out.path.bytesize)
-          cgi_in.write(cgi_out.path)
-          cgi_in.write("%8d" % cgi_err.path.bytesize)
-          cgi_in.write(cgi_err.path)
-          cgi_in.write("%8d" % dump.bytesize)
-          cgi_in.write(dump)
-
-          req.body { |chunk| cgi_in.write(chunk) }
-        ensure
-          cgi_in.close
-          status = $?.exitstatus
-          sleep 0.1 if /mswin|bccwin|mingw/ =~ RUBY_PLATFORM
-          data = cgi_out.read
-          cgi_out.close(true)
-          if errmsg = cgi_err.read
-            if errmsg.bytesize > 0
-              @logger.error("CGIHandler: #{@script_filename}:\n" + errmsg)
-            end
-          end
-          cgi_err.close(true)
-        end
-
-        if status != 0
-          @logger.error("CGIHandler: #{@script_filename} exit with #{status}")
-        end
-
-        data = "" unless data
-        raw_header, body = data.split(/^[\xd\xa]+/, 2)
-        raise HTTPStatus::InternalServerError,
-          "Premature end of script headers: #{@script_filename}" if body.nil?
-
-        begin
-          header = HTTPUtils::parse_header(raw_header)
-          if /^(\d+)/ =~ header['status'][0]
-            res.status = $1.to_i
-            header.delete('status')
-          end
-          if header.has_key?('location')
-            # RFC 3875 6.2.3, 6.2.4
-            res.status = 302 unless (300...400) === res.status
-          end
-          if header.has_key?('set-cookie')
-            header['set-cookie'].each{|k|
-              res.cookies << Cookie.parse_set_cookie(k)
-            }
-            header.delete('set-cookie')
-          end
-          header.each{|key, val| res[key] = val.join(", ") }
-        rescue => ex
-          raise HTTPStatus::InternalServerError, ex.message
-        end
-        res.body = body
-      end
-      alias do_POST do_GET
-
-      # :startdoc:
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/erbhandler.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/erbhandler.rb
deleted file mode 100644
index cd09e5f216154..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/erbhandler.rb
+++ /dev/null
@@ -1,88 +0,0 @@
-# frozen_string_literal: false
-#
-# erbhandler.rb -- ERBHandler Class
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: erbhandler.rb,v 1.25 2003/02/24 19:25:31 gotoyuzo Exp $
-
-require_relative 'abstract'
-
-require 'erb'
-
-module WEBrick
-  module HTTPServlet
-
-    ##
-    # ERBHandler evaluates an ERB file and returns the result.  This handler
-    # is automatically used if there are .rhtml files in a directory served by
-    # the FileHandler.
-    #
-    # ERBHandler supports GET and POST methods.
-    #
-    # The ERB file is evaluated with the local variables +servlet_request+ and
-    # +servlet_response+ which are a WEBrick::HTTPRequest and
-    # WEBrick::HTTPResponse respectively.
-    #
-    # Example .rhtml file:
-    #
-    #   Request to <%= servlet_request.request_uri %>
-    #
-    #   Query params <%= servlet_request.query.inspect %>
-
-    class ERBHandler < AbstractServlet
-
-      ##
-      # Creates a new ERBHandler on +server+ that will evaluate and serve the
-      # ERB file +name+
-
-      def initialize(server, name)
-        super(server, name)
-        @script_filename = name
-      end
-
-      ##
-      # Handles GET requests
-
-      def do_GET(req, res)
-        unless defined?(ERB)
-          @logger.warn "#{self.class}: ERB not defined."
-          raise HTTPStatus::Forbidden, "ERBHandler cannot work."
-        end
-        begin
-          data = File.open(@script_filename, &:read)
-          res.body = evaluate(ERB.new(data), req, res)
-          res['content-type'] ||=
-            HTTPUtils::mime_type(@script_filename, @config[:MimeTypes])
-        rescue StandardError
-          raise
-        rescue Exception => ex
-          @logger.error(ex)
-          raise HTTPStatus::InternalServerError, ex.message
-        end
-      end
-
-      ##
-      # Handles POST requests
-
-      alias do_POST do_GET
-
-      private
-
-      ##
-      # Evaluates +erb+ providing +servlet_request+ and +servlet_response+ as
-      # local variables.
-
-      def evaluate(erb, servlet_request, servlet_response)
-        Module.new.module_eval{
-          servlet_request.meta_vars
-          servlet_request.query
-          erb.result(binding)
-        }
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb
deleted file mode 100644
index 010df0e918d22..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb
+++ /dev/null
@@ -1,552 +0,0 @@
-# frozen_string_literal: false
-#
-# filehandler.rb -- FileHandler Module
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2003 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: filehandler.rb,v 1.44 2003/06/07 01:34:51 gotoyuzo Exp $
-
-require 'time'
-
-require_relative '../htmlutils'
-require_relative '../httputils'
-require_relative '../httpstatus'
-
-module WEBrick
-  module HTTPServlet
-
-    ##
-    # Servlet for serving a single file.  You probably want to use the
-    # FileHandler servlet instead as it handles directories and fancy indexes.
-    #
-    # Example:
-    #
-    #   server.mount('/my_page.txt', WEBrick::HTTPServlet::DefaultFileHandler,
-    #                '/path/to/my_page.txt')
-    #
-    # This servlet handles If-Modified-Since and Range requests.
-
-    class DefaultFileHandler < AbstractServlet
-
-      ##
-      # Creates a DefaultFileHandler instance for the file at +local_path+.
-
-      def initialize(server, local_path)
-        super(server, local_path)
-        @local_path = local_path
-      end
-
-      # :stopdoc:
-
-      def do_GET(req, res)
-        st = File::stat(@local_path)
-        mtime = st.mtime
-        res['etag'] = sprintf("%x-%x-%x", st.ino, st.size, st.mtime.to_i)
-
-        if not_modified?(req, res, mtime, res['etag'])
-          res.body = ''
-          raise HTTPStatus::NotModified
-        elsif req['range']
-          make_partial_content(req, res, @local_path, st.size)
-          raise HTTPStatus::PartialContent
-        else
-          mtype = HTTPUtils::mime_type(@local_path, @config[:MimeTypes])
-          res['content-type'] = mtype
-          res['content-length'] = st.size.to_s
-          res['last-modified'] = mtime.httpdate
-          res.body = File.open(@local_path, "rb")
-        end
-      end
-
-      def not_modified?(req, res, mtime, etag)
-        if ir = req['if-range']
-          begin
-            if Time.httpdate(ir) >= mtime
-              return true
-            end
-          rescue
-            if HTTPUtils::split_header_value(ir).member?(res['etag'])
-              return true
-            end
-          end
-        end
-
-        if (ims = req['if-modified-since']) && Time.parse(ims) >= mtime
-          return true
-        end
-
-        if (inm = req['if-none-match']) &&
-           HTTPUtils::split_header_value(inm).member?(res['etag'])
-          return true
-        end
-
-        return false
-      end
-
-      # returns a lambda for webrick/httpresponse.rb send_body_proc
-      def multipart_body(body, parts, boundary, mtype, filesize)
-        lambda do |socket|
-          begin
-            begin
-              first = parts.shift
-              last = parts.shift
-              socket.write(
-                "--#{boundary}#{CRLF}" \
-                "Content-Type: #{mtype}#{CRLF}" \
-                "Content-Range: bytes #{first}-#{last}/#{filesize}#{CRLF}" \
-                "#{CRLF}"
-              )
-
-              begin
-                IO.copy_stream(body, socket, last - first + 1, first)
-              rescue NotImplementedError
-                body.seek(first, IO::SEEK_SET)
-                IO.copy_stream(body, socket, last - first + 1)
-              end
-              socket.write(CRLF)
-            end while parts[0]
-            socket.write("--#{boundary}--#{CRLF}")
-          ensure
-            body.close
-          end
-        end
-      end
-
-      def make_partial_content(req, res, filename, filesize)
-        mtype = HTTPUtils::mime_type(filename, @config[:MimeTypes])
-        unless ranges = HTTPUtils::parse_range_header(req['range'])
-          raise HTTPStatus::BadRequest,
-            "Unrecognized range-spec: \"#{req['range']}\""
-        end
-        File.open(filename, "rb"){|io|
-          if ranges.size > 1
-            time = Time.now
-            boundary = "#{time.sec}_#{time.usec}_#{Process::pid}"
-            parts = []
-            ranges.each {|range|
-              prange = prepare_range(range, filesize)
-              next if prange[0] < 0
-              parts.concat(prange)
-            }
-            raise HTTPStatus::RequestRangeNotSatisfiable if parts.empty?
-            res["content-type"] = "multipart/byteranges; boundary=#{boundary}"
-            if req.http_version < '1.1'
-              res['connection'] = 'close'
-            else
-              res.chunked = true
-            end
-            res.body = multipart_body(io.dup, parts, boundary, mtype, filesize)
-          elsif range = ranges[0]
-            first, last = prepare_range(range, filesize)
-            raise HTTPStatus::RequestRangeNotSatisfiable if first < 0
-            res['content-type'] = mtype
-            res['content-range'] = "bytes #{first}-#{last}/#{filesize}"
-            res['content-length'] = (last - first + 1).to_s
-            res.body = io.dup
-          else
-            raise HTTPStatus::BadRequest
-          end
-        }
-      end
-
-      def prepare_range(range, filesize)
-        first = range.first < 0 ? filesize + range.first : range.first
-        return -1, -1 if first < 0 || first >= filesize
-        last = range.last < 0 ? filesize + range.last : range.last
-        last = filesize - 1 if last >= filesize
-        return first, last
-      end
-
-      # :startdoc:
-    end
-
-    ##
-    # Serves a directory including fancy indexing and a variety of other
-    # options.
-    #
-    # Example:
-    #
-    #   server.mount('/assets', WEBrick::HTTPServlet::FileHandler,
-    #                '/path/to/assets')
-
-    class FileHandler < AbstractServlet
-      HandlerTable = Hash.new # :nodoc:
-
-      ##
-      # Allow custom handling of requests for files with +suffix+ by class
-      # +handler+
-
-      def self.add_handler(suffix, handler)
-        HandlerTable[suffix] = handler
-      end
-
-      ##
-      # Remove custom handling of requests for files with +suffix+
-
-      def self.remove_handler(suffix)
-        HandlerTable.delete(suffix)
-      end
-
-      ##
-      # Creates a FileHandler servlet on +server+ that serves files starting
-      # at directory +root+
-      #
-      # +options+ may be a Hash containing keys from
-      # WEBrick::Config::FileHandler or +true+ or +false+.
-      #
-      # If +options+ is true or false then +:FancyIndexing+ is enabled or
-      # disabled respectively.
-
-      def initialize(server, root, options={}, default=Config::FileHandler)
-        @config = server.config
-        @logger = @config[:Logger]
-        @root = File.expand_path(root)
-        if options == true || options == false
-          options = { :FancyIndexing => options }
-        end
-        @options = default.dup.update(options)
-      end
-
-      # :stopdoc:
-
-      def set_filesystem_encoding(str)
-        enc = Encoding.find('filesystem')
-        if enc == Encoding::US_ASCII
-          str.b
-        else
-          str.dup.force_encoding(enc)
-        end
-      end
-
-      def service(req, res)
-        # if this class is mounted on "/" and /~username is requested.
-        # we're going to override path information before invoking service.
-        if defined?(Etc) && @options[:UserDir] && req.script_name.empty?
-          if %r|^(/~([^/]+))| =~ req.path_info
-            script_name, user = $1, $2
-            path_info = $'
-            begin
-              passwd = Etc::getpwnam(user)
-              @root = File::join(passwd.dir, @options[:UserDir])
-              req.script_name = script_name
-              req.path_info = path_info
-            rescue
-              @logger.debug "#{self.class}#do_GET: getpwnam(#{user}) failed"
-            end
-          end
-        end
-        prevent_directory_traversal(req, res)
-        super(req, res)
-      end
-
-      def do_GET(req, res)
-        unless exec_handler(req, res)
-          set_dir_list(req, res)
-        end
-      end
-
-      def do_POST(req, res)
-        unless exec_handler(req, res)
-          raise HTTPStatus::NotFound, "`#{req.path}' not found."
-        end
-      end
-
-      def do_OPTIONS(req, res)
-        unless exec_handler(req, res)
-          super(req, res)
-        end
-      end
-
-      # ToDo
-      # RFC2518: HTTP Extensions for Distributed Authoring -- WEBDAV
-      #
-      # PROPFIND PROPPATCH MKCOL DELETE PUT COPY MOVE
-      # LOCK UNLOCK
-
-      # RFC3253: Versioning Extensions to WebDAV
-      #          (Web Distributed Authoring and Versioning)
-      #
-      # VERSION-CONTROL REPORT CHECKOUT CHECK_IN UNCHECKOUT
-      # MKWORKSPACE UPDATE LABEL MERGE ACTIVITY
-
-      private
-
-      def trailing_pathsep?(path)
-        # check for trailing path separator:
-        #   File.dirname("/aaaa/bbbb/")      #=> "/aaaa")
-        #   File.dirname("/aaaa/bbbb/x")     #=> "/aaaa/bbbb")
-        #   File.dirname("/aaaa/bbbb")       #=> "/aaaa")
-        #   File.dirname("/aaaa/bbbbx")      #=> "/aaaa")
-        return File.dirname(path) != File.dirname(path+"x")
-      end
-
-      def prevent_directory_traversal(req, res)
-        # Preventing directory traversal on Windows platforms;
-        # Backslashes (0x5c) in path_info are not interpreted as special
-        # character in URI notation. So the value of path_info should be
-        # normalize before accessing to the filesystem.
-
-        # dirty hack for filesystem encoding; in nature, File.expand_path
-        # should not be used for path normalization.  [Bug #3345]
-        path = req.path_info.dup.force_encoding(Encoding.find("filesystem"))
-        if trailing_pathsep?(req.path_info)
-          # File.expand_path removes the trailing path separator.
-          # Adding a character is a workaround to save it.
-          #  File.expand_path("/aaa/")        #=> "/aaa"
-          #  File.expand_path("/aaa/" + "x")  #=> "/aaa/x"
-          expanded = File.expand_path(path + "x")
-          expanded.chop!  # remove trailing "x"
-        else
-          expanded = File.expand_path(path)
-        end
-        expanded.force_encoding(req.path_info.encoding)
-        req.path_info = expanded
-      end
-
-      def exec_handler(req, res)
-        raise HTTPStatus::NotFound, "`#{req.path}' not found." unless @root
-        if set_filename(req, res)
-          handler = get_handler(req, res)
-          call_callback(:HandlerCallback, req, res)
-          h = handler.get_instance(@config, res.filename)
-          h.service(req, res)
-          return true
-        end
-        call_callback(:HandlerCallback, req, res)
-        return false
-      end
-
-      def get_handler(req, res)
-        suffix1 = (/\.(\w+)\z/ =~ res.filename) && $1.downcase
-        if /\.(\w+)\.([\w\-]+)\z/ =~ res.filename
-          if @options[:AcceptableLanguages].include?($2.downcase)
-            suffix2 = $1.downcase
-          end
-        end
-        handler_table = @options[:HandlerTable]
-        return handler_table[suffix1] || handler_table[suffix2] ||
-               HandlerTable[suffix1] || HandlerTable[suffix2] ||
-               DefaultFileHandler
-      end
-
-      def set_filename(req, res)
-        res.filename = @root
-        path_info = req.path_info.scan(%r|/[^/]*|)
-
-        path_info.unshift("")  # dummy for checking @root dir
-        while base = path_info.first
-          base = set_filesystem_encoding(base)
-          break if base == "/"
-          break unless File.directory?(File.expand_path(res.filename + base))
-          shift_path_info(req, res, path_info)
-          call_callback(:DirectoryCallback, req, res)
-        end
-
-        if base = path_info.first
-          base = set_filesystem_encoding(base)
-          if base == "/"
-            if file = search_index_file(req, res)
-              shift_path_info(req, res, path_info, file)
-              call_callback(:FileCallback, req, res)
-              return true
-            end
-            shift_path_info(req, res, path_info)
-          elsif file = search_file(req, res, base)
-            shift_path_info(req, res, path_info, file)
-            call_callback(:FileCallback, req, res)
-            return true
-          else
-            raise HTTPStatus::NotFound, "`#{req.path}' not found."
-          end
-        end
-
-        return false
-      end
-
-      def check_filename(req, res, name)
-        if nondisclosure_name?(name) || windows_ambiguous_name?(name)
-          @logger.warn("the request refers nondisclosure name `#{name}'.")
-          raise HTTPStatus::NotFound, "`#{req.path}' not found."
-        end
-      end
-
-      def shift_path_info(req, res, path_info, base=nil)
-        tmp = path_info.shift
-        base = base || set_filesystem_encoding(tmp)
-        req.path_info = path_info.join
-        req.script_name << base
-        res.filename = File.expand_path(res.filename + base)
-        check_filename(req, res, File.basename(res.filename))
-      end
-
-      def search_index_file(req, res)
-        @config[:DirectoryIndex].each{|index|
-          if file = search_file(req, res, "/"+index)
-            return file
-          end
-        }
-        return nil
-      end
-
-      def search_file(req, res, basename)
-        langs = @options[:AcceptableLanguages]
-        path = res.filename + basename
-        if File.file?(path)
-          return basename
-        elsif langs.size > 0
-          req.accept_language.each{|lang|
-            path_with_lang = path + ".#{lang}"
-            if langs.member?(lang) && File.file?(path_with_lang)
-              return basename + ".#{lang}"
-            end
-          }
-          (langs - req.accept_language).each{|lang|
-            path_with_lang = path + ".#{lang}"
-            if File.file?(path_with_lang)
-              return basename + ".#{lang}"
-            end
-          }
-        end
-        return nil
-      end
-
-      def call_callback(callback_name, req, res)
-        if cb = @options[callback_name]
-          cb.call(req, res)
-        end
-      end
-
-      def windows_ambiguous_name?(name)
-        return true if /[. ]+\z/ =~ name
-        return true if /::\$DATA\z/ =~ name
-        return false
-      end
-
-      def nondisclosure_name?(name)
-        @options[:NondisclosureName].each{|pattern|
-          if File.fnmatch(pattern, name, File::FNM_CASEFOLD)
-            return true
-          end
-        }
-        return false
-      end
-
-      def set_dir_list(req, res)
-        redirect_to_directory_uri(req, res)
-        unless @options[:FancyIndexing]
-          raise HTTPStatus::Forbidden, "no access permission to `#{req.path}'"
-        end
-        local_path = res.filename
-        list = Dir::entries(local_path).collect{|name|
-          next if name == "." || name == ".."
-          next if nondisclosure_name?(name)
-          next if windows_ambiguous_name?(name)
-          st = (File::stat(File.join(local_path, name)) rescue nil)
-          if st.nil?
-            [ name, nil, -1 ]
-          elsif st.directory?
-            [ name + "/", st.mtime, -1 ]
-          else
-            [ name, st.mtime, st.size ]
-          end
-        }
-        list.compact!
-
-        query = req.query
-
-        d0 = nil
-        idx = nil
-        %w[N M S].each_with_index do |q, i|
-          if d = query.delete(q)
-            idx ||= i
-            d0 ||= d
-          end
-        end
-        d0 ||= "A"
-        idx ||= 0
-        d1 = (d0 == "A") ? "D" : "A"
-
-        if d0 == "A"
-          list.sort!{|a,b| a[idx] <=> b[idx] }
-        else
-          list.sort!{|a,b| b[idx] <=> a[idx] }
-        end
-
-        namewidth = query["NameWidth"]
-        if namewidth == "*"
-          namewidth = nil
-        elsif !namewidth or (namewidth = namewidth.to_i) < 2
-          namewidth = 25
-        end
-        query = query.inject('') {|s, (k, v)| s << '&' << HTMLUtils::escape("#{k}=#{v}")}
-
-        type = "text/html"
-        case enc = Encoding.find('filesystem')
-        when Encoding::US_ASCII, Encoding::ASCII_8BIT
-        else
-          type << "; charset=\"#{enc.name}\""
-        end
-        res['content-type'] = type
-
-        title = "Index of #{HTMLUtils::escape(req.path)}"
-        res.body = <<-_end_of_html_
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
-<HTML>
-  <HEAD>
-    <TITLE>#{title}</TITLE>
-    <style type="text/css">
-    <!--
-    .name, .mtime { text-align: left; }
-    .size { text-align: right; }
-    td { text-overflow: ellipsis; white-space: nowrap; overflow: hidden; }
-    table { border-collapse: collapse; }
-    tr th { border-bottom: 2px groove; }
-    //-->
-    </style>
-  </HEAD>
-  <BODY>
-    <H1>#{title}</H1>
-        _end_of_html_
-
-        res.body << "<TABLE width=\"100%\"><THEAD><TR>\n"
-        res.body << "<TH class=\"name\"><A HREF=\"?N=#{d1}#{query}\">Name</A></TH>"
-        res.body << "<TH class=\"mtime\"><A HREF=\"?M=#{d1}#{query}\">Last modified</A></TH>"
-        res.body << "<TH class=\"size\"><A HREF=\"?S=#{d1}#{query}\">Size</A></TH>\n"
-        res.body << "</TR></THEAD>\n"
-        res.body << "<TBODY>\n"
-
-        query.sub!(/\A&/, '?')
-        list.unshift [ "..", File::mtime(local_path+"/.."), -1 ]
-        list.each{ |name, time, size|
-          if name == ".."
-            dname = "Parent Directory"
-          elsif namewidth and name.size > namewidth
-            dname = name[0...(namewidth - 2)] << '..'
-          else
-            dname = name
-          end
-          s =  "<TR><TD class=\"name\"><A HREF=\"#{HTTPUtils::escape(name)}#{query if name.end_with?('/')}\">#{HTMLUtils::escape(dname)}</A></TD>"
-          s << "<TD class=\"mtime\">" << (time ? time.strftime("%Y/%m/%d %H:%M") : "") << "</TD>"
-          s << "<TD class=\"size\">" << (size >= 0 ? size.to_s : "-") << "</TD></TR>\n"
-          res.body << s
-        }
-        res.body << "</TBODY></TABLE>"
-        res.body << "<HR>"
-
-        res.body << <<-_end_of_html_
-    <ADDRESS>
-     #{HTMLUtils::escape(@config[:ServerSoftware])}<BR>
-     at #{req.host}:#{req.port}
-    </ADDRESS>
-  </BODY>
-</HTML>
-        _end_of_html_
-      end
-
-      # :startdoc:
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/prochandler.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/prochandler.rb
deleted file mode 100644
index 599ffc43408d3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpservlet/prochandler.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-# frozen_string_literal: false
-#
-# prochandler.rb -- ProcHandler Class
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: prochandler.rb,v 1.7 2002/09/21 12:23:42 gotoyuzo Exp $
-
-require_relative 'abstract'
-
-module WEBrick
-  module HTTPServlet
-
-    ##
-    # Mounts a proc at a path that accepts a request and response.
-    #
-    # Instead of mounting this servlet with WEBrick::HTTPServer#mount use
-    # WEBrick::HTTPServer#mount_proc:
-    #
-    #   server.mount_proc '/' do |req, res|
-    #     res.body = 'it worked!'
-    #     res.status = 200
-    #   end
-
-    class ProcHandler < AbstractServlet
-      # :stopdoc:
-      def get_instance(server, *options)
-        self
-      end
-
-      def initialize(proc)
-        @proc = proc
-      end
-
-      def do_GET(request, response)
-        @proc.call(request, response)
-      end
-
-      alias do_POST do_GET
-      # :startdoc:
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpstatus.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpstatus.rb
deleted file mode 100644
index c811f21964990..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpstatus.rb
+++ /dev/null
@@ -1,194 +0,0 @@
-# frozen_string_literal: false
-#--
-# httpstatus.rb -- HTTPStatus Class
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: httpstatus.rb,v 1.11 2003/03/24 20:18:55 gotoyuzo Exp $
-
-require_relative 'accesslog'
-
-module WEBrick
-
-  ##
-  # This module is used to manager HTTP status codes.
-  #
-  # See http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html for more
-  # information.
-  module HTTPStatus
-
-    ##
-    # Root of the HTTP status class hierarchy
-    class Status < StandardError
-      class << self
-        attr_reader :code, :reason_phrase # :nodoc:
-      end
-
-      # Returns the HTTP status code
-      def code() self::class::code end
-
-      # Returns the HTTP status description
-      def reason_phrase() self::class::reason_phrase end
-
-      alias to_i code # :nodoc:
-    end
-
-    # Root of the HTTP info statuses
-    class Info        < Status; end
-    # Root of the HTTP success statuses
-    class Success     < Status; end
-    # Root of the HTTP redirect statuses
-    class Redirect    < Status; end
-    # Root of the HTTP error statuses
-    class Error       < Status; end
-    # Root of the HTTP client error statuses
-    class ClientError < Error; end
-    # Root of the HTTP server error statuses
-    class ServerError < Error; end
-
-    class EOFError < StandardError; end
-
-    # HTTP status codes and descriptions
-    StatusMessage = { # :nodoc:
-      100 => 'Continue',
-      101 => 'Switching Protocols',
-      200 => 'OK',
-      201 => 'Created',
-      202 => 'Accepted',
-      203 => 'Non-Authoritative Information',
-      204 => 'No Content',
-      205 => 'Reset Content',
-      206 => 'Partial Content',
-      207 => 'Multi-Status',
-      300 => 'Multiple Choices',
-      301 => 'Moved Permanently',
-      302 => 'Found',
-      303 => 'See Other',
-      304 => 'Not Modified',
-      305 => 'Use Proxy',
-      307 => 'Temporary Redirect',
-      400 => 'Bad Request',
-      401 => 'Unauthorized',
-      402 => 'Payment Required',
-      403 => 'Forbidden',
-      404 => 'Not Found',
-      405 => 'Method Not Allowed',
-      406 => 'Not Acceptable',
-      407 => 'Proxy Authentication Required',
-      408 => 'Request Timeout',
-      409 => 'Conflict',
-      410 => 'Gone',
-      411 => 'Length Required',
-      412 => 'Precondition Failed',
-      413 => 'Request Entity Too Large',
-      414 => 'Request-URI Too Large',
-      415 => 'Unsupported Media Type',
-      416 => 'Request Range Not Satisfiable',
-      417 => 'Expectation Failed',
-      422 => 'Unprocessable Entity',
-      423 => 'Locked',
-      424 => 'Failed Dependency',
-      426 => 'Upgrade Required',
-      428 => 'Precondition Required',
-      429 => 'Too Many Requests',
-      431 => 'Request Header Fields Too Large',
-      451 => 'Unavailable For Legal Reasons',
-      500 => 'Internal Server Error',
-      501 => 'Not Implemented',
-      502 => 'Bad Gateway',
-      503 => 'Service Unavailable',
-      504 => 'Gateway Timeout',
-      505 => 'HTTP Version Not Supported',
-      507 => 'Insufficient Storage',
-      511 => 'Network Authentication Required',
-    }
-
-    # Maps a status code to the corresponding Status class
-    CodeToError = {} # :nodoc:
-
-    # Creates a status or error class for each status code and
-    # populates the CodeToError map.
-    StatusMessage.each{|code, message|
-      message.freeze
-      var_name = message.gsub(/[ \-]/,'_').upcase
-      err_name = message.gsub(/[ \-]/,'')
-
-      case code
-      when 100...200; parent = Info
-      when 200...300; parent = Success
-      when 300...400; parent = Redirect
-      when 400...500; parent = ClientError
-      when 500...600; parent = ServerError
-      end
-
-      const_set("RC_#{var_name}", code)
-      err_class = Class.new(parent)
-      err_class.instance_variable_set(:@code, code)
-      err_class.instance_variable_set(:@reason_phrase, message)
-      const_set(err_name, err_class)
-      CodeToError[code] = err_class
-    }
-
-    ##
-    # Returns the description corresponding to the HTTP status +code+
-    #
-    #   WEBrick::HTTPStatus.reason_phrase 404
-    #   => "Not Found"
-    def reason_phrase(code)
-      StatusMessage[code.to_i]
-    end
-
-    ##
-    # Is +code+ an informational status?
-    def info?(code)
-      code.to_i >= 100 and code.to_i < 200
-    end
-
-    ##
-    # Is +code+ a successful status?
-    def success?(code)
-      code.to_i >= 200 and code.to_i < 300
-    end
-
-    ##
-    # Is +code+ a redirection status?
-    def redirect?(code)
-      code.to_i >= 300 and code.to_i < 400
-    end
-
-    ##
-    # Is +code+ an error status?
-    def error?(code)
-      code.to_i >= 400 and code.to_i < 600
-    end
-
-    ##
-    # Is +code+ a client error status?
-    def client_error?(code)
-      code.to_i >= 400 and code.to_i < 500
-    end
-
-    ##
-    # Is +code+ a server error status?
-    def server_error?(code)
-      code.to_i >= 500 and code.to_i < 600
-    end
-
-    ##
-    # Returns the status class corresponding to +code+
-    #
-    #   WEBrick::HTTPStatus[302]
-    #   => WEBrick::HTTPStatus::NotFound
-    #
-    def self.[](code)
-      CodeToError[code]
-    end
-
-    module_function :reason_phrase
-    module_function :info?, :success?, :redirect?, :error?
-    module_function :client_error?, :server_error?
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httputils.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httputils.rb
deleted file mode 100644
index f1b9ddf9f03d4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httputils.rb
+++ /dev/null
@@ -1,512 +0,0 @@
-# frozen_string_literal: false
-#
-# httputils.rb -- HTTPUtils Module
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: httputils.rb,v 1.34 2003/06/05 21:34:08 gotoyuzo Exp $
-
-require 'socket'
-require 'tempfile'
-
-module WEBrick
-  CR   = "\x0d"     # :nodoc:
-  LF   = "\x0a"     # :nodoc:
-  CRLF = "\x0d\x0a" # :nodoc:
-
-  ##
-  # HTTPUtils provides utility methods for working with the HTTP protocol.
-  #
-  # This module is generally used internally by WEBrick
-
-  module HTTPUtils
-
-    ##
-    # Normalizes a request path.  Raises an exception if the path cannot be
-    # normalized.
-
-    def normalize_path(path)
-      raise "abnormal path `#{path}'" if path[0] != ?/
-      ret = path.dup
-
-      ret.gsub!(%r{/+}o, '/')                    # //      => /
-      while ret.sub!(%r'/\.(?:/|\Z)', '/'); end  # /.      => /
-      while ret.sub!(%r'/(?!\.\./)[^/]+/\.\.(?:/|\Z)', '/'); end # /foo/.. => /foo
-
-      raise "abnormal path `#{path}'" if %r{/\.\.(/|\Z)} =~ ret
-      ret
-    end
-    module_function :normalize_path
-
-    ##
-    # Default mime types
-
-    DefaultMimeTypes = {
-      "ai"    => "application/postscript",
-      "asc"   => "text/plain",
-      "avi"   => "video/x-msvideo",
-      "bin"   => "application/octet-stream",
-      "bmp"   => "image/bmp",
-      "class" => "application/octet-stream",
-      "cer"   => "application/pkix-cert",
-      "crl"   => "application/pkix-crl",
-      "crt"   => "application/x-x509-ca-cert",
-     #"crl"   => "application/x-pkcs7-crl",
-      "css"   => "text/css",
-      "dms"   => "application/octet-stream",
-      "doc"   => "application/msword",
-      "dvi"   => "application/x-dvi",
-      "eps"   => "application/postscript",
-      "etx"   => "text/x-setext",
-      "exe"   => "application/octet-stream",
-      "gif"   => "image/gif",
-      "htm"   => "text/html",
-      "html"  => "text/html",
-      "jpe"   => "image/jpeg",
-      "jpeg"  => "image/jpeg",
-      "jpg"   => "image/jpeg",
-      "js"    => "application/javascript",
-      "json"  => "application/json",
-      "lha"   => "application/octet-stream",
-      "lzh"   => "application/octet-stream",
-      "mjs"   => "application/javascript",
-      "mov"   => "video/quicktime",
-      "mpe"   => "video/mpeg",
-      "mpeg"  => "video/mpeg",
-      "mpg"   => "video/mpeg",
-      "pbm"   => "image/x-portable-bitmap",
-      "pdf"   => "application/pdf",
-      "pgm"   => "image/x-portable-graymap",
-      "png"   => "image/png",
-      "pnm"   => "image/x-portable-anymap",
-      "ppm"   => "image/x-portable-pixmap",
-      "ppt"   => "application/vnd.ms-powerpoint",
-      "ps"    => "application/postscript",
-      "qt"    => "video/quicktime",
-      "ras"   => "image/x-cmu-raster",
-      "rb"    => "text/plain",
-      "rd"    => "text/plain",
-      "rtf"   => "application/rtf",
-      "sgm"   => "text/sgml",
-      "sgml"  => "text/sgml",
-      "svg"   => "image/svg+xml",
-      "tif"   => "image/tiff",
-      "tiff"  => "image/tiff",
-      "txt"   => "text/plain",
-      "wasm"  => "application/wasm",
-      "xbm"   => "image/x-xbitmap",
-      "xhtml" => "text/html",
-      "xls"   => "application/vnd.ms-excel",
-      "xml"   => "text/xml",
-      "xpm"   => "image/x-xpixmap",
-      "xwd"   => "image/x-xwindowdump",
-      "zip"   => "application/zip",
-    }
-
-    ##
-    # Loads Apache-compatible mime.types in +file+.
-
-    def load_mime_types(file)
-      # note: +file+ may be a "| command" for now; some people may
-      # rely on this, but currently we do not use this method by default.
-      open(file){ |io|
-        hash = Hash.new
-        io.each{ |line|
-          next if /^#/ =~ line
-          line.chomp!
-          mimetype, ext0 = line.split(/\s+/, 2)
-          next unless ext0
-          next if ext0.empty?
-          ext0.split(/\s+/).each{ |ext| hash[ext] = mimetype }
-        }
-        hash
-      }
-    end
-    module_function :load_mime_types
-
-    ##
-    # Returns the mime type of +filename+ from the list in +mime_tab+.  If no
-    # mime type was found application/octet-stream is returned.
-
-    def mime_type(filename, mime_tab)
-      suffix1 = (/\.(\w+)$/ =~ filename && $1.downcase)
-      suffix2 = (/\.(\w+)\.[\w\-]+$/ =~ filename && $1.downcase)
-      mime_tab[suffix1] || mime_tab[suffix2] || "application/octet-stream"
-    end
-    module_function :mime_type
-
-    ##
-    # Parses an HTTP header +raw+ into a hash of header fields with an Array
-    # of values.
-
-    def parse_header(raw)
-      header = Hash.new([].freeze)
-      field = nil
-      raw.each_line{|line|
-        case line
-        when /^([A-Za-z0-9!\#$%&'*+\-.^_`|~]+):\s*(.*?)\s*\z/om
-          field, value = $1, $2
-          field.downcase!
-          header[field] = [] unless header.has_key?(field)
-          header[field] << value
-        when /^\s+(.*?)\s*\z/om
-          value = $1
-          unless field
-            raise HTTPStatus::BadRequest, "bad header '#{line}'."
-          end
-          header[field][-1] << " " << value
-        else
-          raise HTTPStatus::BadRequest, "bad header '#{line}'."
-        end
-      }
-      header.each{|key, values|
-        values.each(&:strip!)
-      }
-      header
-    end
-    module_function :parse_header
-
-    ##
-    # Splits a header value +str+ according to HTTP specification.
-
-    def split_header_value(str)
-      str.scan(%r'\G((?:"(?:\\.|[^"])+?"|[^",]+)+)
-                    (?:,\s*|\Z)'xn).flatten
-    end
-    module_function :split_header_value
-
-    ##
-    # Parses a Range header value +ranges_specifier+
-
-    def parse_range_header(ranges_specifier)
-      if /^bytes=(.*)/ =~ ranges_specifier
-        byte_range_set = split_header_value($1)
-        byte_range_set.collect{|range_spec|
-          case range_spec
-          when /^(\d+)-(\d+)/ then $1.to_i .. $2.to_i
-          when /^(\d+)-/      then $1.to_i .. -1
-          when /^-(\d+)/      then -($1.to_i) .. -1
-          else return nil
-          end
-        }
-      end
-    end
-    module_function :parse_range_header
-
-    ##
-    # Parses q values in +value+ as used in Accept headers.
-
-    def parse_qvalues(value)
-      tmp = []
-      if value
-        parts = value.split(/,\s*/)
-        parts.each {|part|
-          if m = %r{^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$}.match(part)
-            val = m[1]
-            q = (m[2] or 1).to_f
-            tmp.push([val, q])
-          end
-        }
-        tmp = tmp.sort_by{|val, q| -q}
-        tmp.collect!{|val, q| val}
-      end
-      return tmp
-    end
-    module_function :parse_qvalues
-
-    ##
-    # Removes quotes and escapes from +str+
-
-    def dequote(str)
-      ret = (/\A"(.*)"\Z/ =~ str) ? $1 : str.dup
-      ret.gsub!(/\\(.)/, "\\1")
-      ret
-    end
-    module_function :dequote
-
-    ##
-    # Quotes and escapes quotes in +str+
-
-    def quote(str)
-      '"' << str.gsub(/[\\\"]/o, "\\\1") << '"'
-    end
-    module_function :quote
-
-    ##
-    # Stores multipart form data.  FormData objects are created when
-    # WEBrick::HTTPUtils.parse_form_data is called.
-
-    class FormData < String
-      EmptyRawHeader = [].freeze # :nodoc:
-      EmptyHeader = {}.freeze # :nodoc:
-
-      ##
-      # The name of the form data part
-
-      attr_accessor :name
-
-      ##
-      # The filename of the form data part
-
-      attr_accessor :filename
-
-      attr_accessor :next_data # :nodoc:
-      protected :next_data
-
-      ##
-      # Creates a new FormData object.
-      #
-      # +args+ is an Array of form data entries.  One FormData will be created
-      # for each entry.
-      #
-      # This is called by WEBrick::HTTPUtils.parse_form_data for you
-
-      def initialize(*args)
-        @name = @filename = @next_data = nil
-        if args.empty?
-          @raw_header = []
-          @header = nil
-          super("")
-        else
-          @raw_header = EmptyRawHeader
-          @header = EmptyHeader
-          super(args.shift)
-          unless args.empty?
-            @next_data = self.class.new(*args)
-          end
-        end
-      end
-
-      ##
-      # Retrieves the header at the first entry in +key+
-
-      def [](*key)
-        begin
-          @header[key[0].downcase].join(", ")
-        rescue StandardError, NameError
-          super
-        end
-      end
-
-      ##
-      # Adds +str+ to this FormData which may be the body, a header or a
-      # header entry.
-      #
-      # This is called by WEBrick::HTTPUtils.parse_form_data for you
-
-      def <<(str)
-        if @header
-          super
-        elsif str == CRLF
-          @header = HTTPUtils::parse_header(@raw_header.join)
-          if cd = self['content-disposition']
-            if /\s+name="(.*?)"/ =~ cd then @name = $1 end
-            if /\s+filename="(.*?)"/ =~ cd then @filename = $1 end
-          end
-        else
-          @raw_header << str
-        end
-        self
-      end
-
-      ##
-      # Adds +data+ at the end of the chain of entries
-      #
-      # This is called by WEBrick::HTTPUtils.parse_form_data for you.
-
-      def append_data(data)
-        tmp = self
-        while tmp
-          unless tmp.next_data
-            tmp.next_data = data
-            break
-          end
-          tmp = tmp.next_data
-        end
-        self
-      end
-
-      ##
-      # Yields each entry in this FormData
-
-      def each_data
-        tmp = self
-        while tmp
-          next_data = tmp.next_data
-          yield(tmp)
-          tmp = next_data
-        end
-      end
-
-      ##
-      # Returns all the FormData as an Array
-
-      def list
-        ret = []
-        each_data{|data|
-          ret << data.to_s
-        }
-        ret
-      end
-
-      ##
-      # A FormData will behave like an Array
-
-      alias :to_ary :list
-
-      ##
-      # This FormData's body
-
-      def to_s
-        String.new(self)
-      end
-    end
-
-    ##
-    # Parses the query component of a URI in +str+
-
-    def parse_query(str)
-      query = Hash.new
-      if str
-        str.split(/[&;]/).each{|x|
-          next if x.empty?
-          key, val = x.split(/=/,2)
-          key = unescape_form(key)
-          val = unescape_form(val.to_s)
-          val = FormData.new(val)
-          val.name = key
-          if query.has_key?(key)
-            query[key].append_data(val)
-            next
-          end
-          query[key] = val
-        }
-      end
-      query
-    end
-    module_function :parse_query
-
-    ##
-    # Parses form data in +io+ with the given +boundary+
-
-    def parse_form_data(io, boundary)
-      boundary_regexp = /\A--#{Regexp.quote(boundary)}(--)?#{CRLF}\z/
-      form_data = Hash.new
-      return form_data unless io
-      data = nil
-      io.each_line{|line|
-        if boundary_regexp =~ line
-          if data
-            data.chop!
-            key = data.name
-            if form_data.has_key?(key)
-              form_data[key].append_data(data)
-            else
-              form_data[key] = data
-            end
-          end
-          data = FormData.new
-          next
-        else
-          if data
-            data << line
-          end
-        end
-      }
-      return form_data
-    end
-    module_function :parse_form_data
-
-    #####
-
-    reserved = ';/?:@&=+$,'
-    num      = '0123456789'
-    lowalpha = 'abcdefghijklmnopqrstuvwxyz'
-    upalpha  = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-    mark     = '-_.!~*\'()'
-    unreserved = num + lowalpha + upalpha + mark
-    control  = (0x0..0x1f).collect{|c| c.chr }.join + "\x7f"
-    space    = " "
-    delims   = '<>#%"'
-    unwise   = '{}|\\^[]`'
-    nonascii = (0x80..0xff).collect{|c| c.chr }.join
-
-    module_function
-
-    # :stopdoc:
-
-    def _make_regex(str) /([#{Regexp.escape(str)}])/n end
-    def _make_regex!(str) /([^#{Regexp.escape(str)}])/n end
-    def _escape(str, regex)
-      str = str.b
-      str.gsub!(regex) {"%%%02X" % $1.ord}
-      # %-escaped string should contain US-ASCII only
-      str.force_encoding(Encoding::US_ASCII)
-    end
-    def _unescape(str, regex)
-      str = str.b
-      str.gsub!(regex) {$1.hex.chr}
-      # encoding of %-unescaped string is unknown
-      str
-    end
-
-    UNESCAPED = _make_regex(control+space+delims+unwise+nonascii)
-    UNESCAPED_FORM = _make_regex(reserved+control+delims+unwise+nonascii)
-    NONASCII  = _make_regex(nonascii)
-    ESCAPED   = /%([0-9a-fA-F]{2})/
-    UNESCAPED_PCHAR = _make_regex!(unreserved+":@&=+$,")
-
-    # :startdoc:
-
-    ##
-    # Escapes HTTP reserved and unwise characters in +str+
-
-    def escape(str)
-      _escape(str, UNESCAPED)
-    end
-
-    ##
-    # Unescapes HTTP reserved and unwise characters in +str+
-
-    def unescape(str)
-      _unescape(str, ESCAPED)
-    end
-
-    ##
-    # Escapes form reserved characters in +str+
-
-    def escape_form(str)
-      ret = _escape(str, UNESCAPED_FORM)
-      ret.gsub!(/ /, "+")
-      ret
-    end
-
-    ##
-    # Unescapes form reserved characters in +str+
-
-    def unescape_form(str)
-      _unescape(str.gsub(/\+/, " "), ESCAPED)
-    end
-
-    ##
-    # Escapes path +str+
-
-    def escape_path(str)
-      result = ""
-      str.scan(%r{/([^/]*)}).each{|i|
-        result << "/" << _escape(i[0], UNESCAPED_PCHAR)
-      }
-      return result
-    end
-
-    ##
-    # Escapes 8 bit characters in +str+
-
-    def escape8bit(str)
-      _escape(str, NONASCII)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpversion.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpversion.rb
deleted file mode 100644
index 8a251944a2c06..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/httpversion.rb
+++ /dev/null
@@ -1,76 +0,0 @@
-# frozen_string_literal: false
-#--
-# HTTPVersion.rb -- presentation of HTTP version
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: httpversion.rb,v 1.5 2002/09/21 12:23:37 gotoyuzo Exp $
-
-module WEBrick
-
-  ##
-  # Represents an HTTP protocol version
-
-  class HTTPVersion
-    include Comparable
-
-    ##
-    # The major protocol version number
-
-    attr_accessor :major
-
-    ##
-    # The minor protocol version number
-
-    attr_accessor :minor
-
-    ##
-    # Converts +version+ into an HTTPVersion
-
-    def self.convert(version)
-      version.is_a?(self) ? version : new(version)
-    end
-
-    ##
-    # Creates a new HTTPVersion from +version+.
-
-    def initialize(version)
-      case version
-      when HTTPVersion
-        @major, @minor = version.major, version.minor
-      when String
-        if /^(\d+)\.(\d+)$/ =~ version
-          @major, @minor = $1.to_i, $2.to_i
-        end
-      end
-      if @major.nil? || @minor.nil?
-        raise ArgumentError,
-          format("cannot convert %s into %s", version.class, self.class)
-      end
-    end
-
-    ##
-    # Compares this version with +other+ according to the HTTP specification
-    # rules.
-
-    def <=>(other)
-      unless other.is_a?(self.class)
-        other = self.class.new(other)
-      end
-      if (ret = @major <=> other.major) == 0
-        return @minor <=> other.minor
-      end
-      return ret
-    end
-
-    ##
-    # The HTTP version as show in the HTTP request and response.  For example,
-    # "1.1"
-
-    def to_s
-      format("%d.%d", @major, @minor)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/log.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/log.rb
deleted file mode 100644
index 2c1fdfe602bdc..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/log.rb
+++ /dev/null
@@ -1,156 +0,0 @@
-# frozen_string_literal: false
-#--
-# log.rb -- Log Class
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: log.rb,v 1.26 2002/10/06 17:06:10 gotoyuzo Exp $
-
-module WEBrick
-
-  ##
-  # A generic logging class
-
-  class BasicLog
-
-    # Fatal log level which indicates a server crash
-
-    FATAL = 1
-
-    # Error log level which indicates a recoverable error
-
-    ERROR = 2
-
-    # Warning log level which indicates a possible problem
-
-    WARN  = 3
-
-    # Information log level which indicates possibly useful information
-
-    INFO  = 4
-
-    # Debugging error level for messages used in server development or
-    # debugging
-
-    DEBUG = 5
-
-    # log-level, messages above this level will be logged
-    attr_accessor :level
-
-    ##
-    # Initializes a new logger for +log_file+ that outputs messages at +level+
-    # or higher.  +log_file+ can be a filename, an IO-like object that
-    # responds to #<< or nil which outputs to $stderr.
-    #
-    # If no level is given INFO is chosen by default
-
-    def initialize(log_file=nil, level=nil)
-      @level = level || INFO
-      case log_file
-      when String
-        @log = File.open(log_file, "a+")
-        @log.sync = true
-        @opened = true
-      when NilClass
-        @log = $stderr
-      else
-        @log = log_file  # requires "<<". (see BasicLog#log)
-      end
-    end
-
-    ##
-    # Closes the logger (also closes the log device associated to the logger)
-    def close
-      @log.close if @opened
-      @log = nil
-    end
-
-    ##
-    # Logs +data+ at +level+ if the given level is above the current log
-    # level.
-
-    def log(level, data)
-      if @log && level <= @level
-        data += "\n" if /\n\Z/ !~ data
-        @log << data
-      end
-    end
-
-    ##
-    # Synonym for log(INFO, obj.to_s)
-    def <<(obj)
-      log(INFO, obj.to_s)
-    end
-
-    # Shortcut for logging a FATAL message
-    def fatal(msg) log(FATAL, "FATAL " << format(msg)); end
-    # Shortcut for logging an ERROR message
-    def error(msg) log(ERROR, "ERROR " << format(msg)); end
-    # Shortcut for logging a WARN message
-    def warn(msg)  log(WARN,  "WARN  " << format(msg)); end
-    # Shortcut for logging an INFO message
-    def info(msg)  log(INFO,  "INFO  " << format(msg)); end
-    # Shortcut for logging a DEBUG message
-    def debug(msg) log(DEBUG, "DEBUG " << format(msg)); end
-
-    # Will the logger output FATAL messages?
-    def fatal?; @level >= FATAL; end
-    # Will the logger output ERROR messages?
-    def error?; @level >= ERROR; end
-    # Will the logger output WARN messages?
-    def warn?;  @level >= WARN; end
-    # Will the logger output INFO messages?
-    def info?;  @level >= INFO; end
-    # Will the logger output DEBUG messages?
-    def debug?; @level >= DEBUG; end
-
-    private
-
-    ##
-    # Formats +arg+ for the logger
-    #
-    # * If +arg+ is an Exception, it will format the error message and
-    #   the back trace.
-    # * If +arg+ responds to #to_str, it will return it.
-    # * Otherwise it will return +arg+.inspect.
-    def format(arg)
-      if arg.is_a?(Exception)
-        "#{arg.class}: #{AccessLog.escape(arg.message)}\n\t" <<
-        arg.backtrace.join("\n\t") << "\n"
-      elsif arg.respond_to?(:to_str)
-        AccessLog.escape(arg.to_str)
-      else
-        arg.inspect
-      end
-    end
-  end
-
-  ##
-  # A logging class that prepends a timestamp to each message.
-
-  class Log < BasicLog
-    # Format of the timestamp which is applied to each logged line.  The
-    # default is <tt>"[%Y-%m-%d %H:%M:%S]"</tt>
-    attr_accessor :time_format
-
-    ##
-    # Same as BasicLog#initialize
-    #
-    # You can set the timestamp format through #time_format
-    def initialize(log_file=nil, level=nil)
-      super(log_file, level)
-      @time_format = "[%Y-%m-%d %H:%M:%S]"
-    end
-
-    ##
-    # Same as BasicLog#log
-    def log(level, data)
-      tmp = Time.now.strftime(@time_format)
-      tmp << " " << data
-      super(level, tmp)
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/server.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/server.rb
deleted file mode 100644
index fd6b7a61b56e2..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/server.rb
+++ /dev/null
@@ -1,381 +0,0 @@
-# frozen_string_literal: false
-#
-# server.rb -- GenericServer Class
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: server.rb,v 1.62 2003/07/22 19:20:43 gotoyuzo Exp $
-
-require 'socket'
-require_relative 'config'
-require_relative 'log'
-
-module WEBrick
-
-  ##
-  # Server error exception
-
-  class ServerError < StandardError; end
-
-  ##
-  # Base server class
-
-  class SimpleServer
-
-    ##
-    # A SimpleServer only yields when you start it
-
-    def SimpleServer.start
-      yield
-    end
-  end
-
-  ##
-  # A generic module for daemonizing a process
-
-  class Daemon
-
-    ##
-    # Performs the standard operations for daemonizing a process.  Runs a
-    # block, if given.
-
-    def Daemon.start
-      Process.daemon
-      File.umask(0)
-      yield if block_given?
-    end
-  end
-
-  ##
-  # Base TCP server class.  You must subclass GenericServer and provide a #run
-  # method.
-
-  class GenericServer
-
-    ##
-    # The server status.  One of :Stop, :Running or :Shutdown
-
-    attr_reader :status
-
-    ##
-    # The server configuration
-
-    attr_reader :config
-
-    ##
-    # The server logger.  This is independent from the HTTP access log.
-
-    attr_reader :logger
-
-    ##
-    # Tokens control the number of outstanding clients.  The
-    # <code>:MaxClients</code> configuration sets this.
-
-    attr_reader :tokens
-
-    ##
-    # Sockets listening for connections.
-
-    attr_reader :listeners
-
-    ##
-    # Creates a new generic server from +config+.  The default configuration
-    # comes from +default+.
-
-    def initialize(config={}, default=Config::General)
-      @config = default.dup.update(config)
-      @status = :Stop
-      @config[:Logger] ||= Log::new
-      @logger = @config[:Logger]
-
-      @tokens = Thread::SizedQueue.new(@config[:MaxClients])
-      @config[:MaxClients].times{ @tokens.push(nil) }
-
-      webrickv = WEBrick::VERSION
-      rubyv = "#{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
-      @logger.info("WEBrick #{webrickv}")
-      @logger.info("ruby #{rubyv}")
-
-      @listeners = []
-      @shutdown_pipe = nil
-      unless @config[:DoNotListen]
-        raise ArgumentError, "Port must an integer" unless @config[:Port].to_s == @config[:Port].to_i.to_s
-
-        @config[:Port] = @config[:Port].to_i
-        if @config[:Listen]
-          warn(":Listen option is deprecated; use GenericServer#listen", uplevel: 1)
-        end
-        listen(@config[:BindAddress], @config[:Port])
-        if @config[:Port] == 0
-          @config[:Port] = @listeners[0].addr[1]
-        end
-      end
-    end
-
-    ##
-    # Retrieves +key+ from the configuration
-
-    def [](key)
-      @config[key]
-    end
-
-    ##
-    # Adds listeners from +address+ and +port+ to the server.  See
-    # WEBrick::Utils::create_listeners for details.
-
-    def listen(address, port)
-      @listeners += Utils::create_listeners(address, port)
-    end
-
-    ##
-    # Starts the server and runs the +block+ for each connection.  This method
-    # does not return until the server is stopped from a signal handler or
-    # another thread using #stop or #shutdown.
-    #
-    # If the block raises a subclass of StandardError the exception is logged
-    # and ignored.  If an IOError or Errno::EBADF exception is raised the
-    # exception is ignored.  If an Exception subclass is raised the exception
-    # is logged and re-raised which stops the server.
-    #
-    # To completely shut down a server call #shutdown from ensure:
-    #
-    #   server = WEBrick::GenericServer.new
-    #   # or WEBrick::HTTPServer.new
-    #
-    #   begin
-    #     server.start
-    #   ensure
-    #     server.shutdown
-    #   end
-
-    def start(&block)
-      raise ServerError, "already started." if @status != :Stop
-      server_type = @config[:ServerType] || SimpleServer
-
-      setup_shutdown_pipe
-
-      server_type.start{
-        @logger.info \
-          "#{self.class}#start: pid=#{$$} port=#{@config[:Port]}"
-        @status = :Running
-        call_callback(:StartCallback)
-
-        shutdown_pipe = @shutdown_pipe
-
-        thgroup = ThreadGroup.new
-        begin
-          while @status == :Running
-            begin
-              sp = shutdown_pipe[0]
-              if svrs = IO.select([sp, *@listeners])
-                if svrs[0].include? sp
-                  # swallow shutdown pipe
-                  buf = String.new
-                  nil while String ===
-                            sp.read_nonblock([sp.nread, 8].max, buf, exception: false)
-                  break
-                end
-                svrs[0].each{|svr|
-                  @tokens.pop          # blocks while no token is there.
-                  if sock = accept_client(svr)
-                    unless config[:DoNotReverseLookup].nil?
-                      sock.do_not_reverse_lookup = !!config[:DoNotReverseLookup]
-                    end
-                    th = start_thread(sock, &block)
-                    th[:WEBrickThread] = true
-                    thgroup.add(th)
-                  else
-                    @tokens.push(nil)
-                  end
-                }
-              end
-            rescue Errno::EBADF, Errno::ENOTSOCK, IOError => ex
-              # if the listening socket was closed in GenericServer#shutdown,
-              # IO::select raise it.
-            rescue StandardError => ex
-              msg = "#{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
-              @logger.error msg
-            rescue Exception => ex
-              @logger.fatal ex
-              raise
-            end
-          end
-        ensure
-          cleanup_shutdown_pipe(shutdown_pipe)
-          cleanup_listener
-          @status = :Shutdown
-          @logger.info "going to shutdown ..."
-          thgroup.list.each{|th| th.join if th[:WEBrickThread] }
-          call_callback(:StopCallback)
-          @logger.info "#{self.class}#start done."
-          @status = :Stop
-        end
-      }
-    end
-
-    ##
-    # Stops the server from accepting new connections.
-
-    def stop
-      if @status == :Running
-        @status = :Shutdown
-      end
-
-      alarm_shutdown_pipe {|f| f.write_nonblock("\0")}
-    end
-
-    ##
-    # Shuts down the server and all listening sockets.  New listeners must be
-    # provided to restart the server.
-
-    def shutdown
-      stop
-
-      alarm_shutdown_pipe(&:close)
-    end
-
-    ##
-    # You must subclass GenericServer and implement \#run which accepts a TCP
-    # client socket
-
-    def run(sock)
-      @logger.fatal "run() must be provided by user."
-    end
-
-    private
-
-    # :stopdoc:
-
-    ##
-    # Accepts a TCP client socket from the TCP server socket +svr+ and returns
-    # the client socket.
-
-    def accept_client(svr)
-      case sock = svr.to_io.accept_nonblock(exception: false)
-      when :wait_readable
-        nil
-      else
-        if svr.respond_to?(:start_immediately)
-          sock = OpenSSL::SSL::SSLSocket.new(sock, ssl_context)
-          sock.sync_close = true
-          # we cannot do OpenSSL::SSL::SSLSocket#accept here because
-          # a slow client can prevent us from accepting connections
-          # from other clients
-        end
-        sock
-      end
-    rescue Errno::ECONNRESET, Errno::ECONNABORTED,
-           Errno::EPROTO, Errno::EINVAL
-      nil
-    rescue StandardError => ex
-      msg = "#{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
-      @logger.error msg
-      nil
-    end
-
-    ##
-    # Starts a server thread for the client socket +sock+ that runs the given
-    # +block+.
-    #
-    # Sets the socket to the <code>:WEBrickSocket</code> thread local variable
-    # in the thread.
-    #
-    # If any errors occur in the block they are logged and handled.
-
-    def start_thread(sock, &block)
-      Thread.start{
-        begin
-          Thread.current[:WEBrickSocket] = sock
-          begin
-            addr = sock.peeraddr
-            @logger.debug "accept: #{addr[3]}:#{addr[1]}"
-          rescue SocketError
-            @logger.debug "accept: <address unknown>"
-            raise
-          end
-          if sock.respond_to?(:sync_close=) && @config[:SSLStartImmediately]
-            WEBrick::Utils.timeout(@config[:RequestTimeout]) do
-              begin
-                sock.accept # OpenSSL::SSL::SSLSocket#accept
-              rescue Errno::ECONNRESET, Errno::ECONNABORTED,
-                     Errno::EPROTO, Errno::EINVAL
-                Thread.exit
-              end
-            end
-          end
-          call_callback(:AcceptCallback, sock)
-          block ? block.call(sock) : run(sock)
-        rescue Errno::ENOTCONN
-          @logger.debug "Errno::ENOTCONN raised"
-        rescue ServerError => ex
-          msg = "#{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
-          @logger.error msg
-        rescue Exception => ex
-          @logger.error ex
-        ensure
-          @tokens.push(nil)
-          Thread.current[:WEBrickSocket] = nil
-          if addr
-            @logger.debug "close: #{addr[3]}:#{addr[1]}"
-          else
-            @logger.debug "close: <address unknown>"
-          end
-          sock.close
-        end
-      }
-    end
-
-    ##
-    # Calls the callback +callback_name+ from the configuration with +args+
-
-    def call_callback(callback_name, *args)
-      @config[callback_name]&.call(*args)
-    end
-
-    def setup_shutdown_pipe
-      return @shutdown_pipe ||= IO.pipe
-    end
-
-    def cleanup_shutdown_pipe(shutdown_pipe)
-      @shutdown_pipe = nil
-      shutdown_pipe&.each(&:close)
-    end
-
-    def alarm_shutdown_pipe
-      _, pipe = @shutdown_pipe # another thread may modify @shutdown_pipe.
-      if pipe
-        if !pipe.closed?
-          begin
-            yield pipe
-          rescue IOError # closed by another thread.
-          end
-        end
-      end
-    end
-
-    def cleanup_listener
-      @listeners.each{|s|
-        if @logger.debug?
-          addr = s.addr
-          @logger.debug("close TCPSocket(#{addr[2]}, #{addr[1]})")
-        end
-        begin
-          s.shutdown
-        rescue Errno::ENOTCONN
-          # when `Errno::ENOTCONN: Socket is not connected' on some platforms,
-          # call #close instead of #shutdown.
-          # (ignore @config[:ShutdownSocketWithoutClose])
-          s.close
-        else
-          unless @config[:ShutdownSocketWithoutClose]
-            s.close
-          end
-        end
-      }
-      @listeners.clear
-    end
-  end    # end of GenericServer
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/ssl.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/ssl.rb
deleted file mode 100644
index e448095a12f6d..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/ssl.rb
+++ /dev/null
@@ -1,215 +0,0 @@
-# frozen_string_literal: false
-#
-# ssl.rb -- SSL/TLS enhancement for GenericServer
-#
-# Copyright (c) 2003 GOTOU Yuuzou All rights reserved.
-#
-# $Id$
-
-require 'webrick'
-require 'openssl'
-
-module WEBrick
-  module Config
-    svrsoft = General[:ServerSoftware]
-    osslv = ::OpenSSL::OPENSSL_VERSION.split[1]
-
-    ##
-    # Default SSL server configuration.
-    #
-    # WEBrick can automatically create a self-signed certificate if
-    # <code>:SSLCertName</code> is set.  For more information on the various
-    # SSL options see OpenSSL::SSL::SSLContext.
-    #
-    # :ServerSoftware       ::
-    #   The server software name used in the Server: header.
-    # :SSLEnable            :: false,
-    #   Enable SSL for this server.  Defaults to false.
-    # :SSLCertificate       ::
-    #   The SSL certificate for the server.
-    # :SSLPrivateKey        ::
-    #   The SSL private key for the server certificate.
-    # :SSLClientCA          :: nil,
-    #   Array of certificates that will be sent to the client.
-    # :SSLExtraChainCert    :: nil,
-    #   Array of certificates that will be added to the certificate chain
-    # :SSLCACertificateFile :: nil,
-    #   Path to a CA certificate file
-    # :SSLCACertificatePath :: nil,
-    #   Path to a directory containing CA certificates
-    # :SSLCertificateStore  :: nil,
-    #   OpenSSL::X509::Store used for certificate validation of the client
-    # :SSLTmpDhCallback     :: nil,
-    #   Callback invoked when DH parameters are required.
-    # :SSLVerifyClient      ::
-    #   Sets whether the client is verified.  This defaults to VERIFY_NONE
-    #   which is typical for an HTTPS server.
-    # :SSLVerifyDepth       ::
-    #   Number of CA certificates to walk when verifying a certificate chain
-    # :SSLVerifyCallback    ::
-    #   Custom certificate verification callback
-    # :SSLServerNameCallback::
-    #   Custom servername indication callback
-    # :SSLTimeout           ::
-    #   Maximum session lifetime
-    # :SSLOptions           ::
-    #   Various SSL options
-    # :SSLCiphers           ::
-    #   Ciphers to be used
-    # :SSLStartImmediately  ::
-    #   Immediately start SSL upon connection?  Defaults to true
-    # :SSLCertName          ::
-    #   SSL certificate name.  Must be set to enable automatic certificate
-    #   creation.
-    # :SSLCertComment       ::
-    #   Comment used during automatic certificate creation.
-
-    SSL = {
-      :ServerSoftware       => "#{svrsoft} OpenSSL/#{osslv}",
-      :SSLEnable            => false,
-      :SSLCertificate       => nil,
-      :SSLPrivateKey        => nil,
-      :SSLClientCA          => nil,
-      :SSLExtraChainCert    => nil,
-      :SSLCACertificateFile => nil,
-      :SSLCACertificatePath => nil,
-      :SSLCertificateStore  => nil,
-      :SSLTmpDhCallback     => nil,
-      :SSLVerifyClient      => ::OpenSSL::SSL::VERIFY_NONE,
-      :SSLVerifyDepth       => nil,
-      :SSLVerifyCallback    => nil,   # custom verification
-      :SSLTimeout           => nil,
-      :SSLOptions           => nil,
-      :SSLCiphers           => nil,
-      :SSLStartImmediately  => true,
-      # Must specify if you use auto generated certificate.
-      :SSLCertName          => nil,
-      :SSLCertComment       => "Generated by Ruby/OpenSSL"
-    }
-    General.update(SSL)
-  end
-
-  module Utils
-    ##
-    # Creates a self-signed certificate with the given number of +bits+,
-    # the issuer +cn+ and a +comment+ to be stored in the certificate.
-
-    def create_self_signed_cert(bits, cn, comment)
-      rsa = OpenSSL::PKey::RSA.new(bits){|p, n|
-        case p
-        when 0; $stderr.putc "."  # BN_generate_prime
-        when 1; $stderr.putc "+"  # BN_generate_prime
-        when 2; $stderr.putc "*"  # searching good prime,
-                                  # n = #of try,
-                                  # but also data from BN_generate_prime
-        when 3; $stderr.putc "\n" # found good prime, n==0 - p, n==1 - q,
-                                  # but also data from BN_generate_prime
-        else;   $stderr.putc "*"  # BN_generate_prime
-        end
-      }
-      cert = OpenSSL::X509::Certificate.new
-      cert.version = 2
-      cert.serial = 1
-      name = (cn.kind_of? String) ? OpenSSL::X509::Name.parse(cn)
-                                  : OpenSSL::X509::Name.new(cn)
-      cert.subject = name
-      cert.issuer = name
-      cert.not_before = Time.now
-      cert.not_after = Time.now + (365*24*60*60)
-      cert.public_key = rsa.public_key
-
-      ef = OpenSSL::X509::ExtensionFactory.new(nil,cert)
-      ef.issuer_certificate = cert
-      cert.extensions = [
-        ef.create_extension("basicConstraints","CA:FALSE"),
-        ef.create_extension("keyUsage", "keyEncipherment, digitalSignature, keyAgreement, dataEncipherment"),
-        ef.create_extension("subjectKeyIdentifier", "hash"),
-        ef.create_extension("extendedKeyUsage", "serverAuth"),
-        ef.create_extension("nsComment", comment),
-      ]
-      aki = ef.create_extension("authorityKeyIdentifier",
-                                "keyid:always,issuer:always")
-      cert.add_extension(aki)
-      cert.sign(rsa, "SHA256")
-
-      return [ cert, rsa ]
-    end
-    module_function :create_self_signed_cert
-  end
-
-  ##
-  #--
-  # Updates WEBrick::GenericServer with SSL functionality
-
-  class GenericServer
-
-    ##
-    # SSL context for the server when run in SSL mode
-
-    def ssl_context # :nodoc:
-      @ssl_context ||= begin
-        if @config[:SSLEnable]
-          ssl_context = setup_ssl_context(@config)
-          @logger.info("\n" + @config[:SSLCertificate].to_text)
-          ssl_context
-        end
-      end
-    end
-
-    undef listen
-
-    ##
-    # Updates +listen+ to enable SSL when the SSL configuration is active.
-
-    def listen(address, port) # :nodoc:
-      listeners = Utils::create_listeners(address, port)
-      if @config[:SSLEnable]
-        listeners.collect!{|svr|
-          ssvr = ::OpenSSL::SSL::SSLServer.new(svr, ssl_context)
-          ssvr.start_immediately = @config[:SSLStartImmediately]
-          ssvr
-        }
-      end
-      @listeners += listeners
-      setup_shutdown_pipe
-    end
-
-    ##
-    # Sets up an SSL context for +config+
-
-    def setup_ssl_context(config) # :nodoc:
-      unless config[:SSLCertificate]
-        cn = config[:SSLCertName]
-        comment = config[:SSLCertComment]
-        cert, key = Utils::create_self_signed_cert(2048, cn, comment)
-        config[:SSLCertificate] = cert
-        config[:SSLPrivateKey] = key
-      end
-      ctx = OpenSSL::SSL::SSLContext.new
-      ctx.key = config[:SSLPrivateKey]
-      ctx.cert = config[:SSLCertificate]
-      ctx.client_ca = config[:SSLClientCA]
-      ctx.extra_chain_cert = config[:SSLExtraChainCert]
-      ctx.ca_file = config[:SSLCACertificateFile]
-      ctx.ca_path = config[:SSLCACertificatePath]
-      ctx.cert_store = config[:SSLCertificateStore]
-      ctx.tmp_dh_callback = config[:SSLTmpDhCallback]
-      ctx.verify_mode = config[:SSLVerifyClient]
-      ctx.verify_depth = config[:SSLVerifyDepth]
-      ctx.verify_callback = config[:SSLVerifyCallback]
-      ctx.servername_cb = config[:SSLServerNameCallback] || proc { |args| ssl_servername_callback(*args) }
-      ctx.timeout = config[:SSLTimeout]
-      ctx.options = config[:SSLOptions]
-      ctx.ciphers = config[:SSLCiphers]
-      ctx
-    end
-
-    ##
-    # ServerNameIndication callback
-
-    def ssl_servername_callback(sslsocket, hostname = nil)
-      # default
-    end
-
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/utils.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/utils.rb
deleted file mode 100644
index a96d6f03fd049..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/utils.rb
+++ /dev/null
@@ -1,265 +0,0 @@
-# frozen_string_literal: false
-#
-# utils.rb -- Miscellaneous utilities
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
-# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: utils.rb,v 1.10 2003/02/16 22:22:54 gotoyuzo Exp $
-
-require 'socket'
-require 'io/nonblock'
-require 'etc'
-
-module WEBrick
-  module Utils
-    ##
-    # Sets IO operations on +io+ to be non-blocking
-    def set_non_blocking(io)
-      io.nonblock = true if io.respond_to?(:nonblock=)
-    end
-    module_function :set_non_blocking
-
-    ##
-    # Sets the close on exec flag for +io+
-    def set_close_on_exec(io)
-      io.close_on_exec = true if io.respond_to?(:close_on_exec=)
-    end
-    module_function :set_close_on_exec
-
-    ##
-    # Changes the process's uid and gid to the ones of +user+
-    def su(user)
-      if pw = Etc.getpwnam(user)
-        Process::initgroups(user, pw.gid)
-        Process::Sys::setgid(pw.gid)
-        Process::Sys::setuid(pw.uid)
-      else
-        warn("WEBrick::Utils::su doesn't work on this platform", uplevel: 1)
-      end
-    end
-    module_function :su
-
-    ##
-    # The server hostname
-    def getservername
-      Socket::gethostname
-    end
-    module_function :getservername
-
-    ##
-    # Creates TCP server sockets bound to +address+:+port+ and returns them.
-    #
-    # It will create IPV4 and IPV6 sockets on all interfaces.
-    def create_listeners(address, port)
-      unless port
-        raise ArgumentError, "must specify port"
-      end
-      sockets = Socket.tcp_server_sockets(address, port)
-      sockets = sockets.map {|s|
-        s.autoclose = false
-        ts = TCPServer.for_fd(s.fileno)
-        s.close
-        ts
-      }
-      return sockets
-    end
-    module_function :create_listeners
-
-    ##
-    # Characters used to generate random strings
-    RAND_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
-                 "0123456789" +
-                 "abcdefghijklmnopqrstuvwxyz"
-
-    ##
-    # Generates a random string of length +len+
-    def random_string(len)
-      rand_max = RAND_CHARS.bytesize
-      ret = ""
-      len.times{ ret << RAND_CHARS[rand(rand_max)] }
-      ret
-    end
-    module_function :random_string
-
-    ###########
-
-    require "timeout"
-    require "singleton"
-
-    ##
-    # Class used to manage timeout handlers across multiple threads.
-    #
-    # Timeout handlers should be managed by using the class methods which are
-    # synchronized.
-    #
-    #   id = TimeoutHandler.register(10, Timeout::Error)
-    #   begin
-    #     sleep 20
-    #     puts 'foo'
-    #   ensure
-    #     TimeoutHandler.cancel(id)
-    #   end
-    #
-    # will raise Timeout::Error
-    #
-    #   id = TimeoutHandler.register(10, Timeout::Error)
-    #   begin
-    #     sleep 5
-    #     puts 'foo'
-    #   ensure
-    #     TimeoutHandler.cancel(id)
-    #   end
-    #
-    # will print 'foo'
-    #
-    class TimeoutHandler
-      include Singleton
-
-      ##
-      # Mutex used to synchronize access across threads
-      TimeoutMutex = Thread::Mutex.new # :nodoc:
-
-      ##
-      # Registers a new timeout handler
-      #
-      # +time+:: Timeout in seconds
-      # +exception+:: Exception to raise when timeout elapsed
-      def TimeoutHandler.register(seconds, exception)
-        at = Process.clock_gettime(Process::CLOCK_MONOTONIC) + seconds
-        instance.register(Thread.current, at, exception)
-      end
-
-      ##
-      # Cancels the timeout handler +id+
-      def TimeoutHandler.cancel(id)
-        instance.cancel(Thread.current, id)
-      end
-
-      def self.terminate
-        instance.terminate
-      end
-
-      ##
-      # Creates a new TimeoutHandler.  You should use ::register and ::cancel
-      # instead of creating the timeout handler directly.
-      def initialize
-        TimeoutMutex.synchronize{
-          @timeout_info = Hash.new
-        }
-        @queue = Thread::Queue.new
-        @watcher = nil
-      end
-
-      # :nodoc:
-      private \
-        def watch
-          to_interrupt = []
-          while true
-            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-            wakeup = nil
-            to_interrupt.clear
-            TimeoutMutex.synchronize{
-              @timeout_info.each {|thread, ary|
-                next unless ary
-                ary.each{|info|
-                  time, exception = *info
-                  if time < now
-                    to_interrupt.push [thread, info.object_id, exception]
-                  elsif !wakeup || time < wakeup
-                    wakeup = time
-                  end
-                }
-              }
-            }
-            to_interrupt.each {|arg| interrupt(*arg)}
-            if !wakeup
-              @queue.pop
-            elsif (wakeup -= now) > 0
-              begin
-                (th = Thread.start {@queue.pop}).join(wakeup)
-              ensure
-                th&.kill&.join
-              end
-            end
-            @queue.clear
-          end
-        end
-
-      # :nodoc:
-      private \
-        def watcher
-          (w = @watcher)&.alive? and return w # usual case
-          TimeoutMutex.synchronize{
-            (w = @watcher)&.alive? and next w # pathological check
-            @watcher = Thread.start(&method(:watch))
-          }
-        end
-
-      ##
-      # Interrupts the timeout handler +id+ and raises +exception+
-      def interrupt(thread, id, exception)
-        if cancel(thread, id) && thread.alive?
-          thread.raise(exception, "execution timeout")
-        end
-      end
-
-      ##
-      # Registers a new timeout handler
-      #
-      # +time+:: Timeout in seconds
-      # +exception+:: Exception to raise when timeout elapsed
-      def register(thread, time, exception)
-        info = nil
-        TimeoutMutex.synchronize{
-          (@timeout_info[thread] ||= []) << (info = [time, exception])
-        }
-        @queue.push nil
-        watcher
-        return info.object_id
-      end
-
-      ##
-      # Cancels the timeout handler +id+
-      def cancel(thread, id)
-        TimeoutMutex.synchronize{
-          if ary = @timeout_info[thread]
-            ary.delete_if{|info| info.object_id == id }
-            if ary.empty?
-              @timeout_info.delete(thread)
-            end
-            return true
-          end
-          return false
-        }
-      end
-
-      ##
-      def terminate
-        TimeoutMutex.synchronize{
-          @timeout_info.clear
-          @watcher&.kill&.join
-        }
-      end
-    end
-
-    ##
-    # Executes the passed block and raises +exception+ if execution takes more
-    # than +seconds+.
-    #
-    # If +seconds+ is zero or nil, simply executes the block
-    def timeout(seconds, exception=Timeout::Error)
-      return yield if seconds.nil? or seconds.zero?
-      # raise ThreadError, "timeout within critical session" if Thread.critical
-      id = TimeoutHandler.register(seconds, exception)
-      begin
-        yield(seconds)
-      ensure
-        TimeoutHandler.cancel(id)
-      end
-    end
-    module_function :timeout
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/version.rb
deleted file mode 100644
index b62988bdbb5ec..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/webrick-1.7.0/lib/webrick/version.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-# frozen_string_literal: false
-#--
-# version.rb -- version and release date
-#
-# Author: IPR -- Internet Programming with Ruby -- writers
-# Copyright (c) 2000 TAKAHASHI Masayoshi, GOTOU YUUZOU
-# Copyright (c) 2003 Internet Programming with Ruby writers. All rights
-# reserved.
-#
-# $IPR: version.rb,v 1.74 2003/07/22 19:20:43 gotoyuzo Exp $
-
-module WEBrick
-
-  ##
-  # The WEBrick version
-
-  VERSION      = "1.7.0"
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk.rb
deleted file mode 100644
index 0f3e180b337fd..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk
-  require_relative "zeitwerk/real_mod_name"
-  require_relative "zeitwerk/loader"
-  require_relative "zeitwerk/gem_loader"
-  require_relative "zeitwerk/registry"
-  require_relative "zeitwerk/explicit_namespace"
-  require_relative "zeitwerk/inflector"
-  require_relative "zeitwerk/gem_inflector"
-  require_relative "zeitwerk/kernel"
-  require_relative "zeitwerk/error"
-  require_relative "zeitwerk/version"
-
-  # This is a dangerous method.
-  #
-  # @experimental
-  # @sig () -> void
-  def self.with_loader
-    loader = Zeitwerk::Loader.new
-    yield loader
-  ensure
-    loader.unregister
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/error.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/error.rb
deleted file mode 100644
index cfbbb8964a769..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/error.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk
-  class Error < StandardError
-  end
-
-  class ReloadingDisabledError < Error
-    def initialize
-      super("can't reload, please call loader.enable_reloading before setup")
-    end
-  end
-
-  class NameError < ::NameError
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/explicit_namespace.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/explicit_namespace.rb
deleted file mode 100644
index b363961b1e1e3..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/explicit_namespace.rb
+++ /dev/null
@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk
-  # Centralizes the logic for the trace point used to detect the creation of
-  # explicit namespaces, needed to descend into matching subdirectories right
-  # after the constant has been defined.
-  #
-  # The implementation assumes an explicit namespace is managed by one loader.
-  # Loaders that reopen namespaces owned by other projects are responsible for
-  # loading their constant before setup. This is documented.
-  module ExplicitNamespace # :nodoc: all
-    class << self
-      include RealModName
-
-      # Maps constant paths that correspond to explicit namespaces according to
-      # the file system, to the loader responsible for them.
-      #
-      # @private
-      # @sig Hash[String, Zeitwerk::Loader]
-      attr_reader :cpaths
-
-      # @private
-      # @sig Mutex
-      attr_reader :mutex
-
-      # @private
-      # @sig TracePoint
-      attr_reader :tracer
-
-      # Asserts `cpath` corresponds to an explicit namespace for which `loader`
-      # is responsible.
-      #
-      # @private
-      # @sig (String, Zeitwerk::Loader) -> void
-      def register(cpath, loader)
-        mutex.synchronize do
-          cpaths[cpath] = loader
-          # We check enabled? because, looking at the C source code, enabling an
-          # enabled tracer does not seem to be a simple no-op.
-          tracer.enable unless tracer.enabled?
-        end
-      end
-
-      # @private
-      # @sig (Zeitwerk::Loader) -> void
-      def unregister_loader(loader)
-        cpaths.delete_if { |_cpath, l| l == loader }
-        disable_tracer_if_unneeded
-      end
-
-      private
-
-      # @sig () -> void
-      def disable_tracer_if_unneeded
-        mutex.synchronize do
-          tracer.disable if cpaths.empty?
-        end
-      end
-
-      # @sig (TracePoint) -> void
-      def tracepoint_class_callback(event)
-        # If the class is a singleton class, we won't do anything with it so we
-        # can bail out immediately. This is several orders of magnitude faster
-        # than accessing its name.
-        return if event.self.singleton_class?
-
-        # It might be tempting to return if name.nil?, to avoid the computation
-        # of a hash code and delete call. But Ruby does not trigger the :class
-        # event on Class.new or Module.new, so that would incur in an extra call
-        # for nothing.
-        #
-        # On the other hand, if we were called, cpaths is not empty. Otherwise
-        # the tracer is disabled. So we do need to go ahead with the hash code
-        # computation and delete call.
-        if loader = cpaths.delete(real_mod_name(event.self))
-          loader.on_namespace_loaded(event.self)
-          disable_tracer_if_unneeded
-        end
-      end
-    end
-
-    @cpaths = {}
-    @mutex  = Mutex.new
-
-    # We go through a method instead of defining a block mainly to have a better
-    # label when profiling.
-    @tracer = TracePoint.new(:class, &method(:tracepoint_class_callback))
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/gem_inflector.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/gem_inflector.rb
deleted file mode 100644
index 8e59de591a896..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/gem_inflector.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk
-  class GemInflector < Inflector
-    # @sig (String) -> void
-    def initialize(root_file)
-      namespace     = File.basename(root_file, ".rb")
-      lib_dir       = File.dirname(root_file)
-      @version_file = File.join(lib_dir, namespace, "version.rb")
-    end
-
-    # @sig (String, String) -> String
-    def camelize(basename, abspath)
-      abspath == @version_file ? "VERSION" : super
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/gem_loader.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/gem_loader.rb
deleted file mode 100644
index cbbffc944c2c4..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/gem_loader.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk
-  # @private
-  class GemLoader < Loader
-    # Users should not create instances directly, the public interface is
-    # `Zeitwerk::Loader.for_gem`.
-    private_class_method :new
-
-    # @private
-    # @sig (String, bool) -> Zeitwerk::GemLoader
-    def self._new(root_file, warn_on_extra_files:)
-      new(root_file, warn_on_extra_files: warn_on_extra_files)
-    end
-
-    # @sig (String, bool) -> void
-    def initialize(root_file, warn_on_extra_files:)
-      super()
-
-      @tag                 = File.basename(root_file, ".rb")
-      @inflector           = GemInflector.new(root_file)
-      @root_file           = File.expand_path(root_file)
-      @lib                 = File.dirname(root_file)
-      @warn_on_extra_files = warn_on_extra_files
-
-      push_dir(@lib)
-    end
-
-    # @sig () -> void
-    def setup
-      warn_on_extra_files if @warn_on_extra_files
-      super
-    end
-
-    private
-
-    # @sig () -> void
-    def warn_on_extra_files
-      expected_namespace_dir = @root_file.delete_suffix(".rb")
-
-      ls(@lib) do |basename, abspath|
-        next if abspath == @root_file
-        next if abspath == expected_namespace_dir
-
-        basename_without_ext = basename.delete_suffix(".rb")
-        cname = inflector.camelize(basename_without_ext, abspath)
-        ftype = dir?(abspath) ? "directory" : "file"
-
-        warn(<<~EOS)
-          WARNING: Zeitwerk defines the constant #{cname} after the #{ftype}
-
-              #{abspath}
-
-          To prevent that, please configure the loader to ignore it:
-
-              loader.ignore("\#{__dir__}/#{basename}")
-
-          Otherwise, there is a flag to silence this warning:
-
-              Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
-        EOS
-      end
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/inflector.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/inflector.rb
deleted file mode 100644
index 8cac2df0f275f..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/inflector.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk
-  class Inflector
-    # Very basic snake case -> camel case conversion.
-    #
-    #   inflector = Zeitwerk::Inflector.new
-    #   inflector.camelize("post", ...)             # => "Post"
-    #   inflector.camelize("users_controller", ...) # => "UsersController"
-    #   inflector.camelize("api", ...)              # => "Api"
-    #
-    # Takes into account hard-coded mappings configured with `inflect`.
-    #
-    # @sig (String, String) -> String
-    def camelize(basename, _abspath)
-      overrides[basename] || basename.split('_').each(&:capitalize!).join
-    end
-
-    # Configures hard-coded inflections:
-    #
-    #   inflector = Zeitwerk::Inflector.new
-    #   inflector.inflect(
-    #     "html_parser"   => "HTMLParser",
-    #     "mysql_adapter" => "MySQLAdapter"
-    #   )
-    #
-    #   inflector.camelize("html_parser", abspath)      # => "HTMLParser"
-    #   inflector.camelize("mysql_adapter", abspath)    # => "MySQLAdapter"
-    #   inflector.camelize("users_controller", abspath) # => "UsersController"
-    #
-    # @sig (Hash[String, String]) -> void
-    def inflect(inflections)
-      overrides.merge!(inflections)
-    end
-
-    private
-
-    # Hard-coded basename to constant name user maps that override the default
-    # inflection logic.
-    #
-    # @sig () -> Hash[String, String]
-    def overrides
-      @overrides ||= {}
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/kernel.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/kernel.rb
deleted file mode 100644
index 3e2463ddb7f98..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/kernel.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module Kernel
-  module_function
-
-  # Zeitwerk's main idea is to define autoloads for project constants, and then
-  # intercept them when triggered in this thin `Kernel#require` wrapper.
-  #
-  # That allows us to complete the circle, invoke callbacks, autovivify modules,
-  # define autoloads for just autoloaded namespaces, update internal state, etc.
-  #
-  # On the other hand, if you publish a new version of a gem that is now managed
-  # by Zeitwerk, client code can reference directly your classes and modules and
-  # should not require anything. But if someone has legacy require calls around,
-  # they will work as expected, and in a compatible way. This feature is by now
-  # EXPERIMENTAL and UNDOCUMENTED.
-  #
-  # We cannot decorate with prepend + super because Kernel has already been
-  # included in Object, and changes in ancestors don't get propagated into
-  # already existing ancestor chains on Ruby < 3.0.
-  alias_method :zeitwerk_original_require, :require
-
-  # @sig (String) -> true | false
-  def require(path)
-    if loader = Zeitwerk::Registry.loader_for(path)
-      if path.end_with?(".rb")
-        required = zeitwerk_original_require(path)
-        loader.on_file_autoloaded(path) if required
-        required
-      else
-        loader.on_dir_autoloaded(path)
-        true
-      end
-    else
-      required = zeitwerk_original_require(path)
-      if required
-        abspath = $LOADED_FEATURES.last
-        if loader = Zeitwerk::Registry.loader_for(abspath)
-          loader.on_file_autoloaded(abspath)
-        end
-      end
-      required
-    end
-  end
-
-  # By now, I have seen no way so far to decorate require_relative.
-  #
-  # For starters, at least in CRuby, require_relative does not delegate to
-  # require. Both require and require_relative delegate the bulk of their work
-  # to an internal C function called rb_require_safe. So, our require wrapper is
-  # not executed.
-  #
-  # On the other hand, we cannot use the aliasing technique above because
-  # require_relative receives a path relative to the directory of the file in
-  # which the call is performed. If a wrapper here invoked the original method,
-  # Ruby would resolve the relative path taking lib/zeitwerk as base directory.
-  #
-  # A workaround could be to extract the base directory from caller_locations,
-  # but what if someone else decorated require_relative before us? You can't
-  # really know with certainty where's the original call site in the stack.
-  #
-  # However, the main use case for require_relative is to load files from your
-  # own project. Projects managed by Zeitwerk don't do this for files managed by
-  # Zeitwerk, precisely.
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/loader.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/loader.rb
deleted file mode 100644
index dc75497824ffc..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/loader.rb
+++ /dev/null
@@ -1,515 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-
-module Zeitwerk
-  class Loader
-    require_relative "loader/helpers"
-    require_relative "loader/callbacks"
-    require_relative "loader/config"
-
-    include RealModName
-    include Callbacks
-    include Helpers
-    include Config
-
-    MUTEX = Mutex.new
-    private_constant :MUTEX
-
-    # Maps absolute paths for which an autoload has been set ---and not
-    # executed--- to their corresponding parent class or module and constant
-    # name.
-    #
-    #   "/Users/fxn/blog/app/models/user.rb"          => [Object, :User],
-    #   "/Users/fxn/blog/app/models/hotel/pricing.rb" => [Hotel, :Pricing]
-    #   ...
-    #
-    # @private
-    # @sig Hash[String, [Module, Symbol]]
-    attr_reader :autoloads
-
-    # We keep track of autoloaded directories to remove them from the registry
-    # at the end of eager loading.
-    #
-    # Files are removed as they are autoloaded, but directories need to wait due
-    # to concurrency (see why in Zeitwerk::Loader::Callbacks#on_dir_autoloaded).
-    #
-    # @private
-    # @sig Array[String]
-    attr_reader :autoloaded_dirs
-
-    # Stores metadata needed for unloading. Its entries look like this:
-    #
-    #   "Admin::Role" => [".../admin/role.rb", [Admin, :Role]]
-    #
-    # The cpath as key helps implementing unloadable_cpath? The file name is
-    # stored in order to be able to delete it from $LOADED_FEATURES, and the
-    # pair [Module, Symbol] is used to remove_const the constant from the class
-    # or module object.
-    #
-    # If reloading is enabled, this hash is filled as constants are autoloaded
-    # or eager loaded. Otherwise, the collection remains empty.
-    #
-    # @private
-    # @sig Hash[String, [String, [Module, Symbol]]]
-    attr_reader :to_unload
-
-    # Maps constant paths of namespaces to arrays of corresponding directories.
-    #
-    # For example, given this mapping:
-    #
-    #   "Admin" => [
-    #     "/Users/fxn/blog/app/controllers/admin",
-    #     "/Users/fxn/blog/app/models/admin",
-    #     ...
-    #   ]
-    #
-    # when `Admin` gets defined we know that it plays the role of a namespace and
-    # that its children are spread over those directories. We'll visit them to set
-    # up the corresponding autoloads.
-    #
-    # @private
-    # @sig Hash[String, Array[String]]
-    attr_reader :lazy_subdirs
-
-    # @private
-    # @sig Mutex
-    attr_reader :mutex
-
-    # @private
-    # @sig Mutex
-    attr_reader :mutex2
-
-    def initialize
-      super
-
-      @autoloads       = {}
-      @autoloaded_dirs = []
-      @to_unload       = {}
-      @lazy_subdirs    = Hash.new { |h, cpath| h[cpath] = [] }
-      @mutex           = Mutex.new
-      @mutex2          = Mutex.new
-      @setup           = false
-      @eager_loaded    = false
-
-      Registry.register_loader(self)
-    end
-
-    # Sets autoloads in the root namespace.
-    #
-    # @sig () -> void
-    def setup
-      mutex.synchronize do
-        break if @setup
-
-        actual_root_dirs.each do |root_dir, namespace|
-          set_autoloads_in_dir(root_dir, namespace)
-        end
-
-        on_setup_callbacks.each(&:call)
-
-        @setup = true
-      end
-    end
-
-    # Removes loaded constants and configured autoloads.
-    #
-    # The objects the constants stored are no longer reachable through them. In
-    # addition, since said objects are normally not referenced from anywhere
-    # else, they are eligible for garbage collection, which would effectively
-    # unload them.
-    #
-    # This method is public but undocumented. Main interface is `reload`, which
-    # means `unload` + `setup`. This one is avaiable to be used together with
-    # `unregister`, which is undocumented too.
-    #
-    # @sig () -> void
-    def unload
-      mutex.synchronize do
-        # We are going to keep track of the files that were required by our
-        # autoloads to later remove them from $LOADED_FEATURES, thus making them
-        # loadable by Kernel#require again.
-        #
-        # Directories are not stored in $LOADED_FEATURES, keeping track of files
-        # is enough.
-        unloaded_files = Set.new
-
-        autoloads.each do |abspath, (parent, cname)|
-          if parent.autoload?(cname)
-            unload_autoload(parent, cname)
-          else
-            # Could happen if loaded with require_relative. That is unsupported,
-            # and the constant path would escape unloadable_cpath? This is just
-            # defensive code to clean things up as much as we are able to.
-            unload_cref(parent, cname)
-            unloaded_files.add(abspath) if ruby?(abspath)
-          end
-        end
-
-        to_unload.each do |cpath, (abspath, (parent, cname))|
-          unless on_unload_callbacks.empty?
-            begin
-              value = cget(parent, cname)
-            rescue ::NameError
-              # Perhaps the user deleted the constant by hand, or perhaps an
-              # autoload failed to define the expected constant but the user
-              # rescued the exception.
-            else
-              run_on_unload_callbacks(cpath, value, abspath)
-            end
-          end
-
-          unload_cref(parent, cname)
-          unloaded_files.add(abspath) if ruby?(abspath)
-        end
-
-        unless unloaded_files.empty?
-          # Bootsnap decorates Kernel#require to speed it up using a cache and
-          # this optimization does not check if $LOADED_FEATURES has the file.
-          #
-          # To make it aware of changes, the gem defines singleton methods in
-          # $LOADED_FEATURES:
-          #
-          #   https://github.com/Shopify/bootsnap/blob/master/lib/bootsnap/load_path_cache/core_ext/loaded_features.rb
-          #
-          # Rails applications may depend on bootsnap, so for unloading to work
-          # in that setting it is preferable that we restrict our API choice to
-          # one of those methods.
-          $LOADED_FEATURES.reject! { |file| unloaded_files.member?(file) }
-        end
-
-        autoloads.clear
-        autoloaded_dirs.clear
-        to_unload.clear
-        lazy_subdirs.clear
-
-        Registry.on_unload(self)
-        ExplicitNamespace.unregister_loader(self)
-
-        @setup        = false
-        @eager_loaded = false
-      end
-    end
-
-    # Unloads all loaded code, and calls setup again so that the loader is able
-    # to pick any changes in the file system.
-    #
-    # This method is not thread-safe, please see how this can be achieved by
-    # client code in the README of the project.
-    #
-    # @raise [Zeitwerk::Error]
-    # @sig () -> void
-    def reload
-      raise ReloadingDisabledError unless reloading_enabled?
-
-      unload
-      recompute_ignored_paths
-      recompute_collapse_dirs
-      setup
-    end
-
-    # Eager loads all files in the root directories, recursively. Files do not
-    # need to be in `$LOAD_PATH`, absolute file names are used. Ignored files
-    # are not eager loaded. You can opt-out specifically in specific files and
-    # directories with `do_not_eager_load`, and that can be overridden passing
-    # `force: true`.
-    #
-    # @sig (true | false) -> void
-    def eager_load(force: false)
-      mutex.synchronize do
-        break if @eager_loaded
-
-        log("eager load start") if logger
-
-        honour_exclusions = !force
-
-        queue = []
-        actual_root_dirs.each do |root_dir, namespace|
-          queue << [namespace, root_dir] unless honour_exclusions && excluded_from_eager_load?(root_dir)
-        end
-
-        while to_eager_load = queue.shift
-          namespace, dir = to_eager_load
-
-          ls(dir) do |basename, abspath|
-            next if honour_exclusions && excluded_from_eager_load?(abspath)
-
-            if ruby?(abspath)
-              if cref = autoloads[abspath]
-                cget(*cref)
-              end
-            elsif !root_dirs.key?(abspath)
-              if collapse?(abspath)
-                queue << [namespace, abspath]
-              else
-                cname = inflector.camelize(basename, abspath)
-                queue << [cget(namespace, cname), abspath]
-              end
-            end
-          end
-        end
-
-        autoloaded_dirs.each do |autoloaded_dir|
-          Registry.unregister_autoload(autoloaded_dir)
-        end
-        autoloaded_dirs.clear
-
-        @eager_loaded = true
-
-        log("eager load end") if logger
-      end
-    end
-
-    # Says if the given constant path would be unloaded on reload. This
-    # predicate returns `false` if reloading is disabled.
-    #
-    # @sig (String) -> bool
-    def unloadable_cpath?(cpath)
-      to_unload.key?(cpath)
-    end
-
-    # Returns an array with the constant paths that would be unloaded on reload.
-    # This predicate returns an empty array if reloading is disabled.
-    #
-    # @sig () -> Array[String]
-    def unloadable_cpaths
-      to_unload.keys.freeze
-    end
-
-    # This is a dangerous method.
-    #
-    # @experimental
-    # @sig () -> void
-    def unregister
-      Registry.unregister_loader(self)
-      ExplicitNamespace.unregister_loader(self)
-    end
-
-    # --- Class methods ---------------------------------------------------------------------------
-
-    class << self
-      # @sig #call | #debug | nil
-      attr_accessor :default_logger
-
-      # This is a shortcut for
-      #
-      #   require "zeitwerk"
-      #   loader = Zeitwerk::Loader.new
-      #   loader.tag = File.basename(__FILE__, ".rb")
-      #   loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
-      #   loader.push_dir(__dir__)
-      #
-      # except that this method returns the same object in subsequent calls from
-      # the same file, in the unlikely case the gem wants to be able to reload.
-      #
-      # This method returns a subclass of Zeitwerk::Loader, but the exact type
-      # is private, client code can only rely on the interface.
-      #
-      # @sig (bool) -> Zeitwerk::GemLoader
-      def for_gem(warn_on_extra_files: true)
-        called_from = caller_locations(1, 1).first.path
-        Registry.loader_for_gem(called_from, warn_on_extra_files: warn_on_extra_files)
-      end
-
-      # Broadcasts `eager_load` to all loaders.
-      #
-      # @sig () -> void
-      def eager_load_all
-        Registry.loaders.each(&:eager_load)
-      end
-
-      # Returns an array with the absolute paths of the root directories of all
-      # registered loaders. This is a read-only collection.
-      #
-      # @sig () -> Array[String]
-      def all_dirs
-        Registry.loaders.flat_map(&:dirs).freeze
-      end
-    end
-
-    private # -------------------------------------------------------------------------------------
-
-    # @sig (String, Module) -> void
-    def set_autoloads_in_dir(dir, parent)
-      ls(dir) do |basename, abspath|
-        begin
-          if ruby?(basename)
-            basename.delete_suffix!(".rb")
-            cname = inflector.camelize(basename, abspath).to_sym
-            autoload_file(parent, cname, abspath)
-          else
-            # In a Rails application, `app/models/concerns` is a subdirectory of
-            # `app/models`, but both of them are root directories.
-            #
-            # To resolve the ambiguity file name -> constant path this introduces,
-            # the `app/models/concerns` directory is totally ignored as a namespace,
-            # it counts only as root. The guard checks that.
-            unless root_dir?(abspath)
-              cname = inflector.camelize(basename, abspath).to_sym
-              if collapse?(abspath)
-                set_autoloads_in_dir(abspath, parent)
-              else
-                autoload_subdir(parent, cname, abspath)
-              end
-            end
-          end
-        rescue ::NameError => error
-          path_type = ruby?(abspath) ? "file" : "directory"
-
-          raise NameError.new(<<~MESSAGE, error.name)
-            #{error.message} inferred by #{inflector.class} from #{path_type}
-
-              #{abspath}
-
-            Possible ways to address this:
-
-              * Tell Zeitwerk to ignore this particular #{path_type}.
-              * Tell Zeitwerk to ignore one of its parent directories.
-              * Rename the #{path_type} to comply with the naming conventions.
-              * Modify the inflector to handle this case.
-          MESSAGE
-        end
-      end
-    end
-
-    # @sig (Module, Symbol, String) -> void
-    def autoload_subdir(parent, cname, subdir)
-      if autoload_path = autoload_path_set_by_me_for?(parent, cname)
-        cpath = cpath(parent, cname)
-        register_explicit_namespace(cpath) if ruby?(autoload_path)
-        # We do not need to issue another autoload, the existing one is enough
-        # no matter if it is for a file or a directory. Just remember the
-        # subdirectory has to be visited if the namespace is used.
-        lazy_subdirs[cpath] << subdir
-      elsif !cdef?(parent, cname)
-        # First time we find this namespace, set an autoload for it.
-        lazy_subdirs[cpath(parent, cname)] << subdir
-        set_autoload(parent, cname, subdir)
-      else
-        # For whatever reason the constant that corresponds to this namespace has
-        # already been defined, we have to recurse.
-        log("the namespace #{cpath(parent, cname)} already exists, descending into #{subdir}") if logger
-        set_autoloads_in_dir(subdir, cget(parent, cname))
-      end
-    end
-
-    # @sig (Module, Symbol, String) -> void
-    def autoload_file(parent, cname, file)
-      if autoload_path = strict_autoload_path(parent, cname) || Registry.inception?(cpath(parent, cname))
-        # First autoload for a Ruby file wins, just ignore subsequent ones.
-        if ruby?(autoload_path)
-          log("file #{file} is ignored because #{autoload_path} has precedence") if logger
-        else
-          promote_namespace_from_implicit_to_explicit(
-            dir:    autoload_path,
-            file:   file,
-            parent: parent,
-            cname:  cname
-          )
-        end
-      elsif cdef?(parent, cname)
-        log("file #{file} is ignored because #{cpath(parent, cname)} is already defined") if logger
-      else
-        set_autoload(parent, cname, file)
-      end
-    end
-
-    # `dir` is the directory that would have autovivified a namespace. `file` is
-    # the file where we've found the namespace is explicitly defined.
-    #
-    # @sig (dir: String, file: String, parent: Module, cname: Symbol) -> void
-    def promote_namespace_from_implicit_to_explicit(dir:, file:, parent:, cname:)
-      autoloads.delete(dir)
-      Registry.unregister_autoload(dir)
-
-      log("earlier autoload for #{cpath(parent, cname)} discarded, it is actually an explicit namespace defined in #{file}") if logger
-
-      set_autoload(parent, cname, file)
-      register_explicit_namespace(cpath(parent, cname))
-    end
-
-    # @sig (Module, Symbol, String) -> void
-    def set_autoload(parent, cname, abspath)
-      parent.autoload(cname, abspath)
-
-      if logger
-        if ruby?(abspath)
-          log("autoload set for #{cpath(parent, cname)}, to be loaded from #{abspath}")
-        else
-          log("autoload set for #{cpath(parent, cname)}, to be autovivified from #{abspath}")
-        end
-      end
-
-      autoloads[abspath] = [parent, cname]
-      Registry.register_autoload(self, abspath)
-
-      # See why in the documentation of Zeitwerk::Registry.inceptions.
-      unless parent.autoload?(cname)
-        Registry.register_inception(cpath(parent, cname), abspath, self)
-      end
-    end
-
-    # @sig (Module, Symbol) -> String?
-    def autoload_path_set_by_me_for?(parent, cname)
-      if autoload_path = strict_autoload_path(parent, cname)
-        autoload_path if autoloads.key?(autoload_path)
-      else
-        Registry.inception?(cpath(parent, cname))
-      end
-    end
-
-    # @sig (String) -> void
-    def register_explicit_namespace(cpath)
-      ExplicitNamespace.register(cpath, self)
-    end
-
-    # @sig (String) -> void
-    def raise_if_conflicting_directory(dir)
-      MUTEX.synchronize do
-        Registry.loaders.each do |loader|
-          next if loader == self
-          next if loader.ignores?(dir)
-
-          dir = dir + "/"
-          loader.root_dirs.each do |root_dir, _namespace|
-            next if ignores?(root_dir)
-
-            root_dir = root_dir + "/"
-            if dir.start_with?(root_dir) || root_dir.start_with?(dir)
-              require "pp" # Needed for pretty_inspect, even in Ruby 2.5.
-              raise Error,
-                "loader\n\n#{pretty_inspect}\n\nwants to manage directory #{dir.chop}," \
-                " which is already managed by\n\n#{loader.pretty_inspect}\n"
-              EOS
-            end
-          end
-        end
-      end
-    end
-
-    # @sig (String, Object, String) -> void
-    def run_on_unload_callbacks(cpath, value, abspath)
-      # Order matters. If present, run the most specific one.
-      on_unload_callbacks[cpath]&.each { |c| c.call(value, abspath) }
-      on_unload_callbacks[:ANY]&.each { |c| c.call(cpath, value, abspath) }
-    end
-
-    # @sig (Module, Symbol) -> void
-    def unload_autoload(parent, cname)
-      parent.__send__(:remove_const, cname)
-      log("autoload for #{cpath(parent, cname)} removed") if logger
-    end
-
-    # @sig (Module, Symbol) -> void
-    def unload_cref(parent, cname)
-      # Let's optimistically remove_const. The way we use it, this is going to
-      # succeed always if all is good.
-      parent.__send__(:remove_const, cname)
-    rescue ::NameError
-      # There are a few edge scenarios in which this may happen. If the constant
-      # is gone, that is OK, anyway.
-    else
-      log("#{cpath(parent, cname)} unloaded") if logger
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/loader/callbacks.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/loader/callbacks.rb
deleted file mode 100644
index 5ec2758ae25bb..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/loader/callbacks.rb
+++ /dev/null
@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk::Loader::Callbacks
-  include Zeitwerk::RealModName
-
-  # Invoked from our decorated Kernel#require when a managed file is autoloaded.
-  #
-  # @private
-  # @sig (String) -> void
-  def on_file_autoloaded(file)
-    cref  = autoloads.delete(file)
-    cpath = cpath(*cref)
-
-    # If reloading is enabled, we need to put this constant for unloading
-    # regardless of what cdef? says. In Ruby < 3.1 the internal state is not
-    # fully cleared. Module#constants still includes it, and you need to
-    # remove_const. See https://github.com/ruby/ruby/pull/4715.
-    to_unload[cpath] = [file, cref] if reloading_enabled?
-    Zeitwerk::Registry.unregister_autoload(file)
-
-    if cdef?(*cref)
-      log("constant #{cpath} loaded from file #{file}") if logger
-      run_on_load_callbacks(cpath, cget(*cref), file) unless on_load_callbacks.empty?
-    else
-      raise Zeitwerk::NameError.new("expected file #{file} to define constant #{cpath}, but didn't", cref.last)
-    end
-  end
-
-  # Invoked from our decorated Kernel#require when a managed directory is
-  # autoloaded.
-  #
-  # @private
-  # @sig (String) -> void
-  def on_dir_autoloaded(dir)
-    # Module#autoload does not serialize concurrent requires, and we handle
-    # directories ourselves, so the callback needs to account for concurrency.
-    #
-    # Multi-threading would introduce a race condition here in which thread t1
-    # autovivifies the module, and while autoloads for its children are being
-    # set, thread t2 autoloads the same namespace.
-    #
-    # Without the mutex and subsequent delete call, t2 would reset the module.
-    # That not only would reassign the constant (undesirable per se) but, worse,
-    # the module object created by t2 wouldn't have any of the autoloads for its
-    # children, since t1 would have correctly deleted its lazy_subdirs entry.
-    mutex2.synchronize do
-      if cref = autoloads.delete(dir)
-        autovivified_module = cref[0].const_set(cref[1], Module.new)
-        cpath = autovivified_module.name
-        log("module #{cpath} autovivified from directory #{dir}") if logger
-
-        to_unload[cpath] = [dir, cref] if reloading_enabled?
-
-        # We don't unregister `dir` in the registry because concurrent threads
-        # wouldn't find a loader associated to it in Kernel#require and would
-        # try to require the directory. Instead, we are going to keep track of
-        # these to be able to unregister later if eager loading.
-        autoloaded_dirs << dir
-
-        on_namespace_loaded(autovivified_module)
-
-        run_on_load_callbacks(cpath, autovivified_module, dir) unless on_load_callbacks.empty?
-      end
-    end
-  end
-
-  # Invoked when a class or module is created or reopened, either from the
-  # tracer or from module autovivification. If the namespace has matching
-  # subdirectories, we descend into them now.
-  #
-  # @private
-  # @sig (Module) -> void
-  def on_namespace_loaded(namespace)
-    if subdirs = lazy_subdirs.delete(real_mod_name(namespace))
-      subdirs.each do |subdir|
-        set_autoloads_in_dir(subdir, namespace)
-      end
-    end
-  end
-
-  private
-
-  # @sig (String, Object) -> void
-  def run_on_load_callbacks(cpath, value, abspath)
-    # Order matters. If present, run the most specific one.
-    callbacks = reloading_enabled? ? on_load_callbacks[cpath] : on_load_callbacks.delete(cpath)
-    callbacks&.each { |c| c.call(value, abspath) }
-
-    callbacks = on_load_callbacks[:ANY]
-    callbacks&.each { |c| c.call(cpath, value, abspath) }
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/loader/config.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/loader/config.rb
deleted file mode 100644
index f121fa9840fac..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/loader/config.rb
+++ /dev/null
@@ -1,320 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-require "securerandom"
-
-module Zeitwerk::Loader::Config
-  # Absolute paths of the root directories. Stored in a hash to preserve
-  # order, easily handle duplicates, and also be able to have a fast lookup,
-  # needed for detecting nested paths.
-  #
-  #   "/Users/fxn/blog/app/assets"   => true,
-  #   "/Users/fxn/blog/app/channels" => true,
-  #   ...
-  #
-  # This is a private collection maintained by the loader. The public
-  # interface for it is `push_dir` and `dirs`.
-  #
-  # @private
-  # @sig Hash[String, true]
-  attr_reader :root_dirs
-
-  # @sig #camelize
-  attr_accessor :inflector
-
-  # Absolute paths of files, directories, or glob patterns to be totally
-  # ignored.
-  #
-  # @private
-  # @sig Set[String]
-  attr_reader :ignored_glob_patterns
-
-  # The actual collection of absolute file and directory names at the time the
-  # ignored glob patterns were expanded. Computed on setup, and recomputed on
-  # reload.
-  #
-  # @private
-  # @sig Set[String]
-  attr_reader :ignored_paths
-
-  # Absolute paths of directories or glob patterns to be collapsed.
-  #
-  # @private
-  # @sig Set[String]
-  attr_reader :collapse_glob_patterns
-
-  # The actual collection of absolute directory names at the time the collapse
-  # glob patterns were expanded. Computed on setup, and recomputed on reload.
-  #
-  # @private
-  # @sig Set[String]
-  attr_reader :collapse_dirs
-
-  # Absolute paths of files or directories not to be eager loaded.
-  #
-  # @private
-  # @sig Set[String]
-  attr_reader :eager_load_exclusions
-
-  # User-oriented callbacks to be fired on setup and on reload.
-  #
-  # @private
-  # @sig Array[{ () -> void }]
-  attr_reader :on_setup_callbacks
-
-  # User-oriented callbacks to be fired when a constant is loaded.
-  #
-  # @private
-  # @sig Hash[String, Array[{ (Object, String) -> void }]]
-  #      Hash[Symbol, Array[{ (String, Object, String) -> void }]]
-  attr_reader :on_load_callbacks
-
-  # User-oriented callbacks to be fired before constants are removed.
-  #
-  # @private
-  # @sig Hash[String, Array[{ (Object, String) -> void }]]
-  #      Hash[Symbol, Array[{ (String, Object, String) -> void }]]
-  attr_reader :on_unload_callbacks
-
-  # @sig #call | #debug | nil
-  attr_accessor :logger
-
-  def initialize
-    @initialized_at         = Time.now
-    @root_dirs              = {}
-    @inflector              = Zeitwerk::Inflector.new
-    @ignored_glob_patterns  = Set.new
-    @ignored_paths          = Set.new
-    @collapse_glob_patterns = Set.new
-    @collapse_dirs          = Set.new
-    @eager_load_exclusions  = Set.new
-    @reloading_enabled      = false
-    @on_setup_callbacks     = []
-    @on_load_callbacks      = {}
-    @on_unload_callbacks    = {}
-    @logger                 = self.class.default_logger
-    @tag                    = SecureRandom.hex(3)
-  end
-
-  # Pushes `path` to the list of root directories.
-  #
-  # Raises `Zeitwerk::Error` if `path` does not exist, or if another loader in
-  # the same process already manages that directory or one of its ascendants or
-  # descendants.
-  #
-  # @raise [Zeitwerk::Error]
-  # @sig (String | Pathname, Module) -> void
-  def push_dir(path, namespace: Object)
-    # Note that Class < Module.
-    unless namespace.is_a?(Module)
-      raise Zeitwerk::Error, "#{namespace.inspect} is not a class or module object, should be"
-    end
-
-    abspath = File.expand_path(path)
-    if dir?(abspath)
-      raise_if_conflicting_directory(abspath)
-      root_dirs[abspath] = namespace
-    else
-      raise Zeitwerk::Error, "the root directory #{abspath} does not exist"
-    end
-  end
-
-  # Returns the loader's tag.
-  #
-  # Implemented as a method instead of via attr_reader for symmetry with the
-  # writer below.
-  #
-  # @sig () -> String
-  def tag
-    @tag
-  end
-
-  # Sets a tag for the loader, useful for logging.
-  #
-  # @sig (#to_s) -> void
-  def tag=(tag)
-    @tag = tag.to_s
-  end
-
-  # Absolute paths of the root directories. This is a read-only collection,
-  # please push here via `push_dir`.
-  #
-  # @sig () -> Array[String]
-  def dirs
-    root_dirs.keys.freeze
-  end
-
-  # You need to call this method before setup in order to be able to reload.
-  # There is no way to undo this, either you want to reload or you don't.
-  #
-  # @raise [Zeitwerk::Error]
-  # @sig () -> void
-  def enable_reloading
-    mutex.synchronize do
-      break if @reloading_enabled
-
-      if @setup
-        raise Zeitwerk::Error, "cannot enable reloading after setup"
-      else
-        @reloading_enabled = true
-      end
-    end
-  end
-
-  # @sig () -> bool
-  def reloading_enabled?
-    @reloading_enabled
-  end
-
-  # Let eager load ignore the given files or directories. The constants defined
-  # in those files are still autoloadable.
-  #
-  # @sig (*(String | Pathname | Array[String | Pathname])) -> void
-  def do_not_eager_load(*paths)
-    mutex.synchronize { eager_load_exclusions.merge(expand_paths(paths)) }
-  end
-
-  # Configure files, directories, or glob patterns to be totally ignored.
-  #
-  # @sig (*(String | Pathname | Array[String | Pathname])) -> void
-  def ignore(*glob_patterns)
-    glob_patterns = expand_paths(glob_patterns)
-    mutex.synchronize do
-      ignored_glob_patterns.merge(glob_patterns)
-      ignored_paths.merge(expand_glob_patterns(glob_patterns))
-    end
-  end
-
-  # Configure directories or glob patterns to be collapsed.
-  #
-  # @sig (*(String | Pathname | Array[String | Pathname])) -> void
-  def collapse(*glob_patterns)
-    glob_patterns = expand_paths(glob_patterns)
-    mutex.synchronize do
-      collapse_glob_patterns.merge(glob_patterns)
-      collapse_dirs.merge(expand_glob_patterns(glob_patterns))
-    end
-  end
-
-  # Configure a block to be called after setup and on each reload.
-  # If setup was already done, the block runs immediately.
-  #
-  # @sig () { () -> void } -> void
-  def on_setup(&block)
-    mutex.synchronize do
-      on_setup_callbacks << block
-      block.call if @setup
-    end
-  end
-
-  # Configure a block to be invoked once a certain constant path is loaded.
-  # Supports multiple callbacks, and if there are many, they are executed in
-  # the order in which they were defined.
-  #
-  #   loader.on_load("SomeApiClient") do |klass, _abspath|
-  #     klass.endpoint = "https://api.dev"
-  #   end
-  #
-  # Can also be configured for any constant loaded:
-  #
-  #   loader.on_load do |cpath, value, abspath|
-  #     # ...
-  #   end
-  #
-  # @raise [TypeError]
-  # @sig (String) { (Object, String) -> void } -> void
-  #      (:ANY) { (String, Object, String) -> void } -> void
-  def on_load(cpath = :ANY, &block)
-    raise TypeError, "on_load only accepts strings" unless cpath.is_a?(String) || cpath == :ANY
-
-    mutex.synchronize do
-      (on_load_callbacks[cpath] ||= []) << block
-    end
-  end
-
-  # Configure a block to be invoked right before a certain constant is removed.
-  # Supports multiple callbacks, and if there are many, they are executed in the
-  # order in which they were defined.
-  #
-  #   loader.on_unload("Country") do |klass, _abspath|
-  #     klass.clear_cache
-  #   end
-  #
-  # Can also be configured for any removed constant:
-  #
-  #   loader.on_unload do |cpath, value, abspath|
-  #     # ...
-  #   end
-  #
-  # @raise [TypeError]
-  # @sig (String) { (Object) -> void } -> void
-  #      (:ANY) { (String, Object) -> void } -> void
-  def on_unload(cpath = :ANY, &block)
-    raise TypeError, "on_unload only accepts strings" unless cpath.is_a?(String) || cpath == :ANY
-
-    mutex.synchronize do
-      (on_unload_callbacks[cpath] ||= []) << block
-    end
-  end
-
-  # Logs to `$stdout`, handy shortcut for debugging.
-  #
-  # @sig () -> void
-  def log!
-    @logger = ->(msg) { puts msg }
-  end
-
-  # @private
-  # @sig (String) -> bool
-  def ignores?(abspath)
-    ignored_paths.any? do |ignored_path|
-      ignored_path == abspath || (dir?(ignored_path) && abspath.start_with?(ignored_path + "/"))
-    end
-  end
-
-  private
-
-  # @sig () -> Array[String]
-  def actual_root_dirs
-    root_dirs.reject do |root_dir, _namespace|
-      !dir?(root_dir) || ignored_paths.member?(root_dir)
-    end
-  end
-
-  # @sig (String) -> bool
-  def root_dir?(dir)
-    root_dirs.key?(dir)
-  end
-
-  # @sig (String) -> bool
-  def excluded_from_eager_load?(abspath)
-    eager_load_exclusions.member?(abspath)
-  end
-
-  # @sig (String) -> bool
-  def collapse?(dir)
-    collapse_dirs.member?(dir)
-  end
-
-  # @sig (String | Pathname | Array[String | Pathname]) -> Array[String]
-  def expand_paths(paths)
-    paths.flatten.map! { |path| File.expand_path(path) }
-  end
-
-  # @sig (Array[String]) -> Array[String]
-  def expand_glob_patterns(glob_patterns)
-    # Note that Dir.glob works with regular file names just fine. That is,
-    # glob patterns technically need no wildcards.
-    glob_patterns.flat_map { |glob_pattern| Dir.glob(glob_pattern) }
-  end
-
-  # @sig () -> void
-  def recompute_ignored_paths
-    ignored_paths.replace(expand_glob_patterns(ignored_glob_patterns))
-  end
-
-  # @sig () -> void
-  def recompute_collapse_dirs
-    collapse_dirs.replace(expand_glob_patterns(collapse_glob_patterns))
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/loader/helpers.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/loader/helpers.rb
deleted file mode 100644
index 117167180b55b..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/loader/helpers.rb
+++ /dev/null
@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk::Loader::Helpers
-  private
-
-  # --- Logging -----------------------------------------------------------------------------------
-
-  # @sig (String) -> void
-  def log(message)
-    method_name = logger.respond_to?(:debug) ? :debug : :call
-    logger.send(method_name, "Zeitwerk@#{tag}: #{message}")
-  end
-
-  # --- Files and directories ---------------------------------------------------------------------
-
-  # @sig (String) { (String, String) -> void } -> void
-  def ls(dir)
-    children = Dir.children(dir)
-
-    # The order in which a directory is listed depends on the file system.
-    #
-    # Since client code may run in different platforms, it seems convenient to
-    # order directory entries. This provides consistent eager loading across
-    # platforms, for example.
-    children.sort!
-
-    children.each do |basename|
-      next if hidden?(basename)
-
-      abspath = File.join(dir, basename)
-      next if ignored_paths.member?(abspath)
-
-      if dir?(abspath)
-        next unless has_at_least_one_ruby_file?(abspath)
-      else
-        next unless ruby?(abspath)
-      end
-
-      # We freeze abspath because that saves allocations when passed later to
-      # File methods. See #125.
-      yield basename, abspath.freeze
-    end
-  end
-
-  # @sig (String) -> bool
-  def has_at_least_one_ruby_file?(dir)
-    to_visit = [dir]
-
-    while dir = to_visit.shift
-      ls(dir) do |_basename, abspath|
-        if dir?(abspath)
-          to_visit << abspath
-        else
-          return true
-        end
-      end
-    end
-
-    false
-  end
-
-  # @sig (String) -> bool
-  def ruby?(path)
-    path.end_with?(".rb")
-  end
-
-  # @sig (String) -> bool
-  def dir?(path)
-    File.directory?(path)
-  end
-
-  # @sig (String) -> bool
-  def hidden?(basename)
-    basename.start_with?(".")
-  end
-
-  # --- Constants ---------------------------------------------------------------------------------
-
-  # The autoload? predicate takes into account the ancestor chain of the
-  # receiver, like const_defined? and other methods in the constants API do.
-  #
-  # For example, given
-  #
-  #   class A
-  #     autoload :X, "x.rb"
-  #   end
-  #
-  #   class B < A
-  #   end
-  #
-  # B.autoload?(:X) returns "x.rb".
-  #
-  # We need a way to strictly check in parent ignoring ancestors.
-  #
-  # @sig (Module, Symbol) -> String?
-  if method(:autoload?).arity == 1
-    def strict_autoload_path(parent, cname)
-      parent.autoload?(cname) if cdef?(parent, cname)
-    end
-  else
-    def strict_autoload_path(parent, cname)
-      parent.autoload?(cname, false)
-    end
-  end
-
-  # @sig (Module, Symbol) -> String
-  if Symbol.method_defined?(:name)
-    # Symbol#name was introduced in Ruby 3.0. It returns always the same
-    # frozen object, so we may save a few string allocations.
-    def cpath(parent, cname)
-      Object == parent ? cname.name : "#{real_mod_name(parent)}::#{cname.name}"
-    end
-  else
-    def cpath(parent, cname)
-      Object == parent ? cname.to_s : "#{real_mod_name(parent)}::#{cname}"
-    end
-  end
-
-  # @sig (Module, Symbol) -> bool
-  def cdef?(parent, cname)
-    parent.const_defined?(cname, false)
-  end
-
-  # @raise [NameError]
-  # @sig (Module, Symbol) -> Object
-  def cget(parent, cname)
-    parent.const_get(cname, false)
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/real_mod_name.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/real_mod_name.rb
deleted file mode 100644
index 326a6194db973..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/real_mod_name.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk::RealModName
-  UNBOUND_METHOD_MODULE_NAME = Module.instance_method(:name)
-  private_constant :UNBOUND_METHOD_MODULE_NAME
-
-  # Returns the real name of the class or module, as set after the first
-  # constant to which it was assigned (or nil).
-  #
-  # The name method can be overridden, hence the indirection in this method.
-  #
-  # @sig (Module) -> String?
-  if UnboundMethod.method_defined?(:bind_call)
-    def real_mod_name(mod)
-      UNBOUND_METHOD_MODULE_NAME.bind_call(mod)
-    end
-  else
-    def real_mod_name(mod)
-      UNBOUND_METHOD_MODULE_NAME.bind(mod).call
-    end
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/registry.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/registry.rb
deleted file mode 100644
index f6d15b05df6c7..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/registry.rb
+++ /dev/null
@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk
-  module Registry # :nodoc: all
-    class << self
-      # Keeps track of all loaders. Useful to broadcast messages and to prevent
-      # them from being garbage collected.
-      #
-      # @private
-      # @sig Array[Zeitwerk::Loader]
-      attr_reader :loaders
-
-      # Registers gem loaders to let `for_gem` be idempotent in case of reload.
-      #
-      # @private
-      # @sig Hash[String, Zeitwerk::Loader]
-      attr_reader :gem_loaders_by_root_file
-
-      # Maps absolute paths to the loaders responsible for them.
-      #
-      # This information is used by our decorated `Kernel#require` to be able to
-      # invoke callbacks and autovivify modules.
-      #
-      # @private
-      # @sig Hash[String, Zeitwerk::Loader]
-      attr_reader :autoloads
-
-      # This hash table addresses an edge case in which an autoload is ignored.
-      #
-      # For example, let's suppose we want to autoload in a gem like this:
-      #
-      #   # lib/my_gem.rb
-      #   loader = Zeitwerk::Loader.new
-      #   loader.push_dir(__dir__)
-      #   loader.setup
-      #
-      #   module MyGem
-      #   end
-      #
-      # if you require "my_gem", as Bundler would do, this happens while setting
-      # up autoloads:
-      #
-      #   1. Object.autoload?(:MyGem) returns `nil` because the autoload for
-      #      the constant is issued by Zeitwerk while the same file is being
-      #      required.
-      #   2. The constant `MyGem` is undefined while setup runs.
-      #
-      # Therefore, a directory `lib/my_gem` would autovivify a module according to
-      # the existing information. But that would be wrong.
-      #
-      # To overcome this fundamental limitation, we keep track of the constant
-      # paths that are in this situation ---in the example above, "MyGem"--- and
-      # take this collection into account for the autovivification logic.
-      #
-      # Note that you cannot generally address this by moving the setup code
-      # below the constant definition, because we want libraries to be able to
-      # use managed constants in the module body:
-      #
-      #   module MyGem
-      #     include MyConcern
-      #   end
-      #
-      # @private
-      # @sig Hash[String, [String, Zeitwerk::Loader]]
-      attr_reader :inceptions
-
-      # Registers a loader.
-      #
-      # @private
-      # @sig (Zeitwerk::Loader) -> void
-      def register_loader(loader)
-        loaders << loader
-      end
-
-      # @private
-      # @sig (Zeitwerk::Loader) -> void
-      def unregister_loader(loader)
-        loaders.delete(loader)
-        gem_loaders_by_root_file.delete_if { |_, l| l == loader }
-        autoloads.delete_if { |_, l| l == loader }
-        inceptions.delete_if { |_, (_, l)| l == loader }
-      end
-
-      # This method returns always a loader, the same instance for the same root
-      # file. That is how Zeitwerk::Loader.for_gem is idempotent.
-      #
-      # @private
-      # @sig (String) -> Zeitwerk::Loader
-      def loader_for_gem(root_file, warn_on_extra_files:)
-        gem_loaders_by_root_file[root_file] ||= GemLoader._new(root_file, warn_on_extra_files: warn_on_extra_files)
-      end
-
-      # @private
-      # @sig (Zeitwerk::Loader, String) -> String
-      def register_autoload(loader, abspath)
-        autoloads[abspath] = loader
-      end
-
-      # @private
-      # @sig (String) -> void
-      def unregister_autoload(abspath)
-        autoloads.delete(abspath)
-      end
-
-      # @private
-      # @sig (String, String, Zeitwerk::Loader) -> void
-      def register_inception(cpath, abspath, loader)
-        inceptions[cpath] = [abspath, loader]
-      end
-
-      # @private
-      # @sig (String) -> String?
-      def inception?(cpath)
-        if pair = inceptions[cpath]
-          pair.first
-        end
-      end
-
-      # @private
-      # @sig (String) -> Zeitwerk::Loader?
-      def loader_for(path)
-        autoloads[path]
-      end
-
-      # @private
-      # @sig (Zeitwerk::Loader) -> void
-      def on_unload(loader)
-        autoloads.delete_if { |_path, object| object == loader }
-        inceptions.delete_if { |_cpath, (_path, object)| object == loader }
-      end
-    end
-
-    @loaders                  = []
-    @gem_loaders_by_root_file = {}
-    @autoloads                = {}
-    @inceptions               = {}
-  end
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/version.rb b/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/version.rb
deleted file mode 100644
index fdb8ac5ea65eb..0000000000000
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/zeitwerk-2.6.0/lib/zeitwerk/version.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module Zeitwerk
-  VERSION = "2.6.0"
-end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/LICENSE.txt b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/LICENSE.txt
new file mode 100644
index 0000000000000..ef51da2b0e8df
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/LICENSE.txt
@@ -0,0 +1,202 @@
+
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/data/unicode.data b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/data/unicode.data
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/data/unicode.data
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/data/unicode.data
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/idna.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/idna.rb
similarity index 97%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/idna.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/idna.rb
index e41c1f5da4cee..2dbd3934a04aa 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/idna.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/idna.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# encoding:utf-8
 #--
 # Copyright (C) Bob Aman
 #
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/idna/native.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/idna/native.rb
similarity index 83%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/idna/native.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/idna/native.rb
index 84de8e8cb48ca..a718364fe7076 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/idna/native.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/idna/native.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# encoding:utf-8
 #--
 # Copyright (C) Bob Aman
 #
@@ -30,8 +29,14 @@ def self.punycode_decode(value)
        IDN::Punycode.decode(value.to_s)
      end
 
-    def self.unicode_normalize_kc(value)
-      IDN::Stringprep.nfkc_normalize(value.to_s)
+    class << self
+      # @deprecated Use {String#unicode_normalize(:nfkc)} instead
+      def unicode_normalize_kc(value)
+        value.to_s.unicode_normalize(:nfkc)
+      end
+
+      extend Gem::Deprecate
+      deprecate :unicode_normalize_kc, "String#unicode_normalize(:nfkc)", 2023, 4
     end
 
     def self.to_ascii(value)
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/idna/pure.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/idna/pure.rb
new file mode 100644
index 0000000000000..3d6ffbadf24bf
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/idna/pure.rb
@@ -0,0 +1,505 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (C) Bob Aman
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#++
+
+
+module Addressable
+  module IDNA
+    # This module is loosely based on idn_actionmailer by Mick Staugaard,
+    # the unicode library by Yoshida Masato, and the punycode implementation
+    # by Kazuhiro Nishiyama.  Most of the code was copied verbatim, but
+    # some reformatting was done, and some translation from C was done.
+    #
+    # Without their code to work from as a base, we'd all still be relying
+    # on the presence of libidn.  Which nobody ever seems to have installed.
+    #
+    # Original sources:
+    # http://github.com/staugaard/idn_actionmailer
+    # http://www.yoshidam.net/Ruby.html#unicode
+    # http://rubyforge.org/frs/?group_id=2550
+
+
+    UNICODE_TABLE = File.expand_path(
+      File.join(File.dirname(__FILE__), '../../..', 'data/unicode.data')
+    )
+
+    ACE_PREFIX = "xn--"
+
+    UTF8_REGEX = /\A(?:
+      [\x09\x0A\x0D\x20-\x7E]               # ASCII
+      | [\xC2-\xDF][\x80-\xBF]              # non-overlong 2-byte
+      | \xE0[\xA0-\xBF][\x80-\xBF]          # excluding overlongs
+      | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}   # straight 3-byte
+      | \xED[\x80-\x9F][\x80-\xBF]          # excluding surrogates
+      | \xF0[\x90-\xBF][\x80-\xBF]{2}       # planes 1-3
+      | [\xF1-\xF3][\x80-\xBF]{3}           # planes 4nil5
+      | \xF4[\x80-\x8F][\x80-\xBF]{2}       # plane 16
+      )*\z/mnx
+
+    UTF8_REGEX_MULTIBYTE = /(?:
+      [\xC2-\xDF][\x80-\xBF]                # non-overlong 2-byte
+      | \xE0[\xA0-\xBF][\x80-\xBF]          # excluding overlongs
+      | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}   # straight 3-byte
+      | \xED[\x80-\x9F][\x80-\xBF]          # excluding surrogates
+      | \xF0[\x90-\xBF][\x80-\xBF]{2}       # planes 1-3
+      | [\xF1-\xF3][\x80-\xBF]{3}           # planes 4nil5
+      | \xF4[\x80-\x8F][\x80-\xBF]{2}       # plane 16
+      )/mnx
+
+    # :startdoc:
+
+    # Converts from a Unicode internationalized domain name to an ASCII
+    # domain name as described in RFC 3490.
+    def self.to_ascii(input)
+      input = input.to_s unless input.is_a?(String)
+      input = input.dup.force_encoding(Encoding::UTF_8).unicode_normalize(:nfkc)
+      if input.respond_to?(:force_encoding)
+        input.force_encoding(Encoding::ASCII_8BIT)
+      end
+      if input =~ UTF8_REGEX && input =~ UTF8_REGEX_MULTIBYTE
+        parts = unicode_downcase(input).split('.')
+        parts.map! do |part|
+          if part.respond_to?(:force_encoding)
+            part.force_encoding(Encoding::ASCII_8BIT)
+          end
+          if part =~ UTF8_REGEX && part =~ UTF8_REGEX_MULTIBYTE
+            ACE_PREFIX + punycode_encode(part)
+          else
+            part
+          end
+        end
+        parts.join('.')
+      else
+        input
+      end
+    end
+
+    # Converts from an ASCII domain name to a Unicode internationalized
+    # domain name as described in RFC 3490.
+    def self.to_unicode(input)
+      input = input.to_s unless input.is_a?(String)
+      parts = input.split('.')
+      parts.map! do |part|
+        if part =~ /^#{ACE_PREFIX}(.+)/
+          begin
+            punycode_decode(part[/^#{ACE_PREFIX}(.+)/, 1])
+          rescue Addressable::IDNA::PunycodeBadInput
+            # toUnicode is explicitly defined as never-fails by the spec
+            part
+          end
+        else
+          part
+        end
+      end
+      output = parts.join('.')
+      if output.respond_to?(:force_encoding)
+        output.force_encoding(Encoding::UTF_8)
+      end
+      output
+    end
+
+    class << self
+      # @deprecated Use {String#unicode_normalize(:nfkc)} instead
+      def unicode_normalize_kc(value)
+        value.to_s.unicode_normalize(:nfkc)
+      end
+
+      extend Gem::Deprecate
+      deprecate :unicode_normalize_kc, "String#unicode_normalize(:nfkc)", 2023, 4
+    end
+
+    ##
+    # Unicode aware downcase method.
+    #
+    # @api private
+    # @param [String] input
+    #   The input string.
+    # @return [String] The downcased result.
+    def self.unicode_downcase(input)
+      input = input.to_s unless input.is_a?(String)
+      unpacked = input.unpack("U*")
+      unpacked.map! { |codepoint| lookup_unicode_lowercase(codepoint) }
+      return unpacked.pack("U*")
+    end
+    private_class_method :unicode_downcase
+
+    def self.lookup_unicode_lowercase(codepoint)
+      codepoint_data = UNICODE_DATA[codepoint]
+      (codepoint_data ?
+        (codepoint_data[UNICODE_DATA_LOWERCASE] || codepoint) :
+        codepoint)
+    end
+    private_class_method :lookup_unicode_lowercase
+
+    UNICODE_DATA_COMBINING_CLASS = 0
+    UNICODE_DATA_EXCLUSION = 1
+    UNICODE_DATA_CANONICAL = 2
+    UNICODE_DATA_COMPATIBILITY = 3
+    UNICODE_DATA_UPPERCASE = 4
+    UNICODE_DATA_LOWERCASE = 5
+    UNICODE_DATA_TITLECASE = 6
+
+    begin
+      if defined?(FakeFS)
+        fakefs_state = FakeFS.activated?
+        FakeFS.deactivate!
+      end
+      # This is a sparse Unicode table.  Codepoints without entries are
+      # assumed to have the value: [0, 0, nil, nil, nil, nil, nil]
+      UNICODE_DATA = File.open(UNICODE_TABLE, "rb") do |file|
+        Marshal.load(file.read)
+      end
+    ensure
+      if defined?(FakeFS)
+        FakeFS.activate! if fakefs_state
+      end
+    end
+
+    COMPOSITION_TABLE = {}
+    UNICODE_DATA.each do |codepoint, data|
+      canonical = data[UNICODE_DATA_CANONICAL]
+      exclusion = data[UNICODE_DATA_EXCLUSION]
+
+      if canonical && exclusion == 0
+        COMPOSITION_TABLE[canonical.unpack("C*")] = codepoint
+      end
+    end
+
+    UNICODE_MAX_LENGTH = 256
+    ACE_MAX_LENGTH = 256
+
+    PUNYCODE_BASE = 36
+    PUNYCODE_TMIN = 1
+    PUNYCODE_TMAX = 26
+    PUNYCODE_SKEW = 38
+    PUNYCODE_DAMP = 700
+    PUNYCODE_INITIAL_BIAS = 72
+    PUNYCODE_INITIAL_N = 0x80
+    PUNYCODE_DELIMITER = 0x2D
+
+    PUNYCODE_MAXINT = 1 << 64
+
+    PUNYCODE_PRINT_ASCII =
+      "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n" +
+      "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n" +
+      " !\"\#$%&'()*+,-./" +
+      "0123456789:;<=>?" +
+      "@ABCDEFGHIJKLMNO" +
+      "PQRSTUVWXYZ[\\]^_" +
+      "`abcdefghijklmno" +
+      "pqrstuvwxyz{|}~\n"
+
+    # Input is invalid.
+    class PunycodeBadInput < StandardError; end
+    # Output would exceed the space provided.
+    class PunycodeBigOutput < StandardError; end
+    # Input needs wider integers to process.
+    class PunycodeOverflow < StandardError; end
+
+    def self.punycode_encode(unicode)
+      unicode = unicode.to_s unless unicode.is_a?(String)
+      input = unicode.unpack("U*")
+      output = [0] * (ACE_MAX_LENGTH + 1)
+      input_length = input.size
+      output_length = [ACE_MAX_LENGTH]
+
+      # Initialize the state
+      n = PUNYCODE_INITIAL_N
+      delta = out = 0
+      max_out = output_length[0]
+      bias = PUNYCODE_INITIAL_BIAS
+
+      # Handle the basic code points:
+      input_length.times do |j|
+        if punycode_basic?(input[j])
+          if max_out - out < 2
+            raise PunycodeBigOutput,
+              "Output would exceed the space provided."
+          end
+          output[out] = input[j]
+          out += 1
+        end
+      end
+
+      h = b = out
+
+      # h is the number of code points that have been handled, b is the
+      # number of basic code points, and out is the number of characters
+      # that have been output.
+
+      if b > 0
+        output[out] = PUNYCODE_DELIMITER
+        out += 1
+      end
+
+      # Main encoding loop:
+
+      while h < input_length
+        # All non-basic code points < n have been
+        # handled already.  Find the next larger one:
+
+        m = PUNYCODE_MAXINT
+        input_length.times do |j|
+          m = input[j] if (n...m) === input[j]
+        end
+
+        # Increase delta enough to advance the decoder's
+        # <n,i> state to <m,0>, but guard against overflow:
+
+        if m - n > (PUNYCODE_MAXINT - delta) / (h + 1)
+          raise PunycodeOverflow, "Input needs wider integers to process."
+        end
+        delta += (m - n) * (h + 1)
+        n = m
+
+        input_length.times do |j|
+          # Punycode does not need to check whether input[j] is basic:
+          if input[j] < n
+            delta += 1
+            if delta == 0
+              raise PunycodeOverflow,
+                "Input needs wider integers to process."
+            end
+          end
+
+          if input[j] == n
+            # Represent delta as a generalized variable-length integer:
+
+            q = delta; k = PUNYCODE_BASE
+            while true
+              if out >= max_out
+                raise PunycodeBigOutput,
+                  "Output would exceed the space provided."
+              end
+              t = (
+                if k <= bias
+                  PUNYCODE_TMIN
+                elsif k >= bias + PUNYCODE_TMAX
+                  PUNYCODE_TMAX
+                else
+                  k - bias
+                end
+              )
+              break if q < t
+              output[out] =
+                punycode_encode_digit(t + (q - t) % (PUNYCODE_BASE - t))
+              out += 1
+              q = (q - t) / (PUNYCODE_BASE - t)
+              k += PUNYCODE_BASE
+            end
+
+            output[out] = punycode_encode_digit(q)
+            out += 1
+            bias = punycode_adapt(delta, h + 1, h == b)
+            delta = 0
+            h += 1
+          end
+        end
+
+        delta += 1
+        n += 1
+      end
+
+      output_length[0] = out
+
+      outlen = out
+      outlen.times do |j|
+        c = output[j]
+        unless c >= 0 && c <= 127
+          raise StandardError, "Invalid output char."
+        end
+        unless PUNYCODE_PRINT_ASCII[c]
+          raise PunycodeBadInput, "Input is invalid."
+        end
+      end
+
+      output[0..outlen].map { |x| x.chr }.join("").sub(/\0+\z/, "")
+    end
+    private_class_method :punycode_encode
+
+    def self.punycode_decode(punycode)
+      input = []
+      output = []
+
+      if ACE_MAX_LENGTH * 2 < punycode.size
+        raise PunycodeBigOutput, "Output would exceed the space provided."
+      end
+      punycode.each_byte do |c|
+        unless c >= 0 && c <= 127
+          raise PunycodeBadInput, "Input is invalid."
+        end
+        input.push(c)
+      end
+
+      input_length = input.length
+      output_length = [UNICODE_MAX_LENGTH]
+
+      # Initialize the state
+      n = PUNYCODE_INITIAL_N
+
+      out = i = 0
+      max_out = output_length[0]
+      bias = PUNYCODE_INITIAL_BIAS
+
+      # Handle the basic code points:  Let b be the number of input code
+      # points before the last delimiter, or 0 if there is none, then
+      # copy the first b code points to the output.
+
+      b = 0
+      input_length.times do |j|
+        b = j if punycode_delimiter?(input[j])
+      end
+      if b > max_out
+        raise PunycodeBigOutput, "Output would exceed the space provided."
+      end
+
+      b.times do |j|
+        unless punycode_basic?(input[j])
+          raise PunycodeBadInput, "Input is invalid."
+        end
+        output[out] = input[j]
+        out+=1
+      end
+
+      # Main decoding loop:  Start just after the last delimiter if any
+      # basic code points were copied; start at the beginning otherwise.
+
+      in_ = b > 0 ? b + 1 : 0
+      while in_ < input_length
+
+        # in_ is the index of the next character to be consumed, and
+        # out is the number of code points in the output array.
+
+        # Decode a generalized variable-length integer into delta,
+        # which gets added to i.  The overflow checking is easier
+        # if we increase i as we go, then subtract off its starting
+        # value at the end to obtain delta.
+
+        oldi = i; w = 1; k = PUNYCODE_BASE
+        while true
+          if in_ >= input_length
+            raise PunycodeBadInput, "Input is invalid."
+          end
+          digit = punycode_decode_digit(input[in_])
+          in_+=1
+          if digit >= PUNYCODE_BASE
+            raise PunycodeBadInput, "Input is invalid."
+          end
+          if digit > (PUNYCODE_MAXINT - i) / w
+            raise PunycodeOverflow, "Input needs wider integers to process."
+          end
+          i += digit * w
+          t = (
+            if k <= bias
+              PUNYCODE_TMIN
+            elsif k >= bias + PUNYCODE_TMAX
+              PUNYCODE_TMAX
+            else
+              k - bias
+            end
+          )
+          break if digit < t
+          if w > PUNYCODE_MAXINT / (PUNYCODE_BASE - t)
+            raise PunycodeOverflow, "Input needs wider integers to process."
+          end
+          w *= PUNYCODE_BASE - t
+          k += PUNYCODE_BASE
+        end
+
+        bias = punycode_adapt(i - oldi, out + 1, oldi == 0)
+
+        # I was supposed to wrap around from out + 1 to 0,
+        # incrementing n each time, so we'll fix that now:
+
+        if i / (out + 1) > PUNYCODE_MAXINT - n
+          raise PunycodeOverflow, "Input needs wider integers to process."
+        end
+        n += i / (out + 1)
+        i %= out + 1
+
+        # Insert n at position i of the output:
+
+        # not needed for Punycode:
+        # raise PUNYCODE_INVALID_INPUT if decode_digit(n) <= base
+        if out >= max_out
+          raise PunycodeBigOutput, "Output would exceed the space provided."
+        end
+
+        #memmove(output + i + 1, output + i, (out - i) * sizeof *output)
+        output[i + 1, out - i] = output[i, out - i]
+        output[i] = n
+        i += 1
+
+        out += 1
+      end
+
+      output_length[0] = out
+
+      output.pack("U*")
+    end
+    private_class_method :punycode_decode
+
+    def self.punycode_basic?(codepoint)
+      codepoint < 0x80
+    end
+    private_class_method :punycode_basic?
+
+    def self.punycode_delimiter?(codepoint)
+      codepoint == PUNYCODE_DELIMITER
+    end
+    private_class_method :punycode_delimiter?
+
+    def self.punycode_encode_digit(d)
+      d + 22 + 75 * ((d < 26) ? 1 : 0)
+    end
+    private_class_method :punycode_encode_digit
+
+    # Returns the numeric value of a basic codepoint
+    # (for use in representing integers) in the range 0 to
+    # base - 1, or PUNYCODE_BASE if codepoint does not represent a value.
+    def self.punycode_decode_digit(codepoint)
+      if codepoint - 48 < 10
+        codepoint - 22
+      elsif codepoint - 65 < 26
+        codepoint - 65
+      elsif codepoint - 97 < 26
+        codepoint - 97
+      else
+        PUNYCODE_BASE
+      end
+    end
+    private_class_method :punycode_decode_digit
+
+    # Bias adaptation method
+    def self.punycode_adapt(delta, numpoints, firsttime)
+      delta = firsttime ? delta / PUNYCODE_DAMP : delta >> 1
+      # delta >> 1 is a faster way of doing delta / 2
+      delta += delta / numpoints
+      difference = PUNYCODE_BASE - PUNYCODE_TMIN
+
+      k = 0
+      while delta > (difference * PUNYCODE_TMAX) / 2
+        delta /= difference
+        k += PUNYCODE_BASE
+      end
+
+      k + (difference + 1) * delta / (delta + PUNYCODE_SKEW)
+    end
+    private_class_method :punycode_adapt
+  end
+  # :startdoc:
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/template.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/template.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/template.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/template.rb
index 45f6ae69eece2..08556d9e10487 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/addressable-2.8.0/lib/addressable/template.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/template.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# encoding:utf-8
 #--
 # Copyright (C) Bob Aman
 #
@@ -158,7 +157,7 @@ def values
       #   the ::MatchData#[] behavior.
       #
       # @param [#to_int, nil] len
-      #   If provided, an array of values will be returend with the given
+      #   If provided, an array of values will be returned with the given
       #   parameter used as length.
       #
       # @return [Array, String, nil]
@@ -657,12 +656,12 @@ def named_captures
     def ordered_variable_defaults
       @ordered_variable_defaults ||= begin
         expansions, _ = parse_template_pattern(pattern)
-        expansions.map do |capture|
+        expansions.flat_map do |capture|
           _, _, varlist = *capture.match(EXPRESSION)
           varlist.split(',').map do |varspec|
             varspec[VARSPEC, 1]
           end
-        end.flatten
+        end
       end
     end
 
@@ -893,25 +892,24 @@ def join_values(operator, return_value)
     # operator.
     #
     # @param [Hash, Array, String] value
-    #   Normalizes keys and values with IDNA#unicode_normalize_kc
+    #   Normalizes unicode keys and values with String#unicode_normalize (NFC)
     #
     # @return [Hash, Array, String] The normalized values
     def normalize_value(value)
-      unless value.is_a?(Hash)
-        value = value.respond_to?(:to_ary) ? value.to_ary : value.to_str
-      end
-
       # Handle unicode normalization
-      if value.kind_of?(Array)
-        value.map! { |val| Addressable::IDNA.unicode_normalize_kc(val) }
+      if value.respond_to?(:to_ary)
+        value.to_ary.map! { |val| normalize_value(val) }
       elsif value.kind_of?(Hash)
         value = value.inject({}) { |acc, (k, v)|
-          acc[Addressable::IDNA.unicode_normalize_kc(k)] =
-            Addressable::IDNA.unicode_normalize_kc(v)
+          acc[normalize_value(k)] = normalize_value(v)
           acc
         }
       else
-        value = Addressable::IDNA.unicode_normalize_kc(value)
+        value = value.to_s if !value.kind_of?(String)
+        if value.encoding != Encoding::UTF_8
+          value = value.dup.force_encoding(Encoding::UTF_8)
+        end
+        value = value.unicode_normalize(:nfc)
       end
       value
     end
@@ -1023,7 +1021,7 @@ def parse_new_template_pattern(pattern, processor = nil)
       end
 
       # Ensure that the regular expression matches the whole URI.
-      regexp_string = "^#{regexp_string}$"
+      regexp_string = "\\A#{regexp_string}\\z"
       return expansions, Regexp.new(regexp_string)
     end
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/uri.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/uri.rb
new file mode 100644
index 0000000000000..40b80cf0ffe04
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/uri.rb
@@ -0,0 +1,2602 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (C) Bob Aman
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#++
+
+
+require "addressable/version"
+require "addressable/idna"
+require "public_suffix"
+
+##
+# Addressable is a library for processing links and URIs.
+module Addressable
+  ##
+  # This is an implementation of a URI parser based on
+  # <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>,
+  # <a href="http://www.ietf.org/rfc/rfc3987.txt">RFC 3987</a>.
+  class URI
+    ##
+    # Raised if something other than a uri is supplied.
+    class InvalidURIError < StandardError
+    end
+
+    ##
+    # Container for the character classes specified in
+    # <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
+    #
+    # Note: Concatenated and interpolated `String`s are not affected by the
+    #       `frozen_string_literal` directive and must be frozen explicitly.
+    #
+    #       Interpolated `String`s *were* frozen this way before Ruby 3.0:
+    #       https://bugs.ruby-lang.org/issues/17104
+    module CharacterClasses
+      ALPHA = "a-zA-Z"
+      DIGIT = "0-9"
+      GEN_DELIMS = "\\:\\/\\?\\#\\[\\]\\@"
+      SUB_DELIMS = "\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\="
+      RESERVED = (GEN_DELIMS + SUB_DELIMS).freeze
+      UNRESERVED = (ALPHA + DIGIT + "\\-\\.\\_\\~").freeze
+      RESERVED_AND_UNRESERVED = RESERVED + UNRESERVED
+      PCHAR = (UNRESERVED + SUB_DELIMS + "\\:\\@").freeze
+      SCHEME = (ALPHA + DIGIT + "\\-\\+\\.").freeze
+      HOST = (UNRESERVED + SUB_DELIMS + "\\[\\:\\]").freeze
+      AUTHORITY = (PCHAR + "\\[\\]").freeze
+      PATH = (PCHAR + "\\/").freeze
+      QUERY = (PCHAR + "\\/\\?").freeze
+      FRAGMENT = (PCHAR + "\\/\\?").freeze
+    end
+
+    module NormalizeCharacterClasses
+      HOST = /[^#{CharacterClasses::HOST}]/
+      UNRESERVED = /[^#{CharacterClasses::UNRESERVED}]/
+      PCHAR = /[^#{CharacterClasses::PCHAR}]/
+      SCHEME = /[^#{CharacterClasses::SCHEME}]/
+      FRAGMENT = /[^#{CharacterClasses::FRAGMENT}]/
+      QUERY = %r{[^a-zA-Z0-9\-\.\_\~\!\$\'\(\)\*\+\,\=\:\@\/\?%]|%(?!2B|2b)}
+    end
+
+    module CharacterClassesRegexps
+      AUTHORITY = /[^#{CharacterClasses::AUTHORITY}]/
+      FRAGMENT = /[^#{CharacterClasses::FRAGMENT}]/
+      HOST = /[^#{CharacterClasses::HOST}]/
+      PATH = /[^#{CharacterClasses::PATH}]/
+      QUERY = /[^#{CharacterClasses::QUERY}]/
+      RESERVED = /[^#{CharacterClasses::RESERVED}]/
+      RESERVED_AND_UNRESERVED = /[^#{CharacterClasses::RESERVED_AND_UNRESERVED}]/
+      SCHEME = /[^#{CharacterClasses::SCHEME}]/
+      UNRESERVED = /[^#{CharacterClasses::UNRESERVED}]/
+    end
+
+    SLASH = '/'
+    EMPTY_STR = ''
+
+    URIREGEX = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/
+
+    PORT_MAPPING = {
+      "http" => 80,
+      "https" => 443,
+      "ftp" => 21,
+      "tftp" => 69,
+      "sftp" => 22,
+      "ssh" => 22,
+      "svn+ssh" => 22,
+      "telnet" => 23,
+      "nntp" => 119,
+      "gopher" => 70,
+      "wais" => 210,
+      "ldap" => 389,
+      "prospero" => 1525
+    }.freeze
+
+    ##
+    # Returns a URI object based on the parsed string.
+    #
+    # @param [String, Addressable::URI, #to_str] uri
+    #   The URI string to parse.
+    #   No parsing is performed if the object is already an
+    #   <code>Addressable::URI</code>.
+    #
+    # @return [Addressable::URI] The parsed URI.
+    def self.parse(uri)
+      # If we were given nil, return nil.
+      return nil unless uri
+      # If a URI object is passed, just return itself.
+      return uri.dup if uri.kind_of?(self)
+
+      # If a URI object of the Ruby standard library variety is passed,
+      # convert it to a string, then parse the string.
+      # We do the check this way because we don't want to accidentally
+      # cause a missing constant exception to be thrown.
+      if uri.class.name =~ /^URI\b/
+        uri = uri.to_s
+      end
+
+      # Otherwise, convert to a String
+      begin
+        uri = uri.to_str
+      rescue TypeError, NoMethodError
+        raise TypeError, "Can't convert #{uri.class} into String."
+      end unless uri.is_a?(String)
+
+      # This Regexp supplied as an example in RFC 3986, and it works great.
+      scan = uri.scan(URIREGEX)
+      fragments = scan[0]
+      scheme = fragments[1]
+      authority = fragments[3]
+      path = fragments[4]
+      query = fragments[6]
+      fragment = fragments[8]
+      user = nil
+      password = nil
+      host = nil
+      port = nil
+      if authority != nil
+        # The Regexp above doesn't split apart the authority.
+        userinfo = authority[/^([^\[\]]*)@/, 1]
+        if userinfo != nil
+          user = userinfo.strip[/^([^:]*):?/, 1]
+          password = userinfo.strip[/:(.*)$/, 1]
+        end
+
+        host = authority.sub(
+          /^([^\[\]]*)@/, EMPTY_STR
+        ).sub(
+          /:([^:@\[\]]*?)$/, EMPTY_STR
+        )
+
+        port = authority[/:([^:@\[\]]*?)$/, 1]
+        port = nil if port == EMPTY_STR
+      end
+
+      return new(
+        :scheme => scheme,
+        :user => user,
+        :password => password,
+        :host => host,
+        :port => port,
+        :path => path,
+        :query => query,
+        :fragment => fragment
+      )
+    end
+
+    ##
+    # Converts an input to a URI. The input does not have to be a valid
+    # URI — the method will use heuristics to guess what URI was intended.
+    # This is not standards-compliant, merely user-friendly.
+    #
+    # @param [String, Addressable::URI, #to_str] uri
+    #   The URI string to parse.
+    #   No parsing is performed if the object is already an
+    #   <code>Addressable::URI</code>.
+    # @param [Hash] hints
+    #   A <code>Hash</code> of hints to the heuristic parser.
+    #   Defaults to <code>{:scheme => "http"}</code>.
+    #
+    # @return [Addressable::URI] The parsed URI.
+    def self.heuristic_parse(uri, hints={})
+      # If we were given nil, return nil.
+      return nil unless uri
+      # If a URI object is passed, just return itself.
+      return uri.dup if uri.kind_of?(self)
+
+      # If a URI object of the Ruby standard library variety is passed,
+      # convert it to a string, then parse the string.
+      # We do the check this way because we don't want to accidentally
+      # cause a missing constant exception to be thrown.
+      if uri.class.name =~ /^URI\b/
+        uri = uri.to_s
+      end
+
+      unless uri.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{uri.class} into String."
+      end
+      # Otherwise, convert to a String
+      uri = uri.to_str.dup.strip
+      hints = {
+        :scheme => "http"
+      }.merge(hints)
+      case uri
+      when /^http:\//i
+        uri.sub!(/^http:\/+/i, "http://")
+      when /^https:\//i
+        uri.sub!(/^https:\/+/i, "https://")
+      when /^feed:\/+http:\//i
+        uri.sub!(/^feed:\/+http:\/+/i, "feed:http://")
+      when /^feed:\//i
+        uri.sub!(/^feed:\/+/i, "feed://")
+      when %r[^file:/{4}]i
+        uri.sub!(%r[^file:/+]i, "file:////")
+      when %r[^file://localhost/]i
+        uri.sub!(%r[^file://localhost/+]i, "file:///")
+      when %r[^file:/+]i
+        uri.sub!(%r[^file:/+]i, "file:///")
+      when /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
+        uri.sub!(/^/, hints[:scheme] + "://")
+      when /\A\d+\..*:\d+\z/
+        uri = "#{hints[:scheme]}://#{uri}"
+      end
+      match = uri.match(URIREGEX)
+      fragments = match.captures
+      authority = fragments[3]
+      if authority && authority.length > 0
+        new_authority = authority.tr("\\", "/").gsub(" ", "%20")
+        # NOTE: We want offset 4, not 3!
+        offset = match.offset(4)
+        uri = uri.dup
+        uri[offset[0]...offset[1]] = new_authority
+      end
+      parsed = self.parse(uri)
+      if parsed.scheme =~ /^[^\/?#\.]+\.[^\/?#]+$/
+        parsed = self.parse(hints[:scheme] + "://" + uri)
+      end
+      if parsed.path.include?(".")
+        if parsed.path[/\b@\b/]
+          parsed.scheme = "mailto" unless parsed.scheme
+        elsif new_host = parsed.path[/^([^\/]+\.[^\/]*)/, 1]
+          parsed.defer_validation do
+            new_path = parsed.path.sub(
+              Regexp.new("^" + Regexp.escape(new_host)), EMPTY_STR)
+            parsed.host = new_host
+            parsed.path = new_path
+            parsed.scheme = hints[:scheme] unless parsed.scheme
+          end
+        end
+      end
+      return parsed
+    end
+
+    ##
+    # Converts a path to a file scheme URI. If the path supplied is
+    # relative, it will be returned as a relative URI. If the path supplied
+    # is actually a non-file URI, it will parse the URI as if it had been
+    # parsed with <code>Addressable::URI.parse</code>. Handles all of the
+    # various Microsoft-specific formats for specifying paths.
+    #
+    # @param [String, Addressable::URI, #to_str] path
+    #   Typically a <code>String</code> path to a file or directory, but
+    #   will return a sensible return value if an absolute URI is supplied
+    #   instead.
+    #
+    # @return [Addressable::URI]
+    #   The parsed file scheme URI or the original URI if some other URI
+    #   scheme was provided.
+    #
+    # @example
+    #   base = Addressable::URI.convert_path("/absolute/path/")
+    #   uri = Addressable::URI.convert_path("relative/path")
+    #   (base + uri).to_s
+    #   #=> "file:///absolute/path/relative/path"
+    #
+    #   Addressable::URI.convert_path(
+    #     "c:\\windows\\My Documents 100%20\\foo.txt"
+    #   ).to_s
+    #   #=> "file:///c:/windows/My%20Documents%20100%20/foo.txt"
+    #
+    #   Addressable::URI.convert_path("http://example.com/").to_s
+    #   #=> "http://example.com/"
+    def self.convert_path(path)
+      # If we were given nil, return nil.
+      return nil unless path
+      # If a URI object is passed, just return itself.
+      return path if path.kind_of?(self)
+      unless path.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{path.class} into String."
+      end
+      # Otherwise, convert to a String
+      path = path.to_str.strip
+
+      path.sub!(/^file:\/?\/?/, EMPTY_STR) if path =~ /^file:\/?\/?/
+      path = SLASH + path if path =~ /^([a-zA-Z])[\|:]/
+      uri = self.parse(path)
+
+      if uri.scheme == nil
+        # Adjust windows-style uris
+        uri.path.sub!(/^\/?([a-zA-Z])[\|:][\\\/]/) do
+          "/#{$1.downcase}:/"
+        end
+        uri.path.tr!("\\", SLASH)
+        if File.exist?(uri.path) &&
+            File.stat(uri.path).directory?
+          uri.path.chomp!(SLASH)
+          uri.path = uri.path + '/'
+        end
+
+        # If the path is absolute, set the scheme and host.
+        if uri.path.start_with?(SLASH)
+          uri.scheme = "file"
+          uri.host = EMPTY_STR
+        end
+        uri.normalize!
+      end
+
+      return uri
+    end
+
+    ##
+    # Joins several URIs together.
+    #
+    # @param [String, Addressable::URI, #to_str] *uris
+    #   The URIs to join.
+    #
+    # @return [Addressable::URI] The joined URI.
+    #
+    # @example
+    #   base = "http://example.com/"
+    #   uri = Addressable::URI.parse("relative/path")
+    #   Addressable::URI.join(base, uri)
+    #   #=> #<Addressable::URI:0xcab390 URI:http://example.com/relative/path>
+    def self.join(*uris)
+      uri_objects = uris.collect do |uri|
+        unless uri.respond_to?(:to_str)
+          raise TypeError, "Can't convert #{uri.class} into String."
+        end
+        uri.kind_of?(self) ? uri : self.parse(uri.to_str)
+      end
+      result = uri_objects.shift.dup
+      uri_objects.each do |uri|
+        result.join!(uri)
+      end
+      return result
+    end
+
+    ##
+    # Tables used to optimize encoding operations in `self.encode_component`
+    # and `self.normalize_component`
+    SEQUENCE_ENCODING_TABLE = (0..255).map do |byte|
+      format("%02x", byte).freeze
+    end.freeze
+
+    SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE = (0..255).map do |byte|
+      format("%%%02X", byte).freeze
+    end.freeze
+
+    ##
+    # Percent encodes a URI component.
+    #
+    # @param [String, #to_str] component The URI component to encode.
+    #
+    # @param [String, Regexp] character_class
+    #   The characters which are not percent encoded. If a <code>String</code>
+    #   is passed, the <code>String</code> must be formatted as a regular
+    #   expression character class. (Do not include the surrounding square
+    #   brackets.)  For example, <code>"b-zB-Z0-9"</code> would cause
+    #   everything but the letters 'b' through 'z' and the numbers '0' through
+    #  '9' to be percent encoded. If a <code>Regexp</code> is passed, the
+    #   value <code>/[^b-zB-Z0-9]/</code> would have the same effect. A set of
+    #   useful <code>String</code> values may be found in the
+    #   <code>Addressable::URI::CharacterClasses</code> module. The default
+    #   value is the reserved plus unreserved character classes specified in
+    #   <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
+    #
+    # @param [Regexp] upcase_encoded
+    #   A string of characters that may already be percent encoded, and whose
+    #   encodings should be upcased. This allows normalization of percent
+    #   encodings for characters not included in the
+    #   <code>character_class</code>.
+    #
+    # @return [String] The encoded component.
+    #
+    # @example
+    #   Addressable::URI.encode_component("simple/example", "b-zB-Z0-9")
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.encode_component("simple/example", /[^b-zB-Z0-9]/)
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.encode_component(
+    #     "simple/example", Addressable::URI::CharacterClasses::UNRESERVED
+    #   )
+    #   => "simple%2Fexample"
+    def self.encode_component(component, character_class=CharacterClassesRegexps::RESERVED_AND_UNRESERVED, upcase_encoded='')
+      return nil if component.nil?
+
+      begin
+        if component.kind_of?(Symbol) ||
+            component.kind_of?(Numeric) ||
+            component.kind_of?(TrueClass) ||
+            component.kind_of?(FalseClass)
+          component = component.to_s
+        else
+          component = component.to_str
+        end
+      rescue TypeError, NoMethodError
+        raise TypeError, "Can't convert #{component.class} into String."
+      end if !component.is_a? String
+
+      if ![String, Regexp].include?(character_class.class)
+        raise TypeError,
+          "Expected String or Regexp, got #{character_class.inspect}"
+      end
+      if character_class.kind_of?(String)
+        character_class = /[^#{character_class}]/
+      end
+      # We can't perform regexps on invalid UTF sequences, but
+      # here we need to, so switch to ASCII.
+      component = component.dup
+      component.force_encoding(Encoding::ASCII_8BIT)
+      # Avoiding gsub! because there are edge cases with frozen strings
+      component = component.gsub(character_class) do |char|
+        SEQUENCE_UPCASED_PERCENT_ENCODING_TABLE[char.ord]
+      end
+      if upcase_encoded.length > 0
+        upcase_encoded_chars = upcase_encoded.bytes.map do |byte|
+          SEQUENCE_ENCODING_TABLE[byte]
+        end
+        component = component.gsub(/%(#{upcase_encoded_chars.join('|')})/,
+                                   &:upcase)
+      end
+
+      return component
+    end
+
+    class << self
+      alias_method :escape_component, :encode_component
+    end
+
+    ##
+    # Unencodes any percent encoded characters within a URI component.
+    # This method may be used for unencoding either components or full URIs,
+    # however, it is recommended to use the <code>unencode_component</code>
+    # alias when unencoding components.
+    #
+    # @param [String, Addressable::URI, #to_str] uri
+    #   The URI or component to unencode.
+    #
+    # @param [Class] return_type
+    #   The type of object to return.
+    #   This value may only be set to <code>String</code> or
+    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
+    #   to <code>String</code>.
+    #
+    # @param [String] leave_encoded
+    #   A string of characters to leave encoded. If a percent encoded character
+    #   in this list is encountered then it will remain percent encoded.
+    #
+    # @return [String, Addressable::URI]
+    #   The unencoded component or URI.
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    def self.unencode(uri, return_type=String, leave_encoded='')
+      return nil if uri.nil?
+
+      begin
+        uri = uri.to_str
+      rescue NoMethodError, TypeError
+        raise TypeError, "Can't convert #{uri.class} into String."
+      end if !uri.is_a? String
+      if ![String, ::Addressable::URI].include?(return_type)
+        raise TypeError,
+          "Expected Class (String or Addressable::URI), " +
+          "got #{return_type.inspect}"
+      end
+
+      result = uri.gsub(/%[0-9a-f]{2}/i) do |sequence|
+        c = sequence[1..3].to_i(16).chr
+        c.force_encoding(sequence.encoding)
+        leave_encoded.include?(c) ? sequence : c
+      end
+
+      result.force_encoding(Encoding::UTF_8)
+      if return_type == String
+        return result
+      elsif return_type == ::Addressable::URI
+        return ::Addressable::URI.parse(result)
+      end
+    end
+
+    class << self
+      alias_method :unescape, :unencode
+      alias_method :unencode_component, :unencode
+      alias_method :unescape_component, :unencode
+    end
+
+
+    ##
+    # Normalizes the encoding of a URI component.
+    #
+    # @param [String, #to_str] component The URI component to encode.
+    #
+    # @param [String, Regexp] character_class
+    #   The characters which are not percent encoded. If a <code>String</code>
+    #   is passed, the <code>String</code> must be formatted as a regular
+    #   expression character class. (Do not include the surrounding square
+    #   brackets.)  For example, <code>"b-zB-Z0-9"</code> would cause
+    #   everything but the letters 'b' through 'z' and the numbers '0'
+    #   through '9' to be percent encoded. If a <code>Regexp</code> is passed,
+    #   the value <code>/[^b-zB-Z0-9]/</code> would have the same effect. A
+    #   set of useful <code>String</code> values may be found in the
+    #   <code>Addressable::URI::CharacterClasses</code> module. The default
+    #   value is the reserved plus unreserved character classes specified in
+    #   <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>.
+    #
+    # @param [String] leave_encoded
+    #   When <code>character_class</code> is a <code>String</code> then
+    #   <code>leave_encoded</code> is a string of characters that should remain
+    #   percent encoded while normalizing the component; if they appear percent
+    #   encoded in the original component, then they will be upcased ("%2f"
+    #   normalized to "%2F") but otherwise left alone.
+    #
+    # @return [String] The normalized component.
+    #
+    # @example
+    #   Addressable::URI.normalize_component("simpl%65/%65xampl%65", "b-zB-Z")
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.normalize_component(
+    #     "simpl%65/%65xampl%65", /[^b-zB-Z]/
+    #   )
+    #   => "simple%2Fex%61mple"
+    #   Addressable::URI.normalize_component(
+    #     "simpl%65/%65xampl%65",
+    #     Addressable::URI::CharacterClasses::UNRESERVED
+    #   )
+    #   => "simple%2Fexample"
+    #   Addressable::URI.normalize_component(
+    #     "one%20two%2fthree%26four",
+    #     "0-9a-zA-Z &/",
+    #     "/"
+    #   )
+    #   => "one two%2Fthree&four"
+    def self.normalize_component(component, character_class=
+        CharacterClassesRegexps::RESERVED_AND_UNRESERVED,
+        leave_encoded='')
+      return nil if component.nil?
+
+      begin
+        component = component.to_str
+      rescue NoMethodError, TypeError
+        raise TypeError, "Can't convert #{component.class} into String."
+      end if !component.is_a? String
+
+      if ![String, Regexp].include?(character_class.class)
+        raise TypeError,
+          "Expected String or Regexp, got #{character_class.inspect}"
+      end
+      if character_class.kind_of?(String)
+        leave_re = if leave_encoded.length > 0
+          character_class = "#{character_class}%" unless character_class.include?('%')
+
+          bytes = leave_encoded.bytes
+          leave_encoded_pattern = bytes.map { |b| SEQUENCE_ENCODING_TABLE[b] }.join('|')
+          "|%(?!#{leave_encoded_pattern}|#{leave_encoded_pattern.upcase})"
+        end
+
+        character_class = if leave_re
+                            /[^#{character_class}]#{leave_re}/
+                          else
+                            /[^#{character_class}]/
+                          end
+      end
+      # We can't perform regexps on invalid UTF sequences, but
+      # here we need to, so switch to ASCII.
+      component = component.dup
+      component.force_encoding(Encoding::ASCII_8BIT)
+      unencoded = self.unencode_component(component, String, leave_encoded)
+      begin
+        encoded = self.encode_component(
+          unencoded.unicode_normalize(:nfc),
+          character_class,
+          leave_encoded
+        )
+      rescue ArgumentError
+        encoded = self.encode_component(unencoded)
+      end
+      encoded.force_encoding(Encoding::UTF_8)
+      return encoded
+    end
+
+    ##
+    # Percent encodes any special characters in the URI.
+    #
+    # @param [String, Addressable::URI, #to_str] uri
+    #   The URI to encode.
+    #
+    # @param [Class] return_type
+    #   The type of object to return.
+    #   This value may only be set to <code>String</code> or
+    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
+    #   to <code>String</code>.
+    #
+    # @return [String, Addressable::URI]
+    #   The encoded URI.
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    def self.encode(uri, return_type=String)
+      return nil if uri.nil?
+
+      begin
+        uri = uri.to_str
+      rescue NoMethodError, TypeError
+        raise TypeError, "Can't convert #{uri.class} into String."
+      end if !uri.is_a? String
+
+      if ![String, ::Addressable::URI].include?(return_type)
+        raise TypeError,
+          "Expected Class (String or Addressable::URI), " +
+          "got #{return_type.inspect}"
+      end
+      uri_object = uri.kind_of?(self) ? uri : self.parse(uri)
+      encoded_uri = Addressable::URI.new(
+        :scheme => self.encode_component(uri_object.scheme,
+          Addressable::URI::CharacterClassesRegexps::SCHEME),
+        :authority => self.encode_component(uri_object.authority,
+          Addressable::URI::CharacterClassesRegexps::AUTHORITY),
+        :path => self.encode_component(uri_object.path,
+          Addressable::URI::CharacterClassesRegexps::PATH),
+        :query => self.encode_component(uri_object.query,
+          Addressable::URI::CharacterClassesRegexps::QUERY),
+        :fragment => self.encode_component(uri_object.fragment,
+          Addressable::URI::CharacterClassesRegexps::FRAGMENT)
+      )
+      if return_type == String
+        return encoded_uri.to_s
+      elsif return_type == ::Addressable::URI
+        return encoded_uri
+      end
+    end
+
+    class << self
+      alias_method :escape, :encode
+    end
+
+    ##
+    # Normalizes the encoding of a URI. Characters within a hostname are
+    # not percent encoded to allow for internationalized domain names.
+    #
+    # @param [String, Addressable::URI, #to_str] uri
+    #   The URI to encode.
+    #
+    # @param [Class] return_type
+    #   The type of object to return.
+    #   This value may only be set to <code>String</code> or
+    #   <code>Addressable::URI</code>. All other values are invalid. Defaults
+    #   to <code>String</code>.
+    #
+    # @return [String, Addressable::URI]
+    #   The encoded URI.
+    #   The return type is determined by the <code>return_type</code>
+    #   parameter.
+    def self.normalized_encode(uri, return_type=String)
+      begin
+        uri = uri.to_str
+      rescue NoMethodError, TypeError
+        raise TypeError, "Can't convert #{uri.class} into String."
+      end if !uri.is_a? String
+
+      if ![String, ::Addressable::URI].include?(return_type)
+        raise TypeError,
+          "Expected Class (String or Addressable::URI), " +
+          "got #{return_type.inspect}"
+      end
+      uri_object = uri.kind_of?(self) ? uri : self.parse(uri)
+      components = {
+        :scheme => self.unencode_component(uri_object.scheme),
+        :user => self.unencode_component(uri_object.user),
+        :password => self.unencode_component(uri_object.password),
+        :host => self.unencode_component(uri_object.host),
+        :port => (uri_object.port.nil? ? nil : uri_object.port.to_s),
+        :path => self.unencode_component(uri_object.path),
+        :query => self.unencode_component(uri_object.query),
+        :fragment => self.unencode_component(uri_object.fragment)
+      }
+      components.each do |key, value|
+        if value != nil
+          begin
+            components[key] = value.to_str.unicode_normalize(:nfc)
+          rescue ArgumentError
+            # Likely a malformed UTF-8 character, skip unicode normalization
+            components[key] = value.to_str
+          end
+        end
+      end
+      encoded_uri = Addressable::URI.new(
+        :scheme => self.encode_component(components[:scheme],
+          Addressable::URI::CharacterClassesRegexps::SCHEME),
+        :user => self.encode_component(components[:user],
+          Addressable::URI::CharacterClassesRegexps::UNRESERVED),
+        :password => self.encode_component(components[:password],
+          Addressable::URI::CharacterClassesRegexps::UNRESERVED),
+        :host => components[:host],
+        :port => components[:port],
+        :path => self.encode_component(components[:path],
+          Addressable::URI::CharacterClassesRegexps::PATH),
+        :query => self.encode_component(components[:query],
+          Addressable::URI::CharacterClassesRegexps::QUERY),
+        :fragment => self.encode_component(components[:fragment],
+          Addressable::URI::CharacterClassesRegexps::FRAGMENT)
+      )
+      if return_type == String
+        return encoded_uri.to_s
+      elsif return_type == ::Addressable::URI
+        return encoded_uri
+      end
+    end
+
+    ##
+    # Encodes a set of key/value pairs according to the rules for the
+    # <code>application/x-www-form-urlencoded</code> MIME type.
+    #
+    # @param [#to_hash, #to_ary] form_values
+    #   The form values to encode.
+    #
+    # @param [TrueClass, FalseClass] sort
+    #   Sort the key/value pairs prior to encoding.
+    #   Defaults to <code>false</code>.
+    #
+    # @return [String]
+    #   The encoded value.
+    def self.form_encode(form_values, sort=false)
+      if form_values.respond_to?(:to_hash)
+        form_values = form_values.to_hash.to_a
+      elsif form_values.respond_to?(:to_ary)
+        form_values = form_values.to_ary
+      else
+        raise TypeError, "Can't convert #{form_values.class} into Array."
+      end
+
+      form_values = form_values.inject([]) do |accu, (key, value)|
+        if value.kind_of?(Array)
+          value.each do |v|
+            accu << [key.to_s, v.to_s]
+          end
+        else
+          accu << [key.to_s, value.to_s]
+        end
+        accu
+      end
+
+      if sort
+        # Useful for OAuth and optimizing caching systems
+        form_values = form_values.sort
+      end
+      escaped_form_values = form_values.map do |(key, value)|
+        # Line breaks are CRLF pairs
+        [
+          self.encode_component(
+            key.gsub(/(\r\n|\n|\r)/, "\r\n"),
+            CharacterClassesRegexps::UNRESERVED
+          ).gsub("%20", "+"),
+          self.encode_component(
+            value.gsub(/(\r\n|\n|\r)/, "\r\n"),
+            CharacterClassesRegexps::UNRESERVED
+          ).gsub("%20", "+")
+        ]
+      end
+      return escaped_form_values.map do |(key, value)|
+        "#{key}=#{value}"
+      end.join("&")
+    end
+
+    ##
+    # Decodes a <code>String</code> according to the rules for the
+    # <code>application/x-www-form-urlencoded</code> MIME type.
+    #
+    # @param [String, #to_str] encoded_value
+    #   The form values to decode.
+    #
+    # @return [Array]
+    #   The decoded values.
+    #   This is not a <code>Hash</code> because of the possibility for
+    #   duplicate keys.
+    def self.form_unencode(encoded_value)
+      if !encoded_value.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{encoded_value.class} into String."
+      end
+      encoded_value = encoded_value.to_str
+      split_values = encoded_value.split("&").map do |pair|
+        pair.split("=", 2)
+      end
+      return split_values.map do |(key, value)|
+        [
+          key ? self.unencode_component(
+            key.gsub("+", "%20")).gsub(/(\r\n|\n|\r)/, "\n") : nil,
+          value ? (self.unencode_component(
+            value.gsub("+", "%20")).gsub(/(\r\n|\n|\r)/, "\n")) : nil
+        ]
+      end
+    end
+
+    ##
+    # Creates a new uri object from component parts.
+    #
+    # @option [String, #to_str] scheme The scheme component.
+    # @option [String, #to_str] user The user component.
+    # @option [String, #to_str] password The password component.
+    # @option [String, #to_str] userinfo
+    #   The userinfo component. If this is supplied, the user and password
+    #   components must be omitted.
+    # @option [String, #to_str] host The host component.
+    # @option [String, #to_str] port The port component.
+    # @option [String, #to_str] authority
+    #   The authority component. If this is supplied, the user, password,
+    #   userinfo, host, and port components must be omitted.
+    # @option [String, #to_str] path The path component.
+    # @option [String, #to_str] query The query component.
+    # @option [String, #to_str] fragment The fragment component.
+    #
+    # @return [Addressable::URI] The constructed URI object.
+    def initialize(options={})
+      if options.has_key?(:authority)
+        if (options.keys & [:userinfo, :user, :password, :host, :port]).any?
+          raise ArgumentError,
+            "Cannot specify both an authority and any of the components " +
+            "within the authority."
+        end
+      end
+      if options.has_key?(:userinfo)
+        if (options.keys & [:user, :password]).any?
+          raise ArgumentError,
+            "Cannot specify both a userinfo and either the user or password."
+        end
+      end
+
+      reset_ivs
+
+      defer_validation do
+        # Bunch of crazy logic required because of the composite components
+        # like userinfo and authority.
+        self.scheme = options[:scheme] if options[:scheme]
+        self.user = options[:user] if options[:user]
+        self.password = options[:password] if options[:password]
+        self.userinfo = options[:userinfo] if options[:userinfo]
+        self.host = options[:host] if options[:host]
+        self.port = options[:port] if options[:port]
+        self.authority = options[:authority] if options[:authority]
+        self.path = options[:path] if options[:path]
+        self.query = options[:query] if options[:query]
+        self.query_values = options[:query_values] if options[:query_values]
+        self.fragment = options[:fragment] if options[:fragment]
+      end
+
+      to_s # force path validation
+    end
+
+    ##
+    # Freeze URI, initializing instance variables.
+    #
+    # @return [Addressable::URI] The frozen URI object.
+    def freeze
+      self.normalized_scheme
+      self.normalized_user
+      self.normalized_password
+      self.normalized_userinfo
+      self.normalized_host
+      self.normalized_port
+      self.normalized_authority
+      self.normalized_site
+      self.normalized_path
+      self.normalized_query
+      self.normalized_fragment
+      self.hash
+      super
+    end
+
+    ##
+    # The scheme component for this URI.
+    #
+    # @return [String] The scheme component.
+    attr_reader :scheme
+
+    ##
+    # The scheme component for this URI, normalized.
+    #
+    # @return [String] The scheme component, normalized.
+    def normalized_scheme
+      return nil unless self.scheme
+      if @normalized_scheme == NONE
+        @normalized_scheme = if self.scheme =~ /^\s*ssh\+svn\s*$/i
+          "svn+ssh".dup
+        else
+          Addressable::URI.normalize_component(
+            self.scheme.strip.downcase,
+            Addressable::URI::NormalizeCharacterClasses::SCHEME
+          )
+        end
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_scheme)
+      @normalized_scheme
+    end
+
+    ##
+    # Sets the scheme component for this URI.
+    #
+    # @param [String, #to_str] new_scheme The new scheme component.
+    def scheme=(new_scheme)
+      if new_scheme && !new_scheme.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_scheme.class} into String."
+      elsif new_scheme
+        new_scheme = new_scheme.to_str
+      end
+      if new_scheme && new_scheme !~ /\A[a-z][a-z0-9\.\+\-]*\z/i
+        raise InvalidURIError, "Invalid scheme format: '#{new_scheme}'"
+      end
+      @scheme = new_scheme
+      @scheme = nil if @scheme.to_s.strip.empty?
+
+      # Reset dependent values
+      @normalized_scheme = NONE
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The user component for this URI.
+    #
+    # @return [String] The user component.
+    attr_reader :user
+
+    ##
+    # The user component for this URI, normalized.
+    #
+    # @return [String] The user component, normalized.
+    def normalized_user
+      return nil unless self.user
+      return @normalized_user unless @normalized_user == NONE
+      @normalized_user = begin
+        if normalized_scheme =~ /https?/ && self.user.strip.empty? &&
+            (!self.password || self.password.strip.empty?)
+          nil
+        else
+          Addressable::URI.normalize_component(
+            self.user.strip,
+            Addressable::URI::NormalizeCharacterClasses::UNRESERVED
+          )
+        end
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_user)
+      @normalized_user
+    end
+
+    ##
+    # Sets the user component for this URI.
+    #
+    # @param [String, #to_str] new_user The new user component.
+    def user=(new_user)
+      if new_user && !new_user.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_user.class} into String."
+      end
+      @user = new_user ? new_user.to_str : nil
+
+      # You can't have a nil user with a non-nil password
+      if password != nil
+        @user = EMPTY_STR unless user
+      end
+
+      # Reset dependent values
+      @userinfo = nil
+      @normalized_userinfo = NONE
+      @authority = nil
+      @normalized_user = NONE
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The password component for this URI.
+    #
+    # @return [String] The password component.
+    attr_reader :password
+
+    ##
+    # The password component for this URI, normalized.
+    #
+    # @return [String] The password component, normalized.
+    def normalized_password
+      return nil unless self.password
+      return @normalized_password unless @normalized_password == NONE
+      @normalized_password = begin
+        if self.normalized_scheme =~ /https?/ && self.password.strip.empty? &&
+            (!self.user || self.user.strip.empty?)
+          nil
+        else
+          Addressable::URI.normalize_component(
+            self.password.strip,
+            Addressable::URI::NormalizeCharacterClasses::UNRESERVED
+          )
+        end
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_password)
+      @normalized_password
+    end
+
+    ##
+    # Sets the password component for this URI.
+    #
+    # @param [String, #to_str] new_password The new password component.
+    def password=(new_password)
+      if new_password && !new_password.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_password.class} into String."
+      end
+      @password = new_password ? new_password.to_str : nil
+
+      # You can't have a nil user with a non-nil password
+      if @password != nil
+        self.user = EMPTY_STR if user.nil?
+      end
+
+      # Reset dependent values
+      @userinfo = nil
+      @normalized_userinfo = NONE
+      @authority = nil
+      @normalized_password = NONE
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The userinfo component for this URI.
+    # Combines the user and password components.
+    #
+    # @return [String] The userinfo component.
+    def userinfo
+      current_user = self.user
+      current_password = self.password
+      (current_user || current_password) && @userinfo ||= begin
+        if current_user && current_password
+          "#{current_user}:#{current_password}"
+        elsif current_user && !current_password
+          "#{current_user}"
+        end
+      end
+    end
+
+    ##
+    # The userinfo component for this URI, normalized.
+    #
+    # @return [String] The userinfo component, normalized.
+    def normalized_userinfo
+      return nil unless self.userinfo
+      return @normalized_userinfo unless @normalized_userinfo == NONE
+      @normalized_userinfo = begin
+        current_user = self.normalized_user
+        current_password = self.normalized_password
+        if !current_user && !current_password
+          nil
+        elsif current_user && current_password
+          "#{current_user}:#{current_password}".dup
+        elsif current_user && !current_password
+          "#{current_user}".dup
+        end
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_userinfo)
+      @normalized_userinfo
+    end
+
+    ##
+    # Sets the userinfo component for this URI.
+    #
+    # @param [String, #to_str] new_userinfo The new userinfo component.
+    def userinfo=(new_userinfo)
+      if new_userinfo && !new_userinfo.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_userinfo.class} into String."
+      end
+      new_user, new_password = if new_userinfo
+        [
+          new_userinfo.to_str.strip[/^(.*):/, 1],
+          new_userinfo.to_str.strip[/:(.*)$/, 1]
+        ]
+      else
+        [nil, nil]
+      end
+
+      # Password assigned first to ensure validity in case of nil
+      self.password = new_password
+      self.user = new_user
+
+      # Reset dependent values
+      @authority = nil
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The host component for this URI.
+    #
+    # @return [String] The host component.
+    attr_reader :host
+
+    ##
+    # The host component for this URI, normalized.
+    #
+    # @return [String] The host component, normalized.
+    def normalized_host
+      return nil unless self.host
+
+      @normalized_host ||= begin
+        if !self.host.strip.empty?
+          result = ::Addressable::IDNA.to_ascii(
+            URI.unencode_component(self.host.strip.downcase)
+          )
+          if result =~ /[^\.]\.$/
+            # Single trailing dots are unnecessary.
+            result = result[0...-1]
+          end
+          result = Addressable::URI.normalize_component(
+            result,
+            NormalizeCharacterClasses::HOST
+          )
+          result
+        else
+          EMPTY_STR.dup
+        end
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_host)
+      @normalized_host
+    end
+
+    ##
+    # Sets the host component for this URI.
+    #
+    # @param [String, #to_str] new_host The new host component.
+    def host=(new_host)
+      if new_host && !new_host.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_host.class} into String."
+      end
+      @host = new_host ? new_host.to_str : nil
+
+      # Reset dependent values
+      @authority = nil
+      @normalized_host = nil
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # This method is same as URI::Generic#host except
+    # brackets for IPv6 (and 'IPvFuture') addresses are removed.
+    #
+    # @see Addressable::URI#host
+    #
+    # @return [String] The hostname for this URI.
+    def hostname
+      v = self.host
+      /\A\[(.*)\]\z/ =~ v ? $1 : v
+    end
+
+    ##
+    # This method is same as URI::Generic#host= except
+    # the argument can be a bare IPv6 address (or 'IPvFuture').
+    #
+    # @see Addressable::URI#host=
+    #
+    # @param [String, #to_str] new_hostname The new hostname for this URI.
+    def hostname=(new_hostname)
+      if new_hostname &&
+          (new_hostname.respond_to?(:ipv4?) || new_hostname.respond_to?(:ipv6?))
+        new_hostname = new_hostname.to_s
+      elsif new_hostname && !new_hostname.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_hostname.class} into String."
+      end
+      v = new_hostname ? new_hostname.to_str : nil
+      v = "[#{v}]" if /\A\[.*\]\z/ !~ v && /:/ =~ v
+      self.host = v
+    end
+
+    ##
+    # Returns the top-level domain for this host.
+    #
+    # @example
+    #   Addressable::URI.parse("http://www.example.co.uk").tld # => "co.uk"
+    def tld
+      PublicSuffix.parse(self.host, ignore_private: true).tld
+    end
+
+    ##
+    # Sets the top-level domain for this URI.
+    #
+    # @param [String, #to_str] new_tld The new top-level domain.
+    def tld=(new_tld)
+      replaced_tld = host.sub(/#{tld}\z/, new_tld)
+      self.host = PublicSuffix::Domain.new(replaced_tld).to_s
+    end
+
+    ##
+    # Returns the public suffix domain for this host.
+    #
+    # @example
+    #   Addressable::URI.parse("http://www.example.co.uk").domain # => "example.co.uk"
+    def domain
+      PublicSuffix.domain(self.host, ignore_private: true)
+    end
+
+    ##
+    # The authority component for this URI.
+    # Combines the user, password, host, and port components.
+    #
+    # @return [String] The authority component.
+    def authority
+      self.host && @authority ||= begin
+        authority = String.new
+        if self.userinfo != nil
+          authority << "#{self.userinfo}@"
+        end
+        authority << self.host
+        if self.port != nil
+          authority << ":#{self.port}"
+        end
+        authority
+      end
+    end
+
+    ##
+    # The authority component for this URI, normalized.
+    #
+    # @return [String] The authority component, normalized.
+    def normalized_authority
+      return nil unless self.authority
+      @normalized_authority ||= begin
+        authority = String.new
+        if self.normalized_userinfo != nil
+          authority << "#{self.normalized_userinfo}@"
+        end
+        authority << self.normalized_host
+        if self.normalized_port != nil
+          authority << ":#{self.normalized_port}"
+        end
+        authority
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_authority)
+      @normalized_authority
+    end
+
+    ##
+    # Sets the authority component for this URI.
+    #
+    # @param [String, #to_str] new_authority The new authority component.
+    def authority=(new_authority)
+      if new_authority
+        if !new_authority.respond_to?(:to_str)
+          raise TypeError, "Can't convert #{new_authority.class} into String."
+        end
+        new_authority = new_authority.to_str
+        new_userinfo = new_authority[/^([^\[\]]*)@/, 1]
+        if new_userinfo
+          new_user = new_userinfo.strip[/^([^:]*):?/, 1]
+          new_password = new_userinfo.strip[/:(.*)$/, 1]
+        end
+        new_host = new_authority.sub(
+          /^([^\[\]]*)@/, EMPTY_STR
+        ).sub(
+          /:([^:@\[\]]*?)$/, EMPTY_STR
+        )
+        new_port =
+          new_authority[/:([^:@\[\]]*?)$/, 1]
+      end
+
+      # Password assigned first to ensure validity in case of nil
+      self.password = new_password
+      self.user = new_user
+      self.host = new_host
+      self.port = new_port
+
+      # Reset dependent values
+      @userinfo = nil
+      @normalized_userinfo = NONE
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The origin for this URI, serialized to ASCII, as per
+    # RFC 6454, section 6.2.
+    #
+    # @return [String] The serialized origin.
+    def origin
+      if self.scheme && self.authority
+        if self.normalized_port
+          "#{self.normalized_scheme}://#{self.normalized_host}" +
+          ":#{self.normalized_port}"
+        else
+          "#{self.normalized_scheme}://#{self.normalized_host}"
+        end
+      else
+        "null"
+      end
+    end
+
+    ##
+    # Sets the origin for this URI, serialized to ASCII, as per
+    # RFC 6454, section 6.2. This assignment will reset the `userinfo`
+    # component.
+    #
+    # @param [String, #to_str] new_origin The new origin component.
+    def origin=(new_origin)
+      if new_origin
+        if !new_origin.respond_to?(:to_str)
+          raise TypeError, "Can't convert #{new_origin.class} into String."
+        end
+        new_origin = new_origin.to_str
+        new_scheme = new_origin[/^([^:\/?#]+):\/\//, 1]
+        unless new_scheme
+          raise InvalidURIError, 'An origin cannot omit the scheme.'
+        end
+        new_host = new_origin[/:\/\/([^\/?#:]+)/, 1]
+        unless new_host
+          raise InvalidURIError, 'An origin cannot omit the host.'
+        end
+        new_port = new_origin[/:([^:@\[\]\/]*?)$/, 1]
+      end
+
+      self.scheme = new_scheme
+      self.host = new_host
+      self.port = new_port
+      self.userinfo = nil
+
+      # Reset dependent values
+      @userinfo = nil
+      @normalized_userinfo = NONE
+      @authority = nil
+      @normalized_authority = nil
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    # Returns an array of known ip-based schemes. These schemes typically
+    # use a similar URI form:
+    # <code>//<user>:<password>@<host>:<port>/<url-path></code>
+    def self.ip_based_schemes
+      return self.port_mapping.keys
+    end
+
+    # Returns a hash of common IP-based schemes and their default port
+    # numbers. Adding new schemes to this hash, as necessary, will allow
+    # for better URI normalization.
+    def self.port_mapping
+      PORT_MAPPING
+    end
+
+    ##
+    # The port component for this URI.
+    # This is the port number actually given in the URI. This does not
+    # infer port numbers from default values.
+    #
+    # @return [Integer] The port component.
+    attr_reader :port
+
+    ##
+    # The port component for this URI, normalized.
+    #
+    # @return [Integer] The port component, normalized.
+    def normalized_port
+      return nil unless self.port
+      return @normalized_port unless @normalized_port == NONE
+      @normalized_port = begin
+        if URI.port_mapping[self.normalized_scheme] == self.port
+          nil
+        else
+          self.port
+        end
+      end
+    end
+
+    ##
+    # Sets the port component for this URI.
+    #
+    # @param [String, Integer, #to_s] new_port The new port component.
+    def port=(new_port)
+      if new_port != nil && new_port.respond_to?(:to_str)
+        new_port = Addressable::URI.unencode_component(new_port.to_str)
+      end
+
+      if new_port.respond_to?(:valid_encoding?) && !new_port.valid_encoding?
+        raise InvalidURIError, "Invalid encoding in port"
+      end
+
+      if new_port != nil && !(new_port.to_s =~ /^\d+$/)
+        raise InvalidURIError,
+          "Invalid port number: #{new_port.inspect}"
+      end
+
+      @port = new_port.to_s.to_i
+      @port = nil if @port == 0
+
+      # Reset dependent values
+      @authority = nil
+      @normalized_port = NONE
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The inferred port component for this URI.
+    # This method will normalize to the default port for the URI's scheme if
+    # the port isn't explicitly specified in the URI.
+    #
+    # @return [Integer] The inferred port component.
+    def inferred_port
+      if self.port.to_i == 0
+        self.default_port
+      else
+        self.port.to_i
+      end
+    end
+
+    ##
+    # The default port for this URI's scheme.
+    # This method will always returns the default port for the URI's scheme
+    # regardless of the presence of an explicit port in the URI.
+    #
+    # @return [Integer] The default port.
+    def default_port
+      URI.port_mapping[self.scheme.strip.downcase] if self.scheme
+    end
+
+    ##
+    # The combination of components that represent a site.
+    # Combines the scheme, user, password, host, and port components.
+    # Primarily useful for HTTP and HTTPS.
+    #
+    # For example, <code>"http://example.com/path?query"</code> would have a
+    # <code>site</code> value of <code>"http://example.com"</code>.
+    #
+    # @return [String] The components that identify a site.
+    def site
+      (self.scheme || self.authority) && @site ||= begin
+        site_string = "".dup
+        site_string << "#{self.scheme}:" if self.scheme != nil
+        site_string << "//#{self.authority}" if self.authority != nil
+        site_string
+      end
+    end
+
+    ##
+    # The normalized combination of components that represent a site.
+    # Combines the scheme, user, password, host, and port components.
+    # Primarily useful for HTTP and HTTPS.
+    #
+    # For example, <code>"http://example.com/path?query"</code> would have a
+    # <code>site</code> value of <code>"http://example.com"</code>.
+    #
+    # @return [String] The normalized components that identify a site.
+    def normalized_site
+      return nil unless self.site
+      @normalized_site ||= begin
+        site_string = "".dup
+        if self.normalized_scheme != nil
+          site_string << "#{self.normalized_scheme}:"
+        end
+        if self.normalized_authority != nil
+          site_string << "//#{self.normalized_authority}"
+        end
+        site_string
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_site)
+      @normalized_site
+    end
+
+    ##
+    # Sets the site value for this URI.
+    #
+    # @param [String, #to_str] new_site The new site value.
+    def site=(new_site)
+      if new_site
+        if !new_site.respond_to?(:to_str)
+          raise TypeError, "Can't convert #{new_site.class} into String."
+        end
+        new_site = new_site.to_str
+        # These two regular expressions derived from the primary parsing
+        # expression
+        self.scheme = new_site[/^(?:([^:\/?#]+):)?(?:\/\/(?:[^\/?#]*))?$/, 1]
+        self.authority = new_site[
+          /^(?:(?:[^:\/?#]+):)?(?:\/\/([^\/?#]*))?$/, 1
+        ]
+      else
+        self.scheme = nil
+        self.authority = nil
+      end
+    end
+
+    ##
+    # The path component for this URI.
+    #
+    # @return [String] The path component.
+    attr_reader :path
+
+    NORMPATH = /^(?!\/)[^\/:]*:.*$/
+    ##
+    # The path component for this URI, normalized.
+    #
+    # @return [String] The path component, normalized.
+    def normalized_path
+      @normalized_path ||= begin
+        path = self.path.to_s
+        if self.scheme == nil && path =~ NORMPATH
+          # Relative paths with colons in the first segment are ambiguous.
+          path = path.sub(":", "%2F")
+        end
+        # String#split(delimiter, -1) uses the more strict splitting behavior
+        # found by default in Python.
+        result = path.strip.split(SLASH, -1).map do |segment|
+          Addressable::URI.normalize_component(
+            segment,
+            Addressable::URI::NormalizeCharacterClasses::PCHAR
+          )
+        end.join(SLASH)
+
+        result = URI.normalize_path(result)
+        if result.empty? &&
+            ["http", "https", "ftp", "tftp"].include?(self.normalized_scheme)
+          result = SLASH.dup
+        end
+        result
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_path)
+      @normalized_path
+    end
+
+    ##
+    # Sets the path component for this URI.
+    #
+    # @param [String, #to_str] new_path The new path component.
+    def path=(new_path)
+      if new_path && !new_path.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_path.class} into String."
+      end
+      @path = (new_path || EMPTY_STR).to_str
+      if !@path.empty? && @path[0..0] != SLASH && host != nil
+        @path = "/#{@path}"
+      end
+
+      # Reset dependent values
+      @normalized_path = nil
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # The basename, if any, of the file in the path component.
+    #
+    # @return [String] The path's basename.
+    def basename
+      # Path cannot be nil
+      return File.basename(self.path).sub(/;[^\/]*$/, EMPTY_STR)
+    end
+
+    ##
+    # The extname, if any, of the file in the path component.
+    # Empty string if there is no extension.
+    #
+    # @return [String] The path's extname.
+    def extname
+      return nil unless self.path
+      return File.extname(self.basename)
+    end
+
+    ##
+    # The query component for this URI.
+    #
+    # @return [String] The query component.
+    attr_reader :query
+
+    ##
+    # The query component for this URI, normalized.
+    #
+    # @return [String] The query component, normalized.
+    def normalized_query(*flags)
+      return nil unless self.query
+      return @normalized_query unless @normalized_query == NONE
+      @normalized_query = begin
+        modified_query_class = Addressable::URI::CharacterClasses::QUERY.dup
+        # Make sure possible key-value pair delimiters are escaped.
+        modified_query_class.sub!("\\&", "").sub!("\\;", "")
+        pairs = (query || "").split("&", -1)
+        pairs.delete_if(&:empty?).uniq! if flags.include?(:compacted)
+        pairs.sort! if flags.include?(:sorted)
+        component = pairs.map do |pair|
+          Addressable::URI.normalize_component(
+            pair,
+            Addressable::URI::NormalizeCharacterClasses::QUERY,
+            "+"
+          )
+        end.join("&")
+        component == "" ? nil : component
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_query)
+      @normalized_query
+    end
+
+    ##
+    # Sets the query component for this URI.
+    #
+    # @param [String, #to_str] new_query The new query component.
+    def query=(new_query)
+      if new_query && !new_query.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_query.class} into String."
+      end
+      @query = new_query ? new_query.to_str : nil
+
+      # Reset dependent values
+      @normalized_query = NONE
+      remove_composite_values
+    end
+
+    ##
+    # Converts the query component to a Hash value.
+    #
+    # @param [Class] return_type The return type desired. Value must be either
+    #   `Hash` or `Array`.
+    #
+    # @return [Hash, Array, nil] The query string parsed as a Hash or Array
+    #   or nil if the query string is blank.
+    #
+    # @example
+    #   Addressable::URI.parse("?one=1&two=2&three=3").query_values
+    #   #=> {"one" => "1", "two" => "2", "three" => "3"}
+    #   Addressable::URI.parse("?one=two&one=three").query_values(Array)
+    #   #=> [["one", "two"], ["one", "three"]]
+    #   Addressable::URI.parse("?one=two&one=three").query_values(Hash)
+    #   #=> {"one" => "three"}
+    #   Addressable::URI.parse("?").query_values
+    #   #=> {}
+    #   Addressable::URI.parse("").query_values
+    #   #=> nil
+    def query_values(return_type=Hash)
+      empty_accumulator = Array == return_type ? [] : {}
+      if return_type != Hash && return_type != Array
+        raise ArgumentError, "Invalid return type. Must be Hash or Array."
+      end
+      return nil if self.query == nil
+      split_query = self.query.split("&").map do |pair|
+        pair.split("=", 2) if pair && !pair.empty?
+      end.compact
+      return split_query.inject(empty_accumulator.dup) do |accu, pair|
+        # I'd rather use key/value identifiers instead of array lookups,
+        # but in this case I really want to maintain the exact pair structure,
+        # so it's best to make all changes in-place.
+        pair[0] = URI.unencode_component(pair[0])
+        if pair[1].respond_to?(:to_str)
+          value = pair[1].to_str
+          # I loathe the fact that I have to do this. Stupid HTML 4.01.
+          # Treating '+' as a space was just an unbelievably bad idea.
+          # There was nothing wrong with '%20'!
+          # If it ain't broke, don't fix it!
+          value = value.tr("+", " ") if ["http", "https", nil].include?(scheme)
+          pair[1] = URI.unencode_component(value)
+        end
+        if return_type == Hash
+          accu[pair[0]] = pair[1]
+        else
+          accu << pair
+        end
+        accu
+      end
+    end
+
+    ##
+    # Sets the query component for this URI from a Hash object.
+    # An empty Hash or Array will result in an empty query string.
+    #
+    # @param [Hash, #to_hash, Array] new_query_values The new query values.
+    #
+    # @example
+    #   uri.query_values = {:a => "a", :b => ["c", "d", "e"]}
+    #   uri.query
+    #   # => "a=a&b=c&b=d&b=e"
+    #   uri.query_values = [['a', 'a'], ['b', 'c'], ['b', 'd'], ['b', 'e']]
+    #   uri.query
+    #   # => "a=a&b=c&b=d&b=e"
+    #   uri.query_values = [['a', 'a'], ['b', ['c', 'd', 'e']]]
+    #   uri.query
+    #   # => "a=a&b=c&b=d&b=e"
+    #   uri.query_values = [['flag'], ['key', 'value']]
+    #   uri.query
+    #   # => "flag&key=value"
+    def query_values=(new_query_values)
+      if new_query_values == nil
+        self.query = nil
+        return nil
+      end
+
+      if !new_query_values.is_a?(Array)
+        if !new_query_values.respond_to?(:to_hash)
+          raise TypeError,
+            "Can't convert #{new_query_values.class} into Hash."
+        end
+        new_query_values = new_query_values.to_hash
+        new_query_values = new_query_values.map do |key, value|
+          key = key.to_s if key.kind_of?(Symbol)
+          [key, value]
+        end
+        # Useful default for OAuth and caching.
+        # Only to be used for non-Array inputs. Arrays should preserve order.
+        new_query_values.sort!
+      end
+
+      # new_query_values have form [['key1', 'value1'], ['key2', 'value2']]
+      buffer = "".dup
+      new_query_values.each do |key, value|
+        encoded_key = URI.encode_component(
+          key, CharacterClassesRegexps::UNRESERVED
+        )
+        if value == nil
+          buffer << "#{encoded_key}&"
+        elsif value.kind_of?(Array)
+          value.each do |sub_value|
+            encoded_value = URI.encode_component(
+              sub_value, CharacterClassesRegexps::UNRESERVED
+            )
+            buffer << "#{encoded_key}=#{encoded_value}&"
+          end
+        else
+          encoded_value = URI.encode_component(
+            value, CharacterClassesRegexps::UNRESERVED
+          )
+          buffer << "#{encoded_key}=#{encoded_value}&"
+        end
+      end
+      self.query = buffer.chop
+    end
+
+    ##
+    # The HTTP request URI for this URI.  This is the path and the
+    # query string.
+    #
+    # @return [String] The request URI required for an HTTP request.
+    def request_uri
+      return nil if self.absolute? && self.scheme !~ /^https?$/i
+      return (
+        (!self.path.empty? ? self.path : SLASH) +
+        (self.query ? "?#{self.query}" : EMPTY_STR)
+      )
+    end
+
+    ##
+    # Sets the HTTP request URI for this URI.
+    #
+    # @param [String, #to_str] new_request_uri The new HTTP request URI.
+    def request_uri=(new_request_uri)
+      if !new_request_uri.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_request_uri.class} into String."
+      end
+      if self.absolute? && self.scheme !~ /^https?$/i
+        raise InvalidURIError,
+          "Cannot set an HTTP request URI for a non-HTTP URI."
+      end
+      new_request_uri = new_request_uri.to_str
+      path_component = new_request_uri[/^([^\?]*)\??(?:.*)$/, 1]
+      query_component = new_request_uri[/^(?:[^\?]*)\?(.*)$/, 1]
+      path_component = path_component.to_s
+      path_component = (!path_component.empty? ? path_component : SLASH)
+      self.path = path_component
+      self.query = query_component
+
+      # Reset dependent values
+      remove_composite_values
+    end
+
+    ##
+    # The fragment component for this URI.
+    #
+    # @return [String] The fragment component.
+    attr_reader :fragment
+
+    ##
+    # The fragment component for this URI, normalized.
+    #
+    # @return [String] The fragment component, normalized.
+    def normalized_fragment
+      return nil unless self.fragment
+      return @normalized_fragment unless @normalized_fragment == NONE
+      @normalized_fragment = begin
+        component = Addressable::URI.normalize_component(
+          self.fragment,
+          Addressable::URI::NormalizeCharacterClasses::FRAGMENT
+        )
+        component == "" ? nil : component
+      end
+      # All normalized values should be UTF-8
+      force_utf8_encoding_if_needed(@normalized_fragment)
+      @normalized_fragment
+    end
+
+    ##
+    # Sets the fragment component for this URI.
+    #
+    # @param [String, #to_str] new_fragment The new fragment component.
+    def fragment=(new_fragment)
+      if new_fragment && !new_fragment.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{new_fragment.class} into String."
+      end
+      @fragment = new_fragment ? new_fragment.to_str : nil
+
+      # Reset dependent values
+      @normalized_fragment = NONE
+      remove_composite_values
+
+      # Ensure we haven't created an invalid URI
+      validate()
+    end
+
+    ##
+    # Determines if the scheme indicates an IP-based protocol.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the scheme indicates an IP-based protocol.
+    #   <code>false</code> otherwise.
+    def ip_based?
+      if self.scheme
+        return URI.ip_based_schemes.include?(
+          self.scheme.strip.downcase)
+      end
+      return false
+    end
+
+    ##
+    # Determines if the URI is relative.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the URI is relative. <code>false</code>
+    #   otherwise.
+    def relative?
+      return self.scheme.nil?
+    end
+
+    ##
+    # Determines if the URI is absolute.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the URI is absolute. <code>false</code>
+    #   otherwise.
+    def absolute?
+      return !relative?
+    end
+
+    ##
+    # Joins two URIs together.
+    #
+    # @param [String, Addressable::URI, #to_str] The URI to join with.
+    #
+    # @return [Addressable::URI] The joined URI.
+    def join(uri)
+      if !uri.respond_to?(:to_str)
+        raise TypeError, "Can't convert #{uri.class} into String."
+      end
+      if !uri.kind_of?(URI)
+        # Otherwise, convert to a String, then parse.
+        uri = URI.parse(uri.to_str)
+      end
+      if uri.to_s.empty?
+        return self.dup
+      end
+
+      joined_scheme = nil
+      joined_user = nil
+      joined_password = nil
+      joined_host = nil
+      joined_port = nil
+      joined_path = nil
+      joined_query = nil
+      joined_fragment = nil
+
+      # Section 5.2.2 of RFC 3986
+      if uri.scheme != nil
+        joined_scheme = uri.scheme
+        joined_user = uri.user
+        joined_password = uri.password
+        joined_host = uri.host
+        joined_port = uri.port
+        joined_path = URI.normalize_path(uri.path)
+        joined_query = uri.query
+      else
+        if uri.authority != nil
+          joined_user = uri.user
+          joined_password = uri.password
+          joined_host = uri.host
+          joined_port = uri.port
+          joined_path = URI.normalize_path(uri.path)
+          joined_query = uri.query
+        else
+          if uri.path == nil || uri.path.empty?
+            joined_path = self.path
+            if uri.query != nil
+              joined_query = uri.query
+            else
+              joined_query = self.query
+            end
+          else
+            if uri.path[0..0] == SLASH
+              joined_path = URI.normalize_path(uri.path)
+            else
+              base_path = self.path.dup
+              base_path = EMPTY_STR if base_path == nil
+              base_path = URI.normalize_path(base_path)
+
+              # Section 5.2.3 of RFC 3986
+              #
+              # Removes the right-most path segment from the base path.
+              if base_path.include?(SLASH)
+                base_path.sub!(/\/[^\/]+$/, SLASH)
+              else
+                base_path = EMPTY_STR
+              end
+
+              # If the base path is empty and an authority segment has been
+              # defined, use a base path of SLASH
+              if base_path.empty? && self.authority != nil
+                base_path = SLASH
+              end
+
+              joined_path = URI.normalize_path(base_path + uri.path)
+            end
+            joined_query = uri.query
+          end
+          joined_user = self.user
+          joined_password = self.password
+          joined_host = self.host
+          joined_port = self.port
+        end
+        joined_scheme = self.scheme
+      end
+      joined_fragment = uri.fragment
+
+      return self.class.new(
+        :scheme => joined_scheme,
+        :user => joined_user,
+        :password => joined_password,
+        :host => joined_host,
+        :port => joined_port,
+        :path => joined_path,
+        :query => joined_query,
+        :fragment => joined_fragment
+      )
+    end
+    alias_method :+, :join
+
+    ##
+    # Destructive form of <code>join</code>.
+    #
+    # @param [String, Addressable::URI, #to_str] The URI to join with.
+    #
+    # @return [Addressable::URI] The joined URI.
+    #
+    # @see Addressable::URI#join
+    def join!(uri)
+      replace_self(self.join(uri))
+    end
+
+    ##
+    # Merges a URI with a <code>Hash</code> of components.
+    # This method has different behavior from <code>join</code>. Any
+    # components present in the <code>hash</code> parameter will override the
+    # original components. The path component is not treated specially.
+    #
+    # @param [Hash, Addressable::URI, #to_hash] The components to merge with.
+    #
+    # @return [Addressable::URI] The merged URI.
+    #
+    # @see Hash#merge
+    def merge(hash)
+      unless hash.respond_to?(:to_hash)
+        raise TypeError, "Can't convert #{hash.class} into Hash."
+      end
+      hash = hash.to_hash
+
+      if hash.has_key?(:authority)
+        if (hash.keys & [:userinfo, :user, :password, :host, :port]).any?
+          raise ArgumentError,
+            "Cannot specify both an authority and any of the components " +
+            "within the authority."
+        end
+      end
+      if hash.has_key?(:userinfo)
+        if (hash.keys & [:user, :password]).any?
+          raise ArgumentError,
+            "Cannot specify both a userinfo and either the user or password."
+        end
+      end
+
+      uri = self.class.new
+      uri.defer_validation do
+        # Bunch of crazy logic required because of the composite components
+        # like userinfo and authority.
+        uri.scheme =
+          hash.has_key?(:scheme) ? hash[:scheme] : self.scheme
+        if hash.has_key?(:authority)
+          uri.authority =
+            hash.has_key?(:authority) ? hash[:authority] : self.authority
+        end
+        if hash.has_key?(:userinfo)
+          uri.userinfo =
+            hash.has_key?(:userinfo) ? hash[:userinfo] : self.userinfo
+        end
+        if !hash.has_key?(:userinfo) && !hash.has_key?(:authority)
+          uri.user =
+            hash.has_key?(:user) ? hash[:user] : self.user
+          uri.password =
+            hash.has_key?(:password) ? hash[:password] : self.password
+        end
+        if !hash.has_key?(:authority)
+          uri.host =
+            hash.has_key?(:host) ? hash[:host] : self.host
+          uri.port =
+            hash.has_key?(:port) ? hash[:port] : self.port
+        end
+        uri.path =
+          hash.has_key?(:path) ? hash[:path] : self.path
+        uri.query =
+          hash.has_key?(:query) ? hash[:query] : self.query
+        uri.fragment =
+          hash.has_key?(:fragment) ? hash[:fragment] : self.fragment
+      end
+
+      return uri
+    end
+
+    ##
+    # Destructive form of <code>merge</code>.
+    #
+    # @param [Hash, Addressable::URI, #to_hash] The components to merge with.
+    #
+    # @return [Addressable::URI] The merged URI.
+    #
+    # @see Addressable::URI#merge
+    def merge!(uri)
+      replace_self(self.merge(uri))
+    end
+
+    ##
+    # Returns the shortest normalized relative form of this URI that uses the
+    # supplied URI as a base for resolution. Returns an absolute URI if
+    # necessary. This is effectively the opposite of <code>route_to</code>.
+    #
+    # @param [String, Addressable::URI, #to_str] uri The URI to route from.
+    #
+    # @return [Addressable::URI]
+    #   The normalized relative URI that is equivalent to the original URI.
+    def route_from(uri)
+      uri = URI.parse(uri).normalize
+      normalized_self = self.normalize
+      if normalized_self.relative?
+        raise ArgumentError, "Expected absolute URI, got: #{self.to_s}"
+      end
+      if uri.relative?
+        raise ArgumentError, "Expected absolute URI, got: #{uri.to_s}"
+      end
+      if normalized_self == uri
+        return Addressable::URI.parse("##{normalized_self.fragment}")
+      end
+      components = normalized_self.to_hash
+      if normalized_self.scheme == uri.scheme
+        components[:scheme] = nil
+        if normalized_self.authority == uri.authority
+          components[:user] = nil
+          components[:password] = nil
+          components[:host] = nil
+          components[:port] = nil
+          if normalized_self.path == uri.path
+            components[:path] = nil
+            if normalized_self.query == uri.query
+              components[:query] = nil
+            end
+          else
+            if uri.path != SLASH and components[:path]
+              self_splitted_path = split_path(components[:path])
+              uri_splitted_path = split_path(uri.path)
+              self_dir = self_splitted_path.shift
+              uri_dir = uri_splitted_path.shift
+              while !self_splitted_path.empty? && !uri_splitted_path.empty? and self_dir == uri_dir
+                self_dir = self_splitted_path.shift
+                uri_dir = uri_splitted_path.shift
+              end
+              components[:path] = (uri_splitted_path.fill('..') + [self_dir] + self_splitted_path).join(SLASH)
+            end
+          end
+        end
+      end
+      # Avoid network-path references.
+      if components[:host] != nil
+        components[:scheme] = normalized_self.scheme
+      end
+      return Addressable::URI.new(
+        :scheme => components[:scheme],
+        :user => components[:user],
+        :password => components[:password],
+        :host => components[:host],
+        :port => components[:port],
+        :path => components[:path],
+        :query => components[:query],
+        :fragment => components[:fragment]
+      )
+    end
+
+    ##
+    # Returns the shortest normalized relative form of the supplied URI that
+    # uses this URI as a base for resolution. Returns an absolute URI if
+    # necessary. This is effectively the opposite of <code>route_from</code>.
+    #
+    # @param [String, Addressable::URI, #to_str] uri The URI to route to.
+    #
+    # @return [Addressable::URI]
+    #   The normalized relative URI that is equivalent to the supplied URI.
+    def route_to(uri)
+      return URI.parse(uri).route_from(self)
+    end
+
+    ##
+    # Returns a normalized URI object.
+    #
+    # NOTE: This method does not attempt to fully conform to specifications.
+    # It exists largely to correct other people's failures to read the
+    # specifications, and also to deal with caching issues since several
+    # different URIs may represent the same resource and should not be
+    # cached multiple times.
+    #
+    # @return [Addressable::URI] The normalized URI.
+    def normalize
+      # This is a special exception for the frequently misused feed
+      # URI scheme.
+      if normalized_scheme == "feed"
+        if self.to_s =~ /^feed:\/*http:\/*/
+          return URI.parse(
+            self.to_s[/^feed:\/*(http:\/*.*)/, 1]
+          ).normalize
+        end
+      end
+
+      return self.class.new(
+        :scheme => normalized_scheme,
+        :authority => normalized_authority,
+        :path => normalized_path,
+        :query => normalized_query,
+        :fragment => normalized_fragment
+      )
+    end
+
+    ##
+    # Destructively normalizes this URI object.
+    #
+    # @return [Addressable::URI] The normalized URI.
+    #
+    # @see Addressable::URI#normalize
+    def normalize!
+      replace_self(self.normalize)
+    end
+
+    ##
+    # Creates a URI suitable for display to users. If semantic attacks are
+    # likely, the application should try to detect these and warn the user.
+    # See <a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>,
+    # section 7.6 for more information.
+    #
+    # @return [Addressable::URI] A URI suitable for display purposes.
+    def display_uri
+      display_uri = self.normalize
+      display_uri.host = ::Addressable::IDNA.to_unicode(display_uri.host)
+      return display_uri
+    end
+
+    ##
+    # Returns <code>true</code> if the URI objects are equal. This method
+    # normalizes both URIs before doing the comparison, and allows comparison
+    # against <code>Strings</code>.
+    #
+    # @param [Object] uri The URI to compare.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the URIs are equivalent, <code>false</code>
+    #   otherwise.
+    def ===(uri)
+      if uri.respond_to?(:normalize)
+        uri_string = uri.normalize.to_s
+      else
+        begin
+          uri_string = ::Addressable::URI.parse(uri).normalize.to_s
+        rescue InvalidURIError, TypeError
+          return false
+        end
+      end
+      return self.normalize.to_s == uri_string
+    end
+
+    ##
+    # Returns <code>true</code> if the URI objects are equal. This method
+    # normalizes both URIs before doing the comparison.
+    #
+    # @param [Object] uri The URI to compare.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the URIs are equivalent, <code>false</code>
+    #   otherwise.
+    def ==(uri)
+      return false unless uri.kind_of?(URI)
+      return self.normalize.to_s == uri.normalize.to_s
+    end
+
+    ##
+    # Returns <code>true</code> if the URI objects are equal. This method
+    # does NOT normalize either URI before doing the comparison.
+    #
+    # @param [Object] uri The URI to compare.
+    #
+    # @return [TrueClass, FalseClass]
+    #   <code>true</code> if the URIs are equivalent, <code>false</code>
+    #   otherwise.
+    def eql?(uri)
+      return false unless uri.kind_of?(URI)
+      return self.to_s == uri.to_s
+    end
+
+    ##
+    # A hash value that will make a URI equivalent to its normalized
+    # form.
+    #
+    # @return [Integer] A hash of the URI.
+    def hash
+      @hash ||= self.to_s.hash * -1
+    end
+
+    ##
+    # Clones the URI object.
+    #
+    # @return [Addressable::URI] The cloned URI.
+    def dup
+      duplicated_uri = self.class.new(
+        :scheme => self.scheme ? self.scheme.dup : nil,
+        :user => self.user ? self.user.dup : nil,
+        :password => self.password ? self.password.dup : nil,
+        :host => self.host ? self.host.dup : nil,
+        :port => self.port,
+        :path => self.path ? self.path.dup : nil,
+        :query => self.query ? self.query.dup : nil,
+        :fragment => self.fragment ? self.fragment.dup : nil
+      )
+      return duplicated_uri
+    end
+
+    ##
+    # Omits components from a URI.
+    #
+    # @param [Symbol] *components The components to be omitted.
+    #
+    # @return [Addressable::URI] The URI with components omitted.
+    #
+    # @example
+    #   uri = Addressable::URI.parse("http://example.com/path?query")
+    #   #=> #<Addressable::URI:0xcc5e7a URI:http://example.com/path?query>
+    #   uri.omit(:scheme, :authority)
+    #   #=> #<Addressable::URI:0xcc4d86 URI:/path?query>
+    def omit(*components)
+      invalid_components = components - [
+        :scheme, :user, :password, :userinfo, :host, :port, :authority,
+        :path, :query, :fragment
+      ]
+      unless invalid_components.empty?
+        raise ArgumentError,
+          "Invalid component names: #{invalid_components.inspect}."
+      end
+      duplicated_uri = self.dup
+      duplicated_uri.defer_validation do
+        components.each do |component|
+          duplicated_uri.send((component.to_s + "=").to_sym, nil)
+        end
+        duplicated_uri.user = duplicated_uri.normalized_user
+      end
+      duplicated_uri
+    end
+
+    ##
+    # Destructive form of omit.
+    #
+    # @param [Symbol] *components The components to be omitted.
+    #
+    # @return [Addressable::URI] The URI with components omitted.
+    #
+    # @see Addressable::URI#omit
+    def omit!(*components)
+      replace_self(self.omit(*components))
+    end
+
+    ##
+    # Determines if the URI is an empty string.
+    #
+    # @return [TrueClass, FalseClass]
+    #   Returns <code>true</code> if empty, <code>false</code> otherwise.
+    def empty?
+      return self.to_s.empty?
+    end
+
+    ##
+    # Converts the URI to a <code>String</code>.
+    #
+    # @return [String] The URI's <code>String</code> representation.
+    def to_s
+      if self.scheme == nil && self.path != nil && !self.path.empty? &&
+          self.path =~ NORMPATH
+        raise InvalidURIError,
+          "Cannot assemble URI string with ambiguous path: '#{self.path}'"
+      end
+      @uri_string ||= begin
+        uri_string = String.new
+        uri_string << "#{self.scheme}:" if self.scheme != nil
+        uri_string << "//#{self.authority}" if self.authority != nil
+        uri_string << self.path.to_s
+        uri_string << "?#{self.query}" if self.query != nil
+        uri_string << "##{self.fragment}" if self.fragment != nil
+        uri_string.force_encoding(Encoding::UTF_8)
+        uri_string
+      end
+    end
+
+    ##
+    # URI's are glorified <code>Strings</code>. Allow implicit conversion.
+    alias_method :to_str, :to_s
+
+    ##
+    # Returns a Hash of the URI components.
+    #
+    # @return [Hash] The URI as a <code>Hash</code> of components.
+    def to_hash
+      return {
+        :scheme => self.scheme,
+        :user => self.user,
+        :password => self.password,
+        :host => self.host,
+        :port => self.port,
+        :path => self.path,
+        :query => self.query,
+        :fragment => self.fragment
+      }
+    end
+
+    ##
+    # Returns a <code>String</code> representation of the URI object's state.
+    #
+    # @return [String] The URI object's state, as a <code>String</code>.
+    def inspect
+      sprintf("#<%s:%#0x URI:%s>", URI.to_s, self.object_id, self.to_s)
+    end
+
+    ##
+    # This method allows you to make several changes to a URI simultaneously,
+    # which separately would cause validation errors, but in conjunction,
+    # are valid.  The URI will be revalidated as soon as the entire block has
+    # been executed.
+    #
+    # @param [Proc] block
+    #   A set of operations to perform on a given URI.
+    def defer_validation
+      raise LocalJumpError, "No block given." unless block_given?
+      @validation_deferred = true
+      yield
+      @validation_deferred = false
+      validate
+    ensure
+      @validation_deferred = false
+    end
+
+    def encode_with(coder)
+      instance_variables.each do |ivar|
+        value = instance_variable_get(ivar)
+        if value != NONE
+          key = ivar.to_s.slice(1..-1)
+          coder[key] = value
+        end
+      end
+      nil
+    end
+
+    def init_with(coder)
+      reset_ivs
+      coder.map.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+      nil
+    end
+
+  protected
+    SELF_REF = '.'
+    PARENT = '..'
+
+    RULE_2A = /\/\.\/|\/\.$/
+    RULE_2B_2C = /\/([^\/]*)\/\.\.\/|\/([^\/]*)\/\.\.$/
+    RULE_2D = /^\.\.?\/?/
+    RULE_PREFIXED_PARENT = /^\/\.\.?\/|^(\/\.\.?)+\/?$/
+
+    ##
+    # Resolves paths to their simplest form.
+    #
+    # @param [String] path The path to normalize.
+    #
+    # @return [String] The normalized path.
+    def self.normalize_path(path)
+      # Section 5.2.4 of RFC 3986
+
+      return if path.nil?
+      normalized_path = path.dup
+      loop do
+        mod ||= normalized_path.gsub!(RULE_2A, SLASH)
+
+        pair = normalized_path.match(RULE_2B_2C)
+        if pair
+          parent  = pair[1]
+          current = pair[2]
+        else
+          parent  = nil
+          current = nil
+        end
+
+        regexp = "/#{Regexp.escape(parent.to_s)}/\\.\\./|"
+        regexp += "(/#{Regexp.escape(current.to_s)}/\\.\\.$)"
+
+        if pair && ((parent != SELF_REF && parent != PARENT) ||
+            (current != SELF_REF && current != PARENT))
+          mod ||= normalized_path.gsub!(Regexp.new(regexp), SLASH)
+        end
+
+        mod ||= normalized_path.gsub!(RULE_2D, EMPTY_STR)
+        # Non-standard, removes prefixed dotted segments from path.
+        mod ||= normalized_path.gsub!(RULE_PREFIXED_PARENT, SLASH)
+        break if mod.nil?
+      end
+
+      normalized_path
+    end
+
+    ##
+    # Ensures that the URI is valid.
+    def validate
+      return if !!@validation_deferred
+      if self.scheme != nil && self.ip_based? &&
+          (self.host == nil || self.host.empty?) &&
+          (self.path == nil || self.path.empty?)
+        raise InvalidURIError,
+          "Absolute URI missing hierarchical segment: '#{self.to_s}'"
+      end
+      if self.host == nil
+        if self.port != nil ||
+            self.user != nil ||
+            self.password != nil
+          raise InvalidURIError, "Hostname not supplied: '#{self.to_s}'"
+        end
+      end
+      if self.path != nil && !self.path.empty? && self.path[0..0] != SLASH &&
+          self.authority != nil
+        raise InvalidURIError,
+          "Cannot have a relative path with an authority set: '#{self.to_s}'"
+      end
+      if self.path != nil && !self.path.empty? &&
+          self.path[0..1] == SLASH + SLASH && self.authority == nil
+        raise InvalidURIError,
+          "Cannot have a path with two leading slashes " +
+          "without an authority set: '#{self.to_s}'"
+      end
+      unreserved = CharacterClasses::UNRESERVED
+      sub_delims = CharacterClasses::SUB_DELIMS
+      if !self.host.nil? && (self.host =~ /[<>{}\/\\\?\#\@"[[:space:]]]/ ||
+          (self.host[/^\[(.*)\]$/, 1] != nil && self.host[/^\[(.*)\]$/, 1] !~
+          Regexp.new("^[#{unreserved}#{sub_delims}:]*$")))
+        raise InvalidURIError, "Invalid character in host: '#{self.host.to_s}'"
+      end
+      return nil
+    end
+
+    ##
+    # Replaces the internal state of self with the specified URI's state.
+    # Used in destructive operations to avoid massive code repetition.
+    #
+    # @param [Addressable::URI] uri The URI to replace <code>self</code> with.
+    #
+    # @return [Addressable::URI] <code>self</code>.
+    def replace_self(uri)
+      # Reset dependent values
+      reset_ivs
+
+      @scheme = uri.scheme
+      @user = uri.user
+      @password = uri.password
+      @host = uri.host
+      @port = uri.port
+      @path = uri.path
+      @query = uri.query
+      @fragment = uri.fragment
+      return self
+    end
+
+    ##
+    # Splits path string with "/" (slash).
+    # It is considered that there is empty string after last slash when
+    # path ends with slash.
+    #
+    # @param [String] path The path to split.
+    #
+    # @return [Array<String>] An array of parts of path.
+    def split_path(path)
+      splitted = path.split(SLASH)
+      splitted << EMPTY_STR if path.end_with? SLASH
+      splitted
+    end
+
+    ##
+    # Resets composite values for the entire URI
+    #
+    # @api private
+    def remove_composite_values
+      @uri_string = nil
+      @hash = nil
+    end
+
+    ##
+    # Converts the string to be UTF-8 if it is not already UTF-8
+    #
+    # @api private
+    def force_utf8_encoding_if_needed(str)
+      if str && str.encoding != Encoding::UTF_8
+        str.force_encoding(Encoding::UTF_8)
+      end
+    end
+
+    private
+
+    ##
+    # Resets instance variables
+    #
+    # @api private
+    def reset_ivs
+      @scheme = nil
+      @user = nil
+      @normalized_scheme = NONE
+      @normalized_user = NONE
+      @uri_string = nil
+      @hash = nil
+      @userinfo = nil
+      @normalized_userinfo = NONE
+      @authority = nil
+      @password = nil
+      @normalized_authority = nil
+      @port = nil
+      @normalized_password = NONE
+      @host = nil
+      @normalized_host = nil
+      @normalized_port = NONE
+      @path = EMPTY_STR
+      @normalized_path = nil
+      @normalized_query = NONE
+      @fragment = nil
+      @normalized_fragment = NONE
+      @query = nil
+    end
+
+    NONE = Module.new.freeze
+
+    private_constant :NONE
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/version.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/version.rb
new file mode 100644
index 0000000000000..2eec3e651b2f4
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/addressable-2.8.7/lib/addressable/version.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (C) Bob Aman
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#++
+
+
+# Used to prevent the class/module from being loaded more than once
+if !defined?(Addressable::VERSION)
+  module Addressable
+    module VERSION
+      MAJOR = 2
+      MINOR = 8
+      TINY  = 7
+
+      STRING = [MAJOR, MINOR, TINY].join('.')
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/LICENSE b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/LICENSE
new file mode 100644
index 0000000000000..991663e7b4383
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/LICENSE
@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2007-2022, Dion Mendel
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata.rb
similarity index 97%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata.rb
index 02a8390443f5a..9d3dcd339ccff 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata.rb
@@ -13,6 +13,7 @@
 require 'bindata/primitive'
 require 'bindata/record'
 require 'bindata/rest'
+require 'bindata/section'
 require 'bindata/skip'
 require 'bindata/string'
 require 'bindata/stringz'
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/alignment.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/alignment.rb
new file mode 100644
index 0000000000000..92fa72e1875d7
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/alignment.rb
@@ -0,0 +1,87 @@
+require 'bindata/base_primitive'
+
+module BinData
+  # Resets the stream alignment to the next byte.  This is
+  # only useful when using bit-based primitives.
+  #
+  #    class MyRec < BinData::Record
+  #      bit4 :a
+  #      resume_byte_alignment
+  #      bit4 :b
+  #    end
+  #
+  #    MyRec.read("\x12\x34") #=> {"a" => 1, "b" => 3}
+  #
+  class ResumeByteAlignment < BinData::Base
+    def clear?; true; end
+    def assign(val); end
+    def snapshot; nil; end
+    def do_num_bytes; 0; end
+
+    def do_read(io)
+      io.readbytes(0)
+    end
+
+    def do_write(io)
+      io.writebytes("")
+    end
+  end
+
+  # A monkey patch to force byte-aligned primitives to
+  # become bit-aligned.  This allows them to be used at
+  # non byte based boundaries.
+  #
+  #     class BitString < BinData::String
+  #       bit_aligned
+  #     end
+  #
+  #     class MyRecord < BinData::Record
+  #       bit4       :preamble
+  #       bit_string :str, length: 2
+  #     end
+  #
+  module BitAligned
+    class BitAlignedIO
+      def initialize(io)
+        @io = io
+      end
+
+      def binary_string(str)
+        str.to_s.dup.force_encoding(Encoding::BINARY)
+      end
+
+      def readbytes(n)
+        n.times.inject(binary_string("")) do |bytes, _|
+          bytes + @io.readbits(8, :big).chr
+        end
+      end
+      def writebytes(str)
+        str.each_byte { |v| @io.writebits(v, 8, :big) }
+      end
+    end
+
+    def bit_aligned?
+      true
+    end
+
+    def do_read(io)
+      super(BitAlignedIO.new(io))
+    end
+
+    def do_num_bytes
+      super.to_f
+    end
+
+    def do_write(io)
+      super(BitAlignedIO.new(io))
+    end
+  end
+
+  def BasePrimitive.bit_aligned
+    include BitAligned
+  end
+
+  def Primitive.bit_aligned
+    fail "'bit_aligned' is not supported for BinData::Primitives"
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/array.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/array.rb
new file mode 100644
index 0000000000000..6764b69f0caff
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/array.rb
@@ -0,0 +1,344 @@
+require 'bindata/base'
+require 'bindata/dsl'
+
+module BinData
+  # An Array is a list of data objects of the same type.
+  #
+  #   require 'bindata'
+  #
+  #   data = "\x03\x04\x05\x06\x07\x08\x09"
+  #
+  #   obj = BinData::Array.new(type: :int8, initial_length: 6)
+  #   obj.read(data) #=> [3, 4, 5, 6, 7, 8]
+  #
+  #   obj = BinData::Array.new(type: :int8,
+  #                            read_until: -> { index == 1 })
+  #   obj.read(data) #=> [3, 4]
+  #
+  #   obj = BinData::Array.new(type: :int8,
+  #                            read_until: -> { element >= 6 })
+  #   obj.read(data) #=> [3, 4, 5, 6]
+  #
+  #   obj = BinData::Array.new(type: :int8,
+  #           read_until: -> { array[index] + array[index - 1] == 13 })
+  #   obj.read(data) #=> [3, 4, 5, 6, 7]
+  #
+  #   obj = BinData::Array.new(type: :int8, read_until: :eof)
+  #   obj.read(data) #=> [3, 4, 5, 6, 7, 8, 9]
+  #
+  # == Parameters
+  #
+  # Parameters may be provided at initialisation to control the behaviour of
+  # an object.  These params are:
+  #
+  # <tt>:type</tt>::           The symbol representing the data type of the
+  #                            array elements.  If the type is to have params
+  #                            passed to it, then it should be provided as
+  #                            <tt>[type_symbol, hash_params]</tt>.
+  # <tt>:initial_length</tt>:: The initial length of the array.
+  # <tt>:read_until</tt>::     While reading, elements are read until this
+  #                            condition is true.  This is typically used to
+  #                            read an array until a sentinel value is found.
+  #                            The variables +index+, +element+ and +array+
+  #                            are made available to any lambda assigned to
+  #                            this parameter.  If the value of this parameter
+  #                            is the symbol :eof, then the array will read
+  #                            as much data from the stream as possible.
+  #
+  # Each data object in an array has the variable +index+ made available
+  # to any lambda evaluated as a parameter of that data object.
+  class Array < BinData::Base
+    extend DSLMixin
+    include Enumerable
+
+    dsl_parser    :array
+    arg_processor :array
+
+    mandatory_parameter :type
+    optional_parameters :initial_length, :read_until
+    mutually_exclusive_parameters :initial_length, :read_until
+
+    def initialize_shared_instance
+      @element_prototype = get_parameter(:type)
+      if get_parameter(:read_until) == :eof
+        extend ReadUntilEOFPlugin
+      elsif has_parameter?(:read_until)
+        extend ReadUntilPlugin
+      elsif has_parameter?(:initial_length)
+        extend InitialLengthPlugin
+      end
+
+      super
+    end
+
+    def initialize_instance
+      @elements = nil
+    end
+
+    def clear?
+      @elements.nil? || elements.all?(&:clear?)
+    end
+
+    def assign(array)
+      return if self.equal?(array)  # prevent self assignment
+      raise ArgumentError, "can't set a nil value for #{debug_name}" if array.nil?
+
+      @elements = []
+      concat(array)
+    end
+
+    def snapshot
+      elements.collect(&:snapshot)
+    end
+
+    def find_index(obj)
+      elements.index(obj)
+    end
+    alias index find_index
+
+    # Returns the first index of +obj+ in self.
+    #
+    # Uses equal? for the comparator.
+    def find_index_of(obj)
+      elements.index { |el| el.equal?(obj) }
+    end
+
+    def push(*args)
+      insert(-1, *args)
+      self
+    end
+    alias << push
+
+    def unshift(*args)
+      insert(0, *args)
+      self
+    end
+
+    def concat(array)
+      insert(-1, *array.to_ary)
+      self
+    end
+
+    def insert(index, *objs)
+      extend_array(index - 1)
+      abs_index = (index >= 0) ? index : index + 1 + length
+
+      # insert elements before...
+      new_elements = objs.map { new_element }
+      elements.insert(index, *new_elements)
+
+      # ...assigning values
+      objs.each_with_index do |obj, i|
+        self[abs_index + i] = obj
+      end
+
+      self
+    end
+
+    # Returns the element at +index+.
+    def [](arg1, arg2 = nil)
+      if arg1.respond_to?(:to_int) && arg2.nil?
+        slice_index(arg1.to_int)
+      elsif arg1.respond_to?(:to_int) && arg2.respond_to?(:to_int)
+        slice_start_length(arg1.to_int, arg2.to_int)
+      elsif arg1.is_a?(Range) && arg2.nil?
+        slice_range(arg1)
+      else
+        raise TypeError, "can't convert #{arg1} into Integer" unless arg1.respond_to?(:to_int)
+        raise TypeError, "can't convert #{arg2} into Integer" unless arg2.respond_to?(:to_int)
+      end
+    end
+    alias slice []
+
+    def slice_index(index)
+      extend_array(index)
+      at(index)
+    end
+
+    def slice_start_length(start, length)
+      elements[start, length]
+    end
+
+    def slice_range(range)
+      elements[range]
+    end
+    private :slice_index, :slice_start_length, :slice_range
+
+    # Returns the element at +index+.  Unlike +slice+, if +index+ is out
+    # of range the array will not be automatically extended.
+    def at(index)
+      elements[index]
+    end
+
+    # Sets the element at +index+.
+    def []=(index, value)
+      extend_array(index)
+      elements[index].assign(value)
+    end
+
+    # Returns the first element, or the first +n+ elements, of the array.
+    # If the array is empty, the first form returns nil, and the second
+    # form returns an empty array.
+    def first(n = nil)
+      if n.nil? && empty?
+        # explicitly return nil as arrays grow automatically
+        nil
+      elsif n.nil?
+        self[0]
+      else
+        self[0, n]
+      end
+    end
+
+    # Returns the last element, or the last +n+ elements, of the array.
+    # If the array is empty, the first form returns nil, and the second
+    # form returns an empty array.
+    def last(n = nil)
+      if n.nil?
+        self[-1]
+      else
+        n = length if n > length
+        self[-n, n]
+      end
+    end
+
+    def length
+      elements.length
+    end
+    alias size length
+
+    def empty?
+      length.zero?
+    end
+
+    # Allow this object to be used in array context.
+    def to_ary
+      collect { |el| el }
+    end
+
+    def each
+      elements.each { |el| yield el }
+    end
+
+    def debug_name_of(child) # :nodoc:
+      index = find_index_of(child)
+      "#{debug_name}[#{index}]"
+    end
+
+    def offset_of(child) # :nodoc:
+      index = find_index_of(child)
+      sum = sum_num_bytes_below_index(index)
+
+      child.bit_aligned? ? sum.floor : sum.ceil
+    end
+
+    def do_write(io) # :nodoc:
+      elements.each { |el| el.do_write(io) }
+    end
+
+    def do_num_bytes # :nodoc:
+      sum_num_bytes_for_all_elements
+    end
+
+    #---------------
+    private
+
+    def extend_array(max_index)
+      max_length = max_index + 1
+      while elements.length < max_length
+        append_new_element
+      end
+    end
+
+    def elements
+      @elements ||= []
+    end
+
+    def append_new_element
+      element = new_element
+      elements << element
+      element
+    end
+
+    def new_element
+      @element_prototype.instantiate(nil, self)
+    end
+
+    def sum_num_bytes_for_all_elements
+      sum_num_bytes_below_index(length)
+    end
+
+    def sum_num_bytes_below_index(index)
+      (0...index).inject(0) do |sum, i|
+        nbytes = elements[i].do_num_bytes
+
+        if nbytes.is_a?(Integer)
+          sum.ceil + nbytes
+        else
+          sum + nbytes
+        end
+      end
+    end
+
+    # Logic for the :read_until parameter
+    module ReadUntilPlugin
+      def do_read(io)
+        loop do
+          element = append_new_element
+          element.do_read(io)
+          variables = { index: self.length - 1, element: self.last, array: self }
+          break if eval_parameter(:read_until, variables)
+        end
+      end
+    end
+
+    # Logic for the read_until: :eof parameter
+    module ReadUntilEOFPlugin
+      def do_read(io)
+        loop do
+          element = append_new_element
+          begin
+            element.do_read(io)
+          rescue EOFError, IOError
+            elements.pop
+            break
+          end
+        end
+      end
+    end
+
+    # Logic for the :initial_length parameter
+    module InitialLengthPlugin
+      def do_read(io)
+        elements.each { |el| el.do_read(io) }
+      end
+
+      def elements
+        if @elements.nil?
+          @elements = []
+          eval_parameter(:initial_length).times do
+            @elements << new_element
+          end
+        end
+
+        @elements
+      end
+    end
+  end
+
+  class ArrayArgProcessor < BaseArgProcessor
+    def sanitize_parameters!(obj_class, params) # :nodoc:
+      # ensure one of :initial_length and :read_until exists
+      unless params.has_at_least_one_of?(:initial_length, :read_until)
+        params[:initial_length] = 0
+      end
+
+      params.warn_replacement_parameter(:length, :initial_length)
+      params.warn_replacement_parameter(:read_length, :initial_length)
+      params.must_be_integer(:initial_length)
+
+      params.merge!(obj_class.dsl_params)
+      params.sanitize_object_prototype(:type)
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/base.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/base.rb
new file mode 100644
index 0000000000000..c5bbf3378a6bb
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/base.rb
@@ -0,0 +1,324 @@
+require 'bindata/framework'
+require 'bindata/io'
+require 'bindata/lazy'
+require 'bindata/name'
+require 'bindata/params'
+require 'bindata/registry'
+require 'bindata/sanitize'
+
+module BinData
+  # This is the abstract base class for all data objects.
+  class Base
+    extend AcceptedParametersPlugin
+    include Framework
+    include RegisterNamePlugin
+
+    class << self
+      # Instantiates this class and reads from +io+, returning the newly
+      # created data object.  +args+ will be used when instantiating.
+      def read(io, *args, &block)
+        obj = new(*args)
+        obj.read(io, &block)
+        obj
+      end
+
+      # The arg processor for this class.
+      def arg_processor(name = nil)
+        @arg_processor ||= nil
+
+        if name
+          @arg_processor = "#{name}_arg_processor".gsub(/(?:^|_)(.)/) { $1.upcase }.to_sym
+        elsif @arg_processor.is_a? Symbol
+          @arg_processor = BinData.const_get(@arg_processor).new
+        elsif @arg_processor.nil?
+          @arg_processor = superclass.arg_processor
+        else
+          @arg_processor
+        end
+      end
+
+      # The name of this class as used by Records, Arrays etc.
+      def bindata_name
+        RegisteredClasses.underscore_name(name)
+      end
+
+      # Call this method if this class is abstract and not to be used.
+      def unregister_self
+        RegisteredClasses.unregister(name)
+      end
+
+      # Registers all subclasses of this class for use
+      def register_subclasses # :nodoc:
+        singleton_class.send(:undef_method, :inherited)
+        define_singleton_method(:inherited) do |subclass|
+          RegisteredClasses.register(subclass.name, subclass)
+          register_subclasses
+        end
+      end
+
+      private :unregister_self, :register_subclasses
+    end
+
+    # Register all subclasses of this class.
+    register_subclasses
+
+    # Set the initial arg processor.
+    arg_processor :base
+
+    # Creates a new data object.
+    #
+    # Args are optional, but if present, must be in the following order.
+    #
+    # +value+ is a value that is +assign+ed immediately after initialization.
+    #
+    # +parameters+ is a hash containing symbol keys.  Some parameters may
+    # reference callable objects (methods or procs).
+    #
+    # +parent+ is the parent data object (e.g. struct, array, choice) this
+    # object resides under.
+    #
+    def initialize(*args)
+      value, @params, @parent = extract_args(args)
+
+      initialize_shared_instance
+      initialize_instance
+      assign(value) if value
+    end
+
+    attr_accessor :parent
+    protected :parent=
+
+    # Creates a new data object based on this instance.
+    #
+    # This implements the prototype design pattern.
+    #
+    # All parameters will be be duplicated.  Use this method
+    # when creating multiple objects with the same parameters.
+    def new(value = nil, parent = nil)
+      obj = clone
+      obj.parent = parent if parent
+      obj.initialize_instance
+      obj.assign(value) if value
+
+      obj
+    end
+
+    # Returns the result of evaluating the parameter identified by +key+.
+    #
+    # +overrides+ is an optional +parameters+ like hash that allow the
+    # parameters given at object construction to be overridden.
+    #
+    # Returns nil if +key+ does not refer to any parameter.
+    def eval_parameter(key, overrides = nil)
+      value = get_parameter(key)
+      if value.is_a?(Symbol) || value.respond_to?(:arity)
+        lazy_evaluator.lazy_eval(value, overrides)
+      else
+        value
+      end
+    end
+
+    # Returns a lazy evaluator for this object.
+    def lazy_evaluator # :nodoc:
+      @lazy_evaluator ||= LazyEvaluator.new(self)
+    end
+
+    # Returns the parameter referenced by +key+.
+    # Use this method if you are sure the parameter is not to be evaluated.
+    # You most likely want #eval_parameter.
+    def get_parameter(key)
+      @params[key]
+    end
+
+    # Returns whether +key+ exists in the +parameters+ hash.
+    def has_parameter?(key)
+      @params.has_parameter?(key)
+    end
+
+    # Resets the internal state to that of a newly created object.
+    def clear
+      initialize_instance
+    end
+
+    # Reads data into this data object.
+    def read(io, &block)
+      io = BinData::IO::Read.new(io) unless BinData::IO::Read === io
+
+      start_read do
+        clear
+        do_read(io)
+      end
+      block.call(self) if block_given?
+
+      self
+    end
+
+    # Writes the value for this data object to +io+.
+    def write(io, &block)
+      io = BinData::IO::Write.new(io) unless BinData::IO::Write === io
+
+      do_write(io)
+      io.flush
+
+      block.call(self) if block_given?
+
+      self
+    end
+
+    # Returns the number of bytes it will take to write this data object.
+    def num_bytes
+      do_num_bytes.ceil
+    end
+
+    # Returns the string representation of this data object.
+    def to_binary_s(&block)
+      io = BinData::IO.create_string_io
+      write(io, &block)
+      io.string
+    end
+
+    # Returns the hexadecimal string representation of this data object.
+    def to_hex(&block)
+      to_binary_s(&block).unpack1('H*')
+    end
+
+    # Return a human readable representation of this data object.
+    def inspect
+      snapshot.inspect
+    end
+
+    # Return a string representing this data object.
+    def to_s
+      snapshot.to_s
+    end
+
+    # Work with Ruby's pretty-printer library.
+    def pretty_print(pp) # :nodoc:
+      pp.pp(snapshot)
+    end
+
+    # Override and delegate =~ as it is defined in Object.
+    def =~(other)
+      snapshot =~ other
+    end
+
+    # Returns a user friendly name of this object for debugging purposes.
+    def debug_name
+      @parent ? @parent.debug_name_of(self) : 'obj'
+    end
+
+    # Returns the offset (in bytes) of this object with respect to its most
+    # distant ancestor.
+    def abs_offset
+      @parent ? @parent.abs_offset + @parent.offset_of(self) : 0
+    end
+
+    # Returns the offset (in bytes) of this object with respect to its parent.
+    def rel_offset
+      @parent ? @parent.offset_of(self) : 0
+    end
+
+    def ==(other) # :nodoc:
+      # double dispatch
+      other == snapshot
+    end
+
+    # A version of +respond_to?+ used by the lazy evaluator.  It doesn't
+    # reinvoke the evaluator so as to avoid infinite evaluation loops.
+    def safe_respond_to?(symbol, include_private = false) # :nodoc:
+      base_respond_to?(symbol, include_private)
+    end
+
+    alias base_respond_to? respond_to?
+
+    #---------------
+    private
+
+    def extract_args(args)
+      self.class.arg_processor.extract_args(self.class, args)
+    end
+
+    def start_read
+      top_level_set(:in_read, true)
+      yield
+    ensure
+      top_level_set(:in_read, false)
+    end
+
+    # Is this object tree currently being read?  Used by BasePrimitive.
+    def reading?
+      top_level_get(:in_read)
+    end
+
+    def top_level_set(sym, value)
+      top_level.instance_variable_set("@tl_#{sym}", value)
+    end
+
+    def top_level_get(sym)
+      tl = top_level
+      tl.instance_variable_defined?("@tl_#{sym}") &&
+        tl.instance_variable_get("@tl_#{sym}")
+    end
+
+    def top_level
+      if parent.nil?
+        tl = self
+      else
+        tl = parent
+        tl = tl.parent while tl.parent
+      end
+
+      tl
+    end
+
+    def binary_string(str)
+      str.to_s.dup.force_encoding(Encoding::BINARY)
+    end
+  end
+
+  # ArgProcessors process the arguments passed to BinData::Base.new into
+  # the form required to initialise the BinData object.
+  #
+  # Any passed parameters are sanitized so the BinData object doesn't
+  # need to perform error checking on the parameters.
+  class BaseArgProcessor
+    @@empty_hash = Hash.new.freeze
+
+    # Takes the arguments passed to BinData::Base.new and
+    # extracts [value, sanitized_parameters, parent].
+    def extract_args(obj_class, obj_args)
+      value, params, parent = separate_args(obj_class, obj_args)
+      sanitized_params = SanitizedParameters.sanitize(params, obj_class)
+
+      [value, sanitized_params, parent]
+    end
+
+    # Separates the arguments passed to BinData::Base.new into
+    # [value, parameters, parent].  Called by #extract_args.
+    def separate_args(_obj_class, obj_args)
+      args = obj_args.dup
+      value = parameters = parent = nil
+
+      if args.length > 1 && args.last.is_a?(BinData::Base)
+        parent = args.pop
+      end
+
+      if args.length > 0 && args.last.is_a?(Hash)
+        parameters = args.pop
+      end
+
+      if args.length > 0
+        value = args.pop
+      end
+
+      parameters ||= @@empty_hash
+
+      [value, parameters, parent]
+    end
+
+    # Performs sanity checks on the given parameters.
+    # This method converts the parameters to the form expected
+    # by the data object.
+    def sanitize_parameters!(obj_class, obj_params); end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/base_primitive.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/base_primitive.rb
similarity index 86%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/base_primitive.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/base_primitive.rb
index 3b2b4839e793d..fc6f6b5df0c81 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/base_primitive.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/base_primitive.rb
@@ -65,7 +65,7 @@ def initialize_instance
       @value = nil
     end
 
-    def clear? #:nodoc:
+    def clear? # :nodoc:
       @value.nil?
     end
 
@@ -73,13 +73,7 @@ def assign(val)
       raise ArgumentError, "can't set a nil value for #{debug_name}" if val.nil?
 
       raw_val = val.respond_to?(:snapshot) ? val.snapshot : val
-      @value =
-        begin
-          raw_val.dup
-        rescue TypeError
-          # can't dup Fixnums
-          raw_val
-        end
+      @value = raw_val.dup
     end
 
     def snapshot
@@ -94,18 +88,19 @@ def value=(val)
       assign(val)
     end
 
-    def respond_to?(symbol, include_private = false) #:nodoc:
+    def respond_to_missing?(symbol, include_all = false) # :nodoc:
       child = snapshot
-      child.respond_to?(symbol, include_private) || super
+      child.respond_to?(symbol, include_all) || super
     end
 
-    def method_missing(symbol, *args, &block) #:nodoc:
+    def method_missing(symbol, *args, &block) # :nodoc:
       child = snapshot
       if child.respond_to?(symbol)
-        self.class.class_eval \
-          "def #{symbol}(*args, &block);" \
-          "  snapshot.#{symbol}(*args, &block);" \
-          "end"
+        self.class.class_eval <<-END, __FILE__, __LINE__ + 1
+          def #{symbol}(*args, &block)         # def clamp(*args, &block)
+            snapshot.#{symbol}(*args, &block)  #   snapshot.clamp(*args, &block)
+          end                                  # end
+        END
         child.__send__(symbol, *args, &block)
       else
         super
@@ -125,15 +120,15 @@ def hash
       snapshot.hash
     end
 
-    def do_read(io) #:nodoc:
+    def do_read(io) # :nodoc:
       @value = read_and_return_value(io)
     end
 
-    def do_write(io) #:nodoc:
+    def do_write(io) # :nodoc:
       io.writebytes(value_to_binary_string(_value))
     end
 
-    def do_num_bytes #:nodoc:
+    def do_num_bytes # :nodoc:
       value_to_binary_string(_value).length
     end
 
@@ -172,7 +167,7 @@ def assign(val)
         assert!
       end
 
-      def do_read(io) #:nodoc:
+      def do_read(io) # :nodoc:
         super(io)
         assert!
       end
@@ -205,7 +200,16 @@ def _value
         reading? ? @value : eval_parameter(:asserted_value)
       end
 
-      def do_read(io) #:nodoc:
+      # The asserted value as a binary string.
+      #
+      # Rationale: while reading, +#to_binary_s+ will use the
+      # value read in, rather than the +:asserted_value+.
+      # This feature is used by Skip.
+      def asserted_binary_s
+        value_to_binary_string(eval_parameter(:asserted_value))
+      end
+
+      def do_read(io) # :nodoc:
         super(io)
         assert!
       end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/bits.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/bits.rb
similarity index 86%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/bits.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/bits.rb
index 1a69d5fa08bbd..d11b16547d81f 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/bits.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/bits.rb
@@ -5,7 +5,7 @@ module BinData
   # Defines a number of classes that contain a bit based integer.
   # The integer is defined by endian and number of bits.
 
-  module BitField #:nodoc: all
+  module BitField # :nodoc: all
     @@mutex = Mutex.new
 
     class << self
@@ -99,14 +99,14 @@ def create_clamp_code(nbits, signed)
 
       def create_dynamic_clamp_code(signed)
         if signed == :signed
-          max = "max = (1 << (nbits - 1)) - 1"
-          min = "min = -(max + 1)"
+          max = "(1 << (nbits - 1)) - 1"
+          min = "-((#{max}) + 1)"
         else
-          max = "max = (1 << nbits) - 1"
-          min = "min = 0"
+          max = "(1 << nbits) - 1"
+          min = "0"
         end
 
-        "#{max}; #{min}; val = (val < min) ? min : (val > max) ? max : val"
+        "val = val.clamp(#{min}, #{max})"
       end
 
       def create_fixed_clamp_code(nbits, signed)
@@ -115,14 +115,14 @@ def create_fixed_clamp_code(nbits, signed)
         end
 
         if signed == :signed
-          max = "max = (1 << (#{nbits} - 1)) - 1"
-          min = "min = -(max + 1)"
+          max = "(1 << (#{nbits} - 1)) - 1"
+          min = "-((#{max}) + 1)"
         else
-          min = "min = 0"
-          max = "max = (1 << #{nbits}) - 1"
+          min = "0"
+          max = "(1 << #{nbits}) - 1"
         end
 
-        clamp = "(#{max}; #{min}; val = (val < min) ? min : (val > max) ? max : val)"
+        clamp = "(val = val.clamp(#{min}, #{max}))"
 
         if nbits == 1
           # allow single bits to be used as booleans
@@ -156,10 +156,10 @@ def create_uint2int_code(nbits, signed)
 
   # Create classes for dynamic bitfields
   {
-    "Bit"    => :big,
-    "BitLe"  => :little,
-    "Sbit"   => [:big, :signed],
-    "SbitLe" => [:little, :signed],
+    'Bit'    => :big,
+    'BitLe'  => :little,
+    'Sbit'   => [:big, :signed],
+    'SbitLe' => [:little, :signed]
   }.each_pair { |name, args| BitField.define_class(name, :nbits, *args) }
 
   # Create classes on demand
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/buffer.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/buffer.rb
new file mode 100644
index 0000000000000..17cd486bbe9a1
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/buffer.rb
@@ -0,0 +1,195 @@
+require 'bindata/base'
+require 'bindata/dsl'
+
+module BinData
+  # A Buffer is conceptually a substream within a data stream.  It has a
+  # defined size and it will always read or write the exact number of bytes to
+  # fill the buffer.  Short reads will skip over unused bytes and short writes
+  # will pad the substream with "\0" bytes.
+  #
+  #   require 'bindata'
+  #
+  #   obj = BinData::Buffer.new(length: 5, type: [:string, {value: "abc"}])
+  #   obj.to_binary_s #=> "abc\000\000"
+  #
+  #
+  #   class MyBuffer < BinData::Buffer
+  #     default_parameter length: 8
+  #
+  #     endian :little
+  #
+  #     uint16 :num1
+  #     uint16 :num2
+  #     # padding occurs here
+  #   end
+  #
+  #   obj = MyBuffer.read("\001\000\002\000\000\000\000\000")
+  #   obj.num1 #=> 1
+  #   obj.num1 #=> 2
+  #   obj.raw_num_bytes #=> 4
+  #   obj.num_bytes #=> 8
+  #
+  #
+  #   class StringTable < BinData::Record
+  #     endian :little
+  #
+  #     uint16 :table_size_in_bytes
+  #     buffer :strings, length: :table_size_in_bytes do
+  #       array read_until: :eof do
+  #         uint8 :len
+  #         string :str, length: :len
+  #       end
+  #     end
+  #   end
+  #
+  #
+  # == Parameters
+  #
+  # Parameters may be provided at initialisation to control the behaviour of
+  # an object.  These params are:
+  #
+  # <tt>:length</tt>::   The number of bytes in the buffer.
+  # <tt>:type</tt>::     The single type inside the buffer.  Use a struct if
+  #                      multiple fields are required.
+  class Buffer < BinData::Base
+    extend DSLMixin
+
+    dsl_parser    :buffer
+    arg_processor :buffer
+
+    mandatory_parameters :length, :type
+
+    def initialize_instance
+      @type = get_parameter(:type).instantiate(nil, self)
+    end
+
+    # The number of bytes used, ignoring the padding imposed by the buffer.
+    def raw_num_bytes
+      @type.num_bytes
+    end
+
+    def clear?
+      @type.clear?
+    end
+
+    def assign(val)
+      @type.assign(val)
+    end
+
+    def snapshot
+      @type.snapshot
+    end
+
+    def respond_to_missing?(symbol, include_all = false) # :nodoc:
+      @type.respond_to?(symbol, include_all) || super
+    end
+
+    def method_missing(symbol, *args, &block) # :nodoc:
+      @type.__send__(symbol, *args, &block)
+    end
+
+    def do_read(io) # :nodoc:
+      buf_len = eval_parameter(:length)
+      io.transform(BufferIO.new(buf_len)) do |transformed_io, _|
+        @type.do_read(transformed_io)
+      end
+    end
+
+    def do_write(io) # :nodoc:
+      buf_len = eval_parameter(:length)
+      io.transform(BufferIO.new(buf_len)) do |transformed_io, _|
+        @type.do_write(transformed_io)
+      end
+    end
+
+    def do_num_bytes # :nodoc:
+      eval_parameter(:length)
+    end
+
+    # Transforms the IO stream to restrict access inside
+    # a buffer of specified length.
+    class BufferIO < IO::Transform
+      def initialize(length)
+        super()
+        @bytes_remaining = length
+      end
+
+      def before_transform
+        @buf_start = offset
+        @buf_end = @buf_start + @bytes_remaining
+      end
+
+      def num_bytes_remaining
+        [@bytes_remaining, super].min
+      rescue IOError
+        @bytes_remaining
+      end
+
+      def skip(n)
+        nbytes = buffer_limited_n(n)
+        @bytes_remaining -= nbytes
+
+        chain_skip(nbytes)
+      end
+
+      def seek_abs(n)
+        if n < @buf_start || n >= @buf_end
+          raise IOError, "can not seek to abs_offset outside of buffer"
+        end
+
+        @bytes_remaining -= (n - offset)
+        chain_seek_abs(n)
+      end
+
+      def read(n)
+        nbytes = buffer_limited_n(n)
+        @bytes_remaining -= nbytes
+
+        chain_read(nbytes)
+      end
+
+      def write(data)
+        nbytes = buffer_limited_n(data.size)
+        @bytes_remaining -= nbytes
+        if nbytes < data.size
+          data = data[0, nbytes]
+        end
+
+        chain_write(data)
+      end
+
+      def after_read_transform
+        read(nil)
+      end
+
+      def after_write_transform
+        write("\x00" * @bytes_remaining)
+      end
+
+      def buffer_limited_n(n)
+        if n.nil?
+          @bytes_remaining
+        elsif n.positive?
+          limit = @bytes_remaining
+          n > limit ? limit : n
+# uncomment if we decide to allow backwards skipping
+#        elsif n.negative?
+#          limit = @bytes_remaining + @buf_start - @buf_end
+#          n < limit ? limit : n
+        else
+          0
+        end
+      end
+    end
+  end
+
+  class BufferArgProcessor < BaseArgProcessor
+    include MultiFieldArgSeparator
+
+    def sanitize_parameters!(obj_class, params)
+      params.merge!(obj_class.dsl_params)
+      params.must_be_integer(:length)
+      params.sanitize_object_prototype(:type)
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/choice.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/choice.rb
similarity index 92%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/choice.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/choice.rb
index a06f36e3cf695..2e18205933d29 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/choice.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/choice.rb
@@ -82,18 +82,19 @@ def selection
       if selection.nil?
         raise IndexError, ":selection returned nil for #{debug_name}"
       end
+
       selection
     end
 
-    def respond_to?(symbol, include_private = false) #:nodoc:
-      current_choice.respond_to?(symbol, include_private) || super
+    def respond_to?(symbol, include_all = false) # :nodoc:
+      current_choice.respond_to?(symbol, include_all) || super
     end
 
-    def method_missing(symbol, *args, &block) #:nodoc:
+    def method_missing(symbol, *args, &block) # :nodoc:
       current_choice.__send__(symbol, *args, &block)
     end
 
-    %w(clear? assign snapshot do_read do_write do_num_bytes).each do |m|
+    %w[clear? assign snapshot do_read do_write do_num_bytes].each do |m|
       module_eval <<-END
         def #{m}(*args)
           current_choice.#{m}(*args)
@@ -112,14 +113,16 @@ def current_choice
     def instantiate_choice(selection)
       prototype = get_parameter(:choices)[selection]
       if prototype.nil?
-        raise IndexError, "selection '#{selection}' does not exist in :choices for #{debug_name}"
+        msg = "selection '#{selection}' does not exist in :choices for #{debug_name}"
+        raise IndexError, msg
       end
+
       prototype.instantiate(nil, self)
     end
   end
 
   class ChoiceArgProcessor < BaseArgProcessor
-    def sanitize_parameters!(obj_class, params) #:nodoc:
+    def sanitize_parameters!(obj_class, params) # :nodoc:
       params.merge!(obj_class.dsl_params)
 
       params.sanitize_choices(:choices) do |choices|
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/count_bytes_remaining.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/count_bytes_remaining.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/count_bytes_remaining.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/count_bytes_remaining.rb
index c90b7ba268768..843405f79ba17 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/count_bytes_remaining.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/count_bytes_remaining.rb
@@ -1,4 +1,4 @@
-require "bindata/base_primitive"
+require 'bindata/base_primitive'
 
 module BinData
   # Counts the number of bytes remaining in the input stream from the current
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/delayed_io.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/delayed_io.rb
similarity index 88%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/delayed_io.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/delayed_io.rb
index d0bae60300cba..c9d3d8d7377d2 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/delayed_io.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/delayed_io.rb
@@ -83,11 +83,11 @@ def num_bytes
       @type.num_bytes
     end
 
-    def respond_to?(symbol, include_private = false) #:nodoc:
-      @type.respond_to?(symbol, include_private) || super
+    def respond_to_missing?(symbol, include_all = false) # :nodoc:
+      @type.respond_to?(symbol, include_all) || super
     end
 
-    def method_missing(symbol, *args, &block) #:nodoc:
+    def method_missing(symbol, *args, &block) # :nodoc:
       @type.__send__(symbol, *args, &block)
     end
 
@@ -104,24 +104,29 @@ def rel_offset
       abs_offset
     end
 
-    def do_read(io) #:nodoc:
+    def do_read(io) # :nodoc:
       @read_io = io
     end
 
-    def do_write(io) #:nodoc:
+    def do_write(io) # :nodoc:
       @write_io = io
     end
 
-    def do_num_bytes #:nodoc:
+    def do_num_bytes # :nodoc:
       0
     end
 
+    def include_obj?
+      !has_parameter?(:onlyif) || eval_parameter(:onlyif)
+    end
+
     # DelayedIO objects aren't read when #read is called.
     # The reading is delayed until this method is called.
     def read_now!
+      return unless include_obj?
       raise IOError, "read from where?" unless @read_io
 
-      @read_io.seekbytes(abs_offset - @read_io.offset)
+      @read_io.seek_to_abs_offset(abs_offset)
       start_read do
         @type.do_read(@read_io)
       end
@@ -130,8 +135,10 @@ def read_now!
     # DelayedIO objects aren't written when #write is called.
     # The writing is delayed until this method is called.
     def write_now!
+      return unless include_obj?
       raise IOError, "write to where?" unless @write_io
-      @write_io.seekbytes(abs_offset - @write_io.offset)
+
+      @write_io.seek_to_abs_offset(abs_offset)
       @type.do_write(@write_io)
     end
   end
@@ -146,15 +153,16 @@ def sanitize_parameters!(obj_class, params)
     end
   end
 
-  # Add +auto_call_delayed_io+ keyword to BinData::Base.
   class Base
+    # Add +auto_call_delayed_io+ keyword to BinData::Base.
     class << self
       # The +auto_call_delayed_io+ keyword sets a data object tree to perform
       # multi pass I/O automatically.
       def auto_call_delayed_io
+        include AutoCallDelayedIO
+
         return if DelayedIO.method_defined? :initialize_instance_without_record_io
 
-        include AutoCallDelayedIO
         DelayedIO.send(:alias_method, :initialize_instance_without_record_io, :initialize_instance)
         DelayedIO.send(:define_method, :initialize_instance) do
           if @parent && !defined? @delayed_io_recorded
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/dsl.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/dsl.rb
similarity index 86%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/dsl.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/dsl.rb
index 44b25f266b651..d757a88d0b4a7 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/dsl.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/dsl.rb
@@ -42,7 +42,7 @@ def dsl_parser(parser_type = nil)
       end
     end
 
-    def method_missing(symbol, *args, &block) #:nodoc:
+    def method_missing(symbol, *args, &block) # :nodoc:
       dsl_parser.__send__(symbol, *args, &block)
     end
 
@@ -131,7 +131,8 @@ def parser_abilities
           choice:     [:to_choice_params, :choices,     [:multiple_fields, :all_or_none_fieldnames, :fieldnames_are_values]],
           delayed_io: [:to_object_params, :type,        [:multiple_fields, :optional_fieldnames, :hidden_fields]],
           primitive:  [:to_struct_params, :struct,      [:multiple_fields, :optional_fieldnames]],
-          skip:       [:to_object_params, :until_valid, [:multiple_fields, :optional_fieldnames]],
+          section:    [:to_object_params, :type,        [:multiple_fields, :optional_fieldnames]],
+          skip:       [:to_object_params, :until_valid, [:multiple_fields, :optional_fieldnames]]
         }
       end
 
@@ -182,21 +183,21 @@ def parse_and_append_field(*args, &block)
         begin
           @validator.validate_field(parser.name)
           append_field(parser.type, parser.name, parser.params)
-        rescue Exception => err
-          dsl_raise err.class, err.message
+        rescue Exception => e
+          dsl_raise e.class, e.message
         end
       end
 
       def append_field(type, name, params)
         fields.add_field(type, name, params)
-      rescue BinData::UnRegisteredTypeError => err
-        raise TypeError, "unknown type '#{err.message}'"
+      rescue BinData::UnRegisteredTypeError => e
+        raise TypeError, "unknown type '#{e.message}'"
       end
 
       def parent_attribute(attr, default = nil)
         parent = @the_class.superclass
         parser = parent.respond_to?(:dsl_parser) ? parent.dsl_parser : nil
-        if parser && parser.respond_to?(attr)
+        if parser&.respond_to?(attr)
           parser.send(attr)
         else
           default
@@ -205,7 +206,7 @@ def parent_attribute(attr, default = nil)
 
       def dsl_raise(exception, msg)
         backtrace = caller
-        backtrace.shift while %r{bindata/dsl.rb} =~ backtrace.first
+        backtrace.shift while %r{bindata/dsl.rb}.match?(backtrace.first)
 
         raise exception, "#{msg} in #{@the_class}", backtrace
       end
@@ -215,9 +216,9 @@ def to_object_params(key)
         when 0
           {}
         when 1
-          {key => fields[0].prototype}
+          { key => fields[0].prototype }
         else
-          {key=> [:struct, to_struct_params]}
+          { key => [:struct, to_struct_params] }
         end
       end
 
@@ -225,16 +226,16 @@ def to_choice_params(key)
         if fields.empty?
           {}
         elsif fields.all_field_names_blank?
-          {key => fields.collect(&:prototype)}
+          { key => fields.collect(&:prototype) }
         else
           choices = {}
           fields.each { |f| choices[f.name] = f.prototype }
-          {key => choices}
+          { key => choices }
         end
       end
 
-      def to_struct_params(*unused)
-        result = {fields: fields}
+      def to_struct_params(*_)
+        result = { fields: fields }
         if !endian.nil?
           result[:endian] = endian
         end
@@ -274,7 +275,7 @@ def create_subclasses_with_endian(bnl_class)
         def override_new_in_class(bnl_class)
           endian_classes = {
             big:    class_with_endian(bnl_class, :big),
-            little: class_with_endian(bnl_class, :little),
+            little: class_with_endian(bnl_class, :little)
           }
           bnl_class.define_singleton_method(:new) do |*args|
             if self == bnl_class
@@ -290,7 +291,7 @@ def override_new_in_class(bnl_class)
         def delegate_field_creation(bnl_class)
           endian_classes = {
             big:    class_with_endian(bnl_class, :big),
-            little: class_with_endian(bnl_class, :little),
+            little: class_with_endian(bnl_class, :little)
           }
 
           parser = bnl_class.dsl_parser
@@ -302,28 +303,28 @@ def delegate_field_creation(bnl_class)
 
         def fixup_subclass_hierarchy(bnl_class)
           parent = bnl_class.superclass
-          if obj_attribute(parent, :endian) == :big_and_little
-            be_subclass = class_with_endian(bnl_class, :big)
-            be_parent   = class_with_endian(parent, :big)
-            be_fields   = obj_attribute(be_parent, :fields)
+          return if obj_attribute(parent, :endian) != :big_and_little
 
-            le_subclass = class_with_endian(bnl_class, :little)
-            le_parent   = class_with_endian(parent, :little)
-            le_fields   = obj_attribute(le_parent, :fields)
+          be_subclass = class_with_endian(bnl_class, :big)
+          be_parent   = class_with_endian(parent, :big)
+          be_fields   = obj_attribute(be_parent, :fields)
 
-            be_subclass.dsl_parser.define_singleton_method(:parent_fields) do
-              be_fields
-            end
-            le_subclass.dsl_parser.define_singleton_method(:parent_fields) do
-              le_fields
-            end
+          le_subclass = class_with_endian(bnl_class, :little)
+          le_parent   = class_with_endian(parent, :little)
+          le_fields   = obj_attribute(le_parent, :fields)
+
+          be_subclass.dsl_parser.define_singleton_method(:parent_fields) do
+            be_fields
+          end
+          le_subclass.dsl_parser.define_singleton_method(:parent_fields) do
+            le_fields
           end
         end
 
         def class_with_endian(class_name, endian)
           hints = {
             endian: endian,
-            search_prefix: class_name.dsl_parser.search_prefix,
+            search_prefix: class_name.dsl_parser.search_prefix
           }
           RegisteredClasses.lookup(class_name, hints)
         end
@@ -377,8 +378,9 @@ def params_from_block(&block)
           buffer:     BinData::Buffer,
           choice:     BinData::Choice,
           delayed_io: BinData::DelayedIO,
+          section:    BinData::Section,
           skip:       BinData::Skip,
-          struct:     BinData::Struct,
+          struct:     BinData::Struct
         }
 
         if bindata_classes.include?(@type)
@@ -420,7 +422,7 @@ def validate_field(name)
       def ensure_valid_name(name)
         if name && !option?(:fieldnames_are_values)
           if malformed_name?(name)
-            raise NameError.new("", name), "field '#{name}' is an illegal fieldname"
+            raise SyntaxError, "field '#{name}' is an illegal fieldname"
           end
 
           if duplicate_name?(name)
@@ -428,11 +430,11 @@ def ensure_valid_name(name)
           end
 
           if name_shadows_method?(name)
-            raise NameError.new("", name), "field '#{name}' shadows an existing method"
+            raise SyntaxError, "field '#{name}' shadows an existing method"
           end
 
           if name_is_reserved?(name)
-            raise NameError.new("", name), "field '#{name}' is a reserved name"
+            raise SyntaxError, "field '#{name}' is a reserved name"
           end
         end
       end
@@ -457,7 +459,7 @@ def all_or_none_names_failed?(name)
       end
 
       def malformed_name?(name)
-        /^[a-z_]\w*$/ !~ name.to_s
+        !/^[a-z_]\w*$/.match?(name.to_s)
       end
 
       def duplicate_name?(name)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/float.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/float.rb
similarity index 93%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/float.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/float.rb
index 98a470817f4a4..f22b7e3fd1e3d 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/float.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/float.rb
@@ -4,7 +4,7 @@ module BinData
   # Defines a number of classes that contain a floating point number.
   # The float is defined by precision and endian.
 
-  module FloatingPoint #:nodoc: all
+  module FloatingPoint # :nodoc: all
     class << self
       PRECISION = {
         single: 4,
@@ -15,7 +15,7 @@ class << self
         [:single, :little] => 'e',
         [:single, :big]    => 'g',
         [:double, :little] => 'E',
-        [:double, :big]    => 'G',
+        [:double, :big]    => 'G'
       }
 
       def define_methods(float_class, precision, endian)
@@ -49,7 +49,7 @@ def create_read_code(precision, endian)
         nbytes = PRECISION[precision]
         unpack = PACK_CODE[[precision, endian]]
 
-        "io.readbytes(#{nbytes}).unpack('#{unpack}').at(0)"
+        "io.readbytes(#{nbytes}).unpack1('#{unpack}')"
       end
 
       def create_to_binary_s_code(precision, endian)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/framework.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/framework.rb
similarity index 87%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/framework.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/framework.rb
index ab652c2de310b..1a9d84c94e583 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/framework.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/framework.rb
@@ -1,14 +1,13 @@
 module BinData
   # Error raised when unexpected results occur when reading data from IO.
-  class ValidityError < StandardError ; end
+  class ValidityError < StandardError; end
 
   # All methods provided by the framework are to be implemented or overridden 
   # by subclasses of BinData::Base.
   module Framework
     # Initializes the state of the object.  All instance variables that
     # are used by the object must be initialized here.
-    def initialize_instance
-    end
+    def initialize_instance; end
 
     # Initialises state that is shared by objects with the same parameters.
     #
@@ -16,8 +15,7 @@ def initialize_instance
     # variables set here, and changes to the singleton class will be shared
     # between all objects that are initialized with the same parameters.
     # This method is called only once for a particular set of parameters.
-    def initialize_shared_instance
-    end
+    def initialize_shared_instance; end
 
     # Returns true if the object has not been changed since creation.
     def clear?
@@ -37,13 +35,13 @@ def snapshot
 
     # Returns the debug name of +child+.  This only needs to be implemented
     # by objects that contain child objects.
-    def debug_name_of(child) #:nodoc:
+    def debug_name_of(child) # :nodoc:
       debug_name
     end
 
     # Returns the offset of +child+.  This only needs to be implemented
     # by objects that contain child objects.
-    def offset_of(child) #:nodoc:
+    def offset_of(child) # :nodoc:
       0
     end
 
@@ -53,17 +51,17 @@ def bit_aligned?
     end
 
     # Reads the data for this data object from +io+.
-    def do_read(io) #:nodoc:
+    def do_read(io) # :nodoc:
       raise NotImplementedError
     end
 
     # Writes the value for this data to +io+.
-    def do_write(io) #:nodoc:
+    def do_write(io) # :nodoc:
       raise NotImplementedError
     end
 
     # Returns the number of bytes it will take to write this data.
-    def do_num_bytes #:nodoc:
+    def do_num_bytes # :nodoc:
       raise NotImplementedError
     end
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/int.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/int.rb
similarity index 88%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/int.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/int.rb
index e9c087b0cb1a6..63418e7978b6c 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/int.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/int.rb
@@ -5,7 +5,7 @@ module BinData
   # Defines a number of classes that contain an integer.  The integer
   # is defined by endian, signedness and number of bytes.
 
-  module Int #:nodoc: all
+  module Int # :nodoc: all
     @@mutex = Mutex.new
 
     class << self
@@ -59,16 +59,14 @@ def read_and_return_value(io)
 
       def create_clamp_code(nbits, signed)
         if signed == :signed
-          max = "max = (1 << (#{nbits} - 1)) - 1"
-          min = "min = -(max + 1)"
+          max = "(1 << (#{nbits} - 1)) - 1"
+          min = "-((#{max}) + 1)"
         else
-          max = "max = (1 << #{nbits}) - 1"
-          min = "min = 0"
+          max = "(1 << #{nbits}) - 1"
+          min = "0"
         end
 
-        clamp = "(#{max}; #{min}; val = (val < min) ? min : (val > max) ? max : val)"
-
-        "val = #{clamp}"
+        "val = val.clamp(#{min}, #{max})"
       end
 
       def create_read_code(nbits, endian, signed)
@@ -87,7 +85,7 @@ def create_raw_read_code(nbits, endian, signed)
           "io.readbytes(1).ord"
         else
           unpack_str   = create_read_unpack_code(nbits, endian, signed)
-          assemble_str = create_read_assemble_code(nbits, endian, signed)
+          assemble_str = create_read_assemble_code(nbits, endian)
 
           "(#{unpack_str} ; #{assemble_str})"
         end
@@ -100,7 +98,7 @@ def create_read_unpack_code(nbits, endian, signed)
         "ints = io.readbytes(#{nbytes}).unpack('#{pack_directive}')"
       end
 
-      def create_read_assemble_code(nbits, endian, signed)
+      def create_read_assemble_code(nbits, endian)
         nwords = nbits / bits_per_word(nbits)
 
         idx = (0...nwords).to_a
@@ -119,7 +117,7 @@ def create_to_binary_s_code(nbits, endian, signed)
         return "(val & 0xff).chr" if nbits == 8
 
         pack_directive = pack_directive(nbits, endian, signed)
-        words          = val_as_packed_words(nbits, endian, signed)
+        words          = val_as_packed_words(nbits, endian)
         pack_str       = "[#{words}].pack('#{pack_directive}')"
 
         if need_signed_conversion_code?(nbits, signed)
@@ -129,7 +127,7 @@ def create_to_binary_s_code(nbits, endian, signed)
         end
       end
 
-      def val_as_packed_words(nbits, endian, signed)
+      def val_as_packed_words(nbits, endian)
         nwords = nbits / bits_per_word(nbits)
         mask   = (1 << bits_per_word(nbits)) - 1
 
@@ -138,7 +136,7 @@ def val_as_packed_words(nbits, endian, signed)
         vals.reverse! if (endian == :big)
 
         vals = vals.collect { |val| "#{val} & #{mask}" }  # TODO: "& mask" is needed to work around jruby bug. Remove this line when fixed.
-        vals.join(",")
+        vals.join(',')
       end
 
       def create_int2uint_code(nbits)
@@ -159,10 +157,10 @@ def bits_per_word(nbits)
       def pack_directive(nbits, endian, signed)
         nwords = nbits / bits_per_word(nbits)
 
-        directives = { 8 => "C", 16 => "S", 32 => "L", 64 => "Q" }
+        directives = { 8 => 'C', 16 => 'S', 32 => 'L', 64 => 'Q' }
 
         d = directives[bits_per_word(nbits)]
-        d += ((endian == :big) ? ">" : "<") unless d == "C"
+        d += ((endian == :big) ? '>' : '<') unless d == 'C'
 
         if signed == :signed && directives.key?(nbits)
           (d * nwords).downcase
@@ -195,7 +193,7 @@ def const_missing(name)
         /^Uint(\d+)be$/ => [:big,    :unsigned],
         /^Uint(\d+)le$/ => [:little, :unsigned],
         /^Int(\d+)be$/  => [:big,    :signed],
-        /^Int(\d+)le$/  => [:little, :signed],
+        /^Int(\d+)le$/  => [:little, :signed]
       }
 
       mappings.each_pair do |regex, args|
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/io.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/io.rb
new file mode 100644
index 0000000000000..a5600002a9d84
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/io.rb
@@ -0,0 +1,519 @@
+require 'stringio'
+
+module BinData
+  # A wrapper around an IO object.  The wrapper provides a consistent
+  # interface for BinData objects to use when accessing the IO.
+  module IO
+
+    # Creates a StringIO around +str+.
+    def self.create_string_io(str = "")
+      bin_str = str.dup.force_encoding(Encoding::BINARY)
+      StringIO.new(bin_str).tap(&:binmode)
+    end
+
+    # Create a new IO Read wrapper around +io+.  +io+ must provide #read,
+    # #pos if reading the current stream position and #seek if setting the
+    # current stream position.  If +io+ is a string it will be automatically
+    # wrapped in an StringIO object.
+    #
+    # The IO can handle bitstreams in either big or little endian format.
+    #
+    #      M  byte1   L      M  byte2   L
+    #      S 76543210 S      S fedcba98 S
+    #      B          B      B          B
+    #
+    # In big endian format:
+    #   readbits(6), readbits(5) #=> [765432, 10fed]
+    #
+    # In little endian format:
+    #   readbits(6), readbits(5) #=> [543210, a9876]
+    #
+    class Read
+      def initialize(io)
+        if self.class === io
+          raise ArgumentError, "io must not be a #{self.class}"
+        end
+
+        # wrap strings in a StringIO
+        if io.respond_to?(:to_str)
+          io = BinData::IO.create_string_io(io.to_str)
+        end
+
+        @io = RawIO.new(io)
+
+        # bits when reading
+        @rnbits  = 0
+        @rval    = 0
+        @rendian = nil
+      end
+
+      # Allow transforming data in the input stream.
+      # See +BinData::Buffer+ as an example.
+      #
+      # +io+ must be an instance of +Transform+.
+      #
+      # yields +self+ and +io+ to the given block
+      def transform(io)
+        reset_read_bits
+
+        saved = @io
+        @io = io.prepend_to_chain(@io)
+        yield(self, io)
+        io.after_read_transform
+      ensure
+        @io = saved
+      end
+
+      # The number of bytes remaining in the io steam.
+      def num_bytes_remaining
+        @io.num_bytes_remaining
+      end
+
+      # Seek +n+ bytes from the current position in the io stream.
+      def skipbytes(n)
+        reset_read_bits
+        @io.skip(n)
+      end
+
+      # Seek to an absolute offset within the io stream.
+      def seek_to_abs_offset(n)
+        reset_read_bits
+        @io.seek_abs(n)
+      end
+
+      # Reads exactly +n+ bytes from +io+.
+      #
+      # If the data read is nil an EOFError is raised.
+      #
+      # If the data read is too short an IOError is raised.
+      def readbytes(n)
+        reset_read_bits
+        read(n)
+      end
+
+      # Reads all remaining bytes from the stream.
+      def read_all_bytes
+        reset_read_bits
+        read
+      end
+
+      # Reads exactly +nbits+ bits from the stream. +endian+ specifies whether
+      # the bits are stored in +:big+ or +:little+ endian format.
+      def readbits(nbits, endian)
+        if @rendian != endian
+          # don't mix bits of differing endian
+          reset_read_bits
+          @rendian = endian
+        end
+
+        if endian == :big
+          read_big_endian_bits(nbits)
+        else
+          read_little_endian_bits(nbits)
+        end
+      end
+
+      # Discards any read bits so the stream becomes aligned at the
+      # next byte boundary.
+      def reset_read_bits
+        @rnbits = 0
+        @rval   = 0
+      end
+
+      #---------------
+      private
+
+      def read(n = nil)
+        str = @io.read(n)
+        if n
+          raise EOFError, "End of file reached" if str.nil?
+          raise IOError, "data truncated" if str.size < n
+        end
+        str
+      end
+
+      def read_big_endian_bits(nbits)
+        while @rnbits < nbits
+          accumulate_big_endian_bits
+        end
+
+        val     = (@rval >> (@rnbits - nbits)) & mask(nbits)
+        @rnbits -= nbits
+        @rval   &= mask(@rnbits)
+
+        val
+      end
+
+      def accumulate_big_endian_bits
+        byte = read(1).unpack1('C') & 0xff
+        @rval = (@rval << 8) | byte
+        @rnbits += 8
+      end
+
+      def read_little_endian_bits(nbits)
+        while @rnbits < nbits
+          accumulate_little_endian_bits
+        end
+
+        val     = @rval & mask(nbits)
+        @rnbits -= nbits
+        @rval   >>= nbits
+
+        val
+      end
+
+      def accumulate_little_endian_bits
+        byte = read(1).unpack1('C') & 0xff
+        @rval = @rval | (byte << @rnbits)
+        @rnbits += 8
+      end
+
+      def mask(nbits)
+        (1 << nbits) - 1
+      end
+    end
+
+    # Create a new IO Write wrapper around +io+.  +io+ must provide #write.
+    # If +io+ is a string it will be automatically wrapped in an StringIO
+    # object.
+    #
+    # The IO can handle bitstreams in either big or little endian format.
+    #
+    # See IO::Read for more information.
+    class Write
+      def initialize(io)
+        if self.class === io
+          raise ArgumentError, "io must not be a #{self.class}"
+        end
+
+        # wrap strings in a StringIO
+        if io.respond_to?(:to_str)
+          io = BinData::IO.create_string_io(io.to_str)
+        end
+
+        @io = RawIO.new(io)
+
+        @wnbits  = 0
+        @wval    = 0
+        @wendian = nil
+      end
+
+      # Allow transforming data in the output stream.
+      # See +BinData::Buffer+ as an example.
+      #
+      # +io+ must be an instance of +Transform+.
+      #
+      # yields +self+ and +io+ to the given block
+      def transform(io)
+        flushbits
+
+        saved = @io
+        @io = io.prepend_to_chain(@io)
+        yield(self, io)
+        io.after_write_transform
+      ensure
+        @io = saved
+      end
+
+      # Seek to an absolute offset within the io stream.
+      def seek_to_abs_offset(n)
+        raise IOError, "stream is unseekable" unless @io.seekable?
+
+        flushbits
+        @io.seek_abs(n)
+      end
+
+      # Writes the given string of bytes to the io stream.
+      def writebytes(str)
+        flushbits
+        write(str)
+      end
+
+      # Writes +nbits+ bits from +val+ to the stream. +endian+ specifies whether
+      # the bits are to be stored in +:big+ or +:little+ endian format.
+      def writebits(val, nbits, endian)
+        if @wendian != endian
+          # don't mix bits of differing endian
+          flushbits
+          @wendian = endian
+        end
+
+        clamped_val = val & mask(nbits)
+
+        if endian == :big
+          write_big_endian_bits(clamped_val, nbits)
+        else
+          write_little_endian_bits(clamped_val, nbits)
+        end
+      end
+
+      # To be called after all +writebits+ have been applied.
+      def flushbits
+        raise "Internal state error nbits = #{@wnbits}" if @wnbits >= 8
+
+        if @wnbits > 0
+          writebits(0, 8 - @wnbits, @wendian)
+        end
+      end
+      alias flush flushbits
+
+      #---------------
+      private
+
+      def write(data)
+        @io.write(data)
+      end
+
+      def write_big_endian_bits(val, nbits)
+        while nbits > 0
+          bits_req = 8 - @wnbits
+          if nbits >= bits_req
+            msb_bits = (val >> (nbits - bits_req)) & mask(bits_req)
+            nbits -= bits_req
+            val &= mask(nbits)
+
+            @wval   = (@wval << bits_req) | msb_bits
+            write(@wval.chr)
+
+            @wval   = 0
+            @wnbits = 0
+          else
+            @wval = (@wval << nbits) | val
+            @wnbits += nbits
+            nbits = 0
+          end
+        end
+      end
+
+      def write_little_endian_bits(val, nbits)
+        while nbits > 0
+          bits_req = 8 - @wnbits
+          if nbits >= bits_req
+            lsb_bits = val & mask(bits_req)
+            nbits -= bits_req
+            val >>= bits_req
+
+            @wval   = @wval | (lsb_bits << @wnbits)
+            write(@wval.chr)
+
+            @wval   = 0
+            @wnbits = 0
+          else
+            @wval   = @wval | (val << @wnbits)
+            @wnbits += nbits
+            nbits = 0
+          end
+        end
+      end
+
+      def mask(nbits)
+        (1 << nbits) - 1
+      end
+    end
+
+    # API used to access the raw data stream.
+    class RawIO
+      def initialize(io)
+        @io = io
+        @pos = 0
+
+        if is_seekable?(io)
+          @initial_pos = io.pos
+        else
+          singleton_class.prepend(UnSeekableIO)
+        end
+      end
+
+      def is_seekable?(io)
+        io.pos
+      rescue NoMethodError, Errno::ESPIPE, Errno::EPIPE, Errno::EINVAL
+        nil
+      end
+
+      def seekable?
+        true
+      end
+
+      def num_bytes_remaining
+        start_mark = @io.pos
+        @io.seek(0, ::IO::SEEK_END)
+        end_mark = @io.pos
+        @io.seek(start_mark, ::IO::SEEK_SET)
+
+        end_mark - start_mark
+      end
+
+      def offset
+        @pos
+      end
+
+      def skip(n)
+        raise IOError, "can not skip backwards" if n.negative?
+        @io.seek(n, ::IO::SEEK_CUR)
+        @pos += n
+      end
+
+      def seek_abs(n)
+        @io.seek(n + @initial_pos, ::IO::SEEK_SET)
+        @pos = n
+      end
+
+      def read(n)
+        @io.read(n).tap { |data| @pos += (data&.size || 0) }
+      end
+
+      def write(data)
+        @io.write(data)
+      end
+    end
+
+    # An IO stream may be transformed before processing.
+    # e.g. encoding, compression, buffered.
+    #
+    # Multiple transforms can be chained together.
+    #
+    # To create a new transform layer, subclass +Transform+.
+    # Override the public methods +#read+ and +#write+ at a minimum.
+    # Additionally the hook, +#before_transform+, +#after_read_transform+
+    # and +#after_write_transform+ are available as well.
+    #
+    # IMPORTANT!  If your transform changes the size of the underlying
+    # data stream (e.g. compression), then call
+    # +::transform_changes_stream_length!+ in your subclass.
+    class Transform
+      class << self
+        # Indicates that this transform changes the length of the
+        # underlying data. e.g. performs compression or error correction
+        def transform_changes_stream_length!
+          prepend(UnSeekableIO)
+        end
+      end
+
+      def initialize
+        @chain_io = nil
+      end
+
+      # Initialises this transform.
+      #
+      # Called before any IO operations.
+      def before_transform; end
+
+      # Flushes the input stream.
+      #
+      # Called after the final read operation.
+      def after_read_transform; end
+
+      # Flushes the output stream.
+      #
+      # Called after the final write operation.
+      def after_write_transform; end
+
+      # Prepends this transform to the given +chain+.
+      #
+      # Returns self (the new head of chain).
+      def prepend_to_chain(chain)
+        @chain_io = chain
+        before_transform
+        self
+      end
+
+      # Is the IO seekable?
+      def seekable?
+        @chain_io.seekable?
+      end
+
+      # How many bytes are available for reading?
+      def num_bytes_remaining
+        chain_num_bytes_remaining
+      end
+
+      # The current offset within the stream.
+      def offset
+        chain_offset
+      end
+
+      # Skips forward +n+ bytes in the input stream.
+      def skip(n)
+        chain_skip(n)
+      end
+
+      # Seeks to the given absolute position.
+      def seek_abs(n)
+        chain_seek_abs(n)
+      end
+
+      # Reads +n+ bytes from the stream.
+      def read(n)
+        chain_read(n)
+      end
+
+      # Writes +data+ to the stream.
+      def write(data)
+        chain_write(data)
+      end
+
+      #-------------
+      private
+
+      def create_empty_binary_string
+        "".force_encoding(Encoding::BINARY)
+      end
+
+      def chain_seekable?
+        @chain_io.seekable?
+      end
+
+      def chain_num_bytes_remaining
+        @chain_io.num_bytes_remaining
+      end
+
+      def chain_offset
+        @chain_io.offset
+      end
+
+      def chain_skip(n)
+        @chain_io.skip(n)
+      end
+
+      def chain_seek_abs(n)
+        @chain_io.seek_abs(n)
+      end
+
+      def chain_read(n)
+        @chain_io.read(n)
+      end
+
+      def chain_write(data)
+        @chain_io.write(data)
+      end
+    end
+
+    # A module to be prepended to +RawIO+ or +Transform+ when the data
+    # stream is not seekable.  This is either due to underlying stream
+    # being unseekable or the transform changes the number of bytes.
+    module UnSeekableIO
+      def seekable?
+        false
+      end
+
+      def num_bytes_remaining
+        raise IOError, "stream is unseekable"
+      end
+
+      def skip(n)
+        raise IOError, "can not skip backwards" if n.negative?
+
+        # skip over data in 8k blocks
+        while n > 0
+          bytes_to_read = [n, 8192].min
+          read(bytes_to_read)
+          n -= bytes_to_read
+        end
+      end
+
+      def seek_abs(n)
+        skip(n - offset)
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/lazy.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/lazy.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/lazy.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/lazy.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/name.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/name.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/name.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/name.rb
index bd22b50312f9d..1a0e6cc9b9a77 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/name.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/name.rb
@@ -13,7 +13,7 @@ module BinData
   #                  </pre></code>
   module RegisterNamePlugin
 
-    def self.included(base) #:nodoc:
+    def self.included(base) # :nodoc:
       # The registered name may be provided explicitly.
       base.optional_parameter :name
     end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/params.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/params.rb
new file mode 100644
index 0000000000000..278f2e9591278
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/params.rb
@@ -0,0 +1,130 @@
+require 'bindata/lazy'
+
+module BinData
+  module AcceptedParametersPlugin
+    # Mandatory parameters must be present when instantiating a data object.
+    def mandatory_parameters(*args)
+      accepted_parameters.mandatory(*args)
+    end
+
+    # Optional parameters may be present when instantiating a data object.
+    def optional_parameters(*args)
+      accepted_parameters.optional(*args)
+    end
+
+    # Default parameters can be overridden when instantiating a data object.
+    def default_parameters(*args)
+      accepted_parameters.default(*args)
+    end
+
+    # Mutually exclusive parameters may not all be present when
+    # instantiating a data object.
+    def mutually_exclusive_parameters(*args)
+      accepted_parameters.mutually_exclusive(*args)
+    end
+
+    alias mandatory_parameter mandatory_parameters
+    alias optional_parameter  optional_parameters
+    alias default_parameter   default_parameters
+
+    def accepted_parameters # :nodoc:
+      @accepted_parameters ||= begin
+        ancestor_params = superclass.respond_to?(:accepted_parameters) ?
+                            superclass.accepted_parameters : nil
+        AcceptedParameters.new(ancestor_params)
+      end
+    end
+
+    # BinData objects accept parameters when initializing.  AcceptedParameters
+    # allow a BinData class to declaratively identify accepted parameters as
+    # mandatory, optional, default or mutually exclusive.
+    class AcceptedParameters
+      def initialize(ancestor_parameters = nil)
+        if ancestor_parameters
+          @mandatory = ancestor_parameters.mandatory.dup
+          @optional  = ancestor_parameters.optional.dup
+          @default   = ancestor_parameters.default.dup
+          @mutually_exclusive = ancestor_parameters.mutually_exclusive.dup
+        else
+          @mandatory = []
+          @optional  = []
+          @default   = Hash.new
+          @mutually_exclusive = []
+        end
+      end
+
+      def mandatory(*args)
+        unless args.empty?
+          @mandatory.concat(to_syms(args))
+          @mandatory.uniq!
+        end
+        @mandatory
+      end
+
+      def optional(*args)
+        unless args.empty?
+          @optional.concat(to_syms(args))
+          @optional.uniq!
+        end
+        @optional
+      end
+
+      def default(args = nil)
+        if args
+          to_syms(args.keys)  # call for side effect of validating names
+          args.each_pair do |param, value|
+            @default[param.to_sym] = value
+          end
+        end
+        @default
+      end
+
+      def mutually_exclusive(*args)
+        arg1 = args.shift
+        until args.empty?
+          args.each do |arg2|
+            @mutually_exclusive.push([arg1.to_sym, arg2.to_sym])
+            @mutually_exclusive.uniq!
+          end
+          arg1 = args.shift
+        end
+        @mutually_exclusive
+      end
+
+      def all
+        (@mandatory + @optional + @default.keys).uniq
+      end
+
+      #---------------
+      private
+
+      def to_syms(args)
+        syms = args.collect(&:to_sym)
+        ensure_valid_names(syms)
+        syms
+      end
+
+      def ensure_valid_names(names)
+        invalid_names = self.class.invalid_parameter_names
+        names.each do |name|
+          if invalid_names.include?(name)
+            raise NameError.new("Rename parameter '#{name}' " \
+                                "as it shadows an existing method.", name)
+          end
+        end
+      end
+
+      class << self
+        def invalid_parameter_names
+          @invalid_parameter_names ||= begin
+            all_names = LazyEvaluator.instance_methods(true)
+            allowed_names = [:name, :type]
+            invalid_names = (all_names - allowed_names).uniq
+
+            Hash[*invalid_names.collect { |key| [key.to_sym, true] }.flatten]
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/primitive.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/primitive.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/primitive.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/primitive.rb
index 9b9bd8d41d5bd..8dc7bb4690560 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/primitive.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/primitive.rb
@@ -73,11 +73,11 @@ def initialize_instance
       @struct = BinData::Struct.new(get_parameter(:struct_params), self)
     end
 
-    def respond_to?(symbol, include_private = false) #:nodoc:
+    def respond_to?(symbol, include_private = false) # :nodoc:
       @struct.respond_to?(symbol, include_private) || super
     end
 
-    def method_missing(symbol, *args, &block) #:nodoc:
+    def method_missing(symbol, *args, &block) # :nodoc:
       if @struct.respond_to?(symbol)
         @struct.__send__(symbol, *args, &block)
       else
@@ -91,7 +91,7 @@ def assign(val)
       @value = get
     end
 
-    def debug_name_of(child) #:nodoc:
+    def debug_name_of(child) # :nodoc:
       debug_name + "-internal-"
     end
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/record.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/record.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/record.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/record.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/registry.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/registry.rb
new file mode 100644
index 0000000000000..fa986658d3d1d
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/registry.rb
@@ -0,0 +1,134 @@
+module BinData
+  # Raised when #lookup fails.
+  class UnRegisteredTypeError < StandardError; end
+
+  # This registry contains a register of name -> class mappings.
+  #
+  # Numerics (integers and floating point numbers) have an endian property as
+  # part of their name (e.g. int32be, float_le).
+  #
+  # Classes can be looked up based on their full name or an abbreviated +name+
+  # with +hints+.
+  #
+  # There are two hints supported, :endian and :search_prefix.
+  #
+  #   #lookup("int32", { endian: :big }) will return Int32Be.
+  #
+  #   #lookup("my_type", { search_prefix: :ns }) will return NsMyType.
+  #
+  # Names are stored in under_score_style, not camelCase.
+  class Registry
+    def initialize
+      @registry = {}
+    end
+
+    def register(name, class_to_register)
+      return if name.nil? || class_to_register.nil?
+
+      formatted_name = underscore_name(name)
+      warn_if_name_is_already_registered(formatted_name, class_to_register)
+
+      @registry[formatted_name] = class_to_register
+    end
+
+    def unregister(name)
+      @registry.delete(underscore_name(name))
+    end
+
+    def lookup(name, hints = {})
+      the_class = @registry[normalize_name(name, hints)]
+      if the_class
+        the_class
+      elsif @registry[normalize_name(name, hints.merge(endian: :big))]
+        raise(UnRegisteredTypeError, "#{name}, do you need to specify endian?")
+      else
+        raise(UnRegisteredTypeError, name)
+      end
+    end
+
+    # Convert CamelCase +name+ to underscore style.
+    def underscore_name(name)
+      name
+        .to_s
+        .sub(/.*::/, "")
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .tr('-', '_')
+        .downcase
+    end
+
+    #---------------
+    private
+
+    def normalize_name(name, hints)
+      name = underscore_name(name)
+
+      if !registered?(name)
+        search_prefix = [""] + Array(hints[:search_prefix])
+        search_prefix.each do |prefix|
+          nwp = name_with_prefix(name, prefix)
+          if registered?(nwp)
+            name = nwp
+            break
+          end
+
+          nwe = name_with_endian(nwp, hints[:endian])
+          if registered?(nwe)
+            name = nwe
+            break
+          end
+        end
+      end
+
+      name
+    end
+
+    def name_with_prefix(name, prefix)
+      prefix = prefix.to_s.chomp('_')
+      if prefix == ""
+        name
+      else
+        "#{prefix}_#{name}"
+      end
+    end
+
+    def name_with_endian(name, endian)
+      return name if endian.nil?
+
+      suffix = (endian == :little) ? 'le' : 'be'
+      if /^u?int\d+$/.match?(name)
+        name + suffix
+      else
+        name + '_' + suffix
+      end
+    end
+
+    def registered?(name)
+      register_dynamic_class(name) unless @registry.key?(name)
+
+      @registry.key?(name)
+    end
+
+    def register_dynamic_class(name)
+      if /^u?int\d+(le|be)$/.match?(name) || /^s?bit\d+(le)?$/.match?(name)
+        class_name = name.gsub(/(?:^|_)(.)/) { $1.upcase }
+        begin
+          # call const_get for side effects
+          BinData.const_get(class_name)
+        rescue NameError
+        end
+      end
+    end
+
+    def warn_if_name_is_already_registered(name, class_to_register)
+      prev_class = @registry[name]
+      if prev_class && prev_class != class_to_register
+        Kernel.warn "warning: replacing registered class #{prev_class} " \
+             "with #{class_to_register}"
+      end
+    end
+  end
+
+  # A singleton registry of all registered classes.
+  RegisteredClasses = Registry.new
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/rest.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/rest.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/rest.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/rest.rb
index cdc104459c568..d6eaa245d72f1 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/rest.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/rest.rb
@@ -1,4 +1,4 @@
-require "bindata/base_primitive"
+require 'bindata/base_primitive'
 
 module BinData
   # Rest will consume the input stream from the current position to the end of
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/sanitize.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/sanitize.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/sanitize.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/sanitize.rb
index 7325b206b0c47..99ff2062033f1 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/sanitize.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/sanitize.rb
@@ -49,14 +49,10 @@ def initialize(name, field_type, field_params, hints)
       @prototype = SanitizedPrototype.new(field_type, field_params, hints)
     end
 
-    attr_reader :prototype
+    attr_reader :prototype, :name
 
     def name_as_sym
-      @name.nil? ? nil : @name.to_sym
-    end
-
-    def name
-      @name
+      @name&.to_sym
     end
 
     def has_parameter?(param)
@@ -74,11 +70,7 @@ class SanitizedFields < SanitizedParameter
 
     def initialize(hints, base_fields = nil)
       @hints = hints
-      if base_fields
-        @fields = base_fields.raw_fields
-      else
-        @fields = []
-      end
+      @fields =  base_fields ? base_fields.raw_fields : []
     end
 
     def add_field(type, name, params)
@@ -179,7 +171,6 @@ def endian
   # is to recursively sanitize the parameters of an entire BinData object chain
   # at a single time.
   class SanitizedParameters < Hash
-
     # Memoized constants
     BIG_ENDIAN    = SanitizedBigEndian.new
     LITTLE_ENDIAN = SanitizedLittleEndian.new
@@ -210,7 +201,7 @@ def initialize(parameters, the_class, hints)
       sanitize!
     end
 
-    alias_method :has_parameter?, :key?
+    alias has_parameter? key?
 
     def has_at_least_one_of?(*keys)
       keys.each do |key|
@@ -257,7 +248,9 @@ def rename_parameter(old_key, new_key)
     end
 
     def sanitize_object_prototype(key)
-      sanitize(key) { |obj_type, obj_params| create_sanitized_object_prototype(obj_type, obj_params) }
+      sanitize(key) do |obj_type, obj_params|
+        create_sanitized_object_prototype(obj_type, obj_params)
+      end
     end
 
     def sanitize_fields(key, &block)
@@ -306,7 +299,7 @@ def sanitize!
     end
 
     def needs_sanitizing?(key)
-      has_key?(key) && ! self[key].is_a?(SanitizedParameter)
+      has_parameter?(key) && !self[key].is_a?(SanitizedParameter)
     end
 
     def ensure_no_nil_values
@@ -320,7 +313,7 @@ def ensure_no_nil_values
 
     def merge_default_parameters!
       @the_class.default_parameters.each do |key, value|
-        self[key] = value unless has_key?(key)
+        self[key] = value unless has_parameter?(key)
       end
     end
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/section.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/section.rb
new file mode 100644
index 0000000000000..8194ea01cfa65
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/section.rb
@@ -0,0 +1,97 @@
+require 'bindata/base'
+require 'bindata/dsl'
+
+module BinData
+  # A Section is a layer on top of a stream that transforms the underlying
+  # data.  This allows BinData to process a stream that has multiple
+  # encodings.  e.g.  Some data data is compressed or encrypted.
+  #
+  #   require 'bindata'
+  #
+  #   class XorTransform < BinData::IO::Transform
+  #      def initialize(xor)
+  #        super()
+  #        @xor = xor
+  #      end
+  #
+  #      def read(n)
+  #        chain_read(n).bytes.map { |byte| (byte ^ @xor).chr }.join
+  #      end
+  #
+  #      def write(data)
+  #        chain_write(data.bytes.map { |byte| (byte ^ @xor).chr }.join)
+  #      end
+  #   end
+  #
+  #   obj = BinData::Section.new(transform: -> { XorTransform.new(0xff) },
+  #                              type: [:string, read_length: 5])
+  #
+  #   obj.read("\x97\x9A\x93\x93\x90") #=> "hello"
+  #
+  #
+  # == Parameters
+  #
+  # Parameters may be provided at initialisation to control the behaviour of
+  # an object.  These params are:
+  #
+  # <tt>:transform</tt>:: A callable that returns a new BinData::IO::Transform.
+  # <tt>:type</tt>::      The single type inside the buffer.  Use a struct if
+  #                       multiple fields are required.
+  class Section < BinData::Base
+    extend DSLMixin
+
+    dsl_parser    :section
+    arg_processor :section
+
+    mandatory_parameters :transform, :type
+
+    def initialize_instance
+      @type = get_parameter(:type).instantiate(nil, self)
+    end
+
+    def clear?
+      @type.clear?
+    end
+
+    def assign(val)
+      @type.assign(val)
+    end
+
+    def snapshot
+      @type.snapshot
+    end
+
+    def respond_to_missing?(symbol, include_all = false) # :nodoc:
+      @type.respond_to?(symbol, include_all) || super
+    end
+
+    def method_missing(symbol, *args, &block) # :nodoc:
+      @type.__send__(symbol, *args, &block)
+    end
+
+    def do_read(io) # :nodoc:
+      io.transform(eval_parameter(:transform)) do |transformed_io, _raw_io|
+        @type.do_read(transformed_io)
+      end
+    end
+
+    def do_write(io) # :nodoc:
+      io.transform(eval_parameter(:transform)) do |transformed_io, _raw_io|
+        @type.do_write(transformed_io)
+      end
+    end
+
+    def do_num_bytes # :nodoc:
+      to_binary_s.size
+    end
+  end
+
+  class SectionArgProcessor < BaseArgProcessor
+    include MultiFieldArgSeparator
+
+    def sanitize_parameters!(obj_class, params)
+      params.merge!(obj_class.dsl_params)
+      params.sanitize_object_prototype(:type)
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/skip.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/skip.rb
new file mode 100644
index 0000000000000..b64374d033f7f
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/skip.rb
@@ -0,0 +1,222 @@
+require 'bindata/base_primitive'
+require 'bindata/dsl'
+
+module BinData
+  # Skip will skip over bytes from the input stream.  If the stream is not
+  # seekable, then the bytes are consumed and discarded.
+  #
+  # When writing, skip will write the appropriate number of zero bytes.
+  #
+  #   require 'bindata'
+  #
+  #   class A < BinData::Record
+  #     skip length: 5
+  #     string :a, read_length: 5
+  #   end
+  #
+  #   obj = A.read("abcdefghij")
+  #   obj.a #=> "fghij"
+  #
+  #
+  #   class B < BinData::Record
+  #     skip do
+  #       string read_length: 2, assert: 'ef'
+  #     end
+  #     string :s, read_length: 5
+  #   end
+  #
+  #   obj = B.read("abcdefghij")
+  #   obj.s #=> "efghi"
+  #
+  #
+  # == Parameters
+  #
+  # Skip objects accept all the params that BinData::BasePrimitive
+  # does, as well as the following:
+  #
+  # <tt>:length</tt>::        The number of bytes to skip.
+  # <tt>:to_abs_offset</tt>:: Skips to the given absolute offset.
+  # <tt>:until_valid</tt>::   Skips until a given byte pattern is matched.
+  #                           This parameter contains a type that will raise
+  #                           a BinData::ValidityError unless an acceptable byte
+  #                           sequence is found.  The type is represented by a
+  #                           Symbol, or if the type is to have params
+  #                           passed to it, then it should be provided as
+  #                           <tt>[type_symbol, hash_params]</tt>.
+  #
+  class Skip < BinData::BasePrimitive
+    extend DSLMixin
+
+    dsl_parser    :skip
+    arg_processor :skip
+
+    optional_parameters :length, :to_abs_offset, :until_valid
+    mutually_exclusive_parameters :length, :to_abs_offset, :until_valid
+
+    def initialize_shared_instance
+      extend SkipLengthPlugin      if has_parameter?(:length)
+      extend SkipToAbsOffsetPlugin if has_parameter?(:to_abs_offset)
+      extend SkipUntilValidPlugin  if has_parameter?(:until_valid)
+      super
+    end
+
+    #---------------
+    private
+
+    def value_to_binary_string(_)
+      len = skip_length
+      if len.negative?
+        raise ArgumentError,
+              "#{debug_name} attempted to seek backwards by #{len.abs} bytes"
+      end
+
+      "\000" * skip_length
+    end
+
+    def read_and_return_value(io)
+      len = skip_length
+      if len.negative?
+        raise ArgumentError,
+              "#{debug_name} attempted to seek backwards by #{len.abs} bytes"
+      end
+
+      io.skipbytes(len)
+      ""
+    end
+
+    def sensible_default
+      ""
+    end
+
+    # Logic for the :length parameter
+    module SkipLengthPlugin
+      def skip_length
+        eval_parameter(:length)
+      end
+    end
+
+    # Logic for the :to_abs_offset parameter
+    module SkipToAbsOffsetPlugin
+      def skip_length
+        eval_parameter(:to_abs_offset) - abs_offset
+      end
+    end
+
+    # Logic for the :until_valid parameter
+    module SkipUntilValidPlugin
+      def skip_length
+        @skip_length ||= 0
+      end
+
+      def read_and_return_value(io)
+        prototype = get_parameter(:until_valid)
+        validator = prototype.instantiate(nil, self)
+        fs = fast_search_for_obj(validator)
+
+        io.transform(ReadaheadIO.new) do |transformed_io, raw_io|
+          pos = 0
+          loop do
+            seek_to_pos(pos, raw_io)
+            validator.clear
+            validator.do_read(transformed_io)
+            break
+          rescue ValidityError
+            pos += 1
+
+            if fs
+              seek_to_pos(pos, raw_io)
+              pos += next_search_index(raw_io, fs)
+            end
+          end
+
+          seek_to_pos(pos, raw_io)
+          @skip_length = pos
+        end
+      end
+
+      def seek_to_pos(pos, io)
+        io.rollback
+        io.skip(pos)
+      end
+
+      # A fast search has a pattern string at a specific offset.
+      FastSearch = ::Struct.new('FastSearch', :pattern, :offset)
+
+      def fast_search_for(obj)
+        if obj.respond_to?(:asserted_binary_s)
+          FastSearch.new(obj.asserted_binary_s, obj.rel_offset)
+        else
+          nil
+        end
+      end
+
+      # If a search object has an +asserted_value+ field then we
+      # perform a faster search for a valid object.
+      def fast_search_for_obj(obj)
+        if BinData::Struct === obj
+          obj.each_pair(true) do |_, field|
+            fs = fast_search_for(field)
+            return fs if fs
+          end
+        elsif BinData::BasePrimitive === obj
+          return fast_search_for(obj)
+        end
+
+        nil
+      end
+
+      SEARCH_SIZE = 100_000
+
+      def next_search_index(io, fs)
+        buffer = binary_string("")
+
+        # start searching at fast_search offset
+        pos = fs.offset
+        io.skip(fs.offset)
+
+        loop do
+          data = io.read(SEARCH_SIZE)
+          raise EOFError, "no match" if data.nil?
+
+          buffer << data
+          index = buffer.index(fs.pattern)
+          if index
+            return pos + index - fs.offset
+          end
+
+          # advance buffer
+          searched = buffer.slice!(0..-fs.pattern.size)
+          pos += searched.size
+        end
+      end
+
+      class ReadaheadIO < BinData::IO::Transform
+        def before_transform
+          if !seekable?
+            raise IOError, "readahead is not supported on unseekable streams"
+          end
+
+          @mark = offset
+        end
+
+        def rollback
+          seek_abs(@mark)
+        end
+      end
+    end
+  end
+
+  class SkipArgProcessor < BaseArgProcessor
+    def sanitize_parameters!(obj_class, params)
+      params.merge!(obj_class.dsl_params)
+
+      unless params.has_at_least_one_of?(:length, :to_abs_offset, :until_valid)
+        raise ArgumentError,
+              "#{obj_class} requires :length, :to_abs_offset or :until_valid"
+      end
+
+      params.must_be_integer(:to_abs_offset, :length)
+      params.sanitize_object_prototype(:until_valid)
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/string.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/string.rb
new file mode 100644
index 0000000000000..0a4d50cfe8a2f
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/string.rb
@@ -0,0 +1,153 @@
+require 'bindata/base_primitive'
+
+module BinData
+  # A String is a sequence of bytes.  This is the same as strings in Ruby 1.8.
+  # The issue of character encoding is ignored by this class.
+  #
+  #   require 'bindata'
+  #
+  #   data = "abcdefghij"
+  #
+  #   obj = BinData::String.new(read_length: 5)
+  #   obj.read(data)
+  #   obj #=> "abcde"
+  #
+  #   obj = BinData::String.new(length: 6)
+  #   obj.read(data)
+  #   obj #=> "abcdef"
+  #   obj.assign("abcdefghij")
+  #   obj #=> "abcdef"
+  #   obj.assign("abcd")
+  #   obj #=> "abcd\000\000"
+  #
+  #   obj = BinData::String.new(length: 6, trim_padding: true)
+  #   obj.assign("abcd")
+  #   obj #=> "abcd"
+  #   obj.to_binary_s #=> "abcd\000\000"
+  #
+  #   obj = BinData::String.new(length: 6, pad_byte: 'A')
+  #   obj.assign("abcd")
+  #   obj #=> "abcdAA"
+  #   obj.to_binary_s #=> "abcdAA"
+  #
+  # == Parameters
+  #
+  # String objects accept all the params that BinData::BasePrimitive
+  # does, as well as the following:
+  #
+  # <tt>:read_length</tt>::    The length in bytes to use when reading a value.
+  # <tt>:length</tt>::         The fixed length of the string.  If a shorter
+  #                            string is set, it will be padded to this length.
+  # <tt>:pad_byte</tt>::       The byte to use when padding a string to a
+  #                            set length.  Valid values are Integers and
+  #                            Strings of length 1.  "\0" is the default.
+  # <tt>:pad_front</tt>::      Signifies that the padding occurs at the front
+  #                            of the string rather than the end.  Default
+  #                            is false.
+  # <tt>:trim_padding</tt>::   Boolean, default false.  If set, #value will
+  #                            return the value with all pad_bytes trimmed
+  #                            from the end of the string.  The value will
+  #                            not be trimmed when writing.
+  class String < BinData::BasePrimitive
+    arg_processor :string
+
+    optional_parameters :read_length, :length, :trim_padding, :pad_front, :pad_left
+    default_parameters  pad_byte: "\0"
+    mutually_exclusive_parameters :read_length, :length
+    mutually_exclusive_parameters :length, :value
+
+    def initialize_shared_instance
+      if (has_parameter?(:value) || has_parameter?(:asserted_value)) &&
+          !has_parameter?(:read_length)
+        extend WarnNoReadLengthPlugin
+      end
+      super
+    end
+
+    def assign(val)
+      super(binary_string(val))
+    end
+
+    def snapshot
+      # override to trim padding
+      snap = super
+      snap = clamp_to_length(snap)
+
+      if get_parameter(:trim_padding)
+        trim_padding(snap)
+      else
+        snap
+      end
+    end
+
+    #---------------
+    private
+
+    def clamp_to_length(str)
+      str = binary_string(str)
+
+      len = eval_parameter(:length) || str.length
+      if str.length == len
+        str
+      elsif str.length > len
+        str.slice(0, len)
+      else
+        padding = (eval_parameter(:pad_byte) * (len - str.length))
+        if get_parameter(:pad_front)
+          padding + str
+        else
+          str + padding
+        end
+      end
+    end
+
+    def trim_padding(str)
+      if get_parameter(:pad_front)
+        str.sub(/\A#{eval_parameter(:pad_byte)}*/, "")
+      else
+        str.sub(/#{eval_parameter(:pad_byte)}*\z/, "")
+      end
+    end
+
+    def value_to_binary_string(val)
+      clamp_to_length(val)
+    end
+
+    def read_and_return_value(io)
+      len = eval_parameter(:read_length) || eval_parameter(:length) || 0
+      io.readbytes(len)
+    end
+
+    def sensible_default
+      ""
+    end
+
+    # Warns when reading if :value && no :read_length
+    module WarnNoReadLengthPlugin
+      def read_and_return_value(io)
+        Kernel.warn "#{debug_name} does not have a :read_length parameter - returning empty string"
+        ""
+      end
+    end
+  end
+
+  class StringArgProcessor < BaseArgProcessor
+    def sanitize_parameters!(obj_class, params)
+      params.warn_replacement_parameter(:initial_length, :read_length)
+      params.must_be_integer(:read_length, :length)
+      params.rename_parameter(:pad_left, :pad_front)
+      params.sanitize(:pad_byte) { |byte| sanitized_pad_byte(byte) }
+    end
+
+    #-------------
+    private
+
+    def sanitized_pad_byte(byte)
+      pad_byte = byte.is_a?(Integer) ? byte.chr : byte.to_s
+      if pad_byte.bytesize > 1
+        raise ArgumentError, ":pad_byte must not contain more than 1 byte"
+      end
+      pad_byte
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/stringz.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/stringz.rb
similarity index 82%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/stringz.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/stringz.rb
index ff047fca85567..2351eca6a721c 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/stringz.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/stringz.rb
@@ -1,4 +1,4 @@
-require "bindata/base_primitive"
+require 'bindata/base_primitive'
 
 module BinData
   # A BinData::Stringz object is a container for a zero ("\0") terminated
@@ -25,7 +25,6 @@ module BinData
   # <tt>:max_length</tt>:: The maximum length of the string including the zero
   #                        byte.
   class Stringz < BinData::BasePrimitive
-
     optional_parameters :max_length
 
     def assign(val)
@@ -47,14 +46,14 @@ def value_to_binary_string(val)
 
     def read_and_return_value(io)
       max_length = eval_parameter(:max_length)
-      str = ""
+      str = binary_string("")
       i = 0
       ch = nil
 
       # read until zero byte or we have read in the max number of bytes
       while ch != "\0" && i != max_length
         ch = io.readbytes(1)
-        str += ch
+        str << ch
         i += 1
       end
 
@@ -66,9 +65,15 @@ def sensible_default
     end
 
     def trim_and_zero_terminate(str)
+      max_length = eval_parameter(:max_length)
+      if max_length && max_length < 1
+        msg = "max_length must be >= 1 in #{debug_name} (got #{max_length})"
+        raise ArgumentError, msg
+      end
+
       result = binary_string(str)
       truncate_after_first_zero_byte!(result)
-      trim_to!(result, eval_parameter(:max_length))
+      trim_to!(result, max_length)
       append_zero_byte_if_needed!(result)
       result
     end
@@ -79,16 +84,13 @@ def truncate_after_first_zero_byte!(str)
 
     def trim_to!(str, max_length = nil)
       if max_length
-        max_length = 1 if max_length < 1
         str.slice!(max_length..-1)
-        if str.length == max_length && str[-1, 1] != "\0"
-          str[-1, 1] = "\0"
-        end
+        str[-1, 1] = "\0" if str.length == max_length
       end
     end
 
     def append_zero_byte_if_needed!(str)
-      if str.length == 0 || str[-1, 1] != "\0"
+      if str.empty? || str[-1, 1] != "\0"
         str << "\0"
       end
     end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/struct.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/struct.rb
new file mode 100644
index 0000000000000..1b253d8d5a172
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/struct.rb
@@ -0,0 +1,439 @@
+require 'bindata/base'
+require 'bindata/delayed_io'
+
+module BinData
+  class Base
+    optional_parameter :onlyif, :byte_align  # Used by Struct
+  end
+
+  # A Struct is an ordered collection of named data objects.
+  #
+  #    require 'bindata'
+  #
+  #    class Tuple < BinData::Record
+  #      int8  :x
+  #      int8  :y
+  #      int8  :z
+  #    end
+  #
+  #    obj = BinData::Struct.new(hide: :a,
+  #                              fields: [ [:int32le, :a],
+  #                                        [:int16le, :b],
+  #                                        [:tuple, :s] ])
+  #    obj.field_names   =># [:b, :s]
+  #
+  #
+  # == Parameters
+  #
+  # Parameters may be provided at initialisation to control the behaviour of
+  # an object.  These params are:
+  #
+  # <tt>:fields</tt>::   An array specifying the fields for this struct.
+  #                      Each element of the array is of the form [type, name,
+  #                      params].  Type is a symbol representing a registered
+  #                      type.  Name is the name of this field.  Params is an
+  #                      optional hash of parameters to pass to this field
+  #                      when instantiating it.  If name is "" or nil, then
+  #                      that field is anonymous and behaves as a hidden field.
+  # <tt>:hide</tt>::     A list of the names of fields that are to be hidden
+  #                      from the outside world.  Hidden fields don't appear
+  #                      in #snapshot or #field_names but are still accessible
+  #                      by name.
+  # <tt>:endian</tt>::   Either :little or :big.  This specifies the default
+  #                      endian of any numerics in this struct, or in any
+  #                      nested data objects.
+  # <tt>:search_prefix</tt>::  Allows abbreviated type names.  If a type is
+  #                            unrecognised, then each prefix is applied until
+  #                            a match is found.
+  #
+  # == Field Parameters
+  #
+  # Fields may have have extra parameters as listed below:
+  #
+  # [<tt>:onlyif</tt>]     Used to indicate a data object is optional.
+  #                        if +false+, this object will not be included in any
+  #                        calls to #read, #write, #num_bytes or #snapshot.
+  # [<tt>:byte_align</tt>] This field's rel_offset must be a multiple of
+  #                        <tt>:byte_align</tt>.
+  class Struct < BinData::Base
+    arg_processor :struct
+
+    mandatory_parameter :fields
+    optional_parameters :endian, :search_prefix, :hide
+
+    # These reserved words may not be used as field names
+    RESERVED =
+      Hash[*
+        (Hash.instance_methods +
+         %w[alias and begin break case class def defined do else elsif
+            end ensure false for if in module next nil not or redo
+            rescue retry return self super then true undef unless until
+            when while yield] +
+         %w[array element index value] +
+         %w[type initial_length read_until] +
+         %w[fields endian search_prefix hide onlyif byte_align] +
+         %w[choices selection copy_on_change] +
+         %w[read_abs_offset struct_params])
+        .collect(&:to_sym)
+        .uniq.collect { |key| [key, true] }
+        .flatten
+      ]
+
+    def initialize_shared_instance
+      fields = get_parameter(:fields)
+      @field_names = fields.field_names.freeze
+      extend ByteAlignPlugin if fields.any_field_has_parameter?(:byte_align)
+      define_field_accessors
+      super
+    end
+
+    def initialize_instance
+      @field_objs = []
+    end
+
+    def clear # :nodoc:
+      @field_objs.each { |f| f.nil? || f.clear }
+    end
+
+    def clear? # :nodoc:
+      @field_objs.all? { |f| f.nil? || f.clear? }
+    end
+
+    def assign(val)
+      clear
+      assign_fields(val)
+    end
+
+    def snapshot
+      snapshot = Snapshot.new
+      field_names.each do |name|
+        obj = find_obj_for_name(name)
+        snapshot[name] = obj.snapshot if include_obj?(obj)
+      end
+      snapshot
+    end
+
+    # Returns a list of the names of all fields accessible through this
+    # object.  +include_hidden+ specifies whether to include hidden names
+    # in the listing.
+    def field_names(include_hidden = false)
+      if include_hidden
+        @field_names.compact
+      else
+        hidden = get_parameter(:hide) || []
+        @field_names.compact - hidden
+      end
+    end
+
+    def debug_name_of(child) # :nodoc:
+      field_name = @field_names[find_index_of(child)]
+      "#{debug_name}.#{field_name}"
+    end
+
+    def offset_of(child) # :nodoc:
+      instantiate_all_objs
+      sum = sum_num_bytes_below_index(find_index_of(child))
+      child.bit_aligned? ? sum.floor : sum.ceil
+    end
+
+    def do_read(io) # :nodoc:
+      instantiate_all_objs
+      @field_objs.each { |f| f.do_read(io) if include_obj_for_io?(f) }
+    end
+
+    def do_write(io) # :nodoc:
+      instantiate_all_objs
+      @field_objs.each { |f| f.do_write(io) if include_obj_for_io?(f) }
+    end
+
+    def do_num_bytes # :nodoc:
+      instantiate_all_objs
+      sum_num_bytes_for_all_fields
+    end
+
+    def [](key)
+      find_obj_for_name(key)
+    end
+
+    def []=(key, value)
+      find_obj_for_name(key)&.assign(value)
+    end
+
+    def key?(key)
+      @field_names.index(base_field_name(key))
+    end
+
+    # Calls the given block for each field_name-field_obj pair.
+    #
+    # Does not include anonymous or hidden fields unless
+    # +include_all+ is true.
+    def each_pair(include_all = false)
+      instantiate_all_objs
+
+      pairs = @field_names.zip(@field_objs).select do |name, _obj|
+        name || include_all
+      end
+
+      if block_given?
+        pairs.each { |el| yield(el) }
+      else
+        pairs.each
+      end
+    end
+
+    #---------------
+    private
+
+    def define_field_accessors
+      get_parameter(:fields).each_with_index do |field, i|
+        name = field.name_as_sym
+        define_field_accessors_for(name, i) if name
+      end
+    end
+
+    def define_field_accessors_for(name, index)
+      define_singleton_method(name) do
+        instantiate_obj_at(index) if @field_objs[index].nil?
+        @field_objs[index]
+      end
+      define_singleton_method("#{name}=") do |*vals|
+        instantiate_obj_at(index) if @field_objs[index].nil?
+        @field_objs[index].assign(*vals)
+      end
+      define_singleton_method("#{name}?") do
+        instantiate_obj_at(index) if @field_objs[index].nil?
+        include_obj?(@field_objs[index])
+      end
+    end
+
+    def find_index_of(obj)
+      @field_objs.index { |el| el.equal?(obj) }
+    end
+
+    def find_obj_for_name(name)
+      index = @field_names.index(base_field_name(name))
+      if index
+        instantiate_obj_at(index)
+        @field_objs[index]
+      end
+    end
+
+    def base_field_name(name)
+      name.to_s.sub(/(=|\?)\z/, "").to_sym
+    end
+
+    def instantiate_all_objs
+      @field_names.each_index { |i| instantiate_obj_at(i) }
+    end
+
+    def instantiate_obj_at(index)
+      if @field_objs[index].nil?
+        field = get_parameter(:fields)[index]
+        @field_objs[index] = field.instantiate(nil, self)
+      end
+    end
+
+    def assign_fields(val)
+      src = as_stringified_hash(val)
+
+      @field_names.compact.each do |name|
+        obj = find_obj_for_name(name)
+        if obj && src.key?(name)
+          obj.assign(src[name])
+        end
+      end
+    end
+
+    def as_stringified_hash(val)
+      if BinData::Struct === val
+        val
+      elsif val.nil?
+        {}
+      else
+        hash = Snapshot.new
+        val.each_pair { |k, v| hash[k] = v }
+        hash
+      end
+    end
+
+    def sum_num_bytes_for_all_fields
+      sum_num_bytes_below_index(@field_objs.length)
+    end
+
+    def sum_num_bytes_below_index(index)
+      (0...index).inject(0) do |sum, i|
+        obj = @field_objs[i]
+        if include_obj?(obj)
+          nbytes = obj.do_num_bytes
+          (nbytes.is_a?(Integer) ? sum.ceil : sum) + nbytes
+        else
+          sum
+        end
+      end
+    end
+
+    def include_obj_for_io?(obj)
+      # Used by #do_read and #do_write, to ensure the stream is passed to
+      # DelayedIO objects for delayed processing.
+      include_obj?(obj) || DelayedIO === obj
+    end
+
+    def include_obj?(obj)
+      !obj.has_parameter?(:onlyif) || obj.eval_parameter(:onlyif)
+    end
+
+    # A hash that can be accessed via attributes.
+    class Snapshot < ::Hash # :nodoc:
+      def []=(key, value)
+        super unless value.nil?
+      end
+
+      def respond_to_missing?(symbol, include_all = false)
+        key?(symbol) || super
+      end
+
+      def method_missing(symbol, *args)
+        key?(symbol) ? self[symbol] : super
+      end
+    end
+
+    # Align fields to a multiple of :byte_align
+    module ByteAlignPlugin
+      def do_read(io)
+        offset = 0
+        instantiate_all_objs
+        @field_objs.each do |f|
+          next unless include_obj?(f)
+
+          if align_obj?(f)
+            nbytes = bytes_to_align(f, offset.ceil)
+            offset = offset.ceil + nbytes
+            io.readbytes(nbytes)
+          end
+
+          f.do_read(io)
+          nbytes = f.do_num_bytes
+          offset = (nbytes.is_a?(Integer) ? offset.ceil : offset) + nbytes
+        end
+      end
+
+      def do_write(io)
+        offset = 0
+        instantiate_all_objs
+        @field_objs.each do |f|
+          next unless include_obj?(f)
+
+          if align_obj?(f)
+            nbytes = bytes_to_align(f, offset.ceil)
+            offset = offset.ceil + nbytes
+            io.writebytes("\x00" * nbytes)
+          end
+
+          f.do_write(io)
+          nbytes = f.do_num_bytes
+          offset = (nbytes.is_a?(Integer) ? offset.ceil : offset) + nbytes
+        end
+      end
+
+      def sum_num_bytes_below_index(index)
+        sum = 0
+        @field_objs.each_with_index do |obj, i|
+          next unless include_obj?(obj)
+
+          if align_obj?(obj)
+            sum = sum.ceil + bytes_to_align(obj, sum.ceil)
+          end
+
+          break if i >= index
+
+          nbytes = obj.do_num_bytes
+          sum = (nbytes.is_a?(Integer) ? sum.ceil : sum) + nbytes
+        end
+
+        sum
+      end
+
+      def bytes_to_align(obj, rel_offset)
+        align = obj.eval_parameter(:byte_align)
+        (align - (rel_offset % align)) % align
+      end
+
+      def align_obj?(obj)
+        obj.has_parameter?(:byte_align)
+      end
+    end
+  end
+
+  class StructArgProcessor < BaseArgProcessor
+    def sanitize_parameters!(obj_class, params)
+      sanitize_endian(params)
+      sanitize_search_prefix(params)
+      sanitize_fields(obj_class, params)
+      sanitize_hide(params)
+    end
+
+    #-------------
+    private
+
+    def sanitize_endian(params)
+      params.sanitize_endian(:endian)
+    end
+
+    def sanitize_search_prefix(params)
+      params.sanitize(:search_prefix) do |sprefix|
+        search_prefix = Array(sprefix).collect do |prefix|
+          prefix.to_s.chomp("_")
+        end
+
+        search_prefix - [""]
+      end
+    end
+
+    def sanitize_fields(obj_class, params)
+      params.sanitize_fields(:fields) do |fields, sanitized_fields|
+        fields.each do |ftype, fname, fparams|
+          sanitized_fields.add_field(ftype, fname, fparams)
+        end
+
+        field_names = sanitized_field_names(sanitized_fields)
+        ensure_field_names_are_valid(obj_class, field_names)
+      end
+    end
+
+    def sanitize_hide(params)
+      params.sanitize(:hide) do |hidden|
+        field_names  = sanitized_field_names(params[:fields])
+        hfield_names = hidden_field_names(hidden)
+
+        hfield_names & field_names
+      end
+    end
+
+    def sanitized_field_names(sanitized_fields)
+      sanitized_fields.field_names.compact
+    end
+
+    def hidden_field_names(hidden)
+      (hidden || []).collect(&:to_sym)
+    end
+
+    def ensure_field_names_are_valid(obj_class, field_names)
+      reserved_names = BinData::Struct::RESERVED
+
+      field_names.each do |name|
+        if obj_class.method_defined?(name)
+          raise NameError.new("Rename field '#{name}' in #{obj_class}, " \
+                              "as it shadows an existing method.", name)
+        end
+        if reserved_names.include?(name)
+          raise NameError.new("Rename field '#{name}' in #{obj_class}, " \
+                              "as it is a reserved name.", name)
+        end
+        if field_names.count(name) != 1
+          raise NameError.new("field '#{name}' in #{obj_class}, " \
+                              "is defined multiple times.", name)
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/trace.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/trace.rb
similarity index 76%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/trace.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/trace.rb
index 4e4f9ba59c477..d1dce92fe58f7 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/trace.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/trace.rb
@@ -1,8 +1,26 @@
 module BinData
+
+  # Turn on trace information when reading a BinData object.
+  # If +block+ is given then the tracing only occurs for that block.
+  # This is useful for debugging a BinData declaration.
+  def trace_reading(io = STDERR)
+    @tracer = Tracer.new(io)
+    [BasePrimitive, Choice].each(&:turn_on_tracing)
+
+    if block_given?
+      begin
+        yield
+      ensure
+        [BasePrimitive, Choice].each(&:turn_off_tracing)
+        @tracer = nil
+      end
+    end
+  end
+
   # reference to the current tracer
   @tracer ||= nil
 
-  class Tracer #:nodoc:
+  class Tracer # :nodoc:
     def initialize(io)
       @trace_io = io
     end
@@ -20,47 +38,34 @@ def trace_obj(obj_name, val)
     end
   end
 
-  # Turn on trace information when reading a BinData object.
-  # If +block+ is given then the tracing only occurs for that block.
-  # This is useful for debugging a BinData declaration.
-  def trace_reading(io = STDERR)
-    @tracer = Tracer.new(io)
-    [BasePrimitive, Choice].each(&:turn_on_tracing)
-
-    if block_given?
-      begin
-        yield
-      ensure
-        [BasePrimitive, Choice].each(&:turn_off_tracing)
-        @tracer = nil
-      end
-    end
-  end
-
-  def trace_message #:nodoc:
-    yield @tracer if @tracer
+  def trace_message # :nodoc:
+    yield @tracer
   end
 
   module_function :trace_reading, :trace_message
 
-  class BasePrimitive < BinData::Base
-    class << self
-      def turn_on_tracing
+  module TraceHook
+    def turn_on_tracing
+      if !method_defined? :do_read_without_hook
         alias_method :do_read_without_hook, :do_read
         alias_method :do_read, :do_read_with_hook
       end
+    end
 
-      def turn_off_tracing
+    def turn_off_tracing
+      if method_defined? :do_read_without_hook
         alias_method :do_read, :do_read_without_hook
+        remove_method :do_read_without_hook
       end
     end
+  end
+
+  class BasePrimitive < BinData::Base
+    extend TraceHook
 
     def do_read_with_hook(io)
       do_read_without_hook(io)
-      trace_value
-    end
 
-    def trace_value
       BinData.trace_message do |tracer|
         value_string = _value.inspect
         tracer.trace_obj(debug_name, value_string)
@@ -69,27 +74,15 @@ def trace_value
   end
 
   class Choice < BinData::Base
-    class << self
-      def turn_on_tracing
-        alias_method :do_read_without_hook, :do_read
-        alias_method :do_read, :do_read_with_hook
-      end
-
-      def turn_off_tracing
-        alias_method :do_read, :do_read_without_hook
-      end
-    end
+    extend TraceHook
 
     def do_read_with_hook(io)
-      trace_selection
-      do_read_without_hook(io)
-    end
-
-    def trace_selection
       BinData.trace_message do |tracer|
         selection_string = eval_parameter(:selection).inspect
         tracer.trace_obj("#{debug_name}-selection-", selection_string)
       end
+
+      do_read_without_hook(io)
     end
   end
 end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/brotli.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/brotli.rb
new file mode 100755
index 0000000000000..9a9396fd6804c
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/brotli.rb
@@ -0,0 +1,35 @@
+require 'brotli'
+
+module BinData
+  module Transform
+    # Transforms a brotli compressed data stream.
+    #
+    #     gem install brotli
+    class Brotli < BinData::IO::Transform
+      transform_changes_stream_length!
+
+      def initialize(read_length)
+        super()
+        @length = read_length
+      end
+
+      def read(n)
+        @read ||= ::Brotli::inflate(chain_read(@length))
+        @read.slice!(0...n)
+      end
+
+      def write(data)
+        @write ||= create_empty_binary_string
+        @write << data
+      end
+
+      def after_read_transform
+        raise IOError, "didn't read all data" unless @read.empty?
+      end
+
+      def after_write_transform
+        chain_write(::Brotli::deflate(@write))
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/lz4.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/lz4.rb
new file mode 100755
index 0000000000000..227343e3d59b3
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/lz4.rb
@@ -0,0 +1,35 @@
+require 'extlz4'
+
+module BinData
+  module Transform
+    # Transforms a LZ4 compressed data stream.
+    #
+    #     gem install extlz4
+    class LZ4 < BinData::IO::Transform
+      transform_changes_stream_length!
+
+      def initialize(read_length)
+        super()
+        @length = read_length
+      end
+
+      def read(n)
+        @read ||= ::LZ4::decode(chain_read(@length))
+        @read.slice!(0...n)
+      end
+
+      def write(data)
+        @write ||= create_empty_binary_string
+        @write << data
+      end
+
+      def after_read_transform
+        raise IOError, "didn't read all data" unless @read.empty?
+      end
+
+      def after_write_transform
+        chain_write(::LZ4::encode(@write))
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/lzma.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/lzma.rb
new file mode 100755
index 0000000000000..332a4fe9ff791
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/lzma.rb
@@ -0,0 +1,35 @@
+require 'xz'
+
+module BinData
+  module Transform
+    # Transforms a lzma compressed data stream.
+    #
+    #     gem install ruby-xz
+    class Lzma < BinData::IO::Transform
+      transform_changes_stream_length!
+
+      def initialize(read_length)
+        super()
+        @length = read_length
+      end
+
+      def read(n)
+        @read ||= ::XZ::decompress(chain_read(@length))
+        @read.slice!(0...n)
+      end
+
+      def write(data)
+        @write ||= create_empty_binary_string
+        @write << data
+      end
+
+      def after_read_transform
+        raise IOError, "didn't read all data" unless @read.empty?
+      end
+
+      def after_write_transform
+        chain_write(::XZ::compress(@write))
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/xor.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/xor.rb
new file mode 100755
index 0000000000000..c67d0465e2488
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/xor.rb
@@ -0,0 +1,19 @@
+module BinData
+  module Transform
+    # Transforms the data stream by xoring each byte.
+    class Xor < BinData::IO::Transform
+      def initialize(xor)
+        super()
+        @xor = xor
+      end
+
+      def read(n)
+        chain_read(n).bytes.map { |byte| (byte ^ @xor).chr }.join
+      end
+
+      def write(data)
+        chain_write(data.bytes.map { |byte| (byte ^ @xor).chr }.join)
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/xz.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/xz.rb
new file mode 100755
index 0000000000000..c8288397324cd
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/xz.rb
@@ -0,0 +1,35 @@
+require 'xz'
+
+module BinData
+  module Transform
+    # Transforms a xz compressed data stream.
+    #
+    #     gem install ruby-xz
+    class XZ < BinData::IO::Transform
+      transform_changes_stream_length!
+
+      def initialize(read_length)
+        super()
+        @length = read_length
+      end
+
+      def read(n)
+        @read ||= ::XZ::decompress(chain_read(@length))
+        @read.slice!(0...n)
+      end
+
+      def write(data)
+        @write ||= create_empty_binary_string
+        @write << data
+      end
+
+      def after_read_transform
+        raise IOError, "didn't read all data" unless @read.empty?
+      end
+
+      def after_write_transform
+        chain_write(::XZ::compress(@write))
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/zlib.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/zlib.rb
new file mode 100755
index 0000000000000..4e724af1fd96b
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/zlib.rb
@@ -0,0 +1,33 @@
+require 'zlib'
+
+module BinData
+  module Transform
+    # Transforms a zlib compressed data stream.
+    class Zlib < BinData::IO::Transform
+      transform_changes_stream_length!
+
+      def initialize(read_length)
+        super()
+        @length = read_length
+      end
+
+      def read(n)
+        @read ||= ::Zlib::Inflate.inflate(chain_read(@length))
+        @read.slice!(0...n)
+      end
+
+      def write(data)
+        @write ||= create_empty_binary_string
+        @write << data
+      end
+
+      def after_read_transform
+        raise IOError, "didn't read all data" unless @read.empty?
+      end
+
+      def after_write_transform
+        chain_write(::Zlib::Deflate.deflate(@write))
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/zstd.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/zstd.rb
new file mode 100755
index 0000000000000..58e3b126a5f91
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/transform/zstd.rb
@@ -0,0 +1,35 @@
+require 'zstd-ruby'
+
+module BinData
+  module Transform
+    # Transforms a zstd compressed data stream.
+    #
+    #     gem install zstd-ruby
+    class Zstd < BinData::IO::Transform
+      transform_changes_stream_length!
+
+      def initialize(read_length)
+        super()
+        @length = read_length
+      end
+
+      def read(n)
+        @read ||= ::Zstd::decompress(chain_read(@length))
+        @read.slice!(0...n)
+      end
+
+      def write(data)
+        @write ||= create_empty_binary_string
+        @write << data
+      end
+
+      def after_read_transform
+        raise IOError, "didn't read all data" unless @read.empty?
+      end
+
+      def after_write_transform
+        chain_write(::Zstd::compress(@write))
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/uint8_array.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/uint8_array.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/uint8_array.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/uint8_array.rb
index 72816611e8eeb..1507ab6ca156e 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/uint8_array.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/uint8_array.rb
@@ -1,4 +1,4 @@
-require "bindata/base_primitive"
+require 'bindata/base_primitive'
 
 module BinData
   # Uint8Array is a specialised type of array that only contains
@@ -49,7 +49,7 @@ def sensible_default
   end
 
   class Uint8ArrayArgProcessor < BaseArgProcessor
-    def sanitize_parameters!(obj_class, params) #:nodoc:
+    def sanitize_parameters!(obj_class, params) # :nodoc:
       # ensure one of :initial_length and :read_until exists
       unless params.has_at_least_one_of?(:initial_length, :read_until)
         params[:initial_length] = 0
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/version.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/version.rb
new file mode 100644
index 0000000000000..6856d5bdf3257
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/version.rb
@@ -0,0 +1,3 @@
+module BinData
+  VERSION = '2.5.0'
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/virtual.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/virtual.rb
similarity index 91%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/virtual.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/virtual.rb
index 1a7205f74bf83..93eb902d5b62c 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/virtual.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/virtual.rb
@@ -1,4 +1,4 @@
-require "bindata/base"
+require 'bindata/base'
 
 module BinData
   # A virtual field is one that is neither read, written nor occupies space in
@@ -15,7 +15,7 @@ module BinData
   #
   #   obj = A.read("abcdeabcde")
   #   obj.a #=> "abcde"
-  #   obj.c.offset #=> 10
+  #   obj.c.rel_offset #=> 10
   #
   #   obj = A.read("abcdeABCDE") #=> BinData::ValidityError: assertion failed for obj.c
   #
@@ -29,12 +29,9 @@ module BinData
   # [<tt>:value</tt>]     The virtual object will always have this value.
   #
   class Virtual < BinData::BasePrimitive
+    def do_read(io); end
 
-    def do_read(io)
-    end
-
-    def do_write(io)
-    end
+    def do_write(io); end
 
     def do_num_bytes
       0.0
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/warnings.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/warnings.rb
similarity index 94%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/warnings.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/warnings.rb
index 3d1cfe728be72..71868bb96ccf7 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/bindata-2.4.10/lib/bindata/warnings.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/bindata-2.5.0/lib/bindata/warnings.rb
@@ -13,7 +13,7 @@ def initialize_with_warning(*args)
       owner = method(:initialize).owner
       if owner != BinData::Base
         msg = "Don't override #initialize on #{owner}."
-        if %w(BinData::Base BinData::BasePrimitive).include? self.class.superclass.name
+        if %w[BinData::Base BinData::BasePrimitive].include? self.class.superclass.name
           msg += "\nrename #initialize to #initialize_instance."
         end
         fail msg
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/LICENSE.txt b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/LICENSE.txt
new file mode 100644
index 0000000000000..1026f28d0be92
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/LICENSE.txt
@@ -0,0 +1,21 @@
+Copyright (c) Jerry D'Antonio -- released under the MIT license.
+
+http://www.opensource.org/licenses/mit-license.php
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent-ruby.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent-ruby.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent-ruby.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent-ruby.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/agent.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/agent.rb
similarity index 99%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/agent.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/agent.rb
index 815dca008c326..2d32926ba14d0 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/agent.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/agent.rb
@@ -1,9 +1,10 @@
 require 'concurrent/configuration'
 require 'concurrent/atomic/atomic_reference'
+require 'concurrent/atomic/count_down_latch'
 require 'concurrent/atomic/thread_local_var'
 require 'concurrent/collection/copy_on_write_observer_set'
 require 'concurrent/concern/observable'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/array.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/array.rb
new file mode 100644
index 0000000000000..c8761af8a6e22
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/array.rb
@@ -0,0 +1,56 @@
+require 'concurrent/utility/engine'
+require 'concurrent/thread_safe/util'
+
+module Concurrent
+
+  # @!macro concurrent_array
+  #
+  #   A thread-safe subclass of Array. This version locks against the object
+  #   itself for every method call, ensuring only one thread can be reading
+  #   or writing at a time. This includes iteration methods like `#each`.
+  #
+  #   @note `a += b` is **not** a **thread-safe** operation on
+  #     `Concurrent::Array`. It reads array `a`, then it creates new `Concurrent::Array`
+  #     which is concatenation of `a` and `b`, then it writes the concatenation to `a`.
+  #     The read and write are independent operations they do not form a single atomic
+  #     operation therefore when two `+=` operations are executed concurrently updates
+  #     may be lost. Use `#concat` instead.
+  #
+  #   @see http://ruby-doc.org/core/Array.html Ruby standard library `Array`
+
+  # @!macro internal_implementation_note
+  ArrayImplementation = case
+                        when Concurrent.on_cruby?
+                          # Array is not fully thread-safe on CRuby, see
+                          # https://github.com/ruby-concurrency/concurrent-ruby/issues/929
+                          # So we will need to add synchronization here
+                          ::Array
+
+                        when Concurrent.on_jruby?
+                          require 'jruby/synchronized'
+
+                          class JRubyArray < ::Array
+                            include JRuby::Synchronized
+                          end
+                          JRubyArray
+
+                        when Concurrent.on_truffleruby?
+                          require 'concurrent/thread_safe/util/data_structures'
+
+                          class TruffleRubyArray < ::Array
+                          end
+
+                          ThreadSafe::Util.make_synchronized_on_truffleruby TruffleRubyArray
+                          TruffleRubyArray
+
+                        else
+                          warn 'Possibly unsupported Ruby implementation'
+                          ::Array
+                        end
+  private_constant :ArrayImplementation
+
+  # @!macro concurrent_array
+  class Array < ArrayImplementation
+  end
+
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/async.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/async.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/async.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/async.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atom.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atom.rb
similarity index 99%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atom.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atom.rb
index 8a45730082625..1074006d76a04 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atom.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atom.rb
@@ -1,7 +1,7 @@
 require 'concurrent/atomic/atomic_reference'
 require 'concurrent/collection/copy_on_notify_observer_set'
 require 'concurrent/concern/observable'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
 
 # @!macro thread_safe_variable_comparison
 #
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb
similarity index 94%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb
index 0b0373dc29cab..f775691a2a6a5 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb
@@ -1,5 +1,6 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
 require 'concurrent/atomic/mutex_atomic_boolean'
-require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -79,10 +80,10 @@ module Concurrent
   # @!visibility private
   # @!macro internal_implementation_note
   AtomicBooleanImplementation = case
-                                when defined?(JavaAtomicBoolean)
-                                  JavaAtomicBoolean
-                                when defined?(CAtomicBoolean)
+                                when Concurrent.on_cruby? && Concurrent.c_extensions_loaded?
                                   CAtomicBoolean
+                                when Concurrent.on_jruby?
+                                  JavaAtomicBoolean
                                 else
                                   MutexAtomicBoolean
                                 end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb
index c67166d833543..26cd05d869213 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb
@@ -1,5 +1,6 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
 require 'concurrent/atomic/mutex_atomic_fixnum'
-require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -96,10 +97,10 @@ module Concurrent
   # @!visibility private
   # @!macro internal_implementation_note
   AtomicFixnumImplementation = case
-                               when defined?(JavaAtomicFixnum)
-                                 JavaAtomicFixnum
-                               when defined?(CAtomicFixnum)
+                               when Concurrent.on_cruby? && Concurrent.c_extensions_loaded?
                                  CAtomicFixnum
+                               when Concurrent.on_jruby?
+                                 JavaAtomicFixnum
                                else
                                  MutexAtomicFixnum
                                end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb
index f20cd46a5259a..e16be65772c96 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb
@@ -1,3 +1,6 @@
+require 'concurrent/errors'
+require 'concurrent/synchronization/object'
+
 module Concurrent
   # An atomic reference which maintains an object reference along with a mark bit
   # that can be updated atomically.
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/atomic_reference.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/atomic_reference.rb
new file mode 100644
index 0000000000000..bb5fb774598cd
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/atomic_reference.rb
@@ -0,0 +1,135 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
+require 'concurrent/atomic_reference/atomic_direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+require 'concurrent/atomic_reference/mutex_atomic'
+
+# Shim for TruffleRuby::AtomicReference
+if Concurrent.on_truffleruby? && !defined?(TruffleRuby::AtomicReference)
+  # @!visibility private
+  module TruffleRuby
+    AtomicReference = Truffle::AtomicReference
+  end
+end
+
+module Concurrent
+
+  # @!macro internal_implementation_note
+  AtomicReferenceImplementation = case
+                                  when Concurrent.on_cruby? && Concurrent.c_extensions_loaded?
+                                    # @!visibility private
+                                    # @!macro internal_implementation_note
+                                    class CAtomicReference
+                                      include AtomicDirectUpdate
+                                      include AtomicNumericCompareAndSetWrapper
+                                      alias_method :compare_and_swap, :compare_and_set
+                                    end
+                                    CAtomicReference
+                                  when Concurrent.on_jruby?
+                                    # @!visibility private
+                                    # @!macro internal_implementation_note
+                                    class JavaAtomicReference
+                                      include AtomicDirectUpdate
+                                    end
+                                    JavaAtomicReference
+                                  when Concurrent.on_truffleruby?
+                                    class TruffleRubyAtomicReference < TruffleRuby::AtomicReference
+                                      include AtomicDirectUpdate
+                                      alias_method :value, :get
+                                      alias_method :value=, :set
+                                      alias_method :compare_and_swap, :compare_and_set
+                                      alias_method :swap, :get_and_set
+                                    end
+                                    TruffleRubyAtomicReference
+                                  else
+                                    MutexAtomicReference
+                                  end
+  private_constant :AtomicReferenceImplementation
+
+  # An object reference that may be updated atomically. All read and write
+  # operations have java volatile semantic.
+  #
+  # @!macro thread_safe_variable_comparison
+  #
+  # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html
+  # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html
+  #
+  # @!method initialize(value = nil)
+  #   @!macro atomic_reference_method_initialize
+  #     @param [Object] value The initial value.
+  #
+  # @!method get
+  #   @!macro atomic_reference_method_get
+  #     Gets the current value.
+  #     @return [Object] the current value
+  #
+  # @!method set(new_value)
+  #   @!macro atomic_reference_method_set
+  #     Sets to the given value.
+  #     @param [Object] new_value the new value
+  #     @return [Object] the new value
+  #
+  # @!method get_and_set(new_value)
+  #   @!macro atomic_reference_method_get_and_set
+  #     Atomically sets to the given value and returns the old value.
+  #     @param [Object] new_value the new value
+  #     @return [Object] the old value
+  #
+  # @!method compare_and_set(old_value, new_value)
+  #   @!macro atomic_reference_method_compare_and_set
+  #
+  #     Atomically sets the value to the given updated value if
+  #     the current value == the expected value.
+  #
+  #     @param [Object] old_value the expected value
+  #     @param [Object] new_value the new value
+  #
+  #     @return [Boolean] `true` if successful. A `false` return indicates
+  #     that the actual value was not equal to the expected value.
+  #
+  # @!method update
+  #   Pass the current value to the given block, replacing it
+  #   with the block's result. May retry if the value changes
+  #   during the block's execution.
+  #
+  #   @yield [Object] Calculate a new value for the atomic reference using
+  #     given (old) value
+  #   @yieldparam [Object] old_value the starting value of the atomic reference
+  #   @return [Object] the new value
+  #
+  # @!method try_update
+  #   Pass the current value to the given block, replacing it
+  #   with the block's result. Return nil if the update fails.
+  #
+  #   @yield [Object] Calculate a new value for the atomic reference using
+  #     given (old) value
+  #   @yieldparam [Object] old_value the starting value of the atomic reference
+  #   @note This method was altered to avoid raising an exception by default.
+  #     Instead, this method now returns `nil` in case of failure. For more info,
+  #     please see: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
+  #   @return [Object] the new value, or nil if update failed
+  #
+  # @!method try_update!
+  #   Pass the current value to the given block, replacing it
+  #   with the block's result. Raise an exception if the update
+  #   fails.
+  #
+  #   @yield [Object] Calculate a new value for the atomic reference using
+  #     given (old) value
+  #   @yieldparam [Object] old_value the starting value of the atomic reference
+  #   @note This behavior mimics the behavior of the original
+  #     `AtomicReference#try_update` API. The reason this was changed was to
+  #     avoid raising exceptions (which are inherently slow) by default. For more
+  #     info: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
+  #   @return [Object] the new value
+  #   @raise [Concurrent::ConcurrentUpdateError] if the update fails
+  class AtomicReference < AtomicReferenceImplementation
+
+    # @return [String] Short string representation.
+    def to_s
+      format '%s value:%s>', super[0..-2], get
+    end
+
+    alias_method :inspect, :to_s
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/count_down_latch.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/count_down_latch.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/count_down_latch.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/count_down_latch.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb
index 42f5a94967b86..9ebe29dd09816 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb
@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 require 'concurrent/utility/native_integer'
 
 module Concurrent
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/event.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/event.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/event.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/event.rb
index 31700ce22b7a3..ccf84c9d1b8a1 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/event.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/event.rb
@@ -1,5 +1,5 @@
 require 'thread'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/fiber_local_var.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/fiber_local_var.rb
new file mode 100644
index 0000000000000..e90fc24f9ecb5
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/fiber_local_var.rb
@@ -0,0 +1,109 @@
+require 'concurrent/constants'
+require_relative 'locals'
+
+module Concurrent
+
+  # A `FiberLocalVar` is a variable where the value is different for each fiber.
+  # Each variable may have a default value, but when you modify the variable only
+  # the current fiber will ever see that change.
+  #
+  # This is similar to Ruby's built-in fiber-local variables (`Thread.current[:name]`),
+  # but with these major advantages:
+  # * `FiberLocalVar` has its own identity, it doesn't need a Symbol.
+  # * Each Ruby's built-in fiber-local variable leaks some memory forever (it's a Symbol held forever on the fiber),
+  #   so it's only OK to create a small amount of them.
+  #   `FiberLocalVar` has no such issue and it is fine to create many of them.
+  # * Ruby's built-in fiber-local variables leak forever the value set on each fiber (unless set to nil explicitly).
+  #   `FiberLocalVar` automatically removes the mapping for each fiber once the `FiberLocalVar` instance is GC'd.
+  #
+  # @example
+  #   v = FiberLocalVar.new(14)
+  #   v.value #=> 14
+  #   v.value = 2
+  #   v.value #=> 2
+  #
+  # @example
+  #   v = FiberLocalVar.new(14)
+  #
+  #   Fiber.new do
+  #     v.value #=> 14
+  #     v.value = 1
+  #     v.value #=> 1
+  #   end.resume
+  #
+  #   Fiber.new do
+  #     v.value #=> 14
+  #     v.value = 2
+  #     v.value #=> 2
+  #   end.resume
+  #
+  #   v.value #=> 14
+  class FiberLocalVar
+    LOCALS = FiberLocals.new
+
+    # Creates a fiber local variable.
+    #
+    # @param [Object] default the default value when otherwise unset
+    # @param [Proc] default_block Optional block that gets called to obtain the
+    #   default value for each fiber
+    def initialize(default = nil, &default_block)
+      if default && block_given?
+        raise ArgumentError, "Cannot use both value and block as default value"
+      end
+
+      if block_given?
+        @default_block = default_block
+        @default = nil
+      else
+        @default_block = nil
+        @default = default
+      end
+
+      @index = LOCALS.next_index(self)
+    end
+
+    # Returns the value in the current fiber's copy of this fiber-local variable.
+    #
+    # @return [Object] the current value
+    def value
+      LOCALS.fetch(@index) { default }
+    end
+
+    # Sets the current fiber's copy of this fiber-local variable to the specified value.
+    #
+    # @param [Object] value the value to set
+    # @return [Object] the new value
+    def value=(value)
+      LOCALS.set(@index, value)
+    end
+
+    # Bind the given value to fiber local storage during
+    # execution of the given block.
+    #
+    # @param [Object] value the value to bind
+    # @yield the operation to be performed with the bound variable
+    # @return [Object] the value
+    def bind(value)
+      if block_given?
+        old_value = self.value
+        self.value = value
+        begin
+          yield
+        ensure
+          self.value = old_value
+        end
+      end
+    end
+
+    protected
+
+    # @!visibility private
+    def default
+      if @default_block
+        self.value = @default_block.call
+      else
+        @default
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/java_count_down_latch.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/java_count_down_latch.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/java_count_down_latch.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/java_count_down_latch.rb
index cb5b35a567a87..3c119bc32c2c4 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/java_count_down_latch.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/java_count_down_latch.rb
@@ -1,4 +1,5 @@
 if Concurrent.on_jruby?
+  require 'concurrent/utility/native_extension_loader'
 
   module Concurrent
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/locals.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/locals.rb
new file mode 100644
index 0000000000000..0a276aedd5251
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/locals.rb
@@ -0,0 +1,189 @@
+require 'fiber'
+require 'concurrent/utility/engine'
+require 'concurrent/constants'
+
+module Concurrent
+  # @!visibility private
+  # @!macro internal_implementation_note
+  #
+  # An abstract implementation of local storage, with sub-classes for
+  # per-thread and per-fiber locals.
+  #
+  # Each execution context (EC, thread or fiber) has a lazily initialized array
+  # of local variable values. Each time a new local variable is created, we
+  # allocate an "index" for it.
+  #
+  # For example, if the allocated index is 1, that means slot #1 in EVERY EC's
+  # locals array will be used for the value of that variable.
+  #
+  # The good thing about using a per-EC structure to hold values, rather than
+  # a global, is that no synchronization is needed when reading and writing
+  # those values (since the structure is only ever accessed by a single
+  # thread).
+  #
+  # Of course, when a local variable is GC'd, 1) we need to recover its index
+  # for use by other new local variables (otherwise the locals arrays could
+  # get bigger and bigger with time), and 2) we need to null out all the
+  # references held in the now-unused slots (both to avoid blocking GC of those
+  # objects, and also to prevent "stale" values from being passed on to a new
+  # local when the index is reused).
+  #
+  # Because we need to null out freed slots, we need to keep references to
+  # ALL the locals arrays, so we can null out the appropriate slots in all of
+  # them. This is why we need to use a finalizer to clean up the locals array
+  # when the EC goes out of scope.
+  class AbstractLocals
+    def initialize
+      @free = []
+      @lock = Mutex.new
+      @all_arrays = {}
+      @next = 0
+    end
+
+    def synchronize
+      @lock.synchronize { yield }
+    end
+
+    if Concurrent.on_cruby?
+      def weak_synchronize
+        yield
+      end
+    else
+      alias_method :weak_synchronize, :synchronize
+    end
+
+    def next_index(local)
+      index = synchronize do
+        if @free.empty?
+          @next += 1
+        else
+          @free.pop
+        end
+      end
+
+      # When the local goes out of scope, we should free the associated index
+      # and all values stored into it.
+      ObjectSpace.define_finalizer(local, local_finalizer(index))
+
+      index
+    end
+
+    def free_index(index)
+      weak_synchronize do
+        # The cost of GC'ing a TLV is linear in the number of ECs using local
+        # variables. But that is natural! More ECs means more storage is used
+        # per local variable. So naturally more CPU time is required to free
+        # more storage.
+        #
+        # DO NOT use each_value which might conflict with new pair assignment
+        # into the hash in #set method.
+        @all_arrays.values.each do |locals|
+          locals[index] = nil
+        end
+
+        # free index has to be published after the arrays are cleared:
+        @free << index
+      end
+    end
+
+    def fetch(index)
+      locals = self.locals
+      value = locals ? locals[index] : nil
+
+      if nil == value
+        yield
+      elsif NULL.equal?(value)
+        nil
+      else
+        value
+      end
+    end
+
+    def set(index, value)
+      locals = self.locals!
+      locals[index] = (nil == value ? NULL : value)
+
+      value
+    end
+
+    private
+
+    # When the local goes out of scope, clean up that slot across all locals currently assigned.
+    def local_finalizer(index)
+      proc do
+        free_index(index)
+      end
+    end
+
+    # When a thread/fiber goes out of scope, remove the array from @all_arrays.
+    def thread_fiber_finalizer(array_object_id)
+      proc do
+        weak_synchronize do
+          @all_arrays.delete(array_object_id)
+        end
+      end
+    end
+
+    # Returns the locals for the current scope, or nil if none exist.
+    def locals
+      raise NotImplementedError
+    end
+
+    # Returns the locals for the current scope, creating them if necessary.
+    def locals!
+      raise NotImplementedError
+    end
+  end
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  # An array-backed storage of indexed variables per thread.
+  class ThreadLocals < AbstractLocals
+    def locals
+      Thread.current.thread_variable_get(:concurrent_thread_locals)
+    end
+
+    def locals!
+      thread = Thread.current
+      locals = thread.thread_variable_get(:concurrent_thread_locals)
+
+      unless locals
+        locals = thread.thread_variable_set(:concurrent_thread_locals, [])
+        weak_synchronize do
+          @all_arrays[locals.object_id] = locals
+        end
+        # When the thread goes out of scope, we should delete the associated locals:
+        ObjectSpace.define_finalizer(thread, thread_fiber_finalizer(locals.object_id))
+      end
+
+      locals
+    end
+  end
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  # An array-backed storage of indexed variables per fiber.
+  class FiberLocals < AbstractLocals
+    def locals
+      Thread.current[:concurrent_fiber_locals]
+    end
+
+    def locals!
+      thread = Thread.current
+      locals = thread[:concurrent_fiber_locals]
+
+      unless locals
+        locals = thread[:concurrent_fiber_locals] = []
+        weak_synchronize do
+          @all_arrays[locals.object_id] = locals
+        end
+        # When the fiber goes out of scope, we should delete the associated locals:
+        ObjectSpace.define_finalizer(Fiber.current, thread_fiber_finalizer(locals.object_id))
+      end
+
+      locals
+    end
+  end
+
+  private_constant :AbstractLocals, :ThreadLocals, :FiberLocals
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/lock_local_var.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/lock_local_var.rb
new file mode 100644
index 0000000000000..ebf23a2414093
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/lock_local_var.rb
@@ -0,0 +1,28 @@
+require 'concurrent/utility/engine'
+require_relative 'fiber_local_var'
+require_relative 'thread_local_var'
+
+module Concurrent
+  # @!visibility private
+  def self.mutex_owned_per_thread?
+    return false if Concurrent.on_jruby? || Concurrent.on_truffleruby?
+
+    mutex = Mutex.new
+    # Lock the mutex:
+    mutex.synchronize do
+      # Check if the mutex is still owned in a child fiber:
+      Fiber.new { mutex.owned? }.resume
+    end
+  end
+
+  if mutex_owned_per_thread?
+    LockLocalVar = ThreadLocalVar
+  else
+    LockLocalVar = FiberLocalVar
+  end
+
+  # Either {FiberLocalVar} or {ThreadLocalVar} depending on whether Mutex (and Monitor)
+  # are held, respectively, per Fiber or per Thread.
+  class LockLocalVar
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb
similarity index 79%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb
index a033de4cade07..015996b06f04c 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb
@@ -1,16 +1,18 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/safe_initialization'
 
 module Concurrent
 
   # @!macro atomic_boolean
   # @!visibility private
   # @!macro internal_implementation_note
-  class MutexAtomicBoolean < Synchronization::LockableObject
+  class MutexAtomicBoolean
+    extend Concurrent::Synchronization::SafeInitialization
 
     # @!macro atomic_boolean_method_initialize
     def initialize(initial = false)
       super()
-      synchronize { ns_initialize(initial) }
+      @Lock = ::Mutex.new
+      @value = !!initial
     end
 
     # @!macro atomic_boolean_method_value_get
@@ -46,8 +48,12 @@ def make_false
     protected
 
     # @!visibility private
-    def ns_initialize(initial)
-      @value = !!initial
+    def synchronize
+      if @Lock.owned?
+        yield
+      else
+        @Lock.synchronize { yield }
+      end
     end
 
     private
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb
similarity index 83%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb
index 77b91d2dbfb4d..0ca395579fe09 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb
@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/safe_initialization'
 require 'concurrent/utility/native_integer'
 
 module Concurrent
@@ -6,12 +6,14 @@ module Concurrent
   # @!macro atomic_fixnum
   # @!visibility private
   # @!macro internal_implementation_note
-  class MutexAtomicFixnum < Synchronization::LockableObject
+  class MutexAtomicFixnum
+    extend Concurrent::Synchronization::SafeInitialization
 
     # @!macro atomic_fixnum_method_initialize
     def initialize(initial = 0)
       super()
-      synchronize { ns_initialize(initial) }
+      @Lock = ::Mutex.new
+      ns_set(initial)
     end
 
     # @!macro atomic_fixnum_method_value_get
@@ -60,8 +62,12 @@ def update
     protected
 
     # @!visibility private
-    def ns_initialize(initial)
-      ns_set(initial)
+    def synchronize
+      if @Lock.owned?
+        yield
+      else
+        @Lock.synchronize { yield }
+      end
     end
 
     private
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb
similarity index 94%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb
index e99744cef633b..29aa1caa4f296 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb
@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 require 'concurrent/utility/native_integer'
 
 module Concurrent
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb
index b6ac45f9c0e7a..4347289f1ed10 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb
@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 require 'concurrent/utility/native_integer'
 
 module Concurrent
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb
index 246f21aac3138..b26bd17a089ce 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb
@@ -1,7 +1,8 @@
 require 'thread'
 require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/errors'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
+require 'concurrent/synchronization/lock'
 
 module Concurrent
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb
index 92c96fd16dab3..6d72a3a097831 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb
@@ -1,8 +1,10 @@
 require 'thread'
 require 'concurrent/atomic/atomic_reference'
+require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/errors'
-require 'concurrent/synchronization'
-require 'concurrent/atomic/thread_local_var'
+require 'concurrent/synchronization/object'
+require 'concurrent/synchronization/lock'
+require 'concurrent/atomic/lock_local_var'
 
 module Concurrent
 
@@ -109,7 +111,7 @@ def initialize
       @Counter    = AtomicFixnum.new(0)       # single integer which represents lock state
       @ReadQueue  = Synchronization::Lock.new # used to queue waiting readers
       @WriteQueue = Synchronization::Lock.new # used to queue waiting writers
-      @HeldCount  = ThreadLocalVar.new(0)     # indicates # of R & W locks held by this thread
+      @HeldCount  = LockLocalVar.new(0) # indicates # of R & W locks held by this thread
     end
 
     # Execute a block operation within a read lock.
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/semaphore.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/semaphore.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/semaphore.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/semaphore.rb
index cc6a8925bc43e..f0799f0f41a63 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic/semaphore.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/semaphore.rb
@@ -1,5 +1,4 @@
 require 'concurrent/atomic/mutex_semaphore'
-require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -11,7 +10,7 @@ module Concurrent
   #
   #   @param [Fixnum] count the initial count
   #
-  #   @raise [ArgumentError] if `count` is not an integer or is less than zero
+  #   @raise [ArgumentError] if `count` is not an integer
 
   # @!macro semaphore_method_acquire
   #
@@ -21,8 +20,7 @@ module Concurrent
   #
   #   @param [Fixnum] permits Number of permits to acquire
   #
-  #   @raise [ArgumentError] if `permits` is not an integer or is less than
-  #     one
+  #   @raise [ArgumentError] if `permits` is not an integer or is less than zero
   #
   #   @return [nil, BasicObject] Without a block, `nil` is returned. If a block
   #   is given, its return value is returned.
@@ -52,8 +50,7 @@ module Concurrent
   #   @param [Fixnum] timeout the number of seconds to wait for the counter
   #     or `nil` to return immediately
   #
-  #   @raise [ArgumentError] if `permits` is not an integer or is less than
-  #     one
+  #   @raise [ArgumentError] if `permits` is not an integer or is less than zero
   #
   #   @return [true, false, nil, BasicObject] `false` if no permits are
   #     available, `true` when acquired a permit. If a block is given, the
@@ -66,7 +63,7 @@ module Concurrent
   #
   #   @param [Fixnum] permits Number of permits to return to the semaphore.
   #
-  #   @raise [ArgumentError] if `permits` is not a number or is less than one
+  #   @raise [ArgumentError] if `permits` is not a number or is less than zero
   #
   #   @return [nil]
 
@@ -96,8 +93,8 @@ module Concurrent
 
   # @!visibility private
   # @!macro internal_implementation_note
-  SemaphoreImplementation = case
-                            when defined?(JavaSemaphore)
+  SemaphoreImplementation = if Concurrent.on_jruby?
+                              require 'concurrent/utility/native_extension_loader'
                               JavaSemaphore
                             else
                               MutexSemaphore
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb
new file mode 100644
index 0000000000000..3b7e12b5bb97c
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb
@@ -0,0 +1,111 @@
+require 'concurrent/constants'
+require_relative 'locals'
+
+module Concurrent
+
+  # A `ThreadLocalVar` is a variable where the value is different for each thread.
+  # Each variable may have a default value, but when you modify the variable only
+  # the current thread will ever see that change.
+  #
+  # This is similar to Ruby's built-in thread-local variables (`Thread#thread_variable_get`),
+  # but with these major advantages:
+  # * `ThreadLocalVar` has its own identity, it doesn't need a Symbol.
+  # * Each Ruby's built-in thread-local variable leaks some memory forever (it's a Symbol held forever on the thread),
+  #   so it's only OK to create a small amount of them.
+  #   `ThreadLocalVar` has no such issue and it is fine to create many of them.
+  # * Ruby's built-in thread-local variables leak forever the value set on each thread (unless set to nil explicitly).
+  #   `ThreadLocalVar` automatically removes the mapping for each thread once the `ThreadLocalVar` instance is GC'd.
+  #
+  # @!macro thread_safe_variable_comparison
+  #
+  # @example
+  #   v = ThreadLocalVar.new(14)
+  #   v.value #=> 14
+  #   v.value = 2
+  #   v.value #=> 2
+  #
+  # @example
+  #   v = ThreadLocalVar.new(14)
+  #
+  #   t1 = Thread.new do
+  #     v.value #=> 14
+  #     v.value = 1
+  #     v.value #=> 1
+  #   end
+  #
+  #   t2 = Thread.new do
+  #     v.value #=> 14
+  #     v.value = 2
+  #     v.value #=> 2
+  #   end
+  #
+  #   v.value #=> 14
+  class ThreadLocalVar
+    LOCALS = ThreadLocals.new
+
+    # Creates a thread local variable.
+    #
+    # @param [Object] default the default value when otherwise unset
+    # @param [Proc] default_block Optional block that gets called to obtain the
+    #   default value for each thread
+    def initialize(default = nil, &default_block)
+      if default && block_given?
+        raise ArgumentError, "Cannot use both value and block as default value"
+      end
+
+      if block_given?
+        @default_block = default_block
+        @default = nil
+      else
+        @default_block = nil
+        @default = default
+      end
+
+      @index = LOCALS.next_index(self)
+    end
+
+    # Returns the value in the current thread's copy of this thread-local variable.
+    #
+    # @return [Object] the current value
+    def value
+      LOCALS.fetch(@index) { default }
+    end
+
+    # Sets the current thread's copy of this thread-local variable to the specified value.
+    #
+    # @param [Object] value the value to set
+    # @return [Object] the new value
+    def value=(value)
+      LOCALS.set(@index, value)
+    end
+
+    # Bind the given value to thread local storage during
+    # execution of the given block.
+    #
+    # @param [Object] value the value to bind
+    # @yield the operation to be performed with the bound variable
+    # @return [Object] the value
+    def bind(value)
+      if block_given?
+        old_value = self.value
+        self.value = value
+        begin
+          yield
+        ensure
+          self.value = old_value
+        end
+      end
+    end
+
+    protected
+
+    # @!visibility private
+    def default
+      if @default_block
+        self.value = @default_block.call
+      else
+        @default
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic_reference/atomic_direct_update.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic_reference/atomic_direct_update.rb
new file mode 100644
index 0000000000000..5d2d7edd4f540
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic_reference/atomic_direct_update.rb
@@ -0,0 +1,37 @@
+require 'concurrent/errors'
+
+module Concurrent
+
+  # Define update methods that use direct paths
+  #
+  # @!visibility private
+  # @!macro internal_implementation_note
+  module AtomicDirectUpdate
+    def update
+      true until compare_and_set(old_value = get, new_value = yield(old_value))
+      new_value
+    end
+
+    def try_update
+      old_value = get
+      new_value = yield old_value
+
+      return unless compare_and_set old_value, new_value
+
+      new_value
+    end
+
+    def try_update!
+      old_value = get
+      new_value = yield old_value
+      unless compare_and_set(old_value, new_value)
+        if $VERBOSE
+          raise ConcurrentUpdateError, "Update failed"
+        else
+          raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
+        end
+      end
+      new_value
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb
new file mode 100644
index 0000000000000..e5e2a6377d59a
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb
@@ -0,0 +1,67 @@
+require 'concurrent/atomic_reference/atomic_direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+require 'concurrent/synchronization/safe_initialization'
+
+module Concurrent
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  class MutexAtomicReference
+    extend Concurrent::Synchronization::SafeInitialization
+    include AtomicDirectUpdate
+    include AtomicNumericCompareAndSetWrapper
+    alias_method :compare_and_swap, :compare_and_set
+
+    # @!macro atomic_reference_method_initialize
+    def initialize(value = nil)
+      super()
+      @Lock = ::Mutex.new
+      @value = value
+    end
+
+    # @!macro atomic_reference_method_get
+    def get
+      synchronize { @value }
+    end
+    alias_method :value, :get
+
+    # @!macro atomic_reference_method_set
+    def set(new_value)
+      synchronize { @value = new_value }
+    end
+    alias_method :value=, :set
+
+    # @!macro atomic_reference_method_get_and_set
+    def get_and_set(new_value)
+      synchronize do
+        old_value = @value
+        @value = new_value
+        old_value
+      end
+    end
+    alias_method :swap, :get_and_set
+
+    # @!macro atomic_reference_method_compare_and_set
+    def _compare_and_set(old_value, new_value)
+      synchronize do
+        if @value.equal? old_value
+          @value = new_value
+          true
+        else
+          false
+        end
+      end
+    end
+
+    protected
+
+    # @!visibility private
+    def synchronize
+      if @Lock.owned?
+        yield
+      else
+        @Lock.synchronize { yield }
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic_reference/numeric_cas_wrapper.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic_reference/numeric_cas_wrapper.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomic_reference/numeric_cas_wrapper.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomic_reference/numeric_cas_wrapper.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomics.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomics.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/atomics.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/atomics.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb
index 50d52a6237ad6..7c700bd78ac4c 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb
@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
   module Collection
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb
index 3f3f7cccd03b1..bcb6750d41109 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb
@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
   module Collection
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/java_non_concurrent_priority_queue.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/java_non_concurrent_priority_queue.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/java_non_concurrent_priority_queue.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/java_non_concurrent_priority_queue.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb
index d003d3cf7317a..3704410ba0bd4 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb
@@ -1,3 +1,5 @@
+require 'concurrent/synchronization/object'
+
 module Concurrent
 
   # @!macro warn.edge
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb
similarity index 93%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb
index 903c1f2f470ae..e0cf9990c52e0 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb
@@ -9,8 +9,8 @@ module Collection
     # @!visibility private
     class MriMapBackend < NonConcurrentMapBackend
 
-      def initialize(options = nil)
-        super(options)
+      def initialize(options = nil, &default_proc)
+        super(options, &default_proc)
         @write_lock = Mutex.new
       end
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb
similarity index 83%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb
index e7c62e6d19097..ca5fd9b48e37b 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb
@@ -12,8 +12,10 @@ class NonConcurrentMapBackend
       # directly without calling each other. This is important because of the
       # SynchronizedMapBackend which uses a non-reentrant mutex for performance
       # reasons.
-      def initialize(options = nil)
-        @backend = {}
+      def initialize(options = nil, &default_proc)
+        validate_options_hash!(options) if options.kind_of?(::Hash)
+        set_backend(default_proc)
+        @default_proc = default_proc
       end
 
       def [](key)
@@ -55,7 +57,7 @@ def compute_if_present(key)
       end
 
       def compute(key)
-        store_computed_value(key, yield(@backend[key]))
+        store_computed_value(key, yield(get_or_default(key, nil)))
       end
 
       def merge_pair(key, value)
@@ -67,7 +69,7 @@ def merge_pair(key, value)
       end
 
       def get_and_set(key, value)
-        stored_value = @backend[key]
+        stored_value = get_or_default(key, nil)
         @backend[key] = value
         stored_value
       end
@@ -109,13 +111,19 @@ def get_or_default(key, default_value)
         @backend.fetch(key, default_value)
       end
 
-      alias_method :_get, :[]
-      alias_method :_set, :[]=
-      private :_get, :_set
       private
+
+      def set_backend(default_proc)
+        if default_proc
+          @backend = ::Hash.new { |_h, key| default_proc.call(self, key) }
+        else
+          @backend = {}
+        end
+      end
+
       def initialize_copy(other)
         super
-        @backend = {}
+        set_backend(@default_proc)
         self
       end
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/map/synchronized_map_backend.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/map/synchronized_map_backend.rb
new file mode 100644
index 0000000000000..efa161ed9eaa6
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/map/synchronized_map_backend.rb
@@ -0,0 +1,85 @@
+require 'concurrent/collection/map/non_concurrent_map_backend'
+
+module Concurrent
+
+  # @!visibility private
+  module Collection
+
+    # @!visibility private
+    class SynchronizedMapBackend < NonConcurrentMapBackend
+
+      def initialize(*args, &block)
+        super
+
+        # WARNING: Mutex is a non-reentrant lock, so the synchronized methods are
+        # not allowed to call each other.
+        @mutex = Mutex.new
+      end
+
+      def [](key)
+        @mutex.synchronize { super }
+      end
+
+      def []=(key, value)
+        @mutex.synchronize { super }
+      end
+
+      def compute_if_absent(key)
+        @mutex.synchronize { super }
+      end
+
+      def compute_if_present(key)
+        @mutex.synchronize { super }
+      end
+
+      def compute(key)
+        @mutex.synchronize { super }
+      end
+
+      def merge_pair(key, value)
+        @mutex.synchronize { super }
+      end
+
+      def replace_pair(key, old_value, new_value)
+        @mutex.synchronize { super }
+      end
+
+      def replace_if_exists(key, new_value)
+        @mutex.synchronize { super }
+      end
+
+      def get_and_set(key, value)
+        @mutex.synchronize { super }
+      end
+
+      def key?(key)
+        @mutex.synchronize { super }
+      end
+
+      def delete(key)
+        @mutex.synchronize { super }
+      end
+
+      def delete_pair(key, value)
+        @mutex.synchronize { super }
+      end
+
+      def clear
+        @mutex.synchronize { super }
+      end
+
+      def size
+        @mutex.synchronize { super }
+      end
+
+      def get_or_default(key, default_value)
+        @mutex.synchronize { super }
+      end
+
+      private
+      def dupped_backend
+        @mutex.synchronize { super }
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/map/truffleruby_map_backend.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/map/truffleruby_map_backend.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/map/truffleruby_map_backend.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/map/truffleruby_map_backend.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/non_concurrent_priority_queue.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/non_concurrent_priority_queue.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/non_concurrent_priority_queue.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/non_concurrent_priority_queue.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/concern/deprecation.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/concern/deprecation.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/concern/deprecation.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/concern/deprecation.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/concern/dereferenceable.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/concern/dereferenceable.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/concern/dereferenceable.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/concern/dereferenceable.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/concern/logging.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/concern/logging.rb
new file mode 100644
index 0000000000000..568a539ebf0b8
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/concern/logging.rb
@@ -0,0 +1,116 @@
+require 'logger'
+require 'concurrent/atomic/atomic_reference'
+
+module Concurrent
+  module Concern
+
+    # Include where logging is needed
+    #
+    # @!visibility private
+    module Logging
+      include Logger::Severity
+
+      # Logs through {Concurrent.global_logger}, it can be overridden by setting @logger
+      # @param [Integer] level one of Logger::Severity constants
+      # @param [String] progname e.g. a path of an Actor
+      # @param [String, nil] message when nil block is used to generate the message
+      # @yieldreturn [String] a message
+      def log(level, progname, message = nil, &block)
+        logger = if defined?(@logger) && @logger
+                   @logger
+                 else
+                   Concurrent.global_logger
+                 end
+        logger.call level, progname, message, &block
+      rescue => error
+        $stderr.puts "`Concurrent.configuration.logger` failed to log #{[level, progname, message, block]}\n" +
+          "#{error.message} (#{error.class})\n#{error.backtrace.join "\n"}"
+      end
+    end
+  end
+end
+
+module Concurrent
+  extend Concern::Logging
+
+  # @return [Logger] Logger with provided level and output.
+  def self.create_simple_logger(level = Logger::FATAL, output = $stderr)
+    # TODO (pitr-ch 24-Dec-2016): figure out why it had to be replaced, stdlogger was deadlocking
+    lambda do |severity, progname, message = nil, &block|
+      return false if severity < level
+
+      message           = block ? block.call : message
+      formatted_message = case message
+                          when String
+                            message
+                          when Exception
+                            format "%s (%s)\n%s",
+                                   message.message, message.class, (message.backtrace || []).join("\n")
+                          else
+                            message.inspect
+                          end
+
+      output.print format "[%s] %5s -- %s: %s\n",
+                          Time.now.strftime('%Y-%m-%d %H:%M:%S.%L'),
+                          Logger::SEV_LABEL[severity],
+                          progname,
+                          formatted_message
+      true
+    end
+  end
+
+  # Use logger created by #create_simple_logger to log concurrent-ruby messages.
+  def self.use_simple_logger(level = Logger::FATAL, output = $stderr)
+    Concurrent.global_logger = create_simple_logger level, output
+  end
+
+  # @return [Logger] Logger with provided level and output.
+  # @deprecated
+  def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
+    logger           = Logger.new(output)
+    logger.level     = level
+    logger.formatter = lambda do |severity, datetime, progname, msg|
+      formatted_message = case msg
+                          when String
+                            msg
+                          when Exception
+                            format "%s (%s)\n%s",
+                                   msg.message, msg.class, (msg.backtrace || []).join("\n")
+                          else
+                            msg.inspect
+                          end
+      format "[%s] %5s -- %s: %s\n",
+             datetime.strftime('%Y-%m-%d %H:%M:%S.%L'),
+             severity,
+             progname,
+             formatted_message
+    end
+
+    lambda do |loglevel, progname, message = nil, &block|
+      logger.add loglevel, message, progname, &block
+    end
+  end
+
+  # Use logger created by #create_stdlib_logger to log concurrent-ruby messages.
+  # @deprecated
+  def self.use_stdlib_logger(level = Logger::FATAL, output = $stderr)
+    Concurrent.global_logger = create_stdlib_logger level, output
+  end
+
+  # TODO (pitr-ch 27-Dec-2016): remove deadlocking stdlib_logger methods
+
+  # Suppresses all output when used for logging.
+  NULL_LOGGER   = lambda { |level, progname, message = nil, &block| }
+
+  # @!visibility private
+  GLOBAL_LOGGER = AtomicReference.new(create_simple_logger(Logger::WARN))
+  private_constant :GLOBAL_LOGGER
+
+  def self.global_logger
+    GLOBAL_LOGGER.value
+  end
+
+  def self.global_logger=(value)
+    GLOBAL_LOGGER.value = value
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/concern/obligation.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/concern/obligation.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/concern/obligation.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/concern/obligation.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/concern/observable.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/concern/observable.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/concern/observable.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/concern/observable.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/concurrent_ruby.jar b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/concurrent_ruby.jar
new file mode 100644
index 0000000000000..c0d7b155b675c
Binary files /dev/null and b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/concurrent_ruby.jar differ
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/configuration.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/configuration.rb
new file mode 100644
index 0000000000000..5571d39b0cc47
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/configuration.rb
@@ -0,0 +1,105 @@
+require 'thread'
+require 'concurrent/delay'
+require 'concurrent/errors'
+require 'concurrent/concern/deprecation'
+require 'concurrent/executor/immediate_executor'
+require 'concurrent/executor/fixed_thread_pool'
+require 'concurrent/executor/cached_thread_pool'
+require 'concurrent/utility/processor_counter'
+
+module Concurrent
+  extend Concern::Deprecation
+
+  autoload :Options, 'concurrent/options'
+  autoload :TimerSet, 'concurrent/executor/timer_set'
+  autoload :ThreadPoolExecutor, 'concurrent/executor/thread_pool_executor'
+
+  # @!visibility private
+  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor }
+  private_constant :GLOBAL_FAST_EXECUTOR
+
+  # @!visibility private
+  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor }
+  private_constant :GLOBAL_IO_EXECUTOR
+
+  # @!visibility private
+  GLOBAL_TIMER_SET = Delay.new { TimerSet.new }
+  private_constant :GLOBAL_TIMER_SET
+
+  # @!visibility private
+  GLOBAL_IMMEDIATE_EXECUTOR = ImmediateExecutor.new
+  private_constant :GLOBAL_IMMEDIATE_EXECUTOR
+
+  # Disables AtExit handlers including pool auto-termination handlers.
+  # When disabled it will be the application programmer's responsibility
+  # to ensure that the handlers are shutdown properly prior to application
+  # exit by calling `AtExit.run` method.
+  #
+  # @note this option should be needed only because of `at_exit` ordering
+  #   issues which may arise when running some of the testing frameworks.
+  #   E.g. Minitest's test-suite runs itself in `at_exit` callback which
+  #   executes after the pools are already terminated. Then auto termination
+  #   needs to be disabled and called manually after test-suite ends.
+  # @note This method should *never* be called
+  #   from within a gem. It should *only* be used from within the main
+  #   application and even then it should be used only when necessary.
+  # @deprecated Has no effect since it is no longer needed, see https://github.com/ruby-concurrency/concurrent-ruby/pull/841.
+  #
+  def self.disable_at_exit_handlers!
+    deprecated "Method #disable_at_exit_handlers! has no effect since it is no longer needed, see https://github.com/ruby-concurrency/concurrent-ruby/pull/841."
+  end
+
+  # Global thread pool optimized for short, fast *operations*.
+  #
+  # @return [ThreadPoolExecutor] the thread pool
+  def self.global_fast_executor
+    GLOBAL_FAST_EXECUTOR.value!
+  end
+
+  # Global thread pool optimized for long, blocking (IO) *tasks*.
+  #
+  # @return [ThreadPoolExecutor] the thread pool
+  def self.global_io_executor
+    GLOBAL_IO_EXECUTOR.value!
+  end
+
+  def self.global_immediate_executor
+    GLOBAL_IMMEDIATE_EXECUTOR
+  end
+
+  # Global thread pool user for global *timers*.
+  #
+  # @return [Concurrent::TimerSet] the thread pool
+  def self.global_timer_set
+    GLOBAL_TIMER_SET.value!
+  end
+
+  # General access point to global executors.
+  # @param [Symbol, Executor] executor_identifier symbols:
+  #   - :fast - {Concurrent.global_fast_executor}
+  #   - :io - {Concurrent.global_io_executor}
+  #   - :immediate - {Concurrent.global_immediate_executor}
+  # @return [Executor]
+  def self.executor(executor_identifier)
+    Options.executor(executor_identifier)
+  end
+
+  def self.new_fast_executor(opts = {})
+    FixedThreadPool.new(
+        [2, Concurrent.processor_count].max,
+        auto_terminate:  opts.fetch(:auto_terminate, true),
+        idletime:        60, # 1 minute
+        max_queue:       0, # unlimited
+        fallback_policy: :abort, # shouldn't matter -- 0 max queue
+        name:            "fast"
+    )
+  end
+
+  def self.new_io_executor(opts = {})
+    CachedThreadPool.new(
+        auto_terminate:  opts.fetch(:auto_terminate, true),
+        fallback_policy: :abort, # shouldn't matter -- 0 max queue
+        name:            "io"
+    )
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/constants.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/constants.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/constants.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/constants.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/dataflow.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/dataflow.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/dataflow.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/dataflow.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/delay.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/delay.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/delay.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/delay.rb
index 83799d03dd637..923773cbcaf0f 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/delay.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/delay.rb
@@ -1,7 +1,7 @@
 require 'thread'
 require 'concurrent/concern/obligation'
 require 'concurrent/executor/immediate_executor'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
@@ -67,7 +67,7 @@ def initialize(opts = {}, &block)
 
     # Return the value this object represents after applying the options
     # specified by the `#set_deref_options` method. If the delayed operation
-    # raised an exception this method will return nil. The execption object
+    # raised an exception this method will return nil. The exception object
     # can be accessed via the `#reason` method.
     #
     # @param [Numeric] timeout the maximum number of seconds to wait
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/errors.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/errors.rb
new file mode 100644
index 0000000000000..74f1fc3ddab9d
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/errors.rb
@@ -0,0 +1,74 @@
+module Concurrent
+
+  Error = Class.new(StandardError)
+
+  # Raised when errors occur during configuration.
+  ConfigurationError = Class.new(Error)
+
+  # Raised when an asynchronous operation is cancelled before execution.
+  CancelledOperationError = Class.new(Error)
+
+  # Raised when a lifecycle method (such as `stop`) is called in an improper
+  # sequence or when the object is in an inappropriate state.
+  LifecycleError = Class.new(Error)
+
+  # Raised when an attempt is made to violate an immutability guarantee.
+  ImmutabilityError = Class.new(Error)
+
+  # Raised when an operation is attempted which is not legal given the
+  # receiver's current state
+  IllegalOperationError = Class.new(Error)
+
+  # Raised when an object's methods are called when it has not been
+  # properly initialized.
+  InitializationError = Class.new(Error)
+
+  # Raised when an object with a start/stop lifecycle has been started an
+  # excessive number of times. Often used in conjunction with a restart
+  # policy or strategy.
+  MaxRestartFrequencyError = Class.new(Error)
+
+  # Raised when an attempt is made to modify an immutable object
+  # (such as an `IVar`) after its final state has been set.
+  class MultipleAssignmentError < Error
+    attr_reader :inspection_data
+
+    def initialize(message = nil, inspection_data = nil)
+      @inspection_data = inspection_data
+      super message
+    end
+
+    def inspect
+      format '%s %s>', super[0..-2], @inspection_data.inspect
+    end
+  end
+
+  # Raised by an `Executor` when it is unable to process a given task,
+  # possibly because of a reject policy or other internal error.
+  RejectedExecutionError = Class.new(Error)
+
+  # Raised when any finite resource, such as a lock counter, exceeds its
+  # maximum limit/threshold.
+  ResourceLimitError = Class.new(Error)
+
+  # Raised when an operation times out.
+  TimeoutError = Class.new(Error)
+
+  # Aggregates multiple exceptions.
+  class MultipleErrors < Error
+    attr_reader :errors
+
+    def initialize(errors, message = "#{errors.size} errors")
+      @errors = errors
+      super [*message,
+             *errors.map { |e| [format('%s (%s)', e.message, e.class), *e.backtrace] }.flatten(1)
+            ].join("\n")
+    end
+  end
+
+  # @!macro internal_implementation_note
+  class ConcurrentUpdateError < ThreadError
+    # frozen pre-allocated backtrace to speed ConcurrentUpdateError
+    CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/exchanger.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/exchanger.rb
similarity index 99%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/exchanger.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/exchanger.rb
index 5a99550b33a4c..a5405d252283e 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/exchanger.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/exchanger.rb
@@ -289,6 +289,7 @@ def do_exchange(value, timeout)
   end
 
   if Concurrent.on_jruby?
+    require 'concurrent/utility/native_extension_loader'
 
     # @!macro internal_implementation_note
     # @!visibility private
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb
index f3631bf8ef3fa..ac429531bf7bf 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb
@@ -1,7 +1,7 @@
 require 'concurrent/errors'
 require 'concurrent/concern/deprecation'
 require 'concurrent/executor/executor_service'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/cached_thread_pool.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/cached_thread_pool.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/cached_thread_pool.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/cached_thread_pool.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/executor_service.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/executor_service.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/executor_service.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/executor_service.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb
index 4de512a5ff1a1..993c3f1e36670 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb
@@ -39,6 +39,10 @@ module Concurrent
   #   The number of tasks that have been completed by the pool since construction.
   #   @return [Integer] The number of tasks that have been completed by the pool since construction.
 
+  # @!macro thread_pool_executor_method_active_count
+  #   The number of threads that are actively executing tasks.
+  #   @return [Integer] The number of threads that are actively executing tasks.
+
   # @!macro thread_pool_executor_attr_reader_idletime
   #   The number of seconds that a thread may be idle before being reclaimed.
   #   @return [Integer] The number of seconds that a thread may be idle before being reclaimed.
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/immediate_executor.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/immediate_executor.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/immediate_executor.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/immediate_executor.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/indirect_immediate_executor.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/indirect_immediate_executor.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/indirect_immediate_executor.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/indirect_immediate_executor.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/java_executor_service.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/java_executor_service.rb
similarity index 88%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/java_executor_service.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/java_executor_service.rb
index e63e89812eeab..b2bc69a6ea58d 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/java_executor_service.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/java_executor_service.rb
@@ -1,7 +1,7 @@
-if Concurrent.on_jruby?
+require 'concurrent/utility/engine'
 
+if Concurrent.on_jruby?
   require 'concurrent/errors'
-  require 'concurrent/utility/engine'
   require 'concurrent/executor/abstract_executor_service'
 
   module Concurrent
@@ -57,15 +57,11 @@ def ns_running?
       end
 
       def ns_shuttingdown?
-        if @executor.respond_to? :isTerminating
-          @executor.isTerminating
-        else
-          false
-        end
+        @executor.isShutdown && !@executor.isTerminated
       end
 
       def ns_shutdown?
-        @executor.isShutdown || @executor.isTerminated
+        @executor.isTerminated
       end
 
       class Job
@@ -88,10 +84,11 @@ class DaemonThreadFactory
 
       def initialize(daemonize = true)
         @daemonize = daemonize
+        @java_thread_factory = java.util.concurrent.Executors.defaultThreadFactory
       end
 
       def newThread(runnable)
-        thread = java.util.concurrent.Executors.defaultThreadFactory().newThread(runnable)
+        thread = @java_thread_factory.newThread(runnable)
         thread.setDaemon(@daemonize)
         return thread
       end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/java_single_thread_executor.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/java_single_thread_executor.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/java_single_thread_executor.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/java_single_thread_executor.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/java_thread_pool_executor.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/java_thread_pool_executor.rb
similarity index 97%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/java_thread_pool_executor.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/java_thread_pool_executor.rb
index 1213a95fb0986..598a5f91f8822 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/java_thread_pool_executor.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/java_thread_pool_executor.rb
@@ -73,6 +73,11 @@ def completed_task_count
         @executor.getCompletedTaskCount
       end
 
+      # @!macro thread_pool_executor_method_active_count
+      def active_count
+        @executor.getActiveCount
+      end
+
       # @!macro thread_pool_executor_attr_reader_idletime
       def idletime
         @executor.getKeepAliveTime(java.util.concurrent.TimeUnit::SECONDS)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/ruby_single_thread_executor.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/ruby_single_thread_executor.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/ruby_single_thread_executor.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/ruby_single_thread_executor.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb
index 298dd7fed0078..9375acf38402b 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb
@@ -61,6 +61,13 @@ def completed_task_count
       synchronize { @completed_task_count }
     end
 
+    # @!macro thread_pool_executor_method_active_count
+    def active_count
+      synchronize do
+        @pool.length - @ready.length
+      end
+    end
+
     # @!macro executor_service_method_can_overflow_question
     def can_overflow?
       synchronize { ns_limited_queue? }
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/safe_task_executor.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/safe_task_executor.rb
similarity index 94%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/safe_task_executor.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/safe_task_executor.rb
index 17acfd567ce05..f796b8571fa44 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/safe_task_executor.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/safe_task_executor.rb
@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/serial_executor_service.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/serial_executor_service.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/serial_executor_service.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/serial_executor_service.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/serialized_execution.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/serialized_execution.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/serialized_execution.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/serialized_execution.rb
index d314e90616587..4db7c7f0c2135 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/serialized_execution.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/serialized_execution.rb
@@ -1,6 +1,6 @@
 require 'concurrent/errors'
 require 'concurrent/concern/logging'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/serialized_execution_delegator.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/serialized_execution_delegator.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/serialized_execution_delegator.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/serialized_execution_delegator.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb
similarity index 93%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb
index b87fed5e02204..0bc62afd38d20 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/simple_executor_service.rb
@@ -1,5 +1,8 @@
-require 'concurrent/atomics'
+require 'concurrent/atomic/atomic_boolean'
+require 'concurrent/atomic/atomic_fixnum'
+require 'concurrent/atomic/event'
 require 'concurrent/executor/executor_service'
+require 'concurrent/executor/ruby_executor_service'
 
 module Concurrent
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/single_thread_executor.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/single_thread_executor.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/single_thread_executor.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/single_thread_executor.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/thread_pool_executor.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/thread_pool_executor.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/thread_pool_executor.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/thread_pool_executor.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/timer_set.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/timer_set.rb
similarity index 96%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/timer_set.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/timer_set.rb
index 0dfaf1288c190..759dce093a5b6 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executor/timer_set.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executor/timer_set.rb
@@ -3,7 +3,7 @@
 require 'concurrent/collection/non_concurrent_priority_queue'
 require 'concurrent/executor/executor_service'
 require 'concurrent/executor/single_thread_executor'
-
+require 'concurrent/errors'
 require 'concurrent/options'
 
 module Concurrent
@@ -162,7 +162,11 @@ def process_tasks
           # queue now must have the same pop time, or a closer one, as
           # when we peeked).
           task = synchronize { @queue.pop }
-          task.executor.post { task.process_task }
+          begin
+            task.executor.post { task.process_task }
+          rescue RejectedExecutionError
+            # ignore and continue
+          end
         else
           @condition.wait([diff, 60].min)
         end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executors.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executors.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/executors.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/executors.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/future.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/future.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/future.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/future.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/hash.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/hash.rb
new file mode 100644
index 0000000000000..db0208e0174fc
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/hash.rb
@@ -0,0 +1,52 @@
+require 'concurrent/utility/engine'
+require 'concurrent/thread_safe/util'
+
+module Concurrent
+
+  # @!macro concurrent_hash
+  #
+  #   A thread-safe subclass of Hash. This version locks against the object
+  #   itself for every method call, ensuring only one thread can be reading
+  #   or writing at a time. This includes iteration methods like `#each`,
+  #   which takes the lock repeatedly when reading an item.
+  #
+  #   @see http://ruby-doc.org/core/Hash.html Ruby standard library `Hash`
+
+  # @!macro internal_implementation_note
+  HashImplementation = case
+                       when Concurrent.on_cruby?
+                         # Hash is not fully thread-safe on CRuby, see
+                         # https://bugs.ruby-lang.org/issues/19237
+                         # https://github.com/ruby/ruby/commit/ffd52412ab
+                         # https://github.com/ruby-concurrency/concurrent-ruby/issues/929
+                         # So we will need to add synchronization here (similar to Concurrent::Map).
+                         ::Hash
+
+                       when Concurrent.on_jruby?
+                         require 'jruby/synchronized'
+
+                         class JRubyHash < ::Hash
+                           include JRuby::Synchronized
+                         end
+                         JRubyHash
+
+                       when Concurrent.on_truffleruby?
+                         require 'concurrent/thread_safe/util/data_structures'
+
+                         class TruffleRubyHash < ::Hash
+                         end
+
+                         ThreadSafe::Util.make_synchronized_on_truffleruby TruffleRubyHash
+                         TruffleRubyHash
+
+                       else
+                         warn 'Possibly unsupported Ruby implementation'
+                         ::Hash
+                       end
+  private_constant :HashImplementation
+
+  # @!macro concurrent_hash
+  class Hash < HashImplementation
+  end
+
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/immutable_struct.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/immutable_struct.rb
similarity index 97%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/immutable_struct.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/immutable_struct.rb
index d2755951f5b27..48462e8375b87 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/immutable_struct.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/immutable_struct.rb
@@ -1,5 +1,5 @@
 require 'concurrent/synchronization/abstract_struct'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/ivar.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/ivar.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/ivar.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/ivar.rb
index 2a724db4674f3..4165038f8945b 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/ivar.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/ivar.rb
@@ -3,7 +3,8 @@
 require 'concurrent/collection/copy_on_write_observer_set'
 require 'concurrent/concern/obligation'
 require 'concurrent/concern/observable'
-require 'concurrent/synchronization'
+require 'concurrent/executor/safe_task_executor'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/map.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/map.rb
similarity index 82%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/map.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/map.rb
index 808757fa4ba89..601e365042570 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/map.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/map.rb
@@ -1,6 +1,5 @@
 require 'thread'
 require 'concurrent/constants'
-require 'concurrent/synchronization'
 require 'concurrent/utility/engine'
 
 module Concurrent
@@ -10,17 +9,20 @@ module Collection
     # @!visibility private
     MapImplementation = case
                         when Concurrent.on_jruby?
+                          require 'concurrent/utility/native_extension_loader'
                           # noinspection RubyResolve
                           JRubyMapBackend
                         when Concurrent.on_cruby?
                           require 'concurrent/collection/map/mri_map_backend'
                           MriMapBackend
-                        when Concurrent.on_truffleruby? && defined?(::TruffleRuby::ConcurrentMap)
-                          require 'concurrent/collection/map/truffleruby_map_backend'
-                          TruffleRubyMapBackend
-                        when Concurrent.on_truffleruby? || Concurrent.on_rbx?
-                          require 'concurrent/collection/map/atomic_reference_map_backend'
-                          AtomicReferenceMapBackend
+                        when Concurrent.on_truffleruby?
+                          if defined?(::TruffleRuby::ConcurrentMap)
+                            require 'concurrent/collection/map/truffleruby_map_backend'
+                            TruffleRubyMapBackend
+                          else
+                            require 'concurrent/collection/map/synchronized_map_backend'
+                            SynchronizedMapBackend
+                          end
                         else
                           warn 'Concurrent::Map: unsupported Ruby engine, using a fully synchronized Concurrent::Map implementation'
                           require 'concurrent/collection/map/synchronized_map_backend'
@@ -44,6 +46,12 @@ class Map < Collection::MapImplementation
     #   @note Atomic methods taking a block do not allow the `self` instance
     #     to be used within the block. Doing so will cause a deadlock.
 
+    # @!method []=(key, value)
+    #   Set a value with key
+    #   @param [Object] key
+    #   @param [Object] value
+    #   @return [Object] the new value
+
     # @!method compute_if_absent(key)
     #   Compute and store new value for key if the key is absent.
     #   @param [Object] key
@@ -117,41 +125,38 @@ class Map < Collection::MapImplementation
     #   @return [true, false] true if deleted
     #   @!macro map.atomic_method
 
-    #
-    def initialize(options = nil, &block)
-      if options.kind_of?(::Hash)
-        validate_options_hash!(options)
-      else
-        options = nil
-      end
+    # NonConcurrentMapBackend handles default_proc natively
+    unless defined?(Collection::NonConcurrentMapBackend) and self < Collection::NonConcurrentMapBackend
 
-      super(options)
-      @default_proc = block
-    end
+      # @param [Hash, nil] options options to set the :initial_capacity or :load_factor. Ignored on some Rubies.
+      # @param [Proc] default_proc Optional block to compute the default value if the key is not set, like `Hash#default_proc`
+      def initialize(options = nil, &default_proc)
+        if options.kind_of?(::Hash)
+          validate_options_hash!(options)
+        else
+          options = nil
+        end
 
-    # Get a value with key
-    # @param [Object] key
-    # @return [Object] the value
-    def [](key)
-      if value = super # non-falsy value is an existing mapping, return it right away
-        value
-        # re-check is done with get_or_default(key, NULL) instead of a simple !key?(key) in order to avoid a race condition, whereby by the time the current thread gets to the key?(key) call
-        # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrent +nil+ value
-        # would be returned)
-        # note: nil == value check is not technically necessary
-      elsif @default_proc && nil == value && NULL == (value = get_or_default(key, NULL))
-        @default_proc.call(self, key)
-      else
-        value
+        super(options)
+        @default_proc = default_proc
       end
-    end
 
-    # Set a value with key
-    # @param [Object] key
-    # @param [Object] value
-    # @return [Object] the new value
-    def []=(key, value)
-      super
+      # Get a value with key
+      # @param [Object] key
+      # @return [Object] the value
+      def [](key)
+        if value = super # non-falsy value is an existing mapping, return it right away
+          value
+          # re-check is done with get_or_default(key, NULL) instead of a simple !key?(key) in order to avoid a race condition, whereby by the time the current thread gets to the key?(key) call
+          # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrent +nil+ value
+          # would be returned)
+          # note: nil == value check is not technically necessary
+        elsif @default_proc && nil == value && NULL == (value = get_or_default(key, NULL))
+          @default_proc.call(self, key)
+        else
+          value
+        end
+      end
     end
 
     alias_method :get, :[]
@@ -197,7 +202,6 @@ def fetch(key, default_value = NULL)
     # @yieldparam key [Object]
     # @yieldreturn [Object] default value
     # @return [Object] the value or default value
-    # @!macro map.atomic_method_with_block
     def fetch_or_store(key, default_value = NULL)
       fetch(key) do
         put(key, block_given? ? yield(key) : (NULL == default_value ? raise_fetch_no_key : default_value))
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/maybe.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/maybe.rb
similarity index 99%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/maybe.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/maybe.rb
index 7ba3d3ebb56cb..317c82b86fa2a 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/maybe.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/maybe.rb
@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
 
 module Concurrent
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/mutable_struct.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/mutable_struct.rb
similarity index 99%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/mutable_struct.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/mutable_struct.rb
index 55361e753f527..5d0e9b9af59e0 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/mutable_struct.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/mutable_struct.rb
@@ -1,5 +1,5 @@
 require 'concurrent/synchronization/abstract_struct'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/mvar.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/mvar.rb
similarity index 99%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/mvar.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/mvar.rb
index 9034711bf559d..dfc41950cf85f 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/mvar.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/mvar.rb
@@ -1,5 +1,5 @@
 require 'concurrent/concern/dereferenceable'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
 
 module Concurrent
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/options.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/options.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/options.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/options.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/promise.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/promise.rb
similarity index 99%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/promise.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/promise.rb
index e91779173dae9..ccc47dd628c8d 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/promise.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/promise.rb
@@ -66,7 +66,7 @@ module Concurrent
   # Start by requiring promises
   #
   # ```ruby
-  # require 'concurrent'
+  # require 'concurrent/promise'
   # ```
   #
   # Then create one
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/promises.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/promises.rb
similarity index 96%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/promises.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/promises.rb
index 76af4d5963dac..c5df8fe9cb9fd 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/promises.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/promises.rb
@@ -1,9 +1,11 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
 require 'concurrent/atomic/atomic_boolean'
 require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/collection/lock_free_stack'
+require 'concurrent/configuration'
 require 'concurrent/errors'
 require 'concurrent/re_include'
+require 'concurrent/utility/monotonic_time'
 
 module Concurrent
 
@@ -21,7 +23,7 @@ module Promises
     #
     # @!macro promises.param.args
     #   @param [Object] args arguments which are passed to the task when it's executed.
-    #     (It might be prepended with other arguments, see the @yeild section).
+    #     (It might be prepended with other arguments, see the @yield section).
     #
     # @!macro promises.shortcut.on
     #   Shortcut of {#$0_on} with default `:io` executor supplied.
@@ -62,8 +64,8 @@ def resolvable_event
         resolvable_event_on default_executor
       end
 
-      # Created resolvable event, user is responsible for resolving the event once by
-      # {Promises::ResolvableEvent#resolve}.
+      # Creates a resolvable event, user is responsible for resolving the event once
+      # by calling {Promises::ResolvableEvent#resolve}.
       #
       # @!macro promises.param.default_executor
       # @return [ResolvableEvent]
@@ -93,7 +95,7 @@ def future(*args, &task)
         future_on(default_executor, *args, &task)
       end
 
-      # Constructs new Future which will be resolved after block is evaluated on default executor.
+      # Constructs a new Future which will be resolved after block is evaluated on default executor.
       # Evaluation begins immediately.
       #
       # @!macro promises.param.default_executor
@@ -105,7 +107,7 @@ def future_on(default_executor, *args, &task)
         ImmediateEventPromise.new(default_executor).future.then(*args, &task)
       end
 
-      # Creates resolved future with will be either fulfilled with the given value or rejection with
+      # Creates a resolved future with will be either fulfilled with the given value or rejected with
       # the given reason.
       #
       # @param [true, false] fulfilled
@@ -117,7 +119,7 @@ def resolved_future(fulfilled, value, reason, default_executor = self.default_ex
         ImmediateFuturePromise.new(default_executor, fulfilled, value, reason).future
       end
 
-      # Creates resolved future with will be fulfilled with the given value.
+      # Creates a resolved future which will be fulfilled with the given value.
       #
       # @!macro promises.param.default_executor
       # @param [Object] value
@@ -126,7 +128,7 @@ def fulfilled_future(value, default_executor = self.default_executor)
         resolved_future true, value, nil, default_executor
       end
 
-      # Creates resolved future with will be rejected with the given reason.
+      # Creates a resolved future which will be rejected with the given reason.
       #
       # @!macro promises.param.default_executor
       # @param [Object] reason
@@ -189,7 +191,7 @@ def delay(*args, &task)
         delay_on default_executor, *args, &task
       end
 
-      # Creates new event or future which is resolved only after it is touched,
+      # Creates a new event or future which is resolved only after it is touched,
       # see {Concurrent::AbstractEventFuture#touch}.
       #
       # @!macro promises.param.default_executor
@@ -213,7 +215,7 @@ def schedule(intended_time, *args, &task)
         schedule_on default_executor, intended_time, *args, &task
       end
 
-      # Creates new event or future which is resolved in intended_time.
+      # Creates a new event or future which is resolved in intended_time.
       #
       # @!macro promises.param.default_executor
       # @!macro promises.param.intended_time
@@ -239,8 +241,8 @@ def zip_futures(*futures_and_or_events)
         zip_futures_on default_executor, *futures_and_or_events
       end
 
-      # Creates new future which is resolved after all futures_and_or_events are resolved.
-      # Its value is array of zipped future values. Its reason is array of reasons for rejection.
+      # Creates a new future which is resolved after all futures_and_or_events are resolved.
+      # Its value is an array of zipped future values. Its reason is an array of reasons for rejection.
       # If there is an error it rejects.
       # @!macro promises.event-conversion
       #   If event is supplied, which does not have value and can be only resolved, it's
@@ -261,7 +263,7 @@ def zip_events(*futures_and_or_events)
         zip_events_on default_executor, *futures_and_or_events
       end
 
-      # Creates new event which is resolved after all futures_and_or_events are resolved.
+      # Creates a new event which is resolved after all futures_and_or_events are resolved.
       # (Future is resolved when fulfilled or rejected.)
       #
       # @!macro promises.param.default_executor
@@ -279,8 +281,8 @@ def any_resolved_future(*futures_and_or_events)
 
       alias_method :any, :any_resolved_future
 
-      # Creates new future which is resolved after first futures_and_or_events is resolved.
-      # Its result equals result of the first resolved future.
+      # Creates a new future which is resolved after the first futures_and_or_events is resolved.
+      # Its result equals the result of the first resolved future.
       # @!macro promises.any-touch
       #   If resolved it does not propagate {Concurrent::AbstractEventFuture#touch}, leaving delayed
       #   futures un-executed if they are not required any more.
@@ -299,9 +301,9 @@ def any_fulfilled_future(*futures_and_or_events)
         any_fulfilled_future_on default_executor, *futures_and_or_events
       end
 
-      # Creates new future which is resolved after first of futures_and_or_events is fulfilled.
-      # Its result equals result of the first resolved future or if all futures_and_or_events reject,
-      # it has reason of the last resolved future.
+      # Creates a new future which is resolved after the first futures_and_or_events is fulfilled.
+      # Its result equals the result of the first resolved future or if all futures_and_or_events reject,
+      # it has reason of the last rejected future.
       # @!macro promises.any-touch
       # @!macro promises.event-conversion
       #
@@ -313,12 +315,12 @@ def any_fulfilled_future_on(default_executor, *futures_and_or_events)
       end
 
       # @!macro promises.shortcut.on
-      # @return [Future]
+      # @return [Event]
       def any_event(*futures_and_or_events)
         any_event_on default_executor, *futures_and_or_events
       end
 
-      # Creates new event which becomes resolved after first of the futures_and_or_events resolves.
+      # Creates a new event which becomes resolved after the first futures_and_or_events resolves.
       # @!macro promises.any-touch
       #
       # @!macro promises.param.default_executor
@@ -610,7 +612,7 @@ def chain(*args, &task)
       #   @yieldparam [Object] value
       #   @yieldparam [Object] reason
       def chain_on(executor, *args, &task)
-        ChainPromise.new_blocked_by1(self, @DefaultExecutor, executor, args, &task).future
+        ChainPromise.new_blocked_by1(self, executor, executor, args, &task).future
       end
 
       # @return [String] Short string representation.
@@ -771,8 +773,17 @@ def wait_until_resolved(timeout)
         @Lock.synchronize do
           @Waiters.increment
           begin
-            unless resolved?
-              @Condition.wait @Lock, timeout
+            if timeout
+              start = Concurrent.monotonic_time
+              until resolved?
+                break if @Condition.wait(@Lock, timeout) == nil # nil means timeout
+                timeout -= (Concurrent.monotonic_time - start)
+                break if timeout <= 0
+              end
+            else
+              until resolved?
+                @Condition.wait(@Lock, timeout)
+              end
             end
           ensure
             # JRuby may raise ConcurrencyError
@@ -892,7 +903,7 @@ def with_default_executor(executor)
       private
 
       def rejected_resolution(raise_on_reassign, state)
-        Concurrent::MultipleAssignmentError.new('Event can be resolved only once') if raise_on_reassign
+        raise Concurrent::MultipleAssignmentError.new('Event can be resolved only once') if raise_on_reassign
         return false
       end
 
@@ -1033,7 +1044,7 @@ def then(*args, &task)
       # @return [Future]
       # @yield [value, *args] to the task.
       def then_on(executor, *args, &task)
-        ThenPromise.new_blocked_by1(self, @DefaultExecutor, executor, args, &task).future
+        ThenPromise.new_blocked_by1(self, executor, executor, args, &task).future
       end
 
       # @!macro promises.shortcut.on
@@ -1051,7 +1062,7 @@ def rescue(*args, &task)
       # @return [Future]
       # @yield [reason, *args] to the task.
       def rescue_on(executor, *args, &task)
-        RescuePromise.new_blocked_by1(self, @DefaultExecutor, executor, args, &task).future
+        RescuePromise.new_blocked_by1(self, executor, executor, args, &task).future
       end
 
       # @!macro promises.method.zip
@@ -1298,7 +1309,7 @@ class ResolvableEvent < Event
 
       # @!macro promise.param.raise_on_reassign
       #   @param [Boolean] raise_on_reassign should method raise exception if already resolved
-      #   @return [self, false] false is returner when raise_on_reassign is false and the receiver
+      #   @return [self, false] false is returned when raise_on_reassign is false and the receiver
       #     is already resolved.
       #
 
@@ -2074,8 +2085,8 @@ class AnyFulfilledFuturePromise < AnyResolvedFuturePromise
 
       private
 
-      def resolvable?(countdown, future, index)
-        future.fulfilled? ||
+      def resolvable?(countdown, event_or_future, index)
+        (event_or_future.is_a?(Event) ? event_or_future.resolved? : event_or_future.fulfilled?) ||
             # inlined super from BlockedPromise
             countdown.zero?
       end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/re_include.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/re_include.rb
similarity index 97%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/re_include.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/re_include.rb
index 516d58cae13cc..600bc6a53568c 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/re_include.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/re_include.rb
@@ -31,6 +31,8 @@ module Concurrent
   #
   #   C1.new.respond_to? :a # => false
   #   C2.new.respond_to? :a # => true
+  #
+  # @!visibility private
   module ReInclude
     # @!visibility private
     def included(base)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/scheduled_task.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/scheduled_task.rb
similarity index 99%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/scheduled_task.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/scheduled_task.rb
index 96c8272178444..429fc0683c6f2 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/scheduled_task.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/scheduled_task.rb
@@ -57,7 +57,7 @@ module Concurrent
   #
   # @example Basic usage
   #
-  #   require 'concurrent'
+  #   require 'concurrent/scheduled_task'
   #   require 'csv'
   #   require 'open-uri'
   #
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/set.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/set.rb
similarity index 87%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/set.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/set.rb
index 3bf0c895c18d6..eee4effdfd2d6 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/set.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/set.rb
@@ -42,16 +42,6 @@ class JRubySet < ::Set
 
                         JRubySet
 
-                      when Concurrent.on_rbx?
-                        require 'monitor'
-                        require 'concurrent/thread_safe/util/data_structures'
-
-                        class RbxSet < ::Set
-                        end
-
-                        ThreadSafe::Util.make_synchronized_on_rbx RbxSet
-                        RbxSet
-
                       when Concurrent.on_truffleruby?
                         require 'concurrent/thread_safe/util/data_structures'
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/settable_struct.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/settable_struct.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/settable_struct.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/settable_struct.rb
index 00123523cc799..99b85619fd370 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/settable_struct.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/settable_struct.rb
@@ -1,6 +1,6 @@
-require 'concurrent/synchronization/abstract_struct'
 require 'concurrent/errors'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/abstract_struct'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization.rb
new file mode 100644
index 0000000000000..6d8cf4bd584d4
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization.rb
@@ -0,0 +1,13 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
+require 'concurrent/synchronization/object'
+require 'concurrent/synchronization/lockable_object'
+require 'concurrent/synchronization/condition'
+require 'concurrent/synchronization/lock'
+
+module Concurrent
+  # @!visibility private
+  module Synchronization
+  end
+end
+
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/abstract_lockable_object.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/abstract_lockable_object.rb
similarity index 93%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/abstract_lockable_object.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/abstract_lockable_object.rb
index bc12603364500..d9050b312fd45 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/abstract_lockable_object.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/abstract_lockable_object.rb
@@ -1,3 +1,7 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+require 'concurrent/utility/monotonic_time'
+require 'concurrent/synchronization/object'
+
 module Concurrent
   module Synchronization
 
@@ -34,7 +38,7 @@ def ns_wait_until(timeout = nil, &condition)
         if timeout
           wait_until = Concurrent.monotonic_time + timeout
           loop do
-            now              = Concurrent.monotonic_time
+            now = Concurrent.monotonic_time
             condition_result = condition.call
             return condition_result if now >= wait_until || condition_result
             ns_wait wait_until - now
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/abstract_object.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/abstract_object.rb
similarity index 80%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/abstract_object.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/abstract_object.rb
index 532388b2b8e5a..7cd2decf99ca5 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/abstract_object.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/abstract_object.rb
@@ -4,10 +4,8 @@ module Synchronization
     # @!visibility private
     # @!macro internal_implementation_note
     class AbstractObject
-
-      # @abstract has to be implemented based on Ruby runtime
       def initialize
-        raise NotImplementedError
+        # nothing to do
       end
 
       # @!visibility private
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/condition.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/condition.rb
similarity index 96%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/condition.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/condition.rb
index f704b81ee6db2..5daa68be8ab54 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/condition.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/condition.rb
@@ -1,3 +1,5 @@
+require 'concurrent/synchronization/lockable_object'
+
 module Concurrent
   module Synchronization
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/full_memory_barrier.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/full_memory_barrier.rb
new file mode 100644
index 0000000000000..139e08d854e01
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/full_memory_barrier.rb
@@ -0,0 +1,29 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
+module Concurrent
+  module Synchronization
+    case
+    when Concurrent.on_cruby?
+      def self.full_memory_barrier
+        # relying on undocumented behavior of CRuby, GVL acquire has lock which ensures visibility of ivars
+        # https://github.com/ruby/ruby/blob/ruby_2_2/thread_pthread.c#L204-L211
+      end
+
+    when Concurrent.on_jruby?
+      require 'concurrent/utility/native_extension_loader'
+      def self.full_memory_barrier
+        JRubyAttrVolatile.full_memory_barrier
+      end
+
+    when Concurrent.on_truffleruby?
+      def self.full_memory_barrier
+        TruffleRuby.full_memory_barrier
+      end
+
+    else
+      warn 'Possibly unsupported Ruby implementation'
+      def self.full_memory_barrier
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/jruby_lockable_object.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/jruby_lockable_object.rb
new file mode 100644
index 0000000000000..76930461bdb8c
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/jruby_lockable_object.rb
@@ -0,0 +1,15 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
+module Concurrent
+  module Synchronization
+
+    if Concurrent.on_jruby?
+
+      # @!visibility private
+      # @!macro internal_implementation_note
+      class JRubyLockableObject < AbstractLockableObject
+
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/lock.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/lock.rb
new file mode 100644
index 0000000000000..f90e0b5f76872
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/lock.rb
@@ -0,0 +1,38 @@
+require 'concurrent/synchronization/lockable_object'
+
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    # TODO (pitr-ch 04-Dec-2016): should be in edge
+    class Lock < LockableObject
+      # TODO use JavaReentrantLock on JRuby
+
+      public :synchronize
+
+      def wait(timeout = nil)
+        synchronize { ns_wait(timeout) }
+      end
+
+      public :ns_wait
+
+      def wait_until(timeout = nil, &condition)
+        synchronize { ns_wait_until(timeout, &condition) }
+      end
+
+      public :ns_wait_until
+
+      def signal
+        synchronize { ns_signal }
+      end
+
+      public :ns_signal
+
+      def broadcast
+        synchronize { ns_broadcast }
+      end
+
+      public :ns_broadcast
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/lockable_object.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/lockable_object.rb
similarity index 92%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/lockable_object.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/lockable_object.rb
index ae28e5bc8e839..08d2ff66cd824 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/lockable_object.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/lockable_object.rb
@@ -1,3 +1,8 @@
+require 'concurrent/utility/engine'
+require 'concurrent/synchronization/abstract_lockable_object'
+require 'concurrent/synchronization/mutex_lockable_object'
+require 'concurrent/synchronization/jruby_lockable_object'
+
 module Concurrent
   module Synchronization
 
@@ -8,8 +13,6 @@ module Synchronization
                                      MutexLockableObject
                                    when Concurrent.on_jruby?
                                      JRubyLockableObject
-                                   when Concurrent.on_rbx?
-                                     RbxLockableObject
                                    when Concurrent.on_truffleruby?
                                      MutexLockableObject
                                    else
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb
similarity index 91%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb
index f17ea507aadab..acc9745a2e292 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb
@@ -1,5 +1,6 @@
+require 'concurrent/synchronization/abstract_lockable_object'
+
 module Concurrent
-  # noinspection RubyInstanceVariableNamingConvention
   module Synchronization
 
     # @!visibility private
@@ -26,8 +27,8 @@ class MutexLockableObject < AbstractLockableObject
 
       safe_initialization!
 
-      def initialize(*defaults)
-        super(*defaults)
+      def initialize
+        super()
         @__Lock__      = ::Mutex.new
         @__Condition__ = ::ConditionVariable.new
       end
@@ -61,8 +62,8 @@ class MonitorLockableObject < AbstractLockableObject
 
       safe_initialization!
 
-      def initialize(*defaults)
-        super(*defaults)
+      def initialize
+        super()
         @__Lock__      = ::Monitor.new
         @__Condition__ = @__Lock__.new_cond
       end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/object.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/object.rb
new file mode 100644
index 0000000000000..e839c9f18890f
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/object.rb
@@ -0,0 +1,151 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
+require 'concurrent/synchronization/safe_initialization'
+require 'concurrent/synchronization/volatile'
+require 'concurrent/atomic/atomic_reference'
+
+module Concurrent
+  module Synchronization
+
+    # Abstract object providing final, volatile, ans CAS extensions to build other concurrent abstractions.
+    # - final instance variables see {Object.safe_initialization!}
+    # - volatile instance variables see {Object.attr_volatile}
+    # - volatile instance variables see {Object.attr_atomic}
+    # @!visibility private
+    class Object < AbstractObject
+      include Volatile
+
+      # TODO make it a module if possible
+
+      # @!method self.attr_volatile(*names)
+      #   Creates methods for reading and writing (as `attr_accessor` does) to a instance variable with
+      #   volatile (Java) semantic. The instance variable should be accessed only through generated methods.
+      #
+      #   @param [::Array<Symbol>] names of the instance variables to be volatile
+      #   @return [::Array<Symbol>] names of defined method names
+
+      # Has to be called by children.
+      def initialize
+        super
+        __initialize_atomic_fields__
+      end
+
+      def self.safe_initialization!
+        extend SafeInitialization unless safe_initialization?
+      end
+
+      def self.safe_initialization?
+        self.singleton_class < SafeInitialization
+      end
+
+      # For testing purposes, quite slow. Injects assert code to new method which will raise if class instance contains
+      # any instance variables with CamelCase names and isn't {.safe_initialization?}.
+      # @raise when offend found
+      # @return [true]
+      def self.ensure_safe_initialization_when_final_fields_are_present
+        Object.class_eval do
+          def self.new(*args, &block)
+            object = super(*args, &block)
+          ensure
+            has_final_field = object.instance_variables.any? { |v| v.to_s =~ /^@[A-Z]/ }
+            if has_final_field && !safe_initialization?
+              raise "there was an instance of #{object.class} with final field but not marked with safe_initialization!"
+            end
+          end
+        end
+        true
+      end
+
+      # Creates methods for reading and writing to a instance variable with
+      # volatile (Java) semantic as {.attr_volatile} does.
+      # The instance variable should be accessed oly through generated methods.
+      # This method generates following methods: `value`, `value=(new_value) #=> new_value`,
+      # `swap_value(new_value) #=> old_value`,
+      # `compare_and_set_value(expected, value) #=> true || false`, `update_value(&block)`.
+      # @param [::Array<Symbol>] names of the instance variables to be volatile with CAS.
+      # @return [::Array<Symbol>] names of defined method names.
+      # @!macro attr_atomic
+      #   @!method $1
+      #     @return [Object] The $1.
+      #   @!method $1=(new_$1)
+      #     Set the $1.
+      #     @return [Object] new_$1.
+      #   @!method swap_$1(new_$1)
+      #     Set the $1 to new_$1 and return the old $1.
+      #     @return [Object] old $1
+      #   @!method compare_and_set_$1(expected_$1, new_$1)
+      #     Sets the $1 to new_$1 if the current $1 is expected_$1
+      #     @return [true, false]
+      #   @!method update_$1(&block)
+      #     Updates the $1 using the block.
+      #     @yield [Object] Calculate a new $1 using given (old) $1
+      #     @yieldparam [Object] old $1
+      #     @return [Object] new $1
+      def self.attr_atomic(*names)
+        @__atomic_fields__ ||= []
+        @__atomic_fields__ += names
+        safe_initialization!
+        define_initialize_atomic_fields
+
+        names.each do |name|
+          ivar = :"@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }}"
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              #{ivar}.get
+            end
+
+            def #{name}=(value)
+              #{ivar}.set value
+            end
+
+            def swap_#{name}(value)
+              #{ivar}.swap value
+            end
+
+            def compare_and_set_#{name}(expected, value)
+              #{ivar}.compare_and_set expected, value
+            end
+
+            def update_#{name}(&block)
+              #{ivar}.update(&block)
+            end
+          RUBY
+        end
+        names.flat_map { |n| [n, :"#{n}=", :"swap_#{n}", :"compare_and_set_#{n}", :"update_#{n}"] }
+      end
+
+      # @param [true, false] inherited should inherited volatile with CAS fields be returned?
+      # @return [::Array<Symbol>] Returns defined volatile with CAS fields on this class.
+      def self.atomic_attributes(inherited = true)
+        @__atomic_fields__ ||= []
+        ((superclass.atomic_attributes if superclass.respond_to?(:atomic_attributes) && inherited) || []) + @__atomic_fields__
+      end
+
+      # @return [true, false] is the attribute with name atomic?
+      def self.atomic_attribute?(name)
+        atomic_attributes.include? name
+      end
+
+      private
+
+      def self.define_initialize_atomic_fields
+        assignments = @__atomic_fields__.map do |name|
+          "@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }} = Concurrent::AtomicReference.new(nil)"
+        end.join("\n")
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def __initialize_atomic_fields__
+            super
+            #{assignments}
+          end
+        RUBY
+      end
+
+      private_class_method :define_initialize_atomic_fields
+
+      def __initialize_atomic_fields__
+      end
+
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/safe_initialization.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/safe_initialization.rb
new file mode 100644
index 0000000000000..f785e35229fa3
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/safe_initialization.rb
@@ -0,0 +1,36 @@
+require 'concurrent/synchronization/full_memory_barrier'
+
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    #
+    # By extending this module, a class and all its children are marked to be constructed safely. Meaning that
+    # all writes (ivar initializations) are made visible to all readers of newly constructed object. It ensures
+    # same behaviour as Java's final fields.
+    #
+    # Due to using Kernel#extend, the module is not included again if already present in the ancestors,
+    # which avoids extra overhead.
+    #
+    # @example
+    #   class AClass < Concurrent::Synchronization::Object
+    #     extend Concurrent::Synchronization::SafeInitialization
+    #
+    #     def initialize
+    #       @AFinalValue = 'value' # published safely, #foo will never return nil
+    #     end
+    #
+    #     def foo
+    #       @AFinalValue
+    #     end
+    #   end
+    module SafeInitialization
+      def new(*args, &block)
+        super(*args, &block)
+      ensure
+        Concurrent::Synchronization.full_memory_barrier
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/volatile.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/volatile.rb
new file mode 100644
index 0000000000000..46e8ba6a48ca1
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/synchronization/volatile.rb
@@ -0,0 +1,101 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+require 'concurrent/utility/engine'
+require 'concurrent/synchronization/full_memory_barrier'
+
+module Concurrent
+  module Synchronization
+
+    # Volatile adds the attr_volatile class method when included.
+    #
+    # @example
+    #   class Foo
+    #     include Concurrent::Synchronization::Volatile
+    #
+    #     attr_volatile :bar
+    #
+    #     def initialize
+    #       self.bar = 1
+    #     end
+    #   end
+    #
+    #  foo = Foo.new
+    #  foo.bar
+    #  => 1
+    #  foo.bar = 2
+    #  => 2
+    #
+    # @!visibility private
+    module Volatile
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def full_memory_barrier
+        Synchronization.full_memory_barrier
+      end
+
+      module ClassMethods
+        if Concurrent.on_cruby?
+          def attr_volatile(*names)
+            names.each do |name|
+              ivar = :"@volatile_#{name}"
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{name}
+                  #{ivar}
+                end
+
+                def #{name}=(value)
+                  #{ivar} = value
+                end
+              RUBY
+            end
+            names.map { |n| [n, :"#{n}="] }.flatten
+          end
+
+        elsif Concurrent.on_jruby?
+          def attr_volatile(*names)
+            names.each do |name|
+              ivar = :"@volatile_#{name}"
+
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{name}
+                  ::Concurrent::Synchronization::JRubyAttrVolatile.instance_variable_get_volatile(self, :#{ivar})
+                end
+
+                def #{name}=(value)
+                  ::Concurrent::Synchronization::JRubyAttrVolatile.instance_variable_set_volatile(self, :#{ivar}, value)
+                end
+              RUBY
+
+            end
+            names.map { |n| [n, :"#{n}="] }.flatten
+          end
+
+        else
+          warn 'Possibly unsupported Ruby implementation' unless Concurrent.on_truffleruby?
+
+          def attr_volatile(*names)
+            names.each do |name|
+              ivar = :"@volatile_#{name}"
+
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{name}
+                  ::Concurrent::Synchronization.full_memory_barrier
+                  #{ivar}
+                end
+
+                def #{name}=(value)
+                  #{ivar} = value
+                  ::Concurrent::Synchronization.full_memory_barrier
+                end
+              RUBY
+            end
+
+            names.map { |n| [n, :"#{n}="] }.flatten
+          end
+        end
+      end
+
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb
new file mode 100644
index 0000000000000..019d84382d609
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb
@@ -0,0 +1,47 @@
+require 'delegate'
+require 'monitor'
+
+module Concurrent
+  # This class provides a trivial way to synchronize all calls to a given object
+  # by wrapping it with a `Delegator` that performs `Monitor#enter/exit` calls
+  # around the delegated `#send`. Example:
+  #
+  #   array = [] # not thread-safe on many impls
+  #   array = SynchronizedDelegator.new([]) # thread-safe
+  #
+  # A simple `Monitor` provides a very coarse-grained way to synchronize a given
+  # object, in that it will cause synchronization for methods that have no need
+  # for it, but this is a trivial way to get thread-safety where none may exist
+  # currently on some implementations.
+  #
+  # This class is currently being considered for inclusion into stdlib, via
+  # https://bugs.ruby-lang.org/issues/8556
+  #
+  # @!visibility private
+  class SynchronizedDelegator < SimpleDelegator
+    def setup
+      @old_abort = Thread.abort_on_exception
+      Thread.abort_on_exception = true
+    end
+
+    def teardown
+      Thread.abort_on_exception = @old_abort
+    end
+
+    def initialize(obj)
+      __setobj__(obj)
+      @monitor = Monitor.new
+    end
+
+    def method_missing(method, *args, &block)
+      monitor = @monitor
+      begin
+        monitor.enter
+        super
+      ensure
+        monitor.exit
+      end
+    end
+
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/adder.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util/adder.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/adder.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util/adder.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb
new file mode 100644
index 0000000000000..01eb98f4aa603
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb
@@ -0,0 +1,52 @@
+require 'concurrent/thread_safe/util'
+require 'concurrent/utility/engine'
+
+# Shim for TruffleRuby.synchronized
+if Concurrent.on_truffleruby? && !TruffleRuby.respond_to?(:synchronized)
+  module TruffleRuby
+    def self.synchronized(object, &block)
+      Truffle::System.synchronized(object, &block)
+    end
+  end
+end
+
+module Concurrent
+  module ThreadSafe
+    module Util
+      def self.make_synchronized_on_cruby(klass)
+        klass.class_eval do
+          def initialize(*args, &block)
+            @_monitor = Monitor.new
+            super
+          end
+
+          def initialize_copy(other)
+            # make sure a copy is not sharing a monitor with the original object!
+            @_monitor = Monitor.new
+            super
+          end
+        end
+
+        klass.superclass.instance_methods(false).each do |method|
+          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}(*args)
+              monitor = @_monitor
+              monitor or raise("BUG: Internal monitor was not properly initialized. Please report this to the concurrent-ruby developers.")
+              monitor.synchronize { super }
+            end
+          RUBY
+        end
+      end
+
+      def self.make_synchronized_on_truffleruby(klass)
+        klass.superclass.instance_methods(false).each do |method|
+          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}(*args, &block)    
+              TruffleRuby.synchronized(self) { super(*args, &block) }
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/power_of_two_tuple.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util/power_of_two_tuple.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/power_of_two_tuple.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util/power_of_two_tuple.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/striped64.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util/striped64.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/striped64.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util/striped64.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/volatile.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util/volatile.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/volatile.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util/volatile.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/xor_shift_random.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util/xor_shift_random.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/thread_safe/util/xor_shift_random.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/thread_safe/util/xor_shift_random.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/timer_task.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/timer_task.rb
similarity index 77%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/timer_task.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/timer_task.rb
index b69cfc8d8abcf..dd2037f62a107 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/timer_task.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/timer_task.rb
@@ -32,6 +32,17 @@ module Concurrent
   # be tested separately then passed to the `TimerTask` for scheduling and
   # running.
   #
+  # A `TimerTask` supports two different types of interval calculations.
+  # A fixed delay will always wait the same amount of time between the
+  # completion of one task and the start of the next. A fixed rate will
+  # attempt to maintain a constant rate of execution regardless of the
+  # duration of the task. For example, if a fixed rate task is scheduled
+  # to run every 60 seconds but the task itself takes 10 seconds to
+  # complete, the next task will be scheduled to run 50 seconds after
+  # the start of the previous task. If the task takes 70 seconds to
+  # complete, the next task will be start immediately after the previous
+  # task completes. Tasks will not be executed concurrently.
+  #
   # In some cases it may be necessary for a `TimerTask` to affect its own
   # execution cycle. To facilitate this, a reference to the TimerTask instance
   # is passed as an argument to the provided block every time the task is
@@ -74,6 +85,12 @@ module Concurrent
   #
   #   #=> 'Boom!'
   #
+  # @example Configuring `:interval_type` with either :fixed_delay or :fixed_rate, default is :fixed_delay
+  #   task = Concurrent::TimerTask.new(execution_interval: 5, interval_type: :fixed_rate) do
+  #          puts 'Boom!'
+  #        end
+  #   task.interval_type #=> :fixed_rate
+  #
   # @example Last `#value` and `Dereferenceable` mixin
   #   task = Concurrent::TimerTask.new(
   #     dup_on_deref: true,
@@ -87,7 +104,7 @@ module Concurrent
   #
   # @example Controlling execution from within the block
   #   timer_task = Concurrent::TimerTask.new(execution_interval: 1) do |task|
-  #     task.execution_interval.times{ print 'Boom! ' }
+  #     task.execution_interval.to_i.times{ print 'Boom! ' }
   #     print "\n"
   #     task.execution_interval += 1
   #     if task.execution_interval > 5
@@ -96,7 +113,7 @@ module Concurrent
   #     end
   #   end
   #
-  #   timer_task.execute # blocking call - this task will stop itself
+  #   timer_task.execute
   #   #=> Boom!
   #   #=> Boom! Boom!
   #   #=> Boom! Boom! Boom!
@@ -152,18 +169,30 @@ class TimerTask < RubyExecutorService
     # Default `:execution_interval` in seconds.
     EXECUTION_INTERVAL = 60
 
-    # Default `:timeout_interval` in seconds.
-    TIMEOUT_INTERVAL = 30
+    # Maintain the interval between the end of one execution and the start of the next execution.
+    FIXED_DELAY = :fixed_delay
+
+    # Maintain the interval between the start of one execution and the start of the next.
+    # If execution time exceeds the interval, the next execution will start immediately
+    # after the previous execution finishes. Executions will not run concurrently.
+    FIXED_RATE = :fixed_rate
+
+    # Default `:interval_type`
+    DEFAULT_INTERVAL_TYPE = FIXED_DELAY
 
     # Create a new TimerTask with the given task and configuration.
     #
     # @!macro timer_task_initialize
     #   @param [Hash] opts the options defining task execution.
-    #   @option opts [Integer] :execution_interval number of seconds between
+    #   @option opts [Float] :execution_interval number of seconds between
     #     task executions (default: EXECUTION_INTERVAL)
     #   @option opts [Boolean] :run_now Whether to run the task immediately
     #     upon instantiation or to wait until the first #  execution_interval
     #     has passed (default: false)
+    #   @options opts [Symbol] :interval_type method to calculate the interval
+    #     between executions, can be either :fixed_rate or :fixed_delay.
+    #     (default: :fixed_delay)
+    #   @option opts [Executor] executor, default is `global_io_executor`
     #
     #   @!macro deref_options
     #
@@ -242,6 +271,10 @@ def execution_interval=(value)
       end
     end
 
+    # @!attribute [r] interval_type
+    # @return [Symbol] method to calculate the interval between executions
+    attr_reader :interval_type
+
     # @!attribute [rw] timeout_interval
     # @return [Fixnum] Number of seconds the task can run before it is
     #   considered to have failed.
@@ -264,11 +297,17 @@ def ns_initialize(opts, &task)
       set_deref_options(opts)
 
       self.execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
+      if opts[:interval_type] && ![FIXED_DELAY, FIXED_RATE].include?(opts[:interval_type])
+        raise ArgumentError.new('interval_type must be either :fixed_delay or :fixed_rate')
+      end
       if opts[:timeout] || opts[:timeout_interval]
         warn 'TimeTask timeouts are now ignored as these were not able to be implemented correctly'
       end
+
       @run_now = opts[:now] || opts[:run_now]
-      @executor = Concurrent::SafeTaskExecutor.new(task)
+      @interval_type = opts[:interval_type] || DEFAULT_INTERVAL_TYPE
+      @task = Concurrent::SafeTaskExecutor.new(task)
+      @executor = opts[:executor] || Concurrent.global_io_executor
       @running = Concurrent::AtomicBoolean.new(false)
       @value = nil
 
@@ -289,17 +328,18 @@ def ns_kill_execution
 
     # @!visibility private
     def schedule_next_task(interval = execution_interval)
-      ScheduledTask.execute(interval, args: [Concurrent::Event.new], &method(:execute_task))
+      ScheduledTask.execute(interval, executor: @executor, args: [Concurrent::Event.new], &method(:execute_task))
       nil
     end
 
     # @!visibility private
     def execute_task(completion)
       return nil unless @running.true?
-      _success, value, reason = @executor.execute(self)
+      start_time = Concurrent.monotonic_time
+      _success, value, reason = @task.execute(self)
       if completion.try?
         self.value = value
-        schedule_next_task
+        schedule_next_task(calculate_next_interval(start_time))
         time = Time.now
         observers.notify_observers do
           [time, self.value, reason]
@@ -307,5 +347,15 @@ def execute_task(completion)
       end
       nil
     end
+
+    # @!visibility private
+    def calculate_next_interval(start_time)
+      if @interval_type == FIXED_RATE
+        run_time = Concurrent.monotonic_time - start_time
+        [execution_interval - run_time, 0].max
+      else # FIXED_DELAY
+        execution_interval
+      end
+    end
   end
 end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/tuple.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/tuple.rb
similarity index 94%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/tuple.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/tuple.rb
index f8c4c25d32b99..56212cfd15cc6 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/tuple.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/tuple.rb
@@ -23,16 +23,12 @@ class Tuple
     # The (fixed) size of the tuple.
     attr_reader :size
 
-    # @!visibility private
-    Tuple = defined?(Rubinius::Tuple) ? Rubinius::Tuple : ::Array
-    private_constant :Tuple
-
     # Create a new tuple of the given size.
     #
     # @param [Integer] size the number of elements in the tuple
     def initialize(size)
       @size = size
-      @tuple = tuple = Tuple.new(size)
+      @tuple = tuple = ::Array.new(size)
       i = 0
       while i < size
         tuple[i] = Concurrent::AtomicReference.new
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/tvar.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/tvar.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/tvar.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/tvar.rb
index 104761ff6050d..5d02ef090fd0c 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/tvar.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/tvar.rb
@@ -1,5 +1,5 @@
 require 'set'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
 
 module Concurrent
 
@@ -149,6 +149,7 @@ def leave_transaction
 
   private
 
+  # @!visibility private
   class Transaction
 
     ABORTED = ::Object.new
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/engine.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/engine.rb
new file mode 100644
index 0000000000000..0c574b2abb893
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/engine.rb
@@ -0,0 +1,45 @@
+module Concurrent
+  # @!visibility private
+  module Utility
+
+    # @!visibility private
+    module EngineDetector
+      def on_cruby?
+        RUBY_ENGINE == 'ruby'
+      end
+
+      def on_jruby?
+        RUBY_ENGINE == 'jruby'
+      end
+
+      def on_truffleruby?
+        RUBY_ENGINE == 'truffleruby'
+      end
+
+      def on_windows?
+        !(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/).nil?
+      end
+
+      def on_osx?
+        !(RbConfig::CONFIG['host_os'] =~ /darwin|mac os/).nil?
+      end
+
+      def on_linux?
+        !(RbConfig::CONFIG['host_os'] =~ /linux/).nil?
+      end
+
+      def ruby_version(version = RUBY_VERSION, comparison, major, minor, patch)
+        result      = (version.split('.').map(&:to_i) <=> [major, minor, patch])
+        comparisons = { :== => [0],
+                        :>= => [1, 0],
+                        :<= => [-1, 0],
+                        :>  => [1],
+                        :<  => [-1] }
+        comparisons.fetch(comparison).include? result
+      end
+    end
+  end
+
+  # @!visibility private
+  extend Utility::EngineDetector
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/monotonic_time.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/monotonic_time.rb
new file mode 100644
index 0000000000000..1c987d8a411fc
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/monotonic_time.rb
@@ -0,0 +1,19 @@
+module Concurrent
+
+  # @!macro monotonic_get_time
+  #
+  #   Returns the current time as tracked by the application monotonic clock.
+  #
+  #   @param [Symbol] unit the time unit to be returned, can be either
+  #     :float_second, :float_millisecond, :float_microsecond, :second,
+  #     :millisecond, :microsecond, or :nanosecond default to :float_second.
+  #
+  #   @return [Float] The current monotonic time since some unspecified
+  #     starting point
+  #
+  #   @!macro monotonic_clock_warning
+  def monotonic_time(unit = :float_second)
+    Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
+  end
+  module_function :monotonic_time
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb
similarity index 90%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb
index a944bd729032f..bf7bab354e832 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb
@@ -1,9 +1,10 @@
 require 'concurrent/utility/engine'
+# Synchronization::AbstractObject must be defined before loading the extension
+require 'concurrent/synchronization/abstract_object'
 
 module Concurrent
-
+  # @!visibility private
   module Utility
-
     # @!visibility private
     module NativeExtensionLoader
 
@@ -15,15 +16,7 @@ def c_extensions_loaded?
         defined?(@c_extensions_loaded) && @c_extensions_loaded
       end
 
-      def java_extensions_loaded?
-        defined?(@java_extensions_loaded) && @java_extensions_loaded
-      end
-
       def load_native_extensions
-        unless defined? Synchronization::AbstractObject
-          raise 'native_extension_loader loaded before Synchronization::AbstractObject'
-        end
-
         if Concurrent.on_cruby? && !c_extensions_loaded?
           ['concurrent/concurrent_ruby_ext',
            "concurrent/#{RUBY_VERSION[0..2]}/concurrent_ruby_ext"
@@ -54,6 +47,10 @@ def set_c_extensions_loaded
         @c_extensions_loaded = true
       end
 
+      def java_extensions_loaded?
+        defined?(@java_extensions_loaded) && @java_extensions_loaded
+      end
+
       def set_java_extensions_loaded
         @java_extensions_loaded = true
       end
@@ -77,3 +74,4 @@ def try_load_c_extension(path)
   extend Utility::NativeExtensionLoader
 end
 
+Concurrent.load_native_extensions
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/native_integer.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/native_integer.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/native_integer.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/native_integer.rb
index 10719e7caa798..de1cdc306a1bd 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/concurrent-ruby-1.1.10/lib/concurrent-ruby/concurrent/utility/native_integer.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/native_integer.rb
@@ -1,4 +1,5 @@
 module Concurrent
+  # @!visibility private
   module Utility
     # @private
     module NativeInteger
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/processor_counter.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/processor_counter.rb
new file mode 100644
index 0000000000000..2489cbd76b1de
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/utility/processor_counter.rb
@@ -0,0 +1,220 @@
+require 'etc'
+require 'rbconfig'
+require 'concurrent/delay'
+
+module Concurrent
+  # @!visibility private
+  module Utility
+
+    # @!visibility private
+    class ProcessorCounter
+      def initialize
+        @processor_count          = Delay.new { compute_processor_count }
+        @physical_processor_count = Delay.new { compute_physical_processor_count }
+        @cpu_quota                = Delay.new { compute_cpu_quota }
+        @cpu_shares               = Delay.new { compute_cpu_shares }
+      end
+
+      def processor_count
+        @processor_count.value
+      end
+
+      def physical_processor_count
+        @physical_processor_count.value
+      end
+
+      def available_processor_count
+        cpu_count = processor_count.to_f
+        quota = cpu_quota
+
+        return cpu_count if quota.nil?
+
+        # cgroup cpus quotas have no limits, so they can be set to higher than the
+        # real count of cores.
+        if quota > cpu_count
+          cpu_count
+        else
+          quota
+        end
+      end
+
+      def cpu_quota
+        @cpu_quota.value
+      end
+
+      def cpu_shares
+        @cpu_shares.value
+      end
+
+      private
+
+      def compute_processor_count
+        if Concurrent.on_jruby?
+          java.lang.Runtime.getRuntime.availableProcessors
+        else
+          Etc.nprocessors
+        end
+      end
+
+      def compute_physical_processor_count
+        ppc = case RbConfig::CONFIG["target_os"]
+              when /darwin\d\d/
+                IO.popen("/usr/sbin/sysctl -n hw.physicalcpu", &:read).to_i
+              when /linux/
+                cores = {} # unique physical ID / core ID combinations
+                phy   = 0
+                IO.read("/proc/cpuinfo").scan(/^physical id.*|^core id.*/) do |ln|
+                  if ln.start_with?("physical")
+                    phy = ln[/\d+/]
+                  elsif ln.start_with?("core")
+                    cid        = phy + ":" + ln[/\d+/]
+                    cores[cid] = true if not cores[cid]
+                  end
+                end
+                cores.count
+              when /mswin|mingw/
+                # Get-CimInstance introduced in PowerShell 3 or earlier: https://learn.microsoft.com/en-us/previous-versions/powershell/module/cimcmdlets/get-ciminstance?view=powershell-3.0
+                result = run('powershell -command "Get-CimInstance -ClassName Win32_Processor -Property NumberOfCores | Select-Object -Property NumberOfCores"')
+                if !result || $?.exitstatus != 0
+                  # fallback to deprecated wmic for older systems
+                  result = run("wmic cpu get NumberOfCores")
+                end
+                if !result || $?.exitstatus != 0
+                  # Bail out if both commands returned something unexpected
+                  processor_count
+                else
+                  # powershell: "\nNumberOfCores\n-------------\n            4\n\n\n"
+                  # wmic:       "NumberOfCores  \n\n4              \n\n\n\n"
+                  result.scan(/\d+/).map(&:to_i).reduce(:+)
+                end
+              else
+                processor_count
+              end
+        # fall back to logical count if physical info is invalid
+        ppc > 0 ? ppc : processor_count
+      rescue
+        return 1
+      end
+
+      def run(command)
+        IO.popen(command, &:read)
+      rescue Errno::ENOENT
+      end
+
+      def compute_cpu_quota
+        if RbConfig::CONFIG["target_os"].include?("linux")
+          if File.exist?("/sys/fs/cgroup/cpu.max")
+            # cgroups v2: https://docs.kernel.org/admin-guide/cgroup-v2.html#cpu-interface-files
+            cpu_max = File.read("/sys/fs/cgroup/cpu.max")
+            return nil if cpu_max.start_with?("max ") # no limit
+            max, period = cpu_max.split.map(&:to_f)
+            max / period
+          elsif File.exist?("/sys/fs/cgroup/cpu,cpuacct/cpu.cfs_quota_us")
+            # cgroups v1: https://kernel.googlesource.com/pub/scm/linux/kernel/git/glommer/memcg/+/cpu_stat/Documentation/cgroups/cpu.txt
+            max = File.read("/sys/fs/cgroup/cpu,cpuacct/cpu.cfs_quota_us").to_i
+            # If the cpu.cfs_quota_us is -1, cgroup does not adhere to any CPU time restrictions
+            # https://docs.kernel.org/scheduler/sched-bwc.html#management
+            return nil if max <= 0
+            period = File.read("/sys/fs/cgroup/cpu,cpuacct/cpu.cfs_period_us").to_f
+            max / period
+          end
+        end
+      end
+
+      def compute_cpu_shares
+        if RbConfig::CONFIG["target_os"].include?("linux")
+          if File.exist?("/sys/fs/cgroup/cpu.weight")
+            # cgroups v2: https://docs.kernel.org/admin-guide/cgroup-v2.html#cpu-interface-files
+            # Ref: https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/2254-cgroup-v2#phase-1-convert-from-cgroups-v1-settings-to-v2
+            weight = File.read("/sys/fs/cgroup/cpu.weight").to_f
+            ((((weight - 1) * 262142) / 9999) + 2) / 1024
+          elsif File.exist?("/sys/fs/cgroup/cpu/cpu.shares")
+            # cgroups v1: https://kernel.googlesource.com/pub/scm/linux/kernel/git/glommer/memcg/+/cpu_stat/Documentation/cgroups/cpu.txt
+            File.read("/sys/fs/cgroup/cpu/cpu.shares").to_f / 1024
+          end
+        end
+      end
+    end
+  end
+
+  # create the default ProcessorCounter on load
+  @processor_counter = Utility::ProcessorCounter.new
+  singleton_class.send :attr_reader, :processor_counter
+
+  # Number of processors seen by the OS and used for process scheduling. For
+  # performance reasons the calculated value will be memoized on the first
+  # call.
+  #
+  # When running under JRuby the Java runtime call
+  # `java.lang.Runtime.getRuntime.availableProcessors` will be used. According
+  # to the Java documentation this "value may change during a particular
+  # invocation of the virtual machine... [applications] should therefore
+  # occasionally poll this property." We still memoize this value once under
+  # JRuby.
+  #
+  # Otherwise Ruby's Etc.nprocessors will be used.
+  #
+  # @return [Integer] number of processors seen by the OS or Java runtime
+  #
+  # @see http://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html#availableProcessors()
+  def self.processor_count
+    processor_counter.processor_count
+  end
+
+  # Number of physical processor cores on the current system. For performance
+  # reasons the calculated value will be memoized on the first call.
+  #
+  # On Windows the Win32 API will be queried for the `NumberOfCores from
+  # Win32_Processor`. This will return the total number "of cores for the
+  # current instance of the processor." On Unix-like operating systems either
+  # the `hwprefs` or `sysctl` utility will be called in a subshell and the
+  # returned value will be used. In the rare case where none of these methods
+  # work or an exception is raised the function will simply return 1.
+  #
+  # @return [Integer] number physical processor cores on the current system
+  #
+  # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
+  #
+  # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
+  # @see http://www.unix.com/man-page/osx/1/HWPREFS/
+  # @see http://linux.die.net/man/8/sysctl
+  def self.physical_processor_count
+    processor_counter.physical_processor_count
+  end
+
+  # Number of processors cores available for process scheduling.
+  # This method takes in account the CPU quota if the process is inside a cgroup with a
+  # dedicated CPU quota (typically Docker).
+  # Otherwise it returns the same value as #processor_count but as a Float.
+  #
+  # For performance reasons the calculated value will be memoized on the first
+  # call.
+  #
+  # @return [Float] number of available processors
+  def self.available_processor_count
+    processor_counter.available_processor_count
+  end
+
+  # The maximum number of processors cores available for process scheduling.
+  # Returns `nil` if there is no enforced limit, or a `Float` if the
+  # process is inside a cgroup with a dedicated CPU quota (typically Docker).
+  #
+  # Note that nothing prevents setting a CPU quota higher than the actual number of
+  # cores on the system.
+  #
+  # For performance reasons the calculated value will be memoized on the first
+  # call.
+  #
+  # @return [nil, Float] Maximum number of available processors as set by a cgroup CPU quota, or nil if none set
+  def self.cpu_quota
+    processor_counter.cpu_quota
+  end
+
+  # The CPU shares requested by the process. For performance reasons the calculated
+  # value will be memoized on the first call.
+  #
+  # @return [Float, nil] CPU shares requested by the process, or nil if not set
+  def self.cpu_shares
+    processor_counter.cpu_shares
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/version.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/version.rb
new file mode 100644
index 0000000000000..1b0c4c22f4acb
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/concurrent-ruby-1.3.4/lib/concurrent-ruby/concurrent/version.rb
@@ -0,0 +1,3 @@
+module Concurrent
+  VERSION = '1.3.4'
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/constants.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/constants.rb
new file mode 100644
index 0000000000000..2e2f77da2bd5d
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/constants.rb
@@ -0,0 +1,722 @@
+# frozen_string_literal: true
+
+module ELFTools
+  # Define constants from elf.h.
+  # Mostly refer from https://github.com/torvalds/linux/blob/master/include/uapi/linux/elf.h
+  # and binutils/elfcpp/elfcpp.h.
+  module Constants
+    # ELF magic header
+    ELFMAG = "\x7FELF"
+
+    # Values of `d_un.d_val' in the DT_FLAGS and DT_FLAGS_1 entry.
+    module DF
+      DF_ORIGIN       = 0x00000001 # Object may use DF_ORIGIN
+      DF_SYMBOLIC     = 0x00000002 # Symbol resolutions starts here
+      DF_TEXTREL      = 0x00000004 # Object contains text relocations
+      DF_BIND_NOW     = 0x00000008 # No lazy binding for this object
+      DF_STATIC_TLS   = 0x00000010 # Module uses the static TLS model
+
+      DF_1_NOW        = 0x00000001 # Set RTLD_NOW for this object.
+      DF_1_GLOBAL     = 0x00000002 # Set RTLD_GLOBAL for this object.
+      DF_1_GROUP      = 0x00000004 # Set RTLD_GROUP for this object.
+      DF_1_NODELETE   = 0x00000008 # Set RTLD_NODELETE for this object.
+      DF_1_LOADFLTR   = 0x00000010 # Trigger filtee loading at runtime.
+      DF_1_INITFIRST  = 0x00000020 # Set RTLD_INITFIRST for this object
+      DF_1_NOOPEN     = 0x00000040 # Set RTLD_NOOPEN for this object.
+      DF_1_ORIGIN     = 0x00000080 # $ORIGIN must be handled.
+      DF_1_DIRECT     = 0x00000100 # Direct binding enabled.
+      DF_1_TRANS      = 0x00000200 # :nodoc:
+      DF_1_INTERPOSE  = 0x00000400 # Object is used to interpose.
+      DF_1_NODEFLIB   = 0x00000800 # Ignore default lib search path.
+      DF_1_NODUMP     = 0x00001000 # Object can't be dldump'ed.
+      DF_1_CONFALT    = 0x00002000 # Configuration alternative created.
+      DF_1_ENDFILTEE  = 0x00004000 # Filtee terminates filters search.
+      DF_1_DISPRELDNE = 0x00008000 # Disp reloc applied at build time.
+      DF_1_DISPRELPND = 0x00010000 # Disp reloc applied at run-time.
+      DF_1_NODIRECT   = 0x00020000 # Object has no-direct binding.
+      DF_1_IGNMULDEF  = 0x00040000 # :nodoc:
+      DF_1_NOKSYMS    = 0x00080000 # :nodoc:
+      DF_1_NOHDR      = 0x00100000 # :nodoc:
+      DF_1_EDITED     = 0x00200000 # Object is modified after built.
+      DF_1_NORELOC    = 0x00400000 # :nodoc:
+      DF_1_SYMINTPOSE = 0x00800000 # Object has individual interposers.
+      DF_1_GLOBAUDIT  = 0x01000000 # Global auditing required.
+      DF_1_SINGLETON  = 0x02000000 # Singleton symbols are used.
+      DF_1_STUB       = 0x04000000 # :nodoc:
+      DF_1_PIE        = 0x08000000 # Object is a position-independent executable.
+      DF_1_KMOD       = 0x10000000 # :nodoc:
+      DF_1_WEAKFILTER = 0x20000000 # :nodoc:
+      DF_1_NOCOMMON   = 0x40000000 # :nodoc:
+    end
+    include DF
+
+    # Dynamic table types, records in +d_tag+.
+    module DT
+      DT_NULL                       = 0 # marks the end of the _DYNAMIC array
+      DT_NEEDED                     = 1 # libraries need to be linked by loader
+      DT_PLTRELSZ                   = 2 # total size of relocation entries
+      DT_PLTGOT                     = 3 # address of procedure linkage table or global offset table
+      DT_HASH                       = 4 # address of symbol hash table
+      DT_STRTAB                     = 5 # address of string table
+      DT_SYMTAB                     = 6 # address of symbol table
+      DT_RELA                       = 7 # address of a relocation table
+      DT_RELASZ                     = 8 # total size of the {DT_RELA} table
+      DT_RELAENT                    = 9 # size of each entry in the {DT_RELA} table
+      DT_STRSZ                      = 10 # total size of {DT_STRTAB}
+      DT_SYMENT                     = 11 # size of each entry in {DT_SYMTAB}
+      DT_INIT                       = 12 # where the initialization function is
+      DT_FINI                       = 13 # where the termination function is
+      DT_SONAME                     = 14 # the shared object name
+      DT_RPATH                      = 15 # has been superseded by {DT_RUNPATH}
+      DT_SYMBOLIC                   = 16 # has been superseded by the DF_SYMBOLIC flag
+      DT_REL                        = 17 # similar to {DT_RELA}
+      DT_RELSZ                      = 18 # total size of the {DT_REL} table
+      DT_RELENT                     = 19 # size of each entry in the {DT_REL} table
+      DT_PLTREL                     = 20 # type of relocation entry, either {DT_REL} or {DT_RELA}
+      DT_DEBUG                      = 21 # for debugging
+      DT_TEXTREL                    = 22 # has been superseded by the DF_TEXTREL flag
+      DT_JMPREL                     = 23 # address of relocation entries associated solely with procedure linkage table
+      DT_BIND_NOW                   = 24 # if the loader needs to do relocate now, superseded by the DF_BIND_NOW flag
+      DT_INIT_ARRAY                 = 25 # address init array
+      DT_FINI_ARRAY                 = 26 # address of fini array
+      DT_INIT_ARRAYSZ               = 27 # total size of init array
+      DT_FINI_ARRAYSZ               = 28 # total size of fini array
+      DT_RUNPATH                    = 29 # path of libraries for searching
+      DT_FLAGS                      = 30 # flags
+      DT_ENCODING                   = 32 # just a lower bound
+      DT_PREINIT_ARRAY              = 32 # pre-initialization functions array
+      DT_PREINIT_ARRAYSZ            = 33 # pre-initialization functions array size (bytes)
+      DT_SYMTAB_SHNDX               = 34 # address of the +SHT_SYMTAB_SHNDX+ section associated with {DT_SYMTAB} table
+      DT_RELRSZ                     = 35 # :nodoc:
+      DT_RELR                       = 36 # :nodoc:
+      DT_RELRENT                    = 37 # :nodoc:
+
+      # Values between {DT_LOOS} and {DT_HIOS} are reserved for operating system-specific semantics.
+      DT_LOOS                       = 0x6000000d
+      DT_HIOS                       = 0x6ffff000 # see {DT_LOOS}
+
+      # Values between {DT_VALRNGLO} and {DT_VALRNGHI} use the +d_un.d_val+ field of the dynamic structure.
+      DT_VALRNGLO                   = 0x6ffffd00
+      DT_VALRNGHI                   = 0x6ffffdff # see {DT_VALRNGLO}
+
+      # Values between {DT_ADDRRNGLO} and {DT_ADDRRNGHI} use the +d_un.d_ptr+ field of the dynamic structure.
+      DT_ADDRRNGLO                  = 0x6ffffe00
+      DT_GNU_HASH                   = 0x6ffffef5 # the gnu hash
+      DT_TLSDESC_PLT                = 0x6ffffef6 # :nodoc:
+      DT_TLSDESC_GOT                = 0x6ffffef7 # :nodoc:
+      DT_GNU_CONFLICT               = 0x6ffffef8 # :nodoc:
+      DT_GNU_LIBLIST                = 0x6ffffef9 # :nodoc:
+      DT_CONFIG                     = 0x6ffffefa # :nodoc:
+      DT_DEPAUDIT                   = 0x6ffffefb # :nodoc:
+      DT_AUDIT                      = 0x6ffffefc # :nodoc:
+      DT_PLTPAD                     = 0x6ffffefd # :nodoc:
+      DT_MOVETAB                    = 0x6ffffefe # :nodoc:
+      DT_SYMINFO                    = 0x6ffffeff # :nodoc:
+      DT_ADDRRNGHI                  = 0x6ffffeff # see {DT_ADDRRNGLO}
+
+      DT_VERSYM                     = 0x6ffffff0 # section address of .gnu.version
+      DT_RELACOUNT                  = 0x6ffffff9 # relative relocation count
+      DT_RELCOUNT                   = 0x6ffffffa # relative relocation count
+      DT_FLAGS_1                    = 0x6ffffffb # flags
+      DT_VERDEF                     = 0x6ffffffc # address of version definition table
+      DT_VERDEFNUM                  = 0x6ffffffd # number of entries in {DT_VERDEF}
+      DT_VERNEED                    = 0x6ffffffe # address of version dependency table
+      DT_VERNEEDNUM                 = 0x6fffffff # number of entries in {DT_VERNEED}
+
+      # Values between {DT_LOPROC} and {DT_HIPROC} are reserved for processor-specific semantics.
+      DT_LOPROC                     = 0x70000000
+
+      DT_PPC_GOT                    = 0x70000000 # global offset table
+      DT_PPC_OPT                    = 0x70000001 # whether various optimisations are possible
+
+      DT_PPC64_GLINK                = 0x70000000 # start of the .glink section
+      DT_PPC64_OPD                  = 0x70000001 # start of the .opd section
+      DT_PPC64_OPDSZ                = 0x70000002 # size of the .opd section
+      DT_PPC64_OPT                  = 0x70000003 # whether various optimisations are possible
+
+      DT_SPARC_REGISTER             = 0x70000000 # index of an +STT_SPARC_REGISTER+ symbol within the {DT_SYMTAB} table
+
+      DT_MIPS_RLD_VERSION           = 0x70000001 # 32 bit version number for runtime linker interface
+      DT_MIPS_TIME_STAMP            = 0x70000002 # time stamp
+      DT_MIPS_ICHECKSUM             = 0x70000003 # checksum of external strings and common sizes
+      DT_MIPS_IVERSION              = 0x70000004 # index of version string in string table
+      DT_MIPS_FLAGS                 = 0x70000005 # 32 bits of flags
+      DT_MIPS_BASE_ADDRESS          = 0x70000006 # base address of the segment
+      DT_MIPS_MSYM                  = 0x70000007 # :nodoc:
+      DT_MIPS_CONFLICT              = 0x70000008 # address of +.conflict+ section
+      DT_MIPS_LIBLIST               = 0x70000009 # address of +.liblist+ section
+      DT_MIPS_LOCAL_GOTNO           = 0x7000000a # number of local global offset table entries
+      DT_MIPS_CONFLICTNO            = 0x7000000b # number of entries in the +.conflict+ section
+      DT_MIPS_LIBLISTNO             = 0x70000010 # number of entries in the +.liblist+ section
+      DT_MIPS_SYMTABNO              = 0x70000011 # number of entries in the +.dynsym+ section
+      DT_MIPS_UNREFEXTNO            = 0x70000012 # index of first external dynamic symbol not referenced locally
+      DT_MIPS_GOTSYM                = 0x70000013 # index of first dynamic symbol in global offset table
+      DT_MIPS_HIPAGENO              = 0x70000014 # number of page table entries in global offset table
+      DT_MIPS_RLD_MAP               = 0x70000016 # address of run time loader map, used for debugging
+      DT_MIPS_DELTA_CLASS           = 0x70000017 # delta C++ class definition
+      DT_MIPS_DELTA_CLASS_NO        = 0x70000018 # number of entries in {DT_MIPS_DELTA_CLASS}
+      DT_MIPS_DELTA_INSTANCE        = 0x70000019 # delta C++ class instances
+      DT_MIPS_DELTA_INSTANCE_NO     = 0x7000001a # number of entries in {DT_MIPS_DELTA_INSTANCE}
+      DT_MIPS_DELTA_RELOC           = 0x7000001b # delta relocations
+      DT_MIPS_DELTA_RELOC_NO        = 0x7000001c # number of entries in {DT_MIPS_DELTA_RELOC}
+      DT_MIPS_DELTA_SYM             = 0x7000001d # delta symbols that Delta relocations refer to
+      DT_MIPS_DELTA_SYM_NO          = 0x7000001e # number of entries in {DT_MIPS_DELTA_SYM}
+      DT_MIPS_DELTA_CLASSSYM        = 0x70000020 # delta symbols that hold class declarations
+      DT_MIPS_DELTA_CLASSSYM_NO     = 0x70000021 # number of entries in {DT_MIPS_DELTA_CLASSSYM}
+      DT_MIPS_CXX_FLAGS             = 0x70000022 # flags indicating information about C++ flavor
+      DT_MIPS_PIXIE_INIT            = 0x70000023 # :nodoc:
+      DT_MIPS_SYMBOL_LIB            = 0x70000024 # address of +.MIPS.symlib+
+      DT_MIPS_LOCALPAGE_GOTIDX      = 0x70000025 # GOT index of the first PTE for a segment
+      DT_MIPS_LOCAL_GOTIDX          = 0x70000026 # GOT index of the first PTE for a local symbol
+      DT_MIPS_HIDDEN_GOTIDX         = 0x70000027 # GOT index of the first PTE for a hidden symbol
+      DT_MIPS_PROTECTED_GOTIDX      = 0x70000028 # GOT index of the first PTE for a protected symbol
+      DT_MIPS_OPTIONS               = 0x70000029 # address of +.MIPS.options+
+      DT_MIPS_INTERFACE             = 0x7000002a # address of +.interface+
+      DT_MIPS_DYNSTR_ALIGN          = 0x7000002b # :nodoc:
+      DT_MIPS_INTERFACE_SIZE        = 0x7000002c # size of the +.interface+ section
+      DT_MIPS_RLD_TEXT_RESOLVE_ADDR = 0x7000002d # size of +rld_text_resolve+ function stored in the GOT
+      DT_MIPS_PERF_SUFFIX           = 0x7000002e # default suffix of DSO to be added by rld on +dlopen()+ calls
+      DT_MIPS_COMPACT_SIZE          = 0x7000002f # size of compact relocation section (O32)
+      DT_MIPS_GP_VALUE              = 0x70000030 # GP value for auxiliary GOTs
+      DT_MIPS_AUX_DYNAMIC           = 0x70000031 # address of auxiliary +.dynamic+
+      DT_MIPS_PLTGOT                = 0x70000032 # address of the base of the PLTGOT
+      DT_MIPS_RWPLT                 = 0x70000034 # base of a writable PLT
+      DT_MIPS_RLD_MAP_REL           = 0x70000035 # relative offset of run time loader map
+      DT_MIPS_XHASH                 = 0x70000036 # GNU-style hash table with xlat
+
+      DT_AUXILIARY                  = 0x7ffffffd # :nodoc:
+      DT_USED                       = 0x7ffffffe # :nodoc:
+      DT_FILTER                     = 0x7ffffffe # :nodoc:
+
+      DT_HIPROC                     = 0x7fffffff # see {DT_LOPROC}
+    end
+    include DT
+
+    # These constants define the various ELF target machines.
+    module EM
+      EM_NONE            = 0      # none
+      EM_M32             = 1      # AT&T WE 32100
+      EM_SPARC           = 2      # SPARC
+      EM_386             = 3      # Intel 80386
+      EM_68K             = 4      # Motorola 68000
+      EM_88K             = 5      # Motorola 88000
+      EM_486             = 6      # Intel 80486
+      EM_860             = 7      # Intel 80860
+      EM_MIPS            = 8      # MIPS R3000 (officially, big-endian only)
+      EM_S370            = 9      # IBM System/370
+
+      # Next two are historical and binaries and
+      # modules of these types will be rejected by Linux.
+      EM_MIPS_RS3_LE     = 10     # MIPS R3000 little-endian
+      EM_MIPS_RS4_BE     = 10     # MIPS R4000 big-endian
+
+      EM_PARISC          = 15     # HPPA
+      EM_VPP500          = 17     # Fujitsu VPP500 (also some older versions of PowerPC)
+      EM_SPARC32PLUS     = 18     # Sun's "v8plus"
+      EM_960             = 19     # Intel 80960
+      EM_PPC             = 20     # PowerPC
+      EM_PPC64           = 21     # PowerPC64
+      EM_S390            = 22     # IBM S/390
+      EM_SPU             = 23     # Cell BE SPU
+      EM_V800            = 36     # NEC V800 series
+      EM_FR20            = 37     # Fujitsu FR20
+      EM_RH32            = 38     # TRW RH32
+      EM_RCE             = 39     # Motorola M*Core
+      EM_ARM             = 40     # ARM 32 bit
+      EM_SH              = 42     # SuperH
+      EM_SPARCV9         = 43     # SPARC v9 64-bit
+      EM_TRICORE         = 44     # Siemens Tricore embedded processor
+      EM_ARC             = 45     # ARC Cores
+      EM_H8_300          = 46     # Renesas H8/300
+      EM_H8_300H         = 47     # Renesas H8/300H
+      EM_H8S             = 48     # Renesas H8S
+      EM_H8_500          = 49     # Renesas H8/500H
+      EM_IA_64           = 50     # HP/Intel IA-64
+      EM_MIPS_X          = 51     # Stanford MIPS-X
+      EM_COLDFIRE        = 52     # Motorola Coldfire
+      EM_68HC12          = 53     # Motorola M68HC12
+      EM_MMA             = 54     # Fujitsu Multimedia Accelerator
+      EM_PCP             = 55     # Siemens PCP
+      EM_NCPU            = 56     # Sony nCPU embedded RISC processor
+      EM_NDR1            = 57     # Denso NDR1 microprocessor
+      EM_STARCORE        = 58     # Motorola Star*Core processor
+      EM_ME16            = 59     # Toyota ME16 processor
+      EM_ST100           = 60     # STMicroelectronics ST100 processor
+      EM_TINYJ           = 61     # Advanced Logic Corp. TinyJ embedded processor
+      EM_X86_64          = 62     # AMD x86-64
+      EM_PDSP            = 63     # Sony DSP Processor
+      EM_PDP10           = 64     # Digital Equipment Corp. PDP-10
+      EM_PDP11           = 65     # Digital Equipment Corp. PDP-11
+      EM_FX66            = 66     # Siemens FX66 microcontroller
+      EM_ST9PLUS         = 67     # STMicroelectronics ST9+ 8/16 bit microcontroller
+      EM_ST7             = 68     # STMicroelectronics ST7 8-bit microcontroller
+      EM_68HC16          = 69     # Motorola MC68HC16 Microcontroller
+      EM_68HC11          = 70     # Motorola MC68HC11 Microcontroller
+      EM_68HC08          = 71     # Motorola MC68HC08 Microcontroller
+      EM_68HC05          = 72     # Motorola MC68HC05 Microcontroller
+      EM_SVX             = 73     # Silicon Graphics SVx
+      EM_ST19            = 74     # STMicroelectronics ST19 8-bit cpu
+      EM_VAX             = 75     # Digital VAX
+      EM_CRIS            = 76     # Axis Communications 32-bit embedded processor
+      EM_JAVELIN         = 77     # Infineon Technologies 32-bit embedded cpu
+      EM_FIREPATH        = 78     # Element 14 64-bit DSP processor
+      EM_ZSP             = 79     # LSI Logic's 16-bit DSP processor
+      EM_MMIX            = 80     # Donald Knuth's educational 64-bit processor
+      EM_HUANY           = 81     # Harvard's machine-independent format
+      EM_PRISM           = 82     # SiTera Prism
+      EM_AVR             = 83     # Atmel AVR 8-bit microcontroller
+      EM_FR30            = 84     # Fujitsu FR30
+      EM_D10V            = 85     # Mitsubishi D10V
+      EM_D30V            = 86     # Mitsubishi D30V
+      EM_V850            = 87     # Renesas V850
+      EM_M32R            = 88     # Renesas M32R
+      EM_MN10300         = 89     # Matsushita MN10300
+      EM_MN10200         = 90     # Matsushita MN10200
+      EM_PJ              = 91     # picoJava
+      EM_OPENRISC        = 92     # OpenRISC 32-bit embedded processor
+      EM_ARC_COMPACT     = 93     # ARC International ARCompact processor
+      EM_XTENSA          = 94     # Tensilica Xtensa Architecture
+      EM_VIDEOCORE       = 95     # Alphamosaic VideoCore processor
+      EM_TMM_GPP         = 96     # Thompson Multimedia General Purpose Processor
+      EM_NS32K           = 97     # National Semiconductor 32000 series
+      EM_TPC             = 98     # Tenor Network TPC processor
+      EM_SNP1K           = 99     # Trebia SNP 1000 processor
+      EM_ST200           = 100    # STMicroelectronics ST200 microcontroller
+      EM_IP2K            = 101    # Ubicom IP2022 micro controller
+      EM_MAX             = 102    # MAX Processor
+      EM_CR              = 103    # National Semiconductor CompactRISC
+      EM_F2MC16          = 104    # Fujitsu F2MC16
+      EM_MSP430          = 105    # TI msp430 micro controller
+      EM_BLACKFIN        = 106    # ADI Blackfin Processor
+      EM_SE_C33          = 107    # S1C33 Family of Seiko Epson processors
+      EM_SEP             = 108    # Sharp embedded microprocessor
+      EM_ARCA            = 109    # Arca RISC Microprocessor
+      EM_UNICORE         = 110    # Microprocessor series from PKU-Unity Ltd. and MPRC of Peking University
+      EM_EXCESS          = 111    # eXcess: 16/32/64-bit configurable embedded CPU
+      EM_DXP             = 112    # Icera Semiconductor Inc. Deep Execution Processor
+      EM_ALTERA_NIOS2    = 113    # Altera Nios II soft-core processor
+      EM_CRX             = 114    # National Semiconductor CRX
+      EM_XGATE           = 115    # Motorola XGATE embedded processor
+      EM_C116            = 116    # Infineon C16x/XC16x processor
+      EM_M16C            = 117    # Renesas M16C series microprocessors
+      EM_DSPIC30F        = 118    # Microchip Technology dsPIC30F Digital Signal Controller
+      EM_CE              = 119    # Freescale Communication Engine RISC core
+      EM_M32C            = 120    # Freescale Communication Engine RISC core
+      EM_TSK3000         = 131    # Altium TSK3000 core
+      EM_RS08            = 132    # Freescale RS08 embedded processor
+      EM_SHARC           = 133    # Analog Devices SHARC family of 32-bit DSP processors
+      EM_ECOG2           = 134    # Cyan Technology eCOG2 microprocessor
+      EM_SCORE7          = 135    # Sunplus S+core7 RISC processor
+      EM_DSP24           = 136    # New Japan Radio (NJR) 24-bit DSP Processor
+      EM_VIDEOCORE3      = 137    # Broadcom VideoCore III processor
+      EM_LATTICEMICO32   = 138    # RISC processor for Lattice FPGA architecture
+      EM_SE_C17          = 139    # Seiko Epson C17 family
+      EM_TI_C6000        = 140    # The Texas Instruments TMS320C6000 DSP family
+      EM_TI_C2000        = 141    # The Texas Instruments TMS320C2000 DSP family
+      EM_TI_C5500        = 142    # The Texas Instruments TMS320C55x DSP family
+      EM_TI_ARP32        = 143    # Texas Instruments Application Specific RISC Processor, 32bit fetch
+      EM_TI_PRU          = 144    # Texas Instruments Programmable Realtime Unit
+      EM_MMDSP_PLUS      = 160    # STMicroelectronics 64bit VLIW Data Signal Processor
+      EM_CYPRESS_M8C     = 161    # Cypress M8C microprocessor
+      EM_R32C            = 162    # Renesas R32C series microprocessors
+      EM_TRIMEDIA        = 163    # NXP Semiconductors TriMedia architecture family
+      EM_QDSP6           = 164    # QUALCOMM DSP6 Processor
+      EM_8051            = 165    # Intel 8051 and variants
+      EM_STXP7X          = 166    # STMicroelectronics STxP7x family
+      EM_NDS32           = 167    # Andes Technology compact code size embedded RISC processor family
+      EM_ECOG1           = 168    # Cyan Technology eCOG1X family
+      EM_ECOG1X          = 168    # Cyan Technology eCOG1X family
+      EM_MAXQ30          = 169    # Dallas Semiconductor MAXQ30 Core Micro-controllers
+      EM_XIMO16          = 170    # New Japan Radio (NJR) 16-bit DSP Processor
+      EM_MANIK           = 171    # M2000 Reconfigurable RISC Microprocessor
+      EM_CRAYNV2         = 172    # Cray Inc. NV2 vector architecture
+      EM_RX              = 173    # Renesas RX family
+      EM_METAG           = 174    # Imagination Technologies Meta processor architecture
+      EM_MCST_ELBRUS     = 175    # MCST Elbrus general purpose hardware architecture
+      EM_ECOG16          = 176    # Cyan Technology eCOG16 family
+      EM_CR16            = 177    # National Semiconductor CompactRISC 16-bit processor
+      EM_ETPU            = 178    # Freescale Extended Time Processing Unit
+      EM_SLE9X           = 179    # Infineon Technologies SLE9X core
+      EM_L1OM            = 180    # Intel L1OM
+      EM_K1OM            = 181    # Intel K1OM
+      EM_AARCH64         = 183    # ARM 64 bit
+      EM_AVR32           = 185    # Atmel Corporation 32-bit microprocessor family
+      EM_STM8            = 186    # STMicroeletronics STM8 8-bit microcontroller
+      EM_TILE64          = 187    # Tilera TILE64 multicore architecture family
+      EM_TILEPRO         = 188    # Tilera TILEPro
+      EM_MICROBLAZE      = 189    # Xilinx MicroBlaze
+      EM_CUDA            = 190    # NVIDIA CUDA architecture
+      EM_TILEGX          = 191    # Tilera TILE-Gx
+      EM_CLOUDSHIELD     = 192    # CloudShield architecture family
+      EM_COREA_1ST       = 193    # KIPO-KAIST Core-A 1st generation processor family
+      EM_COREA_2ND       = 194    # KIPO-KAIST Core-A 2nd generation processor family
+      EM_ARC_COMPACT2    = 195    # Synopsys ARCompact V2
+      EM_OPEN8           = 196    # Open8 8-bit RISC soft processor core
+      EM_RL78            = 197    # Renesas RL78 family
+      EM_VIDEOCORE5      = 198    # Broadcom VideoCore V processor
+      EM_78K0R           = 199    # Renesas 78K0R
+      EM_56800EX         = 200    # Freescale 56800EX Digital Signal Controller (DSC)
+      EM_BA1             = 201    # Beyond BA1 CPU architecture
+      EM_BA2             = 202    # Beyond BA2 CPU architecture
+      EM_XCORE           = 203    # XMOS xCORE processor family
+      EM_MCHP_PIC        = 204    # Microchip 8-bit PIC(r) family
+      EM_INTELGT         = 205    # Intel Graphics Technology
+      EM_KM32            = 210    # KM211 KM32 32-bit processor
+      EM_KMX32           = 211    # KM211 KMX32 32-bit processor
+      EM_KMX16           = 212    # KM211 KMX16 16-bit processor
+      EM_KMX8            = 213    # KM211 KMX8 8-bit processor
+      EM_KVARC           = 214    # KM211 KVARC processor
+      EM_CDP             = 215    # Paneve CDP architecture family
+      EM_COGE            = 216    # Cognitive Smart Memory Processor
+      EM_COOL            = 217    # Bluechip Systems CoolEngine
+      EM_NORC            = 218    # Nanoradio Optimized RISC
+      EM_CSR_KALIMBA     = 219    # CSR Kalimba architecture family
+      EM_Z80             = 220    # Zilog Z80
+      EM_VISIUM          = 221    # Controls and Data Services VISIUMcore processor
+      EM_FT32            = 222    # FTDI Chip FT32 high performance 32-bit RISC architecture
+      EM_MOXIE           = 223    # Moxie processor family
+      EM_AMDGPU          = 224    # AMD GPU architecture
+      EM_LANAI           = 244    # Lanai 32-bit processor
+      EM_CEVA            = 245    # CEVA Processor Architecture Family
+      EM_CEVA_X2         = 246    # CEVA X2 Processor Family
+      EM_BPF             = 247    # Linux BPF - in-kernel virtual machine
+      EM_GRAPHCORE_IPU   = 248    # Graphcore Intelligent Processing Unit
+      EM_IMG1            = 249    # Imagination Technologies
+      EM_NFP             = 250    # Netronome Flow Processor (NFP)
+      EM_VE              = 251    # NEC Vector Engine
+      EM_CSKY            = 252    # C-SKY processor family
+      EM_ARC_COMPACT3_64 = 253    # Synopsys ARCv2.3 64-bit
+      EM_MCS6502         = 254    # MOS Technology MCS 6502 processor
+      EM_ARC_COMPACT3    = 255    # Synopsys ARCv2.3 32-bit
+      EM_KVX             = 256    # Kalray VLIW core of the MPPA processor family
+      EM_65816           = 257    # WDC 65816/65C816
+      EM_LOONGARCH       = 258    # LoongArch
+      EM_KF32            = 259    # ChipON KungFu32
+      EM_U16_U8CORE      = 260    # LAPIS nX-U16/U8
+      EM_TACHYUM         = 261    # Tachyum
+      EM_56800EF         = 262    # NXP 56800EF Digital Signal Controller (DSC)
+
+      EM_FRV             = 0x5441 # Fujitsu FR-V
+
+      # This is an interim value that we will use until the committee comes up with a final number.
+      EM_ALPHA           = 0x9026
+
+      # Bogus old m32r magic number, used by old tools.
+      EM_CYGNUS_M32R     = 0x9041
+      # This is the old interim value for S/390 architecture
+      EM_S390_OLD        = 0xA390
+      # Also Panasonic/MEI MN10300, AM33
+      EM_CYGNUS_MN10300  = 0xbeef
+
+      # Return the architecture name according to +val+.
+      # Used by {ELFTools::ELFFile#machine}.
+      #
+      # Only supports famous archs.
+      # @param [Integer] val Value of +e_machine+.
+      # @return [String]
+      #   Name of architecture.
+      # @example
+      #   mapping(3)
+      #   #=> 'Intel 80386'
+      #   mapping(6)
+      #   #=> 'Intel 80386'
+      #   mapping(62)
+      #   #=> 'Advanced Micro Devices X86-64'
+      #   mapping(1337)
+      #   #=> '<unknown>: 0x539'
+      def self.mapping(val)
+        case val
+        when EM_NONE then 'None'
+        when EM_386, EM_486 then 'Intel 80386'
+        when EM_860 then 'Intel 80860'
+        when EM_MIPS then 'MIPS R3000'
+        when EM_PPC then 'PowerPC'
+        when EM_PPC64 then 'PowerPC64'
+        when EM_ARM then 'ARM'
+        when EM_IA_64 then 'Intel IA-64'
+        when EM_AARCH64 then 'AArch64'
+        when EM_X86_64 then 'Advanced Micro Devices X86-64'
+        else format('<unknown>: 0x%x', val)
+        end
+      end
+    end
+    include EM
+
+    # This module defines ELF file types.
+    module ET
+      ET_NONE = 0 # no file type
+      ET_REL  = 1 # relocatable file
+      ET_EXEC = 2 # executable file
+      ET_DYN  = 3 # shared object
+      ET_CORE = 4 # core file
+      # Return the type name according to +e_type+ in ELF file header.
+      # @return [String] Type in string format.
+      def self.mapping(type)
+        case type
+        when Constants::ET_NONE then 'NONE'
+        when Constants::ET_REL then 'REL'
+        when Constants::ET_EXEC then 'EXEC'
+        when Constants::ET_DYN then 'DYN'
+        when Constants::ET_CORE then 'CORE'
+        else '<unknown>'
+        end
+      end
+    end
+    include ET
+
+    # Program header permission flags, records bitwise OR value in +p_flags+.
+    module PF
+      PF_X = 1 # executable
+      PF_W = 2 # writable
+      PF_R = 4 # readable
+    end
+    include PF
+
+    # Program header types, records in +p_type+.
+    module PT
+      PT_NULL              = 0          # null segment
+      PT_LOAD              = 1          # segment to be load
+      PT_DYNAMIC           = 2          # dynamic tags
+      PT_INTERP            = 3          # interpreter, same as .interp section
+      PT_NOTE              = 4          # same as .note* section
+      PT_SHLIB             = 5          # reserved
+      PT_PHDR              = 6          # where program header starts
+      PT_TLS               = 7          # thread local storage segment
+
+      PT_LOOS              = 0x60000000 # OS-specific
+      PT_GNU_EH_FRAME      = 0x6474e550 # for exception handler
+      PT_GNU_STACK         = 0x6474e551 # permission of stack
+      PT_GNU_RELRO         = 0x6474e552 # read only after relocation
+      PT_GNU_PROPERTY      = 0x6474e553 # GNU property
+      PT_GNU_MBIND_HI      = 0x6474f554 # Mbind segments (upper bound)
+      PT_GNU_MBIND_LO      = 0x6474e555 # Mbind segments (lower bound)
+      PT_OPENBSD_RANDOMIZE = 0x65a3dbe6 # Fill with random data
+      PT_OPENBSD_WXNEEDED  = 0x65a3dbe7 # Program does W^X violations
+      PT_OPENBSD_BOOTDATA  = 0x65a41be6 # Section for boot arguments
+      PT_HIOS              = 0x6fffffff # OS-specific
+
+      # Values between {PT_LOPROC} and {PT_HIPROC} are reserved for processor-specific semantics.
+      PT_LOPROC            = 0x70000000
+
+      PT_ARM_ARCHEXT       = 0x70000000 # platform architecture compatibility information
+      PT_ARM_EXIDX         = 0x70000001 # exception unwind tables
+
+      PT_MIPS_REGINFO      = 0x70000000 # register usage information
+      PT_MIPS_RTPROC       = 0x70000001 # runtime procedure table
+      PT_MIPS_OPTIONS      = 0x70000002 # +.MIPS.options+ section
+      PT_MIPS_ABIFLAGS     = 0x70000003 # +.MIPS.abiflags+ section
+
+      PT_AARCH64_ARCHEXT   = 0x70000000 # platform architecture compatibility information
+      PT_AARCH64_UNWIND    = 0x70000001 # exception unwind tables
+
+      PT_S390_PGSTE        = 0x70000000 # 4k page table size
+
+      PT_HIPROC            = 0x7fffffff # see {PT_LOPROC}
+    end
+    include PT
+
+    # Special indices to section. These are used when there is no valid index to section header.
+    # The meaning of these values is left upto the embedding header.
+    module SHN
+      SHN_UNDEF           = 0      # undefined section
+      SHN_LORESERVE       = 0xff00 # start of reserved indices
+
+      # Values between {SHN_LOPROC} and {SHN_HIPROC} are reserved for processor-specific semantics.
+      SHN_LOPROC          = 0xff00
+
+      SHN_MIPS_ACOMMON    = 0xff00 # defined and allocated common symbol
+      SHN_MIPS_TEXT       = 0xff01 # defined and allocated text symbol
+      SHN_MIPS_DATA       = 0xff02 # defined and allocated data symbol
+      SHN_MIPS_SCOMMON    = 0xff03 # small common symbol
+      SHN_MIPS_SUNDEFINED = 0xff04 # small undefined symbol
+
+      SHN_X86_64_LCOMMON  = 0xff02 # large common symbol
+
+      SHN_HIPROC          = 0xff1f # see {SHN_LOPROC}
+
+      # Values between {SHN_LOOS} and {SHN_HIOS} are reserved for operating system-specific semantics.
+      SHN_LOOS            = 0xff20
+      SHN_HIOS            = 0xff3f # see {SHN_LOOS}
+      SHN_ABS             = 0xfff1 # specifies absolute values for the corresponding reference
+      SHN_COMMON          = 0xfff2 # symbols defined relative to this section are common symbols
+      SHN_XINDEX          = 0xffff # escape value indicating that the actual section header index is too large to fit
+      SHN_HIRESERVE       = 0xffff # end of reserved indices
+    end
+    include SHN
+
+    # Section flag mask types, records in +sh_flag+.
+    module SHF
+      SHF_WRITE = (1 << 0) # Writable
+      SHF_ALLOC = (1 << 1) # Occupies memory during execution
+      SHF_EXECINSTR = (1 << 2) # Executable
+      SHF_MERGE = (1 << 4) # Might be merged
+      SHF_STRINGS = (1 << 5) # Contains nul-terminated strings
+      SHF_INFO_LINK = (1 << 6) # `sh_info' contains SHT index
+      SHF_LINK_ORDER = (1 << 7) # Preserve order after combining
+      SHF_OS_NONCONFORMING = (1 << 8) # Non-standard OS specific handling required
+      SHF_GROUP = (1 << 9) # Section is member of a group.
+      SHF_TLS = (1 << 10) # Section hold thread-local data.
+      SHF_COMPRESSED = (1 << 11) # Section with compressed data.
+      SHF_MASKOS = 0x0ff00000 # OS-specific.
+      SHF_MASKPROC = 0xf0000000 # Processor-specific
+      SHF_GNU_RETAIN = (1 << 21) # Not to be GCed by linker.
+      SHF_GNU_MBIND = (1 << 24) # Mbind section
+      SHF_ORDERED = (1 << 30) # Special ordering requirement
+      SHF_EXCLUDE = (1 << 31) # Section is excluded unless referenced or allocated (Solaris).
+    end
+    include SHF
+
+    # Section header types, records in +sh_type+.
+    module SHT
+      SHT_NULL                    = 0 # null section
+      SHT_PROGBITS                = 1 # information defined by program itself
+      SHT_SYMTAB                  = 2 # symbol table section
+      SHT_STRTAB                  = 3 # string table section
+      SHT_RELA                    = 4 # relocation with addends
+      SHT_HASH                    = 5 # symbol hash table
+      SHT_DYNAMIC                 = 6 # information of dynamic linking
+      SHT_NOTE                    = 7 # section for notes
+      SHT_NOBITS                  = 8 # section occupies no space
+      SHT_REL                     = 9 # relocation
+      SHT_SHLIB                   = 10 # reserved
+      SHT_DYNSYM                  = 11 # symbols for dynamic
+      SHT_INIT_ARRAY              = 14 # array of initialization functions
+      SHT_FINI_ARRAY              = 15 # array of termination functions
+      SHT_PREINIT_ARRAY           = 16 # array of functions that are invoked before all other initialization functions
+      SHT_GROUP                   = 17 # section group
+      SHT_SYMTAB_SHNDX            = 18 # indices for SHN_XINDEX entries
+      SHT_RELR                    = 19 # RELR relative relocations
+
+      # Values between {SHT_LOOS} and {SHT_HIOS} are reserved for operating system-specific semantics.
+      SHT_LOOS                    = 0x60000000
+      SHT_GNU_INCREMENTAL_INPUTS  = 0x6fff4700 # incremental build data
+      SHT_GNU_INCREMENTAL_SYMTAB  = 0x6fff4701 # incremental build data
+      SHT_GNU_INCREMENTAL_RELOCS  = 0x6fff4702 # incremental build data
+      SHT_GNU_INCREMENTAL_GOT_PLT = 0x6fff4703 # incremental build data
+      SHT_GNU_ATTRIBUTES          = 0x6ffffff5 # object attributes
+      SHT_GNU_HASH                = 0x6ffffff6 # GNU style symbol hash table
+      SHT_GNU_LIBLIST             = 0x6ffffff7 # list of prelink dependencies
+      SHT_SUNW_verdef             = 0x6ffffffd # versions defined by file
+      SHT_GNU_verdef              = 0x6ffffffd # versions defined by file
+      SHT_SUNW_verneed            = 0x6ffffffe # versions needed by file
+      SHT_GNU_verneed             = 0x6ffffffe # versions needed by file
+      SHT_SUNW_versym             = 0x6fffffff # symbol versions
+      SHT_GNU_versym              = 0x6fffffff # symbol versions
+      SHT_HIOS                    = 0x6fffffff # see {SHT_LOOS}
+
+      # Values between {SHT_LOPROC} and {SHT_HIPROC} are reserved for processor-specific semantics.
+      SHT_LOPROC                  = 0x70000000
+
+      SHT_SPARC_GOTDATA           = 0x70000000 # :nodoc:
+
+      SHT_ARM_EXIDX               = 0x70000001 # exception index table
+      SHT_ARM_PREEMPTMAP          = 0x70000002 # BPABI DLL dynamic linking pre-emption map
+      SHT_ARM_ATTRIBUTES          = 0x70000003 # object file compatibility attributes
+      SHT_ARM_DEBUGOVERLAY        = 0x70000004 # support for debugging overlaid programs
+      SHT_ARM_OVERLAYSECTION      = 0x70000005 # support for debugging overlaid programs
+
+      SHT_X86_64_UNWIND           = 0x70000001 # x86_64 unwind information
+
+      SHT_MIPS_LIBLIST            = 0x70000000 # set of dynamic shared objects
+      SHT_MIPS_MSYM               = 0x70000001 # :nodoc:
+      SHT_MIPS_CONFLICT           = 0x70000002 # list of symbols whose definitions conflict with shared objects
+      SHT_MIPS_GPTAB              = 0x70000003 # global pointer table
+      SHT_MIPS_UCODE              = 0x70000004 # microcode information
+      SHT_MIPS_DEBUG              = 0x70000005 # register usage information
+      SHT_MIPS_REGINFO            = 0x70000006 # section contains register usage information
+      SHT_MIPS_PACKAGE            = 0x70000007 # :nodoc:
+      SHT_MIPS_PACKSYM            = 0x70000008 # :nodoc:
+      SHT_MIPS_RELD               = 0x70000009 # :nodoc:
+      SHT_MIPS_IFACE              = 0x7000000b # interface information
+      SHT_MIPS_CONTENT            = 0x7000000c # description of contents of another section
+      SHT_MIPS_OPTIONS            = 0x7000000d # miscellaneous options
+      SHT_MIPS_SHDR               = 0x70000010 # :nodoc:
+      SHT_MIPS_FDESC              = 0x70000011 # :nodoc:
+      SHT_MIPS_EXTSYM             = 0x70000012 # :nodoc:
+      SHT_MIPS_DENSE              = 0x70000013 # :nodoc:
+      SHT_MIPS_PDESC              = 0x70000014 # :nodoc:
+      SHT_MIPS_LOCSYM             = 0x70000015 # :nodoc:
+      SHT_MIPS_AUXSYM             = 0x70000016 # :nodoc:
+      SHT_MIPS_OPTSYM             = 0x70000017 # :nodoc:
+      SHT_MIPS_LOCSTR             = 0x70000018 # :nodoc:
+      SHT_MIPS_LINE               = 0x70000019 # :nodoc:
+      SHT_MIPS_RFDESC             = 0x7000001a # :nodoc:
+      SHT_MIPS_DELTASYM           = 0x7000001b # delta C++ symbol table
+      SHT_MIPS_DELTAINST          = 0x7000001c # delta C++ instance table
+      SHT_MIPS_DELTACLASS         = 0x7000001d # delta C++ class table
+      SHT_MIPS_DWARF              = 0x7000001e # DWARF debugging section
+      SHT_MIPS_DELTADECL          = 0x7000001f # delta C++ declarations
+      SHT_MIPS_SYMBOL_LIB         = 0x70000020 # list of libraries the binary depends on
+      SHT_MIPS_EVENTS             = 0x70000021 # events section
+      SHT_MIPS_TRANSLATE          = 0x70000022 # :nodoc:
+      SHT_MIPS_PIXIE              = 0x70000023 # :nodoc:
+      SHT_MIPS_XLATE              = 0x70000024 # address translation table
+      SHT_MIPS_XLATE_DEBUG        = 0x70000025 # SGI internal address translation table
+      SHT_MIPS_WHIRL              = 0x70000026 # intermediate code
+      SHT_MIPS_EH_REGION          = 0x70000027 # C++ exception handling region info
+      SHT_MIPS_PDR_EXCEPTION      = 0x70000029 # runtime procedure descriptor table exception information
+      SHT_MIPS_ABIFLAGS           = 0x7000002a # ABI related flags
+      SHT_MIPS_XHASH              = 0x7000002b # GNU style symbol hash table with xlat
+
+      SHT_AARCH64_ATTRIBUTES      = 0x70000003 # :nodoc:
+
+      SHT_CSKY_ATTRIBUTES         = 0x70000001 # object file compatibility attributes
+
+      SHT_ORDERED                 = 0x7fffffff # :nodoc:
+
+      SHT_HIPROC                  = 0x7fffffff # see {SHT_LOPROC}
+
+      # Values between {SHT_LOUSER} and {SHT_HIUSER} are reserved for application programs.
+      SHT_LOUSER                  = 0x80000000
+      SHT_HIUSER                  = 0xffffffff # see {SHT_LOUSER}
+    end
+    include SHT
+
+    # Symbol binding from Sym st_info field.
+    module STB
+      STB_LOCAL      = 0 # Local symbol
+      STB_GLOBAL     = 1 # Global symbol
+      STB_WEAK       = 2 # Weak symbol
+      STB_NUM        = 3 # Number of defined types.
+      STB_LOOS       = 10 # Start of OS-specific
+      STB_GNU_UNIQUE = 10 # Unique symbol.
+      STB_HIOS       = 12 # End of OS-specific
+      STB_LOPROC     = 13 # Start of processor-specific
+      STB_HIPROC     = 15 # End of processor-specific
+    end
+    include STB
+
+    # Symbol types from Sym st_info field.
+    module STT
+      STT_NOTYPE         = 0 # Symbol type is unspecified
+      STT_OBJECT         = 1 # Symbol is a data object
+      STT_FUNC           = 2 # Symbol is a code object
+      STT_SECTION        = 3 # Symbol associated with a section
+      STT_FILE           = 4 # Symbol's name is file name
+      STT_COMMON         = 5 # Symbol is a common data object
+      STT_TLS            = 6 # Symbol is thread-local data object
+      STT_NUM            = 7 # Deprecated.
+      STT_RELC           = 8 # Complex relocation expression
+      STT_SRELC          = 9 # Signed Complex relocation expression
+
+      # GNU extension: symbol value points to a function which is called
+      # at runtime to determine the final value of the symbol.
+      STT_GNU_IFUNC      = 10
+
+      STT_LOOS           = 10 # Start of OS-specific
+      STT_HIOS           = 12 # End of OS-specific
+      STT_LOPROC         = 13 # Start of processor-specific
+      STT_HIPROC         = 15 # End of processor-specific
+
+      # The section type that must be used for register symbols on
+      # Sparc. These symbols initialize a global register.
+      STT_SPARC_REGISTER = 13
+
+      # ARM: a THUMB function. This is not defined in ARM ELF Specification but
+      # used by the GNU tool-chain.
+      STT_ARM_TFUNC      = 13
+      STT_ARM_16BIT      = 15 # ARM: a THUMB label.
+    end
+    include STT
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/dynamic.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/dynamic.rb
similarity index 99%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/dynamic.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/dynamic.rb
index 3295504cb5d96..33791f3edf358 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/dynamic.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/dynamic.rb
@@ -96,7 +96,7 @@ def tag_at(n)
       @tag_at_map ||= {}
       return @tag_at_map[n] if @tag_at_map[n]
 
-      dyn = Structs::ELF_Dyn.new(endian: endian)
+      dyn = Structs::ELF_Dyn.new(endian:)
       dyn.elf_class = header.elf_class
       stream.pos = tag_start + n * dyn.num_bytes
       dyn.offset = stream.pos
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/elf_file.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/elf_file.rb
similarity index 96%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/elf_file.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/elf_file.rb
index 5f6fa229e0ec3..63d351d68a5fe 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/elf_file.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/elf_file.rb
@@ -36,7 +36,7 @@ def header
       return @header if defined?(@header)
 
       stream.pos = 0
-      @header = Structs::ELF_Ehdr.new(endian: endian, offset: stream.pos)
+      @header = Structs::ELF_Ehdr.new(endian:, offset: stream.pos)
       @header.elf_class = elf_class
       @header.read(stream)
     end
@@ -237,7 +237,7 @@ def segments
     #   #=>  #<ELFTools::Segments::NoteSegment:0x005629dda1e4f8>
     #
     #   # this is ok
-    #   elf.segment_by_type('note') # will be tranformed into `PT_NOTE`
+    #   elf.segment_by_type('note') # will be transformed into `PT_NOTE`
     #   #=>  #<ELFTools::Segments::NoteSegment:0x005629dda1e4f8>
     # @example
     #   elf.segment_by_type(1337)
@@ -290,7 +290,7 @@ def segment_at(n)
     #   elf = ELFTools::ELFFile.new(File.open('/bin/cat'))
     #   elf.offset_from_vma(0x401337)
     #   #=> 4919 # 0x1337
-    def offset_from_vma(vma, size = 0)
+    def offset_from_vma(vma, size = 1)
       segments_by_type(:load) do |seg|
         return seg.vma_to_offset(vma) if seg.vma_in?(vma, size)
       end
@@ -318,7 +318,7 @@ def save(filename)
       patches.each do |pos, val|
         all[pos, val.size] = val
       end
-      IO.binwrite(filename, all)
+      File.binwrite(filename, all)
     end
 
     private
@@ -358,7 +358,7 @@ def identify
 
     def create_section(n)
       stream.pos = header.e_shoff + n * header.e_shentsize
-      shdr = Structs::ELF_Shdr.new(endian: endian, offset: stream.pos)
+      shdr = Structs::ELF_Shdr.new(endian:, offset: stream.pos)
       shdr.elf_class = elf_class
       shdr.read(stream)
       Sections::Section.create(shdr, stream,
@@ -369,7 +369,7 @@ def create_section(n)
 
     def create_segment(n)
       stream.pos = header.e_phoff + n * header.e_phentsize
-      phdr = Structs::ELF_Phdr[elf_class].new(endian: endian, offset: stream.pos)
+      phdr = Structs::ELF_Phdr[elf_class].new(endian:, offset: stream.pos)
       phdr.elf_class = elf_class
       Segments::Segment.create(phdr.read(stream), stream, offset_from_vma: method(:offset_from_vma))
     end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/exceptions.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/exceptions.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/exceptions.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/exceptions.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/lazy_array.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/lazy_array.rb
similarity index 84%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/lazy_array.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/lazy_array.rb
index f272e0a9335a2..ecb300d9bb8f9 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/lazy_array.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/lazy_array.rb
@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require 'delegate'
+
 module ELFTools
   # A helper class for {ELFTools} easy to implement
   # 'lazy loading' objects.
   # Mainly used when loading sections, segments, and
   # symbols.
-  class LazyArray
+  class LazyArray < SimpleDelegator
     # Instantiate a {LazyArray} object.
     # @param [Integer] size
     #   The size of array.
@@ -26,7 +28,7 @@ class LazyArray
     #   p arr[3]
     #   # 9
     def initialize(size, &block)
-      @internal = Array.new(size)
+      super(Array.new(size))
       @block = block
     end
 
@@ -39,9 +41,9 @@ def initialize(size, &block)
     #   return type of block given in {#initialize}.
     def [](i)
       # XXX: support negative index?
-      return nil unless i.between?(0, @internal.size - 1)
+      return nil unless i.between?(0, __getobj__.size - 1)
 
-      @internal[i] ||= @block.call(i)
+      __getobj__[i] ||= @block.call(i)
     end
   end
 end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/note.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/note.rb
similarity index 97%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/note.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/note.rb
index 5eae0338f75da..d71dc23a67f85 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/note.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/note.rb
@@ -79,7 +79,7 @@ def endian
     end
 
     def create_note(cur)
-      nhdr = Structs::ELF_Nhdr.new(endian: endian, offset: stream.pos).read(stream)
+      nhdr = Structs::ELF_Nhdr.new(endian:, offset: stream.pos).read(stream)
       ELFTools::Note::Note.new(nhdr, stream, cur)
     end
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/dynamic_section.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/dynamic_section.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/dynamic_section.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/dynamic_section.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/note_section.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/note_section.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/note_section.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/note_section.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/null_section.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/null_section.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/null_section.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/null_section.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/relocation_section.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/relocation_section.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/relocation_section.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/relocation_section.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/section.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/section.rb
new file mode 100644
index 0000000000000..8eb5892a4c64d
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/section.rb
@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'elftools/constants'
+module ELFTools
+  module Sections
+    # Base class of sections.
+    class Section
+      attr_reader :header # @return [ELFTools::Structs::ELF_Shdr] Section header.
+      attr_reader :stream # @return [#pos=, #read] Streaming object.
+
+      # Instantiate a {Section} object.
+      # @param [ELFTools::Structs::ELF_Shdr] header
+      #   The section header object.
+      # @param [#pos=, #read] stream
+      #   The streaming object for further dump.
+      # @param [ELFTools::Sections::StrTabSection, Proc] strtab
+      #   The string table object. For fetching section names.
+      #   If +Proc+ if given, it will call at the first
+      #   time access +#name+.
+      # @param [Method] offset_from_vma
+      #   The method to get offset of file, given virtual memory address.
+      def initialize(header, stream, offset_from_vma: nil, strtab: nil, **_kwargs)
+        @header = header
+        @stream = stream
+        @strtab = strtab
+        @offset_from_vma = offset_from_vma
+      end
+
+      # Return +header.sh_type+ in a simpler way.
+      # @return [Integer]
+      #   The type, meaning of types are defined in {Constants::SHT}.
+      def type
+        header.sh_type.to_i
+      end
+
+      # Get name of this section.
+      # @return [String] The name.
+      def name
+        @name ||= @strtab.call.name_at(header.sh_name)
+      end
+
+      # Fetch data of this section.
+      # @return [String] Data.
+      def data
+        stream.pos = header.sh_offset
+        stream.read(header.sh_size)
+      end
+
+      # Is this a null section?
+      # @return [Boolean] No it's not.
+      def null?
+        false
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/sections.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/sections.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/sections.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/sections.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/str_tab_section.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/str_tab_section.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/str_tab_section.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/str_tab_section.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/sym_tab_section.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/sym_tab_section.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/sections/sym_tab_section.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/sections/sym_tab_section.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/segments/dynamic_segment.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/segments/dynamic_segment.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/segments/dynamic_segment.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/segments/dynamic_segment.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/segments/interp_segment.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/segments/interp_segment.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/segments/interp_segment.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/segments/interp_segment.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/segments/load_segment.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/segments/load_segment.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/segments/load_segment.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/segments/load_segment.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/segments/note_segment.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/segments/note_segment.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/segments/note_segment.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/segments/note_segment.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/segments/segment.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/segments/segment.rb
similarity index 89%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/segments/segment.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/segments/segment.rb
index b575e31cc9b6e..b5d751ca5eaa7 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/segments/segment.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/segments/segment.rb
@@ -20,7 +20,7 @@ def initialize(header, stream, offset_from_vma: nil)
         @offset_from_vma = offset_from_vma
       end
 
-      # Return +header.p_type+ in a simplier way.
+      # Return +header.p_type+ in a simpler way.
       # @return [Integer]
       #   The type, meaning of types are defined in {Constants::PT}.
       def type
@@ -35,19 +35,19 @@ def data
       end
 
       # Is this segment readable?
-      # @return [Boolean] Ture or false.
+      # @return [Boolean] True or false.
       def readable?
         (header.p_flags & 4) == 4
       end
 
       # Is this segment writable?
-      # @return [Boolean] Ture or false.
+      # @return [Boolean] True or false.
       def writable?
         (header.p_flags & 2) == 2
       end
 
       # Is this segment executable?
-      # @return [Boolean] Ture or false.
+      # @return [Boolean] True or false.
       def executable?
         (header.p_flags & 1) == 1
       end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/segments/segments.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/segments/segments.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/segments/segments.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/segments/segments.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/structs.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/structs.rb
similarity index 82%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/structs.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/structs.rb
index c7213bba8d56d..6ac7803204e3d 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/structs.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/structs.rb
@@ -11,9 +11,9 @@ module Structs
     # The base structure to define common methods.
     class ELFStruct < BinData::Record
       # DRY. Many fields have different type in different arch.
-      CHOICE_SIZE_T = {
-        selection: :elf_class, choices: { 32 => :uint32, 64 => :uint64 }
-      }.freeze
+      CHOICE_SIZE_T = proc do |t = 'uint'|
+        { selection: :elf_class, choices: { 32 => :"#{t}32", 64 => :"#{t}64" }, copy_on_change: true }
+      end
 
       attr_accessor :elf_class # @return [Integer] 32 or 64.
       attr_accessor :offset # @return [Integer] The file offset of this header.
@@ -24,6 +24,9 @@ def patches
         @patches ||= {}
       end
 
+      # BinData hash(Snapshot) that behaves like HashWithIndifferentAccess
+      alias to_h snapshot
+
       class << self
         # Hooks the constructor.
         #
@@ -51,7 +54,7 @@ def new(*args)
         # Gets the endianness of current class.
         # @return [:little, :big] The endianness.
         def self_endian
-          bindata_name[-2..-1] == 'be' ? :big : :little
+          bindata_name[-2..] == 'be' ? :big : :little
         end
 
         # Packs an integer to string.
@@ -89,9 +92,9 @@ class ELF_Ehdr < ELFStruct
       uint16 :e_machine
       uint32 :e_version
       # entry point
-      choice :e_entry, **CHOICE_SIZE_T
-      choice :e_phoff, **CHOICE_SIZE_T
-      choice :e_shoff, **CHOICE_SIZE_T
+      choice :e_entry, **CHOICE_SIZE_T['uint']
+      choice :e_phoff, **CHOICE_SIZE_T['uint']
+      choice :e_shoff, **CHOICE_SIZE_T['uint']
       uint32 :e_flags
       uint16 :e_ehsize # size of this header
       uint16 :e_phentsize # size of each segment
@@ -106,14 +109,14 @@ class ELF_Shdr < ELFStruct
       endian :big_and_little
       uint32 :sh_name
       uint32 :sh_type
-      choice :sh_flags, **CHOICE_SIZE_T
-      choice :sh_addr, **CHOICE_SIZE_T
-      choice :sh_offset, **CHOICE_SIZE_T
-      choice :sh_size, **CHOICE_SIZE_T
+      choice :sh_flags, **CHOICE_SIZE_T['uint']
+      choice :sh_addr, **CHOICE_SIZE_T['uint']
+      choice :sh_offset, **CHOICE_SIZE_T['uint']
+      choice :sh_size, **CHOICE_SIZE_T['uint']
       uint32 :sh_link
       uint32 :sh_info
-      choice :sh_addralign, **CHOICE_SIZE_T
-      choice :sh_entsize, **CHOICE_SIZE_T
+      choice :sh_addralign, **CHOICE_SIZE_T['uint']
+      choice :sh_entsize, **CHOICE_SIZE_T['uint']
     end
 
     # Program header structure for 32-bit.
@@ -187,25 +190,30 @@ class ELF_Nhdr < ELFStruct
     # Dynamic tag header.
     class ELF_Dyn < ELFStruct
       endian :big_and_little
-      choice :d_tag, selection: :elf_class, choices: { 32 => :int32, 64 => :int64 }
+      choice :d_tag, **CHOICE_SIZE_T['int']
       # This is an union type named +d_un+ in original source,
       # simplify it to be +d_val+ here.
-      choice :d_val, **CHOICE_SIZE_T
+      choice :d_val, **CHOICE_SIZE_T['uint']
     end
 
     # Rel header in .rel section.
     class ELF_Rel < ELFStruct
       endian :big_and_little
-      choice :r_offset, **CHOICE_SIZE_T
-      choice :r_info, **CHOICE_SIZE_T
+      choice :r_offset, **CHOICE_SIZE_T['uint']
+      choice :r_info, **CHOICE_SIZE_T['uint']
+
+      # Compatibility with ELF_Rela, both can be used interchangeably
+      def r_addend
+        nil
+      end
     end
 
     # Rela header in .rela section.
     class ELF_Rela < ELFStruct
       endian :big_and_little
-      choice :r_offset, **CHOICE_SIZE_T
-      choice :r_info, **CHOICE_SIZE_T
-      choice :r_addend, selection: :elf_class, choices: { 32 => :int32, 64 => :int64 }
+      choice :r_offset, **CHOICE_SIZE_T['uint']
+      choice :r_info, **CHOICE_SIZE_T['uint']
+      choice :r_addend, **CHOICE_SIZE_T['int']
     end
   end
 end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/util.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/util.rb
similarity index 96%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/util.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/util.rb
index 37727634a1d5b..ca25946692630 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/elftools-1.1.3/lib/elftools/util.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/util.rb
@@ -5,7 +5,7 @@ module ELFTools
   module Util
     # Class methods.
     module ClassMethods
-      # Round up the number to be mulitple of
+      # Round up the number to be multiple of
       # +2**bit+.
       # @param [Integer] num Number to be rounded-up.
       # @param [Integer] bit How many bit to be aligned.
@@ -44,7 +44,7 @@ def to_constant(mod, val)
         end
         val = val.to_s.upcase
         prefix = module_name.split('::')[-1]
-        val = prefix + '_' + val unless val.start_with?(prefix)
+        val = "#{prefix}_#{val}" unless val.start_with?(prefix)
         val = val.to_sym
         raise ArgumentError, "No constants in #{module_name} named \"#{val}\"" unless mod.const_defined?(val)
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/version.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/version.rb
new file mode 100644
index 0000000000000..7ebb74462e6d4
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/elftools-1.3.1/lib/elftools/version.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ELFTools
+  # Current gem version
+  VERSION = '1.3.1'
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/alt_saver.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/alt_saver.rb
new file mode 100644
index 0000000000000..9ac38864911fc
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/alt_saver.rb
@@ -0,0 +1,1053 @@
+# frozen_string_literal: true
+
+require 'elftools/constants'
+require 'elftools/elf_file'
+require 'elftools/structs'
+require 'elftools/util'
+require 'fileutils'
+
+require 'patchelf/helper'
+
+# :nodoc:
+module PatchELF
+  # TODO: refactor buf_* methods here
+  # TODO: move all refinements into a separate file / helper file.
+  # refinements for cleaner syntax / speed / memory optimizations
+  module Refinements
+    refine StringIO do
+      # behaves like C memset. Equivalent to calling stream.write(char * nbytes)
+      # the benefit of preferring this over `stream.write(char * nbytes)` is only when data to be written is large.
+      # @param [String] char
+      # @param [Integer] nbytes
+      # @return[void]
+      def fill(char, nbytes)
+        at_once = Helper.page_size
+        pending = nbytes
+
+        if pending > at_once
+          to_write = char * at_once
+          while pending >= at_once
+            write(to_write)
+            pending -= at_once
+          end
+        end
+        write(char * pending) if pending.positive?
+      end
+    end
+  end
+  using Refinements
+
+  # Internal use only.
+  # alternative to +Saver+, that aims to be byte to byte equivalent with NixOS/patchelf.
+  #
+  # *DISCLAIMER*: This differs from +Saver+ in number of ways.  No lazy reading,
+  # inconsistent use of existing internal API(e.g: manual reading of data instead of calling +section.data+)
+  # @private
+  class AltSaver
+    attr_reader :in_file # @return [String] Input filename.
+    attr_reader :out_file # @return [String] Output filename.
+
+    # Instantiate a {AltSaver} object.
+    # the params passed are the same as the ones passed to +Saver+
+    # @param [String] in_file
+    # @param [String] out_file
+    # @param [{Symbol => String, Array}] set
+    def initialize(in_file, out_file, set)
+      @in_file = in_file
+      @out_file = out_file
+      @set = set
+
+      f = File.open(in_file, 'rb')
+      # the +@buffer+ and +@elf+ both could work on same +StringIO+ stream,
+      # the updating of @buffer in place blocks us from looking up old values.
+      # TODO: cache the values needed later, use same stream for +@buffer+ and +@elf+.
+      # also be sure to update the stream offset passed to Segments::Segment.
+      @elf = ELFTools::ELFFile.new(f)
+      @buffer = StringIO.new(f.tap(&:rewind).read) # StringIO makes easier to work with Bindata
+
+      @ehdr = @elf.header
+      @endian = @elf.endian
+      @elf_class = @elf.elf_class
+
+      @segments = @elf.segments # usage similar to phdrs
+      @sections = @elf.sections # usage similar to shdrs
+      update_section_idx!
+
+      # {String => String}
+      # section name to its data mapping
+      @replaced_sections = {}
+      @section_alignment = ehdr.e_phoff.num_bytes
+
+      # using the same environment flag as patchelf, makes it easier for debugging
+      Logger.level = ::Logger.const_get(ENV['PATCHELF_DEBUG'] ? :DEBUG : :WARN)
+    end
+
+    # @return [void]
+    def save!
+      @set.each { |mtd, val| send(:"modify_#{mtd}") if val }
+      rewrite_sections
+
+      FileUtils.cp(in_file, out_file) if out_file != in_file
+      patch_out
+      # Let output file have the same permission as input.
+      FileUtils.chmod(File.stat(in_file).mode, out_file)
+    end
+
+    private
+
+    attr_reader :ehdr, :endian, :elf_class
+
+    def old_sections
+      @old_sections ||= @elf.sections
+    end
+
+    def buf_cstr(off)
+      cstr = []
+      with_buf_at(off) do |buf|
+        loop do
+          c = buf.read 1
+          break if c.nil? || c == "\x00"
+
+          cstr.push c
+        end
+      end
+      cstr.join
+    end
+
+    def buf_move!(dst_idx, src_idx, n_bytes)
+      with_buf_at(src_idx) do |buf|
+        to_write = buf.read(n_bytes)
+        buf.seek dst_idx
+        buf.write to_write
+      end
+    end
+
+    def dynstr
+      find_section '.dynstr'
+    end
+
+    # yields dynamic tag, and offset in buffer
+    def each_dynamic_tags
+      return unless block_given?
+
+      sec = find_section '.dynamic'
+      return unless sec
+
+      return if sec.header.sh_type == ELFTools::Constants::SHT_NOBITS
+
+      shdr = sec.header
+      with_buf_at(shdr.sh_offset) do |buf|
+        dyn = ELFTools::Structs::ELF_Dyn.new(elf_class: elf_class, endian: endian)
+        loop do
+          buf_dyn_offset = buf.tell
+          dyn.clear
+          dyn.read(buf)
+          break if dyn.d_tag == ELFTools::Constants::DT_NULL
+
+          yield dyn, buf_dyn_offset
+          # there's a possibility for caller to modify @buffer.pos, seek to avoid such issues
+          buf.seek buf_dyn_offset + dyn.num_bytes
+        end
+      end
+    end
+
+    # the idea of uniquely identifying section by its name has its problems
+    # but this is how patchelf operates and is prone to bugs.
+    # e.g: https://github.com/NixOS/patchelf/issues/197
+    def find_section(sec_name)
+      idx = find_section_idx sec_name
+      return unless idx
+
+      @sections[idx]
+    end
+
+    def find_section_idx(sec_name)
+      @section_idx_by_name[sec_name]
+    end
+
+    def buf_grow!(newsz)
+      bufsz = @buffer.size
+      return if newsz <= bufsz
+
+      @buffer.truncate newsz
+    end
+
+    def modify_interpreter
+      @replaced_sections['.interp'] = "#{@set[:interpreter]}\x00"
+    end
+
+    def modify_needed
+      # due to gsoc time constraints only implementing features used by brew.
+      raise NotImplementedError
+    end
+
+    # not checking for nil as modify_rpath is only called if @set[:rpath]
+    def modify_rpath
+      modify_rpath_helper @set[:rpath], force_rpath: true
+    end
+
+    # not checking for nil as modify_runpath is only called if @set[:runpath]
+    def modify_runpath
+      modify_rpath_helper @set[:runpath]
+    end
+
+    def collect_runpath_tags
+      tags = {}
+      each_dynamic_tags do |dyn, off|
+        case dyn.d_tag
+        when ELFTools::Constants::DT_RPATH
+          tag_type = :rpath
+        when ELFTools::Constants::DT_RUNPATH
+          tag_type = :runpath
+        else
+          next
+        end
+
+        # clone does shallow copy, and for some reason d_tag and d_val can't be pass as argument
+        dyn_rpath = ELFTools::Structs::ELF_Dyn.new(endian: endian, elf_class: elf_class)
+        dyn_rpath.assign({ d_tag: dyn.d_tag.to_i, d_val: dyn.d_val.to_i })
+        tags[tag_type] = { offset: off, header: dyn_rpath }
+      end
+      tags
+    end
+
+    def resolve_rpath_tag_conflict(dyn_tags, force_rpath: false)
+      dyn_runpath, dyn_rpath = dyn_tags.values_at(:runpath, :rpath)
+
+      update_sym =
+        if !force_rpath && dyn_rpath && dyn_runpath.nil?
+          :runpath
+        elsif force_rpath && dyn_runpath
+          :rpath
+        end
+      return unless update_sym
+
+      delete_sym, = %i[rpath runpath] - [update_sym]
+      dyn_tag = dyn_tags[update_sym] = dyn_tags[delete_sym]
+      dyn = dyn_tag[:header]
+      dyn.d_tag = ELFTools::Constants.const_get("DT_#{update_sym.upcase}")
+      with_buf_at(dyn_tag[:offset]) { |buf| dyn.write(buf) }
+      dyn_tags.delete(delete_sym)
+    end
+
+    def modify_rpath_helper(new_rpath, force_rpath: false)
+      shdr_dynstr = dynstr.header
+
+      dyn_tags = collect_runpath_tags
+      resolve_rpath_tag_conflict(dyn_tags, force_rpath: force_rpath)
+      # (:runpath, :rpath) order_matters.
+      resolved_rpath_dyn = dyn_tags.values_at(:runpath, :rpath).compact.first
+
+      old_rpath = ''
+      rpath_off = nil
+      if resolved_rpath_dyn
+        rpath_off = shdr_dynstr.sh_offset + resolved_rpath_dyn[:header].d_val
+        old_rpath = buf_cstr(rpath_off)
+      end
+      return if old_rpath == new_rpath
+
+      with_buf_at(rpath_off) { |b| b.write('X' * old_rpath.size) } if rpath_off
+      if new_rpath.size <= old_rpath.size
+        with_buf_at(rpath_off) { |b| b.write "#{new_rpath}\x00" }
+        return
+      end
+
+      Logger.debug 'rpath is too long, resizing...'
+      new_dynstr = replace_section '.dynstr', shdr_dynstr.sh_size + new_rpath.size + 1
+      new_rpath_strtab_idx = shdr_dynstr.sh_size.to_i
+      new_dynstr[new_rpath_strtab_idx..(new_rpath_strtab_idx + new_rpath.size)] = "#{new_rpath}\x00"
+
+      dyn_tags.each_value do |dyn|
+        dyn[:header].d_val = new_rpath_strtab_idx
+        with_buf_at(dyn[:offset]) { |b| dyn[:header].write(b) }
+      end
+
+      return unless dyn_tags.empty?
+
+      add_dt_rpath!(
+        d_tag: force_rpath ? ELFTools::Constants::DT_RPATH : ELFTools::Constants::DT_RUNPATH,
+        d_val: new_rpath_strtab_idx
+      )
+    end
+
+    def modify_soname
+      return unless ehdr.e_type == ELFTools::Constants::ET_DYN
+
+      # due to gsoc time constraints only implementing features used by brew.
+      raise NotImplementedError
+    end
+
+    def add_segment!(**phdr_vals)
+      new_phdr = ELFTools::Structs::ELF_Phdr[elf_class].new(endian: endian, **phdr_vals)
+      # nil = no reference to stream; we only want @segments[i].header
+      new_segment = ELFTools::Segments::Segment.new(new_phdr, nil)
+      @segments.push new_segment
+      ehdr.e_phnum += 1
+      nil
+    end
+
+    def add_dt_rpath!(d_tag: nil, d_val: nil)
+      dyn_num_bytes = nil
+      dt_null_idx = 0
+      each_dynamic_tags do |dyn|
+        dyn_num_bytes ||= dyn.num_bytes
+        dt_null_idx += 1
+      end
+
+      if dyn_num_bytes.nil?
+        Logger.error 'no dynamic tags'
+        return
+      end
+
+      # allot for new dt_runpath
+      shdr_dynamic = find_section('.dynamic').header
+      new_dynamic_data = replace_section '.dynamic', shdr_dynamic.sh_size + dyn_num_bytes
+
+      # consider DT_NULL when copying
+      replacement_size = (dt_null_idx + 1) * dyn_num_bytes
+
+      # make space for dt_runpath tag at the top, shift data by one tag position
+      new_dynamic_data[dyn_num_bytes..(replacement_size + dyn_num_bytes)] = new_dynamic_data[0..replacement_size]
+
+      dyn_rpath = ELFTools::Structs::ELF_Dyn.new endian: endian, elf_class: elf_class
+      dyn_rpath.d_tag = d_tag
+      dyn_rpath.d_val = d_val
+
+      zi = StringIO.new
+      dyn_rpath.write zi
+      zi.rewind
+      new_dynamic_data[0...dyn_num_bytes] = zi.read
+    end
+
+    # given a index into old_sections table
+    # returns the corresponding section index in @sections
+    #
+    # raises ArgumentError if old_shndx can't be found in old_sections
+    # TODO: handle case of non existing section in (new) @sections.
+    def new_section_idx(old_shndx)
+      return if old_shndx == ELFTools::Constants::SHN_UNDEF || old_shndx >= ELFTools::Constants::SHN_LORESERVE
+
+      raise ArgumentError if old_shndx >= old_sections.count
+
+      old_sec = old_sections[old_shndx]
+      raise PatchError, "old_sections[#{shndx}] is nil" if old_sec.nil?
+
+      # TODO: handle case of non existing section in (new) @sections.
+      find_section_idx(old_sec.name)
+    end
+
+    def page_size
+      Helper.page_size(ehdr.e_machine)
+    end
+
+    def patch_out
+      with_buf_at(0) { |b| ehdr.write(b) }
+
+      File.open(out_file, 'wb') do |f|
+        @buffer.rewind
+        f.write @buffer.read
+      end
+    end
+
+    # size includes NUL byte
+    def replace_section(section_name, size)
+      data = @replaced_sections[section_name]
+      unless data
+        shdr = find_section(section_name).header
+        # avoid calling +section.data+ as the @buffer contents may vary from
+        # the stream provided to section at initialization.
+        # ideally, calling section.data should work, however avoiding it to prevent
+        # future traps.
+        with_buf_at(shdr.sh_offset) { |b| data = b.read shdr.sh_size }
+      end
+      rep_data = if data.size == size
+                   data
+                 elsif data.size < size
+                   data.ljust(size, "\x00")
+                 else
+                   "#{data[0...size]}\x00"
+                 end
+      @replaced_sections[section_name] = rep_data
+    end
+
+    def write_phdrs_to_buf!
+      sort_phdrs!
+      with_buf_at(ehdr.e_phoff) do |buf|
+        @segments.each { |seg| seg.header.write(buf) }
+      end
+    end
+
+    def write_shdrs_to_buf!
+      raise PatchError, 'ehdr.e_shnum != @sections.count' if ehdr.e_shnum != @sections.count
+
+      sort_shdrs!
+      with_buf_at(ehdr.e_shoff) do |buf|
+        @sections.each { |section| section.header.write(buf) }
+      end
+      sync_dyn_tags!
+    end
+
+    # data for manual packing and unpacking of symbols in symtab sections.
+    def meta_sym_pack
+      return @meta_sym_pack if @meta_sym_pack
+
+      # resort to manual packing and unpacking of data,
+      # as using bindata is painfully slow :(
+      if elf_class == 32
+        sym_num_bytes = 16 # u32 u32 u32 u8 u8 u16
+        pack_code = endian == :little ? 'VVVCCv' : 'NNNCCn'
+        pack_st_info = 3
+        pack_st_shndx = 5
+        pack_st_value = 1
+      else # 64
+        sym_num_bytes = 24 # u32 u8 u8 u16 u64 u64
+        pack_code = endian == :little ? 'VCCvQ<Q<' : 'NCCnQ>Q>'
+        pack_st_info = 1
+        pack_st_shndx = 3
+        pack_st_value = 4
+      end
+
+      @meta_sym_pack = {
+        num_bytes: sym_num_bytes, code: pack_code,
+        st_info: pack_st_info, st_shndx: pack_st_shndx, st_value: pack_st_value
+      }
+    end
+
+    # yields +symbol+, +entry+
+    def each_symbol(shdr)
+      return unless [ELFTools::Constants::SHT_SYMTAB, ELFTools::Constants::SHT_DYNSYM].include?(shdr.sh_type)
+
+      pack_code, sym_num_bytes = meta_sym_pack.values_at(:code, :num_bytes)
+
+      with_buf_at(shdr.sh_offset) do |buf|
+        num_symbols = shdr.sh_size / sym_num_bytes
+        num_symbols.times do |entry|
+          sym = buf.read(sym_num_bytes).unpack(pack_code)
+          sym_modified = yield sym, entry
+
+          if sym_modified
+            buf.seek buf.tell - sym_num_bytes
+            buf.write sym.pack(pack_code)
+          end
+        end
+      end
+    end
+
+    def rewrite_headers(phdr_address)
+      # there can only be a single program header table according to ELF spec
+      @segments.find { |seg| seg.header.p_type == ELFTools::Constants::PT_PHDR }&.tap do |seg|
+        phdr = seg.header
+        phdr.p_offset = ehdr.e_phoff.to_i
+        phdr.p_vaddr = phdr.p_paddr = phdr_address.to_i
+        phdr.p_filesz = phdr.p_memsz = phdr.num_bytes * @segments.count # e_phentsize * e_phnum
+      end
+      write_phdrs_to_buf!
+      write_shdrs_to_buf!
+
+      pack = meta_sym_pack
+      @sections.each do |sec|
+        each_symbol(sec.header) do |sym, entry|
+          old_shndx = sym[pack[:st_shndx]]
+
+          begin
+            new_index = new_section_idx(old_shndx)
+          rescue ArgumentError
+            Logger.warn "entry #{entry} in symbol table refers to a non existing section, skipping"
+          end
+          next unless new_index
+
+          sym[pack[:st_shndx]] = new_index
+
+          # right 4 bits in the st_info field is st_type
+          if (sym[pack[:st_info]] & 0xF) == ELFTools::Constants::STT_SECTION
+            sym[pack[:st_value]] = @sections[new_index].header.sh_addr.to_i
+          end
+          true
+        end
+      end
+    end
+
+    def rewrite_sections
+      return if @replaced_sections.empty?
+
+      case ehdr.e_type
+      when ELFTools::Constants::ET_DYN
+        rewrite_sections_library
+      when ELFTools::Constants::ET_EXEC
+        rewrite_sections_executable
+      else
+        raise PatchError, 'unknown ELF type'
+      end
+    end
+
+    def replaced_section_indices
+      return enum_for(:replaced_section_indices) unless block_given?
+
+      last_replaced = 0
+      @sections.each_with_index do |sec, idx|
+        if @replaced_sections[sec.name]
+          last_replaced = idx
+          yield last_replaced
+        end
+      end
+      raise PatchError, 'last_replaced = 0' if last_replaced.zero?
+      raise PatchError, 'last_replaced + 1 >= @sections.size' if last_replaced + 1 >= @sections.size
+    end
+
+    def start_replacement_shdr
+      last_replaced = replaced_section_indices.max
+      start_replacement_hdr = @sections[last_replaced + 1].header
+
+      prev_sec_name = ''
+      (1..last_replaced).each do |idx|
+        sec = @sections[idx]
+        shdr = sec.header
+        if (sec.type == ELFTools::Constants::SHT_PROGBITS && sec.name != '.interp') || prev_sec_name == '.dynstr'
+          start_replacement_hdr = shdr
+          break
+        elsif @replaced_sections[sec.name].nil?
+          Logger.debug " replacing section #{sec.name} which is in the way"
+          replace_section(sec.name, shdr.sh_size)
+        end
+        prev_sec_name = sec.name
+      end
+
+      start_replacement_hdr
+    end
+
+    def copy_shdrs_to_eof
+      shoff_new = @buffer.size
+      # honestly idk why `ehdr.e_shoff` is considered when we are only moving shdrs.
+      sh_size = ehdr.e_shoff + (ehdr.e_shnum * ehdr.e_shentsize)
+      buf_grow! @buffer.size + sh_size
+      ehdr.e_shoff = shoff_new
+      raise PatchError, 'ehdr.e_shnum != @sections.size' if ehdr.e_shnum != @sections.size
+
+      with_buf_at(ehdr.e_shoff + @sections.first.header.num_bytes) do |buf| # skip writing to NULL section
+        @sections.each_with_index do |sec, idx|
+          next if idx.zero?
+
+          sec.header.write buf
+        end
+      end
+    end
+
+    def rewrite_sections_executable
+      sort_shdrs!
+      shdr = start_replacement_shdr
+      start_offset = shdr.sh_offset.to_i
+      start_addr = shdr.sh_addr.to_i
+      first_page = start_addr - start_offset
+
+      Logger.debug "first reserved offset/addr is 0x#{start_offset.to_s 16}/0x#{start_addr.to_s 16}"
+
+      unless start_addr % page_size == start_offset % page_size
+        raise PatchError, 'start_addr != start_offset (mod PAGE_SIZE)'
+      end
+
+      Logger.debug "first page is 0x#{first_page.to_i.to_s 16}"
+
+      copy_shdrs_to_eof if ehdr.e_shoff < start_offset
+
+      normalize_note_segments
+
+      seg_num_bytes = @segments.first.header.num_bytes
+      needed_space = (
+        ehdr.num_bytes +
+        (@segments.count * seg_num_bytes) +
+        @replaced_sections.sum { |_, str| Helper.alignup(str.size, @section_alignment) }
+      )
+
+      if needed_space > start_offset
+        needed_space += seg_num_bytes # new load segment is required
+
+        extra_bytes = needed_space - start_offset
+        needed_pages = Helper.alignup(extra_bytes, page_size) / page_size
+        Logger.debug "needed pages is #{needed_pages}"
+        raise PatchError, 'virtual address space underrun' if needed_pages * page_size > first_page
+
+        shift_file(needed_pages, start_offset, extra_bytes)
+
+        first_page -= needed_pages * page_size
+        start_offset += needed_pages * page_size
+      end
+      Logger.debug "needed space is #{needed_space}"
+
+      cur_off = ehdr.num_bytes + (@segments.count * seg_num_bytes)
+      Logger.debug "clearing first #{start_offset - cur_off} bytes"
+      with_buf_at(cur_off) { |buf| buf.fill("\x00", (start_offset - cur_off)) }
+
+      cur_off = write_replaced_sections cur_off, first_page, 0
+      raise PatchError, "cur_off(#{cur_off}) != needed_space" if cur_off != needed_space
+
+      rewrite_headers first_page + ehdr.e_phoff
+    end
+
+    def replace_sections_in_the_way_of_phdr!
+      num_notes = @sections.count { |sec| sec.type == ELFTools::Constants::SHT_NOTE }
+      pht_size = ehdr.num_bytes + ((@segments.count + num_notes + 1) * @segments.first.header.num_bytes)
+
+      # replace sections that may overlap with expanded program header table
+      @sections.each_with_index do |sec, idx|
+        shdr = sec.header
+        next if idx.zero? || @replaced_sections[sec.name]
+        break if shdr.sh_offset > pht_size
+
+        replace_section sec.name, shdr.sh_size
+      end
+    end
+
+    def rewrite_sections_library
+      start_page = 0
+      first_page = 0
+      @segments.each do |seg|
+        phdr = seg.header
+        this_page = Helper.alignup(phdr.p_vaddr + phdr.p_memsz, page_size)
+        start_page = [start_page, this_page].max
+        first_page = phdr.p_vaddr - phdr.p_offset if phdr.p_type == ELFTools::Constants::PT_PHDR
+      end
+
+      Logger.debug "Last page is 0x#{start_page.to_s 16}"
+      Logger.debug "First page is 0x#{first_page.to_s 16}"
+      replace_sections_in_the_way_of_phdr!
+      needed_space = @replaced_sections.sum { |_, str| Helper.alignup(str.size, @section_alignment) }
+      Logger.debug "needed space = #{needed_space}"
+
+      start_offset = Helper.alignup(@buffer.size, page_size)
+      buf_grow! start_offset + needed_space
+
+      # executable shared object
+      if start_offset > start_page && @segments.any? { |seg| seg.header.p_type == ELFTools::Constants::PT_INTERP }
+        Logger.debug(
+          "shifting new PT_LOAD segment by #{start_offset - start_page} bytes to work around a Linux kernel bug"
+        )
+        start_page = start_offset
+      end
+
+      ehdr.e_phoff = ehdr.num_bytes
+      add_segment!(
+        p_type: ELFTools::Constants::PT_LOAD,
+        p_offset: start_offset,
+        p_vaddr: start_page,
+        p_paddr: start_page,
+        p_filesz: needed_space,
+        p_memsz: needed_space,
+        p_flags: ELFTools::Constants::PF_R | ELFTools::Constants::PF_W,
+        p_align: page_size
+      )
+
+      normalize_note_segments
+
+      cur_off = write_replaced_sections start_offset, start_page, start_offset
+      raise PatchError, 'cur_off != start_offset + needed_space' if cur_off != start_offset + needed_space
+
+      rewrite_headers(first_page + ehdr.e_phoff)
+    end
+
+    def normalize_note_segments
+      return if @replaced_sections.none? do |rsec_name, _|
+        find_section(rsec_name)&.type == ELFTools::Constants::SHT_NOTE
+      end
+
+      new_phdrs = []
+
+      phdrs_by_type(ELFTools::Constants::PT_NOTE) do |phdr|
+        # Binaries produced by older patchelf versions may contain empty PT_NOTE segments.
+        next if @sections.none? do |sec|
+          sec.header.sh_offset >= phdr.p_offset && sec.header.sh_offset < phdr.p_offset + phdr.p_filesz
+        end
+
+        new_phdrs += normalize_note_segment(phdr)
+      end
+
+      new_phdrs.each { |phdr| add_segment!(**phdr.snapshot) }
+    end
+
+    def normalize_note_segment(phdr)
+      start_off = phdr.p_offset.to_i
+      curr_off = start_off
+      end_off = start_off + phdr.p_filesz
+
+      new_phdrs = []
+
+      while curr_off < end_off
+        size = 0
+        sections_at_aligned_offset(curr_off) do |sec|
+          next if sec.type != ELFTools::Constants::SHT_NOTE
+
+          size = sec.header.sh_size.to_i
+          curr_off = sec.header.sh_offset.to_i
+          break
+        end
+
+        raise PatchError, 'cannot normalize PT_NOTE segment: non-contiguous SHT_NOTE sections' if size.zero?
+
+        if curr_off + size > end_off
+          raise PatchError, 'cannot normalize PT_NOTE segment: partially mapped SHT_NOTE section'
+        end
+
+        new_phdr = ELFTools::Structs::ELF_Phdr[elf_class].new(endian: endian, **phdr.snapshot)
+        new_phdr.p_offset = curr_off
+        new_phdr.p_vaddr = phdr.p_vaddr + (curr_off - start_off)
+        new_phdr.p_paddr = phdr.p_paddr + (curr_off - start_off)
+        new_phdr.p_filesz = size
+        new_phdr.p_memsz = size
+
+        if curr_off == start_off
+          phdr.assign(new_phdr)
+        else
+          new_phdrs << new_phdr
+        end
+
+        curr_off += size
+      end
+
+      new_phdrs
+    end
+
+    def sections_at_aligned_offset(offset)
+      @sections.each do |sec|
+        shdr = sec.header
+
+        aligned_offset = Helper.alignup(offset, shdr.sh_addralign)
+        next if shdr.sh_offset != aligned_offset
+
+        yield sec
+      end
+    end
+
+    def shift_sections(shift, start_offset)
+      ehdr.e_shoff += shift if ehdr.e_shoff >= start_offset
+
+      @sections.each_with_index do |sec, i|
+        next if i.zero? # dont touch NULL section
+
+        shdr = sec.header
+        next if shdr.sh_offset < start_offset
+
+        shdr.sh_offset += shift
+      end
+    end
+
+    def shift_segment_offset(phdr, shift)
+      phdr.p_offset += shift
+      phdr.p_align = page_size if phdr.p_align != 0 && (phdr.p_vaddr - phdr.p_offset) % phdr.p_align != 0
+    end
+
+    def shift_segment_virtual_address(phdr, shift)
+      phdr.p_paddr -= shift if phdr.p_paddr > shift
+      phdr.p_vaddr -= shift if phdr.p_vaddr > shift
+    end
+
+    # rubocop:disable Metrics/PerceivedComplexity
+    def shift_segments(shift, start_offset)
+      split_index = -1
+      split_shift = 0
+
+      @segments.each_with_index do |seg, idx|
+        phdr = seg.header
+        p_start = phdr.p_offset
+
+        if p_start <= start_offset && p_start + phdr.p_filesz > start_offset &&
+           phdr.p_type == ELFTools::Constants::PT_LOAD
+          raise PatchError, "split_index(#{split_index}) != -1" if split_index != -1
+
+          split_index = idx
+          split_shift = start_offset - p_start
+
+          phdr.p_offset = start_offset
+          phdr.p_memsz -= split_shift
+          phdr.p_filesz -= split_shift
+          phdr.p_paddr += split_shift
+          phdr.p_vaddr += split_shift
+
+          p_start = start_offset
+        end
+
+        if p_start >= start_offset
+          shift_segment_offset(phdr, shift)
+        else
+          shift_segment_virtual_address(phdr, shift)
+        end
+      end
+
+      raise PatchError, "split_index(#{split_index}) == -1" if split_index == -1
+
+      [split_index, split_shift]
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    def shift_file(extra_pages, start_offset, extra_bytes)
+      raise PatchError, "start_offset(#{start_offset}) < ehdr.num_bytes" if start_offset < ehdr.num_bytes
+
+      oldsz = @buffer.size
+      raise PatchError, "oldsz <= start_offset(#{start_offset})" if oldsz <= start_offset
+
+      shift = extra_pages * page_size
+      buf_grow!(oldsz + shift)
+      buf_move!(start_offset + shift, start_offset, oldsz - start_offset)
+      with_buf_at(start_offset) { |buf| buf.write "\x00" * shift }
+
+      ehdr.e_phoff = ehdr.num_bytes
+
+      shift_sections(shift, start_offset)
+
+      split_index, split_shift = shift_segments(shift, start_offset)
+
+      split_phdr = @segments[split_index].header
+      add_segment!(
+        p_type: ELFTools::Constants::PT_LOAD,
+        p_offset: split_phdr.p_offset - split_shift - shift,
+        p_vaddr: split_phdr.p_vaddr - split_shift - shift,
+        p_paddr: split_phdr.p_paddr - split_shift - shift,
+        p_filesz: split_shift + extra_bytes,
+        p_memsz: split_shift + extra_bytes,
+        p_flags: ELFTools::Constants::PF_R | ELFTools::Constants::PF_W,
+        p_align: page_size
+      )
+    end
+
+    def sort_phdrs!
+      pt_phdr = ELFTools::Constants::PT_PHDR
+      @segments.sort! do |me, you|
+        next  1 if you.header.p_type == pt_phdr
+        next -1 if me.header.p_type == pt_phdr
+
+        me.header.p_paddr.to_i <=> you.header.p_paddr.to_i
+      end
+    end
+
+    # section headers may contain sh_info and sh_link values that are
+    # references to another section
+    def collect_section_to_section_refs
+      rel_syms = [ELFTools::Constants::SHT_REL, ELFTools::Constants::SHT_RELA]
+      # Translate sh_link, sh_info mappings to section names.
+      @sections.each_with_object({ linkage: {}, info: {} }) do |s, collected|
+        hdr = s.header
+        collected[:linkage][s.name] = @sections[hdr.sh_link].name if hdr.sh_link.nonzero?
+        collected[:info][s.name] = @sections[hdr.sh_info].name if hdr.sh_info.nonzero? && rel_syms.include?(hdr.sh_type)
+      end
+    end
+
+    # @param collected
+    # this must be the value returned by +collect_section_to_section_refs+
+    def restore_section_to_section_refs!(collected)
+      rel_syms = [ELFTools::Constants::SHT_REL, ELFTools::Constants::SHT_RELA]
+      linkage, info = collected.values_at(:linkage, :info)
+      @sections.each do |sec|
+        hdr = sec.header
+        hdr.sh_link = find_section_idx(linkage[sec.name]) if hdr.sh_link.nonzero?
+        hdr.sh_info = find_section_idx(info[sec.name]) if hdr.sh_info.nonzero? && rel_syms.include?(hdr.sh_type)
+      end
+    end
+
+    def sort_shdrs!
+      return if @sections.empty?
+
+      section_dep_values = collect_section_to_section_refs
+      shstrtab = @sections[ehdr.e_shstrndx].header
+      @sections.sort! { |me, you| me.header.sh_offset.to_i <=> you.header.sh_offset.to_i }
+      update_section_idx!
+      restore_section_to_section_refs!(section_dep_values)
+      @sections.each_with_index do |sec, idx|
+        ehdr.e_shstrndx = idx if sec.header.sh_offset == shstrtab.sh_offset
+      end
+    end
+
+    def jmprel_section_name
+      sec_name = %w[.rel.plt .rela.plt .rela.IA_64.pltoff].find { |s| find_section(s) }
+      raise PatchError, 'cannot find section corresponding to DT_JMPREL' unless sec_name
+
+      sec_name
+    end
+
+    # given a +dyn.d_tag+, returns the section name it must be synced to.
+    # it may return nil, when given tag maps to no section,
+    # or when its okay to skip if section is not found.
+    def dyn_tag_to_section_name(d_tag)
+      case d_tag
+      when ELFTools::Constants::DT_STRTAB, ELFTools::Constants::DT_STRSZ
+        '.dynstr'
+      when ELFTools::Constants::DT_SYMTAB
+        '.dynsym'
+      when ELFTools::Constants::DT_HASH
+        '.hash'
+      when ELFTools::Constants::DT_GNU_HASH
+        # return nil if not found, patchelf claims no problem in skipping
+        find_section('.gnu.hash')&.name
+      when ELFTools::Constants::DT_MIPS_XHASH
+        return if ehdr.e_machine != ELFTools::Constants::EM_MIPS
+
+        '.MIPS.xhash'
+      when ELFTools::Constants::DT_JMPREL
+        jmprel_section_name
+      when ELFTools::Constants::DT_REL
+        # regarding .rel.got, NixOS/patchelf says
+        # "no idea if this makes sense, but it was needed for some program"
+        #
+        # return nil if not found, patchelf claims no problem in skipping
+        %w[.rel.dyn .rel.got].find { |s| find_section(s) }
+      when ELFTools::Constants::DT_RELA
+        # return nil if not found, patchelf claims no problem in skipping
+        find_section('.rela.dyn')&.name
+      when ELFTools::Constants::DT_VERNEED
+        '.gnu.version_r'
+      when ELFTools::Constants::DT_VERSYM
+        '.gnu.version'
+      end
+    end
+
+    # updates dyn tags by syncing it with @section values
+    def sync_dyn_tags!
+      dyn_table_offset = nil
+      each_dynamic_tags do |dyn, buf_off|
+        dyn_table_offset ||= buf_off
+
+        sec_name = dyn_tag_to_section_name(dyn.d_tag)
+
+        unless sec_name
+          if dyn.d_tag == ELFTools::Constants::DT_MIPS_RLD_MAP_REL && ehdr.e_machine == ELFTools::Constants::EM_MIPS
+            rld_map = find_section('.rld_map')
+            dyn.d_val = if rld_map
+                          rld_map.header.sh_addr.to_i - (buf_off - dyn_table_offset) -
+                            find_section('.dynamic').header.sh_addr.to_i
+                        else
+                          Logger.warn 'DT_MIPS_RLD_MAP_REL entry is present, but .rld_map section is not'
+                          0
+                        end
+          end
+
+          next
+        end
+
+        shdr = find_section(sec_name).header
+        dyn.d_val = dyn.d_tag == ELFTools::Constants::DT_STRSZ ? shdr.sh_size.to_i : shdr.sh_addr.to_i
+
+        with_buf_at(buf_off) { |wbuf| dyn.write(wbuf) }
+      end
+    end
+
+    def update_section_idx!
+      @section_idx_by_name = @sections.map.with_index { |sec, idx| [sec.name, idx] }.to_h
+    end
+
+    def with_buf_at(pos)
+      return unless block_given?
+
+      opos = @buffer.tell
+      @buffer.seek pos
+      yield @buffer
+      @buffer.seek opos
+      nil
+    end
+
+    def sync_sec_to_seg(shdr, phdr)
+      phdr.p_offset = shdr.sh_offset.to_i
+      phdr.p_vaddr = phdr.p_paddr = shdr.sh_addr.to_i
+      phdr.p_filesz = phdr.p_memsz = shdr.sh_size.to_i
+    end
+
+    def phdrs_by_type(seg_type)
+      return unless seg_type
+
+      @segments.each_with_index do |seg, idx|
+        next unless (phdr = seg.header).p_type == seg_type
+
+        yield phdr, idx
+      end
+    end
+
+    # Returns a blank shdr if the section doesn't exist.
+    def find_or_create_section_header(rsec_name)
+      shdr = find_section(rsec_name)&.header
+      shdr ||= ELFTools::Structs::ELF_Shdr.new(endian: endian, elf_class: elf_class)
+      shdr
+    end
+
+    def overwrite_replaced_sections
+      # the original source says this has to be done separately to
+      # prevent clobbering the previously written section contents.
+      @replaced_sections.each_key do |rsec_name|
+        shdr = find_section(rsec_name)&.header
+        next unless shdr
+
+        next if shdr.sh_type == ELFTools::Constants::SHT_NOBITS
+
+        with_buf_at(shdr.sh_offset) { |b| b.fill('X', shdr.sh_size) }
+      end
+    end
+
+    def write_section_alignment(shdr)
+      return if shdr.sh_type == ELFTools::Constants::SHT_NOTE && shdr.sh_addralign <= @section_alignment
+
+      shdr.sh_addralign = @section_alignment
+    end
+
+    def section_bounds_within_segment?(s_start, s_end, p_start, p_end)
+      (s_start >= p_start && s_start < p_end) || (s_end > p_start && s_end <= p_end)
+    end
+
+    def write_replaced_sections(cur_off, start_addr, start_offset)
+      overwrite_replaced_sections
+
+      noted_phdrs = Set.new
+
+      # the sort is necessary, the strategy in ruby and Cpp to iterate map/hash
+      # is different, patchelf v0.10 iterates the replaced_sections sorted by
+      # keys.
+      @replaced_sections.sort.each do |rsec_name, rsec_data|
+        shdr = find_or_create_section_header(rsec_name)
+
+        Logger.debug <<~DEBUG
+          rewriting section '#{rsec_name}'
+          from offset 0x#{shdr.sh_offset.to_i.to_s 16}(size #{shdr.sh_size})
+            to offset 0x#{cur_off.to_i.to_s 16}(size #{rsec_data.size})
+        DEBUG
+
+        with_buf_at(cur_off) { |b| b.write rsec_data }
+
+        orig_sh_offset = shdr.sh_offset.to_i
+        orig_sh_size = shdr.sh_size.to_i
+
+        shdr.sh_offset = cur_off
+        shdr.sh_addr = start_addr + (cur_off - start_offset)
+        shdr.sh_size = rsec_data.size
+
+        write_section_alignment(shdr)
+
+        seg_type = {
+          '.interp' => ELFTools::Constants::PT_INTERP,
+          '.dynamic' => ELFTools::Constants::PT_DYNAMIC,
+          '.MIPS.abiflags' => ELFTools::Constants::PT_MIPS_ABIFLAGS,
+          '.note.gnu.property' => ELFTools::Constants::PT_GNU_PROPERTY
+        }[rsec_name]
+
+        phdrs_by_type(seg_type) { |phdr| sync_sec_to_seg(shdr, phdr) }
+
+        if shdr.sh_type == ELFTools::Constants::SHT_NOTE
+          phdrs_by_type(ELFTools::Constants::PT_NOTE) do |phdr, idx|
+            next if noted_phdrs.include?(idx)
+
+            s_start = orig_sh_offset
+            s_end = s_start + orig_sh_size
+            p_start = phdr.p_offset
+            p_end = p_start + phdr.p_filesz
+
+            next unless section_bounds_within_segment?(s_start, s_end, p_start, p_end)
+
+            raise PatchError, 'unsupported overlap of SHT_NOTE and PT_NOTE' if p_start != s_start || p_end != s_end
+
+            sync_sec_to_seg(shdr, phdr)
+
+            noted_phdrs << idx
+          end
+        end
+
+        cur_off += Helper.alignup(rsec_data.size, @section_alignment)
+      end
+      @replaced_sections.clear
+
+      cur_off
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/cli.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/cli.rb
similarity index 96%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/cli.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/cli.rb
index 18f82b784bda7..106d8a177b0a2 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/cli.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/cli.rb
@@ -63,11 +63,11 @@ def readonly
 
     def patch_requests
       @options[:set].each do |sym, val|
-        patcher.__send__("#{sym}=".to_sym, val)
+        patcher.__send__(:"#{sym}=", val)
       end
 
       @options[:needed].each do |type, val|
-        patcher.__send__("#{type}_needed".to_sym, *val)
+        patcher.__send__(:"#{type}_needed", *val)
       end
     end
 
@@ -139,7 +139,7 @@ def option_parser
           @options[:set][:soname] = soname
         end
 
-        opts.on('--version', 'Show current gem\'s version.') {}
+        opts.on('--version', 'Show current gem\'s version.')
       end
     end
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/exceptions.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/exceptions.rb
new file mode 100644
index 0000000000000..3a7b69614fbc1
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/exceptions.rb
@@ -0,0 +1,15 @@
+# encoding: ascii-8bit
+# frozen_string_literal: true
+
+require 'elftools/exceptions'
+
+module PatchELF
+  # Raised on an error during ELF modification.
+  class PatchError < ELFTools::ELFError; end
+
+  # Raised when Dynamic Tag is missing
+  class MissingTagError < PatchError; end
+
+  # Raised on missing Program Header(segment)
+  class MissingSegmentError < PatchError; end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/helper.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/helper.rb
new file mode 100644
index 0000000000000..10b740d833ede
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/helper.rb
@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module PatchELF
+  # Helper methods for internal usage.
+  module Helper
+    module_function
+
+    # Color codes for pretty print.
+    COLOR_CODE = {
+      esc_m: "\e[0m",
+      info: "\e[38;5;82m", # light green
+      warn: "\e[38;5;230m", # light yellow
+      error: "\e[38;5;196m" # heavy red
+    }.freeze
+
+    # The size of one page.
+    def page_size(e_machine = nil)
+      # Different architectures have different minimum section alignments.
+      case e_machine
+      when ELFTools::Constants::EM_SPARC,
+           ELFTools::Constants::EM_MIPS,
+           ELFTools::Constants::EM_PPC,
+           ELFTools::Constants::EM_PPC64,
+           ELFTools::Constants::EM_AARCH64,
+           ELFTools::Constants::EM_TILEGX,
+           ELFTools::Constants::EM_LOONGARCH
+        0x10000
+      else
+        0x1000
+      end
+    end
+
+    # For wrapping string with color codes for prettier inspect.
+    # @param [String] str
+    #   Content to colorize.
+    # @param [Symbol] type
+    #   Specify which kind of color to use, valid symbols are defined in {.COLOR_CODE}.
+    # @return [String]
+    #   String that wrapped with color codes.
+    def colorize(str, type)
+      return str unless color_enabled?
+
+      cc = COLOR_CODE
+      color = cc.key?(type) ? cc[type] : ''
+      "#{color}#{str.sub(COLOR_CODE[:esc_m], color)}#{cc[:esc_m]}"
+    end
+
+    # For {#colorize} to decide if need add color codes.
+    # @return [Boolean]
+    def color_enabled?
+      $stderr.tty?
+    end
+
+    # @param [Integer] val
+    # @param [Integer] align
+    # @return [Integer]
+    #   Aligned result.
+    # @example
+    #   aligndown(0x1234)
+    #   #=> 4096
+    #   aligndown(0x33, 0x20)
+    #   #=> 32
+    #   aligndown(0x10, 0x8)
+    #   #=> 16
+    def aligndown(val, align = page_size)
+      val - (val & (align - 1))
+    end
+
+    # @param [Integer] val
+    # @param [Integer] align
+    # @return [Integer]
+    #   Aligned result.
+    # @example
+    #   alignup(0x1234)
+    #   #=> 8192
+    #   alignup(0x33, 0x20)
+    #   #=> 64
+    #   alignup(0x10, 0x8)
+    #   #=> 16
+    def alignup(val, align = page_size)
+      (val & (align - 1)).zero? ? val : (aligndown(val, align) + align)
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/logger.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/logger.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/logger.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/logger.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/mm.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/mm.rb
similarity index 97%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/mm.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/mm.rb
index 03eec0bad499c..ec2b1ea08164d 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/mm.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/mm.rb
@@ -115,7 +115,7 @@ def mgap_method
       # prefer backward than forward
       return extend_backward(loads[idx - 1]) if writable?(loads[idx - 1])
 
-      # note: loads[idx].file_head has been changed in shift_attributes
+      # NOTE: loads[idx].file_head has been changed in shift_attributes
       extend_forward(loads[idx], @extend_size)
     end
 
@@ -161,7 +161,7 @@ def shift_attributes
 
         seg.header.p_offset += extend_size
         # We have to change align of LOAD segment since ld.so checks it.
-        seg.header.p_align = Helper::PAGE_SIZE if seg.is_a?(ELFTools::Segments::LoadSegment)
+        seg.header.p_align = Helper.page_size if seg.is_a?(ELFTools::Segments::LoadSegment)
       end
 
       @elf.header.e_shoff += extend_size if @elf.header.e_shoff >= threshold
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/patcher.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/patcher.rb
similarity index 99%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/patcher.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/patcher.rb
index 9fbb991e9d703..94da26822b608 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/patcher.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/patcher.rb
@@ -30,7 +30,7 @@ def initialize(filename, on_error: :log, logging: true)
       @elf = ELFTools::ELFFile.new(File.open(filename))
       @set = {}
       @rpath_sym = :runpath
-      @on_error = !logging ? :exception : on_error
+      @on_error = logging ? on_error : :exception
 
       on_error_syms = %i[exception log silent]
       raise ArgumentError, "on_error must be one of #{on_error_syms}" unless on_error_syms.include?(@on_error)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/saver.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/saver.rb
similarity index 97%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/saver.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/saver.rb
index 4ecd806795afc..0da2b11e17ec7 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/patchelf-1.3.0/lib/patchelf/saver.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/saver.rb
@@ -53,8 +53,8 @@ def save!
     def patch_interpreter
       return if @set[:interpreter].nil?
 
-      new_interp = @set[:interpreter] + "\x00"
-      old_interp = @elf.segment_by_type(:interp).interp_name + "\x00"
+      new_interp = "#{@set[:interpreter]}\x00"
+      old_interp = "#{@elf.segment_by_type(:interp).interp_name}\x00"
       return if old_interp == new_interp
 
       # These headers must be found here but not in the proc.
@@ -184,7 +184,7 @@ def malloc_strtab!
       need_size = strtab_string.size + @strtab_extend_requests.reduce(0) { |sum, (str, _)| sum + str.size + 1 }
       dynstr = section_header('.dynstr')
       @mm.malloc(need_size) do |off, vaddr|
-        new_str = strtab_string + @strtab_extend_requests.map(&:first).join("\x00") + "\x00"
+        new_str = "#{strtab_string}#{@strtab_extend_requests.map(&:first).join("\x00")}\x00"
         inline_patch(off, new_str)
         cur = strtab_string.size
         @strtab_extend_requests.each do |str, block|
@@ -206,7 +206,7 @@ def malloc_strtab!
     # @yieldparam [Integer] idx
     # @yieldreturn [void]
     def reg_str_table(str, &block)
-      idx = strtab_string.index(str + "\x00")
+      idx = strtab_string.index("#{str}\x00")
       # Request string is already exist
       return yield idx if idx
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/version.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/version.rb
new file mode 100644
index 0000000000000..0389d29916457
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/patchelf-1.5.1/lib/patchelf/version.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module PatchELF
+  # Current gem version.
+  VERSION = '1.5.1'.freeze
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/LICENSE.txt b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/LICENSE.txt
new file mode 100644
index 0000000000000..0ccffe7bf3d5c
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/LICENSE.txt
@@ -0,0 +1,20 @@
+Copyright (c) 2006-2010, Ben Bleything and Patrick May
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/plist-3.6.0/lib/plist.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/lib/plist.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/plist-3.6.0/lib/plist.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/lib/plist.rb
index 2304992dfa023..0939cb359a723 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/plist-3.6.0/lib/plist.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/lib/plist.rb
@@ -9,7 +9,6 @@
 # Distributed under the MIT License
 #
 
-require 'base64'
 require 'cgi'
 require 'stringio'
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/lib/plist/generator.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/lib/plist/generator.rb
new file mode 100644
index 0000000000000..5d17d55f5f86d
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/lib/plist/generator.rb
@@ -0,0 +1,178 @@
+# encoding: utf-8
+
+# = plist
+#
+# Copyright 2006-2010 Ben Bleything and Patrick May
+# Distributed under the MIT License
+#
+
+module Plist
+  # === Create a plist
+  # You can dump an object to a plist in one of two ways:
+  #
+  # * <tt>Plist::Emit.dump(obj)</tt>
+  # * <tt>obj.to_plist</tt>
+  #   * This requires that you mixin the <tt>Plist::Emit</tt> module, which is already done for +Array+ and +Hash+.
+  #
+  # The following Ruby classes are converted into native plist types:
+  #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time, true, false
+  # * +Array+ and +Hash+ are both recursive; their elements will be converted into plist nodes inside the <array> and <dict> containers (respectively).
+  # * +IO+ (and its descendants) and +StringIO+ objects are read from and their contents placed in a <data> element.
+  # * User classes may implement +to_plist_node+ to dictate how they should be serialized; otherwise the object will be passed to <tt>Marshal.dump</tt> and the result placed in a <data> element.
+  #
+  # For detailed usage instructions, refer to USAGE[link:files/docs/USAGE.html] and the methods documented below.
+  module Emit
+    DEFAULT_INDENT = "\t"
+
+    # Helper method for injecting into classes.  Calls <tt>Plist::Emit.dump</tt> with +self+.
+    def to_plist(envelope = true, options = {})
+      Plist::Emit.dump(self, envelope, options)
+    end
+
+    # Helper method for injecting into classes.  Calls <tt>Plist::Emit.save_plist</tt> with +self+.
+    def save_plist(filename, options = {})
+      Plist::Emit.save_plist(self, filename, options)
+    end
+
+    # The following Ruby classes are converted into native plist types:
+    #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time
+    #
+    # Write us (via RubyForge) if you think another class can be coerced safely into one of the expected plist classes.
+    #
+    # +IO+ and +StringIO+ objects are encoded and placed in <data> elements; other objects are <tt>Marshal.dump</tt>'ed unless they implement +to_plist_node+.
+    #
+    # The +envelope+ parameters dictates whether or not the resultant plist fragment is wrapped in the normal XML/plist header and footer.  Set it to false if you only want the fragment.
+    def self.dump(obj, envelope = true, options = {})
+      options = { :indent => DEFAULT_INDENT }.merge(options)
+
+      output = PlistBuilder.new(options[:indent]).build(obj)
+      output = wrap(output) if envelope
+
+      output
+    end
+
+    # Writes the serialized object's plist to the specified filename.
+    def self.save_plist(obj, filename, options = {})
+      File.open(filename, 'wb') do |f|
+        f.write(obj.to_plist(true, options))
+      end
+    end
+
+    private
+
+    class PlistBuilder
+      def initialize(indent_str)
+        @indent_str = indent_str.to_s
+      end
+
+      def build(element, level=0)
+        if element.respond_to? :to_plist_node
+          element.to_plist_node
+        else
+          case element
+          when Array
+            if element.empty?
+              tag('array', nil, level)
+            else
+              tag('array', nil, level) {
+                element.collect {|e| build(e, level + 1) }.join
+              }
+            end
+          when Hash
+            if element.empty?
+              tag('dict', nil, level)
+            else
+              tag('dict', '', level) do
+                element.sort_by{|k,v| k.to_s }.collect do |k,v| 
+                  tag('key', CGI.escapeHTML(k.to_s), level + 1) +
+                  build(v, level + 1)
+                end.join
+              end
+            end
+          when true, false
+            tag(element, nil, level)
+          when Time
+            tag('date', element.utc.strftime('%Y-%m-%dT%H:%M:%SZ'), level)
+          when Date # also catches DateTime
+            tag('date', element.strftime('%Y-%m-%dT%H:%M:%SZ'), level)
+          when String, Symbol, Integer, Float
+            tag(element_type(element), CGI.escapeHTML(element.to_s), level)
+          when IO, StringIO
+            data = element.tap(&:rewind).read 
+            data_tag(data, level)
+          else
+            data = Marshal.dump(element)
+            comment_tag('The <data> element below contains a Ruby object which has been serialized with Marshal.dump.') +
+            data_tag(data, level)
+          end
+        end
+      end
+
+      private
+
+      def tag(type, contents, level, &block)
+        if block_given?
+          indent("<#{type}>\n", level) +
+          block.call +
+          indent("</#{type}>\n", level)
+        elsif contents.to_s.empty?
+          indent("<#{type}/>\n", level)
+        else
+          indent("<#{type}>#{contents.to_s}</#{type}>\n", level)
+        end
+      end
+
+      def data_tag(data, level)
+        # note that apple plists are wrapped at a different length then
+        # what ruby's pack wraps by default.
+        tag('data', nil, level) do
+          [data].pack("m") # equivalent to Base64.encode64(data)
+                .gsub(/\s+/, '')
+                .scan(/.{1,68}/o)
+                .collect { |line| indent(line, level) }
+                .join("\n")
+                .concat("\n")
+        end
+      end
+
+      def indent(str, level)
+        @indent_str.to_s * level + str
+      end
+
+      def element_type(item)
+        case item
+        when String, Symbol
+          'string'
+        when Integer
+          'integer'
+        when Float
+          'real'
+        else
+          raise "Don't know about this data type... something must be wrong!"
+        end
+      end
+
+      def comment_tag(content)
+        return "<!-- #{content} -->\n"
+      end
+    end
+
+    def self.wrap(contents)
+      output =  '<?xml version="1.0" encoding="UTF-8"?>' + "\n"
+      output << '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">' + "\n"
+      output << '<plist version="1.0">' + "\n"
+      output << contents
+      output << '</plist>' + "\n"
+
+      output
+    end
+  end
+end
+
+class Array #:nodoc:
+  include Plist::Emit
+end
+
+class Hash #:nodoc:
+  include Plist::Emit
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/lib/plist/parser.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/lib/plist/parser.rb
new file mode 100755
index 0000000000000..038b1943871bc
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/lib/plist/parser.rb
@@ -0,0 +1,263 @@
+# encoding: utf-8
+
+# = plist
+#
+# Copyright 2006-2010 Ben Bleything and Patrick May
+# Distributed under the MIT License
+#
+
+# Plist parses Mac OS X xml property list files into ruby data structures.
+#
+# === Load a plist file
+# This is the main point of the library:
+#
+#   r = Plist.parse_xml(filename_or_xml)
+module Plist
+  # Raised when an element is not implemented
+  class UnimplementedElementError < RuntimeError; end
+
+  # Note that I don't use these two elements much:
+  #
+  #  + Date elements are returned as DateTime objects.
+  #  + Data elements are implemented as Tempfiles
+  #
+  # Plist.parse_xml will blow up if it encounters a Date element.
+  # If you encounter such an error, or if you have a Date element which
+  # can't be parsed into a Time object, please create an issue
+  # attaching your plist file at https://github.com/patsplat/plist/issues
+  # so folks can implement the proper support.
+  #
+  # By default, <data> will be assumed to be a marshaled Ruby object and
+  # interpreted with <tt>Marshal.load</tt>. Pass <tt>marshal: false</tt>
+  # to disable this behavior and return the raw binary data as an IO
+  # object instead.
+  def self.parse_xml(filename_or_xml, options={})
+    listener = Listener.new(options)
+    # parser = REXML::Parsers::StreamParser.new(File.new(filename), listener)
+    parser = StreamParser.new(filename_or_xml, listener)
+    parser.parse
+    listener.result
+  end
+
+  class Listener
+    # include REXML::StreamListener
+
+    attr_accessor :result, :open
+
+    def initialize(options={})
+      @result = nil
+      @open   = []
+      @options = { :marshal => true }.merge(options).freeze
+    end
+
+    def tag_start(name, attributes)
+      @open.push PTag.mappings[name].new(@options)
+    end
+
+    def text(contents)
+      if @open.last
+        @open.last.text ||= ''
+        @open.last.text.concat(contents)
+      end
+    end
+
+    def tag_end(name)
+      last = @open.pop
+      if @open.empty?
+        @result = last.to_ruby
+      else
+        @open.last.children.push last
+      end
+    end
+  end
+
+  class StreamParser
+    def initialize(plist_data_or_file, listener)
+      if plist_data_or_file.respond_to? :read
+        @xml = plist_data_or_file.read
+      elsif File.exist? plist_data_or_file
+        @xml = File.read(plist_data_or_file)
+      else
+        @xml = plist_data_or_file
+      end
+
+      @listener = listener
+    end
+
+    TEXT = /([^<]+)/
+    CDATA = /<!\[CDATA\[(.*?)\]\]>/
+    XMLDECL_PATTERN = /<\?xml\s+(.*?)\?>*/m
+    DOCTYPE_PATTERN = /\s*<!DOCTYPE\s+(.*?)(\[|>)/m
+    COMMENT_START = /\A<!--/
+    COMMENT_END = /.*?-->/m
+    UNIMPLEMENTED_ERROR = 'Unimplemented element. ' \
+      'Consider reporting via https://github.com/patsplat/plist/issues'
+
+    def parse
+      plist_tags = PTag.mappings.keys.join('|')
+      start_tag  = /<(#{plist_tags})([^>]*)>/i
+      end_tag    = /<\/(#{plist_tags})[^>]*>/i
+
+      require 'strscan'
+
+      @scanner = StringScanner.new(@xml)
+      until @scanner.eos?
+        if @scanner.scan(COMMENT_START)
+          @scanner.scan(COMMENT_END)
+        elsif @scanner.scan(XMLDECL_PATTERN)
+          encoding = parse_encoding_from_xml_declaration(@scanner[1])
+          next if encoding.nil?
+
+          # use the specified encoding for the rest of the file
+          next unless String.method_defined?(:force_encoding)
+          @scanner.string = @scanner.rest.force_encoding(encoding)
+        elsif @scanner.scan(DOCTYPE_PATTERN)
+          next
+        elsif @scanner.scan(start_tag)
+          @listener.tag_start(@scanner[1], nil)
+          if (@scanner[2] =~ /\/$/)
+            @listener.tag_end(@scanner[1])
+          end
+        elsif @scanner.scan(TEXT)
+          @listener.text(@scanner[1])
+        elsif @scanner.scan(CDATA)
+          @listener.text(@scanner[1])
+        elsif @scanner.scan(end_tag)
+          @listener.tag_end(@scanner[1])
+        else
+          raise UnimplementedElementError.new(UNIMPLEMENTED_ERROR)
+        end
+      end
+    end
+
+    private
+
+    def parse_encoding_from_xml_declaration(xml_declaration)
+      return unless defined?(Encoding)
+
+      xml_encoding = xml_declaration.match(/(?:\A|\s)encoding=(?:"(.*?)"|'(.*?)')(?:\s|\Z)/)
+
+      return if xml_encoding.nil?
+
+      begin
+        Encoding.find(xml_encoding[1])
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+
+  class PTag
+    def self.mappings
+      @mappings ||= {}
+    end
+
+    def self.inherited(sub_class)
+      key = sub_class.to_s.downcase
+      key.gsub!(/^plist::/, '')
+      key.gsub!(/^p/, '')  unless key == "plist"
+
+      mappings[key] = sub_class
+    end
+
+    attr_accessor :text, :children, :options
+    def initialize(options)
+      @children = []
+      @options = options
+    end
+
+    def to_ruby
+      raise "Unimplemented: " + self.class.to_s + "#to_ruby on #{self.inspect}"
+    end
+  end
+
+  class PList < PTag
+    def to_ruby
+      children.first.to_ruby if children.first
+    end
+  end
+
+  class PDict < PTag
+    def to_ruby
+      dict = {}
+      key = nil
+
+      children.each do |c|
+        if key.nil?
+          key = c.to_ruby
+        else
+          dict[key] = c.to_ruby
+          key = nil
+        end
+      end
+
+      dict
+    end
+  end
+
+  class PKey < PTag
+    def to_ruby
+      CGI.unescapeHTML(text || '')
+    end
+  end
+
+  class PString < PTag
+    def to_ruby
+      CGI.unescapeHTML(text || '')
+    end
+  end
+
+  class PArray < PTag
+    def to_ruby
+      children.collect do |c|
+        c.to_ruby
+      end
+    end
+  end
+
+  class PInteger < PTag
+    def to_ruby
+      text.to_i
+    end
+  end
+
+  class PTrue < PTag
+    def to_ruby
+      true
+    end
+  end
+
+  class PFalse < PTag
+    def to_ruby
+      false
+    end
+  end
+
+  class PReal < PTag
+    def to_ruby
+      text.to_f
+    end
+  end
+
+  require 'date'
+  class PDate < PTag
+    def to_ruby
+      DateTime.parse(text)
+    end
+  end
+
+  class PData < PTag
+    def to_ruby
+      # unpack("m")[0] is equivalent to Base64.decode64
+      data = text.gsub(/\s+/, '').unpack("m")[0] unless text.nil?
+      begin
+        return Marshal.load(data) if options[:marshal]
+      rescue Exception
+      end
+      io = StringIO.new
+      io.write data
+      io.rewind
+      io
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/lib/plist/version.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/lib/plist/version.rb
new file mode 100644
index 0000000000000..6417e8f9b4afa
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/plist-3.7.1/lib/plist/version.rb
@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Plist
+  VERSION = '3.7.1'.freeze
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/LICENSE.txt b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/LICENSE.txt
new file mode 100644
index 0000000000000..32b1ac8395620
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/LICENSE.txt
@@ -0,0 +1,22 @@
+Copyright (c) 2009-2024 Simone Carletti <weppos@weppos.net>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/data/list.txt b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/data/list.txt
new file mode 100644
index 0000000000000..0fac6625f8c6c
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/data/list.txt
@@ -0,0 +1,15843 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+// Please pull this list from, and only from https://publicsuffix.org/list/public_suffix_list.dat,
+// rather than any other VCS sites. Pulling from any other URL is not guaranteed to be supported.
+
+// Instructions on pulling and using this list can be found at https://publicsuffix.org/list/.
+
+// ===BEGIN ICANN DOMAINS===
+
+// ac : http://nic.ac/rules.htm
+ac
+com.ac
+edu.ac
+gov.ac
+net.ac
+mil.ac
+org.ac
+
+// ad : https://en.wikipedia.org/wiki/.ad
+ad
+nom.ad
+
+// ae : https://tdra.gov.ae/en/aeda/ae-policies
+ae
+co.ae
+net.ae
+org.ae
+sch.ae
+ac.ae
+gov.ae
+mil.ae
+
+// aero : https://information.aero/registration/policies/dmp
+aero
+// 2LDs
+airline.aero
+airport.aero
+// 2LDs (currently not accepting registration, seemingly never have)
+// As of 2024-07, these are marked as reserved for potential 3LD
+// registrations (clause 11 "allocated subdomains" in the 2006 TLD
+// policy), but the relevant industry partners have not opened them up
+// for registration. Current status can be determined from the TLD's
+// policy document: 2LDs that are open for registration must list
+// their policy in the TLD's policy. Any 2LD without such a policy is
+// not open for registrations.
+accident-investigation.aero
+accident-prevention.aero
+aerobatic.aero
+aeroclub.aero
+aerodrome.aero
+agents.aero
+air-surveillance.aero
+air-traffic-control.aero
+aircraft.aero
+airtraffic.aero
+ambulance.aero
+association.aero
+author.aero
+ballooning.aero
+broker.aero
+caa.aero
+cargo.aero
+catering.aero
+certification.aero
+championship.aero
+charter.aero
+civilaviation.aero
+club.aero
+conference.aero
+consultant.aero
+consulting.aero
+control.aero
+council.aero
+crew.aero
+design.aero
+dgca.aero
+educator.aero
+emergency.aero
+engine.aero
+engineer.aero
+entertainment.aero
+equipment.aero
+exchange.aero
+express.aero
+federation.aero
+flight.aero
+freight.aero
+fuel.aero
+gliding.aero
+government.aero
+groundhandling.aero
+group.aero
+hanggliding.aero
+homebuilt.aero
+insurance.aero
+journal.aero
+journalist.aero
+leasing.aero
+logistics.aero
+magazine.aero
+maintenance.aero
+marketplace.aero
+media.aero
+microlight.aero
+modelling.aero
+navigation.aero
+parachuting.aero
+paragliding.aero
+passenger-association.aero
+pilot.aero
+press.aero
+production.aero
+recreation.aero
+repbody.aero
+res.aero
+research.aero
+rotorcraft.aero
+safety.aero
+scientist.aero
+services.aero
+show.aero
+skydiving.aero
+software.aero
+student.aero
+taxi.aero
+trader.aero
+trading.aero
+trainer.aero
+union.aero
+workinggroup.aero
+works.aero
+
+// af : http://www.nic.af/help.jsp
+af
+gov.af
+com.af
+org.af
+net.af
+edu.af
+
+// ag : http://www.nic.ag/prices.htm
+ag
+com.ag
+org.ag
+net.ag
+co.ag
+nom.ag
+
+// ai : http://nic.com.ai/
+ai
+off.ai
+com.ai
+net.ai
+org.ai
+
+// al : http://www.ert.gov.al/ert_alb/faq_det.html?Id=31
+al
+com.al
+edu.al
+gov.al
+mil.al
+net.al
+org.al
+
+// am : https://www.amnic.net/policy/en/Policy_EN.pdf
+am
+co.am
+com.am
+commune.am
+net.am
+org.am
+
+// ao : https://en.wikipedia.org/wiki/.ao
+// http://www.dns.ao/REGISTR.DOC
+ao
+ed.ao
+gv.ao
+og.ao
+co.ao
+pb.ao
+it.ao
+
+// aq : https://en.wikipedia.org/wiki/.aq
+aq
+
+// ar : https://nic.ar/es/nic-argentina/normativa
+ar
+bet.ar
+com.ar
+coop.ar
+edu.ar
+gob.ar
+gov.ar
+int.ar
+mil.ar
+musica.ar
+mutual.ar
+net.ar
+org.ar
+senasa.ar
+tur.ar
+
+// arpa : https://en.wikipedia.org/wiki/.arpa
+// Confirmed by registry <iana-questions@icann.org> 2008-06-18
+arpa
+e164.arpa
+in-addr.arpa
+ip6.arpa
+iris.arpa
+uri.arpa
+urn.arpa
+
+// as : https://en.wikipedia.org/wiki/.as
+as
+gov.as
+
+// asia : https://en.wikipedia.org/wiki/.asia
+asia
+
+// at : https://en.wikipedia.org/wiki/.at
+// Confirmed by registry <it@nic.at> 2008-06-17
+at
+ac.at
+co.at
+gv.at
+or.at
+sth.ac.at
+
+// au : https://en.wikipedia.org/wiki/.au
+// http://www.auda.org.au/
+au
+// 2LDs
+com.au
+net.au
+org.au
+edu.au
+gov.au
+asn.au
+id.au
+// Historic 2LDs (closed to new registration, but sites still exist)
+info.au
+conf.au
+oz.au
+// CGDNs - http://www.cgdn.org.au/
+act.au
+nsw.au
+nt.au
+qld.au
+sa.au
+tas.au
+vic.au
+wa.au
+// 3LDs
+act.edu.au
+catholic.edu.au
+// eq.edu.au - Removed at the request of the Queensland Department of Education
+nsw.edu.au
+nt.edu.au
+qld.edu.au
+sa.edu.au
+tas.edu.au
+vic.edu.au
+wa.edu.au
+// act.gov.au  Bug 984824 - Removed at request of Greg Tankard
+// nsw.gov.au  Bug 547985 - Removed at request of <Shae.Donelan@services.nsw.gov.au>
+// nt.gov.au  Bug 940478 - Removed at request of Greg Connors <Greg.Connors@nt.gov.au>
+qld.gov.au
+sa.gov.au
+tas.gov.au
+vic.gov.au
+wa.gov.au
+// 4LDs
+// education.tas.edu.au - Removed at the request of the Department of Education Tasmania
+schools.nsw.edu.au
+
+// aw : https://en.wikipedia.org/wiki/.aw
+aw
+com.aw
+
+// ax : https://en.wikipedia.org/wiki/.ax
+ax
+
+// az : https://en.wikipedia.org/wiki/.az
+az
+com.az
+net.az
+int.az
+gov.az
+org.az
+edu.az
+info.az
+pp.az
+mil.az
+name.az
+pro.az
+biz.az
+
+// ba : http://nic.ba/users_data/files/pravilnik_o_registraciji.pdf
+ba
+com.ba
+edu.ba
+gov.ba
+mil.ba
+net.ba
+org.ba
+
+// bb : https://en.wikipedia.org/wiki/.bb
+bb
+biz.bb
+co.bb
+com.bb
+edu.bb
+gov.bb
+info.bb
+net.bb
+org.bb
+store.bb
+tv.bb
+
+// bd : https://en.wikipedia.org/wiki/.bd
+*.bd
+
+// be : https://en.wikipedia.org/wiki/.be
+// Confirmed by registry <tech@dns.be> 2008-06-08
+be
+ac.be
+
+// bf : https://en.wikipedia.org/wiki/.bf
+bf
+gov.bf
+
+// bg : https://en.wikipedia.org/wiki/.bg
+// https://www.register.bg/user/static/rules/en/index.html
+bg
+a.bg
+b.bg
+c.bg
+d.bg
+e.bg
+f.bg
+g.bg
+h.bg
+i.bg
+j.bg
+k.bg
+l.bg
+m.bg
+n.bg
+o.bg
+p.bg
+q.bg
+r.bg
+s.bg
+t.bg
+u.bg
+v.bg
+w.bg
+x.bg
+y.bg
+z.bg
+0.bg
+1.bg
+2.bg
+3.bg
+4.bg
+5.bg
+6.bg
+7.bg
+8.bg
+9.bg
+
+// bh : https://en.wikipedia.org/wiki/.bh
+bh
+com.bh
+edu.bh
+net.bh
+org.bh
+gov.bh
+
+// bi : https://en.wikipedia.org/wiki/.bi
+// http://whois.nic.bi/
+bi
+co.bi
+com.bi
+edu.bi
+or.bi
+org.bi
+
+// biz : https://en.wikipedia.org/wiki/.biz
+biz
+
+// bj : https://nic.bj/bj-suffixes.txt
+// submitted by registry <contact@nic.bj>
+bj
+africa.bj
+agro.bj
+architectes.bj
+assur.bj
+avocats.bj
+co.bj
+com.bj
+eco.bj
+econo.bj
+edu.bj
+info.bj
+loisirs.bj
+money.bj
+net.bj
+org.bj
+ote.bj
+resto.bj
+restaurant.bj
+tourism.bj
+univ.bj
+
+// bm : http://www.bermudanic.bm/dnr-text.txt
+bm
+com.bm
+edu.bm
+gov.bm
+net.bm
+org.bm
+
+// bn : http://www.bnnic.bn/faqs
+bn
+com.bn
+edu.bn
+gov.bn
+net.bn
+org.bn
+
+// bo : https://nic.bo/delegacion2015.php#h-1.10
+bo
+com.bo
+edu.bo
+gob.bo
+int.bo
+org.bo
+net.bo
+mil.bo
+tv.bo
+web.bo
+// Social Domains
+academia.bo
+agro.bo
+arte.bo
+blog.bo
+bolivia.bo
+ciencia.bo
+cooperativa.bo
+democracia.bo
+deporte.bo
+ecologia.bo
+economia.bo
+empresa.bo
+indigena.bo
+industria.bo
+info.bo
+medicina.bo
+movimiento.bo
+musica.bo
+natural.bo
+nombre.bo
+noticias.bo
+patria.bo
+politica.bo
+profesional.bo
+plurinacional.bo
+pueblo.bo
+revista.bo
+salud.bo
+tecnologia.bo
+tksat.bo
+transporte.bo
+wiki.bo
+
+// br : http://registro.br/dominio/categoria.html
+// Submitted by registry <fneves@registro.br>
+br
+9guacu.br
+abc.br
+adm.br
+adv.br
+agr.br
+aju.br
+am.br
+anani.br
+aparecida.br
+app.br
+arq.br
+art.br
+ato.br
+b.br
+barueri.br
+belem.br
+bhz.br
+bib.br
+bio.br
+blog.br
+bmd.br
+boavista.br
+bsb.br
+campinagrande.br
+campinas.br
+caxias.br
+cim.br
+cng.br
+cnt.br
+com.br
+contagem.br
+coop.br
+coz.br
+cri.br
+cuiaba.br
+curitiba.br
+def.br
+des.br
+det.br
+dev.br
+ecn.br
+eco.br
+edu.br
+emp.br
+enf.br
+eng.br
+esp.br
+etc.br
+eti.br
+far.br
+feira.br
+flog.br
+floripa.br
+fm.br
+fnd.br
+fortal.br
+fot.br
+foz.br
+fst.br
+g12.br
+geo.br
+ggf.br
+goiania.br
+gov.br
+// gov.br 26 states + df https://en.wikipedia.org/wiki/States_of_Brazil
+ac.gov.br
+al.gov.br
+am.gov.br
+ap.gov.br
+ba.gov.br
+ce.gov.br
+df.gov.br
+es.gov.br
+go.gov.br
+ma.gov.br
+mg.gov.br
+ms.gov.br
+mt.gov.br
+pa.gov.br
+pb.gov.br
+pe.gov.br
+pi.gov.br
+pr.gov.br
+rj.gov.br
+rn.gov.br
+ro.gov.br
+rr.gov.br
+rs.gov.br
+sc.gov.br
+se.gov.br
+sp.gov.br
+to.gov.br
+gru.br
+imb.br
+ind.br
+inf.br
+jab.br
+jampa.br
+jdf.br
+joinville.br
+jor.br
+jus.br
+leg.br
+lel.br
+log.br
+londrina.br
+macapa.br
+maceio.br
+manaus.br
+maringa.br
+mat.br
+med.br
+mil.br
+morena.br
+mp.br
+mus.br
+natal.br
+net.br
+niteroi.br
+*.nom.br
+not.br
+ntr.br
+odo.br
+ong.br
+org.br
+osasco.br
+palmas.br
+poa.br
+ppg.br
+pro.br
+psc.br
+psi.br
+pvh.br
+qsl.br
+radio.br
+rec.br
+recife.br
+rep.br
+ribeirao.br
+rio.br
+riobranco.br
+riopreto.br
+salvador.br
+sampa.br
+santamaria.br
+santoandre.br
+saobernardo.br
+saogonca.br
+seg.br
+sjc.br
+slg.br
+slz.br
+sorocaba.br
+srv.br
+taxi.br
+tc.br
+tec.br
+teo.br
+the.br
+tmp.br
+trd.br
+tur.br
+tv.br
+udi.br
+vet.br
+vix.br
+vlog.br
+wiki.br
+zlg.br
+
+// bs : http://www.nic.bs/rules.html
+bs
+com.bs
+net.bs
+org.bs
+edu.bs
+gov.bs
+
+// bt : https://en.wikipedia.org/wiki/.bt
+bt
+com.bt
+edu.bt
+gov.bt
+net.bt
+org.bt
+
+// bv : No registrations at this time.
+// Submitted by registry <jarle@uninett.no>
+bv
+
+// bw : https://en.wikipedia.org/wiki/.bw
+// http://www.gobin.info/domainname/bw.doc
+// list of other 2nd level tlds ?
+bw
+co.bw
+org.bw
+
+// by : https://en.wikipedia.org/wiki/.by
+// http://tld.by/rules_2006_en.html
+// list of other 2nd level tlds ?
+by
+gov.by
+mil.by
+// Official information does not indicate that com.by is a reserved
+// second-level domain, but it's being used as one (see www.google.com.by and
+// www.yahoo.com.by, for example), so we list it here for safety's sake.
+com.by
+// http://hoster.by/
+of.by
+
+// bz : https://en.wikipedia.org/wiki/.bz
+// http://www.belizenic.bz/
+bz
+com.bz
+net.bz
+org.bz
+edu.bz
+gov.bz
+
+// ca : https://en.wikipedia.org/wiki/.ca
+ca
+// ca geographical names
+ab.ca
+bc.ca
+mb.ca
+nb.ca
+nf.ca
+nl.ca
+ns.ca
+nt.ca
+nu.ca
+on.ca
+pe.ca
+qc.ca
+sk.ca
+yk.ca
+// gc.ca: https://en.wikipedia.org/wiki/.gc.ca
+// see also: http://registry.gc.ca/en/SubdomainFAQ
+gc.ca
+
+// cat : https://en.wikipedia.org/wiki/.cat
+cat
+
+// cc : https://en.wikipedia.org/wiki/.cc
+cc
+
+// cd : https://en.wikipedia.org/wiki/.cd
+// see also: https://www.nic.cd/domain/insertDomain_2.jsp?act=1
+cd
+gov.cd
+
+// cf : https://en.wikipedia.org/wiki/.cf
+cf
+
+// cg : https://en.wikipedia.org/wiki/.cg
+cg
+
+// ch : https://en.wikipedia.org/wiki/.ch
+ch
+
+// ci : https://en.wikipedia.org/wiki/.ci
+// http://www.nic.ci/index.php?page=charte
+ci
+org.ci
+or.ci
+com.ci
+co.ci
+edu.ci
+ed.ci
+ac.ci
+net.ci
+go.ci
+asso.ci
+aéroport.ci
+int.ci
+presse.ci
+md.ci
+gouv.ci
+
+// ck : https://en.wikipedia.org/wiki/.ck
+*.ck
+!www.ck
+
+// cl : https://www.nic.cl
+// Confirmed by .CL registry <hsalgado@nic.cl>
+cl
+co.cl
+gob.cl
+gov.cl
+mil.cl
+
+// cm : https://en.wikipedia.org/wiki/.cm plus bug 981927
+cm
+co.cm
+com.cm
+gov.cm
+net.cm
+
+// cn : https://en.wikipedia.org/wiki/.cn
+// Submitted by registry <tanyaling@cnnic.cn>
+cn
+ac.cn
+com.cn
+edu.cn
+gov.cn
+net.cn
+org.cn
+mil.cn
+公司.cn
+网络.cn
+網絡.cn
+// cn geographic names
+ah.cn
+bj.cn
+cq.cn
+fj.cn
+gd.cn
+gs.cn
+gz.cn
+gx.cn
+ha.cn
+hb.cn
+he.cn
+hi.cn
+hl.cn
+hn.cn
+jl.cn
+js.cn
+jx.cn
+ln.cn
+nm.cn
+nx.cn
+qh.cn
+sc.cn
+sd.cn
+sh.cn
+sn.cn
+sx.cn
+tj.cn
+xj.cn
+xz.cn
+yn.cn
+zj.cn
+hk.cn
+mo.cn
+tw.cn
+
+// co : https://en.wikipedia.org/wiki/.co
+// Submitted by registry <tecnico@uniandes.edu.co>
+co
+arts.co
+com.co
+edu.co
+firm.co
+gov.co
+info.co
+int.co
+mil.co
+net.co
+nom.co
+org.co
+rec.co
+web.co
+
+// com : https://en.wikipedia.org/wiki/.com
+com
+
+// coop : https://en.wikipedia.org/wiki/.coop
+coop
+
+// cr : http://www.nic.cr/niccr_publico/showRegistroDominiosScreen.do
+cr
+ac.cr
+co.cr
+ed.cr
+fi.cr
+go.cr
+or.cr
+sa.cr
+
+// cu : https://en.wikipedia.org/wiki/.cu
+cu
+com.cu
+edu.cu
+org.cu
+net.cu
+gov.cu
+inf.cu
+
+// cv : https://en.wikipedia.org/wiki/.cv
+// cv : http://www.dns.cv/tldcv_portal/do?com=DS;5446457100;111;+PAGE(4000018)+K-CAT-CODIGO(RDOM)+RCNT(100); <- registration rules
+cv
+com.cv
+edu.cv
+int.cv
+nome.cv
+org.cv
+
+// cw : http://www.una.cw/cw_registry/
+// Confirmed by registry <registry@una.net> 2013-03-26
+cw
+com.cw
+edu.cw
+net.cw
+org.cw
+
+// cx : https://en.wikipedia.org/wiki/.cx
+// list of other 2nd level tlds ?
+cx
+gov.cx
+
+// cy : http://www.nic.cy/
+// Submitted by registry Panayiotou Fotia <cydns@ucy.ac.cy>
+// namespace policies URL https://www.nic.cy/portal//sites/default/files/symfonia_gia_eggrafi.pdf
+cy
+ac.cy
+biz.cy
+com.cy
+ekloges.cy
+gov.cy
+ltd.cy
+mil.cy
+net.cy
+org.cy
+press.cy
+pro.cy
+tm.cy
+
+// cz : https://en.wikipedia.org/wiki/.cz
+cz
+
+// de : https://en.wikipedia.org/wiki/.de
+// Confirmed by registry <ops@denic.de> (with technical
+// reservations) 2008-07-01
+de
+
+// dj : https://en.wikipedia.org/wiki/.dj
+dj
+
+// dk : https://en.wikipedia.org/wiki/.dk
+// Confirmed by registry <robert@dk-hostmaster.dk> 2008-06-17
+dk
+
+// dm : https://en.wikipedia.org/wiki/.dm
+dm
+com.dm
+net.dm
+org.dm
+edu.dm
+gov.dm
+
+// do : https://en.wikipedia.org/wiki/.do
+do
+art.do
+com.do
+edu.do
+gob.do
+gov.do
+mil.do
+net.do
+org.do
+sld.do
+web.do
+
+// dz : http://www.nic.dz/images/pdf_nic/charte.pdf
+dz
+art.dz
+asso.dz
+com.dz
+edu.dz
+gov.dz
+org.dz
+net.dz
+pol.dz
+soc.dz
+tm.dz
+
+// ec : http://www.nic.ec/reg/paso1.asp
+// Submitted by registry <vabboud@nic.ec>
+ec
+com.ec
+info.ec
+net.ec
+fin.ec
+k12.ec
+med.ec
+pro.ec
+org.ec
+edu.ec
+gov.ec
+gob.ec
+mil.ec
+
+// edu : https://en.wikipedia.org/wiki/.edu
+edu
+
+// ee : http://www.eenet.ee/EENet/dom_reeglid.html#lisa_B
+ee
+edu.ee
+gov.ee
+riik.ee
+lib.ee
+med.ee
+com.ee
+pri.ee
+aip.ee
+org.ee
+fie.ee
+
+// eg : https://en.wikipedia.org/wiki/.eg
+eg
+com.eg
+edu.eg
+eun.eg
+gov.eg
+mil.eg
+name.eg
+net.eg
+org.eg
+sci.eg
+
+// er : https://en.wikipedia.org/wiki/.er
+*.er
+
+// es : https://www.nic.es/site_ingles/ingles/dominios/index.html
+es
+com.es
+nom.es
+org.es
+gob.es
+edu.es
+
+// et : https://en.wikipedia.org/wiki/.et
+et
+com.et
+gov.et
+org.et
+edu.et
+biz.et
+name.et
+info.et
+net.et
+
+// eu : https://en.wikipedia.org/wiki/.eu
+eu
+
+// fi : https://www.iana.org/domains/root/db/fi.html
+fi
+// aland.fi : https://www.iana.org/domains/root/db/ax.html
+// This domain is being phased out in favor of .ax. As there are still many
+// domains under aland.fi, we still keep it on the list until aland.fi is
+// completely removed.
+aland.fi
+
+// fj : http://domains.fj/
+// Submitted by registry <garth.miller@cocca.org.nz> 2020-02-11
+fj
+ac.fj
+biz.fj
+com.fj
+gov.fj
+info.fj
+mil.fj
+name.fj
+net.fj
+org.fj
+pro.fj
+
+// fk : https://en.wikipedia.org/wiki/.fk
+*.fk
+
+// fm : https://en.wikipedia.org/wiki/.fm
+com.fm
+edu.fm
+net.fm
+org.fm
+fm
+
+// fo : https://en.wikipedia.org/wiki/.fo
+fo
+
+// fr : https://www.afnic.fr/ https://www.afnic.fr/wp-media/uploads/2022/12/afnic-naming-policy-2023-01-01.pdf
+fr
+asso.fr
+com.fr
+gouv.fr
+nom.fr
+prd.fr
+tm.fr
+// Other SLDs now selfmanaged out of AFNIC range. Former "domaines sectoriels", still registration suffixes
+avoues.fr
+cci.fr
+greta.fr
+huissier-justice.fr
+
+// ga : https://en.wikipedia.org/wiki/.ga
+ga
+
+// gb : This registry is effectively dormant
+// Submitted by registry <Damien.Shaw@ja.net>
+gb
+
+// gd : https://en.wikipedia.org/wiki/.gd
+edu.gd
+gov.gd
+gd
+
+// ge : http://www.nic.net.ge/policy_en.pdf
+ge
+com.ge
+edu.ge
+gov.ge
+org.ge
+mil.ge
+net.ge
+pvt.ge
+
+// gf : https://en.wikipedia.org/wiki/.gf
+gf
+
+// gg : http://www.channelisles.net/register-domains/
+// Confirmed by registry <nigel@channelisles.net> 2013-11-28
+gg
+co.gg
+net.gg
+org.gg
+
+// gh : https://en.wikipedia.org/wiki/.gh
+// see also: http://www.nic.gh/reg_now.php
+// Although domains directly at second level are not possible at the moment,
+// they have been possible for some time and may come back.
+gh
+com.gh
+edu.gh
+gov.gh
+org.gh
+mil.gh
+
+// gi : http://www.nic.gi/rules.html
+gi
+com.gi
+ltd.gi
+gov.gi
+mod.gi
+edu.gi
+org.gi
+
+// gl : https://en.wikipedia.org/wiki/.gl
+// http://nic.gl
+gl
+co.gl
+com.gl
+edu.gl
+net.gl
+org.gl
+
+// gm : http://www.nic.gm/htmlpages%5Cgm-policy.htm
+gm
+
+// gn : http://psg.com/dns/gn/gn.txt
+// Submitted by registry <randy@psg.com>
+gn
+ac.gn
+com.gn
+edu.gn
+gov.gn
+org.gn
+net.gn
+
+// gov : https://en.wikipedia.org/wiki/.gov
+gov
+
+// gp : http://www.nic.gp/index.php?lang=en
+gp
+com.gp
+net.gp
+mobi.gp
+edu.gp
+org.gp
+asso.gp
+
+// gq : https://en.wikipedia.org/wiki/.gq
+gq
+
+// gr : https://grweb.ics.forth.gr/english/1617-B-2005.html
+// Submitted by registry <segred@ics.forth.gr>
+gr
+com.gr
+edu.gr
+net.gr
+org.gr
+gov.gr
+
+// gs : https://en.wikipedia.org/wiki/.gs
+gs
+
+// gt : https://www.gt/sitio/registration_policy.php?lang=en
+gt
+com.gt
+edu.gt
+gob.gt
+ind.gt
+mil.gt
+net.gt
+org.gt
+
+// gu : http://gadao.gov.gu/register.html
+// University of Guam : https://www.uog.edu
+// Submitted by uognoc@triton.uog.edu
+gu
+com.gu
+edu.gu
+gov.gu
+guam.gu
+info.gu
+net.gu
+org.gu
+web.gu
+
+// gw : https://en.wikipedia.org/wiki/.gw
+// gw : https://nic.gw/regras/
+gw
+
+// gy : https://en.wikipedia.org/wiki/.gy
+// http://registry.gy/
+gy
+co.gy
+com.gy
+edu.gy
+gov.gy
+net.gy
+org.gy
+
+// hk : https://www.hkirc.hk
+// Submitted by registry <hk.tech@hkirc.hk>
+hk
+com.hk
+edu.hk
+gov.hk
+idv.hk
+net.hk
+org.hk
+公司.hk
+教育.hk
+敎育.hk
+政府.hk
+個人.hk
+个人.hk
+箇人.hk
+網络.hk
+网络.hk
+组織.hk
+網絡.hk
+网絡.hk
+组织.hk
+組織.hk
+組织.hk
+
+// hm : https://en.wikipedia.org/wiki/.hm
+hm
+
+// hn : http://www.nic.hn/politicas/ps02,,05.html
+hn
+com.hn
+edu.hn
+org.hn
+net.hn
+mil.hn
+gob.hn
+
+// hr : http://www.dns.hr/documents/pdf/HRTLD-regulations.pdf
+hr
+iz.hr
+from.hr
+name.hr
+com.hr
+
+// ht : http://www.nic.ht/info/charte.cfm
+ht
+com.ht
+shop.ht
+firm.ht
+info.ht
+adult.ht
+net.ht
+pro.ht
+org.ht
+med.ht
+art.ht
+coop.ht
+pol.ht
+asso.ht
+edu.ht
+rel.ht
+gouv.ht
+perso.ht
+
+// hu : http://www.domain.hu/domain/English/sld.html
+// Confirmed by registry <pasztor@iszt.hu> 2008-06-12
+hu
+co.hu
+info.hu
+org.hu
+priv.hu
+sport.hu
+tm.hu
+2000.hu
+agrar.hu
+bolt.hu
+casino.hu
+city.hu
+erotica.hu
+erotika.hu
+film.hu
+forum.hu
+games.hu
+hotel.hu
+ingatlan.hu
+jogasz.hu
+konyvelo.hu
+lakas.hu
+media.hu
+news.hu
+reklam.hu
+sex.hu
+shop.hu
+suli.hu
+szex.hu
+tozsde.hu
+utazas.hu
+video.hu
+
+// id : https://pandi.id/en/domain/registration-requirements/
+id
+ac.id
+biz.id
+co.id
+desa.id
+go.id
+mil.id
+my.id
+net.id
+or.id
+ponpes.id
+sch.id
+web.id
+
+// ie : https://en.wikipedia.org/wiki/.ie
+ie
+gov.ie
+
+// il :         http://www.isoc.org.il/domains/
+// see also:    https://en.isoc.org.il/il-cctld/registration-rules
+// ISOC-IL      (operated by .il Registry)
+il
+ac.il
+co.il
+gov.il
+idf.il
+k12.il
+muni.il
+net.il
+org.il
+// xn--4dbrk0ce ("Israel", Hebrew) : IL
+ישראל
+// xn--4dbgdty6c.xn--4dbrk0ce.
+אקדמיה.ישראל
+// xn--5dbhl8d.xn--4dbrk0ce.
+ישוב.ישראל
+// xn--8dbq2a.xn--4dbrk0ce.
+צהל.ישראל
+// xn--hebda8b.xn--4dbrk0ce.
+ממשל.ישראל
+
+// im : https://www.nic.im/
+// Submitted by registry <info@nic.im>
+im
+ac.im
+co.im
+com.im
+ltd.co.im
+net.im
+org.im
+plc.co.im
+tt.im
+tv.im
+
+// in : https://en.wikipedia.org/wiki/.in
+// see also: https://registry.in/policies
+// Please note, that nic.in is not an official eTLD, but used by most
+// government institutions.
+in
+5g.in
+6g.in
+ac.in
+ai.in
+am.in
+bihar.in
+biz.in
+business.in
+ca.in
+cn.in
+co.in
+com.in
+coop.in
+cs.in
+delhi.in
+dr.in
+edu.in
+er.in
+firm.in
+gen.in
+gov.in
+gujarat.in
+ind.in
+info.in
+int.in
+internet.in
+io.in
+me.in
+mil.in
+net.in
+nic.in
+org.in
+pg.in
+post.in
+pro.in
+res.in
+travel.in
+tv.in
+uk.in
+up.in
+us.in
+
+// info : https://en.wikipedia.org/wiki/.info
+info
+
+// int : https://en.wikipedia.org/wiki/.int
+// Confirmed by registry <iana-questions@icann.org> 2008-06-18
+int
+eu.int
+
+// io : http://www.nic.io/rules.htm
+// list of other 2nd level tlds ?
+io
+com.io
+
+// iq : http://www.cmc.iq/english/iq/iqregister1.htm
+iq
+gov.iq
+edu.iq
+mil.iq
+com.iq
+org.iq
+net.iq
+
+// ir : http://www.nic.ir/Terms_and_Conditions_ir,_Appendix_1_Domain_Rules
+// Also see http://www.nic.ir/Internationalized_Domain_Names
+// Two <iran>.ir entries added at request of <tech-team@nic.ir>, 2010-04-16
+ir
+ac.ir
+co.ir
+gov.ir
+id.ir
+net.ir
+org.ir
+sch.ir
+// xn--mgba3a4f16a.ir (<iran>.ir, Persian YEH)
+ایران.ir
+// xn--mgba3a4fra.ir (<iran>.ir, Arabic YEH)
+ايران.ir
+
+// is : http://www.isnic.is/domain/rules.php
+// Confirmed by registry <marius@isgate.is> 2008-12-06
+is
+net.is
+com.is
+edu.is
+gov.is
+org.is
+int.is
+
+// it : https://en.wikipedia.org/wiki/.it
+it
+gov.it
+edu.it
+// Reserved geo-names (regions and provinces):
+// https://www.nic.it/sites/default/files/archivio/docs/Regulation_assignation_v7.1.pdf
+// Regions
+abr.it
+abruzzo.it
+aosta-valley.it
+aostavalley.it
+bas.it
+basilicata.it
+cal.it
+calabria.it
+cam.it
+campania.it
+emilia-romagna.it
+emiliaromagna.it
+emr.it
+friuli-v-giulia.it
+friuli-ve-giulia.it
+friuli-vegiulia.it
+friuli-venezia-giulia.it
+friuli-veneziagiulia.it
+friuli-vgiulia.it
+friuliv-giulia.it
+friulive-giulia.it
+friulivegiulia.it
+friulivenezia-giulia.it
+friuliveneziagiulia.it
+friulivgiulia.it
+fvg.it
+laz.it
+lazio.it
+lig.it
+liguria.it
+lom.it
+lombardia.it
+lombardy.it
+lucania.it
+mar.it
+marche.it
+mol.it
+molise.it
+piedmont.it
+piemonte.it
+pmn.it
+pug.it
+puglia.it
+sar.it
+sardegna.it
+sardinia.it
+sic.it
+sicilia.it
+sicily.it
+taa.it
+tos.it
+toscana.it
+trentin-sud-tirol.it
+trentin-süd-tirol.it
+trentin-sudtirol.it
+trentin-südtirol.it
+trentin-sued-tirol.it
+trentin-suedtirol.it
+trentino-a-adige.it
+trentino-aadige.it
+trentino-alto-adige.it
+trentino-altoadige.it
+trentino-s-tirol.it
+trentino-stirol.it
+trentino-sud-tirol.it
+trentino-süd-tirol.it
+trentino-sudtirol.it
+trentino-südtirol.it
+trentino-sued-tirol.it
+trentino-suedtirol.it
+trentino.it
+trentinoa-adige.it
+trentinoaadige.it
+trentinoalto-adige.it
+trentinoaltoadige.it
+trentinos-tirol.it
+trentinostirol.it
+trentinosud-tirol.it
+trentinosüd-tirol.it
+trentinosudtirol.it
+trentinosüdtirol.it
+trentinosued-tirol.it
+trentinosuedtirol.it
+trentinsud-tirol.it
+trentinsüd-tirol.it
+trentinsudtirol.it
+trentinsüdtirol.it
+trentinsued-tirol.it
+trentinsuedtirol.it
+tuscany.it
+umb.it
+umbria.it
+val-d-aosta.it
+val-daosta.it
+vald-aosta.it
+valdaosta.it
+valle-aosta.it
+valle-d-aosta.it
+valle-daosta.it
+valleaosta.it
+valled-aosta.it
+valledaosta.it
+vallee-aoste.it
+vallée-aoste.it
+vallee-d-aoste.it
+vallée-d-aoste.it
+valleeaoste.it
+valléeaoste.it
+valleedaoste.it
+valléedaoste.it
+vao.it
+vda.it
+ven.it
+veneto.it
+// Provinces
+ag.it
+agrigento.it
+al.it
+alessandria.it
+alto-adige.it
+altoadige.it
+an.it
+ancona.it
+andria-barletta-trani.it
+andria-trani-barletta.it
+andriabarlettatrani.it
+andriatranibarletta.it
+ao.it
+aosta.it
+aoste.it
+ap.it
+aq.it
+aquila.it
+ar.it
+arezzo.it
+ascoli-piceno.it
+ascolipiceno.it
+asti.it
+at.it
+av.it
+avellino.it
+ba.it
+balsan-sudtirol.it
+balsan-südtirol.it
+balsan-suedtirol.it
+balsan.it
+bari.it
+barletta-trani-andria.it
+barlettatraniandria.it
+belluno.it
+benevento.it
+bergamo.it
+bg.it
+bi.it
+biella.it
+bl.it
+bn.it
+bo.it
+bologna.it
+bolzano-altoadige.it
+bolzano.it
+bozen-sudtirol.it
+bozen-südtirol.it
+bozen-suedtirol.it
+bozen.it
+br.it
+brescia.it
+brindisi.it
+bs.it
+bt.it
+bulsan-sudtirol.it
+bulsan-südtirol.it
+bulsan-suedtirol.it
+bulsan.it
+bz.it
+ca.it
+cagliari.it
+caltanissetta.it
+campidano-medio.it
+campidanomedio.it
+campobasso.it
+carbonia-iglesias.it
+carboniaiglesias.it
+carrara-massa.it
+carraramassa.it
+caserta.it
+catania.it
+catanzaro.it
+cb.it
+ce.it
+cesena-forli.it
+cesena-forlì.it
+cesenaforli.it
+cesenaforlì.it
+ch.it
+chieti.it
+ci.it
+cl.it
+cn.it
+co.it
+como.it
+cosenza.it
+cr.it
+cremona.it
+crotone.it
+cs.it
+ct.it
+cuneo.it
+cz.it
+dell-ogliastra.it
+dellogliastra.it
+en.it
+enna.it
+fc.it
+fe.it
+fermo.it
+ferrara.it
+fg.it
+fi.it
+firenze.it
+florence.it
+fm.it
+foggia.it
+forli-cesena.it
+forlì-cesena.it
+forlicesena.it
+forlìcesena.it
+fr.it
+frosinone.it
+ge.it
+genoa.it
+genova.it
+go.it
+gorizia.it
+gr.it
+grosseto.it
+iglesias-carbonia.it
+iglesiascarbonia.it
+im.it
+imperia.it
+is.it
+isernia.it
+kr.it
+la-spezia.it
+laquila.it
+laspezia.it
+latina.it
+lc.it
+le.it
+lecce.it
+lecco.it
+li.it
+livorno.it
+lo.it
+lodi.it
+lt.it
+lu.it
+lucca.it
+macerata.it
+mantova.it
+massa-carrara.it
+massacarrara.it
+matera.it
+mb.it
+mc.it
+me.it
+medio-campidano.it
+mediocampidano.it
+messina.it
+mi.it
+milan.it
+milano.it
+mn.it
+mo.it
+modena.it
+monza-brianza.it
+monza-e-della-brianza.it
+monza.it
+monzabrianza.it
+monzaebrianza.it
+monzaedellabrianza.it
+ms.it
+mt.it
+na.it
+naples.it
+napoli.it
+no.it
+novara.it
+nu.it
+nuoro.it
+og.it
+ogliastra.it
+olbia-tempio.it
+olbiatempio.it
+or.it
+oristano.it
+ot.it
+pa.it
+padova.it
+padua.it
+palermo.it
+parma.it
+pavia.it
+pc.it
+pd.it
+pe.it
+perugia.it
+pesaro-urbino.it
+pesarourbino.it
+pescara.it
+pg.it
+pi.it
+piacenza.it
+pisa.it
+pistoia.it
+pn.it
+po.it
+pordenone.it
+potenza.it
+pr.it
+prato.it
+pt.it
+pu.it
+pv.it
+pz.it
+ra.it
+ragusa.it
+ravenna.it
+rc.it
+re.it
+reggio-calabria.it
+reggio-emilia.it
+reggiocalabria.it
+reggioemilia.it
+rg.it
+ri.it
+rieti.it
+rimini.it
+rm.it
+rn.it
+ro.it
+roma.it
+rome.it
+rovigo.it
+sa.it
+salerno.it
+sassari.it
+savona.it
+si.it
+siena.it
+siracusa.it
+so.it
+sondrio.it
+sp.it
+sr.it
+ss.it
+suedtirol.it
+südtirol.it
+sv.it
+ta.it
+taranto.it
+te.it
+tempio-olbia.it
+tempioolbia.it
+teramo.it
+terni.it
+tn.it
+to.it
+torino.it
+tp.it
+tr.it
+trani-andria-barletta.it
+trani-barletta-andria.it
+traniandriabarletta.it
+tranibarlettaandria.it
+trapani.it
+trento.it
+treviso.it
+trieste.it
+ts.it
+turin.it
+tv.it
+ud.it
+udine.it
+urbino-pesaro.it
+urbinopesaro.it
+va.it
+varese.it
+vb.it
+vc.it
+ve.it
+venezia.it
+venice.it
+verbania.it
+vercelli.it
+verona.it
+vi.it
+vibo-valentia.it
+vibovalentia.it
+vicenza.it
+viterbo.it
+vr.it
+vs.it
+vt.it
+vv.it
+
+// je : http://www.channelisles.net/register-domains/
+// Confirmed by registry <nigel@channelisles.net> 2013-11-28
+je
+co.je
+net.je
+org.je
+
+// jm : http://www.com.jm/register.html
+*.jm
+
+// jo : http://www.dns.jo/Registration_policy.aspx
+jo
+com.jo
+org.jo
+net.jo
+edu.jo
+sch.jo
+gov.jo
+mil.jo
+name.jo
+
+// jobs : https://en.wikipedia.org/wiki/.jobs
+jobs
+
+// jp : https://en.wikipedia.org/wiki/.jp
+// http://jprs.co.jp/en/jpdomain.html
+// Submitted by registry <info@jprs.jp>
+jp
+// jp organizational type names
+ac.jp
+ad.jp
+co.jp
+ed.jp
+go.jp
+gr.jp
+lg.jp
+ne.jp
+or.jp
+// jp prefecture type names
+aichi.jp
+akita.jp
+aomori.jp
+chiba.jp
+ehime.jp
+fukui.jp
+fukuoka.jp
+fukushima.jp
+gifu.jp
+gunma.jp
+hiroshima.jp
+hokkaido.jp
+hyogo.jp
+ibaraki.jp
+ishikawa.jp
+iwate.jp
+kagawa.jp
+kagoshima.jp
+kanagawa.jp
+kochi.jp
+kumamoto.jp
+kyoto.jp
+mie.jp
+miyagi.jp
+miyazaki.jp
+nagano.jp
+nagasaki.jp
+nara.jp
+niigata.jp
+oita.jp
+okayama.jp
+okinawa.jp
+osaka.jp
+saga.jp
+saitama.jp
+shiga.jp
+shimane.jp
+shizuoka.jp
+tochigi.jp
+tokushima.jp
+tokyo.jp
+tottori.jp
+toyama.jp
+wakayama.jp
+yamagata.jp
+yamaguchi.jp
+yamanashi.jp
+栃木.jp
+愛知.jp
+愛媛.jp
+兵庫.jp
+熊本.jp
+茨城.jp
+北海道.jp
+千葉.jp
+和歌山.jp
+長崎.jp
+長野.jp
+新潟.jp
+青森.jp
+静岡.jp
+東京.jp
+石川.jp
+埼玉.jp
+三重.jp
+京都.jp
+佐賀.jp
+大分.jp
+大阪.jp
+奈良.jp
+宮城.jp
+宮崎.jp
+富山.jp
+山口.jp
+山形.jp
+山梨.jp
+岩手.jp
+岐阜.jp
+岡山.jp
+島根.jp
+広島.jp
+徳島.jp
+沖縄.jp
+滋賀.jp
+神奈川.jp
+福井.jp
+福岡.jp
+福島.jp
+秋田.jp
+群馬.jp
+香川.jp
+高知.jp
+鳥取.jp
+鹿児島.jp
+// jp geographic type names
+// http://jprs.jp/doc/rule/saisoku-1.html
+*.kawasaki.jp
+*.kitakyushu.jp
+*.kobe.jp
+*.nagoya.jp
+*.sapporo.jp
+*.sendai.jp
+*.yokohama.jp
+!city.kawasaki.jp
+!city.kitakyushu.jp
+!city.kobe.jp
+!city.nagoya.jp
+!city.sapporo.jp
+!city.sendai.jp
+!city.yokohama.jp
+// 4th level registration
+aisai.aichi.jp
+ama.aichi.jp
+anjo.aichi.jp
+asuke.aichi.jp
+chiryu.aichi.jp
+chita.aichi.jp
+fuso.aichi.jp
+gamagori.aichi.jp
+handa.aichi.jp
+hazu.aichi.jp
+hekinan.aichi.jp
+higashiura.aichi.jp
+ichinomiya.aichi.jp
+inazawa.aichi.jp
+inuyama.aichi.jp
+isshiki.aichi.jp
+iwakura.aichi.jp
+kanie.aichi.jp
+kariya.aichi.jp
+kasugai.aichi.jp
+kira.aichi.jp
+kiyosu.aichi.jp
+komaki.aichi.jp
+konan.aichi.jp
+kota.aichi.jp
+mihama.aichi.jp
+miyoshi.aichi.jp
+nishio.aichi.jp
+nisshin.aichi.jp
+obu.aichi.jp
+oguchi.aichi.jp
+oharu.aichi.jp
+okazaki.aichi.jp
+owariasahi.aichi.jp
+seto.aichi.jp
+shikatsu.aichi.jp
+shinshiro.aichi.jp
+shitara.aichi.jp
+tahara.aichi.jp
+takahama.aichi.jp
+tobishima.aichi.jp
+toei.aichi.jp
+togo.aichi.jp
+tokai.aichi.jp
+tokoname.aichi.jp
+toyoake.aichi.jp
+toyohashi.aichi.jp
+toyokawa.aichi.jp
+toyone.aichi.jp
+toyota.aichi.jp
+tsushima.aichi.jp
+yatomi.aichi.jp
+akita.akita.jp
+daisen.akita.jp
+fujisato.akita.jp
+gojome.akita.jp
+hachirogata.akita.jp
+happou.akita.jp
+higashinaruse.akita.jp
+honjo.akita.jp
+honjyo.akita.jp
+ikawa.akita.jp
+kamikoani.akita.jp
+kamioka.akita.jp
+katagami.akita.jp
+kazuno.akita.jp
+kitaakita.akita.jp
+kosaka.akita.jp
+kyowa.akita.jp
+misato.akita.jp
+mitane.akita.jp
+moriyoshi.akita.jp
+nikaho.akita.jp
+noshiro.akita.jp
+odate.akita.jp
+oga.akita.jp
+ogata.akita.jp
+semboku.akita.jp
+yokote.akita.jp
+yurihonjo.akita.jp
+aomori.aomori.jp
+gonohe.aomori.jp
+hachinohe.aomori.jp
+hashikami.aomori.jp
+hiranai.aomori.jp
+hirosaki.aomori.jp
+itayanagi.aomori.jp
+kuroishi.aomori.jp
+misawa.aomori.jp
+mutsu.aomori.jp
+nakadomari.aomori.jp
+noheji.aomori.jp
+oirase.aomori.jp
+owani.aomori.jp
+rokunohe.aomori.jp
+sannohe.aomori.jp
+shichinohe.aomori.jp
+shingo.aomori.jp
+takko.aomori.jp
+towada.aomori.jp
+tsugaru.aomori.jp
+tsuruta.aomori.jp
+abiko.chiba.jp
+asahi.chiba.jp
+chonan.chiba.jp
+chosei.chiba.jp
+choshi.chiba.jp
+chuo.chiba.jp
+funabashi.chiba.jp
+futtsu.chiba.jp
+hanamigawa.chiba.jp
+ichihara.chiba.jp
+ichikawa.chiba.jp
+ichinomiya.chiba.jp
+inzai.chiba.jp
+isumi.chiba.jp
+kamagaya.chiba.jp
+kamogawa.chiba.jp
+kashiwa.chiba.jp
+katori.chiba.jp
+katsuura.chiba.jp
+kimitsu.chiba.jp
+kisarazu.chiba.jp
+kozaki.chiba.jp
+kujukuri.chiba.jp
+kyonan.chiba.jp
+matsudo.chiba.jp
+midori.chiba.jp
+mihama.chiba.jp
+minamiboso.chiba.jp
+mobara.chiba.jp
+mutsuzawa.chiba.jp
+nagara.chiba.jp
+nagareyama.chiba.jp
+narashino.chiba.jp
+narita.chiba.jp
+noda.chiba.jp
+oamishirasato.chiba.jp
+omigawa.chiba.jp
+onjuku.chiba.jp
+otaki.chiba.jp
+sakae.chiba.jp
+sakura.chiba.jp
+shimofusa.chiba.jp
+shirako.chiba.jp
+shiroi.chiba.jp
+shisui.chiba.jp
+sodegaura.chiba.jp
+sosa.chiba.jp
+tako.chiba.jp
+tateyama.chiba.jp
+togane.chiba.jp
+tohnosho.chiba.jp
+tomisato.chiba.jp
+urayasu.chiba.jp
+yachimata.chiba.jp
+yachiyo.chiba.jp
+yokaichiba.chiba.jp
+yokoshibahikari.chiba.jp
+yotsukaido.chiba.jp
+ainan.ehime.jp
+honai.ehime.jp
+ikata.ehime.jp
+imabari.ehime.jp
+iyo.ehime.jp
+kamijima.ehime.jp
+kihoku.ehime.jp
+kumakogen.ehime.jp
+masaki.ehime.jp
+matsuno.ehime.jp
+matsuyama.ehime.jp
+namikata.ehime.jp
+niihama.ehime.jp
+ozu.ehime.jp
+saijo.ehime.jp
+seiyo.ehime.jp
+shikokuchuo.ehime.jp
+tobe.ehime.jp
+toon.ehime.jp
+uchiko.ehime.jp
+uwajima.ehime.jp
+yawatahama.ehime.jp
+echizen.fukui.jp
+eiheiji.fukui.jp
+fukui.fukui.jp
+ikeda.fukui.jp
+katsuyama.fukui.jp
+mihama.fukui.jp
+minamiechizen.fukui.jp
+obama.fukui.jp
+ohi.fukui.jp
+ono.fukui.jp
+sabae.fukui.jp
+sakai.fukui.jp
+takahama.fukui.jp
+tsuruga.fukui.jp
+wakasa.fukui.jp
+ashiya.fukuoka.jp
+buzen.fukuoka.jp
+chikugo.fukuoka.jp
+chikuho.fukuoka.jp
+chikujo.fukuoka.jp
+chikushino.fukuoka.jp
+chikuzen.fukuoka.jp
+chuo.fukuoka.jp
+dazaifu.fukuoka.jp
+fukuchi.fukuoka.jp
+hakata.fukuoka.jp
+higashi.fukuoka.jp
+hirokawa.fukuoka.jp
+hisayama.fukuoka.jp
+iizuka.fukuoka.jp
+inatsuki.fukuoka.jp
+kaho.fukuoka.jp
+kasuga.fukuoka.jp
+kasuya.fukuoka.jp
+kawara.fukuoka.jp
+keisen.fukuoka.jp
+koga.fukuoka.jp
+kurate.fukuoka.jp
+kurogi.fukuoka.jp
+kurume.fukuoka.jp
+minami.fukuoka.jp
+miyako.fukuoka.jp
+miyama.fukuoka.jp
+miyawaka.fukuoka.jp
+mizumaki.fukuoka.jp
+munakata.fukuoka.jp
+nakagawa.fukuoka.jp
+nakama.fukuoka.jp
+nishi.fukuoka.jp
+nogata.fukuoka.jp
+ogori.fukuoka.jp
+okagaki.fukuoka.jp
+okawa.fukuoka.jp
+oki.fukuoka.jp
+omuta.fukuoka.jp
+onga.fukuoka.jp
+onojo.fukuoka.jp
+oto.fukuoka.jp
+saigawa.fukuoka.jp
+sasaguri.fukuoka.jp
+shingu.fukuoka.jp
+shinyoshitomi.fukuoka.jp
+shonai.fukuoka.jp
+soeda.fukuoka.jp
+sue.fukuoka.jp
+tachiarai.fukuoka.jp
+tagawa.fukuoka.jp
+takata.fukuoka.jp
+toho.fukuoka.jp
+toyotsu.fukuoka.jp
+tsuiki.fukuoka.jp
+ukiha.fukuoka.jp
+umi.fukuoka.jp
+usui.fukuoka.jp
+yamada.fukuoka.jp
+yame.fukuoka.jp
+yanagawa.fukuoka.jp
+yukuhashi.fukuoka.jp
+aizubange.fukushima.jp
+aizumisato.fukushima.jp
+aizuwakamatsu.fukushima.jp
+asakawa.fukushima.jp
+bandai.fukushima.jp
+date.fukushima.jp
+fukushima.fukushima.jp
+furudono.fukushima.jp
+futaba.fukushima.jp
+hanawa.fukushima.jp
+higashi.fukushima.jp
+hirata.fukushima.jp
+hirono.fukushima.jp
+iitate.fukushima.jp
+inawashiro.fukushima.jp
+ishikawa.fukushima.jp
+iwaki.fukushima.jp
+izumizaki.fukushima.jp
+kagamiishi.fukushima.jp
+kaneyama.fukushima.jp
+kawamata.fukushima.jp
+kitakata.fukushima.jp
+kitashiobara.fukushima.jp
+koori.fukushima.jp
+koriyama.fukushima.jp
+kunimi.fukushima.jp
+miharu.fukushima.jp
+mishima.fukushima.jp
+namie.fukushima.jp
+nango.fukushima.jp
+nishiaizu.fukushima.jp
+nishigo.fukushima.jp
+okuma.fukushima.jp
+omotego.fukushima.jp
+ono.fukushima.jp
+otama.fukushima.jp
+samegawa.fukushima.jp
+shimogo.fukushima.jp
+shirakawa.fukushima.jp
+showa.fukushima.jp
+soma.fukushima.jp
+sukagawa.fukushima.jp
+taishin.fukushima.jp
+tamakawa.fukushima.jp
+tanagura.fukushima.jp
+tenei.fukushima.jp
+yabuki.fukushima.jp
+yamato.fukushima.jp
+yamatsuri.fukushima.jp
+yanaizu.fukushima.jp
+yugawa.fukushima.jp
+anpachi.gifu.jp
+ena.gifu.jp
+gifu.gifu.jp
+ginan.gifu.jp
+godo.gifu.jp
+gujo.gifu.jp
+hashima.gifu.jp
+hichiso.gifu.jp
+hida.gifu.jp
+higashishirakawa.gifu.jp
+ibigawa.gifu.jp
+ikeda.gifu.jp
+kakamigahara.gifu.jp
+kani.gifu.jp
+kasahara.gifu.jp
+kasamatsu.gifu.jp
+kawaue.gifu.jp
+kitagata.gifu.jp
+mino.gifu.jp
+minokamo.gifu.jp
+mitake.gifu.jp
+mizunami.gifu.jp
+motosu.gifu.jp
+nakatsugawa.gifu.jp
+ogaki.gifu.jp
+sakahogi.gifu.jp
+seki.gifu.jp
+sekigahara.gifu.jp
+shirakawa.gifu.jp
+tajimi.gifu.jp
+takayama.gifu.jp
+tarui.gifu.jp
+toki.gifu.jp
+tomika.gifu.jp
+wanouchi.gifu.jp
+yamagata.gifu.jp
+yaotsu.gifu.jp
+yoro.gifu.jp
+annaka.gunma.jp
+chiyoda.gunma.jp
+fujioka.gunma.jp
+higashiagatsuma.gunma.jp
+isesaki.gunma.jp
+itakura.gunma.jp
+kanna.gunma.jp
+kanra.gunma.jp
+katashina.gunma.jp
+kawaba.gunma.jp
+kiryu.gunma.jp
+kusatsu.gunma.jp
+maebashi.gunma.jp
+meiwa.gunma.jp
+midori.gunma.jp
+minakami.gunma.jp
+naganohara.gunma.jp
+nakanojo.gunma.jp
+nanmoku.gunma.jp
+numata.gunma.jp
+oizumi.gunma.jp
+ora.gunma.jp
+ota.gunma.jp
+shibukawa.gunma.jp
+shimonita.gunma.jp
+shinto.gunma.jp
+showa.gunma.jp
+takasaki.gunma.jp
+takayama.gunma.jp
+tamamura.gunma.jp
+tatebayashi.gunma.jp
+tomioka.gunma.jp
+tsukiyono.gunma.jp
+tsumagoi.gunma.jp
+ueno.gunma.jp
+yoshioka.gunma.jp
+asaminami.hiroshima.jp
+daiwa.hiroshima.jp
+etajima.hiroshima.jp
+fuchu.hiroshima.jp
+fukuyama.hiroshima.jp
+hatsukaichi.hiroshima.jp
+higashihiroshima.hiroshima.jp
+hongo.hiroshima.jp
+jinsekikogen.hiroshima.jp
+kaita.hiroshima.jp
+kui.hiroshima.jp
+kumano.hiroshima.jp
+kure.hiroshima.jp
+mihara.hiroshima.jp
+miyoshi.hiroshima.jp
+naka.hiroshima.jp
+onomichi.hiroshima.jp
+osakikamijima.hiroshima.jp
+otake.hiroshima.jp
+saka.hiroshima.jp
+sera.hiroshima.jp
+seranishi.hiroshima.jp
+shinichi.hiroshima.jp
+shobara.hiroshima.jp
+takehara.hiroshima.jp
+abashiri.hokkaido.jp
+abira.hokkaido.jp
+aibetsu.hokkaido.jp
+akabira.hokkaido.jp
+akkeshi.hokkaido.jp
+asahikawa.hokkaido.jp
+ashibetsu.hokkaido.jp
+ashoro.hokkaido.jp
+assabu.hokkaido.jp
+atsuma.hokkaido.jp
+bibai.hokkaido.jp
+biei.hokkaido.jp
+bifuka.hokkaido.jp
+bihoro.hokkaido.jp
+biratori.hokkaido.jp
+chippubetsu.hokkaido.jp
+chitose.hokkaido.jp
+date.hokkaido.jp
+ebetsu.hokkaido.jp
+embetsu.hokkaido.jp
+eniwa.hokkaido.jp
+erimo.hokkaido.jp
+esan.hokkaido.jp
+esashi.hokkaido.jp
+fukagawa.hokkaido.jp
+fukushima.hokkaido.jp
+furano.hokkaido.jp
+furubira.hokkaido.jp
+haboro.hokkaido.jp
+hakodate.hokkaido.jp
+hamatonbetsu.hokkaido.jp
+hidaka.hokkaido.jp
+higashikagura.hokkaido.jp
+higashikawa.hokkaido.jp
+hiroo.hokkaido.jp
+hokuryu.hokkaido.jp
+hokuto.hokkaido.jp
+honbetsu.hokkaido.jp
+horokanai.hokkaido.jp
+horonobe.hokkaido.jp
+ikeda.hokkaido.jp
+imakane.hokkaido.jp
+ishikari.hokkaido.jp
+iwamizawa.hokkaido.jp
+iwanai.hokkaido.jp
+kamifurano.hokkaido.jp
+kamikawa.hokkaido.jp
+kamishihoro.hokkaido.jp
+kamisunagawa.hokkaido.jp
+kamoenai.hokkaido.jp
+kayabe.hokkaido.jp
+kembuchi.hokkaido.jp
+kikonai.hokkaido.jp
+kimobetsu.hokkaido.jp
+kitahiroshima.hokkaido.jp
+kitami.hokkaido.jp
+kiyosato.hokkaido.jp
+koshimizu.hokkaido.jp
+kunneppu.hokkaido.jp
+kuriyama.hokkaido.jp
+kuromatsunai.hokkaido.jp
+kushiro.hokkaido.jp
+kutchan.hokkaido.jp
+kyowa.hokkaido.jp
+mashike.hokkaido.jp
+matsumae.hokkaido.jp
+mikasa.hokkaido.jp
+minamifurano.hokkaido.jp
+mombetsu.hokkaido.jp
+moseushi.hokkaido.jp
+mukawa.hokkaido.jp
+muroran.hokkaido.jp
+naie.hokkaido.jp
+nakagawa.hokkaido.jp
+nakasatsunai.hokkaido.jp
+nakatombetsu.hokkaido.jp
+nanae.hokkaido.jp
+nanporo.hokkaido.jp
+nayoro.hokkaido.jp
+nemuro.hokkaido.jp
+niikappu.hokkaido.jp
+niki.hokkaido.jp
+nishiokoppe.hokkaido.jp
+noboribetsu.hokkaido.jp
+numata.hokkaido.jp
+obihiro.hokkaido.jp
+obira.hokkaido.jp
+oketo.hokkaido.jp
+okoppe.hokkaido.jp
+otaru.hokkaido.jp
+otobe.hokkaido.jp
+otofuke.hokkaido.jp
+otoineppu.hokkaido.jp
+oumu.hokkaido.jp
+ozora.hokkaido.jp
+pippu.hokkaido.jp
+rankoshi.hokkaido.jp
+rebun.hokkaido.jp
+rikubetsu.hokkaido.jp
+rishiri.hokkaido.jp
+rishirifuji.hokkaido.jp
+saroma.hokkaido.jp
+sarufutsu.hokkaido.jp
+shakotan.hokkaido.jp
+shari.hokkaido.jp
+shibecha.hokkaido.jp
+shibetsu.hokkaido.jp
+shikabe.hokkaido.jp
+shikaoi.hokkaido.jp
+shimamaki.hokkaido.jp
+shimizu.hokkaido.jp
+shimokawa.hokkaido.jp
+shinshinotsu.hokkaido.jp
+shintoku.hokkaido.jp
+shiranuka.hokkaido.jp
+shiraoi.hokkaido.jp
+shiriuchi.hokkaido.jp
+sobetsu.hokkaido.jp
+sunagawa.hokkaido.jp
+taiki.hokkaido.jp
+takasu.hokkaido.jp
+takikawa.hokkaido.jp
+takinoue.hokkaido.jp
+teshikaga.hokkaido.jp
+tobetsu.hokkaido.jp
+tohma.hokkaido.jp
+tomakomai.hokkaido.jp
+tomari.hokkaido.jp
+toya.hokkaido.jp
+toyako.hokkaido.jp
+toyotomi.hokkaido.jp
+toyoura.hokkaido.jp
+tsubetsu.hokkaido.jp
+tsukigata.hokkaido.jp
+urakawa.hokkaido.jp
+urausu.hokkaido.jp
+uryu.hokkaido.jp
+utashinai.hokkaido.jp
+wakkanai.hokkaido.jp
+wassamu.hokkaido.jp
+yakumo.hokkaido.jp
+yoichi.hokkaido.jp
+aioi.hyogo.jp
+akashi.hyogo.jp
+ako.hyogo.jp
+amagasaki.hyogo.jp
+aogaki.hyogo.jp
+asago.hyogo.jp
+ashiya.hyogo.jp
+awaji.hyogo.jp
+fukusaki.hyogo.jp
+goshiki.hyogo.jp
+harima.hyogo.jp
+himeji.hyogo.jp
+ichikawa.hyogo.jp
+inagawa.hyogo.jp
+itami.hyogo.jp
+kakogawa.hyogo.jp
+kamigori.hyogo.jp
+kamikawa.hyogo.jp
+kasai.hyogo.jp
+kasuga.hyogo.jp
+kawanishi.hyogo.jp
+miki.hyogo.jp
+minamiawaji.hyogo.jp
+nishinomiya.hyogo.jp
+nishiwaki.hyogo.jp
+ono.hyogo.jp
+sanda.hyogo.jp
+sannan.hyogo.jp
+sasayama.hyogo.jp
+sayo.hyogo.jp
+shingu.hyogo.jp
+shinonsen.hyogo.jp
+shiso.hyogo.jp
+sumoto.hyogo.jp
+taishi.hyogo.jp
+taka.hyogo.jp
+takarazuka.hyogo.jp
+takasago.hyogo.jp
+takino.hyogo.jp
+tamba.hyogo.jp
+tatsuno.hyogo.jp
+toyooka.hyogo.jp
+yabu.hyogo.jp
+yashiro.hyogo.jp
+yoka.hyogo.jp
+yokawa.hyogo.jp
+ami.ibaraki.jp
+asahi.ibaraki.jp
+bando.ibaraki.jp
+chikusei.ibaraki.jp
+daigo.ibaraki.jp
+fujishiro.ibaraki.jp
+hitachi.ibaraki.jp
+hitachinaka.ibaraki.jp
+hitachiomiya.ibaraki.jp
+hitachiota.ibaraki.jp
+ibaraki.ibaraki.jp
+ina.ibaraki.jp
+inashiki.ibaraki.jp
+itako.ibaraki.jp
+iwama.ibaraki.jp
+joso.ibaraki.jp
+kamisu.ibaraki.jp
+kasama.ibaraki.jp
+kashima.ibaraki.jp
+kasumigaura.ibaraki.jp
+koga.ibaraki.jp
+miho.ibaraki.jp
+mito.ibaraki.jp
+moriya.ibaraki.jp
+naka.ibaraki.jp
+namegata.ibaraki.jp
+oarai.ibaraki.jp
+ogawa.ibaraki.jp
+omitama.ibaraki.jp
+ryugasaki.ibaraki.jp
+sakai.ibaraki.jp
+sakuragawa.ibaraki.jp
+shimodate.ibaraki.jp
+shimotsuma.ibaraki.jp
+shirosato.ibaraki.jp
+sowa.ibaraki.jp
+suifu.ibaraki.jp
+takahagi.ibaraki.jp
+tamatsukuri.ibaraki.jp
+tokai.ibaraki.jp
+tomobe.ibaraki.jp
+tone.ibaraki.jp
+toride.ibaraki.jp
+tsuchiura.ibaraki.jp
+tsukuba.ibaraki.jp
+uchihara.ibaraki.jp
+ushiku.ibaraki.jp
+yachiyo.ibaraki.jp
+yamagata.ibaraki.jp
+yawara.ibaraki.jp
+yuki.ibaraki.jp
+anamizu.ishikawa.jp
+hakui.ishikawa.jp
+hakusan.ishikawa.jp
+kaga.ishikawa.jp
+kahoku.ishikawa.jp
+kanazawa.ishikawa.jp
+kawakita.ishikawa.jp
+komatsu.ishikawa.jp
+nakanoto.ishikawa.jp
+nanao.ishikawa.jp
+nomi.ishikawa.jp
+nonoichi.ishikawa.jp
+noto.ishikawa.jp
+shika.ishikawa.jp
+suzu.ishikawa.jp
+tsubata.ishikawa.jp
+tsurugi.ishikawa.jp
+uchinada.ishikawa.jp
+wajima.ishikawa.jp
+fudai.iwate.jp
+fujisawa.iwate.jp
+hanamaki.iwate.jp
+hiraizumi.iwate.jp
+hirono.iwate.jp
+ichinohe.iwate.jp
+ichinoseki.iwate.jp
+iwaizumi.iwate.jp
+iwate.iwate.jp
+joboji.iwate.jp
+kamaishi.iwate.jp
+kanegasaki.iwate.jp
+karumai.iwate.jp
+kawai.iwate.jp
+kitakami.iwate.jp
+kuji.iwate.jp
+kunohe.iwate.jp
+kuzumaki.iwate.jp
+miyako.iwate.jp
+mizusawa.iwate.jp
+morioka.iwate.jp
+ninohe.iwate.jp
+noda.iwate.jp
+ofunato.iwate.jp
+oshu.iwate.jp
+otsuchi.iwate.jp
+rikuzentakata.iwate.jp
+shiwa.iwate.jp
+shizukuishi.iwate.jp
+sumita.iwate.jp
+tanohata.iwate.jp
+tono.iwate.jp
+yahaba.iwate.jp
+yamada.iwate.jp
+ayagawa.kagawa.jp
+higashikagawa.kagawa.jp
+kanonji.kagawa.jp
+kotohira.kagawa.jp
+manno.kagawa.jp
+marugame.kagawa.jp
+mitoyo.kagawa.jp
+naoshima.kagawa.jp
+sanuki.kagawa.jp
+tadotsu.kagawa.jp
+takamatsu.kagawa.jp
+tonosho.kagawa.jp
+uchinomi.kagawa.jp
+utazu.kagawa.jp
+zentsuji.kagawa.jp
+akune.kagoshima.jp
+amami.kagoshima.jp
+hioki.kagoshima.jp
+isa.kagoshima.jp
+isen.kagoshima.jp
+izumi.kagoshima.jp
+kagoshima.kagoshima.jp
+kanoya.kagoshima.jp
+kawanabe.kagoshima.jp
+kinko.kagoshima.jp
+kouyama.kagoshima.jp
+makurazaki.kagoshima.jp
+matsumoto.kagoshima.jp
+minamitane.kagoshima.jp
+nakatane.kagoshima.jp
+nishinoomote.kagoshima.jp
+satsumasendai.kagoshima.jp
+soo.kagoshima.jp
+tarumizu.kagoshima.jp
+yusui.kagoshima.jp
+aikawa.kanagawa.jp
+atsugi.kanagawa.jp
+ayase.kanagawa.jp
+chigasaki.kanagawa.jp
+ebina.kanagawa.jp
+fujisawa.kanagawa.jp
+hadano.kanagawa.jp
+hakone.kanagawa.jp
+hiratsuka.kanagawa.jp
+isehara.kanagawa.jp
+kaisei.kanagawa.jp
+kamakura.kanagawa.jp
+kiyokawa.kanagawa.jp
+matsuda.kanagawa.jp
+minamiashigara.kanagawa.jp
+miura.kanagawa.jp
+nakai.kanagawa.jp
+ninomiya.kanagawa.jp
+odawara.kanagawa.jp
+oi.kanagawa.jp
+oiso.kanagawa.jp
+sagamihara.kanagawa.jp
+samukawa.kanagawa.jp
+tsukui.kanagawa.jp
+yamakita.kanagawa.jp
+yamato.kanagawa.jp
+yokosuka.kanagawa.jp
+yugawara.kanagawa.jp
+zama.kanagawa.jp
+zushi.kanagawa.jp
+aki.kochi.jp
+geisei.kochi.jp
+hidaka.kochi.jp
+higashitsuno.kochi.jp
+ino.kochi.jp
+kagami.kochi.jp
+kami.kochi.jp
+kitagawa.kochi.jp
+kochi.kochi.jp
+mihara.kochi.jp
+motoyama.kochi.jp
+muroto.kochi.jp
+nahari.kochi.jp
+nakamura.kochi.jp
+nankoku.kochi.jp
+nishitosa.kochi.jp
+niyodogawa.kochi.jp
+ochi.kochi.jp
+okawa.kochi.jp
+otoyo.kochi.jp
+otsuki.kochi.jp
+sakawa.kochi.jp
+sukumo.kochi.jp
+susaki.kochi.jp
+tosa.kochi.jp
+tosashimizu.kochi.jp
+toyo.kochi.jp
+tsuno.kochi.jp
+umaji.kochi.jp
+yasuda.kochi.jp
+yusuhara.kochi.jp
+amakusa.kumamoto.jp
+arao.kumamoto.jp
+aso.kumamoto.jp
+choyo.kumamoto.jp
+gyokuto.kumamoto.jp
+kamiamakusa.kumamoto.jp
+kikuchi.kumamoto.jp
+kumamoto.kumamoto.jp
+mashiki.kumamoto.jp
+mifune.kumamoto.jp
+minamata.kumamoto.jp
+minamioguni.kumamoto.jp
+nagasu.kumamoto.jp
+nishihara.kumamoto.jp
+oguni.kumamoto.jp
+ozu.kumamoto.jp
+sumoto.kumamoto.jp
+takamori.kumamoto.jp
+uki.kumamoto.jp
+uto.kumamoto.jp
+yamaga.kumamoto.jp
+yamato.kumamoto.jp
+yatsushiro.kumamoto.jp
+ayabe.kyoto.jp
+fukuchiyama.kyoto.jp
+higashiyama.kyoto.jp
+ide.kyoto.jp
+ine.kyoto.jp
+joyo.kyoto.jp
+kameoka.kyoto.jp
+kamo.kyoto.jp
+kita.kyoto.jp
+kizu.kyoto.jp
+kumiyama.kyoto.jp
+kyotamba.kyoto.jp
+kyotanabe.kyoto.jp
+kyotango.kyoto.jp
+maizuru.kyoto.jp
+minami.kyoto.jp
+minamiyamashiro.kyoto.jp
+miyazu.kyoto.jp
+muko.kyoto.jp
+nagaokakyo.kyoto.jp
+nakagyo.kyoto.jp
+nantan.kyoto.jp
+oyamazaki.kyoto.jp
+sakyo.kyoto.jp
+seika.kyoto.jp
+tanabe.kyoto.jp
+uji.kyoto.jp
+ujitawara.kyoto.jp
+wazuka.kyoto.jp
+yamashina.kyoto.jp
+yawata.kyoto.jp
+asahi.mie.jp
+inabe.mie.jp
+ise.mie.jp
+kameyama.mie.jp
+kawagoe.mie.jp
+kiho.mie.jp
+kisosaki.mie.jp
+kiwa.mie.jp
+komono.mie.jp
+kumano.mie.jp
+kuwana.mie.jp
+matsusaka.mie.jp
+meiwa.mie.jp
+mihama.mie.jp
+minamiise.mie.jp
+misugi.mie.jp
+miyama.mie.jp
+nabari.mie.jp
+shima.mie.jp
+suzuka.mie.jp
+tado.mie.jp
+taiki.mie.jp
+taki.mie.jp
+tamaki.mie.jp
+toba.mie.jp
+tsu.mie.jp
+udono.mie.jp
+ureshino.mie.jp
+watarai.mie.jp
+yokkaichi.mie.jp
+furukawa.miyagi.jp
+higashimatsushima.miyagi.jp
+ishinomaki.miyagi.jp
+iwanuma.miyagi.jp
+kakuda.miyagi.jp
+kami.miyagi.jp
+kawasaki.miyagi.jp
+marumori.miyagi.jp
+matsushima.miyagi.jp
+minamisanriku.miyagi.jp
+misato.miyagi.jp
+murata.miyagi.jp
+natori.miyagi.jp
+ogawara.miyagi.jp
+ohira.miyagi.jp
+onagawa.miyagi.jp
+osaki.miyagi.jp
+rifu.miyagi.jp
+semine.miyagi.jp
+shibata.miyagi.jp
+shichikashuku.miyagi.jp
+shikama.miyagi.jp
+shiogama.miyagi.jp
+shiroishi.miyagi.jp
+tagajo.miyagi.jp
+taiwa.miyagi.jp
+tome.miyagi.jp
+tomiya.miyagi.jp
+wakuya.miyagi.jp
+watari.miyagi.jp
+yamamoto.miyagi.jp
+zao.miyagi.jp
+aya.miyazaki.jp
+ebino.miyazaki.jp
+gokase.miyazaki.jp
+hyuga.miyazaki.jp
+kadogawa.miyazaki.jp
+kawaminami.miyazaki.jp
+kijo.miyazaki.jp
+kitagawa.miyazaki.jp
+kitakata.miyazaki.jp
+kitaura.miyazaki.jp
+kobayashi.miyazaki.jp
+kunitomi.miyazaki.jp
+kushima.miyazaki.jp
+mimata.miyazaki.jp
+miyakonojo.miyazaki.jp
+miyazaki.miyazaki.jp
+morotsuka.miyazaki.jp
+nichinan.miyazaki.jp
+nishimera.miyazaki.jp
+nobeoka.miyazaki.jp
+saito.miyazaki.jp
+shiiba.miyazaki.jp
+shintomi.miyazaki.jp
+takaharu.miyazaki.jp
+takanabe.miyazaki.jp
+takazaki.miyazaki.jp
+tsuno.miyazaki.jp
+achi.nagano.jp
+agematsu.nagano.jp
+anan.nagano.jp
+aoki.nagano.jp
+asahi.nagano.jp
+azumino.nagano.jp
+chikuhoku.nagano.jp
+chikuma.nagano.jp
+chino.nagano.jp
+fujimi.nagano.jp
+hakuba.nagano.jp
+hara.nagano.jp
+hiraya.nagano.jp
+iida.nagano.jp
+iijima.nagano.jp
+iiyama.nagano.jp
+iizuna.nagano.jp
+ikeda.nagano.jp
+ikusaka.nagano.jp
+ina.nagano.jp
+karuizawa.nagano.jp
+kawakami.nagano.jp
+kiso.nagano.jp
+kisofukushima.nagano.jp
+kitaaiki.nagano.jp
+komagane.nagano.jp
+komoro.nagano.jp
+matsukawa.nagano.jp
+matsumoto.nagano.jp
+miasa.nagano.jp
+minamiaiki.nagano.jp
+minamimaki.nagano.jp
+minamiminowa.nagano.jp
+minowa.nagano.jp
+miyada.nagano.jp
+miyota.nagano.jp
+mochizuki.nagano.jp
+nagano.nagano.jp
+nagawa.nagano.jp
+nagiso.nagano.jp
+nakagawa.nagano.jp
+nakano.nagano.jp
+nozawaonsen.nagano.jp
+obuse.nagano.jp
+ogawa.nagano.jp
+okaya.nagano.jp
+omachi.nagano.jp
+omi.nagano.jp
+ookuwa.nagano.jp
+ooshika.nagano.jp
+otaki.nagano.jp
+otari.nagano.jp
+sakae.nagano.jp
+sakaki.nagano.jp
+saku.nagano.jp
+sakuho.nagano.jp
+shimosuwa.nagano.jp
+shinanomachi.nagano.jp
+shiojiri.nagano.jp
+suwa.nagano.jp
+suzaka.nagano.jp
+takagi.nagano.jp
+takamori.nagano.jp
+takayama.nagano.jp
+tateshina.nagano.jp
+tatsuno.nagano.jp
+togakushi.nagano.jp
+togura.nagano.jp
+tomi.nagano.jp
+ueda.nagano.jp
+wada.nagano.jp
+yamagata.nagano.jp
+yamanouchi.nagano.jp
+yasaka.nagano.jp
+yasuoka.nagano.jp
+chijiwa.nagasaki.jp
+futsu.nagasaki.jp
+goto.nagasaki.jp
+hasami.nagasaki.jp
+hirado.nagasaki.jp
+iki.nagasaki.jp
+isahaya.nagasaki.jp
+kawatana.nagasaki.jp
+kuchinotsu.nagasaki.jp
+matsuura.nagasaki.jp
+nagasaki.nagasaki.jp
+obama.nagasaki.jp
+omura.nagasaki.jp
+oseto.nagasaki.jp
+saikai.nagasaki.jp
+sasebo.nagasaki.jp
+seihi.nagasaki.jp
+shimabara.nagasaki.jp
+shinkamigoto.nagasaki.jp
+togitsu.nagasaki.jp
+tsushima.nagasaki.jp
+unzen.nagasaki.jp
+ando.nara.jp
+gose.nara.jp
+heguri.nara.jp
+higashiyoshino.nara.jp
+ikaruga.nara.jp
+ikoma.nara.jp
+kamikitayama.nara.jp
+kanmaki.nara.jp
+kashiba.nara.jp
+kashihara.nara.jp
+katsuragi.nara.jp
+kawai.nara.jp
+kawakami.nara.jp
+kawanishi.nara.jp
+koryo.nara.jp
+kurotaki.nara.jp
+mitsue.nara.jp
+miyake.nara.jp
+nara.nara.jp
+nosegawa.nara.jp
+oji.nara.jp
+ouda.nara.jp
+oyodo.nara.jp
+sakurai.nara.jp
+sango.nara.jp
+shimoichi.nara.jp
+shimokitayama.nara.jp
+shinjo.nara.jp
+soni.nara.jp
+takatori.nara.jp
+tawaramoto.nara.jp
+tenkawa.nara.jp
+tenri.nara.jp
+uda.nara.jp
+yamatokoriyama.nara.jp
+yamatotakada.nara.jp
+yamazoe.nara.jp
+yoshino.nara.jp
+aga.niigata.jp
+agano.niigata.jp
+gosen.niigata.jp
+itoigawa.niigata.jp
+izumozaki.niigata.jp
+joetsu.niigata.jp
+kamo.niigata.jp
+kariwa.niigata.jp
+kashiwazaki.niigata.jp
+minamiuonuma.niigata.jp
+mitsuke.niigata.jp
+muika.niigata.jp
+murakami.niigata.jp
+myoko.niigata.jp
+nagaoka.niigata.jp
+niigata.niigata.jp
+ojiya.niigata.jp
+omi.niigata.jp
+sado.niigata.jp
+sanjo.niigata.jp
+seiro.niigata.jp
+seirou.niigata.jp
+sekikawa.niigata.jp
+shibata.niigata.jp
+tagami.niigata.jp
+tainai.niigata.jp
+tochio.niigata.jp
+tokamachi.niigata.jp
+tsubame.niigata.jp
+tsunan.niigata.jp
+uonuma.niigata.jp
+yahiko.niigata.jp
+yoita.niigata.jp
+yuzawa.niigata.jp
+beppu.oita.jp
+bungoono.oita.jp
+bungotakada.oita.jp
+hasama.oita.jp
+hiji.oita.jp
+himeshima.oita.jp
+hita.oita.jp
+kamitsue.oita.jp
+kokonoe.oita.jp
+kuju.oita.jp
+kunisaki.oita.jp
+kusu.oita.jp
+oita.oita.jp
+saiki.oita.jp
+taketa.oita.jp
+tsukumi.oita.jp
+usa.oita.jp
+usuki.oita.jp
+yufu.oita.jp
+akaiwa.okayama.jp
+asakuchi.okayama.jp
+bizen.okayama.jp
+hayashima.okayama.jp
+ibara.okayama.jp
+kagamino.okayama.jp
+kasaoka.okayama.jp
+kibichuo.okayama.jp
+kumenan.okayama.jp
+kurashiki.okayama.jp
+maniwa.okayama.jp
+misaki.okayama.jp
+nagi.okayama.jp
+niimi.okayama.jp
+nishiawakura.okayama.jp
+okayama.okayama.jp
+satosho.okayama.jp
+setouchi.okayama.jp
+shinjo.okayama.jp
+shoo.okayama.jp
+soja.okayama.jp
+takahashi.okayama.jp
+tamano.okayama.jp
+tsuyama.okayama.jp
+wake.okayama.jp
+yakage.okayama.jp
+aguni.okinawa.jp
+ginowan.okinawa.jp
+ginoza.okinawa.jp
+gushikami.okinawa.jp
+haebaru.okinawa.jp
+higashi.okinawa.jp
+hirara.okinawa.jp
+iheya.okinawa.jp
+ishigaki.okinawa.jp
+ishikawa.okinawa.jp
+itoman.okinawa.jp
+izena.okinawa.jp
+kadena.okinawa.jp
+kin.okinawa.jp
+kitadaito.okinawa.jp
+kitanakagusuku.okinawa.jp
+kumejima.okinawa.jp
+kunigami.okinawa.jp
+minamidaito.okinawa.jp
+motobu.okinawa.jp
+nago.okinawa.jp
+naha.okinawa.jp
+nakagusuku.okinawa.jp
+nakijin.okinawa.jp
+nanjo.okinawa.jp
+nishihara.okinawa.jp
+ogimi.okinawa.jp
+okinawa.okinawa.jp
+onna.okinawa.jp
+shimoji.okinawa.jp
+taketomi.okinawa.jp
+tarama.okinawa.jp
+tokashiki.okinawa.jp
+tomigusuku.okinawa.jp
+tonaki.okinawa.jp
+urasoe.okinawa.jp
+uruma.okinawa.jp
+yaese.okinawa.jp
+yomitan.okinawa.jp
+yonabaru.okinawa.jp
+yonaguni.okinawa.jp
+zamami.okinawa.jp
+abeno.osaka.jp
+chihayaakasaka.osaka.jp
+chuo.osaka.jp
+daito.osaka.jp
+fujiidera.osaka.jp
+habikino.osaka.jp
+hannan.osaka.jp
+higashiosaka.osaka.jp
+higashisumiyoshi.osaka.jp
+higashiyodogawa.osaka.jp
+hirakata.osaka.jp
+ibaraki.osaka.jp
+ikeda.osaka.jp
+izumi.osaka.jp
+izumiotsu.osaka.jp
+izumisano.osaka.jp
+kadoma.osaka.jp
+kaizuka.osaka.jp
+kanan.osaka.jp
+kashiwara.osaka.jp
+katano.osaka.jp
+kawachinagano.osaka.jp
+kishiwada.osaka.jp
+kita.osaka.jp
+kumatori.osaka.jp
+matsubara.osaka.jp
+minato.osaka.jp
+minoh.osaka.jp
+misaki.osaka.jp
+moriguchi.osaka.jp
+neyagawa.osaka.jp
+nishi.osaka.jp
+nose.osaka.jp
+osakasayama.osaka.jp
+sakai.osaka.jp
+sayama.osaka.jp
+sennan.osaka.jp
+settsu.osaka.jp
+shijonawate.osaka.jp
+shimamoto.osaka.jp
+suita.osaka.jp
+tadaoka.osaka.jp
+taishi.osaka.jp
+tajiri.osaka.jp
+takaishi.osaka.jp
+takatsuki.osaka.jp
+tondabayashi.osaka.jp
+toyonaka.osaka.jp
+toyono.osaka.jp
+yao.osaka.jp
+ariake.saga.jp
+arita.saga.jp
+fukudomi.saga.jp
+genkai.saga.jp
+hamatama.saga.jp
+hizen.saga.jp
+imari.saga.jp
+kamimine.saga.jp
+kanzaki.saga.jp
+karatsu.saga.jp
+kashima.saga.jp
+kitagata.saga.jp
+kitahata.saga.jp
+kiyama.saga.jp
+kouhoku.saga.jp
+kyuragi.saga.jp
+nishiarita.saga.jp
+ogi.saga.jp
+omachi.saga.jp
+ouchi.saga.jp
+saga.saga.jp
+shiroishi.saga.jp
+taku.saga.jp
+tara.saga.jp
+tosu.saga.jp
+yoshinogari.saga.jp
+arakawa.saitama.jp
+asaka.saitama.jp
+chichibu.saitama.jp
+fujimi.saitama.jp
+fujimino.saitama.jp
+fukaya.saitama.jp
+hanno.saitama.jp
+hanyu.saitama.jp
+hasuda.saitama.jp
+hatogaya.saitama.jp
+hatoyama.saitama.jp
+hidaka.saitama.jp
+higashichichibu.saitama.jp
+higashimatsuyama.saitama.jp
+honjo.saitama.jp
+ina.saitama.jp
+iruma.saitama.jp
+iwatsuki.saitama.jp
+kamiizumi.saitama.jp
+kamikawa.saitama.jp
+kamisato.saitama.jp
+kasukabe.saitama.jp
+kawagoe.saitama.jp
+kawaguchi.saitama.jp
+kawajima.saitama.jp
+kazo.saitama.jp
+kitamoto.saitama.jp
+koshigaya.saitama.jp
+kounosu.saitama.jp
+kuki.saitama.jp
+kumagaya.saitama.jp
+matsubushi.saitama.jp
+minano.saitama.jp
+misato.saitama.jp
+miyashiro.saitama.jp
+miyoshi.saitama.jp
+moroyama.saitama.jp
+nagatoro.saitama.jp
+namegawa.saitama.jp
+niiza.saitama.jp
+ogano.saitama.jp
+ogawa.saitama.jp
+ogose.saitama.jp
+okegawa.saitama.jp
+omiya.saitama.jp
+otaki.saitama.jp
+ranzan.saitama.jp
+ryokami.saitama.jp
+saitama.saitama.jp
+sakado.saitama.jp
+satte.saitama.jp
+sayama.saitama.jp
+shiki.saitama.jp
+shiraoka.saitama.jp
+soka.saitama.jp
+sugito.saitama.jp
+toda.saitama.jp
+tokigawa.saitama.jp
+tokorozawa.saitama.jp
+tsurugashima.saitama.jp
+urawa.saitama.jp
+warabi.saitama.jp
+yashio.saitama.jp
+yokoze.saitama.jp
+yono.saitama.jp
+yorii.saitama.jp
+yoshida.saitama.jp
+yoshikawa.saitama.jp
+yoshimi.saitama.jp
+aisho.shiga.jp
+gamo.shiga.jp
+higashiomi.shiga.jp
+hikone.shiga.jp
+koka.shiga.jp
+konan.shiga.jp
+kosei.shiga.jp
+koto.shiga.jp
+kusatsu.shiga.jp
+maibara.shiga.jp
+moriyama.shiga.jp
+nagahama.shiga.jp
+nishiazai.shiga.jp
+notogawa.shiga.jp
+omihachiman.shiga.jp
+otsu.shiga.jp
+ritto.shiga.jp
+ryuoh.shiga.jp
+takashima.shiga.jp
+takatsuki.shiga.jp
+torahime.shiga.jp
+toyosato.shiga.jp
+yasu.shiga.jp
+akagi.shimane.jp
+ama.shimane.jp
+gotsu.shimane.jp
+hamada.shimane.jp
+higashiizumo.shimane.jp
+hikawa.shimane.jp
+hikimi.shimane.jp
+izumo.shimane.jp
+kakinoki.shimane.jp
+masuda.shimane.jp
+matsue.shimane.jp
+misato.shimane.jp
+nishinoshima.shimane.jp
+ohda.shimane.jp
+okinoshima.shimane.jp
+okuizumo.shimane.jp
+shimane.shimane.jp
+tamayu.shimane.jp
+tsuwano.shimane.jp
+unnan.shimane.jp
+yakumo.shimane.jp
+yasugi.shimane.jp
+yatsuka.shimane.jp
+arai.shizuoka.jp
+atami.shizuoka.jp
+fuji.shizuoka.jp
+fujieda.shizuoka.jp
+fujikawa.shizuoka.jp
+fujinomiya.shizuoka.jp
+fukuroi.shizuoka.jp
+gotemba.shizuoka.jp
+haibara.shizuoka.jp
+hamamatsu.shizuoka.jp
+higashiizu.shizuoka.jp
+ito.shizuoka.jp
+iwata.shizuoka.jp
+izu.shizuoka.jp
+izunokuni.shizuoka.jp
+kakegawa.shizuoka.jp
+kannami.shizuoka.jp
+kawanehon.shizuoka.jp
+kawazu.shizuoka.jp
+kikugawa.shizuoka.jp
+kosai.shizuoka.jp
+makinohara.shizuoka.jp
+matsuzaki.shizuoka.jp
+minamiizu.shizuoka.jp
+mishima.shizuoka.jp
+morimachi.shizuoka.jp
+nishiizu.shizuoka.jp
+numazu.shizuoka.jp
+omaezaki.shizuoka.jp
+shimada.shizuoka.jp
+shimizu.shizuoka.jp
+shimoda.shizuoka.jp
+shizuoka.shizuoka.jp
+susono.shizuoka.jp
+yaizu.shizuoka.jp
+yoshida.shizuoka.jp
+ashikaga.tochigi.jp
+bato.tochigi.jp
+haga.tochigi.jp
+ichikai.tochigi.jp
+iwafune.tochigi.jp
+kaminokawa.tochigi.jp
+kanuma.tochigi.jp
+karasuyama.tochigi.jp
+kuroiso.tochigi.jp
+mashiko.tochigi.jp
+mibu.tochigi.jp
+moka.tochigi.jp
+motegi.tochigi.jp
+nasu.tochigi.jp
+nasushiobara.tochigi.jp
+nikko.tochigi.jp
+nishikata.tochigi.jp
+nogi.tochigi.jp
+ohira.tochigi.jp
+ohtawara.tochigi.jp
+oyama.tochigi.jp
+sakura.tochigi.jp
+sano.tochigi.jp
+shimotsuke.tochigi.jp
+shioya.tochigi.jp
+takanezawa.tochigi.jp
+tochigi.tochigi.jp
+tsuga.tochigi.jp
+ujiie.tochigi.jp
+utsunomiya.tochigi.jp
+yaita.tochigi.jp
+aizumi.tokushima.jp
+anan.tokushima.jp
+ichiba.tokushima.jp
+itano.tokushima.jp
+kainan.tokushima.jp
+komatsushima.tokushima.jp
+matsushige.tokushima.jp
+mima.tokushima.jp
+minami.tokushima.jp
+miyoshi.tokushima.jp
+mugi.tokushima.jp
+nakagawa.tokushima.jp
+naruto.tokushima.jp
+sanagochi.tokushima.jp
+shishikui.tokushima.jp
+tokushima.tokushima.jp
+wajiki.tokushima.jp
+adachi.tokyo.jp
+akiruno.tokyo.jp
+akishima.tokyo.jp
+aogashima.tokyo.jp
+arakawa.tokyo.jp
+bunkyo.tokyo.jp
+chiyoda.tokyo.jp
+chofu.tokyo.jp
+chuo.tokyo.jp
+edogawa.tokyo.jp
+fuchu.tokyo.jp
+fussa.tokyo.jp
+hachijo.tokyo.jp
+hachioji.tokyo.jp
+hamura.tokyo.jp
+higashikurume.tokyo.jp
+higashimurayama.tokyo.jp
+higashiyamato.tokyo.jp
+hino.tokyo.jp
+hinode.tokyo.jp
+hinohara.tokyo.jp
+inagi.tokyo.jp
+itabashi.tokyo.jp
+katsushika.tokyo.jp
+kita.tokyo.jp
+kiyose.tokyo.jp
+kodaira.tokyo.jp
+koganei.tokyo.jp
+kokubunji.tokyo.jp
+komae.tokyo.jp
+koto.tokyo.jp
+kouzushima.tokyo.jp
+kunitachi.tokyo.jp
+machida.tokyo.jp
+meguro.tokyo.jp
+minato.tokyo.jp
+mitaka.tokyo.jp
+mizuho.tokyo.jp
+musashimurayama.tokyo.jp
+musashino.tokyo.jp
+nakano.tokyo.jp
+nerima.tokyo.jp
+ogasawara.tokyo.jp
+okutama.tokyo.jp
+ome.tokyo.jp
+oshima.tokyo.jp
+ota.tokyo.jp
+setagaya.tokyo.jp
+shibuya.tokyo.jp
+shinagawa.tokyo.jp
+shinjuku.tokyo.jp
+suginami.tokyo.jp
+sumida.tokyo.jp
+tachikawa.tokyo.jp
+taito.tokyo.jp
+tama.tokyo.jp
+toshima.tokyo.jp
+chizu.tottori.jp
+hino.tottori.jp
+kawahara.tottori.jp
+koge.tottori.jp
+kotoura.tottori.jp
+misasa.tottori.jp
+nanbu.tottori.jp
+nichinan.tottori.jp
+sakaiminato.tottori.jp
+tottori.tottori.jp
+wakasa.tottori.jp
+yazu.tottori.jp
+yonago.tottori.jp
+asahi.toyama.jp
+fuchu.toyama.jp
+fukumitsu.toyama.jp
+funahashi.toyama.jp
+himi.toyama.jp
+imizu.toyama.jp
+inami.toyama.jp
+johana.toyama.jp
+kamiichi.toyama.jp
+kurobe.toyama.jp
+nakaniikawa.toyama.jp
+namerikawa.toyama.jp
+nanto.toyama.jp
+nyuzen.toyama.jp
+oyabe.toyama.jp
+taira.toyama.jp
+takaoka.toyama.jp
+tateyama.toyama.jp
+toga.toyama.jp
+tonami.toyama.jp
+toyama.toyama.jp
+unazuki.toyama.jp
+uozu.toyama.jp
+yamada.toyama.jp
+arida.wakayama.jp
+aridagawa.wakayama.jp
+gobo.wakayama.jp
+hashimoto.wakayama.jp
+hidaka.wakayama.jp
+hirogawa.wakayama.jp
+inami.wakayama.jp
+iwade.wakayama.jp
+kainan.wakayama.jp
+kamitonda.wakayama.jp
+katsuragi.wakayama.jp
+kimino.wakayama.jp
+kinokawa.wakayama.jp
+kitayama.wakayama.jp
+koya.wakayama.jp
+koza.wakayama.jp
+kozagawa.wakayama.jp
+kudoyama.wakayama.jp
+kushimoto.wakayama.jp
+mihama.wakayama.jp
+misato.wakayama.jp
+nachikatsuura.wakayama.jp
+shingu.wakayama.jp
+shirahama.wakayama.jp
+taiji.wakayama.jp
+tanabe.wakayama.jp
+wakayama.wakayama.jp
+yuasa.wakayama.jp
+yura.wakayama.jp
+asahi.yamagata.jp
+funagata.yamagata.jp
+higashine.yamagata.jp
+iide.yamagata.jp
+kahoku.yamagata.jp
+kaminoyama.yamagata.jp
+kaneyama.yamagata.jp
+kawanishi.yamagata.jp
+mamurogawa.yamagata.jp
+mikawa.yamagata.jp
+murayama.yamagata.jp
+nagai.yamagata.jp
+nakayama.yamagata.jp
+nanyo.yamagata.jp
+nishikawa.yamagata.jp
+obanazawa.yamagata.jp
+oe.yamagata.jp
+oguni.yamagata.jp
+ohkura.yamagata.jp
+oishida.yamagata.jp
+sagae.yamagata.jp
+sakata.yamagata.jp
+sakegawa.yamagata.jp
+shinjo.yamagata.jp
+shirataka.yamagata.jp
+shonai.yamagata.jp
+takahata.yamagata.jp
+tendo.yamagata.jp
+tozawa.yamagata.jp
+tsuruoka.yamagata.jp
+yamagata.yamagata.jp
+yamanobe.yamagata.jp
+yonezawa.yamagata.jp
+yuza.yamagata.jp
+abu.yamaguchi.jp
+hagi.yamaguchi.jp
+hikari.yamaguchi.jp
+hofu.yamaguchi.jp
+iwakuni.yamaguchi.jp
+kudamatsu.yamaguchi.jp
+mitou.yamaguchi.jp
+nagato.yamaguchi.jp
+oshima.yamaguchi.jp
+shimonoseki.yamaguchi.jp
+shunan.yamaguchi.jp
+tabuse.yamaguchi.jp
+tokuyama.yamaguchi.jp
+toyota.yamaguchi.jp
+ube.yamaguchi.jp
+yuu.yamaguchi.jp
+chuo.yamanashi.jp
+doshi.yamanashi.jp
+fuefuki.yamanashi.jp
+fujikawa.yamanashi.jp
+fujikawaguchiko.yamanashi.jp
+fujiyoshida.yamanashi.jp
+hayakawa.yamanashi.jp
+hokuto.yamanashi.jp
+ichikawamisato.yamanashi.jp
+kai.yamanashi.jp
+kofu.yamanashi.jp
+koshu.yamanashi.jp
+kosuge.yamanashi.jp
+minami-alps.yamanashi.jp
+minobu.yamanashi.jp
+nakamichi.yamanashi.jp
+nanbu.yamanashi.jp
+narusawa.yamanashi.jp
+nirasaki.yamanashi.jp
+nishikatsura.yamanashi.jp
+oshino.yamanashi.jp
+otsuki.yamanashi.jp
+showa.yamanashi.jp
+tabayama.yamanashi.jp
+tsuru.yamanashi.jp
+uenohara.yamanashi.jp
+yamanakako.yamanashi.jp
+yamanashi.yamanashi.jp
+
+// ke : http://www.kenic.or.ke/index.php/en/ke-domains/ke-domains
+ke
+ac.ke
+co.ke
+go.ke
+info.ke
+me.ke
+mobi.ke
+ne.ke
+or.ke
+sc.ke
+
+// kg : http://www.domain.kg/dmn_n.html
+kg
+org.kg
+net.kg
+com.kg
+edu.kg
+gov.kg
+mil.kg
+
+// kh : http://www.mptc.gov.kh/dns_registration.htm
+*.kh
+
+// ki : http://www.ki/dns/index.html
+ki
+edu.ki
+biz.ki
+net.ki
+org.ki
+gov.ki
+info.ki
+com.ki
+
+// km : https://en.wikipedia.org/wiki/.km
+// http://www.domaine.km/documents/charte.doc
+km
+org.km
+nom.km
+gov.km
+prd.km
+tm.km
+edu.km
+mil.km
+ass.km
+com.km
+// These are only mentioned as proposed suggestions at domaine.km, but
+// https://en.wikipedia.org/wiki/.km says they're available for registration:
+coop.km
+asso.km
+presse.km
+medecin.km
+notaires.km
+pharmaciens.km
+veterinaire.km
+gouv.km
+
+// kn : https://en.wikipedia.org/wiki/.kn
+// http://www.dot.kn/domainRules.html
+kn
+net.kn
+org.kn
+edu.kn
+gov.kn
+
+// kp : http://www.kcce.kp/en_index.php
+kp
+com.kp
+edu.kp
+gov.kp
+org.kp
+rep.kp
+tra.kp
+
+// kr : https://en.wikipedia.org/wiki/.kr
+// see also: http://domain.nida.or.kr/eng/registration.jsp
+kr
+ac.kr
+co.kr
+es.kr
+go.kr
+hs.kr
+kg.kr
+mil.kr
+ms.kr
+ne.kr
+or.kr
+pe.kr
+re.kr
+sc.kr
+// kr geographical names
+busan.kr
+chungbuk.kr
+chungnam.kr
+daegu.kr
+daejeon.kr
+gangwon.kr
+gwangju.kr
+gyeongbuk.kr
+gyeonggi.kr
+gyeongnam.kr
+incheon.kr
+jeju.kr
+jeonbuk.kr
+jeonnam.kr
+seoul.kr
+ulsan.kr
+
+// kw : https://www.nic.kw/policies/
+// Confirmed by registry <nic.tech@citra.gov.kw>
+kw
+com.kw
+edu.kw
+emb.kw
+gov.kw
+ind.kw
+net.kw
+org.kw
+
+// ky : http://www.icta.ky/da_ky_reg_dom.php
+// Confirmed by registry <kysupport@perimeterusa.com> 2008-06-17
+ky
+com.ky
+edu.ky
+net.ky
+org.ky
+
+// kz : https://en.wikipedia.org/wiki/.kz
+// see also: http://www.nic.kz/rules/index.jsp
+kz
+org.kz
+edu.kz
+net.kz
+gov.kz
+mil.kz
+com.kz
+
+// la : https://en.wikipedia.org/wiki/.la
+// Submitted by registry <gavin.brown@nic.la>
+la
+int.la
+net.la
+info.la
+edu.la
+gov.la
+per.la
+com.la
+org.la
+
+// lb : https://en.wikipedia.org/wiki/.lb
+// Submitted by registry <randy@psg.com>
+lb
+com.lb
+edu.lb
+gov.lb
+net.lb
+org.lb
+
+// lc : https://en.wikipedia.org/wiki/.lc
+// see also: http://www.nic.lc/rules.htm
+lc
+com.lc
+net.lc
+co.lc
+org.lc
+edu.lc
+gov.lc
+
+// li : https://en.wikipedia.org/wiki/.li
+li
+
+// lk : https://www.nic.lk/index.php/domain-registration/lk-domain-naming-structure
+lk
+gov.lk
+sch.lk
+net.lk
+int.lk
+com.lk
+org.lk
+edu.lk
+ngo.lk
+soc.lk
+web.lk
+ltd.lk
+assn.lk
+grp.lk
+hotel.lk
+ac.lk
+
+// lr : http://psg.com/dns/lr/lr.txt
+// Submitted by registry <randy@psg.com>
+lr
+com.lr
+edu.lr
+gov.lr
+org.lr
+net.lr
+
+// ls : http://www.nic.ls/
+// Confirmed by registry <lsadmin@nic.ls>
+ls
+ac.ls
+biz.ls
+co.ls
+edu.ls
+gov.ls
+info.ls
+net.ls
+org.ls
+sc.ls
+
+// lt : https://en.wikipedia.org/wiki/.lt
+lt
+// gov.lt : http://www.gov.lt/index_en.php
+gov.lt
+
+// lu : http://www.dns.lu/en/
+lu
+
+// lv : http://www.nic.lv/DNS/En/generic.php
+lv
+com.lv
+edu.lv
+gov.lv
+org.lv
+mil.lv
+id.lv
+net.lv
+asn.lv
+conf.lv
+
+// ly : http://www.nic.ly/regulations.php
+ly
+com.ly
+net.ly
+gov.ly
+plc.ly
+edu.ly
+sch.ly
+med.ly
+org.ly
+id.ly
+
+// ma : https://en.wikipedia.org/wiki/.ma
+// http://www.anrt.ma/fr/admin/download/upload/file_fr782.pdf
+ma
+co.ma
+net.ma
+gov.ma
+org.ma
+ac.ma
+press.ma
+
+// mc : http://www.nic.mc/
+mc
+tm.mc
+asso.mc
+
+// md : https://en.wikipedia.org/wiki/.md
+md
+
+// me : https://en.wikipedia.org/wiki/.me
+me
+co.me
+net.me
+org.me
+edu.me
+ac.me
+gov.me
+its.me
+priv.me
+
+// mg : http://nic.mg/nicmg/?page_id=39
+mg
+org.mg
+nom.mg
+gov.mg
+prd.mg
+tm.mg
+edu.mg
+mil.mg
+com.mg
+co.mg
+
+// mh : https://en.wikipedia.org/wiki/.mh
+mh
+
+// mil : https://en.wikipedia.org/wiki/.mil
+mil
+
+// mk : https://en.wikipedia.org/wiki/.mk
+// see also: http://dns.marnet.net.mk/postapka.php
+mk
+com.mk
+org.mk
+net.mk
+edu.mk
+gov.mk
+inf.mk
+name.mk
+
+// ml : http://www.gobin.info/domainname/ml-template.doc
+// see also: https://en.wikipedia.org/wiki/.ml
+ml
+com.ml
+edu.ml
+gouv.ml
+gov.ml
+net.ml
+org.ml
+presse.ml
+
+// mm : https://en.wikipedia.org/wiki/.mm
+*.mm
+
+// mn : https://en.wikipedia.org/wiki/.mn
+mn
+gov.mn
+edu.mn
+org.mn
+
+// mo : http://www.monic.net.mo/
+mo
+com.mo
+net.mo
+org.mo
+edu.mo
+gov.mo
+
+// mobi : https://en.wikipedia.org/wiki/.mobi
+mobi
+
+// mp : http://www.dot.mp/
+// Confirmed by registry <dcamacho@saipan.com> 2008-06-17
+mp
+
+// mq : https://en.wikipedia.org/wiki/.mq
+mq
+
+// mr : https://en.wikipedia.org/wiki/.mr
+mr
+gov.mr
+
+// ms : http://www.nic.ms/pdf/MS_Domain_Name_Rules.pdf
+ms
+com.ms
+edu.ms
+gov.ms
+net.ms
+org.ms
+
+// mt : https://www.nic.org.mt/go/policy
+// Submitted by registry <help@nic.org.mt>
+mt
+com.mt
+edu.mt
+net.mt
+org.mt
+
+// mu : https://en.wikipedia.org/wiki/.mu
+mu
+com.mu
+net.mu
+org.mu
+gov.mu
+ac.mu
+co.mu
+or.mu
+
+// museum : https://welcome.museum/wp-content/uploads/2018/05/20180525-Registration-Policy-MUSEUM-EN_VF-2.pdf https://welcome.museum/buy-your-dot-museum-2/
+museum
+
+// mv : https://en.wikipedia.org/wiki/.mv
+// "mv" included because, contra Wikipedia, google.mv exists.
+mv
+aero.mv
+biz.mv
+com.mv
+coop.mv
+edu.mv
+gov.mv
+info.mv
+int.mv
+mil.mv
+museum.mv
+name.mv
+net.mv
+org.mv
+pro.mv
+
+// mw : http://www.registrar.mw/
+mw
+ac.mw
+biz.mw
+co.mw
+com.mw
+coop.mw
+edu.mw
+gov.mw
+int.mw
+museum.mw
+net.mw
+org.mw
+
+// mx : http://www.nic.mx/
+// Submitted by registry <farias@nic.mx>
+mx
+com.mx
+org.mx
+gob.mx
+edu.mx
+net.mx
+
+// my : http://www.mynic.my/
+// Available strings: https://mynic.my/resources/domains/buying-a-domain/
+my
+biz.my
+com.my
+edu.my
+gov.my
+mil.my
+name.my
+net.my
+org.my
+
+// mz : http://www.uem.mz/
+// Submitted by registry <antonio@uem.mz>
+mz
+ac.mz
+adv.mz
+co.mz
+edu.mz
+gov.mz
+mil.mz
+net.mz
+org.mz
+
+// na : http://www.na-nic.com.na/
+// http://www.info.na/domain/
+na
+info.na
+pro.na
+name.na
+school.na
+or.na
+dr.na
+us.na
+mx.na
+ca.na
+in.na
+cc.na
+tv.na
+ws.na
+mobi.na
+co.na
+com.na
+org.na
+
+// name : has 2nd-level tlds, but there's no list of them
+name
+
+// nc : http://www.cctld.nc/
+nc
+asso.nc
+nom.nc
+
+// ne : https://en.wikipedia.org/wiki/.ne
+ne
+
+// net : https://en.wikipedia.org/wiki/.net
+net
+
+// nf : https://en.wikipedia.org/wiki/.nf
+nf
+com.nf
+net.nf
+per.nf
+rec.nf
+web.nf
+arts.nf
+firm.nf
+info.nf
+other.nf
+store.nf
+
+// ng : http://www.nira.org.ng/index.php/join-us/register-ng-domain/189-nira-slds
+ng
+com.ng
+edu.ng
+gov.ng
+i.ng
+mil.ng
+mobi.ng
+name.ng
+net.ng
+org.ng
+sch.ng
+
+// ni : http://www.nic.ni/
+ni
+ac.ni
+biz.ni
+co.ni
+com.ni
+edu.ni
+gob.ni
+in.ni
+info.ni
+int.ni
+mil.ni
+net.ni
+nom.ni
+org.ni
+web.ni
+
+// nl : https://en.wikipedia.org/wiki/.nl
+//      https://www.sidn.nl/
+//      ccTLD for the Netherlands
+nl
+
+// no : https://www.norid.no/en/om-domenenavn/regelverk-for-no/
+// Norid geographical second level domains : https://www.norid.no/en/om-domenenavn/regelverk-for-no/vedlegg-b/
+// Norid category second level domains : https://www.norid.no/en/om-domenenavn/regelverk-for-no/vedlegg-c/
+// Norid category second-level domains managed by parties other than Norid : https://www.norid.no/en/om-domenenavn/regelverk-for-no/vedlegg-d/
+// RSS feed: https://teknisk.norid.no/en/feed/
+no
+// Norid category second level domains : https://www.norid.no/en/om-domenenavn/regelverk-for-no/vedlegg-c/
+fhs.no
+vgs.no
+fylkesbibl.no
+folkebibl.no
+museum.no
+idrett.no
+priv.no
+// Norid category second-level domains managed by parties other than Norid : https://www.norid.no/en/om-domenenavn/regelverk-for-no/vedlegg-d/
+mil.no
+stat.no
+dep.no
+kommune.no
+herad.no
+// Norid geographical second level domains : https://www.norid.no/en/om-domenenavn/regelverk-for-no/vedlegg-b/
+// counties
+aa.no
+ah.no
+bu.no
+fm.no
+hl.no
+hm.no
+jan-mayen.no
+mr.no
+nl.no
+nt.no
+of.no
+ol.no
+oslo.no
+rl.no
+sf.no
+st.no
+svalbard.no
+tm.no
+tr.no
+va.no
+vf.no
+// primary and lower secondary schools per county
+gs.aa.no
+gs.ah.no
+gs.bu.no
+gs.fm.no
+gs.hl.no
+gs.hm.no
+gs.jan-mayen.no
+gs.mr.no
+gs.nl.no
+gs.nt.no
+gs.of.no
+gs.ol.no
+gs.oslo.no
+gs.rl.no
+gs.sf.no
+gs.st.no
+gs.svalbard.no
+gs.tm.no
+gs.tr.no
+gs.va.no
+gs.vf.no
+// cities
+akrehamn.no
+åkrehamn.no
+algard.no
+ålgård.no
+arna.no
+brumunddal.no
+bryne.no
+bronnoysund.no
+brønnøysund.no
+drobak.no
+drøbak.no
+egersund.no
+fetsund.no
+floro.no
+florø.no
+fredrikstad.no
+hokksund.no
+honefoss.no
+hønefoss.no
+jessheim.no
+jorpeland.no
+jørpeland.no
+kirkenes.no
+kopervik.no
+krokstadelva.no
+langevag.no
+langevåg.no
+leirvik.no
+mjondalen.no
+mjøndalen.no
+mo-i-rana.no
+mosjoen.no
+mosjøen.no
+nesoddtangen.no
+orkanger.no
+osoyro.no
+osøyro.no
+raholt.no
+råholt.no
+sandnessjoen.no
+sandnessjøen.no
+skedsmokorset.no
+slattum.no
+spjelkavik.no
+stathelle.no
+stavern.no
+stjordalshalsen.no
+stjørdalshalsen.no
+tananger.no
+tranby.no
+vossevangen.no
+// communities
+afjord.no
+åfjord.no
+agdenes.no
+al.no
+ål.no
+alesund.no
+ålesund.no
+alstahaug.no
+alta.no
+áltá.no
+alaheadju.no
+álaheadju.no
+alvdal.no
+amli.no
+åmli.no
+amot.no
+åmot.no
+andebu.no
+andoy.no
+andøy.no
+andasuolo.no
+ardal.no
+årdal.no
+aremark.no
+arendal.no
+ås.no
+aseral.no
+åseral.no
+asker.no
+askim.no
+askvoll.no
+askoy.no
+askøy.no
+asnes.no
+åsnes.no
+audnedaln.no
+aukra.no
+aure.no
+aurland.no
+aurskog-holand.no
+aurskog-høland.no
+austevoll.no
+austrheim.no
+averoy.no
+averøy.no
+balestrand.no
+ballangen.no
+balat.no
+bálát.no
+balsfjord.no
+bahccavuotna.no
+báhccavuotna.no
+bamble.no
+bardu.no
+beardu.no
+beiarn.no
+bajddar.no
+bájddar.no
+baidar.no
+báidár.no
+berg.no
+bergen.no
+berlevag.no
+berlevåg.no
+bearalvahki.no
+bearalváhki.no
+bindal.no
+birkenes.no
+bjarkoy.no
+bjarkøy.no
+bjerkreim.no
+bjugn.no
+bodo.no
+bodø.no
+badaddja.no
+bådåddjå.no
+budejju.no
+bokn.no
+bremanger.no
+bronnoy.no
+brønnøy.no
+bygland.no
+bykle.no
+barum.no
+bærum.no
+bo.telemark.no
+bø.telemark.no
+bo.nordland.no
+bø.nordland.no
+bievat.no
+bievát.no
+bomlo.no
+bømlo.no
+batsfjord.no
+båtsfjord.no
+bahcavuotna.no
+báhcavuotna.no
+dovre.no
+drammen.no
+drangedal.no
+dyroy.no
+dyrøy.no
+donna.no
+dønna.no
+eid.no
+eidfjord.no
+eidsberg.no
+eidskog.no
+eidsvoll.no
+eigersund.no
+elverum.no
+enebakk.no
+engerdal.no
+etne.no
+etnedal.no
+evenes.no
+evenassi.no
+evenášši.no
+evje-og-hornnes.no
+farsund.no
+fauske.no
+fuossko.no
+fuoisku.no
+fedje.no
+fet.no
+finnoy.no
+finnøy.no
+fitjar.no
+fjaler.no
+fjell.no
+flakstad.no
+flatanger.no
+flekkefjord.no
+flesberg.no
+flora.no
+fla.no
+flå.no
+folldal.no
+forsand.no
+fosnes.no
+frei.no
+frogn.no
+froland.no
+frosta.no
+frana.no
+fræna.no
+froya.no
+frøya.no
+fusa.no
+fyresdal.no
+forde.no
+førde.no
+gamvik.no
+gangaviika.no
+gáŋgaviika.no
+gaular.no
+gausdal.no
+gildeskal.no
+gildeskål.no
+giske.no
+gjemnes.no
+gjerdrum.no
+gjerstad.no
+gjesdal.no
+gjovik.no
+gjøvik.no
+gloppen.no
+gol.no
+gran.no
+grane.no
+granvin.no
+gratangen.no
+grimstad.no
+grong.no
+kraanghke.no
+kråanghke.no
+grue.no
+gulen.no
+hadsel.no
+halden.no
+halsa.no
+hamar.no
+hamaroy.no
+habmer.no
+hábmer.no
+hapmir.no
+hápmir.no
+hammerfest.no
+hammarfeasta.no
+hámmárfeasta.no
+haram.no
+hareid.no
+harstad.no
+hasvik.no
+aknoluokta.no
+ákŋoluokta.no
+hattfjelldal.no
+aarborte.no
+haugesund.no
+hemne.no
+hemnes.no
+hemsedal.no
+heroy.more-og-romsdal.no
+herøy.møre-og-romsdal.no
+heroy.nordland.no
+herøy.nordland.no
+hitra.no
+hjartdal.no
+hjelmeland.no
+hobol.no
+hobøl.no
+hof.no
+hol.no
+hole.no
+holmestrand.no
+holtalen.no
+holtålen.no
+hornindal.no
+horten.no
+hurdal.no
+hurum.no
+hvaler.no
+hyllestad.no
+hagebostad.no
+hægebostad.no
+hoyanger.no
+høyanger.no
+hoylandet.no
+høylandet.no
+ha.no
+hå.no
+ibestad.no
+inderoy.no
+inderøy.no
+iveland.no
+jevnaker.no
+jondal.no
+jolster.no
+jølster.no
+karasjok.no
+karasjohka.no
+kárášjohka.no
+karlsoy.no
+galsa.no
+gálsá.no
+karmoy.no
+karmøy.no
+kautokeino.no
+guovdageaidnu.no
+klepp.no
+klabu.no
+klæbu.no
+kongsberg.no
+kongsvinger.no
+kragero.no
+kragerø.no
+kristiansand.no
+kristiansund.no
+krodsherad.no
+krødsherad.no
+kvalsund.no
+rahkkeravju.no
+ráhkkerávju.no
+kvam.no
+kvinesdal.no
+kvinnherad.no
+kviteseid.no
+kvitsoy.no
+kvitsøy.no
+kvafjord.no
+kvæfjord.no
+giehtavuoatna.no
+kvanangen.no
+kvænangen.no
+navuotna.no
+návuotna.no
+kafjord.no
+kåfjord.no
+gaivuotna.no
+gáivuotna.no
+larvik.no
+lavangen.no
+lavagis.no
+loabat.no
+loabát.no
+lebesby.no
+davvesiida.no
+leikanger.no
+leirfjord.no
+leka.no
+leksvik.no
+lenvik.no
+leangaviika.no
+leaŋgaviika.no
+lesja.no
+levanger.no
+lier.no
+lierne.no
+lillehammer.no
+lillesand.no
+lindesnes.no
+lindas.no
+lindås.no
+lom.no
+loppa.no
+lahppi.no
+láhppi.no
+lund.no
+lunner.no
+luroy.no
+lurøy.no
+luster.no
+lyngdal.no
+lyngen.no
+ivgu.no
+lardal.no
+lerdal.no
+lærdal.no
+lodingen.no
+lødingen.no
+lorenskog.no
+lørenskog.no
+loten.no
+løten.no
+malvik.no
+masoy.no
+måsøy.no
+muosat.no
+muosát.no
+mandal.no
+marker.no
+marnardal.no
+masfjorden.no
+meland.no
+meldal.no
+melhus.no
+meloy.no
+meløy.no
+meraker.no
+meråker.no
+moareke.no
+moåreke.no
+midsund.no
+midtre-gauldal.no
+modalen.no
+modum.no
+molde.no
+moskenes.no
+moss.no
+mosvik.no
+malselv.no
+målselv.no
+malatvuopmi.no
+málatvuopmi.no
+namdalseid.no
+aejrie.no
+namsos.no
+namsskogan.no
+naamesjevuemie.no
+nååmesjevuemie.no
+laakesvuemie.no
+nannestad.no
+narvik.no
+narviika.no
+naustdal.no
+nedre-eiker.no
+nes.akershus.no
+nes.buskerud.no
+nesna.no
+nesodden.no
+nesseby.no
+unjarga.no
+unjárga.no
+nesset.no
+nissedal.no
+nittedal.no
+nord-aurdal.no
+nord-fron.no
+nord-odal.no
+norddal.no
+nordkapp.no
+davvenjarga.no
+davvenjárga.no
+nordre-land.no
+nordreisa.no
+raisa.no
+ráisa.no
+nore-og-uvdal.no
+notodden.no
+naroy.no
+nærøy.no
+notteroy.no
+nøtterøy.no
+odda.no
+oksnes.no
+øksnes.no
+oppdal.no
+oppegard.no
+oppegård.no
+orkdal.no
+orland.no
+ørland.no
+orskog.no
+ørskog.no
+orsta.no
+ørsta.no
+os.hedmark.no
+os.hordaland.no
+osen.no
+osteroy.no
+osterøy.no
+ostre-toten.no
+østre-toten.no
+overhalla.no
+ovre-eiker.no
+øvre-eiker.no
+oyer.no
+øyer.no
+oygarden.no
+øygarden.no
+oystre-slidre.no
+øystre-slidre.no
+porsanger.no
+porsangu.no
+porsáŋgu.no
+porsgrunn.no
+radoy.no
+radøy.no
+rakkestad.no
+rana.no
+ruovat.no
+randaberg.no
+rauma.no
+rendalen.no
+rennebu.no
+rennesoy.no
+rennesøy.no
+rindal.no
+ringebu.no
+ringerike.no
+ringsaker.no
+rissa.no
+risor.no
+risør.no
+roan.no
+rollag.no
+rygge.no
+ralingen.no
+rælingen.no
+rodoy.no
+rødøy.no
+romskog.no
+rømskog.no
+roros.no
+røros.no
+rost.no
+røst.no
+royken.no
+røyken.no
+royrvik.no
+røyrvik.no
+rade.no
+råde.no
+salangen.no
+siellak.no
+saltdal.no
+salat.no
+sálát.no
+sálat.no
+samnanger.no
+sande.more-og-romsdal.no
+sande.møre-og-romsdal.no
+sande.vestfold.no
+sandefjord.no
+sandnes.no
+sandoy.no
+sandøy.no
+sarpsborg.no
+sauda.no
+sauherad.no
+sel.no
+selbu.no
+selje.no
+seljord.no
+sigdal.no
+siljan.no
+sirdal.no
+skaun.no
+skedsmo.no
+ski.no
+skien.no
+skiptvet.no
+skjervoy.no
+skjervøy.no
+skierva.no
+skiervá.no
+skjak.no
+skjåk.no
+skodje.no
+skanland.no
+skånland.no
+skanit.no
+skánit.no
+smola.no
+smøla.no
+snillfjord.no
+snasa.no
+snåsa.no
+snoasa.no
+snaase.no
+snåase.no
+sogndal.no
+sokndal.no
+sola.no
+solund.no
+songdalen.no
+sortland.no
+spydeberg.no
+stange.no
+stavanger.no
+steigen.no
+steinkjer.no
+stjordal.no
+stjørdal.no
+stokke.no
+stor-elvdal.no
+stord.no
+stordal.no
+storfjord.no
+omasvuotna.no
+strand.no
+stranda.no
+stryn.no
+sula.no
+suldal.no
+sund.no
+sunndal.no
+surnadal.no
+sveio.no
+svelvik.no
+sykkylven.no
+sogne.no
+søgne.no
+somna.no
+sømna.no
+sondre-land.no
+søndre-land.no
+sor-aurdal.no
+sør-aurdal.no
+sor-fron.no
+sør-fron.no
+sor-odal.no
+sør-odal.no
+sor-varanger.no
+sør-varanger.no
+matta-varjjat.no
+mátta-várjjat.no
+sorfold.no
+sørfold.no
+sorreisa.no
+sørreisa.no
+sorum.no
+sørum.no
+tana.no
+deatnu.no
+time.no
+tingvoll.no
+tinn.no
+tjeldsund.no
+dielddanuorri.no
+tjome.no
+tjøme.no
+tokke.no
+tolga.no
+torsken.no
+tranoy.no
+tranøy.no
+tromso.no
+tromsø.no
+tromsa.no
+romsa.no
+trondheim.no
+troandin.no
+trysil.no
+trana.no
+træna.no
+trogstad.no
+trøgstad.no
+tvedestrand.no
+tydal.no
+tynset.no
+tysfjord.no
+divtasvuodna.no
+divttasvuotna.no
+tysnes.no
+tysvar.no
+tysvær.no
+tonsberg.no
+tønsberg.no
+ullensaker.no
+ullensvang.no
+ulvik.no
+utsira.no
+vadso.no
+vadsø.no
+cahcesuolo.no
+čáhcesuolo.no
+vaksdal.no
+valle.no
+vang.no
+vanylven.no
+vardo.no
+vardø.no
+varggat.no
+várggát.no
+vefsn.no
+vaapste.no
+vega.no
+vegarshei.no
+vegårshei.no
+vennesla.no
+verdal.no
+verran.no
+vestby.no
+vestnes.no
+vestre-slidre.no
+vestre-toten.no
+vestvagoy.no
+vestvågøy.no
+vevelstad.no
+vik.no
+vikna.no
+vindafjord.no
+volda.no
+voss.no
+varoy.no
+værøy.no
+vagan.no
+vågan.no
+voagat.no
+vagsoy.no
+vågsøy.no
+vaga.no
+vågå.no
+valer.ostfold.no
+våler.østfold.no
+valer.hedmark.no
+våler.hedmark.no
+
+// np : http://www.mos.com.np/register.html
+*.np
+
+// nr : http://cenpac.net.nr/dns/index.html
+// Submitted by registry <technician@cenpac.net.nr>
+nr
+biz.nr
+info.nr
+gov.nr
+edu.nr
+org.nr
+net.nr
+com.nr
+
+// nu : https://en.wikipedia.org/wiki/.nu
+nu
+
+// nz : https://en.wikipedia.org/wiki/.nz
+// Submitted by registry <jay@nzrs.net.nz>
+nz
+ac.nz
+co.nz
+cri.nz
+geek.nz
+gen.nz
+govt.nz
+health.nz
+iwi.nz
+kiwi.nz
+maori.nz
+mil.nz
+māori.nz
+net.nz
+org.nz
+parliament.nz
+school.nz
+
+// om : https://en.wikipedia.org/wiki/.om
+om
+co.om
+com.om
+edu.om
+gov.om
+med.om
+museum.om
+net.om
+org.om
+pro.om
+
+// onion : https://tools.ietf.org/html/rfc7686
+onion
+
+// org : https://en.wikipedia.org/wiki/.org
+org
+
+// pa : http://www.nic.pa/
+// Some additional second level "domains" resolve directly as hostnames, such as
+// pannet.pa, so we add a rule for "pa".
+pa
+ac.pa
+gob.pa
+com.pa
+org.pa
+sld.pa
+edu.pa
+net.pa
+ing.pa
+abo.pa
+med.pa
+nom.pa
+
+// pe : https://www.nic.pe/InformeFinalComision.pdf
+pe
+edu.pe
+gob.pe
+nom.pe
+mil.pe
+org.pe
+com.pe
+net.pe
+
+// pf : http://www.gobin.info/domainname/formulaire-pf.pdf
+pf
+com.pf
+org.pf
+edu.pf
+
+// pg : https://en.wikipedia.org/wiki/.pg
+*.pg
+
+// ph : http://www.domains.ph/FAQ2.asp
+// Submitted by registry <jed@email.com.ph>
+ph
+com.ph
+net.ph
+org.ph
+gov.ph
+edu.ph
+ngo.ph
+mil.ph
+i.ph
+
+// pk : http://pk5.pknic.net.pk/pk5/msgNamepk.PK
+pk
+com.pk
+net.pk
+edu.pk
+org.pk
+fam.pk
+biz.pk
+web.pk
+gov.pk
+gob.pk
+gok.pk
+gon.pk
+gop.pk
+gos.pk
+info.pk
+
+// pl http://www.dns.pl/english/index.html
+// Submitted by registry
+pl
+com.pl
+net.pl
+org.pl
+// pl functional domains (http://www.dns.pl/english/index.html)
+aid.pl
+agro.pl
+atm.pl
+auto.pl
+biz.pl
+edu.pl
+gmina.pl
+gsm.pl
+info.pl
+mail.pl
+miasta.pl
+media.pl
+mil.pl
+nieruchomosci.pl
+nom.pl
+pc.pl
+powiat.pl
+priv.pl
+realestate.pl
+rel.pl
+sex.pl
+shop.pl
+sklep.pl
+sos.pl
+szkola.pl
+targi.pl
+tm.pl
+tourism.pl
+travel.pl
+turystyka.pl
+// Government domains
+gov.pl
+ap.gov.pl
+griw.gov.pl
+ic.gov.pl
+is.gov.pl
+kmpsp.gov.pl
+konsulat.gov.pl
+kppsp.gov.pl
+kwp.gov.pl
+kwpsp.gov.pl
+mup.gov.pl
+mw.gov.pl
+oia.gov.pl
+oirm.gov.pl
+oke.gov.pl
+oow.gov.pl
+oschr.gov.pl
+oum.gov.pl
+pa.gov.pl
+pinb.gov.pl
+piw.gov.pl
+po.gov.pl
+pr.gov.pl
+psp.gov.pl
+psse.gov.pl
+pup.gov.pl
+rzgw.gov.pl
+sa.gov.pl
+sdn.gov.pl
+sko.gov.pl
+so.gov.pl
+sr.gov.pl
+starostwo.gov.pl
+ug.gov.pl
+ugim.gov.pl
+um.gov.pl
+umig.gov.pl
+upow.gov.pl
+uppo.gov.pl
+us.gov.pl
+uw.gov.pl
+uzs.gov.pl
+wif.gov.pl
+wiih.gov.pl
+winb.gov.pl
+wios.gov.pl
+witd.gov.pl
+wiw.gov.pl
+wkz.gov.pl
+wsa.gov.pl
+wskr.gov.pl
+wsse.gov.pl
+wuoz.gov.pl
+wzmiuw.gov.pl
+zp.gov.pl
+zpisdn.gov.pl
+// pl regional domains (http://www.dns.pl/english/index.html)
+augustow.pl
+babia-gora.pl
+bedzin.pl
+beskidy.pl
+bialowieza.pl
+bialystok.pl
+bielawa.pl
+bieszczady.pl
+boleslawiec.pl
+bydgoszcz.pl
+bytom.pl
+cieszyn.pl
+czeladz.pl
+czest.pl
+dlugoleka.pl
+elblag.pl
+elk.pl
+glogow.pl
+gniezno.pl
+gorlice.pl
+grajewo.pl
+ilawa.pl
+jaworzno.pl
+jelenia-gora.pl
+jgora.pl
+kalisz.pl
+kazimierz-dolny.pl
+karpacz.pl
+kartuzy.pl
+kaszuby.pl
+katowice.pl
+kepno.pl
+ketrzyn.pl
+klodzko.pl
+kobierzyce.pl
+kolobrzeg.pl
+konin.pl
+konskowola.pl
+kutno.pl
+lapy.pl
+lebork.pl
+legnica.pl
+lezajsk.pl
+limanowa.pl
+lomza.pl
+lowicz.pl
+lubin.pl
+lukow.pl
+malbork.pl
+malopolska.pl
+mazowsze.pl
+mazury.pl
+mielec.pl
+mielno.pl
+mragowo.pl
+naklo.pl
+nowaruda.pl
+nysa.pl
+olawa.pl
+olecko.pl
+olkusz.pl
+olsztyn.pl
+opoczno.pl
+opole.pl
+ostroda.pl
+ostroleka.pl
+ostrowiec.pl
+ostrowwlkp.pl
+pila.pl
+pisz.pl
+podhale.pl
+podlasie.pl
+polkowice.pl
+pomorze.pl
+pomorskie.pl
+prochowice.pl
+pruszkow.pl
+przeworsk.pl
+pulawy.pl
+radom.pl
+rawa-maz.pl
+rybnik.pl
+rzeszow.pl
+sanok.pl
+sejny.pl
+slask.pl
+slupsk.pl
+sosnowiec.pl
+stalowa-wola.pl
+skoczow.pl
+starachowice.pl
+stargard.pl
+suwalki.pl
+swidnica.pl
+swiebodzin.pl
+swinoujscie.pl
+szczecin.pl
+szczytno.pl
+tarnobrzeg.pl
+tgory.pl
+turek.pl
+tychy.pl
+ustka.pl
+walbrzych.pl
+warmia.pl
+warszawa.pl
+waw.pl
+wegrow.pl
+wielun.pl
+wlocl.pl
+wloclawek.pl
+wodzislaw.pl
+wolomin.pl
+wroclaw.pl
+zachpomor.pl
+zagan.pl
+zarow.pl
+zgora.pl
+zgorzelec.pl
+
+// pm : https://www.afnic.fr/wp-media/uploads/2022/12/afnic-naming-policy-2023-01-01.pdf
+pm
+
+// pn : http://www.government.pn/PnRegistry/policies.htm
+pn
+gov.pn
+co.pn
+org.pn
+edu.pn
+net.pn
+
+// post : https://en.wikipedia.org/wiki/.post
+post
+
+// pr : http://www.nic.pr/index.asp?f=1
+pr
+com.pr
+net.pr
+org.pr
+gov.pr
+edu.pr
+isla.pr
+pro.pr
+biz.pr
+info.pr
+name.pr
+// these aren't mentioned on nic.pr, but on https://en.wikipedia.org/wiki/.pr
+est.pr
+prof.pr
+ac.pr
+
+// pro : http://registry.pro/get-pro
+pro
+aaa.pro
+aca.pro
+acct.pro
+avocat.pro
+bar.pro
+cpa.pro
+eng.pro
+jur.pro
+law.pro
+med.pro
+recht.pro
+
+// ps : https://en.wikipedia.org/wiki/.ps
+// http://www.nic.ps/registration/policy.html#reg
+ps
+edu.ps
+gov.ps
+sec.ps
+plo.ps
+com.ps
+org.ps
+net.ps
+
+// pt : https://www.dns.pt/en/domain/pt-terms-and-conditions-registration-rules/
+pt
+net.pt
+gov.pt
+org.pt
+edu.pt
+int.pt
+publ.pt
+com.pt
+nome.pt
+
+// pw : https://en.wikipedia.org/wiki/.pw
+pw
+co.pw
+ne.pw
+or.pw
+ed.pw
+go.pw
+belau.pw
+
+// py : http://www.nic.py/pautas.html#seccion_9
+// Submitted by registry
+py
+com.py
+coop.py
+edu.py
+gov.py
+mil.py
+net.py
+org.py
+
+// qa : http://domains.qa/en/
+qa
+com.qa
+edu.qa
+gov.qa
+mil.qa
+name.qa
+net.qa
+org.qa
+sch.qa
+
+// re : https://www.afnic.fr/wp-media/uploads/2022/12/afnic-naming-policy-2023-01-01.pdf
+re
+asso.re
+com.re
+nom.re
+
+// ro : http://www.rotld.ro/
+ro
+arts.ro
+com.ro
+firm.ro
+info.ro
+nom.ro
+nt.ro
+org.ro
+rec.ro
+store.ro
+tm.ro
+www.ro
+
+// rs : https://www.rnids.rs/en/domains/national-domains
+rs
+ac.rs
+co.rs
+edu.rs
+gov.rs
+in.rs
+org.rs
+
+// ru : https://cctld.ru/files/pdf/docs/en/rules_ru-rf.pdf
+// Submitted by George Georgievsky <gug@cctld.ru>
+ru
+
+// rw : https://www.ricta.org.rw/sites/default/files/resources/registry_registrar_contract_0.pdf
+rw
+ac.rw
+co.rw
+coop.rw
+gov.rw
+mil.rw
+net.rw
+org.rw
+
+// sa : http://www.nic.net.sa/
+sa
+com.sa
+net.sa
+org.sa
+gov.sa
+med.sa
+pub.sa
+edu.sa
+sch.sa
+
+// sb : http://www.sbnic.net.sb/
+// Submitted by registry <lee.humphries@telekom.com.sb>
+sb
+com.sb
+edu.sb
+gov.sb
+net.sb
+org.sb
+
+// sc : http://www.nic.sc/
+sc
+com.sc
+gov.sc
+net.sc
+org.sc
+edu.sc
+
+// sd : http://www.isoc.sd/sudanic.isoc.sd/billing_pricing.htm
+// Submitted by registry <admin@isoc.sd>
+sd
+com.sd
+net.sd
+org.sd
+edu.sd
+med.sd
+tv.sd
+gov.sd
+info.sd
+
+// se : https://en.wikipedia.org/wiki/.se
+// Submitted by registry <patrik.wallstrom@iis.se>
+se
+a.se
+ac.se
+b.se
+bd.se
+brand.se
+c.se
+d.se
+e.se
+f.se
+fh.se
+fhsk.se
+fhv.se
+g.se
+h.se
+i.se
+k.se
+komforb.se
+kommunalforbund.se
+komvux.se
+l.se
+lanbib.se
+m.se
+n.se
+naturbruksgymn.se
+o.se
+org.se
+p.se
+parti.se
+pp.se
+press.se
+r.se
+s.se
+t.se
+tm.se
+u.se
+w.se
+x.se
+y.se
+z.se
+
+// sg : http://www.nic.net.sg/page/registration-policies-procedures-and-guidelines
+sg
+com.sg
+net.sg
+org.sg
+gov.sg
+edu.sg
+per.sg
+
+// sh : http://nic.sh/rules.htm
+sh
+com.sh
+net.sh
+gov.sh
+org.sh
+mil.sh
+
+// si : https://en.wikipedia.org/wiki/.si
+si
+
+// sj : No registrations at this time.
+// Submitted by registry <jarle@uninett.no>
+sj
+
+// sk : https://en.wikipedia.org/wiki/.sk
+// list of 2nd level domains ?
+sk
+
+// sl : http://www.nic.sl
+// Submitted by registry <adam@neoip.com>
+sl
+com.sl
+net.sl
+edu.sl
+gov.sl
+org.sl
+
+// sm : https://en.wikipedia.org/wiki/.sm
+sm
+
+// sn : https://en.wikipedia.org/wiki/.sn
+sn
+art.sn
+com.sn
+edu.sn
+gouv.sn
+org.sn
+perso.sn
+univ.sn
+
+// so : http://sonic.so/policies/
+so
+com.so
+edu.so
+gov.so
+me.so
+net.so
+org.so
+
+// sr : https://en.wikipedia.org/wiki/.sr
+sr
+
+// ss : https://registry.nic.ss/
+// Submitted by registry <technical@nic.ss>
+ss
+biz.ss
+com.ss
+edu.ss
+gov.ss
+me.ss
+net.ss
+org.ss
+sch.ss
+
+// st : http://www.nic.st/html/policyrules/
+st
+co.st
+com.st
+consulado.st
+edu.st
+embaixada.st
+mil.st
+net.st
+org.st
+principe.st
+saotome.st
+store.st
+
+// su : https://en.wikipedia.org/wiki/.su
+su
+
+// sv : http://www.svnet.org.sv/niveldos.pdf
+sv
+com.sv
+edu.sv
+gob.sv
+org.sv
+red.sv
+
+// sx : https://en.wikipedia.org/wiki/.sx
+// Submitted by registry <jcvignes@openregistry.com>
+sx
+gov.sx
+
+// sy : https://en.wikipedia.org/wiki/.sy
+// see also: http://www.gobin.info/domainname/sy.doc
+sy
+edu.sy
+gov.sy
+net.sy
+mil.sy
+com.sy
+org.sy
+
+// sz : https://en.wikipedia.org/wiki/.sz
+// http://www.sispa.org.sz/
+sz
+co.sz
+ac.sz
+org.sz
+
+// tc : https://en.wikipedia.org/wiki/.tc
+tc
+
+// td : https://en.wikipedia.org/wiki/.td
+td
+
+// tel: https://en.wikipedia.org/wiki/.tel
+// http://www.telnic.org/
+tel
+
+// tf : https://www.afnic.fr/wp-media/uploads/2022/12/afnic-naming-policy-2023-01-01.pdf
+tf
+
+// tg : https://en.wikipedia.org/wiki/.tg
+// http://www.nic.tg/
+tg
+
+// th : https://en.wikipedia.org/wiki/.th
+// Submitted by registry <krit@thains.co.th>
+th
+ac.th
+co.th
+go.th
+in.th
+mi.th
+net.th
+or.th
+
+// tj : http://www.nic.tj/policy.html
+tj
+ac.tj
+biz.tj
+co.tj
+com.tj
+edu.tj
+go.tj
+gov.tj
+int.tj
+mil.tj
+name.tj
+net.tj
+nic.tj
+org.tj
+test.tj
+web.tj
+
+// tk : https://en.wikipedia.org/wiki/.tk
+tk
+
+// tl : https://en.wikipedia.org/wiki/.tl
+tl
+gov.tl
+
+// tm : http://www.nic.tm/local.html
+tm
+com.tm
+co.tm
+org.tm
+net.tm
+nom.tm
+gov.tm
+mil.tm
+edu.tm
+
+// tn : http://www.registre.tn/fr/
+// https://whois.ati.tn/
+tn
+com.tn
+ens.tn
+fin.tn
+gov.tn
+ind.tn
+info.tn
+intl.tn
+mincom.tn
+nat.tn
+net.tn
+org.tn
+perso.tn
+tourism.tn
+
+// to : https://en.wikipedia.org/wiki/.to
+// Submitted by registry <egullich@colo.to>
+to
+com.to
+gov.to
+net.to
+org.to
+edu.to
+mil.to
+
+// tr : https://nic.tr/
+// https://nic.tr/forms/eng/policies.pdf
+// https://nic.tr/index.php?USRACTN=PRICELST
+tr
+av.tr
+bbs.tr
+bel.tr
+biz.tr
+com.tr
+dr.tr
+edu.tr
+gen.tr
+gov.tr
+info.tr
+mil.tr
+k12.tr
+kep.tr
+name.tr
+net.tr
+org.tr
+pol.tr
+tel.tr
+tsk.tr
+tv.tr
+web.tr
+// Used by Northern Cyprus
+nc.tr
+// Used by government agencies of Northern Cyprus
+gov.nc.tr
+
+// tt : http://www.nic.tt/
+tt
+co.tt
+com.tt
+org.tt
+net.tt
+biz.tt
+info.tt
+pro.tt
+int.tt
+coop.tt
+jobs.tt
+mobi.tt
+travel.tt
+museum.tt
+aero.tt
+name.tt
+gov.tt
+edu.tt
+
+// tv : https://en.wikipedia.org/wiki/.tv
+// Not listing any 2LDs as reserved since none seem to exist in practice,
+// Wikipedia notwithstanding.
+tv
+
+// tw : https://en.wikipedia.org/wiki/.tw
+tw
+edu.tw
+gov.tw
+mil.tw
+com.tw
+net.tw
+org.tw
+idv.tw
+game.tw
+ebiz.tw
+club.tw
+網路.tw
+組織.tw
+商業.tw
+
+// tz : http://www.tznic.or.tz/index.php/domains
+// Submitted by registry <manager@tznic.or.tz>
+tz
+ac.tz
+co.tz
+go.tz
+hotel.tz
+info.tz
+me.tz
+mil.tz
+mobi.tz
+ne.tz
+or.tz
+sc.tz
+tv.tz
+
+// ua : https://hostmaster.ua/policy/?ua
+// Submitted by registry <dk@cctld.ua>
+ua
+// ua 2LD
+com.ua
+edu.ua
+gov.ua
+in.ua
+net.ua
+org.ua
+// ua geographic names
+// https://hostmaster.ua/2ld/
+cherkassy.ua
+cherkasy.ua
+chernigov.ua
+chernihiv.ua
+chernivtsi.ua
+chernovtsy.ua
+ck.ua
+cn.ua
+cr.ua
+crimea.ua
+cv.ua
+dn.ua
+dnepropetrovsk.ua
+dnipropetrovsk.ua
+donetsk.ua
+dp.ua
+if.ua
+ivano-frankivsk.ua
+kh.ua
+kharkiv.ua
+kharkov.ua
+kherson.ua
+khmelnitskiy.ua
+khmelnytskyi.ua
+kiev.ua
+kirovograd.ua
+km.ua
+kr.ua
+kropyvnytskyi.ua
+krym.ua
+ks.ua
+kv.ua
+kyiv.ua
+lg.ua
+lt.ua
+lugansk.ua
+luhansk.ua
+lutsk.ua
+lv.ua
+lviv.ua
+mk.ua
+mykolaiv.ua
+nikolaev.ua
+od.ua
+odesa.ua
+odessa.ua
+pl.ua
+poltava.ua
+rivne.ua
+rovno.ua
+rv.ua
+sb.ua
+sebastopol.ua
+sevastopol.ua
+sm.ua
+sumy.ua
+te.ua
+ternopil.ua
+uz.ua
+uzhgorod.ua
+uzhhorod.ua
+vinnica.ua
+vinnytsia.ua
+vn.ua
+volyn.ua
+yalta.ua
+zakarpattia.ua
+zaporizhzhe.ua
+zaporizhzhia.ua
+zhitomir.ua
+zhytomyr.ua
+zp.ua
+zt.ua
+
+// ug : https://www.registry.co.ug/
+ug
+co.ug
+or.ug
+ac.ug
+sc.ug
+go.ug
+ne.ug
+com.ug
+org.ug
+
+// uk : https://en.wikipedia.org/wiki/.uk
+// Submitted by registry <Michael.Daly@nominet.org.uk>
+uk
+ac.uk
+co.uk
+gov.uk
+ltd.uk
+me.uk
+net.uk
+nhs.uk
+org.uk
+plc.uk
+police.uk
+*.sch.uk
+
+// us : https://en.wikipedia.org/wiki/.us
+us
+dni.us
+fed.us
+isa.us
+kids.us
+nsn.us
+// us geographic names
+ak.us
+al.us
+ar.us
+as.us
+az.us
+ca.us
+co.us
+ct.us
+dc.us
+de.us
+fl.us
+ga.us
+gu.us
+hi.us
+ia.us
+id.us
+il.us
+in.us
+ks.us
+ky.us
+la.us
+ma.us
+md.us
+me.us
+mi.us
+mn.us
+mo.us
+ms.us
+mt.us
+nc.us
+nd.us
+ne.us
+nh.us
+nj.us
+nm.us
+nv.us
+ny.us
+oh.us
+ok.us
+or.us
+pa.us
+pr.us
+ri.us
+sc.us
+sd.us
+tn.us
+tx.us
+ut.us
+vi.us
+vt.us
+va.us
+wa.us
+wi.us
+wv.us
+wy.us
+// The registrar notes several more specific domains available in each state,
+// such as state.*.us, dst.*.us, etc., but resolution of these is somewhat
+// haphazard; in some states these domains resolve as addresses, while in others
+// only subdomains are available, or even nothing at all. We include the
+// most common ones where it's clear that different sites are different
+// entities.
+k12.ak.us
+k12.al.us
+k12.ar.us
+k12.as.us
+k12.az.us
+k12.ca.us
+k12.co.us
+k12.ct.us
+k12.dc.us
+k12.fl.us
+k12.ga.us
+k12.gu.us
+// k12.hi.us  Bug 614565 - Hawaii has a state-wide DOE login
+k12.ia.us
+k12.id.us
+k12.il.us
+k12.in.us
+k12.ks.us
+k12.ky.us
+k12.la.us
+k12.ma.us
+k12.md.us
+k12.me.us
+k12.mi.us
+k12.mn.us
+k12.mo.us
+k12.ms.us
+k12.mt.us
+k12.nc.us
+// k12.nd.us  Bug 1028347 - Removed at request of Travis Rosso <trossow@nd.gov>
+k12.ne.us
+k12.nh.us
+k12.nj.us
+k12.nm.us
+k12.nv.us
+k12.ny.us
+k12.oh.us
+k12.ok.us
+k12.or.us
+k12.pa.us
+k12.pr.us
+// k12.ri.us  Removed at request of Kim Cournoyer <netsupport@staff.ri.net>
+k12.sc.us
+// k12.sd.us  Bug 934131 - Removed at request of James Booze <James.Booze@k12.sd.us>
+k12.tn.us
+k12.tx.us
+k12.ut.us
+k12.vi.us
+k12.vt.us
+k12.va.us
+k12.wa.us
+k12.wi.us
+// k12.wv.us  Bug 947705 - Removed at request of Verne Britton <verne@wvnet.edu>
+k12.wy.us
+cc.ak.us
+cc.al.us
+cc.ar.us
+cc.as.us
+cc.az.us
+cc.ca.us
+cc.co.us
+cc.ct.us
+cc.dc.us
+cc.de.us
+cc.fl.us
+cc.ga.us
+cc.gu.us
+cc.hi.us
+cc.ia.us
+cc.id.us
+cc.il.us
+cc.in.us
+cc.ks.us
+cc.ky.us
+cc.la.us
+cc.ma.us
+cc.md.us
+cc.me.us
+cc.mi.us
+cc.mn.us
+cc.mo.us
+cc.ms.us
+cc.mt.us
+cc.nc.us
+cc.nd.us
+cc.ne.us
+cc.nh.us
+cc.nj.us
+cc.nm.us
+cc.nv.us
+cc.ny.us
+cc.oh.us
+cc.ok.us
+cc.or.us
+cc.pa.us
+cc.pr.us
+cc.ri.us
+cc.sc.us
+cc.sd.us
+cc.tn.us
+cc.tx.us
+cc.ut.us
+cc.vi.us
+cc.vt.us
+cc.va.us
+cc.wa.us
+cc.wi.us
+cc.wv.us
+cc.wy.us
+lib.ak.us
+lib.al.us
+lib.ar.us
+lib.as.us
+lib.az.us
+lib.ca.us
+lib.co.us
+lib.ct.us
+lib.dc.us
+// lib.de.us  Issue #243 - Moved to Private section at request of Ed Moore <Ed.Moore@lib.de.us>
+lib.fl.us
+lib.ga.us
+lib.gu.us
+lib.hi.us
+lib.ia.us
+lib.id.us
+lib.il.us
+lib.in.us
+lib.ks.us
+lib.ky.us
+lib.la.us
+lib.ma.us
+lib.md.us
+lib.me.us
+lib.mi.us
+lib.mn.us
+lib.mo.us
+lib.ms.us
+lib.mt.us
+lib.nc.us
+lib.nd.us
+lib.ne.us
+lib.nh.us
+lib.nj.us
+lib.nm.us
+lib.nv.us
+lib.ny.us
+lib.oh.us
+lib.ok.us
+lib.or.us
+lib.pa.us
+lib.pr.us
+lib.ri.us
+lib.sc.us
+lib.sd.us
+lib.tn.us
+lib.tx.us
+lib.ut.us
+lib.vi.us
+lib.vt.us
+lib.va.us
+lib.wa.us
+lib.wi.us
+// lib.wv.us  Bug 941670 - Removed at request of Larry W Arnold <arnold@wvlc.lib.wv.us>
+lib.wy.us
+// k12.ma.us contains school districts in Massachusetts. The 4LDs are
+//  managed independently except for private (PVT), charter (CHTR) and
+//  parochial (PAROCH) schools.  Those are delegated directly to the
+//  5LD operators.   <k12-ma-hostmaster _ at _ rsuc.gweep.net>
+pvt.k12.ma.us
+chtr.k12.ma.us
+paroch.k12.ma.us
+// Merit Network, Inc. maintains the registry for =~ /(k12|cc|lib).mi.us/ and the following
+//    see also: http://domreg.merit.edu
+//    see also: whois -h whois.domreg.merit.edu help
+ann-arbor.mi.us
+cog.mi.us
+dst.mi.us
+eaton.mi.us
+gen.mi.us
+mus.mi.us
+tec.mi.us
+washtenaw.mi.us
+
+// uy : http://www.nic.org.uy/
+uy
+com.uy
+edu.uy
+gub.uy
+mil.uy
+net.uy
+org.uy
+
+// uz : http://www.reg.uz/
+uz
+co.uz
+com.uz
+net.uz
+org.uz
+
+// va : https://en.wikipedia.org/wiki/.va
+va
+
+// vc : https://en.wikipedia.org/wiki/.vc
+// Submitted by registry <kshah@ca.afilias.info>
+vc
+com.vc
+net.vc
+org.vc
+gov.vc
+mil.vc
+edu.vc
+
+// ve : https://registro.nic.ve/
+// Submitted by registry nic@nic.ve and nicve@conatel.gob.ve
+ve
+arts.ve
+bib.ve
+co.ve
+com.ve
+e12.ve
+edu.ve
+firm.ve
+gob.ve
+gov.ve
+info.ve
+int.ve
+mil.ve
+net.ve
+nom.ve
+org.ve
+rar.ve
+rec.ve
+store.ve
+tec.ve
+web.ve
+
+// vg : https://en.wikipedia.org/wiki/.vg
+vg
+
+// vi : http://www.nic.vi/newdomainform.htm
+// http://www.nic.vi/Domain_Rules/body_domain_rules.html indicates some other
+// TLDs are "reserved", such as edu.vi and gov.vi, but doesn't actually say they
+// are available for registration (which they do not seem to be).
+vi
+co.vi
+com.vi
+k12.vi
+net.vi
+org.vi
+
+// vn : https://www.vnnic.vn/en/domain/cctld-vn
+// https://vnnic.vn/sites/default/files/tailieu/vn.cctld.domains.txt
+vn
+ac.vn
+ai.vn
+biz.vn
+com.vn
+edu.vn
+gov.vn
+health.vn
+id.vn
+info.vn
+int.vn
+io.vn
+name.vn
+net.vn
+org.vn
+pro.vn
+
+// vn geographical names
+angiang.vn
+bacgiang.vn
+backan.vn
+baclieu.vn
+bacninh.vn
+baria-vungtau.vn
+bentre.vn
+binhdinh.vn
+binhduong.vn
+binhphuoc.vn
+binhthuan.vn
+camau.vn
+cantho.vn
+caobang.vn
+daklak.vn
+daknong.vn
+danang.vn
+dienbien.vn
+dongnai.vn
+dongthap.vn
+gialai.vn
+hagiang.vn
+haiduong.vn
+haiphong.vn
+hanam.vn
+hanoi.vn
+hatinh.vn
+haugiang.vn
+hoabinh.vn
+hungyen.vn
+khanhhoa.vn
+kiengiang.vn
+kontum.vn
+laichau.vn
+lamdong.vn
+langson.vn
+laocai.vn
+longan.vn
+namdinh.vn
+nghean.vn
+ninhbinh.vn
+ninhthuan.vn
+phutho.vn
+phuyen.vn
+quangbinh.vn
+quangnam.vn
+quangngai.vn
+quangninh.vn
+quangtri.vn
+soctrang.vn
+sonla.vn
+tayninh.vn
+thaibinh.vn
+thainguyen.vn
+thanhhoa.vn
+thanhphohochiminh.vn
+thuathienhue.vn
+tiengiang.vn
+travinh.vn
+tuyenquang.vn
+vinhlong.vn
+vinhphuc.vn
+yenbai.vn
+
+// vu : https://en.wikipedia.org/wiki/.vu
+// http://www.vunic.vu/
+vu
+com.vu
+edu.vu
+net.vu
+org.vu
+
+// wf : https://www.afnic.fr/wp-media/uploads/2022/12/afnic-naming-policy-2023-01-01.pdf
+wf
+
+// ws : https://en.wikipedia.org/wiki/.ws
+// http://samoanic.ws/index.dhtml
+ws
+com.ws
+net.ws
+org.ws
+gov.ws
+edu.ws
+
+// yt : https://www.afnic.fr/wp-media/uploads/2022/12/afnic-naming-policy-2023-01-01.pdf
+yt
+
+// IDN ccTLDs
+// When submitting patches, please maintain a sort by ISO 3166 ccTLD, then
+// U-label, and follow this format:
+// // A-Label ("<Latin renderings>", <language name>[, variant info]) : <ISO 3166 ccTLD>
+// // [sponsoring org]
+// U-Label
+
+// xn--mgbaam7a8h ("Emerat", Arabic) : AE
+// http://nic.ae/english/arabicdomain/rules.jsp
+امارات
+
+// xn--y9a3aq ("hye", Armenian) : AM
+// ISOC AM (operated by .am Registry)
+հայ
+
+// xn--54b7fta0cc ("Bangla", Bangla) : BD
+বাংলা
+
+// xn--90ae ("bg", Bulgarian) : BG
+бг
+
+// xn--mgbcpq6gpa1a ("albahrain", Arabic) : BH
+البحرين
+
+// xn--90ais ("bel", Belarusian/Russian Cyrillic) : BY
+// Operated by .by registry
+бел
+
+// xn--fiqs8s ("Zhongguo/China", Chinese, Simplified) : CN
+// CNNIC
+// http://cnnic.cn/html/Dir/2005/10/11/3218.htm
+中国
+
+// xn--fiqz9s ("Zhongguo/China", Chinese, Traditional) : CN
+// CNNIC
+// http://cnnic.cn/html/Dir/2005/10/11/3218.htm
+中國
+
+// xn--lgbbat1ad8j ("Algeria/Al Jazair", Arabic) : DZ
+الجزائر
+
+// xn--wgbh1c ("Egypt/Masr", Arabic) : EG
+// http://www.dotmasr.eg/
+مصر
+
+// xn--e1a4c ("eu", Cyrillic) : EU
+// https://eurid.eu
+ею
+
+// xn--qxa6a ("eu", Greek) : EU
+// https://eurid.eu
+ευ
+
+// xn--mgbah1a3hjkrd ("Mauritania", Arabic) : MR
+موريتانيا
+
+// xn--node ("ge", Georgian Mkhedruli) : GE
+გე
+
+// xn--qxam ("el", Greek) : GR
+// Hellenic Ministry of Infrastructure, Transport, and Networks
+ελ
+
+// xn--j6w193g ("Hong Kong", Chinese) : HK
+// https://www.hkirc.hk
+// Submitted by registry <hk.tech@hkirc.hk>
+// https://www.hkirc.hk/content.jsp?id=30#!/34
+香港
+公司.香港
+教育.香港
+政府.香港
+個人.香港
+網絡.香港
+組織.香港
+
+// xn--2scrj9c ("Bharat", Kannada) : IN
+// India
+ಭಾರತ
+
+// xn--3hcrj9c ("Bharat", Oriya) : IN
+// India
+ଭାରତ
+
+// xn--45br5cyl ("Bharatam", Assamese) : IN
+// India
+ভাৰত
+
+// xn--h2breg3eve ("Bharatam", Sanskrit) : IN
+// India
+भारतम्
+
+// xn--h2brj9c8c ("Bharot", Santali) : IN
+// India
+भारोत
+
+// xn--mgbgu82a ("Bharat", Sindhi) : IN
+// India
+ڀارت
+
+// xn--rvc1e0am3e ("Bharatam", Malayalam) : IN
+// India
+ഭാരതം
+
+// xn--h2brj9c ("Bharat", Devanagari) : IN
+// India
+भारत
+
+// xn--mgbbh1a ("Bharat", Kashmiri) : IN
+// India
+بارت
+
+// xn--mgbbh1a71e ("Bharat", Arabic) : IN
+// India
+بھارت
+
+// xn--fpcrj9c3d ("Bharat", Telugu) : IN
+// India
+భారత్
+
+// xn--gecrj9c ("Bharat", Gujarati) : IN
+// India
+ભારત
+
+// xn--s9brj9c ("Bharat", Gurmukhi) : IN
+// India
+ਭਾਰਤ
+
+// xn--45brj9c ("Bharat", Bengali) : IN
+// India
+ভারত
+
+// xn--xkc2dl3a5ee0h ("India", Tamil) : IN
+// India
+இந்தியா
+
+// xn--mgba3a4f16a ("Iran", Persian) : IR
+ایران
+
+// xn--mgba3a4fra ("Iran", Arabic) : IR
+ايران
+
+// xn--mgbtx2b ("Iraq", Arabic) : IQ
+// Communications and Media Commission
+عراق
+
+// xn--mgbayh7gpa ("al-Ordon", Arabic) : JO
+// National Information Technology Center (NITC)
+// Royal Scientific Society, Al-Jubeiha
+الاردن
+
+// xn--3e0b707e ("Republic of Korea", Hangul) : KR
+한국
+
+// xn--80ao21a ("Kaz", Kazakh) : KZ
+қаз
+
+// xn--q7ce6a ("Lao", Lao) : LA
+ລາວ
+
+// xn--fzc2c9e2c ("Lanka", Sinhalese-Sinhala) : LK
+// https://nic.lk
+ලංකා
+
+// xn--xkc2al3hye2a ("Ilangai", Tamil) : LK
+// https://nic.lk
+இலங்கை
+
+// xn--mgbc0a9azcg ("Morocco/al-Maghrib", Arabic) : MA
+المغرب
+
+// xn--d1alf ("mkd", Macedonian) : MK
+// MARnet
+мкд
+
+// xn--l1acc ("mon", Mongolian) : MN
+мон
+
+// xn--mix891f ("Macao", Chinese, Traditional) : MO
+// MONIC / HNET Asia (Registry Operator for .mo)
+澳門
+
+// xn--mix082f ("Macao", Chinese, Simplified) : MO
+澳门
+
+// xn--mgbx4cd0ab ("Malaysia", Malay) : MY
+مليسيا
+
+// xn--mgb9awbf ("Oman", Arabic) : OM
+عمان
+
+// xn--mgbai9azgqp6j ("Pakistan", Urdu/Arabic) : PK
+پاکستان
+
+// xn--mgbai9a5eva00b ("Pakistan", Urdu/Arabic, variant) : PK
+پاكستان
+
+// xn--ygbi2ammx ("Falasteen", Arabic) : PS
+// The Palestinian National Internet Naming Authority (PNINA)
+// http://www.pnina.ps
+فلسطين
+
+// xn--90a3ac ("srb", Cyrillic) : RS
+// https://www.rnids.rs/en/domains/national-domains
+срб
+пр.срб
+орг.срб
+обр.срб
+од.срб
+упр.срб
+ак.срб
+
+// xn--p1ai ("rf", Russian-Cyrillic) : RU
+// https://cctld.ru/files/pdf/docs/en/rules_ru-rf.pdf
+// Submitted by George Georgievsky <gug@cctld.ru>
+рф
+
+// xn--wgbl6a ("Qatar", Arabic) : QA
+// http://www.ict.gov.qa/
+قطر
+
+// xn--mgberp4a5d4ar ("AlSaudiah", Arabic) : SA
+// http://www.nic.net.sa/
+السعودية
+
+// xn--mgberp4a5d4a87g ("AlSaudiah", Arabic, variant)  : SA
+السعودیة
+
+// xn--mgbqly7c0a67fbc ("AlSaudiah", Arabic, variant) : SA
+السعودیۃ
+
+// xn--mgbqly7cvafr ("AlSaudiah", Arabic, variant) : SA
+السعوديه
+
+// xn--mgbpl2fh ("sudan", Arabic) : SD
+// Operated by .sd registry
+سودان
+
+// xn--yfro4i67o Singapore ("Singapore", Chinese) : SG
+新加坡
+
+// xn--clchc0ea0b2g2a9gcd ("Singapore", Tamil) : SG
+சிங்கப்பூர்
+
+// xn--ogbpf8fl ("Syria", Arabic) : SY
+سورية
+
+// xn--mgbtf8fl ("Syria", Arabic, variant) : SY
+سوريا
+
+// xn--o3cw4h ("Thai", Thai) : TH
+// http://www.thnic.co.th
+ไทย
+ศึกษา.ไทย
+ธุรกิจ.ไทย
+รัฐบาล.ไทย
+ทหาร.ไทย
+เน็ต.ไทย
+องค์กร.ไทย
+
+// xn--pgbs0dh ("Tunisia", Arabic) : TN
+// http://nic.tn
+تونس
+
+// xn--kpry57d ("Taiwan", Chinese, Traditional) : TW
+// http://www.twnic.net/english/dn/dn_07a.htm
+台灣
+
+// xn--kprw13d ("Taiwan", Chinese, Simplified) : TW
+// http://www.twnic.net/english/dn/dn_07a.htm
+台湾
+
+// xn--nnx388a ("Taiwan", Chinese, variant) : TW
+臺灣
+
+// xn--j1amh ("ukr", Cyrillic) : UA
+укр
+
+// xn--mgb2ddes ("AlYemen", Arabic) : YE
+اليمن
+
+// xxx : http://icmregistry.com
+xxx
+
+// ye : http://www.y.net.ye/services/domain_name.htm
+ye
+com.ye
+edu.ye
+gov.ye
+net.ye
+mil.ye
+org.ye
+
+// za : https://www.zadna.org.za/content/page/domain-information/
+ac.za
+agric.za
+alt.za
+co.za
+edu.za
+gov.za
+grondar.za
+law.za
+mil.za
+net.za
+ngo.za
+nic.za
+nis.za
+nom.za
+org.za
+school.za
+tm.za
+web.za
+
+// zm : https://zicta.zm/
+// Submitted by registry <info@zicta.zm>
+zm
+ac.zm
+biz.zm
+co.zm
+com.zm
+edu.zm
+gov.zm
+info.zm
+mil.zm
+net.zm
+org.zm
+sch.zm
+
+// zw : https://www.potraz.gov.zw/
+// Confirmed by registry <bmtengwa@potraz.gov.zw> 2017-01-25
+zw
+ac.zw
+co.zw
+gov.zw
+mil.zw
+org.zw
+
+
+// newGTLDs
+
+// List of new gTLDs imported from https://www.icann.org/resources/registries/gtlds/v2/gtlds.json on 2024-07-12T15:14:39Z
+// This list is auto-generated, don't edit it manually.
+// aaa : American Automobile Association, Inc.
+// https://www.iana.org/domains/root/db/aaa.html
+aaa
+
+// aarp : AARP
+// https://www.iana.org/domains/root/db/aarp.html
+aarp
+
+// abb : ABB Ltd
+// https://www.iana.org/domains/root/db/abb.html
+abb
+
+// abbott : Abbott Laboratories, Inc.
+// https://www.iana.org/domains/root/db/abbott.html
+abbott
+
+// abbvie : AbbVie Inc.
+// https://www.iana.org/domains/root/db/abbvie.html
+abbvie
+
+// abc : Disney Enterprises, Inc.
+// https://www.iana.org/domains/root/db/abc.html
+abc
+
+// able : Able Inc.
+// https://www.iana.org/domains/root/db/able.html
+able
+
+// abogado : Registry Services, LLC
+// https://www.iana.org/domains/root/db/abogado.html
+abogado
+
+// abudhabi : Abu Dhabi Systems and Information Centre
+// https://www.iana.org/domains/root/db/abudhabi.html
+abudhabi
+
+// academy : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/academy.html
+academy
+
+// accenture : Accenture plc
+// https://www.iana.org/domains/root/db/accenture.html
+accenture
+
+// accountant : dot Accountant Limited
+// https://www.iana.org/domains/root/db/accountant.html
+accountant
+
+// accountants : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/accountants.html
+accountants
+
+// aco : ACO Severin Ahlmann GmbH & Co. KG
+// https://www.iana.org/domains/root/db/aco.html
+aco
+
+// actor : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/actor.html
+actor
+
+// ads : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/ads.html
+ads
+
+// adult : ICM Registry AD LLC
+// https://www.iana.org/domains/root/db/adult.html
+adult
+
+// aeg : Aktiebolaget Electrolux
+// https://www.iana.org/domains/root/db/aeg.html
+aeg
+
+// aetna : Aetna Life Insurance Company
+// https://www.iana.org/domains/root/db/aetna.html
+aetna
+
+// afl : Australian Football League
+// https://www.iana.org/domains/root/db/afl.html
+afl
+
+// africa : ZA Central Registry NPC trading as Registry.Africa
+// https://www.iana.org/domains/root/db/africa.html
+africa
+
+// agakhan : Fondation Aga Khan (Aga Khan Foundation)
+// https://www.iana.org/domains/root/db/agakhan.html
+agakhan
+
+// agency : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/agency.html
+agency
+
+// aig : American International Group, Inc.
+// https://www.iana.org/domains/root/db/aig.html
+aig
+
+// airbus : Airbus S.A.S.
+// https://www.iana.org/domains/root/db/airbus.html
+airbus
+
+// airforce : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/airforce.html
+airforce
+
+// airtel : Bharti Airtel Limited
+// https://www.iana.org/domains/root/db/airtel.html
+airtel
+
+// akdn : Fondation Aga Khan (Aga Khan Foundation)
+// https://www.iana.org/domains/root/db/akdn.html
+akdn
+
+// alibaba : Alibaba Group Holding Limited
+// https://www.iana.org/domains/root/db/alibaba.html
+alibaba
+
+// alipay : Alibaba Group Holding Limited
+// https://www.iana.org/domains/root/db/alipay.html
+alipay
+
+// allfinanz : Allfinanz Deutsche Vermögensberatung Aktiengesellschaft
+// https://www.iana.org/domains/root/db/allfinanz.html
+allfinanz
+
+// allstate : Allstate Fire and Casualty Insurance Company
+// https://www.iana.org/domains/root/db/allstate.html
+allstate
+
+// ally : Ally Financial Inc.
+// https://www.iana.org/domains/root/db/ally.html
+ally
+
+// alsace : Region Grand Est
+// https://www.iana.org/domains/root/db/alsace.html
+alsace
+
+// alstom : ALSTOM
+// https://www.iana.org/domains/root/db/alstom.html
+alstom
+
+// amazon : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/amazon.html
+amazon
+
+// americanexpress : American Express Travel Related Services Company, Inc.
+// https://www.iana.org/domains/root/db/americanexpress.html
+americanexpress
+
+// americanfamily : AmFam, Inc.
+// https://www.iana.org/domains/root/db/americanfamily.html
+americanfamily
+
+// amex : American Express Travel Related Services Company, Inc.
+// https://www.iana.org/domains/root/db/amex.html
+amex
+
+// amfam : AmFam, Inc.
+// https://www.iana.org/domains/root/db/amfam.html
+amfam
+
+// amica : Amica Mutual Insurance Company
+// https://www.iana.org/domains/root/db/amica.html
+amica
+
+// amsterdam : Gemeente Amsterdam
+// https://www.iana.org/domains/root/db/amsterdam.html
+amsterdam
+
+// analytics : Campus IP LLC
+// https://www.iana.org/domains/root/db/analytics.html
+analytics
+
+// android : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/android.html
+android
+
+// anquan : Beijing Qihu Keji Co., Ltd.
+// https://www.iana.org/domains/root/db/anquan.html
+anquan
+
+// anz : Australia and New Zealand Banking Group Limited
+// https://www.iana.org/domains/root/db/anz.html
+anz
+
+// aol : Yahoo Inc.
+// https://www.iana.org/domains/root/db/aol.html
+aol
+
+// apartments : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/apartments.html
+apartments
+
+// app : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/app.html
+app
+
+// apple : Apple Inc.
+// https://www.iana.org/domains/root/db/apple.html
+apple
+
+// aquarelle : Aquarelle.com
+// https://www.iana.org/domains/root/db/aquarelle.html
+aquarelle
+
+// arab : League of Arab States
+// https://www.iana.org/domains/root/db/arab.html
+arab
+
+// aramco : Aramco Services Company
+// https://www.iana.org/domains/root/db/aramco.html
+aramco
+
+// archi : Identity Digital Limited
+// https://www.iana.org/domains/root/db/archi.html
+archi
+
+// army : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/army.html
+army
+
+// art : UK Creative Ideas Limited
+// https://www.iana.org/domains/root/db/art.html
+art
+
+// arte : Association Relative à la Télévision Européenne G.E.I.E.
+// https://www.iana.org/domains/root/db/arte.html
+arte
+
+// asda : Wal-Mart Stores, Inc.
+// https://www.iana.org/domains/root/db/asda.html
+asda
+
+// associates : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/associates.html
+associates
+
+// athleta : The Gap, Inc.
+// https://www.iana.org/domains/root/db/athleta.html
+athleta
+
+// attorney : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/attorney.html
+attorney
+
+// auction : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/auction.html
+auction
+
+// audi : AUDI Aktiengesellschaft
+// https://www.iana.org/domains/root/db/audi.html
+audi
+
+// audible : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/audible.html
+audible
+
+// audio : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/audio.html
+audio
+
+// auspost : Australian Postal Corporation
+// https://www.iana.org/domains/root/db/auspost.html
+auspost
+
+// author : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/author.html
+author
+
+// auto : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/auto.html
+auto
+
+// autos : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/autos.html
+autos
+
+// aws : AWS Registry LLC
+// https://www.iana.org/domains/root/db/aws.html
+aws
+
+// axa : AXA Group Operations SAS
+// https://www.iana.org/domains/root/db/axa.html
+axa
+
+// azure : Microsoft Corporation
+// https://www.iana.org/domains/root/db/azure.html
+azure
+
+// baby : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/baby.html
+baby
+
+// baidu : Baidu, Inc.
+// https://www.iana.org/domains/root/db/baidu.html
+baidu
+
+// banamex : Citigroup Inc.
+// https://www.iana.org/domains/root/db/banamex.html
+banamex
+
+// band : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/band.html
+band
+
+// bank : fTLD Registry Services LLC
+// https://www.iana.org/domains/root/db/bank.html
+bank
+
+// bar : Punto 2012 Sociedad Anonima Promotora de Inversion de Capital Variable
+// https://www.iana.org/domains/root/db/bar.html
+bar
+
+// barcelona : Municipi de Barcelona
+// https://www.iana.org/domains/root/db/barcelona.html
+barcelona
+
+// barclaycard : Barclays Bank PLC
+// https://www.iana.org/domains/root/db/barclaycard.html
+barclaycard
+
+// barclays : Barclays Bank PLC
+// https://www.iana.org/domains/root/db/barclays.html
+barclays
+
+// barefoot : Gallo Vineyards, Inc.
+// https://www.iana.org/domains/root/db/barefoot.html
+barefoot
+
+// bargains : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/bargains.html
+bargains
+
+// baseball : MLB Advanced Media DH, LLC
+// https://www.iana.org/domains/root/db/baseball.html
+baseball
+
+// basketball : Fédération Internationale de Basketball (FIBA)
+// https://www.iana.org/domains/root/db/basketball.html
+basketball
+
+// bauhaus : Werkhaus GmbH
+// https://www.iana.org/domains/root/db/bauhaus.html
+bauhaus
+
+// bayern : Bayern Connect GmbH
+// https://www.iana.org/domains/root/db/bayern.html
+bayern
+
+// bbc : British Broadcasting Corporation
+// https://www.iana.org/domains/root/db/bbc.html
+bbc
+
+// bbt : BB&T Corporation
+// https://www.iana.org/domains/root/db/bbt.html
+bbt
+
+// bbva : BANCO BILBAO VIZCAYA ARGENTARIA, S.A.
+// https://www.iana.org/domains/root/db/bbva.html
+bbva
+
+// bcg : The Boston Consulting Group, Inc.
+// https://www.iana.org/domains/root/db/bcg.html
+bcg
+
+// bcn : Municipi de Barcelona
+// https://www.iana.org/domains/root/db/bcn.html
+bcn
+
+// beats : Beats Electronics, LLC
+// https://www.iana.org/domains/root/db/beats.html
+beats
+
+// beauty : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/beauty.html
+beauty
+
+// beer : Registry Services, LLC
+// https://www.iana.org/domains/root/db/beer.html
+beer
+
+// bentley : Bentley Motors Limited
+// https://www.iana.org/domains/root/db/bentley.html
+bentley
+
+// berlin : dotBERLIN GmbH & Co. KG
+// https://www.iana.org/domains/root/db/berlin.html
+berlin
+
+// best : BestTLD Pty Ltd
+// https://www.iana.org/domains/root/db/best.html
+best
+
+// bestbuy : BBY Solutions, Inc.
+// https://www.iana.org/domains/root/db/bestbuy.html
+bestbuy
+
+// bet : Identity Digital Limited
+// https://www.iana.org/domains/root/db/bet.html
+bet
+
+// bharti : Bharti Enterprises (Holding) Private Limited
+// https://www.iana.org/domains/root/db/bharti.html
+bharti
+
+// bible : American Bible Society
+// https://www.iana.org/domains/root/db/bible.html
+bible
+
+// bid : dot Bid Limited
+// https://www.iana.org/domains/root/db/bid.html
+bid
+
+// bike : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/bike.html
+bike
+
+// bing : Microsoft Corporation
+// https://www.iana.org/domains/root/db/bing.html
+bing
+
+// bingo : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/bingo.html
+bingo
+
+// bio : Identity Digital Limited
+// https://www.iana.org/domains/root/db/bio.html
+bio
+
+// black : Identity Digital Limited
+// https://www.iana.org/domains/root/db/black.html
+black
+
+// blackfriday : Registry Services, LLC
+// https://www.iana.org/domains/root/db/blackfriday.html
+blackfriday
+
+// blockbuster : Dish DBS Corporation
+// https://www.iana.org/domains/root/db/blockbuster.html
+blockbuster
+
+// blog : Knock Knock WHOIS There, LLC
+// https://www.iana.org/domains/root/db/blog.html
+blog
+
+// bloomberg : Bloomberg IP Holdings LLC
+// https://www.iana.org/domains/root/db/bloomberg.html
+bloomberg
+
+// blue : Identity Digital Limited
+// https://www.iana.org/domains/root/db/blue.html
+blue
+
+// bms : Bristol-Myers Squibb Company
+// https://www.iana.org/domains/root/db/bms.html
+bms
+
+// bmw : Bayerische Motoren Werke Aktiengesellschaft
+// https://www.iana.org/domains/root/db/bmw.html
+bmw
+
+// bnpparibas : BNP Paribas
+// https://www.iana.org/domains/root/db/bnpparibas.html
+bnpparibas
+
+// boats : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/boats.html
+boats
+
+// boehringer : Boehringer Ingelheim International GmbH
+// https://www.iana.org/domains/root/db/boehringer.html
+boehringer
+
+// bofa : Bank of America Corporation
+// https://www.iana.org/domains/root/db/bofa.html
+bofa
+
+// bom : Núcleo de Informação e Coordenação do Ponto BR - NIC.br
+// https://www.iana.org/domains/root/db/bom.html
+bom
+
+// bond : ShortDot SA
+// https://www.iana.org/domains/root/db/bond.html
+bond
+
+// boo : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/boo.html
+boo
+
+// book : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/book.html
+book
+
+// booking : Booking.com B.V.
+// https://www.iana.org/domains/root/db/booking.html
+booking
+
+// bosch : Robert Bosch GMBH
+// https://www.iana.org/domains/root/db/bosch.html
+bosch
+
+// bostik : Bostik SA
+// https://www.iana.org/domains/root/db/bostik.html
+bostik
+
+// boston : Registry Services, LLC
+// https://www.iana.org/domains/root/db/boston.html
+boston
+
+// bot : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/bot.html
+bot
+
+// boutique : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/boutique.html
+boutique
+
+// box : Intercap Registry Inc.
+// https://www.iana.org/domains/root/db/box.html
+box
+
+// bradesco : Banco Bradesco S.A.
+// https://www.iana.org/domains/root/db/bradesco.html
+bradesco
+
+// bridgestone : Bridgestone Corporation
+// https://www.iana.org/domains/root/db/bridgestone.html
+bridgestone
+
+// broadway : Celebrate Broadway, Inc.
+// https://www.iana.org/domains/root/db/broadway.html
+broadway
+
+// broker : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/broker.html
+broker
+
+// brother : Brother Industries, Ltd.
+// https://www.iana.org/domains/root/db/brother.html
+brother
+
+// brussels : DNS.be vzw
+// https://www.iana.org/domains/root/db/brussels.html
+brussels
+
+// build : Plan Bee LLC
+// https://www.iana.org/domains/root/db/build.html
+build
+
+// builders : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/builders.html
+builders
+
+// business : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/business.html
+business
+
+// buy : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/buy.html
+buy
+
+// buzz : DOTSTRATEGY CO.
+// https://www.iana.org/domains/root/db/buzz.html
+buzz
+
+// bzh : Association www.bzh
+// https://www.iana.org/domains/root/db/bzh.html
+bzh
+
+// cab : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/cab.html
+cab
+
+// cafe : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/cafe.html
+cafe
+
+// cal : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/cal.html
+cal
+
+// call : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/call.html
+call
+
+// calvinklein : PVH gTLD Holdings LLC
+// https://www.iana.org/domains/root/db/calvinklein.html
+calvinklein
+
+// cam : Cam Connecting SARL
+// https://www.iana.org/domains/root/db/cam.html
+cam
+
+// camera : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/camera.html
+camera
+
+// camp : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/camp.html
+camp
+
+// canon : Canon Inc.
+// https://www.iana.org/domains/root/db/canon.html
+canon
+
+// capetown : ZA Central Registry NPC trading as ZA Central Registry
+// https://www.iana.org/domains/root/db/capetown.html
+capetown
+
+// capital : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/capital.html
+capital
+
+// capitalone : Capital One Financial Corporation
+// https://www.iana.org/domains/root/db/capitalone.html
+capitalone
+
+// car : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/car.html
+car
+
+// caravan : Caravan International, Inc.
+// https://www.iana.org/domains/root/db/caravan.html
+caravan
+
+// cards : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/cards.html
+cards
+
+// care : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/care.html
+care
+
+// career : dotCareer LLC
+// https://www.iana.org/domains/root/db/career.html
+career
+
+// careers : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/careers.html
+careers
+
+// cars : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/cars.html
+cars
+
+// casa : Registry Services, LLC
+// https://www.iana.org/domains/root/db/casa.html
+casa
+
+// case : Digity, LLC
+// https://www.iana.org/domains/root/db/case.html
+case
+
+// cash : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/cash.html
+cash
+
+// casino : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/casino.html
+casino
+
+// catering : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/catering.html
+catering
+
+// catholic : Pontificium Consilium de Comunicationibus Socialibus (PCCS) (Pontifical Council for Social Communication)
+// https://www.iana.org/domains/root/db/catholic.html
+catholic
+
+// cba : COMMONWEALTH BANK OF AUSTRALIA
+// https://www.iana.org/domains/root/db/cba.html
+cba
+
+// cbn : The Christian Broadcasting Network, Inc.
+// https://www.iana.org/domains/root/db/cbn.html
+cbn
+
+// cbre : CBRE, Inc.
+// https://www.iana.org/domains/root/db/cbre.html
+cbre
+
+// center : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/center.html
+center
+
+// ceo : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/ceo.html
+ceo
+
+// cern : European Organization for Nuclear Research ("CERN")
+// https://www.iana.org/domains/root/db/cern.html
+cern
+
+// cfa : CFA Institute
+// https://www.iana.org/domains/root/db/cfa.html
+cfa
+
+// cfd : ShortDot SA
+// https://www.iana.org/domains/root/db/cfd.html
+cfd
+
+// chanel : Chanel International B.V.
+// https://www.iana.org/domains/root/db/chanel.html
+chanel
+
+// channel : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/channel.html
+channel
+
+// charity : Public Interest Registry
+// https://www.iana.org/domains/root/db/charity.html
+charity
+
+// chase : JPMorgan Chase Bank, National Association
+// https://www.iana.org/domains/root/db/chase.html
+chase
+
+// chat : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/chat.html
+chat
+
+// cheap : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/cheap.html
+cheap
+
+// chintai : CHINTAI Corporation
+// https://www.iana.org/domains/root/db/chintai.html
+chintai
+
+// christmas : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/christmas.html
+christmas
+
+// chrome : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/chrome.html
+chrome
+
+// church : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/church.html
+church
+
+// cipriani : Hotel Cipriani Srl
+// https://www.iana.org/domains/root/db/cipriani.html
+cipriani
+
+// circle : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/circle.html
+circle
+
+// cisco : Cisco Technology, Inc.
+// https://www.iana.org/domains/root/db/cisco.html
+cisco
+
+// citadel : Citadel Domain LLC
+// https://www.iana.org/domains/root/db/citadel.html
+citadel
+
+// citi : Citigroup Inc.
+// https://www.iana.org/domains/root/db/citi.html
+citi
+
+// citic : CITIC Group Corporation
+// https://www.iana.org/domains/root/db/citic.html
+citic
+
+// city : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/city.html
+city
+
+// claims : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/claims.html
+claims
+
+// cleaning : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/cleaning.html
+cleaning
+
+// click : Internet Naming Company LLC
+// https://www.iana.org/domains/root/db/click.html
+click
+
+// clinic : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/clinic.html
+clinic
+
+// clinique : The Estée Lauder Companies Inc.
+// https://www.iana.org/domains/root/db/clinique.html
+clinique
+
+// clothing : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/clothing.html
+clothing
+
+// cloud : Aruba PEC S.p.A.
+// https://www.iana.org/domains/root/db/cloud.html
+cloud
+
+// club : Registry Services, LLC
+// https://www.iana.org/domains/root/db/club.html
+club
+
+// clubmed : Club Méditerranée S.A.
+// https://www.iana.org/domains/root/db/clubmed.html
+clubmed
+
+// coach : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/coach.html
+coach
+
+// codes : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/codes.html
+codes
+
+// coffee : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/coffee.html
+coffee
+
+// college : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/college.html
+college
+
+// cologne : dotKoeln GmbH
+// https://www.iana.org/domains/root/db/cologne.html
+cologne
+
+// commbank : COMMONWEALTH BANK OF AUSTRALIA
+// https://www.iana.org/domains/root/db/commbank.html
+commbank
+
+// community : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/community.html
+community
+
+// company : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/company.html
+company
+
+// compare : Registry Services, LLC
+// https://www.iana.org/domains/root/db/compare.html
+compare
+
+// computer : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/computer.html
+computer
+
+// comsec : VeriSign, Inc.
+// https://www.iana.org/domains/root/db/comsec.html
+comsec
+
+// condos : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/condos.html
+condos
+
+// construction : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/construction.html
+construction
+
+// consulting : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/consulting.html
+consulting
+
+// contact : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/contact.html
+contact
+
+// contractors : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/contractors.html
+contractors
+
+// cooking : Registry Services, LLC
+// https://www.iana.org/domains/root/db/cooking.html
+cooking
+
+// cool : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/cool.html
+cool
+
+// corsica : Collectivité de Corse
+// https://www.iana.org/domains/root/db/corsica.html
+corsica
+
+// country : Internet Naming Company LLC
+// https://www.iana.org/domains/root/db/country.html
+country
+
+// coupon : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/coupon.html
+coupon
+
+// coupons : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/coupons.html
+coupons
+
+// courses : Registry Services, LLC
+// https://www.iana.org/domains/root/db/courses.html
+courses
+
+// cpa : American Institute of Certified Public Accountants
+// https://www.iana.org/domains/root/db/cpa.html
+cpa
+
+// credit : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/credit.html
+credit
+
+// creditcard : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/creditcard.html
+creditcard
+
+// creditunion : DotCooperation LLC
+// https://www.iana.org/domains/root/db/creditunion.html
+creditunion
+
+// cricket : dot Cricket Limited
+// https://www.iana.org/domains/root/db/cricket.html
+cricket
+
+// crown : Crown Equipment Corporation
+// https://www.iana.org/domains/root/db/crown.html
+crown
+
+// crs : Federated Co-operatives Limited
+// https://www.iana.org/domains/root/db/crs.html
+crs
+
+// cruise : Viking River Cruises (Bermuda) Ltd.
+// https://www.iana.org/domains/root/db/cruise.html
+cruise
+
+// cruises : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/cruises.html
+cruises
+
+// cuisinella : SCHMIDT GROUPE S.A.S.
+// https://www.iana.org/domains/root/db/cuisinella.html
+cuisinella
+
+// cymru : Nominet UK
+// https://www.iana.org/domains/root/db/cymru.html
+cymru
+
+// cyou : ShortDot SA
+// https://www.iana.org/domains/root/db/cyou.html
+cyou
+
+// dabur : Dabur India Limited
+// https://www.iana.org/domains/root/db/dabur.html
+dabur
+
+// dad : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/dad.html
+dad
+
+// dance : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/dance.html
+dance
+
+// data : Dish DBS Corporation
+// https://www.iana.org/domains/root/db/data.html
+data
+
+// date : dot Date Limited
+// https://www.iana.org/domains/root/db/date.html
+date
+
+// dating : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/dating.html
+dating
+
+// datsun : NISSAN MOTOR CO., LTD.
+// https://www.iana.org/domains/root/db/datsun.html
+datsun
+
+// day : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/day.html
+day
+
+// dclk : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/dclk.html
+dclk
+
+// dds : Registry Services, LLC
+// https://www.iana.org/domains/root/db/dds.html
+dds
+
+// deal : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/deal.html
+deal
+
+// dealer : Intercap Registry Inc.
+// https://www.iana.org/domains/root/db/dealer.html
+dealer
+
+// deals : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/deals.html
+deals
+
+// degree : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/degree.html
+degree
+
+// delivery : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/delivery.html
+delivery
+
+// dell : Dell Inc.
+// https://www.iana.org/domains/root/db/dell.html
+dell
+
+// deloitte : Deloitte Touche Tohmatsu
+// https://www.iana.org/domains/root/db/deloitte.html
+deloitte
+
+// delta : Delta Air Lines, Inc.
+// https://www.iana.org/domains/root/db/delta.html
+delta
+
+// democrat : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/democrat.html
+democrat
+
+// dental : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/dental.html
+dental
+
+// dentist : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/dentist.html
+dentist
+
+// desi
+// https://www.iana.org/domains/root/db/desi.html
+desi
+
+// design : Registry Services, LLC
+// https://www.iana.org/domains/root/db/design.html
+design
+
+// dev : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/dev.html
+dev
+
+// dhl : Deutsche Post AG
+// https://www.iana.org/domains/root/db/dhl.html
+dhl
+
+// diamonds : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/diamonds.html
+diamonds
+
+// diet : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/diet.html
+diet
+
+// digital : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/digital.html
+digital
+
+// direct : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/direct.html
+direct
+
+// directory : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/directory.html
+directory
+
+// discount : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/discount.html
+discount
+
+// discover : Discover Financial Services
+// https://www.iana.org/domains/root/db/discover.html
+discover
+
+// dish : Dish DBS Corporation
+// https://www.iana.org/domains/root/db/dish.html
+dish
+
+// diy : Internet Naming Company LLC
+// https://www.iana.org/domains/root/db/diy.html
+diy
+
+// dnp : Dai Nippon Printing Co., Ltd.
+// https://www.iana.org/domains/root/db/dnp.html
+dnp
+
+// docs : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/docs.html
+docs
+
+// doctor : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/doctor.html
+doctor
+
+// dog : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/dog.html
+dog
+
+// domains : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/domains.html
+domains
+
+// dot : Dish DBS Corporation
+// https://www.iana.org/domains/root/db/dot.html
+dot
+
+// download : dot Support Limited
+// https://www.iana.org/domains/root/db/download.html
+download
+
+// drive : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/drive.html
+drive
+
+// dtv : Dish DBS Corporation
+// https://www.iana.org/domains/root/db/dtv.html
+dtv
+
+// dubai : Dubai Smart Government Department
+// https://www.iana.org/domains/root/db/dubai.html
+dubai
+
+// dunlop : The Goodyear Tire & Rubber Company
+// https://www.iana.org/domains/root/db/dunlop.html
+dunlop
+
+// dupont : DuPont Specialty Products USA, LLC
+// https://www.iana.org/domains/root/db/dupont.html
+dupont
+
+// durban : ZA Central Registry NPC trading as ZA Central Registry
+// https://www.iana.org/domains/root/db/durban.html
+durban
+
+// dvag : Deutsche Vermögensberatung Aktiengesellschaft DVAG
+// https://www.iana.org/domains/root/db/dvag.html
+dvag
+
+// dvr : DISH Technologies L.L.C.
+// https://www.iana.org/domains/root/db/dvr.html
+dvr
+
+// earth : Interlink Systems Innovation Institute K.K.
+// https://www.iana.org/domains/root/db/earth.html
+earth
+
+// eat : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/eat.html
+eat
+
+// eco : Big Room Inc.
+// https://www.iana.org/domains/root/db/eco.html
+eco
+
+// edeka : EDEKA Verband kaufmännischer Genossenschaften e.V.
+// https://www.iana.org/domains/root/db/edeka.html
+edeka
+
+// education : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/education.html
+education
+
+// email : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/email.html
+email
+
+// emerck : Merck KGaA
+// https://www.iana.org/domains/root/db/emerck.html
+emerck
+
+// energy : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/energy.html
+energy
+
+// engineer : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/engineer.html
+engineer
+
+// engineering : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/engineering.html
+engineering
+
+// enterprises : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/enterprises.html
+enterprises
+
+// epson : Seiko Epson Corporation
+// https://www.iana.org/domains/root/db/epson.html
+epson
+
+// equipment : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/equipment.html
+equipment
+
+// ericsson : Telefonaktiebolaget L M Ericsson
+// https://www.iana.org/domains/root/db/ericsson.html
+ericsson
+
+// erni : ERNI Group Holding AG
+// https://www.iana.org/domains/root/db/erni.html
+erni
+
+// esq : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/esq.html
+esq
+
+// estate : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/estate.html
+estate
+
+// eurovision : European Broadcasting Union (EBU)
+// https://www.iana.org/domains/root/db/eurovision.html
+eurovision
+
+// eus : Puntueus Fundazioa
+// https://www.iana.org/domains/root/db/eus.html
+eus
+
+// events : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/events.html
+events
+
+// exchange : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/exchange.html
+exchange
+
+// expert : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/expert.html
+expert
+
+// exposed : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/exposed.html
+exposed
+
+// express : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/express.html
+express
+
+// extraspace : Extra Space Storage LLC
+// https://www.iana.org/domains/root/db/extraspace.html
+extraspace
+
+// fage : Fage International S.A.
+// https://www.iana.org/domains/root/db/fage.html
+fage
+
+// fail : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/fail.html
+fail
+
+// fairwinds : FairWinds Partners, LLC
+// https://www.iana.org/domains/root/db/fairwinds.html
+fairwinds
+
+// faith : dot Faith Limited
+// https://www.iana.org/domains/root/db/faith.html
+faith
+
+// family : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/family.html
+family
+
+// fan : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/fan.html
+fan
+
+// fans : ZDNS International Limited
+// https://www.iana.org/domains/root/db/fans.html
+fans
+
+// farm : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/farm.html
+farm
+
+// farmers : Farmers Insurance Exchange
+// https://www.iana.org/domains/root/db/farmers.html
+farmers
+
+// fashion : Registry Services, LLC
+// https://www.iana.org/domains/root/db/fashion.html
+fashion
+
+// fast : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/fast.html
+fast
+
+// fedex : Federal Express Corporation
+// https://www.iana.org/domains/root/db/fedex.html
+fedex
+
+// feedback : Top Level Spectrum, Inc.
+// https://www.iana.org/domains/root/db/feedback.html
+feedback
+
+// ferrari : Fiat Chrysler Automobiles N.V.
+// https://www.iana.org/domains/root/db/ferrari.html
+ferrari
+
+// ferrero : Ferrero Trading Lux S.A.
+// https://www.iana.org/domains/root/db/ferrero.html
+ferrero
+
+// fidelity : Fidelity Brokerage Services LLC
+// https://www.iana.org/domains/root/db/fidelity.html
+fidelity
+
+// fido : Rogers Communications Canada Inc.
+// https://www.iana.org/domains/root/db/fido.html
+fido
+
+// film : Motion Picture Domain Registry Pty Ltd
+// https://www.iana.org/domains/root/db/film.html
+film
+
+// final : Núcleo de Informação e Coordenação do Ponto BR - NIC.br
+// https://www.iana.org/domains/root/db/final.html
+final
+
+// finance : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/finance.html
+finance
+
+// financial : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/financial.html
+financial
+
+// fire : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/fire.html
+fire
+
+// firestone : Bridgestone Licensing Services, Inc
+// https://www.iana.org/domains/root/db/firestone.html
+firestone
+
+// firmdale : Firmdale Holdings Limited
+// https://www.iana.org/domains/root/db/firmdale.html
+firmdale
+
+// fish : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/fish.html
+fish
+
+// fishing : Registry Services, LLC
+// https://www.iana.org/domains/root/db/fishing.html
+fishing
+
+// fit : Registry Services, LLC
+// https://www.iana.org/domains/root/db/fit.html
+fit
+
+// fitness : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/fitness.html
+fitness
+
+// flickr : Flickr, Inc.
+// https://www.iana.org/domains/root/db/flickr.html
+flickr
+
+// flights : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/flights.html
+flights
+
+// flir : FLIR Systems, Inc.
+// https://www.iana.org/domains/root/db/flir.html
+flir
+
+// florist : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/florist.html
+florist
+
+// flowers : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/flowers.html
+flowers
+
+// fly : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/fly.html
+fly
+
+// foo : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/foo.html
+foo
+
+// food : Internet Naming Company LLC
+// https://www.iana.org/domains/root/db/food.html
+food
+
+// football : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/football.html
+football
+
+// ford : Ford Motor Company
+// https://www.iana.org/domains/root/db/ford.html
+ford
+
+// forex : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/forex.html
+forex
+
+// forsale : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/forsale.html
+forsale
+
+// forum : Fegistry, LLC
+// https://www.iana.org/domains/root/db/forum.html
+forum
+
+// foundation : Public Interest Registry
+// https://www.iana.org/domains/root/db/foundation.html
+foundation
+
+// fox : FOX Registry, LLC
+// https://www.iana.org/domains/root/db/fox.html
+fox
+
+// free : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/free.html
+free
+
+// fresenius : Fresenius Immobilien-Verwaltungs-GmbH
+// https://www.iana.org/domains/root/db/fresenius.html
+fresenius
+
+// frl : FRLregistry B.V.
+// https://www.iana.org/domains/root/db/frl.html
+frl
+
+// frogans : OP3FT
+// https://www.iana.org/domains/root/db/frogans.html
+frogans
+
+// frontier : Frontier Communications Corporation
+// https://www.iana.org/domains/root/db/frontier.html
+frontier
+
+// ftr : Frontier Communications Corporation
+// https://www.iana.org/domains/root/db/ftr.html
+ftr
+
+// fujitsu : Fujitsu Limited
+// https://www.iana.org/domains/root/db/fujitsu.html
+fujitsu
+
+// fun : Radix Technologies Inc.
+// https://www.iana.org/domains/root/db/fun.html
+fun
+
+// fund : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/fund.html
+fund
+
+// furniture : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/furniture.html
+furniture
+
+// futbol : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/futbol.html
+futbol
+
+// fyi : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/fyi.html
+fyi
+
+// gal : Asociación puntoGAL
+// https://www.iana.org/domains/root/db/gal.html
+gal
+
+// gallery : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/gallery.html
+gallery
+
+// gallo : Gallo Vineyards, Inc.
+// https://www.iana.org/domains/root/db/gallo.html
+gallo
+
+// gallup : Gallup, Inc.
+// https://www.iana.org/domains/root/db/gallup.html
+gallup
+
+// game : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/game.html
+game
+
+// games : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/games.html
+games
+
+// gap : The Gap, Inc.
+// https://www.iana.org/domains/root/db/gap.html
+gap
+
+// garden : Registry Services, LLC
+// https://www.iana.org/domains/root/db/garden.html
+garden
+
+// gay : Registry Services, LLC
+// https://www.iana.org/domains/root/db/gay.html
+gay
+
+// gbiz : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/gbiz.html
+gbiz
+
+// gdn : Joint Stock Company "Navigation-information systems"
+// https://www.iana.org/domains/root/db/gdn.html
+gdn
+
+// gea : GEA Group Aktiengesellschaft
+// https://www.iana.org/domains/root/db/gea.html
+gea
+
+// gent : Easyhost BV
+// https://www.iana.org/domains/root/db/gent.html
+gent
+
+// genting : Resorts World Inc Pte. Ltd.
+// https://www.iana.org/domains/root/db/genting.html
+genting
+
+// george : Wal-Mart Stores, Inc.
+// https://www.iana.org/domains/root/db/george.html
+george
+
+// ggee : GMO Internet, Inc.
+// https://www.iana.org/domains/root/db/ggee.html
+ggee
+
+// gift : DotGift, LLC
+// https://www.iana.org/domains/root/db/gift.html
+gift
+
+// gifts : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/gifts.html
+gifts
+
+// gives : Public Interest Registry
+// https://www.iana.org/domains/root/db/gives.html
+gives
+
+// giving : Public Interest Registry
+// https://www.iana.org/domains/root/db/giving.html
+giving
+
+// glass : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/glass.html
+glass
+
+// gle : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/gle.html
+gle
+
+// global : Identity Digital Limited
+// https://www.iana.org/domains/root/db/global.html
+global
+
+// globo : Globo Comunicação e Participações S.A
+// https://www.iana.org/domains/root/db/globo.html
+globo
+
+// gmail : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/gmail.html
+gmail
+
+// gmbh : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/gmbh.html
+gmbh
+
+// gmo : GMO Internet, Inc.
+// https://www.iana.org/domains/root/db/gmo.html
+gmo
+
+// gmx : 1&1 Mail & Media GmbH
+// https://www.iana.org/domains/root/db/gmx.html
+gmx
+
+// godaddy : Go Daddy East, LLC
+// https://www.iana.org/domains/root/db/godaddy.html
+godaddy
+
+// gold : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/gold.html
+gold
+
+// goldpoint : YODOBASHI CAMERA CO.,LTD.
+// https://www.iana.org/domains/root/db/goldpoint.html
+goldpoint
+
+// golf : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/golf.html
+golf
+
+// goo : NTT DOCOMO, INC.
+// https://www.iana.org/domains/root/db/goo.html
+goo
+
+// goodyear : The Goodyear Tire & Rubber Company
+// https://www.iana.org/domains/root/db/goodyear.html
+goodyear
+
+// goog : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/goog.html
+goog
+
+// google : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/google.html
+google
+
+// gop : Republican State Leadership Committee, Inc.
+// https://www.iana.org/domains/root/db/gop.html
+gop
+
+// got : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/got.html
+got
+
+// grainger : Grainger Registry Services, LLC
+// https://www.iana.org/domains/root/db/grainger.html
+grainger
+
+// graphics : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/graphics.html
+graphics
+
+// gratis : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/gratis.html
+gratis
+
+// green : Identity Digital Limited
+// https://www.iana.org/domains/root/db/green.html
+green
+
+// gripe : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/gripe.html
+gripe
+
+// grocery : Wal-Mart Stores, Inc.
+// https://www.iana.org/domains/root/db/grocery.html
+grocery
+
+// group : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/group.html
+group
+
+// gucci : Guccio Gucci S.p.a.
+// https://www.iana.org/domains/root/db/gucci.html
+gucci
+
+// guge : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/guge.html
+guge
+
+// guide : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/guide.html
+guide
+
+// guitars : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/guitars.html
+guitars
+
+// guru : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/guru.html
+guru
+
+// hair : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/hair.html
+hair
+
+// hamburg : Hamburg Top-Level-Domain GmbH
+// https://www.iana.org/domains/root/db/hamburg.html
+hamburg
+
+// hangout : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/hangout.html
+hangout
+
+// haus : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/haus.html
+haus
+
+// hbo : HBO Registry Services, Inc.
+// https://www.iana.org/domains/root/db/hbo.html
+hbo
+
+// hdfc : HOUSING DEVELOPMENT FINANCE CORPORATION LIMITED
+// https://www.iana.org/domains/root/db/hdfc.html
+hdfc
+
+// hdfcbank : HDFC Bank Limited
+// https://www.iana.org/domains/root/db/hdfcbank.html
+hdfcbank
+
+// health : Registry Services, LLC
+// https://www.iana.org/domains/root/db/health.html
+health
+
+// healthcare : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/healthcare.html
+healthcare
+
+// help : Innovation service Limited
+// https://www.iana.org/domains/root/db/help.html
+help
+
+// helsinki : City of Helsinki
+// https://www.iana.org/domains/root/db/helsinki.html
+helsinki
+
+// here : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/here.html
+here
+
+// hermes : HERMES INTERNATIONAL
+// https://www.iana.org/domains/root/db/hermes.html
+hermes
+
+// hiphop : Dot Hip Hop, LLC
+// https://www.iana.org/domains/root/db/hiphop.html
+hiphop
+
+// hisamitsu : Hisamitsu Pharmaceutical Co.,Inc.
+// https://www.iana.org/domains/root/db/hisamitsu.html
+hisamitsu
+
+// hitachi : Hitachi, Ltd.
+// https://www.iana.org/domains/root/db/hitachi.html
+hitachi
+
+// hiv : Internet Naming Company LLC
+// https://www.iana.org/domains/root/db/hiv.html
+hiv
+
+// hkt : PCCW-HKT DataCom Services Limited
+// https://www.iana.org/domains/root/db/hkt.html
+hkt
+
+// hockey : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/hockey.html
+hockey
+
+// holdings : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/holdings.html
+holdings
+
+// holiday : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/holiday.html
+holiday
+
+// homedepot : Home Depot Product Authority, LLC
+// https://www.iana.org/domains/root/db/homedepot.html
+homedepot
+
+// homegoods : The TJX Companies, Inc.
+// https://www.iana.org/domains/root/db/homegoods.html
+homegoods
+
+// homes : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/homes.html
+homes
+
+// homesense : The TJX Companies, Inc.
+// https://www.iana.org/domains/root/db/homesense.html
+homesense
+
+// honda : Honda Motor Co., Ltd.
+// https://www.iana.org/domains/root/db/honda.html
+honda
+
+// horse : Registry Services, LLC
+// https://www.iana.org/domains/root/db/horse.html
+horse
+
+// hospital : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/hospital.html
+hospital
+
+// host : Radix Technologies Inc.
+// https://www.iana.org/domains/root/db/host.html
+host
+
+// hosting : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/hosting.html
+hosting
+
+// hot : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/hot.html
+hot
+
+// hotels : Booking.com B.V.
+// https://www.iana.org/domains/root/db/hotels.html
+hotels
+
+// hotmail : Microsoft Corporation
+// https://www.iana.org/domains/root/db/hotmail.html
+hotmail
+
+// house : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/house.html
+house
+
+// how : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/how.html
+how
+
+// hsbc : HSBC Global Services (UK) Limited
+// https://www.iana.org/domains/root/db/hsbc.html
+hsbc
+
+// hughes : Hughes Satellite Systems Corporation
+// https://www.iana.org/domains/root/db/hughes.html
+hughes
+
+// hyatt : Hyatt GTLD, L.L.C.
+// https://www.iana.org/domains/root/db/hyatt.html
+hyatt
+
+// hyundai : Hyundai Motor Company
+// https://www.iana.org/domains/root/db/hyundai.html
+hyundai
+
+// ibm : International Business Machines Corporation
+// https://www.iana.org/domains/root/db/ibm.html
+ibm
+
+// icbc : Industrial and Commercial Bank of China Limited
+// https://www.iana.org/domains/root/db/icbc.html
+icbc
+
+// ice : IntercontinentalExchange, Inc.
+// https://www.iana.org/domains/root/db/ice.html
+ice
+
+// icu : ShortDot SA
+// https://www.iana.org/domains/root/db/icu.html
+icu
+
+// ieee : IEEE Global LLC
+// https://www.iana.org/domains/root/db/ieee.html
+ieee
+
+// ifm : ifm electronic gmbh
+// https://www.iana.org/domains/root/db/ifm.html
+ifm
+
+// ikano : Ikano S.A.
+// https://www.iana.org/domains/root/db/ikano.html
+ikano
+
+// imamat : Fondation Aga Khan (Aga Khan Foundation)
+// https://www.iana.org/domains/root/db/imamat.html
+imamat
+
+// imdb : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/imdb.html
+imdb
+
+// immo : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/immo.html
+immo
+
+// immobilien : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/immobilien.html
+immobilien
+
+// inc : Intercap Registry Inc.
+// https://www.iana.org/domains/root/db/inc.html
+inc
+
+// industries : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/industries.html
+industries
+
+// infiniti : NISSAN MOTOR CO., LTD.
+// https://www.iana.org/domains/root/db/infiniti.html
+infiniti
+
+// ing : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/ing.html
+ing
+
+// ink : Registry Services, LLC
+// https://www.iana.org/domains/root/db/ink.html
+ink
+
+// institute : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/institute.html
+institute
+
+// insurance : fTLD Registry Services LLC
+// https://www.iana.org/domains/root/db/insurance.html
+insurance
+
+// insure : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/insure.html
+insure
+
+// international : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/international.html
+international
+
+// intuit : Intuit Administrative Services, Inc.
+// https://www.iana.org/domains/root/db/intuit.html
+intuit
+
+// investments : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/investments.html
+investments
+
+// ipiranga : Ipiranga Produtos de Petroleo S.A.
+// https://www.iana.org/domains/root/db/ipiranga.html
+ipiranga
+
+// irish : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/irish.html
+irish
+
+// ismaili : Fondation Aga Khan (Aga Khan Foundation)
+// https://www.iana.org/domains/root/db/ismaili.html
+ismaili
+
+// ist : Istanbul Metropolitan Municipality
+// https://www.iana.org/domains/root/db/ist.html
+ist
+
+// istanbul : Istanbul Metropolitan Municipality
+// https://www.iana.org/domains/root/db/istanbul.html
+istanbul
+
+// itau : Itau Unibanco Holding S.A.
+// https://www.iana.org/domains/root/db/itau.html
+itau
+
+// itv : ITV Services Limited
+// https://www.iana.org/domains/root/db/itv.html
+itv
+
+// jaguar : Jaguar Land Rover Ltd
+// https://www.iana.org/domains/root/db/jaguar.html
+jaguar
+
+// java : Oracle Corporation
+// https://www.iana.org/domains/root/db/java.html
+java
+
+// jcb : JCB Co., Ltd.
+// https://www.iana.org/domains/root/db/jcb.html
+jcb
+
+// jeep : FCA US LLC.
+// https://www.iana.org/domains/root/db/jeep.html
+jeep
+
+// jetzt : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/jetzt.html
+jetzt
+
+// jewelry : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/jewelry.html
+jewelry
+
+// jio : Reliance Industries Limited
+// https://www.iana.org/domains/root/db/jio.html
+jio
+
+// jll : Jones Lang LaSalle Incorporated
+// https://www.iana.org/domains/root/db/jll.html
+jll
+
+// jmp : Matrix IP LLC
+// https://www.iana.org/domains/root/db/jmp.html
+jmp
+
+// jnj : Johnson & Johnson Services, Inc.
+// https://www.iana.org/domains/root/db/jnj.html
+jnj
+
+// joburg : ZA Central Registry NPC trading as ZA Central Registry
+// https://www.iana.org/domains/root/db/joburg.html
+joburg
+
+// jot : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/jot.html
+jot
+
+// joy : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/joy.html
+joy
+
+// jpmorgan : JPMorgan Chase Bank, National Association
+// https://www.iana.org/domains/root/db/jpmorgan.html
+jpmorgan
+
+// jprs : Japan Registry Services Co., Ltd.
+// https://www.iana.org/domains/root/db/jprs.html
+jprs
+
+// juegos : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/juegos.html
+juegos
+
+// juniper : JUNIPER NETWORKS, INC.
+// https://www.iana.org/domains/root/db/juniper.html
+juniper
+
+// kaufen : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/kaufen.html
+kaufen
+
+// kddi : KDDI CORPORATION
+// https://www.iana.org/domains/root/db/kddi.html
+kddi
+
+// kerryhotels : Kerry Trading Co. Limited
+// https://www.iana.org/domains/root/db/kerryhotels.html
+kerryhotels
+
+// kerrylogistics : Kerry Trading Co. Limited
+// https://www.iana.org/domains/root/db/kerrylogistics.html
+kerrylogistics
+
+// kerryproperties : Kerry Trading Co. Limited
+// https://www.iana.org/domains/root/db/kerryproperties.html
+kerryproperties
+
+// kfh : Kuwait Finance House
+// https://www.iana.org/domains/root/db/kfh.html
+kfh
+
+// kia : KIA MOTORS CORPORATION
+// https://www.iana.org/domains/root/db/kia.html
+kia
+
+// kids : DotKids Foundation Limited
+// https://www.iana.org/domains/root/db/kids.html
+kids
+
+// kim : Identity Digital Limited
+// https://www.iana.org/domains/root/db/kim.html
+kim
+
+// kindle : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/kindle.html
+kindle
+
+// kitchen : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/kitchen.html
+kitchen
+
+// kiwi : DOT KIWI LIMITED
+// https://www.iana.org/domains/root/db/kiwi.html
+kiwi
+
+// koeln : dotKoeln GmbH
+// https://www.iana.org/domains/root/db/koeln.html
+koeln
+
+// komatsu : Komatsu Ltd.
+// https://www.iana.org/domains/root/db/komatsu.html
+komatsu
+
+// kosher : Kosher Marketing Assets LLC
+// https://www.iana.org/domains/root/db/kosher.html
+kosher
+
+// kpmg : KPMG International Cooperative (KPMG International Genossenschaft)
+// https://www.iana.org/domains/root/db/kpmg.html
+kpmg
+
+// kpn : Koninklijke KPN N.V.
+// https://www.iana.org/domains/root/db/kpn.html
+kpn
+
+// krd : KRG Department of Information Technology
+// https://www.iana.org/domains/root/db/krd.html
+krd
+
+// kred : KredTLD Pty Ltd
+// https://www.iana.org/domains/root/db/kred.html
+kred
+
+// kuokgroup : Kerry Trading Co. Limited
+// https://www.iana.org/domains/root/db/kuokgroup.html
+kuokgroup
+
+// kyoto : Academic Institution: Kyoto Jyoho Gakuen
+// https://www.iana.org/domains/root/db/kyoto.html
+kyoto
+
+// lacaixa : Fundación Bancaria Caixa d’Estalvis i Pensions de Barcelona, “la Caixa”
+// https://www.iana.org/domains/root/db/lacaixa.html
+lacaixa
+
+// lamborghini : Automobili Lamborghini S.p.A.
+// https://www.iana.org/domains/root/db/lamborghini.html
+lamborghini
+
+// lamer : The Estée Lauder Companies Inc.
+// https://www.iana.org/domains/root/db/lamer.html
+lamer
+
+// lancaster : LANCASTER
+// https://www.iana.org/domains/root/db/lancaster.html
+lancaster
+
+// land : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/land.html
+land
+
+// landrover : Jaguar Land Rover Ltd
+// https://www.iana.org/domains/root/db/landrover.html
+landrover
+
+// lanxess : LANXESS Corporation
+// https://www.iana.org/domains/root/db/lanxess.html
+lanxess
+
+// lasalle : Jones Lang LaSalle Incorporated
+// https://www.iana.org/domains/root/db/lasalle.html
+lasalle
+
+// lat : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/lat.html
+lat
+
+// latino : Dish DBS Corporation
+// https://www.iana.org/domains/root/db/latino.html
+latino
+
+// latrobe : La Trobe University
+// https://www.iana.org/domains/root/db/latrobe.html
+latrobe
+
+// law : Registry Services, LLC
+// https://www.iana.org/domains/root/db/law.html
+law
+
+// lawyer : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/lawyer.html
+lawyer
+
+// lds : IRI Domain Management, LLC
+// https://www.iana.org/domains/root/db/lds.html
+lds
+
+// lease : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/lease.html
+lease
+
+// leclerc : A.C.D. LEC Association des Centres Distributeurs Edouard Leclerc
+// https://www.iana.org/domains/root/db/leclerc.html
+leclerc
+
+// lefrak : LeFrak Organization, Inc.
+// https://www.iana.org/domains/root/db/lefrak.html
+lefrak
+
+// legal : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/legal.html
+legal
+
+// lego : LEGO Juris A/S
+// https://www.iana.org/domains/root/db/lego.html
+lego
+
+// lexus : TOYOTA MOTOR CORPORATION
+// https://www.iana.org/domains/root/db/lexus.html
+lexus
+
+// lgbt : Identity Digital Limited
+// https://www.iana.org/domains/root/db/lgbt.html
+lgbt
+
+// lidl : Schwarz Domains und Services GmbH & Co. KG
+// https://www.iana.org/domains/root/db/lidl.html
+lidl
+
+// life : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/life.html
+life
+
+// lifeinsurance : American Council of Life Insurers
+// https://www.iana.org/domains/root/db/lifeinsurance.html
+lifeinsurance
+
+// lifestyle : Internet Naming Company LLC
+// https://www.iana.org/domains/root/db/lifestyle.html
+lifestyle
+
+// lighting : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/lighting.html
+lighting
+
+// like : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/like.html
+like
+
+// lilly : Eli Lilly and Company
+// https://www.iana.org/domains/root/db/lilly.html
+lilly
+
+// limited : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/limited.html
+limited
+
+// limo : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/limo.html
+limo
+
+// lincoln : Ford Motor Company
+// https://www.iana.org/domains/root/db/lincoln.html
+lincoln
+
+// link : Nova Registry Ltd
+// https://www.iana.org/domains/root/db/link.html
+link
+
+// lipsy : Lipsy Ltd
+// https://www.iana.org/domains/root/db/lipsy.html
+lipsy
+
+// live : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/live.html
+live
+
+// living : Internet Naming Company LLC
+// https://www.iana.org/domains/root/db/living.html
+living
+
+// llc : Identity Digital Limited
+// https://www.iana.org/domains/root/db/llc.html
+llc
+
+// llp : Intercap Registry Inc.
+// https://www.iana.org/domains/root/db/llp.html
+llp
+
+// loan : dot Loan Limited
+// https://www.iana.org/domains/root/db/loan.html
+loan
+
+// loans : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/loans.html
+loans
+
+// locker : Orange Domains LLC
+// https://www.iana.org/domains/root/db/locker.html
+locker
+
+// locus : Locus Analytics LLC
+// https://www.iana.org/domains/root/db/locus.html
+locus
+
+// lol : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/lol.html
+lol
+
+// london : Dot London Domains Limited
+// https://www.iana.org/domains/root/db/london.html
+london
+
+// lotte : Lotte Holdings Co., Ltd.
+// https://www.iana.org/domains/root/db/lotte.html
+lotte
+
+// lotto : Identity Digital Limited
+// https://www.iana.org/domains/root/db/lotto.html
+lotto
+
+// love : Waterford Limited
+// https://www.iana.org/domains/root/db/love.html
+love
+
+// lpl : LPL Holdings, Inc.
+// https://www.iana.org/domains/root/db/lpl.html
+lpl
+
+// lplfinancial : LPL Holdings, Inc.
+// https://www.iana.org/domains/root/db/lplfinancial.html
+lplfinancial
+
+// ltd : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/ltd.html
+ltd
+
+// ltda : InterNetX, Corp
+// https://www.iana.org/domains/root/db/ltda.html
+ltda
+
+// lundbeck : H. Lundbeck A/S
+// https://www.iana.org/domains/root/db/lundbeck.html
+lundbeck
+
+// luxe : Registry Services, LLC
+// https://www.iana.org/domains/root/db/luxe.html
+luxe
+
+// luxury : Luxury Partners, LLC
+// https://www.iana.org/domains/root/db/luxury.html
+luxury
+
+// madrid : Comunidad de Madrid
+// https://www.iana.org/domains/root/db/madrid.html
+madrid
+
+// maif : Mutuelle Assurance Instituteur France (MAIF)
+// https://www.iana.org/domains/root/db/maif.html
+maif
+
+// maison : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/maison.html
+maison
+
+// makeup : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/makeup.html
+makeup
+
+// man : MAN SE
+// https://www.iana.org/domains/root/db/man.html
+man
+
+// management : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/management.html
+management
+
+// mango : PUNTO FA S.L.
+// https://www.iana.org/domains/root/db/mango.html
+mango
+
+// map : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/map.html
+map
+
+// market : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/market.html
+market
+
+// marketing : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/marketing.html
+marketing
+
+// markets : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/markets.html
+markets
+
+// marriott : Marriott Worldwide Corporation
+// https://www.iana.org/domains/root/db/marriott.html
+marriott
+
+// marshalls : The TJX Companies, Inc.
+// https://www.iana.org/domains/root/db/marshalls.html
+marshalls
+
+// mattel : Mattel Sites, Inc.
+// https://www.iana.org/domains/root/db/mattel.html
+mattel
+
+// mba : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/mba.html
+mba
+
+// mckinsey : McKinsey Holdings, Inc.
+// https://www.iana.org/domains/root/db/mckinsey.html
+mckinsey
+
+// med : Medistry LLC
+// https://www.iana.org/domains/root/db/med.html
+med
+
+// media : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/media.html
+media
+
+// meet : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/meet.html
+meet
+
+// melbourne : The Crown in right of the State of Victoria, represented by its Department of State Development, Business and Innovation
+// https://www.iana.org/domains/root/db/melbourne.html
+melbourne
+
+// meme : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/meme.html
+meme
+
+// memorial : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/memorial.html
+memorial
+
+// men : Exclusive Registry Limited
+// https://www.iana.org/domains/root/db/men.html
+men
+
+// menu : Dot Menu Registry, LLC
+// https://www.iana.org/domains/root/db/menu.html
+menu
+
+// merckmsd : MSD Registry Holdings, Inc.
+// https://www.iana.org/domains/root/db/merckmsd.html
+merckmsd
+
+// miami : Registry Services, LLC
+// https://www.iana.org/domains/root/db/miami.html
+miami
+
+// microsoft : Microsoft Corporation
+// https://www.iana.org/domains/root/db/microsoft.html
+microsoft
+
+// mini : Bayerische Motoren Werke Aktiengesellschaft
+// https://www.iana.org/domains/root/db/mini.html
+mini
+
+// mint : Intuit Administrative Services, Inc.
+// https://www.iana.org/domains/root/db/mint.html
+mint
+
+// mit : Massachusetts Institute of Technology
+// https://www.iana.org/domains/root/db/mit.html
+mit
+
+// mitsubishi : Mitsubishi Corporation
+// https://www.iana.org/domains/root/db/mitsubishi.html
+mitsubishi
+
+// mlb : MLB Advanced Media DH, LLC
+// https://www.iana.org/domains/root/db/mlb.html
+mlb
+
+// mls : The Canadian Real Estate Association
+// https://www.iana.org/domains/root/db/mls.html
+mls
+
+// mma : MMA IARD
+// https://www.iana.org/domains/root/db/mma.html
+mma
+
+// mobile : Dish DBS Corporation
+// https://www.iana.org/domains/root/db/mobile.html
+mobile
+
+// moda : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/moda.html
+moda
+
+// moe : Interlink Systems Innovation Institute K.K.
+// https://www.iana.org/domains/root/db/moe.html
+moe
+
+// moi : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/moi.html
+moi
+
+// mom : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/mom.html
+mom
+
+// monash : Monash University
+// https://www.iana.org/domains/root/db/monash.html
+monash
+
+// money : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/money.html
+money
+
+// monster : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/monster.html
+monster
+
+// mormon : IRI Domain Management, LLC
+// https://www.iana.org/domains/root/db/mormon.html
+mormon
+
+// mortgage : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/mortgage.html
+mortgage
+
+// moscow : Foundation for Assistance for Internet Technologies and Infrastructure Development (FAITID)
+// https://www.iana.org/domains/root/db/moscow.html
+moscow
+
+// moto : Motorola Trademark Holdings, LLC
+// https://www.iana.org/domains/root/db/moto.html
+moto
+
+// motorcycles : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/motorcycles.html
+motorcycles
+
+// mov : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/mov.html
+mov
+
+// movie : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/movie.html
+movie
+
+// msd : MSD Registry Holdings, Inc.
+// https://www.iana.org/domains/root/db/msd.html
+msd
+
+// mtn : MTN Dubai Limited
+// https://www.iana.org/domains/root/db/mtn.html
+mtn
+
+// mtr : MTR Corporation Limited
+// https://www.iana.org/domains/root/db/mtr.html
+mtr
+
+// music : DotMusic Limited
+// https://www.iana.org/domains/root/db/music.html
+music
+
+// nab : National Australia Bank Limited
+// https://www.iana.org/domains/root/db/nab.html
+nab
+
+// nagoya : GMO Registry, Inc.
+// https://www.iana.org/domains/root/db/nagoya.html
+nagoya
+
+// navy : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/navy.html
+navy
+
+// nba : NBA REGISTRY, LLC
+// https://www.iana.org/domains/root/db/nba.html
+nba
+
+// nec : NEC Corporation
+// https://www.iana.org/domains/root/db/nec.html
+nec
+
+// netbank : COMMONWEALTH BANK OF AUSTRALIA
+// https://www.iana.org/domains/root/db/netbank.html
+netbank
+
+// netflix : Netflix, Inc.
+// https://www.iana.org/domains/root/db/netflix.html
+netflix
+
+// network : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/network.html
+network
+
+// neustar : NeuStar, Inc.
+// https://www.iana.org/domains/root/db/neustar.html
+neustar
+
+// new : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/new.html
+new
+
+// news : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/news.html
+news
+
+// next : Next plc
+// https://www.iana.org/domains/root/db/next.html
+next
+
+// nextdirect : Next plc
+// https://www.iana.org/domains/root/db/nextdirect.html
+nextdirect
+
+// nexus : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/nexus.html
+nexus
+
+// nfl : NFL Reg Ops LLC
+// https://www.iana.org/domains/root/db/nfl.html
+nfl
+
+// ngo : Public Interest Registry
+// https://www.iana.org/domains/root/db/ngo.html
+ngo
+
+// nhk : Japan Broadcasting Corporation (NHK)
+// https://www.iana.org/domains/root/db/nhk.html
+nhk
+
+// nico : DWANGO Co., Ltd.
+// https://www.iana.org/domains/root/db/nico.html
+nico
+
+// nike : NIKE, Inc.
+// https://www.iana.org/domains/root/db/nike.html
+nike
+
+// nikon : NIKON CORPORATION
+// https://www.iana.org/domains/root/db/nikon.html
+nikon
+
+// ninja : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/ninja.html
+ninja
+
+// nissan : NISSAN MOTOR CO., LTD.
+// https://www.iana.org/domains/root/db/nissan.html
+nissan
+
+// nissay : Nippon Life Insurance Company
+// https://www.iana.org/domains/root/db/nissay.html
+nissay
+
+// nokia : Nokia Corporation
+// https://www.iana.org/domains/root/db/nokia.html
+nokia
+
+// norton : NortonLifeLock Inc.
+// https://www.iana.org/domains/root/db/norton.html
+norton
+
+// now : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/now.html
+now
+
+// nowruz : Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
+// https://www.iana.org/domains/root/db/nowruz.html
+nowruz
+
+// nowtv : Starbucks (HK) Limited
+// https://www.iana.org/domains/root/db/nowtv.html
+nowtv
+
+// nra : NRA Holdings Company, INC.
+// https://www.iana.org/domains/root/db/nra.html
+nra
+
+// nrw : Minds + Machines GmbH
+// https://www.iana.org/domains/root/db/nrw.html
+nrw
+
+// ntt : NIPPON TELEGRAPH AND TELEPHONE CORPORATION
+// https://www.iana.org/domains/root/db/ntt.html
+ntt
+
+// nyc : The City of New York by and through the New York City Department of Information Technology & Telecommunications
+// https://www.iana.org/domains/root/db/nyc.html
+nyc
+
+// obi : OBI Group Holding SE & Co. KGaA
+// https://www.iana.org/domains/root/db/obi.html
+obi
+
+// observer : Fegistry, LLC
+// https://www.iana.org/domains/root/db/observer.html
+observer
+
+// office : Microsoft Corporation
+// https://www.iana.org/domains/root/db/office.html
+office
+
+// okinawa : BRregistry, Inc.
+// https://www.iana.org/domains/root/db/okinawa.html
+okinawa
+
+// olayan : Competrol (Luxembourg) Sarl
+// https://www.iana.org/domains/root/db/olayan.html
+olayan
+
+// olayangroup : Competrol (Luxembourg) Sarl
+// https://www.iana.org/domains/root/db/olayangroup.html
+olayangroup
+
+// ollo : Dish DBS Corporation
+// https://www.iana.org/domains/root/db/ollo.html
+ollo
+
+// omega : The Swatch Group Ltd
+// https://www.iana.org/domains/root/db/omega.html
+omega
+
+// one : One.com A/S
+// https://www.iana.org/domains/root/db/one.html
+one
+
+// ong : Public Interest Registry
+// https://www.iana.org/domains/root/db/ong.html
+ong
+
+// onl : iRegistry GmbH
+// https://www.iana.org/domains/root/db/onl.html
+onl
+
+// online : Radix Technologies Inc.
+// https://www.iana.org/domains/root/db/online.html
+online
+
+// ooo : INFIBEAM AVENUES LIMITED
+// https://www.iana.org/domains/root/db/ooo.html
+ooo
+
+// open : American Express Travel Related Services Company, Inc.
+// https://www.iana.org/domains/root/db/open.html
+open
+
+// oracle : Oracle Corporation
+// https://www.iana.org/domains/root/db/oracle.html
+oracle
+
+// orange : Orange Brand Services Limited
+// https://www.iana.org/domains/root/db/orange.html
+orange
+
+// organic : Identity Digital Limited
+// https://www.iana.org/domains/root/db/organic.html
+organic
+
+// origins : The Estée Lauder Companies Inc.
+// https://www.iana.org/domains/root/db/origins.html
+origins
+
+// osaka : Osaka Registry Co., Ltd.
+// https://www.iana.org/domains/root/db/osaka.html
+osaka
+
+// otsuka : Otsuka Holdings Co., Ltd.
+// https://www.iana.org/domains/root/db/otsuka.html
+otsuka
+
+// ott : Dish DBS Corporation
+// https://www.iana.org/domains/root/db/ott.html
+ott
+
+// ovh : MédiaBC
+// https://www.iana.org/domains/root/db/ovh.html
+ovh
+
+// page : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/page.html
+page
+
+// panasonic : Panasonic Holdings Corporation
+// https://www.iana.org/domains/root/db/panasonic.html
+panasonic
+
+// paris : City of Paris
+// https://www.iana.org/domains/root/db/paris.html
+paris
+
+// pars : Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
+// https://www.iana.org/domains/root/db/pars.html
+pars
+
+// partners : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/partners.html
+partners
+
+// parts : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/parts.html
+parts
+
+// party : Blue Sky Registry Limited
+// https://www.iana.org/domains/root/db/party.html
+party
+
+// pay : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/pay.html
+pay
+
+// pccw : PCCW Enterprises Limited
+// https://www.iana.org/domains/root/db/pccw.html
+pccw
+
+// pet : Identity Digital Limited
+// https://www.iana.org/domains/root/db/pet.html
+pet
+
+// pfizer : Pfizer Inc.
+// https://www.iana.org/domains/root/db/pfizer.html
+pfizer
+
+// pharmacy : National Association of Boards of Pharmacy
+// https://www.iana.org/domains/root/db/pharmacy.html
+pharmacy
+
+// phd : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/phd.html
+phd
+
+// philips : Koninklijke Philips N.V.
+// https://www.iana.org/domains/root/db/philips.html
+philips
+
+// phone : Dish DBS Corporation
+// https://www.iana.org/domains/root/db/phone.html
+phone
+
+// photo : Registry Services, LLC
+// https://www.iana.org/domains/root/db/photo.html
+photo
+
+// photography : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/photography.html
+photography
+
+// photos : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/photos.html
+photos
+
+// physio : PhysBiz Pty Ltd
+// https://www.iana.org/domains/root/db/physio.html
+physio
+
+// pics : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/pics.html
+pics
+
+// pictet : Pictet Europe S.A.
+// https://www.iana.org/domains/root/db/pictet.html
+pictet
+
+// pictures : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/pictures.html
+pictures
+
+// pid : Top Level Spectrum, Inc.
+// https://www.iana.org/domains/root/db/pid.html
+pid
+
+// pin : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/pin.html
+pin
+
+// ping : Ping Registry Provider, Inc.
+// https://www.iana.org/domains/root/db/ping.html
+ping
+
+// pink : Identity Digital Limited
+// https://www.iana.org/domains/root/db/pink.html
+pink
+
+// pioneer : Pioneer Corporation
+// https://www.iana.org/domains/root/db/pioneer.html
+pioneer
+
+// pizza : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/pizza.html
+pizza
+
+// place : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/place.html
+place
+
+// play : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/play.html
+play
+
+// playstation : Sony Interactive Entertainment Inc.
+// https://www.iana.org/domains/root/db/playstation.html
+playstation
+
+// plumbing : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/plumbing.html
+plumbing
+
+// plus : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/plus.html
+plus
+
+// pnc : PNC Domain Co., LLC
+// https://www.iana.org/domains/root/db/pnc.html
+pnc
+
+// pohl : Deutsche Vermögensberatung Aktiengesellschaft DVAG
+// https://www.iana.org/domains/root/db/pohl.html
+pohl
+
+// poker : Identity Digital Limited
+// https://www.iana.org/domains/root/db/poker.html
+poker
+
+// politie : Politie Nederland
+// https://www.iana.org/domains/root/db/politie.html
+politie
+
+// porn : ICM Registry PN LLC
+// https://www.iana.org/domains/root/db/porn.html
+porn
+
+// pramerica : Prudential Financial, Inc.
+// https://www.iana.org/domains/root/db/pramerica.html
+pramerica
+
+// praxi : Praxi S.p.A.
+// https://www.iana.org/domains/root/db/praxi.html
+praxi
+
+// press : Radix Technologies Inc.
+// https://www.iana.org/domains/root/db/press.html
+press
+
+// prime : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/prime.html
+prime
+
+// prod : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/prod.html
+prod
+
+// productions : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/productions.html
+productions
+
+// prof : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/prof.html
+prof
+
+// progressive : Progressive Casualty Insurance Company
+// https://www.iana.org/domains/root/db/progressive.html
+progressive
+
+// promo : Identity Digital Limited
+// https://www.iana.org/domains/root/db/promo.html
+promo
+
+// properties : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/properties.html
+properties
+
+// property : Digital Property Infrastructure Limited
+// https://www.iana.org/domains/root/db/property.html
+property
+
+// protection : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/protection.html
+protection
+
+// pru : Prudential Financial, Inc.
+// https://www.iana.org/domains/root/db/pru.html
+pru
+
+// prudential : Prudential Financial, Inc.
+// https://www.iana.org/domains/root/db/prudential.html
+prudential
+
+// pub : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/pub.html
+pub
+
+// pwc : PricewaterhouseCoopers LLP
+// https://www.iana.org/domains/root/db/pwc.html
+pwc
+
+// qpon : dotQPON LLC
+// https://www.iana.org/domains/root/db/qpon.html
+qpon
+
+// quebec : PointQuébec Inc
+// https://www.iana.org/domains/root/db/quebec.html
+quebec
+
+// quest : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/quest.html
+quest
+
+// racing : Premier Registry Limited
+// https://www.iana.org/domains/root/db/racing.html
+racing
+
+// radio : European Broadcasting Union (EBU)
+// https://www.iana.org/domains/root/db/radio.html
+radio
+
+// read : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/read.html
+read
+
+// realestate : dotRealEstate LLC
+// https://www.iana.org/domains/root/db/realestate.html
+realestate
+
+// realtor : Real Estate Domains LLC
+// https://www.iana.org/domains/root/db/realtor.html
+realtor
+
+// realty : Internet Naming Company LLC
+// https://www.iana.org/domains/root/db/realty.html
+realty
+
+// recipes : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/recipes.html
+recipes
+
+// red : Identity Digital Limited
+// https://www.iana.org/domains/root/db/red.html
+red
+
+// redstone : Redstone Haute Couture Co., Ltd.
+// https://www.iana.org/domains/root/db/redstone.html
+redstone
+
+// redumbrella : Travelers TLD, LLC
+// https://www.iana.org/domains/root/db/redumbrella.html
+redumbrella
+
+// rehab : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/rehab.html
+rehab
+
+// reise : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/reise.html
+reise
+
+// reisen : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/reisen.html
+reisen
+
+// reit : National Association of Real Estate Investment Trusts, Inc.
+// https://www.iana.org/domains/root/db/reit.html
+reit
+
+// reliance : Reliance Industries Limited
+// https://www.iana.org/domains/root/db/reliance.html
+reliance
+
+// ren : ZDNS International Limited
+// https://www.iana.org/domains/root/db/ren.html
+ren
+
+// rent : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/rent.html
+rent
+
+// rentals : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/rentals.html
+rentals
+
+// repair : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/repair.html
+repair
+
+// report : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/report.html
+report
+
+// republican : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/republican.html
+republican
+
+// rest : Punto 2012 Sociedad Anonima Promotora de Inversion de Capital Variable
+// https://www.iana.org/domains/root/db/rest.html
+rest
+
+// restaurant : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/restaurant.html
+restaurant
+
+// review : dot Review Limited
+// https://www.iana.org/domains/root/db/review.html
+review
+
+// reviews : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/reviews.html
+reviews
+
+// rexroth : Robert Bosch GMBH
+// https://www.iana.org/domains/root/db/rexroth.html
+rexroth
+
+// rich : iRegistry GmbH
+// https://www.iana.org/domains/root/db/rich.html
+rich
+
+// richardli : Pacific Century Asset Management (HK) Limited
+// https://www.iana.org/domains/root/db/richardli.html
+richardli
+
+// ricoh : Ricoh Company, Ltd.
+// https://www.iana.org/domains/root/db/ricoh.html
+ricoh
+
+// ril : Reliance Industries Limited
+// https://www.iana.org/domains/root/db/ril.html
+ril
+
+// rio : Empresa Municipal de Informática SA - IPLANRIO
+// https://www.iana.org/domains/root/db/rio.html
+rio
+
+// rip : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/rip.html
+rip
+
+// rocks : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/rocks.html
+rocks
+
+// rodeo : Registry Services, LLC
+// https://www.iana.org/domains/root/db/rodeo.html
+rodeo
+
+// rogers : Rogers Communications Canada Inc.
+// https://www.iana.org/domains/root/db/rogers.html
+rogers
+
+// room : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/room.html
+room
+
+// rsvp : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/rsvp.html
+rsvp
+
+// rugby : World Rugby Strategic Developments Limited
+// https://www.iana.org/domains/root/db/rugby.html
+rugby
+
+// ruhr : dotSaarland GmbH
+// https://www.iana.org/domains/root/db/ruhr.html
+ruhr
+
+// run : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/run.html
+run
+
+// rwe : RWE AG
+// https://www.iana.org/domains/root/db/rwe.html
+rwe
+
+// ryukyu : BRregistry, Inc.
+// https://www.iana.org/domains/root/db/ryukyu.html
+ryukyu
+
+// saarland : dotSaarland GmbH
+// https://www.iana.org/domains/root/db/saarland.html
+saarland
+
+// safe : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/safe.html
+safe
+
+// safety : Safety Registry Services, LLC.
+// https://www.iana.org/domains/root/db/safety.html
+safety
+
+// sakura : SAKURA Internet Inc.
+// https://www.iana.org/domains/root/db/sakura.html
+sakura
+
+// sale : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/sale.html
+sale
+
+// salon : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/salon.html
+salon
+
+// samsclub : Wal-Mart Stores, Inc.
+// https://www.iana.org/domains/root/db/samsclub.html
+samsclub
+
+// samsung : SAMSUNG SDS CO., LTD
+// https://www.iana.org/domains/root/db/samsung.html
+samsung
+
+// sandvik : Sandvik AB
+// https://www.iana.org/domains/root/db/sandvik.html
+sandvik
+
+// sandvikcoromant : Sandvik AB
+// https://www.iana.org/domains/root/db/sandvikcoromant.html
+sandvikcoromant
+
+// sanofi : Sanofi
+// https://www.iana.org/domains/root/db/sanofi.html
+sanofi
+
+// sap : SAP AG
+// https://www.iana.org/domains/root/db/sap.html
+sap
+
+// sarl : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/sarl.html
+sarl
+
+// sas : Research IP LLC
+// https://www.iana.org/domains/root/db/sas.html
+sas
+
+// save : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/save.html
+save
+
+// saxo : Saxo Bank A/S
+// https://www.iana.org/domains/root/db/saxo.html
+saxo
+
+// sbi : STATE BANK OF INDIA
+// https://www.iana.org/domains/root/db/sbi.html
+sbi
+
+// sbs : ShortDot SA
+// https://www.iana.org/domains/root/db/sbs.html
+sbs
+
+// scb : The Siam Commercial Bank Public Company Limited ("SCB")
+// https://www.iana.org/domains/root/db/scb.html
+scb
+
+// schaeffler : Schaeffler Technologies AG & Co. KG
+// https://www.iana.org/domains/root/db/schaeffler.html
+schaeffler
+
+// schmidt : SCHMIDT GROUPE S.A.S.
+// https://www.iana.org/domains/root/db/schmidt.html
+schmidt
+
+// scholarships : Scholarships.com, LLC
+// https://www.iana.org/domains/root/db/scholarships.html
+scholarships
+
+// school : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/school.html
+school
+
+// schule : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/schule.html
+schule
+
+// schwarz : Schwarz Domains und Services GmbH & Co. KG
+// https://www.iana.org/domains/root/db/schwarz.html
+schwarz
+
+// science : dot Science Limited
+// https://www.iana.org/domains/root/db/science.html
+science
+
+// scot : Dot Scot Registry Limited
+// https://www.iana.org/domains/root/db/scot.html
+scot
+
+// search : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/search.html
+search
+
+// seat : SEAT, S.A. (Sociedad Unipersonal)
+// https://www.iana.org/domains/root/db/seat.html
+seat
+
+// secure : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/secure.html
+secure
+
+// security : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/security.html
+security
+
+// seek : Seek Limited
+// https://www.iana.org/domains/root/db/seek.html
+seek
+
+// select : Registry Services, LLC
+// https://www.iana.org/domains/root/db/select.html
+select
+
+// sener : Sener Ingeniería y Sistemas, S.A.
+// https://www.iana.org/domains/root/db/sener.html
+sener
+
+// services : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/services.html
+services
+
+// seven : Seven West Media Ltd
+// https://www.iana.org/domains/root/db/seven.html
+seven
+
+// sew : SEW-EURODRIVE GmbH & Co KG
+// https://www.iana.org/domains/root/db/sew.html
+sew
+
+// sex : ICM Registry SX LLC
+// https://www.iana.org/domains/root/db/sex.html
+sex
+
+// sexy : Internet Naming Company LLC
+// https://www.iana.org/domains/root/db/sexy.html
+sexy
+
+// sfr : Societe Francaise du Radiotelephone - SFR
+// https://www.iana.org/domains/root/db/sfr.html
+sfr
+
+// shangrila : Shangri‐La International Hotel Management Limited
+// https://www.iana.org/domains/root/db/shangrila.html
+shangrila
+
+// sharp : Sharp Corporation
+// https://www.iana.org/domains/root/db/sharp.html
+sharp
+
+// shell : Shell Information Technology International Inc
+// https://www.iana.org/domains/root/db/shell.html
+shell
+
+// shia : Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
+// https://www.iana.org/domains/root/db/shia.html
+shia
+
+// shiksha : Identity Digital Limited
+// https://www.iana.org/domains/root/db/shiksha.html
+shiksha
+
+// shoes : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/shoes.html
+shoes
+
+// shop : GMO Registry, Inc.
+// https://www.iana.org/domains/root/db/shop.html
+shop
+
+// shopping : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/shopping.html
+shopping
+
+// shouji : Beijing Qihu Keji Co., Ltd.
+// https://www.iana.org/domains/root/db/shouji.html
+shouji
+
+// show : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/show.html
+show
+
+// silk : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/silk.html
+silk
+
+// sina : Sina Corporation
+// https://www.iana.org/domains/root/db/sina.html
+sina
+
+// singles : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/singles.html
+singles
+
+// site : Radix Technologies Inc.
+// https://www.iana.org/domains/root/db/site.html
+site
+
+// ski : Identity Digital Limited
+// https://www.iana.org/domains/root/db/ski.html
+ski
+
+// skin : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/skin.html
+skin
+
+// sky : Sky International AG
+// https://www.iana.org/domains/root/db/sky.html
+sky
+
+// skype : Microsoft Corporation
+// https://www.iana.org/domains/root/db/skype.html
+skype
+
+// sling : DISH Technologies L.L.C.
+// https://www.iana.org/domains/root/db/sling.html
+sling
+
+// smart : Smart Communications, Inc. (SMART)
+// https://www.iana.org/domains/root/db/smart.html
+smart
+
+// smile : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/smile.html
+smile
+
+// sncf : Société Nationale SNCF
+// https://www.iana.org/domains/root/db/sncf.html
+sncf
+
+// soccer : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/soccer.html
+soccer
+
+// social : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/social.html
+social
+
+// softbank : SoftBank Group Corp.
+// https://www.iana.org/domains/root/db/softbank.html
+softbank
+
+// software : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/software.html
+software
+
+// sohu : Sohu.com Limited
+// https://www.iana.org/domains/root/db/sohu.html
+sohu
+
+// solar : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/solar.html
+solar
+
+// solutions : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/solutions.html
+solutions
+
+// song : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/song.html
+song
+
+// sony : Sony Corporation
+// https://www.iana.org/domains/root/db/sony.html
+sony
+
+// soy : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/soy.html
+soy
+
+// spa : Asia Spa and Wellness Promotion Council Limited
+// https://www.iana.org/domains/root/db/spa.html
+spa
+
+// space : Radix Technologies Inc.
+// https://www.iana.org/domains/root/db/space.html
+space
+
+// sport : SportAccord
+// https://www.iana.org/domains/root/db/sport.html
+sport
+
+// spot : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/spot.html
+spot
+
+// srl : InterNetX, Corp
+// https://www.iana.org/domains/root/db/srl.html
+srl
+
+// stada : STADA Arzneimittel AG
+// https://www.iana.org/domains/root/db/stada.html
+stada
+
+// staples : Staples, Inc.
+// https://www.iana.org/domains/root/db/staples.html
+staples
+
+// star : Star India Private Limited
+// https://www.iana.org/domains/root/db/star.html
+star
+
+// statebank : STATE BANK OF INDIA
+// https://www.iana.org/domains/root/db/statebank.html
+statebank
+
+// statefarm : State Farm Mutual Automobile Insurance Company
+// https://www.iana.org/domains/root/db/statefarm.html
+statefarm
+
+// stc : Saudi Telecom Company
+// https://www.iana.org/domains/root/db/stc.html
+stc
+
+// stcgroup : Saudi Telecom Company
+// https://www.iana.org/domains/root/db/stcgroup.html
+stcgroup
+
+// stockholm : Stockholms kommun
+// https://www.iana.org/domains/root/db/stockholm.html
+stockholm
+
+// storage : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/storage.html
+storage
+
+// store : Radix Technologies Inc.
+// https://www.iana.org/domains/root/db/store.html
+store
+
+// stream : dot Stream Limited
+// https://www.iana.org/domains/root/db/stream.html
+stream
+
+// studio : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/studio.html
+studio
+
+// study : Registry Services, LLC
+// https://www.iana.org/domains/root/db/study.html
+study
+
+// style : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/style.html
+style
+
+// sucks : Vox Populi Registry Ltd.
+// https://www.iana.org/domains/root/db/sucks.html
+sucks
+
+// supplies : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/supplies.html
+supplies
+
+// supply : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/supply.html
+supply
+
+// support : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/support.html
+support
+
+// surf : Registry Services, LLC
+// https://www.iana.org/domains/root/db/surf.html
+surf
+
+// surgery : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/surgery.html
+surgery
+
+// suzuki : SUZUKI MOTOR CORPORATION
+// https://www.iana.org/domains/root/db/suzuki.html
+suzuki
+
+// swatch : The Swatch Group Ltd
+// https://www.iana.org/domains/root/db/swatch.html
+swatch
+
+// swiss : Swiss Confederation
+// https://www.iana.org/domains/root/db/swiss.html
+swiss
+
+// sydney : State of New South Wales, Department of Premier and Cabinet
+// https://www.iana.org/domains/root/db/sydney.html
+sydney
+
+// systems : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/systems.html
+systems
+
+// tab : Tabcorp Holdings Limited
+// https://www.iana.org/domains/root/db/tab.html
+tab
+
+// taipei : Taipei City Government
+// https://www.iana.org/domains/root/db/taipei.html
+taipei
+
+// talk : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/talk.html
+talk
+
+// taobao : Alibaba Group Holding Limited
+// https://www.iana.org/domains/root/db/taobao.html
+taobao
+
+// target : Target Domain Holdings, LLC
+// https://www.iana.org/domains/root/db/target.html
+target
+
+// tatamotors : Tata Motors Ltd
+// https://www.iana.org/domains/root/db/tatamotors.html
+tatamotors
+
+// tatar : Limited Liability Company "Coordination Center of Regional Domain of Tatarstan Republic"
+// https://www.iana.org/domains/root/db/tatar.html
+tatar
+
+// tattoo : Registry Services, LLC
+// https://www.iana.org/domains/root/db/tattoo.html
+tattoo
+
+// tax : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/tax.html
+tax
+
+// taxi : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/taxi.html
+taxi
+
+// tci : Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
+// https://www.iana.org/domains/root/db/tci.html
+tci
+
+// tdk : TDK Corporation
+// https://www.iana.org/domains/root/db/tdk.html
+tdk
+
+// team : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/team.html
+team
+
+// tech : Radix Technologies Inc.
+// https://www.iana.org/domains/root/db/tech.html
+tech
+
+// technology : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/technology.html
+technology
+
+// temasek : Temasek Holdings (Private) Limited
+// https://www.iana.org/domains/root/db/temasek.html
+temasek
+
+// tennis : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/tennis.html
+tennis
+
+// teva : Teva Pharmaceutical Industries Limited
+// https://www.iana.org/domains/root/db/teva.html
+teva
+
+// thd : Home Depot Product Authority, LLC
+// https://www.iana.org/domains/root/db/thd.html
+thd
+
+// theater : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/theater.html
+theater
+
+// theatre : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/theatre.html
+theatre
+
+// tiaa : Teachers Insurance and Annuity Association of America
+// https://www.iana.org/domains/root/db/tiaa.html
+tiaa
+
+// tickets : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/tickets.html
+tickets
+
+// tienda : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/tienda.html
+tienda
+
+// tips : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/tips.html
+tips
+
+// tires : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/tires.html
+tires
+
+// tirol : punkt Tirol GmbH
+// https://www.iana.org/domains/root/db/tirol.html
+tirol
+
+// tjmaxx : The TJX Companies, Inc.
+// https://www.iana.org/domains/root/db/tjmaxx.html
+tjmaxx
+
+// tjx : The TJX Companies, Inc.
+// https://www.iana.org/domains/root/db/tjx.html
+tjx
+
+// tkmaxx : The TJX Companies, Inc.
+// https://www.iana.org/domains/root/db/tkmaxx.html
+tkmaxx
+
+// tmall : Alibaba Group Holding Limited
+// https://www.iana.org/domains/root/db/tmall.html
+tmall
+
+// today : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/today.html
+today
+
+// tokyo : GMO Registry, Inc.
+// https://www.iana.org/domains/root/db/tokyo.html
+tokyo
+
+// tools : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/tools.html
+tools
+
+// top : .TOP Registry
+// https://www.iana.org/domains/root/db/top.html
+top
+
+// toray : Toray Industries, Inc.
+// https://www.iana.org/domains/root/db/toray.html
+toray
+
+// toshiba : TOSHIBA Corporation
+// https://www.iana.org/domains/root/db/toshiba.html
+toshiba
+
+// total : TotalEnergies SE
+// https://www.iana.org/domains/root/db/total.html
+total
+
+// tours : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/tours.html
+tours
+
+// town : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/town.html
+town
+
+// toyota : TOYOTA MOTOR CORPORATION
+// https://www.iana.org/domains/root/db/toyota.html
+toyota
+
+// toys : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/toys.html
+toys
+
+// trade : Elite Registry Limited
+// https://www.iana.org/domains/root/db/trade.html
+trade
+
+// trading : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/trading.html
+trading
+
+// training : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/training.html
+training
+
+// travel : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/travel.html
+travel
+
+// travelers : Travelers TLD, LLC
+// https://www.iana.org/domains/root/db/travelers.html
+travelers
+
+// travelersinsurance : Travelers TLD, LLC
+// https://www.iana.org/domains/root/db/travelersinsurance.html
+travelersinsurance
+
+// trust : Internet Naming Company LLC
+// https://www.iana.org/domains/root/db/trust.html
+trust
+
+// trv : Travelers TLD, LLC
+// https://www.iana.org/domains/root/db/trv.html
+trv
+
+// tube : Latin American Telecom LLC
+// https://www.iana.org/domains/root/db/tube.html
+tube
+
+// tui : TUI AG
+// https://www.iana.org/domains/root/db/tui.html
+tui
+
+// tunes : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/tunes.html
+tunes
+
+// tushu : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/tushu.html
+tushu
+
+// tvs : T V SUNDRAM IYENGAR  & SONS LIMITED
+// https://www.iana.org/domains/root/db/tvs.html
+tvs
+
+// ubank : National Australia Bank Limited
+// https://www.iana.org/domains/root/db/ubank.html
+ubank
+
+// ubs : UBS AG
+// https://www.iana.org/domains/root/db/ubs.html
+ubs
+
+// unicom : China United Network Communications Corporation Limited
+// https://www.iana.org/domains/root/db/unicom.html
+unicom
+
+// university : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/university.html
+university
+
+// uno : Radix Technologies Inc.
+// https://www.iana.org/domains/root/db/uno.html
+uno
+
+// uol : UBN INTERNET LTDA.
+// https://www.iana.org/domains/root/db/uol.html
+uol
+
+// ups : UPS Market Driver, Inc.
+// https://www.iana.org/domains/root/db/ups.html
+ups
+
+// vacations : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/vacations.html
+vacations
+
+// vana : D3 Registry LLC
+// https://www.iana.org/domains/root/db/vana.html
+vana
+
+// vanguard : The Vanguard Group, Inc.
+// https://www.iana.org/domains/root/db/vanguard.html
+vanguard
+
+// vegas : Dot Vegas, Inc.
+// https://www.iana.org/domains/root/db/vegas.html
+vegas
+
+// ventures : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/ventures.html
+ventures
+
+// verisign : VeriSign, Inc.
+// https://www.iana.org/domains/root/db/verisign.html
+verisign
+
+// versicherung : tldbox GmbH
+// https://www.iana.org/domains/root/db/versicherung.html
+versicherung
+
+// vet : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/vet.html
+vet
+
+// viajes : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/viajes.html
+viajes
+
+// video : Dog Beach, LLC
+// https://www.iana.org/domains/root/db/video.html
+video
+
+// vig : VIENNA INSURANCE GROUP AG Wiener Versicherung Gruppe
+// https://www.iana.org/domains/root/db/vig.html
+vig
+
+// viking : Viking River Cruises (Bermuda) Ltd.
+// https://www.iana.org/domains/root/db/viking.html
+viking
+
+// villas : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/villas.html
+villas
+
+// vin : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/vin.html
+vin
+
+// vip : Registry Services, LLC
+// https://www.iana.org/domains/root/db/vip.html
+vip
+
+// virgin : Virgin Enterprises Limited
+// https://www.iana.org/domains/root/db/virgin.html
+virgin
+
+// visa : Visa Worldwide Pte. Limited
+// https://www.iana.org/domains/root/db/visa.html
+visa
+
+// vision : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/vision.html
+vision
+
+// viva : Saudi Telecom Company
+// https://www.iana.org/domains/root/db/viva.html
+viva
+
+// vivo : Telefonica Brasil S.A.
+// https://www.iana.org/domains/root/db/vivo.html
+vivo
+
+// vlaanderen : DNS.be vzw
+// https://www.iana.org/domains/root/db/vlaanderen.html
+vlaanderen
+
+// vodka : Registry Services, LLC
+// https://www.iana.org/domains/root/db/vodka.html
+vodka
+
+// volvo : Volvo Holding Sverige Aktiebolag
+// https://www.iana.org/domains/root/db/volvo.html
+volvo
+
+// vote : Monolith Registry LLC
+// https://www.iana.org/domains/root/db/vote.html
+vote
+
+// voting : Valuetainment Corp.
+// https://www.iana.org/domains/root/db/voting.html
+voting
+
+// voto : Monolith Registry LLC
+// https://www.iana.org/domains/root/db/voto.html
+voto
+
+// voyage : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/voyage.html
+voyage
+
+// wales : Nominet UK
+// https://www.iana.org/domains/root/db/wales.html
+wales
+
+// walmart : Wal-Mart Stores, Inc.
+// https://www.iana.org/domains/root/db/walmart.html
+walmart
+
+// walter : Sandvik AB
+// https://www.iana.org/domains/root/db/walter.html
+walter
+
+// wang : Zodiac Wang Limited
+// https://www.iana.org/domains/root/db/wang.html
+wang
+
+// wanggou : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/wanggou.html
+wanggou
+
+// watch : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/watch.html
+watch
+
+// watches : Identity Digital Limited
+// https://www.iana.org/domains/root/db/watches.html
+watches
+
+// weather : International Business Machines Corporation
+// https://www.iana.org/domains/root/db/weather.html
+weather
+
+// weatherchannel : International Business Machines Corporation
+// https://www.iana.org/domains/root/db/weatherchannel.html
+weatherchannel
+
+// webcam : dot Webcam Limited
+// https://www.iana.org/domains/root/db/webcam.html
+webcam
+
+// weber : Saint-Gobain Weber SA
+// https://www.iana.org/domains/root/db/weber.html
+weber
+
+// website : Radix Technologies Inc.
+// https://www.iana.org/domains/root/db/website.html
+website
+
+// wed
+// https://www.iana.org/domains/root/db/wed.html
+wed
+
+// wedding : Registry Services, LLC
+// https://www.iana.org/domains/root/db/wedding.html
+wedding
+
+// weibo : Sina Corporation
+// https://www.iana.org/domains/root/db/weibo.html
+weibo
+
+// weir : Weir Group IP Limited
+// https://www.iana.org/domains/root/db/weir.html
+weir
+
+// whoswho : Who's Who Registry
+// https://www.iana.org/domains/root/db/whoswho.html
+whoswho
+
+// wien : punkt.wien GmbH
+// https://www.iana.org/domains/root/db/wien.html
+wien
+
+// wiki : Registry Services, LLC
+// https://www.iana.org/domains/root/db/wiki.html
+wiki
+
+// williamhill : William Hill Organization Limited
+// https://www.iana.org/domains/root/db/williamhill.html
+williamhill
+
+// win : First Registry Limited
+// https://www.iana.org/domains/root/db/win.html
+win
+
+// windows : Microsoft Corporation
+// https://www.iana.org/domains/root/db/windows.html
+windows
+
+// wine : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/wine.html
+wine
+
+// winners : The TJX Companies, Inc.
+// https://www.iana.org/domains/root/db/winners.html
+winners
+
+// wme : William Morris Endeavor Entertainment, LLC
+// https://www.iana.org/domains/root/db/wme.html
+wme
+
+// wolterskluwer : Wolters Kluwer N.V.
+// https://www.iana.org/domains/root/db/wolterskluwer.html
+wolterskluwer
+
+// woodside : Woodside Petroleum Limited
+// https://www.iana.org/domains/root/db/woodside.html
+woodside
+
+// work : Registry Services, LLC
+// https://www.iana.org/domains/root/db/work.html
+work
+
+// works : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/works.html
+works
+
+// world : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/world.html
+world
+
+// wow : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/wow.html
+wow
+
+// wtc : World Trade Centers Association, Inc.
+// https://www.iana.org/domains/root/db/wtc.html
+wtc
+
+// wtf : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/wtf.html
+wtf
+
+// xbox : Microsoft Corporation
+// https://www.iana.org/domains/root/db/xbox.html
+xbox
+
+// xerox : Xerox DNHC LLC
+// https://www.iana.org/domains/root/db/xerox.html
+xerox
+
+// xihuan : Beijing Qihu Keji Co., Ltd.
+// https://www.iana.org/domains/root/db/xihuan.html
+xihuan
+
+// xin : Elegant Leader Limited
+// https://www.iana.org/domains/root/db/xin.html
+xin
+
+// xn--11b4c3d : VeriSign Sarl
+// https://www.iana.org/domains/root/db/xn--11b4c3d.html
+कॉम
+
+// xn--1ck2e1b : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/xn--1ck2e1b.html
+セール
+
+// xn--1qqw23a : Guangzhou YU Wei Information Technology Co., Ltd.
+// https://www.iana.org/domains/root/db/xn--1qqw23a.html
+佛山
+
+// xn--30rr7y : Excellent First Limited
+// https://www.iana.org/domains/root/db/xn--30rr7y.html
+慈善
+
+// xn--3bst00m : Eagle Horizon Limited
+// https://www.iana.org/domains/root/db/xn--3bst00m.html
+集团
+
+// xn--3ds443g : TLD REGISTRY LIMITED OY
+// https://www.iana.org/domains/root/db/xn--3ds443g.html
+在线
+
+// xn--3pxu8k : VeriSign Sarl
+// https://www.iana.org/domains/root/db/xn--3pxu8k.html
+点看
+
+// xn--42c2d9a : VeriSign Sarl
+// https://www.iana.org/domains/root/db/xn--42c2d9a.html
+คอม
+
+// xn--45q11c : Zodiac Gemini Ltd
+// https://www.iana.org/domains/root/db/xn--45q11c.html
+八卦
+
+// xn--4gbrim : Helium TLDs Ltd
+// https://www.iana.org/domains/root/db/xn--4gbrim.html
+موقع
+
+// xn--55qw42g : China Organizational Name Administration Center
+// https://www.iana.org/domains/root/db/xn--55qw42g.html
+公益
+
+// xn--55qx5d : China Internet Network Information Center (CNNIC)
+// https://www.iana.org/domains/root/db/xn--55qx5d.html
+公司
+
+// xn--5su34j936bgsg : Shangri‐La International Hotel Management Limited
+// https://www.iana.org/domains/root/db/xn--5su34j936bgsg.html
+香格里拉
+
+// xn--5tzm5g : Global Website TLD Asia Limited
+// https://www.iana.org/domains/root/db/xn--5tzm5g.html
+网站
+
+// xn--6frz82g : Identity Digital Limited
+// https://www.iana.org/domains/root/db/xn--6frz82g.html
+移动
+
+// xn--6qq986b3xl : Tycoon Treasure Limited
+// https://www.iana.org/domains/root/db/xn--6qq986b3xl.html
+我爱你
+
+// xn--80adxhks : Foundation for Assistance for Internet Technologies and Infrastructure Development (FAITID)
+// https://www.iana.org/domains/root/db/xn--80adxhks.html
+москва
+
+// xn--80aqecdr1a : Pontificium Consilium de Comunicationibus Socialibus (PCCS) (Pontifical Council for Social Communication)
+// https://www.iana.org/domains/root/db/xn--80aqecdr1a.html
+католик
+
+// xn--80asehdb : CORE Association
+// https://www.iana.org/domains/root/db/xn--80asehdb.html
+онлайн
+
+// xn--80aswg : CORE Association
+// https://www.iana.org/domains/root/db/xn--80aswg.html
+сайт
+
+// xn--8y0a063a : China United Network Communications Corporation Limited
+// https://www.iana.org/domains/root/db/xn--8y0a063a.html
+联通
+
+// xn--9dbq2a : VeriSign Sarl
+// https://www.iana.org/domains/root/db/xn--9dbq2a.html
+קום
+
+// xn--9et52u : RISE VICTORY LIMITED
+// https://www.iana.org/domains/root/db/xn--9et52u.html
+时尚
+
+// xn--9krt00a : Sina Corporation
+// https://www.iana.org/domains/root/db/xn--9krt00a.html
+微博
+
+// xn--b4w605ferd : Temasek Holdings (Private) Limited
+// https://www.iana.org/domains/root/db/xn--b4w605ferd.html
+淡马锡
+
+// xn--bck1b9a5dre4c : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/xn--bck1b9a5dre4c.html
+ファッション
+
+// xn--c1avg : Public Interest Registry
+// https://www.iana.org/domains/root/db/xn--c1avg.html
+орг
+
+// xn--c2br7g : VeriSign Sarl
+// https://www.iana.org/domains/root/db/xn--c2br7g.html
+नेट
+
+// xn--cck2b3b : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/xn--cck2b3b.html
+ストア
+
+// xn--cckwcxetd : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/xn--cckwcxetd.html
+アマゾン
+
+// xn--cg4bki : SAMSUNG SDS CO., LTD
+// https://www.iana.org/domains/root/db/xn--cg4bki.html
+삼성
+
+// xn--czr694b : Internet DotTrademark Organisation Limited
+// https://www.iana.org/domains/root/db/xn--czr694b.html
+商标
+
+// xn--czrs0t : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/xn--czrs0t.html
+商店
+
+// xn--czru2d : Zodiac Aquarius Limited
+// https://www.iana.org/domains/root/db/xn--czru2d.html
+商城
+
+// xn--d1acj3b : The Foundation for Network Initiatives “The Smart Internet”
+// https://www.iana.org/domains/root/db/xn--d1acj3b.html
+дети
+
+// xn--eckvdtc9d : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/xn--eckvdtc9d.html
+ポイント
+
+// xn--efvy88h : Guangzhou YU Wei Information Technology Co., Ltd.
+// https://www.iana.org/domains/root/db/xn--efvy88h.html
+新闻
+
+// xn--fct429k : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/xn--fct429k.html
+家電
+
+// xn--fhbei : VeriSign Sarl
+// https://www.iana.org/domains/root/db/xn--fhbei.html
+كوم
+
+// xn--fiq228c5hs : TLD REGISTRY LIMITED OY
+// https://www.iana.org/domains/root/db/xn--fiq228c5hs.html
+中文网
+
+// xn--fiq64b : CITIC Group Corporation
+// https://www.iana.org/domains/root/db/xn--fiq64b.html
+中信
+
+// xn--fjq720a : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/xn--fjq720a.html
+娱乐
+
+// xn--flw351e : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/xn--flw351e.html
+谷歌
+
+// xn--fzys8d69uvgm : PCCW Enterprises Limited
+// https://www.iana.org/domains/root/db/xn--fzys8d69uvgm.html
+電訊盈科
+
+// xn--g2xx48c : Nawang Heli(Xiamen) Network Service Co., LTD.
+// https://www.iana.org/domains/root/db/xn--g2xx48c.html
+购物
+
+// xn--gckr3f0f : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/xn--gckr3f0f.html
+クラウド
+
+// xn--gk3at1e : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/xn--gk3at1e.html
+通販
+
+// xn--hxt814e : Zodiac Taurus Limited
+// https://www.iana.org/domains/root/db/xn--hxt814e.html
+网店
+
+// xn--i1b6b1a6a2e : Public Interest Registry
+// https://www.iana.org/domains/root/db/xn--i1b6b1a6a2e.html
+संगठन
+
+// xn--imr513n : Internet DotTrademark Organisation Limited
+// https://www.iana.org/domains/root/db/xn--imr513n.html
+餐厅
+
+// xn--io0a7i : China Internet Network Information Center (CNNIC)
+// https://www.iana.org/domains/root/db/xn--io0a7i.html
+网络
+
+// xn--j1aef : VeriSign Sarl
+// https://www.iana.org/domains/root/db/xn--j1aef.html
+ком
+
+// xn--jlq480n2rg : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/xn--jlq480n2rg.html
+亚马逊
+
+// xn--jvr189m : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/xn--jvr189m.html
+食品
+
+// xn--kcrx77d1x4a : Koninklijke Philips N.V.
+// https://www.iana.org/domains/root/db/xn--kcrx77d1x4a.html
+飞利浦
+
+// xn--kput3i : Beijing RITT-Net Technology Development Co., Ltd
+// https://www.iana.org/domains/root/db/xn--kput3i.html
+手机
+
+// xn--mgba3a3ejt : Aramco Services Company
+// https://www.iana.org/domains/root/db/xn--mgba3a3ejt.html
+ارامكو
+
+// xn--mgba7c0bbn0a : Competrol (Luxembourg) Sarl
+// https://www.iana.org/domains/root/db/xn--mgba7c0bbn0a.html
+العليان
+
+// xn--mgbab2bd : CORE Association
+// https://www.iana.org/domains/root/db/xn--mgbab2bd.html
+بازار
+
+// xn--mgbca7dzdo : Abu Dhabi Systems and Information Centre
+// https://www.iana.org/domains/root/db/xn--mgbca7dzdo.html
+ابوظبي
+
+// xn--mgbi4ecexp : Pontificium Consilium de Comunicationibus Socialibus (PCCS) (Pontifical Council for Social Communication)
+// https://www.iana.org/domains/root/db/xn--mgbi4ecexp.html
+كاثوليك
+
+// xn--mgbt3dhd : Asia Green IT System Bilgisayar San. ve Tic. Ltd. Sti.
+// https://www.iana.org/domains/root/db/xn--mgbt3dhd.html
+همراه
+
+// xn--mk1bu44c : VeriSign Sarl
+// https://www.iana.org/domains/root/db/xn--mk1bu44c.html
+닷컴
+
+// xn--mxtq1m : Net-Chinese Co., Ltd.
+// https://www.iana.org/domains/root/db/xn--mxtq1m.html
+政府
+
+// xn--ngbc5azd : International Domain Registry Pty. Ltd.
+// https://www.iana.org/domains/root/db/xn--ngbc5azd.html
+شبكة
+
+// xn--ngbe9e0a : Kuwait Finance House
+// https://www.iana.org/domains/root/db/xn--ngbe9e0a.html
+بيتك
+
+// xn--ngbrx : League of Arab States
+// https://www.iana.org/domains/root/db/xn--ngbrx.html
+عرب
+
+// xn--nqv7f : Public Interest Registry
+// https://www.iana.org/domains/root/db/xn--nqv7f.html
+机构
+
+// xn--nqv7fs00ema : Public Interest Registry
+// https://www.iana.org/domains/root/db/xn--nqv7fs00ema.html
+组织机构
+
+// xn--nyqy26a : Stable Tone Limited
+// https://www.iana.org/domains/root/db/xn--nyqy26a.html
+健康
+
+// xn--otu796d : Jiang Yu Liang Cai Technology Company Limited
+// https://www.iana.org/domains/root/db/xn--otu796d.html
+招聘
+
+// xn--p1acf : Rusnames Limited
+// https://www.iana.org/domains/root/db/xn--p1acf.html
+рус
+
+// xn--pssy2u : VeriSign Sarl
+// https://www.iana.org/domains/root/db/xn--pssy2u.html
+大拿
+
+// xn--q9jyb4c : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/xn--q9jyb4c.html
+みんな
+
+// xn--qcka1pmc : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/xn--qcka1pmc.html
+グーグル
+
+// xn--rhqv96g : Stable Tone Limited
+// https://www.iana.org/domains/root/db/xn--rhqv96g.html
+世界
+
+// xn--rovu88b : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/xn--rovu88b.html
+書籍
+
+// xn--ses554g : KNET Co., Ltd.
+// https://www.iana.org/domains/root/db/xn--ses554g.html
+网址
+
+// xn--t60b56a : VeriSign Sarl
+// https://www.iana.org/domains/root/db/xn--t60b56a.html
+닷넷
+
+// xn--tckwe : VeriSign Sarl
+// https://www.iana.org/domains/root/db/xn--tckwe.html
+コム
+
+// xn--tiq49xqyj : Pontificium Consilium de Comunicationibus Socialibus (PCCS) (Pontifical Council for Social Communication)
+// https://www.iana.org/domains/root/db/xn--tiq49xqyj.html
+天主教
+
+// xn--unup4y : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/xn--unup4y.html
+游戏
+
+// xn--vermgensberater-ctb : Deutsche Vermögensberatung Aktiengesellschaft DVAG
+// https://www.iana.org/domains/root/db/xn--vermgensberater-ctb.html
+vermögensberater
+
+// xn--vermgensberatung-pwb : Deutsche Vermögensberatung Aktiengesellschaft DVAG
+// https://www.iana.org/domains/root/db/xn--vermgensberatung-pwb.html
+vermögensberatung
+
+// xn--vhquv : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/xn--vhquv.html
+企业
+
+// xn--vuq861b : Beijing Tele-info Technology Co., Ltd.
+// https://www.iana.org/domains/root/db/xn--vuq861b.html
+信息
+
+// xn--w4r85el8fhu5dnra : Kerry Trading Co. Limited
+// https://www.iana.org/domains/root/db/xn--w4r85el8fhu5dnra.html
+嘉里大酒店
+
+// xn--w4rs40l : Kerry Trading Co. Limited
+// https://www.iana.org/domains/root/db/xn--w4rs40l.html
+嘉里
+
+// xn--xhq521b : Guangzhou YU Wei Information Technology Co., Ltd.
+// https://www.iana.org/domains/root/db/xn--xhq521b.html
+广东
+
+// xn--zfr164b : China Organizational Name Administration Center
+// https://www.iana.org/domains/root/db/xn--zfr164b.html
+政务
+
+// xyz : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/xyz.html
+xyz
+
+// yachts : XYZ.COM LLC
+// https://www.iana.org/domains/root/db/yachts.html
+yachts
+
+// yahoo : Yahoo Inc.
+// https://www.iana.org/domains/root/db/yahoo.html
+yahoo
+
+// yamaxun : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/yamaxun.html
+yamaxun
+
+// yandex : Yandex Europe B.V.
+// https://www.iana.org/domains/root/db/yandex.html
+yandex
+
+// yodobashi : YODOBASHI CAMERA CO.,LTD.
+// https://www.iana.org/domains/root/db/yodobashi.html
+yodobashi
+
+// yoga : Registry Services, LLC
+// https://www.iana.org/domains/root/db/yoga.html
+yoga
+
+// yokohama : GMO Registry, Inc.
+// https://www.iana.org/domains/root/db/yokohama.html
+yokohama
+
+// you : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/you.html
+you
+
+// youtube : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/youtube.html
+youtube
+
+// yun : Beijing Qihu Keji Co., Ltd.
+// https://www.iana.org/domains/root/db/yun.html
+yun
+
+// zappos : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/zappos.html
+zappos
+
+// zara : Industria de Diseño Textil, S.A. (INDITEX, S.A.)
+// https://www.iana.org/domains/root/db/zara.html
+zara
+
+// zero : Amazon Registry Services, Inc.
+// https://www.iana.org/domains/root/db/zero.html
+zero
+
+// zip : Charleston Road Registry Inc.
+// https://www.iana.org/domains/root/db/zip.html
+zip
+
+// zone : Binky Moon, LLC
+// https://www.iana.org/domains/root/db/zone.html
+zone
+
+// zuerich : Kanton Zürich (Canton of Zurich)
+// https://www.iana.org/domains/root/db/zuerich.html
+zuerich
+
+
+// ===END ICANN DOMAINS===
+// ===BEGIN PRIVATE DOMAINS===
+// (Note: these are in alphabetical order by company name)
+
+// 12CHARS: https://12chars.com
+// Submitted by Kenny Niehage <psl@12chars.com>
+12chars.dev
+12chars.it
+12chars.pro
+
+// 1GB LLC : https://www.1gb.ua/
+// Submitted by 1GB LLC <noc@1gb.com.ua>
+cc.ua
+inf.ua
+ltd.ua
+
+// 611coin : https://611project.org/
+611.to
+
+// AAA workspace : https://aaa.vodka
+// Submitted by Kirill Rezraf <admin@aaa.vodka>
+aaa.vodka
+
+// A2 Hosting
+// Submitted by Tyler Hall <sysadmin@a2hosting.com>
+a2hosted.com
+cpserver.com
+
+// Aaron Marais' Gitlab pages: https://lab.aaronleem.co.za
+// Submitted by Aaron Marais <its_me@aaronleem.co.za>
+graphox.us
+
+// accesso Technology Group, plc. : https://accesso.com/
+// Submitted by accesso Team <accessoecommerce@accesso.com>
+*.devcdnaccesso.com
+
+// Acorn Labs : https://acorn.io
+// Submitted by Craig Jellick <domains@acorn.io>
+*.on-acorn.io
+
+// ActiveTrail: https://www.activetrail.biz/
+// Submitted by Ofer Kalaora <postmaster@activetrail.com>
+activetrail.biz
+
+// Adaptable.io : https://adaptable.io
+// Submitted by Mark Terrel <support@adaptable.io>
+adaptable.app
+
+// Adobe : https://www.adobe.com/
+// Submitted by Ian Boston <boston@adobe.com> and Lars Trieloff <trieloff@adobe.com>
+adobeaemcloud.com
+*.dev.adobeaemcloud.com
+aem.live
+hlx.live
+adobeaemcloud.net
+aem.page
+hlx.page
+hlx3.page
+
+// Adobe Developer Platform : https://developer.adobe.com
+// Submitted by Jesse MacFadyen<jessem@adobe.com>
+adobeio-static.net
+adobeioruntime.net
+
+// Agnat sp. z o.o. : https://domena.pl
+// Submitted by Przemyslaw Plewa <it-admin@domena.pl>
+beep.pl
+
+// Airkit : https://www.airkit.com/
+// Submitted by Grant Cooksey <security@airkit.com>
+airkitapps.com
+airkitapps-au.com
+airkitapps.eu
+
+// Aiven: https://aiven.io/
+// Submitted by Etienne Stalmans <security@aiven.io>
+aivencloud.com
+
+// Akamai : https://www.akamai.com/
+// Submitted by Akamai Team <publicsuffixlist@akamai.com>
+akadns.net
+akamai.net
+akamai-staging.net
+akamaiedge.net
+akamaiedge-staging.net
+akamaihd.net
+akamaihd-staging.net
+akamaiorigin.net
+akamaiorigin-staging.net
+akamaized.net
+akamaized-staging.net
+edgekey.net
+edgekey-staging.net
+edgesuite.net
+edgesuite-staging.net
+
+// alboto.ca : http://alboto.ca
+// Submitted by Anton Avramov <avramov@alboto.ca>
+barsy.ca
+
+// Alces Software Ltd : http://alces-software.com
+// Submitted by Mark J. Titorenko <mark.titorenko@alces-software.com>
+*.compute.estate
+*.alces.network
+
+// all-inkl.com : https://all-inkl.com
+// Submitted by Werner Kaltofen <wk@all-inkl.com>
+kasserver.com
+
+// Altervista: https://www.altervista.org
+// Submitted by Carlo Cannas <tech_staff@altervista.it>
+altervista.org
+
+// alwaysdata : https://www.alwaysdata.com
+// Submitted by Cyril <admin@alwaysdata.com>
+alwaysdata.net
+
+// Amaze Software : https://amaze.co
+// Submitted by Domain Admin <domainadmin@amaze.co>
+myamaze.net
+
+// Amazon : https://www.amazon.com/
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Subsections of Amazon/subsidiaries will appear until "concludes" tag
+
+// Amazon API Gateway
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Reference: 9e37648f-a66c-4655-9ab1-5981f8737197
+execute-api.cn-north-1.amazonaws.com.cn
+execute-api.cn-northwest-1.amazonaws.com.cn
+execute-api.af-south-1.amazonaws.com
+execute-api.ap-east-1.amazonaws.com
+execute-api.ap-northeast-1.amazonaws.com
+execute-api.ap-northeast-2.amazonaws.com
+execute-api.ap-northeast-3.amazonaws.com
+execute-api.ap-south-1.amazonaws.com
+execute-api.ap-south-2.amazonaws.com
+execute-api.ap-southeast-1.amazonaws.com
+execute-api.ap-southeast-2.amazonaws.com
+execute-api.ap-southeast-3.amazonaws.com
+execute-api.ap-southeast-4.amazonaws.com
+execute-api.ca-central-1.amazonaws.com
+execute-api.ca-west-1.amazonaws.com
+execute-api.eu-central-1.amazonaws.com
+execute-api.eu-central-2.amazonaws.com
+execute-api.eu-north-1.amazonaws.com
+execute-api.eu-south-1.amazonaws.com
+execute-api.eu-south-2.amazonaws.com
+execute-api.eu-west-1.amazonaws.com
+execute-api.eu-west-2.amazonaws.com
+execute-api.eu-west-3.amazonaws.com
+execute-api.il-central-1.amazonaws.com
+execute-api.me-central-1.amazonaws.com
+execute-api.me-south-1.amazonaws.com
+execute-api.sa-east-1.amazonaws.com
+execute-api.us-east-1.amazonaws.com
+execute-api.us-east-2.amazonaws.com
+execute-api.us-gov-east-1.amazonaws.com
+execute-api.us-gov-west-1.amazonaws.com
+execute-api.us-west-1.amazonaws.com
+execute-api.us-west-2.amazonaws.com
+
+// Amazon CloudFront
+// Submitted by Donavan Miller <donavanm@amazon.com>
+// Reference: 54144616-fd49-4435-8535-19c6a601bdb3
+cloudfront.net
+
+// Amazon Cognito
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Reference: cb38c251-c93d-4cda-81ec-e72c4f0fdb72
+auth.af-south-1.amazoncognito.com
+auth.ap-east-1.amazoncognito.com
+auth.ap-northeast-1.amazoncognito.com
+auth.ap-northeast-2.amazoncognito.com
+auth.ap-northeast-3.amazoncognito.com
+auth.ap-south-1.amazoncognito.com
+auth.ap-south-2.amazoncognito.com
+auth.ap-southeast-1.amazoncognito.com
+auth.ap-southeast-2.amazoncognito.com
+auth.ap-southeast-3.amazoncognito.com
+auth.ap-southeast-4.amazoncognito.com
+auth.ca-central-1.amazoncognito.com
+auth.ca-west-1.amazoncognito.com
+auth.eu-central-1.amazoncognito.com
+auth.eu-central-2.amazoncognito.com
+auth.eu-north-1.amazoncognito.com
+auth.eu-south-1.amazoncognito.com
+auth.eu-south-2.amazoncognito.com
+auth.eu-west-1.amazoncognito.com
+auth.eu-west-2.amazoncognito.com
+auth.eu-west-3.amazoncognito.com
+auth.il-central-1.amazoncognito.com
+auth.me-central-1.amazoncognito.com
+auth.me-south-1.amazoncognito.com
+auth.sa-east-1.amazoncognito.com
+auth.us-east-1.amazoncognito.com
+auth-fips.us-east-1.amazoncognito.com
+auth.us-east-2.amazoncognito.com
+auth-fips.us-east-2.amazoncognito.com
+auth-fips.us-gov-west-1.amazoncognito.com
+auth.us-west-1.amazoncognito.com
+auth-fips.us-west-1.amazoncognito.com
+auth.us-west-2.amazoncognito.com
+auth-fips.us-west-2.amazoncognito.com
+
+// Amazon EC2
+// Submitted by Luke Wells <psl-maintainers@amazon.com>
+// Reference: 4c38fa71-58ac-4768-99e5-689c1767e537
+*.compute.amazonaws.com.cn
+*.compute.amazonaws.com
+*.compute-1.amazonaws.com
+us-east-1.amazonaws.com
+
+// Amazon EMR
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Reference: 82f43f9f-bbb8-400e-8349-854f5a62f20d
+emrappui-prod.cn-north-1.amazonaws.com.cn
+emrnotebooks-prod.cn-north-1.amazonaws.com.cn
+emrstudio-prod.cn-north-1.amazonaws.com.cn
+emrappui-prod.cn-northwest-1.amazonaws.com.cn
+emrnotebooks-prod.cn-northwest-1.amazonaws.com.cn
+emrstudio-prod.cn-northwest-1.amazonaws.com.cn
+emrappui-prod.af-south-1.amazonaws.com
+emrnotebooks-prod.af-south-1.amazonaws.com
+emrstudio-prod.af-south-1.amazonaws.com
+emrappui-prod.ap-east-1.amazonaws.com
+emrnotebooks-prod.ap-east-1.amazonaws.com
+emrstudio-prod.ap-east-1.amazonaws.com
+emrappui-prod.ap-northeast-1.amazonaws.com
+emrnotebooks-prod.ap-northeast-1.amazonaws.com
+emrstudio-prod.ap-northeast-1.amazonaws.com
+emrappui-prod.ap-northeast-2.amazonaws.com
+emrnotebooks-prod.ap-northeast-2.amazonaws.com
+emrstudio-prod.ap-northeast-2.amazonaws.com
+emrappui-prod.ap-northeast-3.amazonaws.com
+emrnotebooks-prod.ap-northeast-3.amazonaws.com
+emrstudio-prod.ap-northeast-3.amazonaws.com
+emrappui-prod.ap-south-1.amazonaws.com
+emrnotebooks-prod.ap-south-1.amazonaws.com
+emrstudio-prod.ap-south-1.amazonaws.com
+emrappui-prod.ap-south-2.amazonaws.com
+emrnotebooks-prod.ap-south-2.amazonaws.com
+emrstudio-prod.ap-south-2.amazonaws.com
+emrappui-prod.ap-southeast-1.amazonaws.com
+emrnotebooks-prod.ap-southeast-1.amazonaws.com
+emrstudio-prod.ap-southeast-1.amazonaws.com
+emrappui-prod.ap-southeast-2.amazonaws.com
+emrnotebooks-prod.ap-southeast-2.amazonaws.com
+emrstudio-prod.ap-southeast-2.amazonaws.com
+emrappui-prod.ap-southeast-3.amazonaws.com
+emrnotebooks-prod.ap-southeast-3.amazonaws.com
+emrstudio-prod.ap-southeast-3.amazonaws.com
+emrappui-prod.ap-southeast-4.amazonaws.com
+emrnotebooks-prod.ap-southeast-4.amazonaws.com
+emrstudio-prod.ap-southeast-4.amazonaws.com
+emrappui-prod.ca-central-1.amazonaws.com
+emrnotebooks-prod.ca-central-1.amazonaws.com
+emrstudio-prod.ca-central-1.amazonaws.com
+emrappui-prod.ca-west-1.amazonaws.com
+emrnotebooks-prod.ca-west-1.amazonaws.com
+emrstudio-prod.ca-west-1.amazonaws.com
+emrappui-prod.eu-central-1.amazonaws.com
+emrnotebooks-prod.eu-central-1.amazonaws.com
+emrstudio-prod.eu-central-1.amazonaws.com
+emrappui-prod.eu-central-2.amazonaws.com
+emrnotebooks-prod.eu-central-2.amazonaws.com
+emrstudio-prod.eu-central-2.amazonaws.com
+emrappui-prod.eu-north-1.amazonaws.com
+emrnotebooks-prod.eu-north-1.amazonaws.com
+emrstudio-prod.eu-north-1.amazonaws.com
+emrappui-prod.eu-south-1.amazonaws.com
+emrnotebooks-prod.eu-south-1.amazonaws.com
+emrstudio-prod.eu-south-1.amazonaws.com
+emrappui-prod.eu-south-2.amazonaws.com
+emrnotebooks-prod.eu-south-2.amazonaws.com
+emrstudio-prod.eu-south-2.amazonaws.com
+emrappui-prod.eu-west-1.amazonaws.com
+emrnotebooks-prod.eu-west-1.amazonaws.com
+emrstudio-prod.eu-west-1.amazonaws.com
+emrappui-prod.eu-west-2.amazonaws.com
+emrnotebooks-prod.eu-west-2.amazonaws.com
+emrstudio-prod.eu-west-2.amazonaws.com
+emrappui-prod.eu-west-3.amazonaws.com
+emrnotebooks-prod.eu-west-3.amazonaws.com
+emrstudio-prod.eu-west-3.amazonaws.com
+emrappui-prod.il-central-1.amazonaws.com
+emrnotebooks-prod.il-central-1.amazonaws.com
+emrstudio-prod.il-central-1.amazonaws.com
+emrappui-prod.me-central-1.amazonaws.com
+emrnotebooks-prod.me-central-1.amazonaws.com
+emrstudio-prod.me-central-1.amazonaws.com
+emrappui-prod.me-south-1.amazonaws.com
+emrnotebooks-prod.me-south-1.amazonaws.com
+emrstudio-prod.me-south-1.amazonaws.com
+emrappui-prod.sa-east-1.amazonaws.com
+emrnotebooks-prod.sa-east-1.amazonaws.com
+emrstudio-prod.sa-east-1.amazonaws.com
+emrappui-prod.us-east-1.amazonaws.com
+emrnotebooks-prod.us-east-1.amazonaws.com
+emrstudio-prod.us-east-1.amazonaws.com
+emrappui-prod.us-east-2.amazonaws.com
+emrnotebooks-prod.us-east-2.amazonaws.com
+emrstudio-prod.us-east-2.amazonaws.com
+emrappui-prod.us-gov-east-1.amazonaws.com
+emrnotebooks-prod.us-gov-east-1.amazonaws.com
+emrstudio-prod.us-gov-east-1.amazonaws.com
+emrappui-prod.us-gov-west-1.amazonaws.com
+emrnotebooks-prod.us-gov-west-1.amazonaws.com
+emrstudio-prod.us-gov-west-1.amazonaws.com
+emrappui-prod.us-west-1.amazonaws.com
+emrnotebooks-prod.us-west-1.amazonaws.com
+emrstudio-prod.us-west-1.amazonaws.com
+emrappui-prod.us-west-2.amazonaws.com
+emrnotebooks-prod.us-west-2.amazonaws.com
+emrstudio-prod.us-west-2.amazonaws.com
+
+// Amazon Managed Workflows for Apache Airflow
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Reference: f5ea5d0a-ec6a-4f23-ac1c-553fbff13f5c
+*.cn-north-1.airflow.amazonaws.com.cn
+*.cn-northwest-1.airflow.amazonaws.com.cn
+*.af-south-1.airflow.amazonaws.com
+*.ap-east-1.airflow.amazonaws.com
+*.ap-northeast-1.airflow.amazonaws.com
+*.ap-northeast-2.airflow.amazonaws.com
+*.ap-northeast-3.airflow.amazonaws.com
+*.ap-south-1.airflow.amazonaws.com
+*.ap-south-2.airflow.amazonaws.com
+*.ap-southeast-1.airflow.amazonaws.com
+*.ap-southeast-2.airflow.amazonaws.com
+*.ap-southeast-3.airflow.amazonaws.com
+*.ap-southeast-4.airflow.amazonaws.com
+*.ca-central-1.airflow.amazonaws.com
+*.ca-west-1.airflow.amazonaws.com
+*.eu-central-1.airflow.amazonaws.com
+*.eu-central-2.airflow.amazonaws.com
+*.eu-north-1.airflow.amazonaws.com
+*.eu-south-1.airflow.amazonaws.com
+*.eu-south-2.airflow.amazonaws.com
+*.eu-west-1.airflow.amazonaws.com
+*.eu-west-2.airflow.amazonaws.com
+*.eu-west-3.airflow.amazonaws.com
+*.il-central-1.airflow.amazonaws.com
+*.me-central-1.airflow.amazonaws.com
+*.me-south-1.airflow.amazonaws.com
+*.sa-east-1.airflow.amazonaws.com
+*.us-east-1.airflow.amazonaws.com
+*.us-east-2.airflow.amazonaws.com
+*.us-west-1.airflow.amazonaws.com
+*.us-west-2.airflow.amazonaws.com
+
+// Amazon S3
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Reference: cd5c8b3a-67b7-4b40-9236-c87ce81a3d10
+s3.dualstack.cn-north-1.amazonaws.com.cn
+s3-accesspoint.dualstack.cn-north-1.amazonaws.com.cn
+s3-website.dualstack.cn-north-1.amazonaws.com.cn
+s3.cn-north-1.amazonaws.com.cn
+s3-accesspoint.cn-north-1.amazonaws.com.cn
+s3-deprecated.cn-north-1.amazonaws.com.cn
+s3-object-lambda.cn-north-1.amazonaws.com.cn
+s3-website.cn-north-1.amazonaws.com.cn
+s3.dualstack.cn-northwest-1.amazonaws.com.cn
+s3-accesspoint.dualstack.cn-northwest-1.amazonaws.com.cn
+s3.cn-northwest-1.amazonaws.com.cn
+s3-accesspoint.cn-northwest-1.amazonaws.com.cn
+s3-object-lambda.cn-northwest-1.amazonaws.com.cn
+s3-website.cn-northwest-1.amazonaws.com.cn
+s3.dualstack.af-south-1.amazonaws.com
+s3-accesspoint.dualstack.af-south-1.amazonaws.com
+s3-website.dualstack.af-south-1.amazonaws.com
+s3.af-south-1.amazonaws.com
+s3-accesspoint.af-south-1.amazonaws.com
+s3-object-lambda.af-south-1.amazonaws.com
+s3-website.af-south-1.amazonaws.com
+s3.dualstack.ap-east-1.amazonaws.com
+s3-accesspoint.dualstack.ap-east-1.amazonaws.com
+s3.ap-east-1.amazonaws.com
+s3-accesspoint.ap-east-1.amazonaws.com
+s3-object-lambda.ap-east-1.amazonaws.com
+s3-website.ap-east-1.amazonaws.com
+s3.dualstack.ap-northeast-1.amazonaws.com
+s3-accesspoint.dualstack.ap-northeast-1.amazonaws.com
+s3-website.dualstack.ap-northeast-1.amazonaws.com
+s3.ap-northeast-1.amazonaws.com
+s3-accesspoint.ap-northeast-1.amazonaws.com
+s3-object-lambda.ap-northeast-1.amazonaws.com
+s3-website.ap-northeast-1.amazonaws.com
+s3.dualstack.ap-northeast-2.amazonaws.com
+s3-accesspoint.dualstack.ap-northeast-2.amazonaws.com
+s3-website.dualstack.ap-northeast-2.amazonaws.com
+s3.ap-northeast-2.amazonaws.com
+s3-accesspoint.ap-northeast-2.amazonaws.com
+s3-object-lambda.ap-northeast-2.amazonaws.com
+s3-website.ap-northeast-2.amazonaws.com
+s3.dualstack.ap-northeast-3.amazonaws.com
+s3-accesspoint.dualstack.ap-northeast-3.amazonaws.com
+s3-website.dualstack.ap-northeast-3.amazonaws.com
+s3.ap-northeast-3.amazonaws.com
+s3-accesspoint.ap-northeast-3.amazonaws.com
+s3-object-lambda.ap-northeast-3.amazonaws.com
+s3-website.ap-northeast-3.amazonaws.com
+s3.dualstack.ap-south-1.amazonaws.com
+s3-accesspoint.dualstack.ap-south-1.amazonaws.com
+s3-website.dualstack.ap-south-1.amazonaws.com
+s3.ap-south-1.amazonaws.com
+s3-accesspoint.ap-south-1.amazonaws.com
+s3-object-lambda.ap-south-1.amazonaws.com
+s3-website.ap-south-1.amazonaws.com
+s3.dualstack.ap-south-2.amazonaws.com
+s3-accesspoint.dualstack.ap-south-2.amazonaws.com
+s3.ap-south-2.amazonaws.com
+s3-accesspoint.ap-south-2.amazonaws.com
+s3-object-lambda.ap-south-2.amazonaws.com
+s3-website.ap-south-2.amazonaws.com
+s3.dualstack.ap-southeast-1.amazonaws.com
+s3-accesspoint.dualstack.ap-southeast-1.amazonaws.com
+s3-website.dualstack.ap-southeast-1.amazonaws.com
+s3.ap-southeast-1.amazonaws.com
+s3-accesspoint.ap-southeast-1.amazonaws.com
+s3-object-lambda.ap-southeast-1.amazonaws.com
+s3-website.ap-southeast-1.amazonaws.com
+s3.dualstack.ap-southeast-2.amazonaws.com
+s3-accesspoint.dualstack.ap-southeast-2.amazonaws.com
+s3-website.dualstack.ap-southeast-2.amazonaws.com
+s3.ap-southeast-2.amazonaws.com
+s3-accesspoint.ap-southeast-2.amazonaws.com
+s3-object-lambda.ap-southeast-2.amazonaws.com
+s3-website.ap-southeast-2.amazonaws.com
+s3.dualstack.ap-southeast-3.amazonaws.com
+s3-accesspoint.dualstack.ap-southeast-3.amazonaws.com
+s3.ap-southeast-3.amazonaws.com
+s3-accesspoint.ap-southeast-3.amazonaws.com
+s3-object-lambda.ap-southeast-3.amazonaws.com
+s3-website.ap-southeast-3.amazonaws.com
+s3.dualstack.ap-southeast-4.amazonaws.com
+s3-accesspoint.dualstack.ap-southeast-4.amazonaws.com
+s3.ap-southeast-4.amazonaws.com
+s3-accesspoint.ap-southeast-4.amazonaws.com
+s3-object-lambda.ap-southeast-4.amazonaws.com
+s3-website.ap-southeast-4.amazonaws.com
+s3.dualstack.ca-central-1.amazonaws.com
+s3-accesspoint.dualstack.ca-central-1.amazonaws.com
+s3-accesspoint-fips.dualstack.ca-central-1.amazonaws.com
+s3-fips.dualstack.ca-central-1.amazonaws.com
+s3-website.dualstack.ca-central-1.amazonaws.com
+s3.ca-central-1.amazonaws.com
+s3-accesspoint.ca-central-1.amazonaws.com
+s3-accesspoint-fips.ca-central-1.amazonaws.com
+s3-fips.ca-central-1.amazonaws.com
+s3-object-lambda.ca-central-1.amazonaws.com
+s3-website.ca-central-1.amazonaws.com
+s3.dualstack.ca-west-1.amazonaws.com
+s3-accesspoint.dualstack.ca-west-1.amazonaws.com
+s3-accesspoint-fips.dualstack.ca-west-1.amazonaws.com
+s3-fips.dualstack.ca-west-1.amazonaws.com
+s3-website.dualstack.ca-west-1.amazonaws.com
+s3.ca-west-1.amazonaws.com
+s3-accesspoint.ca-west-1.amazonaws.com
+s3-accesspoint-fips.ca-west-1.amazonaws.com
+s3-fips.ca-west-1.amazonaws.com
+s3-website.ca-west-1.amazonaws.com
+s3.dualstack.eu-central-1.amazonaws.com
+s3-accesspoint.dualstack.eu-central-1.amazonaws.com
+s3-website.dualstack.eu-central-1.amazonaws.com
+s3.eu-central-1.amazonaws.com
+s3-accesspoint.eu-central-1.amazonaws.com
+s3-object-lambda.eu-central-1.amazonaws.com
+s3-website.eu-central-1.amazonaws.com
+s3.dualstack.eu-central-2.amazonaws.com
+s3-accesspoint.dualstack.eu-central-2.amazonaws.com
+s3.eu-central-2.amazonaws.com
+s3-accesspoint.eu-central-2.amazonaws.com
+s3-object-lambda.eu-central-2.amazonaws.com
+s3-website.eu-central-2.amazonaws.com
+s3.dualstack.eu-north-1.amazonaws.com
+s3-accesspoint.dualstack.eu-north-1.amazonaws.com
+s3.eu-north-1.amazonaws.com
+s3-accesspoint.eu-north-1.amazonaws.com
+s3-object-lambda.eu-north-1.amazonaws.com
+s3-website.eu-north-1.amazonaws.com
+s3.dualstack.eu-south-1.amazonaws.com
+s3-accesspoint.dualstack.eu-south-1.amazonaws.com
+s3-website.dualstack.eu-south-1.amazonaws.com
+s3.eu-south-1.amazonaws.com
+s3-accesspoint.eu-south-1.amazonaws.com
+s3-object-lambda.eu-south-1.amazonaws.com
+s3-website.eu-south-1.amazonaws.com
+s3.dualstack.eu-south-2.amazonaws.com
+s3-accesspoint.dualstack.eu-south-2.amazonaws.com
+s3.eu-south-2.amazonaws.com
+s3-accesspoint.eu-south-2.amazonaws.com
+s3-object-lambda.eu-south-2.amazonaws.com
+s3-website.eu-south-2.amazonaws.com
+s3.dualstack.eu-west-1.amazonaws.com
+s3-accesspoint.dualstack.eu-west-1.amazonaws.com
+s3-website.dualstack.eu-west-1.amazonaws.com
+s3.eu-west-1.amazonaws.com
+s3-accesspoint.eu-west-1.amazonaws.com
+s3-deprecated.eu-west-1.amazonaws.com
+s3-object-lambda.eu-west-1.amazonaws.com
+s3-website.eu-west-1.amazonaws.com
+s3.dualstack.eu-west-2.amazonaws.com
+s3-accesspoint.dualstack.eu-west-2.amazonaws.com
+s3.eu-west-2.amazonaws.com
+s3-accesspoint.eu-west-2.amazonaws.com
+s3-object-lambda.eu-west-2.amazonaws.com
+s3-website.eu-west-2.amazonaws.com
+s3.dualstack.eu-west-3.amazonaws.com
+s3-accesspoint.dualstack.eu-west-3.amazonaws.com
+s3-website.dualstack.eu-west-3.amazonaws.com
+s3.eu-west-3.amazonaws.com
+s3-accesspoint.eu-west-3.amazonaws.com
+s3-object-lambda.eu-west-3.amazonaws.com
+s3-website.eu-west-3.amazonaws.com
+s3.dualstack.il-central-1.amazonaws.com
+s3-accesspoint.dualstack.il-central-1.amazonaws.com
+s3.il-central-1.amazonaws.com
+s3-accesspoint.il-central-1.amazonaws.com
+s3-object-lambda.il-central-1.amazonaws.com
+s3-website.il-central-1.amazonaws.com
+s3.dualstack.me-central-1.amazonaws.com
+s3-accesspoint.dualstack.me-central-1.amazonaws.com
+s3.me-central-1.amazonaws.com
+s3-accesspoint.me-central-1.amazonaws.com
+s3-object-lambda.me-central-1.amazonaws.com
+s3-website.me-central-1.amazonaws.com
+s3.dualstack.me-south-1.amazonaws.com
+s3-accesspoint.dualstack.me-south-1.amazonaws.com
+s3.me-south-1.amazonaws.com
+s3-accesspoint.me-south-1.amazonaws.com
+s3-object-lambda.me-south-1.amazonaws.com
+s3-website.me-south-1.amazonaws.com
+s3.amazonaws.com
+s3-1.amazonaws.com
+s3-ap-east-1.amazonaws.com
+s3-ap-northeast-1.amazonaws.com
+s3-ap-northeast-2.amazonaws.com
+s3-ap-northeast-3.amazonaws.com
+s3-ap-south-1.amazonaws.com
+s3-ap-southeast-1.amazonaws.com
+s3-ap-southeast-2.amazonaws.com
+s3-ca-central-1.amazonaws.com
+s3-eu-central-1.amazonaws.com
+s3-eu-north-1.amazonaws.com
+s3-eu-west-1.amazonaws.com
+s3-eu-west-2.amazonaws.com
+s3-eu-west-3.amazonaws.com
+s3-external-1.amazonaws.com
+s3-fips-us-gov-east-1.amazonaws.com
+s3-fips-us-gov-west-1.amazonaws.com
+mrap.accesspoint.s3-global.amazonaws.com
+s3-me-south-1.amazonaws.com
+s3-sa-east-1.amazonaws.com
+s3-us-east-2.amazonaws.com
+s3-us-gov-east-1.amazonaws.com
+s3-us-gov-west-1.amazonaws.com
+s3-us-west-1.amazonaws.com
+s3-us-west-2.amazonaws.com
+s3-website-ap-northeast-1.amazonaws.com
+s3-website-ap-southeast-1.amazonaws.com
+s3-website-ap-southeast-2.amazonaws.com
+s3-website-eu-west-1.amazonaws.com
+s3-website-sa-east-1.amazonaws.com
+s3-website-us-east-1.amazonaws.com
+s3-website-us-gov-west-1.amazonaws.com
+s3-website-us-west-1.amazonaws.com
+s3-website-us-west-2.amazonaws.com
+s3.dualstack.sa-east-1.amazonaws.com
+s3-accesspoint.dualstack.sa-east-1.amazonaws.com
+s3-website.dualstack.sa-east-1.amazonaws.com
+s3.sa-east-1.amazonaws.com
+s3-accesspoint.sa-east-1.amazonaws.com
+s3-object-lambda.sa-east-1.amazonaws.com
+s3-website.sa-east-1.amazonaws.com
+s3.dualstack.us-east-1.amazonaws.com
+s3-accesspoint.dualstack.us-east-1.amazonaws.com
+s3-accesspoint-fips.dualstack.us-east-1.amazonaws.com
+s3-fips.dualstack.us-east-1.amazonaws.com
+s3-website.dualstack.us-east-1.amazonaws.com
+s3.us-east-1.amazonaws.com
+s3-accesspoint.us-east-1.amazonaws.com
+s3-accesspoint-fips.us-east-1.amazonaws.com
+s3-deprecated.us-east-1.amazonaws.com
+s3-fips.us-east-1.amazonaws.com
+s3-object-lambda.us-east-1.amazonaws.com
+s3-website.us-east-1.amazonaws.com
+s3.dualstack.us-east-2.amazonaws.com
+s3-accesspoint.dualstack.us-east-2.amazonaws.com
+s3-accesspoint-fips.dualstack.us-east-2.amazonaws.com
+s3-fips.dualstack.us-east-2.amazonaws.com
+s3.us-east-2.amazonaws.com
+s3-accesspoint.us-east-2.amazonaws.com
+s3-accesspoint-fips.us-east-2.amazonaws.com
+s3-deprecated.us-east-2.amazonaws.com
+s3-fips.us-east-2.amazonaws.com
+s3-object-lambda.us-east-2.amazonaws.com
+s3-website.us-east-2.amazonaws.com
+s3.dualstack.us-gov-east-1.amazonaws.com
+s3-accesspoint.dualstack.us-gov-east-1.amazonaws.com
+s3-accesspoint-fips.dualstack.us-gov-east-1.amazonaws.com
+s3-fips.dualstack.us-gov-east-1.amazonaws.com
+s3.us-gov-east-1.amazonaws.com
+s3-accesspoint.us-gov-east-1.amazonaws.com
+s3-accesspoint-fips.us-gov-east-1.amazonaws.com
+s3-fips.us-gov-east-1.amazonaws.com
+s3-object-lambda.us-gov-east-1.amazonaws.com
+s3-website.us-gov-east-1.amazonaws.com
+s3.dualstack.us-gov-west-1.amazonaws.com
+s3-accesspoint.dualstack.us-gov-west-1.amazonaws.com
+s3-accesspoint-fips.dualstack.us-gov-west-1.amazonaws.com
+s3-fips.dualstack.us-gov-west-1.amazonaws.com
+s3.us-gov-west-1.amazonaws.com
+s3-accesspoint.us-gov-west-1.amazonaws.com
+s3-accesspoint-fips.us-gov-west-1.amazonaws.com
+s3-fips.us-gov-west-1.amazonaws.com
+s3-object-lambda.us-gov-west-1.amazonaws.com
+s3-website.us-gov-west-1.amazonaws.com
+s3.dualstack.us-west-1.amazonaws.com
+s3-accesspoint.dualstack.us-west-1.amazonaws.com
+s3-accesspoint-fips.dualstack.us-west-1.amazonaws.com
+s3-fips.dualstack.us-west-1.amazonaws.com
+s3-website.dualstack.us-west-1.amazonaws.com
+s3.us-west-1.amazonaws.com
+s3-accesspoint.us-west-1.amazonaws.com
+s3-accesspoint-fips.us-west-1.amazonaws.com
+s3-fips.us-west-1.amazonaws.com
+s3-object-lambda.us-west-1.amazonaws.com
+s3-website.us-west-1.amazonaws.com
+s3.dualstack.us-west-2.amazonaws.com
+s3-accesspoint.dualstack.us-west-2.amazonaws.com
+s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com
+s3-fips.dualstack.us-west-2.amazonaws.com
+s3-website.dualstack.us-west-2.amazonaws.com
+s3.us-west-2.amazonaws.com
+s3-accesspoint.us-west-2.amazonaws.com
+s3-accesspoint-fips.us-west-2.amazonaws.com
+s3-deprecated.us-west-2.amazonaws.com
+s3-fips.us-west-2.amazonaws.com
+s3-object-lambda.us-west-2.amazonaws.com
+s3-website.us-west-2.amazonaws.com
+
+// Amazon SageMaker Ground Truth
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Reference: 98dbfde4-7802-48c3-8751-b60f204e0d9c
+labeling.ap-northeast-1.sagemaker.aws
+labeling.ap-northeast-2.sagemaker.aws
+labeling.ap-south-1.sagemaker.aws
+labeling.ap-southeast-1.sagemaker.aws
+labeling.ap-southeast-2.sagemaker.aws
+labeling.ca-central-1.sagemaker.aws
+labeling.eu-central-1.sagemaker.aws
+labeling.eu-west-1.sagemaker.aws
+labeling.eu-west-2.sagemaker.aws
+labeling.us-east-1.sagemaker.aws
+labeling.us-east-2.sagemaker.aws
+labeling.us-west-2.sagemaker.aws
+
+// Amazon SageMaker Notebook Instances
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Reference: b5ea56df-669e-43cc-9537-14aa172f5dfc
+notebook.af-south-1.sagemaker.aws
+notebook.ap-east-1.sagemaker.aws
+notebook.ap-northeast-1.sagemaker.aws
+notebook.ap-northeast-2.sagemaker.aws
+notebook.ap-northeast-3.sagemaker.aws
+notebook.ap-south-1.sagemaker.aws
+notebook.ap-south-2.sagemaker.aws
+notebook.ap-southeast-1.sagemaker.aws
+notebook.ap-southeast-2.sagemaker.aws
+notebook.ap-southeast-3.sagemaker.aws
+notebook.ap-southeast-4.sagemaker.aws
+notebook.ca-central-1.sagemaker.aws
+notebook-fips.ca-central-1.sagemaker.aws
+notebook.ca-west-1.sagemaker.aws
+notebook-fips.ca-west-1.sagemaker.aws
+notebook.eu-central-1.sagemaker.aws
+notebook.eu-central-2.sagemaker.aws
+notebook.eu-north-1.sagemaker.aws
+notebook.eu-south-1.sagemaker.aws
+notebook.eu-south-2.sagemaker.aws
+notebook.eu-west-1.sagemaker.aws
+notebook.eu-west-2.sagemaker.aws
+notebook.eu-west-3.sagemaker.aws
+notebook.il-central-1.sagemaker.aws
+notebook.me-central-1.sagemaker.aws
+notebook.me-south-1.sagemaker.aws
+notebook.sa-east-1.sagemaker.aws
+notebook.us-east-1.sagemaker.aws
+notebook-fips.us-east-1.sagemaker.aws
+notebook.us-east-2.sagemaker.aws
+notebook-fips.us-east-2.sagemaker.aws
+notebook.us-gov-east-1.sagemaker.aws
+notebook-fips.us-gov-east-1.sagemaker.aws
+notebook.us-gov-west-1.sagemaker.aws
+notebook-fips.us-gov-west-1.sagemaker.aws
+notebook.us-west-1.sagemaker.aws
+notebook-fips.us-west-1.sagemaker.aws
+notebook.us-west-2.sagemaker.aws
+notebook-fips.us-west-2.sagemaker.aws
+notebook.cn-north-1.sagemaker.com.cn
+notebook.cn-northwest-1.sagemaker.com.cn
+
+// Amazon SageMaker Studio
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Reference: 69c723d9-6e1a-4bff-a203-48eecd203183
+studio.af-south-1.sagemaker.aws
+studio.ap-east-1.sagemaker.aws
+studio.ap-northeast-1.sagemaker.aws
+studio.ap-northeast-2.sagemaker.aws
+studio.ap-northeast-3.sagemaker.aws
+studio.ap-south-1.sagemaker.aws
+studio.ap-southeast-1.sagemaker.aws
+studio.ap-southeast-2.sagemaker.aws
+studio.ap-southeast-3.sagemaker.aws
+studio.ca-central-1.sagemaker.aws
+studio.eu-central-1.sagemaker.aws
+studio.eu-north-1.sagemaker.aws
+studio.eu-south-1.sagemaker.aws
+studio.eu-south-2.sagemaker.aws
+studio.eu-west-1.sagemaker.aws
+studio.eu-west-2.sagemaker.aws
+studio.eu-west-3.sagemaker.aws
+studio.il-central-1.sagemaker.aws
+studio.me-central-1.sagemaker.aws
+studio.me-south-1.sagemaker.aws
+studio.sa-east-1.sagemaker.aws
+studio.us-east-1.sagemaker.aws
+studio.us-east-2.sagemaker.aws
+studio.us-gov-east-1.sagemaker.aws
+studio-fips.us-gov-east-1.sagemaker.aws
+studio.us-gov-west-1.sagemaker.aws
+studio-fips.us-gov-west-1.sagemaker.aws
+studio.us-west-1.sagemaker.aws
+studio.us-west-2.sagemaker.aws
+studio.cn-north-1.sagemaker.com.cn
+studio.cn-northwest-1.sagemaker.com.cn
+
+// Amazon SageMaker with MLflow
+// Submited by: AWS Security <psl-maintainers@amazon.com>
+// Reference: c19f92b3-a82a-452d-8189-831b572eea7e
+*.experiments.sagemaker.aws
+
+// Analytics on AWS
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Reference: 955f9f40-a495-4e73-ae85-67b77ac9cadd
+analytics-gateway.ap-northeast-1.amazonaws.com
+analytics-gateway.ap-northeast-2.amazonaws.com
+analytics-gateway.ap-south-1.amazonaws.com
+analytics-gateway.ap-southeast-1.amazonaws.com
+analytics-gateway.ap-southeast-2.amazonaws.com
+analytics-gateway.eu-central-1.amazonaws.com
+analytics-gateway.eu-west-1.amazonaws.com
+analytics-gateway.us-east-1.amazonaws.com
+analytics-gateway.us-east-2.amazonaws.com
+analytics-gateway.us-west-2.amazonaws.com
+
+// AWS Amplify
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Reference: c35bed18-6f4f-424f-9298-5756f2f7d72b
+amplifyapp.com
+
+// AWS App Runner
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Reference: 6828c008-ba5d-442f-ade5-48da4e7c2316
+*.awsapprunner.com
+
+// AWS Cloud9
+// Submitted by: AWS Security <psl-maintainers@amazon.com>
+// Reference: 30717f72-4007-4f0f-8ed4-864c6f2efec9
+webview-assets.aws-cloud9.af-south-1.amazonaws.com
+vfs.cloud9.af-south-1.amazonaws.com
+webview-assets.cloud9.af-south-1.amazonaws.com
+webview-assets.aws-cloud9.ap-east-1.amazonaws.com
+vfs.cloud9.ap-east-1.amazonaws.com
+webview-assets.cloud9.ap-east-1.amazonaws.com
+webview-assets.aws-cloud9.ap-northeast-1.amazonaws.com
+vfs.cloud9.ap-northeast-1.amazonaws.com
+webview-assets.cloud9.ap-northeast-1.amazonaws.com
+webview-assets.aws-cloud9.ap-northeast-2.amazonaws.com
+vfs.cloud9.ap-northeast-2.amazonaws.com
+webview-assets.cloud9.ap-northeast-2.amazonaws.com
+webview-assets.aws-cloud9.ap-northeast-3.amazonaws.com
+vfs.cloud9.ap-northeast-3.amazonaws.com
+webview-assets.cloud9.ap-northeast-3.amazonaws.com
+webview-assets.aws-cloud9.ap-south-1.amazonaws.com
+vfs.cloud9.ap-south-1.amazonaws.com
+webview-assets.cloud9.ap-south-1.amazonaws.com
+webview-assets.aws-cloud9.ap-southeast-1.amazonaws.com
+vfs.cloud9.ap-southeast-1.amazonaws.com
+webview-assets.cloud9.ap-southeast-1.amazonaws.com
+webview-assets.aws-cloud9.ap-southeast-2.amazonaws.com
+vfs.cloud9.ap-southeast-2.amazonaws.com
+webview-assets.cloud9.ap-southeast-2.amazonaws.com
+webview-assets.aws-cloud9.ca-central-1.amazonaws.com
+vfs.cloud9.ca-central-1.amazonaws.com
+webview-assets.cloud9.ca-central-1.amazonaws.com
+webview-assets.aws-cloud9.eu-central-1.amazonaws.com
+vfs.cloud9.eu-central-1.amazonaws.com
+webview-assets.cloud9.eu-central-1.amazonaws.com
+webview-assets.aws-cloud9.eu-north-1.amazonaws.com
+vfs.cloud9.eu-north-1.amazonaws.com
+webview-assets.cloud9.eu-north-1.amazonaws.com
+webview-assets.aws-cloud9.eu-south-1.amazonaws.com
+vfs.cloud9.eu-south-1.amazonaws.com
+webview-assets.cloud9.eu-south-1.amazonaws.com
+webview-assets.aws-cloud9.eu-west-1.amazonaws.com
+vfs.cloud9.eu-west-1.amazonaws.com
+webview-assets.cloud9.eu-west-1.amazonaws.com
+webview-assets.aws-cloud9.eu-west-2.amazonaws.com
+vfs.cloud9.eu-west-2.amazonaws.com
+webview-assets.cloud9.eu-west-2.amazonaws.com
+webview-assets.aws-cloud9.eu-west-3.amazonaws.com
+vfs.cloud9.eu-west-3.amazonaws.com
+webview-assets.cloud9.eu-west-3.amazonaws.com
+webview-assets.aws-cloud9.il-central-1.amazonaws.com
+vfs.cloud9.il-central-1.amazonaws.com
+webview-assets.aws-cloud9.me-south-1.amazonaws.com
+vfs.cloud9.me-south-1.amazonaws.com
+webview-assets.cloud9.me-south-1.amazonaws.com
+webview-assets.aws-cloud9.sa-east-1.amazonaws.com
+vfs.cloud9.sa-east-1.amazonaws.com
+webview-assets.cloud9.sa-east-1.amazonaws.com
+webview-assets.aws-cloud9.us-east-1.amazonaws.com
+vfs.cloud9.us-east-1.amazonaws.com
+webview-assets.cloud9.us-east-1.amazonaws.com
+webview-assets.aws-cloud9.us-east-2.amazonaws.com
+vfs.cloud9.us-east-2.amazonaws.com
+webview-assets.cloud9.us-east-2.amazonaws.com
+webview-assets.aws-cloud9.us-west-1.amazonaws.com
+vfs.cloud9.us-west-1.amazonaws.com
+webview-assets.cloud9.us-west-1.amazonaws.com
+webview-assets.aws-cloud9.us-west-2.amazonaws.com
+vfs.cloud9.us-west-2.amazonaws.com
+webview-assets.cloud9.us-west-2.amazonaws.com
+
+// AWS Directory Service
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Reference: a13203e8-42dc-4045-a0d2-2ee67bed1068
+awsapps.com
+
+// AWS Elastic Beanstalk
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Reference: bb5a965c-dec3-4967-aa22-e306ad064797
+cn-north-1.eb.amazonaws.com.cn
+cn-northwest-1.eb.amazonaws.com.cn
+elasticbeanstalk.com
+af-south-1.elasticbeanstalk.com
+ap-east-1.elasticbeanstalk.com
+ap-northeast-1.elasticbeanstalk.com
+ap-northeast-2.elasticbeanstalk.com
+ap-northeast-3.elasticbeanstalk.com
+ap-south-1.elasticbeanstalk.com
+ap-southeast-1.elasticbeanstalk.com
+ap-southeast-2.elasticbeanstalk.com
+ap-southeast-3.elasticbeanstalk.com
+ca-central-1.elasticbeanstalk.com
+eu-central-1.elasticbeanstalk.com
+eu-north-1.elasticbeanstalk.com
+eu-south-1.elasticbeanstalk.com
+eu-west-1.elasticbeanstalk.com
+eu-west-2.elasticbeanstalk.com
+eu-west-3.elasticbeanstalk.com
+il-central-1.elasticbeanstalk.com
+me-south-1.elasticbeanstalk.com
+sa-east-1.elasticbeanstalk.com
+us-east-1.elasticbeanstalk.com
+us-east-2.elasticbeanstalk.com
+us-gov-east-1.elasticbeanstalk.com
+us-gov-west-1.elasticbeanstalk.com
+us-west-1.elasticbeanstalk.com
+us-west-2.elasticbeanstalk.com
+
+// (AWS) Elastic Load Balancing
+// Submitted by Luke Wells <psl-maintainers@amazon.com>
+// Reference: 12a3d528-1bac-4433-a359-a395867ffed2
+*.elb.amazonaws.com.cn
+*.elb.amazonaws.com
+
+// AWS Global Accelerator
+// Submitted by Daniel Massaguer <psl-maintainers@amazon.com>
+// Reference: d916759d-a08b-4241-b536-4db887383a6a
+awsglobalaccelerator.com
+
+// AWS re:Post Private
+// Submitted by AWS Security <psl-maintainers@amazon.com>
+// Reference: 83385945-225f-416e-9aa0-ad0632bfdcee
+*.private.repost.aws
+
+// eero
+// Submitted by Yue Kang <eero-dynamic-dns@amazon.com>
+// Reference: 264afe70-f62c-4c02-8ab9-b5281ed24461
+eero.online
+eero-stage.online
+
+// concludes Amazon
+
+// Amune : https://amune.org/
+// Submitted by Team Amune <cert@amune.org>
+t3l3p0rt.net
+tele.amune.org
+
+// Apigee : https://apigee.com/
+// Submitted by Apigee Security Team <security@apigee.com>
+apigee.io
+
+// Apis Networks: https://apisnetworks.com
+// Submitted by Matt Saladna <matt@apisnetworks.com>
+panel.dev
+
+// Apphud : https://apphud.com
+// Submitted by Alexander Selivanov <alex@apphud.com>
+siiites.com
+
+// Appspace : https://www.appspace.com
+// Submitted by Appspace Security Team <security@appspace.com>
+appspacehosted.com
+appspaceusercontent.com
+
+// Appudo UG (haftungsbeschränkt) : https://www.appudo.com
+// Submitted by Alexander Hochbaum <admin@appudo.com>
+appudo.net
+
+// Aptible : https://www.aptible.com/
+// Submitted by Thomas Orozco <thomas@aptible.com>
+on-aptible.com
+
+// Aquapal : https://aquapal.net/
+// Submitted by Aki Ueno <admin@aquapal.net>
+f5.si
+
+// ASEINet : https://www.aseinet.com/
+// Submitted by Asei SEKIGUCHI <mail@aseinet.com>
+user.aseinet.ne.jp
+gv.vc
+d.gv.vc
+
+// Asociación Amigos de la Informática "Euskalamiga" : http://encounter.eus/
+// Submitted by Hector Martin <marcan@euskalencounter.org>
+user.party.eus
+
+// Association potager.org : https://potager.org/
+// Submitted by Lunar <jardiniers@potager.org>
+pimienta.org
+poivron.org
+potager.org
+sweetpepper.org
+
+// ASUSTOR Inc. : http://www.asustor.com
+// Submitted by Vincent Tseng <vincenttseng@asustor.com>
+myasustor.com
+
+// Atlassian : https://atlassian.com
+// Submitted by Sam Smyth <devloop@atlassian.com>
+cdn.prod.atlassian-dev.net
+
+// Authentick UG (haftungsbeschränkt) : https://authentick.net
+// Submitted by Lukas Reschke <lukas@authentick.net>
+translated.page
+
+// Autocode : https://autocode.com
+// Submitted by Jacob Lee <jacob@autocode.com>
+autocode.dev
+
+// AVM : https://avm.de
+// Submitted by Andreas Weise <a.weise@avm.de>
+myfritz.link
+myfritz.net
+
+// AVStack Pte. Ltd. : https://avstack.io
+// Submitted by Jasper Hugo <jasper@avstack.io>
+onavstack.net
+
+// AW AdvisorWebsites.com Software Inc : https://advisorwebsites.com
+// Submitted by James Kennedy <domains@advisorwebsites.com>
+*.awdev.ca
+*.advisor.ws
+
+// AZ.pl sp. z.o.o: https://az.pl
+// Submitted by Krzysztof Wolski <krzysztof.wolski@home.eu>
+ecommerce-shop.pl
+
+// b-data GmbH : https://www.b-data.io
+// Submitted by Olivier Benz <olivier.benz@b-data.ch>
+b-data.io
+
+// backplane : https://www.backplane.io
+// Submitted by Anthony Voutas <anthony@backplane.io>
+backplaneapp.io
+
+// Balena : https://www.balena.io
+// Submitted by Petros Angelatos <petrosagg@balena.io>
+balena-devices.com
+
+// University of Banja Luka : https://unibl.org
+// Domains for Republic of Srpska administrative entity.
+// Submitted by Marko Ivanovic <kormang@hotmail.rs>
+rs.ba
+
+// Banzai Cloud
+// Submitted by Janos Matyas <info@banzaicloud.com>
+*.banzai.cloud
+app.banzaicloud.io
+*.backyards.banzaicloud.io
+
+// BASE, Inc. : https://binc.jp
+// Submitted by Yuya NAGASAWA <public-suffix-list@binc.jp>
+base.ec
+official.ec
+buyshop.jp
+fashionstore.jp
+handcrafted.jp
+kawaiishop.jp
+supersale.jp
+theshop.jp
+shopselect.net
+base.shop
+
+// BeagleBoard.org Foundation : https://beagleboard.org
+// Submitted by Jason Kridner <jkridner@beagleboard.org>
+beagleboard.io
+
+// Beget Ltd
+// Submitted by Lev Nekrasov <lnekrasov@beget.com>
+*.beget.app
+
+// Besties : https://besties.house
+// Submitted by Hazel Cora <hazy@besties.house>
+pages.gay
+
+// BetaInABox
+// Submitted by Adrian <adrian@betainabox.com>
+betainabox.com
+
+// University of Bielsko-Biala regional domain: http://dns.bielsko.pl/
+// Submitted by Marcin <dns@ath.bielsko.pl>
+bielsko.pl
+
+// BinaryLane : http://www.binarylane.com
+// Submitted by Nathan O'Sullivan <nathan@mammoth.com.au>
+bnr.la
+
+// Bitbucket : http://bitbucket.org
+// Submitted by Andy Ortlieb <aortlieb@atlassian.com>
+bitbucket.io
+
+// Blackbaud, Inc. : https://www.blackbaud.com
+// Submitted by Paul Crowder <paul.crowder@blackbaud.com>
+blackbaudcdn.net
+
+// Blatech : http://www.blatech.net
+// Submitted by Luke Bratch <luke@bratch.co.uk>
+of.je
+
+// Blue Bite, LLC : https://bluebite.com
+// Submitted by Joshua Weiss <admin.engineering@bluebite.com>
+bluebite.io
+
+// Boomla : https://boomla.com
+// Submitted by Tibor Halter <thalter@boomla.com>
+boomla.net
+
+// Boutir : https://www.boutir.com
+// Submitted by Eric Ng Ka Ka <ngkaka@boutir.com>
+boutir.com
+
+// Boxfuse : https://boxfuse.com
+// Submitted by Axel Fontaine <axel@boxfuse.com>
+boxfuse.io
+
+// bplaced : https://www.bplaced.net/
+// Submitted by Miroslav Bozic <security@bplaced.net>
+square7.ch
+bplaced.com
+bplaced.de
+square7.de
+bplaced.net
+square7.net
+
+// Brave : https://brave.com
+// Submitted by Andrea Brancaleoni <abrancaleoni@brave.com>
+*.s.brave.io
+
+// Brendly : https://brendly.rs
+// Submitted by Dusan Radovanovic <administracija@brendly.rs>
+shop.brendly.hr
+shop.brendly.rs
+
+// BrowserSafetyMark
+// Submitted by Dave Tharp <browsersafetymark.io@quicinc.com>
+browsersafetymark.io
+
+// Bytemark Hosting : https://www.bytemark.co.uk
+// Submitted by Paul Cammish <paul.cammish@bytemark.co.uk>
+uk0.bigv.io
+dh.bytemark.co.uk
+vm.bytemark.co.uk
+
+// Caf.js Labs LLC : https://www.cafjs.com
+// Submitted by Antonio Lain <antlai@cafjs.com>
+cafjs.com
+
+// callidomus : https://www.callidomus.com/
+// Submitted by Marcus Popp <admin@callidomus.com>
+mycd.eu
+
+// Canva Pty Ltd : https://canva.com/
+// Submitted by Joel Aquilina <publicsuffixlist@canva.com>
+canva-apps.cn
+*.my.canvasite.cn
+canva-apps.com
+*.my.canva.site
+
+// Carrd : https://carrd.co
+// Submitted by AJ <aj@carrd.co>
+drr.ac
+uwu.ai
+carrd.co
+crd.co
+ju.mp
+
+// CentralNic : http://www.centralnic.com/names/domains
+// Submitted by registry <gavin.brown@centralnic.com>
+za.bz
+br.com
+cn.com
+de.com
+eu.com
+jpn.com
+mex.com
+ru.com
+sa.com
+uk.com
+us.com
+za.com
+com.de
+gb.net
+hu.net
+jp.net
+se.net
+uk.net
+ae.org
+com.se
+
+// No longer operated by CentralNic, these entries should be adopted and/or removed by current operators
+// Submitted by Gavin Brown <gavin.brown@centralnic.com>
+ar.com
+hu.com
+kr.com
+no.com
+qc.com
+uy.com
+
+// Africa.com Web Solutions Ltd : https://registry.africa.com
+// Submitted by Gavin Brown <gavin.brown@centralnic.com>
+africa.com
+
+// iDOT Services Limited : http://www.domain.gr.com
+// Submitted by Gavin Brown <gavin.brown@centralnic.com>
+gr.com
+
+// Radix FZC : http://domains.in.net
+// Submitted by Gavin Brown <gavin.brown@centralnic.com>
+web.in
+in.net
+
+// US REGISTRY LLC : http://us.org
+// Submitted by Gavin Brown <gavin.brown@centralnic.com>
+us.org
+
+// co.com Registry, LLC : https://registry.co.com
+// Submitted by Gavin Brown <gavin.brown@centralnic.com>
+co.com
+
+// Roar Domains LLC : https://roar.basketball/
+// Submitted by Gavin Brown <gavin.brown@centralnic.com>
+aus.basketball
+nz.basketball
+
+// BRS Media : https://brsmedia.com/
+// Submitted by Gavin Brown <gavin.brown@centralnic.com>
+radio.am
+radio.fm
+
+// certmgr.org : https://certmgr.org
+// Submitted by B. Blechschmidt <hostmaster@certmgr.org>
+certmgr.org
+
+// Cityhost LLC  : https://cityhost.ua
+// Submitted by Maksym Rivtin <support@cityhost.net.ua>
+cx.ua
+
+// Civilized Discourse Construction Kit, Inc. : https://www.discourse.org/
+// Submitted by Rishabh Nambiar & Michael Brown <team@discourse.org>
+discourse.group
+discourse.team
+
+// Clever Cloud : https://www.clever-cloud.com/
+// Submitted by Quentin Adam <noc@clever-cloud.com>
+cleverapps.cc
+*.services.clever-cloud.com
+cleverapps.io
+cleverapps.tech
+
+// Clerk : https://www.clerk.dev
+// Submitted by Colin Sidoti <systems@clerk.dev>
+clerk.app
+clerkstage.app
+*.lcl.dev
+*.lclstage.dev
+*.stg.dev
+*.stgstage.dev
+
+// ClickRising : https://clickrising.com/
+// Submitted by Umut Gumeli <infrastructure-publicsuffixlist@clickrising.com>
+clickrising.net
+
+// Cloud66 : https://www.cloud66.com/
+// Submitted by Khash Sajadi <khash@cloud66.com>
+c66.me
+cloud66.ws
+cloud66.zone
+
+// CloudAccess.net : https://www.cloudaccess.net/
+// Submitted by Pawel Panek <noc@cloudaccess.net>
+jdevcloud.com
+wpdevcloud.com
+cloudaccess.host
+freesite.host
+cloudaccess.net
+
+// cloudControl : https://www.cloudcontrol.com/
+// Submitted by Tobias Wilken <tw@cloudcontrol.com>
+cloudcontrolapp.com
+cloudcontrolled.com
+
+// Cloudera, Inc. : https://www.cloudera.com/
+// Submitted by Kedarnath Waikar <security@cloudera.com>
+*.cloudera.site
+
+// Cloudflare, Inc. : https://www.cloudflare.com/
+// Submitted by Cloudflare Team <publicsuffixlist@cloudflare.com>
+cf-ipfs.com
+cloudflare-ipfs.com
+trycloudflare.com
+pages.dev
+r2.dev
+workers.dev
+cdn.cloudflareanycast.net
+cdn.cloudflarecn.net
+cdn.cloudflareglobal.net
+cloudflare.net
+cdn.cloudflare.net
+
+// cloudscale.ch AG : https://www.cloudscale.ch/
+// Submitted by Gaudenz Steinlin <support@cloudscale.ch>
+cust.cloudscale.ch
+objects.lpg.cloudscale.ch
+objects.rma.cloudscale.ch
+
+// Clovyr : https://clovyr.io
+// Submitted by Patrick Nielsen <patrick@clovyr.io>
+wnext.app
+
+// co.ca : http://registry.co.ca/
+co.ca
+
+// Co & Co : https://co-co.nl/
+// Submitted by Govert Versluis <govert@co-co.nl>
+*.otap.co
+
+// i-registry s.r.o. : http://www.i-registry.cz/
+// Submitted by Martin Semrad <semrad@i-registry.cz>
+co.cz
+
+// CDN77.com : http://www.cdn77.com
+// Submitted by Jan Krpes <jan.krpes@cdn77.com>
+cdn77-storage.com
+rsc.contentproxy9.cz
+r.cdn77.net
+cdn77-ssl.net
+c.cdn77.org
+rsc.cdn77.org
+ssl.origin.cdn77-secure.org
+
+// Cloud DNS Ltd : http://www.cloudns.net
+// Submitted by Aleksander Hristov <noc@cloudns.net> & Boyan Peychev <boyan@cloudns.net>
+cloudns.asia
+cloudns.be
+cloudns.biz
+cloudns.cc
+cloudns.ch
+cloudns.cl
+cloudns.club
+dnsabr.com
+cloudns.cx
+cloudns.eu
+cloudns.in
+cloudns.info
+dns-cloud.net
+dns-dynamic.net
+cloudns.nz
+cloudns.org
+cloudns.ph
+cloudns.pro
+cloudns.pw
+cloudns.us
+
+// CNPY : https://cnpy.gdn
+// Submitted by Angelo Gladding <angelo@lahacker.net>
+cnpy.gdn
+
+// Codeberg e. V. : https://codeberg.org
+// Submitted by Moritz Marquardt <git@momar.de>
+codeberg.page
+
+// CodeSandbox B.V. : https://codesandbox.io
+// Submitted by Ives van Hoorne <abuse@codesandbox.io>
+csb.app
+preview.csb.app
+
+// CoDNS B.V.
+co.nl
+co.no
+
+// Combell.com : https://www.combell.com
+// Submitted by Thomas Wouters <thomas.wouters@combellgroup.com>
+webhosting.be
+hosting-cluster.nl
+
+// Convex : https://convex.dev/
+// Submitted by James Cowling <security@convex.dev>
+convex.site
+
+// Coordination Center for TLD RU and XN--P1AI : https://cctld.ru/en/domains/domens_ru/reserved/
+// Submitted by George Georgievsky <gug@cctld.ru>
+ac.ru
+edu.ru
+gov.ru
+int.ru
+mil.ru
+test.ru
+
+// COSIMO GmbH : http://www.cosimo.de
+// Submitted by Rene Marticke <rmarticke@cosimo.de>
+dyn.cosidns.de
+dnsupdater.de
+dynamisches-dns.de
+internet-dns.de
+l-o-g-i-n.de
+dynamic-dns.info
+feste-ip.net
+knx-server.net
+static-access.net
+
+// Craft Docs Ltd : https://www.craft.do/
+// Submitted by Zsombor Fuszenecker <security@craft.do>
+craft.me
+
+// Craynic, s.r.o. : http://www.craynic.com/
+// Submitted by Ales Krajnik <ales.krajnik@craynic.com>
+realm.cz
+
+// Crisp IM SAS : https://crisp.chat/
+// Submitted by Baptiste Jamin <hostmaster@crisp.chat>
+on.crisp.email
+
+// Cryptonomic : https://cryptonomic.net/
+// Submitted by Andrew Cady <public-suffix-list@cryptonomic.net>
+*.cryptonomic.net
+
+// Cupcake : https://cupcake.io/
+// Submitted by Jonathan Rudenberg <jonathan@cupcake.io>
+cupcake.is
+
+// Curv UG : https://curv-labs.de/
+// Submitted by Marvin Wiesner <Marvin@curv-labs.de>
+curv.dev
+
+// Customer OCI - Oracle Dyn https://cloud.oracle.com/home https://dyn.com/dns/
+// Submitted by Gregory Drake <support@dyn.com>
+// Note: This is intended to also include customer-oci.com due to wildcards implicitly including the current label
+*.customer-oci.com
+*.oci.customer-oci.com
+*.ocp.customer-oci.com
+*.ocs.customer-oci.com
+
+// cyber_Folks S.A. : https://cyberfolks.pl
+// Submitted by Bartlomiej Kida <security@cyberfolks.pl>
+cfolks.pl
+
+// Cyclic Software : https://www.cyclic.sh
+// Submitted by Kam Lasater <dns-admin@cyclic.sh>
+cyclic.app
+cyclic.cloud
+cyclic-app.com
+cyclic.co.in
+
+// cyon GmbH : https://www.cyon.ch/
+// Submitted by Dominic Luechinger <dol@cyon.ch>
+cyon.link
+cyon.site
+
+// Danger Science Group: https://dangerscience.com/
+// Submitted by Skylar MacDonald <skylar@dangerscience.com>
+platform0.app
+fnwk.site
+folionetwork.site
+
+// Daplie, Inc : https://daplie.com
+// Submitted by AJ ONeal <aj@daplie.com>
+daplie.me
+localhost.daplie.me
+
+// Datto, Inc. : https://www.datto.com/
+// Submitted by Philipp Heckel <ph@datto.com>
+dattolocal.com
+dattorelay.com
+dattoweb.com
+mydatto.com
+dattolocal.net
+mydatto.net
+
+// Dansk.net : http://www.dansk.net/
+// Submitted by Anani Voule <digital@digital.co.dk>
+biz.dk
+co.dk
+firm.dk
+reg.dk
+store.dk
+
+// dappnode.io : https://dappnode.io/
+// Submitted by Abel Boldu / DAppNode Team <community@dappnode.io>
+dyndns.dappnode.io
+
+// dapps.earth : https://dapps.earth/
+// Submitted by Daniil Burdakov <icqkill@gmail.com>
+*.dapps.earth
+*.bzz.dapps.earth
+
+// Dark, Inc. : https://darklang.com
+// Submitted by Paul Biggar <ops@darklang.com>
+builtwithdark.com
+darklang.io
+
+// DataDetect, LLC. : https://datadetect.com
+// Submitted by Andrew Banchich <abanchich@sceven.com>
+demo.datadetect.com
+instance.datadetect.com
+
+// Datawire, Inc : https://www.datawire.io
+// Submitted by Richard Li <secalert@datawire.io>
+edgestack.me
+
+// DDNS5 : https://ddns5.com
+// Submitted by Cameron Elliott <cameron@cameronelliott.com>
+ddns5.com
+
+// Debian : https://www.debian.org/
+// Submitted by Peter Palfrader / Debian Sysadmin Team <dsa-publicsuffixlist@debian.org>
+debian.net
+
+// Deno Land Inc : https://deno.com/
+// Submitted by Luca Casonato <hostmaster@deno.com>
+deno.dev
+deno-staging.dev
+
+// deSEC : https://desec.io/
+// Submitted by Peter Thomassen <peter@desec.io>
+dedyn.io
+
+// Deta: https://www.deta.sh/
+// Submitted by Aavash Shrestha <aavash@deta.sh>
+deta.app
+deta.dev
+
+// dhosting.pl Sp. z o.o.: https://dhosting.pl/
+// Submitted by Michal Kokoszkiewicz <bok@dhosting.pl>
+dfirma.pl
+dkonto.pl
+you2.pl
+
+// Diher Solutions : https://diher.solutions
+// Submitted by Didi Hermawan <mail@diher.solutions>
+*.rss.my.id
+*.diher.solutions
+
+// Discord Inc : https://discord.com
+// Submitted by Sahn Lam <slam@discordapp.com>
+discordsays.com
+discordsez.com
+
+// DNS Africa Ltd https://dns.business
+// Submitted by Calvin Browne <calvin@dns.business>
+jozi.biz
+
+// DNShome : https://www.dnshome.de/
+// Submitted by Norbert Auler <mail@dnshome.de>
+dnshome.de
+
+// DotArai : https://www.dotarai.com/
+// Submitted by Atsadawat Netcharadsang <atsadawat@dotarai.co.th>
+online.th
+shop.th
+
+// DrayTek Corp. : https://www.draytek.com/
+// Submitted by Paul Fang <mis@draytek.com>
+drayddns.com
+
+// DreamCommerce : https://shoper.pl/
+// Submitted by Konrad Kotarba <konrad.kotarba@dreamcommerce.com>
+shoparena.pl
+
+// DreamHost : http://www.dreamhost.com/
+// Submitted by Andrew Farmer <andrew.farmer@dreamhost.com>
+dreamhosters.com
+
+// Dreamyoungs, Inc. : https://durumis.com
+// Submitted by Infra Team <infra@durumis.com>
+durumis.com
+
+// Drobo : http://www.drobo.com/
+// Submitted by Ricardo Padilha <rpadilha@drobo.com>
+mydrobo.com
+
+// Drud Holdings, LLC. : https://www.drud.com/
+// Submitted by Kevin Bridges <kevin@drud.com>
+drud.io
+drud.us
+
+// DuckDNS : http://www.duckdns.org/
+// Submitted by Richard Harper <richard@duckdns.org>
+duckdns.org
+
+// Bip : https://bip.sh
+// Submitted by Joel Kennedy <joel@bip.sh>
+bip.sh
+
+// bitbridge.net : Submitted by Craig Welch, abeliidev@gmail.com
+bitbridge.net
+
+// dy.fi : http://dy.fi/
+// Submitted by Heikki Hannikainen <hessu@hes.iki.fi>
+dy.fi
+tunk.org
+
+// DynDNS.com : http://www.dyndns.com/services/dns/dyndns/
+dyndns.biz
+for-better.biz
+for-more.biz
+for-some.biz
+for-the.biz
+selfip.biz
+webhop.biz
+ftpaccess.cc
+game-server.cc
+myphotos.cc
+scrapping.cc
+blogdns.com
+cechire.com
+dnsalias.com
+dnsdojo.com
+doesntexist.com
+dontexist.com
+doomdns.com
+dyn-o-saur.com
+dynalias.com
+dyndns-at-home.com
+dyndns-at-work.com
+dyndns-blog.com
+dyndns-free.com
+dyndns-home.com
+dyndns-ip.com
+dyndns-mail.com
+dyndns-office.com
+dyndns-pics.com
+dyndns-remote.com
+dyndns-server.com
+dyndns-web.com
+dyndns-wiki.com
+dyndns-work.com
+est-a-la-maison.com
+est-a-la-masion.com
+est-le-patron.com
+est-mon-blogueur.com
+from-ak.com
+from-al.com
+from-ar.com
+from-ca.com
+from-ct.com
+from-dc.com
+from-de.com
+from-fl.com
+from-ga.com
+from-hi.com
+from-ia.com
+from-id.com
+from-il.com
+from-in.com
+from-ks.com
+from-ky.com
+from-ma.com
+from-md.com
+from-mi.com
+from-mn.com
+from-mo.com
+from-ms.com
+from-mt.com
+from-nc.com
+from-nd.com
+from-ne.com
+from-nh.com
+from-nj.com
+from-nm.com
+from-nv.com
+from-oh.com
+from-ok.com
+from-or.com
+from-pa.com
+from-pr.com
+from-ri.com
+from-sc.com
+from-sd.com
+from-tn.com
+from-tx.com
+from-ut.com
+from-va.com
+from-vt.com
+from-wa.com
+from-wi.com
+from-wv.com
+from-wy.com
+getmyip.com
+gotdns.com
+hobby-site.com
+homelinux.com
+homeunix.com
+iamallama.com
+is-a-anarchist.com
+is-a-blogger.com
+is-a-bookkeeper.com
+is-a-bulls-fan.com
+is-a-caterer.com
+is-a-chef.com
+is-a-conservative.com
+is-a-cpa.com
+is-a-cubicle-slave.com
+is-a-democrat.com
+is-a-designer.com
+is-a-doctor.com
+is-a-financialadvisor.com
+is-a-geek.com
+is-a-green.com
+is-a-guru.com
+is-a-hard-worker.com
+is-a-hunter.com
+is-a-landscaper.com
+is-a-lawyer.com
+is-a-liberal.com
+is-a-libertarian.com
+is-a-llama.com
+is-a-musician.com
+is-a-nascarfan.com
+is-a-nurse.com
+is-a-painter.com
+is-a-personaltrainer.com
+is-a-photographer.com
+is-a-player.com
+is-a-republican.com
+is-a-rockstar.com
+is-a-socialist.com
+is-a-student.com
+is-a-teacher.com
+is-a-techie.com
+is-a-therapist.com
+is-an-accountant.com
+is-an-actor.com
+is-an-actress.com
+is-an-anarchist.com
+is-an-artist.com
+is-an-engineer.com
+is-an-entertainer.com
+is-certified.com
+is-gone.com
+is-into-anime.com
+is-into-cars.com
+is-into-cartoons.com
+is-into-games.com
+is-leet.com
+is-not-certified.com
+is-slick.com
+is-uberleet.com
+is-with-theband.com
+isa-geek.com
+isa-hockeynut.com
+issmarterthanyou.com
+likes-pie.com
+likescandy.com
+neat-url.com
+saves-the-whales.com
+selfip.com
+sells-for-less.com
+sells-for-u.com
+servebbs.com
+simple-url.com
+space-to-rent.com
+teaches-yoga.com
+writesthisblog.com
+ath.cx
+fuettertdasnetz.de
+isteingeek.de
+istmein.de
+lebtimnetz.de
+leitungsen.de
+traeumtgerade.de
+barrel-of-knowledge.info
+barrell-of-knowledge.info
+dyndns.info
+for-our.info
+groks-the.info
+groks-this.info
+here-for-more.info
+knowsitall.info
+selfip.info
+webhop.info
+forgot.her.name
+forgot.his.name
+at-band-camp.net
+blogdns.net
+broke-it.net
+buyshouses.net
+dnsalias.net
+dnsdojo.net
+does-it.net
+dontexist.net
+dynalias.net
+dynathome.net
+endofinternet.net
+from-az.net
+from-co.net
+from-la.net
+from-ny.net
+gets-it.net
+ham-radio-op.net
+homeftp.net
+homeip.net
+homelinux.net
+homeunix.net
+in-the-band.net
+is-a-chef.net
+is-a-geek.net
+isa-geek.net
+kicks-ass.net
+office-on-the.net
+podzone.net
+scrapper-site.net
+selfip.net
+sells-it.net
+servebbs.net
+serveftp.net
+thruhere.net
+webhop.net
+merseine.nu
+mine.nu
+shacknet.nu
+blogdns.org
+blogsite.org
+boldlygoingnowhere.org
+dnsalias.org
+dnsdojo.org
+doesntexist.org
+dontexist.org
+doomdns.org
+dvrdns.org
+dynalias.org
+dyndns.org
+go.dyndns.org
+home.dyndns.org
+endofinternet.org
+endoftheinternet.org
+from-me.org
+game-host.org
+gotdns.org
+hobby-site.org
+homedns.org
+homeftp.org
+homelinux.org
+homeunix.org
+is-a-bruinsfan.org
+is-a-candidate.org
+is-a-celticsfan.org
+is-a-chef.org
+is-a-geek.org
+is-a-knight.org
+is-a-linux-user.org
+is-a-patsfan.org
+is-a-soxfan.org
+is-found.org
+is-lost.org
+is-saved.org
+is-very-bad.org
+is-very-evil.org
+is-very-good.org
+is-very-nice.org
+is-very-sweet.org
+isa-geek.org
+kicks-ass.org
+misconfused.org
+podzone.org
+readmyblog.org
+selfip.org
+sellsyourhome.org
+servebbs.org
+serveftp.org
+servegame.org
+stuff-4-sale.org
+webhop.org
+better-than.tv
+dyndns.tv
+on-the-web.tv
+worse-than.tv
+is-by.us
+land-4-sale.us
+stuff-4-sale.us
+dyndns.ws
+mypets.ws
+
+// ddnss.de : https://www.ddnss.de/
+// Submitted by Robert Niedziela <webmaster@ddnss.de>
+ddnss.de
+dyn.ddnss.de
+dyndns.ddnss.de
+dyn-ip24.de
+dyndns1.de
+home-webserver.de
+dyn.home-webserver.de
+myhome-server.de
+ddnss.org
+
+// Definima : http://www.definima.com/
+// Submitted by Maxence Bitterli <maxence@definima.com>
+definima.io
+definima.net
+
+// DigitalOcean App Platform : https://www.digitalocean.com/products/app-platform/
+// Submitted by Braxton Huggins <psl-maintainers@digitalocean.com>
+ondigitalocean.app
+
+// DigitalOcean Spaces : https://www.digitalocean.com/products/spaces/
+// Submitted by Robin H. Johnson <psl-maintainers@digitalocean.com>
+*.digitaloceanspaces.com
+
+// DigitalPlat : https://www.digitalplat.org/
+// Submitted by Edward Hsing <contact@digitalplat.org>
+us.kg
+
+// dnstrace.pro : https://dnstrace.pro/
+// Submitted by Chris Partridge <chris@partridge.tech>
+bci.dnstrace.pro
+
+// Dynu.com : https://www.dynu.com/
+// Submitted by Sue Ye <sue@dynu.com>
+ddnsfree.com
+ddnsgeek.com
+giize.com
+gleeze.com
+kozow.com
+loseyourip.com
+ooguy.com
+theworkpc.com
+casacam.net
+dynu.net
+accesscam.org
+camdvr.org
+freeddns.org
+mywire.org
+webredirect.org
+myddns.rocks
+blogsite.xyz
+
+// dynv6 : https://dynv6.com
+// Submitted by Dominik Menke <dom@digineo.de>
+dynv6.net
+
+// E4YOU spol. s.r.o. : https://e4you.cz/
+// Submitted by Vladimir Dudr <info@e4you.cz>
+e4.cz
+
+// Easypanel : https://easypanel.io
+// Submitted by Andrei Canta <andrei@easypanel.io>
+easypanel.app
+easypanel.host
+
+// EasyWP : https://www.easywp.com
+// Submitted by <infracloudteam@namecheap.com>
+*.ewp.live
+
+// eDirect Corp. : https://hosting.url.com.tw/
+// Submitted by C.S. chang <cschang@corp.url.com.tw>
+twmail.cc
+twmail.net
+twmail.org
+mymailer.com.tw
+url.tw
+
+// Electromagnetic Field : https://www.emfcamp.org
+// Submitted by <noc@emfcamp.org>
+at.emf.camp
+
+// Elefunc, Inc. : https://elefunc.com
+// Submitted by Cetin Sert <domains@elefunc.com>
+rt.ht
+
+// Elementor : Elementor Ltd.
+// Submitted by Anton Barkan <antonb@elementor.com>
+elementor.cloud
+elementor.cool
+
+// En root‽ : https://en-root.org
+// Submitted by Emmanuel Raviart <emmanuel@raviart.com>
+en-root.fr
+
+// Enalean SAS: https://www.enalean.com
+// Submitted by Enalean Security Team <security@enalean.com>
+mytuleap.com
+tuleap-partners.com
+
+// Encoretivity AB: https://encore.dev
+// Submitted by André Eriksson <andre@encore.dev>
+encr.app
+encoreapi.com
+
+// ECG Robotics, Inc: https://ecgrobotics.org
+// Submitted by <frc1533@ecgrobotics.org>
+onred.one
+staging.onred.one
+
+// encoway GmbH : https://www.encoway.de
+// Submitted by Marcel Daus <cloudops@encoway.de>
+eu.encoway.cloud
+
+// EU.org https://eu.org/
+// Submitted by Pierre Beyssac <hostmaster@eu.org>
+eu.org
+al.eu.org
+asso.eu.org
+at.eu.org
+au.eu.org
+be.eu.org
+bg.eu.org
+ca.eu.org
+cd.eu.org
+ch.eu.org
+cn.eu.org
+cy.eu.org
+cz.eu.org
+de.eu.org
+dk.eu.org
+edu.eu.org
+ee.eu.org
+es.eu.org
+fi.eu.org
+fr.eu.org
+gr.eu.org
+hr.eu.org
+hu.eu.org
+ie.eu.org
+il.eu.org
+in.eu.org
+int.eu.org
+is.eu.org
+it.eu.org
+jp.eu.org
+kr.eu.org
+lt.eu.org
+lu.eu.org
+lv.eu.org
+mc.eu.org
+me.eu.org
+mk.eu.org
+mt.eu.org
+my.eu.org
+net.eu.org
+ng.eu.org
+nl.eu.org
+no.eu.org
+nz.eu.org
+paris.eu.org
+pl.eu.org
+pt.eu.org
+q-a.eu.org
+ro.eu.org
+ru.eu.org
+se.eu.org
+si.eu.org
+sk.eu.org
+tr.eu.org
+uk.eu.org
+us.eu.org
+
+// Eurobyte : https://eurobyte.ru
+// Submitted by Evgeniy Subbotin <e.subbotin@eurobyte.ru>
+eurodir.ru
+
+// Evennode : http://www.evennode.com/
+// Submitted by Michal Kralik <support@evennode.com>
+eu-1.evennode.com
+eu-2.evennode.com
+eu-3.evennode.com
+eu-4.evennode.com
+us-1.evennode.com
+us-2.evennode.com
+us-3.evennode.com
+us-4.evennode.com
+
+// Evervault : https://evervault.com
+// Submitted by Hannah Neary <engineering@evervault.com>
+relay.evervault.app
+relay.evervault.dev
+
+// Expo : https://expo.dev/
+// Submitted by James Ide <psl@expo.dev>
+expo.app
+staging.expo.app
+
+// Fabrica Technologies, Inc. : https://www.fabrica.dev/
+// Submitted by Eric Jiang <eric@fabrica.dev>
+onfabrica.com
+
+// FAITID : https://faitid.org/
+// Submitted by Maxim Alzoba <tech.contact@faitid.org>
+// https://www.flexireg.net/stat_info
+ru.net
+adygeya.ru
+bashkiria.ru
+bir.ru
+cbg.ru
+com.ru
+dagestan.ru
+grozny.ru
+kalmykia.ru
+kustanai.ru
+marine.ru
+mordovia.ru
+msk.ru
+mytis.ru
+nalchik.ru
+nov.ru
+pyatigorsk.ru
+spb.ru
+vladikavkaz.ru
+vladimir.ru
+abkhazia.su
+adygeya.su
+aktyubinsk.su
+arkhangelsk.su
+armenia.su
+ashgabad.su
+azerbaijan.su
+balashov.su
+bashkiria.su
+bryansk.su
+bukhara.su
+chimkent.su
+dagestan.su
+east-kazakhstan.su
+exnet.su
+georgia.su
+grozny.su
+ivanovo.su
+jambyl.su
+kalmykia.su
+kaluga.su
+karacol.su
+karaganda.su
+karelia.su
+khakassia.su
+krasnodar.su
+kurgan.su
+kustanai.su
+lenug.su
+mangyshlak.su
+mordovia.su
+msk.su
+murmansk.su
+nalchik.su
+navoi.su
+north-kazakhstan.su
+nov.su
+obninsk.su
+penza.su
+pokrovsk.su
+sochi.su
+spb.su
+tashkent.su
+termez.su
+togliatti.su
+troitsk.su
+tselinograd.su
+tula.su
+tuva.su
+vladikavkaz.su
+vladimir.su
+vologda.su
+
+// Fancy Bits, LLC : http://getchannels.com
+// Submitted by Aman Gupta <aman@getchannels.com>
+channelsdvr.net
+u.channelsdvr.net
+
+// Fastly Inc. : http://www.fastly.com/
+// Submitted by Fastly Security <security@fastly.com>
+edgecompute.app
+fastly-edge.com
+fastly-terrarium.com
+freetls.fastly.net
+map.fastly.net
+a.prod.fastly.net
+global.prod.fastly.net
+a.ssl.fastly.net
+b.ssl.fastly.net
+global.ssl.fastly.net
+fastlylb.net
+map.fastlylb.net
+
+// Fastmail : https://www.fastmail.com/
+// Submitted by Marc Bradshaw <marc@fastmailteam.com>
+*.user.fm
+
+// FASTVPS EESTI OU : https://fastvps.ru/
+// Submitted by Likhachev Vasiliy <lihachev@fastvps.ru>
+fastvps-server.com
+fastvps.host
+myfast.host
+fastvps.site
+myfast.space
+
+// Fedora : https://fedoraproject.org/
+// submitted by Patrick Uiterwijk <puiterwijk@fedoraproject.org>
+fedorainfracloud.org
+fedorapeople.org
+cloud.fedoraproject.org
+app.os.fedoraproject.org
+app.os.stg.fedoraproject.org
+
+// FearWorks Media Ltd. : https://fearworksmedia.co.uk
+// submitted by Keith Fairley <domains@fearworksmedia.co.uk>
+conn.uk
+copro.uk
+hosp.uk
+
+// Fermax : https://fermax.com/
+// submitted by Koen Van Isterdael <k.vanisterdael@fermax.be>
+mydobiss.com
+
+// FH Muenster : https://www.fh-muenster.de
+// Submitted by Robin Naundorf <r.naundorf@fh-muenster.de>
+fh-muenster.io
+
+// Filegear Inc. : https://www.filegear.com
+// Submitted by Jason Zhu <jason@owtware.com>
+filegear.me
+filegear-au.me
+filegear-de.me
+filegear-gb.me
+filegear-ie.me
+filegear-jp.me
+filegear-sg.me
+
+// Firebase, Inc.
+// Submitted by Chris Raynor <chris@firebase.com>
+firebaseapp.com
+
+// Firewebkit : https://www.firewebkit.com
+// Submitted by Majid Qureshi <mqureshi@amrayn.com>
+fireweb.app
+
+// FLAP : https://www.flap.cloud
+// Submitted by Louis Chemineau <louis@chmn.me>
+flap.id
+
+// FlashDrive : https://flashdrive.io
+// Submitted by Eric Chan <support@flashdrive.io>
+onflashdrive.app
+fldrv.com
+
+// FlutterFlow : https://flutterflow.io
+// Submitted by Anton Emelyanov <anton@flutterflow.io>
+flutterflow.app
+
+// fly.io: https://fly.io
+// Submitted by Kurt Mackey <kurt@fly.io>
+fly.dev
+shw.io
+edgeapp.net
+
+// Flynn : https://flynn.io
+// Submitted by Jonathan Rudenberg <jonathan@flynn.io>
+flynnhosting.net
+
+// Forgerock : https://www.forgerock.com
+// Submitted by Roderick Parr <roderick.parr@forgerock.com>
+forgeblocks.com
+id.forgerock.io
+
+// Framer : https://www.framer.com
+// Submitted by Koen Rouwhorst <security@framer.com>
+framer.ai
+framer.app
+framercanvas.com
+framer.media
+framer.photos
+framer.website
+framer.wiki
+
+// Frusky MEDIA&PR : https://www.frusky.de
+// Submitted by Victor Pupynin <hallo@frusky.de>
+*.frusky.de
+
+// RavPage : https://www.ravpage.co.il
+// Submitted by Roni Horowitz <roni@responder.co.il>
+ravpage.co.il
+
+// Frederik Braun https://frederik-braun.com
+// Submitted by Frederik Braun <fb@frederik-braun.com>
+0e.vc
+
+// Freebox : http://www.freebox.fr
+// Submitted by Romain Fliedel <rfliedel@freebox.fr>
+freebox-os.com
+freeboxos.com
+fbx-os.fr
+fbxos.fr
+freebox-os.fr
+freeboxos.fr
+
+// freedesktop.org : https://www.freedesktop.org
+// Submitted by Daniel Stone <daniel@fooishbar.org>
+freedesktop.org
+
+// freemyip.com : https://freemyip.com
+// Submitted by Cadence <contact@freemyip.com>
+freemyip.com
+
+// FunkFeuer - Verein zur Förderung freier Netze : https://www.funkfeuer.at
+// Submitted by Daniel A. Maierhofer <vorstand@funkfeuer.at>
+wien.funkfeuer.at
+
+// Future Versatile Group. : https://www.fvg-on.net/
+// T.Kabu <webmaster@fvg-on.net>
+daemon.asia
+dix.asia
+mydns.bz
+0am.jp
+0g0.jp
+0j0.jp
+0t0.jp
+mydns.jp
+pgw.jp
+wjg.jp
+keyword-on.net
+live-on.net
+server-on.net
+mydns.tw
+mydns.vc
+
+// Futureweb GmbH : https://www.futureweb.at
+// Submitted by Andreas Schnederle-Wagner <schnederle@futureweb.at>
+*.futurecms.at
+*.ex.futurecms.at
+*.in.futurecms.at
+futurehosting.at
+futuremailing.at
+*.ex.ortsinfo.at
+*.kunden.ortsinfo.at
+*.statics.cloud
+
+// GCom Internet : https://www.gcom.net.au
+// Submitted by Leo Julius <support@gcom.net.au>
+aliases121.com
+
+// GDS : https://www.gov.uk/service-manual/technology/managing-domain-names
+// Submitted by Stephen Ford <hostmaster@digital.cabinet-office.gov.uk>
+campaign.gov.uk
+service.gov.uk
+independent-commission.uk
+independent-inquest.uk
+independent-inquiry.uk
+independent-panel.uk
+independent-review.uk
+public-inquiry.uk
+royal-commission.uk
+
+// CDDO : https://www.gov.uk/guidance/get-an-api-domain-on-govuk
+// Submitted by Jamie Tanna <jamie.tanna@digital.cabinet-office.gov.uk>
+api.gov.uk
+
+// Gehirn Inc. : https://www.gehirn.co.jp/
+// Submitted by Kohei YOSHIDA <tech@gehirn.co.jp>
+gehirn.ne.jp
+usercontent.jp
+
+// Gentlent, Inc. : https://www.gentlent.com
+// Submitted by Tom Klein <tom@gentlent.com>
+gentapps.com
+gentlentapis.com
+lab.ms
+cdn-edges.net
+
+// Getlocalcert: https://www.getlocalcert.net
+// Submitted by Robert Alexander <support@getlocalcert.net>
+localcert.net
+localhostcert.net
+corpnet.work
+
+// GignoSystemJapan: http://gsj.bz
+// Submitted by GignoSystemJapan <kakutou-ec@gsj.bz>
+gsj.bz
+
+// GitHub, Inc.
+// Submitted by Patrick Toomey <security@github.com>
+githubusercontent.com
+githubpreview.dev
+github.io
+
+// GitLab, Inc.
+// Submitted by Alex Hanselka <alex@gitlab.com>
+gitlab.io
+
+// Gitplac.si - https://gitplac.si
+// Submitted by Aljaž Starc <me@aljaxus.eu>
+gitapp.si
+gitpage.si
+
+// Glitch, Inc : https://glitch.com
+// Submitted by Mads Hartmann <mads@glitch.com>
+glitch.me
+
+// Global NOG Alliance : https://nogalliance.org/
+// Submitted by Sander Steffann <sander@nogalliance.org>
+nog.community
+
+// Globe Hosting SRL : https://www.globehosting.com/
+// Submitted by Gavin Brown <gavin.brown@centralnic.com>
+co.ro
+shop.ro
+
+// GMO Pepabo, Inc. : https://pepabo.com/
+// Submitted by Hosting Div <admin@pepabo.com>
+lolipop.io
+angry.jp
+babyblue.jp
+babymilk.jp
+backdrop.jp
+bambina.jp
+bitter.jp
+blush.jp
+boo.jp
+boy.jp
+boyfriend.jp
+but.jp
+candypop.jp
+capoo.jp
+catfood.jp
+cheap.jp
+chicappa.jp
+chillout.jp
+chips.jp
+chowder.jp
+chu.jp
+ciao.jp
+cocotte.jp
+coolblog.jp
+cranky.jp
+cutegirl.jp
+daa.jp
+deca.jp
+deci.jp
+digick.jp
+egoism.jp
+fakefur.jp
+fem.jp
+flier.jp
+floppy.jp
+fool.jp
+frenchkiss.jp
+girlfriend.jp
+girly.jp
+gloomy.jp
+gonna.jp
+greater.jp
+hacca.jp
+heavy.jp
+her.jp
+hiho.jp
+hippy.jp
+holy.jp
+hungry.jp
+icurus.jp
+itigo.jp
+jellybean.jp
+kikirara.jp
+kill.jp
+kilo.jp
+kuron.jp
+littlestar.jp
+lolipopmc.jp
+lolitapunk.jp
+lomo.jp
+lovepop.jp
+lovesick.jp
+main.jp
+mods.jp
+mond.jp
+mongolian.jp
+moo.jp
+namaste.jp
+nikita.jp
+nobushi.jp
+noor.jp
+oops.jp
+parallel.jp
+parasite.jp
+pecori.jp
+peewee.jp
+penne.jp
+pepper.jp
+perma.jp
+pigboat.jp
+pinoko.jp
+punyu.jp
+pupu.jp
+pussycat.jp
+pya.jp
+raindrop.jp
+readymade.jp
+sadist.jp
+schoolbus.jp
+secret.jp
+staba.jp
+stripper.jp
+sub.jp
+sunnyday.jp
+thick.jp
+tonkotsu.jp
+under.jp
+upper.jp
+velvet.jp
+verse.jp
+versus.jp
+vivian.jp
+watson.jp
+weblike.jp
+whitesnow.jp
+zombie.jp
+heteml.net
+
+// GoDaddy Registry : https://registry.godaddy
+// Submitted by Rohan Durrant <tldns@registry.godaddy>
+graphic.design
+
+// GOV.UK Platform as a Service : https://www.cloud.service.gov.uk/
+// Submitted by Tom Whitwell <gov-uk-paas-support@digital.cabinet-office.gov.uk>
+cloudapps.digital
+london.cloudapps.digital
+
+// GOV.UK Pay : https://www.payments.service.gov.uk/
+// Submitted by Richard Baker <richard.baker@digital.cabinet-office.gov.uk>
+pymnt.uk
+
+// GoIP DNS Services : http://www.goip.de
+// Submitted by Christian Poulter <milchstrasse@goip.de>
+goip.de
+
+// Google, Inc.
+// Submitted by Shannon McCabe <public-suffix-editors@google.com>
+blogspot.ae
+blogspot.al
+blogspot.am
+*.hosted.app
+*.run.app
+web.app
+blogspot.com.ar
+blogspot.co.at
+blogspot.com.au
+blogspot.ba
+blogspot.be
+blogspot.bg
+blogspot.bj
+blogspot.com.br
+blogspot.com.by
+blogspot.ca
+blogspot.cf
+blogspot.ch
+blogspot.cl
+blogspot.com.co
+*.0emm.com
+appspot.com
+*.r.appspot.com
+blogspot.com
+codespot.com
+googleapis.com
+googlecode.com
+pagespeedmobilizer.com
+publishproxy.com
+withgoogle.com
+withyoutube.com
+blogspot.cv
+blogspot.com.cy
+blogspot.cz
+blogspot.de
+*.gateway.dev
+blogspot.dk
+blogspot.com.ee
+blogspot.com.eg
+blogspot.com.es
+blogspot.fi
+blogspot.fr
+cloud.goog
+translate.goog
+*.usercontent.goog
+blogspot.gr
+blogspot.hk
+blogspot.hr
+blogspot.hu
+blogspot.co.id
+blogspot.ie
+blogspot.co.il
+blogspot.in
+blogspot.is
+blogspot.it
+blogspot.jp
+blogspot.co.ke
+blogspot.kr
+blogspot.li
+blogspot.lt
+blogspot.lu
+blogspot.md
+blogspot.mk
+blogspot.mr
+blogspot.com.mt
+blogspot.mx
+blogspot.my
+cloudfunctions.net
+blogspot.com.ng
+blogspot.nl
+blogspot.no
+blogspot.co.nz
+blogspot.pe
+blogspot.pt
+blogspot.qa
+blogspot.re
+blogspot.ro
+blogspot.rs
+blogspot.ru
+blogspot.se
+blogspot.sg
+blogspot.si
+blogspot.sk
+blogspot.sn
+blogspot.td
+blogspot.com.tr
+blogspot.tw
+blogspot.ug
+blogspot.co.uk
+blogspot.com.uy
+blogspot.vn
+blogspot.co.za
+
+// Goupile : https://goupile.fr
+// Submitted by Niels Martignene <hello@goupile.fr>
+goupile.fr
+
+// Government of the Netherlands: https://www.government.nl
+// Submitted by <domeinnaam@minaz.nl>
+gov.nl
+
+// GrayJay Web Solutions Inc. : https://grayjaysports.ca
+// Submitted by Matt Yamkowy <info@grayjaysports.ca>
+grayjayleagues.com
+
+// Group 53, LLC : https://www.group53.com
+// Submitted by Tyler Todd <noc@nova53.net>
+awsmppl.com
+
+// GünstigBestellen : https://günstigbestellen.de
+// Submitted by Furkan Akkoc <info@hendelzon.de>
+günstigbestellen.de
+günstigliefern.de
+
+// Hakaran group: http://hakaran.cz
+// Submitted by Arseniy Sokolov <security@hakaran.cz>
+fin.ci
+free.hr
+caa.li
+ua.rs
+conf.se
+
+// Handshake : https://handshake.org
+// Submitted by Mike Damm <md@md.vc>
+hs.run
+hs.zone
+
+// Hashbang : https://hashbang.sh
+hashbang.sh
+
+// Hasura : https://hasura.io
+// Submitted by Shahidh K Muhammed <shahidh@hasura.io>
+hasura.app
+hasura-app.io
+
+// Hatena Co., Ltd. : https://hatena.co.jp
+// Submitted by Masato Nakamura <blog-developers@hatena.ne.jp>
+hatenablog.com
+hatenadiary.com
+hateblo.jp
+hatenablog.jp
+hatenadiary.jp
+hatenadiary.org
+
+// Heilbronn University of Applied Sciences - Faculty Informatics (GitLab Pages): https://www.hs-heilbronn.de
+// Submitted by Richard Zowalla <mi-admin@hs-heilbronn.de>
+pages.it.hs-heilbronn.de
+
+// Helio Networks : https://heliohost.org
+// Submitted by Ben Frede <admin@heliohost.org>
+helioho.st
+heliohost.us
+
+// HeiyuSpace: https://lazycat.cloud
+// Submitted by Xia Bin <admin@lazycat.cloud>
+heiyu.space
+
+// Hepforge : https://www.hepforge.org
+// Submitted by David Grellscheid <admin@hepforge.org>
+hepforge.org
+
+// Heroku : https://www.heroku.com/
+// Submitted by Tom Maher <tmaher@heroku.com>
+herokuapp.com
+herokussl.com
+
+// Hibernating Rhinos
+// Submitted by Oren Eini <oren@ravendb.net>
+ravendb.cloud
+ravendb.community
+development.run
+ravendb.run
+
+// home.pl S.A.: https://home.pl
+// Submitted by Krzysztof Wolski <krzysztof.wolski@home.eu>
+homesklep.pl
+
+// Homebase : https://homebase.id/
+// Submitted by Jason Babo <info@homebase.id>
+*.kin.one
+*.id.pub
+*.kin.pub
+
+// Hong Kong Productivity Council: https://www.hkpc.org/
+// Submitted by SECaaS Team <summchan@hkpc.org>
+secaas.hk
+
+// Hoplix : https://www.hoplix.com
+// Submitted by Danilo De Franco<info@hoplix.shop>
+hoplix.shop
+
+
+// HOSTBIP REGISTRY : https://www.hostbip.com/
+// Submitted by Atanunu Igbunuroghene <publicsuffixlist@hostbip.com>
+orx.biz
+biz.gl
+col.ng
+firm.ng
+gen.ng
+ltd.ng
+ngo.ng
+edu.scot
+sch.so
+
+// HostFly : https://www.ie.ua
+// Submitted by Bohdan Dub <support@hostfly.com.ua>
+ie.ua
+
+// HostyHosting (https://hostyhosting.com)
+hostyhosting.io
+
+// Hypernode B.V. : https://www.hypernode.com/
+// Submitted by Cipriano Groenendal <security@nl.team.blue>
+hypernode.io
+
+// Häkkinen.fi
+// Submitted by Eero Häkkinen <Eero+psl@Häkkinen.fi>
+häkkinen.fi
+
+// Ici la Lune : http://www.icilalune.com/
+// Submitted by Simon Morvan <simon@icilalune.com>
+*.moonscale.io
+moonscale.net
+
+// iki.fi
+// Submitted by Hannu Aronsson <haa@iki.fi>
+iki.fi
+
+// iliad italia: https://www.iliad.it
+// Submitted by Marios Makassikis <mmakassikis@freebox.fr>
+ibxos.it
+iliadboxos.it
+
+// Impertrix Solutions : <https://impertrixcdn.com>
+// Submitted by Zhixiang Zhao <csuite@impertrix.com>
+impertrix.com
+impertrixcdn.com
+
+// Incsub, LLC: https://incsub.com/
+// Submitted by Aaron Edwards <sysadmins@incsub.com>
+smushcdn.com
+wphostedmail.com
+wpmucdn.com
+tempurl.host
+wpmudev.host
+
+// Individual Network Berlin e.V. : https://www.in-berlin.de/
+// Submitted by Christian Seitz <chris@in-berlin.de>
+dyn-berlin.de
+in-berlin.de
+in-brb.de
+in-butter.de
+in-dsl.de
+in-vpn.de
+in-dsl.net
+in-vpn.net
+in-dsl.org
+in-vpn.org
+
+// info.at : http://www.info.at/
+biz.at
+info.at
+
+// info.cx : http://info.cx
+// Submitted by June Slater <whois@igloo.to>
+info.cx
+
+// Interlegis : http://www.interlegis.leg.br
+// Submitted by Gabriel Ferreira <registrobr@interlegis.leg.br>
+ac.leg.br
+al.leg.br
+am.leg.br
+ap.leg.br
+ba.leg.br
+ce.leg.br
+df.leg.br
+es.leg.br
+go.leg.br
+ma.leg.br
+mg.leg.br
+ms.leg.br
+mt.leg.br
+pa.leg.br
+pb.leg.br
+pe.leg.br
+pi.leg.br
+pr.leg.br
+rj.leg.br
+rn.leg.br
+ro.leg.br
+rr.leg.br
+rs.leg.br
+sc.leg.br
+se.leg.br
+sp.leg.br
+to.leg.br
+
+// intermetrics GmbH : https://pixolino.com/
+// Submitted by Wolfgang Schwarz <admin@intermetrics.de>
+pixolino.com
+
+// Internet-Pro, LLP: https://netangels.ru/
+// Submitted by Vasiliy Sheredeko <piphon@gmail.com>
+na4u.ru
+
+// iopsys software solutions AB : https://iopsys.eu/
+// Submitted by Roman Azarenko <roman.azarenko@iopsys.eu>
+iopsys.se
+
+// IPiFony Systems, Inc. : https://www.ipifony.com/
+// Submitted by Matthew Hardeman <mhardeman@ipifony.com>
+ipifony.net
+
+// is-a.dev : https://www.is-a.dev
+// Submitted by William Harrison <admin@maintainers.is-a.dev>
+is-a.dev
+
+// ir.md : https://nic.ir.md
+// Submitted by Ali Soizi <info@nic.ir.md>
+ir.md
+
+// IServ GmbH : https://iserv.de
+// Submitted by Mario Hoberg <info@iserv.de>
+iservschule.de
+mein-iserv.de
+schulplattform.de
+schulserver.de
+test-iserv.de
+iserv.dev
+
+// I-O DATA DEVICE, INC. : http://www.iodata.com/
+// Submitted by Yuji Minagawa <domains-admin@iodata.jp>
+iobb.net
+
+// Jelastic, Inc. : https://jelastic.com/
+// Submitted by Ihor Kolodyuk <ik@jelastic.com>
+mel.cloudlets.com.au
+cloud.interhostsolutions.be
+mycloud.by
+alp1.ae.flow.ch
+appengine.flow.ch
+es-1.axarnet.cloud
+diadem.cloud
+vip.jelastic.cloud
+jele.cloud
+it1.eur.aruba.jenv-aruba.cloud
+it1.jenv-aruba.cloud
+keliweb.cloud
+cs.keliweb.cloud
+oxa.cloud
+tn.oxa.cloud
+uk.oxa.cloud
+primetel.cloud
+uk.primetel.cloud
+ca.reclaim.cloud
+uk.reclaim.cloud
+us.reclaim.cloud
+ch.trendhosting.cloud
+de.trendhosting.cloud
+jele.club
+amscompute.com
+dopaas.com
+paas.hosted-by-previder.com
+rag-cloud.hosteur.com
+rag-cloud-ch.hosteur.com
+jcloud.ik-server.com
+jcloud-ver-jpc.ik-server.com
+demo.jelastic.com
+kilatiron.com
+paas.massivegrid.com
+jed.wafaicloud.com
+lon.wafaicloud.com
+ryd.wafaicloud.com
+j.scaleforce.com.cy
+jelastic.dogado.eu
+fi.cloudplatform.fi
+demo.datacenter.fi
+paas.datacenter.fi
+jele.host
+mircloud.host
+paas.beebyte.io
+sekd1.beebyteapp.io
+jele.io
+cloud-fr1.unispace.io
+jc.neen.it
+cloud.jelastic.open.tim.it
+jcloud.kz
+upaas.kazteleport.kz
+cloudjiffy.net
+fra1-de.cloudjiffy.net
+west1-us.cloudjiffy.net
+jls-sto1.elastx.net
+jls-sto2.elastx.net
+jls-sto3.elastx.net
+faststacks.net
+fr-1.paas.massivegrid.net
+lon-1.paas.massivegrid.net
+lon-2.paas.massivegrid.net
+ny-1.paas.massivegrid.net
+ny-2.paas.massivegrid.net
+sg-1.paas.massivegrid.net
+jelastic.saveincloud.net
+nordeste-idc.saveincloud.net
+j.scaleforce.net
+jelastic.tsukaeru.net
+sdscloud.pl
+unicloud.pl
+mircloud.ru
+jelastic.regruhosting.ru
+enscaled.sg
+jele.site
+jelastic.team
+orangecloud.tn
+j.layershift.co.uk
+phx.enscaled.us
+mircloud.us
+
+// Jino : https://www.jino.ru
+// Submitted by Sergey Ulyashin <ulyashin@jino.ru>
+myjino.ru
+*.hosting.myjino.ru
+*.landing.myjino.ru
+*.spectrum.myjino.ru
+*.vps.myjino.ru
+
+// Jotelulu S.L. : https://jotelulu.com
+// Submitted by Daniel Fariña <ingenieria@jotelulu.com>
+jotelulu.cloud
+
+// JouwWeb B.V. : https://www.jouwweb.nl
+// Submitted by Camilo Sperberg <tech@webador.com>
+webadorsite.com
+jouwweb.site
+
+// Joyent : https://www.joyent.com/
+// Submitted by Brian Bennett <brian.bennett@joyent.com>
+*.cns.joyent.com
+*.triton.zone
+
+// JS.ORG : http://dns.js.org
+// Submitted by Stefan Keim <admin@js.org>
+js.org
+
+// KaasHosting : http://www.kaashosting.nl/
+// Submitted by Wouter Bakker <hostmaster@kaashosting.nl>
+kaas.gg
+khplay.nl
+
+// Kakao : https://www.kakaocorp.com/
+// Submitted by JaeYoong Lee <cec@kakaocorp.com>
+ktistory.com
+
+// Kapsi : https://kapsi.fi
+// Submitted by Tomi Juntunen <erani@kapsi.fi>
+kapsi.fi
+
+// Keyweb AG : https://www.keyweb.de
+// Submitted by Martin Dannehl <postmaster@keymachine.de>
+keymachine.de
+
+// KingHost : https://king.host
+// Submitted by Felipe Keller Braz <felipebraz@kinghost.com.br>
+kinghost.net
+uni5.net
+
+// KnightPoint Systems, LLC : http://www.knightpoint.com/
+// Submitted by Roy Keene <rkeene@knightpoint.com>
+knightpoint.systems
+
+// KoobinEvent, SL: https://www.koobin.com
+// Submitted by Iván Oliva <ivan.oliva@koobin.com>
+koobin.events
+
+// KUROKU LTD : https://kuroku.ltd/
+// Submitted by DisposaBoy <security@oya.to>
+oya.to
+
+// Katholieke Universiteit Leuven: https://www.kuleuven.be
+// Submitted by Abuse KU Leuven <abuse@kuleuven.be>
+ezproxy.kuleuven.be
+kuleuven.cloud
+
+// .KRD : http://nic.krd/data/krd/Registration%20Policy.pdf
+co.krd
+edu.krd
+
+// Krellian Ltd. : https://krellian.com
+// Submitted by Ben Francis <ben@krellian.com>
+webthings.io
+krellian.net
+
+// LCube - Professional hosting e.K. : https://www.lcube-webhosting.de
+// Submitted by Lars Laehn <info@lcube.de>
+git-repos.de
+lcube-server.de
+svn-repos.de
+
+// Leadpages : https://www.leadpages.net
+// Submitted by Greg Dallavalle <domains@leadpages.net>
+leadpages.co
+lpages.co
+lpusercontent.com
+
+// Lelux.fi : https://lelux.fi/
+// Submitted by Lelux Admin <publisuffix@lelux.site>
+lelux.site
+
+// Libre IT Ltd : https://libre.nz
+// Submitted by Tomas Maggio <support@libre.nz>
+runcontainers.dev
+
+// Lifetime Hosting : https://Lifetime.Hosting/
+// Submitted by Mike Fillator <support@lifetime.hosting>
+co.business
+co.education
+co.events
+co.financial
+co.network
+co.place
+co.technology
+
+// linkyard ldt: https://www.linkyard.ch/
+// Submitted by Mario Siegenthaler <mario.siegenthaler@linkyard.ch>
+linkyard-cloud.ch
+linkyard.cloud
+
+// Linode : https://linode.com
+// Submitted by <security@linode.com>
+members.linode.com
+*.nodebalancer.linode.com
+*.linodeobjects.com
+ip.linodeusercontent.com
+
+// LiquidNet Ltd : http://www.liquidnetlimited.com/
+// Submitted by Victor Velchev <admin@liquidnetlimited.com>
+we.bs
+
+// Localcert : https://localcert.dev
+// Submitted by Lann Martin <security@localcert.dev>
+*.user.localcert.dev
+
+// localzone.xyz
+// Submitted by Kenny Niehage <hello@yahe.sh>
+localzone.xyz
+
+// Log'in Line : https://www.loginline.com/
+// Submitted by Rémi Mach <remi.mach@loginline.com>
+loginline.app
+loginline.dev
+loginline.io
+loginline.services
+loginline.site
+
+// Lokalized : https://lokalized.nl
+// Submitted by Noah Taheij <noah@lokalized.nl>
+servers.run
+
+// Lõhmus Family, The
+// Submitted by Heiki Lõhmus <hostmaster at lohmus dot me>
+lohmus.me
+
+// LubMAN UMCS Sp. z o.o : https://lubman.pl/
+// Submitted by Ireneusz Maliszewski <ireneusz.maliszewski@lubman.pl>
+krasnik.pl
+leczna.pl
+lubartow.pl
+lublin.pl
+poniatowa.pl
+swidnik.pl
+
+// Lug.org.uk : https://lug.org.uk
+// Submitted by Jon Spriggs <admin@lug.org.uk>
+glug.org.uk
+lug.org.uk
+lugs.org.uk
+
+// Lukanet Ltd : https://lukanet.com
+// Submitted by Anton Avramov <register@lukanet.com>
+barsy.bg
+barsy.club
+barsycenter.com
+barsyonline.com
+barsy.de
+barsy.dev
+barsy.eu
+barsy.gr
+barsy.in
+barsy.info
+barsy.io
+barsy.me
+barsy.menu
+barsyonline.menu
+barsy.mobi
+barsy.net
+barsy.online
+barsy.org
+barsy.pro
+barsy.pub
+barsy.ro
+barsy.rs
+barsy.shop
+barsyonline.shop
+barsy.site
+barsy.store
+barsy.support
+barsy.uk
+barsy.co.uk
+barsyonline.co.uk
+
+// Magento Commerce
+// Submitted by Damien Tournoud <dtournoud@magento.cloud>
+*.magentosite.cloud
+
+// May First - People Link : https://mayfirst.org/
+// Submitted by Jamie McClelland <info@mayfirst.org>
+mayfirst.info
+mayfirst.org
+
+// Mail.Ru Group : https://hb.cldmail.ru
+// Submitted by Ilya Zaretskiy <zaretskiy@corp.mail.ru>
+hb.cldmail.ru
+
+// Maze Play: https://www.mazeplay.com
+// Submitted by Adam Humpherys <adam@mws.dev>
+mazeplay.com
+
+// mcpe.me : https://mcpe.me
+// Submitted by Noa Heyl <hi@noa.dev>
+mcpe.me
+
+// McHost : https://mchost.ru
+// Submitted by Evgeniy Subbotin <e.subbotin@mchost.ru>
+mcdir.me
+mcdir.ru
+vps.mcdir.ru
+mcpre.ru
+
+// Mediatech : https://mediatech.by
+// Submitted by Evgeniy Kozhuhovskiy <ugenk@mediatech.by>
+mediatech.by
+mediatech.dev
+
+// Medicom Health : https://medicomhealth.com
+// Submitted by Michael Olson <molson@medicomhealth.com>
+hra.health
+
+// Memset hosting : https://www.memset.com
+// Submitted by Tom Whitwell <domains@memset.com>
+miniserver.com
+memset.net
+
+// Messerli Informatik AG : https://www.messerli.ch/
+// Submitted by Ruben Schmidmeister <psl-maintainers@messerli.ch>
+messerli.app
+
+// Meta Platforms, Inc. : https://meta.com/
+// Submitted by Jacob Cordero <public-suffix@meta.com>
+atmeta.com
+apps.fbsbx.com
+
+// MetaCentrum, CESNET z.s.p.o. : https://www.metacentrum.cz/en/
+// Submitted by Zdeněk Šustr <zdenek.sustr@cesnet.cz>
+*.cloud.metacentrum.cz
+custom.metacentrum.cz
+
+// MetaCentrum, CESNET z.s.p.o. : https://www.metacentrum.cz/en/
+// Submitted by Radim Janča <janca@cesnet.cz>
+flt.cloud.muni.cz
+usr.cloud.muni.cz
+
+// Meteor Development Group : https://www.meteor.com/hosting
+// Submitted by Pierre Carrier <pierre@meteor.com>
+meteorapp.com
+eu.meteorapp.com
+
+// Michau Enterprises Limited : http://www.co.pl/
+co.pl
+
+// Microsoft Corporation : http://microsoft.com
+// Submitted by Public Suffix List Admin <msftpsladmin@microsoft.com>
+// Managed by Corporate Domains
+// Microsoft Azure : https://home.azure
+*.azurecontainer.io
+azure-api.net
+azure-mobile.net
+azureedge.net
+azurefd.net
+azurestaticapps.net
+1.azurestaticapps.net
+2.azurestaticapps.net
+3.azurestaticapps.net
+4.azurestaticapps.net
+5.azurestaticapps.net
+6.azurestaticapps.net
+7.azurestaticapps.net
+centralus.azurestaticapps.net
+eastasia.azurestaticapps.net
+eastus2.azurestaticapps.net
+westeurope.azurestaticapps.net
+westus2.azurestaticapps.net
+azurewebsites.net
+cloudapp.net
+trafficmanager.net
+blob.core.windows.net
+servicebus.windows.net
+
+// minion.systems : http://minion.systems
+// Submitted by Robert Böttinger <r@minion.systems>
+csx.cc
+
+// Mintere : https://mintere.com/
+// Submitted by Ben Aubin <security@mintere.com>
+mintere.site
+
+// MobileEducation, LLC : https://joinforte.com
+// Submitted by Grayson Martin <grayson.martin@mobileeducation.us>
+forte.id
+
+// MODX Systems LLC : https://modx.com
+// Submitted by Elizabeth Southwell <elizabeth@modx.com>
+modx.dev
+
+// Mozilla Corporation : https://mozilla.com
+// Submitted by Ben Francis <bfrancis@mozilla.com>
+mozilla-iot.org
+
+// Mozilla Foundation : https://mozilla.org/
+// Submitted by glob <glob@mozilla.com>
+bmoattachments.org
+
+// MSK-IX : https://www.msk-ix.ru/
+// Submitted by Khannanov Roman <r.khannanov@msk-ix.ru>
+net.ru
+org.ru
+pp.ru
+
+// Mythic Beasts : https://www.mythic-beasts.com
+// Submitted by Paul Cammish <kelduum@mythic-beasts.com>
+hostedpi.com
+caracal.mythic-beasts.com
+customer.mythic-beasts.com
+fentiger.mythic-beasts.com
+lynx.mythic-beasts.com
+ocelot.mythic-beasts.com
+oncilla.mythic-beasts.com
+onza.mythic-beasts.com
+sphinx.mythic-beasts.com
+vs.mythic-beasts.com
+x.mythic-beasts.com
+yali.mythic-beasts.com
+cust.retrosnub.co.uk
+
+// Nabu Casa : https://www.nabucasa.com
+// Submitted by Paulus Schoutsen <infra@nabucasa.com>
+ui.nabu.casa
+
+// Net at Work Gmbh : https://www.netatwork.de
+// Submitted by Jan Jaeschke <jan.jaeschke@netatwork.de>
+cloud.nospamproxy.com
+
+// Netfy Domains : https://netfy.domains
+// Submitted by Suranga Ranasinghe <security@mavicsoft.com>
+netfy.app
+
+// Netlify : https://www.netlify.com
+// Submitted by Jessica Parsons <jessica@netlify.com>
+netlify.app
+
+// Neustar Inc.
+// Submitted by Trung Tran <Trung.Tran@neustar.biz>
+4u.com
+
+// NGO.US Registry : https://nic.ngo.us
+// Submitted by Alstra Solutions Ltd. Networking Team <admin@alstra.org>
+ngo.us
+
+// ngrok : https://ngrok.com/
+// Submitted by Alan Shreve <alan@ngrok.com>
+ngrok.app
+ngrok-free.app
+ngrok.dev
+ngrok-free.dev
+ngrok.io
+ap.ngrok.io
+au.ngrok.io
+eu.ngrok.io
+in.ngrok.io
+jp.ngrok.io
+sa.ngrok.io
+us.ngrok.io
+ngrok.pizza
+ngrok.pro
+
+// Nicolaus Copernicus University in Torun - MSK TORMAN (https://www.man.torun.pl)
+torun.pl
+
+// Nimbus Hosting Ltd. : https://www.nimbushosting.co.uk/
+// Submitted by Nicholas Ford <dev@nimbushosting.co.uk>
+nh-serv.co.uk
+nimsite.uk
+
+// NFSN, Inc. : https://www.NearlyFreeSpeech.NET/
+// Submitted by Jeff Wheelhouse <support@nearlyfreespeech.net>
+nfshost.com
+
+// NFT.Storage : https://nft.storage/
+// Submitted by Vasco Santos <vasco.santos@protocol.ai> or <support@nft.storage>
+ipfs.nftstorage.link
+
+// Noop : https://noop.app
+// Submitted by Nathaniel Schweinberg <noop@rearc.io>
+*.developer.app
+noop.app
+
+// Northflank Ltd. : https://northflank.com/
+// Submitted by Marco Suter <marco@northflank.com>
+*.northflank.app
+*.build.run
+*.code.run
+*.database.run
+*.migration.run
+
+// Noticeable : https://noticeable.io
+// Submitted by Laurent Pellegrino <security@noticeable.io>
+noticeable.news
+
+// Notion Labs, Inc : https://www.notion.so/
+// Submitted by Jess Yao <trust-core-team@makenotion.com>
+notion.site
+
+// Now-DNS : https://now-dns.com
+// Submitted by Steve Russell <steve@now-dns.com>
+dnsking.ch
+mypi.co
+n4t.co
+001www.com
+ddnslive.com
+myiphost.com
+forumz.info
+16-b.it
+32-b.it
+64-b.it
+soundcast.me
+tcp4.me
+dnsup.net
+hicam.net
+now-dns.net
+ownip.net
+vpndns.net
+dynserv.org
+now-dns.org
+x443.pw
+now-dns.top
+ntdll.top
+freeddns.us
+crafting.xyz
+zapto.xyz
+
+// nsupdate.info : https://www.nsupdate.info/
+// Submitted by Thomas Waldmann <info@nsupdate.info>
+nsupdate.info
+nerdpol.ovh
+
+// No-IP.com : https://noip.com/
+// Submitted by Deven Reza <publicsuffixlist@noip.com>
+mmafan.biz
+myftp.biz
+no-ip.biz
+no-ip.ca
+fantasyleague.cc
+gotdns.ch
+3utilities.com
+blogsyte.com
+ciscofreak.com
+damnserver.com
+ddnsking.com
+ditchyourip.com
+dnsiskinky.com
+dynns.com
+geekgalaxy.com
+health-carereform.com
+homesecuritymac.com
+homesecuritypc.com
+myactivedirectory.com
+mysecuritycamera.com
+myvnc.com
+net-freaks.com
+onthewifi.com
+point2this.com
+quicksytes.com
+securitytactics.com
+servebeer.com
+servecounterstrike.com
+serveexchange.com
+serveftp.com
+servegame.com
+servehalflife.com
+servehttp.com
+servehumour.com
+serveirc.com
+servemp3.com
+servep2p.com
+servepics.com
+servequake.com
+servesarcasm.com
+stufftoread.com
+unusualperson.com
+workisboring.com
+dvrcam.info
+ilovecollege.info
+no-ip.info
+brasilia.me
+ddns.me
+dnsfor.me
+hopto.me
+loginto.me
+noip.me
+webhop.me
+bounceme.net
+ddns.net
+eating-organic.net
+mydissent.net
+myeffect.net
+mymediapc.net
+mypsx.net
+mysecuritycamera.net
+nhlfan.net
+no-ip.net
+pgafan.net
+privatizehealthinsurance.net
+redirectme.net
+serveblog.net
+serveminecraft.net
+sytes.net
+cable-modem.org
+collegefan.org
+couchpotatofries.org
+hopto.org
+mlbfan.org
+myftp.org
+mysecuritycamera.org
+nflfan.org
+no-ip.org
+read-books.org
+ufcfan.org
+zapto.org
+no-ip.co.uk
+golffan.us
+noip.us
+pointto.us
+
+// NodeArt : https://nodeart.io
+// Submitted by Konstantin Nosov <Nosov@nodeart.io>
+stage.nodeart.io
+
+// Nucleos Inc. : https://nucleos.com
+// Submitted by Piotr Zduniak <piotr@nucleos.com>
+pcloud.host
+
+// NYC.mn : http://www.information.nyc.mn
+// Submitted by Matthew Brown <mattbrown@nyc.mn>
+nyc.mn
+
+// O3O.Foundation : https://o3o.foundation/
+// Submitted by the prvcy.page Registry Team <psl@registry.prvcy.page>
+prvcy.page
+
+// Obl.ong : <https://obl.ong>
+// Submitted by Reese Armstrong <team@obl.ong>
+obl.ong
+
+// Observable, Inc. : https://observablehq.com
+// Submitted by Mike Bostock <dns@observablehq.com>
+observablehq.cloud
+static.observableusercontent.com
+
+// Octopodal Solutions, LLC. : https://ulterius.io/
+// Submitted by Andrew Sampson <andrew@ulterius.io>
+cya.gg
+
+// OMG.LOL : <https://omg.lol>
+// Submitted by Adam Newbold <adam@omg.lol>
+omg.lol
+
+// Omnibond Systems, LLC. : https://www.omnibond.com
+// Submitted by Cole Estep <cole@omnibond.com>
+cloudycluster.net
+
+// OmniWe Limited: https://omniwe.com
+// Submitted by Vicary Archangel <vicary@omniwe.com>
+omniwe.site
+
+// One.com: https://www.one.com/
+// Submitted by Jacob Bunk Nielsen <jbn@one.com>
+123webseite.at
+123website.be
+simplesite.com.br
+123website.ch
+simplesite.com
+123webseite.de
+123hjemmeside.dk
+123miweb.es
+123kotisivu.fi
+123siteweb.fr
+simplesite.gr
+123homepage.it
+123website.lu
+123website.nl
+123hjemmeside.no
+service.one
+simplesite.pl
+123paginaweb.pt
+123minsida.se
+
+// One Fold Media : http://www.onefoldmedia.com/
+// Submitted by Eddie Jones <eddie@onefoldmedia.com>
+nid.io
+
+// Open Domains : https://open-domains.net
+// Submitted by William Harrison <admin@open-domains.net>
+is-cool.dev
+is-not-a.dev
+localplayer.dev
+is-local.org
+
+// Open Social : https://www.getopensocial.com/
+// Submitted by Alexander Varwijk <security@getopensocial.com>
+opensocial.site
+
+// OpenCraft GmbH : http://opencraft.com/
+// Submitted by Sven Marnach <sven@opencraft.com>
+opencraft.hosting
+
+// OpenResearch GmbH: https://openresearch.com/
+// Submitted by Philipp Schmid <ops@openresearch.com>
+orsites.com
+
+// Opera Software, A.S.A.
+// Submitted by Yngve Pettersen <yngve@opera.com>
+operaunite.com
+
+// Orange : https://www.orange.com
+// Submitted by Alexandre Linte <alexandre.linte@orange.com>
+tech.orange
+
+// OsSav Technology Ltd. : https://ossav.com/
+// TLD Nic: http://nic.can.re - TLD Whois Server: whois.can.re
+// Submitted by OsSav Technology Ltd. <support@ossav.com>
+can.re
+
+// Oursky Limited : https://authgear.com/, https://skygear.io/
+// Submitted by Authgear Team <hello@authgear.com>, Skygear Developer <hello@skygear.io>
+authgear-staging.com
+authgearapps.com
+skygearapp.com
+
+// OutSystems
+// Submitted by Duarte Santos <domain-admin@outsystemscloud.com>
+outsystemscloud.com
+
+// OVHcloud: https://ovhcloud.com
+// Submitted by Vincent Cassé <vincent.casse@ovhcloud.com>
+*.hosting.ovh.net
+*.webpaas.ovh.net
+
+// OwnProvider GmbH: http://www.ownprovider.com
+// Submitted by Jan Moennich <jan.moennich@ownprovider.com>
+ownprovider.com
+own.pm
+
+// OwO : https://whats-th.is/
+// Submitted by Dean Sheather <dean@deansheather.com>
+*.owo.codes
+
+// OX : http://www.ox.rs
+// Submitted by Adam Grand <webmaster@mail.ox.rs>
+ox.rs
+
+// oy.lc
+// Submitted by Charly Coste <changaco@changaco.oy.lc>
+oy.lc
+
+// Pagefog : https://pagefog.com/
+// Submitted by Derek Myers <derek@pagefog.com>
+pgfog.com
+
+// Pagefront : https://www.pagefronthq.com/
+// Submitted by Jason Kriss <jason@pagefronthq.com>
+pagefrontapp.com
+
+// PageXL : https://pagexl.com
+// Submitted by Yann Guichard <yann@pagexl.com>
+pagexl.com
+
+// Paywhirl, Inc : https://paywhirl.com/
+// Submitted by Daniel Netzer <dan@paywhirl.com>
+*.paywhirl.com
+
+// pcarrier.ca Software Inc: https://pcarrier.ca/
+// Submitted by Pierre Carrier <pc@rrier.ca>
+*.xmit.co
+xmit.dev
+madethis.site
+srv.us
+gh.srv.us
+gl.srv.us
+
+// .pl domains (grandfathered)
+art.pl
+gliwice.pl
+krakow.pl
+poznan.pl
+wroc.pl
+zakopane.pl
+
+// Pantheon Systems, Inc. : https://pantheon.io/
+// Submitted by Gary Dylina <gary@pantheon.io>
+gotpantheon.com
+pantheonsite.io
+
+// Peplink | Pepwave : http://peplink.com/
+// Submitted by Steve Leung <steveleung@peplink.com>
+mypep.link
+
+// Perspecta : https://perspecta.com/
+// Submitted by Kenneth Van Alstyne <kvanalstyne@perspecta.com>
+perspecta.cloud
+
+// PE Ulyanov Kirill Sergeevich : https://airy.host
+// Submitted by Kirill Ulyanov <k.ulyanov@airy.host>
+lk3.ru
+
+// Planet-Work : https://www.planet-work.com/
+// Submitted by Frédéric VANNIÈRE <f.vanniere@planet-work.com>
+on-web.fr
+
+// Platform.sh : https://platform.sh
+// Submitted by Nikola Kotur <nikola@platform.sh>
+*.upsun.app
+upsunapp.com
+ent.platform.sh
+eu.platform.sh
+us.platform.sh
+*.platformsh.site
+*.tst.site
+
+// Platter: https://platter.dev
+// Submitted by Patrick Flor <patrick@platter.dev>
+platter-app.com
+platter-app.dev
+platterp.us
+
+// Pley AB : https://www.pley.com/
+// Submitted by Henning Pohl <infra@pley.com>
+pley.games
+
+// Port53 : https://port53.io/
+// Submitted by Maximilian Schieder <maxi@zeug.co>
+dyn53.io
+
+// Porter : https://porter.run/
+// Submitted by Rudraksh MK <rudi@porter.run>
+onporter.run
+
+// Positive Codes Technology Company : http://co.bn/faq.html
+// Submitted by Zulfais <pc@co.bn>
+co.bn
+
+// Postman, Inc : https://postman.com
+// Submitted by Rahul Dhawan <security@postman.com>
+postman-echo.com
+pstmn.io
+mock.pstmn.io
+httpbin.org
+
+// prequalifyme.today : https://prequalifyme.today
+// Submitted by DeepakTiwari deepak@ivylead.io
+prequalifyme.today
+
+// prgmr.com : https://prgmr.com/
+// Submitted by Sarah Newman <owner@prgmr.com>
+xen.prgmr.com
+
+// priv.at : http://www.nic.priv.at/
+// Submitted by registry <lendl@nic.at>
+priv.at
+
+// Protocol Labs : https://protocol.ai/
+// Submitted by Michael Burns <noc@protocol.ai>
+*.dweb.link
+
+// Protonet GmbH : http://protonet.io
+// Submitted by Martin Meier <admin@protonet.io>
+protonet.io
+
+// Publication Presse Communication SARL : https://ppcom.fr
+// Submitted by Yaacov Akiba Slama <admin@chirurgiens-dentistes-en-france.fr>
+chirurgiens-dentistes-en-france.fr
+byen.site
+
+// pubtls.org: https://www.pubtls.org
+// Submitted by Kor Nielsen <kor@pubtls.org>
+pubtls.org
+
+// PythonAnywhere LLP: https://www.pythonanywhere.com
+// Submitted by Giles Thomas <giles@pythonanywhere.com>
+pythonanywhere.com
+eu.pythonanywhere.com
+
+// QOTO, Org.
+// Submitted by Jeffrey Phillips Freeman <jeffrey.freeman@qoto.org>
+qoto.io
+
+// Qualifio : https://qualifio.com/
+// Submitted by Xavier De Cock <xdecock@gmail.com>
+qualifioapp.com
+
+// Quality Unit: https://qualityunit.com
+// Submitted by Vasyl Tsalko <vtsalko@qualityunit.com>
+ladesk.com
+
+// QuickBackend: https://www.quickbackend.com
+// Submitted by Dani Biro <dani@pymet.com>
+qbuser.com
+
+// Rad Web Hosting: https://radwebhosting.com
+// Submitted by Scott Claeys <s.claeys@radwebhosting.com>
+cloudsite.builders
+myradweb.net
+servername.us
+
+// Raidboxes GmbH : https://raidboxes.de
+// Submitted by Auke Tembrink <hostmaster@raidboxes.de>
+myrdbx.io
+site.rb-hosting.io
+
+// Redgate Software: https://red-gate.com
+// Submitted by Andrew Farries <andrew.farries@red-gate.com>
+instances.spawn.cc
+
+// Russian Academy of Sciences
+// Submitted by Tech Support <support@rasnet.ru>
+ras.ru
+
+// QA2
+// Submitted by Daniel Dent (https://www.danieldent.com/)
+qa2.com
+
+// QCX
+// Submitted by Cassandra Beelen <cassandra@beelen.one>
+qcx.io
+*.sys.qcx.io
+
+// QNAP System Inc : https://www.qnap.com
+// Submitted by Nick Chang <cloudadmin@qnap.com>
+myqnapcloud.cn
+alpha-myqnapcloud.com
+dev-myqnapcloud.com
+mycloudnas.com
+mynascloud.com
+myqnapcloud.com
+
+// Quip : https://quip.com
+// Submitted by Patrick Linehan <plinehan@quip.com>
+*.quipelements.com
+
+// Qutheory LLC : http://qutheory.io
+// Submitted by Jonas Schwartz <jonas@qutheory.io>
+vapor.cloud
+vaporcloud.io
+
+// Rackmaze LLC : https://www.rackmaze.com
+// Submitted by Kirill Pertsev <kika@rackmaze.com>
+rackmaze.com
+rackmaze.net
+
+// Rancher Labs, Inc : https://rancher.com
+// Submitted by Vincent Fiduccia <domains@rancher.com>
+*.on-rancher.cloud
+*.on-k3s.io
+*.on-rio.io
+
+// Read The Docs, Inc : https://www.readthedocs.org
+// Submitted by David Fischer <team@readthedocs.org>
+readthedocs.io
+
+// Red Hat, Inc. OpenShift : https://openshift.redhat.com/
+// Submitted by Tim Kramer <tkramer@rhcloud.com>
+rhcloud.com
+
+// Render : https://render.com
+// Submitted by Anurag Goel <dev@render.com>
+onrender.com
+app.render.com
+
+// Repl.it : https://repl.it
+// Submitted by Lincoln Bergeson <psl@repl.it>
+replit.app
+id.replit.app
+firewalledreplit.co
+id.firewalledreplit.co
+repl.co
+id.repl.co
+replit.dev
+archer.replit.dev
+bones.replit.dev
+canary.replit.dev
+global.replit.dev
+hacker.replit.dev
+id.replit.dev
+janeway.replit.dev
+kim.replit.dev
+kira.replit.dev
+kirk.replit.dev
+odo.replit.dev
+paris.replit.dev
+picard.replit.dev
+pike.replit.dev
+prerelease.replit.dev
+reed.replit.dev
+riker.replit.dev
+sisko.replit.dev
+spock.replit.dev
+staging.replit.dev
+sulu.replit.dev
+tarpit.replit.dev
+teams.replit.dev
+tucker.replit.dev
+wesley.replit.dev
+worf.replit.dev
+repl.run
+
+// Resin.io : https://resin.io
+// Submitted by Tim Perry <tim@resin.io>
+resindevice.io
+devices.resinstaging.io
+
+// RethinkDB : https://www.rethinkdb.com/
+// Submitted by Chris Kastorff <info@rethinkdb.com>
+hzc.io
+
+// Revitalised Limited : http://www.revitalised.co.uk
+// Submitted by Jack Price <jack@revitalised.co.uk>
+wellbeingzone.eu
+wellbeingzone.co.uk
+
+// Rico Developments Limited : https://adimo.co
+// Submitted by Colin Brown <hello@adimo.co>
+adimo.co.uk
+
+// Riseup Networks : https://riseup.net
+// Submitted by Micah Anderson <micah@riseup.net>
+itcouldbewor.se
+
+// Rochester Institute of Technology : http://www.rit.edu/
+// Submitted by Jennifer Herting <jchits@rit.edu>
+git-pages.rit.edu
+
+// Rocky Enterprise Software Foundation : https://resf.org
+// Submitted by Neil Hanlon <neil@resf.org>
+rocky.page
+
+// Rusnames Limited: http://rusnames.ru/
+// Submitted by Sergey Zotov <admin@rusnames.ru>
+биз.рус
+ком.рус
+крым.рус
+мир.рус
+мск.рус
+орг.рус
+самара.рус
+сочи.рус
+спб.рус
+я.рус
+
+// SAKURA Internet Inc. : https://www.sakura.ad.jp/
+// Submitted by Internet Service Department <rs-vendor-ml@sakura.ad.jp>
+180r.com
+dojin.com
+sakuratan.com
+sakuraweb.com
+x0.com
+2-d.jp
+bona.jp
+crap.jp
+daynight.jp
+eek.jp
+flop.jp
+halfmoon.jp
+jeez.jp
+matrix.jp
+mimoza.jp
+ivory.ne.jp
+mail-box.ne.jp
+mints.ne.jp
+mokuren.ne.jp
+opal.ne.jp
+sakura.ne.jp
+sumomo.ne.jp
+topaz.ne.jp
+netgamers.jp
+nyanta.jp
+o0o0.jp
+rdy.jp
+rgr.jp
+rulez.jp
+s3.isk01.sakurastorage.jp
+s3.isk02.sakurastorage.jp
+saloon.jp
+sblo.jp
+skr.jp
+tank.jp
+uh-oh.jp
+undo.jp
+rs.webaccel.jp
+user.webaccel.jp
+websozai.jp
+xii.jp
+squares.net
+jpn.org
+kirara.st
+x0.to
+from.tv
+sakura.tv
+
+// Salesforce.com, Inc. https://salesforce.com/
+// Submitted by Salesforce Public Suffix List Team <public-suffix-list@salesforce.com>
+*.builder.code.com
+*.dev-builder.code.com
+*.stg-builder.code.com
+*.001.test.code-builder-stg.platform.salesforce.com
+*.d.crm.dev
+*.w.crm.dev
+*.wa.crm.dev
+*.wb.crm.dev
+*.wc.crm.dev
+*.wd.crm.dev
+*.we.crm.dev
+*.wf.crm.dev
+
+// Sandstorm Development Group, Inc. : https://sandcats.io/
+// Submitted by Asheesh Laroia <asheesh@sandstorm.io>
+sandcats.io
+
+// SBE network solutions GmbH : https://www.sbe.de/
+// Submitted by Norman Meilick <nm@sbe.de>
+logoip.com
+logoip.de
+
+// Scaleway : https://www.scaleway.com/
+// Submitted by Rémy Léone <rleone@scaleway.com>
+fr-par-1.baremetal.scw.cloud
+fr-par-2.baremetal.scw.cloud
+nl-ams-1.baremetal.scw.cloud
+cockpit.fr-par.scw.cloud
+fnc.fr-par.scw.cloud
+functions.fnc.fr-par.scw.cloud
+k8s.fr-par.scw.cloud
+nodes.k8s.fr-par.scw.cloud
+s3.fr-par.scw.cloud
+s3-website.fr-par.scw.cloud
+whm.fr-par.scw.cloud
+priv.instances.scw.cloud
+pub.instances.scw.cloud
+k8s.scw.cloud
+cockpit.nl-ams.scw.cloud
+k8s.nl-ams.scw.cloud
+nodes.k8s.nl-ams.scw.cloud
+s3.nl-ams.scw.cloud
+s3-website.nl-ams.scw.cloud
+whm.nl-ams.scw.cloud
+cockpit.pl-waw.scw.cloud
+k8s.pl-waw.scw.cloud
+nodes.k8s.pl-waw.scw.cloud
+s3.pl-waw.scw.cloud
+s3-website.pl-waw.scw.cloud
+scalebook.scw.cloud
+smartlabeling.scw.cloud
+dedibox.fr
+
+// schokokeks.org GbR : https://schokokeks.org/
+// Submitted by Hanno Böck <hanno@schokokeks.org>
+schokokeks.net
+
+// Scottish Government: https://www.gov.scot
+// Submitted by Martin Ellis <martin.ellis@gov.scot>
+gov.scot
+service.gov.scot
+
+// Scry Security : http://www.scrysec.com
+// Submitted by Shante Adam <shante@skyhat.io>
+scrysec.com
+
+// Scrypted : https://scrypted.app
+// Submitted by Koushik Dutta <public-suffix-list@scrypted.app>
+client.scrypted.io
+
+// Securepoint GmbH : https://www.securepoint.de
+// Submitted by Erik Anders <erik.anders@securepoint.de>
+firewall-gateway.com
+firewall-gateway.de
+my-gateway.de
+my-router.de
+spdns.de
+spdns.eu
+firewall-gateway.net
+my-firewall.org
+myfirewall.org
+spdns.org
+
+// Seidat : https://www.seidat.com
+// Submitted by Artem Kondratev <accounts@seidat.com>
+seidat.net
+
+// Sellfy : https://sellfy.com
+// Submitted by Yuriy Romadin <contact@sellfy.com>
+sellfy.store
+
+// Senseering GmbH : https://www.senseering.de
+// Submitted by Felix Mönckemeyer <f.moenckemeyer@senseering.de>
+senseering.net
+
+// Sendmsg: https://www.sendmsg.co.il
+// Submitted by Assaf Stern <domains@comstar.co.il>
+minisite.ms
+
+// Servebolt AS: https://servebolt.com
+// Submitted by Daniel Kjeserud <cloudops@servebolt.com>
+servebolt.cloud
+
+// Service Magnet : https://myservicemagnet.com
+// Submitted by Dave Sanders <dave@myservicemagnet.com>
+magnet.page
+
+// Service Online LLC : http://drs.ua/
+// Submitted by Serhii Bulakh <support@drs.ua>
+biz.ua
+co.ua
+pp.ua
+
+// Shanghai Accounting Society : https://www.sasf.org.cn
+// Submitted by Information Administration <info@sasf.org.cn>
+as.sh.cn
+
+// Sheezy.Art : https://sheezy.art
+// Submitted by Nyoom <admin@sheezy.art>
+sheezy.games
+
+// Shift Crypto AG : https://shiftcrypto.ch
+// Submitted by alex <alex@shiftcrypto.ch>
+shiftcrypto.dev
+shiftcrypto.io
+
+// ShiftEdit : https://shiftedit.net/
+// Submitted by Adam Jimenez <adam@shiftcreate.com>
+shiftedit.io
+
+// Shopblocks : http://www.shopblocks.com/
+// Submitted by Alex Bowers <alex@shopblocks.com>
+myshopblocks.com
+
+// Shopify : https://www.shopify.com
+// Submitted by Alex Richter <alex.richter@shopify.com>
+myshopify.com
+
+// Shopit : https://www.shopitcommerce.com/
+// Submitted by Craig McMahon <craig@shopitcommerce.com>
+shopitsite.com
+
+// shopware AG : https://shopware.com
+// Submitted by Jens Küper <cloud@shopware.com>
+shopware.store
+
+// Siemens Mobility GmbH
+// Submitted by Oliver Graebner <security@mo-siemens.io>
+mo-siemens.io
+
+// SinaAppEngine : http://sae.sina.com.cn/
+// Submitted by SinaAppEngine <saesupport@sinacloud.com>
+1kapp.com
+appchizi.com
+applinzi.com
+sinaapp.com
+vipsinaapp.com
+
+// Siteleaf : https://www.siteleaf.com/
+// Submitted by Skylar Challand <support@siteleaf.com>
+siteleaf.net
+
+// Skyhat : http://www.skyhat.io
+// Submitted by Shante Adam <shante@skyhat.io>
+bounty-full.com
+alpha.bounty-full.com
+beta.bounty-full.com
+
+// Smallregistry by Promopixel SARL: https://www.smallregistry.net
+// Former AFNIC's SLDs
+// Submitted by Jérôme Lipowicz <support@promopixel.com>
+aeroport.fr
+avocat.fr
+chambagri.fr
+chirurgiens-dentistes.fr
+experts-comptables.fr
+medecin.fr
+notaires.fr
+pharmacien.fr
+port.fr
+veterinaire.fr
+
+// Small Technology Foundation : https://small-tech.org
+// Submitted by Aral Balkan <aral@small-tech.org>
+small-web.org
+
+// Smoove.io : https://www.smoove.io/
+// Submitted by Dan Kozak <dan@smoove.io>
+vp4.me
+
+// Snowflake Inc : https://www.snowflake.com/
+// Submitted by Sam Haar <psl@snowflake.com>
+*.snowflake.app
+*.privatelink.snowflake.app
+streamlit.app
+streamlitapp.com
+
+// Snowplow Analytics : https://snowplowanalytics.com/
+// Submitted by Ian Streeter <ian@snowplowanalytics.com>
+try-snowplow.com
+
+// SourceHut : https://sourcehut.org
+// Submitted by Drew DeVault <sir@cmpwn.com>
+srht.site
+
+// SparrowHost : https://sparrowhost.in/
+// Submitted by Anant Pandey <info@sparrowhost.in>
+ind.mom
+
+// StackBlitz : https://stackblitz.com
+// Submitted by Dominic Elm <hello@stackblitz.com>
+w-corp-staticblitz.com
+w-credentialless-staticblitz.com
+w-staticblitz.com
+
+// Stackhero : https://www.stackhero.io
+// Submitted by Adrien Gillon <adrien+public-suffix-list@stackhero.io>
+stackhero-network.com
+
+// STACKIT : https://www.stackit.de/en/
+// Submitted by STACKIT-DNS Team (Simon Stier) <stackit-dns@mail.schwarz>
+runs.onstackit.cloud
+stackit.gg
+stackit.rocks
+stackit.run
+stackit.zone
+
+// Staclar : https://staclar.com
+// Submitted by Q Misell <q@staclar.com>
+// Submitted by Matthias Merkel <matthias.merkel@staclar.com>
+musician.io
+novecore.site
+
+// staticland : https://static.land
+// Submitted by Seth Vincent <sethvincent@gmail.com>
+static.land
+dev.static.land
+sites.static.land
+
+// Storebase : https://www.storebase.io
+// Submitted by Tony Schirmer <tony@storebase.io>
+storebase.store
+
+// Strapi : https://strapi.io/
+// Submitted by Florent Baldino <security@strapi.io>
+strapiapp.com
+media.strapiapp.com
+
+// Strategic System Consulting (eApps Hosting): https://www.eapps.com/
+// Submitted by Alex Oancea <aoancea@cloudscale365.com>
+vps-host.net
+atl.jelastic.vps-host.net
+njs.jelastic.vps-host.net
+ric.jelastic.vps-host.net
+
+// Sony Interactive Entertainment LLC : https://sie.com/
+// Submitted by David Coles <david.coles@sony.com>
+playstation-cloud.com
+
+// SourceLair PC : https://www.sourcelair.com
+// Submitted by Antonis Kalipetis <akalipetis@sourcelair.com>
+apps.lair.io
+*.stolos.io
+
+// SpaceKit : https://www.spacekit.io/
+// Submitted by Reza Akhavan <spacekit.io@gmail.com>
+spacekit.io
+
+// SpeedPartner GmbH: https://www.speedpartner.de/
+// Submitted by Stefan Neufeind <info@speedpartner.de>
+customer.speedpartner.de
+
+// Spreadshop (sprd.net AG) : https://www.spreadshop.com/
+// Submitted by Martin Breest <security@spreadshop.com>
+myspreadshop.at
+myspreadshop.com.au
+myspreadshop.be
+myspreadshop.ca
+myspreadshop.ch
+myspreadshop.com
+myspreadshop.de
+myspreadshop.dk
+myspreadshop.es
+myspreadshop.fi
+myspreadshop.fr
+myspreadshop.ie
+myspreadshop.it
+myspreadshop.net
+myspreadshop.nl
+myspreadshop.no
+myspreadshop.pl
+myspreadshop.se
+myspreadshop.co.uk
+
+// Standard Library : https://stdlib.com
+// Submitted by Jacob Lee <jacob@stdlib.com>
+api.stdlib.com
+
+// stereosense GmbH : https://www.involve.me
+// Submitted by Florian Burmann <publicsuffix@involve.me>
+feedback.ac
+forms.ac
+assessments.cx
+calculators.cx
+funnels.cx
+paynow.cx
+quizzes.cx
+researched.cx
+tests.cx
+surveys.so
+
+// Storipress : https://storipress.com
+// Submitted by Benno Liu <benno@storipress.com>
+storipress.app
+
+// Storj Labs Inc. : https://storj.io/
+// Submitted by Philip Hutchins <hostmaster@storj.io>
+storj.farm
+
+// Streak : https://streak.com
+// Submitted by Blake Kadatz <eng@streak.com>
+streak-link.com
+streaklinks.com
+streakusercontent.com
+
+// Studenten Net Twente : http://www.snt.utwente.nl/
+// Submitted by Silke Hofstra <syscom@snt.utwente.nl>
+utwente.io
+
+// Student-Run Computing Facility : https://www.srcf.net/
+// Submitted by Edwin Balani <sysadmins@srcf.net>
+soc.srcf.net
+user.srcf.net
+
+// Sub 6 Limited: http://www.sub6.com
+// Submitted by Dan Miller <dm@sub6.com>
+temp-dns.com
+
+// Supabase : https://supabase.io
+// Submitted by Inian Parameshwaran <security@supabase.io>
+supabase.co
+supabase.in
+supabase.net
+
+// Symfony, SAS : https://symfony.com/
+// Submitted by Fabien Potencier <fabien@symfony.com>
+*.sensiosite.cloud
+*.s5y.io
+
+// Syncloud : https://syncloud.org
+// Submitted by Boris Rybalkin <syncloud@syncloud.it>
+syncloud.it
+
+// Synology, Inc. : https://www.synology.com/
+// Submitted by Rony Weng <ronyweng@synology.com>
+dscloud.biz
+direct.quickconnect.cn
+dsmynas.com
+familyds.com
+diskstation.me
+dscloud.me
+i234.me
+myds.me
+synology.me
+dscloud.mobi
+dsmynas.net
+familyds.net
+dsmynas.org
+familyds.org
+direct.quickconnect.to
+vpnplus.to
+
+// Tabit Technologies Ltd. : https://tabit.cloud/
+// Submitted by Oren Agiv <oren@tabit.cloud>
+mytabit.com
+mytabit.co.il
+tabitorder.co.il
+
+// TAIFUN Software AG : http://taifun-software.de
+// Submitted by Bjoern Henke <dev-server@taifun-software.de>
+taifun-dns.de
+
+// Tailscale Inc. : https://www.tailscale.com
+// Submitted by David Anderson <danderson@tailscale.com>
+beta.tailscale.net
+ts.net
+*.c.ts.net
+
+// TASK geographical domains (https://www.task.gda.pl/uslugi/dns)
+gda.pl
+gdansk.pl
+gdynia.pl
+med.pl
+sopot.pl
+
+// tawk.to, Inc : https://www.tawk.to
+// Submitted by tawk.to developer team <dev-accounts@tawk.to>
+p.tawk.email
+p.tawkto.email
+
+// team.blue https://team.blue
+// Submitted by Cedric Dubois <cedric.dubois@team.blue>
+site.tb-hosting.com
+
+// Teckids e.V. : https://www.teckids.org
+// Submitted by Dominik George <dominik.george@teckids.org>
+edugit.io
+s3.teckids.org
+
+// Telebit : https://telebit.cloud
+// Submitted by AJ ONeal <aj@telebit.cloud>
+telebit.app
+telebit.io
+*.telebit.xyz
+
+// Thingdust AG : https://thingdust.com/
+// Submitted by Adrian Imboden <adi@thingdust.com>
+*.firenet.ch
+*.svc.firenet.ch
+reservd.com
+thingdustdata.com
+cust.dev.thingdust.io
+reservd.dev.thingdust.io
+cust.disrec.thingdust.io
+reservd.disrec.thingdust.io
+cust.prod.thingdust.io
+cust.testing.thingdust.io
+reservd.testing.thingdust.io
+
+// ticket i/O GmbH : https://ticket.io
+// Submitted by Christian Franke <it@ticket.io>
+tickets.io
+
+// Tlon.io : https://tlon.io
+// Submitted by Mark Staarink <mark@tlon.io>
+arvo.network
+azimuth.network
+tlon.network
+
+// Tor Project, Inc. : https://torproject.org
+// Submitted by Antoine Beaupré <anarcat@torproject.org>
+torproject.net
+pages.torproject.net
+
+// TownNews.com : http://www.townnews.com
+// Submitted by Dustin Ward <dward@townnews.com>
+bloxcms.com
+townnews-staging.com
+
+// TrafficPlex GmbH : https://www.trafficplex.de/
+// Submitted by Phillipp Röll <phillipp.roell@trafficplex.de>
+12hp.at
+2ix.at
+4lima.at
+lima-city.at
+12hp.ch
+2ix.ch
+4lima.ch
+lima-city.ch
+trafficplex.cloud
+de.cool
+12hp.de
+2ix.de
+4lima.de
+lima-city.de
+1337.pictures
+clan.rip
+lima-city.rocks
+webspace.rocks
+lima.zone
+
+// TransIP : https://www.transip.nl
+// Submitted by Rory Breuk <rbreuk@transip.nl>
+*.transurl.be
+*.transurl.eu
+*.transurl.nl
+
+// TransIP: https://www.transip.nl
+// Submitted by Cedric Dubois <cedric.dubois@team.blue>
+site.transip.me
+
+// TuxFamily : http://tuxfamily.org
+// Submitted by TuxFamily administrators <adm@staff.tuxfamily.org>
+tuxfamily.org
+
+// TwoDNS : https://www.twodns.de/
+// Submitted by TwoDNS-Support <support@two-dns.de>
+dd-dns.de
+dray-dns.de
+draydns.de
+dyn-vpn.de
+dynvpn.de
+mein-vigor.de
+my-vigor.de
+my-wan.de
+syno-ds.de
+synology-diskstation.de
+synology-ds.de
+diskstation.eu
+diskstation.org
+
+// Typedream : https://typedream.com
+// Submitted by Putri Karunia <putri@typedream.com>
+typedream.app
+
+// Typeform : https://www.typeform.com
+// Submitted by Sergi Ferriz <sergi.ferriz@typeform.com>
+pro.typeform.com
+
+// Uberspace : https://uberspace.de
+// Submitted by Moritz Werner <mwerner@jonaspasche.com>
+*.uberspace.de
+uber.space
+
+// UDR Limited : http://www.udr.hk.com
+// Submitted by registry <hostmaster@udr.hk.com>
+hk.com
+inc.hk
+ltd.hk
+hk.org
+
+// UK Intis Telecom LTD : https://it.com
+// Submitted by ITComdomains <to@it.com>
+it.com
+
+// Unison Computing, PBC : https://unison.cloud
+// Submitted by Simon Højberg <security@unison.cloud>
+unison-services.cloud
+
+// UNIVERSAL DOMAIN REGISTRY : https://www.udr.org.yt/
+// see also: whois -h whois.udr.org.yt help
+// Submitted by Atanunu Igbunuroghene <publicsuffixlist@udr.org.yt>
+name.pm
+sch.tf
+biz.wf
+sch.wf
+org.yt
+
+// United Gameserver GmbH : https://united-gameserver.de
+// Submitted by Stefan Schwarz <sysadm@united-gameserver.de>
+virtual-user.de
+virtualuser.de
+
+// Upli : https://upli.io
+// Submitted by Lenny Bakkalian <lenny.bakkalian@gmail.com>
+upli.io
+
+// urown.net : https://urown.net
+// Submitted by Hostmaster <hostmaster@urown.net>
+urown.cloud
+dnsupdate.info
+
+// .US
+// Submitted by Ed Moore <Ed.Moore@lib.de.us>
+lib.de.us
+
+// Val Town, Inc : https://val.town/
+// Submitted by Tom MacWright <security@val.town>
+express.val.run
+web.val.run
+
+// VeryPositive SIA : http://very.lv
+// Submitted by Danko Aleksejevs <danko@very.lv>
+2038.io
+
+// Vercel, Inc : https://vercel.com/
+// Submitted by Connor Davis <security@vercel.com>
+vercel.app
+vercel.dev
+now.sh
+
+// Viprinet Europe GmbH : http://www.viprinet.com
+// Submitted by Simon Kissel <hostmaster@viprinet.com>
+router.management
+
+// Virtual-Info : https://www.virtual-info.info/
+// Submitted by Adnan RIHAN <hostmaster@v-info.info>
+v-info.info
+
+// Voorloper.com: https://voorloper.com
+// Submitted by Nathan van Bakel <info@voorloper.com>
+voorloper.cloud
+
+// V.UA Domain Administrator : https://domain.v.ua/
+// Submitted by Serhii Rostilo <sergey@rostilo.kiev.ua>
+v.ua
+
+// Vultr Objects : https://www.vultr.com/products/object-storage/
+// Submitted by Niels Maumenee <storage@vultr.com>
+*.vultrobjects.com
+
+// Waffle Computer Inc., Ltd. : https://docs.waffleinfo.com
+// Submitted by Masayuki Note <masa@blade.wafflecell.com>
+wafflecell.com
+
+// Webflow, Inc. : https://www.webflow.com
+// Submitted by Webflow Security Team <security@webflow.com>
+webflow.io
+webflowtest.io
+
+// WebHare bv: https://www.webhare.com/
+// Submitted by Arnold Hendriks <info@webhare.com>
+*.webhare.dev
+
+// WebHotelier Technologies Ltd: https://www.webhotelier.net/
+// Submitted by Apostolos Tsakpinis <apostolos.tsakpinis@gmail.com>
+bookonline.app
+hotelwithflight.com
+reserve-online.com
+reserve-online.net
+
+// WebPros International, LLC : https://webpros.com/
+// Submitted by Nicolas Rochelemagne <public.suffix@webpros.com>
+cprapid.com
+pleskns.com
+wp2.host
+pdns.page
+plesk.page
+wpsquared.site
+
+// WebWaddle Ltd: https://webwaddle.com/
+// Submitted by Merlin Glander <hostmaster@webwaddle.com>
+*.wadl.top
+
+// WeDeploy by Liferay, Inc. : https://www.wedeploy.com
+// Submitted by Henrique Vicente <security@wedeploy.com>
+wedeploy.io
+wedeploy.me
+wedeploy.sh
+
+// Western Digital Technologies, Inc : https://www.wdc.com
+// Submitted by Jung Jin <jungseok.jin@wdc.com>
+remotewd.com
+
+// Whatbox Inc. : https://whatbox.ca/
+// Submitted by Anthony Ryan <servers@whatbox.ca>
+box.ca
+
+// WIARD Enterprises : https://wiardweb.com
+// Submitted by Kidd Hustle <kiddhustle@wiardweb.com>
+pages.wiardweb.com
+
+// Wikimedia Labs : https://wikitech.wikimedia.org
+// Submitted by Arturo Borrero Gonzalez <aborrero@wikimedia.org>
+toolforge.org
+wmcloud.org
+wmflabs.org
+
+// WISP : https://wisp.gg
+// Submitted by Stepan Fedotov <stepan@wisp.gg>
+panel.gg
+daemon.panel.gg
+
+// Wix.com, Inc. : https://www.wix.com
+// Submitted by Shahar Talmi / Alon Kochba <publicsuffixlist@wix.com>
+wixsite.com
+wixstudio.com
+editorx.io
+wixstudio.io
+wix.run
+
+// Wizard Zines : https://wizardzines.com
+// Submitted by Julia Evans <julia@wizardzines.com>
+messwithdns.com
+
+// WoltLab GmbH : https://www.woltlab.com
+// Submitted by Tim Düsterhus <security@woltlab.cloud>
+woltlab-demo.com
+myforum.community
+community-pro.de
+diskussionsbereich.de
+community-pro.net
+meinforum.net
+
+// Woods Valldata : https://www.woodsvalldata.co.uk/
+// Submitted by Chris Whittle <chris.whittle@woodsvalldata.co.uk>
+affinitylottery.org.uk
+raffleentry.org.uk
+weeklylottery.org.uk
+
+// WP Engine : https://wpengine.com/
+// Submitted by Michael Smith <michael.smith@wpengine.com>
+// Submitted by Brandon DuRette <brandon.durette@wpengine.com>
+wpenginepowered.com
+js.wpenginepowered.com
+
+// XenonCloud GbR: https://xenoncloud.net
+// Submitted by Julian Uphoff <publicsuffixlist@xenoncloud.net>
+half.host
+
+// XnBay Technology : http://www.xnbay.com/
+// Submitted by XnBay Developer <developer.xncloud@gmail.com>
+xnbay.com
+u2.xnbay.com
+u2-local.xnbay.com
+
+// XS4ALL Internet bv : https://www.xs4all.nl/
+// Submitted by Daniel Mostertman <unixbeheer+publicsuffix@xs4all.net>
+cistron.nl
+demon.nl
+xs4all.space
+
+// Yandex.Cloud LLC: https://cloud.yandex.com
+// Submitted by Alexander Lodin <security+psl@yandex-team.ru>
+yandexcloud.net
+storage.yandexcloud.net
+website.yandexcloud.net
+
+// YesCourse Pty Ltd : https://yescourse.com
+// Submitted by Atul Bhouraskar <atul@yescourse.com>
+official.academy
+
+// Yola : https://www.yola.com/
+// Submitted by Stefano Rivera <stefano@yola.com>
+yolasite.com
+
+// Yombo : https://yombo.net
+// Submitted by Mitch Schwenk <mitch@yombo.net>
+ybo.faith
+yombo.me
+homelink.one
+ybo.party
+ybo.review
+ybo.science
+ybo.trade
+
+// Yunohost : https://yunohost.org
+// Submitted by Valentin Grimaud <security@yunohost.org>
+ynh.fr
+nohost.me
+noho.st
+
+// ZaNiC : http://www.za.net/
+// Submitted by registry <hostmaster@nic.za.net>
+za.net
+za.org
+
+// ZAP-Hosting GmbH & Co. KG : https://zap-hosting.com
+// Submitted by Julian Alker <security@zap-hosting.com>
+zap.cloud
+
+// Zeabur : https://zeabur.com/
+// Submitted by Zeabur Team <contact@zeabur.com>
+zeabur.app
+
+// Zine EOOD : https://zine.bg/
+// Submitted by Martin Angelov <martin@zine.bg>
+bss.design
+
+// Zitcom A/S : https://www.zitcom.dk
+// Submitted by Emil Stahl <esp@zitcom.dk>
+basicserver.io
+virtualserver.io
+enterprisecloud.nu
+
+// ===END PRIVATE DOMAINS===
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix.rb
similarity index 97%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix.rb
index c0f3fab67d968..bd131e3f02742 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix.rb
@@ -4,7 +4,7 @@
 #
 # Domain name parser based on the Public Suffix List.
 #
-# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
+# Copyright (c) 2009-2024 Simone Carletti <weppos@weppos.net>
 
 require_relative "public_suffix/domain"
 require_relative "public_suffix/version"
@@ -169,7 +169,7 @@ def self.normalize(name)
 
     return DomainInvalid.new("Name is blank") if name.empty?
     return DomainInvalid.new("Name starts with a dot") if name.start_with?(DOT)
-    return DomainInvalid.new("%s is not expected to contain a scheme" % name) if name.include?("://")
+    return DomainInvalid.new(format("%s is not expected to contain a scheme", name)) if name.include?("://")
 
     name
   end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/domain.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/domain.rb
similarity index 99%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/domain.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/domain.rb
index f7a9c49418f6a..54e05f98c50ec 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/domain.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/domain.rb
@@ -4,7 +4,7 @@
 #
 # Domain name parser based on the Public Suffix List.
 #
-# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
+# Copyright (c) 2009-2024 Simone Carletti <weppos@weppos.net>
 
 module PublicSuffix
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/errors.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/errors.rb
new file mode 100644
index 0000000000000..40ee981418ecf
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/errors.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# = Public Suffix
+#
+# Domain name parser based on the Public Suffix List.
+#
+# Copyright (c) 2009-2024 Simone Carletti <weppos@weppos.net>
+
+module PublicSuffix
+
+  class Error < StandardError
+  end
+
+  # Raised when trying to parse an invalid name.
+  # A name is considered invalid when no rule is found in the definition list.
+  #
+  # @example
+  #
+  #   PublicSuffix.parse("nic.test")
+  #   # => PublicSuffix::DomainInvalid
+  #
+  #   PublicSuffix.parse("http://www.nic.it")
+  #   # => PublicSuffix::DomainInvalid
+  #
+  class DomainInvalid < Error
+  end
+
+  # Raised when trying to parse a name that matches a suffix.
+  #
+  # @example
+  #
+  #   PublicSuffix.parse("nic.do")
+  #   # => PublicSuffix::DomainNotAllowed
+  #
+  #   PublicSuffix.parse("www.nic.do")
+  #   # => PublicSuffix::Domain
+  #
+  class DomainNotAllowed < DomainInvalid
+  end
+
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/list.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/list.rb
new file mode 100644
index 0000000000000..d90b72342f661
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/list.rb
@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+# = Public Suffix
+#
+# Domain name parser based on the Public Suffix List.
+#
+# Copyright (c) 2009-2024 Simone Carletti <weppos@weppos.net>
+
+module PublicSuffix
+
+  # A {PublicSuffix::List} is a collection of one
+  # or more {PublicSuffix::Rule}.
+  #
+  # Given a {PublicSuffix::List},
+  # you can add or remove {PublicSuffix::Rule},
+  # iterate all items in the list or search for the first rule
+  # which matches a specific domain name.
+  #
+  #   # Create a new list
+  #   list =  PublicSuffix::List.new
+  #
+  #   # Push two rules to the list
+  #   list << PublicSuffix::Rule.factory("it")
+  #   list << PublicSuffix::Rule.factory("com")
+  #
+  #   # Get the size of the list
+  #   list.size
+  #   # => 2
+  #
+  #   # Search for the rule matching given domain
+  #   list.find("example.com")
+  #   # => #<PublicSuffix::Rule::Normal>
+  #   list.find("example.org")
+  #   # => nil
+  #
+  # You can create as many {PublicSuffix::List} you want.
+  # The {PublicSuffix::List.default} rule list is used
+  # to tokenize and validate a domain.
+  #
+  class List
+
+    DEFAULT_LIST_PATH = File.expand_path("../../data/list.txt", __dir__)
+
+    # Gets the default rule list.
+    #
+    # Initializes a new {PublicSuffix::List} parsing the content
+    # of {PublicSuffix::List.default_list_content}, if required.
+    #
+    # @return [PublicSuffix::List]
+    def self.default(**options)
+      @default ||= parse(File.read(DEFAULT_LIST_PATH), **options)
+    end
+
+    # Sets the default rule list to +value+.
+    #
+    # @param  value [PublicSuffix::List] the new list
+    # @return [PublicSuffix::List]
+    def self.default=(value)
+      @default = value
+    end
+
+    # Parse given +input+ treating the content as Public Suffix List.
+    #
+    # See http://publicsuffix.org/format/ for more details about input format.
+    #
+    # @param  input [#each_line] the list to parse
+    # @param  private_domains [Boolean] whether to ignore the private domains section
+    # @return [PublicSuffix::List]
+    def self.parse(input, private_domains: true)
+      comment_token = "//"
+      private_token = "===BEGIN PRIVATE DOMAINS==="
+      section = nil # 1 == ICANN, 2 == PRIVATE
+
+      new do |list|
+        input.each_line do |line|
+          line.strip!
+          case # rubocop:disable Style/EmptyCaseCondition
+
+          # skip blank lines
+          when line.empty?
+            next
+
+          # include private domains or stop scanner
+          when line.include?(private_token)
+            break if !private_domains
+
+            section = 2
+
+          # skip comments
+          when line.start_with?(comment_token) # rubocop:disable Lint/DuplicateBranch
+            next
+
+          else
+            list.add(Rule.factory(line, private: section == 2))
+
+          end
+        end
+      end
+    end
+
+
+    # Initializes an empty {PublicSuffix::List}.
+    #
+    # @yield [self] Yields on self.
+    # @yieldparam [PublicSuffix::List] self The newly created instance.
+    def initialize
+      @rules = {}
+      yield(self) if block_given?
+    end
+
+
+    # Checks whether two lists are equal.
+    #
+    # List <tt>one</tt> is equal to <tt>two</tt>, if <tt>two</tt> is an instance of
+    # {PublicSuffix::List} and each +PublicSuffix::Rule::*+
+    # in list <tt>one</tt> is available in list <tt>two</tt>, in the same order.
+    #
+    # @param  other [PublicSuffix::List] the List to compare
+    # @return [Boolean]
+    def ==(other)
+      return false unless other.is_a?(List)
+
+      equal?(other) || @rules == other.rules
+    end
+    alias eql? ==
+
+    # Iterates each rule in the list.
+    def each(&block)
+      Enumerator.new do |y|
+        @rules.each do |key, node|
+          y << entry_to_rule(node, key)
+        end
+      end.each(&block)
+    end
+
+
+    # Adds the given object to the list and optionally refreshes the rule index.
+    #
+    # @param  rule [PublicSuffix::Rule::*] the rule to add to the list
+    # @return [self]
+    def add(rule)
+      @rules[rule.value] = rule_to_entry(rule)
+      self
+    end
+    alias << add
+
+    # Gets the number of rules in the list.
+    #
+    # @return [Integer]
+    def size
+      @rules.size
+    end
+
+    # Checks whether the list is empty.
+    #
+    # @return [Boolean]
+    def empty?
+      @rules.empty?
+    end
+
+    # Removes all rules.
+    #
+    # @return [self]
+    def clear
+      @rules.clear
+      self
+    end
+
+    # Finds and returns the rule corresponding to the longest public suffix for the hostname.
+    #
+    # @param  name [#to_s] the hostname
+    # @param  default [PublicSuffix::Rule::*] the default rule to return in case no rule matches
+    # @return [PublicSuffix::Rule::*]
+    def find(name, default: default_rule, **options)
+      rule = select(name, **options).inject do |l, r|
+        return r if r.instance_of?(Rule::Exception)
+
+        l.length > r.length ? l : r
+      end
+      rule || default
+    end
+
+    # Selects all the rules matching given hostame.
+    #
+    # If `ignore_private` is set to true, the algorithm will skip the rules that are flagged as
+    # private domain. Note that the rules will still be part of the loop.
+    # If you frequently need to access lists ignoring the private domains,
+    # you should create a list that doesn't include these domains setting the
+    # `private_domains: false` option when calling {.parse}.
+    #
+    # Note that this method is currently private, as you should not rely on it. Instead,
+    # the public interface is {#find}. The current internal algorithm allows to return all
+    # matching rules, but different data structures may not be able to do it, and instead would
+    # return only the match. For this reason, you should rely on {#find}.
+    #
+    # @param  name [#to_s] the hostname
+    # @param  ignore_private [Boolean]
+    # @return [Array<PublicSuffix::Rule::*>]
+    def select(name, ignore_private: false)
+      name = name.to_s
+
+      parts = name.split(DOT).reverse!
+      index = 0
+      query = parts[index]
+      rules = []
+
+      loop do
+        match = @rules[query]
+        rules << entry_to_rule(match, query) if !match.nil? && (ignore_private == false || match.private == false)
+
+        index += 1
+        break if index >= parts.size
+
+        query = parts[index] + DOT + query
+      end
+
+      rules
+    end
+    private :select
+
+    # Gets the default rule.
+    #
+    # @see PublicSuffix::Rule.default_rule
+    #
+    # @return [PublicSuffix::Rule::*]
+    def default_rule
+      PublicSuffix::Rule.default
+    end
+
+
+    protected
+
+    attr_reader :rules
+
+
+    private
+
+    def entry_to_rule(entry, value)
+      entry.type.new(value: value, length: entry.length, private: entry.private)
+    end
+
+    def rule_to_entry(rule)
+      Rule::Entry.new(rule.class, rule.length, rule.private)
+    end
+
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/rule.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/rule.rb
similarity index 96%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/rule.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/rule.rb
index d41a48074b0c9..23696f34880de 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/public_suffix-4.0.7/lib/public_suffix/rule.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/rule.rb
@@ -4,7 +4,7 @@
 #
 # Domain name parser based on the Public Suffix List.
 #
-# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
+# Copyright (c) 2009-2024 Simone Carletti <weppos@weppos.net>
 
 module PublicSuffix
 
@@ -125,7 +125,7 @@ def self.build(content, private: false)
       # @param  private [Boolean]
       def initialize(value:, length: nil, private: false)
         @value    = value.to_s
-        @length   = length || @value.count(DOT) + 1
+        @length   = length || (@value.count(DOT) + 1)
         @private  = private
       end
 
@@ -161,7 +161,7 @@ def ==(other)
       # @param  name [String] the domain name to check
       # @return [Boolean]
       def match?(name)
-        # Note: it works because of the assumption there are no
+        # NOTE: it works because of the assumption there are no
         # rules like foo.*.com. If the assumption is incorrect,
         # we need to properly walk the input and skip parts according
         # to wildcard component.
@@ -221,7 +221,7 @@ class Wildcard < Base
       # @param  content [String] the content of the rule
       # @param  private [Boolean]
       def self.build(content, private: false)
-        new(value: content.to_s[2..-1], private: private)
+        new(value: content.to_s[2..], private: private)
       end
 
       # Initializes a new rule.
@@ -230,7 +230,7 @@ def self.build(content, private: false)
       # @param  length [Integer]
       # @param  private [Boolean]
       def initialize(value:, length: nil, private: false)
-        super(value: value, length: length, private: private)
+        super
         length or @length += 1 # * counts as 1
       end
 
@@ -269,7 +269,7 @@ class Exception < Base
       # @param  content [#to_s] the content of the rule
       # @param  private [Boolean]
       def self.build(content, private: false)
-        new(value: content.to_s[1..-1], private: private)
+        new(value: content.to_s[1..], private: private)
       end
 
       # Gets the original rule definition.
@@ -299,7 +299,7 @@ def decompose(domain)
       #
       # @return [Array<String>]
       def parts
-        @value.split(DOT)[1..-1]
+        @value.split(DOT)[1..]
       end
 
     end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/version.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/version.rb
new file mode 100644
index 0000000000000..2584d3747f1f3
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/public_suffix-6.0.1/lib/public_suffix/version.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# = Public Suffix
+#
+# Domain name parser based on the Public Suffix List.
+#
+# Copyright (c) 2009-2024 Simone Carletti <weppos@weppos.net>
+
+module PublicSuffix
+
+  # @return [String] the current library version
+  VERSION = "6.0.1"
+
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/LICENSE b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/LICENSE
new file mode 100644
index 0000000000000..89dd7d651b27e
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015, 2016, 2017, 2018 William Woodruff <william @ yossarian.net>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho.rb
similarity index 99%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho.rb
index 8b9e24f81a18c..b9a90bb833360 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho.rb
@@ -2,6 +2,7 @@
 
 require "open3"
 
+require_relative "macho/utils"
 require_relative "macho/structure"
 require_relative "macho/view"
 require_relative "macho/headers"
@@ -10,13 +11,12 @@
 require_relative "macho/macho_file"
 require_relative "macho/fat_file"
 require_relative "macho/exceptions"
-require_relative "macho/utils"
 require_relative "macho/tools"
 
 # The primary namespace for ruby-macho.
 module MachO
   # release version
-  VERSION = "3.0.0"
+  VERSION = "4.1.0"
 
   # Opens the given filename as a MachOFile or FatFile, depending on its magic.
   # @param filename [String] the file being opened
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/exceptions.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/exceptions.rb
new file mode 100644
index 0000000000000..66af33427f941
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/exceptions.rb
@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+module MachO
+  # A generic Mach-O error in execution.
+  class MachOError < RuntimeError
+  end
+
+  # Raised when a Mach-O file modification fails.
+  class ModificationError < MachOError
+  end
+
+  # Raised when codesigning fails. Certain environments
+  # may want to rescue this to treat it as non-fatal.
+  class CodeSigningError < MachOError
+  end
+
+  # Raised when a Mach-O file modification fails but can be recovered when
+  # operating on multiple Mach-O slices of a fat binary in non-strict mode.
+  class RecoverableModificationError < ModificationError
+    # @return [Integer, nil] The index of the Mach-O slice of a fat binary for
+    #   which modification failed or `nil` if not a fat binary. This is used to
+    #   make the error message more useful.
+    attr_accessor :macho_slice
+
+    # @return [String] The exception message.
+    def to_s
+      s = super.to_s
+      s = "While modifying Mach-O slice #{@macho_slice}: #{s}" if @macho_slice
+      s
+    end
+  end
+
+  # Raised when a file is not a Mach-O.
+  class NotAMachOError < MachOError
+  end
+
+  # Raised when a file is too short to be a valid Mach-O file.
+  class TruncatedFileError < NotAMachOError
+    def initialize
+      super "File is too short to be a valid Mach-O"
+    end
+  end
+
+  # Raised when a file's magic bytes are not valid Mach-O magic.
+  class MagicError < NotAMachOError
+    # @param num [Integer] the unknown number
+    def initialize(magic)
+      super "Unrecognized Mach-O magic: 0x%02<magic>x" % { :magic => magic }
+    end
+  end
+
+  # Raised when a file is a Java classfile instead of a fat Mach-O.
+  class JavaClassFileError < NotAMachOError
+    def initialize
+      super "File is a Java class file"
+    end
+  end
+
+  # Raised when a a fat Mach-O file has zero architectures
+  class ZeroArchitectureError < NotAMachOError
+    def initialize
+      super "Fat file has zero internal architectures"
+    end
+  end
+
+  # Raised when there is a mismatch between the fat arch
+  # and internal slice cputype or cpusubtype.
+  class CPUTypeMismatchError < NotAMachOError
+    def initialize(fat_cputype, fat_cpusubtype, macho_cputype, macho_cpusubtype)
+      # @param cputype_fat [Integer] the CPU type in the fat header
+      # @param cpusubtype_fat [Integer] the CPU subtype in the fat header
+      # @param cputype_macho [Integer] the CPU type in the macho header
+      # @param cpusubtype_macho [Integer] the CPU subtype in the macho header
+      super ("Mismatch between cputypes >> 0x%08<fat_cputype>x and 0x%08<macho_cputype>x\n" \
+             "and/or cpusubtypes >> 0x%08<fat_cpusubtype>x and 0x%08<macho_cpusubtype>x" %
+            { :fat_cputype => fat_cputype, :macho_cputype => macho_cputype,
+              :fat_cpusubtype => fat_cpusubtype, :macho_cpusubtype => macho_cpusubtype })
+    end
+  end
+
+  # Raised when a fat binary is loaded with MachOFile.
+  class FatBinaryError < MachOError
+    def initialize
+      super "Fat binaries must be loaded with MachO::FatFile"
+    end
+  end
+
+  # Raised when a Mach-O is loaded with FatFile.
+  class MachOBinaryError < MachOError
+    def initialize
+      super "Normal binaries must be loaded with MachO::MachOFile"
+    end
+  end
+
+  # Raised when the CPU type is unknown.
+  class CPUTypeError < MachOError
+    # @param cputype [Integer] the unknown CPU type
+    def initialize(cputype)
+      super "Unrecognized CPU type: 0x%08<cputype>x" % { :cputype => cputype }
+    end
+  end
+
+  # Raised when the CPU type/sub-type pair is unknown.
+  class CPUSubtypeError < MachOError
+    # @param cputype [Integer] the CPU type of the unknown pair
+    # @param cpusubtype [Integer] the CPU sub-type of the unknown pair
+    def initialize(cputype, cpusubtype)
+      super "Unrecognized CPU sub-type: 0x%08<cpusubtype>x " \
+            "(for CPU type: 0x%08<cputype>x" % { :cputype => cputype, :cpusubtype => cpusubtype }
+    end
+  end
+
+  # Raised when a mach-o file's filetype field is unknown.
+  class FiletypeError < MachOError
+    # @param num [Integer] the unknown number
+    def initialize(num)
+      super "Unrecognized Mach-O filetype code: 0x%02<num>x" % { :num => num }
+    end
+  end
+
+  # Raised when an unknown load command is encountered.
+  class LoadCommandError < MachOError
+    # @param num [Integer] the unknown number
+    def initialize(num)
+      super "Unrecognized Mach-O load command: 0x%02<num>x" % { :num => num }
+    end
+  end
+
+  # Raised when a load command can't be created manually.
+  class LoadCommandNotCreatableError < MachOError
+    # @param cmd_sym [Symbol] the uncreatable load command's symbol
+    def initialize(cmd_sym)
+      super "Load commands of type #{cmd_sym} cannot be created manually"
+    end
+  end
+
+  # Raised when the number of arguments used to create a load command manually
+  # is wrong.
+  class LoadCommandCreationArityError < MachOError
+    # @param cmd_sym [Symbol] the load command's symbol
+    # @param expected_arity [Integer] the number of arguments expected
+    # @param actual_arity [Integer] the number of arguments received
+    def initialize(cmd_sym, expected_arity, actual_arity)
+      super "Expected #{expected_arity} arguments for #{cmd_sym} creation, " \
+            "got #{actual_arity}"
+    end
+  end
+
+  # Raised when a load command can't be serialized.
+  class LoadCommandNotSerializableError < MachOError
+    # @param cmd_sym [Symbol] the load command's symbol
+    def initialize(cmd_sym)
+      super "Load commands of type #{cmd_sym} cannot be serialized"
+    end
+  end
+
+  # Raised when a load command string is malformed in some way.
+  class LCStrMalformedError < MachOError
+    # @param lc [MachO::LoadCommand] the load command containing the string
+    def initialize(lc)
+      super "Load command #{lc.type} at offset #{lc.view.offset} contains a " \
+            "malformed string"
+    end
+  end
+
+  # Raised when a change at an offset is not valid.
+  class OffsetInsertionError < ModificationError
+    # @param offset [Integer] the invalid offset
+    def initialize(offset)
+      super "Insertion at offset #{offset} is not valid"
+    end
+  end
+
+  # Raised when load commands are too large to fit in the current file.
+  class HeaderPadError < ModificationError
+    # @param filename [String] the filename
+    def initialize(filename)
+      super "Updated load commands do not fit in the header of " \
+            "#{filename}. #{filename} needs to be relinked, possibly with " \
+            "-headerpad or -headerpad_max_install_names"
+    end
+  end
+
+  # Raised when attempting to change a dylib name that doesn't exist.
+  class DylibUnknownError < RecoverableModificationError
+    # @param dylib [String] the unknown shared library name
+    def initialize(dylib)
+      super "No such dylib name: #{dylib}"
+    end
+  end
+
+  # Raised when a dylib is missing an ID
+  class DylibIdMissingError < RecoverableModificationError
+    def initialize
+      super "Dylib is missing a dylib ID"
+    end
+  end
+
+  # Raised when attempting to change an rpath that doesn't exist.
+  class RpathUnknownError < RecoverableModificationError
+    # @param path [String] the unknown runtime path
+    def initialize(path)
+      super "No such runtime path: #{path}"
+    end
+  end
+
+  # Raised when attempting to add an rpath that already exists.
+  class RpathExistsError < RecoverableModificationError
+    # @param path [String] the extant path
+    def initialize(path)
+      super "#{path} already exists"
+    end
+  end
+
+  # Raised whenever unfinished code is called.
+  class UnimplementedError < MachOError
+    # @param thing [String] the thing that is unimplemented
+    def initialize(thing)
+      super "Unimplemented: #{thing}"
+    end
+  end
+
+  # Raised when attempting to create a {FatFile} from one or more {MachOFile}s
+  #  whose offsets will not fit within the resulting 32-bit {Headers::FatArch#offset} fields.
+  class FatArchOffsetOverflowError < MachOError
+    # @param offset [Integer] the offending offset
+    def initialize(offset)
+      super "Offset #{offset} exceeds the 32-bit width of a fat_arch offset. " \
+            "Consider merging with `fat64: true`"
+    end
+  end
+
+  # Raised when attempting to parse a compressed Mach-O without explicitly
+  # requesting decompression.
+  class CompressedMachOError < MachOError
+  end
+
+  # Raised when attempting to decompress a compressed Mach-O without adequate
+  # dependencies, or on other decompression errors.
+  class DecompressionError < MachOError
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/fat_file.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/fat_file.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/fat_file.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/fat_file.rb
index 569250cc75e22..637e1c5aa50d2 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/fat_file.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/fat_file.rb
@@ -327,6 +327,8 @@ def to_h
     # @raise [MagicError] if the magic is not valid Mach-O magic
     # @raise [MachOBinaryError] if the magic is for a non-fat Mach-O file
     # @raise [JavaClassFileError] if the file is a Java classfile
+    # @raise [ZeroArchitectureError] if the file has no internal slices
+    #  (i.e., nfat_arch == 0) and the permissive option is not set
     # @api private
     def populate_fat_header
       # the smallest fat Mach-O header is 8 bytes
@@ -346,6 +348,9 @@ def populate_fat_header
       # formats.
       raise JavaClassFileError if fh.nfat_arch > 30
 
+      # Rationale: return an error if the file has no internal slices.
+      raise ZeroArchitectureError if fh.nfat_arch.zero?
+
       fh
     end
 
@@ -374,6 +379,13 @@ def populate_machos
 
       fat_archs.each do |arch|
         machos << MachOFile.new_from_bin(@raw_data[arch.offset, arch.size], **options)
+
+        # Make sure that each fat_arch and internal slice.
+        # contain matching cputypes and cpusubtypes
+        next if machos.last.header.cputype == arch.cputype &&
+                machos.last.header.cpusubtype == arch.cpusubtype
+
+        raise CPUTypeMismatchError.new(arch.cputype, arch.cpusubtype, machos.last.header.cputype, machos.last.header.cpusubtype)
       end
 
       machos
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/headers.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/headers.rb
similarity index 85%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/headers.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/headers.rb
index a810f6317dc49..4abdd533d43d1 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/headers.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/headers.rb
@@ -505,30 +505,14 @@ module Headers
     # @see MachO::FatArch
     class FatHeader < MachOStructure
       # @return [Integer] the magic number of the header (and file)
-      attr_reader :magic
+      field :magic, :uint32, :endian => :big
 
       # @return [Integer] the number of fat architecture structures following the header
-      attr_reader :nfat_arch
-
-      # always big-endian
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "N2"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 8
-
-      # @api private
-      def initialize(magic, nfat_arch)
-        super()
-        @magic = magic
-        @nfat_arch = nfat_arch
-      end
+      field :nfat_arch, :uint32, :endian => :big
 
       # @return [String] the serialized fields of the fat header
       def serialize
-        [magic, nfat_arch].pack(FORMAT)
+        [magic, nfat_arch].pack(self.class.format)
       end
 
       # @return [Hash] a hash representation of this {FatHeader}
@@ -548,42 +532,23 @@ def to_h
     # @see MachO::Headers::FatHeader
     class FatArch < MachOStructure
       # @return [Integer] the CPU type of the Mach-O
-      attr_reader :cputype
+      field :cputype, :uint32, :endian => :big
 
       # @return [Integer] the CPU subtype of the Mach-O
-      attr_reader :cpusubtype
+      field :cpusubtype, :uint32, :endian => :big, :mask => CPU_SUBTYPE_MASK
 
       # @return [Integer] the file offset to the beginning of the Mach-O data
-      attr_reader :offset
+      field :offset, :uint32, :endian => :big
 
       # @return [Integer] the size, in bytes, of the Mach-O data
-      attr_reader :size
+      field :size, :uint32, :endian => :big
 
       # @return [Integer] the alignment, as a power of 2
-      attr_reader :align
-
-      # @note Always big endian.
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L>5"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 20
-
-      # @api private
-      def initialize(cputype, cpusubtype, offset, size, align)
-        super()
-        @cputype = cputype
-        @cpusubtype = cpusubtype & ~CPU_SUBTYPE_MASK
-        @offset = offset
-        @size = size
-        @align = align
-      end
+      field :align, :uint32, :endian => :big
 
       # @return [String] the serialized fields of the fat arch
       def serialize
-        [cputype, cpusubtype, offset, size, align].pack(FORMAT)
+        [cputype, cpusubtype, offset, size, align].pack(self.class.format)
       end
 
       # @return [Hash] a hash representation of this {FatArch}
@@ -606,27 +571,18 @@ def to_h
     #  Mach-Os that it points to necessarily *are* 64-bit.
     # @see MachO::Headers::FatHeader
     class FatArch64 < FatArch
-      # @return [void]
-      attr_reader :reserved
-
-      # @note Always big endian.
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L>2Q>2L>2"
+      # @return [Integer] the file offset to the beginning of the Mach-O data
+      field :offset, :uint64, :endian => :big
 
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 32
+      # @return [Integer] the size, in bytes, of the Mach-O data
+      field :size, :uint64, :endian => :big
 
-      # @api private
-      def initialize(cputype, cpusubtype, offset, size, align, reserved = 0)
-        super(cputype, cpusubtype, offset, size, align)
-        @reserved = reserved
-      end
+      # @return [void]
+      field :reserved, :uint32, :endian => :big, :default => 0
 
       # @return [String] the serialized fields of the fat arch
       def serialize
-        [cputype, cpusubtype, offset, size, align, reserved].pack(FORMAT)
+        [cputype, cpusubtype, offset, size, align, reserved].pack(self.class.format)
       end
 
       # @return [Hash] a hash representation of this {FatArch64}
@@ -640,48 +596,25 @@ def to_h
     # 32-bit Mach-O file header structure
     class MachHeader < MachOStructure
       # @return [Integer] the magic number
-      attr_reader :magic
+      field :magic, :uint32
 
       # @return [Integer] the CPU type of the Mach-O
-      attr_reader :cputype
+      field :cputype, :uint32
 
       # @return [Integer] the CPU subtype of the Mach-O
-      attr_reader :cpusubtype
+      field :cpusubtype, :uint32, :mask => CPU_SUBTYPE_MASK
 
       # @return [Integer] the file type of the Mach-O
-      attr_reader :filetype
+      field :filetype, :uint32
 
       # @return [Integer] the number of load commands in the Mach-O
-      attr_reader :ncmds
+      field :ncmds, :uint32
 
       # @return [Integer] the size of all load commands, in bytes, in the Mach-O
-      attr_reader :sizeofcmds
+      field :sizeofcmds, :uint32
 
       # @return [Integer] the header flags associated with the Mach-O
-      attr_reader :flags
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=7"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 28
-
-      # @api private
-      def initialize(magic, cputype, cpusubtype, filetype, ncmds, sizeofcmds,
-                     flags)
-        super()
-        @magic = magic
-        @cputype = cputype
-        # For now we're not interested in additional capability bits also to be
-        # found in the `cpusubtype` field. We only care about the CPU sub-type.
-        @cpusubtype = cpusubtype & ~CPU_SUBTYPE_MASK
-        @filetype = filetype
-        @ncmds = ncmds
-        @sizeofcmds = sizeofcmds
-        @flags = flags
-      end
+      field :flags, :uint32
 
       # @example
       #  puts "this mach-o has position-independent execution" if header.flag?(:MH_PIE)
@@ -787,22 +720,7 @@ def to_h
     # 64-bit Mach-O file header structure
     class MachHeader64 < MachHeader
       # @return [void]
-      attr_reader :reserved
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L=8"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 32
-
-      # @api private
-      def initialize(magic, cputype, cpusubtype, filetype, ncmds, sizeofcmds,
-                     flags, reserved)
-        super(magic, cputype, cpusubtype, filetype, ncmds, sizeofcmds, flags)
-        @reserved = reserved
-      end
+      field :reserved, :uint32
 
       # @return [Hash] a hash representation of this {MachHeader64}
       def to_h
@@ -815,54 +733,31 @@ def to_h
     # Prelinked kernel/"kernelcache" header structure
     class PrelinkedKernelHeader < MachOStructure
       # @return [Integer] the magic number for a compressed header ({COMPRESSED_MAGIC})
-      attr_reader :signature
+      field :signature, :uint32, :endian => :big
 
       # @return [Integer] the type of compression used
-      attr_reader :compress_type
+      field :compress_type, :uint32, :endian => :big
 
       # @return [Integer] a checksum for the uncompressed data
-      attr_reader :adler32
+      field :adler32, :uint32, :endian => :big
 
       # @return [Integer] the size of the uncompressed data, in bytes
-      attr_reader :uncompressed_size
+      field :uncompressed_size, :uint32, :endian => :big
 
       # @return [Integer] the size of the compressed data, in bytes
-      attr_reader :compressed_size
+      field :compressed_size, :uint32, :endian => :big
 
       # @return [Integer] the version of the prelink format
-      attr_reader :prelink_version
+      field :prelink_version, :uint32, :endian => :big
 
       # @return [void]
-      attr_reader :reserved
+      field :reserved, :string, :size => 40, :unpack => "L>10"
 
       # @return [void]
-      attr_reader :platform_name
+      field :platform_name, :string, :size => 64
 
       # @return [void]
-      attr_reader :root_path
-
-      # @see MachOStructure::FORMAT
-      # @api private
-      FORMAT = "L>6a40a64a256"
-
-      # @see MachOStructure::SIZEOF
-      # @api private
-      SIZEOF = 384
-
-      # @api private
-      def initialize(signature, compress_type, adler32, uncompressed_size, compressed_size, prelink_version, reserved, platform_name, root_path)
-        super()
-
-        @signature = signature
-        @compress_type = compress_type
-        @adler32 = adler32
-        @uncompressed_size = uncompressed_size
-        @compressed_size = compressed_size
-        @prelink_version = prelink_version
-        @reserved = reserved.unpack("L>10")
-        @platform_name = platform_name
-        @root_path = root_path
-      end
+      field :root_path, :string, :size => 256
 
       # @return [Boolean] whether this prelinked kernel supports KASLR
       def kaslr?
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/load_commands.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/load_commands.rb
new file mode 100644
index 0000000000000..1ed24a58beed4
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/load_commands.rb
@@ -0,0 +1,1477 @@
+# frozen_string_literal: true
+
+module MachO
+  # Classes and constants for parsing load commands in Mach-O binaries.
+  module LoadCommands
+    # load commands added after OS X 10.1 need to be bitwise ORed with
+    # LC_REQ_DYLD to be recognized by the dynamic linker (dyld)
+    # @api private
+    LC_REQ_DYLD = 0x80000000
+
+    # association of load commands to symbol representations
+    # @api private
+    LOAD_COMMANDS = {
+      0x1 => :LC_SEGMENT,
+      0x2 => :LC_SYMTAB,
+      0x3 => :LC_SYMSEG,
+      0x4 => :LC_THREAD,
+      0x5 => :LC_UNIXTHREAD,
+      0x6 => :LC_LOADFVMLIB,
+      0x7 => :LC_IDFVMLIB,
+      0x8 => :LC_IDENT,
+      0x9 => :LC_FVMFILE,
+      0xa => :LC_PREPAGE,
+      0xb => :LC_DYSYMTAB,
+      0xc => :LC_LOAD_DYLIB,
+      0xd => :LC_ID_DYLIB,
+      0xe => :LC_LOAD_DYLINKER,
+      0xf => :LC_ID_DYLINKER,
+      0x10 => :LC_PREBOUND_DYLIB,
+      0x11 => :LC_ROUTINES,
+      0x12 => :LC_SUB_FRAMEWORK,
+      0x13 => :LC_SUB_UMBRELLA,
+      0x14 => :LC_SUB_CLIENT,
+      0x15 => :LC_SUB_LIBRARY,
+      0x16 => :LC_TWOLEVEL_HINTS,
+      0x17 => :LC_PREBIND_CKSUM,
+      (LC_REQ_DYLD | 0x18) => :LC_LOAD_WEAK_DYLIB,
+      0x19 => :LC_SEGMENT_64,
+      0x1a => :LC_ROUTINES_64,
+      0x1b => :LC_UUID,
+      (LC_REQ_DYLD | 0x1c) => :LC_RPATH,
+      0x1d => :LC_CODE_SIGNATURE,
+      0x1e => :LC_SEGMENT_SPLIT_INFO,
+      (LC_REQ_DYLD | 0x1f) => :LC_REEXPORT_DYLIB,
+      0x20 => :LC_LAZY_LOAD_DYLIB,
+      0x21 => :LC_ENCRYPTION_INFO,
+      0x22 => :LC_DYLD_INFO,
+      (LC_REQ_DYLD | 0x22) => :LC_DYLD_INFO_ONLY,
+      (LC_REQ_DYLD | 0x23) => :LC_LOAD_UPWARD_DYLIB,
+      0x24 => :LC_VERSION_MIN_MACOSX,
+      0x25 => :LC_VERSION_MIN_IPHONEOS,
+      0x26 => :LC_FUNCTION_STARTS,
+      0x27 => :LC_DYLD_ENVIRONMENT,
+      (LC_REQ_DYLD | 0x28) => :LC_MAIN,
+      0x29 => :LC_DATA_IN_CODE,
+      0x2a => :LC_SOURCE_VERSION,
+      0x2b => :LC_DYLIB_CODE_SIGN_DRS,
+      0x2c => :LC_ENCRYPTION_INFO_64,
+      0x2d => :LC_LINKER_OPTION,
+      0x2e => :LC_LINKER_OPTIMIZATION_HINT,
+      0x2f => :LC_VERSION_MIN_TVOS,
+      0x30 => :LC_VERSION_MIN_WATCHOS,
+      0x31 => :LC_NOTE,
+      0x32 => :LC_BUILD_VERSION,
+      (LC_REQ_DYLD | 0x33) => :LC_DYLD_EXPORTS_TRIE,
+      (LC_REQ_DYLD | 0x34) => :LC_DYLD_CHAINED_FIXUPS,
+      (LC_REQ_DYLD | 0x35) => :LC_FILESET_ENTRY,
+      0x36 => :LC_ATOM_INFO,
+    }.freeze
+
+    # association of symbol representations to load command constants
+    # @api private
+    LOAD_COMMAND_CONSTANTS = LOAD_COMMANDS.invert.freeze
+
+    # load commands responsible for loading dylibs
+    # @api private
+    DYLIB_LOAD_COMMANDS = %i[
+      LC_LOAD_DYLIB
+      LC_LOAD_WEAK_DYLIB
+      LC_REEXPORT_DYLIB
+      LC_LAZY_LOAD_DYLIB
+      LC_LOAD_UPWARD_DYLIB
+    ].freeze
+
+    # load commands that can be created manually via {LoadCommand.create}
+    # @api private
+    CREATABLE_LOAD_COMMANDS = DYLIB_LOAD_COMMANDS + %i[
+      LC_ID_DYLIB
+      LC_RPATH
+      LC_LOAD_DYLINKER
+    ].freeze
+
+    # association of load command symbols to string representations of classes
+    # @api private
+    LC_STRUCTURES = {
+      :LC_SEGMENT => "SegmentCommand",
+      :LC_SYMTAB => "SymtabCommand",
+      # "obsolete"
+      :LC_SYMSEG => "SymsegCommand",
+      # seems obsolete, but not documented as such
+      :LC_THREAD => "ThreadCommand",
+      :LC_UNIXTHREAD => "ThreadCommand",
+      # "obsolete"
+      :LC_LOADFVMLIB => "FvmlibCommand",
+      # "obsolete"
+      :LC_IDFVMLIB => "FvmlibCommand",
+      # "obsolete"
+      :LC_IDENT => "IdentCommand",
+      # "reserved for internal use only"
+      :LC_FVMFILE => "FvmfileCommand",
+      # "reserved for internal use only", no public struct
+      :LC_PREPAGE => "LoadCommand",
+      :LC_DYSYMTAB => "DysymtabCommand",
+      :LC_LOAD_DYLIB => "DylibUseCommand",
+      :LC_ID_DYLIB => "DylibCommand",
+      :LC_LOAD_DYLINKER => "DylinkerCommand",
+      :LC_ID_DYLINKER => "DylinkerCommand",
+      :LC_PREBOUND_DYLIB => "PreboundDylibCommand",
+      :LC_ROUTINES => "RoutinesCommand",
+      :LC_SUB_FRAMEWORK => "SubFrameworkCommand",
+      :LC_SUB_UMBRELLA => "SubUmbrellaCommand",
+      :LC_SUB_CLIENT => "SubClientCommand",
+      :LC_SUB_LIBRARY => "SubLibraryCommand",
+      :LC_TWOLEVEL_HINTS => "TwolevelHintsCommand",
+      :LC_PREBIND_CKSUM => "PrebindCksumCommand",
+      :LC_LOAD_WEAK_DYLIB => "DylibUseCommand",
+      :LC_SEGMENT_64 => "SegmentCommand64",
+      :LC_ROUTINES_64 => "RoutinesCommand64",
+      :LC_UUID => "UUIDCommand",
+      :LC_RPATH => "RpathCommand",
+      :LC_CODE_SIGNATURE => "LinkeditDataCommand",
+      :LC_SEGMENT_SPLIT_INFO => "LinkeditDataCommand",
+      :LC_REEXPORT_DYLIB => "DylibCommand",
+      :LC_LAZY_LOAD_DYLIB => "DylibCommand",
+      :LC_ENCRYPTION_INFO => "EncryptionInfoCommand",
+      :LC_DYLD_INFO => "DyldInfoCommand",
+      :LC_DYLD_INFO_ONLY => "DyldInfoCommand",
+      :LC_LOAD_UPWARD_DYLIB => "DylibCommand",
+      :LC_VERSION_MIN_MACOSX => "VersionMinCommand",
+      :LC_VERSION_MIN_IPHONEOS => "VersionMinCommand",
+      :LC_FUNCTION_STARTS => "LinkeditDataCommand",
+      :LC_DYLD_ENVIRONMENT => "DylinkerCommand",
+      :LC_MAIN => "EntryPointCommand",
+      :LC_DATA_IN_CODE => "LinkeditDataCommand",
+      :LC_SOURCE_VERSION => "SourceVersionCommand",
+      :LC_DYLIB_CODE_SIGN_DRS => "LinkeditDataCommand",
+      :LC_ENCRYPTION_INFO_64 => "EncryptionInfoCommand64",
+      :LC_LINKER_OPTION => "LinkerOptionCommand",
+      :LC_LINKER_OPTIMIZATION_HINT => "LinkeditDataCommand",
+      :LC_VERSION_MIN_TVOS => "VersionMinCommand",
+      :LC_VERSION_MIN_WATCHOS => "VersionMinCommand",
+      :LC_NOTE => "NoteCommand",
+      :LC_BUILD_VERSION => "BuildVersionCommand",
+      :LC_DYLD_EXPORTS_TRIE => "LinkeditDataCommand",
+      :LC_DYLD_CHAINED_FIXUPS => "LinkeditDataCommand",
+      :LC_FILESET_ENTRY => "FilesetEntryCommand",
+      :LC_ATOM_INFO => "LinkeditDataCommand",
+    }.freeze
+
+    # association of segment name symbols to names
+    # @api private
+    SEGMENT_NAMES = {
+      :SEG_PAGEZERO => "__PAGEZERO",
+      :SEG_TEXT => "__TEXT",
+      :SEG_TEXT_EXEC => "__TEXT_EXEC",
+      :SEG_DATA => "__DATA",
+      :SEG_DATA_CONST => "__DATA_CONST",
+      :SEG_OBJC => "__OBJC",
+      :SEG_OBJC_CONST => "__OBJC_CONST",
+      :SEG_ICON => "__ICON",
+      :SEG_LINKEDIT => "__LINKEDIT",
+      :SEG_LINKINFO => "__LINKINFO",
+      :SEG_UNIXSTACK => "__UNIXSTACK",
+      :SEG_IMPORT => "__IMPORT",
+      :SEG_KLD => "__KLD",
+      :SEG_KLDDATA => "__KLDDATA",
+      :SEG_HIB => "__HIB",
+      :SEG_VECTORS => "__VECTORS",
+      :SEG_LAST => "__LAST",
+      :SEG_LASTDATA_CONST => "__LASTDATA_CONST",
+      :SEG_PRELINK_TEXT => "__PRELINK_TEXT",
+      :SEG_PRELINK_INFO => "__PRELINK_INFO",
+      :SEG_CTF => "__CTF",
+      :SEG_AUTH => "__AUTH",
+      :SEG_AUTH_CONST => "__AUTH_CONST",
+    }.freeze
+
+    # association of segment flag symbols to values
+    # @api private
+    SEGMENT_FLAGS = {
+      :SG_HIGHVM => 0x1,
+      :SG_FVMLIB => 0x2,
+      :SG_NORELOC => 0x4,
+      :SG_PROTECTED_VERSION_1 => 0x8,
+      :SG_READ_ONLY => 0x10,
+    }.freeze
+
+    # association of dylib use flag symbols to values
+    # @api private
+    DYLIB_USE_FLAGS = {
+      :DYLIB_USE_WEAK_LINK => 0x1,
+      :DYLIB_USE_REEXPORT => 0x2,
+      :DYLIB_USE_UPWARD => 0x4,
+      :DYLIB_USE_DELAYED_INIT => 0x8,
+    }.freeze
+
+    # the marker used to denote a newer style dylib use command.
+    # the value is the timestamp 24 January 1984 18:12:16
+    # @api private
+    DYLIB_USE_MARKER = 0x1a741800
+
+    # The top-level Mach-O load command structure.
+    #
+    # This is the most generic load command -- only the type ID and size are
+    # represented. Used when a more specific class isn't available or isn't implemented.
+    class LoadCommand < MachOStructure
+      # @return [MachO::MachOView, nil] the raw view associated with the load command,
+      #  or nil if the load command was created via {create}.
+      field :view, :view
+
+      # @return [Integer] the load command's type ID
+      field :cmd, :uint32
+
+      # @return [Integer] the size of the load command, in bytes
+      field :cmdsize, :uint32
+
+      # Instantiates a new LoadCommand given a view into its origin Mach-O
+      # @param view [MachO::MachOView] the load command's raw view
+      # @return [LoadCommand] the new load command
+      # @api private
+      def self.new_from_bin(view)
+        bin = view.raw_data.slice(view.offset, bytesize)
+        format = Utils.specialize_format(self.format, view.endianness)
+
+        new(view, *bin.unpack(format))
+      end
+
+      # Creates a new (viewless) command corresponding to the symbol provided
+      # @param cmd_sym [Symbol] the symbol of the load command being created
+      # @param args [Array] the arguments for the load command being created
+      def self.create(cmd_sym, *args)
+        raise LoadCommandNotCreatableError, cmd_sym unless CREATABLE_LOAD_COMMANDS.include?(cmd_sym)
+
+        klass = LoadCommands.const_get LC_STRUCTURES[cmd_sym]
+        cmd = LOAD_COMMAND_CONSTANTS[cmd_sym]
+
+        # cmd will be filled in, view and cmdsize will be left unpopulated
+        klass_arity = klass.min_args - 3
+
+        # macOS 15 introduces a new dylib load command that adds a flags field to the end.
+        # It uses the same commands with it dynamically being created if the dylib has a flags field
+        if klass == DylibUseCommand && (args[1] != DYLIB_USE_MARKER || args.size <= DylibCommand.min_args - 3)
+          klass = DylibCommand
+          klass_arity = klass.min_args - 3
+        end
+
+        raise LoadCommandCreationArityError.new(cmd_sym, klass_arity, args.size) if klass_arity > args.size
+
+        klass.new(nil, cmd, nil, *args)
+      end
+
+      # @return [Boolean] whether the load command can be serialized
+      def serializable?
+        CREATABLE_LOAD_COMMANDS.include?(LOAD_COMMANDS[cmd])
+      end
+
+      # @param context [SerializationContext] the context
+      #  to serialize into
+      # @return [String, nil] the serialized fields of the load command, or nil
+      #  if the load command can't be serialized
+      # @api private
+      def serialize(context)
+        raise LoadCommandNotSerializableError, LOAD_COMMANDS[cmd] unless serializable?
+
+        format = Utils.specialize_format(self.class.format, context.endianness)
+        [cmd, self.class.bytesize].pack(format)
+      end
+
+      # @return [Integer] the load command's offset in the source file
+      # @deprecated use {#view} instead
+      def offset
+        view.offset
+      end
+
+      # @return [Symbol, nil] a symbol representation of the load command's
+      #  type ID, or nil if the ID doesn't correspond to a known load command class
+      def type
+        LOAD_COMMANDS[cmd]
+      end
+
+      alias to_sym type
+
+      # @return [String] a string representation of the load command's
+      #  identifying number
+      def to_s
+        type.to_s
+      end
+
+      # @return [Hash] a hash representation of this load command
+      # @note Children should override this to include additional information.
+      def to_h
+        {
+          "view" => view.to_h,
+          "cmd" => cmd,
+          "cmdsize" => cmdsize,
+          "type" => type,
+        }.merge super
+      end
+
+      # Represents a Load Command string. A rough analogue to the lc_str
+      # struct used internally by OS X. This class allows ruby-macho to
+      # pretend that strings stored in LCs are immediately available without
+      # explicit operations on the raw Mach-O data.
+      class LCStr
+        # @param lc [LoadCommand] the load command
+        # @param lc_str [Integer, String] the offset to the beginning of the
+        #  string, or the string itself if not being initialized with a view.
+        # @raise [MachO::LCStrMalformedError] if the string is malformed
+        # @todo devise a solution such that the `lc_str` parameter is not
+        #  interpreted differently depending on `lc.view`. The current behavior
+        #  is a hack to allow viewless load command creation.
+        # @api private
+        def initialize(lc, lc_str)
+          view = lc.view
+
+          if view
+            lc_str_abs = view.offset + lc_str
+            lc_end = view.offset + lc.cmdsize - 1
+            raw_string = view.raw_data.slice(lc_str_abs..lc_end)
+            @string, null_byte, _padding = raw_string.partition("\x00")
+
+            raise LCStrMalformedError, lc if null_byte.empty?
+
+            @string_offset = lc_str
+          else
+            @string = lc_str
+            @string_offset = 0
+          end
+        end
+
+        # @return [String] a string representation of the LCStr
+        def to_s
+          @string
+        end
+
+        # @return [Integer] the offset to the beginning of the string in the
+        #  load command
+        def to_i
+          @string_offset
+        end
+
+        # @return [Hash] a hash representation of this {LCStr}.
+        def to_h
+          {
+            "string" => to_s,
+            "offset" => to_i,
+          }
+        end
+      end
+
+      # Represents the contextual information needed by a load command to
+      # serialize itself correctly into a binary string.
+      class SerializationContext
+        # @return [Symbol] the endianness of the serialized load command
+        attr_reader :endianness
+
+        # @return [Integer] the constant alignment value used to pad the
+        #  serialized load command
+        attr_reader :alignment
+
+        # @param macho [MachO::MachOFile] the file to contextualize
+        # @return [SerializationContext] the
+        #  resulting context
+        def self.context_for(macho)
+          new(macho.endianness, macho.alignment)
+        end
+
+        # @param endianness [Symbol] the endianness of the context
+        # @param alignment [Integer] the alignment of the context
+        # @api private
+        def initialize(endianness, alignment)
+          @endianness = endianness
+          @alignment = alignment
+        end
+      end
+    end
+
+    # A load command containing a single 128-bit unique random number
+    # identifying an object produced by static link editor. Corresponds to
+    # LC_UUID.
+    class UUIDCommand < LoadCommand
+      # @return [Array<Integer>] the UUID
+      field :uuid, :string, :size => 16, :unpack => "C16"
+
+      # @return [String] a string representation of the UUID
+      def uuid_string
+        hexes = uuid.map { |elem| "%02<elem>x" % { :elem => elem } }
+        segs = [
+          hexes[0..3].join, hexes[4..5].join, hexes[6..7].join,
+          hexes[8..9].join, hexes[10..15].join
+        ]
+
+        segs.join("-")
+      end
+
+      # @return [String] an alias for uuid_string
+      def to_s
+        uuid_string
+      end
+
+      # @return [Hash] returns a hash representation of this {UUIDCommand}
+      def to_h
+        {
+          "uuid" => uuid,
+          "uuid_string" => uuid_string,
+        }.merge super
+      end
+    end
+
+    # A load command indicating that part of this file is to be mapped into
+    # the task's address space. Corresponds to LC_SEGMENT.
+    class SegmentCommand < LoadCommand
+      # @return [String] the name of the segment
+      field :segname, :string, :padding => :null, :size => 16, :to_s => true
+
+      # @return [Integer] the memory address of the segment
+      field :vmaddr, :uint32
+
+      # @return [Integer] the memory size of the segment
+      field :vmsize, :uint32
+
+      # @return [Integer] the file offset of the segment
+      field :fileoff, :uint32
+
+      # @return [Integer] the amount to map from the file
+      field :filesize, :uint32
+
+      # @return [Integer] the maximum VM protection
+      field :maxprot, :int32
+
+      # @return [Integer] the initial VM protection
+      field :initprot, :int32
+
+      # @return [Integer] the number of sections in the segment
+      field :nsects, :uint32
+
+      # @return [Integer] any flags associated with the segment
+      field :flags, :uint32
+
+      # All sections referenced within this segment.
+      # @return [Array<MachO::Sections::Section>] if the Mach-O is 32-bit
+      # @return [Array<MachO::Sections::Section64>] if the Mach-O is 64-bit
+      def sections
+        klass = case self
+        when SegmentCommand64
+          MachO::Sections::Section64
+        when SegmentCommand
+          MachO::Sections::Section
+        end
+
+        offset = view.offset + self.class.bytesize
+        length = nsects * klass.bytesize
+
+        bins = view.raw_data[offset, length]
+        bins.unpack("a#{klass.bytesize}" * nsects).map do |bin|
+          klass.new_from_bin(view.endianness, bin)
+        end
+      end
+
+      # @example
+      #  puts "this segment relocated in/to it" if sect.flag?(:SG_NORELOC)
+      # @param flag [Symbol] a segment flag symbol
+      # @return [Boolean] true if `flag` is present in the segment's flag field
+      def flag?(flag)
+        flag = SEGMENT_FLAGS[flag]
+
+        return false if flag.nil?
+
+        flags & flag == flag
+      end
+
+      # Guesses the alignment of the segment.
+      # @return [Integer] the guessed alignment, as a power of 2
+      # @note See `guess_align` in `cctools/misc/lipo.c`
+      def guess_align
+        return Sections::MAX_SECT_ALIGN if vmaddr.zero?
+
+        align = 0
+        segalign = 1
+
+        while (segalign & vmaddr).zero?
+          segalign <<= 1
+          align += 1
+        end
+
+        return 2 if align < 2
+        return Sections::MAX_SECT_ALIGN if align > Sections::MAX_SECT_ALIGN
+
+        align
+      end
+
+      # @return [Hash] a hash representation of this {SegmentCommand}
+      def to_h
+        {
+          "segname" => segname,
+          "vmaddr" => vmaddr,
+          "vmsize" => vmsize,
+          "fileoff" => fileoff,
+          "filesize" => filesize,
+          "maxprot" => maxprot,
+          "initprot" => initprot,
+          "nsects" => nsects,
+          "flags" => flags,
+          "sections" => sections.map(&:to_h),
+        }.merge super
+      end
+    end
+
+    # A load command indicating that part of this file is to be mapped into
+    # the task's address space. Corresponds to LC_SEGMENT_64.
+    class SegmentCommand64 < SegmentCommand
+      # @return [Integer] the memory address of the segment
+      field :vmaddr, :uint64
+
+      # @return [Integer] the memory size of the segment
+      field :vmsize, :uint64
+
+      # @return [Integer] the file offset of the segment
+      field :fileoff, :uint64
+
+      # @return [Integer] the amount to map from the file
+      field :filesize, :uint64
+    end
+
+    # A load command representing some aspect of shared libraries, depending
+    # on filetype. Corresponds to LC_ID_DYLIB, LC_LOAD_DYLIB,
+    # LC_LOAD_WEAK_DYLIB, and LC_REEXPORT_DYLIB.
+    class DylibCommand < LoadCommand
+      # @return [LCStr] the library's path
+      #  name as an LCStr
+      field :name, :lcstr, :to_s => true
+
+      # @return [Integer] the library's build time stamp
+      field :timestamp, :uint32
+
+      # @return [Integer] the library's current version number
+      field :current_version, :uint32
+
+      # @return [Integer] the library's compatibility version number
+      field :compatibility_version, :uint32
+
+      # @example
+      #  puts "this dylib is weakly loaded" if dylib_command.flag?(:DYLIB_USE_WEAK_LINK)
+      # @param flag [Symbol] a dylib use command flag symbol
+      # @return [Boolean] true if `flag` applies to this dylib command
+      def flag?(flag)
+        case cmd
+        when LOAD_COMMAND_CONSTANTS[:LC_LOAD_WEAK_DYLIB]
+          flag == :DYLIB_USE_WEAK_LINK
+        when LOAD_COMMAND_CONSTANTS[:LC_REEXPORT_DYLIB]
+          flag == :DYLIB_USE_REEXPORT
+        when LOAD_COMMAND_CONSTANTS[:LC_LOAD_UPWARD_DYLIB]
+          flag == :DYLIB_USE_UPWARD
+        else
+          false
+        end
+      end
+
+      # @param context [SerializationContext]
+      #  the context
+      # @return [String] the serialized fields of the load command
+      # @api private
+      def serialize(context)
+        format = Utils.specialize_format(self.class.format, context.endianness)
+        string_payload, string_offsets = Utils.pack_strings(self.class.bytesize,
+                                                            context.alignment,
+                                                            :name => name.to_s)
+        cmdsize = self.class.bytesize + string_payload.bytesize
+        [cmd, cmdsize, string_offsets[:name], timestamp, current_version,
+         compatibility_version].pack(format) + string_payload
+      end
+
+      # @return [Hash] a hash representation of this {DylibCommand}
+      def to_h
+        {
+          "name" => name.to_h,
+          "timestamp" => timestamp,
+          "current_version" => current_version,
+          "compatibility_version" => compatibility_version,
+        }.merge super
+      end
+    end
+
+    # The newer format of load command representing some aspect of shared libraries,
+    # depending on filetype. Corresponds to LC_LOAD_DYLIB or LC_LOAD_WEAK_DYLIB.
+    class DylibUseCommand < DylibCommand
+      # @return [Integer] any flags associated with this dylib use command
+      field :flags, :uint32
+
+      alias marker timestamp
+
+      # Instantiates a new DylibCommand or DylibUseCommand.
+      # macOS 15 and later use a new format for dylib commands (DylibUseCommand),
+      # which is determined based on a special timestamp and the name offset.
+      # @param view [MachO::MachOView] the load command's raw view
+      # @return [DylibCommand] the new dylib load command
+      # @api private
+      def self.new_from_bin(view)
+        dylib_command = DylibCommand.new_from_bin(view)
+
+        if dylib_command.timestamp == DYLIB_USE_MARKER &&
+           dylib_command.name.to_i == DylibUseCommand.bytesize
+          super(view)
+        else
+          dylib_command
+        end
+      end
+
+      # @example
+      #  puts "this dylib is weakly loaded" if dylib_command.flag?(:DYLIB_USE_WEAK_LINK)
+      # @param flag [Symbol] a dylib use command flag symbol
+      # @return [Boolean] true if `flag` applies to this dylib command
+      def flag?(flag)
+        flag = DYLIB_USE_FLAGS[flag]
+
+        return false if flag.nil?
+
+        flags & flag == flag
+      end
+
+      # @param context [SerializationContext]
+      #  the context
+      # @return [String] the serialized fields of the load command
+      # @api private
+      def serialize(context)
+        format = Utils.specialize_format(self.class.format, context.endianness)
+        string_payload, string_offsets = Utils.pack_strings(self.class.bytesize,
+                                                            context.alignment,
+                                                            :name => name.to_s)
+        cmdsize = self.class.bytesize + string_payload.bytesize
+        [cmd, cmdsize, string_offsets[:name], marker, current_version,
+         compatibility_version, flags].pack(format) + string_payload
+      end
+
+      # @return [Hash] a hash representation of this {DylibUseCommand}
+      def to_h
+        {
+          "flags" => flags,
+        }.merge super
+      end
+    end
+
+    # A load command representing some aspect of the dynamic linker, depending
+    # on filetype. Corresponds to LC_ID_DYLINKER, LC_LOAD_DYLINKER, and
+    # LC_DYLD_ENVIRONMENT.
+    class DylinkerCommand < LoadCommand
+      # @return [LCStr] the dynamic linker's
+      #  path name as an LCStr
+      field :name, :lcstr, :to_s => true
+
+      # @param context [SerializationContext]
+      #  the context
+      # @return [String] the serialized fields of the load command
+      # @api private
+      def serialize(context)
+        format = Utils.specialize_format(self.class.format, context.endianness)
+        string_payload, string_offsets = Utils.pack_strings(self.class.bytesize,
+                                                            context.alignment,
+                                                            :name => name.to_s)
+        cmdsize = self.class.bytesize + string_payload.bytesize
+        [cmd, cmdsize, string_offsets[:name]].pack(format) + string_payload
+      end
+
+      # @return [Hash] a hash representation of this {DylinkerCommand}
+      def to_h
+        {
+          "name" => name.to_h,
+        }.merge super
+      end
+    end
+
+    # A load command used to indicate dynamic libraries used in prebinding.
+    # Corresponds to LC_PREBOUND_DYLIB.
+    class PreboundDylibCommand < LoadCommand
+      # @return [LCStr] the library's path
+      #  name as an LCStr
+      field :name, :lcstr, :to_s => true
+
+      # @return [Integer] the number of modules in the library
+      field :nmodules, :uint32
+
+      # @return [Integer] a bit vector of linked modules
+      field :linked_modules, :uint32
+
+      # @return [Hash] a hash representation of this {PreboundDylibCommand}
+      def to_h
+        {
+          "name" => name.to_h,
+          "nmodules" => nmodules,
+          "linked_modules" => linked_modules,
+        }.merge super
+      end
+    end
+
+    # A load command used to represent threads.
+    # @note cctools-870 and onwards have all fields of thread_command commented
+    # out except the common ones (cmd, cmdsize)
+    class ThreadCommand < LoadCommand
+    end
+
+    # A load command containing the address of the dynamic shared library
+    # initialization routine and an index into the module table for the module
+    # that defines the routine. Corresponds to LC_ROUTINES.
+    class RoutinesCommand < LoadCommand
+      # @return [Integer] the address of the initialization routine
+      field :init_address, :uint32
+
+      # @return [Integer] the index into the module table that the init routine
+      #  is defined in
+      field :init_module, :uint32
+
+      # @return [void]
+      field :reserved1, :uint32
+
+      # @return [void]
+      field :reserved2, :uint32
+
+      # @return [void]
+      field :reserved3, :uint32
+
+      # @return [void]
+      field :reserved4, :uint32
+
+      # @return [void]
+      field :reserved5, :uint32
+
+      # @return [void]
+      field :reserved6, :uint32
+
+      # @return [Hash] a hash representation of this {RoutinesCommand}
+      def to_h
+        {
+          "init_address" => init_address,
+          "init_module" => init_module,
+          "reserved1" => reserved1,
+          "reserved2" => reserved2,
+          "reserved3" => reserved3,
+          "reserved4" => reserved4,
+          "reserved5" => reserved5,
+          "reserved6" => reserved6,
+        }.merge super
+      end
+    end
+
+    # A load command containing the address of the dynamic shared library
+    # initialization routine and an index into the module table for the module
+    # that defines the routine. Corresponds to LC_ROUTINES_64.
+    class RoutinesCommand64 < RoutinesCommand
+      # @return [Integer] the address of the initialization routine
+      field :init_address, :uint64
+
+      # @return [Integer] the index into the module table that the init routine
+      #  is defined in
+      field :init_module, :uint64
+
+      # @return [void]
+      field :reserved1, :uint64
+
+      # @return [void]
+      field :reserved2, :uint64
+
+      # @return [void]
+      field :reserved3, :uint64
+
+      # @return [void]
+      field :reserved4, :uint64
+
+      # @return [void]
+      field :reserved5, :uint64
+
+      # @return [void]
+      field :reserved6, :uint64
+    end
+
+    # A load command signifying membership of a subframework containing the name
+    # of an umbrella framework. Corresponds to LC_SUB_FRAMEWORK.
+    class SubFrameworkCommand < LoadCommand
+      # @return [LCStr] the umbrella framework name as an LCStr
+      field :umbrella, :lcstr, :to_s => true
+
+      # @return [Hash] a hash representation of this {SubFrameworkCommand}
+      def to_h
+        {
+          "umbrella" => umbrella.to_h,
+        }.merge super
+      end
+    end
+
+    # A load command signifying membership of a subumbrella containing the name
+    # of an umbrella framework. Corresponds to LC_SUB_UMBRELLA.
+    class SubUmbrellaCommand < LoadCommand
+      # @return [LCStr] the subumbrella framework name as an LCStr
+      field :sub_umbrella, :lcstr, :to_s => true
+
+      # @return [Hash] a hash representation of this {SubUmbrellaCommand}
+      def to_h
+        {
+          "sub_umbrella" => sub_umbrella.to_h,
+        }.merge super
+      end
+    end
+
+    # A load command signifying a sublibrary of a shared library. Corresponds
+    # to LC_SUB_LIBRARY.
+    class SubLibraryCommand < LoadCommand
+      # @return [LCStr] the sublibrary name as an LCStr
+      field :sub_library, :lcstr, :to_s => true
+
+      # @return [Hash] a hash representation of this {SubLibraryCommand}
+      def to_h
+        {
+          "sub_library" => sub_library.to_h,
+        }.merge super
+      end
+    end
+
+    # A load command signifying a shared library that is a subframework of
+    # an umbrella framework. Corresponds to LC_SUB_CLIENT.
+    class SubClientCommand < LoadCommand
+      # @return [LCStr] the subclient name as an LCStr
+      field :sub_client, :lcstr, :to_s => true
+
+      # @return [Hash] a hash representation of this {SubClientCommand}
+      def to_h
+        {
+          "sub_client" => sub_client.to_h,
+        }.merge super
+      end
+    end
+
+    # A load command containing the offsets and sizes of the link-edit 4.3BSD
+    # "stab" style symbol table information. Corresponds to LC_SYMTAB.
+    class SymtabCommand < LoadCommand
+      # @return [Integer] the symbol table's offset
+      field :symoff, :uint32
+
+      # @return [Integer] the number of symbol table entries
+      field :nsyms, :uint32
+
+      # @return [Integer] the string table's offset
+      field :stroff, :uint32
+
+      # @return [Integer] the string table size in bytes
+      field :strsize, :uint32
+
+      # @return [Hash] a hash representation of this {SymtabCommand}
+      def to_h
+        {
+          "symoff" => symoff,
+          "nsyms" => nsyms,
+          "stroff" => stroff,
+          "strsize" => strsize,
+        }.merge super
+      end
+    end
+
+    # A load command containing symbolic information needed to support data
+    # structures used by the dynamic link editor. Corresponds to LC_DYSYMTAB.
+    class DysymtabCommand < LoadCommand
+      # @return [Integer] the index to local symbols
+      field :ilocalsym, :uint32
+
+      # @return [Integer] the number of local symbols
+      field :nlocalsym, :uint32
+
+      # @return [Integer] the index to externally defined symbols
+      field :iextdefsym, :uint32
+
+      # @return [Integer] the number of externally defined symbols
+      field :nextdefsym, :uint32
+
+      # @return [Integer] the index to undefined symbols
+      field :iundefsym, :uint32
+
+      # @return [Integer] the number of undefined symbols
+      field :nundefsym, :uint32
+
+      # @return [Integer] the file offset to the table of contents
+      field :tocoff, :uint32
+
+      # @return [Integer] the number of entries in the table of contents
+      field :ntoc, :uint32
+
+      # @return [Integer] the file offset to the module table
+      field :modtaboff, :uint32
+
+      # @return [Integer] the number of entries in the module table
+      field :nmodtab, :uint32
+
+      # @return [Integer] the file offset to the referenced symbol table
+      field :extrefsymoff, :uint32
+
+      # @return [Integer] the number of entries in the referenced symbol table
+      field :nextrefsyms, :uint32
+
+      # @return [Integer] the file offset to the indirect symbol table
+      field :indirectsymoff, :uint32
+
+      # @return [Integer] the number of entries in the indirect symbol table
+      field :nindirectsyms, :uint32
+
+      # @return [Integer] the file offset to the external relocation entries
+      field :extreloff, :uint32
+
+      # @return [Integer] the number of external relocation entries
+      field :nextrel, :uint32
+
+      # @return [Integer] the file offset to the local relocation entries
+      field :locreloff, :uint32
+
+      # @return [Integer] the number of local relocation entries
+      field :nlocrel, :uint32
+
+      # @return [Hash] a hash representation of this {DysymtabCommand}
+      def to_h
+        {
+          "ilocalsym" => ilocalsym,
+          "nlocalsym" => nlocalsym,
+          "iextdefsym" => iextdefsym,
+          "nextdefsym" => nextdefsym,
+          "iundefsym" => iundefsym,
+          "nundefsym" => nundefsym,
+          "tocoff" => tocoff,
+          "ntoc" => ntoc,
+          "modtaboff" => modtaboff,
+          "nmodtab" => nmodtab,
+          "extrefsymoff" => extrefsymoff,
+          "nextrefsyms" => nextrefsyms,
+          "indirectsymoff" => indirectsymoff,
+          "nindirectsyms" => nindirectsyms,
+          "extreloff" => extreloff,
+          "nextrel" => nextrel,
+          "locreloff" => locreloff,
+          "nlocrel" => nlocrel,
+        }.merge super
+      end
+    end
+
+    # A load command containing the offset and number of hints in the two-level
+    # namespace lookup hints table. Corresponds to LC_TWOLEVEL_HINTS.
+    class TwolevelHintsCommand < LoadCommand
+      # @return [Integer] the offset to the hint table
+      field :htoffset, :uint32
+
+      # @return [Integer] the number of hints in the hint table
+      field :nhints, :uint32
+
+      # @return [TwolevelHintsTable]
+      #  the hint table
+      field :table, :two_level_hints_table
+
+      # @return [Hash] a hash representation of this {TwolevelHintsCommand}
+      def to_h
+        {
+          "htoffset" => htoffset,
+          "nhints" => nhints,
+          "table" => table.hints.map(&:to_h),
+        }.merge super
+      end
+
+      # A representation of the two-level namespace lookup hints table exposed
+      # by a {TwolevelHintsCommand} (`LC_TWOLEVEL_HINTS`).
+      class TwolevelHintsTable
+        # @return [Array<TwolevelHint>] all hints in the table
+        attr_reader :hints
+
+        # @param view [MachO::MachOView] the view into the current Mach-O
+        # @param htoffset [Integer] the offset of the hints table
+        # @param nhints [Integer] the number of two-level hints in the table
+        # @api private
+        def initialize(view, htoffset, nhints)
+          format = Utils.specialize_format("L=#{nhints}", view.endianness)
+          raw_table = view.raw_data[htoffset, nhints * 4]
+          blobs = raw_table.unpack(format)
+
+          @hints = blobs.map { |b| TwolevelHint.new(b) }
+        end
+
+        # An individual two-level namespace lookup hint.
+        class TwolevelHint
+          # @return [Integer] the index into the sub-images
+          attr_reader :isub_image
+
+          # @return [Integer] the index into the table of contents
+          attr_reader :itoc
+
+          # @param blob [Integer] the 32-bit number containing the lookup hint
+          # @api private
+          def initialize(blob)
+            @isub_image = blob >> 24
+            @itoc = blob & 0x00FFFFFF
+          end
+
+          # @return [Hash] a hash representation of this {TwolevelHint}
+          def to_h
+            {
+              "isub_image" => isub_image,
+              "itoc" => itoc,
+            }
+          end
+        end
+      end
+    end
+
+    # A load command containing the value of the original checksum for prebound
+    # files, or zero. Corresponds to LC_PREBIND_CKSUM.
+    class PrebindCksumCommand < LoadCommand
+      # @return [Integer] the checksum or 0
+      field :cksum, :uint32
+
+      # @return [Hash] a hash representation of this {PrebindCksumCommand}
+      def to_h
+        {
+          "cksum" => cksum,
+        }.merge super
+      end
+    end
+
+    # A load command representing an rpath, which specifies a path that should
+    # be added to the current run path used to find @rpath prefixed dylibs.
+    # Corresponds to LC_RPATH.
+    class RpathCommand < LoadCommand
+      # @return [LCStr] the path to add to the run path as an LCStr
+      field :path, :lcstr, :to_s => true
+
+      # @param context [SerializationContext] the context
+      # @return [String] the serialized fields of the load command
+      # @api private
+      def serialize(context)
+        format = Utils.specialize_format(self.class.format, context.endianness)
+        string_payload, string_offsets = Utils.pack_strings(self.class.bytesize,
+                                                            context.alignment,
+                                                            :path => path.to_s)
+        cmdsize = self.class.bytesize + string_payload.bytesize
+        [cmd, cmdsize, string_offsets[:path]].pack(format) + string_payload
+      end
+
+      # @return [Hash] a hash representation of this {RpathCommand}
+      def to_h
+        {
+          "path" => path.to_h,
+        }.merge super
+      end
+    end
+
+    # A load command representing the offsets and sizes of a blob of data in
+    # the __LINKEDIT segment. Corresponds to LC_CODE_SIGNATURE,
+    # LC_SEGMENT_SPLIT_INFO, LC_FUNCTION_STARTS, LC_DATA_IN_CODE,
+    # LC_DYLIB_CODE_SIGN_DRS, LC_LINKER_OPTIMIZATION_HINT, LC_DYLD_EXPORTS_TRIE,
+    # LC_DYLD_CHAINED_FIXUPS, or LC_ATOM_INFO.
+    class LinkeditDataCommand < LoadCommand
+      # @return [Integer] offset to the data in the __LINKEDIT segment
+      field :dataoff, :uint32
+
+      # @return [Integer] size of the data in the __LINKEDIT segment
+      field :datasize, :uint32
+
+      # @return [Hash] a hash representation of this {LinkeditDataCommand}
+      def to_h
+        {
+          "dataoff" => dataoff,
+          "datasize" => datasize,
+        }.merge super
+      end
+    end
+
+    # A load command representing the offset to and size of an encrypted
+    # segment. Corresponds to LC_ENCRYPTION_INFO.
+    class EncryptionInfoCommand < LoadCommand
+      # @return [Integer] the offset to the encrypted segment
+      field :cryptoff, :uint32
+
+      # @return [Integer] the size of the encrypted segment
+      field :cryptsize, :uint32
+
+      # @return [Integer] the encryption system, or 0 if not encrypted yet
+      field :cryptid, :uint32
+
+      # @return [Hash] a hash representation of this {EncryptionInfoCommand}
+      def to_h
+        {
+          "cryptoff" => cryptoff,
+          "cryptsize" => cryptsize,
+          "cryptid" => cryptid,
+        }.merge super
+      end
+    end
+
+    # A load command representing the offset to and size of an encrypted
+    # segment. Corresponds to LC_ENCRYPTION_INFO_64.
+    class EncryptionInfoCommand64 < EncryptionInfoCommand
+      # @return [Integer] 64-bit padding value
+      field :pad, :uint32
+
+      # @return [Hash] a hash representation of this {EncryptionInfoCommand64}
+      def to_h
+        {
+          "pad" => pad,
+        }.merge super
+      end
+    end
+
+    # A load command containing the minimum OS version on which the binary
+    # was built to run. Corresponds to LC_VERSION_MIN_MACOSX and
+    # LC_VERSION_MIN_IPHONEOS.
+    class VersionMinCommand < LoadCommand
+      # @return [Integer] the version X.Y.Z packed as x16.y8.z8
+      field :version, :uint32
+
+      # @return [Integer] the SDK version X.Y.Z packed as x16.y8.z8
+      field :sdk, :uint32
+
+      # A string representation of the binary's minimum OS version.
+      # @return [String] a string representing the minimum OS version.
+      def version_string
+        binary = "%032<version>b" % { :version => version }
+        segs = [
+          binary[0..15], binary[16..23], binary[24..31]
+        ].map { |s| s.to_i(2) }
+
+        segs.join(".")
+      end
+
+      # A string representation of the binary's SDK version.
+      # @return [String] a string representing the SDK version.
+      def sdk_string
+        binary = "%032<sdk>b" % { :sdk => sdk }
+        segs = [
+          binary[0..15], binary[16..23], binary[24..31]
+        ].map { |s| s.to_i(2) }
+
+        segs.join(".")
+      end
+
+      # @return [Hash] a hash representation of this {VersionMinCommand}
+      def to_h
+        {
+          "version" => version,
+          "version_string" => version_string,
+          "sdk" => sdk,
+          "sdk_string" => sdk_string,
+        }.merge super
+      end
+    end
+
+    # A load command containing the minimum OS version on which
+    # the binary was built for its platform.
+    # Corresponds to LC_BUILD_VERSION.
+    class BuildVersionCommand < LoadCommand
+      # @return [Integer]
+      field :platform, :uint32
+
+      # @return [Integer] the minimum OS version X.Y.Z packed as x16.y8.z8
+      field :minos, :uint32
+
+      # @return [Integer] the SDK version X.Y.Z packed as x16.y8.z8
+      field :sdk, :uint32
+
+      # @return [ToolEntries] tool entries
+      field :tool_entries, :tool_entries
+
+      # A string representation of the binary's minimum OS version.
+      # @return [String] a string representing the minimum OS version.
+      def minos_string
+        binary = "%032<minos>b" % { :minos => minos }
+        segs = [
+          binary[0..15], binary[16..23], binary[24..31]
+        ].map { |s| s.to_i(2) }
+
+        segs.join(".")
+      end
+
+      # A string representation of the binary's SDK version.
+      # @return [String] a string representing the SDK version.
+      def sdk_string
+        binary = "%032<sdk>b" % { :sdk => sdk }
+        segs = [
+          binary[0..15], binary[16..23], binary[24..31]
+        ].map { |s| s.to_i(2) }
+
+        segs.join(".")
+      end
+
+      # @return [Hash] a hash representation of this {BuildVersionCommand}
+      def to_h
+        {
+          "platform" => platform,
+          "minos" => minos,
+          "minos_string" => minos_string,
+          "sdk" => sdk,
+          "sdk_string" => sdk_string,
+          "tool_entries" => tool_entries.tools.map(&:to_h),
+        }.merge super
+      end
+
+      # A representation of the tool versions exposed
+      # by a {BuildVersionCommand} (`LC_BUILD_VERSION`).
+      class ToolEntries
+        # @return [Array<Tool>] all tools
+        attr_reader :tools
+
+        # @param view [MachO::MachOView] the view into the current Mach-O
+        # @param ntools [Integer] the number of tools
+        # @api private
+        def initialize(view, ntools)
+          format = Utils.specialize_format("L=#{ntools * 2}", view.endianness)
+          raw_table = view.raw_data[view.offset + 24, ntools * 8]
+          blobs = raw_table.unpack(format).each_slice(2).to_a
+
+          @tools = blobs.map { |b| Tool.new(*b) }
+        end
+
+        # An individual tool.
+        class Tool
+          # @return [Integer] the enum for the tool
+          attr_reader :tool
+
+          # @return [Integer] the tool's version number
+          attr_reader :version
+
+          # @param tool [Integer] 32-bit integer
+          # @param version [Integer] 32-bit integer
+          # @api private
+          def initialize(tool, version)
+            @tool = tool
+            @version = version
+          end
+
+          # @return [Hash] a hash representation of this {Tool}
+          def to_h
+            {
+              "tool" => tool,
+              "version" => version,
+            }
+          end
+        end
+      end
+    end
+
+    # A load command containing the file offsets and sizes of the new
+    # compressed form of the information dyld needs to load the image.
+    # Corresponds to LC_DYLD_INFO and LC_DYLD_INFO_ONLY.
+    class DyldInfoCommand < LoadCommand
+      # @return [Integer] the file offset to the rebase information
+      field :rebase_off, :uint32
+
+      # @return [Integer] the size of the rebase information
+      field :rebase_size, :uint32
+
+      # @return [Integer] the file offset to the binding information
+      field :bind_off, :uint32
+
+      # @return [Integer] the size of the binding information
+      field :bind_size, :uint32
+
+      # @return [Integer] the file offset to the weak binding information
+      field :weak_bind_off, :uint32
+
+      # @return [Integer] the size of the weak binding information
+      field :weak_bind_size, :uint32
+
+      # @return [Integer] the file offset to the lazy binding information
+      field :lazy_bind_off, :uint32
+
+      # @return [Integer] the size of the lazy binding information
+      field :lazy_bind_size, :uint32
+
+      # @return [Integer] the file offset to the export information
+      field :export_off, :uint32
+
+      # @return [Integer] the size of the export information
+      field :export_size, :uint32
+
+      # @return [Hash] a hash representation of this {DyldInfoCommand}
+      def to_h
+        {
+          "rebase_off" => rebase_off,
+          "rebase_size" => rebase_size,
+          "bind_off" => bind_off,
+          "bind_size" => bind_size,
+          "weak_bind_off" => weak_bind_off,
+          "weak_bind_size" => weak_bind_size,
+          "lazy_bind_off" => lazy_bind_off,
+          "lazy_bind_size" => lazy_bind_size,
+          "export_off" => export_off,
+          "export_size" => export_size,
+        }.merge super
+      end
+    end
+
+    # A load command containing linker options embedded in object files.
+    # Corresponds to LC_LINKER_OPTION.
+    class LinkerOptionCommand < LoadCommand
+      # @return [Integer] the number of strings
+      field :count, :uint32
+
+      # @return [Hash] a hash representation of this {LinkerOptionCommand}
+      def to_h
+        {
+          "count" => count,
+        }.merge super
+      end
+    end
+
+    # A load command specifying the offset of main(). Corresponds to LC_MAIN.
+    class EntryPointCommand < LoadCommand
+      # @return [Integer] the file (__TEXT) offset of main()
+      field :entryoff, :uint64
+
+      # @return [Integer] if not 0, the initial stack size.
+      field :stacksize, :uint64
+
+      # @return [Hash] a hash representation of this {EntryPointCommand}
+      def to_h
+        {
+          "entryoff" => entryoff,
+          "stacksize" => stacksize,
+        }.merge super
+      end
+    end
+
+    # A load command specifying the version of the sources used to build the
+    # binary. Corresponds to LC_SOURCE_VERSION.
+    class SourceVersionCommand < LoadCommand
+      # @return [Integer] the version packed as a24.b10.c10.d10.e10
+      field :version, :uint64
+
+      # A string representation of the sources used to build the binary.
+      # @return [String] a string representation of the version
+      def version_string
+        binary = "%064<version>b" % { :version => version }
+        segs = [
+          binary[0..23], binary[24..33], binary[34..43], binary[44..53],
+          binary[54..63]
+        ].map { |s| s.to_i(2) }
+
+        segs.join(".")
+      end
+
+      # @return [Hash] a hash representation of this {SourceVersionCommand}
+      def to_h
+        {
+          "version" => version,
+          "version_string" => version_string,
+        }.merge super
+      end
+    end
+
+    # An obsolete load command containing the offset and size of the (GNU style)
+    # symbol table information. Corresponds to LC_SYMSEG.
+    class SymsegCommand < LoadCommand
+      # @return [Integer] the offset to the symbol segment
+      field :offset, :uint32
+
+      # @return [Integer] the size of the symbol segment in bytes
+      field :size, :uint32
+
+      # @return [Hash] a hash representation of this {SymsegCommand}
+      def to_h
+        {
+          "offset" => offset,
+          "size" => size,
+        }.merge super
+      end
+    end
+
+    # An obsolete load command containing a free format string table. Each
+    # string is null-terminated and the command is zero-padded to a multiple of
+    # 4. Corresponds to LC_IDENT.
+    class IdentCommand < LoadCommand
+    end
+
+    # An obsolete load command containing the path to a file to be loaded into
+    # memory. Corresponds to LC_FVMFILE.
+    class FvmfileCommand < LoadCommand
+      # @return [LCStr] the pathname of the file being loaded
+      field :name, :lcstr, :to_s => true
+
+      # @return [Integer] the virtual address being loaded at
+      field :header_addr, :uint32
+
+      # @return [Hash] a hash representation of this {FvmfileCommand}
+      def to_h
+        {
+          "name" => name.to_h,
+          "header_addr" => header_addr,
+        }.merge super
+      end
+    end
+
+    # An obsolete load command containing the path to a library to be loaded
+    # into memory. Corresponds to LC_LOADFVMLIB and LC_IDFVMLIB.
+    class FvmlibCommand < LoadCommand
+      # @return [LCStr] the library's target pathname
+      field :name, :lcstr, :to_s => true
+
+      # @return [Integer] the library's minor version number
+      field :minor_version, :uint32
+
+      # @return [Integer] the library's header address
+      field :header_addr, :uint32
+
+      # @return [Hash] a hash representation of this {FvmlibCommand}
+      def to_h
+        {
+          "name" => name.to_h,
+          "minor_version" => minor_version,
+          "header_addr" => header_addr,
+        }.merge super
+      end
+    end
+
+    # A load command containing an owner name and offset/size for an arbitrary data region.
+    # Corresponds to LC_NOTE.
+    class NoteCommand < LoadCommand
+      # @return [String] the name of the owner for this note
+      field :data_owner, :string, :padding => :null, :size => 16, :to_s => true
+
+      # @return [Integer] the offset, within the file, of the note
+      field :offset, :uint64
+
+      # @return [Integer] the size, in bytes, of the note
+      field :size, :uint64
+
+      # @return [Hash] a hash representation of this {NoteCommand}
+      def to_h
+        {
+          "data_owner" => data_owner,
+          "offset" => offset,
+          "size" => size,
+        }.merge super
+      end
+    end
+
+    # A load command containing a description of a Mach-O that is a constituent of a fileset.
+    # Each entry is further described by its own Mach header.
+    # Corresponds to LC_FILESET_ENTRY.
+    class FilesetEntryCommand < LoadCommand
+      # @return [Integer] the virtual memory address of the entry
+      field :vmaddr, :uint64
+
+      # @return [Integer] the file offset of the entry
+      field :fileoff, :uint64
+
+      # @return [LCStr] the entry's ID
+      field :entry_id, :lcstr, :to_s => true
+
+      # @return [void]
+      field :reserved, :uint32
+
+      # @return [Hash] a hash representation of this {FilesetEntryCommand}
+      def to_h
+        {
+          "vmaddr" => vmaddr,
+          "fileoff" => fileoff,
+          "entry_id" => entry_id,
+          "reserved" => reserved,
+        }.merge super
+      end
+
+      # @return [SegmentCommand64, nil] the matching segment command or nil if nothing matches
+      def segment
+        view.macho_file.command(:LC_SEGMENT_64).select { |cmd| cmd.fileoff == fileoff }.first
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/macho_file.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/macho_file.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/macho_file.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/macho_file.rb
index af9df10956ca3..15dadbcf788ca 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/macho_file.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/macho_file.rb
@@ -381,11 +381,9 @@ def rpaths
     #  rpaths simultaneously.
     # @return [void]
     # @raise [RpathUnknownError] if no such old runtime path exists
-    # @raise [RpathExistsError] if the new runtime path already exists
     def change_rpath(old_path, new_path, options = {})
       old_lc = command(:LC_RPATH).find { |r| r.path.to_s == old_path }
       raise RpathUnknownError, old_path if old_lc.nil?
-      raise RpathExistsError, new_path if rpaths.include?(new_path)
 
       new_lc = LoadCommands::LoadCommand.create(:LC_RPATH, new_path)
 
@@ -413,22 +411,37 @@ def add_rpath(path, _options = {})
 
     # Delete the given runtime path from the Mach-O.
     # @example
-    #  file.rpaths # => ["/lib"]
-    #  file.delete_rpath("/lib")
-    #  file.rpaths # => []
+    #  file1.rpaths # => ["/lib", "/usr/lib", "/lib"]
+    #  file1.delete_rpath("/lib")
+    #  file1.rpaths # => ["/usr/lib", "/lib"]
+    #  file2.rpaths # => ["foo", "foo"]
+    #  file2.delete_rpath("foo", :uniq => true)
+    #  file2.rpaths # => []
+    #  file3.rpaths # => ["foo", "bar", "foo"]
+    #  file3.delete_rpath("foo", :last => true)
+    #  file3.rpaths # => ["foo", "bar"]
     # @param path [String] the runtime path to delete
     # @param options [Hash]
     # @option options [Boolean] :uniq (false) if true, also delete
     #  duplicates of the requested path. If false, delete the first
-    #  instance (by offset) of the requested path.
+    #  instance (by offset) of the requested path, unless :last is true.
+    #  Incompatible with :last.
+    # @option options [Boolean] :last (false) if true, delete the last
+    #  instance (by offset) of the requested path. Incompatible with :uniq.
     # @return void
     # @raise [RpathUnknownError] if no such runtime path exists
+    # @raise [ArgumentError] if both :uniq and :last are true
     def delete_rpath(path, options = {})
       uniq = options.fetch(:uniq, false)
-      search_method = uniq ? :select : :find
+      last = options.fetch(:last, false)
+      raise ArgumentError, "Cannot set both :uniq and :last to true" if uniq && last
+
+      search_method = uniq || last ? :select : :find
+      rpath_cmds = command(:LC_RPATH).public_send(search_method) { |r| r.path.to_s == path }
+      rpath_cmds = rpath_cmds.last if last
 
       # Cast rpath_cmds into an Array so we can handle the uniq and non-uniq cases the same way
-      rpath_cmds = Array(command(:LC_RPATH).method(search_method).call { |r| r.path.to_s == path })
+      rpath_cmds = Array(rpath_cmds)
       raise RpathUnknownError, path if rpath_cmds.empty?
 
       # delete the commands in reverse order, offset descending.
@@ -592,7 +605,7 @@ def populate_load_commands
           LoadCommands::LoadCommand
         end
 
-        view = MachOView.new(@raw_data, endianness, offset)
+        view = MachOView.new(self, @raw_data, endianness, offset)
         command = klass.new_from_bin(view)
 
         load_commands << command
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/sections.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/sections.rb
similarity index 81%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/sections.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/sections.rb
index ab9650ad67b07..0b48808de22fa 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/sections.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/sections.rb
@@ -89,61 +89,38 @@ module Sections
     # Represents a section of a segment for 32-bit architectures.
     class Section < MachOStructure
       # @return [String] the name of the section, including null pad bytes
-      attr_reader :sectname
+      field :sectname, :string, :padding => :null, :size => 16
 
       # @return [String] the name of the segment's section, including null
       #  pad bytes
-      attr_reader :segname
+      field :segname, :string, :padding => :null, :size => 16
 
       # @return [Integer] the memory address of the section
-      attr_reader :addr
+      field :addr, :uint32
 
       # @return [Integer] the size, in bytes, of the section
-      attr_reader :size
+      field :size, :uint32
 
       # @return [Integer] the file offset of the section
-      attr_reader :offset
+      field :offset, :uint32
 
       # @return [Integer] the section alignment (power of 2) of the section
-      attr_reader :align
+      field :align, :uint32
 
       # @return [Integer] the file offset of the section's relocation entries
-      attr_reader :reloff
+      field :reloff, :uint32
 
       # @return [Integer] the number of relocation entries
-      attr_reader :nreloc
+      field :nreloc, :uint32
 
       # @return [Integer] flags for type and attributes of the section
-      attr_reader :flags
+      field :flags, :uint32
 
       # @return [void] reserved (for offset or index)
-      attr_reader :reserved1
+      field :reserved1, :uint32
 
       # @return [void] reserved (for count or sizeof)
-      attr_reader :reserved2
-
-      # @see MachOStructure::FORMAT
-      FORMAT = "Z16Z16L=9"
-
-      # @see MachOStructure::SIZEOF
-      SIZEOF = 68
-
-      # @api private
-      def initialize(sectname, segname, addr, size, offset, align, reloff,
-                     nreloc, flags, reserved1, reserved2)
-        super()
-        @sectname = sectname
-        @segname = segname
-        @addr = addr
-        @size = size
-        @offset = offset
-        @align = align
-        @reloff = reloff
-        @nreloc = nreloc
-        @flags = flags
-        @reserved1 = reserved1
-        @reserved2 = reserved2
-      end
+      field :reserved2, :uint32
 
       # @return [String] the section's name
       def section_name
@@ -219,22 +196,14 @@ def to_h
 
     # Represents a section of a segment for 64-bit architectures.
     class Section64 < Section
-      # @return [void] reserved
-      attr_reader :reserved3
-
-      # @see MachOStructure::FORMAT
-      FORMAT = "Z16Z16Q=2L=8"
+      # @return [Integer] the memory address of the section
+      field :addr, :uint64
 
-      # @see MachOStructure::SIZEOF
-      SIZEOF = 80
+      # @return [Integer] the size, in bytes, of the section
+      field :size, :uint64
 
-      # @api private
-      def initialize(sectname, segname, addr, size, offset, align, reloff,
-                     nreloc, flags, reserved1, reserved2, reserved3)
-        super(sectname, segname, addr, size, offset, align, reloff,
-          nreloc, flags, reserved1, reserved2)
-        @reserved3 = reserved3
-      end
+      # @return [void] reserved
+      field :reserved3, :uint32
 
       # @return [Hash] a hash representation of this {Section64}
       def to_h
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/structure.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/structure.rb
new file mode 100644
index 0000000000000..ed5b3a5f73032
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/structure.rb
@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module MachO
+  # A general purpose pseudo-structure. Described in detail in docs/machostructure-dsl.md.
+  # @abstract
+  class MachOStructure
+    # Constants used for parsing MachOStructure fields
+    module Fields
+      # 1. All fields with empty strings and zeros aren't used
+      #    to calculate the format and sizeof variables.
+      # 2. All fields with nil should provide those values manually
+      #    via the :size parameter.
+
+      # association of field types to byte size
+      # @api private
+      BYTE_SIZE = {
+        # Binary slices
+        :string => nil,
+        :null_padded_string => nil,
+        :int32 => 4,
+        :uint32 => 4,
+        :uint64 => 8,
+        # Classes
+        :view => 0,
+        :lcstr => 4,
+        :two_level_hints_table => 0,
+        :tool_entries => 4,
+      }.freeze
+
+      # association of field types with ruby format codes
+      # Binary format codes can be found here:
+      # https://docs.ruby-lang.org/en/2.6.0/String.html#method-i-unpack
+      #
+      # The equals sign is used to manually change endianness using
+      # the Utils#specialize_format() method.
+      # @api private
+      FORMAT_CODE = {
+        # Binary slices
+        :string => "a",
+        :null_padded_string => "Z",
+        :int32 => "l=",
+        :uint32 => "L=",
+        :uint64 => "Q=",
+        # Classes
+        :view => "",
+        :lcstr => "L=",
+        :two_level_hints_table => "",
+        :tool_entries => "L=",
+      }.freeze
+
+      # A list of classes that must get initialized
+      # To add a new class append it here and add the init method to the def_class_reader method
+      # @api private
+      CLASSES_TO_INIT = %i[lcstr tool_entries two_level_hints_table].freeze
+
+      # A list of fields that don't require arguments in the initializer
+      # Used to calculate MachOStructure#min_args
+      # @api private
+      NO_ARG_REQUIRED = %i[two_level_hints_table].freeze
+    end
+
+    # map of field names to indices
+    @field_idxs = {}
+
+    # array of fields sizes
+    @size_list = []
+
+    # array of field format codes
+    @fmt_list = []
+
+    # minimum number of required arguments
+    @min_args = 0
+
+    # @param args [Array[Value]] list of field parameters
+    def initialize(*args)
+      raise ArgumentError, "Invalid number of arguments" if args.size < self.class.min_args
+
+      @values = args
+    end
+
+    # @return [Hash] a hash representation of this {MachOStructure}.
+    def to_h
+      {
+        "structure" => {
+          "format" => self.class.format,
+          "bytesize" => self.class.bytesize,
+        },
+      }
+    end
+
+    class << self
+      attr_reader :min_args
+
+      # @param endianness [Symbol] either `:big` or `:little`
+      # @param bin [String] the string to be unpacked into the new structure
+      # @return [MachO::MachOStructure] the resulting structure
+      # @api private
+      def new_from_bin(endianness, bin)
+        format = Utils.specialize_format(self.format, endianness)
+
+        new(*bin.unpack(format))
+      end
+
+      def format
+        @format ||= @fmt_list.join
+      end
+
+      def bytesize
+        @bytesize ||= @size_list.sum
+      end
+
+      private
+
+      # @param subclass [Class] subclass type
+      # @api private
+      def inherited(subclass) # rubocop:disable Lint/MissingSuper
+        # Clone all class instance variables
+        field_idxs = @field_idxs.dup
+        size_list = @size_list.dup
+        fmt_list = @fmt_list.dup
+        min_args = @min_args.dup
+
+        # Add those values to the inheriting class
+        subclass.class_eval do
+          @field_idxs = field_idxs
+          @size_list = size_list
+          @fmt_list = fmt_list
+          @min_args = min_args
+        end
+      end
+
+      # @param name [Symbol] name of internal field
+      # @param type [Symbol] type of field in terms of binary size
+      # @param options [Hash] set of additional options
+      # Expected options
+      #   :size [Integer] size in bytes
+      #   :mask [Integer] bitmask
+      #   :unpack [String] string format
+      #   :default [Value] default value
+      #   :to_s [Boolean] flag for generating #to_s
+      #   :endian [Symbol] optionally specify :big or :little endian
+      #   :padding [Symbol] optionally specify :null padding
+      # @api private
+      def field(name, type, **options)
+        raise ArgumentError, "Invalid field type #{type}" unless Fields::FORMAT_CODE.key?(type)
+
+        # Get field idx for size_list and fmt_list
+        idx = if @field_idxs.key?(name)
+          @field_idxs[name]
+        else
+          @min_args += 1 unless options.key?(:default) || Fields::NO_ARG_REQUIRED.include?(type)
+          @field_idxs[name] = @field_idxs.size
+          @size_list << nil
+          @fmt_list << nil
+          @field_idxs.size - 1
+        end
+
+        # Update string type if padding is specified
+        type = :null_padded_string if type == :string && options[:padding] == :null
+
+        # Add to size_list and fmt_list
+        @size_list[idx] = Fields::BYTE_SIZE[type] || options[:size]
+        @fmt_list[idx] = if options[:endian]
+          Utils.specialize_format(Fields::FORMAT_CODE[type], options[:endian])
+        else
+          Fields::FORMAT_CODE[type]
+        end
+        @fmt_list[idx] += options[:size].to_s if options.key?(:size)
+
+        # Generate methods
+        if Fields::CLASSES_TO_INIT.include?(type)
+          def_class_reader(name, type, idx)
+        elsif options.key?(:mask)
+          def_mask_reader(name, idx, options[:mask])
+        elsif options.key?(:unpack)
+          def_unpack_reader(name, idx, options[:unpack])
+        elsif options.key?(:default)
+          def_default_reader(name, idx, options[:default])
+        else
+          def_reader(name, idx)
+        end
+
+        def_to_s(name) if options[:to_s]
+      end
+
+      #
+      # Method Generators
+      #
+
+      # Generates a reader method for classes that need to be initialized.
+      # These classes are defined in the Fields::CLASSES_TO_INIT array.
+      # @param name [Symbol] name of internal field
+      # @param type [Symbol] type of field in terms of binary size
+      # @param idx [Integer] the index of the field value in the @values array
+      # @api private
+      def def_class_reader(name, type, idx)
+        case type
+        when :lcstr
+          define_method(name) do
+            instance_variable_defined?("@#{name}") ||
+              instance_variable_set("@#{name}", LoadCommands::LoadCommand::LCStr.new(self, @values[idx]))
+
+            instance_variable_get("@#{name}")
+          end
+        when :two_level_hints_table
+          define_method(name) do
+            instance_variable_defined?("@#{name}") ||
+              instance_variable_set("@#{name}", LoadCommands::TwolevelHintsCommand::TwolevelHintsTable.new(view, htoffset, nhints))
+
+            instance_variable_get("@#{name}")
+          end
+        when :tool_entries
+          define_method(name) do
+            instance_variable_defined?("@#{name}") ||
+              instance_variable_set("@#{name}", LoadCommands::BuildVersionCommand::ToolEntries.new(view, @values[idx]))
+
+            instance_variable_get("@#{name}")
+          end
+        end
+      end
+
+      # Generates a reader method for fields that need to be bitmasked.
+      # @param name [Symbol] name of internal field
+      # @param idx [Integer] the index of the field value in the @values array
+      # @param mask [Integer] the bitmask
+      # @api private
+      def def_mask_reader(name, idx, mask)
+        define_method(name) do
+          instance_variable_defined?("@#{name}") ||
+            instance_variable_set("@#{name}", @values[idx] & ~mask)
+
+          instance_variable_get("@#{name}")
+        end
+      end
+
+      # Generates a reader method for fields that need further unpacking.
+      # @param name [Symbol] name of internal field
+      # @param idx [Integer] the index of the field value in the @values array
+      # @param unpack [String] the format code used for further binary unpacking
+      # @api private
+      def def_unpack_reader(name, idx, unpack)
+        define_method(name) do
+          instance_variable_defined?("@#{name}") ||
+            instance_variable_set("@#{name}", @values[idx].unpack(unpack))
+
+          instance_variable_get("@#{name}")
+        end
+      end
+
+      # Generates a reader method for fields that have default values.
+      # @param name [Symbol] name of internal field
+      # @param idx [Integer] the index of the field value in the @values array
+      # @param default [Value] the default value
+      # @api private
+      def def_default_reader(name, idx, default)
+        define_method(name) do
+          instance_variable_defined?("@#{name}") ||
+            instance_variable_set("@#{name}", @values.size > idx ? @values[idx] : default)
+
+          instance_variable_get("@#{name}")
+        end
+      end
+
+      # Generates an attr_reader like method for a field.
+      # @param name [Symbol] name of internal field
+      # @param idx [Integer] the index of the field value in the @values array
+      # @api private
+      def def_reader(name, idx)
+        define_method(name) do
+          @values[idx]
+        end
+      end
+
+      # Generates the to_s method based on the named field.
+      # @param name [Symbol] name of the field
+      # @api private
+      def def_to_s(name)
+        define_method(:to_s) do
+          send(name).to_s
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/tools.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/tools.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/tools.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/tools.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/utils.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/utils.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/ruby-macho-3.0.0/lib/macho/utils.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/utils.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/view.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/view.rb
new file mode 100644
index 0000000000000..3b1c36d9544d2
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/ruby-macho-4.1.0/lib/macho/view.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module MachO
+  # A representation of some unspecified Mach-O data.
+  class MachOView
+    # @return [MachOFile] that this view belongs to
+    attr_reader :macho_file
+
+    # @return [String] the raw Mach-O data
+    attr_reader :raw_data
+
+    # @return [Symbol] the endianness of the data (`:big` or `:little`)
+    attr_reader :endianness
+
+    # @return [Integer] the offset of the relevant data (in {#raw_data})
+    attr_reader :offset
+
+    # Creates a new MachOView.
+    # @param macho_file [MachOFile] the file this view slice is from
+    # @param raw_data [String] the raw Mach-O data
+    # @param endianness [Symbol] the endianness of the data
+    # @param offset [Integer] the offset of the relevant data
+    def initialize(macho_file, raw_data, endianness, offset)
+      @macho_file = macho_file
+      @raw_data = raw_data
+      @endianness = endianness
+      @offset = offset
+    end
+
+    # @return [Hash] a hash representation of this {MachOView}.
+    def to_h
+      {
+        "endianness" => endianness,
+        "offset" => offset,
+      }
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{(object_id << 1).to_s(16)} @endianness=#{@endianness.inspect}, @offset=#{@offset.inspect}, length=#{@raw_data.length}>"
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/sorbet-runtime.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/sorbet-runtime.rb
similarity index 94%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/sorbet-runtime.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/sorbet-runtime.rb
index c2ad5678d09e8..3c8cad60090fc 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/sorbet-runtime.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/sorbet-runtime.rb
@@ -19,6 +19,7 @@ module T::Private::Types; end
 require_relative 'types/configuration'
 require_relative 'types/_types'
 require_relative 'types/private/decl_state'
+require_relative 'types/private/caller_utils'
 require_relative 'types/private/class_utils'
 require_relative 'types/private/runtime_levels'
 require_relative 'types/private/methods/_methods'
@@ -37,14 +38,15 @@ module T::Private::Types; end
 require_relative 'types/types/fixed_hash'
 require_relative 'types/types/intersection'
 require_relative 'types/types/noreturn'
+require_relative 'types/types/anything'
 require_relative 'types/types/proc'
 require_relative 'types/types/attached_class'
 require_relative 'types/types/self_type'
 require_relative 'types/types/simple'
 require_relative 'types/types/t_enum'
 require_relative 'types/types/type_parameter'
-require_relative 'types/types/typed_array'
 require_relative 'types/types/typed_enumerator'
+require_relative 'types/types/typed_enumerator_chain'
 require_relative 'types/types/typed_enumerator_lazy'
 require_relative 'types/types/typed_hash'
 require_relative 'types/types/typed_range'
@@ -55,6 +57,7 @@ module T::Private::Types; end
 require_relative 'types/private/types/void'
 require_relative 'types/private/types/string_holder'
 require_relative 'types/private/types/type_alias'
+require_relative 'types/private/types/simple_pair_union'
 
 require_relative 'types/types/type_variable'
 require_relative 'types/types/type_member'
@@ -71,7 +74,6 @@ module T::Private::Types; end
 
 # Catch all. Sort of built by `cd extn; find types -type f | grep -v test | sort`
 require_relative 'types/generic'
-require_relative 'types/interface_wrapper'
 require_relative 'types/private/abstract/declare'
 require_relative 'types/private/abstract/hooks'
 require_relative 'types/private/casts'
@@ -81,6 +83,10 @@ module T::Private::Types; end
 require_relative 'types/utils'
 require_relative 'types/boolean'
 
+# Depends on types/utils
+require_relative 'types/types/typed_array'
+require_relative 'types/types/typed_class'
+
 # Props dependencies
 require_relative 'types/private/abstract/data'
 require_relative 'types/private/mixins/mixins'
@@ -111,6 +117,3 @@ module T::Private::Types; end
 require_relative 'types/non_forcing_constants'
 
 require_relative 'types/compatibility_patches'
-
-# Sorbet Compiler support module
-require_relative 'types/private/compiler'
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/_types.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/_types.rb
similarity index 81%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/_types.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/_types.rb
index 20a0e641e0e03..55401ca76d131 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/_types.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/_types.rb
@@ -47,6 +47,10 @@ def self.noreturn
     T::Types::NoReturn::Private::INSTANCE
   end
 
+  def self.anything
+    T::Types::Anything::Private::INSTANCE
+  end
+
   # T.all(<Type>, <Type>, ...) -- matches an object that has all of the types listed
   def self.all(type_a, type_b, *types)
     T::Types::Intersection.new([type_a, type_b] + types)
@@ -119,7 +123,7 @@ def self.type_alias(type=nil, &blk)
   #  .returns(T::Array[T.type_parameter(:U)])
   #  def map(&blk); end
   def self.type_parameter(name)
-    T::Types::TypeParameter.new(name)
+    T::Types::TypeParameter.make(name)
   end
 
   # Tells the typechecker that `value` is of type `type`. Use this to get additional checking after
@@ -130,7 +134,7 @@ def self.type_parameter(name)
   def self.cast(value, type, checked: true)
     return value unless checked
 
-    Private::Casts.cast(value, type, cast_method: "T.cast")
+    Private::Casts.cast(value, type, "T.cast")
   end
 
   # Tells the typechecker to declare a variable of type `type`. Use
@@ -145,7 +149,7 @@ def self.cast(value, type, checked: true)
   def self.let(value, type, checked: true)
     return value unless checked
 
-    Private::Casts.cast(value, type, cast_method: "T.let")
+    Private::Casts.cast(value, type, "T.let")
   end
 
   # Tells the type checker to treat `self` in the current block as `type`.
@@ -164,7 +168,7 @@ def self.let(value, type, checked: true)
   def self.bind(value, type, checked: true)
     return value unless checked
 
-    Private::Casts.cast(value, type, cast_method: "T.bind")
+    Private::Casts.cast(value, type, "T.bind")
   end
 
   # Tells the typechecker to ensure that `value` is of type `type` (if not, the typechecker will
@@ -174,7 +178,7 @@ def self.bind(value, type, checked: true)
   def self.assert_type!(value, type, checked: true)
     return value unless checked
 
-    Private::Casts.cast(value, type, cast_method: "T.assert_type!")
+    Private::Casts.cast(value, type, "T.assert_type!")
   end
 
   # For the static type checker, strips all type information from a value
@@ -221,6 +225,34 @@ def self.must(arg)
     end
   end
 
+  # A convenience method to `raise` with a provided error reason when the argument
+  # is `nil` and return it otherwise.
+  #
+  # Intended to be used as:
+  #
+  #   needs_foo(T.must_because(maybe_gives_foo) {"reason_foo_should_not_be_nil"})
+  #
+  # Equivalent to:
+  #
+  #   foo = maybe_gives_foo
+  #   raise "reason_foo_should_not_be_nil" if foo.nil?
+  #   needs_foo(foo)
+  #
+  # Intended to be used to promise sorbet that a given nilable value happens
+  # to contain a non-nil value at this point.
+  #
+  # `sig {params(arg: T.nilable(A), reason_blk: T.proc.returns(String)).returns(A)}`
+  def self.must_because(arg)
+    return arg if arg
+    return arg if arg == false
+
+    begin
+      raise TypeError.new("Unexpected `nil` because #{yield}")
+    rescue TypeError => e # raise into rescue to ensure e.backtrace is populated
+      T::Configuration.inline_type_error_handler(e, {kind: 'T.must_because', value: arg, type: nil})
+    end
+  end
+
   # A way to ask Sorbet to show what type it thinks an expression has.
   # This can be useful for debugging and checking assumptions.
   # In the runtime, merely returns the value passed in.
@@ -251,9 +283,9 @@ def self.absurd(value)
   module Array
     def self.[](type)
       if type.is_a?(T::Types::Untyped)
-        T::Types::TypedArray::Untyped.new
+        T::Types::TypedArray::Untyped::Private::INSTANCE
       else
-        T::Types::TypedArray.new(type)
+        T::Types::TypedArray::Private::Pool.type_for_module(type)
       end
     end
   end
@@ -296,6 +328,16 @@ def self.[](type)
         end
       end
     end
+
+    module Chain
+      def self.[](type)
+        if type.is_a?(T::Types::Untyped)
+          T::Types::TypedEnumeratorChain::Untyped.new
+        else
+          T::Types::TypedEnumeratorChain.new(type)
+        end
+      end
+    end
   end
 
   module Range
@@ -313,4 +355,16 @@ def self.[](type)
       end
     end
   end
+
+  module Class
+    def self.[](type)
+      if type.is_a?(T::Types::Untyped)
+        T::Types::TypedClass::Untyped::Private::INSTANCE
+      elsif type.is_a?(T::Types::Anything)
+        T::Types::TypedClass::Anything::Private::INSTANCE
+      else
+        T::Types::TypedClass::Private::Pool.type_for_module(type)
+      end
+    end
+  end
 end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/abstract_utils.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/abstract_utils.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/abstract_utils.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/abstract_utils.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/boolean.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/boolean.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/boolean.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/boolean.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/compatibility_patches.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/compatibility_patches.rb
similarity index 92%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/compatibility_patches.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/compatibility_patches.rb
index 070b182aae1db..17e46ea3ae285 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/compatibility_patches.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/compatibility_patches.rb
@@ -27,8 +27,10 @@ module CompatibilityPatches
       module RSpecCompatibility
         module RecorderExtensions
           def observe!(method_name)
-            method = @klass.instance_method(method_name.to_sym)
-            T::Private::Methods.maybe_run_sig_block_for_method(method)
+            if @klass.method_defined?(method_name.to_sym)
+              method = @klass.instance_method(method_name.to_sym)
+              T::Private::Methods.maybe_run_sig_block_for_method(method)
+            end
             super(method_name)
           end
         end
@@ -36,7 +38,7 @@ def observe!(method_name)
 
         module MethodDoubleExtensions
           def initialize(object, method_name, proxy)
-            if ::Kernel.instance_method(:respond_to?).bind(object).call(method_name, true)
+            if ::Kernel.instance_method(:respond_to?).bind(object).call(method_name, true) # rubocop:disable Performance/BindCall
               method = ::RSpec::Support.method_handle_for(object, method_name)
               T::Private::Methods.maybe_run_sig_block_for_method(method)
             end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/configuration.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/configuration.rb
new file mode 100644
index 0000000000000..d598fa4e7ed51
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/configuration.rb
@@ -0,0 +1,592 @@
+# typed: true
+# frozen_string_literal: true
+
+module T::Configuration
+  # Cache this comparisonn to avoid two allocations all over the place.
+  AT_LEAST_RUBY_2_7 = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7')
+
+  # Announces to Sorbet that we are currently in a test environment, so it
+  # should treat any sigs which are marked `.checked(:tests)` as if they were
+  # just a normal sig.
+  #
+  # If this method is not called, sigs marked `.checked(:tests)` will not be
+  # checked. In fact, such methods won't even be wrapped--the runtime will put
+  # back the original method.
+  #
+  # Note: Due to the way sigs are evaluated and methods are wrapped, this
+  # method MUST be called before any code calls `sig`. This method raises if
+  # it has been called too late.
+  def self.enable_checking_for_sigs_marked_checked_tests
+    T::Private::RuntimeLevels.enable_checking_in_tests
+  end
+
+  # Announce to Sorbet that we would like the final checks to be enabled when
+  # including and extending modules. Iff this is not called, then the following
+  # example will not raise an error.
+  #
+  # ```ruby
+  # module M
+  #   extend T::Sig
+  #   sig(:final) {void}
+  #   def foo; end
+  # end
+  # class C
+  #   include M
+  #   def foo; end
+  # end
+  # ```
+  def self.enable_final_checks_on_hooks
+    T::Private::Methods.set_final_checks_on_hooks(true)
+  end
+
+  # Undo the effects of a previous call to
+  # `enable_final_checks_on_hooks`.
+  def self.reset_final_checks_on_hooks
+    T::Private::Methods.set_final_checks_on_hooks(false)
+  end
+
+  @include_value_in_type_errors = true
+  # Whether to include values in TypeError messages.
+  #
+  # Including values is useful for debugging, but can potentially leak
+  # sensitive information to logs.
+  #
+  # @return [T::Boolean]
+  def self.include_value_in_type_errors?
+    @include_value_in_type_errors
+  end
+
+  # Configure if type errors excludes the value of the problematic type.
+  #
+  # The default is to include values in type errors:
+  #   TypeError: Expected type Integer, got String with value "foo"
+  #
+  # When values are excluded from type errors:
+  #   TypeError: Expected type Integer, got String
+  def self.exclude_value_in_type_errors
+    @include_value_in_type_errors = false
+  end
+
+  # Opposite of exclude_value_in_type_errors.
+  # (Including values in type errors is the default)
+  def self.include_value_in_type_errors
+    @include_value_in_type_errors = true
+  end
+
+  # Whether VM-defined prop serialization/deserialization routines can be enabled.
+  #
+  # @return [T::Boolean]
+  def self.can_enable_vm_prop_serde?
+    T::Props::Private::DeserializerGenerator.respond_to?(:generate2)
+  end
+
+  @use_vm_prop_serde = false
+  # Whether to use VM-defined prop serialization/deserialization routines.
+  #
+  # The default is to use runtime codegen inside sorbet-runtime itself.
+  #
+  # @return [T::Boolean]
+  def self.use_vm_prop_serde?
+    @use_vm_prop_serde || false
+  end
+
+  # Enable using VM-defined prop serialization/deserialization routines.
+  #
+  # This method is likely to break things outside of Stripe's systems.
+  def self.enable_vm_prop_serde
+    if !can_enable_vm_prop_serde?
+      hard_assert_handler('Ruby VM is not setup to use VM-defined prop serde')
+    end
+    @use_vm_prop_serde = true
+  end
+
+  # Disable using VM-defined prop serialization/deserialization routines.
+  def self.disable_vm_prop_serde
+    @use_vm_prop_serde = false
+  end
+
+  # Configure the default checked level for a sig with no explicit `.checked`
+  # builder. When unset, the default checked level is `:always`.
+  #
+  # Note: setting this option is potentially dangerous! Sorbet can't check all
+  # code statically. The runtime checks complement the checks that Sorbet does
+  # statically, so that methods don't have to guard themselves from being
+  # called incorrectly by untyped code.
+  #
+  # @param [:never, :tests, :always] default_checked_level
+  def self.default_checked_level=(default_checked_level)
+    T::Private::RuntimeLevels.default_checked_level = default_checked_level
+  end
+
+  @inline_type_error_handler = nil
+  # Set a handler to handle `TypeError`s raised by any in-line type assertions,
+  # including `T.must`, `T.let`, `T.cast`, and `T.assert_type!`.
+  #
+  # By default, any `TypeError`s detected by this gem will be raised. Setting
+  # inline_type_error_handler to an object that implements :call (e.g. proc or
+  # lambda) allows users to customize the behavior when a `TypeError` is
+  # raised on any inline type assertion.
+  #
+  # @param [Lambda, Proc, Object, nil] value Proc that handles the error (pass
+  #   nil to reset to default behavior)
+  #
+  # Parameters passed to value.call:
+  #
+  #  @param [TypeError] error TypeError that was raised
+  #  @param [Hash] opts A hash containing contextual information on the error:
+  #  @option opts [String] :kind One of:
+  #    ['T.cast', 'T.let', 'T.bind', 'T.assert_type!', 'T.must', 'T.absurd']
+  #  @option opts [Object, nil] :type Expected param/return value type
+  #  @option opts [Object] :value Actual param/return value
+  #
+  # @example
+  #   T::Configuration.inline_type_error_handler = lambda do |error, opts|
+  #     puts error.message
+  #   end
+  def self.inline_type_error_handler=(value)
+    validate_lambda_given!(value)
+    @inline_type_error_handler = value
+  end
+
+  private_class_method def self.inline_type_error_handler_default(error, opts)
+    raise error
+  end
+
+  def self.inline_type_error_handler(error, opts={})
+    if @inline_type_error_handler
+      # Backwards compatibility before `inline_type_error_handler` took a second arg
+      if @inline_type_error_handler.arity == 1
+        @inline_type_error_handler.call(error)
+      else
+        @inline_type_error_handler.call(error, opts)
+      end
+    else
+      inline_type_error_handler_default(error, opts)
+    end
+    nil
+  end
+
+  @sig_builder_error_handler = nil
+  # Set a handler to handle errors that occur when the builder methods in the
+  # body of a sig are executed. The sig builder methods are inside a proc so
+  # that they can be lazily evaluated the first time the method being sig'd is
+  # called.
+  #
+  # By default, improper use of the builder methods within the body of a sig
+  # cause an ArgumentError to be raised. Setting sig_builder_error_handler to an
+  # object that implements :call (e.g. proc or lambda) allows users to
+  # customize the behavior when a sig can't be built for some reason.
+  #
+  # @param [Lambda, Proc, Object, nil] value Proc that handles the error (pass
+  #   nil to reset to default behavior)
+  #
+  # Parameters passed to value.call:
+  #
+  #  @param [StandardError] error The error that was raised
+  #  @param [Thread::Backtrace::Location] location Location of the error
+  #
+  # @example
+  #   T::Configuration.sig_builder_error_handler = lambda do |error, location|
+  #     puts error.message
+  #   end
+  def self.sig_builder_error_handler=(value)
+    validate_lambda_given!(value)
+    @sig_builder_error_handler = value
+  end
+
+  private_class_method def self.sig_builder_error_handler_default(error, location)
+    raise ArgumentError.new("#{location.path}:#{location.lineno}: Error interpreting `sig`:\n  #{error.message}\n\n")
+  end
+
+  def self.sig_builder_error_handler(error, location)
+    if @sig_builder_error_handler
+      @sig_builder_error_handler.call(error, location)
+    else
+      sig_builder_error_handler_default(error, location)
+    end
+    nil
+  end
+
+  @sig_validation_error_handler = nil
+  # Set a handler to handle sig validation errors.
+  #
+  # Sig validation errors include things like abstract checks, override checks,
+  # and type compatibility of arguments. They happen after a sig has been
+  # successfully built, but the built sig is incompatible with other sigs in
+  # some way.
+  #
+  # By default, sig validation errors cause an exception to be raised.
+  # Setting sig_validation_error_handler to an object that implements :call
+  # (e.g. proc or lambda) allows users to customize the behavior when a method
+  # signature's build fails.
+  #
+  # @param [Lambda, Proc, Object, nil] value Proc that handles the error (pass
+  #   nil to reset to default behavior)
+  #
+  # Parameters passed to value.call:
+  #
+  #  @param [StandardError] error The error that was raised
+  #  @param [Hash] opts A hash containing contextual information on the error:
+  #  @option opts [Method, UnboundMethod] :method Method on which the signature build failed
+  #  @option opts [T::Private::Methods::Declaration] :declaration Method
+  #    signature declaration struct
+  #  @option opts [T::Private::Methods::Signature, nil] :signature Signature
+  #    that failed (nil if sig build failed before Signature initialization)
+  #  @option opts [T::Private::Methods::Signature, nil] :super_signature Super
+  #    method's signature (nil if method is not an override or super method
+  #    does not have a method signature)
+  #
+  # @example
+  #   T::Configuration.sig_validation_error_handler = lambda do |error, opts|
+  #     puts error.message
+  #   end
+  def self.sig_validation_error_handler=(value)
+    validate_lambda_given!(value)
+    @sig_validation_error_handler = value
+  end
+
+  private_class_method def self.sig_validation_error_handler_default(error, opts)
+    raise error
+  end
+
+  def self.sig_validation_error_handler(error, opts={})
+    if @sig_validation_error_handler
+      @sig_validation_error_handler.call(error, opts)
+    else
+      sig_validation_error_handler_default(error, opts)
+    end
+    nil
+  end
+
+  @call_validation_error_handler = nil
+  # Set a handler for type errors that result from calling a method.
+  #
+  # By default, errors from calling a method cause an exception to be raised.
+  # Setting call_validation_error_handler to an object that implements :call
+  # (e.g. proc or lambda) allows users to customize the behavior when a method
+  # is called with invalid parameters, or returns an invalid value.
+  #
+  # @param [Lambda, Proc, Object, nil] value Proc that handles the error
+  #   report (pass nil to reset to default behavior)
+  #
+  # Parameters passed to value.call:
+  #
+  #  @param [T::Private::Methods::Signature] signature Signature that failed
+  #  @param [Hash] opts A hash containing contextual information on the error:
+  #  @option opts [String] :message Error message
+  #  @option opts [String] :kind One of:
+  #    ['Parameter', 'Block parameter', 'Return value']
+  #  @option opts [Symbol] :name Param or block param name (nil for return
+  #    value)
+  #  @option opts [Object] :type Expected param/return value type
+  #  @option opts [Object] :value Actual param/return value
+  #  @option opts [Thread::Backtrace::Location] :location Location of the
+  #    caller
+  #
+  # @example
+  #   T::Configuration.call_validation_error_handler = lambda do |signature, opts|
+  #     puts opts[:message]
+  #   end
+  def self.call_validation_error_handler=(value)
+    validate_lambda_given!(value)
+    @call_validation_error_handler = value
+  end
+
+  private_class_method def self.call_validation_error_handler_default(signature, opts)
+    raise TypeError.new(opts[:pretty_message])
+  end
+
+  def self.call_validation_error_handler(signature, opts={})
+    if @call_validation_error_handler
+      @call_validation_error_handler.call(signature, opts)
+    else
+      call_validation_error_handler_default(signature, opts)
+    end
+    nil
+  end
+
+  @log_info_handler = nil
+  # Set a handler for logging
+  #
+  # @param [Lambda, Proc, Object, nil] value Proc that handles the error
+  #   report (pass nil to reset to default behavior)
+  #
+  # Parameters passed to value.call:
+  #
+  #  @param [String] str Message to be logged
+  #  @param [Hash] extra A hash containing additional parameters to be passed along to the logger.
+  #
+  # @example
+  #   T::Configuration.log_info_handler = lambda do |str, extra|
+  #     puts "#{str}, context: #{extra}"
+  #   end
+  def self.log_info_handler=(value)
+    validate_lambda_given!(value)
+    @log_info_handler = value
+  end
+
+  private_class_method def self.log_info_handler_default(str, extra)
+    puts "#{str}, extra: #{extra}"
+  end
+
+  def self.log_info_handler(str, extra)
+    if @log_info_handler
+      @log_info_handler.call(str, extra)
+    else
+      log_info_handler_default(str, extra)
+    end
+  end
+
+  @soft_assert_handler = nil
+  # Set a handler for soft assertions
+  #
+  # These generally shouldn't stop execution of the program, but rather inform
+  # some party of the assertion to action on later.
+  #
+  # @param [Lambda, Proc, Object, nil] value Proc that handles the error
+  #   report (pass nil to reset to default behavior)
+  #
+  # Parameters passed to value.call:
+  #
+  #  @param [String] str Assertion message
+  #  @param [Hash] extra A hash containing additional parameters to be passed along to the handler.
+  #
+  # @example
+  #   T::Configuration.soft_assert_handler = lambda do |str, extra|
+  #     puts "#{str}, context: #{extra}"
+  #   end
+  def self.soft_assert_handler=(value)
+    validate_lambda_given!(value)
+    @soft_assert_handler = value
+  end
+
+  private_class_method def self.soft_assert_handler_default(str, extra)
+    puts "#{str}, extra: #{extra}"
+  end
+
+  def self.soft_assert_handler(str, extra)
+    if @soft_assert_handler
+      @soft_assert_handler.call(str, extra)
+    else
+      soft_assert_handler_default(str, extra)
+    end
+  end
+
+  @hard_assert_handler = nil
+  # Set a handler for hard assertions
+  #
+  # These generally should stop execution of the program, and optionally inform
+  # some party of the assertion.
+  #
+  # @param [Lambda, Proc, Object, nil] value Proc that handles the error
+  #   report (pass nil to reset to default behavior)
+  #
+  # Parameters passed to value.call:
+  #
+  #  @param [String] str Assertion message
+  #  @param [Hash] extra A hash containing additional parameters to be passed along to the handler.
+  #
+  # @example
+  #   T::Configuration.hard_assert_handler = lambda do |str, extra|
+  #     raise "#{str}, context: #{extra}"
+  #   end
+  def self.hard_assert_handler=(value)
+    validate_lambda_given!(value)
+    @hard_assert_handler = value
+  end
+
+  private_class_method def self.hard_assert_handler_default(str, _)
+    raise str
+  end
+
+  def self.hard_assert_handler(str, extra={})
+    if @hard_assert_handler
+      @hard_assert_handler.call(str, extra)
+    else
+      hard_assert_handler_default(str, extra)
+    end
+  end
+
+  @scalar_types = nil
+  # Set a list of class strings that are to be considered scalar.
+  #   (pass nil to reset to default behavior)
+  #
+  # @param [String] values Class name.
+  #
+  # @example
+  #   T::Configuration.scalar_types = ["NilClass", "TrueClass", "FalseClass", ...]
+  def self.scalar_types=(values)
+    if values.nil?
+      @scalar_types = values
+    else
+      bad_values = values.reject {|v| v.class == String}
+      unless bad_values.empty?
+        raise ArgumentError.new("Provided values must all be class name strings.")
+      end
+
+      @scalar_types = values.each_with_object({}) {|x, acc| acc[x] = true}.freeze
+    end
+  end
+
+  @default_scalar_types = {
+    "NilClass" => true,
+    "TrueClass" => true,
+    "FalseClass" => true,
+    "Integer" => true,
+    "Float" => true,
+    "String" => true,
+    "Symbol" => true,
+    "Time" => true,
+    "T::Enum" => true,
+  }.freeze
+
+  def self.scalar_types
+    @scalar_types || @default_scalar_types
+  end
+
+  # Guard against overrides of `name` or `to_s`
+  MODULE_NAME = Module.instance_method(:name)
+  private_constant :MODULE_NAME
+
+  @default_module_name_mangler = if T::Configuration::AT_LEAST_RUBY_2_7
+    ->(type) {MODULE_NAME.bind_call(type)}
+  else
+    ->(type) {MODULE_NAME.bind(type).call} # rubocop:disable Performance/BindCall
+  end
+
+  @module_name_mangler = nil
+
+  def self.module_name_mangler
+    @module_name_mangler || @default_module_name_mangler
+  end
+
+  # Set to override the default behavior for converting types
+  #   to names in generated code. Used by the runtime implementation
+  #   associated with `--stripe-packages` mode.
+  #
+  # @param [Lambda, Proc, nil] handler Proc that converts a type (Class/Module)
+  #   to a String (pass nil to reset to default behavior)
+  def self.module_name_mangler=(handler)
+    @module_name_mangler = handler
+  end
+
+  @sensitivity_and_pii_handler = nil
+  # Set to a PII handler function. This will be called with the `sensitivity:`
+  # annotations on things that use `T::Props` and can modify them ahead-of-time.
+  #
+  # @param [Lambda, Proc, nil] handler Proc that takes a hash mapping symbols to the
+  # prop values. Pass nil to avoid changing `sensitivity:` annotations.
+  def self.normalize_sensitivity_and_pii_handler=(handler)
+    @sensitivity_and_pii_handler = handler
+  end
+
+  def self.normalize_sensitivity_and_pii_handler
+    @sensitivity_and_pii_handler
+  end
+
+  @redaction_handler = nil
+  # Set to a redaction handling function. This will be called when the
+  # `_redacted` version of a prop reader is used. By default this is set to
+  # `nil` and will raise an exception when the redacted version of a prop is
+  # accessed.
+  #
+  # @param [Lambda, Proc, nil] handler Proc that converts a value into its
+  # redacted version according to the spec passed as the second argument.
+  def self.redaction_handler=(handler)
+    @redaction_handler = handler
+  end
+
+  def self.redaction_handler
+    @redaction_handler
+  end
+
+  @class_owner_finder = nil
+  # Set to a function which can get the 'owner' of a class. This is
+  # used in reporting deserialization errors
+  #
+  # @param [Lambda, Proc, nil] handler Proc that takes a class and
+  # produces its owner, or `nil` if it does not have one.
+  def self.class_owner_finder=(handler)
+    @class_owner_finder = handler
+  end
+
+  def self.class_owner_finder
+    @class_owner_finder
+  end
+
+  # Temporarily disable ruby warnings while executing the given block. This is
+  # useful when doing something that would normally cause a warning to be
+  # emitted in Ruby verbose mode ($VERBOSE = true).
+  #
+  # @yield
+  #
+  def self.without_ruby_warnings
+    if $VERBOSE
+      begin
+        original_verbose = $VERBOSE
+        $VERBOSE = false
+        yield
+      ensure
+        $VERBOSE = original_verbose
+      end
+    else
+      yield
+    end
+  end
+
+  @legacy_t_enum_migration_mode = false
+  def self.enable_legacy_t_enum_migration_mode
+    T::Enum.include(T::Enum::LegacyMigrationMode)
+    @legacy_t_enum_migration_mode = true
+  end
+  def self.disable_legacy_t_enum_migration_mode
+    @legacy_t_enum_migration_mode = false
+  end
+  def self.legacy_t_enum_migration_mode?
+    @legacy_t_enum_migration_mode || false
+  end
+
+  @prop_freeze_handler = ->(instance, prop_name) {}
+
+  def self.prop_freeze_handler=(handler)
+    @prop_freeze_handler = handler
+  end
+
+  def self.prop_freeze_handler
+    @prop_freeze_handler
+  end
+
+  @sealed_violation_whitelist = nil
+  # @param [Array] sealed_violation_whitelist An array of Regexp to validate
+  #   whether inheriting /including a sealed module outside the defining module
+  #   should be allowed. Useful to whitelist benign violations, like shim files
+  #   generated for an autoloader.
+  def self.sealed_violation_whitelist=(sealed_violation_whitelist)
+    if !@sealed_violation_whitelist.nil?
+      raise ArgumentError.new("Cannot overwrite sealed_violation_whitelist after setting it")
+    end
+
+    case sealed_violation_whitelist
+    when Array
+      sealed_violation_whitelist.each do |x|
+        case x
+        when Regexp then nil
+        else raise TypeError.new("sealed_violation_whitelist accepts an Array of Regexp")
+        end
+      end
+    else
+      raise TypeError.new("sealed_violation_whitelist= accepts an Array of Regexp")
+    end
+
+    @sealed_violation_whitelist = sealed_violation_whitelist
+  end
+  def self.sealed_violation_whitelist
+    @sealed_violation_whitelist
+  end
+
+  private_class_method def self.validate_lambda_given!(value)
+    if !value.nil? && !value.respond_to?(:call)
+      raise ArgumentError.new("Provided value must respond to :call")
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/enum.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/enum.rb
new file mode 100644
index 0000000000000..38eea14f5a546
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/enum.rb
@@ -0,0 +1,406 @@
+# frozen_string_literal: true
+# typed: strict
+
+# Enumerations allow for type-safe declarations of a fixed set of values.
+#
+# Every value is a singleton instance of the class (i.e. `Suit::SPADE.is_a?(Suit) == true`).
+#
+# Each value has a corresponding serialized value. By default this is the constant's name converted
+# to lowercase (e.g. `Suit::Club.serialize == 'club'`); however a custom value may be passed to the
+# constructor. Enum will `freeze` the serialized value.
+#
+# @example Declaring an Enum:
+#   class Suit < T::Enum
+#     enums do
+#       CLUB = new
+#       SPADE = new
+#       DIAMOND = new
+#       HEART = new
+#     end
+#   end
+#
+# @example Custom serialization value:
+#   class Status < T::Enum
+#     enums do
+#       READY = new('rdy')
+#       ...
+#     end
+#   end
+#
+# @example Accessing values:
+#   Suit::SPADE
+#
+# @example Converting from serialized value to enum instance:
+#   Suit.deserialize('club') == Suit::CLUB
+#
+# @example Using enums in type signatures:
+#   sig {params(suit: Suit).returns(Boolean)}
+#   def is_red?(suit); ...; end
+#
+# WARNING: Enum instances are singletons that are shared among all their users. Their internals
+# should be kept immutable to avoid unpredictable action at a distance.
+class T::Enum
+  extend T::Sig
+  extend T::Props::CustomType
+
+  # TODO(jez) Might want to restrict this, or make subclasses provide this type
+  SerializedVal = T.type_alias {T.untyped}
+  private_constant :SerializedVal
+
+  ### Enum class methods ###
+  sig {returns(T::Array[T.attached_class])}
+  def self.values
+    if @values.nil?
+      raise "Attempting to access values of #{self.class} before it has been initialized." \
+        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+    end
+    @values
+  end
+
+  # This exists for compatibility with the interface of `Hash` & mostly to support
+  # the HashEachMethods Rubocop.
+  sig {params(blk: T.nilable(T.proc.params(arg0: T.attached_class).void)).returns(T.any(T::Enumerator[T.attached_class], T::Array[T.attached_class]))}
+  def self.each_value(&blk)
+    if blk
+      values.each(&blk)
+    else
+      values.each
+    end
+  end
+
+  # Convert from serialized value to enum instance
+  #
+  # Note: It would have been nice to make this method final before people started overriding it.
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  sig {params(serialized_val: SerializedVal).returns(T.nilable(T.attached_class)).checked(:never)}
+  def self.try_deserialize(serialized_val)
+    if @mapping.nil?
+      raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
+        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+    end
+    @mapping[serialized_val]
+  end
+
+  # Convert from serialized value to enum instance.
+  #
+  # Note: It would have been nice to make this method final before people started overriding it.
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  #
+  # @return [self]
+  # @raise [KeyError] if serialized value does not match any instance.
+  sig {overridable.params(serialized_val: SerializedVal).returns(T.attached_class).checked(:never)}
+  def self.from_serialized(serialized_val)
+    res = try_deserialize(serialized_val)
+    if res.nil?
+      raise KeyError.new("Enum #{self} key not found: #{serialized_val.inspect}")
+    end
+    res
+  end
+
+  # Note: It would have been nice to make this method final before people started overriding it.
+  # @return [Boolean] Does the given serialized value correspond with any of this enum's values.
+  sig {overridable.params(serialized_val: SerializedVal).returns(T::Boolean).checked(:never)}
+  def self.has_serialized?(serialized_val)
+    if @mapping.nil?
+      raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
+        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+    end
+    @mapping.include?(serialized_val)
+  end
+
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  sig {override.params(instance: T.nilable(T::Enum)).returns(SerializedVal).checked(:never)}
+  def self.serialize(instance)
+    # This is needed otherwise if a Chalk::ODM::Document with a property of the shape
+    # T::Hash[T.nilable(MyEnum), Integer] and a value that looks like {nil => 0} is
+    # serialized, we throw the error on L102.
+    return nil if instance.nil?
+
+    if self == T::Enum
+      raise "Cannot call T::Enum.serialize directly. You must call on a specific child class."
+    end
+    if instance.class != self
+      raise "Cannot call #serialize on a value that is not an instance of #{self}."
+    end
+    instance.serialize
+  end
+
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  sig {override.params(mongo_value: SerializedVal).returns(T.attached_class).checked(:never)}
+  def self.deserialize(mongo_value)
+    if self == T::Enum
+      raise "Cannot call T::Enum.deserialize directly. You must call on a specific child class."
+    end
+    self.from_serialized(mongo_value)
+  end
+
+  ### Enum instance methods ###
+
+  sig {returns(T.self_type)}
+  def dup
+    self
+  end
+
+  sig {returns(T.self_type).checked(:tests)}
+  def clone
+    self
+  end
+
+  # Note: Failed CriticalMethodsNoRuntimeTypingTest
+  sig {returns(SerializedVal).checked(:never)}
+  def serialize
+    assert_bound!
+    @serialized_val
+  end
+
+  sig {params(args: T.untyped).returns(T.untyped)}
+  def to_json(*args)
+    serialize.to_json(*args)
+  end
+
+  sig {params(args: T.untyped).returns(T.untyped)}
+  def as_json(*args)
+    serialized_val = serialize
+    return serialized_val unless serialized_val.respond_to?(:as_json)
+    serialized_val.as_json(*args)
+  end
+
+  sig {returns(String)}
+  def to_s
+    inspect
+  end
+
+  sig {returns(String)}
+  def inspect
+    "#<#{self.class.name}::#{@const_name || '__UNINITIALIZED__'}>"
+  end
+
+  sig {params(other: BasicObject).returns(T.nilable(Integer))}
+  def <=>(other)
+    case other
+    when self.class
+      self.serialize <=> other.serialize
+    else
+      nil
+    end
+  end
+
+  # NB: Do not call this method. This exists to allow for a safe migration path in places where enum
+  # values are compared directly against string values.
+  #
+  # Ruby's string has a weird quirk where `'my_string' == obj` calls obj.==('my_string') if obj
+  # responds to the `to_str` method. It does not actually call `to_str` however.
+  #
+  # See https://ruby-doc.org/core-2.4.0/String.html#method-i-3D-3D
+  T::Sig::WithoutRuntime.sig {returns(String)}
+  def to_str
+    msg = 'Implicit conversion of Enum instances to strings is not allowed. Call #serialize instead.'
+    if T::Configuration.legacy_t_enum_migration_mode?
+      T::Configuration.soft_assert_handler(
+        msg,
+        storytime: {
+          class: self.class.name,
+          caller_location: Kernel.caller_locations(1..1)&.[](0)&.then {"#{_1.path}:#{_1.lineno}"},
+        },
+      )
+      serialize.to_s
+    else
+      Kernel.raise NoMethodError.new(msg)
+    end
+  end
+
+  module LegacyMigrationMode
+    include Kernel
+    extend T::Helpers
+    abstract!
+
+    if T.unsafe(false)
+      # Declare to the type system that the `serialize` method for sure exists
+      # on whatever we mix this into.
+      T::Sig::WithoutRuntime.sig {abstract.returns(T.untyped)}
+      def serialize; end
+    end
+
+    # WithoutRuntime so that comparison_assertion_failed can assume a constant stack depth
+    T::Sig::WithoutRuntime.sig {params(other: BasicObject).returns(T::Boolean)}
+    def ==(other)
+      case other
+      when String
+        if T::Configuration.legacy_t_enum_migration_mode?
+          comparison_assertion_failed(:==, other)
+          self.serialize == other
+        else
+          false
+        end
+      else
+        super(other)
+      end
+    end
+
+    # WithoutRuntime so that comparison_assertion_failed can assume a constant stack depth
+    T::Sig::WithoutRuntime.sig {params(other: BasicObject).returns(T::Boolean)}
+    def ===(other)
+      case other
+      when String
+        if T::Configuration.legacy_t_enum_migration_mode?
+          comparison_assertion_failed(:===, other)
+          self.serialize == other
+        else
+          false
+        end
+      else
+        super(other)
+      end
+    end
+
+    # WithoutRuntime so that caller_locations can assume a constant stack depth
+    # (Otherwise, the first call would be the method with the wrapping, which would have a different stack depth.)
+    T::Sig::WithoutRuntime.sig {params(method: Symbol, other: T.untyped).void}
+    private def comparison_assertion_failed(method, other)
+      T::Configuration.soft_assert_handler(
+        'Enum to string comparison not allowed. Compare to the Enum instance directly instead. See go/enum-migration',
+        storytime: {
+          class: self.class.name,
+          self: self.inspect,
+          other: other,
+          other_class: other.class.name,
+          method: method,
+          caller_location: Kernel.caller_locations(2..2)&.[](0)&.then {"#{_1.path}:#{_1.lineno}"},
+        }
+      )
+    end
+  end
+
+  ### Private implementation ###
+
+  UNSET = T.let(Module.new.freeze, Module)
+  private_constant :UNSET
+
+  sig {params(serialized_val: SerializedVal).void}
+  def initialize(serialized_val=UNSET)
+    raise 'T::Enum is abstract' if self.class == T::Enum
+    if !self.class.started_initializing?
+      raise "Must instantiate all enum values of #{self.class} inside 'enums do'."
+    end
+    if self.class.fully_initialized?
+      raise "Cannot instantiate a new enum value of #{self.class} after it has been initialized."
+    end
+
+    serialized_val = serialized_val.frozen? ? serialized_val : serialized_val.dup.freeze
+    @serialized_val = T.let(serialized_val, T.nilable(SerializedVal))
+    @const_name = T.let(nil, T.nilable(Symbol))
+    self.class._register_instance(self)
+  end
+
+  sig {returns(NilClass).checked(:never)}
+  private def assert_bound!
+    if @const_name.nil?
+      raise "Attempting to access Enum value on #{self.class} before it has been initialized." \
+        " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+    end
+  end
+
+  sig {params(const_name: Symbol).void}
+  def _bind_name(const_name)
+    @const_name = const_name
+    @serialized_val = const_to_serialized_val(const_name) if @serialized_val.equal?(UNSET)
+    freeze
+  end
+
+  sig {params(const_name: Symbol).returns(String)}
+  private def const_to_serialized_val(const_name)
+    # Historical note: We convert to lowercase names because the majority of existing calls to
+    # `make_accessible` were arrays of lowercase strings. Doing this conversion allowed for the
+    # least amount of repetition in migrated declarations.
+    -const_name.to_s.downcase.freeze
+  end
+
+  sig {returns(T::Boolean)}
+  def self.started_initializing?
+    unless defined?(@started_initializing)
+      @started_initializing = T.let(false, T.nilable(T::Boolean))
+    end
+    T.must(@started_initializing)
+  end
+
+  sig {returns(T::Boolean)}
+  def self.fully_initialized?
+    unless defined?(@fully_initialized)
+      @fully_initialized = T.let(false, T.nilable(T::Boolean))
+    end
+    T.must(@fully_initialized)
+  end
+
+  # Maintains the order in which values are defined
+  sig {params(instance: T.untyped).void}
+  def self._register_instance(instance)
+    @values ||= []
+    @values << T.cast(instance, T.attached_class)
+  end
+
+  # Entrypoint for allowing people to register new enum values.
+  # All enum values must be defined within this block.
+  sig {params(blk: T.proc.void).void}
+  def self.enums(&blk)
+    raise "enums cannot be defined for T::Enum" if self == T::Enum
+    raise "Enum #{self} was already initialized" if fully_initialized?
+    raise "Enum #{self} is still initializing" if started_initializing?
+
+    @started_initializing = true
+
+    @values = T.let(nil, T.nilable(T::Array[T.attached_class]))
+
+    yield
+
+    @mapping = T.let(nil, T.nilable(T::Hash[SerializedVal, T.attached_class]))
+    @mapping = {}
+
+    # Freeze the Enum class and bind the constant names into each of the instances.
+    self.constants(false).each do |const_name|
+      instance = self.const_get(const_name, false)
+      if !instance.is_a?(self)
+        raise "Invalid constant #{self}::#{const_name} on enum. " \
+          "All constants defined for an enum must be instances itself (e.g. `Foo = new`)."
+      end
+
+      instance._bind_name(const_name)
+      serialized = instance.serialize
+      if @mapping.include?(serialized)
+        raise "Enum values must have unique serializations. Value '#{serialized}' is repeated on #{self}."
+      end
+      @mapping[serialized] = instance
+    end
+    @values.freeze
+    @mapping.freeze
+
+    orphaned_instances = T.must(@values) - @mapping.values
+    if !orphaned_instances.empty?
+      raise "Enum values must be assigned to constants: #{orphaned_instances.map {|v| v.instance_variable_get('@serialized_val')}}"
+    end
+
+    @fully_initialized = true
+  end
+
+  sig {params(child_class: T::Class[T.anything]).void}
+  def self.inherited(child_class)
+    super
+
+    raise "Inheriting from children of T::Enum is prohibited" if self != T::Enum
+
+    # "oj" gem JSON support
+    if Object.const_defined?(:Oj)
+      Object.const_get(:Oj).register_odd(child_class, child_class, :try_deserialize, :serialize)
+    end
+  end
+
+  # Marshal support
+  sig {params(_level: Integer).returns(String)}
+  def _dump(_level)
+    Marshal.dump(serialize)
+  end
+
+  sig {params(args: String).returns(T.attached_class)}
+  def self._load(args)
+    deserialize(Marshal.load(args)) # rubocop:disable Security/MarshalLoad
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/generic.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/generic.rb
similarity index 87%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/generic.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/generic.rb
index 58def7aa1adf8..11c073122ceb8 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/generic.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/generic.rb
@@ -19,4 +19,6 @@ def type_member(variance=:invariant, &blk)
   def type_template(variance=:invariant, &blk)
     T::Types::TypeTemplate.new(variance)
   end
+
+  def has_attached_class!(variance=:invariant, &blk); end
 end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/helpers.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/helpers.rb
new file mode 100644
index 0000000000000..e9b3675c34787
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/helpers.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+# typed: true
+
+# Use as a mixin with extend (`extend T::Helpers`).
+# Docs at https://sorbet.org/docs/
+module T::Helpers
+  extend T::Sig
+
+  Private = T::Private
+
+  ### Class/Module Helpers ###
+
+  def abstract!
+    if defined?(super)
+      # This is to play nicely with Rails' AbstractController::Base,
+      # which also defines an `abstract!` method.
+      # https://api.rubyonrails.org/classes/AbstractController/Base.html#method-c-abstract-21
+      super
+    end
+
+    Private::Abstract::Declare.declare_abstract(self, type: :abstract)
+  end
+
+  def interface!
+    Private::Abstract::Declare.declare_abstract(self, type: :interface)
+  end
+
+  def final!
+    Private::Final.declare(self)
+  end
+
+  def sealed!
+    Private::Sealed.declare(self, Kernel.caller(1..1)&.first&.split(':')&.first)
+  end
+
+  # Causes a mixin to also mix in class methods from the named module.
+  #
+  # Nearly equivalent to
+  #
+  #  def self.included(other)
+  #    other.extend(mod)
+  #  end
+  #
+  # Except that it is statically analyzed by sorbet.
+  def mixes_in_class_methods(mod, *mods)
+    Private::Mixins.declare_mixes_in_class_methods(self, [mod].concat(mods))
+  end
+
+  # Specify an inclusion or inheritance requirement for `self`.
+  #
+  # Example:
+  #
+  #   module MyHelper
+  #     extend T::Helpers
+  #
+  #     requires_ancestor { Kernel }
+  #   end
+  #
+  #   class MyClass < BasicObject # error: `MyClass` must include `Kernel` (required by `MyHelper`)
+  #     include MyHelper
+  #   end
+  #
+  # TODO: implement the checks in sorbet-runtime.
+  def requires_ancestor(&block); end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/non_forcing_constants.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/non_forcing_constants.rb
new file mode 100644
index 0000000000000..0459b92610c8d
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/non_forcing_constants.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::NonForcingConstants
+  # NOTE: This method is documented on the RBI in Sorbet's payload, so that it
+  # shows up in the hover/completion documentation via LSP.
+  T::Sig::WithoutRuntime.sig {params(val: BasicObject, klass: String).returns(T::Boolean)}
+  def self.non_forcing_is_a?(val, klass)
+    method_name = "T::NonForcingConstants.non_forcing_is_a?"
+    if klass.empty?
+      raise ArgumentError.new("The string given to `#{method_name}` must not be empty")
+    end
+
+    current_klass = T.let(nil, T.nilable(Module))
+    current_prefix = T.let(nil, T.nilable(String))
+
+    parts = klass.split('::')
+    parts.each do |part|
+      if current_klass.nil?
+        # First iteration
+        if part != ""
+          raise ArgumentError.new("The string given to `#{method_name}` must be an absolute constant reference that starts with `::`")
+        end
+
+        current_klass = Object
+        current_prefix = ''
+
+        # if this had a :: prefix, then there's no more loading to
+        # do---skip to the next one
+        next
+      end
+
+      if current_klass.autoload?(part)
+        # There's an autoload registered for that constant, which means it's not
+        # yet loaded. `value` can't be an instance of something not yet loaded.
+        return false
+      end
+
+      # Sorbet guarantees that the string is an absolutely resolved name.
+      search_inheritance_chain = false
+      if !current_klass.const_defined?(part, search_inheritance_chain)
+        return false
+      end
+
+      current_klass = current_klass.const_get(part)
+      current_prefix = "#{current_prefix}::#{part}"
+
+      if !Module.===(current_klass)
+        raise ArgumentError.new("#{current_prefix} is not a class or module")
+      end
+    end
+
+    current_klass.===(val)
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/abstract/data.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/abstract/data.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/abstract/data.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/abstract/data.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/abstract/declare.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/abstract/declare.rb
similarity index 75%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/abstract/declare.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/abstract/declare.rb
index ce8ddf9531d38..4ebee4a11f408 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/abstract/declare.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/abstract/declare.rb
@@ -18,7 +18,6 @@ def self.declare_abstract(mod, type:)
     Abstract::Data.set(mod, :abstract_type, type)
 
     mod.extend(Abstract::Hooks)
-    mod.extend(T::InterfaceWrapper::Helpers)
 
     if mod.is_a?(Class)
       if type == :interface
@@ -27,26 +26,27 @@ def self.declare_abstract(mod, type:)
         raise "Classes can't be interfaces. Use `abstract!` instead of `interface!`."
       end
 
-      if mod.instance_method(:initialize).owner == mod
-        raise "You must call `abstract!` *before* defining an initialize method"
+      if Object.instance_method(:method).bind_call(mod, :new).owner == mod
+        raise "You must call `abstract!` *before* defining a `new` method"
       end
 
       # Don't need to silence warnings via without_ruby_warnings when calling
       # define_method because of the guard above
 
-      mod.send(:define_method, :initialize) do |*args, &blk|
-        if self.class == mod
+      mod.send(:define_singleton_method, :new) do |*args, &blk|
+        result = super(*args, &blk)
+        if result.instance_of?(mod)
           raise "#{mod} is declared as abstract; it cannot be instantiated"
         end
-        super(*args, &blk)
+        result
       end
 
       # Ruby doesn not emit "method redefined" warnings for aliased methods
       # (more robust than undef_method that would create a small window in which the method doesn't exist)
-      mod.send(:alias_method, :initialize, :initialize)
+      mod.singleton_class.send(:alias_method, :new, :new)
 
-      if mod.respond_to?(:ruby2_keywords, true)
-        mod.send(:ruby2_keywords, :initialize)
+      if mod.singleton_class.respond_to?(:ruby2_keywords, true)
+        mod.singleton_class.send(:ruby2_keywords, :new)
       end
     end
   end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/abstract/hooks.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/abstract/hooks.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/abstract/hooks.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/abstract/hooks.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/abstract/validate.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/abstract/validate.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/abstract/validate.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/abstract/validate.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/caller_utils.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/caller_utils.rb
new file mode 100644
index 0000000000000..a84c3ab37d8fe
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/caller_utils.rb
@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Private::CallerUtils
+  if Thread.respond_to?(:each_caller_location) # RUBY_VERSION >= "3.2"
+    def self.find_caller
+      skipped_first = false
+      Thread.each_caller_location do |loc|
+        unless skipped_first
+          skipped_first = true
+          next
+        end
+
+        next if loc.path&.start_with?("<internal:")
+
+        return loc if yield(loc)
+      end
+      nil
+    end
+  else
+    def self.find_caller
+      caller_locations(2).find do |loc|
+        !loc.path&.start_with?("<internal:") && yield(loc)
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/casts.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/casts.rb
similarity index 81%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/casts.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/casts.rb
index f771090814770..f4530dc267d42 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/casts.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/casts.rb
@@ -3,9 +3,12 @@
 
 module T::Private
   module Casts
-    def self.cast(value, type, cast_method:)
+    def self.cast(value, type, cast_method)
       begin
-        error = T::Utils.coerce(type).error_message_for_obj(value)
+        coerced_type = T::Utils::Private.coerce_and_check_module_types(type, value, true)
+        return value unless coerced_type
+
+        error = coerced_type.error_message_for_obj(value)
         return value unless error
 
         caller_loc = T.must(caller_locations(2..2)).first
@@ -22,7 +25,7 @@ def self.cast(value, type, cast_method:)
     # there's a lot of shared logic with the above one, but factoring
     # it out like this makes it easier to hopefully one day delete
     # this one
-    def self.cast_recursive(value, type, cast_method:)
+    def self.cast_recursive(value, type, cast_method)
       begin
         error = T::Utils.coerce(type).error_message_for_obj_recursive(value)
         return value unless error
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/class_utils.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/class_utils.rb
new file mode 100644
index 0000000000000..dbe377301593d
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/class_utils.rb
@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+# typed: false
+
+# Cut down version of Chalk::Tools::ClassUtils with only :replace_method functionality.
+# Extracted to a separate namespace so the type system can be used standalone.
+module T::Private::ClassUtils
+  class ReplacedMethod
+    def initialize(mod, old_method, new_method, overwritten, visibility)
+      if old_method.name != new_method.name
+        raise "Method names must match. old=#{old_method.name} new=#{new_method.name}"
+      end
+      @mod = mod
+      @old_method = old_method
+      @new_method = new_method
+      @overwritten = overwritten
+      @name = old_method.name
+      @visibility = visibility
+      @restored = false
+    end
+
+    def restore
+      # The check below would also catch this, but this makes the failure mode much clearer
+      if @restored
+        raise "Method '#{@name}' on '#{@mod}' was already restored"
+      end
+
+      if @mod.instance_method(@name) != @new_method
+        raise "Trying to restore #{@mod}##{@name} but the method has changed since the call to replace_method"
+      end
+
+      @restored = true
+
+      if @overwritten
+        # The original method was overwritten. Overwrite again to restore it.
+        T::Configuration.without_ruby_warnings do
+          @mod.send(:define_method, @old_method.name, @old_method)
+        end
+      else
+        # The original method was in an ancestor. Restore it by removing the overriding method.
+        @mod.send(:remove_method, @old_method.name)
+      end
+
+      # Restore the visibility. Note that we need to do this even when we call remove_method
+      # above, because the module may have set custom visibility for a method it inherited.
+      @mod.send(@visibility, @old_method.name)
+
+      nil
+    end
+
+    def bind(obj)
+      @old_method.bind(obj)
+    end
+
+    def to_s
+      @old_method.to_s
+    end
+  end
+
+  # `name` must be an instance method (for class methods, pass in mod.singleton_class)
+  private_class_method def self.visibility_method_name(mod, name)
+    if mod.public_method_defined?(name)
+      :public
+    elsif mod.protected_method_defined?(name)
+      :protected
+    elsif mod.private_method_defined?(name)
+      :private
+    else
+      mod.method(name) # Raises
+    end
+  end
+
+  def self.def_with_visibility(mod, name, visibility, method=nil, &block)
+    mod.module_exec do
+      # Start a visibility (public/protected/private) region, so that
+      # all of the method redefinitions happen with the right visibility
+      # from the beginning. This ensures that any other code that is
+      # triggered by `method_added`, sees the redefined method with the
+      # right visibility.
+      send(visibility)
+
+      if method
+        define_method(name, method)
+      else
+        define_method(name, &block)
+      end
+
+      if block && block.arity < 0 && respond_to?(:ruby2_keywords, true)
+        ruby2_keywords(name)
+      end
+    end
+  end
+
+  # Replaces a method, either by overwriting it (if it is defined directly on `mod`) or by
+  # overriding it (if it is defined by one of mod's ancestors).  If `original_only` is
+  # false, returns a ReplacedMethod instance on which you can call `bind(...).call(...)`
+  # to call the original method, or `restore` to restore the original method (by
+  # overwriting or removing the override).
+  #
+  # If `original_only` is true, return the `UnboundMethod` representing the original method.
+  def self.replace_method(mod, name, original_only=false, &blk)
+    original_method = mod.instance_method(name)
+    original_visibility = visibility_method_name(mod, name)
+    original_owner = original_method.owner
+
+    mod.ancestors.each do |ancestor|
+      break if ancestor == mod
+      if ancestor == original_owner
+        # If we get here, that means the method we're trying to replace exists on a *prepended*
+        # mixin, which means in order to supersede it, we'd need to create a method on a new
+        # module that we'd prepend before `ancestor`. The problem with that approach is there'd
+        # be no way to remove that new module after prepending it, so we'd be left with these
+        # empty anonymous modules in the ancestor chain after calling `restore`.
+        #
+        # That's not necessarily a deal breaker, but for now, we're keeping it as unsupported.
+        raise "You're trying to replace `#{name}` on `#{mod}`, but that method exists in a " \
+              "prepended module (#{ancestor}), which we don't currently support."
+      end
+    end
+
+    overwritten = original_owner == mod
+    T::Configuration.without_ruby_warnings do
+      T::Private::DeclState.current.without_on_method_added do
+        def_with_visibility(mod, name, original_visibility, &blk)
+      end
+    end
+
+    if original_only
+      original_method
+    else
+      new_method = mod.instance_method(name)
+      ReplacedMethod.new(mod, original_method, new_method, overwritten, original_visibility)
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/decl_state.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/decl_state.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/decl_state.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/decl_state.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/final.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/final.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/final.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/final.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/_methods.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/_methods.rb
similarity index 86%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/_methods.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/_methods.rb
index 1720892a953fe..4a8b689eb3d77 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/_methods.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/_methods.rb
@@ -3,12 +3,17 @@
 
 module T::Private::Methods
   @installed_hooks = {}
-  @signatures_by_method = {}
-  @sig_wrappers = {}
+  if defined?(Concurrent::Hash)
+    @signatures_by_method = Concurrent::Hash.new
+    @sig_wrappers = Concurrent::Hash.new
+  else
+    @signatures_by_method = {}
+    @sig_wrappers = {}
+  end
   @sigs_that_raised = {}
   # stores method names that were declared final without regard for where.
   # enables early rejection of names that we know can't induce final method violations.
-  @was_ever_final_names = {}
+  @was_ever_final_names = {}.compare_by_identity
   # maps from a module's object_id to the set of final methods declared in that module.
   # we also overload entries slightly: if the value is nil, that means that the
   # module has final methods somewhere along its ancestor chain, but does not itself
@@ -20,7 +25,7 @@ module T::Private::Methods
   # twice is permitted).  we could do this with two tables, but it seems slightly
   # cleaner with a single table.
   # Effectively T::Hash[Module, T.nilable(Set))]
-  @modules_with_final = Hash.new {|hash, key| hash[key] = nil}
+  @modules_with_final = Hash.new {|hash, key| hash[key] = nil}.compare_by_identity
   # this stores the old [included, extended] hooks for Module and inherited hook for Class that we override when
   # enabling final checks for when those hooks are called. the 'hooks' here don't have anything to do with the 'hooks'
   # in installed_hooks.
@@ -83,7 +88,7 @@ def self.finalize_proc(decl)
       raise "Procs cannot have override/abstract modifiers"
     end
     if decl.mod != PROC_TYPE
-      raise "You are passing a DeclBuilder as a type. Did you accidentally use `self` inside a `sig` block?"
+      raise "You are passing a DeclBuilder as a type. Did you accidentally use `self` inside a `sig` block? Perhaps you wanted the `T.self_type` instead: https://sorbet.org/docs/self-type"
     end
     if decl.returns == ARG_NOT_PROVIDED
       raise "Procs must specify a return type"
@@ -117,6 +122,11 @@ def self.signature_for_method(method)
     @signatures_by_method[key]
   end
 
+  # Fetch the directory name of the file that defines the `T::Private` constant and
+  # add a trailing slash to allow us to match it as a directory prefix.
+  SORBET_RUNTIME_LIB_PATH = File.dirname(T.const_source_location(:Private).first) + File::SEPARATOR
+  private_constant :SORBET_RUNTIME_LIB_PATH
+
   # when target includes a module with instance methods source_method_names, ensure there is zero intersection between
   # the final instance methods of target and source_method_names. so, for every m in source_method_names, check if there
   # is already a method defined on one of target_ancestors with the same name that is final.
@@ -127,7 +137,7 @@ def self._check_final_ancestors(target, target_ancestors, source_method_names, s
     source_ancestors = nil
     # use reverse_each to check farther-up ancestors first, for better error messages.
     target_ancestors.reverse_each do |ancestor|
-      final_methods = @modules_with_final.fetch(ancestor.object_id, nil)
+      final_methods = @modules_with_final.fetch(ancestor, nil)
       # In this case, either ancestor didn't have any final methods anywhere in its
       # ancestor chain, or ancestor did have final methods somewhere in its ancestor
       # chain, but no final methods defined in ancestor itself.  Either way, there
@@ -145,20 +155,20 @@ def self._check_final_ancestors(target, target_ancestors, source_method_names, s
             # filter out things without actual final methods just to make sure that
             # the below checks (which should be uncommon) go as quickly as possible.
             source_ancestors.select! do |a|
-              @modules_with_final.fetch(a.object_id, nil)
+              @modules_with_final.fetch(a, nil)
             end
           end
           # final-ness means that there should be no more than one index for which
           # the below block returns true.
           defining_ancestor_idx = source_ancestors.index do |a|
-            @modules_with_final.fetch(a.object_id).include?(method_name)
+            @modules_with_final.fetch(a).include?(method_name)
           end
           next if defining_ancestor_idx && source_ancestors[defining_ancestor_idx] == ancestor
         end
 
         definition_file, definition_line = T::Private::Methods.signature_for_method(ancestor.instance_method(method_name)).method.source_location
         is_redefined = target == ancestor
-        caller_loc = caller_locations&.find {|l| !l.to_s.match?(%r{sorbet-runtime[^/]*/lib/})}
+        caller_loc = T::Private::CallerUtils.find_caller {|loc| !loc.path.to_s.start_with?(SORBET_RUNTIME_LIB_PATH)}
         extra_info = "\n"
         if caller_loc
           extra_info = (is_redefined ? "Redefined" : "Overridden") + " here: #{caller_loc.path}:#{caller_loc.lineno}\n"
@@ -186,13 +196,11 @@ def self._check_final_ancestors(target, target_ancestors, source_method_names, s
     end
   end
 
-  def self.add_module_with_final_method(mod, method_name, is_singleton_method)
-    m = is_singleton_method ? mod.singleton_class : mod
-    mid = m.object_id
-    methods = @modules_with_final[mid]
+  def self.add_module_with_final_method(mod, method_name)
+    methods = @modules_with_final[mod]
     if methods.nil?
       methods = {}
-      @modules_with_final[mid] = methods
+      @modules_with_final[mod] = methods
     end
     methods[method_name] = true
     nil
@@ -200,24 +208,23 @@ def self.add_module_with_final_method(mod, method_name, is_singleton_method)
 
   def self.note_module_deals_with_final(mod)
     # Side-effectfully initialize the value if it's not already there
-    @modules_with_final[mod.object_id]
-    @modules_with_final[mod.singleton_class.object_id]
+    @modules_with_final[mod]
+    @modules_with_final[mod.singleton_class]
   end
 
   # Only public because it needs to get called below inside the replace_method blocks below.
-  def self._on_method_added(hook_mod, method_name, is_singleton_method: false)
+  def self._on_method_added(hook_mod, mod, method_name)
     if T::Private::DeclState.current.skip_on_method_added
       return
     end
 
     current_declaration = T::Private::DeclState.current.active_declaration
-    mod = is_singleton_method ? hook_mod.singleton_class : hook_mod
 
     if T::Private::Final.final_module?(mod) && (current_declaration.nil? || !current_declaration.final)
       raise "#{mod} was declared as final but its method `#{method_name}` was not declared as final"
     end
     # Don't compute mod.ancestors if we don't need to bother checking final-ness.
-    if @was_ever_final_names.include?(method_name) && @modules_with_final.include?(mod.object_id)
+    if @was_ever_final_names.include?(method_name) && @modules_with_final.include?(mod)
       _check_final_ancestors(mod, mod.ancestors, [method_name], nil)
       # We need to fetch the active declaration again, as _check_final_ancestors
       # may have reset it (see the comment in that method for details).
@@ -247,7 +254,7 @@ def self._on_method_added(hook_mod, method_name, is_singleton_method: false)
     # (or unwrap back to the original method).
     key = method_owner_and_name_to_key(mod, method_name)
     unless current_declaration.raw
-      T::Private::ClassUtils.replace_method(mod, method_name) do |*args, &blk|
+      T::Private::ClassUtils.replace_method(mod, method_name, true) do |*args, &blk|
         method_sig = T::Private::Methods.maybe_run_sig_block_for_key(key)
         method_sig ||= T::Private::Methods._handle_missing_method_signature(
           self,
@@ -271,7 +278,7 @@ def self._on_method_added(hook_mod, method_name, is_singleton_method: false)
         elsif T::Configuration::AT_LEAST_RUBY_2_7
           original_method.bind_call(self, *args, &blk)
         else
-          original_method.bind(self).call(*args, &blk)
+          original_method.bind(self).call(*args, &blk) # rubocop:disable Performance/BindCall
         end
       end
     end
@@ -282,7 +289,7 @@ def self._on_method_added(hook_mod, method_name, is_singleton_method: false)
       # use hook_mod, not mod, because for example, we want class C to be marked as having final if we def C.foo as
       # final. change this to mod to see some final_method tests fail.
       note_module_deals_with_final(hook_mod)
-      add_module_with_final_method(hook_mod, method_name, is_singleton_method)
+      add_module_with_final_method(mod, method_name)
     end
   end
 
@@ -334,9 +341,11 @@ def self.run_sig(hook_mod, method_name, original_method, declaration_block)
         nil
       end
 
+    declaration_block.loc = nil
+
     signature =
       if current_declaration
-        build_sig(hook_mod, method_name, original_method, current_declaration, declaration_block.loc)
+        build_sig(hook_mod, method_name, original_method, current_declaration)
       else
         Signature.new_untyped(method: original_method)
       end
@@ -353,7 +362,7 @@ def self.run_builder(declaration_block)
       .decl
   end
 
-  def self.build_sig(hook_mod, method_name, original_method, current_declaration, loc)
+  def self.build_sig(hook_mod, method_name, original_method, current_declaration)
     begin
       # We allow `sig` in the current module's context (normal case) and
       if hook_mod != current_declaration.mod &&
@@ -424,7 +433,7 @@ def self.run_sig_block_for_method(method)
     run_sig_block_for_key(method_to_key(method))
   end
 
-  private_class_method def self.run_sig_block_for_key(key)
+  private_class_method def self.run_sig_block_for_key(key, force_type_init: false)
     blk = @sig_wrappers[key]
     if !blk
       sig = @signatures_by_method[key]
@@ -447,14 +456,17 @@ def self.run_sig_block_for_method(method)
     end
 
     @sig_wrappers.delete(key)
+
+    sig.force_type_init if force_type_init
+
     sig
   end
 
-  def self.run_all_sig_blocks
+  def self.run_all_sig_blocks(force_type_init: true)
     loop do
       break if @sig_wrappers.empty?
       key, = @sig_wrappers.first
-      run_sig_block_for_key(key)
+      run_sig_block_for_key(key, force_type_init: force_type_init)
     end
   end
 
@@ -467,8 +479,8 @@ def self.all_checked_tests_sigs
   def self._hook_impl(target, singleton_class, source)
     # we do not need to call add_was_ever_final here, because we have already marked
     # any such methods when source was originally defined.
-    if !@modules_with_final.include?(target.object_id)
-      if !@modules_with_final.include?(source.object_id)
+    if !@modules_with_final.include?(target)
+      if !@modules_with_final.include?(source)
         return
       end
       note_module_deals_with_final(target)
@@ -494,19 +506,37 @@ def self.set_final_checks_on_hooks(enable)
       return
     end
     if is_enabled
-      @old_hooks.each(&:restore)
+      # A cut-down version of T::Private::ClassUtils::ReplacedMethod#restore, because we
+      # should only be resetting final hooks during tests.
+      T::Configuration.without_ruby_warnings do
+        Module.define_method(:included, @old_hooks[0])
+        Module.define_method(:extended, @old_hooks[1])
+        Class.define_method(:inherited, @old_hooks[2])
+      end
       @old_hooks = nil
     else
-      old_included = T::Private::ClassUtils.replace_method(Module, :included) do |arg|
-        old_included.bind(self).call(arg)
+      old_included = T::Private::ClassUtils.replace_method(Module, :included, true) do |arg|
+        if T::Configuration::AT_LEAST_RUBY_2_7
+          old_included.bind_call(self, arg)
+        else
+          old_included.bind(self).call(arg) # rubocop:disable Performance/BindCall
+        end
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
-      old_extended = T::Private::ClassUtils.replace_method(Module, :extended) do |arg|
-        old_extended.bind(self).call(arg)
+      old_extended = T::Private::ClassUtils.replace_method(Module, :extended, true) do |arg|
+        if T::Configuration::AT_LEAST_RUBY_2_7
+          old_extended.bind_call(self, arg)
+        else
+          old_extended.bind(self).call(arg) # rubocop:disable Performance/BindCall
+        end
         ::T::Private::Methods._hook_impl(arg, true, self)
       end
-      old_inherited = T::Private::ClassUtils.replace_method(Class, :inherited) do |arg|
-        old_inherited.bind(self).call(arg)
+      old_inherited = T::Private::ClassUtils.replace_method(Class, :inherited, true) do |arg|
+        if T::Configuration::AT_LEAST_RUBY_2_7
+          old_inherited.bind_call(self, arg)
+        else
+          old_inherited.bind(self).call(arg) # rubocop:disable Performance/BindCall
+        end
         ::T::Private::Methods._hook_impl(arg, false, self)
       end
       @old_hooks = [old_included, old_extended, old_inherited]
@@ -516,14 +546,14 @@ def self.set_final_checks_on_hooks(enable)
   module MethodHooks
     def method_added(name)
       super(name)
-      ::T::Private::Methods._on_method_added(self, name, is_singleton_method: false)
+      ::T::Private::Methods._on_method_added(self, self, name)
     end
   end
 
   module SingletonMethodHooks
     def singleton_method_added(name)
       super(name)
-      ::T::Private::Methods._on_method_added(self, name, is_singleton_method: true)
+      ::T::Private::Methods._on_method_added(self, singleton_class, name)
     end
   end
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/call_validation.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/call_validation.rb
new file mode 100644
index 0000000000000..b26e8710c1d1a
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/call_validation.rb
@@ -0,0 +1,348 @@
+# frozen_string_literal: true
+# typed: false
+
+module T::Private::Methods::CallValidation
+  CallValidation = T::Private::Methods::CallValidation
+  Modes = T::Private::Methods::Modes
+
+  # Wraps a method with a layer of validation for the given type signature.
+  # This wrapper is meant to be fast, and is applied by a previous wrapper,
+  # which was placed by `_on_method_added`.
+  #
+  # @param method_sig [T::Private::Methods::Signature]
+  # @return [UnboundMethod] the new wrapper method (or the original one if we didn't wrap it)
+  def self.wrap_method_if_needed(mod, method_sig, original_method)
+    original_visibility = visibility_method_name(mod, method_sig.method_name)
+    if method_sig.mode == T::Private::Methods::Modes.abstract
+      create_abstract_wrapper(mod, method_sig, original_method, original_visibility)
+    # Do nothing in this case; this method was not wrapped in _on_method_added.
+    elsif method_sig.defined_raw
+    # Note, this logic is duplicated (intentionally, for micro-perf) at `Methods._on_method_added`,
+    # make sure to keep changes in sync.
+    # This is a trapdoor point for each method:
+    # if a given method is wrapped, it stays wrapped; and if not, it's never wrapped.
+    # (Therefore, we need the `@wrapped_tests_with_validation` check in `T::RuntimeLevels`.)
+    elsif method_sig.check_level == :always || (method_sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
+      create_validator_method(mod, original_method, method_sig, original_visibility)
+    else
+      T::Configuration.without_ruby_warnings do
+        # get all the shims out of the way and put back the original method
+        T::Private::DeclState.current.without_on_method_added do
+          T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility, original_method)
+        end
+      end
+    end
+    # Return the newly created method (or the original one if we didn't replace it)
+    mod.instance_method(method_sig.method_name)
+  end
+
+  @is_allowed_to_have_fast_path = true
+  def self.is_allowed_to_have_fast_path
+    @is_allowed_to_have_fast_path
+  end
+
+  def self.disable_fast_path
+    @is_allowed_to_have_fast_path = false
+  end
+
+  def self.create_abstract_wrapper(mod, method_sig, original_method, original_visibility)
+    mod.module_eval(<<~METHOD, __FILE__, __LINE__ + 1)
+      #{original_visibility}
+
+      def #{method_sig.method_name}(...)
+        # We allow abstract methods to be implemented by things further down the ancestor chain.
+        # So, if a super method exists, call it.
+        if defined?(super)
+          super
+        else
+          raise NotImplementedError.new(
+            "The method `#{method_sig.method_name}` on #{mod} is declared as `abstract`. It does not have an implementation."
+          )
+        end
+      end
+    METHOD
+  end
+
+  def self.create_validator_method(mod, original_method, method_sig, original_visibility)
+    has_fixed_arity = method_sig.kwarg_types.empty? && !method_sig.has_rest && !method_sig.has_keyrest &&
+      original_method.parameters.all? {|(kind, _name)| kind == :req || kind == :block}
+    can_skip_block_type = method_sig.block_type.nil? || method_sig.block_type.valid?(nil)
+    ok_for_fast_path = has_fixed_arity && can_skip_block_type && !method_sig.bind && method_sig.arg_types.length < 5 && is_allowed_to_have_fast_path
+
+    all_args_are_simple = ok_for_fast_path && method_sig.arg_types.all? {|_name, type| type.is_a?(T::Types::Simple)}
+    simple_method = all_args_are_simple && method_sig.return_type.is_a?(T::Types::Simple)
+    simple_procedure = all_args_are_simple && method_sig.return_type.is_a?(T::Private::Types::Void)
+
+    # All the types for which valid? unconditionally returns `true`
+    return_is_ignorable =
+      (method_sig.return_type.equal?(T::Types::Untyped::Private::INSTANCE) ||
+       method_sig.return_type.equal?(T::Types::Anything::Private::INSTANCE) ||
+       method_sig.return_type.equal?(T::Types::AttachedClassType::Private::INSTANCE) ||
+       method_sig.return_type.equal?(T::Types::SelfType::Private::INSTANCE) ||
+       method_sig.return_type.is_a?(T::Types::TypeParameter) ||
+       method_sig.return_type.is_a?(T::Types::TypeVariable) ||
+       (method_sig.return_type.is_a?(T::Types::Simple) && method_sig.return_type.raw_type.equal?(BasicObject)))
+
+    returns_anything_method = all_args_are_simple && return_is_ignorable
+
+    T::Configuration.without_ruby_warnings do
+      T::Private::DeclState.current.without_on_method_added do
+        if simple_method
+          create_validator_method_fast(mod, original_method, method_sig, original_visibility)
+        elsif returns_anything_method
+          create_validator_method_skip_return_fast(mod, original_method, method_sig, original_visibility)
+        elsif simple_procedure
+          create_validator_procedure_fast(mod, original_method, method_sig, original_visibility)
+        elsif ok_for_fast_path && method_sig.return_type.is_a?(T::Private::Types::Void)
+          create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
+        elsif ok_for_fast_path && return_is_ignorable
+          create_validator_method_skip_return_medium(mod, original_method, method_sig, original_visibility)
+        elsif ok_for_fast_path
+          create_validator_method_medium(mod, original_method, method_sig, original_visibility)
+        elsif can_skip_block_type
+          # The Ruby VM already validates that any block passed to a method
+          # must be either `nil` or a `Proc` object, so there's no need to also
+          # have sorbet-runtime check that.
+          create_validator_slow_skip_block_type(mod, original_method, method_sig, original_visibility)
+        else
+          create_validator_slow(mod, original_method, method_sig, original_visibility)
+        end
+      end
+      mod.send(original_visibility, method_sig.method_name)
+    end
+  end
+
+  def self.create_validator_slow_skip_block_type(mod, original_method, method_sig, original_visibility)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
+      CallValidation.validate_call_skip_block_type(self, original_method, method_sig, args, blk)
+    end
+  end
+
+  def self.validate_call_skip_block_type(instance, original_method, method_sig, args, blk)
+    # This method is called for every `sig`. It's critical to keep it fast and
+    # reduce number of allocations that happen here.
+
+    if method_sig.bind
+      message = method_sig.bind.error_message_for_obj(instance)
+      if message
+        CallValidation.report_error(
+          method_sig,
+          message,
+          'Bind',
+          nil,
+          method_sig.bind,
+          instance
+        )
+      end
+    end
+
+    # NOTE: We don't bother validating for missing or extra kwargs;
+    # the method call itself will take care of that.
+    method_sig.each_args_value_type(args) do |name, arg, type|
+      message = type.error_message_for_obj(arg)
+      if message
+        CallValidation.report_error(
+          method_sig,
+          message,
+          'Parameter',
+          name,
+          type,
+          arg,
+          caller_offset: 2
+        )
+      end
+    end
+
+    # The original method definition allows passing `nil` for the `&blk`
+    # argument, so we do not have to do any method_sig.block_type type checks
+    # of our own.
+
+    # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+    # PRY note:
+    # this code is sig validation code.
+    # Please issue `finish` to step out of it
+
+    return_value = T::Configuration::AT_LEAST_RUBY_2_7 ? original_method.bind_call(instance, *args, &blk) : original_method.bind(instance).call(*args, &blk)
+
+    # The only type that is allowed to change the return value is `.void`.
+    # It ignores what you returned and changes it to be a private singleton.
+    if method_sig.return_type.is_a?(T::Private::Types::Void)
+      T::Private::Types::Void::VOID
+    else
+      message = method_sig.return_type.error_message_for_obj(return_value)
+      if message
+        CallValidation.report_error(
+          method_sig,
+          message,
+          'Return value',
+          nil,
+          method_sig.return_type,
+          return_value,
+        )
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_slow(mod, original_method, method_sig, original_visibility)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |*args, &blk|
+      CallValidation.validate_call(self, original_method, method_sig, args, blk)
+    end
+  end
+
+  def self.validate_call(instance, original_method, method_sig, args, blk)
+    # This method is called for every `sig`. It's critical to keep it fast and
+    # reduce number of allocations that happen here.
+
+    if method_sig.bind
+      message = method_sig.bind.error_message_for_obj(instance)
+      if message
+        CallValidation.report_error(
+          method_sig,
+          message,
+          'Bind',
+          nil,
+          method_sig.bind,
+          instance
+        )
+      end
+    end
+
+    # NOTE: We don't bother validating for missing or extra kwargs;
+    # the method call itself will take care of that.
+    method_sig.each_args_value_type(args) do |name, arg, type|
+      message = type.error_message_for_obj(arg)
+      if message
+        CallValidation.report_error(
+          method_sig,
+          message,
+          'Parameter',
+          name,
+          type,
+          arg,
+          caller_offset: 2
+        )
+      end
+    end
+
+    # The Ruby VM already checks that `&blk` is either a `Proc` type or `nil`:
+    # https://github.com/ruby/ruby/blob/v2_7_6/vm_args.c#L1150-L1154
+    # And `T.proc` types don't (can't) do any runtime arg checking, so we can
+    # save work by simply checking that `blk` is non-nil (if the method allows
+    # `nil` for the block, it would not have used this validate_call path).
+    unless blk
+      # Have to use `&.` here, because it's technically a public API that
+      # people can _always_ call `validate_call` to validate any signature
+      # (i.e., the faster validators are merely optimizations).
+      # In practice, this only affects the first call to the method (before the
+      # optimized validators have a chance to replace the initial, slow
+      # wrapper).
+      message = method_sig.block_type&.error_message_for_obj(blk)
+      if message
+        CallValidation.report_error(
+          method_sig,
+          message,
+          'Block parameter',
+          method_sig.block_name,
+          method_sig.block_type,
+          blk
+        )
+      end
+    end
+
+    # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+    # PRY note:
+    # this code is sig validation code.
+    # Please issue `finish` to step out of it
+
+    return_value = T::Configuration::AT_LEAST_RUBY_2_7 ? original_method.bind_call(instance, *args, &blk) : original_method.bind(instance).call(*args, &blk)
+
+    # The only type that is allowed to change the return value is `.void`.
+    # It ignores what you returned and changes it to be a private singleton.
+    if method_sig.return_type.is_a?(T::Private::Types::Void)
+      T::Private::Types::Void::VOID
+    else
+      message = method_sig.return_type.error_message_for_obj(return_value)
+      if message
+        CallValidation.report_error(
+          method_sig,
+          message,
+          'Return value',
+          nil,
+          method_sig.return_type,
+          return_value,
+        )
+      end
+      return_value
+    end
+  end
+
+  def self.report_error(method_sig, error_message, kind, name, type, value, caller_offset: 0)
+    caller_loc = T.must(caller_locations(3 + caller_offset, 1))[0]
+    method = method_sig.method
+    definition_file, definition_line = method.source_location
+
+    owner = method.owner
+    pretty_method_name =
+      if owner.singleton_class? && owner.respond_to?(:attached_object)
+        # attached_object is new in Ruby 3.2
+        "#{owner.attached_object}.#{method.name}"
+      else
+        "#{owner}##{method.name}"
+      end
+
+    pretty_message = "#{kind}#{name ? " '#{name}'" : ''}: #{error_message}\n" \
+      "Caller: #{caller_loc.path}:#{caller_loc.lineno}\n" \
+      "Definition: #{definition_file}:#{definition_line} (#{pretty_method_name})"
+
+    T::Configuration.call_validation_error_handler(
+      method_sig,
+      message: error_message,
+      pretty_message: pretty_message,
+      kind: kind,
+      name: name,
+      type: type,
+      value: value,
+      location: caller_loc
+    )
+  end
+
+  # `name` must be an instance method (for class methods, pass in mod.singleton_class)
+  private_class_method def self.visibility_method_name(mod, name)
+    if mod.public_method_defined?(name)
+      :public
+    elsif mod.protected_method_defined?(name)
+      :protected
+    elsif mod.private_method_defined?(name)
+      :private
+    else
+      mod.method(name) # Raises
+    end
+  end
+end
+
+if T::Configuration::AT_LEAST_RUBY_2_7
+  require_relative './call_validation_2_7'
+else
+  require_relative './call_validation_2_6'
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/call_validation_2_6.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/call_validation_2_6.rb
new file mode 100644
index 0000000000000..26f810515e366
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/call_validation_2_6.rb
@@ -0,0 +1,1729 @@
+# frozen_string_literal: true
+# typed: false
+
+# DO NOT EDIT. This file is autogenerated. To regenerate, run:
+#
+#     bazel test //gems/sorbet-runtime:update_call_validation
+
+module T::Private::Methods::CallValidation
+  def self.create_validator_method_fast(mod, original_method, method_sig, original_visibility)
+    if method_sig.return_type.is_a?(T::Private::Types::Void)
+      raise 'Should have used create_validator_procedure_fast'
+    end
+    # trampoline to reduce stack frame size
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
+      create_validator_method_fast0(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type)
+    when 1
+      create_validator_method_fast1(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
+                                    arg_types[0][1].raw_type)
+    when 2
+      create_validator_method_fast2(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type)
+    when 3
+      create_validator_method_fast3(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type)
+    when 4
+      create_validator_method_fast4(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type,
+                                    arg_types[3][1].raw_type)
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_method_fast0(mod, original_method, method_sig, original_visibility, return_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(&blk)
+      unless return_value.is_a?(return_type)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_fast1(mod, original_method, method_sig, original_visibility, return_type, arg0_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(arg0, &blk)
+      unless return_value.is_a?(return_type)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_fast2(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(arg0, arg1, &blk)
+      unless return_value.is_a?(return_type)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_fast3(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2.is_a?(arg2_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(arg0, arg1, arg2, &blk)
+      unless return_value.is_a?(return_type)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_fast4(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2.is_a?(arg2_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      unless arg3.is_a?(arg3_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
+      unless return_value.is_a?(return_type)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_skip_return_fast(mod, original_method, method_sig, original_visibility)
+    # trampoline to reduce stack frame size
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
+      create_validator_method_skip_return_fast0(mod, original_method, method_sig, original_visibility)
+    when 1
+      create_validator_method_skip_return_fast1(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type)
+    when 2
+      create_validator_method_skip_return_fast2(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type)
+    when 3
+      create_validator_method_skip_return_fast3(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type)
+    when 4
+      create_validator_method_skip_return_fast4(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type,
+                                    arg_types[3][1].raw_type)
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_method_skip_return_fast0(mod, original_method, method_sig, original_visibility)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(&blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_fast1(mod, original_method, method_sig, original_visibility, arg0_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, &blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_fast2(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, &blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_fast3(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2.is_a?(arg2_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, arg2, &blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_fast4(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2.is_a?(arg2_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      unless arg3.is_a?(arg3_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
+    end
+  end
+
+  def self.create_validator_procedure_fast(mod, original_method, method_sig, original_visibility)
+    # trampoline to reduce stack frame size
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
+      create_validator_procedure_fast0(mod, original_method, method_sig, original_visibility)
+    when 1
+      create_validator_procedure_fast1(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type)
+    when 2
+      create_validator_procedure_fast2(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type)
+    when 3
+      create_validator_procedure_fast3(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type)
+    when 4
+      create_validator_procedure_fast4(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type,
+                                    arg_types[3][1].raw_type)
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_procedure_fast0(mod, original_method, method_sig, original_visibility)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(&blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_fast1(mod, original_method, method_sig, original_visibility, arg0_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_fast2(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_fast3(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2.is_a?(arg2_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, arg2, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_fast4(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2.is_a?(arg2_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      unless arg3.is_a?(arg3_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_method_medium(mod, original_method, method_sig, original_visibility)
+    if method_sig.return_type.is_a?(T::Private::Types::Void)
+      raise 'Should have used create_validator_procedure_medium'
+    end
+    # trampoline to reduce stack frame size
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
+      create_validator_method_medium0(mod, original_method, method_sig, original_visibility, method_sig.return_type)
+    when 1
+      create_validator_method_medium1(mod, original_method, method_sig, original_visibility, method_sig.return_type,
+                                    arg_types[0][1])
+    when 2
+      create_validator_method_medium2(mod, original_method, method_sig, original_visibility, method_sig.return_type,
+                                    arg_types[0][1],
+                                    arg_types[1][1])
+    when 3
+      create_validator_method_medium3(mod, original_method, method_sig, original_visibility, method_sig.return_type,
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1])
+    when 4
+      create_validator_method_medium4(mod, original_method, method_sig, original_visibility, method_sig.return_type,
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1],
+                                    arg_types[3][1])
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_method_medium0(mod, original_method, method_sig, original_visibility, return_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(&blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_medium1(mod, original_method, method_sig, original_visibility, return_type, arg0_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(arg0, &blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_medium2(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(arg0, arg1, &blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_medium3(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(arg0, arg1, arg2, &blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_medium4(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      unless arg3_type.valid?(arg3)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_skip_return_medium(mod, original_method, method_sig, original_visibility)
+    # trampoline to reduce stack frame size
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
+      create_validator_method_skip_return_medium0(mod, original_method, method_sig, original_visibility)
+    when 1
+      create_validator_method_skip_return_medium1(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1])
+    when 2
+      create_validator_method_skip_return_medium2(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1],
+                                    arg_types[1][1])
+    when 3
+      create_validator_method_skip_return_medium3(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1])
+    when 4
+      create_validator_method_skip_return_medium4(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1],
+                                    arg_types[3][1])
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_method_skip_return_medium0(mod, original_method, method_sig, original_visibility)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(&blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_medium1(mod, original_method, method_sig, original_visibility, arg0_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, &blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_medium2(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, &blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_medium3(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, arg2, &blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_medium4(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      unless arg3_type.valid?(arg3)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
+    end
+  end
+
+  def self.create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
+    # trampoline to reduce stack frame size
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
+      create_validator_procedure_medium0(mod, original_method, method_sig, original_visibility)
+    when 1
+      create_validator_procedure_medium1(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1])
+    when 2
+      create_validator_procedure_medium2(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1],
+                                    arg_types[1][1])
+    when 3
+      create_validator_procedure_medium3(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1])
+    when 4
+      create_validator_procedure_medium4(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1],
+                                    arg_types[3][1])
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_procedure_medium0(mod, original_method, method_sig, original_visibility)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(&blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_medium1(mod, original_method, method_sig, original_visibility, arg0_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_medium2(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_medium3(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, arg2, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_medium4(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      unless arg3_type.valid?(arg3)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind(self).call(arg0, arg1, arg2, arg3, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/call_validation_2_7.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/call_validation_2_7.rb
new file mode 100644
index 0000000000000..4198467f2f711
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/call_validation_2_7.rb
@@ -0,0 +1,1729 @@
+# frozen_string_literal: true
+# typed: false
+
+# DO NOT EDIT. This file is autogenerated. To regenerate, run:
+#
+#     bazel test //gems/sorbet-runtime:update_call_validation
+
+module T::Private::Methods::CallValidation
+  def self.create_validator_method_fast(mod, original_method, method_sig, original_visibility)
+    if method_sig.return_type.is_a?(T::Private::Types::Void)
+      raise 'Should have used create_validator_procedure_fast'
+    end
+    # trampoline to reduce stack frame size
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
+      create_validator_method_fast0(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type)
+    when 1
+      create_validator_method_fast1(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
+                                    arg_types[0][1].raw_type)
+    when 2
+      create_validator_method_fast2(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type)
+    when 3
+      create_validator_method_fast3(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type)
+    when 4
+      create_validator_method_fast4(mod, original_method, method_sig, original_visibility, method_sig.return_type.raw_type,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type,
+                                    arg_types[3][1].raw_type)
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_method_fast0(mod, original_method, method_sig, original_visibility, return_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind_call(self, &blk)
+      unless return_value.is_a?(return_type)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_fast1(mod, original_method, method_sig, original_visibility, return_type, arg0_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind_call(self, arg0, &blk)
+      unless return_value.is_a?(return_type)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_fast2(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind_call(self, arg0, arg1, &blk)
+      unless return_value.is_a?(return_type)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_fast3(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2.is_a?(arg2_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind_call(self, arg0, arg1, arg2, &blk)
+      unless return_value.is_a?(return_type)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_fast4(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2.is_a?(arg2_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      unless arg3.is_a?(arg3_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind_call(self, arg0, arg1, arg2, arg3, &blk)
+      unless return_value.is_a?(return_type)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_skip_return_fast(mod, original_method, method_sig, original_visibility)
+    # trampoline to reduce stack frame size
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
+      create_validator_method_skip_return_fast0(mod, original_method, method_sig, original_visibility)
+    when 1
+      create_validator_method_skip_return_fast1(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type)
+    when 2
+      create_validator_method_skip_return_fast2(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type)
+    when 3
+      create_validator_method_skip_return_fast3(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type)
+    when 4
+      create_validator_method_skip_return_fast4(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type,
+                                    arg_types[3][1].raw_type)
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_method_skip_return_fast0(mod, original_method, method_sig, original_visibility)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, &blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_fast1(mod, original_method, method_sig, original_visibility, arg0_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, &blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_fast2(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, arg1, &blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_fast3(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2.is_a?(arg2_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, arg1, arg2, &blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_fast4(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2.is_a?(arg2_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      unless arg3.is_a?(arg3_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, arg1, arg2, arg3, &blk)
+    end
+  end
+
+  def self.create_validator_procedure_fast(mod, original_method, method_sig, original_visibility)
+    # trampoline to reduce stack frame size
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
+      create_validator_procedure_fast0(mod, original_method, method_sig, original_visibility)
+    when 1
+      create_validator_procedure_fast1(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type)
+    when 2
+      create_validator_procedure_fast2(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type)
+    when 3
+      create_validator_procedure_fast3(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type)
+    when 4
+      create_validator_procedure_fast4(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1].raw_type,
+                                    arg_types[1][1].raw_type,
+                                    arg_types[2][1].raw_type,
+                                    arg_types[3][1].raw_type)
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_procedure_fast0(mod, original_method, method_sig, original_visibility)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_fast1(mod, original_method, method_sig, original_visibility, arg0_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_fast2(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, arg1, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_fast3(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2.is_a?(arg2_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, arg1, arg2, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_fast4(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0.is_a?(arg0_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1.is_a?(arg1_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2.is_a?(arg2_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      unless arg3.is_a?(arg3_type)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, arg1, arg2, arg3, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_method_medium(mod, original_method, method_sig, original_visibility)
+    if method_sig.return_type.is_a?(T::Private::Types::Void)
+      raise 'Should have used create_validator_procedure_medium'
+    end
+    # trampoline to reduce stack frame size
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
+      create_validator_method_medium0(mod, original_method, method_sig, original_visibility, method_sig.return_type)
+    when 1
+      create_validator_method_medium1(mod, original_method, method_sig, original_visibility, method_sig.return_type,
+                                    arg_types[0][1])
+    when 2
+      create_validator_method_medium2(mod, original_method, method_sig, original_visibility, method_sig.return_type,
+                                    arg_types[0][1],
+                                    arg_types[1][1])
+    when 3
+      create_validator_method_medium3(mod, original_method, method_sig, original_visibility, method_sig.return_type,
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1])
+    when 4
+      create_validator_method_medium4(mod, original_method, method_sig, original_visibility, method_sig.return_type,
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1],
+                                    arg_types[3][1])
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_method_medium0(mod, original_method, method_sig, original_visibility, return_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind_call(self, &blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_medium1(mod, original_method, method_sig, original_visibility, return_type, arg0_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind_call(self, arg0, &blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_medium2(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind_call(self, arg0, arg1, &blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_medium3(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind_call(self, arg0, arg1, arg2, &blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_medium4(mod, original_method, method_sig, original_visibility, return_type, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      unless arg3_type.valid?(arg3)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      return_value = original_method.bind_call(self, arg0, arg1, arg2, arg3, &blk)
+      unless return_type.valid?(return_value)
+        message = method_sig.return_type.error_message_for_obj(return_value)
+        if message
+          CallValidation.report_error(
+            method_sig,
+            message,
+            'Return value',
+            nil,
+            method_sig.return_type,
+            return_value,
+            caller_offset: -1
+          )
+        end
+      end
+      return_value
+    end
+  end
+
+  def self.create_validator_method_skip_return_medium(mod, original_method, method_sig, original_visibility)
+    # trampoline to reduce stack frame size
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
+      create_validator_method_skip_return_medium0(mod, original_method, method_sig, original_visibility)
+    when 1
+      create_validator_method_skip_return_medium1(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1])
+    when 2
+      create_validator_method_skip_return_medium2(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1],
+                                    arg_types[1][1])
+    when 3
+      create_validator_method_skip_return_medium3(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1])
+    when 4
+      create_validator_method_skip_return_medium4(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1],
+                                    arg_types[3][1])
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_method_skip_return_medium0(mod, original_method, method_sig, original_visibility)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, &blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_medium1(mod, original_method, method_sig, original_visibility, arg0_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, &blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_medium2(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, arg1, &blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_medium3(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, arg1, arg2, &blk)
+    end
+  end
+
+  def self.create_validator_method_skip_return_medium4(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      unless arg3_type.valid?(arg3)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, arg1, arg2, arg3, &blk)
+    end
+  end
+
+  def self.create_validator_procedure_medium(mod, original_method, method_sig, original_visibility)
+    # trampoline to reduce stack frame size
+    arg_types = method_sig.arg_types
+    case arg_types.length
+    when 0
+      create_validator_procedure_medium0(mod, original_method, method_sig, original_visibility)
+    when 1
+      create_validator_procedure_medium1(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1])
+    when 2
+      create_validator_procedure_medium2(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1],
+                                    arg_types[1][1])
+    when 3
+      create_validator_procedure_medium3(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1])
+    when 4
+      create_validator_procedure_medium4(mod, original_method, method_sig, original_visibility,
+                                    arg_types[0][1],
+                                    arg_types[1][1],
+                                    arg_types[2][1],
+                                    arg_types[3][1])
+    else
+      raise 'should not happen'
+    end
+  end
+
+  def self.create_validator_procedure_medium0(mod, original_method, method_sig, original_visibility)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |&blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_medium1(mod, original_method, method_sig, original_visibility, arg0_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_medium2(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, arg1, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_medium3(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, arg1, arg2, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+  def self.create_validator_procedure_medium4(mod, original_method, method_sig, original_visibility, arg0_type, arg1_type, arg2_type, arg3_type)
+    T::Private::ClassUtils.def_with_visibility(mod, method_sig.method_name, original_visibility) do |arg0, arg1, arg2, arg3, &blk|
+      # This method is a manually sped-up version of more general code in `validate_call`
+      unless arg0_type.valid?(arg0)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[0][1].error_message_for_obj(arg0),
+          'Parameter',
+          method_sig.arg_types[0][0],
+          arg0_type,
+          arg0,
+          caller_offset: -1
+        )
+      end
+
+      unless arg1_type.valid?(arg1)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[1][1].error_message_for_obj(arg1),
+          'Parameter',
+          method_sig.arg_types[1][0],
+          arg1_type,
+          arg1,
+          caller_offset: -1
+        )
+      end
+
+      unless arg2_type.valid?(arg2)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[2][1].error_message_for_obj(arg2),
+          'Parameter',
+          method_sig.arg_types[2][0],
+          arg2_type,
+          arg2,
+          caller_offset: -1
+        )
+      end
+
+      unless arg3_type.valid?(arg3)
+        CallValidation.report_error(
+          method_sig,
+          method_sig.arg_types[3][1].error_message_for_obj(arg3),
+          'Parameter',
+          method_sig.arg_types[3][0],
+          arg3_type,
+          arg3,
+          caller_offset: -1
+        )
+      end
+
+      # The following line breaks are intentional to show nice pry message
+
+
+
+
+
+
+
+
+
+
+      # PRY note:
+      # this code is sig validation code.
+      # Please issue `finish` to step out of it
+
+      original_method.bind_call(self, arg0, arg1, arg2, arg3, &blk)
+      T::Private::Types::Void::VOID
+    end
+  end
+
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/decl_builder.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/decl_builder.rb
similarity index 83%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/decl_builder.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/decl_builder.rb
index b48b1d5b68f87..74a3ec6543149 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/decl_builder.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/decl_builder.rb
@@ -16,7 +16,6 @@ class BuilderError < StandardError; end
     end
 
     def initialize(mod, raw)
-      # TODO RUBYPLAT-1278 - with ruby 2.5, use kwargs here
       @decl = Declaration.new(
         mod,
         ARG_NOT_PROVIDED, # params
@@ -32,15 +31,29 @@ def initialize(mod, raw)
       )
     end
 
-    def params(**params)
+    def params(*unused_positional_params, **params)
       check_live!
       if !decl.params.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .params twice")
       end
 
+      if unused_positional_params.any?
+        some_or_only = params.any? ? "some" : "only"
+        raise BuilderError.new(<<~MSG)
+          'params' was called with #{some_or_only} positional arguments, but it needs to be called with keyword arguments.
+          The keyword arguments' keys must match the name and order of the method's parameters.
+        MSG
+      end
+
       if params.empty?
-        raise BuilderError.new("params expects keyword arguments")
+        raise BuilderError.new(<<~MSG)
+          'params' was called without any arguments, but it needs to be called with keyword arguments.
+          The keyword arguments' keys must match the name and order of the method's parameters.
+
+          Omit 'params' entirely for methods with no parameters.
+        MSG
       end
+
       decl.params = params
 
       self
@@ -66,7 +79,7 @@ def void
         raise BuilderError.new("You can't call .void after calling .returns.")
       end
 
-      decl.returns = T::Private::Types::Void.new
+      decl.returns = T::Private::Types::Void::Private::INSTANCE
 
       self
     end
@@ -88,7 +101,7 @@ def checked(level)
       if !decl.checked.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .checked multiple times in a signature.")
       end
-      if (level == :never || level == :compiled) && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+      if level == :never && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't use .checked(:#{level}) with .on_failure because .on_failure will have no effect.")
       end
       if !T::Private::RuntimeLevels::LEVELS.include?(level)
@@ -106,7 +119,7 @@ def on_failure(*args)
       if !decl.on_failure.equal?(ARG_NOT_PROVIDED)
         raise BuilderError.new("You can't call .on_failure multiple times in a signature.")
       end
-      if decl.checked == :never || decl.checked == :compiled
+      if decl.checked == :never
         raise BuilderError.new("You can't use .on_failure with .checked(:#{decl.checked}) because .on_failure will have no effect.")
       end
 
@@ -170,7 +183,7 @@ def overridable
       self
     end
 
-    # Declares valid type paramaters which can be used with `T.type_parameter` in
+    # Declares valid type parameters which can be used with `T.type_parameter` in
     # this `sig`.
     #
     # This is used for generic methods. Example usage:
@@ -209,7 +222,7 @@ def finalize!
       end
       if decl.checked.equal?(ARG_NOT_PROVIDED)
         default_checked_level = T::Private::RuntimeLevels.default_checked_level
-        if (default_checked_level == :never || default_checked_level == :compiled) && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
+        if default_checked_level == :never && !decl.on_failure.equal?(ARG_NOT_PROVIDED)
           raise BuilderError.new("To use .on_failure you must additionally call .checked(:tests) or .checked(:always), otherwise, the .on_failure has no effect.")
         end
         decl.checked = default_checked_level
@@ -218,15 +231,17 @@ def finalize!
         decl.on_failure = nil
       end
       if decl.params.equal?(ARG_NOT_PROVIDED)
-        decl.params = {}
+        decl.params = FROZEN_HASH
       end
       if decl.type_parameters.equal?(ARG_NOT_PROVIDED)
-        decl.type_parameters = {}
+        decl.type_parameters = FROZEN_HASH
       end
 
       decl.finalized = true
 
       self
     end
+
+    FROZEN_HASH = {}.freeze
   end
 end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/modes.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/modes.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/methods/modes.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/modes.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/signature.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/signature.rb
new file mode 100644
index 0000000000000..79772957a7464
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/signature.rb
@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+# typed: true
+
+class T::Private::Methods::Signature
+  attr_reader :method, :method_name, :arg_types, :kwarg_types, :block_type, :block_name,
+              :rest_type, :rest_name, :keyrest_type, :keyrest_name, :bind,
+              :return_type, :mode, :req_arg_count, :req_kwarg_names, :has_rest, :has_keyrest,
+              :check_level, :parameters, :on_failure, :override_allow_incompatible,
+              :defined_raw
+
+  UNNAMED_REQUIRED_PARAMETERS = [[:req]].freeze
+
+  def self.new_untyped(method:, mode: T::Private::Methods::Modes.untyped, parameters: method.parameters)
+    # Using `NotTyped` ensures we'll get an error if we ever try validation on these.
+    not_typed = T::Private::Types::NotTyped::INSTANCE
+    raw_return_type = not_typed
+    # Map missing parameter names to "argN" positionally
+    parameters = parameters.each_with_index.map do |(param_kind, param_name), index|
+      [param_kind, param_name || "arg#{index}"]
+    end
+    raw_arg_types = {}
+    parameters.each do |_, param_name|
+      raw_arg_types[param_name] = not_typed
+    end
+
+    self.new(
+      method: method,
+      method_name: method.name,
+      raw_arg_types: raw_arg_types,
+      raw_return_type: raw_return_type,
+      bind: nil,
+      mode: mode,
+      check_level: :never,
+      parameters: parameters,
+      on_failure: nil,
+    )
+  end
+
+  def initialize(method:, method_name:, raw_arg_types:, raw_return_type:, bind:, mode:, check_level:, on_failure:, parameters: method.parameters, override_allow_incompatible: false, defined_raw: false)
+    @method = method
+    @method_name = method_name
+    @block_type = nil
+    @block_name = nil
+    @rest_type = nil
+    @rest_name = nil
+    @keyrest_type = nil
+    @keyrest_name = nil
+    @return_type = T::Utils.coerce(raw_return_type)
+    @bind = bind ? T::Utils.coerce(bind) : bind
+    @mode = mode
+    @check_level = check_level
+    @has_rest = false
+    @has_keyrest = false
+    @parameters = parameters
+    @on_failure = on_failure
+    @override_allow_incompatible = override_allow_incompatible
+    @defined_raw = defined_raw
+
+    # Use T.untyped in lieu of T.nilable to try to avoid unnecessary allocations.
+    arg_types = T.let(nil, T.untyped)
+    kwarg_types = T.let(nil, T.untyped)
+    req_arg_count = 0
+    req_kwarg_names = T.let(nil, T.untyped)
+
+    # If sig params are declared but there is a single parameter with a missing name
+    # **and** the method ends with a "=", assume it is a writer method generated
+    # by attr_writer or attr_accessor
+    writer_method = !(raw_arg_types.size == 1 && raw_arg_types.key?(nil)) && parameters == UNNAMED_REQUIRED_PARAMETERS && method_name[-1] == "="
+    # For writer methods, map the single parameter to the method name without the "=" at the end
+    parameters = [[:req, method_name[0...-1].to_sym]] if writer_method
+    is_name_missing = parameters.any? {|_, name| !raw_arg_types.key?(name)}
+    if is_name_missing
+      param_names = parameters.map {|_, name| name}
+      missing_names = param_names - raw_arg_types.keys
+      raise "The declaration for `#{method.name}` is missing parameter(s): #{missing_names.join(', ')}"
+    elsif parameters.length != raw_arg_types.size
+      param_names = parameters.map {|_, name| name}
+      has_extra_names = parameters.count {|_, name| raw_arg_types.key?(name)} < raw_arg_types.size
+      if has_extra_names
+        extra_names = raw_arg_types.keys - param_names
+        raise "The declaration for `#{method.name}` has extra parameter(s): #{extra_names.join(', ')}"
+      end
+    end
+
+    if parameters.size != raw_arg_types.size
+      raise "The declaration for `#{method.name}` has arguments with duplicate names"
+    end
+    i = 0
+    raw_arg_types.each do |type_name, raw_type|
+      param_kind, param_name = parameters[i]
+
+      if type_name != param_name
+        hint = ""
+        # Ruby reorders params so that required keyword arguments
+        # always precede optional keyword arguments. We can't tell
+        # whether the culprit is the Ruby reordering or user error, so
+        # we error but include a note
+        if param_kind == :keyreq && parameters.any? {|k, _| k == :key}
+          hint = "\n\nNote: Any required keyword arguments must precede any optional keyword " \
+                 "arguments. If your method declaration matches your `def`, try reordering any " \
+                 "optional keyword parameters to the end of the method list."
+        end
+
+        raise "Parameter `#{type_name}` is declared out of order (declared as arg number " \
+              "#{i + 1}, defined in the method as arg number " \
+              "#{parameters.index {|_, name| name == type_name} + 1}).#{hint}\nMethod: #{method_desc}"
+      end
+
+      type = T::Utils.coerce(raw_type)
+
+      case param_kind
+      when :req
+        if (arg_types ? arg_types.length : 0) > req_arg_count
+          # Note that this is actually is supported by Ruby, but it would add complexity to
+          # support it here, and I'm happy to discourage its use anyway.
+          #
+          # If you are seeing this error and surprised by it, it's possible that you have
+          # overridden the method described in the error message. For example, Rails defines
+          # def self.update!(id = :all, attributes)
+          # on AR models. If you have also defined `self.update!` on an AR model you might
+          # see this error. The simplest resolution is to rename your method.
+          raise "Required params after optional params are not supported in method declarations. Method: #{method_desc}"
+        end
+        (arg_types ||= []) << [param_name, type]
+        req_arg_count += 1
+      when :opt
+        (arg_types ||= []) << [param_name, type]
+      when :key, :keyreq
+        (kwarg_types ||= {})[param_name] = type
+        if param_kind == :keyreq
+          (req_kwarg_names ||= []) << param_name
+        end
+      when :block
+        @block_name = param_name
+        @block_type = type
+      when :rest
+        @has_rest = true
+        @rest_name = param_name
+        @rest_type = type
+      when :keyrest
+        @has_keyrest = true
+        @keyrest_name = param_name
+        @keyrest_type = type
+      else
+        raise "Unexpected param_kind: `#{param_kind}`. Method: #{method_desc}"
+      end
+
+      i += 1
+    end
+
+    @arg_types = arg_types || EMPTY_LIST
+    @kwarg_types = kwarg_types || EMPTY_HASH
+    @req_arg_count = req_arg_count
+    @req_kwarg_names = req_kwarg_names || EMPTY_LIST
+  end
+
+  attr_writer :method_name
+  protected :method_name=
+
+  def as_alias(alias_name)
+    new_sig = clone
+    new_sig.method_name = alias_name
+    new_sig
+  end
+
+  def arg_count
+    @arg_types.length
+  end
+
+  def kwarg_names
+    @kwarg_types.keys
+  end
+
+  def owner
+    @method.owner
+  end
+
+  def dsl_method
+    "#{@mode}_method"
+  end
+
+  # @return [Hash] a mapping like `{arg_name: [val, type], ...}`, for only those args actually present.
+  def each_args_value_type(args)
+    # Manually split out args and kwargs based on ruby's behavior. Do not try to implement this by
+    # getting ruby to determine the kwargs for you (e.g., by defining this method to take *args and
+    # **kwargs). That won't work, because ruby's behavior for determining kwargs is dependent on the
+    # the other parameters in the method definition, and our method definition here doesn't (and
+    # can't) match the definition of the method we're validating. In addition, Ruby has a bug that
+    # causes forwarding **kwargs to do the wrong thing: see https://bugs.ruby-lang.org/issues/10708
+    # and https://bugs.ruby-lang.org/issues/11860.
+    args_length = args.length
+    if (args_length > @req_arg_count) && (!@kwarg_types.empty? || @has_keyrest) && args[-1].is_a?(Hash)
+      kwargs = args[-1]
+      args_length -= 1
+    else
+      kwargs = EMPTY_HASH
+    end
+
+    if !@has_rest && ((args_length < @req_arg_count) || (args_length > @arg_types.length))
+      expected_str = @req_arg_count.to_s
+      if @arg_types.length != @req_arg_count
+        expected_str += "..#{@arg_types.length}"
+      end
+      raise ArgumentError.new("wrong number of arguments (given #{args_length}, expected #{expected_str})")
+    end
+
+    begin
+      it = 0
+
+      # Process given pre-rest args. When there are no rest args,
+      # this is just the given number of args.
+      while it < args_length && it < @arg_types.length
+        yield @arg_types[it][0], args[it], @arg_types[it][1]
+        it += 1
+      end
+
+      if @has_rest
+        rest_count = args_length - @arg_types.length
+        rest_count = 0 if rest_count.negative?
+
+        rest_count.times do
+          yield @rest_name, args[it], @rest_type
+          it += 1
+        end
+      end
+    end
+
+    kwargs.each do |name, val|
+      type = @kwarg_types[name]
+      if !type && @has_keyrest
+        type = @keyrest_type
+      end
+
+      yield name, val, type if type
+    end
+  end
+
+  def method_desc
+    loc = if @method.source_location
+      @method.source_location.join(':')
+    else
+      "<unknown location>"
+    end
+    "#{@method} at #{loc}"
+  end
+
+  def force_type_init
+    @arg_types.each {|_, type| type.build_type}
+    @kwarg_types.each {|_, type| type.build_type}
+    @block_type&.build_type
+    @rest_type&.build_type
+    @keyrest_type&.build_type
+    @return_type.build_type
+  end
+
+  EMPTY_LIST = [].freeze
+  EMPTY_HASH = {}.freeze
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/signature_validation.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/signature_validation.rb
new file mode 100644
index 0000000000000..07a33d73acda9
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/methods/signature_validation.rb
@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Private::Methods::SignatureValidation
+  Methods = T::Private::Methods
+  Modes = Methods::Modes
+
+  def self.validate(signature)
+    # Constructors in any language are always a bit weird: they're called in a
+    # static context, but their bodies are implemented by instance methods. So
+    # a mix of the rules that apply to instance methods and class methods
+    # apply.
+    #
+    # In languages like Java and Scala, static methods/companion object methods
+    # are never inherited. (In Java it almost looks like you can inherit them,
+    # because `Child.static_parent_method` works, but this method is simply
+    # resolved statically to `Parent.static_parent_method`). Even though most
+    # instance methods overrides have variance checking done, constructors are
+    # not treated like this, because static methods are never
+    # inherited/overridden, and the constructor can only ever be called
+    # indirectly by way of the static method. (Note: this is only a mental
+    # model--there's not actually a static method for the constructor in Java,
+    # there's an `invokespecial` JVM instruction that handles this).
+    #
+    # But Ruby is not like Java: singleton class methods in Ruby *are*
+    # inherited, unlike static methods in Java. In fact, this is similar to how
+    # JavaScript works. TypeScript simply then sidesteps the issue with
+    # structural typing: `typeof Parent` is not compatible with `typeof Child`
+    # if their constructors are different. (In a nominal type system, simply
+    # having Child descend from Parent should be the only factor in determining
+    # whether those types are compatible).
+    #
+    # Flow has nominal subtyping for classes. When overriding (static and
+    # instance) methods in a child class, the overrides must satisfy variance
+    # constraints. But it still carves out an exception for constructors,
+    # because then literally every class would have to have the same
+    # constructor. This is simply unsound. Hack does a similar thing--static
+    # method overrides are checked, but not constructors. Though what Hack
+    # *does* have is a way to opt into override checking for constructors with
+    # a special annotation.
+    #
+    # It turns out, Sorbet already has this special annotation: either
+    # `abstract` or `overridable`. At time of writing, *no* static override
+    # checking happens unless marked with these keywords (though at runtime, it
+    # always happens). Getting the static system to parity with the runtime by
+    # always checking overrides would be a great place to get to one day, but
+    # for now we can take advantage of it by only doing override checks for
+    # constructors if they've opted in.
+    #
+    # (When we get around to more widely checking overrides statically, we will
+    # need to build a matching special case for constructors statically.)
+    #
+    # Note that this breaks with tradition: normally, constructors are not
+    # allowed to be abstract. But that's kind of a side-effect of everything
+    # above: in Java/Scala, singleton class methods are never abstract because
+    # they're not inherited, and this extends to constructors. TypeScript
+    # simply rejects `new klass()` entirely if `klass` is
+    # `typeof AbstractClass`, requiring instead that you write
+    # `{ new(): AbstractClass }`. We may want to consider building some
+    # analogue to `T.class_of` in the future that works like this `{new():
+    # ...}` type.
+    if signature.method_name == :initialize && signature.method.owner.is_a?(Class) &&
+        signature.mode == Modes.standard
+      return
+    end
+
+    super_method = signature.method.super_method
+
+    if super_method && super_method.owner != signature.method.owner
+      Methods.maybe_run_sig_block_for_method(super_method)
+      super_signature = Methods.signature_for_method(super_method)
+
+      # If the super_method has any kwargs we can't build a
+      # Signature for it, so we'll just skip validation in that case.
+      if !super_signature && !super_method.parameters.select {|kind, _| kind == :rest || kind == :kwrest}.empty?
+        nil
+      else
+        # super_signature can be nil when we're overriding a method (perhaps a builtin) that didn't use
+        # one of the method signature helpers. Use an untyped signature so we can still validate
+        # everything but types.
+        #
+        # We treat these signatures as overridable, that way people can use `.override` with
+        # overrides of builtins. In the future we could try to distinguish when the method is a
+        # builtin and treat non-builtins as non-overridable (so you'd be forced to declare them with
+        # `.overridable`).
+        #
+        super_signature ||= Methods::Signature.new_untyped(method: super_method)
+
+        validate_override_mode(signature, super_signature)
+        validate_override_shape(signature, super_signature)
+        validate_override_types(signature, super_signature)
+      end
+    else
+      validate_non_override_mode(signature)
+    end
+  end
+
+  private_class_method def self.pretty_mode(signature)
+    if signature.mode == Modes.overridable_override
+      '.overridable.override'
+    else
+      ".#{signature.mode}"
+    end
+  end
+
+  def self.validate_override_mode(signature, super_signature)
+    case signature.mode
+    when *Modes::OVERRIDE_MODES
+      # Peaceful
+    when Modes.abstract
+      # Either the parent method is abstract, or it's not.
+      #
+      # If it's abstract, we want to allow overriding abstract with abstract to
+      # possibly narrow the type or provide more specific documentation.
+      #
+      # If it's not, then marking this method `abstract` will silently be a no-op.
+      # That's bad and we probably want to report an error, but fixing that
+      # will have to be a separate fix (that bad behavior predates this current
+      # comment, introduced when we fixed the abstract/abstract case).
+      #
+      # Therefore:
+      # Peaceful (mostly)
+    when *Modes::NON_OVERRIDE_MODES
+      if super_signature.mode == Modes.standard
+        # Peaceful
+      elsif super_signature.mode == Modes.abstract
+        raise "You must use `.override` when overriding the abstract method `#{signature.method_name}`.\n" \
+              "  Abstract definition: #{method_loc_str(super_signature.method)}\n" \
+              "  Implementation definition: #{method_loc_str(signature.method)}\n"
+      elsif super_signature.mode != Modes.untyped
+        raise "You must use `.override` when overriding the existing method `#{signature.method_name}`.\n" \
+              "  Parent definition: #{method_loc_str(super_signature.method)}\n" \
+              "  Child definition:  #{method_loc_str(signature.method)}\n"
+      end
+    else
+      raise "Unexpected mode: #{signature.mode}. Please report this bug at https://github.com/sorbet/sorbet/issues"
+    end
+  end
+
+  def self.validate_non_override_mode(signature)
+    case signature.mode
+    when Modes.override
+      if signature.method_name == :each && signature.method.owner < Enumerable
+        # Enumerable#each is the only method in Sorbet's RBI payload that defines an abstract method.
+        # Enumerable#each does not actually exist at runtime, but it is required to be implemented by
+        # any class which includes Enumerable. We want to declare Enumerable#each as abstract so that
+        # people can call it anything which implements the Enumerable interface, and so that it's a
+        # static error to forget to implement it.
+        #
+        # This is a one-off hack, and we should think carefully before adding more methods here.
+        nil
+      else
+        raise "You marked `#{signature.method_name}` as #{pretty_mode(signature)}, but that method doesn't already exist in this class/module to be overridden.\n" \
+          "  Either check for typos and for missing includes or super classes to make the parent method shows up\n" \
+          "  ... or remove #{pretty_mode(signature)} here: #{method_loc_str(signature.method)}\n"
+      end
+    when Modes.standard, *Modes::NON_OVERRIDE_MODES
+      # Peaceful
+      nil
+    else
+      raise "Unexpected mode: #{signature.mode}. Please report this bug at https://github.com/sorbet/sorbet/issues"
+    end
+
+    # Given a singleton class, we can check if it belongs to a
+    # module by looking at its superclass; given `module M`,
+    # `M.singleton_class.superclass == Module`, which is not true
+    # for any class.
+    owner = signature.method.owner
+    if (signature.mode == Modes.abstract || Modes::OVERRIDABLE_MODES.include?(signature.mode)) &&
+        owner.singleton_class? && owner.superclass == Module
+      raise "Defining an overridable class method (via #{pretty_mode(signature)}) " \
+            "on a module is not allowed. Class methods on " \
+            "modules do not get inherited and thus cannot be overridden."
+    end
+  end
+
+  def self.validate_override_shape(signature, super_signature)
+    return if signature.override_allow_incompatible
+    return if super_signature.mode == Modes.untyped
+
+    method_name = signature.method_name
+    mode_verb = super_signature.mode == Modes.abstract ? 'implements' : 'overrides'
+
+    if !signature.has_rest && signature.arg_count < super_signature.arg_count
+      raise "Your definition of `#{method_name}` must accept at least #{super_signature.arg_count} " \
+            "positional arguments to be compatible with the method it #{mode_verb}: " \
+            "#{base_override_loc_str(signature, super_signature)}"
+    end
+
+    if !signature.has_rest && super_signature.has_rest
+      raise "Your definition of `#{method_name}` must have `*#{super_signature.rest_name}` " \
+            "to be compatible with the method it #{mode_verb}: " \
+            "#{base_override_loc_str(signature, super_signature)}"
+    end
+
+    if signature.req_arg_count > super_signature.req_arg_count
+      raise "Your definition of `#{method_name}` must have no more than #{super_signature.req_arg_count} " \
+            "required argument(s) to be compatible with the method it #{mode_verb}: " \
+            "#{base_override_loc_str(signature, super_signature)}"
+    end
+
+    if !signature.has_keyrest
+      # O(nm), but n and m are tiny here
+      missing_kwargs = super_signature.kwarg_names - signature.kwarg_names
+      if !missing_kwargs.empty?
+        raise "Your definition of `#{method_name}` is missing these keyword arg(s): #{missing_kwargs} " \
+              "which are defined in the method it #{mode_verb}: " \
+              "#{base_override_loc_str(signature, super_signature)}"
+      end
+    end
+
+    if !signature.has_keyrest && super_signature.has_keyrest
+      raise "Your definition of `#{method_name}` must have `**#{super_signature.keyrest_name}` " \
+            "to be compatible with the method it #{mode_verb}: " \
+            "#{base_override_loc_str(signature, super_signature)}"
+    end
+
+    # O(nm), but n and m are tiny here
+    extra_req_kwargs = signature.req_kwarg_names - super_signature.req_kwarg_names
+    if !extra_req_kwargs.empty?
+      raise "Your definition of `#{method_name}` has extra required keyword arg(s) " \
+            "#{extra_req_kwargs} relative to the method it #{mode_verb}, making it incompatible: " \
+            "#{base_override_loc_str(signature, super_signature)}"
+    end
+
+    if super_signature.block_name && !signature.block_name
+      raise "Your definition of `#{method_name}` must accept a block parameter to be compatible " \
+            "with the method it #{mode_verb}: " \
+            "#{base_override_loc_str(signature, super_signature)}"
+    end
+  end
+
+  def self.validate_override_types(signature, super_signature)
+    return if signature.override_allow_incompatible
+    return if super_signature.mode == Modes.untyped
+    return unless [signature, super_signature].all? do |sig|
+      sig.check_level == :always || (sig.check_level == :tests && T::Private::RuntimeLevels.check_tests?)
+    end
+    mode_noun = super_signature.mode == Modes.abstract ? 'implementation' : 'override'
+
+    # arg types must be contravariant
+    super_signature.arg_types.zip(signature.arg_types).each_with_index do |((_super_name, super_type), (name, type)), index|
+      if !super_type.subtype_of?(type)
+        raise "Incompatible type for arg ##{index + 1} (`#{name}`) in signature for #{mode_noun} of method " \
+              "`#{signature.method_name}`:\n" \
+              "* Base: `#{super_type}` (in #{method_loc_str(super_signature.method)})\n" \
+              "* #{mode_noun.capitalize}: `#{type}` (in #{method_loc_str(signature.method)})\n" \
+              "(The types must be contravariant.)"
+      end
+    end
+
+    # kwarg types must be contravariant
+    super_signature.kwarg_types.each do |name, super_type|
+      type = signature.kwarg_types[name]
+      if !super_type.subtype_of?(type)
+        raise "Incompatible type for arg `#{name}` in signature for #{mode_noun} of method `#{signature.method_name}`:\n" \
+              "* Base: `#{super_type}` (in #{method_loc_str(super_signature.method)})\n" \
+              "* #{mode_noun.capitalize}: `#{type}` (in #{method_loc_str(signature.method)})\n" \
+              "(The types must be contravariant.)"
+      end
+    end
+
+    # return types must be covariant
+    super_signature_return_type = super_signature.return_type
+
+    if super_signature_return_type == T::Private::Types::Void::Private::INSTANCE
+      # Treat `.void` as `T.anything` (see corresponding comment in definition_valitor for more)
+      super_signature_return_type = T::Types::Anything::Private::INSTANCE
+    end
+
+    if !signature.return_type.subtype_of?(super_signature_return_type)
+      raise "Incompatible return type in signature for #{mode_noun} of method `#{signature.method_name}`:\n" \
+            "* Base: `#{super_signature.return_type}` (in #{method_loc_str(super_signature.method)})\n" \
+            "* #{mode_noun.capitalize}: `#{signature.return_type}` (in #{method_loc_str(signature.method)})\n" \
+            "(The types must be covariant.)"
+    end
+  end
+
+  private_class_method def self.base_override_loc_str(signature, super_signature)
+    mode_noun = super_signature.mode == Modes.abstract ? 'Implementation' : 'Override'
+    "\n * Base definition: in #{method_loc_str(super_signature.method)}" \
+    "\n * #{mode_noun}: in #{method_loc_str(signature.method)}"
+  end
+
+  private_class_method def self.method_loc_str(method)
+    loc = if method.source_location
+      method.source_location.join(':')
+    else
+      "<unknown location>"
+    end
+    "#{method.owner} at #{loc}"
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/mixins/mixins.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/mixins/mixins.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/mixins/mixins.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/mixins/mixins.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/retry.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/retry.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/retry.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/retry.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/runtime_levels.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/runtime_levels.rb
new file mode 100644
index 0000000000000..dbf088419575a
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/runtime_levels.rb
@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+# typed: true
+
+# Used in `sig.checked(level)` to determine when runtime type checking
+# is enabled on a method.
+module T::Private::RuntimeLevels
+  LEVELS = [
+    # Validate every call in every environment
+    :always,
+    # Validate in tests, but not in production
+    :tests,
+    # Don't even validate in tests, b/c too expensive,
+    # or b/c we fully trust the static typing
+    :never,
+  ].freeze
+
+  @check_tests = false
+  @wrapped_tests_with_validation = false
+
+  @has_read_default_checked_level = false
+  @default_checked_level = :always
+
+  def self.check_tests?
+    # Assume that this code path means that some `sig.checked(:tests)`
+    # has been wrapped (or not wrapped) already, which is a trapdoor
+    # for toggling `@check_tests`.
+    @wrapped_tests_with_validation = true
+
+    @check_tests
+  end
+
+  def self.enable_checking_in_tests
+    if !@check_tests && @wrapped_tests_with_validation
+      all_checked_tests_sigs = T::Private::Methods.all_checked_tests_sigs
+      locations = all_checked_tests_sigs.map {|sig| sig.method.source_location.join(':')}.join("\n- ")
+      raise "Toggle `:tests`-level runtime type checking earlier. " \
+        "There are already some methods wrapped with `sig.checked(:tests)`:\n" \
+        "- #{locations}"
+    end
+
+    _toggle_checking_tests(true)
+  end
+
+  def self.default_checked_level
+    @has_read_default_checked_level = true
+    @default_checked_level
+  end
+
+  def self.default_checked_level=(default_checked_level)
+    if @has_read_default_checked_level
+      raise "Set the default checked level earlier. There are already some methods whose sig blocks have evaluated which would not be affected by the new default."
+    end
+    if !LEVELS.include?(default_checked_level)
+      raise "Invalid `checked` level '#{default_checked_level}'. Use one of: #{LEVELS}."
+    end
+
+    @default_checked_level = default_checked_level
+  end
+
+  def self._toggle_checking_tests(checked)
+    @check_tests = checked
+  end
+
+  private_class_method def self.set_enable_checking_in_tests_from_environment
+    if ENV['SORBET_RUNTIME_ENABLE_CHECKING_IN_TESTS']
+      enable_checking_in_tests
+    end
+  end
+  set_enable_checking_in_tests_from_environment
+
+  private_class_method def self.set_default_checked_level_from_environment
+    level = ENV['SORBET_RUNTIME_DEFAULT_CHECKED_LEVEL']
+    if level
+      self.default_checked_level = level.to_sym
+    end
+  end
+  set_default_checked_level_from_environment
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/sealed.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/sealed.rb
similarity index 80%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/sealed.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/sealed.rb
index 62e19fb088c46..0c912f9a46e6d 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/sealed.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/sealed.rb
@@ -5,8 +5,8 @@ module T::Private::Sealed
   module NoInherit
     def inherited(child)
       super
-      this_line = Kernel.caller.find {|line| !line.match(/in `inherited'$/)}
-      T::Private::Sealed.validate_inheritance(this_line, self, child, 'inherited')
+      caller_loc = T::Private::CallerUtils.find_caller {|loc| loc.base_label != 'inherited'}
+      T::Private::Sealed.validate_inheritance(caller_loc, self, child, 'inherited')
       @sorbet_sealed_module_all_subclasses << child
     end
 
@@ -22,15 +22,15 @@ def sealed_subclasses
   module NoIncludeExtend
     def included(child)
       super
-      this_line = Kernel.caller.find {|line| !line.match(/in `included'$/)}
-      T::Private::Sealed.validate_inheritance(this_line, self, child, 'included')
+      caller_loc = T::Private::CallerUtils.find_caller {|loc| !loc.to_s.match(/in `included'$/)}
+      T::Private::Sealed.validate_inheritance(caller_loc, self, child, 'included')
       @sorbet_sealed_module_all_subclasses << child
     end
 
     def extended(child)
       super
-      this_line = Kernel.caller.find {|line| !line.match(/in `extended'$/)}
-      T::Private::Sealed.validate_inheritance(this_line, self, child, 'extended')
+      caller_loc = T::Private::CallerUtils.find_caller {|loc| !loc.to_s.match(/in `extended'$/)}
+      T::Private::Sealed.validate_inheritance(caller_loc, self, child, 'extended')
       @sorbet_sealed_module_all_subclasses << child
     end
 
@@ -68,8 +68,8 @@ def self.sealed_module?(mod)
     mod.instance_variable_defined?(:@sorbet_sealed_module_decl_file)
   end
 
-  def self.validate_inheritance(this_line, parent, child, verb)
-    this_file = this_line&.split(':')&.first
+  def self.validate_inheritance(caller_loc, parent, child, verb)
+    this_file = caller_loc&.path
     decl_file = parent.instance_variable_get(:@sorbet_sealed_module_decl_file) if sealed_module?(parent)
 
     if !this_file
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/types/not_typed.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/not_typed.rb
similarity index 86%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/types/not_typed.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/not_typed.rb
index 57196553b6959..832361a048b04 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/types/not_typed.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/not_typed.rb
@@ -6,6 +6,10 @@
 class T::Private::Types::NotTyped < T::Types::Base
   ERROR_MESSAGE = "Validation is being done on a `NotTyped`. Please report this bug at https://github.com/sorbet/sorbet/issues"
 
+  def build_type
+    nil
+  end
+
   # overrides Base
   def name
     "<NOT-TYPED>"
@@ -20,4 +24,6 @@ def valid?(obj)
   private def subtype_of_single?(other)
     raise ERROR_MESSAGE
   end
+
+  INSTANCE = ::T::Private::Types::NotTyped.new.freeze
 end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/simple_pair_union.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/simple_pair_union.rb
new file mode 100644
index 0000000000000..910111a9ba576
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/simple_pair_union.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+# typed: true
+
+# Specialization of Union for the common case of the union of two simple types.
+#
+# This covers e.g. T.nilable(SomeModule), T.any(Integer, Float), and T::Boolean.
+class T::Private::Types::SimplePairUnion < T::Types::Union
+  class DuplicateType < RuntimeError; end
+
+  # @param type_a [T::Types::Simple]
+  # @param type_b [T::Types::Simple]
+  def initialize(type_a, type_b)
+    if type_a == type_b
+      raise DuplicateType.new("#{type_a} == #{type_b}")
+    end
+
+    @raw_a = type_a.raw_type
+    @raw_b = type_b.raw_type
+  end
+
+  # @override Union
+  def recursively_valid?(obj)
+    obj.is_a?(@raw_a) || obj.is_a?(@raw_b)
+  end
+
+  # @override Union
+  def valid?(obj)
+    obj.is_a?(@raw_a) || obj.is_a?(@raw_b)
+  end
+
+  # @override Union
+  def types
+    # We reconstruct the simple types rather than just storing them because
+    # (1) this is normally not a hot path and (2) we want to keep the instance
+    # variable count <= 3 so that we can fit in a 40 byte heap entry along
+    # with object headers.
+    @types ||= [
+      T::Types::Simple::Private::Pool.type_for_module(@raw_a),
+      T::Types::Simple::Private::Pool.type_for_module(@raw_b),
+    ]
+  end
+
+  # overrides Union
+  def unwrap_nilable
+    a_nil = @raw_a.equal?(NilClass)
+    b_nil = @raw_b.equal?(NilClass)
+    if a_nil
+      return types[1]
+    end
+    if b_nil
+      return types[0]
+    end
+    nil
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/types/string_holder.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/string_holder.rb
similarity index 92%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/types/string_holder.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/string_holder.rb
index b2295f77308f9..a3bcbe63c9f78 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/types/string_holder.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/string_holder.rb
@@ -9,6 +9,10 @@ def initialize(string)
     @string = string
   end
 
+  def build_type
+    nil
+  end
+
   # overrides Base
   def name
     string
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/types/type_alias.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/type_alias.rb
similarity index 93%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/types/type_alias.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/type_alias.rb
index de805c96595a0..dcb03b8de2a91 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/private/types/type_alias.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/type_alias.rb
@@ -9,6 +9,10 @@ def initialize(callable)
       @callable = callable
     end
 
+    def build_type
+      nil
+    end
+
     def aliased_type
       @aliased_type ||= T::Utils.coerce(@callable.call)
     end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/void.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/void.rb
new file mode 100644
index 0000000000000..3208a68ead043
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/private/types/void.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+# typed: true
+
+# A marking class for when methods return void.
+# Should never appear in types directly.
+module T::Private::Types
+  class Void < T::Types::Base
+    ERROR_MESSAGE = "Validation is being done on an `Void`. Please report this bug at https://github.com/sorbet/sorbet/issues"
+
+    # The actual return value of `.void` methods.
+    #
+    # Uses `module VOID` because this gives it a readable name when someone
+    # examines it in Pry or with `#inspect` like:
+    #
+    #     T::Private::Types::Void::VOID
+    #
+    module VOID
+      freeze
+    end
+
+    def build_type
+      nil
+    end
+
+    # overrides Base
+    def name
+      "<VOID>"
+    end
+
+    # overrides Base
+    def valid?(obj)
+      raise ERROR_MESSAGE
+    end
+
+    # overrides Base
+    private def subtype_of_single?(other)
+      raise ERROR_MESSAGE
+    end
+
+    module Private
+      INSTANCE = Void.new.freeze
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/_props.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/_props.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/_props.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/_props.rb
index fae252aa048f7..420e1d2651f2b 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/_props.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/_props.rb
@@ -110,7 +110,7 @@ def reload_decorator!
     #
     # @return [void]
     sig {params(name: Symbol, cls: T.untyped, rules: T.untyped).void}
-    def prop(name, cls, rules={})
+    def prop(name, cls, **rules)
       cls = T::Utils.coerce(cls) if !cls.is_a?(Module)
       decorator.prop_defined(name, cls, rules)
     end
@@ -132,16 +132,16 @@ def plugin(mod)
     end
 
     # Shorthand helper to define a `prop` with `immutable => true`
-    sig {params(name: Symbol, cls_or_args: T.untyped, args: T::Hash[Symbol, T.untyped]).void}
-    def const(name, cls_or_args, args={})
+    sig {params(name: Symbol, cls_or_args: T.untyped, args: T.untyped).void}
+    def const(name, cls_or_args, **args)
       if (cls_or_args.is_a?(Hash) && cls_or_args.key?(:immutable)) || args.key?(:immutable)
         Kernel.raise ArgumentError.new("Cannot pass 'immutable' argument when using 'const' keyword to define a prop")
       end
 
       if cls_or_args.is_a?(Hash)
-        self.prop(name, cls_or_args.merge(immutable: true))
+        self.prop(name, **cls_or_args.merge(immutable: true))
       else
-        self.prop(name, cls_or_args, args.merge(immutable: true))
+        self.prop(name, cls_or_args, **args.merge(immutable: true))
       end
     end
 
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/constructor.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/constructor.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/constructor.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/constructor.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/custom_type.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/custom_type.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/custom_type.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/custom_type.rb
index 0df6a0d863196..a09b6a76c52ab 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/custom_type.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/custom_type.rb
@@ -57,12 +57,12 @@ def self.included(_base)
       raise 'Please use "extend", not "include" to attach this module'
     end
 
-    sig(:final) {params(val: Object).returns(T::Boolean).checked(:never)}
+    sig(:final) {params(val: T.untyped).returns(T::Boolean).checked(:never)}
     def self.scalar_type?(val)
       # We don't need to check for val's included modules in
       # T::Configuration.scalar_types, because T::Configuration.scalar_types
       # are all classes.
-      klass = T.let(val.class, T.nilable(Class))
+      klass = val.class
       until klass.nil?
         return true if T::Configuration.scalar_types.include?(klass.to_s)
         klass = klass.superclass
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/decorator.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/decorator.rb
similarity index 89%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/decorator.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/decorator.rb
index 679a32584b4f1..82e213da4589c 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/decorator.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/decorator.rb
@@ -17,7 +17,7 @@ class T::Props::Decorator
 
   class NoRulesError < StandardError; end
 
-  EMPTY_PROPS = T.let({}.freeze, T::Hash[Symbol, Rules])
+  EMPTY_PROPS = T.let({}.freeze, T::Hash[Symbol, Rules], checked: false)
   private_constant :EMPTY_PROPS
 
   sig {params(klass: T.untyped).void.checked(:never)}
@@ -26,7 +26,7 @@ def initialize(klass)
     @class.plugins.each do |mod|
       T::Props::Plugin::Private.apply_decorator_methods(mod, self)
     end
-    @props = T.let(EMPTY_PROPS, T::Hash[Symbol, Rules])
+    @props = T.let(EMPTY_PROPS, T::Hash[Symbol, Rules], checked: false)
   end
 
   # checked(:never) - O(prop accesses)
@@ -50,9 +50,9 @@ def add_prop_definition(prop, rules)
     override = rules.delete(:override)
 
     if props.include?(prop) && !override
-      raise ArgumentError.new("Attempted to redefine prop #{prop.inspect} that's already defined without specifying :override => true: #{prop_rules(prop)}")
+      raise ArgumentError.new("Attempted to redefine prop #{prop.inspect} on class #{@class} that's already defined without specifying :override => true: #{prop_rules(prop)}")
     elsif !props.include?(prop) && override
-      raise ArgumentError.new("Attempted to override a prop #{prop.inspect} that doesn't already exist")
+      raise ArgumentError.new("Attempted to override a prop #{prop.inspect} on class #{@class} that doesn't already exist")
     end
 
     @props = @props.merge(prop => rules.freeze).freeze
@@ -79,7 +79,7 @@ def add_prop_definition(prop, rules)
     extra
     setter_validate
     _tnilable
-  ].map {|k| [k, true]}.to_h.freeze, T::Hash[Symbol, T::Boolean])
+  ].to_h {|k| [k, true]}.freeze, T::Hash[Symbol, T::Boolean], checked: false)
   private_constant :VALID_RULE_KEYS
 
   sig {params(key: Symbol).returns(T::Boolean).checked(:never)}
@@ -100,10 +100,7 @@ def decorated_class
   # checked(:never) - potentially O(prop accesses) depending on usage pattern
   sig {params(prop: Symbol, val: T.untyped).void.checked(:never)}
   def validate_prop_value(prop, val)
-    # We call `setter_proc` here without binding to an instance, so it'll run
-    # `instance_variable_set` if validation passes, but nothing will care.
-    # We only care about the validation.
-    prop_rules(prop).fetch(:setter_proc).call(val)
+    prop_rules(prop).fetch(:value_validate_proc).call(val)
   end
 
   # For performance, don't use named params here.
@@ -205,7 +202,7 @@ def foreign_prop_get(instance, prop, foreign_class, rules=prop_rules(prop), opts
   end
 
   # TODO: we should really be checking all the methods on `cls`, not just Object
-  BANNED_METHOD_NAMES = T.let(Object.instance_methods.each_with_object({}) {|x, acc| acc[x] = true}.freeze, T::Hash[Symbol, TrueClass])
+  BANNED_METHOD_NAMES = T.let(Object.instance_methods.each_with_object({}) {|x, acc| acc[x] = true}.freeze, T::Hash[Symbol, TrueClass], checked: false)
 
   # checked(:never) - Rules hash is expensive to check
   sig do
@@ -247,10 +244,10 @@ def prop_validate_definition!(name, cls, rules, type)
     nil
   end
 
-  SAFE_NAME = T.let(/\A[A-Za-z_][A-Za-z0-9_-]*\z/.freeze, Regexp)
+  SAFE_NAME = T.let(/\A[A-Za-z_][A-Za-z0-9_-]*\z/.freeze, Regexp, checked: false)
 
   # Used to validate both prop names and serialized forms
-  sig {params(name: T.any(Symbol, String)).void}
+  sig {params(name: T.any(Symbol, String)).void.checked(:never)}
   private def validate_prop_name(name)
     if !name.match?(SAFE_NAME)
       raise ArgumentError.new("Invalid prop name in #{@class.name}: #{name}")
@@ -258,7 +255,7 @@ def prop_validate_definition!(name, cls, rules, type)
   end
 
   # This converts the type from a T::Type to a regular old ruby class.
-  sig {params(type: T::Types::Base).returns(Module)}
+  sig {params(type: T::Types::Base).returns(Module).checked(:never)}
   private def convert_type_to_class(type)
     case type
     when T::Types::TypedArray, T::Types::FixedArray
@@ -296,11 +293,13 @@ def prop_validate_definition!(name, cls, rules, type)
       cls: PropTypeOrClass,
       rules: Rules,
     )
-    .void
+    .returns(T.anything)
     .checked(:never)
   end
   private def prop_nilable?(cls, rules)
-    T::Utils::Nilable.is_union_with_nilclass(cls) || (cls == T.untyped && rules.key?(:default) && rules[:default].nil?)
+    # NB: `prop` and `const` do not `T::Utils::coerce the type of the prop if it is a `Module`,
+    # hence the bare `NilClass` check.
+    T::Utils::Nilable.is_union_with_nilclass(cls) || ((cls == T.untyped || cls == NilClass) && rules.key?(:default) && rules[:default].nil?)
   end
 
   # checked(:never) - Rules hash is expensive to check
@@ -333,37 +332,37 @@ def prop_defined(name, cls, rules={})
 
     prop_validate_definition!(name, cls, rules, type_object)
 
-    # Retrive the possible underlying object with T.nilable.
+    # Retrieve the possible underlying object with T.nilable.
     type = T::Utils::Nilable.get_underlying_type(type)
 
-    sensitivity_and_pii = {sensitivity: rules[:sensitivity]}
-    normalize = T::Configuration.normalize_sensitivity_and_pii_handler
-    if normalize
-      sensitivity_and_pii = normalize.call(sensitivity_and_pii)
-
-      # We check for Class so this is only applied on concrete
-      # documents/models; We allow mixins containing props to not
-      # specify their PII nature, as long as every class into which they
-      # are ultimately included does.
-      #
-      if sensitivity_and_pii[:pii] && @class.is_a?(Class) && !T.unsafe(@class).contains_pii?
-        raise ArgumentError.new(
-          'Cannot include a pii prop in a class that declares `contains_no_pii`'
-        )
+    rules_sensitivity = rules[:sensitivity]
+    sensitivity_and_pii = {sensitivity: rules_sensitivity}
+    if !rules_sensitivity.nil?
+      normalize = T::Configuration.normalize_sensitivity_and_pii_handler
+      if normalize
+        sensitivity_and_pii = normalize.call(sensitivity_and_pii)
+
+        # We check for Class so this is only applied on concrete
+        # documents/models; We allow mixins containing props to not
+        # specify their PII nature, as long as every class into which they
+        # are ultimately included does.
+        #
+        if sensitivity_and_pii[:pii] && @class.is_a?(Class) && !T.unsafe(@class).contains_pii?
+          raise ArgumentError.new(
+            'Cannot include a pii prop in a class that declares `contains_no_pii`'
+          )
+        end
       end
     end
 
-    rules = rules.merge(
-      # TODO: The type of this element is confusing. We should refactor so that
-      # it can be always `type_object` (a PropType) or always `cls` (a Module)
-      type: type,
-      type_object: type_object,
-      accessor_key: "@#{name}".to_sym,
-      sensitivity: sensitivity_and_pii[:sensitivity],
-      pii: sensitivity_and_pii[:pii],
-      # extra arbitrary metadata attached by the code defining this property
-      extra: rules[:extra]&.freeze,
-    )
+    rules[:type] = type
+    rules[:type_object] = type_object
+    rules[:accessor_key] = "@#{name}".to_sym
+    rules[:sensitivity] = sensitivity_and_pii[:sensitivity]
+    rules[:pii] = sensitivity_and_pii[:pii]
+    rules[:extra] = rules[:extra]&.freeze
+
+    # extra arbitrary metadata attached by the code defining this property
 
     validate_not_missing_sensitivity(name, rules)
 
@@ -376,7 +375,11 @@ def prop_defined(name, cls, rules={})
       end
     end
 
-    rules[:setter_proc] = T::Props::Private::SetterFactory.build_setter_proc(@class, name, rules).freeze
+    setter_proc, value_validate_proc = T::Props::Private::SetterFactory.build_setter_proc(@class, name, rules)
+    setter_proc.freeze
+    value_validate_proc.freeze
+    rules[:setter_proc] = setter_proc
+    rules[:value_validate_proc] = value_validate_proc
 
     add_prop_definition(name, rules)
 
@@ -417,6 +420,7 @@ def prop_defined(name, cls, rules={})
   sig do
     params(type: PropTypeOrClass, enum: T.untyped)
     .returns(T::Types::Base)
+    .checked(:never)
   end
   private def smart_coerce(type, enum:)
     # Backwards compatibility for pre-T::Types style
@@ -426,7 +430,7 @@ def prop_defined(name, cls, rules={})
     else
       nonnil_type = T::Utils.unwrap_nilable(type)
       if nonnil_type
-        T.unsafe(T.nilable(T.all(nonnil_type, T.deprecated_enum(enum))))
+        T.unsafe(T.nilable(T.all(T.unsafe(nonnil_type), T.deprecated_enum(enum))))
       else
         T.unsafe(T.all(T.unsafe(type), T.deprecated_enum(enum)))
       end
@@ -469,6 +473,7 @@ def prop_defined(name, cls, rules={})
       redaction: T.untyped,
     )
     .void
+    .checked(:never)
   end
   private def handle_redaction_option(prop_name, redaction)
     redacted_method = "#{prop_name}_redacted"
@@ -490,6 +495,7 @@ def prop_defined(name, cls, rules={})
       valid_type_msg: String,
     )
     .void
+    .checked(:never)
   end
   private def validate_foreign_option(option_sym, foreign, valid_type_msg:)
     if foreign.is_a?(Symbol) || foreign.is_a?(String)
@@ -521,8 +527,8 @@ def prop_defined(name, cls, rules={})
     # here, but we're baking in `allow_direct_mutation` since we
     # *haven't* allowed additional options in the past and want to
     # default to keeping this interface narrow.
+    foreign = T.let(foreign, T.untyped, checked: false)
     @class.send(:define_method, fk_method) do |allow_direct_mutation: nil|
-      foreign = T.let(foreign, T.untyped)
       if foreign.is_a?(Proc)
         resolved_foreign = foreign.call
         if !resolved_foreign.respond_to?(:load)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/errors.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/errors.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/errors.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/errors.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/generated_code_validation.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/generated_code_validation.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/generated_code_validation.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/generated_code_validation.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/has_lazily_specialized_methods.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/has_lazily_specialized_methods.rb
similarity index 91%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/has_lazily_specialized_methods.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/has_lazily_specialized_methods.rb
index 5c1acecb69d31..a82f699032221 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/has_lazily_specialized_methods.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/has_lazily_specialized_methods.rb
@@ -62,7 +62,9 @@ module DecoratorMethods
         source = lazily_defined_methods.fetch(name).call
 
         cls = decorated_class
-        cls.class_eval(source.to_s)
+        T::Configuration.without_ruby_warnings do
+          cls.class_eval(source.to_s)
+        end
         cls.send(:private, name)
       end
 
@@ -83,7 +85,7 @@ module DecoratorMethods
         lazily_defined_methods[name] = blk
 
         cls = decorated_class
-        if cls.method_defined?(name)
+        if cls.method_defined?(name) || cls.private_method_defined?(name)
           # Ruby does not emit "method redefined" warnings for aliased methods
           # (more robust than undef_method that would create a small window in which the method doesn't exist)
           cls.send(:alias_method, name, name)
@@ -117,7 +119,9 @@ module DecoratorMethods
       def eagerly_define_lazy_methods!
         return if lazily_defined_methods.empty?
 
-        source = lazily_defined_methods.values.map(&:call).map(&:to_s).join("\n\n")
+        # rubocop:disable Style/StringConcatenation
+        source = "# frozen_string_literal: true\n" + lazily_defined_methods.values.map(&:call).map(&:to_s).join("\n\n")
+        # rubocop:enable Style/StringConcatenation
 
         cls = decorated_class
         cls.class_eval(source)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/optional.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/optional.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/optional.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/optional.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/plugin.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/plugin.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/plugin.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/plugin.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/pretty_printable.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/pretty_printable.rb
new file mode 100644
index 0000000000000..8a472ff4be76e
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/pretty_printable.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+# typed: true
+require 'pp'
+
+module T::Props::PrettyPrintable
+  include T::Props::Plugin
+
+  # Override the PP gem with something that's similar, but gives us a hook to do redaction and customization
+  def pretty_print(pp)
+    klass = T.unsafe(T.cast(self, Object).class).decorator
+    multiline = pp.is_a?(PP)
+    pp.group(1, "<#{klass.inspect_class_with_decoration(self)}", ">") do
+      klass.all_props.sort.each do |prop|
+        pp.breakable
+        val = klass.get(self, prop)
+        rules = klass.prop_rules(prop)
+        pp.text("#{prop}=")
+        if (custom_inspect = rules[:inspect])
+          inspected = if T::Utils.arity(custom_inspect) == 1
+            custom_inspect.call(val)
+          else
+            custom_inspect.call(val, {multiline: multiline})
+          end
+          pp.text(inspected.nil? ? "nil" : inspected)
+        elsif rules[:sensitivity] && !rules[:sensitivity].empty? && !val.nil?
+          pp.text("<REDACTED #{rules[:sensitivity].join(', ')}>")
+        else
+          val.pretty_print(pp)
+        end
+      end
+      klass.pretty_print_extra(self, pp)
+    end
+  end
+
+  # Return a string representation of this object and all of its props in a single line
+  def inspect
+    string = +""
+    PP.singleline_pp(self, string)
+    string
+  end
+
+  # Return a pretty string representation of this object and all of its props
+  def pretty_inspect
+    string = +""
+    PP.pp(self, string)
+    string
+  end
+
+  module DecoratorMethods
+    extend T::Sig
+
+    sig {params(key: Symbol).returns(T::Boolean).checked(:never)}
+    def valid_rule_key?(key)
+      super || key == :inspect
+    end
+
+    # Overridable method to specify how the first part of a `pretty_print`d object's class should look like
+    # NOTE: This is just to support Stripe's `PrettyPrintableModel` case, and not recommended to be overridden
+    sig {params(instance: T::Props::PrettyPrintable).returns(String)}
+    def inspect_class_with_decoration(instance)
+      T.unsafe(instance).class.to_s
+    end
+
+    # Overridable method to add anything that is not a prop
+    # NOTE: This is to support cases like Serializable's `@_extra_props`, and Stripe's `PrettyPrintableModel#@_deleted`
+    sig {params(instance: T::Props::PrettyPrintable, pp: T.any(PrettyPrint, PP::SingleLine)).void}
+    def pretty_print_extra(instance, pp); end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/private/apply_default.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/private/apply_default.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/private/apply_default.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/private/apply_default.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/private/deserializer_generator.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/private/deserializer_generator.rb
similarity index 94%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/private/deserializer_generator.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/private/deserializer_generator.rb
index 2393e1a284b6d..8a2f6858bed42 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/private/deserializer_generator.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/private/deserializer_generator.rb
@@ -137,7 +137,10 @@ def __t_props_generated_deserialize(hash)
           when ApplyPrimitiveDefault
             literal = default.default
             case literal
-            when String, Integer, Symbol, Float, TrueClass, FalseClass, NilClass
+            # `Float` is intentionally left out here because `.inspect` does not produce the correct code
+            # representation for non-finite values like `Float::INFINITY` and `Float::NAN` and it's not totally
+            # clear that it won't cause issues with floating point precision.
+            when String, Integer, Symbol, TrueClass, FalseClass, NilClass
               literal.inspect
             else
               "self.class.decorator.props_with_defaults.fetch(#{prop.inspect}).default"
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/private/parser.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/private/parser.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/private/parser.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/private/parser.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/private/serde_transform.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/private/serde_transform.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/private/serde_transform.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/private/serde_transform.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/private/serializer_generator.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/private/serializer_generator.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/private/serializer_generator.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/private/serializer_generator.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/private/setter_factory.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/private/setter_factory.rb
new file mode 100644
index 0000000000000..95ff9863004fa
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/private/setter_factory.rb
@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+# typed: strict
+
+module T::Props
+  module Private
+    module SetterFactory
+      extend T::Sig
+
+      SetterProc = T.type_alias {T.proc.params(val: T.untyped).void}
+      ValueValidationProc = T.type_alias {T.proc.params(val: T.untyped).void}
+      ValidateProc = T.type_alias {T.proc.params(prop: Symbol, value: T.untyped).void}
+
+      sig do
+        params(
+          klass: T.all(Module, T::Props::ClassMethods),
+          prop: Symbol,
+          rules: T::Hash[Symbol, T.untyped]
+        )
+        .returns([SetterProc, ValueValidationProc])
+        .checked(:never)
+      end
+      def self.build_setter_proc(klass, prop, rules)
+        # Our nil check works differently than a simple T.nilable for various
+        # reasons (including the `raise_on_nil_write` setting and the existence
+        # of defaults & factories), so unwrap any T.nilable and do a check
+        # manually.
+        non_nil_type = T::Utils::Nilable.get_underlying_type_object(rules.fetch(:type_object))
+        accessor_key = rules.fetch(:accessor_key)
+        validate = rules[:setter_validate]
+
+        # It seems like a bug that this affects the behavior of setters, but
+        # some existing code relies on this behavior
+        has_explicit_nil_default = rules.key?(:default) && rules.fetch(:default).nil?
+
+        # Use separate methods in order to ensure that we only close over necessary
+        # variables
+        if !T::Props::Utils.need_nil_write_check?(rules) || has_explicit_nil_default
+          if validate.nil? && non_nil_type.is_a?(T::Types::Simple)
+            simple_nilable_proc(prop, accessor_key, non_nil_type.raw_type, klass)
+          else
+            nilable_proc(prop, accessor_key, non_nil_type, klass, validate)
+          end
+        else
+          if validate.nil? && non_nil_type.is_a?(T::Types::Simple)
+            simple_non_nil_proc(prop, accessor_key, non_nil_type.raw_type, klass)
+          else
+            non_nil_proc(prop, accessor_key, non_nil_type, klass, validate)
+          end
+        end
+      end
+
+      sig do
+        params(
+          prop: Symbol,
+          accessor_key: Symbol,
+          non_nil_type: Module,
+          klass: T.all(Module, T::Props::ClassMethods),
+        )
+        .returns([SetterProc, ValueValidationProc])
+      end
+      private_class_method def self.simple_non_nil_proc(prop, accessor_key, non_nil_type, klass)
+        [
+          proc do |val|
+            unless val.is_a?(non_nil_type)
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                T::Utils.coerce(non_nil_type),
+                val,
+              )
+            end
+            instance_variable_set(accessor_key, val)
+          end,
+          proc do |val|
+            unless val.is_a?(non_nil_type)
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                T::Utils.coerce(non_nil_type),
+                val,
+              )
+            end
+          end,
+        ]
+      end
+
+      sig do
+        params(
+          prop: Symbol,
+          accessor_key: Symbol,
+          non_nil_type: T::Types::Base,
+          klass: T.all(Module, T::Props::ClassMethods),
+          validate: T.nilable(ValidateProc)
+        )
+        .returns([SetterProc, ValueValidationProc])
+      end
+      private_class_method def self.non_nil_proc(prop, accessor_key, non_nil_type, klass, validate)
+        [
+          proc do |val|
+            # this use of recursively_valid? is intentional: unlike for
+            # methods, we want to make sure data at the 'edge'
+            # (e.g. models that go into databases or structs serialized
+            # from disk) are correct, so we use more thorough runtime
+            # checks there
+            if non_nil_type.recursively_valid?(val)
+              validate&.call(prop, val)
+            else
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                non_nil_type,
+                val,
+              )
+            end
+            instance_variable_set(accessor_key, val)
+          end,
+          proc do |val|
+            # this use of recursively_valid? is intentional: unlike for
+            # methods, we want to make sure data at the 'edge'
+            # (e.g. models that go into databases or structs serialized
+            # from disk) are correct, so we use more thorough runtime
+            # checks there
+            if non_nil_type.recursively_valid?(val)
+              validate&.call(prop, val)
+            else
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                non_nil_type,
+                val,
+              )
+            end
+          end,
+        ]
+      end
+
+      sig do
+        params(
+          prop: Symbol,
+          accessor_key: Symbol,
+          non_nil_type: Module,
+          klass: T.all(Module, T::Props::ClassMethods),
+        )
+        .returns([SetterProc, ValueValidationProc])
+      end
+      private_class_method def self.simple_nilable_proc(prop, accessor_key, non_nil_type, klass)
+        [
+          proc do |val|
+            unless val.nil? || val.is_a?(non_nil_type)
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                T::Utils.coerce(non_nil_type),
+                val,
+              )
+            end
+            instance_variable_set(accessor_key, val)
+          end,
+          proc do |val|
+            unless val.nil? || val.is_a?(non_nil_type)
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                T::Utils.coerce(non_nil_type),
+                val,
+              )
+            end
+          end,
+        ]
+      end
+
+      sig do
+        params(
+          prop: Symbol,
+          accessor_key: Symbol,
+          non_nil_type: T::Types::Base,
+          klass: T.all(Module, T::Props::ClassMethods),
+          validate: T.nilable(ValidateProc),
+        )
+        .returns([SetterProc, ValueValidationProc])
+      end
+      private_class_method def self.nilable_proc(prop, accessor_key, non_nil_type, klass, validate)
+        [
+          proc do |val|
+            if val.nil?
+              instance_variable_set(accessor_key, nil)
+            # this use of recursively_valid? is intentional: unlike for
+            # methods, we want to make sure data at the 'edge'
+            # (e.g. models that go into databases or structs serialized
+            # from disk) are correct, so we use more thorough runtime
+            # checks there
+            elsif non_nil_type.recursively_valid?(val)
+              validate&.call(prop, val)
+              instance_variable_set(accessor_key, val)
+            else
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                non_nil_type,
+                val,
+              )
+              instance_variable_set(accessor_key, val)
+            end
+          end,
+          proc do |val|
+            if val.nil?
+            # this use of recursively_valid? is intentional: unlike for
+            # methods, we want to make sure data at the 'edge'
+            # (e.g. models that go into databases or structs serialized
+            # from disk) are correct, so we use more thorough runtime
+            # checks there
+            elsif non_nil_type.recursively_valid?(val)
+              validate&.call(prop, val)
+            else
+              T::Props::Private::SetterFactory.raise_pretty_error(
+                klass,
+                prop,
+                non_nil_type,
+                val,
+              )
+            end
+          end,
+        ]
+      end
+
+      sig do
+        params(
+          klass: T.all(Module, T::Props::ClassMethods),
+          prop: Symbol,
+          type: T.any(T::Types::Base, Module),
+          val: T.untyped,
+        )
+        .void
+      end
+      def self.raise_pretty_error(klass, prop, type, val)
+        base_message = "Can't set #{klass.name}.#{prop} to #{val.inspect} (instance of #{val.class}) - need a #{type}"
+
+        pretty_message = "Parameter '#{prop}': #{base_message}\n"
+        caller_loc = caller_locations.find {|l| !l.to_s.include?('sorbet-runtime/lib/types/props')}
+        if caller_loc
+          pretty_message += "Caller: #{caller_loc.path}:#{caller_loc.lineno}\n"
+        end
+
+        T::Configuration.call_validation_error_handler(
+          nil,
+          message: base_message,
+          pretty_message: pretty_message,
+          kind: 'Parameter',
+          name: prop,
+          type: type,
+          value: val,
+          location: caller_loc,
+        )
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/serializable.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/serializable.rb
similarity index 88%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/serializable.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/serializable.rb
index 2e2ea1b749f93..6a58b8664bd3b 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/serializable.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/serializable.rb
@@ -223,9 +223,10 @@ def serialized_form_prop(serialized_form)
   end
 
   def add_prop_definition(prop, rules)
-    rules[:serialized_form] = rules.fetch(:name, prop.to_s)
+    serialized_form = rules.fetch(:name, prop.to_s)
+    rules[:serialized_form] = serialized_form
     res = super
-    prop_by_serialized_forms[rules[:serialized_form]] = prop
+    prop_by_serialized_forms[serialized_form] = prop
     if T::Configuration.use_vm_prop_serde?
       enqueue_lazy_vm_method_definition!(:__t_props_generated_serialize) {generate_serialize2}
       enqueue_lazy_vm_method_definition!(:__t_props_generated_deserialize) {generate_deserialize2}
@@ -260,10 +261,31 @@ def add_prop_definition(prop, rules)
   end
 
   def message_with_generated_source_context(error, generated_method, generate_source_method)
-    line_label = error.backtrace.find {|l| l.end_with?("in `#{generated_method}'")}
-    return unless line_label
+    generated_method = generated_method.to_s
+    if error.backtrace_locations
+      line_loc = error.backtrace_locations.find {|l| l.base_label == generated_method}
+      return unless line_loc
 
-    line_num = line_label.split(':')[1]&.to_i
+      line_num = line_loc.lineno
+    else
+      label = if RUBY_VERSION >= "3.4"
+        # in 'ClassName#__t_props_generated_serialize'"
+        "##{generated_method}'"
+      else
+        # in `__t_props_generated_serialize'"
+        "in `#{generated_method}'"
+      end
+      line_label = error.backtrace.find {|l| l.end_with?(label)}
+      return unless line_label
+
+      line_num = if line_label.start_with?("(eval)")
+        # (eval):13:in ...
+        line_label.split(':')[1]&.to_i
+      else
+        # (eval at /Users/jez/stripe/sorbet/gems/sorbet-runtime/lib/types/props/has_lazily_specialized_methods.rb:65):13:in ...
+        line_label.split(':')[2]&.to_i
+      end
+    end
     return unless line_num
 
     source_lines = self.send(generate_source_method).split("\n")
@@ -338,14 +360,21 @@ def extra_props(instance)
     end
   end
 
-  # overrides T::Props::PrettyPrintable
-  private def inspect_instance_components(instance, multiline:, indent:)
+  # adds to the default result of T::Props::PrettyPrintable
+  def pretty_print_extra(instance, pp)
+    # This is to maintain backwards compatibility with Stripe's codebase, where only the single line (through `inspect`)
+    # version is expected to add anything extra
+    return if !pp.is_a?(PP::SingleLine)
     if (extra_props = extra_props(instance)) && !extra_props.empty?
-      pretty_kvs = extra_props.map {|k, v| [k.to_sym, v.inspect]}
-      extra = join_props_with_pretty_values(pretty_kvs, multiline: false)
-      super + ["@_extra_props=<#{extra}>"]
-    else
-      super
+      pp.breakable
+      pp.text("@_extra_props=")
+      pp.group(1, "<", ">") do
+        extra_props.each_with_index do |(prop, value), i|
+          pp.breakable unless i.zero?
+          pp.text("#{prop}=")
+          value.pretty_print(pp)
+        end
+      end
     end
   end
 end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/type_validation.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/type_validation.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/type_validation.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/type_validation.rb
index ae3557783d85a..8a7dc9a4df099 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/type_validation.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/type_validation.rb
@@ -16,6 +16,7 @@ def valid_rule_key?(key)
       super || key == :DEPRECATED_underspecified_type
     end
 
+    # checked(:never) - Rules hash is expensive to check
     sig do
       params(
         name: T.any(Symbol, String),
@@ -24,12 +25,13 @@ def valid_rule_key?(key)
         type: T.any(T::Types::Base, Module)
       )
       .void
+      .checked(:never)
     end
     def prop_validate_definition!(name, _cls, rules, type)
       super
 
       if !rules[:DEPRECATED_underspecified_type]
-        validate_type(type, field_name: name)
+        validate_type(type, name)
       elsif rules[:DEPRECATED_underspecified_type] && find_invalid_subtype(type).nil?
         raise ArgumentError.new("DEPRECATED_underspecified_type set unnecessarily for #{@class.name}.#{name} - #{type} is a valid type")
       end
@@ -41,8 +43,9 @@ def prop_validate_definition!(name, _cls, rules, type)
         field_name: T.any(Symbol, String),
       )
       .void
+      .checked(:never)
     end
-    private def validate_type(type, field_name:)
+    private def validate_type(type, field_name)
       if (invalid_subtype = find_invalid_subtype(type))
         raise UnderspecifiedType.new(type_error_message(invalid_subtype, field_name, type))
       end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/utils.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/utils.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/utils.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/utils.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/weak_constructor.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/weak_constructor.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/props/weak_constructor.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/props/weak_constructor.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/sig.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/sig.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/sig.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/sig.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/struct.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/struct.rb
new file mode 100644
index 0000000000000..3ca17fe459e93
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/struct.rb
@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+# typed: true
+
+class T::InexactStruct
+  include T::Props
+  include T::Props::Serializable
+  include T::Props::Constructor
+end
+
+class T::Struct < T::InexactStruct
+  def self.inherited(subclass)
+    super(subclass)
+    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited, true) do |s|
+      super(s)
+      raise "#{self.name} is a subclass of T::Struct and cannot be subclassed"
+    end
+  end
+end
+
+class T::ImmutableStruct < T::InexactStruct
+  extend T::Sig
+
+  def self.inherited(subclass)
+    super(subclass)
+
+    T::Private::ClassUtils.replace_method(subclass.singleton_class, :inherited, true) do |s|
+      super(s)
+      raise "#{self.name} is a subclass of T::ImmutableStruct and cannot be subclassed"
+    end
+  end
+
+  # Matches the one in WeakConstructor, but freezes the object
+  sig {params(hash: T::Hash[Symbol, T.untyped]).void.checked(:never)}
+  def initialize(hash={})
+    super
+
+    freeze
+  end
+
+  # Matches the signature in Props, but raises since this is an immutable struct and only const is allowed
+  sig {params(name: Symbol, cls: T.untyped, rules: T.untyped).void}
+  def self.prop(name, cls, **rules)
+    return super if (cls.is_a?(Hash) && cls[:immutable]) || rules[:immutable]
+
+    raise "Cannot use `prop` in #{self.name} because it is an immutable struct. Use `const` instead"
+  end
+
+  def with(changed_props)
+    raise "Cannot use `with` in #{self.class.name} because it is an immutable struct"
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/anything.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/anything.rb
new file mode 100644
index 0000000000000..65f33ad49d386
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/anything.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # The top type
+  class Anything < Base
+    def initialize; end
+
+    def build_type
+      nil
+    end
+
+    # overrides Base
+    def name
+      "T.anything"
+    end
+
+    # overrides Base
+    def valid?(obj)
+      true
+    end
+
+    # overrides Base
+    private def subtype_of_single?(other)
+      case other
+      when T::Types::Anything then true
+      else false
+      end
+    end
+
+    module Private
+      INSTANCE = Anything.new.freeze
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/attached_class.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/attached_class.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/attached_class.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/attached_class.rb
index 059956a68d0a5..dbfc3a6a3f50c 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/attached_class.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/attached_class.rb
@@ -10,6 +10,10 @@ class AttachedClassType < Base
 
     def initialize(); end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.attached_class"
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/base.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/base.rb
new file mode 100644
index 0000000000000..b3a882553b9d5
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/base.rb
@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class Base
+    def self.method_added(method_name)
+      super(method_name)
+      # What is now `subtype_of_single?` used to be named `subtype_of?`. Make sure people don't
+      # override the wrong thing.
+      #
+      # NB: Outside of T::Types, we would enforce this by using `sig` and not declaring the method
+      # as overridable, but doing so here would result in a dependency cycle.
+      if method_name == :subtype_of? && self != T::Types::Base
+        raise "`subtype_of?` should not be overridden. You probably want to override " \
+              "`subtype_of_single?` instead."
+      end
+    end
+
+    # this will be redefined in certain subclasses
+    def recursively_valid?(obj)
+      valid?(obj)
+    end
+
+    define_method(:valid?) do |_obj|
+      raise NotImplementedError
+    end
+
+    # @return [T::Boolean] This method must be implemented to return whether the subclass is a subtype
+    # of `type`. This should only be called by `subtype_of?`, which guarantees that `type` will be
+    # a "single" type, by which we mean it won't be a Union or an Intersection (c.f.
+    # `isSubTypeSingle` in sorbet).
+    private def subtype_of_single?(type)
+      raise NotImplementedError
+    end
+
+    # Force any lazy initialization that this type might need to do
+    # It's unusual to call this directly; you probably want to call it indirectly via `T::Utils.run_all_sig_blocks`.
+    define_method(:build_type) do
+      raise NotImplementedError
+    end
+
+    # Equality is based on name, so be sure the name reflects all relevant state when implementing.
+    define_method(:name) do
+      raise NotImplementedError
+    end
+
+    # Mirrors ruby_typer::core::Types::isSubType
+    # See https://git.corp.stripe.com/stripe-internal/ruby-typer/blob/9fc8ed998c04ac0b96592ae6bb3493b8a925c5c1/core/types/subtyping.cc#L912-L950
+    #
+    # This method cannot be overridden (see `method_added` above).
+    # Subclasses only need to implement `subtype_of_single?`).
+    def subtype_of?(t2)
+      t1 = self
+
+      if t2.is_a?(T::Private::Types::TypeAlias)
+        t2 = t2.aliased_type
+      end
+
+      if t2.is_a?(T::Types::Anything)
+        return true
+      end
+
+      if t1.is_a?(T::Private::Types::TypeAlias)
+        return t1.aliased_type.subtype_of?(t2)
+      end
+
+      if t1.is_a?(T::Types::TypeVariable) || t2.is_a?(T::Types::TypeVariable)
+        # Generics are erased at runtime. Let's treat them like `T.untyped` for
+        # the purpose of things like override checking.
+        return true
+      end
+
+      # pairs to cover: 1  (_, _)
+      #                 2  (_, And)
+      #                 3  (_, Or)
+      #                 4  (And, _)
+      #                 5  (And, And)
+      #                 6  (And, Or)
+      #                 7  (Or, _)
+      #                 8  (Or, And)
+      #                 9  (Or, Or)
+
+      # Note: order of cases here matters!
+      if t1.is_a?(T::Types::Union) # 7, 8, 9
+        # this will be incorrect if/when we have Type members
+        return t1.types.all? {|t1_member| t1_member.subtype_of?(t2)}
+      end
+
+      if t2.is_a?(T::Types::Intersection) # 2, 5
+        # this will be incorrect if/when we have Type members
+        return t2.types.all? {|t2_member| t1.subtype_of?(t2_member)}
+      end
+
+      if t2.is_a?(T::Types::Union)
+        if t1.is_a?(T::Types::Intersection) # 6
+          # dropping either of parts eagerly make subtype test be too strict.
+          # we have to try both cases, when we normally try only one
+          return t2.types.any? {|t2_member| t1.subtype_of?(t2_member)} ||
+              t1.types.any? {|t1_member| t1_member.subtype_of?(t2)}
+        end
+        return t2.types.any? {|t2_member| t1.subtype_of?(t2_member)} # 3
+      end
+
+      if t1.is_a?(T::Types::Intersection) # 4
+        # this will be incorrect if/when we have Type members
+        return t1.types.any? {|t1_member| t1_member.subtype_of?(t2)}
+      end
+
+      # 1; Start with some special cases
+      if t1.is_a?(T::Private::Types::Void)
+        return t2.is_a?(T::Private::Types::Void)
+      end
+
+      if t1.is_a?(T::Types::Untyped) || t2.is_a?(T::Types::Untyped)
+        return true
+      end
+
+      # Rest of (1)
+      subtype_of_single?(t2)
+    end
+
+    def to_s
+      name
+    end
+
+    def describe_obj(obj)
+      # Would be redundant to print class and value in these common cases.
+      case obj
+      when nil, true, false
+        return "type #{obj.class}"
+      end
+
+      # In rare cases, obj.inspect may fail, or be undefined, so rescue.
+      begin
+        # Default inspect behavior of, eg; `#<Object:0x0...>` is ugly; just print the hash instead, which is more concise/readable.
+        if obj.method(:inspect).owner == Kernel
+          "type #{obj.class} with hash #{obj.hash}"
+        elsif T::Configuration.include_value_in_type_errors?
+          "type #{obj.class} with value #{T::Utils.string_truncate_middle(obj.inspect, 30, 30)}"
+        else
+          "type #{obj.class}"
+        end
+      rescue StandardError, SystemStackError
+        "type #{obj.class} with unprintable value"
+      end
+    end
+
+    def error_message_for_obj(obj)
+      if valid?(obj)
+        nil
+      else
+        error_message(obj)
+      end
+    end
+
+    def error_message_for_obj_recursive(obj)
+      if recursively_valid?(obj)
+        nil
+      else
+        error_message(obj)
+      end
+    end
+
+    private def error_message(obj)
+      "Expected type #{self.name}, got #{describe_obj(obj)}"
+    end
+
+    def validate!(obj)
+      err = error_message_for_obj(obj)
+      raise TypeError.new(err) if err
+    end
+
+    ### Equality methods (necessary for deduping types with `uniq`)
+
+    def hash
+      name.hash
+    end
+
+    # Type equivalence, defined by serializing the type to a string (with
+    # `#name`) and comparing the resulting strings for equality.
+    def ==(other)
+      case other
+      when T::Types::Base
+        other.name == self.name
+      else
+        false
+      end
+    end
+
+    alias_method :eql?, :==
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/class_of.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/class_of.rb
new file mode 100644
index 0000000000000..e8d53a28cefae
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/class_of.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Validates that an object belongs to the specified class.
+  class ClassOf < Base
+    attr_reader :type
+
+    def initialize(type)
+      @type = type
+    end
+
+    def build_type
+      nil
+    end
+
+    # overrides Base
+    def name
+      "T.class_of(#{@type})"
+    end
+
+    # overrides Base
+    def valid?(obj)
+      obj.is_a?(Module) && (obj <= @type || false)
+    end
+
+    # overrides Base
+    def subtype_of_single?(other)
+      case other
+      when ClassOf
+        @type <= other.type
+      when Simple
+        @type.is_a?(other.raw_type)
+      when TypedClass
+        @type.is_a?(other.underlying_class)
+      else
+        false
+      end
+    end
+
+    # overrides Base
+    def describe_obj(obj)
+      obj.inspect
+    end
+
+    # So that `T.class_of(...)[...]` syntax is valid.
+    # Mirrors the definition of T::Generic#[] (generics are erased).
+    #
+    # We avoid simply writing `include T::Generic` because we don't want any of
+    # the other methods to appear (`T.class_of(A).type_member` doesn't make sense)
+    def [](*types)
+      self
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/enum.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/enum.rb
new file mode 100644
index 0000000000000..34eb26f51d254
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/enum.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # validates that the provided value is within a given set/enum
+  class Enum < Base
+    extend T::Sig
+
+    attr_reader :values
+
+    def initialize(values)
+      @values = values
+    end
+
+    def build_type
+      nil
+    end
+
+    # overrides Base
+    def valid?(obj)
+      @values.member?(obj)
+    end
+
+    # overrides Base
+    private def subtype_of_single?(other)
+      case other
+      when Enum
+        (other.values - @values).empty?
+      else
+        false
+      end
+    end
+
+    # overrides Base
+    def name
+      @name ||= "T.deprecated_enum([#{@values.map(&:inspect).sort.join(', ')}])"
+    end
+
+    # overrides Base
+    def describe_obj(obj)
+      obj.inspect
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/fixed_array.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/fixed_array.rb
new file mode 100644
index 0000000000000..967273d99f84f
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/fixed_array.rb
@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+# https://jira.corp.stripe.com/browse/RUBYPLAT-1107
+# typed: false
+
+module T::Types
+  # Takes a list of types. Validates each item in an array using the type in the same position
+  # in the list.
+  class FixedArray < Base
+    def initialize(types)
+      @inner_types = types
+    end
+
+    def types
+      @types ||= @inner_types.map {|type| T::Utils.coerce(type)}
+    end
+
+    def build_type
+      types
+      nil
+    end
+
+    # overrides Base
+    def name
+      "[#{types.join(', ')}]"
+    end
+
+    # overrides Base
+    def recursively_valid?(obj)
+      if obj.is_a?(Array) && obj.length == types.length
+        i = 0
+        while i < types.length
+          if !types[i].recursively_valid?(obj[i])
+            return false
+          end
+          i += 1
+        end
+        true
+      else
+        false
+      end
+    end
+
+    # overrides Base
+    def valid?(obj)
+      if obj.is_a?(Array) && obj.length == types.length
+        i = 0
+        while i < types.length
+          if !types[i].valid?(obj[i])
+            return false
+          end
+          i += 1
+        end
+        true
+      else
+        false
+      end
+    end
+
+    # overrides Base
+    private def subtype_of_single?(other)
+      case other
+      when FixedArray
+        # Properly speaking, covariance here is unsound since arrays
+        # can be mutated, but sorbet implements covariant tuples for
+        # ease of adoption.
+        types.size == other.types.size && types.zip(other.types).all? do |t1, t2|
+          t1.subtype_of?(t2)
+        end
+      when TypedArray
+        # warning: covariant arrays
+
+        value1, value2, *values_rest = types
+        value_type = if !value2.nil?
+          T::Types::Union::Private::Pool.union_of_types(value1, value2, values_rest)
+        elsif value1.nil?
+          T.untyped
+        else
+          value1
+        end
+
+        T::Types::TypedArray.new(value_type).subtype_of?(other)
+      else
+        false
+      end
+    end
+
+    # This gives us better errors, e.g.:
+    # "Expected [String, Symbol], got [String, String]"
+    # instead of
+    # "Expected [String, Symbol], got Array".
+    #
+    # overrides Base
+    def describe_obj(obj)
+      if obj.is_a?(Array)
+        if obj.length == types.length
+          item_classes = obj.map(&:class).join(', ')
+          "type [#{item_classes}]"
+        else
+          "array of size #{obj.length}"
+        end
+      else
+        super
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/fixed_hash.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/fixed_hash.rb
new file mode 100644
index 0000000000000..2bb805be5a160
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/fixed_hash.rb
@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Takes a hash of types. Validates each item in a hash using the type in the same position
+  # in the list.
+  class FixedHash < Base
+    def initialize(types)
+      @inner_types = types
+    end
+
+    def types
+      @types ||= @inner_types.transform_values {|v| T::Utils.coerce(v)}
+    end
+
+    def build_type
+      types
+      nil
+    end
+
+    # overrides Base
+    def name
+      serialize_hash(types)
+    end
+
+    # overrides Base
+    def recursively_valid?(obj)
+      return false unless obj.is_a?(Hash)
+      return false if types.any? {|key, type| !type.recursively_valid?(obj[key])}
+      return false if obj.any? {|key, _| !types[key]}
+      true
+    end
+
+    # overrides Base
+    def valid?(obj)
+      return false unless obj.is_a?(Hash)
+      return false if types.any? {|key, type| !type.valid?(obj[key])}
+      return false if obj.any? {|key, _| !types[key]}
+      true
+    end
+
+    # overrides Base
+    private def subtype_of_single?(other)
+      case other
+      when FixedHash
+        # Using `subtype_of?` here instead of == would be unsound
+        types == other.types
+      when TypedHash
+        # warning: covariant hashes
+
+        key1, key2, *keys_rest = types.keys.map {|key| T::Utils.coerce(key.class)}
+        key_type = if !key2.nil?
+          T::Types::Union::Private::Pool.union_of_types(key1, key2, keys_rest)
+        elsif key1.nil?
+          T.untyped
+        else
+          key1
+        end
+
+        value1, value2, *values_rest = types.values
+        value_type = if !value2.nil?
+          T::Types::Union::Private::Pool.union_of_types(value1, value2, values_rest)
+        elsif value1.nil?
+          T.untyped
+        else
+          value1
+        end
+
+        T::Types::TypedHash.new(keys: key_type, values: value_type).subtype_of?(other)
+      else
+        false
+      end
+    end
+
+    # This gives us better errors, e.g.:
+    # `Expected {a: String}, got {a: TrueClass}`
+    # instead of
+    # `Expected {a: String}, got Hash`.
+    #
+    # overrides Base
+    def describe_obj(obj)
+      if obj.is_a?(Hash)
+        "type #{serialize_hash(obj.transform_values(&:class))}"
+      else
+        super
+      end
+    end
+
+    private
+
+    def serialize_hash(hash)
+      entries = hash.map do |(k, v)|
+        if Symbol === k && ":#{k}" == k.inspect
+          "#{k}: #{v}"
+        else
+          "#{k.inspect} => #{v}"
+        end
+      end
+
+      "{#{entries.join(', ')}}"
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/intersection.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/intersection.rb
new file mode 100644
index 0000000000000..bc17acbb79568
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/intersection.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Takes a list of types. Validates that an object matches all of the types.
+  class Intersection < Base
+    def initialize(types)
+      @inner_types = types
+    end
+
+    def types
+      @types ||= @inner_types.flat_map do |type|
+        type = T::Utils.resolve_alias(type)
+        if type.is_a?(Intersection)
+          # Simplify nested intersections (mostly so `name` returns a nicer value)
+          type.types
+        else
+          T::Utils.coerce(type)
+        end
+      end.uniq
+    end
+
+    def build_type
+      types
+      nil
+    end
+
+    # overrides Base
+    def name
+      "T.all(#{types.map(&:name).compact.sort.join(', ')})"
+    end
+
+    # overrides Base
+    def recursively_valid?(obj)
+      types.all? {|type| type.recursively_valid?(obj)}
+    end
+
+    # overrides Base
+    def valid?(obj)
+      types.all? {|type| type.valid?(obj)}
+    end
+
+    # overrides Base
+    private def subtype_of_single?(other)
+      raise "This should never be reached if you're going through `subtype_of?` (and you should be)"
+    end
+
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/noreturn.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/noreturn.rb
similarity index 91%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/noreturn.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/noreturn.rb
index c28579748013d..6e0088db65e49 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/noreturn.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/noreturn.rb
@@ -4,9 +4,12 @@
 module T::Types
   # The bottom type
   class NoReturn < Base
-
     def initialize; end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.noreturn"
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/proc.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/proc.rb
new file mode 100644
index 0000000000000..91642ac8cb038
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/proc.rb
@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Defines the type of a proc (a ruby callable). At runtime, only
+  # validates that the value is a `::Proc`.
+  #
+  # At present, we only support fixed-arity procs with no optional or
+  # keyword arguments.
+  class Proc < Base
+    def initialize(arg_types, returns)
+      @inner_arg_types = arg_types
+      @inner_returns = returns
+    end
+
+    def arg_types
+      @arg_types ||= @inner_arg_types.transform_values do |raw_type|
+        T::Utils.coerce(raw_type)
+      end
+    end
+
+    def returns
+      @returns ||= T::Utils.coerce(@inner_returns)
+    end
+
+    def build_type
+      arg_types
+      returns
+      nil
+    end
+
+    # overrides Base
+    def name
+      args = []
+      arg_types.each do |k, v|
+        args << "#{k}: #{v.name}"
+      end
+      "T.proc.params(#{args.join(', ')}).returns(#{returns})"
+    end
+
+    # overrides Base
+    def valid?(obj)
+      obj.is_a?(::Proc)
+    end
+
+    # overrides Base
+    private def subtype_of_single?(other)
+      case other
+      when self.class
+        if arg_types.size != other.arg_types.size
+          return false
+        end
+        arg_types.values.zip(other.arg_types.values).all? do |a, b|
+          !b.nil? && b.subtype_of?(a)
+        end && returns.subtype_of?(other.returns)
+      else
+        false
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/self_type.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/self_type.rb
similarity index 94%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/self_type.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/self_type.rb
index e431a3e0f933e..f1eafc06c35fc 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/self_type.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/self_type.rb
@@ -8,6 +8,10 @@ class SelfType < Base
 
     def initialize(); end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.self_type"
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/simple.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/simple.rb
new file mode 100644
index 0000000000000..5bacd1c6dd771
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/simple.rb
@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Validates that an object belongs to the specified class.
+  class Simple < Base
+    NAME_METHOD = Module.instance_method(:name)
+    private_constant(:NAME_METHOD)
+
+    attr_reader :raw_type
+
+    def initialize(raw_type)
+      @raw_type = raw_type
+    end
+
+    def build_type
+      nil
+    end
+
+    # overrides Base
+    def name
+      # Memoize to mitigate pathological performance with anonymous modules (https://bugs.ruby-lang.org/issues/11119)
+      #
+      # `name` isn't normally a hot path for types, but it is used in initializing a T::Types::Union,
+      # and so in `T.nilable`, and so in runtime constructions like `x = T.let(nil, T.nilable(Integer))`.
+      #
+      # Care more about back compat than we do about performance here.
+      # Once 2.6 is well in the rear view mirror, we can replace this.
+      # rubocop:disable Performance/BindCall
+      @name ||= (NAME_METHOD.bind(@raw_type).call || @raw_type.name).freeze
+      # rubocop:enable Performance/BindCall
+    end
+
+    # overrides Base
+    def valid?(obj)
+      obj.is_a?(@raw_type)
+    end
+
+    # overrides Base
+    private def subtype_of_single?(other)
+      case other
+      when Simple
+        @raw_type <= other.raw_type
+      when TypedClass
+        # This case is a bit odd--we would have liked to solve this like we do
+        # for `T::Array` et al., but don't for backwards compatibility.
+        # See `type_for_module` below.
+        @raw_type <= other.underlying_class
+      else
+        false
+      end
+    end
+
+    # overrides Base
+    private def error_message(obj)
+      error_message = super(obj)
+      actual_name = obj.class.name
+
+      return error_message unless name == actual_name
+
+      <<~MSG.strip
+        #{error_message}
+
+        The expected type and received object type have the same name but refer to different constants.
+        Expected type is #{name} with object id #{@raw_type.__id__}, but received type is #{actual_name} with object id #{obj.class.__id__}.
+
+        There might be a constant reloading problem in your application.
+      MSG
+    end
+
+    def to_nilable
+      @nilable ||= T::Private::Types::SimplePairUnion.new(
+        self,
+        T::Utils::Nilable::NIL_TYPE,
+      )
+    end
+
+    module Private
+      module Pool
+        CACHE_FROZEN_OBJECTS = begin
+          ObjectSpace::WeakMap.new[1] = 1
+          true # Ruby 2.7 and newer
+                               rescue ArgumentError # Ruby 2.6 and older
+                                 false
+        end
+
+        @cache = ObjectSpace::WeakMap.new
+
+        def self.type_for_module(mod)
+          cached = @cache[mod]
+          return cached if cached
+
+          type = if mod == ::Array
+            T::Array[T.untyped]
+          elsif mod == ::Hash
+            T::Hash[T.untyped, T.untyped]
+          elsif mod == ::Enumerable
+            T::Enumerable[T.untyped]
+          elsif mod == ::Enumerator
+            T::Enumerator[T.untyped]
+          elsif mod == ::Range
+            T::Range[T.untyped]
+          elsif !Object.autoload?(:Set) && Object.const_defined?(:Set) && mod == ::Set
+            T::Set[T.untyped]
+          else
+            # ideally we would have a case mapping from ::Class -> T::Class here
+            # but for backwards compatibility we don't have that, and instead
+            # have a special case in subtype_of_single?
+            Simple.new(mod)
+          end
+
+          # Unfortunately, we still need to check if the module is frozen,
+          # since on 2.6 and older WeakMap adds a finalizer to the key that is added
+          # to the map, so that it can clear the map entry when the key is
+          # garbage collected.
+          # For a frozen object, though, adding a finalizer is not a valid
+          # operation, so this still raises if `mod` is frozen.
+          if CACHE_FROZEN_OBJECTS || (!mod.frozen? && !type.frozen?)
+            @cache[mod] = type
+          end
+          type
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/t_enum.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/t_enum.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/t_enum.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/t_enum.rb
index 121368c7b6078..be5deb5b1b04b 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/t_enum.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/t_enum.rb
@@ -10,6 +10,10 @@ def initialize(val)
       @val = val
     end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       # Strips the #<...> off, just leaving the ...
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/type_member.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/type_member.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/type_member.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/type_member.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/type_parameter.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/type_parameter.rb
new file mode 100644
index 0000000000000..ed80363a9f696
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/type_parameter.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypeParameter < Base
+    module Private
+      @pool = {}
+
+      def self.cached_entry(name)
+        @pool[name]
+      end
+
+      def self.set_entry_for(name, type)
+        @pool[name] = type
+      end
+    end
+
+    def initialize(name)
+      raise ArgumentError.new("not a symbol: #{name}") unless name.is_a?(Symbol)
+      @name = name
+    end
+
+    def build_type
+      nil
+    end
+
+    def self.make(name)
+      cached = Private.cached_entry(name)
+      return cached if cached
+
+      Private.set_entry_for(name, new(name))
+    end
+
+    def valid?(obj)
+      true
+    end
+
+    def subtype_of_single?(type)
+      true
+    end
+
+    def name
+      "T.type_parameter(:#{@name})"
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/type_template.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/type_template.rb
similarity index 100%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/type_template.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/type_template.rb
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/type_variable.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/type_variable.rb
similarity index 95%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/type_variable.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/type_variable.rb
index 187119167dbe7..60222bb6ec55b 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/type_variable.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/type_variable.rb
@@ -19,6 +19,10 @@ def initialize(variance)
       @variance = variance
     end
 
+    def build_type
+      nil
+    end
+
     def valid?(obj)
       true
     end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_array.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_array.rb
new file mode 100644
index 0000000000000..04589b1ceac94
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_array.rb
@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedArray < TypedEnumerable
+    # overrides Base
+    def name
+      "T::Array[#{type.name}]"
+    end
+
+    def underlying_class
+      Array
+    end
+
+    # overrides Base
+    def recursively_valid?(obj)
+      obj.is_a?(Array) && super
+    end
+
+    # overrides Base
+    def valid?(obj)
+      obj.is_a?(Array)
+    end
+
+    def new(*args)
+      Array.new(*T.unsafe(args))
+    end
+
+    module Private
+      module Pool
+        CACHE_FROZEN_OBJECTS = begin
+          ObjectSpace::WeakMap.new[1] = 1
+          true # Ruby 2.7 and newer
+                               rescue ArgumentError # Ruby 2.6 and older
+                                 false
+        end
+
+        @cache = ObjectSpace::WeakMap.new
+
+        def self.type_for_module(mod)
+          cached = @cache[mod]
+          return cached if cached
+
+          type = TypedArray.new(mod)
+
+          if CACHE_FROZEN_OBJECTS || (!mod.frozen? && !type.frozen?)
+            @cache[mod] = type
+          end
+          type
+        end
+      end
+    end
+
+    class Untyped < TypedArray
+      def initialize
+        super(T::Types::Untyped::Private::INSTANCE)
+      end
+
+      def valid?(obj)
+        obj.is_a?(Array)
+      end
+
+      def freeze
+        build_type # force lazy initialization before freezing the object
+        super
+      end
+
+      module Private
+        INSTANCE = Untyped.new.freeze
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_class.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_class.rb
new file mode 100644
index 0000000000000..eeffcc27b13b4
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_class.rb
@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedClass < T::Types::Base
+    def initialize(type)
+      @inner_type = type
+    end
+
+    def type
+      @type ||= T::Utils.coerce(@inner_type)
+    end
+
+    def build_type
+      type
+      nil
+    end
+
+    # overrides Base
+    def name
+      "T::Class[#{type.name}]"
+    end
+
+    def underlying_class
+      Class
+    end
+
+    # overrides Base
+    def valid?(obj)
+      Class.===(obj)
+    end
+
+    # overrides Base
+    private def subtype_of_single?(type)
+      case type
+      when TypedClass
+        # treat like generics are erased
+        true
+      when Simple
+        Class <= type.raw_type
+      else
+        false
+      end
+    end
+
+    module Private
+      module Pool
+        CACHE_FROZEN_OBJECTS =
+          begin
+            ObjectSpace::WeakMap.new[1] = 1
+            true # Ruby 2.7 and newer
+          rescue ArgumentError
+            false # Ruby 2.6 and older
+          end
+
+        @cache = ObjectSpace::WeakMap.new
+
+        def self.type_for_module(mod)
+          cached = @cache[mod]
+          return cached if cached
+
+          type = TypedClass.new(mod)
+
+          if CACHE_FROZEN_OBJECTS || (!mod.frozen? && !type.frozen?)
+            @cache[mod] = type
+          end
+          type
+        end
+      end
+    end
+
+    class Untyped < TypedClass
+      def initialize
+        super(T::Types::Untyped::Private::INSTANCE)
+      end
+
+      def freeze
+        build_type # force lazy initialization before freezing the object
+        super
+      end
+
+      module Private
+        INSTANCE = Untyped.new.freeze
+      end
+    end
+
+    class Anything < TypedClass
+      def initialize
+        super(T.anything)
+      end
+
+      def freeze
+        build_type # force lazy initialization before freezing the object
+        super
+      end
+
+      module Private
+        INSTANCE = Anything.new.freeze
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_enumerable.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_enumerable.rb
similarity index 80%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_enumerable.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_enumerable.rb
index 65c2631f0a711..8fc0c3fba7758 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_enumerable.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_enumerable.rb
@@ -6,10 +6,17 @@ module T::Types
   # `case` statement below in `describe_obj` in order to get better
   # error messages.
   class TypedEnumerable < Base
-    attr_reader :type
-
     def initialize(type)
-      @type = T::Utils.coerce(type)
+      @inner_type = type
+    end
+
+    def type
+      @type ||= T::Utils.coerce(@inner_type)
+    end
+
+    def build_type
+      type
+      nil
     end
 
     def underlying_class
@@ -18,7 +25,7 @@ def underlying_class
 
     # overrides Base
     def name
-      "T::Enumerable[#{@type.name}]"
+      "T::Enumerable[#{type.name}]"
     end
 
     # overrides Base
@@ -34,26 +41,28 @@ def recursively_valid?(obj)
         begin
           it = 0
           while it < obj.count
-            return false unless @type.recursively_valid?(obj[it])
+            return false unless type.recursively_valid?(obj[it])
             it += 1
           end
           true
         end
       when Hash
-        return false unless @type.is_a?(FixedArray)
-        types = @type.types
-        return false if types.count != 2
-        key_type = types[0]
-        value_type = types[1]
+        type_ = self.type
+        return false unless type_.is_a?(FixedArray)
+        key_type, value_type = type_.types
+        return false if key_type.nil? || value_type.nil? || type_.types.size > 2
         obj.each_pair do |key, val|
           # Some objects (I'm looking at you Rack::Utils::HeaderHash) don't
-          # iterate over a [key, value] array, so we can't juse use the @type.recursively_valid?(v)
+          # iterate over a [key, value] array, so we can't just use the type.recursively_valid?(v)
           return false if !key_type.recursively_valid?(key) || !value_type.recursively_valid?(val)
         end
         true
       when Enumerator::Lazy
         # Enumerators can be unbounded: see `[:foo, :bar].cycle`
         true
+      when Enumerator::Chain
+        # Enumerators can be unbounded: see `[:foo, :bar].cycle`
+        true
       when Enumerator
         # Enumerators can be unbounded: see `[:foo, :bar].cycle`
         true
@@ -62,10 +71,10 @@ def recursively_valid?(obj)
         # boundlessness, it does not express a type. For example `(nil...nil)` is not a T::Range[NilClass], its a range
         # of unknown types (T::Range[T.untyped]).
         # Similarly, `(nil...1)` is not a `T::Range[T.nilable(Integer)]`, it's a boundless range of Integer.
-        (obj.begin.nil? || @type.recursively_valid?(obj.begin)) && (obj.end.nil? || @type.recursively_valid?(obj.end))
+        (obj.begin.nil? || type.recursively_valid?(obj.begin)) && (obj.end.nil? || type.recursively_valid?(obj.end))
       when Set
         obj.each do |item|
-          return false unless @type.recursively_valid?(item)
+          return false unless type.recursively_valid?(item)
         end
 
         true
@@ -87,7 +96,9 @@ def recursively_valid?(obj)
         # should be invariant because they are mutable and support
         # both reading and writing. However, Sorbet treats *all*
         # Enumerable subclasses as covariant for ease of adoption.
-        @type.subtype_of?(other.type)
+        type.subtype_of?(other.type)
+      elsif other.class <= Simple
+        underlying_class <= other.raw_type
       else
         false
       end
@@ -145,6 +156,8 @@ def describe_obj(obj)
         end
       when Enumerator::Lazy
         T::Enumerator::Lazy[type_from_instances(obj)]
+      when Enumerator::Chain
+        T::Enumerator::Chain[type_from_instances(obj)]
       when Enumerator
         T::Enumerator[type_from_instances(obj)]
       when Set
@@ -158,14 +171,14 @@ def describe_obj(obj)
         if T::Configuration::AT_LEAST_RUBY_2_7
           Object.instance_method(:class).bind_call(obj)
         else
-          Object.instance_method(:class).bind(obj).call
+          Object.instance_method(:class).bind(obj).call # rubocop:disable Performance/BindCall
         end
       end
     end
 
     class Untyped < TypedEnumerable
       def initialize
-        super(T.untyped)
+        super(T::Types::Untyped::Private::INSTANCE)
       end
 
       def valid?(obj)
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_enumerator.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_enumerator.rb
similarity index 87%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_enumerator.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_enumerator.rb
index e79341eb9425c..1c1fbbe354711 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_enumerator.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_enumerator.rb
@@ -3,15 +3,13 @@
 
 module T::Types
   class TypedEnumerator < TypedEnumerable
-    attr_reader :type
-
     def underlying_class
       Enumerator
     end
 
     # overrides Base
     def name
-      "T::Enumerator[#{@type.name}]"
+      "T::Enumerator[#{type.name}]"
     end
 
     # overrides Base
@@ -30,7 +28,7 @@ def new(*args, &blk)
 
     class Untyped < TypedEnumerator
       def initialize
-        super(T.untyped)
+        super(T::Types::Untyped::Private::INSTANCE)
       end
 
       def valid?(obj)
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_enumerator_chain.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_enumerator_chain.rb
new file mode 100644
index 0000000000000..7e0ab602a45b6
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_enumerator_chain.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedEnumeratorChain < TypedEnumerable
+    def underlying_class
+      Enumerator::Chain
+    end
+
+    # overrides Base
+    def name
+      "T::Enumerator::Chain[#{type.name}]"
+    end
+
+    # overrides Base
+    def recursively_valid?(obj)
+      obj.is_a?(Enumerator::Chain) && super
+    end
+
+    # overrides Base
+    def valid?(obj)
+      obj.is_a?(Enumerator::Chain)
+    end
+
+    def new(*args, &blk)
+      T.unsafe(Enumerator::Chain).new(*args, &blk)
+    end
+
+    class Untyped < TypedEnumeratorChain
+      def initialize
+        super(T::Types::Untyped::Private::INSTANCE)
+      end
+
+      def valid?(obj)
+        obj.is_a?(Enumerator::Chain)
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_enumerator_lazy.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_enumerator_lazy.rb
similarity index 87%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_enumerator_lazy.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_enumerator_lazy.rb
index 3569be398aaad..5f5cfc844c41b 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_enumerator_lazy.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_enumerator_lazy.rb
@@ -3,15 +3,13 @@
 
 module T::Types
   class TypedEnumeratorLazy < TypedEnumerable
-    attr_reader :type
-
     def underlying_class
       Enumerator::Lazy
     end
 
     # overrides Base
     def name
-      "T::Enumerator::Lazy[#{@type.name}]"
+      "T::Enumerator::Lazy[#{type.name}]"
     end
 
     # overrides Base
@@ -30,7 +28,7 @@ def new(*args, &blk)
 
     class Untyped < TypedEnumeratorLazy
       def initialize
-        super(T.untyped)
+        super(T::Types::Untyped::Private::INSTANCE)
       end
 
       def valid?(obj)
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_hash.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_hash.rb
new file mode 100644
index 0000000000000..185813220a967
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_hash.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  class TypedHash < TypedEnumerable
+    def underlying_class
+      Hash
+    end
+
+    def initialize(keys:, values:)
+      @inner_keys = keys
+      @inner_values = values
+    end
+
+    # Technically we don't need this, but it is a nice api
+    def keys
+      @keys ||= T::Utils.coerce(@inner_keys)
+    end
+
+    # Technically we don't need this, but it is a nice api
+    def values
+      @values ||= T::Utils.coerce(@inner_values)
+    end
+
+    def type
+      @type ||= T::Utils.coerce([keys, values])
+    end
+
+    # overrides Base
+    def name
+      "T::Hash[#{keys.name}, #{values.name}]"
+    end
+
+    # overrides Base
+    def recursively_valid?(obj)
+      obj.is_a?(Hash) && super
+    end
+
+    # overrides Base
+    def valid?(obj)
+      obj.is_a?(Hash)
+    end
+
+    def new(*args, &blk)
+      Hash.new(*T.unsafe(args), &blk)
+    end
+
+    class Untyped < TypedHash
+      def initialize
+        super(keys: T.untyped, values: T.untyped)
+      end
+
+      def valid?(obj)
+        obj.is_a?(Hash)
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_range.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_range.rb
similarity index 86%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_range.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_range.rb
index 50e2ef9d5304f..ff34ae2a48753 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_range.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_range.rb
@@ -3,15 +3,13 @@
 
 module T::Types
   class TypedRange < TypedEnumerable
-    attr_reader :type
-
     def underlying_class
-      Hash
+      Range
     end
 
     # overrides Base
     def name
-      "T::Range[#{@type.name}]"
+      "T::Range[#{type.name}]"
     end
 
     # overrides Base
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_set.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_set.rb
similarity index 94%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_set.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_set.rb
index 8c1b2caee3687..0011f84a9d1d6 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/typed_set.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/typed_set.rb
@@ -3,15 +3,13 @@
 
 module T::Types
   class TypedSet < TypedEnumerable
-    attr_reader :type
-
     def underlying_class
-      Hash
+      Set
     end
 
     # overrides Base
     def name
-      "T::Set[#{@type.name}]"
+      "T::Set[#{type.name}]"
     end
 
     # overrides Base
@@ -39,7 +37,7 @@ def new(*args)
 
     class Untyped < TypedSet
       def initialize
-        super(T.untyped)
+        super(T::Types::Untyped::Private::INSTANCE)
       end
 
       def valid?(obj)
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/union.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/union.rb
new file mode 100644
index 0000000000000..28a2d5ea0eb90
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/union.rb
@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Types
+  # Takes a list of types. Validates that an object matches at least one of the types.
+  class Union < Base
+    # Don't use Union.new directly, use `Private::Pool.union_of_types`
+    # inside sorbet-runtime and `T.any` elsewhere.
+    def initialize(types)
+      @inner_types = types
+    end
+
+    def types
+      @types ||= @inner_types.flat_map do |type|
+        type = T::Utils.coerce(type)
+        if type.is_a?(Union)
+          # Simplify nested unions (mostly so `name` returns a nicer value)
+          type.types
+        else
+          type
+        end
+      end.uniq
+    end
+
+    def build_type
+      types
+      nil
+    end
+
+    # overrides Base
+    def name
+      # Use the attr_reader here so we can override it in SimplePairUnion
+      type_shortcuts(types)
+    end
+
+    private def type_shortcuts(types)
+      if types.size == 1
+        # We shouldn't generally get here but it's possible if initializing the type
+        # evades Sorbet's static check and we end up on the slow path, or if someone
+        # is using the T:Types::Union constructor directly (the latter possibility
+        # is why we don't just move the `uniq` into `Private::Pool.union_of_types`).
+        return types[0].name
+      end
+      nilable = T::Utils.coerce(NilClass)
+      trueclass = T::Utils.coerce(TrueClass)
+      falseclass = T::Utils.coerce(FalseClass)
+      if types.any? {|t| t == nilable}
+        remaining_types = types.reject {|t| t == nilable}
+        "T.nilable(#{type_shortcuts(remaining_types)})"
+      elsif types.any? {|t| t == trueclass} && types.any? {|t| t == falseclass}
+        remaining_types = types.reject {|t| t == trueclass || t == falseclass}
+        type_shortcuts([T::Private::Types::StringHolder.new("T::Boolean")] + remaining_types)
+      else
+        names = types.map(&:name).compact.sort
+        "T.any(#{names.join(', ')})"
+      end
+    end
+
+    # overrides Base
+    def recursively_valid?(obj)
+      types.any? {|type| type.recursively_valid?(obj)}
+    end
+
+    # overrides Base
+    def valid?(obj)
+      types.any? {|type| type.valid?(obj)}
+    end
+
+    # overrides Base
+    private def subtype_of_single?(other)
+      raise "This should never be reached if you're going through `subtype_of?` (and you should be)"
+    end
+
+    def unwrap_nilable
+      non_nil_types = types.reject {|t| t == T::Utils::Nilable::NIL_TYPE}
+      return nil if types.length == non_nil_types.length
+      case non_nil_types.length
+      when 0 then nil
+      when 1 then non_nil_types.first
+      else
+        T::Types::Union::Private::Pool.union_of_types(non_nil_types[0], non_nil_types[1], non_nil_types[2..-1])
+      end
+    end
+
+    module Private
+      module Pool
+        EMPTY_ARRAY = [].freeze
+        private_constant :EMPTY_ARRAY
+
+        # Try to use `to_nilable` on a type to get memoization, or failing that
+        # try to at least use SimplePairUnion to get faster init and typechecking.
+        #
+        # We aren't guaranteed to detect a simple `T.nilable(<Module>)` type here
+        # in cases where there are duplicate types, nested unions, etc.
+        #
+        # That's ok, because returning is SimplePairUnion an optimization which
+        # isn't necessary for correctness.
+        #
+        # @param type_a [T::Types::Base]
+        # @param type_b [T::Types::Base]
+        # @param types [Array] optional array of additional T::Types::Base instances
+        def self.union_of_types(type_a, type_b, types=EMPTY_ARRAY)
+          if !types.empty?
+            # Slow path
+            return Union.new([type_a, type_b] + types)
+          elsif !type_a.is_a?(T::Types::Simple) || !type_b.is_a?(T::Types::Simple)
+            # Slow path
+            return Union.new([type_a, type_b])
+          end
+
+          begin
+            if type_b == T::Utils::Nilable::NIL_TYPE
+              type_a.to_nilable
+            elsif type_a == T::Utils::Nilable::NIL_TYPE
+              type_b.to_nilable
+            else
+              T::Private::Types::SimplePairUnion.new(type_a, type_b)
+            end
+          rescue T::Private::Types::SimplePairUnion::DuplicateType
+            # Slow path
+            #
+            # This shouldn't normally be possible due to static checks,
+            # but we can get here if we're constructing a type dynamically.
+            #
+            # Relying on the duplicate check in the constructor has the
+            # advantage that we avoid it when we hit the memoized case
+            # of `to_nilable`.
+            type_a
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/untyped.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/untyped.rb
similarity index 91%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/untyped.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/untyped.rb
index a06a633d420fb..ee0bc62357060 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/sorbet-runtime-0.5.10175/lib/types/types/untyped.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/types/untyped.rb
@@ -7,6 +7,10 @@ class Untyped < Base
 
     def initialize; end
 
+    def build_type
+      nil
+    end
+
     # overrides Base
     def name
       "T.untyped"
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/utils.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/utils.rb
new file mode 100644
index 0000000000000..01897c0a27d9d
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/sorbet-runtime-0.5.11633/lib/types/utils.rb
@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+# typed: true
+
+module T::Utils
+  module Private
+    def self.coerce_and_check_module_types(val, check_val, check_module_type)
+      # rubocop:disable Style/CaseLikeIf
+      if val.is_a?(T::Types::Base)
+        if val.is_a?(T::Private::Types::TypeAlias)
+          val.aliased_type
+        else
+          val
+        end
+      elsif val.is_a?(Module)
+        if check_module_type && check_val.is_a?(val)
+          nil
+        else
+          T::Types::Simple::Private::Pool.type_for_module(val)
+        end
+      elsif val.is_a?(::Array)
+        T::Types::FixedArray.new(val)
+      elsif val.is_a?(::Hash)
+        T::Types::FixedHash.new(val)
+      elsif val.is_a?(T::Private::Methods::DeclBuilder)
+        T::Private::Methods.finalize_proc(val.decl)
+      elsif val.is_a?(::T::Enum)
+        T::Types::TEnum.new(val)
+      elsif val.is_a?(::String)
+        raise "Invalid String literal for type constraint. Must be an #{T::Types::Base}, a " \
+              "class/module, or an array. Got a String with value `#{val}`."
+      else
+        raise "Invalid value for type constraint. Must be an #{T::Types::Base}, a " \
+              "class/module, or an array. Got a `#{val.class}`."
+      end
+      # rubocop:enable Style/CaseLikeIf
+    end
+  end
+
+  # Used to convert from a type specification to a `T::Types::Base`.
+  def self.coerce(val)
+    Private.coerce_and_check_module_types(val, nil, false)
+  end
+
+  # Dynamically confirm that `value` is recursively a valid value of
+  # type `type`, including recursively through collections. Note that
+  # in some cases this runtime check can be very expensive, especially
+  # with large collections of objects.
+  def self.check_type_recursive!(value, type)
+    T::Private::Casts.cast_recursive(value, type, "T.check_type_recursive!")
+  end
+
+  # Returns the set of all methods (public, protected, private) defined on a module or its
+  # ancestors, excluding Object and its ancestors. Overrides of methods from Object (and its
+  # ancestors) are included.
+  def self.methods_excluding_object(mod)
+    # We can't just do mod.instance_methods - Object.instance_methods, because that would leave out
+    # any methods from Object that are overridden in mod.
+    mod.ancestors.flat_map do |ancestor|
+      # equivalent to checking Object.ancestors.include?(ancestor)
+      next [] if Object <= ancestor
+      ancestor.instance_methods(false) + ancestor.private_instance_methods(false)
+    end.uniq
+  end
+
+  # Returns the signature for the `UnboundMethod`, or nil if it's not sig'd
+  #
+  # @example T::Utils.signature_for_method(x.method(:foo))
+  def self.signature_for_method(method)
+    T::Private::Methods.signature_for_method(method)
+  end
+
+  # Returns the signature for the instance method on the supplied module, or nil if it's not found or not typed.
+  #
+  # @example T::Utils.signature_for_instance_method(MyClass, :my_method)
+  def self.signature_for_instance_method(mod, method_name)
+    T::Private::Methods.signature_for_method(mod.instance_method(method_name))
+  end
+
+  def self.wrap_method_with_call_validation_if_needed(mod, method_sig, original_method)
+    T::Private::Methods::CallValidation.wrap_method_if_needed(mod, method_sig, original_method)
+  end
+
+  # Unwraps all the sigs.
+  def self.run_all_sig_blocks(force_type_init: true)
+    T::Private::Methods.run_all_sig_blocks(force_type_init: force_type_init)
+  end
+
+  # Return the underlying type for a type alias. Otherwise returns type.
+  def self.resolve_alias(type)
+    case type
+    when T::Private::Types::TypeAlias
+      type.aliased_type
+    else
+      type
+    end
+  end
+
+  # Give a type which is a subclass of T::Types::Base, determines if the type is a simple nilable type (union of NilClass and something else).
+  # If so, returns the T::Types::Base of the something else. Otherwise, returns nil.
+  def self.unwrap_nilable(type)
+    case type
+    when T::Types::Union
+      type.unwrap_nilable
+    else
+      nil
+    end
+  end
+
+  # Returns the arity of a method, unwrapping the sig if needed
+  def self.arity(method)
+    arity = method.arity
+    return arity if arity != -1 || method.is_a?(Proc)
+    sig = T::Private::Methods.signature_for_method(method)
+    sig ? sig.method.arity : arity
+  end
+
+  # Elide the middle of a string as needed and replace it with an ellipsis.
+  # Keep the given number of characters at the start and end of the string.
+  #
+  # This method operates on string length, not byte length.
+  #
+  # If the string is shorter than the requested truncation length, return it
+  # without adding an ellipsis. This method may return a longer string than
+  # the original if the characters removed are shorter than the ellipsis.
+  #
+  # @param [String] str
+  #
+  # @param [Fixnum] start_len The length of string before the ellipsis
+  # @param [Fixnum] end_len The length of string after the ellipsis
+  #
+  # @param [String] ellipsis The string to add in place of the elided text
+  #
+  # @return [String]
+  #
+  def self.string_truncate_middle(str, start_len, end_len, ellipsis='...')
+    return unless str
+
+    raise ArgumentError.new('must provide start_len') unless start_len
+    raise ArgumentError.new('must provide end_len') unless end_len
+
+    raise ArgumentError.new('start_len must be >= 0') if start_len < 0
+    raise ArgumentError.new('end_len must be >= 0') if end_len < 0
+
+    str = str.to_s
+    return str if str.length <= start_len + end_len
+
+    start_part = str[0...start_len - ellipsis.length]
+    end_part = end_len == 0 ? '' : str[-end_len..-1]
+
+    "#{start_part}#{ellipsis}#{end_part}"
+  end
+
+  def self.lift_enum(enum)
+    unless enum.is_a?(T::Types::Enum)
+      raise ArgumentError.new("#{enum.inspect} is not a T.deprecated_enum")
+    end
+
+    classes = T.unsafe(enum.values).map(&:class).uniq
+    if classes.empty?
+      T.untyped
+    elsif classes.length > 1
+      T::Types::Union.new(classes)
+    else
+      T::Types::Simple::Private::Pool.type_for_module(classes.first)
+    end
+  end
+
+  module Nilable
+    # :is_union_type, T::Boolean: whether the type is an T::Types::Union type
+    # :non_nilable_type, Class: if it is an T.nilable type, the corresponding underlying type; otherwise, nil.
+    TypeInfo = Struct.new(:is_union_type, :non_nilable_type)
+
+    NIL_TYPE = T::Utils.coerce(NilClass)
+
+    def self.get_type_info(prop_type)
+      if prop_type.is_a?(T::Types::Union)
+        non_nilable_type = prop_type.unwrap_nilable
+        if non_nilable_type.is_a?(T::Types::Simple)
+          non_nilable_type = non_nilable_type.raw_type
+        end
+        TypeInfo.new(true, non_nilable_type)
+      else
+        TypeInfo.new(false, nil)
+      end
+    end
+
+    # Get the underlying type inside prop_type:
+    #  - if the type is A, the function returns A
+    #  - if the type is T.nilable(A), the function returns A
+    def self.get_underlying_type(prop_type)
+      if prop_type.is_a?(T::Types::Union)
+        non_nilable_type = prop_type.unwrap_nilable
+        if non_nilable_type.is_a?(T::Types::Simple)
+          non_nilable_type = non_nilable_type.raw_type
+        end
+        non_nilable_type || prop_type
+      elsif prop_type.is_a?(T::Types::Simple)
+        prop_type.raw_type
+      else
+        prop_type
+      end
+    end
+
+    # The difference between this function and the above function is that the Sorbet type, like T::Types::Simple
+    # is preserved.
+    def self.get_underlying_type_object(prop_type)
+      T::Utils.unwrap_nilable(prop_type) || prop_type
+    end
+
+    def self.is_union_with_nilclass(prop_type)
+      case prop_type
+      when T::Types::Union
+        prop_type.types.include?(NIL_TYPE)
+      else
+        false
+      end
+    end
+  end
+end
diff --git a/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/warning-1.4.0/MIT-LICENSE b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/warning-1.4.0/MIT-LICENSE
new file mode 100644
index 0000000000000..b045251a19105
--- /dev/null
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/warning-1.4.0/MIT-LICENSE
@@ -0,0 +1,18 @@
+Copyright (c) 2016-2022 Jeremy Evans
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+   
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/warning-1.3.0/lib/warning.rb b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/warning-1.4.0/lib/warning.rb
similarity index 92%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/warning-1.3.0/lib/warning.rb
rename to Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/warning-1.4.0/lib/warning.rb
index 9179aa377359d..db5794c5c5ca6 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/warning-1.3.0/lib/warning.rb
+++ b/Library/Homebrew/vendor/bundle/ruby/3.3.0/gems/warning-1.4.0/lib/warning.rb
@@ -4,18 +4,19 @@ module Warning
   module Processor
     # Map of symbols to regexps for warning messages to ignore.
     IGNORE_MAP = {
-      ambiguous_slash: /: warning: ambiguous first argument; put parentheses or a space even after `\/' operator\n\z|: warning: ambiguity between regexp and two divisions: wrap regexp in parentheses or add a space after `\/' operator\n\z/,
-      arg_prefix: /: warning: `[&\*]' interpreted as argument prefix\n\z/,
+      ambiguous_slash: /: warning: ambiguous first argument; put parentheses or a space even after [`']\/' operator\n\z|: warning: ambiguity between regexp and two divisions: wrap regexp in parentheses or add a space after [`']\/' operator\n\z/,
+      arg_prefix: /: warning: [`'][&\*]' interpreted as argument prefix\n\z/,
       bignum: /: warning: constant ::Bignum is deprecated\n\z/,
       fixnum: /: warning: constant ::Fixnum is deprecated\n\z/,
+      ignored_block: /: warning: the block passed to '.+' defined at .+:\d+ may be ignored\n\z/,
       method_redefined: /: warning: method redefined; discarding old .+\n\z|: warning: previous definition of .+ was here\n\z/,
-      missing_gvar: /: warning: global variable `\$.+' not initialized\n\z/,
+      missing_gvar: /: warning: global variable [`']\$.+' not initialized\n\z/,
       missing_ivar: /: warning: instance variable @.+ not initialized\n\z/,
       not_reached: /: warning: statement not reached\n\z/,
       shadow: /: warning: shadowing outer local variable - \w+\n\z/,
       unused_var: /: warning: assigned but unused variable - \w+\n\z/,
       useless_operator: /: warning: possibly useless use of [><!=]+ in void context\n\z/,
-      keyword_separation: /: warning: (?:Using the last argument (?:for `.+' )?as keyword parameters is deprecated; maybe \*\* should be added to the call|Passing the keyword argument (?:for `.+' )?as the last hash parameter is deprecated|Splitting the last argument (?:for `.+' )?into positional and keyword parameters is deprecated|The called method (?:`.+' )?is defined here)\n\z/,
+      keyword_separation: /: warning: (?:Using the last argument (?:for [`'].+' )?as keyword parameters is deprecated; maybe \*\* should be added to the call|Passing the keyword argument (?:for [`'].+' )?as the last hash parameter is deprecated|Splitting the last argument (?:for [`'].+' )?into positional and keyword parameters is deprecated|The called method (?:[`'].+' )?is defined here)\n\z/,
       safe: /: warning: (?:rb_safe_level_2_warning|rb_safe_level|rb_set_safe_level_force|rb_set_safe_level|rb_secure|rb_insecure_operation|rb_check_safe_obj|\$SAFE) will (?:be removed|become a normal global variable) in Ruby 3\.0\n\z/,
       taint: /: warning: (?:rb_error_untrusted|rb_check_trusted|Pathname#taint|Pathname#untaint|rb_env_path_tainted|Object#tainted\?|Object#taint|Object#untaint|Object#untrusted\?|Object#untrust|Object#trust|rb_obj_infect|rb_tainted_str_new|rb_tainted_str_new_cstr) is deprecated and will be removed in Ruby 3\.2\.?\n\z/,
       mismatched_indentations: /: warning: mismatched indentations at '.+' with '.+' at \d+\n\z/,
@@ -166,7 +167,7 @@ def ignore(regexp, path='')
     #     /instance variable @\w+ not initialized/ => proc do |warning|
     #       LOGGER.warning(warning)
     #     end,
-    #     /global variable `\$\w+' not initialized/ => proc do |warning|
+    #     /global variable [`']\$\w+' not initialized/ => proc do |warning|
     #       LOGGER.error(warning)
     #     end
     #   )
diff --git a/Library/Homebrew/vendor/gems/mechanize b/Library/Homebrew/vendor/gems/mechanize
new file mode 120000
index 0000000000000..c99eaf374cbe8
--- /dev/null
+++ b/Library/Homebrew/vendor/gems/mechanize
@@ -0,0 +1 @@
+mechanize-2.12.2/
\ No newline at end of file
diff --git a/Library/Homebrew/vendor/gems/mechanize-2.12.2/LICENSE.txt b/Library/Homebrew/vendor/gems/mechanize-2.12.2/LICENSE.txt
new file mode 100644
index 0000000000000..3a5074024a5c3
--- /dev/null
+++ b/Library/Homebrew/vendor/gems/mechanize-2.12.2/LICENSE.txt
@@ -0,0 +1,24 @@
+(The MIT License)
+
+Copyright (c) 2005 by Michael Neumann (mneumann@ntecs.de)
+
+Copyright (c) 2006-2021 by Eric Hodel, Akinori MUSHA, Aaron Patterson, Lee Jarvis, Mike Dalessio
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/mechanize-2.8.5/lib/mechanize/http/content_disposition_parser.rb b/Library/Homebrew/vendor/gems/mechanize-2.12.2/lib/mechanize/http/content_disposition_parser.rb
similarity index 98%
rename from Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/mechanize-2.8.5/lib/mechanize/http/content_disposition_parser.rb
rename to Library/Homebrew/vendor/gems/mechanize-2.12.2/lib/mechanize/http/content_disposition_parser.rb
index 3ea90971dcec5..f8b8f9a9fdf26 100644
--- a/Library/Homebrew/vendor/bundle/ruby/2.6.0/gems/mechanize-2.8.5/lib/mechanize/http/content_disposition_parser.rb
+++ b/Library/Homebrew/vendor/gems/mechanize-2.12.2/lib/mechanize/http/content_disposition_parser.rb
@@ -81,7 +81,7 @@ def parse content_disposition, header = false
   end
 
   ##
-  # Extracts disposition-parm and returns a Hash.
+  # Extracts disposition-param and returns a Hash.
 
   def parse_parameters
     parameters = {}
@@ -200,4 +200,3 @@ def spaces
   end
 
 end
-
diff --git a/Library/Homebrew/vendor/gems/mechanize-2.12.2/lib/mechanize/version.rb b/Library/Homebrew/vendor/gems/mechanize-2.12.2/lib/mechanize/version.rb
new file mode 100644
index 0000000000000..94fb599a8d2a5
--- /dev/null
+++ b/Library/Homebrew/vendor/gems/mechanize-2.12.2/lib/mechanize/version.rb
@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+class Mechanize
+  VERSION = "2.12.2"
+end
diff --git a/Library/Homebrew/vendor/portable-ruby-arm64-darwin b/Library/Homebrew/vendor/portable-ruby-arm64-darwin
new file mode 100644
index 0000000000000..a5d655df70035
--- /dev/null
+++ b/Library/Homebrew/vendor/portable-ruby-arm64-darwin
@@ -0,0 +1,2 @@
+ruby_TAG=arm64_big_sur
+ruby_SHA=e7340e4a1d7cc0f113686e461b93114270848cb14676e9037a1a2ff3b1a0ff32
diff --git a/Library/Homebrew/vendor/portable-ruby-version b/Library/Homebrew/vendor/portable-ruby-version
index 3472e7b17843b..fa7adc7ac72a2 100644
--- a/Library/Homebrew/vendor/portable-ruby-version
+++ b/Library/Homebrew/vendor/portable-ruby-version
@@ -1 +1 @@
-2.6.8_1
+3.3.5
diff --git a/Library/Homebrew/vendor/portable-ruby-x86_64-darwin b/Library/Homebrew/vendor/portable-ruby-x86_64-darwin
new file mode 100644
index 0000000000000..cd58fb4b0cef9
--- /dev/null
+++ b/Library/Homebrew/vendor/portable-ruby-x86_64-darwin
@@ -0,0 +1,2 @@
+ruby_TAG=el_capitan
+ruby_SHA=e02b387d80f10c835df15115360b0b5deb8e35f8967c7e68c9942af046023209
diff --git a/Library/Homebrew/vendor/portable-ruby-x86_64-linux b/Library/Homebrew/vendor/portable-ruby-x86_64-linux
new file mode 100644
index 0000000000000..99384c12c7b8e
--- /dev/null
+++ b/Library/Homebrew/vendor/portable-ruby-x86_64-linux
@@ -0,0 +1,2 @@
+ruby_TAG=x86_64_linux
+ruby_SHA=bd08b92d6725f9216fc3c2458ffd174d5468d43d47dd0fcaeb5109e3008fd40b
diff --git a/Library/Homebrew/version.rb b/Library/Homebrew/version.rb
index d94b51f84a185..067acba83fa59 100644
--- a/Library/Homebrew/version.rb
+++ b/Library/Homebrew/version.rb
@@ -1,16 +1,10 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-require "pkg_version"
-require "version/null"
 require "version/parser"
 
 # A formula's version.
-#
-# @api private
 class Version
-  extend T::Sig
-
   include Comparable
 
   sig { params(name: T.any(String, Symbol), full: T::Boolean).returns(Regexp) }
@@ -20,7 +14,6 @@ def self.formula_optionally_versioned_regex(name, full: true)
 
   # A part of a {Version}.
   class Token
-    extend T::Sig
     extend T::Helpers
     abstract!
 
@@ -28,8 +21,6 @@ class Token
 
     sig { params(val: String).returns(Token) }
     def self.create(val)
-      raise TypeError, "Token value must be a string; got a #{val.class} (#{val})" unless val.respond_to?(:to_str)
-
       case val
       when /\A#{AlphaToken::PATTERN}\z/o   then AlphaToken
       when /\A#{BetaToken::PATTERN}\z/o    then BetaToken
@@ -86,10 +77,12 @@ def to_i
     end
 
     sig { returns(String) }
-    def to_s
+    def to_str
       value.to_s
     end
-    alias to_str to_s
+
+    sig { returns(String) }
+    def to_s = to_str
 
     sig { returns(T::Boolean) }
     def numeric?
@@ -100,12 +93,13 @@ def numeric?
     def null?
       false
     end
+
+    sig { returns(T::Boolean) }
+    def blank? = null?
   end
 
   # A pseudo-token representing the absence of a token.
   class NullToken < Token
-    extend T::Sig
-
     sig { override.returns(NilClass) }
     attr_reader :value
 
@@ -135,7 +129,10 @@ def null?
       true
     end
 
-    sig { override.returns(String) }
+    sig { returns(T::Boolean) }
+    def blank? = true
+
+    sig { returns(String) }
     def inspect
       "#<#{self.class.name}>"
     end
@@ -143,11 +140,11 @@ def inspect
   private_constant :NullToken
 
   # Represents the absence of a token.
-  NULL_TOKEN = NullToken.new.freeze
+  NULL_TOKEN = T.let(NullToken.new.freeze, NullToken)
 
   # A token string.
   class StringToken < Token
-    PATTERN = /[a-z]+/i.freeze
+    PATTERN = /[a-z]+/i
 
     sig { override.returns(String) }
     attr_reader :value
@@ -172,8 +169,7 @@ def <=>(other)
 
   # A token consisting of only numbers.
   class NumericToken < Token
-    PATTERN = /[0-9]+/i.freeze
-    extend T::Sig
+    PATTERN = /[0-9]+/i
 
     sig { override.returns(Integer) }
     attr_reader :value
@@ -213,7 +209,7 @@ def rev
 
   # A token representing the part of a version designating it as an alpha release.
   class AlphaToken < CompositeToken
-    PATTERN = /alpha[0-9]*|a[0-9]+/i.freeze
+    PATTERN = /alpha[0-9]*|a[0-9]+/i
 
     sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
     def <=>(other)
@@ -232,7 +228,7 @@ def <=>(other)
 
   # A token representing the part of a version designating it as a beta release.
   class BetaToken < CompositeToken
-    PATTERN = /beta[0-9]*|b[0-9]+/i.freeze
+    PATTERN = /beta[0-9]*|b[0-9]+/i
 
     sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
     def <=>(other)
@@ -253,7 +249,7 @@ def <=>(other)
 
   # A token representing the part of a version designating it as a pre-release.
   class PreToken < CompositeToken
-    PATTERN = /pre[0-9]*/i.freeze
+    PATTERN = /pre[0-9]*/i
 
     sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
     def <=>(other)
@@ -274,7 +270,7 @@ def <=>(other)
 
   # A token representing the part of a version designating it as a release candidate.
   class RCToken < CompositeToken
-    PATTERN = /rc[0-9]*/i.freeze
+    PATTERN = /rc[0-9]*/i
 
     sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
     def <=>(other)
@@ -295,7 +291,7 @@ def <=>(other)
 
   # A token representing the part of a version designating it as a patch release.
   class PatchToken < CompositeToken
-    PATTERN = /p[0-9]*/i.freeze
+    PATTERN = /p[0-9]*/i
 
     sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
     def <=>(other)
@@ -314,7 +310,7 @@ def <=>(other)
 
   # A token representing the part of a version designating it as a post release.
   class PostToken < CompositeToken
-    PATTERN = /.post[0-9]+/i.freeze
+    PATTERN = /.post[0-9]+/i
 
     sig { override.params(other: T.untyped).returns(T.nilable(Integer)) }
     def <=>(other)
@@ -331,7 +327,7 @@ def <=>(other)
     end
   end
 
-  SCAN_PATTERN = Regexp.union(
+  SCAN_PATTERN = T.let(Regexp.union(
     AlphaToken::PATTERN,
     BetaToken::PATTERN,
     PreToken::PATTERN,
@@ -340,7 +336,7 @@ def <=>(other)
     PostToken::PATTERN,
     NumericToken::PATTERN,
     StringToken::PATTERN,
-  ).freeze
+  ).freeze, Regexp)
   private_constant :SCAN_PATTERN
 
   sig { params(url: T.any(String, Pathname), specs: T.untyped).returns(Version) }
@@ -348,172 +344,159 @@ def self.detect(url, **specs)
     parse(specs.fetch(:tag, url), detected_from_url: true)
   end
 
-  sig { params(val: String).returns(Version) }
-  def self.create(val)
-    raise TypeError, "Version value must be a string; got a #{val.class} (#{val})" unless val.respond_to?(:to_str)
-
-    if val.to_str.start_with?("HEAD")
-      HeadVersion.new(val)
-    else
-      Version.new(val)
-    end
-  end
-
   sig { params(spec: T.any(String, Pathname), detected_from_url: T::Boolean).returns(Version) }
   def self.parse(spec, detected_from_url: false)
-    version = _parse(spec, detected_from_url: detected_from_url)
-    version.nil? ? NULL : new(version, detected_from_url: detected_from_url)
-  end
-
-  sig { params(spec: T.any(String, Pathname), detected_from_url: T::Boolean).returns(T.nilable(String)) }
-  def self._parse(spec, detected_from_url:)
     spec = CGI.unescape(spec.to_s) if detected_from_url
 
-    spec = Pathname.new(spec) unless spec.is_a? Pathname
+    spec = Pathname(spec)
 
     VERSION_PARSERS.each do |parser|
       version = parser.parse(spec)
-      return version if version.present?
+      return new(version, detected_from_url:) if version.present?
     end
 
-    nil
+    NULL
   end
-  private_class_method :_parse
 
-  NUMERIC_WITH_OPTIONAL_DOTS = /(?:\d+(?:\.\d+)*)/.source.freeze
+  NUMERIC_WITH_OPTIONAL_DOTS = T.let(/(?:\d+(?:\.\d+)*)/.source.freeze, String)
   private_constant :NUMERIC_WITH_OPTIONAL_DOTS
 
-  NUMERIC_WITH_DOTS = /(?:\d+(?:\.\d+)+)/.source.freeze
+  NUMERIC_WITH_DOTS = T.let(/(?:\d+(?:\.\d+)+)/.source.freeze, String)
   private_constant :NUMERIC_WITH_DOTS
 
-  MINOR_OR_PATCH = /(?:\d+(?:\.\d+){1,2})/.source.freeze
+  MINOR_OR_PATCH = T.let(/(?:\d+(?:\.\d+){1,2})/.source.freeze, String)
   private_constant :MINOR_OR_PATCH
 
-  CONTENT_SUFFIX = /(?:[._-](?i:bin|dist|stable|src|sources?|final|full))/.source.freeze
+  CONTENT_SUFFIX = T.let(/(?:[._-](?i:bin|dist|stable|src|sources?|final|full))/.source.freeze, String)
   private_constant :CONTENT_SUFFIX
 
-  PRERELEASE_SUFFIX = /(?:[._-]?(?i:alpha|beta|pre|rc)\.?\d{,2})/.source.freeze
+  PRERELEASE_SUFFIX = T.let(/(?:[._-]?(?i:alpha|beta|pre|rc)\.?\d{,2})/.source.freeze, String)
   private_constant :PRERELEASE_SUFFIX
 
-  VERSION_PARSERS = [
+  VERSION_PARSERS = T.let([
     # date-based versioning
-    # e.g. ltopers-v2017-04-14.tar.gz
-    StemParser.new(/-v?(\d{4}-\d{2}-\d{2})/),
+    # e.g. `2023-09-28.tar.gz`
+    # e.g. `ltopers-v2017-04-14.tar.gz`
+    StemParser.new(/(?:^|[._-]?)v?(\d{4}-\d{2}-\d{2})/),
 
     # GitHub tarballs
-    # e.g. https://github.com/foo/bar/tarball/v1.2.3
-    # e.g. https://github.com/sam-github/libnet/tarball/libnet-1.1.4
-    # e.g. https://github.com/isaacs/npm/tarball/v0.2.5-1
-    # e.g. https://github.com/petdance/ack/tarball/1.93_02
+    # e.g. `https://github.com/foo/bar/tarball/v1.2.3`
+    # e.g. `https://github.com/sam-github/libnet/tarball/libnet-1.1.4`
+    # e.g. `https://github.com/isaacs/npm/tarball/v0.2.5-1`
+    # e.g. `https://github.com/petdance/ack/tarball/1.93_02`
     UrlParser.new(%r{github\.com/.+/(?:zip|tar)ball/(?:v|\w+-)?((?:\d+[._-])+\d*)$}),
 
-    # e.g. https://github.com/erlang/otp/tarball/OTP_R15B01 (erlang style)
+    # e.g. `https://github.com/erlang/otp/tarball/OTP_R15B01 (erlang style)`
     UrlParser.new(/[_-]([Rr]\d+[AaBb]\d*(?:-\d+)?)/),
 
-    # e.g. boost_1_39_0
+    # e.g. `boost_1_39_0`
     StemParser.new(/((?:\d+_)+\d+)$/) { |s| s.tr("_", ".") },
 
-    # e.g. foobar-4.5.1-1
-    # e.g. unrtf_0.20.4-1
-    # e.g. ruby-1.9.1-p243
+    # e.g. `foobar-4.5.1-1`
+    # e.g. `unrtf_0.20.4-1`
+    # e.g. `ruby-1.9.1-p243`
     StemParser.new(/[_-](#{NUMERIC_WITH_DOTS}-(?:p|P|rc|RC)?\d+)#{CONTENT_SUFFIX}?$/),
 
     # Hyphenated versions without software-name prefix (e.g. brew-)
-    # e.g. v0.0.8-12.tar.gz
-    # e.g. 3.3.04-1.tar.gz
-    # e.g. v2.1-20210510.tar.gz
-    # e.g. 2020.11.11-3.tar.gz
-    # e.g. v3.6.6-0.2
+    # e.g. `v0.0.8-12.tar.gz`
+    # e.g. `3.3.04-1.tar.gz`
+    # e.g. `v2.1-20210510.tar.gz`
+    # e.g. `2020.11.11-3.tar.gz`
+    # e.g. `v3.6.6-0.2`
     StemParser.new(/^v?(#{NUMERIC_WITH_DOTS}(?:-#{NUMERIC_WITH_OPTIONAL_DOTS})+)/),
 
     # URL with no extension
-    # e.g. https://waf.io/waf-1.8.12
-    # e.g. https://codeload.github.com/gsamokovarov/jump/tar.gz/v0.7.1
+    # e.g. `https://waf.io/waf-1.8.12`
+    # e.g. `https://codeload.github.com/gsamokovarov/jump/tar.gz/v0.7.1`
     UrlParser.new(/[-v](#{NUMERIC_WITH_OPTIONAL_DOTS})$/),
 
-    # e.g. lame-398-1
+    # e.g. `lame-398-1`
     StemParser.new(/-(\d+-\d+)/),
 
-    # e.g. foobar-4.5.1
+    # e.g. `foobar-4.5.1`
     StemParser.new(/-(#{NUMERIC_WITH_OPTIONAL_DOTS})$/),
 
-    # e.g. foobar-4.5.1.post1
+    # e.g. `foobar-4.5.1.post1`
     StemParser.new(/-(#{NUMERIC_WITH_OPTIONAL_DOTS}(.post\d+)?)$/),
 
-    # e.g. foobar-4.5.1b
+    # e.g. `foobar-4.5.1b`
     StemParser.new(/-(#{NUMERIC_WITH_OPTIONAL_DOTS}(?:[abc]|rc|RC)\d*)$/),
 
-    # e.g. foobar-4.5.0-alpha5, foobar-4.5.0-beta1, or foobar-4.50-beta
+    # e.g. `foobar-4.5.0-alpha5, foobar-4.5.0-beta1, or foobar-4.50-beta`
     StemParser.new(/-(#{NUMERIC_WITH_OPTIONAL_DOTS}-(?:alpha|beta|rc)\d*)$/),
 
-    # e.g. https://ftpmirror.gnu.org/libidn/libidn-1.29-win64.zip
-    # e.g. https://ftpmirror.gnu.org/libmicrohttpd/libmicrohttpd-0.9.17-w32.zip
+    # e.g. `https://ftpmirror.gnu.org/libidn/libidn-1.29-win64.zip`
+    # e.g. `https://ftpmirror.gnu.org/libmicrohttpd/libmicrohttpd-0.9.17-w32.zip`
     StemParser.new(/-(#{MINOR_OR_PATCH})-w(?:in)?(?:32|64)$/),
 
     # Opam packages
-    # e.g. https://opam.ocaml.org/archives/sha.1.9+opam.tar.gz
-    # e.g. https://opam.ocaml.org/archives/lablgtk.2.18.3+opam.tar.gz
-    # e.g. https://opam.ocaml.org/archives/easy-format.1.0.2+opam.tar.gz
+    # e.g. `https://opam.ocaml.org/archives/sha.1.9+opam.tar.gz`
+    # e.g. `https://opam.ocaml.org/archives/lablgtk.2.18.3+opam.tar.gz`
+    # e.g. `https://opam.ocaml.org/archives/easy-format.1.0.2+opam.tar.gz`
     StemParser.new(/\.(#{MINOR_OR_PATCH})\+opam$/),
 
-    # e.g. https://ftpmirror.gnu.org/mtools/mtools-4.0.18-1.i686.rpm
-    # e.g. https://ftpmirror.gnu.org/autogen/autogen-5.5.7-5.i386.rpm
-    # e.g. https://ftpmirror.gnu.org/libtasn1/libtasn1-2.8-x86.zip
-    # e.g. https://ftpmirror.gnu.org/libtasn1/libtasn1-2.8-x64.zip
-    # e.g. https://ftpmirror.gnu.org/mtools/mtools_4.0.18_i386.deb
+    # e.g. `https://ftpmirror.gnu.org/mtools/mtools-4.0.18-1.i686.rpm`
+    # e.g. `https://ftpmirror.gnu.org/autogen/autogen-5.5.7-5.i386.rpm`
+    # e.g. `https://ftpmirror.gnu.org/libtasn1/libtasn1-2.8-x86.zip`
+    # e.g. `https://ftpmirror.gnu.org/libtasn1/libtasn1-2.8-x64.zip`
+    # e.g. `https://ftpmirror.gnu.org/mtools/mtools_4.0.18_i386.deb`
     StemParser.new(/[_-](#{MINOR_OR_PATCH}(?:-\d+)?)[._-](?:i[36]86|x86|x64(?:[_-](?:32|64))?)$/),
 
-    # e.g. https://registry.npmjs.org/@angular/cli/-/cli-1.3.0-beta.1.tgz
-    # e.g. https://github.com/dlang/dmd/archive/v2.074.0-beta1.tar.gz
-    # e.g. https://github.com/dlang/dmd/archive/v2.074.0-rc1.tar.gz
-    # e.g. https://github.com/premake/premake-core/releases/download/v5.0.0-alpha10/premake-5.0.0-alpha10-src.zip
-    StemParser.new(/[.-vV]?(#{NUMERIC_WITH_DOTS}#{PRERELEASE_SUFFIX})/),
+    # e.g. `https://registry.npmjs.org/@angular/cli/-/cli-1.3.0-beta.1.tgz`
+    # e.g. `https://github.com/dlang/dmd/archive/v2.074.0-beta1.tar.gz`
+    # e.g. `https://github.com/dlang/dmd/archive/v2.074.0-rc1.tar.gz`
+    # e.g. `https://github.com/premake/premake-core/releases/download/v5.0.0-alpha10/premake-5.0.0-alpha10-src.zip`
+    StemParser.new(/[-.vV]?(#{NUMERIC_WITH_DOTS}#{PRERELEASE_SUFFIX})/),
 
-    # e.g. foobar4.5.1
+    # e.g. `foobar4.5.1`
     StemParser.new(/(#{NUMERIC_WITH_OPTIONAL_DOTS})$/),
 
-    # e.g. foobar-4.5.0-bin
+    # e.g. `foobar-4.5.0-bin`
     StemParser.new(/[-vV](#{NUMERIC_WITH_DOTS}[abc]?)#{CONTENT_SUFFIX}$/),
 
     # dash version style
-    # e.g. http://www.antlr.org/download/antlr-3.4-complete.jar
-    # e.g. https://cdn.nuxeo.com/nuxeo-9.2/nuxeo-server-9.2-tomcat.zip
-    # e.g. https://search.maven.org/remotecontent?filepath=com/facebook/presto/presto-cli/0.181/presto-cli-0.181-executable.jar
-    # e.g. https://search.maven.org/remotecontent?filepath=org/fusesource/fuse-extra/fusemq-apollo-mqtt/1.3/fusemq-apollo-mqtt-1.3-uber.jar
-    # e.g. https://search.maven.org/remotecontent?filepath=org/apache/orc/orc-tools/1.2.3/orc-tools-1.2.3-uber.jar
+    # e.g. `http://www.antlr.org/download/antlr-3.4-complete.jar`
+    # e.g. `https://cdn.nuxeo.com/nuxeo-9.2/nuxeo-server-9.2-tomcat.zip`
+    # e.g. `https://search.maven.org/remotecontent?filepath=com/facebook/presto/presto-cli/0.181/presto-cli-0.181-executable.jar`
+    # e.g. `https://search.maven.org/remotecontent?filepath=org/fusesource/fuse-extra/fusemq-apollo-mqtt/1.3/fusemq-apollo-mqtt-1.3-uber.jar`
+    # e.g. `https://search.maven.org/remotecontent?filepath=org/apache/orc/orc-tools/1.2.3/orc-tools-1.2.3-uber.jar`
     StemParser.new(/-(#{NUMERIC_WITH_DOTS})-/),
 
-    # e.g. dash_0.5.5.1.orig.tar.gz (Debian style)
-    StemParser.new(/_(#{NUMERIC_WITH_DOTS}[abc]?)\.orig$/),
+    # Debian style
+    # e.g. `dash_0.5.5.1.orig.tar.gz`
+    # e.g. `lcrack_20040914.orig.tar.gz`
+    # e.g. `mkcue_1.orig.tar.gz`
+    StemParser.new(/_(#{NUMERIC_WITH_OPTIONAL_DOTS}[abc]?)\.orig$/),
 
-    # e.g. https://www.openssl.org/source/openssl-0.9.8s.tar.gz
+    # e.g. `https://www.openssl.org/source/openssl-0.9.8s.tar.gz`
     StemParser.new(/-v?(\d[^-]+)/),
 
-    # e.g. astyle_1.23_macosx.tar.gz
+    # e.g. `astyle_1.23_macosx.tar.gz`
     StemParser.new(/_v?(\d[^_]+)/),
 
-    # e.g. http://mirrors.jenkins-ci.org/war/1.486/jenkins.war
-    # e.g. https://github.com/foo/bar/releases/download/0.10.11/bar.phar
-    # e.g. https://github.com/clojure/clojurescript/releases/download/r1.9.293/cljs.jar
-    # e.g. https://github.com/fibjs/fibjs/releases/download/v0.6.1/fullsrc.zip
-    # e.g. https://wwwlehre.dhbw-stuttgart.de/~sschulz/WORK/E_DOWNLOAD/V_1.9/E.tgz
-    # e.g. https://github.com/JustArchi/ArchiSteamFarm/releases/download/2.3.2.0/ASF.zip
-    # e.g. https://people.gnome.org/~newren/eg/download/1.7.5.2/eg
+    # e.g. `http://mirrors.jenkins-ci.org/war/1.486/jenkins.war`
+    # e.g. `https://github.com/foo/bar/releases/download/0.10.11/bar.phar`
+    # e.g. `https://github.com/clojure/clojurescript/releases/download/r1.9.293/cljs.jar`
+    # e.g. `https://github.com/fibjs/fibjs/releases/download/v0.6.1/fullsrc.zip`
+    # e.g. `https://wwwlehre.dhbw-stuttgart.de/~sschulz/WORK/E_DOWNLOAD/V_1.9/E.tgz`
+    # e.g. `https://github.com/JustArchi/ArchiSteamFarm/releases/download/2.3.2.0/ASF.zip`
+    # e.g. `https://people.gnome.org/~newren/eg/download/1.7.5.2/eg`
     UrlParser.new(%r{/(?:[rvV]_?)?(\d+\.\d+(?:\.\d+){,2})}),
 
-    # e.g. https://www.ijg.org/files/jpegsrc.v8d.tar.gz
+    # e.g. `https://www.ijg.org/files/jpegsrc.v8d.tar.gz`
     StemParser.new(/\.v(\d+[a-z]?)/),
 
-    # e.g. https://secure.php.net/get/php-7.1.10.tar.bz2/from/this/mirror
-    UrlParser.new(/[.-vV]?(#{NUMERIC_WITH_DOTS}#{PRERELEASE_SUFFIX}?)/),
-  ].freeze
+    # e.g. `https://secure.php.net/get/php-7.1.10.tar.bz2/from/this/mirror`
+    UrlParser.new(/[-.vV]?(#{NUMERIC_WITH_DOTS}#{PRERELEASE_SUFFIX}?)/),
+  ].freeze, T::Array[Version::Parser])
   private_constant :VERSION_PARSERS
 
-  sig { params(val: T.any(PkgVersion, String, Version), detected_from_url: T::Boolean).void }
+  sig { params(val: T.any(String, Version), detected_from_url: T::Boolean).void }
   def initialize(val, detected_from_url: false)
-    raise TypeError, "Version value must be a string; got a #{val.class} (#{val})" unless val.respond_to?(:to_str)
+    version = val.to_str
+    raise ArgumentError, "Version must not be empty" if version.blank?
 
-    @version = val.to_str
+    @version = T.let(version, String)
     @detected_from_url = detected_from_url
   end
 
@@ -522,28 +505,98 @@ def detected_from_url?
     @detected_from_url
   end
 
+  HEAD_VERSION_REGEX = /\AHEAD(?:-(?<commit>.*))?\Z/
+  private_constant :HEAD_VERSION_REGEX
+
+  # Check if this is a HEAD version.
+  #
+  # @api public
   sig { returns(T::Boolean) }
   def head?
-    false
+    version&.match?(HEAD_VERSION_REGEX) || false
+  end
+
+  # Return the commit for a HEAD version.
+  #
+  # @api public
+  sig { returns(T.nilable(String)) }
+  def commit
+    version&.match(HEAD_VERSION_REGEX)&.[](:commit)
+  end
+
+  # Update the commit for a HEAD version.
+  sig { params(commit: T.nilable(String)).void }
+  def update_commit(commit)
+    raise ArgumentError, "Cannot update commit for non-HEAD version." unless head?
+
+    @version = if commit
+      "HEAD-#{commit}"
+    else
+      "HEAD"
+    end
   end
 
   sig { returns(T::Boolean) }
   def null?
-    false
+    version.nil?
+  end
+
+  sig { params(comparator: String, other: Version).returns(T::Boolean) }
+  def compare(comparator, other)
+    case comparator
+    when ">=" then self >= other
+    when ">" then self > other
+    when "<" then self < other
+    when "<=" then self <= other
+    when "==" then self == other
+    when "!=" then self != other
+    else raise ArgumentError, "Unknown comparator: #{comparator}"
+    end
   end
 
   sig { params(other: T.untyped).returns(T.nilable(Integer)) }
   def <=>(other)
-    # Needed to retain API compatibility with older string comparisons
-    # for compiler versions, etc.
-    other = Version.new(other) if other.is_a? String
-    # Used by the *_build_version comparisons, which formerly returned Fixnum
-    other = Version.new(other.to_s) if other.is_a? Integer
-    return 1 if other.nil?
-    return 1 if other.respond_to?(:null?) && other.null?
-
-    other = Version.new(other.to_s) if other.is_a? Token
-    return unless other.is_a?(Version)
+    other = case other
+    when String
+      if other.blank?
+        # Cannot compare `NULL` to empty string.
+        return if null?
+
+        return 1
+      end
+
+      # Needed to retain API compatibility with older string comparisons for compiler versions, etc.
+      Version.new(other)
+    when Integer
+      # Used by the `*_build_version` comparisons, which formerly returned an integer.
+      Version.new(other.to_s)
+    when Token
+      if other.null?
+        # Cannot compare `NULL` to `NULL`.
+        return if null?
+
+        return 1
+      end
+
+      Version.new(other.to_s)
+    when Version
+      if other.null?
+        # Cannot compare `NULL` to `NULL`.
+        return if null?
+
+        return 1
+      end
+
+      other
+    when nil
+      return 1
+    else
+      return
+    end
+
+    # All `other.null?` cases are handled at this point.
+    return -1 if null?
+
     return 0 if version == other.version
     return 1 if head? && !other.head?
     return -1 if !head? && other.head?
@@ -577,41 +630,69 @@ def <=>(other)
 
     0
   end
+
+  sig { override.params(other: T.untyped).returns(T::Boolean) }
+  def ==(other)
+    # Makes sure that the same instance of Version::NULL
+    # will never equal itself; normally Comparable#==
+    # will return true for this regardless of the return
+    # value of #<=>
+    return false if null?
+
+    super
+  end
   alias eql? ==
 
+  # The major version.
+  #
   # @api public
   sig { returns(T.nilable(Token)) }
   def major
+    return NULL_TOKEN if null?
+
     tokens.first
   end
 
+  # The minor version.
+  #
   # @api public
   sig { returns(T.nilable(Token)) }
   def minor
+    return NULL_TOKEN if null?
+
     tokens.second
   end
 
+  # The patch version.
+  #
   # @api public
   sig { returns(T.nilable(Token)) }
   def patch
+    return NULL_TOKEN if null?
+
     tokens.third
   end
 
+  # The major and minor version.
+  #
   # @api public
   sig { returns(T.self_type) }
   def major_minor
-    self.class.new([major, minor].compact.join("."))
+    return self if null?
+
+    major_minor = T.must(tokens[0..1])
+    major_minor.empty? ? NULL : self.class.new(major_minor.join("."))
   end
 
+  # The major, minor and patch version.
+  #
   # @api public
   sig { returns(T.self_type) }
   def major_minor_patch
-    self.class.new([major, minor, patch].compact.join("."))
-  end
+    return self if null?
 
-  sig { returns(T::Boolean) }
-  def empty?
-    version.empty?
+    major_minor_patch = T.must(tokens[0..2])
+    major_minor_patch.empty? ? NULL : self.class.new(major_minor_patch.join("."))
   end
 
   sig { returns(Integer) }
@@ -619,21 +700,52 @@ def hash
     version.hash
   end
 
+  # Convert the version to a floating-point number.
+  #
+  # @api public
   sig { returns(Float) }
   def to_f
+    return Float::NAN if null?
+
     version.to_f
   end
 
+  # Convert the version to an integer.
+  #
+  # @api public
   sig { returns(Integer) }
   def to_i
     version.to_i
   end
 
+  # @api public
   sig { returns(String) }
-  def to_s
-    version.dup
+  def to_str
+    raise NoMethodError, "undefined method `to_str' for #{self.class}:NULL" if null?
+
+    T.must(version).to_str
+  end
+
+  # @api public
+  sig { returns(String) }
+  def to_s = version.to_s
+
+  sig { params(options: T.untyped).returns(String) }
+  def to_json(*options) = version.to_json(*options)
+
+  sig { params(method: T.any(Symbol, String), include_all: T::Boolean).returns(T::Boolean) }
+  def respond_to?(method, include_all = false)
+    return !null? if ["to_str", :to_str].include?(method)
+
+    super
+  end
+
+  sig { returns(String) }
+  def inspect
+    return "#<Version::NULL>" if null?
+
+    super
   end
-  alias to_str to_s
 
   sig { returns(T.self_type) }
   def freeze
@@ -643,54 +755,26 @@ def freeze
 
   protected
 
-  sig { returns(String) }
+  sig { returns(T.nilable(String)) }
   attr_reader :version
 
   sig { returns(T::Array[Token]) }
   def tokens
-    @tokens ||= tokenize
+    @tokens ||= T.let(
+      version&.scan(SCAN_PATTERN)&.map { |token| Token.create(T.cast(token, String)) } || [],
+      T.nilable(T::Array[Token]),
+    )
   end
 
   private
 
-  sig { params(a: Integer, b: Integer).returns(Integer) }
-  def max(a, b)
-    (a > b) ? a : b
-  end
-
-  sig { returns(T::Array[Token]) }
-  def tokenize
-    version.scan(SCAN_PATTERN).map { |token| Token.create(T.cast(token, String)) }
-  end
-end
-
-# A formula's HEAD version.
-# @see https://docs.brew.sh/Formula-Cookbook#unstable-versions-head Unstable versions (head)
-#
-# @api private
-class HeadVersion < Version
-  extend T::Sig
-
-  sig { returns(T.nilable(String)) }
-  attr_reader :commit
-
-  def initialize(*)
-    super
-    @commit = @version[/^HEAD-(.+)$/, 1]
-  end
-
-  sig { params(commit: T.nilable(String)).void }
-  def update_commit(commit)
-    @commit = commit
-    @version = if commit
-      "HEAD-#{commit}"
-    else
-      "HEAD"
-    end
+  sig { params(first: Integer, second: Integer).returns(Integer) }
+  def max(first, second)
+    (first > second) ? first : second
   end
 
-  sig { returns(T::Boolean) }
-  def head?
-    true
-  end
+  # Represents the absence of a version.
+  #
+  # NOTE: Constructor needs to called with an arbitrary non-empty version which is then set to `nil`.
+  NULL = T.let(Version.new("NULL").tap { |v| v.instance_variable_set(:@version, nil) }.freeze, Version)
 end
diff --git a/Library/Homebrew/version.rbi b/Library/Homebrew/version.rbi
deleted file mode 100644
index ef503c1554621..0000000000000
--- a/Library/Homebrew/version.rbi
+++ /dev/null
@@ -1,10 +0,0 @@
-# typed: strict
-
-class Version
-  # For `alias eql? ==`
-  # See discussions:
-  #  - https://github.com/sorbet/sorbet/pull/1443
-  #  - https://github.com/sorbet/sorbet/issues/2378
-  sig { params(other: T.untyped).returns(T::Boolean) }
-  def ==(other); end
-end
diff --git a/Library/Homebrew/version/null.rb b/Library/Homebrew/version/null.rb
deleted file mode 100644
index 08616aa2fe889..0000000000000
--- a/Library/Homebrew/version/null.rb
+++ /dev/null
@@ -1,106 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "singleton"
-
-class Version
-  # A pseudo-version representing the absence of a version.
-  #
-  # @api private
-  class NullVersion < Version
-    extend T::Sig
-
-    include Comparable
-    include Singleton
-
-    sig { override.params(_other: T.untyped).returns(Integer) }
-    def <=>(_other)
-      -1
-    end
-
-    sig { override.params(_other: T.untyped).returns(T::Boolean) }
-    def eql?(_other)
-      # Makes sure that the same instance of Version::NULL
-      # will never equal itself; normally Comparable#==
-      # will return true for this regardless of the return
-      # value of #<=>
-      false
-    end
-
-    sig { override.returns(T::Boolean) }
-    def detected_from_url?
-      false
-    end
-
-    sig { override.returns(T::Boolean) }
-    def head?
-      false
-    end
-
-    sig { override.returns(T::Boolean) }
-    def null?
-      true
-    end
-
-    # For {OS::Mac::Version} compatibility.
-    sig { returns(T::Boolean) }
-    def requires_nehalem_cpu?
-      false
-    end
-    alias requires_sse4? requires_nehalem_cpu?
-    alias requires_sse41? requires_nehalem_cpu?
-    alias requires_sse42? requires_nehalem_cpu?
-    alias requires_popcnt? requires_nehalem_cpu?
-    alias outdated_release? requires_nehalem_cpu?
-
-    sig { override.returns(Token) }
-    def major
-      NULL_TOKEN
-    end
-
-    sig { override.returns(Token) }
-    def minor
-      NULL_TOKEN
-    end
-
-    sig { override.returns(Token) }
-    def patch
-      NULL_TOKEN
-    end
-
-    sig { override.returns(Version) }
-    def major_minor
-      self
-    end
-
-    sig { override.returns(Version) }
-    def major_minor_patch
-      self
-    end
-
-    sig { override.returns(Float) }
-    def to_f
-      Float::NAN
-    end
-
-    sig { override.returns(Integer) }
-    def to_i
-      0
-    end
-
-    sig { override.returns(String) }
-    def to_s
-      ""
-    end
-    alias to_str to_s
-
-    sig { override.returns(String) }
-    def inspect
-      "#<Version::NULL>"
-    end
-  end
-  private_constant :NullVersion
-
-  # Represents the absence of a version.
-  NULL = NullVersion.instance.freeze
-end
diff --git a/Library/Homebrew/version/parser.rb b/Library/Homebrew/version/parser.rb
index c5127dd99e413..99beb4f82d011 100644
--- a/Library/Homebrew/version/parser.rb
+++ b/Library/Homebrew/version/parser.rb
@@ -1,10 +1,8 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class Version
-  # @api private
   class Parser
-    extend T::Sig
     extend T::Helpers
     abstract!
 
@@ -12,9 +10,7 @@ class Parser
     def parse(spec); end
   end
 
-  # @api private
   class RegexParser < Parser
-    extend T::Sig
     extend T::Helpers
     abstract!
 
@@ -41,22 +37,16 @@ def parse(spec)
     def self.process_spec(spec); end
   end
 
-  # @api private
   class UrlParser < RegexParser
-    extend T::Sig
-
     sig { override.params(spec: Pathname).returns(String) }
     def self.process_spec(spec)
       spec.to_s
     end
   end
 
-  # @api private
   class StemParser < RegexParser
-    extend T::Sig
-
-    SOURCEFORGE_DOWNLOAD_REGEX = %r{(?:sourceforge\.net|sf\.net)/.*/download$}.freeze
-    NO_FILE_EXTENSION_REGEX = /\.[^a-zA-Z]+$/.freeze
+    SOURCEFORGE_DOWNLOAD_REGEX = %r{(?:sourceforge\.net|sf\.net)/.*/download$}
+    NO_FILE_EXTENSION_REGEX = /\.[^a-zA-Z]+$/
 
     sig { override.params(spec: Pathname).returns(String) }
     def self.process_spec(spec)
diff --git a/Library/Homebrew/warnings.rb b/Library/Homebrew/warnings.rb
index f0a3ed116ff34..454b488d8be46 100644
--- a/Library/Homebrew/warnings.rb
+++ b/Library/Homebrew/warnings.rb
@@ -1,23 +1,20 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "warning"
 
 # Helper module for handling warnings.
-#
-# @api private
 module Warnings
-  module_function
-
-  COMMON_WARNINGS = {
+  COMMON_WARNINGS = T.let({
     parser_syntax: [
       %r{warning: parser/current is loading parser/ruby\d+, which recognizes},
       /warning: \d+\.\d+\.\d+-compliant syntax, but you are running \d+\.\d+\.\d+\./,
       %r{warning: please see https://github\.com/whitequark/parser#compatibility-with-ruby-mri\.},
     ],
-  }.freeze
+  }.freeze, T::Hash[Symbol, T::Array[Regexp]])
 
-  def ignore(*warnings)
+  sig { params(warnings: T.any(Symbol, Regexp), _block: T.nilable(T.proc.void)).void }
+  def self.ignore(*warnings, &_block)
     warnings.map! do |warning|
       next warning if !warning.is_a?(Symbol) || !COMMON_WARNINGS.key?(warning)
 
@@ -29,8 +26,7 @@ def ignore(*warnings)
     end
     return unless block_given?
 
-    result = yield
+    yield
     Warning.clear
-    result
   end
 end
diff --git a/Library/Homebrew/warnings.rbi b/Library/Homebrew/warnings.rbi
deleted file mode 100644
index 5d83b4cc35e44..0000000000000
--- a/Library/Homebrew/warnings.rbi
+++ /dev/null
@@ -1,5 +0,0 @@
-# typed: strict
-
-module Warnings
-  include Kernel
-end
diff --git a/Library/Homebrew/yard/docstring_parser.rb b/Library/Homebrew/yard/docstring_parser.rb
new file mode 100644
index 0000000000000..67bebedbee289
--- /dev/null
+++ b/Library/Homebrew/yard/docstring_parser.rb
@@ -0,0 +1,99 @@
+# typed: true # rubocop:todo Sorbet/StrictSigil
+# frozen_string_literal: true
+
+# from https://github.com/lsegal/yard/issues/484#issuecomment-442586899
+module Homebrew
+  module YARD
+    class DocstringParser < ::YARD::DocstringParser
+      # Every `Object` has these methods.
+      OVERRIDABLE_METHODS = [
+        :hash, :inspect, :to_s,
+        :<=>, :===, :!~, :eql?, :equal?, :!, :==, :!=
+      ].freeze
+      private_constant :OVERRIDABLE_METHODS
+
+      SELF_EXPLANATORY_METHODS = [:to_yaml, :to_json, :to_str].freeze
+      private_constant :SELF_EXPLANATORY_METHODS
+
+      def parse_content(content)
+        # Convert plain text to tags.
+        content = content&.gsub(/^\s*(TODO|FIXME):\s*/i, "@todo ")
+        content = content&.gsub(/^\s*NOTE:\s*/i, "@note ")
+
+        # Ignore non-documentation comments.
+        content = content&.sub(/\A(typed|.*rubocop):.*/m, "")
+
+        content = super
+
+        source = handler&.statement&.source
+
+        if object&.type == :method &&
+           (match = source&.match(/\so(deprecated|disabled)\s+"((?:\\"|[^"])*)"(?:\s*,\s*"((?:\\"|[^"])*))?"/m))
+          type = match[1]
+          method = match[2]
+          method = method.sub(/\#{self(\.class)?}/, object.namespace.to_s)
+          replacement = match[3]
+          replacement = replacement.sub(/\#{self(\.class)?}/, object.namespace.to_s)
+
+          # Only match `odeprecated`/`odisabled` for this method.
+          if method.match?(/(.|#|`)#{Regexp.escape(object.name.to_s)}`/)
+            if (method_name = method[/\A`([^`]*)`\Z/, 1]) && (
+              (method_name.count(".") + method_name.count("#")) <= 1
+            )
+              method_name = method_name.delete_prefix(object.namespace.to_s)
+              method = (method_name.delete_prefix(".") == object.name(true).to_s) ? nil : "{#{method_name}}"
+            end
+
+            if replacement &&
+               (replacement_method_name = replacement[/\A`([^`]*)`\Z/, 1]) && (
+               (replacement_method_name.count(".") + replacement_method_name.count("#")) <= 1
+             )
+              replacement_method_name = replacement_method_name.delete_prefix(object.namespace.to_s)
+              replacement = "{#{replacement_method_name}}"
+            end
+
+            if method && !method.include?('#{')
+              description = "Calling #{method} is #{type}"
+              description += ", use #{replacement} instead" if replacement && !replacement.include?('#{')
+              description += "."
+            elsif replacement && !replacement.include?('#{')
+              description = "Use #{replacement} instead."
+            else
+              description = ""
+            end
+
+            tags << create_tag("deprecated", description)
+          end
+        end
+
+        api = tags.find { |tag| tag.tag_name == "api" }&.text
+        is_private = tags.any? { |tag| tag.tag_name == "private" }
+        visibility = directives.find { |d| d.tag.tag_name == "visibility" }&.tag&.text
+
+        # Hide `#hash`, `#inspect` and `#to_s`.
+        if visibility.nil? && OVERRIDABLE_METHODS.include?(object&.name)
+          create_directive("visibility", "private")
+          visibility = "private"
+        end
+
+        # Mark everything as `@api private` by default.
+        if api.nil? && !is_private
+          tags << create_tag("api", "private")
+          api = "private"
+        end
+
+        # Warn about undocumented non-private APIs.
+        if handler && api && api != "private" && visibility != "private" &&
+           content.chomp.empty? && !SELF_EXPLANATORY_METHODS.include?(object&.name)
+          stmt = handler.statement
+          log.warn "#{api.capitalize} API should be documented:\n  " \
+                   "in `#{handler.parser.file}`:#{stmt.line}:\n\n#{stmt.show}\n"
+        end
+
+        content
+      end
+    end
+  end
+end
+
+YARD::Docstring.default_parser = Homebrew::YARD::DocstringParser
diff --git a/Library/Homebrew/yard/ignore_directives.rb b/Library/Homebrew/yard/ignore_directives.rb
deleted file mode 100644
index 4685ce026ef6f..0000000000000
--- a/Library/Homebrew/yard/ignore_directives.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-# from https://github.com/lsegal/yard/issues/484#issuecomment-442586899
-class IgnoreDirectiveDocstringParser < YARD::DocstringParser
-  def parse_content(content)
-    super(content&.sub(/(\A(typed|.*rubocop)|TODO):.*/m, ""))
-  end
-end
-
-YARD::Docstring.default_parser = IgnoreDirectiveDocstringParser
diff --git a/Library/Homebrew/yard/templates/default/docstring/html/setup.rb b/Library/Homebrew/yard/templates/default/docstring/html/setup.rb
index 6d07ea8198fab..ab197a0fe6a57 100644
--- a/Library/Homebrew/yard/templates/default/docstring/html/setup.rb
+++ b/Library/Homebrew/yard/templates/default/docstring/html/setup.rb
@@ -1,7 +1,12 @@
-# typed: false
+# typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+# This follows the docs at https://github.com/lsegal/yard/blob/main/docs/Templates.md#setuprb
+# rubocop:disable Style/TopLevelMethodDefinition
 def init
+  # `sorbet` is available transitively through the `yard-sorbet` plugin, but we're
+  # outside of the standalone sorbet config, so `checked` is enabled by default
+  T.bind(self, T.all(Class, YARD::Templates::Template), checked: false)
   super
 
   return if sections.empty?
@@ -10,5 +15,7 @@ def init
 end
 
 def internal
+  T.bind(self, YARD::Templates::Template, checked: false)
   erb(:internal) if object.has_tag?(:api) && object.tag(:api).text == "internal"
 end
+# rubocop:enable Style/TopLevelMethodDefinition
diff --git a/README.md b/README.md
index 9f000dc1108ef..0ef0359a849d4 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,6 @@ Features, usage and installation instructions are [summarised on the homepage](h
 
 1. Type `brew formulae` for a list.
 2. Or visit [formulae.brew.sh](https://formulae.brew.sh) to browse packages online.
-3. Or use `brew search --desc <keyword>` to browse packages from the command line.
 
 ## More Documentation
 
@@ -22,50 +21,53 @@ Second, read the [Troubleshooting Checklist](https://docs.brew.sh/Troubleshootin
 
 **If you don't read these it will take us far longer to help you with your problem.**
 
+## Donations
+
+Homebrew is a non-profit project run entirely by unpaid volunteers. We need your funds to pay for software, hardware and hosting around continuous integration and future improvements to the project. Every donation will be spent on making Homebrew better for our users.
+
+Please consider a regular donation through [GitHub Sponsors](https://github.com/sponsors/Homebrew), [Open Collective](https://opencollective.com/homebrew) or [Patreon](https://www.patreon.com/homebrew). Homebrew is fiscally hosted by the [Open Source Collective](https://opencollective.com/opensource).
+
+For questions about donations, including corporate giving, please email the Homebrew PLC at [plc@brew.sh](mailto:plc@brew.sh).
+
+## Community
+
+- [Homebrew/discussions (forum)](https://github.com/orgs/Homebrew/discussions)
+- [@homebrew@fosstodon.org (Mastodon)](https://fosstodon.org/@homebrew)
+- [@MacHomebrew (𝕏 (formerly known as Twitter))](https://x.com/MacHomebrew)
+
 ## Contributing
 
 We'd love you to contribute to Homebrew. First, please read our [Contribution Guide](CONTRIBUTING.md) and [Code of Conduct](https://github.com/Homebrew/.github/blob/HEAD/CODE_OF_CONDUCT.md#code-of-conduct).
 
 We explicitly welcome contributions from people who have never contributed to open-source before: we were all beginners once! We can help build on a partially working pull request with the aim of getting it merged. We are also actively seeking to diversify our contributors and especially welcome contributions from women from all backgrounds and people of colour.
 
-A good starting point for contributing is running `brew audit --strict` with some of the packages you use (e.g. `brew audit --strict wget` if you use `wget`) and then read through the warnings, try to fix them until `brew audit --strict` shows no results and [submit a pull request](https://docs.brew.sh/How-To-Open-a-Homebrew-Pull-Request). If no formulae you use have warnings you can run `brew audit --strict` without arguments to have it run on all packages and pick one.
+A good starting point for contributing is to first [tap `homebrew/core`](https://docs.brew.sh/FAQ#can-i-edit-formulae-myself), then run `brew audit --strict` with some of the packages you use (e.g. `brew audit --strict wget` if you use `wget`) and read through the warnings. Try to fix them until `brew audit --strict` shows no results and [submit a pull request](https://docs.brew.sh/How-To-Open-a-Homebrew-Pull-Request). If no formulae you use have warnings you can run `brew audit --strict` without arguments to have it run on all packages and pick one.
 
-Alternatively, for something more substantial, check out one of the issues labeled `help wanted` in [Homebrew/brew](https://github.com/homebrew/brew/issues?q=is%3Aopen+is%3Aissue+label%3A%22help+wanted%22) or [Homebrew/homebrew-core](https://github.com/homebrew/homebrew-core/issues?q=is%3Aopen+is%3Aissue+label%3A%22help+wanted%22).
+Alternatively, for something more substantial, check out one of the issues labelled `help wanted` in [Homebrew/brew](https://github.com/homebrew/brew/issues?q=is%3Aopen+is%3Aissue+label%3A%22help+wanted%22) or [Homebrew/homebrew-core](https://github.com/homebrew/homebrew-core/issues?q=is%3Aopen+is%3Aissue+label%3A%22help+wanted%22).
 
 Good luck!
 
 ## Security
 
-Please report security issues to our [HackerOne](https://hackerone.com/homebrew/).
+Please report security issues by filling in [the security advisory form](https://github.com/homebrew/brew/security/advisories/new).
 
 ## Who We Are
 
 Homebrew's [Project Leader](https://docs.brew.sh/Homebrew-Governance#6-project-leader) is [Mike McQuaid](https://github.com/MikeMcQuaid).
 
-Homebrew's [Project Leadership Committee](https://docs.brew.sh/Homebrew-Governance#4-project-leadership-committee) is [Issy Long](https://github.com/issyl0), [Jonathan Chang](https://github.com/jonchang), [Mike McQuaid](https://github.com/MikeMcQuaid), [Misty De Méo](https://github.com/mistydemeo) and [Sean Molenaar](https://github.com/SMillerDev).
+Homebrew's [Project Leadership Committee](https://docs.brew.sh/Homebrew-Governance#4-project-leadership-committee) is [Colin Dean](https://github.com/colindean), [Issy Long](https://github.com/issyl0), [Mike McQuaid](https://github.com/MikeMcQuaid), [Patrick Linnane](https://github.com/p-linnane) and [Vanessa Gennarelli](https://github.com/mozzadrella).
 
 Homebrew's [Technical Steering Committee](https://docs.brew.sh/Homebrew-Governance#7-technical-steering-committee) is [Bo Anderson](https://github.com/Bo98), [FX Coudert](https://github.com/fxcoudert), [Michka Popoff](https://github.com/iMichka), [Mike McQuaid](https://github.com/MikeMcQuaid) and [Rylan Polster](https://github.com/Rylan12).
 
-Homebrew's other current maintainers are [Alexander Bayandin](https://github.com/bayandin), [Bevan Kay](https://github.com/bevanjkay), [Branch Vincent](https://github.com/branchvincent), [Caleb Xu](https://github.com/alebcay), [Carlo Cabrera](https://github.com/carlocab), [Daniel Nachun](https://github.com/danielnachun), [Dawid Dziurla](https://github.com/dawidd6), [Dustin Rodrigues](https://github.com/dtrodrigues), [Eric Knibbe](https://github.com/EricFromCanada), [George Adams](https://github.com/gdams), [Markus Reiter](https://github.com/reitermarkus), [Maxim Belkin](https://github.com/maxim-belkin), [Miccal Matthews](https://github.com/miccal), [Michael Cho](https://github.com/cho-m), [Nanda H Krishna](https://github.com/nandahkrishna), [Randall](https://github.com/ran-dall), [Rui Chen](https://github.com/chenrui333), [Sam Ford](https://github.com/samford), [Shaun Jackman](https://github.com/sjackman), [Steve Peters](https://github.com/scpeters), [Thierry Moisan](https://github.com/Moisan) and [Vítor Galvão](https://github.com/vitorgalvao).
+Homebrew's maintainers are [Alexander Bayandin](https://github.com/bayandin), [Bevan Kay](https://github.com/bevanjkay), [Bo Anderson](https://github.com/Bo98), [Branch Vincent](https://github.com/branchvincent), [Caleb Xu](https://github.com/alebcay), [Carlo Cabrera](https://github.com/carlocab), [Daeho Ro](https://github.com/daeho-ro), [Douglas Eichelberger](https://github.com/dduugg), [Dustin Rodrigues](https://github.com/dtrodrigues), [Eric Knibbe](https://github.com/EricFromCanada), [FX Coudert](https://github.com/fxcoudert), [Issy Long](https://github.com/issyl0), [Justin Krehel](https://github.com/krehel), [Klaus Hipp](https://github.com/khipp), [Markus Reiter](https://github.com/reitermarkus), [Michael Cho](https://github.com/cho-m), [Michka Popoff](https://github.com/iMichka), [Mike McQuaid](https://github.com/MikeMcQuaid), [Nanda H Krishna](https://github.com/nandahkrishna), [Patrick Linnane](https://github.com/p-linnane), [Rui Chen](https://github.com/chenrui333), [Ruoyu Zhong](https://github.com/ZhongRuoyu), [Rylan Polster](https://github.com/Rylan12), [Sam Ford](https://github.com/samford), [Sean Molenaar](https://github.com/SMillerDev), [Thierry Moisan](https://github.com/Moisan), [Timothy Sutton](https://github.com/timsutton), [William Woodruff](https://github.com/woodruffw) and [Štefan Baebler](https://github.com/stefanb).
 
-Former maintainers with significant contributions include [Claudia Pellegrino](https://github.com/claui), [Seeker](https://github.com/SeekingMeaning), [William Woodruff](https://github.com/woodruffw), [Jan Viljanen](https://github.com/javian), [JCount](https://github.com/jcount), [commitay](https://github.com/commitay), [Dominyk Tiller](https://github.com/DomT4), [Tim Smith](https://github.com/tdsmith), [Baptiste Fontaine](https://github.com/bfontaine), [Xu Cheng](https://github.com/xu-cheng), [Martin Afanasjew](https://github.com/UniqMartin), [Brett Koonce](https://github.com/asparagui), [Charlie Sharpsteen](https://github.com/Sharpie), [Jack Nagel](https://github.com/jacknagel), [Adam Vandenberg](https://github.com/adamv), [Andrew Janke](https://github.com/apjanke), [Alex Dunn](https://github.com/dunn), [neutric](https://github.com/neutric), [Tomasz Pajor](https://github.com/nijikon), [Uladzislau Shablinski](https://github.com/vladshablinsky), [Alyssa Ross](https://github.com/alyssais), [ilovezfs](https://github.com/ilovezfs), [Chongyu Zhu](https://github.com/lembacon) and Homebrew's creator: [Max Howell](https://github.com/mxcl).
-
-## Community
-
-- [Homebrew/discussions (forum)](https://github.com/orgs/Homebrew/discussions)
-- [@MacHomebrew (Twitter)](https://twitter.com/MacHomebrew)
+Former maintainers with significant contributions include [Miccal Matthews](https://github.com/miccal), [Misty De Méo](https://github.com/mistydemeo), [Shaun Jackman](https://github.com/sjackman), [Vítor Galvão](https://github.com/vitorgalvao), [Claudia Pellegrino](https://github.com/claui), [Seeker](https://github.com/SeekingMeaning), [Jan Viljanen](https://github.com/javian), [JCount](https://github.com/jcount), [commitay](https://github.com/commitay), [Dominyk Tiller](https://github.com/DomT4), [Tim Smith](https://github.com/tdsmith), [Baptiste Fontaine](https://github.com/bfontaine), [Xu Cheng](https://github.com/xu-cheng), [Martin Afanasjew](https://github.com/UniqMartin), [Brett Koonce](https://github.com/asparagui), [Charlie Sharpsteen](https://github.com/Sharpie), [Jack Nagel](https://github.com/jacknagel), [Adam Vandenberg](https://github.com/adamv), [Andrew Janke](https://github.com/apjanke), [Alex Dunn](https://github.com/dunn), [neutric](https://github.com/neutric), [Tomasz Pajor](https://github.com/nijikon), [Uladzislau Shablinski](https://github.com/vladshablinsky), [Alyssa Ross](https://github.com/alyssais), [ilovezfs](https://github.com/ilovezfs), [Chongyu Zhu](https://github.com/lembacon) and Homebrew's creator: [Max Howell](https://github.com/mxcl).
 
 ## License
 
 Code is under the [BSD 2-clause "Simplified" License](LICENSE.txt).
 Documentation is under the [Creative Commons Attribution license](https://creativecommons.org/licenses/by/4.0/).
 
-## Donations
-
-Homebrew is a non-profit project run entirely by unpaid volunteers. We need your funds to pay for software, hardware and hosting around continuous integration and future improvements to the project. Every donation will be spent on making Homebrew better for our users.
-
-Please consider a regular donation through [GitHub Sponsors](https://github.com/sponsors/Homebrew), [Open Collective](https://opencollective.com/homebrew) or [Patreon](https://www.patreon.com/homebrew). Homebrew is fiscally hosted by the [Open Source Collective](https://opencollective.com/opensource).
-
 ## Sponsors
 
 Our macOS continuous integration infrastructure is hosted by [MacStadium's Orka](https://www.macstadium.com/customers/homebrew).
@@ -74,17 +76,17 @@ Our macOS continuous integration infrastructure is hosted by [MacStadium's Orka]
 
 Secure password storage and syncing is provided by [1Password for Teams](https://1password.com/teams/).
 
-[![1Password](https://1password.com/img/redesign/press/logo.c757be5591a513da9c768f8b80829318.svg)](https://1password.com)
+[<img src="https://i.1password.com/akb/featured/1password-icon.svg" alt="1Password" height="64">](https://1password.com)
 
 Flaky test detection and tracking is provided by [BuildPulse](https://buildpulse.io/).
 
-[![BuildPulse](https://user-images.githubusercontent.com/2988/130445500-96f44c87-e7dd-4da0-9877-7e5b1618e144.png)](https://buildpulse.io)
+[![BuildPulse](https://github.com/Homebrew/brew/assets/1699443/87385e9a-6c47-4e59-b17e-fe083e945709)](https://buildpulse.io)
 
 <https://brew.sh>'s DNS is [resolving with DNSimple](https://dnsimple.com/resolving/homebrew).
 
 [![DNSimple](https://cdn.dnsimple.com/assets/resolving-with-us/logo-light.png)](https://dnsimple.com/resolving/homebrew#gh-light-mode-only)
 [![DNSimple](https://cdn.dnsimple.com/assets/resolving-with-us/logo-dark.png)](https://dnsimple.com/resolving/homebrew#gh-dark-mode-only)
 
-Homebrew is generously supported by [Substack](https://github.com/substackinc), [Randy Reddig](https://github.com/ydnar), [embark-studios](https://github.com/embark-studios), [CodeCrafters](https://github.com/codecrafters-io) and many other users and organisations via [GitHub Sponsors](https://github.com/sponsors/Homebrew).
+Homebrew is generously supported by [GitHub](https://github.com/github), [Custom Ink](https://github.com/customink), [Randy Reddig](https://github.com/ydnar), [Codecademy](https://github.com/Codecademy), [thanks.dev](https://github.com/thnxdev), [Workbrew](https://github.com/Workbrew) and many other users and organisations via [GitHub Sponsors](https://github.com/sponsors/Homebrew).
 
-[![Substack](https://github.com/substackinc.png?size=64)](https://github.com/substackinc)
+[![GitHub](https://github.com/github.png?size=64)](https://github.com/github)[![thanks.dev](https://github.com/thnxdev.png?size=64)](https://github.com/thnxdev)
diff --git a/bin/brew b/bin/brew
index 30e1fec5f2e05..58bc4f24a35e3 100755
--- a/bin/brew
+++ b/bin/brew
@@ -1,4 +1,5 @@
-#!/bin/bash
+#!/bin/bash -p
+set -u
 
 # Fail fast with concise message when not using bash
 # Single brackets is needed here for POSIX compatibility
@@ -11,15 +12,32 @@ fi
 
 set +o posix # as we are using bash now
 
-# Fail fast with concise message when cwd does not exist
+# Fail fast with concise messages when PWD has issues
+if [[ -z "${PWD-}" ]]
+then
+  echo "Error: \$PWD must be set to run brew." >&2
+  exit 1
+fi
 if ! [[ -d "${PWD}" ]]
 then
-  echo "Error: The current working directory doesn't exist, cannot proceed." >&2
+  echo "Error: The current working directory must exist to run brew." >&2
+  exit 1
+fi
+if ! [[ -r "${PWD}" ]]
+then
+  echo "Error: The current working directory must be readable to ${USER} to run brew." >&2
+  exit 1
+fi
+
+# Fail fast with concise message when HOME is unset
+if [[ -z "${HOME:-}" ]]
+then
+  echo "Error: \$HOME must be set to run brew." >&2
   exit 1
 fi
 
 quiet_cd() {
-  cd "$@" &>/dev/null || return
+  CDPATH='' cd -- "$@" &>/dev/null || return
 }
 
 symlink_target_directory() {
@@ -39,6 +57,28 @@ do
 done
 unset cmd
 
+# Avoid picking up any random `sudo` in `PATH`.
+if [[ -x /usr/bin/sudo ]]
+then
+  SUDO=/usr/bin/sudo
+else
+  # Do this after ensuring we're using default Bash builtins.
+  SUDO="$(command -v sudo 2>/dev/null)"
+fi
+
+# Reset sudo timestamp to avoid running unauthorized sudo commands
+if [[ -n "${SUDO}" ]]
+then
+  "${SUDO}" --reset-timestamp 2>/dev/null || true
+fi
+unset SUDO
+
+# Take the HOMEBREW_PATH if we are running brew within brew, otherwise we would lose the original path.
+if [[ -n "${HOMEBREW_BREW_FILE:-}" && -n "${HOMEBREW_PATH:-}" ]]
+then
+  PATH="${HOMEBREW_PATH}"
+fi
+
 BREW_FILE_DIRECTORY="$(quiet_cd "${0%/*}/" && pwd -P)"
 HOMEBREW_BREW_FILE="${BREW_FILE_DIRECTORY%/}/${0##*/}"
 HOMEBREW_PREFIX="${HOMEBREW_BREW_FILE%/*/*}"
@@ -58,7 +98,7 @@ then
   HOMEBREW_REPOSITORY="${BREW_FILE_DIRECTORY%/*}"
 fi
 
-# Try to find a /usr/local HOMEBREW_PREFIX where possible (for bottles)
+# Try to find a /usr/local HOMEBREW_PREFIX where possible (for macOS x86_64 bottles)
 if [[ -L "/usr/local/bin/brew" && ! -L "${HOMEBREW_PREFIX}/Cellar" ]]
 then
   USR_LOCAL_BREW_FILE_DIRECTORY="$(symlink_target_directory "/usr/local/bin/brew" "/usr/local/bin")"
@@ -67,35 +107,121 @@ then
   then
     HOMEBREW_PREFIX="/usr/local"
   fi
+  unset USR_LOCAL_BREW_FILE_DIRECTORY USR_LOCAL_HOMEBREW_REPOSITORY
 fi
 
+unset BREW_FILE_DIRECTORY
+
 # If the location of HOMEBREW_LIBRARY changes
 # keg_relocate.rb, formula_cellar_checks.rb, and test/global_spec.rb need to change.
 HOMEBREW_LIBRARY="${HOMEBREW_REPOSITORY}/Library"
 
+# Load Homebrew's variable configuration files from disk.
+export_homebrew_env_file() {
+  local env_file
+
+  env_file="${1}"
+  [[ -r "${env_file}" ]] || return 0
+  while read -r line
+  do
+    # only load HOMEBREW_* lines
+    [[ "${line}" = "HOMEBREW_"* ]] || continue
+    export "${line?}"
+  done <"${env_file}"
+}
+
+# First, load the system-wide configuration.
+unset SYSTEM_ENV_TAKES_PRIORITY
+if [[ -n "${HOMEBREW_SYSTEM_ENV_TAKES_PRIORITY-}" ]]
+then
+  SYSTEM_ENV_TAKES_PRIORITY="1"
+else
+  export_homebrew_env_file "/etc/homebrew/brew.env"
+fi
+
+# Next, load the prefix configuration
+export_homebrew_env_file "${HOMEBREW_PREFIX}/etc/homebrew/brew.env"
+
+# Finally, load the user configuration
+if [[ -n "${XDG_CONFIG_HOME-}" ]]
+then
+  HOMEBREW_USER_CONFIG_HOME="${XDG_CONFIG_HOME}/homebrew"
+else
+  HOMEBREW_USER_CONFIG_HOME="${HOME}/.homebrew"
+fi
+
+export_homebrew_env_file "${HOMEBREW_USER_CONFIG_HOME}/brew.env"
+
+# If the system configuration takes priority, load it last.
+if [[ -n "${SYSTEM_ENV_TAKES_PRIORITY-}" ]]
+then
+  export_homebrew_env_file "/etc/homebrew/brew.env"
+fi
+
 # Copy and export all HOMEBREW_* variables previously mentioned in
 # manpage or used elsewhere by Homebrew.
-for VAR in BAT_THEME BROWSER DISPLAY EDITOR NO_COLOR TMUX DBUS_SESSION_BUS_ADDRESS
+
+# These variables are allowed to be set by the user as, e.g., `HOMEBREW_BROWSER`.
+MANPAGE_VARS=(
+  BAT_CONFIG_PATH
+  BAT_THEME
+  BROWSER
+  BUNDLE_USER_CACHE
+  DISPLAY
+  EDITOR
+  NO_COLOR
+)
+for VAR in "${MANPAGE_VARS[@]}"
 do
   # Skip if variable value is empty.
-  [[ -z "${!VAR}" ]] && continue
+  [[ -z "${!VAR:-}" ]] && continue
 
   VAR_NEW="HOMEBREW_${VAR}"
   # Skip if existing HOMEBREW_* variable is set.
-  [[ -n "${!VAR_NEW}" ]] && continue
+  [[ -n "${!VAR_NEW:-}" ]] && continue
   export "${VAR_NEW}"="${!VAR}"
 done
-unset VAR VAR_NEW
+
+# We don't want to take the user's value for, e.g., `HOMEBREW_PATH` here!
+USED_BY_HOMEBREW_VARS=(
+  CODESPACES
+  COLORTERM
+  DBUS_SESSION_BUS_ADDRESS
+  NODENV_ROOT
+  PATH
+  PYENV_ROOT
+  RBENV_ROOT
+  SSH_TTY
+  SUDO_USER
+  TMPDIR
+  TMUX
+  XDG_CACHE_HOME
+  XDG_DATA_DIRS
+  XDG_RUNTIME_DIR
+  ZDOTDIR
+)
+for VAR in "${USED_BY_HOMEBREW_VARS[@]}"
+do
+  # Skip if variable value is empty.
+  [[ -z "${!VAR:-}" ]] && continue
+
+  # We unconditionally override `HOMEBREW_*` here.
+  VAR_NEW="HOMEBREW_${VAR}"
+  export "${VAR_NEW}"="${!VAR}"
+done
+
+unset VAR VAR_NEW MANPAGE_VARS USED_BY_HOMEBREW_VARS
 
 export HOMEBREW_BREW_FILE
 export HOMEBREW_PREFIX
 export HOMEBREW_REPOSITORY
 export HOMEBREW_LIBRARY
+export HOMEBREW_USER_CONFIG_HOME
 
 # set from user environment
 # shellcheck disable=SC2154
 # Use VISUAL if HOMEBREW_EDITOR and EDITOR are unset.
-if [[ -z "${HOMEBREW_EDITOR}" && -n "${VISUAL}" ]]
+if [[ -z "${HOMEBREW_EDITOR:-}" && -n "${VISUAL:-}" ]]
 then
   export HOMEBREW_EDITOR="${VISUAL}"
 fi
@@ -104,42 +230,57 @@ fi
 # shellcheck disable=SC2154
 # Set CI variable for Azure Pipelines and Jenkins
 # (Set by default on GitHub Actions, Circle and Travis CI)
-if [[ -z "${CI}" ]] && [[ -n "${TF_BUILD}" || -n "${JENKINS_HOME}" ]]
+if [[ -z "${CI:-}" ]] && [[ -n "${TF_BUILD:-}" || -n "${JENKINS_HOME:-}" ]]
 then
   export CI="1"
 fi
 
-# save the existing user path as HOMEBREW_PATH so it can be queried by
-# e.g. brew doctor later.
-HOMEBREW_PATH="${PATH}"
-export HOMEBREW_PATH
+if [[ -n "${GITHUB_ACTIONS:-}" && -n "${ImageOS:-}" && -n "${ImageVersion:-}" ]]
+then
+  export HOMEBREW_GITHUB_HOSTED_RUNNER=1
+fi
 
-# set from user environment
-# shellcheck disable=SC2154
-if [[ -z "${HOMEBREW_NO_ENV_FILTERING}" ]]
-then
-  PATH="/usr/bin:/bin:/usr/sbin:/sbin"
-
-  FILTERED_ENV=()
-  ENV_VAR_NAMES=(
-    HOME SHELL PATH TERM TERMINFO TERMINFO_DIRS COLUMNS DISPLAY LOGNAME USER CI SSH_AUTH_SOCK SUDO_ASKPASS
-    http_proxy https_proxy ftp_proxy no_proxy all_proxy HTTPS_PROXY FTP_PROXY ALL_PROXY
-    GITHUB_ACTIONS GITHUB_WORKSPACE GITHUB_ACTIONS_HOMEBREW_SELF_HOSTED
-    GITHUB_REPOSITORY GITHUB_RUN_ID GITHUB_RUN_ATTEMPT GITHUB_SHA GITHUB_HEAD_REF GITHUB_BASE_REF GITHUB_REF
-  )
-  # Filter all but the specific variables.
-  for VAR in "${ENV_VAR_NAMES[@]}" "${!HOMEBREW_@}"
+# filter the user environment
+PATH="/usr/bin:/bin:/usr/sbin:/sbin"
+
+FILTERED_ENV=()
+ENV_VAR_NAMES=(
+  HOME SHELL PATH TERM TERMINFO TERMINFO_DIRS COLUMNS DISPLAY LOGNAME USER CI SSH_AUTH_SOCK SUDO_ASKPASS
+  http_proxy https_proxy ftp_proxy no_proxy all_proxy HTTPS_PROXY FTP_PROXY ALL_PROXY
+)
+# Filter all but the specific variables.
+for VAR in "${ENV_VAR_NAMES[@]}" "${!HOMEBREW_@}"
+do
+  # Skip if variable value is empty.
+  [[ -z "${!VAR:-}" ]] && continue
+
+  FILTERED_ENV+=("${VAR}=${!VAR}")
+done
+
+if [[ -n "${CI:-}" ]]
+then
+  for VAR in "${!GITHUB_@}"
   do
     # Skip if variable value is empty.
-    [[ -z "${!VAR}" ]] && continue
+    [[ -z "${!VAR:-}" ]] && continue
+    # Skip variables that look like tokens.
+    [[ "${VAR}" = *TOKEN* ]] && continue
 
     FILTERED_ENV+=("${VAR}=${!VAR}")
   done
-  unset VAR ENV_VAR_NAMES
+fi
 
-  exec /usr/bin/env -i "${FILTERED_ENV[@]}" /bin/bash "${HOMEBREW_LIBRARY}/Homebrew/brew.sh" "$@"
-else
-  echo "Warning: HOMEBREW_NO_ENV_FILTERING is undocumented, deprecated and will be removed in a future Homebrew release (because it breaks many things)!" >&2
+if [[ -n "${HOMEBREW_RDBG:-}" ]]
+then
+  for VAR in "${!RUBY_DEBUG_@}"
+  do
+    # Skip if variable value is empty.
+    [[ -z "${!VAR:-}" ]] && continue
 
-  source "${HOMEBREW_LIBRARY}/Homebrew/brew.sh"
+    FILTERED_ENV+=("${VAR}=${!VAR}")
+  done
 fi
+
+unset VAR ENV_VAR_NAMES
+
+exec /usr/bin/env -i "${FILTERED_ENV[@]}" /bin/bash -p "${HOMEBREW_LIBRARY}/Homebrew/brew.sh" "$@"
diff --git a/completions/bash/brew b/completions/bash/brew
index 86abb433c2eac..1a916500f3468 100644
--- a/completions/bash/brew
+++ b/completions/bash/brew
@@ -1,42 +1,36 @@
 # Bash completion script for brew(1)
+# This file is automatically generated by running `brew generate-man-completions`.
+# See Library/Homebrew/completions/bash.erb for editing instructions.
+
+if [[ -n ${POSIXLY_CORRECT:-} ]] || shopt -oq posix
+then
+  echo "Homebrew Bash completions do not work in POSIX mode" 1>&2
+  return
+fi
 
 __brewcomp_words_include() {
-  local i=1
-  while [[ "${i}" -lt "${COMP_CWORD}" ]]
+  local element idx
+  for (( idx = 1; idx < COMP_CWORD; idx++ ))
   do
-    if [[ "${COMP_WORDS[i]}" = "$1" ]]
-    then
-      return 0
-    fi
-    (( i++ ))
+    element=${COMP_WORDS[idx]}
+    [[ -n ${element} && ${element} == "$1" ]] && return 0
   done
   return 1
 }
 
-# Find the previous non-switch word
-__brewcomp_prev() {
-  local idx="$((COMP_CWORD - 1))"
-  local prv="${COMP_WORDS[idx]}"
-  while [[ "${prv}" = -* ]]
-  do
-    (( idx-- ))
-    prv="${COMP_WORDS[idx]}"
-  done
-  echo "${prv}"
-}
-
 __brewcomp() {
   # break $1 on space, tab, and newline characters,
   # and turn it into a newline separated list of words
   local list s sep=$'\n' IFS=$' \t\n'
-  local cur="${COMP_WORDS[COMP_CWORD]}"
+  local cur=${COMP_WORDS[COMP_CWORD]}
 
   for s in $1
   do
-    __brewcomp_words_include "${s}" && continue
-    list="${list}${s}${sep}"
+    __brewcomp_words_include "${s}" || list+="${s}${sep}"
   done
 
+  list=${list%"${sep}"}
+
   IFS="${sep}"
   while read -r line; do COMPREPLY+=("${line}"); done < <(compgen -W "${list}" -- "${cur}")
 }
@@ -60,7 +54,7 @@ __brew_complete_casks() {
 __brew_complete_installed_formulae() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   local installed_formulae
-  installed_formulae="$(command ls "$(brew --cellar)" 2>/dev/null)"
+  installed_formulae="$(command ls "${HOMEBREW_CELLAR:-$(brew --cellar)}" 2>/dev/null)"
   while read -r line; do COMPREPLY+=("${line}"); done < <(compgen -W "${installed_formulae}" -- "${cur}")
 }
 
@@ -74,44 +68,50 @@ __brew_complete_installed_casks() {
 __brew_complete_outdated_formulae() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   local outdated_formulae
-  outdated_formulae="$(brew outdated --formula --quiet)"
+  outdated_formulae="$(HOMEBREW_NO_AUTO_UPDATE=1 brew outdated --formula --quiet)"
   while read -r line; do COMPREPLY+=("${line}"); done < <(compgen -W "${outdated_formulae}" -- "${cur}")
 }
 
 __brew_complete_outdated_casks() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   local outdated_casks
-  outdated_casks="$(brew outdated --cask --quiet)"
+  outdated_casks="$(HOMEBREW_NO_AUTO_UPDATE=1 brew outdated --cask --quiet 2>/dev/null)"
   while read -r line; do COMPREPLY+=("${line}"); done < <(compgen -W "${outdated_casks}" -- "${cur}")
 }
 
 __brew_complete_tapped() {
   local dir taps taplib
-  taplib="$(brew --repository)/Library/Taps"
+  taplib=${HOMEBREW_REPOSITORY:-$(brew --repository)}/Library/Taps
 
   for dir in "${taplib}"/*/*
   do
-    [[ -d "${dir}" ]] || continue
-    dir="${dir#"${taplib}"/}"
-    dir="${dir/homebrew-/}"
-    taps="${taps} ${dir}"
+    [[ -d ${dir} ]] || continue
+    dir=${dir#"${taplib}"/}
+    dir=${dir/homebrew-/}
+    taps+=" ${dir}"
   done
   __brewcomp "${taps}"
 }
 
 __brew_complete_commands() {
+  # Auto-complete Homebrew commands
+  # Do NOT auto-complete "*instal" aliases for "*install" commands
+
   local cur="${COMP_WORDS[COMP_CWORD]}"
   local cmds
-  HOMEBREW_CACHE=$(brew --cache)
-  HOMEBREW_REPOSITORY=$(brew --repo)
-  # Do not auto-complete "*instal" or "*uninstal" aliases for "*install" commands.
-  if [[ -f "${HOMEBREW_CACHE}/all_commands_list.txt" ]]
+
+  if [[ -n ${__HOMEBREW_COMMANDS} ]]
+  then
+    cmds=${__HOMEBREW_COMMANDS}
+  elif [[ -n ${HOMEBREW_CACHE:-} && -f ${HOMEBREW_CACHE}/all_commands_list.txt ]]
   then
     cmds="$(< "${HOMEBREW_CACHE}/all_commands_list.txt" \grep -v instal$)"
-  else
+  elif [[ -n ${HOMEBREW_REPOSITORY:-} && -f ${HOMEBREW_REPOSITORY}/completions/internal_commands_list.txt ]]
+  then
     cmds="$(< "${HOMEBREW_REPOSITORY}/completions/internal_commands_list.txt" \grep -v instal$)"
   fi
   while read -r line; do COMPREPLY+=("${line}"); done < <(compgen -W "${cmds}" -- "${cur}")
+  export __HOMEBREW_COMMANDS=${cmds}
 }
 
 # compopt is only available in newer versions of bash
@@ -125,6 +125,7 @@ _brew___cache() {
     -*)
       __brewcomp "
       --HEAD
+      --arch
       --bottle-tag
       --build-from-source
       --cask
@@ -132,12 +133,13 @@ _brew___cache() {
       --force-bottle
       --formula
       --help
+      --os
       --quiet
       --verbose
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -155,7 +157,7 @@ _brew___caskroom() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_casks
 }
@@ -172,7 +174,7 @@ _brew___cellar() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
@@ -189,7 +191,7 @@ _brew___config() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -207,7 +209,7 @@ _brew___env() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
@@ -226,7 +228,7 @@ _brew___prefix() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
@@ -243,7 +245,7 @@ _brew___repo() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_tapped
 }
@@ -260,11 +262,27 @@ _brew___repository() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_tapped
 }
 
+_brew___version() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+}
+
 _brew__s() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   case "${cur}" in
@@ -276,6 +294,7 @@ _brew__s() {
       --debian
       --debug
       --desc
+      --eval-all
       --fedora
       --fink
       --formula
@@ -291,7 +310,23 @@ _brew__s() {
       "
       return
       ;;
-    *)
+    *) ;;
+  esac
+}
+
+_brew__v() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
   esac
 }
 
@@ -300,12 +335,13 @@ _brew_abv() {
   case "${cur}" in
     -*)
       __brewcomp "
-      --all
       --analytics
       --cask
       --category
       --days
       --debug
+      --eval-all
+      --fetch-manifest
       --formula
       --github
       --help
@@ -317,7 +353,7 @@ _brew_abv() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -335,7 +371,7 @@ _brew_analytics() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brewcomp "state on off regenerate-uuid"
 }
@@ -345,13 +381,12 @@ _brew_audit() {
   case "${cur}" in
     -*)
       __brewcomp "
-      --appcast
+      --arch
       --audit-debug
       --cask
       --debug
-      --display-cop-names
-      --display-failures-only
       --display-filename
+      --eval-all
       --except
       --except-cops
       --fix
@@ -360,11 +395,13 @@ _brew_audit() {
       --help
       --installed
       --new
-      --no-appcast
+      --no-signing
       --online
       --only
       --only-cops
+      --os
       --quiet
+      --signing
       --skip-style
       --strict
       --tap
@@ -373,7 +410,7 @@ _brew_audit() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -392,7 +429,7 @@ _brew_autoremove() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -408,6 +445,7 @@ _brew_bottle() {
       --json
       --keep-old
       --merge
+      --no-all-checks
       --no-commit
       --no-rebuild
       --only-json-tab
@@ -420,7 +458,7 @@ _brew_bottle() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
   __brew_complete_files
@@ -433,19 +471,23 @@ _brew_bump() {
       __brewcomp "
       --cask
       --debug
+      --eval-all
       --formula
       --full-name
       --help
-      --limit
+      --installed
+      --no-fork
       --no-pull-requests
       --open-pr
       --quiet
+      --repology
       --start-with
+      --tap
       --verbose
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -459,7 +501,6 @@ _brew_bump_cask_pr() {
       --commit
       --debug
       --dry-run
-      --force
       --fork-org
       --help
       --message
@@ -467,17 +508,18 @@ _brew_bump_cask_pr() {
       --no-browse
       --no-fork
       --no-style
-      --online
       --quiet
       --sha256
       --url
       --verbose
       --version
+      --version-arm
+      --version-intel
       --write-only
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_casks
 }
@@ -493,6 +535,7 @@ _brew_bump_formula_pr() {
       --force
       --fork-org
       --help
+      --install-dependencies
       --message
       --mirror
       --no-audit
@@ -514,7 +557,7 @@ _brew_bump_formula_pr() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
@@ -535,7 +578,7 @@ _brew_bump_revision() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
@@ -555,12 +598,28 @@ _brew_bump_unversioned_casks() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_casks
   __brew_complete_tapped
 }
 
+_brew_casks() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+}
+
 _brew_cat() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   case "${cur}" in
@@ -575,7 +634,7 @@ _brew_cat() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -592,12 +651,12 @@ _brew_cleanup() {
       --prune
       --prune-prefix
       --quiet
+      --scrub
       --verbose
-      -s
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -615,7 +674,7 @@ _brew_command() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_commands
 }
@@ -633,7 +692,7 @@ _brew_commands() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -649,7 +708,7 @@ _brew_completions() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brewcomp "state link unlink"
 }
@@ -666,7 +725,28 @@ _brew_config() {
       "
       return
       ;;
-    *)
+    *) ;;
+  esac
+}
+
+_brew_contributions() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --csv
+      --debug
+      --from
+      --help
+      --quiet
+      --repositories
+      --to
+      --user
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
   esac
 }
 
@@ -700,21 +780,41 @@ _brew_create() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
+_brew_debugger() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --open
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+  __brew_complete_commands
+}
+
 _brew_deps() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   case "${cur}" in
     -*)
       __brewcomp "
-      --1
-      --all
+      --HEAD
       --annotate
+      --arch
       --cask
       --debug
+      --direct
       --dot
+      --eval-all
       --for-each
       --formula
       --full-name
@@ -725,16 +825,18 @@ _brew_deps() {
       --include-requirements
       --include-test
       --installed
+      --missing
+      --os
       --quiet
       --skip-recommended
+      --topological
       --tree
       --union
       --verbose
-      -n
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -748,6 +850,7 @@ _brew_desc() {
       --cask
       --debug
       --description
+      --eval-all
       --formula
       --help
       --name
@@ -757,12 +860,31 @@ _brew_desc() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
 }
 
+_brew_determine_test_runners() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --all-supported
+      --debug
+      --dependents
+      --eval-all
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+}
+
 _brew_developer() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   case "${cur}" in
@@ -775,7 +897,7 @@ _brew_developer() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brewcomp "state on off"
 }
@@ -801,11 +923,27 @@ _brew_dispatch_build_bottle() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
 
+_brew_docs() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+}
+
 _brew_doctor() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   case "${cur}" in
@@ -820,9 +958,9 @@ _brew_doctor() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
-  __brewcomp "$(brew doctor --list-checks)"
+  __brewcomp "${__HOMEBREW_DOCTOR_CHECKS=$(brew doctor --list-checks)}"
 }
 
 _brew_dr() {
@@ -839,9 +977,9 @@ _brew_dr() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
-  __brewcomp "$(brew doctor --list-checks)"
+  __brewcomp "${__HOMEBREW_DOCTOR_CHECKS=$(brew doctor --list-checks)}"
 }
 
 _brew_edit() {
@@ -859,10 +997,11 @@ _brew_edit() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
+  __brew_complete_tapped
 }
 
 _brew_environment() {
@@ -879,7 +1018,7 @@ _brew_environment() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
@@ -891,6 +1030,7 @@ _brew_extract() {
       __brewcomp "
       --debug
       --force
+      --git-revision
       --help
       --quiet
       --verbose
@@ -898,7 +1038,7 @@ _brew_extract() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_tapped
@@ -910,6 +1050,7 @@ _brew_fetch() {
     -*)
       __brewcomp "
       --HEAD
+      --arch
       --bottle-tag
       --build-bottle
       --build-from-source
@@ -921,6 +1062,7 @@ _brew_fetch() {
       --formula
       --help
       --no-quarantine
+      --os
       --quarantine
       --quiet
       --retry
@@ -928,7 +1070,7 @@ _brew_fetch() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -946,25 +1088,74 @@ _brew_formula() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
 
+_brew_formulae() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+}
+
+_brew_generate_cask_api() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --dry-run
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+}
+
+_brew_generate_formula_api() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --dry-run
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+}
+
 _brew_generate_man_completions() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   case "${cur}" in
     -*)
       __brewcomp "
       --debug
-      --fail-if-not-changed
       --help
       --quiet
       --verbose
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -983,7 +1174,7 @@ _brew_gist_logs() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
@@ -1002,7 +1193,7 @@ _brew_home() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -1022,7 +1213,7 @@ _brew_homepage() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -1033,12 +1224,13 @@ _brew_info() {
   case "${cur}" in
     -*)
       __brewcomp "
-      --all
       --analytics
       --cask
       --category
       --days
       --debug
+      --eval-all
+      --fetch-manifest
       --formula
       --github
       --help
@@ -1050,7 +1242,7 @@ _brew_info() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -1062,6 +1254,7 @@ _brew_instal() {
     -*)
       __brewcomp "
       --HEAD
+      --adopt
       --appdir
       --audio-unit-plugindir
       --binaries
@@ -1072,8 +1265,10 @@ _brew_instal() {
       --cc
       --colorpickerdir
       --debug
+      --debug-symbols
       --dictionarydir
       --display-times
+      --dry-run
       --fetch-HEAD
       --fontdir
       --force
@@ -1087,6 +1282,7 @@ _brew_instal() {
       --interactive
       --internet-plugindir
       --keep-tmp
+      --keyboard-layoutdir
       --language
       --mdimporterdir
       --no-binaries
@@ -1101,6 +1297,7 @@ _brew_instal() {
       --screen-saverdir
       --servicedir
       --skip-cask-deps
+      --skip-post-install
       --verbose
       --vst-plugindir
       --vst3-plugindir
@@ -1108,7 +1305,7 @@ _brew_instal() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -1120,6 +1317,7 @@ _brew_install() {
     -*)
       __brewcomp "
       --HEAD
+      --adopt
       --appdir
       --audio-unit-plugindir
       --binaries
@@ -1130,8 +1328,10 @@ _brew_install() {
       --cc
       --colorpickerdir
       --debug
+      --debug-symbols
       --dictionarydir
       --display-times
+      --dry-run
       --fetch-HEAD
       --fontdir
       --force
@@ -1145,6 +1345,7 @@ _brew_install() {
       --interactive
       --internet-plugindir
       --keep-tmp
+      --keyboard-layoutdir
       --language
       --mdimporterdir
       --no-binaries
@@ -1159,6 +1360,7 @@ _brew_install() {
       --screen-saverdir
       --servicedir
       --skip-cask-deps
+      --skip-post-install
       --verbose
       --vst-plugindir
       --vst3-plugindir
@@ -1166,7 +1368,7 @@ _brew_install() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -1177,6 +1379,7 @@ _brew_install_bundler_gems() {
   case "${cur}" in
     -*)
       __brewcomp "
+      --add-groups
       --debug
       --groups
       --help
@@ -1185,7 +1388,7 @@ _brew_install_bundler_gems() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -1203,7 +1406,7 @@ _brew_irb() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -1212,9 +1415,10 @@ _brew_lc() {
   case "${cur}" in
     -*)
       __brewcomp "
-      --all
       --cask
       --debug
+      --eval-all
+      --extract-plist
       --formula
       --full-name
       --help
@@ -1222,12 +1426,13 @@ _brew_lc() {
       --json
       --newer-only
       --quiet
+      --resources
       --tap
       --verbose
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -1247,7 +1452,7 @@ _brew_leaves() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -1267,7 +1472,7 @@ _brew_link() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
 }
@@ -1288,7 +1493,7 @@ _brew_linkage() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
 }
@@ -1298,13 +1503,17 @@ _brew_list() {
   case "${cur}" in
     -*)
       __brewcomp "
+      --built-from-source
       --cask
       --debug
       --formula
       --full-name
       --help
+      --installed-as-dependency
+      --installed-on-request
       --multiple
       --pinned
+      --poured-from-bottle
       --quiet
       --verbose
       --versions
@@ -1315,7 +1524,7 @@ _brew_list() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
   __brew_complete_installed_casks
@@ -1326,9 +1535,10 @@ _brew_livecheck() {
   case "${cur}" in
     -*)
       __brewcomp "
-      --all
       --cask
       --debug
+      --eval-all
+      --extract-plist
       --formula
       --full-name
       --help
@@ -1336,12 +1546,13 @@ _brew_livecheck() {
       --json
       --newer-only
       --quiet
+      --resources
       --tap
       --verbose
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -1363,7 +1574,7 @@ _brew_ln() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
 }
@@ -1387,7 +1598,7 @@ _brew_log() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -1398,13 +1609,17 @@ _brew_ls() {
   case "${cur}" in
     -*)
       __brewcomp "
+      --built-from-source
       --cask
       --debug
       --formula
       --full-name
       --help
+      --installed-as-dependency
+      --installed-on-request
       --multiple
       --pinned
+      --poured-from-bottle
       --quiet
       --verbose
       --versions
@@ -1415,7 +1630,7 @@ _brew_ls() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
   __brew_complete_installed_casks
@@ -1426,18 +1641,21 @@ _brew_migrate() {
   case "${cur}" in
     -*)
       __brewcomp "
+      --cask
       --debug
       --dry-run
       --force
+      --formula
       --help
       --quiet
       --verbose
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
+  __brew_complete_installed_casks
 }
 
 _brew_missing() {
@@ -1453,20 +1671,36 @@ _brew_missing() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
 
+_brew_nodenv_sync() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+}
+
 _brew_options() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   case "${cur}" in
     -*)
       __brewcomp "
-      --all
       --command
       --compact
       --debug
+      --eval-all
       --help
       --installed
       --quiet
@@ -1474,7 +1708,7 @@ _brew_options() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
@@ -1498,7 +1732,7 @@ _brew_outdated() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -1516,7 +1750,24 @@ _brew_pin() {
       "
       return
       ;;
-    *)
+    *) ;;
+  esac
+  __brew_complete_installed_formulae
+}
+
+_brew_post_install() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
   esac
   __brew_complete_installed_formulae
 }
@@ -1533,7 +1784,7 @@ _brew_postinstall() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
 }
@@ -1543,10 +1794,10 @@ _brew_pr_automerge() {
   case "${cur}" in
     -*)
       __brewcomp "
+      --autosquash
       --debug
       --help
       --ignore-failures
-      --no-autosquash
       --publish
       --quiet
       --tap
@@ -1558,7 +1809,7 @@ _brew_pr_automerge() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -1567,11 +1818,12 @@ _brew_pr_publish() {
   case "${cur}" in
     -*)
       __brewcomp "
+      --autosquash
       --branch
       --debug
       --help
+      --large-runner
       --message
-      --no-autosquash
       --quiet
       --tap
       --verbose
@@ -1579,7 +1831,7 @@ _brew_pr_publish() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -1588,7 +1840,8 @@ _brew_pr_pull() {
   case "${cur}" in
     -*)
       __brewcomp "
-      --artifact
+      --artifact-pattern
+      --autosquash
       --branch-okay
       --clean
       --committer
@@ -1598,11 +1851,12 @@ _brew_pr_pull() {
       --ignore-missing-artifacts
       --keep-old
       --message
-      --no-autosquash
+      --no-cherry-pick
       --no-commit
       --no-upload
       --quiet
       --resolve
+      --retain-bottle-dir
       --root-url
       --root-url-using
       --tap
@@ -1612,7 +1866,7 @@ _brew_pr_pull() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -1636,7 +1890,7 @@ _brew_pr_upload() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -1650,29 +1904,66 @@ _brew_prof() {
       --quiet
       --stackprof
       --verbose
+      --vernier
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_commands
 }
 
+_brew_pyenv_sync() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+}
+
+_brew_rbenv_sync() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+}
+
 _brew_readall() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   case "${cur}" in
     -*)
       __brewcomp "
       --aliases
+      --arch
       --debug
+      --eval-all
       --help
+      --no-simulate
+      --os
       --quiet
       --syntax
       --verbose
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_tapped
 }
@@ -1682,6 +1973,7 @@ _brew_reinstall() {
   case "${cur}" in
     -*)
       __brewcomp "
+      --adopt
       --appdir
       --audio-unit-plugindir
       --binaries
@@ -1689,6 +1981,7 @@ _brew_reinstall() {
       --cask
       --colorpickerdir
       --debug
+      --debug-symbols
       --dictionarydir
       --display-times
       --fontdir
@@ -1701,6 +1994,7 @@ _brew_reinstall() {
       --interactive
       --internet-plugindir
       --keep-tmp
+      --keyboard-layoutdir
       --language
       --mdimporterdir
       --no-binaries
@@ -1720,7 +2014,7 @@ _brew_reinstall() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
   __brew_complete_casks
@@ -1740,7 +2034,7 @@ _brew_release() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -1761,7 +2055,7 @@ _brew_remove() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
   __brew_complete_installed_casks
@@ -1784,12 +2078,28 @@ _brew_rm() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
   __brew_complete_installed_casks
 }
 
+_brew_rubocop() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+}
+
 _brew_ruby() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   case "${cur}" in
@@ -1804,11 +2114,29 @@ _brew_ruby() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_files
 }
 
+_brew_rubydoc() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --only-public
+      --open
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+}
+
 _brew_search() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   case "${cur}" in
@@ -1820,6 +2148,7 @@ _brew_search() {
       --debian
       --debug
       --desc
+      --eval-all
       --fedora
       --fink
       --formula
@@ -1835,10 +2164,27 @@ _brew_search() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
+_brew_setup_ruby() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+  __brew_complete_commands
+}
+
 _brew_sh() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   case "${cur}" in
@@ -1853,12 +2199,12 @@ _brew_sh() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_files
 }
 
-_brew_sponsors() {
+_brew_shellenv() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   case "${cur}" in
     -*)
@@ -1870,7 +2216,7 @@ _brew_sponsors() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -1881,7 +2227,6 @@ _brew_style() {
       __brewcomp "
       --cask
       --debug
-      --display-cop-names
       --except-cops
       --fix
       --formula
@@ -1893,7 +2238,7 @@ _brew_style() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_files
   __brew_complete_tapped
@@ -1901,6 +2246,28 @@ _brew_style() {
   __brew_complete_casks
 }
 
+_brew_tab() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --cask
+      --debug
+      --formula
+      --help
+      --installed-on-request
+      --no-installed-on-request
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+  __brew_complete_installed_formulae
+  __brew_complete_installed_casks
+}
+
 _brew_tap() {
   local cur="${COMP_WORDS[COMP_CWORD]}"
   case "${cur}" in
@@ -1908,17 +2275,16 @@ _brew_tap() {
       __brewcomp "
       --custom-remote
       --debug
-      --force-auto-update
+      --eval-all
+      --force
       --help
-      --list-pinned
-      --no-force-auto-update
       --quiet
       --repair
       --verbose
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_tapped
 }
@@ -1937,7 +2303,7 @@ _brew_tap_info() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_tapped
 }
@@ -1958,7 +2324,7 @@ _brew_tap_new() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_tapped
 }
@@ -1968,23 +2334,24 @@ _brew_tc() {
   case "${cur}" in
     -*)
       __brewcomp "
-      --all
       --debug
       --dir
-      --fail-if-not-changed
       --file
       --fix
       --help
       --ignore
+      --lsp
       --quiet
       --suggest-typed
       --update
+      --update-all
       --verbose
       "
       return
       ;;
-    *)
+    *) ;;
   esac
+  __brew_complete_tapped
 }
 
 _brew_test() {
@@ -2003,7 +2370,7 @@ _brew_test() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
 }
@@ -2013,22 +2380,22 @@ _brew_tests() {
   case "${cur}" in
     -*)
       __brewcomp "
-      --byebug
       --changed
       --coverage
       --debug
+      --fail-fast
       --generic
       --help
-      --no-compat
       --online
       --only
+      --profile
       --quiet
       --seed
       --verbose
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -2037,23 +2404,24 @@ _brew_typecheck() {
   case "${cur}" in
     -*)
       __brewcomp "
-      --all
       --debug
       --dir
-      --fail-if-not-changed
       --file
       --fix
       --help
       --ignore
+      --lsp
       --quiet
       --suggest-typed
       --update
+      --update-all
       --verbose
       "
       return
       ;;
-    *)
+    *) ;;
   esac
+  __brew_complete_tapped
 }
 
 _brew_unbottled() {
@@ -2061,17 +2429,19 @@ _brew_unbottled() {
   case "${cur}" in
     -*)
       __brewcomp "
-      --all
       --debug
       --dependents
+      --eval-all
       --help
+      --lost
       --quiet
       --tag
+      --total
       --verbose
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
@@ -2093,7 +2463,7 @@ _brew_uninstal() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
   __brew_complete_installed_casks
@@ -2116,7 +2486,7 @@ _brew_uninstall() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
   __brew_complete_installed_casks
@@ -2135,7 +2505,7 @@ _brew_unlink() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
 }
@@ -2156,7 +2526,7 @@ _brew_unpack() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
@@ -2173,7 +2543,7 @@ _brew_unpin() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_installed_formulae
 }
@@ -2191,7 +2561,7 @@ _brew_untap() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_tapped
 }
@@ -2211,7 +2581,7 @@ _brew_up() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -2230,7 +2600,7 @@ _brew_update() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -2240,14 +2610,13 @@ _brew_update_license_data() {
     -*)
       __brewcomp "
       --debug
-      --fail-if-not-changed
       --help
       --quiet
       --verbose
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -2263,7 +2632,7 @@ _brew_update_maintainers() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -2277,6 +2646,7 @@ _brew_update_python_resources() {
       --extra-packages
       --help
       --ignore-non-pypi-packages
+      --install-dependencies
       --package-name
       --print-only
       --quiet
@@ -2286,7 +2656,7 @@ _brew_update_python_resources() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
@@ -2305,7 +2675,39 @@ _brew_update_report() {
       "
       return
       ;;
-    *)
+    *) ;;
+  esac
+}
+
+_brew_update_reset() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
+  esac
+}
+
+_brew_update_sponsors() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
   esac
 }
 
@@ -2325,7 +2727,7 @@ _brew_update_test() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
 }
 
@@ -2341,6 +2743,7 @@ _brew_upgrade() {
       --cask
       --colorpickerdir
       --debug
+      --debug-symbols
       --dictionarydir
       --display-times
       --dry-run
@@ -2353,15 +2756,16 @@ _brew_upgrade() {
       --greedy-auto-updates
       --greedy-latest
       --help
-      --ignore-pinned
       --input-methoddir
       --interactive
       --internet-plugindir
       --keep-tmp
+      --keyboard-layoutdir
       --language
       --mdimporterdir
       --no-binaries
       --no-quarantine
+      --overwrite
       --prefpanedir
       --qlplugindir
       --quarantine
@@ -2376,10 +2780,10 @@ _brew_upgrade() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
-  __brew_complete_outdated_formulae
-  __brew_complete_outdated_casks
+  __brew_complete_installed_formulae
+  __brew_complete_installed_casks
 }
 
 _brew_uses() {
@@ -2389,12 +2793,14 @@ _brew_uses() {
       __brewcomp "
       --cask
       --debug
+      --eval-all
       --formula
       --help
       --include-build
       --include-optional
       --include-test
       --installed
+      --missing
       --quiet
       --recursive
       --skip-recommended
@@ -2402,7 +2808,7 @@ _brew_uses() {
       "
       return
       ;;
-    *)
+    *) ;;
   esac
   __brew_complete_formulae
 }
@@ -2414,13 +2820,30 @@ _brew_vendor_gems() {
       __brewcomp "
       --debug
       --help
+      --no-commit
       --quiet
       --update
       --verbose
       "
       return
       ;;
-    *)
+    *) ;;
+  esac
+}
+
+_brew_vendor_install() {
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  case "${cur}" in
+    -*)
+      __brewcomp "
+      --debug
+      --help
+      --quiet
+      --verbose
+      "
+      return
+      ;;
+    *) ;;
   esac
 }
 
@@ -2462,7 +2885,9 @@ _brew() {
     --prefix) _brew___prefix ;;
     --repo) _brew___repo ;;
     --repository) _brew___repository ;;
+    --version) _brew___version ;;
     -S) _brew__s ;;
+    -v) _brew__v ;;
     abv) _brew_abv ;;
     analytics) _brew_analytics ;;
     audit) _brew_audit ;;
@@ -2473,17 +2898,22 @@ _brew() {
     bump-formula-pr) _brew_bump_formula_pr ;;
     bump-revision) _brew_bump_revision ;;
     bump-unversioned-casks) _brew_bump_unversioned_casks ;;
+    casks) _brew_casks ;;
     cat) _brew_cat ;;
     cleanup) _brew_cleanup ;;
     command) _brew_command ;;
     commands) _brew_commands ;;
     completions) _brew_completions ;;
     config) _brew_config ;;
+    contributions) _brew_contributions ;;
     create) _brew_create ;;
+    debugger) _brew_debugger ;;
     deps) _brew_deps ;;
     desc) _brew_desc ;;
+    determine-test-runners) _brew_determine_test_runners ;;
     developer) _brew_developer ;;
     dispatch-build-bottle) _brew_dispatch_build_bottle ;;
+    docs) _brew_docs ;;
     doctor) _brew_doctor ;;
     dr) _brew_dr ;;
     edit) _brew_edit ;;
@@ -2491,6 +2921,9 @@ _brew() {
     extract) _brew_extract ;;
     fetch) _brew_fetch ;;
     formula) _brew_formula ;;
+    formulae) _brew_formulae ;;
+    generate-cask-api) _brew_generate_cask_api ;;
+    generate-formula-api) _brew_generate_formula_api ;;
     generate-man-completions) _brew_generate_man_completions ;;
     gist-logs) _brew_gist_logs ;;
     home) _brew_home ;;
@@ -2511,25 +2944,33 @@ _brew() {
     ls) _brew_ls ;;
     migrate) _brew_migrate ;;
     missing) _brew_missing ;;
+    nodenv-sync) _brew_nodenv_sync ;;
     options) _brew_options ;;
     outdated) _brew_outdated ;;
     pin) _brew_pin ;;
+    post_install) _brew_post_install ;;
     postinstall) _brew_postinstall ;;
     pr-automerge) _brew_pr_automerge ;;
     pr-publish) _brew_pr_publish ;;
     pr-pull) _brew_pr_pull ;;
     pr-upload) _brew_pr_upload ;;
     prof) _brew_prof ;;
+    pyenv-sync) _brew_pyenv_sync ;;
+    rbenv-sync) _brew_rbenv_sync ;;
     readall) _brew_readall ;;
     reinstall) _brew_reinstall ;;
     release) _brew_release ;;
     remove) _brew_remove ;;
     rm) _brew_rm ;;
+    rubocop) _brew_rubocop ;;
     ruby) _brew_ruby ;;
+    rubydoc) _brew_rubydoc ;;
     search) _brew_search ;;
+    setup-ruby) _brew_setup_ruby ;;
     sh) _brew_sh ;;
-    sponsors) _brew_sponsors ;;
+    shellenv) _brew_shellenv ;;
     style) _brew_style ;;
+    tab) _brew_tab ;;
     tap) _brew_tap ;;
     tap-info) _brew_tap_info ;;
     tap-new) _brew_tap_new ;;
@@ -2550,10 +2991,13 @@ _brew() {
     update-maintainers) _brew_update_maintainers ;;
     update-python-resources) _brew_update_python_resources ;;
     update-report) _brew_update_report ;;
+    update-reset) _brew_update_reset ;;
+    update-sponsors) _brew_update_sponsors ;;
     update-test) _brew_update_test ;;
     upgrade) _brew_upgrade ;;
     uses) _brew_uses ;;
     vendor-gems) _brew_vendor_gems ;;
+    vendor-install) _brew_vendor_install ;;
     *) ;;
   esac
 }
diff --git a/completions/fish/brew.fish b/completions/fish/brew.fish
index d1ba1881af91e..7ecabc2e8baa9 100644
--- a/completions/fish/brew.fish
+++ b/completions/fish/brew.fish
@@ -1,4 +1,6 @@
 # Fish shell completions for Homebrew
+# This file is automatically generated by running `brew generate-man-completions`.
+# See Library/Homebrew/completions/fish.erb for editing instructions.
 
 # A note about aliases:
 #
@@ -83,30 +85,17 @@ end
 ######################
 # These functions return lists of suggestions for arguments completion
 
-function __fish_brew_ruby_parse_json -a file parser -d 'Parses given JSON file with Ruby'
-    # parser is any chain of methods to call on the parsed JSON
-    ruby -e "require('json'); JSON.parse(File.read('$file'))$parser"
-end
-
 function __fish_brew_suggest_formulae_all -d 'Lists all available formulae with their descriptions'
-    # store the brew cache path in a var (because calling (brew --cache) is slow)
-    set -q __brew_cache_path
-    or set -gx __brew_cache_path (brew --cache)
-
-    if test -f "$__brew_cache_path/descriptions.json"
-        __fish_brew_ruby_parse_json "$__brew_cache_path/descriptions.json" \
-            '.each{ |k, v| puts([k, v].reject(&:nil?).join("\t")) }'
-    else
-        brew formulae
-    end
+    brew formulae
 end
 
 function __fish_brew_suggest_formulae_installed
-    brew list --formula
+    command ls -1 (brew --cellar)
 end
 
+
 function __fish_brew_suggest_formulae_outdated -d "List of outdated formulae with the information about potential upgrade"
-    brew outdated --formula --verbose \
+    HOMEBREW_NO_AUTO_UPDATE=1 brew outdated --formula --verbose 2>/dev/null \
         # replace first space with tab to make the following a description in the completions list:
         | string replace -r '\s' '\t'
 end
@@ -128,17 +117,19 @@ function __fish_brew_suggest_casks_all -d "Lists locally available casks"
 end
 
 function __fish_brew_suggest_casks_installed -d "Lists installed casks"
-    brew list --cask -1
+    command ls -1 (brew --caskroom) 2>/dev/null
 end
 
 function __fish_brew_suggest_casks_outdated -d "Lists outdated casks with the information about potential upgrade"
-    brew outdated --cask --verbose \
+    HOMEBREW_NO_AUTO_UPDATE=1 brew outdated --cask --verbose 2>/dev/null \
         # replace first space with tab to make the following a description in the completions list:
         | string replace -r '\s' '\t'
 end
 
 function __fish_brew_suggest_taps_installed -d "List all available taps"
-    brew tap
+    command find (brew --repo)/Library/Taps -mindepth 2 -maxdepth 2 -type d \
+    | string replace homebrew- "" \
+    | string replace (brew --repo)/Library/Taps/ ""
 end
 
 function __fish_brew_suggest_commands -d "Lists all commands names, including aliases"
@@ -153,13 +144,10 @@ function __fish_brew_suggest_diagnostic_checks -d "List available diagnostic che
     brew doctor --list-checks
 end
 
-# TODO: any better way to list available services?
 function __fish_brew_suggest_services -d "Lists available services"
-    set -l list (brew services list)
-    set -e list[1] # Header
-    for line in $list
-        echo (string split ' ' $line)[1]
-    end
+    command find (brew --cellar) -mindepth 3 -maxdepth 3 -name '*.service' \
+      | awk -F'homebrew.|.service' '{print $3}' \
+      | sort -d
 end
 
 
@@ -201,6 +189,7 @@ end
 
 __fish_brew_complete_cmd '--cache' 'Display Homebrew\'s download cache'
 __fish_brew_complete_arg '--cache' -l HEAD -d 'Show the cache file used when building from HEAD'
+__fish_brew_complete_arg '--cache' -l arch -d 'Show cache file for the given CPU architecture. (Pass `all` to show cache files for all architectures.)'
 __fish_brew_complete_arg '--cache' -l bottle-tag -d 'Show the cache file used when pouring a bottle for the given tag'
 __fish_brew_complete_arg '--cache' -l build-from-source -d 'Show the cache file used when building from source'
 __fish_brew_complete_arg '--cache' -l cask -d 'Only show cache files for casks'
@@ -208,6 +197,7 @@ __fish_brew_complete_arg '--cache' -l debug -d 'Display any debugging informatio
 __fish_brew_complete_arg '--cache' -l force-bottle -d 'Show the cache file used when pouring a bottle'
 __fish_brew_complete_arg '--cache' -l formula -d 'Only show cache files for formulae'
 __fish_brew_complete_arg '--cache' -l help -d 'Show this message'
+__fish_brew_complete_arg '--cache' -l os -d 'Show cache file for the given operating system. (Pass `all` to show cache files for all operating systems.)'
 __fish_brew_complete_arg '--cache' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg '--cache' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg '--cache; and not __fish_seen_argument -l cask -l casks' -a '(__fish_brew_suggest_formulae_all)'
@@ -257,7 +247,7 @@ __fish_brew_complete_arg '--prefix' -l verbose -d 'Make some output more verbose
 __fish_brew_complete_arg '--prefix' -a '(__fish_brew_suggest_formulae_all)'
 
 
-__fish_brew_complete_cmd '--repo' 'Display where Homebrew\'s git repository is located'
+__fish_brew_complete_cmd '--repo' 'Display where Homebrew\'s Git repository is located'
 __fish_brew_complete_arg '--repo' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg '--repo' -l help -d 'Show this message'
 __fish_brew_complete_arg '--repo' -l quiet -d 'Make some output more quiet'
@@ -265,7 +255,7 @@ __fish_brew_complete_arg '--repo' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg '--repo' -a '(__fish_brew_suggest_taps_installed)'
 
 
-__fish_brew_complete_cmd '--repository' 'Display where Homebrew\'s git repository is located'
+__fish_brew_complete_cmd '--repository' 'Display where Homebrew\'s Git repository is located'
 __fish_brew_complete_arg '--repository' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg '--repository' -l help -d 'Show this message'
 __fish_brew_complete_arg '--repository' -l quiet -d 'Make some output more quiet'
@@ -273,16 +263,24 @@ __fish_brew_complete_arg '--repository' -l verbose -d 'Make some output more ver
 __fish_brew_complete_arg '--repository' -a '(__fish_brew_suggest_taps_installed)'
 
 
+__fish_brew_complete_cmd '--version' 'Print the version numbers of Homebrew, Homebrew/homebrew-core and Homebrew/homebrew-cask (if tapped) to standard output'
+__fish_brew_complete_arg '--version' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg '--version' -l help -d 'Show this message'
+__fish_brew_complete_arg '--version' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg '--version' -l verbose -d 'Make some output more verbose'
+
+
 __fish_brew_complete_cmd '-S' 'Perform a substring search of cask tokens and formula names for text'
 __fish_brew_complete_arg '-S' -l archlinux -d 'Search for text in the given database'
-__fish_brew_complete_arg '-S' -l cask -d 'Search online and locally for casks'
+__fish_brew_complete_arg '-S' -l cask -d 'Search for casks'
 __fish_brew_complete_arg '-S' -l closed -d 'Search for only closed GitHub pull requests'
 __fish_brew_complete_arg '-S' -l debian -d 'Search for text in the given database'
 __fish_brew_complete_arg '-S' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg '-S' -l desc -d 'Search for formulae with a description matching text and casks with a name or description matching text'
+__fish_brew_complete_arg '-S' -l eval-all -d 'Evaluate all available formulae and casks, whether installed or not, to search their descriptions. Implied if `HOMEBREW_EVAL_ALL` is set'
 __fish_brew_complete_arg '-S' -l fedora -d 'Search for text in the given database'
 __fish_brew_complete_arg '-S' -l fink -d 'Search for text in the given database'
-__fish_brew_complete_arg '-S' -l formula -d 'Search online and locally for formulae'
+__fish_brew_complete_arg '-S' -l formula -d 'Search for formulae'
 __fish_brew_complete_arg '-S' -l help -d 'Show this message'
 __fish_brew_complete_arg '-S' -l macports -d 'Search for text in the given database'
 __fish_brew_complete_arg '-S' -l open -d 'Search for only open GitHub pull requests'
@@ -294,13 +292,21 @@ __fish_brew_complete_arg '-S' -l ubuntu -d 'Search for text in the given databas
 __fish_brew_complete_arg '-S' -l verbose -d 'Make some output more verbose'
 
 
+__fish_brew_complete_cmd '-v' 'Print the version numbers of Homebrew, Homebrew/homebrew-core and Homebrew/homebrew-cask (if tapped) to standard output'
+__fish_brew_complete_arg '-v' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg '-v' -l help -d 'Show this message'
+__fish_brew_complete_arg '-v' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg '-v' -l verbose -d 'Make some output more verbose'
+
+
 __fish_brew_complete_cmd 'abv' 'Display brief statistics for your Homebrew installation'
-__fish_brew_complete_arg 'abv' -l all -d 'Print JSON of all available formulae'
 __fish_brew_complete_arg 'abv' -l analytics -d 'List global Homebrew analytics data or, if specified, installation and build error data for formula (provided neither `HOMEBREW_NO_ANALYTICS` nor `HOMEBREW_NO_GITHUB_API` are set)'
 __fish_brew_complete_arg 'abv' -l cask -d 'Treat all named arguments as casks'
 __fish_brew_complete_arg 'abv' -l category -d 'Which type of analytics data to retrieve. The value for category must be `install`, `install-on-request` or `build-error`; `cask-install` or `os-version` may be specified if formula is not. The default is `install`'
 __fish_brew_complete_arg 'abv' -l days -d 'How many days of analytics data to retrieve. The value for days must be `30`, `90` or `365`. The default is `30`'
 __fish_brew_complete_arg 'abv' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'abv' -l eval-all -d 'Evaluate all available formulae and casks, whether installed or not, to print their JSON. Implied if `HOMEBREW_EVAL_ALL` is set'
+__fish_brew_complete_arg 'abv' -l fetch-manifest -d 'Fetch GitHub Packages manifest for extra information when formula is not installed'
 __fish_brew_complete_arg 'abv' -l formula -d 'Treat all named arguments as formulae'
 __fish_brew_complete_arg 'abv' -l github -d 'Open the GitHub source page for formula and cask in a browser. To view the history locally: `brew log -p` formula or cask'
 __fish_brew_complete_arg 'abv' -l help -d 'Show this message'
@@ -325,13 +331,12 @@ __fish_brew_complete_arg 'analytics' -l verbose -d 'Make some output more verbos
 
 
 __fish_brew_complete_cmd 'audit' 'Check formula for Homebrew coding style violations'
-__fish_brew_complete_arg 'audit' -l appcast -d 'Audit the appcast'
+__fish_brew_complete_arg 'audit' -l arch -d 'Audit the given CPU architecture. (Pass `all` to audit all architectures.)'
 __fish_brew_complete_arg 'audit' -l audit-debug -d 'Enable debugging and profiling of audit methods'
 __fish_brew_complete_arg 'audit' -l cask -d 'Treat all named arguments as casks'
 __fish_brew_complete_arg 'audit' -l debug -d 'Display any debugging information'
-__fish_brew_complete_arg 'audit' -l display-cop-names -d 'Include the RuboCop cop name for each violation in the output'
-__fish_brew_complete_arg 'audit' -l display-failures-only -d 'Only display casks that fail the audit. This is the default for formulae'
 __fish_brew_complete_arg 'audit' -l display-filename -d 'Prefix every line of output with the file or formula name being audited, to make output easy to grep'
+__fish_brew_complete_arg 'audit' -l eval-all -d 'Evaluate all available formulae and casks, whether installed or not, to audit them. Implied if `HOMEBREW_EVAL_ALL` is set'
 __fish_brew_complete_arg 'audit' -l except -d 'Specify a comma-separated method list to skip running the methods named `audit_`method'
 __fish_brew_complete_arg 'audit' -l except-cops -d 'Specify a comma-separated cops list to skip checking for violations of the listed RuboCop cops'
 __fish_brew_complete_arg 'audit' -l fix -d 'Fix style violations automatically using RuboCop\'s auto-correct feature'
@@ -339,12 +344,14 @@ __fish_brew_complete_arg 'audit' -l formula -d 'Treat all named arguments as for
 __fish_brew_complete_arg 'audit' -l git -d 'Run additional, slower style checks that navigate the Git repository'
 __fish_brew_complete_arg 'audit' -l help -d 'Show this message'
 __fish_brew_complete_arg 'audit' -l installed -d 'Only check formulae and casks that are currently installed'
-__fish_brew_complete_arg 'audit' -l new -d 'Run various additional style checks to determine if a new formula or cask is eligible for Homebrew. This should be used when creating new formula and implies `--strict` and `--online`'
-__fish_brew_complete_arg 'audit' -l no-appcast -d 'Audit the appcast'
+__fish_brew_complete_arg 'audit' -l new -d 'Run various additional style checks to determine if a new formula or cask is eligible for Homebrew. This should be used when creating new formulae or casks and implies `--strict` and `--online`'
+__fish_brew_complete_arg 'audit' -l no-signing -d 'Audit for signed apps, which are required on ARM'
 __fish_brew_complete_arg 'audit' -l online -d 'Run additional, slower style checks that require a network connection'
 __fish_brew_complete_arg 'audit' -l only -d 'Specify a comma-separated method list to only run the methods named `audit_`method'
 __fish_brew_complete_arg 'audit' -l only-cops -d 'Specify a comma-separated cops list to check for violations of only the listed RuboCop cops'
+__fish_brew_complete_arg 'audit' -l os -d 'Audit the given operating system. (Pass `all` to audit all operating systems.)'
 __fish_brew_complete_arg 'audit' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'audit' -l signing -d 'Audit for signed apps, which are required on ARM'
 __fish_brew_complete_arg 'audit' -l skip-style -d 'Skip running non-RuboCop style checks. Useful if you plan on running `brew style` separately. Enabled by default unless a formula is specified by name'
 __fish_brew_complete_arg 'audit' -l strict -d 'Run additional, stricter style checks'
 __fish_brew_complete_arg 'audit' -l tap -d 'Check the formulae within the given tap, specified as user`/`repo'
@@ -370,6 +377,7 @@ __fish_brew_complete_arg 'bottle' -l help -d 'Show this message'
 __fish_brew_complete_arg 'bottle' -l json -d 'Write bottle information to a JSON file, which can be used as the value for `--merge`'
 __fish_brew_complete_arg 'bottle' -l keep-old -d 'If the formula specifies a rebuild version, attempt to preserve its value in the generated DSL'
 __fish_brew_complete_arg 'bottle' -l merge -d 'Generate an updated bottle block for a formula and optionally merge it into the formula file. Instead of a formula name, requires the path to a JSON file generated with `brew bottle --json` formula'
+__fish_brew_complete_arg 'bottle' -l no-all-checks -d 'Don\'t try to create an `all` bottle or stop a no-change upload'
 __fish_brew_complete_arg 'bottle' -l no-commit -d 'When passed with `--write`, a new commit will not generated after writing changes to the formula file'
 __fish_brew_complete_arg 'bottle' -l no-rebuild -d 'If the formula specifies a rebuild version, remove it from the generated DSL'
 __fish_brew_complete_arg 'bottle' -l only-json-tab -d 'When passed with `--json`, the tab will be written to the JSON file but not the bottle'
@@ -382,17 +390,21 @@ __fish_brew_complete_arg 'bottle' -l write -d 'Write changes to the formula file
 __fish_brew_complete_arg 'bottle' -a '(__fish_brew_suggest_formulae_installed)'
 
 
-__fish_brew_complete_cmd 'bump' 'Display out-of-date brew formulae and the latest version available'
+__fish_brew_complete_cmd 'bump' 'Displays out-of-date packages and the latest version available'
 __fish_brew_complete_arg 'bump' -l cask -d 'Check only casks'
 __fish_brew_complete_arg 'bump' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'bump' -l eval-all -d 'Evaluate all formulae and casks'
 __fish_brew_complete_arg 'bump' -l formula -d 'Check only formulae'
 __fish_brew_complete_arg 'bump' -l full-name -d 'Print formulae/casks with fully-qualified names'
 __fish_brew_complete_arg 'bump' -l help -d 'Show this message'
-__fish_brew_complete_arg 'bump' -l limit -d 'Limit number of package results returned'
+__fish_brew_complete_arg 'bump' -l installed -d 'Check formulae and casks that are currently installed'
+__fish_brew_complete_arg 'bump' -l no-fork -d 'Don\'t try to fork the repository'
 __fish_brew_complete_arg 'bump' -l no-pull-requests -d 'Do not retrieve pull requests from GitHub'
-__fish_brew_complete_arg 'bump' -l open-pr -d 'Open a pull request for the new version if there are none already open'
+__fish_brew_complete_arg 'bump' -l open-pr -d 'Open a pull request for the new version if none have been opened yet'
 __fish_brew_complete_arg 'bump' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'bump' -l repology -d 'Use Repology to check for outdated packages'
 __fish_brew_complete_arg 'bump' -l start-with -d 'Letter or word that the list of package results should alphabetically follow'
+__fish_brew_complete_arg 'bump' -l tap -d 'Check formulae and casks within the given tap, specified as user`/`repo'
 __fish_brew_complete_arg 'bump' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'bump; and not __fish_seen_argument -l cask -l casks' -a '(__fish_brew_suggest_formulae_all)'
 __fish_brew_complete_arg 'bump; and not __fish_seen_argument -l formula -l formulae' -a '(__fish_brew_suggest_casks_all)'
@@ -402,20 +414,20 @@ __fish_brew_complete_cmd 'bump-cask-pr' 'Create a pull request to update cask wi
 __fish_brew_complete_arg 'bump-cask-pr' -l commit -d 'When passed with `--write-only`, generate a new commit after writing changes to the cask file'
 __fish_brew_complete_arg 'bump-cask-pr' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'bump-cask-pr' -l dry-run -d 'Print what would be done rather than doing it'
-__fish_brew_complete_arg 'bump-cask-pr' -l force -d 'Ignore duplicate open PRs'
 __fish_brew_complete_arg 'bump-cask-pr' -l fork-org -d 'Use the specified GitHub organization for forking'
 __fish_brew_complete_arg 'bump-cask-pr' -l help -d 'Show this message'
-__fish_brew_complete_arg 'bump-cask-pr' -l message -d 'Append message to the default pull request message'
+__fish_brew_complete_arg 'bump-cask-pr' -l message -d 'Prepend message to the default pull request message'
 __fish_brew_complete_arg 'bump-cask-pr' -l no-audit -d 'Don\'t run `brew audit` before opening the PR'
 __fish_brew_complete_arg 'bump-cask-pr' -l no-browse -d 'Print the pull request URL instead of opening in a browser'
 __fish_brew_complete_arg 'bump-cask-pr' -l no-fork -d 'Don\'t try to fork the repository'
 __fish_brew_complete_arg 'bump-cask-pr' -l no-style -d 'Don\'t run `brew style --fix` before opening the PR'
-__fish_brew_complete_arg 'bump-cask-pr' -l online -d 'Run `brew audit --online` before opening the PR'
 __fish_brew_complete_arg 'bump-cask-pr' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'bump-cask-pr' -l sha256 -d 'Specify the SHA-256 checksum of the new download'
 __fish_brew_complete_arg 'bump-cask-pr' -l url -d 'Specify the URL for the new download'
 __fish_brew_complete_arg 'bump-cask-pr' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'bump-cask-pr' -l version -d 'Specify the new version for the cask'
+__fish_brew_complete_arg 'bump-cask-pr' -l version-arm -d 'Specify the new cask version for the ARM architecture'
+__fish_brew_complete_arg 'bump-cask-pr' -l version-intel -d 'Specify the new cask version for the Intel architecture'
 __fish_brew_complete_arg 'bump-cask-pr' -l write-only -d 'Make the expected file modifications without taking any Git actions'
 __fish_brew_complete_arg 'bump-cask-pr' -a '(__fish_brew_suggest_casks_all)'
 
@@ -424,10 +436,11 @@ __fish_brew_complete_cmd 'bump-formula-pr' 'Create a pull request to update form
 __fish_brew_complete_arg 'bump-formula-pr' -l commit -d 'When passed with `--write-only`, generate a new commit after writing changes to the formula file'
 __fish_brew_complete_arg 'bump-formula-pr' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'bump-formula-pr' -l dry-run -d 'Print what would be done rather than doing it'
-__fish_brew_complete_arg 'bump-formula-pr' -l force -d 'Ignore duplicate open PRs. Remove all mirrors if `--mirror` was not specified'
+__fish_brew_complete_arg 'bump-formula-pr' -l force -d 'Remove all mirrors if `--mirror` was not specified'
 __fish_brew_complete_arg 'bump-formula-pr' -l fork-org -d 'Use the specified GitHub organization for forking'
 __fish_brew_complete_arg 'bump-formula-pr' -l help -d 'Show this message'
-__fish_brew_complete_arg 'bump-formula-pr' -l message -d 'Append message to the default pull request message'
+__fish_brew_complete_arg 'bump-formula-pr' -l install-dependencies -d 'Install missing dependencies required to update resources'
+__fish_brew_complete_arg 'bump-formula-pr' -l message -d 'Prepend message to the default pull request message'
 __fish_brew_complete_arg 'bump-formula-pr' -l mirror -d 'Use the specified URL as a mirror URL. If URL is a comma-separated list of URLs, multiple mirrors will be added'
 __fish_brew_complete_arg 'bump-formula-pr' -l no-audit -d 'Don\'t run `brew audit` before opening the PR'
 __fish_brew_complete_arg 'bump-formula-pr' -l no-browse -d 'Print the pull request URL instead of opening in a browser'
@@ -472,6 +485,13 @@ __fish_brew_complete_arg 'bump-unversioned-casks' -a '(__fish_brew_suggest_casks
 __fish_brew_complete_arg 'bump-unversioned-casks' -a '(__fish_brew_suggest_taps_installed)'
 
 
+__fish_brew_complete_cmd 'casks' 'List all locally installable casks including short names'
+__fish_brew_complete_arg 'casks' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'casks' -l help -d 'Show this message'
+__fish_brew_complete_arg 'casks' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'casks' -l verbose -d 'Make some output more verbose'
+
+
 __fish_brew_complete_cmd 'cat' 'Display the source of a formula or cask'
 __fish_brew_complete_arg 'cat' -l cask -d 'Treat all named arguments as casks'
 __fish_brew_complete_arg 'cat' -l debug -d 'Display any debugging information'
@@ -490,8 +510,8 @@ __fish_brew_complete_arg 'cleanup' -l help -d 'Show this message'
 __fish_brew_complete_arg 'cleanup' -l prune -d 'Remove all cache files older than specified days. If you want to remove everything, use `--prune=all`'
 __fish_brew_complete_arg 'cleanup' -l prune-prefix -d 'Only prune the symlinks and directories from the prefix and remove no other files'
 __fish_brew_complete_arg 'cleanup' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'cleanup' -l scrub -d 'Scrub the cache, including downloads for even the latest versions. Note that downloads for any installed formulae or casks will still not be deleted. If you want to delete those too: `rm -rf "$(brew --cache)"`'
 __fish_brew_complete_arg 'cleanup' -l verbose -d 'Make some output more verbose'
-__fish_brew_complete_arg 'cleanup' -l s -d 'Scrub the cache, including downloads for even the latest versions. Note that downloads for any installed formulae or casks will still not be deleted. If you want to delete those too: `rm -rf "$(brew --cache)"`'
 __fish_brew_complete_arg 'cleanup' -a '(__fish_brew_suggest_formulae_all)'
 __fish_brew_complete_arg 'cleanup' -a '(__fish_brew_suggest_casks_all)'
 
@@ -529,6 +549,18 @@ __fish_brew_complete_arg 'config' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'config' -l verbose -d 'Make some output more verbose'
 
 
+__fish_brew_complete_cmd 'contributions' 'Summarise contributions to Homebrew repositories'
+__fish_brew_complete_arg 'contributions' -l csv -d 'Print a CSV of contributions across repositories over the time period'
+__fish_brew_complete_arg 'contributions' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'contributions' -l from -d 'Date (ISO-8601 format) to start searching contributions. Omitting this flag searches the last year'
+__fish_brew_complete_arg 'contributions' -l help -d 'Show this message'
+__fish_brew_complete_arg 'contributions' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'contributions' -l repositories -d 'Specify a comma-separated list of repositories to search. Supported repositories: `brew`, `core`, `cask`, `aliases`, `bundle`, `command-not-found`, `test-bot` and `services`. Omitting this flag, or specifying `--repositories=primary`, searches only the main repositories: brew,core,cask. Specifying `--repositories=all`, searches all repositories. '
+__fish_brew_complete_arg 'contributions' -l to -d 'Date (ISO-8601 format) to stop searching contributions'
+__fish_brew_complete_arg 'contributions' -l user -d 'Specify a comma-separated list of GitHub usernames or email addresses to find contributions from. Omitting this flag searches maintainers'
+__fish_brew_complete_arg 'contributions' -l verbose -d 'Make some output more verbose'
+
+
 __fish_brew_complete_cmd 'create' 'Generate a formula or, with `--cask`, a cask for the downloadable file at URL and open it in the editor'
 __fish_brew_complete_arg 'create' -l HEAD -d 'Indicate that URL points to the package\'s repository rather than a file'
 __fish_brew_complete_arg 'create' -l autotools -d 'Create a basic template for an Autotools-style build'
@@ -554,14 +586,25 @@ __fish_brew_complete_arg 'create' -l tap -d 'Generate the new formula within the
 __fish_brew_complete_arg 'create' -l verbose -d 'Make some output more verbose'
 
 
+__fish_brew_complete_cmd 'debugger' 'Run the specified Homebrew command in debug mode'
+__fish_brew_complete_arg 'debugger' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'debugger' -l help -d 'Show this message'
+__fish_brew_complete_arg 'debugger' -l open -d 'Start remote debugging over a Unix socket'
+__fish_brew_complete_arg 'debugger' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'debugger' -l verbose -d 'Make some output more verbose'
+__fish_brew_complete_arg 'debugger' -a '(__fish_brew_suggest_commands)'
+
+
 __fish_brew_complete_cmd 'deps' 'Show dependencies for formula'
-__fish_brew_complete_arg 'deps' -l 1 -d 'Only show dependencies one level down, instead of recursing'
-__fish_brew_complete_arg 'deps' -l all -d 'List dependencies for all available formulae'
-__fish_brew_complete_arg 'deps' -l annotate -d 'Mark any build, test, optional, or recommended dependencies as such in the output'
+__fish_brew_complete_arg 'deps' -l HEAD -d 'Show dependencies for HEAD version instead of stable version'
+__fish_brew_complete_arg 'deps' -l annotate -d 'Mark any build, test, implicit, optional, or recommended dependencies as such in the output'
+__fish_brew_complete_arg 'deps' -l arch -d 'Show dependencies for the given CPU architecture'
 __fish_brew_complete_arg 'deps' -l cask -d 'Treat all named arguments as casks'
 __fish_brew_complete_arg 'deps' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'deps' -l direct -d 'Show only the direct dependencies declared in the formula'
 __fish_brew_complete_arg 'deps' -l dot -d 'Show text-based graph description in DOT format'
-__fish_brew_complete_arg 'deps' -l for-each -d 'Switch into the mode used by the `--all` option, but only list dependencies for each provided formula, one formula per line. This is used for debugging the `--installed`/`--all` display mode'
+__fish_brew_complete_arg 'deps' -l eval-all -d 'Evaluate all available formulae and casks, whether installed or not, to list their dependencies'
+__fish_brew_complete_arg 'deps' -l for-each -d 'Switch into the mode used by the `--eval-all` option, but only list dependencies for each provided formula, one formula per line. This is used for debugging the `--installed`/`--eval-all` display mode'
 __fish_brew_complete_arg 'deps' -l formula -d 'Treat all named arguments as formulae'
 __fish_brew_complete_arg 'deps' -l full-name -d 'List dependencies by their full name'
 __fish_brew_complete_arg 'deps' -l graph -d 'Show dependencies as a directed graph'
@@ -571,12 +614,14 @@ __fish_brew_complete_arg 'deps' -l include-optional -d 'Include `:optional` depe
 __fish_brew_complete_arg 'deps' -l include-requirements -d 'Include requirements in addition to dependencies for formula'
 __fish_brew_complete_arg 'deps' -l include-test -d 'Include `:test` dependencies for formula (non-recursive)'
 __fish_brew_complete_arg 'deps' -l installed -d 'List dependencies for formulae that are currently installed. If formula is specified, list only its dependencies that are currently installed'
+__fish_brew_complete_arg 'deps' -l missing -d 'Show only missing dependencies'
+__fish_brew_complete_arg 'deps' -l os -d 'Show dependencies for the given operating system'
 __fish_brew_complete_arg 'deps' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'deps' -l skip-recommended -d 'Skip `:recommended` dependencies for formula'
+__fish_brew_complete_arg 'deps' -l topological -d 'Sort dependencies in topological order'
 __fish_brew_complete_arg 'deps' -l tree -d 'Show dependencies as a tree. When given multiple formula arguments, show individual trees for each formula'
 __fish_brew_complete_arg 'deps' -l union -d 'Show the union of dependencies for multiple formula, instead of the intersection'
 __fish_brew_complete_arg 'deps' -l verbose -d 'Make some output more verbose'
-__fish_brew_complete_arg 'deps' -l n -d 'Sort dependencies in topological order'
 __fish_brew_complete_arg 'deps; and not __fish_seen_argument -l cask -l casks' -a '(__fish_brew_suggest_formulae_all)'
 __fish_brew_complete_arg 'deps; and not __fish_seen_argument -l formula -l formulae' -a '(__fish_brew_suggest_casks_all)'
 
@@ -585,6 +630,7 @@ __fish_brew_complete_cmd 'desc' 'Display formula\'s name and one-line descriptio
 __fish_brew_complete_arg 'desc' -l cask -d 'Treat all named arguments as casks'
 __fish_brew_complete_arg 'desc' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'desc' -l description -d 'Search just descriptions for text. If text is flanked by slashes, it is interpreted as a regular expression'
+__fish_brew_complete_arg 'desc' -l eval-all -d 'Evaluate all available formulae and casks, whether installed or not, to search their descriptions. Implied if `HOMEBREW_EVAL_ALL` is set'
 __fish_brew_complete_arg 'desc' -l formula -d 'Treat all named arguments as formulae'
 __fish_brew_complete_arg 'desc' -l help -d 'Show this message'
 __fish_brew_complete_arg 'desc' -l name -d 'Search just names for text. If text is flanked by slashes, it is interpreted as a regular expression'
@@ -595,6 +641,16 @@ __fish_brew_complete_arg 'desc; and not __fish_seen_argument -l cask -l casks' -
 __fish_brew_complete_arg 'desc; and not __fish_seen_argument -l formula -l formulae' -a '(__fish_brew_suggest_casks_all)'
 
 
+__fish_brew_complete_cmd 'determine-test-runners' 'Determines the runners used to test formulae or their dependents'
+__fish_brew_complete_arg 'determine-test-runners' -l all-supported -d 'Instead of selecting runners based on the chosen formula, return all supported runners'
+__fish_brew_complete_arg 'determine-test-runners' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'determine-test-runners' -l dependents -d 'Determine runners for testing dependents. Requires `--eval-all` or `HOMEBREW_EVAL_ALL`'
+__fish_brew_complete_arg 'determine-test-runners' -l eval-all -d 'Evaluate all available formulae, whether installed or not, to determine testing dependents'
+__fish_brew_complete_arg 'determine-test-runners' -l help -d 'Show this message'
+__fish_brew_complete_arg 'determine-test-runners' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'determine-test-runners' -l verbose -d 'Make some output more verbose'
+
+
 __fish_brew_complete_cmd 'developer' 'Control Homebrew\'s developer mode'
 __fish_brew_complete_sub_cmd 'developer' 'state'
 __fish_brew_complete_sub_cmd 'developer' 'on'
@@ -612,7 +668,7 @@ __fish_brew_complete_arg 'dispatch-build-bottle' -l issue -d 'If specified, post
 __fish_brew_complete_arg 'dispatch-build-bottle' -l linux -d 'Dispatch bottle for Linux (using GitHub runners)'
 __fish_brew_complete_arg 'dispatch-build-bottle' -l linux-self-hosted -d 'Dispatch bottle for Linux (using self-hosted runner)'
 __fish_brew_complete_arg 'dispatch-build-bottle' -l linux-wheezy -d 'Use Debian Wheezy container for building the bottle on Linux'
-__fish_brew_complete_arg 'dispatch-build-bottle' -l macos -d 'Version(s) of macOS the bottle should be built for'
+__fish_brew_complete_arg 'dispatch-build-bottle' -l macos -d 'macOS version (or comma-separated list of versions) the bottle should be built for'
 __fish_brew_complete_arg 'dispatch-build-bottle' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'dispatch-build-bottle' -l tap -d 'Target tap repository (default: `homebrew/core`)'
 __fish_brew_complete_arg 'dispatch-build-bottle' -l timeout -d 'Build timeout (in minutes, default: 60)'
@@ -622,6 +678,13 @@ __fish_brew_complete_arg 'dispatch-build-bottle' -l workflow -d 'Dispatch specif
 __fish_brew_complete_arg 'dispatch-build-bottle' -a '(__fish_brew_suggest_formulae_all)'
 
 
+__fish_brew_complete_cmd 'docs' 'Open Homebrew\'s online documentation at https://docs.brew.sh in a browser'
+__fish_brew_complete_arg 'docs' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'docs' -l help -d 'Show this message'
+__fish_brew_complete_arg 'docs' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'docs' -l verbose -d 'Make some output more verbose'
+
+
 __fish_brew_complete_cmd 'doctor' 'Check your system for potential problems'
 __fish_brew_complete_arg 'doctor' -l audit-debug -d 'Enable debugging and profiling of audit methods'
 __fish_brew_complete_arg 'doctor' -l debug -d 'Display any debugging information'
@@ -642,7 +705,7 @@ __fish_brew_complete_arg 'dr' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'dr' -a '(__fish_brew_suggest_diagnostic_checks)'
 
 
-__fish_brew_complete_cmd 'edit' 'Open a formula or cask in the editor set by `EDITOR` or `HOMEBREW_EDITOR`, or open the Homebrew repository for editing if no formula is provided'
+__fish_brew_complete_cmd 'edit' 'Open a formula, cask or tap in the editor set by `EDITOR` or `HOMEBREW_EDITOR`, or open the Homebrew repository for editing if no argument is provided'
 __fish_brew_complete_arg 'edit' -l cask -d 'Treat all named arguments as casks'
 __fish_brew_complete_arg 'edit' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'edit' -l formula -d 'Treat all named arguments as formulae'
@@ -652,6 +715,7 @@ __fish_brew_complete_arg 'edit' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'edit' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'edit; and not __fish_seen_argument -l cask -l casks' -a '(__fish_brew_suggest_formulae_all)'
 __fish_brew_complete_arg 'edit; and not __fish_seen_argument -l formula -l formulae' -a '(__fish_brew_suggest_casks_all)'
+__fish_brew_complete_arg 'edit' -a '(__fish_brew_suggest_taps_installed)'
 
 
 __fish_brew_complete_cmd 'environment' 'Summarise Homebrew\'s build environment as a plain list'
@@ -667,6 +731,7 @@ __fish_brew_complete_arg 'environment' -a '(__fish_brew_suggest_formulae_all)'
 __fish_brew_complete_cmd 'extract' 'Look through repository history to find the most recent version of formula and create a copy in tap'
 __fish_brew_complete_arg 'extract' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'extract' -l force -d 'Overwrite the destination formula if it already exists'
+__fish_brew_complete_arg 'extract' -l git-revision -d 'Search for the specified version of formula starting at revision instead of HEAD'
 __fish_brew_complete_arg 'extract' -l help -d 'Show this message'
 __fish_brew_complete_arg 'extract' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'extract' -l verbose -d 'Make some output more verbose'
@@ -677,6 +742,7 @@ __fish_brew_complete_arg 'extract' -a '(__fish_brew_suggest_taps_installed)'
 
 __fish_brew_complete_cmd 'fetch' 'Download a bottle (if available) or source packages for formulae and binaries for casks'
 __fish_brew_complete_arg 'fetch' -l HEAD -d 'Fetch HEAD version instead of stable version'
+__fish_brew_complete_arg 'fetch' -l arch -d 'Download for the given CPU architecture. (Pass `all` to download for all architectures.)'
 __fish_brew_complete_arg 'fetch' -l bottle-tag -d 'Download a bottle for given tag'
 __fish_brew_complete_arg 'fetch' -l build-bottle -d 'Download source packages (for eventual bottling) rather than a bottle'
 __fish_brew_complete_arg 'fetch' -l build-from-source -d 'Download source packages rather than a bottle'
@@ -688,9 +754,10 @@ __fish_brew_complete_arg 'fetch' -l force-bottle -d 'Download a bottle if it exi
 __fish_brew_complete_arg 'fetch' -l formula -d 'Treat all named arguments as formulae'
 __fish_brew_complete_arg 'fetch' -l help -d 'Show this message'
 __fish_brew_complete_arg 'fetch' -l no-quarantine -d 'Disable/enable quarantining of downloads (default: enabled)'
+__fish_brew_complete_arg 'fetch' -l os -d 'Download for the given operating system. (Pass `all` to download for all operating systems.)'
 __fish_brew_complete_arg 'fetch' -l quarantine -d 'Disable/enable quarantining of downloads (default: enabled)'
 __fish_brew_complete_arg 'fetch' -l quiet -d 'Make some output more quiet'
-__fish_brew_complete_arg 'fetch' -l retry -d 'Retry if downloading fails or re-download if the checksum of a previously cached version no longer matches'
+__fish_brew_complete_arg 'fetch' -l retry -d 'Retry if downloading fails or re-download if the checksum of a previously cached version no longer matches. Tries at most 5 times with exponential backoff'
 __fish_brew_complete_arg 'fetch' -l verbose -d 'Do a verbose VCS checkout, if the URL represents a VCS. This is useful for seeing if an existing VCS cache has been updated'
 __fish_brew_complete_arg 'fetch; and not __fish_seen_argument -l cask -l casks' -a '(__fish_brew_suggest_formulae_all)'
 __fish_brew_complete_arg 'fetch; and not __fish_seen_argument -l formula -l formulae' -a '(__fish_brew_suggest_casks_all)'
@@ -704,9 +771,31 @@ __fish_brew_complete_arg 'formula' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'formula' -a '(__fish_brew_suggest_formulae_all)'
 
 
+__fish_brew_complete_cmd 'formulae' 'List all locally installable formulae including short names'
+__fish_brew_complete_arg 'formulae' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'formulae' -l help -d 'Show this message'
+__fish_brew_complete_arg 'formulae' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'formulae' -l verbose -d 'Make some output more verbose'
+
+
+__fish_brew_complete_cmd 'generate-cask-api' 'Generate `homebrew/cask` API data files for https://formulae.brew.sh'
+__fish_brew_complete_arg 'generate-cask-api' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'generate-cask-api' -l dry-run -d 'Generate API data without writing it to files'
+__fish_brew_complete_arg 'generate-cask-api' -l help -d 'Show this message'
+__fish_brew_complete_arg 'generate-cask-api' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'generate-cask-api' -l verbose -d 'Make some output more verbose'
+
+
+__fish_brew_complete_cmd 'generate-formula-api' 'Generate `homebrew/core` API data files for https://formulae.brew.sh'
+__fish_brew_complete_arg 'generate-formula-api' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'generate-formula-api' -l dry-run -d 'Generate API data without writing it to files'
+__fish_brew_complete_arg 'generate-formula-api' -l help -d 'Show this message'
+__fish_brew_complete_arg 'generate-formula-api' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'generate-formula-api' -l verbose -d 'Make some output more verbose'
+
+
 __fish_brew_complete_cmd 'generate-man-completions' 'Generate Homebrew\'s manpages and shell completions'
 __fish_brew_complete_arg 'generate-man-completions' -l debug -d 'Display any debugging information'
-__fish_brew_complete_arg 'generate-man-completions' -l fail-if-not-changed -d 'Return a failing status code if no changes are detected in the manpage outputs. This can be used to notify CI when the manpages are out of date. Additionally, the date used in new manpages will match those in the existing manpages (to allow comparison without factoring in the date)'
 __fish_brew_complete_arg 'generate-man-completions' -l help -d 'Show this message'
 __fish_brew_complete_arg 'generate-man-completions' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'generate-man-completions' -l verbose -d 'Make some output more verbose'
@@ -746,12 +835,13 @@ __fish_brew_complete_arg 'homepage; and not __fish_seen_argument -l formula -l f
 
 
 __fish_brew_complete_cmd 'info' 'Display brief statistics for your Homebrew installation'
-__fish_brew_complete_arg 'info' -l all -d 'Print JSON of all available formulae'
 __fish_brew_complete_arg 'info' -l analytics -d 'List global Homebrew analytics data or, if specified, installation and build error data for formula (provided neither `HOMEBREW_NO_ANALYTICS` nor `HOMEBREW_NO_GITHUB_API` are set)'
 __fish_brew_complete_arg 'info' -l cask -d 'Treat all named arguments as casks'
 __fish_brew_complete_arg 'info' -l category -d 'Which type of analytics data to retrieve. The value for category must be `install`, `install-on-request` or `build-error`; `cask-install` or `os-version` may be specified if formula is not. The default is `install`'
 __fish_brew_complete_arg 'info' -l days -d 'How many days of analytics data to retrieve. The value for days must be `30`, `90` or `365`. The default is `30`'
 __fish_brew_complete_arg 'info' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'info' -l eval-all -d 'Evaluate all available formulae and casks, whether installed or not, to print their JSON. Implied if `HOMEBREW_EVAL_ALL` is set'
+__fish_brew_complete_arg 'info' -l fetch-manifest -d 'Fetch GitHub Packages manifest for extra information when formula is not installed'
 __fish_brew_complete_arg 'info' -l formula -d 'Treat all named arguments as formulae'
 __fish_brew_complete_arg 'info' -l github -d 'Open the GitHub source page for formula and cask in a browser. To view the history locally: `brew log -p` formula or cask'
 __fish_brew_complete_arg 'info' -l help -d 'Show this message'
@@ -766,6 +856,7 @@ __fish_brew_complete_arg 'info; and not __fish_seen_argument -l formula -l formu
 
 __fish_brew_complete_cmd 'instal' 'Install a formula or cask'
 __fish_brew_complete_arg 'instal' -l HEAD -d 'If formula defines it, install the HEAD version, aka. main, trunk, unstable, master'
+__fish_brew_complete_arg 'instal' -l adopt -d 'Adopt existing artifacts in the destination that are identical to those being installed. Cannot be combined with `--force`'
 __fish_brew_complete_arg 'instal' -l appdir -d 'Target location for Applications (default: `/Applications`)'
 __fish_brew_complete_arg 'instal' -l audio-unit-plugindir -d 'Target location for Audio Unit Plugins (default: `~/Library/Audio/Plug-Ins/Components`)'
 __fish_brew_complete_arg 'instal' -l binaries -d 'Disable/enable linking of helper executables (default: enabled)'
@@ -773,11 +864,13 @@ __fish_brew_complete_arg 'instal' -l bottle-arch -d 'Optimise bottles for the sp
 __fish_brew_complete_arg 'instal' -l build-bottle -d 'Prepare the formula for eventual bottling during installation, skipping any post-install steps'
 __fish_brew_complete_arg 'instal' -l build-from-source -d 'Compile formula from source even if a bottle is provided. Dependencies will still be installed from bottles if they are available'
 __fish_brew_complete_arg 'instal' -l cask -d 'Treat all named arguments as casks'
-__fish_brew_complete_arg 'instal' -l cc -d 'Attempt to compile using the specified compiler, which should be the name of the compiler\'s executable, e.g. `gcc-7` for GCC 7. In order to use LLVM\'s clang, specify `llvm_clang`. To use the Apple-provided clang, specify `clang`. This option will only accept compilers that are provided by Homebrew or bundled with macOS. Please do not file issues if you encounter errors while using this option'
+__fish_brew_complete_arg 'instal' -l cc -d 'Attempt to compile using the specified compiler, which should be the name of the compiler\'s executable, e.g. `gcc-9` for GCC 9. In order to use LLVM\'s clang, specify `llvm_clang`. To use the Apple-provided clang, specify `clang`. This option will only accept compilers that are provided by Homebrew or bundled with macOS. Please do not file issues if you encounter errors while using this option'
 __fish_brew_complete_arg 'instal' -l colorpickerdir -d 'Target location for Color Pickers (default: `~/Library/ColorPickers`)'
 __fish_brew_complete_arg 'instal' -l debug -d 'If brewing fails, open an interactive debugging session with access to IRB or a shell inside the temporary build directory'
+__fish_brew_complete_arg 'instal' -l debug-symbols -d 'Generate debug symbols on build. Source will be retained in a cache directory'
 __fish_brew_complete_arg 'instal' -l dictionarydir -d 'Target location for Dictionaries (default: `~/Library/Dictionaries`)'
 __fish_brew_complete_arg 'instal' -l display-times -d 'Print install times for each package at the end of the run'
+__fish_brew_complete_arg 'instal' -l dry-run -d 'Show what would be installed, but do not actually install anything'
 __fish_brew_complete_arg 'instal' -l fetch-HEAD -d 'Fetch the upstream repository to detect if the HEAD installation of the formula is outdated. Otherwise, the repository\'s HEAD will only be checked for updates when a new stable or development version has been released'
 __fish_brew_complete_arg 'instal' -l fontdir -d 'Target location for Fonts (default: `~/Library/Fonts`)'
 __fish_brew_complete_arg 'instal' -l force -d 'Install formulae without checking for previously installed keg-only or non-migrated versions. When installing casks, overwrite existing files (binaries and symlinks are excluded, unless originally from the same cask)'
@@ -785,12 +878,13 @@ __fish_brew_complete_arg 'instal' -l force-bottle -d 'Install from a bottle if i
 __fish_brew_complete_arg 'instal' -l formula -d 'Treat all named arguments as formulae'
 __fish_brew_complete_arg 'instal' -l git -d 'Create a Git repository, useful for creating patches to the software'
 __fish_brew_complete_arg 'instal' -l help -d 'Show this message'
-__fish_brew_complete_arg 'instal' -l ignore-dependencies -d 'An unsupported Homebrew development flag to skip installing any dependencies of any kind. If the dependencies are not already present, the formula will have issues. If you\'re not developing Homebrew, consider adjusting your PATH rather than using this flag'
+__fish_brew_complete_arg 'instal' -l ignore-dependencies -d 'An unsupported Homebrew development option to skip installing any dependencies of any kind. If the dependencies are not already present, the formula will have issues. If you\'re not developing Homebrew, consider adjusting your PATH rather than using this option'
 __fish_brew_complete_arg 'instal' -l include-test -d 'Install testing dependencies required to run `brew test` formula'
 __fish_brew_complete_arg 'instal' -l input-methoddir -d 'Target location for Input Methods (default: `~/Library/Input Methods`)'
 __fish_brew_complete_arg 'instal' -l interactive -d 'Download and patch formula, then open a shell. This allows the user to run `./configure --help` and otherwise determine how to turn the software package into a Homebrew package'
 __fish_brew_complete_arg 'instal' -l internet-plugindir -d 'Target location for Internet Plugins (default: `~/Library/Internet Plug-Ins`)'
 __fish_brew_complete_arg 'instal' -l keep-tmp -d 'Retain the temporary files created during installation'
+__fish_brew_complete_arg 'instal' -l keyboard-layoutdir -d 'Target location for Keyboard Layouts (default: `/Library/Keyboard Layouts`)'
 __fish_brew_complete_arg 'instal' -l language -d 'Comma-separated list of language codes to prefer for cask installation. The first matching language is used, otherwise it reverts to the cask\'s default language. The default value is the language of your system'
 __fish_brew_complete_arg 'instal' -l mdimporterdir -d 'Target location for Spotlight Plugins (default: `~/Library/Spotlight`)'
 __fish_brew_complete_arg 'instal' -l no-binaries -d 'Disable/enable linking of helper executables (default: enabled)'
@@ -798,14 +892,15 @@ __fish_brew_complete_arg 'instal' -l no-quarantine -d 'Disable/enable quarantini
 __fish_brew_complete_arg 'instal' -l only-dependencies -d 'Install the dependencies with specified options but do not install the formula itself'
 __fish_brew_complete_arg 'instal' -l overwrite -d 'Delete files that already exist in the prefix while linking'
 __fish_brew_complete_arg 'instal' -l prefpanedir -d 'Target location for Preference Panes (default: `~/Library/PreferencePanes`)'
-__fish_brew_complete_arg 'instal' -l qlplugindir -d 'Target location for QuickLook Plugins (default: `~/Library/QuickLook`)'
+__fish_brew_complete_arg 'instal' -l qlplugindir -d 'Target location for Quick Look Plugins (default: `~/Library/QuickLook`)'
 __fish_brew_complete_arg 'instal' -l quarantine -d 'Disable/enable quarantining of downloads (default: enabled)'
 __fish_brew_complete_arg 'instal' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'instal' -l require-sha -d 'Require all casks to have a checksum'
 __fish_brew_complete_arg 'instal' -l screen-saverdir -d 'Target location for Screen Savers (default: `~/Library/Screen Savers`)'
 __fish_brew_complete_arg 'instal' -l servicedir -d 'Target location for Services (default: `~/Library/Services`)'
 __fish_brew_complete_arg 'instal' -l skip-cask-deps -d 'Skip installing cask dependencies'
-__fish_brew_complete_arg 'instal' -l verbose -d 'Print the verification and postinstall steps'
+__fish_brew_complete_arg 'instal' -l skip-post-install -d 'Install but skip any post-install steps'
+__fish_brew_complete_arg 'instal' -l verbose -d 'Print the verification and post-install steps'
 __fish_brew_complete_arg 'instal' -l vst-plugindir -d 'Target location for VST Plugins (default: `~/Library/Audio/Plug-Ins/VST`)'
 __fish_brew_complete_arg 'instal' -l vst3-plugindir -d 'Target location for VST3 Plugins (default: `~/Library/Audio/Plug-Ins/VST3`)'
 __fish_brew_complete_arg 'instal' -l zap -d 'For use with `brew reinstall --cask`. Remove all files associated with a cask. *May remove files which are shared between applications.*'
@@ -815,6 +910,7 @@ __fish_brew_complete_arg 'instal; and not __fish_seen_argument -l formula -l for
 
 __fish_brew_complete_cmd 'install' 'Install a formula or cask'
 __fish_brew_complete_arg 'install' -l HEAD -d 'If formula defines it, install the HEAD version, aka. main, trunk, unstable, master'
+__fish_brew_complete_arg 'install' -l adopt -d 'Adopt existing artifacts in the destination that are identical to those being installed. Cannot be combined with `--force`'
 __fish_brew_complete_arg 'install' -l appdir -d 'Target location for Applications (default: `/Applications`)'
 __fish_brew_complete_arg 'install' -l audio-unit-plugindir -d 'Target location for Audio Unit Plugins (default: `~/Library/Audio/Plug-Ins/Components`)'
 __fish_brew_complete_arg 'install' -l binaries -d 'Disable/enable linking of helper executables (default: enabled)'
@@ -822,11 +918,13 @@ __fish_brew_complete_arg 'install' -l bottle-arch -d 'Optimise bottles for the s
 __fish_brew_complete_arg 'install' -l build-bottle -d 'Prepare the formula for eventual bottling during installation, skipping any post-install steps'
 __fish_brew_complete_arg 'install' -l build-from-source -d 'Compile formula from source even if a bottle is provided. Dependencies will still be installed from bottles if they are available'
 __fish_brew_complete_arg 'install' -l cask -d 'Treat all named arguments as casks'
-__fish_brew_complete_arg 'install' -l cc -d 'Attempt to compile using the specified compiler, which should be the name of the compiler\'s executable, e.g. `gcc-7` for GCC 7. In order to use LLVM\'s clang, specify `llvm_clang`. To use the Apple-provided clang, specify `clang`. This option will only accept compilers that are provided by Homebrew or bundled with macOS. Please do not file issues if you encounter errors while using this option'
+__fish_brew_complete_arg 'install' -l cc -d 'Attempt to compile using the specified compiler, which should be the name of the compiler\'s executable, e.g. `gcc-9` for GCC 9. In order to use LLVM\'s clang, specify `llvm_clang`. To use the Apple-provided clang, specify `clang`. This option will only accept compilers that are provided by Homebrew or bundled with macOS. Please do not file issues if you encounter errors while using this option'
 __fish_brew_complete_arg 'install' -l colorpickerdir -d 'Target location for Color Pickers (default: `~/Library/ColorPickers`)'
 __fish_brew_complete_arg 'install' -l debug -d 'If brewing fails, open an interactive debugging session with access to IRB or a shell inside the temporary build directory'
+__fish_brew_complete_arg 'install' -l debug-symbols -d 'Generate debug symbols on build. Source will be retained in a cache directory'
 __fish_brew_complete_arg 'install' -l dictionarydir -d 'Target location for Dictionaries (default: `~/Library/Dictionaries`)'
 __fish_brew_complete_arg 'install' -l display-times -d 'Print install times for each package at the end of the run'
+__fish_brew_complete_arg 'install' -l dry-run -d 'Show what would be installed, but do not actually install anything'
 __fish_brew_complete_arg 'install' -l fetch-HEAD -d 'Fetch the upstream repository to detect if the HEAD installation of the formula is outdated. Otherwise, the repository\'s HEAD will only be checked for updates when a new stable or development version has been released'
 __fish_brew_complete_arg 'install' -l fontdir -d 'Target location for Fonts (default: `~/Library/Fonts`)'
 __fish_brew_complete_arg 'install' -l force -d 'Install formulae without checking for previously installed keg-only or non-migrated versions. When installing casks, overwrite existing files (binaries and symlinks are excluded, unless originally from the same cask)'
@@ -834,12 +932,13 @@ __fish_brew_complete_arg 'install' -l force-bottle -d 'Install from a bottle if
 __fish_brew_complete_arg 'install' -l formula -d 'Treat all named arguments as formulae'
 __fish_brew_complete_arg 'install' -l git -d 'Create a Git repository, useful for creating patches to the software'
 __fish_brew_complete_arg 'install' -l help -d 'Show this message'
-__fish_brew_complete_arg 'install' -l ignore-dependencies -d 'An unsupported Homebrew development flag to skip installing any dependencies of any kind. If the dependencies are not already present, the formula will have issues. If you\'re not developing Homebrew, consider adjusting your PATH rather than using this flag'
+__fish_brew_complete_arg 'install' -l ignore-dependencies -d 'An unsupported Homebrew development option to skip installing any dependencies of any kind. If the dependencies are not already present, the formula will have issues. If you\'re not developing Homebrew, consider adjusting your PATH rather than using this option'
 __fish_brew_complete_arg 'install' -l include-test -d 'Install testing dependencies required to run `brew test` formula'
 __fish_brew_complete_arg 'install' -l input-methoddir -d 'Target location for Input Methods (default: `~/Library/Input Methods`)'
 __fish_brew_complete_arg 'install' -l interactive -d 'Download and patch formula, then open a shell. This allows the user to run `./configure --help` and otherwise determine how to turn the software package into a Homebrew package'
 __fish_brew_complete_arg 'install' -l internet-plugindir -d 'Target location for Internet Plugins (default: `~/Library/Internet Plug-Ins`)'
 __fish_brew_complete_arg 'install' -l keep-tmp -d 'Retain the temporary files created during installation'
+__fish_brew_complete_arg 'install' -l keyboard-layoutdir -d 'Target location for Keyboard Layouts (default: `/Library/Keyboard Layouts`)'
 __fish_brew_complete_arg 'install' -l language -d 'Comma-separated list of language codes to prefer for cask installation. The first matching language is used, otherwise it reverts to the cask\'s default language. The default value is the language of your system'
 __fish_brew_complete_arg 'install' -l mdimporterdir -d 'Target location for Spotlight Plugins (default: `~/Library/Spotlight`)'
 __fish_brew_complete_arg 'install' -l no-binaries -d 'Disable/enable linking of helper executables (default: enabled)'
@@ -847,14 +946,15 @@ __fish_brew_complete_arg 'install' -l no-quarantine -d 'Disable/enable quarantin
 __fish_brew_complete_arg 'install' -l only-dependencies -d 'Install the dependencies with specified options but do not install the formula itself'
 __fish_brew_complete_arg 'install' -l overwrite -d 'Delete files that already exist in the prefix while linking'
 __fish_brew_complete_arg 'install' -l prefpanedir -d 'Target location for Preference Panes (default: `~/Library/PreferencePanes`)'
-__fish_brew_complete_arg 'install' -l qlplugindir -d 'Target location for QuickLook Plugins (default: `~/Library/QuickLook`)'
+__fish_brew_complete_arg 'install' -l qlplugindir -d 'Target location for Quick Look Plugins (default: `~/Library/QuickLook`)'
 __fish_brew_complete_arg 'install' -l quarantine -d 'Disable/enable quarantining of downloads (default: enabled)'
 __fish_brew_complete_arg 'install' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'install' -l require-sha -d 'Require all casks to have a checksum'
 __fish_brew_complete_arg 'install' -l screen-saverdir -d 'Target location for Screen Savers (default: `~/Library/Screen Savers`)'
 __fish_brew_complete_arg 'install' -l servicedir -d 'Target location for Services (default: `~/Library/Services`)'
 __fish_brew_complete_arg 'install' -l skip-cask-deps -d 'Skip installing cask dependencies'
-__fish_brew_complete_arg 'install' -l verbose -d 'Print the verification and postinstall steps'
+__fish_brew_complete_arg 'install' -l skip-post-install -d 'Install but skip any post-install steps'
+__fish_brew_complete_arg 'install' -l verbose -d 'Print the verification and post-install steps'
 __fish_brew_complete_arg 'install' -l vst-plugindir -d 'Target location for VST Plugins (default: `~/Library/Audio/Plug-Ins/VST`)'
 __fish_brew_complete_arg 'install' -l vst3-plugindir -d 'Target location for VST3 Plugins (default: `~/Library/Audio/Plug-Ins/VST3`)'
 __fish_brew_complete_arg 'install' -l zap -d 'For use with `brew reinstall --cask`. Remove all files associated with a cask. *May remove files which are shared between applications.*'
@@ -863,8 +963,9 @@ __fish_brew_complete_arg 'install; and not __fish_seen_argument -l formula -l fo
 
 
 __fish_brew_complete_cmd 'install-bundler-gems' 'Install Homebrew\'s Bundler gems'
+__fish_brew_complete_arg 'install-bundler-gems' -l add-groups -d 'Installs the specified comma-separated list of gem groups, in addition to those already installed'
 __fish_brew_complete_arg 'install-bundler-gems' -l debug -d 'Display any debugging information'
-__fish_brew_complete_arg 'install-bundler-gems' -l groups -d 'Installs the specified comma-separated list of gem groups (default: last used)'
+__fish_brew_complete_arg 'install-bundler-gems' -l groups -d 'Installs the specified comma-separated list of gem groups (default: last used). Replaces any previously installed groups'
 __fish_brew_complete_arg 'install-bundler-gems' -l help -d 'Show this message'
 __fish_brew_complete_arg 'install-bundler-gems' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'install-bundler-gems' -l verbose -d 'Make some output more verbose'
@@ -880,23 +981,25 @@ __fish_brew_complete_arg 'irb' -l verbose -d 'Make some output more verbose'
 
 
 __fish_brew_complete_cmd 'lc' 'Check for newer versions of formulae and/or casks from upstream'
-__fish_brew_complete_arg 'lc' -l all -d 'Check all available formulae/casks'
 __fish_brew_complete_arg 'lc' -l cask -d 'Only check casks'
 __fish_brew_complete_arg 'lc' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'lc' -l eval-all -d 'Evaluate all available formulae and casks, whether installed or not, to check them'
+__fish_brew_complete_arg 'lc' -l extract-plist -d 'Enable checking multiple casks with ExtractPlist strategy'
 __fish_brew_complete_arg 'lc' -l formula -d 'Only check formulae'
-__fish_brew_complete_arg 'lc' -l full-name -d 'Print formulae/casks with fully-qualified names'
+__fish_brew_complete_arg 'lc' -l full-name -d 'Print formulae and casks with fully-qualified names'
 __fish_brew_complete_arg 'lc' -l help -d 'Show this message'
-__fish_brew_complete_arg 'lc' -l installed -d 'Check formulae/casks that are currently installed'
+__fish_brew_complete_arg 'lc' -l installed -d 'Check formulae and casks that are currently installed'
 __fish_brew_complete_arg 'lc' -l json -d 'Output information in JSON format'
 __fish_brew_complete_arg 'lc' -l newer-only -d 'Show the latest version only if it\'s newer than the formula/cask'
 __fish_brew_complete_arg 'lc' -l quiet -d 'Suppress warnings, don\'t print a progress bar for JSON output'
-__fish_brew_complete_arg 'lc' -l tap -d 'Check formulae/casks within the given tap, specified as user`/`repo'
+__fish_brew_complete_arg 'lc' -l resources -d 'Also check resources for formulae'
+__fish_brew_complete_arg 'lc' -l tap -d 'Check formulae and casks within the given tap, specified as user`/`repo'
 __fish_brew_complete_arg 'lc' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'lc; and not __fish_seen_argument -l cask -l casks' -a '(__fish_brew_suggest_formulae_all)'
 __fish_brew_complete_arg 'lc; and not __fish_seen_argument -l formula -l formulae' -a '(__fish_brew_suggest_casks_all)'
 
 
-__fish_brew_complete_cmd 'leaves' 'List installed formulae that are not dependencies of another installed formula'
+__fish_brew_complete_cmd 'leaves' 'List installed formulae that are not dependencies of another installed formula or cask'
 __fish_brew_complete_arg 'leaves' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'leaves' -l help -d 'Show this message'
 __fish_brew_complete_arg 'leaves' -l installed-as-dependency -d 'Only list leaves that were installed as dependencies'
@@ -930,13 +1033,17 @@ __fish_brew_complete_arg 'linkage' -a '(__fish_brew_suggest_formulae_installed)'
 
 
 __fish_brew_complete_cmd 'list' 'List all installed formulae and casks'
+__fish_brew_complete_arg 'list' -l built-from-source -d 'List the formulae compiled from source'
 __fish_brew_complete_arg 'list' -l cask -d 'List only casks, or treat all named arguments as casks'
 __fish_brew_complete_arg 'list' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'list' -l formula -d 'List only formulae, or treat all named arguments as formulae'
 __fish_brew_complete_arg 'list' -l full-name -d 'Print formulae with fully-qualified names. Unless `--full-name`, `--versions` or `--pinned` are passed, other options (i.e. `-1`, `-l`, `-r` and `-t`) are passed to `ls`(1) which produces the actual output'
 __fish_brew_complete_arg 'list' -l help -d 'Show this message'
+__fish_brew_complete_arg 'list' -l installed-as-dependency -d 'List the formulae installed as dependencies'
+__fish_brew_complete_arg 'list' -l installed-on-request -d 'List the formulae installed on request'
 __fish_brew_complete_arg 'list' -l multiple -d 'Only show formulae with multiple versions installed'
 __fish_brew_complete_arg 'list' -l pinned -d 'List only pinned formulae, or only the specified (pinned) formulae if formula are provided. See also `pin`, `unpin`'
+__fish_brew_complete_arg 'list' -l poured-from-bottle -d 'List the formulae installed from a bottle'
 __fish_brew_complete_arg 'list' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'list' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'list' -l versions -d 'Show the version number for installed formulae, or only the specified formulae if formula are provided'
@@ -949,17 +1056,19 @@ __fish_brew_complete_arg 'list; and not __fish_seen_argument -l formula -l formu
 
 
 __fish_brew_complete_cmd 'livecheck' 'Check for newer versions of formulae and/or casks from upstream'
-__fish_brew_complete_arg 'livecheck' -l all -d 'Check all available formulae/casks'
 __fish_brew_complete_arg 'livecheck' -l cask -d 'Only check casks'
 __fish_brew_complete_arg 'livecheck' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'livecheck' -l eval-all -d 'Evaluate all available formulae and casks, whether installed or not, to check them'
+__fish_brew_complete_arg 'livecheck' -l extract-plist -d 'Enable checking multiple casks with ExtractPlist strategy'
 __fish_brew_complete_arg 'livecheck' -l formula -d 'Only check formulae'
-__fish_brew_complete_arg 'livecheck' -l full-name -d 'Print formulae/casks with fully-qualified names'
+__fish_brew_complete_arg 'livecheck' -l full-name -d 'Print formulae and casks with fully-qualified names'
 __fish_brew_complete_arg 'livecheck' -l help -d 'Show this message'
-__fish_brew_complete_arg 'livecheck' -l installed -d 'Check formulae/casks that are currently installed'
+__fish_brew_complete_arg 'livecheck' -l installed -d 'Check formulae and casks that are currently installed'
 __fish_brew_complete_arg 'livecheck' -l json -d 'Output information in JSON format'
 __fish_brew_complete_arg 'livecheck' -l newer-only -d 'Show the latest version only if it\'s newer than the formula/cask'
 __fish_brew_complete_arg 'livecheck' -l quiet -d 'Suppress warnings, don\'t print a progress bar for JSON output'
-__fish_brew_complete_arg 'livecheck' -l tap -d 'Check formulae/casks within the given tap, specified as user`/`repo'
+__fish_brew_complete_arg 'livecheck' -l resources -d 'Also check resources for formulae'
+__fish_brew_complete_arg 'livecheck' -l tap -d 'Check formulae and casks within the given tap, specified as user`/`repo'
 __fish_brew_complete_arg 'livecheck' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'livecheck; and not __fish_seen_argument -l cask -l casks' -a '(__fish_brew_suggest_formulae_all)'
 __fish_brew_complete_arg 'livecheck; and not __fish_seen_argument -l formula -l formulae' -a '(__fish_brew_suggest_casks_all)'
@@ -994,13 +1103,17 @@ __fish_brew_complete_arg 'log; and not __fish_seen_argument -l formula -l formul
 
 
 __fish_brew_complete_cmd 'ls' 'List all installed formulae and casks'
+__fish_brew_complete_arg 'ls' -l built-from-source -d 'List the formulae compiled from source'
 __fish_brew_complete_arg 'ls' -l cask -d 'List only casks, or treat all named arguments as casks'
 __fish_brew_complete_arg 'ls' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'ls' -l formula -d 'List only formulae, or treat all named arguments as formulae'
 __fish_brew_complete_arg 'ls' -l full-name -d 'Print formulae with fully-qualified names. Unless `--full-name`, `--versions` or `--pinned` are passed, other options (i.e. `-1`, `-l`, `-r` and `-t`) are passed to `ls`(1) which produces the actual output'
 __fish_brew_complete_arg 'ls' -l help -d 'Show this message'
+__fish_brew_complete_arg 'ls' -l installed-as-dependency -d 'List the formulae installed as dependencies'
+__fish_brew_complete_arg 'ls' -l installed-on-request -d 'List the formulae installed on request'
 __fish_brew_complete_arg 'ls' -l multiple -d 'Only show formulae with multiple versions installed'
 __fish_brew_complete_arg 'ls' -l pinned -d 'List only pinned formulae, or only the specified (pinned) formulae if formula are provided. See also `pin`, `unpin`'
+__fish_brew_complete_arg 'ls' -l poured-from-bottle -d 'List the formulae installed from a bottle'
 __fish_brew_complete_arg 'ls' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'ls' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'ls' -l versions -d 'Show the version number for installed formulae, or only the specified formulae if formula are provided'
@@ -1013,13 +1126,16 @@ __fish_brew_complete_arg 'ls; and not __fish_seen_argument -l formula -l formula
 
 
 __fish_brew_complete_cmd 'migrate' 'Migrate renamed packages to new names, where formula are old names of packages'
+__fish_brew_complete_arg 'migrate' -l cask -d 'Only migrate casks'
 __fish_brew_complete_arg 'migrate' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'migrate' -l dry-run -d 'Show what would be migrated, but do not actually migrate anything'
 __fish_brew_complete_arg 'migrate' -l force -d 'Treat installed formula and provided formula as if they are from the same taps and migrate them anyway'
+__fish_brew_complete_arg 'migrate' -l formula -d 'Only migrate formulae'
 __fish_brew_complete_arg 'migrate' -l help -d 'Show this message'
 __fish_brew_complete_arg 'migrate' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'migrate' -l verbose -d 'Make some output more verbose'
-__fish_brew_complete_arg 'migrate' -a '(__fish_brew_suggest_formulae_installed)'
+__fish_brew_complete_arg 'migrate; and not __fish_seen_argument -l cask -l casks' -a '(__fish_brew_suggest_formulae_installed)'
+__fish_brew_complete_arg 'migrate; and not __fish_seen_argument -l formula -l formulae' -a '(__fish_brew_suggest_casks_installed)'
 
 
 __fish_brew_complete_cmd 'missing' 'Check the given formula kegs for missing dependencies'
@@ -1031,11 +1147,18 @@ __fish_brew_complete_arg 'missing' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'missing' -a '(__fish_brew_suggest_formulae_all)'
 
 
+__fish_brew_complete_cmd 'nodenv-sync' 'Create symlinks for Homebrew\'s installed NodeJS versions in `~/.nodenv/versions`'
+__fish_brew_complete_arg 'nodenv-sync' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'nodenv-sync' -l help -d 'Show this message'
+__fish_brew_complete_arg 'nodenv-sync' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'nodenv-sync' -l verbose -d 'Make some output more verbose'
+
+
 __fish_brew_complete_cmd 'options' 'Show install options specific to formula'
-__fish_brew_complete_arg 'options' -l all -d 'Show options for all available formulae'
 __fish_brew_complete_arg 'options' -l command -d 'Show options for the specified command'
 __fish_brew_complete_arg 'options' -l compact -d 'Show all options on a single line separated by spaces'
 __fish_brew_complete_arg 'options' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'options' -l eval-all -d 'Evaluate all available formulae and casks, whether installed or not, to show their options'
 __fish_brew_complete_arg 'options' -l help -d 'Show this message'
 __fish_brew_complete_arg 'options' -l installed -d 'Show options for formulae that are currently installed'
 __fish_brew_complete_arg 'options' -l quiet -d 'Make some output more quiet'
@@ -1067,6 +1190,14 @@ __fish_brew_complete_arg 'pin' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'pin' -a '(__fish_brew_suggest_formulae_installed)'
 
 
+__fish_brew_complete_cmd 'post_install' 'Rerun the post-install steps for formula'
+__fish_brew_complete_arg 'post_install' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'post_install' -l help -d 'Show this message'
+__fish_brew_complete_arg 'post_install' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'post_install' -l verbose -d 'Make some output more verbose'
+__fish_brew_complete_arg 'post_install' -a '(__fish_brew_suggest_formulae_installed)'
+
+
 __fish_brew_complete_cmd 'postinstall' 'Rerun the post-install steps for formula'
 __fish_brew_complete_arg 'postinstall' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'postinstall' -l help -d 'Show this message'
@@ -1076,34 +1207,36 @@ __fish_brew_complete_arg 'postinstall' -a '(__fish_brew_suggest_formulae_install
 
 
 __fish_brew_complete_cmd 'pr-automerge' 'Find pull requests that can be automatically merged using `brew pr-publish`'
+__fish_brew_complete_arg 'pr-automerge' -l autosquash -d 'Instruct `brew pr-publish` to automatically reformat and reword commits in the pull request to the preferred format'
 __fish_brew_complete_arg 'pr-automerge' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'pr-automerge' -l help -d 'Show this message'
 __fish_brew_complete_arg 'pr-automerge' -l ignore-failures -d 'Include pull requests that have failing status checks'
-__fish_brew_complete_arg 'pr-automerge' -l no-autosquash -d 'Instruct `brew pr-publish` to skip automatically reformatting and rewording commits in the pull request to the preferred format'
 __fish_brew_complete_arg 'pr-automerge' -l publish -d 'Run `brew pr-publish` on matching pull requests'
 __fish_brew_complete_arg 'pr-automerge' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'pr-automerge' -l tap -d 'Target tap repository (default: `homebrew/core`)'
 __fish_brew_complete_arg 'pr-automerge' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'pr-automerge' -l with-label -d 'Pull requests must have this label'
 __fish_brew_complete_arg 'pr-automerge' -l without-approval -d 'Pull requests do not require approval to be merged'
-__fish_brew_complete_arg 'pr-automerge' -l without-labels -d 'Pull requests must not have these labels (default: `do not merge`, `new formula`, `automerge-skip`)'
+__fish_brew_complete_arg 'pr-automerge' -l without-labels -d 'Pull requests must not have these labels (default: `do not merge`, `new formula`, `automerge-skip`, `pre-release`, `CI-published-bottle-commits`)'
 __fish_brew_complete_arg 'pr-automerge' -l workflow -d 'Workflow file to use with `brew pr-publish`'
 
 
 __fish_brew_complete_cmd 'pr-publish' 'Publish bottles for a pull request with GitHub Actions'
-__fish_brew_complete_arg 'pr-publish' -l branch -d 'Branch to publish to (default: `master`)'
+__fish_brew_complete_arg 'pr-publish' -l autosquash -d 'If supported on the target tap, automatically reformat and reword commits to our preferred format'
+__fish_brew_complete_arg 'pr-publish' -l branch -d 'Branch to use the workflow from (default: `master`)'
 __fish_brew_complete_arg 'pr-publish' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'pr-publish' -l help -d 'Show this message'
-__fish_brew_complete_arg 'pr-publish' -l message -d 'Message to include when autosquashing revision bumps, deletions, and rebuilds'
-__fish_brew_complete_arg 'pr-publish' -l no-autosquash -d 'Skip automatically reformatting and rewording commits in the pull request to the preferred format, even if supported on the target tap'
+__fish_brew_complete_arg 'pr-publish' -l large-runner -d 'Run the upload job on a large runner'
+__fish_brew_complete_arg 'pr-publish' -l message -d 'Message to include when autosquashing revision bumps, deletions and rebuilds'
 __fish_brew_complete_arg 'pr-publish' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'pr-publish' -l tap -d 'Target tap repository (default: `homebrew/core`)'
 __fish_brew_complete_arg 'pr-publish' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'pr-publish' -l workflow -d 'Target workflow filename (default: `publish-commit-bottles.yml`)'
 
 
-__fish_brew_complete_cmd 'pr-pull' 'Download and publish bottles, and apply the bottle commit from a pull request with artifacts generated by GitHub Actions'
-__fish_brew_complete_arg 'pr-pull' -l artifact -d 'Download artifacts with the specified name (default: `bottles`)'
+__fish_brew_complete_cmd 'pr-pull' 'Download and publish bottles and apply the bottle commit from a pull request with artifacts generated by GitHub Actions'
+__fish_brew_complete_arg 'pr-pull' -l artifact-pattern -d 'Download artifacts with the specified pattern (default: `bottles{,_*}`)'
+__fish_brew_complete_arg 'pr-pull' -l autosquash -d 'Automatically reformat and reword commits in the pull request to our preferred format'
 __fish_brew_complete_arg 'pr-pull' -l branch-okay -d 'Do not warn if pulling to a branch besides the repository default (useful for testing)'
 __fish_brew_complete_arg 'pr-pull' -l clean -d 'Do not amend the commits from pull requests'
 __fish_brew_complete_arg 'pr-pull' -l committer -d 'Specify a committer name and email in `git`\'s standard author format'
@@ -1112,12 +1245,13 @@ __fish_brew_complete_arg 'pr-pull' -l dry-run -d 'Print what would be done rathe
 __fish_brew_complete_arg 'pr-pull' -l help -d 'Show this message'
 __fish_brew_complete_arg 'pr-pull' -l ignore-missing-artifacts -d 'Comma-separated list of workflows which can be ignored if they have not been run'
 __fish_brew_complete_arg 'pr-pull' -l keep-old -d 'If the formula specifies a rebuild version, attempt to preserve its value in the generated DSL'
-__fish_brew_complete_arg 'pr-pull' -l message -d 'Message to include when autosquashing revision bumps, deletions, and rebuilds'
-__fish_brew_complete_arg 'pr-pull' -l no-autosquash -d 'Skip automatically reformatting and rewording commits in the pull request to our preferred format'
+__fish_brew_complete_arg 'pr-pull' -l message -d 'Message to include when autosquashing revision bumps, deletions and rebuilds'
+__fish_brew_complete_arg 'pr-pull' -l no-cherry-pick -d 'Do not cherry-pick commits from the pull request branch'
 __fish_brew_complete_arg 'pr-pull' -l no-commit -d 'Do not generate a new commit before uploading'
 __fish_brew_complete_arg 'pr-pull' -l no-upload -d 'Download the bottles but don\'t upload them'
 __fish_brew_complete_arg 'pr-pull' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'pr-pull' -l resolve -d 'When a patch fails to apply, leave in progress and allow user to resolve, instead of aborting'
+__fish_brew_complete_arg 'pr-pull' -l retain-bottle-dir -d 'Does not clean up the tmp directory for the bottle so it can be used later'
 __fish_brew_complete_arg 'pr-pull' -l root-url -d 'Use the specified URL as the root of the bottle\'s URL instead of Homebrew\'s default'
 __fish_brew_complete_arg 'pr-pull' -l root-url-using -d 'Use the specified download strategy class for downloading the bottle\'s URL instead of Homebrew\'s default'
 __fish_brew_complete_arg 'pr-pull' -l tap -d 'Target tap repository (default: `homebrew/core`)'
@@ -1147,20 +1281,40 @@ __fish_brew_complete_arg 'prof' -l help -d 'Show this message'
 __fish_brew_complete_arg 'prof' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'prof' -l stackprof -d 'Use `stackprof` instead of `ruby-prof` (the default)'
 __fish_brew_complete_arg 'prof' -l verbose -d 'Make some output more verbose'
+__fish_brew_complete_arg 'prof' -l vernier -d 'Use `vernier` instead of `ruby-prof` (the default)'
 __fish_brew_complete_arg 'prof' -a '(__fish_brew_suggest_commands)'
 
 
+__fish_brew_complete_cmd 'pyenv-sync' 'Create symlinks for Homebrew\'s installed Python versions in `~/.pyenv/versions`'
+__fish_brew_complete_arg 'pyenv-sync' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'pyenv-sync' -l help -d 'Show this message'
+__fish_brew_complete_arg 'pyenv-sync' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'pyenv-sync' -l verbose -d 'Make some output more verbose'
+
+
+__fish_brew_complete_cmd 'rbenv-sync' 'Create symlinks for Homebrew\'s installed Ruby versions in `~/.rbenv/versions`'
+__fish_brew_complete_arg 'rbenv-sync' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'rbenv-sync' -l help -d 'Show this message'
+__fish_brew_complete_arg 'rbenv-sync' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'rbenv-sync' -l verbose -d 'Make some output more verbose'
+
+
 __fish_brew_complete_cmd 'readall' 'Import all items from the specified tap, or from all installed taps if none is provided'
 __fish_brew_complete_arg 'readall' -l aliases -d 'Verify any alias symlinks in each tap'
+__fish_brew_complete_arg 'readall' -l arch -d 'Read using the given CPU architecture. (Pass `all` to simulate all architectures.)'
 __fish_brew_complete_arg 'readall' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'readall' -l eval-all -d 'Evaluate all available formulae and casks, whether installed or not. Implied if `HOMEBREW_EVAL_ALL` is set'
 __fish_brew_complete_arg 'readall' -l help -d 'Show this message'
+__fish_brew_complete_arg 'readall' -l no-simulate -d 'Don\'t simulate other system configurations when checking formulae and casks'
+__fish_brew_complete_arg 'readall' -l os -d 'Read using the given operating system. (Pass `all` to simulate all operating systems.)'
 __fish_brew_complete_arg 'readall' -l quiet -d 'Make some output more quiet'
-__fish_brew_complete_arg 'readall' -l syntax -d 'Syntax-check all of Homebrew\'s Ruby files (if no `tap` is passed)'
+__fish_brew_complete_arg 'readall' -l syntax -d 'Syntax-check all of Homebrew\'s Ruby files (if no tap is passed)'
 __fish_brew_complete_arg 'readall' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'readall' -a '(__fish_brew_suggest_taps_installed)'
 
 
 __fish_brew_complete_cmd 'reinstall' 'Uninstall and then reinstall a formula or cask using the same options it was originally installed with, plus any appended options specific to a formula'
+__fish_brew_complete_arg 'reinstall' -l adopt -d 'Adopt existing artifacts in the destination that are identical to those being installed. Cannot be combined with `--force`'
 __fish_brew_complete_arg 'reinstall' -l appdir -d 'Target location for Applications (default: `/Applications`)'
 __fish_brew_complete_arg 'reinstall' -l audio-unit-plugindir -d 'Target location for Audio Unit Plugins (default: `~/Library/Audio/Plug-Ins/Components`)'
 __fish_brew_complete_arg 'reinstall' -l binaries -d 'Disable/enable linking of helper executables (default: enabled)'
@@ -1168,8 +1322,9 @@ __fish_brew_complete_arg 'reinstall' -l build-from-source -d 'Compile formula fr
 __fish_brew_complete_arg 'reinstall' -l cask -d 'Treat all named arguments as casks'
 __fish_brew_complete_arg 'reinstall' -l colorpickerdir -d 'Target location for Color Pickers (default: `~/Library/ColorPickers`)'
 __fish_brew_complete_arg 'reinstall' -l debug -d 'If brewing fails, open an interactive debugging session with access to IRB or a shell inside the temporary build directory'
+__fish_brew_complete_arg 'reinstall' -l debug-symbols -d 'Generate debug symbols on build. Source will be retained in a cache directory'
 __fish_brew_complete_arg 'reinstall' -l dictionarydir -d 'Target location for Dictionaries (default: `~/Library/Dictionaries`)'
-__fish_brew_complete_arg 'reinstall' -l display-times -d 'Print install times for each formula at the end of the run'
+__fish_brew_complete_arg 'reinstall' -l display-times -d 'Print install times for each package at the end of the run'
 __fish_brew_complete_arg 'reinstall' -l fontdir -d 'Target location for Fonts (default: `~/Library/Fonts`)'
 __fish_brew_complete_arg 'reinstall' -l force -d 'Install without checking for previously installed keg-only or non-migrated versions'
 __fish_brew_complete_arg 'reinstall' -l force-bottle -d 'Install from a bottle if it exists for the current or newest version of macOS, even if it would not normally be used for installation'
@@ -1180,19 +1335,20 @@ __fish_brew_complete_arg 'reinstall' -l input-methoddir -d 'Target location for
 __fish_brew_complete_arg 'reinstall' -l interactive -d 'Download and patch formula, then open a shell. This allows the user to run `./configure --help` and otherwise determine how to turn the software package into a Homebrew package'
 __fish_brew_complete_arg 'reinstall' -l internet-plugindir -d 'Target location for Internet Plugins (default: `~/Library/Internet Plug-Ins`)'
 __fish_brew_complete_arg 'reinstall' -l keep-tmp -d 'Retain the temporary files created during installation'
+__fish_brew_complete_arg 'reinstall' -l keyboard-layoutdir -d 'Target location for Keyboard Layouts (default: `/Library/Keyboard Layouts`)'
 __fish_brew_complete_arg 'reinstall' -l language -d 'Comma-separated list of language codes to prefer for cask installation. The first matching language is used, otherwise it reverts to the cask\'s default language. The default value is the language of your system'
 __fish_brew_complete_arg 'reinstall' -l mdimporterdir -d 'Target location for Spotlight Plugins (default: `~/Library/Spotlight`)'
 __fish_brew_complete_arg 'reinstall' -l no-binaries -d 'Disable/enable linking of helper executables (default: enabled)'
 __fish_brew_complete_arg 'reinstall' -l no-quarantine -d 'Disable/enable quarantining of downloads (default: enabled)'
 __fish_brew_complete_arg 'reinstall' -l prefpanedir -d 'Target location for Preference Panes (default: `~/Library/PreferencePanes`)'
-__fish_brew_complete_arg 'reinstall' -l qlplugindir -d 'Target location for QuickLook Plugins (default: `~/Library/QuickLook`)'
+__fish_brew_complete_arg 'reinstall' -l qlplugindir -d 'Target location for Quick Look Plugins (default: `~/Library/QuickLook`)'
 __fish_brew_complete_arg 'reinstall' -l quarantine -d 'Disable/enable quarantining of downloads (default: enabled)'
 __fish_brew_complete_arg 'reinstall' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'reinstall' -l require-sha -d 'Require all casks to have a checksum'
 __fish_brew_complete_arg 'reinstall' -l screen-saverdir -d 'Target location for Screen Savers (default: `~/Library/Screen Savers`)'
 __fish_brew_complete_arg 'reinstall' -l servicedir -d 'Target location for Services (default: `~/Library/Services`)'
 __fish_brew_complete_arg 'reinstall' -l skip-cask-deps -d 'Skip installing cask dependencies'
-__fish_brew_complete_arg 'reinstall' -l verbose -d 'Print the verification and postinstall steps'
+__fish_brew_complete_arg 'reinstall' -l verbose -d 'Print the verification and post-install steps'
 __fish_brew_complete_arg 'reinstall' -l vst-plugindir -d 'Target location for VST Plugins (default: `~/Library/Audio/Plug-Ins/VST`)'
 __fish_brew_complete_arg 'reinstall' -l vst3-plugindir -d 'Target location for VST3 Plugins (default: `~/Library/Audio/Plug-Ins/VST3`)'
 __fish_brew_complete_arg 'reinstall' -l zap -d 'For use with `brew reinstall --cask`. Remove all files associated with a cask. *May remove files which are shared between applications.*'
@@ -1237,6 +1393,13 @@ __fish_brew_complete_arg 'rm; and not __fish_seen_argument -l cask -l casks' -a
 __fish_brew_complete_arg 'rm; and not __fish_seen_argument -l formula -l formulae' -a '(__fish_brew_suggest_casks_installed)'
 
 
+__fish_brew_complete_cmd 'rubocop' 'Installs, configures and runs Homebrew\'s `rubocop`'
+__fish_brew_complete_arg 'rubocop' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'rubocop' -l help -d 'Show this message'
+__fish_brew_complete_arg 'rubocop' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'rubocop' -l verbose -d 'Make some output more verbose'
+
+
 __fish_brew_complete_cmd 'ruby' 'Run a Ruby instance with Homebrew\'s libraries loaded'
 __fish_brew_complete_arg 'ruby' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'ruby' -l help -d 'Show this message'
@@ -1246,16 +1409,26 @@ __fish_brew_complete_arg 'ruby' -l e -d 'Execute the given text string as a scri
 __fish_brew_complete_arg 'ruby' -l r -d 'Load a library using `require`'
 
 
+__fish_brew_complete_cmd 'rubydoc' 'Generate Homebrew\'s RubyDoc documentation'
+__fish_brew_complete_arg 'rubydoc' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'rubydoc' -l help -d 'Show this message'
+__fish_brew_complete_arg 'rubydoc' -l only-public -d 'Only generate public API documentation'
+__fish_brew_complete_arg 'rubydoc' -l open -d 'Open generated documentation in a browser'
+__fish_brew_complete_arg 'rubydoc' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'rubydoc' -l verbose -d 'Make some output more verbose'
+
+
 __fish_brew_complete_cmd 'search' 'Perform a substring search of cask tokens and formula names for text'
 __fish_brew_complete_arg 'search' -l archlinux -d 'Search for text in the given database'
-__fish_brew_complete_arg 'search' -l cask -d 'Search online and locally for casks'
+__fish_brew_complete_arg 'search' -l cask -d 'Search for casks'
 __fish_brew_complete_arg 'search' -l closed -d 'Search for only closed GitHub pull requests'
 __fish_brew_complete_arg 'search' -l debian -d 'Search for text in the given database'
 __fish_brew_complete_arg 'search' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'search' -l desc -d 'Search for formulae with a description matching text and casks with a name or description matching text'
+__fish_brew_complete_arg 'search' -l eval-all -d 'Evaluate all available formulae and casks, whether installed or not, to search their descriptions. Implied if `HOMEBREW_EVAL_ALL` is set'
 __fish_brew_complete_arg 'search' -l fedora -d 'Search for text in the given database'
 __fish_brew_complete_arg 'search' -l fink -d 'Search for text in the given database'
-__fish_brew_complete_arg 'search' -l formula -d 'Search online and locally for formulae'
+__fish_brew_complete_arg 'search' -l formula -d 'Search for formulae'
 __fish_brew_complete_arg 'search' -l help -d 'Show this message'
 __fish_brew_complete_arg 'search' -l macports -d 'Search for text in the given database'
 __fish_brew_complete_arg 'search' -l open -d 'Search for only open GitHub pull requests'
@@ -1267,6 +1440,14 @@ __fish_brew_complete_arg 'search' -l ubuntu -d 'Search for text in the given dat
 __fish_brew_complete_arg 'search' -l verbose -d 'Make some output more verbose'
 
 
+__fish_brew_complete_cmd 'setup-ruby' 'Installs and configures Homebrew\'s Ruby'
+__fish_brew_complete_arg 'setup-ruby' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'setup-ruby' -l help -d 'Show this message'
+__fish_brew_complete_arg 'setup-ruby' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'setup-ruby' -l verbose -d 'Make some output more verbose'
+__fish_brew_complete_arg 'setup-ruby' -a '(__fish_brew_suggest_commands)'
+
+
 __fish_brew_complete_cmd 'sh' 'Enter an interactive shell for Homebrew\'s build environment'
 __fish_brew_complete_arg 'sh' -l cmd -d 'Execute commands in a non-interactive shell'
 __fish_brew_complete_arg 'sh' -l debug -d 'Display any debugging information'
@@ -1276,17 +1457,16 @@ __fish_brew_complete_arg 'sh' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'sh' -l verbose -d 'Make some output more verbose'
 
 
-__fish_brew_complete_cmd 'sponsors' 'Update the list of GitHub Sponsors in the `Homebrew/brew` README'
-__fish_brew_complete_arg 'sponsors' -l debug -d 'Display any debugging information'
-__fish_brew_complete_arg 'sponsors' -l help -d 'Show this message'
-__fish_brew_complete_arg 'sponsors' -l quiet -d 'Make some output more quiet'
-__fish_brew_complete_arg 'sponsors' -l verbose -d 'Make some output more verbose'
+__fish_brew_complete_cmd 'shellenv' 'Valid shells: bash|csh|fish|pwsh|sh|tcsh|zsh  Print export statements'
+__fish_brew_complete_arg 'shellenv' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'shellenv' -l help -d 'Show this message'
+__fish_brew_complete_arg 'shellenv' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'shellenv' -l verbose -d 'Make some output more verbose'
 
 
 __fish_brew_complete_cmd 'style' 'Check formulae or files for conformance to Homebrew style guidelines'
 __fish_brew_complete_arg 'style' -l cask -d 'Treat all named arguments as casks'
 __fish_brew_complete_arg 'style' -l debug -d 'Display any debugging information'
-__fish_brew_complete_arg 'style' -l display-cop-names -d 'Include the RuboCop cop name for each violation in the output'
 __fish_brew_complete_arg 'style' -l except-cops -d 'Specify a comma-separated cops list to skip checking for violations of the listed RuboCop cops'
 __fish_brew_complete_arg 'style' -l fix -d 'Fix style violations automatically using RuboCop\'s auto-correct feature'
 __fish_brew_complete_arg 'style' -l formula -d 'Treat all named arguments as formulae'
@@ -1300,13 +1480,25 @@ __fish_brew_complete_arg 'style; and not __fish_seen_argument -l cask -l casks'
 __fish_brew_complete_arg 'style; and not __fish_seen_argument -l formula -l formulae' -a '(__fish_brew_suggest_casks_all)'
 
 
+__fish_brew_complete_cmd 'tab' 'Edit tab information for installed formulae or casks'
+__fish_brew_complete_arg 'tab' -l cask -d 'Only mark casks'
+__fish_brew_complete_arg 'tab' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'tab' -l formula -d 'Only mark formulae'
+__fish_brew_complete_arg 'tab' -l help -d 'Show this message'
+__fish_brew_complete_arg 'tab' -l installed-on-request -d 'Mark installed_formula or installed_cask as installed on request'
+__fish_brew_complete_arg 'tab' -l no-installed-on-request -d 'Mark installed_formula or installed_cask as not installed on request'
+__fish_brew_complete_arg 'tab' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'tab' -l verbose -d 'Make some output more verbose'
+__fish_brew_complete_arg 'tab; and not __fish_seen_argument -l cask -l casks' -a '(__fish_brew_suggest_formulae_installed)'
+__fish_brew_complete_arg 'tab; and not __fish_seen_argument -l formula -l formulae' -a '(__fish_brew_suggest_casks_installed)'
+
+
 __fish_brew_complete_cmd 'tap' 'Tap a formula repository'
 __fish_brew_complete_arg 'tap' -l custom-remote -d 'Install or change a tap with a custom remote. Useful for mirrors'
 __fish_brew_complete_arg 'tap' -l debug -d 'Display any debugging information'
-__fish_brew_complete_arg 'tap' -l force-auto-update -d 'Auto-update tap even if it is not hosted on GitHub. By default, only taps hosted on GitHub are auto-updated (for performance reasons)'
+__fish_brew_complete_arg 'tap' -l eval-all -d 'Evaluate all the formulae, casks and aliases in the new tap to check validity. Implied if `HOMEBREW_EVAL_ALL` is set'
+__fish_brew_complete_arg 'tap' -l force -d 'Force install core taps even under API mode'
 __fish_brew_complete_arg 'tap' -l help -d 'Show this message'
-__fish_brew_complete_arg 'tap' -l list-pinned -d 'List all pinned taps'
-__fish_brew_complete_arg 'tap' -l no-force-auto-update -d 'Auto-update tap even if it is not hosted on GitHub. By default, only taps hosted on GitHub are auto-updated (for performance reasons)'
 __fish_brew_complete_arg 'tap' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'tap' -l repair -d 'Migrate tapped formulae from symlink-based to directory-based structure'
 __fish_brew_complete_arg 'tap' -l verbose -d 'Make some output more verbose'
@@ -1336,22 +1528,23 @@ __fish_brew_complete_arg 'tap-new' -a '(__fish_brew_suggest_taps_installed)'
 
 
 __fish_brew_complete_cmd 'tc' 'Check for typechecking errors using Sorbet'
-__fish_brew_complete_arg 'tc' -l all -d 'Regenerate all RBI files rather than just updated gems'
 __fish_brew_complete_arg 'tc' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'tc' -l dir -d 'Typecheck all files in a specific directory'
-__fish_brew_complete_arg 'tc' -l fail-if-not-changed -d 'Return a failing status code if all gems are up to date and gem definitions do not need a tapioca update'
 __fish_brew_complete_arg 'tc' -l file -d 'Typecheck a single file'
 __fish_brew_complete_arg 'tc' -l fix -d 'Automatically fix type errors'
 __fish_brew_complete_arg 'tc' -l help -d 'Show this message'
 __fish_brew_complete_arg 'tc' -l ignore -d 'Ignores input files that contain the given string in their paths (relative to the input path passed to Sorbet)'
+__fish_brew_complete_arg 'tc' -l lsp -d 'Start the Sorbet LSP server'
 __fish_brew_complete_arg 'tc' -l quiet -d 'Silence all non-critical errors'
 __fish_brew_complete_arg 'tc' -l suggest-typed -d 'Try upgrading `typed` sigils'
 __fish_brew_complete_arg 'tc' -l update -d 'Update RBI files'
+__fish_brew_complete_arg 'tc' -l update-all -d 'Update all RBI files rather than just updated gems'
 __fish_brew_complete_arg 'tc' -l verbose -d 'Make some output more verbose'
+__fish_brew_complete_arg 'tc' -a '(__fish_brew_suggest_taps_installed)'
 
 
 __fish_brew_complete_cmd 'test' 'Run the test method provided by an installed formula'
-__fish_brew_complete_arg 'test' -l HEAD -d 'Test the head version of a formula'
+__fish_brew_complete_arg 'test' -l HEAD -d 'Test the HEAD version of a formula'
 __fish_brew_complete_arg 'test' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'test' -l force -d 'Test formulae even if they are unlinked'
 __fish_brew_complete_arg 'test' -l help -d 'Show this message'
@@ -1363,42 +1556,45 @@ __fish_brew_complete_arg 'test' -a '(__fish_brew_suggest_formulae_installed)'
 
 
 __fish_brew_complete_cmd 'tests' 'Run Homebrew\'s unit and integration tests'
-__fish_brew_complete_arg 'tests' -l byebug -d 'Enable debugging using byebug'
 __fish_brew_complete_arg 'tests' -l changed -d 'Only runs tests on files that were changed from the master branch'
 __fish_brew_complete_arg 'tests' -l coverage -d 'Generate code coverage reports'
-__fish_brew_complete_arg 'tests' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'tests' -l debug -d 'Enable debugging using `ruby/debug`, or surface the standard `odebug` output'
+__fish_brew_complete_arg 'tests' -l fail-fast -d 'Exit early on the first failing test'
 __fish_brew_complete_arg 'tests' -l generic -d 'Run only OS-agnostic tests'
 __fish_brew_complete_arg 'tests' -l help -d 'Show this message'
-__fish_brew_complete_arg 'tests' -l no-compat -d 'Do not load the compatibility layer when running tests'
 __fish_brew_complete_arg 'tests' -l online -d 'Include tests that use the GitHub API and tests that use any of the taps for official external commands'
-__fish_brew_complete_arg 'tests' -l only -d 'Run only test_script`_spec.rb`. Appending `:`line_number will start at a specific line'
+__fish_brew_complete_arg 'tests' -l only -d 'Run only `test_script_spec.rb`. Appending `:line_number` will start at a specific line'
+__fish_brew_complete_arg 'tests' -l profile -d 'Run the test suite serially to find the n slowest tests'
 __fish_brew_complete_arg 'tests' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'tests' -l seed -d 'Randomise tests with the specified value instead of a random seed'
 __fish_brew_complete_arg 'tests' -l verbose -d 'Make some output more verbose'
 
 
 __fish_brew_complete_cmd 'typecheck' 'Check for typechecking errors using Sorbet'
-__fish_brew_complete_arg 'typecheck' -l all -d 'Regenerate all RBI files rather than just updated gems'
 __fish_brew_complete_arg 'typecheck' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'typecheck' -l dir -d 'Typecheck all files in a specific directory'
-__fish_brew_complete_arg 'typecheck' -l fail-if-not-changed -d 'Return a failing status code if all gems are up to date and gem definitions do not need a tapioca update'
 __fish_brew_complete_arg 'typecheck' -l file -d 'Typecheck a single file'
 __fish_brew_complete_arg 'typecheck' -l fix -d 'Automatically fix type errors'
 __fish_brew_complete_arg 'typecheck' -l help -d 'Show this message'
 __fish_brew_complete_arg 'typecheck' -l ignore -d 'Ignores input files that contain the given string in their paths (relative to the input path passed to Sorbet)'
+__fish_brew_complete_arg 'typecheck' -l lsp -d 'Start the Sorbet LSP server'
 __fish_brew_complete_arg 'typecheck' -l quiet -d 'Silence all non-critical errors'
 __fish_brew_complete_arg 'typecheck' -l suggest-typed -d 'Try upgrading `typed` sigils'
 __fish_brew_complete_arg 'typecheck' -l update -d 'Update RBI files'
+__fish_brew_complete_arg 'typecheck' -l update-all -d 'Update all RBI files rather than just updated gems'
 __fish_brew_complete_arg 'typecheck' -l verbose -d 'Make some output more verbose'
+__fish_brew_complete_arg 'typecheck' -a '(__fish_brew_suggest_taps_installed)'
 
 
 __fish_brew_complete_cmd 'unbottled' 'Show the unbottled dependents of formulae'
-__fish_brew_complete_arg 'unbottled' -l all -d 'Print the number of unbottled and total formulae'
 __fish_brew_complete_arg 'unbottled' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'unbottled' -l dependents -d 'Skip getting analytics data and sort by number of dependents instead'
+__fish_brew_complete_arg 'unbottled' -l eval-all -d 'Evaluate all available formulae and casks, whether installed or not, to check them. Implied if `HOMEBREW_EVAL_ALL` is set'
 __fish_brew_complete_arg 'unbottled' -l help -d 'Show this message'
+__fish_brew_complete_arg 'unbottled' -l lost -d 'Print the `homebrew/core` commits where bottles were lost in the last week'
 __fish_brew_complete_arg 'unbottled' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'unbottled' -l tag -d 'Use the specified bottle tag (e.g. `big_sur`) instead of the current OS'
+__fish_brew_complete_arg 'unbottled' -l total -d 'Print the number of unbottled and total formulae'
 __fish_brew_complete_arg 'unbottled' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'unbottled' -a '(__fish_brew_suggest_formulae_all)'
 
@@ -1491,7 +1687,6 @@ __fish_brew_complete_arg 'update' -l verbose -d 'Print the directories checked a
 
 __fish_brew_complete_cmd 'update-license-data' 'Update SPDX license data in the Homebrew repository'
 __fish_brew_complete_arg 'update-license-data' -l debug -d 'Display any debugging information'
-__fish_brew_complete_arg 'update-license-data' -l fail-if-not-changed -d 'Return a failing status code if current license data\'s version is the same as the upstream. This can be used to notify CI when the SPDX license data is out of date'
 __fish_brew_complete_arg 'update-license-data' -l help -d 'Show this message'
 __fish_brew_complete_arg 'update-license-data' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'update-license-data' -l verbose -d 'Make some output more verbose'
@@ -1510,6 +1705,7 @@ __fish_brew_complete_arg 'update-python-resources' -l exclude-packages -d 'Exclu
 __fish_brew_complete_arg 'update-python-resources' -l extra-packages -d 'Include these additional packages when finding resources'
 __fish_brew_complete_arg 'update-python-resources' -l help -d 'Show this message'
 __fish_brew_complete_arg 'update-python-resources' -l ignore-non-pypi-packages -d 'Don\'t fail if formula is not a PyPI package'
+__fish_brew_complete_arg 'update-python-resources' -l install-dependencies -d 'Install missing dependencies required to update resources'
 __fish_brew_complete_arg 'update-python-resources' -l package-name -d 'Use the specified package-name when finding resources for formula. If no package name is specified, it will be inferred from the formula\'s stable URL'
 __fish_brew_complete_arg 'update-python-resources' -l print-only -d 'Print the updated resource blocks instead of changing formula'
 __fish_brew_complete_arg 'update-python-resources' -l quiet -d 'Make some output more quiet'
@@ -1528,6 +1724,20 @@ __fish_brew_complete_arg 'update-report' -l quiet -d 'Make some output more quie
 __fish_brew_complete_arg 'update-report' -l verbose -d 'Make some output more verbose'
 
 
+__fish_brew_complete_cmd 'update-reset' 'Fetch and reset Homebrew and all tap repositories (or any specified repository) using `git`(1) to their latest `origin/HEAD`'
+__fish_brew_complete_arg 'update-reset' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'update-reset' -l help -d 'Show this message'
+__fish_brew_complete_arg 'update-reset' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'update-reset' -l verbose -d 'Make some output more verbose'
+
+
+__fish_brew_complete_cmd 'update-sponsors' 'Update the list of GitHub Sponsors in the `Homebrew/brew` README'
+__fish_brew_complete_arg 'update-sponsors' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'update-sponsors' -l help -d 'Show this message'
+__fish_brew_complete_arg 'update-sponsors' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'update-sponsors' -l verbose -d 'Make some output more verbose'
+
+
 __fish_brew_complete_cmd 'update-test' 'Run a test of `brew update` with a new repository clone'
 __fish_brew_complete_arg 'update-test' -l before -d 'Use the commit at the specified date as the start commit'
 __fish_brew_complete_arg 'update-test' -l commit -d 'Use the specified commit as the start commit'
@@ -1547,6 +1757,7 @@ __fish_brew_complete_arg 'upgrade' -l build-from-source -d 'Compile formula from
 __fish_brew_complete_arg 'upgrade' -l cask -d 'Treat all named arguments as casks. If no named arguments are specified, upgrade only outdated casks'
 __fish_brew_complete_arg 'upgrade' -l colorpickerdir -d 'Target location for Color Pickers (default: `~/Library/ColorPickers`)'
 __fish_brew_complete_arg 'upgrade' -l debug -d 'If brewing fails, open an interactive debugging session with access to IRB or a shell inside the temporary build directory'
+__fish_brew_complete_arg 'upgrade' -l debug-symbols -d 'Generate debug symbols on build. Source will be retained in a cache directory'
 __fish_brew_complete_arg 'upgrade' -l dictionarydir -d 'Target location for Dictionaries (default: `~/Library/Dictionaries`)'
 __fish_brew_complete_arg 'upgrade' -l display-times -d 'Print install times for each package at the end of the run'
 __fish_brew_complete_arg 'upgrade' -l dry-run -d 'Show what would be upgraded, but do not actually upgrade anything'
@@ -1559,42 +1770,45 @@ __fish_brew_complete_arg 'upgrade' -l greedy -d 'Also include casks with `auto_u
 __fish_brew_complete_arg 'upgrade' -l greedy-auto-updates -d 'Also include casks with `auto_updates true`'
 __fish_brew_complete_arg 'upgrade' -l greedy-latest -d 'Also include casks with `version :latest`'
 __fish_brew_complete_arg 'upgrade' -l help -d 'Show this message'
-__fish_brew_complete_arg 'upgrade' -l ignore-pinned -d 'Set a successful exit status even if pinned formulae are not upgraded'
 __fish_brew_complete_arg 'upgrade' -l input-methoddir -d 'Target location for Input Methods (default: `~/Library/Input Methods`)'
 __fish_brew_complete_arg 'upgrade' -l interactive -d 'Download and patch formula, then open a shell. This allows the user to run `./configure --help` and otherwise determine how to turn the software package into a Homebrew package'
 __fish_brew_complete_arg 'upgrade' -l internet-plugindir -d 'Target location for Internet Plugins (default: `~/Library/Internet Plug-Ins`)'
 __fish_brew_complete_arg 'upgrade' -l keep-tmp -d 'Retain the temporary files created during installation'
+__fish_brew_complete_arg 'upgrade' -l keyboard-layoutdir -d 'Target location for Keyboard Layouts (default: `/Library/Keyboard Layouts`)'
 __fish_brew_complete_arg 'upgrade' -l language -d 'Comma-separated list of language codes to prefer for cask installation. The first matching language is used, otherwise it reverts to the cask\'s default language. The default value is the language of your system'
 __fish_brew_complete_arg 'upgrade' -l mdimporterdir -d 'Target location for Spotlight Plugins (default: `~/Library/Spotlight`)'
 __fish_brew_complete_arg 'upgrade' -l no-binaries -d 'Disable/enable linking of helper executables (default: enabled)'
 __fish_brew_complete_arg 'upgrade' -l no-quarantine -d 'Disable/enable quarantining of downloads (default: enabled)'
+__fish_brew_complete_arg 'upgrade' -l overwrite -d 'Delete files that already exist in the prefix while linking'
 __fish_brew_complete_arg 'upgrade' -l prefpanedir -d 'Target location for Preference Panes (default: `~/Library/PreferencePanes`)'
-__fish_brew_complete_arg 'upgrade' -l qlplugindir -d 'Target location for QuickLook Plugins (default: `~/Library/QuickLook`)'
+__fish_brew_complete_arg 'upgrade' -l qlplugindir -d 'Target location for Quick Look Plugins (default: `~/Library/QuickLook`)'
 __fish_brew_complete_arg 'upgrade' -l quarantine -d 'Disable/enable quarantining of downloads (default: enabled)'
 __fish_brew_complete_arg 'upgrade' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'upgrade' -l require-sha -d 'Require all casks to have a checksum'
 __fish_brew_complete_arg 'upgrade' -l screen-saverdir -d 'Target location for Screen Savers (default: `~/Library/Screen Savers`)'
 __fish_brew_complete_arg 'upgrade' -l servicedir -d 'Target location for Services (default: `~/Library/Services`)'
 __fish_brew_complete_arg 'upgrade' -l skip-cask-deps -d 'Skip installing cask dependencies'
-__fish_brew_complete_arg 'upgrade' -l verbose -d 'Print the verification and postinstall steps'
+__fish_brew_complete_arg 'upgrade' -l verbose -d 'Print the verification and post-install steps'
 __fish_brew_complete_arg 'upgrade' -l vst-plugindir -d 'Target location for VST Plugins (default: `~/Library/Audio/Plug-Ins/VST`)'
 __fish_brew_complete_arg 'upgrade' -l vst3-plugindir -d 'Target location for VST3 Plugins (default: `~/Library/Audio/Plug-Ins/VST3`)'
-__fish_brew_complete_arg 'upgrade; and not __fish_seen_argument -l cask -l casks' -a '(__fish_brew_suggest_formulae_outdated)'
-__fish_brew_complete_arg 'upgrade; and not __fish_seen_argument -l formula -l formulae' -a '(__fish_brew_suggest_casks_outdated)'
+__fish_brew_complete_arg 'upgrade; and not __fish_seen_argument -l cask -l casks' -a '(__fish_brew_suggest_formulae_installed)'
+__fish_brew_complete_arg 'upgrade; and not __fish_seen_argument -l formula -l formulae' -a '(__fish_brew_suggest_casks_installed)'
 
 
 __fish_brew_complete_cmd 'uses' 'Show formulae and casks that specify formula as a dependency; that is, show dependents of formula'
 __fish_brew_complete_arg 'uses' -l cask -d 'Include only casks'
 __fish_brew_complete_arg 'uses' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'uses' -l eval-all -d 'Evaluate all available formulae and casks, whether installed or not, to show their dependents'
 __fish_brew_complete_arg 'uses' -l formula -d 'Include only formulae'
 __fish_brew_complete_arg 'uses' -l help -d 'Show this message'
-__fish_brew_complete_arg 'uses' -l include-build -d 'Include all formulae that specify formula as `:build` type dependency'
-__fish_brew_complete_arg 'uses' -l include-optional -d 'Include all formulae that specify formula as `:optional` type dependency'
-__fish_brew_complete_arg 'uses' -l include-test -d 'Include all formulae that specify formula as `:test` type dependency'
+__fish_brew_complete_arg 'uses' -l include-build -d 'Include formulae that specify formula as a `:build` dependency'
+__fish_brew_complete_arg 'uses' -l include-optional -d 'Include formulae that specify formula as an `:optional` dependency'
+__fish_brew_complete_arg 'uses' -l include-test -d 'Include formulae that specify formula as a `:test` dependency'
 __fish_brew_complete_arg 'uses' -l installed -d 'Only list formulae and casks that are currently installed'
+__fish_brew_complete_arg 'uses' -l missing -d 'Only list formulae and casks that are not currently installed'
 __fish_brew_complete_arg 'uses' -l quiet -d 'Make some output more quiet'
 __fish_brew_complete_arg 'uses' -l recursive -d 'Resolve more than one level of dependencies'
-__fish_brew_complete_arg 'uses' -l skip-recommended -d 'Skip all formulae that specify formula as `:recommended` type dependency'
+__fish_brew_complete_arg 'uses' -l skip-recommended -d 'Skip all formulae that specify formula as a `:recommended` dependency'
 __fish_brew_complete_arg 'uses' -l verbose -d 'Make some output more verbose'
 __fish_brew_complete_arg 'uses; and not __fish_seen_argument -l cask -l casks' -a '(__fish_brew_suggest_formulae_all)'
 
@@ -1602,11 +1816,19 @@ __fish_brew_complete_arg 'uses; and not __fish_seen_argument -l cask -l casks' -
 __fish_brew_complete_cmd 'vendor-gems' 'Install and commit Homebrew\'s vendored gems'
 __fish_brew_complete_arg 'vendor-gems' -l debug -d 'Display any debugging information'
 __fish_brew_complete_arg 'vendor-gems' -l help -d 'Show this message'
+__fish_brew_complete_arg 'vendor-gems' -l no-commit -d 'Do not generate a new commit upon completion'
 __fish_brew_complete_arg 'vendor-gems' -l quiet -d 'Make some output more quiet'
-__fish_brew_complete_arg 'vendor-gems' -l update -d 'Update all vendored Gems to the latest version'
+__fish_brew_complete_arg 'vendor-gems' -l update -d 'Update the specified list of vendored gems to the latest version'
 __fish_brew_complete_arg 'vendor-gems' -l verbose -d 'Make some output more verbose'
 
 
+__fish_brew_complete_cmd 'vendor-install' 'Install Homebrew\'s portable Ruby'
+__fish_brew_complete_arg 'vendor-install' -l debug -d 'Display any debugging information'
+__fish_brew_complete_arg 'vendor-install' -l help -d 'Show this message'
+__fish_brew_complete_arg 'vendor-install' -l quiet -d 'Make some output more quiet'
+__fish_brew_complete_arg 'vendor-install' -l verbose -d 'Make some output more verbose'
+
+
 
 ################################
 ## OFFICIAL EXTERNAL COMMANDS ##
@@ -1629,10 +1851,12 @@ __fish_brew_complete_arg 'bundle;
         and not __fish_brew_opt --file --global
     ' -l global  -d "Use \$HOME/.Brewfile"
 
+__fish_brew_complete_sub_cmd 'bundle' 'install' "Install and upgrade (by default) all dependencies from the Brewfile."
 __fish_brew_complete_sub_cmd 'bundle' 'dump'    "Write all installed casks/formulae/taps into a Brewfile"
 __fish_brew_complete_sub_cmd 'bundle' 'cleanup' "Uninstall all dependencies not listed in a Brewfile"
 __fish_brew_complete_sub_cmd 'bundle' 'check'   "Check if all dependencies are installed in a Brewfile"
 __fish_brew_complete_sub_cmd 'bundle' 'exec'    "Run an external command in an isolated build environment"
+__fish_brew_complete_sub_cmd 'bundle' 'list'    "List all dependencies present in the Brewfile."
 
 # --force is available only for the dump/cleanup subcommands
 __fish_brew_complete_sub_arg 'bundle' 'dump cleanup' -l force -d "Uninstall dependencies or overwrite an existing Brewfile"
diff --git a/completions/internal_commands_list.txt b/completions/internal_commands_list.txt
index 09af017ba68f3..a9d6f8ef1942a 100644
--- a/completions/internal_commands_list.txt
+++ b/completions/internal_commands_list.txt
@@ -26,11 +26,15 @@ command
 commands
 completions
 config
+contributions
 create
+debugger
 deps
 desc
+determine-test-runners
 developer
 dispatch-build-bottle
+docs
 doctor
 dr
 edit
@@ -39,6 +43,8 @@ extract
 fetch
 formula
 formulae
+generate-cask-api
+generate-formula-api
 generate-man-completions
 gist-logs
 help
@@ -59,15 +65,19 @@ log
 ls
 migrate
 missing
+nodenv-sync
 options
 outdated
 pin
+post_install
 postinstall
 pr-automerge
 pr-publish
 pr-pull
 pr-upload
 prof
+pyenv-sync
+rbenv-sync
 readall
 reinstall
 release
@@ -75,11 +85,13 @@ remove
 rm
 rubocop
 ruby
+rubydoc
 search
+setup-ruby
 sh
 shellenv
-sponsors
 style
+tab
 tap
 tap-info
 tap-new
@@ -99,6 +111,7 @@ update-license-data
 update-maintainers
 update-python-resources
 update-reset
+update-sponsors
 update-test
 upgrade
 uses
diff --git a/completions/zsh/_brew b/completions/zsh/_brew
index 7c33b100123c9..198eb1fff37b5 100644
--- a/completions/zsh/_brew
+++ b/completions/zsh/_brew
@@ -2,6 +2,8 @@
 #autoload
 
 # Brew ZSH completion function
+# This file is automatically generated by running `brew generate-man-completions`.
+# See Library/Homebrew/completions/zsh.erb for editing instructions.
 
 # functions starting with __brew are helper functions that complete or list
 #   various types of items.
@@ -20,6 +22,7 @@ __brew_list_aliases() {
     ln link
     instal install
     uninstal uninstall
+    post_install postinstall
     rm uninstall
     remove uninstall
     abv info
@@ -75,7 +78,7 @@ __brew_outdated_formulae() {
   [[ -prefix '-' ]] && return 0
 
   local -a formulae
-  formulae=($(brew outdated --formula))
+  formulae=($(HOMEBREW_NO_AUTO_UPDATE=1 brew outdated --formula))
   _describe -t formulae 'outdated formulae' formulae
 }
 
@@ -99,7 +102,7 @@ __brew_installed_casks() {
 
   local -a list
   local expl
-  list=( $(brew list --cask) )
+  list=( $(brew list --cask 2>/dev/null) )
   _wanted list expl 'installed casks' compadd -a list
 }
 
@@ -107,7 +110,7 @@ __brew_outdated_casks() {
   [[ -prefix '-' ]] && return 0
 
   local -a casks
-  casks=($(brew outdated --cask))
+  casks=($(HOMEBREW_NO_AUTO_UPDATE=1 brew outdated --cask 2>/dev/null))
   _describe -t casks 'outdated casks' casks
 }
 
@@ -134,13 +137,13 @@ __brew_internal_commands() {
     '--cellar:Display Homebrew'\''s Cellar path'
     '--env:Summarise Homebrew'\''s build environment as a plain list'
     '--prefix:Display Homebrew'\''s install path'
-    '--repository:Display where Homebrew'\''s git repository is located'
+    '--repository:Display where Homebrew'\''s Git repository is located'
     '--version:Print the version numbers of Homebrew, Homebrew/homebrew-core and Homebrew/homebrew-cask (if tapped) to standard output'
     'analytics:Control Homebrew'\''s anonymous aggregate user behaviour analytics'
     'audit:Check formula for Homebrew coding style violations'
     'autoremove:Uninstall formulae that were only installed as a dependency of another formula and are now no longer needed'
     'bottle:Generate a bottle (binary package) from a formula that was installed with `--build-bottle`'
-    'bump:Display out-of-date brew formulae and the latest version available'
+    'bump:Displays out-of-date packages and the latest version available'
     'bump-cask-pr:Create a pull request to update cask with a new version'
     'bump-formula-pr:Create a pull request to update formula with a new URL or a new tag'
     'bump-revision:Create a commit to increment the revision of formula'
@@ -152,25 +155,32 @@ __brew_internal_commands() {
     'commands:Show lists of built-in and external commands'
     'completions:Control whether Homebrew automatically links external tap shell completion files'
     'config:Show Homebrew and system configuration info useful for debugging'
+    'contributions:Summarise contributions to Homebrew repositories'
     'create:Generate a formula or, with `--cask`, a cask for the downloadable file at URL and open it in the editor'
+    'debugger:Run the specified Homebrew command in debug mode'
     'deps:Show dependencies for formula'
     'desc:Display formula'\''s name and one-line description'
+    'determine-test-runners:Determines the runners used to test formulae or their dependents'
     'developer:Control Homebrew'\''s developer mode'
     'dispatch-build-bottle:Build bottles for these formulae with GitHub Actions'
+    'docs:Open Homebrew'\''s online documentation at https://docs.brew.sh in a browser'
     'doctor:Check your system for potential problems'
-    'edit:Open a formula or cask in the editor set by `EDITOR` or `HOMEBREW_EDITOR`, or open the Homebrew repository for editing if no formula is provided'
+    'edit:Open a formula, cask or tap in the editor set by `EDITOR` or `HOMEBREW_EDITOR`, or open the Homebrew repository for editing if no argument is provided'
     'extract:Look through repository history to find the most recent version of formula and create a copy in tap'
     'fetch:Download a bottle (if available) or source packages for formulae and binaries for casks'
     'formula:Display the path where formula is located'
     'formulae:List all locally installable formulae including short names'
+    'generate-cask-api:Generate `homebrew/cask` API data files for https://formulae.brew.sh'
+    'generate-formula-api:Generate `homebrew/core` API data files for https://formulae.brew.sh'
     'generate-man-completions:Generate Homebrew'\''s manpages and shell completions'
     'gist-logs:Upload logs for a failed build of formula to a new Gist'
+    'help:Outputs the usage instructions for `brew` command'
     'home:Open a formula or cask'\''s homepage in a browser, or open Homebrew'\''s own homepage if no argument is provided'
     'info:Display brief statistics for your Homebrew installation'
     'install:Install a formula or cask'
     'install-bundler-gems:Install Homebrew'\''s Bundler gems'
     'irb:Enter the interactive Homebrew Ruby shell'
-    'leaves:List installed formulae that are not dependencies of another installed formula'
+    'leaves:List installed formulae that are not dependencies of another installed formula or cask'
     'link:Symlink all of formula'\''s installed files into Homebrew'\''s prefix'
     'linkage:Check the library links from the given formula kegs'
     'list:List all installed formulae and casks'
@@ -178,25 +188,30 @@ __brew_internal_commands() {
     'log:Show the `git log` for formula or cask, or show the log for the Homebrew repository if no formula or cask is provided'
     'migrate:Migrate renamed packages to new names, where formula are old names of packages'
     'missing:Check the given formula kegs for missing dependencies'
+    'nodenv-sync:Create symlinks for Homebrew'\''s installed NodeJS versions in `~/.nodenv/versions`'
     'options:Show install options specific to formula'
     'outdated:List installed casks and formulae that have an updated version available'
     'pin:Pin the specified formula, preventing them from being upgraded when issuing the `brew upgrade` formula command'
     'postinstall:Rerun the post-install steps for formula'
     'pr-automerge:Find pull requests that can be automatically merged using `brew pr-publish`'
     'pr-publish:Publish bottles for a pull request with GitHub Actions'
-    'pr-pull:Download and publish bottles, and apply the bottle commit from a pull request with artifacts generated by GitHub Actions'
+    'pr-pull:Download and publish bottles and apply the bottle commit from a pull request with artifacts generated by GitHub Actions'
     'pr-upload:Apply the bottle commit and publish bottles to a host'
     'prof:Run Homebrew with a Ruby profiler'
+    'pyenv-sync:Create symlinks for Homebrew'\''s installed Python versions in `~/.pyenv/versions`'
+    'rbenv-sync:Create symlinks for Homebrew'\''s installed Ruby versions in `~/.rbenv/versions`'
     'readall:Import all items from the specified tap, or from all installed taps if none is provided'
     'reinstall:Uninstall and then reinstall a formula or cask using the same options it was originally installed with, plus any appended options specific to a formula'
     'release:Create a new draft Homebrew/brew release with the appropriate version number and release notes'
     'rubocop:Installs, configures and runs Homebrew'\''s `rubocop`'
     'ruby:Run a Ruby instance with Homebrew'\''s libraries loaded'
+    'rubydoc:Generate Homebrew'\''s RubyDoc documentation'
     'search:Perform a substring search of cask tokens and formula names for text'
+    'setup-ruby:Installs and configures Homebrew'\''s Ruby'
     'sh:Enter an interactive shell for Homebrew'\''s build environment'
-    'shellenv:Print export statements'
-    'sponsors:Update the list of GitHub Sponsors in the `Homebrew/brew` README'
+    'shellenv:Valid shells: bash|csh|fish|pwsh|sh|tcsh|zsh  Print export statements'
     'style:Check formulae or files for conformance to Homebrew style guidelines'
+    'tab:Edit tab information for installed formulae or casks'
     'tap:Tap a formula repository'
     'tap-info:Show detailed information about one or more taps'
     'tap-new:Generate the template files for a new tap'
@@ -215,6 +230,7 @@ __brew_internal_commands() {
     'update-python-resources:Update versions for PyPI resource blocks in formula'
     'update-report:The Ruby implementation of `brew update`'
     'update-reset:Fetch and reset Homebrew and all tap repositories (or any specified repository) using `git`(1) to their latest `origin/HEAD`'
+    'update-sponsors:Update the list of GitHub Sponsors in the `Homebrew/brew` README'
     'update-test:Run a test of `brew update` with a new repository clone'
     'upgrade:Upgrade outdated casks and outdated, unpinned formulae using the same options they were originally installed with, plus any appended brew formula options'
     'uses:Show formulae and casks that specify formula as a dependency; that is, show dependents of formula'
@@ -252,11 +268,13 @@ __brew_diagnostic_checks() {
 _brew___cache() {
   _arguments \
     '(--build-from-source --force-bottle --bottle-tag --cask)--HEAD[Show the cache file used when building from HEAD]' \
-    '(--build-from-source --force-bottle --HEAD --cask)--bottle-tag[Show the cache file used when pouring a bottle for the given tag]' \
+    '(--bottle-tag)--arch[Show cache file for the given CPU architecture. (Pass `all` to show cache files for all architectures.)]' \
+    '(--build-from-source --force-bottle --HEAD --cask --os --arch)--bottle-tag[Show the cache file used when pouring a bottle for the given tag]' \
     '(--force-bottle --bottle-tag --HEAD --cask)--build-from-source[Show the cache file used when building from source]' \
     '--debug[Display any debugging information]' \
     '(--build-from-source --bottle-tag --HEAD --cask)--force-bottle[Show the cache file used when pouring a bottle]' \
     '--help[Show this message]' \
+    '(--bottle-tag)--os[Show cache file for the given operating system. (Pass `all` to show cache files for all operating systems.)]' \
     '--quiet[Make some output more quiet]' \
     '--verbose[Make some output more verbose]' \
     - formula \
@@ -346,18 +364,28 @@ _brew___repository() {
     '*::tap:__brew_any_tap'
 }
 
+# brew --version
+_brew___version() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
 # brew -S
 _brew__s() {
   _arguments \
     '(--repology --macports --fink --opensuse --fedora --debian --ubuntu)--archlinux[Search for text in the given database]' \
-    '--cask[Search online and locally for casks]' \
+    '--cask[Search for casks]' \
     '(--open)--closed[Search for only closed GitHub pull requests]' \
     '(--repology --macports --fink --opensuse --fedora --archlinux --ubuntu)--debian[Search for text in the given database]' \
     '--debug[Display any debugging information]' \
     '(--pull-request)--desc[Search for formulae with a description matching text and casks with a name or description matching text]' \
+    '--eval-all[Evaluate all available formulae and casks, whether installed or not, to search their descriptions. Implied if `HOMEBREW_EVAL_ALL` is set]' \
     '(--repology --macports --fink --opensuse --archlinux --debian --ubuntu)--fedora[Search for text in the given database]' \
     '(--repology --macports --opensuse --fedora --archlinux --debian --ubuntu)--fink[Search for text in the given database]' \
-    '--formula[Search online and locally for formulae]' \
+    '--formula[Search for formulae]' \
     '--help[Show this message]' \
     '(--repology --fink --opensuse --fedora --archlinux --debian --ubuntu)--macports[Search for text in the given database]' \
     '(--closed)--open[Search for only open GitHub pull requests]' \
@@ -369,18 +397,28 @@ _brew__s() {
     '--verbose[Make some output more verbose]'
 }
 
+# brew -v
+_brew__v() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
 # brew abv
 _brew_abv() {
   _arguments \
-    '(--installed)--all[Print JSON of all available formulae]' \
-    '(--bottle)--analytics[List global Homebrew analytics data or, if specified, installation and build error data for formula (provided neither `HOMEBREW_NO_ANALYTICS` nor `HOMEBREW_NO_GITHUB_API` are set)]' \
+    '--analytics[List global Homebrew analytics data or, if specified, installation and build error data for formula (provided neither `HOMEBREW_NO_ANALYTICS` nor `HOMEBREW_NO_GITHUB_API` are set)]' \
     '--category[Which type of analytics data to retrieve. The value for category must be `install`, `install-on-request` or `build-error`; `cask-install` or `os-version` may be specified if formula is not. The default is `install`]' \
     '--days[How many days of analytics data to retrieve. The value for days must be `30`, `90` or `365`. The default is `30`]' \
     '--debug[Display any debugging information]' \
-    '(--bottle)--github[Open the GitHub source page for formula and cask in a browser. To view the history locally: `brew log -p` formula or cask]' \
+    '(--installed)--eval-all[Evaluate all available formulae and casks, whether installed or not, to print their JSON. Implied if `HOMEBREW_EVAL_ALL` is set]' \
+    '(--cask --json)--fetch-manifest[Fetch GitHub Packages manifest for extra information when formula is not installed]' \
+    '--github[Open the GitHub source page for formula and cask in a browser. To view the history locally: `brew log -p` formula or cask]' \
     '--help[Show this message]' \
-    '(--all)--installed[Print JSON of formulae that are currently installed]' \
-    '--json[Print a JSON representation. Currently the default value for version is `v1` for formula. For formula and cask use `v2`. See the docs for examples of using the JSON output: https://docs.brew.sh/Querying-Brew]' \
+    '(--eval-all --all)--installed[Print JSON of formulae that are currently installed]' \
+    '(--fetch-manifest)--json[Print a JSON representation. Currently the default value for version is `v1` for formula. For formula and cask use `v2`. See the docs for examples of using the JSON output: https://docs.brew.sh/Querying-Brew]' \
     '--quiet[Make some output more quiet]' \
     '--variations[Include the variations hash in each formula'\''s JSON output]' \
     '--verbose[Show more verbose analytics data for formula]' \
@@ -388,7 +426,7 @@ _brew_abv() {
     '(--cask)--formula[Treat all named arguments as formulae]' \
     '*::formula:__brew_formulae' \
     - cask \
-    '(--formula --bottle)--cask[Treat all named arguments as casks]' \
+    '(--formula --fetch-manifest)--cask[Treat all named arguments as casks]' \
     '*::cask:__brew_casks'
 }
 
@@ -406,25 +444,26 @@ _brew_analytics() {
 # brew audit
 _brew_audit() {
   _arguments \
-    '--appcast[Audit the appcast]' \
+    '--arch[Audit the given CPU architecture. (Pass `all` to audit all architectures.)]' \
     '--audit-debug[Enable debugging and profiling of audit methods]' \
     '--debug[Display any debugging information]' \
-    '(--skip-style --only-cops --except-cops)--display-cop-names[Include the RuboCop cop name for each violation in the output]' \
-    '--display-failures-only[Only display casks that fail the audit. This is the default for formulae]' \
     '--display-filename[Prefix every line of output with the file or formula name being audited, to make output easy to grep]' \
+    '--eval-all[Evaluate all available formulae and casks, whether installed or not, to audit them. Implied if `HOMEBREW_EVAL_ALL` is set]' \
     '(--only)--except[Specify a comma-separated method list to skip running the methods named `audit_`method]' \
-    '(--only-cops --strict --only-cops --only --display-cop-names)--except-cops[Specify a comma-separated cops list to skip checking for violations of the listed RuboCop cops]' \
+    '(--only-cops --strict --only-cops --only)--except-cops[Specify a comma-separated cops list to skip checking for violations of the listed RuboCop cops]' \
     '--fix[Fix style violations automatically using RuboCop'\''s auto-correct feature]' \
     '--git[Run additional, slower style checks that navigate the Git repository]' \
     '--help[Show this message]' \
     '(--all)--installed[Only check formulae and casks that are currently installed]' \
-    '--new[Run various additional style checks to determine if a new formula or cask is eligible for Homebrew. This should be used when creating new formula and implies `--strict` and `--online`]' \
-    '--no-appcast[Audit the appcast]' \
+    '--new[Run various additional style checks to determine if a new formula or cask is eligible for Homebrew. This should be used when creating new formulae or casks and implies `--strict` and `--online`]' \
+    '--no-signing[Audit for signed apps, which are required on ARM]' \
     '--online[Run additional, slower style checks that require a network connection]' \
     '(--except --only-cops --except-cops)--only[Specify a comma-separated method list to only run the methods named `audit_`method]' \
-    '(--except-cops --strict --except-cops --only --display-cop-names)--only-cops[Specify a comma-separated cops list to check for violations of only the listed RuboCop cops]' \
+    '(--except-cops --strict --except-cops --only)--only-cops[Specify a comma-separated cops list to check for violations of only the listed RuboCop cops]' \
+    '--os[Audit the given operating system. (Pass `all` to audit all operating systems.)]' \
     '--quiet[Make some output more quiet]' \
-    '(--display-cop-names)--skip-style[Skip running non-RuboCop style checks. Useful if you plan on running `brew style` separately. Enabled by default unless a formula is specified by name]' \
+    '--signing[Audit for signed apps, which are required on ARM]' \
+    '--skip-style[Skip running non-RuboCop style checks. Useful if you plan on running `brew style` separately. Enabled by default unless a formula is specified by name]' \
     '(--only-cops --except-cops)--strict[Run additional, stricter style checks]' \
     '--tap[Check the formulae within the given tap, specified as user`/`repo]' \
     '--token-conflicts[Audit for token conflicts]' \
@@ -457,6 +496,7 @@ _brew_bottle() {
     '--json[Write bottle information to a JSON file, which can be used as the value for `--merge`]' \
     '(--no-rebuild)--keep-old[If the formula specifies a rebuild version, attempt to preserve its value in the generated DSL]' \
     '--merge[Generate an updated bottle block for a formula and optionally merge it into the formula file. Instead of a formula name, requires the path to a JSON file generated with `brew bottle --json` formula]' \
+    '--no-all-checks[Don'\''t try to create an `all` bottle or stop a no-change upload]' \
     '--no-commit[When passed with `--write`, a new commit will not generated after writing changes to the formula file]' \
     '(--keep-old)--no-rebuild[If the formula specifies a rebuild version, remove it from the generated DSL]' \
     '--only-json-tab[When passed with `--json`, the tab will be written to the JSON file but not the bottle]' \
@@ -476,13 +516,17 @@ _brew_bottle() {
 _brew_bump() {
   _arguments \
     '--debug[Display any debugging information]' \
+    '(--installed)--eval-all[Evaluate all formulae and casks]' \
     '--full-name[Print formulae/casks with fully-qualified names]' \
     '--help[Show this message]' \
-    '--limit[Limit number of package results returned]' \
+    '(--tap --eval-all --auto)--installed[Check formulae and casks that are currently installed]' \
+    '--no-fork[Don'\''t try to fork the repository]' \
     '(--open-pr)--no-pull-requests[Do not retrieve pull requests from GitHub]' \
-    '(--no-pull-requests)--open-pr[Open a pull request for the new version if there are none already open]' \
+    '(--no-pull-requests)--open-pr[Open a pull request for the new version if none have been opened yet]' \
     '--quiet[Make some output more quiet]' \
+    '--repology[Use Repology to check for outdated packages]' \
     '--start-with[Letter or word that the list of package results should alphabetically follow]' \
+    '(--installed)--tap[Check formulae and casks within the given tap, specified as user`/`repo]' \
     '--verbose[Make some output more verbose]' \
     - formula \
     '(--cask)--formula[Check only formulae]' \
@@ -498,20 +542,20 @@ _brew_bump_cask_pr() {
     '--commit[When passed with `--write-only`, generate a new commit after writing changes to the cask file]' \
     '--debug[Display any debugging information]' \
     '(--write)--dry-run[Print what would be done rather than doing it]' \
-    '--force[Ignore duplicate open PRs]' \
     '--fork-org[Use the specified GitHub organization for forking]' \
     '--help[Show this message]' \
-    '--message[Append message to the default pull request message]' \
+    '--message[Prepend message to the default pull request message]' \
     '(--online)--no-audit[Don'\''t run `brew audit` before opening the PR]' \
     '--no-browse[Print the pull request URL instead of opening in a browser]' \
     '--no-fork[Don'\''t try to fork the repository]' \
     '--no-style[Don'\''t run `brew style --fix` before opening the PR]' \
-    '(--no-audit)--online[Run `brew audit --online` before opening the PR]' \
     '--quiet[Make some output more quiet]' \
     '--sha256[Specify the SHA-256 checksum of the new download]' \
     '--url[Specify the URL for the new download]' \
     '--verbose[Make some output more verbose]' \
-    '--version[Specify the new version for the cask]' \
+    '(--version-arm --version-intel)--version[Specify the new version for the cask]' \
+    '(--version)--version-arm[Specify the new cask version for the ARM architecture]' \
+    '(--version)--version-intel[Specify the new cask version for the Intel architecture]' \
     '--write-only[Make the expected file modifications without taking any Git actions]' \
     - cask \
     '*::cask:__brew_casks'
@@ -522,11 +566,12 @@ _brew_bump_formula_pr() {
   _arguments \
     '--commit[When passed with `--write-only`, generate a new commit after writing changes to the formula file]' \
     '--debug[Display any debugging information]' \
-    '(--write-only --write)--dry-run[Print what would be done rather than doing it]' \
-    '--force[Ignore duplicate open PRs. Remove all mirrors if `--mirror` was not specified]' \
+    '(--write-only)--dry-run[Print what would be done rather than doing it]' \
+    '--force[Remove all mirrors if `--mirror` was not specified]' \
     '--fork-org[Use the specified GitHub organization for forking]' \
     '--help[Show this message]' \
-    '--message[Append message to the default pull request message]' \
+    '--install-dependencies[Install missing dependencies required to update resources]' \
+    '--message[Prepend message to the default pull request message]' \
     '--mirror[Use the specified URL as a mirror URL. If URL is a comma-separated list of URLs, multiple mirrors will be added]' \
     '(--strict --online)--no-audit[Don'\''t run `brew audit` before opening the PR]' \
     '--no-browse[Print the pull request URL instead of opening in a browser]' \
@@ -579,6 +624,15 @@ _brew_bump_unversioned_casks() {
     '*::tap:__brew_any_tap'
 }
 
+# brew casks
+_brew_casks() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
 # brew cat
 _brew_cat() {
   _arguments \
@@ -603,8 +657,8 @@ _brew_cleanup() {
     '--prune[Remove all cache files older than specified days. If you want to remove everything, use `--prune=all`]' \
     '--prune-prefix[Only prune the symlinks and directories from the prefix and remove no other files]' \
     '--quiet[Make some output more quiet]' \
+    '--scrub[Scrub the cache, including downloads for even the latest versions. Note that downloads for any installed formulae or casks will still not be deleted. If you want to delete those too: `rm -rf "$(brew --cache)"`]' \
     '--verbose[Make some output more verbose]' \
-    '-s[Scrub the cache, including downloads for even the latest versions. Note that downloads for any installed formulae or casks will still not be deleted. If you want to delete those too: `rm -rf "$(brew --cache)"`]' \
     - formula \
     '*::formula:__brew_formulae' \
     - cask \
@@ -652,6 +706,20 @@ _brew_config() {
     '--verbose[Make some output more verbose]'
 }
 
+# brew contributions
+_brew_contributions() {
+  _arguments \
+    '--csv[Print a CSV of contributions across repositories over the time period]' \
+    '--debug[Display any debugging information]' \
+    '--from[Date (ISO-8601 format) to start searching contributions. Omitting this flag searches the last year]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--repositories[Specify a comma-separated list of repositories to search. Supported repositories: `brew`, `core`, `cask`, `aliases`, `bundle`, `command-not-found`, `test-bot` and `services`. Omitting this flag, or specifying `--repositories=primary`, searches only the main repositories: brew,core,cask. Specifying `--repositories=all`, searches all repositories. ]' \
+    '--to[Date (ISO-8601 format) to stop searching contributions]' \
+    '--user[Specify a comma-separated list of GitHub usernames or email addresses to find contributions from. Omitting this flag searches maintainers]' \
+    '--verbose[Make some output more verbose]'
+}
+
 # brew create
 _brew_create() {
   _arguments \
@@ -679,15 +747,29 @@ _brew_create() {
     '--verbose[Make some output more verbose]'
 }
 
+# brew debugger
+_brew_debugger() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--open[Start remote debugging over a Unix socket]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]' \
+    - command \
+    '*::command:__brew_commands'
+}
+
 # brew deps
 _brew_deps() {
   _arguments \
-    '--1[Only show dependencies one level down, instead of recursing]' \
-    '(--installed)--all[List dependencies for all available formulae]' \
-    '--annotate[Mark any build, test, optional, or recommended dependencies as such in the output]' \
+    '--HEAD[Show dependencies for HEAD version instead of stable version]' \
+    '--annotate[Mark any build, test, implicit, optional, or recommended dependencies as such in the output]' \
+    '--arch[Show dependencies for the given CPU architecture]' \
     '--debug[Display any debugging information]' \
+    '--direct[Show only the direct dependencies declared in the formula]' \
     '--dot[Show text-based graph description in DOT format]' \
-    '--for-each[Switch into the mode used by the `--all` option, but only list dependencies for each provided formula, one formula per line. This is used for debugging the `--installed`/`--all` display mode]' \
+    '(--installed)--eval-all[Evaluate all available formulae and casks, whether installed or not, to list their dependencies]' \
+    '--for-each[Switch into the mode used by the `--eval-all` option, but only list dependencies for each provided formula, one formula per line. This is used for debugging the `--installed`/`--eval-all` display mode]' \
     '--full-name[List dependencies by their full name]' \
     '(--tree)--graph[Show dependencies as a directed graph]' \
     '--help[Show this message]' \
@@ -695,13 +777,15 @@ _brew_deps() {
     '--include-optional[Include `:optional` dependencies for formula]' \
     '--include-requirements[Include requirements in addition to dependencies for formula]' \
     '--include-test[Include `:test` dependencies for formula (non-recursive)]' \
-    '(--all)--installed[List dependencies for formulae that are currently installed. If formula is specified, list only its dependencies that are currently installed]' \
+    '(--missing --eval-all)--installed[List dependencies for formulae that are currently installed. If formula is specified, list only its dependencies that are currently installed]' \
+    '(--installed)--missing[Show only missing dependencies]' \
+    '--os[Show dependencies for the given operating system]' \
     '--quiet[Make some output more quiet]' \
     '--skip-recommended[Skip `:recommended` dependencies for formula]' \
+    '--topological[Sort dependencies in topological order]' \
     '(--graph)--tree[Show dependencies as a tree. When given multiple formula arguments, show individual trees for each formula]' \
     '--union[Show the union of dependencies for multiple formula, instead of the intersection]' \
     '--verbose[Make some output more verbose]' \
-    '-n[Sort dependencies in topological order]' \
     - formula \
     '(--cask)--formula[Treat all named arguments as formulae]' \
     '*::formula:__brew_formulae' \
@@ -715,6 +799,7 @@ _brew_desc() {
   _arguments \
     '--debug[Display any debugging information]' \
     '(--search --name)--description[Search just descriptions for text. If text is flanked by slashes, it is interpreted as a regular expression]' \
+    '--eval-all[Evaluate all available formulae and casks, whether installed or not, to search their descriptions. Implied if `HOMEBREW_EVAL_ALL` is set]' \
     '--help[Show this message]' \
     '(--search --description)--name[Search just names for text. If text is flanked by slashes, it is interpreted as a regular expression]' \
     '--quiet[Make some output more quiet]' \
@@ -728,6 +813,18 @@ _brew_desc() {
     '*::cask:__brew_casks'
 }
 
+# brew determine-test-runners
+_brew_determine_test_runners() {
+  _arguments \
+    '(--dependents)--all-supported[Instead of selecting runners based on the chosen formula, return all supported runners]' \
+    '--debug[Display any debugging information]' \
+    '(--all-supported)--dependents[Determine runners for testing dependents. Requires `--eval-all` or `HOMEBREW_EVAL_ALL`]' \
+    '--eval-all[Evaluate all available formulae, whether installed or not, to determine testing dependents]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
 # brew developer
 _brew_developer() {
   _arguments \
@@ -748,7 +845,7 @@ _brew_dispatch_build_bottle() {
     '(--linux-self-hosted)--linux[Dispatch bottle for Linux (using GitHub runners)]' \
     '(--linux)--linux-self-hosted[Dispatch bottle for Linux (using self-hosted runner)]' \
     '--linux-wheezy[Use Debian Wheezy container for building the bottle on Linux]' \
-    '--macos[Version(s) of macOS the bottle should be built for]' \
+    '--macos[macOS version (or comma-separated list of versions) the bottle should be built for]' \
     '--quiet[Make some output more quiet]' \
     '--tap[Target tap repository (default: `homebrew/core`)]' \
     '--timeout[Build timeout (in minutes, default: 60)]' \
@@ -759,6 +856,15 @@ _brew_dispatch_build_bottle() {
     '*::formula:__brew_formulae'
 }
 
+# brew docs
+_brew_docs() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
 # brew doctor
 _brew_doctor() {
   _arguments \
@@ -798,7 +904,9 @@ _brew_edit() {
     '*::formula:__brew_formulae' \
     - cask \
     '(--formula)--cask[Treat all named arguments as casks]' \
-    '*::cask:__brew_casks'
+    '*::cask:__brew_casks' \
+    - tap \
+    '*::tap:__brew_any_tap'
 }
 
 # brew environment
@@ -819,6 +927,7 @@ _brew_extract() {
   _arguments \
     '--debug[Display any debugging information]' \
     '--force[Overwrite the destination formula if it already exists]' \
+    '--git-revision[Search for the specified version of formula starting at revision instead of HEAD]' \
     '--help[Show this message]' \
     '--quiet[Make some output more quiet]' \
     '--verbose[Make some output more verbose]' \
@@ -833,7 +942,8 @@ _brew_extract() {
 _brew_fetch() {
   _arguments \
     '(--cask)--HEAD[Fetch HEAD version instead of stable version]' \
-    '(--build-from-source --build-bottle --force-bottle --cask)--bottle-tag[Download a bottle for given tag]' \
+    '(--bottle-tag)--arch[Download for the given CPU architecture. (Pass `all` to download for all architectures.)]' \
+    '(--build-from-source --build-bottle --force-bottle --cask --os --arch)--bottle-tag[Download a bottle for given tag]' \
     '(--build-from-source --force-bottle --bottle-tag --cask)--build-bottle[Download source packages (for eventual bottling) rather than a bottle]' \
     '(--build-bottle --force-bottle --bottle-tag)--build-from-source[Download source packages rather than a bottle]' \
     '--debug[Display any debugging information]' \
@@ -842,15 +952,16 @@ _brew_fetch() {
     '(--build-from-source --build-bottle --bottle-tag --cask)--force-bottle[Download a bottle if it exists for the current or newest version of macOS, even if it would not be used during installation]' \
     '--help[Show this message]' \
     '--no-quarantine[Disable/enable quarantining of downloads (default: enabled)]' \
+    '(--bottle-tag)--os[Download for the given operating system. (Pass `all` to download for all operating systems.)]' \
     '--quarantine[Disable/enable quarantining of downloads (default: enabled)]' \
     '--quiet[Make some output more quiet]' \
-    '--retry[Retry if downloading fails or re-download if the checksum of a previously cached version no longer matches]' \
+    '--retry[Retry if downloading fails or re-download if the checksum of a previously cached version no longer matches. Tries at most 5 times with exponential backoff]' \
     '--verbose[Do a verbose VCS checkout, if the URL represents a VCS. This is useful for seeing if an existing VCS cache has been updated]' \
     - formula \
     '(--cask)--formula[Treat all named arguments as formulae]' \
     '*::formula:__brew_formulae' \
     - cask \
-    '(--HEAD --deps --s --build-bottle --force-bottle --bottle-tag --formula)--cask[Treat all named arguments as casks]' \
+    '(--HEAD --deps -s --build-bottle --force-bottle --bottle-tag --formula)--cask[Treat all named arguments as casks]' \
     '*::cask:__brew_casks'
 }
 
@@ -865,11 +976,39 @@ _brew_formula() {
     '*::formula:__brew_formulae'
 }
 
+# brew formulae
+_brew_formulae() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
+# brew generate-cask-api
+_brew_generate_cask_api() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--dry-run[Generate API data without writing it to files]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
+# brew generate-formula-api
+_brew_generate_formula_api() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--dry-run[Generate API data without writing it to files]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
 # brew generate-man-completions
 _brew_generate_man_completions() {
   _arguments \
     '--debug[Display any debugging information]' \
-    '--fail-if-not-changed[Return a failing status code if no changes are detected in the manpage outputs. This can be used to notify CI when the manpages are out of date. Additionally, the date used in new manpages will match those in the existing manpages (to allow comparison without factoring in the date)]' \
     '--help[Show this message]' \
     '--quiet[Make some output more quiet]' \
     '--verbose[Make some output more verbose]'
@@ -922,15 +1061,16 @@ _brew_homepage() {
 # brew info
 _brew_info() {
   _arguments \
-    '(--installed)--all[Print JSON of all available formulae]' \
-    '(--bottle)--analytics[List global Homebrew analytics data or, if specified, installation and build error data for formula (provided neither `HOMEBREW_NO_ANALYTICS` nor `HOMEBREW_NO_GITHUB_API` are set)]' \
+    '--analytics[List global Homebrew analytics data or, if specified, installation and build error data for formula (provided neither `HOMEBREW_NO_ANALYTICS` nor `HOMEBREW_NO_GITHUB_API` are set)]' \
     '--category[Which type of analytics data to retrieve. The value for category must be `install`, `install-on-request` or `build-error`; `cask-install` or `os-version` may be specified if formula is not. The default is `install`]' \
     '--days[How many days of analytics data to retrieve. The value for days must be `30`, `90` or `365`. The default is `30`]' \
     '--debug[Display any debugging information]' \
-    '(--bottle)--github[Open the GitHub source page for formula and cask in a browser. To view the history locally: `brew log -p` formula or cask]' \
+    '(--installed)--eval-all[Evaluate all available formulae and casks, whether installed or not, to print their JSON. Implied if `HOMEBREW_EVAL_ALL` is set]' \
+    '(--cask --json)--fetch-manifest[Fetch GitHub Packages manifest for extra information when formula is not installed]' \
+    '--github[Open the GitHub source page for formula and cask in a browser. To view the history locally: `brew log -p` formula or cask]' \
     '--help[Show this message]' \
-    '(--all)--installed[Print JSON of formulae that are currently installed]' \
-    '--json[Print a JSON representation. Currently the default value for version is `v1` for formula. For formula and cask use `v2`. See the docs for examples of using the JSON output: https://docs.brew.sh/Querying-Brew]' \
+    '(--eval-all --all)--installed[Print JSON of formulae that are currently installed]' \
+    '(--fetch-manifest)--json[Print a JSON representation. Currently the default value for version is `v1` for formula. For formula and cask use `v2`. See the docs for examples of using the JSON output: https://docs.brew.sh/Querying-Brew]' \
     '--quiet[Make some output more quiet]' \
     '--variations[Include the variations hash in each formula'\''s JSON output]' \
     '--verbose[Show more verbose analytics data for formula]' \
@@ -938,7 +1078,7 @@ _brew_info() {
     '(--cask)--formula[Treat all named arguments as formulae]' \
     '*::formula:__brew_formulae' \
     - cask \
-    '(--formula --bottle)--cask[Treat all named arguments as casks]' \
+    '(--formula --fetch-manifest)--cask[Treat all named arguments as casks]' \
     '*::cask:__brew_casks'
 }
 
@@ -946,29 +1086,33 @@ _brew_info() {
 _brew_instal() {
   _arguments \
     '(--cask)--HEAD[If formula defines it, install the HEAD version, aka. main, trunk, unstable, master]' \
+    '(--formula --force)--adopt[Adopt existing artifacts in the destination that are identical to those being installed. Cannot be combined with `--force`]' \
     '(--formula)--appdir[Target location for Applications (default: `/Applications`)]' \
     '(--formula)--audio-unit-plugindir[Target location for Audio Unit Plugins (default: `~/Library/Audio/Plug-Ins/Components`)]' \
     '(--formula)--binaries[Disable/enable linking of helper executables (default: enabled)]' \
     '(--cask)--bottle-arch[Optimise bottles for the specified architecture rather than the oldest architecture supported by the version of macOS the bottles are built on]' \
     '(--cask --build-from-source --force-bottle)--build-bottle[Prepare the formula for eventual bottling during installation, skipping any post-install steps]' \
     '(--cask --build-bottle --force-bottle)--build-from-source[Compile formula from source even if a bottle is provided. Dependencies will still be installed from bottles if they are available]' \
-    '(--cask)--cc[Attempt to compile using the specified compiler, which should be the name of the compiler'\''s executable, e.g. `gcc-7` for GCC 7. In order to use LLVM'\''s clang, specify `llvm_clang`. To use the Apple-provided clang, specify `clang`. This option will only accept compilers that are provided by Homebrew or bundled with macOS. Please do not file issues if you encounter errors while using this option]' \
+    '(--cask)--cc[Attempt to compile using the specified compiler, which should be the name of the compiler'\''s executable, e.g. `gcc-9` for GCC 9. In order to use LLVM'\''s clang, specify `llvm_clang`. To use the Apple-provided clang, specify `clang`. This option will only accept compilers that are provided by Homebrew or bundled with macOS. Please do not file issues if you encounter errors while using this option]' \
     '(--formula)--colorpickerdir[Target location for Color Pickers (default: `~/Library/ColorPickers`)]' \
     '--debug[If brewing fails, open an interactive debugging session with access to IRB or a shell inside the temporary build directory]' \
+    '(--cask)--debug-symbols[Generate debug symbols on build. Source will be retained in a cache directory]' \
     '(--formula)--dictionarydir[Target location for Dictionaries (default: `~/Library/Dictionaries`)]' \
-    '(--cask)--display-times[Print install times for each package at the end of the run]' \
+    '--display-times[Print install times for each package at the end of the run]' \
+    '--dry-run[Show what would be installed, but do not actually install anything]' \
     '(--cask)--fetch-HEAD[Fetch the upstream repository to detect if the HEAD installation of the formula is outdated. Otherwise, the repository'\''s HEAD will only be checked for updates when a new stable or development version has been released]' \
     '(--formula)--fontdir[Target location for Fonts (default: `~/Library/Fonts`)]' \
-    '--force[Install formulae without checking for previously installed keg-only or non-migrated versions. When installing casks, overwrite existing files (binaries and symlinks are excluded, unless originally from the same cask)]' \
+    '(--adopt)--force[Install formulae without checking for previously installed keg-only or non-migrated versions. When installing casks, overwrite existing files (binaries and symlinks are excluded, unless originally from the same cask)]' \
     '(--cask --build-from-source --build-bottle)--force-bottle[Install from a bottle if it exists for the current or newest version of macOS, even if it would not normally be used for installation]' \
     '(--cask)--git[Create a Git repository, useful for creating patches to the software]' \
     '--help[Show this message]' \
-    '(--cask --only-dependencies)--ignore-dependencies[An unsupported Homebrew development flag to skip installing any dependencies of any kind. If the dependencies are not already present, the formula will have issues. If you'\''re not developing Homebrew, consider adjusting your PATH rather than using this flag]' \
+    '(--cask --only-dependencies)--ignore-dependencies[An unsupported Homebrew development option to skip installing any dependencies of any kind. If the dependencies are not already present, the formula will have issues. If you'\''re not developing Homebrew, consider adjusting your PATH rather than using this option]' \
     '(--cask)--include-test[Install testing dependencies required to run `brew test` formula]' \
     '(--formula)--input-methoddir[Target location for Input Methods (default: `~/Library/Input Methods`)]' \
     '(--cask)--interactive[Download and patch formula, then open a shell. This allows the user to run `./configure --help` and otherwise determine how to turn the software package into a Homebrew package]' \
     '(--formula)--internet-plugindir[Target location for Internet Plugins (default: `~/Library/Internet Plug-Ins`)]' \
     '(--cask)--keep-tmp[Retain the temporary files created during installation]' \
+    '(--formula)--keyboard-layoutdir[Target location for Keyboard Layouts (default: `/Library/Keyboard Layouts`)]' \
     '(--formula)--language[Comma-separated list of language codes to prefer for cask installation. The first matching language is used, otherwise it reverts to the cask'\''s default language. The default value is the language of your system]' \
     '(--formula)--mdimporterdir[Target location for Spotlight Plugins (default: `~/Library/Spotlight`)]' \
     '--no-binaries[Disable/enable linking of helper executables (default: enabled)]' \
@@ -976,22 +1120,23 @@ _brew_instal() {
     '(--cask --ignore-dependencies)--only-dependencies[Install the dependencies with specified options but do not install the formula itself]' \
     '(--cask)--overwrite[Delete files that already exist in the prefix while linking]' \
     '(--formula)--prefpanedir[Target location for Preference Panes (default: `~/Library/PreferencePanes`)]' \
-    '(--formula)--qlplugindir[Target location for QuickLook Plugins (default: `~/Library/QuickLook`)]' \
+    '(--formula)--qlplugindir[Target location for Quick Look Plugins (default: `~/Library/QuickLook`)]' \
     '(--formula)--quarantine[Disable/enable quarantining of downloads (default: enabled)]' \
     '--quiet[Make some output more quiet]' \
     '(--formula)--require-sha[Require all casks to have a checksum]' \
     '(--formula)--screen-saverdir[Target location for Screen Savers (default: `~/Library/Screen Savers`)]' \
     '(--formula)--servicedir[Target location for Services (default: `~/Library/Services`)]' \
     '(--formula)--skip-cask-deps[Skip installing cask dependencies]' \
-    '--verbose[Print the verification and postinstall steps]' \
+    '(--cask)--skip-post-install[Install but skip any post-install steps]' \
+    '--verbose[Print the verification and post-install steps]' \
     '(--formula)--vst-plugindir[Target location for VST Plugins (default: `~/Library/Audio/Plug-Ins/VST`)]' \
     '(--formula)--vst3-plugindir[Target location for VST3 Plugins (default: `~/Library/Audio/Plug-Ins/VST3`)]' \
     '(--formula)--zap[For use with `brew reinstall --cask`. Remove all files associated with a cask. *May remove files which are shared between applications.*]' \
     - formula \
-    '(--casks --binaries --require-sha --quarantine --skip-cask-deps --zap --appdir --colorpickerdir --prefpanedir --qlplugindir --mdimporterdir --dictionarydir --fontdir --servicedir --input-methoddir --internet-plugindir --audio-unit-plugindir --vst-plugindir --vst3-plugindir --screen-saverdir --language)--formula[Treat all named arguments as formulae]' \
+    '(--casks --binaries --require-sha --quarantine --adopt --skip-cask-deps --zap --appdir --keyboard-layoutdir --colorpickerdir --prefpanedir --qlplugindir --mdimporterdir --dictionarydir --fontdir --servicedir --input-methoddir --internet-plugindir --audio-unit-plugindir --vst-plugindir --vst3-plugindir --screen-saverdir --language)--formula[Treat all named arguments as formulae]' \
     '*::formula:__brew_formulae' \
     - cask \
-    '(--formulae --env --ignore-dependencies --only-dependencies --cc --build-from-source --force-bottle --include-test --HEAD --fetch-HEAD --keep-tmp --build-bottle --bottle-arch --display-times --interactive --git --overwrite)--cask[Treat all named arguments as casks]' \
+    '(--formulae --env --ignore-dependencies --only-dependencies --cc --build-from-source --force-bottle --include-test --HEAD --fetch-HEAD --keep-tmp --debug-symbols --build-bottle --skip-post-install --bottle-arch --interactive --git --overwrite)--cask[Treat all named arguments as casks]' \
     '*::cask:__brew_casks'
 }
 
@@ -999,29 +1144,33 @@ _brew_instal() {
 _brew_install() {
   _arguments \
     '(--cask)--HEAD[If formula defines it, install the HEAD version, aka. main, trunk, unstable, master]' \
+    '(--formula --force)--adopt[Adopt existing artifacts in the destination that are identical to those being installed. Cannot be combined with `--force`]' \
     '(--formula)--appdir[Target location for Applications (default: `/Applications`)]' \
     '(--formula)--audio-unit-plugindir[Target location for Audio Unit Plugins (default: `~/Library/Audio/Plug-Ins/Components`)]' \
     '(--formula)--binaries[Disable/enable linking of helper executables (default: enabled)]' \
     '(--cask)--bottle-arch[Optimise bottles for the specified architecture rather than the oldest architecture supported by the version of macOS the bottles are built on]' \
     '(--cask --build-from-source --force-bottle)--build-bottle[Prepare the formula for eventual bottling during installation, skipping any post-install steps]' \
     '(--cask --build-bottle --force-bottle)--build-from-source[Compile formula from source even if a bottle is provided. Dependencies will still be installed from bottles if they are available]' \
-    '(--cask)--cc[Attempt to compile using the specified compiler, which should be the name of the compiler'\''s executable, e.g. `gcc-7` for GCC 7. In order to use LLVM'\''s clang, specify `llvm_clang`. To use the Apple-provided clang, specify `clang`. This option will only accept compilers that are provided by Homebrew or bundled with macOS. Please do not file issues if you encounter errors while using this option]' \
+    '(--cask)--cc[Attempt to compile using the specified compiler, which should be the name of the compiler'\''s executable, e.g. `gcc-9` for GCC 9. In order to use LLVM'\''s clang, specify `llvm_clang`. To use the Apple-provided clang, specify `clang`. This option will only accept compilers that are provided by Homebrew or bundled with macOS. Please do not file issues if you encounter errors while using this option]' \
     '(--formula)--colorpickerdir[Target location for Color Pickers (default: `~/Library/ColorPickers`)]' \
     '--debug[If brewing fails, open an interactive debugging session with access to IRB or a shell inside the temporary build directory]' \
+    '(--cask)--debug-symbols[Generate debug symbols on build. Source will be retained in a cache directory]' \
     '(--formula)--dictionarydir[Target location for Dictionaries (default: `~/Library/Dictionaries`)]' \
-    '(--cask)--display-times[Print install times for each package at the end of the run]' \
+    '--display-times[Print install times for each package at the end of the run]' \
+    '--dry-run[Show what would be installed, but do not actually install anything]' \
     '(--cask)--fetch-HEAD[Fetch the upstream repository to detect if the HEAD installation of the formula is outdated. Otherwise, the repository'\''s HEAD will only be checked for updates when a new stable or development version has been released]' \
     '(--formula)--fontdir[Target location for Fonts (default: `~/Library/Fonts`)]' \
-    '--force[Install formulae without checking for previously installed keg-only or non-migrated versions. When installing casks, overwrite existing files (binaries and symlinks are excluded, unless originally from the same cask)]' \
+    '(--adopt)--force[Install formulae without checking for previously installed keg-only or non-migrated versions. When installing casks, overwrite existing files (binaries and symlinks are excluded, unless originally from the same cask)]' \
     '(--cask --build-from-source --build-bottle)--force-bottle[Install from a bottle if it exists for the current or newest version of macOS, even if it would not normally be used for installation]' \
     '(--cask)--git[Create a Git repository, useful for creating patches to the software]' \
     '--help[Show this message]' \
-    '(--cask --only-dependencies)--ignore-dependencies[An unsupported Homebrew development flag to skip installing any dependencies of any kind. If the dependencies are not already present, the formula will have issues. If you'\''re not developing Homebrew, consider adjusting your PATH rather than using this flag]' \
+    '(--cask --only-dependencies)--ignore-dependencies[An unsupported Homebrew development option to skip installing any dependencies of any kind. If the dependencies are not already present, the formula will have issues. If you'\''re not developing Homebrew, consider adjusting your PATH rather than using this option]' \
     '(--cask)--include-test[Install testing dependencies required to run `brew test` formula]' \
     '(--formula)--input-methoddir[Target location for Input Methods (default: `~/Library/Input Methods`)]' \
     '(--cask)--interactive[Download and patch formula, then open a shell. This allows the user to run `./configure --help` and otherwise determine how to turn the software package into a Homebrew package]' \
     '(--formula)--internet-plugindir[Target location for Internet Plugins (default: `~/Library/Internet Plug-Ins`)]' \
     '(--cask)--keep-tmp[Retain the temporary files created during installation]' \
+    '(--formula)--keyboard-layoutdir[Target location for Keyboard Layouts (default: `/Library/Keyboard Layouts`)]' \
     '(--formula)--language[Comma-separated list of language codes to prefer for cask installation. The first matching language is used, otherwise it reverts to the cask'\''s default language. The default value is the language of your system]' \
     '(--formula)--mdimporterdir[Target location for Spotlight Plugins (default: `~/Library/Spotlight`)]' \
     '--no-binaries[Disable/enable linking of helper executables (default: enabled)]' \
@@ -1029,30 +1178,32 @@ _brew_install() {
     '(--cask --ignore-dependencies)--only-dependencies[Install the dependencies with specified options but do not install the formula itself]' \
     '(--cask)--overwrite[Delete files that already exist in the prefix while linking]' \
     '(--formula)--prefpanedir[Target location for Preference Panes (default: `~/Library/PreferencePanes`)]' \
-    '(--formula)--qlplugindir[Target location for QuickLook Plugins (default: `~/Library/QuickLook`)]' \
+    '(--formula)--qlplugindir[Target location for Quick Look Plugins (default: `~/Library/QuickLook`)]' \
     '(--formula)--quarantine[Disable/enable quarantining of downloads (default: enabled)]' \
     '--quiet[Make some output more quiet]' \
     '(--formula)--require-sha[Require all casks to have a checksum]' \
     '(--formula)--screen-saverdir[Target location for Screen Savers (default: `~/Library/Screen Savers`)]' \
     '(--formula)--servicedir[Target location for Services (default: `~/Library/Services`)]' \
     '(--formula)--skip-cask-deps[Skip installing cask dependencies]' \
-    '--verbose[Print the verification and postinstall steps]' \
+    '(--cask)--skip-post-install[Install but skip any post-install steps]' \
+    '--verbose[Print the verification and post-install steps]' \
     '(--formula)--vst-plugindir[Target location for VST Plugins (default: `~/Library/Audio/Plug-Ins/VST`)]' \
     '(--formula)--vst3-plugindir[Target location for VST3 Plugins (default: `~/Library/Audio/Plug-Ins/VST3`)]' \
     '(--formula)--zap[For use with `brew reinstall --cask`. Remove all files associated with a cask. *May remove files which are shared between applications.*]' \
     - formula \
-    '(--casks --binaries --require-sha --quarantine --skip-cask-deps --zap --appdir --colorpickerdir --prefpanedir --qlplugindir --mdimporterdir --dictionarydir --fontdir --servicedir --input-methoddir --internet-plugindir --audio-unit-plugindir --vst-plugindir --vst3-plugindir --screen-saverdir --language)--formula[Treat all named arguments as formulae]' \
+    '(--casks --binaries --require-sha --quarantine --adopt --skip-cask-deps --zap --appdir --keyboard-layoutdir --colorpickerdir --prefpanedir --qlplugindir --mdimporterdir --dictionarydir --fontdir --servicedir --input-methoddir --internet-plugindir --audio-unit-plugindir --vst-plugindir --vst3-plugindir --screen-saverdir --language)--formula[Treat all named arguments as formulae]' \
     '*::formula:__brew_formulae' \
     - cask \
-    '(--formulae --env --ignore-dependencies --only-dependencies --cc --build-from-source --force-bottle --include-test --HEAD --fetch-HEAD --keep-tmp --build-bottle --bottle-arch --display-times --interactive --git --overwrite)--cask[Treat all named arguments as casks]' \
+    '(--formulae --env --ignore-dependencies --only-dependencies --cc --build-from-source --force-bottle --include-test --HEAD --fetch-HEAD --keep-tmp --debug-symbols --build-bottle --skip-post-install --bottle-arch --interactive --git --overwrite)--cask[Treat all named arguments as casks]' \
     '*::cask:__brew_casks'
 }
 
 # brew install-bundler-gems
 _brew_install_bundler_gems() {
   _arguments \
+    '(--groups)--add-groups[Installs the specified comma-separated list of gem groups, in addition to those already installed]' \
     '--debug[Display any debugging information]' \
-    '--groups[Installs the specified comma-separated list of gem groups (default: last used)]' \
+    '(--add-groups)--groups[Installs the specified comma-separated list of gem groups (default: last used). Replaces any previously installed groups]' \
     '--help[Show this message]' \
     '--quiet[Make some output more quiet]' \
     '--verbose[Make some output more verbose]'
@@ -1072,18 +1223,20 @@ _brew_irb() {
 # brew lc
 _brew_lc() {
   _arguments \
-    '(--tap --installed)--all[Check all available formulae/casks]' \
     '(--json)--debug[Display any debugging information]' \
-    '--full-name[Print formulae/casks with fully-qualified names]' \
+    '(--tap --installed)--eval-all[Evaluate all available formulae and casks, whether installed or not, to check them]' \
+    '(--formula)--extract-plist[Enable checking multiple casks with ExtractPlist strategy]' \
+    '--full-name[Print formulae and casks with fully-qualified names]' \
     '--help[Show this message]' \
-    '(--tap --all)--installed[Check formulae/casks that are currently installed]' \
+    '(--tap --eval-all)--installed[Check formulae and casks that are currently installed]' \
     '(--debug)--json[Output information in JSON format]' \
     '--newer-only[Show the latest version only if it'\''s newer than the formula/cask]' \
     '--quiet[Suppress warnings, don'\''t print a progress bar for JSON output]' \
-    '(--all --installed)--tap[Check formulae/casks within the given tap, specified as user`/`repo]' \
+    '--resources[Also check resources for formulae]' \
+    '(--eval-all --installed)--tap[Check formulae and casks within the given tap, specified as user`/`repo]' \
     '--verbose[Make some output more verbose]' \
     - formula \
-    '(--cask)--formula[Only check formulae]' \
+    '(--cask --extract-plist)--formula[Only check formulae]' \
     '*::formula:__brew_formulae' \
     - cask \
     '(--formula)--cask[Only check casks]' \
@@ -1134,41 +1287,47 @@ _brew_linkage() {
 # brew list
 _brew_list() {
   _arguments \
+    '(--cask --versions --pinned -l --full-name)--built-from-source[List the formulae compiled from source]' \
     '--debug[Display any debugging information]' \
-    '(--versions --pinned --l --r --t)--full-name[Print formulae with fully-qualified names. Unless `--full-name`, `--versions` or `--pinned` are passed, other options (i.e. `-1`, `-l`, `-r` and `-t`) are passed to `ls`(1) which produces the actual output]' \
+    '(--versions --pinned --installed-on-request --installed-as-dependency --poured-from-bottle --built-from-source -l -r -t)--full-name[Print formulae with fully-qualified names. Unless `--full-name`, `--versions` or `--pinned` are passed, other options (i.e. `-1`, `-l`, `-r` and `-t`) are passed to `ls`(1) which produces the actual output]' \
     '--help[Show this message]' \
+    '(--cask --versions --pinned -l --full-name)--installed-as-dependency[List the formulae installed as dependencies]' \
+    '(--cask --versions --pinned -l --full-name)--installed-on-request[List the formulae installed on request]' \
     '(--cask --pinned)--multiple[Only show formulae with multiple versions installed]' \
-    '(--cask --multiple --1 --l --r --t --full-name)--pinned[List only pinned formulae, or only the specified (pinned) formulae if formula are provided. See also `pin`, `unpin`]' \
+    '(--cask --multiple --installed-on-request --installed-as-dependency --poured-from-bottle --built-from-source -1 -l -r -t --full-name)--pinned[List only pinned formulae, or only the specified (pinned) formulae if formula are provided. See also `pin`, `unpin`]' \
+    '(--cask --versions --pinned -l --full-name)--poured-from-bottle[List the formulae installed from a bottle]' \
     '--quiet[Make some output more quiet]' \
     '--verbose[Make some output more verbose]' \
-    '(--1 --l --r --t --full-name)--versions[Show the version number for installed formulae, or only the specified formulae if formula are provided]' \
-    '-1[Force output to be one entry per line. This is the default when output is not to a terminal]' \
-    '-l[List formulae and/or casks in long format. Has no effect when a formula or cask name is passed as an argument]' \
-    '-r[Reverse the order of the formulae and/or casks sort to list the oldest entries first. Has no effect when a formula or cask name is passed as an argument]' \
-    '-t[Sort formulae and/or casks by time modified, listing most recently modified first. Has no effect when a formula or cask name is passed as an argument]' \
+    '(--installed-on-request --installed-as-dependency --poured-from-bottle --built-from-source -1 -l -r -t --full-name)--versions[Show the version number for installed formulae, or only the specified formulae if formula are provided]' \
+    '(--versions --pinned)-1[Force output to be one entry per line. This is the default when output is not to a terminal]' \
+    '(--installed-on-request --installed-as-dependency --poured-from-bottle --built-from-source --versions --pinned --full-name)-l[List formulae and/or casks in long format. Has no effect when a formula or cask name is passed as an argument]' \
+    '(--versions --pinned --full-name)-r[Reverse the order of the formulae and/or casks sort to list the oldest entries first. Has no effect when a formula or cask name is passed as an argument]' \
+    '(--versions --pinned --full-name)-t[Sort formulae and/or casks by time modified, listing most recently modified first. Has no effect when a formula or cask name is passed as an argument]' \
     - installed_formula \
     '(--cask)--formula[List only formulae, or treat all named arguments as formulae]' \
     '*::installed_formula:__brew_installed_formulae' \
     - installed_cask \
-    '(--formula --pinned --multiple)--cask[List only casks, or treat all named arguments as casks]' \
+    '(--formula --pinned --multiple --installed-on-request --installed-as-dependency --poured-from-bottle --built-from-source)--cask[List only casks, or treat all named arguments as casks]' \
     '*::installed_cask:__brew_installed_casks'
 }
 
 # brew livecheck
 _brew_livecheck() {
   _arguments \
-    '(--tap --installed)--all[Check all available formulae/casks]' \
     '(--json)--debug[Display any debugging information]' \
-    '--full-name[Print formulae/casks with fully-qualified names]' \
+    '(--tap --installed)--eval-all[Evaluate all available formulae and casks, whether installed or not, to check them]' \
+    '(--formula)--extract-plist[Enable checking multiple casks with ExtractPlist strategy]' \
+    '--full-name[Print formulae and casks with fully-qualified names]' \
     '--help[Show this message]' \
-    '(--tap --all)--installed[Check formulae/casks that are currently installed]' \
+    '(--tap --eval-all)--installed[Check formulae and casks that are currently installed]' \
     '(--debug)--json[Output information in JSON format]' \
     '--newer-only[Show the latest version only if it'\''s newer than the formula/cask]' \
     '--quiet[Suppress warnings, don'\''t print a progress bar for JSON output]' \
-    '(--all --installed)--tap[Check formulae/casks within the given tap, specified as user`/`repo]' \
+    '--resources[Also check resources for formulae]' \
+    '(--eval-all --installed)--tap[Check formulae and casks within the given tap, specified as user`/`repo]' \
     '--verbose[Make some output more verbose]' \
     - formula \
-    '(--cask)--formula[Only check formulae]' \
+    '(--cask --extract-plist)--formula[Only check formulae]' \
     '*::formula:__brew_formulae' \
     - cask \
     '(--formula)--cask[Only check casks]' \
@@ -1195,13 +1354,13 @@ _brew_log() {
   _arguments \
     '--debug[Display any debugging information]' \
     '--help[Show this message]' \
-    '(--1)--max-count[Print only a specified number of commits]' \
+    '(-1)--max-count[Print only a specified number of commits]' \
     '--oneline[Print only one line per commit]' \
     '--patch[Also print patch from commit]' \
     '--quiet[Make some output more quiet]' \
     '--stat[Also print diffstat from commit]' \
     '--verbose[Make some output more verbose]' \
-    '-1[Print only one commit]' \
+    '(--max-count)-1[Print only one commit]' \
     - formula \
     '(--cask)--formula[Treat all named arguments as formulae]' \
     '*::formula:__brew_formulae' \
@@ -1213,23 +1372,27 @@ _brew_log() {
 # brew ls
 _brew_ls() {
   _arguments \
+    '(--cask --versions --pinned -l --full-name)--built-from-source[List the formulae compiled from source]' \
     '--debug[Display any debugging information]' \
-    '(--versions --pinned --l --r --t)--full-name[Print formulae with fully-qualified names. Unless `--full-name`, `--versions` or `--pinned` are passed, other options (i.e. `-1`, `-l`, `-r` and `-t`) are passed to `ls`(1) which produces the actual output]' \
+    '(--versions --pinned --installed-on-request --installed-as-dependency --poured-from-bottle --built-from-source -l -r -t)--full-name[Print formulae with fully-qualified names. Unless `--full-name`, `--versions` or `--pinned` are passed, other options (i.e. `-1`, `-l`, `-r` and `-t`) are passed to `ls`(1) which produces the actual output]' \
     '--help[Show this message]' \
+    '(--cask --versions --pinned -l --full-name)--installed-as-dependency[List the formulae installed as dependencies]' \
+    '(--cask --versions --pinned -l --full-name)--installed-on-request[List the formulae installed on request]' \
     '(--cask --pinned)--multiple[Only show formulae with multiple versions installed]' \
-    '(--cask --multiple --1 --l --r --t --full-name)--pinned[List only pinned formulae, or only the specified (pinned) formulae if formula are provided. See also `pin`, `unpin`]' \
+    '(--cask --multiple --installed-on-request --installed-as-dependency --poured-from-bottle --built-from-source -1 -l -r -t --full-name)--pinned[List only pinned formulae, or only the specified (pinned) formulae if formula are provided. See also `pin`, `unpin`]' \
+    '(--cask --versions --pinned -l --full-name)--poured-from-bottle[List the formulae installed from a bottle]' \
     '--quiet[Make some output more quiet]' \
     '--verbose[Make some output more verbose]' \
-    '(--1 --l --r --t --full-name)--versions[Show the version number for installed formulae, or only the specified formulae if formula are provided]' \
-    '-1[Force output to be one entry per line. This is the default when output is not to a terminal]' \
-    '-l[List formulae and/or casks in long format. Has no effect when a formula or cask name is passed as an argument]' \
-    '-r[Reverse the order of the formulae and/or casks sort to list the oldest entries first. Has no effect when a formula or cask name is passed as an argument]' \
-    '-t[Sort formulae and/or casks by time modified, listing most recently modified first. Has no effect when a formula or cask name is passed as an argument]' \
+    '(--installed-on-request --installed-as-dependency --poured-from-bottle --built-from-source -1 -l -r -t --full-name)--versions[Show the version number for installed formulae, or only the specified formulae if formula are provided]' \
+    '(--versions --pinned)-1[Force output to be one entry per line. This is the default when output is not to a terminal]' \
+    '(--installed-on-request --installed-as-dependency --poured-from-bottle --built-from-source --versions --pinned --full-name)-l[List formulae and/or casks in long format. Has no effect when a formula or cask name is passed as an argument]' \
+    '(--versions --pinned --full-name)-r[Reverse the order of the formulae and/or casks sort to list the oldest entries first. Has no effect when a formula or cask name is passed as an argument]' \
+    '(--versions --pinned --full-name)-t[Sort formulae and/or casks by time modified, listing most recently modified first. Has no effect when a formula or cask name is passed as an argument]' \
     - installed_formula \
     '(--cask)--formula[List only formulae, or treat all named arguments as formulae]' \
     '*::installed_formula:__brew_installed_formulae' \
     - installed_cask \
-    '(--formula --pinned --multiple)--cask[List only casks, or treat all named arguments as casks]' \
+    '(--formula --pinned --multiple --installed-on-request --installed-as-dependency --poured-from-bottle --built-from-source)--cask[List only casks, or treat all named arguments as casks]' \
     '*::installed_cask:__brew_installed_casks'
 }
 
@@ -1243,7 +1406,11 @@ _brew_migrate() {
     '--quiet[Make some output more quiet]' \
     '--verbose[Make some output more verbose]' \
     - installed_formula \
-    '*::installed_formula:__brew_installed_formulae'
+    '(--cask)--formula[Only migrate formulae]' \
+    '*::installed_formula:__brew_installed_formulae' \
+    - installed_cask \
+    '(--formula)--cask[Only migrate casks]' \
+    '*::installed_cask:__brew_installed_casks'
 }
 
 # brew missing
@@ -1258,13 +1425,22 @@ _brew_missing() {
     '*::formula:__brew_formulae'
 }
 
+# brew nodenv-sync
+_brew_nodenv_sync() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
 # brew options
 _brew_options() {
   _arguments \
-    '(--installed --command)--all[Show options for all available formulae]' \
     '(--installed --all)--command[Show options for the specified command]' \
     '--compact[Show all options on a single line separated by spaces]' \
     '--debug[Display any debugging information]' \
+    '--eval-all[Evaluate all available formulae and casks, whether installed or not, to show their options]' \
     '--help[Show this message]' \
     '(--all --command)--installed[Show options for formulae that are currently installed]' \
     '--quiet[Make some output more quiet]' \
@@ -1304,6 +1480,17 @@ _brew_pin() {
     '*::installed_formula:__brew_installed_formulae'
 }
 
+# brew post_install
+_brew_post_install() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]' \
+    - installed_formula \
+    '*::installed_formula:__brew_installed_formulae'
+}
+
 # brew postinstall
 _brew_postinstall() {
   _arguments \
@@ -1318,28 +1505,29 @@ _brew_postinstall() {
 # brew pr-automerge
 _brew_pr_automerge() {
   _arguments \
+    '--autosquash[Instruct `brew pr-publish` to automatically reformat and reword commits in the pull request to the preferred format]' \
     '--debug[Display any debugging information]' \
     '--help[Show this message]' \
     '--ignore-failures[Include pull requests that have failing status checks]' \
-    '--no-autosquash[Instruct `brew pr-publish` to skip automatically reformatting and rewording commits in the pull request to the preferred format]' \
     '--publish[Run `brew pr-publish` on matching pull requests]' \
     '--quiet[Make some output more quiet]' \
     '--tap[Target tap repository (default: `homebrew/core`)]' \
     '--verbose[Make some output more verbose]' \
     '--with-label[Pull requests must have this label]' \
     '--without-approval[Pull requests do not require approval to be merged]' \
-    '--without-labels[Pull requests must not have these labels (default: `do not merge`, `new formula`, `automerge-skip`)]' \
+    '--without-labels[Pull requests must not have these labels (default: `do not merge`, `new formula`, `automerge-skip`, `pre-release`, `CI-published-bottle-commits`)]' \
     '--workflow[Workflow file to use with `brew pr-publish`]'
 }
 
 # brew pr-publish
 _brew_pr_publish() {
   _arguments \
-    '--branch[Branch to publish to (default: `master`)]' \
+    '--autosquash[If supported on the target tap, automatically reformat and reword commits to our preferred format]' \
+    '--branch[Branch to use the workflow from (default: `master`)]' \
     '--debug[Display any debugging information]' \
     '--help[Show this message]' \
-    '(--no-autosquash)--message[Message to include when autosquashing revision bumps, deletions, and rebuilds]' \
-    '(--message)--no-autosquash[Skip automatically reformatting and rewording commits in the pull request to the preferred format, even if supported on the target tap]' \
+    '--large-runner[Run the upload job on a large runner]' \
+    '--message[Message to include when autosquashing revision bumps, deletions and rebuilds]' \
     '--quiet[Make some output more quiet]' \
     '--tap[Target tap repository (default: `homebrew/core`)]' \
     '--verbose[Make some output more verbose]' \
@@ -1349,21 +1537,23 @@ _brew_pr_publish() {
 # brew pr-pull
 _brew_pr_pull() {
   _arguments \
-    '--artifact[Download artifacts with the specified name (default: `bottles`)]' \
+    '--artifact-pattern[Download artifacts with the specified pattern (default: `bottles{,_*}`)]' \
+    '(--clean)--autosquash[Automatically reformat and reword commits in the pull request to our preferred format]' \
     '--branch-okay[Do not warn if pulling to a branch besides the repository default (useful for testing)]' \
-    '--clean[Do not amend the commits from pull requests]' \
+    '(--autosquash)--clean[Do not amend the commits from pull requests]' \
     '--committer[Specify a committer name and email in `git`'\''s standard author format]' \
     '--debug[Display any debugging information]' \
     '--dry-run[Print what would be done rather than doing it]' \
     '--help[Show this message]' \
     '--ignore-missing-artifacts[Comma-separated list of workflows which can be ignored if they have not been run]' \
     '--keep-old[If the formula specifies a rebuild version, attempt to preserve its value in the generated DSL]' \
-    '(--no-autosquash)--message[Message to include when autosquashing revision bumps, deletions, and rebuilds]' \
-    '(--message)--no-autosquash[Skip automatically reformatting and rewording commits in the pull request to our preferred format]' \
+    '--message[Message to include when autosquashing revision bumps, deletions and rebuilds]' \
+    '--no-cherry-pick[Do not cherry-pick commits from the pull request branch]' \
     '--no-commit[Do not generate a new commit before uploading]' \
     '--no-upload[Download the bottles but don'\''t upload them]' \
     '--quiet[Make some output more quiet]' \
     '--resolve[When a patch fails to apply, leave in progress and allow user to resolve, instead of aborting]' \
+    '--retain-bottle-dir[Does not clean up the tmp directory for the bottle so it can be used later]' \
     '--root-url[Use the specified URL as the root of the bottle'\''s URL instead of Homebrew'\''s default]' \
     '--root-url-using[Use the specified download strategy class for downloading the bottle'\''s URL instead of Homebrew'\''s default]' \
     '--tap[Target tap repository (default: `homebrew/core`)]' \
@@ -1397,18 +1587,41 @@ _brew_prof() {
     '--quiet[Make some output more quiet]' \
     '--stackprof[Use `stackprof` instead of `ruby-prof` (the default)]' \
     '--verbose[Make some output more verbose]' \
+    '--vernier[Use `vernier` instead of `ruby-prof` (the default)]' \
     - command \
     '*::command:__brew_commands'
 }
 
+# brew pyenv-sync
+_brew_pyenv_sync() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
+# brew rbenv-sync
+_brew_rbenv_sync() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
 # brew readall
 _brew_readall() {
   _arguments \
     '--aliases[Verify any alias symlinks in each tap]' \
+    '--arch[Read using the given CPU architecture. (Pass `all` to simulate all architectures.)]' \
     '--debug[Display any debugging information]' \
+    '--eval-all[Evaluate all available formulae and casks, whether installed or not. Implied if `HOMEBREW_EVAL_ALL` is set]' \
     '--help[Show this message]' \
+    '--no-simulate[Don'\''t simulate other system configurations when checking formulae and casks]' \
+    '--os[Read using the given operating system. (Pass `all` to simulate all operating systems.)]' \
     '--quiet[Make some output more quiet]' \
-    '--syntax[Syntax-check all of Homebrew'\''s Ruby files (if no `tap` is passed)]' \
+    '--syntax[Syntax-check all of Homebrew'\''s Ruby files (if no tap is passed)]' \
     '--verbose[Make some output more verbose]' \
     - tap \
     '*::tap:__brew_any_tap'
@@ -1417,14 +1630,16 @@ _brew_readall() {
 # brew reinstall
 _brew_reinstall() {
   _arguments \
+    '(--formula)--adopt[Adopt existing artifacts in the destination that are identical to those being installed. Cannot be combined with `--force`]' \
     '(--formula)--appdir[Target location for Applications (default: `/Applications`)]' \
     '(--formula)--audio-unit-plugindir[Target location for Audio Unit Plugins (default: `~/Library/Audio/Plug-Ins/Components`)]' \
     '(--formula)--binaries[Disable/enable linking of helper executables (default: enabled)]' \
     '(--cask --force-bottle)--build-from-source[Compile formula from source even if a bottle is available]' \
     '(--formula)--colorpickerdir[Target location for Color Pickers (default: `~/Library/ColorPickers`)]' \
     '--debug[If brewing fails, open an interactive debugging session with access to IRB or a shell inside the temporary build directory]' \
+    '(--cask)--debug-symbols[Generate debug symbols on build. Source will be retained in a cache directory]' \
     '(--formula)--dictionarydir[Target location for Dictionaries (default: `~/Library/Dictionaries`)]' \
-    '(--cask)--display-times[Print install times for each formula at the end of the run]' \
+    '--display-times[Print install times for each package at the end of the run]' \
     '(--formula)--fontdir[Target location for Fonts (default: `~/Library/Fonts`)]' \
     '--force[Install without checking for previously installed keg-only or non-migrated versions]' \
     '(--cask --build-from-source)--force-bottle[Install from a bottle if it exists for the current or newest version of macOS, even if it would not normally be used for installation]' \
@@ -1434,27 +1649,28 @@ _brew_reinstall() {
     '(--cask)--interactive[Download and patch formula, then open a shell. This allows the user to run `./configure --help` and otherwise determine how to turn the software package into a Homebrew package]' \
     '(--formula)--internet-plugindir[Target location for Internet Plugins (default: `~/Library/Internet Plug-Ins`)]' \
     '(--cask)--keep-tmp[Retain the temporary files created during installation]' \
+    '(--formula)--keyboard-layoutdir[Target location for Keyboard Layouts (default: `/Library/Keyboard Layouts`)]' \
     '(--formula)--language[Comma-separated list of language codes to prefer for cask installation. The first matching language is used, otherwise it reverts to the cask'\''s default language. The default value is the language of your system]' \
     '(--formula)--mdimporterdir[Target location for Spotlight Plugins (default: `~/Library/Spotlight`)]' \
     '--no-binaries[Disable/enable linking of helper executables (default: enabled)]' \
     '--no-quarantine[Disable/enable quarantining of downloads (default: enabled)]' \
     '(--formula)--prefpanedir[Target location for Preference Panes (default: `~/Library/PreferencePanes`)]' \
-    '(--formula)--qlplugindir[Target location for QuickLook Plugins (default: `~/Library/QuickLook`)]' \
+    '(--formula)--qlplugindir[Target location for Quick Look Plugins (default: `~/Library/QuickLook`)]' \
     '(--formula)--quarantine[Disable/enable quarantining of downloads (default: enabled)]' \
     '--quiet[Make some output more quiet]' \
     '(--formula)--require-sha[Require all casks to have a checksum]' \
     '(--formula)--screen-saverdir[Target location for Screen Savers (default: `~/Library/Screen Savers`)]' \
     '(--formula)--servicedir[Target location for Services (default: `~/Library/Services`)]' \
     '(--formula)--skip-cask-deps[Skip installing cask dependencies]' \
-    '--verbose[Print the verification and postinstall steps]' \
+    '--verbose[Print the verification and post-install steps]' \
     '(--formula)--vst-plugindir[Target location for VST Plugins (default: `~/Library/Audio/Plug-Ins/VST`)]' \
     '(--formula)--vst3-plugindir[Target location for VST3 Plugins (default: `~/Library/Audio/Plug-Ins/VST3`)]' \
     '(--formula)--zap[For use with `brew reinstall --cask`. Remove all files associated with a cask. *May remove files which are shared between applications.*]' \
     - formula \
-    '(--casks --binaries --require-sha --quarantine --skip-cask-deps --zap --appdir --colorpickerdir --prefpanedir --qlplugindir --mdimporterdir --dictionarydir --fontdir --servicedir --input-methoddir --internet-plugindir --audio-unit-plugindir --vst-plugindir --vst3-plugindir --screen-saverdir --language)--formula[Treat all named arguments as formulae]' \
+    '(--casks --binaries --require-sha --quarantine --adopt --skip-cask-deps --zap --appdir --keyboard-layoutdir --colorpickerdir --prefpanedir --qlplugindir --mdimporterdir --dictionarydir --fontdir --servicedir --input-methoddir --internet-plugindir --audio-unit-plugindir --vst-plugindir --vst3-plugindir --screen-saverdir --language)--formula[Treat all named arguments as formulae]' \
     '*::formula:__brew_formulae' \
     - cask \
-    '(--formulae --build-from-source --interactive --force-bottle --keep-tmp --display-times --git)--cask[Treat all named arguments as casks]' \
+    '(--formulae --build-from-source --interactive --force-bottle --keep-tmp --debug-symbols --git)--cask[Treat all named arguments as casks]' \
     '*::cask:__brew_casks'
 }
 
@@ -1505,6 +1721,15 @@ _brew_rm() {
     '*::installed_cask:__brew_installed_casks'
 }
 
+# brew rubocop
+_brew_rubocop() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
 # brew ruby
 _brew_ruby() {
   _arguments \
@@ -1518,18 +1743,30 @@ _brew_ruby() {
     '*::file:__brew_formulae_or_ruby_files'
 }
 
+# brew rubydoc
+_brew_rubydoc() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--only-public[Only generate public API documentation]' \
+    '--open[Open generated documentation in a browser]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
 # brew search
 _brew_search() {
   _arguments \
     '(--repology --macports --fink --opensuse --fedora --debian --ubuntu)--archlinux[Search for text in the given database]' \
-    '--cask[Search online and locally for casks]' \
+    '--cask[Search for casks]' \
     '(--open)--closed[Search for only closed GitHub pull requests]' \
     '(--repology --macports --fink --opensuse --fedora --archlinux --ubuntu)--debian[Search for text in the given database]' \
     '--debug[Display any debugging information]' \
     '(--pull-request)--desc[Search for formulae with a description matching text and casks with a name or description matching text]' \
+    '--eval-all[Evaluate all available formulae and casks, whether installed or not, to search their descriptions. Implied if `HOMEBREW_EVAL_ALL` is set]' \
     '(--repology --macports --fink --opensuse --archlinux --debian --ubuntu)--fedora[Search for text in the given database]' \
     '(--repology --macports --opensuse --fedora --archlinux --debian --ubuntu)--fink[Search for text in the given database]' \
-    '--formula[Search online and locally for formulae]' \
+    '--formula[Search for formulae]' \
     '--help[Show this message]' \
     '(--repology --fink --opensuse --fedora --archlinux --debian --ubuntu)--macports[Search for text in the given database]' \
     '(--closed)--open[Search for only open GitHub pull requests]' \
@@ -1541,6 +1778,17 @@ _brew_search() {
     '--verbose[Make some output more verbose]'
 }
 
+# brew setup-ruby
+_brew_setup_ruby() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]' \
+    - command \
+    '*::command:__brew_commands'
+}
+
 # brew sh
 _brew_sh() {
   _arguments \
@@ -1554,8 +1802,8 @@ _brew_sh() {
     '*::file:__brew_formulae_or_ruby_files'
 }
 
-# brew sponsors
-_brew_sponsors() {
+# brew shellenv
+_brew_shellenv() {
   _arguments \
     '--debug[Display any debugging information]' \
     '--help[Show this message]' \
@@ -1567,7 +1815,6 @@ _brew_sponsors() {
 _brew_style() {
   _arguments \
     '--debug[Display any debugging information]' \
-    '--display-cop-names[Include the RuboCop cop name for each violation in the output]' \
     '(--only-cops)--except-cops[Specify a comma-separated cops list to skip checking for violations of the listed RuboCop cops]' \
     '--fix[Fix style violations automatically using RuboCop'\''s auto-correct feature]' \
     '--help[Show this message]' \
@@ -1587,15 +1834,31 @@ _brew_style() {
     '*::cask:__brew_casks'
 }
 
+# brew tab
+_brew_tab() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '(--no-installed-on-request)--installed-on-request[Mark installed_formula or installed_cask as installed on request]' \
+    '(--installed-on-request)--no-installed-on-request[Mark installed_formula or installed_cask as not installed on request]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]' \
+    - installed_formula \
+    '(--cask)--formula[Only mark formulae]' \
+    '*::installed_formula:__brew_installed_formulae' \
+    - installed_cask \
+    '(--formula)--cask[Only mark casks]' \
+    '*::installed_cask:__brew_installed_casks'
+}
+
 # brew tap
 _brew_tap() {
   _arguments \
     '--custom-remote[Install or change a tap with a custom remote. Useful for mirrors]' \
     '--debug[Display any debugging information]' \
-    '--force-auto-update[Auto-update tap even if it is not hosted on GitHub. By default, only taps hosted on GitHub are auto-updated (for performance reasons)]' \
+    '--eval-all[Evaluate all the formulae, casks and aliases in the new tap to check validity. Implied if `HOMEBREW_EVAL_ALL` is set]' \
+    '--force[Force install core taps even under API mode]' \
     '--help[Show this message]' \
-    '--list-pinned[List all pinned taps]' \
-    '--no-force-auto-update[Auto-update tap even if it is not hosted on GitHub. By default, only taps hosted on GitHub are auto-updated (for performance reasons)]' \
     '--quiet[Make some output more quiet]' \
     '--repair[Migrate tapped formulae from symlink-based to directory-based structure]' \
     '--verbose[Make some output more verbose]' \
@@ -1634,24 +1897,26 @@ _brew_tap_new() {
 # brew tc
 _brew_tc() {
   _arguments \
-    '--all[Regenerate all RBI files rather than just updated gems]' \
     '--debug[Display any debugging information]' \
     '(--file)--dir[Typecheck all files in a specific directory]' \
-    '--fail-if-not-changed[Return a failing status code if all gems are up to date and gem definitions do not need a tapioca update]' \
     '(--dir)--file[Typecheck a single file]' \
-    '--fix[Automatically fix type errors]' \
+    '(--lsp)--fix[Automatically fix type errors]' \
     '--help[Show this message]' \
     '--ignore[Ignores input files that contain the given string in their paths (relative to the input path passed to Sorbet)]' \
+    '(--update --update-all --fix)--lsp[Start the Sorbet LSP server]' \
     '--quiet[Silence all non-critical errors]' \
     '--suggest-typed[Try upgrading `typed` sigils]' \
-    '--update[Update RBI files]' \
-    '--verbose[Make some output more verbose]'
+    '(--lsp)--update[Update RBI files]' \
+    '(--lsp)--update-all[Update all RBI files rather than just updated gems]' \
+    '--verbose[Make some output more verbose]' \
+    - tap \
+    '*::tap:__brew_any_tap'
 }
 
 # brew test
 _brew_test() {
   _arguments \
-    '--HEAD[Test the head version of a formula]' \
+    '--HEAD[Test the HEAD version of a formula]' \
     '--debug[Display any debugging information]' \
     '--force[Test formulae even if they are unlinked]' \
     '--help[Show this message]' \
@@ -1666,15 +1931,15 @@ _brew_test() {
 # brew tests
 _brew_tests() {
   _arguments \
-    '--byebug[Enable debugging using byebug]' \
     '(--only)--changed[Only runs tests on files that were changed from the master branch]' \
     '--coverage[Generate code coverage reports]' \
-    '--debug[Display any debugging information]' \
+    '--debug[Enable debugging using `ruby/debug`, or surface the standard `odebug` output]' \
+    '--fail-fast[Exit early on the first failing test]' \
     '--generic[Run only OS-agnostic tests]' \
     '--help[Show this message]' \
-    '--no-compat[Do not load the compatibility layer when running tests]' \
     '--online[Include tests that use the GitHub API and tests that use any of the taps for official external commands]' \
-    '(--changed)--only[Run only test_script`_spec.rb`. Appending `:`line_number will start at a specific line]' \
+    '(--changed)--only[Run only `test_script_spec.rb`. Appending `:line_number` will start at a specific line]' \
+    '--profile[Run the test suite serially to find the n slowest tests]' \
     '--quiet[Make some output more quiet]' \
     '--seed[Randomise tests with the specified value instead of a random seed]' \
     '--verbose[Make some output more verbose]'
@@ -1683,29 +1948,33 @@ _brew_tests() {
 # brew typecheck
 _brew_typecheck() {
   _arguments \
-    '--all[Regenerate all RBI files rather than just updated gems]' \
     '--debug[Display any debugging information]' \
     '(--file)--dir[Typecheck all files in a specific directory]' \
-    '--fail-if-not-changed[Return a failing status code if all gems are up to date and gem definitions do not need a tapioca update]' \
     '(--dir)--file[Typecheck a single file]' \
-    '--fix[Automatically fix type errors]' \
+    '(--lsp)--fix[Automatically fix type errors]' \
     '--help[Show this message]' \
     '--ignore[Ignores input files that contain the given string in their paths (relative to the input path passed to Sorbet)]' \
+    '(--update --update-all --fix)--lsp[Start the Sorbet LSP server]' \
     '--quiet[Silence all non-critical errors]' \
     '--suggest-typed[Try upgrading `typed` sigils]' \
-    '--update[Update RBI files]' \
-    '--verbose[Make some output more verbose]'
+    '(--lsp)--update[Update RBI files]' \
+    '(--lsp)--update-all[Update all RBI files rather than just updated gems]' \
+    '--verbose[Make some output more verbose]' \
+    - tap \
+    '*::tap:__brew_any_tap'
 }
 
 # brew unbottled
 _brew_unbottled() {
   _arguments \
-    '(--dependents --installed)--all[Print the number of unbottled and total formulae]' \
     '--debug[Display any debugging information]' \
-    '(--all)--dependents[Skip getting analytics data and sort by number of dependents instead]' \
+    '(--total --lost)--dependents[Skip getting analytics data and sort by number of dependents instead]' \
+    '--eval-all[Evaluate all available formulae and casks, whether installed or not, to check them. Implied if `HOMEBREW_EVAL_ALL` is set]' \
     '--help[Show this message]' \
+    '(--dependents --total)--lost[Print the `homebrew/core` commits where bottles were lost in the last week]' \
     '--quiet[Make some output more quiet]' \
     '--tag[Use the specified bottle tag (e.g. `big_sur`) instead of the current OS]' \
+    '(--dependents --lost)--total[Print the number of unbottled and total formulae]' \
     '--verbose[Make some output more verbose]' \
     - formula \
     '*::formula:__brew_formulae'
@@ -1825,7 +2094,6 @@ _brew_update() {
 _brew_update_license_data() {
   _arguments \
     '--debug[Display any debugging information]' \
-    '--fail-if-not-changed[Return a failing status code if current license data'\''s version is the same as the upstream. This can be used to notify CI when the SPDX license data is out of date]' \
     '--help[Show this message]' \
     '--quiet[Make some output more quiet]' \
     '--verbose[Make some output more verbose]'
@@ -1848,6 +2116,7 @@ _brew_update_python_resources() {
     '--extra-packages[Include these additional packages when finding resources]' \
     '--help[Show this message]' \
     '--ignore-non-pypi-packages[Don'\''t fail if formula is not a PyPI package]' \
+    '--install-dependencies[Install missing dependencies required to update resources]' \
     '--package-name[Use the specified package-name when finding resources for formula. If no package name is specified, it will be inferred from the formula'\''s stable URL]' \
     '--print-only[Print the updated resource blocks instead of changing formula]' \
     '--quiet[Make some output more quiet]' \
@@ -1869,6 +2138,24 @@ _brew_update_report() {
     '--verbose[Make some output more verbose]'
 }
 
+# brew update-reset
+_brew_update_reset() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
+# brew update-sponsors
+_brew_update_sponsors() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--quiet[Make some output more quiet]' \
+    '--verbose[Make some output more verbose]'
+}
+
 # brew update-test
 _brew_update_test() {
   _arguments \
@@ -1891,8 +2178,9 @@ _brew_upgrade() {
     '(--cask --force-bottle)--build-from-source[Compile formula from source even if a bottle is available]' \
     '(--formula)--colorpickerdir[Target location for Color Pickers (default: `~/Library/ColorPickers`)]' \
     '--debug[If brewing fails, open an interactive debugging session with access to IRB or a shell inside the temporary build directory]' \
+    '(--cask)--debug-symbols[Generate debug symbols on build. Source will be retained in a cache directory]' \
     '(--formula)--dictionarydir[Target location for Dictionaries (default: `~/Library/Dictionaries`)]' \
-    '(--cask)--display-times[Print install times for each package at the end of the run]' \
+    '--display-times[Print install times for each package at the end of the run]' \
     '--dry-run[Show what would be upgraded, but do not actually upgrade anything]' \
     '(--cask)--fetch-HEAD[Fetch the upstream repository to detect if the HEAD installation of the formula is outdated. Otherwise, the repository'\''s HEAD will only be checked for updates when a new stable or development version has been released]' \
     '(--formula)--fontdir[Target location for Fonts (default: `~/Library/Fonts`)]' \
@@ -1902,32 +2190,33 @@ _brew_upgrade() {
     '(--formula)--greedy-auto-updates[Also include casks with `auto_updates true`]' \
     '(--formula)--greedy-latest[Also include casks with `version :latest`]' \
     '--help[Show this message]' \
-    '(--cask)--ignore-pinned[Set a successful exit status even if pinned formulae are not upgraded]' \
     '(--formula)--input-methoddir[Target location for Input Methods (default: `~/Library/Input Methods`)]' \
     '(--cask)--interactive[Download and patch formula, then open a shell. This allows the user to run `./configure --help` and otherwise determine how to turn the software package into a Homebrew package]' \
     '(--formula)--internet-plugindir[Target location for Internet Plugins (default: `~/Library/Internet Plug-Ins`)]' \
     '(--cask)--keep-tmp[Retain the temporary files created during installation]' \
+    '(--formula)--keyboard-layoutdir[Target location for Keyboard Layouts (default: `/Library/Keyboard Layouts`)]' \
     '(--formula)--language[Comma-separated list of language codes to prefer for cask installation. The first matching language is used, otherwise it reverts to the cask'\''s default language. The default value is the language of your system]' \
     '(--formula)--mdimporterdir[Target location for Spotlight Plugins (default: `~/Library/Spotlight`)]' \
     '--no-binaries[Disable/enable linking of helper executables (default: enabled)]' \
     '--no-quarantine[Disable/enable quarantining of downloads (default: enabled)]' \
+    '(--cask)--overwrite[Delete files that already exist in the prefix while linking]' \
     '(--formula)--prefpanedir[Target location for Preference Panes (default: `~/Library/PreferencePanes`)]' \
-    '(--formula)--qlplugindir[Target location for QuickLook Plugins (default: `~/Library/QuickLook`)]' \
+    '(--formula)--qlplugindir[Target location for Quick Look Plugins (default: `~/Library/QuickLook`)]' \
     '(--formula)--quarantine[Disable/enable quarantining of downloads (default: enabled)]' \
     '--quiet[Make some output more quiet]' \
     '(--formula)--require-sha[Require all casks to have a checksum]' \
     '(--formula)--screen-saverdir[Target location for Screen Savers (default: `~/Library/Screen Savers`)]' \
     '(--formula)--servicedir[Target location for Services (default: `~/Library/Services`)]' \
     '(--formula)--skip-cask-deps[Skip installing cask dependencies]' \
-    '--verbose[Print the verification and postinstall steps]' \
+    '--verbose[Print the verification and post-install steps]' \
     '(--formula)--vst-plugindir[Target location for VST Plugins (default: `~/Library/Audio/Plug-Ins/VST`)]' \
     '(--formula)--vst3-plugindir[Target location for VST3 Plugins (default: `~/Library/Audio/Plug-Ins/VST3`)]' \
-    - outdated_formula \
-    '(--casks --binaries --require-sha --quarantine --skip-cask-deps --greedy --greedy-latest --greedy-auto-updates --appdir --colorpickerdir --prefpanedir --qlplugindir --mdimporterdir --dictionarydir --fontdir --servicedir --input-methoddir --internet-plugindir --audio-unit-plugindir --vst-plugindir --vst3-plugindir --screen-saverdir --language)--formula[Treat all named arguments as formulae. If no named arguments are specified, upgrade only outdated formulae]' \
-    '*::outdated_formula:__brew_outdated_formulae' \
-    - outdated_cask \
-    '(--formulae --build-from-source --interactive --force-bottle --fetch-HEAD --ignore-pinned --keep-tmp --display-times)--cask[Treat all named arguments as casks. If no named arguments are specified, upgrade only outdated casks]' \
-    '*::outdated_cask:__brew_outdated_casks'
+    - installed_formula \
+    '(--casks --skip-cask-deps --greedy --greedy-latest --greedy-auto-updates --binaries --require-sha --quarantine --appdir --keyboard-layoutdir --colorpickerdir --prefpanedir --qlplugindir --mdimporterdir --dictionarydir --fontdir --servicedir --input-methoddir --internet-plugindir --audio-unit-plugindir --vst-plugindir --vst3-plugindir --screen-saverdir --language)--formula[Treat all named arguments as formulae. If no named arguments are specified, upgrade only outdated formulae]' \
+    '*::installed_formula:__brew_installed_formulae' \
+    - installed_cask \
+    '(--formulae --build-from-source --interactive --force-bottle --fetch-HEAD --keep-tmp --debug-symbols --overwrite)--cask[Treat all named arguments as casks. If no named arguments are specified, upgrade only outdated casks]' \
+    '*::installed_cask:__brew_installed_casks'
 }
 
 # brew uses
@@ -1935,14 +2224,16 @@ _brew_uses() {
   _arguments \
     '(--formula)--cask[Include only casks]' \
     '--debug[Display any debugging information]' \
+    '--eval-all[Evaluate all available formulae and casks, whether installed or not, to show their dependents]' \
     '--help[Show this message]' \
-    '--include-build[Include all formulae that specify formula as `:build` type dependency]' \
-    '--include-optional[Include all formulae that specify formula as `:optional` type dependency]' \
-    '--include-test[Include all formulae that specify formula as `:test` type dependency]' \
-    '(--all)--installed[Only list formulae and casks that are currently installed]' \
+    '--include-build[Include formulae that specify formula as a `:build` dependency]' \
+    '--include-optional[Include formulae that specify formula as an `:optional` dependency]' \
+    '--include-test[Include formulae that specify formula as a `:test` dependency]' \
+    '(--all --missing)--installed[Only list formulae and casks that are currently installed]' \
+    '(--installed)--missing[Only list formulae and casks that are not currently installed]' \
     '--quiet[Make some output more quiet]' \
     '--recursive[Resolve more than one level of dependencies]' \
-    '--skip-recommended[Skip all formulae that specify formula as `:recommended` type dependency]' \
+    '--skip-recommended[Skip all formulae that specify formula as a `:recommended` dependency]' \
     '--verbose[Make some output more verbose]' \
     - formula \
     '(--cask)--formula[Include only formulae]' \
@@ -1951,11 +2242,21 @@ _brew_uses() {
 
 # brew vendor-gems
 _brew_vendor_gems() {
+  _arguments \
+    '--debug[Display any debugging information]' \
+    '--help[Show this message]' \
+    '--no-commit[Do not generate a new commit upon completion]' \
+    '--quiet[Make some output more quiet]' \
+    '--update[Update the specified list of vendored gems to the latest version]' \
+    '--verbose[Make some output more verbose]'
+}
+
+# brew vendor-install
+_brew_vendor_install() {
   _arguments \
     '--debug[Display any debugging information]' \
     '--help[Show this message]' \
     '--quiet[Make some output more quiet]' \
-    '--update[Update all vendored Gems to the latest version]' \
     '--verbose[Make some output more verbose]'
 }
 
diff --git a/docs/.mdl_ruleset.rb b/docs/.mdl_ruleset.rb
index a32f752d2e654..7cf80606d77e7 100644
--- a/docs/.mdl_ruleset.rb
+++ b/docs/.mdl_ruleset.rb
@@ -1,6 +1,9 @@
-rule 'HB034', 'Bare unstyled URL used' do
+# typed: true
+# frozen_string_literal: true
+
+rule "HB034", "Bare unstyled URL used" do
   tags :links, :url
-  aliases 'no-bare-unstyled-urls'
+  aliases "no-bare-unstyled-urls"
   check do |doc|
     doc.matching_text_element_lines(%r{(?<=\s)https?://})
   end
diff --git a/docs/.mdl_style.rb b/docs/.mdl_style.rb
index 3466dc4ffdce5..dda5902a4e8da 100644
--- a/docs/.mdl_style.rb
+++ b/docs/.mdl_style.rb
@@ -1,7 +1,11 @@
+# typed: true
+# frozen_string_literal: true
+
 all
-rule 'MD026', punctuation: ',;:' # Trailing punctuation in header
-exclude_rule 'MD013' # Line length
-exclude_rule 'MD029' # Ordered list item prefix
-exclude_rule 'MD033' # Inline HTML
-exclude_rule 'MD034' # Bare URL used (replaced by HB034)
-exclude_rule 'MD046' # Code block style
+rule "MD007", indent: 2 # Unordered list indentation
+rule "MD026", punctuation: ",;:" # Trailing punctuation in header
+exclude_rule "MD013" # Line length
+exclude_rule "MD029" # Ordered list item prefix
+exclude_rule "MD033" # Inline HTML
+exclude_rule "MD034" # Bare URL used (replaced by HB034)
+exclude_rule "MD046" # Code block style
diff --git a/docs/.rubocop.yml b/docs/.rubocop.yml
new file mode 100644
index 0000000000000..cc101165e6d52
--- /dev/null
+++ b/docs/.rubocop.yml
@@ -0,0 +1,42 @@
+inherit_from: ../Library/.rubocop.yml
+
+AllCops:
+  Exclude:
+    - "**/_site/**/*"
+    - "**/Manpage.md"
+    - "**/vendor/**/*"
+
+# These are included in docs deliberately to show what
+# `brew create` does and what the user should replace.
+FormulaAudit/Comments:
+  Enabled: false
+
+# This forces us to use dummy descriptions/homepages in example formulae which we don't need to clutter the docs with.
+FormulaAudit/Desc:
+  Enabled: false
+FormulaAudit/Homepage:
+  Enabled: false
+
+Layout/LineLength:
+  Exclude:
+    - "**/Bottles.md" # The bottle block line length is long in its full form.
+
+# Apparently Casks are allowed to have constant definitions in blocks and we document this.
+Lint/ConstantDefinitionInBlock:
+  Enabled: false
+
+# A fake regexp is deliberately documented for `inreplace` in the Formula Cookbook.
+Style/RedundantRegexpArgument:
+  Enabled: false
+
+# Want to be able to display partial formulae in the docs.
+Style/TopLevelMethodDefinition:
+  Enabled: false
+
+# Formulae and Casks no longer use `rm_f`/`rm_rf`, so the docs need to match.
+Lint/NonAtomicFileOperation:
+  Enabled: false
+
+# The markdown linter config files don't need to be typed strict.
+Sorbet/StrictSigil:
+  Enabled: false
diff --git a/docs/.ruby-version b/docs/.ruby-version
new file mode 120000
index 0000000000000..120ff9fc88ee5
--- /dev/null
+++ b/docs/.ruby-version
@@ -0,0 +1 @@
+../Library/Homebrew/.ruby-version
\ No newline at end of file
diff --git a/docs/Acceptable-Casks.md b/docs/Acceptable-Casks.md
index 9ec01fa975916..6de1de69dad6c 100644
--- a/docs/Acceptable-Casks.md
+++ b/docs/Acceptable-Casks.md
@@ -1,132 +1,131 @@
 # Acceptable Casks
 
-Some casks should not go in
-[homebrew/cask](https://github.com/Homebrew/homebrew-cask). But there are
-additional [Interesting Taps and Forks](Interesting-Taps-and-Forks.md) and anyone can [start their own](Taps.md)!
+Some casks should not go in [homebrew/cask](https://github.com/Homebrew/homebrew-cask). But there are additional [Interesting Taps and Forks](Interesting-Taps-and-Forks.md) and anyone can [start their own](How-to-Create-and-Maintain-a-Tap.md)!
 
-## Finding a Home For Your Cask
-
-We maintain separate Taps for different types of binaries. Our nomenclature is:
+* Table of Contents
+{:toc}
 
-+ **Stable**: The latest version provided by the developer defined by them as such.
-+ **Beta, Development, Unstable**: Subsequent versions to **stable**, yet incomplete and under development, aiming to eventually become the new **stable**. Also includes alternate versions specifically targeted at developers.
-+ **Nightly**: Constantly up-to-date versions of the current development state.
-+ **Legacy**: Any **stable** version that is not the most recent.
-+ **Regional, Localized**: Any version that isn’t the US English one, when that exists.
-+ **Trial**: Time-limited version that stops working entirely after it expires, requiring payment to lift the limitation.
-+ **Freemium**: Gratis version that works indefinitely but with limitations that can be removed by paying.
-+ **Fork**: An alternate version of an existing project, with a based-on but modified source and binary.
-+ **Unofficial**: An *allegedly* unmodified compiled binary, by a third-party, of a binary that has no existing build by the owner of the source code.
-+ **Vendorless**: A binary distributed without an official website, like a forum posting.
-+ **Walled**: When the download URL is both behind a login/registration form and from a host that differs from the homepage.
-+ **Font**: Data file containing a set of glyphs, characters, or symbols, that changes typed text.
-+ **Driver**: Software to make a hardware peripheral recognisable and usable by the system. If the software is useless without the peripheral, it’s considered a driver.
+## Finding a Home For Your Cask
 
-### Stable Versions
+We maintain separate taps for different types of binaries. Our nomenclature is:
 
-Stable versions live in the main repository at [Homebrew/homebrew-cask](https://github.com/Homebrew/homebrew-cask). They should run on the latest release of macOS or the previous point release (High Sierra and Mojave as of late 2018).
+* **Stable**: The latest version provided by the developer defined by them as such.
+* **Beta, Development, Unstable**: Subsequent versions to **stable**, yet incomplete and under development, aiming to eventually become the new **stable**. Also includes alternate versions specifically targeted at developers.
+* **Nightly**: Constantly up-to-date versions of the current development state.
+* **Legacy**: Any **stable** version that is not the most recent.
+* **Regional, Localized**: Any version that isn’t the US English one, when that exists.
+* **Trial**: Time-limited version that stops working entirely after it expires, requiring payment to lift the limitation.
+* **Freemium**: Gratis version that works indefinitely but with limitations that can be removed by paying.
+* **Fork**: An alternate version of an existing project, with a based-on but modified source and binary.
+* **Unofficial**: An *allegedly* unmodified compiled binary, by a third-party, of a binary that has no existing build by the owner of the source code.
+* **Vendorless**: A binary distributed via means other than an official website, like a forum posting.
+* **Walled**: When the download URL is both behind a login/registration form and from a host that differs from the homepage.
+* **Font**: Data file containing a set of glyphs, characters, or symbols, that changes typed text.
 
-### But There Is No Stable Version!
+### Stable versions
 
-When software is only available as a beta, development, or unstable version, its cask can go in the main repo. When stable versions become available, only those will be accepted as subsequent updates.
+Stable versions live in the main repository at [Homebrew/homebrew-cask](https://github.com/Homebrew/homebrew-cask). They should run on the latest release of macOS or the previous point release (Monterey and Ventura as of late 2022).
 
 ### Beta, Unstable, Development, Nightly, or Legacy
 
-Alternative versions should be submitted to [Homebrew/homebrew-cask-versions](https://github.com/Homebrew/homebrew-cask-versions).
+These versions also live in the main repository at [Homebrew/homebrew-cask](https://github.com/Homebrew/homebrew-cask). The filename and token should include `@beta`, `@nightly`, etc. to distinguish them from stable versions.
 
 ### Regional and Localized
 
-When an App exists in more than one language or has different regional editions, [the `language` stanza should be used to switch between languages or regions](https://docs.brew.sh/Cask-Cookbook#stanza-language).
-
-### Trial and Freemium Versions
+When an app exists in more than one language or has different regional editions, [the `language` stanza should be used to switch between languages or regions](https://docs.brew.sh/Cask-Cookbook#stanza-language).
 
-Before submitting a trial, make sure it can be made into a full working version without the need to be redownloaded. If an App provides a trial but the only way to buy the full version is via the Mac App Store, it does not belong in any of the official repos. Freemium versions are fine.
+### Trial and Freemium versions
 
-### Forks and Apps with Conflicting Names
+Before submitting a trial, make sure it can be made into a full working version without needing to be redownloaded. If an app provides a trial but the only way to buy the full version is via the Mac App Store, it does not belong in any of the official repositories. Freemium versions are fine.
 
-Forks must have the vendor’s name as a prefix on the Cask’s file name and token. If the original software is discontinued, forks still need to follow this rule so as to not be surprising to the user. There are two exceptions which allow the fork to replace the main cask:
+### Forks and apps with conflicting names
 
-* The original discontinued software recommends that fork.
-* The fork is so overwhelmingly popular that it surpasses the original and is now the de facto project when people think of the name.
+Forks must have the vendor’s name as a prefix on the cask’s filename and token. If the original software is discontinued, forks still need to follow this rule so as to not be surprising to the user. There are two exceptions which allow the fork to replace the main cask:
 
-For unrelated Apps that share a name, the most popular one (usually the one already present) stays unprefixed. Since this can be subjective, if you disagree with a decision, open an issue and make your case to the maintainers.
+1. The original discontinued software recommends that fork.
+2. The fork is so overwhelmingly popular that it surpasses the original and is now the de facto project when people think of the name.
 
-### Unofficial, Vendorless, and Walled Builds
+For unrelated apps that share a name, the most popular one (usually the one already present) stays unprefixed. Since this can be subjective, if you disagree with a decision, open an issue and make your case to the maintainers.
 
-We do not accept these casks since they offer a higher-than-normal security risk.
+### Unofficial, Vendorless, and Walled builds
 
-### Fonts
-
-Font Casks live in the [Homebrew/homebrew-cask-fonts](https://github.com/Homebrew/homebrew-cask-fonts) repository. See the font repo [CONTRIBUTING.md](https://github.com/Homebrew/homebrew-cask-fonts/blob/HEAD/CONTRIBUTING.md)
-for details.
-
-### Drivers
-
-Driver Casks live in the [Homebrew/homebrew-cask-drivers](https://github.com/Homebrew/homebrew-cask-drivers) repository. See the drivers repo [CONTRIBUTING.md](https://github.com/Homebrew/homebrew-cask-drivers/blob/master/CONTRIBUTING.md)
-for details.
+We do not accept these casks since they involve a higher-than-normal security risk.
 
 ## Apps that bundle malware
 
-Unfortunately, in the world of software there are bad actors that bundle malware with their apps. Even so, Homebrew Cask has long decided it will not be an active gatekeeper ([macOS already has one](https://support.apple.com/en-us/HT202491)) and [users are expected to know about the software they are installing](#homebrew-cask-is-not-a-discoverability-service). This means we will not always remove casks that link to these apps, in part because there is no clear line between useful app, potentially unwanted program, and the different shades of malware — what is useful to one user may be seen as malicious by another.
+Unfortunately, in the world of software there are bad actors that bundle malware with their apps. Even so, Homebrew Cask has long decided it will not be an active gatekeeper ([macOS already has one](https://support.apple.com/en-us/HT202491)) and [users are expected to know about the software they are installing](#homebrew-cask-is-not-a-discoverability-service). This means we will not always remove casks that link to these apps, in part because there is no clear line between useful app, potentially unwanted program, and the different shades of malware—what is useful to one user may be seen as malicious by another.
 
 But we’d still like for users to enjoy some kind of protection while minimising occurrences of legitimate developers being branded as malware carriers. To do so, we evaluate casks on a case-by-case basis and any user is free to bring a potential malware case to our attention. However, it is important to never forget the last line of defence is *always* the user.
 
-If an app that bundles malware was not signed with an Apple Developer ID and you purposefully disabled or bypassed Gatekeeper, no action will be taken on our part. When you disable security features, you do so at your own risk. If, however, an app that bundles malware is signed, Apple can revoke its permissions and it will no longer run on the computers of users that keep security features on — we all benefit, Homebrew Cask users or not. To report a signed app that bundles malware, use [Apple’s Feedback Assistant](https://feedbackassistant.apple.com)
+If an app that bundles malware was not signed with an Apple Developer ID and you purposefully disabled or bypassed Gatekeeper, no action will be taken on our part. When you disable security features, you do so at your own risk. If, however, an app that bundles malware is signed, Apple can revoke its permissions and it will no longer run on the computers of users that keep security features on—we all benefit, Homebrew Cask users or not. To report a signed app that bundles malware, use [Apple’s Feedback Assistant](https://feedbackassistant.apple.com).
 
-We are also open to removing casks where we feel there is enough evidence that the app is malicious. To suggest a cask for removal, submit a Pull Request to delete it, together with your reasoning. Typically, this will mean presenting a [VirusTotal](https://www.virustotal.com) scan of the app showing it is malicious, ideally with some other reporting indicating it’s not a false positive.
+We are also open to removing casks where we feel there is enough evidence that the app is malicious. To suggest a cask for removal, submit a pull request to delete it along with your reasoning. Typically, this will mean presenting a [VirusTotal](https://www.virustotal.com) scan of the app showing it is malicious, ideally with some other reporting indicating it’s not a false positive.
 
-Likewise, software which provides both “clean” and malware-infested versions might be removed from the repo — even if we could have access to the *good* version — if its developers push for users to install the *bad* version. We do so because in these cases there’s a higher than normal risk that both versions are (or will soon become) compromised in some manner.
+Likewise, software which provides both “clean” and malware-infested versions might be removed from the repository; even if we could have access to the *good* version—if its developers push for users to install the *bad* version. We do so because in these cases there’s a higher than normal risk that both versions are (or will soon become) compromised in some manner.
 
-If a cask you depend on was removed due to these rules, fear not. Removal of a cask from the official repositories means we won’t support it, but you can do so by hosting your own [tap](How-to-Create-and-Maintain-a-Tap.md).
+If a cask you depend on was removed due to these rules, fear not. Removal of a cask from the official repositories means we won’t support it, but you can do so by [hosting your own tap](How-to-Create-and-Maintain-a-Tap.md).
 
-## Exceptions to the Notability Threshold
+## Exceptions to the notability threshold
 
 Casks which do not reach a minimum notability threshold (see [Rejected Casks](#rejected-casks)) aren’t accepted in the main repositories because the increased maintenance burden doesn’t justify the poor usage numbers they will likely get. This notability check is performed automatically by the audit commands we provide, but its decisions aren’t set in stone. A cask which fails the notability check can be added if it is:
 
-1. A popular app that has their own website but the developers use GitHub for hosting the binaries. That repository won’t be notable but the app may be.
-2. Submitted by a maintainer or prolific contributor. A big part of the reasoning for the notability rule is unpopular software garners less attention and the cask gets abandoned, outdated, and broken. Someone with a proven investment in Hombrew Cask is less likely to let that happen for software they depend on.
-3. A piece of software that was recently released to great fanfare—everyone is talking about it on Twitter and Hacker News and we’ve even gotten multiple premature submissions for it. That’s a clear case of an app that will reach the threshold in no time so that’s a PR we won’t close immediately (but may wait to merge).
-
-Note none of these exceptions is a guarantee for inclusion, but examples of situations where we may take a second look.
+1. A popular app that has its own website but the developers use GitHub for hosting the binaries. That repository won’t be notable but the app may be.
+2. Submitted by a maintainer or prolific contributor. A big part of the reasoning for the notability rule is unpopular software garners less attention and the cask gets abandoned, outdated, and broken. Someone with a proven investment in Homebrew Cask is less likely to let that happen for software they depend on.
+3. A piece of software that was recently released to great fanfare—everyone is talking about it on Twitter and Hacker News and we’ve even gotten multiple premature submissions for it. That’d be a clear case of an app that will reach the threshold in no time so that’s a PR we won’t close immediately (but may wait to merge).
 
-## Homebrew Cask is not a discoverability service
+Note that none of these exceptions is a guarantee for inclusion, but examples of situations where we may take a second look.
 
-From the inception of Homebrew Cask, various requests fell under the umbrella of this reply. Though a somewhat popular request, after careful consideration on multiple occasions we’ve always come back to the same conclusion: we’re not a discoverability service and our users are expected to have reasonable knowledge about the apps they’re installing through us before doing so. For example, [grouping casks by categories](https://github.com/Homebrew/homebrew-cask/issues/5425) is not within the scope of the project.
+## Not a fork (usually)
 
-Amongst other things, the logistics of such requests are unsustainable for Homebrew Cask. Before making a request of this nature, you must read through previous related issues, as well as any other issues they link to, to get a full understanding of why that is the case, and why “but project *x* does *y*” arguments aren’t applicable, and not every package manager is the same.
+We will not add new casks using forks unless at least one of the following is true:
 
-You should also be able to present clear actionable fixes to those concerns. Simply asking for it without solutions will get your issue closed.
+* the fork has been designated the official successor in the original source repository (e.g. in the README) or in a publicly verifiable way by the original author (e.g. in an issue or pull request comment)
+* the fork has been used as the replacement by at least two other major distributions (e.g. Debian, Fedora, Arch, Gentoo, not smaller Linux distributions that are not widely used)
 
-However, there is a difference between discoverability (finding new apps you didn’t know about) and searchability (identifying the app you know about and want to install). While the former is unlikely to ever become part of our goals, the latter is indeed important to us, and we continue to work on it.
+The fork should still meet all the other acceptable casks requirements (including those of e.g. popularity and self-submission).
 
-## Rejected Casks
+An alternative to the fork replacing the original cask is a new cask. For example, if `MikeMcQuaid` forked `google-chrome` and it was very popular: a `mikemcquaid-google-chrome` cask might make sense.
 
-Before submitting a Cask to any of our repos, you must read [our documentation on acceptable Casks](#finding-a-home-for-your-cask) and perform a (at least quick) search to see if there were any previous attempts to introduce it.
+## Homebrew Cask is not a discoverability service
 
-Common reasons to reject a Cask entirely:
+From the inception of Homebrew Cask, various requests have fallen under the umbrella of this reply. Though a somewhat popular request, after careful consideration on multiple occasions we’ve always come back to the same conclusion: we’re not a discoverability service and our users are expected to have reasonable knowledge about the apps they’re installing through us before doing so. For example, [grouping casks by categories](https://github.com/Homebrew/homebrew-cask/issues/5425) is not within the scope of the project.
 
-+ We have strong reasons to believe including the Cask can put the whole project at risk. Happened only once so far, [with Popcorn Time](https://github.com/Homebrew/homebrew-cask/pull/3954).
-+ The Cask is unreasonably difficult to maintain. Examples once included [Audacity](https://github.com/Homebrew/homebrew-cask/pull/27517) and [older Java development Casks](https://github.com/Homebrew/homebrew-cask/issues/57387).
-+ The app is a trial version, and the only way to acquire the full version is through the Mac App Store.
-  + Similarly (and trickier to spot), the app has moved to the Mac App Store but still provides old versions via direct download. We reject these in all official repos so users don’t get stuck using an old version, wrongly thinking they’re using the most up-to-date one (which, amongst other things, might be a security risk).
-+ The app is both open-source and CLI-only (i.e. it only uses the `binary` artifact). In that case, and [in the spirit of deduplication](https://github.com/Homebrew/homebrew-cask/issues/15603), submit it first to [Homebrew/core](https://github.com/Homebrew/homebrew-core) as a formula that builds from source. If it is rejected, you may then try again as a cask (link us to the issue so we can see the discussion and reasoning for rejection).
-+ The app is open-source and has a GUI but no compiled versions (or only old ones) are provided. It’s better to have them in [Homebrew/core](https://github.com/Homebrew/homebrew-core) so users don’t get perpetually outdated versions. See [`gedit`](https://github.com/Homebrew/homebrew-cask/pull/23360) for example.
-+ The app has been rejected before due to an issue we cannot fix, and the new submission doesn’t fix that. An example would be [the first submission of `soapui`](https://github.com/Homebrew/homebrew-cask/pull/4939), whose installation problems were not fixed in the two subsequent submissions ([#9969](https://github.com/Homebrew/homebrew-cask/pull/9969), [#10606](https://github.com/Homebrew/homebrew-cask/pull/10606)).
-+ The Cask is a duplicate. These submissions mostly occur when the [token reference](https://docs.brew.sh/Cask-Cookbook#token-reference) was not followed.
-+ The download URL for the app is both behind a login/registration form and from a host that differs from the homepage, meaning users can’t easily verify its authenticity.
-+ The Cask is for an unmaintained app (no releases in the last year, or [explicitly discontinued](https://github.com/Homebrew/homebrew-cask/pull/22699)).
-+ The Cask is for an app that is too obscure. Examples:
-  + An app from a code repository that is not notable enough (under 30 forks, 30 watchers, 75 stars).
-  + [Electronic Identification (eID) software](https://github.com/Homebrew/homebrew-cask/issues/59021).
-+ The Cask is for an app with no information on the homepage (example: a GitHub repository without a README).
-+ The author has [specifically asked us not to include it](https://github.com/Homebrew/homebrew-cask/pull/5342).
-+ The Cask requires [SIP to be disabled](https://github.com/Homebrew/homebrew-cask/pull/41890) to be installed and/or used.
-+ The Cask is a `pkg` that requires [`allow_untrusted: true`](https://docs.brew.sh/Cask-Cookbook#pkg-allow_untrusted).
+Amongst other things, the logistics of such requests are unsustainable for Homebrew Cask. Before making a request of this nature, you must read through previous related issues, as well as any other issues they link to, to get a full understanding of why that is the case, and why “but project *x* does *y*” arguments aren’t applicable, and how not every package manager is the same.
 
-Common reasons to reject a Cask from the main repo:
+You should also be able to present clear actionable fixes to those concerns. Simply asking for it without solutions will get your issue closed.
 
-+ The cask was submitted to the wrong repo. When drafting a cask, consult “[Finding a Home For Your Cask](#finding-a-home-for-your-cask)” to see where it belongs.
+However, there is a difference between discoverability (finding new apps you didn’t know about) and searchability (identifying the app you know about and want to install). While the former is unlikely to ever become part of our goals, the latter is indeed important to us, and we continue to work on it.
 
-## No cask is guaranteed to be accepted
+## Rejected Casks
 
-Follow the guidelines above and your submission has a great chance of being accepted. But remember documentation tends to lag behind current decision-making and we can’t predict every case. Maintainers may override these rules when experience tells us it will lead to a better overall Homebrew.
+Before submitting a cask to any of our repositories, you must read our [documentation on acceptable casks](#finding-a-home-for-your-cask) and perform a (at least quick) search to see if there were any previous attempts to introduce it.
+
+Common reasons to reject a cask entirely:
+
+* App fails with GateKeeper enabled on Homebrew supported macOS versions and platforms (e.g. unsigned apps fail on Macs with Apple Silicon/ARM).
+* App is too obscure. Examples:
+  * An app from a code repository that is not notable enough (under 30 forks, 30 watchers, 75 stars).
+  * [Electronic Identification (eID) software](https://github.com/Homebrew/homebrew-cask/issues/59021).
+* App requires [SIP to be disabled](https://github.com/Homebrew/homebrew-cask/pull/41890) to be installed and/or used.
+* App installer is a `pkg` that requires [`allow_untrusted: true`](https://docs.brew.sh/Cask-Cookbook#pkg-allow_untrusted).
+* App is a trial version, and the only way to acquire the full version is through the Mac App Store.
+  * Similarly (and trickier to spot), the app has moved to the Mac App Store but still provides old versions via direct download. We reject these in all official repositories so users don’t get stuck using an old version, wrongly thinking they’re using the most up-to-date one (which, amongst other things, might be a security risk).
+* App is unmaintained, i.e. no releases in the last year, or [explicitly discontinued](https://github.com/Homebrew/homebrew-cask/pull/22699).
+* App has no information on its homepage (example: a GitHub repository without a README).
+* Cask has no public presence so `brew install` would be the only way to install the software, meaning users can’t easily verify its authenticity.
+  * Or if the Cask has a download URL that is both behind a login/registration form and from a host that differs from the homepage.
+* Cask is unreasonably difficult to maintain. Examples have included [Audacity](https://github.com/Homebrew/homebrew-cask/pull/27517) and [older Java development casks](https://github.com/Homebrew/homebrew-cask/issues/57387).
+* Cask has been rejected before due to an issue we cannot fix, and the new submission doesn’t fix that. An example would be the [first submission of `soapui`](https://github.com/Homebrew/homebrew-cask/pull/4939), whose installation problems were not fixed in the two [subsequent](https://github.com/Homebrew/homebrew-cask/pull/9969) [submissions](https://github.com/Homebrew/homebrew-cask/pull/10606).
+* Cask is a duplicate. These submissions mostly occur when the [token reference](https://docs.brew.sh/Cask-Cookbook#token-reference) was not followed.
+* The author has [specifically asked us not to include it](https://github.com/Homebrew/homebrew-cask/pull/5342).
+* App is both open-source and CLI-only (i.e. it only uses the `binary` artifact). In that case, and [in the spirit of deduplication](https://github.com/Homebrew/homebrew-cask/issues/15603), submit it first to [homebrew/core](https://github.com/Homebrew/homebrew-core) as a formula that builds from source. If it is rejected, you may then try again as a cask (link to the issue from your pull request so we can see the discussion and reasoning for rejection).
+* App is open-source and has a GUI but no compiled versions (or only old ones) are provided. It’s better to have them in [homebrew/core](https://github.com/Homebrew/homebrew-core) so users don’t get perpetually outdated versions. See [`gedit`](https://github.com/Homebrew/homebrew-cask/pull/23360) for example.
+* We have strong reasons to believe including the cask can put the whole project at risk. Happened only once so far, [with Popcorn Time](https://github.com/Homebrew/homebrew-cask/pull/3954).
+
+Common reasons to reject a cask from the main `homebrew/cask` repository:
+
+* Cask was submitted to the wrong repository. When drafting a cask, consult [Finding a Home For Your Cask](#finding-a-home-for-your-cask) to see where it belongs.
+
+### No cask is guaranteed to be accepted
+
+Follow the guidelines above and your submission has a great chance of being accepted. But remember that documentation tends to lag behind current decision-making and we can’t predict every case. Maintainers may override these rules when experience tells us it will lead to a better overall Homebrew.
diff --git a/docs/Acceptable-Formulae.md b/docs/Acceptable-Formulae.md
index 40b5c6246769f..77e3a88f1cbb2 100644
--- a/docs/Acceptable-Formulae.md
+++ b/docs/Acceptable-Formulae.md
@@ -1,91 +1,104 @@
 # Acceptable Formulae
 
-Some formulae should not go in
-[homebrew/core](https://github.com/Homebrew/homebrew-core). But there are
-additional [Interesting Taps and Forks](Interesting-Taps-and-Forks.md) and anyone can start their
-own!
+Some formulae should not go in [homebrew/core](https://github.com/Homebrew/homebrew-core). But there are additional [Interesting Taps and Forks](Interesting-Taps-and-Forks.md) and anyone can [start their own](How-to-Create-and-Maintain-a-Tap.md)!
 
-### Supported platforms in `homebrew/core`
+* Table of Contents
+{:toc}
 
-The formula needs to build and pass tests on the latest 3 supported macOS versions ([x86_64 and Apple Silicon/ARM](Installation.md#macos-requirements)) and on x86_64 Linux.
-Please have a look at the continuous integration jobs on a pull request in `homebrew/core` to see the full list of OSs.
-If upstream does not support one of these platforms, an exception can be made and the formula can be disabled for that platform.
+## Requirements for `homebrew/core`
+
+### Supported platforms
+
+The formula needs to build and pass tests on the latest 3 supported macOS versions ([x86_64 and Apple Silicon/ARM](Installation.md#macos-requirements)) and on x86_64 [Linux](Linux-CI.md). Please have a look at the continuous integration jobs on a pull request in `homebrew/core` to see the full list of OSs. If upstream does not support one of these platforms, an exception can be made and the formula can be disabled for that platform.
+
+### Duplicates of system packages
 
-### Dupes in `homebrew/core`
 We now accept stuff that comes with macOS as long as it uses `keg_only :provided_by_macos` to be keg-only by default.
 
-### Versioned formulae in `homebrew/core`
+### Versioned formulae
+
 We now accept versioned formulae as long as they [meet the requirements](Versions.md).
 
+### Not a fork (usually)
+
+We will not add new formulae using forks unless at least one of the following is true:
+
+* the fork has been designated the official successor in the original source repository (e.g. in the README) or in a publicly verifiable way by the original author (e.g. in an issue or pull request comment)
+* the fork has been used as the replacement by at least two other major distributions (e.g. Debian, Fedora, Arch, Gentoo, not smaller Linux distributions that are not widely used)
+
+The fork must still meet all the other acceptable formulae requirements (including those of e.g. popularity and self-submission).
+
+An alternative to the fork replacing the original formula is a new formula. For example, if `MikeMcQuaid` forked `curl` and it was very popular: a `curl-mikemcquaid` formula might make sense.
+
 ### We don’t like tools that upgrade themselves
-Software that can upgrade itself does not integrate well with Homebrew's own
-upgrade functionality. The self-update functionality should be disabled (while minimising complication to the formula).
+
+Software that can upgrade itself does not integrate well with Homebrew formulae's own upgrade functionality. The self-update functionality should be disabled (while minimising complication to the formula). It's fine (and well-supported) for Casks.
 
 ### We don’t like install scripts that download unversioned things
-We don't like install scripts that are pulling from the `master` branch of Git repositories or unversioned, unchecksummed tarballs. These should use `resource` blocks with specific revisions or checksummed tarballs instead. Note that we now allow tools like `cargo`, `gem` and `pip` to download specifically versioned libraries during installation.
+
+We don't like install scripts that are pulling from the master branch of Git repositories or unversioned, unchecksummed tarballs. These should ideally use `resource` blocks with specific revisions or checksummed tarballs instead. Note that we now allow tools like `cargo`, `gem` and `pip` to download versioned libraries during installation. There's no need to reproduce the functionality of any language package manager with `resource` blocks when we can call it instead.
 
 ### We don’t like binary formulae
-Our policy is that formulae in the core tap
-([homebrew/core](https://github.com/Homebrew/homebrew-core)) must be open-source
-with an [Debian Free Software Guidelines license](https://wiki.debian.org/DFSGLicenses) and either built
-from source or produce cross-platform binaries (e.g. Java, Mono). Binary-only
-formulae should go to [homebrew/cask](https://github.com/Homebrew/homebrew-cask).
 
-Additionally, [homebrew/core](https://github.com/Homebrew/homebrew-core) formulae must also not depend on casks or any other proprietary software.
+Our policy is that formulae in the core tap ([homebrew/core](https://github.com/Homebrew/homebrew-core)) must be open-source with a [Debian Free Software Guidelines license](https://wiki.debian.org/DFSGLicenses) and either built from source or producing cross-platform binaries (e.g. Java, Mono). Binary-only formulae should go in [homebrew/cask](https://github.com/Homebrew/homebrew-cask).
 
-This includes automatic installation of casks at runtime.
+Additionally, core formulae must also not depend on casks or any other proprietary software. This includes automatic installation of casks at runtime.
 
 ### Stable versions
-Formulae in the core repository must have a stable version tagged by
-the upstream project. Tarballs are preferred to Git checkouts, and
-tarballs should include the version in the filename whenever possible.
 
-We don’t accept software without a tagged version because they regularly break
-due to upstream changes and we can’t provide [bottles](Bottles.md) for them.
+Formulae in the core repository must have a stable version tagged by the upstream project. Tarballs are preferred to Git checkouts, and tarballs should include the version in the filename whenever possible.
+
+We don’t accept software without a tagged version because they regularly break due to upstream changes and we can’t provide [bottles](Bottles.md) for them.
 
 ### Niche (or self-submitted) stuff
+
 The software in question must:
 
 * be maintained (i.e. the last release wasn't ages ago, it works without patching on all Homebrew-supported OS versions and has no outstanding, unpatched security vulnerabilities)
-* be known
 * be stable (e.g. not declared "unstable" or "beta" by upstream)
+* be known (e.g. GitHub repositories should have >=30 forks, >=30 watchers or >=75 stars)
 * be used
 * have a homepage
 
-We will reject formulae that seem too obscure, partly because they won’t
-get maintained and partly because we have to draw the line somewhere.
+We will reject formulae that seem too obscure, partly because they won’t get maintained and partly because we have to draw the line somewhere.
 
 We frown on authors submitting their own work unless it is very popular.
 
-Don’t forget Homebrew is all Git underneath!
-[Maintain your own tap](How-to-Create-and-Maintain-a-Tap.md) if you have to!
+Don’t forget Homebrew is all Git underneath! [Maintain your own tap](How-to-Create-and-Maintain-a-Tap.md) if you have to!
 
-There may be exceptions to these rules in the main repository; we may
-include things that don't meet these criteria or reject things that do.
-Please trust that we need to use our discretion based on our experience
-running a package manager.
+There may be exceptions to these rules in the main repository; we may include things that don't meet these criteria or reject things that do. Please trust that we need to use our discretion based on our experience running a package manager.
 
 ### Stuff that builds an `.app`
-Don’t make your formula build an `.app` (native macOS Application); we
-don’t want those things in Homebrew. Encourage upstream projects to build and support a `.app` that can be distributed by [homebrew/cask](https://github.com/Homebrew/homebrew-cask) (and used without it, too).
+
+Don’t make your formula build an `.app` (native macOS Application); we don’t want those things in Homebrew. Encourage upstream projects to build and support a `.app` that can be distributed by [homebrew/cask](https://github.com/Homebrew/homebrew-cask) (and used without it, too).
 
 ### Stuff that builds a GUI by default (but doesn't have to)
+
 Make it build a command-line tool or a library by default and, if the GUI is useful and would be widely used, also build the GUI. Don’t build X11/XQuartz GUIs as they are a bad user experience on macOS.
 
 ### Stuff that doesn't build with the latest, stable Xcode Clang
+
 Clang is the default C/C++ compiler on macOS (and has been for a long time). Software that doesn't build with it hasn't been adequately ported to macOS.
 
 ### Stuff that requires heavy manual pre/post-install intervention
+
 We're a package manager so we want to do things like resolve dependencies and set up applications for our users. If things require too much manual intervention then they aren't useful in a package manager.
 
-## Stuff that requires vendored versions of Homebrew formulae
-Homebrew formulae should avoid having multiple, separate, upstream projects bundled together in a single package to avoid shipping outdated/insecure versions of software that is already a formula. Veracode's [State of Software Security report](https://www.veracode.com/blog/research/announcing-state-software-security-v11-open-source-edition) concludes
+### Shared vs. static libraries
+
+In general, if formulae have to ship either shared or static libraries: they should ship shared ones.
+If there is interest in static libraries they can ship both.
+Shipping only static libraries should be avoided when possible, particularly when the formula is depended on by other formulae since these dependents cannot be updated without a rebuild.
+
+### Stuff that requires vendored versions of Homebrew formulae
+
+Homebrew formulae should avoid having multiple, separate, upstream projects bundled together in a single package to avoid shipping outdated/insecure versions of software that is already a formula. Veracode's [State of Software Security report](https://www.veracode.com/blog/research/announcing-state-software-security-v11-open-source-edition) concludes:
 > In fact, 79% of the time, developers never update third-party libraries after including them in a codebase.
 
 For more info see [Debian's](https://www.debian.org/doc/debian-policy/ch-source.html#s-embeddedfiles) and [Fedora's](https://docs.fedoraproject.org/en-US/packaging-guidelines/#bundling) stances on this.
 
-### Sometimes there are exceptions
-Even if all criteria are met we may not accept the formula.
-Documentation tends to lag behind current decision-making. Although some
-rejections may seem arbitrary or strange they are based on years of
-experience making Homebrew work acceptably for our users.
+Increasingly, though: this can be (too) hard. Homebrew's primary mission is to be useful rather than ideologically pure. If we cannot package something without using vendored upstream versions: so be it; better to have packaged software in Homebrew than not.
+
+## Sometimes there are exceptions
+
+Even if all criteria are met we may not accept the formula. Even if some criteria are not met we may accept the formula. New formulae are held to a higher standard than existing formulae. Documentation will lag behind current decision-making. Although some rejections may seem arbitrary or strange they are based on years of experience making Homebrew work acceptably for our users.
diff --git a/docs/Adding-Software-to-Homebrew.md b/docs/Adding-Software-to-Homebrew.md
index 9ea5eb2ed2c11..b54c020686ebd 100644
--- a/docs/Adding-Software-to-Homebrew.md
+++ b/docs/Adding-Software-to-Homebrew.md
@@ -1,8 +1,8 @@
-# Adding Software To Homebrew
+# Adding Software to Homebrew
 
-Is your favorite software missing from Homebrew? Then you're the perfect person to resolve this problem.
+Is your favourite software missing from Homebrew? Then you're the perfect person to resolve this problem.
 
-If you want to add software that is either closed source or a GUI-only program, you will want to follow the guide for [Casks](#casks). Otherwise follow the guide for [Formulae](#formulae). See also: [Homebrew Terminology](Formula-Cookbook.md#homebrew-terminology)
+If you want to add software that is either closed source or a GUI-only program, you will want to follow the guide for [Casks](#casks). Otherwise follow the guide for [Formulae](#formulae) (see also: [Homebrew Terminology](Formula-Cookbook.md#homebrew-terminology)).
 
 Before you start, please check the open pull requests for [Homebrew/homebrew-core](https://github.com/Homebrew/homebrew-core/pulls) or [Homebrew/homebrew-cask](https://github.com/Homebrew/homebrew-cask/pulls) to make sure no one else beat you to the punch.
 
@@ -14,7 +14,7 @@ If everything checks out, you're ready to get started on a new formula!
 
 ### Writing the formula
 
-1. It's a good idea to find existing formulae in Homebrew that have similarities to the software you want to add. This will help you to understand how specific languages, build methods, etc. are typically handled.
+1. It's a good idea to find existing formulae in Homebrew that have similarities to the software you want to add. This will help you to understand how specific languages, build methods, etc. are typically handled. Start by tapping `homebrew/core`: first set `HOMEBREW_NO_INSTALL_FROM_API=1` in your shell environment, then run `brew tap --force homebrew/core` to clone the `homebrew/core` tap to the path returned by `brew --repository homebrew/core`.
 
 1. If you're starting from scratch, you can use the [`brew create` command](Manpage.md#create-options-url) to produce a basic version of your formula. This command accepts a number of options and you may be able to save yourself some work by using an appropriate template option like `--python`.
 
@@ -22,19 +22,19 @@ If everything checks out, you're ready to get started on a new formula!
 
 1. Make sure you write a good test as part of your formula. Refer to the [Add a test to the formula](Formula-Cookbook.md#add-a-test-to-the-formula) section of the Cookbook for help with this.
 
-1. Try installing your formula using `brew install --build-from-source <formula>`, where \<formula> is the name of your formula. If any errors occur, correct your formula and attempt to install it again. The formula installation should finish without errors by the end of this step.
+1. Try installing your formula using `brew install --build-from-source <formula>`, where *\<formula>* is the name of your formula. If any errors occur, correct your formula and attempt to install it again. The formula installation should finish without errors by the end of this step.
 
-If you're stuck, ask for help on GitHub or [Homebrew/discussions](https://github.com/homebrew/discussions/discussions). The maintainers are very happy to help but we also like to see that you've put effort into trying to find a solution first.
+If you're stuck, ask for help on GitHub or the [Homebrew discussion forum](https://github.com/orgs/Homebrew/discussions). The maintainers are very happy to help but we also like to see that you've put effort into trying to find a solution first.
 
 ### Testing and auditing the formula
 
-1. Run `brew audit --strict --new-formula --online <formula>` with your formula. If any errors occur, correct your formula and run the audit again. The audit should finish without any errors by the end of this step.
+1. Run `brew audit --strict --new --online <formula>` with your formula. If any errors occur, correct your formula and run the audit again. The audit should finish without any errors by the end of this step.
 
 1. Run your formula's test using `brew test <formula>`. The test should finish without any errors.
 
 ### Submitting the formula
 
-You're finally ready to submit your formula to the [homebrew-core](https://github.com/Homebrew/homebrew-core/) repository. If you haven't done this before, you can refer to the [How to Open a Pull Request](How-To-Open-a-Homebrew-Pull-Request.md) documentation for help. Maintainers will review the pull request and provide feedback about any areas that need to be addressed before the formula can be added to Homebrew.
+You're finally ready to submit your formula to the [homebrew-core](https://github.com/Homebrew/homebrew-core) repository. If you haven't done this before, you can refer to the [How to Open a Homebrew Pull Request](How-To-Open-a-Homebrew-Pull-Request.md#formulae-related-pull-request) documentation for help. Maintainers will review the pull request and provide feedback about any areas that need to be addressed before the formula can be added to Homebrew.
 
 If you've made it this far, congratulations on submitting a Homebrew formula! We appreciate the hard work you put into this and you can take satisfaction in knowing that your work may benefit other Homebrew users as well.
 
@@ -47,72 +47,101 @@ If you've made it this far, congratulations on submitting a Homebrew formula! We
 
 ### Writing the cask
 
-Making a new cask is easy. Follow the directions in [Getting Set Up To Contribute](https://github.com/Homebrew/homebrew-cask/blob/HEAD/CONTRIBUTING.md#getting-set-up-to-contribute) to begin.
+Making a new cask is easy. Follow the directions in [How to Open a Homebrew Pull Request](How-To-Open-a-Homebrew-Pull-Request.md#cask-related-pull-request) to begin.
 
 #### Examples
 
-Here’s a cask for `shuttle` as an example. Note the `verified` parameter below the `url`, which is needed when [the url and homepage hostnames differ](Cask-Cookbook.md#when-url-and-homepage-domains-differ-add-verified).
+Here’s a cask for `dixa` as an example. Note the `verified` parameter below the `url`, which is needed when [the url and homepage hostnames differ](Cask-Cookbook.md#when-url-and-homepage-domains-differ-add-verified).
 
 ```ruby
-cask "shuttle" do
-  version "1.2.9"
-  sha256 "0b80bf62922291da391098f979683e69cc7b65c4bdb986a431e3f1d9175fba20"
+cask "dixa" do
+  version "4.0.12"
+  sha256 "a4e1a30d074e724ba24e9e2674a72bc4050f00161fb7dc23295a2c189ecda5bb"
 
-  url "https://github.com/fitztrev/shuttle/releases/download/v#{version}/Shuttle.zip",
-      verified: "github.com/fitztrev/shuttle/"
-  name "Shuttle"
-  desc "Simple shortcut menu"
-  homepage "https://fitztrev.github.io/shuttle/"
+  url "https://github.com/dixahq/dixa-desktop-app-release/releases/download/v#{version}/dixa-#{version}.dmg",
+      verified: "github.com/dixahq/dixa-desktop-app-release/"
+  name "Dixa"
+  desc "Customer service platform"
+  homepage "https://dixa.com/"
 
-  app "Shuttle.app"
+  livecheck do
+    url :url
+    strategy :github_latest
+  end
+
+  app "Dixa.app"
 
-  zap trash: "~/.shuttle.json"
+  zap trash: [
+    "~/Library/Application Support/Dixa",
+    "~/Library/Logs/Dixa",
+    "~/Library/Preferences/dixa.plist",
+    "~/Library/Saved Application State/dixa.savedState",
+  ]
 end
 ```
 
-And here is one for `noisy`. Note that it has an unversioned download (the download `url` does not contain the version number, unlike the example above). It also suppresses the checksum with `sha256 :no_check`, which is necessary because since the download `url` does not contain the version number, its checksum will change when a new version is made available.
+And here is one for `pomello`. Note that it has an unversioned download (the download `url` does not contain the version number, unlike the example above). It also suppresses the checksum with `sha256 :no_check`, which is necessary because since the download `url` does not contain the version number, its checksum will change when a new version is made available.
 
 ```ruby
-cask "noisy" do
-  version "1.3"
+cask "pomello" do
+  version "0.10.17"
   sha256 :no_check
 
-  url "https://github.com/downloads/jonshea/Noisy/Noisy.zip"
-  name "Noisy"
-  desc "White noise generator"
-  homepage "https://github.com/jonshea/Noisy"
+  url "https://pomelloapp.com/download/mac/latest"
+  name "Pomello"
+  desc "Turns your Trello cards into Pomodoro tasks"
+  homepage "https://pomelloapp.com/"
+
+  livecheck do
+    url :url
+    strategy :header_match
+  end
+
+  app "Pomello.app"
 
-  app "Noisy.app"
+  zap trash: [
+    "~/Library/Application Support/com.apple.sharedfilelist/com.apple.LSSharedFileList.ApplicationRecentDocuments/com.tinynudge.pomello.*",
+    "~/Library/Application Support/Pomello",
+    "~/Library/Caches/com.tinynudge.pomello",
+    "~/Library/Caches/com.tinynudge.pomello.ShipIt",
+    "~/Library/HTTPStorages/com.tinynudge.pomello",
+    "~/Library/Preferences/com.tinynudge.pomello.plist",
+    "~/Library/Saved Application State/com.tinynudge.pomello.savedState",
+  ]
 end
 ```
 
-Here is a last example for `airdisplay`, which uses a `pkg` installer to install the application instead of a stand-alone application bundle (`.app`). Note the [`uninstall pkgutil` stanza](Cask-Cookbook.md#uninstall-key-pkgutil), which is needed to uninstall all files that were installed using the installer.
+Here is a last example for `fabfilter-one`, which uses a `pkg` installer to install the application instead of a stand-alone application bundle (`.app`). Note the [`uninstall pkgutil` stanza](Cask-Cookbook.md#uninstall-pkgutil), which is needed to uninstall all files that were installed using the installer.
 
 You will also see how to adapt `version` to the download `url`. Use [our custom `version` methods](Cask-Cookbook.md#version-methods) to do so, resorting to the standard [Ruby String methods](https://ruby-doc.org/core/String.html) when they don’t suffice.
 
 ```ruby
-cask "airdisplay" do
-  version "3.4.2,26581"
-  sha256 "272d14f33b3a4a16e5e0e1ebb2d519db4e0e3da17f95f77c91455b354bee7ee7"
+cask "fabfilter-one" do
+  version "3.37"
+  sha256 "4059594580e365237ded16a213d8d549cbb01c4b8bad80895c61f44bcff7eb68"
 
-  url "https://www.avatron.com/updates/software/airdisplay/ad#{version.before_comma.no_dots}.zip"
-  name "Air Display"
-  desc "Utility for using a tablet as a second monitor"
-  homepage "https://avatron.com/applications/air-display/"
+  url "https://download.fabfilter.com/ffone#{version.no_dots}.dmg"
+  name "FabFilter One"
+  desc "Synthesizer plug-in"
+  homepage "https://www.fabfilter.com/products/volcano-2-powerful-filter-plug-in"
 
   livecheck do
-    url "https://www.avatron.com/updates/software/airdisplay/appcast.xml"
-    strategy :sparkle
+    url "https://www.fabfilter.com/download"
+    strategy :page_match do |page|
+      match = page.match(/ffone(\d)(\d+)\.dmg/i)
+      next if match.blank?
+
+      "#{match[1]}.#{match[2]}"
+    end
   end
 
-  depends_on macos: ">= :mojave"
+  depends_on macos: ">= :sierra"
 
-  pkg "Air Display Installer.pkg"
+  pkg "FabFilter One #{version} Installer.pkg"
 
-  uninstall pkgutil: [
-    "com.avatron.pkg.AirDisplay",
-    "com.avatron.pkg.AirDisplayHost2",
-  ]
+  uninstall pkgutil: "com.fabfilter.One.#{version.major}"
+
+  # No zap stanza required
 end
 ```
 
@@ -120,7 +149,7 @@ end
 
 The cask **token** is the mnemonic string people will use to interact with the cask via `brew install`, etc. The name of the cask **file** is simply the token with the extension `.rb` appended.
 
-The easiest way to generate a token for a cask is to run this command:
+The easiest way to generate a token for a cask is to run `generate_cask_token`:
 
 ```bash
 $(brew --repository homebrew/cask)/developer/bin/generate_cask_token "/full/path/to/new/software.app"
@@ -136,27 +165,13 @@ If the `generate_cask_token` script does not work for you, see [Cask Token Detai
 
 #### Creating the cask file
 
-Once you know the token, create your cask with the handy-dandy `brew create --cask` command:
+Once you know the token, create your cask with the `brew create --cask` command:
 
 ```bash
 brew create --cask download-url --set-name my-new-cask
 ```
 
-This will open `$EDITOR` with a template for your new cask, to be stored in the file `my-new-cask.rb`. Running the `create` command above will get you a template that looks like this:
-
-```ruby
-cask "my-new-cask" do
-  version ""
-  sha256 ""
-
-  url "download-url"
-  name ""
-  desc ""
-  homepage ""
-
-  app ""
-end
-```
+This will open `EDITOR` with a template for your new cask, to be stored in the file `my-new-cask.rb`.
 
 #### Cask stanzas
 
@@ -164,29 +179,29 @@ Fill in the following stanzas for your cask:
 
 | name               | value       |
 | ------------------ | ----------- |
-| `version`          | application version
-| `sha256`           | SHA-256 checksum of the file downloaded from `url`, calculated by the command `shasum -a 256 <file>`. Can be suppressed by using the special value `:no_check`. (see [`sha256` Stanza Details](Cask-Cookbook.md#stanza-sha256))
-| `url`              | URL to the `.dmg`/`.zip`/`.tgz`/`.tbz2` file that contains the application.<br />A [`verified` parameter](Cask-Cookbook.md#when-url-and-homepage-domains-differ-add-verified) must be added if the hostnames in the `url` and `homepage` stanzas differ. [Block syntax](Cask-Cookbook.md#using-a-block-to-defer-code-execution) is available for URLs that change on every visit
-| `name`             | the full and proper name defined by the vendor, and any useful alternate names (see [`name` Stanza Details](Cask-Cookbook.md#stanza-name))
-| `desc`             | one-line description of the software (see [`desc` Stanza Details](Cask-Cookbook.md#stanza-desc))
-| `homepage`         | application homepage; used for the `brew home` command
-| `app`              | relative path to an `.app` bundle that should be moved into the `/Applications` folder on installation (see [`app` Stanza Details](Cask-Cookbook.md#stanza-app))
+| `version`          | application version |
+| `sha256`           | SHA-256 checksum of the file downloaded from `url`, calculated by the command `shasum -a 256 <file>`. Can be suppressed by using the special value `:no_check`. (see [`sha256` Stanza Details](Cask-Cookbook.md#stanza-sha256)) |
+| `url`              | URL to the `.dmg`/`.zip`/`.tgz`/`.tbz2` file that contains the application.<br />A [`verified` parameter](Cask-Cookbook.md#when-url-and-homepage-domains-differ-add-verified) must be added if the hostnames in the `url` and `homepage` stanzas differ. [Block syntax](Cask-Cookbook.md#using-a-block-to-defer-code-execution) is available for URLs that change on every visit. |
+| `name`             | the full and proper name defined by the vendor, and any useful alternate names (see [`name` Stanza Details](Cask-Cookbook.md#stanza-name)) |
+| `desc`             | one-line description of the software (see [`desc` Stanza Details](Cask-Cookbook.md#stanza-desc)) |
+| `homepage`         | application homepage; used for the `brew home` command |
+| `livecheck`        | Ruby block describing how to find updates for this cask (see [`livecheck` Stanza Details](Cask-Cookbook.md#stanza-livecheck)) |
+| `app`              | relative path to an `.app` bundle that should be moved into the `/Applications` folder on installation (see [`app` Stanza Details](Cask-Cookbook.md#stanza-app)) |
+| `zap`              | additional procedures for a more complete uninstall, including configuration files and shared resources (see [`zap` Stanza Details](Cask-Cookbook.md#stanza-zap)) |
 
 Other commonly used stanzas are:
 
 | name               | value       |
 | ------------------ | ----------- |
-| `livecheck`        | Ruby block describing how to find updates for this cask (see [`livecheck` Stanza Details](Cask-Cookbook.md#stanza-livecheck))
-| `pkg`              | relative path to a `.pkg` file containing the distribution (see [`pkg` Stanza Details](Cask-Cookbook.md#stanza-pkg))
-| `caveats`          | a string or Ruby block providing the user with cask-specific information at install time (see [`caveats` Stanza Details](Cask-Cookbook.md#stanza-caveats))
-| `uninstall`        | procedures to uninstall a cask. Optional unless the `pkg` stanza is used. (see [`uninstall` Stanza Details](Cask-Cookbook.md#stanza-uninstall))
-| `zap`              | additional procedures for a more complete uninstall, including configuration files and shared resources (see [`zap` Stanza Details](Cask-Cookbook.md#stanza-zap))
+| `pkg`              | relative path to a `.pkg` file containing the distribution (see [`pkg` Stanza Details](Cask-Cookbook.md#stanza-pkg)) |
+| `caveats`          | string or Ruby block providing the user with cask-specific information at install time (see [`caveats` Stanza Details](Cask-Cookbook.md#stanza-caveats)) |
+| `uninstall`        | procedures to uninstall a cask; optional unless the `pkg` stanza is used (see [`uninstall` Stanza Details](Cask-Cookbook.md#stanza-uninstall)) |
 
 Additional [`artifact` stanzas](Cask-Cookbook.md#at-least-one-artifact-stanza-is-also-required) may be needed for special use cases. Even more special-use stanzas are listed at [Optional Stanzas](Cask-Cookbook.md#optional-stanzas).
 
 #### Cask token details
 
-If a token conflicts with an already-existing cask, authors should manually make the new token unique by prepending the vendor name. Example: [unison.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/unison.rb) and [panic-unison.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/panic-unison.rb).
+If a token conflicts with an already-existing cask, authors should manually make the new token unique by prepending the vendor name. Example: [unison.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/u/unison.rb) and [panic-unison.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/p/panic-unison.rb).
 
 If possible, avoid creating tokens that differ only by the placement of hyphens.
 
@@ -198,14 +213,14 @@ When a downloaded archive expands to a subfolder, the subfolder name must be inc
 
 Example:
 
-1. Texmaker is downloaded to the file `TexmakerMacosxLion.zip`.
-1. `TexmakerMacosxLion.zip` unzips to a folder called `TexmakerMacosxLion`.
-1. The folder `TexmakerMacosxLion` contains the application `texmaker.app`.
+1. Simple Floating Clock is downloaded to the file `sfc.zip`.
+1. `sfc.zip` unzips to a folder called `Simple Floating Clock`.
+1. The folder `Simple Floating Clock` contains the application `SimpleFloatingClock.app`.
 1. So, the `app` stanza should include the subfolder as a relative path:
 
-  ```ruby
-  app "TexmakerMacosxLion/texmaker.app"
-  ```
+   ```ruby
+app "Simple Floating Clock/SimpleFloatingClock.app"
+   ```
 
 ### Testing and auditing the cask
 
@@ -213,6 +228,7 @@ Give it a shot with:
 
 ```bash
 export HOMEBREW_NO_AUTO_UPDATE=1
+export HOMEBREW_NO_INSTALL_FROM_API=1
 brew install my-new-cask
 ```
 
@@ -227,7 +243,7 @@ brew uninstall my-new-cask
 If everything looks good, you’ll also want to make sure your cask passes audit with:
 
 ```bash
-brew audit --new-cask my-new-cask
+brew audit --new --cask my-new-cask
 ```
 
 You should also check stylistic details with `brew style`:
@@ -246,21 +262,20 @@ If your application and Homebrew Cask do not work well together, feel free to [f
 
 See the [Acceptable Casks documentation](Acceptable-Casks.md#finding-a-home-for-your-cask).
 
-Hop into your Tap and check to make sure your new cask is there:
+Hop into your tap and check to make sure your new cask is there:
 
-```bash
+```console
 $ cd "$(brew --repository)"/Library/Taps/homebrew/homebrew-cask
 $ git status
-# On branch master
-# Untracked files:
-#   (use "git add <file>..." to include in what will be committed)
-#
-#       Casks/my-new-cask.rb
+On branch master
+Untracked files:
+  (use "git add <file>..." to include in what will be committed)
+        Casks/m/my-new-cask.rb
 ```
 
 So far, so good. Now make a feature branch `my-new-cask-branch` that you’ll use in your pull request:
 
-```bash
+```console
 $ git checkout -b my-new-cask-branch
 Switched to a new branch 'my-new-cask-branch'
 ```
@@ -268,7 +283,7 @@ Switched to a new branch 'my-new-cask-branch'
 Stage your cask with:
 
 ```bash
-git add Casks/my-new-cask.rb
+git add Casks/m/my-new-cask.rb
 ```
 
 You can view the changes that are to be committed with:
@@ -299,10 +314,10 @@ For cask commits in the Homebrew Cask project, we like to include the applicatio
 
 Examples of good, clear commit summaries:
 
-* `Add Transmission.app v1.0`
-* `Upgrade Transmission.app to v2.82`
-* `Fix checksum in Transmission.app cask`
-* `Add CodeBox Latest`
+* `transmission 1.0 (new cask)`
+* `transmission 2.82`
+* `transmission: fix checksum`
+* `codebox latest (new cask)`
 
 Examples of difficult, unclear commit summaries:
 
@@ -349,8 +364,9 @@ cd "$(brew --repository)"/Library/Taps/homebrew/homebrew-cask
 git checkout master
 ```
 
-If earlier you set the variable `HOMEBREW_NO_AUTO_UPDATE` then clean it up with:
+If earlier you set the variable `HOMEBREW_NO_AUTO_UPDATE` and `HOMEBREW_NO_INSTALL_FROM_API` then clean it up with:
 
 ```bash
 unset HOMEBREW_NO_AUTO_UPDATE
+unset HOMEBREW_NO_INSTALL_FROM_API
 ```
diff --git a/docs/Analytics.md b/docs/Analytics.md
index 558da53b59bc1..d233072fb50c2 100644
--- a/docs/Analytics.md
+++ b/docs/Analytics.md
@@ -1,53 +1,53 @@
-# Anonymous Aggregate User Behaviour Analytics
+# Anonymous Analytics
 
-Homebrew gathers anonymous aggregate user behaviour analytics using Google Analytics. You will be notified the first time you run `brew update` or install Homebrew. Analytics are not enabled until after this notice is shown, to ensure that you can [opt out](Analytics.md#opting-out) without ever sending analytics data.
+Homebrew gathers anonymous analytics using InfluxDB. You will be notified the first time you run `brew update` or install Homebrew. Analytics are not enabled until after this notice is shown, to ensure that you can [opt out](Analytics.md#opting-out) without ever sending analytics data.
 
 ## Why?
 
-Homebrew is provided free of charge and run entirely by volunteers in their spare time. As a result, we do not have the resources to do detailed user studies of Homebrew users to decide on how best to design future features and prioritise current work. Anonymous aggregate user analytics allow us to prioritise fixes and features based on how, where and when people use Homebrew. For example:
+Homebrew is provided free of charge and run entirely by volunteers in their spare time. As a result, we do not have the resources to do detailed user studies of Homebrew users to decide on how best to design future features and prioritise current work. Anonymous analytics allow us to prioritise fixes and features based on how, where and when people use Homebrew. For example:
 
 - If a formula is widely used and is failing often it will enable us to prioritise fixing that formula over others.
 - Collecting the OS version allows us to decide which versions of macOS to prioritise for support and identify build failures that occur only on single versions.
+- If a command is not widely used, it can be deprecated.
 
 ## How Long?
 
-Homebrew's anonymous user and event data have a 14 month retention period. This is the [lowest possible value for Google Analytics](https://support.google.com/analytics/answer/7667196).
+Homebrew's anonymous analytics has a 365 day retention period in InfluxDB.
 
 ## What?
 
-Homebrew's analytics record some shared information for every event:
+Homebrew's analytics record some shared information for every formula or cask event:
 
-- The Homebrew user agent, e.g. `Homebrew/3.3.0 (Macintosh; Intel Mac OS X 10.15.6) curl/7.64.1`.
-- The [Google Analytics version](https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#v), i.e. `1`.
-- The Homebrew [analytics tracking ID](https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#tid), e.g. `UA-75654628-1`.
-- A Homebrew [analytics user ID](https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#cid), e.g. `1BAB65CC-FE7F-4D8C-AB45-B7DB5A6BA9CB`. This is generated by `uuidgen` and stored in the repository-specific Git configuration variable `homebrew.analyticsuuid` within `$(brew --repository)/.git/config`. This does not allow us to track individual users, but does enable us to accurately measure user counts versus event counts. The ID is specific to the Homebrew package manager, and does not permit Homebrew maintainers to e.g. track you across websites you visit.
-- Whether the [Google Analytics anonymous IP setting](https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#aip) is enabled, i.e. `1`.
-- The Homebrew [application name](https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#an), e.g. `Homebrew`.
-- The Homebrew [application version](https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#av), e.g. `2.5.0`.
-- The Homebrew [analytics hit type](https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#t), e.g. `event`.
+- Whether the data is being sent from CI, e.g. `true` if the CI environment variable is set.
+- Whether you are using the default install prefix (e.g. `/opt/homebrew`) or a custom one (e.g. `/home/mike/.brew`). If your prefix is custom, it will be sent as `custom-prefix` to preserve anonymity.
+- Whether you are a Homebrew Developer, e.g. `true` if the `HOMEBREW_DEVELOPER` environment variable is set.
+- Whether `devcmdrun` is set, e.g. `true` if you have ever run one of Homebrew's developer commands.
+- Your CPU's architecture, e.g. `x86_64`.
+- The OS you are using and its version number, e.g. `macOS 13`.
+- The version of Homebrew, e.g. `4.0.0`.
+
+All analytics data previously sent to Google Analytics has been destroyed.
 
 Homebrew's analytics records the following different events:
 
-- An `event` hit type with the `install` event category and the Homebrew formula from a non-private GitHub tap you install plus any used options (e.g. `wget --HEAD`) as the action, and an event label (e.g. `macOS 10.15, non-/usr/local, CI`) to indicate the OS version, non-standard installation location and invocation as part of CI. This allows us to identify which formulae need fixing and where more easily.
-- An `event` hit type with the `install_on_request` event category and the Homebrew formula from a non-private GitHub tap you have requested to install (e.g. when explicitly named with a `brew install`) plus options and an event label as above. This allows us to differentiate the formulae that users intend to install from those pulled in as dependencies.
-- An `event` hit type with the `cask_install` event category and the Homebrew cask from a non-private GitHub tap you install as the action and an event label as above. This allows us to identify which casks need fixing and where more easily.
-- An `event` hit type with the `BuildError` event category and the Homebrew formula plus options that failed to install as the action and an event label as above, e.g. `wget --HEAD` and `macOS 10.15`.
+- The `install` event category and the Homebrew formula from a non-private GitHub tap you install plus any used options (e.g. `wget --HEAD`) as the action. This allows us to identify which formulae where work should be prioritised, as well as how to handle possible deprecation or removal of any.
+- The `install_on_request` event category and the Homebrew formula from a non-private GitHub tap you have requested to install (e.g. when explicitly named with a `brew install`) plus options. This allows us to differentiate the formulae that users intend to install from those pulled in as dependencies.
+- The `cask_install` event category and the Homebrew cask from a non-private GitHub tap you install as the action. This allows us to identify which casks where work should be prioritised, as well as how to handle possible deprecation or removal of any.
+- The `build_error` event category and the Homebrew formula plus options that failed to install as the action, e.g. `wget --HEAD`. This allows us to identify formulae that may need fixing. The details or logs of the build error are not sent.
+- The `command_run` event category and the command and flags you run as the action. This allows us to identify which commands and flags are most commonly used and which are not used at all.
+- The `test_bot_test` event category is only used in Homebrew's CI environment and is used to record the results of running tests on pull requests.
 
 You can also view all the information that is sent by Homebrew's analytics by setting `HOMEBREW_ANALYTICS_DEBUG=1` in your environment. Please note this will also stop any analytics from being sent.
 
-It is impossible for the Homebrew developers to match any particular event to any particular user, even if we had access to the Homebrew analytics user ID (which we do not). An example of the most user-specific information we can see from Google Analytics:
-
-![Aggregate user analytics](assets/img/docs/analytics.png)
-
-As far as we can tell it would be impossible for Google to match the randomly generated Homebrew-only analytics user ID to any other Google Analytics user ID. If Google turned evil the only thing they could do would be to lie about anonymising IP addresses and attempt to match users based on IP addresses.
+It is impossible for the Homebrew developers to match any particular event to any particular user. We do not store or receive IP addresses.
 
 ## When/Where?
 
-Homebrew's analytics are sent throughout Homebrew's execution to Google Analytics over HTTPS.
+Homebrew's analytics are sent throughout Homebrew's execution to InfluxDB over HTTPS.
 
 ## Who?
 
-Summaries of installation and error analytics are [publicly available](https://formulae.brew.sh/analytics/). A JSON API is also available. The majority of Homebrew maintainers are not granted more detailed analytics data beyond these public resources.
+Aggregates of analytics events are [publicly available](https://formulae.brew.sh/analytics/). A JSON API is also available. The majority of Homebrew maintainers are not granted more detailed analytics data beyond these public resources.
 
 ## How?
 
diff --git a/docs/Bottles.md b/docs/Bottles.md
index 7283f8e5e1ac9..96106ac596ad4 100644
--- a/docs/Bottles.md
+++ b/docs/Bottles.md
@@ -16,7 +16,7 @@ Bottles will not be used if:
 
 ## Creation
 
-Bottles for `homebrew/core` formulae are created by [Brew Test Bot](Brew-Test-Bot.md) when a pull request is submitted. If the formula builds successfully on each supported platform and a maintainer approves the change, Brew Test Bot updates its `bottle do` block and uploads each bottle to [GitHub Packages](https://github.com/orgs/Homebrew/packages).
+Bottles for `homebrew/core` formulae are created by [BrewTestBot](BrewTestBot.md) when a pull request is submitted. If the formula builds successfully on each supported platform and a maintainer approves the change, BrewTestBot updates its `bottle do` block and uploads each bottle to [GitHub Packages](https://github.com/orgs/Homebrew/packages).
 
 By default, bottles will be built for the oldest CPU supported by the OS/architecture you're building for (Core 2 for 64-bit x86 operating systems). This ensures that bottles are compatible with all computers you might distribute them to. If you *really* want your bottles to be optimised for something else, you can pass the `--bottle-arch=` option to build for another architecture; for example, `brew install foo --build-bottle --bottle-arch=penryn`. Just remember that if you build for a newer architecture, some of your users might get binaries they can't run and that would be sad!
 
@@ -62,7 +62,7 @@ By default this is omitted and Homebrew's default bottle URL root is used. This
 
 Optionally contains the value of `HOMEBREW_CELLAR` in which the bottles were built.
 
-Most compiled software contains references to its compiled location, preventing it from being simply relocated anywhere on disk. A value of `:any` or `:any_skip_relocation` means that the bottle can be safely installed in any Cellar as it did not contain any references to the Cellar in which it was originally built. This can be omitted if the bottle was compiled for the given OS/architecture's default `HOMEBREW_CELLAR`, as is done for all bottles built by Brew Test Bot.
+Most compiled software contains references to its compiled location, preventing it from being simply relocated anywhere on disk. A value of `:any` or `:any_skip_relocation` means that the bottle can be safely installed in any Cellar as it did not contain any references to the Cellar in which it was originally built. This can be omitted if the bottle was compiled for the given OS/architecture's default `HOMEBREW_CELLAR`, as is done for all bottles built by BrewTestBot.
 
 ### Rebuild version (`rebuild`)
 
diff --git a/docs/Brew-Livecheck.md b/docs/Brew-Livecheck.md
index fbbef6c7dcc14..b385b653221e5 100644
--- a/docs/Brew-Livecheck.md
+++ b/docs/Brew-Livecheck.md
@@ -1,33 +1,33 @@
 # `brew livecheck`
 
-The `brew livecheck` command finds the newest version of a formula or cask's software by checking upstream. Livecheck has [strategies](https://rubydoc.brew.sh/Homebrew/Livecheck/Strategy.html) to identify versions from various sources, such as Git repositories, websites, etc.
+The `brew livecheck` command finds the newest version of a formula or cask's software by checking upstream. Livecheck has [strategies](https://rubydoc.brew.sh/Homebrew/Livecheck/Strategy) to identify versions from various sources, such as Git repositories, websites, etc.
 
 ## Behavior
 
 When livecheck isn't given instructions for how to check for upstream versions, it does the following by default:
 
-1. For formulae: Collect the `head`, `stable`, and `homepage` URLs, in that order. For casks: Collect the `url` and `homepage` URLs, in that order.
+1. For formulae: Collect the `stable`, `head`, and `homepage` URLs, in that order (resources simply use their `url`). For casks: Collect the `url` and `homepage` URLs, in that order.
 1. Determine if any strategies apply to the first URL. If not, try the next URL.
 1. If a strategy can be applied, use it to check for new versions.
 1. Return the newest version (or an error if versions could not be found at any available URLs).
 
 It's sometimes necessary to override this default behavior to create a working check. If a source doesn't provide the newest version, we need to check a different one. If livecheck doesn't correctly match version text, we need to provide an appropriate regex or `strategy` block.
 
-This can be accomplished by adding a `livecheck` block to the formula/cask. For more information on the available methods, please refer to the [`Livecheck` class documentation](https://rubydoc.brew.sh/Livecheck.html).
+This can be accomplished by adding a `livecheck` block to the formula/cask/resource. For more information on the available methods, please refer to the [`Livecheck` class documentation](https://rubydoc.brew.sh/Livecheck).
 
 ## Creating a check
 
 1. **Use the debug output to understand the situation**. `brew livecheck --debug <formula>|<cask>` provides information about which URLs livecheck tries, any strategies that apply, matched versions, etc.
 
-1. **Research available sources to select a URL**. Try removing the file name from `stable`/`url`, to see if this is a directory listing page. If that doesn't work, try to find a page that links to the file (e.g. a download page). If it's not possible to find the newest version on the website, try checking other sources from the formula/cask. When necessary, search for other sources outside of the formula/cask.
+1. **Research available sources to select a URL**. Try removing the file name from `stable`/`url` to see if it provides a directory listing page. If that doesn't work, try to find a page that links to the file (e.g. a download page). If it's not possible to find the newest version on the website, try checking other sources from the formula/cask. When necessary, search for other sources outside of the formula/cask.
 
 1. **Create a regex, if necessary**. If the check works without a regex and wouldn't benefit from having one, it's usually fine to omit it. More information on creating regexes can be found in the [regex guidelines](#regex-guidelines) section.
 
 ### General guidelines
 
-* **Only use `strategy` when it's necessary**. For example, if livecheck is already using `Git` for a URL, it's not necessary to use `strategy :git`. However, if `Git` applies to a URL but we need to use `PageMatch`, it's necessary to specify `strategy :page_match`.
+* **Only use `strategy` when it's necessary**. For example, if livecheck is already using the `Git` strategy for a URL, it's not necessary to use `strategy :git`. However, if `Git` applies to a URL but we need to use `PageMatch`, it's necessary to specify `strategy :page_match`.
 
-* **Only use the `GithubLatest` strategy when it's necessary and correct**. `github.com` rate limits requests and we try to minimize our use of this strategy to avoid hitting the rate limit on CI or when using `brew livecheck --tap` on large taps (e.g. homebrew/core). The `Git` strategy is often sufficient and we only need to use `GithubLatest` when the "latest" release is different than the newest version from the tags.
+* **Only use the `GithubLatest` and `GithubReleases` strategies when they are necessary and correct**. GitHub rate-limits API requests, so we only use these strategies when `Git` isn't sufficient or appropriate. `GithubLatest` should only be used if the upstream repository has a "latest" release for a suitable version and either the formula/cask uses a release asset or the `Git` strategy can't correctly identify the latest release version. `GithubReleases` should only be used if the upstream repository uses releases and both the `Git` and `GithubLatest` strategies aren't suitable.
 
 ### URL guidelines
 
@@ -47,7 +47,7 @@ The `livecheck` block regex restricts matches to a subset of the fetched content
 
 * **Anchor the start/end of the regex, to restrict the scope**. For example, on HTML pages we often match file names or version directories in `href` attribute URLs (e.g. `/href=.*?example[._-]v?(\d+(?:\.\d+)+)\.zip/i`). The general idea is that limiting scope will help exclude unwanted matches.
 
-* **Avoid generic catch-alls like `.*` or `.+`** in favor of something non-greedy and/or contextually appropriate. For example, to match characters within the bounds of an HTML attribute, use `[^"' >]+?`.
+* **Avoid generic catchalls like `.*` or `.+`** in favor of something non-greedy and/or contextually appropriate. For example, to match characters within the bounds of an HTML attribute, use `[^"' >]+?`.
 
 * **Use `[._-]` in place of a period/underscore/hyphen between the software name and version in a file name**. For a file named `example-1.2.3.tar.gz`, `example[._-]v?(\d+(?:\.\d+)+)\.t` will continue matching if the upstream file name format changes to `example_1.2.3.tar.gz` or `example.1.2.3.tar.gz`.
 
@@ -114,7 +114,32 @@ If the upstream version format needs to be manipulated to match the formula/cask
 
 #### `PageMatch` `strategy` block
 
-In the example below, we're converting a date format like `2020-01-01` into `20200101`.
+Here is a basic example, extracting a simple version from a page:
+
+```ruby
+livecheck do
+  url "https://example.org/my-app/download"
+  regex(%r{href=.*?/MyApp-(\d+(?:\.\d+)*)\.zip}i)
+  strategy :page_match
+end
+```
+
+More complex versions can be handled by specifying a block.
+
+```ruby
+livecheck do
+  url "https://example.org/my-app/download"
+  regex(%r{href=.*?/(\d+)/MyApp-(\d+(?:\.\d+)*)\.zip}i)
+  strategy :page_match do |page, regex|
+    match = page.match(regex)
+    next if match.blank?
+
+    "#{match[2]},#{match[1]}"
+  end
+end
+```
+
+In the example below, we're scanning the contents of the homepage for a date format like `2020-01-01` and converting it into `20200101`.
 
 ```ruby
 livecheck do
@@ -126,7 +151,34 @@ livecheck do
 end
 ```
 
-The `PageMatch` `strategy` block style seen here also applies to any strategy that uses `PageMatch` internally.
+The `PageMatch` `strategy` block style seen here also applies to any site-specific strategy that uses `PageMatch` internally.
+
+#### `HeaderMatch` `strategy` block
+
+A `strategy` block for `HeaderMatch` will try to parse a version from the filename (in the `Content-Disposition` header) and the final URL (in the `Location` header). If that doesn't work, a `regex` can be specified.
+
+```ruby
+livecheck do
+  url "https://example.org/my-app/download/latest"
+  regex(/MyApp-(\d+(?:\.\d+)*)\.zip/i)
+  strategy :header_match
+end
+```
+
+If the version depends on multiple header fields, a block can be specified.
+
+```ruby
+livecheck do
+  url "https://example.org/my-app/download/latest"
+  strategy :header_match do |headers|
+    v = headers["content-disposition"][/MyApp-(\d+(?:\.\d+)*)\.zip/i, 1]
+    id = headers["location"][%r{/(\d+)/download$}i, 1]
+    next if v.blank? || id.blank?
+
+    "#{v},#{id}"
+  end
+end
+```
 
 #### `Git` `strategy` block
 
@@ -136,16 +188,138 @@ A `strategy` block for `Git` is a bit different, as the block receives an array
 livecheck do
   url :stable
   strategy :git do |tags|
-    tags.map { |tag| tag[/^(\d{4}-\d{2}-\d{2})$/i, 1]&.gsub(/\D/, "") }.compact
+    tags.filter_map { |tag| tag[/^(\d{4}-\d{2}-\d{2})$/i, 1]&.gsub(/\D/, "") }
+  end
+end
+```
+
+#### `GithubLatest` `strategy` block
+
+A `strategy` block for `GithubLatest` receives the parsed JSON data from the GitHub API for a repository's "latest" release, along with a regex. When a regex is not provided in a `livecheck` block, the strategy's default regex is passed into the `strategy` block instead.
+
+By default, the strategy matches version text in the release's tag or title but a `strategy` block can be used to check any of the fields in the release JSON. The logic in the following `strategy` block is similar to the default behavior but only checks the release tag instead, for the sake of demonstration:
+
+```ruby
+livecheck do
+  url :stable
+  regex(/^example[._-]v?(\d+(?:\.\d+)+)$/i)
+  strategy :github_latest do |json, regex|
+    match = json["tag_name"]&.match(regex)
+    next if match.blank?
+
+    match[1]
+  end
+end
+```
+
+You can find more information on the response JSON from this API endpoint in the related [GitHub REST API documentation](https://docs.github.com/en/rest/releases/releases?apiVersion=latest#get-the-latest-release).
+
+#### `GithubReleases` `strategy` block
+
+A `strategy` block for `GithubReleases` receives the parsed JSON data from the GitHub API for a repository's most recent releases, along with a regex. When a regex is not provided in a `livecheck` block, the strategy's default regex is passed into the `strategy` block instead.
+
+By default, the strategy matches version text in each release's tag or title but a `strategy` block can be used to check any of the fields in the release JSON. The logic in the following `strategy` block is similar to the default behavior but only checks the release tag instead, for the sake of demonstration:
+
+```ruby
+livecheck do
+  url :stable
+  regex(/^example[._-]v?(\d+(?:\.\d+)+)$/i)
+  strategy :github_releases do |json, regex|
+    json.map do |release|
+      next if release["draft"] || release["prerelease"]
+
+      match = release["tag_name"]&.match(regex)
+      next if match.blank?
+
+      match[1]
+    end
+  end
+end
+```
+
+You can find more information on the response JSON from this API endpoint in the related [GitHub REST API documentation](https://docs.github.com/en/rest/releases/releases?apiVersion=latest#list-releases).
+
+#### `Crate` `strategy` block
+
+A `strategy` block for `Crate` receives parsed JSON data from the registry API's `versions` endpoint and either the provided or default strategy regex. The strategy uses the following logic by default, so this `strategy` block may be a good starting point for a modified approach:
+
+```ruby
+livecheck do
+  url :stable
+  strategy :crate do |json, regex|
+    json["versions"]&.map do |version|
+      next if version["yanked"]
+      next unless (match = version["num"]&.match(regex))
+
+      match[1]
+    end
+  end
+end
+```
+
+#### `ElectronBuilder` `strategy` block
+
+A `strategy` block for `ElectronBuilder` fetches content at a URL and parses it as an electron-builder appcast in YAML format. It's used for casks of macOS applications built using the Electron framework.
+
+```ruby
+livecheck do
+  url "https://example.org/my-app/latest-mac.yml"
+  strategy :electron_builder
+end
+```
+
+If you need to modify the version, you can access the YAML hash in the `strategy` block like so:
+
+```ruby
+livecheck do
+  url "https://example.org/my-app/latest-mac.yml"
+  strategy :electron_builder do |yaml|
+    yaml["version"]&.gsub(/\D/, "")
+  end
+end
+```
+
+Similarly, you can work with the `files` array like this:
+
+```ruby
+livecheck do
+  url "https://example.org/my-app/latest-mac.yml"
+  regex(/MyApp[._-]v?(\d+(?:\.\d+)+)-(\h+)\.dmg/i)
+  strategy :electron_builder do |yaml, regex|
+    yaml["files"]&.map do |file|
+      match = file["url"]&.match(regex)
+      next if match.blank?
+
+      "#{match[1]},#{match[2]}"
+    end
+  end
+end
+```
+
+#### `Json` `strategy` block
+
+A `strategy` block for `Json` receives parsed JSON data and, if provided, a regex. For example, if we have an object containing an array of objects with a `version` string, we can select only the members that match the regex and isolate the relevant version text as follows:
+
+```ruby
+livecheck do
+  url "https://www.example.com/example.json"
+  regex(/^v?(\d+(?:\.\d+)+)$/i)
+  strategy :json do |json, regex|
+    json["versions"].select { |item| item["version"]&.match?(regex) }
+                    .map { |item| item["version"][regex, 1] }
   end
 end
 ```
 
 #### `Sparkle` `strategy` block
 
-A `strategy` block for `Sparkle` receives an `item` which has methods for the `short_version`, `version`, `url` and `title`.
+A `strategy` block for `Sparkle` receives an `item` which has methods for the `version`, `short_version`, `nice_version`, `url`, `channel` and `title`. It expects a URL for an XML feed providing release information to a macOS application that self-updates using the Sparkle framework. This URL can be found within the app bundle as the `SUFeedURL` property in `Contents/Info.plist` or by using the [`find-appcast`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/cmd/find-appcast.rb) command. Run it with:
 
-The default pattern for the `Sparkle` strategy is `"#{item.short_version},#{item.version}"` if both are set. In the example below, the `url` also includes a download ID which is needed:
+```bash
+brew find-appcast '/path/to/application.app'
+```
+
+The default pattern for the `Sparkle` strategy is to generate `"#{item.short_version},#{item.version}"` from `sparkle:shortVersionString` and `sparkle:version` if both are set. In the example below, the `url` also includes a download ID which is needed:
 
 ```ruby
 livecheck do
@@ -156,9 +330,71 @@ livecheck do
 end
 ```
 
+To use only one, specify `&:version`, `&:short_version` or `&:nice_version`:
+
+```ruby
+livecheck do
+  url "https://www.example.com/example.xml"
+  strategy :sparkle, &:short_version
+end
+```
+
+#### `Xml` `strategy` block
+
+A `strategy` block for `Xml` receives an `REXML::Document` object and, if provided, a regex. For example, if the XML contains a `versions` element with nested `version` elements and their inner text contains the version string, we could extract it using a regex as follows:
+
+```ruby
+livecheck do
+  url "https://www.example.com/example.xml"
+  regex(/v?(\d+(?:\.\d+)+)/i)
+  strategy :xml do |xml, regex|
+    xml.get_elements("versions//version").map { |item| item.text[regex, 1] }
+  end
+end
+```
+
+For more information on how to work with an `REXML::Document` object, please refer to the [`REXML::Document`](https://ruby.github.io/rexml/REXML/Document.html) and [`REXML::Element`](https://ruby.github.io/rexml/REXML/Element.html) documentation.
+
+#### `Yaml` `strategy` block
+
+A `strategy` block for `Yaml` receives parsed YAML data and, if provided, a regex. Borrowing the `Json` example, if we have an object containing an array of objects with a `version` string, we can select only the members that match the regex and isolate the relevant version text as follows:
+
+```ruby
+livecheck do
+  url "https://www.example.com/example.yaml"
+  regex(/^v?(\d+(?:\.\d+)+)$/i)
+  strategy :yaml do |yaml, regex|
+    yaml["versions"].select { |item| item["version"]&.match?(regex) }
+                    .map { |item| item["version"][regex, 1] }
+  end
+end
+```
+
+#### `ExtractPlist` `strategy` block
+
+If no means are available online for checking which version of a macOS package is current, as a last resort the `:extract_plist` strategy will have `brew livecheck` download the artifact and retrieve its version string from contained `.plist` files.
+
+```ruby
+livecheck do
+  url :url
+  strategy :extract_plist
+end
+```
+
+A `strategy` block for `ExtractPlist` receives a hash containing keys for each found bundle identifier and `item`s with methods for each `version` and `short_version`.
+
+```ruby
+livecheck do
+  url :url
+  strategy :extract_plist do |items|
+    items["com.example.MyApp"].short_version
+  end
+end
+```
+
 ### `skip`
 
-Livecheck automatically skips some formulae/casks for a number of reasons (deprecated, disabled, discontinued, etc.). However, on rare occasions we need to use a `livecheck` block to do a manual skip. The `skip` method takes a string containing a very brief reason for skipping.
+Livecheck automatically skips some formulae/casks for a number of reasons (deprecated, disabled, etc.). However, on rare occasions we need to use a `livecheck` block to do a manual skip. The `skip` method takes a string containing a very brief reason for skipping.
 
 ```ruby
 livecheck do
diff --git a/docs/Brew-Test-Bot-For-Core-Contributors.md b/docs/Brew-Test-Bot-For-Core-Contributors.md
deleted file mode 100644
index 74d033d680585..0000000000000
--- a/docs/Brew-Test-Bot-For-Core-Contributors.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# Brew Test Bot For Core Contributors
-
-If a build has run and passed on `brew test-bot` then it can be used to quickly bottle formulae.
-
-## Bottling
-
-If a pull request is correct and doesn't need any modifications to commit messages or otherwise:
-
-1. Review and approve the pull request. Be sure to thank the contributor!
-2. Wait for BrewTestBot to automatically merge the pull request. This happens about once an hour. BrewTestBot will comment if there is a failure.
-
-If a pull request won't be automatically merged by Brew Test Bot (has the labels `do not merge`, `new formula`, or `automerge-skip`), but the [commit messages and commit style](Formula-Cookbook.md#commit) are correct:
-
-1. Ensure the job has already completed successfully.
-2. Run `brew pr-publish 12345` where `12345` is the pull request number (or URL).
-    - Approving a PR for an existing formula will automatically publish the bottles and close the PR, taking care of this step.
-3. Watch the [actions queue](https://github.com/Homebrew/homebrew-core/actions) to ensure your job finishes. BrewTestBot will usually notify you of failures with a ping as well.
-
-If a pull request needs its commit messages changed in a way that autosquash doesn't support (has the label `automerge-skip`):
-
-1. Ensure the job has already completed successfully.
-2. Run `brew pr-pull 12345` where `12345` is the pull request number (or URL).
-3. Amend any relevant commits if needed, then run `git push` to push the commits.
diff --git a/docs/Brew-Test-Bot.md b/docs/Brew-Test-Bot.md
deleted file mode 100644
index e6db4d3485180..0000000000000
--- a/docs/Brew-Test-Bot.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-logo: https://brew.sh/assets/img/brewtestbot.png
-image: https://brew.sh/assets/img/brewtestbot.png
----
-
-# Brew Test Bot
-
-`brew test-bot` is the name for the automated review and testing system funded
-by [our Kickstarter in 2013](https://www.kickstarter.com/projects/homebrew/brew-test-bot).
-
-It comprises three Mac Pros hosting virtual machines that run the
-[`test-bot.rb`](https://github.com/Homebrew/homebrew-test-bot/) external
-command to perform automated testing of commits to the master branch, pull
-requests and custom builds requested by maintainers.
-
-## Pull Requests
-
-The bot automatically builds pull requests and updates their status depending
-on the result of the job.
-
-For example, a job which has been queued but not yet completed will have a
-section in the pull request that looks like this:
-
-![Triggered Pull Request](assets/img/docs/brew-test-bot-triggered-pr.png)
-
----
-
-A failed build looks like this:
-
-![Failed Pull Request](assets/img/docs/brew-test-bot-failed-pr.png)
-
----
-
-A passed build looks like this:
-
-![Passed Pull Request](assets/img/docs/brew-test-bot-passed-pr.png)
-
----
-
-On failed or passed builds you can click the "Details" link to view the result
-in GitHub Actions.
-
diff --git a/docs/BrewTestBot-For-Maintainers.md b/docs/BrewTestBot-For-Maintainers.md
new file mode 100644
index 0000000000000..340848f3d9b9e
--- /dev/null
+++ b/docs/BrewTestBot-For-Maintainers.md
@@ -0,0 +1,33 @@
+---
+logo: /assets/img/brewtestbot.png
+image: /assets/img/brewtestbot.png
+redirect_from:
+  - /Brew-Test-Bot-For-Core-Contributors
+---
+
+# BrewTestBot for Maintainers
+
+[`brew test-bot`](Manpage.md#test-bot-options-formula) is the command our [CI](https://github.com/BrewTestBot) runs to test and build bottles for formulae.
+
+## Publishing Bottles
+
+If CI is passing on a pull request and it doesn't need any modifications (e.g. commit message, revision bump, etc.):
+
+1. Review and approve the pull request. Be sure to thank the contributor!
+2. Wait for BrewTestBot to automatically merge the pull request. This job usually starts within a minute if both of the following are true:
+    - The pull request is approved by a maintainer who has write access to homebrew-core.
+    - CI is passing.
+
+If any jobs did not complete successfully, the pull request will not automatically merge. Additionally, BrewTestBot will comment on the pull request if there is a publishing failure.
+
+If a pull request won't be automatically merged by BrewTestBot (has the labels `autosquash`, `automerge-skip`, or`new formula`, or has some kind of acceptable CI failure):
+
+1. Ensure that bottles have built successfully.
+2. Run `brew pr-publish 12345` where `12345` is the pull request number (or URL).
+3. Watch the [actions queue](https://github.com/Homebrew/homebrew-core/actions) to ensure your job finishes. BrewTestBot will notify you of failures with a ping as well.
+
+If a pull request needs its commit messages changed in a way that autosquash doesn't support (has the label `automerge-skip`):
+
+1. Ensure that bottles have built successfully.
+2. Run `brew pr-pull 12345` where `12345` is the pull request number (or URL).
+3. Amend any relevant commits if needed, then run `git push` to push the commits to the pull request.
diff --git a/docs/BrewTestBot.md b/docs/BrewTestBot.md
new file mode 100644
index 0000000000000..1a658c32234ad
--- /dev/null
+++ b/docs/BrewTestBot.md
@@ -0,0 +1,36 @@
+---
+logo: /assets/img/brewtestbot.png
+image: /assets/img/brewtestbot.png
+redirect_from:
+  - /Brew-Test-Bot
+---
+
+# BrewTestBot
+
+[`brew test-bot`](Manpage.md#test-bot-options-formula) is what runs the automated review and testing system funded by [our Kickstarter in 2013](https://www.kickstarter.com/projects/homebrew/brew-test-bot).
+
+It comprises three Mac Pros hosting virtual machines, several Intel and M1 Mac minis and some cloud Ubuntu instances that run the [`test-bot.rb`](https://github.com/Homebrew/homebrew-test-bot) external command to perform bottle builds and automated testing of the full lifecycle of any change to Homebrew or its taps.
+
+## Pull Requests
+
+The bot automatically builds pull requests and updates their status depending on the result of the job.
+
+For example, a job which has been queued but not yet completed will have a section in the pull request that looks like this:
+
+![Triggered Pull Request](assets/img/docs/brew-test-bot-triggered-pr.png)
+
+---
+
+A failed build looks like this:
+
+![Failed Pull Request](assets/img/docs/brew-test-bot-failed-pr.png)
+
+---
+
+A passed build that's been approved to merge looks like this:
+
+![Passed Pull Request](assets/img/docs/brew-test-bot-passed-pr.png)
+
+---
+
+On failed or passed builds you can click the "Details" link for each check to view its output in GitHub Actions.
diff --git a/docs/C++-Standard-Libraries.md b/docs/C++-Standard-Libraries.md
index 2eaa89050cf7b..1f1fc094b4b45 100644
--- a/docs/C++-Standard-Libraries.md
+++ b/docs/C++-Standard-Libraries.md
@@ -20,9 +20,9 @@ dependencies that you built on 10.8 or earlier. If you're reading this page beca
 you were directed here by a build error, you can most likely fix the issue if
 you reinstall all the dependencies of the package you're trying to build.
 
-Example install using GCC 7:
+Example install using GCC 9:
 
 ```sh
-brew install gcc@7
-brew install --cc=gcc-7 <formula>
+brew install gcc@9
+brew install --cc=gcc-9 <formula>
 ```
diff --git a/docs/Cask-Cookbook.md b/docs/Cask-Cookbook.md
index e1d26d6fe459c..0fa74b3239f7e 100644
--- a/docs/Cask-Cookbook.md
+++ b/docs/Cask-Cookbook.md
@@ -1,239 +1,165 @@
 # Cask Cookbook
 
-Each Cask is a Ruby block, beginning with a special header line. The Cask definition itself is always enclosed in a `do … end` block. Example:
+Each cask is a Ruby block, beginning with a special header line. The cask definition itself is always enclosed in a `do … end` block. Example:
 
 ```ruby
-cask "alfred" do
-  version "2.7.1_387"
-  sha256 "a3738d0513d736918a6d71535ef3d85dd184af267c05698e49ac4c6b48f38e17"
+cask "anybar" do
+  version "0.2.3"
+  sha256 "c87dbc6aff5411676a471e84905d69c671b62b93b1210bd95c9d776d087de95c"
 
-  url "https://cachefly.alfredapp.com/Alfred_#{version}.zip"
-  name "Alfred"
-  desc "Application launcher and productivity software"
-  homepage "https://www.alfredapp.com/"
+  url "https://github.com/tonsky/AnyBar/releases/download/#{version}/AnyBar-#{version}.zip"
+  name "AnyBar"
+  desc "Menu bar status indicator"
+  homepage "https://github.com/tonsky/AnyBar"
 
-  app "Alfred 2.app"
-  app "Alfred 2.app/Contents/Preferences/Alfred Preferences.app"
+  app "AnyBar.app"
 end
 ```
 
-## The Cask Language Is Declarative
+* Table of Contents
+{:toc}
 
-Each Cask contains a series of stanzas (or “fields”) which *declare* how the software is to be obtained and installed. In a declarative language, the author does not need to worry about **order**. As long as all the needed fields are present, Homebrew Cask will figure out what needs to be done at install time.
+## The cask language is declarative
+
+Each cask contains a series of stanzas (or “fields”) which *declare* how the software is to be obtained and installed. In a declarative language, the author does not need to worry about **order**. As long as all the needed fields are present, Homebrew Cask will figure out what needs to be done at install time.
 
 To make maintenance easier, the most-frequently-updated stanzas are usually placed at the top. But that’s a convention, not a rule.
 
 Exception: `do` blocks such as `postflight` may enclose a block of pure Ruby code. Lines within that block follow a procedural (order-dependent) paradigm.
 
-## Conditional Statements
+## Header line details
 
-### Efficiency
+The Cask name ([`<cask-token>`](#token-reference)) on the header line `cask <cask-token> do` should match the cask filename, without the `.rb` extension, enclosed in double quotes.
 
-Conditional statements are permitted, but only if they are very efficient.
-Tests on the following values are known to be acceptable:
+There are currently some arbitrary limitations on cask tokens which are in the process of being removed. GitHub Actions will catch any errors during the transition.
 
-| value                       | examples
-| ----------------------------|--------------------------------------
-| `MacOS.version`             | [coconutbattery.rb](https://github.com/Homebrew/homebrew-cask/blob/a11ee55e8ed8255f7dab77120dfb1fb955789559/Casks/coconutbattery.rb#L2-L16), [yasu.rb](https://github.com/Homebrew/homebrew-cask/blob/21d3f7ac8a4adac0fe474b3d4b020d284eeef88d/Casks/yasu.rb#L2-L23)
+## Stanza order
 
-### Version Comparisons
+Having a common order for stanzas makes casks easier to update and parse. Below is the complete stanza sequence (no cask will have all stanzas). The empty lines shown here are also important, as they help to visually delimit information.
 
-Tests against `MacOS.version` may use either symbolic names or version
-strings with numeric comparison operators:
+    version
+    sha256
 
-```ruby
-if MacOS.version <= :mojave        # symbolic name
-```
+    language
 
-```ruby
-if MacOS.version <= "10.14"        # version string
-```
+    url
+    name
+    desc
+    homepage
 
-The available symbols for macOS versions are: `:el_capitan`, `:sierra`, `:high_sierra`, `:mojave`, `:catalina` and `:big_sur`. The corresponding numeric version strings should be given as major releases containing a single dot.
+    livecheck
 
-Note that in the official Homebrew Cask repositories only the symbolic names are allowed. The numeric comparison may only be used for third-party taps.
+    deprecate!
+    disable!
 
-### Always Fall Through to the Newest Case
+    auto_updates
+    conflicts_with
+    depends_on
+    container
 
-Conditionals should be constructed so that the default is the newest OS version. When using an `if` statement, test for older versions, and then let the `else` statement hold the latest and greatest. This makes it more likely that the Cask will work without alteration when a new OS is released. Example (from [coconutbattery.rb](https://github.com/Homebrew/homebrew-cask/blob/2c801af44be29fff7f3cb2996455fce5dd95d1cc/Casks/coconutbattery.rb)):
+    suite
+    app
+    pkg
+    installer
+    binary
+    manpage
+    colorpicker
+    dictionary
+    font
+    input_method
+    internet_plugin
+    keyboard_layout
+    prefpane
+    qlplugin
+    mdimporter
+    screen_saver
+    service
+    audio_unit_plugin
+    vst_plugin
+    vst3_plugin
+    artifact, target: # target: shown here as is required with `artifact`
+    stage_only
 
-```ruby
-if MacOS.version <= :sierra
-  # ...
-elsif MacOS.version <= :mojave
-  # ...
-else
-  # ...
-end
-```
+    preflight
 
-### Switch Between Languages or Regions
+    postflight
 
-If a cask is available in multiple languages, you can use the `language` stanza to switch between languages or regions based on the system locale.
+    uninstall_preflight
 
-## Arbitrary Ruby Methods
+    uninstall_postflight
 
-In the exceptional case that the Cask DSL is insufficient, it is possible to define arbitrary Ruby variables and methods inside the Cask by creating a `Utils` namespace. Example:
+    uninstall
 
-```ruby
-cask "myapp" do
-  module Utils
-    def self.arbitrary_method
-      ...
-    end
-  end
+    zap
 
-  name "MyApp"
-  version "1.0"
-  sha256 "a32565cdb1673f4071593d4cc9e1c26bc884218b62fef8abc450daa47ba8fa92"
-
-  url "https://#{Utils.arbitrary_method}"
-  homepage "https://www.example.com/"
-  ...
-end
-```
-
-This should be used sparingly: any method which is needed by two or more Casks should instead be rolled into the core. Care must also be taken that such methods be very efficient.
-
-Variables and methods should not be defined outside the `Utils` namespace, as they may collide with Homebrew Cask internals.
-
-## Header Line Details
-
-The first non-comment line in a Cask follows the form:
-
-```ruby
-cask "<cask-token>" do
-```
-
-[`<cask-token>`](#token-reference) should match the Cask filename, without the `.rb` extension,
-enclosed in single quotes.
-
-There are currently some arbitrary limitations on Cask tokens which are in the process of being removed. GitHub Actions will catch any errors during the transition.
-
-## Stanza order
-
-Having a common order for stanzas makes Casks easier to update and parse. Below is the complete stanza sequence (no Cask will have all stanzas). The empty lines shown here are also important, as they help to visually delineate information.
-
-```
-version
-sha256
-
-language
-
-url
-appcast
-name
-desc
-homepage
-
-livecheck
-
-auto_updates
-conflicts_with
-depends_on
-container
-
-suite
-app
-pkg
-installer
-binary
-manpage
-colorpicker
-dictionary
-font
-input_method
-internet_plugin
-prefpane
-qlplugin
-mdimporter
-screen_saver
-service
-audio_unit_plugin
-vst_plugin
-vst3_plugin
-artifact, target: # target: shown here as is required with `artifact`
-stage_only
-
-preflight
-
-postflight
-
-uninstall_preflight
-
-uninstall_postflight
-
-uninstall
-
-zap
-
-caveats
-```
+    caveats
 
 Note that every stanza that has additional parameters (`:symbols` after a `,`) shall have them on separate lines, one per line, in alphabetical order. An exception is `target:` which typically consists of short lines.
 
 ## Stanzas
 
-### Required Stanzas
-
-Each of the following stanzas is required for every Cask.
-
-| name       | multiple occurrences allowed? | value                           |
-| ---------- |------------------------------ | ------------------------------- |
-| `version`  | no                            | Application version.<br />See [Version Stanza Details](#stanza-version) for more information.
-| `sha256`   | no                            | SHA-256 checksum of the file downloaded from `url`, calculated by the command `shasum -a 256 <file>`. Can be suppressed by using the special value `:no_check`.<br />See [Checksum Stanza Details](#stanza-sha256) for more information.
-| `url`      | no                            | URL to the `.dmg`/`.zip`/`.tgz`/`.tbz2` file that contains the application.<br />A [comment](#when-url-and-homepage-hostnames-differ-add-a-comment) should be added if the hostnames in the `url` and `homepage` stanzas differ. Block syntax should be used for URLs that change on every visit.<br />See [URL Stanza Details](#stanza-url) for more information.
-| `name`     | yes                           | String providing the full and proper name defined by the vendor.<br />See [Name Stanza Details](#stanza-name) for more information.
-| `desc`     | no                            | One-line description of the Cask. Shows when running `brew info`.<br />See [Desc Stanza Details](#stanza-desc) for more information.
-| `homepage` | no                            | Application homepage; used for the `brew home` command.
-
-### At Least One Artifact Stanza Is Also Required
-
-Each Cask must declare one or more *artifacts* (i.e. something to install).
-
-| name                | multiple occurrences allowed? | value                  |
-| ------------------- |------------------------------ | ---------------------- |
-| `app`               | yes                           | Relative path to an `.app` that should be moved into the `/Applications` folder on installation.<br />See [App Stanza Details](#stanza-app) for more information.
-| `pkg`               | yes                           | Relative path to a `.pkg` file containing the distribution.<br />See [Pkg Stanza Details](#stanza-pkg) for more information.
-| `binary`            | yes                           | Relative path to a Binary that should be linked into the `$(brew --prefix)/bin` folder (typically `/usr/local/bin`) on installation.<br />See [Binary Stanza Details](#stanza-binary) for more information.
-| `colorpicker`       | yes                           | Relative path to a ColorPicker plugin that should be moved into the `~/Library/ColorPickers` folder on installation.
-| `dictionary`        | yes                           | Relative path to a Dictionary that should be moved into the `~/Library/Dictionaries` folder on installation.
-| `font`              | yes                           | Relative path to a Font that should be moved into the `~/Library/Fonts` folder on installation.
-| `input_method`      | yes                           | Relative path to a Input Method that should be moved into the `~/Library/Input Methods` folder on installation.
-| `internet_plugin`   | yes                           | Relative path to a Service that should be moved into the `~/Library/Internet Plug-Ins` folder on installation.
-| `manpage`           | yes                           | Relative path to a Man Page that should be linked into the respective man page folder on installation, e.g. `/usr/local/share/man/man3` for `my_app.3`.
-| `prefpane`          | yes                           | Relative path to a Preference Pane that should be moved into the `~/Library/PreferencePanes` folder on installation.
-| `qlplugin`          | yes                           | Relative path to a QuickLook Plugin that should be moved into the `~/Library/QuickLook` folder on installation.
-| `mdimporter`        | yes                           | Relative path to a Spotlight metadata importer that should be moved into the `~/Library/Spotlight` folder on installation.
-| `screen_saver`      | yes                           | Relative path to a Screen Saver that should be moved into the `~/Library/Screen Savers` folder on installation.
-| `service`           | yes                           | Relative path to a Service that should be moved into the `~/Library/Services` folder on installation.
-| `audio_unit_plugin` | yes                           | Relative path to an Audio Unit plugin that should be moved into the `~/Library/Audio/Components` folder on installation.
-| `vst_plugin`        | yes                           | Relative path to a VST Plugin that should be moved into the `~/Library/Audio/VST` folder on installation.
-| `vst3_plugin`       | yes                           | Relative path to a VST3 Plugin that should be moved into the `~/Library/Audio/VST3` folder on installation.
-| `suite`             | yes                           | Relative path to a containing directory that should be moved into the `/Applications` folder on installation.<br />See [Suite Stanza Details](#stanza-suite) for more information.
-| `artifact`          | yes                           | Relative path to an arbitrary path that should be moved on installation. Must provide an absolute path as a `target` (example [alcatraz.rb](https://github.com/Homebrew/homebrew-cask/blob/312ae841f1f1b2ec07f4d88b7dfdd7fbdf8d4f94/Casks/alcatraz.rb#L12)). This is only for unusual cases. The `app` stanza is strongly preferred when moving `.app` bundles.
-| `installer`         | yes                           | Describes an executable which must be run to complete the installation.<br />See [Installer Stanza Details](#stanza-installer) for more information.
-| `stage_only`        | no                            | `true`. Assert that the Cask contains no activatable artifacts.
-
-### Optional Stanzas
-
-| name                   | multiple occurrences allowed? | value               |
-| ---------------------- |------------------------------ | ------------------- |
-| `uninstall`            | yes                           | Procedures to uninstall a Cask. Optional unless the `pkg` stanza is used.<br />See [Uninstall Stanza Details](#stanza-uninstall) for more information.
-| `zap`                  | yes                           | Additional procedures for a more complete uninstall, including user files and shared resources.<br />See [Zap Stanza Details](#stanza-zap) for more information.
-| `appcast`              | no                            | URL providing an appcast feed to find updates for this Cask.<br />See [Appcast Stanza Details](#stanza-appcast) for more information.
-| `depends_on`           | yes                           | List of dependencies and requirements for this Cask.<br />See [Depends_on Stanza Details](#stanza-depends_on) for more information.
-| `conflicts_with`       | yes                           | List of conflicts with this Cask (*not yet functional*).<br />See [Conflicts_with Stanza Details](#stanza-conflicts_with) for more information.
-| `caveats`              | yes                           | String or Ruby block providing the user with Cask-specific information at install time.<br />See [Caveats Stanza Details](#stanza-caveats) for more information.
-| `livecheck`            | no                            | Ruby block describing how to find updates for this Cask.<br />See [Livecheck Stanza Details](#stanza-livecheck) for more information.
-| `preflight`            | yes                           | Ruby block containing preflight install operations (needed only in very rare cases).
-| `postflight`           | yes                           | Ruby block containing postflight install operations.<br />See [Postflight Stanza Details](#stanza-flight) for more information.
-| `uninstall_preflight`  | yes                           | Ruby block containing preflight uninstall operations (needed only in very rare cases).
-| `uninstall_postflight` | yes                           | Ruby block containing postflight uninstall operations.
-| `language`             | required                      | Ruby block, called with language code parameters, containing other stanzas and/or a return value.<br />See [Language Stanza Details](#stanza-language) for more information.
-| `container nested:`    | no                            | Relative path to an inner container that must be extracted before moving on with the installation. This allows us to support dmg inside tar, zip inside dmg, etc.
-| `container type:`      | no                            | Symbol to override container-type autodetect. May be one of: `:air`, `:bz2`, `:cab`, `:dmg`, `:generic_unar`, `:gzip`, `:otf`, `:pkg`, `:rar`, `:seven_zip`, `:sit`, `:tar`, `:ttf`, `:xar`, `:zip`, `:naked`. (Example: [parse.rb](https://github.com/Homebrew/homebrew-cask/blob/312ae841f1f1b2ec07f4d88b7dfdd7fbdf8d4f94/Casks/parse.rb#L11))
-| `auto_updates`         | no                            | `true`. Assert the Cask artifacts auto-update. Use if `Check for Updates…` or similar is present in app menu, but not if it only opens a webpage and does not do the download and installation for you.
+### Required stanzas
+
+Each of the following stanzas is required for every cask.
+
+| name                         | multiple occurrences allowed? | value |
+| ---------------------------- | :---------------------------: | ----- |
+| [`version`](#stanza-version) | no                            | Application version. |
+| [`sha256`](#stanza-sha256)   | no                            | SHA-256 checksum of the file downloaded from `url`, calculated by the command `shasum -a 256 <file>`. Can be suppressed by using the special value `:no_check`. |
+| [`url`](#stanza-url)         | no                            | URL to the `.dmg`/`.zip`/`.tgz`/`.tbz2` file that contains the application. A [comment](#when-url-and-homepage-domains-differ-add-verified) should be added if the domains in the `url` and `homepage` stanzas differ. Block syntax should be used for URLs that change on every visit. |
+| [`name`](#stanza-name)       | yes                           | String providing the full and proper name defined by the vendor. |
+| [`desc`](#stanza-desc)       | no                            | One-line description of the cask. Shown when running `brew info`. |
+| `homepage`                   | no                            | Application homepage; used for the `brew home` command. |
+| [`livecheck`](#stanza-livecheck)           | no                            | Ruby block describing how to find updates for this cask. Supersedes `appcast`. |
+| [`depends_on`](#stanza-depends_on)         | yes                           | List of dependencies and requirements for this cask. |
+| [`zap`](#stanza-zap)                       | yes                           | Additional procedures for a more complete uninstall, including user files and shared resources. |
+
+### At least one artifact stanza is also required
+
+Each cask must declare one or more *artifacts* (i.e. something to install).
+
+| name                             | multiple occurrences allowed? | value |
+| -------------------------------- | :---------------------------: | ----- |
+| [`app`](#stanza-app)             | yes                           | Relative path to an `.app` that should be moved into the `/Applications` folder on installation. |
+| [`suite`](#stanza-suite)         | yes                           | Relative path to a containing directory that should be moved into the `/Applications` folder on installation. |
+| [`pkg`](#stanza-pkg)             | yes                           | Relative path to a `.pkg` file containing the distribution. |
+| [`installer`](#stanza-installer) | yes                           | Describes an executable which must be run to complete the installation. |
+| [`binary`](#stanza-binary)       | yes                           | Relative path to a Binary that should be linked into the `$(brew --prefix)/bin` folder on installation. |
+| `manpage`                        | yes                           | Relative path to a Man Page that should be linked into the respective man page folder on installation, e.g. `/usr/local/share/man/man3` for `my_app.3`. |
+| `colorpicker`                    | yes                           | Relative path to a ColorPicker plugin that should be moved into the `~/Library/ColorPickers` folder on installation. |
+| `dictionary`                     | yes                           | Relative path to a Dictionary that should be moved into the `~/Library/Dictionaries` folder on installation. |
+| `font`                           | yes                           | Relative path to a Font that should be moved into the `~/Library/Fonts` folder on installation. |
+| `input_method`                   | yes                           | Relative path to an Input Method that should be moved into the `~/Library/Input Methods` folder on installation. |
+| `internet_plugin`                | yes                           | Relative path to an Internet Plugin that should be moved into the `~/Library/Internet Plug-Ins` folder on installation. |
+| `keyboard_layout`                | yes                           | Relative path to a Keyboard Layout that should be moved into the `/Library/Keyboard Layouts` folder on installation. |
+| `prefpane`                       | yes                           | Relative path to a Preference Pane that should be moved into the `~/Library/PreferencePanes` folder on installation. |
+| `qlplugin`                       | yes                           | Relative path to a Quick Look Plugin that should be moved into the `~/Library/QuickLook` folder on installation. |
+| `mdimporter`                     | yes                           | Relative path to a Spotlight Metadata Importer that should be moved into the `~/Library/Spotlight` folder on installation. |
+| `screen_saver`                   | yes                           | Relative path to a Screen Saver that should be moved into the `~/Library/Screen Savers` folder on installation. |
+| `service`                        | yes                           | Relative path to a Service that should be moved into the `~/Library/Services` folder on installation. |
+| `audio_unit_plugin`              | yes                           | Relative path to an Audio Unit Plugin that should be moved into the `~/Library/Audio/Components` folder on installation. |
+| `vst_plugin`                     | yes                           | Relative path to a VST Plugin that should be moved into the `~/Library/Audio/VST` folder on installation. |
+| `vst3_plugin`                    | yes                           | Relative path to a VST3 Plugin that should be moved into the `~/Library/Audio/VST3` folder on installation. |
+| `artifact`                       | yes                           | Relative path to an arbitrary path that should be moved on installation. Must provide an absolute path as a `target`. (Example: [free-gpgmail.rb](https://github.com/Homebrew/homebrew-cask/blob/b3c438d608d9702380edf10d5495e0727cf17108/Casks/f/free-gpgmail.rb#L44)) This is only for unusual cases; the `app` stanza is strongly preferred when moving `.app` bundles. |
+| `stage_only`                     | no                            | `true`. Asserts that the cask contains no activatable artifacts. |
+
+### Optional stanzas
+
+| name                                       | multiple occurrences allowed? | value |
+| ------------------------------------------ | :---------------------------: | ----- |
+| [`uninstall`](#stanza-uninstall)           | yes                           | Procedures to uninstall a cask. Optional unless the `pkg` stanza is used. |
+| [`conflicts_with`](#stanza-conflicts_with) | yes                           | List of conflicts with this cask (*not yet functional*). |
+| [`caveats`](#stanza-caveats)               | yes                           | String or Ruby block providing the user with cask-specific information at install time. |
+| [`deprecate!`](#stanza-deprecate--disable) | no                            | Date as a String in `YYYY-MM-DD` format and a String or Symbol providing a reason. |
+| [`disable!`](#stanza-deprecate--disable)   | no                            | Date as a String in `YYYY-MM-DD` format and a String or Symbol providing a reason. |
+| `preflight`                                | yes                           | Ruby block containing preflight install operations (needed only in very rare cases). |
+| [`postflight`](#stanza-flight)             | yes                           | Ruby block containing postflight install operations. |
+| `uninstall_preflight`                      | yes                           | Ruby block containing preflight uninstall operations (needed only in very rare cases). |
+| `uninstall_postflight`                     | yes                           | Ruby block containing postflight uninstall operations. |
+| [`language`](#stanza-language)             | required                      | Ruby block, called with language code parameters, containing other stanzas and/or a return value. |
+| `container nested:`                        | no                            | Relative path to an inner container that must be extracted before moving on with the installation. This allows for support of `.dmg` inside `.tar`, `.zip` inside `.dmg`, etc. (Example: [blocs.rb](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/b/blocs.rb#L17-L19)) |
+| `container type:`                          | no                            | Symbol to override container-type autodetect. May be one of: `:air`, `:bz2`, `:cab`, `:dmg`, `:generic_unar`, `:gzip`, `:otf`, `:pkg`, `:rar`, `:seven_zip`, `:sit`, `:tar`, `:ttf`, `:xar`, `:zip`, `:naked`. (Example: [parse.rb](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/p/parse.rb#L10)) |
+| `auto_updates`                             | no                            | `true`. Asserts that the cask artifacts auto-update. Use if `Check for Updates…` or similar is present in an app menu, but not if it only opens a webpage and does not do the download and installation for you. |
 
 ## Stanza descriptions
 
@@ -251,72 +177,36 @@ by default moves the source to:
 /Applications/Alfred 2.app
 ```
 
-#### Renaming the Target
+#### Renaming the target
 
-You can rename the target which appears in your `/Applications` directory by adding a `target:` key to `app`. Example (from [scala-ide.rb](https://github.com/Homebrew/homebrew-cask/blob/312ae841f1f1b2ec07f4d88b7dfdd7fbdf8d4f94/Casks/scala-ide.rb#L21)):
+You can rename the target which appears in your `/Applications` directory by adding a `target:` key to `app`. Example (from [scala-ide.rb](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/s/scala-ide.rb#L24)):
 
 ```ruby
-app "eclipse/Eclipse.app", target: "Scala IDE.app"
+app "eclipse.app", target: "Scala IDE.app"
 ```
 
-#### target: May Contain an Absolute Path
+#### *target* may contain an absolute path
 
-If `target:` has a leading slash, it is interpreted as an absolute path. The containing directory for the absolute path will be created if it does not already exist. Example (from [manopen.rb](https://github.com/Homebrew/homebrew-cask/blob/312ae841f1f1b2ec07f4d88b7dfdd7fbdf8d4f94/Casks/manopen.rb#L12)):
+If `target:` has a leading slash, it is interpreted as an absolute path. The containing directory for the absolute path will be created if it does not already exist. Example (from [sapmachine-jdk.rb](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/s/sapmachine-jdk.rb#L21)):
 
 ```ruby
-artifact "openman.1", target: "/usr/local/share/man/man1/openman.1"
+artifact "sapmachine-jdk-#{version}.jdk", target: "/Library/Java/JavaVirtualMachines/sapmachine-jdk-#{version}.jdk"
 ```
 
-#### target: Works on Most Artifact Types
-
-The `target:` key works similarly for most Cask artifacts, such as `app`, `binary`, `colorpicker`, `dictionary`, `font`, `input_method`, `prefpane`, `qlplugin`, `mdimporter`, `service`, `suite`, and `artifact`.
-
-#### target: Should Only Be Used in Select Cases
-
-Don’t use `target:` for aesthetic reasons, like removing version numbers (`app "Slack #{version}.app", target: "Slack.app"`). Use it when it makes sense functionally and document your reason clearly in the Cask, using one of the templates: [for clarity](https://github.com/Homebrew/homebrew-cask/blob/312ae841f1f1b2ec07f4d88b7dfdd7fbdf8d4f94/Casks/imagemin.rb#L12); [for consistency](https://github.com/Homebrew/homebrew-cask/blob/d2a6b26df69fc28c4d84d6f5198b2b652c2f414d/Casks/devonthink-pro-office.rb#L16); [to prevent conflicts](https://github.com/Homebrew/homebrew-cask/blob/bd6dc1a64e0bdd35ba0e20789045ea023b0b6aed/Casks/flash-player-debugger.rb#L11); [due to developer suggestion](https://github.com/Homebrew/homebrew-cask/blob/ff3e9c4a6623af44b8a071027e8dcf3f4edfc6d9/Casks/kivy.rb#L12).
-
-### Stanza: `appcast`
-
-The value of the `appcast` stanza is a string, holding the URL for an appcast which provides information on future updates.
-
-Note: The [`livecheck` stanza](#stanza-livecheck) should be preferred in most cases, as it allows casks to be updated automatically.
-
-The main casks repo only accepts submissions for stable versions of software (and [documented exceptions](https://docs.brew.sh/Acceptable-Casks#but-there-is-no-stable-version)), but it still gets pull requests for unstable versions. By checking the submitted `version` against the contents of an appcast, we can better detect these invalid cases.
+#### *target* works on most artifact types
 
-Example: [`atom.rb`](https://github.com/Homebrew/homebrew-cask/blob/645dbb8228ec2f1f217ed1431e188687aac13ca5/Casks/atom.rb#L7)
+The `target:` key works similarly for most cask artifacts, such as `app`, `binary`, `colorpicker`, `dictionary`, `font`, `input_method`, `internet_plugin`, `keyboard_layout`, `prefpane`, `qlplugin`, `mdimporter`, `screen_saver`, `service`, `suite`, `audio_unit_plugin`, `vst_plugin`, `vst3_plugin`, and `artifact`.
 
-There are a few different ways the `appcast` can be determined:
+#### *target* should only be used in select cases
 
-* If the app is distributed via GitHub releases, the `appcast` will be of the form `https://github.com/<user>/<project_name>/releases.atom`. Example: [`electron.rb`](https://github.com/Homebrew/homebrew-cask/blob/645dbb8228ec2f1f217ed1431e188687aac13ca5/Casks/electron.rb#L7)
-
-* If the app is distributed via GitLab releases, the `appcast` will be of the form `https://gitlab.com/<user>/<project_name>/-/tags?format=atom`. Example: [`grafx.rb`](https://github.com/Homebrew/homebrew-cask/blob/b22381902f9da870bb07d21b496558f283dad612/Casks/grafx.rb#L6)
-
-* The popular update framework [Sparkle](https://sparkle-project.org/) generally uses the `SUFeedURL` property in `Contents/Info.plist` inside `.app` bundles. Example: [`glyphs.rb`](https://github.com/Homebrew/homebrew-cask/blob/645dbb8228ec2f1f217ed1431e188687aac13ca5/Casks/glyphs.rb#L6)
-
-* Sourceforge projects follow the form `https://sourceforge.net/projects/<project_name>/rss`. A more specific page can be used as needed, pointing to a specific directory structure: `https://sourceforge.net/projects/<project_name>/rss?path=/<path_here>`. Example: [`seashore.rb`](https://github.com/Homebrew/homebrew-cask/blob/645dbb8228ec2f1f217ed1431e188687aac13ca5/Casks/seashore.rb#L6)
-
-* An appcast can be any URL hosted by the app’s developer that changes every time a new release is out or that contains the version number of the current release (e.g. a download HTML page). Webpages that only change on new version releases are preferred, as are sites that do not contain previous version strings (i.e. avoid changelog pages if the download page contains the current version number but not older ones). Example: [`razorsql.rb`](https://github.com/Homebrew/homebrew-cask/blob/645dbb8228ec2f1f217ed1431e188687aac13ca5/Casks/razorsql.rb#L6)
-
-The [`find-appcast`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/developer/bin/find-appcast) script is able to identify some of these, as well as `electron-builder` appcasts which are trickier to find by hand. Run it with `"$(brew --repository homebrew/cask)/developer/bin/find-appcast" '</path/to/software.app>'`.
-
-#### Parameters
-
-| key             | value       |
-| --------------- | ----------- |
-| `must_contain:` | a custom string for `brew audit --appcast <cask>` to check against. |
-
-Sometimes a `version` doesn’t match a string on the webpage, in which case we tweak what to search for. Example: if `version` is `6.26.1440` and the appcast’s contents only show `6.24`, the check for “is `version` in the appcast feed” will fail. With `must_contain`, the check is told to “look for this string instead of `version`”. In the example, `must_contain: version.major_minor` is saying “look for `6.24`”, making the check succeed.
-
-If no `must_contain` is given, the check considers from the beginning of the `version` string until the first character that isn’t alphanumeric or a period. Example: if `version` is `6.26b-14,40`, the check will see `6.26b`. This is so it covers most cases by default, while still allowing complex `version`s suitable for interpolation on the rest of the cask.
-
-Example of using `must_contain`: [`hwsensors.rb`](https://github.com/Homebrew/homebrew-cask/blob/87bc3860f43d5b14d0c38ae8de469d24ee7f5b2f/Casks/hwsensors.rb#L6L7)
+Don’t use `target:` for aesthetic reasons, like removing version numbers (`app "Slack #{version}.app", target: "Slack.app"`). Use it when it makes sense functionally and document your reason clearly in the cask, using one of the templates: [for clarity](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/i/imagemin.rb#L10); [for consistency](https://github.com/Homebrew/homebrew-cask/blob/8be96e3658ff7ab66ca40723c3018fc5e35e3735/Casks/x-moto.rb#L16); [to prevent conflicts](https://github.com/Homebrew/homebrew-cask/blob/4472df441468e2aa657005550e2b951c2ef817f4/Casks/t/telegram-desktop.rb#L20); [due to developer suggestion](https://github.com/Homebrew/homebrew-cask/blob/ff3e9c4a6623af44b8a071027e8dcf3f4edfc6d9/Casks/kivy.rb#L12).
 
 ### Stanza: `binary`
 
-In the simple case of a string argument to `binary`, the source file is linked into the `$(brew --prefix)/bin` directory (typically `/usr/local/bin`) on installation. For example (from [operadriver.rb](https://github.com/Homebrew/homebrew-cask/blob/60531a2812005dd5f17dc92f3ce7419af3c5d019/Casks/operadriver.rb#L11)):
+In the simple case of a string argument to `binary`, the source file is linked into the `$(brew --prefix)/bin` directory on installation. For example (from [operadriver.rb](https://github.com/Homebrew/homebrew-cask/blob/326c44e93aeb8d4dd73acea14a99ae215c75fdd6/Casks/o/operadriver.rb#L15)):
 
 ```ruby
-binary "operadriver"
+binary "operadriver_mac64/operadriver"
 ```
 
 creates a symlink to:
@@ -328,7 +218,7 @@ $(brew --prefix)/bin/operadriver
 from a source file such as:
 
 ```bash
-/usr/local/Caskroom/operadriver/0.2.2/operadriver
+$(brew --caskroom)/operadriver/106.0.5249.119/operadriver_mac64/operadriver
 ```
 
 A binary (or multiple) can also be contained in an application bundle:
@@ -344,7 +234,7 @@ You can rename the target which appears in your binaries directory by adding a `
 binary "#{appdir}/Atom.app/Contents/Resources/app/atom.sh", target: "atom"
 ```
 
-Behaviour and usage of `target:` is [the same as with `app`](#renaming-the-target). However, for `binary` the select cases don’t apply as rigidly. It’s fine to take extra liberties with `target:` to be consistent with other command-line tools, like [changing case](https://github.com/Homebrew/homebrew-cask/blob/9ad93b833961f1d969505bc6bdb1c2ad4e58a433/Casks/openscad.rb#L12), [removing an extension](https://github.com/Homebrew/homebrew-cask/blob/c443d4f5c6864538efe5bb1ecf662565a5ffb438/Casks/filebot.rb#L13), or [cleaning up the name](https://github.com/Homebrew/homebrew-cask/blob/146917cbcc679648de6b0bccff4e9b43fce0e6c8/Casks/minishift.rb#L13).
+Behaviour and usage of `target:` is [the same as with `app`](#renaming-the-target). However, for `binary` the select cases don’t apply as rigidly. It’s fine to take extra liberties with `target:` to be consistent with other command-line tools, like [changing case](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/g/godot.rb#L19), [removing an extension](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/f/filebot.rb#L19), or [cleaning up the name](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/f/fig.rb#L21).
 
 ### Stanza: `caveats`
 
@@ -352,29 +242,29 @@ Sometimes there are particularities with the installation of a piece of software
 
 To avoid flooding users with too many messages (thus desensitising them to the important ones), `caveats` should be used sparingly and exclusively for installation-related matters. If you’re not sure a `caveat` you find pertinent is installation-related or not, ask a maintainer. As a general rule, if your case isn’t already covered in our comprehensive [`caveats Mini-DSL`](#caveats-mini-dsl), it’s unlikely to be accepted.
 
-#### caveats as a String
+#### `caveats` as a string
 
-When `caveats` is a string, it is evaluated at compile time. The following methods are available for interpolation if `caveats` is placed in its customary position at the end of the Cask:
+When `caveats` is a string, it is evaluated at compile time. The following methods are available for interpolation if `caveats` is placed in its customary position at the end of the cask:
 
 | method             | description |
 | ------------------ | ----------- |
-| `token`            | the Cask token
-| `version`          | the Cask version
-| `homepage`         | the Cask homepage
-| `caskroom_path`    | the containing directory for this Cask, typically `/usr/local/Caskroom/<token>` (only available with block form)
-| `staged_path`      | the staged location for this Cask, including version number: `/usr/local/Caskroom/<token>/<version>` (only available with block form)
+| `token`            | the cask token |
+| `version`          | the cask version |
+| `homepage`         | the cask homepage |
+| `caskroom_path`    | the containing directory for this cask: `$(brew --caskroom)/<token>` (only available with block form) |
+| `staged_path`      | the staged location for this cask, including version number: `$(brew --caskroom)/<token>/<version>` (only available with block form) |
 
 Example:
 
 ```ruby
-caveats "Using #{token} is hazardous to your health."
+caveats "Using #{token} may be hazardous to your health."
 ```
 
-#### caveats as a Block
+#### `caveats` as a block
 
-When `caveats` is a Ruby block, evaluation is deferred until install time. Within a block you may refer to the `@cask` instance variable, and invoke any method available on `@cask`.
+When `caveats` is a Ruby block, evaluation is deferred until install time. Within a block you may refer to the `@cask` instance variable, and invoke [any method available on `@cask`](https://rubydoc.brew.sh/Cask/Cask).
 
-#### caveats Mini-DSL
+#### `caveats` mini-DSL
 
 There is a mini-DSL available within `caveats` blocks.
 
@@ -382,17 +272,17 @@ The following methods may be called to generate standard warning messages:
 
 | method                             | description |
 | ---------------------------------- | ----------- |
-| `path_environment_variable "path"` | users should make sure `path` is in their `$PATH` environment variable.
-| `zsh_path_helper "path"`           | zsh users must take additional steps to make sure `path` is in their `$PATH` environment variable.
-| `depends_on_java "version"`        | users should make sure they have the specified version of java installed. `version` can be exact (e.g. `6`), a minimum (e.g. `7+`), or omitted (when any version works).
-| `logout`                           | users should log out and log back in to complete installation.
-| `reboot`                           | users should reboot to complete installation.
-| `files_in_usr_local`               | the Cask installs files to `/usr/local`, which may confuse Homebrew.
-| `discontinued`                     | all software development has been officially discontinued upstream.
-| `free_license "web_page"`          | users may get an official license to use the software at `web_page`.
-| `kext`                             | users may need to enable their kexts in System Preferences → Security & Privacy → General.
-| `unsigned_accessibility`           | users will need to re-enable the app on each update in System Preferences → Security & Privacy → Privacy as it is unsigned.
-| `license "web_page"`               | software has a usage license at `web_page`.
+| `path_environment_variable "path"` | Users should make sure `path` is in their `PATH` environment variable. |
+| `zsh_path_helper "path"`           | `zsh` users must take additional steps to make sure `path` is in their `PATH` environment variable. |
+| `depends_on_java "version"`        | Users should make sure they have the specified version of Java installed. `version` can be exact (e.g. `6`), a minimum (e.g. `7+`), or omitted (when any version works). |
+| `requires_rosetta`                 | The cask requires Rosetta 2 for it to run on Apple Silicon. |
+| `logout`                           | Users should log out and log back in to complete installation. |
+| `reboot`                           | Users should reboot to complete installation. |
+| `files_in_usr_local`               | The cask installs files to `/usr/local`, which may confuse Homebrew. |
+| `kext`                             | Users may need to enable their kexts in *System Settings → Privacy & Security* (or *System Preferences → Security & Privacy → General* in earlier macOS versions). |
+| `unsigned_accessibility`           | Users will need to re-enable the app on each update in *System Settings → Privacy & Security* (or *System Preferences → Security & Privacy → Privacy* in earlier macOS versions) as it is unsigned. |
+| `license "web_page"`               | Users may find the software's usage license at `web_page`. |
+| `free_license "web_page"`          | Users may obtain an official license to use the software at `web_page`. |
 
 Example:
 
@@ -402,27 +292,64 @@ caveats do
 end
 ```
 
+### Stanza: `deprecate!` / `disable!`
+
+`deprecate!` and `disable!` are used to declare that a cask is no longer functional or supported.
+Casks that contain a `deprecate!` stanza can still be installed, but will print a warning message when they are installed or upgraded.
+Casks that contain a `disable!` stanza cannot be installed or upgraded and will print an error message.
+
+The syntax for both stanzas is the same:
+
+```ruby
+deprecate! date: "YYYY-MM-DD", because: "is ..."
+disable! date: "YYYY-MM-DD", because: "is ..."
+
+# Or with a preset reason (see the `because:` argument section below)
+deprecate! date: "YYYY-MM-DD", because: :discontinued
+disable! date: "YYYY-MM-DD", because: :discontinued
+```
+
+#### `date:` argument
+
+The `date:` argument controls when the deprecation or disabling will take effect.
+Casks that have a `deprecate!` stanza with a date in the future will not be treated as being deprecated until that date.
+Casks that have a `disable!` stanza with a date in the future will be automatically deprecated until that date, at which point they will be disabled.
+
+#### `because:` argument
+
+The `because:` argument accepts a reason for the cask being deprecated or disabled.
+The info message will be `<cask> is deprecated because it <reason>!`, so format the reason to fit that sentence.
+For example, `because: "is broken"` will result in `<cask> is deprecated because it is broken!`.
+
+The `because:` argument can also accept a symbol that corresponds to a preset reason, for example:
+
+```ruby
+deprecate! date: "YYYY-MM-DD", because: :discontinued
+```
+
+A complete list of allowable symbols can be found in the [`DeprecateDisable` module](https://github.com/Homebrew/brew/blob/master/Library/Homebrew/deprecate_disable.rb).
+
 ### Stanza: `conflicts_with`
 
-`conflicts_with` is used to declare conflicts that keep a Cask from installing or working correctly.
+`conflicts_with` is used to declare conflicts that keep a cask from installing or working correctly.
 
-#### conflicts_with cask
+#### `conflicts_with` *cask*
 
-The value should be another Cask token.
+The value should be another cask token.
 
-Example use: [`wireshark`](https://github.com/Homebrew/homebrew-cask/blob/903493e09cf33b845e7cf497ecf9cfc9709087ee/Casks/wireshark.rb#L10), which conflicts with `wireshark-chmodbpf`.
+Example: the [macFUSE](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/m/macfuse.rb#L17) cask, which conflicts with `macfuse-dev`.
 
 ```ruby
-conflicts_with cask: "wireshark-chmodbpf"
+conflicts_with cask: "macfuse-dev"
 ```
 
-#### conflicts_with formula
+#### `conflicts_with` *formula*
 
-Note: `conflicts_with formula:` is a stub and is not yet functional.
+**Note:** `conflicts_with formula:` is a stub and is not yet functional.
 
 The value should be another formula name.
 
-Example use: [`macvim`](https://github.com/Homebrew/homebrew-cask/blob/84b90afd7b571e581f8a48d4bdf9c7bb24ebff3b/Casks/macvim.rb#L10), which conflicts with the `macvim` formula.
+Example: [MacVim](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/m/macvim.rb#L16), which conflicts with the `macvim` formula.
 
 ```ruby
 conflicts_with formula: "macvim"
@@ -430,48 +357,35 @@ conflicts_with formula: "macvim"
 
 ### Stanza: `depends_on`
 
-`depends_on` is used to declare dependencies and requirements for a Cask.
-`depends_on` is not consulted until `install` is attempted.
+`depends_on` is used to declare dependencies and requirements for a cask. `depends_on` is not consulted until `install` is attempted.
 
-#### depends_on cask
+#### `depends_on` *cask*
 
-The value should be another Cask token, needed by the current Cask.
+The value should be another cask token, needed by the current cask.
 
-Example use: [`cellery`](https://github.com/Homebrew/homebrew-cask/blob/4002df8f6bca93ed6eb40494995fcfa038cf99bf/Casks/cellery.rb#L11) depends on OSXFUSE:
+Example: [NTFSTool](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/n/ntfstool.rb#L11), which depends on macFUSE.
 
 ```ruby
-depends_on cask: "osxfuse"
+depends_on cask: "macfuse"
 ```
 
-#### depends_on formula
+#### `depends_on` *formula*
 
-The value should name a Homebrew Formula needed by the Cask.
+The value should name a Homebrew formula needed by the cask.
 
-Example use: some distributions are contained in archive formats such as `7z` which are not supported by stock Apple tools. For these cases, a more capable archive reader may be pulled in at install time by declaring a dependency on the Homebrew Formula `unar`:
+Example: some distributions are contained in archive formats such as `7z` which are not supported by stock Apple tools. For these cases, a more capable archive reader may be pulled in at install time by declaring a dependency on the `unar` formula:
 
 ```ruby
 depends_on formula: "unar"
 ```
 
-#### depends_on macos
-
-##### Requiring an Exact macOS Release
-
-The value for `depends_on macos:` may be a symbol or an array of symbols, listing the exact compatible macOS releases.
+#### `depends_on` *macos*
 
-The available values for macOS releases are:
+##### Requiring an exact macOS release
 
-| symbol             | corresponding release
-| -------------------|----------------------
-| `:el_capitan`      | `10.11`
-| `:sierra`          | `10.12`
-| `:high_sierra`     | `10.13`
-| `:mojave`          | `10.14`
-| `:catalina`        | `10.15`
-| `:big_sur`         | `11.0`
-| `:monterey`        | `12.0`
+The value for `depends_on macos:` may be a symbol or an array of symbols, listing the exact compatible macOS releases. The available values for macOS releases are defined in the [MacOSVersion class](https://rubydoc.brew.sh/MacOSVersion.html).
 
-Only major releases are covered (version numbers containing a single dot). The symbol form is used for readability. The following are all valid ways to enumerate the exact macOS release requirements for a Cask:
+Only major releases are covered (10.x numbers containing a single dot or whole numbers since macOS 11). The symbol form is used for readability. The following are all valid ways to enumerate the exact macOS release requirements for a cask:
 
 ```ruby
 depends_on macos: :big_sur
@@ -481,7 +395,7 @@ depends_on macos: [
 ]
 ```
 
-##### Setting a Minimum macOS Release
+##### Setting a minimum macOS release
 
 `depends_on macos:` can also accept a string starting with a comparison operator such as `>=`, followed by an macOS release in the form above. The following is a valid expression meaning “at least macOS Big Sur (11.0)”:
 
@@ -491,17 +405,17 @@ depends_on macos: ">= :big_sur"
 
 A comparison expression cannot be combined with any other form of `depends_on macos:`.
 
-#### depends_on arch
+#### `depends_on` *arch*
 
-The value for `depends_on arch:` may be a symbol or an array of symbols, listing the hardware compatibility requirements for a Cask. The requirement is satisfied at install time if any one of multiple `arch:` value matches the user’s hardware.
+The value for `depends_on arch:` may be a symbol or an array of symbols, listing the hardware compatibility requirements for a cask. The requirement is satisfied at install time if any one of multiple `arch:` values matches the user’s hardware.
 
 The available symbols for hardware are:
 
 | symbol     | meaning        |
 | ---------- | -------------- |
-| `:x86_64`  | 64-bit Intel   |
-| `:intel`   | 64-bit Intel   |
-| `:arm64`   | Apple Silicon  |
+| `:x86_64`  | 64-bit Intel |
+| `:intel`   | 64-bit Intel |
+| `:arm64`   | Apple Silicon |
 
 The following are all valid expressions:
 
@@ -512,21 +426,21 @@ depends_on arch: [:x86_64]          # same meaning as above
 depends_on arch: :arm64
 ```
 
-#### All depends_on Keys
+#### `depends_on` parameters
 
 | key        | description |
 | ---------- | ----------- |
-| `formula:` | a Homebrew Formula
-| `cask:`    | a Cask token
-| `macos:`   | a symbol, string, array, or comparison expression defining macOS release requirements
-| `arch:`    | a symbol or array defining hardware requirements
-| `java:`    | *stub - not yet functional*
+| `formula:` | Homebrew formula |
+| `cask:`    | cask token |
+| `macos:`   | symbol, array, or string comparison expression defining macOS release requirements |
+| `arch:`    | symbol or array defining hardware requirements |
+| `java:`    | *stub - not yet functional* |
 
 ### Stanza: `desc`
 
 `desc` accepts a single-line UTF-8 string containing a short description of the software. It’s used to help with searchability and disambiguation, thus it must concisely describe what the software does (or what you can accomplish with it).
 
-`desc` is not for app slogans! Vendors’ descriptions tend to be filled with generic adjectives such as “modern” and “lightweight”. Those are meaningless marketing fluff (do you ever see apps proudly describing themselves as outdated and bulky?) which must the deleted. It’s fine to use the information on the software’s website as a starting point, but it will require editing in almost all cases.
+`desc` is not for app slogans! Vendors’ descriptions tend to be filled with generic adjectives such as “modern” and “lightweight”. Those are meaningless marketing fluff (do you ever see apps proudly describing themselves as outdated and bulky?) which must be deleted. It’s fine to use the information on the software’s website as a starting point, but it will require editing in almost all cases.
 
 #### Dos and Don'ts
 
@@ -544,7 +458,7 @@ depends_on arch: :arm64
   + desc "Sound and music editor"
   ```
 
-* **Do** describe what the software does or is:
+* **Do** describe what the software does or is.
 
   ```diff
   - desc "Development of musical ideas made easy"
@@ -558,14 +472,14 @@ depends_on arch: :arm64
   + desc "Sound and music editor"
   ```
 
-* **Do not** include the Cask’s [name](#stanza-name).
+* **Do not** include the cask’s [name](#stanza-name).
 
   ```diff
   - desc "Ableton Live is a sound and music editor"
   + desc "Sound and music editor"
   ```
 
-* **Do not** include the vendor. This should be added to the Cask’s [name](#stanza-name) instead.
+* **Do not** include the vendor. This should be added to the cask’s [name](#stanza-name) instead.
 
   ```diff
   - desc "Sound and music editor made by Ableton"
@@ -586,13 +500,15 @@ depends_on arch: :arm64
   + desc "Sound and music editor"
   ```
 
-### Stanza: `\*flight`
+### Stanza: `*flight`
 
-#### Evaluation of Blocks is Always Deferred
+The stanzas `preflight`, `postflight`, `uninstall_preflight`, and `uninstall_postflight` define operations to be run before or after installation or uninstallation.
 
-The Ruby blocks defined by `preflight`, `postflight`, `uninstall_preflight`, and `uninstall_postflight` are not evaluated until install time or uninstall time. Within a block, you may refer to the `@cask` instance variable, and invoke any method available on `@cask`.
+#### Evaluation of blocks is always deferred
 
-#### \*flight Mini-DSL
+The Ruby blocks defined by these stanzas are not evaluated until install time or uninstall time. Within a block you may refer to the `@cask` instance variable, and invoke [any method available on `@cask`](https://rubydoc.brew.sh/Cask/Cask).
+
+#### `*flight` mini-DSL
 
 There is a mini-DSL available within these blocks.
 
@@ -600,10 +516,10 @@ The following methods may be called to perform standard tasks:
 
 | method                                    | availability                                     | description |
 | ----------------------------------------- | ------------------------------------------------ | ----------- |
-| `set_ownership(paths)`                    | `preflight`, `postflight`, `uninstall_preflight` | set user and group ownership of `paths`. Example: [`unifi-controller.rb`](https://github.com/Homebrew/homebrew-cask/blob/8a452a41707af6a661049da6254571090fac5418/Casks/unifi-controller.rb#L13)
-| `set_permissions(paths, permissions_str)` | `preflight`, `postflight`, `uninstall_preflight` | set permissions in `paths` to `permissions_str`. Example: [`docker-machine.rb`](https://github.com/Homebrew/homebrew-cask/blob/8a452a41707af6a661049da6254571090fac5418/Casks/docker-machine.rb#L16)
+| `set_ownership(paths)`                    | `preflight`, `postflight`, `uninstall_preflight` | Set user and group ownership of `paths`. (Example: [docker-toolbox.rb](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/d/docker-toolbox.rb#L42)) |
+| `set_permissions(paths, permissions_str)` | `preflight`, `postflight`, `uninstall_preflight` | Set permissions in `paths` to `permissions_str`. (Example: [ngrok.rb](https://github.com/Homebrew/homebrew-cask/blob/41d91ff669d85343175202adf568e2328486205f/Casks/n/ngrok.rb#L30)) |
 
-`set_ownership(paths)` defaults user ownership to the current user and group ownership to `staff`. These can be changed by passing in extra options: `set_ownership(paths, user: 'user', group: 'group')`.
+`set_ownership(paths)` defaults user ownership to the current user and group ownership to `staff`. These can be changed by passing in extra options: `set_ownership(paths, user: "user", group: "group")`. (Example: [hummingbird.rb](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/h/hummingbird.rb#L24))
 
 ### Stanza: `installer`
 
@@ -611,33 +527,33 @@ This stanza must always be accompanied by [`uninstall`](#stanza-uninstall).
 
 The `installer` stanza takes a series of key-value pairs, the first key of which must be `manual:` or `script:`.
 
-#### installer manual
+#### `installer` *manual*
 
-`installer manual:` takes a single string value, describing a GUI installer which must be run by the user at a later time. The path may be absolute, or relative to the Cask. Example (from [nutstore.rb](https://github.com/Homebrew/homebrew-cask/blob/249ec31048591308e63e50f79dae01d2f933cccf/Casks/nutstore.rb#L9)):
+`installer manual:` takes a single string value, describing a GUI installer which must be run by the user at a later time. The path may be absolute, or relative to the cask. Example (from [rubymotion.rb](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/r/rubymotion.rb#L15)):
 
 ```ruby
-installer manual: "Nutstore Installer.app"
+installer manual: "RubyMotion Installer.app"
 ```
 
-#### installer script
+#### `installer` *script*
 
-`installer script:` introduces a series of key-value pairs describing a command which will automate completion of the install. **It should never be used for interactive installations.** The form is similar to `uninstall script:`:
+`installer script:` introduces a series of key-value pairs describing a command which will automate completion of the install. **It should never be used for interactive installations.** The form is similar to [`uninstall script:`](#uninstall-script):
 
-| key             | value
-| ----------------|------------------------------
-| `executable:`   | path to an install script to be run
-| `args:`         | array of arguments to the install script
-| `input:`        | array of lines of input to be sent to `stdin` of the script
-| `must_succeed:` | set to `false` if the script is allowed to fail
-| `sudo:`         | set to `true` if the script needs `sudo`
+| key             | value |
+| --------------- | ----- |
+| `executable:`   | path to an install script to be run |
+| `args:`         | array of arguments to the install script |
+| `input:`        | array of lines of input to be sent to `stdin` of the script |
+| `must_succeed:` | set to `false` if the script is allowed to fail |
+| `sudo:`         | set to `true` if the script needs *sudo* |
 
-The path may be absolute, or relative to the Cask. Example (from [miniforge.rb](https://github.com/Homebrew/homebrew-cask/blob/ed2033fb3578376c3ee58a2cb459ef96fa6eb37d/Casks/miniforge.rb#L15L18)):
+The path may be absolute, or relative to the cask. Example (from [miniforge.rb](https://github.com/Homebrew/homebrew-cask/blob/864f623e2cd17dbde5987a7b3923fdb0b4ac9ee5/Casks/m/miniforge.rb#L23-L26)):
 
 ```ruby
-  installer script: {
-    executable: "Miniforge3-#{version}-MacOSX-x86_64.sh",
-    args:       ["-b", "-p", "#{caskroom_path}/base"],
-  }
+installer script: {
+  executable: "Miniforge3-#{version}-MacOSX-x86_64.sh",
+  args:       ["-b", "-p", "#{caskroom_path}/base"],
+}
 ```
 
 If the `installer script:` does not require any of the key-values it can point directly to the path of the install script:
@@ -648,7 +564,7 @@ installer script: "#{staged_path}/install.sh"
 
 ### Stanza: `language`
 
-The `language` stanza can match [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) language codes, regional identifiers ([ISO 3166-1 Alpha 2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)) and script codes ([ISO 15924](https://en.wikipedia.org/wiki/ISO_15924)), or a combination thereof.
+The `language` stanza can match [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) language codes, script codes ([ISO 15924](https://en.wikipedia.org/wiki/ISO_15924)) and regional identifiers ([ISO 3166-1 Alpha 2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)), or a combination thereof.
 
 US English should always be used as the default language:
 
@@ -688,95 +604,39 @@ The return value of the matching `language` block can be accessed by simply call
 homepage "https://example.org/#{language}"
 ```
 
-Examples: [Firefox](https://github.com/Homebrew/homebrew-cask/blob/306b8fbd9502036f1ca742f70c569d8677b62403/Casks/firefox.rb#L4L74), [Battle.net](https://github.com/Homebrew/homebrew-cask/blob/306b8fbd9502036f1ca742f70c569d8677b62403/Casks/battle-net.rb#L5L17)
+Examples: [firefox.rb](https://github.com/Homebrew/homebrew-cask/blob/939b4331dc2a6860350d66a1b2c7b3f22442cc08/Casks/f/firefox.rb#L4-L207), [battle-net.rb](https://github.com/Homebrew/homebrew-cask/blob/e039d079560cf2f77b671f7dda4752a053341180/Casks/b/battle-net.rb#L5-L10)
 
 #### Installation
 
 To install a cask in a specific language, you can pass the `--language=` option to `brew install`:
 
-```
+```bash
 brew install firefox --language=it
 ```
 
 ### Stanza: `livecheck`
 
-The `livecheck` stanza is used to automatically fetch the latest version of a cask from changelogs, release notes, appcasts, etc. See also: [`brew livecheck` reference](Brew-Livecheck.md)
-
-Every `livecheck` block must contain a `url`, which can either be a string or a symbol pointing to other URLs in the cask (`:url` or `:homepage`).
-
-Additionally, a `livecheck` should specify which `strategy` should be used to extract the version:
-
-| `strategy`      | Description |
-|-----------------|-----------|
-| `:header_match` | extract version from HTTP headers (e.g. `Location` or `Content-Disposition`) |
-| `:page_match`   | extract version from page contents                                           |
-| `:sparkle`      | extract version from Sparkle appcast contents                                |
-
-Here is a basic example, extracting a simple version from a page:
-
-```ruby
-livecheck do
-  url "https://example.org/my-app/download"
-  strategy :page_match
-  regex(%r{href=.*?/MyApp-(\d+(?:\.\d+)*)\.zip}i)
-end
-```
-
-If the download URL is present on the homepage, we can use a symbol instead of a string:
-
-```ruby
-livecheck do
-  url :homepage
-  strategy :page_match
-  regex(%r{href=.*?/MyApp-(\d+(?:\.\d+)*)\.zip}i)
-end
-```
-
-The `header_match` strategy will try parsing a version from the filename (in the `Content-Disposition` header) and the final URL (in the `Location` header). If that doesn't work, a `regex` can be specified, e.g.:
-
-```ruby
-strategy :header_match
-regex(/MyApp-(\d+(?:\.\d+)*)\.zip/i)
-```
-
-If the version depends on multiple header fields, a block can be specified, e.g.
+The `livecheck` stanza is used to automatically fetch the latest version of a cask from changelogs, release notes, appcasts, etc.
 
-```ruby
-strategy :header_match do |headers|
-  v = headers["content-disposition"][/MyApp-(\d+(?:\.\d+)*)\.zip/i, 1]
-  id = headers["location"][%r{/(\d+)/download$}i, 1]
-  next if v.blank? || id.blank?
-
-  "#{v},#{id}"
-end
-```
+Every `livecheck` block must contain a `url`, which can be either a string or a symbol pointing to other URLs in the cask (`:url` or `:homepage`).
 
-Similarly, the `:page_match` strategy can also be used for more complex versions by specifying a block:
-
-```ruby
-strategy :page_match do |page|
-  match = page.match(%r{href=.*?/(\d+)/MyApp-(\d+(?:\.\d+)*)\.zip}i)
-  next if match.blank?
-
-  "#{match[2]},#{match[1]}"
-end
-```
+Refer to the [`brew livecheck` documentation](Brew-Livecheck.md) for how to write a `livecheck` block.
 
 ### Stanza: `name`
 
 `name` accepts a UTF-8 string defining the name of the software, including capitalization and punctuation. It is used to help with searchability and disambiguation.
 
-Unlike the [token](#token-reference), which is simplified and reduced to a limited set of characters, the `name` stanza can include the proper capitalization, spacing and punctuation to match the official name of the software. For disambiguation purposes, it is recommended to spell out the name of the application, and including the vendor name if necessary. A good example is [`pycharm-ce`](https://github.com/Homebrew/homebrew-cask/blob/fc05c0353aebb28e40db72faba04b82ca832d11a/Casks/pycharm-ce.rb#L6-L7), whose name is spelled out as `Jetbrains PyCharm Community Edition`, even though it is likely never referenced as such anywhere.
+Unlike the [token](#token-reference), which is simplified and reduced to a limited set of characters, the `name` stanza can include the proper capitalization, spacing and punctuation to match the official name of the software. For disambiguation purposes, it is recommended to spell out the name of the application, including the vendor name if necessary. A good example is the [`pycharm-ce`](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/p/pycharm-ce.rb#L9-L10) cask, whose name is spelled out as `Jetbrains PyCharm Community Edition`, even though it is likely never referenced as such anywhere.
 
-Additional details about the software can be provided in the [desc](#stanza-desc) stanza.
+Additional details about the software can be provided in the [`desc` stanza](#stanza-desc).
 
-The `name` stanza can be repeated multiple times if there are useful alternative names. The first instance should use the Latin alphabet. For example, see the [`cave-story`](https://github.com/Homebrew/homebrew-cask/blob/0fe48607f5656e4f1de58c6884945378b7e6f960/Casks/cave-story.rb#L7-L9) cask, whose original name does not use the Latin alphabet.
+The `name` stanza can be repeated multiple times if there are useful alternative names. The first instance should use the Latin alphabet. For example, see the [`cave-story`](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/c/cave-story.rb#L58-L60) cask, whose original name does not use the Latin alphabet.
 
 ### Stanza: `pkg`
 
-This stanza must always be accompanied by [`uninstall`](#stanza-uninstall)
+This stanza must always be accompanied by [`uninstall`](#stanza-uninstall).
 
-The first argument to the `pkg` stanza should be a relative path to the `.pkg` file to be installed. For example:
+The first argument to the `pkg` stanza should be a relative path to the `.pkg` file to be installed. Example:
 
 ```ruby
 pkg "Unity.pkg"
@@ -784,79 +644,74 @@ pkg "Unity.pkg"
 
 Subsequent arguments to `pkg` are key/value pairs which modify the install process. Currently supported keys are `allow_untrusted:` and `choices:`.
 
-#### `pkg allow_untrusted:`
+#### `pkg` *allow_untrusted*
 
-`pkg allow_untrusted: true` can be used to install the `.pkg` with an untrusted certificate passing `-allowUntrusted` to `/usr/sbin/installer`.
+`pkg allow_untrusted: true` can be used to install a `.pkg` containing an untrusted certificate by passing `-allowUntrusted` to `/usr/sbin/installer`.
 
-This option is not permitted in official Homebrew Cask taps, it is only provided for use in third-party taps or local Casks.
+This option is not permitted in official Homebrew Cask taps; it is only provided for use in third-party taps or local casks.
 
-Example ([alinof-timer.rb](https://github.com/Homebrew/homebrew-cask/blob/312ae841f1f1b2ec07f4d88b7dfdd7fbdf8d4f94/Casks/alinof-timer.rb#L10)):
+Historical example (from [alinof-timer.rb](https://github.com/Homebrew/homebrew-cask/blob/312ae841f1f1b2ec07f4d88b7dfdd7fbdf8d4f94/Casks/alinof-timer.rb#L10)):
 
 ```ruby
 pkg "AlinofTimer.pkg", allow_untrusted: true
 ```
 
-#### `pkg choices:`
+#### `pkg` *choices*
 
-`pkg choices:` can be used to override `.pkg`’s default install options via `-applyChoiceChangesXML`. It uses a deserialized version of the `choiceChanges` property list (refer to the `CHOICE CHANGES FILE` section of the `installer` manual page by running `man -P 'less --pattern "^CHOICE CHANGES FILE"' installer`).
+`pkg choices:` can be used to override a `.pkg`’s default install options via `-applyChoiceChangesXML`. It uses a deserialized version of the `choiceChanges` property list (refer to the `CHOICE CHANGES FILE` section of the `installer` manual page by running `man -P 'less --pattern "^CHOICE CHANGES FILE"' installer`).
 
-Running the  macOS command:
+Running this macOS `installer` command:
 
 ```bash
 installer -showChoicesXML -pkg '/path/to/my.pkg'
 ```
 
-will output an XML which you can use to extract the `choices:` values, as well as their equivalents to the GUI options.
+will output XML that you can use to extract the `choices:` values, as well as their equivalents to the GUI options.
 
 See [this pull request for wireshark-chmodbpf](https://github.com/Homebrew/homebrew-cask/pull/26997) and [this one for wine-staging](https://github.com/Homebrew/homebrew-cask/pull/27937) for some examples of the procedure.
 
-Example ([wireshark-chmodbpf.rb](https://github.com/Homebrew/homebrew-cask/blob/f95b8a8306b91fe9da7908b842f4a5fa80f7afe0/Casks/wireshark-chmodbpf.rb#L9-L26)):
+Example (from [lando.rb](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/l/lando.rb#L21-L33)):
 
 ```ruby
-pkg "Wireshark #{version} Intel 64.pkg",
+pkg "LandoInstaller.pkg",
     choices: [
-               {
-                 "choiceIdentifier" => "wireshark",
-                 "choiceAttribute"  => "selected",
-                 "attributeSetting" => 0,
-               },
-               {
-                 "choiceIdentifier" => "chmodbpf",
-                 "choiceAttribute"  => "selected",
-                 "attributeSetting" => 1,
-               },
-               {
-                 "choiceIdentifier" => "cli",
-                 "choiceAttribute"  => "selected",
-                 "attributeSetting" => 0,
-               },
-             ]
+      {
+        "choiceIdentifier" => "choiceDocker",
+        "choiceAttribute"  => "selected",
+        "attributeSetting" => 0,
+      },
+      {
+        "choiceIdentifier" => "choiceLando",
+        "choiceAttribute"  => "selected",
+        "attributeSetting" => 1,
+      },
+    ]
 ```
 
-Example ([wine-staging.rb](https://github.com/Homebrew/homebrew-cask/blob/51b65f6a5a25a7f79af4d372e1a0bf1dc3849251/Casks/wine-staging.rb#L11-L18)):
+Example (from [microsoft-office.rb](https://github.com/Homebrew/homebrew-cask/blob/56cabc6cec8be8f8a2fd06bc0b88f851d3b075d7/Casks/m/microsoft-office.rb#L30-L37)):
 
 ```ruby
-pkg "winehq-staging-#{version}.pkg",
+pkg "Microsoft_365_and_Office_#{version}_Installer.pkg",
     choices: [
-               {
-                 "choiceIdentifier" => "choice3",
-                 "choiceAttribute"  => "selected",
-                 "attributeSetting" => 1,
-               },
-             ]
+      {
+        "choiceIdentifier" => "com.microsoft.autoupdate", # Office16_all_autoupdate.pkg
+        "choiceAttribute"  => "selected",
+        "attributeSetting" => 0,
+      },
+    ]
 ```
 
 ### Stanza: `sha256`
 
-#### Calculating the SHA256
+#### Calculating the SHA-256
 
-The `sha256` value is usually calculated by the command:
+The `sha256` value is usually calculated by the `shasum` command:
 
 ```bash
 shasum --algorithm 256 <file>
 ```
 
-#### Special Value `:no_check`
+#### Special value `:no_check`
 
 The special value `sha256 :no_check` is used to turn off SHA checking whenever checksumming is impractical due to the upstream configuration.
 
@@ -868,10 +723,10 @@ We use a checksum whenever possible.
 
 Some distributions provide a suite of multiple applications, or an application with required data, to be installed together in a subdirectory of `/Applications`.
 
-For these Casks, use the `suite` stanza to define the directory containing the application suite. Example (from [sketchup.rb](https://github.com/Homebrew/homebrew-cask/blob/312ae841f1f1b2ec07f4d88b7dfdd7fbdf8d4f94/Casks/sketchup.rb#L12)):
+For these casks, use the `suite` stanza to define the directory containing the application suite. Example (from [racket.rb](https://github.com/Homebrew/homebrew-cask/blob/e65e45e94d27d14a78e1bd02b584b0c89c8f9e8b/Casks/r/racket.rb#L18)):
 
 ```ruby
-suite "SketchUp 2016"
+suite "Racket v#{version}"
 ```
 
 The value of `suite` is never an `.app` bundle, but a plain directory.
@@ -880,132 +735,132 @@ The value of `suite` is never an `.app` bundle, but a plain directory.
 
 > If you cannot design a working `uninstall` stanza, please submit your cask anyway. The maintainers can help you write an `uninstall` stanza, just ask!
 
-#### `uninstall pkgutil:` Is The Easiest and Most Useful
+#### `uninstall pkgutil:` is the easiest and most useful
 
-`pkgutil:` is the easiest and most useful `uninstall` directive. See [Uninstall Key pkgutil:](#uninstall-key-pkgutil).
+The easiest and most useful `uninstall` directive is [`pkgutil:`](#uninstall-pkgutil). It should cover most use cases.
 
-#### `uninstall` Is Required for Casks That Install a pkg or installer manual
+#### `uninstall` is required for casks that install using `pkg` or `installer manual:`
 
-For most Casks, uninstall actions are determined automatically, and an explicit `uninstall` stanza is not needed. However, a Cask which uses the `pkg` or `installer manual:` stanzas will **not** know how to uninstall correctly unless an `uninstall` stanza is given.
+For most casks, uninstall actions are determined automatically, and an explicit `uninstall` stanza is not needed. However, a cask which uses the `pkg` or `installer manual:` stanzas will **not** know how to uninstall correctly unless an `uninstall` stanza is given.
 
-So, while the [Cask DSL](#required-stanzas) does not enforce the requirement, it is much better for end-users if every `pkg` and `installer manual:` has a corresponding `uninstall`.
+So, while the [cask DSL](#required-stanzas) does not enforce the requirement, it is much better for users if every `pkg` and `installer manual:` has a corresponding `uninstall`.
 
-The `uninstall` stanza is available for non-`pkg` Casks, and is useful for a few corner cases. However, the documentation below concerns the typical case of using `uninstall` to define procedures for a `pkg`.
+The `uninstall` stanza is available for non-`pkg` casks, and is useful for a few corner cases. However, the documentation below concerns the typical case of using `uninstall` to define procedures for a `pkg`.
 
-#### There Are Multiple Uninstall Techniques
+#### There are multiple uninstall techniques
 
 Since `pkg` installers can do arbitrary things, different techniques are needed to uninstall in each case. You may need to specify one, or several, of the following key/value pairs as arguments to `uninstall`.
 
-#### Summary of Keys
+#### Summary of keys
 
-* `early_script:` (string or hash) - like [`script:`](#uninstall-key-script), but runs early (for special cases, best avoided)
-* [`launchctl:`](#uninstall-key-launchctl) (string or array) - ids of `launchctl` jobs to remove
-* [`quit:`](#uninstall-key-quit) (string or array) - bundle ids of running applications to quit
-* [`signal:`](#uninstall-key-signal) (array of arrays) - signal numbers and bundle ids of running applications to send a Unix signal to (used when `quit:` does not work)
-* [`login_item:`](#uninstall-key-login_item) (string or array) - names of login items to remove
-* [`kext:`](#uninstall-key-kext) (string or array) - bundle ids of kexts to unload from the system
-* [`script:`](#uninstall-key-script) (string or hash) - relative path to an uninstall script to be run via sudo; use hash if args are needed
+* **`early_script:`** (string or hash) - like [`script:`](#uninstall-script), but runs early (for special cases, best avoided)
+* [`launchctl:`](#uninstall-launchctl) (string or array) - IDs of `launchd` jobs to remove
+* [`quit:`](#uninstall-quit) (string or array) - bundle IDs of running applications to quit (does not run when uninstall is initiated by `brew upgrade` or `brew reinstall`)
+* [`signal:`](#uninstall-signal) (array of arrays) - signal numbers and bundle IDs of running applications to send a Unix signal to - for when `quit:` does not work (does not run when uninstall is initiated by `brew upgrade` or `brew reinstall`)
+* [`login_item:`](#uninstall-login_item) (string or array) - names of login items to remove
+* [`kext:`](#uninstall-kext) (string or array) - bundle IDs of kexts to unload from the system
+* [`script:`](#uninstall-script) (string or hash) - relative path to an uninstall script to be run via sudo; use hash if args are needed
   * `executable:` - relative path to an uninstall script to be run via sudo (required for hash form)
   * `args:` - array of arguments to the uninstall script
   * `input:` - array of lines of input to be sent to `stdin` of the script
   * `must_succeed:` - set to `false` if the script is allowed to fail
-  * `sudo:` - set to `true` if the script needs `sudo`
-* [`pkgutil:`](#uninstall-key-pkgutil) (string, regexp or array of strings and regexps) - strings or regexps matching bundle ids of packages to uninstall using `pkgutil`
-* [`delete:`](#uninstall-key-delete) (string or array) - single-quoted, absolute paths of files or directory trees to remove. `delete:` should only be used as a last resort. `pkgutil:` is strongly preferred.
-* `rmdir:` (string or array) - single-quoted, absolute paths of directories to remove if empty. Works recursively.
-* [`trash:`](#uninstall-key-trash) (string or array) - single-quoted, absolute paths of files or directory trees to move to Trash.
+  * `sudo:` - set to `true` if the script needs *sudo*
+* [`pkgutil:`](#uninstall-pkgutil) (string, regexp or array of strings and regexps) - strings or regexps matching bundle IDs of packages to uninstall using `pkgutil`
+* [`delete:`](#uninstall-delete) (string or array) - double-quoted, absolute paths of files or directory trees to remove. Should only be used as a last resort; `pkgutil:` is strongly preferred.
+* **`rmdir:`** (string or array) - double-quoted, absolute paths of directories to remove if empty. Works recursively.
+* [`trash:`](#uninstall-trash) (string or array) - double-quoted, absolute paths of files or directory trees to move to Trash
 
-Each `uninstall` technique is applied according to the order above. The order in which `uninstall` keys appear in the Cask file is ignored.
+Each `uninstall` technique is applied according to the order above. The order in which `uninstall` keys appear in the cask file is ignored.
 
 For assistance filling in the right values for `uninstall` keys, there are several helper scripts found under `developer/bin` in the Homebrew Cask repository. Each of these scripts responds to the `-help` option with additional documentation.
 
-The easiest way to work out an `uninstall` stanza is on a system where the `pkg` is currently installed and operational. To operate on an uninstalled `pkg` file, see [Working With a pkg File Manually](#working-with-a-pkg-file-manually), below.
+Working out an `uninstall` stanza is easiest when done on a system where the package is currently installed and operational. To operate on an uninstalled `.pkg` file, see [Working With a `.pkg` File Manually](#working-with-a-pkg-file-manually), below.
 
-#### `uninstall` Key `pkgutil:`
+#### `uninstall` *pkgutil*
 
 This is the most useful uninstall key. `pkgutil:` is often sufficient to completely uninstall a `pkg`, and is strongly preferred over `delete:`.
 
-IDs for the most recently-installed packages can be listed using the command:
+IDs for the most recently installed packages can be listed using [`list_recent_pkg_ids`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/developer/bin/list_recent_pkg_ids):
 
 ```bash
 "$(brew --repository homebrew/cask)/developer/bin/list_recent_pkg_ids"
 ```
 
-`pkgutil:` also accepts a regular expression match against multiple package IDs. The regular expressions are somewhat nonstandard. To test a `pkgutil:` regular expression against currently-installed packages, use the command:
+`pkgutil:` also accepts a regular expression match against multiple package IDs. The regular expressions are somewhat nonstandard. To test a `pkgutil:` regular expression against currently installed packages, use [`list_pkg_ids_by_regexp`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/developer/bin/list_pkg_ids_by_regexp):
 
 ```bash
 "$(brew --repository homebrew/cask)/developer/bin/list_pkg_ids_by_regexp" <regular-expression>
 ```
 
-#### List Files Associated With a pkg Id
+#### List files associated with a package ID
 
-Once you know the ID for an installed package, (above), you can list all files on your system associated with that package ID using the macOS command:
+Once you know the ID for an installed package (see above), you can list all files on your system associated with that package ID using the macOS `pkgutil` command:
 
 ```bash
 pkgutil --files <package.id.goes.here>
 ```
 
-Listing the associated files can help you assess whether the package included any `launchctl` jobs or kernel extensions (kexts).
+Listing the associated files can help you assess whether the package included any `launchd` jobs or kernel extensions (kexts).
 
-#### `uninstall` Key `launchctl:`
+#### `uninstall` *launchctl*
 
-IDs for currently loaded `launchctl` jobs can be listed using the command:
+IDs for currently loaded `launchd` jobs can be listed using [`list_loaded_launchjob_ids`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/developer/bin/list_loaded_launchjob_ids):
 
 ```bash
 "$(brew --repository homebrew/cask)/developer/bin/list_loaded_launchjob_ids"
 ```
 
-IDs for all installed `launchctl` jobs can be listed using the command:
+IDs for all installed `launchd` jobs can be listed using [`list_installed_launchjob_ids`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/developer/bin/list_installed_launchjob_ids):
 
 ```bash
 "$(brew --repository homebrew/cask)/developer/bin/list_installed_launchjob_ids"
 ```
 
-#### `uninstall` Key `quit:`
+#### `uninstall` *quit*
 
-Bundle IDs for currently running Applications can be listed using the command:
+Bundle IDs for currently running applications can be listed using [`list_running_app_ids`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/developer/bin/list_running_app_ids):
 
 ```bash
 "$(brew --repository homebrew/cask)/developer/bin/list_running_app_ids"
 ```
 
-Bundle IDs inside an Application bundle on disk can be listed using the command:
+Bundle IDs inside an application bundle on disk can be listed using [`list_ids_in_app`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/developer/bin/list_ids_in_app):
 
 ```bash
 "$(brew --repository homebrew/cask)/developer/bin/list_ids_in_app" '/path/to/application.app'
 ```
 
-#### `uninstall` Key `signal:`
+#### `uninstall` *signal*
 
 `signal:` should only be needed in the rare case that a process does not respond to `quit:`.
 
-Bundle IDs for `signal:` targets may be obtained as for `quit:`. The value for `signal:` is an array-of-arrays, with each cell containing two elements: the desired Unix signal followed by the corresponding bundle ID.
+Bundle IDs for `signal:` targets may be obtained in the same way as for `quit:`. The value for `signal:` is an array-of-arrays, with each cell containing two elements: the desired Unix signal followed by the corresponding bundle ID.
 
-The Unix signal may be given in numeric or string form (see the `kill` man page for more details).
+The Unix signal may be given in numeric or string form (see the `kill`(1) man page for more details).
 
 The elements of the `signal:` array are applied in order, only if there is an existing process associated the bundle ID, and stopping when that process terminates. A bundle ID may be repeated to send more than one signal to the same process.
 
-It is better to use the least-severe signals which are sufficient to stop a process. The `KILL` signal in particular can have unwanted side-effects.
+It is better to use the least-severe signals that are sufficient to stop a process. The `KILL` signal in particular can have unwanted side effects.
 
-An example, with commonly-used signals in ascending order of severity:
+An example, with commonly used signals in ascending order of severity:
 
 ```ruby
-  uninstall signal: [
-                      ["TERM", "fr.madrau.switchresx.daemon"],
-                      ["QUIT", "fr.madrau.switchresx.daemon"],
-                      ["INT",  "fr.madrau.switchresx.daemon"],
-                      ["HUP",  "fr.madrau.switchresx.daemon"],
-                      ["KILL", "fr.madrau.switchresx.daemon"],
-                    ]
+uninstall signal: [
+  ["TERM", "fr.madrau.switchresx.daemon"],
+  ["QUIT", "fr.madrau.switchresx.daemon"],
+  ["INT",  "fr.madrau.switchresx.daemon"],
+  ["HUP",  "fr.madrau.switchresx.daemon"],
+  ["KILL", "fr.madrau.switchresx.daemon"],
+]
 ```
 
-Note that when multiple running processes match the given Bundle ID, all matching processes will be signaled.
+Note that when multiple running processes match the given bundle ID, all matching processes will be signaled.
 
 Unlike `quit:` directives, Unix signals originate from the current user, not from the superuser. This is construed as a safety feature, since the superuser is capable of bringing down the system via signals. However, this inconsistency may also be considered a bug, and should be addressed in some fashion in a future version.
 
-## `uninstall` key `login_item:`
+#### `uninstall` *login_item*
 
-Login items associated with an Application bundle on disk can be listed using the command:
+Login items associated with an application bundle on disk can be listed using [`list_login_items_for_app`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/developer/bin/list_login_items_for_app):
 
 ```bash
 "$(brew --repository homebrew/cask)/developer/bin/list_login_items_for_app" '/path/to/application.app'
@@ -1013,34 +868,37 @@ Login items associated with an Application bundle on disk can be listed using th
 
 Note that you will likely need to have opened the app at least once for any login items to be present.
 
-#### `uninstall` Key `kext:`
+#### `uninstall` *kext*
 
-IDs for currently loaded kernel extensions can be listed using the command:
+IDs for currently loaded kernel extensions can be listed using [`list_loaded_kext_ids`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/developer/bin/list_loaded_kext_ids):
 
 ```bash
 "$(brew --repository homebrew/cask)/developer/bin/list_loaded_kext_ids"
 ```
 
-IDs inside a kext bundle you have located on disk can be listed using the command:
+IDs inside a kext bundle on disk can be listed using [`list_id_in_kext`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/developer/bin/list_id_in_kext):
 
 ```bash
 "$(brew --repository homebrew/cask)/developer/bin/list_id_in_kext" '/path/to/name.kext'
 ```
 
-#### `uninstall` Key `script:`
+#### `uninstall` *script*
 
-`uninstall script:` introduces a series of key-value pairs describing a command which will automate completion of the uninstall. Example (from [gpgtools.rb](https://github.com/Homebrew/homebrew-cask/blob/4a0a49d1210a8202cbdd54bce2986f15049b8b61/Casks/gpgtools.rb#L33-#L37)):
+`uninstall script:` introduces a series of key-value pairs describing a command which will automate completion of the uninstall. Example (from [virtualbox.rb](https://github.com/Homebrew/homebrew-cask/blob/ef9931087f6e101262bf64119166e2d9cec068f0/Casks/v/virtualbox.rb#L55-L61)):
 
 ```ruby
-  uninstall script:    {
-                         executable: "#{staged_path}/Uninstall.app/Contents/Resources/GPG Suite Uninstaller.app/Contents/Resources/uninstall.sh",
-                         sudo:       true,
-                       }
+uninstall script:  {
+            executable: "VirtualBox_Uninstall.tool",
+            args:       ["--unattended"],
+            sudo:       true,
+          },
+          pkgutil: "org.virtualbox.pkg.*",
+          delete:  "/usr/local/bin/vboximg-mount"
 ```
 
-It is important to note that, although `script:` in the above example does attempt to completely uninstall the `pkg`, it should not be used in detriment of [`pkgutil:`](#uninstall-key-pkgutil), but as a complement when possible.
+It is important to note that, although `script:` in the above example does attempt to completely uninstall the `pkg`, it should not be used in place of [`pkgutil:`](#uninstall-pkgutil), but as a complement when possible.
 
-#### `uninstall` Key `delete:`
+#### `uninstall` *delete*
 
 `delete:` should only be used as a last resort, if other `uninstall` methods are insufficient.
 
@@ -1052,77 +910,71 @@ Arguments to `uninstall delete:` should use the following basic rules:
 
 To remove user-specific files, use the [`zap` stanza](#stanza-zap).
 
-#### `uninstall` Key `trash:`
+#### `uninstall` *trash*
 
 `trash:` arguments follow the same rules listed above for `delete:`.
 
-#### Working With a pkg File Manually
+#### Working with a `.pkg` file manually
 
-Advanced users may wish to work with a `pkg` file manually, without having the package installed.
+Advanced users may wish to work with a `.pkg` file manually, without having the package installed.
 
-A list of files which may be installed from a `pkg` can be extracted using the command:
+A list of files which may be installed from a `.pkg` can be extracted using [`list_payload_in_pkg`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/developer/bin/list_payload_in_pkg):
 
 ```bash
 "$(brew --repository homebrew/cask)/developer/bin/list_payload_in_pkg" '/path/to/my.pkg'
 ```
 
-Candidate application names helpful for determining the name of a Cask may be extracted from a `pkg` file using the command:
+Candidate application names helpful for determining the name of a cask may be extracted from a `.pkg` file using [`list_apps_in_pkg`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/developer/bin/list_apps_in_pkg):
 
 ```bash
 "$(brew --repository homebrew/cask)/developer/bin/list_apps_in_pkg" '/path/to/my.pkg'
 ```
 
-Candidate package IDs which may be useful in a `pkgutil:` key may be extracted from a `pkg` file using the command:
+Candidate package IDs which may be useful in a `pkgutil:` key may be extracted from a `.pkg` file using [`list_ids_in_pkg`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/developer/bin/list_ids_in_pkg):
 
 ```bash
 "$(brew --repository homebrew/cask)/developer/bin/list_ids_in_pkg" '/path/to/my.pkg'
 ```
 
-A fully manual method for finding bundle ids in a package file follows:
+A fully manual method for finding bundle IDs in a package file follows:
 
 1. Unpack `/path/to/my.pkg` (replace with your package name) with `pkgutil --expand /path/to/my.pkg /tmp/expanded.unpkg`.
-2. The unpacked package is a folder. Bundle ids are contained within files named `PackageInfo`. These files can be found with the command `find /tmp/expanded.unpkg -name PackageInfo`.
-3. `PackageInfo` files are XML files, and bundle ids are found within the `identifier` attributes of `<pkg-info>` tags that look like `<pkg-info ... identifier="com.oracle.jdk7u51" ... >`, where extraneous attributes have been snipped out and replaced with ellipses.
+2. The unpacked package is a folder. Bundle IDs are contained within files named `PackageInfo`. These files can be found with the command `find /tmp/expanded.unpkg -name PackageInfo`.
+3. `PackageInfo` files are XML files, and bundle IDs are found within the `identifier` attributes of `<pkg-info>` tags that look like `<pkg-info ... identifier="com.oracle.jdk7u51" ... >`, where extraneous attributes have been snipped out and replaced with ellipses.
 4. Kexts inside packages are also described in `PackageInfo` files. If any kernel extensions are present, the command `find /tmp/expanded.unpkg -name PackageInfo -print0 | xargs -0 grep -i kext` should return a `<bundle id>` tag with a `path` attribute that contains a `.kext` extension, for example `<bundle id="com.wavtap.driver.WavTap" ... path="./WavTap.kext" ... />`.
-5. Once bundle ids have been identified, the unpacked package directory can be deleted.
+5. Once bundle IDs have been identified, the unpacked package directory can be deleted.
 
 ### Stanza: `url`
 
-#### HTTPS URLs are Preferred
+#### HTTPS URLs are preferred
 
 If available, an HTTPS URL is preferred. A plain HTTP URL should only be used in the absence of a secure alternative.
 
-#### Additional HTTP/S URL Parameters
+#### Additional `url` parameters
 
 When a plain URL string is insufficient to fetch a file, additional information may be provided to the `curl`-based downloader, in the form of key/value pairs appended to `url`:
 
 | key                | value       |
 | ------------------ | ----------- |
-| `verified:`        | a string repeating the beginning of `url`, for verification purposes. [See below](#when-url-and-homepage-domains-differ-add-verified).
-| `using:`           | the symbol `:post` is the only legal value
-| `cookies:`         | a hash of cookies to be set in the download request
-| `referer:`         | a string holding the URL to set as referer in the download request
-| `header:`          | a string holding the header to set for the download request.
-| `user_agent:`      | a string holding the user agent to set for the download request. Can also be set to the symbol `:fake`, which will use a generic Browser-like user agent string. We prefer `:fake` when the server does not require a specific user agent.
-| `data:`            | a hash of parameters to be set in the POST request
-
-Example of using `cookies:`: [java.rb](https://github.com/Homebrew/homebrew-cask/blob/472930df191d66747a57d5c96c0d00511d56e21b/Casks/java.rb#L5-L8)
-
-Example of using `referer:`: [rrootage.rb](https://github.com/Homebrew/homebrew-cask/blob/312ae841f1f1b2ec07f4d88b7dfdd7fbdf8d4f94/Casks/rrootage.rb#L5)
+| `verified:`        | string repeating the beginning of `url`, for [verification purposes](#when-url-and-homepage-domains-differ-add-verified) |
+| `using:`           | the symbols `:post` and `:homebrew_curl` are the only legal values |
+| `cookies:`         | hash of cookies to be set in the download request (Example: [oracle-jdk-javadoc.rb](https://github.com/Homebrew/homebrew-cask/blob/326c44e93aeb8d4dd73acea14a99ae215c75fdd6/Casks/o/oracle-jdk-javadoc.rb#L5-L8)) |
+| `referer:`         | string holding the URL to set as referer in the download request (Example: [firealpaca.rb](https://github.com/Homebrew/homebrew-cask/blob/c4b3f0742e044ae2a6e114eb6b90068763d0d12b/Casks/f/firealpaca.rb#L5-L6)) |
+| `header:`          | string or array of strings holding the header(s) to set for the download request (Example: [pull-6545](https://github.com/Homebrew/brew/pull/6545#issue-503302353), [issue-15590](https://github.com/Homebrew/brew/issues/15590#issue-1774825542)) |
+| `user_agent:`      | string holding the user agent to set for the download request. Can also be set to the symbol `:fake`, which will use a generic browser-like user agent string. We prefer `:fake` when the server does not require a specific user agent. |
+| `data:`            | hash of parameters to be set in the POST request (Example: [segger-jlink.rb](https://github.com/Homebrew/homebrew-cask/blob/38ac55614f146d68ae317594f0c119e9acbd7c9e/Casks/s/segger-jlink.rb#L6-L11)) |
 
-Example of using `header:`: [issue-325182724](https://github.com/Homebrew/brew/pull/6545#issue-325182724)
+#### When URL and homepage domains differ, add `verified:`
 
-#### When URL and Homepage Domains Differ, Add `verified:`
-
-When the domains of `url` and `homepage` differ, the discrepancy should be documented with the `verified:` parameter, repeating the smallest possible portion of the URL that uniquely identifies the app or vendor, excluding the protocol. Example: [`shotcut.rb`](https://github.com/Homebrew/homebrew-cask/blob/08733296b49c59c58b6beeada59ed4207cef60c3/Casks/shotcut.rb#L5L6).
+When the domains of `url` and `homepage` differ, the discrepancy should be documented with the `verified:` parameter, repeating the smallest possible portion of the URL that uniquely identifies the app or vendor, excluding the protocol. (Example: [1password-cli.rb](https://github.com/Homebrew/homebrew-cask/blob/ec2476459ead02e80391f44d42a2b48a18bf373d/Casks/1/1password-cli.rb#L8-L9))
 
 This must be added so a user auditing the cask knows the URL was verified by the Homebrew Cask team as the one provided by the vendor, even though it may look unofficial. It is our responsibility as Homebrew Cask maintainers to verify both the `url` and `homepage` information when first added (or subsequently modified, apart from versioning).
 
-The parameter doesn’t mean you should trust the source blindly, but we only approve casks in which users can easily verify its authenticity with basic means, such as checking the official homepage or public repository. Occasionally, slightly more elaborate techniques may be used, such as inspecting an [`appcast`](#stanza-appcast) we established as official. Cases where such quick verifications aren’t possible (e.g. when the download URL is behind a registration wall) are [treated in a stricter manner](https://docs.brew.sh/Acceptable-Casks#unofficial-vendorless-and-walled-builds).
+The parameter doesn’t mean you should trust the source blindly, but we only approve casks in which users can easily verify its authenticity with basic means, such as checking the official homepage or public repository. Occasionally, slightly more elaborate techniques may be used, such as inspecting a [`livecheck`](#stanza-livecheck) URL we established as official. Cases where such quick verifications aren’t possible (e.g. when the download URL is behind a registration wall) are [treated in a stricter manner](https://docs.brew.sh/Acceptable-Casks#unofficial-vendorless-and-walled-builds).
 
-#### Difficulty Finding a URL
+#### Difficulty finding a URL
 
-Web browsers may obscure the direct `url` download location for a variety of reasons. Homebrew Cask supplies a script which can read extended file attributes to extract the actual source URL for most files downloaded by a browser on macOS. The script usually emits multiple candidate URLs; you may have to test each of them:
+Web browsers may obscure the direct `url` download location for a variety of reasons. Homebrew Cask supplies a [`list_url_attributes_on_file`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/developer/bin/list_url_attributes_on_file) script which can read extended file attributes to extract the actual source URL of most files downloaded by a browser on macOS. The script usually emits multiple candidate URLs; you may have to test each of them:
 
 ```bash
 $(brew --repository homebrew/cask)/developer/bin/list_url_attributes_on_file <file>
@@ -1134,9 +986,21 @@ In rare cases, a distribution may not be available over ordinary HTTP/S. Subvers
 
 | key                | value       |
 | ------------------ | ----------- |
-| `using:`           | the symbol `:svn` is the only legal value
-| `revision:`        | a string identifying the subversion revision to download
-| `trust_cert:`      | set to `true` to automatically trust the certificate presented by the server (avoiding an interactive prompt)
+| `using:`           | the symbol `:svn` is the only legal value |
+| `revision:`        | string identifying the Subversion revision to download |
+| `trust_cert:`      | set to `true` to automatically trust the certificate presented by the server (avoiding an interactive prompt) |
+
+#### Git URLs
+
+Artifacts also may be distributed via Git repositories. URLs that end in `.git` are automatically assumed to be Git repositories, and the following key/value pairs may be appended to `url`:
+
+| key                | value       |
+| ------------------ | ----------- |
+| `using:`           | the symbol `:git` is the only legal value |
+| `tag:`             | string identifying the Git tag to download |
+| `revision:`        | string identifying the Git revision to download |
+| `branch:`          | string identifying the Git branch to download |
+| `only_path:`       | path within the repository to limit the checkout to. If only a single directory of a large repository is required, using this option can significantly speed up downloads. If provided, artifact paths are relative to this path. (Example: [font-geo.rb](https://github.com/Homebrew/homebrew-cask-fonts/blob/bac691e1d7b5bd7372e7e0befae989a3ff7ad449/Casks/font-geo.rb#L5-L8)) |
 
 #### SourceForge/OSDN URLs
 
@@ -1144,45 +1008,37 @@ SourceForge and OSDN (formerly `SourceForge.JP`) projects are common ways to dis
 
 We prefer URLs of this format:
 
-```
-https://downloads.sourceforge.net/<project_name>/<filename>.<ext>
-```
-
-Or, if it’s from [OSDN](https://osdn.jp/):
+    https://downloads.sourceforge.net/<project_name>/<filename>.<ext>
 
-```
-http://<subdomain>.osdn.jp/<project_name>/<release_id>/<filename>.<ext>
-```
+Or, if it’s from OSDN, where `<subdomain>` is typically of the form `dl` or `<user>.dl`:
 
-`<subdomain>` is typically of the form `dl` or `<user>.dl`.
+    http://<subdomain>.osdn.jp/<project_name>/<release_id>/<filename>.<ext>
 
 If these formats are not available, and the application is macOS-exclusive (otherwise a command-line download defaults to the Windows version) we prefer the use of this format:
 
-```
-https://sourceforge.net/projects/<project_name>/files/latest/download
-```
+    https://sourceforge.net/projects/<project_name>/files/latest/download
 
-#### Some Providers Block Command-line Downloads
+#### Some providers block command-line downloads
 
-Some hosting providers actively block command-line HTTP clients. Such URLs cannot be used in Casks.
+Some hosting providers actively block command-line HTTP clients. Such URLs cannot be used in casks.
 
 Other providers may use URLs that change periodically, or even on each visit (example: FossHub). While some cases [could be circumvented](#using-a-block-to-defer-code-execution), they tend to occur when the vendor is actively trying to prevent automated downloads, so we prefer to not add those casks to the main repository.
 
-#### Using a Block to Defer Code Execution
+#### Using a block to defer code execution
 
 Some casks—notably nightlies—have versioned download URLs but are updated so often that they become impractical to keep current with the usual process. For those, we want to dynamically determine `url`.
 
 ##### The Problem
 
-In theory, one can write arbitrary Ruby code right in the Cask definition to fetch and construct a disposable URL.
+In theory, one can write arbitrary Ruby code right in the cask definition to fetch and construct a disposable URL.
 
-However, this typically involves an HTTP round trip to a landing site, which may take a long time. Because of the way Homebrew Cask loads and parses Casks, it is not acceptable that such expensive operations be performed directly in the body of a Cask definition.
+However, this typically involves an HTTP round trip to a landing site, which may take a long time. Because of the way Homebrew Cask loads and parses casks, it is not acceptable that such expensive operations be performed directly in the body of a cask definition.
 
-##### Writing the Block
+##### Writing the block
 
 Similar to the `preflight`, `postflight`, `uninstall_preflight`, and `uninstall_postflight` blocks, the `url` stanza offers an optional *block syntax*:
 
-```rb
+```ruby
 url "https://handbrake.fr/nightly.php" do |page|
   file_path = page[/href=["']?([^"' >]*Handbrake[._-][^"' >]+\.dmg)["' >]/i, 1]
   file_path ? URI.join(page.url, file_path) : nil
@@ -1191,15 +1047,15 @@ end
 
 You can also nest `url do` blocks inside `url do` blocks to follow a chain of URLs.
 
-The block is only evaluated when needed, for example on download time or when auditing a Cask. Inside a block, you may safely do things such as HTTP/S requests that may take a long time to execute. You may also refer to the `@cask` instance variable, and invoke any method available on `@cask`.
+The block is only evaluated when needed, for example at download time or when auditing a cask. Inside a block, you may safely do things such as HTTP/S requests that may take a long time to execute. You may also refer to the `@cask` instance variable, and invoke [any method available on `@cask`](https://rubydoc.brew.sh/Cask/Cask).
 
 The block will be called immediately before downloading; its result value will be assumed to be a `String` (or a pair of a `String` and `Hash` containing parameters) and subsequently used as a download URL.
 
 You can use the `url` stanza with either a direct argument or a block but not with both.
 
-Example for using the block syntax: [vlc-nightly.rb](https://github.com/Homebrew/homebrew-cask-versions/blob/2bf0f13dd49d263ebec0ca56e58ad8458633f789/Casks/vlc-nightly.rb#L5L10)
+Example of using the block syntax: [vlc@nightly.rb](https://github.com/Homebrew/homebrew-cask/blob/0b2b76ad8c3fbf4e1ee2f5e758640c4963ad6aaf/Casks/v/vlc%40nightly.rb#L7-L12)
 
-##### Mixing Additional URL Parameters With the Block Syntax
+##### Mixing additional URL parameters with the block syntax
 
 In rare cases, you might need to set URL parameters like `cookies` or `referer` while also using the block syntax.
 
@@ -1207,73 +1063,72 @@ This is possible by returning a two-element array as a block result. The first e
 
 ### Stanza: `version`
 
-`version`, while related to the app’s own versioning, doesn’t have to follow it exactly. It is common to change it slightly so it can be [interpolated](https://en.wikipedia.org/wiki/String_interpolation#Ruby_/_Crystal) in other stanzas, usually in `url` to create a Cask that only needs `version` and `sha256` changes when updated. This can be taken further, when needed, with [ruby String methods](https://ruby-doc.org/core/String.html).
-
-For example:
+`version`, while related to the app’s own versioning, doesn’t have to follow it exactly. It is common to change it slightly so it can be [interpolated](https://en.wikipedia.org/wiki/String_interpolation#Ruby_/_Crystal) in other stanzas, usually in `url` to create a cask that only needs `version` and `sha256` changes when updated. This can be taken further, when needed, with [Ruby String methods](https://ruby-doc.org/core/String.html).
 
-Instead of
+For example, instead of:
 
 ```ruby
 version "1.2.3"
 url "https://example.com/file-version-123.dmg"
 ```
 
-We can use
+we can use:
 
 ```ruby
 version "1.2.3"
-url "https://example.com/file-version-#{version.delete('.')}.dmg"
+url "https://example.com/file-version-#{version.delete(".")}.dmg"
 ```
 
-We can also leverage the power of regular expressions. So instead of
+We can also leverage the power of regular expressions. So instead of:
 
 ```ruby
 version "1.2.3build4"
 url "https://example.com/1.2.3/file-version-1.2.3build4.dmg"
 ```
 
-We can use
+we can use:
 
 ```ruby
 version "1.2.3build4"
-url "https://example.com/#{version.sub(%r{build\d+}, '')}/file-version-#{version}.dmg"
+url "https://example.com/#{version.sub(/build\d+/, "")}/file-version-#{version}.dmg"
 ```
 
-#### version :latest
+#### `version` methods
 
-The special value `:latest` is used on casks which:
-
-1. `url` doesn’t contain a version.
-2. Having a correct value to `version` is too difficult or impractical, even with our automated systems.
+The examples above can become hard to read, however. Since many of these changes are common, we provide a number of helpers to clearly interpret otherwise obtuse cases:
 
-Example: [spotify.rb](https://github.com/Homebrew/homebrew-cask/blob/f56e8ba057687690e26a6502623aa9476ff4ac0e/Casks/spotify.rb#L2)
+| method                   | input              | output             |
+| ------------------------ | ------------------ | ------------------ |
+| `major`                  | `1.2.3-a45,ccdd88` | `1` |
+| `minor`                  | `1.2.3-a45,ccdd88` | `2` |
+| `patch`                  | `1.2.3-a45,ccdd88` | `3-a45` |
+| `major_minor`            | `1.2.3-a45,ccdd88` | `1.2` |
+| `major_minor_patch`      | `1.2.3-a45,ccdd88` | `1.2.3-a45` |
+| `minor_patch`            | `1.2.3-a45,ccdd88` | `2.3-a45` |
+| `before_comma`           | `1.2.3-a45,ccdd88` | `1.2.3-a45` |
+| `after_comma`            | `1.2.3-a45,ccdd88` | `ccdd88` |
+| `dots_to_hyphens`        | `1.2.3-a45,ccdd88` | `1-2-3-a45,ccdd88` |
+| `no_dots`                | `1.2.3-a45,ccdd88` | `123-a45,ccdd88` |
 
-#### version methods
+Similar to `dots_to_hyphens`, we provide methods for all logical permutations of `{dots,hyphens,underscores}_to_{dots,hyphens,underscores}`. The same applies to `no_dots` in the form of `no_{dots,hyphens,underscores}`, with an extra `no_dividers` that applies all these at once.
 
-The examples above can become hard to read, however. Since many of these changes are common, we provide a number of helpers to clearly interpret otherwise obtuse cases:
+Finally, there is `csv` which returns an array of comma-separated values. `csv`, `before_comma` and `after_comma` are extra-special to allow for otherwise complex cases, and should be used sparingly. There should be no more than two of `,` per `version`.
 
-| Method                   | Input              | Output             |
-|--------------------------|--------------------|--------------------|
-| `major`                  | `1.2.3-a45,ccdd88` | `1`                |
-| `minor`                  | `1.2.3-a45,ccdd88` | `2`                |
-| `patch`                  | `1.2.3-a45,ccdd88` | `3-a45`            |
-| `major_minor`            | `1.2.3-a45,ccdd88` | `1.2`              |
-| `major_minor_patch`      | `1.2.3-a45,ccdd88` | `1.2.3-a45`        |
-| `minor_patch`            | `1.2.3-a45,ccdd88` | `2.3-a45`          |
-| `before_comma`           | `1.2.3-a45,ccdd88` | `1.2.3-a45`        |
-| `after_comma`            | `1.2.3-a45,ccdd88` | `ccdd88`           |
-| `dots_to_hyphens`        | `1.2.3-a45,ccdd88` | `1-2-3-a45,ccdd88` |
-| `no_dots`                | `1.2.3-a45,ccdd88` | `123-a45,ccdd88`   |
+#### `version :latest`
 
-Similar to `dots_to_hyphens`, we provide all logical permutations of `{dots,hyphens,underscores}_to_{dots,hyphens,underscores}`. The same applies to `no_dots` in the form of `no_{dots,hyphens,underscores}`, with an extra `no_dividers` that applies all of those at once.
+The special value `:latest` is used when:
 
-Finally, there is `csv` that returns an array of comma-separated values. `csv`, `before_comma` and `after_comma` are extra special to allow for otherwise complex cases, and should be used sparingly. There should be no more than two of `,` per `version`.
+* `url` does not contain any version information and there is no way to retrieve
+  the version using a `livecheck`, or
+* having a correct value for `version` is too difficult or impractical, even with our automated systems. For example,
+  [chromium.rb](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/c/chromium.rb#L4)
+  releases multiple versions a day.
 
 ### Stanza: `zap`
 
-#### `zap` Stanza Purpose
+#### `zap` purpose
 
-The `zap` stanza describes a more complete uninstallation of files associated with a Cask. The `zap` procedures will never be performed by default, but only if the user uses `--zap` on `uninstall`:
+The `zap` stanza describes a more complete uninstallation of files associated with a cask. The `zap` procedures will never be performed by default, but only if the user uses `--zap` on `uninstall`:
 
 ```bash
 brew uninstall --zap firefox
@@ -1288,30 +1143,137 @@ brew uninstall --zap firefox
 
 * Files created by the user directly.
 
-Appending `--force` to the command will allow you to perform these actions even if the Cask is no longer installed:
+Appending `--force` to the command will allow you to perform these actions even if the cask is no longer installed:
 
 ```bash
 brew uninstall --zap --force firefox
 ```
 
-#### `zap` Stanza Syntax
+#### `zap` syntax
 
-The form of `zap` stanza follows the [`uninstall` stanza](#stanza-uninstall). All of the same directives are available. The `trash:` key is preferred over `delete:`.
+The form of the `zap` stanza follows the [`uninstall` stanza](#stanza-uninstall). All the same directives are available. The `trash:` key is preferred over `delete:`.
 
-Example: [dropbox.rb](https://github.com/Homebrew/homebrew-cask/blob/31cd96cc0e00dab1bff74d622e32d816bafd1f6f/Casks/dropbox.rb#L17-L35)
+Example: [dropbox.rb](https://github.com/Homebrew/homebrew-cask/blob/974a55ade77bb4edc8bbb80ef72eec83ae0e76c0/Casks/d/dropbox.rb#L30-L68)
 
-#### `zap` Creation
+#### `zap` creation
 
 The simplest method is to use [@nrlquaker's CreateZap](https://github.com/nrlquaker/homebrew-createzap), which can automatically generate the stanza. In a few instances it may fail to pick up anything and manual creation may be required.
 
 Manual creation can be facilitated with:
 
-* Some of the developer tools are already available in Homebrew Cask.
+* Some of the developer tools which are already available in Homebrew Cask.
 * `sudo find / -iname "*<search item>*"`
-* An uninstaller tool such as [AppCleaner](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/appcleaner.rb).
-* Inspecting the usual suspects, i.e. `/Library/{'Application Support',LaunchAgents,LaunchDaemons,Frameworks,Logs,Preferences,PrivilegedHelperTools}` and `~/Library/{'Application Support',Caches,Containers,LaunchAgents,Logs,Preferences,'Saved Application State'}`.
+* An uninstaller tool such as [AppCleaner](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/a/appcleaner.rb).
+* Inspection of the usual paths, i.e. `/Library/{'Application Support',LaunchAgents,LaunchDaemons,Frameworks,Logs,Preferences,PrivilegedHelperTools}` and `~/Library/{'Application Support',Caches,Containers,LaunchAgents,Logs,Preferences,'Saved Application State'}`.
+
+If no additional files are discovered, instead of a zap stanza, include the following comment:
+
+```ruby
+# No zap stanza required
+```
+
+## Conditional statements
+
+### Handling different system configurations
+
+Casks can deliver specific versions of artifacts depending on the current macOS release or CPU architecture by either tailoring the URL / SHA-256 hash / version, using the [`on_<system>` syntax](Formula-Cookbook.md#handling-different-system-configurations) (which replaces conditional statements using `MacOS.version` or `Hardware::CPU`), or both.
+
+If your cask's artifact is offered as separate downloads for Intel and Apple Silicon architectures, they'll presumably be downloadable at distinct URLs that differ only slightly. To adjust the URL depending on the current CPU architecture, supply a hash for each to the `arm:` and `intel:` parameters of `sha256`, and use the special `arch` stanza to define the unique components of the respective URLs for substitution in the `url`. Additional substitutions can be defined by calling `on_arch_conditional` directly. Example (from [libreoffice.rb](https://github.com/Homebrew/homebrew-cask/blob/a4164b8f5084fdaefb6e2e2f4f699270690b7845/Casks/l/libreoffice.rb#L1-L10)):
+
+```ruby
+cask "libreoffice" do
+  arch arm: "aarch64", intel: "x86-64"
+  folder = on_arch_conditional arm: "aarch64", intel: "x86_64"
+
+  version "7.6.0"
+  sha256 arm:   "81eab945a33622fc156951e804024d23aa9a745c06743b4947215ed9303ad1c4",
+         intel: "ede541af151487f60eb518e310d20dad1a973f3dbe9ff78d782dd29b14ba2946"
+
+  url "https://download.documentfoundation.org/libreoffice/stable/#{version}/mac/#{folder}/LibreOffice_#{version}_MacOS_#{arch}.dmg",
+      verified: "download.documentfoundation.org/libreoffice/stable/"
+end
+```
+
+If the version number is different for each architecture, locate the unique `version` and (if checked) `sha256` stanzas within `on_arm` and `on_intel` blocks. Example (from [inkscape.rb](https://github.com/Homebrew/homebrew-cask/blob/11f6966bf17628b98895d64a61a4fb0bc1bb31bf/Casks/i/inkscape.rb#L1-L13)):
+
+```ruby
+cask "inkscape" do
+  arch arm: "arm64", intel: "x86_64"
+
+  on_arm do
+    version "1.3.0,42339"
+    sha256 "e37b5f8b8995a0ecc41ca7fcae90d79bcd652b7a25d2f6e52c4e2e79aef7fec1"
+  end
+  on_intel do
+    version "1.3.0,42338"
+    sha256 "e97de6804d8811dd2f1bc45d709d87fb6fe45963aae710c24a4ed655ecd8eb8a"
+  end
+
+  url "https://inkscape.org/gallery/item/#{version.csv.second}/Inkscape-#{version.csv.first}_#{arch}.dmg"
+end
+```
 
----
+To adjust the installed version depending on the current macOS release, use a series of `on_<system>` blocks that cover the range of supported releases. Each block can contain stanzas that set which version to download and customize installation/uninstallation and livecheck behaviour for one or more releases. Example (from [calibre.rb](https://github.com/Homebrew/homebrew-cask/blob/482c34e950da8d649705f4aaea7b760dcb4b5402/Casks/c/calibre.rb#L1-L34)):
+
+```ruby
+cask "calibre" do
+  on_high_sierra :or_older do
+    version "3.48.0"
+    sha256 "68829cd902b8e0b2b7d5cf7be132df37bcc274a1e5720b4605d2dd95f3a29168"
+
+    livecheck do
+      skip "Legacy version"
+    end
+  end
+  on_mojave do
+    # ...
+  end
+  on_catalina do
+    # ...
+  end
+  on_big_sur :or_newer do
+    version "6.25.0"
+    sha256 "a7ed19ae0526630ccb138b9afee6dc5169904180b02f7a3089e78d3e0022753b"
+
+    livecheck do
+      url "https://github.com/kovidgoyal/calibre"
+      strategy :github_latest
+    end
+  end
+end
+```
+
+Such `on_<system>` blocks can be nested and contain other stanzas not listed here. Examples: [calhash.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/c/calhash.rb), [openzfs.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/o/openzfs.rb), [r.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/r/r.rb), [wireshark.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/w/wireshark.rb)
+
+### Switch between languages or regions
+
+If a cask is available in multiple languages, you can use the [`language` stanza](#stanza-language) to switch between languages or regions based on the system locale.
+
+## Arbitrary Ruby methods
+
+In the exceptional case that the cask DSL is insufficient, it is possible to define arbitrary Ruby variables and methods inside the cask by creating a `Utils` namespace. Example:
+
+```ruby
+cask "myapp" do
+  module Utils
+    def self.arbitrary_method
+      # ...
+    end
+  end
+
+  version "1.0"
+  sha256 "a32565cdb1673f4071593d4cc9e1c26bc884218b62fef8abc450daa47ba8fa92"
+
+  url "https://#{Utils.arbitrary_method}"
+  name "MyApp"
+  homepage "https://www.example.com/"
+  # ...
+end
+```
+
+This should be used sparingly: any method which is needed by two or more casks should instead be rolled into Homebrew/brew. Care must also be taken that such methods be very efficient.
+
+Variables and methods should not be defined outside the `Utils` namespace, as they may collide with Homebrew Cask internals.
 
 ## Token reference
 
@@ -1323,10 +1285,9 @@ This section describes the algorithm implemented in the `generate_cask_token` sc
 * [Cask Filenames](#cask-filenames)
 * [Cask Headers](#cask-headers)
 * [Cask Token Examples](#cask-token-examples)
-* [Tap Specific Cask Token Examples](#tap-specific-cask-token-examples)
-* [Token Overlap](#token-overlap)
+* [Special Affixes](#special-affixes)
 
-## Purpose
+### Purpose
 
 Software vendors are often inconsistent with their naming. By enforcing strict naming conventions we aim to:
 
@@ -1334,21 +1295,21 @@ Software vendors are often inconsistent with their naming. By enforcing strict n
 * Minimize renaming events
 * Unambiguously boil down the name of the software into a unique identifier
 
-Details of software names and brands will inevitably be lost in the conversion to a minimal token. To capture the vendor’s full name for a distribution, use the [`name`](#stanza-name) within a Cask. `name` accepts an unrestricted UTF-8 string.
+Details of software names and brands will inevitably be lost in the conversion to a minimal token. To capture the vendor’s full name for a distribution, use the [`name`](#stanza-name) within a cask. `name` accepts an unrestricted UTF-8 string.
 
-## Finding the Simplified Name of the Vendor’s Distribution
+### Finding the simplified name of the vendor’s distribution
 
-### Simplified Names of Apps
+#### Simplified names of apps
 
-* Start with the exact name of the Application bundle as it appears on disk, such as `Google Chrome.app`.
+* Start with the exact name of the application bundle as it appears on disk, such as `Google Chrome.app`.
 
-* If the name uses letters outside A-Z, convert it to ASCII as described in [Converting to ASCII](#converting-to-ascii).
+* If the name uses letters outside A–Z, convert it to ASCII as described in [Converting to ASCII](#converting-to-ascii).
 
 * Remove `.app` from the end.
 
-* Remove from the end: the string “app”, if the vendor styles the name like “Software App.app”. Exception: when “app” is an inseparable part of the name, without which the name would be inherently nonsensical, as in [whatsapp.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/whatsapp.rb).
+* Remove from the end: the string “app”, if the vendor styles the name like “Software App.app”. Exception: when “app” is an inseparable part of the name, without which the name would be inherently nonsensical, as in [whatsapp.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/w/whatsapp.rb).
 
-* Remove from the end: version numbers or incremental release designations such as “alpha”, “beta”, or “release candidate”. Strings which distinguish different capabilities or codebases such as “Community Edition” are currently accepted. Exception: when a number is not an incremental release counter, but a differentiator for a different product from a different vendor, as in [kdiff3.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/kdiff3.rb).
+* Remove from the end: version numbers or incremental release designations such as “alpha”, “beta”, or “release candidate”. Strings which distinguish different capabilities or codebases such as “Community Edition” are currently accepted. Exception: when a number is not an incremental release counter, but a differentiator for a different product from a different vendor, as in [kdiff3.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/k/kdiff3.rb).
 
 * If the version number is arranged to occur in the middle of the App name, it should also be removed.
 
@@ -1356,21 +1317,21 @@ Details of software names and brands will inevitably be lost in the conversion t
 
 * Remove from the end: strings such as “Desktop”, “for Desktop”.
 
-* Remove from the end: strings such as “Mac”, “for Mac”, “for OS X”, “macOS”, “for macOS”. These terms are generally added to ported software such as “MAME OS X.app”. Exception: when the software is not a port, and “Mac” is an inseparable part of the name, without which the name would be inherently nonsensical, as in [PlayOnMac.app](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/playonmac.rb).
+* Remove from the end: strings such as “Mac”, “for Mac”, “for OS X”, “macOS”, “for macOS”. These terms are generally added to ported software such as “MAME OS X.app”. Exception: when the software is not a port, and “Mac” is an inseparable part of the name, without which the name would be inherently nonsensical, as in [PlayOnMac.app](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/p/playonmac.rb).
 
-* Remove from the end: hardware designations such as “for x86”, “32-bit”, “ppc”.
+* Remove from the end: hardware designations such as “for x86”, “32-bit”, “ARM”.
 
-* Remove from the end: software framework names such as “Cocoa”, “Qt”, “Gtk”, “Wx”, “Java”, “Oracle JVM”, etc. Exception: the framework is the product being Casked.
+* Remove from the end: software framework names such as “Cocoa”, “Qt”, “Gtk”, “Wx”, “Java”, “Oracle JVM”, etc. Exception: the framework is the product being casked.
 
 * Remove from the end: localization strings such as “en-US”.
 
 * If the result of that process is a generic term, such as “Macintosh Installer”, try prepending the name of the vendor or developer, followed by a hyphen. If that doesn’t work, then just create the best name you can, based on the vendor’s web page.
 
-* If the result conflicts with the name of an existing Cask, make yours unique by prepending the name of the vendor or developer, followed by a hyphen. Example: [unison.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/unison.rb) and [panic-unison.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/panic-unison.rb).
+* If the result conflicts with the name of an existing cask, make yours unique by prepending the name of the vendor or developer, followed by a hyphen. Example: [unison.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/u/unison.rb) and [panic-unison.rb](https://github.com/Homebrew/homebrew-cask/blob/HEAD/Casks/p/panic-unison.rb).
 
 * Inevitably, there are a small number of exceptions not covered by the rules. Don’t hesitate to [use the forum](https://github.com/orgs/Homebrew/discussions) if you have a problem.
 
-### Converting to ASCII
+#### Converting to ASCII
 
 * If the vendor provides an English localization string, that is preferred. Here are the places it may be found, in order of preference:
 
@@ -1385,19 +1346,19 @@ Details of software names and brands will inevitably be lost in the conversion t
 
 * As a last resort, translate the name of the app bundle into English.
 
-### Simplified Names of `pkg`-based Installers
+#### Simplified names of `pkg`-based installers
 
 * The Simplified Name of a `pkg` may be more tricky to determine than that of an App. If a `pkg` installs an App, then use that App name with the rules above. If not, just create the best name you can, based on the vendor’s web page.
 
-### Simplified Names of non-App Software
+#### Simplified names of non-App software
 
-* Currently, rules for generating a token are not well-defined for Preference Panes, QuickLook plugins, and several other types of software installable by Homebrew Cask. Just create the best name you can, based on the filename on disk or the vendor’s web page. Watch out for duplicates.
+* Currently, rules for generating a token are not well-defined for Preference Panes, Quick Look plugins, and several other types of software installable by Homebrew Cask. Just create the best name you can, based on the filename on disk or the vendor’s web page. Watch out for duplicates.
 
   Non-app tokens should become more standardized in the future.
 
-## Converting the Simplified Name To a Token
+### Converting the simplified name to a token
 
-The token is the primary identifier for a package in our project. It’s the unique string users refer to when operating on the Cask.
+The token is the primary identifier for a package in this project. It’s the unique string users refer to when operating on the cask.
 
 To convert the App’s Simplified Name (above) to a token:
 
@@ -1413,45 +1374,51 @@ To convert the App’s Simplified Name (above) to a token:
 * Collapse a series of multiple hyphens into one hyphen.
 * Delete a leading or trailing hyphen.
 
-## Cask Filenames
+### Casks pinned to specific versions
 
-Casks are stored in a Ruby file named after the token, with the file extension `.rb`.
+Casks pinned to a specific version of the application (i.e. [`carbon-copy-cloner@5`](https://github.com/Homebrew/homebrew-cask/blob/1b8f44198e5e184c597ee07454a1e10f97f36b15/Casks/c/carbon-copy-cloner%405.rb)) should use the same token as the standard cask with a suffix of `@<version-number`. For Carbon Copy Cloner (`carbon-copy-cloner`), pinned to version 5, the token should be `carbon-copy-cloner@5`.
 
-## Cask Headers
+### Casks pinned to development channels
 
-The token is also given in the header line for each Cask.
+Casks that use an development "channel", such as betas, should use the same token as the standard cask with a suffix of `@<channel>`. For Google Chrome (`google-chrome`), using the "beta" channel, the token should be `google-chrome@beta`.
 
-## Cask Token Examples
+### Cask filenames
 
-These illustrate most of the rules for generating a token:
+Casks are stored in a Ruby file named after the token, with the file extension `.rb`.
+
+### Cask headers
 
-App Name on Disk       | Simplified App Name | Cask Token       | Filename
------------------------|---------------------|------------------|----------------------
-`Audio Hijack Pro.app` | Audio Hijack Pro    | audio-hijack-pro | `audio-hijack-pro.rb`
-`VLC.app`              | VLC                 | vlc              | `vlc.rb`
-`BetterTouchTool.app`  | BetterTouchTool     | bettertouchtool  | `bettertouchtool.rb`
-`LPK25 Editor.app`     | LPK25 Editor        | lpk25-editor     | `lpk25-editor.rb`
-`Sublime Text 2.app`   | Sublime Text        | sublime-text     | `sublime-text.rb`
+The token is also given in the header line for each cask.
 
-## Tap Specific Cask Token Examples
+### Cask token examples
 
-Cask taps have naming conventions specific to each tap.
+These illustrate most of the rules for generating a token:
 
-[Homebrew/cask-versions](https://github.com/Homebrew/homebrew-cask-versions/blob/HEAD/CONTRIBUTING.md#naming-versions-casks)
+| App Name on Disk       | Simplified App Name | Cask Token       | Filename |
+|------------------------|---------------------|------------------|----------------------|
+| `Audio Hijack Pro.app` | Audio Hijack Pro    | audio-hijack-pro | `audio-hijack-pro.rb` |
+| `VLC.app`              | VLC                 | vlc              | `vlc.rb` |
+| `BetterTouchTool.app`  | BetterTouchTool     | bettertouchtool  | `bettertouchtool.rb` |
+| `LPK25 Editor.app`     | LPK25 Editor        | lpk25-editor     | `lpk25-editor.rb` |
+| `Sublime Text 2.app`   | Sublime Text        | sublime-text     | `sublime-text.rb` |
 
-[Homebrew/cask-fonts](https://github.com/Homebrew/homebrew-cask-fonts/blob/HEAD/CONTRIBUTING.md#naming-font-casks)
+For versioned/development channel casks:
 
-[Homebrew/cask-drivers](https://github.com/Homebrew/homebrew-cask-drivers/blob/HEAD/CONTRIBUTING.md#naming-driver-casks)
+| Standard Cask Token     | Derivative          | Cask Token           | Filename  |
+|------------------------|---------------------|-----------------------|----------------------|
+| `google-chrome`        | Beta Channel        | `google-chrome@beta`  | `google-chrome@beta.rb` |
+| `vlc`                  | Nightly Channel     | `vlc@nightly`         | `vlc@nightly.rb` |
+| `carbon-copy-cloner`   | Pinned to version 5 | `carbon-copy-cloner@5`| `carbon-copy-cloner@5.rb` |
 
-# Special Affixes
+### Special affixes
 
 A few situations require a prefix or suffix to be added to the token.
 
-## Token Overlap
+#### Token overlap
 
-When the token for a new Cask would otherwise conflict with the token of an already existing Cask, the nature of that overlap dictates the token (for possibly both Casks). See [Forks and Apps with Conflicting Names](Acceptable-Casks.md#forks-and-apps-with-conflicting-names) for information on how to proceed.
+When the token for a new cask would otherwise conflict with the token of an already existing cask, the nature of that overlap dictates the token, potentially for both casks. See [Forks and Apps with Conflicting Names](Acceptable-Casks.md#forks-and-apps-with-conflicting-names) for information on how to proceed.
 
-## Potentially Misleading Name
+#### Potentially misleading name
 
 If the token for a piece of unofficial software that interacts with a popular service would make it look official and the vendor is not authorised to use the name, [a prefix must be added](Acceptable-Casks.md#forks-and-apps-with-conflicting-names) for disambiguation.
 
diff --git a/docs/Checksum_Deprecation.md b/docs/Checksum_Deprecation.md
index 633a6d6498aed..b758dd51ed8f2 100644
--- a/docs/Checksum_Deprecation.md
+++ b/docs/Checksum_Deprecation.md
@@ -2,7 +2,7 @@
 
 In early 2015 Homebrew started the process of deprecating _SHA1_ for package
 integrity verification. Since then formulae under the Homebrew organisation
-have been migrated to use _SHA256_ for verification; this includes both source
+have been migrated to use _SHA-256_ for verification; this includes both source
 packages and our precompiled packages (bottles).
 
 Homebrew has since stopped supporting _SHA1_ and _MD5_ entirely.
@@ -15,4 +15,4 @@ This is enforced in the same way _MD5_ is, by blocking the installation of that
 individual formula until the checksum is migrated.
 
 This means custom taps, local custom formulae, etc. need to be migrated to use
-_SHA256_ before you can install them.
+_SHA-256_ before you can install them.
diff --git a/docs/Common-Issues-for-Core-Contributors.md b/docs/Common-Issues-for-Core-Contributors.md
index c7d8dba25c925..f6ceb5143fd2b 100644
--- a/docs/Common-Issues-for-Core-Contributors.md
+++ b/docs/Common-Issues-for-Core-Contributors.md
@@ -1,4 +1,4 @@
-# Common Issues for Core Contributors
+# Common Issues for Maintainers
 
 ## Overview
 
@@ -9,17 +9,18 @@ This is a page for maintainers to diagnose certain build errors.
 ### Bottle publishes failed but the commits are correct in the git history
 
 Follow these steps to fix this issue:
+
 * Download and extract the bottle artifact.
 * `brew pr-upload --no-commit` in the bottle directory.
 
 Alternative instructions using `pr-pull`:
-* `git reset --hard <SHA>` in homebrew/core to reset to the commit before before all the commits created by `brew pr-pull`.
-* `brew pr-pull <options>` to upload the right bottles. Add the `--warn-on-upload-failure` flag if the bottles have been partially uploaded and you're certain that the bottle checksums will match the checksums already present in the `bottle do` block of the formula.
+
+* `git reset --hard <SHA>` in `homebrew/core` to reset to the commit before all the commits created by `brew pr-pull`.
+* `brew pr-pull <options>` to upload the right bottles. Add the `--warn-on-upload-failure` switch if the bottles have been partially uploaded and you're certain that the bottle checksums will match the checksums already present in the `bottle do` block of the formula.
 * `git reset --hard origin/master` to return to the latest commit and discard the commits made by `brew pr-pull`.
 
 ### `ld: internal error: atom not found in symbolIndex(__ZN10SQInstance3GetERK11SQObjectPtrRS0_) for architecture x86_64`
 
 The exact atom may be different.
 
-This can be caused by passing the obsolete `-s` flag to the linker and can be
-fixed like [this](https://github.com/Homebrew/homebrew-core/commit/c4ad981d788b21a406a6efe7748f2922986919a8).
+This can be caused by passing the obsolete `-s` option to the linker and can be fixed [using `inreplace`](https://github.com/Homebrew/homebrew-core/commit/c4ad981d788b21a406a6efe7748f2922986919a8).
diff --git a/docs/Common-Issues.md b/docs/Common-Issues.md
index 6b61a7a7e086d..a6ce9616411aa 100644
--- a/docs/Common-Issues.md
+++ b/docs/Common-Issues.md
@@ -2,6 +2,9 @@
 
 This is a list of commonly encountered problems, known issues, and their solutions.
 
+* Table of Contents
+{:toc}
+
 ## Running `brew`
 
 ### `brew` complains about absence of "Command Line Tools"
@@ -34,7 +37,7 @@ cd "$(brew --repository)/Library"
 git clean -fd
 ```
 
-### `launchctl` refuses to load launchd plist files
+### `launchctl` refuses to load `launchd` plist files
 
 When trying to load a plist file with `launchctl`, you receive an error that resembles either:
 
@@ -99,12 +102,29 @@ Don't follow the advice here but fix by using
 `Language::Python.setup_install_args` in the formula as described in
 [Python for Formula Authors](Python-for-Formula-Authors.md).
 
+## Installation fails with "unknown revision or path not in the working tree"
+
+When installing Homebrew, if the initial download fails with something like:
+
+    error: Not a valid ref: refs/remotes/origin/master
+    fatal: ambiguous argument 'refs/remotes/origin/master': unknown revision or path not in the working tree.
+    Use '--' to separate paths from revisions, like this:
+    'git <command> [<revision>...] -- [<file>...]'
+
+or:
+
+    fatal: the remote end hung up unexpectedly
+    fatal: early EOF
+    fatal: index-pack failed
+
+This is an issue in the connection between your machine and GitHub, rather than a bug in Homebrew itself. See this [discussion topic](https://github.com/orgs/Homebrew/discussions/666) for a number of solutions others have found, such as using a wired connection or a VPN, or disabling network monitoring tools.
+
 ## Upgrading macOS
 
 Upgrading macOS can cause errors like the following:
 
-- `dyld: Library not loaded: /usr/local/opt/icu4c/lib/libicui18n.54.dylib`
-- `configure: error: Cannot find libz`
+* `dyld: Library not loaded: /usr/local/opt/icu4c/lib/libicui18n.54.dylib`
+* `configure: error: Cannot find libz`
 
 Following a macOS upgrade it may be necessary to reinstall the Xcode Command Line Tools and then `brew upgrade` all installed formulae:
 
@@ -113,7 +133,47 @@ xcode-select --install
 brew upgrade
 ```
 
-## Cask - cURL error
+## Unintentional dual Homebrew installations
+
+When using tools such as Apple's _Migration Assistant_ (MA), it's possible to have two Homebrew installations unintentionally.
+This most commonly results in MA copying `/usr/local` and `/Applications` from an Intel-based Mac to these same paths on an Apple Silicon-based Mac.
+This is problematic because `/Applications` may contain x86_64-only apps.
+Using an x86_64 terminal emulator will cause the shell to use the `/usr/local` installation of Homebrew
+instead of a new installation in `/opt/homebrew`, which is the correct path for an arm64 Homebrew installation on macOS.
+
+Continuing with this setup may eventually cause problems, so it's best to migrate your Homebrew installation.
+Follow these steps to do this.
+
+1. Run `arch -x86_64 /usr/local/bin/brew bundle dump --global` to dump your current installed formulae list to `~/.Brewfile`.
+1. Review the contents of `~/.Brewfile` to remove things you no longer want to have installed.
+1. Verify that your terminal emulator is running in arm64 mode by checking that the output of `arch` is `arm64`.
+
+   If it is not, use a different terminal emulator, such as Apple's Terminal.app, that will run in `arm64` mode.
+
+1. Install Homebrew under the correct prefix (`/opt/homebrew`),
+   which will happen by default when the terminal is running in arm64 mode.
+
+   **Follow the _Next Steps_ instructions** listed at the end of the installation process;
+    failing to adjust your shell configuration accordingly could break your Homebrew installation.
+
+1. Run `/opt/homebrew/bin/brew bundle install --global` to replicate your original formulae installation using your new Homebrew installation in `/opt/homebrew`.
+
+Expect to spend some time [searching Homebrew's formulae and cask list](https://formulae.brew.sh/)
+for replacements for deprecated, disabled, or removed formulae.
+
+Once you are satisfied with the state of your new `/opt/homebrew` Homebrew installation,
+you can uninstall the old `/usr/local` installation.
+Download and run [the uninstaller](https://github.com/Homebrew/install/#uninstall-homebrew) script:
+
+```sh
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/uninstall.sh)" -- --path=/usr/local
+```
+
+For more information, see [this discussion](https://github.com/orgs/Homebrew/discussions/4397#discussioncomment-5567441).
+
+## Homebrew Cask issues
+
+### Cask - cURL error
 
 First, let's tackle a common problem: do you have a `.curlrc` file? Check with `ls -A ~ | grep .curlrc` (if you get a result, the file exists). Those are a frequent cause of issues of this nature. Before anything else, remove that file and try again. If it now works, do not open an issue. Incompatible `.curlrc` configurations must be fixed on your side.
 
@@ -122,81 +182,76 @@ If, however, you do not have a `.curlrc` or removing it did not work, let’s se
 1. Go to the vendor’s website (`brew home <cask_name>`).
 2. Find the download link for the app and click on it.
 
-### If the download works
+#### If the download works
 
 The cask is outdated. Let’s fix it:
 
-1. Look around the app’s website and find out what the latest version is. It will likely be expressed in the URL used to download it.
-2. Take a look at the cask’s version (`brew cat <cask_name>`) and verify it is indeed outdated. If the app’s version is `:latest`, it means the `url` itself is outdated. It will need to be changed to the new one.
+1. Look around the app’s website and find out what the latest version is. It may be expressed in the URL used to download it.
+2. Take a look at the cask’s version (`brew info <cask_name>`) and verify it is indeed outdated. If the app’s version is `:latest`, it means the `url` itself is outdated. It will need to be changed to the new one.
 
 Help us by [submitting a fix](https://github.com/Homebrew/homebrew-cask/blob/HEAD/CONTRIBUTING.md#updating-a-cask). If you get stumped, [open an issue](https://github.com/Homebrew/homebrew-cask/issues/new?template=01_bug_report.md) explaining your steps so far and where you’re having trouble.
 
-### If the download does not work
+#### If the download does not work
 
 The issue isn’t in any way related to Homebrew Cask, but with the vendor or your connection.
 
-Start by diagnosing your connection (try to download other casks, go around the web). If the problem is with your connection, try a website like [Ask Different](https://apple.stackexchange.com/) to ask for advice.
+Start by diagnosing your connection (try to download other casks, or browse around the web). If the problem is with your connection, try a website like [Ask Different](https://apple.stackexchange.com/) to ask for advice.
 
 If you’re sure the issue is not with your connection, contact the app’s vendor and let them know their link is down, so they can fix it.
 
 **Do not open an issue.**
 
-## Cask - checksum does not match
+### Cask - checksum does not match
 
 First, check if the problem was with your download. Delete the downloaded file (its location will be pointed out in the error message) and try again.
 
-If the problem persists, the cask must be outdated. It’ll likely need a new version, but it’s possible the version has remained the same (happens occasionally when the vendor updates the app in place).
+If the problem persists, the cask must be outdated. It’ll likely need a new version, but it’s possible the version has remained the same (this happens occasionally when the vendor updates the app in-place).
 
 1. Go to the vendor’s website (`brew home <cask_name>`).
 2. Find out what the latest version is. It may be expressed in the URL used to download it.
-3. Take a look at the cask’s version (`brew info <cask_name>`) and verify it is indeed outdated. If it is:
+3. Take a look at the cask’s version (`brew info <cask_name>`) and verify it is indeed outdated. If so, it will need to be updated.
 
 Help us by [submitting a fix](https://github.com/Homebrew/homebrew-cask/blob/HEAD/CONTRIBUTING.md#updating-a-cask). If you get stumped, [open an issue](https://github.com/Homebrew/homebrew-cask/issues/new?template=01_bug_report.md) explaining your steps so far and where you’re having trouble.
 
-## Cask - permission denied
+### Cask - permission denied
 
-In this case, it’s likely your user account has no admin rights so you don’t have permissions to write to `/Applications` (which is the default). You can use [`--appdir`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/USAGE.md#options) to choose where to install your applications.
+In this case, it’s likely your user account has no admin rights and therefore lacks permissions for writing to `/Applications`, which is the default install location. You can use [`--appdir`](https://github.com/Homebrew/homebrew-cask/blob/HEAD/USAGE.md#options) to choose where to install your applications.
 
-If `--appdir` doesn’t fix the issue or you do have write permissions to `/Applications`, verify you’re the owner of the `Caskroom` directory by running `ls -dl "$(brew --prefix)/Caskroom"` and checking the third field. If you are not the owner, fix it with `sudo chown -R "$(whoami)" "$(brew --prefix)/Caskroom"`. If you are, the problem may lie in the app bundle itself.
+If `--appdir` doesn’t fix the issue or you do have write permissions to `/Applications`, verify you’re the owner of the `Caskroom` directory by running `ls -dl "$(brew --caskroom)"` and checking the third field. If you are not the owner, fix it with `sudo chown -R "$(whoami)" "$(brew --caskroom)"`. If you are, the problem may lie in the app bundle itself.
 
-Some app bundles don’t have certain permissions that are necessary for us to move them to the appropriate location. You may check such permissions with `ls -ls <path_to_app_bundle>`. If you see something like `dr-xr-xr-x` at the start of the output, that may be the cause. To fix it, we change the app bundle’s permission to allow us to move it, and then set it back to what it was (in case the developer set those permissions deliberately). See [`litecoin`](https://github.com/Homebrew/homebrew-cask/blob/0cde71f1fea8ad62d6ec4732fcf35ac0c52d8792/Casks/litecoin.rb#L14L20) for an example of such a cask.
+Some app bundles don’t have certain permissions that are necessary for us to move them to the appropriate location. You may check such permissions with `ls -ls '/path/to/application.app'`. If you see something like `dr-xr-xr-x` at the start of the output, that may be the cause. To fix it, we need to change the app bundle’s permission to allow us to move it, and then set it back to what it was (in case the developer set those permissions deliberately). See [litecoin.rb](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/l/litecoin.rb#L17-L27) for an example of such a cask.
 
 Help us by [submitting a fix](https://github.com/Homebrew/homebrew-cask/blob/HEAD/CONTRIBUTING.md#updating-a-cask). If you get stumped, [open an issue](https://github.com/Homebrew/homebrew-cask/issues/new?template=01_bug_report.md) explaining your steps so far and where you’re having trouble.
 
-## Cask - source is not there
+### Cask - source is not there
 
-First, you need to identify which artifact is not being handled correctly anymore. It’s explicit in the error message: if it says `It seems the App source…'` the problem is [`app`](https://docs.brew.sh/Cask-Cookbook#stanza-app). The pattern is the same across [all artifacts](https://docs.brew.sh/Cask-Cookbook#at-least-one-artifact-stanza-is-also-required).
+First, you need to identify which artifact is not being handled correctly anymore. It’s explicit in the error message: if it says `It seems the App source…'` then the problem is with the [`app`](https://docs.brew.sh/Cask-Cookbook#stanza-app) stanza. This pattern is the same across [all artifacts](https://docs.brew.sh/Cask-Cookbook#at-least-one-artifact-stanza-is-also-required).
 
-Fixing this error is typically easy, and requires only a bit of time on your part. Start by downloading the package for the cask: `brew fetch <cask_name>`. The last line of output will inform you of the location of the download. Navigate there and manually unpack it. As an example, lets say the structure inside the archive is as follows:
+Fixing this error is typically easy, and requires only a bit of time on your part. Start by downloading the package for the cask: `brew fetch <cask_name>`. The last line of output will inform you of the location of the download. Navigate there and manually unpack it. As an example, let's say the structure inside the archive is as follows:
 
-```
-.
-├─ Files/SomeApp.app
-├─ Files/script.sh
-└─ README.md
-```
+    .
+    ├─ Files/SomeApp.app
+    ├─ Files/script.sh
+    └─ README.md
 
-Now, let's look at the cask (`brew cat <cask_name>`):
+Now, if we find this when looking at the cask with `brew cat <cask_name>`:
 
-```
-(…)
-app "SomeApp.app"
-(…)
-```
+    (…)
+    app "SomeApp.app"
+    (…)
 
-The cask was expecting `SomeApp.app` to be in the top directory of the archive (see how it says simply `SomeApp.app`) but the developer changed it to inside a `Files` directory. All we have to do is update that line of the cask to follow the new structure: `app 'Files/SomeApp.app'`.
+The cask expects `SomeApp.app` to be in the top directory of the archive (see how it says simply `SomeApp.app`) but the developer has since moved it to be inside a `Files` directory. All we have to do is update that line of the cask to follow the new structure: `app "Files/SomeApp.app"`.
 
 Note that occasionally the app’s name changes completely (from `SomeApp.app` to `OtherApp.app`, let's say). In these instances, the filename of the cask itself, as well as its token, must also change. Consult the [`token reference`](https://docs.brew.sh/Cask-Cookbook#token-reference) for complete instructions on the new name.
 
 Help us by [submitting a fix](https://github.com/Homebrew/homebrew-cask/blob/HEAD/CONTRIBUTING.md#updating-a-cask). If you get stumped, [open an issue](https://github.com/Homebrew/homebrew-cask/issues/new?template=01_bug_report.md) explaining your steps so far and where you’re having trouble.
 
-## Cask - wrong number of arguments
+### Cask - wrong number of arguments
 
-Make sure the issue really lies with your macOS version. To do so, try to install the software manually. If it is incompatible with your macOS version, it will tell you. In that case, there is nothing we can do to help you install the software, but we can add a [`depends_on macos:`](https://docs.brew.sh/Cask-Cookbook#depends_on-macos) stanza to prevent the cask from trying to install on incompatible macOS versions.
+Make sure the issue really lies with your macOS version. To do so, try to install the software manually. If it is incompatible with your macOS version, it will tell you. In that case, there is nothing we can do to help you install the software, but we can add a [`depends_on macos:`](https://docs.brew.sh/Cask-Cookbook#depends_on-macos) stanza to prevent the cask from being installed on incompatible macOS versions.
 
 Help us by [submitting a fix](https://github.com/Homebrew/homebrew-cask/blob/HEAD/CONTRIBUTING.md#updating-a-cask). If you get stumped, [open an issue](https://github.com/Homebrew/homebrew-cask/issues/new?template=01_bug_report.md) explaining your steps so far and where you’re having trouble.
 
-
 ## Other local issues
 
 If your Homebrew installation gets messed up (and fixing the issues found by `brew doctor` doesn't solve the problem), reinstalling Homebrew may help to reset to a normal state. To easily reinstall Homebrew, use [Homebrew Bundle](https://github.com/Homebrew/homebrew-bundle) to automatically restore your installed formulae and casks. To do so, run `brew bundle dump`, [uninstall](https://docs.brew.sh/FAQ#how-do-i-uninstall-homebrew), [reinstall](https://docs.brew.sh/Installation) and run `brew bundle install`.
diff --git a/docs/Custom-GCC-and-cross-compilers.md b/docs/Custom-GCC-and-cross-compilers.md
index c9255839656ae..2dda2d54f52c1 100644
--- a/docs/Custom-GCC-and-cross-compilers.md
+++ b/docs/Custom-GCC-and-cross-compilers.md
@@ -5,7 +5,7 @@ Homebrew depends on having an up-to-date version of Xcode because it comes with
 Rather than merging formulae for either of these cases at this time, we're listing them on this page. If you come up with a formula for a new version of GCC or cross-compiler suite, please link to it here.
 
 - Homebrew provides a `gcc` formula for use with Xcode 4.2+.
-- Homebrew provides older GCC formulae, e.g. `gcc@7`.
+- Homebrew provides older GCC formulae, e.g. `gcc@9`.
 - Homebrew provides some cross-compilers and toolchains, but these are named to avoid clashing with the default tools, e.g. `i686-elf-gcc`, `x86_64-elf-gcc`.
 - Homebrew provides LLVM's Clang, which is bundled with the `llvm` formula.
 - [RISC-V](https://github.com/riscv/homebrew-riscv) provides the RISC-V toolchain including binutils and GCC.
diff --git a/docs/Deprecating-Disabling-and-Removing-Casks.md b/docs/Deprecating-Disabling-and-Removing-Casks.md
new file mode 100644
index 0000000000000..396fb1a36966f
--- /dev/null
+++ b/docs/Deprecating-Disabling-and-Removing-Casks.md
@@ -0,0 +1,102 @@
+# Deprecating, Disabling and Removing Casks
+
+There are many reasons why casks may be deprecated, disabled or removed. This document explains the differences between each method as well as explaining when one method should be used over another.
+
+## Overview
+
+These general rules of thumb can be followed:
+
+- `deprecate!` should be used for casks that _should_ no longer be used.
+- `disable!` should be used for casks that _cannot_ be used.
+- Casks that are no longer acceptable in `homebrew/cask` or have been disabled for over a year _should_ be removed.
+
+## Deprecation
+
+If a user attempts to install a deprecated cask, they will be shown a warning message but the install will proceed.
+
+A cask should be deprecated to indicate to users that the cask should not be used and will be disabled in the future. Deprecated casks should continue to be maintained by the Homebrew maintainers if they continue to be installable. If this is not possible, they should be immediately disabled.
+
+The most common reasons for deprecation are when the upstream project is deprecated, unmaintained or archived.
+
+Casks should only be deprecated if at least one of the following are true:
+
+- the software installed by the cask cannot be run on any of our supported macOS versions
+- the cask has outstanding CVEs
+- the cask has [zero installs in the last 90 days](https://formulae.brew.sh/analytics/cask-install/90d/)
+- the software installed by the cask has been discontinued upstream
+
+To deprecate a cask, add a `deprecate!` call. This call should include a deprecation date in the ISO 8601 format and a deprecation reason:
+
+```ruby
+deprecate! date: "YYYY-MM-DD", because: :reason
+```
+
+The `date` parameter should be set to the date that the deprecation period should begin, which is usually today's date. If the `date` parameter is set to a date in the future, the cask will not become deprecated until that date. This can be useful if the upstream developers have indicated a date when the project or version will stop being supported. Do not backdate the `date` parameter as it causes confusion for users and maintainers.
+
+The `because` parameter can be a preset reason (using a symbol) or a custom reason. See the [Deprecate and Disable Reasons](#deprecate-and-disable-reasons) section below for more details about the `because` parameter.
+
+## Disabling
+
+If a user attempts to install a disabled cask, they will be shown an error message and the install will fail.
+
+A cask should be disabled to indicate to users that the cask cannot be used and will be removed in the future. Disabled cask are those that could not be installed successfully any longer.
+
+The most common reasons for disabling a cask are:
+
+- it cannot be installed on any of our supported macOS versions
+- it has been deprecated for a long time
+- the upstream URL has been removed
+
+Popular casks (e.g. have more than 300 [analytics installs in the last 90 days](https://formulae.brew.sh/analytics/cask-install/90d/)) should not be disabled without a deprecation period of at least six months unless they cannot be installed on all macOS versions and issue is unable be fixed (e.g. download URL no longer works and a mirror cannot be sourced).
+
+Unpopular casks (e.g. have fewer than 300 [analytics installs in the last 90 days](https://formulae.brew.sh/analytics/cask-install/90d/)) can be disabled immediately for any of the reasons above.
+They can be manually removed three months after their disable date.
+
+To disable a cask, add a `disable!` call. This call should include a deprecation date (in the ISO 8601 format) and a deprecation reason:
+
+```ruby
+disable! date: "YYYY-MM-DD", because: :reason
+```
+
+The `date` parameter should be set to the date that the reason for disabling came into effect. If there is no clear date but the cask needs to be disabled, use today's date. If the `date` parameter is set to a date in the future, the cask will be deprecated until that date (on which the cask will become disabled).
+
+The `because` parameter can be a preset reason (using a symbol) or a custom reason. See the [Deprecate and Disable Reasons](#deprecate-and-disable-reasons) section below for more details about the `because` parameter.
+
+## Removal
+
+A cask should be removed if it does not meet our criteria for [acceptable casks](Acceptable-Casks.md) or has been disabled for over a year.
+
+**Note: disabled casks in `homebrew/cask` will be automatically removed one year after their disable date.**
+
+## Deprecate and Disable Reasons
+
+When a cask is deprecated or disabled, a reason explaining the action must be provided.
+
+There are two ways to indicate the reason. The preferred way is to use a pre-existing symbol to indicate the reason. The available symbols are listed below and can be found in the [`DeprecateDisable` module](https://github.com/Homebrew/brew/blob/master/Library/Homebrew/deprecate_disable.rb):
+
+- `:discontinued`: the cask is discontinued upstream
+- `:no_longer_available`: the cask is no longer available upstream
+- `:unmaintained`: the cask is not maintained upstream
+
+These reasons can be specified by their symbols (the comments show the message that will be displayed to users):
+
+```ruby
+# Warning: <cask> has been deprecated because it is discontinued upstream!
+deprecate! date: "2020-01-01", because: :discontinued
+```
+
+If these pre-existing reasons do not fit, a custom reason can be specified. Such reasons should be written to fit into the sentence `<cask> has been deprecated/disabled because it <reason>!`.
+
+A well-worded example of a custom reason would be:
+
+```ruby
+# Warning: <cask> has been deprecated because it has unresolved CVEs!
+deprecate! date: "2020-01-01", because: "has unresolved CVEs"
+```
+
+A poorly-worded example of a custom reason would be:
+
+```ruby
+# Error: <cask> has been disabled because it broken!
+disable! date: "2020-01-01", because: "broken"
+```
diff --git a/docs/Deprecating-Disabling-and-Removing-Formulae.md b/docs/Deprecating-Disabling-and-Removing-Formulae.md
index b7828385fda08..5282a6ecbf8b6 100644
--- a/docs/Deprecating-Disabling-and-Removing-Formulae.md
+++ b/docs/Deprecating-Disabling-and-Removing-Formulae.md
@@ -1,28 +1,31 @@
-# Deprecating, Disabling, and Removing Formulae
+# Deprecating, Disabling and Removing Formulae
 
-There are many reasons why formulae may be deprecated, disabled, or removed. This document explains the differences between each method as well as explaining when one method should be used over another.
+There are many reasons why formulae may be deprecated, disabled or removed. This document explains the differences between each method as well as explaining when one method should be used over another.
 
 ## Overview
 
-This general rule of thumb can be followed:
+These general rules of thumb can be followed:
 
 - `deprecate!` should be used for formulae that _should_ no longer be used.
 - `disable!` should be used for formulae that _cannot_ be used.
-- Formulae that are no longer acceptable in homebrew/core or have been disabled for over a year should be removed.
+- Formulae that are no longer acceptable in `homebrew/core` or have been disabled for over a year _should_ be removed.
 
 ## Deprecation
 
 If a user attempts to install a deprecated formula, they will be shown a warning message but the install will proceed.
 
-A formula should be deprecated to indicate to users that the formula should not be used and will be disabled in the future. Deprecated formulae should be maintained by the Homebrew maintainers so they can still build from source and their bottles continue to work (even if unmaintained upstream). If this is not possible, they should be disabled.
+A formula should be deprecated to indicate to users that the formula should not be used and will be disabled in the future. Deprecated formulae should continue to be maintained by the Homebrew maintainers so they still build from source and their bottles continue to work (even if unmaintained upstream). If this is not possible, they should be disabled.
 
 The most common reasons for deprecation are when the upstream project is deprecated, unmaintained, or archived.
 
-Formulae with dependents may be deprecated only if at least one of the following are true:
+Formulae should only be deprecated if at least one of the following are true:
 
-- its dependents are all deprecated
 - the formula does not build on any of our supported macOS versions and on Linux
 - the formula has outstanding CVEs
+- the formula has [zero installs in the last 90 days](https://formulae.brew.sh/analytics/install/90d/)
+- the software installed by the formula has been discontinued or abandoned upstream
+
+Formulae with dependents should not be deprecated until or when all dependents are also deprecated.
 
 To deprecate a formula, add a `deprecate!` call. This call should include a deprecation date (in the ISO 8601 format) and a deprecation reason:
 
@@ -30,7 +33,7 @@ To deprecate a formula, add a `deprecate!` call. This call should include a depr
 deprecate! date: "YYYY-MM-DD", because: :reason
 ```
 
-The `date` parameter should be set to the date that the project or version became (or will become) deprecated. If there is no clear date but the formula needs to be deprecated, use today's date. If the `date` parameter is set to a date in the future, the formula will not become deprecated until that date. This can be useful if the upstream developers have indicated a date where the project or version will stop being supported.
+The `date` parameter should be set to the date that the deprecation period should begin, which is usually today's date. If the `date` parameter is set to a date in the future, the formula will not become deprecated until that date. This can be useful if the upstream developers have indicated a date when the project or version will stop being supported. Do not backdate the `date` parameter as it causes confusion for users and maintainers.
 
 The `because` parameter can be a preset reason (using a symbol) or a custom reason. See the [Deprecate and Disable Reasons](#deprecate-and-disable-reasons) section below for more details about the `because` parameter.
 
@@ -42,16 +45,16 @@ A formula should be disabled to indicate to users that the formula cannot be use
 
 The most common reasons for disabling a formula are:
 
-- it cannot be built from source (meaning no bottles can be built)
+- it cannot be built from source on all supported OS versions (meaning no new bottles can be built)
 - it has been deprecated for a long time
-- the upstream repository has been removed
 - the project has no license
 
-Formulae should not be disabled without a deprecation period of at least three months unless the circumstances are exceptional (e.g. the formula does not build on any supported macOS version or Linux). Popular formulae should have longer deprecation periods. The popularity of a formula should be based on our analytics data.
+Popular formulae (e.g. have more than 1000 [analytics installs in the last 90 days](https://formulae.brew.sh/analytics/install/90d/)) should not be disabled without a deprecation period of at least six months even if e.g. they do not build from source and do not have a license.
 
-**Note: disabled formulae in homebrew/core will be automatically removed one year after their disable date**
+Unpopular formulae (e.g. have fewer than 1000 [analytics installs in the last 90 days](https://formulae.brew.sh/analytics/install/90d/)) can be disabled immediately for any of the reasons above e.g. they cannot be built from source on any supported macOS version or Linux.
+They can be manually removed three months after their disable date.
 
-To disable a formula, add a `disable!` call. This call should include a deprecation date (in the ISO 8601 format) and a deprecation reason:
+To disable a formula, add a `disable!` call. This call should include a deprecation date in the ISO 8601 format and a deprecation reason:
 
 ```ruby
 disable! date: "YYYY-MM-DD", because: :reason
@@ -65,20 +68,23 @@ The `because` parameter can be a preset reason (using a symbol) or a custom reas
 
 A formula should be removed if it does not meet our criteria for [acceptable formulae](Acceptable-Formulae.md) or [versioned formulae](Versions.md), has a non-open-source license, or has been disabled for over a year.
 
+**Note: disabled formulae in `homebrew/core` will be automatically removed one year after their disable date.**
+
 ## Deprecate and Disable Reasons
 
 When a formula is deprecated or disabled, a reason explaining the action must be provided.
 
 There are two ways to indicate the reason. The preferred way is to use a pre-existing symbol to indicate the reason. The available symbols are listed below and can be found in the [`DeprecateDisable` module](https://github.com/Homebrew/brew/blob/master/Library/Homebrew/deprecate_disable.rb):
 
-- `:does_not_build`: the formula cannot be built from source
-- `:no_license`: the formula does not have a license
-- `:repo_archived`: the upstream repository has been archived
-- `:repo_removed`: the upstream repository has been removed
-- `:unmaintained`: the project appears to be abandoned
-- `:unsupported`: Homebrew's application of the software is not supported by the upstream developers (e.g. upstream only supports macOS versions prior to 10.14)
-- `:deprecated_upstream`: the project is deprecated upstream
-- `:versioned_formula`: the formula is a versioned formula
+- `:does_not_build`: the formula cannot be built from source on any supported macOS version or Linux.
+- `:no_license`: we cannot identify a license for the formula
+- `:repo_archived`: the upstream repository has been archived and no replacement is pointed to that we can use
+- `:repo_removed`: the upstream repository has been removed and no replacement is mentioned on the homepage that we can use
+- `:unmaintained`: the project appears to be abandoned i.e. it has had no commits for at least a year and has critical bugs or CVE that have been reported and gone resolved longer. Note: some software is "done"; a lack of activity does not imply a need for removal.
+- `:unsupported`: Homebrew's compilation of the software is not supported by the upstream developers (e.g. upstream only supports macOS versions older than 10.15)
+- `:deprecated_upstream`: the project is deprecated upstream and no replacement is pointed to that we can use
+- `:versioned_formula`: the formula is a versioned formula and no longer [meets the requirements](Versions.md).
+- `:checksum_mismatch`: the checksum of the source for the formula's current version has changed since bottles were built and we cannot find a reputable source or statement justifying this
 
 These reasons can be specified by their symbols (the comments show the message that will be displayed to users):
 
@@ -92,7 +98,7 @@ deprecate! date: "2020-01-01", because: :deprecated_upstream
 disable! date: "2020-01-01", because: :does_not_build
 ```
 
-If these pre-existing reasons do not fit, a custom reason can be specified. These reasons should be written to fit into the sentence `<formula> has been deprecated/disabled because it <reason>!`.
+If these pre-existing reasons do not fit, a custom reason can be specified. Such reasons should be written to fit into the sentence `<formula> has been deprecated/disabled because it <reason>!`.
 
 A well-worded example of a custom reason would be:
 
diff --git a/docs/Diagram-Guidelines.md b/docs/Diagram-Guidelines.md
deleted file mode 100644
index a31669784e94f..0000000000000
--- a/docs/Diagram-Guidelines.md
+++ /dev/null
@@ -1,45 +0,0 @@
-# Diagram Guidelines
-
-## Preferred file format
-
-For complex diagrams, use the `.drawio.svg` format.
-
-Files with the `.drawio.svg` extension are SVG files with embedded [draw.io](https://www.diagrams.net/) source code. Using that format lends itself to a developer-friendly workflow: it is valid SVG, plays well with `git diff` and can be edited in lock-step using various online and offline flavours of draw.io. If you use VS Code, you can use an [extension](https://marketplace.visualstudio.com/items?itemName=hediet.vscode-drawio) for draw.io integration.
-
-Files in the `.drawio.svg` format can be processed offline.
-
-## Embedding a diagram into Markdown
-
-To embed a `.drawio.svg` file into Markdown, use the same syntax as for any image. Example: `![My diagram](my-diagram.drawio.svg)`
-
-Mind that GitHub doesn’t allow styling in Markdown documents. Where styling is allowed (e.g. in the exported brew.sh version of the documentation), always set a background colour of `white` for the diagram. That’s the colour draw.io assumes, and keeps the diagram easy to read in dark mode without further customization. You can use the CSS selector `img[src$=".drawio.svg"]` for styling.
-
-## Example
-
-Example for an SVG image embedded into Markdown:
-
-```md
-![Example diagram: Managing Pull Requests](assets/img/docs/managing-pull-requests.drawio.svg)
-```
-
-Result:
-
-![Example diagram: Managing Pull Requests](assets/img/docs/managing-pull-requests.drawio.svg)
-
-Example for styling (where allowed):
-
-```css
-img[src$=".drawio.svg"] {
-  background-color: white;
-  margin-bottom: 20px;
-  padding: 5%;
-  width: 90%;
-}
-
-@media (prefers-color-scheme: dark) {
-  img[src$=".drawio.svg"] {
-    filter: invert(85%);
-    -webkit-filter: invert(85%);
-  }
-}
-```
diff --git a/docs/External-Commands.md b/docs/External-Commands.md
index 46cc807476053..05ab51e46a2bb 100644
--- a/docs/External-Commands.md
+++ b/docs/External-Commands.md
@@ -24,19 +24,19 @@ The command may `Kernel.exit` with a status code if it needs to; if it doesn't e
 
 ### Other executable scripts
 
-An executable script for a command named `extcmd` should be named `brew-extcmd`. The script itself can use any suitable shebang (`#!`) line, so an external script can be written in Bash, Ruby, or even Python. Unlike the ruby commands this file must not end with a language-specific suffix (`.sh`, or `.py`). This file will be run via `exec` with some Homebrew variables set as environment variables, and passed any additional command-line arguments.
+An executable script for a command named `extcmd` should be named `brew-extcmd`. The script itself can use any suitable shebang (`#!`) line, so an external script can be written in Bash, Ruby, or even Python. Unlike the Ruby commands this file must not end with a language-specific suffix (`.sh`, or `.py`). This file will be run via `exec` with some Homebrew variables set as environment variables, and passed any additional command-line arguments.
 
-| Variable               | Description                                                                                                                                                                 |
-|------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `HOMEBREW_CACHE`       | Where Homebrew caches downloaded tarballs to, by default `~/Library/Caches/Homebrew`.                                                                                       |
-| `HOMEBREW_PREFIX`      | Where Homebrew installs software. `/usr/local` by default for macOS Intel, `/opt/homebrew` for Apple Silicon and `/home/linuxbrew/.linuxbrew` for Linux.                    |
-| `HOMEBREW_CELLAR`      | The location of the Homebrew Cellar, where software is staged. This will be `HOMEBREW_PREFIX/Cellar` if that directory exists, or `HOMEBREW_REPOSITORY/Cellar` otherwise.   |
-| `HOMEBREW_LIBRARY_PATH`| The directory containing Homebrew’s own application code.                                                                                                                   |
-| `HOMEBREW_REPOSITORY`  | The Git repository directory (i.e. where Homebrew’s `.git` directory lives). Usually either the same as `HOMEBREW_PREFIX` or a `Homebrew` subdirectory.                    |
+| variable               | description |
+| ---------------------- | ----------- |
+| `HOMEBREW_CACHE`       | Where Homebrew caches downloaded tarballs to, by default `~/Library/Caches/Homebrew`. |
+| `HOMEBREW_PREFIX`      | Where Homebrew installs software. `/usr/local` by default for macOS Intel, `/opt/homebrew` for Apple Silicon and `/home/linuxbrew/.linuxbrew` for Linux. |
+| `HOMEBREW_CELLAR`      | The location of the Homebrew Cellar, where software is staged. This will be `HOMEBREW_PREFIX/Cellar` if that directory exists, or `HOMEBREW_REPOSITORY/Cellar` otherwise. |
+| `HOMEBREW_LIBRARY_PATH`| The directory containing Homebrew’s own application code. |
+| `HOMEBREW_REPOSITORY`  | The Git repository directory (i.e. where Homebrew’s `.git` directory lives). Usually either the same as `HOMEBREW_PREFIX` or a `Homebrew` subdirectory. |
 
 ## Providing `--help`
 
-All internal and external Homebrew commands can provide styled `--help` output by using Homebrew’s [argument parser](https://rubydoc.brew.sh/Homebrew/CLI/Parser.html), as seen in the [`brew services` command](https://github.com/Homebrew/homebrew-services/blob/HEAD/cmd/services.rb); or by including lines starting with `#:` (a comment then `:` character in both Bash and Ruby), as seen in the [header of `update.sh`](https://github.com/Homebrew/brew/blob/cf7def0c68903814c6b4e04a55fe8f3cb3f5605e/Library/Homebrew/cmd/update.sh#L1-L10), which is printed with `brew update --help`.
+All internal and external Homebrew commands can provide styled `--help` output by using Homebrew’s [argument parser](https://rubydoc.brew.sh/Homebrew/CLI/Parser), as seen in the [`brew services` command](https://github.com/Homebrew/homebrew-services/blob/HEAD/cmd/services.rb); or by including lines starting with `#:` (a comment then `:` character in both Bash and Ruby), as seen in the [header of `update.sh`](https://github.com/Homebrew/brew/blob/cf7def0c68903814c6b4e04a55fe8f3cb3f5605e/Library/Homebrew/cmd/update.sh#L1-L10), which is printed with `brew update --help`.
 
 ## Unofficial external commands
 
@@ -56,36 +56,38 @@ External commands can be hosted in a [tap](Taps.md) to allow users to easily ins
 
 External commands should be added to a `cmd` directory in the tap. An external command `extcmd` implemented as a Ruby command should live in `cmd/extcmd.rb` (don't forget to `chmod +x`).
 
-To easily use Homebrew's argument parser, replicate the following Ruby template for external commands (replacing all instances of `foo` with the name of the command):
+To easily use Homebrew's argument parser, replicate the Ruby template below for external commands. Your implementation must include the following:
+
+- The class name should be the command name in CamelCase (e.g. `my-cmd` should be named `MyCmd`).
+- Provide a `cmd_args` block that describes the command and its arguments.
+- Implement the `run` method, which will be invoked when the command is executed. Within the `run` method, the parsed arguments are available using `args`.
 
 ```ruby
 # frozen_string_literal: true
 
 module Homebrew
-  module_function
-
-  def foo_args
-    Homebrew::CLI::Parser.new do
-      description <<~EOS
-        Do something. Place a description here.
-      EOS
-      switch "-f", "--force",
-             description: "Force doing something in the command."
-      flag   "--file=",
-             description: "Specify a file to do something with in the command."
-      comma_array "--names",
-                  description: "Add a list of names to the command."
-
-      named_args [:formula, :cask], min: 1
+  module Cmd
+    class Foo < AbstractCommand
+      cmd_args do
+        description <<~EOS
+          Do something. Place a description here.
+        EOS
+        switch "-f", "--force",
+               description: "Force doing something in the command."
+        flag   "--file=",
+               description: "Specify a file to do something with in the command."
+        comma_array "--names",
+                    description: "Add a list of names to the command."
+
+        named_args [:formula, :cask], min: 1
+      end
+
+      def run
+        something if args.force?
+        something_else if args.file == "file.txt"
+      end
     end
   end
-
-  def foo
-    args = foo_args.parse
-
-    something if args.force?
-    something_else if args.file == "file.txt"
-  end
 end
 ```
 
diff --git a/docs/FAQ.md b/docs/FAQ.md
index 6d37d8a629662..63a9ae33230be 100644
--- a/docs/FAQ.md
+++ b/docs/FAQ.md
@@ -1,4 +1,7 @@
-# FAQ
+# FAQ (Frequently Asked Questions)
+
+* Table of Contents
+{:toc}
 
 ## Is there a glossary of terms around?
 
@@ -85,16 +88,6 @@ If available, bottled binaries will be used by default except under the followin
 
 We aim to bottle everything.
 
-## How do I get a formula from someone else’s pull request?
-
-```sh
-brew install hub
-brew update
-cd "$(brew --repository homebrew/core)"
-hub fetch github_username
-hub pr checkout pull_request_number
-```
-
 ## Why should I install Homebrew in the default location?
 
 Homebrew's pre-built binary packages (known as [bottles](Bottles.md)) of many formulae can only be used if you install in the default installation prefix, otherwise they have to be built from source. Building from source takes a long time, is prone to failure, and is not supported. The default prefix is:
@@ -137,14 +130,36 @@ If all maintainer feedback has been addressed and all tests are passing, bump it
 
 ## Can I edit formulae myself?
 
-Yes! It’s easy! Just `brew edit <formula>`. You don’t have to submit modifications back to `homebrew/core`, just edit the formula to what you personally need and `brew install <formula>`. As a bonus, `brew update` will merge your changes with upstream so you can still keep the formula up-to-date **with** your personal modifications!
+Yes! It’s easy! If `brew tap` doesn't show `homebrew/core`, set yourself up to edit a local copy:
+
+1. Set `HOMEBREW_NO_INSTALL_FROM_API=1` in your shell environment,
+2. Run `brew tap --force homebrew/core` and wait for the clone to complete, then
+3. Run `brew edit <formula>` to open the formula in `EDITOR`.
+
+You don’t have to submit modifications back to `homebrew/core`, just edit the formula to what you personally need and `brew install <formula>`. As a bonus, `brew update` will merge your changes with upstream so you can still keep the formula up-to-date **with** your personal modifications!
+
+Note that if you are editing a core formula or cask you must set `HOMEBREW_NO_INSTALL_FROM_API=1` before using `brew install` or `brew update` otherwise they will ignore your local changes and default to the API.
+
+To undo all changes you have made to any of Homebrew's repositories, run `brew update-reset`. It will revert to the upstream state on all Homebrew's repositories.
 
 ## Can I make new formulae?
 
-Yes! It’s easy! Just `brew create URL`. Homebrew will then open the formula in `EDITOR` so you can edit it, but it probably already installs; try it: `brew install <formula>`. If you encounter any issues, run the command with the `--debug` switch like so: `brew install --debug <formula>`, which drops you into a debugging shell.
+Yes! It’s easy! If you already have a local copy of `homebrew/core` (see above), just use the [`brew create` command](Manpage.md#create-options-url). Homebrew will then open the formula in `EDITOR` so you can edit it, but it probably already installs; try it: `brew install <formula>`. If you encounter any issues, run the command with the `--debug` switch like so: `brew install --debug <formula>`, which drops you into a debugging shell.
 
 If you want your new formula to be part of `homebrew/core` or want to learn more about writing formulae, then please read the [Formula Cookbook](Formula-Cookbook.md).
 
+## How do I get a formula from someone else’s pull request?
+
+Ensure you have a [local copy of `homebrew/core`](#can-i-edit-formulae-myself), then:
+
+```sh
+brew update
+brew install hub
+cd "$(brew --repository homebrew/core)"
+hub fetch github_username
+hub pr checkout pull_request_number
+```
+
 ## Why was a formula deleted or disabled?
 
 Use `brew log <formula>` to find out! Likely because it had [unresolved issues](Acceptable-Formulae.md) and/or [our analytics](https://formulae.brew.sh/analytics/) indicated it was not widely used.
@@ -169,7 +184,7 @@ You can [modify a tool's build configuration](How-to-Build-Software-Outside-Home
 
 Chances are that certain apps will give you a popup message like this:
 
-<img src="https://i.imgur.com/CnEEATG.png" width="532" alt="Gatekeeper message">
+<img src="assets/img/docs/gatekeeper-unidentified-message.png" width="532" alt="Gatekeeper unidentified developer message">
 
 This is a [security feature from Apple](https://support.apple.com/en-us/HT202491). The single most important thing to know is that **you can allow individual apps to be exempt from this feature.** This allows the app to run while the rest of the system remains under protection.
 
@@ -177,13 +192,13 @@ This is a [security feature from Apple](https://support.apple.com/en-us/HT202491
 
 If you're sure you want to trust the app, you can disable protection for it by right-clicking its icon and choosing *Open*:
 
-<img src="https://i.imgur.com/69xc2WK.png" width="312" alt="Right-click the app and choose Open">
+<img src="assets/img/docs/right-click-choose-open.png" width="312" style="margin-left:60px" alt="Right-click the app and choose Open">
 
 In the resulting dialog, click the *Open* button to have macOS permanently allow the app to run on this Mac. **Don’t do this unless you’re sure you trust the app.**
 
-<img src="https://i.imgur.com/xppa4Qv.png" width="532" alt="Gatekeeper message">
+<img src="assets/img/docs/gatekeeper-unidentified-open.png" width="532" alt="Gatekeeper unidentified developer open prompt">
 
-Alternatively, you may provide the [`--no-quarantine` flag](https://github.com/Homebrew/homebrew-cask/blob/HEAD/USAGE.md#options) at install time to not add this feature to a specific app.
+Alternatively, you may provide the [`--no-quarantine` switch](https://github.com/Homebrew/homebrew-cask/blob/HEAD/USAGE.md#options) at install time to not add this feature to a specific app.
 
 ## Why aren’t some apps included during `brew upgrade`?
 
@@ -191,7 +206,7 @@ After running `brew upgrade`, you may notice some casks you think should be upgr
 
 As you’re likely aware, a lot of macOS software can upgrade itself:
 
-<img src="https://upload.wikimedia.org/wikipedia/commons/c/c0/Sparkle_Test_App_Software_Update.png" width="532" alt="Sparkle update window">
+<img src="assets/img/docs/sparkle-test-app-software-update.png" width="600" alt="Sparkle update window">
 
 That could cause conflicts when used in tandem with Homebrew Cask’s `upgrade` mechanism.
 
@@ -202,7 +217,7 @@ There are a few ideas to fix this problem:
 * Try to prevent the software’s automated updates. It wouldn’t be a universal solution and may cause it to break. Most software on Homebrew Cask is closed-source, so we’d be guessing. This is also why pinning casks to a version isn’t available.
 * Try to extract the installed software’s version and compare it to the cask, deciding what to do at that time. It’d be a complicated solution that would break other parts of our methodology, such as using versions to interpolate `url` values (a definite win for maintainability). This solution also isn’t universal, as many software developers are inconsistent in their versioning schemes (and app bundles are meant to have two version strings) and it doesn’t work for all types of software we support.
 
-So we let software be. Anything installed with Homebrew Cask should behave the same as if it were installed manually. But since we also want to support software that doesn’t self-upgrade, we add [`auto_updates true`](https://github.com/Homebrew/homebrew-cask/blob/62c0495b254845a481dacac6ea7c8005e27a3fb0/Casks/alfred.rb#L10) to casks for software that does, which excludes them from `brew upgrade`.
+So we let software be. Anything installed with Homebrew Cask should behave the same as if it were installed manually. But since we also want to support software that doesn’t self-upgrade, we add [`auto_updates true`](https://github.com/Homebrew/homebrew-cask/blob/aa461148bbb5119af26b82cccf5003e2b4e50d95/Casks/a/alfred.rb#L18) to casks for software that does, which excludes them from `brew upgrade`.
 
 Casks which use [`version :latest`](https://docs.brew.sh/Cask-Cookbook#version-latest) are also excluded, because we have no way to track their installed version. It helps to ask the developers of such software to provide versioned releases (i.e. include the version in the path of the download `url`).
 
@@ -210,8 +225,14 @@ If you still want to force software to be upgraded via Homebrew Cask, you can re
 
     brew upgrade <cask>
 
-Or use the `--greedy` flag:
+Or use the `--greedy` switch:
 
     brew upgrade --greedy
 
 Refer to the `upgrade` section of the [`brew` manual page](Manpage.md) for more details.
+
+## Why do my cask apps lose their Dock position / Launchpad position / permission settings when I run `brew upgrade`?
+
+Homebrew has two possible strategies to update cask apps: uninstalling the old version and reinstalling the new one, or replacing the contents of the app with the new contents. With the uninstall/reinstall strategy, [macOS thinks the app is being deleted without any intent to reinstall it](https://github.com/Homebrew/brew/pull/15138), and so it removes some internal metadata for the old app, including where it appears in the Dock and Launchpad and which permissions it's been granted. The content replacement strategy works around this by treating the upgrade as an in-place upgrade. However, starting in macOS Ventura, these in-place upgrades are only allowed when the updater application (in this case, the terminal running Homebrew) has [certain permissions granted](https://github.com/Homebrew/brew/pull/15483). Either the "App Management" or "Full Disk Access" permission will suffice.
+
+Homebrew defaults to in-place upgrades when it has the necessary permissions. Otherwise, it will use the uninstall/reinstall strategy.
diff --git a/docs/Formula-Cookbook.md b/docs/Formula-Cookbook.md
index 0355953b85563..b62706023446d 100644
--- a/docs/Formula-Cookbook.md
+++ b/docs/Formula-Cookbook.md
@@ -2,31 +2,44 @@
 
 A *formula* is a package definition written in Ruby. It can be created with `brew create <URL>` where `<URL>` is a zip or tarball, installed with `brew install <formula>`, and debugged with `brew install --debug --verbose <formula>`. Formulae use the [Formula API](https://rubydoc.brew.sh/Formula) which provides various Homebrew-specific helpers.
 
+* Table of Contents
+{:toc}
+
 ## Homebrew terminology
 
-| Term           | Description                                                | Example                                                         |
-|----------------|------------------------------------------------------------|-----------------------------------------------------------------|
-| **Formula**    | The package definition                                     | `/usr/local/Homebrew/Library/Taps/homebrew/homebrew-core/Formula/foo.rb` |
-| **Keg**        | The installation prefix of a **Formula**                   | `/usr/local/Cellar/foo/0.1`                                     |
-| **Keg-only**   | A **Formula** is **Keg-only** if it is not linked into the Homebrew prefix | The [`openjdk` formula](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/openjdk.rb) |
-| **opt prefix** | A symlink to the active version of a **Keg**               | `/usr/local/opt/foo `                                           |
-| **Cellar**     | All **Kegs** are installed here                            | `/usr/local/Cellar`                                             |
-| **Tap**        | A Git repository of **Formulae** and/or commands | `/usr/local/Homebrew/Library/Taps/homebrew/homebrew-core`   |
-| **Bottle**     | Pre-built **Keg** used instead of building from source     | `qt-4.8.4.catalina.bottle.tar.gz`                              |
-| **Cask**       | An [extension of Homebrew](https://github.com/Homebrew/homebrew-cask) to install macOS native apps  | `/Applications/MacDown.app/Contents/SharedSupport/bin/macdown` |
-| **Brew Bundle**| An [extension of Homebrew](https://github.com/Homebrew/homebrew-bundle) to describe dependencies    | `brew 'myservice', restart_service: true` |
+| term                 | description                                                               | example |
+| -------------------- | ------------------------------------------------------------------------- | ------- |
+| **formula**          | Homebrew package definition that builds from upstream sources             | `/usr/local/Homebrew/Library/Taps/homebrew/homebrew-core/Formula/f/foo.rb` |
+| **cask**             | Homebrew package definition that installs macOS native applications       | `/usr/local/Homebrew/Library/Taps/homebrew/homebrew-cask/Casks/b/bar.rb` |
+| **prefix**           | path in which Homebrew is installed                                       | `/usr/local` |
+| **keg**              | installation destination directory of a given **formula** version         | `/usr/local/Cellar/foo/0.1` |
+| **rack**             | directory containing one or more versioned **kegs**                       | `/usr/local/Cellar/foo` |
+| **keg-only**         | a **formula** is *keg-only* if it is not symlinked into Homebrew's prefix | the [`openjdk`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/o/openjdk.rb) formula |
+| **opt prefix**       | a symlink to the active version of a **keg**                              | `/usr/local/opt/foo` |
+| **Cellar**           | directory containing one or more named **racks**                          | `/usr/local/Cellar` |
+| **Caskroom**         | directory containing one or more named **casks**                          | `/usr/local/Caskroom` |
+| **external command** | `brew` subcommand defined outside of the Homebrew/brew GitHub repository  | [`brew alias`](https://github.com/Homebrew/homebrew-aliases) |
+| **tap**              | directory (and usually Git repository) of **formulae**, **casks** and/or **external commands**       | `/usr/local/Homebrew/Library/Taps/homebrew/homebrew-core` |
+| **bottle**           | pre-built **keg** poured into a **rack** of the **Cellar** instead of building from upstream sources | `qt--6.5.1.ventura.bottle.tar.gz` |
+| **tab**              | information about a **keg**, e.g. whether it was poured from a **bottle** or built from source       | `/usr/local/Cellar/foo/0.1/INSTALL_RECEIPT.json` |
+| **Brew Bundle**      | an [extension of Homebrew](https://github.com/Homebrew/homebrew-bundle) to describe dependencies     | `brew 'myservice', restart_service: true` |
+| **Brew Services**    | an [extension of Homebrew](https://github.com/Homebrew/homebrew-services) to manage services         | `brew services start myservice` |
 
 ## An introduction
 
-Homebrew uses Git for downloading updates and contributing to the project.
+Homebrew uses Git for storing formulae and contributing to the project.
+
+As of [Homebrew 4.0.0](https://brew.sh/2023/02/16/homebrew-4.0.0/), formulae are downloaded as JSON from <https://formulae.brew.sh> which is automatically regenerated by a scheduled [Homebrew/formulae.brew.sh](https://github.com/Homebrew/formulae.brew.sh) job from the `master` branch of the Homebrew/homebrew-core repository.
 
-Homebrew installs to the `Cellar` and then symlinks some of the installation into `/usr/local` so that other programs can see what's going on. We suggest you `brew ls` a few of the kegs in your Cellar to see how it is all arranged.
+Homebrew installs formulae to the Cellar at `$(brew --cellar)` and then symlinks some of the installation into the prefix at `$(brew --prefix)` (e.g. `/opt/homebrew`) so that other programs can see what's going on. We suggest running `brew ls` on a few of the kegs in your Cellar to see how it is all arranged.
 
-Packages are installed according to their formulae, which live in `/usr/local/Homebrew/Library/Taps/homebrew/homebrew-core/Formula`. Check out a simple one, e.g. `brew edit etl` (or [`etl`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/etl.rb)) or a more advanced one, e.g. `brew edit git` (or [`git`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/git.rb)).
+Packages are installed according to their formulae. Read over a simple one, e.g. `brew edit etl` (or [etl.rb](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/e/etl.rb)) or a more advanced one, e.g. `brew edit git` (or [git.rb](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/g/git.rb)).
 
 ## Basic instructions
 
-Make sure you run `brew update` before you start. This turns your Homebrew installation into a Git repository.
+Make sure you run `brew update` before you start. This ensures your Homebrew installation is a Git repository.
+
+To create or edit formulae locally, you'll need to first [tap `homebrew/core`](https://docs.brew.sh/FAQ#can-i-edit-formulae-myself) if you haven't previously. This clones the Homebrew/homebrew-core Git repository to `$(brew --repository homebrew/core)`. As you're developing, you'll also need to set `HOMEBREW_NO_INSTALL_FROM_API=1` in your shell environment or before any `install`, `reinstall` or `upgrade` commands to force `brew` to use the local repository instead of the API.
 
 Before submitting a new formula make sure your package:
 
@@ -34,8 +47,8 @@ Before submitting a new formula make sure your package:
 * isn't already in Homebrew (check `brew search <formula>`)
 * isn't already waiting to be merged (check the [issue tracker](https://github.com/Homebrew/homebrew-core/pulls))
 * is still supported by upstream (i.e. doesn't require extensive patching)
-* has a stable, tagged version (i.e. not just a GitHub repository with no versions)
-* passes all `brew audit --new-formula <formula>` tests
+* has a stable, tagged version (i.e. isn't just a GitHub repository with no versions)
+* passes all `brew audit --new --formula <formula>` tests
 
 Before submitting a new formula make sure you read over our [contribution guidelines](https://github.com/Homebrew/brew/blob/HEAD/CONTRIBUTING.md#contributing-to-homebrew).
 
@@ -47,38 +60,13 @@ Run `brew create` with a URL to the source tarball:
 brew create https://example.com/foo-0.1.tar.gz
 ```
 
-This creates `/usr/local/Homebrew/Library/Taps/homebrew/homebrew-core/Formula/foo.rb` and opens it in your `EDITOR`. It'll look something like:
-
-```ruby
-class Foo < Formula
-  desc ""
-  homepage ""
-  url "https://example.com/foo-0.1.tar.gz"
-  sha256 "85cc828a96735bdafcf29eb6291ca91bac846579bcef7308536e0c875d6c81d7"
-  license ""
-
-  # depends_on "cmake" => :build
+This creates `$(brew --repository)/Library/Taps/homebrew/homebrew-core/Formula/f/foo.rb` and opens it in your `EDITOR`.
 
-  def install
-    # ENV.deparallelize
-    system "./configure", "--disable-debug",
-                          "--disable-dependency-tracking",
-                          "--disable-silent-rules",
-                          "--prefix=#{prefix}"
-    # system "cmake", ".", *std_cmake_args
-    system "make", "install"
-  end
-
-  test do
-    system "false"
-  end
-end
-```
+Passing in `--ruby` or `--python` will populate various defaults commonly useful for projects written in those languages.
 
 If `brew` said `Warning: Version cannot be determined from URL` when doing the `create` step, you’ll need to explicitly add the correct [`version`](https://rubydoc.brew.sh/Formula#version-class_method) to the formula and then save the formula.
 
-Homebrew will try to guess the formula’s name from its URL. If it fails to do
-so you can override this with `brew create <URL> --set-name <name>`.
+Homebrew will try to guess the formula’s name from its URL. If it fails to do so you can override this with `brew create <URL> --set-name <name>`.
 
 ### Fill in the `homepage`
 
@@ -86,7 +74,7 @@ so you can override this with `brew create <URL> --set-name <name>`.
 
 An SSL/TLS (https) [`homepage`](https://rubydoc.brew.sh/Formula#homepage%3D-class_method) is preferred, if one is available.
 
-Try to summarise from the [`homepage`](https://rubydoc.brew.sh/Formula#homepage%3D-class_method) what the formula does in the [`desc`](https://rubydoc.brew.sh/Formula#desc%3D-class_method)ription. Note that the [`desc`](https://rubydoc.brew.sh/Formula#desc%3D-class_method)ription is automatically prepended with the formula name.
+Try to summarise from the [`homepage`](https://rubydoc.brew.sh/Formula#homepage%3D-class_method) what the formula does in the [`desc`](https://rubydoc.brew.sh/Formula#desc%3D-class_method)ription. Note that the [`desc`](https://rubydoc.brew.sh/Formula#desc%3D-class_method)ription is automatically prepended with the formula name when printed.
 
 ### Fill in the `license`
 
@@ -103,7 +91,7 @@ Check out the [License Guidelines](License-Guidelines.md) for examples of comple
 ### Check the build system
 
 ```sh
-brew install --interactive foo
+HOMEBREW_NO_INSTALL_FROM_API=1 brew install --interactive foo
 ```
 
 You’re now at a new prompt with the tarball extracted to a temporary sandbox.
@@ -126,63 +114,54 @@ There are plenty of others; check `/usr/lib` for them.
 
 We generally try not to duplicate system libraries and complicated tools in core Homebrew but we do duplicate some commonly used tools.
 
-Special exceptions are OpenSSL and LibreSSL. Things that use either *should* be built using Homebrew’s shipped equivalent and our Brew Test Bot's post-install `audit` will warn if it detects you haven't done this.
-
-Homebrew’s OpenSSL is [`keg_only`](https://rubydoc.brew.sh/Formula#keg_only-class_method)
-to avoid conflicting with the system so sometimes formulae need to
-have environment variables set or special configuration flags passed
-to locate our OpenSSL. You can see this mechanism in the
-[`clamav`](https://github.com/Homebrew/homebrew-core/blob/89c4574ef1a6d15e92196637ff315a0a4bb3e289/Formula/clamav.rb#L37)
-formula. Usually this is unnecessary because Homebrew sets up our [build environment](https://github.com/Homebrew/brew/blob/HEAD/Library/Homebrew/extend/ENV/super.rb)
-to favour finding [`keg_only`](https://rubydoc.brew.sh/Formula#keg_only-class_method) formulae first.
+Special exceptions are OpenSSL and LibreSSL. Things that use either *should* be built using Homebrew’s shipped equivalent and our BrewTestBot's post-install `audit` will warn if it detects you haven't done this.
 
-**Important:** `$(brew --prefix)/bin` is NOT on the `PATH` during formula installation. If you have dependencies at build time, you must specify them and `brew` will add them to the `PATH` or create a [`Requirement`](https://rubydoc.brew.sh/Requirement).
+**Important:** `$(brew --prefix)/bin` is NOT in the `PATH` during formula installation. If you have dependencies at build time, you must specify them and `brew` will add them to the `PATH` or create a [`Requirement`](https://rubydoc.brew.sh/Requirement).
 
 ### Specifying other formulae as dependencies
 
 ```ruby
 class Foo < Formula
-  depends_on "pkg-config"
+  # ...
+
+  depends_on "httpd" => [:build, :test]
+  depends_on xcode: ["9.3", :build]
+  depends_on arch: :x86_64
   depends_on "jpeg"
+  depends_on macos: :high_sierra
+  depends_on "pkg-config"
   depends_on "readline" => :recommended
   depends_on "gtk+" => :optional
-  depends_on "httpd" => [:build, :test]
-  depends_on :xcode => "9.3"
+
+  # ...
 end
 ```
 
-A String (e.g. `"jpeg"`) specifies a formula dependency.
+A `String` (e.g. `"jpeg"`) specifies a formula dependency.
+
+A `Symbol` (e.g. `:xcode`) specifies a [`Requirement`](https://rubydoc.brew.sh/Requirement) to restrict installation to systems meeting certain criteria, which can be fulfilled by one or more formulae, casks or other system-wide installed software (e.g. Xcode). Some [`Requirement`](https://rubydoc.brew.sh/Requirement)s can also take a string or symbol specifying their minimum version that the formula depends on.
 
-A Symbol (e.g. `:xcode`) specifies a [`Requirement`](https://rubydoc.brew.sh/Requirement) which can be fulfilled by one or more formulae, casks or other system-wide installed software (e.g. Xcode).
+A `Hash` (e.g. `=>`) adds information to a dependency. Given a string or symbol, the value can be one or more of the following values:
 
-A Hash (e.g. `=>`) adds information to a dependency. Given a String or Symbol, the value can be one or more of the following values:
+* `:build` means this is a build-time only dependency so it can be skipped when installing from a bottle or when listing missing dependencies using `brew missing`.
+* `:test` means this is only required when running `brew test`.
+* `:optional` (not allowed in `Homebrew/homebrew-core`) generates an implicit `with-foo` option for the formula. This means that, given `depends_on "foo" => :optional`, the user must pass `--with-foo` to use the dependency.
+* `:recommended` (not allowed in `Homebrew/homebrew-core`) generates an implicit `without-foo` option, meaning that the dependency is enabled by default and the user must pass `--without-foo` to disable this dependency. The default description can be overridden using the [`option`](https://rubydoc.brew.sh/Formula#option-class_method) syntax (in this case, the [`option` declaration](#adding-optional-steps) must precede the dependency):
 
-* `:build` means that dependency is a build-time only dependency so it can
-be skipped when installing from a bottle or when listing missing
-dependencies using `brew missing`.
-* `:test` means that dependency is only required when running `brew test`.
-* `:optional` generates an implicit `with-foo` option for the formula.
-This means that, given `depends_on "foo" => :optional`, the user must pass `--with-foo` in order to use the dependency.
-* `:recommended` generates an implicit `without-foo` option, meaning that
-the dependency is enabled by default and the user must pass
-`--without-foo` to disable this dependency. The default
-description can be overridden using the normal option syntax (in this case, the option declaration must precede the dependency):
-    ```ruby
-    option "with-foo", "Compile with foo bindings" # This overrides the generated description if you want to
-    depends_on "foo" => :optional # Generated description would otherwise be "Build with foo support"
-    ```
-* Some [`Requirement`](https://rubydoc.brew.sh/Requirement)s can also take a string specifying their minimum version that the formula depends on.
+  ```ruby
+option "with-foo", "Compile with foo bindings" # This overrides the generated description if you want to
+depends_on "foo" => :optional # Generated description would otherwise be "Build with foo support"
+  ```
 
-**Note:** `:optional` and `:recommended` are not allowed in Homebrew/homebrew-core as they are not tested by CI.
+* `"<option-name>"` (not allowed in `Homebrew/homebrew-core`) requires a dependency to have been built with the specified option.
 
 ### Specifying conflicts with other formulae
 
-Sometimes there’s hard conflict between formulae, and it can’t be avoided or circumvented with [`keg_only`](https://rubydoc.brew.sh/Formula#keg_only-class_method).
+Sometimes there’s a hard conflict between formulae that can’t be avoided or circumvented with [`keg_only`](https://rubydoc.brew.sh/Formula#keg_only-class_method).
 
-A good example formula for minor conflict is [`mbedtls`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/mbedtls.rb), which ships and compiles a "Hello World" executable. This is obviously non-essential to `mbedtls`’s functionality, and conflict with the popular GNU [`hello`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/hello.rb) formula would be overkill, so we just [remove it](https://github.com/Homebrew/homebrew-core/blob/966273060ad507fea490bd931971963de8b1a1dc/Formula/mbedtls.rb#L30-L31) during the installation process.
+A good example for minor conflict is the [`mbedtls`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/m/mbedtls.rb) formula, which ships and compiles a "Hello World" executable. This is obviously non-essential to `mbedtls`’s functionality, and as conflict with the popular GNU [`hello`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/h/hello.rb) formula would be overkill, we just [remove it](https://github.com/Homebrew/homebrew-core/blob/442f9cc511ce6dfe75b96b2c83749d90dde914d2/Formula/m/mbedtls.rb#L52-L53) during the installation process.
 
-[`pdftohtml`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/pdftohtml.rb) provides an example of a serious
-conflict, where both formula ship an identically-named binary that is essential to functionality, so a [`conflicts_with`](https://rubydoc.brew.sh/Formula#conflicts_with-class_method) is preferable.
+[`pdftohtml`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/p/pdftohtml.rb) provides an example of a serious conflict, where each listed formula ships an identically named binary that is essential to functionality, so a [`conflicts_with`](https://rubydoc.brew.sh/Formula#conflicts_with-class_method) is preferable.
 
 As a general rule, [`conflicts_with`](https://rubydoc.brew.sh/Formula#conflicts_with-class_method) should be a last-resort option. It’s a fairly blunt instrument.
 
@@ -196,9 +175,9 @@ conflicts_with "blueduck", because: "yellowduck also ships a duck binary"
 
 In Homebrew we sometimes accept formulae updates that don’t include a version bump. These include resource updates, new patches or fixing a security issue with a formula.
 
-Occasionally, these updates require a forced-recompile of the formula itself or its dependents to either ensure formulae continue to function as expected or to close a security issue. This forced-recompile is known as a [`revision`](https://rubydoc.brew.sh/Formula#revision%3D-class_method) and is inserted underneath the [`homepage`](https://rubydoc.brew.sh/Formula#homepage%3D-class_method)/[`url`](https://rubydoc.brew.sh/Formula#url-class_method)/[`sha256`](https://rubydoc.brew.sh/Formula#sha256%3D-class_method) block.
+Occasionally, these updates require a forced-recompile of the formula itself or its dependents to either ensure formulae continue to function as expected or to close a security issue. This forced-recompile is known as a [`revision`](https://rubydoc.brew.sh/Formula#revision%3D-class_method) and is inserted underneath the [`homepage`](https://rubydoc.brew.sh/Formula#homepage%3D-class_method)/[`url`](https://rubydoc.brew.sh/Formula#url-class_method)/[`sha256`](https://rubydoc.brew.sh/Formula#sha256%3D-class_method)/[`license`](https://rubydoc.brew.sh/Formula#license-class_method) block.
 
-When a dependent of a formula fails against a new version of that dependency it must receive a [`revision`](https://rubydoc.brew.sh/Formula#revision%3D-class_method). An example of such failure can be seen [here](https://github.com/Homebrew/legacy-homebrew/issues/31195) and the fix [here](https://github.com/Homebrew/legacy-homebrew/pull/31207).
+When a dependent of a formula fails to build against a new version of that dependency it must receive a [`revision`](https://rubydoc.brew.sh/Formula#revision%3D-class_method). An example of such failure is in [this issue report](https://github.com/Homebrew/legacy-homebrew/issues/31195) and [its fix](https://github.com/Homebrew/legacy-homebrew/pull/31207).
 
 [`revision`](https://rubydoc.brew.sh/Formula#revision%3D-class_method)s are also used for formulae that move from the system OpenSSL to the Homebrew-shipped OpenSSL without any other changes to that formula. This ensures users aren’t left exposed to the potential security issues of the outdated OpenSSL. An example of this can be seen in [this commit](https://github.com/Homebrew/homebrew-core/commit/0d4453a91923e6118983961e18d0609e9828a1a4).
 
@@ -206,13 +185,13 @@ When a dependent of a formula fails against a new version of that dependency it
 
 Sometimes formulae have version schemes that change such that a direct comparison between two versions no longer produces the correct result. For example, a project might be version `13` and then decide to become `1.0.0`. As `13` is translated to `13.0.0` by our versioning system by default this requires intervention.
 
-When a version scheme of a formula fails to recognise a new version as newer it must receive a [`version_scheme`](https://rubydoc.brew.sh/Formula#version_scheme%3D-class_method). An example of this can be seen [here](https://github.com/Homebrew/homebrew-core/pull/4006).
+When a version scheme of a formula fails to recognise a new version as newer it must receive a [`version_scheme`](https://rubydoc.brew.sh/Formula#version_scheme%3D-class_method). An example of this can be seen in [this pull request](https://github.com/Homebrew/homebrew-core/pull/4006).
 
 ### Double-check for dependencies
 
 When you already have a lot of formulae installed, it's easy to miss a common dependency. You can double-check which libraries a binary links to with the `otool` command (perhaps you need to use `xcrun otool`):
 
-```sh
+```console
 $ otool -L /usr/local/bin/ldapvi
 /usr/local/bin/ldapvi:
     /usr/local/opt/openssl/lib/libssl.1.0.0.dylib (compatibility version 1.0.0, current version 1.0.0)
@@ -227,14 +206,68 @@ $ otool -L /usr/local/bin/ldapvi
     /usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1213.0.0)
 ```
 
+### Specifying macOS components as dependencies
+
+If a formula dependency is required on all platforms but can be handled by a component that ships with macOS, specify it with [`uses_from_macos`](https://rubydoc.brew.sh/Formula#uses_from_macos-class_method). On Linux it acts like [`depends_on`](https://rubydoc.brew.sh/Formula#depends_on-class_method), while on macOS it's ignored unless the host system is older than the optional `since:` parameter.
+
+For example, to require the `bzip2` formula on Linux while relying on built-in `bzip2` on macOS:
+
+```ruby
+uses_from_macos "bzip2"
+```
+
+To require the `perl` formula only when building or testing on Linux:
+
+```ruby
+uses_from_macos "perl" => [:build, :test]
+```
+
+To require the `curl` formula on Linux and pre-macOS 12:
+
+```ruby
+uses_from_macos "curl", since: :monterey
+```
+
 ### Specifying gems, Python modules, Go projects, etc. as dependencies
 
 Homebrew doesn’t package already-packaged language-specific libraries. These should be installed directly from `gem`/`cpan`/`pip` etc.
 
-If you're installing an application then use [`resource`](https://rubydoc.brew.sh/Formula#resource-class_method)s for all language-specific dependencies:
+### Ruby Gem Dependencies
+
+The preferred mechanism for installing gem dependencies is to use `bundler` with the upstream's `Gemfile.lock`. This requires the upstream checks in their `Gemfile.lock`, so if they don't, it's a good idea to file an issue and ask them to do so. Assuming they have one, this is as simple as:
+
+```ruby
+ENV["GEM_HOME"] = libexec
+system "bundle", "install", "--without", "development"
+```
+
+From there, you can build and install the project itself:
+
+```ruby
+system "gem", "build", "<project>.gemspec"
+system "gem", "install", "--ignore-dependencies", "<project>-#{version}.gem"
+```
+
+And install any bins, and munge their shebang lines, with:
+
+```ruby
+bin.install libexec/"bin/<bin>"
+bin.env_script_all_files(libexec/"bin", GEM_HOME: ENV.fetch("GEM_HOME", nil))
+```
+
+### Python dependencies
+
+For python we use [`resource`](https://rubydoc.brew.sh/Formula#resource-class_method)s for dependencies and there's automation to generate these for you. Running `brew update-python-resources <formula>` will automatically add the necessary [`resource`](https://rubydoc.brew.sh/Formula#resource-class_method) stanzas for the dependencies of your Python application to the formula. Note that `brew update-python-resources` is run automatically by `brew create` if you pass the `--python` switch. If `brew update-python-resources` is unable to determine the correct `resource` stanzas, [homebrew-pypi-poet](https://github.com/tdsmith/homebrew-pypi-poet) is a good third-party alternative that may help.
+
+### All other cases
+
+If all else fails, you'll want to use [`resource`](https://rubydoc.brew.sh/Formula#resource-class_method)s for all other language-specific dependencies. This requires you to specify both a specific URL for a version and the sha256 checksum for security. Here's an example:
 
 ```ruby
 class Foo < Formula
+  # ...
+  url "https://example.com/foo-1.0.tar.gz"
+
   resource "pycrypto" do
     url "https://files.pythonhosted.org/packages/60/db/645aa9af249f059cc3a368b118de33889219e0362141e75d4eaf6f80f163/pycrypto-2.6.1.tar.gz"
     sha256 "f2ce1e989b272cfcb677616763e0a2e7ec659effa67a88aa92b3a65528f60a3c"
@@ -246,14 +279,12 @@ class Foo < Formula
 end
 ```
 
-[`jrnl`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/jrnl.rb) is an example of a formula that does this well. The end result means the user doesn't have to use `pip` or Python and can just run `jrnl`.
-
-For Python formulae, running `brew update-python-resources <formula>` will automatically add the necessary [`resource`](https://rubydoc.brew.sh/Formula#resource-class_method) stanzas for the dependencies of your Python application to the formula. Note that `brew update-python-resources` is run automatically by `brew create` if you pass the `--python` flag. If `brew update-python-resources` is unable to determine the correct `resource` stanzas, [homebrew-pypi-poet](https://github.com/tdsmith/homebrew-pypi-poet) is a good third-party alternative that may help.
+[`jrnl`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/j/jrnl.rb) is an example of a formula that does this well. The end result means the user doesn't have to use `pip` or Python and can just run `jrnl`.
 
 ### Install the formula
 
 ```sh
-brew install --build-from-source --verbose --debug foo
+HOMEBREW_NO_INSTALL_FROM_API=1 brew install --build-from-source --verbose --debug foo
 ```
 
 `--debug` will ask you to open an interactive shell if the build fails so you can try to figure out what went wrong.
@@ -262,17 +293,15 @@ Check the top of the e.g. `./configure` output. Some configure scripts do not re
 
 ### Add a test to the formula
 
-Add a valid test to the [`test do`](https://rubydoc.brew.sh/Formula#test-class_method) block of the formula. This will be run by `brew test foo` and the [Brew Test Bot](Brew-Test-Bot.md).
+Add a valid test to the [`test do`](https://rubydoc.brew.sh/Formula#test-class_method) block of the formula. This will be run by `brew test foo` and [BrewTestBot](BrewTestBot.md).
 
-The [`test do`](https://rubydoc.brew.sh/Formula#test-class_method) block automatically creates and changes to a temporary directory which
-is deleted after run. You can access this [`Pathname`](https://rubydoc.brew.sh/Pathname) with the [`testpath`](https://rubydoc.brew.sh/Formula#testpath-instance_method)
-function. The environment variable `HOME` is set to [`testpath`](https://rubydoc.brew.sh/Formula#testpath-instance_method) within the [`test do`](https://rubydoc.brew.sh/Formula#test-class_method) block.
+The [`test do`](https://rubydoc.brew.sh/Formula#test-class_method) block automatically creates and changes to a temporary directory which is deleted after run. You can access this [`Pathname`](https://rubydoc.brew.sh/Pathname) with the [`testpath`](https://rubydoc.brew.sh/Formula#testpath-instance_method) function. The environment variable `HOME` is set to [`testpath`](https://rubydoc.brew.sh/Formula#testpath-instance_method) within the [`test do`](https://rubydoc.brew.sh/Formula#test-class_method) block.
 
 We want tests that don't require any user input and test the basic functionality of the application. For example `foo build-foo input.foo` is a good test and (despite their widespread use) `foo --version` and `foo --help` are bad tests. However, a bad test is better than no test at all.
 
-See [`cmake`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/cmake.rb) for an example of a formula with a good test. The formula writes a basic `CMakeLists.txt` file into the test directory then calls CMake to generate Makefiles. This test checks that CMake doesn't e.g. segfault during basic operation.
+See the [`cmake`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/c/cmake.rb) formula for an example of a good test. It writes a basic `CMakeLists.txt` file into the test directory then calls CMake to generate Makefiles. This test checks that CMake doesn't e.g. segfault during basic operation.
 
-You can check that the output is as expected with `assert_equal` or `assert_match` on the output of the [Formula assertions](https://rubydoc.brew.sh/Homebrew/Assertions.html) such as in this example from the [envv formula](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/envv.rb):
+You can check that the output is as expected with `assert_equal` or `assert_match` on the output of the [Formula assertions](https://rubydoc.brew.sh/Homebrew/Assertions) such as in this example from the [`envv`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/e/envv.rb) formula:
 
 ```ruby
 assert_equal "mylist=A:C; export mylist", shell_output("#{bin}/envv del mylist B").strip
@@ -285,20 +314,20 @@ assert_predicate testpath/"output.txt", :exist?
 ```
 
 Some advice for specific cases:
-* If the formula is a library, compile and run some simple code that links against it. It could be taken from upstream's documentation / source examples.
-A good example is [`tinyxml2`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/tinyxml2.rb), which writes a small C++ source file into the test directory, compiles and links it against the tinyxml2 library and finally checks that the resulting program runs successfully.
+
+* If the formula is a library, compile and run some simple code that links against it. It could be taken from upstream's documentation / source examples. A good example is [`tinyxml2`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/t/tinyxml2.rb)'s test, which writes a small C++ source file into the test directory, compiles and links it against the tinyxml2 library and finally checks that the resulting program runs successfully.
 * If the formula is for a GUI program, try to find some function that runs as command-line only, like a format conversion, reading or displaying a config file, etc.
 * If the software cannot function without credentials or requires a virtual machine, docker instance, etc. to run, a test could be to try to connect with invalid credentials (or without credentials) and confirm that it fails as expected. This is preferred over mocking a dependency.
-* Homebrew comes with a number of [standard test fixtures](https://github.com/Homebrew/brew/tree/master/Library/Homebrew/test/support/fixtures), including numerous sample images, sounds, and documents in various formats. You can get the file path to a test fixture with `test_fixtures("test.svg")`.
-* If your test requires a test file that isn't a standard test fixture, you can install it from a source repository during the `test` phase with a resource block, like this:
+* Homebrew comes with a number of [standard test fixtures](https://github.com/Homebrew/brew/tree/master/Library/Homebrew/test/support/fixtures), including numerous sample images, sounds, and documents in various formats. You can get the file path to a test fixture with e.g. `test_fixtures("test.svg")`.
+* If your test requires a test file that isn't a standard test fixture, you can install it from a source repository during the `test` phase with a [`resource`](https://rubydoc.brew.sh/Formula#resource-class_method) block, like this:
 
 ```ruby
-resource("testdata") do
-  url "https://example.com/input.foo"
-  sha256 "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
-end
-
 test do
+  resource "testdata" do
+    url "https://example.com/input.foo"
+    sha256 "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+  end
+
   resource("testdata").stage do
     assert_match "OK", shell_output("#{bin}/foo build-foo input.foo")
   end
@@ -313,15 +342,13 @@ Some software installs to `man` instead of `share/man`, so check the output and
 
 ### Caveats
 
-In case there are specific issues with the Homebrew packaging (compared to how the software is installed from other sources) a `caveats` block can be added to the formula to warn users. This can indicate non-standard install paths, an example from the `ruby` formula:
+In case there are specific issues with the Homebrew packaging (compared to how the software is installed from other sources) a `caveats` block can be added to the formula to warn users. This can indicate non-standard install paths, like this example from the [`ruby`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/r/ruby.rb) formula:
 
-```
-==> Caveats
-By default, binaries installed by gem will be placed into:
-  /usr/local/lib/ruby/gems/bin
+    ==> Caveats
+    By default, binaries installed by gem will be placed into:
+      /usr/local/lib/ruby/gems/bin
 
-You may want to add this to your PATH.
-```
+    You may want to add this to your PATH.
 
 ### A quick word on naming
 
@@ -333,7 +360,7 @@ If you’re not sure about the name, check its homepage, Wikipedia page and [wha
 
 When Homebrew already has a formula called `foo` we typically do not accept requests to replace that formula with something else also named `foo`. This is to avoid both confusing and surprising users’ expectations.
 
-When two formulae share an upstream name, e.g. [AESCrypt](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/aescrypt.rb) and [AES Crypt](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/aescrypt-packetizer.rb) the newer formula must typically adapt its name to avoid conflict with the current formula.
+When two formulae share an upstream name, e.g. [AESCrypt](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/a/aescrypt.rb) and [AES Crypt](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/a/aescrypt-packetizer.rb) the newer formula must typically adapt its name to avoid conflict with the current formula.
 
 If you’re *still* not sure, just commit. We’ll apply some arbitrary rule and make a decision 😉.
 
@@ -348,24 +375,23 @@ Add aliases by creating symlinks in an `Aliases` directory in the tap root.
 
 ### Audit the formula
 
-You can run `brew audit --strict --online` to test formulae for adherence to Homebrew house style. The `audit` command includes warnings for trailing whitespace, preferred URLs for certain source hosts, and a lot of other style issues. Fixing these warnings before committing will make the process a lot quicker for everyone.
+You can run `brew audit --strict --online` to test formulae for adherence to Homebrew house style, which is loosely based on the [Ruby Style Guide](https://github.com/rubocop-hq/ruby-style-guide#the-ruby-style-guide). The `audit` command includes warnings for trailing whitespace, preferred URLs for certain source hosts, and many other style issues. Fixing these warnings before committing will make the process a lot quicker for everyone.
 
-New formulae being submitted to Homebrew should run `brew audit --new-formula foo`. This command is performed by the Brew Test Bot on new submissions as part of the automated build and test process, and highlights more potential issues than the standard audit.
+New formulae being submitted to Homebrew should run `brew audit --new --formula foo`. This command is performed by BrewTestBot on new submissions as part of the automated build and test process, and highlights more potential issues than the standard audit.
 
-Use `brew info` and check if the version guessed by Homebrew from the URL is
-correct. Add an explicit [`version`](https://rubydoc.brew.sh/Formula#version-class_method) if not.
+Use `brew info` and check if the version guessed by Homebrew from the URL is correct. Add an explicit [`version`](https://rubydoc.brew.sh/Formula#version-class_method) if not.
 
 ### Commit
 
 Everything is built on Git, so contribution is easy:
 
 ```sh
-brew update # required in more ways than you think (initialises the brew git repository if you don't already have it)
+brew update # required in more ways than you think (initialises the Homebrew/brew Git repository if you don't already have it)
 cd "$(brew --repository homebrew/core)"
 # Create a new git branch for your formula so your pull request is easy to
 # modify if any changes come up during review.
 git checkout -b <some-descriptive-name> origin/master
-git add Formula/foo.rb
+git add Formula/f/foo.rb
 git commit
 ```
 
@@ -375,10 +401,11 @@ The established standard for Git commit messages is:
 * two (2) newlines, then
 * explain the commit thoroughly.
 
-At Homebrew, we like to put the name of the formula up front like so: `foobar 7.3 (new formula)`.
-This may seem crazy short, but you’ll find that forcing yourself to summarise the commit encourages you to be atomic and concise. If you can’t summarise it in 50-80 characters, you’re probably trying to commit two commits as one. For a more thorough explanation, please read Tim Pope’s excellent blog post, [A Note About Git Commit Messages](https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
+At Homebrew, we require the name of the formula up front like so: `foobar 7.3 (new formula)`.
 
-The preferred commit message format for simple version updates is `foobar 7.3` and for fixes is `foobar: fix flibble matrix.`.
+This may seem crazy short, but you’ll find that forcing yourself to summarise the commit encourages you to be atomic and concise. If you can’t summarise it in 50 to 80 characters, you’re probably trying to commit two commits as one. For a more thorough explanation, please read Tim Pope’s excellent blog post, [A Note About Git Commit Messages](https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
+
+The required commit message format for simple version updates is `foobar 7.3` and for fixes is `foobar: fix flibble matrix.`. Please squash your commits into one with this message format, otherwise your PR will be replaced by our autosquash workflow.
 
 Ensure you reference any relevant GitHub issue, e.g. `Closes #12345` in the commit message. Homebrew’s history is the first thing future contributors will look to when trying to understand the current state of formulae they’re interested in.
 
@@ -386,12 +413,12 @@ Ensure you reference any relevant GitHub issue, e.g. `Closes #12345` in the comm
 
 Now you just need to push your commit to GitHub.
 
-If you haven’t forked Homebrew yet, [go to the `homebrew-core` repository and hit the Fork button](https://github.com/Homebrew/homebrew-core).
+If you haven’t forked Homebrew yet, [go to the Homebrew/homebrew-core repository and hit the Fork button](https://github.com/Homebrew/homebrew-core).
 
 If you have already forked Homebrew on GitHub, then you can manually push (just make sure you have been pulling from the `Homebrew/homebrew-core` master):
 
 ```sh
-git push https://github.com/myname/homebrew-core/ <what-you-called-your-branch>
+git push https://github.com/myname/homebrew-core/ <what-you-named-your-branch>
 ```
 
 Now, [open a pull request](https://docs.brew.sh/How-To-Open-a-Homebrew-Pull-Request) for your changes.
@@ -419,6 +446,94 @@ if build.head?
 end
 ```
 
+### Standard arguments
+
+For any formula using certain well-known build systems, there will be arguments that should be passed during compilation so that the build conforms to Homebrew standards. These have been collected into a set of `std_*_args` methods.
+
+Most of these methods accept parameters to customize their output. For example, to set the install prefix to [**`libexec`**](#variables-for-directory-locations) for `configure` or `cmake`:
+
+```ruby
+system "./configure", *std_configure_args(prefix: libexec)
+system "cmake", "-S", ".", "-B", "build", *std_cmake_args(install_prefix: libexec)
+```
+
+The `std_*_args` methods, as well as the arguments they pass, are:
+
+#### `std_cabal_v2_args`
+
+```ruby
+"--jobs=#{ENV.make_jobs}"
+"--max-backjumps=100000"
+"--install-method=copy"
+"--installdir=#{bin}"
+```
+
+#### `std_cargo_args`
+
+```ruby
+"--locked"
+"--root=#{root}"
+"--path=#{path}"
+```
+
+#### `std_cmake_args`
+
+```ruby
+"-DCMAKE_INSTALL_PREFIX=#{install_prefix}"
+"-DCMAKE_INSTALL_LIBDIR=#{install_libdir}"
+"-DCMAKE_BUILD_TYPE=Release"
+"-DCMAKE_FIND_FRAMEWORK=#{find_framework}"
+"-DCMAKE_VERBOSE_MAKEFILE=ON"
+"-DCMAKE_PROJECT_TOP_LEVEL_INCLUDES=#{HOMEBREW_LIBRARY_PATH}/cmake/trap_fetchcontent_provider.cmake"
+"-Wno-dev"
+"-DBUILD_TESTING=OFF"
+```
+
+#### `std_configure_args`
+
+```ruby
+"--disable-debug"
+"--disable-dependency-tracking"
+"--prefix=#{prefix}"
+"--libdir=#{libdir}"
+```
+
+#### `std_go_args`
+
+```ruby
+"-trimpath"
+"-o=#{output}"
+```
+
+#### `std_meson_args`
+
+```ruby
+"--prefix=#{prefix}"
+"--libdir=#{lib}"
+"--buildtype=release"
+"--wrap-mode=nofallback"
+```
+
+#### `std_npm_args`
+
+```ruby
+"-ddd"
+"--global"
+"--build-from-source"
+"--cache=$(brew --cache)/npm_cache"
+"--prefix=#{libexec}"
+```
+
+#### `std_pip_args`
+
+```ruby
+"--verbose"
+"--no-deps"
+"--no-binary=:all:"
+"--ignore-installed"
+"--no-compile"
+```
+
 ### `bin.install "foo"`
 
 You’ll see stuff like this in some formulae. This moves the file `foo` into the formula’s `bin` directory (`/usr/local/Cellar/pkg/0.1/bin`) and makes it executable (`chmod 0555 foo`).
@@ -450,7 +565,7 @@ Make sure you modify `s`! This block ignores the returned value.
 
 [`inreplace`](https://rubydoc.brew.sh/Utils/Inreplace) should be used instead of patches when patching something that will never be accepted upstream, e.g. making the software’s build system respect Homebrew’s installation hierarchy. If it's something that affects both Homebrew and MacPorts (i.e. macOS specific) it should be turned into an upstream submitted patch instead.
 
-If you need modify variables in a `Makefile`, rather than using [`inreplace`](https://rubydoc.brew.sh/Utils/Inreplace), pass them as arguments to `make`:
+If you need to modify variables in a `Makefile`, rather than using [`change_make_var!`](https://rubydoc.brew.sh/StringInreplaceExtension.html#change_make_var!-instance_method) within an [`inreplace`](https://rubydoc.brew.sh/Utils/Inreplace), try passing them as arguments to `make`:
 
 ```ruby
 system "make", "target", "VAR2=value1", "VAR2=value2", "VAR3=values can have spaces"
@@ -466,7 +581,7 @@ Note that values *can* contain unescaped spaces if you use the multiple-argument
 
 While [`patch`](https://rubydoc.brew.sh/Formula#patch-class_method)es should generally be avoided, sometimes they are temporarily necessary.
 
-When [`patch`](https://rubydoc.brew.sh/Formula#patch-class_method)ing (i.e. fixing header file inclusion, fixing compiler warnings, etc.) the first thing to do is check whether or not the upstream project is aware of the issue. If not, file a bug report and/or submit your patch for inclusion. We may sometimes still accept your patch before it was submitted upstream but by getting the ball rolling on fixing the upstream issue you reduce the length of time we have to carry the patch around.
+When [`patch`](https://rubydoc.brew.sh/Formula#patch-class_method)ing (i.e. fixing header file inclusion, fixing compiler warnings, etc.) the first thing to do is check whether the upstream project is aware of the issue. If not, file a bug report and/or submit your patch for inclusion. We may sometimes still accept your patch before it was submitted upstream but by getting the ball rolling on fixing the upstream issue you reduce the length of time we have to carry the patch around.
 
 *Always justify a [`patch`](https://rubydoc.brew.sh/Formula#patch-class_method) with a code comment!* Otherwise, nobody will know when it is safe to remove the patch, or safe to leave it in when updating the formula. The comment should include a link to the relevant upstream issue(s).
 
@@ -492,7 +607,7 @@ end
 
 ```ruby
 stable do
-  # some other things...
+  # ...
 
   patch do
     url "https://example.com/example_patch.diff"
@@ -510,15 +625,13 @@ patch :p0, :DATA
 
 with the patch data included at the end of the file:
 
-```
-__END__
-diff --git a/foo/showfigfonts b/foo/showfigfonts
-index 643c60b..543379c 100644
---- a/foo/showfigfonts
-+++ b/foo/showfigfonts
-@@ -14,6 +14,7 @@
-…
-```
+    __END__
+    diff --git a/foo/showfigfonts b/foo/showfigfonts
+    index 643c60b..543379c 100644
+    --- a/foo/showfigfonts
+    +++ b/foo/showfigfonts
+    @@ -14,6 +14,7 @@
+    …
 
 Patches can also be embedded by passing a string. This makes it possible to provide multiple embedded patches while making only some of them conditional.
 
@@ -528,21 +641,70 @@ patch :p0, "..."
 
 In embedded patches, the string "HOMEBREW\_PREFIX" is replaced with the value of the constant `HOMEBREW_PREFIX` before the patch is applied.
 
+In external patches, the string "@@HOMEBREW\_PREFIX@@" is replaced with the value of the constant `HOMEBREW_PREFIX` before the patch is applied.
+
 ### Creating the diff
 
 ```sh
-brew install --interactive --git foo
+HOMEBREW_NO_INSTALL_FROM_API=1 brew install --interactive --git foo
 # (make some edits)
 git diff | pbcopy
 brew edit foo
 ```
 
 Now just paste into the formula after `__END__`.
-Instead of `git diff | pbcopy`, for some editors `git diff >> path/to/your/formula/foo.rb` might help you ensure that the patch is not touched, e.g. white space removal, indentation changes, etc.
+
+Instead of `git diff | pbcopy`, for some editors `git diff >> path/to/your/formula/foo.rb` might help you ensure that the patch is not altered, e.g. whitespace removal, indentation changes, etc.
 
 ## Advanced formula tricks
 
-If anything isn’t clear, you can usually figure it out by `grep`ping the `$(brew --repository homebrew/core)` directory. Please submit a pull request to amend this document if you think it will help!
+See the [Formula API](https://rubydoc.brew.sh/Formula) for the full list of methods available within a formula. If anything isn’t clear, you can usually figure it out by `grep`ping the `$(brew --repository homebrew/core)` directory for examples. Please submit a pull request to amend this document if you think it will help!
+
+### Handling different system configurations
+
+Often, formulae need different dependencies, resources, patches, conflicts, deprecations or `keg_only` statuses on different OSes and architectures. In these cases, the components can be nested inside `on_macos`, `on_linux`, `on_arm` or `on_intel` blocks. For example, here's how to add `gcc` as a Linux-only dependency:
+
+```ruby
+on_linux do
+  depends_on "gcc"
+end
+```
+
+Components can also be declared for specific macOS versions or version ranges. For example, to declare a dependency only on High Sierra, nest the `depends_on` call inside an `on_high_sierra` block. Add an `:or_older` or `:or_newer` parameter to the `on_high_sierra` method to add the dependency to all macOS versions that meet the condition. For example, to add `gettext` as a build dependency on Mojave and all later macOS versions, use:
+
+```ruby
+on_mojave :or_newer do
+  depends_on "gettext" => :build
+end
+```
+
+Sometimes, a dependency is needed on certain macOS versions *and* on Linux. In these cases, a special `on_system` method can be used:
+
+```ruby
+on_system :linux, macos: :sierra_or_older do
+  depends_on "gettext" => :build
+end
+```
+
+To check multiple conditions, nest the corresponding blocks. For example, the following code adds a `gettext` build dependency when on ARM *and* macOS:
+
+```ruby
+on_macos do
+  on_arm do
+    depends_on "gettext" => :build
+  end
+end
+```
+
+#### Inside `def install` and `test do`
+
+Inside `def install` and `test do`, don't use these `on_*` methods. Instead, use `if` statements and the following conditionals:
+
+* `OS.mac?` and `OS.linux?` return `true` or `false` based on the OS
+* `Hardware::CPU.intel?` and `Hardware::CPU.arm?` return `true` or `false` based on the arch
+* `MacOS.version` returns the current macOS version. Use `==`, `<=` or `>=` to compare to symbols corresponding to macOS versions (e.g. `if MacOS.version >= :mojave`)
+
+See the [`icoutils`](https://github.com/Homebrew/homebrew-core/blob/442f9cc511ce6dfe75b96b2c83749d90dde914d2/Formula/i/icoutils.rb#L36) formula for an example.
 
 ### `livecheck` blocks
 
@@ -555,77 +717,75 @@ livecheck do
 end
 ```
 
-For `url`/`regex` guidelines and additional `livecheck` block examples, refer to the [`brew livecheck` documentation](Brew-Livecheck.md). For more technical information on the methods used in a `livecheck` block, please refer to the [`Livecheck` class documentation](https://rubydoc.brew.sh/Livecheck.html).
+For `url`/`regex` guidelines and additional `livecheck` block examples, refer to the [`brew livecheck` documentation](Brew-Livecheck.md). For more technical information on the methods used in a `livecheck` block, please refer to the [`Livecheck` class documentation](https://rubydoc.brew.sh/Livecheck).
 
 ### Unstable versions (`head`)
 
-Formulae can specify an alternate download for the upstream project’s [`head`](https://rubydoc.brew.sh/Formula#head-class_method) (`master`/`trunk`).
-
-#### `head`
-
-[`head`](https://rubydoc.brew.sh/Formula#head-class_method) URLs (activated by passing `--HEAD`) build the development cutting edge. Specifying it is easy:
+Formulae can specify an alternate download for the upstream project’s development cutting-edge source (e.g. `master`/`main`/`trunk`) using [`head`](https://rubydoc.brew.sh/Formula#head-class_method), which can be activated by passing `--HEAD` when installing. Specifying it is done in the same manner as [`url`](https://rubydoc.brew.sh/Formula#url-class_method):
 
 ```ruby
 class Foo < Formula
-  head "https://github.com/mxcl/lastfm-cocoa.git"
+  # ...
+  head "https://github.com/some/package.git", branch: "main" # the default is "master"
 end
 ```
 
-Homebrew understands `git`, `svn`, and `hg` URLs, and has a way to specify `cvs` repositories as a URL as well. You can test whether the [`head`](https://rubydoc.brew.sh/Formula#head-class_method) is being built with `build.head?`.
-
-To use a specific commit, tag, or branch from a repository, specify [`head`](https://rubydoc.brew.sh/Formula#head-class_method) with the `:tag` and `:revision`, `:revision`, or `:branch` option, like so:
+You can also bundle the URL and any `head`-specific dependencies and resources in a `head do` block.
 
 ```ruby
 class Foo < Formula
-  head "https://github.com/some/package.git", revision: "090930930295adslfknsdfsdaffnasd13"
-                                         # or branch: "main" (the default is "master")
-                                         # or tag: "1_0_release", revision: "090930930295adslfknsdfsdaffnasd13"
+  # ...
+
+  head do
+    url "https://svn.code.sf.net/p/project/code/trunk"
+    depends_on "pkg-config" => :build
+  end
 end
 ```
 
-### Compiler selection
+You can test whether the [`head`](https://rubydoc.brew.sh/Formula#head-class_method) is being built with `build.head?` in the `install` method.
 
-Sometimes a package fails to build when using a certain compiler. Since recent [Xcode versions](Xcode.md) no longer include a GCC compiler we cannot simply force the use of GCC. Instead, the correct way to declare this is the [`fails_with`](https://rubydoc.brew.sh/Formula#fails_with-class_method) DSL method. A properly constructed [`fails_with`](https://rubydoc.brew.sh/Formula#fails_with-class_method) block documents the latest compiler build version known to cause compilation to fail, and the cause of the failure. For example:
+### URL download strategies
+
+When parsing a download URL, Homebrew auto-detects the resource type it points to, whether archive (e.g. tarball, zip) or version control repository (e.g. Git, SVN, Mercurial) and chooses an appropriate download strategy. Some strategies can be passed additional options to alter what's downloaded. For example, to use a specific commit, tag, or branch from a repository, specify [`url`](https://rubydoc.brew.sh/Formula#url-class_method) or [`head`](https://rubydoc.brew.sh/Formula#head-class_method) with the `:tag` and `:revision`, `:revision`, or `:branch` options, like so:
 
 ```ruby
-fails_with :clang do
-  build 211
-  cause "Miscompilation resulting in segfault on queries"
+class Foo < Formula
+  # ...
+  url "https://github.com/some/package.git",
+      tag:      "v1.6.2",
+      revision: "344cd2ee3463abab4c16ac0f9529a846314932a2"
 end
 ```
 
-`build` takes a Fixnum (an integer; you can find this number in your `brew --config` output). `cause` takes a String, and the use of heredocs is encouraged to improve readability and allow for more comprehensive documentation.
-
-[`fails_with`](https://rubydoc.brew.sh/Formula#fails_with-class_method) declarations can be used with any of `:gcc`, `:llvm`, and `:clang`. Homebrew will use this information to select a working compiler (if one is available).
-
-### Specifying the download strategy explicitly
-
-To use one of Homebrew’s built-in download strategies, specify the `:using =>` flag on a [`url`](https://rubydoc.brew.sh/Formula#url-class_method) or [`head`](https://rubydoc.brew.sh/Formula#head-class_method). For example:
+If not inferable, specify which of Homebrew’s built-in download strategies to use with the `using:` option. For example:
 
 ```ruby
-class Python3 < Formula
-  homepage "https://www.python.org/"
-  url "https://www.python.org/ftp/python/3.4.3/Python-3.4.3.tar.xz"
-  sha256 "b5b3963533768d5fc325a4d7a6bd6f666726002d696f1d399ec06b043ea996b8"
-  head "https://hg.python.org/cpython", :using => :hg
+class Nginx < Formula
+  desc "HTTP(S) server and reverse proxy, and IMAP/POP3 proxy server"
+  homepage "https://nginx.org/"
+  url "https://nginx.org/download/nginx-1.23.2.tar.gz", using: :homebrew_curl
+  sha256 "a80cc272d3d72aaee70aa8b517b4862a635c0256790434dbfc4d618a999b0b46"
+  head "https://hg.nginx.org/nginx/", using: :hg
+end
 ```
 
-Homebrew offers anonymous download strategies.
+Homebrew offers these anonymous download strategies.
 
-| `:using` value | download strategy             |
-|----------------|-------------------------------|
-| `:bzr`         | `BazaarDownloadStrategy`      |
-| `:curl`        | `CurlDownloadStrategy`        |
-| `:cvs`         | `CVSDownloadStrategy`         |
-| `:fossil`      | `FossilDownloadStrategy`      |
-| `:git`         | `GitDownloadStrategy`         |
-| `:hg`          | `MercurialDownloadStrategy`   |
-| `:nounzip`     | `NoUnzipCurlDownloadStrategy` |
-| `:post`        | `CurlPostDownloadStrategy`    |
-| `:svn`         | `SubversionDownloadStrategy`  |
-|----------------|-------------------------------|
+| `:using` value   | download strategy             |
+| ---------------- | ----------------------------- |
+| `:bzr`           | `BazaarDownloadStrategy` |
+| `:curl`          | `CurlDownloadStrategy` |
+| `:cvs`           | `CVSDownloadStrategy` |
+| `:fossil`        | `FossilDownloadStrategy` |
+| `:git`           | `GitDownloadStrategy` |
+| `:hg`            | `MercurialDownloadStrategy` |
+| `:homebrew_curl` | `HomebrewCurlDownloadStrategy` |
+| `:nounzip`       | `NoUnzipCurlDownloadStrategy` |
+| `:post`          | `CurlPostDownloadStrategy` |
+| `:svn`           | `SubversionDownloadStrategy` |
 
-If you need more control over the way files are downloaded and staged, you can create a custom download strategy and specify it using the [`url`](https://rubydoc.brew.sh/Formula#url-class_method) method's `:using` option:
+If you need more control over the way files are downloaded and staged, you can create a custom download strategy and specify it with the `:using` option:
 
 ```ruby
 class MyDownloadStrategy < SomeHomebrewDownloadStrategy
@@ -637,15 +797,41 @@ class MyDownloadStrategy < SomeHomebrewDownloadStrategy
 end
 
 class Foo < Formula
-  url "something", :using => MyDownloadStrategy
+  url "something", using: MyDownloadStrategy
 end
 ```
 
-### Just moving some files
+### Compiler selection
+
+Sometimes a package fails to build when using a certain compiler. Since recent [Xcode versions](Xcode.md) no longer include a GCC compiler we cannot simply force the use of GCC. Instead, the correct way to declare this is with the [`fails_with`](https://rubydoc.brew.sh/Formula#fails_with-class_method) DSL method. A properly constructed [`fails_with`](https://rubydoc.brew.sh/Formula#fails_with-class_method) block documents the latest compiler build version known to cause compilation to fail, and the cause of the failure. For example:
 
-When your code in the install function is run, the current working directory is set to the extracted tarball.
+```ruby
+fails_with :clang do
+  build 211
+  cause "Miscompilation resulting in segfault on queries"
+end
+
+fails_with :gcc do
+  version "5" # fails with GCC 5.x and earlier
+  cause "Requires C++17 support"
+end
+
+fails_with gcc: "7" do
+  version "7.1" # fails with GCC 7.0 and 7.1 but not 7.2, or any other major GCC version
+  cause <<-EOS
+    warning: dereferencing type-punned pointer will break strict-aliasing rules
+    Fixed in GCC 7.2, see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=42136
+  EOS
+end
+```
 
-So it is easy to just move some files:
+For `:clang`, `build` takes an integer (you can find this number in your `brew --config` output), while `:gcc` uses either just `version` which takes a string to indicate the last problematic GCC version, or a major version argument combined with `version` to single out a range of specific GCC releases. `cause` takes a string, and the use of heredocs is encouraged to improve readability and allow for more comprehensive documentation.
+
+[`fails_with`](https://rubydoc.brew.sh/Formula#fails_with-class_method) declarations can be used with any of `:gcc`, `:llvm`, and `:clang`. Homebrew will use this information to select a working compiler (if one is available).
+
+### Just moving some files
+
+When your code in the install function is run, the current working directory is set to the extracted tarball. This makes it easy to just move some files:
 
 ```ruby
 prefix.install "file1", "file2"
@@ -657,46 +843,52 @@ Or everything:
 prefix.install Dir["output/*"]
 ```
 
-Generally we'd rather you were specific about what files or directories need to be installed rather than installing everything.
+Or just the tarball's top-level files like README, LICENSE etc.:
+
+```ruby
+prefix.install_metafiles
+```
+
+Generally we'd rather you were specific about which files or directories need to be installed rather than installing everything.
 
 #### Variables for directory locations
 
-| Name                  | Default                                        | Example                                                     |
-|-----------------------|------------------------------------------------|-------------------------------------------------------------|
-| **`HOMEBREW_PREFIX`** | `/usr/local`                                   |                                                             |
-| **`prefix`**          | `#{HOMEBREW_PREFIX}/Cellar/#{name}/#{version}` | `/usr/local/Cellar/foo/0.1`                                 |
-| **`opt_prefix`**      | `#{HOMEBREW_PREFIX}/opt/#{name}`               | `/usr/local/opt/foo`                                        |
-| **`bin`**             | `#{prefix}/bin`                                | `/usr/local/Cellar/foo/0.1/bin`                             |
-| **`doc`**             | `#{prefix}/share/doc/#{name}`                  | `/usr/local/Cellar/foo/0.1/share/doc/foo`                   |
-| **`include`**         | `#{prefix}/include`                            | `/usr/local/Cellar/foo/0.1/include`                         |
-| **`info`**            | `#{prefix}/share/info`                         | `/usr/local/Cellar/foo/0.1/share/info`                      |
-| **`lib`**             | `#{prefix}/lib`                                | `/usr/local/Cellar/foo/0.1/lib`                             |
-| **`libexec`**         | `#{prefix}/libexec`                            | `/usr/local/Cellar/foo/0.1/libexec`                         |
-| **`man`**             | `#{prefix}/share/man`                          | `/usr/local/Cellar/foo/0.1/share/man`                       |
-| **`man[1-8]`**        | `#{prefix}/share/man/man[1-8]`                 | `/usr/local/Cellar/foo/0.1/share/man/man[1-8]`              |
-| **`sbin`**            | `#{prefix}/sbin`                               | `/usr/local/Cellar/foo/0.1/sbin`                            |
-| **`share`**           | `#{prefix}/share`                              | `/usr/local/Cellar/foo/0.1/share`                           |
-| **`pkgshare`**        | `#{prefix}/share/#{name}`                      | `/usr/local/Cellar/foo/0.1/share/foo`                       |
-| **`elisp`**           | `#{prefix}/share/emacs/site-lisp/#{name}`      | `/usr/local/Cellar/foo/0.1/share/emacs/site-lisp/foo`       |
-| **`frameworks`**      | `#{prefix}/Frameworks`                         | `/usr/local/Cellar/foo/0.1/Frameworks`                      |
-| **`kext_prefix`**     | `#{prefix}/Library/Extensions`                 | `/usr/local/Cellar/foo/0.1/Library/Extensions`              |
-| **`zsh_function`**    | `#{prefix}/share/zsh/site-functions`           | `/usr/local/Cellar/foo/0.1/share/zsh/site-functions`        |
-| **`fish_function`**   | `#{prefix}/share/fish/vendor_functions`        | `/usr/local/Cellar/foo/0.1/share/fish/vendor_functions`     |
-| **`bash_completion`** | `#{prefix}/etc/bash_completion.d`              | `/usr/local/Cellar/foo/0.1/etc/bash_completion.d`           |
-| **`zsh_completion`**  | `#{prefix}/share/zsh/site-functions`           | `/usr/local/Cellar/foo/0.1/share/zsh/site-functions`        |
+| name                  | default path                                   | example |
+| --------------------- | ---------------------------------------------- | ------- |
+| **`HOMEBREW_PREFIX`** | output of `$(brew --prefix)`                   | `/usr/local` |
+| **`prefix`**          | `#{HOMEBREW_PREFIX}/Cellar/#{name}/#{version}` | `/usr/local/Cellar/foo/0.1` |
+| **`opt_prefix`**      | `#{HOMEBREW_PREFIX}/opt/#{name}`               | `/usr/local/opt/foo` |
+| **`bin`**             | `#{prefix}/bin`                                | `/usr/local/Cellar/foo/0.1/bin` |
+| **`doc`**             | `#{prefix}/share/doc/#{name}`                  | `/usr/local/Cellar/foo/0.1/share/doc/foo` |
+| **`include`**         | `#{prefix}/include`                            | `/usr/local/Cellar/foo/0.1/include` |
+| **`info`**            | `#{prefix}/share/info`                         | `/usr/local/Cellar/foo/0.1/share/info` |
+| **`lib`**             | `#{prefix}/lib`                                | `/usr/local/Cellar/foo/0.1/lib` |
+| **`libexec`**         | `#{prefix}/libexec`                            | `/usr/local/Cellar/foo/0.1/libexec` |
+| **`man`**             | `#{prefix}/share/man`                          | `/usr/local/Cellar/foo/0.1/share/man` |
+| **`man[1-8]`**        | `#{prefix}/share/man/man[1-8]`                 | `/usr/local/Cellar/foo/0.1/share/man/man[1-8]` |
+| **`sbin`**            | `#{prefix}/sbin`                               | `/usr/local/Cellar/foo/0.1/sbin` |
+| **`share`**           | `#{prefix}/share`                              | `/usr/local/Cellar/foo/0.1/share` |
+| **`pkgshare`**        | `#{prefix}/share/#{name}`                      | `/usr/local/Cellar/foo/0.1/share/foo` |
+| **`elisp`**           | `#{prefix}/share/emacs/site-lisp/#{name}`      | `/usr/local/Cellar/foo/0.1/share/emacs/site-lisp/foo` |
+| **`frameworks`**      | `#{prefix}/Frameworks`                         | `/usr/local/Cellar/foo/0.1/Frameworks` |
+| **`kext_prefix`**     | `#{prefix}/Library/Extensions`                 | `/usr/local/Cellar/foo/0.1/Library/Extensions` |
+| **`zsh_function`**    | `#{prefix}/share/zsh/site-functions`           | `/usr/local/Cellar/foo/0.1/share/zsh/site-functions` |
+| **`fish_function`**   | `#{prefix}/share/fish/vendor_functions`        | `/usr/local/Cellar/foo/0.1/share/fish/vendor_functions` |
+| **`bash_completion`** | `#{prefix}/etc/bash_completion.d`              | `/usr/local/Cellar/foo/0.1/etc/bash_completion.d` |
+| **`zsh_completion`**  | `#{prefix}/share/zsh/site-functions`           | `/usr/local/Cellar/foo/0.1/share/zsh/site-functions` |
 | **`fish_completion`** | `#{prefix}/share/fish/vendor_completions.d`    | `/usr/local/Cellar/foo/0.1/share/fish/vendor_completions.d` |
-| **`etc`**             | `#{HOMEBREW_PREFIX}/etc`                       | `/usr/local/etc`                                            |
-| **`pkgetc`**          | `#{HOMEBREW_PREFIX}/etc/#{name}`               | `/usr/local/etc/foo`                                        |
-| **`var`**             | `#{HOMEBREW_PREFIX}/var`                       | `/usr/local/var`                                            |
-| **`buildpath`**       | A temporary directory somewhere on your system | `/private/tmp/[formula-name]-0q2b/[formula-name]`           |
+| **`etc`**             | `#{HOMEBREW_PREFIX}/etc`                       | `/usr/local/etc` |
+| **`pkgetc`**          | `#{HOMEBREW_PREFIX}/etc/#{name}`               | `/usr/local/etc/foo` |
+| **`var`**             | `#{HOMEBREW_PREFIX}/var`                       | `/usr/local/var` |
+| **`buildpath`**       | temporary directory somewhere on your system | `/private/tmp/[formula-name]-0q2b/[formula-name]` |
 
-These can be used, for instance, in code such as
+These can be used, for instance, in code such as:
 
 ```ruby
 bin.install Dir["output/*"]
 ```
 
-to move binaries into their correct location into the Cellar, and
+to move binaries into their correct location within the Cellar, and:
 
 ```ruby
 man.mkpath
@@ -708,6 +900,56 @@ To install man pages into specific locations, use `man1.install "foo.1", "bar.1"
 
 Note that in the context of Homebrew, [`libexec`](https://rubydoc.brew.sh/Formula#libexec-instance_method) is reserved for private use by the formula and therefore is not symlinked into `HOMEBREW_PREFIX`.
 
+### File-level operations
+
+You can use the file utilities provided by Ruby's [`FileUtils`](https://ruby-doc.org/stdlib-2.7.0/libdoc/fileutils/rdoc/FileUtils.html). These are included in the [`Formula`](https://rubydoc.brew.sh/Formula) class, so you do not need the `FileUtils.` prefix to use them.
+
+When creating symlinks, take special care to ensure they are *relative* symlinks. This makes it easier to create a relocatable bottle. For example, to create a symlink in `bin` to an executable in `libexec`, use:
+
+```ruby
+bin.install_symlink libexec/"name"
+```
+
+instead of:
+
+```ruby
+ln_s libexec/"name", bin
+```
+
+The symlinks created by [`install_symlink`](https://rubydoc.brew.sh/Pathname#install_symlink-instance_method) are guaranteed to be relative. `ln_s` will only produce a relative symlink when given a relative path.
+
+Several other utilities for Ruby's [`Pathname`](https://rubydoc.brew.sh/Pathname) can simplify some common operations.
+
+* To perform several operations within a directory, enclose them within a  [`cd <path> do`](https://rubydoc.brew.sh/Pathname#cd-instance_method) block:
+
+  ```ruby
+cd "src" do
+  system "./configure", "--disable-debug", "--prefix=#{prefix}"
+  system "make", "install"
+end
+  ```
+
+* To surface one or more binaries buried in `libexec` or a macOS `.app` package, use [`write_exec_script`](https://rubydoc.brew.sh/Pathname#write_exec_script-instance_method) or [`write_jar_script`](https://rubydoc.brew.sh/Pathname#write_jar_script-instance_method):
+
+  ```ruby
+bin.write_exec_script (libexec/"bin").children
+bin.write_exec_script prefix/"Package.app/Contents/MacOS/package"
+bin.write_jar_script libexec/jar_file, "jarfile", java_version: "11"
+  ```
+
+* For binaries that require setting one or more environment variables to function properly, use [`write_env_script`](https://rubydoc.brew.sh/Pathname#write_env_script-instance_method) or [`env_script_all_files`](https://rubydoc.brew.sh/Pathname#env_script_all_files-instance_method):
+
+  ```ruby
+(bin/"package").write_env_script libexec/"package", PACKAGE_ROOT: libexec
+bin.env_script_all_files(libexec/"bin", PERL5LIB: ENV.fetch("PERL5LIB", nil))
+  ```
+
+### Rewriting a script shebang
+
+Some formulae install executable scripts written in an interpreted language such as Python or Perl. Homebrew provides a `rewrite_shebang` method to rewrite the shebang of a script. This replaces a script's original interpreter path with the one the formula depends on. This guarantees that the correct interpreter is used at execution time. This isn't required if the build system already handles it (e.g. often with `pip` or Perl `ExtUtils::MakeMaker`).
+
+For example, the [`icdiff`](https://github.com/Homebrew/homebrew-core/blob/bc311e91f3a77889e568dec8d3063c3a6cb2965a/Formula/i/icdiff.rb#L18) formula uses this utility. Note that it is necessary to include the utility in the formula; for example with Python one must use `include Language::Python::Shebang`.
+
 ### Adding optional steps
 
 **Note:** [`option`](https://rubydoc.brew.sh/Formula#option-class_method)s are not allowed in Homebrew/homebrew-core as they are not tested by CI.
@@ -716,12 +958,17 @@ If you want to add an [`option`](https://rubydoc.brew.sh/Formula#option-class_me
 
 ```ruby
 class Yourformula < Formula
-  ...
+  # ...
+  url "https://example.com/yourformula-1.0.tar.gz"
+  sha256 "abc123abc123abc123abc123abc123abc123abc123abc123abc123abc123abc1"
+  # ...
   option "with-ham", "Description of the option"
   option "without-spam", "Another description"
 
-  depends_on "foo" => :optional  # will automatically add a with-foo option
-  ...
+  depends_on "bar" => :recommended
+  depends_on "foo" => :optional # automatically adds a with-foo option # automatically adds a without-bar option
+  # ...
+end
 ```
 
 And then to define the effects the [`option`](https://rubydoc.brew.sh/Formula#option-class_method)s have:
@@ -736,33 +983,28 @@ if build.without? "ham"
 end
 ```
 
-[`option`](https://rubydoc.brew.sh/Formula#option-class_method) names should be prefixed with the words `with` or `without`. For example, an option to run a test suite should be named `--with-test` or `--with-check` rather than `--test`, and an option to enable a shared library `--with-shared` rather than `--shared` or `--enable-shared`.
+[`option`](https://rubydoc.brew.sh/Formula#option-class_method) names should be prefixed with the words `with` or `without`. For example, an option to run a test suite should be named `--with-test` or `--with-check` rather than `--test`, and an option to enable a shared library `--with-shared` rather than `--shared` or `--enable-shared`. See the [alternative `ffmpeg`](https://github.com/homebrew-ffmpeg/homebrew-ffmpeg/blob/HEAD/Formula/ffmpeg.rb) formula for examples.
 
-[`option`](https://rubydoc.brew.sh/Formula#option-class_method)s that aren’t `build.with? ` or `build.without?` should be deprecated with [`deprecated_option`](https://rubydoc.brew.sh/Formula#deprecated_option-class_method). See [`wget`](https://github.com/Homebrew/homebrew-core/blob/3f762b63c6fbbd49191ffdf58574d7e18937d93f/Formula/wget.rb#L27-L31) for an example.
+[`option`](https://rubydoc.brew.sh/Formula#option-class_method)s that aren’t `build.with?` or `build.without?` should be deprecated with [`deprecated_option`](https://rubydoc.brew.sh/Formula#deprecated_option-class_method). See the [`wget`](https://github.com/Homebrew/homebrew-core/blob/3f762b63c6fbbd49191ffdf58574d7e18937d93f/Formula/wget.rb#L27-L31) formula for a historical example.
 
-### File level operations
+### Running commands after installation
 
-You can use the file utilities provided by Ruby's [`FileUtils`](https://www.ruby-doc.org/stdlib/libdoc/fileutils/rdoc/index.html). These are included in the [`Formula`](https://rubydoc.brew.sh/Formula) class, so you do not need the `FileUtils.` prefix to use them.
-
-When creating symlinks, take special care to ensure they are *relative* symlinks. This makes it easier to create a relocatable bottle. For example, to create a symlink in `bin` to an executable in `libexec`, use
+Any initialization steps that aren't necessarily part of the install process can be located in a `post_install` block, such as setup commands or data directory creation. This block can be re-run separately with `brew postinstall <formula>`.
 
 ```ruby
-bin.install_symlink libexec/"name"
-```
-
-instead of:
+class Foo < Formula
+  # ...
+  url "https://example.com/foo-1.0.tar.gz"
 
-```ruby
-ln_s libexec/"name", bin
+  def post_install
+    rm pkgetc/"cert.pem" if File.exist?(pkgetc/"cert.pem")
+    pkgetc.install_symlink Formula["ca-certificates"].pkgetc/"cert.pem"
+  end
+  # ...
+end
 ```
 
-The symlinks created by [`install_symlink`](https://rubydoc.brew.sh/Pathname#install_symlink-instance_method) are guaranteed to be relative. `ln_s` will only produce a relative symlink when given a relative path.
-
-### Rewriting a script shebang
-
-Some formulae install executable scripts written in an interpreted language such as Python or Perl. Homebrew provides a `rewrite_shebang` method to rewrite the shebang of a script. This replaces a script's original interpreter path with the one the formula depends on. This guarantees that the correct interpreter is used at execution time. This isn't required if the build system already handles it (e.g. often with `pip` or Perl `ExtUtils::MakeMaker`).
-
-For example, the [`icdiff` formula](https://github.com/Homebrew/homebrew-core/blob/7beae5ab57c65249403699b2b0700fbccf14e6cb/Formula/icdiff.rb#L16) uses such utility. Note that it is necessary to include the utility in the formula, for example with Python one must use `include Language::Python::Shebang`.
+In the above example, the [`libressl`](https://github.com/Homebrew/homebrew-core/blob/442f9cc511ce6dfe75b96b2c83749d90dde914d2/Formula/lib/libressl.rb#L53-L56) formula replaces its stock list of certificates with a symlink to that of the `ca-certificates` formula.
 
 ### Handling files that should persist over formula upgrades
 
@@ -772,183 +1014,232 @@ Another example would be configuration files that should not be overwritten on p
 
 ### Service files
 
-There are two ways to add plists and systemd services to a formula, so that [`brew services`](https://github.com/Homebrew/homebrew-services) can pick it up:
-1. If the formula already provides a file the formula can install it into the prefix like so.
+There are two ways to add `launchd` plists and `systemd` services to a formula, so that [`brew services`](https://github.com/Homebrew/homebrew-services) can pick them up:
 
-```ruby
-prefix.install_symlink "file.plist" => "#{plist_name}.plist"
-prefix.install_symlink "file.service" => "#{service_name}.service"
-```
+1. If the package already provides a service file the formula can reference it by name:
 
-2. If the formula does not provide a service you can generate one using the following stanza.
-```rb
+   ```ruby
 service do
-  run bin/"script"
+  name macos: "custom.launchd.name",
+       linux: "custom.systemd.name"
+end
+   ```
+
+   To find the file we append `.plist` to the `launchd` service name and `.service` to the `systemd` service name internally.
+
+2. If the formula does not provide a service file you can generate one using the following stanza:
+
+   ```ruby
+   # 1. An individual command
+service do
+  run opt_bin/"script"
+end
+
+   # 2. A command with arguments
+service do
+  run [opt_bin/"script", "--config", etc/"dir/config.yml"]
 end
-```
+
+   # 3. OS specific commands (If you omit one, the service file won't get generated for that OS.)
+service do
+  run macos: [opt_bin/"macos_script", "standalone"],
+      linux: var/"special_linux_script"
+end
+   ```
 
 #### Service block methods
-There are many more options you can set within such a block, and in this table you will find them all.
-The only required field in a `service` block is the `run` field to indicate what to run.
-
-| Method                  | Default      | macOS | Linux | Description                                                                              |
-|-------------------------|--------------|-------|-------|------------------------------------------------------------------------------------------|
-| `run`                   | -            |  yes  |  yes  | Command to execute, an array with arguments or a path                                    |
-| `run_type`              | `:immediate` |  yes  |  yes  | The type of service, `:immediate`, `:interval` or `:cron`                                |
-| `keep_alive`            | `false`      |  yes  |  yes  | If the service needs to keep the process running after exit                              |
-| `interval`              | -            |  yes  |  yes  | Controls the start interval, required for the `:interval` type                           |
-| `cron`                  | -            |  yes  |  yes  | Controls the trigger times, required for the `:cron` type                                |
-| `launch_only_once`      | false        |  yes  |  yes  | If the command should only run once                                                      |
-| `environment_variables` | -            |  yes  |  yes  | A hash of variables to set                                                               |
-| `working_dir`           | -            |  yes  |  yes  | The directory to operate from                                                            |
-| `root_dir`              | -            |  yes  |  yes  | The directory to use as a chroot for the process                                         |
-| `input_path`            | -            |  yes  |  yes  | Path to use as input for the process                                                     |
-| `log_path`              | -            |  yes  |  yes  | Path to write stdout to                                                                  |
-| `error_log_path`        | -            |  yes  |  yes  | Path to write stderr to                                                                  |
-| `restart_delay`         | -            |  yes  |  yes  | The delay before restarting a process                                                    |
-| `process_type`          | -            |  yes  | no-op | The type of process to manage, `:background`, `:standard`, `:interactive` or `:adaptive` |
-| `macos_legacy_timers`   | -            |  yes  | no-op | Timers created by launchd jobs are coalesced unless this is set                          |
-| `sockets`               | -            |  yes  | no-op | A socket that is created as an accesspoint to the service                                |
-
-For services that start and keep running alive you can use the default `run_type :` like so:
-```ruby
-  service do
-    run [opt_bin/"beanstalkd", "test"]
-    keep_alive true
-    run_type :immediate # This should be omitted since it's the default
-  end
+
+This table lists the options you can set within a `service` block. The `run` or `name` field must be defined inside the service block. If `name` is defined without `run`, then Homebrew makes no attempt to change the package-provided service file according these fields. The `run` field indicates what command to run, instructs Homebrew to create a service description file using options set in the block, and therefore is required before using fields other than `name` and `require_root`.
+
+| method                  | default      | macOS | Linux | description |
+| ----------------------- | ------------ | :---: | :---: | ----------- |
+| `run`                   | -            |  yes  |  yes  | command to execute: an array with arguments or a path |
+| `run_type`              | `:immediate` |  yes  |  yes  | type of service: `:immediate`, `:interval` or `:cron` |
+| `interval`              | -            |  yes  |  yes  | controls the start interval, required for the `:interval` type |
+| `cron`                  | -            |  yes  |  yes  | controls the trigger times, required for the `:cron` type |
+| `keep_alive`            | `false`      |  yes  |  yes  | [sets contexts](#keep_alive-options) in which the service will keep the process running |
+| `launch_only_once`      | `false`      |  yes  |  yes  | whether the command should only run once |
+| `require_root`          | `false`      |  yes  |  yes  | whether the service requires root access. If true, Homebrew hints at using `sudo` on various occasions, but does not enforce it |
+| `environment_variables` | -            |  yes  |  yes  | hash of variables to set |
+| `working_dir`           | -            |  yes  |  yes  | directory to operate from |
+| `root_dir`              | -            |  yes  |  yes  | directory to use as a chroot for the process |
+| `input_path`            | -            |  yes  |  yes  | path to use as input for the process |
+| `log_path`              | -            |  yes  |  yes  | path to write `stdout` to |
+| `error_log_path`        | -            |  yes  |  yes  | path to write `stderr` to |
+| `restart_delay`         | -            |  yes  |  yes  | number of seconds to delay before restarting a process |
+| `process_type`          | -            |  yes  | no-op | type of process to manage: `:background`, `:standard`, `:interactive` or `:adaptive` |
+| `macos_legacy_timers`   | -            |  yes  | no-op | timers created by `launchd` jobs are coalesced unless this is set |
+| `sockets`               | -            |  yes  | no-op | socket that is created as an accesspoint to the service |
+| `name`                  | -            |  yes  |  yes  | a hash with the `launchd` service name on macOS and/or the `systemd` service name on Linux. Homebrew generates a default name for the service file if this is not present |
+
+For services that are kept alive after starting you can use the default `run_type`:
+
+```ruby
+service do
+  run [opt_bin/"beanstalkd", "test"]
+  keep_alive true
+  run_type :immediate # This should be omitted since it's the default
+end
 ```
 
 If a service needs to run on an interval, use `run_type :interval` and specify an interval:
+
 ```ruby
-  service do
-    run [opt_bin/"beanstalkd", "test"]
-    run_type :interval
-    interval 500
-  end
+service do
+  run [opt_bin/"beanstalkd", "test"]
+  run_type :interval
+  interval 500
+end
 ```
 
 If a service needs to run at certain times, use `run_type :cron` and specify a time with the crontab syntax:
+
 ```ruby
-  service do
-    run [opt_bin/"beanstalkd", "test"]
-    run_type :cron
-    cron "5 * * * *"
-  end
+service do
+  run [opt_bin/"beanstalkd", "test"]
+  run_type :cron
+  cron "5 * * * *"
+end
 ```
 
-For environment variables you can specify a hash. For the path there is the helper method `std_service_path_env`.
-This method will set the path to `#{HOMEBREW_PREFIX}/bin:#{HOMEBREW_PREFIX}/sbin:/usr/bin:/bin:/usr/sbin:/sbin` so the service can find other `brew` commands.
-```rb
-  service do
-    run opt_bin/"beanstalkd"
-    environment_variables PATH: std_service_path_env
-  end
+Environment variables can be set with a hash. For the `PATH` there is the helper method `std_service_path_env` which returns `#{HOMEBREW_PREFIX}/bin:#{HOMEBREW_PREFIX}/sbin:/usr/bin:/bin:/usr/sbin:/sbin` so the service can find other `brew`-installed commands.
+
+```ruby
+service do
+  run opt_bin/"beanstalkd"
+  environment_variables PATH: std_service_path_env
+end
 ```
 
-#### KeepAlive options
-The standard options, keep alive regardless of any status or circomstances
-```rb
-  service do
-    run [opt_bin/"beanstalkd", "test"]
-    keep_alive true # or false
-  end
+#### `keep_alive` options
+
+The standard options keep the service alive regardless of any status or circumstances:
+
+```ruby
+service do
+  run [opt_bin/"beanstalkd", "test"]
+  keep_alive true # or false
+end
 ```
 
-Same as above in hash form
-```rb
-  service do
-    run [opt_bin/"beanstalkd", "test"]
-    keep_alive { always: true }
-  end
+Same as above in hash form:
+
+```ruby
+service do
+  run [opt_bin/"beanstalkd", "test"]
+  keep_alive always: true
+end
 ```
 
-Keep alive until the job exits with a non-zero return code
-```rb
-  service do
-    run [opt_bin/"beanstalkd", "test"]
-    keep_alive { succesful_exit: true }
-  end
+Keep alive until the service exits with a non-zero return code:
+
+```ruby
+service do
+  run [opt_bin/"beanstalkd", "test"]
+  keep_alive successful_exit: true
+end
 ```
 
-Keep alive only if the job crashed
-```rb
-  service do
-    run [opt_bin/"beanstalkd", "test"]
-    keep_alive { crashed: true }
-  end
+Keep alive only if the job crashed:
+
+```ruby
+service do
+  run [opt_bin/"beanstalkd", "test"]
+  keep_alive crashed: true
+end
 ```
 
-Keep alive as long as a file exists
-```rb
-  service do
-    run [opt_bin/"beanstalkd", "test"]
-    keep_alive { path: "/some/path" }
-  end
+Keep alive as long as a file exists:
+
+```ruby
+service do
+  run [opt_bin/"beanstalkd", "test"]
+  keep_alive path: "/some/path"
+end
 ```
 
-#### Socket format
-The sockets method accepts a formatted socket definition as `<type>://<host>:<port>`.
-- `type`: `udp` or `tcp`
-- `host`: The host to run the socket on. For example `0.0.0.0`
-- `port`: The port the socket should listen on.
+#### `sockets` format
+
+The `sockets` method accepts a formatted socket definition as `<type>://<host>:<port>`.
+
+* `type`: `udp` or `tcp`
+* `host`: host to run the socket on, e.g. `0.0.0.0`
+* `port`: port number the socket should listen on
 
 Please note that sockets will be accessible on IPv4 and IPv6 addresses by default.
 
-### Using environment variables
+If you only need one socket and you don't care about the name (the default is `listeners`):
 
-Homebrew has multiple levels of environment variable filtering which affects variables available to formulae.
+```rb
+service do
+  run [opt_bin/"beanstalkd", "test"]
+  sockets "tcp://127.0.0.1:80"
+end
+```
+
+If you need multiple sockets and/or you want to specify the name:
+
+```rb
+service do
+  run [opt_bin/"beanstalkd", "test"]
+  sockets http: "tcp://0.0.0.0:80", https: "tcp://0.0.0.0:443"
+end
+```
 
-Firstly, the overall environment in which Homebrew runs is filtered to avoid environment contamination breaking from-source builds (<https://github.com/Homebrew/brew/issues/932>). In particular, this process filters all but the given whitelisted variables, but allows environment variables prefixed with `HOMEBREW_`. The specific implementation can be seen in [`bin/brew`](https://github.com/Homebrew/brew/blob/HEAD/bin/brew).
+### Using environment variables
 
-The second level of filtering removes sensitive environment variables (such as credentials like keys, passwords or tokens) to avoid malicious subprocesses obtaining them (<https://github.com/Homebrew/brew/pull/2524>). This has the effect of preventing any such variables from reaching a formula's Ruby code as they are filtered before it is called. The specific implementation can be seen in the [`ENV.clear_sensitive_environment!` method](https://github.com/Homebrew/brew/blob/HEAD/Library/Homebrew/extend/ENV.rb).
+Homebrew has multiple levels of environment variable filtering which affects which variables are available to formulae.
 
-You can set environment variables in a formula's `install` method using `ENV["VARIABLE_NAME"] = "VALUE"`. An example can be seen in [the `gh` formula](https://github.com/Homebrew/homebrew-core/blob/fd9ad29f8e3ca9476f838ebb13794ddb7dafba00/Formula/gh.rb#L22). Environment variables can also be set temporarily using the `with_env` method; any variables defined in the call to that method will be restored to their original values at the end of the block. An example can be seen in [the `csound` formula](https://github.com/Homebrew/homebrew-core/blob/c3feaff8cdb578331385676620c865796cfc3388/Formula/csound.rb#L155-L157).
+Firstly, the overall [environment in which Homebrew runs is filtered](https://github.com/Homebrew/brew/issues/932) to avoid environment contamination breaking from-source builds. In particular, this process filters all but a select list of variables, plus allowing any prefixed with `HOMEBREW_`. The specific implementation is found in [`bin/brew`](https://github.com/Homebrew/brew/blob/HEAD/bin/brew).
 
-In summary, environment variables used by a formula need to conform to these filtering rules in order to be available.
+The second level of filtering [removes sensitive environment variables](https://github.com/Homebrew/brew/pull/2524) (such as credentials like keys, passwords or tokens) to prevent malicious subprocesses from obtaining them. This has the effect of preventing any such variables from reaching a formula's Ruby code since they are filtered before it is called. The specific implementation is found in the [`ENV.clear_sensitive_environment!` method](https://github.com/Homebrew/brew/blob/HEAD/Library/Homebrew/extend/ENV.rb).
 
-### Deprecating and disabling a formula
+In summary, any environment variables intended for use by a formula need to conform to these filtering rules in order to be available.
 
-See our [Deprecating, Disabling, and Removing Formulae](Deprecating-Disabling-and-Removing-Formulae.md) documentation for more information about how and when to deprecate or disable a formula.
+#### Setting environment variables during installation
 
-## Updating formulae
+You can set environment variables in a formula's `install` or `test` blocks using `ENV["VARIABLE_NAME"] = "VALUE"`. An example can be seen in the [`csound`](https://github.com/Homebrew/homebrew-core/blob/442f9cc511ce6dfe75b96b2c83749d90dde914d2/Formula/c/csound.rb#L96) formula.
 
-Eventually a new version of the software will be released. In this case you should update the [`url`](https://rubydoc.brew.sh/Formula#url-class_method) and [`sha256`](https://rubydoc.brew.sh/Formula#sha256%3D-class_method). You can use:
+Environment variables can also be set temporarily using the `with_env` method; any variables defined in the call to that method will be restored to their original values at the end of the block. An example can be seen in the [`gh`](https://github.com/Homebrew/homebrew-core/blob/1fd795861004bdf8bc5f6687c58b76c674794d40/Formula/g/gh.rb#L28-L33) formula.
 
-```sh
-brew bump-formula-pr foo
-```
+There are also `ENV` helper methods available for many common environment variable setting and retrieval operations, such as:
 
-If a [`revision`](https://rubydoc.brew.sh/Formula#revision%3D-class_method) line exists outside any `bottle do` block it should be removed.
+* `ENV.cxx11` - compile with C++11 features enabled
+* `ENV.deparallelize` - compile with only one job at a time; pass a block to have it only influence specific install steps
+* `ENV.O0`, `ENV.O1`, `ENV.O3` - set a specific compiler optimization level (*default:* macOS: `-Os`, Linux: `-O2`)
+* `ENV.runtime_cpu_detection` - account for formulae that detect CPU features at runtime
+* `ENV.append_to_cflags` - add a value to `CFLAGS` `CXXFLAGS` `OBJCFLAGS` `OBJCXXFLAGS` all at once
+* `ENV.prepend_create_path` - create and prepend a path to an existing list of paths
+* `ENV.remove` - remove a string from an environment variable value
+* `ENV.delete` - unset an environment variable
 
-Leave the `bottle do ... end`  block as-is; our CI system will update it when we pull your change.
+The full list can be found in the [SharedEnvExtension](https://rubydoc.brew.sh/SharedEnvExtension.html) and [Superenv](https://rubydoc.brew.sh/Superenv.html) module documentation.
 
-Check if the formula you are updating is a dependency for any other formulae by running `brew uses <formula>`. If it is a dependency, run `brew reinstall` for all the dependencies after it is installed and verify they work correctly.
+### Deprecating and disabling a formula
 
-## Style guide
+See our [Deprecating, Disabling and Removing Formulae](Deprecating-Disabling-and-Removing-Formulae.md) documentation for more information about how and when to deprecate or disable a formula.
 
-Homebrew wants to maintain a consistent Ruby style across all formulae mostly based on [Ruby Style Guide](https://github.com/rubocop-hq/ruby-style-guide#the-ruby-style-guide). Other formulae may not have been updated to match this guide yet but all new ones should. Also:
+## Updating formulae
 
-* The order of methods in a formula should be consistent with other formulae (e.g.: `def install` goes before `def post_install`).
-* An empty line is required before the `__END__` line.
+When a new version of the software is released, use `brew bump-formula-pr` to automatically update the [`url`](https://rubydoc.brew.sh/Formula#url-class_method) and [`sha256`](https://rubydoc.brew.sh/Formula#sha256%3D-class_method), remove any [`revision`](https://rubydoc.brew.sh/Formula#revision%3D-class_method) lines, and submit a pull request. See our [How to Open a Homebrew Pull Request](How-To-Open-a-Homebrew-Pull-Request.md) documentation for more information.
 
-## Troubleshooting for people writing new formulae
+## Troubleshooting for new formulae
 
-### Version detection fails
+### Version detection failures
 
 Homebrew tries to automatically determine the [`version`](https://rubydoc.brew.sh/Formula#version-class_method) from the [`url`](https://rubydoc.brew.sh/Formula#url-class_method) to avoid duplication. If the tarball has an unusual name you may need to manually assign the [`version`](https://rubydoc.brew.sh/Formula#version-class_method).
 
 ### Bad makefiles
 
-Not all projects have makefiles that will run in parallel so try to deparallelize by adding these lines to the `install` method:
+If a project's makefile will not run in parallel, try to deparallelize by adding these lines to the formula's `install` method:
 
 ```ruby
 ENV.deparallelize
-system "make"  # separate make and make install steps
+system "make" # separate compilation and installation steps
 system "make", "install"
 ```
 
-If that fixes it, please open an [issue](https://github.com/Homebrew/homebrew-core/issues) so that we can fix it for everyone.
+If that fixes it, please open an issue with the upstream project so that we can fix it for everyone.
 
 ### Still won’t work?
 
@@ -959,25 +1250,27 @@ brew search --macports foo
 brew search --fink foo
 ```
 
-## Superenv notes
+### Superenv notes
 
 `superenv` is our "super environment" that isolates builds by removing `/usr/local/bin` and all user `PATH`s that are not essential for the build. It does this because user `PATH`s are often full of stuff that breaks builds. `superenv` also removes bad flags from the commands passed to `clang`/`gcc` and injects others (for example all [`keg_only`](https://rubydoc.brew.sh/Formula#keg_only-class_method) dependencies are added to the `-I` and `-L` flags).
 
-## Fortran
+If in your local Homebrew build of your new formula, you see `Operation not permitted` errors, this will be because your new formula tried to write to the disk outside of your sandbox area. This is enforced on macOS by `sandbox-exec`.
+
+### Fortran
 
 Some software requires a Fortran compiler. This can be declared by adding `depends_on "gcc"` to a formula.
 
-## MPI
+### MPI
 
-Formula requiring MPI should use [OpenMPI](https://www.open-mpi.org/) by adding `depends_on "open-mpi"` to the formula, rather than [MPICH](https://www.mpich.org/). These packages have conflicts and provide the same standardised interfaces. Choosing a default implementation and requiring it to be adopted allows software to link against multiple libraries that rely on MPI without creating un-anticipated incompatibilities due to differing MPI runtimes.
+Packages requiring MPI should use [OpenMPI](https://www.open-mpi.org/) by adding `depends_on "open-mpi"` to the formula, rather than [MPICH](https://www.mpich.org/). These packages have conflicts and provide the same standardised interfaces. Choosing a default implementation and requiring its adoption allows software to link against multiple libraries that rely on MPI without creating unanticipated incompatibilities due to differing MPI runtimes.
 
-## Linear algebra libraries
+### Linear algebra libraries
 
-By default packages that require BLAS/LAPACK linear algebra interfaces should link to [OpenBLAS](https://www.openblas.net/) using `depends_on "openblas"` and passing `-DBLA_VENDOR=OpenBLAS` to CMake (applies to CMake based formula only) rather than Apple's Accelerate framework, or the default reference lapack implementation. Apple's implementation of BLAS/LAPACK is outdated and may introduce hard-to-debug problems. The reference `lapack` formula is fine, although it is not actively maintained or tuned. For this reason, formulae needing BLAS/LAPACK should link with OpenBLAS.
+Packages requiring BLAS/LAPACK linear algebra interfaces should link to [OpenBLAS](https://www.openblas.net/) by adding `depends_on "openblas"` and (if built with CMake) passing `-DBLA_VENDOR=OpenBLAS` to CMake, rather than Apple's Accelerate framework or the default reference `lapack` implementation. Apple's implementation of BLAS/LAPACK is outdated and may introduce hard-to-debug problems. The reference `lapack` formula is fine, although it is not actively maintained or tuned.
 
 ## How to start over (reset to upstream `master`)
 
-Have you created a real mess in Git which stops you from creating a commit you want to submit to us? You might want to consider starting again from scratch. Your changes can be reset to the Homebrew `master` branch by running:
+Have you created a real mess in Git which stops you from creating a commit you want to submit to us? You might want to consider starting again from scratch. Your changes to the Homebrew `master` branch can be reset by running:
 
 ```sh
 git checkout -f master
diff --git a/docs/Gemfile b/docs/Gemfile
index 50368eba3401a..12ef85fa9750c 100644
--- a/docs/Gemfile
+++ b/docs/Gemfile
@@ -1,9 +1,14 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
+ruby file: ".ruby-version"
+
 gem "github-pages", group: :jekyll_plugins
 
 group :test do
   gem "html-proofer"
   gem "mdl"
   gem "rake"
+  gem "webrick"
 end
diff --git a/docs/Gems,-Eggs-and-Perl-Modules.md b/docs/Gems,-Eggs-and-Perl-Modules.md
index c187f90b73083..9cfdf852ec865 100644
--- a/docs/Gems,-Eggs-and-Perl-Modules.md
+++ b/docs/Gems,-Eggs-and-Perl-Modules.md
@@ -1,14 +1,13 @@
 # Gems, Eggs and Perl Modules
 
-On a fresh macOS installation there are three empty directories for
+On a fresh macOS installation there are two empty directories for
 add-ons available to all users:
 
 * `/Library/Ruby`
-* `/Library/Python`
 * `/Library/Perl`
 
-You need sudo to install to these like so: `sudo gem install`,
-`sudo easy_install` or `sudo cpan -i`.
+You need sudo to install to these like so: `sudo gem install`
+or `sudo cpan -i`.
 
 ## Python packages (eggs) without sudo using system Python
 
@@ -60,7 +59,7 @@ which therefore don’t need sudo.
 
 _This is only recommended if you **don't** use rbenv or RVM._
 
-Brewed Ruby installs executables to `$(brew --prefix)/opt/ruby/bin`
+Brewed Ruby installs executables to `$(brew --prefix ruby)/bin`
 without sudo. You should add this to your path. See the caveats in the
 `ruby` formula for up-to-date information.
 
@@ -91,7 +90,7 @@ Just install everything into the Homebrew prefix like this:
 echo "export GEM_HOME=\"$(brew --prefix)\"" >> ~/.bashrc
 ```
 
-### It doesn’t work! I get some “permissions” error when I try to install stuff!
+### It doesn’t work! I get some “permissions” error when I try to install stuff
 
 _Note that you may not want to do this, since Apple has decided it
 is not a good default._
@@ -129,7 +128,7 @@ subdirectories will be in your `PATH` and `PERL5LIB`.
 
 ### Avoiding sudo altogether for Perl
 
-If you don’t even want (or can’t) use sudo for bootstrapping
+If you don’t even want to (or can’t) use sudo for bootstrapping
 `local::lib`, just manually install `local::lib` in
 `~/perl5` and add the relevant path to `PERL5LIB` before the `.bashrc` eval incantation.
 
diff --git a/docs/Homebrew-Governance-Archives.md b/docs/Homebrew-Governance-Archives.md
index ccf040b826cc0..28441bc95995e 100644
--- a/docs/Homebrew-Governance-Archives.md
+++ b/docs/Homebrew-Governance-Archives.md
@@ -1,7 +1,8 @@
 # Homebrew Governance Archives
 
 {% assign governance_pages = site.pages | where: "category", "governance-archives" %}
+{% assign marker = "-" %}
 
 {% for item in governance_pages -%}
-- [{{ item.title }}]({{ item.url }})
+{{ marker }} [{{ item.title }}]({{ item.url }})
 {% endfor %}
diff --git a/docs/Homebrew-Governance.md b/docs/Homebrew-Governance.md
index 7c6dab825f16e..db47f3d6cc672 100644
--- a/docs/Homebrew-Governance.md
+++ b/docs/Homebrew-Governance.md
@@ -2,120 +2,163 @@
 
 ## 1. Definitions
 
+- The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED",  "MAY", and "OPTIONAL" in this document are to be interpreted as described in [RFC 2119](https://www.ietf.org/rfc/rfc2119.txt).
 - PLC: Project Leadership Committee
 - TSC: Technical Steering Committee
 - AGM: Annual General Meeting
 - An ordinary resolution requires a majority of the votes cast.
 - A special resolution requires a two-thirds supermajority of the votes cast.
+- Primary repositories: the three highest-traffic, security-critical repositories in the Homebrew project:
+  - [Homebrew/brew](https://github.com/Homebrew/brew) ([contributions](https://github.com/Homebrew/brew/graphs/contributors)),
+  - [Homebrew/homebrew-core](https://github.com/Homebrew/homebrew-core) ([contributions](https://github.com/Homebrew/homebrew-core/graphs/contributors)),
+  - [Homebrew/homebrew-cask](https://github.com/Homebrew/homebrew-cask) ([contributions](https://github.com/Homebrew/homebrew-cask/graphs/contributors))
 
 ## 2. Members
 
 1. New members (unless nominated as maintainers, see below) will be admitted by an ordinary resolution of the PLC and added to the Homebrew organisation on GitHub.
 
-2. Members may vote in all general elections and resolutions, hold office for Homebrew, and participate in all other membership functions.
+1. Members are expected to remain active within Homebrew. Members who are not active maintainers or active committee members must affirm their continued interest in Homebrew membership annually by voting on annual measures, even if voting abstention. Inactive, non-affirmed, non-voting members will be removed within 14 days after the annual meeting unless excused by the PLC.
 
-3. Members are expected to remain active within Homebrew, and are required to affirm their continued interest in Homebrew membership annually.
+1. A member may be removed from Homebrew by an ordinary resolution of the PLC. A removed member may be reinstated by the usual admission process.
 
-4. A member may be removed from Homebrew by an ordinary resolution of the PLC. A removed member may be reinstated by the usual admission process.
+1. All members will follow the [Homebrew Code of Conduct](https://github.com/Homebrew/.github/blob/HEAD/CODE_OF_CONDUCT.md#code-of-conduct). Changes to the code of conduct must be approved by the PLC.
 
-5. All members will follow the [Homebrew Code of Conduct](https://github.com/Homebrew/.github/blob/HEAD/CODE_OF_CONDUCT.md#code-of-conduct). Changes to the code of conduct must be approved by the PLC.
-
-6. Members should abstain from voting when they have a conflict of interest not shared by other members. No one may be compelled to abstain from voting.
+1. Members should abstain from voting when they have a conflict of interest not shared by other members. No one may be compelled to abstain from voting.
 
 ## 3. General Meetings of Members
 
-1. A general meeting of the members may be called by either an ordinary resolution of the PLC or a majority of the entire membership. The membership must be given at least three weeks notice of a general meeting.
+1. A general meeting of the members may be called by either an ordinary resolution of the PLC or a majority of the entire membership. The membership must be given at least three weeks' notice of a general meeting.
+   The Annual General Meeting should be conducted in person and may provide online video conferencing for those unable to attend. Other general meetings should be an online video conference.
 
-2. The quorum to vote on resolutions and elections at a general meeting is 3 voting members or 10% of the voting members, whichever is greater.
+1. The quorum to vote on resolutions and elections at a general meeting is 3 voting members or 10% of the voting members, whichever is greater.
+   A general meeting with no business except voting should be asynchronous.
+   Otherwise, it must be a synchronous online video conference.
+   The voting will occur using an online voting system chosen by the PLC.
+   The voting period closes after one week or after the outcome of the vote would not be changed by any subsequent votes.
+   If a synchronous meeting is happening, the meeting must occur before the votes can be tallied.
 
-3. Homebrew members will meet at the annual general meeting (AGM) in a manner determined by the PLC.
+1. Homebrew members will meet at the annual general meeting (AGM) in a manner determined by the PLC.
 
-4. General elections will be held at the AGM.
+1. Elections will be held at the AGM.
 
-5. The PLC will announce candidates and proposals three weeks prior to the election date.
+1. The PLC will announce candidates and proposals three weeks prior to the election date.
 
-6. Members may cast a vote any time up to three weeks prior to the election date.
+1. Members should cast their vote any time up to three weeks prior to the election date.
 
 ### 3.1. Amendments to these bylaws
 
-1. These bylaws may be amended by a special resolution at a general meeting of the members.
+1. These bylaws must only be amended by a special resolution at a general meeting of the members.
 
-2. Any member may propose an amendment via pull request on GitHub against this document.
+1. Any member may propose an amendment via pull request on GitHub against this document. Proposed amendments may be merged for consideration in aggregate with other amendments once more than half of the PLC has approved the pull request.
 
-3. Members shall vote on any amendments by approving or requesting changes on the GitHub pull request. Voting will close three weeks after an amendment is proposed, and all votes tallied.
+1. Members must vote on any amendments. All votes will be tallied.
+  Voting will open for three weeks once one or more amendment proposals are accepted unless the AGM is within one month, in which case the proposed amendments will be voted on at the same time as elections.
 
-4. Any approved amendments will take effect three weeks after the close of voting.
+1. Any approved amendments will take effect three weeks after the close of voting.
 
 ## 4. Project Leadership Committee
 
 1. The financial administration of Homebrew, organisation of the AGM, enforcement of the code of conduct and removal of members are performed by the PLC. The PLC will represent Homebrew in all dealings with Open Collective.
 
-2. The PLC consists of five members including the Project Leader. Committee members are elected by Homebrew members in a [Meek Single Transferable Vote](https://en.wikipedia.org/wiki/Counting_single_transferable_votes#Meek) election using the Droop quota. Each PLC member will serve a term of two years or until the member's successor is elected. Any sudden vacancy in the PLC will be filled by the usual procedure for electing PLC members at the next general meeting, typically the next AGM.
+1. The PLC consists of five members, one of whom is the Project Leader. The other committee members are elected by Homebrew members in a [Meek Single Transferable Vote](https://en.wikipedia.org/wiki/Counting_single_transferable_votes#Meek) election using the Droop quota. Each PLC member will serve a term of two years or until the member's successor is elected. The maximum number of consecutive terms a (non-PL) PLC member can serve is two, even if this means they have no successor. Any sudden vacancy in the PLC will be filled by the usual procedure for electing PLC members at the next general meeting, typically the next AGM.
 
-3. Three weeks prior to the AGM, the PLC will nominate at least one candidate for each upcoming vacant seat. Any member may also nominate any other member as a candidate for the PLC at this time.
+1. When a PLC seat is up for election or is vacant, any member may become a candidate for the PLC by providing a brief statement in the `#members` channel in Homebrew's Slack expressing relevant experience and intentions if elected no later than three weeks before the AGM. The PLC will maintain the candidate list until ballots are sent out one week before the AGM, during which time members should cast their votes. Candidates should deliver remarks in writing or verbally before or during the AGM but votes already cast are not changeable. The current PLC should vote on and publish a statement recommending their preferred candidates within the three-week period between the candidate deadline and the AGM.
 
-4. The PLC will deliver a report of their activities, decisions, and financial statements to the Homebrew members at the AGM.
+1. The PLC must report all minutes, participants in discussions and breakdowns of any votes cast to Homebrew members in the Homebrew/homebrew-governance-private GitHub repository no later than one week after the action has been taken. At the AGM, the PLC must present a summary of their activities and decisions since the last AGM. Financial statements can be viewed by anyone on the internet on [Homebrew's OpenCollective](https://opencollective.com/homebrew).
 
-5. No more than two employees of the same employer may serve on the PLC.
+1. No more than two employees of the same employer may serve on the PLC.
 
-6. A member of the PLC may be removed from the PLC by a special resolution of the membership.
+1. A member of the PLC must only be removed from the PLC by a special resolution of the membership.
 
-## 5. Meetings of the Project Leadership Committee
+1. All members of the PLC will be “billing managers” and "moderators" of the GitHub organisation and any related resources (e.g. Slack, 1Password where possible).
+
+1. One member of the PLC other than the PL will have an `Owner` role in the GitHub organization and any related resources. The PLC will choose this person, with preference given to any PLC members who are current Homebrew maintainers. If no PLC members are Homebrew maintainers, any PLC member qualifies for the `Owner` role.
 
-1. A synchronous meeting of the PLC may be called by any two of its members with at least three weeks notice, unless all PLC members agree to a shorter notice period.
+## 5. Meetings of the Project Leadership Committee
 
-2. The quorum to vote on resolutions at a synchronous meeting of the PLC is a majority of its members. In a Slack vote, there a time limit instead of quorum: it will take effect after a week, assuming vote passes.
+1. All members of the PLC must meet by synchronous video call or in person at least once per year. This meeting should be in person at the AGM with at least two months' notice.
 
-3. A majority of the entire membership of the PLC is required to pass an ordinary resolution.
+1. The quorum to vote on resolutions of the PLC is a majority of its members. In an electronic vote, a voting period of one week replaces the quorum requirement. Any approved resolution will take effect immediately.
 
-4. The PLC will meet synchronously and annually to review the status of all members and remove members who did not vote in the AGM and then did not re-affirm a commitment to Homebrew. Voting in the AGM confirms that a member wishes to remain active with the project. After the AGM, the PLC will ask the members who did not vote whether they wish to remain active with the project. The PLC removes any members who don't respond to this second request after three weeks.
+1. A majority of the entire membership of the PLC is required to pass an ordinary resolution.
 
-5. The PLC will appoint the members of the TSC.
+1. The PLC will annually review the status of all members and remove members who did not vote in the AGM and then did not re-affirm a commitment to Homebrew. Voting in the AGM confirms that a member wishes to remain active with the project. After the AGM, the PLC will ask the members who did not vote whether they wish to remain active with the project. The PLC removes any members who don't respond to this second request after three weeks.
 
-6. Any member may refer any financial questions, AGM questions or code of conduct violations to the PLC. All technical matters should instead be referred to the Project Leader and technical disputes to the TSC. Members will make a good faith effort to resolve any disputes with compromise prior to referral to the PLC, Project Leader or TSC.
+1. The PLC will appoint the members of the TSC.
 
-7. The PLC may synchronously meet by any mutually agreeable means, such as text chat, voice or video call, and in person. Members of the PLC must meet synchronously at least once per quarter. Members of the PLC must meet by synchronous video call or in person at least once per year.
+1. Any member may refer any financial questions, AGM questions or code of conduct violations to the PLC. All technical matters must instead be referred to the Project Leader and technical disputes to the TSC. Members will make a good faith effort to resolve any disputes with compromise prior to referral to the PLC, Project Leader or TSC.
 
 ## 6. Project Leader
 
 1. The Project Leader will represent Homebrew publicly, manage all day-to-day technical decisions, and resolve disputes related to the operation of Homebrew between maintainers, members, other contributors, and users.
 
-2. The Project Leader will be elected annually by Homebrew members in a [Schulze Condorcet method](https://en.wikipedia.org/wiki/Schulze_method) (aka 'beatpath') election. The PLC will nominate at least one candidate for Project Leader. Any member may nominate a candidate, or self-nominate. Nominations must be announced to the membership three weeks before the AGM.
+1. The Project Leader will be elected every two years by Homebrew members in a [Schulze Condorcet method](https://en.wikipedia.org/wiki/Schulze_method) (aka 'beatpath') election. The PLC will nominate at least one candidate for Project Leader. Any member may nominate a candidate, or self-nominate. Nominations must be announced to the membership three weeks before the AGM.
 
-3. Any vacancy of the Project Leader will be filled by appointment of the PLC.
+1. Any vacancy of the Project Leader will be filled by appointment of the PLC.
 
-4. The Project Leader's seat on the PLC is non-voting, unless a tie-breaker vote is required.
+1. A technical decision of the Project Leader may be overruled by an ordinary resolution of the TSC.
 
-5. A technical decision of the Project Leader may be overruled by an ordinary resolution of the TSC.
+1. A non-technical decision of the Project Leader may be overruled by an ordinary resolution of the PLC.
 
-6. A non-technical decision of the Project Leader may be overruled by an ordinary resolution of the PLC.
+1. The Project Leader must only be removed from the position by a special resolution of the membership.
 
-7. The Project Leader may be removed from the position by a special resolution of the membership.
+1. The Project Leader must be included in all PLC communications with or about Open Collective and in all communications related to joint responsibilities.
 
-8. The Project Leader must be included in all PLC communications with or about Open Collective and in all communications related to joint responsibilities.
+1. The Project Leader must be a maintainer, not just a member.
 
-9. The Project Leader must be a maintainer, not just a member.
+1. The Project Leader will be an "Owner" of the GitHub organization, Slack, 1Password and any related resources.
 
 ## 7. Technical Steering Committee
 
-1. The TSC has the authority to decide on any technical disputes between any maintainer and the Project Leader. Disputes not involving the Project Leader should be addressed through the Project Leader.
+1. The TSC has the authority to decide on any technical disputes between any maintainer and the Project Leader. Disputes not involving the Project Leader must be addressed through the Project Leader.
+
+1. The PL is one member of the TSC. The PLC will appoint between three and five maintainers to be members of the TSC. PLC members should not be any of these appointees. Appointed TSC members will serve a term of one year or until the member's successor is appointed.
+
+1. Any member may refer any technical question or dispute to the TSC. Members will make a good faith effort to resolve any disputes with compromise prior to referral to the TSC.
 
-2. The PLC will appoint between three and five maintainers to be members of the TSC. Voting PLC members should not be any of these appointees. Appointed TSC members will serve a term of one year or until the member's successor is appointed.
+1. No more than two employees of the same employer may serve on the TSC.
 
-3. Any member may refer any technical question or dispute to the TSC. Members will make a good faith effort to resolve any disputes with compromise prior to referral to the TSC.
+1. A member of the TSC, except the Project Leader, must only be removed from the TSC by an ordinary resolution of the PLC.
 
-4. No more than two employees of the same employer may serve on the TSC.
+1. All members of the TSC will be "moderators" of the GitHub organisation.
 
-5. A member of the TSC, except the Project Leader, may be removed from the TSC by an ordinary resolution of the PLC.
+1. One member of the TSC (not the PL) will be an "Owner" of the GitHub organisation, Slack, 1Password and any related resources.
 
 ## 8. Maintainers
 
 1. All maintainers are automatically members. Some, not all, members are maintainers.
 
-2. Maintainers are members with commit/write-access to at least one of: Homebrew/brew, Homebrew/homebrew-core, Homebrew/homebrew-cask.
+1. Maintainers are members with commit/write-access to at least one primary repository.
+
+1. New maintainers can be nominated by any existing maintainer. To become a maintainer, a nomination requires approval from one of the PL or any member of the TSC with no opposition from any of these people within a 24-hour period, excluding 19:00 UTC on Friday until 19:00 UTC on the following Monday. If there is opposition, the TSC must vote on the nomination in the #tsc private Slack channel, with the vote closing after one week or after the outcome of the vote would not be changed by any subsequent votes (such as when a majority of the TSC has voted in favour or against). The nomination will succeed by a simple majority vote of the votes cast.
+
+1. In accordance with Homebrew's organisational security posture, which requires operating under the principle of least privilege, the PL will review maintainers' write/commit access no later than six weeks before the AGM. The PL will remove maintainer privileges from those who have not consistently met these criteria:
+
+- having more contributions to primary repositories than the majority of non-maintainer contributors in at least one of these repositories
+- reviewing and merging of PRs of other maintainers and contributors in primary repositories
+  - the PL will exclude from consideration non-essential pull requests submitted and merged by the same person
+- reviewing any direct GitHub review requests or GitHub reviews for any sub-teams they are part of (e.g. Homebrew/linux) in any repository in the Homebrew organisation
+- responding to direct mentions on GitHub and direct mentions in Slack from the PL and other maintainers
+- maintaining a positive working relationship with the PL and other maintainers
+- engaging actively to resolve conflict with the PL or other maintainers, with a neutral intermediary upon request
+
+Maintainers who do not fulfil these requirements will be removed as a maintainer but may remain a member if they wish.
+
+The PL will not consider the following activities because they do not require commit or write access on security-critical repositories:
 
-3. New maintainers can be nominated by any existing maintainer. They require one approval from the Project Leader or a member of the TSC and no opposition from these people in a 24 hour "working" period (i.e. 7pm on a Friday waits until 7pm on a Monday). If there is opposition, it will be subject to a TSC Slack vote with a majority taking effect after a week.
+- contributions to the wider Homebrew organisation, repositories excluding the main, security-critical repositories, or the greater Homebrew ecosystem
+- contributions in previous years as a maintainer or contributor
+- contributions to the governance documents, the PLC, GSoC, MLH, social media, Homebrew's discussion forum, etc.
 
-4. Maintainers' commit access will be reviewed yearly by the Project Leader before the AGM and removed from those who have not committed enough or not performing maintainer responsibilities (e.g. reviewing the PRs of other maintainers and contributors rather than just merging their own PRs) in a given repository. If they are not active enough on any of Homebrew/brew, Homebrew/homebrew-core, Homebrew/homebrew-cask: they will be asked to step down as a maintainer but can remain as a member. If a TSC member believes that a maintainer's removal is unwarranted, they can call a TSC vote on whether to remove the member.
+If a maintainer wishes to appeal their removal, they may request a TSC review of the decision. This appeal must be lodged within 72 hours of removal.
+The appellant will confirm their intent to address any unfulfilled criteria which caused the removal.
+The TSC will review the decision within one week.
+A member of the TSC, who is not the PL, will respond immediately upon upholding or reversing the decision.
+The PL will restore access as soon as is feasible if the TSC votes to reverse the removal.
+If the TSC or PL feels that the maintainer has not made sufficient progress on the criteria for any reversed removal,
+  they may request a second TSC review no sooner than 30 days after the initial reversal.
+The TSC or PL may request a review in the event of noticeable no communication inactivity or unresponsiveness.
+The TSC will consider appeals no more than once per quarter per maintainer until the next AGM.
+The TSC will not consider any maintainer removal review until three months after the 2023 AGM.
 
-5. Members of the PLC do not have to be maintainers but will have implicit write access to their repositories anyway as "Owners" of the GitHub organisation. If they are not maintainers, they should not make use of this write access.
+In emergency situations, including but not limited to malicious commits, suspicious activity, abuse of resources, or any action or activity that could harm the security posture of the Homebrew codebase, systems, or organisation, the PL or anyone with the capability to remove privileges should remove any or all of a maintainer's access rights (e.g. to GitHub, Slack, 1Password, etc.). Upon doing so, they must inform the PLC and the TSC. The PLC will discuss the situation. The TSC will review the removal of any maintainer removed under this clause within two weeks and instruct the PL to restore the maintainer's privileges only if the situation is resolved. This is considered to be the maintainer removal appeal process, as mentioned above. The TSC will document the situation in an incident report to be shared with members and recommend changes to security settings, maintainer policy, this governance document or any additional measures required to prevent the situation from occurring again.
diff --git a/docs/Homebrew-Leadership-Responsibilities.md b/docs/Homebrew-Leadership-Responsibilities.md
index 2dd0ea405a412..35e49c64a569c 100644
--- a/docs/Homebrew-Leadership-Responsibilities.md
+++ b/docs/Homebrew-Leadership-Responsibilities.md
@@ -1,4 +1,4 @@
-# Homebrew Governance Responsibilities
+# Homebrew Leadership Responsibilities
 
 ## Project Leadership Committee
 
@@ -21,19 +21,21 @@
 
 - January: check membership, announce AGM votes
   - Ask for nominations for the for the PLC and project leader, and ask who is interested in serving on the TSC
-  - Create ballots for the elections on https://www.opavote.com
+  - Create ballots for the elections on <https://www.opavote.com>
   - Ask the project leader and representatives of the PLC and TSC to prepare reports for the AGM
   - Ask for members interested in presenting lightning talks at the AGM
 - February: organise the annual general meeting (AGM)
   - Create a dedicated Slack channel
   - Book a group dinner (which Homebrew pays for) and check for any dietary requirements
   - Ask someone to bring a conference/table microphone for people to be able to remotely participate in AGM
+  - Reconsider current OpenCollective invoice hourly rates based on e.g. inflation
 - February after the AGM:
-  - Add the minutes of the AGM to https://github.com/Homebrew/homebrew-governance
-  - Create [issue in homebrew-governance](https://github.com/homebrew/homebrew-governance/issues) to ask members who did not vote in the election whether they wish to remain or step down as members
+  - Add the minutes of the AGM to Homebrew/brew's [governance archives](https://github.com/Homebrew/brew/tree/master/docs/governance)
+  - Create an [issue in Homebrew/brew](https://github.com/Homebrew/brew/issues?q=is%3Aissue+in%3Atitle+membership+) to survey members who did not vote in the election whether they wish to remain or step down as members
     - Members that are not maintainers should be a least one of:
       - An current or previously active maintainer, PLC/TSC member or Project Leader
       - A long-standing member of the Homebrew community (e.g. been submitting good bug reports for over two years)
+    - After the survey issue is closed, list the current year's members in a new file within the [governance archives](https://github.com/Homebrew/brew/tree/master/docs/governance)
 - October: arrange in-person AGM
   - Offer to pay for Homebrew maintainers who are at least one of:
     - active Homebrew maintainers (i.e. not just contributors)
diff --git a/docs/Homebrew-and-Python.md b/docs/Homebrew-and-Python.md
index c255cd8037b16..e3d90d025a45c 100644
--- a/docs/Homebrew-and-Python.md
+++ b/docs/Homebrew-and-Python.md
@@ -2,15 +2,12 @@
 
 This page describes how Python is handled in Homebrew for users. See [Python for Formula Authors](Python-for-Formula-Authors.md) for advice on writing formulae to install packages written in Python.
 
-Homebrew should work with any [CPython](https://stackoverflow.com/questions/2324208/is-there-any-difference-between-cpython-and-python) and defaults to the macOS system Python.
+Homebrew will install the necessary Python 3 version that is needed to make your packages work. Python 2 (or 1) is not supported.
 
-Homebrew provides formulae to brew Python 3.y. A `python@2` formula was provided until the end of 2019, at which point it was removed due to the Python 2 deprecation.
+## Python 3
 
-**Important:** If you choose to use a Python which isn't either of these two (system Python or brewed Python), the Homebrew team cannot support any breakage that may occur.
-
-## Python 3.y
-
-Homebrew provides formulae for maintained releases of Python 3.y (`python@3.y`).
+Homebrew provides formulae for the newest and maintained releases of Python 3 (`python@3.y`) (<https://devguide.python.org/versions/>).
+We keep older `python@3.y` versions according to our [versioned formulae guidelines](https://docs.brew.sh/Versions).
 
 **Important:** Python may be upgraded to a newer version at any time. Consider using a version
 manager such as `pyenv` if you require stability of minor or patch versions for virtual environments.
@@ -23,20 +20,26 @@ The executables are organised as follows:
 Unversioned symlinks for `python`, `python-config`, `pip` etc. are installed here:
 
 ```sh
-$(brew --prefix)/opt/python/libexec/bin
+$(brew --prefix python)/libexec/bin
 ```
 
-## Setuptools, Pip, etc.
+**Warning!** The executables do not always point to the latest Python 3 version, as there is always a delay between the newest Python 3 release and the homebrew-core repository switching to the newest version.
+
+## Setuptools, pip, etc.
+
+The Python formulae install [pip](https://pip.pypa.io/) (as `pip3`). Python@3.11 and older Python formulae also install [Setuptools](https://pypi.org/project/setuptools/).
 
-The Python formulae install [pip](https://pip.pypa.io/) (as `pip3`) and [Setuptools](https://pypi.org/project/setuptools/).
+Starting with Python 3.12, the bundled Python packages should be updated by reinstalling brewed Python. For older Python formulae, they can be updated as described below.
 
-Setuptools can be updated via pip3, without having to re-brew Python:
+**Warning!** The steps below **do not work** for Homebrew's Python 3.12 or newer. If you need a newer version of `pip` or `setuptools` than comes with the Homebrewed Python, you **must** use a virtual environment or other isolation mechanism [per below](#pep-668-and-virtual-environments).
+
+Setuptools can be updated via `pip`, without having to reinstall brewed Python:
 
 ```sh
 python3 -m pip install --upgrade setuptools
 ```
 
-Similarly, pip3 can be used to upgrade itself via:
+Similarly, `pip` can be used to upgrade itself via:
 
 ```sh
 python3 -m pip install --upgrade pip
@@ -50,7 +53,7 @@ The `site-packages` is a directory that contains Python modules, including bindi
 $(brew --prefix)/lib/pythonX.Y/site-packages
 ```
 
-So, for Python 3.y.z, you'll find it at `/usr/local/lib/python3.y/site-packages`.
+So, for Python 3.y.z, you'll find it at `/usr/local/lib/python3.y/site-packages` on macOS Intel.
 
 Python 3.y also searches for modules in:
 
@@ -67,17 +70,15 @@ The reasoning for this location is to preserve your modules between (minor) upgr
 
 Some formulae provide Python bindings.
 
-**Warning!** Python may crash (see [Common Issues](Common-Issues.md)) when you `import <module>` from a brewed Python if you ran `brew install <formula_with_python_bindings>` against the system Python. If you decide to switch to the brewed Python, then reinstall all formulae with Python bindings (e.g. `pyside`, `wxwidgets`, `pyqt`, `pygobject3`, `opencv`, `vtk` and `boost-python`).
-
 ## Policy for non-brewed Python bindings
 
-These should be installed via `pip install <package>`. To discover, you can use `pip search` or <https://pypi.org>.
+These should be installed via `pip install <package>`. To discover, you can use <https://pypi.org/search>.
 
-**Note:** macOS's system Python does not provide `pip`. Follow the [pip documentation](https://pip.pypa.io/en/stable/installation/) to install it for your system Python if you would like it.
+Starting with Python 3.12, we highly recommend you to use a separate virtualenv for this (see the section about [PEP 668](https://peps.python.org/pep-0668/#marking-an-interpreter-as-using-an-external-package-manager) below).
 
 ## Brewed Python modules
 
-For brewed Python, modules installed with `pip3` or `python3 setup.py install` will be installed to the `$(brew --prefix)/lib/pythonX.Y/site-packages` directory (explained above). Executable Python scripts will be in `$(brew --prefix)/bin`.
+For brewed Python, modules installed with `pip` or `python3 setup.py install` will be installed to the `$(brew --prefix)/lib/pythonX.Y/site-packages` directory (explained above). Executable Python scripts will be in `$(brew --prefix)/bin`.
 
 Since the system Python may not know which compiler flags to set when building bindings for software installed by Homebrew, you may need to run:
 
@@ -85,14 +86,18 @@ Since the system Python may not know which compiler flags to set when building b
 CFLAGS="-I$(brew --prefix)/include" LDFLAGS="-L$(brew --prefix)/lib" pip install <package>
 ```
 
-## Virtualenv
+## PEP 668 and virtual environments
+
+Starting with Python 3.12, Homebrew follows [PEP 668](https://peps.python.org/pep-0668/#marking-an-interpreter-as-using-an-external-package-manager).
 
-**Warning!** When you `brew install` formulae that provide Python bindings, you should **not be in an active virtual environment**.
+If you wish to install a non-brew-packaged Python package (from PyPI for example):
 
-Activate the virtualenv *after* you've brewed, or brew in a fresh terminal window.
-This will ensure Python modules are installed into Homebrew's `site-packages` and *not* into that of the virtual environment.
+* create a virtual environment using `python3 -m venv path/to/venv`. Then use `path/to/venv/bin/python` and `path/to/venv/bin/pip`.
+* or use `pipx install xyz`, which will manage a virtual environment for you.
+  You can install `pipx` by running `brew install pipx`.
+  When you use `pipx` to install a Python application, it will always use a virtual environment for you.
 
-Virtualenv has a `--system-site-packages` switch to allow "global" (i.e. Homebrew's) `site-packages` to be accessible from within the virtualenv.
+It is possible to install some Python packages as formulae by using `brew install xyz`. We do not recommend using these formulae and instead recommend you install them with pip inside a virtualenv. These system-wide Homebrew Python formulae are often Homebrew-specific formulae that are useful as dependencies for other Homebrew formulae. It is not recommended to rely on them.
 
 ## Why is Homebrew's Python being installed as a dependency?
 
diff --git a/docs/Homebrew-brew-Maintainer-Guide.md b/docs/Homebrew-brew-Maintainer-Guide.md
index 1c22341e4bfb2..1968a56a060db 100644
--- a/docs/Homebrew-brew-Maintainer-Guide.md
+++ b/docs/Homebrew-brew-Maintainer-Guide.md
@@ -1,119 +1,57 @@
 # Homebrew/brew Maintainer Guide
 
-This document describes a few components of the `Homebrew/brew` repository that are useful for maintainers to
-be aware of, but don't necessarily need to appear in documentation for most users and contributors.
-
-## Reviewing PRs
-
-Using `gh pr checkout NUMBER` is a super easy way to check out a PR branch using the GitHub CLI.
-
-When reviewing a PR, use "comment", "approve", or "request changes" when submitting based on the following guidelines:
-
-- Comment: if the PR isn't quite ready to be merged
-- Approve: if you feel that the PR is in a good state to be merged, even if there are
-  non-blocking changes you'd like to be made
-- Request changes: if you feel strongly that the PR is likely to cause a problem for users or
-  have another reason to oppose the PR.
+This document describes a few components of the `Homebrew/brew` repository that are useful for maintainers to be aware of, but don't necessarily need to appear in documentation for most users and contributors.
 
 ## Merging PRs
 
-Merging is done using the standard Merge button in the `Homebrew/brew` repository to preserve
-history and GPG commit signing. The Squash and Merge and Rebase and Merge buttons are disabled.
+Merging is done using the standard "Merge" button in the `Homebrew/brew` repository to preserve history and GPG commit signing. The "Squash and Merge" and "Rebase and Merge" buttons are disabled.
 
 PRs must meet the following conditions to be merged:
 
-- Have at least one maintainer (or [@BrewTestBot](https://github.com/BrewTestBot)) approval.
-  See the ["Automatic approvals" section below](#automatic-approvals).
-  for more details about how [@BrewTestBot](https://github.com/BrewTestBot) approves PRs.
-- Have passing CI. This is a _mandatory_ step. PRs with failing CI should _never_ be merged.
-  See the ["CI" section below](#ci) for more information about `Homebrew/brew` CI.
-
-If possible, PRs should also have GPG-signed commits (see the private `ops` repository for
-instructions on setting this up).
-
-## Automatic approvals
+- Have at least one maintainer approval.
+- Have passing CI (continuous integration). This is a _mandatory_ step. PRs with failing CI should _never_ be merged. See the [CI](#ci) section below for more information about `Homebrew/brew` CI.
 
-To ensure that non-urgent PRs have the opportunity to be seen and reviewed by any other maintainers who wish
-to take a look, all PRs require an approval before they can be merged. However, not every PR is
-reviewed by another maintainer, and some PRs are urgent enough that they need to be merged without
-an approval by another maintainer.
+If possible, PRs should also have GPG-signed commits (see the private `ops` repository for instructions on setting this up).
 
-As a compromise between always needing a review and allowing maintainers to merge PRs they deem ready,
-the `Triage` CI job will ensure that PRs cannot be merged until they've been open for 24 hours
-(only counting hours that occur Monday to Friday). After the triage period has expired, the
-CI job will show up as "passed" and [@BrewTestBot](https://github.com/BrewTestBot) will approve the PR,
-allowing it to be merged. This gives all maintainers a reasonable opportunity to review every PR,
-but won't block any PR for lack of reviews.
+### Automatic approvals
 
-If the PR is urgent enough that it is necessary to bypass that 24 hour window, the `critical` label
-should be applied to the PR. When this label is applied, the `Triage` CI job will immediately be
-successful and [@BrewTestBot](https://github.com/BrewTestBot) will approve the PR.
+To ensure that non-urgent PRs have the opportunity to be seen and reviewed by any other maintainers who wish to take a look, all PRs require an approval before they can be merged.
 
 ## CI
 
-Every PR in `Homebrew/brew` runs a series of CI tests to try to prevent bugs from being introduced.
-**A PR _must_ have passing CI before it can be merged**.
+Every PR in `Homebrew/brew` runs a series of CI tests to try to prevent bugs from being introduced. **A PR _must_ have passing CI before it can be merged.**
 
 There are many checks that run on every PR. The following is a quick list of the various checks and what they represent:
 
-- `Vendor Gems / vendor-gems`: This is skipped except for dependabot PRs. It updates the RBI files to match
-  any new/changed dependencies. See [Type Checking With Sorbet](Typechecking.md) for more information about RBI files
-  and typechecking.
-- `Triage / review`: This verifies that the PR has been open for long enough.
-  See the ["Automatic approvals" section above](#automatic-approvals) for more information about automatic approvals.
-- `codecov/patch` and `codecov/project`: These show the Codecov report for the PR.
-  See the ["`brew tests` and Codecov" section below](#brew-tests-and-codecov) for more info about Codecov.
-- `CI / vendored gems (Linux)`: This checks whether there was a change to the vendored gems on Linux that needs to be
-  committed to the PR branch.
+- `Vendor Gems / vendor-gems`: This is skipped except for dependabot PRs. It updates the RBI files to match any new/changed dependencies. See [Type Checking With Sorbet](Typechecking.md) for more information about RBI files and typechecking.
+- `Codecov / codecov/patch` and `codecov/project`: These show the Codecov report for the PR. See the [`brew tests` and Codecov](#brew-tests-and-codecov) section below for more info about Codecov.
+- `CI / vendored gems`: This checks whether there was a change to the vendored gems on Linux that needs to be committed to the PR branch.
 - `CI / test default formula (Linux)`: This runs `brew test-bot` on Linux to ensure it still works as expected.
-- `CI / syntax`: This is run first to check whether the PR passes `brew style` and `brew typecheck`. If this job fails the
-  following jobs will not run.
-- `CI / tap syntax (Linux)`: This runs `brew style` and `brew audit` on all official taps
-  (note that although this has Linux in its name, it does check `Homebrew/homebrew-core` and all cask repos).
-- `CI / docker`: This builds and deploys a new Homebrew Docker image.
-- `CI / test everything (macOS)`: This runs several checks on macOS including `brew tests`, `brew update-tests`,
-  `brew test-bot --only-formulae --test-default-formula`, `brew readall` and `brew doctor`.
-- `CI / tests (no-compatibility mode)`, `CI / tests (generic OS)` and `CI / tests (Linux)`: These run
-  `brew tests` with various options on Linux.
+- `CI / syntax`: This is run first to check whether the PR passes `brew style` and `brew typecheck`. If this job fails the following jobs will not run.
+- `CI / tap syntax`: This runs `brew style` and `brew audit` on all official taps (note that although this runs on Linux, it does check all cask repositories).
+- `CI / docker`: This builds and deploys a new Homebrew Docker image to GitHub Packages and Docker Hub.
+- `CI / test everything (macOS)`: This runs several checks on macOS including `brew tests`, `brew update-tests`, `brew test-bot --only-formulae --test-default-formula`, `brew readall` and `brew doctor`.
+- `CI / tests (generic OS)` and `CI / tests (Linux)`: These run `brew tests` with various options on Linux.
+- `Documentation CI / linting` and `rubydoc`: These check the prose and formatting of the written documentation, and verify the [rubydoc API documentation](https://rubydoc.brew.sh) can be built without issue.
 
 _Note that this list is non-exhaustive and can change over time._
 
 ### `brew tests` and Codecov
 
-A coverage report is generated by Codecov for every PR, and its results are shown as CI jobs.
-These reports are publicly viewable on [Homebrew/brew's Codecov page](https://app.codecov.io/gh/Homebrew/brew).
-Additionally, annotations will appear in the PR's "Files changed" tab where lines of code have been
-added that aren't being hit by `brew tests`. If the Codecov job fails, that's a sign that some
-more tests should be added to test the functionality being added in the PR.
+A coverage report is generated by Codecov for every PR, and its results are shown as CI jobs. These reports are publicly viewable on [Homebrew/brew's Codecov page](https://app.codecov.io/gh/Homebrew/brew). Additionally, annotations will appear in the PR's "Files changed" tab where lines of code have been added that aren't being hit by `brew tests`. If the Codecov job fails, that's a sign that some more tests should be added to test the functionality being added in the PR.
 
-Codecov should be used as a guide to indicate when more tests are probably needed, but it's unrealistic for
-every line of code to have a test associated with it, especially when testing would require a slow
-integration test. For this reason, it's okay to merge PRs that fail the Codecov check if necessary,
-but this should be avoided if possible.
+Codecov should be used as a guide to indicate when more tests are probably needed, but it's unrealistic for every line of code to have a test associated with it, especially when testing would require a slow integration test. For this reason, it's okay to merge PRs that fail the Codecov check if necessary, but this should be avoided if possible.
 
 ### `brew tests` and BuildPulse
 
-BuildPulse monitors CI jobs for every push to `Homebrew/brew` to detect flaky tests and track them over time. The
-reports are available to Homebrew maintainers on [buildpulse.io](https://buildpulse.io/installations) and daily
-summaries are published to [`#buildpulse-health`](https://machomebrew.slack.com/archives/C0268BSJBJ8) in Slack.
+BuildPulse monitors CI jobs for every push to `Homebrew/brew` to detect flaky tests and track them over time. The reports are available to Homebrew maintainers on [buildpulse.io](https://app.buildpulse.io/@Homebrew) and daily summaries are published to [`#buildpulse-health`](https://machomebrew.slack.com/archives/C0268BSJBJ8) in Slack.
 
-BuildPulse can be used as a guide to identify which flaky tests are causing the most disruption to the CI suite. To make
-the biggest improvements to the reliability of the build, we can focus on the most disruptive flaky tests first (i.e.
-the tests causing the most intermittent failures).
+BuildPulse can be used as a guide to identify which flaky tests are causing the most disruption to the CI suite. To make the biggest improvements to the reliability of the build, we can focus on the most disruptive flaky tests first (i.e. the tests causing the most intermittent failures).
 
-To help find the root cause for a particular flaky test, buildpulse.io provides links to the most recent CI job and
-commit where the test failed and then passed with no change to the underlying code. You may want to check out the code
-at that commit to attempt to reproduce the failure locally. You can also see the list of recent failures on
-[buildpulse.io](https://buildpulse.io) to determine if the test always fails the same way.
+To help find the root cause for a particular flaky test, buildpulse.io provides links to the most recent CI job and commit where the test failed and then passed with no change to the underlying code. You may want to check out the code at that commit to attempt to reproduce the failure locally. You can also see the list of recent failures on [buildpulse.io](https://app.buildpulse.io/@Homebrew) to determine if the test always fails the same way.
 
-## Manpages and shell completions
+## Manpages and Shell Completions
 
-Homebrew's manpages and shell completions are generated automatically by the `brew generate-man-completions` command.
-Contributors are welcome to run this command and commit the changes in a PR, but they don't have to. If they don't,
-a follow-up PR to make the necessary changes will be opened automatically by [@BrewTestBot](https://github.com/BrewTestBot)
-once the original PR is merged. These follow-up PRs can be merged immediately if the changes seem correct.
+Homebrew's manpages and shell completions are generated automatically by the `brew generate-man-completions` command. Contributors are welcome to run this command and commit the changes in a PR, but they don't have to. If they don't, a follow-up PR to make the necessary changes will be opened automatically by [@BrewTestBot](https://github.com/BrewTestBot) once the original PR is merged. These follow-up PRs can be merged immediately if the changes seem correct.
 
-An update can be requested manually by triggering the workflow from the
-[Update maintainers, manpage and completions](https://github.com/Homebrew/brew/actions/workflows/update-man-completions.yml)
-section under the "Actions" tab. Click on the "Run workflow" dropdown and then the "Run workflow" button.
-A PR will be opened shortly if there are any changes.
+An update can be requested manually by triggering the workflow from the [Update sponsors, maintainers, manpage and completions](https://github.com/Homebrew/brew/actions/workflows/sponsors-maintainers-man-completions.yml) section under the "Actions" tab. Click on the "Run workflow" dropdown and then the "Run workflow" button. A PR will be opened shortly if there are any changes.
diff --git a/docs/Homebrew-homebrew-cask-Maintainer-Guide.md b/docs/Homebrew-homebrew-cask-Maintainer-Guide.md
index 5a1cf7d14719d..5ba68447cbf90 100644
--- a/docs/Homebrew-homebrew-cask-Maintainer-Guide.md
+++ b/docs/Homebrew-homebrew-cask-Maintainer-Guide.md
@@ -1,50 +1,29 @@
 # Homebrew/homebrew-cask Maintainer Guide
 
-This guide is intended to help maintainers effectively maintain the cask repositories.
-It is meant to be used in conjunction with the more generic [Maintainer Guidelines](Maintainer-Guidelines.md).
-
-This guide applies to all four of the cask repositories:
-
-- [Homebrew/homebrew-cask](https://github.com/Homebrew/homebrew-cask): The main cask repository
-- [Homebrew/homebrew-cask-drivers](https://github.com/Homebrew/homebrew-cask-drivers): Casks of drivers
-- [Homebrew/homebrew-cask-fonts](https://github.com/Homebrew/homebrew-cask-fonts): Casks of fonts
-- [Homebrew/homebrew-cask-versions](https://github.com/Homebrew/homebrew-cask-versions): Alternate versions of Casks
+This guide is intended to help maintainers effectively maintain the cask repository. It is meant to be used in conjunction with the more generic [Maintainer Guidelines](Maintainer-Guidelines.md).
 
 ## Common Situations
 
 Here is a list of the most common situations that arise in cask PRs and how to handle them:
 
 - The `version` and `sha256` both change (keeping the same format): Merge.
-- Only the `sha256` changes: Merge unless the version needs to be updated as well.
-  It’s not uncommon for upstream vendors to update versions in-place.
-  However, be wary for times when e.g. upstream could have been hacked.
-- `livecheck` is updated: Use your best judgement and try to make sure that the changes
-  follow the [`livecheck` guidelines](Brew-Livecheck.md).
-- Only the `version` changes or the `version` format changes: Use your best judgement and
-  merge if it seems correct (this is relatively rare).
+- Only the `sha256` changes: Merge unless the version needs to be updated as well. It’s not uncommon for upstream vendors to update versions in-place. However, be wary for times when e.g. upstream could have been hacked.
+- `livecheck` is updated: Use your best judgement and try to make sure that the changes follow the [`livecheck` guidelines](Brew-Livecheck.md).
+- Only the `version` changes or the `version` format changes: Use your best judgement and merge if it seems correct (this is relatively rare).
 - Other changes (including adding new casks): Use the [Cask Cookbook](Cask-Cookbook.md) to determine what's correct.
 
 If in doubt, ask another cask maintainer on GitHub or Slack.
 
-Note that unlike formulae, casks do not consider the `sha256` stanza to be a meaningful security measure
-as maintainers cannot realistically check them for authenticity. Casks download from upstream; if a malicious
-actor compromised a URL, they could potentially compromise a version and make it look like an update.
+Note that unlike formulae, casks do not consider the `sha256` stanza to be a meaningful security measure as maintainers cannot realistically check them for authenticity. Casks download from upstream; if a malicious actor compromised a URL, they could potentially compromise a version and make it look like an update.
 
 ## Merging
 
-In general, using GitHub's Squash and Merge button is the best way to merge a PR. This can be used when
-the PR modifies only one cask, regardless of the number of commits or whether the commit message
-format is correct. When merging using this method, the commit message can be modified if needed.
-Usually, version bump commit messages follow the form `Update CASK from OLD_VERSION to NEW_VERSION`.
+In general, using GitHub's "Merge" button is the best way to merge a PR. This can be used when the PR modifies only one cask, regardless of the number of commits or whether the commit message format is correct. When merging using this method, the commit message can be modified if needed. Usually, version bump commit messages follow the form `Update CASK from OLD_VERSION to NEW_VERSION`.
 
-If the PR modifies multiple casks, use the Rebase and Merge button to merge the PR. This will use the
-commit messages from the PR, so make sure that they are appropriate before merging. If needed,
-checkout the PR, squash/reword the commits and force-push back to the PR branch to ensure the proper commit format.
+If the PR modifies multiple casks, use the "Rebase and Merge" button to merge the PR. This will use the commit messages from the PR, so make sure that they are appropriate before merging. If needed, checkout the PR, squash/reword the commits and force-push back to the PR branch to ensure the proper commit format.
 
 Finally, make sure to thank the contributor for submitting a PR!
 
 ## Other Tips
 
-A maintainer can easily rebase a PR onto the latest `master` branch by adding a `/rebase` comment.
-`BrewTestBot` will automatically rebase the PR and add a reaction to
-the comment once the rebase is in progress and complete.
+A maintainer can easily rebase a PR onto the latest `master` branch by adding a `/rebase` comment. `BrewTestBot` will automatically rebase the PR and add a reaction to the comment once the rebase is in progress and complete.
diff --git a/docs/Homebrew-homebrew-core-Maintainer-Guide.md b/docs/Homebrew-homebrew-core-Maintainer-Guide.md
index dfe27fdd8077a..8595fdc8bb2ed 100644
--- a/docs/Homebrew-homebrew-core-Maintainer-Guide.md
+++ b/docs/Homebrew-homebrew-core-Maintainer-Guide.md
@@ -7,55 +7,33 @@ A detailed checklist can be found [below](#detailed-merge-checklist). This is al
 - Ensure the name seems reasonable.
 - Add aliases.
 - Ensure it uses `keg_only :provided_by_macos` if it already comes with macOS.
-- Ensure it is not a library that can be installed with
-  [gem](https://en.wikipedia.org/wiki/RubyGems),
-  [cpan](https://en.wikipedia.org/wiki/Cpan) or
-  [pip](https://pip.pypa.io/en/stable/).
-- Ensure that any dependencies are accurate and minimal. We don't need to
-  support every possible optional feature for the software.
-- When bottles aren't required or affected, use the GitHub squash & merge workflow for a single-formula PR or rebase & merge workflow for a multiple-formulae PR. See the ["How to merge without bottles" section below](#how-to-merge-without-bottles)
-for more details.
-- Use `brew pr-publish` or `brew pr-pull` otherwise, which adds messages to auto-close pull requests and pull bottles built by the Brew Test Bot.
+- Ensure it is not a library that can be installed with [gem](https://en.wikipedia.org/wiki/RubyGems), [cpan](https://en.wikipedia.org/wiki/Cpan) or [pip](https://pip.pypa.io/en/stable/).
+- Ensure that any dependencies are accurate and minimal. We don't need to support every possible optional feature for the software.
+- When bottles aren't required or affected, use the GitHub squash & merge workflow for a single-formula PR or rebase & merge workflow for a multiple-formulae PR. See the [How to merge without bottles](#how-to-merge-without-bottles) section below for more details.
+- Use `brew pr-publish` or `brew pr-pull` otherwise, which adds messages to auto-close pull requests and pull bottles built by BrewTestBot.
 - Thank people for contributing.
 
-Checking dependencies is important, because they will probably stick around
-forever. Nobody really checks if they are necessary or not.
+Checking dependencies is important, because they will probably stick around forever. Nobody really checks if they are necessary or not.
 
-Depend on as little stuff as possible. Disable X11 functionality if possible.
-For example, we build Wireshark, but not the heavy GUI.
+Depend on as little stuff as possible. Disable X11 functionality if possible. For example, we build Wireshark, but not the heavy GUI.
 
-Homebrew is about Unix software. Stuff that builds to an `.app` should
-be in Homebrew Cask instead.
+Homebrew is about Unix software. Stuff that builds to an `.app` should be in Homebrew Cask instead.
 
 ## Merging, rebasing, cherry-picking
 
-For most PRs that make formula modifications, you can simply approve the PR and an automatic
-merge (with bottles) will be performed by [@BrewTestBot](https://github.com/BrewTestBot).
-See [Brew Test Bot For Core Contributors](Brew-Test-Bot-For-Core-Contributors.md) for more information.
+For most PRs that make formula modifications, you can simply approve the PR and an automatic merge (with bottles) will be performed by [@BrewTestBot](https://github.com/BrewTestBot). See [BrewTestBot for Maintainers](BrewTestBot-For-Maintainers.md) for more information.
 
-Certain PRs may not be merged automatically by [@BrewTestBot](https://github.com/BrewTestBot),
-even after they've been approved. This includes PRs with the `new formula`, `automerge-skip`,
-and `linux-only` labels. To trigger a merge for these PRs, run `brew pr-publish`.
+Certain PRs may not be merged automatically by [@BrewTestBot](https://github.com/BrewTestBot), even after they've been approved. This includes PRs with the `new formula` and `automerge-skip` labels. To trigger a merge for these PRs, run `brew pr-publish`.
 
-PRs modifying formulae that don't need bottles or making changes that don't
-require new bottles to be pulled should use GitHub's squash & merge or rebase & merge workflows.
-See the [table below](#how-to-merge-without-bottles) for more details.
+PRs modifying formulae that don't need bottles or making changes that don't require new bottles to be pulled should use GitHub's squash & merge or rebase & merge workflows.
 
 Otherwise, you should use `brew pr-pull` (or `rebase`/`cherry-pick` contributions).
 
-Don’t `rebase` until you finally `push`. Once `master` is pushed, you can’t
-`rebase`: **you’re a maintainer now!**
+Don’t `rebase` until you finally `push`. Once `master` is pushed, you can’t `rebase`: **you’re a maintainer now!**
 
 Cherry-picking changes the date of the commit, which kind of sucks.
 
-Don’t `merge` unclean branches. So if someone is still learning `git` and
-their branch is filled with nonsensical merges, then `rebase` and squash
-the commits. Our main branch history should be useful to other people,
-not confusing.
-
-Here’s a flowchart for managing a PR which is ready to merge:
-
-![Flowchart for managing pull requests](assets/img/docs/managing-pull-requests.drawio.svg)
+Don’t `merge` unclean branches. So if someone is still learning `git` and their branch is filled with nonsensical merges, then `rebase` and squash the commits. Our main branch history should be useful to other people, not confusing.
 
 Only one maintainer is necessary to approve and merge the addition of a new or updated formula which passes CI. However, if the formula addition or update proves controversial the maintainer who adds it will be expected to answer requests and fix problems that arise with it in future.
 
@@ -70,45 +48,25 @@ Here are guidelines about when to use squash & merge versus rebase & merge. Thes
 
 ## Naming
 
-The name is the strictest item, because avoiding a later name change is
-desirable.
+The name is the strictest item, because avoiding a later name change is desirable.
 
-Choose a name that’s the most common name for the project.
-For example, we initially chose `objective-caml` but we should have chosen `ocaml`.
-Choose what people say to each other when talking about the project.
+Choose a name that’s the most common name for the project. For example, we initially chose `objective-caml` but we should have chosen `ocaml`. Choose what people say to each other when talking about the project.
 
-Formulae that are also packaged by other package managers (e.g. Debian, Ubuntu) should be
-named consistently (subject to minor differences due to Homebrew formula naming conventions).
+Formulae that are also packaged by other package managers (e.g. Debian, Ubuntu) should be named consistently (subject to minor differences due to Homebrew formula naming conventions).
 
-Add other names as aliases as symlinks in `Aliases` in the tap root. Ensure the
-name referenced on the homepage is one of these, as it may be different and have
-underscores and hyphens and so on.
+Add other names as aliases using symlinks within `Aliases` in the tap root. Ensure the name referenced on the homepage is one of these, as it may be different and have underscores and hyphens and so on.
 
 We now accept versioned formulae as long as they [meet the requirements](Versions.md).
 
 ## Testing
 
-We need to at least check that it builds. Use the [Brew Test Bot](Brew-Test-Bot.md) for this.
+We need to at least check that it builds. Use [BrewTestBot](BrewTestBot.md) for this.
 
-Verify the formula works if possible. If you can’t tell (e.g. if it’s a
-library) trust the original contributor, it worked for them, so chances are it
-is fine. If you aren’t an expert in the tool in question, you can’t really
-gauge if the formula installed the program correctly. At some point an expert
-will come along, cry blue murder that it doesn’t work, and fix it. This is how
-open source works. Ideally, request a `test do` block to test that
-functionality is consistently available.
+Verify the formula works if possible. If you can’t tell (e.g. if it’s a library) trust the original contributor; it worked for them, so chances are it is fine. If you aren’t an expert in the tool in question, you can’t really gauge if the formula installed the program correctly. At some point an expert will come along, cry blue murder that it doesn’t work, and fix it. This is how open source works. Ideally, request a `test do` block to test that functionality is consistently available.
 
-If the formula uses a repository, then the `url` parameter should have a
-tag or revision. `url`s have versions and are stable (not yet
-implemented!).
+If the formula uses a repository, then the `url` parameter should have a tag or revision. `url`s have versions and are stable (not yet implemented!).
 
-Don't merge any formula updates with failing `brew test`s. If a `test do` block
-is failing it needs to be fixed. This may involve replacing more involved tests
-with those that are more reliable. This is fine: false positives are better than
-false negatives as we don't want to teach maintainers to merge red PRs. If the
-test failure is believed to be due to a bug in `Homebrew/brew` or the CI system,
-that bug must be fixed, or worked around in the formula to yield a passing test,
-before the PR can be merged.
+Don't merge any formula updates with failing `brew test`s. If a `test do` block is failing it needs to be fixed. This may involve replacing more involved tests with those that are more reliable. This is fine: false positives are better than false negatives as we don't want to teach maintainers to merge red PRs. If the test failure is believed to be due to a bug in `Homebrew/brew` or the CI system, that bug must be fixed, or worked around in the formula to yield a passing test, before the PR can be merged.
 
 ## Duplicates
 
@@ -125,28 +83,24 @@ Formulae that:
 
 should not be removed from Homebrew. The exception to this rule are [versioned formulae](Versions.md) for which there are higher standards of usage and a maximum number of versions for a given formula.
 
-For more information about deprecating, disabling and removing formulae, see the
-[Deprecating, Disabling, and Removing Formulae page](Deprecating-Disabling-and-Removing-Formulae.md).
+For more information about deprecating, disabling and removing formulae, see the [Deprecating, Disabling and Removing Formulae](Deprecating-Disabling-and-Removing-Formulae.md) page.
 
 ## Detailed merge checklist
 
-The following checklist is intended to help maintainers decide on
-whether to merge, request changes or close a PR. It also brings more
-transparency for contributors in addition to the
-[Acceptable Formulae](Acceptable-Formulae.md) requirements.
+The following checklist is intended to help maintainers decide on whether to merge, request changes or close a PR. It also brings more transparency for contributors in addition to the [Acceptable Formulae](Acceptable-Formulae.md) requirements.
 
 - previously opened active PRs, as we would like to be fair to contributors who came first
 - patches/`inreplace` that have been applied to upstream and can be removed
-- comments in formula around `url`, as we do skip some versions (for example [vim](https://github.com/Homebrew/homebrew-core/blob/359dbb190bb3776c4d6a1f603a271dd8f186f077/Formula/vim.rb#L4) or [v8](https://github.com/Homebrew/homebrew-core/blob/359dbb190bb3776c4d6a1f603a271dd8f186f077/Formula/v8.rb#L4))
-- vendored resources that need updates (for example [emscripten](https://github.com/Homebrew/homebrew-core/commit/57126ac765c3ac5201ce53bcdebf7a0e19071eba))
-- vendored dependencies (for example [certbot](https://github.com/Homebrew/homebrew-core/pull/42966/files))
-- stable/announced release
-  - some teams use odd minor release number for tests and even for stable releases
-  - other teams drop new version with minor release 0 but promote it to stable only after a few minor releases
+- comments in formula around `url`, as we do skip some versions (for example [`vim`](https://github.com/Homebrew/homebrew-core/blob/960639ce96ae5dd4a4b60b8887f44c1475dc60db/Formula/v/vim.rb#L4) or [`v8`](https://github.com/Homebrew/homebrew-core/blob/d14753288535e01178a3cd510ef2d64b03901c01/Formula/v/v8.rb#L4))
+- vendored resources that need updates (for example [`emscripten`](https://github.com/Homebrew/homebrew-core/blob/442f9cc511ce6dfe75b96b2c83749d90dde914d2/Formula/e/emscripten.rb#L49-L67))
+- vendored dependencies (for example [`certbot`](https://github.com/Homebrew/homebrew-core/pull/42966/files))
+- stable/announced release:
+  - some teams use an odd minor release number for tests and even for stable releases
+  - other teams drop new versions with minor release 0 but promote it to stable only after a few minor releases
   - if the software uses only hosted version control (such as GitHub, GitLab or Bitbucket), the release should be tagged and if upstream marks latest/pre-releases, PR must use latest
-- does changelog mention addition/removal of dependency and is it addressed in the PR
-  - does formula depend on versioned formula (for example `python@3.7`, `go@1.10`, `erlang@17`) that can be upgraded
-- commits
+- does changelog mention addition/removal of a dependency, and is it addressed in the PR?
+  - does formula depend on versioned formula (for example `python@3.7`, `go@1.10`, `erlang@17`) that can be upgraded?
+- commits:
   - contain one formula change per commit
     - ask author to squash
     - rebase during merge
@@ -155,27 +109,27 @@ transparency for contributors in addition to the
 - bottle block is not removed
 
   Suggested reply:
-  ```
-  Please keep bottle block in place, [@BrewTestBot](https://github.com/BrewTestBot) takes care of it.
-  ```
+
+      Please keep bottle block in place; [@BrewTestBot](https://github.com/BrewTestBot) takes care of it.
+
 - is there a test block for other than checking version or printing help? Consider asking to add one
-- if CI failed
+- if CI failed:
   - due to test block - paste relevant lines and add `test failure` label
   - due to build errors - paste relevant lines and add `build failure` label
-  - due to other formulae needing revision bumps - suggest to use the following command:
-    ```
-    # in this example PR is for `libuv` formula and `urbit` needs revision bump
-    brew bump-revision --message 'for libuv' urbit
-    ```
-    - make sure it is one commit per revision bump
+  - due to other formulae needing revision bumps - suggest using the following command:
+
+        # in this example: PR is for `libuv` formula and `urbit` needs revision bump
+        brew bump-revision --message 'for libuv' urbit
+
+    - make sure it has one commit per revision bump
 - if CI is green and...
   - bottles need to be pulled, and...
     - the commits are correct, don't need changes, and BrewTestBot can merge it (doesn't have the label `automerge-skip`): approve the PR to trigger an automatic merge (use `brew pr-publish $PR_ID` to trigger manually in case of a new formula)
-    - the commits are correct and don't need changes, but BrewTestBot can't merge it (has the label `automerge-skip`), use `brew pr-publish $PR_ID`
-    - the commits need to be amended, use `brew pr-pull $PR_ID`, make changes, and `git push`
+    - the commits are correct and don't need changes, but BrewTestBot can't merge it (has the label `automerge-skip`): use `brew pr-publish $PR_ID`
+    - the commits need to be amended: use `brew pr-pull $PR_ID`, make changes, and `git push`
 - don't forget to thank the contributor
-  - celebrate the first-time contributors
-- suggest to use `brew bump-formula-pr` next time if this was not the case
+  - celebrate any first-time contributors
+- suggest using `brew bump-formula-pr` next time if this was not the case
 
 ## Common build failures and how to handle them
 
@@ -187,25 +141,55 @@ This error might pop up when parameters passed to `gcc` are in the wrong order.
 
 An example from `libmagic` formula:
 
-```
-==> brew test libmagic --verbose
-Testing libmagic
-==> /usr/bin/gcc -I/home/linuxbrew/.linuxbrew/Cellar/libmagic/5.38/include -L/home/linuxbrew/.linuxbrew/Cellar/libmagic/5.38/lib -lmagic test.c -o test
-/tmp/ccNeDVRt.o: In function `main':
-test.c:(.text+0x15): undefined reference to `magic_open'
-test.c:(.text+0x4a): undefined reference to `magic_load'
-test.c:(.text+0x81): undefined reference to `magic_file'
-collect2: error: ld returned 1 exit status
-```
+    ==> brew test libmagic --verbose
+    Testing libmagic
+    ==> /usr/bin/gcc -I/home/linuxbrew/.linuxbrew/Cellar/libmagic/5.38/include -L/home/linuxbrew/.linuxbrew/Cellar/libmagic/5.38/lib -lmagic test.c -o test
+    /tmp/ccNeDVRt.o: In function `main':
+    test.c:(.text+0x15): undefined reference to `magic_open'
+    test.c:(.text+0x4a): undefined reference to `magic_load'
+    test.c:(.text+0x81): undefined reference to `magic_file'
+    collect2: error: ld returned 1 exit status
 
 Solution:
 
 ```ruby
 if OS.mac?
-    system ENV.cc, "-I#{include}", "-L#{lib}", "-lmagic", "test.c", "-o", "test"
+  system ENV.cc, "-I#{include}", "-L#{lib}", "-lmagic", "test.c", "-o", "test"
 else
-    system ENV.cc, "test.c", "-I#{include}", "-L#{lib}", "-lmagic", "-o", "test"
+  system ENV.cc, "test.c", "-I#{include}", "-L#{lib}", "-lmagic", "-o", "test"
 end
 ```
 
 For an explanation of why this happens, read the [Ubuntu 11.04 Toolchain documentation](https://wiki.ubuntu.com/NattyNarwhal/ToolchainTransition).
+
+## Staging Branches
+
+### Summary
+
+Some formulae (e.g. Python, OpenSSL, ICU, Boost) have a large number of dependents. This makes updating these formulae (or their dependents) difficult because the standard procedure involves updating a large number of formulae in a single pull request. An alternative procedure that can significantly simplify this process is to use a staging branch.
+
+The idea of using a staging branch is to merge updates and publish bottles for the affected formula to a non-default branch. This allows work to be done incrementally in smaller PRs, instead of in one giant PR that touches many formulae. When the staging branch is ready, it can be merged to the `master`/default branch.
+
+Before making use of a staging branch, there is one important disadvantage to consider: once you have merged bottle updates to the staging branch, it is **very difficult** to take them back. This typically involves deleting uploaded bottles, which will occasionally require an owner of the Homebrew GitHub organisation to delete uploaded bottles one at a time.
+
+### How to use a staging branch
+
+Here is a rough outline of how to use a staging branch:
+
+1. Create the staging branch in [Homebrew/homebrew-core](https://github.com/Homebrew/homebrew-core). The name of the staging branch _must_ start with the name of the root formula, followed by a `-`, and end in `-staging`. You can omit the `@` and anything that follows for versioned formulae (e.g. `icu4c-staging`, `openssl-migration-staging`, `python@3.12-staging`). It might be helpful to look at the [code](https://github.com/Homebrew/brew/blob/3db1acf3e38e270af4e1c3f214622bbfb18f830e/Library/Homebrew/formula_auditor.rb#L357-L375) that parses the branch names to check whether a PR targets a staging branch.
+
+1. Open an issue in homebrew-core inviting contributors to help. Be sure to include instructions for how to do so, and a checklist of formulae that need to be updated. See [Homebrew/homebrew-core#134251](https://github.com/Homebrew/homebrew-core/issues/134251) for an example.
+
+1. Open a _draft_ PR that merges the staging branch into the `master` branch. This allows you to keep track of the work done so far. You may wish to apply the [`no long build conflict`](https://github.com/Homebrew/homebrew-core/labels/no%20long%20build%20conflict) label to this PR to avoid conflicting changes from being merged to the `master` branch.
+
+1. Open PRs targeting the staging branch that update the affected formulae. Each PR should touch as few formulae as possible. The typical PR that targets the staging branch will update only one formula at a time. Staging branch PRs can be merged using the same process as PRs that target the `master` branch. Ideally, these PRs should be opened in [topological order](https://en.wikipedia.org/wiki/Topological_sorting) according to the dependency graph, but we don't currently have good tooling for generating a topological sort. (Help wanted.)
+
+1. Label PRs that target the staging branch with the [`staging-branch-pr`](https://github.com/Homebrew/homebrew-core/labels/staging-branch-pr) label for ease of tracking and review. (TODO: Add some automation for this to homebrew-core.)
+
+1. Monitor the draft PR you created in step 3 above for merge conflicts. If you encounter a merge conflict, you must resolve those conflicts in a staging branch PR that merges the `master` branch into the staging branch.
+
+1. When the staging branch is ready to be merged into `master`, mark the draft PR as ready for review and merge it into the `master` branch. Your PR may spend a long time in the merge queue waiting for the bottle fetch tests to run.
+
+For examples of uses of the staging branch, see homebrew-core PRs labelled [`openssl-3-migration-staging`](https://github.com/Homebrew/homebrew-core/labels/openssl-3-migration), [Homebrew/homebrew-core#134260](https://github.com/Homebrew/homebrew-core/pull/134260), or [Homebrew/homebrew-core#133611](https://github.com/Homebrew/homebrew-core/pull/133611).
+
+Finally: while the use of a staging branch worked extremely well in the two instances it was used (see PRs linked in the previous paragraph), the procedure outlined above is not perfect. Suggestions for improvement are much appreciated.
diff --git a/docs/Homebrew-on-Linux.md b/docs/Homebrew-on-Linux.md
index f3a3e3f31b649..fdecb2d27d9a8 100644
--- a/docs/Homebrew-on-Linux.md
+++ b/docs/Homebrew-on-Linux.md
@@ -1,6 +1,6 @@
 ---
-logo: https://brew.sh/assets/img/linuxbrew.png
-image: https://brew.sh/assets/img/linuxbrew.png
+logo: /assets/img/linuxbrew.png
+image: /assets/img/linuxbrew.png
 redirect_from:
   - /linux
   - /Linux
@@ -9,32 +9,32 @@ redirect_from:
 
 # Homebrew on Linux
 
-The Homebrew package manager may be used on Linux and [Windows Subsystem for Linux (WSL)](https://docs.microsoft.com/en-us/windows/wsl/about). Homebrew was formerly referred to as Linuxbrew when running on Linux or WSL. It can be installed in your home directory, in which case it does not use *sudo*. Homebrew does not use any libraries provided by your host system, except *glibc* and *gcc* if they are new enough. Homebrew can install its own current versions of *glibc* and *gcc* for older distributions of Linux.
+The Homebrew package manager may be used on Linux and [Windows Subsystem for Linux (WSL)](https://docs.microsoft.com/en-us/windows/wsl/about) 2. Homebrew was formerly referred to as Linuxbrew when running on Linux or WSL. Homebrew does not use any libraries provided by your host system, except *glibc* and *gcc* if they are new enough. Homebrew can install its own current versions of *glibc* and *gcc* for older distributions of Linux.
 
 [Features](#features), [installation instructions](#install) and [requirements](#requirements) are described below. Terminology (e.g. the difference between a Cellar, Tap, Cask and so forth) is [explained in the documentation](Formula-Cookbook.md#homebrew-terminology).
 
 ## Features
 
-- Can install software to your home directory and so does not require *sudo*
 - Install software not packaged by your host distribution
 - Install up-to-date versions of software when your host distribution is old
 - Use the same package manager to manage your macOS, Linux, and Windows systems
 
 ## Install
 
-Instructions for a supported install of Homebrew on Linux are on the [homepage](https://brew.sh).
+Instructions for the best, supported install of Homebrew on Linux are on the [homepage](https://brew.sh).
 
-The installation script installs Homebrew to `/home/linuxbrew/.linuxbrew` using *sudo* if possible and within your home directory at `~/.linuxbrew` otherwise. Homebrew does not use *sudo* after installation. Using `/home/linuxbrew/.linuxbrew` allows the use of more binary packages (bottles) than installing in your personal home directory.
+The installation script installs Homebrew to `/home/linuxbrew/.linuxbrew` using *sudo*. Homebrew does not use *sudo* after installation. Using `/home/linuxbrew/.linuxbrew` allows the use of most binary packages (bottles) which will not work when installing in e.g. your personal home directory.
 
-The prefix `/home/linuxbrew/.linuxbrew` was chosen so that users without admin access can ask an admin to create a `linuxbrew` role account and still benefit from precompiled binaries. If you do not yourself have admin privileges, consider asking your admin staff to create a `linuxbrew` role account for you with home directory set to `/home/linuxbrew`.
+Technically, you can install Homebrew wherever you want. However, you shouldn't install outside the default, supported, best prefix. Many things will need to be built from source outside the default prefix. Building from source is slow, energy-inefficient, buggy and unsupported. The main reason Homebrew just works is **because** we use bottles (binary packages) and most of these require using the default prefix. If you decide to use another prefix: don't open any issues, even if you think they are unrelated to your prefix choice. They will be closed without response.
 
-Follow the *Next steps* instructions to add Homebrew to your `PATH` and to your bash shell profile script, either `~/.profile` on Debian/Ubuntu or `~/.bash_profile` on CentOS/Fedora/Red Hat.
+The prefix `/home/linuxbrew/.linuxbrew` was chosen so that users without admin access can ask an admin to create a `linuxbrew` role account and still benefit from precompiled binaries. If you do not have admin privileges, consider asking your admin staff to create a `linuxbrew` role account for you with home directory set to `/home/linuxbrew`.
+
+Follow the *Next steps* instructions to add Homebrew to your `PATH` and to your bash shell rcfile, either `~/.bashrc` for `bash` or `~/.zshrc` for `zsh`.
 
 ```sh
 test -d ~/.linuxbrew && eval "$(~/.linuxbrew/bin/brew shellenv)"
 test -d /home/linuxbrew/.linuxbrew && eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"
-test -r ~/.bash_profile && echo "eval \"\$($(brew --prefix)/bin/brew shellenv)\"" >> ~/.bash_profile
-echo "eval \"\$($(brew --prefix)/bin/brew shellenv)\"" >> ~/.profile
+echo "eval \"\$($(brew --prefix)/bin/brew shellenv)\"" >> ~/.bashrc
 ```
 
 You're done! Try installing a package:
@@ -45,10 +45,12 @@ brew install hello
 
 If you're using an older distribution of Linux, installing your first package will also install a recent version of *glibc* and *gcc*. Use `brew doctor` to troubleshoot common issues.
 
+> [!NOTE]
+> Please note that unlike macOS, Homebrew does not use a sandbox when building on Linux, so formulae may install outside the Homebrew prefix.
+
 ## Requirements
 
-- **GCC** 4.7.0 or newer
-- **Linux** 2.6.32 or newer
+- **Linux** 3.2 or newer
 - **Glibc** 2.13 or newer
 - **64-bit x86_64** CPU
 
@@ -65,20 +67,29 @@ To install build tools, paste at a terminal prompt:
   ```sh
   sudo yum groupinstall 'Development Tools'
   sudo yum install procps-ng curl file git
-  sudo yum install libxcrypt-compat # needed by Fedora 30 and up
   ```
 
-### ARM
+- **Arch Linux**
+
+  ```sh
+  sudo pacman -S base-devel procps-ng curl file git
+  ```
+
+### ARM (unsupported)
 
-Homebrew can run on 32-bit ARM (Raspberry Pi and others) and 64-bit ARM (AArch64), but no binary packages (bottles) are available. Support for ARM is on a best-effort basis. Pull requests are welcome to improve the experience on ARM platforms.
+Homebrew can run on 32-bit ARM (Raspberry Pi and others) and 64-bit ARM (AArch64), but as they lack binary packages (bottles) they are unsupported. Pull requests are welcome to improve the experience on ARM platforms.
 
 You may need to install your own Ruby using your system package manager, a PPA, or `rbenv/ruby-build` as we no longer distribute a Homebrew Portable Ruby for ARM.
 
-### 32-bit x86
+### 32-bit x86 (incompatible)
+
+Homebrew does not run at all on 32-bit x86 platforms.
+
+### Windows Subsystem for Linux (WSL) 1
 
-Homebrew does not currently support 32-bit x86 platforms. It would be possible for Homebrew to work on 32-bit x86 platforms with some effort. An interested and dedicated person could maintain a fork of Homebrew to develop support for 32-bit x86.
+Due to [known issues](https://github.com/microsoft/WSL/issues/8219) with WSL 1, you may experience issues running various executables installed by Homebrew. We recommend you switch to WSL 2 instead.
 
 ## Homebrew on Linux Community
 
 - [@HomebrewOnLinux on Twitter](https://twitter.com/HomebrewOnLinux)
-- [Homebrew/discussions (forum)](https://github.com/homebrew/discussions/discussions)
+- [Homebrew/discussions (forum)](https://github.com/orgs/Homebrew/discussions/categories/linux)
diff --git a/docs/How-To-Open-a-Homebrew-Pull-Request.md b/docs/How-To-Open-a-Homebrew-Pull-Request.md
index de77fa927591d..71322d0176b0e 100644
--- a/docs/How-To-Open-a-Homebrew-Pull-Request.md
+++ b/docs/How-To-Open-a-Homebrew-Pull-Request.md
@@ -1,91 +1,131 @@
-# How To Open a Homebrew Pull Request
+# How to Open a Homebrew Pull Request
 
-The following commands are used by Homebrew contributors to set up a fork of Homebrew's Git repository on GitHub, create a new branch and create a GitHub pull request ("PR") of the changes in that branch.
+The following commands are used by Homebrew contributors to set up a fork of Homebrew's Git repository on GitHub, create a new branch and create a GitHub pull request ("PR") for the changes in that branch.
 
-Depending on the change you want to make, you need to send the pull request to the appropriate one of Homebrew's main repositories. If you want to submit a change to Homebrew core code (the `brew` implementation), you should open the pull request on [Homebrew/brew](https://github.com/Homebrew/brew). If you want to submit a change for a formula, you should open the pull request on the [homebrew/core](https://github.com/Homebrew/homebrew-core) tap, for casks you should open the pull request on the [homebrew/cask](https://github.com/Homebrew/homebrew-cask) tap or another [official tap](https://github.com/Homebrew), based on the formula type.
+The type of change you want to make influences which of Homebrew's main repositories you'll need to send your pull request to. If you want to submit a change to Homebrew's core code (the `brew` implementation), you should open a pull request on [Homebrew/brew](https://github.com/Homebrew/brew). If you want to submit a change for a formula, you should open a pull request on the [homebrew/core](https://github.com/Homebrew/homebrew-core) tap, while for casks you should open the pull request on the [homebrew/cask](https://github.com/Homebrew/homebrew-cask) tap or another [official tap](https://github.com/Homebrew), depending on the formula type.
 
 ## Submit a new version of an existing formula
-1. Use `brew bump-formula-pr` to do everything (i.e. forking, committing, pushing) with a single command. Run `brew bump-formula-pr --help` to learn more.
+
+1. Use [`brew bump-formula-pr`](Manpage#bump-formula-pr-options-formula) to do everything (i.e. forking, committing, pushing) with a single command. Run `brew bump-formula-pr --help` to learn more.
 
 ## Submit a new version of an existing cask
-1. Use `brew bump-cask-pr` to do everything (i.e. forking, committing, pushing) with a single command. Run `brew bump-cask-pr --help` to learn more.
+
+1. Use [`brew bump-cask-pr`](Manpage#bump-cask-pr-options-cask) to do everything (i.e. forking, committing, pushing) with a single command. Run `brew bump-cask-pr --help` to learn more.
 
 ## Set up your own fork of the Homebrew repository
 
-### Core `brew` code related pull request
+### Core `brew` code pull request
 
 1. [Fork the Homebrew/brew repository on GitHub](https://github.com/Homebrew/brew/fork).
-  * This creates a personal remote repository that you can push to. This is needed because only Homebrew maintainers have push access to the main repositories.
+   * This creates a personal remote repository that you can push to. This is needed because only Homebrew maintainers have push access to the main repositories.
 2. Change to the directory containing your Homebrew installation:
-    ```sh
-    cd "$(brew --repository)"
-    ```
+
+   ```sh
+   cd "$(brew --repository)"
+   ```
+
 3. Add your pushable forked repository as a new remote:
-    ```sh
-    git remote add <YOUR_USERNAME> https://github.com/<YOUR_USERNAME>/brew.git
-    ```
-  * `<YOUR_USERNAME>` is your GitHub username, not your local machine username.
 
-### Formulae related pull request
+   ```sh
+   git remote add <YOUR_USERNAME> https://github.com/<YOUR_USERNAME>/brew.git
+   ```
+
+   * `<YOUR_USERNAME>` is your GitHub username, not your local machine username.
+
+### Formulae-related pull request
+
+Before creating a new formulae, please read [Acceptable Formulae](https://docs.brew.sh/Acceptable-Formulae).
 
 1. [Fork the Homebrew/homebrew-core repository on GitHub](https://github.com/Homebrew/homebrew-core/fork).
-  * This creates a personal remote repository that you can push to. This is needed because only Homebrew maintainers have push access to the main repositories.
-2. Change to the directory containing Homebrew formulae:
-    ```sh
-    cd "$(brew --repository homebrew/core)"
-    ```
-3. Add your pushable forked repository as a new remote:
-    ```sh
-    git remote add <YOUR_USERNAME> https://github.com/<YOUR_USERNAME>/homebrew-core.git
-    ```
-  * `<YOUR_USERNAME>` is your GitHub username, not your local machine username.
+   * This creates a personal remote repository that you can push to. This is needed because only Homebrew maintainers have push access to the main repositories.
+2. Tap (download a local clone of) the repository of core Homebrew formulae:
+
+   ```sh
+   brew tap --force homebrew/core
+   ```
 
-### Cask related pull request
+3. Change to the directory containing Homebrew formulae:
+
+   ```sh
+   cd "$(brew --repository homebrew/core)"
+   ```
+
+4. Add your pushable forked repository as a new remote:
+
+   ```sh
+   git remote add <YOUR_USERNAME> https://github.com/<YOUR_USERNAME>/homebrew-core.git
+   ```
+
+   * `<YOUR_USERNAME>` is your GitHub username, not your local machine username.
+
+### Cask-related pull request
+
+Before creating a new cask, please read [Acceptable Casks](https://docs.brew.sh/Acceptable-Casks).
 
 1. [Fork the Homebrew/homebrew-cask repository on GitHub](https://github.com/Homebrew/homebrew-cask/fork).
-  * This creates a personal remote repository that you can push to. This is needed because only Homebrew maintainers have push access to the main repositories.
-2. Change to the directory containing Homebrew casks:
-    ```sh
-    cd "$(brew --repository homebrew/cask)"
-    ```
-3. Add your pushable forked repository as a new remote:
-    ```sh
-    git remote add <YOUR_USERNAME> https://github.com/<YOUR_USERNAME>/homebrew-cask.git
-    ```
-  * `<YOUR_USERNAME>` is your GitHub username, not your local machine username.
+   * This creates a personal remote repository that you can push to. This is needed because only Homebrew maintainers have push access to the main repositories.
+2. Tap (download a local clone of) the repository of core Homebrew casks:
+
+   ```sh
+   brew tap --force homebrew/cask
+   ```
+
+3. Change to the directory containing Homebrew casks:
+
+   ```sh
+   cd "$(brew --repository homebrew/cask)"
+   ```
+
+4. Add your pushable forked repository as a new remote:
+
+   ```sh
+   git remote add <YOUR_USERNAME> https://github.com/<YOUR_USERNAME>/homebrew-cask.git
+   ```
+
+   * `<YOUR_USERNAME>` is your GitHub username, not your local machine username.
 
 ## Create your pull request from a new branch
 
-To make a new branch and submit it for review, create a GitHub pull request with the following steps:
+To make changes on a new branch and submit it for review, create a GitHub pull request with the following steps:
 
 1. Check out the `master` branch:
-    ```sh
-    git checkout master
-    ```
+
+   ```sh
+   git checkout master
+   ```
+
 2. Retrieve new changes to the `master` branch:
-    ```sh
-    brew update
-    ```
+
+   ```sh
+   brew update
+   ```
+
 3. Create a new branch from the latest `master` branch:
-    ```sh
-    git checkout -b <YOUR_BRANCH_NAME> origin/master
-    ```
+
+   ```sh
+   git checkout -b <YOUR_BRANCH_NAME> origin/master
+   ```
+
 4. Make your changes. For formulae or casks, use `brew edit` or your favourite text editor, following all the guidelines in the [Formula Cookbook](Formula-Cookbook.md) or [Cask Cookbook](Cask-Cookbook.md).
-  * If there's a `bottle do` block in the formula, don't remove or change it; we'll update it when we pull your PR.
-5. Test your changes by running the following, and ensure they all pass without issue. For changed formulae and casks, make sure you do the `brew audit` step while your changed formula/cask is installed.
-    ```sh
-    brew tests
-    brew install --build-from-source <CHANGED_FORMULA|CHANGED_CASK>
-    brew test <CHANGED_FORMULA|CHANGED_CASK>
-    brew audit --strict --online <CHANGED_FORMULA|CHANGED_CASK>
-    ```
-6. [Make a separate commit](Formula-Cookbook.md#commit) for each changed formula with `git add` and `git commit`.
-  * Please note that our preferred commit message format for simple version updates is "`<FORMULA_NAME> <NEW_VERSION>`", e.g. "`source-highlight 3.1.8`".
+   * If there's a `bottle do` block in the formula, don't remove or change it; we'll update it when we merge your PR.
+5. Test your changes by running the following, and ensure they all pass without issue. For changed formulae and casks, make sure you do the `brew audit` step after your changed formula/cask has been installed.
+
+   ```sh
+   brew tests
+   HOMEBREW_NO_INSTALL_FROM_API=1 brew install --build-from-source <CHANGED_FORMULA|CHANGED_CASK>
+   brew test <CHANGED_FORMULA|CHANGED_CASK>
+   brew audit --strict --online <CHANGED_FORMULA|CHANGED_CASK>
+   ```
+
+6. [Make a separate commit](Formula-Cookbook.md#commit) for each changed formula with `git add` and `git commit`. Each formula's commits must be squashed.
+   * Please note that our required commit message format for simple version updates is "`<FORMULA_NAME> <NEW_VERSION>`", e.g. "`source-highlight 3.1.8`".
 7. Upload your branch of new commits to your fork:
-    ```sh
-    git push --set-upstream <YOUR_USERNAME> <YOUR_BRANCH_NAME>
-    ```
-8. Go to the relevant repository (e.g. <https://github.com/Homebrew/brew>, <https://github.com/Homebrew/homebrew-core>, etc.) and create a pull request to request review and merging of the commits in your pushed branch. Explain why the change is needed and, if fixing a bug, how to reproduce the bug. Make sure you have done each step in the checklist that appears in your new PR.
+
+   ```sh
+   git push --set-upstream <YOUR_USERNAME> <YOUR_BRANCH_NAME>
+   ```
+
+8. Go to the relevant repository (e.g. <https://github.com/Homebrew/brew>, <https://github.com/Homebrew/homebrew-core>, etc.) and create a pull request to request review and merging of the commits from your pushed branch. Explain why the change is needed and, if fixing a bug, how to reproduce the bug. Make sure you have done each step in the checklist that appears in your new PR.
 9. Await feedback or a merge from Homebrew's maintainers. We typically respond to all PRs within a couple days, but it may take up to a week, depending on the maintainers' workload.
 
 Thank you!
@@ -96,7 +136,7 @@ To respond well to feedback:
 
 1. Ask for clarification of anything you don't understand and for help with anything you don't know how to do.
 2. Post a comment on your pull request if you've provided all the requested changes/information and it hasn't been merged after a week. Post a comment on your pull request if you're stuck and need help.
-  * A `needs response` label on a PR means that the Homebrew maintainers need you to respond to previous comments.
+   * A `needs response` label on a PR means that the Homebrew maintainers need you to respond to previous comments.
 3. Keep discussion in the pull request unless requested otherwise (i.e. do not email maintainers privately).
 4. Do not continue discussion in closed pull requests.
 5. Do not argue with Homebrew maintainers. You may disagree but unless they change their mind, please implement what they request. Ultimately they control what is included in Homebrew, as they have to support any changes that are made.
@@ -104,20 +144,25 @@ To respond well to feedback:
 To make changes based on feedback:
 
 1. Check out your branch again:
-    ```sh
-    git checkout <YOUR_BRANCH_NAME>
-    ```
+
+   ```sh
+   git checkout <YOUR_BRANCH_NAME>
+   ```
+
 2. Make any requested changes and commit them with `git add` and `git commit`.
 3. Squash new commits into one commit per formula:
-    ```sh
-    git rebase --interactive origin/master
-    ```
-  * If you are working on a PR for a single formula, `git commit --amend` is a convenient way of keeping your commits squashed as you go.
+
+   ```sh
+   git rebase --interactive origin/master
+   ```
+
+   * If you are working on a PR for a single formula, `git commit --amend` is a convenient way of keeping your commits squashed as you go.
 4. Push to your remote fork's branch and the pull request:
-    ```sh
-    git push --force
-    ```
 
-Once all feedback has been addressed and if it's a change we want to include (we include most changes), then we'll add your commit to Homebrew. Note that the PR status may show up as "Closed" instead of "Merged" because of the way we merge contributions. Don't worry: you will still get author credit in the actual merged commit.
+   ```sh
+   git push --force
+   ```
+
+Once all feedback has been addressed and if it's a change we want to include (we include most changes), then we'll add your changes to Homebrew. Note that the PR status may show up as "Closed" instead of "Merged" because of the way we merge contributions. Don't worry: you will still get author credit in the actual merged commit.
 
 Well done, you are now a Homebrew contributor!
diff --git a/docs/How-To-Organize-AGM.md b/docs/How-To-Organize-AGM.md
new file mode 100644
index 0000000000000..160686964e3ec
--- /dev/null
+++ b/docs/How-To-Organize-AGM.md
@@ -0,0 +1,163 @@
+# How To Organize AGM
+
+AGM is our combination of business meeting, yearly work planning session, and opportunity to meet others in our international team in person.
+
+This document is a _guide_ that assumes that the meeting will be held in person.
+If a situation occurs that prevents that, it is acceptable to execute it virtually, as was done in 2021 and 2022 during the COVID-19 pandemic.
+
+<!-- TOC start -->
+
+* [Roles](#roles)
+* [Logistics Timeline](#logistics-timeline)
+  * [Three months prior](#three-months-prior)
+  * [Two months prior](#two-months-prior)
+  * [Four weeks prior](#four-weeks-prior)
+  * [Three weeks prior](#three-weeks-prior)
+  * [Two weeks prior](#two-weeks-prior)
+  * [10 days prior](#10-days-prior)
+  * [One week prior](#one-week-prior)
+  * [Day before](#day-before)
+  * [Day-of](#day-of)
+* [Pre-planning](#pre-planning)
+  * [Finding a Meeting Venue](#finding-a-meeting-venue)
+  * [Who Qualifies For AGM Travel Assistance](#who-qualifies-for-agm-travel-assistance)
+* [Ideas for future AGMs](#ideas-for-future-agms)
+  * [Meeting enhancements](#meeting-enhancements)
+  * [Day-of enhancements](#day-of-enhancements)
+
+<!-- TOC end -->
+
+## Roles
+
+Expected participants:
+
+|Who|Role|
+|---|---|
+|Project Leadership Committee (PLC)|Should be physically present if possible, dialed-in if not. Several members must be present in person to run the event. Several members, regardless, needed to provide content for meeting.|
+|Project Leader (PL)|Should be physically present if possible, dialed-in if not. Regardless, needed to provide content for meeting.|
+|Technology Steering Committee (TSC)|Should be physically present if possible, dialed-in if not. Regardless, needed to provide content for meeting.|
+|Members|Should dial-in or participate in person if possible.|
+
+PLC members' roles of responsibility for planning and execution:
+
+|Who|Role|
+|---|---|
+|Logistics Coordinator (LC)|Coordinates with meeting venue, restaurants, members, committees, vendors|
+|Agenda Coordinator (AC)|Coordinates agenda and content to be presented|
+|Technology Coordinator (TC)|Coordinates video conference audiovisual setup|
+
+:information_source: _(A person may have more than one role but one person should not have all roles.)_
+
+## Logistics Timeline
+
+Past practice and future intent is for AGM to coincide with [FOSDEM](https://fosdem.org "Free and Open Source Developers European Meeting"), which is held in Brussels, Belgium annually typically on the Saturday and Sunday of the fifth ISO-8601 week of the calendar year, calculable with:
+
+    ruby -rdate -e "s=ARGV[0].to_i;s.upto(s+4).map{|y|Date.commercial(y,5,6)}.each{|y|puts [y,y+1].join(' - ')}" 2024
+
+AGM should be held on the Friday before or the Monday following FOSDEM.
+
+:information_source: _Regenerate the dates for the WHEN lines in the next several headers
+using this quick command:_
+
+    ruby -rdate -e "YEAR=ARGV[0].to_i;puts ([[44,YEAR-1],[49,YEAR-1]]+(1.upto(4).map{|wk|[wk, YEAR]})).map{|wk,yr|Date.commercial(yr,wk).to_s}" 2024
+
+### Three months prior
+
+**When:** Week 44 of YEAR-1 :date: `2023-10-30`
+
+* [ ] LC: Seek venue through previous contacts or RFP.
+* [ ] PLC: Notify members of eligibility to attend AGM, with date to be determined.
+  * This is primarily to enable members to begin planning travel by
+      asking for time off, requesting employer reimbursement,
+      arranging childcare or pet sitters,
+      [applying for a visa](https://5195.f2w.bosa.be/en/themes/entry/border-control/visa/visa-type-c)
+      which may [take 2–7 weeks](https://dofi.ibz.be/en/themes/third-country-nationals/short-stay/processing-time-visa-application),
+      etc.
+
+### Two months prior
+
+**When:** Week 49 of YEAR-1 :date: `2023-12-04`
+
+* [ ] LC: Seek informal count of members intending to attend in-person.
+* [ ] PL: Review maintainer activity per [Governance/Maintainers](Homebrew-Governance.md#8-maintainers).
+* [ ] PLC: Determine travel assistance budget.
+* [ ] PLC: Open travel assistance pre-approval process.
+
+### Four weeks prior
+
+**When:** Week 1 of YEAR :date: `2024-01-01`
+
+* [ ] PLC: Solicit changes to [Homebrew Governance](Homebrew-Governance.md) in the form of PRs on the `homebrew-governance-private` repository.
+
+### Three weeks prior
+
+**When:** Week 2 of YEAR :date: `2024-01-08`
+
+* [ ] PLC: Close travel assistance pre-approval process.
+
+### Two weeks prior
+
+**When:** Week 3 of YEAR :date: `2024-01-15`
+
+* [ ] AC: Create agenda, solicit agenda items from PLC and TSC.
+* [ ] LC: Seek committed member attendance and dietary requirements for each.
+* [ ] PLC: Close proposals for new Governance changes.
+
+### 10 days prior
+
+**When:** Week 4 of YEAR :date: `2024-01-22`
+
+* [ ] PLC: Resolve all open Governance PRs, roll-up changes, and open PR with changes to `docs/Homebrew-Governance.md` on `homebrew/brew`.
+
+### One week prior
+
+**When:** Week 4 of YEAR :date: `2024-01-22`
+
+* [ ] PLC: Open voting for PLC, PL, and Governance changes.
+* [ ] AC: Solicit agenda items from membership.
+* [ ] LC: Secure a venue and reservation for dinner
+
+### Day before
+
+* [ ] LC: Confirm reservation count for dinner with attendees
+* [ ] LC: Hand-off venue AV contact to TC
+
+### Day-of
+
+* [ ] LC: Confirm reservation count for dinner with venue
+* [ ] TC: Connect to video conference, ensure audiovisual equipment is ready and appropriately placed and leveled periodically
+* [ ] AC: Keep the meeting paced to the agenda, keep time for timeboxed discussions, cut people off if they're talking too long, ensure remote attendees can get a word in
+
+## Pre-planning
+
+### Finding a meeting venue
+
+In the past, PLC hosted the AGM at the
+[THON Hotel Brussels City Centre](https://www.thonhotels.com/conference/belgium/brussels/thon-hotel-brussels-city-centre/?Persons=20)
+and arranged for a room block checking in the day before FOSDEM and AGM weekend, generally on Friday, and checking out the day after, generally Tuesday when the AGM is Monday.
+
+### Who qualifies for AGM travel assistance
+
+Travel assistance is available for AGM participants who are expected to attend the AGM in-person.
+Those who have employers able to cover all or a part of the costs of attending FOSDEM should exhaust that
+source of funding before seeking Homebrew funding.
+
+PLC, TSC, PL and maintainers can expect to have all reasonable, in-policy expenses covered while members will be considered on a case-by-case basis.
+
+Read the Expense and Reimbursement policy document in `Homebrew/homebrew-governance-private`.
+It contains the process and details on what is covered.
+It is important that all attendees expecting reimbursement stay in-policy.
+
+## Ideas for future AGMs
+
+### Meeting enhancements
+
+* Captioning or transcription, or both - [White Coat Captioning](https://whitecoatcaptioning.com) could handle the live captioning and provide us that for a transcript.
+* Separate meeting runner
+  * Keep PL ideally focused on content and not agenda or tracking who's asked to speak
+  * Should be a PLC member who is not the AC, LC, or TC
+  * Should be someone happy and willing to cut people off mid-sentence and, assertively but in a friendly manner, stop conversations that are not running to time
+
+### Day-of enhancements
+
+* Track dietary requirements centrally for in-person participants
diff --git a/docs/How-to-Build-Software-Outside-Homebrew-with-Homebrew-keg-only-Dependencies.md b/docs/How-to-Build-Software-Outside-Homebrew-with-Homebrew-keg-only-Dependencies.md
index 06ae20af9d795..685a0f3cddfbb 100644
--- a/docs/How-to-Build-Software-Outside-Homebrew-with-Homebrew-keg-only-Dependencies.md
+++ b/docs/How-to-Build-Software-Outside-Homebrew-with-Homebrew-keg-only-Dependencies.md
@@ -27,13 +27,13 @@ Useful, reliable alternatives exist should you wish to use keg-only tools outsid
 You can set flags to give configure scripts or Makefiles a nudge in the right direction. An example of flag setting:
 
 ```sh
-./configure --prefix=/Users/Dave/Downloads CFLAGS="-I$(brew --prefix)/opt/openssl/include" LDFLAGS="-L$(brew --prefix)/opt/openssl/lib"
+./configure --prefix=/Users/Dave/Downloads CFLAGS="-I$(brew --prefix openssl)/include" LDFLAGS="-L$(brew --prefix openssl)/lib"
 ```
 
 An example using `pip`:
 
 ```sh
-CFLAGS="-I$(brew --prefix)/opt/icu4c/include" LDFLAGS="-L$(brew --prefix)/opt/icu4c/lib" pip install pyicu
+CFLAGS="-I$(brew --prefix icu4c)/include" LDFLAGS="-L$(brew --prefix icu4c)/lib" pip install pyicu
 ```
 
 ### `PATH` modification
@@ -41,7 +41,7 @@ CFLAGS="-I$(brew --prefix)/opt/icu4c/include" LDFLAGS="-L$(brew --prefix)/opt/ic
 You can temporarily prepend your `PATH` with the tool’s `bin` directory, such as:
 
 ```sh
-export PATH="$(brew --prefix)/opt/openssl/bin:${PATH}"
+export PATH="$(brew --prefix openssl)/bin:${PATH}"
 ```
 
 This will prepend the directory to your `PATH`, ensuring any build script that searches the `PATH` will find it first.
@@ -55,7 +55,7 @@ If the tool you are attempting to build is [pkg-config](https://en.wikipedia.org
 An example of this is:
 
 ```sh
-export PKG_CONFIG_PATH="$(brew --prefix)/opt/openssl/lib/pkgconfig"
+export PKG_CONFIG_PATH="$(brew --prefix openssl)/lib/pkgconfig"
 ```
 
 If you’re curious about the `PKG_CONFIG_PATH` variable, `man pkg-config` goes into more detail.
diff --git a/docs/How-to-Create-and-Maintain-a-Tap.md b/docs/How-to-Create-and-Maintain-a-Tap.md
index 60d87aa100d8a..9a5fcf5c1db91 100644
--- a/docs/How-to-Create-and-Maintain-a-Tap.md
+++ b/docs/How-to-Create-and-Maintain-a-Tap.md
@@ -1,92 +1,57 @@
 # How to Create and Maintain a Tap
 
-[Taps](Taps.md) are external sources of Homebrew formulae, casks  and/or external commands. They
-can be created by anyone to provide their own formulae, casks  and/or external commands
-to any Homebrew user.
+[Taps](Taps.md) are external sources of Homebrew formulae, casks and/or external commands. They can be created by anyone to provide their own formulae, casks and/or external commands to any Homebrew user.
 
 ## Creating a tap
 
-A tap is usually a Git repository available online, but you can use anything as
-long as it’s a protocol that Git understands, or even just a directory with
-files in it.
-If hosted on GitHub, we recommend that the repository’s name start with
-`homebrew-` so the short `brew tap` command can be used.
-See the [manpage](Manpage.md) for more information on repository naming.
+A tap is usually a Git repository available online, but you can use anything as long as it’s a protocol that Git understands, or even just a directory with files in it. If hosted on GitHub, we recommend that the repository’s name start with `homebrew-` so the short `brew tap` command can be used. See the [`brew` manual page](Manpage.md) for more information on repository naming.
 
-The `brew tap-new` command can be used to create a new tap along with some
-template files.
+The `brew tap-new` command can be used to create a new tap along with some template files.
 
-Tap formulae follow the same format as the core’s ones, and can be added under
-either the `Formula` subdirectory, the `HomebrewFormula` subdirectory or the
-repository’s root. The first available directory is used, other locations will
-be ignored. We recommend use of subdirectories because it makes the repository
-organisation easier to grasp, and top-level files are not mixed with formulae.
+Tap formulae follow the same format as the core’s ones, and can be added under either the `Formula` subdirectory, the `HomebrewFormula` subdirectory or the repository’s root. The first available directory is used, other locations will be ignored. We recommend the use of subdirectories because it makes the repository organisation easier to grasp, and top-level files are not mixed with formulae.
 
-See [homebrew/core](https://github.com/Homebrew/homebrew-core) for an example of
-a tap with a `Formula` subdirectory.
+See [homebrew/core](https://github.com/Homebrew/homebrew-core) for an example of a tap with a `Formula` subdirectory.
 
-## Naming your formulae to avoid clashes
+### Naming your formulae to avoid clashes
 
-If your formulae have the same name as Homebrew/homebrew-core formulae they cannot be installed side-by-side. If you wish to create a different version of a formula that's in Homebrew/homebrew-core (e.g. with `option`s) consider giving it a different name e.g. `nginx-full` for more fully-featured `nginx` formula. This will allow both `nginx` and `nginx-full` to be installed at the same time (assuming one is `keg_only` or the linked files do not clash).
+If a formula in your tap has the same name as a Homebrew/homebrew-core formula they cannot be installed side-by-side. If you wish to create a different version of a formula that's in Homebrew/homebrew-core (e.g. with `option`s) consider giving it a different name; e.g. `nginx-full` for a more full-featured `nginx` formula. This will allow both `nginx` and `nginx-full` to be installed at the same time (assuming one is [`keg_only`](https://rubydoc.brew.sh/Formula#keg_only-class_method) or the linked files do not clash).
 
-### Installing
+## Installing
 
-If it’s on GitHub, users can install any of your formulae with
-`brew install user/repo/formula`. Homebrew will automatically add your
-`github.com/user/homebrew-repo` tap before installing the formula.
-`user/repo/formula` points to the `github.com/user/homebrew-repo/**/formula.rb`
-file here.
+If it’s on GitHub, users can install any of your formulae with `brew install user/repo/formula`. Homebrew will automatically add your `github.com/user/homebrew-repository` tap before installing the formula. `user/repo/formula` points to the `github.com/user/homebrew-repo/**/formula.rb` file here.
 
-If they want to get your tap without installing any formula at the same time,
-users can add it with the [`brew tap` command](Taps.md).
+To install your tap without installing any formula at the same time, users can add it with the [`brew tap` command](Taps.md). If it’s on GitHub, they can use `brew tap user/repository`, where `user` is your GitHub username and `homebrew-repository` is your repository. If it’s hosted outside of GitHub, they have to use `brew tap user/repo <URL>`, where `user` and `repository` will be used to refer to your tap and `<URL>` is your Git clone URL.
 
-If it’s on GitHub, they can use `brew tap user/repo`, where `user` is your
-GitHub username and `homebrew-repo` is your repository.
-
-If it’s hosted outside of GitHub, they have to use `brew tap user/repo <URL>`,
-where `user` and `repo` will be used to refer to your tap and `<URL>` is your
-Git clone URL.
-
-Users can then install your formulae either with `brew install foo` if there’s
-no core formula with the same name, or with `brew install user/repo/foo` to
-avoid conflicts.
+Users can then install your formulae either with `brew install foo` if there’s no core formula with the same name, or with `brew install user/repo/foo` to avoid conflicts.
 
 ## Maintaining a tap
 
-A tap is just a Git repository so you don’t have to do anything specific when
-making modifications, apart from committing and pushing your changes.
+A tap is just a Git repository so you don’t have to do anything specific when making modifications, apart from committing and pushing your changes.
 
 ### Updating
 
-Once your tap is installed, Homebrew will update it each time a user runs
-`brew update`. Outdated formulae will be upgraded when a user runs
-`brew upgrade`, like core formulae.
+Once your tap is installed, Homebrew will update it each time a user runs `brew update`. Outdated formulae will be upgraded when a user runs `brew upgrade`, like core formulae.
 
 ## Casks
 
-Casks can also be installed from a tap.
-Casks can be included in taps with formulae, or in a tap with just casks.
-Place any cask files you wish to make available in a `Casks` directory at the top level of your tap.
+Casks can also be installed from a tap. Casks can be included in taps with formulae, or in a tap with just casks. Place any cask files you wish to make available in a `Casks` directory at the top level of your tap.
 
 See [homebrew/cask](https://github.com/Homebrew/homebrew-cask) for an example of a tap with a `Casks` subdirectory.
 
 ### Naming
 
-Unlike formulae, casks must have globally unique names to avoid clashes.
-This can be achieved by e.g. prepending the cask name with your github username: `username-formula-name`.
+Unlike formulae, casks must have globally unique names to avoid clashes. This can be achieved by e.g. prepending the cask name with your github username: `username-formula-name`.
 
 ## External commands
 
-You can provide your tap users with custom `brew` commands by adding them in a
-`cmd` subdirectory. [Read more on external commands](External-Commands.md).
+You can provide your tap users with custom `brew` commands by adding them in a `cmd` subdirectory. [Read more on external commands](External-Commands.md).
 
-See [homebrew/aliases](https://github.com/Homebrew/homebrew-aliases) for an
-example of a tap with external commands.
+See [homebrew/aliases](https://github.com/Homebrew/homebrew-aliases) for an example of a tap with external commands.
 
-## Official Vendor Taps
+## Upstream taps
 
 Some upstream software providers like to package their software in their own Homebrew tap. When their software is [eligible for Homebrew/homebrew-core](Acceptable-Formulae.md) we prefer to maintain software there for ease of updates, improved discoverability and use of tools such as [formulae.brew.sh](https://formulae.brew.sh).
 
-We are not willing to remove software packaged in Homebrew/homebrew-core in favour of an upstream tap. We are not willing to instruct users in our formulae to use your formulae instead. If upstream projects have issues with how Homebrew packages your software: please file issues (or, ideally, pull requests) to address these problems.
+We are not willing to remove software packaged in Homebrew/homebrew-core in favour of an upstream tap. We are not willing to instruct users of our formulae to use an upstream tap instead. If upstream projects have issues with how Homebrew packages your software: please file issues (or, ideally, pull requests) to address these problems.
 
 There’s an increasing desire in commercial open source about “maintaining control” e.g. defining exactly what binaries are shipping to users. Not supporting users (or even software distributions) to build-from-source is antithetical to the values of open source. If you think Homebrew's perspective is annoying on this: try and see how Debian responds to requests to ship your binaries.
diff --git a/docs/Installation.md b/docs/Installation.md
index 72dd8cdad70f9..dbd758b113cab 100644
--- a/docs/Installation.md
+++ b/docs/Installation.md
@@ -2,28 +2,51 @@
 
 Instructions for a supported install of Homebrew are on the [homepage](https://brew.sh).
 
-This script installs Homebrew to its preferred prefix (`/usr/local` for macOS Intel, `/opt/homebrew` for Apple Silicon and `/home/linuxbrew/.linuxbrew` for Linux) so that [you don’t need sudo](FAQ.md#why-does-homebrew-say-sudo-is-bad) when you `brew install`. It is a careful script; it can be run even if you have stuff installed in the preferred prefix already. It tells you exactly what it will do before it does it too. You have to confirm everything it will do before it starts.
+The script installs Homebrew to its default, supported, best prefix (`/opt/homebrew` for Apple Silicon, `/usr/local` for macOS Intel and `/home/linuxbrew/.linuxbrew` for Linux) so that [you don’t need *sudo* after Homebrew's initial installation](FAQ.md#why-does-homebrew-say-sudo-is-bad) when you `brew install`. This prefix is required for most bottles (binary packages) to be used. It is a careful script; it can be run even if you have stuff installed in the preferred prefix already. It tells you exactly what it will do before it does it too. You have to confirm everything it will do before it starts.
+
+The macOS `.pkg` installer also installs Homebrew to its default prefix (`/opt/homebrew` for Apple Silicon and `/usr/local` for macOS Intel) for the same reasons as above. It's available on [Homebrew/brew's latest GitHub release](https://github.com/Homebrew/brew/releases/latest). To specify an alternate install user, like in situations where the package is installed at the login window before a user has logged in, write a property list file to `/var/tmp/.homebrew_pkg_user.plist` with the value `HOMEBREW_PKG_USER`. For example, `defaults write /var/tmp/.homebrew_pkg_user HOMEBREW_PKG_USER penny`. The file and user must exist prior to install.
 
 ## macOS Requirements
 
 * A 64-bit Intel CPU or Apple Silicon CPU <sup>[1](#1)</sup>
-* macOS Catalina (10.15) (or higher) <sup>[2](#2)</sup>
+* macOS Ventura (13) (or higher) <sup>[2](#2)</sup>
 * Command Line Tools (CLT) for Xcode (from `xcode-select --install` or
   [https://developer.apple.com/download/all/](https://developer.apple.com/download/all/)) or
   [Xcode](https://itunes.apple.com/us/app/xcode/id497799835) <sup>[3](#3)</sup>
 * The Bourne-again shell for installation (i.e. `bash`) <sup>[4](#4)</sup>
 
-## Git Remote Mirroring
+## Advanced Configuration
+
+The Homebrew installer offers various advanced configuration settings. **Most users can skip this section and instead follow the instructions on the [homepage](https://brew.sh)!**
 
-You can use geolocalized Git mirrors to speed up Homebrew's installation and `brew update` by setting `HOMEBREW_BREW_GIT_REMOTE` and/or `HOMEBREW_CORE_GIT_REMOTE` in your shell environment with this script:
+### Git Remote Mirroring
+
+If you have issues connecting to GitHub.com, you can use Git mirrors for Homebrew's installation and `brew update` by setting `HOMEBREW_BREW_GIT_REMOTE` and/or `HOMEBREW_CORE_GIT_REMOTE` in your shell environment with this script:
 
 ```bash
 export HOMEBREW_BREW_GIT_REMOTE="..."  # put your Git mirror of Homebrew/brew here
 export HOMEBREW_CORE_GIT_REMOTE="..."  # put your Git mirror of Homebrew/homebrew-core here
-/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
 ```
 
-The default Git remote will be used if the corresponding environment variable is unset.
+The default Git remote will be used if the corresponding environment variable is unset and works best for most users.
+
+**Note:** if you set these variables you are granting these repositories the same level of trust you currently grant to Homebrew itself. You should be extremely confident that these repositories will not be compromised.
+
+### Default Tap Cloning
+
+You can instruct Homebrew to return to pre-4.0.0 behaviour by cloning the Homebrew/homebrew-core tap during installation by setting the `HOMEBREW_NO_INSTALL_FROM_API` environment variable with the following:
+
+```bash
+export HOMEBREW_NO_INSTALL_FROM_API=1
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+```
+
+This will make Homebrew install formulae and casks from the `homebrew/core` and `homebrew/cask` taps using local checkouts of these repositories instead of Homebrew’s API. Unless you are a Homebrew maintainer or contributor, you should probably not globally enable this setting. It can easily be enabled later after installation should it be necessary.
+
+### Unattended installation
+
+If you want a non-interactive run of the Homebrew installer that doesn't prompt for passwords (e.g. in automation scripts), prepend [`NONINTERACTIVE=1`](https://github.com/Homebrew/install/#install-homebrew-on-macos-or-linux) to the installation command.
 
 ## Alternative Installs
 
@@ -31,27 +54,23 @@ The default Git remote will be used if the corresponding environment variable is
 
 Check out [the Homebrew on Linux installation documentation](Homebrew-on-Linux.md).
 
-### Untar anywhere
-
-Just extract (or `git clone`) Homebrew wherever you want. Just avoid:
+### Untar anywhere (unsupported)
 
-* Directories with names that contain spaces. Homebrew itself can handle spaces, but many build scripts cannot.
-* `/tmp` subdirectories because Homebrew gets upset.
-* `/sw` and `/opt/local` because build scripts get confused when Homebrew is there instead of Fink or MacPorts, respectively.
+Technically, you can just extract (or `git clone`) Homebrew wherever you want. However, you shouldn't install outside the default, supported, best prefix. Many things will need to be built from source outside the default prefix. Building from source is slow, energy-inefficient, buggy and unsupported. The main reason Homebrew just works is **because** we use bottles (binary packages) and most of these require using the default prefix. If you decide to use another prefix: don't open any issues, even if you think they are unrelated to your prefix choice. They will be closed without response.
 
-However do yourself a favour and use the installer to install to the default prefix. Some things may not build when installed elsewhere. One of the reasons Homebrew just works relative to the competition is **because** we recommend installing here. *Pick another prefix at your peril!*
+**TL;DR: pick another prefix at your peril!**
 
 ```sh
-mkdir homebrew && curl -L https://github.com/Homebrew/brew/tarball/master | tar xz --strip 1 -C homebrew
+mkdir homebrew && curl -L https://github.com/Homebrew/brew/tarball/master | tar xz --strip-components 1 -C homebrew
 ```
 
-or
+or:
 
 ```sh
 git clone https://github.com/Homebrew/brew homebrew
 ```
 
-then
+then:
 
 ```sh
 eval "$(homebrew/bin/brew shellenv)"
@@ -59,22 +78,24 @@ brew update --force --quiet
 chmod -R go-w "$(brew --prefix)/share/zsh"
 ```
 
-### Multiple installations
+Make sure you avoid installing into:
 
-Create a Homebrew installation wherever you extract the tarball. Whichever `brew` command is called is where the packages will be installed. You can use this as you see fit, e.g. to have a system set of libs in the default prefix and tweaked formulae for development in `~/homebrew`.
+* Directories with names that contain spaces. Homebrew itself can handle spaces, but many build scripts cannot.
+* `/tmp` subdirectories because Homebrew gets upset.
+* `/sw` and `/opt/local` because build scripts get confused when Homebrew is there instead of Fink or MacPorts, respectively.
 
-### Unattended installation
+### Multiple installations (unsupported)
 
-If you want a non-interactive run of the Homebrew installer that doesn't prompt for passwords (e.g. in automation scripts), prepend [`NONINTERACTIVE=1`](https://github.com/Homebrew/install/#install-homebrew-on-macos-or-linux) to the installation command.
+Create a Homebrew installation wherever you extract the tarball. Whichever `brew` command is called is where the packages will be installed. You can use this as you see fit, e.g. to have a system set of libs in the default prefix and tweaked formulae for development in `~/homebrew`.
 
 ## Uninstallation
 
-Uninstallation is documented in the [FAQ](FAQ.md).
+Uninstallation is documented in the [FAQ](FAQ.md#how-do-i-uninstall-homebrew).
 
-<a name="1"><sup>1</sup></a> For 32-bit or PPC support see [Tigerbrew](https://github.com/mistydemeo/tigerbrew).
+<a data-proofer-ignore name="1"><sup>1</sup></a> For 32-bit or PPC support see [Tigerbrew](https://github.com/mistydemeo/tigerbrew).
 
-<a name="2"><sup>2</sup></a> 10.15 or higher is recommended, while 10.11–10.14 are supported on a best-effort basis. For 10.4–10.6 see [Tigerbrew](https://github.com/mistydemeo/tigerbrew).
+<a data-proofer-ignore name="2"><sup>2</sup></a> macOS 13 (Ventura) or higher is best and supported, 10.11 (El Capitan) – 12 (Monterey) are unsupported but may work and 10.10 (Yosemite) and older will not run Homebrew at all. For 10.4 (Tiger) – 10.6 (Snow Leopard) see [Tigerbrew](https://github.com/mistydemeo/tigerbrew).
 
-<a name="3"><sup>3</sup></a> Most formulae require a compiler. A handful require a full Xcode installation. You can install Xcode, the CLT, or both; Homebrew supports all three configurations. Downloading Xcode may require an Apple Developer account on older versions of Mac OS X. Sign up for free at [Apple's website](https://developer.apple.com/register/index.action).
+<a data-proofer-ignore name="3"><sup>3</sup></a> You may need to install Xcode, the CLT, or both depending on the formula, to install a bottle (binary package) which is the only supported configuration. Downloading Xcode may require an Apple Developer account on older versions of Mac OS X. Sign up for free at [Apple's website](https://developer.apple.com/account/).
 
-<a name="4"><sup>4</sup></a> The one-liner installation method found on [brew.sh](https://brew.sh) requires the Bourne-again shell, i.e. `bash`. Notably, `zsh`, `fish`, `tcsh` and `csh` will not work.
+<a data-proofer-ignore name="4"><sup>4</sup></a> The one-liner installation method found on [brew.sh](https://brew.sh) uses the Bourne-again shell at `/bin/bash`. Notably, `zsh`, `fish`, `tcsh` and `csh` will not work.
diff --git a/docs/Interesting-Taps-and-Forks.md b/docs/Interesting-Taps-and-Forks.md
index c478a4f5716b5..42f0b1207c98a 100644
--- a/docs/Interesting-Taps-and-Forks.md
+++ b/docs/Interesting-Taps-and-Forks.md
@@ -1,4 +1,4 @@
-# Interesting Taps & Forks
+# Interesting Taps and Forks
 
 A [tap](Taps.md) is Homebrew-speak for a Git repository containing additional formulae.
 
@@ -8,6 +8,8 @@ Your taps are Git repositories located at `$(brew --repository)/Library/Taps`.
 
 ## Unsupported interesting taps
 
+* [DomT4/autoupdate](https://github.com/DomT4/homebrew-autoupdate): An external command to automatically run `brew update` (and optionally `brew upgrade` or `brew cleanup`) in the background with `launchd`.
+
 * [homebrew-ffmpeg/ffmpeg](https://github.com/homebrew-ffmpeg/homebrew-ffmpeg): A tap for FFmpeg with additional options, including nonfree additions.
 
 * [denji/nginx](https://github.com/denji/homebrew-nginx): A tap for NGINX modules, intended for its `nginx-full` formula which includes more module options.
@@ -30,6 +32,8 @@ Your taps are Git repositories located at `$(brew --repository)/Library/Taps`.
 
 * [cloudflare/cloudflare](https://github.com/cloudflare/homebrew-cloudflare): Formulae for the applications by Cloudflare, including curl with HTTP/3 support.
 
+* [apple/apple](https://github.com/apple/homebrew-apple): Formulae from Apple, including the Game Porting Toolkit.
+
 ## Unsupported interesting forks
 
 * [mistydemeo/tigerbrew](https://github.com/mistydemeo/tigerbrew): Experimental Tiger/Leopard PowerPC version.
diff --git a/docs/License-Guidelines.md b/docs/License-Guidelines.md
index 2b626b31cfc7b..96f632105e973 100644
--- a/docs/License-Guidelines.md
+++ b/docs/License-Guidelines.md
@@ -1,6 +1,6 @@
 # License Guidelines
 
-We only accept formulae that use a [Debian Free Software Guidelines license](https://wiki.debian.org/DFSGLicenses) or are released into the public domain following [DFSG Guidelines on Public Domain software](https://wiki.debian.org/DFSGLicenses#Public_Domain).
+We only accept formulae that use a [Debian Free Software Guidelines license](https://wiki.debian.org/DFSGLicenses) or are released into the public domain following [DFSG Guidelines on Public Domain software](https://wiki.debian.org/DFSGLicenses#Public_Domain) into `homebrew/core`.
 
 ## Specifying a License
 
@@ -26,7 +26,7 @@ license :cannot_represent
 
 ## Complex SPDX License Expressions
 
-Some formulae have multiple licenses that need to be combined in different ways. In these cases, a more complex license expression can be used. These expressions are based on the [SPDX License Expression Guidelines](https://spdx.github.io/spdx-spec/appendix-IV-SPDX-license-expressions/).
+Some formulae have multiple licenses that need to be combined in different ways. In these cases, a more complex license expression can be used. These expressions are based on the [SPDX License Expression Guidelines](https://spdx.github.io/spdx-spec/latest/annexes/spdx-license-expressions/).
 
 Add a `+` to indicate that the user can choose a later version of the same license:
 
@@ -68,8 +68,8 @@ These expressions can be nested as needed:
 license any_of: [
   "MIT",
   :public_domain,
-  all_of: ["0BSD", "Zlib", "Artistic-1.0+"],
-  "Apache-2.0" => { with: "LLVM-exception" },
+  { all_of: ["0BSD", "Zlib", "Artistic-1.0+"],
+  "Apache-2.0" => { with: "LLVM-exception" } },
 ]
 ```
 
@@ -77,7 +77,7 @@ license any_of: [
 
 The `HOMEBREW_FORBIDDEN_LICENSES` environment variable can be set to forbid installation of formulae that require or have dependencies that require certain licenses.
 
-The `HOMEBREW_FORBIDDEN_LICENSES` should be set to a space separated list of licenses. Use `public_domain` to forbid installation of formulae with a `:public_domain` license.
+The `HOMEBREW_FORBIDDEN_LICENSES` should be set to a space-separated list of licenses. Use `public_domain` to forbid installation of formulae with a `:public_domain` license.
 
 For example, the following forbids installation of `MIT`, `Artistic-1.0` and `:public_domain` licenses:
 
@@ -109,7 +109,7 @@ license any_of: ["MIT", "0BSD"]
 export HOMEBREW_FORBIDDEN_LICENSES="Artistic-1.0+"
 ```
 
-For GNU licenses (such as `GPL`, `LGPL`, `AGPL` and `GFDL`), use `-only` or `-or-later`. For example, the following would forbid `GPL-2.0`, `LGPL-2.1` and `LGPL-3.0` formulae from being installed, but would allow `GPL-3.0`
+For GNU licenses (such as `GPL`, `LGPL`, `AGPL` and `GFDL`), use `-only` or `-or-later`. For example, the following would forbid `GPL-2.0`, `LGPL-2.1` and `LGPL-3.0` formulae from being installed, but would allow `GPL-3.0`:
 
 ```bash
 export HOMEBREW_FORBIDDEN_LICENSES="GPL-2.0-only LGPL-2.1-or-later"
diff --git a/docs/Linux-CI.md b/docs/Linux-CI.md
new file mode 100644
index 0000000000000..a06ff70c104f8
--- /dev/null
+++ b/docs/Linux-CI.md
@@ -0,0 +1,40 @@
+# Linux CI in `homebrew/core`
+
+We currently use Ubuntu 22.04 for bottling in `homebrew/core`.
+
+## Ubuntu vs. other Linux distributions
+
+As of 2022, around 77% of our users are using Ubuntu. This is the reason why we have chosen this distribution for our base CI image.
+We have successfully used Ubuntu for CI since version 14.04.
+The Ubuntu LTS versions are supported for 5 years. A new LTS version is released every 2 years.
+
+Our bottles are compatible with other distributions like Debian/CentOS, even when compiled on Ubuntu.
+
+## Past and next versions
+
+We have moved our CI to Ubuntu 22.04
+
+Moving from Ubuntu 16.04 to Ubuntu 22.04 (and thus skipping version 18.04 and 20.04) took longer than expected.
+
+We plan to proceed with regular updates from 2022 onwards. We aim to use the latest Ubuntu LTS version for our CI.
+
+We will start using the latest Ubuntu LTS version for our CI no earlier than 3 months after its release and, ideally, no more than 12 months after its release.
+
+| Distribution | Glibc | GCC | LTS standard security maintenance |
+|---|---|---|---|
+| Ubuntu 14.04 | 2.19 | 4 | From 2014 to 2017 |
+| Ubuntu 16.04 | 2.23 | 5 | From 2017 to 2022 |
+| Ubuntu 20.04 | 2.31 | 5 | From 2020 to 2025 |
+| Ubuntu 22.04 | 2.35 | 11 | From 2022 to 2027 |
+| Ubuntu 24.04 | 2.39 | 13 | From 2024 to 2029 |
+| Ubuntu 26.04 | ? | ? | ? |
+
+[Source](https://ubuntu.com/about/release-cycle)
+
+## Why always use the latest version?
+
+Homebrew is a rolling-release package manager. We try to ship the newest things as quickly as possible, on macOS and Linux.
+
+When a formula needs a newer GCC because our host GCC in CI is too old, we needed to make that formula depend on a newer Homebrew GCC. All C++ dependents of that formula immediately acquire a dependency on Homebrew GCC as well. While we have taken the steps to make sure this no longer holds up GCC updates, it still creates a maintenance burden. This problem is more likely for formula which are very actively maintained and try to use newer features of C++. We decided that we shouldn't have a maintenance burden for formulae which are doing the right thing by staying up to date. It makes a lot of sense for Homebrew maintainers to submit upstream fixes when formulae are not working with newer compilers. It makes a lot less sense for Homebrew maintainers to submit fixes because our host compiler is too old.
+
+Note that `glibc` will need to be installed for more users as their `glibc` version will often be too old: disk space is cheap and we have can handle this situation for our users. This situation will often arise when update to a new LTS version and adoption of the new Ubuntu is still low during the first months. For the same reasons as above: we prefer to stay on the bleeding edge and give our users a gentle nudge to think about updating their OS.
diff --git a/docs/Maintainer-Guidelines.md b/docs/Maintainer-Guidelines.md
index 3aaba1f199dd3..ce3c2e7256e7e 100644
--- a/docs/Maintainer-Guidelines.md
+++ b/docs/Maintainer-Guidelines.md
@@ -1,35 +1,48 @@
 # Maintainer Guidelines
 
-**This guide is for maintainers.** These special people have **write
-access** to Homebrew’s repository and help merge the contributions of
-others. You may find what is written here interesting, but it’s
-definitely not a beginner’s guide.
+**This guide is for maintainers.** These special people have **write access** to Homebrew’s repository and help merge the contributions of others. You may find what is written here interesting, but it’s definitely not a beginner’s guide.
 
 Maybe you were looking for the [Formula Cookbook](Formula-Cookbook.md) or [Cask Cookbook](Cask-Cookbook.md)?
 
 ## Overview
 
-All Homebrew maintainers are encouraged to contribute to all parts of the project,
-but there are four main teams that maintainers tend to be a part of:
-
-- `brew` maintainers: this team maintains the [`Homebrew/brew`](https://github.com/Homebrew/brew) repository.
-  See the [Homebrew/brew Maintainer Guide](Homebrew-brew-Maintainer-Guide.md) for more details about being a `brew` maintainer.
-- Core maintainers: this team maintains the [`Homebrew/homebrew-core`](https://github.com/Homebrew/homebrew-core)
-  repository. See the [Homebrew/homebrew-core Maintainer Guide](Homebrew-homebrew-core-Maintainer-Guide.md)
-  for more details about being a core maintainer.
-- Linux maintainers: this team maintains the [`Homebrew/homebrew-core`](https://github.com/Homebrew/homebrew-core)
-  repository on Linux.
-- Cask maintainers: this team maintains the [`Homebrew/homebrew-cask`](https://github.com/Homebrew/homebrew-cask),
-  [`Homebrew/homebrew-cask-drivers`](https://github.com/Homebrew/homebrew-cask-drivers),
-  [`Homebrew/homebrew-cask-fonts`](https://github.com/Homebrew/homebrew-cask-fonts) and
-  [`Homebrew/homebrew-cask-versions`](https://github.com/Homebrew/homebrew-cask-versions) repositories.
-  See the [Homebrew/homebrew-cask Maintainer Guide](Homebrew-homebrew-cask-Maintainer-Guide.md)
-  for more details about being a cask maintainer.
-
-These documents are meant to serve as guiding principles. As a maintainer, you can make a call to either
-request changes from a contributor or help them out based on their comfort and previous contributions.
-Remember, as a team we [Prioritise Maintainers Over Users](Maintainers-Avoiding-Burnout.md) to avoid
-burnout. If you wish to change or discuss any of the guidelines: open a PR to suggest a change.
+All Homebrew maintainers are encouraged to contribute to all parts of the project, but there are four main teams that maintainers tend to be a part of:
+
+- `brew` maintainers: this team maintains the [`Homebrew/brew`](https://github.com/Homebrew/brew) repository. See the [Homebrew/brew Maintainer Guide](Homebrew-brew-Maintainer-Guide.md) for more details about being a `brew` maintainer.
+- Core maintainers: this team maintains the [`Homebrew/homebrew-core`](https://github.com/Homebrew/homebrew-core) repository. See the [Homebrew/homebrew-core Maintainer Guide](Homebrew-homebrew-core-Maintainer-Guide.md) for more details about being a core maintainer.
+- Linux maintainers: this team maintains the [`Homebrew/homebrew-core`](https://github.com/Homebrew/homebrew-core) repository on Linux.
+- Cask maintainers: this team maintains the [`Homebrew/homebrew-cask`](https://github.com/Homebrew/homebrew-cask) repository. See the [Homebrew/homebrew-cask Maintainer Guide](Homebrew-homebrew-cask-Maintainer-Guide.md) for more details about being a cask maintainer.
+
+These documents are meant to serve as guiding principles. As a maintainer, you can make a call to either request changes from a contributor or help them out based on their comfort and previous contributions. Remember, as a team we [Prioritise Maintainers Over Users](Maintainers-Avoiding-Burnout.md) to avoid burnout. If you wish to change or discuss any of the guidelines: open a PR to suggest a change.
+
+## Reviewing PRs
+
+When reviewing a PR, use "approve", "approve with comments", "comment" or "request changes" when submitting based on the following guidelines:
+
+- ✅ Approve: if you feel that the PR looks good as is, you can ✅ approve it as-is.
+- ✅ Approve with comments: if you have a few questions or comments to be answered and the PR can be merged after they are addressed, you can ✅ approve with comments.
+  - Please trust that other maintainers will not merge the PR until the comments are addressed rather than e.g. making them wait another 24h to get another review.
+  - If auto-merge is enabled: don't worry, PRs need to have comments manually resolved before they are automatically merged.
+    Please feel free to ✅ approve or ✅ approve with comments even if others have just commented and it will not be merged until the author has resolved the comments.
+- 🗣️ Comment: if you need to ask questions before you can provide a ✅ approval but are fine with someone else providing a ✅ approval before you, provide a comment review and ask questions.
+- 🚫 Request changes: a last resort.
+  - When reviewing non-maintainers' PRs: this means "these changes must be made before this PR should be merged by anyone".
+    Other maintainers can dismiss this review when these changes have been made.
+  - When reviewing others maintainers' PRs: this is to be avoided whenever possible.
+    - Save it for "if this PR is merged before I personally have had a chance to ✅ approve it: it seems very likely to cause user-visible problems".
+    - It may be used by the Project Leader for "this functionality is not acceptable in Homebrew".
+      In that case: additional code changes should be held off until there's agreement that the functionality is acceptable.
+
+Relatedly:
+
+- The default option should be to ✅ approve, with or without comments.
+- Whenever possible, you should try to use the GitHub "suggestion" feature to edit the code how you would like it to be.
+  If you don't have time or can't be bothered: you probably don't have the time to review the PR properly.
+- We're a globally distributed team and this helps us move faster.
+- The PR review process is primarily a security measure, not a way to get consensus on the perfect code style before merging.
+- It is easy to make changes on a PR after approval, make follow-up PRs to address comments or revert PRs before a tag.
+- It is (nearly) impossible to merge a PR without approval.
+- Using `gh pr checkout <URL>` is a super easy way to check out a PR branch using the GitHub CLI.
 
 ## Mission
 
@@ -39,31 +52,25 @@ Homebrew aims to be the missing package manager for macOS (and Linux). Its prima
 
 1. [Ensure you have set your username and email address properly](https://help.github.com/articles/setting-your-email-in-git/)
 2. Sign off cherry-picks if you amended them (use `git -s`)
-3. If the commit fixes a bug, use “Fixes \#104” syntax to close the bug report and link to the commit
+3. If your commit fixes a bug, use [issue linking syntax](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue) (e.g. “Fixes \#104”) to close the bug report and link back to the commit
 
 ### Add comments
 
-It may be enough to refer to an issue ticket, but make sure changes are clear so that
-if you came to them unaware of the surrounding issues they would make sense
-to you. Many times on other projects I’ve seen code removed because the
-new guy didn’t know why it was there. Regressions suck.
+It may be enough to refer to an issue ticket, but make sure changes and context are clear enough so that anyone reading them for the first time can make sense of them. You don't want code you wrote to be removed because the someone new doesn’t understand why it’s there. Regressions suck.
+
+This also applies to issue and PR bodies. Be as explicit as possible. If a pull request is part of a larger initiative: link to a relevant tracking issue. If there isn't a tracking issue yet: create one to improve communication and get consensus.
 
 ### Don’t allow bloated diffs
 
-Amend a cherry-pick to remove commits that are only changes in
-whitespace. They are not acceptable because our history is important and
-`git blame` should be useful.
+Amend a cherry-pick to remove commits that are only changes in whitespace. They are not acceptable because our history is important and `git blame` should be useful.
 
-Whitespace corrections (to Ruby standard etc.) are allowed (in fact this
-is a good opportunity to do it) provided the line itself has some kind
-of modification that is not whitespace in it. But be careful about
-making changes to inline patches—make sure they still apply.
+Whitespace corrections (to Ruby standard etc.) are allowed (in fact this is a good opportunity to do it) provided the line itself has some kind of modification that is more than just whitespace changes. But be careful about making changes to inline patches—make sure they still apply.
 
 ### Closing issues/PRs
 
-Maintainers (including the lead maintainer) should not close issues or pull requests (note a merge is not considered a close in this case) opened by other maintainers unless they are stale (i.e. have seen no updates for 28 days) in which case they can be closed by any maintainer. Any maintainer is encouraged to reopen a closed issue when they wish to do additional work on the issue.
+Maintainers (including the project leader) should not close issues or pull requests (note a merge is not considered a close in this case) opened by other maintainers unless they are stale in which case they can be closed by any maintainer. Any maintainer is encouraged to reopen a closed issue when they wish to do additional work on the issue.
 
-Any maintainer can merge any PR they have carefully reviewed and is passing CI that has been opened by any other maintainer. If you do not wish to have other maintainers merge your PRs: please use the `do not merge` label to indicate that until you're ready to merge it yourself.
+Any maintainer can merge any PR they have carefully reviewed and is passing CI that has been opened by any other maintainer. If you do not wish to have other maintainers merge your PRs: please use the draft pull request status to indicate that until you're ready to merge it yourself.
 
 ## Reverting PRs
 
@@ -71,13 +78,13 @@ Any maintainer can revert a PR created by another maintainer after a user submit
 
 ### Give time for other maintainers to review
 
-PRs that are an "enhancement" to existing functionality i.e. not a fix to an open user issue/discussion, not a version bump, not a security fix, not a fix for CI failure, a usability improvement, a new feature, refactoring etc. should wait 24h Monday - Friday before being merged. For example,
+PRs that are an "enhancement" to existing functionality, i.e. not a fix to an open user issue/discussion, not a version bump, not a security fix, not a fix for CI failure, a usability improvement, a new feature, refactoring etc. should wait 24h Monday to Friday before being merged. For example,
 
 - a new feature PR submitted at 5pm on Thursday should wait until 5pm on Friday before it is merged
 - a usability fix PR submitted at 5pm on Friday should wait until 5pm on Monday before it is merged
 - a user-reported issue fix PR can be merged immediately after CI is green
 
-If a maintainer is on holiday/vacation/sick during this time and leaves comments after they are back: please treat post-merge PR comments and feedback as you would left within the time period and follow-up with another PR to address their requests (if agreed).
+If a maintainer is on holiday/vacation/sick during this time and leaves comments after they are back: please treat post-merge PR comments and feedback as you would if left within the time period and follow-up with another PR to address their requests (if agreed).
 
 The vast majority of `Homebrew/homebrew-core` PRs are bug fixes or version bumps which can be self-merged once CI has completed.
 
@@ -93,6 +100,6 @@ All communication should ideally occur in public on GitHub. Where this is not po
 
 This makes it easier for other maintainers, contributors and users to follow along with what we're doing (and, more importantly, why we're doing it) and means that decisions have a linkable URL.
 
-All maintainers (and lead maintainer) communication through any medium is bound by [Homebrew's Code of Conduct](https://github.com/Homebrew/.github/blob/HEAD/CODE_OF_CONDUCT.md#code-of-conduct). Abusive behaviour towards other maintainers, contributors or users will not be tolerated; the maintainer will be given a warning and if their behaviour continues they will be removed as a maintainer.
+All maintainers (and project leader) communication through any medium is bound by [Homebrew's Code of Conduct](https://github.com/Homebrew/.github/blob/HEAD/CODE_OF_CONDUCT.md#code-of-conduct). Abusive behaviour towards other maintainers, contributors or users will not be tolerated; the maintainer will be given a warning and if their behaviour continues they will be removed as a maintainer.
 
 Maintainers should feel free to pleasantly disagree with the work and decisions of other maintainers. Healthy, friendly, technical disagreement between maintainers is actively encouraged and should occur in public on the issue tracker to make the project better. Interpersonal issues should be handled privately in Slack, ideally with moderation. If work or decisions are insufficiently documented or explained any maintainer or contributor should feel free to ask for clarification. No maintainer may ever justify a decision with e.g. "because I say so" or "it was I who did X" alone. Off-topic discussions on the issue tracker, [bike-shedding](https://en.wikipedia.org/wiki/Law_of_triviality) and personal attacks are forbidden.
diff --git a/docs/Maintainers-Avoiding-Burnout.md b/docs/Maintainers-Avoiding-Burnout.md
index 9a55338e5d8b5..d4cf617273671 100644
--- a/docs/Maintainers-Avoiding-Burnout.md
+++ b/docs/Maintainers-Avoiding-Burnout.md
@@ -44,6 +44,14 @@ realise that they aren't going to be resolved or merged. This is kinder than
 deciding this after a long period of review. Our issue tracker should reflect
 work to be done.
 
+## 5. Slow Down
+
+We're a volunteer-run open source project used by a lot of people. That can mean
+that it feels like there's a lot of pressure to get a fix, package or project
+completed ASAP. Try to not feel this pressure; slow down, focus on Homebrew
+being enjoyable. If in doubt: over-communicate your decision making. A revert
+can always be done now and a proper fix done tomorrow.
+
 ---
 
-_Thanks to https://gist.github.com/ryanflorence/124070e7c4b3839d4573 which influenced this document_
+_Thanks to <https://gist.github.com/ryanflorence/124070e7c4b3839d4573> which influenced this document._
diff --git a/docs/Manpage.md b/docs/Manpage.md
index 57e1e3b4efb64..b3b49381747e3 100644
--- a/docs/Manpage.md
+++ b/docs/Manpage.md
@@ -1,1900 +1,3518 @@
-brew(1) -- The Missing Package Manager for macOS (or Linux)
-===========================================================
+# brew(1) -- The Missing Package Manager for macOS (or Linux)
 
 ## SYNOPSIS
 
-`brew` `--version`<br>
-`brew` *`command`* [`--verbose`|`-v`] [*`options`*] [*`formula`*] ...
+`brew` `--version`  
+`brew` *`command`* \[`--verbose`\|`-v`\] \[*`options`*\] \[*`formula`*\] ...
 
 ## DESCRIPTION
 
 Homebrew is the easiest and most flexible way to install the UNIX tools Apple
 didn't include with macOS. It can also install software not packaged for your
-Linux distribution to your home directory without requiring `sudo`.
+Linux distribution without requiring `sudo`.
 
 ## TERMINOLOGY
 
-**formula**: Homebrew package definition built from upstream sources
+**formula**
 
-**cask**: Homebrew package definition that installs macOS native applications
+: Homebrew package definition that builds from upstream sources
 
-**keg**: installation destination directory of a given **formula** version e.g. `/usr/local/Cellar/foo/0.1`
+**cask**
 
-**rack**: directory containing one or more versioned kegs e.g. `/usr/local/Cellar/foo`
+: Homebrew package definition that installs macOS native applications
 
-**keg-only**: a **formula** is **keg-only** if it is not symlinked into Homebrew's prefix (e.g. `/usr/local`)
+**prefix**
 
-**cellar**: directory containing one or more named **racks** e.g. `/usr/local/Cellar`
+: path in which Homebrew is installed, e.g. `/usr/local`
 
-**Caskroom**: directory containing one or more named **casks** e.g. `/usr/local/Caskroom`
+**keg**
 
-**external command**: `brew` subcommand defined outside of the Homebrew/brew GitHub repository
+: installation destination directory of a given **formula** version, e.g.
+  `/usr/local/Cellar/foo/0.1`
 
-**tap**: directory (and usually Git repository) of **formulae**, **casks** and/or **external commands**
+**rack**
 
-**bottle**: pre-built **keg** poured into the **cellar**/**rack** instead of building from upstream sources
+: directory containing one or more versioned **kegs**, e.g.
+  `/usr/local/Cellar/foo`
+
+**keg-only**
+
+: a **formula** is *keg-only* if it is not symlinked into Homebrew's prefix
+
+**opt prefix**
+
+: a symlink to the active version of a **keg**, e.g. `/usr/local/opt/foo`
+
+**Cellar**
+
+: directory containing one or more named **racks**, e.g. `/usr/local/Cellar`
+
+**Caskroom**
+
+: directory containing one or more named **casks**, e.g. `/usr/local/Caskroom`
+
+**external command**
+
+: `brew` subcommand defined outside of the Homebrew/brew GitHub repository
+
+**tap**
+
+: directory (and usually Git repository) of **formulae**, **casks** and/or
+  **external commands**
+
+**bottle**
+
+: pre-built **keg** poured into a **rack** of the **Cellar** instead of building
+  from upstream sources
 
 ## ESSENTIAL COMMANDS
 
-For the full command list, see the [COMMANDS](#commands) section.
+For the full command list, see the [COMMANDS](#commands) section.
+
+With `--verbose` or `--debug`, many commands print extra debugging information.
+Note that these options should only appear after a command.
+
+Some command behaviour can be customised with environment variables; see the
+[ENVIRONMENT](#environment) section.
+
+### `install` *`formula`*
+
+Install *`formula`*.
+
+*`formula`* is usually the name of the formula to install, but it has other
+syntaxes which are listed in the [SPECIFYING FORMULAE](#specifying-formulae)
+section.
+
+### `uninstall` *`formula`*
+
+Uninstall *`formula`*.
+
+### `list`
+
+List all installed formulae.
+
+### `search` \[*`text`*\|`/`*`text`*`/`\]
+
+Perform a substring search of cask tokens and formula names for *`text`*. If
+*`text`* is flanked by slashes, it is interpreted as a regular expression. The
+search for *`text`* is extended online to `homebrew/core` and `homebrew/cask`.
+If no search term is provided, all locally available formulae are listed.
+
+## COMMANDS
+
+### `analytics` \[*`subcommand`*\]
+
+Control Homebrew's anonymous aggregate user behaviour analytics. Read more at
+<https://docs.brew.sh/Analytics>.
+
+`brew analytics` \[`state`\]
+
+: Display the current state of Homebrew's analytics.
+
+`brew analytics` (`on`\|`off`)
+
+: Turn Homebrew's analytics on or off respectively.
+
+### `autoremove` \[`--dry-run`\]
+
+Uninstall formulae that were only installed as a dependency of another formula
+and are now no longer needed.
+
+`-n`, `--dry-run`
+
+: List what would be uninstalled, but do not actually uninstall anything.
+
+### `casks`
+
+List all locally installable casks including short names.
+
+### `cleanup` \[*`options`*\] \[*`formula`*\|*`cask`* ...\]
+
+Remove stale lock files and outdated downloads for all formulae and casks, and
+remove old versions of installed formulae. If arguments are specified, only do
+this for the given formulae and casks. Removes all downloads more than 120 days
+old. This can be adjusted with `HOMEBREW_CLEANUP_MAX_AGE_DAYS`.
+
+`--prune`
+
+: Remove all cache files older than specified *`days`*. If you want to remove
+  everything, use `--prune=all`.
+
+`-n`, `--dry-run`
+
+: Show what would be removed, but do not actually remove anything.
+
+`-s`, `--scrub`
+
+: Scrub the cache, including downloads for even the latest versions. Note that
+  downloads for any installed formulae or casks will still not be deleted. If
+  you want to delete those too: `rm -rf "$(brew --cache)"`
+
+`--prune-prefix`
+
+: Only prune the symlinks and directories from the prefix and remove no other
+  files.
+
+### `command` *`command`* \[...\]
+
+Display the path to the file being used when invoking `brew` *`cmd`*.
+
+### `commands` \[`--quiet`\] \[`--include-aliases`\]
+
+Show lists of built-in and external commands.
+
+`-q`, `--quiet`
+
+: List only the names of commands without category headers.
+
+`--include-aliases`
+
+: Include aliases of internal commands.
+
+### `completions` \[*`subcommand`*\]
+
+Control whether Homebrew automatically links external tap shell completion
+files. Read more at <https://docs.brew.sh/Shell-Completion>.
+
+`brew completions` \[`state`\]
+
+: Display the current state of Homebrew's completions.
+
+`brew completions` (`link`\|`unlink`)
+
+: Link or unlink Homebrew's completions.
+
+### `config`, `--config`
+
+Show Homebrew and system configuration info useful for debugging. If you file a
+bug report, you will be required to provide this information.
+
+### `deps` \[*`options`*\] \[*`formula`*\|*`cask`* ...\]
+
+Show dependencies for *`formula`*. When given multiple formula arguments, show
+the intersection of dependencies for each formula. By default, `deps` shows all
+required and recommended dependencies.
+
+If any version of each formula argument is installed and no other options are
+passed, this command displays their actual runtime dependencies (similar to
+`brew linkage`), which may differ from the current versions' stated dependencies
+if the installed versions are outdated.
+
+*Note:* `--missing` and `--skip-recommended` have precedence over `--include-*`.
+
+`-n`, `--topological`
+
+: Sort dependencies in topological order.
+
+`-1`, `--direct`
+
+: Show only the direct dependencies declared in the formula.
+
+`--union`
+
+: Show the union of dependencies for multiple *`formula`*, instead of the
+  intersection.
+
+`--full-name`
+
+: List dependencies by their full name.
+
+`--include-build`
+
+: Include `:build` dependencies for *`formula`*.
+
+`--include-optional`
+
+: Include `:optional` dependencies for *`formula`*.
+
+`--include-test`
+
+: Include `:test` dependencies for *`formula`* (non-recursive).
+
+`--skip-recommended`
+
+: Skip `:recommended` dependencies for *`formula`*.
+
+`--include-requirements`
+
+: Include requirements in addition to dependencies for *`formula`*.
+
+`--tree`
+
+: Show dependencies as a tree. When given multiple formula arguments, show
+  individual trees for each formula.
+
+`--graph`
+
+: Show dependencies as a directed graph.
+
+`--dot`
+
+: Show text-based graph description in DOT format.
+
+`--annotate`
+
+: Mark any build, test, implicit, optional, or recommended dependencies as such
+  in the output.
+
+`--installed`
+
+: List dependencies for formulae that are currently installed. If *`formula`* is
+  specified, list only its dependencies that are currently installed.
+
+`--missing`
+
+: Show only missing dependencies.
+
+`--eval-all`
+
+: Evaluate all available formulae and casks, whether installed or not, to list
+  their dependencies.
+
+`--for-each`
+
+: Switch into the mode used by the `--eval-all` option, but only list
+  dependencies for each provided *`formula`*, one formula per line. This is used
+  for debugging the `--installed`/`--eval-all` display mode.
+
+`--HEAD`
+
+: Show dependencies for HEAD version instead of stable version.
+
+`--os`
+
+: Show dependencies for the given operating system.
+
+`--arch`
+
+: Show dependencies for the given CPU architecture.
+
+`--formula`
+
+: Treat all named arguments as formulae.
+
+`--cask`
+
+: Treat all named arguments as casks.
+
+### `desc` \[*`options`*\] *`formula`*\|*`cask`*\|*`text`*\|`/`*`regex`*`/` \[...\]
+
+Display *`formula`*'s name and one-line description. The cache is created on the
+first search, making that search slower than subsequent ones.
+
+`-s`, `--search`
+
+: Search both names and descriptions for *`text`*. If *`text`* is flanked by
+  slashes, it is interpreted as a regular expression.
+
+`-n`, `--name`
+
+: Search just names for *`text`*. If *`text`* is flanked by slashes, it is
+  interpreted as a regular expression.
+
+`-d`, `--description`
+
+: Search just descriptions for *`text`*. If *`text`* is flanked by slashes, it
+  is interpreted as a regular expression.
+
+`--eval-all`
+
+: Evaluate all available formulae and casks, whether installed or not, to search
+  their descriptions. Implied if `HOMEBREW_EVAL_ALL` is set.
+
+`--formula`
+
+: Treat all named arguments as formulae.
+
+`--cask`
+
+: Treat all named arguments as casks.
+
+### `developer` \[*`subcommand`*\]
+
+Control Homebrew's developer mode. When developer mode is enabled, `brew update`
+will update Homebrew to the latest commit on the `master` branch instead of the
+latest stable version along with some other behaviour changes.
+
+`brew developer` \[`state`\]
+
+: Display the current state of Homebrew's developer mode.
+
+`brew developer` (`on`\|`off`)
+
+: Turn Homebrew's developer mode on or off respectively.
+
+### `docs`
+
+Open Homebrew's online documentation at <https://docs.brew.sh> in a browser.
+
+### `doctor`, `dr` \[`--list-checks`\] \[`--audit-debug`\] \[*`diagnostic_check`* ...\]
+
+Check your system for potential problems. Will exit with a non-zero status if
+any potential problems are found.
+
+Please note that these warnings are just used to help the Homebrew maintainers
+with debugging if you file an issue. If everything you use Homebrew for is
+working fine: please don't worry or file an issue; just ignore this.
+
+`--list-checks`
+
+: List all audit methods, which can be run individually if provided as
+  arguments.
+
+`-D`, `--audit-debug`
+
+: Enable debugging and profiling of audit methods.
+
+### `fetch` \[*`options`*\] *`formula`*\|*`cask`* \[...\]
+
+Download a bottle (if available) or source packages for *`formula`*e and
+binaries for *`cask`*s. For files, also print SHA-256 checksums.
+
+`--os`
+
+: Download for the given operating system. (Pass `all` to download for all
+  operating systems.)
+
+`--arch`
+
+: Download for the given CPU architecture. (Pass `all` to download for all
+  architectures.)
+
+`--bottle-tag`
+
+: Download a bottle for given tag.
+
+`--HEAD`
+
+: Fetch HEAD version instead of stable version.
+
+`-f`, `--force`
+
+: Remove a previously cached version and re-fetch.
+
+`-v`, `--verbose`
+
+: Do a verbose VCS checkout, if the URL represents a VCS. This is useful for
+  seeing if an existing VCS cache has been updated.
+
+`--retry`
+
+: Retry if downloading fails or re-download if the checksum of a previously
+  cached version no longer matches. Tries at most 5 times with exponential
+  backoff.
+
+`--deps`
+
+: Also download dependencies for any listed *`formula`*.
+
+`-s`, `--build-from-source`
+
+: Download source packages rather than a bottle.
+
+`--build-bottle`
+
+: Download source packages (for eventual bottling) rather than a bottle.
+
+`--force-bottle`
+
+: Download a bottle if it exists for the current or newest version of macOS,
+  even if it would not be used during installation.
+
+`--[no-]quarantine`
+
+: Disable/enable quarantining of downloads (default: enabled).
+
+`--formula`
+
+: Treat all named arguments as formulae.
+
+`--cask`
+
+: Treat all named arguments as casks.
+
+### `formulae`
+
+List all locally installable formulae including short names.
+
+### `gist-logs` \[*`options`*\] *`formula`*
+
+Upload logs for a failed build of *`formula`* to a new Gist. Presents an error
+message if no logs are found.
+
+`--with-hostname`
+
+: Include the hostname in the Gist.
+
+`-n`, `--new-issue`
+
+: Automatically create a new issue in the appropriate GitHub repository after
+  creating the Gist.
+
+`-p`, `--private`
+
+: The Gist will be marked private and will not appear in listings but will be
+  accessible with its link.
+
+### `help` \[*`command`* ...\]
+
+Outputs the usage instructions for `brew` *`command`*. Equivalent to `brew
+--help` *`command`*.
+
+### `home`, `homepage` \[`--formula`\] \[`--cask`\] \[*`formula`*\|*`cask`* ...\]
+
+Open a *`formula`* or *`cask`*'s homepage in a browser, or open Homebrew's own
+homepage if no argument is provided.
+
+`--formula`
+
+: Treat all named arguments as formulae.
+
+`--cask`
+
+: Treat all named arguments as casks.
+
+### `info`, `abv` \[*`options`*\] \[*`formula`*\|*`cask`* ...\]
+
+Display brief statistics for your Homebrew installation. If a *`formula`* or
+*`cask`* is provided, show summary of information about it.
+
+`--analytics`
+
+: List global Homebrew analytics data or, if specified, installation and build
+  error data for *`formula`* (provided neither `HOMEBREW_NO_ANALYTICS` nor
+  `HOMEBREW_NO_GITHUB_API` are set).
+
+`--days`
+
+: How many days of analytics data to retrieve. The value for *`days`* must be
+  `30`, `90` or `365`. The default is `30`.
+
+`--category`
+
+: Which type of analytics data to retrieve. The value for *`category`* must be
+  `install`, `install-on-request` or `build-error`; `cask-install` or
+  `os-version` may be specified if *`formula`* is not. The default is `install`.
+
+`--github`
+
+: Open the GitHub source page for *`formula`* and *`cask`* in a browser. To view
+  the history locally: `brew log -p` *`formula`* or *`cask`*
+
+`--fetch-manifest`
+
+: Fetch GitHub Packages manifest for extra information when *`formula`* is not
+  installed.
+
+`--json`
+
+: Print a JSON representation. Currently the default value for *`version`* is
+  `v1` for *`formula`*. For *`formula`* and *`cask`* use `v2`. See the docs for
+  examples of using the JSON output: <https://docs.brew.sh/Querying-Brew>
+
+`--installed`
+
+: Print JSON of formulae that are currently installed.
+
+`--eval-all`
+
+: Evaluate all available formulae and casks, whether installed or not, to print
+  their JSON. Implied if `HOMEBREW_EVAL_ALL` is set.
+
+`--variations`
+
+: Include the variations hash in each formula's JSON output.
+
+`-v`, `--verbose`
+
+: Show more verbose analytics data for *`formula`*.
+
+`--formula`
+
+: Treat all named arguments as formulae.
+
+`--cask`
+
+: Treat all named arguments as casks.
+
+### `install` \[*`options`*\] *`formula`*\|*`cask`* \[...\]
+
+Install a *`formula`* or *`cask`*. Additional options specific to a *`formula`*
+may be appended to the command.
+
+Unless `HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew
+reinstall` will be run for outdated dependents and dependents with broken
+linkage, respectively.
+
+Unless `HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for
+the installed formulae or, every 30 days, for all formulae.
+
+Unless `HOMEBREW_NO_INSTALL_UPGRADE` is set, `brew install` *`formula`* will
+upgrade *`formula`* if it is already installed but outdated.
+
+`-d`, `--debug`
+
+: If brewing fails, open an interactive debugging session with access to IRB or
+  a shell inside the temporary build directory.
+
+`--display-times`
+
+: Print install times for each package at the end of the run.
+
+`-f`, `--force`
+
+: Install formulae without checking for previously installed keg-only or
+  non-migrated versions. When installing casks, overwrite existing files
+  (binaries and symlinks are excluded, unless originally from the same cask).
+
+`-v`, `--verbose`
+
+: Print the verification and post-install steps.
+
+`-n`, `--dry-run`
+
+: Show what would be installed, but do not actually install anything.
+
+`--formula`
+
+: Treat all named arguments as formulae.
+
+`--ignore-dependencies`
+
+: An unsupported Homebrew development option to skip installing any dependencies
+  of any kind. If the dependencies are not already present, the formula will
+  have issues. If you're not developing Homebrew, consider adjusting your PATH
+  rather than using this option.
+
+`--only-dependencies`
+
+: Install the dependencies with specified options but do not install the formula
+  itself.
+
+`--cc`
+
+: Attempt to compile using the specified *`compiler`*, which should be the name
+  of the compiler's executable, e.g. `gcc-9` for GCC 9. In order to use LLVM's
+  clang, specify `llvm_clang`. To use the Apple-provided clang, specify `clang`.
+  This option will only accept compilers that are provided by Homebrew or
+  bundled with macOS. Please do not file issues if you encounter errors while
+  using this option.
+
+`-s`, `--build-from-source`
+
+: Compile *`formula`* from source even if a bottle is provided. Dependencies
+  will still be installed from bottles if they are available.
+
+`--force-bottle`
+
+: Install from a bottle if it exists for the current or newest version of macOS,
+  even if it would not normally be used for installation.
+
+`--include-test`
+
+: Install testing dependencies required to run `brew test` *`formula`*.
+
+`--HEAD`
+
+: If *`formula`* defines it, install the HEAD version, aka. main, trunk,
+  unstable, master.
+
+`--fetch-HEAD`
+
+: Fetch the upstream repository to detect if the HEAD installation of the
+  formula is outdated. Otherwise, the repository's HEAD will only be checked for
+  updates when a new stable or development version has been released.
+
+`--keep-tmp`
+
+: Retain the temporary files created during installation.
+
+`--debug-symbols`
+
+: Generate debug symbols on build. Source will be retained in a cache directory.
+
+`--build-bottle`
+
+: Prepare the formula for eventual bottling during installation, skipping any
+  post-install steps.
+
+`--skip-post-install`
+
+: Install but skip any post-install steps.
+
+`--bottle-arch`
+
+: Optimise bottles for the specified architecture rather than the oldest
+  architecture supported by the version of macOS the bottles are built on.
+
+`-i`, `--interactive`
+
+: Download and patch *`formula`*, then open a shell. This allows the user to run
+  `./configure --help` and otherwise determine how to turn the software package
+  into a Homebrew package.
+
+`-g`, `--git`
+
+: Create a Git repository, useful for creating patches to the software.
+
+`--overwrite`
+
+: Delete files that already exist in the prefix while linking.
+
+`--cask`
+
+: Treat all named arguments as casks.
+
+`--[no-]binaries`
+
+: Disable/enable linking of helper executables (default: enabled).
+
+`--require-sha`
+
+: Require all casks to have a checksum.
+
+`--[no-]quarantine`
+
+: Disable/enable quarantining of downloads (default: enabled).
+
+`--adopt`
+
+: Adopt existing artifacts in the destination that are identical to those being
+  installed. Cannot be combined with `--force`.
+
+`--skip-cask-deps`
+
+: Skip installing cask dependencies.
+
+`--zap`
+
+: For use with `brew reinstall --cask`. Remove all files associated with a cask.
+  *May remove files which are shared between applications.*
+
+### `leaves` \[`--installed-on-request`\] \[`--installed-as-dependency`\]
+
+List installed formulae that are not dependencies of another installed formula
+or cask.
+
+`-r`, `--installed-on-request`
+
+: Only list leaves that were manually installed.
+
+`-p`, `--installed-as-dependency`
+
+: Only list leaves that were installed as dependencies.
+
+### `link`, `ln` \[*`options`*\] *`installed_formula`* \[...\]
+
+Symlink all of *`formula`*'s installed files into Homebrew's prefix. This is
+done automatically when you install formulae but can be useful for manual
+installations.
+
+`--overwrite`
+
+: Delete files that already exist in the prefix while linking.
+
+`-n`, `--dry-run`
+
+: List files which would be linked or deleted by `brew link --overwrite` without
+  actually linking or deleting any files.
+
+`-f`, `--force`
+
+: Allow keg-only formulae to be linked.
+
+`--HEAD`
+
+: Link the HEAD version of the formula if it is installed.
+
+### `list`, `ls` \[*`options`*\] \[*`installed_formula`*\|*`installed_cask`* ...\]
+
+List all installed formulae and casks. If *`formula`* is provided, summarise the
+paths within its current keg. If *`cask`* is provided, list its artifacts.
+
+`--formula`
+
+: List only formulae, or treat all named arguments as formulae.
+
+`--cask`
+
+: List only casks, or treat all named arguments as casks.
+
+`--full-name`
+
+: Print formulae with fully-qualified names. Unless `--full-name`, `--versions`
+  or `--pinned` are passed, other options (i.e. `-1`, `-l`, `-r` and `-t`) are
+  passed to `ls`(1) which produces the actual output.
+
+`--versions`
+
+: Show the version number for installed formulae, or only the specified formulae
+  if *`formula`* are provided.
+
+`--multiple`
+
+: Only show formulae with multiple versions installed.
+
+`--pinned`
+
+: List only pinned formulae, or only the specified (pinned) formulae if
+  *`formula`* are provided. See also `pin`, `unpin`.
+
+`--installed-on-request`
+
+: List the formulae installed on request.
+
+`--installed-as-dependency`
+
+: List the formulae installed as dependencies.
+
+`--poured-from-bottle`
+
+: List the formulae installed from a bottle.
+
+`--built-from-source`
+
+: List the formulae compiled from source.
+
+`-1`
+
+: Force output to be one entry per line. This is the default when output is not
+  to a terminal.
+
+`-l`
+
+: List formulae and/or casks in long format. Has no effect when a formula or
+  cask name is passed as an argument.
+
+`-r`
+
+: Reverse the order of the formulae and/or casks sort to list the oldest entries
+  first. Has no effect when a formula or cask name is passed as an argument.
+
+`-t`
+
+: Sort formulae and/or casks by time modified, listing most recently modified
+  first. Has no effect when a formula or cask name is passed as an argument.
+
+### `log` \[*`options`*\] \[*`formula`*\|*`cask`*\]
+
+Show the `git log` for *`formula`* or *`cask`*, or show the log for the Homebrew
+repository if no formula or cask is provided.
+
+`-p`, `--patch`
+
+: Also print patch from commit.
+
+`--stat`
+
+: Also print diffstat from commit.
+
+`--oneline`
+
+: Print only one line per commit.
+
+`-1`
+
+: Print only one commit.
+
+`-n`, `--max-count`
+
+: Print only a specified number of commits.
+
+`--formula`
+
+: Treat all named arguments as formulae.
+
+`--cask`
+
+: Treat all named arguments as casks.
+
+### `migrate` \[*`options`*\] *`installed_formula`*\|*`installed_cask`* \[...\]
+
+Migrate renamed packages to new names, where *`formula`* are old names of
+packages.
+
+`-f`, `--force`
+
+: Treat installed *`formula`* and provided *`formula`* as if they are from the
+  same taps and migrate them anyway.
+
+`-n`, `--dry-run`
+
+: Show what would be migrated, but do not actually migrate anything.
+
+`--formula`
+
+: Only migrate formulae.
+
+`--cask`
+
+: Only migrate casks.
+
+### `missing` \[`--hide=`\] \[*`formula`* ...\]
+
+Check the given *`formula`* kegs for missing dependencies. If no *`formula`* are
+provided, check all kegs. Will exit with a non-zero status if any kegs are found
+to be missing dependencies.
+
+`--hide`
+
+: Act as if none of the specified *`hidden`* are installed. *`hidden`* should be
+  a comma-separated list of formulae.
+
+### `nodenv-sync`
+
+Create symlinks for Homebrew's installed NodeJS versions in
+`~/.nodenv/versions`.
+
+Note that older version symlinks will also be created so e.g. NodeJS 19.1.0 will
+also be symlinked to 19.0.0.
+
+### `options` \[*`options`*\] \[*`formula`* ...\]
+
+Show install options specific to *`formula`*.
+
+`--compact`
+
+: Show all options on a single line separated by spaces.
+
+`--installed`
+
+: Show options for formulae that are currently installed.
+
+`--eval-all`
+
+: Evaluate all available formulae and casks, whether installed or not, to show
+  their options.
+
+`--command`
+
+: Show options for the specified *`command`*.
+
+### `outdated` \[*`options`*\] \[*`formula`*\|*`cask`* ...\]
+
+List installed casks and formulae that have an updated version available. By
+default, version information is displayed in interactive shells and suppressed
+otherwise.
+
+`-q`, `--quiet`
+
+: List only the names of outdated kegs (takes precedence over `--verbose`).
+
+`-v`, `--verbose`
+
+: Include detailed version information.
+
+`--formula`
+
+: List only outdated formulae.
+
+`--cask`
+
+: List only outdated casks.
+
+`--json`
+
+: Print output in JSON format. There are two versions: `v1` and `v2`. `v1` is
+  deprecated and is currently the default if no version is specified. `v2`
+  prints outdated formulae and casks.
+
+`--fetch-HEAD`
+
+: Fetch the upstream repository to detect if the HEAD installation of the
+  formula is outdated. Otherwise, the repository's HEAD will only be checked for
+  updates when a new stable or development version has been released.
+
+`-g`, `--greedy`
+
+: Also include outdated casks with `auto_updates true` or `version :latest`.
+
+`--greedy-latest`
+
+: Also include outdated casks including those with `version :latest`.
+
+`--greedy-auto-updates`
+
+: Also include outdated casks including those with `auto_updates true`.
+
+### `pin` *`installed_formula`* \[...\]
+
+Pin the specified *`formula`*, preventing them from being upgraded when issuing
+the `brew upgrade` *`formula`* command. See also `unpin`.
+
+*Note:* Other packages which depend on newer versions of a pinned formula might
+not install or run correctly.
+
+### `postinstall`, `post_install` *`installed_formula`* \[...\]
+
+Rerun the post-install steps for *`formula`*.
+
+### `pyenv-sync`
+
+Create symlinks for Homebrew's installed Python versions in `~/.pyenv/versions`.
+
+Note that older patch version symlinks will be created and linked to the minor
+version so e.g. Python 3.11.0 will also be symlinked to 3.11.3.
+
+### `rbenv-sync`
+
+Create symlinks for Homebrew's installed Ruby versions in `~/.rbenv/versions`.
+
+Note that older version symlinks will also be created so e.g. Ruby 3.2.1 will
+also be symlinked to 3.2.0.
+
+### `readall` \[*`options`*\] \[*`tap`* ...\]
+
+Import all items from the specified *`tap`*, or from all installed taps if none
+is provided. This can be useful for debugging issues across all items when
+making significant changes to `formula.rb`, testing the performance of loading
+all items or checking if any current formulae/casks have Ruby issues.
+
+`--os`
+
+: Read using the given operating system. (Pass `all` to simulate all operating
+  systems.)
+
+`--arch`
+
+: Read using the given CPU architecture. (Pass `all` to simulate all
+  architectures.)
+
+`--aliases`
+
+: Verify any alias symlinks in each tap.
+
+`--syntax`
+
+: Syntax-check all of Homebrew's Ruby files (if no *`tap`* is passed).
+
+`--eval-all`
+
+: Evaluate all available formulae and casks, whether installed or not. Implied
+  if `HOMEBREW_EVAL_ALL` is set.
+
+`--no-simulate`
+
+: Don't simulate other system configurations when checking formulae and casks.
+
+### `reinstall` \[*`options`*\] *`formula`*\|*`cask`* \[...\]
+
+Uninstall and then reinstall a *`formula`* or *`cask`* using the same options it
+was originally installed with, plus any appended options specific to a
+*`formula`*.
+
+Unless `HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew
+reinstall` will be run for outdated dependents and dependents with broken
+linkage, respectively.
+
+Unless `HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for
+the reinstalled formulae or, every 30 days, for all formulae.
+
+`-d`, `--debug`
+
+: If brewing fails, open an interactive debugging session with access to IRB or
+  a shell inside the temporary build directory.
+
+`--display-times`
+
+: Print install times for each package at the end of the run.
+
+`-f`, `--force`
+
+: Install without checking for previously installed keg-only or non-migrated
+  versions.
+
+`-v`, `--verbose`
+
+: Print the verification and post-install steps.
+
+`--formula`
+
+: Treat all named arguments as formulae.
+
+`-s`, `--build-from-source`
+
+: Compile *`formula`* from source even if a bottle is available.
+
+`-i`, `--interactive`
+
+: Download and patch *`formula`*, then open a shell. This allows the user to run
+  `./configure --help` and otherwise determine how to turn the software package
+  into a Homebrew package.
+
+`--force-bottle`
+
+: Install from a bottle if it exists for the current or newest version of macOS,
+  even if it would not normally be used for installation.
+
+`--keep-tmp`
+
+: Retain the temporary files created during installation.
+
+`--debug-symbols`
+
+: Generate debug symbols on build. Source will be retained in a cache directory.
+
+`-g`, `--git`
+
+: Create a Git repository, useful for creating patches to the software.
+
+`--cask`
+
+: Treat all named arguments as casks.
+
+`--[no-]binaries`
+
+: Disable/enable linking of helper executables (default: enabled).
+
+`--require-sha`
+
+: Require all casks to have a checksum.
+
+`--[no-]quarantine`
+
+: Disable/enable quarantining of downloads (default: enabled).
+
+`--adopt`
+
+: Adopt existing artifacts in the destination that are identical to those being
+  installed. Cannot be combined with `--force`.
+
+`--skip-cask-deps`
+
+: Skip installing cask dependencies.
+
+`--zap`
+
+: For use with `brew reinstall --cask`. Remove all files associated with a cask.
+  *May remove files which are shared between applications.*
+
+### `search`, `-S` \[*`options`*\] *`text`*\|`/`*`regex`*`/` \[...\]
+
+Perform a substring search of cask tokens and formula names for *`text`*. If
+*`text`* is flanked by slashes, it is interpreted as a regular expression.
+
+`--formula`
+
+: Search for formulae.
+
+`--cask`
+
+: Search for casks.
+
+`--desc`
+
+: Search for formulae with a description matching *`text`* and casks with a name
+  or description matching *`text`*.
+
+`--eval-all`
+
+: Evaluate all available formulae and casks, whether installed or not, to search
+  their descriptions. Implied if `HOMEBREW_EVAL_ALL` is set.
+
+`--pull-request`
+
+: Search for GitHub pull requests containing *`text`*.
+
+`--open`
+
+: Search for only open GitHub pull requests.
+
+`--closed`
+
+: Search for only closed GitHub pull requests.
+
+`--repology`
+
+: Search for *`text`* in the given database.
+
+`--macports`
+
+: Search for *`text`* in the given database.
+
+`--fink`
+
+: Search for *`text`* in the given database.
+
+`--opensuse`
+
+: Search for *`text`* in the given database.
+
+`--fedora`
+
+: Search for *`text`* in the given database.
+
+`--archlinux`
+
+: Search for *`text`* in the given database.
+
+`--debian`
+
+: Search for *`text`* in the given database.
+
+`--ubuntu`
+
+: Search for *`text`* in the given database.
+
+### `setup-ruby` \[*`command`* ...\]
+
+Installs and configures Homebrew's Ruby. If `command` is passed, it will only
+run Bundler if necessary for that command.
+
+### `shellenv` \[*`shell`* ...\]
+
+Valid shells: bash\|csh\|fish\|pwsh\|sh\|tcsh\|zsh
+
+Print export statements. When run in a shell, this installation of Homebrew will
+be added to your `PATH`, `MANPATH`, and `INFOPATH`.
+
+The variables `HOMEBREW_PREFIX`, `HOMEBREW_CELLAR` and `HOMEBREW_REPOSITORY` are
+also exported to avoid querying them multiple times. To help guarantee
+idempotence, this command produces no output when Homebrew's `bin` and `sbin`
+directories are first and second respectively in your `PATH`. Consider adding
+evaluation of this command's output to your dotfiles (e.g. `~/.bash_profile` or
+`~/.zprofile` on macOS and `~/.bashrc` or `~/.zshrc` on Linux) with: `eval
+"$(brew shellenv)"`
+
+The shell can be specified explicitly with a supported shell name parameter.
+Unknown shells will output POSIX exports.
+
+### `tab` \[*`options`*\] *`installed_formula`*\|*`installed_cask`* \[...\]
+
+Edit tab information for installed formulae or casks.
+
+This can be useful when you want to control whether an installed formula should
+be removed by `brew autoremove`. To prevent removal, mark the formula as
+installed on request; to allow removal, mark the formula as not installed on
+request.
+
+`--installed-on-request`
+
+: Mark *`installed_formula`* or *`installed_cask`* as installed on request.
+
+`--no-installed-on-request`
+
+: Mark *`installed_formula`* or *`installed_cask`* as not installed on request.
+
+`--formula`
+
+: Only mark formulae.
+
+`--cask`
+
+: Only mark casks.
+
+### `tap` \[*`options`*\] \[*`user`*`/`*`repo`*\] \[*`URL`*\]
+
+Tap a formula repository. If no arguments are provided, list all installed taps.
+
+With *`URL`* unspecified, tap a formula repository from GitHub using HTTPS.
+Since so many taps are hosted on GitHub, this command is a shortcut for `brew
+tap` *`user`*`/`*`repo`* `https://github.com/`*`user`*`/homebrew-`*`repo`*.
+
+With *`URL`* specified, tap a formula repository from anywhere, using any
+transport protocol that `git`(1) handles. The one-argument form of `tap`
+simplifies but also limits. This two-argument command makes no assumptions, so
+taps can be cloned from places other than GitHub and using protocols other than
+HTTPS, e.g. SSH, git, HTTP, FTP(S), rsync.
+
+`--custom-remote`
+
+: Install or change a tap with a custom remote. Useful for mirrors.
+
+`--repair`
+
+: Migrate tapped formulae from symlink-based to directory-based structure.
+
+`--eval-all`
+
+: Evaluate all the formulae, casks and aliases in the new tap to check validity.
+  Implied if `HOMEBREW_EVAL_ALL` is set.
+
+`--force`
+
+: Force install core taps even under API mode.
+
+### `tap-info` \[`--installed`\] \[`--json`\] \[*`tap`* ...\]
+
+Show detailed information about one or more *`tap`*s. If no *`tap`* names are
+provided, display brief statistics for all installed taps.
+
+`--installed`
+
+: Show information on each installed tap.
+
+`--json`
+
+: Print a JSON representation of *`tap`*. Currently the default and only
+  accepted value for *`version`* is `v1`. See the docs for examples of using the
+  JSON output: <https://docs.brew.sh/Querying-Brew>
+
+### `uninstall`, `remove`, `rm` \[*`options`*\] *`installed_formula`*\|*`installed_cask`* \[...\]
+
+Uninstall a *`formula`* or *`cask`*.
+
+`-f`, `--force`
+
+: Delete all installed versions of *`formula`*. Uninstall even if *`cask`* is
+  not installed, overwrite existing files and ignore errors when removing files.
+
+`--zap`
+
+: Remove all files associated with a *`cask`*. *May remove files which are
+  shared between applications.*
+
+`--ignore-dependencies`
+
+: Don't fail uninstall, even if *`formula`* is a dependency of any installed
+  formulae.
+
+`--formula`
+
+: Treat all named arguments as formulae.
+
+`--cask`
+
+: Treat all named arguments as casks.
+
+### `unlink` \[`--dry-run`\] *`installed_formula`* \[...\]
+
+Remove symlinks for *`formula`* from Homebrew's prefix. This can be useful for
+temporarily disabling a formula: `brew unlink` *`formula`* `&&` *`commands`* `&&
+brew link` *`formula`*
+
+`-n`, `--dry-run`
+
+: List files which would be unlinked without actually unlinking or deleting any
+  files.
+
+### `unpin` *`installed_formula`* \[...\]
+
+Unpin *`formula`*, allowing them to be upgraded by `brew upgrade` *`formula`*.
+See also `pin`.
+
+### `untap` \[`--force`\] *`tap`* \[...\]
+
+Remove a tapped formula repository.
+
+`-f`, `--force`
+
+: Untap even if formulae or casks from this tap are currently installed.
+
+### `update`, `up` \[*`options`*\]
+
+Fetch the newest version of Homebrew and all formulae from GitHub using `git`(1)
+and perform any necessary migrations.
+
+`--merge`
+
+: Use `git merge` to apply updates (rather than `git rebase`).
+
+`--auto-update`
+
+: Run on auto-updates (e.g. before `brew install`). Skips some slower steps.
+
+`-f`, `--force`
+
+: Always do a slower, full update check (even if unnecessary).
+
+`-v`, `--verbose`
+
+: Print the directories checked and `git` operations performed.
+
+`-d`, `--debug`
+
+: Display a trace of all shell commands as they are executed.
+
+### `update-reset` \[*`repository`* ...\]
+
+Fetch and reset Homebrew and all tap repositories (or any specified
+*`repository`*) using `git`(1) to their latest `origin/HEAD`.
+
+*Note:* this will destroy all your uncommitted or committed changes.
+
+### `upgrade` \[*`options`*\] \[*`installed_formula`*\|*`installed_cask`* ...\]
+
+Upgrade outdated casks and outdated, unpinned formulae using the same options
+they were originally installed with, plus any appended brew formula options. If
+*`cask`* or *`formula`* are specified, upgrade only the given *`cask`* or
+*`formula`* kegs (unless they are pinned; see `pin`, `unpin`).
+
+Unless `HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew
+reinstall` will be run for outdated dependents and dependents with broken
+linkage, respectively.
+
+Unless `HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for
+the upgraded formulae or, every 30 days, for all formulae.
+
+`-d`, `--debug`
+
+: If brewing fails, open an interactive debugging session with access to IRB or
+  a shell inside the temporary build directory.
+
+`--display-times`
+
+: Print install times for each package at the end of the run.
+
+`-f`, `--force`
+
+: Install formulae without checking for previously installed keg-only or
+  non-migrated versions. When installing casks, overwrite existing files
+  (binaries and symlinks are excluded, unless originally from the same cask).
+
+`-v`, `--verbose`
+
+: Print the verification and post-install steps.
+
+`-n`, `--dry-run`
+
+: Show what would be upgraded, but do not actually upgrade anything.
+
+`--formula`
+
+: Treat all named arguments as formulae. If no named arguments are specified,
+  upgrade only outdated formulae.
+
+`-s`, `--build-from-source`
+
+: Compile *`formula`* from source even if a bottle is available.
+
+`-i`, `--interactive`
+
+: Download and patch *`formula`*, then open a shell. This allows the user to run
+  `./configure --help` and otherwise determine how to turn the software package
+  into a Homebrew package.
+
+`--force-bottle`
+
+: Install from a bottle if it exists for the current or newest version of macOS,
+  even if it would not normally be used for installation.
+
+`--fetch-HEAD`
+
+: Fetch the upstream repository to detect if the HEAD installation of the
+  formula is outdated. Otherwise, the repository's HEAD will only be checked for
+  updates when a new stable or development version has been released.
+
+`--keep-tmp`
+
+: Retain the temporary files created during installation.
+
+`--debug-symbols`
+
+: Generate debug symbols on build. Source will be retained in a cache directory.
+
+`--overwrite`
+
+: Delete files that already exist in the prefix while linking.
+
+`--cask`
+
+: Treat all named arguments as casks. If no named arguments are specified,
+  upgrade only outdated casks.
+
+`--skip-cask-deps`
+
+: Skip installing cask dependencies.
+
+`-g`, `--greedy`
+
+: Also include casks with `auto_updates true` or `version :latest`.
+
+`--greedy-latest`
+
+: Also include casks with `version :latest`.
+
+`--greedy-auto-updates`
+
+: Also include casks with `auto_updates true`.
+
+`--[no-]binaries`
+
+: Disable/enable linking of helper executables (default: enabled).
+
+`--require-sha`
+
+: Require all casks to have a checksum.
+
+`--[no-]quarantine`
+
+: Disable/enable quarantining of downloads (default: enabled).
+
+### `uses` \[*`options`*\] *`formula`* \[...\]
+
+Show formulae and casks that specify *`formula`* as a dependency; that is, show
+dependents of *`formula`*. When given multiple formula arguments, show the
+intersection of formulae that use *`formula`*. By default, `uses` shows all
+formulae and casks that specify *`formula`* as a required or recommended
+dependency for their stable builds.
+
+*Note:* `--missing` and `--skip-recommended` have precedence over `--include-*`.
+
+`--recursive`
+
+: Resolve more than one level of dependencies.
+
+`--installed`
+
+: Only list formulae and casks that are currently installed.
+
+`--missing`
+
+: Only list formulae and casks that are not currently installed.
+
+`--eval-all`
+
+: Evaluate all available formulae and casks, whether installed or not, to show
+  their dependents.
+
+`--include-build`
+
+: Include formulae that specify *`formula`* as a `:build` dependency.
+
+`--include-test`
+
+: Include formulae that specify *`formula`* as a `:test` dependency.
+
+`--include-optional`
+
+: Include formulae that specify *`formula`* as an `:optional` dependency.
+
+`--skip-recommended`
+
+: Skip all formulae that specify *`formula`* as a `:recommended` dependency.
+
+`--formula`
+
+: Include only formulae.
+
+`--cask`
+
+: Include only casks.
+
+### `--cache` \[*`options`*\] \[*`formula`*\|*`cask`* ...\]
+
+Display Homebrew's download cache. See also `HOMEBREW_CACHE`.
+
+If a *`formula`* or *`cask`* is provided, display the file or directory used to
+cache it.
+
+`--os`
+
+: Show cache file for the given operating system. (Pass `all` to show cache
+  files for all operating systems.)
+
+`--arch`
+
+: Show cache file for the given CPU architecture. (Pass `all` to show cache
+  files for all architectures.)
+
+`-s`, `--build-from-source`
+
+: Show the cache file used when building from source.
+
+`--force-bottle`
+
+: Show the cache file used when pouring a bottle.
+
+`--bottle-tag`
+
+: Show the cache file used when pouring a bottle for the given tag.
+
+`--HEAD`
+
+: Show the cache file used when building from HEAD.
+
+`--formula`
+
+: Only show cache files for formulae.
+
+`--cask`
+
+: Only show cache files for casks.
+
+### `--caskroom` \[*`cask`* ...\]
+
+Display Homebrew's Caskroom path.
+
+If *`cask`* is provided, display the location in the Caskroom where *`cask`*
+would be installed, without any sort of versioned directory as the last path.
+
+### `--cellar` \[*`formula`* ...\]
+
+Display Homebrew's Cellar path. *Default:* `$(brew --prefix)/Cellar`, or if that
+directory doesn't exist, `$(brew --repository)/Cellar`.
+
+If *`formula`* is provided, display the location in the Cellar where *`formula`*
+would be installed, without any sort of versioned directory as the last path.
+
+### `--env`, `environment` \[`--shell=`\] \[`--plain`\] \[*`formula`* ...\]
+
+Summarise Homebrew's build environment as a plain list.
+
+If the command's output is sent through a pipe and no shell is specified, the
+list is formatted for export to `bash`(1) unless `--plain` is passed.
+
+`--shell`
+
+: Generate a list of environment variables for the specified shell, or
+  `--shell=auto` to detect the current shell.
+
+`--plain`
+
+: Generate plain output even when piped.
+
+### `--prefix` \[`--unbrewed`\] \[`--installed`\] \[*`formula`* ...\]
+
+Display Homebrew's install path. *Default:*
+
+* macOS ARM: `/opt/homebrew`
+* macOS Intel: `/usr/local`
+* Linux: `/home/linuxbrew/.linuxbrew`
+
+If *`formula`* is provided, display the location where *`formula`* is or would
+be installed.
+
+`--unbrewed`
+
+: List files in Homebrew's prefix not installed by Homebrew.
+
+`--installed`
+
+: Outputs nothing and returns a failing status code if *`formula`* is not
+  installed.
+
+### `--repository`, `--repo` \[*`tap`* ...\]
+
+Display where Homebrew's Git repository is located.
+
+If *`user`*`/`*`repo`* are provided, display where tap *`user`*`/`*`repo`*'s
+directory is located.
+
+### `--version`, `-v`
+
+Print the version numbers of Homebrew, Homebrew/homebrew-core and
+Homebrew/homebrew-cask (if tapped) to standard output.
+
+## DEVELOPER COMMANDS
+
+### `audit` \[*`options`*\] \[*`formula`*\|*`cask`* ...\]
+
+Check *`formula`* for Homebrew coding style violations. This should be run
+before submitting a new formula or cask. If no *`formula`*\|*`cask`* are
+provided, check all locally available formulae and casks and skip style checks.
+Will exit with a non-zero status if any errors are found.
+
+`--os`
+
+: Audit the given operating system. (Pass `all` to audit all operating systems.)
+
+`--arch`
+
+: Audit the given CPU architecture. (Pass `all` to audit all architectures.)
+
+`--strict`
+
+: Run additional, stricter style checks.
+
+`--git`
+
+: Run additional, slower style checks that navigate the Git repository.
+
+`--online`
+
+: Run additional, slower style checks that require a network connection.
+
+`--installed`
+
+: Only check formulae and casks that are currently installed.
+
+`--eval-all`
+
+: Evaluate all available formulae and casks, whether installed or not, to audit
+  them. Implied if `HOMEBREW_EVAL_ALL` is set.
+
+`--new`
+
+: Run various additional style checks to determine if a new formula or cask is
+  eligible for Homebrew. This should be used when creating new formulae or casks
+  and implies `--strict` and `--online`.
+
+`--[no-]signing`
+
+: Audit for signed apps, which are required on ARM
+
+`--token-conflicts`
+
+: Audit for token conflicts.
+
+`--tap`
+
+: Check the formulae within the given tap, specified as *`user`*`/`*`repo`*.
+
+`--fix`
+
+: Fix style violations automatically using RuboCop's auto-correct feature.
+
+`--display-filename`
+
+: Prefix every line of output with the file or formula name being audited, to
+  make output easy to grep.
+
+`--skip-style`
+
+: Skip running non-RuboCop style checks. Useful if you plan on running `brew
+  style` separately. Enabled by default unless a formula is specified by name.
+
+`-D`, `--audit-debug`
+
+: Enable debugging and profiling of audit methods.
+
+`--only`
+
+: Specify a comma-separated *`method`* list to only run the methods named
+  `audit_`*`method`*.
+
+`--except`
+
+: Specify a comma-separated *`method`* list to skip running the methods named
+  `audit_`*`method`*.
+
+`--only-cops`
+
+: Specify a comma-separated *`cops`* list to check for violations of only the
+  listed RuboCop cops.
+
+`--except-cops`
+
+: Specify a comma-separated *`cops`* list to skip checking for violations of the
+  listed RuboCop cops.
+
+`--formula`
+
+: Treat all named arguments as formulae.
+
+`--cask`
+
+: Treat all named arguments as casks.
+
+### `bottle` \[*`options`*\] *`installed_formula`*\|*`file`* \[...\]
+
+Generate a bottle (binary package) from a formula that was installed with
+`--build-bottle`. If the formula specifies a rebuild version, it will be
+incremented in the generated DSL. Passing `--keep-old` will attempt to keep it
+at its original value, while `--no-rebuild` will remove it.
+
+`--skip-relocation`
+
+: Do not check if the bottle can be marked as relocatable.
+
+`--force-core-tap`
+
+: Build a bottle even if *`formula`* is not in `homebrew/core` or any installed
+  taps.
+
+`--no-rebuild`
+
+: If the formula specifies a rebuild version, remove it from the generated DSL.
+
+`--keep-old`
+
+: If the formula specifies a rebuild version, attempt to preserve its value in
+  the generated DSL.
+
+`--json`
+
+: Write bottle information to a JSON file, which can be used as the value for
+  `--merge`.
+
+`--merge`
+
+: Generate an updated bottle block for a formula and optionally merge it into
+  the formula file. Instead of a formula name, requires the path to a JSON file
+  generated with `brew bottle --json` *`formula`*.
+
+`--write`
+
+: Write changes to the formula file. A new commit will be generated unless
+  `--no-commit` is passed.
+
+`--no-commit`
+
+: When passed with `--write`, a new commit will not generated after writing
+  changes to the formula file.
+
+`--only-json-tab`
+
+: When passed with `--json`, the tab will be written to the JSON file but not
+  the bottle.
+
+`--no-all-checks`
+
+: Don't try to create an `all` bottle or stop a no-change upload.
+
+`--committer`
+
+: Specify a committer name and email in `git`'s standard author format.
+
+`--root-url`
+
+: Use the specified *`URL`* as the root of the bottle's URL instead of
+  Homebrew's default.
+
+`--root-url-using`
+
+: Use the specified download strategy class for downloading the bottle's URL
+  instead of Homebrew's default.
+
+### `bump` \[*`options`*\] \[*`formula`*\|*`cask`* ...\]
+
+Displays out-of-date packages and the latest version available. If the returned
+current and livecheck versions differ or when querying specific packages, also
+displays whether a pull request has been opened with the URL.
+
+`--full-name`
+
+: Print formulae/casks with fully-qualified names.
+
+`--no-pull-requests`
+
+: Do not retrieve pull requests from GitHub.
+
+`--formula`
+
+: Check only formulae.
+
+`--cask`
+
+: Check only casks.
+
+`--eval-all`
+
+: Evaluate all formulae and casks.
+
+`--repology`
+
+: Use Repology to check for outdated packages.
+
+`--tap`
+
+: Check formulae and casks within the given tap, specified as
+  *`user`*`/`*`repo`*.
+
+`--installed`
+
+: Check formulae and casks that are currently installed.
+
+`--no-fork`
+
+: Don't try to fork the repository.
+
+`--open-pr`
+
+: Open a pull request for the new version if none have been opened yet.
+
+`--start-with`
+
+: Letter or word that the list of package results should alphabetically follow.
+
+### `bump-cask-pr` \[*`options`*\] *`cask`*
+
+Create a pull request to update *`cask`* with a new version.
+
+A best effort to determine the *`SHA-256`* will be made if the value is not
+supplied by the user.
+
+`-n`, `--dry-run`
+
+: Print what would be done rather than doing it.
+
+`--write-only`
+
+: Make the expected file modifications without taking any Git actions.
+
+`--commit`
+
+: When passed with `--write-only`, generate a new commit after writing changes
+  to the cask file.
+
+`--no-audit`
+
+: Don't run `brew audit` before opening the PR.
+
+`--no-style`
+
+: Don't run `brew style --fix` before opening the PR.
+
+`--no-browse`
+
+: Print the pull request URL instead of opening in a browser.
+
+`--no-fork`
+
+: Don't try to fork the repository.
+
+`--version`
+
+: Specify the new *`version`* for the cask.
+
+`--version-arm`
+
+: Specify the new cask *`version`* for the ARM architecture.
+
+`--version-intel`
+
+: Specify the new cask *`version`* for the Intel architecture.
+
+`--message`
+
+: Prepend *`message`* to the default pull request message.
+
+`--url`
+
+: Specify the *`URL`* for the new download.
+
+`--sha256`
+
+: Specify the *`SHA-256`* checksum of the new download.
+
+`--fork-org`
+
+: Use the specified GitHub organization for forking.
+
+### `bump-formula-pr` \[*`options`*\] \[*`formula`*\]
+
+Create a pull request to update *`formula`* with a new URL or a new tag.
+
+If a *`URL`* is specified, the *`SHA-256`* checksum of the new download should
+also be specified. A best effort to determine the *`SHA-256`* will be made if
+not supplied by the user.
+
+If a *`tag`* is specified, the Git commit *`revision`* corresponding to that tag
+should also be specified. A best effort to determine the *`revision`* will be
+made if the value is not supplied by the user.
+
+If a *`version`* is specified, a best effort to determine the *`URL`* and
+*`SHA-256`* or the *`tag`* and *`revision`* will be made if both values are not
+supplied by the user.
+
+*Note:* this command cannot be used to transition a formula from a
+URL-and-SHA-256 style specification into a tag-and-revision style specification,
+nor vice versa. It must use whichever style specification the formula already
+uses.
+
+`-n`, `--dry-run`
+
+: Print what would be done rather than doing it.
+
+`--write-only`
+
+: Make the expected file modifications without taking any Git actions.
+
+`--commit`
+
+: When passed with `--write-only`, generate a new commit after writing changes
+  to the formula file.
+
+`--no-audit`
+
+: Don't run `brew audit` before opening the PR.
+
+`--strict`
+
+: Run `brew audit --strict` before opening the PR.
+
+`--online`
+
+: Run `brew audit --online` before opening the PR.
+
+`--no-browse`
+
+: Print the pull request URL instead of opening in a browser.
+
+`--no-fork`
+
+: Don't try to fork the repository.
+
+`--mirror`
+
+: Use the specified *`URL`* as a mirror URL. If *`URL`* is a comma-separated
+  list of URLs, multiple mirrors will be added.
+
+`--fork-org`
+
+: Use the specified GitHub organization for forking.
+
+`--version`
+
+: Use the specified *`version`* to override the value parsed from the URL or
+  tag. Note that `--version=0` can be used to delete an existing version
+  override from a formula if it has become redundant.
+
+`--message`
+
+: Prepend *`message`* to the default pull request message.
+
+`--url`
+
+: Specify the *`URL`* for the new download. If a *`URL`* is specified, the
+  *`SHA-256`* checksum of the new download should also be specified.
+
+`--sha256`
+
+: Specify the *`SHA-256`* checksum of the new download.
+
+`--tag`
+
+: Specify the new git commit *`tag`* for the formula.
+
+`--revision`
+
+: Specify the new commit *`revision`* corresponding to the specified git *`tag`*
+  or specified *`version`*.
+
+`-f`, `--force`
+
+: Remove all mirrors if `--mirror` was not specified.
+
+`--install-dependencies`
+
+: Install missing dependencies required to update resources.
+
+`--python-package-name`
+
+: Use the specified *`package-name`* when finding Python resources for
+  *`formula`*. If no package name is specified, it will be inferred from the
+  formula's stable URL.
+
+`--python-extra-packages`
+
+: Include these additional Python packages when finding resources.
+
+`--python-exclude-packages`
+
+: Exclude these Python packages when finding resources.
+
+### `bump-revision` \[*`options`*\] *`formula`* \[...\]
+
+Create a commit to increment the revision of *`formula`*. If no revision is
+present, "revision 1" will be added.
+
+`-n`, `--dry-run`
+
+: Print what would be done rather than doing it.
+
+`--remove-bottle-block`
+
+: Remove the bottle block in addition to bumping the revision.
+
+`--write-only`
+
+: Make the expected file modifications without taking any Git actions.
+
+`--message`
+
+: Append *`message`* to the default commit message.
+
+### `bump-unversioned-casks` \[*`options`*\] *`cask`*\|*`tap`* \[...\]
+
+Check all casks with unversioned URLs in a given *`tap`* for updates.
+
+`-n`, `--dry-run`
+
+: Do everything except caching state and opening pull requests.
+
+`--limit`
+
+: Maximum runtime in minutes.
+
+`--state-file`
+
+: File for caching state.
+
+### `cat` \[`--formula`\] \[`--cask`\] *`formula`*\|*`cask`* \[...\]
+
+Display the source of a *`formula`* or *`cask`*.
+
+`--formula`
+
+: Treat all named arguments as formulae.
+
+`--cask`
+
+: Treat all named arguments as casks.
+
+### `contributions` \[--user=*`email|username`*\] \[*`--repositories`*`=`\] \[*`--csv`*\]
+
+Summarise contributions to Homebrew repositories.
+
+`--repositories`
+
+: Specify a comma-separated list of repositories to search. Supported
+  repositories: `brew`, `core`, `cask`, `aliases`, `bundle`,
+  `command-not-found`, `test-bot` and `services`. Omitting this flag, or
+  specifying `--repositories=primary`, searches only the main repositories:
+  brew,core,cask. Specifying `--repositories=all`, searches all repositories.
+
+`--from`
+
+: Date (ISO-8601 format) to start searching contributions. Omitting this flag
+  searches the last year.
+
+`--to`
+
+: Date (ISO-8601 format) to stop searching contributions.
+
+`--user`
+
+: Specify a comma-separated list of GitHub usernames or email addresses to find
+  contributions from. Omitting this flag searches maintainers.
+
+`--csv`
+
+: Print a CSV of contributions across repositories over the time period.
+
+### `create` \[*`options`*\] *`URL`*
+
+Generate a formula or, with `--cask`, a cask for the downloadable file at
+*`URL`* and open it in the editor. Homebrew will attempt to automatically derive
+the formula name and version, but if it fails, you'll have to make your own
+template. The `wget` formula serves as a simple example. For the complete API,
+see: <https://rubydoc.brew.sh/Formula>
+
+`--autotools`
+
+: Create a basic template for an Autotools-style build.
+
+`--cask`
+
+: Create a basic template for a cask.
+
+`--cmake`
+
+: Create a basic template for a CMake-style build.
+
+`--crystal`
+
+: Create a basic template for a Crystal build.
+
+`--go`
+
+: Create a basic template for a Go build.
+
+`--meson`
+
+: Create a basic template for a Meson-style build.
+
+`--node`
+
+: Create a basic template for a Node build.
+
+`--perl`
+
+: Create a basic template for a Perl build.
+
+`--python`
+
+: Create a basic template for a Python build.
+
+`--ruby`
+
+: Create a basic template for a Ruby build.
+
+`--rust`
+
+: Create a basic template for a Rust build.
+
+`--no-fetch`
+
+: Homebrew will not download *`URL`* to the cache and will thus not add its
+  SHA-256 to the formula for you, nor will it check the GitHub API for GitHub
+  projects (to fill out its description and homepage).
+
+`--HEAD`
+
+: Indicate that *`URL`* points to the package's repository rather than a file.
+
+`--set-name`
+
+: Explicitly set the *`name`* of the new formula or cask.
+
+`--set-version`
+
+: Explicitly set the *`version`* of the new formula or cask.
+
+`--set-license`
+
+: Explicitly set the *`license`* of the new formula.
+
+`--tap`
+
+: Generate the new formula within the given tap, specified as
+  *`user`*`/`*`repo`*.
+
+`-f`, `--force`
+
+: Ignore errors for disallowed formula names and names that shadow aliases.
+
+### `debugger` \[`--open`\] *`command`* \[...\]
+
+Run the specified Homebrew command in debug mode.
+
+To pass flags to the command, use `--` to separate them from the `brew` flags.
+For example: `brew debugger -- list --formula`.
+
+`-O`, `--open`
+
+: Start remote debugging over a Unix socket.
+
+### `dispatch-build-bottle` \[*`options`*\] *`formula`* \[...\]
+
+Build bottles for these formulae with GitHub Actions.
+
+`--tap`
+
+: Target tap repository (default: `homebrew/core`).
+
+`--timeout`
+
+: Build timeout (in minutes, default: 60).
+
+`--issue`
+
+: If specified, post a comment to this issue number if the job fails.
+
+`--macos`
+
+: macOS version (or comma-separated list of versions) the bottle should be built
+  for.
+
+`--workflow`
+
+: Dispatch specified workflow (default: `dispatch-build-bottle.yml`).
+
+`--upload`
+
+: Upload built bottles.
+
+`--linux`
+
+: Dispatch bottle for Linux (using GitHub runners).
+
+`--linux-self-hosted`
+
+: Dispatch bottle for Linux (using self-hosted runner).
+
+`--linux-wheezy`
+
+: Use Debian Wheezy container for building the bottle on Linux.
+
+### `edit` \[*`options`*\] \[*`formula`*\|*`cask`*\|*`tap`* ...\]
+
+Open a *`formula`*, *`cask`* or *`tap`* in the editor set by `EDITOR` or
+`HOMEBREW_EDITOR`, or open the Homebrew repository for editing if no argument is
+provided.
+
+`--formula`
+
+: Treat all named arguments as formulae.
+
+`--cask`
+
+: Treat all named arguments as casks.
+
+`--print-path`
+
+: Print the file path to be edited, without opening an editor.
+
+### `extract` \[`--version=`\] \[`--git-revision=`\] \[`--force`\] *`formula`* *`tap`*
+
+Look through repository history to find the most recent version of *`formula`*
+and create a copy in *`tap`*. Specifically, the command will create the new
+formula file at *`tap`*`/Formula/`*`formula`*`@`*`version`*`.rb`. If the tap is
+not installed yet, attempt to install/clone the tap before continuing. To
+extract a formula from a tap that is not `homebrew/core` use its fully-qualified
+form of *`user`*`/`*`repo`*`/`*`formula`*.
+
+`--git-revision`
+
+: Search for the specified *`version`* of *`formula`* starting at *`revision`*
+  instead of HEAD.
+
+`--version`
+
+: Extract the specified *`version`* of *`formula`* instead of the most recent.
+
+`-f`, `--force`
+
+: Overwrite the destination formula if it already exists.
+
+### `formula` *`formula`* \[...\]
+
+Display the path where *`formula`* is located.
+
+### `generate-cask-api` \[`--dry-run`\]
+
+Generate `homebrew/cask` API data files for <https://formulae.brew.sh>. The
+generated files are written to the current directory.
+
+`-n`, `--dry-run`
+
+: Generate API data without writing it to files.
+
+### `generate-formula-api` \[`--dry-run`\]
+
+Generate `homebrew/core` API data files for <https://formulae.brew.sh>. The
+generated files are written to the current directory.
+
+`-n`, `--dry-run`
+
+: Generate API data without writing it to files.
+
+### `generate-man-completions`
+
+Generate Homebrew's manpages and shell completions.
+
+### `install-bundler-gems` \[`--groups=`\] \[`--add-groups=`\]
+
+Install Homebrew's Bundler gems.
+
+`--groups`
+
+: Installs the specified comma-separated list of gem groups (default: last
+  used). Replaces any previously installed groups.
+
+`--add-groups`
+
+: Installs the specified comma-separated list of gem groups, in addition to
+  those already installed.
+
+### `irb` \[`--examples`\] \[`--pry`\]
+
+Enter the interactive Homebrew Ruby shell.
+
+`--examples`
+
+: Show several examples.
+
+`--pry`
+
+: Use Pry instead of IRB. Implied if `HOMEBREW_PRY` is set.
+
+### `linkage` \[*`options`*\] \[*`installed_formula`* ...\]
+
+Check the library links from the given *`formula`* kegs. If no *`formula`* are
+provided, check all kegs. Raises an error if run on uninstalled formulae.
+
+`--test`
+
+: Show only missing libraries and exit with a non-zero status if any missing
+  libraries are found.
+
+`--strict`
+
+: Exit with a non-zero status if any undeclared dependencies with linkage are
+  found.
+
+`--reverse`
+
+: For every library that a keg references, print its dylib path followed by the
+  binaries that link to it.
+
+`--cached`
+
+: Print the cached linkage values stored in `HOMEBREW_CACHE`, set by a previous
+  `brew linkage` run.
+
+### `livecheck`, `lc` \[*`options`*\] \[*`formula`*\|*`cask`* ...\]
+
+Check for newer versions of formulae and/or casks from upstream. If no formula
+or cask argument is passed, the list of formulae and casks to check is taken
+from `HOMEBREW_LIVECHECK_WATCHLIST` or `~/.homebrew/livecheck_watchlist.txt`.
+
+`--full-name`
+
+: Print formulae and casks with fully-qualified names.
+
+`--tap`
+
+: Check formulae and casks within the given tap, specified as
+  *`user`*`/`*`repo`*.
+
+`--eval-all`
+
+: Evaluate all available formulae and casks, whether installed or not, to check
+  them.
+
+`--installed`
+
+: Check formulae and casks that are currently installed.
+
+`--newer-only`
+
+: Show the latest version only if it's newer than the formula/cask.
+
+`--json`
+
+: Output information in JSON format.
+
+`-r`, `--resources`
+
+: Also check resources for formulae.
+
+`-q`, `--quiet`
+
+: Suppress warnings, don't print a progress bar for JSON output.
+
+`--formula`
+
+: Only check formulae.
+
+`--cask`
+
+: Only check casks.
+
+`--extract-plist`
+
+: Enable checking multiple casks with ExtractPlist strategy.
+
+### `pr-automerge` \[*`options`*\]
+
+Find pull requests that can be automatically merged using `brew pr-publish`.
+
+`--tap`
+
+: Target tap repository (default: `homebrew/core`).
+
+`--workflow`
+
+: Workflow file to use with `brew pr-publish`.
+
+`--with-label`
+
+: Pull requests must have this label.
+
+`--without-labels`
+
+: Pull requests must not have these labels (default: `do not merge`, `new
+  formula`, `automerge-skip`, `pre-release`, `CI-published-bottle-commits`).
+
+`--without-approval`
+
+: Pull requests do not require approval to be merged.
+
+`--publish`
+
+: Run `brew pr-publish` on matching pull requests.
+
+`--autosquash`
+
+: Instruct `brew pr-publish` to automatically reformat and reword commits in the
+  pull request to the preferred format.
+
+`--ignore-failures`
+
+: Include pull requests that have failing status checks.
+
+### `pr-publish` \[*`options`*\] *`pull_request`* \[...\]
+
+Publish bottles for a pull request with GitHub Actions. Requires write access to
+the repository.
+
+`--autosquash`
+
+: If supported on the target tap, automatically reformat and reword commits to
+  our preferred format.
+
+`--large-runner`
+
+: Run the upload job on a large runner.
+
+`--branch`
+
+: Branch to use the workflow from (default: `master`).
+
+`--message`
+
+: Message to include when autosquashing revision bumps, deletions and rebuilds.
+
+`--tap`
+
+: Target tap repository (default: `homebrew/core`).
+
+`--workflow`
+
+: Target workflow filename (default: `publish-commit-bottles.yml`).
+
+### `pr-pull` \[*`options`*\] *`pull_request`* \[...\]
+
+Download and publish bottles and apply the bottle commit from a pull request
+with artifacts generated by GitHub Actions. Requires write access to the
+repository.
+
+`--no-upload`
+
+: Download the bottles but don't upload them.
+
+`--no-commit`
+
+: Do not generate a new commit before uploading.
+
+`--no-cherry-pick`
+
+: Do not cherry-pick commits from the pull request branch.
+
+`-n`, `--dry-run`
+
+: Print what would be done rather than doing it.
+
+`--clean`
+
+: Do not amend the commits from pull requests.
+
+`--keep-old`
+
+: If the formula specifies a rebuild version, attempt to preserve its value in
+  the generated DSL.
+
+`--autosquash`
+
+: Automatically reformat and reword commits in the pull request to our preferred
+  format.
+
+`--branch-okay`
+
+: Do not warn if pulling to a branch besides the repository default (useful for
+  testing).
+
+`--resolve`
+
+: When a patch fails to apply, leave in progress and allow user to resolve,
+  instead of aborting.
+
+`--warn-on-upload-failure`
+
+: Warn instead of raising an error if the bottle upload fails. Useful for
+  repairing bottle uploads that previously failed.
+
+`--retain-bottle-dir`
+
+: Does not clean up the tmp directory for the bottle so it can be used later.
+
+`--committer`
+
+: Specify a committer name and email in `git`'s standard author format.
+
+`--message`
+
+: Message to include when autosquashing revision bumps, deletions and rebuilds.
+
+`--artifact-pattern`
+
+: Download artifacts with the specified pattern (default: `bottles{,_*}`).
+
+`--tap`
+
+: Target tap repository (default: `homebrew/core`).
+
+`--root-url`
+
+: Use the specified *`URL`* as the root of the bottle's URL instead of
+  Homebrew's default.
+
+`--root-url-using`
+
+: Use the specified download strategy class for downloading the bottle's URL
+  instead of Homebrew's default.
+
+`--workflows`
+
+: Retrieve artifacts from the specified workflow (default: `tests.yml`). Can be
+  a comma-separated list to include multiple workflows.
+
+`--ignore-missing-artifacts`
+
+: Comma-separated list of workflows which can be ignored if they have not been
+  run.
+
+### `pr-upload` \[*`options`*\]
+
+Apply the bottle commit and publish bottles to a host.
+
+`--keep-old`
+
+: If the formula specifies a rebuild version, attempt to preserve its value in
+  the generated DSL.
+
+`-n`, `--dry-run`
+
+: Print what would be done rather than doing it.
+
+`--no-commit`
+
+: Do not generate a new commit before uploading.
+
+`--warn-on-upload-failure`
+
+: Warn instead of raising an error if the bottle upload fails. Useful for
+  repairing bottle uploads that previously failed.
+
+`--upload-only`
+
+: Skip running `brew bottle` before uploading.
+
+`--committer`
+
+: Specify a committer name and email in `git`'s standard author format.
+
+`--root-url`
+
+: Use the specified *`URL`* as the root of the bottle's URL instead of
+  Homebrew's default.
+
+`--root-url-using`
+
+: Use the specified download strategy class for downloading the bottle's URL
+  instead of Homebrew's default.
+
+### `prof` \[`--stackprof`\] \[`--vernier`\] *`command`* \[...\]
+
+Run Homebrew with a Ruby profiler. For example, `brew prof readall`.
+
+`--stackprof`
+
+: Use `stackprof` instead of `ruby-prof` (the default).
+
+`--vernier`
+
+: Use `vernier` instead of `ruby-prof` (the default).
+
+### `release` \[`--major`\] \[`--minor`\]
+
+Create a new draft Homebrew/brew release with the appropriate version number and
+release notes.
+
+By default, `brew release` will bump the patch version number. Pass `--major` or
+`--minor` to bump the major or minor version numbers, respectively. The command
+will fail if the previous major or minor release was made less than one month
+ago.
+
+*Note:* Requires write access to the Homebrew/brew repository.
+
+`--major`
+
+: Create a major release.
+
+`--minor`
+
+: Create a minor release.
+
+### `rubocop`
+
+Installs, configures and runs Homebrew's `rubocop`.
+
+### `ruby` \[*`options`*\] (`-e` *`text`*\|*`file`*)
+
+Run a Ruby instance with Homebrew's libraries loaded. For example, `brew ruby -e
+"puts :gcc.f.deps"` or `brew ruby script.rb`.
+
+Run e.g. `brew ruby -- --version` to pass arbitrary arguments to `ruby`.
+
+`-r`
+
+: Load a library using `require`.
+
+`-e`
+
+: Execute the given text string as a script.
+
+### `rubydoc` \[`--only-public`\] \[`--open`\]
+
+Generate Homebrew's RubyDoc documentation.
+
+`--only-public`
+
+: Only generate public API documentation.
+
+`--open`
+
+: Open generated documentation in a browser.
+
+### `sh` \[`--env=`\] \[`--cmd=`\] \[*`file`*\]
+
+Enter an interactive shell for Homebrew's build environment. Use
+years-battle-hardened build logic to help your `./configure && make && make
+install` and even your `gem install` succeed. Especially handy if you run
+Homebrew in an Xcode-only configuration since it adds tools like `make` to your
+`PATH` which build systems would not find otherwise.
+
+`--env`
+
+: Use the standard `PATH` instead of superenv's when `std` is passed.
+
+`-c`, `--cmd`
+
+: Execute commands in a non-interactive shell.
+
+### `style` \[*`options`*\] \[*`file`*\|*`tap`*\|*`formula`*\|*`cask`* ...\]
+
+Check formulae or files for conformance to Homebrew style guidelines.
+
+Lists of *`file`*, *`tap`* and *`formula`* may not be combined. If none are
+provided, `style` will run style checks on the whole Homebrew library, including
+core code and all formulae.
+
+`--fix`
+
+: Fix style violations automatically using RuboCop's auto-correct feature.
+
+`--reset-cache`
+
+: Reset the RuboCop cache.
+
+`--formula`
+
+: Treat all named arguments as formulae.
+
+`--cask`
+
+: Treat all named arguments as casks.
+
+`--only-cops`
+
+: Specify a comma-separated *`cops`* list to check for violations of only the
+  listed RuboCop cops.
+
+`--except-cops`
+
+: Specify a comma-separated *`cops`* list to skip checking for violations of the
+  listed RuboCop cops.
+
+### `tap-new` \[*`options`*\] *`user`*`/`*`repo`*
+
+Generate the template files for a new tap.
+
+`--no-git`
+
+: Don't initialize a Git repository for the tap.
+
+`--pull-label`
+
+: Label name for pull requests ready to be pulled (default: `pr-pull`).
+
+`--branch`
+
+: Initialize Git repository and setup GitHub Actions workflows with the
+  specified branch name (default: `main`).
+
+`--github-packages`
+
+: Upload bottles to GitHub Packages.
+
+### `test` \[*`options`*\] *`installed_formula`* \[...\]
+
+Run the test method provided by an installed formula. There is no standard
+output or return code, but generally it should notify the user if something is
+wrong with the installed formula.
+
+*Example:* `brew install jruby && brew test jruby`
+
+`-f`, `--force`
+
+: Test formulae even if they are unlinked.
+
+`--HEAD`
+
+: Test the HEAD version of a formula.
+
+`--keep-tmp`
+
+: Retain the temporary files created for the test.
+
+`--retry`
+
+: Retry if a testing fails.
+
+### `tests` \[*`options`*\]
+
+Run Homebrew's unit and integration tests.
+
+`--coverage`
+
+: Generate code coverage reports.
+
+`--generic`
+
+: Run only OS-agnostic tests.
+
+`--online`
+
+: Include tests that use the GitHub API and tests that use any of the taps for
+  official external commands.
+
+`--debug`
+
+: Enable debugging using `ruby/debug`, or surface the standard `odebug` output.
+
+`--changed`
+
+: Only runs tests on files that were changed from the master branch.
+
+`--fail-fast`
+
+: Exit early on the first failing test.
+
+`--only`
+
+: Run only `<test_script>_spec.rb`. Appending `:<line_number>` will start at a
+  specific line.
+
+`--profile`
+
+: Run the test suite serially to find the *`n`* slowest tests.
+
+`--seed`
+
+: Randomise tests with the specified *`value`* instead of a random seed.
+
+### `typecheck`, `tc` \[*`options`*\] \[*`tap`* ...\]
+
+Check for typechecking errors using Sorbet.
+
+`--fix`
+
+: Automatically fix type errors.
+
+`-q`, `--quiet`
+
+: Silence all non-critical errors.
+
+`--update`
+
+: Update RBI files.
+
+`--update-all`
+
+: Update all RBI files rather than just updated gems.
+
+`--suggest-typed`
+
+: Try upgrading `typed` sigils.
+
+`--lsp`
+
+: Start the Sorbet LSP server.
+
+`--dir`
+
+: Typecheck all files in a specific directory.
+
+`--file`
+
+: Typecheck a single file.
+
+`--ignore`
+
+: Ignores input files that contain the given string in their paths (relative to
+  the input path passed to Sorbet).
+
+### `unbottled` \[*`options`*\] \[*`formula`* ...\]
+
+Show the unbottled dependents of formulae.
+
+`--tag`
+
+: Use the specified bottle tag (e.g. `big_sur`) instead of the current OS.
+
+`--dependents`
+
+: Skip getting analytics data and sort by number of dependents instead.
+
+`--total`
+
+: Print the number of unbottled and total formulae.
+
+`--lost`
+
+: Print the `homebrew/core` commits where bottles were lost in the last week.
+
+`--eval-all`
+
+: Evaluate all available formulae and casks, whether installed or not, to check
+  them. Implied if `HOMEBREW_EVAL_ALL` is set.
+
+### `unpack` \[*`options`*\] *`formula`* \[...\]
+
+Unpack the source files for *`formula`* into subdirectories of the current
+working directory.
+
+`--destdir`
+
+: Create subdirectories in the directory named by *`path`* instead.
+
+`--patch`
+
+: Patches for *`formula`* will be applied to the unpacked source.
+
+`-g`, `--git`
+
+: Initialise a Git repository in the unpacked source. This is useful for
+  creating patches for the software.
+
+`-f`, `--force`
+
+: Overwrite the destination directory if it already exists.
+
+### `update-license-data`
+
+Update SPDX license data in the Homebrew repository.
+
+### `update-maintainers`
+
+Update the list of maintainers in the `Homebrew/brew` README.
 
-With `--verbose` or `--debug`, many commands print extra debugging information.
-Note that these options should only appear after a command.
+### `update-python-resources` \[*`options`*\] *`formula`* \[...\]
 
-Some command behaviour can be customised with environment variables; see the [ENVIRONMENT](#environment) section.
+Update versions for PyPI resource blocks in *`formula`*.
 
-### `install` *`formula`*
+`-p`, `--print-only`
 
-Install *`formula`*.
+: Print the updated resource blocks instead of changing *`formula`*.
 
-*`formula`* is usually the name of the formula to install, but it has other
-syntaxes which are listed in the [SPECIFYING FORMULAE](#specifying-formulae)
-section.
+`-s`, `--silent`
 
-### `uninstall` *`formula`*
+: Suppress any output.
 
-Uninstall *`formula`*.
+`--ignore-non-pypi-packages`
 
-### `list`
+: Don't fail if *`formula`* is not a PyPI package.
 
-List all installed formulae.
+`--install-dependencies`
 
-### `search` [*`text`*|`/`*`text`*`/`]
+: Install missing dependencies required to update resources.
 
-Perform a substring search of cask tokens and formula names for *`text`*. If
-*`text`* is flanked by slashes, it is interpreted as a regular expression.
-The search for *`text`* is extended online to `homebrew/core` and `homebrew/cask`.
-If no search term is provided, all locally available formulae are listed.
+`--version`
 
-## COMMANDS
+: Use the specified *`version`* when finding resources for *`formula`*. If no
+  version is specified, the current version for *`formula`* will be used.
 
-### `analytics` [*`subcommand`*]
+`--package-name`
 
-Control Homebrew's anonymous aggregate user behaviour analytics.
-Read more at <https://docs.brew.sh/Analytics>.
+: Use the specified *`package-name`* when finding resources for *`formula`*. If
+  no package name is specified, it will be inferred from the formula's stable
+  URL.
 
-`brew analytics` [`state`]
-<br>Display the current state of Homebrew's analytics.
+`--extra-packages`
 
-`brew analytics` (`on`|`off`)
-<br>Turn Homebrew's analytics on or off respectively.
+: Include these additional packages when finding resources.
 
-`brew analytics regenerate-uuid`
-<br>Regenerate the UUID used for Homebrew's analytics.
+`--exclude-packages`
 
-### `autoremove` [*`--dry-run`*]
+: Exclude these packages when finding resources.
 
-Uninstall formulae that were only installed as a dependency of another formula and are now no longer needed.
+### `update-sponsors`
 
-* `-n`, `--dry-run`:
-  List what would be uninstalled, but do not actually uninstall anything.
+Update the list of GitHub Sponsors in the `Homebrew/brew` README.
 
-### `casks`
+### `update-test` \[*`options`*\]
 
-List all locally installable casks including short names.
+Run a test of `brew update` with a new repository clone. If no options are
+passed, use `origin/master` as the start commit.
 
-### `cleanup` [*`options`*] [*`formula`*|*`cask`* ...]
+`--to-tag`
 
-Remove stale lock files and outdated downloads for all formulae and casks,
-and remove old versions of installed formulae. If arguments are specified,
-only do this for the given formulae and casks. Removes all downloads more than
-120 days old. This can be adjusted with `HOMEBREW_CLEANUP_MAX_AGE_DAYS`.
+: Set `HOMEBREW_UPDATE_TO_TAG` to test updating between tags.
 
-* `--prune`:
-  Remove all cache files older than specified *`days`*. If you want to remove everything, use `--prune=all`.
-* `-n`, `--dry-run`:
-  Show what would be removed, but do not actually remove anything.
-* `-s`:
-  Scrub the cache, including downloads for even the latest versions. Note that downloads for any installed formulae or casks will still not be deleted. If you want to delete those too: `rm -rf "$(brew --cache)"`
-* `--prune-prefix`:
-  Only prune the symlinks and directories from the prefix and remove no other files.
+`--keep-tmp`
 
-### `commands` [*`--quiet`*] [*`--include-aliases`*]
+: Retain the temporary directory containing the new repository clone.
 
-Show lists of built-in and external commands.
+`--commit`
 
-* `-q`, `--quiet`:
-  List only the names of commands without category headers.
-* `--include-aliases`:
-  Include aliases of internal commands.
+: Use the specified *`commit`* as the start commit.
 
-### `completions` [*`subcommand`*]
+`--before`
 
-Control whether Homebrew automatically links external tap shell completion files.
-Read more at <https://docs.brew.sh/Shell-Completion>.
+: Use the commit at the specified *`date`* as the start commit.
 
-`brew completions` [`state`]
-<br>Display the current state of Homebrew's completions.
+### `vendor-gems` \[`--update=`\] \[`--no-commit`\]
 
-`brew completions` (`link`|`unlink`)
-<br>Link or unlink Homebrew's completions.
+Install and commit Homebrew's vendored gems.
 
-### `config`, `--config`
+`--update`
 
-Show Homebrew and system configuration info useful for debugging. If you file
-a bug report, you will be required to provide this information.
-
-### `deps` [*`options`*] [*`formula`*|*`cask`* ...]
-
-Show dependencies for *`formula`*. Additional options specific to *`formula`*
-may be appended to the command. When given multiple formula arguments,
-show the intersection of dependencies for each formula.
-
-* `-n`:
-  Sort dependencies in topological order.
-* `--1`:
-  Only show dependencies one level down, instead of recursing.
-* `--union`:
-  Show the union of dependencies for multiple *`formula`*, instead of the intersection.
-* `--full-name`:
-  List dependencies by their full name.
-* `--include-build`:
-  Include `:build` dependencies for *`formula`*.
-* `--include-optional`:
-  Include `:optional` dependencies for *`formula`*.
-* `--include-test`:
-  Include `:test` dependencies for *`formula`* (non-recursive).
-* `--skip-recommended`:
-  Skip `:recommended` dependencies for *`formula`*.
-* `--include-requirements`:
-  Include requirements in addition to dependencies for *`formula`*.
-* `--tree`:
-  Show dependencies as a tree. When given multiple formula arguments, show individual trees for each formula.
-* `--graph`:
-  Show dependencies as a directed graph.
-* `--dot`:
-  Show text-based graph description in DOT format.
-* `--annotate`:
-  Mark any build, test, optional, or recommended dependencies as such in the output.
-* `--installed`:
-  List dependencies for formulae that are currently installed. If *`formula`* is specified, list only its dependencies that are currently installed.
-* `--all`:
-  List dependencies for all available formulae.
-* `--for-each`:
-  Switch into the mode used by the `--all` option, but only list dependencies for each provided *`formula`*, one formula per line. This is used for debugging the `--installed`/`--all` display mode.
-* `--formula`:
-  Treat all named arguments as formulae.
-* `--cask`:
-  Treat all named arguments as casks.
-
-### `desc` [*`options`*] *`formula`*|*`cask`*|*`text`*|`/`*`regex`*`/` [...]
-
-Display *`formula`*'s name and one-line description.
-Formula descriptions are cached; the cache is created on the
-first search, making that search slower than subsequent ones.
+: Update the specified list of vendored gems to the latest version.
 
-* `-s`, `--search`:
-  Search both names and descriptions for *`text`*. If *`text`* is flanked by slashes, it is interpreted as a regular expression.
-* `-n`, `--name`:
-  Search just names for *`text`*. If *`text`* is flanked by slashes, it is interpreted as a regular expression.
-* `-d`, `--description`:
-  Search just descriptions for *`text`*. If *`text`* is flanked by slashes, it is interpreted as a regular expression.
-* `--formula`:
-  Treat all named arguments as formulae.
-* `--cask`:
-  Treat all named arguments as casks.
-
-### `developer` [*`subcommand`*]
-
-Control Homebrew's developer mode. When developer mode is enabled,
-`brew update` will update Homebrew to the latest commit on the `master`
-branch instead of the latest stable version along with some other behaviour changes.
-
-`brew developer` [`state`]
-<br>Display the current state of Homebrew's developer mode.
-
-`brew developer` (`on`|`off`)
-<br>Turn Homebrew's developer mode on or off respectively.
-
-### `doctor`, `dr` [*`--list-checks`*] [*`--audit-debug`*] [*`diagnostic_check`* ...]
-
-Check your system for potential problems. Will exit with a non-zero status
-if any potential problems are found. Please note that these warnings are just
-used to help the Homebrew maintainers with debugging if you file an issue. If
-everything you use Homebrew for is working fine: please don't worry or file
-an issue; just ignore this.
-
-* `--list-checks`:
-  List all audit methods, which can be run individually if provided as arguments.
-* `-D`, `--audit-debug`:
-  Enable debugging and profiling of audit methods.
-
-### `fetch` [*`options`*] *`formula`*|*`cask`* [...]
-
-Download a bottle (if available) or source packages for *`formula`*e
-and binaries for *`cask`*s. For files, also print SHA-256 checksums.
-
-* `--bottle-tag`:
-  Download a bottle for given tag.
-* `--HEAD`:
-  Fetch HEAD version instead of stable version.
-* `-f`, `--force`:
-  Remove a previously cached version and re-fetch.
-* `-v`, `--verbose`:
-  Do a verbose VCS checkout, if the URL represents a VCS. This is useful for seeing if an existing VCS cache has been updated.
-* `--retry`:
-  Retry if downloading fails or re-download if the checksum of a previously cached version no longer matches.
-* `--deps`:
-  Also download dependencies for any listed *`formula`*.
-* `-s`, `--build-from-source`:
-  Download source packages rather than a bottle.
-* `--build-bottle`:
-  Download source packages (for eventual bottling) rather than a bottle.
-* `--force-bottle`:
-  Download a bottle if it exists for the current or newest version of macOS, even if it would not be used during installation.
-* `--[no-]quarantine`:
-  Disable/enable quarantining of downloads (default: enabled).
-* `--formula`:
-  Treat all named arguments as formulae.
-* `--cask`:
-  Treat all named arguments as casks.
+`--no-commit`
 
-### `formulae`
+: Do not generate a new commit upon completion.
 
-List all locally installable formulae including short names.
+## GLOBAL CASK OPTIONS
 
-### `gist-logs` [*`options`*] *`formula`*
-
-Upload logs for a failed build of *`formula`* to a new Gist. Presents an
-error message if no logs are found.
-
-* `--with-hostname`:
-  Include the hostname in the Gist.
-* `-n`, `--new-issue`:
-  Automatically create a new issue in the appropriate GitHub repository after creating the Gist.
-* `-p`, `--private`:
-  The Gist will be marked private and will not appear in listings but will be accessible with its link.
-
-### `home`, `homepage` [*`--formula`*] [*`--cask`*] [*`formula`*|*`cask`* ...]
-
-Open a *`formula`* or *`cask`*'s homepage in a browser, or open
-Homebrew's own homepage if no argument is provided.
-
-* `--formula`:
-  Treat all named arguments as formulae.
-* `--cask`:
-  Treat all named arguments as casks.
-
-### `info`, `abv` [*`options`*] [*`formula`*|*`cask`* ...]
-
-Display brief statistics for your Homebrew installation.
-
-If a *`formula`* or *`cask`* is provided, show summary of information about it.
-
-* `--analytics`:
-  List global Homebrew analytics data or, if specified, installation and build error data for *`formula`* (provided neither `HOMEBREW_NO_ANALYTICS` nor `HOMEBREW_NO_GITHUB_API` are set).
-* `--days`:
-  How many days of analytics data to retrieve. The value for *`days`* must be `30`, `90` or `365`. The default is `30`.
-* `--category`:
-  Which type of analytics data to retrieve. The value for *`category`* must be `install`, `install-on-request` or `build-error`; `cask-install` or `os-version` may be specified if *`formula`* is not. The default is `install`.
-* `--github`:
-  Open the GitHub source page for *`formula`* and *`cask`* in a browser. To view the history locally: `brew log -p` *`formula`* or *`cask`*
-* `--json`:
-  Print a JSON representation. Currently the default value for *`version`* is `v1` for *`formula`*. For *`formula`* and *`cask`* use `v2`. See the docs for examples of using the JSON output: <https://docs.brew.sh/Querying-Brew>
-* `--installed`:
-  Print JSON of formulae that are currently installed.
-* `--all`:
-  Print JSON of all available formulae.
-* `--variations`:
-  Include the variations hash in each formula's JSON output.
-* `-v`, `--verbose`:
-  Show more verbose analytics data for *`formula`*.
-* `--formula`:
-  Treat all named arguments as formulae.
-* `--cask`:
-  Treat all named arguments as casks.
-
-### `install` [*`options`*] *`formula`*|*`cask`* [...]
-
-Install a *`formula`* or *`cask`*. Additional options specific to a *`formula`* may be
-appended to the command.
-
-Unless `HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew reinstall` will be run for
-outdated dependents and dependents with broken linkage, respectively.
+These options are applicable to the `install`, `reinstall` and `upgrade`
+subcommands with the `--cask` switch.
 
-Unless `HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for
-the installed formulae or, every 30 days, for all formulae.
+`--appdir`
 
-Unless `HOMEBREW_NO_INSTALL_UPGRADE` is set, `brew install *`formula`*` will upgrade *`formula`* if it
-is already installed but outdated.
-
-* `-d`, `--debug`:
-  If brewing fails, open an interactive debugging session with access to IRB or a shell inside the temporary build directory.
-* `-f`, `--force`:
-  Install formulae without checking for previously installed keg-only or non-migrated versions. When installing casks, overwrite existing files (binaries and symlinks are excluded, unless originally from the same cask).
-* `-v`, `--verbose`:
-  Print the verification and postinstall steps.
-* `--formula`:
-  Treat all named arguments as formulae.
-* `--ignore-dependencies`:
-  An unsupported Homebrew development flag to skip installing any dependencies of any kind. If the dependencies are not already present, the formula will have issues. If you're not developing Homebrew, consider adjusting your PATH rather than using this flag.
-* `--only-dependencies`:
-  Install the dependencies with specified options but do not install the formula itself.
-* `--cc`:
-  Attempt to compile using the specified *`compiler`*, which should be the name of the compiler's executable, e.g. `gcc-7` for GCC 7. In order to use LLVM's clang, specify `llvm_clang`. To use the Apple-provided clang, specify `clang`. This option will only accept compilers that are provided by Homebrew or bundled with macOS. Please do not file issues if you encounter errors while using this option.
-* `-s`, `--build-from-source`:
-  Compile *`formula`* from source even if a bottle is provided. Dependencies will still be installed from bottles if they are available.
-* `--force-bottle`:
-  Install from a bottle if it exists for the current or newest version of macOS, even if it would not normally be used for installation.
-* `--include-test`:
-  Install testing dependencies required to run `brew test` *`formula`*.
-* `--HEAD`:
-  If *`formula`* defines it, install the HEAD version, aka. main, trunk, unstable, master.
-* `--fetch-HEAD`:
-  Fetch the upstream repository to detect if the HEAD installation of the formula is outdated. Otherwise, the repository's HEAD will only be checked for updates when a new stable or development version has been released.
-* `--keep-tmp`:
-  Retain the temporary files created during installation.
-* `--build-bottle`:
-  Prepare the formula for eventual bottling during installation, skipping any post-install steps.
-* `--bottle-arch`:
-  Optimise bottles for the specified architecture rather than the oldest architecture supported by the version of macOS the bottles are built on.
-* `--display-times`:
-  Print install times for each package at the end of the run.
-* `-i`, `--interactive`:
-  Download and patch *`formula`*, then open a shell. This allows the user to run `./configure --help` and otherwise determine how to turn the software package into a Homebrew package.
-* `-g`, `--git`:
-  Create a Git repository, useful for creating patches to the software.
-* `--overwrite`:
-  Delete files that already exist in the prefix while linking.
-* `--cask`:
-  Treat all named arguments as casks.
-* `--[no-]binaries`:
-  Disable/enable linking of helper executables (default: enabled).
-* `--require-sha`:
-  Require all casks to have a checksum.
-* `--[no-]quarantine`:
-  Disable/enable quarantining of downloads (default: enabled).
-* `--skip-cask-deps`:
-  Skip installing cask dependencies.
-* `--zap`:
-  For use with `brew reinstall --cask`. Remove all files associated with a cask. *May remove files which are shared between applications.*
-
-### `leaves` [*`--installed-on-request`*] [*`--installed-as-dependency`*]
-
-List installed formulae that are not dependencies of another installed formula.
-
-* `-r`, `--installed-on-request`:
-  Only list leaves that were manually installed.
-* `-p`, `--installed-as-dependency`:
-  Only list leaves that were installed as dependencies.
-
-### `link`, `ln` [*`options`*] *`installed_formula`* [...]
-
-Symlink all of *`formula`*'s installed files into Homebrew's prefix. This
-is done automatically when you install formulae but can be useful for DIY
-installations.
+: Target location for Applications (default: `/Applications`).
 
-* `--overwrite`:
-  Delete files that already exist in the prefix while linking.
-* `-n`, `--dry-run`:
-  List files which would be linked or deleted by `brew link --overwrite` without actually linking or deleting any files.
-* `-f`, `--force`:
-  Allow keg-only formulae to be linked.
-* `--HEAD`:
-  Link the HEAD version of the formula if it is installed.
-
-### `list`, `ls` [*`options`*] [*`installed_formula`*|*`installed_cask`* ...]
-
-List all installed formulae and casks.
-
-If *`formula`* is provided, summarise the paths within its current keg.
-If *`cask`* is provided, list its artifacts.
-
-* `--formula`:
-  List only formulae, or treat all named arguments as formulae.
-* `--cask`:
-  List only casks, or treat all named arguments as casks.
-* `--full-name`:
-  Print formulae with fully-qualified names. Unless `--full-name`, `--versions` or `--pinned` are passed, other options (i.e. `-1`, `-l`, `-r` and `-t`) are passed to `ls`(1) which produces the actual output.
-* `--versions`:
-  Show the version number for installed formulae, or only the specified formulae if *`formula`* are provided.
-* `--multiple`:
-  Only show formulae with multiple versions installed.
-* `--pinned`:
-  List only pinned formulae, or only the specified (pinned) formulae if *`formula`* are provided. See also `pin`, `unpin`.
-* `-1`:
-  Force output to be one entry per line. This is the default when output is not to a terminal.
-* `-l`:
-  List formulae and/or casks in long format. Has no effect when a formula or cask name is passed as an argument.
-* `-r`:
-  Reverse the order of the formulae and/or casks sort to list the oldest entries first. Has no effect when a formula or cask name is passed as an argument.
-* `-t`:
-  Sort formulae and/or casks by time modified, listing most recently modified first. Has no effect when a formula or cask name is passed as an argument.
-
-### `log` [*`options`*] [*`formula`*|*`cask`*]
-
-Show the `git log` for *`formula`* or *`cask`*, or show the log for the Homebrew repository
-if no formula or cask is provided.
-
-* `-p`, `--patch`:
-  Also print patch from commit.
-* `--stat`:
-  Also print diffstat from commit.
-* `--oneline`:
-  Print only one line per commit.
-* `-1`:
-  Print only one commit.
-* `-n`, `--max-count`:
-  Print only a specified number of commits.
-* `--formula`:
-  Treat all named arguments as formulae.
-* `--cask`:
-  Treat all named arguments as casks.
-
-### `migrate` [*`--force`*] [*`--dry-run`*] *`installed_formula`* [...]
+`--keyboard-layoutdir`
 
-Migrate renamed packages to new names, where *`formula`* are old names of
-packages.
+: Target location for Keyboard Layouts (default: `/Library/Keyboard Layouts`).
 
-* `-f`, `--force`:
-  Treat installed *`formula`* and provided *`formula`* as if they are from the same taps and migrate them anyway.
-* `-n`, `--dry-run`:
-  Show what would be migrated, but do not actually migrate anything.
+`--colorpickerdir`
 
-### `missing` [*`--hide`*`=`] [*`formula`* ...]
+: Target location for Color Pickers (default: `~/Library/ColorPickers`).
 
-Check the given *`formula`* kegs for missing dependencies. If no *`formula`* are
-provided, check all kegs. Will exit with a non-zero status if any kegs are found
-to be missing dependencies.
+`--prefpanedir`
 
-* `--hide`:
-  Act as if none of the specified *`hidden`* are installed. *`hidden`* should be a comma-separated list of formulae.
+: Target location for Preference Panes (default: `~/Library/PreferencePanes`).
 
-### `options` [*`options`*] [*`formula`* ...]
+`--qlplugindir`
 
-Show install options specific to *`formula`*.
+: Target location for Quick Look Plugins (default: `~/Library/QuickLook`).
 
-* `--compact`:
-  Show all options on a single line separated by spaces.
-* `--installed`:
-  Show options for formulae that are currently installed.
-* `--all`:
-  Show options for all available formulae.
-* `--command`:
-  Show options for the specified *`command`*.
-
-### `outdated` [*`options`*] [*`formula`*|*`cask`* ...]
-
-List installed casks and formulae that have an updated version available. By default, version
-information is displayed in interactive shells, and suppressed otherwise.
-
-* `-q`, `--quiet`:
-  List only the names of outdated kegs (takes precedence over `--verbose`).
-* `-v`, `--verbose`:
-  Include detailed version information.
-* `--formula`:
-  List only outdated formulae.
-* `--cask`:
-  List only outdated casks.
-* `--json`:
-  Print output in JSON format. There are two versions: `v1` and `v2`. `v1` is deprecated and is currently the default if no version is specified. `v2` prints outdated formulae and casks.
-* `--fetch-HEAD`:
-  Fetch the upstream repository to detect if the HEAD installation of the formula is outdated. Otherwise, the repository's HEAD will only be checked for updates when a new stable or development version has been released.
-* `--greedy`:
-  Also include outdated casks with `auto_updates true` or `version :latest`.
-* `--greedy-latest`:
-  Also include outdated casks including those with `version :latest`.
-* `--greedy-auto-updates`:
-  Also include outdated casks including those with `auto_updates true`.
-
-### `pin` *`installed_formula`* [...]
-
-Pin the specified *`formula`*, preventing them from being upgraded when
-issuing the `brew upgrade` *`formula`* command. See also `unpin`.
-
-### `postinstall` *`installed_formula`* [...]
+`--mdimporterdir`
 
-Rerun the post-install steps for *`formula`*.
+: Target location for Spotlight Plugins (default: `~/Library/Spotlight`).
 
-### `readall` [*`--aliases`*] [*`--syntax`*] [*`tap`* ...]
+`--dictionarydir`
 
-Import all items from the specified *`tap`*, or from all installed taps if none is provided.
-This can be useful for debugging issues across all items when making
-significant changes to `formula.rb`, testing the performance of loading
-all items or checking if any current formulae/casks have Ruby issues.
+: Target location for Dictionaries (default: `~/Library/Dictionaries`).
 
-* `--aliases`:
-  Verify any alias symlinks in each tap.
-* `--syntax`:
-  Syntax-check all of Homebrew's Ruby files (if no `*`tap`*` is passed).
-
-### `reinstall` [*`options`*] *`formula`*|*`cask`* [...]
-
-Uninstall and then reinstall a *`formula`* or *`cask`* using the same options it was
-originally installed with, plus any appended options specific to a *`formula`*.
-
-Unless `HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew reinstall` will be run for
-outdated dependents and dependents with broken linkage, respectively.
-
-Unless `HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for the
-reinstalled formulae or, every 30 days, for all formulae.
-
-* `-d`, `--debug`:
-  If brewing fails, open an interactive debugging session with access to IRB or a shell inside the temporary build directory.
-* `-f`, `--force`:
-  Install without checking for previously installed keg-only or non-migrated versions.
-* `-v`, `--verbose`:
-  Print the verification and postinstall steps.
-* `--formula`:
-  Treat all named arguments as formulae.
-* `-s`, `--build-from-source`:
-  Compile *`formula`* from source even if a bottle is available.
-* `-i`, `--interactive`:
-  Download and patch *`formula`*, then open a shell. This allows the user to run `./configure --help` and otherwise determine how to turn the software package into a Homebrew package.
-* `--force-bottle`:
-  Install from a bottle if it exists for the current or newest version of macOS, even if it would not normally be used for installation.
-* `--keep-tmp`:
-  Retain the temporary files created during installation.
-* `--display-times`:
-  Print install times for each formula at the end of the run.
-* `-g`, `--git`:
-  Create a Git repository, useful for creating patches to the software.
-* `--cask`:
-  Treat all named arguments as casks.
-* `--[no-]binaries`:
-  Disable/enable linking of helper executables (default: enabled).
-* `--require-sha`:
-  Require all casks to have a checksum.
-* `--[no-]quarantine`:
-  Disable/enable quarantining of downloads (default: enabled).
-* `--skip-cask-deps`:
-  Skip installing cask dependencies.
-* `--zap`:
-  For use with `brew reinstall --cask`. Remove all files associated with a cask. *May remove files which are shared between applications.*
-
-### `search`, `-S` [*`options`*] *`text`*|`/`*`regex`*`/` [...]
-
-Perform a substring search of cask tokens and formula names for *`text`*. If *`text`*
-is flanked by slashes, it is interpreted as a regular expression.
-The search for *`text`* is extended online to `homebrew/core` and `homebrew/cask`.
-
-* `--formula`:
-  Search online and locally for formulae.
-* `--cask`:
-  Search online and locally for casks.
-* `--desc`:
-  Search for formulae with a description matching *`text`* and casks with a name or description matching *`text`*.
-* `--pull-request`:
-  Search for GitHub pull requests containing *`text`*.
-* `--open`:
-  Search for only open GitHub pull requests.
-* `--closed`:
-  Search for only closed GitHub pull requests.
-* `--repology`:
-  Search for *`text`* in the given database.
-* `--macports`:
-  Search for *`text`* in the given database.
-* `--fink`:
-  Search for *`text`* in the given database.
-* `--opensuse`:
-  Search for *`text`* in the given database.
-* `--fedora`:
-  Search for *`text`* in the given database.
-* `--archlinux`:
-  Search for *`text`* in the given database.
-* `--debian`:
-  Search for *`text`* in the given database.
-* `--ubuntu`:
-  Search for *`text`* in the given database.
-
-### `shellenv`
-
-Print export statements. When run in a shell, this installation of Homebrew will be added to your `PATH`, `MANPATH`, and `INFOPATH`.
-
-The variables `HOMEBREW_PREFIX`, `HOMEBREW_CELLAR` and `HOMEBREW_REPOSITORY` are also exported to avoid querying them multiple times.
-To help guarantee idempotence, this command produces no output when Homebrew's `bin` and `sbin` directories are first and second
-respectively in your `PATH`. Consider adding evaluation of this command's output to your dotfiles (e.g. `~/.profile`,
-`~/.bash_profile`, or `~/.zprofile`) with: `eval "$(brew shellenv)"`
-
-### `tap` [*`options`*] [*`user`*`/`*`repo`*] [*`URL`*]
-
-Tap a formula repository.
-
-If no arguments are provided, list all installed taps.
+`--fontdir`
 
-With *`URL`* unspecified, tap a formula repository from GitHub using HTTPS.
-Since so many taps are hosted on GitHub, this command is a shortcut for
-`brew tap` *`user`*`/`*`repo`* `https://github.com/`*`user`*`/homebrew-`*`repo`*.
+: Target location for Fonts (default: `~/Library/Fonts`).
 
-With *`URL`* specified, tap a formula repository from anywhere, using
-any transport protocol that `git`(1) handles. The one-argument form of `tap`
-simplifies but also limits. This two-argument command makes no
-assumptions, so taps can be cloned from places other than GitHub and
-using protocols other than HTTPS, e.g. SSH, git, HTTP, FTP(S), rsync.
+`--servicedir`
 
-* `--[no-]force-auto-update`:
-  Auto-update tap even if it is not hosted on GitHub. By default, only taps hosted on GitHub are auto-updated (for performance reasons).
-* `--custom-remote`:
-  Install or change a tap with a custom remote. Useful for mirrors.
-* `--repair`:
-  Migrate tapped formulae from symlink-based to directory-based structure.
-* `--list-pinned`:
-  List all pinned taps.
+: Target location for Services (default: `~/Library/Services`).
 
-### `tap-info` [*`--installed`*] [*`--json`*] [*`tap`* ...]
+`--input-methoddir`
 
-Show detailed information about one or more *`tap`*s.
+: Target location for Input Methods (default: `~/Library/Input Methods`).
 
-If no *`tap`* names are provided, display brief statistics for all installed taps.
+`--internet-plugindir`
 
-* `--installed`:
-  Show information on each installed tap.
-* `--json`:
-  Print a JSON representation of *`tap`*. Currently the default and only accepted value for *`version`* is `v1`. See the docs for examples of using the JSON output: <https://docs.brew.sh/Querying-Brew>
+: Target location for Internet Plugins (default: `~/Library/Internet Plug-Ins`).
 
-### `uninstall`, `remove`, `rm` [*`options`*] *`installed_formula`*|*`installed_cask`* [...]
+`--audio-unit-plugindir`
 
-Uninstall a *`formula`* or *`cask`*.
+: Target location for Audio Unit Plugins (default:
+  `~/Library/Audio/Plug-Ins/Components`).
 
-* `-f`, `--force`:
-  Delete all installed versions of *`formula`*. Uninstall even if *`cask`* is not installed, overwrite existing files and ignore errors when removing files.
-* `--zap`:
-  Remove all files associated with a *`cask`*. *May remove files which are shared between applications.*
-* `--ignore-dependencies`:
-  Don't fail uninstall, even if *`formula`* is a dependency of any installed formulae.
-* `--formula`:
-  Treat all named arguments as formulae.
-* `--cask`:
-  Treat all named arguments as casks.
+`--vst-plugindir`
 
-### `unlink` [*`--dry-run`*] *`installed_formula`* [...]
+: Target location for VST Plugins (default: `~/Library/Audio/Plug-Ins/VST`).
 
-Remove symlinks for *`formula`* from Homebrew's prefix. This can be useful
-for temporarily disabling a formula:
-`brew unlink` *`formula`* `&&` *`commands`* `&& brew link` *`formula`*
+`--vst3-plugindir`
 
-* `-n`, `--dry-run`:
-  List files which would be unlinked without actually unlinking or deleting any files.
+: Target location for VST3 Plugins (default: `~/Library/Audio/Plug-Ins/VST3`).
 
-### `unpin` *`installed_formula`* [...]
+`--screen-saverdir`
 
-Unpin *`formula`*, allowing them to be upgraded by `brew upgrade` *`formula`*.
-See also `pin`.
+: Target location for Screen Savers (default: `~/Library/Screen Savers`).
 
-### `untap` [*`--force`*] *`tap`* [...]
+`--language`
 
-Remove a tapped formula repository.
+: Comma-separated list of language codes to prefer for cask installation. The
+  first matching language is used, otherwise it reverts to the cask's default
+  language. The default value is the language of your system.
 
-* `-f`, `--force`:
-  Untap even if formulae or casks from this tap are currently installed.
+## GLOBAL OPTIONS
 
-### `update` [*`options`*]
+These options are applicable across multiple subcommands.
 
-Fetch the newest version of Homebrew and all formulae from GitHub using `git`(1) and perform any necessary migrations.
+`-d`, `--debug`
 
-* `--merge`:
-  Use `git merge` to apply updates (rather than `git rebase`).
-* `--auto-update`:
-  Run on auto-updates (e.g. before `brew install`). Skips some slower steps.
-* `-f`, `--force`:
-  Always do a slower, full update check (even if unnecessary).
+: Display any debugging information.
 
-### `update-reset` [*`repository`* ...]
+`-q`, `--quiet`
 
-Fetch and reset Homebrew and all tap repositories (or any specified *`repository`*) using `git`(1) to their latest `origin/HEAD`.
+: Make some output more quiet.
 
-*Note:* this will destroy all your uncommitted or committed changes.
+`-v`, `--verbose`
 
-### `upgrade` [*`options`*] [*`outdated_formula`*|*`outdated_cask`* ...]
-
-Upgrade outdated casks and outdated, unpinned formulae using the same options they were originally
-installed with, plus any appended brew formula options. If *`cask`* or *`formula`* are specified,
-upgrade only the given *`cask`* or *`formula`* kegs (unless they are pinned; see `pin`, `unpin`).
-
-Unless `HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK` is set, `brew upgrade` or `brew reinstall` will be run for
-outdated dependents and dependents with broken linkage, respectively.
-
-Unless `HOMEBREW_NO_INSTALL_CLEANUP` is set, `brew cleanup` will then be run for the
-upgraded formulae or, every 30 days, for all formulae.
-
-* `-d`, `--debug`:
-  If brewing fails, open an interactive debugging session with access to IRB or a shell inside the temporary build directory.
-* `-f`, `--force`:
-  Install formulae without checking for previously installed keg-only or non-migrated versions. When installing casks, overwrite existing files (binaries and symlinks are excluded, unless originally from the same cask).
-* `-v`, `--verbose`:
-  Print the verification and postinstall steps.
-* `-n`, `--dry-run`:
-  Show what would be upgraded, but do not actually upgrade anything.
-* `--formula`:
-  Treat all named arguments as formulae. If no named arguments are specified, upgrade only outdated formulae.
-* `-s`, `--build-from-source`:
-  Compile *`formula`* from source even if a bottle is available.
-* `-i`, `--interactive`:
-  Download and patch *`formula`*, then open a shell. This allows the user to run `./configure --help` and otherwise determine how to turn the software package into a Homebrew package.
-* `--force-bottle`:
-  Install from a bottle if it exists for the current or newest version of macOS, even if it would not normally be used for installation.
-* `--fetch-HEAD`:
-  Fetch the upstream repository to detect if the HEAD installation of the formula is outdated. Otherwise, the repository's HEAD will only be checked for updates when a new stable or development version has been released.
-* `--ignore-pinned`:
-  Set a successful exit status even if pinned formulae are not upgraded.
-* `--keep-tmp`:
-  Retain the temporary files created during installation.
-* `--display-times`:
-  Print install times for each package at the end of the run.
-* `--cask`:
-  Treat all named arguments as casks. If no named arguments are specified, upgrade only outdated casks.
-* `--[no-]binaries`:
-  Disable/enable linking of helper executables (default: enabled).
-* `--require-sha`:
-  Require all casks to have a checksum.
-* `--[no-]quarantine`:
-  Disable/enable quarantining of downloads (default: enabled).
-* `--skip-cask-deps`:
-  Skip installing cask dependencies.
-* `--greedy`:
-  Also include casks with `auto_updates true` or `version :latest`.
-* `--greedy-latest`:
-  Also include casks with `version :latest`.
-* `--greedy-auto-updates`:
-  Also include casks with `auto_updates true`.
-
-### `uses` [*`options`*] *`formula`* [...]
-
-Show formulae and casks that specify *`formula`* as a dependency; that is, show dependents
-of *`formula`*. When given multiple formula arguments, show the intersection
-of formulae that use *`formula`*. By default, `uses` shows all formulae and casks that
-specify *`formula`* as a required or recommended dependency for their stable builds.
-
-* `--recursive`:
-  Resolve more than one level of dependencies.
-* `--installed`:
-  Only list formulae and casks that are currently installed.
-* `--include-build`:
-  Include all formulae that specify *`formula`* as `:build` type dependency.
-* `--include-test`:
-  Include all formulae that specify *`formula`* as `:test` type dependency.
-* `--include-optional`:
-  Include all formulae that specify *`formula`* as `:optional` type dependency.
-* `--skip-recommended`:
-  Skip all formulae that specify *`formula`* as `:recommended` type dependency.
-* `--formula`:
-  Include only formulae.
-* `--cask`:
-  Include only casks.
-
-### `--cache` [*`options`*] [*`formula`*|*`cask`* ...]
+: Make some output more verbose.
 
-Display Homebrew's download cache. See also `HOMEBREW_CACHE`.
+`-h`, `--help`
 
-If *`formula`* is provided, display the file or directory used to cache *`formula`*.
+: Show this message.
 
-* `-s`, `--build-from-source`:
-  Show the cache file used when building from source.
-* `--force-bottle`:
-  Show the cache file used when pouring a bottle.
-* `--bottle-tag`:
-  Show the cache file used when pouring a bottle for the given tag.
-* `--HEAD`:
-  Show the cache file used when building from HEAD.
-* `--formula`:
-  Only show cache files for formulae.
-* `--cask`:
-  Only show cache files for casks.
+## OFFICIAL EXTERNAL COMMANDS
 
-### `--caskroom` [*`cask`* ...]
+### `alias` \[*`alias`* ... \| *`alias`*=*`command`*\]
 
-Display Homebrew's Caskroom path.
+Show existing aliases. If no aliases are given, print the whole list.
 
-If *`cask`* is provided, display the location in the Caskroom where *`cask`*
-would be installed, without any sort of versioned directory as the last path.
+`--edit`
 
-### `--cellar` [*`formula`* ...]
+: Edit aliases in a text editor. Either one or all aliases may be opened at
+  once. If the given alias doesn't exist it'll be pre-populated with a template.
 
-Display Homebrew's Cellar path. *Default:* `$(brew --prefix)/Cellar`, or if
-that directory doesn't exist, `$(brew --repository)/Cellar`.
+### `bundle` \[*`subcommand`*\]
 
-If *`formula`* is provided, display the location in the Cellar where *`formula`*
-would be installed, without any sort of versioned directory as the last path.
+Bundler for non-Ruby dependencies from Homebrew, Homebrew Cask, Mac App Store,
+Whalebrew and Visual Studio Code.
 
-### `--env`, `environment` [*`--shell`*`=`] [*`--plain`*] [*`formula`* ...]
+`brew bundle` \[`install`\]
 
-Summarise Homebrew's build environment as a plain list.
+: Install and upgrade (by default) all dependencies from the `Brewfile`.
 
-If the command's output is sent through a pipe and no shell is specified,
-the list is formatted for export to `bash`(1) unless `--plain` is passed.
+You can specify the `Brewfile` location using `--file` or by setting the
+`HOMEBREW_BUNDLE_FILE` environment variable.
 
-* `--shell`:
-  Generate a list of environment variables for the specified shell, or `--shell=auto` to detect the current shell.
-* `--plain`:
-  Generate plain output even when piped.
+You can skip the installation of dependencies by adding space-separated values
+to one or more of the following environment variables:
+`HOMEBREW_BUNDLE_BREW_SKIP`, `HOMEBREW_BUNDLE_CASK_SKIP`,
+`HOMEBREW_BUNDLE_MAS_SKIP`, `HOMEBREW_BUNDLE_WHALEBREW_SKIP`,
+`HOMEBREW_BUNDLE_TAP_SKIP`.
 
-### `--prefix` [*`--unbrewed`*] [*`--installed`*] [*`formula`* ...]
+`brew bundle` will output a `Brewfile.lock.json` in the same directory as the
+`Brewfile` if all dependencies are installed successfully. This contains
+dependency and system status information which can be useful for debugging `brew
+bundle` failures and replicating a "last known good build" state. You can
+opt-out of this behaviour by setting the `HOMEBREW_BUNDLE_NO_LOCK` environment
+variable or passing the `--no-lock` option. You may wish to check this file into
+the same version control system as your `Brewfile` (or ensure your version
+control system ignores it if you'd prefer to rely on debugging information from
+a local machine).
 
-Display Homebrew's install path. *Default:*
+`brew bundle dump`
 
-  - macOS Intel: `/usr/local`
-  - macOS ARM: `/opt/homebrew`
-  - Linux: `/home/linuxbrew/.linuxbrew`
+: Write all installed casks/formulae/images/taps into a `Brewfile` in the
+  current directory.
 
-If *`formula`* is provided, display the location where *`formula`* is or would be installed.
+`brew bundle cleanup`
 
-* `--unbrewed`:
-  List files in Homebrew's prefix not installed by Homebrew.
-* `--installed`:
-  Outputs nothing and returns a failing status code if *`formula`* is not installed.
+: Uninstall all dependencies not present in the `Brewfile`.
 
-### `--repository`, `--repo` [*`tap`* ...]
+This workflow is useful for maintainers or testers who regularly install lots of
+formulae.
 
-Display where Homebrew's git repository is located.
+Unless `--force` is passed, this returns a 1 exit code if anything would be
+removed.
 
-If *`user`*`/`*`repo`* are provided, display where tap *`user`*`/`*`repo`*'s directory is located.
+`brew bundle check`
 
-### `--version`, `-v`
+: Check if all dependencies present in the `Brewfile` are installed.
 
-Print the version numbers of Homebrew, Homebrew/homebrew-core and Homebrew/homebrew-cask (if tapped) to standard output.
+This provides a successful exit code if everything is up-to-date, making it
+useful for scripting.
 
-## DEVELOPER COMMANDS
+`brew bundle list`
 
-### `audit` [*`options`*] [*`formula`*|*`cask`* ...]
-
-Check *`formula`* for Homebrew coding style violations. This should be run before
-submitting a new formula or cask. If no *`formula`*|*`cask`* are provided, check all
-locally available formulae and casks and skip style checks. Will exit with a
-non-zero status if any errors are found.
-
-* `--strict`:
-  Run additional, stricter style checks.
-* `--git`:
-  Run additional, slower style checks that navigate the Git repository.
-* `--online`:
-  Run additional, slower style checks that require a network connection.
-* `--installed`:
-  Only check formulae and casks that are currently installed.
-* `--new`:
-  Run various additional style checks to determine if a new formula or cask is eligible for Homebrew. This should be used when creating new formula and implies `--strict` and `--online`.
-* `--[no-]appcast`:
-  Audit the appcast.
-* `--token-conflicts`:
-  Audit for token conflicts.
-* `--tap`:
-  Check the formulae within the given tap, specified as *`user`*`/`*`repo`*.
-* `--fix`:
-  Fix style violations automatically using RuboCop's auto-correct feature.
-* `--display-cop-names`:
-  Include the RuboCop cop name for each violation in the output.
-* `--display-filename`:
-  Prefix every line of output with the file or formula name being audited, to make output easy to grep.
-* `--display-failures-only`:
-  Only display casks that fail the audit. This is the default for formulae.
-* `--skip-style`:
-  Skip running non-RuboCop style checks. Useful if you plan on running `brew style` separately. Enabled by default unless a formula is specified by name.
-* `-D`, `--audit-debug`:
-  Enable debugging and profiling of audit methods.
-* `--only`:
-  Specify a comma-separated *`method`* list to only run the methods named `audit_`*`method`*.
-* `--except`:
-  Specify a comma-separated *`method`* list to skip running the methods named `audit_`*`method`*.
-* `--only-cops`:
-  Specify a comma-separated *`cops`* list to check for violations of only the listed RuboCop cops.
-* `--except-cops`:
-  Specify a comma-separated *`cops`* list to skip checking for violations of the listed RuboCop cops.
-* `--formula`:
-  Treat all named arguments as formulae.
-* `--cask`:
-  Treat all named arguments as casks.
-
-### `bottle` [*`options`*] *`installed_formula`*|*`file`* [...]
+: List all dependencies present in the `Brewfile`.
 
-Generate a bottle (binary package) from a formula that was installed with
-`--build-bottle`.
-If the formula specifies a rebuild version, it will be incremented in the
-generated DSL. Passing `--keep-old` will attempt to keep it at its original
-value, while `--no-rebuild` will remove it.
-
-* `--skip-relocation`:
-  Do not check if the bottle can be marked as relocatable.
-* `--force-core-tap`:
-  Build a bottle even if *`formula`* is not in `homebrew/core` or any installed taps.
-* `--no-rebuild`:
-  If the formula specifies a rebuild version, remove it from the generated DSL.
-* `--keep-old`:
-  If the formula specifies a rebuild version, attempt to preserve its value in the generated DSL.
-* `--json`:
-  Write bottle information to a JSON file, which can be used as the value for `--merge`.
-* `--merge`:
-  Generate an updated bottle block for a formula and optionally merge it into the formula file. Instead of a formula name, requires the path to a JSON file generated with `brew bottle --json` *`formula`*.
-* `--write`:
-  Write changes to the formula file. A new commit will be generated unless `--no-commit` is passed.
-* `--no-commit`:
-  When passed with `--write`, a new commit will not generated after writing changes to the formula file.
-* `--only-json-tab`:
-  When passed with `--json`, the tab will be written to the JSON file but not the bottle.
-* `--committer`:
-  Specify a committer name and email in `git`'s standard author format.
-* `--root-url`:
-  Use the specified *`URL`* as the root of the bottle's URL instead of Homebrew's default.
-* `--root-url-using`:
-  Use the specified download strategy class for downloading the bottle's URL instead of Homebrew's default.
-
-### `bump` [*`options`*] [*`formula`*|*`cask`* ...]
-
-Display out-of-date brew formulae and the latest version available. If the
-returned current and livecheck versions differ or when querying specific
-formulae, also displays whether a pull request has been opened with the URL.
-
-* `--full-name`:
-  Print formulae/casks with fully-qualified names.
-* `--no-pull-requests`:
-  Do not retrieve pull requests from GitHub.
-* `--formula`:
-  Check only formulae.
-* `--cask`:
-  Check only casks.
-* `--open-pr`:
-  Open a pull request for the new version if there are none already open.
-* `--limit`:
-  Limit number of package results returned.
-* `--start-with`:
-  Letter or word that the list of package results should alphabetically follow.
-
-### `bump-cask-pr` [*`options`*] *`cask`*
+By default, only Homebrew formula dependencies are listed.
 
-Create a pull request to update *`cask`* with a new version.
+`brew bundle exec` *`command`*
 
-A best effort to determine the *`SHA-256`* will be made if the value is not
-supplied by the user.
+: Run an external command in an isolated build environment based on the
+  `Brewfile` dependencies.
 
-* `-n`, `--dry-run`:
-  Print what would be done rather than doing it.
-* `--write-only`:
-  Make the expected file modifications without taking any Git actions.
-* `--commit`:
-  When passed with `--write-only`, generate a new commit after writing changes to the cask file.
-* `--no-audit`:
-  Don't run `brew audit` before opening the PR.
-* `--online`:
-  Run `brew audit --online` before opening the PR.
-* `--no-style`:
-  Don't run `brew style --fix` before opening the PR.
-* `--no-browse`:
-  Print the pull request URL instead of opening in a browser.
-* `--no-fork`:
-  Don't try to fork the repository.
-* `--version`:
-  Specify the new *`version`* for the cask.
-* `--message`:
-  Append *`message`* to the default pull request message.
-* `--url`:
-  Specify the *`URL`* for the new download.
-* `--sha256`:
-  Specify the *`SHA-256`* checksum of the new download.
-* `--fork-org`:
-  Use the specified GitHub organization for forking.
-* `-f`, `--force`:
-  Ignore duplicate open PRs.
-
-### `bump-formula-pr` [*`options`*] [*`formula`*]
+This sanitized build environment ignores unrequested dependencies, which makes
+sure that things you didn't specify in your `Brewfile` won't get picked up by
+commands like `bundle install`, `npm install`, etc. It will also add compiler
+flags which will help with finding keg-only dependencies like `openssl`,
+`icu4c`, etc.
 
-Create a pull request to update *`formula`* with a new URL or a new tag.
+`--file`
 
-If a *`URL`* is specified, the *`SHA-256`* checksum of the new download should also
-be specified. A best effort to determine the *`SHA-256`* and *`formula`* name will
-be made if either or both values are not supplied by the user.
+: Read the `Brewfile` from this location. Use `--file=-` to pipe to
+  stdin/stdout.
 
-If a *`tag`* is specified, the Git commit *`revision`* corresponding to that tag
-should also be specified. A best effort to determine the *`revision`* will be made
-if the value is not supplied by the user.
+`--global`
 
-If a *`version`* is specified, a best effort to determine the *`URL`* and *`SHA-256`* or
-the *`tag`* and *`revision`* will be made if both values are not supplied by the user.
+: Read the `Brewfile` from `~/.Brewfile` or the `HOMEBREW_BUNDLE_FILE_GLOBAL`
+  environment variable, if set.
 
-*Note:* this command cannot be used to transition a formula from a
-URL-and-SHA-256 style specification into a tag-and-revision style specification,
-nor vice versa. It must use whichever style specification the formula already uses.
-
-* `-n`, `--dry-run`:
-  Print what would be done rather than doing it.
-* `--write-only`:
-  Make the expected file modifications without taking any Git actions.
-* `--commit`:
-  When passed with `--write-only`, generate a new commit after writing changes to the formula file.
-* `--no-audit`:
-  Don't run `brew audit` before opening the PR.
-* `--strict`:
-  Run `brew audit --strict` before opening the PR.
-* `--online`:
-  Run `brew audit --online` before opening the PR.
-* `--no-browse`:
-  Print the pull request URL instead of opening in a browser.
-* `--no-fork`:
-  Don't try to fork the repository.
-* `--mirror`:
-  Use the specified *`URL`* as a mirror URL. If *`URL`* is a comma-separated list of URLs, multiple mirrors will be added.
-* `--fork-org`:
-  Use the specified GitHub organization for forking.
-* `--version`:
-  Use the specified *`version`* to override the value parsed from the URL or tag. Note that `--version=0` can be used to delete an existing version override from a formula if it has become redundant.
-* `--message`:
-  Append *`message`* to the default pull request message.
-* `--url`:
-  Specify the *`URL`* for the new download. If a *`URL`* is specified, the *`SHA-256`* checksum of the new download should also be specified.
-* `--sha256`:
-  Specify the *`SHA-256`* checksum of the new download.
-* `--tag`:
-  Specify the new git commit *`tag`* for the formula.
-* `--revision`:
-  Specify the new commit *`revision`* corresponding to the specified git *`tag`* or specified *`version`*.
-* `-f`, `--force`:
-  Ignore duplicate open PRs. Remove all mirrors if `--mirror` was not specified.
-* `--python-package-name`:
-  Use the specified *`package-name`* when finding Python resources for *`formula`*. If no package name is specified, it will be inferred from the formula's stable URL.
-* `--python-extra-packages`:
-  Include these additional Python packages when finding resources.
-* `--python-exclude-packages`:
-  Exclude these Python packages when finding resources.
-
-### `bump-revision` [*`options`*] *`formula`* [...]
+`-v`, `--verbose`
 
-Create a commit to increment the revision of *`formula`*. If no revision is
-present, "revision 1" will be added.
+: `install` prints output from commands as they are run. `check` lists all
+  missing dependencies.
 
-* `-n`, `--dry-run`:
-  Print what would be done rather than doing it.
-* `--remove-bottle-block`:
-  Remove the bottle block in addition to bumping the revision.
-* `--write-only`:
-  Make the expected file modifications without taking any Git actions.
-* `--message`:
-  Append *`message`* to the default commit message.
+`--no-upgrade`
 
-### `bump-unversioned-casks` [*`options`*] *`cask`*|*`tap`* [...]
+: `install` does not run `brew upgrade` on outdated dependencies. Note they may
+  still be upgraded by `brew install` if needed.
 
-Check all casks with unversioned URLs in a given *`tap`* for updates.
+`-f`, `--force`
 
-* `-n`, `--dry-run`:
-  Do everything except caching state and opening pull requests.
-* `--limit`:
-  Maximum runtime in minutes.
-* `--state-file`:
-  File for caching state.
+: `install` runs with `--force`/`--overwrite`. `dump` overwrites an existing
+  `Brewfile`. `cleanup` actually performs its cleanup operations.
 
-### `cat` [*`--formula`*] [*`--cask`*] *`formula`*|*`cask`*
+`--cleanup`
 
-Display the source of a *`formula`* or *`cask`*.
+: `install` performs cleanup operation, same as running `cleanup --force`. This
+  is enabled by default if `HOMEBREW_BUNDLE_INSTALL_CLEANUP` is set and
+  `--global` is passed.
 
-* `--formula`:
-  Treat all named arguments as formulae.
-* `--cask`:
-  Treat all named arguments as casks.
+`--no-lock`
 
-### `command` *`command`* [...]
+: `install` does not output a `Brewfile.lock.json`.
 
-Display the path to the file being used when invoking `brew` *`cmd`*.
+`--all`
 
-### `create` [*`options`*] *`URL`*
-
-Generate a formula or, with `--cask`, a cask for the downloadable file at *`URL`*
-and open it in the editor. Homebrew will attempt to automatically derive the
-formula name and version, but if it fails, you'll have to make your own template.
-The `wget` formula serves as a simple example. For the complete API, see:
-<https://rubydoc.brew.sh/Formula>
-
-* `--autotools`:
-  Create a basic template for an Autotools-style build.
-* `--cask`:
-  Create a basic template for a cask.
-* `--cmake`:
-  Create a basic template for a CMake-style build.
-* `--crystal`:
-  Create a basic template for a Crystal build.
-* `--go`:
-  Create a basic template for a Go build.
-* `--meson`:
-  Create a basic template for a Meson-style build.
-* `--node`:
-  Create a basic template for a Node build.
-* `--perl`:
-  Create a basic template for a Perl build.
-* `--python`:
-  Create a basic template for a Python build.
-* `--ruby`:
-  Create a basic template for a Ruby build.
-* `--rust`:
-  Create a basic template for a Rust build.
-* `--no-fetch`:
-  Homebrew will not download *`URL`* to the cache and will thus not add its SHA-256 to the formula for you, nor will it check the GitHub API for GitHub projects (to fill out its description and homepage).
-* `--HEAD`:
-  Indicate that *`URL`* points to the package's repository rather than a file.
-* `--set-name`:
-  Explicitly set the *`name`* of the new formula or cask.
-* `--set-version`:
-  Explicitly set the *`version`* of the new formula or cask.
-* `--set-license`:
-  Explicitly set the *`license`* of the new formula.
-* `--tap`:
-  Generate the new formula within the given tap, specified as *`user`*`/`*`repo`*.
-* `-f`, `--force`:
-  Ignore errors for disallowed formula names and names that shadow aliases.
-
-### `dispatch-build-bottle` [*`options`*] *`formula`* [...]
+: `list` all dependencies.
 
-Build bottles for these formulae with GitHub Actions.
+`--formula`
 
-* `--tap`:
-  Target tap repository (default: `homebrew/core`).
-* `--timeout`:
-  Build timeout (in minutes, default: 60).
-* `--issue`:
-  If specified, post a comment to this issue number if the job fails.
-* `--macos`:
-  Version(s) of macOS the bottle should be built for.
-* `--workflow`:
-  Dispatch specified workflow (default: `dispatch-build-bottle.yml`).
-* `--upload`:
-  Upload built bottles.
-* `--linux`:
-  Dispatch bottle for Linux (using GitHub runners).
-* `--linux-self-hosted`:
-  Dispatch bottle for Linux (using self-hosted runner).
-* `--linux-wheezy`:
-  Use Debian Wheezy container for building the bottle on Linux.
-
-### `edit` [*`options`*] [*`formula`*|*`cask`* ...]
-
-Open a *`formula`* or *`cask`* in the editor set by `EDITOR` or `HOMEBREW_EDITOR`,
-or open the Homebrew repository for editing if no formula is provided.
-
-* `--formula`:
-  Treat all named arguments as formulae.
-* `--cask`:
-  Treat all named arguments as casks.
-* `--print-path`:
-  Print the file path to be edited, without opening an editor.
-
-### `extract` [*`--version`*`=`] [*`--force`*] *`formula`* *`tap`*
-
-Look through repository history to find the most recent version of *`formula`* and
-create a copy in *`tap`*. Specifically, the command will create the new
-formula file at *`tap`*`/Formula/`*`formula`*`@`*`version`*`.rb`. If the tap is not
-installed yet, attempt to install/clone the tap before continuing. To extract
-a formula from a tap that is not `homebrew/core` use its fully-qualified form of
-*`user`*`/`*`repo`*`/`*`formula`*.
-
-* `--version`:
-  Extract the specified *`version`* of *`formula`* instead of the most recent.
-* `-f`, `--force`:
-  Overwrite the destination formula if it already exists.
-
-### `formula` *`formula`* [...]
+: `list` or `dump` Homebrew formula dependencies.
 
-Display the path where *`formula`* is located.
+`--cask`
 
-### `generate-man-completions` [*`--fail-if-not-changed`*]
+: `list` or `dump` Homebrew cask dependencies.
 
-Generate Homebrew's manpages and shell completions.
+`--tap`
 
-* `--fail-if-not-changed`:
-  Return a failing status code if no changes are detected in the manpage outputs. This can be used to notify CI when the manpages are out of date. Additionally, the date used in new manpages will match those in the existing manpages (to allow comparison without factoring in the date).
+: `list` or `dump` Homebrew tap dependencies.
 
-### `install-bundler-gems` [*`--groups`*`=`]
+`--mas`
 
-Install Homebrew's Bundler gems.
+: `list` or `dump` Mac App Store dependencies.
 
-* `--groups`:
-  Installs the specified comma-separated list of gem groups (default: last used).
+`--whalebrew`
 
-### `irb` [*`--examples`*] [*`--pry`*]
+: `list` or `dump` Whalebrew dependencies.
 
-Enter the interactive Homebrew Ruby shell.
+`--vscode`
 
-* `--examples`:
-  Show several examples.
-* `--pry`:
-  Use Pry instead of IRB. Implied if `HOMEBREW_PRY` is set.
+: `list` or `dump` VSCode extensions.
 
-### `linkage` [*`options`*] [*`installed_formula`* ...]
+`--no-vscode`
 
-Check the library links from the given *`formula`* kegs. If no *`formula`* are
-provided, check all kegs. Raises an error if run on uninstalled formulae.
+: `dump` without VSCode extensions. This is enabled by default if
+  `HOMEBREW_BUNDLE_DUMP_NO_VSCODE` is set.
 
-* `--test`:
-  Show only missing libraries and exit with a non-zero status if any missing libraries are found.
-* `--strict`:
-  Exit with a non-zero status if any undeclared dependencies with linkage are found.
-* `--reverse`:
-  For every library that a keg references, print its dylib path followed by the binaries that link to it.
-* `--cached`:
-  Print the cached linkage values stored in `HOMEBREW_CACHE`, set by a previous `brew linkage` run.
-
-### `livecheck`, `lc` [*`options`*] [*`formula`*|*`cask`* ...]
-
-Check for newer versions of formulae and/or casks from upstream.
-
-If no formula or cask argument is passed, the list of formulae and
-casks to check is taken from `HOMEBREW_LIVECHECK_WATCHLIST` or
-`~/.brew_livecheck_watchlist`.
-
-* `--full-name`:
-  Print formulae/casks with fully-qualified names.
-* `--tap`:
-  Check formulae/casks within the given tap, specified as *`user`*`/`*`repo`*.
-* `--all`:
-  Check all available formulae/casks.
-* `--installed`:
-  Check formulae/casks that are currently installed.
-* `--newer-only`:
-  Show the latest version only if it's newer than the formula/cask.
-* `--json`:
-  Output information in JSON format.
-* `-q`, `--quiet`:
-  Suppress warnings, don't print a progress bar for JSON output.
-* `--formula`:
-  Only check formulae.
-* `--cask`:
-  Only check casks.
-
-### `pr-automerge` [*`options`*]
+`--describe`
 
-Find pull requests that can be automatically merged using `brew pr-publish`.
+: `dump` adds a description comment above each line, unless the dependency does
+  not have a description. This is enabled by default if
+  `HOMEBREW_BUNDLE_DUMP_DESCRIBE` is set.
 
-* `--tap`:
-  Target tap repository (default: `homebrew/core`).
-* `--workflow`:
-  Workflow file to use with `brew pr-publish`.
-* `--with-label`:
-  Pull requests must have this label.
-* `--without-labels`:
-  Pull requests must not have these labels (default: `do not merge`, `new formula`, `automerge-skip`).
-* `--without-approval`:
-  Pull requests do not require approval to be merged.
-* `--publish`:
-  Run `brew pr-publish` on matching pull requests.
-* `--no-autosquash`:
-  Instruct `brew pr-publish` to skip automatically reformatting and rewording commits in the pull request to the preferred format.
-* `--ignore-failures`:
-  Include pull requests that have failing status checks.
-
-### `pr-publish` [*`options`*] *`pull_request`* [...]
-
-Publish bottles for a pull request with GitHub Actions.
-Requires write access to the repository.
-
-* `--no-autosquash`:
-  Skip automatically reformatting and rewording commits in the pull request to the preferred format, even if supported on the target tap.
-* `--branch`:
-  Branch to publish to (default: `master`).
-* `--message`:
-  Message to include when autosquashing revision bumps, deletions, and rebuilds.
-* `--tap`:
-  Target tap repository (default: `homebrew/core`).
-* `--workflow`:
-  Target workflow filename (default: `publish-commit-bottles.yml`).
-
-### `pr-pull` [*`options`*] *`pull_request`* [...]
-
-Download and publish bottles, and apply the bottle commit from a
-pull request with artifacts generated by GitHub Actions.
-Requires write access to the repository.
-
-* `--no-upload`:
-  Download the bottles but don't upload them.
-* `--no-commit`:
-  Do not generate a new commit before uploading.
-* `-n`, `--dry-run`:
-  Print what would be done rather than doing it.
-* `--clean`:
-  Do not amend the commits from pull requests.
-* `--keep-old`:
-  If the formula specifies a rebuild version, attempt to preserve its value in the generated DSL.
-* `--no-autosquash`:
-  Skip automatically reformatting and rewording commits in the pull request to our preferred format.
-* `--branch-okay`:
-  Do not warn if pulling to a branch besides the repository default (useful for testing).
-* `--resolve`:
-  When a patch fails to apply, leave in progress and allow user to resolve, instead of aborting.
-* `--warn-on-upload-failure`:
-  Warn instead of raising an error if the bottle upload fails. Useful for repairing bottle uploads that previously failed.
-* `--committer`:
-  Specify a committer name and email in `git`'s standard author format.
-* `--message`:
-  Message to include when autosquashing revision bumps, deletions, and rebuilds.
-* `--artifact`:
-  Download artifacts with the specified name (default: `bottles`).
-* `--tap`:
-  Target tap repository (default: `homebrew/core`).
-* `--root-url`:
-  Use the specified *`URL`* as the root of the bottle's URL instead of Homebrew's default.
-* `--root-url-using`:
-  Use the specified download strategy class for downloading the bottle's URL instead of Homebrew's default.
-* `--workflows`:
-  Retrieve artifacts from the specified workflow (default: `tests.yml`). Can be a comma-separated list to include multiple workflows.
-* `--ignore-missing-artifacts`:
-  Comma-separated list of workflows which can be ignored if they have not been run.
-
-### `pr-upload` [*`options`*]
+`--no-restart`
 
-Apply the bottle commit and publish bottles to a host.
+: `dump` does not add `restart_service` to formula lines.
 
-* `--keep-old`:
-  If the formula specifies a rebuild version, attempt to preserve its value in the generated DSL.
-* `-n`, `--dry-run`:
-  Print what would be done rather than doing it.
-* `--no-commit`:
-  Do not generate a new commit before uploading.
-* `--warn-on-upload-failure`:
-  Warn instead of raising an error if the bottle upload fails. Useful for repairing bottle uploads that previously failed.
-* `--upload-only`:
-  Skip running `brew bottle` before uploading.
-* `--committer`:
-  Specify a committer name and email in `git`'s standard author format.
-* `--root-url`:
-  Use the specified *`URL`* as the root of the bottle's URL instead of Homebrew's default.
-* `--root-url-using`:
-  Use the specified download strategy class for downloading the bottle's URL instead of Homebrew's default.
-
-### `prof` [*`--stackprof`*] *`command`* [...]
+`--zap`
 
-Run Homebrew with a Ruby profiler. For example, `brew prof readall`.
+: `cleanup` casks using the `zap` command instead of `uninstall`.
 
-* `--stackprof`:
-  Use `stackprof` instead of `ruby-prof` (the default).
+### `command-not-found-init`
 
-### `release` [*`--major`*] [*`--minor`*]
+Print instructions for setting up the command-not-found hook for your shell. If
+the output is not to a tty, print the appropriate handler script for your shell.
 
-Create a new draft Homebrew/brew release with the appropriate version number and release notes.
+### `services` \[*`subcommand`*\]
 
-By default, `brew release` will bump the patch version number. Pass
-`--major` or `--minor` to bump the major or minor version numbers, respectively.
-The command will fail if the previous major or minor release was made less than
-one month ago.
+Manage background services with macOS' `launchctl`(1) daemon manager or Linux's
+`systemctl`(1) service manager.
 
-Requires write access to the Homebrew/brew repository.
+If `sudo` is passed, operate on `/Library/LaunchDaemons` or
+`/usr/lib/systemd/system` (started at boot). Otherwise, operate on
+`~/Library/LaunchAgents` or `~/.config/systemd/user` (started at login).
 
-* `--major`:
-  Create a major release.
-* `--minor`:
-  Create a minor release.
+\[`sudo`\] `brew services` \[`list`\] (`--json`) (`--debug`)
 
-### `rubocop`
+: List information about all managed services for the current user (or root).
+  Provides more output from Homebrew and `launchctl`(1) or `systemctl`(1) if run
+  with `--debug`.
 
-Installs, configures and runs Homebrew's `rubocop`.
+\[`sudo`\] `brew services info` (*`formula`*\|`--all`\|`--json`)
 
-### `ruby` [*`options`*] (`-e` *`text`*|*`file`*)
+: List all managed services for the current user (or root).
 
-Run a Ruby instance with Homebrew's libraries loaded. For example,
-`brew ruby -e "puts :gcc.f.deps"` or `brew ruby script.rb`.
+\[`sudo`\] `brew services run` (*`formula`*\|`--all`)
 
-* `-r`:
-  Load a library using `require`.
-* `-e`:
-  Execute the given text string as a script.
+: Run the service *`formula`* without registering to launch at login (or boot).
 
-### `sh` [*`--env`*`=`] [*`--cmd`*`=`] [*`file`*]
+\[`sudo`\] `brew services start` (*`formula`*\|`--all`\|`--file=`)
 
-Enter an interactive shell for Homebrew's build environment. Use years-battle-hardened
-build logic to help your `./configure && make && make install`
-and even your `gem install` succeed. Especially handy if you run Homebrew
-in an Xcode-only configuration since it adds tools like `make` to your `PATH`
-which build systems would not find otherwise.
+: Start the service *`formula`* immediately and register it to launch at login
+  (or boot).
 
-* `--env`:
-  Use the standard `PATH` instead of superenv's when `std` is passed.
-* `-c`, `--cmd`:
-  Execute commands in a non-interactive shell.
+\[`sudo`\] `brew services stop` (*`formula`*\|`--all`)
 
-### `sponsors`
+: Stop the service *`formula`* immediately and unregister it from launching at
+  login (or boot).
 
-Update the list of GitHub Sponsors in the `Homebrew/brew` README.
+\[`sudo`\] `brew services kill` (*`formula`*\|`--all`)
 
-### `style` [*`options`*] [*`file`*|*`tap`*|*`formula`*|*`cask`* ...]
+: Stop the service *`formula`* immediately but keep it registered to launch at
+  login (or boot).
 
-Check formulae or files for conformance to Homebrew style guidelines.
+\[`sudo`\] `brew services restart` (*`formula`*\|`--all`)
 
-Lists of *`file`*, *`tap`* and *`formula`* may not be combined. If none are
-provided, `style` will run style checks on the whole Homebrew library,
-including core code and all formulae.
-
-* `--fix`:
-  Fix style violations automatically using RuboCop's auto-correct feature.
-* `--display-cop-names`:
-  Include the RuboCop cop name for each violation in the output.
-* `--reset-cache`:
-  Reset the RuboCop cache.
-* `--formula`:
-  Treat all named arguments as formulae.
-* `--cask`:
-  Treat all named arguments as casks.
-* `--only-cops`:
-  Specify a comma-separated *`cops`* list to check for violations of only the listed RuboCop cops.
-* `--except-cops`:
-  Specify a comma-separated *`cops`* list to skip checking for violations of the listed RuboCop cops.
-
-### `tap-new` [*`options`*] *`user`*`/`*`repo`*
+: Stop (if necessary) and start the service *`formula`* immediately and register
+  it to launch at login (or boot).
 
-Generate the template files for a new tap.
+\[`sudo`\] `brew services cleanup`
 
-* `--no-git`:
-  Don't initialize a Git repository for the tap.
-* `--pull-label`:
-  Label name for pull requests ready to be pulled (default: `pr-pull`).
-* `--branch`:
-  Initialize Git repository and setup GitHub Actions workflows with the specified branch name (default: `main`).
-* `--github-packages`:
-  Upload bottles to GitHub Packages.
+: Remove all unused services.
 
-### `test` [*`options`*] *`installed_formula`* [...]
+`--file`
 
-Run the test method provided by an installed formula.
-There is no standard output or return code, but generally it should notify the
-user if something is wrong with the installed formula.
+: Use the service file from this location to `start` the service.
 
-*Example:* `brew install jruby && brew test jruby`
+`--sudo-service-user`
 
-* `-f`, `--force`:
-  Test formulae even if they are unlinked.
-* `--HEAD`:
-  Test the head version of a formula.
-* `--keep-tmp`:
-  Retain the temporary files created for the test.
-* `--retry`:
-  Retry if a testing fails.
+: When run as root on macOS, run the service(s) as this user.
 
-### `tests` [*`options`*]
+`--max-wait`
 
-Run Homebrew's unit and integration tests.
+: Wait at most this many seconds for `stop` to finish stopping a service. Omit
+  this flag or set this to zero (0) seconds to wait indefinitely.
 
-* `--coverage`:
-  Generate code coverage reports.
-* `--generic`:
-  Run only OS-agnostic tests.
-* `--no-compat`:
-  Do not load the compatibility layer when running tests.
-* `--online`:
-  Include tests that use the GitHub API and tests that use any of the taps for official external commands.
-* `--byebug`:
-  Enable debugging using byebug.
-* `--changed`:
-  Only runs tests on files that were changed from the master branch.
-* `--only`:
-  Run only *`test_script`*`_spec.rb`. Appending `:`*`line_number`* will start at a specific line.
-* `--seed`:
-  Randomise tests with the specified *`value`* instead of a random seed.
-
-### `typecheck`, `tc` [*`options`*]
+`--all`
 
-Check for typechecking errors using Sorbet.
+: Run *`subcommand`* on all services.
 
-* `--fix`:
-  Automatically fix type errors.
-* `-q`, `--quiet`:
-  Silence all non-critical errors.
-* `--update`:
-  Update RBI files.
-* `--all`:
-  Regenerate all RBI files rather than just updated gems.
-* `--suggest-typed`:
-  Try upgrading `typed` sigils.
-* `--fail-if-not-changed`:
-  Return a failing status code if all gems are up to date and gem definitions do not need a tapioca update.
-* `--dir`:
-  Typecheck all files in a specific directory.
-* `--file`:
-  Typecheck a single file.
-* `--ignore`:
-  Ignores input files that contain the given string in their paths (relative to the input path passed to Sorbet).
-
-### `unbottled` [*`options`*] [*`formula`* ...]
+`--json`
 
-Show the unbottled dependents of formulae.
+: Output as JSON.
 
-* `--tag`:
-  Use the specified bottle tag (e.g. `big_sur`) instead of the current OS.
-* `--dependents`:
-  Skip getting analytics data and sort by number of dependents instead.
-* `--all`:
-  Print the number of unbottled and total formulae.
+`--no-wait`
 
-### `unpack` [*`options`*] *`formula`* [...]
+: Don't wait for `stop` to finish stopping the service.
 
-Unpack the source files for *`formula`* into subdirectories of the current
-working directory.
+### `test-bot` \[*`options`*\] \[*`formula`*\]
 
-* `--destdir`:
-  Create subdirectories in the directory named by *`path`* instead.
-* `--patch`:
-  Patches for *`formula`* will be applied to the unpacked source.
-* `-g`, `--git`:
-  Initialise a Git repository in the unpacked source. This is useful for creating patches for the software.
-* `-f`, `--force`:
-  Overwrite the destination directory if it already exists.
+Tests the full lifecycle of a Homebrew change to a tap (Git repository). For
+example, for a GitHub Actions pull request that changes a formula `brew
+test-bot` will ensure the system is cleaned and set up to test the formula,
+install the formula, run various tests and checks on it, bottle (package) the
+binaries and test formulae that depend on it to ensure they aren't broken by
+these changes.
 
-### `update-license-data` [*`--fail-if-not-changed`*]
+Only supports GitHub Actions as a CI provider. This is because Homebrew uses
+GitHub Actions and it's freely available for public and private use with macOS
+and Linux workers.
 
-Update SPDX license data in the Homebrew repository.
+`--dry-run`
 
-* `--fail-if-not-changed`:
-  Return a failing status code if current license data's version is the same as the upstream. This can be used to notify CI when the SPDX license data is out of date.
+: Print what would be done rather than doing it.
 
-### `update-maintainers`
+`--cleanup`
 
-Update the list of maintainers in the `Homebrew/brew` README.
+: Clean all state from the Homebrew directory. Use with care!
 
-### `update-python-resources` [*`options`*] *`formula`* [...]
+`--skip-setup`
 
-Update versions for PyPI resource blocks in *`formula`*.
+: Don't check if the local system is set up correctly.
 
-* `-p`, `--print-only`:
-  Print the updated resource blocks instead of changing *`formula`*.
-* `-s`, `--silent`:
-  Suppress any output.
-* `--ignore-non-pypi-packages`:
-  Don't fail if *`formula`* is not a PyPI package.
-* `--version`:
-  Use the specified *`version`* when finding resources for *`formula`*. If no version is specified, the current version for *`formula`* will be used.
-* `--package-name`:
-  Use the specified *`package-name`* when finding resources for *`formula`*. If no package name is specified, it will be inferred from the formula's stable URL.
-* `--extra-packages`:
-  Include these additional packages when finding resources.
-* `--exclude-packages`:
-  Exclude these packages when finding resources.
-
-### `update-test` [*`options`*]
-
-Run a test of `brew update` with a new repository clone.
-If no options are passed, use `origin/master` as the start commit.
-
-* `--to-tag`:
-  Set `HOMEBREW_UPDATE_TO_TAG` to test updating between tags.
-* `--keep-tmp`:
-  Retain the temporary directory containing the new repository clone.
-* `--commit`:
-  Use the specified *`commit`* as the start commit.
-* `--before`:
-  Use the commit at the specified *`date`* as the start commit.
-
-### `vendor-gems` [*`--update`*`=`]
+`--build-from-source`
 
-Install and commit Homebrew's vendored gems.
+: Build from source rather than building bottles.
 
-* `--update`:
-  Update all vendored Gems to the latest version.
+`--build-dependents-from-source`
 
-## GLOBAL CASK OPTIONS
+: Build dependents from source rather than testing bottles.
 
-These options are applicable to the `install`, `reinstall`, and `upgrade` subcommands with the `--cask` flag.
+`--junit`
 
-* `--appdir`:
-  Target location for Applications (default: `/Applications`).
+: generate a JUnit XML test results file.
 
-* `--colorpickerdir`:
-  Target location for Color Pickers (default: `~/Library/ColorPickers`).
+`--keep-old`
 
-* `--prefpanedir`:
-  Target location for Preference Panes (default: `~/Library/PreferencePanes`).
+: Run `brew bottle --keep-old` to build new bottles for a single platform.
 
-* `--qlplugindir`:
-  Target location for QuickLook Plugins (default: `~/Library/QuickLook`).
+`--skip-relocation`
 
-* `--mdimporterdir`:
-  Target location for Spotlight Plugins (default: `~/Library/Spotlight`).
+: Run `brew bottle --skip-relocation` to build new bottles that don't require
+  relocation.
 
-* `--dictionarydir`:
-  Target location for Dictionaries (default: `~/Library/Dictionaries`).
+`--only-json-tab`
 
-* `--fontdir`:
-  Target location for Fonts (default: `~/Library/Fonts`).
+: Run `brew bottle --only-json-tab` to build new bottles that do not contain a
+  tab.
 
-* `--servicedir`:
-  Target location for Services (default: `~/Library/Services`).
+`--local`
 
-* `--input-methoddir`:
-  Target location for Input Methods (default: `~/Library/Input Methods`).
+: Ask Homebrew to write verbose logs under `./logs/` and set `$HOME` to
+  `./home/`
 
-* `--internet-plugindir`:
-  Target location for Internet Plugins (default: `~/Library/Internet Plug-Ins`).
+`--tap`
 
-* `--audio-unit-plugindir`:
-  Target location for Audio Unit Plugins (default: `~/Library/Audio/Plug-Ins/Components`).
+: Use the Git repository of the given tap. Defaults to the core tap for syntax
+  checking.
 
-* `--vst-plugindir`:
-  Target location for VST Plugins (default: `~/Library/Audio/Plug-Ins/VST`).
+`--fail-fast`
 
-* `--vst3-plugindir`:
-  Target location for VST3 Plugins (default: `~/Library/Audio/Plug-Ins/VST3`).
+: Immediately exit on a failing step.
 
-* `--screen-saverdir`:
-  Target location for Screen Savers (default: `~/Library/Screen Savers`).
+`-v`, `--verbose`
 
-* `--language`:
-  Comma-separated list of language codes to prefer for cask installation. The first matching language is used, otherwise it reverts to the cask's default language. The default value is the language of your system.
+: Print test step output in real time. Has the side effect of passing output as
+  raw bytes instead of re-encoding in UTF-8.
 
-## GLOBAL OPTIONS
+`--test-default-formula`
 
-These options are applicable across multiple subcommands.
+: Use a default testing formula when not building a tap and no other formulae
+  are specified.
 
-* `-d`, `--debug`:
-  Display any debugging information.
+`--root-url`
 
-* `-q`, `--quiet`:
-  Make some output more quiet.
+: Use the specified *`URL`* as the root of the bottle's URL instead of
+  Homebrew's default.
 
-* `-v`, `--verbose`:
-  Make some output more verbose.
+`--git-name`
 
-* `-h`, `--help`:
-  Show this message.
+: Set the Git author/committer names to the given name.
 
-## OFFICIAL EXTERNAL COMMANDS
+`--git-email`
 
-### `alias` [*`alias`* ... | *`alias`*=*`command`*]
+: Set the Git author/committer email to the given email.
 
-Show existing aliases. If no aliases are given, print the whole list.
+`--publish`
 
-* `--edit`:
-  Edit aliases in a text editor. Either one or all aliases may be opened at once. If the given alias doesn't exist it'll be pre-populated with a template.
+: Publish the uploaded bottles.
 
-### `autoupdate` *`subcommand`* [*`interval`*] [*`options`*]
+`--skip-online-checks`
 
-An easy, convenient way to automatically update Homebrew.
+: Don't pass `--online` to `brew audit` and skip `brew livecheck`.
 
-This script will run `brew update` in the background once every 24 hours (by default)
-until explicitly told to stop, utilising `launchd`.
+`--skip-new`
 
-`brew autoupdate start` [*``interval``*] [*``options``*]
-<br>Start autoupdating either once every `interval` hours or once every 24 hours.
-Please note the interval has to be passed in seconds, so 12 hours would be
-`brew autoupdate start 43200`. Pass `--upgrade` or `--cleanup` to automatically
-run `brew upgrade` and/or `brew cleanup` respectively. Pass `--enable-notification`
-to send a notification when the autoupdate process has finished successfully.
+: Don't pass `--new` to `brew audit` for new formulae.
 
-`brew autoupdate stop`
-<br>Stop autoupdating, but retain plist & logs.
+`--skip-new-strict`
 
-`brew autoupdate delete`
-<br>Cancel the autoupdate, delete the plist and logs.
+: Don't pass `--strict` to `brew audit` for new formulae.
 
-`brew autoupdate status`
-<br>Prints the current status of this tool.
+`--skip-dependents`
 
-`brew autoupdate version`
-<br>Output this tool's current version, and a short changelog.
+: Don't test any dependents.
 
-* `--upgrade`:
-  Automatically upgrade your installed formulae. If the Caskroom exists locally Casks will be upgraded as well. Must be passed with `start`.
-* `--greedy`:
-  Upgrade casks with --greedy (include auto-updating casks). Must be passed with `start`.
-* `--cleanup`:
-  Automatically clean brew's cache and logs. Must be passed with `start`.
-* `--enable-notification`:
-  Send a notification when the autoupdate process has finished successfully, if `terminal-notifier` is installed & found. Must be passed with `start`. <NOTE: Notifications are enabled by default on macOS Catalina and newer.>
-* `--immediate`:
-  Starts the autoupdate command immediately, instead of waiting for one interval (24 hours by default) to pass first. Must be passed with `start`.
+`--skip-livecheck`
 
-### `bundle` [*`subcommand`*]
+: Don't test livecheck.
 
-Bundler for non-Ruby dependencies from Homebrew, Homebrew Cask, Mac App Store and Whalebrew.
+`--skip-recursive-dependents`
 
-`brew bundle` [`install`]
-<br>Install and upgrade (by default) all dependencies from the `Brewfile`.
+: Only test the direct dependents.
 
-You can specify the `Brewfile` location using `--file` or by setting the `HOMEBREW_BUNDLE_FILE` environment variable.
+`--skip-checksum-only-audit`
 
-You can skip the installation of dependencies by adding space-separated values to one or more of the following environment variables: `HOMEBREW_BUNDLE_BREW_SKIP`, `HOMEBREW_BUNDLE_CASK_SKIP`, `HOMEBREW_BUNDLE_MAS_SKIP`, `HOMEBREW_BUNDLE_WHALEBREW_SKIP`, `HOMEBREW_BUNDLE_TAP_SKIP`.
+: Don't audit checksum-only changes.
 
-`brew bundle` will output a `Brewfile.lock.json` in the same directory as the `Brewfile` if all dependencies are installed successfully. This contains dependency and system status information which can be useful in debugging `brew bundle` failures and replicating a "last known good build" state. You can opt-out of this behaviour by setting the `HOMEBREW_BUNDLE_NO_LOCK` environment variable or passing the `--no-lock` option. You may wish to check this file into the same version control system as your `Brewfile` (or ensure your version control system ignores it if you'd prefer to rely on debugging information from a local machine).
+`--skip-stable-version-audit`
 
-`brew bundle dump`
-<br>Write all installed casks/formulae/images/taps into a `Brewfile` in the current directory.
+: Don't audit the stable version.
 
-`brew bundle cleanup`
-<br>Uninstall all dependencies not listed from the `Brewfile`.
+`--skip-revision-audit`
 
-This workflow is useful for maintainers or testers who regularly install lots of formulae.
+: Don't audit the revision.
 
-`brew bundle check`
-<br>Check if all dependencies are installed from the `Brewfile`.
+`--only-cleanup-before`
 
-This provides a successful exit code if everything is up-to-date, making it useful for scripting.
+: Only run the pre-cleanup step. Needs `--cleanup`.
 
-`brew bundle list`
-<br>List all dependencies present in the `Brewfile`.
+`--only-setup`
 
-By default, only Homebrew dependencies are listed.
+: Only run the local system setup check step.
 
-`brew bundle exec` *`command`*
-<br>Run an external command in an isolated build environment based on the `Brewfile` dependencies.
-
-This sanitized build environment ignores unrequested dependencies, which makes sure that things you didn't specify in your `Brewfile` won't get picked up by commands like `bundle install`, `npm install`, etc. It will also add compiler flags which will help find keg-only dependencies like `openssl`, `icu4c`, etc.
-
-* `--file`:
-  Read the `Brewfile` from this location. Use `--file=-` to pipe to stdin/stdout.
-* `--global`:
-  Read the `Brewfile` from `~/.Brewfile`.
-* `-v`, `--verbose`:
-  `install` prints output from commands as they are run. `check` lists all missing dependencies.
-* `--no-upgrade`:
-  `install` won't run `brew upgrade` on outdated dependencies. Note they may still be upgraded by `brew install` if needed.
-* `-f`, `--force`:
-  `dump` overwrites an existing `Brewfile`. `cleanup` actually performs its cleanup operations.
-* `--cleanup`:
-  `install` performs cleanup operation, same as running `cleanup --force`.
-* `--no-lock`:
-  `install` won't output a `Brewfile.lock.json`.
-* `--all`:
-  `list` all dependencies.
-* `--formula`:
-  `list` Homebrew dependencies.
-* `--cask`:
-  `list` Homebrew Cask dependencies.
-* `--tap`:
-  `list` tap dependencies.
-* `--mas`:
-  `list` Mac App Store dependencies.
-* `--whalebrew`:
-  `list` Whalebrew dependencies.
-* `--describe`:
-  `dump` adds a description comment above each line, unless the dependency does not have a description.
-* `--no-restart`:
-  `dump` does not add `restart_service` to formula lines.
-* `--zap`:
-  `cleanup` casks using the `zap` command instead of `uninstall`.
+`--only-tap-syntax`
 
-### `command-not-found-init`
+: Only run the tap syntax check step.
+
+`--stable`
+
+: Only run the tap syntax checks needed on stable brew.
+
+`--only-formulae`
+
+: Only run the formulae steps.
+
+`--only-formulae-detect`
+
+: Only run the formulae detection steps.
+
+`--only-formulae-dependents`
+
+: Only run the formulae dependents steps.
+
+`--only-bottles-fetch`
+
+: Only run the bottles fetch steps. This optional post-upload test checks that
+  all the bottles were uploaded correctly. It is not run unless requested and
+  only needs to be run on a single machine. The bottle commit to be tested must
+  be on the tested branch.
+
+`--only-cleanup-after`
 
-Print instructions for setting up the command-not-found hook for your shell.
-If the output is not to a tty, print the appropriate handler script for your shell.
-
-### `services` [*`subcommand`*]
-
-Manage background services with macOS' `launchctl`(1) daemon manager.
-
-If `sudo` is passed, operate on `/Library/LaunchDaemons` (started at boot).
-Otherwise, operate on `~/Library/LaunchAgents` (started at login).
-
-[`sudo`] `brew services` [`list`] (`--json`)
-<br>List information about all managed services for the current user (or root).
-
-[`sudo`] `brew services info` (*`formula`*|`--all`|`--json`)
-<br>List all managed services for the current user (or root).
-
-[`sudo`] `brew services run` (*`formula`*|`--all`)
-<br>Run the service *`formula`* without registering to launch at login (or boot).
-
-[`sudo`] `brew services start` (*`formula`*|`--all`|`--file=`)
-<br>Start the service *`formula`* immediately and register it to launch at login (or boot).
-
-[`sudo`] `brew services stop` (*`formula`*|`--all`)
-<br>Stop the service *`formula`* immediately and unregister it from launching at login (or boot).
-
-[`sudo`] `brew services kill` (*`formula`*|`--all`)
-<br>Stop the service *`formula`* immediately but keep it registered to launch at login (or boot).
-
-[`sudo`] `brew services restart` (*`formula`*|`--all`)
-<br>Stop (if necessary) and start the service *`formula`* immediately and register it to launch at login (or boot).
-
-[`sudo`] `brew services cleanup`
-<br>Remove all unused services.
-
-* `--file`:
-  Use the service file from this location to `start` the service.
-* `--all`:
-  Run *`subcommand`* on all services.
-* `--json`:
-  Output as JSON.
-
-### `test-bot` [*`options`*] [*`formula`*]
-
-Tests the full lifecycle of a Homebrew change to a tap (Git repository). For example, for a GitHub Actions pull request that changes a formula `brew test-bot` will ensure the system is cleaned and set up to test the formula, install the formula, run various tests and checks on it, bottle (package) the binaries and test formulae that depend on it to ensure they aren't broken by these changes.
-
-Only supports GitHub Actions as a CI provider. This is because Homebrew uses GitHub Actions and it's freely available for public and private use with macOS and Linux workers.
-
-* `--dry-run`:
-  Print what would be done rather than doing it.
-* `--cleanup`:
-  Clean all state from the Homebrew directory. Use with care!
-* `--skip-setup`:
-  Don't check if the local system is set up correctly.
-* `--build-from-source`:
-  Build from source rather than building bottles.
-* `--build-dependents-from-source`:
-  Build dependents from source rather than testing bottles.
-* `--junit`:
-  generate a JUnit XML test results file.
-* `--keep-old`:
-  Run `brew bottle --keep-old` to build new bottles for a single platform.
-* `--skip-relocation`:
-  Run `brew bottle --skip-relocation` to build new bottles that don't require relocation.
-* `--only-json-tab`:
-  Run `brew bottle --only-json-tab` to build new bottles that do not contain a tab.
-* `--local`:
-  Ask Homebrew to write verbose logs under `./logs/` and set `$HOME` to `./home/`
-* `--tap`:
-  Use the Git repository of the given tap. Defaults to the core tap for syntax checking.
-* `--fail-fast`:
-  Immediately exit on a failing step.
-* `-v`, `--verbose`:
-  Print test step output in real time. Has the side effect of passing output as raw bytes instead of re-encoding in UTF-8.
-* `--test-default-formula`:
-  Use a default testing formula when not building a tap and no other formulae are specified.
-* `--root-url`:
-  Use the specified *`URL`* as the root of the bottle's URL instead of Homebrew's default.
-* `--git-name`:
-  Set the Git author/committer names to the given name.
-* `--git-email`:
-  Set the Git author/committer email to the given email.
-* `--publish`:
-  Publish the uploaded bottles.
-* `--skip-online-checks`:
-  Don't pass `--online` to `brew audit` and skip `brew livecheck`.
-* `--skip-dependents`:
-  Don't test any dependents.
-* `--skip-recursive-dependents`:
-  Only test the direct dependents.
-* `--only-cleanup-before`:
-  Only run the pre-cleanup step. Needs `--cleanup`.
-* `--only-setup`:
-  Only run the local system setup check step.
-* `--only-tap-syntax`:
-  Only run the tap syntax check step.
-* `--only-formulae`:
-  Only run the formulae steps.
-* `--only-formulae-detect`:
-  Only run the formulae detection steps.
-* `--only-formulae-dependents`:
-  Only run the formulae dependents steps.
-* `--only-cleanup-after`:
-  Only run the post-cleanup step. Needs `--cleanup`.
-* `--testing-formulae`:
-  Use these testing formulae rather than running the formulae detection steps.
-* `--added-formulae`:
-  Use these added formulae rather than running the formulae detection steps.
-* `--deleted-formulae`:
-  Use these deleted formulae rather than running the formulae detection steps.
-* `--skipped-or-failed-formulae`:
-  Use these skipped or failed formulae from formulae steps for a formulae dependents step.
-
-### `unalias` *`alias`* [...]
+: Only run the post-cleanup step. Needs `--cleanup`.
+
+`--testing-formulae`
+
+: Use these testing formulae rather than running the formulae detection steps.
+
+`--added-formulae`
+
+: Use these added formulae rather than running the formulae detection steps.
+
+`--deleted-formulae`
+
+: Use these deleted formulae rather than running the formulae detection steps.
+
+`--skipped-or-failed-formulae`
+
+: Use these skipped or failed formulae from formulae steps for a formulae
+  dependents step.
+
+`--tested-formulae`
+
+: Use these tested formulae from formulae steps for a formulae dependents step.
+
+### `unalias` *`alias`* \[...\]
 
 Remove aliases.
 
-### `which-formula` [*`--explain`*] *`command`* [...]
+### `which-formula` \[`--explain`\] *`command`* \[...\]
+
+Show which formula(e) provides the given command.
+
+`--explain`
+
+: Output explanation of how to get *`command`* by installing one of the
+  providing formulae.
+
+### `which-update` \[*`options`*\] \[*`database`*\]
+
+Database update for `brew which-formula`.
 
-Prints the formula(e) which provides the given command.
+`--stats`
 
-* `--explain`:
-  Output explanation of how to get 'cmd' by installing one of the providing formulae.
+: Print statistics about the database contents (number of commands and formulae,
+  list of missing formulae).
 
-### `which-update` [*`options`*] [*`database`*]
+`--commit`
 
-Database update for `brew which-formula`
+: Commit the changes using `git`.
 
-* `--stats`:
-  Print statistics about the database contents (number of commands and formulae, list of missing formulae).
-* `--commit`:
-  Commit the changes using `git`.
-* `--update-existing`:
-  Update database entries with outdated formula versions.
-* `--install-missing`:
-  Install and update formulae that are missing from the database and don't have bottles.
-* `--max-downloads`:
-  Specify a maximum number of formulae to download and update.
+`--update-existing`
+
+: Update database entries with outdated formula versions.
+
+`--install-missing`
+
+: Install and update formulae that are missing from the database and don't have
+  bottles.
+
+`--eval-all`
+
+: Evaluate all installed taps, rather than just the core tap.
+
+`--max-downloads`
+
+: Specify a maximum number of formulae to download and update.
 
 ## CUSTOM EXTERNAL COMMANDS
 
 Homebrew, like `git`(1), supports external commands. These are executable
 scripts that reside somewhere in the `PATH`, named `brew-`*`cmdname`* or
-`brew-`*`cmdname`*`.rb`, which can be invoked like `brew` *`cmdname`*. This allows
-you to create your own commands without modifying Homebrew's internals.
+`brew-`*`cmdname`*`.rb`, which can be invoked like `brew` *`cmdname`*. This
+allows you to create your own commands without modifying Homebrew's internals.
 
 Instructions for creating your own commands can be found in the docs:
 <https://docs.brew.sh/External-Commands>
@@ -1904,320 +3522,625 @@ Instructions for creating your own commands can be found in the docs:
 Many Homebrew commands accept one or more *`formula`* arguments. These arguments
 can take several different forms:
 
-  * The name of a formula:
-    e.g. `git`, `node`, `wget`.
+* The name of a formula: e.g. `git`, `node`, `wget`.
 
-  * The fully-qualified name of a tapped formula:
-    Sometimes a formula from a tapped repository may conflict with one in
-    `homebrew/core`.
-    You can still access these formulae by using a special syntax, e.g.
-    `homebrew/dupes/vim` or `homebrew/versions/node4`.
+* The fully-qualified name of a tapped formula: Sometimes a formula from a
+  tapped repository may conflict with one in `homebrew/core`. You can still
+  access these formulae by using a special syntax, e.g. `homebrew/dupes/vim` or
+  `homebrew/versions/node4`.
 
-  * An arbitrary file:
-    Homebrew can install formulae from a local path. It can point to either a
-    formula file or a bottle.
-    Prefix relative paths with `./` to prevent them from being interpreted as a
-    formula or tap name.
+* An arbitrary file: Homebrew can install formulae from a local path. It can
+  point to either a formula file or a bottle. Prefix relative paths with `./` to
+  prevent them from being interpreted as a formula or tap name.
 
 ## SPECIFYING CASKS
 
 Many Homebrew Cask commands accept one or more *`cask`* arguments. These can be
-specified the same way as the *`formula`* arguments described in
-`SPECIFYING FORMULAE` above.
+specified the same way as the *`formula`* arguments described in `SPECIFYING
+FORMULAE` above.
 
 ## ENVIRONMENT
 
 Note that environment variables must have a value set to be detected. For
-example, run `export HOMEBREW_NO_INSECURE_REDIRECT=1` rather than just
-`export HOMEBREW_NO_INSECURE_REDIRECT`.
+example, run `export HOMEBREW_NO_INSECURE_REDIRECT=1` rather than just `export
+HOMEBREW_NO_INSECURE_REDIRECT`.
+
+`HOMEBREW_*` environment variables can also be set in Homebrew's environment
+files:
+
+* `/etc/homebrew/brew.env` (system-wide)
+
+* `$HOMEBREW_PREFIX/etc/homebrew/brew.env` (prefix-specific)
+
+* `$XDG_CONFIG_HOME/homebrew/brew.env` if `$XDG_CONFIG_HOME` is set or
+  `$HOME/.homebrew/brew.env` otherwise (user-specific)
+
+User-specific environment files take precedence over prefix-specific files and
+prefix-specific files take precedence over system-wide files (unless
+`HOMEBREW_SYSTEM_ENV_TAKES_PRIORITY` is set, see below).
+
+Note that these files do not support shell variable expansion e.g. `$HOME` or
+command execution e.g. `$(cat file)`.
+
+`HOMEBREW_ALLOWED_TAPS`
+
+: A space-separated list of taps. Homebrew will refuse to install a formula
+  unless it and all of its dependencies are in an official tap or in a tap on
+  this list.
+
+`HOMEBREW_API_AUTO_UPDATE_SECS`
 
-- `HOMEBREW_ADDITIONAL_GOOGLE_ANALYTICS_ID`
-  <br>Additional Google Analytics tracking ID to emit user behaviour analytics to. For more information, see: <https://docs.brew.sh/Analytics>
+: Check Homebrew's API for new formulae or cask data every
+  `HOMEBREW_API_AUTO_UPDATE_SECS` seconds. Alternatively, disable API
+  auto-update checks entirely with `HOMEBREW_NO_AUTO_UPDATE`.
+  
+  *Default:* `450`.
 
-- `HOMEBREW_ARCH`
-  <br>Linux only: Pass this value to a type name representing the compiler's `-march` option.
+`HOMEBREW_API_DOMAIN`
 
+: Use this URL as the download mirror for Homebrew JSON API. If metadata files
+  at that URL are temporarily unavailable, the default API domain will be used
+  as a fallback mirror.
+  
+  *Default:* `https://formulae.brew.sh/api`.
+
+`HOMEBREW_ARCH`
+
+: Linux only: Pass this value to a type name representing the compiler's
+  `-march` option.
+  
   *Default:* `native`.
 
-- `HOMEBREW_ARTIFACT_DOMAIN`
-  <br>Prefix all download URLs, including those for bottles, with this value. For example, `HOMEBREW_ARTIFACT_DOMAIN=http://localhost:8080` will cause a formula with the URL `https://example.com/foo.tar.gz` to instead download from `http://localhost:8080/https://example.com/foo.tar.gz`. Bottle URLs however, have their domain replaced with this prefix. This results in e.g. `https://ghcr.io/v2/homebrew/core/gettext/manifests/0.21` to instead be downloaded from `http://localhost:8080/v2/homebrew/core/gettext/manifests/0.21`
+`HOMEBREW_ARTIFACT_DOMAIN`
+
+: Prefix all download URLs, including those for bottles, with this value. For
+  example, `HOMEBREW_ARTIFACT_DOMAIN=http://localhost:8080` will cause a formula
+  with the URL `https://example.com/foo.tar.gz` to instead download from
+  `http://localhost:8080/https://example.com/foo.tar.gz`. Bottle URLs however,
+  have their domain replaced with this prefix. This results in e.g.
+  `https://ghcr.io/v2/homebrew/core/gettext/manifests/0.21` to instead be
+  downloaded from
+  `http://localhost:8080/v2/homebrew/core/gettext/manifests/0.21`
+
+`HOMEBREW_ARTIFACT_DOMAIN_NO_FALLBACK`
 
-- `HOMEBREW_AUTO_UPDATE_SECS`
-  <br>Run `brew update` once every `HOMEBREW_AUTO_UPDATE_SECS` seconds before some commands, e.g. `brew install`, `brew upgrade` and `brew tap`. Alternatively, disable auto-update entirely with HOMEBREW_NO_AUTO_UPDATE.
+: If `HOMEBREW_ARTIFACT_DOMAIN` and `HOMEBREW_ARTIFACT_DOMAIN_NO_FALLBACK` are
+  both set, if the request to `HOMEBREW_ARTIFACT_DOMAIN` fails then it Homebrew
+  will error rather than trying any other/default URLs.
 
-  *Default:* `300`.
+`HOMEBREW_AUTO_UPDATE_SECS`
 
-- `HOMEBREW_BAT`
-  <br>If set, use `bat` for the `brew cat` command.
+: Run `brew update` once every `HOMEBREW_AUTO_UPDATE_SECS` seconds before some
+  commands, e.g. `brew install`, `brew upgrade` and `brew tap`. Alternatively,
+  disable auto-update entirely with `HOMEBREW_NO_AUTO_UPDATE`.
+  
+  *Default:* `86400` (24 hours), `3600` (1 hour) if a developer command has been
+  run or `300` (5 minutes) if `HOMEBREW_NO_INSTALL_FROM_API` is set.
 
-- `HOMEBREW_BAT_CONFIG_PATH`
-  <br>Use this as the `bat` configuration file.
+`HOMEBREW_BAT`
 
-  *Default:* `$HOME/.config/bat/config`.
+: If set, use `bat` for the `brew cat` command.
 
-- `HOMEBREW_BAT_THEME`
-  <br>Use this as the `bat` theme for syntax highlighting.
+`HOMEBREW_BAT_CONFIG_PATH`
 
+: Use this as the `bat` configuration file.
+  
+  *Default:* `$BAT_CONFIG_PATH`.
+
+`HOMEBREW_BAT_THEME`
+
+: Use this as the `bat` theme for syntax highlighting.
+  
   *Default:* `$BAT_THEME`.
 
-- `HOMEBREW_BOOTSNAP`
-  <br>If set, use Bootsnap to speed up repeated `brew` calls. A no-op when using Homebrew's vendored, relocatable Ruby on macOS (as it doesn't work).
+`HOMEBREW_BOOTSNAP`
 
-- `HOMEBREW_BOTTLE_DOMAIN`
-  <br>Use this URL as the download mirror for bottles. If bottles at that URL are temporarily unavailable, the default bottle domain will be used as a fallback mirror. For example, `HOMEBREW_BOTTLE_DOMAIN=http://localhost:8080` will cause all bottles to download from the prefix `http://localhost:8080/`. If bottles are not available at `HOMEBREW_BOTTLE_DOMAIN` they will be downloaded from the default bottle domain.
+: If set, use Bootsnap to speed up repeated `brew` calls. A no-op on Linux when
+  not using Homebrew's vendored, relocatable Ruby.
 
+`HOMEBREW_BOTTLE_DOMAIN`
+
+: Use this URL as the download mirror for bottles. If bottles at that URL are
+  temporarily unavailable, the default bottle domain will be used as a fallback
+  mirror. For example, `HOMEBREW_BOTTLE_DOMAIN=http://localhost:8080` will cause
+  all bottles to download from the prefix `http://localhost:8080/`. If bottles
+  are not available at `HOMEBREW_BOTTLE_DOMAIN` they will be downloaded from the
+  default bottle domain.
+  
   *Default:* `https://ghcr.io/v2/homebrew/core`.
 
-- `HOMEBREW_BREW_GIT_REMOTE`
-  <br>Use this URL as the Homebrew/brew `git`(1) remote.
+`HOMEBREW_BREW_GIT_REMOTE`
 
+: Use this URL as the Homebrew/brew `git`(1) remote.
+  
   *Default:* `https://github.com/Homebrew/brew`.
 
-- `HOMEBREW_BROWSER`
-  <br>Use this as the browser when opening project homepages.
+`HOMEBREW_BROWSER`
 
+: Use this as the browser when opening project homepages.
+  
   *Default:* `$BROWSER` or the OS's default browser.
 
-- `HOMEBREW_CACHE`
-  <br>Use this directory as the download cache.
+`HOMEBREW_BUNDLE_USER_CACHE`
 
-  *Default:* macOS: `$HOME/Library/Caches/Homebrew`, Linux: `$XDG_CACHE_HOME/Homebrew` or `$HOME/.cache/Homebrew`.
+: If set, use this directory as the `bundle`(1) user cache.
 
-- `HOMEBREW_CASK_OPTS`
-  <br>Append these options to all `cask` commands. All `--*dir` options, `--language`, `--require-sha`, `--no-quarantine` and `--no-binaries` are supported. For example, you might add something like the following to your `~/.profile`, `~/.bash_profile`, or `~/.zshenv`:\n\n    `export HOMEBREW_CASK_OPTS="--appdir=~/Applications --fontdir=/Library/Fonts"`
+`HOMEBREW_CACHE`
 
-- `HOMEBREW_CLEANUP_PERIODIC_FULL_DAYS`
-  <br>If set, `brew install`, `brew upgrade` and `brew reinstall` will cleanup all formulae when this number of days has passed.
+: Use this directory as the download cache.
+  
+  *Default:* macOS: `$HOME/Library/Caches/Homebrew`, Linux:
+  `$XDG_CACHE_HOME/Homebrew` or `$HOME/.cache/Homebrew`.
 
-  *Default:* `30`.
+`HOMEBREW_CASK_OPTS`
 
-- `HOMEBREW_CLEANUP_MAX_AGE_DAYS`
-  <br>Cleanup all cached files older than this many days.
+: Append these options to all `cask` commands. All `--*dir` options,
+  `--language`, `--require-sha`, `--no-quarantine` and `--no-binaries` are
+  supported. For example, you might add something like the following to your
+  `~/.profile`, `~/.bash_profile`, or `~/.zshenv`:
+  
+  `export HOMEBREW_CASK_OPTS="--appdir=~/Applications --fontdir=/Library/Fonts"`
 
+`HOMEBREW_CLEANUP_MAX_AGE_DAYS`
+
+: Cleanup all cached files older than this many days.
+  
   *Default:* `120`.
 
-- `HOMEBREW_COLOR`
-  <br>If set, force colour output on non-TTY outputs.
+`HOMEBREW_CLEANUP_PERIODIC_FULL_DAYS`
+
+: If set, `brew install`, `brew upgrade` and `brew reinstall` will cleanup all
+  formulae when this number of days has passed.
+  
+  *Default:* `30`.
+
+`HOMEBREW_COLOR`
 
-- `HOMEBREW_CORE_GIT_REMOTE`
-  <br>Use this URL as the Homebrew/homebrew-core `git`(1) remote.
+: If set, force colour output on non-TTY outputs.
 
+`HOMEBREW_CORE_GIT_REMOTE`
+
+: Use this URL as the Homebrew/homebrew-core `git`(1) remote.
+  
   *Default:* `https://github.com/Homebrew/homebrew-core`.
 
-- `HOMEBREW_CURLRC`
-  <br>If set, do not pass `--disable` when invoking `curl`(1), which disables the use of `curlrc`.
+`HOMEBREW_CURLRC`
+
+: If set to an absolute path (i.e. beginning with `/`), pass it with `--config`
+  when invoking `curl`(1). If set but *not* a valid path, do not pass
+  `--disable`, which disables the use of `.curlrc`.
 
-- `HOMEBREW_CURL_PATH`
-  <br>Linux only: Set this value to a new enough `curl` executable for Homebrew to use.
+`HOMEBREW_CURL_PATH`
 
+: Linux only: Set this value to a new enough `curl` executable for Homebrew to
+  use.
+  
   *Default:* `curl`.
 
-- `HOMEBREW_CURL_RETRIES`
-  <br>Pass the given retry count to `--retry` when invoking `curl`(1).
+`HOMEBREW_CURL_RETRIES`
 
+: Pass the given retry count to `--retry` when invoking `curl`(1).
+  
   *Default:* `3`.
 
-- `HOMEBREW_CURL_VERBOSE`
-  <br>If set, pass `--verbose` when invoking `curl`(1).
+`HOMEBREW_CURL_VERBOSE`
+
+: If set, pass `--verbose` when invoking `curl`(1).
+
+`HOMEBREW_DEBUG`
 
-- `HOMEBREW_DEVELOPER`
-  <br>If set, tweak behaviour to be more relevant for Homebrew developers (active or budding) by e.g. turning warnings into errors.
+: If set, always assume `--debug` when running commands.
 
-- `HOMEBREW_DISABLE_LOAD_FORMULA`
-  <br>If set, refuse to load formulae. This is useful when formulae are not trusted (such as in pull requests).
+`HOMEBREW_DEVELOPER`
 
-- `HOMEBREW_DISPLAY`
-  <br>Use this X11 display when opening a page in a browser, for example with `brew home`. Primarily useful on Linux.
+: If set, tweak behaviour to be more relevant for Homebrew developers (active or
+  budding) by e.g. turning warnings into errors.
 
+`HOMEBREW_DISABLE_DEBREW`
+
+: If set, the interactive formula debugger available via `--debug` will be
+  disabled.
+
+`HOMEBREW_DISABLE_LOAD_FORMULA`
+
+: If set, refuse to load formulae. This is useful when formulae are not trusted
+  (such as in pull requests).
+
+`HOMEBREW_DISPLAY`
+
+: Use this X11 display when opening a page in a browser, for example with `brew
+  home`. Primarily useful on Linux.
+  
   *Default:* `$DISPLAY`.
 
-- `HOMEBREW_DISPLAY_INSTALL_TIMES`
-  <br>If set, print install times for each formula at the end of the run.
+`HOMEBREW_DISPLAY_INSTALL_TIMES`
+
+: If set, print install times for each formula at the end of the run.
+
+`HOMEBREW_DOCKER_REGISTRY_BASIC_AUTH_TOKEN`
+
+: Use this base64 encoded username and password for authenticating with a Docker
+  registry proxying GitHub Packages. If `HOMEBREW_DOCKER_REGISTRY_TOKEN` is set,
+  it will be used instead.
 
-- `HOMEBREW_EDITOR`
-  <br>Use this editor when editing a single formula, or several formulae in the same directory.
+`HOMEBREW_DOCKER_REGISTRY_TOKEN`
 
-    *Note:* `brew edit` will open all of Homebrew as discontinuous files and directories. Visual Studio Code can handle this correctly in project mode, but many editors will do strange things in this case.
+: Use this bearer token for authenticating with a Docker registry proxying
+  GitHub Packages. Preferred over `HOMEBREW_DOCKER_REGISTRY_BASIC_AUTH_TOKEN`.
 
+`HOMEBREW_EDITOR`
+
+: Use this editor when editing a single formula, or several formulae in the same
+  directory.
+  
+  *Note:* `brew edit` will open all of Homebrew as discontinuous files and
+  directories. Visual Studio Code can handle this correctly in project mode, but
+  many editors will do strange things in this case.
+  
   *Default:* `$EDITOR` or `$VISUAL`.
 
-- `HOMEBREW_FAIL_LOG_LINES`
-  <br>Output this many lines of output on formula `system` failures.
+`HOMEBREW_EVAL_ALL`
+
+: If set, `brew` commands evaluate all formulae and casks, executing their
+  arbitrary code, by default without requiring `--eval-all`. Required to cache
+  formula and cask descriptions.
 
+`HOMEBREW_FAIL_LOG_LINES`
+
+: Output this many lines of output on formula `system` failures.
+  
   *Default:* `15`.
 
-- `HOMEBREW_FORBIDDEN_LICENSES`
-  <br>A space-separated list of licenses. Homebrew will refuse to install a formula if it or any of its dependencies has a license on this list.
+`HOMEBREW_FORBIDDEN_CASKS`
+
+: A space-separated list of casks. Homebrew will refuse to install a cask if it
+  or any of its dependencies is on this list.
+
+`HOMEBREW_FORBIDDEN_FORMULAE`
+
+: A space-separated list of formulae. Homebrew will refuse to install a formula
+  or cask if it or any of its dependencies is on this list.
+
+`HOMEBREW_FORBIDDEN_LICENSES`
+
+: A space-separated list of SPDX license identifiers. Homebrew will refuse to
+  install a formula if it or any of its dependencies has a license on this list.
 
-- `HOMEBREW_FORCE_BREWED_CA_CERTIFICATES`
-  <br>If set, always use a Homebrew-installed `ca-certificates` rather than the system version. Automatically set if the system version is too old.
+`HOMEBREW_FORBIDDEN_OWNER`
 
-- `HOMEBREW_FORCE_BREWED_CURL`
-  <br>If set, always use a Homebrew-installed `curl`(1) rather than the system version. Automatically set if the system version of `curl` is too old.
+: The person who has set any `HOMEBREW_FORBIDDEN_*` variables.
+  
+  *Default:* `you`.
 
-- `HOMEBREW_FORCE_BREWED_GIT`
-  <br>If set, always use a Homebrew-installed `git`(1) rather than the system version. Automatically set if the system version of `git` is too old.
+`HOMEBREW_FORBIDDEN_OWNER_CONTACT`
 
-- `HOMEBREW_FORCE_VENDOR_RUBY`
-  <br>If set, always use Homebrew's vendored, relocatable Ruby version even if the system version of Ruby is new enough.
+: How to contact the `HOMEBREW_FORBIDDEN_OWNER`, if set and necessary.
 
-- `HOMEBREW_GITHUB_API_TOKEN`
-  <br>Use this personal access token for the GitHub API, for features such as `brew search`. You can create one at <https://github.com/settings/tokens>. If set, GitHub will allow you a greater number of API requests. For more information, see: <https://docs.github.com/en/rest/overview/resources-in-the-rest-api#rate-limiting>
+`HOMEBREW_FORBIDDEN_TAPS`
 
-    *Note:* Homebrew doesn't require permissions for any of the scopes, but some developer commands may require additional permissions.
+: A space-separated list of taps. Homebrew will refuse to install a formula if
+  it or any of its dependencies is in a tap on this list.
 
-- `HOMEBREW_GITHUB_PACKAGES_TOKEN`
-  <br>Use this GitHub personal access token when accessing the GitHub Packages Registry (where bottles may be stored).
+`HOMEBREW_FORBID_PACKAGES_FROM_PATHS`
 
-- `HOMEBREW_DOCKER_REGISTRY_BASIC_AUTH_TOKEN`
-  <br>Use this base64 encoded username and password for authenticating with a Docker registry proxying GitHub Packages. If HOMEBREW_DOCKER_REGISTRY_TOKEN is set, it will be used instead.
+: If set, Homebrew will refuse to read formulae or casks provided from file
+  paths, e.g. `brew install ./package.rb`.
 
-- `HOMEBREW_DOCKER_REGISTRY_TOKEN`
-  <br>Use this bearer token for authenticating with a Docker registry proxying GitHub Packages. Preferred over HOMEBREW_DOCKER_REGISTRY_TOKEN_BASIC.
+`HOMEBREW_FORCE_BREWED_CA_CERTIFICATES`
 
-- `HOMEBREW_GITHUB_PACKAGES_USER`
-  <br>Use this username when accessing the GitHub Packages Registry (where bottles may be stored).
+: If set, always use a Homebrew-installed `ca-certificates` rather than the
+  system version. Automatically set if the system version is too old.
 
-- `HOMEBREW_GIT_EMAIL`
-  <br>Set the Git author and committer email to this value.
+`HOMEBREW_FORCE_BREWED_CURL`
 
-- `HOMEBREW_GIT_NAME`
-  <br>Set the Git author and committer name to this value.
+: If set, always use a Homebrew-installed `curl`(1) rather than the system
+  version. Automatically set if the system version of `curl` is too old.
 
-- `HOMEBREW_GIT_PATH`
-  <br>Linux only: Set this value to a new enough `git` executable for Homebrew to use.
+`HOMEBREW_FORCE_BREWED_GIT`
 
+: If set, always use a Homebrew-installed `git`(1) rather than the system
+  version. Automatically set if the system version of `git` is too old.
+
+`HOMEBREW_FORCE_VENDOR_RUBY`
+
+: If set, always use Homebrew's vendored, relocatable Ruby version even if the
+  system version of Ruby is new enough.
+
+`HOMEBREW_FORMULA_BUILD_NETWORK`
+
+: If set, controls network access to the sandbox for formulae builds. Overrides
+  any controls set through DSL usage inside formulae. Must be `allow` or `deny`.
+  If no value is set through this environment variable or DSL usage, the default
+  behavior is `allow`.
+
+`HOMEBREW_FORMULA_POSTINSTALL_NETWORK`
+
+: If set, controls network access to the sandbox for formulae postinstall.
+  Overrides any controls set through DSL usage inside formulae. Must be `allow`
+  or `deny`. If no value is set through this environment variable or DSL usage,
+  the default behavior is `allow`.
+
+`HOMEBREW_FORMULA_TEST_NETWORK`
+
+: If set, controls network access to the sandbox for formulae test. Overrides
+  any controls set through DSL usage inside formulae. Must be `allow` or `deny`.
+  If no value is set through this environment variable or DSL usage, the default
+  behavior is `allow`.
+
+`HOMEBREW_GITHUB_API_TOKEN`
+
+: Use this personal access token for the GitHub API, for features such as `brew
+  search`. You can create one at <https://github.com/settings/tokens>. If set,
+  GitHub will allow you a greater number of API requests. For more information,
+  see: <https://docs.github.com/en/rest/overview/rate-limits-for-the-rest-api>
+  
+  *Note:* Homebrew doesn't require permissions for any of the scopes, but some
+  developer commands may require additional permissions.
+
+`HOMEBREW_GITHUB_PACKAGES_TOKEN`
+
+: Use this GitHub personal access token when accessing the GitHub Packages
+  Registry (where bottles may be stored).
+
+`HOMEBREW_GITHUB_PACKAGES_USER`
+
+: Use this username when accessing the GitHub Packages Registry (where bottles
+  may be stored).
+
+`HOMEBREW_GIT_EMAIL`
+
+: Set the Git author and committer email to this value.
+
+`HOMEBREW_GIT_NAME`
+
+: Set the Git author and committer name to this value.
+
+`HOMEBREW_GIT_PATH`
+
+: Linux only: Set this value to a new enough `git` executable for Homebrew to
+  use.
+  
   *Default:* `git`.
 
-- `HOMEBREW_INSTALL_BADGE`
-  <br>Print this text before the installation summary of each successful build.
+`HOMEBREW_INSTALL_BADGE`
 
+: Print this text before the installation summary of each successful build.
+  
   *Default:* The "Beer Mug" emoji.
 
-- `HOMEBREW_INSTALL_FROM_API`
-  <br>If set, install formulae and casks in homebrew/core and homebrew/cask taps using Homebrew's API instead of needing (large, slow) local checkouts of these repositories.
+`HOMEBREW_LIVECHECK_WATCHLIST`
 
-    *Note:* Setting HOMEBREW_INSTALL_FROM_API is not compatible with Homebrew's developer mode so will error (as Homebrew development needs a full clone).
+: Consult this file for the list of formulae to check by default when no formula
+  argument is passed to `brew livecheck`.
+  
+  *Default:* `$XDG_CONFIG_HOME/homebrew/livecheck_watchlist.txt` if
+  `$XDG_CONFIG_HOME` is set or `$HOME/.homebrew/livecheck_watchlist.txt`
+  otherwise.
 
-- `HOMEBREW_LIVECHECK_WATCHLIST`
-  <br>Consult this file for the list of formulae to check by default when no formula argument is passed to `brew livecheck`.
+`HOMEBREW_LOCK_CONTEXT`
 
-  *Default:* `$HOME/.brew_livecheck_watchlist`
+: If set, Homebrew will add this output as additional context for locking
+  errors. This is useful when running `brew` in the background.
 
-- `HOMEBREW_LOGS`
-  <br>Use this directory to store log files.
+`HOMEBREW_LOGS`
 
-  *Default:* macOS: `$HOME/Library/Logs/Homebrew`, Linux: `$XDG_CACHE_HOME/Homebrew/Logs` or `$HOME/.cache/Homebrew/Logs`.
+: Use this directory to store log files.
+  
+  *Default:* macOS: `$HOME/Library/Logs/Homebrew`, Linux:
+  `$XDG_CACHE_HOME/Homebrew/Logs` or `$HOME/.cache/Homebrew/Logs`.
 
-- `HOMEBREW_MAKE_JOBS`
-  <br>Use this value as the number of parallel jobs to run when building with `make`(1).
+`HOMEBREW_MAKE_JOBS`
 
+: Use this value as the number of parallel jobs to run when building with
+  `make`(1).
+  
   *Default:* The number of available CPU cores.
 
-- `HOMEBREW_NO_ANALYTICS`
-  <br>If set, do not send analytics. For more information, see: <https://docs.brew.sh/Analytics>
+`HOMEBREW_NO_ANALYTICS`
+
+: If set, do not send analytics. Google Analytics were destroyed. For more
+  information, see: <https://docs.brew.sh/Analytics>
+
+`HOMEBREW_NO_AUTOREMOVE`
+
+: If set, calls to `brew cleanup` and `brew uninstall` will not automatically
+  remove unused formula dependents.
+
+`HOMEBREW_NO_AUTO_UPDATE`
 
-- `HOMEBREW_NO_AUTO_UPDATE`
-  <br>If set, do not automatically update before running some commands, e.g. `brew install`, `brew upgrade` and `brew tap`. Alternatively, run this less often by setting HOMEBREW_AUTO_UPDATE_SECS to a value higher than the default.
+: If set, do not automatically update before running some commands, e.g. `brew
+  install`, `brew upgrade` and `brew tap`. Preferably, run this less often by
+  setting `HOMEBREW_AUTO_UPDATE_SECS` to a value higher than the default. Note
+  that setting this and e.g. tapping new taps may result in a broken
+  configuration. Please ensure you always run `brew update` before reporting any
+  issues.
 
-- `HOMEBREW_NO_BOOTSNAP`
-  <br>If set, do not use Bootsnap to speed up repeated `brew` calls.
+`HOMEBREW_NO_BOOTSNAP`
 
-- `HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK`
-  <br>If set, do not check for broken linkage of dependents or outdated dependents after installing, upgrading or reinstalling formulae. This will result in fewer dependents (and their dependencies) being upgraded or reinstalled but may result in more breakage from running `brew install *`formula`*` or `brew upgrade *`formula`*`.
+: If set, do not use Bootsnap to speed up repeated `brew` calls.
 
-- `HOMEBREW_NO_CLEANUP_FORMULAE`
-  <br>A comma-separated list of formulae. Homebrew will refuse to clean up a formula if it appears on this list.
+`HOMEBREW_NO_CLEANUP_FORMULAE`
 
-- `HOMEBREW_NO_COLOR`
-  <br>If set, do not print text with colour added.
+: A comma-separated list of formulae. Homebrew will refuse to clean up or
+  autoremove a formula if it appears on this list.
 
+`HOMEBREW_NO_COLOR`
+
+: If set, do not print text with colour added.
+  
   *Default:* `$NO_COLOR`.
 
-- `HOMEBREW_NO_COMPAT`
-  <br>If set, disable all use of legacy compatibility code.
+`HOMEBREW_NO_EMOJI`
+
+: If set, do not print `HOMEBREW_INSTALL_BADGE` on a successful build.
+
+`HOMEBREW_NO_ENV_HINTS`
+
+: If set, do not print any hints about changing Homebrew's behaviour with
+  environment variables.
+
+`HOMEBREW_NO_GITHUB_API`
+
+: If set, do not use the GitHub API, e.g. for searches or fetching relevant
+  issues after a failed install.
+
+`HOMEBREW_NO_INSECURE_REDIRECT`
+
+: If set, forbid redirects from secure HTTPS to insecure HTTP.
+  
+  *Note:* while ensuring your downloads are fully secure, this is likely to
+  cause from-source SourceForge, some GNU & GNOME-hosted formulae to fail to
+  download.
 
-- `HOMEBREW_NO_EMOJI`
-  <br>If set, do not print `HOMEBREW_INSTALL_BADGE` on a successful build.
+`HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK`
 
-    *Note:* Will only try to print emoji on OS X Lion or newer.
+: If set, do not check for broken linkage of dependents or outdated dependents
+  after installing, upgrading or reinstalling formulae. This will result in
+  fewer dependents (and their dependencies) being upgraded or reinstalled but
+  may result in more breakage from running `brew install` *`formula`* or `brew
+  upgrade` *`formula`*.
 
-- `HOMEBREW_NO_ENV_HINTS`
-  <br>If set, do not print any hints about changing Homebrew's behaviour with environment variables.
+`HOMEBREW_NO_INSTALL_CLEANUP`
 
-- `HOMEBREW_NO_GITHUB_API`
-  <br>If set, do not use the GitHub API, e.g. for searches or fetching relevant issues after a failed install.
+: If set, `brew install`, `brew upgrade` and `brew reinstall` will never
+  automatically cleanup installed/upgraded/reinstalled formulae or all formulae
+  every `HOMEBREW_CLEANUP_PERIODIC_FULL_DAYS` days. Alternatively,
+  `HOMEBREW_NO_CLEANUP_FORMULAE` allows specifying specific formulae to not
+  clean up.
 
-- `HOMEBREW_NO_INSECURE_REDIRECT`
-  <br>If set, forbid redirects from secure HTTPS to insecure HTTP.
+`HOMEBREW_NO_INSTALL_FROM_API`
 
-    *Note:* While ensuring your downloads are fully secure, this is likely to cause from-source SourceForge, some GNU & GNOME-hosted formulae to fail to download.
+: If set, do not install formulae and casks in homebrew/core and homebrew/cask
+  taps using Homebrew's API and instead use (large, slow) local checkouts of
+  these repositories.
 
-- `HOMEBREW_NO_INSTALL_CLEANUP`
-  <br>If set, `brew install`, `brew upgrade` and `brew reinstall` will never automatically cleanup installed/upgraded/reinstalled formulae or all formulae every `HOMEBREW_CLEANUP_PERIODIC_FULL_DAYS` days. Alternatively, HOMEBREW_NO_CLEANUP_FORMULAE allows specifying specific formulae to not clean up.
+`HOMEBREW_NO_INSTALL_UPGRADE`
 
-- `HOMEBREW_NO_INSTALL_UPGRADE`
-  <br>If set, `brew install *`formula`*` will not upgrade `*`formula`*` if it is installed but outdated.
+: If set, `brew install` *`formula|cask`* will not upgrade *`formula|cask`* if
+  it is installed but outdated.
 
-- `HOMEBREW_PRY`
-  <br>If set, use Pry for the `brew irb` command.
+`HOMEBREW_NO_UPDATE_REPORT_NEW`
 
-- `HOMEBREW_SIMULATE_MACOS_ON_LINUX`
-  <br>If set, running Homebrew on Linux will simulate certain macOS code paths. This is useful when auditing macOS formulae while on Linux.
+: If set, `brew update` will not show the list of newly added formulae/casks.
 
-- `HOMEBREW_SSH_CONFIG_PATH`
-  <br>If set, Homebrew will use the given config file instead of `~/.ssh/config` when fetching `git` repos over `ssh`.
+`HOMEBREW_NO_VERIFY_ATTESTATIONS`
 
+: If set, Homebrew not verify cryptographic attestations of build provenance for
+  bottles from homebrew-core.
+
+`HOMEBREW_PIP_INDEX_URL`
+
+: If set, `brew install` *`formula`* will use this URL to download PyPI package
+  resources.
+  
+  *Default:* `https://pypi.org/simple`.
+
+`HOMEBREW_PRY`
+
+: If set, use Pry for the `brew irb` command.
+
+`HOMEBREW_SIMULATE_MACOS_ON_LINUX`
+
+: If set, running Homebrew on Linux will simulate certain macOS code paths. This
+  is useful when auditing macOS formulae while on Linux.
+
+`HOMEBREW_SKIP_OR_LATER_BOTTLES`
+
+: If set along with `HOMEBREW_DEVELOPER`, do not use bottles from older versions
+  of macOS. This is useful in development on new macOS versions.
+
+`HOMEBREW_SORBET_RUNTIME`
+
+: If set, enable runtime typechecking using Sorbet. Set by default for
+  `HOMEBREW_DEVELOPER` or when running some developer commands.
+
+`HOMEBREW_SSH_CONFIG_PATH`
+
+: If set, Homebrew will use the given config file instead of `~/.ssh/config`
+  when fetching Git repositories over SSH.
+  
   *Default:* `$HOME/.ssh/config`
 
-- `HOMEBREW_SKIP_OR_LATER_BOTTLES`
-  <br>If set along with `HOMEBREW_DEVELOPER`, do not use bottles from older versions of macOS. This is useful in development on new macOS versions.
+`HOMEBREW_SUDO_THROUGH_SUDO_USER`
 
-- `HOMEBREW_SORBET_RUNTIME`
-  <br>If set, enable runtime typechecking using Sorbet.
+: If set, Homebrew will use the `SUDO_USER` environment variable to define the
+  user to `sudo`(8) through when running `sudo`(8).
 
-- `HOMEBREW_SVN`
-  <br>Use this as the `svn`(1) binary.
+`HOMEBREW_SVN`
 
-  *Default:* A Homebrew-built Subversion (if installed), or the system-provided binary.
+: Use this as the `svn`(1) binary.
+  
+  *Default:* A Homebrew-built Subversion (if installed), or the system-provided
+  binary.
 
-- `HOMEBREW_TEMP`
-  <br>Use this path as the temporary directory for building packages. Changing this may be needed if your system temporary directory and Homebrew prefix are on different volumes, as macOS has trouble moving symlinks across volumes when the target does not yet exist. This issue typically occurs when using FileVault or custom SSD configurations.
+`HOMEBREW_SYSTEM_ENV_TAKES_PRIORITY`
 
+: If set in Homebrew's system-wide environment file (`/etc/homebrew/brew.env`),
+  the system-wide environment file will be loaded last to override any prefix or
+  user settings.
+
+`HOMEBREW_TEMP`
+
+: Use this path as the temporary directory for building packages. Changing this
+  may be needed if your system temporary directory and Homebrew prefix are on
+  different volumes, as macOS has trouble moving symlinks across volumes when
+  the target does not yet exist. This issue typically occurs when using
+  FileVault or custom SSD configurations.
+  
   *Default:* macOS: `/private/tmp`, Linux: `/tmp`.
 
-- `HOMEBREW_UPDATE_REPORT_ALL_FORMULAE`
-  <br>If set, `brew update` lists changes to all formulae and cask files rather than only showing when they are new and not installed or outdated and installed.
+`HOMEBREW_UPDATE_TO_TAG`
+
+: If set, always use the latest stable tag (even if developer commands have been
+  run).
+
+`HOMEBREW_UPGRADE_GREEDY`
 
-- `HOMEBREW_UPDATE_TO_TAG`
-  <br>If set, always use the latest stable tag (even if developer commands have been run).
+: If set, pass `--greedy` to all cask upgrade commands.
 
-- `HOMEBREW_VERBOSE`
-  <br>If set, always assume `--verbose` when running commands.
+`HOMEBREW_VERBOSE`
 
-- `HOMEBREW_DEBUG`
-  <br>If set, always assume `--debug` when running commands.
+: If set, always assume `--verbose` when running commands.
 
-- `HOMEBREW_VERBOSE_USING_DOTS`
-  <br>If set, verbose output will print a `.` no more than once a minute. This can be useful to avoid long-running Homebrew commands being killed due to no output.
+`HOMEBREW_VERBOSE_USING_DOTS`
 
-- `all_proxy`
-  <br>Use this SOCKS5 proxy for `curl`(1), `git`(1) and `svn`(1) when downloading through Homebrew.
+: If set, verbose output will print a `.` no more than once a minute. This can
+  be useful to avoid long-running Homebrew commands being killed due to no
+  output.
 
-- `ftp_proxy`
-  <br>Use this FTP proxy for `curl`(1), `git`(1) and `svn`(1) when downloading through Homebrew.
+`HOMEBREW_VERIFY_ATTESTATIONS`
 
-- `http_proxy`
-  <br>Use this HTTP proxy for `curl`(1), `git`(1) and `svn`(1) when downloading through Homebrew.
+: If set, Homebrew will use the `gh` tool to verify cryptographic attestations
+  of build provenance for bottles from homebrew-core.
 
-- `https_proxy`
-  <br>Use this HTTPS proxy for `curl`(1), `git`(1) and `svn`(1) when downloading through Homebrew.
+`SUDO_ASKPASS`
 
-- `no_proxy`
-  <br>A comma-separated list of hostnames and domain names excluded from proxying by `curl`(1), `git`(1) and `svn`(1) when downloading through Homebrew.
+: If set, pass the `-A` option when calling `sudo`(8).
 
-- `SUDO_ASKPASS`
-  <br>If set, pass the `-A` option when calling `sudo`(8).
+`all_proxy`
+
+: Use this SOCKS5 proxy for `curl`(1), `git`(1) and `svn`(1) when downloading
+  through Homebrew.
+
+`ftp_proxy`
+
+: Use this FTP proxy for `curl`(1), `git`(1) and `svn`(1) when downloading
+  through Homebrew.
+
+`http_proxy`
+
+: Use this HTTP proxy for `curl`(1), `git`(1) and `svn`(1) when downloading
+  through Homebrew.
+
+`https_proxy`
+
+: Use this HTTPS proxy for `curl`(1), `git`(1) and `svn`(1) when downloading
+  through Homebrew.
+
+`no_proxy`
+
+: A comma-separated list of hostnames and domain names excluded from proxying by
+  `curl`(1), `git`(1) and `svn`(1) when downloading through Homebrew.
 
 ## USING HOMEBREW BEHIND A PROXY
 
@@ -2227,7 +4150,7 @@ environment variables documented above.
 For example, to use an unauthenticated HTTP or SOCKS5 proxy:
 
     export http_proxy=http://$HOST:$PORT
-
+    
     export all_proxy=socks5://$HOST:$PORT
 
 And for an authenticated HTTP proxy:
@@ -2246,43 +4169,39 @@ Homebrew API: <https://rubydoc.brew.sh>
 
 Homebrew's Project Leader is Mike McQuaid.
 
-Homebrew's Project Leadership Committee is Issy Long, Jonathan Chang, Mike McQuaid, Misty De Méo and Sean Molenaar.
+Homebrew's Project Leadership Committee is Colin Dean, Issy Long, Mike McQuaid,
+Patrick Linnane and Vanessa Gennarelli.
 
-Homebrew's Technical Steering Committee is Bo Anderson, FX Coudert, Michka Popoff, Mike McQuaid and Rylan Polster.
+Homebrew's Technical Steering Committee is Bo Anderson, FX Coudert, Michka
+Popoff, Mike McQuaid and Rylan Polster.
 
-Homebrew's other current maintainers are Alexander Bayandin, Bevan Kay, Branch Vincent, Caleb Xu, Carlo Cabrera, Daniel Nachun, Dawid Dziurla, Dustin Rodrigues, Eric Knibbe, George Adams, Markus Reiter, Maxim Belkin, Miccal Matthews, Michael Cho, Nanda H Krishna, Randall, Rui Chen, Sam Ford, Shaun Jackman, Steve Peters, Thierry Moisan and Vítor Galvão.
+Homebrew's maintainers are Alexander Bayandin, Bevan Kay, Bo Anderson, Branch
+Vincent, Caleb Xu, Carlo Cabrera, Daeho Ro, Douglas Eichelberger, Dustin
+Rodrigues, Eric Knibbe, FX Coudert, Issy Long, Justin Krehel, Klaus Hipp, Markus
+Reiter, Michael Cho, Michka Popoff, Mike McQuaid, Nanda H Krishna, Patrick
+Linnane, Rui Chen, Ruoyu Zhong, Rylan Polster, Sam Ford, Sean Molenaar, Thierry
+Moisan, Timothy Sutton, William Woodruff and Štefan Baebler.
 
-Former maintainers with significant contributions include Claudia Pellegrino, Seeker, William Woodruff, Jan Viljanen, JCount, commitay, Dominyk Tiller, Tim Smith, Baptiste Fontaine, Xu Cheng, Martin Afanasjew, Brett Koonce, Charlie Sharpsteen, Jack Nagel, Adam Vandenberg, Andrew Janke, Alex Dunn, neutric, Tomasz Pajor, Uladzislau Shablinski, Alyssa Ross, ilovezfs, Chongyu Zhu and Homebrew's creator: Max Howell.
+Former maintainers with significant contributions include Miccal Matthews, Misty
+De Méo, Shaun Jackman, Vítor Galvão, Claudia Pellegrino, Seeker, Jan Viljanen,
+JCount, commitay, Dominyk Tiller, Tim Smith, Baptiste Fontaine, Xu Cheng, Martin
+Afanasjew, Brett Koonce, Charlie Sharpsteen, Jack Nagel, Adam Vandenberg, Andrew
+Janke, Alex Dunn, neutric, Tomasz Pajor, Uladzislau Shablinski, Alyssa Ross,
+ilovezfs, Chongyu Zhu and Homebrew's creator: Max Howell.
 
 ## BUGS
 
 See our issues on GitHub:
 
-  * **Homebrew/brew**:
-    <br><https://github.com/Homebrew/brew/issues>
-
-  * **Homebrew/homebrew-core**:
-    <br><https://github.com/Homebrew/homebrew-core/issues>
-
-  * **Homebrew/homebrew-cask**:
-    <br><https://github.com/Homebrew/homebrew-cask/issues>
-
-[SYNOPSIS]: #SYNOPSIS "SYNOPSIS"
-[DESCRIPTION]: #DESCRIPTION "DESCRIPTION"
-[TERMINOLOGY]: #TERMINOLOGY "TERMINOLOGY"
-[ESSENTIAL COMMANDS]: #ESSENTIAL-COMMANDS "ESSENTIAL COMMANDS"
-[COMMANDS]: #COMMANDS "COMMANDS"
-[DEVELOPER COMMANDS]: #DEVELOPER-COMMANDS "DEVELOPER COMMANDS"
-[GLOBAL CASK OPTIONS]: #GLOBAL-CASK-OPTIONS "GLOBAL CASK OPTIONS"
-[GLOBAL OPTIONS]: #GLOBAL-OPTIONS "GLOBAL OPTIONS"
-[OFFICIAL EXTERNAL COMMANDS]: #OFFICIAL-EXTERNAL-COMMANDS "OFFICIAL EXTERNAL COMMANDS"
-[CUSTOM EXTERNAL COMMANDS]: #CUSTOM-EXTERNAL-COMMANDS "CUSTOM EXTERNAL COMMANDS"
-[SPECIFYING FORMULAE]: #SPECIFYING-FORMULAE "SPECIFYING FORMULAE"
-[SPECIFYING CASKS]: #SPECIFYING-CASKS "SPECIFYING CASKS"
-[ENVIRONMENT]: #ENVIRONMENT "ENVIRONMENT"
-[USING HOMEBREW BEHIND A PROXY]: #USING-HOMEBREW-BEHIND-A-PROXY "USING HOMEBREW BEHIND A PROXY"
-[SEE ALSO]: #SEE-ALSO "SEE ALSO"
-[AUTHORS]: #AUTHORS "AUTHORS"
-[BUGS]: #BUGS "BUGS"
-
-[-]: -.html
+**Homebrew/brew**
+
+: <https://github.com/Homebrew/brew/issues>
+
+**Homebrew/homebrew-core**
+
+: <https://github.com/Homebrew/homebrew-core/issues>
+
+**Homebrew/homebrew-cask**
+
+: <https://github.com/Homebrew/homebrew-cask/issues>
+
diff --git a/docs/Migrating-A-Formula-To-A-Tap.md b/docs/Migrating-A-Formula-To-A-Tap.md
index cc50990777430..08c54d7d42d65 100644
--- a/docs/Migrating-A-Formula-To-A-Tap.md
+++ b/docs/Migrating-A-Formula-To-A-Tap.md
@@ -1,11 +1,11 @@
-# Migrating A Formula To A Tap
+# Migrating a Formula to a Tap
 
 There are times when we may wish to migrate a formula from one tap into another tap. To do this:
 
-1. Create a pull request to the new tap adding the formula file as-is from the original tap. Fix any test failures that may occur due to the stricter requirements for new formulae than existing formula (e.g. `brew audit --strict` must pass for that formula).
-2. Create a pull request to the original tap deleting the formula file and add it to `tap_migrations.json` with a commit message like `gv: migrate to homebrew/core`.
+1. Create a pull request on the new tap adding the formula file as-is from the original tap. Fix any test failures that may occur due to the stricter requirements for new formulae compared to existing formulae (e.g. `brew audit --strict` must pass for that formula).
+2. Create a pull request on the original tap deleting the formula file and adding it to `tap_migrations.json` with a commit message like `gv: migrate to homebrew/core`.
 3. Put a link for each pull request in the other pull request so the maintainers can merge them both at once.
 
-Congratulations, you've moved a formula to a tap!
+Congratulations, you've moved a formula to another tap!
 
-For Homebrew maintainers, formulae should only ever be migrated into and within the Homebrew organisation (e.g. from Homebrew/core to Homebrew/cask, or from a third-party tap to Homebrew/core), and never out of it.
+For Homebrew maintainers, formulae should only ever be migrated into and within the Homebrew organisation (e.g. from `homebrew/core` to `homebrew/cask`, or from a third-party tap to `homebrew/core`), and never out of it.
diff --git a/docs/New-Maintainer-Checklist.md b/docs/New-Maintainer-Checklist.md
index e37cc0a000959..528c81298e769 100644
--- a/docs/New-Maintainer-Checklist.md
+++ b/docs/New-Maintainer-Checklist.md
@@ -1,6 +1,15 @@
 # New Maintainer Checklist
 
-**This is a guide used by existing maintainers to invite new maintainers. You might find it interesting but there's nothing here users should have to know.**
+**Existing maintainers and project leadership uses this guide to invite and onboard new maintainers and project leaders.**
+**General Homebrew users might find it interesting but there's nothing here _users_ should have to know.**
+
+- [Homebrew Maintainers](#maintainers)
+- [Project Leadership Committee](#plc)
+- [Technical Steering Committee](#tsc)
+- [Owners](#owners)
+- [General Members](#members)
+
+## Maintainers
 
 There's someone who has been making consistently high-quality contributions to Homebrew and shown themselves able to make slightly more advanced contributions than just e.g. formula updates? Let's invite them to be a maintainer!
 
@@ -11,15 +20,18 @@ The Homebrew team and I really appreciate your help on issues, pull requests and
 your contributions to Homebrew.
 
 We would like to invite you to have commit access and be a Homebrew maintainer.
-If you agree to be a maintainer, you should spend a significant proportion of
-the time you are working on Homebrew applying and self-merging widely used
-changes (e.g. version updates), triaging, fixing and debugging user-reported
-issues, or reviewing user pull requests. You should also be making contributions
-to Homebrew at least once per quarter.
+If you agree to be a maintainer, you should spend the majority of the time you
+are working on Homebrew (in descending order of priority):
+
+- reviewing pull requests (from users and other maintainers)
+- triaging, debugging and fixing user-reported issues and applying
+- opening PRs for widely used changes (e.g. version updates)
 
-You should watch or regularly check Homebrew/brew and/or
-Homebrew/homebrew-core and/or Homebrew/homebrew-cask. Let us know which so we
-can grant you commit access appropriately.
+You should also be making contributions to Homebrew at least once per quarter.
+
+You should watch or regularly check Homebrew/brew and/or Homebrew/homebrew-core
+and/or Homebrew/homebrew-cask. Let us know which so we can grant you commit
+access appropriately.
 
 If you're no longer able to perform all of these tasks, please continue to
 contribute to Homebrew, but we will ask you to step down as a maintainer.
@@ -35,10 +47,8 @@ A few requests:
     - Homebrew/brew: https://docs.brew.sh/Homebrew-brew-Maintainer-Guide
     - Homebrew/homebrew-core: https://docs.brew.sh/Homebrew-homebrew-core-Maintainer-Guide
     - Homebrew/homebrew-cask: https://docs.brew.sh/Homebrew-homebrew-cask-Maintainer-Guide
-- Still create your branches on your fork rather than in the main repository.
-  Note GitHub's UI will create edits and reverts on the main repository if you
-  make edits or click "Revert" on the Homebrew/brew repository rather than your
-  own fork.
+- Create branches in the main repository rather than on your fork to ease collaboration
+  with other maintainers and allow security assumptions to be made based on GitHub access.
 - If still in doubt please ask for help and we'll help you out.
 - Please read:
     - https://docs.brew.sh/Maintainer-Guidelines
@@ -53,29 +63,47 @@ Thanks for all your work so far!
 If they accept, follow a few steps to get them set up:
 
 - Invite them to the [**@Homebrew/maintainers** team](https://github.com/orgs/Homebrew/teams/maintainers) (or any relevant [subteams](https://github.com/orgs/Homebrew/teams/maintainers/teams)) to give them write access to relevant repositories (but don't make them owners). They will need to enable [GitHub's Two Factor Authentication](https://help.github.com/articles/about-two-factor-authentication/).
-- Invite them to the [`machomebrew` private maintainers Slack](https://machomebrew.slack.com/admin/invites) (and ensure they've read the [communication guidelines](Maintainer-Guidelines.md#communication)) and ask them to use their real name there (rather than a pseudonym they may use on e.g. GitHub).
+- Invite them as a full member to the [`machomebrew` private Slack](https://machomebrew.slack.com/admin/invites) (and ensure they've read the [communication guidelines](Maintainer-Guidelines.md#communication)) and ask them to use their real name there (rather than a pseudonym they may use on e.g. GitHub).
 - Ask them to disable SMS as a 2FA device or fallback on their GitHub account in favour of using one of the other authentication methods.
 - Ask them to (regularly) review remove any unneeded [GitHub personal access tokens](https://github.com/settings/tokens).
 - Start the process to [add them as Homebrew members](#members), for formal voting rights and the ability to hold office for Homebrew.
 
-If they are interested in doing system administration work:
+If there are problems, ask them to step down as a maintainer.
+
+When they cease to be a maintainer for any reason, revoke their access to all of the above.
 
-- Invite them to the [`homebrew` private 1Password](https://homebrew.1password.com/people).
-- Optionally: make them [owners on the Homebrew GitHub organisation](https://github.com/orgs/Homebrew/people) if they need to access organisation-wide settings (like GitHub Actions organisation shared runners).
+In the interests of loosely verifying maintainer identity and building camaraderie, if you find yourself in the same town (e.g living, visiting or at a conference) as another Homebrew maintainer you should make the effort to meet up. If you do so, you can [expense your meal](https://docs.opencollective.com/help/expenses-and-getting-paid/submitting-expenses) (within [Homebrew's reimbursable expense policies](https://opencollective.com/homebrew/expenses)). This is a more relaxed version of similar policies used by other projects, e.g. the Debian system to meet in person to sign keys with legal ID verification.
 
-If they are elected to the Homebrew's [Project Leadership Committee](https://docs.brew.sh/Homebrew-Governance#4-project-leadership-committee):
+Now sit back, relax and let the new maintainers handle more of our contributions.
+
+## PLC
+
+If a maintainer or member is elected to the Homebrew's [Project Leadership Committee](https://docs.brew.sh/Homebrew-Governance#4-project-leadership-committee):
 
-- Make them [owners on the Homebrew GitHub organisation](https://github.com/orgs/Homebrew/people)
 - Invite them to the [**@Homebrew/plc** team](https://github.com/orgs/Homebrew/teams/plc/members)
-- Invite them to [Google Analytics](https://analytics.google.com/analytics/web/#management/Settings/a76679469w115400090p120682403/%3Fm.page%3DAccountUsers/).
-- Invite them to the [`homebrew` private 1Password](https://homebrew.1password.com/people).
-- Make them owners on the [`machomebrew` private maintainers Slack](https://machomebrew.slack.com/admin).
+- Make them [billing managers](https://github.com/organizations/Homebrew/settings/billing) and [moderators](https://github.com/organizations/Homebrew/settings/moderators) on the Homebrew GitHub organisation
+- Invite them to the [`homebrew` private 1Password](https://homebrew.1password.com/people) and add them to the "plc" group.
 
-If there are problems, ask them to step down as a maintainer and revoke their access to all of the above.
+When they cease to be a PLC member, revoke or downgrade their access to all of the above.
 
-In the interests of loosely verifying maintainer identity and building camaraderie, if you find yourself in the same town (e.g living, visiting or at a conference) as another Homebrew maintainer you should make the effort to meet up. If you do so, you can expense your meal (within [SFC reimbursable expense policies](https://sfconservancy.org/projects/policies/conservancy-travel-policy.html#meals-for-organizational-development)). This is a more relaxed version of similar policies used by other projects, e.g. the Debian system to meet in person to sign keys with legal ID verification.
+## TSC
 
-Now sit back, relax and let the new maintainers handle more of our contributions.
+If a maintainer is elected to the Homebrew's [Technical Steering Committee](https://docs.brew.sh/Homebrew-Governance#7-technical-steering-committee):
+
+- Invite them to the [**@Homebrew/tsc** team](https://github.com/orgs/Homebrew/teams/tsc/members)
+- Make them [billing managers](https://github.com/organizations/Homebrew/settings/billing) and [moderators](https://github.com/organizations/Homebrew/settings/moderators) on the Homebrew GitHub organisation
+
+When they cease to be a TSC member, revoke or downgrade their access to all of the above.
+
+## Owners
+
+The Project Leader, one other PLC member (ideally a maintainer) and one other TSC member should be made owners on GitHub and Slack:
+
+- Make them owners on the [Homebrew GitHub organisation](https://github.com/orgs/Homebrew/people)
+- Make them owners on the [`machomebrew` private Slack](https://machomebrew.slack.com/admin)
+- Make them owners on the [`homebrew` private 1Password](https://homebrew.1password.com/people)
+
+When they cease to be am owner, revoke or downgrade their access to all of the above.
 
 ## Members
 
@@ -84,5 +112,15 @@ People who are either not eligible or willing to be Homebrew maintainers but hav
 When admitted as members:
 
 - Invite them to the [**@Homebrew/members** team](https://github.com/orgs/Homebrew/teams/members), to give them access to the private governance repository.
-- Invite them as a single-channel guest to the #members channel on the [`machomebrew` private maintainers Slack](https://machomebrew.slack.com/admin/invites) (and ensure they've read the [communication guidelines](Maintainer-Guidelines.md#communication)) and ask them to use their real name there (rather than a pseudonym they may use on e.g. GitHub).
-- Add them to the membership list in the [homebrew-governance repository](https://github.com/Homebrew/homebrew-governance).
+- Invite them as a single-channel guest to the #members channel on the [`machomebrew` private Slack](https://machomebrew.slack.com/admin/invites) (and ensure they've read the [communication guidelines](Maintainer-Guidelines.md#communication)) and ask them to use their real name there (rather than a pseudonym they may use on e.g. GitHub).
+- Add them to the current year's membership list in the [governance archives](https://github.com/Homebrew/brew/tree/master/docs/governance).
+
+If they are interested in doing ops/infrastructure/system administration work:
+
+- Invite them to the [`homebrew` private 1Password](https://homebrew.1password.com/people) and add them to the "ops" group.
+
+If they are interested in doing security work:
+
+- Invite them to the [`homebrew` private 1Password](https://homebrew.1password.com/people) and add them to the "security" group.
+
+See [Homebrew Governance](Homebrew-Governance.md) for when an individual's membership expires.
diff --git a/docs/Node-for-Formula-Authors.md b/docs/Node-for-Formula-Authors.md
index df9cfec310949..99ad8b1e2d764 100644
--- a/docs/Node-for-Formula-Authors.md
+++ b/docs/Node-for-Formula-Authors.md
@@ -4,23 +4,19 @@ This document explains how to successfully use Node and npm in a Node module bas
 
 ## Running `npm install`
 
-Homebrew provides two helper methods in a `Language::Node` module: `std_npm_install_args` and `local_npm_install_args`. They both set up the correct environment for npm and return arguments for `npm install` for their specific use cases. Your formula should use these instead of invoking `npm install` explicitly. The syntax for a standard Node module installation is:
+Homebrew provides a helper method `std_npm_args` to set up the correct environment for npm and return arguments for `npm install`. Your formula should use this when invoking `npm install`. The syntax for a standard Node module installation is:
 
 ```ruby
-system "npm", "install", *Language::Node.std_npm_install_args(libexec)
+system "npm", "install", *std_npm_args
 ```
 
-where `libexec` is the destination prefix (usually the `libexec` variable).
-
 ## Download URL
 
-If the Node module is also available on the npm registry, we prefer npm hosted release tarballs over GitHub (or elsewhere) hosted source tarballs. The advantages of these tarballs are that they don't include the files from the `.npmignore` (such as tests) resulting in a smaller download size and that any possible transpilation step is already done (e.g. no need to compile CoffeeScript files as a build step).
+If the Node module is also available on the npm registry, we prefer npm-hosted release tarballs over GitHub (or elsewhere) hosted source tarballs. The advantages of these tarballs are that they don't include the files from the `.npmignore` (such as tests) resulting in a smaller download size and that any possible transpilation step is already done (e.g. no need to compile CoffeeScript files as a build step).
 
 The npm registry URLs usually have the format of:
 
-```
-https://registry.npmjs.org/<name>/-/<name>-<version>.tgz
-```
+    https://registry.npmjs.org/<name>/-/<name>-<version>.tgz
 
 Alternatively you could `curl` the JSON at `https://registry.npmjs.org/<name>` and look for the value of `versions[<version>].dist.tarball` for the correct tarball URL.
 
@@ -32,7 +28,7 @@ Node modules which are compatible with the latest Node version should declare a
 depends_on "node"
 ```
 
-If your formula requires being executed with an older Node version you should use one of the versioned node formulae (e.g. `node@12`).
+If your formula requires being executed with an older Node version you should use one of its versioned formulae (e.g. `node@20`).
 
 ### Special requirements for native addons
 
@@ -42,7 +38,7 @@ If your Node module is a native addon or has a native addon somewhere in its dep
 depends_on "python" => :build
 ```
 
-Also note that such a formula would only be compatible with the same Node major version it originally was compiled with. This means that we need to revision every formula with a Node native addon with every major version bump of the `node` formula. To make sure we don't overlook your formula on a Node major version bump, write a meaningful test which would fail in such a case (invoked with an ABI-incompatible Node version).
+Also note that such a formula would only be compatible with the same Node major version it originally was compiled with. This means that we need to revision every formula with a Node native addon with every major version bump of the `node` formula. To make sure we don't overlook your formula on a Node major version bump, write a meaningful test which would fail in such a case (being invoked with an ABI-incompatible Node version).
 
 ## Installation
 
@@ -50,65 +46,58 @@ Node modules should be installed to `libexec`. This prevents the Node modules fr
 
 In the following we distinguish between two types of Node modules installed using formulae:
 
-* formulae for standard Node modules compatible with npm's global module format which should use [`std_npm_install_args`](#installing-global-style-modules-with-std_npm_install_args-to-libexec) (like [`azure-cli`](https://github.com/Homebrew/homebrew-core/blob/0f3b27d252b8112c744e0460d871cfe1def6b993/Formula/azure-cli.rb) or [`webpack`](https://github.com/Homebrew/homebrew-core/blob/6282879973d569962e63da7c81ac4623e1a8336b/Formula/webpack.rb))
-* formulae where the `npm install` call is not the only required install step (e.g. need to also compile non-JavaScript sources) which have to use [`local_npm_install_args`](#installing-module-dependencies-locally-with-local_npm_install_args) (like [`elixirscript`](https://github.com/Homebrew/homebrew-core/blob/4bb491b7b246830aed57b97348a17e9401374978/Formula/elixirscript.rb) or [`grunt-cli`](https://github.com/Homebrew/homebrew-core/blob/93be1840908adb2f9ee8c48c66586ee6327480e3/Formula/grunt-cli.rb))
+- formulae for standard Node modules compatible with npm's global module format which should use [`std_npm_args`](#installing-global-style-modules-with-std_npm_args-to-libexec) (like [`angular-cli`](https://github.com/Homebrew/homebrew-core/blob/master/Formula/a/angular-cli.rb) or [`webpack`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/w/webpack.rb))
+- formulae where the `npm install` call is not the only required install step (e.g. need to also compile non-JavaScript sources) which have to use [`std_npm_args`](#installing-module-dependencies-locally-with-std_npm_args) (like [`emscripten`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/e/emscripten.rb) or [`grunt-cli`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/g/grunt-cli.rb))
 
 What both methods have in common is that they are setting the correct environment for using npm inside Homebrew and are returning the arguments for invoking `npm install` for their specific use cases. This includes fixing an important edge case with the npm cache (caused by Homebrew's redirection of `HOME` during the build and test process) by using our own custom `npm_cache` inside `HOMEBREW_CACHE`, which would otherwise result in very long build times and high disk space usage.
 
-To use them you have to require the Node language module at the beginning of your formula file with:
-
-```ruby
-require "language/node"
-```
+### Installing global style modules with `std_npm_args` to `libexec`
 
-### Installing global style modules with `std_npm_install_args` to `libexec`
-
-In your formula's `install` method, simply `cd` to the top level of your Node module if necessary and then use `system` to invoke `npm install` with `Language::Node.std_npm_install_args` like:
+In your formula's `install` method, simply `cd` to the top level of your Node module if necessary and then use `system` to invoke `npm install` with `std_npm_args` like:
 
 ```ruby
-system "npm", "install", *Language::Node.std_npm_install_args(libexec)
+system "npm", "install", *std_npm_args
 ```
 
-This will install your Node module in npm's global module style with a custom prefix to `libexec`. All your modules' executables will be automatically resolved by npm into `libexec/bin` for you, which is not symlinked into Homebrew's prefix. We need to make sure these are installed. To do this we need to symlink all executables to `bin` with:
+This will install your Node module in npm's global module style with a custom prefix to `libexec`. All your modules' executables will be automatically resolved by npm into `libexec/bin` for you, which are not symlinked into Homebrew's prefix. To make sure these are installed, we need to symlink all executables to `bin` with:
 
 ```ruby
 bin.install_symlink Dir["#{libexec}/bin/*"]
 ```
 
-### Installing module dependencies locally with `local_npm_install_args`
+### Installing module dependencies locally with `std_npm_args`
 
-In your formula's `install` method, do any installation steps which need to be done before the `npm install` step and then `cd` to the top level of the included Node module. Then, use `system` with `Language::Node.local_npm_install_args` to invoke `npm install` like:
+In your formula's `install` method, do any installation steps which need to be done before the `npm install` step and then `cd` to the top level of the included Node module. Then, use `system` to invoke `npm install` with `std_npm_args(prefix: false)` like:
 
 ```ruby
-system "npm", "install", *Language::Node.local_npm_install_args
+system "npm", "install", *std_npm_args(prefix: false)
 ```
 
-This will install all of your Node modules dependencies to your local build path. You can now continue with your build steps and take care of the installation into the Homebrew `prefix` on your own, following the [general Homebrew formula instructions](Formula-Cookbook.md).
+This will install all of your Node modules' dependencies to your local build path. You can now continue with your build steps and handle the installation into the Homebrew prefix on your own, following the [general Homebrew formula instructions](Formula-Cookbook.md).
 
 ## Example
 
 Installing a standard Node module based formula would look like this:
 
 ```ruby
-require "language/node"
-
 class Foo < Formula
-  desc "..."
-  homepage "..."
+  desc "An example formula"
+  homepage "https://example.com"
   url "https://registry.npmjs.org/foo/-/foo-1.4.2.tgz"
-  sha256 "..."
+  sha256 "abc123abc123abc123abc123abc123abc123abc123abc123abc123abc123abc1"
 
   depends_on "node"
   # uncomment if there is a native addon inside the dependency tree
   # depends_on "python" => :build
 
   def install
-    system "npm", "install", *Language::Node.std_npm_install_args(libexec)
+    system "npm", "install", *std_npm_args
     bin.install_symlink Dir["#{libexec}/bin/*"]
   end
 
   test do
-    # add a meaningful test here
+    # add a meaningful test here, version isn't usually meaningful
+    assert_match version.to_s, shell_output("#{bin}/foo --version")
   end
 end
 ```
diff --git a/docs/Prose-Style-Guidelines.md b/docs/Prose-Style-Guidelines.md
index 5b2eabeec0789..77390e04e2274 100644
--- a/docs/Prose-Style-Guidelines.md
+++ b/docs/Prose-Style-Guidelines.md
@@ -1,6 +1,7 @@
+# Prose Style Guidelines
+
 <!-- vale off -->
 <!-- Disable vale linting for the whole of the style guide, because it contains deliberately bad examples. -->
-# Prose Style Guidelines
 
 This is a set of style and usage guidelines for Homebrew's prose documentation aimed at users, contributors, and maintainers (as opposed to executable computer code). It applies to documents like those in `docs` in the `Homebrew/brew` repository, announcement emails, and other communications with the Homebrew community.
 
@@ -18,7 +19,7 @@ Homebrew's audience includes users with a wide range of education and experience
 
 We strive for "correct" but not "fancy" usage. Think newspaper article, not academic paper.
 
-This is a set of guidelines to be applied using human judgement, not a set of hard and fast rules. It is like [The Economist's Style Guide](https://web.archive.org/web/20170830001125/https://www.economist.com/styleguide/introduction) or [Garner's Modern American Usage](https://en.wikipedia.org/wiki/Garner's_Modern_American_Usage). It is less like the [Ruby Style Guide](https://github.com/rubocop-hq/ruby-style-guide#the-ruby-style-guide). All guidelines here are open to interpretation and discussion. 100% conformance to these guidelines is *not* a goal.
+This is a set of guidelines to be applied using human judgement, not a set of hard and fast rules. It is like [The Economist's Style Guide](https://cdn.static-economist.com/sites/default/files/pdfs/style_guide_12.pdf) or [Garner's Modern American Usage](https://en.wikipedia.org/wiki/Garner's_Modern_American_Usage). It is less like the [Ruby Style Guide](https://github.com/rubocop-hq/ruby-style-guide#the-ruby-style-guide). All guidelines here are open to interpretation and discussion. 100% conformance to these guidelines is *not* a goal.
 
 The intent of this document is to help authors make decisions about clarity, style, and consistency. It is not to help settle arguments about who knows English better. Don't use this document to be a jerk.
 
diff --git a/docs/Python-for-Formula-Authors.md b/docs/Python-for-Formula-Authors.md
index 4fded0d11a0f2..8ff5048fe060e 100644
--- a/docs/Python-for-Formula-Authors.md
+++ b/docs/Python-for-Formula-Authors.md
@@ -2,33 +2,31 @@
 
 This document explains how to successfully use Python in a Homebrew formula.
 
-Homebrew draws a distinction between Python **applications** and Python **libraries**. The difference is that users generally do not care that applications are written in Python; it is unusual that a user would expect to be able to `import foo` after installing an application. Examples of applications are [`ansible`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/ansible.rb) and [`jrnl`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/jrnl.rb).
+Homebrew draws a distinction between Python **applications** and Python **libraries**. The difference is that users generally do not care that applications are written in Python; it is unusual that a user would expect to be able to `import foo` after installing an application. Examples of applications are [`ansible`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/a/ansible.rb) and [`jrnl`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/j/jrnl.rb).
 
-Python libraries exist to be imported by other Python modules; they are often dependencies of Python applications. They are usually no more than incidentally useful in a terminal. Examples of libraries are [`py2cairo`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/py2cairo.rb) and the bindings that are installed by [`protobuf`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/protobuf.rb).
+Python libraries exist to be imported by other Python modules; they are often dependencies of Python applications. They are usually no more than incidentally useful in a terminal. Examples of libraries are [`certifi`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/c/certifi.rb) and [`numpy`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/n/numpy.rb).
 
-Bindings are a special case of libraries that allow Python code to interact with a library or application implemented in another language.
+Bindings are a special case of libraries that allow Python code to interact with a library or application implemented in another language. An example is the Python bindings installed by [`libxml2`](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/lib/libxml2.rb).
 
-Homebrew is happy to accept applications that are built in Python, whether the apps are available from PyPI or not. Homebrew generally won't accept libraries that can be installed correctly with `pip install foo`. Bindings may be installed for packages that provide them, especially if equivalent functionality isn't available through pip.
+Homebrew is happy to accept applications that are built in Python, whether the apps are available from PyPI or not. Homebrew generally won't accept libraries that can be installed correctly with `pip install foo`. Bindings may be installed for packages that provide them, especially if equivalent functionality isn't available through pip. Similarly, libraries that have non-trivial amounts of native code and have a long compilation as a result can be good candidates. If in doubt, though: do not package libraries.
 
-Applications should unconditionally bundle all of their Python-language dependencies and libraries and should install any unsatisfied dependencies; these strategies are discussed in depth in the following sections.
+Applications should unconditionally bundle all their Python-language dependencies and libraries and should install any unsatisfied dependencies; these strategies are discussed in depth in the following sections.
 
 ## Applications
 
-### Python declarations
+### Python declarations for applications
 
-Formulae for apps that require Python 3 **should** declare an unconditional dependency on `"python@3.x"`. These apps **must** work with the current Homebrew Python 3.x formula.
+Formulae for apps that require Python 3 **must** declare an unconditional dependency on `"python@3.y"`. These apps **must** work with the current Homebrew Python 3.y formula.
 
-Applications that are compatible with Python 2 **should** use the Apple-provided system Python in `/usr/bin` on systems that provide Python 2.7. No explicit Python dependency is needed since `/usr/bin` is always in `PATH` for Homebrew formulae.
+### Installing applications
 
-### Installing
+Starting with Python@3.12, Homebrew follows [PEP 668](https://peps.python.org/pep-0668/#marking-an-interpreter-as-using-an-external-package-manager). Applications must be installed into a Python [virtual environment](https://docs.python.org/3/library/venv.html) rooted in `libexec`. This prevents the app's Python modules from contaminating the system `site-packages` and vice versa.
 
-Applications should be installed into a Python [virtualenv](https://virtualenv.pypa.io/en/stable/) environment rooted in `libexec`. This prevents the app's Python modules from contaminating the system site-packages and vice versa.
-
-All of the Python module dependencies of the application (and their dependencies, recursively) should be declared as `resource`s in the formula and installed into the virtualenv, as well. Each dependency should be explicitly specified; please do not rely on `setup.py` or `pip` to perform automatic dependency resolution, for the [reasons described here](Acceptable-Formulae.md#we-dont-like-install-scripts-that-download-unversioned-things).
+All the Python module dependencies of the application (and their dependencies, recursively) should be declared as [`resource`](https://rubydoc.brew.sh/Formula#resource-class_method)s in the formula and installed into the virtual environment as well. Each dependency should be explicitly specified; please do not rely on `setup.py` or `pip` to perform automatic dependency resolution, for the [reasons described here](Acceptable-Formulae.md#we-dont-like-install-scripts-that-download-unversioned-things).
 
 You can use `brew update-python-resources` to help you write resource stanzas. To use it, simply run `brew update-python-resources <formula>`. Sometimes, `brew update-python-resources` won't be able to automatically update the resources. If this happens, try running `brew update-python-resources --print-only <formula>` to print the resource stanzas instead of applying the changes directly to the file. You can then copy and paste resources as needed.
 
-If using `brew update-python-resources` doesn't work, you can use [homebrew-pypi-poet](https://pypi.python.org/pypi/homebrew-pypi-poet) to help you write resource stanzas. To use it, set up a virtualenv and install your package and all its dependencies. Then, `pip install homebrew-pypi-poet` into the same virtualenv. Running `poet some_package` will generate the necessary resource stanzas. You can do this like:
+If using `brew update-python-resources` doesn't work, you can use [homebrew-pypi-poet](https://github.com/tdsmith/homebrew-pypi-poet) to help you write resource stanzas. To use it, set up a virtual environment and install your package and all its dependencies. Then, `pip install homebrew-pypi-poet` into the same virtual environment. Running `poet some_package` will generate the necessary resource stanzas. You can do this like:
 
 ```sh
 # Use a temporary directory for the virtual environment
@@ -47,35 +45,54 @@ deactivate
 rm -rf venv
 ```
 
-Homebrew provides helper methods for instantiating and populating virtualenvs. You can use them by putting `include Language::Python::Virtualenv` at the top of the `Formula` class definition.
+Homebrew provides helper methods for instantiating and populating virtual environments. You can use them by putting `include Language::Python::Virtualenv` at the top of the `Formula` class definition.
 
 For most applications, all you will need to write is:
 
 ```ruby
-def install
-  virtualenv_install_with_resources
+class Foo < Formula
+  include Language::Python::Virtualenv
+
+  # ...
+  url "https://example.com/foo-1.0.tar.gz"
+  sha256 "abc123abc123abc123abc123abc123abc123abc123abc123abc123abc123abc1"
+
+  depends_on "python@3.y"
+
+  def install
+    virtualenv_install_with_resources
+  end
 end
 ```
 
 This is exactly the same as writing:
 
 ```ruby
-def install
-  # Create a virtualenv in `libexec`. If your app needs Python 3, make sure that
-  # `depends_on "python"` is declared, and use `virtualenv_create(libexec, "python3")`.
-  venv = virtualenv_create(libexec)
-  # Install all of the resources declared on the formula into the virtualenv.
-  venv.pip_install resources
-  # `pip_install_and_link` takes a look at the virtualenv's bin directory
-  # before and after installing its argument. New scripts will be symlinked
-  # into `bin`. `pip_install_and_link buildpath` will install the package
-  # that the formula points to, because buildpath is the location where the
-  # formula's tarball was unpacked.
-  venv.pip_install_and_link buildpath
+class Foo < Formula
+  include Language::Python::Virtualenv
+
+  # ...
+  url "https://example.com/foo-1.0.tar.gz"
+  sha256 "abc123abc123abc123abc123abc123abc123abc123abc123abc123abc123abc1"
+
+  depends_on "python@3.y"
+
+  def install
+    # Create a virtualenv in `libexec`.
+    venv = virtualenv_create(libexec, "python3.y")
+    # Install all of the resources declared on the formula into the virtualenv.
+    venv.pip_install resources
+    # `pip_install_and_link` takes a look at the virtualenv's bin directory
+    # before and after installing its argument. New scripts will be symlinked
+    # into `bin`. `pip_install_and_link buildpath` will install the package
+    # that the formula points to, because buildpath is the location where the
+    # formula's tarball was unpacked.
+    venv.pip_install_and_link buildpath
+  end
 end
 ```
 
-### Example
+### Example formula
 
 Installing a formula with dependencies will look like this:
 
@@ -83,16 +100,18 @@ Installing a formula with dependencies will look like this:
 class Foo < Formula
   include Language::Python::Virtualenv
 
+  desc "Description"
+  homepage "https://example.com"
   url "..."
 
   resource "six" do
-    url "https://pypi.python.org/packages/source/s/six/six-1.9.0.tar.gz"
-    sha256 "e24052411fc4fbd1f672635537c3fc2330d9481b18c0317695b46259512c91d5"
+    url "https://files.pythonhosted.org/packages/71/39/171f1c67cd00715f190ba0b100d606d440a28c93c7714febeca8b79af85e/six-1.16.0.tar.gz"
+    sha256 "1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"
   end
 
   resource "parsedatetime" do
-    url "https://pypi.python.org/packages/source/p/parsedatetime/parsedatetime-1.4.tar.gz"
-    sha256 "09bfcd8f3c239c75e77b3ff05d782ab2c1aed0892f250ce2adf948d4308fe9dc"
+    url "https://files.pythonhosted.org/packages/a8/20/cb587f6672dbe585d101f590c3871d16e7aec5a576a1694997a3777312ac/parsedatetime-2.6.tar.gz"
+    sha256 "4cb368fbb18a0b7231f4d76119165451c8d2e35951455dfee97c62a87b04d455"
   end
 
   def install
@@ -104,12 +123,20 @@ end
 You can also use the more verbose form and request that specific resources be installed:
 
 ```ruby
-def install
-  venv = virtualenv_create(libexec)
-  %w[six parsedatetime].each do |r|
-    venv.pip_install resource(r)
+class Foo < Formula
+  include Language::Python::Virtualenv
+
+  desc "Description"
+  homepage "https://example.com"
+  url "..."
+
+  def install
+    venv = virtualenv_create(libexec)
+    %w[six parsedatetime].each do |r|
+      venv.pip_install resource(r)
+    end
+    venv.pip_install_and_link buildpath
   end
-  venv.pip_install_and_link buildpath
 end
 ```
 
@@ -117,11 +144,9 @@ in case you need to do different things for different resources.
 
 ## Bindings
 
-To add bindings for Python 3, please add `depends_on "python@3.x"` to work with the current Homebrew Python 3.x formula.
+To add bindings for Python 3, please add `depends_on "python@3.y"` to work with the current Homebrew Python 3.y formula.
 
-Build Python 2 bindings with the system Python by default (don't add an option) and they should be usable with any binary-compatible Python. If that isn't the case, it's an upstream bug; [here's some advice for resolving it](https://blog.tim-smith.us/2015/09/python-extension-modules-os-x/).
-
-### Dependencies
+### Dependencies for bindings
 
 Bindings should follow the same advice for Python module dependencies as libraries; see below for more.
 
@@ -130,66 +155,91 @@ Bindings should follow the same advice for Python module dependencies as librari
 If the bindings are installed by invoking a `setup.py`, do something like:
 
 ```ruby
-cd "source/python" do
-  system Formula["python@3.x"].opt_bin/"python3", *Language::Python.setup_install_args(prefix)
-end
+system "python3.y", "-m", "pip", "install", *std_pip_args(build_isolation: true), "./source/python"
 ```
 
-If the configure script takes a `--with-python` flag, it usually will not need extra help finding Python.
+#### Autotools
+
+If the configure script takes a `--with-python` flag, it usually will not need extra help finding Python. However, if there are multiple Python formulae in the dependency tree, it may need help finding the correct one.
 
 If the `configure` and `make` scripts do not want to install into the Cellar, sometimes you can:
 
 1. call `./configure --without-python` (or a similar named option)
-2. `cd` into the directory containing the Python bindings
-3. call `setup.py` with `system` and `Language::Python.setup_install_args` (as described above)
+1. call `pip` on the directory containing the Python bindings (as described above)
 
 Sometimes we have to edit a `Makefile` on-the-fly to use our prefix for the Python bindings using Homebrew's [`inreplace`](Formula-Cookbook.md#inreplace) helper method.
 
+#### CMake
+
+If `cmake` finds a different Python than the direct dependency, sometimes you can help it find the correct Python by setting one of the following variables with the `-D` option:
+
+* `Python3_EXECUTABLE` for the [`FindPython3`](https://cmake.org/cmake/help/latest/module/FindPython3.html) module
+* `Python_EXECUTABLE` for the [`FindPython`](https://cmake.org/cmake/help/latest/module/FindPython.html) module
+* `PYTHON_EXECUTABLE` for the [`FindPythonInterp`](https://cmake.org/cmake/help/latest/module/FindPythonInterp.html) module
+
+#### Meson
+
+As a side effect of Homebrew's symlink installation and the Python sysconfig patch, `meson` may be unable to automatically detect the Cellar directories to install Python bindings into. If the formula's `meson` build definition uses [`install_sources()`](https://mesonbuild.com/Python-module.html#install_sources) or similar methods, you can set `python.purelibdir` and/or `python.platlibdir` to override the default paths.
+
+If `meson` finds a different Python than the direct dependency and the formula's `meson` option definition file does not provide a user-settable option, then you will need to check how the Python executable is being detected. A common approach is the [`find_installation()`](https://mesonbuild.com/Python-module.html#find_installation) method which will behave differently based on what the `name_or_path` argument is set to.
+
 ## Libraries
 
-### Python declarations
+Remember: there are very limited cases for libraries (e.g. significant amounts of native code is compiled) so, if in doubt, do not package them.
+
+**We do not use the `python-` prefix for these kinds of formulae!**
+
+### Examples of allowed libraries in homebrew-core
+
+* `numpy`, `scipy`: long build time, complex build process
+
+* `cryptography`: builds with `rust`
+
+* `certifi`: patched formula to allow any Python-based formulae to leverage the brewed CA certs (see <https://github.com/orgs/Homebrew/discussions/4691>).
+
+### Python declarations for libraries
 
-Libraries built for Python 3 should include `depends_on "python@3.x"`, which will bottle against Homebrew's Python 3.x. Python 2.x libraries must function when they are installed against either the system Python or brewed Python.
+Libraries built for Python 3 must include `depends_on "python@3.y"`, which will bottle against Homebrew's Python 3.y.
 
-Python 2 libraries need a `uses_from_macos "python@2"` declaration; they will be built with the system Python, but should still be usable with any other Python 2.7. If this is not the case, it's an upstream bug; [here's some advice for resolving it](https://blog.tim-smith.us/2015/09/python-extension-modules-os-x/).
+### Installing libraries
 
-### Installing
+Libraries may be installed to `libexec` and added to `sys.path` by writing a `.pth` file (named like "homebrew-foo.pth") to the `prefix` site-packages. This simplifies the ensuing drama if pip is accidentally used to upgrade a Homebrew-installed package and prevents the accumulation of stale `.pyc` files in Homebrew's site-packages.
 
-Libraries may be installed to `libexec` and added to `sys.path` by writing a `.pth` file (named like "homebrew-foo.pth") to the `prefix` site-packages. This simplifies the ensuing drama if `pip` is accidentally used to upgrade a Homebrew-installed package and prevents the accumulation of stale .pyc files in Homebrew's site-packages.
+Most formulae presently just install to `prefix`. Any stale `.pyc` files are handled by `brew cleanup`.
 
-Most formulae presently just install to `prefix`.
+### Dependencies for libraries
 
-### Dependencies
+Library dependencies must be installed so that they are importable. To minimise the potential for linking conflicts, dependencies should be installed to `libexec/<vendor>` and added to `sys.path` by writing a second `.pth` file (named like "homebrew-foo-dependencies.pth") to the `prefix` site-packages.
 
-The dependencies of libraries must be installed so that they are importable. To minimise the potential for linking conflicts, dependencies should be installed to `libexec/<vendor>` and added to `sys.path` by writing a second `.pth` file (named like "homebrew-foo-dependencies.pth") to the `prefix` site-packages.
+Formulae with general Python library dependencies (e.g. `setuptools`, `six`) should not use this approach as it will contaminate the system `site-packages` with all libraries installed inside `libexec/<vendor>`.
 
 ## Further down the rabbit hole
 
 Additional commentary that explains why Homebrew does some of the things it does.
 
-### setuptools vs. distutils vs. pip
+### Setuptools vs. Distutils vs. pip
 
-Distutils is a module in the Python standard library that provides developers a basic package management API. Setuptools is a module distributed outside the standard library that extends distutils. It is a convention that Python packages provide a `setup.py` that calls the `setup()` function from either distutils or setuptools.
+Distutils was a module in the Python standard library that provided developers a basic package management API until its removal in Python 3.12. Setuptools is a module distributed outside the standard library that extends and replaces Distutils. It is a convention that Python packages provide a `setup.py` that calls the `setup()` function from either Distutils or Setuptools.
 
-Setuptools provides the `easy_install` command, which is an end-user package management tool that fetches and installs packages from PyPI, the Python Package Index. `pip` is another, newer end-user package management tool, which is also provided outside the standard library. While pip supplants `easy_install`, pip does not replace the other functionality of the setuptools module.
+Setuptools used to provide the `easy_install` command, which was an end-user package management tool that fetched and installed packages from PyPI, the Python Package Index. The `easy_install` console script was removed in Setuptools v52.0.0 and direct usage has been deprecated since v58.3.0. `pip` is another, newer end-user package management tool, which is also provided outside the standard library. While `pip` supplants `easy_install`, it does not replace the other functionality of the Setuptools module.
 
-Distutils and pip use a "flat" installation hierarchy that installs modules as individual files under site-packages while `easy_install` installs zipped eggs to site-packages instead.
+Distutils and pip use a "flat" installation hierarchy that installs modules as individual files under `site-packages` while `easy_install` installs zipped eggs to `site-packages` instead.
 
-Distribute (not to be confused with distutils) is an obsolete fork of setuptools. Distlib is a package maintained outside the standard library which is used by pip for some low-level packaging operations and is not relevant to most `setup.py` users.
+Distribute (not to be confused with Distutils) is an obsolete fork of Setuptools. Distlib is a package maintained outside the standard library which is used by pip for some low-level packaging operations and is not relevant to most `setup.py` users.
 
 ### Running `setup.py`
 
-In the event that a formula needs to interact with `setup.py` instead of calling `pip`, Homebrew provides a helper method, `Language::Python.setup_install_args`, which returns useful arguments for invoking `setup.py`. Your formula should use this instead of invoking `setup.py` explicitly. The syntax is:
+For when a formula needs to interact with `setup.py` instead of calling `pip`, Homebrew provides the helper method `Language::Python.setup_install_args` which returns useful arguments for invoking `setup.py`. Your formula should use this instead of invoking `setup.py` explicitly. The syntax is:
 
 ```ruby
-system Formula["python@3.x"].opt_bin/"python3", *Language::Python.setup_install_args(prefix)
+system Formula["python@3.y"].opt_bin/"python3.y", *Language::Python.setup_install_args(prefix)
 ```
 
 where `prefix` is the destination prefix (usually `libexec` or `prefix`).
 
 ### What is `--single-version-externally-managed`?
 
-`--single-version-externally-managed` ("SVEM") is a setuptools-only [argument to `setup.py install`](https://setuptools.readthedocs.io/en/latest/setuptools.html?#install-run-easy-install-or-old-style-installation). The primary effect of SVEM is to use distutils to perform the install instead of using setuptools' `easy_install`.
+`--single-version-externally-managed` ("SVEM") is a [Setuptools](https://setuptools.readthedocs.io/en/latest/setuptools.html)-only argument to `setup.py install`. The primary effect of SVEM is using Distutils to perform the install instead of Setuptools' `easy_install`.
 
 `easy_install` does a few things that we need to avoid:
 
@@ -197,18 +247,18 @@ where `prefix` is the destination prefix (usually `libexec` or `prefix`).
 * upgrades dependencies in `sys.path` in-place
 * writes `.pth` and `site.py` files which aren't useful for us and cause link conflicts
 
-Setuptools requires that SVEM is used in conjunction with `--record`, which provides a list of files that can later be used to uninstall the package. We don't need or want this because Homebrew can manage uninstallation but since setuptools demands it we comply. The Homebrew convention is to call the record file "installed.txt".
+Setuptools requires that SVEM be used in conjunction with `--record`, which provides a list of files that can later be used to uninstall the package. We don't need or want this because Homebrew can manage uninstallation, but since Setuptools demands it we comply. The Homebrew convention is to name the record file "installed.txt".
 
-Detecting whether a `setup.py` uses `setup()` from setuptools or distutils is difficult, but we always need to pass this flag to setuptools-based scripts. `pip` faces the same problem that we do and forces `setup()` to use the setuptools version by loading a shim around `setup.py` that imports setuptools before doing anything else. Since setuptools monkey-patches distutils and replaces its `setup` function, this provides a single, consistent interface. We have borrowed this code and use it in `Language::Python.setup_install_args`.
+Detecting whether a `setup.py` uses `setup()` from Setuptools or Distutils is difficult, but we always need to pass this flag to Setuptools-based scripts. `pip` faces the same problem that we do and forces `setup()` to use the Setuptools version by loading a shim around `setup.py` that imports Setuptools before doing anything else. Since Setuptools monkey-patches Distutils and replaces its `setup` function, this provides a single, consistent interface. We have borrowed this code and use it in `Language::Python.setup_install_args`.
 
 ### `--prefix` vs `--root`
 
-`setup.py` accepts a slightly bewildering array of installation options. The correct switch for Homebrew is `--prefix`, which automatically sets the `--install-foo` family of options using sane POSIX-y values.
+`setup.py` accepts a slightly bewildering array of installation options. The correct switch for Homebrew is `--prefix`, which automatically sets the `--install-foo` family of options with sane POSIX-y values.
 
-`--root` [is used](https://mail.python.org/pipermail/distutils-sig/2010-November/017099.html) when installing into a prefix that will not become part of the final installation location of the files, like when building a .rpm or binary distribution. When using a `setup.py`-based setuptools, `--root` has the side effect of activating `--single-version-externally-managed`. It is not safe to use `--root` with an empty `--prefix` because the `root` is removed from paths when byte-compiling modules.
+`--root` [is used](https://mail.python.org/pipermail/distutils-sig/2010-November/017099.html) when installing into a prefix that will not become part of the final installation location of the files, like when building a RPM or binary distribution. When using a `setup.py`-based Setuptools, `--root` has the side effect of activating `--single-version-externally-managed`. It is not safe to use `--root` with an empty `--prefix` because the `root` is removed from paths when byte-compiling modules.
 
-It is probably safe to use `--prefix` with `--root=/`, which should work with either setuptools or distutils-based `setup.py`'s but is kinda ugly.
+It is probably safe to use `--prefix` with `--root=/`, which should work with either Setuptools- or Distutils-based `setup.py`'s, but it's kinda ugly.
 
 ### `pip` vs. `setup.py`
 
-[PEP 453](https://legacy.python.org/dev/peps/pep-0453/#recommendations-for-downstream-distributors) makes a recommendation to downstream distributors (us) that sdist tarballs should be installed with `pip` instead of by invoking `setup.py` directly. We do not do this because Apple's Python distribution does not include pip, so we can't assume that pip is available. We could do something clever to work around Apple's piplessness but the value proposition is not yet clear.
+[PEP 453](https://legacy.python.org/dev/peps/pep-0453/#recommendations-for-downstream-distributors) makes a recommendation to downstream distributors (us) that sdist tarballs should be installed with `pip` instead of by invoking `setup.py` directly. For historical reasons we did not follow PEP 453, so some formulae still use `setup.py` installs. Nowadays, most core formulae use `pip` as we have migrated them to this preferred method of installation.
diff --git a/docs/Querying-Brew.md b/docs/Querying-Brew.md
index 32ef43516d2d8..135cf103bed11 100644
--- a/docs/Querying-Brew.md
+++ b/docs/Querying-Brew.md
@@ -32,12 +32,6 @@ brew info --json=v1 tig | jq .
 
 To show full JSON information about all installed formulae:
 
-```sh
-brew info --json=v1 --all | jq "map(select(.installed != []))"
-```
-
-You'll note that processing all formulae can be slow; it's quicker to let `brew` do this:
-
 ```sh
 brew info --json=v1 --installed
 ```
diff --git a/docs/README.md b/docs/README.md
index af11b6e8f51d3..0e915d7c48592 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,77 +1,17 @@
-# Documentation
+# Homebrew Docs
 
-## Users
+These are the source files for the [Homebrew documentation site](https://docs.brew.sh/).
 
-- [`brew` man-page (command documentation)](Manpage.md)
-- [Homebrew Blog (news on major updates)](https://brew.sh/blog/)
-- [Troubleshooting](Troubleshooting.md)
-- [Installation](Installation.md)
-- [Frequently Asked Questions](FAQ.md)
-- [Common Issues](Common-Issues.md)
-- [`brew` Shell Completion](Shell-Completion.md)
-- [Homebrew on Linux](Homebrew-on-Linux.md)
+A [GitHub Action](https://github.com/Homebrew/brew/blob/master/.github/workflows/docs.yml) is run to validate each change before the site is deployed to GitHub Pages.
 
-- [Tips and Tricks](Tips-N'-Tricks.md)
-- [Bottles (binary packages)](Bottles.md)
-- [Taps (third-party repositories)](Taps.md)
-- [Interesting Taps and Forks](Interesting-Taps-and-Forks.md)
-- [Anonymous Aggregate User Behaviour Analytics](Analytics.md)
+## Usage
 
-- [Querying `brew`](Querying-Brew.md)
-- [C++ Standard Libraries](C++-Standard-Libraries.md)
-- [MD5 and SHA-1 Deprecation](Checksum_Deprecation.md)
-- [Custom GCC and Cross Compilers](Custom-GCC-and-cross-compilers.md)
-- [External Commands](External-Commands.md)
-- [Ruby Gems, Python Eggs and Perl Modules](Gems,-Eggs-and-Perl-Modules.md)
-- [Python](Homebrew-and-Python.md)
-- [How To Build Software Outside Homebrew With Homebrew `keg_only` dependencies](How-to-Build-Software-Outside-Homebrew-with-Homebrew-keg-only-Dependencies.md)
-- [Xcode](Xcode.md)
+Open <https://docs.brew.sh> in your web browser.
 
-- [Creating a Homebrew Issue](Creating-a-Homebrew-Issue.md)
-- [Updating Software in Homebrew](Updating-Software-in-Homebrew.md)
-- [Adding Software to Homebrew](Adding-Software-to-Homebrew.md)
+To instead generate the site locally to <http://localhost:4000>, run:
 
-- [Kickstarter Supporters](Kickstarter-Supporters.md)
-
-## Contributors
-
-- [How To Open A Pull Request (and get it merged)](How-To-Open-a-Homebrew-Pull-Request.md)
-- [Formula Cookbook](Formula-Cookbook.md)
-- [Cask Cookbook](Cask-Cookbook.md)
-- [Acceptable Formulae](Acceptable-Formulae.md)
-- [Acceptable Casks](Acceptable-Casks.md)
-- [License Guidelines](License-Guidelines.md)
-- [Formulae Versions](Versions.md)
-- [Deprecating, Disabling, and Removing Formulae](Deprecating-Disabling-and-Removing-Formulae.md)
-- [Node for Formula Authors](Node-for-Formula-Authors.md)
-- [Python for Formula Authors](Python-for-Formula-Authors.md)
-- [`brew livecheck`](Brew-Livecheck.md)
-- [Migrating A Formula To A Tap](Migrating-A-Formula-To-A-Tap.md)
-- [Rename A Formula](Rename-A-Formula.md)
-- [Building Against Non-Homebrew Dependencies](Building-Against-Non-Homebrew-Dependencies.md)
-- [How To Create (And Maintain) A Tap](How-to-Create-and-Maintain-a-Tap.md)
-- [Brew Test Bot](Brew-Test-Bot.md)
-- [Diagram Guidelines](Diagram-Guidelines.md)
-- [Prose Style Guidelines](Prose-Style-Guidelines.md)
-- [Type Checking with Sorbet](Typechecking.md)
-
-## Maintainers
-
-- [New Maintainer Checklist](New-Maintainer-Checklist.md)
-- [Maintainers: Avoiding Burnout](Maintainers-Avoiding-Burnout.md)
-
-- [Maintainer Guidelines](Maintainer-Guidelines.md)
-- [Homebrew/brew Maintainer Guide](Homebrew-brew-Maintainer-Guide.md)
-- [Homebrew/homebrew-core Maintainer Guide](Homebrew-homebrew-core-Maintainer-Guide.md)
-- [Homebrew/homebrew-cask Maintainer Guide](Homebrew-homebrew-cask-Maintainer-Guide.md)
-
-- [Brew Test Bot For Maintainers](Brew-Test-Bot-For-Core-Contributors.md)
-- [Common Issues for Maintainers](Common-Issues-for-Core-Contributors.md)
-- [Releases](Releases.md)
-- [Developer/Internal API Documentation](https://rubydoc.brew.sh)
-
-## Governance
-
-- [Homebrew Governance](Homebrew-Governance.md)
-- [Homebrew Leadership Responsibilities](Homebrew-Leadership-Responsibilities.md)
-- [Homebrew Governance Archives](Homebrew-Governance-Archives.md)
+```bash
+cd `brew --repository`/docs
+bundle install
+bundle exec jekyll serve --watch
+```
diff --git a/docs/Rakefile b/docs/Rakefile
index 042dfa64d1b8e..4d76f69297f90 100644
--- a/docs/Rakefile
+++ b/docs/Rakefile
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rake"
 
 task default: :build
@@ -8,8 +10,8 @@ task :build do
 end
 
 desc "Run Markdownlint to validate the Markdown style."
-task lint: :build do
-  sh "mdl", "."
+task :lint do
+  sh "mdl $(git ls-files '*.md' | grep -v 'Manpage.md')"
 end
 
 desc "Run HTMLProofer to validate the HTML output."
@@ -17,21 +19,27 @@ task test: :build do
   require "html-proofer"
   HTMLProofer.check_directory(
     "./_site",
-    parallel: { in_threads: 4 },
-    favicon: true,
-    http_status_ignore: [0, 403],
-    assume_extension: true,
-    check_favicon: true,
-    check_opengraph: true,
-    check_html: true,
-    check_img_http: true,
-    enforce_https: true,
-    file_ignore: [
-      %r{Kickstarter-Supporters},
+    parallel:            { in_threads: 4 },
+    favicon:             true,
+    ignore_status_codes: [0, 403],
+    check_favicon:       true,
+    check_opengraph:     true,
+    check_html:          true,
+    check_img_http:      true,
+    enforce_https:       true,
+    ignore_files:        [
+      /Kickstarter-Supporters/,
+    ],
+    ignore_urls:         [
+      "/",
+      %r{https://formulae.brew.sh"},
+      %r{https://github.com/},
+      "https://legacy.python.org/dev/peps/pep-0453/#recommendations-for-downstream-distributors",
     ],
-    url_ignore: [
-      "http://formulae.brew.sh",
-      %r{https://github.com/Homebrew/brew/edit/gh-pages//},
-    ]
+    cache:               {
+      timeframe: {
+        external: "1h",
+      },
+    },
   ).run
 end
diff --git a/docs/Releases.md b/docs/Releases.md
index b284b74f5394e..f0e5b523b95f3 100644
--- a/docs/Releases.md
+++ b/docs/Releases.md
@@ -1,48 +1,41 @@
 # Releases
 
-Since Homebrew 1.0.0 most Homebrew users (those who haven't run a `dev-cmd` or
-set `HOMEBREW_DEVELOPER=1` which is ~99.9% based on analytics data) require tags
-on the [Homebrew/brew repository](https://github.com/homebrew/brew)
-in order to get new versions of Homebrew. There are a few steps in making a new
-Homebrew release:
-
-1. Check the [Homebrew/brew pull requests](https://github.com/homebrew/brew/pulls),
-   [issues](https://github.com/homebrew/brew/issues),
-   [Homebrew/homebrew-core issues](https://github.com/homebrew/homebrew-core/issues) and
-   [Homebrew/discussions (forum)](https://github.com/homebrew/discussions/discussions) to see if there is
-   anything pressing that needs to be fixed or merged before the next release.
-   If so, fix and merge these changes.
-2. Ensure that no code changes have happened for at least a couple of hours (ideally 4 hours),
-   at least one Homebrew/homebrew-core pull request CI job has completed successfully,
-   checked the state of the Homebrew/brew `master` CI job (i.e. main jobs green or green after rerunning),
-   and that you are confident there are no major regressions on the current `master`,
-   branch.
-3. Run `brew release` to create a new draft release. For major or minor version bumps,
-   pass `--major` or `--minor`, respectively.
+Since Homebrew 1.0.0 most Homebrew users (those who haven't run a `dev-cmd` or set `HOMEBREW_DEVELOPER=1` which is ~99.9% based on analytics data) require tags on the [Homebrew/brew repository](https://github.com/homebrew/brew) in order to receive new versions of Homebrew. There are a few steps in making a new Homebrew release:
+
+1. Check if there is anything pressing that needs to be fixed or merged before the next release in:
+   - [`Homebrew/brew` pull requests](https://github.com/homebrew/brew/pulls)
+   - [`Homebrew/brew` issues](https://github.com/homebrew/brew/issues)
+   - [`Homebrew/homebrew-core` issues](https://github.com/homebrew/homebrew-core/issues)
+   - [Homebrew/discussions (forum)](https://github.com/orgs/Homebrew/discussions)
+
+    If so, fix and merge these changes.
+
+2. Ensure that:
+   - no code changes have happened for at least a couple of hours (ideally 4 hours),
+   - at least one Homebrew/homebrew-core pull request CI job has completed successfully,
+   - the state of the Homebrew/brew `master` CI job is clear (i.e. main jobs green or green after rerunning)
+   - you are confident there are no major regressions on the current `master` branch.
+
+3. Run `brew release` to create a new draft release. For major or minor version bumps, pass `--major` or `--minor`, respectively.
+
 4. Publish the draft release on [GitHub](https://github.com/Homebrew/brew/releases).
 
 If this is a major or minor release (e.g. X.0.0 or X.Y.0) then there are a few more steps:
 
-1. Before creating the tag you should delete any `odisabled` code, make any
-   `odeprecated` code `odisabled`, uncomment any `# odeprecated` code and add
-   any new `odeprecations` that are desired. Also delete any command argument
-   definitions that pass `replacement: ...`.
-2. Write up a release notes blog post to <https://brew.sh>
-   e.g. [brew.sh#319](https://github.com/Homebrew/brew.sh/pull/319).
-   This should use the output from `brew release [--major|--minor]` as input but
-   have the wording adjusted to be more human readable and explain not just what has changed but why.
-3. When the release has shipped and the blog post has been merged, tweet the
-   blog post as the [@MacHomebrew Twitter account](https://twitter.com/MacHomebrew)
-   or tweet it yourself and retweet it with the @MacHomebrew Twitter account
-   (credentials are in 1Password).
-4. Consider whether to submit it to other sources e.g. Hacker News, Reddit.
-  - Pros: gets a wider reach and user feedback
-  - Cons: negative comments are common and people take this as a chance to
-          complain about Homebrew (regardless of their usage)
-
-Please do not manually create a release based on older commits on the `master` branch.
-It's very hard to judge whether these have been sufficiently tested by users or if they will
-cause negative side-effects with the current state of Homebrew/homebrew-core.
-If a new branch is needed ASAP but there are things on `master` that cannot be released yet
-(e.g. new deprecations and you want to make a patch release) then revert the relevant PRs,
-follow the process above and then revert the reverted PRs to reapply them on `master`.
+1. Before creating the tag you should:
+   - delete any `odisabled` code,
+   - make any `odeprecated` code `odisabled`,
+   - uncomment any `# odeprecated` code
+   - add any new `odeprecations` that are desired.
+
+   Also delete any command argument definitions that pass `replacement: ...`.
+
+2. Write up a release notes blog post for <https://brew.sh> (e.g. [brew.sh#319](https://github.com/Homebrew/brew.sh/pull/319)). This should use the output from `brew release [--major|--minor]` as input but have the wording adjusted to be more human readable and explain not just what has changed but why.
+
+3. When the release has shipped and the blog post has been merged, tweet the blog post as the [@MacHomebrew Twitter account](https://twitter.com/MacHomebrew) or tweet it yourself and retweet it with the @MacHomebrew Twitter account (credentials are in 1Password).
+
+4. Consider whether to submit it to other sources, e.g. Hacker News, Reddit.
+   - Pros: gets a wider reach and user feedback
+   - Cons: negative comments are common and people take this as a chance to complain about Homebrew (regardless of their usage)
+
+Please do not manually create a release based on older commits on the `master` branch. It's very hard to judge whether these have been sufficiently tested by users or if they will cause negative side effects with the current state of Homebrew/homebrew-core. If a new branch is needed ASAP but there are things on `master` that cannot be released yet (e.g. new deprecations and you want to make a patch release) then revert the relevant PRs, follow the process above and then revert the reverted PRs to reapply them on `master`.
diff --git a/docs/Rename-A-Formula.md b/docs/Rename-A-Formula.md
index b117f46116df5..1bdc2806fc733 100644
--- a/docs/Rename-A-Formula.md
+++ b/docs/Rename-A-Formula.md
@@ -1,11 +1,10 @@
 # Renaming a Formula
 
-Sometimes software and formulae need to be renamed. To rename a formula
-you need to:
+Sometimes software and formulae need to be renamed. To rename a formula you need to:
 
-1. Rename the formula file and its class to a new formula. The new name must meet all the usual rules of formula naming. Fix any test failures that may occur due to the stricter requirements for new formulae than existing formulae (i.e. `brew audit --online --new-formula` must pass for that formula).
+1. Rename the formula file and its class to a new formula name. The new name must meet all the usual rules of formula naming. Fix any test failures that may occur due to the stricter requirements for new formulae compared to existing formulae (e.g. `brew audit --strict` must pass for that formula).
 
-2. Create a pull request to the corresponding tap deleting the old formula file, adding the new formula file, and adding it to `formula_renames.json` with a commit message like `newack: renamed from ack`. Use the canonical name (e.g. `ack` instead of `user/repo/ack`).
+2. Create a pull request on the corresponding tap deleting the old formula file, adding the new formula file, and adding it to `formula_renames.json` with a commit message like `newack: renamed from ack`. Use the canonical name (e.g. `ack` instead of `user/repo/ack`).
 
 A `formula_renames.json` example for a formula rename:
 
diff --git a/docs/Reproducible-Builds.md b/docs/Reproducible-Builds.md
new file mode 100644
index 0000000000000..588cbe160ceea
--- /dev/null
+++ b/docs/Reproducible-Builds.md
@@ -0,0 +1,50 @@
+# Reproducible Builds
+
+The Homebrew build environment is designed with [reproducible builds](https://reproducible-builds.org) as a goal where possible. Some convenience tools are also available to formula authors to help achieve deterministic builds.
+
+## Build time
+
+Some build tools embed or record the time at which the build occurs. This can cause build artifacts to differ between repeated builds of the same sources. To avoid this issue, the Homebrew build environment sets the [`SOURCE_DATE_EPOCH` environment variable](https://reproducible-builds.org/docs/source-date-epoch/) to the modification time of the source code for tools that consume it.
+
+In cases where a build time must be manually set, `time` is a Ruby `DateTime` object containing the same timestamp as the `SOURCE_DATE_EPOCH` environment variable. Methods provided by Ruby on `DateTime` objects can then be used to format this time into the desired format.
+
+```ruby
+def install
+  system "make", "install",
+         "VERSION=#{version}",
+         "DATE=#{time.iso8601}",
+         "PREFIX=#{prefix}"
+end
+```
+
+See the [`kustomize`](https://github.com/Homebrew/homebrew-core/blob/442f9cc511ce6dfe75b96b2c83749d90dde914d2/Formula/k/kustomize.rb#L32) formula for an example of using `time.iso8601` or the [`git-town`](https://github.com/Homebrew/homebrew-core/blob/442f9cc511ce6dfe75b96b2c83749d90dde914d2/Formula/g/git-town.rb#L25) formula for an example of using `time.strftime` with custom format specifiers.
+
+## Reproducible gzip compression
+
+Some formulae may create gzip-compressed files during their build process (for example, compressing manpages or other data files). Build machines may provide different implementations of the `gzip` utility, and by default `gzip` will record the modification time of the file being compressed, which usually varies depending on the build time. Thus, relying on the build machine's `gzip` utility will usually result in non-reproducible outputs being part of the build.
+
+To avoid this issue, Homebrew provides the `Utils::Gzip.compress` helper function for situations where reproducible `gzip` compression is needed. This function accepts one or more paths to be compressed and places the compressed files next to the original with a `.gz` suffix, just like the `gzip` utility does. It also returns an array of `Pathname` objects which can be consumed by other methods.
+
+```ruby
+def install
+  system "make", "install"
+  man1.install Utils::Gzip.compress("mycommand.1")
+end
+```
+
+```ruby
+def install
+  system "make", "install"
+  (pkgshare/"data").install Utils::Gzip.compress(*Dir["#{buildpath}/path/to/some/folder/contents/*"])
+end
+```
+
+See the [`par` formula](https://github.com/Homebrew/homebrew-core/blob/442f9cc511ce6dfe75b96b2c83749d90dde914d2/Formula/p/par.rb#L30) for an example with a single file or the [`pari-elldata` formula](https://github.com/Homebrew/homebrew-core/blob/442f9cc511ce6dfe75b96b2c83749d90dde914d2/Formula/p/pari-elldata.rb#L28) for an example with multiple files.
+
+## Relocatability
+
+Some formulae or build tools record paths specific to the build environment in configuration files or in binaries. When building redistributable bottles, Homebrew searches through the built files and replaces paths to common Homebrew locations, such as the Homebrew prefix and the Cellar, with a placeholder like `@@HOMEBREW_PREFIX@@` or `@@HOMEBREW_CELLAR@@`. When bottles are installed, Homebrew expands these placeholders to the respective paths on the end user's machine.
+
+This allows for some bottles to be used by users that may have Homebrew installed in a non-default prefix. It also results in bit-for-bit identical bottles between platforms where the location of Homebrew is the only difference.
+
+This search and replace process occurs automatically and does not require any additional action from formula authors to use it.
diff --git a/docs/Shell-Completion.md b/docs/Shell-Completion.md
index 07ffd3e1b1574..2f0ee2bd5dbd8 100644
--- a/docs/Shell-Completion.md
+++ b/docs/Shell-Completion.md
@@ -1,4 +1,4 @@
-# Homebrew Shell Completion
+# `brew` Shell Completion
 
 Homebrew comes with completion definitions for the `brew` command. Some packages also provide completion definitions for their own programs.
 
@@ -34,23 +34,14 @@ If you are using Homebrew's `bash` as your shell (i.e. `bash` >= v4) you should
 
 ## Configuring Completions in `zsh`
 
-To make Homebrew's completions available in `zsh`, you must insert the Homebrew-managed `zsh/site-functions` path into your `FPATH` before initialising `zsh`'s completion facility. Add the following to your `~/.zshrc`:
+To make Homebrew's completions available in `zsh`, the Homebrew-managed `zsh/site-functions` path needs to be inserted into `FPATH` before initialising `zsh`'s completion facility. This is done by `brew shellenv`, so if you followed the post-Homebrew installation steps, `eval "$(brew shellenv)"` should be in your `~/.zprofile` (on macOS) or `~/.zshrc` (on Linux). All you need is add the following to your `~/.zshrc` if it's not already there, and, if you're on Linux, make sure it's placed after `eval "$(brew shellenv)"`:
 
 ```sh
-if type brew &>/dev/null
-then
-  FPATH="$(brew --prefix)/share/zsh/site-functions:${FPATH}"
-
-  autoload -Uz compinit
-  compinit
-fi
+autoload -Uz compinit
+compinit
 ```
 
-This must be done before `compinit` is called. Note that if you are using Oh My Zsh, it will call `compinit` for you, so this must be done before you call `oh-my-zsh.sh`. This may be done by appending the following line to your `~/.zprofile` after Homebrew's initialization, instead of modifying your `~/.zshrc` as above:
-
-```sh
-FPATH="$(brew --prefix)/share/zsh/site-functions:${FPATH}"
-```
+Note that if you are using Oh My Zsh, it will call `compinit` for you when you source `oh-my-zsh.sh`. In this case, make sure `eval "$(brew shellenv)"` is called before sourcing `oh-my-zsh.sh` if you're on Linux, and you should be all set without any additional configuration.
 
 You may also need to forcibly rebuild `zcompdump`:
 
@@ -72,10 +63,10 @@ If your `fish` is from somewhere else, add the following to your `~/.config/fish
 
 ```sh
 if test -d (brew --prefix)"/share/fish/completions"
-    set -gx fish_complete_path $fish_complete_path (brew --prefix)/share/fish/completions
+    set -p fish_complete_path (brew --prefix)/share/fish/completions
 end
 
 if test -d (brew --prefix)"/share/fish/vendor_completions.d"
-    set -gx fish_complete_path $fish_complete_path (brew --prefix)/share/fish/vendor_completions.d
+    set -p fish_complete_path (brew --prefix)/share/fish/vendor_completions.d
 end
 ```
diff --git a/docs/Taps.md b/docs/Taps.md
index c4f5db1c38c32..c56363932ffad 100644
--- a/docs/Taps.md
+++ b/docs/Taps.md
@@ -9,30 +9,25 @@ but the command isn't limited to any one location.
 * `brew tap` without arguments lists all currently tapped repositories. For
   example:
 
-  ```sh
+  ```console
   $ brew tap
   homebrew/cask
   homebrew/core
   petere/postgresql
   ```
 
-<!-- vale Homebrew.Terms = OFF -->
-<!-- The `terms` lint suggests changing "repo" to "repository". But we need the abbreviation in the tap syntax and URL example. -->
-
-* `brew tap <user/repo>` makes a clone of the repository at
-  _https://github.com/\<user>/homebrew-\<repo>_ into `$(brew --repository)/Library/Taps`.
+* `brew tap <user>/<repo>` makes a clone of the repository at
+  `https://github.com/<user>/homebrew-<repo>` into `$(brew --repository)/Library/Taps`.
   After that, `brew` will be able to work with those formulae as if they were in Homebrew's
   [homebrew/core](https://github.com/Homebrew/homebrew-core) canonical repository.
   You can install and uninstall them with `brew [un]install`, and the formulae are
   automatically updated when you run `brew update`. (See below for details
   about how `brew tap` handles the names of repositories.)
 
-<!-- vale Homebrew.Terms = ON -->
-
-* `brew tap <user/repo> <URL>` makes a clone of the repository at _URL_.
+* `brew tap <user>/<repo> <URL>` makes a clone of the repository at _URL_.
   Unlike the one-argument version, _URL_ is not assumed to be GitHub, and it
   doesn't have to be HTTP. Any location and any protocol that Git can handle is
-  fine, although non-GitHub taps require running `brew tap --force-auto-update <user/repo>`
+  fine, although non-GitHub taps require running `brew tap --force-auto-update <user>/<repo>`
   to enable automatic updating.
 
 * `brew tap --repair` migrates tapped formulae from a symlink-based to
diff --git a/docs/Tips-N'-Tricks.md b/docs/Tips-N'-Tricks.md
index fbe62ac1ad57b..3e82d455434d1 100644
--- a/docs/Tips-N'-Tricks.md
+++ b/docs/Tips-N'-Tricks.md
@@ -2,7 +2,7 @@
 
 ## Install previous versions of formulae
 
-Some formulae in `homebrew/core` are made available as [versioned formulae](Versions.md) using a special naming format, e.g. `gcc@7`. If the version you're looking for isn't available, consider using `brew extract`.
+Some formulae in `homebrew/core` are made available as [versioned formulae](Versions.md) using a special naming format, e.g. `gcc@9`. If the version you're looking for isn't available, consider using `brew extract`.
 
 ## Quickly remove something from Homebrew's prefix
 
@@ -39,7 +39,7 @@ brew install --only-dependencies <formula>
 
 ## Use the interactive Homebrew shell
 
-```sh
+```console
 $ brew irb
 ==> Interactive Homebrew Shell
 Example commands available with: `brew irb --examples`
@@ -65,8 +65,32 @@ The beer emoji can also be replaced with other character(s):
 export HOMEBREW_INSTALL_BADGE="☕️ 🐸"
 ```
 
+## Migrate a Homebrew installation to a new location
+
+Running `brew bundle dump` will record an installation to a `Brewfile` and `brew bundle install` will install from a `Brewfile`. See `brew bundle --help` for more details.
+
+## Appoint Homebrew Cask to manage a manually-installed app
+
+Run `brew install --cask` with the `--adopt` switch:
+
+```console
+$ brew install --cask --adopt textmate
+==> Downloading https://github.com/textmate/textmate/releases/download/v2.0.23/TextMate_2.0.23.tbz
+...
+==> Installing Cask textmate
+==> Adopting existing App at '/Applications/TextMate.app'
+==> Linking Binary 'mate' to '/opt/homebrew/bin/mate'
+🍺  textmate was successfully installed!
+```
+
 ## Editor plugins
 
+### Visual Studio Code
+
+- [Brewfile](https://marketplace.visualstudio.com/items?itemName=sharat.vscode-brewfile) adds Ruby syntax highlighting for [Homebrew Bundle](https://github.com/Homebrew/homebrew-bundle) `Brewfile`s.
+
+- [Brew Services](https://marketplace.visualstudio.com/items?itemName=beauallison.brew-services) is an extension for starting and stopping Homebrew services.
+
 ### Sublime Text
 
 - [Homebrew-formula-syntax](https://github.com/samueljohn/Homebrew-formula-syntax) can be installed with Package Control in Sublime Text 2/3, which adds highlighting for inline patches.
@@ -81,6 +105,19 @@ export HOMEBREW_INSTALL_BADGE="☕️ 🐸"
 
 - [pcmpl-homebrew](https://github.com/hiddenlotus/pcmpl-homebrew) provides completion for emacs shell-mode and eshell-mode.
 
-### Atom
+## macOS Terminal.app: Enable the "Open man Page" contextual menu item
+
+In the macOS Terminal, you can right-click on a command name (like `ls` or `tar`) and pop open its manpage in a new window by selecting "Open man Page".
+
+Terminal needs an extra hint on where to find manpages installed by Homebrew because it doesn't load normal dotfiles like `~/.bash_profile` or `~/.zshrc`.
 
-- [language-homebrew-formula](https://atom.io/packages/language-homebrew-formula) adds highlighting and diff support (with the [language-diff](https://atom.io/packages/language-diff) plugin).
+```sh
+sudo mkdir -p /usr/local/etc/man.d
+echo "MANPATH /opt/homebrew/share/man" | sudo tee -a /usr/local/etc/man.d/homebrew.man.conf
+```
+
+If you're using Homebrew on macOS Intel, you should also fix permissions afterwards with:
+
+```sh
+sudo chown -R "${USER}" /usr/local/etc
+```
diff --git a/docs/Troubleshooting.md b/docs/Troubleshooting.md
index 8914fb71d4b4a..399e0ff72f5f9 100644
--- a/docs/Troubleshooting.md
+++ b/docs/Troubleshooting.md
@@ -15,7 +15,7 @@ This document will help you check for common issues and make sure your issue has
   * [Homebrew/homebrew-cask issue tracker](https://github.com/Homebrew/homebrew-cask/issues) (casks)
   * [Homebrew/brew issue tracker](https://github.com/Homebrew/brew/issues) (`brew` itself)
 * If the formula or cask that has failed to install is part of a non-Homebrew tap, then check that tap's issue tracker instead.
-* Search the [Homebrew discussion forum](https://github.com/homebrew/discussions/discussions) or [Discourse archive](https://discourse.brew.sh/) to see if any discussions have started about the issue.
+* Search the [Homebrew discussion forum](https://github.com/orgs/Homebrew/discussions) or [Discourse archive](https://discourse.brew.sh/) to see if any discussions have started about the issue.
 
 ## Create an issue
 
@@ -26,6 +26,6 @@ If your problem hasn't been solved or reported, then create an issue:
   * If your have a non-formula problem: collect the output of `brew config` and `brew doctor`.
 
 1. Create a new issue on the issue tracker for [Homebrew/homebrew-core](https://github.com/Homebrew/homebrew-core/issues/new/choose), [Homebrew/homebrew-cask](https://github.com/Homebrew/homebrew-cask/issues/new/choose) or [Homebrew/brew](https://github.com/Homebrew/brew/issues/new/choose) and follow the instructions:
-  * Give your issue a descriptive title which includes the formula name (if applicable) and the version of macOS or Linux you are using. For example, if a formula fails to build, title your issue "\<formula> failed to build on \<platform>", where "\<formula>" is the name of the formula that failed to build, and "\<platform>" is the name and version of macOS or Linux you are using.
+  * Give your issue a descriptive title which includes the formula name (if applicable) and the version of macOS or Linux you are using. For example, if a formula fails to build, title your issue "\<formula> failed to build on \<platform>", where *\<formula>* is the name of the formula that failed to build, and *\<platform>* is the name and version of macOS or Linux you are using.
   * Include the URL provided by `brew gist-logs <formula>` (if applicable) plus links to any additional Gists you may have created.
   * Include the output of `brew config` and `brew doctor`.
diff --git a/docs/Typechecking.md b/docs/Typechecking.md
index f93d12613903d..1d724402c7f9f 100644
--- a/docs/Typechecking.md
+++ b/docs/Typechecking.md
@@ -1,25 +1,17 @@
 # Type Checking With Sorbet
 
-The majority of the code in Homebrew is written in Ruby which is a dynamic
-language. To avail the benefits of static type checking, we have set up
-Sorbet in our codebase which provides the benefits of static type checking
-to dynamic languages like Ruby.
+The majority of the code in Homebrew is written in Ruby which is a dynamic language. To avail the benefits of static type checking, we have set up Sorbet in our codebase which provides the benefits of static type checking to dynamic languages like Ruby.
 
-The [Sorbet Documentation] is a good place
-to get started if you want to dive deeper into Sorbet and it's abilities.
+The [Sorbet Documentation] is a good place to get started if you want to dive deeper into Sorbet and its abilities.
 
 ## Sorbet in the Homebrew Codebase
 
-### Inline Type Annotations
+### Inline type annotations
 
-To add type annotations to a class or module, we need to first extend it with
-the `T::Sig` module (read this as `Type::Signature`). This adds the `sig`
-method which is used to annotate method signatures. Here's a simple example:
+The `sig` method is used to annotate method signatures. Here's a simple example:
 
 ```ruby
 class MyClass
-  extend T::Sig
-
   sig { params(name: String).returns(String) }
   def my_method(name)
     "Hello, #{name}!"
@@ -27,103 +19,56 @@ class MyClass
 end
 ```
 
-With `params`, we specify that we have a parameter `name` which must be a
-`String` and with `returns`, we specify that this method always returns
-a `String`.
-
-For more information on how to express more complex types, refer to the
-official documentation:
+With `params` we specify that there is a parameter `name` which must be a `String`, and with `returns` we specify that this method always returns a `String`.
 
-  - [Method Signatures](https://sorbet.org/docs/sigs)
-  - [Class Types](https://sorbet.org/docs/class-types)
-  - [Nilable Types](https://sorbet.org/docs/nilable-types)
-  - [Union Types](https://sorbet.org/docs/union-types)
+For more information on how to express more complex types, refer to the official documentation:
 
-### Ruby Interface Files (`.rbi`)
+- [Method Signatures](https://sorbet.org/docs/sigs)
+- [Class Types](https://sorbet.org/docs/class-types)
+- [Nilable Types](https://sorbet.org/docs/nilable-types)
+- [Union Types](https://sorbet.org/docs/union-types)
 
-RBI files help Sorbet learn about constants, ancestors and methods
-defined in ways it doesn’t understand natively. We can also create a
-RBI file to help Sorbet understand dynamic definitions.
+### Ruby interface files (`.rbi`)
 
-Sometimes it is necessary to explicitly include the `Kernel` module in
-order for Sorbet to know that methods such as `puts` are available in
-a given context. This is mostly necessary for modules since they can
-be used in both `BasicObject`s (which don't include `Kernel`) and
-`Object`s (which include `Kernel` by default). In this case, it is
-necessary to create an `.rbi` file ([example]) since re-including the
-`Kernel` module in actual code can break things.
+[RBI files](https://sorbet.org/docs/rbi) help Sorbet learn about constants, ancestors and methods defined in ways it doesn’t understand natively. We can also create an RBI file to help Sorbet understand dynamic definitions. Some of these files are autogenerated (see the next section) and some are manually written ([example]).
 
-Read more about RBI files [here](https://sorbet.org/docs/rbi).
+There are also a very small number of files that Homebrew loads before sorbet-runtime, such as `utils/gems.rb`. Those files cannot have type signatures alongside the code itself, so RBI files are used there instead to retain static type checking.
 
-[example]: https://github.com/Homebrew/brew/blob/61b79318ed089b5010501e2cbf163fd8e48e2dfc/Library/Homebrew/global.rbi
+[example]: https://github.com/Homebrew/brew/blob/9d4000b15cb6ffa8c11f49372f7016d05aaa0851/Library/Homebrew/extend/ENV.rbi
 
-### The [`Library/Homebrew/sorbet`] Directory
+### The [`Library/Homebrew/sorbet`] directory
 
 [`Library/Homebrew/sorbet`]: https://github.com/Homebrew/brew/tree/master/Library/Homebrew/sorbet
 
-- The `rbi` directory contains all Ruby Interface (`.rbi`) files
-  auto-generated by running `brew typecheck --update`:
+- The `rbi` directory contains all Ruby Interface (`.rbi`) files auto-generated by running `brew typecheck --update`:
 
-  - RBI files for all gems are generated using
-    [Tapioca](https://github.com/Shopify/tapioca#tapioca).
-  - Definitions for dynamic code (i.e. meta-programming) are generated using
-    `srb rbi hidden-definitions`.
-  - Definitions for missing constants are generated using `srb rbi todo`.
+  - `gems`: RBI files for all gems are generated using [Tapioca](https://github.com/Shopify/tapioca#tapioca).
+  - `dsl`: RBI files autogenerated by our [Tapioca compilers](https://github.com/Homebrew/brew/tree/master/Library/Homebrew/sorbet/tapioca/compilers).
+  - `upstream.rbi`: This file is not auto-generated and is a manually written file that contains temporary workarounds for upstream Sorbet issues. This file is typically empty.
 
-- The `config` file is a newline-separated list of arguments to pass to
-  `srb tc`, the same as if they’d been passed at the command-line. Arguments
-  in the config file are always passed first, followed by arguments provided
-  on the command-line. We use it to ignore Gem directories which we do not
-  wish to type check.
+- The `config` file is a newline-separated list of arguments to pass to `srb tc`, the same as if they’d been passed on the command line. Arguments in the config file are always passed first, followed by arguments provided on the command line. We use it to ignore Gem directories which we do not wish to type check.
 
-- Every Ruby file in the codebase has a magic `# typed: <level>` comment at the
-  top, where `<level>` is one of [Sorbet's strictness levels], usually `false`,
-  `true` or `strict`. The `false` files only report errors related to the
-  syntax, constant resolution and correctness of the method signatures, but no
-  type errors. Our long-term goal is to move all `false` files to `true` and
-  start reporting type errors on those files as well. Therefore, when adding
-  new files, you should ideally mark it with `# typed: true` and work out any
-  resulting type errors.
+- Every Ruby file in the codebase has a magic `# typed: <level>` comment at the top, where `<level>` is one of [Sorbet's strictness levels], usually `false`, `true` or `strict`. The `false` files only report errors related to the syntax, constant resolution and correctness of the method signatures, but no type errors. Our long-term goal is to move all `false` files to `true` and start reporting type errors on those files as well. Therefore, when adding new files, you should ideally mark it with `# typed: true` and work out any resulting type errors.
 
-  [Sorbet's strictness levels]: https://sorbet.org/docs/static#file-level-granularity-strictness-levels
+[Sorbet's strictness levels]: https://sorbet.org/docs/static#file-level-granularity-strictness-levels
 
 ## Using `brew typecheck`
 
-When run without any arguments, `brew typecheck`, will run considering the strictness levels
-set in each of the individual Ruby files in the core Homebrew codebase. However, when
-it is run on a specific file or directory, more errors may show up since Sorbet
-cannot resolve constants defined outside the scope of the specified file. These
-problems can be solved with RBI files. Currently `brew typecheck` provides `--quiet`, `--file`,
-`--dir` and `--ignore` options but you can explore more options with `srb tc --help` and
-passing them with `srb tc`.
+When run without any arguments, `brew typecheck`, will run considering the strictness levels set in each of the individual Ruby files in the core Homebrew codebase. However, when it is run on a specific file or directory, more errors may show up since Sorbet cannot resolve constants defined outside the scope of the specified file. These problems can be solved with RBI files. Currently `brew typecheck` provides `--quiet`, `--file`, `--dir` and `--ignore` options but you can explore more options with `srb tc --help` and pass them with `srb tc`.
 
 ## Resolving Type Errors
 
-Sorbet reports type errors along with an error reference code, which can be used
-to look up more information on how to debug the error, or what causes the error in
-the [Sorbet Documentation]. Here is how to debug some common type errors:
-
-- Using `T.reveal_type`. In files which are `true` or higher, if we wrap a variable
-  or method call in `T.reveal_type`, Sorbet will show us what type it thinks that
-  variable has in the output of `srb tc`. This is particularly useful when writing
-  [method signatures](https://sorbet.org/docs/sigs) and debugging. Make sure to
-  remove this line from your code before committing your changes, since this is
-  just a debugging tool.
-
-- One of the most frequent errors that we've encountered is: `7003: Method does not exist.`
-  Since Ruby is a very dynamic language, methods can be defined in ways Sorbet cannot
-  see statically. In such cases, check if the method exists at runtime, if not, then
-  Sorbet has caught a future bug! But, it is also possible that even though a method
-  exists at runtime, Sorbet cannot see it. In such cases, we use
-  [`.rbi` files](#ruby-interface-files-rbi).
-
-- Since Sorbet does not automatically assume that Kernel is to be included in Modules,
-  we may encounter many errors while trying to use methods like `puts`, `ohai`, `odebug` et cetera.
-  A simple workaround for this would be to add an extra `include Kernel` line in the
-  respective RBI file.
-
-- The tips above are very generic and apply to lots of cases. For some common gotchas
-  when using Sorbet, refer to the [Sorbet Error Reference](https://sorbet.org/docs/error-reference)
-  and [FAQ](https://sorbet.org/docs/faq).
+Sorbet reports type errors along with an error reference code, which can be used to look up more information on how to debug the error, or what causes the error in the [Sorbet Documentation]. Here is how to debug some common type errors:
+
+- Using `T.reveal_type`: in files which are `true` or higher, by wrapping a variable or method call in `T.reveal_type`, Sorbet will show us what type it thinks that variable has in the output of `srb tc`. This is particularly useful when writing [method signatures](https://sorbet.org/docs/sigs) and debugging. Make sure to remove this line from your code before committing your changes, since this is just a debugging tool.
+
+- One of the most frequent errors that we've encountered is `7003: Method does not exist.` Since Ruby is a very dynamic language, methods can be defined in ways Sorbet cannot see statically. In such cases, check if the method exists at runtime; if not, then Sorbet has caught a future bug! But, it is also possible that even though a method exists at runtime, Sorbet cannot see it. In such cases, we use [`.rbi` files](#ruby-interface-files-rbi).
+
+- Since Sorbet does not automatically assume that Kernel is to be included in Modules, we may encounter many errors while trying to use methods like `puts`, `ohai`, `odebug` etc. There are generally two approaches to fixing this:
+
+  - If you are using `module_function` but never run `include ModuleName` anywhere, remove the `module_definition` and convert all methods to class methods (prepend the name with `self.`)
+  - If you do include the module elsewhere, add a `requires_ancestor` to the module defining what types of classes this module can be included in. This may be as simple as a `requires_ancestor { Kernel }`, which most classes are a descendant from.
+
+- The tips above are very generic and apply to lots of cases. For some common gotchas when using Sorbet, refer to the [Sorbet Error Reference](https://sorbet.org/docs/error-reference) and [FAQ](https://sorbet.org/docs/faq).
 
 [Sorbet Documentation]: https://sorbet.org/docs/overview
diff --git a/docs/Updating-Software-in-Homebrew.md b/docs/Updating-Software-in-Homebrew.md
index 43e067a42d86c..88dd253618ec2 100644
--- a/docs/Updating-Software-in-Homebrew.md
+++ b/docs/Updating-Software-in-Homebrew.md
@@ -4,9 +4,9 @@ Did you find something in Homebrew that wasn't the latest version? You can help
 
 First, check the pull requests in the Homebrew tap repositories to make sure a PR isn't already open. If you're submitting a [formula](Formula-Cookbook.md#homebrew-terminology), check [homebrew-core](https://github.com/Homebrew/homebrew-core/pulls). If you're submitting a [cask](Formula-Cookbook.md#homebrew-terminology), check [homebrew-cask](https://github.com/Homebrew/homebrew-cask/pulls). You may also want to look through closed pull requests in the repositories, as sometimes packages run into problems preventing them from being updated and it's better to be aware of any issues before putting significant effort into an update.
 
-The [How To Open a Homebrew Pull Request](How-To-Open-a-Homebrew-Pull-Request.md) documentation should explain most everything you need to know about the process of creating a PR for a version update. For simple updates, this typically involves changing the URL and SHA256 values.
+The [How to Open a Homebrew Pull Request](How-To-Open-a-Homebrew-Pull-Request.md) documentation should explain most everything you need to know about the process of creating a PR for a version update. For simple updates, this typically involves changing the `url` and `sha256` values.
 
-However, some updates require additional changes to the package. You can look back at previous pull requests to see how others have handled things in the past but be sure to look at a variety of PRs. Sometimes packages aren't updated properly, so you may need to use your judgment to determine how to best proceed.
+However, some updates require additional changes to the package. You can look back at previous pull requests to see how others have handled things in the past, but be sure to look at a variety of PRs. Sometimes packages aren't updated properly, so you may need to use your judgment to determine how best to proceed.
 
 Once you've created the pull request in the appropriate Homebrew repository your commit(s) will be tested on our continuous integration servers, showing a green check mark if everything passed or a red X if there were failures. Maintainers will review your pull request and provide feedback about any changes that need to be made before it can be merged.
 
diff --git a/docs/Versions.md b/docs/Versions.md
index 6cd410704dac8..fa887942704d7 100644
--- a/docs/Versions.md
+++ b/docs/Versions.md
@@ -1,26 +1,33 @@
-# Versions
+# Formulae Versions
 
-[homebrew/core](https://github.com/homebrew/homebrew-core) supports multiple versions of formulae with a special naming format. For example, the formula for GCC 6 is named `gcc@6.rb` and begins with `class GccAT6 < Formula`.
+[homebrew/core](https://github.com/homebrew/homebrew-core) supports multiple versions of formulae by using a special naming format. For example, the formula for GCC 9 is named `gcc@9.rb` and begins with `class GccAT9 < Formula`.
 
 ## Acceptable versioned formulae
+
 Versioned formulae we include in [homebrew/core](https://github.com/homebrew/homebrew-core) must meet the following standards:
 
-* Versioned software should build on all Homebrew's supported versions of macOS.
+* Versioned software should build on all of Homebrew's supported versions of macOS.
 * Versioned formulae should differ in major/minor (not patch) versions from the current stable release. This is because patch versions indicate bug or security updates, and we want to ensure you apply security updates.
 * Unstable versions (alpha, beta, development versions) are not acceptable for versioned (or unversioned) formulae.
 * Upstream should have a release branch for each formula version, and have an explicit policy of releasing security updates for each version when necessary. For example, [PHP 7.0 was not a supported version but PHP 7.2 was](https://php.net/supported-versions.php) in January 2020. By contrast, most software projects are structured to only release security updates for their latest versions, so their earlier versions are not eligible for versioning.
 * Versioned formulae should share a codebase with the main formula. If the project is split into a different repository, we recommend creating a new formula (`formula2` rather than `formula@2` or `formula@1`).
 * Formulae that depend on versioned formulae must not depend on the same formulae at two different versions twice in their recursive dependencies. For example, if you depend on `openssl@1.0` and `foo`, and `foo` depends on `openssl` then you must instead use `openssl`.
-* Versioned formulae should only be linkable at the same time as their non-versioned counterpart if the upstream project provides support for it, e.g. using suffixed binaries. If this is not possible, use `keg_only :versioned_formula` to allow users to have multiple versions installed at once.
+* Versioned formulae should only be linkable at the same time as their non-versioned counterpart if the upstream project provides support for it, e.g. by using suffixed binaries. If this is not possible, use `keg_only :versioned_formula` to allow users to have multiple versions installed at once.
 * A `keg_only :versioned_formula` should not `post_install` anything in the `HOMEBREW_PREFIX` that conflicts with or duplicates the main counterpart (or other versioned formulae). For example, a `node@6` formula should not install its `npm` into `HOMEBREW_PREFIX` like the `node` formula does.
-* Versioned formulae submitted should be expected to be used by a large number of people. If this ceases to be the case, they will be removed. We will aim not to remove those in the [top 3,000 `install_on_request` formulae](https://brew.sh/analytics/install-on-request/).
+* Submitted versioned formulae should be expected to be used by a large number of people. If this ceases to be the case, they will be removed. We will aim not to remove those in the [top 3,000 `install_on_request` formulae](https://brew.sh/analytics/install-on-request/).
 * Versioned formulae should not have `resource`s that require security updates. For example, a `node@6` formula should not have an `npm` resource but instead rely on the `npm` provided by the upstream tarball.
 * Versioned formulae should be as similar as possible and sensible compared to the main formulae. Creating or updating a versioned formula should be a chance to ask questions of the main formula and vice versa, e.g. can some unused or useless options be removed or made default?
-* No more than five versions of a formula (including the main one) will be supported at any given time, regardless of usage. When removing formulae that violate this, we will aim to do so based on usage and support status rather than age.
-* Versioned formulae must be ABI stable for the lifetime of the version branch. Updates to the versioned formula must not introduce ABI incompatibilities or otherwise require dependents to be revision bumped. In practice, this means that their dependents should never need `revision` bumps to be rebuilt against newer versions. Version updates which violate this should be rejected and the formula be deprecated from that point onwards.
+* No more than five versions of a formula (including the main one) will be supported at any given time, unless they are popular (e.g. have over 1000 [analytics 90 days installs](https://formulae.brew.sh/analytics/install/90d/) of usage). When removing formulae that violate this, we will aim to do so based on usage and support status rather than age.
+* Versioned formulae must be ABI-stable for the lifetime of the version branch. Updates to the versioned formula must not introduce ABI incompatibilities or otherwise require dependents to be revision bumped. In practice, this means that their dependents should never need `revision` bumps to be rebuilt against newer versions. Version updates which violate this should be rejected and the formula be deprecated from that point onwards.
+
+Homebrew's versions should not be used to "pin" formulae to your personal requirements. You should instead [create your own tap](How-to-Create-and-Maintain-a-Tap.md) for formulae you or your organisation wish to control the versioning of, or those that do not meet the above standards. Software that has regular API or ABI breaking releases still needs to meet all the above requirements; that a `brew upgrade` has broken something for you is not an argument for us to add and maintain a formula for you.
+
+If there is a formula that currently exists in the Homebrew/homebrew-core repository or has existed in the past (i.e. was migrated or deleted), you can recover it for your own use with the `brew extract` command. This will copy the desired version of the formula into a custom tap. For example, if your project depends on `automake` 1.12 instead of the most recent version, you can obtain the `automake` formula at version 1.12 by running:
 
-Homebrew's versions should not be used to "pin" formulae to your personal requirements. You should instead create your own [tap](How-to-Create-and-Maintain-a-Tap.md) for formulae you or your organisation wish to control the versioning of, or those that do not meet the above standards. Software that has regular API or ABI breaking releases still needs to meet all the above requirements; that a `brew upgrade` has broken something for you is not an argument for us to add and maintain a formula for you.
+```sh
+brew extract automake --version=1.12 <YOUR_GITHUB_USER>/<YOUR_TAP_REPOSITORY_NAME>
+```
 
-If there is a formula that currently exists in the Homebrew/homebrew-core repository or has existed in the past (i.e. was migrated or deleted), you can recover it for your own use with the `brew extract` command. This will copy the desired version of the formula into a custom tap. For example, if your project depends on `automake` 1.12 instead of the most recent version, you can obtain the `automake` formula at version 1.12 by running `brew extract automake <YOUR_GITHUB_USER>/<YOUR_TAP_REPOSITORY_NAME> --version=1.12`. Formulae obtained this way may contain deprecated, disabled or removed Homebrew syntax (e.g. checksums may be `sha1` instead of `sha256`); the `brew extract` command does not edit or update formulae to meet current standards and style requirements.
+Formulae obtained this way may contain deprecated, disabled or removed Homebrew syntax (e.g. checksums may be `sha1` instead of `sha256`); the `brew extract` command does not edit or update formulae to meet current standards and style requirements.
 
 We may temporarily add versioned formulae for our own needs that do not meet these standards in [homebrew/core](https://github.com/homebrew/homebrew-core). The presence of a versioned formula there does not imply it will be maintained indefinitely or that we are willing to accept any more versions that do not meet the requirements above.
diff --git a/docs/_config.yml b/docs/_config.yml
index 6c947b4e37125..53e154f12970f 100644
--- a/docs/_config.yml
+++ b/docs/_config.yml
@@ -1,5 +1,5 @@
 title: Homebrew Documentation
-description: Documentation for the missing package manager for macOS.
+description: Documentation for the missing package manager for macOS (or Linux).
 
 remote_theme: Homebrew/brew.sh
 
@@ -11,7 +11,6 @@ exclude:
   - vendor
 
 plugins:
-  - jekyll-feed
   - jekyll-redirect-from
   - jekyll-remote-theme
   - jekyll-seo-tag
@@ -31,7 +30,10 @@ defaults:
     values:
       category: governance-archives
 
-logo: /assets/img/homebrew-256x256.png
+kramdown:
+  toc_levels: 2..3
+
+logo: /assets/img/homebrew.svg
 
 twitter:
   username: MacHomebrew
diff --git a/docs/assets/img/docs/analytics.png b/docs/assets/img/docs/analytics.png
deleted file mode 100644
index c7900cc42db31..0000000000000
Binary files a/docs/assets/img/docs/analytics.png and /dev/null differ
diff --git a/docs/assets/img/docs/brew-test-bot-failed-pr.png b/docs/assets/img/docs/brew-test-bot-failed-pr.png
index 97fbd6c67713b..f0f3e2ce1b107 100644
Binary files a/docs/assets/img/docs/brew-test-bot-failed-pr.png and b/docs/assets/img/docs/brew-test-bot-failed-pr.png differ
diff --git a/docs/assets/img/docs/brew-test-bot-passed-pr.png b/docs/assets/img/docs/brew-test-bot-passed-pr.png
index 3d3dd98c3674f..2c2543bc2ff30 100644
Binary files a/docs/assets/img/docs/brew-test-bot-passed-pr.png and b/docs/assets/img/docs/brew-test-bot-passed-pr.png differ
diff --git a/docs/assets/img/docs/brew-test-bot-triggered-pr.png b/docs/assets/img/docs/brew-test-bot-triggered-pr.png
index 9aafe62403141..6fc17df10770c 100644
Binary files a/docs/assets/img/docs/brew-test-bot-triggered-pr.png and b/docs/assets/img/docs/brew-test-bot-triggered-pr.png differ
diff --git a/docs/assets/img/docs/gatekeeper-unidentified-message.png b/docs/assets/img/docs/gatekeeper-unidentified-message.png
new file mode 100644
index 0000000000000..94833c329c4af
Binary files /dev/null and b/docs/assets/img/docs/gatekeeper-unidentified-message.png differ
diff --git a/docs/assets/img/docs/gatekeeper-unidentified-open.png b/docs/assets/img/docs/gatekeeper-unidentified-open.png
new file mode 100644
index 0000000000000..2c0e0f7eae724
Binary files /dev/null and b/docs/assets/img/docs/gatekeeper-unidentified-open.png differ
diff --git a/docs/assets/img/docs/managing-pull-requests.drawio.svg b/docs/assets/img/docs/managing-pull-requests.drawio.svg
deleted file mode 100644
index 978f5e8c2c531..0000000000000
--- a/docs/assets/img/docs/managing-pull-requests.drawio.svg
+++ /dev/null
@@ -1,775 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="769px" height="1020px" viewBox="-0.5 -0.5 769 1020" content="&lt;mxfile host=&quot;a2e68c2e-a471-4a83-9c5a-60138cad3948&quot; modified=&quot;2020-09-08T17:57:01.545Z&quot; agent=&quot;5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Code/1.48.2 Chrome/78.0.3904.130 Electron/7.3.2 Safari/537.36&quot; etag=&quot;4WQFsQT91_3-fdZHOrtC&quot; version=&quot;13.1.3&quot;&gt;&lt;diagram id=&quot;6hGFLwfOUW9BJ-s0fimq&quot; name=&quot;Diagram&quot;&gt;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&lt;/diagram&gt;&lt;/mxfile&gt;">
-    <defs/>
-    <g>
-        <path d="M 119 991 L 119 1011 L 7 1011 L 7 181 L 62.63 181" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 67.88 181 L 60.88 184.5 L 62.63 181 L 60.88 177.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <path d="M 119 231 L 119 264.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 119 269.88 L 115.5 262.88 L 119 264.63 L 122.5 262.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 242px; margin-left: 120px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                Yes
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="120" y="245" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    Yes
-                </text>
-            </switch>
-        </g>
-        <path d="M 169 181 L 220.63 181" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 225.88 181 L 218.88 184.5 L 220.63 181 L 218.88 177.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 182px; margin-left: 188px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                No, it’s
-                                <br/>
-                                fine
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="188" y="185" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    No, it’s...
-                </text>
-            </switch>
-        </g>
-        <path d="M 119 131 L 169 181 L 119 231 L 69 181 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 181px; margin-left: 70px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                Want to
-                                <br/>
-                                modify or
-                                <br/>
-                                rebase?
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="119" y="185" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
-                    Want to...
-                </text>
-            </switch>
-        </g>
-        <path d="M 119 841 L 119 884.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 119 889.88 L 115.5 882.88 L 119 884.63 L 122.5 882.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <path d="M 119 841 L 74.5 841 Q 69 841 69 835.5 L 69 812.5 Q 69 807 74.32 805.62 L 163.68 782.38 Q 169 781 169 786.5 L 169 835.5 Q 169 841 163.5 841 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 817px; margin-left: 70px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: system-ui-monospace,ui-monospace,Lucida Console,Menlo,monospace; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                <p style="line-height: 120%">
-                                    hub checkout
-                                </p>
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="119" y="821" fill="#000000" font-family="system-ui-monospace,ui-monospace,Lucida Console,Menlo,monospace" font-size="12px" text-anchor="middle">
-                    hub checkout
-                </text>
-            </switch>
-        </g>
-        <path d="M 69 951 L 92 891 L 146 891 L 169 951 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" transform="translate(0,921)scale(1,-1)translate(0,-921)" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 958px; margin-left: 70px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                Modify and push
-                                <br/>
-                                to PR branch
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="119" y="970" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
-                    Modify and push...
-                </text>
-            </switch>
-        </g>
-        <path d="M 119 101 L 119 121 L 119 111 L 119 124.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 119 129.88 L 115.5 122.88 L 119 124.63 L 122.5 122.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <ellipse cx="119" cy="51" rx="50" ry="50" fill="#ffffff" stroke="#000000" stroke-width="2" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 51px; margin-left: 70px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; font-weight: bold; white-space: normal; word-wrap: normal; ">
-                                Pull request on
-                                <br/>
-                                homebrew-core
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="119" y="55" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle" font-weight="bold">
-                    Pull request on...
-                </text>
-            </switch>
-        </g>
-        <path d="M 607 181 L 717 181 L 717 774.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 717 779.88 L 713.5 772.88 L 717 774.63 L 720.5 772.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 172px; margin-left: 638px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                No,
-                                <br/>
-                                it needs
-                                <br/>
-                                bottles
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="638" y="175" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    No,...
-                </text>
-            </switch>
-        </g>
-        <path d="M 557 231 L 557 341 L 557 404.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 557 409.88 L 553.5 402.88 L 557 404.63 L 560.5 402.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 252px; margin-left: 558px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                Yes
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="558" y="255" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    Yes
-                </text>
-            </switch>
-        </g>
-        <path d="M 557 131 L 607 181 L 557 231 L 507 181 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 181px; margin-left: 508px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                Does it
-                                <br/>
-                                say
-                                <span style="font-family: &quot;system-ui-monospace&quot; , &quot;ui-monospace&quot; , &quot;lucida console&quot; , &quot;menlo&quot; , monospace">
-                                    bottle
-                                    <br/>
-                                    :unneeded
-                                </span>
-                                <br/>
-                                ?
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="557" y="185" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
-                    Does it...
-                </text>
-            </switch>
-        </g>
-        <path d="M 277 371 L 277 411 L 417 411 L 417 561 L 557 561 L 557 754.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 557 759.88 L 553.5 752.88 L 557 754.63 L 560.5 752.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 381px; margin-left: 277px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                Yes
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="277" y="384" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    Yes
-                </text>
-            </switch>
-        </g>
-        <path d="M 327 321 L 420.63 321" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 425.88 321 L 418.88 324.5 L 420.63 321 L 418.88 317.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 322px; margin-left: 368px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                No/not yet
-                                <br/>
-                                but I want
-                                <br/>
-                                to override
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="368" y="325" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    No/not yet...
-                </text>
-            </switch>
-        </g>
-        <path d="M 277 271 L 327 321 L 277 371 L 227 321 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 321px; margin-left: 228px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                CI passed?
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="277" y="325" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
-                    CI passed?
-                </text>
-            </switch>
-        </g>
-        <path d="M 477 371 L 477 541 L 657 541 L 657 207 L 590.37 207" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 585.12 207 L 592.12 203.5 L 590.37 207 L 592.12 210.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 382px; margin-left: 478px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                Yes
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="478" y="385" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    Yes
-                </text>
-            </switch>
-        </g>
-        <path d="M 527 321 L 557 321 L 557 404.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 557 409.88 L 553.5 402.88 L 557 404.63 L 560.5 402.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 322px; margin-left: 538px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                No
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="538" y="325" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    No
-                </text>
-            </switch>
-        </g>
-        <path d="M 477 271 L 527 321 L 477 371 L 427 321 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 321px; margin-left: 428px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                Version or
-                                <br/>
-                                revision
-                                <br/>
-                                bump?
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="477" y="325" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
-                    Version or...
-                </text>
-            </switch>
-        </g>
-        <path d="M 327 181 L 500.63 181" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 505.88 181 L 498.88 184.5 L 500.63 181 L 498.88 177.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 182px; margin-left: 358px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                No, it’s
-                                <br/>
-                                a new
-                                <br/>
-                                formula
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="358" y="185" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    No, it’s...
-                </text>
-            </switch>
-        </g>
-        <path d="M 277 231 L 277 264.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 277 269.88 L 273.5 262.88 L 277 264.63 L 280.5 262.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 242px; margin-left: 278px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                Yes
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="278" y="245" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    Yes
-                </text>
-            </switch>
-        </g>
-        <path d="M 277 131 L 327 181 L 277 231 L 227 181 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 181px; margin-left: 228px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                Existing
-                                <br/>
-                                formula?
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="277" y="185" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
-                    Existing...
-                </text>
-            </switch>
-        </g>
-        <path d="M 557 861 L 557 821 L 557 884.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 557 889.88 L 553.5 882.88 L 557 884.63 L 560.5 882.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 842px; margin-left: 557px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                Yes
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="557" y="845" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    Yes
-                </text>
-            </switch>
-        </g>
-        <path d="M 607 811 L 660.63 811" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 665.88 811 L 658.88 814.5 L 660.63 811 L 658.88 807.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 812px; margin-left: 628px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                No,
-                                <br/>
-                                it’s
-                                <br/>
-                                urgent
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="628" y="815" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    No,...
-                </text>
-            </switch>
-        </g>
-        <path d="M 557 761 L 607 811 L 557 861 L 507 811 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 811px; margin-left: 508px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                Can it wait?
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="557" y="815" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
-                    Can it wait?
-                </text>
-            </switch>
-        </g>
-        <path d="M 507 951 L 530 891 L 584 891 L 607 951 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" transform="translate(0,921)scale(1,-1)translate(0,-921)" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 958px; margin-left: 508px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                Approve ✔ PR and wait for BrewTestBot
-                                <br/>
-                                to merge
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="557" y="970" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
-                    Approve ✔ PR and...
-                </text>
-            </switch>
-        </g>
-        <path d="M 717 841 L 672.5 841 Q 667 841 667 835.5 L 667 812.5 Q 667 807 672.32 805.62 L 761.68 782.38 Q 767 781 767 786.5 L 767 835.5 Q 767 841 761.5 841 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 817px; margin-left: 668px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: system-ui-monospace,ui-monospace,Lucida Console,Menlo,monospace; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                <p>
-                                    brew
-                                    <br/>
-                                    pr-publish
-                                </p>
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="717" y="821" fill="#000000" font-family="system-ui-monospace,ui-monospace,Lucida Console,Menlo,monospace" font-size="12px" text-anchor="middle">
-                    brew...
-                </text>
-            </switch>
-        </g>
-        <path d="M 507 471 L 530 411 L 584 411 L 607 471 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" transform="translate(0,441)scale(1,-1)translate(0,-441)" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 478px; margin-left: 508px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                Push the
-                                <br/>
-                                “Rebase and merge” button
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="557" y="490" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
-                    Push the...
-                </text>
-            </switch>
-        </g>
-        <path d="M 119 371 L 119 774.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 119 779.88 L 115.5 772.88 L 119 774.63 L 122.5 772.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 384px; margin-left: 120px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                Yes
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="120" y="387" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    Yes
-                </text>
-            </switch>
-        </g>
-        <path d="M 169 321 L 197 321 L 197 384.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 197 389.88 L 193.5 382.88 L 197 384.63 L 200.5 382.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 342px; margin-left: 198px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                No/
-                                <br/>
-                                don’t
-                                <br/>
-                                care
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="198" y="345" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    No/...
-                </text>
-            </switch>
-        </g>
-        <path d="M 119 271 L 169 321 L 119 371 L 69 321 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 321px; margin-left: 70px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                Prefer to
-                                <br/>
-                                run CI after-
-                                <br/>
-                                wards?
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="119" y="325" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
-                    Prefer to...
-                </text>
-            </switch>
-        </g>
-        <path d="M 197 491 L 197 754.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 197 759.88 L 193.5 752.88 L 197 754.63 L 200.5 752.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 504px; margin-left: 198px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                Yes
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="198" y="507" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    Yes
-                </text>
-            </switch>
-        </g>
-        <path d="M 197 391 L 247 441 L 197 491 L 147 441 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 441px; margin-left: 148px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                Does it
-                                <br/>
-                                say
-                                <span style="font-family: &quot;system-ui-monospace&quot; , &quot;ui-monospace&quot; , &quot;lucida console&quot; , &quot;menlo&quot; , monospace">
-                                    bottle
-                                    <br/>
-                                    :unneeded
-                                </span>
-                                <br/>
-                                ?
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="197" y="445" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
-                    Does it...
-                </text>
-            </switch>
-        </g>
-        <path d="M 247 441 L 277 441 L 277 504.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 277 509.88 L 273.5 502.88 L 277 504.63 L 280.5 502.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 462px; margin-left: 280px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                No,
-                                <br/>
-                                it needs
-                                <br/>
-                                bottles
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="280" y="465" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    No,...
-                </text>
-            </switch>
-        </g>
-        <path d="M 277 611 L 277 754.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 277 759.88 L 273.5 752.88 L 277 754.63 L 280.5 752.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 625px; margin-left: 278px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                Yes
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="278" y="628" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    Yes
-                </text>
-            </switch>
-        </g>
-        <path d="M 277 511 L 327 561 L 277 611 L 227 561 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 561px; margin-left: 228px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                Rebuild
-                                <br/>
-                                bottles after-
-                                <br/>
-                                wards?
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="277" y="565" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
-                    Rebuild...
-                </text>
-            </switch>
-        </g>
-        <path d="M 327 561 L 357 561 L 357 624.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 357 629.88 L 353.5 622.88 L 357 624.63 L 360.5 622.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 581px; margin-left: 357px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                No, they’re
-                                <br/>
-                                not affected
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="357" y="584" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    No, they’re...
-                </text>
-            </switch>
-        </g>
-        <path d="M 357 731 L 357 761 L 125.37 761" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 120.12 761 L 127.12 757.5 L 125.37 761 L 127.12 764.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 743px; margin-left: 358px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                Yes
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="358" y="746" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    Yes
-                </text>
-            </switch>
-        </g>
-        <path d="M 407 681 L 417 681 L 417 774.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 417 779.88 L 413.5 772.88 L 417 774.63 L 420.5 772.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 702px; margin-left: 428px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
-                                No, merge
-                                <br/>
-                                immediately
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="428" y="705" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
-                    No, merge...
-                </text>
-            </switch>
-        </g>
-        <path d="M 357 631 L 407 681 L 357 731 L 307 681 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 681px; margin-left: 308px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                Want to
-                                <br/>
-                                push to the PR
-                                <br/>
-                                branch?
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="357" y="685" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
-                    Want to...
-                </text>
-            </switch>
-        </g>
-        <path d="M 417 841 L 417 884.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
-        <path d="M 417 889.88 L 413.5 882.88 L 417 884.63 L 420.5 882.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
-        <path d="M 417 841 L 372.5 841 Q 367 841 367 835.5 L 367 812.5 Q 367 807 372.32 805.62 L 461.68 782.38 Q 467 781 467 786.5 L 467 835.5 Q 467 841 461.5 841 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 817px; margin-left: 368px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: system-ui-monospace,ui-monospace,Lucida Console,Menlo,monospace; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                <p style="line-height: 120%">
-                                    brew pr-pull
-                                </p>
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="417" y="821" fill="#000000" font-family="system-ui-monospace,ui-monospace,Lucida Console,Menlo,monospace" font-size="12px" text-anchor="middle">
-                    brew pr-pull
-                </text>
-            </switch>
-        </g>
-        <path d="M 367 951 L 390 891 L 444 891 L 467 951 Z" fill="#ffffff" stroke="#000000" stroke-width="2" stroke-miterlimit="10" transform="translate(0,921)scale(1,-1)translate(0,-921)" pointer-events="all"/>
-        <g transform="translate(-0.5 -0.5)">
-            <switch>
-                <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
-                    <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe flex-start; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 958px; margin-left: 368px;">
-                        <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
-                            <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
-                                Modify and push
-                                <br/>
-                                to master
-                            </div>
-                        </div>
-                    </div>
-                </foreignObject>
-                <text x="417" y="970" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
-                    Modify and push...
-                </text>
-            </switch>
-        </g>
-    </g>
-    <switch>
-        <g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/>
-        <a transform="translate(0,-5)" xlink:href="https://desk.draw.io/support/solutions/articles/16000042487" target="_blank">
-            <text text-anchor="middle" font-size="10px" x="50%" y="100%">
-                Viewer does not support full SVG 1.1
-            </text>
-        </a>
-    </switch>
-</svg>
diff --git a/docs/assets/img/docs/right-click-choose-open.png b/docs/assets/img/docs/right-click-choose-open.png
new file mode 100644
index 0000000000000..c42f6a79cc9c3
Binary files /dev/null and b/docs/assets/img/docs/right-click-choose-open.png differ
diff --git a/docs/assets/img/docs/sparkle-test-app-software-update.png b/docs/assets/img/docs/sparkle-test-app-software-update.png
new file mode 100644
index 0000000000000..76f0fe99586e5
Binary files /dev/null and b/docs/assets/img/docs/sparkle-test-app-software-update.png differ
diff --git a/docs/docs_rubocop_style.yml b/docs/docs_rubocop_style.yml
new file mode 120000
index 0000000000000..62a9e6e71f1c2
--- /dev/null
+++ b/docs/docs_rubocop_style.yml
@@ -0,0 +1 @@
+.rubocop.yml
\ No newline at end of file
diff --git a/docs/governance/2019-moss-track-iii-grant-nomination.md b/docs/governance/2019-moss-track-iii-grant-nomination.md
index a937a985b9a98..f75e366d05032 100644
--- a/docs/governance/2019-moss-track-iii-grant-nomination.md
+++ b/docs/governance/2019-moss-track-iii-grant-nomination.md
@@ -83,7 +83,7 @@ The other maintainers reviewed this application and have expressed their support
 
 According to anonymous analytics data collected per our policy (<https://docs.brew.sh/Analytics>), Homebrew on macOS has approximately 1.24 million instances that have been active in the past month. This is an increase of 19.3% over the same period last year, with 1.04 million active instances.
 
-Hoomebrew on Linux has approximately 15 thousand active instances, an increase of 75% over last year with 8.6 thousand instances.
+Homebrew on Linux has approximately 15 thousand active instances, an increase of 75% over last year with 8.6 thousand instances.
 
 Each installed instance of Homebrew is quite active: over the last year we recorded approximately 166 million installation events; meaning on average, a instance will install software about 1.7 times per day.
 
diff --git a/docs/governance/2021-agm-minutes.md b/docs/governance/2021-agm-minutes.md
index ac7bafefd8c41..eea0ebd0e9c1d 100644
--- a/docs/governance/2021-agm-minutes.md
+++ b/docs/governance/2021-agm-minutes.md
@@ -12,8 +12,6 @@
   Greg Brimble moves to adopt the STV election method to elect the PLC and the Schulze method to elect the project leader. <https://github.com/Homebrew/brew/pull/10637>
 
   Motion carried unanimously.
-
-  <https://www.opavote.com/results/4758678377857024>
 - Shaun Jackman moves to suspend the rules requiring a three week waiting period and to adopt these election systems immediately.
   Motion carried unanimously.
 
@@ -29,9 +27,6 @@
 - 11:55–11:57 Election of the Project Leadership Committee
 
   Jonathan Chang and Issy Long are elected.
-
-  <https://www.opavote.com/results/5937355983683584>
-
 - 11:57–12:00 Election of the Project Leader
 
   Mike McQuaid elected by acclamation.
@@ -46,10 +41,10 @@
 - 12:40–12:45 Michka Popoff - Merging the cores <https://github.com/Homebrew/brew/issues/7028>
 - 12:45–12:50 Michka Popoff - Linux CI for homebrew-core <https://github.com/Homebrew/brew/issues/10597>
 - 12:50–13:55 Misty De Meo - Running Homebrew on Apple Silicon
-- 12:55–13:00 Shaun Jackman - Speeding up install times / Git repo size <https://github.com/Homebrew/install/issues/523>
+- 12:55–13:00 Shaun Jackman - Speeding up install times/Git repository size <https://github.com/Homebrew/install/issues/523>
 - 13:10 Meeting adjourned
 
-## Motions
+## Resolutions
 
 ### Motion to adopt the voting system
 
diff --git a/docs/governance/2022-agm-minutes.md b/docs/governance/2022-agm-minutes.md
index 99419c5a5240a..3ac9bee22849f 100644
--- a/docs/governance/2022-agm-minutes.md
+++ b/docs/governance/2022-agm-minutes.md
@@ -9,7 +9,7 @@
 - 19:05 Project Leader Report (10 min, Mike McQuaid)
 - 19:15 Project Leadership Committee Report (10 min, Misty De Méo)
 - 19:25 Treasurer's Financial Report (5 min, Jon Chang)
-- 19:30 Technical Steering Commitee Report (10 min, Rylan Polster)
+- 19:30 Technical Steering Committee Report (10 min, Rylan Polster)
 
 ## Election Results
 
diff --git a/docs/governance/2022-membership.md b/docs/governance/2022-membership.md
new file mode 100644
index 0000000000000..7d58cd153854d
--- /dev/null
+++ b/docs/governance/2022-membership.md
@@ -0,0 +1,49 @@
+# 2022 Membership
+
+- @alebcay
+- @bayandin
+- @bevanjkay
+- @Bo98
+- @branchvincent
+- @carlocab
+- @chenrui333
+- @cho-m
+- @colindean
+- @danielnachun
+- @dawidd6
+- @DomT4
+- @dtrodrigues
+- @EricFromCanada
+- @fxcoudert
+- @GauthamGoli
+- @gdams
+- @gromgit
+- @igas
+- @iMichka
+- @issyl0
+- @jacobbednarz
+- @jonchang
+- @lembacon
+- @maxim-belkin
+- @miccal
+- @MikeMcQuaid
+- @mistydemeo
+- @Moisan
+- @nandahkrishna
+- @p-linnane
+- @ran-dall
+- @reitermarkus
+- @Rylan12
+- @samford
+- @scpeters
+- @sjackman
+- @SMillerDev
+- @tani
+- @victorpopkov
+- @vitorgalvao
+- @whoiswillma
+- @woodruffw
+- @xu-cheng
+- @zachauten
+- @zbeekman
+- @zmwangx
diff --git a/docs/governance/2023-agm-minutes.md b/docs/governance/2023-agm-minutes.md
new file mode 100644
index 0000000000000..eeb7e55a883ff
--- /dev/null
+++ b/docs/governance/2023-agm-minutes.md
@@ -0,0 +1,45 @@
+# Homebrew Annual General Meeting 2023
+
+## Minutes
+
+- 09:10 Call to order
+
+## Reports
+
+- 09:15 Project Leader Report (15 min, Mike McQuaid)
+- 09:40 Project Leadership Committee Report (15 min, Sean Molenaar)
+- 10:00 Technical Steering Committee Report (15 min, Michka Popoff)
+
+## Election Results
+
+- 10:00 PL Voting Results (5 min, Issy Long)
+  - Mike McQuaid was re-elected.
+
+- 10:05 PLC Voting Results (5 min, Sean Molenaar because Issy felt weird announcing their own election)
+  - Issy Long and Jon Chang were re-elected and Colin Dean was newly elected.
+  - Commiserations to George Adams who was not elected.
+
+- 10:10 Governance Changes Voting Results (5 min, Issy Long)
+  - The governance changes (<https://github.com/Homebrew/brew/pull/14482>) passed.
+
+## Member presentations and discussions (11:00-12:00 and 13:30-15:00)
+
+- ARM on Linux (Michka Popoff)
+- Install from API (Rylan Polster)
+- Homebrew on Linux (Patrick Linanne and Bo Anderson)
+- CI infrastructure (Rui Chen)
+- Security initiatives (Patrick Linanne)
+- Formula licenses (Rui Chen)
+- GitHub authentication security improvements (Colin Dean)
+- Improvements to autobumping formulae and casks (Rui Chen)
+- Formalizing the reimbursement process (Colin Dean)
+- Homebrew Mastodon account (Mike McQuaid)
+- InfluxDB analytics (Mike McQuaid)
+- Security posture improvements, potentially making a security-focused volunteer group (Mike McQuaid)
+
+## Hackathon (undocumented, 15:00-17:00)
+
+## Adjournment
+
+- Final remarks, thanks for coming (Issy Long)
+- 17:00 Meeting finished.
diff --git a/docs/governance/2024-agm-minutes.md b/docs/governance/2024-agm-minutes.md
new file mode 100644
index 0000000000000..52c8444657b5c
--- /dev/null
+++ b/docs/governance/2024-agm-minutes.md
@@ -0,0 +1,74 @@
+# Homebrew Annual General Meeting 2024
+
+## Opening
+
+* 09:00 Taking seats
+* 09:10 Call to order
+
+Attendance:
+
+* Issy Long
+* Mike McQuaid
+* Sean Molenaar
+* Colin Dean
+* Rui Chen
+* Bevan Kay
+* George Adams
+* Rylan Polster
+* Doug Eichelberger
+* Michael Cho
+* Eric Knibbe
+* Markus Reiter
+* Vanessa Gennarelli
+* John Britton
+* Carlo Cabrera
+* William Woodruff
+* Patrick Linnane
+* Justin Krehel
+* Ruoyu Zhong
+* Michka Popoff
+* Bo Anderson
+* Miccal Matthews
+* Caleb Xu
+
+## Reports
+
+* 09:15 “State of the Brewnion” Project Leader Report (15 min, Mike McQuaid)
+* 09:40 Project Leadership Committee Report (15 min, Colin and Sean for the PLC)
+* 10:00 Technical Steering Committee Report (15 min, Michka for the TSC)
+
+## Election Results
+
+* 10:00 PL Voting Results (5 min, Issy for the PLC)
+  * Mike McQuaid reelected with 48 votes
+* 10:05 PLC Voting Results (5 min, Issy for the PLC)
+  * Patrick and Vanessa candidates, 2 seats, 46 voters
+  * Both elected.
+* 10:10 Governance Changes Voting Results (5 min, Issy for the PLC)
+  * Approved, merged [#16494](https://github.com/Homebrew/brew/pull/16494)
+
+## Presentations and discussions (11:00-12:00 and 13:30-15:00)
+
+* Review of last year’s topics (Sean Molenaar)
+* Workbrew and Homebrew (Mike McQuaid)
+* Rename master branches to main (Mike McQuaid)
+* Faster brew (Mike McQuaid)
+* Killing non-homebrew-cask cask taps (Mike McQuaid)
+* Maintainers using forks (e.g. packaging CI job doesn’t run with them) (Mike McQuaid)
+* Long-term solutions for formulas with lots of dependents testing: parallelisation, etc. (FX Coudert)
+* Removing six (Python 2/3): communication with the Python community (Michka)
+* Revising the formula deprecation policy (Bo Anderson)
+* Introducing the cask deprecation policy (Bo Anderson)
+* Criteria of suitability for Python formulae (FX Coudert)
+* Revisiting dependency grants (Colin Dean)
+* Grant seeking (Colin Dean)
+* Commission redesign of formula & cask page layouts (Eric Knibbe)
+* Formal security governance (Patrick Linnane)
+* Security initiatives (Patrick Linnane)
+* Build provenance on homebrew-core (William Woodruff)
+* Publicly discouraging duplicating testbot bumps (Sean Molenaar)
+* Long running run switching (Sean Molenaar)
+* [brew fund](https://github.com/colindean/homebrew-fund) (Colin Dean)
+* Formalize when to allow switching a formula/cask’s upstream to a fork (Eric Knibbe)
+* Revamping `conflicts_with` for formulae and casks (Rylan Polster)
+* Maintainers using forks (e.g. packaging CI job doesn’t run with them) (Mike McQuaid)
diff --git a/docs/index.md b/docs/index.md
new file mode 100644
index 0000000000000..f5efc18b455fe
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1,78 @@
+# Documentation
+
+## Users
+
+- [`brew` manual page (command documentation)](Manpage.md)
+- [Homebrew Blog (news on major updates)](https://brew.sh/blog/)
+- [Installation](Installation.md)
+- [Troubleshooting](Troubleshooting.md)
+- [FAQ (Frequently Asked Questions)](FAQ.md)
+- [Common Issues](Common-Issues.md)
+- [`brew` Shell Completion](Shell-Completion.md)
+- [Homebrew on Linux](Homebrew-on-Linux.md)
+
+- [Bottles (binary packages)](Bottles.md)
+- [Taps (third-party repositories)](Taps.md)
+- [Interesting Taps and Forks](Interesting-Taps-and-Forks.md)
+- [Tips and Tricks](Tips-N'-Tricks.md)
+- [Anonymous Analytics](Analytics.md)
+
+- [Querying `brew`](Querying-Brew.md)
+- [C++ Standard Libraries](C++-Standard-Libraries.md)
+- [MD5 and SHA-1 Deprecation](Checksum_Deprecation.md)
+- [Custom GCC and Cross Compilers](Custom-GCC-and-cross-compilers.md)
+- [External Commands](External-Commands.md)
+- [Ruby Gems, Python Eggs and Perl Modules](Gems,-Eggs-and-Perl-Modules.md)
+- [Python](Homebrew-and-Python.md)
+- [How to Build Software Outside Homebrew with Homebrew `keg_only` Dependencies](How-to-Build-Software-Outside-Homebrew-with-Homebrew-keg-only-Dependencies.md)
+- [Xcode](Xcode.md)
+
+- [Creating a Homebrew Issue](Creating-a-Homebrew-Issue.md)
+- [Updating Software in Homebrew](Updating-Software-in-Homebrew.md)
+- [Adding Software to Homebrew](Adding-Software-to-Homebrew.md)
+
+- [Kickstarter Supporters](Kickstarter-Supporters.md)
+
+## Contributors
+
+- [How to Open a Pull Request (and get it merged)](How-To-Open-a-Homebrew-Pull-Request.md)
+- [Formula Cookbook](Formula-Cookbook.md)
+- [Cask Cookbook](Cask-Cookbook.md)
+- [Acceptable Formulae](Acceptable-Formulae.md)
+- [Acceptable Casks](Acceptable-Casks.md)
+- [License Guidelines](License-Guidelines.md)
+- [Formulae Versions](Versions.md)
+- [Deprecating, Disabling and Removing Formulae](Deprecating-Disabling-and-Removing-Formulae.md)
+- [Node for Formula Authors](Node-for-Formula-Authors.md)
+- [Python for Formula Authors](Python-for-Formula-Authors.md)
+- [`brew livecheck`](Brew-Livecheck.md)
+- [Migrating a Formula to a Tap](Migrating-A-Formula-To-A-Tap.md)
+- [Renaming a Formula](Rename-A-Formula.md)
+- [Building Against Non-Homebrew Dependencies](Building-Against-Non-Homebrew-Dependencies.md)
+- [How to Create and Maintain a Tap](How-to-Create-and-Maintain-a-Tap.md)
+- [BrewTestBot](BrewTestBot.md)
+- [Prose Style Guidelines](Prose-Style-Guidelines.md)
+- [Type Checking with Sorbet](Typechecking.md)
+- [Reproducible Builds](Reproducible-Builds.md)
+
+- [Ruby API Documentation](https://rubydoc.brew.sh) (e.g. for `Formula` etc.)
+
+## Maintainers
+
+- [New Maintainer Checklist](New-Maintainer-Checklist.md)
+- [Maintainers: Avoiding Burnout](Maintainers-Avoiding-Burnout.md)
+
+- [Maintainer Guidelines](Maintainer-Guidelines.md)
+- [Homebrew/brew Maintainer Guide](Homebrew-brew-Maintainer-Guide.md)
+- [Homebrew/homebrew-core Maintainer Guide](Homebrew-homebrew-core-Maintainer-Guide.md)
+- [Homebrew/homebrew-cask Maintainer Guide](Homebrew-homebrew-cask-Maintainer-Guide.md)
+
+- [BrewTestBot for Maintainers](BrewTestBot-For-Maintainers.md)
+- [Common Issues for Maintainers](Common-Issues-for-Core-Contributors.md)
+- [Releases](Releases.md)
+
+## Governance
+
+- [Homebrew Governance](Homebrew-Governance.md)
+- [Homebrew Leadership Responsibilities](Homebrew-Leadership-Responsibilities.md)
+- [Homebrew Governance Archives](Homebrew-Governance-Archives.md)
diff --git a/docs/vale-styles/Homebrew/Abbreviations.yml b/docs/vale-styles/Homebrew/Abbreviations.yml
index df562c44aa5ae..f51c2dd53fe12 100644
--- a/docs/vale-styles/Homebrew/Abbreviations.yml
+++ b/docs/vale-styles/Homebrew/Abbreviations.yml
@@ -1,6 +1,6 @@
 ---
 extends: substitution
-message: Use '%s'
+message: Use '%s' instead of '%s'.
 ignorecase: false
 link: "https://github.com/Homebrew/brew/blob/HEAD/docs/Prose-Style-Guidelines.md#style-and-usage"
 level: error
@@ -10,3 +10,9 @@ swap:
   '\bie\b': i.e.
   'e\.g\.,': e.g.
   'i\.e\.,': i.e.
+  '(?<!^\{.*|\.|<)\borg\b': organisation
+  '(?<!^\{.*)\borgs\b': organisations
+  '(?<!^\{.*|<|\{#)\brepo\b': repository # FIXME: https://github.com/errata-ai/vale/issues/818
+  '(?<!^\{.*)\brepos\b': repositories
+  '\bivar\b': instance variable
+  '\bivars\b': instance variables
diff --git a/docs/vale-styles/Homebrew/README.md b/docs/vale-styles/Homebrew/README.md
index a713f91d75e16..ce3e0c3ac7a3a 100644
--- a/docs/vale-styles/Homebrew/README.md
+++ b/docs/vale-styles/Homebrew/README.md
@@ -1 +1,3 @@
+# Vale Styles
+
 Based on Homebrew's [Prose Style Guidelines](http://docs.brew.sh/Prose-Style-Guidelines.html).
diff --git a/docs/vale-styles/Homebrew/Spacing.yml b/docs/vale-styles/Homebrew/Spacing.yml
index ca752c5db39c2..5ab71b63b6969 100644
--- a/docs/vale-styles/Homebrew/Spacing.yml
+++ b/docs/vale-styles/Homebrew/Spacing.yml
@@ -5,5 +5,5 @@ link: "https://github.com/Homebrew/brew/blob/HEAD/docs/Prose-Style-Guidelines.md
 level: error
 nonword: true
 tokens:
-  - "[a-z][.?!][A-Z]"
-  - "[.?!] {2,}[A-Z]"
+  - '(?<!^\{.*)[a-z][.?!][A-Z]' # FIXME: https://github.com/errata-ai/vale/issues/818
+  - '[.?!] {2,}[A-Z]'
diff --git a/docs/vale-styles/Homebrew/Terms.yml b/docs/vale-styles/Homebrew/Terms.yml
index 29ed33b17139a..82c6ca07c720e 100644
--- a/docs/vale-styles/Homebrew/Terms.yml
+++ b/docs/vale-styles/Homebrew/Terms.yml
@@ -3,8 +3,10 @@ extends: substitution
 message: Use '%s' instead of '%s'.
 link: "https://github.com/Homebrew/brew/blob/HEAD/docs/Prose-Style-Guidelines.md#terminology-words-and-word-styling"
 level: error
-scope: $paragraph
+scope: paragraph
+
 swap:
-  Pull Request: pull request
-  repo: repository
+  '(?<!How to Open a Homebrew )Pull Request': pull request
   Rubocop: RuboCop
+  '(?<!^\{.*)MacOS': macOS # FIXME: https://github.com/errata-ai/vale/issues/818
+  '(?<!^\{.*|^!/.*)ruby': Ruby # FIXME: https://github.com/errata-ai/vale/issues/818
diff --git a/manpages/README.md b/manpages/README.md
index 40f8150788734..5970ecf3ce38c 100644
--- a/manpages/README.md
+++ b/manpages/README.md
@@ -1,3 +1,3 @@
-# Manual pages
+# Manual Pages
 
 This directory contains the generated Homebrew man pages from the `brew generate-man-completions` command. This command creates the output from the `CLI::Parser` definitions in files, sections extracted from the repository's `README.md` and `brew.1.md.erb`.
diff --git a/manpages/brew.1 b/manpages/brew.1
index 760aa819c6e21..111cf2e35323b 100644
--- a/manpages/brew.1
+++ b/manpages/brew.1
@@ -1,3354 +1,2765 @@
-.\" generated with Ronn/v0.7.3
-.\" http://github.com/rtomayko/ronn/tree/0.7.3
-.
-.TH "BREW" "1" "July 2022" "Homebrew" "brew"
-.
-.SH "NAME"
-\fBbrew\fR \- The Missing Package Manager for macOS (or Linux)
-.
+.\" generated by kramdown
+.TH "BREW" "1" "November 2024" "Homebrew"
+.SH NAME
+brew \- The Missing Package Manager for macOS (or Linux)
 .SH "SYNOPSIS"
-\fBbrew\fR \fB\-\-version\fR
-.
+\fBbrew\fP \fB\-\-version\fP
 .br
-\fBbrew\fR \fIcommand\fR [\fB\-\-verbose\fR|\fB\-v\fR] [\fIoptions\fR] [\fIformula\fR] \.\.\.
-.
+\fBbrew\fP \fIcommand\fP [\fB\-\-verbose\fP|\fB\-v\fP] [\fIoptions\fP] [\fIformula\fP] \.\.\.
 .SH "DESCRIPTION"
-Homebrew is the easiest and most flexible way to install the UNIX tools Apple didn\'t include with macOS\. It can also install software not packaged for your Linux distribution to your home directory without requiring \fBsudo\fR\.
-.
+Homebrew is the easiest and most flexible way to install the UNIX tools Apple didn\[u2019]t include with macOS\. It can also install software not packaged for your Linux distribution without requiring \fBsudo\fP\&\.
 .SH "TERMINOLOGY"
-\fBformula\fR
-    Homebrew package definition built from upstream sources
-.
-.P
-\fBcask\fR
-    Homebrew package definition that installs macOS native applications
-.
-.P
-\fBkeg\fR
-    installation destination directory of a given \fBformula\fR version e\.g\. \fB/usr/local/Cellar/foo/0\.1\fR
-.
-.P
-\fBrack\fR
-    directory containing one or more versioned kegs e\.g\. \fB/usr/local/Cellar/foo\fR
-.
-.P
-\fBkeg\-only\fR
-    a \fBformula\fR is \fBkeg\-only\fR if it is not symlinked into Homebrew\'s prefix (e\.g\. \fB/usr/local\fR)
-.
-.P
-\fBcellar\fR
-    directory containing one or more named \fBracks\fR e\.g\. \fB/usr/local/Cellar\fR
-.
-.P
-\fBCaskroom\fR
-    directory containing one or more named \fBcasks\fR e\.g\. \fB/usr/local/Caskroom\fR
-.
+.TP
+\fBformula\fP
+Homebrew package definition that builds from upstream sources
+.TP
+\fBcask\fP
+Homebrew package definition that installs macOS native applications
+.TP
+\fBprefix\fP
+path in which Homebrew is installed, e\.g\. \fB/usr/local\fP
+.TP
+\fBkeg\fP
+installation destination directory of a given \fBformula\fP version, e\.g\. \fB/usr/local/Cellar/foo/0\.1\fP
+.TP
+\fBrack\fP
+directory containing one or more versioned \fBkegs\fP, e\.g\. \fB/usr/local/Cellar/foo\fP
+.TP
+\fBkeg\-only\fP
+a \fBformula\fP is \fIkeg\-only\fP if it is not symlinked into Homebrew\[u2019]s prefix
+.TP
+\fBopt prefix\fP
+a symlink to the active version of a \fBkeg\fP, e\.g\. \fB/usr/local/opt/foo\fP
+.TP
+\fBCellar\fP
+directory containing one or more named \fBracks\fP, e\.g\. \fB/usr/local/Cellar\fP
+.TP
+\fBCaskroom\fP
+directory containing one or more named \fBcasks\fP, e\.g\. \fB/usr/local/Caskroom\fP
+.TP
+\fBexternal command\fP
+\fBbrew\fP subcommand defined outside of the Homebrew/brew GitHub repository
+.TP
+\fBtap\fP
+directory (and usually Git repository) of \fBformulae\fP, \fBcasks\fP and/or \fBexternal commands\fP
+.TP
+\fBbottle\fP
+pre\-built \fBkeg\fP poured into a \fBrack\fP of the \fBCellar\fP instead of building from upstream sources
+.SH "ESSENTIAL COMMANDS"
+For the full command list, see the \fICOMMANDS\fP section\.
 .P
-\fBexternal command\fR
-    \fBbrew\fR subcommand defined outside of the Homebrew/brew GitHub repository
-.
+With \fB\-\-verbose\fP or \fB\-\-debug\fP, many commands print extra debugging information\. Note that these options should only appear after a command\.
 .P
-\fBtap\fR
-    directory (and usually Git repository) of \fBformulae\fR, \fBcasks\fR and/or \fBexternal commands\fR
-.
+Some command behaviour can be customised with environment variables; see the \fIENVIRONMENT\fP section\.
+.SS "\fBinstall\fP \fIformula\fP"
+Install \fIformula\fP\&\.
 .P
-\fBbottle\fR
-    pre\-built \fBkeg\fR poured into the \fBcellar\fR/\fBrack\fR instead of building from upstream sources
-.
-.SH "ESSENTIAL COMMANDS"
-For the full command list, see the \fICOMMANDS\fR section\.
-.
-.P
-With \fB\-\-verbose\fR or \fB\-\-debug\fR, many commands print extra debugging information\. Note that these options should only appear after a command\.
-.
-.P
-Some command behaviour can be customised with environment variables; see the \fIENVIRONMENT\fR section\.
-.
-.SS "\fBinstall\fR \fIformula\fR"
-Install \fIformula\fR\.
-.
-.P
-\fIformula\fR is usually the name of the formula to install, but it has other syntaxes which are listed in the \fISPECIFYING FORMULAE\fR section\.
-.
-.SS "\fBuninstall\fR \fIformula\fR"
-Uninstall \fIformula\fR\.
-.
-.SS "\fBlist\fR"
+\fIformula\fP is usually the name of the formula to install, but it has other syntaxes which are listed in the \fISPECIFYING FORMULAE\fP section\.
+.SS "\fBuninstall\fP \fIformula\fP"
+Uninstall \fIformula\fP\&\.
+.SS "\fBlist\fP"
 List all installed formulae\.
-.
-.SS "\fBsearch\fR [\fItext\fR|\fB/\fR\fItext\fR\fB/\fR]"
-Perform a substring search of cask tokens and formula names for \fItext\fR\. If \fItext\fR is flanked by slashes, it is interpreted as a regular expression\. The search for \fItext\fR is extended online to \fBhomebrew/core\fR and \fBhomebrew/cask\fR\. If no search term is provided, all locally available formulae are listed\.
-.
+.SS "\fBsearch\fP \fR[\fItext\fP|\fB/\fP\fItext\fP\fB/\fP]"
+Perform a substring search of cask tokens and formula names for \fItext\fP\&\. If \fItext\fP is flanked by slashes, it is interpreted as a regular expression\. The search for \fItext\fP is extended online to \fBhomebrew/core\fP and \fBhomebrew/cask\fP\&\. If no search term is provided, all locally available formulae are listed\.
 .SH "COMMANDS"
-.
-.SS "\fBanalytics\fR [\fIsubcommand\fR]"
-Control Homebrew\'s anonymous aggregate user behaviour analytics\. Read more at \fIhttps://docs\.brew\.sh/Analytics\fR\.
-.
-.P
-\fBbrew analytics\fR [\fBstate\fR]
-    Display the current state of Homebrew\'s analytics\.
-.
-.P
-\fBbrew analytics\fR (\fBon\fR|\fBoff\fR)
-    Turn Homebrew\'s analytics on or off respectively\.
-.
-.P
-\fBbrew analytics regenerate\-uuid\fR
-    Regenerate the UUID used for Homebrew\'s analytics\.
-.
-.SS "\fBautoremove\fR [\fI\-\-dry\-run\fR]"
+.SS "\fBanalytics\fP \fR[\fIsubcommand\fP]"
+Control Homebrew\[u2019]s anonymous aggregate user behaviour analytics\. Read more at 
+.UR https://docs\.brew\.sh/Analytics
+.UE \&\.
+.TP
+\fBbrew analytics\fP [\fBstate\fP]
+Display the current state of Homebrew\[u2019]s analytics\.
+.TP
+\fBbrew analytics\fP (\fBon\fP|\fBoff\fP)
+Turn Homebrew\[u2019]s analytics on or off respectively\.
+.SS "\fBautoremove\fP \fR[\fB\-\-dry\-run\fP]"
 Uninstall formulae that were only installed as a dependency of another formula and are now no longer needed\.
-.
 .TP
-\fB\-n\fR, \fB\-\-dry\-run\fR
+\fB\-n\fP, \fB\-\-dry\-run\fP
 List what would be uninstalled, but do not actually uninstall anything\.
-.
-.SS "\fBcasks\fR"
+.SS "\fBcasks\fP"
 List all locally installable casks including short names\.
-.
-.SS "\fBcleanup\fR [\fIoptions\fR] [\fIformula\fR|\fIcask\fR \.\.\.]"
-Remove stale lock files and outdated downloads for all formulae and casks, and remove old versions of installed formulae\. If arguments are specified, only do this for the given formulae and casks\. Removes all downloads more than 120 days old\. This can be adjusted with \fBHOMEBREW_CLEANUP_MAX_AGE_DAYS\fR\.
-.
+.SS "\fBcleanup\fP \fR[\fIoptions\fP] \fR[\fIformula\fP|\fIcask\fP \.\.\.]"
+Remove stale lock files and outdated downloads for all formulae and casks, and remove old versions of installed formulae\. If arguments are specified, only do this for the given formulae and casks\. Removes all downloads more than 120 days old\. This can be adjusted with \fBHOMEBREW_CLEANUP_MAX_AGE_DAYS\fP\&\.
 .TP
-\fB\-\-prune\fR
-Remove all cache files older than specified \fIdays\fR\. If you want to remove everything, use \fB\-\-prune=all\fR\.
-.
+\fB\-\-prune\fP
+Remove all cache files older than specified \fIdays\fP\&\. If you want to remove everything, use \fB\-\-prune=all\fP\&\.
 .TP
-\fB\-n\fR, \fB\-\-dry\-run\fR
+\fB\-n\fP, \fB\-\-dry\-run\fP
 Show what would be removed, but do not actually remove anything\.
-.
 .TP
-\fB\-s\fR
-Scrub the cache, including downloads for even the latest versions\. Note that downloads for any installed formulae or casks will still not be deleted\. If you want to delete those too: \fBrm \-rf "$(brew \-\-cache)"\fR
-.
+\fB\-s\fP, \fB\-\-scrub\fP
+Scrub the cache, including downloads for even the latest versions\. Note that downloads for any installed formulae or casks will still not be deleted\. If you want to delete those too: \fBrm \-rf "$(brew \-\-cache)"\fP
 .TP
-\fB\-\-prune\-prefix\fR
+\fB\-\-prune\-prefix\fP
 Only prune the symlinks and directories from the prefix and remove no other files\.
-.
-.SS "\fBcommands\fR [\fI\-\-quiet\fR] [\fI\-\-include\-aliases\fR]"
+.SS "\fBcommand\fP \fIcommand\fP \fR[\.\.\.]"
+Display the path to the file being used when invoking \fBbrew\fP \fIcmd\fP\&\.
+.SS "\fBcommands\fP \fR[\fB\-\-quiet\fP] \fR[\fB\-\-include\-aliases\fP]"
 Show lists of built\-in and external commands\.
-.
 .TP
-\fB\-q\fR, \fB\-\-quiet\fR
+\fB\-q\fP, \fB\-\-quiet\fP
 List only the names of commands without category headers\.
-.
 .TP
-\fB\-\-include\-aliases\fR
+\fB\-\-include\-aliases\fP
 Include aliases of internal commands\.
-.
-.SS "\fBcompletions\fR [\fIsubcommand\fR]"
-Control whether Homebrew automatically links external tap shell completion files\. Read more at \fIhttps://docs\.brew\.sh/Shell\-Completion\fR\.
-.
-.P
-\fBbrew completions\fR [\fBstate\fR]
-    Display the current state of Homebrew\'s completions\.
-.
-.P
-\fBbrew completions\fR (\fBlink\fR|\fBunlink\fR)
-    Link or unlink Homebrew\'s completions\.
-.
-.SS "\fBconfig\fR, \fB\-\-config\fR"
+.SS "\fBcompletions\fP \fR[\fIsubcommand\fP]"
+Control whether Homebrew automatically links external tap shell completion files\. Read more at 
+.UR https://docs\.brew\.sh/Shell\-Completion
+.UE \&\.
+.TP
+\fBbrew completions\fP [\fBstate\fP]
+Display the current state of Homebrew\[u2019]s completions\.
+.TP
+\fBbrew completions\fP (\fBlink\fP|\fBunlink\fP)
+Link or unlink Homebrew\[u2019]s completions\.
+.SS "\fBconfig\fP, \fB\-\-config\fP"
 Show Homebrew and system configuration info useful for debugging\. If you file a bug report, you will be required to provide this information\.
-.
-.SS "\fBdeps\fR [\fIoptions\fR] [\fIformula\fR|\fIcask\fR \.\.\.]"
-Show dependencies for \fIformula\fR\. Additional options specific to \fIformula\fR may be appended to the command\. When given multiple formula arguments, show the intersection of dependencies for each formula\.
-.
+.SS "\fBdeps\fP \fR[\fIoptions\fP] \fR[\fIformula\fP|\fIcask\fP \.\.\.]"
+Show dependencies for \fIformula\fP\&\. When given multiple formula arguments, show the intersection of dependencies for each formula\. By default, \fBdeps\fP shows all required and recommended dependencies\.
+.P
+If any version of each formula argument is installed and no other options are passed, this command displays their actual runtime dependencies (similar to \fBbrew linkage\fP), which may differ from the current versions\[u2019] stated dependencies if the installed versions are outdated\.
+.P
+\fINote:\fP \fB\-\-missing\fP and \fB\-\-skip\-recommended\fP have precedence over \fB\-\-include\-*\fP\&\.
 .TP
-\fB\-n\fR
+\fB\-n\fP, \fB\-\-topological\fP
 Sort dependencies in topological order\.
-.
 .TP
-\fB\-\-1\fR
-Only show dependencies one level down, instead of recursing\.
-.
+\fB\-1\fP, \fB\-\-direct\fP
+Show only the direct dependencies declared in the formula\.
 .TP
-\fB\-\-union\fR
-Show the union of dependencies for multiple \fIformula\fR, instead of the intersection\.
-.
+\fB\-\-union\fP
+Show the union of dependencies for multiple \fIformula\fP, instead of the intersection\.
 .TP
-\fB\-\-full\-name\fR
+\fB\-\-full\-name\fP
 List dependencies by their full name\.
-.
 .TP
-\fB\-\-include\-build\fR
-Include \fB:build\fR dependencies for \fIformula\fR\.
-.
+\fB\-\-include\-build\fP
+Include \fB:build\fP dependencies for \fIformula\fP\&\.
 .TP
-\fB\-\-include\-optional\fR
-Include \fB:optional\fR dependencies for \fIformula\fR\.
-.
+\fB\-\-include\-optional\fP
+Include \fB:optional\fP dependencies for \fIformula\fP\&\.
 .TP
-\fB\-\-include\-test\fR
-Include \fB:test\fR dependencies for \fIformula\fR (non\-recursive)\.
-.
+\fB\-\-include\-test\fP
+Include \fB:test\fP dependencies for \fIformula\fP (non\-recursive)\.
 .TP
-\fB\-\-skip\-recommended\fR
-Skip \fB:recommended\fR dependencies for \fIformula\fR\.
-.
+\fB\-\-skip\-recommended\fP
+Skip \fB:recommended\fP dependencies for \fIformula\fP\&\.
 .TP
-\fB\-\-include\-requirements\fR
-Include requirements in addition to dependencies for \fIformula\fR\.
-.
+\fB\-\-include\-requirements\fP
+Include requirements in addition to dependencies for \fIformula\fP\&\.
 .TP
-\fB\-\-tree\fR
+\fB\-\-tree\fP
 Show dependencies as a tree\. When given multiple formula arguments, show individual trees for each formula\.
-.
 .TP
-\fB\-\-graph\fR
+\fB\-\-graph\fP
 Show dependencies as a directed graph\.
-.
 .TP
-\fB\-\-dot\fR
+\fB\-\-dot\fP
 Show text\-based graph description in DOT format\.
-.
 .TP
-\fB\-\-annotate\fR
-Mark any build, test, optional, or recommended dependencies as such in the output\.
-.
+\fB\-\-annotate\fP
+Mark any build, test, implicit, optional, or recommended dependencies as such in the output\.
+.TP
+\fB\-\-installed\fP
+List dependencies for formulae that are currently installed\. If \fIformula\fP is specified, list only its dependencies that are currently installed\.
+.TP
+\fB\-\-missing\fP
+Show only missing dependencies\.
+.TP
+\fB\-\-eval\-all\fP
+Evaluate all available formulae and casks, whether installed or not, to list their dependencies\.
+.TP
+\fB\-\-for\-each\fP
+Switch into the mode used by the \fB\-\-eval\-all\fP option, but only list dependencies for each provided \fIformula\fP, one formula per line\. This is used for debugging the \fB\-\-installed\fP/\fB\-\-eval\-all\fP display mode\.
 .TP
-\fB\-\-installed\fR
-List dependencies for formulae that are currently installed\. If \fIformula\fR is specified, list only its dependencies that are currently installed\.
-.
+\fB\-\-HEAD\fP
+Show dependencies for HEAD version instead of stable version\.
 .TP
-\fB\-\-all\fR
-List dependencies for all available formulae\.
-.
+\fB\-\-os\fP
+Show dependencies for the given operating system\.
 .TP
-\fB\-\-for\-each\fR
-Switch into the mode used by the \fB\-\-all\fR option, but only list dependencies for each provided \fIformula\fR, one formula per line\. This is used for debugging the \fB\-\-installed\fR/\fB\-\-all\fR display mode\.
-.
+\fB\-\-arch\fP
+Show dependencies for the given CPU architecture\.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Treat all named arguments as formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Treat all named arguments as casks\.
-.
-.SS "\fBdesc\fR [\fIoptions\fR] \fIformula\fR|\fIcask\fR|\fItext\fR|\fB/\fR\fIregex\fR\fB/\fR [\.\.\.]"
-Display \fIformula\fR\'s name and one\-line description\. Formula descriptions are cached; the cache is created on the first search, making that search slower than subsequent ones\.
-.
+.SS "\fBdesc\fP \fR[\fIoptions\fP] \fIformula\fP|\fIcask\fP|\fItext\fP|\fB/\fP\fIregex\fP\fB/\fP \fR[\.\.\.]"
+Display \fIformula\fP\[u2019]s name and one\-line description\. The cache is created on the first search, making that search slower than subsequent ones\.
 .TP
-\fB\-s\fR, \fB\-\-search\fR
-Search both names and descriptions for \fItext\fR\. If \fItext\fR is flanked by slashes, it is interpreted as a regular expression\.
-.
+\fB\-s\fP, \fB\-\-search\fP
+Search both names and descriptions for \fItext\fP\&\. If \fItext\fP is flanked by slashes, it is interpreted as a regular expression\.
 .TP
-\fB\-n\fR, \fB\-\-name\fR
-Search just names for \fItext\fR\. If \fItext\fR is flanked by slashes, it is interpreted as a regular expression\.
-.
+\fB\-n\fP, \fB\-\-name\fP
+Search just names for \fItext\fP\&\. If \fItext\fP is flanked by slashes, it is interpreted as a regular expression\.
 .TP
-\fB\-d\fR, \fB\-\-description\fR
-Search just descriptions for \fItext\fR\. If \fItext\fR is flanked by slashes, it is interpreted as a regular expression\.
-.
+\fB\-d\fP, \fB\-\-description\fP
+Search just descriptions for \fItext\fP\&\. If \fItext\fP is flanked by slashes, it is interpreted as a regular expression\.
 .TP
-\fB\-\-formula\fR
+\fB\-\-eval\-all\fP
+Evaluate all available formulae and casks, whether installed or not, to search their descriptions\. Implied if \fBHOMEBREW_EVAL_ALL\fP is set\.
+.TP
+\fB\-\-formula\fP
 Treat all named arguments as formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Treat all named arguments as casks\.
-.
-.SS "\fBdeveloper\fR [\fIsubcommand\fR]"
-Control Homebrew\'s developer mode\. When developer mode is enabled, \fBbrew update\fR will update Homebrew to the latest commit on the \fBmaster\fR branch instead of the latest stable version along with some other behaviour changes\.
-.
-.P
-\fBbrew developer\fR [\fBstate\fR]
-    Display the current state of Homebrew\'s developer mode\.
-.
-.P
-\fBbrew developer\fR (\fBon\fR|\fBoff\fR)
-    Turn Homebrew\'s developer mode on or off respectively\.
-.
-.SS "\fBdoctor\fR, \fBdr\fR [\fI\-\-list\-checks\fR] [\fI\-\-audit\-debug\fR] [\fIdiagnostic_check\fR \.\.\.]"
-Check your system for potential problems\. Will exit with a non\-zero status if any potential problems are found\. Please note that these warnings are just used to help the Homebrew maintainers with debugging if you file an issue\. If everything you use Homebrew for is working fine: please don\'t worry or file an issue; just ignore this\.
-.
-.TP
-\fB\-\-list\-checks\fR
+.SS "\fBdeveloper\fP \fR[\fIsubcommand\fP]"
+Control Homebrew\[u2019]s developer mode\. When developer mode is enabled, \fBbrew update\fP will update Homebrew to the latest commit on the \fBmaster\fP branch instead of the latest stable version along with some other behaviour changes\.
+.TP
+\fBbrew developer\fP [\fBstate\fP]
+Display the current state of Homebrew\[u2019]s developer mode\.
+.TP
+\fBbrew developer\fP (\fBon\fP|\fBoff\fP)
+Turn Homebrew\[u2019]s developer mode on or off respectively\.
+.SS "\fBdocs\fP"
+Open Homebrew\[u2019]s online documentation at 
+.UR https://docs\.brew\.sh
+.UE
+in a browser\.
+.SS "\fBdoctor\fP, \fBdr\fP \fR[\fB\-\-list\-checks\fP] \fR[\fB\-\-audit\-debug\fP] \fR[\fIdiagnostic_check\fP \.\.\.]"
+Check your system for potential problems\. Will exit with a non\-zero status if any potential problems are found\.
+.P
+Please note that these warnings are just used to help the Homebrew maintainers with debugging if you file an issue\. If everything you use Homebrew for is working fine: please don\[u2019]t worry or file an issue; just ignore this\.
+.TP
+\fB\-\-list\-checks\fP
 List all audit methods, which can be run individually if provided as arguments\.
-.
 .TP
-\fB\-D\fR, \fB\-\-audit\-debug\fR
+\fB\-D\fP, \fB\-\-audit\-debug\fP
 Enable debugging and profiling of audit methods\.
-.
-.SS "\fBfetch\fR [\fIoptions\fR] \fIformula\fR|\fIcask\fR [\.\.\.]"
-Download a bottle (if available) or source packages for \fIformula\fRe and binaries for \fIcask\fRs\. For files, also print SHA\-256 checksums\.
-.
+.SS "\fBfetch\fP \fR[\fIoptions\fP] \fIformula\fP|\fIcask\fP \fR[\.\.\.]"
+Download a bottle (if available) or source packages for \fIformula\fPe and binaries for \fIcask\fPs\. For files, also print SHA\-256 checksums\.
+.TP
+\fB\-\-os\fP
+Download for the given operating system\. (Pass \fBall\fP to download for all operating systems\.)
 .TP
-\fB\-\-bottle\-tag\fR
+\fB\-\-arch\fP
+Download for the given CPU architecture\. (Pass \fBall\fP to download for all architectures\.)
+.TP
+\fB\-\-bottle\-tag\fP
 Download a bottle for given tag\.
-.
 .TP
-\fB\-\-HEAD\fR
+\fB\-\-HEAD\fP
 Fetch HEAD version instead of stable version\.
-.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
+\fB\-f\fP, \fB\-\-force\fP
 Remove a previously cached version and re\-fetch\.
-.
 .TP
-\fB\-v\fR, \fB\-\-verbose\fR
+\fB\-v\fP, \fB\-\-verbose\fP
 Do a verbose VCS checkout, if the URL represents a VCS\. This is useful for seeing if an existing VCS cache has been updated\.
-.
 .TP
-\fB\-\-retry\fR
-Retry if downloading fails or re\-download if the checksum of a previously cached version no longer matches\.
-.
+\fB\-\-retry\fP
+Retry if downloading fails or re\-download if the checksum of a previously cached version no longer matches\. Tries at most 5 times with exponential backoff\.
 .TP
-\fB\-\-deps\fR
-Also download dependencies for any listed \fIformula\fR\.
-.
+\fB\-\-deps\fP
+Also download dependencies for any listed \fIformula\fP\&\.
 .TP
-\fB\-s\fR, \fB\-\-build\-from\-source\fR
+\fB\-s\fP, \fB\-\-build\-from\-source\fP
 Download source packages rather than a bottle\.
-.
 .TP
-\fB\-\-build\-bottle\fR
+\fB\-\-build\-bottle\fP
 Download source packages (for eventual bottling) rather than a bottle\.
-.
 .TP
-\fB\-\-force\-bottle\fR
+\fB\-\-force\-bottle\fP
 Download a bottle if it exists for the current or newest version of macOS, even if it would not be used during installation\.
-.
 .TP
-\fB\-\-[no\-]quarantine\fR
+\fB\-\-[no\-]quarantine\fP
 Disable/enable quarantining of downloads (default: enabled)\.
-.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Treat all named arguments as formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Treat all named arguments as casks\.
-.
-.SS "\fBformulae\fR"
+.SS "\fBformulae\fP"
 List all locally installable formulae including short names\.
-.
-.SS "\fBgist\-logs\fR [\fIoptions\fR] \fIformula\fR"
-Upload logs for a failed build of \fIformula\fR to a new Gist\. Presents an error message if no logs are found\.
-.
+.SS "\fBgist\-logs\fP \fR[\fIoptions\fP] \fIformula\fP"
+Upload logs for a failed build of \fIformula\fP to a new Gist\. Presents an error message if no logs are found\.
 .TP
-\fB\-\-with\-hostname\fR
+\fB\-\-with\-hostname\fP
 Include the hostname in the Gist\.
-.
 .TP
-\fB\-n\fR, \fB\-\-new\-issue\fR
+\fB\-n\fP, \fB\-\-new\-issue\fP
 Automatically create a new issue in the appropriate GitHub repository after creating the Gist\.
-.
 .TP
-\fB\-p\fR, \fB\-\-private\fR
+\fB\-p\fP, \fB\-\-private\fP
 The Gist will be marked private and will not appear in listings but will be accessible with its link\.
-.
-.SS "\fBhome\fR, \fBhomepage\fR [\fI\-\-formula\fR] [\fI\-\-cask\fR] [\fIformula\fR|\fIcask\fR \.\.\.]"
-Open a \fIformula\fR or \fIcask\fR\'s homepage in a browser, or open Homebrew\'s own homepage if no argument is provided\.
-.
+.SS "\fBhelp\fP \fR[\fIcommand\fP \.\.\.]"
+Outputs the usage instructions for \fBbrew\fP \fIcommand\fP\&\. Equivalent to \fBbrew \-\-help\fP \fIcommand\fP\&\.
+.SS "\fBhome\fP, \fBhomepage\fP \fR[\fB\-\-formula\fP] \fR[\fB\-\-cask\fP] \fR[\fIformula\fP|\fIcask\fP \.\.\.]"
+Open a \fIformula\fP or \fIcask\fP\[u2019]s homepage in a browser, or open Homebrew\[u2019]s own homepage if no argument is provided\.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Treat all named arguments as formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Treat all named arguments as casks\.
-.
-.SS "\fBinfo\fR, \fBabv\fR [\fIoptions\fR] [\fIformula\fR|\fIcask\fR \.\.\.]"
-Display brief statistics for your Homebrew installation\.
-.
-.P
-If a \fIformula\fR or \fIcask\fR is provided, show summary of information about it\.
-.
+.SS "\fBinfo\fP, \fBabv\fP \fR[\fIoptions\fP] \fR[\fIformula\fP|\fIcask\fP \.\.\.]"
+Display brief statistics for your Homebrew installation\. If a \fIformula\fP or \fIcask\fP is provided, show summary of information about it\.
+.TP
+\fB\-\-analytics\fP
+List global Homebrew analytics data or, if specified, installation and build error data for \fIformula\fP (provided neither \fBHOMEBREW_NO_ANALYTICS\fP nor \fBHOMEBREW_NO_GITHUB_API\fP are set)\.
 .TP
-\fB\-\-analytics\fR
-List global Homebrew analytics data or, if specified, installation and build error data for \fIformula\fR (provided neither \fBHOMEBREW_NO_ANALYTICS\fR nor \fBHOMEBREW_NO_GITHUB_API\fR are set)\.
-.
+\fB\-\-days\fP
+How many days of analytics data to retrieve\. The value for \fIdays\fP must be \fB30\fP, \fB90\fP or \fB365\fP\&\. The default is \fB30\fP\&\.
 .TP
-\fB\-\-days\fR
-How many days of analytics data to retrieve\. The value for \fIdays\fR must be \fB30\fR, \fB90\fR or \fB365\fR\. The default is \fB30\fR\.
-.
+\fB\-\-category\fP
+Which type of analytics data to retrieve\. The value for \fIcategory\fP must be \fBinstall\fP, \fBinstall\-on\-request\fP or \fBbuild\-error\fP; \fBcask\-install\fP or \fBos\-version\fP may be specified if \fIformula\fP is not\. The default is \fBinstall\fP\&\.
 .TP
-\fB\-\-category\fR
-Which type of analytics data to retrieve\. The value for \fIcategory\fR must be \fBinstall\fR, \fBinstall\-on\-request\fR or \fBbuild\-error\fR; \fBcask\-install\fR or \fBos\-version\fR may be specified if \fIformula\fR is not\. The default is \fBinstall\fR\.
-.
+\fB\-\-github\fP
+Open the GitHub source page for \fIformula\fP and \fIcask\fP in a browser\. To view the history locally: \fBbrew log \-p\fP \fIformula\fP or \fIcask\fP
 .TP
-\fB\-\-github\fR
-Open the GitHub source page for \fIformula\fR and \fIcask\fR in a browser\. To view the history locally: \fBbrew log \-p\fR \fIformula\fR or \fIcask\fR
-.
+\fB\-\-fetch\-manifest\fP
+Fetch GitHub Packages manifest for extra information when \fIformula\fP is not installed\.
 .TP
-\fB\-\-json\fR
-Print a JSON representation\. Currently the default value for \fIversion\fR is \fBv1\fR for \fIformula\fR\. For \fIformula\fR and \fIcask\fR use \fBv2\fR\. See the docs for examples of using the JSON output: \fIhttps://docs\.brew\.sh/Querying\-Brew\fR
-.
+\fB\-\-json\fP
+Print a JSON representation\. Currently the default value for \fIversion\fP is \fBv1\fP for \fIformula\fP\&\. For \fIformula\fP and \fIcask\fP use \fBv2\fP\&\. See the docs for examples of using the JSON output: 
+.UR https://docs\.brew\.sh/Querying\-Brew
+.UE
 .TP
-\fB\-\-installed\fR
+\fB\-\-installed\fP
 Print JSON of formulae that are currently installed\.
-.
 .TP
-\fB\-\-all\fR
-Print JSON of all available formulae\.
-.
+\fB\-\-eval\-all\fP
+Evaluate all available formulae and casks, whether installed or not, to print their JSON\. Implied if \fBHOMEBREW_EVAL_ALL\fP is set\.
 .TP
-\fB\-\-variations\fR
-Include the variations hash in each formula\'s JSON output\.
-.
+\fB\-\-variations\fP
+Include the variations hash in each formula\[u2019]s JSON output\.
 .TP
-\fB\-v\fR, \fB\-\-verbose\fR
-Show more verbose analytics data for \fIformula\fR\.
-.
+\fB\-v\fP, \fB\-\-verbose\fP
+Show more verbose analytics data for \fIformula\fP\&\.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Treat all named arguments as formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Treat all named arguments as casks\.
-.
-.SS "\fBinstall\fR [\fIoptions\fR] \fIformula\fR|\fIcask\fR [\.\.\.]"
-Install a \fIformula\fR or \fIcask\fR\. Additional options specific to a \fIformula\fR may be appended to the command\.
-.
+.SS "\fBinstall\fP \fR[\fIoptions\fP] \fIformula\fP|\fIcask\fP \fR[\.\.\.]"
+Install a \fIformula\fP or \fIcask\fP\&\. Additional options specific to a \fIformula\fP may be appended to the command\.
 .P
-Unless \fBHOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK\fR is set, \fBbrew upgrade\fR or \fBbrew reinstall\fR will be run for outdated dependents and dependents with broken linkage, respectively\.
-.
+Unless \fBHOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK\fP is set, \fBbrew upgrade\fP or \fBbrew reinstall\fP will be run for outdated dependents and dependents with broken linkage, respectively\.
 .P
-Unless \fBHOMEBREW_NO_INSTALL_CLEANUP\fR is set, \fBbrew cleanup\fR will then be run for the installed formulae or, every 30 days, for all formulae\.
-.
+Unless \fBHOMEBREW_NO_INSTALL_CLEANUP\fP is set, \fBbrew cleanup\fP will then be run for the installed formulae or, every 30 days, for all formulae\.
 .P
-Unless \fBHOMEBREW_NO_INSTALL_UPGRADE\fR is set, \fBbrew install <formula>\fR will upgrade \fIformula\fR if it is already installed but outdated\.
-.
+Unless \fBHOMEBREW_NO_INSTALL_UPGRADE\fP is set, \fBbrew install\fP \fIformula\fP will upgrade \fIformula\fP if it is already installed but outdated\.
 .TP
-\fB\-d\fR, \fB\-\-debug\fR
+\fB\-d\fP, \fB\-\-debug\fP
 If brewing fails, open an interactive debugging session with access to IRB or a shell inside the temporary build directory\.
-.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
+\fB\-\-display\-times\fP
+Print install times for each package at the end of the run\.
+.TP
+\fB\-f\fP, \fB\-\-force\fP
 Install formulae without checking for previously installed keg\-only or non\-migrated versions\. When installing casks, overwrite existing files (binaries and symlinks are excluded, unless originally from the same cask)\.
-.
 .TP
-\fB\-v\fR, \fB\-\-verbose\fR
-Print the verification and postinstall steps\.
-.
+\fB\-v\fP, \fB\-\-verbose\fP
+Print the verification and post\-install steps\.
+.TP
+\fB\-n\fP, \fB\-\-dry\-run\fP
+Show what would be installed, but do not actually install anything\.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Treat all named arguments as formulae\.
-.
 .TP
-\fB\-\-ignore\-dependencies\fR
-An unsupported Homebrew development flag to skip installing any dependencies of any kind\. If the dependencies are not already present, the formula will have issues\. If you\'re not developing Homebrew, consider adjusting your PATH rather than using this flag\.
-.
+\fB\-\-ignore\-dependencies\fP
+An unsupported Homebrew development option to skip installing any dependencies of any kind\. If the dependencies are not already present, the formula will have issues\. If you\[u2019]re not developing Homebrew, consider adjusting your PATH rather than using this option\.
 .TP
-\fB\-\-only\-dependencies\fR
+\fB\-\-only\-dependencies\fP
 Install the dependencies with specified options but do not install the formula itself\.
-.
 .TP
-\fB\-\-cc\fR
-Attempt to compile using the specified \fIcompiler\fR, which should be the name of the compiler\'s executable, e\.g\. \fBgcc\-7\fR for GCC 7\. In order to use LLVM\'s clang, specify \fBllvm_clang\fR\. To use the Apple\-provided clang, specify \fBclang\fR\. This option will only accept compilers that are provided by Homebrew or bundled with macOS\. Please do not file issues if you encounter errors while using this option\.
-.
+\fB\-\-cc\fP
+Attempt to compile using the specified \fIcompiler\fP, which should be the name of the compiler\[u2019]s executable, e\.g\. \fBgcc\-9\fP for GCC 9\. In order to use LLVM\[u2019]s clang, specify \fBllvm_clang\fP\&\. To use the Apple\-provided clang, specify \fBclang\fP\&\. This option will only accept compilers that are provided by Homebrew or bundled with macOS\. Please do not file issues if you encounter errors while using this option\.
 .TP
-\fB\-s\fR, \fB\-\-build\-from\-source\fR
-Compile \fIformula\fR from source even if a bottle is provided\. Dependencies will still be installed from bottles if they are available\.
-.
+\fB\-s\fP, \fB\-\-build\-from\-source\fP
+Compile \fIformula\fP from source even if a bottle is provided\. Dependencies will still be installed from bottles if they are available\.
 .TP
-\fB\-\-force\-bottle\fR
+\fB\-\-force\-bottle\fP
 Install from a bottle if it exists for the current or newest version of macOS, even if it would not normally be used for installation\.
-.
 .TP
-\fB\-\-include\-test\fR
-Install testing dependencies required to run \fBbrew test\fR \fIformula\fR\.
-.
+\fB\-\-include\-test\fP
+Install testing dependencies required to run \fBbrew test\fP \fIformula\fP\&\.
 .TP
-\fB\-\-HEAD\fR
-If \fIformula\fR defines it, install the HEAD version, aka\. main, trunk, unstable, master\.
-.
+\fB\-\-HEAD\fP
+If \fIformula\fP defines it, install the HEAD version, aka\. main, trunk, unstable, master\.
 .TP
-\fB\-\-fetch\-HEAD\fR
-Fetch the upstream repository to detect if the HEAD installation of the formula is outdated\. Otherwise, the repository\'s HEAD will only be checked for updates when a new stable or development version has been released\.
-.
+\fB\-\-fetch\-HEAD\fP
+Fetch the upstream repository to detect if the HEAD installation of the formula is outdated\. Otherwise, the repository\[u2019]s HEAD will only be checked for updates when a new stable or development version has been released\.
 .TP
-\fB\-\-keep\-tmp\fR
+\fB\-\-keep\-tmp\fP
 Retain the temporary files created during installation\.
-.
 .TP
-\fB\-\-build\-bottle\fR
+\fB\-\-debug\-symbols\fP
+Generate debug symbols on build\. Source will be retained in a cache directory\.
+.TP
+\fB\-\-build\-bottle\fP
 Prepare the formula for eventual bottling during installation, skipping any post\-install steps\.
-.
 .TP
-\fB\-\-bottle\-arch\fR
-Optimise bottles for the specified architecture rather than the oldest architecture supported by the version of macOS the bottles are built on\.
-.
+\fB\-\-skip\-post\-install\fP
+Install but skip any post\-install steps\.
 .TP
-\fB\-\-display\-times\fR
-Print install times for each package at the end of the run\.
-.
+\fB\-\-bottle\-arch\fP
+Optimise bottles for the specified architecture rather than the oldest architecture supported by the version of macOS the bottles are built on\.
 .TP
-\fB\-i\fR, \fB\-\-interactive\fR
-Download and patch \fIformula\fR, then open a shell\. This allows the user to run \fB\./configure \-\-help\fR and otherwise determine how to turn the software package into a Homebrew package\.
-.
+\fB\-i\fP, \fB\-\-interactive\fP
+Download and patch \fIformula\fP, then open a shell\. This allows the user to run \fB\&\./configure \-\-help\fP and otherwise determine how to turn the software package into a Homebrew package\.
 .TP
-\fB\-g\fR, \fB\-\-git\fR
+\fB\-g\fP, \fB\-\-git\fP
 Create a Git repository, useful for creating patches to the software\.
-.
 .TP
-\fB\-\-overwrite\fR
+\fB\-\-overwrite\fP
 Delete files that already exist in the prefix while linking\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Treat all named arguments as casks\.
-.
 .TP
-\fB\-\-[no\-]binaries\fR
+\fB\-\-[no\-]binaries\fP
 Disable/enable linking of helper executables (default: enabled)\.
-.
 .TP
-\fB\-\-require\-sha\fR
+\fB\-\-require\-sha\fP
 Require all casks to have a checksum\.
-.
 .TP
-\fB\-\-[no\-]quarantine\fR
+\fB\-\-[no\-]quarantine\fP
 Disable/enable quarantining of downloads (default: enabled)\.
-.
 .TP
-\fB\-\-skip\-cask\-deps\fR
+\fB\-\-adopt\fP
+Adopt existing artifacts in the destination that are identical to those being installed\. Cannot be combined with \fB\-\-force\fP\&\.
+.TP
+\fB\-\-skip\-cask\-deps\fP
 Skip installing cask dependencies\.
-.
 .TP
-\fB\-\-zap\fR
-For use with \fBbrew reinstall \-\-cask\fR\. Remove all files associated with a cask\. \fIMay remove files which are shared between applications\.\fR
-.
-.SS "\fBleaves\fR [\fI\-\-installed\-on\-request\fR] [\fI\-\-installed\-as\-dependency\fR]"
-List installed formulae that are not dependencies of another installed formula\.
-.
+\fB\-\-zap\fP
+For use with \fBbrew reinstall \-\-cask\fP\&\. Remove all files associated with a cask\. \fIMay remove files which are shared between applications\.\fP
+.SS "\fBleaves\fP \fR[\fB\-\-installed\-on\-request\fP] \fR[\fB\-\-installed\-as\-dependency\fP]"
+List installed formulae that are not dependencies of another installed formula or cask\.
 .TP
-\fB\-r\fR, \fB\-\-installed\-on\-request\fR
+\fB\-r\fP, \fB\-\-installed\-on\-request\fP
 Only list leaves that were manually installed\.
-.
 .TP
-\fB\-p\fR, \fB\-\-installed\-as\-dependency\fR
+\fB\-p\fP, \fB\-\-installed\-as\-dependency\fP
 Only list leaves that were installed as dependencies\.
-.
-.SS "\fBlink\fR, \fBln\fR [\fIoptions\fR] \fIinstalled_formula\fR [\.\.\.]"
-Symlink all of \fIformula\fR\'s installed files into Homebrew\'s prefix\. This is done automatically when you install formulae but can be useful for DIY installations\.
-.
+.SS "\fBlink\fP, \fBln\fP \fR[\fIoptions\fP] \fIinstalled_formula\fP \fR[\.\.\.]"
+Symlink all of \fIformula\fP\[u2019]s installed files into Homebrew\[u2019]s prefix\. This is done automatically when you install formulae but can be useful for manual installations\.
 .TP
-\fB\-\-overwrite\fR
+\fB\-\-overwrite\fP
 Delete files that already exist in the prefix while linking\.
-.
 .TP
-\fB\-n\fR, \fB\-\-dry\-run\fR
-List files which would be linked or deleted by \fBbrew link \-\-overwrite\fR without actually linking or deleting any files\.
-.
+\fB\-n\fP, \fB\-\-dry\-run\fP
+List files which would be linked or deleted by \fBbrew link \-\-overwrite\fP without actually linking or deleting any files\.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
+\fB\-f\fP, \fB\-\-force\fP
 Allow keg\-only formulae to be linked\.
-.
 .TP
-\fB\-\-HEAD\fR
+\fB\-\-HEAD\fP
 Link the HEAD version of the formula if it is installed\.
-.
-.SS "\fBlist\fR, \fBls\fR [\fIoptions\fR] [\fIinstalled_formula\fR|\fIinstalled_cask\fR \.\.\.]"
-List all installed formulae and casks\.
-.
-.P
-If \fIformula\fR is provided, summarise the paths within its current keg\. If \fIcask\fR is provided, list its artifacts\.
-.
+.SS "\fBlist\fP, \fBls\fP \fR[\fIoptions\fP] \fR[\fIinstalled_formula\fP|\fIinstalled_cask\fP \.\.\.]"
+List all installed formulae and casks\. If \fIformula\fP is provided, summarise the paths within its current keg\. If \fIcask\fP is provided, list its artifacts\.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 List only formulae, or treat all named arguments as formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 List only casks, or treat all named arguments as casks\.
-.
 .TP
-\fB\-\-full\-name\fR
-Print formulae with fully\-qualified names\. Unless \fB\-\-full\-name\fR, \fB\-\-versions\fR or \fB\-\-pinned\fR are passed, other options (i\.e\. \fB\-1\fR, \fB\-l\fR, \fB\-r\fR and \fB\-t\fR) are passed to \fBls\fR(1) which produces the actual output\.
-.
+\fB\-\-full\-name\fP
+Print formulae with fully\-qualified names\. Unless \fB\-\-full\-name\fP, \fB\-\-versions\fP or \fB\-\-pinned\fP are passed, other options (i\.e\. \fB\-1\fP, \fB\-l\fP, \fB\-r\fP and \fB\-t\fP) are passed to \fBls\fP(1) which produces the actual output\.
 .TP
-\fB\-\-versions\fR
-Show the version number for installed formulae, or only the specified formulae if \fIformula\fR are provided\.
-.
+\fB\-\-versions\fP
+Show the version number for installed formulae, or only the specified formulae if \fIformula\fP are provided\.
 .TP
-\fB\-\-multiple\fR
+\fB\-\-multiple\fP
 Only show formulae with multiple versions installed\.
-.
 .TP
-\fB\-\-pinned\fR
-List only pinned formulae, or only the specified (pinned) formulae if \fIformula\fR are provided\. See also \fBpin\fR, \fBunpin\fR\.
-.
+\fB\-\-pinned\fP
+List only pinned formulae, or only the specified (pinned) formulae if \fIformula\fP are provided\. See also \fBpin\fP, \fBunpin\fP\&\.
 .TP
-\fB\-1\fR
+\fB\-\-installed\-on\-request\fP
+List the formulae installed on request\.
+.TP
+\fB\-\-installed\-as\-dependency\fP
+List the formulae installed as dependencies\.
+.TP
+\fB\-\-poured\-from\-bottle\fP
+List the formulae installed from a bottle\.
+.TP
+\fB\-\-built\-from\-source\fP
+List the formulae compiled from source\.
+.TP
+\fB\-1\fP
 Force output to be one entry per line\. This is the default when output is not to a terminal\.
-.
 .TP
-\fB\-l\fR
+\fB\-l\fP
 List formulae and/or casks in long format\. Has no effect when a formula or cask name is passed as an argument\.
-.
 .TP
-\fB\-r\fR
+\fB\-r\fP
 Reverse the order of the formulae and/or casks sort to list the oldest entries first\. Has no effect when a formula or cask name is passed as an argument\.
-.
 .TP
-\fB\-t\fR
+\fB\-t\fP
 Sort formulae and/or casks by time modified, listing most recently modified first\. Has no effect when a formula or cask name is passed as an argument\.
-.
-.SS "\fBlog\fR [\fIoptions\fR] [\fIformula\fR|\fIcask\fR]"
-Show the \fBgit log\fR for \fIformula\fR or \fIcask\fR, or show the log for the Homebrew repository if no formula or cask is provided\.
-.
+.SS "\fBlog\fP \fR[\fIoptions\fP] \fR[\fIformula\fP|\fIcask\fP]"
+Show the \fBgit log\fP for \fIformula\fP or \fIcask\fP, or show the log for the Homebrew repository if no formula or cask is provided\.
 .TP
-\fB\-p\fR, \fB\-\-patch\fR
+\fB\-p\fP, \fB\-\-patch\fP
 Also print patch from commit\.
-.
 .TP
-\fB\-\-stat\fR
+\fB\-\-stat\fP
 Also print diffstat from commit\.
-.
 .TP
-\fB\-\-oneline\fR
+\fB\-\-oneline\fP
 Print only one line per commit\.
-.
 .TP
-\fB\-1\fR
+\fB\-1\fP
 Print only one commit\.
-.
 .TP
-\fB\-n\fR, \fB\-\-max\-count\fR
+\fB\-n\fP, \fB\-\-max\-count\fP
 Print only a specified number of commits\.
-.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Treat all named arguments as formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Treat all named arguments as casks\.
-.
-.SS "\fBmigrate\fR [\fI\-\-force\fR] [\fI\-\-dry\-run\fR] \fIinstalled_formula\fR [\.\.\.]"
-Migrate renamed packages to new names, where \fIformula\fR are old names of packages\.
-.
+.SS "\fBmigrate\fP \fR[\fIoptions\fP] \fIinstalled_formula\fP|\fIinstalled_cask\fP \fR[\.\.\.]"
+Migrate renamed packages to new names, where \fIformula\fP are old names of packages\.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
-Treat installed \fIformula\fR and provided \fIformula\fR as if they are from the same taps and migrate them anyway\.
-.
+\fB\-f\fP, \fB\-\-force\fP
+Treat installed \fIformula\fP and provided \fIformula\fP as if they are from the same taps and migrate them anyway\.
 .TP
-\fB\-n\fR, \fB\-\-dry\-run\fR
+\fB\-n\fP, \fB\-\-dry\-run\fP
 Show what would be migrated, but do not actually migrate anything\.
-.
-.SS "\fBmissing\fR [\fI\-\-hide\fR\fB=\fR] [\fIformula\fR \.\.\.]"
-Check the given \fIformula\fR kegs for missing dependencies\. If no \fIformula\fR are provided, check all kegs\. Will exit with a non\-zero status if any kegs are found to be missing dependencies\.
-.
-.TP
-\fB\-\-hide\fR
-Act as if none of the specified \fIhidden\fR are installed\. \fIhidden\fR should be a comma\-separated list of formulae\.
-.
-.SS "\fBoptions\fR [\fIoptions\fR] [\fIformula\fR \.\.\.]"
-Show install options specific to \fIformula\fR\.
-.
-.TP
-\fB\-\-compact\fR
+.TP
+\fB\-\-formula\fP
+Only migrate formulae\.
+.TP
+\fB\-\-cask\fP
+Only migrate casks\.
+.SS "\fBmissing\fP \fR[\fB\-\-hide=\fP] \fR[\fIformula\fP \.\.\.]"
+Check the given \fIformula\fP kegs for missing dependencies\. If no \fIformula\fP are provided, check all kegs\. Will exit with a non\-zero status if any kegs are found to be missing dependencies\.
+.TP
+\fB\-\-hide\fP
+Act as if none of the specified \fIhidden\fP are installed\. \fIhidden\fP should be a comma\-separated list of formulae\.
+.SS "\fBnodenv\-sync\fP"
+Create symlinks for Homebrew\[u2019]s installed NodeJS versions in \fB~/\.nodenv/versions\fP\&\.
+.P
+Note that older version symlinks will also be created so e\.g\. NodeJS 19\.1\.0 will also be symlinked to 19\.0\.0\.
+.SS "\fBoptions\fP \fR[\fIoptions\fP] \fR[\fIformula\fP \.\.\.]"
+Show install options specific to \fIformula\fP\&\.
+.TP
+\fB\-\-compact\fP
 Show all options on a single line separated by spaces\.
-.
 .TP
-\fB\-\-installed\fR
+\fB\-\-installed\fP
 Show options for formulae that are currently installed\.
-.
 .TP
-\fB\-\-all\fR
-Show options for all available formulae\.
-.
+\fB\-\-eval\-all\fP
+Evaluate all available formulae and casks, whether installed or not, to show their options\.
 .TP
-\fB\-\-command\fR
-Show options for the specified \fIcommand\fR\.
-.
-.SS "\fBoutdated\fR [\fIoptions\fR] [\fIformula\fR|\fIcask\fR \.\.\.]"
-List installed casks and formulae that have an updated version available\. By default, version information is displayed in interactive shells, and suppressed otherwise\.
-.
+\fB\-\-command\fP
+Show options for the specified \fIcommand\fP\&\.
+.SS "\fBoutdated\fP \fR[\fIoptions\fP] \fR[\fIformula\fP|\fIcask\fP \.\.\.]"
+List installed casks and formulae that have an updated version available\. By default, version information is displayed in interactive shells and suppressed otherwise\.
 .TP
-\fB\-q\fR, \fB\-\-quiet\fR
-List only the names of outdated kegs (takes precedence over \fB\-\-verbose\fR)\.
-.
+\fB\-q\fP, \fB\-\-quiet\fP
+List only the names of outdated kegs (takes precedence over \fB\-\-verbose\fP)\.
 .TP
-\fB\-v\fR, \fB\-\-verbose\fR
+\fB\-v\fP, \fB\-\-verbose\fP
 Include detailed version information\.
-.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 List only outdated formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 List only outdated casks\.
-.
-.TP
-\fB\-\-json\fR
-Print output in JSON format\. There are two versions: \fBv1\fR and \fBv2\fR\. \fBv1\fR is deprecated and is currently the default if no version is specified\. \fBv2\fR prints outdated formulae and casks\.
-.
-.TP
-\fB\-\-fetch\-HEAD\fR
-Fetch the upstream repository to detect if the HEAD installation of the formula is outdated\. Otherwise, the repository\'s HEAD will only be checked for updates when a new stable or development version has been released\.
-.
-.TP
-\fB\-\-greedy\fR
-Also include outdated casks with \fBauto_updates true\fR or \fBversion :latest\fR\.
-.
-.TP
-\fB\-\-greedy\-latest\fR
-Also include outdated casks including those with \fBversion :latest\fR\.
-.
-.TP
-\fB\-\-greedy\-auto\-updates\fR
-Also include outdated casks including those with \fBauto_updates true\fR\.
-.
-.SS "\fBpin\fR \fIinstalled_formula\fR [\.\.\.]"
-Pin the specified \fIformula\fR, preventing them from being upgraded when issuing the \fBbrew upgrade\fR \fIformula\fR command\. See also \fBunpin\fR\.
-.
-.SS "\fBpostinstall\fR \fIinstalled_formula\fR [\.\.\.]"
-Rerun the post\-install steps for \fIformula\fR\.
-.
-.SS "\fBreadall\fR [\fI\-\-aliases\fR] [\fI\-\-syntax\fR] [\fItap\fR \.\.\.]"
-Import all items from the specified \fItap\fR, or from all installed taps if none is provided\. This can be useful for debugging issues across all items when making significant changes to \fBformula\.rb\fR, testing the performance of loading all items or checking if any current formulae/casks have Ruby issues\.
-.
-.TP
-\fB\-\-aliases\fR
+.TP
+\fB\-\-json\fP
+Print output in JSON format\. There are two versions: \fBv1\fP and \fBv2\fP\&\. \fBv1\fP is deprecated and is currently the default if no version is specified\. \fBv2\fP prints outdated formulae and casks\.
+.TP
+\fB\-\-fetch\-HEAD\fP
+Fetch the upstream repository to detect if the HEAD installation of the formula is outdated\. Otherwise, the repository\[u2019]s HEAD will only be checked for updates when a new stable or development version has been released\.
+.TP
+\fB\-g\fP, \fB\-\-greedy\fP
+Also include outdated casks with \fBauto_updates true\fP or \fBversion :latest\fP\&\.
+.TP
+\fB\-\-greedy\-latest\fP
+Also include outdated casks including those with \fBversion :latest\fP\&\.
+.TP
+\fB\-\-greedy\-auto\-updates\fP
+Also include outdated casks including those with \fBauto_updates true\fP\&\.
+.SS "\fBpin\fP \fIinstalled_formula\fP \fR[\.\.\.]"
+Pin the specified \fIformula\fP, preventing them from being upgraded when issuing the \fBbrew upgrade\fP \fIformula\fP command\. See also \fBunpin\fP\&\.
+.P
+\fINote:\fP Other packages which depend on newer versions of a pinned formula might not install or run correctly\.
+.SS "\fBpostinstall\fP, \fBpost_install\fP \fIinstalled_formula\fP \fR[\.\.\.]"
+Rerun the post\-install steps for \fIformula\fP\&\.
+.SS "\fBpyenv\-sync\fP"
+Create symlinks for Homebrew\[u2019]s installed Python versions in \fB~/\.pyenv/versions\fP\&\.
+.P
+Note that older patch version symlinks will be created and linked to the minor version so e\.g\. Python 3\.11\.0 will also be symlinked to 3\.11\.3\.
+.SS "\fBrbenv\-sync\fP"
+Create symlinks for Homebrew\[u2019]s installed Ruby versions in \fB~/\.rbenv/versions\fP\&\.
+.P
+Note that older version symlinks will also be created so e\.g\. Ruby 3\.2\.1 will also be symlinked to 3\.2\.0\.
+.SS "\fBreadall\fP \fR[\fIoptions\fP] \fR[\fItap\fP \.\.\.]"
+Import all items from the specified \fItap\fP, or from all installed taps if none is provided\. This can be useful for debugging issues across all items when making significant changes to \fBformula\.rb\fP, testing the performance of loading all items or checking if any current formulae/casks have Ruby issues\.
+.TP
+\fB\-\-os\fP
+Read using the given operating system\. (Pass \fBall\fP to simulate all operating systems\.)
+.TP
+\fB\-\-arch\fP
+Read using the given CPU architecture\. (Pass \fBall\fP to simulate all architectures\.)
+.TP
+\fB\-\-aliases\fP
 Verify any alias symlinks in each tap\.
-.
 .TP
-\fB\-\-syntax\fR
-Syntax\-check all of Homebrew\'s Ruby files (if no \fB<tap>\fR is passed)\.
-.
-.SS "\fBreinstall\fR [\fIoptions\fR] \fIformula\fR|\fIcask\fR [\.\.\.]"
-Uninstall and then reinstall a \fIformula\fR or \fIcask\fR using the same options it was originally installed with, plus any appended options specific to a \fIformula\fR\.
-.
+\fB\-\-syntax\fP
+Syntax\-check all of Homebrew\[u2019]s Ruby files (if no \fItap\fP is passed)\.
+.TP
+\fB\-\-eval\-all\fP
+Evaluate all available formulae and casks, whether installed or not\. Implied if \fBHOMEBREW_EVAL_ALL\fP is set\.
+.TP
+\fB\-\-no\-simulate\fP
+Don\[u2019]t simulate other system configurations when checking formulae and casks\.
+.SS "\fBreinstall\fP \fR[\fIoptions\fP] \fIformula\fP|\fIcask\fP \fR[\.\.\.]"
+Uninstall and then reinstall a \fIformula\fP or \fIcask\fP using the same options it was originally installed with, plus any appended options specific to a \fIformula\fP\&\.
 .P
-Unless \fBHOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK\fR is set, \fBbrew upgrade\fR or \fBbrew reinstall\fR will be run for outdated dependents and dependents with broken linkage, respectively\.
-.
+Unless \fBHOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK\fP is set, \fBbrew upgrade\fP or \fBbrew reinstall\fP will be run for outdated dependents and dependents with broken linkage, respectively\.
 .P
-Unless \fBHOMEBREW_NO_INSTALL_CLEANUP\fR is set, \fBbrew cleanup\fR will then be run for the reinstalled formulae or, every 30 days, for all formulae\.
-.
+Unless \fBHOMEBREW_NO_INSTALL_CLEANUP\fP is set, \fBbrew cleanup\fP will then be run for the reinstalled formulae or, every 30 days, for all formulae\.
 .TP
-\fB\-d\fR, \fB\-\-debug\fR
+\fB\-d\fP, \fB\-\-debug\fP
 If brewing fails, open an interactive debugging session with access to IRB or a shell inside the temporary build directory\.
-.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
+\fB\-\-display\-times\fP
+Print install times for each package at the end of the run\.
+.TP
+\fB\-f\fP, \fB\-\-force\fP
 Install without checking for previously installed keg\-only or non\-migrated versions\.
-.
 .TP
-\fB\-v\fR, \fB\-\-verbose\fR
-Print the verification and postinstall steps\.
-.
+\fB\-v\fP, \fB\-\-verbose\fP
+Print the verification and post\-install steps\.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Treat all named arguments as formulae\.
-.
 .TP
-\fB\-s\fR, \fB\-\-build\-from\-source\fR
-Compile \fIformula\fR from source even if a bottle is available\.
-.
+\fB\-s\fP, \fB\-\-build\-from\-source\fP
+Compile \fIformula\fP from source even if a bottle is available\.
 .TP
-\fB\-i\fR, \fB\-\-interactive\fR
-Download and patch \fIformula\fR, then open a shell\. This allows the user to run \fB\./configure \-\-help\fR and otherwise determine how to turn the software package into a Homebrew package\.
-.
+\fB\-i\fP, \fB\-\-interactive\fP
+Download and patch \fIformula\fP, then open a shell\. This allows the user to run \fB\&\./configure \-\-help\fP and otherwise determine how to turn the software package into a Homebrew package\.
 .TP
-\fB\-\-force\-bottle\fR
+\fB\-\-force\-bottle\fP
 Install from a bottle if it exists for the current or newest version of macOS, even if it would not normally be used for installation\.
-.
 .TP
-\fB\-\-keep\-tmp\fR
+\fB\-\-keep\-tmp\fP
 Retain the temporary files created during installation\.
-.
 .TP
-\fB\-\-display\-times\fR
-Print install times for each formula at the end of the run\.
-.
+\fB\-\-debug\-symbols\fP
+Generate debug symbols on build\. Source will be retained in a cache directory\.
 .TP
-\fB\-g\fR, \fB\-\-git\fR
+\fB\-g\fP, \fB\-\-git\fP
 Create a Git repository, useful for creating patches to the software\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Treat all named arguments as casks\.
-.
 .TP
-\fB\-\-[no\-]binaries\fR
+\fB\-\-[no\-]binaries\fP
 Disable/enable linking of helper executables (default: enabled)\.
-.
 .TP
-\fB\-\-require\-sha\fR
+\fB\-\-require\-sha\fP
 Require all casks to have a checksum\.
-.
 .TP
-\fB\-\-[no\-]quarantine\fR
+\fB\-\-[no\-]quarantine\fP
 Disable/enable quarantining of downloads (default: enabled)\.
-.
 .TP
-\fB\-\-skip\-cask\-deps\fR
+\fB\-\-adopt\fP
+Adopt existing artifacts in the destination that are identical to those being installed\. Cannot be combined with \fB\-\-force\fP\&\.
+.TP
+\fB\-\-skip\-cask\-deps\fP
 Skip installing cask dependencies\.
-.
 .TP
-\fB\-\-zap\fR
-For use with \fBbrew reinstall \-\-cask\fR\. Remove all files associated with a cask\. \fIMay remove files which are shared between applications\.\fR
-.
-.SS "\fBsearch\fR, \fB\-S\fR [\fIoptions\fR] \fItext\fR|\fB/\fR\fIregex\fR\fB/\fR [\.\.\.]"
-Perform a substring search of cask tokens and formula names for \fItext\fR\. If \fItext\fR is flanked by slashes, it is interpreted as a regular expression\. The search for \fItext\fR is extended online to \fBhomebrew/core\fR and \fBhomebrew/cask\fR\.
-.
+\fB\-\-zap\fP
+For use with \fBbrew reinstall \-\-cask\fP\&\. Remove all files associated with a cask\. \fIMay remove files which are shared between applications\.\fP
+.SS "\fBsearch\fP, \fB\-S\fP \fR[\fIoptions\fP] \fItext\fP|\fB/\fP\fIregex\fP\fB/\fP \fR[\.\.\.]"
+Perform a substring search of cask tokens and formula names for \fItext\fP\&\. If \fItext\fP is flanked by slashes, it is interpreted as a regular expression\.
+.TP
+\fB\-\-formula\fP
+Search for formulae\.
 .TP
-\fB\-\-formula\fR
-Search online and locally for formulae\.
-.
+\fB\-\-cask\fP
+Search for casks\.
 .TP
-\fB\-\-cask\fR
-Search online and locally for casks\.
-.
+\fB\-\-desc\fP
+Search for formulae with a description matching \fItext\fP and casks with a name or description matching \fItext\fP\&\.
 .TP
-\fB\-\-desc\fR
-Search for formulae with a description matching \fItext\fR and casks with a name or description matching \fItext\fR\.
-.
+\fB\-\-eval\-all\fP
+Evaluate all available formulae and casks, whether installed or not, to search their descriptions\. Implied if \fBHOMEBREW_EVAL_ALL\fP is set\.
 .TP
-\fB\-\-pull\-request\fR
-Search for GitHub pull requests containing \fItext\fR\.
-.
+\fB\-\-pull\-request\fP
+Search for GitHub pull requests containing \fItext\fP\&\.
 .TP
-\fB\-\-open\fR
+\fB\-\-open\fP
 Search for only open GitHub pull requests\.
-.
 .TP
-\fB\-\-closed\fR
+\fB\-\-closed\fP
 Search for only closed GitHub pull requests\.
-.
 .TP
-\fB\-\-repology\fR
-Search for \fItext\fR in the given database\.
-.
+\fB\-\-repology\fP
+Search for \fItext\fP in the given database\.
 .TP
-\fB\-\-macports\fR
-Search for \fItext\fR in the given database\.
-.
+\fB\-\-macports\fP
+Search for \fItext\fP in the given database\.
 .TP
-\fB\-\-fink\fR
-Search for \fItext\fR in the given database\.
-.
+\fB\-\-fink\fP
+Search for \fItext\fP in the given database\.
 .TP
-\fB\-\-opensuse\fR
-Search for \fItext\fR in the given database\.
-.
+\fB\-\-opensuse\fP
+Search for \fItext\fP in the given database\.
 .TP
-\fB\-\-fedora\fR
-Search for \fItext\fR in the given database\.
-.
+\fB\-\-fedora\fP
+Search for \fItext\fP in the given database\.
 .TP
-\fB\-\-archlinux\fR
-Search for \fItext\fR in the given database\.
-.
+\fB\-\-archlinux\fP
+Search for \fItext\fP in the given database\.
 .TP
-\fB\-\-debian\fR
-Search for \fItext\fR in the given database\.
-.
+\fB\-\-debian\fP
+Search for \fItext\fP in the given database\.
 .TP
-\fB\-\-ubuntu\fR
-Search for \fItext\fR in the given database\.
-.
-.SS "\fBshellenv\fR"
-Print export statements\. When run in a shell, this installation of Homebrew will be added to your \fBPATH\fR, \fBMANPATH\fR, and \fBINFOPATH\fR\.
-.
+\fB\-\-ubuntu\fP
+Search for \fItext\fP in the given database\.
+.SS "\fBsetup\-ruby\fP \fR[\fIcommand\fP \.\.\.]"
+Installs and configures Homebrew\[u2019]s Ruby\. If \fBcommand\fP is passed, it will only run Bundler if necessary for that command\.
+.SS "\fBshellenv\fP \fR[\fIshell\fP \.\.\.]"
+Valid shells: bash|csh|fish|pwsh|sh|tcsh|zsh
 .P
-The variables \fBHOMEBREW_PREFIX\fR, \fBHOMEBREW_CELLAR\fR and \fBHOMEBREW_REPOSITORY\fR are also exported to avoid querying them multiple times\. To help guarantee idempotence, this command produces no output when Homebrew\'s \fBbin\fR and \fBsbin\fR directories are first and second respectively in your \fBPATH\fR\. Consider adding evaluation of this command\'s output to your dotfiles (e\.g\. \fB~/\.profile\fR, \fB~/\.bash_profile\fR, or \fB~/\.zprofile\fR) with: \fBeval "$(brew shellenv)"\fR
-.
-.SS "\fBtap\fR [\fIoptions\fR] [\fIuser\fR\fB/\fR\fIrepo\fR] [\fIURL\fR]"
-Tap a formula repository\.
-.
+Print export statements\. When run in a shell, this installation of Homebrew will be added to your \fBPATH\fP, \fBMANPATH\fP, and \fBINFOPATH\fP\&\.
 .P
-If no arguments are provided, list all installed taps\.
-.
+The variables \fBHOMEBREW_PREFIX\fP, \fBHOMEBREW_CELLAR\fP and \fBHOMEBREW_REPOSITORY\fP are also exported to avoid querying them multiple times\. To help guarantee idempotence, this command produces no output when Homebrew\[u2019]s \fBbin\fP and \fBsbin\fP directories are first and second respectively in your \fBPATH\fP\&\. Consider adding evaluation of this command\[u2019]s output to your dotfiles (e\.g\. \fB~/\.bash_profile\fP or \fB~/\.zprofile\fP on macOS and \fB~/\.bashrc\fP or \fB~/\.zshrc\fP on Linux) with: \fBeval "$(brew shellenv)"\fP
 .P
-With \fIURL\fR unspecified, tap a formula repository from GitHub using HTTPS\. Since so many taps are hosted on GitHub, this command is a shortcut for \fBbrew tap\fR \fIuser\fR\fB/\fR\fIrepo\fR \fBhttps://github\.com/\fR\fIuser\fR\fB/homebrew\-\fR\fIrepo\fR\.
-.
+The shell can be specified explicitly with a supported shell name parameter\. Unknown shells will output POSIX exports\.
+.SS "\fBtab\fP \fR[\fIoptions\fP] \fIinstalled_formula\fP|\fIinstalled_cask\fP \fR[\.\.\.]"
+Edit tab information for installed formulae or casks\.
 .P
-With \fIURL\fR specified, tap a formula repository from anywhere, using any transport protocol that \fBgit\fR(1) handles\. The one\-argument form of \fBtap\fR simplifies but also limits\. This two\-argument command makes no assumptions, so taps can be cloned from places other than GitHub and using protocols other than HTTPS, e\.g\. SSH, git, HTTP, FTP(S), rsync\.
-.
+This can be useful when you want to control whether an installed formula should be removed by \fBbrew autoremove\fP\&\. To prevent removal, mark the formula as installed on request; to allow removal, mark the formula as not installed on request\.
+.TP
+\fB\-\-installed\-on\-request\fP
+Mark \fIinstalled_formula\fP or \fIinstalled_cask\fP as installed on request\.
 .TP
-\fB\-\-[no\-]force\-auto\-update\fR
-Auto\-update tap even if it is not hosted on GitHub\. By default, only taps hosted on GitHub are auto\-updated (for performance reasons)\.
-.
+\fB\-\-no\-installed\-on\-request\fP
+Mark \fIinstalled_formula\fP or \fIinstalled_cask\fP as not installed on request\.
+.TP
+\fB\-\-formula\fP
+Only mark formulae\.
+.TP
+\fB\-\-cask\fP
+Only mark casks\.
+.SS "\fBtap\fP \fR[\fIoptions\fP] \fR[\fIuser\fP\fB/\fP\fIrepo\fP] \fR[\fIURL\fP]"
+Tap a formula repository\. If no arguments are provided, list all installed taps\.
+.P
+With \fIURL\fP unspecified, tap a formula repository from GitHub using HTTPS\. Since so many taps are hosted on GitHub, this command is a shortcut for \fBbrew tap\fP \fIuser\fP\fB/\fP\fIrepo\fP \fBhttps://github\.com/\fP\fIuser\fP\fB/homebrew\-\fP\fIrepo\fP\&\.
+.P
+With \fIURL\fP specified, tap a formula repository from anywhere, using any transport protocol that \fBgit\fP(1) handles\. The one\-argument form of \fBtap\fP simplifies but also limits\. This two\-argument command makes no assumptions, so taps can be cloned from places other than GitHub and using protocols other than HTTPS, e\.g\. SSH, git, HTTP, FTP(S), rsync\.
 .TP
-\fB\-\-custom\-remote\fR
+\fB\-\-custom\-remote\fP
 Install or change a tap with a custom remote\. Useful for mirrors\.
-.
 .TP
-\fB\-\-repair\fR
+\fB\-\-repair\fP
 Migrate tapped formulae from symlink\-based to directory\-based structure\.
-.
 .TP
-\fB\-\-list\-pinned\fR
-List all pinned taps\.
-.
-.SS "\fBtap\-info\fR [\fI\-\-installed\fR] [\fI\-\-json\fR] [\fItap\fR \.\.\.]"
-Show detailed information about one or more \fItap\fRs\.
-.
-.P
-If no \fItap\fR names are provided, display brief statistics for all installed taps\.
-.
+\fB\-\-eval\-all\fP
+Evaluate all the formulae, casks and aliases in the new tap to check validity\. Implied if \fBHOMEBREW_EVAL_ALL\fP is set\.
+.TP
+\fB\-\-force\fP
+Force install core taps even under API mode\.
+.SS "\fBtap\-info\fP \fR[\fB\-\-installed\fP] \fR[\fB\-\-json\fP] \fR[\fItap\fP \.\.\.]"
+Show detailed information about one or more \fItap\fPs\. If no \fItap\fP names are provided, display brief statistics for all installed taps\.
 .TP
-\fB\-\-installed\fR
+\fB\-\-installed\fP
 Show information on each installed tap\.
-.
 .TP
-\fB\-\-json\fR
-Print a JSON representation of \fItap\fR\. Currently the default and only accepted value for \fIversion\fR is \fBv1\fR\. See the docs for examples of using the JSON output: \fIhttps://docs\.brew\.sh/Querying\-Brew\fR
-.
-.SS "\fBuninstall\fR, \fBremove\fR, \fBrm\fR [\fIoptions\fR] \fIinstalled_formula\fR|\fIinstalled_cask\fR [\.\.\.]"
-Uninstall a \fIformula\fR or \fIcask\fR\.
-.
+\fB\-\-json\fP
+Print a JSON representation of \fItap\fP\&\. Currently the default and only accepted value for \fIversion\fP is \fBv1\fP\&\. See the docs for examples of using the JSON output: 
+.UR https://docs\.brew\.sh/Querying\-Brew
+.UE
+.SS "\fBuninstall\fP, \fBremove\fP, \fBrm\fP \fR[\fIoptions\fP] \fIinstalled_formula\fP|\fIinstalled_cask\fP \fR[\.\.\.]"
+Uninstall a \fIformula\fP or \fIcask\fP\&\.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
-Delete all installed versions of \fIformula\fR\. Uninstall even if \fIcask\fR is not installed, overwrite existing files and ignore errors when removing files\.
-.
+\fB\-f\fP, \fB\-\-force\fP
+Delete all installed versions of \fIformula\fP\&\. Uninstall even if \fIcask\fP is not installed, overwrite existing files and ignore errors when removing files\.
 .TP
-\fB\-\-zap\fR
-Remove all files associated with a \fIcask\fR\. \fIMay remove files which are shared between applications\.\fR
-.
+\fB\-\-zap\fP
+Remove all files associated with a \fIcask\fP\&\. \fIMay remove files which are shared between applications\.\fP
 .TP
-\fB\-\-ignore\-dependencies\fR
-Don\'t fail uninstall, even if \fIformula\fR is a dependency of any installed formulae\.
-.
+\fB\-\-ignore\-dependencies\fP
+Don\[u2019]t fail uninstall, even if \fIformula\fP is a dependency of any installed formulae\.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Treat all named arguments as formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Treat all named arguments as casks\.
-.
-.SS "\fBunlink\fR [\fI\-\-dry\-run\fR] \fIinstalled_formula\fR [\.\.\.]"
-Remove symlinks for \fIformula\fR from Homebrew\'s prefix\. This can be useful for temporarily disabling a formula: \fBbrew unlink\fR \fIformula\fR \fB&&\fR \fIcommands\fR \fB&& brew link\fR \fIformula\fR
-.
+.SS "\fBunlink\fP \fR[\fB\-\-dry\-run\fP] \fIinstalled_formula\fP \fR[\.\.\.]"
+Remove symlinks for \fIformula\fP from Homebrew\[u2019]s prefix\. This can be useful for temporarily disabling a formula: \fBbrew unlink\fP \fIformula\fP \fB&&\fP \fIcommands\fP \fB&& brew link\fP \fIformula\fP
 .TP
-\fB\-n\fR, \fB\-\-dry\-run\fR
+\fB\-n\fP, \fB\-\-dry\-run\fP
 List files which would be unlinked without actually unlinking or deleting any files\.
-.
-.SS "\fBunpin\fR \fIinstalled_formula\fR [\.\.\.]"
-Unpin \fIformula\fR, allowing them to be upgraded by \fBbrew upgrade\fR \fIformula\fR\. See also \fBpin\fR\.
-.
-.SS "\fBuntap\fR [\fI\-\-force\fR] \fItap\fR [\.\.\.]"
+.SS "\fBunpin\fP \fIinstalled_formula\fP \fR[\.\.\.]"
+Unpin \fIformula\fP, allowing them to be upgraded by \fBbrew upgrade\fP \fIformula\fP\&\. See also \fBpin\fP\&\.
+.SS "\fBuntap\fP \fR[\fB\-\-force\fP] \fItap\fP \fR[\.\.\.]"
 Remove a tapped formula repository\.
-.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
+\fB\-f\fP, \fB\-\-force\fP
 Untap even if formulae or casks from this tap are currently installed\.
-.
-.SS "\fBupdate\fR [\fIoptions\fR]"
-Fetch the newest version of Homebrew and all formulae from GitHub using \fBgit\fR(1) and perform any necessary migrations\.
-.
+.SS "\fBupdate\fP, \fBup\fP \fR[\fIoptions\fP]"
+Fetch the newest version of Homebrew and all formulae from GitHub using \fBgit\fP(1) and perform any necessary migrations\.
 .TP
-\fB\-\-merge\fR
-Use \fBgit merge\fR to apply updates (rather than \fBgit rebase\fR)\.
-.
+\fB\-\-merge\fP
+Use \fBgit merge\fP to apply updates (rather than \fBgit rebase\fP)\.
 .TP
-\fB\-\-auto\-update\fR
-Run on auto\-updates (e\.g\. before \fBbrew install\fR)\. Skips some slower steps\.
-.
+\fB\-\-auto\-update\fP
+Run on auto\-updates (e\.g\. before \fBbrew install\fP)\. Skips some slower steps\.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
+\fB\-f\fP, \fB\-\-force\fP
 Always do a slower, full update check (even if unnecessary)\.
-.
-.SS "\fBupdate\-reset\fR [\fIrepository\fR \.\.\.]"
-Fetch and reset Homebrew and all tap repositories (or any specified \fIrepository\fR) using \fBgit\fR(1) to their latest \fBorigin/HEAD\fR\.
-.
+.TP
+\fB\-v\fP, \fB\-\-verbose\fP
+Print the directories checked and \fBgit\fP operations performed\.
+.TP
+\fB\-d\fP, \fB\-\-debug\fP
+Display a trace of all shell commands as they are executed\.
+.SS "\fBupdate\-reset\fP \fR[\fIrepository\fP \.\.\.]"
+Fetch and reset Homebrew and all tap repositories (or any specified \fIrepository\fP) using \fBgit\fP(1) to their latest \fBorigin/HEAD\fP\&\.
 .P
-\fINote:\fR this will destroy all your uncommitted or committed changes\.
-.
-.SS "\fBupgrade\fR [\fIoptions\fR] [\fIoutdated_formula\fR|\fIoutdated_cask\fR \.\.\.]"
-Upgrade outdated casks and outdated, unpinned formulae using the same options they were originally installed with, plus any appended brew formula options\. If \fIcask\fR or \fIformula\fR are specified, upgrade only the given \fIcask\fR or \fIformula\fR kegs (unless they are pinned; see \fBpin\fR, \fBunpin\fR)\.
-.
+\fINote:\fP this will destroy all your uncommitted or committed changes\.
+.SS "\fBupgrade\fP \fR[\fIoptions\fP] \fR[\fIinstalled_formula\fP|\fIinstalled_cask\fP \.\.\.]"
+Upgrade outdated casks and outdated, unpinned formulae using the same options they were originally installed with, plus any appended brew formula options\. If \fIcask\fP or \fIformula\fP are specified, upgrade only the given \fIcask\fP or \fIformula\fP kegs (unless they are pinned; see \fBpin\fP, \fBunpin\fP)\.
 .P
-Unless \fBHOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK\fR is set, \fBbrew upgrade\fR or \fBbrew reinstall\fR will be run for outdated dependents and dependents with broken linkage, respectively\.
-.
+Unless \fBHOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK\fP is set, \fBbrew upgrade\fP or \fBbrew reinstall\fP will be run for outdated dependents and dependents with broken linkage, respectively\.
 .P
-Unless \fBHOMEBREW_NO_INSTALL_CLEANUP\fR is set, \fBbrew cleanup\fR will then be run for the upgraded formulae or, every 30 days, for all formulae\.
-.
+Unless \fBHOMEBREW_NO_INSTALL_CLEANUP\fP is set, \fBbrew cleanup\fP will then be run for the upgraded formulae or, every 30 days, for all formulae\.
 .TP
-\fB\-d\fR, \fB\-\-debug\fR
+\fB\-d\fP, \fB\-\-debug\fP
 If brewing fails, open an interactive debugging session with access to IRB or a shell inside the temporary build directory\.
-.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
+\fB\-\-display\-times\fP
+Print install times for each package at the end of the run\.
+.TP
+\fB\-f\fP, \fB\-\-force\fP
 Install formulae without checking for previously installed keg\-only or non\-migrated versions\. When installing casks, overwrite existing files (binaries and symlinks are excluded, unless originally from the same cask)\.
-.
 .TP
-\fB\-v\fR, \fB\-\-verbose\fR
-Print the verification and postinstall steps\.
-.
+\fB\-v\fP, \fB\-\-verbose\fP
+Print the verification and post\-install steps\.
 .TP
-\fB\-n\fR, \fB\-\-dry\-run\fR
+\fB\-n\fP, \fB\-\-dry\-run\fP
 Show what would be upgraded, but do not actually upgrade anything\.
-.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Treat all named arguments as formulae\. If no named arguments are specified, upgrade only outdated formulae\.
-.
 .TP
-\fB\-s\fR, \fB\-\-build\-from\-source\fR
-Compile \fIformula\fR from source even if a bottle is available\.
-.
+\fB\-s\fP, \fB\-\-build\-from\-source\fP
+Compile \fIformula\fP from source even if a bottle is available\.
 .TP
-\fB\-i\fR, \fB\-\-interactive\fR
-Download and patch \fIformula\fR, then open a shell\. This allows the user to run \fB\./configure \-\-help\fR and otherwise determine how to turn the software package into a Homebrew package\.
-.
+\fB\-i\fP, \fB\-\-interactive\fP
+Download and patch \fIformula\fP, then open a shell\. This allows the user to run \fB\&\./configure \-\-help\fP and otherwise determine how to turn the software package into a Homebrew package\.
 .TP
-\fB\-\-force\-bottle\fR
+\fB\-\-force\-bottle\fP
 Install from a bottle if it exists for the current or newest version of macOS, even if it would not normally be used for installation\.
-.
-.TP
-\fB\-\-fetch\-HEAD\fR
-Fetch the upstream repository to detect if the HEAD installation of the formula is outdated\. Otherwise, the repository\'s HEAD will only be checked for updates when a new stable or development version has been released\.
-.
 .TP
-\fB\-\-ignore\-pinned\fR
-Set a successful exit status even if pinned formulae are not upgraded\.
-.
+\fB\-\-fetch\-HEAD\fP
+Fetch the upstream repository to detect if the HEAD installation of the formula is outdated\. Otherwise, the repository\[u2019]s HEAD will only be checked for updates when a new stable or development version has been released\.
 .TP
-\fB\-\-keep\-tmp\fR
+\fB\-\-keep\-tmp\fP
 Retain the temporary files created during installation\.
-.
 .TP
-\fB\-\-display\-times\fR
-Print install times for each package at the end of the run\.
-.
+\fB\-\-debug\-symbols\fP
+Generate debug symbols on build\. Source will be retained in a cache directory\.
 .TP
-\fB\-\-cask\fR
+\fB\-\-overwrite\fP
+Delete files that already exist in the prefix while linking\.
+.TP
+\fB\-\-cask\fP
 Treat all named arguments as casks\. If no named arguments are specified, upgrade only outdated casks\.
-.
 .TP
-\fB\-\-[no\-]binaries\fR
-Disable/enable linking of helper executables (default: enabled)\.
-.
+\fB\-\-skip\-cask\-deps\fP
+Skip installing cask dependencies\.
 .TP
-\fB\-\-require\-sha\fR
-Require all casks to have a checksum\.
-.
+\fB\-g\fP, \fB\-\-greedy\fP
+Also include casks with \fBauto_updates true\fP or \fBversion :latest\fP\&\.
 .TP
-\fB\-\-[no\-]quarantine\fR
-Disable/enable quarantining of downloads (default: enabled)\.
-.
+\fB\-\-greedy\-latest\fP
+Also include casks with \fBversion :latest\fP\&\.
 .TP
-\fB\-\-skip\-cask\-deps\fR
-Skip installing cask dependencies\.
-.
+\fB\-\-greedy\-auto\-updates\fP
+Also include casks with \fBauto_updates true\fP\&\.
 .TP
-\fB\-\-greedy\fR
-Also include casks with \fBauto_updates true\fR or \fBversion :latest\fR\.
-.
+\fB\-\-[no\-]binaries\fP
+Disable/enable linking of helper executables (default: enabled)\.
 .TP
-\fB\-\-greedy\-latest\fR
-Also include casks with \fBversion :latest\fR\.
-.
+\fB\-\-require\-sha\fP
+Require all casks to have a checksum\.
 .TP
-\fB\-\-greedy\-auto\-updates\fR
-Also include casks with \fBauto_updates true\fR\.
-.
-.SS "\fBuses\fR [\fIoptions\fR] \fIformula\fR [\.\.\.]"
-Show formulae and casks that specify \fIformula\fR as a dependency; that is, show dependents of \fIformula\fR\. When given multiple formula arguments, show the intersection of formulae that use \fIformula\fR\. By default, \fBuses\fR shows all formulae and casks that specify \fIformula\fR as a required or recommended dependency for their stable builds\.
-.
+\fB\-\-[no\-]quarantine\fP
+Disable/enable quarantining of downloads (default: enabled)\.
+.SS "\fBuses\fP \fR[\fIoptions\fP] \fIformula\fP \fR[\.\.\.]"
+Show formulae and casks that specify \fIformula\fP as a dependency; that is, show dependents of \fIformula\fP\&\. When given multiple formula arguments, show the intersection of formulae that use \fIformula\fP\&\. By default, \fBuses\fP shows all formulae and casks that specify \fIformula\fP as a required or recommended dependency for their stable builds\.
+.P
+\fINote:\fP \fB\-\-missing\fP and \fB\-\-skip\-recommended\fP have precedence over \fB\-\-include\-*\fP\&\.
 .TP
-\fB\-\-recursive\fR
+\fB\-\-recursive\fP
 Resolve more than one level of dependencies\.
-.
 .TP
-\fB\-\-installed\fR
+\fB\-\-installed\fP
 Only list formulae and casks that are currently installed\.
-.
 .TP
-\fB\-\-include\-build\fR
-Include all formulae that specify \fIformula\fR as \fB:build\fR type dependency\.
-.
+\fB\-\-missing\fP
+Only list formulae and casks that are not currently installed\.
 .TP
-\fB\-\-include\-test\fR
-Include all formulae that specify \fIformula\fR as \fB:test\fR type dependency\.
-.
+\fB\-\-eval\-all\fP
+Evaluate all available formulae and casks, whether installed or not, to show their dependents\.
 .TP
-\fB\-\-include\-optional\fR
-Include all formulae that specify \fIformula\fR as \fB:optional\fR type dependency\.
-.
+\fB\-\-include\-build\fP
+Include formulae that specify \fIformula\fP as a \fB:build\fP dependency\.
 .TP
-\fB\-\-skip\-recommended\fR
-Skip all formulae that specify \fIformula\fR as \fB:recommended\fR type dependency\.
-.
+\fB\-\-include\-test\fP
+Include formulae that specify \fIformula\fP as a \fB:test\fP dependency\.
 .TP
-\fB\-\-formula\fR
+\fB\-\-include\-optional\fP
+Include formulae that specify \fIformula\fP as an \fB:optional\fP dependency\.
+.TP
+\fB\-\-skip\-recommended\fP
+Skip all formulae that specify \fIformula\fP as a \fB:recommended\fP dependency\.
+.TP
+\fB\-\-formula\fP
 Include only formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Include only casks\.
-.
-.SS "\fB\-\-cache\fR [\fIoptions\fR] [\fIformula\fR|\fIcask\fR \.\.\.]"
-Display Homebrew\'s download cache\. See also \fBHOMEBREW_CACHE\fR\.
-.
+.SS "\fB\-\-cache\fP \fR[\fIoptions\fP] \fR[\fIformula\fP|\fIcask\fP \.\.\.]"
+Display Homebrew\[u2019]s download cache\. See also \fBHOMEBREW_CACHE\fP\&\.
 .P
-If \fIformula\fR is provided, display the file or directory used to cache \fIformula\fR\.
-.
+If a \fIformula\fP or \fIcask\fP is provided, display the file or directory used to cache it\.
+.TP
+\fB\-\-os\fP
+Show cache file for the given operating system\. (Pass \fBall\fP to show cache files for all operating systems\.)
 .TP
-\fB\-s\fR, \fB\-\-build\-from\-source\fR
+\fB\-\-arch\fP
+Show cache file for the given CPU architecture\. (Pass \fBall\fP to show cache files for all architectures\.)
+.TP
+\fB\-s\fP, \fB\-\-build\-from\-source\fP
 Show the cache file used when building from source\.
-.
 .TP
-\fB\-\-force\-bottle\fR
+\fB\-\-force\-bottle\fP
 Show the cache file used when pouring a bottle\.
-.
 .TP
-\fB\-\-bottle\-tag\fR
+\fB\-\-bottle\-tag\fP
 Show the cache file used when pouring a bottle for the given tag\.
-.
 .TP
-\fB\-\-HEAD\fR
+\fB\-\-HEAD\fP
 Show the cache file used when building from HEAD\.
-.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Only show cache files for formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Only show cache files for casks\.
-.
-.SS "\fB\-\-caskroom\fR [\fIcask\fR \.\.\.]"
-Display Homebrew\'s Caskroom path\.
-.
-.P
-If \fIcask\fR is provided, display the location in the Caskroom where \fIcask\fR would be installed, without any sort of versioned directory as the last path\.
-.
-.SS "\fB\-\-cellar\fR [\fIformula\fR \.\.\.]"
-Display Homebrew\'s Cellar path\. \fIDefault:\fR \fB$(brew \-\-prefix)/Cellar\fR, or if that directory doesn\'t exist, \fB$(brew \-\-repository)/Cellar\fR\.
-.
-.P
-If \fIformula\fR is provided, display the location in the Cellar where \fIformula\fR would be installed, without any sort of versioned directory as the last path\.
-.
-.SS "\fB\-\-env\fR, \fBenvironment\fR [\fI\-\-shell\fR\fB=\fR] [\fI\-\-plain\fR] [\fIformula\fR \.\.\.]"
-Summarise Homebrew\'s build environment as a plain list\.
-.
-.P
-If the command\'s output is sent through a pipe and no shell is specified, the list is formatted for export to \fBbash\fR(1) unless \fB\-\-plain\fR is passed\.
-.
-.TP
-\fB\-\-shell\fR
-Generate a list of environment variables for the specified shell, or \fB\-\-shell=auto\fR to detect the current shell\.
-.
-.TP
-\fB\-\-plain\fR
+.SS "\fB\-\-caskroom\fP \fR[\fIcask\fP \.\.\.]"
+Display Homebrew\[u2019]s Caskroom path\.
+.P
+If \fIcask\fP is provided, display the location in the Caskroom where \fIcask\fP would be installed, without any sort of versioned directory as the last path\.
+.SS "\fB\-\-cellar\fP \fR[\fIformula\fP \.\.\.]"
+Display Homebrew\[u2019]s Cellar path\. \fIDefault:\fP \fB$(brew \-\-prefix)/Cellar\fP, or if that directory doesn\[u2019]t exist, \fB$(brew \-\-repository)/Cellar\fP\&\.
+.P
+If \fIformula\fP is provided, display the location in the Cellar where \fIformula\fP would be installed, without any sort of versioned directory as the last path\.
+.SS "\fB\-\-env\fP, \fBenvironment\fP \fR[\fB\-\-shell=\fP] \fR[\fB\-\-plain\fP] \fR[\fIformula\fP \.\.\.]"
+Summarise Homebrew\[u2019]s build environment as a plain list\.
+.P
+If the command\[u2019]s output is sent through a pipe and no shell is specified, the list is formatted for export to \fBbash\fP(1) unless \fB\-\-plain\fP is passed\.
+.TP
+\fB\-\-shell\fP
+Generate a list of environment variables for the specified shell, or \fB\-\-shell=auto\fP to detect the current shell\.
+.TP
+\fB\-\-plain\fP
 Generate plain output even when piped\.
-.
-.SS "\fB\-\-prefix\fR [\fI\-\-unbrewed\fR] [\fI\-\-installed\fR] [\fIformula\fR \.\.\.]"
-Display Homebrew\'s install path\. \fIDefault:\fR
-.
-.IP "\(bu" 4
-macOS Intel: \fB/usr/local\fR
-.
-.IP "\(bu" 4
-macOS ARM: \fB/opt/homebrew\fR
-.
-.IP "\(bu" 4
-Linux: \fB/home/linuxbrew/\.linuxbrew\fR
-.
-.IP "" 0
-.
-.P
-If \fIformula\fR is provided, display the location where \fIformula\fR is or would be installed\.
-.
-.TP
-\fB\-\-unbrewed\fR
-List files in Homebrew\'s prefix not installed by Homebrew\.
-.
-.TP
-\fB\-\-installed\fR
-Outputs nothing and returns a failing status code if \fIformula\fR is not installed\.
-.
-.SS "\fB\-\-repository\fR, \fB\-\-repo\fR [\fItap\fR \.\.\.]"
-Display where Homebrew\'s git repository is located\.
-.
-.P
-If \fIuser\fR\fB/\fR\fIrepo\fR are provided, display where tap \fIuser\fR\fB/\fR\fIrepo\fR\'s directory is located\.
-.
-.SS "\fB\-\-version\fR, \fB\-v\fR"
+.SS "\fB\-\-prefix\fP \fR[\fB\-\-unbrewed\fP] \fR[\fB\-\-installed\fP] \fR[\fIformula\fP \.\.\.]"
+Display Homebrew\[u2019]s install path\. \fIDefault:\fP
+.IP \(bu 4
+macOS ARM: \fB/opt/homebrew\fP
+.IP \(bu 4
+macOS Intel: \fB/usr/local\fP
+.IP \(bu 4
+Linux: \fB/home/linuxbrew/\.linuxbrew\fP
+.P
+If \fIformula\fP is provided, display the location where \fIformula\fP is or would be installed\.
+.TP
+\fB\-\-unbrewed\fP
+List files in Homebrew\[u2019]s prefix not installed by Homebrew\.
+.TP
+\fB\-\-installed\fP
+Outputs nothing and returns a failing status code if \fIformula\fP is not installed\.
+.SS "\fB\-\-repository\fP, \fB\-\-repo\fP \fR[\fItap\fP \.\.\.]"
+Display where Homebrew\[u2019]s Git repository is located\.
+.P
+If \fIuser\fP\fB/\fP\fIrepo\fP are provided, display where tap \fIuser\fP\fB/\fP\fIrepo\fP\[u2019]s directory is located\.
+.SS "\fB\-\-version\fP, \fB\-v\fP"
 Print the version numbers of Homebrew, Homebrew/homebrew\-core and Homebrew/homebrew\-cask (if tapped) to standard output\.
-.
 .SH "DEVELOPER COMMANDS"
-.
-.SS "\fBaudit\fR [\fIoptions\fR] [\fIformula\fR|\fIcask\fR \.\.\.]"
-Check \fIformula\fR for Homebrew coding style violations\. This should be run before submitting a new formula or cask\. If no \fIformula\fR|\fIcask\fR are provided, check all locally available formulae and casks and skip style checks\. Will exit with a non\-zero status if any errors are found\.
-.
+.SS "\fBaudit\fP \fR[\fIoptions\fP] \fR[\fIformula\fP|\fIcask\fP \.\.\.]"
+Check \fIformula\fP for Homebrew coding style violations\. This should be run before submitting a new formula or cask\. If no \fIformula\fP|\fIcask\fP are provided, check all locally available formulae and casks and skip style checks\. Will exit with a non\-zero status if any errors are found\.
 .TP
-\fB\-\-strict\fR
+\fB\-\-os\fP
+Audit the given operating system\. (Pass \fBall\fP to audit all operating systems\.)
+.TP
+\fB\-\-arch\fP
+Audit the given CPU architecture\. (Pass \fBall\fP to audit all architectures\.)
+.TP
+\fB\-\-strict\fP
 Run additional, stricter style checks\.
-.
 .TP
-\fB\-\-git\fR
+\fB\-\-git\fP
 Run additional, slower style checks that navigate the Git repository\.
-.
 .TP
-\fB\-\-online\fR
+\fB\-\-online\fP
 Run additional, slower style checks that require a network connection\.
-.
 .TP
-\fB\-\-installed\fR
+\fB\-\-installed\fP
 Only check formulae and casks that are currently installed\.
-.
 .TP
-\fB\-\-new\fR
-Run various additional style checks to determine if a new formula or cask is eligible for Homebrew\. This should be used when creating new formula and implies \fB\-\-strict\fR and \fB\-\-online\fR\.
-.
+\fB\-\-eval\-all\fP
+Evaluate all available formulae and casks, whether installed or not, to audit them\. Implied if \fBHOMEBREW_EVAL_ALL\fP is set\.
 .TP
-\fB\-\-[no\-]appcast\fR
-Audit the appcast\.
-.
+\fB\-\-new\fP
+Run various additional style checks to determine if a new formula or cask is eligible for Homebrew\. This should be used when creating new formulae or casks and implies \fB\-\-strict\fP and \fB\-\-online\fP\&\.
 .TP
-\fB\-\-token\-conflicts\fR
-Audit for token conflicts\.
-.
+\fB\-\-[no\-]signing\fP
+Audit for signed apps, which are required on ARM
 .TP
-\fB\-\-tap\fR
-Check the formulae within the given tap, specified as \fIuser\fR\fB/\fR\fIrepo\fR\.
-.
+\fB\-\-token\-conflicts\fP
+Audit for token conflicts\.
 .TP
-\fB\-\-fix\fR
-Fix style violations automatically using RuboCop\'s auto\-correct feature\.
-.
+\fB\-\-tap\fP
+Check the formulae within the given tap, specified as \fIuser\fP\fB/\fP\fIrepo\fP\&\.
 .TP
-\fB\-\-display\-cop\-names\fR
-Include the RuboCop cop name for each violation in the output\.
-.
+\fB\-\-fix\fP
+Fix style violations automatically using RuboCop\[u2019]s auto\-correct feature\.
 .TP
-\fB\-\-display\-filename\fR
+\fB\-\-display\-filename\fP
 Prefix every line of output with the file or formula name being audited, to make output easy to grep\.
-.
-.TP
-\fB\-\-display\-failures\-only\fR
-Only display casks that fail the audit\. This is the default for formulae\.
-.
 .TP
-\fB\-\-skip\-style\fR
-Skip running non\-RuboCop style checks\. Useful if you plan on running \fBbrew style\fR separately\. Enabled by default unless a formula is specified by name\.
-.
+\fB\-\-skip\-style\fP
+Skip running non\-RuboCop style checks\. Useful if you plan on running \fBbrew style\fP separately\. Enabled by default unless a formula is specified by name\.
 .TP
-\fB\-D\fR, \fB\-\-audit\-debug\fR
+\fB\-D\fP, \fB\-\-audit\-debug\fP
 Enable debugging and profiling of audit methods\.
-.
 .TP
-\fB\-\-only\fR
-Specify a comma\-separated \fImethod\fR list to only run the methods named \fBaudit_\fR\fImethod\fR\.
-.
+\fB\-\-only\fP
+Specify a comma\-separated \fImethod\fP list to only run the methods named \fBaudit_\fP\fImethod\fP\&\.
 .TP
-\fB\-\-except\fR
-Specify a comma\-separated \fImethod\fR list to skip running the methods named \fBaudit_\fR\fImethod\fR\.
-.
+\fB\-\-except\fP
+Specify a comma\-separated \fImethod\fP list to skip running the methods named \fBaudit_\fP\fImethod\fP\&\.
 .TP
-\fB\-\-only\-cops\fR
-Specify a comma\-separated \fIcops\fR list to check for violations of only the listed RuboCop cops\.
-.
+\fB\-\-only\-cops\fP
+Specify a comma\-separated \fIcops\fP list to check for violations of only the listed RuboCop cops\.
 .TP
-\fB\-\-except\-cops\fR
-Specify a comma\-separated \fIcops\fR list to skip checking for violations of the listed RuboCop cops\.
-.
+\fB\-\-except\-cops\fP
+Specify a comma\-separated \fIcops\fP list to skip checking for violations of the listed RuboCop cops\.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Treat all named arguments as formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Treat all named arguments as casks\.
-.
-.SS "\fBbottle\fR [\fIoptions\fR] \fIinstalled_formula\fR|\fIfile\fR [\.\.\.]"
-Generate a bottle (binary package) from a formula that was installed with \fB\-\-build\-bottle\fR\. If the formula specifies a rebuild version, it will be incremented in the generated DSL\. Passing \fB\-\-keep\-old\fR will attempt to keep it at its original value, while \fB\-\-no\-rebuild\fR will remove it\.
-.
+.SS "\fBbottle\fP \fR[\fIoptions\fP] \fIinstalled_formula\fP|\fIfile\fP \fR[\.\.\.]"
+Generate a bottle (binary package) from a formula that was installed with \fB\-\-build\-bottle\fP\&\. If the formula specifies a rebuild version, it will be incremented in the generated DSL\. Passing \fB\-\-keep\-old\fP will attempt to keep it at its original value, while \fB\-\-no\-rebuild\fP will remove it\.
 .TP
-\fB\-\-skip\-relocation\fR
+\fB\-\-skip\-relocation\fP
 Do not check if the bottle can be marked as relocatable\.
-.
 .TP
-\fB\-\-force\-core\-tap\fR
-Build a bottle even if \fIformula\fR is not in \fBhomebrew/core\fR or any installed taps\.
-.
+\fB\-\-force\-core\-tap\fP
+Build a bottle even if \fIformula\fP is not in \fBhomebrew/core\fP or any installed taps\.
 .TP
-\fB\-\-no\-rebuild\fR
+\fB\-\-no\-rebuild\fP
 If the formula specifies a rebuild version, remove it from the generated DSL\.
-.
 .TP
-\fB\-\-keep\-old\fR
+\fB\-\-keep\-old\fP
 If the formula specifies a rebuild version, attempt to preserve its value in the generated DSL\.
-.
 .TP
-\fB\-\-json\fR
-Write bottle information to a JSON file, which can be used as the value for \fB\-\-merge\fR\.
-.
+\fB\-\-json\fP
+Write bottle information to a JSON file, which can be used as the value for \fB\-\-merge\fP\&\.
+.TP
+\fB\-\-merge\fP
+Generate an updated bottle block for a formula and optionally merge it into the formula file\. Instead of a formula name, requires the path to a JSON file generated with \fBbrew bottle \-\-json\fP \fIformula\fP\&\.
 .TP
-\fB\-\-merge\fR
-Generate an updated bottle block for a formula and optionally merge it into the formula file\. Instead of a formula name, requires the path to a JSON file generated with \fBbrew bottle \-\-json\fR \fIformula\fR\.
-.
+\fB\-\-write\fP
+Write changes to the formula file\. A new commit will be generated unless \fB\-\-no\-commit\fP is passed\.
 .TP
-\fB\-\-write\fR
-Write changes to the formula file\. A new commit will be generated unless \fB\-\-no\-commit\fR is passed\.
-.
+\fB\-\-no\-commit\fP
+When passed with \fB\-\-write\fP, a new commit will not generated after writing changes to the formula file\.
 .TP
-\fB\-\-no\-commit\fR
-When passed with \fB\-\-write\fR, a new commit will not generated after writing changes to the formula file\.
-.
+\fB\-\-only\-json\-tab\fP
+When passed with \fB\-\-json\fP, the tab will be written to the JSON file but not the bottle\.
 .TP
-\fB\-\-only\-json\-tab\fR
-When passed with \fB\-\-json\fR, the tab will be written to the JSON file but not the bottle\.
-.
+\fB\-\-no\-all\-checks\fP
+Don\[u2019]t try to create an \fBall\fP bottle or stop a no\-change upload\.
 .TP
-\fB\-\-committer\fR
-Specify a committer name and email in \fBgit\fR\'s standard author format\.
-.
+\fB\-\-committer\fP
+Specify a committer name and email in \fBgit\fP\[u2019]s standard author format\.
 .TP
-\fB\-\-root\-url\fR
-Use the specified \fIURL\fR as the root of the bottle\'s URL instead of Homebrew\'s default\.
-.
+\fB\-\-root\-url\fP
+Use the specified \fIURL\fP as the root of the bottle\[u2019]s URL instead of Homebrew\[u2019]s default\.
 .TP
-\fB\-\-root\-url\-using\fR
-Use the specified download strategy class for downloading the bottle\'s URL instead of Homebrew\'s default\.
-.
-.SS "\fBbump\fR [\fIoptions\fR] [\fIformula\fR|\fIcask\fR \.\.\.]"
-Display out\-of\-date brew formulae and the latest version available\. If the returned current and livecheck versions differ or when querying specific formulae, also displays whether a pull request has been opened with the URL\.
-.
+\fB\-\-root\-url\-using\fP
+Use the specified download strategy class for downloading the bottle\[u2019]s URL instead of Homebrew\[u2019]s default\.
+.SS "\fBbump\fP \fR[\fIoptions\fP] \fR[\fIformula\fP|\fIcask\fP \.\.\.]"
+Displays out\-of\-date packages and the latest version available\. If the returned current and livecheck versions differ or when querying specific packages, also displays whether a pull request has been opened with the URL\.
 .TP
-\fB\-\-full\-name\fR
+\fB\-\-full\-name\fP
 Print formulae/casks with fully\-qualified names\.
-.
 .TP
-\fB\-\-no\-pull\-requests\fR
+\fB\-\-no\-pull\-requests\fP
 Do not retrieve pull requests from GitHub\.
-.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Check only formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Check only casks\.
-.
 .TP
-\fB\-\-open\-pr\fR
-Open a pull request for the new version if there are none already open\.
-.
+\fB\-\-eval\-all\fP
+Evaluate all formulae and casks\.
 .TP
-\fB\-\-limit\fR
-Limit number of package results returned\.
-.
+\fB\-\-repology\fP
+Use Repology to check for outdated packages\.
 .TP
-\fB\-\-start\-with\fR
+\fB\-\-tap\fP
+Check formulae and casks within the given tap, specified as \fIuser\fP\fB/\fP\fIrepo\fP\&\.
+.TP
+\fB\-\-installed\fP
+Check formulae and casks that are currently installed\.
+.TP
+\fB\-\-no\-fork\fP
+Don\[u2019]t try to fork the repository\.
+.TP
+\fB\-\-open\-pr\fP
+Open a pull request for the new version if none have been opened yet\.
+.TP
+\fB\-\-start\-with\fP
 Letter or word that the list of package results should alphabetically follow\.
-.
-.SS "\fBbump\-cask\-pr\fR [\fIoptions\fR] \fIcask\fR"
-Create a pull request to update \fIcask\fR with a new version\.
-.
+.SS "\fBbump\-cask\-pr\fP \fR[\fIoptions\fP] \fIcask\fP"
+Create a pull request to update \fIcask\fP with a new version\.
 .P
-A best effort to determine the \fISHA\-256\fR will be made if the value is not supplied by the user\.
-.
+A best effort to determine the \fISHA\-256\fP will be made if the value is not supplied by the user\.
 .TP
-\fB\-n\fR, \fB\-\-dry\-run\fR
+\fB\-n\fP, \fB\-\-dry\-run\fP
 Print what would be done rather than doing it\.
-.
 .TP
-\fB\-\-write\-only\fR
+\fB\-\-write\-only\fP
 Make the expected file modifications without taking any Git actions\.
-.
-.TP
-\fB\-\-commit\fR
-When passed with \fB\-\-write\-only\fR, generate a new commit after writing changes to the cask file\.
-.
 .TP
-\fB\-\-no\-audit\fR
-Don\'t run \fBbrew audit\fR before opening the PR\.
-.
+\fB\-\-commit\fP
+When passed with \fB\-\-write\-only\fP, generate a new commit after writing changes to the cask file\.
 .TP
-\fB\-\-online\fR
-Run \fBbrew audit \-\-online\fR before opening the PR\.
-.
+\fB\-\-no\-audit\fP
+Don\[u2019]t run \fBbrew audit\fP before opening the PR\.
 .TP
-\fB\-\-no\-style\fR
-Don\'t run \fBbrew style \-\-fix\fR before opening the PR\.
-.
+\fB\-\-no\-style\fP
+Don\[u2019]t run \fBbrew style \-\-fix\fP before opening the PR\.
 .TP
-\fB\-\-no\-browse\fR
+\fB\-\-no\-browse\fP
 Print the pull request URL instead of opening in a browser\.
-.
 .TP
-\fB\-\-no\-fork\fR
-Don\'t try to fork the repository\.
-.
+\fB\-\-no\-fork\fP
+Don\[u2019]t try to fork the repository\.
 .TP
-\fB\-\-version\fR
-Specify the new \fIversion\fR for the cask\.
-.
+\fB\-\-version\fP
+Specify the new \fIversion\fP for the cask\.
 .TP
-\fB\-\-message\fR
-Append \fImessage\fR to the default pull request message\.
-.
+\fB\-\-version\-arm\fP
+Specify the new cask \fIversion\fP for the ARM architecture\.
 .TP
-\fB\-\-url\fR
-Specify the \fIURL\fR for the new download\.
-.
+\fB\-\-version\-intel\fP
+Specify the new cask \fIversion\fP for the Intel architecture\.
 .TP
-\fB\-\-sha256\fR
-Specify the \fISHA\-256\fR checksum of the new download\.
-.
+\fB\-\-message\fP
+Prepend \fImessage\fP to the default pull request message\.
 .TP
-\fB\-\-fork\-org\fR
-Use the specified GitHub organization for forking\.
-.
+\fB\-\-url\fP
+Specify the \fIURL\fP for the new download\.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
-Ignore duplicate open PRs\.
-.
-.SS "\fBbump\-formula\-pr\fR [\fIoptions\fR] [\fIformula\fR]"
-Create a pull request to update \fIformula\fR with a new URL or a new tag\.
-.
+\fB\-\-sha256\fP
+Specify the \fISHA\-256\fP checksum of the new download\.
+.TP
+\fB\-\-fork\-org\fP
+Use the specified GitHub organization for forking\.
+.SS "\fBbump\-formula\-pr\fP \fR[\fIoptions\fP] \fR[\fIformula\fP]"
+Create a pull request to update \fIformula\fP with a new URL or a new tag\.
 .P
-If a \fIURL\fR is specified, the \fISHA\-256\fR checksum of the new download should also be specified\. A best effort to determine the \fISHA\-256\fR and \fIformula\fR name will be made if either or both values are not supplied by the user\.
-.
+If a \fIURL\fP is specified, the \fISHA\-256\fP checksum of the new download should also be specified\. A best effort to determine the \fISHA\-256\fP will be made if not supplied by the user\.
 .P
-If a \fItag\fR is specified, the Git commit \fIrevision\fR corresponding to that tag should also be specified\. A best effort to determine the \fIrevision\fR will be made if the value is not supplied by the user\.
-.
+If a \fItag\fP is specified, the Git commit \fIrevision\fP corresponding to that tag should also be specified\. A best effort to determine the \fIrevision\fP will be made if the value is not supplied by the user\.
 .P
-If a \fIversion\fR is specified, a best effort to determine the \fIURL\fR and \fISHA\-256\fR or the \fItag\fR and \fIrevision\fR will be made if both values are not supplied by the user\.
-.
+If a \fIversion\fP is specified, a best effort to determine the \fIURL\fP and \fISHA\-256\fP or the \fItag\fP and \fIrevision\fP will be made if both values are not supplied by the user\.
 .P
-\fINote:\fR this command cannot be used to transition a formula from a URL\-and\-SHA\-256 style specification into a tag\-and\-revision style specification, nor vice versa\. It must use whichever style specification the formula already uses\.
-.
+\fINote:\fP this command cannot be used to transition a formula from a URL\-and\-SHA\-256 style specification into a tag\-and\-revision style specification, nor vice versa\. It must use whichever style specification the formula already uses\.
 .TP
-\fB\-n\fR, \fB\-\-dry\-run\fR
+\fB\-n\fP, \fB\-\-dry\-run\fP
 Print what would be done rather than doing it\.
-.
 .TP
-\fB\-\-write\-only\fR
+\fB\-\-write\-only\fP
 Make the expected file modifications without taking any Git actions\.
-.
 .TP
-\fB\-\-commit\fR
-When passed with \fB\-\-write\-only\fR, generate a new commit after writing changes to the formula file\.
-.
+\fB\-\-commit\fP
+When passed with \fB\-\-write\-only\fP, generate a new commit after writing changes to the formula file\.
 .TP
-\fB\-\-no\-audit\fR
-Don\'t run \fBbrew audit\fR before opening the PR\.
-.
+\fB\-\-no\-audit\fP
+Don\[u2019]t run \fBbrew audit\fP before opening the PR\.
 .TP
-\fB\-\-strict\fR
-Run \fBbrew audit \-\-strict\fR before opening the PR\.
-.
+\fB\-\-strict\fP
+Run \fBbrew audit \-\-strict\fP before opening the PR\.
 .TP
-\fB\-\-online\fR
-Run \fBbrew audit \-\-online\fR before opening the PR\.
-.
+\fB\-\-online\fP
+Run \fBbrew audit \-\-online\fP before opening the PR\.
 .TP
-\fB\-\-no\-browse\fR
+\fB\-\-no\-browse\fP
 Print the pull request URL instead of opening in a browser\.
-.
 .TP
-\fB\-\-no\-fork\fR
-Don\'t try to fork the repository\.
-.
+\fB\-\-no\-fork\fP
+Don\[u2019]t try to fork the repository\.
 .TP
-\fB\-\-mirror\fR
-Use the specified \fIURL\fR as a mirror URL\. If \fIURL\fR is a comma\-separated list of URLs, multiple mirrors will be added\.
-.
+\fB\-\-mirror\fP
+Use the specified \fIURL\fP as a mirror URL\. If \fIURL\fP is a comma\-separated list of URLs, multiple mirrors will be added\.
 .TP
-\fB\-\-fork\-org\fR
+\fB\-\-fork\-org\fP
 Use the specified GitHub organization for forking\.
-.
 .TP
-\fB\-\-version\fR
-Use the specified \fIversion\fR to override the value parsed from the URL or tag\. Note that \fB\-\-version=0\fR can be used to delete an existing version override from a formula if it has become redundant\.
-.
+\fB\-\-version\fP
+Use the specified \fIversion\fP to override the value parsed from the URL or tag\. Note that \fB\-\-version=0\fP can be used to delete an existing version override from a formula if it has become redundant\.
+.TP
+\fB\-\-message\fP
+Prepend \fImessage\fP to the default pull request message\.
 .TP
-\fB\-\-message\fR
-Append \fImessage\fR to the default pull request message\.
-.
+\fB\-\-url\fP
+Specify the \fIURL\fP for the new download\. If a \fIURL\fP is specified, the \fISHA\-256\fP checksum of the new download should also be specified\.
 .TP
-\fB\-\-url\fR
-Specify the \fIURL\fR for the new download\. If a \fIURL\fR is specified, the \fISHA\-256\fR checksum of the new download should also be specified\.
-.
+\fB\-\-sha256\fP
+Specify the \fISHA\-256\fP checksum of the new download\.
 .TP
-\fB\-\-sha256\fR
-Specify the \fISHA\-256\fR checksum of the new download\.
-.
+\fB\-\-tag\fP
+Specify the new git commit \fItag\fP for the formula\.
 .TP
-\fB\-\-tag\fR
-Specify the new git commit \fItag\fR for the formula\.
-.
+\fB\-\-revision\fP
+Specify the new commit \fIrevision\fP corresponding to the specified git \fItag\fP or specified \fIversion\fP\&\.
 .TP
-\fB\-\-revision\fR
-Specify the new commit \fIrevision\fR corresponding to the specified git \fItag\fR or specified \fIversion\fR\.
-.
+\fB\-f\fP, \fB\-\-force\fP
+Remove all mirrors if \fB\-\-mirror\fP was not specified\.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
-Ignore duplicate open PRs\. Remove all mirrors if \fB\-\-mirror\fR was not specified\.
-.
+\fB\-\-install\-dependencies\fP
+Install missing dependencies required to update resources\.
 .TP
-\fB\-\-python\-package\-name\fR
-Use the specified \fIpackage\-name\fR when finding Python resources for \fIformula\fR\. If no package name is specified, it will be inferred from the formula\'s stable URL\.
-.
+\fB\-\-python\-package\-name\fP
+Use the specified \fIpackage\-name\fP when finding Python resources for \fIformula\fP\&\. If no package name is specified, it will be inferred from the formula\[u2019]s stable URL\.
 .TP
-\fB\-\-python\-extra\-packages\fR
+\fB\-\-python\-extra\-packages\fP
 Include these additional Python packages when finding resources\.
-.
 .TP
-\fB\-\-python\-exclude\-packages\fR
+\fB\-\-python\-exclude\-packages\fP
 Exclude these Python packages when finding resources\.
-.
-.SS "\fBbump\-revision\fR [\fIoptions\fR] \fIformula\fR [\.\.\.]"
-Create a commit to increment the revision of \fIformula\fR\. If no revision is present, "revision 1" will be added\.
-.
+.SS "\fBbump\-revision\fP \fR[\fIoptions\fP] \fIformula\fP \fR[\.\.\.]"
+Create a commit to increment the revision of \fIformula\fP\&\. If no revision is present, \[u201c]revision 1\[u201d] will be added\.
 .TP
-\fB\-n\fR, \fB\-\-dry\-run\fR
+\fB\-n\fP, \fB\-\-dry\-run\fP
 Print what would be done rather than doing it\.
-.
 .TP
-\fB\-\-remove\-bottle\-block\fR
+\fB\-\-remove\-bottle\-block\fP
 Remove the bottle block in addition to bumping the revision\.
-.
 .TP
-\fB\-\-write\-only\fR
+\fB\-\-write\-only\fP
 Make the expected file modifications without taking any Git actions\.
-.
 .TP
-\fB\-\-message\fR
-Append \fImessage\fR to the default commit message\.
-.
-.SS "\fBbump\-unversioned\-casks\fR [\fIoptions\fR] \fIcask\fR|\fItap\fR [\.\.\.]"
-Check all casks with unversioned URLs in a given \fItap\fR for updates\.
-.
+\fB\-\-message\fP
+Append \fImessage\fP to the default commit message\.
+.SS "\fBbump\-unversioned\-casks\fP \fR[\fIoptions\fP] \fIcask\fP|\fItap\fP \fR[\.\.\.]"
+Check all casks with unversioned URLs in a given \fItap\fP for updates\.
 .TP
-\fB\-n\fR, \fB\-\-dry\-run\fR
+\fB\-n\fP, \fB\-\-dry\-run\fP
 Do everything except caching state and opening pull requests\.
-.
 .TP
-\fB\-\-limit\fR
+\fB\-\-limit\fP
 Maximum runtime in minutes\.
-.
 .TP
-\fB\-\-state\-file\fR
+\fB\-\-state\-file\fP
 File for caching state\.
-.
-.SS "\fBcat\fR [\fI\-\-formula\fR] [\fI\-\-cask\fR] \fIformula\fR|\fIcask\fR"
-Display the source of a \fIformula\fR or \fIcask\fR\.
-.
+.SS "\fBcat\fP \fR[\fB\-\-formula\fP] \fR[\fB\-\-cask\fP] \fIformula\fP|\fIcask\fP \fR[\.\.\.]"
+Display the source of a \fIformula\fP or \fIcask\fP\&\.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Treat all named arguments as formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Treat all named arguments as casks\.
-.
-.SS "\fBcommand\fR \fIcommand\fR [\.\.\.]"
-Display the path to the file being used when invoking \fBbrew\fR \fIcmd\fR\.
-.
-.SS "\fBcreate\fR [\fIoptions\fR] \fIURL\fR"
-Generate a formula or, with \fB\-\-cask\fR, a cask for the downloadable file at \fIURL\fR and open it in the editor\. Homebrew will attempt to automatically derive the formula name and version, but if it fails, you\'ll have to make your own template\. The \fBwget\fR formula serves as a simple example\. For the complete API, see: \fIhttps://rubydoc\.brew\.sh/Formula\fR
-.
-.TP
-\fB\-\-autotools\fR
+.SS "\fBcontributions\fP \fR[\-\-user=\fIemail|username\fP] \fR[\fI\-\-repositories\fP\fB=\fP] \fR[\fI\-\-csv\fP]"
+Summarise contributions to Homebrew repositories\.
+.TP
+\fB\-\-repositories\fP
+Specify a comma\-separated list of repositories to search\. Supported repositories: \fBbrew\fP, \fBcore\fP, \fBcask\fP, \fBaliases\fP, \fBbundle\fP, \fBcommand\-not\-found\fP, \fBtest\-bot\fP and \fBservices\fP\&\. Omitting this flag, or specifying \fB\-\-repositories=primary\fP, searches only the main repositories: brew,core,cask\. Specifying \fB\-\-repositories=all\fP, searches all repositories\.
+.TP
+\fB\-\-from\fP
+Date (ISO\-8601 format) to start searching contributions\. Omitting this flag searches the last year\.
+.TP
+\fB\-\-to\fP
+Date (ISO\-8601 format) to stop searching contributions\.
+.TP
+\fB\-\-user\fP
+Specify a comma\-separated list of GitHub usernames or email addresses to find contributions from\. Omitting this flag searches maintainers\.
+.TP
+\fB\-\-csv\fP
+Print a CSV of contributions across repositories over the time period\.
+.SS "\fBcreate\fP \fR[\fIoptions\fP] \fIURL\fP"
+Generate a formula or, with \fB\-\-cask\fP, a cask for the downloadable file at \fIURL\fP and open it in the editor\. Homebrew will attempt to automatically derive the formula name and version, but if it fails, you\[u2019]ll have to make your own template\. The \fBwget\fP formula serves as a simple example\. For the complete API, see: 
+.UR https://rubydoc\.brew\.sh/Formula
+.UE
+.TP
+\fB\-\-autotools\fP
 Create a basic template for an Autotools\-style build\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Create a basic template for a cask\.
-.
 .TP
-\fB\-\-cmake\fR
+\fB\-\-cmake\fP
 Create a basic template for a CMake\-style build\.
-.
 .TP
-\fB\-\-crystal\fR
+\fB\-\-crystal\fP
 Create a basic template for a Crystal build\.
-.
 .TP
-\fB\-\-go\fR
+\fB\-\-go\fP
 Create a basic template for a Go build\.
-.
 .TP
-\fB\-\-meson\fR
+\fB\-\-meson\fP
 Create a basic template for a Meson\-style build\.
-.
 .TP
-\fB\-\-node\fR
+\fB\-\-node\fP
 Create a basic template for a Node build\.
-.
 .TP
-\fB\-\-perl\fR
+\fB\-\-perl\fP
 Create a basic template for a Perl build\.
-.
 .TP
-\fB\-\-python\fR
+\fB\-\-python\fP
 Create a basic template for a Python build\.
-.
 .TP
-\fB\-\-ruby\fR
+\fB\-\-ruby\fP
 Create a basic template for a Ruby build\.
-.
 .TP
-\fB\-\-rust\fR
+\fB\-\-rust\fP
 Create a basic template for a Rust build\.
-.
 .TP
-\fB\-\-no\-fetch\fR
-Homebrew will not download \fIURL\fR to the cache and will thus not add its SHA\-256 to the formula for you, nor will it check the GitHub API for GitHub projects (to fill out its description and homepage)\.
-.
+\fB\-\-no\-fetch\fP
+Homebrew will not download \fIURL\fP to the cache and will thus not add its SHA\-256 to the formula for you, nor will it check the GitHub API for GitHub projects (to fill out its description and homepage)\.
 .TP
-\fB\-\-HEAD\fR
-Indicate that \fIURL\fR points to the package\'s repository rather than a file\.
-.
+\fB\-\-HEAD\fP
+Indicate that \fIURL\fP points to the package\[u2019]s repository rather than a file\.
 .TP
-\fB\-\-set\-name\fR
-Explicitly set the \fIname\fR of the new formula or cask\.
-.
+\fB\-\-set\-name\fP
+Explicitly set the \fIname\fP of the new formula or cask\.
 .TP
-\fB\-\-set\-version\fR
-Explicitly set the \fIversion\fR of the new formula or cask\.
-.
+\fB\-\-set\-version\fP
+Explicitly set the \fIversion\fP of the new formula or cask\.
 .TP
-\fB\-\-set\-license\fR
-Explicitly set the \fIlicense\fR of the new formula\.
-.
+\fB\-\-set\-license\fP
+Explicitly set the \fIlicense\fP of the new formula\.
 .TP
-\fB\-\-tap\fR
-Generate the new formula within the given tap, specified as \fIuser\fR\fB/\fR\fIrepo\fR\.
-.
+\fB\-\-tap\fP
+Generate the new formula within the given tap, specified as \fIuser\fP\fB/\fP\fIrepo\fP\&\.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
+\fB\-f\fP, \fB\-\-force\fP
 Ignore errors for disallowed formula names and names that shadow aliases\.
-.
-.SS "\fBdispatch\-build\-bottle\fR [\fIoptions\fR] \fIformula\fR [\.\.\.]"
+.SS "\fBdebugger\fP \fR[\fB\-\-open\fP] \fIcommand\fP \fR[\.\.\.]"
+Run the specified Homebrew command in debug mode\.
+.P
+To pass flags to the command, use \fB\-\-\fP to separate them from the \fBbrew\fP flags\. For example: \fBbrew debugger \-\- list \-\-formula\fP\&\.
+.TP
+\fB\-O\fP, \fB\-\-open\fP
+Start remote debugging over a Unix socket\.
+.SS "\fBdispatch\-build\-bottle\fP \fR[\fIoptions\fP] \fIformula\fP \fR[\.\.\.]"
 Build bottles for these formulae with GitHub Actions\.
-.
 .TP
-\fB\-\-tap\fR
-Target tap repository (default: \fBhomebrew/core\fR)\.
-.
+\fB\-\-tap\fP
+Target tap repository (default: \fBhomebrew/core\fP)\.
 .TP
-\fB\-\-timeout\fR
+\fB\-\-timeout\fP
 Build timeout (in minutes, default: 60)\.
-.
 .TP
-\fB\-\-issue\fR
+\fB\-\-issue\fP
 If specified, post a comment to this issue number if the job fails\.
-.
 .TP
-\fB\-\-macos\fR
-Version(s) of macOS the bottle should be built for\.
-.
+\fB\-\-macos\fP
+macOS version (or comma\-separated list of versions) the bottle should be built for\.
 .TP
-\fB\-\-workflow\fR
-Dispatch specified workflow (default: \fBdispatch\-build\-bottle\.yml\fR)\.
-.
+\fB\-\-workflow\fP
+Dispatch specified workflow (default: \fBdispatch\-build\-bottle\.yml\fP)\.
 .TP
-\fB\-\-upload\fR
+\fB\-\-upload\fP
 Upload built bottles\.
-.
 .TP
-\fB\-\-linux\fR
+\fB\-\-linux\fP
 Dispatch bottle for Linux (using GitHub runners)\.
-.
 .TP
-\fB\-\-linux\-self\-hosted\fR
+\fB\-\-linux\-self\-hosted\fP
 Dispatch bottle for Linux (using self\-hosted runner)\.
-.
 .TP
-\fB\-\-linux\-wheezy\fR
+\fB\-\-linux\-wheezy\fP
 Use Debian Wheezy container for building the bottle on Linux\.
-.
-.SS "\fBedit\fR [\fIoptions\fR] [\fIformula\fR|\fIcask\fR \.\.\.]"
-Open a \fIformula\fR or \fIcask\fR in the editor set by \fBEDITOR\fR or \fBHOMEBREW_EDITOR\fR, or open the Homebrew repository for editing if no formula is provided\.
-.
+.SS "\fBedit\fP \fR[\fIoptions\fP] \fR[\fIformula\fP|\fIcask\fP|\fItap\fP \.\.\.]"
+Open a \fIformula\fP, \fIcask\fP or \fItap\fP in the editor set by \fBEDITOR\fP or \fBHOMEBREW_EDITOR\fP, or open the Homebrew repository for editing if no argument is provided\.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Treat all named arguments as formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Treat all named arguments as casks\.
-.
 .TP
-\fB\-\-print\-path\fR
+\fB\-\-print\-path\fP
 Print the file path to be edited, without opening an editor\.
-.
-.SS "\fBextract\fR [\fI\-\-version\fR\fB=\fR] [\fI\-\-force\fR] \fIformula\fR \fItap\fR"
-Look through repository history to find the most recent version of \fIformula\fR and create a copy in \fItap\fR\. Specifically, the command will create the new formula file at \fItap\fR\fB/Formula/\fR\fIformula\fR\fB@\fR\fIversion\fR\fB\.rb\fR\. If the tap is not installed yet, attempt to install/clone the tap before continuing\. To extract a formula from a tap that is not \fBhomebrew/core\fR use its fully\-qualified form of \fIuser\fR\fB/\fR\fIrepo\fR\fB/\fR\fIformula\fR\.
-.
+.SS "\fBextract\fP \fR[\fB\-\-version=\fP] \fR[\fB\-\-git\-revision=\fP] \fR[\fB\-\-force\fP] \fIformula\fP \fItap\fP"
+Look through repository history to find the most recent version of \fIformula\fP and create a copy in \fItap\fP\&\. Specifically, the command will create the new formula file at \fItap\fP\fB/Formula/\fP\fIformula\fP\fB@\fP\fIversion\fP\fB\&\.rb\fP\&\. If the tap is not installed yet, attempt to install/clone the tap before continuing\. To extract a formula from a tap that is not \fBhomebrew/core\fP use its fully\-qualified form of \fIuser\fP\fB/\fP\fIrepo\fP\fB/\fP\fIformula\fP\&\.
+.TP
+\fB\-\-git\-revision\fP
+Search for the specified \fIversion\fP of \fIformula\fP starting at \fIrevision\fP instead of HEAD\.
 .TP
-\fB\-\-version\fR
-Extract the specified \fIversion\fR of \fIformula\fR instead of the most recent\.
-.
+\fB\-\-version\fP
+Extract the specified \fIversion\fP of \fIformula\fP instead of the most recent\.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
+\fB\-f\fP, \fB\-\-force\fP
 Overwrite the destination formula if it already exists\.
-.
-.SS "\fBformula\fR \fIformula\fR [\.\.\.]"
-Display the path where \fIformula\fR is located\.
-.
-.SS "\fBgenerate\-man\-completions\fR [\fI\-\-fail\-if\-not\-changed\fR]"
-Generate Homebrew\'s manpages and shell completions\.
-.
-.TP
-\fB\-\-fail\-if\-not\-changed\fR
-Return a failing status code if no changes are detected in the manpage outputs\. This can be used to notify CI when the manpages are out of date\. Additionally, the date used in new manpages will match those in the existing manpages (to allow comparison without factoring in the date)\.
-.
-.SS "\fBinstall\-bundler\-gems\fR [\fI\-\-groups\fR\fB=\fR]"
-Install Homebrew\'s Bundler gems\.
-.
-.TP
-\fB\-\-groups\fR
-Installs the specified comma\-separated list of gem groups (default: last used)\.
-.
-.SS "\fBirb\fR [\fI\-\-examples\fR] [\fI\-\-pry\fR]"
+.SS "\fBformula\fP \fIformula\fP \fR[\.\.\.]"
+Display the path where \fIformula\fP is located\.
+.SS "\fBgenerate\-cask\-api\fP \fR[\fB\-\-dry\-run\fP]"
+Generate \fBhomebrew/cask\fP API data files for 
+.UR https://formulae\.brew\.sh
+.UE \&\. The generated files are written to the current directory\.
+.TP
+\fB\-n\fP, \fB\-\-dry\-run\fP
+Generate API data without writing it to files\.
+.SS "\fBgenerate\-formula\-api\fP \fR[\fB\-\-dry\-run\fP]"
+Generate \fBhomebrew/core\fP API data files for 
+.UR https://formulae\.brew\.sh
+.UE \&\. The generated files are written to the current directory\.
+.TP
+\fB\-n\fP, \fB\-\-dry\-run\fP
+Generate API data without writing it to files\.
+.SS "\fBgenerate\-man\-completions\fP"
+Generate Homebrew\[u2019]s manpages and shell completions\.
+.SS "\fBinstall\-bundler\-gems\fP \fR[\fB\-\-groups=\fP] \fR[\fB\-\-add\-groups=\fP]"
+Install Homebrew\[u2019]s Bundler gems\.
+.TP
+\fB\-\-groups\fP
+Installs the specified comma\-separated list of gem groups (default: last used)\. Replaces any previously installed groups\.
+.TP
+\fB\-\-add\-groups\fP
+Installs the specified comma\-separated list of gem groups, in addition to those already installed\.
+.SS "\fBirb\fP \fR[\fB\-\-examples\fP] \fR[\fB\-\-pry\fP]"
 Enter the interactive Homebrew Ruby shell\.
-.
 .TP
-\fB\-\-examples\fR
+\fB\-\-examples\fP
 Show several examples\.
-.
 .TP
-\fB\-\-pry\fR
-Use Pry instead of IRB\. Implied if \fBHOMEBREW_PRY\fR is set\.
-.
-.SS "\fBlinkage\fR [\fIoptions\fR] [\fIinstalled_formula\fR \.\.\.]"
-Check the library links from the given \fIformula\fR kegs\. If no \fIformula\fR are provided, check all kegs\. Raises an error if run on uninstalled formulae\.
-.
+\fB\-\-pry\fP
+Use Pry instead of IRB\. Implied if \fBHOMEBREW_PRY\fP is set\.
+.SS "\fBlinkage\fP \fR[\fIoptions\fP] \fR[\fIinstalled_formula\fP \.\.\.]"
+Check the library links from the given \fIformula\fP kegs\. If no \fIformula\fP are provided, check all kegs\. Raises an error if run on uninstalled formulae\.
 .TP
-\fB\-\-test\fR
+\fB\-\-test\fP
 Show only missing libraries and exit with a non\-zero status if any missing libraries are found\.
-.
 .TP
-\fB\-\-strict\fR
+\fB\-\-strict\fP
 Exit with a non\-zero status if any undeclared dependencies with linkage are found\.
-.
 .TP
-\fB\-\-reverse\fR
+\fB\-\-reverse\fP
 For every library that a keg references, print its dylib path followed by the binaries that link to it\.
-.
 .TP
-\fB\-\-cached\fR
-Print the cached linkage values stored in \fBHOMEBREW_CACHE\fR, set by a previous \fBbrew linkage\fR run\.
-.
-.SS "\fBlivecheck\fR, \fBlc\fR [\fIoptions\fR] [\fIformula\fR|\fIcask\fR \.\.\.]"
-Check for newer versions of formulae and/or casks from upstream\.
-.
-.P
-If no formula or cask argument is passed, the list of formulae and casks to check is taken from \fBHOMEBREW_LIVECHECK_WATCHLIST\fR or \fB~/\.brew_livecheck_watchlist\fR\.
-.
+\fB\-\-cached\fP
+Print the cached linkage values stored in \fBHOMEBREW_CACHE\fP, set by a previous \fBbrew linkage\fP run\.
+.SS "\fBlivecheck\fP, \fBlc\fP \fR[\fIoptions\fP] \fR[\fIformula\fP|\fIcask\fP \.\.\.]"
+Check for newer versions of formulae and/or casks from upstream\. If no formula or cask argument is passed, the list of formulae and casks to check is taken from \fBHOMEBREW_LIVECHECK_WATCHLIST\fP or \fB~/\.homebrew/livecheck_watchlist\.txt\fP\&\.
 .TP
-\fB\-\-full\-name\fR
-Print formulae/casks with fully\-qualified names\.
-.
+\fB\-\-full\-name\fP
+Print formulae and casks with fully\-qualified names\.
 .TP
-\fB\-\-tap\fR
-Check formulae/casks within the given tap, specified as \fIuser\fR\fB/\fR\fIrepo\fR\.
-.
+\fB\-\-tap\fP
+Check formulae and casks within the given tap, specified as \fIuser\fP\fB/\fP\fIrepo\fP\&\.
 .TP
-\fB\-\-all\fR
-Check all available formulae/casks\.
-.
+\fB\-\-eval\-all\fP
+Evaluate all available formulae and casks, whether installed or not, to check them\.
 .TP
-\fB\-\-installed\fR
-Check formulae/casks that are currently installed\.
-.
+\fB\-\-installed\fP
+Check formulae and casks that are currently installed\.
 .TP
-\fB\-\-newer\-only\fR
-Show the latest version only if it\'s newer than the formula/cask\.
-.
+\fB\-\-newer\-only\fP
+Show the latest version only if it\[u2019]s newer than the formula/cask\.
 .TP
-\fB\-\-json\fR
+\fB\-\-json\fP
 Output information in JSON format\.
-.
 .TP
-\fB\-q\fR, \fB\-\-quiet\fR
-Suppress warnings, don\'t print a progress bar for JSON output\.
-.
+\fB\-r\fP, \fB\-\-resources\fP
+Also check resources for formulae\.
+.TP
+\fB\-q\fP, \fB\-\-quiet\fP
+Suppress warnings, don\[u2019]t print a progress bar for JSON output\.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Only check formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Only check casks\.
-.
-.SS "\fBpr\-automerge\fR [\fIoptions\fR]"
-Find pull requests that can be automatically merged using \fBbrew pr\-publish\fR\.
-.
 .TP
-\fB\-\-tap\fR
-Target tap repository (default: \fBhomebrew/core\fR)\.
-.
+\fB\-\-extract\-plist\fP
+Enable checking multiple casks with ExtractPlist strategy\.
+.SS "\fBpr\-automerge\fP \fR[\fIoptions\fP]"
+Find pull requests that can be automatically merged using \fBbrew pr\-publish\fP\&\.
 .TP
-\fB\-\-workflow\fR
-Workflow file to use with \fBbrew pr\-publish\fR\.
-.
+\fB\-\-tap\fP
+Target tap repository (default: \fBhomebrew/core\fP)\.
 .TP
-\fB\-\-with\-label\fR
+\fB\-\-workflow\fP
+Workflow file to use with \fBbrew pr\-publish\fP\&\.
+.TP
+\fB\-\-with\-label\fP
 Pull requests must have this label\.
-.
 .TP
-\fB\-\-without\-labels\fR
-Pull requests must not have these labels (default: \fBdo not merge\fR, \fBnew formula\fR, \fBautomerge\-skip\fR)\.
-.
+\fB\-\-without\-labels\fP
+Pull requests must not have these labels (default: \fBdo not merge\fP, \fBnew formula\fP, \fBautomerge\-skip\fP, \fBpre\-release\fP, \fBCI\-published\-bottle\-commits\fP)\.
 .TP
-\fB\-\-without\-approval\fR
+\fB\-\-without\-approval\fP
 Pull requests do not require approval to be merged\.
-.
 .TP
-\fB\-\-publish\fR
-Run \fBbrew pr\-publish\fR on matching pull requests\.
-.
+\fB\-\-publish\fP
+Run \fBbrew pr\-publish\fP on matching pull requests\.
 .TP
-\fB\-\-no\-autosquash\fR
-Instruct \fBbrew pr\-publish\fR to skip automatically reformatting and rewording commits in the pull request to the preferred format\.
-.
+\fB\-\-autosquash\fP
+Instruct \fBbrew pr\-publish\fP to automatically reformat and reword commits in the pull request to the preferred format\.
 .TP
-\fB\-\-ignore\-failures\fR
+\fB\-\-ignore\-failures\fP
 Include pull requests that have failing status checks\.
-.
-.SS "\fBpr\-publish\fR [\fIoptions\fR] \fIpull_request\fR [\.\.\.]"
+.SS "\fBpr\-publish\fP \fR[\fIoptions\fP] \fIpull_request\fP \fR[\.\.\.]"
 Publish bottles for a pull request with GitHub Actions\. Requires write access to the repository\.
-.
 .TP
-\fB\-\-no\-autosquash\fR
-Skip automatically reformatting and rewording commits in the pull request to the preferred format, even if supported on the target tap\.
-.
+\fB\-\-autosquash\fP
+If supported on the target tap, automatically reformat and reword commits to our preferred format\.
+.TP
+\fB\-\-large\-runner\fP
+Run the upload job on a large runner\.
 .TP
-\fB\-\-branch\fR
-Branch to publish to (default: \fBmaster\fR)\.
-.
+\fB\-\-branch\fP
+Branch to use the workflow from (default: \fBmaster\fP)\.
 .TP
-\fB\-\-message\fR
-Message to include when autosquashing revision bumps, deletions, and rebuilds\.
-.
+\fB\-\-message\fP
+Message to include when autosquashing revision bumps, deletions and rebuilds\.
 .TP
-\fB\-\-tap\fR
-Target tap repository (default: \fBhomebrew/core\fR)\.
-.
+\fB\-\-tap\fP
+Target tap repository (default: \fBhomebrew/core\fP)\.
 .TP
-\fB\-\-workflow\fR
-Target workflow filename (default: \fBpublish\-commit\-bottles\.yml\fR)\.
-.
-.SS "\fBpr\-pull\fR [\fIoptions\fR] \fIpull_request\fR [\.\.\.]"
-Download and publish bottles, and apply the bottle commit from a pull request with artifacts generated by GitHub Actions\. Requires write access to the repository\.
-.
+\fB\-\-workflow\fP
+Target workflow filename (default: \fBpublish\-commit\-bottles\.yml\fP)\.
+.SS "\fBpr\-pull\fP \fR[\fIoptions\fP] \fIpull_request\fP \fR[\.\.\.]"
+Download and publish bottles and apply the bottle commit from a pull request with artifacts generated by GitHub Actions\. Requires write access to the repository\.
 .TP
-\fB\-\-no\-upload\fR
-Download the bottles but don\'t upload them\.
-.
+\fB\-\-no\-upload\fP
+Download the bottles but don\[u2019]t upload them\.
 .TP
-\fB\-\-no\-commit\fR
+\fB\-\-no\-commit\fP
 Do not generate a new commit before uploading\.
-.
 .TP
-\fB\-n\fR, \fB\-\-dry\-run\fR
+\fB\-\-no\-cherry\-pick\fP
+Do not cherry\-pick commits from the pull request branch\.
+.TP
+\fB\-n\fP, \fB\-\-dry\-run\fP
 Print what would be done rather than doing it\.
-.
 .TP
-\fB\-\-clean\fR
+\fB\-\-clean\fP
 Do not amend the commits from pull requests\.
-.
 .TP
-\fB\-\-keep\-old\fR
+\fB\-\-keep\-old\fP
 If the formula specifies a rebuild version, attempt to preserve its value in the generated DSL\.
-.
 .TP
-\fB\-\-no\-autosquash\fR
-Skip automatically reformatting and rewording commits in the pull request to our preferred format\.
-.
+\fB\-\-autosquash\fP
+Automatically reformat and reword commits in the pull request to our preferred format\.
 .TP
-\fB\-\-branch\-okay\fR
+\fB\-\-branch\-okay\fP
 Do not warn if pulling to a branch besides the repository default (useful for testing)\.
-.
 .TP
-\fB\-\-resolve\fR
+\fB\-\-resolve\fP
 When a patch fails to apply, leave in progress and allow user to resolve, instead of aborting\.
-.
 .TP
-\fB\-\-warn\-on\-upload\-failure\fR
+\fB\-\-warn\-on\-upload\-failure\fP
 Warn instead of raising an error if the bottle upload fails\. Useful for repairing bottle uploads that previously failed\.
-.
 .TP
-\fB\-\-committer\fR
-Specify a committer name and email in \fBgit\fR\'s standard author format\.
-.
+\fB\-\-retain\-bottle\-dir\fP
+Does not clean up the tmp directory for the bottle so it can be used later\.
 .TP
-\fB\-\-message\fR
-Message to include when autosquashing revision bumps, deletions, and rebuilds\.
-.
+\fB\-\-committer\fP
+Specify a committer name and email in \fBgit\fP\[u2019]s standard author format\.
 .TP
-\fB\-\-artifact\fR
-Download artifacts with the specified name (default: \fBbottles\fR)\.
-.
+\fB\-\-message\fP
+Message to include when autosquashing revision bumps, deletions and rebuilds\.
 .TP
-\fB\-\-tap\fR
-Target tap repository (default: \fBhomebrew/core\fR)\.
-.
+\fB\-\-artifact\-pattern\fP
+Download artifacts with the specified pattern (default: \fBbottles{,_*}\fP)\.
 .TP
-\fB\-\-root\-url\fR
-Use the specified \fIURL\fR as the root of the bottle\'s URL instead of Homebrew\'s default\.
-.
+\fB\-\-tap\fP
+Target tap repository (default: \fBhomebrew/core\fP)\.
 .TP
-\fB\-\-root\-url\-using\fR
-Use the specified download strategy class for downloading the bottle\'s URL instead of Homebrew\'s default\.
-.
+\fB\-\-root\-url\fP
+Use the specified \fIURL\fP as the root of the bottle\[u2019]s URL instead of Homebrew\[u2019]s default\.
 .TP
-\fB\-\-workflows\fR
-Retrieve artifacts from the specified workflow (default: \fBtests\.yml\fR)\. Can be a comma\-separated list to include multiple workflows\.
-.
+\fB\-\-root\-url\-using\fP
+Use the specified download strategy class for downloading the bottle\[u2019]s URL instead of Homebrew\[u2019]s default\.
 .TP
-\fB\-\-ignore\-missing\-artifacts\fR
+\fB\-\-workflows\fP
+Retrieve artifacts from the specified workflow (default: \fBtests\.yml\fP)\. Can be a comma\-separated list to include multiple workflows\.
+.TP
+\fB\-\-ignore\-missing\-artifacts\fP
 Comma\-separated list of workflows which can be ignored if they have not been run\.
-.
-.SS "\fBpr\-upload\fR [\fIoptions\fR]"
+.SS "\fBpr\-upload\fP \fR[\fIoptions\fP]"
 Apply the bottle commit and publish bottles to a host\.
-.
 .TP
-\fB\-\-keep\-old\fR
+\fB\-\-keep\-old\fP
 If the formula specifies a rebuild version, attempt to preserve its value in the generated DSL\.
-.
 .TP
-\fB\-n\fR, \fB\-\-dry\-run\fR
+\fB\-n\fP, \fB\-\-dry\-run\fP
 Print what would be done rather than doing it\.
-.
 .TP
-\fB\-\-no\-commit\fR
+\fB\-\-no\-commit\fP
 Do not generate a new commit before uploading\.
-.
 .TP
-\fB\-\-warn\-on\-upload\-failure\fR
+\fB\-\-warn\-on\-upload\-failure\fP
 Warn instead of raising an error if the bottle upload fails\. Useful for repairing bottle uploads that previously failed\.
-.
-.TP
-\fB\-\-upload\-only\fR
-Skip running \fBbrew bottle\fR before uploading\.
-.
-.TP
-\fB\-\-committer\fR
-Specify a committer name and email in \fBgit\fR\'s standard author format\.
-.
-.TP
-\fB\-\-root\-url\fR
-Use the specified \fIURL\fR as the root of the bottle\'s URL instead of Homebrew\'s default\.
-.
-.TP
-\fB\-\-root\-url\-using\fR
-Use the specified download strategy class for downloading the bottle\'s URL instead of Homebrew\'s default\.
-.
-.SS "\fBprof\fR [\fI\-\-stackprof\fR] \fIcommand\fR [\.\.\.]"
-Run Homebrew with a Ruby profiler\. For example, \fBbrew prof readall\fR\.
-.
-.TP
-\fB\-\-stackprof\fR
-Use \fBstackprof\fR instead of \fBruby\-prof\fR (the default)\.
-.
-.SS "\fBrelease\fR [\fI\-\-major\fR] [\fI\-\-minor\fR]"
+.TP
+\fB\-\-upload\-only\fP
+Skip running \fBbrew bottle\fP before uploading\.
+.TP
+\fB\-\-committer\fP
+Specify a committer name and email in \fBgit\fP\[u2019]s standard author format\.
+.TP
+\fB\-\-root\-url\fP
+Use the specified \fIURL\fP as the root of the bottle\[u2019]s URL instead of Homebrew\[u2019]s default\.
+.TP
+\fB\-\-root\-url\-using\fP
+Use the specified download strategy class for downloading the bottle\[u2019]s URL instead of Homebrew\[u2019]s default\.
+.SS "\fBprof\fP \fR[\fB\-\-stackprof\fP] \fR[\fB\-\-vernier\fP] \fIcommand\fP \fR[\.\.\.]"
+Run Homebrew with a Ruby profiler\. For example, \fBbrew prof readall\fP\&\.
+.TP
+\fB\-\-stackprof\fP
+Use \fBstackprof\fP instead of \fBruby\-prof\fP (the default)\.
+.TP
+\fB\-\-vernier\fP
+Use \fBvernier\fP instead of \fBruby\-prof\fP (the default)\.
+.SS "\fBrelease\fP \fR[\fB\-\-major\fP] \fR[\fB\-\-minor\fP]"
 Create a new draft Homebrew/brew release with the appropriate version number and release notes\.
-.
 .P
-By default, \fBbrew release\fR will bump the patch version number\. Pass \fB\-\-major\fR or \fB\-\-minor\fR to bump the major or minor version numbers, respectively\. The command will fail if the previous major or minor release was made less than one month ago\.
-.
+By default, \fBbrew release\fP will bump the patch version number\. Pass \fB\-\-major\fP or \fB\-\-minor\fP to bump the major or minor version numbers, respectively\. The command will fail if the previous major or minor release was made less than one month ago\.
 .P
-Requires write access to the Homebrew/brew repository\.
-.
+\fINote:\fP Requires write access to the Homebrew/brew repository\.
 .TP
-\fB\-\-major\fR
+\fB\-\-major\fP
 Create a major release\.
-.
 .TP
-\fB\-\-minor\fR
+\fB\-\-minor\fP
 Create a minor release\.
-.
-.SS "\fBrubocop\fR"
-Installs, configures and runs Homebrew\'s \fBrubocop\fR\.
-.
-.SS "\fBruby\fR [\fIoptions\fR] (\fB\-e\fR \fItext\fR|\fIfile\fR)"
-Run a Ruby instance with Homebrew\'s libraries loaded\. For example, \fBbrew ruby \-e "puts :gcc\.f\.deps"\fR or \fBbrew ruby script\.rb\fR\.
-.
-.TP
-\fB\-r\fR
-Load a library using \fBrequire\fR\.
-.
-.TP
-\fB\-e\fR
+.SS "\fBrubocop\fP"
+Installs, configures and runs Homebrew\[u2019]s \fBrubocop\fP\&\.
+.SS "\fBruby\fP \fR[\fIoptions\fP] (\fB\-e\fP \fItext\fP|\fIfile\fP)"
+Run a Ruby instance with Homebrew\[u2019]s libraries loaded\. For example, \fBbrew ruby \-e "puts :gcc\.f\.deps"\fP or \fBbrew ruby script\.rb\fP\&\.
+.P
+Run e\.g\. \fBbrew ruby \-\- \-\-version\fP to pass arbitrary arguments to \fBruby\fP\&\.
+.TP
+\fB\-r\fP
+Load a library using \fBrequire\fP\&\.
+.TP
+\fB\-e\fP
 Execute the given text string as a script\.
-.
-.SS "\fBsh\fR [\fI\-\-env\fR\fB=\fR] [\fI\-\-cmd\fR\fB=\fR] [\fIfile\fR]"
-Enter an interactive shell for Homebrew\'s build environment\. Use years\-battle\-hardened build logic to help your \fB\./configure && make && make install\fR and even your \fBgem install\fR succeed\. Especially handy if you run Homebrew in an Xcode\-only configuration since it adds tools like \fBmake\fR to your \fBPATH\fR which build systems would not find otherwise\.
-.
+.SS "\fBrubydoc\fP \fR[\fB\-\-only\-public\fP] \fR[\fB\-\-open\fP]"
+Generate Homebrew\[u2019]s RubyDoc documentation\.
+.TP
+\fB\-\-only\-public\fP
+Only generate public API documentation\.
+.TP
+\fB\-\-open\fP
+Open generated documentation in a browser\.
+.SS "\fBsh\fP \fR[\fB\-\-env=\fP] \fR[\fB\-\-cmd=\fP] \fR[\fIfile\fP]"
+Enter an interactive shell for Homebrew\[u2019]s build environment\. Use years\-battle\-hardened build logic to help your \fB\&\./configure && make && make install\fP and even your \fBgem install\fP succeed\. Especially handy if you run Homebrew in an Xcode\-only configuration since it adds tools like \fBmake\fP to your \fBPATH\fP which build systems would not find otherwise\.
 .TP
-\fB\-\-env\fR
-Use the standard \fBPATH\fR instead of superenv\'s when \fBstd\fR is passed\.
-.
+\fB\-\-env\fP
+Use the standard \fBPATH\fP instead of superenv\[u2019]s when \fBstd\fP is passed\.
 .TP
-\fB\-c\fR, \fB\-\-cmd\fR
+\fB\-c\fP, \fB\-\-cmd\fP
 Execute commands in a non\-interactive shell\.
-.
-.SS "\fBsponsors\fR"
-Update the list of GitHub Sponsors in the \fBHomebrew/brew\fR README\.
-.
-.SS "\fBstyle\fR [\fIoptions\fR] [\fIfile\fR|\fItap\fR|\fIformula\fR|\fIcask\fR \.\.\.]"
+.SS "\fBstyle\fP \fR[\fIoptions\fP] \fR[\fIfile\fP|\fItap\fP|\fIformula\fP|\fIcask\fP \.\.\.]"
 Check formulae or files for conformance to Homebrew style guidelines\.
-.
 .P
-Lists of \fIfile\fR, \fItap\fR and \fIformula\fR may not be combined\. If none are provided, \fBstyle\fR will run style checks on the whole Homebrew library, including core code and all formulae\.
-.
+Lists of \fIfile\fP, \fItap\fP and \fIformula\fP may not be combined\. If none are provided, \fBstyle\fP will run style checks on the whole Homebrew library, including core code and all formulae\.
 .TP
-\fB\-\-fix\fR
-Fix style violations automatically using RuboCop\'s auto\-correct feature\.
-.
+\fB\-\-fix\fP
+Fix style violations automatically using RuboCop\[u2019]s auto\-correct feature\.
 .TP
-\fB\-\-display\-cop\-names\fR
-Include the RuboCop cop name for each violation in the output\.
-.
-.TP
-\fB\-\-reset\-cache\fR
+\fB\-\-reset\-cache\fP
 Reset the RuboCop cache\.
-.
 .TP
-\fB\-\-formula\fR
+\fB\-\-formula\fP
 Treat all named arguments as formulae\.
-.
 .TP
-\fB\-\-cask\fR
+\fB\-\-cask\fP
 Treat all named arguments as casks\.
-.
 .TP
-\fB\-\-only\-cops\fR
-Specify a comma\-separated \fIcops\fR list to check for violations of only the listed RuboCop cops\.
-.
+\fB\-\-only\-cops\fP
+Specify a comma\-separated \fIcops\fP list to check for violations of only the listed RuboCop cops\.
 .TP
-\fB\-\-except\-cops\fR
-Specify a comma\-separated \fIcops\fR list to skip checking for violations of the listed RuboCop cops\.
-.
-.SS "\fBtap\-new\fR [\fIoptions\fR] \fIuser\fR\fB/\fR\fIrepo\fR"
+\fB\-\-except\-cops\fP
+Specify a comma\-separated \fIcops\fP list to skip checking for violations of the listed RuboCop cops\.
+.SS "\fBtap\-new\fP \fR[\fIoptions\fP] \fIuser\fP\fB/\fP\fIrepo\fP"
 Generate the template files for a new tap\.
-.
 .TP
-\fB\-\-no\-git\fR
-Don\'t initialize a Git repository for the tap\.
-.
+\fB\-\-no\-git\fP
+Don\[u2019]t initialize a Git repository for the tap\.
 .TP
-\fB\-\-pull\-label\fR
-Label name for pull requests ready to be pulled (default: \fBpr\-pull\fR)\.
-.
+\fB\-\-pull\-label\fP
+Label name for pull requests ready to be pulled (default: \fBpr\-pull\fP)\.
 .TP
-\fB\-\-branch\fR
-Initialize Git repository and setup GitHub Actions workflows with the specified branch name (default: \fBmain\fR)\.
-.
+\fB\-\-branch\fP
+Initialize Git repository and setup GitHub Actions workflows with the specified branch name (default: \fBmain\fP)\.
 .TP
-\fB\-\-github\-packages\fR
+\fB\-\-github\-packages\fP
 Upload bottles to GitHub Packages\.
-.
-.SS "\fBtest\fR [\fIoptions\fR] \fIinstalled_formula\fR [\.\.\.]"
+.SS "\fBtest\fP \fR[\fIoptions\fP] \fIinstalled_formula\fP \fR[\.\.\.]"
 Run the test method provided by an installed formula\. There is no standard output or return code, but generally it should notify the user if something is wrong with the installed formula\.
-.
 .P
-\fIExample:\fR \fBbrew install jruby && brew test jruby\fR
-.
+\fIExample:\fP \fBbrew install jruby && brew test jruby\fP
 .TP
-\fB\-f\fR, \fB\-\-force\fR
+\fB\-f\fP, \fB\-\-force\fP
 Test formulae even if they are unlinked\.
-.
 .TP
-\fB\-\-HEAD\fR
-Test the head version of a formula\.
-.
+\fB\-\-HEAD\fP
+Test the HEAD version of a formula\.
 .TP
-\fB\-\-keep\-tmp\fR
+\fB\-\-keep\-tmp\fP
 Retain the temporary files created for the test\.
-.
 .TP
-\fB\-\-retry\fR
+\fB\-\-retry\fP
 Retry if a testing fails\.
-.
-.SS "\fBtests\fR [\fIoptions\fR]"
-Run Homebrew\'s unit and integration tests\.
-.
+.SS "\fBtests\fP \fR[\fIoptions\fP]"
+Run Homebrew\[u2019]s unit and integration tests\.
 .TP
-\fB\-\-coverage\fR
+\fB\-\-coverage\fP
 Generate code coverage reports\.
-.
 .TP
-\fB\-\-generic\fR
+\fB\-\-generic\fP
 Run only OS\-agnostic tests\.
-.
-.TP
-\fB\-\-no\-compat\fR
-Do not load the compatibility layer when running tests\.
-.
 .TP
-\fB\-\-online\fR
+\fB\-\-online\fP
 Include tests that use the GitHub API and tests that use any of the taps for official external commands\.
-.
 .TP
-\fB\-\-byebug\fR
-Enable debugging using byebug\.
-.
+\fB\-\-debug\fP
+Enable debugging using \fBruby/debug\fP, or surface the standard \fBodebug\fP output\.
 .TP
-\fB\-\-changed\fR
+\fB\-\-changed\fP
 Only runs tests on files that were changed from the master branch\.
-.
 .TP
-\fB\-\-only\fR
-Run only \fItest_script\fR\fB_spec\.rb\fR\. Appending \fB:\fR\fIline_number\fR will start at a specific line\.
-.
+\fB\-\-fail\-fast\fP
+Exit early on the first failing test\.
+.TP
+\fB\-\-only\fP
+Run only \fB<test_script>_spec\.rb\fP\&\. Appending \fB:<line_number>\fP will start at a specific line\.
 .TP
-\fB\-\-seed\fR
-Randomise tests with the specified \fIvalue\fR instead of a random seed\.
-.
-.SS "\fBtypecheck\fR, \fBtc\fR [\fIoptions\fR]"
+\fB\-\-profile\fP
+Run the test suite serially to find the \fIn\fP slowest tests\.
+.TP
+\fB\-\-seed\fP
+Randomise tests with the specified \fIvalue\fP instead of a random seed\.
+.SS "\fBtypecheck\fP, \fBtc\fP \fR[\fIoptions\fP] \fR[\fItap\fP \.\.\.]"
 Check for typechecking errors using Sorbet\.
-.
 .TP
-\fB\-\-fix\fR
+\fB\-\-fix\fP
 Automatically fix type errors\.
-.
 .TP
-\fB\-q\fR, \fB\-\-quiet\fR
+\fB\-q\fP, \fB\-\-quiet\fP
 Silence all non\-critical errors\.
-.
 .TP
-\fB\-\-update\fR
+\fB\-\-update\fP
 Update RBI files\.
-.
 .TP
-\fB\-\-all\fR
-Regenerate all RBI files rather than just updated gems\.
-.
+\fB\-\-update\-all\fP
+Update all RBI files rather than just updated gems\.
 .TP
-\fB\-\-suggest\-typed\fR
-Try upgrading \fBtyped\fR sigils\.
-.
+\fB\-\-suggest\-typed\fP
+Try upgrading \fBtyped\fP sigils\.
 .TP
-\fB\-\-fail\-if\-not\-changed\fR
-Return a failing status code if all gems are up to date and gem definitions do not need a tapioca update\.
-.
+\fB\-\-lsp\fP
+Start the Sorbet LSP server\.
 .TP
-\fB\-\-dir\fR
+\fB\-\-dir\fP
 Typecheck all files in a specific directory\.
-.
 .TP
-\fB\-\-file\fR
+\fB\-\-file\fP
 Typecheck a single file\.
-.
 .TP
-\fB\-\-ignore\fR
+\fB\-\-ignore\fP
 Ignores input files that contain the given string in their paths (relative to the input path passed to Sorbet)\.
-.
-.SS "\fBunbottled\fR [\fIoptions\fR] [\fIformula\fR \.\.\.]"
+.SS "\fBunbottled\fP \fR[\fIoptions\fP] \fR[\fIformula\fP \.\.\.]"
 Show the unbottled dependents of formulae\.
-.
 .TP
-\fB\-\-tag\fR
-Use the specified bottle tag (e\.g\. \fBbig_sur\fR) instead of the current OS\.
-.
+\fB\-\-tag\fP
+Use the specified bottle tag (e\.g\. \fBbig_sur\fP) instead of the current OS\.
 .TP
-\fB\-\-dependents\fR
+\fB\-\-dependents\fP
 Skip getting analytics data and sort by number of dependents instead\.
-.
 .TP
-\fB\-\-all\fR
+\fB\-\-total\fP
 Print the number of unbottled and total formulae\.
-.
-.SS "\fBunpack\fR [\fIoptions\fR] \fIformula\fR [\.\.\.]"
-Unpack the source files for \fIformula\fR into subdirectories of the current working directory\.
-.
 .TP
-\fB\-\-destdir\fR
-Create subdirectories in the directory named by \fIpath\fR instead\.
-.
+\fB\-\-lost\fP
+Print the \fBhomebrew/core\fP commits where bottles were lost in the last week\.
+.TP
+\fB\-\-eval\-all\fP
+Evaluate all available formulae and casks, whether installed or not, to check them\. Implied if \fBHOMEBREW_EVAL_ALL\fP is set\.
+.SS "\fBunpack\fP \fR[\fIoptions\fP] \fIformula\fP \fR[\.\.\.]"
+Unpack the source files for \fIformula\fP into subdirectories of the current working directory\.
+.TP
+\fB\-\-destdir\fP
+Create subdirectories in the directory named by \fIpath\fP instead\.
 .TP
-\fB\-\-patch\fR
-Patches for \fIformula\fR will be applied to the unpacked source\.
-.
+\fB\-\-patch\fP
+Patches for \fIformula\fP will be applied to the unpacked source\.
 .TP
-\fB\-g\fR, \fB\-\-git\fR
+\fB\-g\fP, \fB\-\-git\fP
 Initialise a Git repository in the unpacked source\. This is useful for creating patches for the software\.
-.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
+\fB\-f\fP, \fB\-\-force\fP
 Overwrite the destination directory if it already exists\.
-.
-.SS "\fBupdate\-license\-data\fR [\fI\-\-fail\-if\-not\-changed\fR]"
+.SS "\fBupdate\-license\-data\fP"
 Update SPDX license data in the Homebrew repository\.
-.
-.TP
-\fB\-\-fail\-if\-not\-changed\fR
-Return a failing status code if current license data\'s version is the same as the upstream\. This can be used to notify CI when the SPDX license data is out of date\.
-.
-.SS "\fBupdate\-maintainers\fR"
-Update the list of maintainers in the \fBHomebrew/brew\fR README\.
-.
-.SS "\fBupdate\-python\-resources\fR [\fIoptions\fR] \fIformula\fR [\.\.\.]"
-Update versions for PyPI resource blocks in \fIformula\fR\.
-.
-.TP
-\fB\-p\fR, \fB\-\-print\-only\fR
-Print the updated resource blocks instead of changing \fIformula\fR\.
-.
-.TP
-\fB\-s\fR, \fB\-\-silent\fR
+.SS "\fBupdate\-maintainers\fP"
+Update the list of maintainers in the \fBHomebrew/brew\fP README\.
+.SS "\fBupdate\-python\-resources\fP \fR[\fIoptions\fP] \fIformula\fP \fR[\.\.\.]"
+Update versions for PyPI resource blocks in \fIformula\fP\&\.
+.TP
+\fB\-p\fP, \fB\-\-print\-only\fP
+Print the updated resource blocks instead of changing \fIformula\fP\&\.
+.TP
+\fB\-s\fP, \fB\-\-silent\fP
 Suppress any output\.
-.
 .TP
-\fB\-\-ignore\-non\-pypi\-packages\fR
-Don\'t fail if \fIformula\fR is not a PyPI package\.
-.
+\fB\-\-ignore\-non\-pypi\-packages\fP
+Don\[u2019]t fail if \fIformula\fP is not a PyPI package\.
+.TP
+\fB\-\-install\-dependencies\fP
+Install missing dependencies required to update resources\.
 .TP
-\fB\-\-version\fR
-Use the specified \fIversion\fR when finding resources for \fIformula\fR\. If no version is specified, the current version for \fIformula\fR will be used\.
-.
+\fB\-\-version\fP
+Use the specified \fIversion\fP when finding resources for \fIformula\fP\&\. If no version is specified, the current version for \fIformula\fP will be used\.
 .TP
-\fB\-\-package\-name\fR
-Use the specified \fIpackage\-name\fR when finding resources for \fIformula\fR\. If no package name is specified, it will be inferred from the formula\'s stable URL\.
-.
+\fB\-\-package\-name\fP
+Use the specified \fIpackage\-name\fP when finding resources for \fIformula\fP\&\. If no package name is specified, it will be inferred from the formula\[u2019]s stable URL\.
 .TP
-\fB\-\-extra\-packages\fR
+\fB\-\-extra\-packages\fP
 Include these additional packages when finding resources\.
-.
 .TP
-\fB\-\-exclude\-packages\fR
+\fB\-\-exclude\-packages\fP
 Exclude these packages when finding resources\.
-.
-.SS "\fBupdate\-test\fR [\fIoptions\fR]"
-Run a test of \fBbrew update\fR with a new repository clone\. If no options are passed, use \fBorigin/master\fR as the start commit\.
-.
+.SS "\fBupdate\-sponsors\fP"
+Update the list of GitHub Sponsors in the \fBHomebrew/brew\fP README\.
+.SS "\fBupdate\-test\fP \fR[\fIoptions\fP]"
+Run a test of \fBbrew update\fP with a new repository clone\. If no options are passed, use \fBorigin/master\fP as the start commit\.
 .TP
-\fB\-\-to\-tag\fR
-Set \fBHOMEBREW_UPDATE_TO_TAG\fR to test updating between tags\.
-.
+\fB\-\-to\-tag\fP
+Set \fBHOMEBREW_UPDATE_TO_TAG\fP to test updating between tags\.
 .TP
-\fB\-\-keep\-tmp\fR
+\fB\-\-keep\-tmp\fP
 Retain the temporary directory containing the new repository clone\.
-.
-.TP
-\fB\-\-commit\fR
-Use the specified \fIcommit\fR as the start commit\.
-.
-.TP
-\fB\-\-before\fR
-Use the commit at the specified \fIdate\fR as the start commit\.
-.
-.SS "\fBvendor\-gems\fR [\fI\-\-update\fR\fB=\fR]"
-Install and commit Homebrew\'s vendored gems\.
-.
-.TP
-\fB\-\-update\fR
-Update all vendored Gems to the latest version\.
-.
+.TP
+\fB\-\-commit\fP
+Use the specified \fIcommit\fP as the start commit\.
+.TP
+\fB\-\-before\fP
+Use the commit at the specified \fIdate\fP as the start commit\.
+.SS "\fBvendor\-gems\fP \fR[\fB\-\-update=\fP] \fR[\fB\-\-no\-commit\fP]"
+Install and commit Homebrew\[u2019]s vendored gems\.
+.TP
+\fB\-\-update\fP
+Update the specified list of vendored gems to the latest version\.
+.TP
+\fB\-\-no\-commit\fP
+Do not generate a new commit upon completion\.
 .SH "GLOBAL CASK OPTIONS"
-These options are applicable to the \fBinstall\fR, \fBreinstall\fR, and \fBupgrade\fR subcommands with the \fB\-\-cask\fR flag\.
-.
+These options are applicable to the \fBinstall\fP, \fBreinstall\fP and \fBupgrade\fP subcommands with the \fB\-\-cask\fP switch\.
+.TP
+\fB\-\-appdir\fP
+Target location for Applications (default: \fB/Applications\fP)\.
 .TP
-\fB\-\-appdir\fR
-Target location for Applications (default: \fB/Applications\fR)\.
-.
+\fB\-\-keyboard\-layoutdir\fP
+Target location for Keyboard Layouts (default: \fB/Library/Keyboard Layouts\fP)\.
 .TP
-\fB\-\-colorpickerdir\fR
-Target location for Color Pickers (default: \fB~/Library/ColorPickers\fR)\.
-.
+\fB\-\-colorpickerdir\fP
+Target location for Color Pickers (default: \fB~/Library/ColorPickers\fP)\.
 .TP
-\fB\-\-prefpanedir\fR
-Target location for Preference Panes (default: \fB~/Library/PreferencePanes\fR)\.
-.
+\fB\-\-prefpanedir\fP
+Target location for Preference Panes (default: \fB~/Library/PreferencePanes\fP)\.
 .TP
-\fB\-\-qlplugindir\fR
-Target location for QuickLook Plugins (default: \fB~/Library/QuickLook\fR)\.
-.
+\fB\-\-qlplugindir\fP
+Target location for Quick Look Plugins (default: \fB~/Library/QuickLook\fP)\.
 .TP
-\fB\-\-mdimporterdir\fR
-Target location for Spotlight Plugins (default: \fB~/Library/Spotlight\fR)\.
-.
+\fB\-\-mdimporterdir\fP
+Target location for Spotlight Plugins (default: \fB~/Library/Spotlight\fP)\.
 .TP
-\fB\-\-dictionarydir\fR
-Target location for Dictionaries (default: \fB~/Library/Dictionaries\fR)\.
-.
+\fB\-\-dictionarydir\fP
+Target location for Dictionaries (default: \fB~/Library/Dictionaries\fP)\.
 .TP
-\fB\-\-fontdir\fR
-Target location for Fonts (default: \fB~/Library/Fonts\fR)\.
-.
+\fB\-\-fontdir\fP
+Target location for Fonts (default: \fB~/Library/Fonts\fP)\.
 .TP
-\fB\-\-servicedir\fR
-Target location for Services (default: \fB~/Library/Services\fR)\.
-.
+\fB\-\-servicedir\fP
+Target location for Services (default: \fB~/Library/Services\fP)\.
 .TP
-\fB\-\-input\-methoddir\fR
-Target location for Input Methods (default: \fB~/Library/Input Methods\fR)\.
-.
+\fB\-\-input\-methoddir\fP
+Target location for Input Methods (default: \fB~/Library/Input Methods\fP)\.
 .TP
-\fB\-\-internet\-plugindir\fR
-Target location for Internet Plugins (default: \fB~/Library/Internet Plug\-Ins\fR)\.
-.
+\fB\-\-internet\-plugindir\fP
+Target location for Internet Plugins (default: \fB~/Library/Internet Plug\-Ins\fP)\.
 .TP
-\fB\-\-audio\-unit\-plugindir\fR
-Target location for Audio Unit Plugins (default: \fB~/Library/Audio/Plug\-Ins/Components\fR)\.
-.
+\fB\-\-audio\-unit\-plugindir\fP
+Target location for Audio Unit Plugins (default: \fB~/Library/Audio/Plug\-Ins/Components\fP)\.
 .TP
-\fB\-\-vst\-plugindir\fR
-Target location for VST Plugins (default: \fB~/Library/Audio/Plug\-Ins/VST\fR)\.
-.
+\fB\-\-vst\-plugindir\fP
+Target location for VST Plugins (default: \fB~/Library/Audio/Plug\-Ins/VST\fP)\.
 .TP
-\fB\-\-vst3\-plugindir\fR
-Target location for VST3 Plugins (default: \fB~/Library/Audio/Plug\-Ins/VST3\fR)\.
-.
+\fB\-\-vst3\-plugindir\fP
+Target location for VST3 Plugins (default: \fB~/Library/Audio/Plug\-Ins/VST3\fP)\.
 .TP
-\fB\-\-screen\-saverdir\fR
-Target location for Screen Savers (default: \fB~/Library/Screen Savers\fR)\.
-.
+\fB\-\-screen\-saverdir\fP
+Target location for Screen Savers (default: \fB~/Library/Screen Savers\fP)\.
 .TP
-\fB\-\-language\fR
-Comma\-separated list of language codes to prefer for cask installation\. The first matching language is used, otherwise it reverts to the cask\'s default language\. The default value is the language of your system\.
-.
+\fB\-\-language\fP
+Comma\-separated list of language codes to prefer for cask installation\. The first matching language is used, otherwise it reverts to the cask\[u2019]s default language\. The default value is the language of your system\.
 .SH "GLOBAL OPTIONS"
 These options are applicable across multiple subcommands\.
-.
 .TP
-\fB\-d\fR, \fB\-\-debug\fR
+\fB\-d\fP, \fB\-\-debug\fP
 Display any debugging information\.
-.
 .TP
-\fB\-q\fR, \fB\-\-quiet\fR
+\fB\-q\fP, \fB\-\-quiet\fP
 Make some output more quiet\.
-.
 .TP
-\fB\-v\fR, \fB\-\-verbose\fR
+\fB\-v\fP, \fB\-\-verbose\fP
 Make some output more verbose\.
-.
 .TP
-\fB\-h\fR, \fB\-\-help\fR
+\fB\-h\fP, \fB\-\-help\fP
 Show this message\.
-.
 .SH "OFFICIAL EXTERNAL COMMANDS"
-.
-.SS "\fBalias\fR [\fIalias\fR \.\.\. | \fIalias\fR=\fIcommand\fR]"
+.SS "\fBalias\fP \fR[\fIalias\fP \.\.\. | \fIalias\fP=\fIcommand\fP]"
 Show existing aliases\. If no aliases are given, print the whole list\.
-.
 .TP
-\fB\-\-edit\fR
-Edit aliases in a text editor\. Either one or all aliases may be opened at once\. If the given alias doesn\'t exist it\'ll be pre\-populated with a template\.
-.
-.SS "\fBautoupdate\fR \fIsubcommand\fR [\fIinterval\fR] [\fIoptions\fR]"
-An easy, convenient way to automatically update Homebrew\.
-.
-.P
-This script will run \fBbrew update\fR in the background once every 24 hours (by default) until explicitly told to stop, utilising \fBlaunchd\fR\.
-.
-.P
-\fBbrew autoupdate start\fR [\fI\fBinterval\fR\fR] [\fI\fBoptions\fR\fR]
-    Start autoupdating either once every \fBinterval\fR hours or once every 24 hours\. Please note the interval has to be passed in seconds, so 12 hours would be \fBbrew autoupdate start 43200\fR\. Pass \fB\-\-upgrade\fR or \fB\-\-cleanup\fR to automatically run \fBbrew upgrade\fR and/or \fBbrew cleanup\fR respectively\. Pass \fB\-\-enable\-notification\fR to send a notification when the autoupdate process has finished successfully\.
-.
-.P
-\fBbrew autoupdate stop\fR
-    Stop autoupdating, but retain plist & logs\.
-.
+\fB\-\-edit\fP
+Edit aliases in a text editor\. Either one or all aliases may be opened at once\. If the given alias doesn\[u2019]t exist it\[u2019]ll be pre\-populated with a template\.
+.SS "\fBbundle\fP \fR[\fIsubcommand\fP]"
+Bundler for non\-Ruby dependencies from Homebrew, Homebrew Cask, Mac App Store, Whalebrew and Visual Studio Code\.
+.TP
+\fBbrew bundle\fP [\fBinstall\fP]
+Install and upgrade (by default) all dependencies from the \fBBrewfile\fP\&\.
 .P
-\fBbrew autoupdate delete\fR
-    Cancel the autoupdate, delete the plist and logs\.
-.
+You can specify the \fBBrewfile\fP location using \fB\-\-file\fP or by setting the \fBHOMEBREW_BUNDLE_FILE\fP environment variable\.
 .P
-\fBbrew autoupdate status\fR
-    Prints the current status of this tool\.
-.
+You can skip the installation of dependencies by adding space\-separated values to one or more of the following environment variables: \fBHOMEBREW_BUNDLE_BREW_SKIP\fP, \fBHOMEBREW_BUNDLE_CASK_SKIP\fP, \fBHOMEBREW_BUNDLE_MAS_SKIP\fP, \fBHOMEBREW_BUNDLE_WHALEBREW_SKIP\fP, \fBHOMEBREW_BUNDLE_TAP_SKIP\fP\&\.
 .P
-\fBbrew autoupdate version\fR
-    Output this tool\'s current version, and a short changelog\.
-.
+\fBbrew bundle\fP will output a \fBBrewfile\.lock\.json\fP in the same directory as the \fBBrewfile\fP if all dependencies are installed successfully\. This contains dependency and system status information which can be useful for debugging \fBbrew bundle\fP failures and replicating a \[u201c]last known good build\[u201d] state\. You can opt\-out of this behaviour by setting the \fBHOMEBREW_BUNDLE_NO_LOCK\fP environment variable or passing the \fB\-\-no\-lock\fP option\. You may wish to check this file into the same version control system as your \fBBrewfile\fP (or ensure your version control system ignores it if you\[u2019]d prefer to rely on debugging information from a local machine)\.
 .TP
-\fB\-\-upgrade\fR
-Automatically upgrade your installed formulae\. If the Caskroom exists locally Casks will be upgraded as well\. Must be passed with \fBstart\fR\.
-.
+\fBbrew bundle dump\fP
+Write all installed casks/formulae/images/taps into a \fBBrewfile\fP in the current directory\.
 .TP
-\fB\-\-greedy\fR
-Upgrade casks with \-\-greedy (include auto\-updating casks)\. Must be passed with \fBstart\fR\.
-.
-.TP
-\fB\-\-cleanup\fR
-Automatically clean brew\'s cache and logs\. Must be passed with \fBstart\fR\.
-.
-.TP
-\fB\-\-enable\-notification\fR
-Send a notification when the autoupdate process has finished successfully, if \fBterminal\-notifier\fR is installed & found\. Must be passed with \fBstart\fR\. <NOTE: Notifications are enabled by default on macOS Catalina and newer\.>
-.
-.TP
-\fB\-\-immediate\fR
-Starts the autoupdate command immediately, instead of waiting for one interval (24 hours by default) to pass first\. Must be passed with \fBstart\fR\.
-.
-.SS "\fBbundle\fR [\fIsubcommand\fR]"
-Bundler for non\-Ruby dependencies from Homebrew, Homebrew Cask, Mac App Store and Whalebrew\.
-.
-.P
-\fBbrew bundle\fR [\fBinstall\fR]
-    Install and upgrade (by default) all dependencies from the \fBBrewfile\fR\.
-.
-.P
-You can specify the \fBBrewfile\fR location using \fB\-\-file\fR or by setting the \fBHOMEBREW_BUNDLE_FILE\fR environment variable\.
-.
-.P
-You can skip the installation of dependencies by adding space\-separated values to one or more of the following environment variables: \fBHOMEBREW_BUNDLE_BREW_SKIP\fR, \fBHOMEBREW_BUNDLE_CASK_SKIP\fR, \fBHOMEBREW_BUNDLE_MAS_SKIP\fR, \fBHOMEBREW_BUNDLE_WHALEBREW_SKIP\fR, \fBHOMEBREW_BUNDLE_TAP_SKIP\fR\.
-.
-.P
-\fBbrew bundle\fR will output a \fBBrewfile\.lock\.json\fR in the same directory as the \fBBrewfile\fR if all dependencies are installed successfully\. This contains dependency and system status information which can be useful in debugging \fBbrew bundle\fR failures and replicating a "last known good build" state\. You can opt\-out of this behaviour by setting the \fBHOMEBREW_BUNDLE_NO_LOCK\fR environment variable or passing the \fB\-\-no\-lock\fR option\. You may wish to check this file into the same version control system as your \fBBrewfile\fR (or ensure your version control system ignores it if you\'d prefer to rely on debugging information from a local machine)\.
-.
-.P
-\fBbrew bundle dump\fR
-    Write all installed casks/formulae/images/taps into a \fBBrewfile\fR in the current directory\.
-.
-.P
-\fBbrew bundle cleanup\fR
-    Uninstall all dependencies not listed from the \fBBrewfile\fR\.
-.
+\fBbrew bundle cleanup\fP
+Uninstall all dependencies not present in the \fBBrewfile\fP\&\.
 .P
 This workflow is useful for maintainers or testers who regularly install lots of formulae\.
-.
 .P
-\fBbrew bundle check\fR
-    Check if all dependencies are installed from the \fBBrewfile\fR\.
-.
+Unless \fB\-\-force\fP is passed, this returns a 1 exit code if anything would be removed\.
+.TP
+\fBbrew bundle check\fP
+Check if all dependencies present in the \fBBrewfile\fP are installed\.
 .P
 This provides a successful exit code if everything is up\-to\-date, making it useful for scripting\.
-.
-.P
-\fBbrew bundle list\fR
-    List all dependencies present in the \fBBrewfile\fR\.
-.
-.P
-By default, only Homebrew dependencies are listed\.
-.
+.TP
+\fBbrew bundle list\fP
+List all dependencies present in the \fBBrewfile\fP\&\.
 .P
-\fBbrew bundle exec\fR \fIcommand\fR
-    Run an external command in an isolated build environment based on the \fBBrewfile\fR dependencies\.
-.
+By default, only Homebrew formula dependencies are listed\.
+.TP
+\fBbrew bundle exec\fP \fIcommand\fP
+Run an external command in an isolated build environment based on the \fBBrewfile\fP dependencies\.
 .P
-This sanitized build environment ignores unrequested dependencies, which makes sure that things you didn\'t specify in your \fBBrewfile\fR won\'t get picked up by commands like \fBbundle install\fR, \fBnpm install\fR, etc\. It will also add compiler flags which will help find keg\-only dependencies like \fBopenssl\fR, \fBicu4c\fR, etc\.
-.
+This sanitized build environment ignores unrequested dependencies, which makes sure that things you didn\[u2019]t specify in your \fBBrewfile\fP won\[u2019]t get picked up by commands like \fBbundle install\fP, \fBnpm install\fP, etc\. It will also add compiler flags which will help with finding keg\-only dependencies like \fBopenssl\fP, \fBicu4c\fP, etc\.
+.TP
+\fB\-\-file\fP
+Read the \fBBrewfile\fP from this location\. Use \fB\-\-file=\-\fP to pipe to stdin/stdout\.
 .TP
-\fB\-\-file\fR
-Read the \fBBrewfile\fR from this location\. Use \fB\-\-file=\-\fR to pipe to stdin/stdout\.
-.
+\fB\-\-global\fP
+Read the \fBBrewfile\fP from \fB~/\.Brewfile\fP or the \fBHOMEBREW_BUNDLE_FILE_GLOBAL\fP environment variable, if set\.
 .TP
-\fB\-\-global\fR
-Read the \fBBrewfile\fR from \fB~/\.Brewfile\fR\.
-.
+\fB\-v\fP, \fB\-\-verbose\fP
+\fBinstall\fP prints output from commands as they are run\. \fBcheck\fP lists all missing dependencies\.
 .TP
-\fB\-v\fR, \fB\-\-verbose\fR
-\fBinstall\fR prints output from commands as they are run\. \fBcheck\fR lists all missing dependencies\.
-.
+\fB\-\-no\-upgrade\fP
+\fBinstall\fP does not run \fBbrew upgrade\fP on outdated dependencies\. Note they may still be upgraded by \fBbrew install\fP if needed\.
 .TP
-\fB\-\-no\-upgrade\fR
-\fBinstall\fR won\'t run \fBbrew upgrade\fR on outdated dependencies\. Note they may still be upgraded by \fBbrew install\fR if needed\.
-.
+\fB\-f\fP, \fB\-\-force\fP
+\fBinstall\fP runs with \fB\-\-force\fP/\fB\-\-overwrite\fP\&\. \fBdump\fP overwrites an existing \fBBrewfile\fP\&\. \fBcleanup\fP actually performs its cleanup operations\.
 .TP
-\fB\-f\fR, \fB\-\-force\fR
-\fBdump\fR overwrites an existing \fBBrewfile\fR\. \fBcleanup\fR actually performs its cleanup operations\.
-.
+\fB\-\-cleanup\fP
+\fBinstall\fP performs cleanup operation, same as running \fBcleanup \-\-force\fP\&\. This is enabled by default if \fBHOMEBREW_BUNDLE_INSTALL_CLEANUP\fP is set and \fB\-\-global\fP is passed\.
 .TP
-\fB\-\-cleanup\fR
-\fBinstall\fR performs cleanup operation, same as running \fBcleanup \-\-force\fR\.
-.
+\fB\-\-no\-lock\fP
+\fBinstall\fP does not output a \fBBrewfile\.lock\.json\fP\&\.
 .TP
-\fB\-\-no\-lock\fR
-\fBinstall\fR won\'t output a \fBBrewfile\.lock\.json\fR\.
-.
+\fB\-\-all\fP
+\fBlist\fP all dependencies\.
 .TP
-\fB\-\-all\fR
-\fBlist\fR all dependencies\.
-.
+\fB\-\-formula\fP
+\fBlist\fP or \fBdump\fP Homebrew formula dependencies\.
 .TP
-\fB\-\-formula\fR
-\fBlist\fR Homebrew dependencies\.
-.
+\fB\-\-cask\fP
+\fBlist\fP or \fBdump\fP Homebrew cask dependencies\.
 .TP
-\fB\-\-cask\fR
-\fBlist\fR Homebrew Cask dependencies\.
-.
+\fB\-\-tap\fP
+\fBlist\fP or \fBdump\fP Homebrew tap dependencies\.
 .TP
-\fB\-\-tap\fR
-\fBlist\fR tap dependencies\.
-.
+\fB\-\-mas\fP
+\fBlist\fP or \fBdump\fP Mac App Store dependencies\.
 .TP
-\fB\-\-mas\fR
-\fBlist\fR Mac App Store dependencies\.
-.
+\fB\-\-whalebrew\fP
+\fBlist\fP or \fBdump\fP Whalebrew dependencies\.
 .TP
-\fB\-\-whalebrew\fR
-\fBlist\fR Whalebrew dependencies\.
-.
+\fB\-\-vscode\fP
+\fBlist\fP or \fBdump\fP VSCode extensions\.
 .TP
-\fB\-\-describe\fR
-\fBdump\fR adds a description comment above each line, unless the dependency does not have a description\.
-.
+\fB\-\-no\-vscode\fP
+\fBdump\fP without VSCode extensions\. This is enabled by default if \fBHOMEBREW_BUNDLE_DUMP_NO_VSCODE\fP is set\.
 .TP
-\fB\-\-no\-restart\fR
-\fBdump\fR does not add \fBrestart_service\fR to formula lines\.
-.
+\fB\-\-describe\fP
+\fBdump\fP adds a description comment above each line, unless the dependency does not have a description\. This is enabled by default if \fBHOMEBREW_BUNDLE_DUMP_DESCRIBE\fP is set\.
 .TP
-\fB\-\-zap\fR
-\fBcleanup\fR casks using the \fBzap\fR command instead of \fBuninstall\fR\.
-.
-.SS "\fBcommand\-not\-found\-init\fR"
+\fB\-\-no\-restart\fP
+\fBdump\fP does not add \fBrestart_service\fP to formula lines\.
+.TP
+\fB\-\-zap\fP
+\fBcleanup\fP casks using the \fBzap\fP command instead of \fBuninstall\fP\&\.
+.SS "\fBcommand\-not\-found\-init\fP"
 Print instructions for setting up the command\-not\-found hook for your shell\. If the output is not to a tty, print the appropriate handler script for your shell\.
-.
-.SS "\fBservices\fR [\fIsubcommand\fR]"
-Manage background services with macOS\' \fBlaunchctl\fR(1) daemon manager\.
-.
-.P
-If \fBsudo\fR is passed, operate on \fB/Library/LaunchDaemons\fR (started at boot)\. Otherwise, operate on \fB~/Library/LaunchAgents\fR (started at login)\.
-.
-.P
-[\fBsudo\fR] \fBbrew services\fR [\fBlist\fR] (\fB\-\-json\fR)
-    List information about all managed services for the current user (or root)\.
-.
-.P
-[\fBsudo\fR] \fBbrew services info\fR (\fIformula\fR|\fB\-\-all\fR|\fB\-\-json\fR)
-    List all managed services for the current user (or root)\.
-.
-.P
-[\fBsudo\fR] \fBbrew services run\fR (\fIformula\fR|\fB\-\-all\fR)
-    Run the service \fIformula\fR without registering to launch at login (or boot)\.
-.
-.P
-[\fBsudo\fR] \fBbrew services start\fR (\fIformula\fR|\fB\-\-all\fR|\fB\-\-file=\fR)
-    Start the service \fIformula\fR immediately and register it to launch at login (or boot)\.
-.
-.P
-[\fBsudo\fR] \fBbrew services stop\fR (\fIformula\fR|\fB\-\-all\fR)
-    Stop the service \fIformula\fR immediately and unregister it from launching at login (or boot)\.
-.
-.P
-[\fBsudo\fR] \fBbrew services kill\fR (\fIformula\fR|\fB\-\-all\fR)
-    Stop the service \fIformula\fR immediately but keep it registered to launch at login (or boot)\.
-.
+.SS "\fBservices\fP \fR[\fIsubcommand\fP]"
+Manage background services with macOS\[u2019] \fBlaunchctl\fP(1) daemon manager or Linux\[u2019]s \fBsystemctl\fP(1) service manager\.
 .P
-[\fBsudo\fR] \fBbrew services restart\fR (\fIformula\fR|\fB\-\-all\fR)
-    Stop (if necessary) and start the service \fIformula\fR immediately and register it to launch at login (or boot)\.
-.
-.P
-[\fBsudo\fR] \fBbrew services cleanup\fR
-    Remove all unused services\.
-.
+If \fBsudo\fP is passed, operate on \fB/Library/LaunchDaemons\fP or \fB/usr/lib/systemd/system\fP (started at boot)\. Otherwise, operate on \fB~/Library/LaunchAgents\fP or \fB~/\.config/systemd/user\fP (started at login)\.
+.TP
+[\fBsudo\fP] \fBbrew services\fP [\fBlist\fP] (\fB\-\-json\fP) (\fB\-\-debug\fP)
+List information about all managed services for the current user (or root)\. Provides more output from Homebrew and \fBlaunchctl\fP(1) or \fBsystemctl\fP(1) if run with \fB\-\-debug\fP\&\.
+.TP
+[\fBsudo\fP] \fBbrew services info\fP (\fIformula\fP|\fB\-\-all\fP|\fB\-\-json\fP)
+List all managed services for the current user (or root)\.
+.TP
+[\fBsudo\fP] \fBbrew services run\fP (\fIformula\fP|\fB\-\-all\fP)
+Run the service \fIformula\fP without registering to launch at login (or boot)\.
+.TP
+[\fBsudo\fP] \fBbrew services start\fP (\fIformula\fP|\fB\-\-all\fP|\fB\-\-file=\fP)
+Start the service \fIformula\fP immediately and register it to launch at login (or boot)\.
+.TP
+[\fBsudo\fP] \fBbrew services stop\fP (\fIformula\fP|\fB\-\-all\fP)
+Stop the service \fIformula\fP immediately and unregister it from launching at login (or boot)\.
 .TP
-\fB\-\-file\fR
-Use the service file from this location to \fBstart\fR the service\.
-.
+[\fBsudo\fP] \fBbrew services kill\fP (\fIformula\fP|\fB\-\-all\fP)
+Stop the service \fIformula\fP immediately but keep it registered to launch at login (or boot)\.
 .TP
-\fB\-\-all\fR
-Run \fIsubcommand\fR on all services\.
-.
+[\fBsudo\fP] \fBbrew services restart\fP (\fIformula\fP|\fB\-\-all\fP)
+Stop (if necessary) and start the service \fIformula\fP immediately and register it to launch at login (or boot)\.
 .TP
-\fB\-\-json\fR
+[\fBsudo\fP] \fBbrew services cleanup\fP
+Remove all unused services\.
+.TP
+\fB\-\-file\fP
+Use the service file from this location to \fBstart\fP the service\.
+.TP
+\fB\-\-sudo\-service\-user\fP
+When run as root on macOS, run the service(s) as this user\.
+.TP
+\fB\-\-max\-wait\fP
+Wait at most this many seconds for \fBstop\fP to finish stopping a service\. Omit this flag or set this to zero (0) seconds to wait indefinitely\.
+.TP
+\fB\-\-all\fP
+Run \fIsubcommand\fP on all services\.
+.TP
+\fB\-\-json\fP
 Output as JSON\.
-.
-.SS "\fBtest\-bot\fR [\fIoptions\fR] [\fIformula\fR]"
-Tests the full lifecycle of a Homebrew change to a tap (Git repository)\. For example, for a GitHub Actions pull request that changes a formula \fBbrew test\-bot\fR will ensure the system is cleaned and set up to test the formula, install the formula, run various tests and checks on it, bottle (package) the binaries and test formulae that depend on it to ensure they aren\'t broken by these changes\.
-.
+.TP
+\fB\-\-no\-wait\fP
+Don\[u2019]t wait for \fBstop\fP to finish stopping the service\.
+.SS "\fBtest\-bot\fP \fR[\fIoptions\fP] \fR[\fIformula\fP]"
+Tests the full lifecycle of a Homebrew change to a tap (Git repository)\. For example, for a GitHub Actions pull request that changes a formula \fBbrew test\-bot\fP will ensure the system is cleaned and set up to test the formula, install the formula, run various tests and checks on it, bottle (package) the binaries and test formulae that depend on it to ensure they aren\[u2019]t broken by these changes\.
 .P
-Only supports GitHub Actions as a CI provider\. This is because Homebrew uses GitHub Actions and it\'s freely available for public and private use with macOS and Linux workers\.
-.
+Only supports GitHub Actions as a CI provider\. This is because Homebrew uses GitHub Actions and it\[u2019]s freely available for public and private use with macOS and Linux workers\.
 .TP
-\fB\-\-dry\-run\fR
+\fB\-\-dry\-run\fP
 Print what would be done rather than doing it\.
-.
 .TP
-\fB\-\-cleanup\fR
+\fB\-\-cleanup\fP
 Clean all state from the Homebrew directory\. Use with care!
-.
 .TP
-\fB\-\-skip\-setup\fR
-Don\'t check if the local system is set up correctly\.
-.
+\fB\-\-skip\-setup\fP
+Don\[u2019]t check if the local system is set up correctly\.
 .TP
-\fB\-\-build\-from\-source\fR
+\fB\-\-build\-from\-source\fP
 Build from source rather than building bottles\.
-.
 .TP
-\fB\-\-build\-dependents\-from\-source\fR
+\fB\-\-build\-dependents\-from\-source\fP
 Build dependents from source rather than testing bottles\.
-.
 .TP
-\fB\-\-junit\fR
+\fB\-\-junit\fP
 generate a JUnit XML test results file\.
-.
 .TP
-\fB\-\-keep\-old\fR
-Run \fBbrew bottle \-\-keep\-old\fR to build new bottles for a single platform\.
-.
+\fB\-\-keep\-old\fP
+Run \fBbrew bottle \-\-keep\-old\fP to build new bottles for a single platform\.
 .TP
-\fB\-\-skip\-relocation\fR
-Run \fBbrew bottle \-\-skip\-relocation\fR to build new bottles that don\'t require relocation\.
-.
+\fB\-\-skip\-relocation\fP
+Run \fBbrew bottle \-\-skip\-relocation\fP to build new bottles that don\[u2019]t require relocation\.
 .TP
-\fB\-\-only\-json\-tab\fR
-Run \fBbrew bottle \-\-only\-json\-tab\fR to build new bottles that do not contain a tab\.
-.
+\fB\-\-only\-json\-tab\fP
+Run \fBbrew bottle \-\-only\-json\-tab\fP to build new bottles that do not contain a tab\.
 .TP
-\fB\-\-local\fR
-Ask Homebrew to write verbose logs under \fB\./logs/\fR and set \fB$HOME\fR to \fB\./home/\fR
-.
+\fB\-\-local\fP
+Ask Homebrew to write verbose logs under \fB\&\./logs/\fP and set \fB$HOME\fP to \fB\&\./home/\fP
 .TP
-\fB\-\-tap\fR
+\fB\-\-tap\fP
 Use the Git repository of the given tap\. Defaults to the core tap for syntax checking\.
-.
 .TP
-\fB\-\-fail\-fast\fR
+\fB\-\-fail\-fast\fP
 Immediately exit on a failing step\.
-.
 .TP
-\fB\-v\fR, \fB\-\-verbose\fR
+\fB\-v\fP, \fB\-\-verbose\fP
 Print test step output in real time\. Has the side effect of passing output as raw bytes instead of re\-encoding in UTF\-8\.
-.
 .TP
-\fB\-\-test\-default\-formula\fR
+\fB\-\-test\-default\-formula\fP
 Use a default testing formula when not building a tap and no other formulae are specified\.
-.
 .TP
-\fB\-\-root\-url\fR
-Use the specified \fIURL\fR as the root of the bottle\'s URL instead of Homebrew\'s default\.
-.
+\fB\-\-root\-url\fP
+Use the specified \fIURL\fP as the root of the bottle\[u2019]s URL instead of Homebrew\[u2019]s default\.
 .TP
-\fB\-\-git\-name\fR
+\fB\-\-git\-name\fP
 Set the Git author/committer names to the given name\.
-.
 .TP
-\fB\-\-git\-email\fR
+\fB\-\-git\-email\fP
 Set the Git author/committer email to the given email\.
-.
 .TP
-\fB\-\-publish\fR
+\fB\-\-publish\fP
 Publish the uploaded bottles\.
-.
 .TP
-\fB\-\-skip\-online\-checks\fR
-Don\'t pass \fB\-\-online\fR to \fBbrew audit\fR and skip \fBbrew livecheck\fR\.
-.
+\fB\-\-skip\-online\-checks\fP
+Don\[u2019]t pass \fB\-\-online\fP to \fBbrew audit\fP and skip \fBbrew livecheck\fP\&\.
 .TP
-\fB\-\-skip\-dependents\fR
-Don\'t test any dependents\.
-.
+\fB\-\-skip\-new\fP
+Don\[u2019]t pass \fB\-\-new\fP to \fBbrew audit\fP for new formulae\.
 .TP
-\fB\-\-skip\-recursive\-dependents\fR
+\fB\-\-skip\-new\-strict\fP
+Don\[u2019]t pass \fB\-\-strict\fP to \fBbrew audit\fP for new formulae\.
+.TP
+\fB\-\-skip\-dependents\fP
+Don\[u2019]t test any dependents\.
+.TP
+\fB\-\-skip\-livecheck\fP
+Don\[u2019]t test livecheck\.
+.TP
+\fB\-\-skip\-recursive\-dependents\fP
 Only test the direct dependents\.
-.
 .TP
-\fB\-\-only\-cleanup\-before\fR
-Only run the pre\-cleanup step\. Needs \fB\-\-cleanup\fR\.
-.
+\fB\-\-skip\-checksum\-only\-audit\fP
+Don\[u2019]t audit checksum\-only changes\.
+.TP
+\fB\-\-skip\-stable\-version\-audit\fP
+Don\[u2019]t audit the stable version\.
+.TP
+\fB\-\-skip\-revision\-audit\fP
+Don\[u2019]t audit the revision\.
+.TP
+\fB\-\-only\-cleanup\-before\fP
+Only run the pre\-cleanup step\. Needs \fB\-\-cleanup\fP\&\.
 .TP
-\fB\-\-only\-setup\fR
+\fB\-\-only\-setup\fP
 Only run the local system setup check step\.
-.
 .TP
-\fB\-\-only\-tap\-syntax\fR
+\fB\-\-only\-tap\-syntax\fP
 Only run the tap syntax check step\.
-.
 .TP
-\fB\-\-only\-formulae\fR
+\fB\-\-stable\fP
+Only run the tap syntax checks needed on stable brew\.
+.TP
+\fB\-\-only\-formulae\fP
 Only run the formulae steps\.
-.
 .TP
-\fB\-\-only\-formulae\-detect\fR
+\fB\-\-only\-formulae\-detect\fP
 Only run the formulae detection steps\.
-.
 .TP
-\fB\-\-only\-formulae\-dependents\fR
+\fB\-\-only\-formulae\-dependents\fP
 Only run the formulae dependents steps\.
-.
 .TP
-\fB\-\-only\-cleanup\-after\fR
-Only run the post\-cleanup step\. Needs \fB\-\-cleanup\fR\.
-.
+\fB\-\-only\-bottles\-fetch\fP
+Only run the bottles fetch steps\. This optional post\-upload test checks that all the bottles were uploaded correctly\. It is not run unless requested and only needs to be run on a single machine\. The bottle commit to be tested must be on the tested branch\.
+.TP
+\fB\-\-only\-cleanup\-after\fP
+Only run the post\-cleanup step\. Needs \fB\-\-cleanup\fP\&\.
 .TP
-\fB\-\-testing\-formulae\fR
+\fB\-\-testing\-formulae\fP
 Use these testing formulae rather than running the formulae detection steps\.
-.
 .TP
-\fB\-\-added\-formulae\fR
+\fB\-\-added\-formulae\fP
 Use these added formulae rather than running the formulae detection steps\.
-.
 .TP
-\fB\-\-deleted\-formulae\fR
+\fB\-\-deleted\-formulae\fP
 Use these deleted formulae rather than running the formulae detection steps\.
-.
 .TP
-\fB\-\-skipped\-or\-failed\-formulae\fR
+\fB\-\-skipped\-or\-failed\-formulae\fP
 Use these skipped or failed formulae from formulae steps for a formulae dependents step\.
-.
-.SS "\fBunalias\fR \fIalias\fR [\.\.\.]"
+.TP
+\fB\-\-tested\-formulae\fP
+Use these tested formulae from formulae steps for a formulae dependents step\.
+.SS "\fBunalias\fP \fIalias\fP \fR[\.\.\.]"
 Remove aliases\.
-.
-.SS "\fBwhich\-formula\fR [\fI\-\-explain\fR] \fIcommand\fR [\.\.\.]"
-Prints the formula(e) which provides the given command\.
-.
-.TP
-\fB\-\-explain\fR
-Output explanation of how to get \'cmd\' by installing one of the providing formulae\.
-.
-.SS "\fBwhich\-update\fR [\fIoptions\fR] [\fIdatabase\fR]"
-Database update for \fBbrew which\-formula\fR
-.
-.TP
-\fB\-\-stats\fR
+.SS "\fBwhich\-formula\fP \fR[\fB\-\-explain\fP] \fIcommand\fP \fR[\.\.\.]"
+Show which formula(e) provides the given command\.
+.TP
+\fB\-\-explain\fP
+Output explanation of how to get \fIcommand\fP by installing one of the providing formulae\.
+.SS "\fBwhich\-update\fP \fR[\fIoptions\fP] \fR[\fIdatabase\fP]"
+Database update for \fBbrew which\-formula\fP\&\.
+.TP
+\fB\-\-stats\fP
 Print statistics about the database contents (number of commands and formulae, list of missing formulae)\.
-.
 .TP
-\fB\-\-commit\fR
-Commit the changes using \fBgit\fR\.
-.
+\fB\-\-commit\fP
+Commit the changes using \fBgit\fP\&\.
 .TP
-\fB\-\-update\-existing\fR
+\fB\-\-update\-existing\fP
 Update database entries with outdated formula versions\.
-.
 .TP
-\fB\-\-install\-missing\fR
-Install and update formulae that are missing from the database and don\'t have bottles\.
-.
+\fB\-\-install\-missing\fP
+Install and update formulae that are missing from the database and don\[u2019]t have bottles\.
+.TP
+\fB\-\-eval\-all\fP
+Evaluate all installed taps, rather than just the core tap\.
 .TP
-\fB\-\-max\-downloads\fR
+\fB\-\-max\-downloads\fP
 Specify a maximum number of formulae to download and update\.
-.
 .SH "CUSTOM EXTERNAL COMMANDS"
-Homebrew, like \fBgit\fR(1), supports external commands\. These are executable scripts that reside somewhere in the \fBPATH\fR, named \fBbrew\-\fR\fIcmdname\fR or \fBbrew\-\fR\fIcmdname\fR\fB\.rb\fR, which can be invoked like \fBbrew\fR \fIcmdname\fR\. This allows you to create your own commands without modifying Homebrew\'s internals\.
-.
+Homebrew, like \fBgit\fP(1), supports external commands\. These are executable scripts that reside somewhere in the \fBPATH\fP, named \fBbrew\-\fP\fIcmdname\fP or \fBbrew\-\fP\fIcmdname\fP\fB\&\.rb\fP, which can be invoked like \fBbrew\fP \fIcmdname\fP\&\. This allows you to create your own commands without modifying Homebrew\[u2019]s internals\.
 .P
-Instructions for creating your own commands can be found in the docs: \fIhttps://docs\.brew\.sh/External\-Commands\fR
-.
+Instructions for creating your own commands can be found in the docs: 
+.UR https://docs\.brew\.sh/External\-Commands
+.UE
 .SH "SPECIFYING FORMULAE"
-Many Homebrew commands accept one or more \fIformula\fR arguments\. These arguments can take several different forms:
-.
+Many Homebrew commands accept one or more \fIformula\fP arguments\. These arguments can take several different forms:
+.IP \(bu 4
+The name of a formula: e\.g\. \fBgit\fP, \fBnode\fP, \fBwget\fP\&\.
+.IP \(bu 4
+The fully\-qualified name of a tapped formula: Sometimes a formula from a tapped repository may conflict with one in \fBhomebrew/core\fP\&\. You can still access these formulae by using a special syntax, e\.g\. \fBhomebrew/dupes/vim\fP or \fBhomebrew/versions/node4\fP\&\.
+.IP \(bu 4
+An arbitrary file: Homebrew can install formulae from a local path\. It can point to either a formula file or a bottle\. Prefix relative paths with \fB\&\./\fP to prevent them from being interpreted as a formula or tap name\.
+.SH "SPECIFYING CASKS"
+Many Homebrew Cask commands accept one or more \fIcask\fP arguments\. These can be specified the same way as the \fIformula\fP arguments described in \fBSPECIFYING FORMULAE\fP above\.
+.SH "ENVIRONMENT"
+Note that environment variables must have a value set to be detected\. For example, run \fBexport HOMEBREW_NO_INSECURE_REDIRECT=1\fP rather than just \fBexport HOMEBREW_NO_INSECURE_REDIRECT\fP\&\.
+.P
+\fBHOMEBREW_*\fP environment variables can also be set in Homebrew\[u2019]s environment files:
+.IP \(bu 4
+\fB/etc/homebrew/brew\.env\fP (system\-wide)
+.IP \(bu 4
+\fB$HOMEBREW_PREFIX/etc/homebrew/brew\.env\fP (prefix\-specific)
+.IP \(bu 4
+\fB$XDG_CONFIG_HOME/homebrew/brew\.env\fP if \fB$XDG_CONFIG_HOME\fP is set or \fB$HOME/\.homebrew/brew\.env\fP otherwise (user\-specific)
+.P
+User\-specific environment files take precedence over prefix\-specific files and prefix\-specific files take precedence over system\-wide files (unless \fBHOMEBREW_SYSTEM_ENV_TAKES_PRIORITY\fP is set, see below)\.
+.P
+Note that these files do not support shell variable expansion e\.g\. \fB$HOME\fP or command execution e\.g\. \fB$(cat file)\fP\&\.
 .TP
-The name of a formula
-e\.g\. \fBgit\fR, \fBnode\fR, \fBwget\fR\.
-.
+\fBHOMEBREW_ALLOWED_TAPS\fP
+A space\-separated list of taps\. Homebrew will refuse to install a formula unless it and all of its dependencies are in an official tap or in a tap on this list\.
 .TP
-The fully\-qualified name of a tapped formula
-Sometimes a formula from a tapped repository may conflict with one in \fBhomebrew/core\fR\. You can still access these formulae by using a special syntax, e\.g\. \fBhomebrew/dupes/vim\fR or \fBhomebrew/versions/node4\fR\.
-.
+\fBHOMEBREW_API_AUTO_UPDATE_SECS\fP
+Check Homebrew\[u2019]s API for new formulae or cask data every \fBHOMEBREW_API_AUTO_UPDATE_SECS\fP seconds\. Alternatively, disable API auto\-update checks entirely with \fBHOMEBREW_NO_AUTO_UPDATE\fP\&\.
+.RS
+.P
+\fIDefault:\fP \fB450\fP\&\.
+.RE
 .TP
-An arbitrary file
-Homebrew can install formulae from a local path\. It can point to either a formula file or a bottle\. Prefix relative paths with \fB\./\fR to prevent them from being interpreted as a formula or tap name\.
-.
-.SH "SPECIFYING CASKS"
-Many Homebrew Cask commands accept one or more \fIcask\fR arguments\. These can be specified the same way as the \fIformula\fR arguments described in \fBSPECIFYING FORMULAE\fR above\.
-.
-.SH "ENVIRONMENT"
-Note that environment variables must have a value set to be detected\. For example, run \fBexport HOMEBREW_NO_INSECURE_REDIRECT=1\fR rather than just \fBexport HOMEBREW_NO_INSECURE_REDIRECT\fR\.
-.
+\fBHOMEBREW_API_DOMAIN\fP
+Use this URL as the download mirror for Homebrew JSON API\. If metadata files at that URL are temporarily unavailable, the default API domain will be used as a fallback mirror\.
+.RS
+.P
+\fIDefault:\fP \fBhttps://formulae\.brew\.sh/api\fP\&\.
+.RE
 .TP
-\fBHOMEBREW_ADDITIONAL_GOOGLE_ANALYTICS_ID\fR
-.
-.br
-Additional Google Analytics tracking ID to emit user behaviour analytics to\. For more information, see: \fIhttps://docs\.brew\.sh/Analytics\fR
-.
+\fBHOMEBREW_ARCH\fP
+Linux only: Pass this value to a type name representing the compiler\[u2019]s \fB\-march\fP option\.
+.RS
+.P
+\fIDefault:\fP \fBnative\fP\&\.
+.RE
 .TP
-\fBHOMEBREW_ARCH\fR
-.
-.br
-Linux only: Pass this value to a type name representing the compiler\'s \fB\-march\fR option\.
-.
-.IP
-\fIDefault:\fR \fBnative\fR\.
-.
-.TP
-\fBHOMEBREW_ARTIFACT_DOMAIN\fR
-.
-.br
-Prefix all download URLs, including those for bottles, with this value\. For example, \fBHOMEBREW_ARTIFACT_DOMAIN=http://localhost:8080\fR will cause a formula with the URL \fBhttps://example\.com/foo\.tar\.gz\fR to instead download from \fBhttp://localhost:8080/https://example\.com/foo\.tar\.gz\fR\. Bottle URLs however, have their domain replaced with this prefix\. This results in e\.g\. \fBhttps://ghcr\.io/v2/homebrew/core/gettext/manifests/0\.21\fR to instead be downloaded from \fBhttp://localhost:8080/v2/homebrew/core/gettext/manifests/0\.21\fR
-.
+\fBHOMEBREW_ARTIFACT_DOMAIN\fP
+Prefix all download URLs, including those for bottles, with this value\. For example, \fBHOMEBREW_ARTIFACT_DOMAIN=http://localhost:8080\fP will cause a formula with the URL \fBhttps://example\.com/foo\.tar\.gz\fP to instead download from \fBhttp://localhost:8080/https://example\.com/foo\.tar\.gz\fP\&\. Bottle URLs however, have their domain replaced with this prefix\. This results in e\.g\. \fBhttps://ghcr\.io/v2/homebrew/core/gettext/manifests/0\.21\fP to instead be downloaded from \fBhttp://localhost:8080/v2/homebrew/core/gettext/manifests/0\.21\fP
 .TP
-\fBHOMEBREW_AUTO_UPDATE_SECS\fR
-.
-.br
-Run \fBbrew update\fR once every \fBHOMEBREW_AUTO_UPDATE_SECS\fR seconds before some commands, e\.g\. \fBbrew install\fR, \fBbrew upgrade\fR and \fBbrew tap\fR\. Alternatively, disable auto\-update entirely with HOMEBREW_NO_AUTO_UPDATE\.
-.
-.IP
-\fIDefault:\fR \fB300\fR\.
-.
-.TP
-\fBHOMEBREW_BAT\fR
-.
-.br
-If set, use \fBbat\fR for the \fBbrew cat\fR command\.
-.
+\fBHOMEBREW_ARTIFACT_DOMAIN_NO_FALLBACK\fP
+If \fBHOMEBREW_ARTIFACT_DOMAIN\fP and \fBHOMEBREW_ARTIFACT_DOMAIN_NO_FALLBACK\fP are both set, if the request to \fBHOMEBREW_ARTIFACT_DOMAIN\fP fails then it Homebrew will error rather than trying any other/default URLs\.
 .TP
-\fBHOMEBREW_BAT_CONFIG_PATH\fR
-.
-.br
-Use this as the \fBbat\fR configuration file\.
-.
-.IP
-\fIDefault:\fR \fB$HOME/\.config/bat/config\fR\.
-.
-.TP
-\fBHOMEBREW_BAT_THEME\fR
-.
-.br
-Use this as the \fBbat\fR theme for syntax highlighting\.
-.
-.IP
-\fIDefault:\fR \fB$BAT_THEME\fR\.
-.
-.TP
-\fBHOMEBREW_BOOTSNAP\fR
-.
-.br
-If set, use Bootsnap to speed up repeated \fBbrew\fR calls\. A no\-op when using Homebrew\'s vendored, relocatable Ruby on macOS (as it doesn\'t work)\.
-.
+\fBHOMEBREW_AUTO_UPDATE_SECS\fP
+Run \fBbrew update\fP once every \fBHOMEBREW_AUTO_UPDATE_SECS\fP seconds before some commands, e\.g\. \fBbrew install\fP, \fBbrew upgrade\fP and \fBbrew tap\fP\&\. Alternatively, disable auto\-update entirely with \fBHOMEBREW_NO_AUTO_UPDATE\fP\&\.
+.RS
+.P
+\fIDefault:\fP \fB86400\fP (24 hours), \fB3600\fP (1 hour) if a developer command has been run or \fB300\fP (5 minutes) if \fBHOMEBREW_NO_INSTALL_FROM_API\fP is set\.
+.RE
 .TP
-\fBHOMEBREW_BOTTLE_DOMAIN\fR
-.
-.br
-Use this URL as the download mirror for bottles\. If bottles at that URL are temporarily unavailable, the default bottle domain will be used as a fallback mirror\. For example, \fBHOMEBREW_BOTTLE_DOMAIN=http://localhost:8080\fR will cause all bottles to download from the prefix \fBhttp://localhost:8080/\fR\. If bottles are not available at \fBHOMEBREW_BOTTLE_DOMAIN\fR they will be downloaded from the default bottle domain\.
-.
-.IP
-\fIDefault:\fR \fBhttps://ghcr\.io/v2/homebrew/core\fR\.
-.
-.TP
-\fBHOMEBREW_BREW_GIT_REMOTE\fR
-.
-.br
-Use this URL as the Homebrew/brew \fBgit\fR(1) remote\.
-.
-.IP
-\fIDefault:\fR \fBhttps://github\.com/Homebrew/brew\fR\.
-.
-.TP
-\fBHOMEBREW_BROWSER\fR
-.
-.br
+\fBHOMEBREW_BAT\fP
+If set, use \fBbat\fP for the \fBbrew cat\fP command\.
+.TP
+\fBHOMEBREW_BAT_CONFIG_PATH\fP
+Use this as the \fBbat\fP configuration file\.
+.RS
+.P
+\fIDefault:\fP \fB$BAT_CONFIG_PATH\fP\&\.
+.RE
+.TP
+\fBHOMEBREW_BAT_THEME\fP
+Use this as the \fBbat\fP theme for syntax highlighting\.
+.RS
+.P
+\fIDefault:\fP \fB$BAT_THEME\fP\&\.
+.RE
+.TP
+\fBHOMEBREW_BOOTSNAP\fP
+If set, use Bootsnap to speed up repeated \fBbrew\fP calls\. A no\-op on Linux when not using Homebrew\[u2019]s vendored, relocatable Ruby\.
+.TP
+\fBHOMEBREW_BOTTLE_DOMAIN\fP
+Use this URL as the download mirror for bottles\. If bottles at that URL are temporarily unavailable, the default bottle domain will be used as a fallback mirror\. For example, \fBHOMEBREW_BOTTLE_DOMAIN=http://localhost:8080\fP will cause all bottles to download from the prefix \fBhttp://localhost:8080/\fP\&\. If bottles are not available at \fBHOMEBREW_BOTTLE_DOMAIN\fP they will be downloaded from the default bottle domain\.
+.RS
+.P
+\fIDefault:\fP \fBhttps://ghcr\.io/v2/homebrew/core\fP\&\.
+.RE
+.TP
+\fBHOMEBREW_BREW_GIT_REMOTE\fP
+Use this URL as the Homebrew/brew \fBgit\fP(1) remote\.
+.RS
+.P
+\fIDefault:\fP \fBhttps://github\.com/Homebrew/brew\fP\&\.
+.RE
+.TP
+\fBHOMEBREW_BROWSER\fP
 Use this as the browser when opening project homepages\.
-.
-.IP
-\fIDefault:\fR \fB$BROWSER\fR or the OS\'s default browser\.
-.
+.RS
+.P
+\fIDefault:\fP \fB$BROWSER\fP or the OS\[u2019]s default browser\.
+.RE
 .TP
-\fBHOMEBREW_CACHE\fR
-.
-.br
+\fBHOMEBREW_BUNDLE_USER_CACHE\fP
+If set, use this directory as the \fBbundle\fP(1) user cache\.
+.TP
+\fBHOMEBREW_CACHE\fP
 Use this directory as the download cache\.
-.
-.IP
-\fIDefault:\fR macOS: \fB$HOME/Library/Caches/Homebrew\fR, Linux: \fB$XDG_CACHE_HOME/Homebrew\fR or \fB$HOME/\.cache/Homebrew\fR\.
-.
+.RS
+.P
+\fIDefault:\fP macOS: \fB$HOME/Library/Caches/Homebrew\fP, Linux: \fB$XDG_CACHE_HOME/Homebrew\fP or \fB$HOME/\.cache/Homebrew\fP\&\.
+.RE
 .TP
-\fBHOMEBREW_CASK_OPTS\fR
-.
-.br
-Append these options to all \fBcask\fR commands\. All \fB\-\-*dir\fR options, \fB\-\-language\fR, \fB\-\-require\-sha\fR, \fB\-\-no\-quarantine\fR and \fB\-\-no\-binaries\fR are supported\. For example, you might add something like the following to your \fB~/\.profile\fR, \fB~/\.bash_profile\fR, or \fB~/\.zshenv\fR:\en\en \fBexport HOMEBREW_CASK_OPTS="\-\-appdir=~/Applications \-\-fontdir=/Library/Fonts"\fR
-.
+\fBHOMEBREW_CASK_OPTS\fP
+Append these options to all \fBcask\fP commands\. All \fB\-\-*dir\fP options, \fB\-\-language\fP, \fB\-\-require\-sha\fP, \fB\-\-no\-quarantine\fP and \fB\-\-no\-binaries\fP are supported\. For example, you might add something like the following to your \fB~/\.profile\fP, \fB~/\.bash_profile\fP, or \fB~/\.zshenv\fP:
+.RS
+.P
+\fBexport HOMEBREW_CASK_OPTS="\-\-appdir=~/Applications \-\-fontdir=/Library/Fonts"\fP
+.RE
 .TP
-\fBHOMEBREW_CLEANUP_PERIODIC_FULL_DAYS\fR
-.
-.br
-If set, \fBbrew install\fR, \fBbrew upgrade\fR and \fBbrew reinstall\fR will cleanup all formulae when this number of days has passed\.
-.
-.IP
-\fIDefault:\fR \fB30\fR\.
-.
-.TP
-\fBHOMEBREW_CLEANUP_MAX_AGE_DAYS\fR
-.
-.br
+\fBHOMEBREW_CLEANUP_MAX_AGE_DAYS\fP
 Cleanup all cached files older than this many days\.
-.
-.IP
-\fIDefault:\fR \fB120\fR\.
-.
+.RS
+.P
+\fIDefault:\fP \fB120\fP\&\.
+.RE
 .TP
-\fBHOMEBREW_COLOR\fR
-.
-.br
+\fBHOMEBREW_CLEANUP_PERIODIC_FULL_DAYS\fP
+If set, \fBbrew install\fP, \fBbrew upgrade\fP and \fBbrew reinstall\fP will cleanup all formulae when this number of days has passed\.
+.RS
+.P
+\fIDefault:\fP \fB30\fP\&\.
+.RE
+.TP
+\fBHOMEBREW_COLOR\fP
 If set, force colour output on non\-TTY outputs\.
-.
 .TP
-\fBHOMEBREW_CORE_GIT_REMOTE\fR
-.
-.br
-Use this URL as the Homebrew/homebrew\-core \fBgit\fR(1) remote\.
-.
-.IP
-\fIDefault:\fR \fBhttps://github\.com/Homebrew/homebrew\-core\fR\.
-.
-.TP
-\fBHOMEBREW_CURLRC\fR
-.
-.br
-If set, do not pass \fB\-\-disable\fR when invoking \fBcurl\fR(1), which disables the use of \fBcurlrc\fR\.
-.
+\fBHOMEBREW_CORE_GIT_REMOTE\fP
+Use this URL as the Homebrew/homebrew\-core \fBgit\fP(1) remote\.
+.RS
+.P
+\fIDefault:\fP \fBhttps://github\.com/Homebrew/homebrew\-core\fP\&\.
+.RE
 .TP
-\fBHOMEBREW_CURL_PATH\fR
-.
-.br
-Linux only: Set this value to a new enough \fBcurl\fR executable for Homebrew to use\.
-.
-.IP
-\fIDefault:\fR \fBcurl\fR\.
-.
-.TP
-\fBHOMEBREW_CURL_RETRIES\fR
-.
-.br
-Pass the given retry count to \fB\-\-retry\fR when invoking \fBcurl\fR(1)\.
-.
-.IP
-\fIDefault:\fR \fB3\fR\.
-.
-.TP
-\fBHOMEBREW_CURL_VERBOSE\fR
-.
-.br
-If set, pass \fB\-\-verbose\fR when invoking \fBcurl\fR(1)\.
-.
+\fBHOMEBREW_CURLRC\fP
+If set to an absolute path (i\.e\. beginning with \fB/\fP), pass it with \fB\-\-config\fP when invoking \fBcurl\fP(1)\. If set but \fInot\fP a valid path, do not pass \fB\-\-disable\fP, which disables the use of \fB\&\.curlrc\fP\&\.
 .TP
-\fBHOMEBREW_DEVELOPER\fR
-.
-.br
+\fBHOMEBREW_CURL_PATH\fP
+Linux only: Set this value to a new enough \fBcurl\fP executable for Homebrew to use\.
+.RS
+.P
+\fIDefault:\fP \fBcurl\fP\&\.
+.RE
+.TP
+\fBHOMEBREW_CURL_RETRIES\fP
+Pass the given retry count to \fB\-\-retry\fP when invoking \fBcurl\fP(1)\.
+.RS
+.P
+\fIDefault:\fP \fB3\fP\&\.
+.RE
+.TP
+\fBHOMEBREW_CURL_VERBOSE\fP
+If set, pass \fB\-\-verbose\fP when invoking \fBcurl\fP(1)\.
+.TP
+\fBHOMEBREW_DEBUG\fP
+If set, always assume \fB\-\-debug\fP when running commands\.
+.TP
+\fBHOMEBREW_DEVELOPER\fP
 If set, tweak behaviour to be more relevant for Homebrew developers (active or budding) by e\.g\. turning warnings into errors\.
-.
 .TP
-\fBHOMEBREW_DISABLE_LOAD_FORMULA\fR
-.
-.br
+\fBHOMEBREW_DISABLE_DEBREW\fP
+If set, the interactive formula debugger available via \fB\-\-debug\fP will be disabled\.
+.TP
+\fBHOMEBREW_DISABLE_LOAD_FORMULA\fP
 If set, refuse to load formulae\. This is useful when formulae are not trusted (such as in pull requests)\.
-.
 .TP
-\fBHOMEBREW_DISPLAY\fR
-.
-.br
-Use this X11 display when opening a page in a browser, for example with \fBbrew home\fR\. Primarily useful on Linux\.
-.
-.IP
-\fIDefault:\fR \fB$DISPLAY\fR\.
-.
-.TP
-\fBHOMEBREW_DISPLAY_INSTALL_TIMES\fR
-.
-.br
+\fBHOMEBREW_DISPLAY\fP
+Use this X11 display when opening a page in a browser, for example with \fBbrew home\fP\&\. Primarily useful on Linux\.
+.RS
+.P
+\fIDefault:\fP \fB$DISPLAY\fP\&\.
+.RE
+.TP
+\fBHOMEBREW_DISPLAY_INSTALL_TIMES\fP
 If set, print install times for each formula at the end of the run\.
-.
 .TP
-\fBHOMEBREW_EDITOR\fR
-.
-.br
+\fBHOMEBREW_DOCKER_REGISTRY_BASIC_AUTH_TOKEN\fP
+Use this base64 encoded username and password for authenticating with a Docker registry proxying GitHub Packages\. If \fBHOMEBREW_DOCKER_REGISTRY_TOKEN\fP is set, it will be used instead\.
+.TP
+\fBHOMEBREW_DOCKER_REGISTRY_TOKEN\fP
+Use this bearer token for authenticating with a Docker registry proxying GitHub Packages\. Preferred over \fBHOMEBREW_DOCKER_REGISTRY_BASIC_AUTH_TOKEN\fP\&\.
+.TP
+\fBHOMEBREW_EDITOR\fP
 Use this editor when editing a single formula, or several formulae in the same directory\.
-.
-.IP
-\fINote:\fR \fBbrew edit\fR will open all of Homebrew as discontinuous files and directories\. Visual Studio Code can handle this correctly in project mode, but many editors will do strange things in this case\.
-.
-.IP
-\fIDefault:\fR \fB$EDITOR\fR or \fB$VISUAL\fR\.
-.
-.TP
-\fBHOMEBREW_FAIL_LOG_LINES\fR
-.
-.br
-Output this many lines of output on formula \fBsystem\fR failures\.
-.
-.IP
-\fIDefault:\fR \fB15\fR\.
-.
-.TP
-\fBHOMEBREW_FORBIDDEN_LICENSES\fR
-.
-.br
-A space\-separated list of licenses\. Homebrew will refuse to install a formula if it or any of its dependencies has a license on this list\.
-.
+.RS
+.P
+\fINote:\fP \fBbrew edit\fP will open all of Homebrew as discontinuous files and directories\. Visual Studio Code can handle this correctly in project mode, but many editors will do strange things in this case\.
+.P
+\fIDefault:\fP \fB$EDITOR\fP or \fB$VISUAL\fP\&\.
+.RE
 .TP
-\fBHOMEBREW_FORCE_BREWED_CA_CERTIFICATES\fR
-.
-.br
-If set, always use a Homebrew\-installed \fBca\-certificates\fR rather than the system version\. Automatically set if the system version is too old\.
-.
+\fBHOMEBREW_EVAL_ALL\fP
+If set, \fBbrew\fP commands evaluate all formulae and casks, executing their arbitrary code, by default without requiring \fB\-\-eval\-all\fP\&\. Required to cache formula and cask descriptions\.
 .TP
-\fBHOMEBREW_FORCE_BREWED_CURL\fR
-.
-.br
-If set, always use a Homebrew\-installed \fBcurl\fR(1) rather than the system version\. Automatically set if the system version of \fBcurl\fR is too old\.
-.
+\fBHOMEBREW_FAIL_LOG_LINES\fP
+Output this many lines of output on formula \fBsystem\fP failures\.
+.RS
+.P
+\fIDefault:\fP \fB15\fP\&\.
+.RE
 .TP
-\fBHOMEBREW_FORCE_BREWED_GIT\fR
-.
-.br
-If set, always use a Homebrew\-installed \fBgit\fR(1) rather than the system version\. Automatically set if the system version of \fBgit\fR is too old\.
-.
+\fBHOMEBREW_FORBIDDEN_CASKS\fP
+A space\-separated list of casks\. Homebrew will refuse to install a cask if it or any of its dependencies is on this list\.
 .TP
-\fBHOMEBREW_FORCE_VENDOR_RUBY\fR
-.
-.br
-If set, always use Homebrew\'s vendored, relocatable Ruby version even if the system version of Ruby is new enough\.
-.
+\fBHOMEBREW_FORBIDDEN_FORMULAE\fP
+A space\-separated list of formulae\. Homebrew will refuse to install a formula or cask if it or any of its dependencies is on this list\.
 .TP
-\fBHOMEBREW_GITHUB_API_TOKEN\fR
-.
-.br
-Use this personal access token for the GitHub API, for features such as \fBbrew search\fR\. You can create one at \fIhttps://github\.com/settings/tokens\fR\. If set, GitHub will allow you a greater number of API requests\. For more information, see: \fIhttps://docs\.github\.com/en/rest/overview/resources\-in\-the\-rest\-api#rate\-limiting\fR
-.
-.IP
-\fINote:\fR Homebrew doesn\'t require permissions for any of the scopes, but some developer commands may require additional permissions\.
-.
-.TP
-\fBHOMEBREW_GITHUB_PACKAGES_TOKEN\fR
-.
-.br
-Use this GitHub personal access token when accessing the GitHub Packages Registry (where bottles may be stored)\.
-.
+\fBHOMEBREW_FORBIDDEN_LICENSES\fP
+A space\-separated list of SPDX license identifiers\. Homebrew will refuse to install a formula if it or any of its dependencies has a license on this list\.
 .TP
-\fBHOMEBREW_DOCKER_REGISTRY_BASIC_AUTH_TOKEN\fR
-.
-.br
-Use this base64 encoded username and password for authenticating with a Docker registry proxying GitHub Packages\. If HOMEBREW_DOCKER_REGISTRY_TOKEN is set, it will be used instead\.
-.
+\fBHOMEBREW_FORBIDDEN_OWNER\fP
+The person who has set any \fBHOMEBREW_FORBIDDEN_*\fP variables\.
+.RS
+.P
+\fIDefault:\fP \fByou\fP\&\.
+.RE
 .TP
-\fBHOMEBREW_DOCKER_REGISTRY_TOKEN\fR
-.
-.br
-Use this bearer token for authenticating with a Docker registry proxying GitHub Packages\. Preferred over HOMEBREW_DOCKER_REGISTRY_TOKEN_BASIC\.
-.
+\fBHOMEBREW_FORBIDDEN_OWNER_CONTACT\fP
+How to contact the \fBHOMEBREW_FORBIDDEN_OWNER\fP, if set and necessary\.
 .TP
-\fBHOMEBREW_GITHUB_PACKAGES_USER\fR
-.
-.br
+\fBHOMEBREW_FORBIDDEN_TAPS\fP
+A space\-separated list of taps\. Homebrew will refuse to install a formula if it or any of its dependencies is in a tap on this list\.
+.TP
+\fBHOMEBREW_FORBID_PACKAGES_FROM_PATHS\fP
+If set, Homebrew will refuse to read formulae or casks provided from file paths, e\.g\. \fBbrew install \./package\.rb\fP\&\.
+.TP
+\fBHOMEBREW_FORCE_BREWED_CA_CERTIFICATES\fP
+If set, always use a Homebrew\-installed \fBca\-certificates\fP rather than the system version\. Automatically set if the system version is too old\.
+.TP
+\fBHOMEBREW_FORCE_BREWED_CURL\fP
+If set, always use a Homebrew\-installed \fBcurl\fP(1) rather than the system version\. Automatically set if the system version of \fBcurl\fP is too old\.
+.TP
+\fBHOMEBREW_FORCE_BREWED_GIT\fP
+If set, always use a Homebrew\-installed \fBgit\fP(1) rather than the system version\. Automatically set if the system version of \fBgit\fP is too old\.
+.TP
+\fBHOMEBREW_FORCE_VENDOR_RUBY\fP
+If set, always use Homebrew\[u2019]s vendored, relocatable Ruby version even if the system version of Ruby is new enough\.
+.TP
+\fBHOMEBREW_FORMULA_BUILD_NETWORK\fP
+If set, controls network access to the sandbox for formulae builds\. Overrides any controls set through DSL usage inside formulae\. Must be \fBallow\fP or \fBdeny\fP\&\. If no value is set through this environment variable or DSL usage, the default behavior is \fBallow\fP\&\.
+.TP
+\fBHOMEBREW_FORMULA_POSTINSTALL_NETWORK\fP
+If set, controls network access to the sandbox for formulae postinstall\. Overrides any controls set through DSL usage inside formulae\. Must be \fBallow\fP or \fBdeny\fP\&\. If no value is set through this environment variable or DSL usage, the default behavior is \fBallow\fP\&\.
+.TP
+\fBHOMEBREW_FORMULA_TEST_NETWORK\fP
+If set, controls network access to the sandbox for formulae test\. Overrides any controls set through DSL usage inside formulae\. Must be \fBallow\fP or \fBdeny\fP\&\. If no value is set through this environment variable or DSL usage, the default behavior is \fBallow\fP\&\.
+.TP
+\fBHOMEBREW_GITHUB_API_TOKEN\fP
+Use this personal access token for the GitHub API, for features such as \fBbrew search\fP\&\. You can create one at 
+.UR https://github\.com/settings/tokens
+.UE \&\. If set, GitHub will allow you a greater number of API requests\. For more information, see: 
+.UR https://docs\.github\.com/en/rest/overview/rate\-limits\-for\-the\-rest\-api
+.UE
+.RS
+.P
+\fINote:\fP Homebrew doesn\[u2019]t require permissions for any of the scopes, but some developer commands may require additional permissions\.
+.RE
+.TP
+\fBHOMEBREW_GITHUB_PACKAGES_TOKEN\fP
+Use this GitHub personal access token when accessing the GitHub Packages Registry (where bottles may be stored)\.
+.TP
+\fBHOMEBREW_GITHUB_PACKAGES_USER\fP
 Use this username when accessing the GitHub Packages Registry (where bottles may be stored)\.
-.
 .TP
-\fBHOMEBREW_GIT_EMAIL\fR
-.
-.br
+\fBHOMEBREW_GIT_EMAIL\fP
 Set the Git author and committer email to this value\.
-.
 .TP
-\fBHOMEBREW_GIT_NAME\fR
-.
-.br
+\fBHOMEBREW_GIT_NAME\fP
 Set the Git author and committer name to this value\.
-.
 .TP
-\fBHOMEBREW_GIT_PATH\fR
-.
-.br
-Linux only: Set this value to a new enough \fBgit\fR executable for Homebrew to use\.
-.
-.IP
-\fIDefault:\fR \fBgit\fR\.
-.
-.TP
-\fBHOMEBREW_INSTALL_BADGE\fR
-.
-.br
+\fBHOMEBREW_GIT_PATH\fP
+Linux only: Set this value to a new enough \fBgit\fP executable for Homebrew to use\.
+.RS
+.P
+\fIDefault:\fP \fBgit\fP\&\.
+.RE
+.TP
+\fBHOMEBREW_INSTALL_BADGE\fP
 Print this text before the installation summary of each successful build\.
-.
-.IP
-\fIDefault:\fR The "Beer Mug" emoji\.
-.
+.RS
+.P
+\fIDefault:\fP The \[u201c]Beer Mug\[u201d] emoji\.
+.RE
 .TP
-\fBHOMEBREW_INSTALL_FROM_API\fR
-.
-.br
-If set, install formulae and casks in homebrew/core and homebrew/cask taps using Homebrew\'s API instead of needing (large, slow) local checkouts of these repositories\.
-.
-.IP
-\fINote:\fR Setting HOMEBREW_INSTALL_FROM_API is not compatible with Homebrew\'s developer mode so will error (as Homebrew development needs a full clone)\.
-.
-.TP
-\fBHOMEBREW_LIVECHECK_WATCHLIST\fR
-.
-.br
-Consult this file for the list of formulae to check by default when no formula argument is passed to \fBbrew livecheck\fR\.
-.
-.IP
-\fIDefault:\fR \fB$HOME/\.brew_livecheck_watchlist\fR
-.
-.TP
-\fBHOMEBREW_LOGS\fR
-.
-.br
+\fBHOMEBREW_LIVECHECK_WATCHLIST\fP
+Consult this file for the list of formulae to check by default when no formula argument is passed to \fBbrew livecheck\fP\&\.
+.RS
+.P
+\fIDefault:\fP \fB$XDG_CONFIG_HOME/homebrew/livecheck_watchlist\.txt\fP if \fB$XDG_CONFIG_HOME\fP is set or \fB$HOME/\.homebrew/livecheck_watchlist\.txt\fP otherwise\.
+.RE
+.TP
+\fBHOMEBREW_LOCK_CONTEXT\fP
+If set, Homebrew will add this output as additional context for locking errors\. This is useful when running \fBbrew\fP in the background\.
+.TP
+\fBHOMEBREW_LOGS\fP
 Use this directory to store log files\.
-.
-.IP
-\fIDefault:\fR macOS: \fB$HOME/Library/Logs/Homebrew\fR, Linux: \fB$XDG_CACHE_HOME/Homebrew/Logs\fR or \fB$HOME/\.cache/Homebrew/Logs\fR\.
-.
+.RS
+.P
+\fIDefault:\fP macOS: \fB$HOME/Library/Logs/Homebrew\fP, Linux: \fB$XDG_CACHE_HOME/Homebrew/Logs\fP or \fB$HOME/\.cache/Homebrew/Logs\fP\&\.
+.RE
 .TP
-\fBHOMEBREW_MAKE_JOBS\fR
-.
-.br
-Use this value as the number of parallel jobs to run when building with \fBmake\fR(1)\.
-.
-.IP
-\fIDefault:\fR The number of available CPU cores\.
-.
-.TP
-\fBHOMEBREW_NO_ANALYTICS\fR
-.
-.br
-If set, do not send analytics\. For more information, see: \fIhttps://docs\.brew\.sh/Analytics\fR
-.
+\fBHOMEBREW_MAKE_JOBS\fP
+Use this value as the number of parallel jobs to run when building with \fBmake\fP(1)\.
+.RS
+.P
+\fIDefault:\fP The number of available CPU cores\.
+.RE
 .TP
-\fBHOMEBREW_NO_AUTO_UPDATE\fR
-.
-.br
-If set, do not automatically update before running some commands, e\.g\. \fBbrew install\fR, \fBbrew upgrade\fR and \fBbrew tap\fR\. Alternatively, run this less often by setting HOMEBREW_AUTO_UPDATE_SECS to a value higher than the default\.
-.
+\fBHOMEBREW_NO_ANALYTICS\fP
+If set, do not send analytics\. Google Analytics were destroyed\. For more information, see: 
+.UR https://docs\.brew\.sh/Analytics
+.UE
 .TP
-\fBHOMEBREW_NO_BOOTSNAP\fR
-.
-.br
-If set, do not use Bootsnap to speed up repeated \fBbrew\fR calls\.
-.
+\fBHOMEBREW_NO_AUTOREMOVE\fP
+If set, calls to \fBbrew cleanup\fP and \fBbrew uninstall\fP will not automatically remove unused formula dependents\.
 .TP
-\fBHOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK\fR
-.
-.br
-If set, do not check for broken linkage of dependents or outdated dependents after installing, upgrading or reinstalling formulae\. This will result in fewer dependents (and their dependencies) being upgraded or reinstalled but may result in more breakage from running \fBbrew install <formula>\fR or \fBbrew upgrade <formula>\fR\.
-.
+\fBHOMEBREW_NO_AUTO_UPDATE\fP
+If set, do not automatically update before running some commands, e\.g\. \fBbrew install\fP, \fBbrew upgrade\fP and \fBbrew tap\fP\&\. Preferably, run this less often by setting \fBHOMEBREW_AUTO_UPDATE_SECS\fP to a value higher than the default\. Note that setting this and e\.g\. tapping new taps may result in a broken configuration\. Please ensure you always run \fBbrew update\fP before reporting any issues\.
 .TP
-\fBHOMEBREW_NO_CLEANUP_FORMULAE\fR
-.
-.br
-A comma\-separated list of formulae\. Homebrew will refuse to clean up a formula if it appears on this list\.
-.
+\fBHOMEBREW_NO_BOOTSNAP\fP
+If set, do not use Bootsnap to speed up repeated \fBbrew\fP calls\.
 .TP
-\fBHOMEBREW_NO_COLOR\fR
-.
-.br
+\fBHOMEBREW_NO_CLEANUP_FORMULAE\fP
+A comma\-separated list of formulae\. Homebrew will refuse to clean up or autoremove a formula if it appears on this list\.
+.TP
+\fBHOMEBREW_NO_COLOR\fP
 If set, do not print text with colour added\.
-.
-.IP
-\fIDefault:\fR \fB$NO_COLOR\fR\.
-.
+.RS
+.P
+\fIDefault:\fP \fB$NO_COLOR\fP\&\.
+.RE
 .TP
-\fBHOMEBREW_NO_COMPAT\fR
-.
-.br
-If set, disable all use of legacy compatibility code\.
-.
+\fBHOMEBREW_NO_EMOJI\fP
+If set, do not print \fBHOMEBREW_INSTALL_BADGE\fP on a successful build\.
 .TP
-\fBHOMEBREW_NO_EMOJI\fR
-.
-.br
-If set, do not print \fBHOMEBREW_INSTALL_BADGE\fR on a successful build\.
-.
-.IP
-\fINote:\fR Will only try to print emoji on OS X Lion or newer\.
-.
-.TP
-\fBHOMEBREW_NO_ENV_HINTS\fR
-.
-.br
-If set, do not print any hints about changing Homebrew\'s behaviour with environment variables\.
-.
+\fBHOMEBREW_NO_ENV_HINTS\fP
+If set, do not print any hints about changing Homebrew\[u2019]s behaviour with environment variables\.
 .TP
-\fBHOMEBREW_NO_GITHUB_API\fR
-.
-.br
+\fBHOMEBREW_NO_GITHUB_API\fP
 If set, do not use the GitHub API, e\.g\. for searches or fetching relevant issues after a failed install\.
-.
 .TP
-\fBHOMEBREW_NO_INSECURE_REDIRECT\fR
-.
-.br
+\fBHOMEBREW_NO_INSECURE_REDIRECT\fP
 If set, forbid redirects from secure HTTPS to insecure HTTP\.
-.
-.IP
-\fINote:\fR While ensuring your downloads are fully secure, this is likely to cause from\-source SourceForge, some GNU & GNOME\-hosted formulae to fail to download\.
-.
+.RS
+.P
+\fINote:\fP while ensuring your downloads are fully secure, this is likely to cause from\-source SourceForge, some GNU & GNOME\-hosted formulae to fail to download\.
+.RE
 .TP
-\fBHOMEBREW_NO_INSTALL_CLEANUP\fR
-.
-.br
-If set, \fBbrew install\fR, \fBbrew upgrade\fR and \fBbrew reinstall\fR will never automatically cleanup installed/upgraded/reinstalled formulae or all formulae every \fBHOMEBREW_CLEANUP_PERIODIC_FULL_DAYS\fR days\. Alternatively, HOMEBREW_NO_CLEANUP_FORMULAE allows specifying specific formulae to not clean up\.
-.
+\fBHOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK\fP
+If set, do not check for broken linkage of dependents or outdated dependents after installing, upgrading or reinstalling formulae\. This will result in fewer dependents (and their dependencies) being upgraded or reinstalled but may result in more breakage from running \fBbrew install\fP \fIformula\fP or \fBbrew upgrade\fP \fIformula\fP\&\.
 .TP
-\fBHOMEBREW_NO_INSTALL_UPGRADE\fR
-.
-.br
-If set, \fBbrew install <formula>\fR will not upgrade \fB<formula>\fR if it is installed but outdated\.
-.
+\fBHOMEBREW_NO_INSTALL_CLEANUP\fP
+If set, \fBbrew install\fP, \fBbrew upgrade\fP and \fBbrew reinstall\fP will never automatically cleanup installed/upgraded/reinstalled formulae or all formulae every \fBHOMEBREW_CLEANUP_PERIODIC_FULL_DAYS\fP days\. Alternatively, \fBHOMEBREW_NO_CLEANUP_FORMULAE\fP allows specifying specific formulae to not clean up\.
 .TP
-\fBHOMEBREW_PRY\fR
-.
-.br
-If set, use Pry for the \fBbrew irb\fR command\.
-.
+\fBHOMEBREW_NO_INSTALL_FROM_API\fP
+If set, do not install formulae and casks in homebrew/core and homebrew/cask taps using Homebrew\[u2019]s API and instead use (large, slow) local checkouts of these repositories\.
 .TP
-\fBHOMEBREW_SIMULATE_MACOS_ON_LINUX\fR
-.
-.br
+\fBHOMEBREW_NO_INSTALL_UPGRADE\fP
+If set, \fBbrew install\fP \fIformula|cask\fP will not upgrade \fIformula|cask\fP if it is installed but outdated\.
+.TP
+\fBHOMEBREW_NO_UPDATE_REPORT_NEW\fP
+If set, \fBbrew update\fP will not show the list of newly added formulae/casks\.
+.TP
+\fBHOMEBREW_NO_VERIFY_ATTESTATIONS\fP
+If set, Homebrew not verify cryptographic attestations of build provenance for bottles from homebrew\-core\.
+.TP
+\fBHOMEBREW_PIP_INDEX_URL\fP
+If set, \fBbrew install\fP \fIformula\fP will use this URL to download PyPI package resources\.
+.RS
+.P
+\fIDefault:\fP \fBhttps://pypi\.org/simple\fP\&\.
+.RE
+.TP
+\fBHOMEBREW_PRY\fP
+If set, use Pry for the \fBbrew irb\fP command\.
+.TP
+\fBHOMEBREW_SIMULATE_MACOS_ON_LINUX\fP
 If set, running Homebrew on Linux will simulate certain macOS code paths\. This is useful when auditing macOS formulae while on Linux\.
-.
 .TP
-\fBHOMEBREW_SSH_CONFIG_PATH\fR
-.
-.br
-If set, Homebrew will use the given config file instead of \fB~/\.ssh/config\fR when fetching \fBgit\fR repos over \fBssh\fR\.
-.
-.IP
-\fIDefault:\fR \fB$HOME/\.ssh/config\fR
-.
-.TP
-\fBHOMEBREW_SKIP_OR_LATER_BOTTLES\fR
-.
-.br
-If set along with \fBHOMEBREW_DEVELOPER\fR, do not use bottles from older versions of macOS\. This is useful in development on new macOS versions\.
-.
+\fBHOMEBREW_SKIP_OR_LATER_BOTTLES\fP
+If set along with \fBHOMEBREW_DEVELOPER\fP, do not use bottles from older versions of macOS\. This is useful in development on new macOS versions\.
 .TP
-\fBHOMEBREW_SORBET_RUNTIME\fR
-.
-.br
-If set, enable runtime typechecking using Sorbet\.
-.
+\fBHOMEBREW_SORBET_RUNTIME\fP
+If set, enable runtime typechecking using Sorbet\. Set by default for \fBHOMEBREW_DEVELOPER\fP or when running some developer commands\.
 .TP
-\fBHOMEBREW_SVN\fR
-.
-.br
-Use this as the \fBsvn\fR(1) binary\.
-.
-.IP
-\fIDefault:\fR A Homebrew\-built Subversion (if installed), or the system\-provided binary\.
-.
-.TP
-\fBHOMEBREW_TEMP\fR
-.
-.br
-Use this path as the temporary directory for building packages\. Changing this may be needed if your system temporary directory and Homebrew prefix are on different volumes, as macOS has trouble moving symlinks across volumes when the target does not yet exist\. This issue typically occurs when using FileVault or custom SSD configurations\.
-.
-.IP
-\fIDefault:\fR macOS: \fB/private/tmp\fR, Linux: \fB/tmp\fR\.
-.
+\fBHOMEBREW_SSH_CONFIG_PATH\fP
+If set, Homebrew will use the given config file instead of \fB~/\.ssh/config\fP when fetching Git repositories over SSH\.
+.RS
+.P
+\fIDefault:\fP \fB$HOME/\.ssh/config\fP
+.RE
 .TP
-\fBHOMEBREW_UPDATE_REPORT_ALL_FORMULAE\fR
-.
-.br
-If set, \fBbrew update\fR lists changes to all formulae and cask files rather than only showing when they are new and not installed or outdated and installed\.
-.
+\fBHOMEBREW_SUDO_THROUGH_SUDO_USER\fP
+If set, Homebrew will use the \fBSUDO_USER\fP environment variable to define the user to \fBsudo\fP(8) through when running \fBsudo\fP(8)\.
 .TP
-\fBHOMEBREW_UPDATE_TO_TAG\fR
-.
-.br
+\fBHOMEBREW_SVN\fP
+Use this as the \fBsvn\fP(1) binary\.
+.RS
+.P
+\fIDefault:\fP A Homebrew\-built Subversion (if installed), or the system\-provided binary\.
+.RE
+.TP
+\fBHOMEBREW_SYSTEM_ENV_TAKES_PRIORITY\fP
+If set in Homebrew\[u2019]s system\-wide environment file (\fB/etc/homebrew/brew\.env\fP), the system\-wide environment file will be loaded last to override any prefix or user settings\.
+.TP
+\fBHOMEBREW_TEMP\fP
+Use this path as the temporary directory for building packages\. Changing this may be needed if your system temporary directory and Homebrew prefix are on different volumes, as macOS has trouble moving symlinks across volumes when the target does not yet exist\. This issue typically occurs when using FileVault or custom SSD configurations\.
+.RS
+.P
+\fIDefault:\fP macOS: \fB/private/tmp\fP, Linux: \fB/tmp\fP\&\.
+.RE
+.TP
+\fBHOMEBREW_UPDATE_TO_TAG\fP
 If set, always use the latest stable tag (even if developer commands have been run)\.
-.
 .TP
-\fBHOMEBREW_VERBOSE\fR
-.
-.br
-If set, always assume \fB\-\-verbose\fR when running commands\.
-.
+\fBHOMEBREW_UPGRADE_GREEDY\fP
+If set, pass \fB\-\-greedy\fP to all cask upgrade commands\.
 .TP
-\fBHOMEBREW_DEBUG\fR
-.
-.br
-If set, always assume \fB\-\-debug\fR when running commands\.
-.
+\fBHOMEBREW_VERBOSE\fP
+If set, always assume \fB\-\-verbose\fP when running commands\.
 .TP
-\fBHOMEBREW_VERBOSE_USING_DOTS\fR
-.
-.br
-If set, verbose output will print a \fB\.\fR no more than once a minute\. This can be useful to avoid long\-running Homebrew commands being killed due to no output\.
-.
+\fBHOMEBREW_VERBOSE_USING_DOTS\fP
+If set, verbose output will print a \fB\&\.\fP no more than once a minute\. This can be useful to avoid long\-running Homebrew commands being killed due to no output\.
 .TP
-\fBall_proxy\fR
-.
-.br
-Use this SOCKS5 proxy for \fBcurl\fR(1), \fBgit\fR(1) and \fBsvn\fR(1) when downloading through Homebrew\.
-.
+\fBHOMEBREW_VERIFY_ATTESTATIONS\fP
+If set, Homebrew will use the \fBgh\fP tool to verify cryptographic attestations of build provenance for bottles from homebrew\-core\.
 .TP
-\fBftp_proxy\fR
-.
-.br
-Use this FTP proxy for \fBcurl\fR(1), \fBgit\fR(1) and \fBsvn\fR(1) when downloading through Homebrew\.
-.
+\fBSUDO_ASKPASS\fP
+If set, pass the \fB\-A\fP option when calling \fBsudo\fP(8)\.
 .TP
-\fBhttp_proxy\fR
-.
-.br
-Use this HTTP proxy for \fBcurl\fR(1), \fBgit\fR(1) and \fBsvn\fR(1) when downloading through Homebrew\.
-.
+\fBall_proxy\fP
+Use this SOCKS5 proxy for \fBcurl\fP(1), \fBgit\fP(1) and \fBsvn\fP(1) when downloading through Homebrew\.
 .TP
-\fBhttps_proxy\fR
-.
-.br
-Use this HTTPS proxy for \fBcurl\fR(1), \fBgit\fR(1) and \fBsvn\fR(1) when downloading through Homebrew\.
-.
+\fBftp_proxy\fP
+Use this FTP proxy for \fBcurl\fP(1), \fBgit\fP(1) and \fBsvn\fP(1) when downloading through Homebrew\.
 .TP
-\fBno_proxy\fR
-.
-.br
-A comma\-separated list of hostnames and domain names excluded from proxying by \fBcurl\fR(1), \fBgit\fR(1) and \fBsvn\fR(1) when downloading through Homebrew\.
-.
+\fBhttp_proxy\fP
+Use this HTTP proxy for \fBcurl\fP(1), \fBgit\fP(1) and \fBsvn\fP(1) when downloading through Homebrew\.
 .TP
-\fBSUDO_ASKPASS\fR
-.
-.br
-If set, pass the \fB\-A\fR option when calling \fBsudo\fR(8)\.
-.
+\fBhttps_proxy\fP
+Use this HTTPS proxy for \fBcurl\fP(1), \fBgit\fP(1) and \fBsvn\fP(1) when downloading through Homebrew\.
+.TP
+\fBno_proxy\fP
+A comma\-separated list of hostnames and domain names excluded from proxying by \fBcurl\fP(1), \fBgit\fP(1) and \fBsvn\fP(1) when downloading through Homebrew\.
 .SH "USING HOMEBREW BEHIND A PROXY"
-Set the \fBhttp_proxy\fR, \fBhttps_proxy\fR, \fBall_proxy\fR, \fBftp_proxy\fR and/or \fBno_proxy\fR environment variables documented above\.
-.
+Set the \fBhttp_proxy\fP, \fBhttps_proxy\fP, \fBall_proxy\fP, \fBftp_proxy\fP and/or \fBno_proxy\fP environment variables documented above\.
 .P
 For example, to use an unauthenticated HTTP or SOCKS5 proxy:
-.
-.IP "" 4
-.
-.nf
-
+.sp
+.RS 4
+.EX
 export http_proxy=http://$HOST:$PORT
 
 export all_proxy=socks5://$HOST:$PORT
-.
-.fi
-.
-.IP "" 0
-.
+.EE
+.RE
 .P
 And for an authenticated HTTP proxy:
-.
-.IP "" 4
-.
-.nf
-
+.sp
+.RS 4
+.EX
 export http_proxy=http://$USER:$PASSWORD@$HOST:$PORT
-.
-.fi
-.
-.IP "" 0
-.
+.EE
+.RE
 .SH "SEE ALSO"
-Homebrew Documentation: \fIhttps://docs\.brew\.sh\fR
-.
+Homebrew Documentation: 
+.UR https://docs\.brew\.sh
+.UE
 .P
-Homebrew API: \fIhttps://rubydoc\.brew\.sh\fR
-.
+Homebrew API: 
+.UR https://rubydoc\.brew\.sh
+.UE
 .P
-\fBgit\fR(1), \fBgit\-log\fR(1)
-.
+\fBgit\fP(1), \fBgit\-log\fP(1)
 .SH "AUTHORS"
-Homebrew\'s Project Leader is Mike McQuaid\.
-.
+Homebrew\[u2019]s Project Leader is Mike McQuaid\.
 .P
-Homebrew\'s Project Leadership Committee is Issy Long, Jonathan Chang, Mike McQuaid, Misty De Meo and Sean Molenaar\.
-.
+Homebrew\[u2019]s Project Leadership Committee is Colin Dean, Issy Long, Mike McQuaid, Patrick Linnane and Vanessa Gennarelli\.
 .P
-Homebrew\'s Technical Steering Committee is Bo Anderson, FX Coudert, Michka Popoff, Mike McQuaid and Rylan Polster\.
-.
+Homebrew\[u2019]s Technical Steering Committee is Bo Anderson, FX Coudert, Michka Popoff, Mike McQuaid and Rylan Polster\.
 .P
-Homebrew\'s other current maintainers are Alexander Bayandin, Bevan Kay, Branch Vincent, Caleb Xu, Carlo Cabrera, Daniel Nachun, Dawid Dziurla, Dustin Rodrigues, Eric Knibbe, George Adams, Markus Reiter, Maxim Belkin, Miccal Matthews, Michael Cho, Nanda H Krishna, Randall, Rui Chen, Sam Ford, Shaun Jackman, Steve Peters, Thierry Moisan and Vitor Galvao\.
-.
+Homebrew\[u2019]s maintainers are Alexander Bayandin, Bevan Kay, Bo Anderson, Branch Vincent, Caleb Xu, Carlo Cabrera, Daeho Ro, Douglas Eichelberger, Dustin Rodrigues, Eric Knibbe, FX Coudert, Issy Long, Justin Krehel, Klaus Hipp, Markus Reiter, Michael Cho, Michka Popoff, Mike McQuaid, Nanda H Krishna, Patrick Linnane, Rui Chen, Ruoyu Zhong, Rylan Polster, Sam Ford, Sean Molenaar, Thierry Moisan, Timothy Sutton, William Woodruff and Štefan Baebler\.
 .P
-Former maintainers with significant contributions include Claudia Pellegrino, Seeker, William Woodruff, Jan Viljanen, JCount, commitay, Dominyk Tiller, Tim Smith, Baptiste Fontaine, Xu Cheng, Martin Afanasjew, Brett Koonce, Charlie Sharpsteen, Jack Nagel, Adam Vandenberg, Andrew Janke, Alex Dunn, neutric, Tomasz Pajor, Uladzislau Shablinski, Alyssa Ross, ilovezfs, Chongyu Zhu and Homebrew\'s creator: Max Howell\.
-.
+Former maintainers with significant contributions include Miccal Matthews, Misty De Méo, Shaun Jackman, Vítor Galvão, Claudia Pellegrino, Seeker, Jan Viljanen, JCount, commitay, Dominyk Tiller, Tim Smith, Baptiste Fontaine, Xu Cheng, Martin Afanasjew, Brett Koonce, Charlie Sharpsteen, Jack Nagel, Adam Vandenberg, Andrew Janke, Alex Dunn, neutric, Tomasz Pajor, Uladzislau Shablinski, Alyssa Ross, ilovezfs, Chongyu Zhu and Homebrew\[u2019]s creator: Max Howell\.
 .SH "BUGS"
 See our issues on GitHub:
-.
 .TP
-\fBHomebrew/brew\fR
-.
-.br
-\fIhttps://github\.com/Homebrew/brew/issues\fR
-.
+\fBHomebrew/brew\fP
+.UR https://github\.com/Homebrew/brew/issues
+.UE
 .TP
-\fBHomebrew/homebrew\-core\fR
-.
-.br
-\fIhttps://github\.com/Homebrew/homebrew\-core/issues\fR
-.
+\fBHomebrew/homebrew\-core\fP
+.UR https://github\.com/Homebrew/homebrew\-core/issues
+.UE
 .TP
-\fBHomebrew/homebrew\-cask\fR
-.
-.br
-\fIhttps://github\.com/Homebrew/homebrew\-cask/issues\fR
-
+\fBHomebrew/homebrew\-cask\fP
+.UR https://github\.com/Homebrew/homebrew\-cask/issues
+.UE
diff --git a/package/Distribution.xml b/package/Distribution.xml
new file mode 100644
index 0000000000000..df0b22fccec9d
--- /dev/null
+++ b/package/Distribution.xml
@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<installer-gui-script minSpecVersion="2">
+  <pkg-ref id="sh.brew.homebrew"/>
+  <options customize="never" hostArchitectures="x86_64,arm64" rootVolumeOnly="true"/>
+  <volume-check>
+    <allowed-os-versions>
+        <os-version min="13.0.0"/>
+    </allowed-os-versions>
+  </volume-check>
+  <choices-outline>
+    <line choice="default">
+      <line choice="sh.brew.homebrew"/>
+    </line>
+  </choices-outline>
+  <choice id="default"/>
+  <choice id="sh.brew.homebrew" visible="false">
+    <pkg-ref id="sh.brew.homebrew"/>
+  </choice>
+  <pkg-ref id="sh.brew.homebrew" onConclusion="none">Homebrew.pkg</pkg-ref>
+
+  <title>Homebrew</title>
+  <organization>sh.brew</organization>
+
+  <background file="Homebrew.png" alignment="bottomleft" scaling="proportional"/>
+  <background-darkAqua file="Homebrew.png" alignment="bottomleft" scaling="proportional"/>
+  <welcome file="WELCOME.rtf"/>
+  <license file="LICENSE.rtf"/>
+  <conclusion file="CONCLUSION.rtf" />
+  <allowed-os-versions>
+    <os-version min="13.0.0"/>
+  </allowed-os-versions>
+
+  <script>
+    // See https://developer.apple.com/documentation/installer_js
+    function installation_check() {
+      if (system.files.fileExistsAtPath("/Library/Developer/CommandLineTools/usr/bin/git")) {
+        return true;
+      } else {
+        my.result.title = "Command Line Tools (CLT) are missing";
+        my.result.message = "You must install the Command Line Tools (CLT) before installing Homebrew by running `xcode-select --install` from a Terminal.";
+        my.result.type = "Fatal";
+        return false;
+      }
+    }
+  </script>
+  <installation-check script="installation_check()" />
+</installer-gui-script>
diff --git a/package/resources/CONCLUSION.rtf b/package/resources/CONCLUSION.rtf
new file mode 100644
index 0000000000000..a057952d22a13
--- /dev/null
+++ b/package/resources/CONCLUSION.rtf
@@ -0,0 +1,53 @@
+{\rtf1\ansi\ansicpg1252\cocoartf2709
+\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fnil\fcharset0 HelveticaNeue-Bold;\f1\fnil\fcharset0 HelveticaNeue;\f2\fnil\fcharset0 Menlo-Regular;
+}
+{\colortbl;\red255\green255\blue255;}
+{\*\expandedcolortbl;;}
+{\*\listtable{\list\listtemplateid1\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace360\levelindent0{\*\levelmarker \{hyphen\}}{\leveltext\leveltemplateid1\'01\uc0\u8259 ;}{\levelnumbers;}\fi-360\li720\lin720 }{\listname ;}\listid1}
+{\list\listtemplateid2\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace360\levelindent0{\*\levelmarker \{hyphen\}}{\leveltext\leveltemplateid101\'01\uc0\u8259 ;}{\levelnumbers;}\fi-360\li720\lin720 }{\listname ;}\listid2}
+{\list\listtemplateid3\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace360\levelindent0{\*\levelmarker \{hyphen\}}{\leveltext\leveltemplateid201\'01\uc0\u8259 ;}{\levelnumbers;}\fi-360\li720\lin720 }{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace360\levelindent0{\*\levelmarker \{hyphen\}}{\leveltext\leveltemplateid202\'01\uc0\u8259 ;}{\levelnumbers;}\fi-360\li1440\lin1440 }{\listname ;}\listid3}}
+{\*\listoverridetable{\listoverride\listid1\listoverridecount0\ls1}{\listoverride\listid2\listoverridecount0\ls2}{\listoverride\listid3\listoverridecount0\ls3}}
+\paperw11900\paperh16840\margl1440\margr1440\vieww13440\viewh7240\viewkind0
+\pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural\partightenfactor0
+
+\f0\b\fs24 \cf0 Homebrew has enabled anonymous aggregate formulae and cask analytics.
+\f1\b0 \
+\
+Read the analytics documentation (and how to opt-out) here:\
+\pard\tx220\tx720\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\li720\fi-720\pardirnatural\partightenfactor0
+\ls1\ilvl0\cf0 {\listtext	\uc0\u8259 	}{\field{\*\fldinst{HYPERLINK "https://docs.brew.sh/Analytics"}}{\fldrslt \ul https://docs.brew.sh/Analytics}}\ul \
+\pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural\partightenfactor0
+\cf0 \ulnone No analytics data has been sent yet.\
+\
+Homebrew is run entirely by unpaid volunteers. Please consider donating:\
+\pard\tx220\tx720\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\li720\fi-720\pardirnatural\partightenfactor0
+\ls2\ilvl0\cf0 {\listtext	\uc0\u8259 	}{\field{\*\fldinst{HYPERLINK "https://github.com/Homebrew/brew#donations"}}{\fldrslt \ul https://github.com/Homebrew/brew#donations}}\ul \
+\pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural\partightenfactor0
+\cf0 \ulc0 \
+\ulnone Next steps:\ul \
+\pard\tx220\tx720\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\li720\fi-720\pardirnatural\partightenfactor0
+\ls3\ilvl0\cf0 \ulnone {\listtext	\uc0\u8259 	}To add Homebrew to your 
+\f2 PATH
+\f1 , add to your shell profile (e.g. 
+\f2 ~/.bash_profile
+\f1  or 
+\f2 ~/.zprofile
+\f1 ):\
+\pard\tx940\tx1440\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\li1440\fi-1440\pardirnatural\partightenfactor0
+\ls3\ilvl1\cf0 {\listtext	\uc0\u8259 	}
+\f2 eval "$(/opt/homebrew/bin/brew shellenv)"
+\f1  on Apple Silicon\
+\ls3\ilvl1{\listtext	\uc0\u8259 	}
+\f2 eval "$(/usr/local/bin/brew shellenv)"
+\f1  on Intel\
+\pard\tx220\tx720\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\li720\fi-720\pardirnatural\partightenfactor0
+\ls3\ilvl0\cf0 {\listtext	\uc0\u8259 	}Run 
+\f2 brew help
+\f1  to get started\
+{\listtext	\uc0\u8259 	}Further documentation:\
+\pard\tx940\tx1440\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\li1440\fi-1440\pardirnatural\partightenfactor0
+\ls3\ilvl1\cf0 {\listtext	\uc0\u8259 	}{\field{\*\fldinst{HYPERLINK "https://docs.brew.sh"}}{\fldrslt \ul https://docs.brew.sh}}\ul \
+\pard\tx940\tx1440\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\li1440\fi-1440\pardirnatural\partightenfactor0
+\cf0 \
+\
+}
diff --git a/package/resources/Homebrew.png b/package/resources/Homebrew.png
new file mode 100644
index 0000000000000..d14d573bc9a2f
Binary files /dev/null and b/package/resources/Homebrew.png differ
diff --git a/package/resources/WELCOME.rtf b/package/resources/WELCOME.rtf
new file mode 100644
index 0000000000000..21b489cae79b0
--- /dev/null
+++ b/package/resources/WELCOME.rtf
@@ -0,0 +1,20 @@
+{\rtf1\ansi\ansicpg1252\cocoartf2709
+\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fnil\fcharset0 HelveticaNeue;\f1\fnil\fcharset0 Menlo-Regular;}
+{\colortbl;\red255\green255\blue255;}
+{\*\expandedcolortbl;;}
+{\*\listtable{\list\listtemplateid1\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace360\levelindent0{\*\levelmarker \{hyphen\}}{\leveltext\leveltemplateid1\'01\uc0\u8259 ;}{\levelnumbers;}\fi-360\li720\lin720 }{\listname ;}\listid1}}
+{\*\listoverridetable{\listoverride\listid1\listoverridecount0\ls1}}
+\paperw11900\paperh16840\margl1440\margr1440\vieww13440\viewh7240\viewkind0
+\pard\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural\partightenfactor0
+
+\f0\fs24 \cf0 This package will install to:\
+\pard\tx220\tx720\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\li720\fi-720\pardirnatural\partightenfactor0
+\ls1\ilvl0\cf0 {\listtext	\uc0\u8259 	}
+\f1 /opt/homebrew
+\f0  on Apple Silicon\
+{\listtext	\uc0\u8259 	}
+\f1 /usr/local/bin/brew
+\f0  and 
+\f1 /usr/local/Homebrew
+\f0  on Intel\
+}
\ No newline at end of file
diff --git a/package/scripts/postinstall b/package/scripts/postinstall
new file mode 100755
index 0000000000000..4296700b9059e
--- /dev/null
+++ b/package/scripts/postinstall
@@ -0,0 +1,94 @@
+#!/bin/bash
+# $1 Full path to the installer (unused)
+# $2 Location of the Homebrew installation we may need to move into place
+# $3 Target install location (unused)
+# $4 System root directory (unused)
+set -euo pipefail
+
+# disable analytics while installing
+export HOMEBREW_NO_ANALYTICS_THIS_RUN=1
+export HOMEBREW_NO_ANALYTICS_MESSAGE_OUTPUT=1
+
+# verify the installation exists
+# default to /opt/homebrew to make development/testing easier
+homebrew_directory="${2:-/opt/homebrew}"
+if [[ ! -d "${homebrew_directory:?}" ]]
+then
+  echo "No directory at ${homebrew_directory}!" >&2
+  exit 1
+fi
+
+# add Git to path
+export PATH="/Library/Developer/CommandLineTools/usr/bin:/Applications/Xcode.app/Contents/Developer/usr/bin:${PATH}"
+
+# avoid writing to user's global config file by overriding HOME
+# https://git-scm.com/docs/git-config#SCOPES
+unset XDG_CONFIG_HOME
+export HOME="${homebrew_directory}"
+
+# reset Git repository
+cd "${homebrew_directory}"
+git config --global --add safe.directory "${homebrew_directory}"
+git reset --hard
+git checkout --force master
+git branch | grep -v '\*' | xargs -n 1 git branch --delete --force || true
+rm "${homebrew_directory}/.gitconfig"
+
+# move to /usr/local if on x86_64
+if [[ $(uname -m) == "x86_64" ]]
+then
+  if [[ -f "/usr/local/bin/brew" && -d "/usr/local/Homebrew" ]]
+  then
+    cp -pRL "${homebrew_directory}/.git" "/usr/local/Homebrew/"
+    mv "${homebrew_directory}/cache_api" "/usr/local/Homebrew/"
+
+    export HOME="/usr/local/Homebrew"
+    git config --global --add safe.directory /usr/local/Homebrew
+    git -C /usr/local/Homebrew reset --hard
+    git -C /usr/local/Homebrew checkout --force master
+    rm /usr/local/Homebrew/.gitconfig
+  else
+    mkdir -vp /usr/local/bin
+    mv "${homebrew_directory}" "/usr/local/Homebrew/"
+
+    # create symlink to /usr/local/bin/brew
+    ln -svf "../Homebrew/bin/brew" "/usr/local/bin/brew"
+  fi
+
+  rm -rf "${homebrew_directory}"
+  homebrew_directory="/usr/local/Homebrew"
+  cd /usr/local
+fi
+
+# create missing directories
+mkdir -vp Caskroom Cellar Frameworks etc include lib opt sbin share var/homebrew/linked
+
+# optionally define an install user at /var/tmp/.homebrew_pkg_user.plist
+homebrew_pkg_user_plist="/var/tmp/.homebrew_pkg_user.plist"
+if [[ -f "${homebrew_pkg_user_plist}" ]] && [[ -n $(defaults read "${homebrew_pkg_user_plist}" HOMEBREW_PKG_USER) ]]
+then
+  homebrew_pkg_user=$(defaults read /var/tmp/.homebrew_pkg_user HOMEBREW_PKG_USER)
+# otherwise, get valid logged in user
+else
+  homebrew_pkg_user=$(echo "show State:/Users/ConsoleUser" | scutil | awk '/Name :/ { print $3 }')
+fi
+
+# set permissions
+chmod ug=rwx Caskroom Cellar Frameworks bin etc include lib opt sbin share var var/homebrew var/homebrew/linked
+if [[ "${homebrew_directory}" == "/usr/local/Homebrew" ]]
+then
+  chown -h "${homebrew_pkg_user}:admin" bin bin/brew etc include lib opt sbin share var
+  chown -h -R "${homebrew_pkg_user}:admin" Caskroom Cellar Frameworks Homebrew var/homebrew
+  chown -h -R "${homebrew_pkg_user}" etc include share var
+else
+  chown -R "${homebrew_pkg_user}:admin" .
+fi
+
+# move API cache to ~/Library/Caches/Homebrew
+user_home_dir=$(dscl . read /Users/"${homebrew_pkg_user}" NFSHomeDirectory | awk '{ print $2 }')
+user_cache_dir="${user_home_dir}/Library/Caches/Homebrew"
+user_api_cache_dir="${user_cache_dir}/api"
+mkdir -vp "${user_api_cache_dir}"
+mv -v "${homebrew_directory}/cache_api/"* "${user_api_cache_dir}"
+chown -R "${homebrew_pkg_user}:staff" "${user_cache_dir}"
+rm -vrf "${homebrew_directory}/cache_api"
diff --git a/package/scripts/preinstall b/package/scripts/preinstall
new file mode 100755
index 0000000000000..9e6baa06ce138
--- /dev/null
+++ b/package/scripts/preinstall
@@ -0,0 +1,17 @@
+#!/bin/bash
+set -euo pipefail
+
+homebrew_pkg_user_plist="/var/tmp/.homebrew_pkg_user.plist"
+if [[ -f "${homebrew_pkg_user_plist}" ]] && [[ -n $(defaults read "${homebrew_pkg_user_plist}" HOMEBREW_PKG_USER) ]]
+then
+  exit 0
+fi
+
+homebrew_pkg_user=$(echo "show State:/Users/ConsoleUser" | scutil | awk '/Name :/ { print $3 }')
+if [[ "${homebrew_pkg_user}" =~ _mbsetupuser|loginwindow|root ]] || [[ -z "${homebrew_pkg_user}" ]]
+then
+  echo "No valid user for Homebrew installation. Log in before install or specify an install user."
+  exit 1
+else
+  exit 0
+fi